tiv

1#define _POSIX_C_SOURCE 200809L
2 
3#include <dirent.h>
4#include <errno.h>
5#include <stdbool.h>
6#include <stdio.h>
7#include <stdlib.h>
8#include <string.h>
9#include <strings.h>
10 
11#include <gtk/gtk.h>
12 
13typedef struct {
14  GtkApplication *app;
15  GtkWindow *window;
16  GtkPicture *picture;
17  GtkScrolledWindow *scroller;
18  GtkDrawingArea *overlay;
19  GtkLabel *label;
20  GtkButton *prev_btn;
21  GtkButton *next_btn;
22  GtkButton *zoom_out_btn;
23  GtkButton *zoom_in_btn;
24  GtkButton *zoom_reset_btn;
25  GtkButton *crop_btn;
26  GtkButton *crop_apply_btn;
27  GtkLabel *zoom_label;
28 
29  char *dir;
30  char **names;
31  size_t count;
32  size_t idx;
33 
34  double zoom;
35  int img_w;
36  int img_h;
37  bool crop_mode;
38  bool has_sel;
39  double sel_x0, sel_y0, sel_x1, sel_y1;
40} Viewer;
41 
42static void die(const char *msg) {
43  perror(msg);
44  exit(1);
45}
46 
47static bool is_image_ext(const char *name) {
48  const char *dot = strrchr(name, '.');
49  if (!dot || dot[1] == '\0')
50    return false;
51  const char *ext = dot + 1;
52 
53  static const char *k[] = {"png",  "jpg",  "jpeg", "webp", "bmp",
54                            "gif",  "tif",  "tiff", "avif", "heic"};
55  for (size_t i = 0; i < sizeof(k) / sizeof(k[0]); i++) {
56    if (strcasecmp(ext, k[i]) == 0)
57      return true;
58  }
59  return false;
60}
61 
62static int cmp_strp(const void *a, const void *b) {
63  const char *const *sa = (const char *const *)a;
64  const char *const *sb = (const char *const *)b;
65  return strcasecmp(*sa, *sb);
66}
67 
68static char *path_dirname_dup(const char *path) {
69  const char *slash = strrchr(path, '/');
70  if (!slash)
71    return strdup(".");
72  size_t len = (size_t)(slash - path);
73  if (len == 0)
74    return strdup("/");
75  char *out = (char *)malloc(len + 1);
76  if (!out)
77    return NULL;
78  memcpy(out, path, len);
79  out[len] = '\0';
80  return out;
81}
82 
83static char *path_basename_dup(const char *path) {
84  const char *slash = strrchr(path, '/');
85  return strdup(slash ? slash + 1 : path);
86}
87 
88static char *path_join(const char *dir, const char *name) {
89  size_t dlen = strlen(dir);
90  size_t nlen = strlen(name);
91  bool need_slash = (dlen > 0 && dir[dlen - 1] != '/');
92  size_t len = dlen + (need_slash ? 1 : 0) + nlen;
93  char *out = (char *)malloc(len + 1);
94  if (!out)
95    return NULL;
96  memcpy(out, dir, dlen);
97  size_t off = dlen;
98  if (need_slash)
99    out[off++] = '/';
100  memcpy(out + off, name, nlen);
101  out[len] = '\0';
102  return out;
103}
104 
105static char **list_images_in_dir(const char *dir, size_t *out_count) {
106  *out_count = 0;
107  DIR *d = opendir(dir);
108  if (!d)
109    return NULL;
110 
111  size_t cap = 64;
112  char **items = (char **)calloc(cap, sizeof(char *));
113  if (!items) {
114    closedir(d);
115    return NULL;
116  }
117 
118  struct dirent *de;
119  while ((de = readdir(d)) != NULL) {
120    if (de->d_name[0] == '.')
121      continue;
122    if (!is_image_ext(de->d_name))
123      continue;
124    if (*out_count == cap) {
125      cap *= 2;
126      char **nitems = (char **)realloc(items, cap * sizeof(char *));
127      if (!nitems)
128        break;
129      items = nitems;
130    }
131    items[*out_count] = strdup(de->d_name);
132    if (!items[*out_count])
133      break;
134    (*out_count)++;
135  }
136 
137  closedir(d);
138  qsort(items, *out_count, sizeof(char *), cmp_strp);
139  return items;
140}
141 
142static void free_strv(char **v, size_t n) {
143  if (!v)
144    return;
145  for (size_t i = 0; i < n; i++)
146    free(v[i]);
147  free(v);
148}
149 
150static void viewer_set_index(Viewer *v, size_t new_idx) {
151  if (!v || v->count == 0)
152    return;
153  v->idx = new_idx % v->count;
154 
155  char *full = path_join(v->dir, v->names[v->idx]);
156  if (!full)
157    die("malloc");
158 
159  GFile *f = g_file_new_for_path(full);
160  gtk_picture_set_file(v->picture, f);
161  g_object_unref(f);
162 
163  // Load dimensions for zoom/crop mapping.
164  GError *err = NULL;
165  GdkPixbuf *pb = gdk_pixbuf_new_from_file(full, &err);
166  if (pb) {
167    v->img_w = gdk_pixbuf_get_width(pb);
168    v->img_h = gdk_pixbuf_get_height(pb);
169    g_object_unref(pb);
170  } else {
171    v->img_w = 0;
172    v->img_h = 0;
173    if (err)
174      g_error_free(err);
175  }
176 
177  v->zoom = 1.0;
178  v->crop_mode = false;
179  v->has_sel = false;
180 
181  gtk_label_set_text(v->label, v->names[v->idx]);
182  gtk_window_set_title(v->window, v->names[v->idx]);
183 
184  gtk_widget_set_sensitive(GTK_WIDGET(v->prev_btn), v->count > 1);
185  gtk_widget_set_sensitive(GTK_WIDGET(v->next_btn), v->count > 1);
186 
187  free(full);
188}
189 
190static void on_prev_clicked(GtkButton *btn, gpointer user_data) {
191  (void)btn;
192  Viewer *v = (Viewer *)user_data;
193  if (!v || v->count == 0)
194    return;
195  viewer_set_index(v, (v->idx + v->count - 1) % v->count);
196}
197 
198static void on_next_clicked(GtkButton *btn, gpointer user_data) {
199  (void)btn;
200  Viewer *v = (Viewer *)user_data;
201  if (!v || v->count == 0)
202    return;
203  viewer_set_index(v, (v->idx + 1) % v->count);
204}
205 
206static void viewer_update_zoom(Viewer *v) {
207  if (!v)
208    return;
209  if (v->zoom < 0.05)
210    v->zoom = 0.05;
211  if (v->zoom > 16.0)
212    v->zoom = 16.0;
213 
214  if (v->img_w > 0 && v->img_h > 0) {
215    int zw = (int)((double)v->img_w * v->zoom);
216    int zh = (int)((double)v->img_h * v->zoom);
217    if (zw < 1)
218      zw = 1;
219    if (zh < 1)
220      zh = 1;
221    gtk_widget_set_size_request(GTK_WIDGET(v->picture), zw, zh);
222    gtk_widget_set_size_request(GTK_WIDGET(v->overlay), zw, zh);
223  }
224 
225  char buf[64];
226  snprintf(buf, sizeof(buf), "%.0f%%", v->zoom * 100.0);
227  gtk_label_set_text(v->zoom_label, buf);
228  gtk_widget_queue_draw(GTK_WIDGET(v->overlay));
229}
230 
231static void on_zoom_out(GtkButton *btn, gpointer user_data) {
232  (void)btn;
233  Viewer *v = (Viewer *)user_data;
234  v->zoom /= 1.25;
235  viewer_update_zoom(v);
236}
237 
238static void on_zoom_in(GtkButton *btn, gpointer user_data) {
239  (void)btn;
240  Viewer *v = (Viewer *)user_data;
241  v->zoom *= 1.25;
242  viewer_update_zoom(v);
243}
244 
245static void on_zoom_reset(GtkButton *btn, gpointer user_data) {
246  (void)btn;
247  Viewer *v = (Viewer *)user_data;
248  v->zoom = 1.0;
249  viewer_update_zoom(v);
250}
251 
252static void on_crop_toggle(GtkButton *btn, gpointer user_data) {
253  (void)btn;
254  Viewer *v = (Viewer *)user_data;
255  v->crop_mode = !v->crop_mode;
256  v->has_sel = false;
257  gtk_widget_set_sensitive(GTK_WIDGET(v->crop_apply_btn), v->crop_mode);
258  gtk_widget_queue_draw(GTK_WIDGET(v->overlay));
259}
260 
261static char *viewer_current_path(Viewer *v) {
262  if (!v || v->count == 0)
263    return NULL;
264  return path_join(v->dir, v->names[v->idx]);
265}
266 
267static char *viewer_crop_output_path(Viewer *v) {
268  if (!v)
269    return NULL;
270  const char *name = v->names[v->idx];
271  const char *dot = strrchr(name, '.');
272  size_t base_len = dot ? (size_t)(dot - name) : strlen(name);
273  char out_name[PATH_MAX];
274  snprintf(out_name, sizeof(out_name), "%.*s_crop.png", (int)base_len, name);
275  return path_join(v->dir, out_name);
276}
277 
278static void on_crop_apply(GtkButton *btn, gpointer user_data) {
279  (void)btn;
280  Viewer *v = (Viewer *)user_data;
281  if (!v || !v->crop_mode || !v->has_sel || v->zoom <= 0.0)
282    return;
283 
284  double x0 = v->sel_x0 < v->sel_x1 ? v->sel_x0 : v->sel_x1;
285  double y0 = v->sel_y0 < v->sel_y1 ? v->sel_y0 : v->sel_y1;
286  double x1 = v->sel_x0 < v->sel_x1 ? v->sel_x1 : v->sel_x0;
287  double y1 = v->sel_y0 < v->sel_y1 ? v->sel_y1 : v->sel_y0;
288 
289  int ix = (int)(x0 / v->zoom);
290  int iy = (int)(y0 / v->zoom);
291  int iw = (int)((x1 - x0) / v->zoom);
292  int ih = (int)((y1 - y0) / v->zoom);
293  if (iw < 2 || ih < 2)
294    return;
295 
296  char *in_path = viewer_current_path(v);
297  char *out_path = viewer_crop_output_path(v);
298  if (!in_path || !out_path) {
299    free(in_path);
300    free(out_path);
301    return;
302  }
303 
304  GError *err = NULL;
305  GdkPixbuf *pb = gdk_pixbuf_new_from_file(in_path, &err);
306  if (!pb) {
307    if (err) {
308      g_warning("Failed to load for crop: %s", err->message);
309      g_error_free(err);
310    }
311    free(in_path);
312    free(out_path);
313    return;
314  }
315 
316  int pw = gdk_pixbuf_get_width(pb);
317  int ph = gdk_pixbuf_get_height(pb);
318  if (ix < 0)
319    ix = 0;
320  if (iy < 0)
321    iy = 0;
322  if (ix + iw > pw)
323    iw = pw - ix;
324  if (iy + ih > ph)
325    ih = ph - iy;
326  if (iw < 2 || ih < 2) {
327    g_object_unref(pb);
328    free(in_path);
329    free(out_path);
330    return;
331  }
332 
333  GdkPixbuf *sub = gdk_pixbuf_new_subpixbuf(pb, ix, iy, iw, ih);
334  gboolean ok = gdk_pixbuf_save(sub, out_path, "png", &err, NULL);
335  if (!ok) {
336    if (err) {
337      g_warning("Failed to save crop: %s", err->message);
338      g_error_free(err);
339    }
340  } else {
341    // Open the newly created crop (and refresh directory list would be more
342    // work; keep it minimal and just load the crop itself).
343    gtk_window_set_title(v->window, out_path);
344  }
345 
346  g_object_unref(sub);
347  g_object_unref(pb);
348  free(in_path);
349  free(out_path);
350}
351 
352static void overlay_draw(GtkDrawingArea *area, cairo_t *cr, int width,
353                         int height, gpointer user_data) {
354  (void)area;
355  Viewer *v = (Viewer *)user_data;
356  if (!v || !v->crop_mode || !v->has_sel)
357    return;
358 
359  double x0 = v->sel_x0;
360  double y0 = v->sel_y0;
361  double x1 = v->sel_x1;
362  double y1 = v->sel_y1;
363  if (x0 > x1) {
364    double t = x0;
365    x0 = x1;
366    x1 = t;
367  }
368  if (y0 > y1) {
369    double t = y0;
370    y0 = y1;
371    y1 = t;
372  }
373 
374  if (x1 - x0 < 2.0 || y1 - y0 < 2.0)
375    return;
376 
377  cairo_save(cr);
378  cairo_set_source_rgba(cr, 0, 0, 0, 0.35);
379  cairo_rectangle(cr, 0, 0, width, height);
380  cairo_rectangle(cr, x0, y0, x1 - x0, y1 - y0);
381  cairo_set_fill_rule(cr, CAIRO_FILL_RULE_EVEN_ODD);
382  cairo_fill(cr);
383 
384  cairo_set_source_rgba(cr, 1, 1, 1, 0.9);
385  cairo_set_line_width(cr, 2.0);
386  cairo_rectangle(cr, x0 + 1, y0 + 1, (x1 - x0) - 2, (y1 - y0) - 2);
387  cairo_stroke(cr);
388  cairo_restore(cr);
389}
390 
391static void on_drag_begin(GtkGestureDrag *gesture, double start_x,
392                          double start_y, gpointer user_data) {
393  (void)gesture;
394  Viewer *v = (Viewer *)user_data;
395  if (!v || !v->crop_mode)
396    return;
397  v->has_sel = true;
398  v->sel_x0 = start_x;
399  v->sel_y0 = start_y;
400  v->sel_x1 = start_x;
401  v->sel_y1 = start_y;
402  gtk_widget_queue_draw(GTK_WIDGET(v->overlay));
403}
404 
405static void on_drag_update(GtkGestureDrag *gesture, double offset_x,
406                           double offset_y, gpointer user_data) {
407  Viewer *v = (Viewer *)user_data;
408  if (!v || !v->crop_mode || !v->has_sel)
409    return;
410  double start_x = 0, start_y = 0;
411  gtk_gesture_drag_get_start_point(gesture, &start_x, &start_y);
412  v->sel_x1 = start_x + offset_x;
413  v->sel_y1 = start_y + offset_y;
414  gtk_widget_queue_draw(GTK_WIDGET(v->overlay));
415}
416 
417static gboolean on_key_pressed(GtkEventControllerKey *controller,
418                               guint keyval, guint keycode,
419                               GdkModifierType state, gpointer user_data) {
420  (void)controller;
421  (void)keycode;
422  (void)state;
423  Viewer *v = (Viewer *)user_data;
424  if (!v)
425    return GDK_EVENT_PROPAGATE;
426 
427  switch (keyval) {
428  case GDK_KEY_Left:
429  case GDK_KEY_p:
430    on_prev_clicked(NULL, v);
431    return GDK_EVENT_STOP;
432  case GDK_KEY_Right:
433  case GDK_KEY_n:
434  case GDK_KEY_space:
435    on_next_clicked(NULL, v);
436    return GDK_EVENT_STOP;
437  case GDK_KEY_plus:
438  case GDK_KEY_equal:
439    on_zoom_in(NULL, v);
440    return GDK_EVENT_STOP;
441  case GDK_KEY_minus:
442  case GDK_KEY_underscore:
443    on_zoom_out(NULL, v);
444    return GDK_EVENT_STOP;
445  case GDK_KEY_0:
446    on_zoom_reset(NULL, v);
447    return GDK_EVENT_STOP;
448  case GDK_KEY_c:
449    on_crop_toggle(NULL, v);
450    return GDK_EVENT_STOP;
451  case GDK_KEY_Return:
452  case GDK_KEY_KP_Enter:
453    on_crop_apply(NULL, v);
454    return GDK_EVENT_STOP;
455  case GDK_KEY_Escape:
456  case GDK_KEY_q:
457    gtk_window_close(v->window);
458    return GDK_EVENT_STOP;
459  default:
460    return GDK_EVENT_PROPAGATE;
461  }
462}
463 
464static void on_activate(GtkApplication *app, gpointer user_data) {
465  Viewer *v = (Viewer *)user_data;
466 
467  v->window = GTK_WINDOW(gtk_application_window_new(app));
468  gtk_window_set_default_size(v->window, 980, 720);
469 
470  GtkWidget *root = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
471  gtk_window_set_child(v->window, root);
472 
473  GtkWidget *toolbar = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 8);
474  gtk_widget_set_margin_top(toolbar, 8);
475  gtk_widget_set_margin_bottom(toolbar, 8);
476  gtk_widget_set_margin_start(toolbar, 8);
477  gtk_widget_set_margin_end(toolbar, 8);
478  gtk_box_append(GTK_BOX(root), toolbar);
479 
480  v->prev_btn = GTK_BUTTON(gtk_button_new_with_label("Prev"));
481  v->next_btn = GTK_BUTTON(gtk_button_new_with_label("Next"));
482  v->zoom_out_btn = GTK_BUTTON(gtk_button_new_with_label("-"));
483  v->zoom_in_btn = GTK_BUTTON(gtk_button_new_with_label("+"));
484  v->zoom_reset_btn = GTK_BUTTON(gtk_button_new_with_label("100%"));
485  v->crop_btn = GTK_BUTTON(gtk_button_new_with_label("Crop"));
486  v->crop_apply_btn = GTK_BUTTON(gtk_button_new_with_label("Save crop"));
487  v->label = GTK_LABEL(gtk_label_new(""));
488  v->zoom_label = GTK_LABEL(gtk_label_new("100%"));
489  gtk_widget_set_hexpand(GTK_WIDGET(v->label), TRUE);
490  gtk_label_set_xalign(v->label, 0.0f);
491  gtk_widget_set_margin_start(GTK_WIDGET(v->label), 8);
492 
493  gtk_box_append(GTK_BOX(toolbar), GTK_WIDGET(v->prev_btn));
494  gtk_box_append(GTK_BOX(toolbar), GTK_WIDGET(v->next_btn));
495  gtk_box_append(GTK_BOX(toolbar), GTK_WIDGET(v->zoom_out_btn));
496  gtk_box_append(GTK_BOX(toolbar), GTK_WIDGET(v->zoom_in_btn));
497  gtk_box_append(GTK_BOX(toolbar), GTK_WIDGET(v->zoom_reset_btn));
498  gtk_box_append(GTK_BOX(toolbar), GTK_WIDGET(v->crop_btn));
499  gtk_box_append(GTK_BOX(toolbar), GTK_WIDGET(v->crop_apply_btn));
500  gtk_box_append(GTK_BOX(toolbar), GTK_WIDGET(v->zoom_label));
501  gtk_box_append(GTK_BOX(toolbar), GTK_WIDGET(v->label));
502 
503  g_signal_connect(v->prev_btn, "clicked", G_CALLBACK(on_prev_clicked), v);
504  g_signal_connect(v->next_btn, "clicked", G_CALLBACK(on_next_clicked), v);
505  g_signal_connect(v->zoom_out_btn, "clicked", G_CALLBACK(on_zoom_out), v);
506  g_signal_connect(v->zoom_in_btn, "clicked", G_CALLBACK(on_zoom_in), v);
507  g_signal_connect(v->zoom_reset_btn, "clicked", G_CALLBACK(on_zoom_reset), v);
508  g_signal_connect(v->crop_btn, "clicked", G_CALLBACK(on_crop_toggle), v);
509  g_signal_connect(v->crop_apply_btn, "clicked", G_CALLBACK(on_crop_apply), v);
510  gtk_widget_set_sensitive(GTK_WIDGET(v->crop_apply_btn), FALSE);
511 
512  v->scroller = GTK_SCROLLED_WINDOW(gtk_scrolled_window_new());
513  gtk_widget_set_vexpand(GTK_WIDGET(v->scroller), TRUE);
514  gtk_box_append(GTK_BOX(root), GTK_WIDGET(v->scroller));
515 
516  GtkWidget *overlay = gtk_overlay_new();
517  gtk_scrolled_window_set_child(v->scroller, overlay);
518 
519  v->picture = GTK_PICTURE(gtk_picture_new());
520  gtk_picture_set_can_shrink(v->picture, TRUE);
521  gtk_picture_set_content_fit(v->picture, GTK_CONTENT_FIT_CONTAIN);
522  gtk_overlay_set_child(GTK_OVERLAY(overlay), GTK_WIDGET(v->picture));
523 
524  v->overlay = GTK_DRAWING_AREA(gtk_drawing_area_new());
525  gtk_widget_set_hexpand(GTK_WIDGET(v->overlay), FALSE);
526  gtk_widget_set_vexpand(GTK_WIDGET(v->overlay), FALSE);
527  gtk_overlay_add_overlay(GTK_OVERLAY(overlay), GTK_WIDGET(v->overlay));
528  gtk_widget_set_halign(GTK_WIDGET(v->overlay), GTK_ALIGN_START);
529  gtk_widget_set_valign(GTK_WIDGET(v->overlay), GTK_ALIGN_START);
530  gtk_widget_set_can_focus(GTK_WIDGET(v->overlay), FALSE);
531  gtk_drawing_area_set_draw_func(v->overlay, overlay_draw, v, NULL);
532 
533  GtkGesture *drag = gtk_gesture_drag_new();
534  gtk_gesture_single_set_button(GTK_GESTURE_SINGLE(drag), GDK_BUTTON_PRIMARY);
535  g_signal_connect(drag, "drag-begin", G_CALLBACK(on_drag_begin), v);
536  g_signal_connect(drag, "drag-update", G_CALLBACK(on_drag_update), v);
537  gtk_widget_add_controller(GTK_WIDGET(v->overlay),
538                            GTK_EVENT_CONTROLLER(drag));
539 
540  GtkEventController *keys = gtk_event_controller_key_new();
541  g_signal_connect(keys, "key-pressed", G_CALLBACK(on_key_pressed), v);
542  gtk_widget_add_controller(GTK_WIDGET(v->window), keys);
543 
544  viewer_set_index(v, v->idx);
545  viewer_update_zoom(v);
546  gtk_window_present(v->window);
547}
548 
549int main(int argc, char **argv) {
550  if (argc != 2) {
551    fprintf(stderr, "Usage: %s /path/to/image\n", argv[0]);
552    return 2;
553  }
554 
555  char *dir = path_dirname_dup(argv[1]);
556  char *base = path_basename_dup(argv[1]);
557  if (!dir || !base)
558    die("malloc");
559 
560  size_t count = 0;
561  char **names = list_images_in_dir(dir, &count);
562  if (!names || count == 0) {
563    fprintf(stderr, "No images found in: %s\n", dir);
564    free_strv(names, count);
565    free(dir);
566    free(base);
567    return 1;
568  }
569 
570  size_t idx = 0;
571  for (size_t i = 0; i < count; i++) {
572    if (strcmp(names[i], base) == 0) {
573      idx = i;
574      break;
575    }
576  }
577 
578  Viewer v = {0};
579  v.dir = dir;
580  v.names = names;
581  v.count = count;
582  v.idx = idx;
583 
584  v.app = gtk_application_new("dev.tiv.viewer", G_APPLICATION_DEFAULT_FLAGS);
585  g_signal_connect(v.app, "activate", G_CALLBACK(on_activate), &v);
586  // We handle the file argument ourselves; passing it to GApplication without an
587  // "open" handler triggers: "This application can not open files."
588  char *argv0[] = {argv[0], NULL};
589  int rc = g_application_run(G_APPLICATION(v.app), 1, argv0);
590  g_object_unref(v.app);
591 
592  free_strv(names, count);
593  free(dir);
594  free(base);
595  return rc;
596}
597