Krolyxon
Commit b2a2a62

Branches

Refs →

nsxivb2a2a62

Added own bool type

Author
Bert
Date
2011-09-11 21:01 +0200
Parent
e2d4b9c
Commit
b2a2a62b7b8a066467d7e8ef520fef7c17e3c5ca

+454 −452

13 files changed

Browse files Patch
−Context 3+
  1. M commands.c +107 −109
  2. M commands.h +30 −28
  3. M config.def.h +77 −77
  4. M image.c +85 −84
  5. M image.h +19 −19
  6. M main.c +41 −44
  7. M options.c +16 −17
  8. M options.h +8 −8
  9. M thumbs.c +40 −39
  10. M thumbs.h +6 −6
  11. M types.h +6 −1
  12. M window.c +14 −15
  13. M window.h +5 −5
M commands.c View
@@ -26,17 +26,16 @@
2626 #include "commands.h"
2727 #include "image.h"
2828 #include "thumbs.h"
29−#include "types.h"
3029 #include "util.h"
3130
3231 void cleanup();
33−void remove_file(int, unsigned char);
32+void remove_file(int, bool);
3433 void load_image(int);
3534 void redraw();
3635 void reset_cursor();
3736 void animate();
3837 void slideshow();
39−void set_timeout(timeout_f, int, int);
38+void set_timeout(timeout_f, int, bool);
4039 void reset_timeout(timeout_f);
4140
4241 extern appmode_t mode;
@@ -47,73 +46,73 @@ extern win_t win;
4746 extern fileinfo_t *files;
4847 extern int filecnt, fileidx;
4948
50−int it_quit(arg_t a) {
49+bool it_quit(arg_t a) {
5150 cleanup();
5251 exit(0);
5352 }
5453
55−int it_switch_mode(arg_t a) {
54+bool it_switch_mode(arg_t a) {
5655 if (mode == MODE_IMAGE) {
5756 if (!tns.thumbs)
5857 tns_init(&tns, filecnt);
59− img_close(&img, 0);
58+ img_close(&img, false);
6059 reset_timeout(reset_cursor);
6160 if (img.slideshow) {
62− img.slideshow = 0;
61+ img.slideshow = false;
6362 reset_timeout(slideshow);
6463 }
6564 tns.sel = fileidx;
66− tns.dirty = 1;
65+ tns.dirty = true;
6766 mode = MODE_THUMB;
6867 } else {
6968 load_image(tns.sel);
7069 mode = MODE_IMAGE;
7170 }
72− return 1;
71+ return true;
7372 }
7473
75−int it_toggle_fullscreen(arg_t a) {
74+bool it_toggle_fullscreen(arg_t a) {
7675 win_toggle_fullscreen(&win);
77− set_timeout(redraw, TO_REDRAW_RESIZE, 0);
76+ set_timeout(redraw, TO_REDRAW_RESIZE, false);
7877 if (mode == MODE_IMAGE)
79− img.checkpan = 1;
78+ img.checkpan = true;
8079 else
81− tns.dirty = 1;
82− return 0;
80+ tns.dirty = true;
81+ return false;
8382 }
8483
85−int it_reload_image(arg_t a) {
84+bool it_reload_image(arg_t a) {
8685 if (mode == MODE_IMAGE) {
8786 load_image(fileidx);
8887 } else {
8988 win_set_cursor(&win, CURSOR_WATCH);
90− if (!tns_load(&tns, tns.sel, &files[tns.sel], True, False)) {
91− remove_file(tns.sel, 0);
92− tns.dirty = 1;
89+ if (!tns_load(&tns, tns.sel, &files[tns.sel], true, false)) {
90+ remove_file(tns.sel, false);
91+ tns.dirty = true;
9392 if (tns.sel >= tns.cnt)
9493 tns.sel = tns.cnt - 1;
9594 }
9695 }
97− return 1;
96+ return true;
9897 }
9998
100−int it_remove_image(arg_t a) {
99+bool it_remove_image(arg_t a) {
101100 if (mode == MODE_IMAGE) {
102− remove_file(fileidx, 1);
101+ remove_file(fileidx, true);
103102 load_image(fileidx >= filecnt ? filecnt - 1 : fileidx);
104− return 1;
103+ return true;
105104 } else if (tns.sel < tns.cnt) {
106− remove_file(tns.sel, 1);
107− tns.dirty = 1;
105+ remove_file(tns.sel, true);
106+ tns.dirty = true;
108107 if (tns.sel >= tns.cnt)
109108 tns.sel = tns.cnt - 1;
110− return 1;
109+ return true;
111110 } else {
112− return 0;
111+ return false;
113112 }
114113 }
115114
116−int i_navigate(arg_t a) {
115+bool i_navigate(arg_t a) {
117116 long n = (long) a;
118117
119118 if (mode == MODE_IMAGE) {
@@ -125,86 +124,83 @@ int i_navigate(arg_t a) {
125124
126125 if (n != fileidx) {
127126 load_image(n);
128− return 1;
127+ return true;
129128 }
130129 }
131− return 0;
130+ return false;
132131 }
133132
134−int it_first(arg_t a) {
133+bool it_first(arg_t a) {
135134 if (mode == MODE_IMAGE && fileidx != 0) {
136135 load_image(0);
137− return 1;
136+ return true;
138137 } else if (mode == MODE_THUMB && tns.sel != 0) {
139138 tns.sel = 0;
140− tns.dirty = 1;
141− return 1;
139+ tns.dirty = true;
140+ return true;
142141 } else {
143− return 0;
142+ return false;
144143 }
145144 }
146145
147−int it_last(arg_t a) {
146+bool it_last(arg_t a) {
148147 if (mode == MODE_IMAGE && fileidx != filecnt - 1) {
149148 load_image(filecnt - 1);
150− return 1;
149+ return true;
151150 } else if (mode == MODE_THUMB && tns.sel != tns.cnt - 1) {
152151 tns.sel = tns.cnt - 1;
153− tns.dirty = 1;
154− return 1;
152+ tns.dirty = true;
153+ return true;
155154 } else {
156− return 0;
155+ return false;
157156 }
158157 }
159158
160−int i_navigate_frame(arg_t a) {
159+bool i_navigate_frame(arg_t a) {
161160 if (mode == MODE_IMAGE && !img.multi.animate)
162161 return img_frame_navigate(&img, (long) a);
163162 else
164− return 0;
163+ return false;
165164 }
166165
167−int i_toggle_animation(arg_t a) {
168− int delay;
169−
166+bool i_toggle_animation(arg_t a) {
170167 if (mode != MODE_IMAGE)
171− return 0;
168+ return false;
172169
173170 if (img.multi.animate) {
174171 reset_timeout(animate);
175− img.multi.animate = 0;
176− } else {
177− delay = img_frame_animate(&img, 1);
178− set_timeout(animate, delay, 1);
172+ img.multi.animate = false;
173+ } else if (img_frame_animate(&img, true)) {
174+ set_timeout(animate, img.multi.frames[img.multi.sel].delay, true);
179175 }
180− return 1;
176+ return true;
181177 }
182178
183−int it_move(arg_t a) {
179+bool it_move(arg_t a) {
184180 direction_t dir = (direction_t) a;
185181
186182 if (mode == MODE_IMAGE)
187− return img_pan(&img, &win, dir, 0);
183+ return img_pan(&img, &win, dir, false);
188184 else
189185 return tns_move_selection(&tns, &win, dir);
190186 }
191187
192−int i_pan_screen(arg_t a) {
188+bool i_pan_screen(arg_t a) {
193189 direction_t dir = (direction_t) a;
194190
195191 if (mode == MODE_IMAGE)
196− return img_pan(&img, &win, dir, 1);
192+ return img_pan(&img, &win, dir, true);
197193 else
198− return 0;
194+ return false;
199195 }
200196
201−int i_pan_edge(arg_t a) {
197+bool i_pan_edge(arg_t a) {
202198 direction_t dir = (direction_t) a;
203199
204200 if (mode == MODE_IMAGE)
205201 return img_pan_edge(&img, &win, dir);
206202 else
207− return 0;
203+ return false;
208204 }
209205
210206 /* Xlib helper function for i_drag() */
@@ -212,17 +208,17 @@ Bool is_motionnotify(Display *d, XEvent *e, XPointer a) {
212208 return e != NULL && e->type == MotionNotify;
213209 }
214210
215−int i_drag(arg_t a) {
211+bool i_drag(arg_t a) {
216212 int dx = 0, dy = 0, i, ox, oy, x, y;
217213 unsigned int ui;
218− Bool dragging = True, next = False;
214+ bool dragging = true, next = false;
219215 XEvent e;
220216 Window w;
221217
222218 if (mode != MODE_IMAGE)
223− return 0;
219+ return false;
224220 if (!XQueryPointer(win.env.dpy, win.xwin, &w, &w, &i, &i, &ox, &oy, &ui))
225− return 0;
221+ return false;
226222
227223 win_set_cursor(&win, CURSOR_HAND);
228224
@@ -233,7 +229,7 @@ int i_drag(arg_t a) {
233229 switch (e.type) {
234230 case ButtonPress:
235231 case ButtonRelease:
236− dragging = False;
232+ dragging = false;
237233 break;
238234 case MotionNotify:
239235 x = e.xmotion.x;
@@ -256,17 +252,17 @@ int i_drag(arg_t a) {
256252 }
257253
258254 win_set_cursor(&win, CURSOR_ARROW);
259− set_timeout(reset_cursor, TO_CURSOR_HIDE, 1);
255+ set_timeout(reset_cursor, TO_CURSOR_HIDE, true);
260256 reset_timeout(redraw);
261257
262− return 0;
258+ return false;
263259 }
264260
265−int i_zoom(arg_t a) {
261+bool i_zoom(arg_t a) {
266262 long scale = (long) a;
267263
268264 if (mode != MODE_IMAGE)
269− return 0;
265+ return false;
270266
271267 if (scale > 0)
272268 return img_zoom_in(&img, &win);
@@ -276,21 +272,22 @@ int i_zoom(arg_t a) {
276272 return img_zoom(&img, &win, 1.0);
277273 }
278274
279−int i_fit_to_win(arg_t a) {
280− int ret;
275+bool i_fit_to_win(arg_t a) {
276+ bool ret;
281277
282278 if (mode == MODE_IMAGE) {
283279 if ((ret = img_fit_win(&img, &win)))
284280 img_center(&img, &win);
285281 return ret;
286282 } else {
287− return 0;
283+ return false;
288284 }
289285 }
290286
291−int i_fit_to_img(arg_t a) {
292− int ret, x, y;
287+bool i_fit_to_img(arg_t a) {
288+ int x, y;
293289 unsigned int w, h;
290+ bool ret;
294291
295292 if (mode == MODE_IMAGE) {
296293 x = MAX(0, win.x + img.x);
@@ -303,90 +300,91 @@ int i_fit_to_img(arg_t a) {
303300 }
304301 return ret;
305302 } else {
306− return 0;
303+ return false;
307304 }
308305 }
309306
310−int i_rotate(arg_t a) {
307+bool i_rotate(arg_t a) {
311308 direction_t dir = (direction_t) a;
312309
313310 if (mode == MODE_IMAGE) {
314311 if (dir == DIR_LEFT) {
315312 img_rotate_left(&img, &win);
316− return 1;
313+ return true;
317314 } else if (dir == DIR_RIGHT) {
318315 img_rotate_right(&img, &win);
319− return 1;
316+ return true;
320317 }
321318 }
322− return 0;
319+ return false;
323320 }
324321
325−int i_toggle_slideshow(arg_t a) {
322+bool i_toggle_slideshow(arg_t a) {
326323 if (mode == MODE_IMAGE) {
327324 if (img.slideshow) {
328− img.slideshow = 0;
325+ img.slideshow = false;
329326 reset_timeout(slideshow);
330− return 1;
327+ return true;
331328 } else if (fileidx + 1 < filecnt) {
332− img.slideshow = 1;
333− set_timeout(slideshow, img.ss_delay, 1);
334− return 1;
329+ img.slideshow = true;
330+ set_timeout(slideshow, img.ss_delay, true);
331+ return true;
335332 }
336333 }
337− return 0;
334+ return false;
338335 }
339336
340−int i_adjust_slideshow(arg_t a) {
337+bool i_adjust_slideshow(arg_t a) {
341338 long d = (long) a;
342339 int i, delays[] = { 1, 2, 3, 5, 10, 15, 20, 30, 60, 120, 180, 300, 600 };
343340
344341 if (mode != MODE_IMAGE || !img.slideshow)
345− return 0;
342+ return false;
346343
347344 if (d < 0) {
348345 for (i = ARRLEN(delays) - 2; i >= 0; i--) {
349346 if (img.ss_delay > delays[i] * 1000) {
350347 img.ss_delay = delays[i] * 1000;
351− return 1;
348+ return true;
352349 }
353350 }
354351 } else {
355352 for (i = 1; i < ARRLEN(delays); i++) {
356353 if (img.ss_delay < delays[i] * 1000) {
357354 img.ss_delay = delays[i] * 1000;
358− return 1;
355+ return true;
359356 }
360357 }
361358 }
362− return 0;
359+ return false;
363360 }
364361
365−int i_toggle_antialias(arg_t a) {
362+bool i_toggle_antialias(arg_t a) {
366363 if (mode == MODE_IMAGE) {
367364 img_toggle_antialias(&img);
368− return 1;
365+ return true;
369366 } else {
370− return 0;
367+ return false;
371368 }
372369 }
373370
374−int it_toggle_alpha(arg_t a) {
375− img.alpha ^= 1;
376− tns.alpha = img.alpha;
377− if (mode == MODE_THUMB)
378− tns.dirty = 1;
379− return 1;
371+bool it_toggle_alpha(arg_t a) {
372+ img.alpha = tns.alpha = !img.alpha;
373+ if (mode == MODE_IMAGE)
374+ img.dirty = true;
375+ else
376+ tns.dirty = true;
377+ return true;
380378 }
381379
382−int it_open_with(arg_t a) {
380+bool it_open_with(arg_t a) {
383381 const char *prog = (const char*) a;
384382 pid_t pid;
385383
386384 if (!prog || !*prog)
387− return 0;
385+ return false;
388386
389− if((pid = fork()) == 0) {
387+ if ((pid = fork()) == 0) {
390388 execlp(prog, prog,
391389 files[mode == MODE_IMAGE ? fileidx : tns.sel].path, NULL);
392390 warn("could not exec: %s", prog);
@@ -395,10 +393,10 @@ int it_open_with(arg_t a) {
395393 warn("could not fork. program was: %s", prog);
396394 }
397395
398− return 0;
396+ return false;
399397 }
400398
401−int it_shell_cmd(arg_t a) {
399+bool it_shell_cmd(arg_t a) {
402400 int n, status;
403401 const char *cmdline = (const char*) a;
404402 pid_t pid;
@@ -411,7 +409,7 @@ int it_shell_cmd(arg_t a) {
411409 if (setenv("SXIV_IMG", files[n].path, 1) < 0) {
412410 warn("could not set env.-variable: SXIV_IMG. command line was: %s",
413411 cmdline);
414− return 0;
412+ return false;
415413 }
416414
417415 if ((pid = fork()) == 0) {
@@ -420,7 +418,7 @@ int it_shell_cmd(arg_t a) {
420418 exit(1);
421419 } else if (pid < 0) {
422420 warn("could not fork. command line was: %s", cmdline);
423− return 0;
421+ return false;
424422 }
425423
426424 win_set_cursor(&win, CURSOR_WATCH);
@@ -431,17 +429,17 @@ int it_shell_cmd(arg_t a) {
431429 WEXITSTATUS(status), cmdline);
432430
433431 if (mode == MODE_IMAGE) {
434− img_close(&img, 1);
432+ img_close(&img, true);
435433 load_image(fileidx);
436434 }
437− if (!tns_load(&tns, n, &files[n], True, mode == MODE_IMAGE) &&
435+ if (!tns_load(&tns, n, &files[n], true, mode == MODE_IMAGE) &&
438436 mode == MODE_THUMB)
439437 {
440− remove_file(tns.sel, 0);
441− tns.dirty = 1;
438+ remove_file(tns.sel, false);
439+ tns.dirty = true;
442440 if (tns.sel >= tns.cnt)
443441 tns.sel = tns.cnt - 1;
444442 }
445443
446− return 1;
444+ return true;
447445 }
M commands.h View
@@ -21,47 +21,49 @@
2121
2222 #include <X11/Xlib.h>
2323
24+#include "types.h"
25+
2426 typedef void* arg_t;
25−typedef int (*command_f)(arg_t);
27+typedef bool (*command_f)(arg_t);
2628
2729 typedef struct {
28− Bool ctrl;
30+ bool ctrl;
2931 KeySym ksym;
3032 command_f cmd;
3133 arg_t arg;
3234 } keymap_t;
3335
3436 typedef struct {
35− Bool ctrl;
36− Bool shift;
37+ bool ctrl;
38+ bool shift;
3739 unsigned int button;
3840 command_f cmd;
3941 arg_t arg;
4042 } button_t;
4143
42−int it_quit(arg_t);
43−int it_switch_mode(arg_t);
44−int it_toggle_fullscreen(arg_t);
45−int it_reload_image(arg_t);
46−int it_remove_image(arg_t);
47−int i_navigate(arg_t);
48−int it_first(arg_t);
49−int it_last(arg_t);
50−int i_navigate_frame(arg_t);
51−int i_toggle_animation(arg_t);
52−int it_move(arg_t);
53−int i_pan_screen(arg_t);
54−int i_pan_edge(arg_t);
55−int i_drag(arg_t);
56−int i_zoom(arg_t);
57−int i_fit_to_win(arg_t);
58−int i_fit_to_img(arg_t);
59−int i_rotate(arg_t);
60−int i_toggle_slideshow(arg_t);
61−int i_adjust_slideshow(arg_t);
62−int i_toggle_antialias(arg_t);
63−int it_toggle_alpha(arg_t);
64−int it_open_with(arg_t);
65−int it_shell_cmd(arg_t);
44+bool it_quit(arg_t);
45+bool it_switch_mode(arg_t);
46+bool it_toggle_fullscreen(arg_t);
47+bool it_reload_image(arg_t);
48+bool it_remove_image(arg_t);
49+bool i_navigate(arg_t);
50+bool it_first(arg_t);
51+bool it_last(arg_t);
52+bool i_navigate_frame(arg_t);
53+bool i_toggle_animation(arg_t);
54+bool it_move(arg_t);
55+bool i_pan_screen(arg_t);
56+bool i_pan_edge(arg_t);
57+bool i_drag(arg_t);
58+bool i_zoom(arg_t);
59+bool i_fit_to_win(arg_t);
60+bool i_fit_to_img(arg_t);
61+bool i_rotate(arg_t);
62+bool i_toggle_slideshow(arg_t);
63+bool i_adjust_slideshow(arg_t);
64+bool i_toggle_antialias(arg_t);
65+bool it_toggle_alpha(arg_t);
66+bool it_open_with(arg_t);
67+bool it_shell_cmd(arg_t);
6668
6769 #endif /* COMMANDS_H */
M config.def.h View
@@ -51,96 +51,96 @@ enum { THUMB_SIZE = 60 };
5151 /* keyboard mappings for image and thumbnail mode: */
5252 static const keymap_t keys[] = {
5353 /* ctrl key function argument */
54− { False, XK_q, it_quit, (arg_t) None },
55− { False, XK_Return, it_switch_mode, (arg_t) None },
56− { False, XK_f, it_toggle_fullscreen, (arg_t) None },
57−
58− { False, XK_r, it_reload_image, (arg_t) None },
59− { False, XK_D, it_remove_image, (arg_t) None },
60−
61− { False, XK_n, i_navigate, (arg_t) +1 },
62− { False, XK_space, i_navigate, (arg_t) +1 },
63− { False, XK_p, i_navigate, (arg_t) -1 },
64− { False, XK_BackSpace, i_navigate, (arg_t) -1 },
65− { False, XK_bracketright, i_navigate, (arg_t) +10 },
66− { False, XK_bracketleft, i_navigate, (arg_t) -10 },
67− { False, XK_g, it_first, (arg_t) None },
68− { False, XK_G, it_last, (arg_t) None },
69−
70− { True, XK_n, i_navigate_frame, (arg_t) +1 },
71− { True, XK_p, i_navigate_frame, (arg_t) -1 },
72− { True, XK_space, i_toggle_animation, (arg_t) None },
73−
74− { False, XK_h, it_move, (arg_t) DIR_LEFT },
75− { False, XK_Left, it_move, (arg_t) DIR_LEFT },
76− { False, XK_j, it_move, (arg_t) DIR_DOWN },
77− { False, XK_Down, it_move, (arg_t) DIR_DOWN },
78− { False, XK_k, it_move, (arg_t) DIR_UP },
79− { False, XK_Up, it_move, (arg_t) DIR_UP },
80− { False, XK_l, it_move, (arg_t) DIR_RIGHT },
81− { False, XK_Right, it_move, (arg_t) DIR_RIGHT },
82−
83− { True, XK_h, i_pan_screen, (arg_t) DIR_LEFT },
84− { True, XK_Left, i_pan_screen, (arg_t) DIR_LEFT },
85− { True, XK_j, i_pan_screen, (arg_t) DIR_DOWN },
86− { True, XK_Down, i_pan_screen, (arg_t) DIR_DOWN },
87− { True, XK_k, i_pan_screen, (arg_t) DIR_UP },
88− { True, XK_Up, i_pan_screen, (arg_t) DIR_UP },
89− { True, XK_l, i_pan_screen, (arg_t) DIR_RIGHT },
90− { True, XK_Right, i_pan_screen, (arg_t) DIR_RIGHT },
91−
92− { False, XK_H, i_pan_edge, (arg_t) DIR_LEFT },
93− { False, XK_J, i_pan_edge, (arg_t) DIR_DOWN },
94− { False, XK_K, i_pan_edge, (arg_t) DIR_UP },
95− { False, XK_L, i_pan_edge, (arg_t) DIR_RIGHT },
96−
97− { False, XK_plus, i_zoom, (arg_t) +1 },
98− { False, XK_equal, i_zoom, (arg_t) +1 },
99− { False, XK_KP_Add, i_zoom, (arg_t) +1 },
100− { False, XK_minus, i_zoom, (arg_t) -1 },
101− { False, XK_KP_Subtract, i_zoom, (arg_t) -1 },
102− { False, XK_0, i_zoom, (arg_t) None },
103− { False, XK_KP_0, i_zoom, (arg_t) None },
104− { False, XK_w, i_fit_to_win, (arg_t) None },
105− { False, XK_W, i_fit_to_img, (arg_t) None },
106−
107− { False, XK_less, i_rotate, (arg_t) DIR_LEFT },
108− { False, XK_greater, i_rotate, (arg_t) DIR_RIGHT },
109−
110− { False, XK_s, i_toggle_slideshow, (arg_t) None },
111− { True, XK_plus, i_adjust_slideshow, (arg_t) +1 },
112− { True, XK_equal, i_adjust_slideshow, (arg_t) +1 },
113− { True, XK_minus, i_adjust_slideshow, (arg_t) -1 },
114−
115− { False, XK_a, i_toggle_antialias, (arg_t) None },
116− { False, XK_A, it_toggle_alpha, (arg_t) None },
54+ { false, XK_q, it_quit, (arg_t) None },
55+ { false, XK_Return, it_switch_mode, (arg_t) None },
56+ { false, XK_f, it_toggle_fullscreen, (arg_t) None },
57+
58+ { false, XK_r, it_reload_image, (arg_t) None },
59+ { false, XK_D, it_remove_image, (arg_t) None },
60+
61+ { false, XK_n, i_navigate, (arg_t) +1 },
62+ { false, XK_space, i_navigate, (arg_t) +1 },
63+ { false, XK_p, i_navigate, (arg_t) -1 },
64+ { false, XK_BackSpace, i_navigate, (arg_t) -1 },
65+ { false, XK_bracketright, i_navigate, (arg_t) +10 },
66+ { false, XK_bracketleft, i_navigate, (arg_t) -10 },
67+ { false, XK_g, it_first, (arg_t) None },
68+ { false, XK_G, it_last, (arg_t) None },
69+
70+ { true, XK_n, i_navigate_frame, (arg_t) +1 },
71+ { true, XK_p, i_navigate_frame, (arg_t) -1 },
72+ { true, XK_space, i_toggle_animation, (arg_t) None },
73+
74+ { false, XK_h, it_move, (arg_t) DIR_LEFT },
75+ { false, XK_Left, it_move, (arg_t) DIR_LEFT },
76+ { false, XK_j, it_move, (arg_t) DIR_DOWN },
77+ { false, XK_Down, it_move, (arg_t) DIR_DOWN },
78+ { false, XK_k, it_move, (arg_t) DIR_UP },
79+ { false, XK_Up, it_move, (arg_t) DIR_UP },
80+ { false, XK_l, it_move, (arg_t) DIR_RIGHT },
81+ { false, XK_Right, it_move, (arg_t) DIR_RIGHT },
82+
83+ { true, XK_h, i_pan_screen, (arg_t) DIR_LEFT },
84+ { true, XK_Left, i_pan_screen, (arg_t) DIR_LEFT },
85+ { true, XK_j, i_pan_screen, (arg_t) DIR_DOWN },
86+ { true, XK_Down, i_pan_screen, (arg_t) DIR_DOWN },
87+ { true, XK_k, i_pan_screen, (arg_t) DIR_UP },
88+ { true, XK_Up, i_pan_screen, (arg_t) DIR_UP },
89+ { true, XK_l, i_pan_screen, (arg_t) DIR_RIGHT },
90+ { true, XK_Right, i_pan_screen, (arg_t) DIR_RIGHT },
91+
92+ { false, XK_H, i_pan_edge, (arg_t) DIR_LEFT },
93+ { false, XK_J, i_pan_edge, (arg_t) DIR_DOWN },
94+ { false, XK_K, i_pan_edge, (arg_t) DIR_UP },
95+ { false, XK_L, i_pan_edge, (arg_t) DIR_RIGHT },
96+
97+ { false, XK_plus, i_zoom, (arg_t) +1 },
98+ { false, XK_equal, i_zoom, (arg_t) +1 },
99+ { false, XK_KP_Add, i_zoom, (arg_t) +1 },
100+ { false, XK_minus, i_zoom, (arg_t) -1 },
101+ { false, XK_KP_Subtract, i_zoom, (arg_t) -1 },
102+ { false, XK_0, i_zoom, (arg_t) None },
103+ { false, XK_KP_0, i_zoom, (arg_t) None },
104+ { false, XK_w, i_fit_to_win, (arg_t) None },
105+ { false, XK_W, i_fit_to_img, (arg_t) None },
106+
107+ { false, XK_less, i_rotate, (arg_t) DIR_LEFT },
108+ { false, XK_greater, i_rotate, (arg_t) DIR_RIGHT },
109+
110+ { false, XK_s, i_toggle_slideshow, (arg_t) None },
111+ { true, XK_plus, i_adjust_slideshow, (arg_t) +1 },
112+ { true, XK_equal, i_adjust_slideshow, (arg_t) +1 },
113+ { true, XK_minus, i_adjust_slideshow, (arg_t) -1 },
114+
115+ { false, XK_a, i_toggle_antialias, (arg_t) None },
116+ { false, XK_A, it_toggle_alpha, (arg_t) None },
117117
118118 /* open current image with given program: */
119− { True, XK_g, it_open_with, (arg_t) "gimp" },
119+ { true, XK_g, it_open_with, (arg_t) "gimp" },
120120
121121 /* run shell command line on current file ("$SXIV_IMG"): */
122− { True, XK_less, it_shell_cmd, (arg_t) \
122+ { true, XK_less, it_shell_cmd, (arg_t) \
123123 "mogrify -rotate -90 \"$SXIV_IMG\"" },
124− { True, XK_greater, it_shell_cmd, (arg_t) \
124+ { true, XK_greater, it_shell_cmd, (arg_t) \
125125 "mogrify -rotate +90 \"$SXIV_IMG\"" },
126− { True, XK_comma, it_shell_cmd, (arg_t) \
126+ { true, XK_comma, it_shell_cmd, (arg_t) \
127127 "jpegtran -rotate 270 -copy all -outfile \"$SXIV_IMG\" \"$SXIV_IMG\"" },
128− { True, XK_period, it_shell_cmd, (arg_t) \
128+ { true, XK_period, it_shell_cmd, (arg_t) \
129129 "jpegtran -rotate 90 -copy all -outfile \"$SXIV_IMG\" \"$SXIV_IMG\"" },
130130 };
131131
132132 /* mouse button mappings for image mode: */
133133 static const button_t buttons[] = {
134134 /* ctrl shift button function argument */
135− { False, False, Button1, i_navigate, (arg_t) +1 },
136− { False, False, Button3, i_navigate, (arg_t) -1 },
137− { False, False, Button2, i_drag, (arg_t) None },
138− { False, False, Button4, it_move, (arg_t) DIR_UP },
139− { False, False, Button5, it_move, (arg_t) DIR_DOWN },
140− { False, True, Button4, it_move, (arg_t) DIR_LEFT },
141− { False, True, Button5, it_move, (arg_t) DIR_RIGHT },
142− { True, False, Button4, i_zoom, (arg_t) +1 },
143− { True, False, Button5, i_zoom, (arg_t) -1 },
135+ { false, false, Button1, i_navigate, (arg_t) +1 },
136+ { false, false, Button3, i_navigate, (arg_t) -1 },
137+ { false, false, Button2, i_drag, (arg_t) None },
138+ { false, false, Button4, it_move, (arg_t) DIR_UP },
139+ { false, false, Button5, it_move, (arg_t) DIR_DOWN },
140+ { false, true, Button4, it_move, (arg_t) DIR_LEFT },
141+ { false, true, Button5, it_move, (arg_t) DIR_RIGHT },
142+ { true, false, Button4, i_zoom, (arg_t) +1 },
143+ { true, false, Button5, i_zoom, (arg_t) -1 },
144144 };
145145
146146 #endif
M image.c View
@@ -51,15 +51,15 @@ void img_init(img_t *img, win_t *win) {
5151 if (img) {
5252 img->im = NULL;
5353 img->multi.cap = img->multi.cnt = 0;
54− img->multi.animate = 0;
54+ img->multi.animate = false;
5555 img->zoom = options->zoom;
5656 img->zoom = MAX(img->zoom, zoom_min);
5757 img->zoom = MIN(img->zoom, zoom_max);
58− img->checkpan = 0;
59− img->dirty = 0;
58+ img->checkpan = false;
59+ img->dirty = false;
6060 img->aa = options->aa;
61− img->alpha = 1;
62− img->slideshow = 0;
61+ img->alpha = true;
62+ img->slideshow = false;
6363 img->ss_delay = SLIDESHOW_DELAY * 1000;
6464 }
6565
@@ -119,7 +119,7 @@ void exif_auto_orientate(const fileinfo_t *file) {
119119 /* Originally based on, but in its current form merely inspired by Imlib2's
120120 * src/modules/loaders/loader_gif.c:load(), written by Carsten Haitzler.
121121 */
122−int img_load_gif(img_t *img, const fileinfo_t *file) {
122+bool img_load_gif(img_t *img, const fileinfo_t *file) {
123123 GifFileType *gif;
124124 GifRowType *rows = NULL;
125125 GifRecordType rec;
@@ -131,8 +131,9 @@ int img_load_gif(img_t *img, const fileinfo_t *file) {
131131 int x, y, w, h, sw, sh;
132132 int intoffset[] = { 0, 4, 2, 1 };
133133 int intjump[] = { 8, 8, 4, 2 };
134− int err = 0, transp = -1;
134+ int transp = -1;
135135 unsigned int delay = 0;
136+ bool err = false;
136137
137138 if (img->multi.cap == 0) {
138139 img->multi.cap = 8;
@@ -145,7 +146,7 @@ int img_load_gif(img_t *img, const fileinfo_t *file) {
145146 gif = DGifOpenFileName(file->path);
146147 if (!gif) {
147148 warn("could not open gif file: %s", file->name);
148− return 0;
149+ return false;
149150 }
150151 bg = gif->SBackGroundColor;
151152 sw = gif->SWidth;
@@ -153,7 +154,7 @@ int img_load_gif(img_t *img, const fileinfo_t *file) {
153154
154155 do {
155156 if (DGifGetRecordType(gif, &rec) == GIF_ERROR) {
156− err = 1;
157+ err = true;
157158 break;
158159 }
159160 if (rec == EXTENSION_RECORD_TYPE) {
@@ -177,7 +178,7 @@ int img_load_gif(img_t *img, const fileinfo_t *file) {
177178 }
178179 } else if (rec == IMAGE_DESC_RECORD_TYPE) {
179180 if (DGifGetImageDesc(gif) == GIF_ERROR) {
180− err = 1;
181+ err = true;
181182 break;
182183 }
183184 x = gif->Image.Left;
@@ -235,7 +236,7 @@ int img_load_gif(img_t *img, const fileinfo_t *file) {
235236 free(data);
236237
237238 if (!im) {
238− err = 1;
239+ err = true;
239240 break;
240241 }
241242
@@ -272,7 +273,7 @@ int img_load_gif(img_t *img, const fileinfo_t *file) {
272273 imlib_context_set_image(img->multi.frames[0].im);
273274 imlib_free_image();
274275 img->multi.cnt = 0;
275− img->multi.animate = 0;
276+ img->multi.animate = false;
276277 }
277278
278279 imlib_context_set_image(img->im);
@@ -281,15 +282,15 @@ int img_load_gif(img_t *img, const fileinfo_t *file) {
281282 }
282283 #endif /* GIF_SUPPORT */
283284
284−int img_load(img_t *img, const fileinfo_t *file) {
285+bool img_load(img_t *img, const fileinfo_t *file) {
285286 const char *fmt;
286287
287288 if (!img || !file || !file->name || !file->path)
288− return 0;
289+ return false;
289290
290291 if (access(file->path, R_OK) || !(img->im = imlib_load_image(file->path))) {
291292 warn("could not open image: %s", file->name);
292− return 0;
293+ return false;
293294 }
294295
295296 imlib_context_set_image(img->im);
@@ -310,17 +311,17 @@ int img_load(img_t *img, const fileinfo_t *file) {
310311 #endif
311312
312313 img->scalemode = options->scalemode;
313− img->re = 0;
314− img->checkpan = 0;
314+ img->re = false;
315+ img->checkpan = false;
316+ img->dirty = true;
315317
316318 img->w = imlib_image_get_width();
317319 img->h = imlib_image_get_height();
318320
319− img->dirty = 1;
320− return 1;
321+ return true;
321322 }
322323
323−void img_close(img_t *img, int decache) {
324+void img_close(img_t *img, bool decache) {
324325 int i;
325326
326327 if (!img)
@@ -343,7 +344,7 @@ void img_close(img_t *img, int decache) {
343344 }
344345 }
345346
346−void img_check_pan(img_t *img, win_t *win, int moved) {
347+void img_check_pan(img_t *img, win_t *win, bool moved) {
347348 int ox, oy;
348349
349350 if (!img || !win)
@@ -370,14 +371,14 @@ void img_check_pan(img_t *img, win_t *win, int moved) {
370371 }
371372
372373 if (!moved && (ox != img->x || oy != img->y))
373− img->dirty = 1;
374+ img->dirty = true;
374375 }
375376
376−int img_fit(img_t *img, win_t *win) {
377+bool img_fit(img_t *img, win_t *win) {
377378 float z, zmax, zw, zh;
378379
379380 if (!img || !win || img->scalemode == SCALE_ZOOM)
380− return 0;
381+ return false;
381382
382383 zmax = img->scalemode == SCALE_DOWN ? 1.0 : zoom_max;
383384 zw = (float) win->w / (float) img->w;
@@ -389,10 +390,10 @@ int img_fit(img_t *img, win_t *win) {
389390
390391 if (ZOOMDIFF(z, img->zoom)) {
391392 img->zoom = z;
392− img->dirty = 1;
393− return 1;
393+ img->dirty = true;
394+ return true;
394395 } else {
395− return 0;
396+ return false;
396397 }
397398 }
398399
@@ -407,7 +408,7 @@ void img_render(img_t *img, win_t *win) {
407408
408409 if (!img->re) {
409410 /* rendered for the first time */
410− img->re = 1;
411+ img->re = true;
411412 if (img->zoom * img->w <= win->w)
412413 img->x = (win->w - img->w * img->zoom) / 2;
413414 else
@@ -419,8 +420,8 @@ void img_render(img_t *img, win_t *win) {
419420 }
420421
421422 if (img->checkpan) {
422− img_check_pan(img, win, 0);
423− img->checkpan = 0;
423+ img_check_pan(img, win, false);
424+ img->checkpan = false;
424425 }
425426
426427 if (!img->dirty)
@@ -462,22 +463,22 @@ void img_render(img_t *img, win_t *win) {
462463
463464 win_draw(win);
464465
465− img->dirty = 0;
466+ img->dirty = false;
466467 }
467468
468−int img_fit_win(img_t *img, win_t *win) {
469+bool img_fit_win(img_t *img, win_t *win) {
469470 if (!img || !img->im || !win)
470− return 0;
471+ return false;
471472
472473 img->scalemode = SCALE_FIT;
473474 return img_fit(img, win);
474475 }
475476
476−int img_center(img_t *img, win_t *win) {
477+bool img_center(img_t *img, win_t *win) {
477478 int ox, oy;
478479
479480 if (!img || !win)
480− return 0;
481+ return false;
481482
482483 ox = img->x;
483484 oy = img->y;
@@ -486,16 +487,16 @@ int img_center(img_t *img, win_t *win) {
486487 img->y = (win->h - img->h * img->zoom) / 2;
487488
488489 if (ox != img->x || oy != img->y) {
489− img->dirty = 1;
490− return 1;
490+ img->dirty = true;
491+ return true;
491492 } else {
492− return 0;
493+ return false;
493494 }
494495 }
495496
496−int img_zoom(img_t *img, win_t *win, float z) {
497+bool img_zoom(img_t *img, win_t *win, float z) {
497498 if (!img || !img->im || !win)
498− return 0;
499+ return false;
499500
500501 z = MAX(z, zoom_min);
501502 z = MIN(z, zoom_max);
@@ -506,45 +507,45 @@ int img_zoom(img_t *img, win_t *win, float z) {
506507 img->x = win->w / 2 - (win->w / 2 - img->x) * z / img->zoom;
507508 img->y = win->h / 2 - (win->h / 2 - img->y) * z / img->zoom;
508509 img->zoom = z;
509− img->checkpan = 1;
510− img->dirty = 1;
511− return 1;
510+ img->checkpan = true;
511+ img->dirty = true;
512+ return true;
512513 } else {
513− return 0;
514+ return false;
514515 }
515516 }
516517
517−int img_zoom_in(img_t *img, win_t *win) {
518+bool img_zoom_in(img_t *img, win_t *win) {
518519 int i;
519520
520521 if (!img || !img->im || !win)
521− return 0;
522+ return false;
522523
523524 for (i = 1; i < ARRLEN(zoom_levels); i++) {
524525 if (zoom_levels[i] > img->zoom * 100.0)
525526 return img_zoom(img, win, zoom_levels[i] / 100.0);
526527 }
527− return 0;
528+ return false;
528529 }
529530
530−int img_zoom_out(img_t *img, win_t *win) {
531+bool img_zoom_out(img_t *img, win_t *win) {
531532 int i;
532533
533534 if (!img || !img->im || !win)
534− return 0;
535+ return false;
535536
536537 for (i = ARRLEN(zoom_levels) - 2; i >= 0; i--) {
537538 if (zoom_levels[i] < img->zoom * 100.0)
538539 return img_zoom(img, win, zoom_levels[i] / 100.0);
539540 }
540− return 0;
541+ return false;
541542 }
542543
543−int img_move(img_t *img, win_t *win, int dx, int dy) {
544+bool img_move(img_t *img, win_t *win, int dx, int dy) {
544545 int ox, oy;
545546
546547 if (!img || !img->im || !win)
547− return 0;
548+ return false;
548549
549550 ox = img->x;
550551 oy = img->y;
@@ -552,19 +553,19 @@ int img_move(img_t *img, win_t *win, int dx, int dy) {
552553 img->x += dx;
553554 img->y += dy;
554555
555− img_check_pan(img, win, 1);
556+ img_check_pan(img, win, true);
556557
557558 if (ox != img->x || oy != img->y) {
558− img->dirty = 1;
559− return 1;
559+ img->dirty = true;
560+ return true;
560561 } else {
561− return 0;
562+ return false;
562563 }
563564 }
564565
565−int img_pan(img_t *img, win_t *win, direction_t dir, int screen) {
566+bool img_pan(img_t *img, win_t *win, direction_t dir, bool screen) {
566567 if (!img || !img->im || !win)
567− return 0;
568+ return false;
568569
569570 switch (dir) {
570571 case DIR_LEFT:
@@ -576,14 +577,14 @@ int img_pan(img_t *img, win_t *win, direction_t dir, int screen) {
576577 case DIR_DOWN:
577578 return img_move(img, win, 0, win->h / (screen ? 1 : 5) * -1);
578579 }
579− return 0;
580+ return false;
580581 }
581582
582−int img_pan_edge(img_t *img, win_t *win, direction_t dir) {
583+bool img_pan_edge(img_t *img, win_t *win, direction_t dir) {
583584 int ox, oy;
584585
585586 if (!img || !img->im || !win)
586− return 0;
587+ return false;
587588
588589 ox = img->x;
589590 oy = img->y;
@@ -603,13 +604,13 @@ int img_pan_edge(img_t *img, win_t *win, direction_t dir) {
603604 break;
604605 }
605606
606− img_check_pan(img, win, 1);
607+ img_check_pan(img, win, true);
607608
608609 if (ox != img->x || oy != img->y) {
609− img->dirty = 1;
610− return 1;
610+ img->dirty = true;
611+ return true;
611612 } else {
612− return 0;
613+ return false;
613614 }
614615 }
615616
@@ -632,8 +633,8 @@ void img_rotate(img_t *img, win_t *win, int d) {
632633 img->w = img->h;
633634 img->h = tmp;
634635
635− img->checkpan = 1;
636− img->dirty = 1;
636+ img->checkpan = true;
637+ img->dirty = true;
637638 }
638639
639640 void img_rotate_left(img_t *img, win_t *win) {
@@ -648,18 +649,18 @@ void img_toggle_antialias(img_t *img) {
648649 if (!img || !img->im)
649650 return;
650651
651− img->aa ^= 1;
652+ img->aa = !img->aa;
652653 imlib_context_set_image(img->im);
653654 imlib_context_set_anti_alias(img->aa);
654− img->dirty = 1;
655+ img->dirty = true;
655656 }
656657
657−int img_frame_goto(img_t *img, int n) {
658+bool img_frame_goto(img_t *img, int n) {
658659 if (!img || n < 0 || n >= img->multi.cnt)
659− return 0;
660+ return false;
660661
661662 if (n == img->multi.sel)
662− return 0;
663+ return false;
663664
664665 img->multi.sel = n;
665666 img->im = img->multi.frames[n].im;
@@ -667,15 +668,15 @@ int img_frame_goto(img_t *img, int n) {
667668 imlib_context_set_image(img->im);
668669 img->w = imlib_image_get_width();
669670 img->h = imlib_image_get_height();
670− img->checkpan = 1;
671− img->dirty = 1;
671+ img->checkpan = true;
672+ img->dirty = true;
672673
673− return 1;
674+ return true;
674675 }
675676
676−int img_frame_navigate(img_t *img, int d) {
677+bool img_frame_navigate(img_t *img, int d) {
677678 if (!img || !img->multi.cnt || !d)
678− return 0;
679+ return false;
679680
680681 d += img->multi.sel;
681682 if (d < 0)
@@ -686,22 +687,22 @@ int img_frame_navigate(img_t *img, int d) {
686687 return img_frame_goto(img, d);
687688 }
688689
689−int img_frame_animate(img_t *img, int restart) {
690+bool img_frame_animate(img_t *img, bool restart) {
690691 if (!img || !img->multi.cnt)
691− return 0;
692+ return false;
692693
693694 if (img->multi.sel + 1 >= img->multi.cnt) {
694695 if (restart || (GIF_LOOP && !img->slideshow)) {
695696 img_frame_goto(img, 0);
696697 } else {
697− img->multi.animate = 0;
698− return 0;
698+ img->multi.animate = false;
699+ return false;
699700 }
700701 } else if (!restart) {
701702 img_frame_goto(img, img->multi.sel + 1);
702703 }
703− img->multi.animate = 1;
704+ img->multi.animate = true;
705+ img->dirty = true;
704706
705− img->dirty = 1;
706− return img->multi.frames[img->multi.sel].delay;
707+ return true;
707708 }
M image.h View
@@ -34,7 +34,7 @@ typedef struct {
3434 int cap;
3535 int cnt;
3636 int sel;
37− unsigned char animate;
37+ bool animate;
3838 } multi_img_t;
3939
4040 typedef struct {
@@ -44,13 +44,13 @@ typedef struct {
4444 float zoom;
4545 scalemode_t scalemode;
4646
47− unsigned char re;
48− unsigned char checkpan;
49− unsigned char dirty;
50− unsigned char aa;
51− unsigned char alpha;
47+ bool re;
48+ bool checkpan;
49+ bool dirty;
50+ bool aa;
51+ bool alpha;
5252
53− unsigned char slideshow;
53+ bool slideshow;
5454 int ss_delay; /* in ms */
5555
5656 int x;
@@ -61,28 +61,28 @@ typedef struct {
6161
6262 void img_init(img_t*, win_t*);
6363
64−int img_load(img_t*, const fileinfo_t*);
65−void img_close(img_t*, int);
64+bool img_load(img_t*, const fileinfo_t*);
65+void img_close(img_t*, bool);
6666
6767 void img_render(img_t*, win_t*);
6868
69−int img_fit_win(img_t*, win_t*);
70−int img_center(img_t*, win_t*);
69+bool img_fit_win(img_t*, win_t*);
70+bool img_center(img_t*, win_t*);
7171
72−int img_zoom(img_t*, win_t*, float);
73−int img_zoom_in(img_t*, win_t*);
74−int img_zoom_out(img_t*, win_t*);
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*);
7575
76−int img_move(img_t*, win_t*, int, int);
77−int img_pan(img_t*, win_t*, direction_t, int);
78−int img_pan_edge(img_t*, win_t*, direction_t);
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);
7979
8080 void img_rotate_left(img_t*, win_t*);
8181 void img_rotate_right(img_t*, win_t*);
8282
8383 void img_toggle_antialias(img_t*);
8484
85−int img_frame_navigate(img_t*, int);
86−int img_frame_animate(img_t*, int);
85+bool img_frame_navigate(img_t*, int);
86+bool img_frame_animate(img_t*, bool);
8787
8888 #endif /* IMAGE_H */
M main.c View
@@ -17,6 +17,7 @@
1717 */
1818
1919 #define _POSIX_C_SOURCE 200112L
20+#define _MAPPINGS_CONFIG
2021
2122 #include <stdlib.h>
2223 #include <stdio.h>
@@ -34,8 +35,6 @@
3435 #include "types.h"
3536 #include "util.h"
3637 #include "window.h"
37−
38−#define _MAPPINGS_CONFIG
3938 #include "config.h"
4039
4140 enum {
@@ -45,7 +44,7 @@ enum {
4544
4645 typedef struct {
4746 struct timeval when;
48− Bool active;
47+ bool active;
4948 timeout_f handler;
5049 } timeout_t;
5150
@@ -67,17 +66,17 @@ size_t filesize;
6766 char win_title[TITLE_LEN];
6867
6968 timeout_t timeouts[] = {
70− { { 0, 0 }, False, redraw },
71− { { 0, 0 }, False, reset_cursor },
72− { { 0, 0 }, False, animate },
73− { { 0, 0 }, False, slideshow },
69+ { { 0, 0 }, false, redraw },
70+ { { 0, 0 }, false, reset_cursor },
71+ { { 0, 0 }, false, animate },
72+ { { 0, 0 }, false, slideshow },
7473 };
7574
7675 void cleanup() {
7776 static int in = 0;
7877
7978 if (!in++) {
80− img_close(&img, 0);
79+ img_close(&img, false);
8180 tns_free(&tns);
8281 win_close(&win);
8382 }
@@ -103,14 +102,14 @@ void check_add_file(char *filename) {
103102 return;
104103 }
105104 }
106− files[fileidx].loaded = 0;
105+ files[fileidx].loaded = false;
107106 files[fileidx].name = s_strdup(filename);
108107 if (*filename == '/')
109108 files[fileidx].path = files[fileidx].name;
110109 fileidx++;
111110 }
112111
113−void remove_file(int n, unsigned char silent) {
112+void remove_file(int n, bool silent) {
114113 if (n < 0 || n >= filecnt)
115114 return;
116115
@@ -138,7 +137,7 @@ void remove_file(int n, unsigned char silent) {
138137 tns.cnt--;
139138 }
140139
141−void set_timeout(timeout_f handler, int time, int overwrite) {
140+void set_timeout(timeout_f handler, int time, bool overwrite) {
142141 int i;
143142
144143 for (i = 0; i < ARRLEN(timeouts); i++) {
@@ -146,7 +145,7 @@ void set_timeout(timeout_f handler, int time, int overwrite) {
146145 if (!timeouts[i].active || overwrite) {
147146 gettimeofday(&timeouts[i].when, 0);
148147 MSEC_ADD_TO_TIMEVAL(time, &timeouts[i].when);
149− timeouts[i].active = True;
148+ timeouts[i].active = true;
150149 }
151150 return;
152151 }
@@ -158,13 +157,13 @@ void reset_timeout(timeout_f handler) {
158157
159158 for (i = 0; i < ARRLEN(timeouts); i++) {
160159 if (timeouts[i].handler == handler) {
161− timeouts[i].active = False;
160+ timeouts[i].active = false;
162161 return;
163162 }
164163 }
165164 }
166165
167−int check_timeouts(struct timeval *t) {
166+bool check_timeouts(struct timeval *t) {
168167 int i = 0, tdiff, tmin = -1;
169168 struct timeval now;
170169
@@ -173,7 +172,7 @@ int check_timeouts(struct timeval *t) {
173172 if (timeouts[i].active) {
174173 tdiff = TIMEDIFF(&timeouts[i].when, &now);
175174 if (tdiff <= 0) {
176− timeouts[i].active = False;
175+ timeouts[i].active = false;
177176 if (timeouts[i].handler)
178177 timeouts[i].handler();
179178 i = tmin = -1;
@@ -196,14 +195,14 @@ void load_image(int new) {
196195
197196 win_set_cursor(&win, CURSOR_WATCH);
198197
199− img_close(&img, 0);
198+ img_close(&img, false);
200199 while (!img_load(&img, &files[new])) {
201− remove_file(new, 0);
200+ remove_file(new, false);
202201 if (new >= filecnt)
203202 new = filecnt - 1;
204203 }
205204
206− files[new].loaded = 1;
205+ files[new].loaded = true;
207206 fileidx = new;
208207 if (!stat(files[new].path, &fstats))
209208 filesize = fstats.st_size;
@@ -211,7 +210,7 @@ void load_image(int new) {
211210 filesize = 0;
212211
213212 if (img.multi.cnt && img.multi.animate)
214− set_timeout(animate, img.multi.frames[img.multi.sel].delay, 1);
213+ set_timeout(animate, img.multi.frames[img.multi.sel].delay, true);
215214 else
216215 reset_timeout(animate);
217216 }
@@ -265,9 +264,9 @@ void redraw() {
265264 img_render(&img, &win);
266265 if (img.slideshow && !img.multi.animate) {
267266 if (fileidx + 1 < filecnt)
268− set_timeout(slideshow, img.ss_delay, 1);
267+ set_timeout(slideshow, img.ss_delay, true);
269268 else
270− img.slideshow = 0;
269+ img.slideshow = false;
271270 }
272271 } else {
273272 tns_render(&tns, &win);
@@ -299,12 +298,10 @@ void reset_cursor() {
299298 }
300299
301300 void animate() {
302− int delay;
303−
304− delay = img_frame_animate(&img, 0);
305− redraw();
306− if (delay)
307− set_timeout(animate, delay, 1);
301+ if (img_frame_animate(&img, false)) {
302+ redraw();
303+ set_timeout(animate, img.multi.frames[img.multi.sel].delay, true);
304+ }
308305 }
309306
310307 void slideshow() {
@@ -313,16 +310,16 @@ void slideshow() {
313310 load_image(fileidx + 1);
314311 redraw();
315312 } else {
316− img.slideshow = 0;
313+ img.slideshow = false;
317314 }
318315 }
319316 }
320317
321−Bool keymask(const keymap_t *k, unsigned int state) {
318+bool keymask(const keymap_t *k, unsigned int state) {
322319 return (k->ctrl ? ControlMask : 0) == (state & ControlMask);
323320 }
324321
325−Bool buttonmask(const button_t *b, unsigned int state) {
322+bool buttonmask(const button_t *b, unsigned int state) {
326323 return ((b->ctrl ? ControlMask : 0) | (b->shift ? ShiftMask : 0)) ==
327324 (state & (ControlMask | ShiftMask));
328325 }
@@ -354,7 +351,7 @@ void on_buttonpress(XButtonEvent *bev) {
354351
355352 if (mode == MODE_IMAGE) {
356353 win_set_cursor(&win, CURSOR_ARROW);
357− set_timeout(reset_cursor, TO_CURSOR_HIDE, 1);
354+ set_timeout(reset_cursor, TO_CURSOR_HIDE, true);
358355
359356 for (i = 0; i < ARRLEN(buttons); i++) {
360357 if (buttons[i].button == bev->button &&
@@ -372,11 +369,11 @@ void on_buttonpress(XButtonEvent *bev) {
372369 if ((sel = tns_translate(&tns, bev->x, bev->y)) >= 0) {
373370 if (sel == tns.sel) {
374371 mode = MODE_IMAGE;
375− set_timeout(reset_cursor, TO_CURSOR_HIDE, 1);
372+ set_timeout(reset_cursor, TO_CURSOR_HIDE, true);
376373 load_image(tns.sel);
377374 } else {
378− tns_highlight(&tns, &win, tns.sel, False);
379− tns_highlight(&tns, &win, sel, True);
375+ tns_highlight(&tns, &win, tns.sel, false);
376+ tns_highlight(&tns, &win, sel, true);
380377 tns.sel = sel;
381378 }
382379 redraw();
@@ -405,11 +402,11 @@ void run() {
405402 !XPending(win.env.dpy))
406403 {
407404 /* load thumbnails */
408− set_timeout(redraw, TO_REDRAW_THUMBS, 0);
409− if (tns_load(&tns, tns.cnt, &files[tns.cnt], False, False))
405+ set_timeout(redraw, TO_REDRAW_THUMBS, false);
406+ if (tns_load(&tns, tns.cnt, &files[tns.cnt], false, false))
410407 tns.cnt++;
411408 else
412− remove_file(tns.cnt, 0);
409+ remove_file(tns.cnt, false);
413410 if (tns.cnt == filecnt)
414411 redraw();
415412 else
@@ -436,11 +433,11 @@ void run() {
436433 break;
437434 case ConfigureNotify:
438435 if (win_configure(&win, &ev.xconfigure)) {
439− set_timeout(redraw, TO_REDRAW_RESIZE, 0);
436+ set_timeout(redraw, TO_REDRAW_RESIZE, false);
440437 if (mode == MODE_IMAGE)
441− img.checkpan = 1;
438+ img.checkpan = true;
442439 else
443− tns.dirty = 1;
440+ tns.dirty = true;
444441 }
445442 break;
446443 case KeyPress:
@@ -449,7 +446,7 @@ void run() {
449446 case MotionNotify:
450447 if (mode == MODE_IMAGE) {
451448 win_set_cursor(&win, CURSOR_ARROW);
452− set_timeout(reset_cursor, TO_CURSOR_HIDE, 1);
449+ set_timeout(reset_cursor, TO_CURSOR_HIDE, true);
453450 }
454451 break;
455452 }
@@ -539,11 +536,11 @@ int main(int argc, char **argv) {
539536 win_init(&win);
540537 img_init(&img, &win);
541538
542− if (options->thumbnails) {
539+ if (options->thumb_mode) {
543540 mode = MODE_THUMB;
544541 tns_init(&tns, filecnt);
545− while (!tns_load(&tns, 0, &files[0], False, False))
546− remove_file(0, 0);
542+ while (!tns_load(&tns, 0, &files[0], false, false))
543+ remove_file(0, false);
547544 tns.cnt = 1;
548545 } else {
549546 mode = MODE_IMAGE;
M options.c View
@@ -17,6 +17,7 @@
1717 */
1818
1919 #define _POSIX_C_SOURCE 200112L
20+#define _IMAGE_CONFIG
2021
2122 #include <stdlib.h>
2223 #include <string.h>
@@ -25,8 +26,6 @@
2526
2627 #include "options.h"
2728 #include "util.h"
28−
29−#define _IMAGE_CONFIG
3029 #include "config.h"
3130
3231 options_t _options;
@@ -56,20 +55,20 @@ void print_version() {
5655 void parse_options(int argc, char **argv) {
5756 int opt, t;
5857
59− _options.recursive = 0;
58+ _options.recursive = false;
6059 _options.startnum = 0;
6160
6261 _options.scalemode = SCALE_MODE;
6362 _options.zoom = 1.0;
64− _options.aa = 1;
63+ _options.aa = true;
6564
66− _options.fixed = 0;
67− _options.fullscreen = 0;
65+ _options.fixed_win = false;
66+ _options.fullscreen = false;
6867 _options.geometry = NULL;
6968
70− _options.quiet = 0;
71− _options.thumbnails = 0;
72− _options.clean_cache = 0;
69+ _options.quiet = false;
70+ _options.thumb_mode = false;
71+ _options.clean_cache = false;
7372
7473 while ((opt = getopt(argc, argv, "cdFfg:hn:pqrstvZz:")) != -1) {
7574 switch (opt) {
@@ -77,16 +76,16 @@ void parse_options(int argc, char **argv) {
7776 print_usage();
7877 exit(1);
7978 case 'c':
80− _options.clean_cache = 1;
79+ _options.clean_cache = true;
8180 break;
8281 case 'd':
8382 _options.scalemode = SCALE_DOWN;
8483 break;
8584 case 'F':
86− _options.fixed = 1;
85+ _options.fixed_win = true;
8786 break;
8887 case 'f':
89− _options.fullscreen = 1;
88+ _options.fullscreen = true;
9089 break;
9190 case 'g':
9291 _options.geometry = optarg;
@@ -104,19 +103,19 @@ void parse_options(int argc, char **argv) {
104103 }
105104 break;
106105 case 'p':
107− _options.aa = 0;
106+ _options.aa = false;
108107 break;
109108 case 'q':
110− _options.quiet = 1;
109+ _options.quiet = true;
111110 break;
112111 case 'r':
113− _options.recursive = 1;
112+ _options.recursive = true;
114113 break;
115114 case 's':
116115 _options.scalemode = SCALE_FIT;
117116 break;
118117 case 't':
119− _options.thumbnails = 1;
118+ _options.thumb_mode = true;
120119 break;
121120 case 'v':
122121 print_version();
@@ -140,5 +139,5 @@ void parse_options(int argc, char **argv) {
140139 _options.filenames = argv + optind;
141140 _options.filecnt = argc - optind;
142141 _options.from_stdin = _options.filecnt == 1 &&
143− strcmp(_options.filenames[0], "-") == 0;
142+ !strcmp(_options.filenames[0], "-");
144143 }
M options.h View
@@ -25,25 +25,25 @@
2525 typedef struct {
2626 /* file list: */
2727 char **filenames;
28− unsigned char from_stdin;
29− unsigned char recursive;
28+ bool from_stdin;
29+ bool recursive;
3030 int filecnt;
3131 int startnum;
3232
3333 /* image: */
3434 scalemode_t scalemode;
3535 float zoom;
36− unsigned char aa;
36+ bool aa;
3737
3838 /* window: */
39− unsigned char fixed;
40− unsigned char fullscreen;
39+ bool fixed_win;
40+ bool fullscreen;
4141 char *geometry;
4242
4343 /* misc flags: */
44− unsigned char quiet;
45− unsigned char thumbnails;
46− unsigned char clean_cache;
44+ bool quiet;
45+ bool thumb_mode;
46+ bool clean_cache;
4747 } options_t;
4848
4949 extern const options_t *options;
M thumbs.c View
@@ -17,6 +17,7 @@
1717 */
1818
1919 #define _POSIX_C_SOURCE 200112L
20+#define _THUMBS_CONFIG
2021
2122 #include <stdlib.h>
2223 #include <string.h>
@@ -27,8 +28,6 @@
2728
2829 #include "thumbs.h"
2930 #include "util.h"
30−
31−#define _THUMBS_CONFIG
3231 #include "config.h"
3332
3433 #ifdef EXIF_SUPPORT
@@ -38,7 +37,7 @@ void exif_auto_orientate(const fileinfo_t*);
3837 const int thumb_dim = THUMB_SIZE + 10;
3938 char *cache_dir = NULL;
4039
41−int tns_cache_enabled() {
40+bool tns_cache_enabled() {
4241 struct stat stats;
4342
4443 return cache_dir && !stat(cache_dir, &stats) && S_ISDIR(stats.st_mode) &&
@@ -81,7 +80,7 @@ Imlib_Image* tns_cache_load(const char *filepath) {
8180 return im;
8281 }
8382
84−void tns_cache_write(thumb_t *t, Bool force) {
83+void tns_cache_write(thumb_t *t, bool force) {
8584 char *cfile, *dirend;
8685 struct stat cstats, fstats;
8786 struct utimbuf times;
@@ -120,7 +119,8 @@ void tns_cache_write(thumb_t *t, Bool force) {
120119 }
121120
122121 void tns_clean_cache(tns_t *tns) {
123− int dirlen, delete;
122+ int dirlen;
123+ bool delete;
124124 char *cfile, *filename, *tpos;
125125 r_dir_t dir;
126126
@@ -136,11 +136,12 @@ void tns_clean_cache(tns_t *tns) {
136136
137137 while ((cfile = r_readdir(&dir))) {
138138 filename = cfile + dirlen;
139− delete = 0;
139+ delete = false;
140140
141141 if ((tpos = strrchr(filename, '.'))) {
142142 *tpos = '\0';
143− delete = access(filename, F_OK);
143+ if (access(filename, F_OK))
144+ delete = true;
144145 *tpos = '.';
145146 }
146147
@@ -170,8 +171,8 @@ void tns_init(tns_t *tns, int cnt) {
170171
171172 tns->cnt = tns->first = tns->sel = 0;
172173 tns->cap = cnt;
173− tns->alpha = 1;
174− tns->dirty = 0;
174+ tns->alpha = true;
175+ tns->dirty = false;
175176
176177 if ((homedir = getenv("HOME"))) {
177178 if (cache_dir)
@@ -207,21 +208,21 @@ void tns_free(tns_t *tns) {
207208 }
208209 }
209210
210−int tns_load(tns_t *tns, int n, const fileinfo_t *file,
211− Bool force, Bool silent)
211+bool tns_load(tns_t *tns, int n, const fileinfo_t *file,
212+ bool force, bool silent)
212213 {
213214 int w, h;
214− int use_cache, cache_hit = 0;
215+ bool use_cache, cache_hit = false;
215216 float z, zw, zh;
216217 thumb_t *t;
217218 Imlib_Image *im;
218219 const char *fmt;
219220
220221 if (!tns || !tns->thumbs || !file || !file->name || !file->path)
221− return 0;
222+ return false;
222223
223224 if (n < 0 || n >= tns->cap)
224− return 0;
225+ return false;
225226
226227 t = &tns->thumbs[n];
227228 t->file = file;
@@ -233,7 +234,7 @@ int tns_load(tns_t *tns, int n, const fileinfo_t *file,
233234
234235 if ((use_cache = tns_cache_enabled())) {
235236 if (!force && (im = tns_cache_load(file->path)))
236− cache_hit = 1;
237+ cache_hit = true;
237238 }
238239
239240 if (!cache_hit &&
@@ -241,7 +242,7 @@ int tns_load(tns_t *tns, int n, const fileinfo_t *file,
241242 {
242243 if (!silent)
243244 warn("could not open image: %s", file->name);
244− return 0;
245+ return false;
245246 }
246247
247248 imlib_context_set_image(im);
@@ -270,13 +271,13 @@ int tns_load(tns_t *tns, int n, const fileinfo_t *file,
270271 imlib_free_image_and_decache();
271272
272273 if (use_cache && !cache_hit)
273− tns_cache_write(t, False);
274+ tns_cache_write(t, false);
274275
275− tns->dirty = 1;
276− return 1;
276+ tns->dirty = true;
277+ return true;
277278 }
278279
279−void tns_check_view(tns_t *tns, Bool scrolled) {
280+void tns_check_view(tns_t *tns, bool scrolled) {
280281 int r;
281282
282283 if (!tns)
@@ -295,10 +296,10 @@ void tns_check_view(tns_t *tns, Bool scrolled) {
295296 /* scroll to selection */
296297 if (tns->first + tns->cols * tns->rows <= tns->sel) {
297298 tns->first = tns->sel - r - tns->cols * (tns->rows - 1);
298− tns->dirty = 1;
299+ tns->dirty = true;
299300 } else if (tns->first > tns->sel) {
300301 tns->first = tns->sel - r;
301− tns->dirty = 1;
302+ tns->dirty = true;
302303 }
303304 }
304305 }
@@ -323,7 +324,7 @@ void tns_render(tns_t *tns, win_t *win) {
323324 tns->first = 0;
324325 cnt = tns->cnt;
325326 } else {
326− tns_check_view(tns, False);
327+ tns_check_view(tns, false);
327328 cnt = tns->cols * tns->rows;
328329 if ((r = tns->first + cnt - tns->cnt) >= tns->cols)
329330 tns->first -= r - r % tns->cols;
@@ -342,7 +343,7 @@ void tns_render(tns_t *tns, win_t *win) {
342343 imlib_context_set_image(t->im);
343344
344345 if (imlib_image_has_alpha() && !tns->alpha)
345− win_draw_rect(win, win->pm, t->x, t->y, t->w, t->h, True, 0, win->white);
346+ win_draw_rect(win, win->pm, t->x, t->y, t->w, t->h, true, 0, win->white);
346347
347348 imlib_render_image_part_on_drawable_at_size(0, 0, t->w, t->h,
348349 t->x, t->y, t->w, t->h);
@@ -354,11 +355,11 @@ void tns_render(tns_t *tns, win_t *win) {
354355 }
355356 }
356357
357− tns->dirty = 0;
358− tns_highlight(tns, win, tns->sel, True);
358+ tns->dirty = false;
359+ tns_highlight(tns, win, tns->sel, true);
359360 }
360361
361−void tns_highlight(tns_t *tns, win_t *win, int n, Bool hl) {
362+void tns_highlight(tns_t *tns, win_t *win, int n, bool hl) {
362363 thumb_t *t;
363364 int x, y;
364365 unsigned long col;
@@ -379,17 +380,17 @@ void tns_highlight(tns_t *tns, win_t *win, int n, Bool hl) {
379380 x = t->x - (THUMB_SIZE - t->w) / 2;
380381 y = t->y - (THUMB_SIZE - t->h) / 2;
381382 win_draw_rect(win, win->pm, x - 3, y - 3, THUMB_SIZE + 6, THUMB_SIZE + 6,
382− False, 2, col);
383+ false, 2, col);
383384 }
384385
385386 win_draw(win);
386387 }
387388
388−int tns_move_selection(tns_t *tns, win_t *win, direction_t dir) {
389+bool tns_move_selection(tns_t *tns, win_t *win, direction_t dir) {
389390 int old;
390391
391392 if (!tns || !tns->thumbs || !win)
392− return 0;
393+ return false;
393394
394395 old = tns->sel;
395396
@@ -413,31 +414,31 @@ int tns_move_selection(tns_t *tns, win_t *win, direction_t dir) {
413414 }
414415
415416 if (tns->sel != old) {
416− tns_highlight(tns, win, old, False);
417− tns_check_view(tns, False);
417+ tns_highlight(tns, win, old, false);
418+ tns_check_view(tns, false);
418419 if (!tns->dirty)
419− tns_highlight(tns, win, tns->sel, True);
420+ tns_highlight(tns, win, tns->sel, true);
420421 }
421422
422423 return tns->sel != old;
423424 }
424425
425−int tns_scroll(tns_t *tns, direction_t dir) {
426+bool tns_scroll(tns_t *tns, direction_t dir) {
426427 int old;
427428
428429 if (!tns)
429− return 0;
430+ return false;
430431
431432 old = tns->first;
432433
433434 if (dir == DIR_DOWN && tns->first + tns->cols * tns->rows < tns->cnt) {
434435 tns->first += tns->cols;
435− tns_check_view(tns, True);
436− tns->dirty = 1;
436+ tns_check_view(tns, true);
437+ tns->dirty = true;
437438 } else if (dir == DIR_UP && tns->first >= tns->cols) {
438439 tns->first -= tns->cols;
439− tns_check_view(tns, True);
440− tns->dirty = 1;
440+ tns_check_view(tns, true);
441+ tns->dirty = true;
441442 }
442443
443444 return tns->first != old;
M thumbs.h View
@@ -44,8 +44,8 @@ typedef struct {
4444 int rows;
4545 int first;
4646 int sel;
47− unsigned char alpha;
48− unsigned char dirty;
47+ bool alpha;
48+ bool dirty;
4949 } tns_t;
5050
5151 void tns_clean_cache(tns_t*);
@@ -53,13 +53,13 @@ void tns_clean_cache(tns_t*);
5353 void tns_init(tns_t*, int);
5454 void tns_free(tns_t*);
5555
56−int tns_load(tns_t*, int, const fileinfo_t*, Bool, Bool);
56+bool tns_load(tns_t*, int, const fileinfo_t*, bool, bool);
5757
5858 void tns_render(tns_t*, win_t*);
59−void tns_highlight(tns_t*, win_t*, int, Bool);
59+void tns_highlight(tns_t*, win_t*, int, bool);
6060
61−int tns_move_selection(tns_t*, win_t*, direction_t);
62−int tns_scroll(tns_t*, direction_t);
61+bool tns_move_selection(tns_t*, win_t*, direction_t);
62+bool tns_scroll(tns_t*, direction_t);
6363
6464 int tns_translate(tns_t*, int, int);
6565
M types.h View
@@ -1,6 +1,11 @@
11 #ifndef TYPES_H
22 #define TYPES_H
33
4+typedef enum {
5+ false,
6+ true
7+} bool;
8+
49 typedef enum {
510 MODE_IMAGE,
611 MODE_THUMB
@@ -29,7 +34,7 @@ typedef enum {
2934 typedef struct {
3035 const char *name; /* as given by user */
3136 const char *path; /* always absolute */
32− unsigned char loaded;
37+ bool loaded;
3338 } fileinfo_t;
3439
3540 /* timeouts in milliseconds: */
M window.c View
@@ -17,6 +17,7 @@
1717 */
1818
1919 #define _POSIX_C_SOURCE 200112L
20+#define _WINDOW_CONFIG
2021
2122 #include <string.h>
2223 #include <X11/Xutil.h>
@@ -25,8 +26,6 @@
2526 #include "options.h"
2627 #include "util.h"
2728 #include "window.h"
28−
29−#define _WINDOW_CONFIG
3029 #include "config.h"
3130
3231 static Cursor carrow;
@@ -76,7 +75,7 @@ void win_init(win_t *win) {
7675
7776 win->xwin = 0;
7877 win->pm = 0;
79− win->fullscreen = 0;
78+ win->fullscreen = false;
8079 }
8180
8281 void win_set_sizehints(win_t *win) {
@@ -97,7 +96,7 @@ void win_open(win_t *win) {
9796 win_env_t *e;
9897 XClassHint classhint;
9998 XColor col;
100− char none_data[] = {0, 0, 0, 0, 0, 0, 0, 0};
99+ char none_data[] = { 0, 0, 0, 0, 0, 0, 0, 0 };
101100 Pixmap none;
102101 int gmask;
103102
@@ -158,7 +157,7 @@ void win_open(win_t *win) {
158157 classhint.res_class = "sxiv";
159158 XSetClassHint(e->dpy, win->xwin, &classhint);
160159
161− if (options->fixed)
160+ if (options->fixed_win)
162161 win_set_sizehints(win);
163162
164163 XMapWindow(e->dpy, win->xwin);
@@ -186,11 +185,11 @@ void win_close(win_t *win) {
186185 XCloseDisplay(win->env.dpy);
187186 }
188187
189−int win_configure(win_t *win, XConfigureEvent *c) {
190− int changed;
188+bool win_configure(win_t *win, XConfigureEvent *c) {
189+ bool changed;
191190
192191 if (!win)
193− return 0;
192+ return false;
194193
195194 changed = win->w != c->width || win->h != c->height;
196195
@@ -203,9 +202,9 @@ int win_configure(win_t *win, XConfigureEvent *c) {
203202 return changed;
204203 }
205204
206−int win_moveresize(win_t *win, int x, int y, unsigned int w, unsigned int h) {
205+bool win_moveresize(win_t *win, int x, int y, unsigned int w, unsigned int h) {
207206 if (!win || !win->xwin)
208− return 0;
207+ return false;
209208
210209 x = MAX(0, x);
211210 y = MAX(0, y);
@@ -213,19 +212,19 @@ int win_moveresize(win_t *win, int x, int y, unsigned int w, unsigned int h) {
213212 h = MIN(h, win->env.scrh - 2 * win->bw);
214213
215214 if (win->x == x && win->y == y && win->w == w && win->h == h)
216− return 0;
215+ return false;
217216
218217 win->x = x;
219218 win->y = y;
220219 win->w = w;
221220 win->h = h;
222221
223− if (options->fixed)
222+ if (options->fixed_win)
224223 win_set_sizehints(win);
225224
226225 XMoveResizeWindow(win->env.dpy, win->xwin, win->x, win->y, win->w, win->h);
227226
228− return 1;
227+ return true;
229228 }
230229
231230 void win_toggle_fullscreen(win_t *win) {
@@ -235,7 +234,7 @@ void win_toggle_fullscreen(win_t *win) {
235234 if (!win || !win->xwin)
236235 return;
237236
238− win->fullscreen ^= 1;
237+ win->fullscreen = !win->fullscreen;
239238
240239 memset(&ev, 0, sizeof(ev));
241240 ev.type = ClientMessage;
@@ -279,7 +278,7 @@ void win_draw(win_t *win) {
279278 }
280279
281280 void win_draw_rect(win_t *win, Pixmap pm, int x, int y, int w, int h,
282− Bool fill, int lw, unsigned long col) {
281+ bool fill, int lw, unsigned long col) {
283282 XGCValues gcval;
284283
285284 if (!win || !pm)
M window.h View
@@ -46,9 +46,9 @@ typedef struct {
4646 int y;
4747 unsigned int w;
4848 unsigned int h;
49−
5049 unsigned int bw;
51− unsigned char fullscreen;
50+
51+ bool fullscreen;
5252 } win_t;
5353
5454 extern Atom wm_delete_win;
@@ -57,14 +57,14 @@ void win_init(win_t*);
5757 void win_open(win_t*);
5858 void win_close(win_t*);
5959
60−int win_configure(win_t*, XConfigureEvent*);
61−int win_moveresize(win_t*, int, int, unsigned int, unsigned int);
60+bool win_configure(win_t*, XConfigureEvent*);
61+bool win_moveresize(win_t*, int, int, unsigned int, unsigned int);
6262
6363 void win_toggle_fullscreen(win_t*);
6464
6565 void win_clear(win_t*);
6666 void win_draw(win_t*);
67−void win_draw_rect(win_t*, Pixmap, int, int, int, int, Bool, int,
67+void win_draw_rect(win_t*, Pixmap, int, int, int, int, bool, int,
6868 unsigned long);
6969
7070 void win_set_title(win_t*, const char*);