Commit 515e410

nsxiv515e410

Use win_t member in img_t & tns_t instead of parameters

Author: Bert Münnich
Date: 2011-09-17 17:23 +0200
Parent: 82df0b3
Commit: 515e41045198074cc1b015c6296f536edbfedff5

+150 −135

7 files changed

Browse files Patch

−Context 3+

M Makefile +1 −1
M commands.c +14 −14
M image.c +80 −74
M image.h +19 −17
M main.c +6 −7
M thumbs.c +18 −13
M thumbs.h +12 −9

M Makefile View

M commands.c View

M image.c View

M image.h View

M main.c View

M thumbs.c View

M thumbs.h View

		@@ -1,4 +1,4 @@
1		−	VERSION = git-20110912
	1	+	VERSION = git-20110917
2	2
3	3		CC = gcc
4	4		CFLAGS = -Wall -pedantic -O2

		@@ -54,7 +54,7 @@ bool it_quit(arg_t a) {
54	54		bool it_switch_mode(arg_t a) {
55	55		if (mode == MODE_IMAGE) {
56	56		if (!tns.thumbs)
57		−	tns_init(&tns, filecnt);
	57	+	tns_init(&tns, filecnt, &win);
58	58		img_close(&img, false);
59	59		reset_timeout(reset_cursor);
60	60		if (img.slideshow) {
		@@ -180,16 +180,16 @@ bool it_move(arg_t a) {
180	180		direction_t dir = (direction_t) a;
181	181
182	182		if (mode == MODE_IMAGE)
183		−	return img_pan(&img, &win, dir, false);
	183	+	return img_pan(&img, dir, false);
184	184		else
185		−	return tns_move_selection(&tns, &win, dir);
	185	+	return tns_move_selection(&tns, dir);
186	186		}
187	187
188	188		bool i_pan_screen(arg_t a) {
189	189		direction_t dir = (direction_t) a;
190	190
191	191		if (mode == MODE_IMAGE)
192		−	return img_pan(&img, &win, dir, true);
	192	+	return img_pan(&img, dir, true);
193	193		else
194	194		return false;
195	195		}
		@@ -198,7 +198,7 @@ bool i_pan_edge(arg_t a) {
198	198		direction_t dir = (direction_t) a;
199	199
200	200		if (mode == MODE_IMAGE)
201		−	return img_pan_edge(&img, &win, dir);
	201	+	return img_pan_edge(&img, dir);
202	202		else
203	203		return false;
204	204		}
		@@ -245,8 +245,8 @@ bool i_drag(arg_t a) {
245	245		if (dragging)
246	246		next = XCheckIfEvent(win.env.dpy, &e, is_motionnotify, None);
247	247		if ((!dragging \|\| !next) && (dx != 0 \|\| dy != 0)) {
248		−	if (img_move(&img, &win, dx, dy))
249		−	img_render(&img, &win);
	248	+	if (img_move(&img, dx, dy))
	249	+	img_render(&img);
250	250		dx = dy = 0;
251	251		}
252	252		}
		@@ -265,19 +265,19 @@ bool i_zoom(arg_t a) {
265	265		return false;
266	266
267	267		if (scale > 0)
268		−	return img_zoom_in(&img, &win);
	268	+	return img_zoom_in(&img);
269	269		else if (scale < 0)
270		−	return img_zoom_out(&img, &win);
	270	+	return img_zoom_out(&img);
271	271		else
272		−	return img_zoom(&img, &win, 1.0);
	272	+	return img_zoom(&img, 1.0);
273	273		}
274	274
275	275		bool i_fit_to_win(arg_t a) {
276	276		bool ret;
277	277
278	278		if (mode == MODE_IMAGE) {
279		−	if ((ret = img_fit_win(&img, &win)))
280		−	img_center(&img, &win);
	279	+	if ((ret = img_fit_win(&img)))
	280	+	img_center(&img);
281	281		return ret;
282	282		} else {
283	283		return false;
		@@ -309,10 +309,10 @@ bool i_rotate(arg_t a) {
309	309
310	310		if (mode == MODE_IMAGE) {
311	311		if (dir == DIR_LEFT) {
312		−	img_rotate_left(&img, &win);
	312	+	img_rotate_left(&img);
313	313		return true;
314	314		} else if (dir == DIR_RIGHT) {
315		−	img_rotate_right(&img, &win);
	315	+	img_rotate_right(&img);
316	316		return true;
317	317		}
318	318		}

		@@ -39,10 +39,15 @@ typedef struct {
39	39
40	40		typedef struct {
41	41		Imlib_Image *im;
42		−	multi_img_t multi;
	42	+	int w;
	43	+	int h;
	44	+
	45	+	win_t *win;
	46	+	int x;
	47	+	int y;
43	48
44		−	float zoom;
45	49		scalemode_t scalemode;
	50	+	float zoom;
46	51
47	52		bool re;
48	53		bool checkpan;
		@@ -53,10 +58,7 @@ typedef struct {
53	58		bool slideshow;
54	59		int ss_delay; /* in ms */
55	60
56		−	int x;
57		−	int y;
58		−	int w;
59		−	int h;
	61	+	multi_img_t multi;
60	62		} img_t;
61	63
62	64		void img_init(img_t, win_t);
		@@ -64,21 +66,21 @@ void img_init(img_t, win_t);
64	66		bool img_load(img_t, const fileinfo_t);
65	67		void img_close(img_t*, bool);
66	68
67		−	void img_render(img_t, win_t);
	69	+	void img_render(img_t*);
68	70
69		−	bool img_fit_win(img_t, win_t);
70		−	bool img_center(img_t, win_t);
	71	+	bool img_fit_win(img_t*);
	72	+	bool img_center(img_t*);
71	73
72		−	bool img_zoom(img_t, win_t, float);
73		−	bool img_zoom_in(img_t, win_t);
74		−	bool img_zoom_out(img_t, win_t);
	74	+	bool img_zoom(img_t*, float);
	75	+	bool img_zoom_in(img_t*);
	76	+	bool img_zoom_out(img_t*);
75	77
76		−	bool img_move(img_t, win_t, int, int);
77		−	bool img_pan(img_t, win_t, direction_t, bool);
78		−	bool img_pan_edge(img_t, win_t, direction_t);
	78	+	bool img_move(img_t*, int, int);
	79	+	bool img_pan(img_t*, direction_t, bool);
	80	+	bool img_pan_edge(img_t*, direction_t);
79	81
80		−	void img_rotate_left(img_t, win_t);
81		−	void img_rotate_right(img_t, win_t);
	82	+	void img_rotate_left(img_t*);
	83	+	void img_rotate_right(img_t*);
82	84
83	85		void img_toggle_antialias(img_t*);
84	86

		@@ -261,7 +261,7 @@ void update_title() {
261	261
262	262		void redraw() {
263	263		if (mode == MODE_IMAGE) {
264		−	img_render(&img, &win);
	264	+	img_render(&img);
265	265		if (img.slideshow && !img.multi.animate) {
266	266		if (fileidx + 1 < filecnt)
267	267		set_timeout(slideshow, img.ss_delay, true);
		@@ -269,7 +269,7 @@ void redraw() {
269	269		img.slideshow = false;
270	270		}
271	271		} else {
272		−	tns_render(&tns, &win);
	272	+	tns_render(&tns);
273	273		}
274	274		update_title();
275	275		reset_timeout(redraw);
		@@ -372,8 +372,8 @@ void on_buttonpress(XButtonEvent *bev) {
372	372		set_timeout(reset_cursor, TO_CURSOR_HIDE, true);
373	373		load_image(tns.sel);
374	374		} else {
375		−	tns_highlight(&tns, &win, tns.sel, false);
376		−	tns_highlight(&tns, &win, sel, true);
	375	+	tns_highlight(&tns, tns.sel, false);
	376	+	tns_highlight(&tns, sel, true);
377	377		tns.sel = sel;
378	378		}
379	379		redraw();
		@@ -469,7 +469,7 @@ int main(int argc, char **argv) {
469	469		parse_options(argc, argv);
470	470
471	471		if (options->clean_cache) {
472		−	tns_init(&tns, 0);
	472	+	tns_init(&tns, 0, NULL);
473	473		tns_clean_cache(&tns);
474	474		exit(0);
475	475		}
		@@ -513,7 +513,6 @@ int main(int argc, char **argv) {
513	513		continue;
514	514		}
515	515		start = fileidx;
516		−	printf("reading dir: %s\n", filename);
517	516		while ((filename = r_readdir(&dir))) {
518	517		check_add_file(filename);
519	518		free((void*) filename);
		@@ -538,7 +537,7 @@ int main(int argc, char **argv) {
538	537
539	538		if (options->thumb_mode) {
540	539		mode = MODE_THUMB;
541		−	tns_init(&tns, filecnt);
	540	+	tns_init(&tns, filecnt, &win);
542	541		while (!tns_load(&tns, 0, &files[0], false, false))
543	542		remove_file(0, false);
544	543		tns.cnt = 1;

		@@ -156,7 +156,7 @@ void tns_clean_cache(tns_t *tns) {
156	156		}
157	157
158	158
159		−	void tns_init(tns_t *tns, int cnt) {
	159	+	void tns_init(tns_t tns, int cnt, win_t win) {
160	160		int len;
161	161		char *homedir;
162	162
		@@ -170,8 +170,9 @@ void tns_init(tns_t *tns, int cnt) {
170	170		tns->thumbs = NULL;
171	171		}
172	172
173		−	tns->cnt = tns->first = tns->sel = 0;
174	173		tns->cap = cnt;
	174	+	tns->cnt = tns->first = tns->sel = 0;
	175	+	tns->win = win;
175	176		tns->alpha = true;
176	177		tns->dirty = false;
177	178
		@@ -305,16 +306,17 @@ void tns_check_view(tns_t *tns, bool scrolled) {
305	306		}
306	307		}
307	308
308		−	void tns_render(tns_t tns, win_t win) {
309		−	int i, cnt, r, x, y;
	309	+	void tns_render(tns_t *tns) {
310	310		thumb_t *t;
	311	+	win_t *win;
	312	+	int i, cnt, r, x, y;
311	313
312		−	if (!tns \|\| !tns->thumbs \|\| !win)
	314	+	if (!tns \|\| !tns->thumbs \|\| !tns->win)
313	315		return;
314		−
315	316		if (!tns->dirty)
316	317		return;
317	318
	319	+	win = tns->win;
318	320		win_clear(win);
319	321		imlib_context_set_drawable(win->pm);
320	322
		@@ -357,17 +359,20 @@ void tns_render(tns_t tns, win_t win) {
357	359		}
358	360
359	361		tns->dirty = false;
360		−	tns_highlight(tns, win, tns->sel, true);
	362	+	tns_highlight(tns, tns->sel, true);
361	363		}
362	364
363		−	void tns_highlight(tns_t tns, win_t win, int n, bool hl) {
	365	+	void tns_highlight(tns_t *tns, int n, bool hl) {
364	366		thumb_t *t;
	367	+	win_t *win;
365	368		int x, y;
366	369		unsigned long col;
367	370
368		−	if (!tns \|\| !tns->thumbs \|\| !win)
	371	+	if (!tns \|\| !tns->thumbs \|\| !tns->win)
369	372		return;
370	373
	374	+	win = tns->win;
	375	+
371	376		if (n >= 0 && n < tns->cnt) {
372	377		t = &tns->thumbs[n];
373	378
		@@ -387,10 +392,10 @@ void tns_highlight(tns_t tns, win_t win, int n, bool hl) {
387	392		win_draw(win);
388	393		}
389	394
390		−	bool tns_move_selection(tns_t tns, win_t win, direction_t dir) {
	395	+	bool tns_move_selection(tns_t *tns, direction_t dir) {
391	396		int old;
392	397
393		−	if (!tns \|\| !tns->thumbs \|\| !win)
	398	+	if (!tns \|\| !tns->thumbs)
394	399		return false;
395	400
396	401		old = tns->sel;
		@@ -415,10 +420,10 @@ bool tns_move_selection(tns_t tns, win_t win, direction_t dir) {
415	420		}
416	421
417	422		if (tns->sel != old) {
418		−	tns_highlight(tns, win, old, false);
	423	+	tns_highlight(tns, old, false);
419	424		tns_check_view(tns, false);
420	425		if (!tns->dirty)
421		−	tns_highlight(tns, win, tns->sel, true);
	426	+	tns_highlight(tns, tns->sel, true);
422	427		}
423	428
424	429		return tns->sel != old;

		@@ -49,26 +49,26 @@ void img_init(img_t img, win_t win) {
49	49		zoom_min = zoom_levels[0] / 100.0;
50	50		zoom_max = zoom_levels[ARRLEN(zoom_levels) - 1] / 100.0;
51	51
52		−	if (img) {
53		−	img->im = NULL;
54		−	img->multi.cap = img->multi.cnt = 0;
55		−	img->multi.animate = false;
56		−	img->zoom = options->zoom;
57		−	img->zoom = MAX(img->zoom, zoom_min);
58		−	img->zoom = MIN(img->zoom, zoom_max);
59		−	img->checkpan = false;
60		−	img->dirty = false;
61		−	img->aa = options->aa;
62		−	img->alpha = true;
63		−	img->slideshow = false;
64		−	img->ss_delay = SLIDESHOW_DELAY * 1000;
65		−	}
	52	+	if (!img \|\| !win)
	53	+	return;
66	54
67		−	if (win) {
68		−	imlib_context_set_display(win->env.dpy);
69		−	imlib_context_set_visual(win->env.vis);
70		−	imlib_context_set_colormap(win->env.cmap);
71		−	}
	55	+	imlib_context_set_display(win->env.dpy);
	56	+	imlib_context_set_visual(win->env.vis);
	57	+	imlib_context_set_colormap(win->env.cmap);
	58	+
	59	+	img->im = NULL;
	60	+	img->win = win;
	61	+	img->zoom = options->zoom;
	62	+	img->zoom = MAX(img->zoom, zoom_min);
	63	+	img->zoom = MIN(img->zoom, zoom_max);
	64	+	img->checkpan = false;
	65	+	img->dirty = false;
	66	+	img->aa = options->aa;
	67	+	img->alpha = true;
	68	+	img->slideshow = false;
	69	+	img->ss_delay = SLIDESHOW_DELAY * 1000;
	70	+	img->multi.cap = img->multi.cnt = 0;
	71	+	img->multi.animate = false;
72	72		}
73	73
74	74		#if EXIF_SUPPORT
		@@ -311,14 +311,13 @@ bool img_load(img_t img, const fileinfo_t file) {
311	311		img_load_gif(img, file);
312	312		#endif
313	313
	314	+	img->w = imlib_image_get_width();
	315	+	img->h = imlib_image_get_height();
314	316		img->scalemode = options->scalemode;
315	317		img->re = false;
316	318		img->checkpan = false;
317	319		img->dirty = true;
318	320
319		−	img->w = imlib_image_get_width();
320		−	img->h = imlib_image_get_height();
321		−
322	321		return true;
323	322		}
324	323
		@@ -345,12 +344,14 @@ void img_close(img_t *img, bool decache) {
345	344		}
346	345		}
347	346
348		−	void img_check_pan(img_t img, win_t win, bool moved) {
	347	+	void img_check_pan(img_t *img, bool moved) {
	348	+	win_t *win;
349	349		int ox, oy;
350	350
351		−	if (!img \|\| !win)
	351	+	if (!img \|\| !img->im \|\| !img->win)
352	352		return;
353	353
	354	+	win = img->win;
354	355		ox = img->x;
355	356		oy = img->y;
356	357
		@@ -375,15 +376,17 @@ void img_check_pan(img_t img, win_t win, bool moved) {
375	376		img->dirty = true;
376	377		}
377	378
378		−	bool img_fit(img_t img, win_t win) {
	379	+	bool img_fit(img_t *img) {
379	380		float z, zmax, zw, zh;
380	381
381		−	if (!img \|\| !win \|\| img->scalemode == SCALE_ZOOM)
	382	+	if (!img \|\| !img->im \|\| !img->win)
	383	+	return false;
	384	+	if (img->scalemode == SCALE_ZOOM)
382	385		return false;
383	386
384	387		zmax = img->scalemode == SCALE_DOWN ? 1.0 : zoom_max;
385		−	zw = (float) win->w / (float) img->w;
386		−	zh = (float) win->h / (float) img->h;
	388	+	zw = (float) img->win->w / (float) img->w;
	389	+	zh = (float) img->win->h / (float) img->h;
387	390
388	391		z = MIN(zw, zh);
389	392		z = MAX(z, zoom_min);
		@@ -398,14 +401,16 @@ bool img_fit(img_t img, win_t win) {
398	401		}
399	402		}
400	403
401		−	void img_render(img_t img, win_t win) {
	404	+	void img_render(img_t *img) {
	405	+	win_t *win;
402	406		int sx, sy, sw, sh;
403	407		int dx, dy, dw, dh;
404	408
405		−	if (!img \|\| !img->im \|\| !win)
	409	+	if (!img \|\| !img->im \|\| !img->win)
406	410		return;
407	411
408		−	img_fit(img, win);
	412	+	win = img->win;
	413	+	img_fit(img);
409	414
410	415		if (!img->re) {
411	416		/* rendered for the first time */
		@@ -421,7 +426,7 @@ void img_render(img_t img, win_t win) {
421	426		}
422	427
423	428		if (img->checkpan) {
424		−	img_check_pan(img, win, false);
	429	+	img_check_pan(img, false);
425	430		img->checkpan = false;
426	431		}
427	432
		@@ -467,25 +472,25 @@ void img_render(img_t img, win_t win) {
467	472		img->dirty = false;
468	473		}
469	474
470		−	bool img_fit_win(img_t img, win_t win) {
471		−	if (!img \|\| !img->im \|\| !win)
	475	+	bool img_fit_win(img_t *img) {
	476	+	if (!img \|\| !img->im)
472	477		return false;
473	478
474	479		img->scalemode = SCALE_FIT;
475		−	return img_fit(img, win);
	480	+	return img_fit(img);
476	481		}
477	482
478		−	bool img_center(img_t img, win_t win) {
	483	+	bool img_center(img_t *img) {
479	484		int ox, oy;
480	485
481		−	if (!img \|\| !win)
	486	+	if (!img \|\| !img->im \|\| !img->win)
482	487		return false;
483	488
484	489		ox = img->x;
485	490		oy = img->y;
486	491
487		−	img->x = (win->w - img->w * img->zoom) / 2;
488		−	img->y = (win->h - img->h * img->zoom) / 2;
	492	+	img->x = (img->win->w - img->w * img->zoom) / 2;
	493	+	img->y = (img->win->h - img->h * img->zoom) / 2;
489	494
490	495		if (ox != img->x \|\| oy != img->y) {
491	496		img->dirty = true;
		@@ -495,8 +500,8 @@ bool img_center(img_t img, win_t win) {
495	500		}
496	501		}
497	502
498		−	bool img_zoom(img_t img, win_t win, float z) {
499		−	if (!img \|\| !img->im \|\| !win)
	503	+	bool img_zoom(img_t *img, float z) {
	504	+	if (!img \|\| !img->im \|\| !img->win)
500	505		return false;
501	506
502	507		z = MAX(z, zoom_min);
		@@ -505,8 +510,8 @@ bool img_zoom(img_t img, win_t win, float z) {
505	510		img->scalemode = SCALE_ZOOM;
506	511
507	512		if (ZOOMDIFF(z, img->zoom)) {
508		−	img->x = win->w / 2 - (win->w / 2 - img->x) * z / img->zoom;
509		−	img->y = win->h / 2 - (win->h / 2 - img->y) * z / img->zoom;
	513	+	img->x = img->win->w / 2 - (img->win->w / 2 - img->x) * z / img->zoom;
	514	+	img->y = img->win->h / 2 - (img->win->h / 2 - img->y) * z / img->zoom;
510	515		img->zoom = z;
511	516		img->checkpan = true;
512	517		img->dirty = true;
		@@ -516,36 +521,36 @@ bool img_zoom(img_t img, win_t win, float z) {
516	521		}
517	522		}
518	523
519		−	bool img_zoom_in(img_t img, win_t win) {
	524	+	bool img_zoom_in(img_t *img) {
520	525		int i;
521	526
522		−	if (!img \|\| !img->im \|\| !win)
	527	+	if (!img \|\| !img->im)
523	528		return false;
524	529
525	530		for (i = 1; i < ARRLEN(zoom_levels); i++) {
526	531		if (zoom_levels[i] > img->zoom * 100.0)
527		−	return img_zoom(img, win, zoom_levels[i] / 100.0);
	532	+	return img_zoom(img, zoom_levels[i] / 100.0);
528	533		}
529	534		return false;
530	535		}
531	536
532		−	bool img_zoom_out(img_t img, win_t win) {
	537	+	bool img_zoom_out(img_t *img) {
533	538		int i;
534	539
535		−	if (!img \|\| !img->im \|\| !win)
	540	+	if (!img \|\| !img->im)
536	541		return false;
537	542
538	543		for (i = ARRLEN(zoom_levels) - 2; i >= 0; i--) {
539	544		if (zoom_levels[i] < img->zoom * 100.0)
540		−	return img_zoom(img, win, zoom_levels[i] / 100.0);
	545	+	return img_zoom(img, zoom_levels[i] / 100.0);
541	546		}
542	547		return false;
543	548		}
544	549
545		−	bool img_move(img_t img, win_t win, int dx, int dy) {
	550	+	bool img_move(img_t *img, int dx, int dy) {
546	551		int ox, oy;
547	552
548		−	if (!img \|\| !img->im \|\| !win)
	553	+	if (!img \|\| !img->im)
549	554		return false;
550	555
551	556		ox = img->x;
		@@ -554,7 +559,7 @@ bool img_move(img_t img, win_t win, int dx, int dy) {
554	559		img->x += dx;
555	560		img->y += dy;
556	561
557		−	img_check_pan(img, win, true);
	562	+	img_check_pan(img, true);
558	563
559	564		if (ox != img->x \|\| oy != img->y) {
560	565		img->dirty = true;
		@@ -564,27 +569,27 @@ bool img_move(img_t img, win_t win, int dx, int dy) {
564	569		}
565	570		}
566	571
567		−	bool img_pan(img_t img, win_t win, direction_t dir, bool screen) {
568		−	if (!img \|\| !img->im \|\| !win)
	572	+	bool img_pan(img_t *img, direction_t dir, bool screen) {
	573	+	if (!img \|\| !img->im \|\| !img->win)
569	574		return false;
570	575
571	576		switch (dir) {
572	577		case DIR_LEFT:
573		−	return img_move(img, win, win->w / (screen ? 1 : 5), 0);
	578	+	return img_move(img, img->win->w / (screen ? 1 : 5), 0);
574	579		case DIR_RIGHT:
575		−	return img_move(img, win, win->w / (screen ? 1 : 5) * -1, 0);
	580	+	return img_move(img, img->win->w / (screen ? 1 : 5) * -1, 0);
576	581		case DIR_UP:
577		−	return img_move(img, win, 0, win->h / (screen ? 1 : 5));
	582	+	return img_move(img, 0, img->win->h / (screen ? 1 : 5));
578	583		case DIR_DOWN:
579		−	return img_move(img, win, 0, win->h / (screen ? 1 : 5) * -1);
	584	+	return img_move(img, 0, img->win->h / (screen ? 1 : 5) * -1);
580	585		}
581	586		return false;
582	587		}
583	588
584		−	bool img_pan_edge(img_t img, win_t win, direction_t dir) {
	589	+	bool img_pan_edge(img_t *img, direction_t dir) {
585	590		int ox, oy;
586	591
587		−	if (!img \|\| !img->im \|\| !win)
	592	+	if (!img \|\| !img->im \|\| !img->win)
588	593		return false;
589	594
590	595		ox = img->x;
		@@ -595,17 +600,17 @@ bool img_pan_edge(img_t img, win_t win, direction_t dir) {
595	600		img->x = 0;
596	601		break;
597	602		case DIR_RIGHT:
598		−	img->x = win->w - img->w * img->zoom;
	603	+	img->x = img->win->w - img->w * img->zoom;
599	604		break;
600	605		case DIR_UP:
601	606		img->y = 0;
602	607		break;
603	608		case DIR_DOWN:
604		−	img->y = win->h - img->h * img->zoom;
	609	+	img->y = img->win->h - img->h * img->zoom;
605	610		break;
606	611		}
607	612
608		−	img_check_pan(img, win, true);
	613	+	img_check_pan(img, true);
609	614
610	615		if (ox != img->x \|\| oy != img->y) {
611	616		img->dirty = true;
		@@ -615,12 +620,14 @@ bool img_pan_edge(img_t img, win_t win, direction_t dir) {
615	620		}
616	621		}
617	622
618		−	void img_rotate(img_t img, win_t win, int d) {
	623	+	void img_rotate(img_t *img, int d) {
	624	+	win_t *win;
619	625		int ox, oy, tmp;
620	626
621		−	if (!img \|\| !img->im \|\| !win)
	627	+	if (!img \|\| !img->im \|\| !img->win)
622	628		return;
623	629
	630	+	win = img->win;
624	631		ox = d == 1 ? img->x : win->w - img->x - img->w * img->zoom;
625	632		oy = d == 3 ? img->y : win->h - img->y - img->h * img->zoom;
626	633
		@@ -638,12 +645,12 @@ void img_rotate(img_t img, win_t win, int d) {
638	645		img->dirty = true;
639	646		}
640	647
641		−	void img_rotate_left(img_t img, win_t win) {
642		−	img_rotate(img, win, 3);
	648	+	void img_rotate_left(img_t *img) {
	649	+	img_rotate(img, 3);
643	650		}
644	651
645		−	void img_rotate_right(img_t img, win_t win) {
646		−	img_rotate(img, win, 1);
	652	+	void img_rotate_right(img_t *img) {
	653	+	img_rotate(img, 1);
647	654		}
648	655
649	656		void img_toggle_antialias(img_t *img) {
		@@ -657,10 +664,9 @@ void img_toggle_antialias(img_t *img) {
657	664		}
658	665
659	666		bool img_frame_goto(img_t *img, int n) {
660		−	if (!img \|\| n < 0 \|\| n >= img->multi.cnt)
	667	+	if (!img \|\| !img->im)
661	668		return false;
662		−
663		−	if (n == img->multi.sel)
	669	+	if (n < 0 \|\| n >= img->multi.cnt \|\| n == img->multi.sel)
664	670		return false;
665	671
666	672		img->multi.sel = n;
		@@ -676,7 +682,7 @@ bool img_frame_goto(img_t *img, int n) {
676	682		}
677	683
678	684		bool img_frame_navigate(img_t *img, int d) {
679		−	if (!img \|\| !img->multi.cnt \|\| !d)
	685	+	if (!img \|\| !img->im \|\| !img->multi.cnt \|\| !d)
680	686		return false;
681	687
682	688		d += img->multi.sel;
		@@ -689,7 +695,7 @@ bool img_frame_navigate(img_t *img, int d) {
689	695		}
690	696
691	697		bool img_frame_animate(img_t *img, bool restart) {
692		−	if (!img \|\| !img->multi.cnt)
	698	+	if (!img \|\| !img->im \|\| !img->multi.cnt)
693	699		return false;
694	700
695	701		if (img->multi.sel + 1 >= img->multi.cnt) {

		@@ -26,39 +26,42 @@
26	26		#include "window.h"
27	27
28	28		typedef struct {
29		−	Imlib_Image *im;
30	29		const fileinfo_t *file;
31		−	int x;
32		−	int y;
	30	+	Imlib_Image *im;
33	31		int w;
34	32		int h;
	33	+	int x;
	34	+	int y;
35	35		} thumb_t;
36	36
37	37		typedef struct {
38	38		thumb_t *thumbs;
39	39		int cap;
40	40		int cnt;
	41	+	int first;
	42	+	int sel;
	43	+
	44	+	win_t *win;
41	45		int x;
42	46		int y;
43	47		int cols;
44	48		int rows;
45		−	int first;
46		−	int sel;
	49	+
47	50		bool alpha;
48	51		bool dirty;
49	52		} tns_t;
50	53
51	54		void tns_clean_cache(tns_t*);
52	55
53		−	void tns_init(tns_t*, int);
	56	+	void tns_init(tns_t, int, win_t);
54	57		void tns_free(tns_t*);
55	58
56	59		bool tns_load(tns_t, int, const fileinfo_t, bool, bool);
57	60
58		−	void tns_render(tns_t, win_t);
59		−	void tns_highlight(tns_t, win_t, int, bool);
	61	+	void tns_render(tns_t*);
	62	+	void tns_highlight(tns_t*, int, bool);
60	63
61		−	bool tns_move_selection(tns_t, win_t, direction_t);
	64	+	bool tns_move_selection(tns_t*, direction_t);
62	65		bool tns_scroll(tns_t*, direction_t);
63	66
64	67		int tns_translate(tns_t*, int, int);

nsxiv/515e410

Use win_t member in img_t & tns_t instead of parameters

nsxiv515e410