src/pan-view.c

   1 /*
   2  * Geeqie
   3  * (C) 2006 John Ellis
   4  * Copyright (C) 2008 The Geeqie Team
   5  *
   6  * Author: John Ellis
   7  *
   8  * This software is released under the GNU General Public License (GNU GPL).
   9  * Please read the included file COPYING for more information.
  10  * This software comes with no warranty of any kind, use at your own risk!
  11  */
  12
  13
  14 #include "main.h"
  15 #include "pan-view.h"
  16
  17 #include "pan-types.h"
  18 #include "bar_exif.h"
  19 #include "dnd.h"
  20 #include "editors.h"
  21 #include "exif.h"
  22 #include "fullscreen.h"
  23 #include "img-view.h"
  24 #include "info.h"
  25 #include "menu.h"
  26 #include "thumb.h"
  27 #include "utilops.h"
  28 #include "ui_bookmark.h"
  29 #include "ui_fileops.h"
  30 #include "ui_menu.h"
  31 #include "ui_tabcomp.h"
  32 #include "ui_utildlg.h"
  33
  34 #include <gdk/gdkkeysyms.h> /* for keyboard values */
  35
  36 #include <math.h>
  37
  38
  39 #define PAN_WINDOW_DEFAULT_WIDTH 720
  40 #define PAN_WINDOW_DEFAULT_HEIGHT 500
  41
  42 #define PAN_TILE_SIZE 512
  43
  44 #define ZOOM_INCREMENT 1.0
  45 #define ZOOM_LABEL_WIDTH 64
  46
  47
  48 #define PAN_PREF_GROUP          "pan_view_options"
  49 #define PAN_PREF_HIDE_WARNING   "hide_performance_warning"
  50 #define PAN_PREF_EXIF_PAN_DATE  "use_exif_date"
  51 #define PAN_PREF_INFO_IMAGE     "info_image_size"
  52 #define PAN_PREF_INFO_EXIF      "info_includes_exif"
  53
  54
  55 static GList *pan_window_list = NULL;
  56
  57
  58 static void pan_layout_update_idle(PanWindow *pw);
  59
  60 static void pan_fullscreen_toggle(PanWindow *pw, gint force_off);
  61
  62 static void pan_search_toggle_visible(PanWindow *pw, gint enable);
  63 static void pan_search_activate(PanWindow *pw);
  64
  65 static void pan_window_close(PanWindow *pw);
  66
  67 static GtkWidget *pan_popup_menu(PanWindow *pw);
  68
  69 static void pan_window_dnd_init(PanWindow *pw);
  70
  71
  72 /*
  73  *-----------------------------------------------------------------------------
  74  * the image/thumb loader queue
  75  *-----------------------------------------------------------------------------
  76  */
  77
  78 static gint pan_queue_step(PanWindow *pw);
  79
  80
  81 static void pan_queue_thumb_done_cb(ThumbLoader *tl, gpointer data)
  82 {
  83         PanWindow *pw = data;
  84
  85         if (pw->queue_pi)
  86                 {
  87                 PanItem *pi;
  88                 gint rc;
  89
  90                 pi = pw->queue_pi;
  91                 pw->queue_pi = NULL;
  92
  93                 pi->queued = FALSE;
  94
  95                 if (pi->pixbuf) g_object_unref(pi->pixbuf);
  96                 pi->pixbuf = thumb_loader_get_pixbuf(tl, TRUE);
  97
  98                 rc = pi->refcount;
  99                 image_area_changed(pw->imd, pi->x, pi->y, pi->width, pi->height);
 100                 pi->refcount = rc;
 101                 }
 102
 103         thumb_loader_free(pw->tl);
 104         pw->tl = NULL;
 105
 106         while (pan_queue_step(pw));
 107 }
 108
 109 static void pan_queue_image_done_cb(ImageLoader *il, gpointer data)
 110 {
 111         PanWindow *pw = data;
 112
 113         if (pw->queue_pi)
 114                 {
 115                 PanItem *pi;
 116                 gint rc;
 117
 118                 pi = pw->queue_pi;
 119                 pw->queue_pi = NULL;
 120
 121                 pi->queued = FALSE;
 122
 123                 if (pi->pixbuf) g_object_unref(pi->pixbuf);
 124                 pi->pixbuf = image_loader_get_pixbuf(pw->il);
 125                 if (pi->pixbuf) g_object_ref(pi->pixbuf);
 126
 127                 if (pi->pixbuf && pw->size != PAN_IMAGE_SIZE_100 &&
 128                     (gdk_pixbuf_get_width(pi->pixbuf) > pi->width ||
 129                      gdk_pixbuf_get_height(pi->pixbuf) > pi->height))
 130                         {
 131                         GdkPixbuf *tmp;
 132
 133                         tmp = pi->pixbuf;
 134                         pi->pixbuf = gdk_pixbuf_scale_simple(tmp, pi->width, pi->height,
 135                                                              (GdkInterpType)options->image.zoom_quality);
 136                         g_object_unref(tmp);
 137                         }
 138
 139                 rc = pi->refcount;
 140                 image_area_changed(pw->imd, pi->x, pi->y, pi->width, pi->height);
 141                 pi->refcount = rc;
 142                 }
 143
 144         image_loader_free(pw->il);
 145         pw->il = NULL;
 146
 147         while (pan_queue_step(pw));
 148 }
 149
 150 #if 0
 151 static void pan_queue_image_area_cb(ImageLoader *il, guint x, guint y,
 152                                     guint width, guint height, gpointer data)
 153 {
 154         PanWindow *pw = data;
 155
 156         if (pw->queue_pi)
 157                 {
 158                 PanItem *pi;
 159                 gint rc;
 160
 161                 pi = pw->queue_pi;
 162
 163                 if (!pi->pixbuf)
 164                         {
 165                         pi->pixbuf = image_loader_get_pixbuf(pw->il);
 166                         if (pi->pixbuf) g_object_ref(pi->pixbuf);
 167                         }
 168
 169                 rc = pi->refcount;
 170                 image_area_changed(pw->imd, pi->x + x, pi->y + y, width, height);
 171                 pi->refcount = rc;
 172                 }
 173 }
 174 #endif
 175
 176 static gint pan_queue_step(PanWindow *pw)
 177 {
 178         PanItem *pi;
 179
 180         if (!pw->queue) return FALSE;
 181
 182         pi = pw->queue->data;
 183         pw->queue = g_list_remove(pw->queue, pi);
 184         pw->queue_pi = pi;
 185
 186         if (!pw->queue_pi->fd)
 187                 {
 188                 pw->queue_pi->queued = FALSE;
 189                 pw->queue_pi = NULL;
 190                 return TRUE;
 191                 }
 192
 193         image_loader_free(pw->il);
 194         pw->il = NULL;
 195         thumb_loader_free(pw->tl);
 196         pw->tl = NULL;
 197
 198         if (pi->type == PAN_ITEM_IMAGE)
 199                 {
 200                 pw->il = image_loader_new(pi->fd);
 201
 202                 if (pw->size != PAN_IMAGE_SIZE_100)
 203                         {
 204                         image_loader_set_requested_size(pw->il, pi->width, pi->height);
 205                         }
 206
 207 #if 0
 208                 image_loader_set_area_ready_func(pw->il, pan_queue_image_area_cb, pw);
 209 #endif
 210                 image_loader_set_error_func(pw->il, pan_queue_image_done_cb, pw);
 211
 212                 if (image_loader_start(pw->il, pan_queue_image_done_cb, pw)) return FALSE;
 213
 214                 image_loader_free(pw->il);
 215                 pw->il = NULL;
 216                 }
 217         else if (pi->type == PAN_ITEM_THUMB)
 218                 {
 219                 pw->tl = thumb_loader_new(PAN_THUMB_SIZE, PAN_THUMB_SIZE);
 220
 221                 if (!pw->tl->standard_loader)
 222                         {
 223                         /* The classic loader will recreate a thumbnail any time we
 224                          * request a different size than what exists. This view will
 225                          * almost never use the user configured sizes so disable cache.
 226                          */
 227                         thumb_loader_set_cache(pw->tl, FALSE, FALSE, FALSE);
 228                         }
 229
 230                 thumb_loader_set_callbacks(pw->tl,
 231                                            pan_queue_thumb_done_cb,
 232                                            pan_queue_thumb_done_cb,
 233                                            NULL, pw);
 234
 235                 if (thumb_loader_start(pw->tl, pi->fd->path)) return FALSE;
 236
 237                 thumb_loader_free(pw->tl);
 238                 pw->tl = NULL;
 239                 }
 240
 241         pw->queue_pi->queued = FALSE;
 242         pw->queue_pi = NULL;
 243         return TRUE;
 244 }
 245
 246 static void pan_queue_add(PanWindow *pw, PanItem *pi)
 247 {
 248         if (!pi || pi->queued || pi->pixbuf) return;
 249         if (pw->size <= PAN_IMAGE_SIZE_THUMB_NONE &&
 250             (!pi->key || strcmp(pi->key, "info") != 0) )
 251                 {
 252                 return;
 253                 }
 254
 255         pi->queued = TRUE;
 256         pw->queue = g_list_prepend(pw->queue, pi);
 257
 258         if (!pw->tl && !pw->il) while(pan_queue_step(pw));
 259 }
 260
 261
 262 /*
 263  *-----------------------------------------------------------------------------
 264  * tile request/dispose handlers
 265  *-----------------------------------------------------------------------------
 266  */
 267
 268 static gint pan_window_request_tile_cb(PixbufRenderer *pr, gint x, gint y,
 269                                        gint width, gint height, GdkPixbuf *pixbuf, gpointer data)
 270 {
 271         PanWindow *pw = data;
 272         GList *list;
 273         GList *work;
 274         gint i;
 275
 276         pixbuf_set_rect_fill(pixbuf,
 277                              0, 0, width, height,
 278                              PAN_BACKGROUND_COLOR, 255);
 279
 280         for (i = (x / PAN_GRID_SIZE) * PAN_GRID_SIZE; i < x + width; i += PAN_GRID_SIZE)
 281                 {
 282                 gint rx, ry, rw, rh;
 283
 284                 if (util_clip_region(x, y, width, height,
 285                                      i, y, 1, height,
 286                                      &rx, &ry, &rw, &rh))
 287                         {
 288                         pixbuf_draw_rect_fill(pixbuf,
 289                                               rx - x, ry - y, rw, rh,
 290                                               PAN_GRID_COLOR, PAN_GRID_ALPHA);
 291                         }
 292                 }
 293         for (i = (y / PAN_GRID_SIZE) * PAN_GRID_SIZE; i < y + height; i += PAN_GRID_SIZE)
 294                 {
 295                 gint rx, ry, rw, rh;
 296
 297                 if (util_clip_region(x, y, width, height,
 298                                      x, i, width, 1,
 299                                      &rx, &ry, &rw, &rh))
 300                         {
 301                         pixbuf_draw_rect_fill(pixbuf,
 302                                               rx - x, ry - y, rw, rh,
 303                                               PAN_GRID_COLOR, PAN_GRID_ALPHA);
 304                         }
 305                 }
 306
 307         list = pan_layout_intersect(pw, x, y, width, height);
 308         work = list;
 309         while (work)
 310                 {
 311                 PanItem *pi;
 312                 gint queue = FALSE;
 313
 314                 pi = work->data;
 315                 work = work->next;
 316
 317                 pi->refcount++;
 318
 319                 switch (pi->type)
 320                         {
 321                         case PAN_ITEM_BOX:
 322                                 queue = pan_item_box_draw(pw, pi, pixbuf, pr, x, y, width, height);
 323                                 break;
 324                         case PAN_ITEM_TRIANGLE:
 325                                 queue = pan_item_tri_draw(pw, pi, pixbuf, pr, x, y, width, height);
 326                                 break;
 327                         case PAN_ITEM_TEXT:
 328                                 queue = pan_item_text_draw(pw, pi, pixbuf, pr, x, y, width, height);
 329                                 break;
 330                         case PAN_ITEM_THUMB:
 331                                 queue = pan_item_thumb_draw(pw, pi, pixbuf, pr, x, y, width, height);
 332                                 break;
 333                         case PAN_ITEM_IMAGE:
 334                                 queue = pan_item_image_draw(pw, pi, pixbuf, pr, x, y, width, height);
 335                                 break;
 336                         case PAN_ITEM_NONE:
 337                         default:
 338                                 break;
 339                         }
 340
 341                 if (queue) pan_queue_add(pw, pi);
 342                 }
 343
 344         g_list_free(list);
 345
 346 #if 0
 347         if (x%512 == 0 && y%512 == 0)
 348                 {
 349                 PangoLayout *layout;
 350                 gchar *buf;
 351
 352                 layout = gtk_widget_create_pango_layout((GtkWidget *)pr, NULL);
 353
 354                 buf = g_strdup_printf("%d,%d\n(#%d)", x, y,
 355                                       (x / pr->source_tile_width) +
 356                                       (y / pr->source_tile_height * (pr->image_width/pr->source_tile_width + 1)));
 357                 pango_layout_set_text(layout, buf, -1);
 358                 g_free(buf);
 359
 360                 pixbuf_draw_layout(pixbuf, layout, (GtkWidget *)pr, 0, 0, 0, 0, 0, 255);
 361
 362                 g_object_unref(G_OBJECT(layout));
 363                 }
 364 #endif
 365
 366         return TRUE;
 367 }
 368
 369 static void pan_window_dispose_tile_cb(PixbufRenderer *pr, gint x, gint y,
 370                                        gint width, gint height, GdkPixbuf *pixbuf, gpointer data)
 371 {
 372         PanWindow *pw = data;
 373         GList *list;
 374         GList *work;
 375
 376         list = pan_layout_intersect(pw, x, y, width, height);
 377         work = list;
 378         while (work)
 379                 {
 380                 PanItem *pi;
 381
 382                 pi = work->data;
 383                 work = work->next;
 384
 385                 if (pi->refcount > 0)
 386                         {
 387                         pi->refcount--;
 388
 389                         if (pi->refcount == 0)
 390                                 {
 391                                 if (pi->queued)
 392                                         {
 393                                         pw->queue = g_list_remove(pw->queue, pi);
 394                                         pi->queued = FALSE;
 395                                         }
 396                                 if (pw->queue_pi == pi) pw->queue_pi = NULL;
 397                                 if (pi->pixbuf)
 398                                         {
 399                                         g_object_unref(pi->pixbuf);
 400                                         pi->pixbuf = NULL;
 401                                         }
 402                                 }
 403                         }
 404                 }
 405
 406         g_list_free(list);
 407 }
 408
 409
 410 /*
 411  *-----------------------------------------------------------------------------
 412  * misc
 413  *-----------------------------------------------------------------------------
 414  */
 415
 416 static void pan_window_message(PanWindow *pw, const gchar *text)
 417 {
 418         GList *work;
 419         gint count = 0;
 420         gint64 size = 0;
 421         gchar *ss;
 422         gchar *buf;
 423
 424         if (text)
 425                 {
 426                 gtk_label_set_text(GTK_LABEL(pw->label_message), text);
 427                 return;
 428                 }
 429
 430         work = pw->list_static;
 431         if (pw->layout == PAN_LAYOUT_CALENDAR)
 432                 {
 433                 while (work)
 434                         {
 435                         PanItem *pi;
 436
 437                         pi = work->data;
 438                         work = work->next;
 439
 440                         if (pi->fd &&
 441                             pi->type == PAN_ITEM_BOX &&
 442                             pi->key && strcmp(pi->key, "dot") == 0)
 443                                 {
 444                                 size += pi->fd->size;
 445                                 count++;
 446                                 }
 447                         }
 448                 }
 449         else
 450                 {
 451                 while (work)
 452                         {
 453                         PanItem *pi;
 454
 455                         pi = work->data;
 456                         work = work->next;
 457
 458                         if (pi->fd &&
 459                             (pi->type == PAN_ITEM_THUMB || pi->type == PAN_ITEM_IMAGE))
 460                                 {
 461                                 size += pi->fd->size;
 462                                 count++;
 463                                 }
 464                         }
 465                 }
 466
 467         ss = text_from_size_abrev(size);
 468         buf = g_strdup_printf(_("%d images, %s"), count, ss);
 469         g_free(ss);
 470         gtk_label_set_text(GTK_LABEL(pw->label_message), buf);
 471         g_free(buf);
 472 }
 473
 474 static void pan_warning_folder(const gchar *path, GtkWidget *parent)
 475 {
 476         gchar *message;
 477
 478         message = g_strdup_printf(_("The pan view does not support the folder \"%s\"."), path);
 479         warning_dialog(_("Folder not supported"), message,
 480                       GTK_STOCK_DIALOG_INFO, parent);
 481         g_free(message);
 482 }
 483
 484 static void pan_window_zoom_limit(PanWindow *pw)
 485 {
 486         gdouble min;
 487
 488         switch (pw->size)
 489                 {
 490                 case PAN_IMAGE_SIZE_THUMB_DOTS:
 491                 case PAN_IMAGE_SIZE_THUMB_NONE:
 492                 case PAN_IMAGE_SIZE_THUMB_SMALL:
 493                 case PAN_IMAGE_SIZE_THUMB_NORMAL:
 494 #if 0
 495                         /* easily requires > 512mb ram when window size > 1024x768 and zoom is <= -8 */
 496                         min = -16.0;
 497                         break;
 498 #endif
 499                 case PAN_IMAGE_SIZE_THUMB_LARGE:
 500                         min = -6.0;
 501                         break;
 502                 case PAN_IMAGE_SIZE_10:
 503                 case PAN_IMAGE_SIZE_25:
 504                         min = -4.0;
 505                         break;
 506                 case PAN_IMAGE_SIZE_33:
 507                 case PAN_IMAGE_SIZE_50:
 508                 case PAN_IMAGE_SIZE_100:
 509                 default:
 510                         min = -2.0;
 511                         break;
 512                 }
 513
 514         image_zoom_set_limits(pw->imd, min, 32.0);
 515 }
 516
 517
 518 /*
 519  *-----------------------------------------------------------------------------
 520  * cache
 521  *-----------------------------------------------------------------------------
 522  */
 523
 524 static gint pan_cache_sort_file_cb(void *a, void *b)
 525 {
 526         PanCacheData *pca = a;
 527         PanCacheData *pcb = b;
 528         return filelist_sort_compare_filedata(pca->fd, pcb->fd);
 529 }
 530 GList *pan_cache_sort(GList *list, SortType method, gint ascend)
 531 {
 532         return filelist_sort_full(list, method, ascend, (GCompareFunc) pan_cache_sort_file_cb);
 533 }
 534
 535
 536 static void pan_cache_free(PanWindow *pw)
 537 {
 538         GList *work;
 539
 540         work = pw->cache_list;
 541         while (work)
 542                 {
 543                 PanCacheData *pc;
 544
 545                 pc = work->data;
 546                 work = work->next;
 547
 548                 cache_sim_data_free(pc->cd);
 549                 file_data_unref(pc->fd);
 550                 g_free(pc);
 551                 }
 552
 553         g_list_free(pw->cache_list);
 554         pw->cache_list = NULL;
 555
 556         filelist_free(pw->cache_todo);
 557         pw->cache_todo = NULL;
 558
 559         pw->cache_count = 0;
 560         pw->cache_total = 0;
 561         pw->cache_tick = 0;
 562
 563         cache_loader_free(pw->cache_cl);
 564         pw->cache_cl = NULL;
 565 }
 566
 567 static void pan_cache_fill(PanWindow *pw, const gchar *path)
 568 {
 569         GList *list;
 570
 571         pan_cache_free(pw);
 572
 573         list = pan_list_tree(path, SORT_NAME, TRUE, pw->ignore_symlinks);
 574         pw->cache_todo = g_list_reverse(list);
 575
 576         pw->cache_total = g_list_length(pw->cache_todo);
 577 }
 578
 579 static void pan_cache_step_done_cb(CacheLoader *cl, gint error, gpointer data)
 580 {
 581         PanWindow *pw = data;
 582
 583         if (pw->cache_list)
 584                 {
 585                 PanCacheData *pc;
 586                 pc = pw->cache_list->data;
 587
 588                 if (!pc->cd)
 589                         {
 590                         pc->cd = cl->cd;
 591                         cl->cd = NULL;
 592                         }
 593                 }
 594
 595         cache_loader_free(cl);
 596         pw->cache_cl = NULL;
 597
 598         pan_layout_update_idle(pw);
 599 }
 600
 601 static gint pan_cache_step(PanWindow *pw)
 602 {
 603         FileData *fd;
 604         PanCacheData *pc;
 605         CacheDataType load_mask;
 606
 607         if (!pw->cache_todo) return TRUE;
 608
 609         fd = pw->cache_todo->data;
 610         pw->cache_todo = g_list_remove(pw->cache_todo, fd);
 611
 612 #if 0
 613         if (enable_thumb_caching)
 614                 {
 615                 gchar *found;
 616
 617                 found = cache_find_location(CACHE_TYPE_SIM, fd->path);
 618                 if (found && filetime(found) == fd->date)
 619                         {
 620                         cd = cache_sim_data_load(found);
 621                         }
 622                 g_free(found);
 623                 }
 624
 625         if (!cd) cd = cache_sim_data_new();
 626
 627         if (!cd->dimensions)
 628                 {
 629                 cd->dimensions = image_load_dimensions(fd, &cd->width, &cd->height);
 630                 if (enable_thumb_caching &&
 631                     cd->dimensions)
 632                         {
 633                         gchar *base;
 634                         mode_t mode = 0755;
 635
 636                         base = cache_get_location(CACHE_TYPE_SIM, fd->path, FALSE, &mode);
 637                         if (cache_ensure_dir_exists(base, mode))
 638                                 {
 639                                 g_free(cd->path);
 640                                 cd->path = cache_get_location(CACHE_TYPE_SIM, fd->path, TRUE, NULL);
 641                                 if (cache_sim_data_save(cd))
 642                                         {
 643                                         filetime_set(cd->path, filetime(fd->path));
 644                                         }
 645                                 }
 646                         g_free(base);
 647                         }
 648
 649                 pw->cache_tick = 9;
 650                 }
 651 #endif
 652         pc = g_new0(PanCacheData, 1);
 653         pc->fd = file_data_ref(fd);
 654
 655         pc->cd = NULL;
 656
 657         pw->cache_list = g_list_prepend(pw->cache_list, pc);
 658
 659         cache_loader_free(pw->cache_cl);
 660
 661         load_mask = CACHE_LOADER_NONE;
 662         if (pw->size > PAN_IMAGE_SIZE_THUMB_LARGE) load_mask |= CACHE_LOADER_DIMENSIONS;
 663         if (pw->exif_date_enable) load_mask |= CACHE_LOADER_DATE;
 664         pw->cache_cl = cache_loader_new(pc->fd, load_mask,
 665                                         pan_cache_step_done_cb, pw);
 666         return (pw->cache_cl == NULL);
 667 }
 668
 669 /* This sync date function is optimized for lists with a common sort */
 670 void pan_cache_sync_date(PanWindow *pw, GList *list)
 671 {
 672         GList *haystack;
 673         GList *work;
 674
 675         haystack = g_list_copy(pw->cache_list);
 676
 677         work = list;
 678         while (work)
 679                 {
 680                 FileData *fd;
 681                 GList *needle;
 682
 683                 fd = work->data;
 684                 work = work->next;
 685
 686                 needle = haystack;
 687                 while (needle)
 688                         {
 689                         PanCacheData *pc;
 690
 691                         pc = needle->data;
 692                         if (pc->fd == fd)
 693                                 {
 694                                 if (pc->cd && pc->cd->have_date && pc->cd->date >= 0)
 695                                         {
 696                                         fd->date = pc->cd->date;
 697                                         }
 698
 699                                 haystack = g_list_delete_link(haystack, needle);
 700                                 needle = NULL;
 701                                 }
 702                         else
 703                                 {
 704                                 needle = needle->next;
 705                                 }
 706                         }
 707                 }
 708
 709         g_list_free(haystack);
 710 }
 711
 712 /*
 713  *-----------------------------------------------------------------------------
 714  * item grid
 715  *-----------------------------------------------------------------------------
 716  */
 717
 718 static void pan_grid_clear(PanWindow *pw)
 719 {
 720         GList *work;
 721
 722         work = pw->list_grid;
 723         while (work)
 724                 {
 725                 PanGrid *pg;
 726
 727                 pg = work->data;
 728                 work = work->next;
 729
 730                 g_list_free(pg->list);
 731                 g_free(pg);
 732                 }
 733
 734         g_list_free(pw->list_grid);
 735         pw->list_grid = NULL;
 736
 737         pw->list = g_list_concat(pw->list, pw->list_static);
 738         pw->list_static = NULL;
 739 }
 740
 741 static void pan_grid_build(PanWindow *pw, gint width, gint height, gint grid_size)
 742 {
 743         GList *work;
 744         gint col, row;
 745         gint cw, ch;
 746         gint l;
 747         gdouble total;
 748         gdouble s;
 749         gdouble aw, ah;
 750         gint i, j;
 751
 752         pan_grid_clear(pw);
 753
 754         l = g_list_length(pw->list);
 755
 756         if (l < 1) return;
 757
 758         total = (gdouble)width * (gdouble)height / (gdouble)l;
 759         s = sqrt(total);
 760
 761         aw = (gdouble)width / s;
 762         ah = (gdouble)height / s;
 763
 764         col = (gint)(sqrt((gdouble)l / grid_size) * width / height + 0.999);
 765         col = CLAMP(col, 1, l / grid_size + 1);
 766         row = (gint)((gdouble)l / grid_size / col);
 767         if (row < 1) row = 1;
 768
 769         /* limit minimum size of grid so that a tile will always fit regardless of position */
 770         cw = MAX((gint)ceil((gdouble)width / col), PAN_TILE_SIZE * 2);
 771         ch = MAX((gint)ceil((gdouble)height / row), PAN_TILE_SIZE * 2);
 772
 773         row = row * 2 - 1;
 774         col = col * 2 - 1;
 775
 776         DEBUG_1("intersect speedup grid is %dx%d, based on %d average per grid\n", col, row, grid_size);
 777
 778         for (j = 0; j < row; j++)
 779             for (i = 0; i < col; i++)
 780                 {
 781                 if ((i + 1) * cw / 2 < width && (j + 1) * ch / 2 < height)
 782                         {
 783                         PanGrid *pg;
 784
 785                         pg = g_new0(PanGrid, 1);
 786                         pg->x = i * cw / 2;
 787                         pg->y = j * ch / 2;
 788                         pg->w = cw;
 789                         pg->h = ch;
 790                         pg->list = NULL;
 791
 792                         pw->list_grid = g_list_prepend(pw->list_grid, pg);
 793
 794                         DEBUG_1("grid section: %d,%d (%dx%d)\n", pg->x, pg->y, pg->w, pg->h);
 795                         }
 796                 }
 797
 798         work = pw->list;
 799         while (work)
 800                 {
 801                 PanItem *pi;
 802                 GList *grid;
 803
 804                 pi = work->data;
 805                 work = work->next;
 806
 807                 grid = pw->list_grid;
 808                 while (grid)
 809                         {
 810                         PanGrid *pg;
 811                         gint rx, ry, rw, rh;
 812
 813                         pg = grid->data;
 814                         grid = grid->next;
 815
 816                         if (util_clip_region(pi->x, pi->y, pi->width, pi->height,
 817                                              pg->x, pg->y, pg->w, pg->h,
 818                                              &rx, &ry, &rw, &rh))
 819                                 {
 820                                 pg->list = g_list_prepend(pg->list, pi);
 821                                 }
 822                         }
 823                 }
 824
 825         work = pw->list_grid;
 826         while (work)
 827                 {
 828                 PanGrid *pg;
 829
 830                 pg = work->data;
 831                 work = work->next;
 832
 833                 pg->list = g_list_reverse(pg->list);
 834                 }
 835
 836         pw->list_static = pw->list;
 837         pw->list = NULL;
 838 }
 839
 840
 841 /*
 842  *-----------------------------------------------------------------------------
 843  * layout state reset
 844  *-----------------------------------------------------------------------------
 845  */
 846
 847 static void pan_window_items_free(PanWindow *pw)
 848 {
 849         GList *work;
 850
 851         pan_grid_clear(pw);
 852
 853         work = pw->list;
 854         while (work)
 855                 {
 856                 PanItem *pi = work->data;
 857                 work = work->next;
 858
 859                 pan_item_free(pi);
 860                 }
 861
 862         g_list_free(pw->list);
 863         pw->list = NULL;
 864
 865         g_list_free(pw->queue);
 866         pw->queue = NULL;
 867         pw->queue_pi = NULL;
 868
 869         image_loader_free(pw->il);
 870         pw->il = NULL;
 871
 872         thumb_loader_free(pw->tl);
 873         pw->tl = NULL;
 874
 875         pw->click_pi = NULL;
 876         pw->search_pi = NULL;
 877 }
 878
 879
 880 /*
 881  *-----------------------------------------------------------------------------
 882  * layout generation, queries, sizing
 883  *-----------------------------------------------------------------------------
 884  */
 885
 886 static void pan_layout_compute(PanWindow *pw, const gchar *path,
 887                                gint *width, gint *height,
 888                                gint *scroll_x, gint *scroll_y)
 889 {
 890         pan_window_items_free(pw);
 891
 892         switch (pw->size)
 893                 {
 894                 case PAN_IMAGE_SIZE_THUMB_DOTS:
 895                         pw->thumb_size = PAN_THUMB_SIZE_DOTS;
 896                         pw->thumb_gap = PAN_THUMB_GAP_DOTS;
 897                         break;
 898                 case PAN_IMAGE_SIZE_THUMB_NONE:
 899                         pw->thumb_size = PAN_THUMB_SIZE_NONE;
 900                         pw->thumb_gap = PAN_THUMB_GAP_SMALL;
 901                         break;
 902                 case PAN_IMAGE_SIZE_THUMB_SMALL:
 903                         pw->thumb_size = PAN_THUMB_SIZE_SMALL;
 904                         pw->thumb_gap = PAN_THUMB_GAP_SMALL;
 905                         break;
 906                 case PAN_IMAGE_SIZE_THUMB_NORMAL:
 907                 default:
 908                         pw->thumb_size = PAN_THUMB_SIZE_NORMAL;
 909                         pw->thumb_gap = PAN_THUMB_GAP_NORMAL;
 910                         break;
 911                 case PAN_IMAGE_SIZE_THUMB_LARGE:
 912                         pw->thumb_size = PAN_THUMB_SIZE_LARGE;
 913                         pw->thumb_gap = PAN_THUMB_GAP_LARGE;
 914                         break;
 915                 case PAN_IMAGE_SIZE_10:
 916                         pw->image_size = 10;
 917                         pw->thumb_gap = PAN_THUMB_GAP_NORMAL;
 918                         break;
 919                 case PAN_IMAGE_SIZE_25:
 920                         pw->image_size = 25;
 921                         pw->thumb_gap = PAN_THUMB_GAP_NORMAL;
 922                         break;
 923                 case PAN_IMAGE_SIZE_33:
 924                         pw->image_size = 33;
 925                         pw->thumb_gap = PAN_THUMB_GAP_LARGE;
 926                         break;
 927                 case PAN_IMAGE_SIZE_50:
 928                         pw->image_size = 50;
 929                         pw->thumb_gap = PAN_THUMB_GAP_HUGE;
 930                         break;
 931                 case PAN_IMAGE_SIZE_100:
 932                         pw->image_size = 100;
 933                         pw->thumb_gap = PAN_THUMB_GAP_HUGE;
 934                         break;
 935                 }
 936
 937         *width = 0;
 938         *height = 0;
 939         *scroll_x = 0;
 940         *scroll_y = 0;
 941
 942         switch (pw->layout)
 943                 {
 944                 case PAN_LAYOUT_GRID:
 945                 default:
 946                         pan_grid_compute(pw, path, width, height);
 947                         break;
 948                 case PAN_LAYOUT_FOLDERS_LINEAR:
 949                         pan_folder_tree_compute(pw, path, width, height);
 950                         break;
 951                 case PAN_LAYOUT_FOLDERS_FLOWER:
 952                         pan_flower_compute(pw, path, width, height, scroll_x, scroll_y);
 953                         break;
 954                 case PAN_LAYOUT_CALENDAR:
 955                         pan_calendar_compute(pw, path, width, height);
 956                         break;
 957                 case PAN_LAYOUT_TIMELINE:
 958                         pan_timeline_compute(pw, path, width, height);
 959                         break;
 960                 }
 961
 962         pan_cache_free(pw);
 963
 964         DEBUG_1("computed %d objects\n", g_list_length(pw->list));
 965 }
 966
 967 static GList *pan_layout_intersect_l(GList *list, GList *item_list,
 968                                      gint x, gint y, gint width, gint height)
 969 {
 970         GList *work;
 971
 972         work = item_list;
 973         while (work)
 974                 {
 975                 PanItem *pi;
 976                 gint rx, ry, rw, rh;
 977
 978                 pi = work->data;
 979                 work = work->next;
 980
 981                 if (util_clip_region(x, y, width, height,
 982                                      pi->x, pi->y, pi->width, pi->height,
 983                                      &rx, &ry, &rw, &rh))
 984                         {
 985                         list = g_list_prepend(list, pi);
 986                         }
 987                 }
 988
 989         return list;
 990 }
 991
 992 GList *pan_layout_intersect(PanWindow *pw, gint x, gint y, gint width, gint height)
 993 {
 994         GList *list = NULL;
 995         GList *grid;
 996         PanGrid *pg = NULL;
 997
 998         grid = pw->list_grid;
 999         while (grid && !pg)
1000                 {
1001                 pg = grid->data;
1002                 grid = grid->next;
1003
1004                 if (x < pg->x || x + width > pg->x + pg->w ||
1005                     y < pg->y || y + height > pg->y + pg->h)
1006                         {
1007                         pg = NULL;
1008                         }
1009                 }
1010
1011         list = pan_layout_intersect_l(list, pw->list, x, y, width, height);
1012
1013         if (pg)
1014                 {
1015                 list = pan_layout_intersect_l(list, pg->list, x, y, width, height);
1016                 }
1017         else
1018                 {
1019                 list = pan_layout_intersect_l(list, pw->list_static, x, y, width, height);
1020                 }
1021
1022         return list;
1023 }
1024
1025 void pan_layout_resize(PanWindow *pw)
1026 {
1027         gint width = 0;
1028         gint height = 0;
1029         GList *work;
1030         PixbufRenderer *pr;
1031
1032         work = pw->list;
1033         while (work)
1034                 {
1035                 PanItem *pi;
1036
1037                 pi = work->data;
1038                 work = work->next;
1039
1040                 if (width < pi->x + pi->width) width = pi->x + pi->width;
1041                 if (height < pi->y + pi->height) height = pi->y + pi->height;
1042                 }
1043         work = pw->list_static;
1044         while (work)
1045                 {
1046                 PanItem *pi;
1047
1048                 pi = work->data;
1049                 work = work->next;
1050
1051                 if (width < pi->x + pi->width) width = pi->x + pi->width;
1052                 if (height < pi->y + pi->height) height = pi->y + pi->height;
1053                 }
1054
1055         width += PAN_BOX_BORDER * 2;
1056         height += PAN_BOX_BORDER * 2;
1057
1058         pr = PIXBUF_RENDERER(pw->imd->pr);
1059         if (width < pr->window_width) width = pr->window_width;
1060         if (height < pr->window_width) height = pr->window_height;
1061
1062         pixbuf_renderer_set_tiles_size(PIXBUF_RENDERER(pw->imd->pr), width, height);
1063 }
1064
1065 static gint pan_layout_update_idle_cb(gpointer data)
1066 {
1067         PanWindow *pw = data;
1068         gint width;
1069         gint height;
1070         gint scroll_x;
1071         gint scroll_y;
1072
1073         if (pw->size > PAN_IMAGE_SIZE_THUMB_LARGE ||
1074             (pw->exif_date_enable && (pw->layout == PAN_LAYOUT_TIMELINE || pw->layout == PAN_LAYOUT_CALENDAR)))
1075                 {
1076                 if (!pw->cache_list && !pw->cache_todo)
1077                         {
1078                         pan_cache_fill(pw, pw->path);
1079                         if (pw->cache_todo)
1080                                 {
1081                                 pan_window_message(pw, _("Reading image data..."));
1082                                 return TRUE;
1083                                 }
1084                         }
1085                 if (pw->cache_todo)
1086                         {
1087                         pw->cache_count++;
1088                         pw->cache_tick++;
1089                         if (pw->cache_count == pw->cache_total)
1090                                 {
1091                                 pan_window_message(pw, _("Sorting..."));
1092                                 }
1093                         else if (pw->cache_tick > 9)
1094                                 {
1095                                 gchar *buf;
1096
1097                                 buf = g_strdup_printf("%s %d / %d", _("Reading image data..."),
1098                                                       pw->cache_count, pw->cache_total);
1099                                 pan_window_message(pw, buf);
1100                                 g_free(buf);
1101
1102                                 pw->cache_tick = 0;
1103                                 }
1104
1105                         if (pan_cache_step(pw)) return TRUE;
1106
1107                         pw->idle_id = -1;
1108                         return FALSE;
1109                         }
1110                 }
1111
1112         pan_layout_compute(pw, pw->path, &width, &height, &scroll_x, &scroll_y);
1113
1114         pan_window_zoom_limit(pw);
1115
1116         if (width > 0 && height > 0)
1117                 {
1118                 gdouble align;
1119
1120                 DEBUG_1("Canvas size is %d x %d\n", width, height);
1121
1122                 pan_grid_build(pw, width, height, 1000);
1123
1124                 pixbuf_renderer_set_tiles(PIXBUF_RENDERER(pw->imd->pr), width, height,
1125                                           PAN_TILE_SIZE, PAN_TILE_SIZE, 10,
1126                                           pan_window_request_tile_cb,
1127                                           pan_window_dispose_tile_cb, pw, 1.0);
1128
1129                 if (scroll_x == 0 && scroll_y == 0)
1130                         {
1131                         align = 0.0;
1132                         }
1133                 else
1134                         {
1135                         align = 0.5;
1136                         }
1137                 pixbuf_renderer_scroll_to_point(PIXBUF_RENDERER(pw->imd->pr), scroll_x, scroll_y, align, align);
1138                 }
1139
1140         pan_window_message(pw, NULL);
1141
1142         pw->idle_id = -1;
1143         return FALSE;
1144 }
1145
1146 static void pan_layout_update_idle(PanWindow *pw)
1147 {
1148         if (pw->idle_id == -1)
1149                 {
1150                 pw->idle_id = g_idle_add(pan_layout_update_idle_cb, pw);
1151                 }
1152 }
1153
1154 static void pan_layout_update(PanWindow *pw)
1155 {
1156         pan_window_message(pw, _("Sorting images..."));
1157         pan_layout_update_idle(pw);
1158 }
1159
1160 static void pan_layout_set_path(PanWindow *pw, const gchar *path)
1161 {
1162         if (!path) return;
1163
1164         if (strcmp(path, "/") == 0)
1165                 {
1166                 pan_warning_folder(path, pw->window);
1167                 return;
1168                 }
1169
1170         g_free(pw->path);
1171         pw->path = g_strdup(path);
1172
1173         pan_layout_update(pw);
1174 }
1175
1176
1177 /*
1178  *-----------------------------------------------------------------------------
1179  * keyboard handlers
1180  *-----------------------------------------------------------------------------
1181  */
1182
1183 FileData *pan_menu_click_fd(PanWindow *pw)
1184 {
1185         if (pw->click_pi && pw->click_pi->fd) return pw->click_pi->fd;
1186         return NULL;
1187 }
1188
1189 static void pan_window_menu_pos_cb(GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer data)
1190 {
1191         PanWindow *pw = data;
1192
1193         gdk_window_get_origin(pw->imd->pr->window, x, y);
1194         popup_menu_position_clamp(menu, x, y, 0);
1195 }
1196
1197 static gint pan_window_key_press_cb(GtkWidget *widget, GdkEventKey *event, gpointer data)
1198 {
1199         PanWindow *pw = data;
1200         PixbufRenderer *pr;
1201         FileData *fd;
1202         gint stop_signal = FALSE;
1203         GtkWidget *menu;
1204         gint x = 0;
1205         gint y = 0;
1206         gint focused;
1207         gint on_entry;
1208
1209         pr = PIXBUF_RENDERER(pw->imd->pr);
1210         fd = pan_menu_click_fd(pw);
1211
1212         focused = (pw->fs || GTK_WIDGET_HAS_FOCUS(GTK_WIDGET(pw->imd->widget)));
1213         on_entry = (GTK_WIDGET_HAS_FOCUS(pw->path_entry) ||
1214                     GTK_WIDGET_HAS_FOCUS(pw->search_entry));
1215
1216         if (focused)
1217                 {
1218                 stop_signal = TRUE;
1219                 switch (event->keyval)
1220                         {
1221                         case GDK_Left: case GDK_KP_Left:
1222                                 x -= 1;
1223                                 break;
1224                         case GDK_Right: case GDK_KP_Right:
1225                                 x += 1;
1226                                 break;
1227                         case GDK_Up: case GDK_KP_Up:
1228                                 y -= 1;
1229                                 break;
1230                         case GDK_Down: case GDK_KP_Down:
1231                                 y += 1;
1232                                 break;
1233                         case GDK_Page_Up: case GDK_KP_Page_Up:
1234                                 pixbuf_renderer_scroll(pr, 0, 0 - pr->vis_height / 2);
1235                                 break;
1236                         case GDK_Page_Down: case GDK_KP_Page_Down:
1237                                 pixbuf_renderer_scroll(pr, 0, pr->vis_height / 2);
1238                                 break;
1239                         case GDK_Home: case GDK_KP_Home:
1240                                 pixbuf_renderer_scroll(pr, 0 - pr->vis_width / 2, 0);
1241                                 break;
1242                         case GDK_End: case GDK_KP_End:
1243                                 pixbuf_renderer_scroll(pr, pr->vis_width / 2, 0);
1244                                 break;
1245                         default:
1246                                 stop_signal = FALSE;
1247                                 break;
1248                         }
1249
1250                 if (x != 0 || y!= 0)
1251                         {
1252                         if (event->state & GDK_SHIFT_MASK)
1253                                 {
1254                                 x *= 3;
1255                                 y *= 3;
1256                                 }
1257                         keyboard_scroll_calc(&x, &y, event);
1258                         pixbuf_renderer_scroll(pr, x, y);
1259                         }
1260                 }
1261
1262         if (stop_signal) return stop_signal;
1263
1264         if (event->state & GDK_CONTROL_MASK)
1265                 {
1266                 gint n = -1;
1267
1268                 stop_signal = TRUE;
1269                 switch (event->keyval)
1270                         {
1271                         case '1':
1272                                 n = 0;
1273                                 break;
1274                         case '2':
1275                                 n = 1;
1276                                 break;
1277                         case '3':
1278                                 n = 2;
1279                                 break;
1280                         case '4':
1281                                 n = 3;
1282                                 break;
1283                         case '5':
1284                                 n = 4;
1285                                 break;
1286                         case '6':
1287                                 n = 5;
1288                                 break;
1289                         case '7':
1290                                 n = 6;
1291                                 break;
1292                         case '8':
1293                                 n = 7;
1294                                 break;
1295                         case '9':
1296                                 n = 8;
1297                                 break;
1298                         case '0':
1299                                 n = 9;
1300                                 break;
1301                         case 'C': case 'c':
1302                                 if (fd) file_util_copy(fd, NULL, NULL, GTK_WIDGET(pr));
1303                                 break;
1304                         case 'M': case 'm':
1305                                 if (fd) file_util_move(fd, NULL, NULL, GTK_WIDGET(pr));
1306                                 break;
1307                         case 'R': case 'r':
1308                                 if (fd) file_util_rename(fd, NULL, GTK_WIDGET(pr));
1309                                 break;
1310                         case 'D': case 'd':
1311                                 if (fd) file_util_delete(fd, NULL, GTK_WIDGET(pr));
1312                                 break;
1313                         case 'P': case 'p':
1314                                 if (fd) info_window_new(fd, NULL, NULL);
1315                                 break;
1316                         case 'F': case 'f':
1317                                 pan_search_toggle_visible(pw, TRUE);
1318                                 break;
1319                         case 'G': case 'g':
1320                                 pan_search_activate(pw);
1321                                 break;
1322                         case 'W': case 'w':
1323                                 pan_window_close(pw);
1324                                 break;
1325                         default:
1326                                 stop_signal = FALSE;
1327                                 break;
1328                         }
1329
1330                 if (n != -1 && fd)
1331                         {
1332                         if (!editor_window_flag_set(n))
1333                                 {
1334                                 pan_fullscreen_toggle(pw, TRUE);
1335                                 }
1336                         start_editor_from_file(n, fd);
1337                         }
1338                 }
1339         else
1340                 {
1341                 stop_signal = TRUE;
1342                 switch (event->keyval)
1343                         {
1344                         case GDK_Escape:
1345                                 if (pw->fs)
1346                                         {
1347                                         pan_fullscreen_toggle(pw, TRUE);
1348                                         }
1349                                 else
1350                                         {
1351                                         pan_search_toggle_visible(pw, FALSE);
1352                                         }
1353                                 break;
1354                         default:
1355                                 stop_signal = FALSE;
1356                                 break;
1357                         }
1358
1359                 if (stop_signal) return stop_signal;
1360
1361                 if (!on_entry)
1362                         {
1363                         stop_signal = TRUE;
1364                         switch (event->keyval)
1365                                 {
1366                                 case '+': case '=': case GDK_KP_Add:
1367                                         pixbuf_renderer_zoom_adjust(pr, ZOOM_INCREMENT);
1368                                         break;
1369                                 case '-': case GDK_KP_Subtract:
1370                                         pixbuf_renderer_zoom_adjust(pr, -ZOOM_INCREMENT);
1371                                         break;
1372                                 case 'Z': case 'z': case GDK_KP_Divide: case '1':
1373                                         pixbuf_renderer_zoom_set(pr, 1.0);
1374                                         break;
1375                                 case '2':
1376                                         pixbuf_renderer_zoom_set(pr, 2.0);
1377                                         break;
1378                                 case '3':
1379                                         pixbuf_renderer_zoom_set(pr, 3.0);
1380                                         break;
1381                                 case '4':
1382                                         pixbuf_renderer_zoom_set(pr, 4.0);
1383                                         break;
1384                                 case '7':
1385                                         pixbuf_renderer_zoom_set(pr, -4.0);
1386                                         break;
1387                                 case '8':
1388                                         pixbuf_renderer_zoom_set(pr, -3.0);
1389                                         break;
1390                                 case '9':
1391                                         pixbuf_renderer_zoom_set(pr, -2.0);
1392                                         break;
1393                                 case 'F': case 'f':
1394                                 case 'V': case 'v':
1395                                 case GDK_F11:
1396                                         pan_fullscreen_toggle(pw, FALSE);
1397                                         break;
1398                                 case 'I': case 'i':
1399 #if 0
1400                                         pan_overlay_toggle(pw);
1401 #endif
1402                                         break;
1403                                 case GDK_Delete: case GDK_KP_Delete:
1404                                         break;
1405                                 case GDK_Menu:
1406                                 case GDK_F10:
1407                                         menu = pan_popup_menu(pw);
1408                                         gtk_menu_popup(GTK_MENU(menu), NULL, NULL,
1409                                                        pan_window_menu_pos_cb, pw, 0, GDK_CURRENT_TIME);
1410                                         break;
1411                                 case '/':
1412                                         pan_search_toggle_visible(pw, TRUE);
1413                                         break;
1414                                 default:
1415                                         stop_signal = FALSE;
1416                                         break;
1417                                 }
1418                         }
1419                 }
1420
1421         return stop_signal;
1422 }
1423
1424 /*
1425  *-----------------------------------------------------------------------------
1426  * info popup
1427  *-----------------------------------------------------------------------------
1428  */
1429
1430 static void pan_info_add_exif(PanTextAlignment *ta, FileData *fd)
1431 {
1432         ExifData *exif;
1433         GList *work;
1434         gint i;
1435
1436         if (!fd) return;
1437         exif = exif_read_fd(fd);
1438         if (!exif) return;
1439
1440         pan_text_alignment_add(ta, NULL, NULL);
1441
1442         for (i = 0; ExifUIList[i].key; i++)
1443                 {
1444                 gchar *label;
1445                 gchar *text;
1446
1447                 if (ExifUIList[i].current == EXIF_UI_OFF) continue;
1448
1449                 text = exif_get_data_as_text(exif, ExifUIList[i].key);
1450                 text = bar_exif_validate_text(text);
1451                 if (ExifUIList[i].current == EXIF_UI_IFSET && (!text || !*text))
1452                         {
1453                         if (text) g_free(text);
1454                         continue;
1455                         }
1456
1457                 label = g_strdup_printf("%s:", exif_get_description_by_key(ExifUIList[i].key));
1458                 pan_text_alignment_add(ta, label, text);
1459                 g_free(label);
1460                 g_free(text);
1461                 }
1462
1463         work = g_list_last(history_list_get_by_key("exif_extras"));
1464         if (work) pan_text_alignment_add(ta, "---", NULL);
1465         while (work)
1466                 {
1467                 const gchar *name;
1468                 gchar *label;
1469                 gchar *text;
1470
1471                 name = work->data;
1472                 work = work->prev;
1473
1474                 label = g_strdup_printf("%s:", name);
1475                 text = exif_get_data_as_text(exif, name);
1476                 text = bar_exif_validate_text(text);
1477                 pan_text_alignment_add(ta, label, text);
1478                 g_free(label);
1479                 g_free(text);
1480                 }
1481
1482         exif_free(exif);
1483 }
1484
1485 static void pan_info_update(PanWindow *pw, PanItem *pi)
1486 {
1487         PanTextAlignment *ta;
1488         PanItem *pbox;
1489         PanItem *p;
1490         gchar *buf;
1491         gint x1, y1, x2, y2, x3, y3;
1492         gint x, y, w, h;
1493
1494         if (pw->click_pi == pi) return;
1495         if (pi && !pi->fd) pi = NULL;
1496
1497         while ((p = pan_item_find_by_key(pw, PAN_ITEM_NONE, "info"))) pan_item_remove(pw, p);
1498         pw->click_pi = pi;
1499
1500         if (!pi) return;
1501
1502         DEBUG_1("info set to %s\n", pi->fd->path);
1503
1504         pbox = pan_item_box_new(pw, NULL, pi->x + pi->width + 4, pi->y, 10, 10,
1505                                 PAN_POPUP_BORDER,
1506                                 PAN_POPUP_COLOR, PAN_POPUP_ALPHA,
1507                                 PAN_POPUP_BORDER_COLOR, PAN_POPUP_ALPHA);
1508         pan_item_set_key(pbox, "info");
1509
1510         if (pi->type == PAN_ITEM_THUMB && pi->pixbuf)
1511                 {
1512                 w = gdk_pixbuf_get_width(pi->pixbuf);
1513                 h = gdk_pixbuf_get_height(pi->pixbuf);
1514
1515                 x1 = pi->x + pi->width - (pi->width - w) / 2 - 8;
1516                 y1 = pi->y + (pi->height - h) / 2 + 8;
1517                 }
1518         else
1519                 {
1520                 x1 = pi->x + pi->width - 8;
1521                 y1 = pi->y + 8;
1522                 }
1523
1524         x2 = pbox->x + 1;
1525         y2 = pbox->y + 36;
1526         x3 = pbox->x + 1;
1527         y3 = pbox->y + 12;
1528         util_clip_triangle(x1, y1, x2, y2, x3, y3,
1529                            &x, &y, &w, &h);
1530
1531         p = pan_item_tri_new(pw, NULL, x, y, w, h,
1532                              x1, y1, x2, y2, x3, y3,
1533                              PAN_POPUP_COLOR, PAN_POPUP_ALPHA);
1534         pan_item_tri_border(p, PAN_BORDER_1 | PAN_BORDER_3, PAN_POPUP_BORDER_COLOR, PAN_POPUP_ALPHA);
1535         pan_item_set_key(p, "info");
1536         pan_item_added(pw, p);
1537
1538         ta = pan_text_alignment_new(pw, pbox->x + PREF_PAD_BORDER, pbox->y + PREF_PAD_BORDER, "info");
1539
1540         pan_text_alignment_add(ta, _("Filename:"), pi->fd->name);
1541         buf = remove_level_from_path(pi->fd->path);
1542         pan_text_alignment_add(ta, _("Location:"), buf);
1543         g_free(buf);
1544         pan_text_alignment_add(ta, _("Date:"), text_from_time(pi->fd->date));
1545         buf = text_from_size(pi->fd->size);
1546         pan_text_alignment_add(ta, _("Size:"), buf);
1547         g_free(buf);
1548
1549         if (pw->info_includes_exif)
1550                 {
1551                 pan_info_add_exif(ta, pi->fd);
1552                 }
1553
1554         pan_text_alignment_calc(ta, pbox);
1555         pan_text_alignment_free(ta);
1556
1557         pan_item_box_shadow(pbox, PAN_SHADOW_OFFSET * 2, PAN_SHADOW_FADE * 2);
1558         pan_item_added(pw, pbox);
1559
1560         if (pw->info_image_size > PAN_IMAGE_SIZE_THUMB_NONE)
1561                 {
1562                 gint iw, ih;
1563                 if (image_load_dimensions(pi->fd, &iw, &ih))
1564                         {
1565                         gint scale = 25;
1566
1567                         switch (pw->info_image_size)
1568                                 {
1569                                 case PAN_IMAGE_SIZE_10:
1570                                         scale = 10;
1571                                         break;
1572                                 case PAN_IMAGE_SIZE_25:
1573                                         scale = 25;
1574                                         break;
1575                                 case PAN_IMAGE_SIZE_33:
1576                                         scale = 33;
1577                                         break;
1578                                 case PAN_IMAGE_SIZE_50:
1579                                         scale = 50;
1580                                         break;
1581                                 case PAN_IMAGE_SIZE_100:
1582                                         scale = 100;
1583                                         break;
1584                                 }
1585
1586                         iw = MAX(1, iw * scale / 100);
1587                         ih = MAX(1, ih * scale / 100);
1588
1589                         pbox = pan_item_box_new(pw, NULL, pbox->x, pbox->y + pbox->height + 8, 10, 10,
1590                                                 PAN_POPUP_BORDER,
1591                                                 PAN_POPUP_COLOR, PAN_POPUP_ALPHA,
1592                                                 PAN_POPUP_BORDER_COLOR, PAN_POPUP_ALPHA);
1593                         pan_item_set_key(pbox, "info");
1594
1595                         p = pan_item_image_new(pw, file_data_new_simple(pi->fd->path),
1596                                                pbox->x + PREF_PAD_BORDER, pbox->y + PREF_PAD_BORDER, iw, ih);
1597                         pan_item_set_key(p, "info");
1598                         pan_item_size_by_item(pbox, p, PREF_PAD_BORDER);
1599
1600                         pan_item_box_shadow(pbox, PAN_SHADOW_OFFSET * 2, PAN_SHADOW_FADE * 2);
1601                         pan_item_added(pw, pbox);
1602                         }
1603                 }
1604
1605         pan_layout_resize(pw);
1606 }
1607
1608
1609 /*
1610  *-----------------------------------------------------------------------------
1611  * search
1612  *-----------------------------------------------------------------------------
1613  */
1614
1615 static void pan_search_status(PanWindow *pw, const gchar *text)
1616 {
1617         gtk_label_set_text(GTK_LABEL(pw->search_label), (text) ? text : "");
1618 }
1619
1620 static gint pan_search_by_path(PanWindow *pw, const gchar *path)
1621 {
1622         PanItem *pi;
1623         GList *list;
1624         GList *found;
1625         PanItemType type;
1626         gchar *buf;
1627
1628         type = (pw->size > PAN_IMAGE_SIZE_THUMB_LARGE) ? PAN_ITEM_IMAGE : PAN_ITEM_THUMB;
1629
1630         list = pan_item_find_by_path(pw, type, path, FALSE, FALSE);
1631         if (!list) return FALSE;
1632
1633         found = g_list_find(list, pw->click_pi);
1634         if (found && found->next)
1635                 {
1636                 found = found->next;
1637                 pi = found->data;
1638                 }
1639         else
1640                 {
1641                 pi = list->data;
1642                 }
1643
1644         pan_info_update(pw, pi);
1645         image_scroll_to_point(pw->imd, pi->x + pi->width / 2, pi->y + pi->height / 2, 0.5, 0.5);
1646
1647         buf = g_strdup_printf("%s ( %d / %d )",
1648                               (path[0] == '/') ? _("path found") : _("filename found"),
1649                               g_list_index(list, pi) + 1,
1650                               g_list_length(list));
1651         pan_search_status(pw, buf);
1652         g_free(buf);
1653
1654         g_list_free(list);
1655
1656         return TRUE;
1657 }
1658
1659 static gint pan_search_by_partial(PanWindow *pw, const gchar *text)
1660 {
1661         PanItem *pi;
1662         GList *list;
1663         GList *found;
1664         PanItemType type;
1665         gchar *buf;
1666
1667         type = (pw->size > PAN_IMAGE_SIZE_THUMB_LARGE) ? PAN_ITEM_IMAGE : PAN_ITEM_THUMB;
1668
1669         list = pan_item_find_by_path(pw, type, text, TRUE, FALSE);
1670         if (!list) list = pan_item_find_by_path(pw, type, text, FALSE, TRUE);
1671         if (!list)
1672                 {
1673                 gchar *needle;
1674
1675                 needle = g_utf8_strdown(text, -1);
1676                 list = pan_item_find_by_path(pw, type, needle, TRUE, TRUE);
1677                 g_free(needle);
1678                 }
1679         if (!list) return FALSE;
1680
1681         found = g_list_find(list, pw->click_pi);
1682         if (found && found->next)
1683                 {
1684                 found = found->next;
1685                 pi = found->data;
1686                 }
1687         else
1688                 {
1689                 pi = list->data;
1690                 }
1691
1692         pan_info_update(pw, pi);
1693         image_scroll_to_point(pw->imd, pi->x + pi->width / 2, pi->y + pi->height / 2, 0.5, 0.5);
1694
1695         buf = g_strdup_printf("%s ( %d / %d )",
1696                               _("partial match"),
1697                               g_list_index(list, pi) + 1,
1698                               g_list_length(list));
1699         pan_search_status(pw, buf);
1700         g_free(buf);
1701
1702         g_list_free(list);
1703
1704         return TRUE;
1705 }
1706
1707 static gint valid_date_separator(gchar c)
1708 {
1709         return (c == '/' || c == '-' || c == ' ' || c == '.' || c == ',');
1710 }
1711
1712 static GList *pan_search_by_date_val(PanWindow *pw, PanItemType type,
1713                                      gint year, gint month, gint day,
1714                                      const gchar *key)
1715 {
1716         GList *list = NULL;
1717         GList *work;
1718
1719         work = g_list_last(pw->list_static);
1720         while (work)
1721                 {
1722                 PanItem *pi;
1723
1724                 pi = work->data;
1725                 work = work->prev;
1726
1727                 if (pi->fd && (pi->type == type || type == PAN_ITEM_NONE) &&
1728                     ((!key && !pi->key) || (key && pi->key && strcmp(key, pi->key) == 0)))
1729                         {
1730                         struct tm *tl;
1731
1732                         tl = localtime(&pi->fd->date);
1733                         if (tl)
1734                                 {
1735                                 gint match;
1736
1737                                 match = (tl->tm_year == year - 1900);
1738                                 if (match && month >= 0) match = (tl->tm_mon == month - 1);
1739                                 if (match && day > 0) match = (tl->tm_mday == day);
1740
1741                                 if (match) list = g_list_prepend(list, pi);
1742                                 }
1743                         }
1744                 }
1745
1746         return g_list_reverse(list);
1747 }
1748
1749 static gint pan_search_by_date(PanWindow *pw, const gchar *text)
1750 {
1751         PanItem *pi = NULL;
1752         GList *list = NULL;
1753         GList *found;
1754         gint year;
1755         gint month = -1;
1756         gint day = -1;
1757         gchar *ptr;
1758         gchar *mptr;
1759         struct tm *lt;
1760         time_t t;
1761         gchar *message;
1762         gchar *buf;
1763         gchar *buf_count;
1764
1765         if (!text) return FALSE;
1766
1767         ptr = (gchar *)text;
1768         while (*ptr != '\0')
1769                 {
1770                 if (!g_unichar_isdigit(*ptr) && !valid_date_separator(*ptr)) return FALSE;
1771                 ptr++;
1772                 }
1773
1774         t = time(NULL);
1775         if (t == -1) return FALSE;
1776         lt = localtime(&t);
1777         if (!lt) return FALSE;
1778
1779         if (valid_date_separator(*text))
1780                 {
1781                 year = -1;
1782                 mptr = (gchar *)text;
1783                 }
1784         else
1785                 {
1786                 year = (gint)strtol(text, &mptr, 10);
1787                 if (mptr == text) return FALSE;
1788                 }
1789
1790         if (*mptr != '\0' && valid_date_separator(*mptr))
1791                 {
1792                 gchar *dptr;
1793
1794                 mptr++;
1795                 month = strtol(mptr, &dptr, 10);
1796                 if (dptr == mptr)
1797                         {
1798                         if (valid_date_separator(*dptr))
1799                                 {
1800                                 month = lt->tm_mon + 1;
1801                                 dptr++;
1802                                 }
1803                         else
1804                                 {
1805                                 month = -1;
1806                                 }
1807                         }
1808                 if (dptr != mptr && *dptr != '\0' && valid_date_separator(*dptr))
1809                         {
1810                         gchar *eptr;
1811                         dptr++;
1812                         day = strtol(dptr, &eptr, 10);
1813                         if (dptr == eptr)
1814                                 {
1815                                 day = lt->tm_mday;
1816                                 }
1817                         }
1818                 }
1819
1820         if (year == -1)
1821                 {
1822                 year = lt->tm_year + 1900;
1823                 }
1824         else if (year < 100)
1825                 {
1826                 if (year > 70)
1827                         year+= 1900;
1828                 else
1829                         year+= 2000;
1830                 }
1831
1832         if (year < 1970 ||
1833             month < -1 || month == 0 || month > 12 ||
1834             day < -1 || day == 0 || day > 31) return FALSE;
1835
1836         t = pan_date_to_time(year, month, day);
1837         if (t < 0) return FALSE;
1838
1839         if (pw->layout == PAN_LAYOUT_CALENDAR)
1840                 {
1841                 list = pan_search_by_date_val(pw, PAN_ITEM_BOX, year, month, day, "day");
1842                 }
1843         else
1844                 {
1845                 PanItemType type;
1846
1847                 type = (pw->size > PAN_IMAGE_SIZE_THUMB_LARGE) ? PAN_ITEM_IMAGE : PAN_ITEM_THUMB;
1848                 list = pan_search_by_date_val(pw, type, year, month, day, NULL);
1849                 }
1850
1851         if (list)
1852                 {
1853                 found = g_list_find(list, pw->search_pi);
1854                 if (found && found->next)
1855                         {
1856                         found = found->next;
1857                         pi = found->data;
1858                         }
1859                 else
1860                         {
1861                         pi = list->data;
1862                         }
1863                 }
1864
1865         pw->search_pi = pi;
1866
1867         if (pw->layout == PAN_LAYOUT_CALENDAR && pi && pi->type == PAN_ITEM_BOX)
1868                 {
1869                 pan_info_update(pw, NULL);
1870                 pan_calendar_update(pw, pi);
1871                 image_scroll_to_point(pw->imd,
1872                                       pi->x + pi->width / 2,
1873                                       pi->y + pi->height / 2, 0.5, 0.5);
1874                 }
1875         else if (pi)
1876                 {
1877                 pan_info_update(pw, pi);
1878                 image_scroll_to_point(pw->imd,
1879                                       pi->x - PAN_BOX_BORDER * 5 / 2,
1880                                       pi->y, 0.0, 0.5);
1881                 }
1882
1883         if (month > 0)
1884                 {
1885                 buf = pan_date_value_string(t, PAN_DATE_LENGTH_MONTH);
1886                 if (day > 0)
1887                         {
1888                         gchar *tmp;
1889                         tmp = buf;
1890                         buf = g_strdup_printf("%d %s", day, tmp);
1891                         g_free(tmp);
1892                         }
1893                 }
1894         else
1895                 {
1896                 buf = pan_date_value_string(t, PAN_DATE_LENGTH_YEAR);
1897                 }
1898
1899         if (pi)
1900                 {
1901                 buf_count = g_strdup_printf("( %d / %d )",
1902                                             g_list_index(list, pi) + 1,
1903                                             g_list_length(list));
1904                 }
1905         else
1906                 {
1907                 buf_count = g_strdup_printf("(%s)", _("no match"));
1908                 }
1909
1910         message = g_strdup_printf("%s %s %s", _("Date:"), buf, buf_count);
1911         g_free(buf);
1912         g_free(buf_count);
1913         pan_search_status(pw, message);
1914         g_free(message);
1915
1916         g_list_free(list);
1917
1918         return TRUE;
1919 }
1920
1921 static void pan_search_activate_cb(const gchar *text, gpointer data)
1922 {
1923         PanWindow *pw = data;
1924
1925         if (!text) return;
1926
1927         tab_completion_append_to_history(pw->search_entry, text);
1928
1929         if (pan_search_by_path(pw, text)) return;
1930
1931         if ((pw->layout == PAN_LAYOUT_TIMELINE ||
1932              pw->layout == PAN_LAYOUT_CALENDAR) &&
1933             pan_search_by_date(pw, text))
1934                 {
1935                 return;
1936                 }
1937
1938         if (pan_search_by_partial(pw, text)) return;
1939
1940         pan_search_status(pw, _("no match"));
1941 }
1942
1943 static void pan_search_activate(PanWindow *pw)
1944 {
1945         gchar *text;
1946
1947 #if 0
1948         if (!GTK_WIDGET_VISIBLE(pw->search_box))
1949                 {
1950                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pw->search_button), TRUE);
1951                 }
1952 #endif
1953
1954         text = g_strdup(gtk_entry_get_text(GTK_ENTRY(pw->search_entry)));
1955         pan_search_activate_cb(text, pw);
1956         g_free(text);
1957 }
1958
1959 static void pan_search_toggle_cb(GtkWidget *button, gpointer data)
1960 {
1961         PanWindow *pw = data;
1962         gint visible;
1963
1964         visible = GTK_WIDGET_VISIBLE(pw->search_box);
1965         if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button)) == visible) return;
1966
1967         if (visible)
1968                 {
1969                 gtk_widget_hide(pw->search_box);
1970                 gtk_arrow_set(GTK_ARROW(pw->search_button_arrow), GTK_ARROW_UP, GTK_SHADOW_NONE);
1971                 }
1972         else
1973                 {
1974                 gtk_widget_show(pw->search_box);
1975                 gtk_arrow_set(GTK_ARROW(pw->search_button_arrow), GTK_ARROW_DOWN, GTK_SHADOW_NONE);
1976                 gtk_widget_grab_focus(pw->search_entry);
1977                 }
1978 }
1979
1980 static void pan_search_toggle_visible(PanWindow *pw, gint enable)
1981 {
1982         if (pw->fs) return;
1983
1984         if (enable)
1985                 {
1986                 if (GTK_WIDGET_VISIBLE(pw->search_box))
1987                         {
1988                         gtk_widget_grab_focus(pw->search_entry);
1989                         }
1990                 else
1991                         {
1992                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pw->search_button), TRUE);
1993                         }
1994                 }
1995         else
1996                 {
1997                 if (GTK_WIDGET_VISIBLE(pw->search_entry))
1998                         {
1999                         if (GTK_WIDGET_HAS_FOCUS(pw->search_entry))
2000                                 {
2001                                 gtk_widget_grab_focus(GTK_WIDGET(pw->imd->widget));
2002                                 }
2003                         gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(pw->search_button), FALSE);
2004                         }
2005                 }
2006 }
2007
2008
2009 /*
2010  *-----------------------------------------------------------------------------
2011  * main window
2012  *-----------------------------------------------------------------------------
2013  */
2014
2015 static void button_cb(PixbufRenderer *pr, GdkEventButton *event, gpointer data)
2016 {
2017         PanWindow *pw = data;
2018         PanItem *pi = NULL;
2019         GtkWidget *menu;
2020         gint rx, ry;
2021
2022         rx = ry = 0;
2023         if (pr->scale)
2024                 {
2025                 rx = (double)(pr->x_scroll + event->x - pr->x_offset) / pr->scale;
2026                 ry = (double)(pr->y_scroll + event->y - pr->y_offset) / pr->scale;
2027                 }
2028
2029         pi = pan_item_find_by_coord(pw, PAN_ITEM_BOX, rx, ry, "info");
2030         if (pi && event->button == MOUSE_BUTTON_LEFT)
2031                 {
2032                 pan_info_update(pw, NULL);
2033                 return;
2034                 }
2035
2036         pi = pan_item_find_by_coord(pw, (pw->size > PAN_IMAGE_SIZE_THUMB_LARGE) ? PAN_ITEM_IMAGE : PAN_ITEM_THUMB,
2037                                     rx, ry, NULL);
2038
2039         switch (event->button)
2040                 {
2041                 case MOUSE_BUTTON_LEFT:
2042                         pan_info_update(pw, pi);
2043
2044                         if (!pi && pw->layout == PAN_LAYOUT_CALENDAR)
2045                                 {
2046                                 pi = pan_item_find_by_coord(pw, PAN_ITEM_BOX, rx, ry, "day");
2047                                 pan_calendar_update(pw, pi);
2048                                 }
2049                         break;
2050                 case MOUSE_BUTTON_MIDDLE:
2051                         break;
2052                 case MOUSE_BUTTON_RIGHT:
2053                         pan_info_update(pw, pi);
2054                         menu = pan_popup_menu(pw);
2055                         gtk_menu_popup (GTK_MENU(menu), NULL, NULL, NULL, NULL, 3, event->time);
2056                         break;
2057                 default:
2058                         break;
2059                 }
2060 }
2061
2062 static void scroll_cb(PixbufRenderer *pr, GdkEventScroll *event, gpointer data)
2063 {
2064 #if 0
2065         PanWindow *pw = data;
2066 #endif
2067         gint w, h;
2068
2069         w = pr->vis_width;
2070         h = pr->vis_height;
2071
2072         if (!(event->state & GDK_SHIFT_MASK))
2073                 {
2074                 w /= 3;
2075                 h /= 3;
2076                 }
2077
2078         if (event->state & GDK_CONTROL_MASK)
2079                 {
2080                 switch (event->direction)
2081                         {
2082                         case GDK_SCROLL_UP:
2083                                 pixbuf_renderer_zoom_adjust_at_point(pr, ZOOM_INCREMENT,
2084                                                                      (gint)event->x, (gint)event->y);
2085                                 break;
2086                         case GDK_SCROLL_DOWN:
2087                                 pixbuf_renderer_zoom_adjust_at_point(pr, -ZOOM_INCREMENT,
2088                                                                      (gint)event->x, (gint)event->y);
2089                                 break;
2090                         default:
2091                                 break;
2092                         }
2093                 }
2094         else
2095                 {
2096                 switch (event->direction)
2097                         {
2098                         case GDK_SCROLL_UP:
2099                                 pixbuf_renderer_scroll(pr, 0, -h);
2100                                 break;
2101                         case GDK_SCROLL_DOWN:
2102                                 pixbuf_renderer_scroll(pr, 0, h);
2103                                 break;
2104                         case GDK_SCROLL_LEFT:
2105                                 pixbuf_renderer_scroll(pr, -w, 0);
2106                                 break;
2107                         case GDK_SCROLL_RIGHT:
2108                                 pixbuf_renderer_scroll(pr, w, 0);
2109                                 break;
2110                         default:
2111                                 break;
2112                         }
2113                 }
2114 }
2115
2116 static void pan_image_set_buttons(PanWindow *pw, ImageWindow *imd)
2117 {
2118         g_signal_connect(G_OBJECT(imd->pr), "clicked",
2119                          G_CALLBACK(button_cb), pw);
2120         g_signal_connect(G_OBJECT(imd->pr), "scroll_event",
2121                          G_CALLBACK(scroll_cb), pw);
2122 }
2123
2124 static void pan_fullscreen_stop_func(FullScreenData *fs, gpointer data)
2125 {
2126         PanWindow *pw = data;
2127
2128         pw->fs = NULL;
2129         pw->imd = pw->imd_normal;
2130 }
2131
2132 static void pan_fullscreen_toggle(PanWindow *pw, gint force_off)
2133 {
2134         if (force_off && !pw->fs) return;
2135
2136         if (pw->fs)
2137                 {
2138                 fullscreen_stop(pw->fs);
2139                 }
2140         else
2141                 {
2142                 pw->fs = fullscreen_start(pw->window, pw->imd, pan_fullscreen_stop_func, pw);
2143                 pan_image_set_buttons(pw, pw->fs->imd);
2144                 g_signal_connect(G_OBJECT(pw->fs->window), "key_press_event",
2145                                  G_CALLBACK(pan_window_key_press_cb), pw);
2146
2147                 pw->imd = pw->fs->imd;
2148                 }
2149 }
2150
2151 static void pan_window_image_zoom_cb(PixbufRenderer *pr, gdouble zoom, gpointer data)
2152 {
2153         PanWindow *pw = data;
2154         gchar *text;
2155
2156         text = image_zoom_get_as_text(pw->imd);
2157         gtk_label_set_text(GTK_LABEL(pw->label_zoom), text);
2158         g_free(text);
2159 }
2160
2161 static void pan_window_image_scroll_notify_cb(PixbufRenderer *pr, gpointer data)
2162 {
2163         PanWindow *pw = data;
2164         GtkAdjustment *adj;
2165         GdkRectangle rect;
2166         gint width, height;
2167
2168         if (pr->scale == 0.0) return;
2169
2170         pixbuf_renderer_get_visible_rect(pr, &rect);
2171         pixbuf_renderer_get_image_size(pr, &width, &height);
2172
2173         adj = gtk_range_get_adjustment(GTK_RANGE(pw->scrollbar_h));
2174         adj->page_size = (gdouble)rect.width;
2175         adj->page_increment = adj->page_size / 2.0;
2176         adj->step_increment = 48.0 / pr->scale;
2177         adj->lower = 0.0;
2178         adj->upper = MAX((gdouble)width, 1.0);
2179         adj->value = (gdouble)rect.x;
2180
2181         pref_signal_block_data(pw->scrollbar_h, pw);
2182         gtk_adjustment_changed(adj);
2183         gtk_adjustment_value_changed(adj);
2184         pref_signal_unblock_data(pw->scrollbar_h, pw);
2185
2186         adj = gtk_range_get_adjustment(GTK_RANGE(pw->scrollbar_v));
2187         adj->page_size = (gdouble)rect.height;
2188         adj->page_increment = adj->page_size / 2.0;
2189         adj->step_increment = 48.0 / pr->scale;
2190         adj->lower = 0.0;
2191         adj->upper = MAX((gdouble)height, 1.0);
2192         adj->value = (gdouble)rect.y;
2193
2194         pref_signal_block_data(pw->scrollbar_v, pw);
2195         gtk_adjustment_changed(adj);
2196         gtk_adjustment_value_changed(adj);
2197         pref_signal_unblock_data(pw->scrollbar_v, pw);
2198 }
2199
2200 static void pan_window_scrollbar_h_value_cb(GtkRange *range, gpointer data)
2201 {
2202         PanWindow *pw = data;
2203         PixbufRenderer *pr;
2204         gint x;
2205
2206         pr = PIXBUF_RENDERER(pw->imd_normal->pr);
2207
2208         if (!pr->scale) return;
2209
2210         x = (gint)gtk_range_get_value(range);
2211
2212         pixbuf_renderer_scroll_to_point(pr, x, (gint)((gdouble)pr->y_scroll / pr->scale), 0.0, 0.0);
2213 }
2214
2215 static void pan_window_scrollbar_v_value_cb(GtkRange *range, gpointer data)
2216 {
2217         PanWindow *pw = data;
2218         PixbufRenderer *pr;
2219         gint y;
2220
2221         pr = PIXBUF_RENDERER(pw->imd_normal->pr);
2222
2223         if (!pr->scale) return;
2224
2225         y = (gint)gtk_range_get_value(range);
2226
2227         pixbuf_renderer_scroll_to_point(pr, (gint)((gdouble)pr->x_scroll / pr->scale), y, 0.0, 0.0);
2228 }
2229
2230 static void pan_window_layout_change_cb(GtkWidget *combo, gpointer data)
2231 {
2232         PanWindow *pw = data;
2233
2234         pw->layout = gtk_combo_box_get_active(GTK_COMBO_BOX(combo));
2235         pan_layout_update(pw);
2236 }
2237
2238 static void pan_window_layout_size_cb(GtkWidget *combo, gpointer data)
2239 {
2240         PanWindow *pw = data;
2241
2242         pw->size = gtk_combo_box_get_active(GTK_COMBO_BOX(combo));
2243         pan_layout_update(pw);
2244 }
2245
2246 #if 0
2247 static void pan_window_date_toggle_cb(GtkWidget *button, gpointer data)
2248 {
2249         PanWindow *pw = data;
2250
2251         pw->exif_date_enable = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
2252         pan_layout_update(pw);
2253 }
2254 #endif
2255
2256 static void pan_window_entry_activate_cb(const gchar *new_text, gpointer data)
2257 {
2258         PanWindow *pw = data;
2259         gchar *path;
2260
2261         path = remove_trailing_slash(new_text);
2262         parse_out_relatives(path);
2263
2264         if (!isdir(path))
2265                 {
2266                 warning_dialog(_("Folder not found"),
2267                                _("The entered path is not a folder"),
2268                                GTK_STOCK_DIALOG_WARNING, pw->path_entry);
2269                 }
2270         else
2271                 {
2272                 tab_completion_append_to_history(pw->path_entry, path);
2273
2274                 pan_layout_set_path(pw, path);
2275                 }
2276
2277         g_free(path);
2278 }
2279
2280 static void pan_window_entry_change_cb(GtkWidget *combo, gpointer data)
2281 {
2282         PanWindow *pw = data;
2283         gchar *text;
2284
2285         if (gtk_combo_box_get_active(GTK_COMBO_BOX(combo)) < 0) return;
2286
2287         text = g_strdup(gtk_entry_get_text(GTK_ENTRY(pw->path_entry)));
2288         pan_window_entry_activate_cb(text, pw);
2289         g_free(text);
2290 }
2291
2292 static void pan_window_close(PanWindow *pw)
2293 {
2294         pan_window_list = g_list_remove(pan_window_list, pw);
2295
2296         pref_list_int_set(PAN_PREF_GROUP, PAN_PREF_EXIF_PAN_DATE, pw->exif_date_enable);
2297         pref_list_int_set(PAN_PREF_GROUP, PAN_PREF_INFO_IMAGE, pw->info_image_size);
2298         pref_list_int_set(PAN_PREF_GROUP, PAN_PREF_INFO_EXIF, pw->info_includes_exif);
2299
2300         if (pw->idle_id != -1)
2301                 {
2302                 g_source_remove(pw->idle_id);
2303                 }
2304
2305         pan_fullscreen_toggle(pw, TRUE);
2306         gtk_widget_destroy(pw->window);
2307
2308         pan_window_items_free(pw);
2309         pan_cache_free(pw);
2310
2311         g_free(pw->path);
2312
2313         g_free(pw);
2314 }
2315
2316 static gint pan_window_delete_cb(GtkWidget *w, GdkEventAny *event, gpointer data)
2317 {
2318         PanWindow *pw = data;
2319
2320         pan_window_close(pw);
2321         return TRUE;
2322 }
2323
2324 static void pan_window_new_real(const gchar *path)
2325 {
2326         PanWindow *pw;
2327         GtkWidget *vbox;
2328         GtkWidget *box;
2329         GtkWidget *combo;
2330         GtkWidget *hbox;
2331         GtkWidget *frame;
2332         GtkWidget *table;
2333         GdkGeometry geometry;
2334
2335         pw = g_new0(PanWindow, 1);
2336
2337         pw->path = g_strdup(path);
2338         pw->layout = PAN_LAYOUT_TIMELINE;
2339         pw->size = PAN_IMAGE_SIZE_THUMB_NORMAL;
2340         pw->thumb_size = PAN_THUMB_SIZE_NORMAL;
2341         pw->thumb_gap = PAN_THUMB_GAP_NORMAL;
2342
2343         if (!pref_list_int_get(PAN_PREF_GROUP, PAN_PREF_EXIF_PAN_DATE, &pw->exif_date_enable))
2344                 {
2345                 pw->exif_date_enable = FALSE;
2346                 }
2347         if (!pref_list_int_get(PAN_PREF_GROUP, PAN_PREF_INFO_IMAGE, &pw->info_image_size))
2348                 {
2349                 pw->info_image_size = PAN_IMAGE_SIZE_THUMB_NONE;
2350                 }
2351         if (!pref_list_int_get(PAN_PREF_GROUP, PAN_PREF_INFO_EXIF, &pw->info_includes_exif))
2352                 {
2353                 pw->info_includes_exif = TRUE;
2354                 }
2355
2356         pw->ignore_symlinks = TRUE;
2357
2358         pw->list = NULL;
2359         pw->list_static = NULL;
2360         pw->list_grid = NULL;
2361
2362         pw->fs = NULL;
2363         pw->overlay_id = -1;
2364         pw->idle_id = -1;
2365
2366         pw->window = window_new(GTK_WINDOW_TOPLEVEL, "panview", NULL, NULL, _("Pan View"));
2367
2368         geometry.min_width = 8;
2369         geometry.min_height = 8;
2370         gtk_window_set_geometry_hints(GTK_WINDOW(pw->window), NULL, &geometry, GDK_HINT_MIN_SIZE);
2371
2372         gtk_window_set_resizable(GTK_WINDOW(pw->window), TRUE);
2373         gtk_container_set_border_width(GTK_CONTAINER(pw->window), 0);
2374
2375         vbox = gtk_vbox_new(FALSE, 0);
2376         gtk_container_add(GTK_CONTAINER(pw->window), vbox);
2377         gtk_widget_show(vbox);
2378
2379         box = pref_box_new(vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, PREF_PAD_SPACE);
2380
2381         pref_spacer(box, 0);
2382         pref_label_new(box, _("Location:"));
2383         combo = tab_completion_new_with_history(&pw->path_entry, path, "pan_view_path", -1,
2384                                                 pan_window_entry_activate_cb, pw);
2385         g_signal_connect(G_OBJECT(pw->path_entry->parent), "changed",
2386                          G_CALLBACK(pan_window_entry_change_cb), pw);
2387         gtk_box_pack_start(GTK_BOX(box), combo, TRUE, TRUE, 0);
2388         gtk_widget_show(combo);
2389
2390         combo = gtk_combo_box_new_text();
2391         gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("Timeline"));
2392         gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("Calendar"));
2393         gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("Folders"));
2394         gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("Folders (flower)"));
2395         gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("Grid"));
2396
2397         gtk_combo_box_set_active(GTK_COMBO_BOX(combo), pw->layout);
2398         g_signal_connect(G_OBJECT(combo), "changed",
2399                          G_CALLBACK(pan_window_layout_change_cb), pw);
2400         gtk_box_pack_start(GTK_BOX(box), combo, FALSE, FALSE, 0);
2401         gtk_widget_show(combo);
2402
2403         combo = gtk_combo_box_new_text();
2404         gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("Dots"));
2405         gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("No Images"));
2406         gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("Small Thumbnails"));
2407         gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("Normal Thumbnails"));
2408         gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("Large Thumbnails"));
2409         gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("1:10 (10%)"));
2410         gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("1:4 (25%)"));
2411         gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("1:3 (33%)"));
2412         gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("1:2 (50%)"));
2413         gtk_combo_box_append_text(GTK_COMBO_BOX(combo), _("1:1 (100%)"));
2414
2415         gtk_combo_box_set_active(GTK_COMBO_BOX(combo), pw->size);
2416         g_signal_connect(G_OBJECT(combo), "changed",
2417                          G_CALLBACK(pan_window_layout_size_cb), pw);
2418         gtk_box_pack_start(GTK_BOX(box), combo, FALSE, FALSE, 0);
2419         gtk_widget_show(combo);
2420
2421         table = pref_table_new(vbox, 2, 2, FALSE, TRUE);
2422         gtk_table_set_row_spacings(GTK_TABLE(table), 2);
2423         gtk_table_set_col_spacings(GTK_TABLE(table), 2);
2424
2425         pw->imd = image_new(TRUE);
2426         pw->imd_normal = pw->imd;
2427
2428         g_signal_connect(G_OBJECT(pw->imd->pr), "zoom",
2429                          G_CALLBACK(pan_window_image_zoom_cb), pw);
2430         g_signal_connect(G_OBJECT(pw->imd->pr), "scroll_notify",
2431                          G_CALLBACK(pan_window_image_scroll_notify_cb), pw);
2432
2433         gtk_table_attach(GTK_TABLE(table), pw->imd->widget, 0, 1, 0, 1,
2434                          GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 0, 0);
2435         gtk_widget_show(GTK_WIDGET(pw->imd->widget));
2436
2437         pan_window_dnd_init(pw);
2438
2439         pan_image_set_buttons(pw, pw->imd);
2440
2441         pw->scrollbar_h = gtk_hscrollbar_new(NULL);
2442         g_signal_connect(G_OBJECT(pw->scrollbar_h), "value_changed",
2443                          G_CALLBACK(pan_window_scrollbar_h_value_cb), pw);
2444         gtk_table_attach(GTK_TABLE(table), pw->scrollbar_h, 0, 1, 1, 2,
2445                          GTK_FILL | GTK_EXPAND, 0, 0, 0);
2446         gtk_widget_show(pw->scrollbar_h);
2447
2448         pw->scrollbar_v = gtk_vscrollbar_new(NULL);
2449         g_signal_connect(G_OBJECT(pw->scrollbar_v), "value_changed",
2450                          G_CALLBACK(pan_window_scrollbar_v_value_cb), pw);
2451         gtk_table_attach(GTK_TABLE(table), pw->scrollbar_v, 1, 2, 0, 1,
2452                          0, GTK_FILL | GTK_EXPAND, 0, 0);
2453         gtk_widget_show(pw->scrollbar_v);
2454
2455         /* find bar */
2456
2457         pw->search_box = gtk_hbox_new(FALSE, PREF_PAD_SPACE);
2458         gtk_box_pack_start(GTK_BOX(vbox), pw->search_box, FALSE, FALSE, 2);
2459
2460         pref_spacer(pw->search_box, 0);
2461         pref_label_new(pw->search_box, _("Find:"));
2462
2463         hbox = gtk_hbox_new(TRUE, PREF_PAD_SPACE);
2464         gtk_box_pack_start(GTK_BOX(pw->search_box), hbox, TRUE, TRUE, 0);
2465         gtk_widget_show(hbox);
2466
2467         combo = tab_completion_new_with_history(&pw->search_entry, "", "pan_view_search", -1,
2468                                                 pan_search_activate_cb, pw);
2469         gtk_box_pack_start(GTK_BOX(hbox), combo, TRUE, TRUE, 0);
2470         gtk_widget_show(combo);
2471
2472         pw->search_label = gtk_label_new("");
2473         gtk_box_pack_start(GTK_BOX(hbox), pw->search_label, TRUE, TRUE, 0);
2474         gtk_widget_show(pw->search_label);
2475
2476         /* status bar */
2477
2478         box = pref_box_new(vbox, FALSE, GTK_ORIENTATION_HORIZONTAL, 0);
2479
2480         frame = gtk_frame_new(NULL);
2481         gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
2482         gtk_widget_set_size_request(frame, ZOOM_LABEL_WIDTH, -1);
2483         gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 0);
2484         gtk_widget_show(frame);
2485
2486         hbox = gtk_hbox_new(FALSE, PREF_PAD_SPACE);
2487         gtk_container_add(GTK_CONTAINER(frame), hbox);
2488         gtk_widget_show(hbox);
2489
2490         pref_spacer(hbox, 0);
2491         pw->label_message = pref_label_new(hbox, "");
2492
2493         frame = gtk_frame_new(NULL);
2494         gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
2495         gtk_widget_set_size_request(frame, ZOOM_LABEL_WIDTH, -1);
2496         gtk_box_pack_end(GTK_BOX(box), frame, FALSE, FALSE, 0);
2497         gtk_widget_show(frame);
2498
2499         pw->label_zoom = gtk_label_new("");
2500         gtk_container_add(GTK_CONTAINER(frame), pw->label_zoom);
2501         gtk_widget_show(pw->label_zoom);
2502
2503 #if 0
2504         pw->date_button = pref_checkbox_new(box, _("Use Exif date"), pw->exif_date_enable,
2505                                             G_CALLBACK(pan_window_date_toggle_cb), pw);
2506 #endif
2507
2508         pw->search_button = gtk_toggle_button_new();
2509         gtk_button_set_relief(GTK_BUTTON(pw->search_button), GTK_RELIEF_NONE);
2510         gtk_button_set_focus_on_click(GTK_BUTTON(pw->search_button), FALSE);
2511         hbox = gtk_hbox_new(FALSE, PREF_PAD_GAP);
2512         gtk_container_add(GTK_CONTAINER(pw->search_button), hbox);
2513         gtk_widget_show(hbox);
2514         pw->search_button_arrow = gtk_arrow_new(GTK_ARROW_UP, GTK_SHADOW_NONE);
2515         gtk_box_pack_start(GTK_BOX(hbox), pw->search_button_arrow, FALSE, FALSE, 0);
2516         gtk_widget_show(pw->search_button_arrow);
2517         pref_label_new(hbox, _("Find"));
2518
2519         gtk_box_pack_end(GTK_BOX(box), pw->search_button, FALSE, FALSE, 0);
2520         gtk_widget_show(pw->search_button);
2521         g_signal_connect(G_OBJECT(pw->search_button), "clicked",
2522                          G_CALLBACK(pan_search_toggle_cb), pw);
2523
2524         g_signal_connect(G_OBJECT(pw->window), "delete_event",
2525                          G_CALLBACK(pan_window_delete_cb), pw);
2526         g_signal_connect(G_OBJECT(pw->window), "key_press_event",
2527                          G_CALLBACK(pan_window_key_press_cb), pw);
2528
2529         gtk_window_set_default_size(GTK_WINDOW(pw->window), PAN_WINDOW_DEFAULT_WIDTH, PAN_WINDOW_DEFAULT_HEIGHT);
2530
2531         pan_layout_update(pw);
2532
2533         gtk_widget_grab_focus(GTK_WIDGET(pw->imd->widget));
2534         gtk_widget_show(pw->window);
2535
2536         pan_window_list = g_list_append(pan_window_list, pw);
2537 }
2538
2539 /*
2540  *-----------------------------------------------------------------------------
2541  * peformance warnings
2542  *-----------------------------------------------------------------------------
2543  */
2544
2545 static void pan_warning_ok_cb(GenericDialog *gd, gpointer data)
2546 {
2547         gchar *path = data;
2548
2549         generic_dialog_close(gd);
2550
2551         pan_window_new_real(path);
2552         g_free(path);
2553 }
2554
2555 static void pan_warning_hide_cb(GtkWidget *button, gpointer data)
2556 {
2557         gint hide_dlg;
2558
2559         hide_dlg = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(button));
2560         pref_list_int_set(PAN_PREF_GROUP, PAN_PREF_HIDE_WARNING, hide_dlg);
2561 }
2562
2563 static gint pan_warning(const gchar *path)
2564 {
2565         GenericDialog *gd;
2566         GtkWidget *box;
2567         GtkWidget *group;
2568         GtkWidget *button;
2569         GtkWidget *ct_button;
2570         gint hide_dlg;
2571
2572         if (path && strcmp(path, "/") == 0)
2573                 {
2574                 pan_warning_folder(path, NULL);
2575                 return TRUE;
2576                 }
2577
2578         if (options->thumbnails.enable_caching &&
2579             options->thumbnails.spec_standard) return FALSE;
2580
2581         if (!pref_list_int_get(PAN_PREF_GROUP, PAN_PREF_HIDE_WARNING, &hide_dlg)) hide_dlg = FALSE;
2582         if (hide_dlg) return FALSE;
2583
2584         gd = generic_dialog_new(_("Pan View Performance"), GQ_WMCLASS, "pan_view_warning", NULL, FALSE,
2585                                 NULL, NULL);
2586         gd->data = g_strdup(path);
2587         generic_dialog_add_button(gd, GTK_STOCK_OK, NULL,
2588                                   pan_warning_ok_cb, TRUE);
2589
2590         box = generic_dialog_add_message(gd, GTK_STOCK_DIALOG_INFO,
2591                                          _("Pan view performance may be poor."),
2592                                          _("To improve performance of thumbnails in the pan view the"
2593                                            " following options can be enabled. Note that both options"
2594                                            " must be enabled to notice a change in performance."));
2595
2596         group = pref_box_new(box, FALSE, GTK_ORIENTATION_HORIZONTAL, 0);
2597         pref_spacer(group, PREF_PAD_INDENT);
2598         group = pref_box_new(group, TRUE, GTK_ORIENTATION_VERTICAL, PREF_PAD_GAP);
2599
2600         ct_button = pref_checkbox_new_int(group, _("Cache thumbnails"),
2601                                           options->thumbnails.enable_caching, &options->thumbnails.enable_caching);
2602         button = pref_checkbox_new_int(group, _("Use shared thumbnail cache"),
2603                                        options->thumbnails.spec_standard, &options->thumbnails.spec_standard);
2604         pref_checkbox_link_sensitivity(ct_button, button);
2605
2606         pref_line(box, 0);
2607
2608         pref_checkbox_new(box, _("Do not show this dialog again"), hide_dlg,
2609                           G_CALLBACK(pan_warning_hide_cb), NULL);
2610
2611         gtk_widget_show(gd->dialog);
2612
2613         return TRUE;
2614 }
2615
2616
2617 /*
2618  *-----------------------------------------------------------------------------
2619  * entry point
2620  *-----------------------------------------------------------------------------
2621  */
2622
2623 void pan_window_new(const gchar *path)
2624 {
2625         if (pan_warning(path)) return;
2626
2627         pan_window_new_real(path);
2628 }
2629
2630
2631 /*
2632  *-----------------------------------------------------------------------------
2633  * menus
2634  *-----------------------------------------------------------------------------
2635  */
2636
2637 #define INFO_IMAGE_SIZE_KEY "image_size_data"
2638
2639
2640 static void pan_new_window_cb(GtkWidget *widget, gpointer data)
2641 {
2642         PanWindow *pw = data;
2643         FileData *fd;
2644
2645         fd = pan_menu_click_fd(pw);
2646         if (fd)
2647                 {
2648                 pan_fullscreen_toggle(pw, TRUE);
2649                 view_window_new(fd);
2650                 }
2651 }
2652
2653 static void pan_edit_cb(GtkWidget *widget, gpointer data)
2654 {
2655         PanWindow *pw;
2656         FileData *fd;
2657         gint n;
2658
2659         pw = submenu_item_get_data(widget);
2660         n = GPOINTER_TO_INT(data);
2661         if (!pw) return;
2662
2663         fd = pan_menu_click_fd(pw);
2664         if (fd)
2665                 {
2666                 if (!editor_window_flag_set(n))
2667                         {
2668                         pan_fullscreen_toggle(pw, TRUE);
2669                         }
2670                 start_editor_from_file(n, fd);
2671                 }
2672 }
2673
2674 static void pan_info_cb(GtkWidget *widget, gpointer data)
2675 {
2676         PanWindow *pw = data;
2677         FileData *fd;
2678
2679         fd = pan_menu_click_fd(pw);
2680         if (fd) info_window_new(fd, NULL, NULL);
2681 }
2682
2683 static void pan_zoom_in_cb(GtkWidget *widget, gpointer data)
2684 {
2685         PanWindow *pw = data;
2686
2687         image_zoom_adjust(pw->imd, ZOOM_INCREMENT);
2688 }
2689
2690 static void pan_zoom_out_cb(GtkWidget *widget, gpointer data)
2691 {
2692         PanWindow *pw = data;
2693
2694         image_zoom_adjust(pw->imd, -ZOOM_INCREMENT);
2695 }
2696
2697 static void pan_zoom_1_1_cb(GtkWidget *widget, gpointer data)
2698 {
2699         PanWindow *pw = data;
2700
2701         image_zoom_set(pw->imd, 1.0);
2702 }
2703
2704 static void pan_copy_cb(GtkWidget *widget, gpointer data)
2705 {
2706         PanWindow *pw = data;
2707         FileData *fd;
2708
2709         fd = pan_menu_click_fd(pw);
2710         if (fd) file_util_copy(fd, NULL, NULL, pw->imd->widget);
2711 }
2712
2713 static void pan_move_cb(GtkWidget *widget, gpointer data)
2714 {
2715         PanWindow *pw = data;
2716         FileData *fd;
2717
2718         fd = pan_menu_click_fd(pw);
2719         if (fd) file_util_move(fd, NULL, NULL, pw->imd->widget);
2720 }
2721
2722 static void pan_rename_cb(GtkWidget *widget, gpointer data)
2723 {
2724         PanWindow *pw = data;
2725         FileData *fd;
2726
2727         fd = pan_menu_click_fd(pw);
2728         if (fd) file_util_rename(fd, NULL, pw->imd->widget);
2729 }
2730
2731 static void pan_delete_cb(GtkWidget *widget, gpointer data)
2732 {
2733         PanWindow *pw = data;
2734         FileData *fd;
2735
2736         fd = pan_menu_click_fd(pw);
2737         if (fd) file_util_delete(fd, NULL, pw->imd->widget);
2738 }
2739
2740 static void pan_copy_path_cb(GtkWidget *widget, gpointer data)
2741 {
2742         PanWindow *pw = data;
2743         FileData *fd;
2744
2745         fd = pan_menu_click_fd(pw);
2746         if (fd) file_util_copy_path_to_clipboard(fd);
2747 }
2748
2749 static void pan_exif_date_toggle_cb(GtkWidget *widget, gpointer data)
2750 {
2751         PanWindow *pw = data;
2752
2753         pw->exif_date_enable = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget));
2754         pan_layout_update(pw);
2755 }
2756
2757 static void pan_info_toggle_exif_cb(GtkWidget *widget, gpointer data)
2758 {
2759         PanWindow *pw = data;
2760
2761         pw->info_includes_exif = gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget));
2762         /* fixme: sync info now */
2763 }
2764
2765 static void pan_info_toggle_image_cb(GtkWidget *widget, gpointer data)
2766 {
2767         PanWindow *pw = data;
2768
2769         pw->info_image_size = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), INFO_IMAGE_SIZE_KEY));
2770         /* fixme: sync info now */
2771 }
2772
2773 static void pan_fullscreen_cb(GtkWidget *widget, gpointer data)
2774 {
2775         PanWindow *pw = data;
2776
2777         pan_fullscreen_toggle(pw, FALSE);
2778 }
2779
2780 static void pan_close_cb(GtkWidget *widget, gpointer data)
2781 {
2782         PanWindow *pw = data;
2783
2784         pan_window_close(pw);
2785 }
2786
2787 static GtkWidget *pan_popup_menu(PanWindow *pw)
2788 {
2789         GtkWidget *menu;
2790         GtkWidget *submenu;
2791         GtkWidget *item;
2792         gint active;
2793
2794         active = (pw->click_pi != NULL);
2795
2796         menu = popup_menu_short_lived();
2797
2798         menu_item_add_stock(menu, _("Zoom _in"), GTK_STOCK_ZOOM_IN,
2799                             G_CALLBACK(pan_zoom_in_cb), pw);
2800         menu_item_add_stock(menu, _("Zoom _out"), GTK_STOCK_ZOOM_OUT,
2801                             G_CALLBACK(pan_zoom_out_cb), pw);
2802         menu_item_add_stock(menu, _("Zoom _1:1"), GTK_STOCK_ZOOM_100,
2803                             G_CALLBACK(pan_zoom_1_1_cb), pw);
2804         menu_item_add_divider(menu);
2805
2806         submenu_add_edit(menu, &item, G_CALLBACK(pan_edit_cb), pw);
2807         gtk_widget_set_sensitive(item, active);
2808
2809         menu_item_add_stock_sensitive(menu, _("_Properties"), GTK_STOCK_PROPERTIES, active,
2810                                       G_CALLBACK(pan_info_cb), pw);
2811
2812         menu_item_add_stock_sensitive(menu, _("View in _new window"), GTK_STOCK_NEW, active,
2813                                       G_CALLBACK(pan_new_window_cb), pw);
2814
2815         menu_item_add_divider(menu);
2816         menu_item_add_stock_sensitive(menu, _("_Copy..."), GTK_STOCK_COPY, active,
2817                                       G_CALLBACK(pan_copy_cb), pw);
2818         menu_item_add_sensitive(menu, _("_Move..."), active,
2819                                 G_CALLBACK(pan_move_cb), pw);
2820         menu_item_add_sensitive(menu, _("_Rename..."), active,
2821                                 G_CALLBACK(pan_rename_cb), pw);
2822         menu_item_add_stock_sensitive(menu, _("_Delete..."), GTK_STOCK_DELETE, active,
2823                                       G_CALLBACK(pan_delete_cb), pw);
2824         if (options->show_copy_path)
2825                 menu_item_add_sensitive(menu, _("_Copy path"), active,
2826                                         G_CALLBACK(pan_copy_path_cb), pw);
2827
2828         menu_item_add_divider(menu);
2829         item = menu_item_add_check(menu, _("Sort by E_xif date"), pw->exif_date_enable,
2830                                    G_CALLBACK(pan_exif_date_toggle_cb), pw);
2831         gtk_widget_set_sensitive(item, (pw->layout == PAN_LAYOUT_TIMELINE || pw->layout == PAN_LAYOUT_CALENDAR));
2832
2833         menu_item_add_divider(menu);
2834
2835         menu_item_add_check(menu, _("_Show Exif information"), pw->info_includes_exif,
2836                             G_CALLBACK(pan_info_toggle_exif_cb), pw);
2837         item = menu_item_add(menu, _("Show im_age"), NULL, NULL);
2838         submenu = gtk_menu_new();
2839         gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
2840
2841         item = menu_item_add_check(submenu, _("_None"), (pw->info_image_size == PAN_IMAGE_SIZE_THUMB_NONE),
2842                                    G_CALLBACK(pan_info_toggle_image_cb), pw);
2843         g_object_set_data(G_OBJECT(item), INFO_IMAGE_SIZE_KEY, GINT_TO_POINTER(PAN_IMAGE_SIZE_THUMB_NONE));
2844
2845         item = menu_item_add_check(submenu, _("_Full size"), (pw->info_image_size == PAN_IMAGE_SIZE_100),
2846                                    G_CALLBACK(pan_info_toggle_image_cb), pw);
2847         g_object_set_data(G_OBJECT(item), INFO_IMAGE_SIZE_KEY, GINT_TO_POINTER(PAN_IMAGE_SIZE_100));
2848
2849         item = menu_item_add_check(submenu, _("1:2 (50%)"), (pw->info_image_size == PAN_IMAGE_SIZE_50),
2850                                    G_CALLBACK(pan_info_toggle_image_cb), pw);
2851         g_object_set_data(G_OBJECT(item), INFO_IMAGE_SIZE_KEY, GINT_TO_POINTER(PAN_IMAGE_SIZE_50));
2852
2853         item = menu_item_add_check(submenu, _("1:3 (33%)"), (pw->info_image_size == PAN_IMAGE_SIZE_33),
2854                                    G_CALLBACK(pan_info_toggle_image_cb), pw);
2855         g_object_set_data(G_OBJECT(item), INFO_IMAGE_SIZE_KEY, GINT_TO_POINTER(PAN_IMAGE_SIZE_33));
2856
2857         item = menu_item_add_check(submenu, _("1:4 (25%)"), (pw->info_image_size == PAN_IMAGE_SIZE_25),
2858                                    G_CALLBACK(pan_info_toggle_image_cb), pw);
2859         g_object_set_data(G_OBJECT(item), INFO_IMAGE_SIZE_KEY, GINT_TO_POINTER(PAN_IMAGE_SIZE_25));
2860
2861         item = menu_item_add_check(submenu, _("1:10 (10%)"), (pw->info_image_size == PAN_IMAGE_SIZE_10),
2862                                    G_CALLBACK(pan_info_toggle_image_cb), pw);
2863         g_object_set_data(G_OBJECT(item), INFO_IMAGE_SIZE_KEY, GINT_TO_POINTER(PAN_IMAGE_SIZE_10));
2864
2865
2866
2867         menu_item_add_divider(menu);
2868
2869         if (pw->fs)
2870                 {
2871                 menu_item_add(menu, _("Exit _full screen"), G_CALLBACK(pan_fullscreen_cb), pw);
2872                 }
2873         else
2874                 {
2875                 menu_item_add(menu, _("_Full screen"), G_CALLBACK(pan_fullscreen_cb), pw);
2876                 }
2877
2878         menu_item_add_divider(menu);
2879         menu_item_add_stock(menu, _("C_lose window"), GTK_STOCK_CLOSE, G_CALLBACK(pan_close_cb), pw);
2880
2881         return menu;
2882 }
2883
2884
2885 /*
2886  *-----------------------------------------------------------------------------
2887  * drag and drop
2888  *-----------------------------------------------------------------------------
2889  */
2890
2891 static void pan_window_get_dnd_data(GtkWidget *widget, GdkDragContext *context,
2892                                     gint x, gint y,
2893                                     GtkSelectionData *selection_data, guint info,
2894                                     guint time, gpointer data)
2895 {
2896         PanWindow *pw = data;
2897
2898         if (gtk_drag_get_source_widget(context) == pw->imd->pr) return;
2899
2900         if (info == TARGET_URI_LIST)
2901                 {
2902                 GList *list;
2903
2904                 list = uri_filelist_from_text((gchar *)selection_data->data, TRUE);
2905                 if (list && isdir(((FileData *)list->data)->path))
2906                         {
2907                         FileData *fd = list->data;
2908
2909                         pan_layout_set_path(pw, fd->path);
2910                         }
2911
2912                 filelist_free(list);
2913                 }
2914 }
2915
2916 static void pan_window_set_dnd_data(GtkWidget *widget, GdkDragContext *context,
2917                                     GtkSelectionData *selection_data, guint info,
2918                                     guint time, gpointer data)
2919 {
2920         PanWindow *pw = data;
2921         FileData *fd;
2922
2923         fd = pan_menu_click_fd(pw);
2924         if (fd)
2925                 {
2926                 gchar *text = NULL;
2927                 gint len;
2928                 gint plain_text;
2929                 GList *list;
2930
2931                 switch (info)
2932                         {
2933                         case TARGET_URI_LIST:
2934                                 plain_text = FALSE;
2935                                 break;
2936                         case TARGET_TEXT_PLAIN:
2937                         default:
2938                                 plain_text = TRUE;
2939                                 break;
2940                         }
2941                 list = g_list_append(NULL, fd);
2942                 text = uri_text_from_filelist(list, &len, plain_text);
2943                 g_list_free(list);
2944                 if (text)
2945                         {
2946                         gtk_selection_data_set (selection_data, selection_data->target,
2947                                                 8, (guchar *)text, len);
2948                         g_free(text);
2949                         }
2950                 }
2951         else
2952                 {
2953                 gtk_selection_data_set (selection_data, selection_data->target,
2954                                         8, NULL, 0);
2955                 }
2956 }
2957
2958 static void pan_window_dnd_init(PanWindow *pw)
2959 {
2960         GtkWidget *widget;
2961
2962         widget = pw->imd->pr;
2963
2964         gtk_drag_source_set(widget, GDK_BUTTON2_MASK,
2965                             dnd_file_drag_types, dnd_file_drag_types_count,
2966                             GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
2967         g_signal_connect(G_OBJECT(widget), "drag_data_get",
2968                          G_CALLBACK(pan_window_set_dnd_data), pw);
2969
2970         gtk_drag_dest_set(widget,
2971                           GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP,
2972                           dnd_file_drop_types, dnd_file_drop_types_count,
2973                           GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
2974         g_signal_connect(G_OBJECT(widget), "drag_data_received",
2975                          G_CALLBACK(pan_window_get_dnd_data), pw);
2976 }
2977
2978 /*
2979  *-----------------------------------------------------------------------------
2980  * maintenance (for rename, move, remove)
2981  *-----------------------------------------------------------------------------
2982  */