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