src/pan-view/pan-view.cc

   1 /*
   2  * Copyright (C) 2006 John Ellis
   3  * Copyright (C) 2008 - 2016 The Geeqie Team
   4  *
   5  * Author: John Ellis
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include "pan-view.h"
  23
  24 #include "bar-exif.h"
  25 #include "dnd.h"
  26 #include "editors.h"
  27 #include "exif.h"
  28 #include "fullscreen.h"
  29 #include "image.h"
  30 #include "img-view.h"
  31 #include "layout-util.h"
  32 #include "menu.h"
  33 #include "metadata.h"
  34 #include "pan-calendar.h"
  35 #include "pan-folder.h"
  36 #include "pan-grid.h"
  37 #include "pan-timeline.h"
  38 #include "pan-util.h"
  39 #include "pan-view-filter.h"
  40 #include "pan-view-search.h"
  41 #include "pixbuf-util.h"
  42 #include "thumb.h"
  43 #include "ui-fileops.h"
  44 #include "ui-menu.h"
  45 #include "ui-misc.h"
  46 #include "ui-tabcomp.h"
  47 #include "uri-utils.h"
  48 #include "utilops.h"
  49 #include "window.h"
  50
  51 #include <cmath>
  52
  53
  54 #define PAN_WINDOW_DEFAULT_WIDTH 720
  55 #define PAN_WINDOW_DEFAULT_HEIGHT 500
  56
  57 #define PAN_TILE_SIZE 512
  58
  59 #define ZOOM_INCREMENT 1.0
  60 #define ZOOM_LABEL_WIDTH 64
  61
  62
  63 #define PAN_PREF_GROUP          "pan_view_options"
  64 #define PAN_PREF_HIDE_WARNING   "hide_performance_warning"
  65 #define PAN_PREF_EXIF_PAN_DATE  "use_exif_date"
  66 #define PAN_PREF_INFO_IMAGE     "info_image_size"
  67 #define PAN_PREF_INFO_EXIF      "info_includes_exif"
  68
  69
  70 static GList *pan_window_list = nullptr;
  71
  72
  73 static void pan_layout_update_idle(PanWindow *pw);
  74
  75 static void pan_fullscreen_toggle(PanWindow *pw, gboolean force_off);
  76
  77 static void pan_window_close(PanWindow *pw);
  78
  79 static GtkWidget *pan_popup_menu(PanWindow *pw);
  80
  81 static void pan_window_dnd_init(PanWindow *pw);
  82
  83 /**
  84  * This array must be kept in sync with the contents of:\n
  85  * @link pan_window_key_press_cb @endlink \n
  86  * @link pan_popup_menu @endlink
  87  *
  88  * See also @link hard_coded_window_keys @endlink
  89  **/
  90 hard_coded_window_keys pan_view_window_keys[] = {
  91         {GDK_CONTROL_MASK, 'C', N_("Copy")},
  92         {GDK_CONTROL_MASK, 'M', N_("Move")},
  93         {GDK_CONTROL_MASK, 'R', N_("Rename")},
  94         {GDK_CONTROL_MASK, 'D', N_("Move to Trash")},
  95         {GDK_CONTROL_MASK, 'W', N_("Close window")},
  96         {GDK_CONTROL_MASK, 'F', N_("Display Find search bar")},
  97         {GDK_CONTROL_MASK, 'G', N_("Start search")},
  98         {static_cast<GdkModifierType>(0), GDK_KEY_Escape, N_("Exit fullscreen")},
  99         {static_cast<GdkModifierType>(0), GDK_KEY_Escape, N_("Hide Find search bar")},
 100         {static_cast<GdkModifierType>(0), GDK_KEY_equal, N_("Zoom in")},
 101         {static_cast<GdkModifierType>(0), GDK_KEY_plus, N_("Zoom in")},
 102         {static_cast<GdkModifierType>(0), GDK_KEY_minus, N_("Zoom out")},
 103         {static_cast<GdkModifierType>(0), GDK_KEY_Z, N_("Zoom 1:1")},
 104         {static_cast<GdkModifierType>(0), GDK_KEY_1, N_("Zoom 1:1")},
 105         {static_cast<GdkModifierType>(0), GDK_KEY_KP_Divide, N_("Zoom 1:1")},
 106         {static_cast<GdkModifierType>(0), '2', N_("Zoom 2:1")},
 107         {static_cast<GdkModifierType>(0), '3', N_("Zoom 3:1")},
 108         {static_cast<GdkModifierType>(0), '4', N_("Zoom 4:1")},
 109         {static_cast<GdkModifierType>(0), '7', N_("Zoom 1:4")},
 110         {static_cast<GdkModifierType>(0), '8', N_("Zoom 1:3")},
 111         {static_cast<GdkModifierType>(0), '9', N_("Zoom 1:2")},
 112         {static_cast<GdkModifierType>(0), 'F', N_("Full screen")},
 113         {static_cast<GdkModifierType>(0), 'V', N_("Full screen")},
 114         {static_cast<GdkModifierType>(0), GDK_KEY_F11, N_("Full screen")},
 115         {static_cast<GdkModifierType>(0), '/', N_("Display Find search bar")},
 116         {static_cast<GdkModifierType>(0), GDK_KEY_Left, N_("Scroll left")},
 117         {static_cast<GdkModifierType>(0), GDK_KEY_Right, N_("Scroll right")},
 118         {static_cast<GdkModifierType>(0), GDK_KEY_Up, N_("Scroll up")},
 119         {static_cast<GdkModifierType>(0), GDK_KEY_Down, N_("Scroll down")},
 120         {GDK_SHIFT_MASK, GDK_KEY_Left, N_("Scroll left faster")},
 121         {GDK_SHIFT_MASK, GDK_KEY_Right, N_("Scroll right faster")},
 122         {GDK_SHIFT_MASK, GDK_KEY_Up, N_("Scroll up faster")},
 123         {GDK_SHIFT_MASK, GDK_KEY_Down, N_("Scroll down faster")},
 124         {static_cast<GdkModifierType>(0), GDK_KEY_Page_Up, N_("Scroll display half screen up")},
 125         {static_cast<GdkModifierType>(0), GDK_KEY_Page_Down, N_("Scroll display half screen down")},
 126         {static_cast<GdkModifierType>(0), GDK_KEY_Home, N_("Scroll display half screen left")},
 127         {static_cast<GdkModifierType>(0), GDK_KEY_End, N_("Scroll display half screen right")},
 128         {static_cast<GdkModifierType>(0), 0, nullptr}
 129 };
 130
 131 /*
 132  *-----------------------------------------------------------------------------
 133  * the image/thumb loader queue
 134  *-----------------------------------------------------------------------------
 135  */
 136
 137 static gboolean pan_queue_step(PanWindow *pw);
 138
 139
 140 static void pan_queue_thumb_done_cb(ThumbLoader *tl, gpointer data)
 141 {
 142         auto pw = static_cast<PanWindow *>(data);
 143
 144         if (pw->queue_pi)
 145                 {
 146                 PanItem *pi;
 147                 gint rc;
 148
 149                 pi = pw->queue_pi;
 150                 pw->queue_pi = nullptr;
 151
 152                 pi->queued = FALSE;
 153
 154                 if (pi->pixbuf) g_object_unref(pi->pixbuf);
 155                 pi->pixbuf = thumb_loader_get_pixbuf(tl);
 156
 157                 rc = pi->refcount;
 158                 image_area_changed(pw->imd, pi->x, pi->y, pi->width, pi->height);
 159                 pi->refcount = rc;
 160                 }
 161
 162         thumb_loader_free(pw->tl);
 163         pw->tl = nullptr;
 164
 165         while (pan_queue_step(pw));
 166 }
 167
 168 static void pan_queue_image_done_cb(ImageLoader *il, gpointer data)
 169 {
 170         auto pw = static_cast<PanWindow *>(data);
 171         GdkPixbuf *rotated = nullptr;
 172
 173         if (pw->queue_pi)
 174                 {
 175                 PanItem *pi;
 176                 gint rc;
 177
 178                 pi = pw->queue_pi;
 179                 pw->queue_pi = nullptr;
 180
 181                 pi->queued = FALSE;
 182
 183                 if (pi->pixbuf) g_object_unref(pi->pixbuf);
 184                 pi->pixbuf = image_loader_get_pixbuf(pw->il);
 185
 186                 if (pi->pixbuf && options->image.exif_rotate_enable)
 187                         {
 188                         if (!il->fd->exif_orientation)
 189                                 {
 190                                 if (g_strcmp0(il->fd->format_name, "heif") != 0)
 191                                         {
 192                                         il->fd->exif_orientation = metadata_read_int(il->fd, ORIENTATION_KEY, EXIF_ORIENTATION_TOP_LEFT);
 193                                         }
 194                                 else
 195                                         {
 196                                         il->fd->exif_orientation = EXIF_ORIENTATION_TOP_LEFT;
 197                                         }
 198                                 }
 199
 200                         if (il->fd->exif_orientation != EXIF_ORIENTATION_TOP_LEFT)
 201                                 {
 202                                 rotated = pixbuf_apply_orientation(pi->pixbuf, il->fd->exif_orientation);
 203                                 pi->pixbuf = rotated;
 204                                 }
 205                         }
 206
 207                 if (pi->pixbuf) g_object_ref(pi->pixbuf);
 208
 209                 if (pi->pixbuf && pw->size != PAN_IMAGE_SIZE_100 &&
 210                     (gdk_pixbuf_get_width(pi->pixbuf) > pi->width ||
 211                      gdk_pixbuf_get_height(pi->pixbuf) > pi->height))
 212                         {
 213                         GdkPixbuf *tmp;
 214
 215                         tmp = pi->pixbuf;
 216                         pi->pixbuf = gdk_pixbuf_scale_simple(tmp, pi->width, pi->height,
 217                                                              static_cast<GdkInterpType>(options->image.zoom_quality));
 218                         g_object_unref(tmp);
 219                         }
 220
 221                 rc = pi->refcount;
 222                 image_area_changed(pw->imd, pi->x, pi->y, pi->width, pi->height);
 223                 pi->refcount = rc;
 224                 }
 225
 226         image_loader_free(pw->il);
 227         pw->il = nullptr;
 228
 229         while (pan_queue_step(pw));
 230 }
 231
 232 static gboolean pan_queue_step(PanWindow *pw)
 233 {
 234         PanItem *pi;
 235
 236         if (!pw->queue) return FALSE;
 237
 238         pi = static_cast<PanItem *>(pw->queue->data);
 239         pw->queue = g_list_remove(pw->queue, pi);
 240         pw->queue_pi = pi;
 241
 242         if (!pw->queue_pi->fd)
 243                 {
 244                 pw->queue_pi->queued = FALSE;
 245                 pw->queue_pi = nullptr;
 246                 return TRUE;
 247                 }
 248
 249         image_loader_free(pw->il);
 250         pw->il = nullptr;
 251         thumb_loader_free(pw->tl);
 252         pw->tl = nullptr;
 253
 254         if (pi->type == PAN_ITEM_IMAGE)
 255                 {
 256                 pw->il = image_loader_new(pi->fd);
 257
 258                 if (pw->size != PAN_IMAGE_SIZE_100)
 259                         {
 260                         image_loader_set_requested_size(pw->il, pi->width, pi->height);
 261                         }
 262
 263                 g_signal_connect(G_OBJECT(pw->il), "error", (GCallback)pan_queue_image_done_cb, pw);
 264                 g_signal_connect(G_OBJECT(pw->il), "done", (GCallback)pan_queue_image_done_cb, pw);
 265
 266                 if (image_loader_start(pw->il)) return FALSE;
 267
 268                 image_loader_free(pw->il);
 269                 pw->il = nullptr;
 270                 }
 271         else if (pi->type == PAN_ITEM_THUMB)
 272                 {
 273                 pw->tl = thumb_loader_new(PAN_THUMB_SIZE, PAN_THUMB_SIZE);
 274
 275                 if (!pw->tl->standard_loader)
 276                         {
 277                         /* The classic loader will recreate a thumbnail any time we
 278                          * request a different size than what exists. This view will
 279                          * almost never use the user configured sizes so disable cache.
 280                          */
 281                         thumb_loader_set_cache(pw->tl, FALSE, FALSE, FALSE);
 282                         }
 283
 284                 thumb_loader_set_callbacks(pw->tl,
 285                                            pan_queue_thumb_done_cb,
 286                                            pan_queue_thumb_done_cb,
 287                                            nullptr, pw);
 288
 289                 if (thumb_loader_start(pw->tl, pi->fd)) return FALSE;
 290
 291                 thumb_loader_free(pw->tl);
 292                 pw->tl = nullptr;
 293                 }
 294
 295         pw->queue_pi->queued = FALSE;
 296         pw->queue_pi = nullptr;
 297         return TRUE;
 298 }
 299
 300 static void pan_queue_add(PanWindow *pw, PanItem *pi)
 301 {
 302         if (!pi || pi->queued || pi->pixbuf) return;
 303         if (pw->size <= PAN_IMAGE_SIZE_THUMB_NONE &&
 304             (!pi->key || strcmp(pi->key, "info") != 0) )
 305                 {
 306                 return;
 307                 }
 308
 309         pi->queued = TRUE;
 310         pw->queue = g_list_prepend(pw->queue, pi);
 311
 312         if (!pw->tl && !pw->il) while (pan_queue_step(pw));
 313 }
 314
 315
 316 /*
 317  *-----------------------------------------------------------------------------
 318  * tile request/dispose handlers
 319  *-----------------------------------------------------------------------------
 320  */
 321
 322 static gboolean pan_window_request_tile_cb(PixbufRenderer *pr, gint x, gint y,
 323                                            gint width, gint height, GdkPixbuf *pixbuf, gpointer data)
 324 {
 325         auto pw = static_cast<PanWindow *>(data);
 326         GList *list;
 327         GList *work;
 328         gint i;
 329
 330         pixbuf_set_rect_fill(pixbuf,
 331                              0, 0, width, height,
 332                              PAN_BACKGROUND_COLOR, 255);
 333
 334         for (i = (x / PAN_GRID_SIZE) * PAN_GRID_SIZE; i < x + width; i += PAN_GRID_SIZE)
 335                 {
 336                 gint rx, ry, rw, rh;
 337
 338                 if (util_clip_region(x, y, width, height,
 339                                      i, y, 1, height,
 340                                      &rx, &ry, &rw, &rh))
 341                         {
 342                         pixbuf_draw_rect_fill(pixbuf,
 343                                               rx - x, ry - y, rw, rh,
 344                                               PAN_GRID_COLOR, PAN_GRID_ALPHA);
 345                         }
 346                 }
 347         for (i = (y / PAN_GRID_SIZE) * PAN_GRID_SIZE; i < y + height; i += PAN_GRID_SIZE)
 348                 {
 349                 gint rx, ry, rw, rh;
 350
 351                 if (util_clip_region(x, y, width, height,
 352                                      x, i, width, 1,
 353                                      &rx, &ry, &rw, &rh))
 354                         {
 355                         pixbuf_draw_rect_fill(pixbuf,
 356                                               rx - x, ry - y, rw, rh,
 357                                               PAN_GRID_COLOR, PAN_GRID_ALPHA);
 358                         }
 359                 }
 360
 361         list = pan_layout_intersect(pw, x, y, width, height);
 362         work = list;
 363         while (work)
 364                 {
 365                 PanItem *pi;
 366                 gboolean queue = FALSE;
 367
 368                 pi = static_cast<PanItem *>(work->data);
 369                 work = work->next;
 370
 371                 pi->refcount++;
 372
 373                 switch (pi->type)
 374                         {
 375                         case PAN_ITEM_BOX:
 376                                 queue = pan_item_box_draw(pw, pi, pixbuf, pr, x, y, width, height);
 377                                 break;
 378                         case PAN_ITEM_TRIANGLE:
 379                                 queue = pan_item_tri_draw(pw, pi, pixbuf, pr, x, y, width, height);
 380                                 break;
 381                         case PAN_ITEM_TEXT:
 382                                 queue = pan_item_text_draw(pw, pi, pixbuf, pr, x, y, width, height);
 383                                 break;
 384                         case PAN_ITEM_THUMB:
 385                                 queue = pan_item_thumb_draw(pw, pi, pixbuf, pr, x, y, width, height);
 386                                 break;
 387                         case PAN_ITEM_IMAGE:
 388                                 queue = pan_item_image_draw(pw, pi, pixbuf, pr, x, y, width, height);
 389                                 break;
 390                         case PAN_ITEM_NONE:
 391                         default:
 392                                 break;
 393                         }
 394
 395                 if (queue) pan_queue_add(pw, pi);
 396                 }
 397
 398         g_list_free(list);
 399
 400         return TRUE;
 401 }
 402
 403 static void pan_window_dispose_tile_cb(PixbufRenderer *, gint x, gint y,
 404                                        gint width, gint height, GdkPixbuf *, gpointer data)
 405 {
 406         auto pw = static_cast<PanWindow *>(data);
 407         GList *list;
 408         GList *work;
 409
 410         list = pan_layout_intersect(pw, x, y, width, height);
 411         work = list;
 412         while (work)
 413                 {
 414                 PanItem *pi;
 415
 416                 pi = static_cast<PanItem *>(work->data);
 417                 work = work->next;
 418
 419                 if (pi->refcount > 0)
 420                         {
 421                         pi->refcount--;
 422
 423                         if (pi->refcount == 0)
 424                                 {
 425                                 if (pi->queued)
 426                                         {
 427                                         pw->queue = g_list_remove(pw->queue, pi);
 428                                         pi->queued = FALSE;
 429                                         }
 430                                 if (pw->queue_pi == pi) pw->queue_pi = nullptr;
 431                                 if (pi->pixbuf)
 432                                         {
 433                                         g_object_unref(pi->pixbuf);
 434                                         pi->pixbuf = nullptr;
 435                                         }
 436                                 }
 437                         }
 438                 }
 439
 440         g_list_free(list);
 441 }
 442
 443
 444 /*
 445  *-----------------------------------------------------------------------------
 446  * misc
 447  *-----------------------------------------------------------------------------
 448  */
 449
 450 static void pan_window_message(PanWindow *pw, const gchar *text)
 451 {
 452         GList *work;
 453         gint count = 0;
 454         gint64 size = 0;
 455         gchar *ss;
 456         gchar *buf;
 457
 458         if (text)
 459                 {
 460                 gtk_label_set_text(GTK_LABEL(pw->label_message), text);
 461                 return;
 462                 }
 463
 464         work = pw->list_static;
 465         if (pw->layout == PAN_LAYOUT_CALENDAR)
 466                 {
 467                 while (work)
 468                         {
 469                         PanItem *pi;
 470
 471                         pi = static_cast<PanItem *>(work->data);
 472                         work = work->next;
 473
 474                         if (pi->fd &&
 475                             pi->type == PAN_ITEM_BOX &&
 476                             pi->key && strcmp(pi->key, "dot") == 0)
 477                                 {
 478                                 size += pi->fd->size;
 479                                 count++;
 480                                 }
 481                         }
 482                 }
 483         else
 484                 {
 485                 while (work)
 486                         {
 487                         PanItem *pi;
 488
 489                         pi = static_cast<PanItem *>(work->data);
 490                         work = work->next;
 491
 492                         if (pi->fd &&
 493                             (pi->type == PAN_ITEM_THUMB || pi->type == PAN_ITEM_IMAGE))
 494                                 {
 495                                 size += pi->fd->size;
 496                                 count++;
 497                                 }
 498                         }
 499                 }
 500
 501         ss = text_from_size_abrev(size);
 502         buf = g_strdup_printf(_("%d images, %s"), count, ss);
 503         g_free(ss);
 504         gtk_label_set_text(GTK_LABEL(pw->label_message), buf);
 505         g_free(buf);
 506 }
 507
 508 static void pan_warning_folder(const gchar *path, GtkWidget *parent)
 509 {
 510         gchar *message;
 511
 512         message = g_strdup_printf(_("The pan view does not support the folder \"%s\"."), path);
 513         warning_dialog(_("Folder not supported"), message,
 514                       GQ_ICON_DIALOG_INFO, parent);
 515         g_free(message);
 516 }
 517
 518 static void pan_window_zoom_limit(PanWindow *pw)
 519 {
 520         gdouble min;
 521
 522         switch (pw->size)
 523                 {
 524                 case PAN_IMAGE_SIZE_THUMB_DOTS:
 525                 case PAN_IMAGE_SIZE_THUMB_NONE:
 526                 case PAN_IMAGE_SIZE_THUMB_SMALL:
 527                 case PAN_IMAGE_SIZE_THUMB_NORMAL:
 528 #if 0
 529                         /* easily requires > 512mb ram when window size > 1024x768 and zoom is <= -8 */
 530                         min = -16.0;
 531                         break;
 532 #endif
 533                 case PAN_IMAGE_SIZE_THUMB_LARGE:
 534                         min = -6.0;
 535                         break;
 536                 case PAN_IMAGE_SIZE_10:
 537                 case PAN_IMAGE_SIZE_25:
 538                         min = -4.0;
 539                         break;
 540                 case PAN_IMAGE_SIZE_33:
 541                 case PAN_IMAGE_SIZE_50:
 542                 case PAN_IMAGE_SIZE_100:
 543                 default:
 544                         min = -2.0;
 545                         break;
 546                 }
 547
 548         image_zoom_set_limits(pw->imd, min, 32.0);
 549 }
 550
 551
 552 /*
 553  *-----------------------------------------------------------------------------
 554  * cache
 555  *-----------------------------------------------------------------------------
 556  */
 557
 558 static gint pan_cache_sort_file_cb(gpointer a, gpointer b)
 559 {
 560         auto pca = static_cast<PanCacheData *>(a);
 561         auto pcb = static_cast<PanCacheData *>(b);
 562         return filelist_sort_compare_filedata(pca->fd, pcb->fd);
 563 }
 564 GList *pan_cache_sort(GList *list, SortType method, gboolean ascend, gboolean case_sensitive)
 565 {
 566         return filelist_sort_full(list, method, ascend, case_sensitive, reinterpret_cast<GCompareFunc>(pan_cache_sort_file_cb));
 567 }
 568
 569
 570 static void pan_cache_free(PanWindow *pw)
 571 {
 572         g_list_free_full(pw->cache_list, [](gpointer data)
 573                 {
 574                 auto pc = static_cast<PanCacheData *>(data);
 575                 cache_sim_data_free(pc->cd);
 576                 file_data_unref(pc->fd);
 577                 g_free(pc);
 578                 });
 579         pw->cache_list = nullptr;
 580
 581         filelist_free(pw->cache_todo);
 582         pw->cache_todo = nullptr;
 583
 584         pw->cache_count = 0;
 585         pw->cache_total = 0;
 586         pw->cache_tick = 0;
 587
 588         cache_loader_free(pw->cache_cl);
 589         pw->cache_cl = nullptr;
 590 }
 591
 592 static void pan_cache_fill(PanWindow *pw, FileData *dir_fd)
 593 {
 594         GList *list;
 595
 596         pan_cache_free(pw);
 597
 598         list = pan_list_tree(dir_fd, SORT_NAME, TRUE, TRUE, pw->ignore_symlinks);
 599         pw->cache_todo = g_list_reverse(list);
 600
 601         pw->cache_total = g_list_length(pw->cache_todo);
 602 }
 603
 604 static void pan_cache_step_done_cb(CacheLoader *cl, gint, gpointer data)
 605 {
 606         auto pw = static_cast<PanWindow *>(data);
 607
 608         if (pw->cache_list)
 609                 {
 610                 PanCacheData *pc;
 611                 pc = static_cast<PanCacheData *>(pw->cache_list->data);
 612
 613                 if (!pc->cd)
 614                         {
 615                         pc->cd = cl->cd;
 616                         cl->cd = nullptr;
 617                         }
 618                 }
 619
 620         cache_loader_free(cl);
 621         pw->cache_cl = nullptr;
 622
 623         pan_layout_update_idle(pw);
 624 }
 625
 626 static gboolean pan_cache_step(PanWindow *pw)
 627 {
 628         FileData *fd;
 629         PanCacheData *pc;
 630         CacheDataType load_mask;
 631
 632         if (!pw->cache_todo) return TRUE;
 633
 634         fd = static_cast<FileData *>(pw->cache_todo->data);
 635         pw->cache_todo = g_list_remove(pw->cache_todo, fd);
 636
 637         pc = g_new0(PanCacheData, 1);
 638         pc->fd = file_data_ref(fd);
 639
 640         pc->cd = nullptr;
 641
 642         pw->cache_list = g_list_prepend(pw->cache_list, pc);
 643
 644         cache_loader_free(pw->cache_cl);
 645
 646         load_mask = CACHE_LOADER_NONE;
 647         if (pw->size > PAN_IMAGE_SIZE_THUMB_LARGE) load_mask = static_cast<CacheDataType>(load_mask | CACHE_LOADER_DIMENSIONS);
 648         if (pw->exif_date_enable) load_mask = static_cast<CacheDataType>(load_mask | CACHE_LOADER_DATE);
 649         pw->cache_cl = cache_loader_new(pc->fd, load_mask,
 650                                         pan_cache_step_done_cb, pw);
 651         return (pw->cache_cl == nullptr);
 652 }
 653
 654 /* This sync date function is optimized for lists with a common sort */
 655 void pan_cache_sync_date(PanWindow *pw, GList *list)
 656 {
 657         GList *haystack;
 658         GList *work;
 659
 660         haystack = g_list_copy(pw->cache_list);
 661
 662         work = list;
 663         while (work)
 664                 {
 665                 FileData *fd;
 666                 GList *needle;
 667
 668                 fd = static_cast<FileData *>(work->data);
 669                 work = work->next;
 670
 671                 needle = haystack;
 672                 while (needle)
 673                         {
 674                         PanCacheData *pc;
 675
 676                         pc = static_cast<PanCacheData *>(needle->data);
 677                         if (pc->fd == fd)
 678                                 {
 679                                 if (pc->cd && pc->cd->have_date && pc->cd->date >= 0)
 680                                         {
 681                                         fd->date = pc->cd->date;
 682                                         }
 683
 684                                 haystack = g_list_delete_link(haystack, needle);
 685                                 needle = nullptr;
 686                                 }
 687                         else
 688                                 {
 689                                 needle = needle->next;
 690                                 }
 691                         }
 692                 }
 693
 694         g_list_free(haystack);
 695 }
 696
 697 /*
 698  *-----------------------------------------------------------------------------
 699  * item grid
 700  *-----------------------------------------------------------------------------
 701  */
 702
 703 static void pan_grid_clear(PanWindow *pw)
 704 {
 705         g_list_free_full(pw->list_grid, [](gpointer data)
 706                 {
 707                 auto pg = static_cast<PanGrid *>(data);
 708                 g_list_free(pg->list);
 709                 g_free(pg);
 710                 });
 711         pw->list_grid = nullptr;
 712
 713         pw->list = g_list_concat(pw->list, pw->list_static);
 714         pw->list_static = nullptr;
 715 }
 716
 717 static void pan_grid_build(PanWindow *pw, gint width, gint height, gint grid_size)
 718 {
 719         GList *work;
 720         gint col, row;
 721         gint cw, ch;
 722         gint l;
 723         gint i, j;
 724
 725         pan_grid_clear(pw);
 726
 727         l = g_list_length(pw->list);
 728
 729         if (l < 1) return;
 730
 731         col = static_cast<gint>(sqrt(static_cast<gdouble>(l) / grid_size) * width / height + 0.999);
 732         col = CLAMP(col, 1, l / grid_size + 1);
 733         row = static_cast<gint>(static_cast<gdouble>(l) / grid_size / col);
 734         if (row < 1) row = 1;
 735
 736         /* limit minimum size of grid so that a tile will always fit regardless of position */
 737         cw = MAX((gint)ceil((gdouble)width / col), PAN_TILE_SIZE * 2);
 738         ch = MAX((gint)ceil((gdouble)height / row), PAN_TILE_SIZE * 2);
 739
 740         row = row * 2 - 1;
 741         col = col * 2 - 1;
 742
 743         DEBUG_1("intersect speedup grid is %dx%d, based on %d average per grid", col, row, grid_size);
 744
 745         for (j = 0; j < row; j++)
 746             for (i = 0; i < col; i++)
 747                 {
 748                 if ((i + 1) * cw / 2 < width && (j + 1) * ch / 2 < height)
 749                         {
 750                         PanGrid *pg;
 751
 752                         pg = g_new0(PanGrid, 1);
 753                         pg->x = i * cw / 2;
 754                         pg->y = j * ch / 2;
 755                         pg->w = cw;
 756                         pg->h = ch;
 757
 758                         pw->list_grid = g_list_prepend(pw->list_grid, pg);
 759
 760                         DEBUG_1("grid section: %d,%d (%dx%d)", pg->x, pg->y, pg->w, pg->h);
 761                         }
 762                 }
 763
 764         work = pw->list;
 765         while (work)
 766                 {
 767                 PanItem *pi;
 768                 GList *grid;
 769
 770                 pi = static_cast<PanItem *>(work->data);
 771                 work = work->next;
 772
 773                 grid = pw->list_grid;
 774                 while (grid)
 775                         {
 776                         PanGrid *pg;
 777                         gint rx, ry, rw, rh;
 778
 779                         pg = static_cast<PanGrid *>(grid->data);
 780                         grid = grid->next;
 781
 782                         if (util_clip_region(pi->x, pi->y, pi->width, pi->height,
 783                                              pg->x, pg->y, pg->w, pg->h,
 784                                              &rx, &ry, &rw, &rh))
 785                                 {
 786                                 pg->list = g_list_prepend(pg->list, pi);
 787                                 }
 788                         }
 789                 }
 790
 791         work = pw->list_grid;
 792         while (work)
 793                 {
 794                 PanGrid *pg;
 795
 796                 pg = static_cast<PanGrid *>(work->data);
 797                 work = work->next;
 798
 799                 pg->list = g_list_reverse(pg->list);
 800                 }
 801
 802         pw->list_static = pw->list;
 803         pw->list = nullptr;
 804 }
 805
 806
 807 /*
 808  *-----------------------------------------------------------------------------
 809  * layout state reset
 810  *-----------------------------------------------------------------------------
 811  */
 812
 813 static void pan_window_items_free(PanWindow *pw)
 814 {
 815         pan_grid_clear(pw);
 816
 817         g_list_free_full(pw->list, reinterpret_cast<GDestroyNotify>(pan_item_free));
 818         pw->list = nullptr;
 819
 820         g_list_free(pw->queue);
 821         pw->queue = nullptr;
 822         pw->queue_pi = nullptr;
 823
 824         image_loader_free(pw->il);
 825         pw->il = nullptr;
 826
 827         thumb_loader_free(pw->tl);
 828         pw->tl = nullptr;
 829
 830         pw->click_pi = nullptr;
 831         pw->search_pi = nullptr;
 832 }
 833
 834
 835 /*
 836  *-----------------------------------------------------------------------------
 837  * layout generation, queries, sizing
 838  *-----------------------------------------------------------------------------
 839  */
 840
 841 static void pan_layout_compute(PanWindow *pw, FileData *dir_fd,
 842                                gint *width, gint *height,
 843                                gint *scroll_x, gint *scroll_y)
 844 {
 845         pan_window_items_free(pw);
 846
 847         switch (pw->size)
 848                 {
 849                 case PAN_IMAGE_SIZE_THUMB_DOTS:
 850                         pw->thumb_size = PAN_THUMB_SIZE_DOTS;
 851                         pw->thumb_gap = PAN_THUMB_GAP_DOTS;
 852                         break;
 853                 case PAN_IMAGE_SIZE_THUMB_NONE:
 854                         pw->thumb_size = PAN_THUMB_SIZE_NONE;
 855                         pw->thumb_gap = PAN_THUMB_GAP_SMALL;
 856                         break;
 857                 case PAN_IMAGE_SIZE_THUMB_SMALL:
 858                         pw->thumb_size = PAN_THUMB_SIZE_SMALL;
 859                         pw->thumb_gap = PAN_THUMB_GAP_SMALL;
 860                         break;
 861                 case PAN_IMAGE_SIZE_THUMB_NORMAL:
 862                 default:
 863                         pw->thumb_size = PAN_THUMB_SIZE_NORMAL;
 864                         pw->thumb_gap = PAN_THUMB_GAP_NORMAL;
 865                         break;
 866                 case PAN_IMAGE_SIZE_THUMB_LARGE:
 867                         pw->thumb_size = PAN_THUMB_SIZE_LARGE;
 868                         pw->thumb_gap = PAN_THUMB_GAP_LARGE;
 869                         break;
 870                 case PAN_IMAGE_SIZE_10:
 871                         pw->image_size = 10;
 872                         pw->thumb_gap = PAN_THUMB_GAP_NORMAL;
 873                         break;
 874                 case PAN_IMAGE_SIZE_25:
 875                         pw->image_size = 25;
 876                         pw->thumb_gap = PAN_THUMB_GAP_NORMAL;
 877                         break;
 878                 case PAN_IMAGE_SIZE_33:
 879                         pw->image_size = 33;
 880                         pw->thumb_gap = PAN_THUMB_GAP_LARGE;
 881                         break;
 882                 case PAN_IMAGE_SIZE_50:
 883                         pw->image_size = 50;
 884                         pw->thumb_gap = PAN_THUMB_GAP_HUGE;
 885                         break;
 886                 case PAN_IMAGE_SIZE_100:
 887                         pw->image_size = 100;
 888                         pw->thumb_gap = PAN_THUMB_GAP_HUGE;
 889                         break;
 890                 }
 891
 892         *width = 0;
 893         *height = 0;
 894         *scroll_x = 0;
 895         *scroll_y = 0;
 896
 897         switch (pw->layout)
 898                 {
 899                 case PAN_LAYOUT_GRID:
 900                 default:
 901                         pan_grid_compute(pw, dir_fd, width, height);
 902                         break;
 903                 case PAN_LAYOUT_FOLDERS_LINEAR:
 904                         pan_folder_tree_compute(pw, dir_fd, width, height);
 905                         break;
 906                 case PAN_LAYOUT_FOLDERS_FLOWER:
 907                         pan_flower_compute(pw, dir_fd, width, height, scroll_x, scroll_y);
 908                         break;
 909                 case PAN_LAYOUT_CALENDAR:
 910                         pan_calendar_compute(pw, dir_fd, width, height);
 911                         break;
 912                 case PAN_LAYOUT_TIMELINE:
 913                         pan_timeline_compute(pw, dir_fd, width, height);
 914                         break;
 915                 }
 916
 917         pan_cache_free(pw);
 918
 919         DEBUG_1("computed %d objects", g_list_length(pw->list));
 920 }
 921
 922 static GList *pan_layout_intersect_l(GList *list, GList *item_list,
 923                                      gint x, gint y, gint width, gint height)
 924 {
 925         GList *work;
 926
 927         work = item_list;
 928         while (work)
 929                 {
 930                 PanItem *pi;
 931                 gint rx, ry, rw, rh;
 932
 933                 pi = static_cast<PanItem *>(work->data);
 934                 work = work->next;
 935
 936                 if (util_clip_region(x, y, width, height,
 937                                      pi->x, pi->y, pi->width, pi->height,
 938                                      &rx, &ry, &rw, &rh))
 939                         {
 940                         list = g_list_prepend(list, pi);
 941                         }
 942                 }
 943
 944         return list;
 945 }
 946
 947 GList *pan_layout_intersect(PanWindow *pw, gint x, gint y, gint width, gint height)
 948 {
 949         GList *list = nullptr;
 950         GList *grid;
 951         PanGrid *pg = nullptr;
 952
 953         grid = pw->list_grid;
 954         while (grid && !pg)
 955                 {
 956                 pg = static_cast<PanGrid *>(grid->data);
 957                 grid = grid->next;
 958
 959                 if (x < pg->x || x + width > pg->x + pg->w ||
 960                     y < pg->y || y + height > pg->y + pg->h)
 961                         {
 962                         pg = nullptr;
 963                         }
 964                 }
 965
 966         list = pan_layout_intersect_l(list, pw->list, x, y, width, height);
 967
 968         if (pg)
 969                 {
 970                 list = pan_layout_intersect_l(list, pg->list, x, y, width, height);
 971                 }
 972         else
 973                 {
 974                 list = pan_layout_intersect_l(list, pw->list_static, x, y, width, height);
 975                 }
 976
 977         return list;
 978 }
 979
 980 void pan_layout_resize(PanWindow *pw)
 981 {
 982         gint width = 0;
 983         gint height = 0;
 984         GList *work;
 985         PixbufRenderer *pr;
 986
 987         work = pw->list;
 988         while (work)
 989                 {
 990                 PanItem *pi;
 991
 992                 pi = static_cast<PanItem *>(work->data);
 993                 work = work->next;
 994
 995                 if (width < pi->x + pi->width) width = pi->x + pi->width;
 996                 if (height < pi->y + pi->height) height = pi->y + pi->height;
 997                 }
 998         work = pw->list_static;
 999         while (work)
1000                 {
1001                 PanItem *pi;
1002
1003                 pi = static_cast<PanItem *>(work->data);
1004                 work = work->next;
1005
1006                 if (width < pi->x + pi->width) width = pi->x + pi->width;
1007                 if (height < pi->y + pi->height) height = pi->y + pi->height;
1008                 }
1009
1010         width += PAN_BOX_BORDER * 2;
1011         height += PAN_BOX_BORDER * 2;
1012
1013         pr = PIXBUF_RENDERER(pw->imd->pr);
1014         if (width < pr->window_width) width = pr->window_width;
1015         if (height < pr->window_width) height = pr->window_height;
1016
1017         pixbuf_renderer_set_tiles_size(PIXBUF_RENDERER(pw->imd->pr), width, height);
1018 }
1019
1020 static gint pan_layout_update_idle_cb(gpointer data)
1021 {
1022         auto pw = static_cast<PanWindow *>(data);
1023         gint width;
1024         gint height;
1025         gint scroll_x;
1026         gint scroll_y;
1027
1028         if (pw->size > PAN_IMAGE_SIZE_THUMB_LARGE ||
1029             (pw->exif_date_enable && (pw->layout == PAN_LAYOUT_TIMELINE || pw->layout == PAN_LAYOUT_CALENDAR)))
1030                 {
1031                 if (!pw->cache_list && !pw->cache_todo)
1032                         {
1033                         pan_cache_fill(pw, pw->dir_fd);
1034                         if (pw->cache_todo)
1035                                 {
1036                                 pan_window_message(pw, _("Reading image data..."));
1037                                 return G_SOURCE_CONTINUE;
1038                                 }
1039                         }
1040                 if (pw->cache_todo)
1041                         {
1042                         pw->cache_count++;
1043                         pw->cache_tick++;
1044                         if (pw->cache_count == pw->cache_total)
1045                                 {
1046                                 pan_window_message(pw, _("Sorting..."));
1047                                 }
1048                         else if (pw->cache_tick > 9)
1049                                 {
1050                                 gchar *buf;
1051
1052                                 buf = g_strdup_printf("%s %d / %d", _("Reading image data..."),
1053                                                       pw->cache_count, pw->cache_total);
1054                                 pan_window_message(pw, buf);
1055                                 g_free(buf);
1056
1057                                 pw->cache_tick = 0;
1058                                 }
1059
1060                         if (pan_cache_step(pw)) return G_SOURCE_CONTINUE;
1061
1062                         pw->idle_id = 0;
1063                         return G_SOURCE_REMOVE;
1064                         }
1065                 }
1066
1067         pan_layout_compute(pw, pw->dir_fd, &width, &height, &scroll_x, &scroll_y);
1068
1069         pan_window_zoom_limit(pw);
1070
1071         if (width > 0 && height > 0)
1072                 {
1073                 gdouble align;
1074
1075                 DEBUG_1("Canvas size is %d x %d", width, height);
1076
1077                 pan_grid_build(pw, width, height, 1000);
1078
1079                 pixbuf_renderer_set_tiles(PIXBUF_RENDERER(pw->imd->pr), width, height,
1080                                           PAN_TILE_SIZE, PAN_TILE_SIZE, 10,
1081                                           pan_window_request_tile_cb,
1082                                           pan_window_dispose_tile_cb, pw, 1.0);
1083
1084                 if (scroll_x == 0 && scroll_y == 0)
1085                         {
1086                         align = 0.0;
1087                         }
1088                 else
1089                         {
1090                         align = 0.5;
1091                         }
1092                 pixbuf_renderer_scroll_to_point(PIXBUF_RENDERER(pw->imd->pr), scroll_x, scroll_y, align, align);
1093                 }
1094
1095         pan_window_message(pw, nullptr);
1096
1097         pw->idle_id = 0;
1098         return G_SOURCE_REMOVE;
1099 }
1100
1101 static void pan_layout_update_idle(PanWindow *pw)
1102 {
1103         if (!pw->idle_id)
1104                 {
1105                 pw->idle_id = g_idle_add(pan_layout_update_idle_cb, pw);
1106                 }
1107 }
1108
1109 void pan_layout_update(PanWindow *pw)
1110 {
1111         pan_window_message(pw, _("Sorting images..."));
1112         pan_layout_update_idle(pw);
1113 }
1114
1115 static void pan_layout_set_fd(PanWindow *pw, FileData *dir_fd)
1116 {
1117         if (!dir_fd) return;
1118
1119         if (strcmp(dir_fd->path, G_DIR_SEPARATOR_S) == 0)
1120                 {
1121                 pan_warning_folder(dir_fd->path, pw->window);
1122                 return;
1123                 }
1124
1125         file_data_unref(pw->dir_fd);
1126         pw->dir_fd = file_data_ref(dir_fd);
1127
1128         pan_layout_update(pw);
1129 }
1130
1131
1132 /*
1133  *-----------------------------------------------------------------------------
1134  * keyboard handlers
1135  *-----------------------------------------------------------------------------
1136  */
1137
1138 FileData *pan_menu_click_fd(PanWindow *pw)
1139 {
1140         if (pw->click_pi && pw->click_pi->fd) return pw->click_pi->fd;
1141         return nullptr;
1142 }
1143
1144 static gboolean pan_window_key_press_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
1145 {
1146         auto pw = static_cast<PanWindow *>(data);
1147         PixbufRenderer *pr;
1148         FileData *fd;
1149         gboolean stop_signal = FALSE;
1150         GtkWidget *menu;
1151         GtkWidget *imd_widget;
1152         gint x = 0;
1153         gint y = 0;
1154         gint focused;
1155         gint on_entry;
1156
1157         pr = PIXBUF_RENDERER(pw->imd->pr);
1158         fd = pan_menu_click_fd(pw);
1159
1160         imd_widget = gtk_container_get_focus_child(GTK_CONTAINER(pw->imd->widget));
1161         focused = (pw->fs || (imd_widget && gtk_widget_has_focus(imd_widget)));
1162         on_entry = (gtk_widget_has_focus(pw->path_entry) ||
1163                     gtk_widget_has_focus(pw->search_ui->search_entry) ||
1164                     gtk_widget_has_focus(pw->filter_ui->filter_entry));
1165
1166         if (focused)
1167                 {
1168                 stop_signal = TRUE;
1169                 switch (event->keyval)
1170                         {
1171                         case GDK_KEY_Left: case GDK_KEY_KP_Left:
1172                                 x -= 1;
1173                                 break;
1174                         case GDK_KEY_Right: case GDK_KEY_KP_Right:
1175                                 x += 1;
1176                                 break;
1177                         case GDK_KEY_Up: case GDK_KEY_KP_Up:
1178                                 y -= 1;
1179                                 break;
1180                         case GDK_KEY_Down: case GDK_KEY_KP_Down:
1181                                 y += 1;
1182                                 break;
1183                         case GDK_KEY_Page_Up: case GDK_KEY_KP_Page_Up:
1184                                 pixbuf_renderer_scroll(pr, 0, 0 - pr->vis_height / 2);
1185                                 break;
1186                         case GDK_KEY_Page_Down: case GDK_KEY_KP_Page_Down:
1187                                 pixbuf_renderer_scroll(pr, 0, pr->vis_height / 2);
1188                                 break;
1189                         case GDK_KEY_Home: case GDK_KEY_KP_Home:
1190                                 pixbuf_renderer_scroll(pr, 0 - pr->vis_width / 2, 0);
1191                                 break;
1192                         case GDK_KEY_End: case GDK_KEY_KP_End:
1193                                 pixbuf_renderer_scroll(pr, pr->vis_width / 2, 0);
1194                                 break;
1195                         default:
1196                                 stop_signal = FALSE;
1197                                 break;
1198                         }
1199
1200                 if (x != 0 || y!= 0)
1201                         {
1202                         if (event->state & GDK_SHIFT_MASK)
1203                                 {
1204                                 x *= 3;
1205                                 y *= 3;
1206                                 }
1207                         keyboard_scroll_calc(&x, &y, event);
1208                         pixbuf_renderer_scroll(pr, x, y);
1209                         }
1210                 }
1211
1212         if (stop_signal) return stop_signal;
1213
1214         if (event->state & GDK_CONTROL_MASK)
1215                 {
1216                 stop_signal = TRUE;
1217                 switch (event->keyval)
1218                         {
1219                         case '1':
1220                         case '2':
1221                         case '3':
1222                         case '4':
1223                         case '5':
1224                         case '6':
1225                         case '7':
1226                         case '8':
1227                         case '9':
1228                         case '0':
1229                                 break;
1230                         case 'C': case 'c':
1231                                 if (fd) file_util_copy(fd, nullptr, nullptr, GTK_WIDGET(pr));
1232                                 break;
1233                         case 'M': case 'm':
1234                                 if (fd) file_util_move(fd, nullptr, nullptr, GTK_WIDGET(pr));
1235                                 break;
1236                         case 'R': case 'r':
1237                                 if (fd) file_util_rename(fd, nullptr, GTK_WIDGET(pr));
1238                                 break;
1239                         case 'D': case 'd':
1240                                 if (fd)
1241                                         {
1242                                         options->file_ops.safe_delete_enable = TRUE;
1243                                         file_util_delete(fd, nullptr, GTK_WIDGET(pr));
1244                                         }
1245                                 break;
1246                         case 'F': case 'f':
1247                                 pan_search_toggle_visible(pw, TRUE);
1248                                 break;
1249                         case 'G': case 'g':
1250                                 pan_search_activate(pw);
1251                                 break;
1252                         case 'W': case 'w':
1253                                 pan_window_close(pw);
1254                                 break;
1255                         default:
1256                                 stop_signal = FALSE;
1257                                 break;
1258                         }
1259                 }
1260         else
1261                 {
1262                 stop_signal = TRUE;
1263                 switch (event->keyval)
1264                         {
1265                         case GDK_KEY_Escape:
1266                                 if (pw->fs)
1267                                         {
1268                                         pan_fullscreen_toggle(pw, TRUE);
1269                                         }
1270                                 else
1271                                         {
1272                                         pan_search_toggle_visible(pw, FALSE);
1273                                         }
1274                                 break;
1275                         default:
1276                                 stop_signal = FALSE;
1277                                 break;
1278                         }
1279
1280                 if (stop_signal) return stop_signal;
1281
1282                 // Don't steal characters from entry boxes.
1283                 if (!on_entry)
1284                         {
1285                         stop_signal = TRUE;
1286                         switch (event->keyval)
1287                                 {
1288                                 case '+': case '=': case GDK_KEY_KP_Add:
1289                                         pixbuf_renderer_zoom_adjust(pr, ZOOM_INCREMENT);
1290                                         break;
1291                                 case '-': case GDK_KEY_KP_Subtract:
1292                                         pixbuf_renderer_zoom_adjust(pr, -ZOOM_INCREMENT);
1293                                         break;
1294                                 case 'Z': case 'z': case GDK_KEY_KP_Divide: case '1':
1295                                         pixbuf_renderer_zoom_set(pr, 1.0);
1296                                         break;
1297                                 case '2':
1298                                         pixbuf_renderer_zoom_set(pr, 2.0);
1299                                         break;
1300                                 case '3':
1301                                         pixbuf_renderer_zoom_set(pr, 3.0);
1302                                         break;
1303                                 case '4':
1304                                         pixbuf_renderer_zoom_set(pr, 4.0);
1305                                         break;
1306                                 case '7':
1307                                         pixbuf_renderer_zoom_set(pr, -4.0);
1308                                         break;
1309                                 case '8':
1310                                         pixbuf_renderer_zoom_set(pr, -3.0);
1311                                         break;
1312                                 case '9':
1313                                         pixbuf_renderer_zoom_set(pr, -2.0);
1314                                         break;
1315                                 case 'F': case 'f':
1316                                 case 'V': case 'v':
1317                                 case GDK_KEY_F11:
1318                                         pan_fullscreen_toggle(pw, FALSE);
1319                                         break;
1320                                 case 'I': case 'i':
1321                                         break;
1322                                 case GDK_KEY_Delete: case GDK_KEY_KP_Delete:
1323                                         break;
1324                                 case GDK_KEY_Menu:
1325                                 case GDK_KEY_F10:
1326                                         menu = pan_popup_menu(pw);
1327                                         gtk_menu_popup_at_widget(GTK_MENU(menu), widget, GDK_GRAVITY_SOUTH, GDK_GRAVITY_CENTER, nullptr);
1328
1329                                         break;
1330                                 case '/':
1331                                         pan_search_toggle_visible(pw, TRUE);
1332                                         break;
1333                                         stop_signal = FALSE;
1334                                         break;
1335                                 }
1336                         }
1337                 }
1338         if (!stop_signal && is_help_key(event))
1339                 {
1340                 help_window_show("GuideOtherWindowsPanView.html");
1341                 stop_signal = TRUE;
1342                 }
1343
1344         return stop_signal;
1345 }
1346
1347 /*
1348  *-----------------------------------------------------------------------------
1349  * info popup
1350  *-----------------------------------------------------------------------------
1351  */
1352
1353 static void pan_info_add_exif(PanTextAlignment *ta, FileData *fd)
1354 {
1355         GList *exif_list;
1356         gchar *text;
1357         gchar *title;
1358         gchar *key;
1359
1360         if (!fd) return;
1361
1362         exif_list = bar_pane_exif_list();
1363         while (exif_list)
1364                 {
1365                 title = static_cast<gchar *>(exif_list->data);
1366                 exif_list = exif_list->next;
1367                 key = static_cast<gchar *>(exif_list->data);
1368                 exif_list = exif_list->next;
1369
1370                 text = metadata_read_string(fd, key, METADATA_FORMATTED);
1371                 if (text && text[0] != '\0')
1372                         {
1373                         pan_text_alignment_add(ta, title, text);
1374                         }
1375
1376                 g_free(text);
1377                 }
1378
1379         g_list_free_full(exif_list, g_free);
1380 }
1381
1382
1383 void pan_info_update(PanWindow *pw, PanItem *pi)
1384 {
1385         PanTextAlignment *ta;
1386         PanItem *pbox;
1387         PanItem *p;
1388         gchar *buf;
1389         gint x1, y1, x2, y2, x3, y3;
1390         gint x, y, w, h;
1391
1392         if (pw->click_pi == pi) return;
1393         if (pi && !pi->fd) pi = nullptr;
1394
1395         while ((p = pan_item_find_by_key(pw, PAN_ITEM_NONE, "info"))) pan_item_remove(pw, p);
1396         pw->click_pi = pi;
1397
1398         if (!pi) return;
1399
1400         DEBUG_1("info set to %s", pi->fd->path);
1401
1402         pbox = pan_item_box_new(pw, nullptr, pi->x + pi->width + 4, pi->y, 10, 10,
1403                                 PAN_POPUP_BORDER,
1404                                 PAN_POPUP_COLOR, PAN_POPUP_ALPHA,
1405                                 PAN_POPUP_BORDER_COLOR, PAN_POPUP_ALPHA);
1406         pan_item_set_key(pbox, "info");
1407
1408         if (pi->type == PAN_ITEM_THUMB && pi->pixbuf)
1409                 {
1410                 w = gdk_pixbuf_get_width(pi->pixbuf);
1411                 h = gdk_pixbuf_get_height(pi->pixbuf);
1412
1413                 x1 = pi->x + pi->width - (pi->width - w) / 2 - 8;
1414                 y1 = pi->y + (pi->height - h) / 2 + 8;
1415                 }
1416         else
1417                 {
1418                 x1 = pi->x + pi->width - 8;
1419                 y1 = pi->y + 8;
1420                 }
1421
1422         x2 = pbox->x + 1;
1423         y2 = pbox->y + 36;
1424         x3 = pbox->x + 1;
1425         y3 = pbox->y + 12;
1426         util_clip_triangle(x1, y1, x2, y2, x3, y3,
1427                            &x, &y, &w, &h);
1428
1429         p = pan_item_tri_new(pw, nullptr, x, y, w, h,
1430                              x1, y1, x2, y2, x3, y3,
1431                              PAN_POPUP_COLOR, PAN_POPUP_ALPHA);
1432         pan_item_tri_border(p, PAN_BORDER_1 | PAN_BORDER_3, PAN_POPUP_BORDER_COLOR, PAN_POPUP_ALPHA);
1433         pan_item_set_key(p, "info");
1434         pan_item_added(pw, p);
1435
1436         ta = pan_text_alignment_new(pw, pbox->x + PREF_PAD_BORDER, pbox->y + PREF_PAD_BORDER, "info");
1437
1438         pan_text_alignment_add(ta, _("Filename:"), pi->fd->name);
1439         buf = remove_level_from_path(pi->fd->path);
1440         pan_text_alignment_add(ta, _("Location:"), buf);
1441         g_free(buf);
1442         pan_text_alignment_add(ta, _("Date:"), text_from_time(pi->fd->date));
1443         buf = text_from_size(pi->fd->size);
1444         pan_text_alignment_add(ta, _("Size:"), buf);
1445         g_free(buf);
1446
1447         if (pw->info_includes_exif)
1448                 {
1449                 pan_info_add_exif(ta, pi->fd);
1450                 }
1451
1452         pan_text_alignment_calc(ta, pbox);
1453         pan_text_alignment_free(ta);
1454
1455         pan_item_box_shadow(pbox, PAN_SHADOW_OFFSET * 2, PAN_SHADOW_FADE * 2);
1456         pan_item_added(pw, pbox);
1457
1458         if (pw->info_image_size > PAN_IMAGE_SIZE_THUMB_NONE)
1459                 {
1460                 gint iw, ih;
1461                 if (image_load_dimensions(pi->fd, &iw, &ih))
1462                         {
1463                         gint scale = 25;
1464
1465                         switch (pw->info_image_size)
1466                                 {
1467                                 case PAN_IMAGE_SIZE_10:
1468                                         scale = 10;
1469                                         break;
1470                                 case PAN_IMAGE_SIZE_25:
1471                                         scale = 25;
1472                                         break;
1473                                 case PAN_IMAGE_SIZE_33:
1474                                         scale = 33;
1475                                         break;
1476                                 case PAN_IMAGE_SIZE_50:
1477                                         scale = 50;
1478                                         break;
1479                                 case PAN_IMAGE_SIZE_100:
1480                                         scale = 100;
1481                                         break;
1482                                 }
1483
1484                         iw = MAX(1, iw * scale / 100);
1485                         ih = MAX(1, ih * scale / 100);
1486
1487                         pbox = pan_item_box_new(pw, nullptr, pbox->x, pbox->y + pbox->height + 8, 10, 10,
1488                                                 PAN_POPUP_BORDER,
1489                                                 PAN_POPUP_COLOR, PAN_POPUP_ALPHA,
1490                                                 PAN_POPUP_BORDER_COLOR, PAN_POPUP_ALPHA);
1491                         pan_item_set_key(pbox, "info");
1492
1493                         p = pan_item_image_new(pw, file_data_new_group(pi->fd->path),
1494                                                pbox->x + PREF_PAD_BORDER, pbox->y + PREF_PAD_BORDER, iw, ih);
1495                         pan_item_set_key(p, "info");
1496                         pan_item_size_by_item(pbox, p, PREF_PAD_BORDER);
1497
1498                         pan_item_box_shadow(pbox, PAN_SHADOW_OFFSET * 2, PAN_SHADOW_FADE * 2);
1499                         pan_item_added(pw, pbox);
1500                         }
1501                 }
1502
1503         pan_layout_resize(pw);
1504 }
1505
1506
1507 /*
1508  *-----------------------------------------------------------------------------
1509  * main window
1510  *-----------------------------------------------------------------------------
1511  */
1512
1513 static void button_cb(PixbufRenderer *pr, GdkEventButton *event, gpointer data)
1514 {
1515         auto pw = static_cast<PanWindow *>(data);
1516         PanItem *pi = nullptr;
1517         GtkWidget *menu;
1518         gint rx, ry;
1519
1520         rx = ry = 0;
1521         if (pr->scale)
1522                 {
1523                 rx = static_cast<gdouble>(pr->x_scroll + event->x - pr->x_offset) / pr->scale;
1524                 ry = static_cast<gdouble>(pr->y_scroll + event->y - pr->y_offset) / pr->scale;
1525                 }
1526
1527         pi = pan_item_find_by_coord(pw, PAN_ITEM_BOX, rx, ry, "info");
1528         if (pi && event->button == MOUSE_BUTTON_LEFT)
1529                 {
1530                 pan_info_update(pw, nullptr);
1531                 return;
1532                 }
1533
1534         pi = pan_item_find_by_coord(pw, (pw->size > PAN_IMAGE_SIZE_THUMB_LARGE) ? PAN_ITEM_IMAGE : PAN_ITEM_THUMB,
1535                                     rx, ry, nullptr);
1536
1537         switch (event->button)
1538                 {
1539                 case MOUSE_BUTTON_LEFT:
1540                         pan_info_update(pw, pi);
1541
1542                         if (!pi && pw->layout == PAN_LAYOUT_CALENDAR)
1543                                 {
1544                                 pi = pan_item_find_by_coord(pw, PAN_ITEM_BOX, rx, ry, "day");
1545                                 pan_calendar_update(pw, pi);
1546                                 }
1547                         break;
1548                 case MOUSE_BUTTON_MIDDLE:
1549                         break;
1550                 case MOUSE_BUTTON_RIGHT:
1551                         pan_info_update(pw, pi);
1552                         menu = pan_popup_menu(pw);
1553                         gtk_menu_popup_at_pointer(GTK_MENU(menu), nullptr);
1554                         break;
1555                 default:
1556                         break;
1557                 }
1558 }
1559
1560 static void scroll_cb(PixbufRenderer *pr, GdkEventScroll *event, gpointer)
1561 {
1562         gint w, h;
1563
1564         w = pr->vis_width;
1565         h = pr->vis_height;
1566
1567         if (!(event->state & GDK_SHIFT_MASK))
1568                 {
1569                 w /= 3;
1570                 h /= 3;
1571                 }
1572
1573         if (event->state & GDK_CONTROL_MASK)
1574                 {
1575                 switch (event->direction)
1576                         {
1577                         case GDK_SCROLL_UP:
1578                                 pixbuf_renderer_zoom_adjust_at_point(pr, ZOOM_INCREMENT,
1579                                                                      static_cast<gint>(event->x), static_cast<gint>(event->y));
1580                                 break;
1581                         case GDK_SCROLL_DOWN:
1582                                 pixbuf_renderer_zoom_adjust_at_point(pr, -ZOOM_INCREMENT,
1583                                                                      static_cast<gint>(event->x), static_cast<gint>(event->y));
1584                                 break;
1585                         default:
1586                                 break;
1587                         }
1588                 }
1589         else
1590                 {
1591                 switch (event->direction)
1592                         {
1593                         case GDK_SCROLL_UP:
1594                                 pixbuf_renderer_scroll(pr, 0, -h);
1595                                 break;
1596                         case GDK_SCROLL_DOWN:
1597                                 pixbuf_renderer_scroll(pr, 0, h);
1598                                 break;
1599                         case GDK_SCROLL_LEFT:
1600                                 pixbuf_renderer_scroll(pr, -w, 0);
1601                                 break;
1602                         case GDK_SCROLL_RIGHT:
1603                                 pixbuf_renderer_scroll(pr, w, 0);
1604                                 break;
1605                         default:
1606                                 break;
1607                         }
1608                 }
1609 }
1610
1611 static void pan_image_set_buttons(PanWindow *pw, ImageWindow *imd)
1612 {
1613         g_signal_connect(G_OBJECT(imd->pr), "clicked",
1614                          G_CALLBACK(button_cb), pw);
1615         g_signal_connect(G_OBJECT(imd->pr), "scroll_event",
1616                          G_CALLBACK(scroll_cb), pw);
1617 }
1618
1619 static void pan_fullscreen_stop_func(FullScreenData *, gpointer data)
1620 {
1621         auto pw = static_cast<PanWindow *>(data);
1622
1623         pw->fs = nullptr;
1624         pw->imd = pw->imd_normal;
1625 }
1626
1627 static void pan_fullscreen_toggle(PanWindow *pw, gboolean force_off)
1628 {
1629         if (force_off && !pw->fs) return;
1630
1631         if (pw->fs)
1632                 {
1633                 fullscreen_stop(pw->fs);
1634                 }
1635         else
1636                 {
1637                 pw->fs = fullscreen_start(pw->window, pw->imd, pan_fullscreen_stop_func, pw);
1638                 pan_image_set_buttons(pw, pw->fs->imd);
1639                 g_signal_connect(G_OBJECT(pw->fs->window), "key_press_event",
1640                                  G_CALLBACK(pan_window_key_press_cb), pw);
1641
1642                 pw->imd = pw->fs->imd;
1643                 }
1644 }
1645
1646 static void pan_window_image_zoom_cb(PixbufRenderer *, gdouble, gpointer data)
1647 {
1648         auto pw = static_cast<PanWindow *>(data);
1649         gchar *text;
1650
1651         text = image_zoom_get_as_text(pw->imd);
1652         gtk_label_set_text(GTK_LABEL(pw->label_zoom), text);
1653         g_free(text);
1654 }
1655
1656 static void pan_window_image_scroll_notify_cb(PixbufRenderer *pr, gpointer data)
1657 {
1658         auto pw = static_cast<PanWindow *>(data);
1659         GtkAdjustment *adj;
1660         GdkRectangle rect;
1661         gint width, height;
1662
1663         if (pr->scale == 0.0) return;
1664
1665         pixbuf_renderer_get_visible_rect(pr, &rect);
1666         pixbuf_renderer_get_image_size(pr, &width, &height);
1667
1668         adj = gtk_range_get_adjustment(GTK_RANGE(pw->scrollbar_h));
1669         gtk_adjustment_set_page_size(adj, rect.width);
1670         gtk_adjustment_set_page_increment(adj, gtk_adjustment_get_page_size(adj) / 2.0);
1671         gtk_adjustment_set_step_increment(adj, 48.0 / pr->scale);
1672         gtk_adjustment_set_lower(adj, 0.0);
1673         gtk_adjustment_set_upper(adj, MAX((gdouble)width, 1.0));
1674         gtk_adjustment_set_value(adj, static_cast<gdouble>(rect.x));
1675
1676         pref_signal_block_data(pw->scrollbar_h, pw);
1677         pref_signal_unblock_data(pw->scrollbar_h, pw);
1678
1679         adj = gtk_range_get_adjustment(GTK_RANGE(pw->scrollbar_v));
1680         gtk_adjustment_set_page_size(adj, rect.height);
1681         gtk_adjustment_set_page_increment(adj, gtk_adjustment_get_page_size(adj) / 2.0);
1682         gtk_adjustment_set_step_increment(adj, 48.0 / pr->scale);
1683         gtk_adjustment_set_lower(adj, 0.0);
1684         gtk_adjustment_set_upper(adj, MAX((gdouble)height, 1.0));
1685         gtk_adjustment_set_value(adj, static_cast<gdouble>(rect.y));
1686
1687         pref_signal_block_data(pw->scrollbar_v, pw);
1688         pref_signal_unblock_data(pw->scrollbar_v, pw);
1689 }
1690
1691 static void pan_window_scrollbar_h_value_cb(GtkRange *range, gpointer data)
1692 {
1693         auto pw = static_cast<PanWindow *>(data);
1694         PixbufRenderer *pr;
1695         gint x;
1696
1697         pr = PIXBUF_RENDERER(pw->imd_normal->pr);
1698
1699         if (!pr->scale) return;
1700
1701         x = static_cast<gint>(gtk_range_get_value(range));
1702
1703         pixbuf_renderer_scroll_to_point(pr, x, static_cast<gint>(static_cast<gdouble>(pr->y_scroll) / pr->scale), 0.0, 0.0);
1704 }
1705
1706 static void pan_window_scrollbar_v_value_cb(GtkRange *range, gpointer data)
1707 {
1708         auto pw = static_cast<PanWindow *>(data);
1709         PixbufRenderer *pr;
1710         gint y;
1711
1712         pr = PIXBUF_RENDERER(pw->imd_normal->pr);
1713
1714         if (!pr->scale) return;
1715
1716         y = static_cast<gint>(gtk_range_get_value(range));
1717
1718         pixbuf_renderer_scroll_to_point(pr, static_cast<gint>(static_cast<gdouble>(pr->x_scroll) / pr->scale), y, 0.0, 0.0);
1719 }
1720
1721 static void pan_window_layout_change_cb(GtkWidget *combo, gpointer data)
1722 {
1723         auto pw = static_cast<PanWindow *>(data);
1724
1725         pw->layout = static_cast<PanLayoutType>(gtk_combo_box_get_active(GTK_COMBO_BOX(combo)));
1726         pan_layout_update(pw);
1727 }
1728
1729 static void pan_window_layout_size_cb(GtkWidget *combo, gpointer data)
1730 {
1731         auto pw = static_cast<PanWindow *>(data);
1732
1733         pw->size = static_cast<PanImageSize>(gtk_combo_box_get_active(GTK_COMBO_BOX(combo)));
1734         pan_layout_update(pw);
1735 }
1736
1737 static void pan_window_entry_activate_cb(const gchar *new_text, gpointer data)
1738 {
1739         auto pw = static_cast<PanWindow *>(data);
1740         gchar *path;
1741
1742         path = remove_trailing_slash(new_text);
1743         parse_out_relatives(path);
1744
1745         if (!isdir(path))
1746                 {
1747                 warning_dialog(_("Folder not found"),
1748                                _("The entered path is not a folder"),
1749                                GQ_ICON_DIALOG_WARNING, pw->path_entry);
1750                 }
1751         else
1752                 {
1753                 FileData *dir_fd = file_data_new_dir(path);
1754                 tab_completion_append_to_history(pw->path_entry, path);
1755
1756                 pan_layout_set_fd(pw, dir_fd);
1757                 file_data_unref(dir_fd);
1758                 }
1759
1760         g_free(path);
1761 }
1762
1763 static void pan_window_close(PanWindow *pw)
1764 {
1765         pan_window_list = g_list_remove(pan_window_list, pw);
1766
1767         pref_list_int_set(PAN_PREF_GROUP, PAN_PREF_EXIF_PAN_DATE, pw->exif_date_enable);
1768         pref_list_int_set(PAN_PREF_GROUP, PAN_PREF_INFO_IMAGE, pw->info_image_size);
1769         pref_list_int_set(PAN_PREF_GROUP, PAN_PREF_INFO_EXIF, pw->info_includes_exif);
1770
1771         if (pw->idle_id)
1772                 {
1773                 g_source_remove(pw->idle_id);
1774                 }
1775
1776         pan_fullscreen_toggle(pw, TRUE);
1777         pan_search_ui_destroy(&pw->search_ui);
1778         pan_filter_ui_destroy(&pw->filter_ui);
1779         gtk_widget_destroy(pw->window);
1780
1781         pan_window_items_free(pw);
1782         pan_cache_free(pw);
1783
1784         file_data_unref(pw->dir_fd);
1785
1786         g_free(pw);
1787 }
1788
1789 static gboolean pan_window_delete_cb(GtkWidget *, GdkEventAny *, gpointer data)
1790 {
1791         auto pw = static_cast<PanWindow *>(data);
1792
1793         pan_window_close(pw);
1794         return TRUE;
1795 }
1796
1797 static void pan_window_new_real(FileData *dir_fd)
1798 {
1799         PanWindow *pw;
1800         GtkWidget *vbox;
1801         GtkWidget *box;
1802         GtkWidget *combo;
1803         GtkWidget *hbox;
1804         GtkWidget *frame;
1805         GtkWidget *table;
1806         GdkGeometry geometry;
1807
1808         pw = g_new0(PanWindow, 1);
1809
1810         pw->dir_fd = file_data_ref(dir_fd);
1811         pw->layout = PAN_LAYOUT_TIMELINE;
1812         pw->size = PAN_IMAGE_SIZE_THUMB_NORMAL;
1813         pw->thumb_size = PAN_THUMB_SIZE_NORMAL;
1814         pw->thumb_gap = PAN_THUMB_GAP_NORMAL;
1815
1816         if (!pref_list_int_get(PAN_PREF_GROUP, PAN_PREF_EXIF_PAN_DATE, &pw->exif_date_enable))
1817                 {
1818                 pw->exif_date_enable = FALSE;
1819                 }
1820         if (!pref_list_int_get(PAN_PREF_GROUP, PAN_PREF_INFO_IMAGE, &pw->info_image_size))
1821                 {
1822                 pw->info_image_size = PAN_IMAGE_SIZE_THUMB_NONE;
1823                 }
1824         if (!pref_list_int_get(PAN_PREF_GROUP, PAN_PREF_INFO_EXIF, &pw->info_includes_exif))
1825                 {
1826                 pw->info_includes_exif = TRUE;
1827                 }
1828
1829         pw->ignore_symlinks = TRUE;
1830
1831         pw->idle_id = 0;
1832
1833         pw->window = window_new(GTK_WINDOW_TOPLEVEL, "panview", nullptr, nullptr, _("Pan View"));
1834         DEBUG_NAME(pw->window);
1835
1836         geometry.min_width = DEFAULT_MINIMAL_WINDOW_SIZE;
1837         geometry.min_height = DEFAULT_MINIMAL_WINDOW_SIZE;
1838         gtk_window_set_geometry_hints(GTK_WINDOW(pw->window), nullptr, &geometry, GDK_HINT_MIN_SIZE);
1839
1840         gtk_window_set_resizable(GTK_WINDOW(pw->window), TRUE);
1841         gtk_container_set_border_width(GTK_CONTAINER(pw->window), 0);
1842
1843         vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
1844         DEBUG_NAME(vbox);
1845         gtk_container_add(GTK_CONTAINER(pw->window), vbox);
1846         gtk_widget_show(vbox);
1847
1848         box = pref_box_new(vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
1849
1850         pref_spacer(box, 0);
1851         pref_label_new(box, _("Location:"));
1852         combo = tab_completion_new_with_history(&pw->path_entry, dir_fd->path, "pan_view_path", -1,
1853                                                 pan_window_entry_activate_cb, pw);
1854         gtk_box_pack_start(GTK_BOX(box), combo, TRUE, TRUE, 0);
1855         gtk_widget_show(combo);
1856
1857         combo = gtk_combo_box_text_new();
1858         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Timeline"));
1859         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Calendar"));
1860         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Folders"));
1861         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Folders (flower)"));
1862         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Grid"));
1863
1864         gtk_combo_box_set_active(GTK_COMBO_BOX(combo), pw->layout);
1865         g_signal_connect(G_OBJECT(combo), "changed",
1866                          G_CALLBACK(pan_window_layout_change_cb), pw);
1867         gtk_box_pack_start(GTK_BOX(box), combo, FALSE, FALSE, 0);
1868         gtk_widget_show(combo);
1869
1870         combo = gtk_combo_box_text_new();
1871         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Dots"));
1872         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("No Images"));
1873         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Small Thumbnails"));
1874         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Normal Thumbnails"));
1875         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("Large Thumbnails"));
1876         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("1:10 (10%)"));
1877         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("1:4 (25%)"));
1878         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("1:3 (33%)"));
1879         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("1:2 (50%)"));
1880         gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), _("1:1 (100%)"));
1881
1882         gtk_combo_box_set_active(GTK_COMBO_BOX(combo), pw->size);
1883         g_signal_connect(G_OBJECT(combo), "changed",
1884                          G_CALLBACK(pan_window_layout_size_cb), pw);
1885         gtk_box_pack_start(GTK_BOX(box), combo, FALSE, FALSE, 0);
1886         gtk_widget_show(combo);
1887
1888         table = pref_table_new(vbox, 2, 2, FALSE, TRUE);
1889         gtk_table_set_row_spacings(GTK_TABLE(table), 2);
1890         gtk_table_set_col_spacings(GTK_TABLE(table), 2);
1891
1892         pw->imd_normal = pw->imd;
1893
1894         g_signal_connect(G_OBJECT(pw->imd->pr), "zoom",
1895                          G_CALLBACK(pan_window_image_zoom_cb), pw);
1896         g_signal_connect(G_OBJECT(pw->imd->pr), "scroll_notify",
1897                          G_CALLBACK(pan_window_image_scroll_notify_cb), pw);
1898
1899         gtk_table_attach(GTK_TABLE(table), pw->imd->widget, 0, 1, 0, 1,
1900                          static_cast<GtkAttachOptions>(GTK_FILL | GTK_EXPAND), static_cast<GtkAttachOptions>(GTK_FILL | GTK_EXPAND), 0, 0);
1901         gtk_widget_show(GTK_WIDGET(pw->imd->widget));
1902
1903         pan_window_dnd_init(pw);
1904
1905         pan_image_set_buttons(pw, pw->imd);
1906
1907         pw->scrollbar_h = gtk_scrollbar_new(GTK_ORIENTATION_HORIZONTAL, nullptr);
1908         g_signal_connect(G_OBJECT(pw->scrollbar_h), "value_changed",
1909                          G_CALLBACK(pan_window_scrollbar_h_value_cb), pw);
1910         gtk_table_attach(GTK_TABLE(table), pw->scrollbar_h, 0, 1, 1, 2,
1911                          static_cast<GtkAttachOptions>(GTK_FILL | GTK_EXPAND), static_cast<GtkAttachOptions>(0), 0, 0);
1912         gtk_widget_show(pw->scrollbar_h);
1913
1914         pw->scrollbar_v = gtk_scrollbar_new(GTK_ORIENTATION_VERTICAL, nullptr);
1915         g_signal_connect(G_OBJECT(pw->scrollbar_v), "value_changed",
1916                          G_CALLBACK(pan_window_scrollbar_v_value_cb), pw);
1917         gtk_table_attach(GTK_TABLE(table), pw->scrollbar_v, 1, 2, 0, 1,
1918                          static_cast<GtkAttachOptions>(0), static_cast<GtkAttachOptions>(GTK_FILL | GTK_EXPAND), 0, 0);
1919         gtk_widget_show(pw->scrollbar_v);
1920
1921         /* find bar */
1922
1923         pw->search_ui = pan_search_ui_new(pw);
1924         gtk_box_pack_start(GTK_BOX(vbox), pw->search_ui->search_box, FALSE, FALSE, 2);
1925
1926     /* filter bar */
1927     pw->filter_ui = pan_filter_ui_new(pw);
1928     gtk_box_pack_start(GTK_BOX(vbox), pw->filter_ui->filter_box, FALSE, FALSE, 2);
1929
1930         /* status bar */
1931
1932         box = pref_box_new(vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, 0);
1933
1934         frame = gtk_frame_new(nullptr);
1935         DEBUG_NAME(frame);
1936         gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
1937         gtk_widget_set_size_request(frame, ZOOM_LABEL_WIDTH, -1);
1938         gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 0);
1939         gtk_widget_show(frame);
1940
1941         hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
1942         gtk_container_add(GTK_CONTAINER(frame), hbox);
1943         gtk_widget_show(hbox);
1944
1945         pref_spacer(hbox, 0);
1946         pw->label_message = pref_label_new(hbox, "");
1947
1948         frame = gtk_frame_new(nullptr);
1949         DEBUG_NAME(frame);
1950         gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
1951         gtk_widget_set_size_request(frame, ZOOM_LABEL_WIDTH, -1);
1952         gtk_box_pack_end(GTK_BOX(box), frame, FALSE, FALSE, 0);
1953         gtk_widget_show(frame);
1954
1955         pw->label_zoom = gtk_label_new("");
1956         gtk_container_add(GTK_CONTAINER(frame), pw->label_zoom);
1957         gtk_widget_show(pw->label_zoom);
1958
1959         // Add the "Find" button to the status bar area.
1960         gtk_box_pack_end(GTK_BOX(box), pw->search_ui->search_button, FALSE, FALSE, 0);
1961         gtk_widget_show(pw->search_ui->search_button);
1962
1963         // Add the "Filter" button to the status bar area.
1964         gtk_box_pack_end(GTK_BOX(box), pw->filter_ui->filter_button, FALSE, FALSE, 0);
1965         gtk_widget_show(pw->filter_ui->filter_button);
1966
1967         g_signal_connect(G_OBJECT(pw->window), "delete_event",
1968                          G_CALLBACK(pan_window_delete_cb), pw);
1969         g_signal_connect(G_OBJECT(pw->window), "key_press_event",
1970                          G_CALLBACK(pan_window_key_press_cb), pw);
1971
1972         gtk_window_set_default_size(GTK_WINDOW(pw->window), PAN_WINDOW_DEFAULT_WIDTH, PAN_WINDOW_DEFAULT_HEIGHT);
1973
1974         pan_layout_update(pw);
1975
1976         gtk_widget_grab_focus(GTK_WIDGET(pw->imd->widget));
1977         gtk_widget_show(pw->window);
1978
1979         pan_window_list = g_list_append(pan_window_list, pw);
1980 }
1981
1982 /*
1983  *-----------------------------------------------------------------------------
1984  * performance warnings
1985  *-----------------------------------------------------------------------------
1986  */
1987
1988 static void pan_warning_ok_cb(GenericDialog *gd, gpointer data)
1989 {
1990         auto dir_fd = static_cast<FileData *>(data);
1991
1992         generic_dialog_close(gd);
1993
1994         pan_window_new_real(dir_fd);
1995         file_data_unref(dir_fd);
1996 }
1997
1998 static void pan_warning_hide_cb(GtkWidget *button, gpointer)
1999 {
2000         gboolean hide_dlg;
2001
2002         hide_dlg = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
2003         pref_list_int_set(PAN_PREF_GROUP, PAN_PREF_HIDE_WARNING, hide_dlg);
2004 }
2005
2006 static gboolean pan_warning(FileData *dir_fd)
2007 {
2008         GenericDialog *gd;
2009         GtkWidget *box;
2010         GtkWidget *group;
2011         GtkWidget *button;
2012         GtkWidget *ct_button;
2013         gboolean hide_dlg;
2014
2015         if (dir_fd && strcmp(dir_fd->path, G_DIR_SEPARATOR_S) == 0)
2016                 {
2017                 pan_warning_folder(dir_fd->path, nullptr);
2018                 return TRUE;
2019                 }
2020
2021         if (options->thumbnails.enable_caching &&
2022             options->thumbnails.spec_standard) return FALSE;
2023
2024         if (!pref_list_int_get(PAN_PREF_GROUP, PAN_PREF_HIDE_WARNING, &hide_dlg)) hide_dlg = FALSE;
2025         if (hide_dlg) return FALSE;
2026
2027         gd = generic_dialog_new(_("Pan View Performance"), "pan_view_warning", nullptr, FALSE,
2028                                 nullptr, nullptr);
2029         gd->data = file_data_ref(dir_fd);
2030         generic_dialog_add_button(gd, GQ_ICON_OK, "OK",
2031                                   pan_warning_ok_cb, TRUE);
2032
2033         box = generic_dialog_add_message(gd, GQ_ICON_DIALOG_INFO,
2034                                          _("Pan view performance may be poor."),
2035                                          _("To improve the performance of thumbnails in\npan view the following options can be enabled.\n\nNote that both options must be enabled to\nnotice a change in performance."), TRUE);
2036
2037         group = pref_box_new(box, FALSE, GTK_ORIENTATION_HORIZONTAL, 0);
2038         pref_spacer(group, PREF_PAD_INDENT);
2039         group = pref_box_new(group, TRUE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
2040
2041         ct_button = pref_checkbox_new_int(group, _("Cache thumbnails"),
2042                                           options->thumbnails.enable_caching, &options->thumbnails.enable_caching);
2043         button = pref_checkbox_new_int(group, _("Use shared thumbnail cache"),
2044                                        options->thumbnails.spec_standard, &options->thumbnails.spec_standard);
2045         pref_checkbox_link_sensitivity(ct_button, button);
2046
2047         pref_line(box, 0);
2048
2049         pref_checkbox_new(box, _("Do not show this dialog again"), hide_dlg,
2050                           G_CALLBACK(pan_warning_hide_cb), nullptr);
2051
2052         gtk_widget_show(gd->dialog);
2053
2054         return TRUE;
2055 }
2056
2057
2058 /*
2059  *-----------------------------------------------------------------------------
2060  * entry point
2061  *-----------------------------------------------------------------------------
2062  */
2063
2064 void pan_window_new(FileData *dir_fd)
2065 {
2066         if (pan_warning(dir_fd)) return;
2067
2068         pan_window_new_real(dir_fd);
2069 }
2070
2071
2072 /*
2073  *-----------------------------------------------------------------------------
2074  * menus
2075  *-----------------------------------------------------------------------------
2076  */
2077
2078 #define INFO_IMAGE_SIZE_KEY "image_size_data"
2079
2080
2081 static void pan_new_window_cb(GtkWidget *, gpointer data)
2082 {
2083         auto pw = static_cast<PanWindow *>(data);
2084         FileData *fd;
2085
2086         fd = pan_menu_click_fd(pw);
2087         if (fd)
2088                 {
2089                 pan_fullscreen_toggle(pw, TRUE);
2090                 view_window_new(fd);
2091                 }
2092 }
2093
2094 static void pan_go_to_original_cb(GtkWidget *, gpointer data)
2095 {
2096         LayoutWindow *lw = nullptr;
2097         auto pw = static_cast<PanWindow *>(data);
2098         FileData *fd;
2099
2100         if (!layout_valid(&lw)) return;
2101
2102         fd = pan_menu_click_fd(pw);
2103         if (fd)
2104                 {
2105                 layout_set_fd(lw, fd);
2106                 }
2107 }
2108
2109 static void pan_edit_cb(GtkWidget *widget, gpointer data)
2110 {
2111         PanWindow *pw;
2112         FileData *fd;
2113         auto key = static_cast<const gchar *>(data);
2114
2115         pw = static_cast<PanWindow *>(submenu_item_get_data(widget));
2116         if (!pw) return;
2117
2118         fd = pan_menu_click_fd(pw);
2119         if (fd)
2120                 {
2121                 if (!editor_window_flag_set(key))
2122                         {
2123                         pan_fullscreen_toggle(pw, TRUE);
2124                         }
2125                 file_util_start_editor_from_file(key, fd, pw->imd->widget);
2126                 }
2127 }
2128
2129 static void pan_zoom_in_cb(GtkWidget *, gpointer data)
2130 {
2131         auto pw = static_cast<PanWindow *>(data);
2132
2133         image_zoom_adjust(pw->imd, ZOOM_INCREMENT);
2134 }
2135
2136 static void pan_zoom_out_cb(GtkWidget *, gpointer data)
2137 {
2138         auto pw = static_cast<PanWindow *>(data);
2139
2140         image_zoom_adjust(pw->imd, -ZOOM_INCREMENT);
2141 }
2142
2143 static void pan_zoom_1_1_cb(GtkWidget *, gpointer data)
2144 {
2145         auto pw = static_cast<PanWindow *>(data);
2146
2147         image_zoom_set(pw->imd, 1.0);
2148 }
2149
2150 static void pan_copy_cb(GtkWidget *, gpointer data)
2151 {
2152         auto pw = static_cast<PanWindow *>(data);
2153         FileData *fd;
2154
2155         fd = pan_menu_click_fd(pw);
2156         if (fd) file_util_copy(fd, nullptr, nullptr, pw->imd->widget);
2157 }
2158
2159 static void pan_move_cb(GtkWidget *, gpointer data)
2160 {
2161         auto pw = static_cast<PanWindow *>(data);
2162         FileData *fd;
2163
2164         fd = pan_menu_click_fd(pw);
2165         if (fd) file_util_move(fd, nullptr, nullptr, pw->imd->widget);
2166 }
2167
2168 static void pan_rename_cb(GtkWidget *, gpointer data)
2169 {
2170         auto pw = static_cast<PanWindow *>(data);
2171         FileData *fd;
2172
2173         fd = pan_menu_click_fd(pw);
2174         if (fd) file_util_rename(fd, nullptr, pw->imd->widget);
2175 }
2176
2177 static void pan_delete_cb(GtkWidget *, gpointer data)
2178 {
2179         auto pw = static_cast<PanWindow *>(data);
2180         FileData *fd;
2181
2182         fd = pan_menu_click_fd(pw);
2183         if (fd)
2184                 {
2185                 options->file_ops.safe_delete_enable = FALSE;
2186                 file_util_delete(fd, nullptr, pw->imd->widget);
2187                 }
2188 }
2189
2190 static void pan_move_to_trash_cb(GtkWidget *, gpointer data)
2191 {
2192         auto pw = static_cast<PanWindow *>(data);
2193         FileData *fd;
2194
2195         fd = pan_menu_click_fd(pw);
2196         if (fd)
2197                 {
2198                 options->file_ops.safe_delete_enable = TRUE;
2199                 file_util_delete(fd, nullptr, pw->imd->widget);
2200                 }
2201 }
2202
2203 static void pan_copy_path_cb(GtkWidget *, gpointer data)
2204 {
2205         auto pw = static_cast<PanWindow *>(data);
2206         FileData *fd;
2207
2208         fd = pan_menu_click_fd(pw);
2209         if (fd) file_util_copy_path_to_clipboard(fd, TRUE);
2210 }
2211
2212 static void pan_copy_path_unquoted_cb(GtkWidget *, gpointer data)
2213 {
2214         auto pw = static_cast<PanWindow *>(data);
2215         FileData *fd;
2216
2217         fd = pan_menu_click_fd(pw);
2218         if (fd) file_util_copy_path_to_clipboard(fd, FALSE);
2219 }
2220
2221 static void pan_exif_date_toggle_cb(GtkWidget *widget, gpointer data)
2222 {
2223         auto pw = static_cast<PanWindow *>(data);
2224
2225         pw->exif_date_enable = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget));
2226         pan_layout_update(pw);
2227 }
2228
2229 static void pan_info_toggle_exif_cb(GtkWidget *widget, gpointer data)
2230 {
2231         auto pw = static_cast<PanWindow *>(data);
2232
2233         pw->info_includes_exif = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget));
2234         /** @FIXME sync info now */
2235 }
2236
2237 static void pan_info_toggle_image_cb(GtkWidget *widget, gpointer data)
2238 {
2239         auto pw = static_cast<PanWindow *>(data);
2240
2241         pw->info_image_size = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), INFO_IMAGE_SIZE_KEY));
2242         /** @FIXME sync info now */
2243 }
2244
2245 static void pan_fullscreen_cb(GtkWidget *, gpointer data)
2246 {
2247         auto pw = static_cast<PanWindow *>(data);
2248
2249         pan_fullscreen_toggle(pw, FALSE);
2250 }
2251
2252 static void pan_close_cb(GtkWidget *, gpointer data)
2253 {
2254         auto pw = static_cast<PanWindow *>(data);
2255
2256         pan_window_close(pw);
2257 }
2258
2259 static void pan_popup_menu_destroy_cb(GtkWidget *, gpointer data)
2260 {
2261         auto editmenu_fd_list = static_cast<GList *>(data);
2262
2263         filelist_free(editmenu_fd_list);
2264 }
2265
2266 static void pan_play_cb(GtkWidget *, gpointer data)
2267 {
2268         auto pw = static_cast<PanWindow *>(data);
2269
2270         start_editor_from_file(options->image_l_click_video_editor, pw->click_pi->fd);
2271 }
2272
2273 static GList *pan_view_get_fd_list(PanWindow *pw)
2274 {
2275         GList *list = nullptr;
2276         FileData *fd = pan_menu_click_fd(pw);
2277
2278         if (fd) list = g_list_prepend(filelist_copy(fd->sidecar_files), file_data_ref(fd));
2279
2280         return list;
2281 }
2282
2283 /**
2284  * @brief Add file selection list to a collection
2285  * @param[in] widget
2286  * @param[in] data Index to the collection list menu item selected, or -1 for new collection
2287  *
2288  *
2289  */
2290 static void pan_pop_menu_collections_cb(GtkWidget *widget, gpointer data)
2291 {
2292         PanWindow *pw;
2293         GList *selection_list = nullptr;
2294
2295         pw = static_cast<PanWindow *>(submenu_item_get_data(widget));
2296         selection_list = g_list_append(selection_list, pan_menu_click_fd(pw));
2297         pop_menu_collections(selection_list, data);
2298
2299         filelist_free(selection_list);
2300 }
2301
2302 static GtkWidget *pan_popup_menu(PanWindow *pw)
2303 {
2304         GtkWidget *menu;
2305         GtkWidget *submenu;
2306         GtkWidget *item;
2307         gboolean active, video;
2308         GList *editmenu_fd_list;
2309         GtkAccelGroup *accel_group;
2310
2311         active = (pw->click_pi != nullptr);
2312         video = (active && pw->click_pi->fd && pw->click_pi->fd->format_class == FORMAT_CLASS_VIDEO);
2313
2314         menu = popup_menu_short_lived();
2315         accel_group = gtk_accel_group_new();
2316         gtk_menu_set_accel_group(GTK_MENU(menu), accel_group);
2317
2318         g_object_set_data(G_OBJECT(menu), "window_keys", pan_view_window_keys);
2319         g_object_set_data(G_OBJECT(menu), "accel_group", accel_group);
2320
2321         menu_item_add_icon_sensitive(menu, _("_Play"), GQ_ICON_PLAY, video,
2322                             G_CALLBACK(pan_play_cb), pw);
2323         menu_item_add_divider(menu);
2324
2325         menu_item_add_icon(menu, _("Zoom _in"), GQ_ICON_ZOOM_IN,
2326                             G_CALLBACK(pan_zoom_in_cb), pw);
2327         menu_item_add_icon(menu, _("Zoom _out"), GQ_ICON_ZOOM_OUT,
2328                             G_CALLBACK(pan_zoom_out_cb), pw);
2329         menu_item_add_icon(menu, _("Zoom _1:1"), GQ_ICON_ZOOM_100,
2330                             G_CALLBACK(pan_zoom_1_1_cb), pw);
2331         menu_item_add_divider(menu);
2332
2333         editmenu_fd_list = pan_view_get_fd_list(pw);
2334         g_signal_connect(G_OBJECT(menu), "destroy",
2335                          G_CALLBACK(pan_popup_menu_destroy_cb), editmenu_fd_list);
2336
2337         submenu_add_edit(menu, &item, G_CALLBACK(pan_edit_cb), pw, editmenu_fd_list);
2338         gtk_widget_set_sensitive(item, active);
2339
2340         menu_item_add_icon_sensitive(menu, _("View in _new window"), GQ_ICON_NEW, active,
2341                                       G_CALLBACK(pan_new_window_cb), pw);
2342         menu_item_add_icon(menu, _("Go to original"), GQ_ICON_FIND,
2343                         G_CALLBACK(pan_go_to_original_cb), pw);
2344
2345         menu_item_add_divider(menu);
2346         menu_item_add_icon_sensitive(menu, _("_Copy..."), GQ_ICON_COPY, active,
2347                                       G_CALLBACK(pan_copy_cb), pw);
2348         menu_item_add_sensitive(menu, _("_Move..."), active,
2349                                 G_CALLBACK(pan_move_cb), pw);
2350         menu_item_add_sensitive(menu, _("_Rename..."), active,
2351                                 G_CALLBACK(pan_rename_cb), pw);
2352         menu_item_add_sensitive(menu, _("_Copy path to clipboard"), active,
2353                                 G_CALLBACK(pan_copy_path_cb), pw);
2354         menu_item_add_sensitive(menu, _("_Copy path unquoted to clipboard"), active,
2355                                 G_CALLBACK(pan_copy_path_unquoted_cb), pw);
2356
2357         menu_item_add_divider(menu);
2358         menu_item_add_icon_sensitive(menu,
2359                                 options->file_ops.confirm_move_to_trash ? _("Move to Trash...") :
2360                                         _("Move to Trash"), GQ_ICON_DELETE, active,
2361                                                 G_CALLBACK(pan_move_to_trash_cb), pw);
2362         menu_item_add_icon_sensitive(menu,
2363                                 options->file_ops.confirm_delete ? _("_Delete...") :
2364                                         _("_Delete"), GQ_ICON_DELETE_SHRED, active,
2365                                                 G_CALLBACK(pan_delete_cb), pw);
2366
2367         menu_item_add_divider(menu);
2368
2369         submenu = submenu_add_collections(menu, &item,
2370                                 G_CALLBACK(pan_pop_menu_collections_cb), pw);
2371         gtk_widget_set_sensitive(item, TRUE);
2372         menu_item_add_divider(menu);
2373
2374
2375         item = menu_item_add_check(menu, _("Sort by E_xif date"), pw->exif_date_enable,
2376                                    G_CALLBACK(pan_exif_date_toggle_cb), pw);
2377         gtk_widget_set_sensitive(item, (pw->layout == PAN_LAYOUT_TIMELINE || pw->layout == PAN_LAYOUT_CALENDAR));
2378
2379         menu_item_add_divider(menu);
2380
2381         menu_item_add_check(menu, _("_Show Exif information"), pw->info_includes_exif,
2382                             G_CALLBACK(pan_info_toggle_exif_cb), pw);
2383         item = menu_item_add(menu, _("Show im_age"), nullptr, nullptr);
2384         submenu = gtk_menu_new();
2385         gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
2386
2387         item = menu_item_add_check(submenu, _("_None"), (pw->info_image_size == PAN_IMAGE_SIZE_THUMB_NONE),
2388                                    G_CALLBACK(pan_info_toggle_image_cb), pw);
2389         g_object_set_data(G_OBJECT(item), INFO_IMAGE_SIZE_KEY, GINT_TO_POINTER(PAN_IMAGE_SIZE_THUMB_NONE));
2390
2391         item = menu_item_add_check(submenu, _("_Full size"), (pw->info_image_size == PAN_IMAGE_SIZE_100),
2392                                    G_CALLBACK(pan_info_toggle_image_cb), pw);
2393         g_object_set_data(G_OBJECT(item), INFO_IMAGE_SIZE_KEY, GINT_TO_POINTER(PAN_IMAGE_SIZE_100));
2394
2395         item = menu_item_add_check(submenu, _("1:2 (50%)"), (pw->info_image_size == PAN_IMAGE_SIZE_50),
2396                                    G_CALLBACK(pan_info_toggle_image_cb), pw);
2397         g_object_set_data(G_OBJECT(item), INFO_IMAGE_SIZE_KEY, GINT_TO_POINTER(PAN_IMAGE_SIZE_50));
2398
2399         item = menu_item_add_check(submenu, _("1:3 (33%)"), (pw->info_image_size == PAN_IMAGE_SIZE_33),
2400                                    G_CALLBACK(pan_info_toggle_image_cb), pw);
2401         g_object_set_data(G_OBJECT(item), INFO_IMAGE_SIZE_KEY, GINT_TO_POINTER(PAN_IMAGE_SIZE_33));
2402
2403         item = menu_item_add_check(submenu, _("1:4 (25%)"), (pw->info_image_size == PAN_IMAGE_SIZE_25),
2404                                    G_CALLBACK(pan_info_toggle_image_cb), pw);
2405         g_object_set_data(G_OBJECT(item), INFO_IMAGE_SIZE_KEY, GINT_TO_POINTER(PAN_IMAGE_SIZE_25));
2406
2407         item = menu_item_add_check(submenu, _("1:10 (10%)"), (pw->info_image_size == PAN_IMAGE_SIZE_10),
2408                                    G_CALLBACK(pan_info_toggle_image_cb), pw);
2409         g_object_set_data(G_OBJECT(item), INFO_IMAGE_SIZE_KEY, GINT_TO_POINTER(PAN_IMAGE_SIZE_10));
2410
2411
2412
2413         menu_item_add_divider(menu);
2414
2415         if (pw->fs)
2416                 {
2417                 menu_item_add_icon(menu, _("Exit _full screen"), GQ_ICON_LEAVE_FULLSCREEN, G_CALLBACK(pan_fullscreen_cb), pw);
2418                 }
2419         else
2420                 {
2421                 menu_item_add_icon(menu, _("_Full screen"), GQ_ICON_FULLSCREEN, G_CALLBACK(pan_fullscreen_cb), pw);
2422                 }
2423
2424         menu_item_add_divider(menu);
2425         menu_item_add_icon(menu, _("C_lose window"), GQ_ICON_CLOSE, G_CALLBACK(pan_close_cb), pw);
2426
2427         return menu;
2428 }
2429
2430
2431 /*
2432  *-----------------------------------------------------------------------------
2433  * drag and drop
2434  *-----------------------------------------------------------------------------
2435  */
2436
2437 static void pan_window_get_dnd_data(GtkWidget *, GdkDragContext *context,
2438                                     gint, gint,
2439                                     GtkSelectionData *selection_data, guint info,
2440                                     guint, gpointer data)
2441 {
2442         auto pw = static_cast<PanWindow *>(data);
2443
2444         if (gtk_drag_get_source_widget(context) == pw->imd->pr) return;
2445
2446         if (info == TARGET_URI_LIST)
2447                 {
2448                 GList *list;
2449
2450                 list = uri_filelist_from_gtk_selection_data(selection_data);
2451                 if (list && isdir((static_cast<FileData *>(list->data))->path))
2452                         {
2453                         auto fd = static_cast<FileData *>(list->data);
2454
2455                         pan_layout_set_fd(pw, fd);
2456                         }
2457
2458                 filelist_free(list);
2459                 }
2460 }
2461
2462 static void pan_window_set_dnd_data(GtkWidget *, GdkDragContext *,
2463                                     GtkSelectionData *selection_data, guint,
2464                                     guint, gpointer data)
2465 {
2466         auto pw = static_cast<PanWindow *>(data);
2467         FileData *fd;
2468
2469         fd = pan_menu_click_fd(pw);
2470         if (fd)
2471                 {
2472                 GList *list;
2473
2474                 list = g_list_append(nullptr, fd);
2475                 uri_selection_data_set_uris_from_filelist(selection_data, list);
2476                 g_list_free(list);
2477                 }
2478         else
2479                 {
2480                 gtk_selection_data_set(selection_data, gtk_selection_data_get_target(selection_data),
2481                                        8, nullptr, 0);
2482                 }
2483 }
2484
2485 static void pan_window_dnd_init(PanWindow *pw)
2486 {
2487         GtkWidget *widget;
2488
2489         widget = pw->imd->pr;
2490
2491         gtk_drag_source_set(widget, GDK_BUTTON2_MASK,
2492                             dnd_file_drag_types, dnd_file_drag_types_count,
2493                             static_cast<GdkDragAction>(GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK));
2494         g_signal_connect(G_OBJECT(widget), "drag_data_get",
2495                          G_CALLBACK(pan_window_set_dnd_data), pw);
2496
2497         gtk_drag_dest_set(widget,
2498                           static_cast<GtkDestDefaults>(GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP),
2499                           dnd_file_drop_types, dnd_file_drop_types_count,
2500                           static_cast<GdkDragAction>(GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK));
2501         g_signal_connect(G_OBJECT(widget), "drag_data_received",
2502                          G_CALLBACK(pan_window_get_dnd_data), pw);
2503 }
2504
2505 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */