Krolyxon
Commit 00d4b0f

Branches

Refs →

nsxivmain.c

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