Krolyxon
Commit dafe7ea

Branches

Refs →

nsxivmain.c

679 lines · 13.9 KB · C

Raw Blame History Download
1/* sxiv: main.c
2 * Copyright (c) 2011 Bert Muennich <muennich at informatik.hu-berlin.de>
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation; either version 2 of the License, or
7 * (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17 */
18
19#include <stdlib.h>
20#include <stdio.h>
21#include <string.h>
22#include <dirent.h>
23#include <sys/select.h>
24#include <sys/stat.h>
25#include <sys/time.h>
26
27#include <X11/Xlib.h>
28#include <X11/Xutil.h>
29#include <X11/keysym.h>
30
31#include "image.h"
32#include "options.h"
33#include "thumbs.h"
34#include "util.h"
35#include "window.h"
36
37typedef enum appmode_e {
38 MODE_NORMAL = 0,
39 MODE_THUMBS
40} appmode_t;
41
42void update_title();
43int check_append(const char*);
44void read_dir_rec(const char*);
45void run();
46
47appmode_t mode;
48img_t img;
49tns_t tns;
50win_t win;
51
52#define DNAME_CNT 512
53#define FNAME_CNT 1024
54const char **filenames;
55int filecnt, fileidx;
56size_t filesize;
57
58#define TITLE_LEN 256
59char win_title[TITLE_LEN];
60
61void cleanup() {
62 static int in = 0;
63
64 if (!in++) {
65 img_close(&img);
66 img_free(&img);
67 tns_free(&tns, &win);
68 win_close(&win);
69 }
70}
71
72int load_image() {
73 struct stat fstats;
74
75 img_close(&img);
76
77 if (!stat(filenames[fileidx], &fstats))
78 filesize = fstats.st_size;
79 else
80 filesize = 0;
81
82 return img_load(&img, filenames[fileidx]);
83}
84
85int main(int argc, char **argv) {
86 int i;
87 const char *filename;
88 struct stat fstats;
89
90 parse_options(argc, argv);
91
92 if (!options->filecnt) {
93 print_usage();
94 exit(1);
95 }
96
97 if (options->recursive || options->from_stdin)
98 filecnt = FNAME_CNT;
99 else
100 filecnt = options->filecnt;
101
102 filenames = (const char**) s_malloc(filecnt * sizeof(const char*));
103 fileidx = 0;
104
105 if (options->from_stdin) {
106 while ((filename = readline(stdin))) {
107 if (!*filename || !check_append(filename))
108 free((void*) filename);
109 }
110 } else {
111 for (i = 0; i < options->filecnt; ++i) {
112 filename = options->filenames[i];
113 if (!stat(filename, &fstats) && S_ISDIR(fstats.st_mode)) {
114 if (options->recursive)
115 read_dir_rec(filename);
116 else
117 warn("ignoring directory: %s", filename);
118 } else {
119 check_append(filename);
120 }
121 }
122 }
123
124 filecnt = fileidx;
125 fileidx = 0;
126
127 if (!filecnt) {
128 fprintf(stderr, "sxiv: no valid image filename given, aborting\n");
129 exit(1);
130 }
131
132 win_open(&win);
133 img_init(&img, &win);
134
135 if (options->thumbnails) {
136 mode = MODE_THUMBS;
137 tns_init(&tns, filecnt);
138 win_clear(&win);
139 win_draw(&win);
140 } else {
141 mode = MODE_NORMAL;
142 tns.thumbs = NULL;
143 load_image();
144 img_render(&img, &win);
145 }
146
147 update_title();
148 run();
149 cleanup();
150
151 return 0;
152}
153
154void update_title() {
155 int n;
156 float size;
157 const char *unit;
158
159 if (mode == MODE_THUMBS) {
160 n = snprintf(win_title, TITLE_LEN, "sxiv: [%d/%d] %s",
161 tns.cnt ? tns.sel + 1 : 0, tns.cnt,
162 tns.cnt ? filenames[tns.sel] : "");
163 } else {
164 if (img.im) {
165 size = filesize;
166 size_readable(&size, &unit);
167 n = snprintf(win_title, TITLE_LEN, "sxiv: [%d/%d] <%d%%> (%.2f%s) %s",
168 fileidx + 1, filecnt, (int) (img.zoom * 100.0), size, unit,
169 filenames[fileidx]);
170 } else {
171 n = snprintf(win_title, TITLE_LEN, "sxiv: [%d/%d] broken: %s",
172 fileidx + 1, filecnt, filenames[fileidx]);
173 }
174 }
175
176 if (n >= TITLE_LEN) {
177 win_title[TITLE_LEN - 2] = '.';
178 win_title[TITLE_LEN - 3] = '.';
179 win_title[TITLE_LEN - 4] = '.';
180 }
181
182 win_set_title(&win, win_title);
183}
184
185int check_append(const char *filename) {
186 if (!filename)
187 return 0;
188
189 if (img_check(filename)) {
190 if (fileidx == filecnt) {
191 filecnt *= 2;
192 filenames = (const char**) s_realloc(filenames,
193 filecnt * sizeof(const char*));
194 }
195 filenames[fileidx++] = filename;
196 return 1;
197 } else {
198 return 0;
199 }
200}
201
202void read_dir_rec(const char *dirname) {
203 char *filename;
204 const char **dirnames;
205 int dircnt, diridx;
206 unsigned char first;
207 size_t len;
208 DIR *dir;
209 struct dirent *dentry;
210 struct stat fstats;
211
212 if (!dirname)
213 return;
214
215 dircnt = DNAME_CNT;
216 diridx = first = 1;
217 dirnames = (const char**) s_malloc(dircnt * sizeof(const char*));
218 dirnames[0] = dirname;
219
220 while (diridx > 0) {
221 dirname = dirnames[--diridx];
222 if (!(dir = opendir(dirname))) {
223 warn("could not open directory: %s", dirname);
224 } else {
225 while ((dentry = readdir(dir))) {
226 if (!strcmp(dentry->d_name, ".") || !strcmp(dentry->d_name, ".."))
227 continue;
228
229 len = strlen(dirname) + strlen(dentry->d_name) + 2;
230 filename = (char*) s_malloc(len * sizeof(char));
231 snprintf(filename, len, "%s/%s", dirname, dentry->d_name);
232
233 if (!stat(filename, &fstats) && S_ISDIR(fstats.st_mode)) {
234 if (diridx == dircnt) {
235 dircnt *= 2;
236 dirnames = (const char**) s_realloc(dirnames,
237 dircnt * sizeof(const char*));
238 }
239 dirnames[diridx++] = filename;
240 } else {
241 if (!check_append(filename))
242 free(filename);
243 }
244 }
245 closedir(dir);
246 }
247
248 if (!first)
249 free((void*) dirname);
250 else
251 first = 0;
252 }
253
254 free(dirnames);
255}
256
257
258/* event handling */
259
260#define TO_WIN_RESIZE 75000;
261#define TO_IMAGE_DRAG 1000;
262#define TO_CURSOR_HIDE 1500000;
263#define TO_THUMBS_LOAD 75000;
264int timo_cursor;
265int timo_redraw;
266
267unsigned char drag;
268int mox, moy;
269
270void redraw() {
271 if (mode == MODE_NORMAL)
272 img_render(&img, &win);
273 else
274 tns_render(&tns, &win);
275 update_title();
276 timo_redraw = 0;
277}
278
279void on_keypress(XKeyEvent *kev) {
280 int x, y;
281 unsigned int w, h;
282 char key;
283 KeySym ksym;
284 int changed;
285
286 if (!kev)
287 return;
288
289 XLookupString(kev, &key, 1, &ksym, NULL);
290 changed = 0;
291
292 if (mode == MODE_NORMAL) {
293 switch (ksym) {
294 /* navigate image list */
295 case XK_n:
296 case XK_space:
297 if (fileidx + 1 < filecnt) {
298 ++fileidx;
299 changed = load_image();
300 }
301 break;
302 case XK_p:
303 case XK_BackSpace:
304 if (fileidx > 0) {
305 --fileidx;
306 changed = load_image();
307 }
308 break;
309 case XK_bracketleft:
310 if (fileidx != 0) {
311 fileidx = MAX(0, fileidx - 10);
312 changed = load_image();
313 }
314 break;
315 case XK_bracketright:
316 if (fileidx != filecnt - 1) {
317 fileidx = MIN(fileidx + 10, filecnt - 1);
318 changed = load_image();
319 }
320 break;
321 case XK_g:
322 if (fileidx != 0) {
323 fileidx = 0;
324 changed = load_image();
325 }
326 break;
327 case XK_G:
328 if (fileidx != filecnt - 1) {
329 fileidx = filecnt - 1;
330 changed = load_image();
331 }
332 break;
333
334 /* zooming */
335 case XK_plus:
336 case XK_equal:
337 changed = img_zoom_in(&img);
338 break;
339 case XK_minus:
340 changed = img_zoom_out(&img);
341 break;
342 case XK_0:
343 changed = img_zoom(&img, 1.0);
344 break;
345 case XK_w:
346 if ((changed = img_fit_win(&img, &win)))
347 img_center(&img, &win);
348 break;
349
350 /* panning */
351 case XK_h:
352 case XK_Left:
353 changed = img_pan(&img, &win, PAN_LEFT);
354 break;
355 case XK_j:
356 case XK_Down:
357 changed = img_pan(&img, &win, PAN_DOWN);
358 break;
359 case XK_k:
360 case XK_Up:
361 changed = img_pan(&img, &win, PAN_UP);
362 break;
363 case XK_l:
364 case XK_Right:
365 changed = img_pan(&img, &win, PAN_RIGHT);
366 break;
367
368 /* rotation */
369 case XK_less:
370 img_rotate_left(&img, &win);
371 changed = 1;
372 break;
373 case XK_greater:
374 img_rotate_right(&img, &win);
375 changed = 1;
376 break;
377
378 /* control window */
379 case XK_W:
380 x = MAX(0, win.x + img.x);
381 y = MAX(0, win.y + img.y);
382 w = img.w * img.zoom;
383 h = img.h * img.zoom;
384 if ((changed = win_moveresize(&win, x, y, w, h))) {
385 img.x = x - win.x;
386 img.y = y - win.y;
387 }
388 break;
389
390 /* switch to thumbnail mode */
391 case XK_Return:
392 if (!tns.thumbs)
393 tns_init(&tns, filecnt);
394 img_close(&img);
395 mode = MODE_THUMBS;
396 win_set_cursor(&win, CURSOR_ARROW);
397 timo_cursor = 0;
398 tns.sel = fileidx;
399 changed = tns.dirty = 1;
400 break;
401
402 /* miscellaneous */
403 case XK_a:
404 img_toggle_antialias(&img);
405 changed = 1;
406 break;
407 case XK_r:
408 changed = load_image();
409 break;
410 }
411 } else {
412 /* thumbnail mode */
413 switch (ksym) {
414 /* open selected image */
415 case XK_Return:
416 fileidx = tns.sel;
417 load_image();
418 mode = MODE_NORMAL;
419 win_set_cursor(&win, CURSOR_NONE);
420 changed = 1;
421 break;
422
423 /* move selection */
424 case XK_h:
425 case XK_Left:
426 changed = tns_move_selection(&tns, &win, TNS_LEFT);
427 break;
428 case XK_j:
429 case XK_Down:
430 changed = tns_move_selection(&tns, &win, TNS_DOWN);
431 break;
432 case XK_k:
433 case XK_Up:
434 changed = tns_move_selection(&tns, &win, TNS_UP);
435 break;
436 case XK_l:
437 case XK_Right:
438 changed = tns_move_selection(&tns, &win, TNS_RIGHT);
439 break;
440 case XK_g:
441 if (tns.sel != 0) {
442 tns.sel = 0;
443 changed = tns.dirty = 1;
444 }
445 break;
446 case XK_G:
447 if (tns.sel != tns.cnt - 1) {
448 tns.sel = tns.cnt - 1;
449 changed = tns.dirty = 1;
450 }
451 }
452 }
453
454 /* common key mappings */
455 switch (ksym) {
456 case XK_Escape:
457 cleanup();
458 exit(2);
459 case XK_q:
460 cleanup();
461 exit(0);
462
463 case XK_f:
464 win_toggle_fullscreen(&win);
465 /* render on next configurenotify */
466 break;
467 }
468
469 if (changed)
470 redraw();
471}
472
473void on_buttonpress(XButtonEvent *bev) {
474 int changed, sel;
475 unsigned int mask;
476
477 if (!bev)
478 return;
479
480 mask = CLEANMASK(bev->state);
481 changed = 0;
482
483 if (mode == MODE_NORMAL) {
484 switch (bev->button) {
485 case Button1:
486 if (fileidx + 1 < filecnt) {
487 ++fileidx;
488 changed = load_image();
489 }
490 break;
491 case Button2:
492 mox = bev->x;
493 moy = bev->y;
494 win_set_cursor(&win, CURSOR_HAND);
495 timo_cursor = 0;
496 drag = 1;
497 break;
498 case Button3:
499 if (fileidx > 0) {
500 --fileidx;
501 changed = load_image();
502 }
503 break;
504 case Button4:
505 if (mask == ControlMask)
506 changed = img_zoom_in(&img);
507 else if (mask == ShiftMask)
508 changed = img_pan(&img, &win, PAN_LEFT);
509 else
510 changed = img_pan(&img, &win, PAN_UP);
511 break;
512 case Button5:
513 if (mask == ControlMask)
514 changed = img_zoom_out(&img);
515 else if (mask == ShiftMask)
516 changed = img_pan(&img, &win, PAN_RIGHT);
517 else
518 changed = img_pan(&img, &win, PAN_DOWN);
519 break;
520 case 6:
521 changed = img_pan(&img, &win, PAN_LEFT);
522 break;
523 case 7:
524 changed = img_pan(&img, &win, PAN_RIGHT);
525 break;
526 }
527 } else {
528 /* thumbnail mode */
529 switch (bev->button) {
530 case Button1:
531 if ((sel = tns_translate(&tns, bev->x, bev->y)) >= 0) {
532 if (sel == tns.sel) {
533 fileidx = tns.sel;
534 load_image();
535 mode = MODE_NORMAL;
536 timo_cursor = TO_CURSOR_HIDE;
537 } else {
538 tns_highlight(&tns, &win, tns.sel, False);
539 tns_highlight(&tns, &win, sel, True);
540 tns.sel = sel;
541 }
542 changed = 1;
543 break;
544 }
545 break;
546 case Button4:
547 changed = tns_scroll(&tns, TNS_UP);
548 break;
549 case Button5:
550 changed = tns_scroll(&tns, TNS_DOWN);
551 break;
552 }
553 }
554
555 if (changed)
556 redraw();
557}
558
559void on_motionnotify(XMotionEvent *mev) {
560 if (!mev)
561 return;
562
563 if (mev->x >= 0 && mev->x <= win.w && mev->y >= 0 && mev->y <= win.h) {
564 if (img_move(&img, &win, mev->x - mox, mev->y - moy))
565 timo_redraw = TO_IMAGE_DRAG;
566
567 mox = mev->x;
568 moy = mev->y;
569 }
570}
571
572void run() {
573 int xfd, timeout;
574 fd_set fds;
575 struct timeval tt, t0, t1;
576 XEvent ev;
577
578 timo_cursor = timo_redraw = 0;
579 drag = 0;
580
581 if (mode == MODE_NORMAL)
582 timo_cursor = TO_CURSOR_HIDE;
583
584 while (1) {
585 if (mode == MODE_THUMBS && tns.cnt < filecnt) {
586 win_set_cursor(&win, CURSOR_WATCH);
587 gettimeofday(&t0, 0);
588
589 while (!XPending(win.env.dpy) && tns.cnt < filecnt) {
590 tns_load(&tns, &win, filenames[tns.cnt]);
591 gettimeofday(&t1, 0);
592 if (TV_TO_DOUBLE(t1) - TV_TO_DOUBLE(t0) >= 0.25)
593 break;
594 }
595 if (tns.cnt == filecnt)
596 win_set_cursor(&win, CURSOR_ARROW);
597 if (!XPending(win.env.dpy)) {
598 redraw();
599 continue;
600 } else {
601 timo_redraw = TO_THUMBS_LOAD;
602 }
603 } else if (timo_cursor || timo_redraw) {
604 gettimeofday(&t0, 0);
605 if (timo_cursor && timo_redraw)
606 timeout = MIN(timo_cursor, timo_redraw);
607 else if (timo_cursor)
608 timeout = timo_cursor;
609 else
610 timeout = timo_redraw;
611 tt.tv_sec = timeout / 1000000;
612 tt.tv_usec = timeout % 1000000;
613 xfd = ConnectionNumber(win.env.dpy);
614 FD_ZERO(&fds);
615 FD_SET(xfd, &fds);
616
617 if (!XPending(win.env.dpy))
618 select(xfd + 1, &fds, 0, 0, &tt);
619 gettimeofday(&t1, 0);
620 timeout = MIN((TV_TO_DOUBLE(t1) - TV_TO_DOUBLE(t0)) * 1000000, timeout);
621
622 /* timeouts fired? */
623 if (timo_cursor) {
624 timo_cursor = MAX(0, timo_cursor - timeout);
625 if (!timo_cursor)
626 win_set_cursor(&win, CURSOR_NONE);
627 }
628 if (timo_redraw) {
629 timo_redraw = MAX(0, timo_redraw - timeout);
630 if (!timo_redraw)
631 redraw();
632 }
633 if (!XPending(win.env.dpy) && (timo_cursor || timo_redraw))
634 continue;
635 }
636
637 if (!XNextEvent(win.env.dpy, &ev)) {
638 switch (ev.type) {
639 case KeyPress:
640 on_keypress(&ev.xkey);
641 break;
642 case ButtonPress:
643 on_buttonpress(&ev.xbutton);
644 break;
645 case ButtonRelease:
646 if (ev.xbutton.button == Button2) {
647 drag = 0;
648 if (mode == MODE_NORMAL) {
649 win_set_cursor(&win, CURSOR_ARROW);
650 timo_cursor = TO_CURSOR_HIDE;
651 }
652 }
653 break;
654 case MotionNotify:
655 if (drag) {
656 on_motionnotify(&ev.xmotion);
657 } else if (mode == MODE_NORMAL) {
658 if (!timo_cursor)
659 win_set_cursor(&win, CURSOR_ARROW);
660 timo_cursor = TO_CURSOR_HIDE;
661 }
662 break;
663 case ConfigureNotify:
664 if (win_configure(&win, &ev.xconfigure)) {
665 timo_redraw = TO_WIN_RESIZE;
666 if (mode == MODE_NORMAL)
667 img.checkpan = 1;
668 else
669 tns.dirty = 1;
670 }
671 break;
672 case ClientMessage:
673 if ((Atom) ev.xclient.data.l[0] == wm_delete_win)
674 return;
675 break;
676 }
677 }
678 }
679}