Krolyxon
Commit 8d4e3a5

Branches

Refs →

nsxivmain.c

769 lines · 16.2 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] not an image: %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 && !access(filename, R_OK)) {
197 if (fileidx == filecnt) {
198 filecnt *= 2;
199 filenames = (const char**) s_realloc(filenames,
200 filecnt * sizeof(const char*));
201 }
202 filenames[fileidx++] = filename;
203 return 1;
204 } else {
205 warn("could not open file: %s", filename);
206 return 0;
207 }
208}
209
210int fncmp(const void *a, const void *b) {
211 return strcoll(*((char* const*) a), *((char* const*) b));
212}
213
214void read_dir_rec(const char *dirname) {
215 char *filename;
216 const char **dirnames;
217 int dircnt, diridx;
218 int fcnt, fstart;
219 unsigned char first;
220 size_t len;
221 DIR *dir;
222 struct dirent *dentry;
223 struct stat fstats;
224
225 if (!dirname)
226 return;
227
228 dircnt = DNAME_CNT;
229 diridx = first = 1;
230 dirnames = (const char**) s_malloc(dircnt * sizeof(const char*));
231 dirnames[0] = dirname;
232
233 fcnt = 0;
234 fstart = fileidx;
235
236 while (diridx > 0) {
237 dirname = dirnames[--diridx];
238 if (!(dir = opendir(dirname))) {
239 warn("could not open directory: %s", dirname);
240 } else {
241 while ((dentry = readdir(dir))) {
242 if (!strcmp(dentry->d_name, ".") || !strcmp(dentry->d_name, ".."))
243 continue;
244
245 len = strlen(dirname) + strlen(dentry->d_name) + 2;
246 filename = (char*) s_malloc(len * sizeof(char));
247 snprintf(filename, len, "%s%s%s", dirname,
248 dirname[strlen(dirname)-1] == '/' ? "" : "/", dentry->d_name);
249
250 if (!stat(filename, &fstats) && S_ISDIR(fstats.st_mode)) {
251 if (diridx == dircnt) {
252 dircnt *= 2;
253 dirnames = (const char**) s_realloc(dirnames,
254 dircnt * sizeof(const char*));
255 }
256 dirnames[diridx++] = filename;
257 } else {
258 if (check_append(filename))
259 ++fcnt;
260 else
261 free(filename);
262 }
263 }
264 closedir(dir);
265 }
266
267 if (!first)
268 free((void*) dirname);
269 else
270 first = 0;
271 }
272
273 if (fcnt > 1)
274 qsort(filenames + fstart, fcnt, sizeof(char*), fncmp);
275
276 free(dirnames);
277}
278
279#ifdef EXT_COMMANDS
280int run_command(const char *cline, Bool reload) {
281 int fncnt, fnlen;
282 char *cn, *cmdline;
283 const char *co, *fname;
284 pid_t pid;
285 int ret, status;
286
287 if (!cline || !*cline)
288 return 0;
289
290 fncnt = 0;
291 co = cline - 1;
292 while ((co = strchr(co + 1, '#')))
293 ++fncnt;
294
295 if (!fncnt)
296 return 0;
297
298 ret = 0;
299 fname = filenames[mode == MODE_NORMAL ? fileidx : tns.sel];
300 fnlen = strlen(fname);
301 cn = cmdline = (char*) s_malloc((strlen(cline) + fncnt * (fnlen + 2)) *
302 sizeof(char));
303
304 /* replace all '#' with filename */
305 for (co = cline; *co; ++co) {
306 if (*co == '#') {
307 *cn++ = '"';
308 strcpy(cn, fname);
309 cn += fnlen;
310 *cn++ = '"';
311 } else {
312 *cn++ = *co;
313 }
314 }
315 *cn = '\0';
316
317 if ((pid = fork()) == 0) {
318 execlp("/bin/sh", "/bin/sh", "-c", cmdline, NULL);
319 warn("could not exec: /bin/sh");
320 exit(1);
321 } else if (pid < 0) {
322 warn("could not fork. command line was: %s", cmdline);
323 } else if (reload) {
324 waitpid(pid, &status, 0);
325 if (WIFEXITED(status) && WEXITSTATUS(status) == 0)
326 ret = 1;
327 else
328 warn("child exited with non-zero return value: %d. command line was: %s",
329 WEXITSTATUS(status), cmdline);
330 }
331
332 free(cmdline);
333 return ret;
334}
335#endif /* EXT_COMMANDS */
336
337
338/* event handling */
339
340#define TO_WIN_RESIZE 75000;
341#define TO_IMAGE_DRAG 1000;
342#define TO_CURSOR_HIDE 1500000;
343#define TO_THUMBS_LOAD 75000;
344int timo_cursor;
345int timo_redraw;
346
347unsigned char drag;
348int mox, moy;
349
350void redraw() {
351 if (mode == MODE_NORMAL)
352 img_render(&img, &win);
353 else
354 tns_render(&tns, &win);
355 update_title();
356 timo_redraw = 0;
357}
358
359void on_keypress(XKeyEvent *kev) {
360 int x, y;
361 unsigned int w, h;
362 char key;
363 KeySym ksym;
364 int changed;
365
366 if (!kev)
367 return;
368
369 XLookupString(kev, &key, 1, &ksym, NULL);
370 changed = 0;
371
372#ifdef EXT_COMMANDS
373 /* external commands from commands.h */
374 if (CLEANMASK(kev->state) & ControlMask) {
375 for (x = 0; x < LEN(commands); ++x) {
376 if (commands[x].ksym == ksym) {
377 win_set_cursor(&win, CURSOR_WATCH);
378 if (run_command(commands[x].cmdline, commands[x].reload)) {
379 if (mode == MODE_NORMAL) {
380 img_close(&img, 1);
381 load_image(fileidx);
382 tns_load(&tns, &win, fileidx, filenames[fileidx]);
383 } else {
384 tns_load(&tns, &win, tns.sel, filenames[tns.sel]);
385 }
386 redraw();
387 }
388 win_set_cursor(&win, mode == MODE_NORMAL ? CURSOR_NONE : CURSOR_ARROW);
389 return;
390 }
391 }
392 }
393#endif
394
395 if (mode == MODE_NORMAL) {
396 switch (ksym) {
397 /* navigate image list */
398 case XK_n:
399 case XK_space:
400 if (fileidx + 1 < filecnt)
401 changed = load_image(fileidx + 1);
402 break;
403 case XK_p:
404 case XK_BackSpace:
405 if (fileidx > 0)
406 changed = load_image(fileidx - 1);
407 break;
408 case XK_bracketleft:
409 if (fileidx != 0)
410 changed = load_image(MAX(0, fileidx - 10));
411 break;
412 case XK_bracketright:
413 if (fileidx != filecnt - 1)
414 changed = load_image(MIN(fileidx + 10, filecnt - 1));
415 break;
416 case XK_g:
417 if (fileidx != 0)
418 changed = load_image(0);
419 break;
420 case XK_G:
421 if (fileidx != filecnt - 1)
422 changed = load_image(filecnt - 1);
423 break;
424
425 /* zooming */
426 case XK_plus:
427 case XK_equal:
428 changed = img_zoom_in(&img);
429 break;
430 case XK_minus:
431 changed = img_zoom_out(&img);
432 break;
433 case XK_0:
434 changed = img_zoom(&img, 1.0);
435 break;
436 case XK_w:
437 if ((changed = img_fit_win(&img, &win)))
438 img_center(&img, &win);
439 break;
440
441 /* panning */
442 case XK_h:
443 case XK_Left:
444 changed = img_pan(&img, &win, PAN_LEFT);
445 break;
446 case XK_j:
447 case XK_Down:
448 changed = img_pan(&img, &win, PAN_DOWN);
449 break;
450 case XK_k:
451 case XK_Up:
452 changed = img_pan(&img, &win, PAN_UP);
453 break;
454 case XK_l:
455 case XK_Right:
456 changed = img_pan(&img, &win, PAN_RIGHT);
457 break;
458
459 /* rotation */
460 case XK_less:
461 img_rotate_left(&img, &win);
462 changed = 1;
463 break;
464 case XK_greater:
465 img_rotate_right(&img, &win);
466 changed = 1;
467 break;
468
469 /* control window */
470 case XK_W:
471 x = MAX(0, win.x + img.x);
472 y = MAX(0, win.y + img.y);
473 w = img.w * img.zoom;
474 h = img.h * img.zoom;
475 if ((changed = win_moveresize(&win, x, y, w, h))) {
476 img.x = x - win.x;
477 img.y = y - win.y;
478 }
479 break;
480
481 /* switch to thumbnail mode */
482 case XK_Return:
483 if (!tns.thumbs)
484 tns_init(&tns, filecnt);
485 img_close(&img, 0);
486 mode = MODE_THUMBS;
487 win_set_cursor(&win, CURSOR_ARROW);
488 timo_cursor = 0;
489 tns.sel = fileidx;
490 changed = tns.dirty = 1;
491 break;
492
493 /* miscellaneous */
494 case XK_a:
495 img_toggle_antialias(&img);
496 changed = 1;
497 break;
498 case XK_A:
499 img.alpha ^= 1;
500 changed = 1;
501 break;
502 case XK_r:
503 changed = load_image(fileidx);
504 break;
505 }
506 } else {
507 /* thumbnail mode */
508 switch (ksym) {
509 /* open selected image */
510 case XK_Return:
511 load_image(tns.sel);
512 mode = MODE_NORMAL;
513 win_set_cursor(&win, CURSOR_NONE);
514 changed = 1;
515 break;
516
517 /* move selection */
518 case XK_h:
519 case XK_Left:
520 changed = tns_move_selection(&tns, &win, TNS_LEFT);
521 break;
522 case XK_j:
523 case XK_Down:
524 changed = tns_move_selection(&tns, &win, TNS_DOWN);
525 break;
526 case XK_k:
527 case XK_Up:
528 changed = tns_move_selection(&tns, &win, TNS_UP);
529 break;
530 case XK_l:
531 case XK_Right:
532 changed = tns_move_selection(&tns, &win, TNS_RIGHT);
533 break;
534 case XK_g:
535 if (tns.sel != 0) {
536 tns.sel = 0;
537 changed = tns.dirty = 1;
538 }
539 break;
540 case XK_G:
541 if (tns.sel != tns.cnt - 1) {
542 tns.sel = tns.cnt - 1;
543 changed = tns.dirty = 1;
544 }
545 }
546 }
547
548 /* common key mappings */
549 switch (ksym) {
550 case XK_Escape:
551 cleanup();
552 exit(2);
553 case XK_q:
554 cleanup();
555 exit(0);
556
557 case XK_f:
558 win_toggle_fullscreen(&win);
559 /* render on next configurenotify */
560 break;
561 }
562
563 if (changed)
564 redraw();
565}
566
567void on_buttonpress(XButtonEvent *bev) {
568 int changed, sel;
569 unsigned int mask;
570
571 if (!bev)
572 return;
573
574 mask = CLEANMASK(bev->state);
575 changed = 0;
576
577 if (mode == MODE_NORMAL) {
578 switch (bev->button) {
579 case Button1:
580 if (fileidx + 1 < filecnt)
581 changed = load_image(fileidx + 1);
582 break;
583 case Button2:
584 mox = bev->x;
585 moy = bev->y;
586 win_set_cursor(&win, CURSOR_HAND);
587 timo_cursor = 0;
588 drag = 1;
589 break;
590 case Button3:
591 if (fileidx > 0)
592 changed = load_image(fileidx - 1);
593 break;
594 case Button4:
595 if (mask == ControlMask)
596 changed = img_zoom_in(&img);
597 else if (mask == ShiftMask)
598 changed = img_pan(&img, &win, PAN_LEFT);
599 else
600 changed = img_pan(&img, &win, PAN_UP);
601 break;
602 case Button5:
603 if (mask == ControlMask)
604 changed = img_zoom_out(&img);
605 else if (mask == ShiftMask)
606 changed = img_pan(&img, &win, PAN_RIGHT);
607 else
608 changed = img_pan(&img, &win, PAN_DOWN);
609 break;
610 case 6:
611 changed = img_pan(&img, &win, PAN_LEFT);
612 break;
613 case 7:
614 changed = img_pan(&img, &win, PAN_RIGHT);
615 break;
616 }
617 } else {
618 /* thumbnail mode */
619 switch (bev->button) {
620 case Button1:
621 if ((sel = tns_translate(&tns, bev->x, bev->y)) >= 0) {
622 if (sel == tns.sel) {
623 load_image(tns.sel);
624 mode = MODE_NORMAL;
625 timo_cursor = TO_CURSOR_HIDE;
626 } else {
627 tns_highlight(&tns, &win, tns.sel, False);
628 tns_highlight(&tns, &win, sel, True);
629 tns.sel = sel;
630 }
631 changed = 1;
632 break;
633 }
634 break;
635 case Button4:
636 changed = tns_scroll(&tns, TNS_UP);
637 break;
638 case Button5:
639 changed = tns_scroll(&tns, TNS_DOWN);
640 break;
641 }
642 }
643
644 if (changed)
645 redraw();
646}
647
648void on_motionnotify(XMotionEvent *mev) {
649 if (!mev)
650 return;
651
652 if (mev->x >= 0 && mev->x <= win.w && mev->y >= 0 && mev->y <= win.h) {
653 if (img_move(&img, &win, mev->x - mox, mev->y - moy))
654 timo_redraw = TO_IMAGE_DRAG;
655
656 mox = mev->x;
657 moy = mev->y;
658 }
659}
660
661void run() {
662 int xfd, timeout;
663 fd_set fds;
664 struct timeval tt, t0, t1;
665 XEvent ev;
666
667 timo_cursor = timo_redraw = 0;
668 drag = 0;
669
670 if (mode == MODE_NORMAL)
671 timo_cursor = TO_CURSOR_HIDE;
672
673 while (1) {
674 if (mode == MODE_THUMBS && tns.cnt < filecnt) {
675 win_set_cursor(&win, CURSOR_WATCH);
676 gettimeofday(&t0, 0);
677
678 while (!XPending(win.env.dpy) && tns.cnt < filecnt) {
679 /* tns.cnt is increased inside tns_load */
680 tns_load(&tns, &win, tns.cnt, filenames[tns.cnt]);
681 gettimeofday(&t1, 0);
682 if (TV_TO_DOUBLE(t1) - TV_TO_DOUBLE(t0) >= 0.25)
683 break;
684 }
685 if (tns.cnt == filecnt)
686 win_set_cursor(&win, CURSOR_ARROW);
687 if (!XPending(win.env.dpy)) {
688 redraw();
689 continue;
690 } else {
691 timo_redraw = TO_THUMBS_LOAD;
692 }
693 } else if (timo_cursor || timo_redraw) {
694 gettimeofday(&t0, 0);
695 if (timo_cursor && timo_redraw)
696 timeout = MIN(timo_cursor, timo_redraw);
697 else if (timo_cursor)
698 timeout = timo_cursor;
699 else
700 timeout = timo_redraw;
701 tt.tv_sec = timeout / 1000000;
702 tt.tv_usec = timeout % 1000000;
703 xfd = ConnectionNumber(win.env.dpy);
704 FD_ZERO(&fds);
705 FD_SET(xfd, &fds);
706
707 if (!XPending(win.env.dpy))
708 select(xfd + 1, &fds, 0, 0, &tt);
709 gettimeofday(&t1, 0);
710 timeout = MIN((TV_TO_DOUBLE(t1) - TV_TO_DOUBLE(t0)) * 1000000, timeout);
711
712 /* timeouts fired? */
713 if (timo_cursor) {
714 timo_cursor = MAX(0, timo_cursor - timeout);
715 if (!timo_cursor)
716 win_set_cursor(&win, CURSOR_NONE);
717 }
718 if (timo_redraw) {
719 timo_redraw = MAX(0, timo_redraw - timeout);
720 if (!timo_redraw)
721 redraw();
722 }
723 if (!XPending(win.env.dpy) && (timo_cursor || timo_redraw))
724 continue;
725 }
726
727 if (!XNextEvent(win.env.dpy, &ev)) {
728 switch (ev.type) {
729 case KeyPress:
730 on_keypress(&ev.xkey);
731 break;
732 case ButtonPress:
733 on_buttonpress(&ev.xbutton);
734 break;
735 case ButtonRelease:
736 if (ev.xbutton.button == Button2) {
737 drag = 0;
738 if (mode == MODE_NORMAL) {
739 win_set_cursor(&win, CURSOR_ARROW);
740 timo_cursor = TO_CURSOR_HIDE;
741 }
742 }
743 break;
744 case MotionNotify:
745 if (drag) {
746 on_motionnotify(&ev.xmotion);
747 } else if (mode == MODE_NORMAL) {
748 if (!timo_cursor)
749 win_set_cursor(&win, CURSOR_ARROW);
750 timo_cursor = TO_CURSOR_HIDE;
751 }
752 break;
753 case ConfigureNotify:
754 if (win_configure(&win, &ev.xconfigure)) {
755 timo_redraw = TO_WIN_RESIZE;
756 if (mode == MODE_NORMAL)
757 img.checkpan = 1;
758 else
759 tns.dirty = 1;
760 }
761 break;
762 case ClientMessage:
763 if ((Atom) ev.xclient.data.l[0] == wm_delete_win)
764 return;
765 break;
766 }
767 }
768 }
769}