Krolyxon
Commit 090ee54

Branches

Refs →

nsxivmain.c

680 lines · 14.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
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(int new) {
73 struct stat fstats;
74
75 img_close(&img);
76 fileidx = new;
77
78 if (!stat(filenames[fileidx], &fstats))
79 filesize = fstats.st_size;
80 else
81 filesize = 0;
82
83 return img_load(&img, filenames[fileidx]);
84}
85
86int main(int argc, char **argv) {
87 int i;
88 const char *filename;
89 struct stat fstats;
90
91 parse_options(argc, argv);
92
93 if (!options->filecnt) {
94 print_usage();
95 exit(1);
96 }
97
98 if (options->recursive || options->from_stdin)
99 filecnt = FNAME_CNT;
100 else
101 filecnt = options->filecnt;
102
103 filenames = (const char**) s_malloc(filecnt * sizeof(const char*));
104 fileidx = 0;
105
106 if (options->from_stdin) {
107 while ((filename = readline(stdin))) {
108 if (!*filename || !check_append(filename))
109 free((void*) filename);
110 }
111 } else {
112 for (i = 0; i < options->filecnt; ++i) {
113 filename = options->filenames[i];
114 if (!stat(filename, &fstats) && S_ISDIR(fstats.st_mode)) {
115 if (options->recursive)
116 read_dir_rec(filename);
117 else
118 warn("ignoring directory: %s", filename);
119 } else {
120 check_append(filename);
121 }
122 }
123 }
124
125 filecnt = fileidx;
126 fileidx = 0;
127
128 if (!filecnt) {
129 fprintf(stderr, "sxiv: no valid image filename given, aborting\n");
130 exit(1);
131 }
132
133 win_open(&win);
134 img_init(&img, &win);
135
136 if (options->thumbnails) {
137 mode = MODE_THUMBS;
138 tns_init(&tns, filecnt);
139 win_clear(&win);
140 win_draw(&win);
141 } else {
142 mode = MODE_NORMAL;
143 tns.thumbs = NULL;
144 load_image(fileidx);
145 img_render(&img, &win);
146 }
147
148 update_title();
149 run();
150 cleanup();
151
152 return 0;
153}
154
155void update_title() {
156 int n;
157 float size;
158 const char *unit;
159
160 if (mode == MODE_THUMBS) {
161 n = snprintf(win_title, TITLE_LEN, "sxiv: [%d/%d] %s",
162 tns.cnt ? tns.sel + 1 : 0, tns.cnt,
163 tns.cnt ? filenames[tns.sel] : "");
164 } else {
165 if (img.im) {
166 size = filesize;
167 size_readable(&size, &unit);
168 n = snprintf(win_title, TITLE_LEN, "sxiv: [%d/%d] <%d%%> (%.2f%s) %s",
169 fileidx + 1, filecnt, (int) (img.zoom * 100.0), size, unit,
170 filenames[fileidx]);
171 } else {
172 n = snprintf(win_title, TITLE_LEN, "sxiv: [%d/%d] broken: %s",
173 fileidx + 1, filecnt, filenames[fileidx]);
174 }
175 }
176
177 if (n >= TITLE_LEN) {
178 win_title[TITLE_LEN - 2] = '.';
179 win_title[TITLE_LEN - 3] = '.';
180 win_title[TITLE_LEN - 4] = '.';
181 }
182
183 win_set_title(&win, win_title);
184}
185
186int check_append(const char *filename) {
187 if (!filename)
188 return 0;
189
190 if (img_check(filename)) {
191 if (fileidx == filecnt) {
192 filecnt *= 2;
193 filenames = (const char**) s_realloc(filenames,
194 filecnt * sizeof(const char*));
195 }
196 filenames[fileidx++] = filename;
197 return 1;
198 } else {
199 return 0;
200 }
201}
202
203int fncmp(const void *a, const void *b) {
204 return strcoll(*((char* const*) a), *((char* const*) b));
205}
206
207void read_dir_rec(const char *dirname) {
208 char *filename;
209 const char **dirnames;
210 int dircnt, diridx;
211 int fcnt, fstart;
212 unsigned char first;
213 size_t len;
214 DIR *dir;
215 struct dirent *dentry;
216 struct stat fstats;
217
218 if (!dirname)
219 return;
220
221 dircnt = DNAME_CNT;
222 diridx = first = 1;
223 dirnames = (const char**) s_malloc(dircnt * sizeof(const char*));
224 dirnames[0] = dirname;
225
226 fcnt = 0;
227 fstart = fileidx;
228
229 while (diridx > 0) {
230 dirname = dirnames[--diridx];
231 if (!(dir = opendir(dirname))) {
232 warn("could not open directory: %s", dirname);
233 } else {
234 while ((dentry = readdir(dir))) {
235 if (!strcmp(dentry->d_name, ".") || !strcmp(dentry->d_name, ".."))
236 continue;
237
238 len = strlen(dirname) + strlen(dentry->d_name) + 2;
239 filename = (char*) s_malloc(len * sizeof(char));
240 snprintf(filename, len, "%s/%s", dirname, dentry->d_name);
241
242 if (!stat(filename, &fstats) && S_ISDIR(fstats.st_mode)) {
243 if (diridx == dircnt) {
244 dircnt *= 2;
245 dirnames = (const char**) s_realloc(dirnames,
246 dircnt * sizeof(const char*));
247 }
248 dirnames[diridx++] = filename;
249 } else {
250 if (check_append(filename))
251 ++fcnt;
252 else
253 free(filename);
254 }
255 }
256 closedir(dir);
257 }
258
259 if (!first)
260 free((void*) dirname);
261 else
262 first = 0;
263 }
264
265 if (fcnt > 1)
266 qsort(filenames + fstart, fcnt, sizeof(char*), fncmp);
267
268 free(dirnames);
269}
270
271
272/* event handling */
273
274#define TO_WIN_RESIZE 75000;
275#define TO_IMAGE_DRAG 1000;
276#define TO_CURSOR_HIDE 1500000;
277#define TO_THUMBS_LOAD 75000;
278int timo_cursor;
279int timo_redraw;
280
281unsigned char drag;
282int mox, moy;
283
284void redraw() {
285 if (mode == MODE_NORMAL)
286 img_render(&img, &win);
287 else
288 tns_render(&tns, &win);
289 update_title();
290 timo_redraw = 0;
291}
292
293void on_keypress(XKeyEvent *kev) {
294 int x, y;
295 unsigned int w, h;
296 char key;
297 KeySym ksym;
298 int changed;
299
300 if (!kev)
301 return;
302
303 XLookupString(kev, &key, 1, &ksym, NULL);
304 changed = 0;
305
306 if (mode == MODE_NORMAL) {
307 switch (ksym) {
308 /* navigate image list */
309 case XK_n:
310 case XK_space:
311 if (fileidx + 1 < filecnt)
312 changed = load_image(fileidx + 1);
313 break;
314 case XK_p:
315 case XK_BackSpace:
316 if (fileidx > 0)
317 changed = load_image(fileidx - 1);
318 break;
319 case XK_bracketleft:
320 if (fileidx != 0)
321 changed = load_image(MAX(0, fileidx - 10));
322 break;
323 case XK_bracketright:
324 if (fileidx != filecnt - 1)
325 changed = load_image(MIN(fileidx + 10, filecnt - 1));
326 break;
327 case XK_g:
328 if (fileidx != 0)
329 changed = load_image(0);
330 break;
331 case XK_G:
332 if (fileidx != filecnt - 1)
333 changed = load_image(filecnt - 1);
334 break;
335
336 /* zooming */
337 case XK_plus:
338 case XK_equal:
339 changed = img_zoom_in(&img);
340 break;
341 case XK_minus:
342 changed = img_zoom_out(&img);
343 break;
344 case XK_0:
345 changed = img_zoom(&img, 1.0);
346 break;
347 case XK_w:
348 if ((changed = img_fit_win(&img, &win)))
349 img_center(&img, &win);
350 break;
351
352 /* panning */
353 case XK_h:
354 case XK_Left:
355 changed = img_pan(&img, &win, PAN_LEFT);
356 break;
357 case XK_j:
358 case XK_Down:
359 changed = img_pan(&img, &win, PAN_DOWN);
360 break;
361 case XK_k:
362 case XK_Up:
363 changed = img_pan(&img, &win, PAN_UP);
364 break;
365 case XK_l:
366 case XK_Right:
367 changed = img_pan(&img, &win, PAN_RIGHT);
368 break;
369
370 /* rotation */
371 case XK_less:
372 img_rotate_left(&img, &win);
373 changed = 1;
374 break;
375 case XK_greater:
376 img_rotate_right(&img, &win);
377 changed = 1;
378 break;
379
380 /* control window */
381 case XK_W:
382 x = MAX(0, win.x + img.x);
383 y = MAX(0, win.y + img.y);
384 w = img.w * img.zoom;
385 h = img.h * img.zoom;
386 if ((changed = win_moveresize(&win, x, y, w, h))) {
387 img.x = x - win.x;
388 img.y = y - win.y;
389 }
390 break;
391
392 /* switch to thumbnail mode */
393 case XK_Return:
394 if (!tns.thumbs)
395 tns_init(&tns, filecnt);
396 img_close(&img);
397 mode = MODE_THUMBS;
398 win_set_cursor(&win, CURSOR_ARROW);
399 timo_cursor = 0;
400 tns.sel = fileidx;
401 changed = tns.dirty = 1;
402 break;
403
404 /* miscellaneous */
405 case XK_a:
406 img_toggle_antialias(&img);
407 changed = 1;
408 break;
409 case XK_r:
410 changed = load_image(fileidx);
411 break;
412 case XK_S:
413 if (img_save(&img))
414 tns_load(&tns, &win, fileidx, filenames[fileidx]);
415 break;
416 }
417 } else {
418 /* thumbnail mode */
419 switch (ksym) {
420 /* open selected image */
421 case XK_Return:
422 load_image(tns.sel);
423 mode = MODE_NORMAL;
424 win_set_cursor(&win, CURSOR_NONE);
425 changed = 1;
426 break;
427
428 /* move selection */
429 case XK_h:
430 case XK_Left:
431 changed = tns_move_selection(&tns, &win, TNS_LEFT);
432 break;
433 case XK_j:
434 case XK_Down:
435 changed = tns_move_selection(&tns, &win, TNS_DOWN);
436 break;
437 case XK_k:
438 case XK_Up:
439 changed = tns_move_selection(&tns, &win, TNS_UP);
440 break;
441 case XK_l:
442 case XK_Right:
443 changed = tns_move_selection(&tns, &win, TNS_RIGHT);
444 break;
445 case XK_g:
446 if (tns.sel != 0) {
447 tns.sel = 0;
448 changed = tns.dirty = 1;
449 }
450 break;
451 case XK_G:
452 if (tns.sel != tns.cnt - 1) {
453 tns.sel = tns.cnt - 1;
454 changed = tns.dirty = 1;
455 }
456 }
457 }
458
459 /* common key mappings */
460 switch (ksym) {
461 case XK_Escape:
462 cleanup();
463 exit(2);
464 case XK_q:
465 cleanup();
466 exit(0);
467
468 case XK_f:
469 win_toggle_fullscreen(&win);
470 /* render on next configurenotify */
471 break;
472 }
473
474 if (changed)
475 redraw();
476}
477
478void on_buttonpress(XButtonEvent *bev) {
479 int changed, sel;
480 unsigned int mask;
481
482 if (!bev)
483 return;
484
485 mask = CLEANMASK(bev->state);
486 changed = 0;
487
488 if (mode == MODE_NORMAL) {
489 switch (bev->button) {
490 case Button1:
491 if (fileidx + 1 < filecnt)
492 changed = load_image(fileidx + 1);
493 break;
494 case Button2:
495 mox = bev->x;
496 moy = bev->y;
497 win_set_cursor(&win, CURSOR_HAND);
498 timo_cursor = 0;
499 drag = 1;
500 break;
501 case Button3:
502 if (fileidx > 0)
503 changed = load_image(fileidx - 1);
504 break;
505 case Button4:
506 if (mask == ControlMask)
507 changed = img_zoom_in(&img);
508 else if (mask == ShiftMask)
509 changed = img_pan(&img, &win, PAN_LEFT);
510 else
511 changed = img_pan(&img, &win, PAN_UP);
512 break;
513 case Button5:
514 if (mask == ControlMask)
515 changed = img_zoom_out(&img);
516 else if (mask == ShiftMask)
517 changed = img_pan(&img, &win, PAN_RIGHT);
518 else
519 changed = img_pan(&img, &win, PAN_DOWN);
520 break;
521 case 6:
522 changed = img_pan(&img, &win, PAN_LEFT);
523 break;
524 case 7:
525 changed = img_pan(&img, &win, PAN_RIGHT);
526 break;
527 }
528 } else {
529 /* thumbnail mode */
530 switch (bev->button) {
531 case Button1:
532 if ((sel = tns_translate(&tns, bev->x, bev->y)) >= 0) {
533 if (sel == tns.sel) {
534 load_image(tns.sel);
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.cnt is increased inside tns_load */
591 tns_load(&tns, &win, tns.cnt, filenames[tns.cnt]);
592 gettimeofday(&t1, 0);
593 if (TV_TO_DOUBLE(t1) - TV_TO_DOUBLE(t0) >= 0.25)
594 break;
595 }
596 if (tns.cnt == filecnt)
597 win_set_cursor(&win, CURSOR_ARROW);
598 if (!XPending(win.env.dpy)) {
599 redraw();
600 continue;
601 } else {
602 timo_redraw = TO_THUMBS_LOAD;
603 }
604 } else if (timo_cursor || timo_redraw) {
605 gettimeofday(&t0, 0);
606 if (timo_cursor && timo_redraw)
607 timeout = MIN(timo_cursor, timo_redraw);
608 else if (timo_cursor)
609 timeout = timo_cursor;
610 else
611 timeout = timo_redraw;
612 tt.tv_sec = timeout / 1000000;
613 tt.tv_usec = timeout % 1000000;
614 xfd = ConnectionNumber(win.env.dpy);
615 FD_ZERO(&fds);
616 FD_SET(xfd, &fds);
617
618 if (!XPending(win.env.dpy))
619 select(xfd + 1, &fds, 0, 0, &tt);
620 gettimeofday(&t1, 0);
621 timeout = MIN((TV_TO_DOUBLE(t1) - TV_TO_DOUBLE(t0)) * 1000000, timeout);
622
623 /* timeouts fired? */
624 if (timo_cursor) {
625 timo_cursor = MAX(0, timo_cursor - timeout);
626 if (!timo_cursor)
627 win_set_cursor(&win, CURSOR_NONE);
628 }
629 if (timo_redraw) {
630 timo_redraw = MAX(0, timo_redraw - timeout);
631 if (!timo_redraw)
632 redraw();
633 }
634 if (!XPending(win.env.dpy) && (timo_cursor || timo_redraw))
635 continue;
636 }
637
638 if (!XNextEvent(win.env.dpy, &ev)) {
639 switch (ev.type) {
640 case KeyPress:
641 on_keypress(&ev.xkey);
642 break;
643 case ButtonPress:
644 on_buttonpress(&ev.xbutton);
645 break;
646 case ButtonRelease:
647 if (ev.xbutton.button == Button2) {
648 drag = 0;
649 if (mode == MODE_NORMAL) {
650 win_set_cursor(&win, CURSOR_ARROW);
651 timo_cursor = TO_CURSOR_HIDE;
652 }
653 }
654 break;
655 case MotionNotify:
656 if (drag) {
657 on_motionnotify(&ev.xmotion);
658 } else if (mode == MODE_NORMAL) {
659 if (!timo_cursor)
660 win_set_cursor(&win, CURSOR_ARROW);
661 timo_cursor = TO_CURSOR_HIDE;
662 }
663 break;
664 case ConfigureNotify:
665 if (win_configure(&win, &ev.xconfigure)) {
666 timo_redraw = TO_WIN_RESIZE;
667 if (mode == MODE_NORMAL)
668 img.checkpan = 1;
669 else
670 tns.dirty = 1;
671 }
672 break;
673 case ClientMessage:
674 if ((Atom) ev.xclient.data.l[0] == wm_delete_win)
675 return;
676 break;
677 }
678 }
679 }
680}