Krolyxon
Commit 426edfb

Branches

Refs →

nsxivmain.c

774 lines · 16.3 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#include <sys/wait.h>
27#include <unistd.h>
28
29#include <X11/Xlib.h>
30#include <X11/Xutil.h>
31#include <X11/keysym.h>
32
33#include "config.h"
34#include "image.h"
35#include "options.h"
36#include "thumbs.h"
37#include "util.h"
38#include "window.h"
39
40#ifdef EXT_COMMANDS
41#include "commands.h"
42#endif
43
44typedef enum {
45 MODE_NORMAL = 0,
46 MODE_THUMBS
47} appmode_t;
48
49void update_title();
50int check_append(const char*);
51void read_dir_rec(const char*);
52void run();
53
54appmode_t mode;
55img_t img;
56tns_t tns;
57win_t win;
58
59#define DNAME_CNT 512
60#define FNAME_CNT 1024
61const char **filenames;
62int filecnt, fileidx;
63size_t filesize;
64
65#define TITLE_LEN 256
66char win_title[TITLE_LEN];
67
68void cleanup() {
69 static int in = 0;
70
71 if (!in++) {
72 img_close(&img, 0);
73 img_free(&img);
74 tns_free(&tns, &win);
75 win_close(&win);
76 }
77}
78
79int load_image(int new) {
80 struct stat fstats;
81
82 if (new >= 0 && new < filecnt) {
83 img_close(&img, 0);
84 fileidx = new;
85 if (!stat(filenames[fileidx], &fstats))
86 filesize = fstats.st_size;
87 else
88 filesize = 0;
89 return img_load(&img, filenames[fileidx]);
90 } else {
91 return 0;
92 }
93}
94
95int main(int argc, char **argv) {
96 int i;
97 const char *filename;
98 struct stat fstats;
99
100 parse_options(argc, argv);
101
102 if (!options->filecnt) {
103 print_usage();
104 exit(1);
105 }
106
107 if (options->recursive || options->from_stdin)
108 filecnt = FNAME_CNT;
109 else
110 filecnt = options->filecnt;
111
112 filenames = (const char**) s_malloc(filecnt * sizeof(const char*));
113 fileidx = 0;
114
115 if (options->from_stdin) {
116 while ((filename = readline(stdin))) {
117 if (!*filename || !check_append(filename))
118 free((void*) filename);
119 }
120 } else {
121 for (i = 0; i < options->filecnt; ++i) {
122 filename = options->filenames[i];
123 if (!stat(filename, &fstats) && S_ISDIR(fstats.st_mode)) {
124 if (options->recursive)
125 read_dir_rec(filename);
126 else
127 warn("ignoring directory: %s", filename);
128 } else {
129 check_append(filename);
130 }
131 }
132 }
133
134 filecnt = fileidx;
135 fileidx = 0;
136
137 if (!filecnt) {
138 fprintf(stderr, "sxiv: no valid image filename given, aborting\n");
139 exit(1);
140 }
141
142 win_open(&win);
143 img_init(&img, &win);
144
145 if (options->thumbnails) {
146 mode = MODE_THUMBS;
147 tns_init(&tns, filecnt);
148 win_clear(&win);
149 win_draw(&win);
150 } else {
151 mode = MODE_NORMAL;
152 tns.thumbs = NULL;
153 load_image(fileidx);
154 img_render(&img, &win);
155 }
156
157 update_title();
158 run();
159 cleanup();
160
161 return 0;
162}
163
164void update_title() {
165 int n;
166 float size;
167 const char *unit;
168
169 if (mode == MODE_THUMBS) {
170 n = snprintf(win_title, TITLE_LEN, "sxiv: [%d/%d] %s",
171 tns.cnt ? tns.sel + 1 : 0, tns.cnt,
172 tns.cnt ? filenames[tns.sel] : "");
173 } else {
174 if (img.im) {
175 size = filesize;
176 size_readable(&size, &unit);
177 n = snprintf(win_title, TITLE_LEN, "sxiv: [%d/%d] <%d%%> (%.2f%s) %s",
178 fileidx + 1, filecnt, (int) (img.zoom * 100.0), size, unit,
179 filenames[fileidx]);
180 } else {
181 n = snprintf(win_title, TITLE_LEN, "sxiv: [%d/%d] invalid: %s",
182 fileidx + 1, filecnt, filenames[fileidx]);
183 }
184 }
185
186 if (n >= TITLE_LEN) {
187 win_title[TITLE_LEN - 2] = '.';
188 win_title[TITLE_LEN - 3] = '.';
189 win_title[TITLE_LEN - 4] = '.';
190 }
191
192 win_set_title(&win, win_title);
193}
194
195int check_append(const char *filename) {
196 if (!filename)
197 return 0;
198
199 if (access(filename, R_OK)) {
200 warn("could not open file: %s", filename);
201 return 0;
202 } else if (img_check(filename)) {
203 if (fileidx == filecnt) {
204 filecnt *= 2;
205 filenames = (const char**) s_realloc(filenames,
206 filecnt * sizeof(const char*));
207 }
208 filenames[fileidx++] = filename;
209 return 1;
210 } else {
211 return 0;
212 }
213}
214
215int fncmp(const void *a, const void *b) {
216 return strcoll(*((char* const*) a), *((char* const*) b));
217}
218
219void read_dir_rec(const char *dirname) {
220 char *filename;
221 const char **dirnames;
222 int dircnt, diridx;
223 int fcnt, fstart;
224 unsigned char first;
225 size_t len;
226 DIR *dir;
227 struct dirent *dentry;
228 struct stat fstats;
229
230 if (!dirname)
231 return;
232
233 dircnt = DNAME_CNT;
234 diridx = first = 1;
235 dirnames = (const char**) s_malloc(dircnt * sizeof(const char*));
236 dirnames[0] = dirname;
237
238 fcnt = 0;
239 fstart = fileidx;
240
241 while (diridx > 0) {
242 dirname = dirnames[--diridx];
243 if (!(dir = opendir(dirname))) {
244 warn("could not open directory: %s", dirname);
245 } else {
246 while ((dentry = readdir(dir))) {
247 if (!strcmp(dentry->d_name, ".") || !strcmp(dentry->d_name, ".."))
248 continue;
249
250 len = strlen(dirname) + strlen(dentry->d_name) + 2;
251 filename = (char*) s_malloc(len * sizeof(char));
252 snprintf(filename, len, "%s%s%s", dirname,
253 dirname[strlen(dirname)-1] == '/' ? "" : "/", dentry->d_name);
254
255 if (!stat(filename, &fstats) && S_ISDIR(fstats.st_mode)) {
256 if (diridx == dircnt) {
257 dircnt *= 2;
258 dirnames = (const char**) s_realloc(dirnames,
259 dircnt * sizeof(const char*));
260 }
261 dirnames[diridx++] = filename;
262 } else {
263 if (check_append(filename))
264 ++fcnt;
265 else
266 free(filename);
267 }
268 }
269 closedir(dir);
270 }
271
272 if (!first)
273 free((void*) dirname);
274 else
275 first = 0;
276 }
277
278 if (fcnt > 1)
279 qsort(filenames + fstart, fcnt, sizeof(char*), fncmp);
280
281 free(dirnames);
282}
283
284#ifdef EXT_COMMANDS
285int run_command(const char *cline, Bool reload) {
286 int fncnt, fnlen;
287 char *cn, *cmdline;
288 const char *co, *fname;
289 pid_t pid;
290 int ret, status;
291
292 if (!cline || !*cline)
293 return 0;
294
295 fncnt = 0;
296 co = cline - 1;
297 while ((co = strchr(co + 1, '#')))
298 ++fncnt;
299
300 if (!fncnt)
301 return 0;
302
303 ret = 0;
304 fname = filenames[mode == MODE_NORMAL ? fileidx : tns.sel];
305 fnlen = strlen(fname);
306 cn = cmdline = (char*) s_malloc((strlen(cline) + fncnt * (fnlen + 2)) *
307 sizeof(char));
308
309 /* replace all '#' with filename */
310 for (co = cline; *co; ++co) {
311 if (*co == '#') {
312 *cn++ = '"';
313 strcpy(cn, fname);
314 cn += fnlen;
315 *cn++ = '"';
316 } else {
317 *cn++ = *co;
318 }
319 }
320 *cn = '\0';
321
322 if ((pid = fork()) == 0) {
323 execlp("/bin/sh", "/bin/sh", "-c", cmdline, NULL);
324 warn("could not exec: /bin/sh");
325 exit(1);
326 } else if (pid < 0) {
327 warn("could not fork. command line was: %s", cmdline);
328 } else if (reload) {
329 waitpid(pid, &status, 0);
330 if (WIFEXITED(status) && WEXITSTATUS(status) == 0)
331 ret = 1;
332 else
333 warn("child exited with non-zero return value: %d. command line was: %s",
334 WEXITSTATUS(status), cmdline);
335 }
336
337 free(cmdline);
338 return ret;
339}
340#endif /* EXT_COMMANDS */
341
342
343/* event handling */
344
345#define TO_WIN_RESIZE 75000;
346#define TO_IMAGE_DRAG 1000;
347#define TO_CURSOR_HIDE 1500000;
348#define TO_THUMBS_LOAD 75000;
349int timo_cursor;
350int timo_redraw;
351
352unsigned char drag;
353int mox, moy;
354
355void redraw() {
356 if (mode == MODE_NORMAL)
357 img_render(&img, &win);
358 else
359 tns_render(&tns, &win);
360 update_title();
361 timo_redraw = 0;
362}
363
364void on_keypress(XKeyEvent *kev) {
365 int x, y;
366 unsigned int w, h;
367 char key;
368 KeySym ksym;
369 int changed;
370
371 if (!kev)
372 return;
373
374 XLookupString(kev, &key, 1, &ksym, NULL);
375 changed = 0;
376
377#ifdef EXT_COMMANDS
378 /* external commands from commands.h */
379 if (CLEANMASK(kev->state) & ControlMask) {
380 for (x = 0; x < LEN(commands); ++x) {
381 if (commands[x].ksym == ksym) {
382 win_set_cursor(&win, CURSOR_WATCH);
383 if (run_command(commands[x].cmdline, commands[x].reload)) {
384 if (mode == MODE_NORMAL) {
385 img_close(&img, 1);
386 load_image(fileidx);
387 tns_load(&tns, &win, fileidx, filenames[fileidx]);
388 } else {
389 tns_load(&tns, &win, tns.sel, filenames[tns.sel]);
390 }
391 redraw();
392 }
393 win_set_cursor(&win, mode == MODE_NORMAL ? CURSOR_NONE : CURSOR_ARROW);
394 return;
395 }
396 }
397 }
398#endif
399
400 if (mode == MODE_NORMAL) {
401 switch (ksym) {
402 /* navigate image list */
403 case XK_n:
404 case XK_space:
405 if (fileidx + 1 < filecnt)
406 changed = load_image(fileidx + 1);
407 break;
408 case XK_p:
409 case XK_BackSpace:
410 if (fileidx > 0)
411 changed = load_image(fileidx - 1);
412 break;
413 case XK_bracketleft:
414 if (fileidx != 0)
415 changed = load_image(MAX(0, fileidx - 10));
416 break;
417 case XK_bracketright:
418 if (fileidx != filecnt - 1)
419 changed = load_image(MIN(fileidx + 10, filecnt - 1));
420 break;
421 case XK_g:
422 if (fileidx != 0)
423 changed = load_image(0);
424 break;
425 case XK_G:
426 if (fileidx != filecnt - 1)
427 changed = load_image(filecnt - 1);
428 break;
429
430 /* zooming */
431 case XK_plus:
432 case XK_equal:
433 changed = img_zoom_in(&img);
434 break;
435 case XK_minus:
436 changed = img_zoom_out(&img);
437 break;
438 case XK_0:
439 changed = img_zoom(&img, 1.0);
440 break;
441 case XK_w:
442 if ((changed = img_fit_win(&img, &win)))
443 img_center(&img, &win);
444 break;
445
446 /* panning */
447 case XK_h:
448 case XK_Left:
449 changed = img_pan(&img, &win, PAN_LEFT);
450 break;
451 case XK_j:
452 case XK_Down:
453 changed = img_pan(&img, &win, PAN_DOWN);
454 break;
455 case XK_k:
456 case XK_Up:
457 changed = img_pan(&img, &win, PAN_UP);
458 break;
459 case XK_l:
460 case XK_Right:
461 changed = img_pan(&img, &win, PAN_RIGHT);
462 break;
463
464 /* rotation */
465 case XK_less:
466 img_rotate_left(&img, &win);
467 changed = 1;
468 break;
469 case XK_greater:
470 img_rotate_right(&img, &win);
471 changed = 1;
472 break;
473
474 /* control window */
475 case XK_W:
476 x = MAX(0, win.x + img.x);
477 y = MAX(0, win.y + img.y);
478 w = img.w * img.zoom;
479 h = img.h * img.zoom;
480 if ((changed = win_moveresize(&win, x, y, w, h))) {
481 img.x = x - win.x;
482 img.y = y - win.y;
483 }
484 break;
485
486 /* switch to thumbnail mode */
487 case XK_Return:
488 if (!tns.thumbs)
489 tns_init(&tns, filecnt);
490 img_close(&img, 0);
491 mode = MODE_THUMBS;
492 win_set_cursor(&win, CURSOR_ARROW);
493 timo_cursor = 0;
494 tns.sel = fileidx;
495 changed = tns.dirty = 1;
496 break;
497
498 /* miscellaneous */
499 case XK_a:
500 img_toggle_antialias(&img);
501 changed = 1;
502 break;
503 case XK_A:
504 img.alpha ^= 1;
505 changed = 1;
506 break;
507 case XK_r:
508 changed = load_image(fileidx);
509 break;
510 }
511 } else {
512 /* thumbnail mode */
513 switch (ksym) {
514 /* open selected image */
515 case XK_Return:
516 load_image(tns.sel);
517 mode = MODE_NORMAL;
518 win_set_cursor(&win, CURSOR_NONE);
519 changed = 1;
520 break;
521
522 /* move selection */
523 case XK_h:
524 case XK_Left:
525 changed = tns_move_selection(&tns, &win, TNS_LEFT);
526 break;
527 case XK_j:
528 case XK_Down:
529 changed = tns_move_selection(&tns, &win, TNS_DOWN);
530 break;
531 case XK_k:
532 case XK_Up:
533 changed = tns_move_selection(&tns, &win, TNS_UP);
534 break;
535 case XK_l:
536 case XK_Right:
537 changed = tns_move_selection(&tns, &win, TNS_RIGHT);
538 break;
539 case XK_g:
540 if (tns.sel != 0) {
541 tns.sel = 0;
542 changed = tns.dirty = 1;
543 }
544 break;
545 case XK_G:
546 if (tns.sel != tns.cnt - 1) {
547 tns.sel = tns.cnt - 1;
548 changed = tns.dirty = 1;
549 }
550 }
551 }
552
553 /* common key mappings */
554 switch (ksym) {
555 case XK_Escape:
556 cleanup();
557 exit(2);
558 case XK_q:
559 cleanup();
560 exit(0);
561
562 case XK_f:
563 win_toggle_fullscreen(&win);
564 /* render on next configurenotify */
565 break;
566 }
567
568 if (changed)
569 redraw();
570}
571
572void on_buttonpress(XButtonEvent *bev) {
573 int changed, sel;
574 unsigned int mask;
575
576 if (!bev)
577 return;
578
579 mask = CLEANMASK(bev->state);
580 changed = 0;
581
582 if (mode == MODE_NORMAL) {
583 switch (bev->button) {
584 case Button1:
585 if (fileidx + 1 < filecnt)
586 changed = load_image(fileidx + 1);
587 break;
588 case Button2:
589 mox = bev->x;
590 moy = bev->y;
591 win_set_cursor(&win, CURSOR_HAND);
592 timo_cursor = 0;
593 drag = 1;
594 break;
595 case Button3:
596 if (fileidx > 0)
597 changed = load_image(fileidx - 1);
598 break;
599 case Button4:
600 if (mask == ControlMask)
601 changed = img_zoom_in(&img);
602 else if (mask == ShiftMask)
603 changed = img_pan(&img, &win, PAN_LEFT);
604 else
605 changed = img_pan(&img, &win, PAN_UP);
606 break;
607 case Button5:
608 if (mask == ControlMask)
609 changed = img_zoom_out(&img);
610 else if (mask == ShiftMask)
611 changed = img_pan(&img, &win, PAN_RIGHT);
612 else
613 changed = img_pan(&img, &win, PAN_DOWN);
614 break;
615 case 6:
616 changed = img_pan(&img, &win, PAN_LEFT);
617 break;
618 case 7:
619 changed = img_pan(&img, &win, PAN_RIGHT);
620 break;
621 }
622 } else {
623 /* thumbnail mode */
624 switch (bev->button) {
625 case Button1:
626 if ((sel = tns_translate(&tns, bev->x, bev->y)) >= 0) {
627 if (sel == tns.sel) {
628 load_image(tns.sel);
629 mode = MODE_NORMAL;
630 timo_cursor = TO_CURSOR_HIDE;
631 } else {
632 tns_highlight(&tns, &win, tns.sel, False);
633 tns_highlight(&tns, &win, sel, True);
634 tns.sel = sel;
635 }
636 changed = 1;
637 break;
638 }
639 break;
640 case Button4:
641 changed = tns_scroll(&tns, TNS_UP);
642 break;
643 case Button5:
644 changed = tns_scroll(&tns, TNS_DOWN);
645 break;
646 }
647 }
648
649 if (changed)
650 redraw();
651}
652
653void on_motionnotify(XMotionEvent *mev) {
654 if (!mev)
655 return;
656
657 if (mev->x >= 0 && mev->x <= win.w && mev->y >= 0 && mev->y <= win.h) {
658 if (img_move(&img, &win, mev->x - mox, mev->y - moy))
659 timo_redraw = TO_IMAGE_DRAG;
660
661 mox = mev->x;
662 moy = mev->y;
663 }
664}
665
666void run() {
667 int xfd, timeout;
668 fd_set fds;
669 struct timeval tt, t0, t1;
670 XEvent ev;
671
672 timo_cursor = timo_redraw = 0;
673 drag = 0;
674
675 if (mode == MODE_NORMAL)
676 timo_cursor = TO_CURSOR_HIDE;
677
678 while (1) {
679 if (mode == MODE_THUMBS && tns.cnt < filecnt) {
680 win_set_cursor(&win, CURSOR_WATCH);
681 gettimeofday(&t0, 0);
682
683 while (!XPending(win.env.dpy) && tns.cnt < filecnt) {
684 /* tns.cnt is increased inside tns_load */
685 tns_load(&tns, &win, tns.cnt, filenames[tns.cnt]);
686 gettimeofday(&t1, 0);
687 if (TV_TO_DOUBLE(t1) - TV_TO_DOUBLE(t0) >= 0.25)
688 break;
689 }
690 if (tns.cnt == filecnt)
691 win_set_cursor(&win, CURSOR_ARROW);
692 if (!XPending(win.env.dpy)) {
693 redraw();
694 continue;
695 } else {
696 timo_redraw = TO_THUMBS_LOAD;
697 }
698 } else if (timo_cursor || timo_redraw) {
699 gettimeofday(&t0, 0);
700 if (timo_cursor && timo_redraw)
701 timeout = MIN(timo_cursor, timo_redraw);
702 else if (timo_cursor)
703 timeout = timo_cursor;
704 else
705 timeout = timo_redraw;
706 tt.tv_sec = timeout / 1000000;
707 tt.tv_usec = timeout % 1000000;
708 xfd = ConnectionNumber(win.env.dpy);
709 FD_ZERO(&fds);
710 FD_SET(xfd, &fds);
711
712 if (!XPending(win.env.dpy))
713 select(xfd + 1, &fds, 0, 0, &tt);
714 gettimeofday(&t1, 0);
715 timeout = MIN((TV_TO_DOUBLE(t1) - TV_TO_DOUBLE(t0)) * 1000000, timeout);
716
717 /* timeouts fired? */
718 if (timo_cursor) {
719 timo_cursor = MAX(0, timo_cursor - timeout);
720 if (!timo_cursor)
721 win_set_cursor(&win, CURSOR_NONE);
722 }
723 if (timo_redraw) {
724 timo_redraw = MAX(0, timo_redraw - timeout);
725 if (!timo_redraw)
726 redraw();
727 }
728 if (!XPending(win.env.dpy) && (timo_cursor || timo_redraw))
729 continue;
730 }
731
732 if (!XNextEvent(win.env.dpy, &ev)) {
733 switch (ev.type) {
734 case KeyPress:
735 on_keypress(&ev.xkey);
736 break;
737 case ButtonPress:
738 on_buttonpress(&ev.xbutton);
739 break;
740 case ButtonRelease:
741 if (ev.xbutton.button == Button2) {
742 drag = 0;
743 if (mode == MODE_NORMAL) {
744 win_set_cursor(&win, CURSOR_ARROW);
745 timo_cursor = TO_CURSOR_HIDE;
746 }
747 }
748 break;
749 case MotionNotify:
750 if (drag) {
751 on_motionnotify(&ev.xmotion);
752 } else if (mode == MODE_NORMAL) {
753 if (!timo_cursor)
754 win_set_cursor(&win, CURSOR_ARROW);
755 timo_cursor = TO_CURSOR_HIDE;
756 }
757 break;
758 case ConfigureNotify:
759 if (win_configure(&win, &ev.xconfigure)) {
760 timo_redraw = TO_WIN_RESIZE;
761 if (mode == MODE_NORMAL)
762 img.checkpan = 1;
763 else
764 tns.dirty = 1;
765 }
766 break;
767 case ClientMessage:
768 if ((Atom) ev.xclient.data.l[0] == wm_delete_win)
769 return;
770 break;
771 }
772 }
773 }
774}