src/layout.c

   1 /*
   2  * GQview
   3  * (C) 2006 John Ellis
   4  *
   5  * Author: John Ellis
   6  *
   7  * This software is released under the GNU General Public License (GNU GPL).
   8  * Please read the included file COPYING for more information.
   9  * This software comes with no warranty of any kind, use at your own risk!
  10  */
  11
  12 #include "gqview.h"
  13 #include "layout.h"
  14
  15 #include "image.h"
  16 #include "layout_config.h"
  17 #include "layout_image.h"
  18 #include "layout_util.h"
  19 #include "menu.h"
  20 #include "pixbuf-renderer.h"
  21 #include "pixbuf_util.h"
  22 #include "utilops.h"
  23 #include "view_dir_list.h"
  24 #include "view_dir_tree.h"
  25 #include "view_file_list.h"
  26 #include "view_file_icon.h"
  27 #include "ui_bookmark.h"
  28 #include "ui_fileops.h"
  29 #include "ui_menu.h"
  30 #include "ui_misc.h"
  31 #include "ui_tabcomp.h"
  32
  33
  34 #define MAINWINDOW_DEF_WIDTH 700
  35 #define MAINWINDOW_DEF_HEIGHT 500
  36
  37 #define MAIN_WINDOW_DIV_HPOS 270
  38 #define MAIN_WINDOW_DIV_VPOS 200
  39
  40 #define TOOLWINDOW_DEF_WIDTH 260
  41 #define TOOLWINDOW_DEF_HEIGHT 450
  42 #define PROGRESS_WIDTH 150
  43 #define ZOOM_LABEL_WIDTH 64
  44
  45 #define PANE_DIVIDER_SIZE 10
  46
  47
  48 GList *layout_window_list = NULL;
  49
  50
  51 static void layout_list_scroll_to_subpart(LayoutWindow *lw, const gchar *needle);
  52
  53
  54 /*
  55  *-----------------------------------------------------------------------------
  56  * misc
  57  *-----------------------------------------------------------------------------
  58  */
  59
  60 gint layout_valid(LayoutWindow **lw)
  61 {
  62         if (*lw == NULL)
  63                 {
  64                 if (layout_window_list) *lw = layout_window_list->data;
  65                 return (*lw != NULL);
  66                 }
  67
  68         return (g_list_find(layout_window_list, *lw) != NULL);
  69 }
  70
  71 LayoutWindow *layout_find_by_image(ImageWindow *imd)
  72 {
  73         GList *work;
  74
  75         work = layout_window_list;
  76         while (work)
  77                 {
  78                 LayoutWindow *lw = work->data;
  79                 work = work->next;
  80
  81                 if (lw->image == imd) return lw;
  82                 }
  83
  84         return NULL;
  85 }
  86
  87 /*
  88  *-----------------------------------------------------------------------------
  89  * menu, toolbar, and dir view
  90  *-----------------------------------------------------------------------------
  91  */
  92
  93 static void layout_path_entry_changed_cb(GtkWidget *widget, gpointer data)
  94 {
  95         LayoutWindow *lw = data;
  96         gchar *buf;
  97
  98         if (gtk_combo_box_get_active(GTK_COMBO_BOX(widget)) < 0) return;
  99
 100         buf = g_strdup(gtk_entry_get_text(GTK_ENTRY(lw->path_entry)));
 101         if (!buf || (lw->path && strcmp(buf, lw->path) == 0))
 102                 {
 103                 g_free(buf);
 104                 return;
 105                 }
 106
 107         layout_set_path(lw, buf);
 108
 109         g_free(buf);
 110 }
 111
 112 static void layout_path_entry_tab_cb(const gchar *path, gpointer data)
 113 {
 114         LayoutWindow *lw = data;
 115         gchar *buf;
 116         gchar *base;
 117
 118         buf = g_strdup(path);
 119         parse_out_relatives(buf);
 120         base = remove_level_from_path(buf);
 121
 122         if (isdir(buf))
 123                 {
 124                 if ((!lw->path || strcmp(lw->path, buf) != 0) && layout_set_path(lw, buf))
 125                         {
 126                         gint pos = -1;
 127                         /* put the '/' back, if we are in tab completion for a dir and result was path change */
 128                         gtk_editable_insert_text(GTK_EDITABLE(lw->path_entry), "/", -1, &pos);
 129                         gtk_editable_set_position(GTK_EDITABLE(lw->path_entry),
 130                                                   strlen(gtk_entry_get_text(GTK_ENTRY(lw->path_entry))));
 131                         }
 132                 }
 133         else if (lw->path && strcmp(lw->path, base) == 0)
 134                 {
 135                 layout_list_scroll_to_subpart(lw, filename_from_path(buf));
 136                 }
 137
 138         g_free(base);
 139         g_free(buf);
 140 }
 141
 142 static void layout_path_entry_cb(const gchar *path, gpointer data)
 143 {
 144         LayoutWindow *lw = data;
 145         gchar *buf;
 146
 147         buf = g_strdup(path);
 148         parse_out_relatives(buf);
 149
 150         layout_set_path(lw, buf);
 151
 152         g_free(buf);
 153 }
 154
 155 static void layout_vdlist_select_cb(ViewDirList *vdl, const gchar *path, gpointer data)
 156 {
 157         LayoutWindow *lw = data;
 158
 159         layout_set_path(lw, path);
 160 }
 161
 162 static void layout_vdtree_select_cb(ViewDirTree *vdt, const gchar *path, gpointer data)
 163 {
 164         LayoutWindow *lw = data;
 165
 166         layout_set_path(lw, path);
 167 }
 168
 169 static GtkWidget *layout_tool_setup(LayoutWindow *lw)
 170 {
 171         GtkWidget *box;
 172         GtkWidget *menu_bar;
 173         GtkWidget *tabcomp;
 174
 175         box = gtk_vbox_new(FALSE, 0);
 176
 177         menu_bar = layout_actions_menu_bar(lw);
 178         gtk_box_pack_start(GTK_BOX(box), menu_bar, FALSE, FALSE, 0);
 179         gtk_widget_show(menu_bar);
 180
 181         lw->toolbar = layout_button_bar(lw);
 182         gtk_box_pack_start(GTK_BOX(box), lw->toolbar, FALSE, FALSE, 0);
 183         if (!lw->toolbar_hidden) gtk_widget_show(lw->toolbar);
 184
 185         tabcomp = tab_completion_new_with_history(&lw->path_entry, NULL, "path_list", -1,
 186                                                   layout_path_entry_cb, lw);
 187         tab_completion_add_tab_func(lw->path_entry, layout_path_entry_tab_cb, lw);
 188         gtk_box_pack_start(GTK_BOX(box), tabcomp, FALSE, FALSE, 0);
 189         gtk_widget_show(tabcomp);
 190
 191         g_signal_connect(G_OBJECT(lw->path_entry->parent), "changed",
 192                          G_CALLBACK(layout_path_entry_changed_cb), lw);
 193
 194         if (lw->tree_view)
 195                 {
 196                 lw->vdt = vdtree_new(lw->path, TRUE);
 197                 vdtree_set_layout(lw->vdt, lw);
 198                 vdtree_set_select_func(lw->vdt, layout_vdtree_select_cb, lw);
 199
 200                 lw->dir_view = lw->vdt->widget;
 201                 }
 202         else
 203                 {
 204                 lw->vdl = vdlist_new(lw->path);
 205                 vdlist_set_layout(lw->vdl, lw);
 206                 vdlist_set_select_func(lw->vdl, layout_vdlist_select_cb, lw);
 207
 208                 lw->dir_view = lw->vdl->widget;
 209                 }
 210
 211         gtk_box_pack_start(GTK_BOX(box), lw->dir_view, TRUE, TRUE, 0);
 212         gtk_widget_show(lw->dir_view);
 213
 214         gtk_widget_show(box);
 215
 216         return box;
 217 }
 218
 219 /*
 220  *-----------------------------------------------------------------------------
 221  * sort button (and menu)
 222  *-----------------------------------------------------------------------------
 223  */
 224
 225 static void layout_sort_menu_cb(GtkWidget *widget, gpointer data)
 226 {
 227         LayoutWindow *lw;
 228         SortType type;
 229
 230         if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))) return;
 231
 232         lw = submenu_item_get_data(widget);
 233         if (!lw) return;
 234
 235         type = (SortType)GPOINTER_TO_INT(data);
 236
 237         layout_sort_set(lw, type, lw->sort_ascend);
 238 }
 239
 240 static void layout_sort_menu_ascend_cb(GtkWidget *widget, gpointer data)
 241 {
 242         LayoutWindow *lw = data;
 243
 244         layout_sort_set(lw, lw->sort_method, !lw->sort_ascend);
 245 }
 246
 247 static void layout_sort_menu_hide_cb(GtkWidget *widget, gpointer data)
 248 {
 249         /* destroy the menu */
 250         gtk_widget_unref(GTK_WIDGET(widget));
 251 }
 252
 253 static void layout_sort_button_press_cb(GtkWidget *widget, gpointer data)
 254 {
 255         LayoutWindow *lw = data;
 256         GtkWidget *menu;
 257         GdkEvent *event;
 258         guint32 etime;
 259
 260         menu = submenu_add_sort(NULL, G_CALLBACK(layout_sort_menu_cb), lw, FALSE, FALSE, TRUE, lw->sort_method);
 261
 262         /* take ownership of menu */
 263 #ifdef GTK_OBJECT_FLOATING
 264         /* GTK+ < 2.10 */
 265         g_object_ref(G_OBJECT(menu));
 266         gtk_object_sink(GTK_OBJECT(menu));
 267 #else
 268         /* GTK+ >= 2.10 */
 269         g_object_ref_sink(G_OBJECT(menu));
 270 #endif
 271
 272         /* ascending option */
 273         menu_item_add_divider(menu);
 274         menu_item_add_check(menu, _("Ascending"), lw->sort_ascend, G_CALLBACK(layout_sort_menu_ascend_cb), lw);
 275
 276         g_signal_connect(G_OBJECT(menu), "selection_done",
 277                          G_CALLBACK(layout_sort_menu_hide_cb), NULL);
 278
 279         event = gtk_get_current_event();
 280         if (event)
 281                 {
 282                 etime = gdk_event_get_time(event);
 283                 gdk_event_free(event);
 284                 }
 285         else
 286                 {
 287                 etime = 0;
 288                 }
 289
 290         gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 0, etime);
 291 }
 292
 293 static GtkWidget *layout_sort_button(LayoutWindow *lw)
 294 {
 295         GtkWidget *button;
 296
 297         button = gtk_button_new_with_label(sort_type_get_text(lw->sort_method));
 298         g_signal_connect(G_OBJECT(button), "clicked",
 299                          G_CALLBACK(layout_sort_button_press_cb), lw);
 300         gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
 301
 302         return button;
 303 }
 304
 305 /*
 306  *-----------------------------------------------------------------------------
 307  * color profile button (and menu)
 308  *-----------------------------------------------------------------------------
 309  */
 310
 311 static void layout_color_menu_enable_cb(GtkWidget *widget, gpointer data)
 312 {
 313         LayoutWindow *lw = data;
 314
 315         layout_image_color_profile_set_use(lw, (!layout_image_color_profile_get_use(lw)));
 316         layout_image_refresh(lw);
 317 }
 318
 319 static void layout_color_menu_use_image_cb(GtkWidget *widget, gpointer data)
 320 {
 321         LayoutWindow *lw = data;
 322         gint input, screen, use_image;
 323
 324         if (!layout_image_color_profile_get(lw, &input, &screen, &use_image)) return;
 325         layout_image_color_profile_set(lw, input, screen, !use_image);
 326         layout_image_refresh(lw);
 327 }
 328
 329 #define COLOR_MENU_KEY "color_menu_key"
 330
 331 static void layout_color_menu_input_cb(GtkWidget *widget, gpointer data)
 332 {
 333         LayoutWindow *lw = data;
 334         gint type;
 335         gint input, screen, use_image;
 336
 337         if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))) return;
 338
 339         type = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), COLOR_MENU_KEY));
 340         if (type < 0 || type > COLOR_PROFILE_INPUTS) return;
 341
 342         if (!layout_image_color_profile_get(lw, &input, &screen, &use_image)) return;
 343         if (type == input) return;
 344
 345         layout_image_color_profile_set(lw, type, screen, use_image);
 346         layout_image_refresh(lw);
 347 }
 348
 349 static void layout_color_menu_screen_cb(GtkWidget *widget, gpointer data)
 350 {
 351         LayoutWindow *lw = data;
 352         gint type;
 353         gint input, screen, use_image;
 354
 355         if (!gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget))) return;
 356
 357         type = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(widget), COLOR_MENU_KEY));
 358         if (type < 0 || type > 1) return;
 359
 360         if (!layout_image_color_profile_get(lw, &input, &screen, &use_image)) return;
 361         if (type == screen) return;
 362
 363         layout_image_color_profile_set(lw, input, type, use_image);
 364         layout_image_refresh(lw);
 365 }
 366
 367 static gchar *layout_color_name_parse(const gchar *name)
 368 {
 369         gchar *result;
 370         gchar *p;
 371
 372         if (!name) name = _("Empty");
 373
 374         result = g_strdup(name);
 375         p = result;
 376         while (*p != '\0')
 377                 {
 378                 if (*p == '_') *p = '-';
 379                 p++;
 380                 }
 381         return result;
 382 }
 383
 384 static void layout_color_button_press_cb(GtkWidget *widget, gpointer data)
 385 {
 386         LayoutWindow *lw = data;
 387         GtkWidget *menu;
 388         GtkWidget *item;
 389         gchar *buf;
 390         gchar *front;
 391         gchar *end;
 392         gint active;
 393         gint input = 0;
 394         gint screen = 0;
 395         gint use_image = 0;
 396         gint i;
 397
 398 #ifndef HAVE_LCMS
 399         file_util_warning_dialog(_("Color profiles not supported"),
 400                                  _("This installation of GQview was not built with support for color profiles."),
 401                                  GTK_STOCK_DIALOG_INFO, widget);
 402         return;
 403 #endif
 404
 405         active = layout_image_color_profile_get_use(lw);
 406         if (!layout_image_color_profile_get(lw, &input, &screen, &use_image)) return;
 407
 408         menu = popup_menu_short_lived();
 409
 410         menu_item_add_check(menu, _("Use _color profiles"), active,
 411                             G_CALLBACK(layout_color_menu_enable_cb), lw);
 412
 413         menu_item_add_divider(menu);
 414
 415         item = menu_item_add_check(menu, _("Use profile from _image"), use_image,
 416                             G_CALLBACK(layout_color_menu_use_image_cb), lw);
 417         gtk_widget_set_sensitive(item, active);
 418
 419         front = g_strdup_printf(_("Input _%d:"), 0);
 420         buf = g_strdup_printf("%s %s", front, "sRGB");
 421         g_free(front);
 422         item = menu_item_add_radio(menu, NULL,
 423                                    buf, (color_profile_input_type == 0),
 424                                    G_CALLBACK(layout_color_menu_input_cb), lw);
 425         g_free(buf);
 426         g_object_set_data(G_OBJECT(item), COLOR_MENU_KEY, GINT_TO_POINTER(0));
 427         gtk_widget_set_sensitive(item, active);
 428
 429         for (i = 0; i < COLOR_PROFILE_INPUTS; i++)
 430                 {
 431                 const gchar *name;
 432
 433                 name = color_profile_input_name[i];
 434                 if (!name) name = filename_from_path(color_profile_input_file[i]);
 435
 436                 front = g_strdup_printf(_("Input _%d:"), i + 1);
 437                 end = layout_color_name_parse(name);
 438                 buf = g_strdup_printf("%s %s", front, end);
 439                 g_free(front);
 440                 g_free(end);
 441
 442                 item = menu_item_add_radio(menu, item,
 443                                            buf, (i + 1 == input),
 444                                            G_CALLBACK(layout_color_menu_input_cb), lw);
 445                 g_free(buf);
 446                 g_object_set_data(G_OBJECT(item), COLOR_MENU_KEY, GINT_TO_POINTER(i + 1));
 447                 gtk_widget_set_sensitive(item, active && color_profile_input_file[i]);
 448                 }
 449
 450         menu_item_add_divider(menu);
 451
 452         buf = g_strdup_printf("%s sRGB", _("Screen"));
 453         item = menu_item_add_radio(menu, NULL,
 454                                    buf, (screen == 0),
 455                                    G_CALLBACK(layout_color_menu_screen_cb), lw);
 456         g_free(buf);
 457         g_object_set_data(G_OBJECT(item), COLOR_MENU_KEY, GINT_TO_POINTER(0));
 458         gtk_widget_set_sensitive(item, active);
 459
 460         item = menu_item_add_radio(menu, item,
 461                                    _("_Screen profile"), (screen == 1),
 462                                    G_CALLBACK(layout_color_menu_screen_cb), lw);
 463         g_object_set_data(G_OBJECT(item), COLOR_MENU_KEY, GINT_TO_POINTER(1));
 464         gtk_widget_set_sensitive(item, active && color_profile_screen_file);
 465
 466         gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 0, GDK_CURRENT_TIME);
 467 }
 468
 469 static GtkWidget *layout_color_button(LayoutWindow *lw)
 470 {
 471         GtkWidget *button;
 472         GtkWidget *image;
 473         gint enable;
 474
 475         button = gtk_button_new();
 476         image = gtk_image_new_from_stock(GTK_STOCK_SELECT_COLOR, GTK_ICON_SIZE_MENU);
 477         gtk_container_add(GTK_CONTAINER(button), image);
 478         gtk_widget_show(image);
 479         g_signal_connect(G_OBJECT(button), "clicked",
 480                          G_CALLBACK(layout_color_button_press_cb), lw);
 481         gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
 482
 483         enable = (lw->image) ? lw->image->color_profile_enable : FALSE;
 484 #ifndef HAVE_LCMS
 485         enable = FALSE;
 486 #endif
 487         gtk_widget_set_sensitive(image, enable);
 488
 489         return button;
 490 }
 491
 492
 493 /*
 494  *-----------------------------------------------------------------------------
 495  * status bar
 496  *-----------------------------------------------------------------------------
 497  */
 498
 499 void layout_status_update_progress(LayoutWindow *lw, gdouble val, const gchar *text)
 500 {
 501         if (!layout_valid(&lw)) return;
 502         if (!lw->info_progress_bar) return;
 503
 504         gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(lw->info_progress_bar), val);
 505         gtk_progress_bar_set_text(GTK_PROGRESS_BAR(lw->info_progress_bar), (text) ? text : " ");
 506 }
 507
 508 void layout_status_update_info(LayoutWindow *lw, const gchar *text)
 509 {
 510         gchar *buf = NULL;
 511
 512         if (!layout_valid(&lw)) return;
 513
 514         if (!text)
 515                 {
 516                 gint n;
 517                 gint64 n_bytes = 0;
 518                 gint s;
 519                 gint64 s_bytes = 0;
 520                 const gchar *ss;
 521                 gchar *b;
 522                 gchar *sb;
 523
 524                 if (layout_image_slideshow_active(lw))
 525                         {
 526                         if (!layout_image_slideshow_paused(lw))
 527                                 {
 528                                 ss = _(" Slideshow");
 529                                 }
 530                         else
 531                                 {
 532                                 ss = _(" Paused");
 533                                 }
 534                         }
 535                 else
 536                         {
 537                         ss = "";
 538                         }
 539
 540                 n = layout_list_count(lw, &n_bytes);
 541                 s = layout_selection_count(lw, &s_bytes);
 542
 543                 layout_bars_new_selection(lw, s);
 544
 545                 if (s > 0)
 546                         {
 547                         b = text_from_size_abrev(n_bytes);
 548                         sb = text_from_size_abrev(s_bytes);
 549                         buf = g_strdup_printf(_("%s, %d files (%s, %d)%s"), b, n, sb, s, ss);
 550                         g_free(b);
 551                         g_free(sb);
 552                         }
 553                 else if (n > 0)
 554                         {
 555                         b = text_from_size_abrev(n_bytes);
 556                         buf = g_strdup_printf(_("%s, %d files%s"), b, n, ss);
 557                         g_free(b);
 558                         }
 559                 else
 560                         {
 561                         buf = g_strdup_printf(_("%d files%s"), n, ss);
 562                         }
 563
 564                 text = buf;
 565
 566                 layout_image_overlay_update(lw);
 567                 }
 568
 569         gtk_label_set_text(GTK_LABEL(lw->info_status), text);
 570         g_free(buf);
 571 }
 572
 573 void layout_status_update_image(LayoutWindow *lw)
 574 {
 575         gchar *text;
 576         gchar *b;
 577
 578         if (!layout_valid(&lw) || !lw->image) return;
 579
 580         text = image_zoom_get_as_text(lw->image);
 581         gtk_label_set_text(GTK_LABEL(lw->info_zoom), text);
 582         g_free(text);
 583
 584         b = text_from_size(lw->image->size);
 585
 586         if (lw->image->unknown)
 587                 {
 588                 if (image_get_path(lw->image) && !access_file(image_get_path(lw->image), R_OK))
 589                         {
 590                         text = g_strdup_printf(_("(no read permission) %s bytes"), b);
 591                         }
 592                 else
 593                         {
 594                         text = g_strdup_printf(_("( ? x ? ) %s bytes"), b);
 595                         }
 596                 }
 597         else
 598                 {
 599                 gint width, height;
 600
 601                 pixbuf_renderer_get_image_size(PIXBUF_RENDERER(lw->image->pr), &width, &height);
 602                 text = g_strdup_printf(_("( %d x %d ) %s bytes"),
 603                                        width, height, b);
 604                 }
 605
 606         gtk_label_set_text(GTK_LABEL(lw->info_details), text);
 607
 608         g_free(b);
 609         g_free(text);
 610 }
 611
 612 void layout_status_update_all(LayoutWindow *lw)
 613 {
 614         layout_status_update_progress(lw, 0.0, NULL);
 615         layout_status_update_info(lw, NULL);
 616         layout_status_update_image(lw);
 617 }
 618
 619 static GtkWidget *layout_status_label(gchar *text, GtkWidget *box, gint start, gint size, gint expand)
 620 {
 621         GtkWidget *label;
 622         GtkWidget *frame;
 623
 624         frame = gtk_frame_new(NULL);
 625         if (size) gtk_widget_set_size_request(frame, size, -1);
 626         gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
 627         if (start)
 628                 {
 629                 gtk_box_pack_start(GTK_BOX(box), frame, expand, expand, 0);
 630                 }
 631         else
 632                 {
 633                 gtk_box_pack_end(GTK_BOX(box), frame, expand, expand, 0);
 634                 }
 635         gtk_widget_show(frame);
 636
 637         label = gtk_label_new(text ? text : "");
 638         gtk_container_add(GTK_CONTAINER(frame), label);
 639         gtk_widget_show(label);
 640
 641         return label;
 642 }
 643
 644 static void layout_status_setup(LayoutWindow *lw, GtkWidget *box, gint small_format)
 645 {
 646         GtkWidget *hbox;
 647
 648         if (lw->info_box) return;
 649
 650         if (small_format)
 651                 {
 652                 lw->info_box = gtk_vbox_new(FALSE, 0);
 653                 }
 654         else
 655                 {
 656                 lw->info_box = gtk_hbox_new(FALSE, 0);
 657                 }
 658         gtk_box_pack_end(GTK_BOX(box), lw->info_box, FALSE, FALSE, 0);
 659         gtk_widget_show(lw->info_box);
 660
 661         if (small_format)
 662                 {
 663                 hbox = gtk_hbox_new(FALSE, 0);
 664                 gtk_box_pack_start(GTK_BOX(lw->info_box), hbox, FALSE, FALSE, 0);
 665                 gtk_widget_show(hbox);
 666                 }
 667         else
 668                 {
 669                 hbox = lw->info_box;
 670                 }
 671         lw->info_progress_bar = gtk_progress_bar_new();
 672         gtk_widget_set_size_request(lw->info_progress_bar, PROGRESS_WIDTH, -1);
 673         gtk_box_pack_start(GTK_BOX(hbox), lw->info_progress_bar, FALSE, FALSE, 0);
 674         gtk_widget_show(lw->info_progress_bar);
 675
 676         lw->info_sort = layout_sort_button(lw);
 677         gtk_box_pack_start(GTK_BOX(hbox), lw->info_sort, FALSE, FALSE, 0);
 678         gtk_widget_show(lw->info_sort);
 679
 680         lw->info_color = layout_color_button(lw);
 681         gtk_widget_show(lw->info_color);
 682
 683         if (small_format) gtk_box_pack_end(GTK_BOX(hbox), lw->info_color, FALSE, FALSE, 0);
 684
 685         lw->info_status = layout_status_label(NULL, lw->info_box, TRUE, 0, (!small_format));
 686
 687         if (small_format)
 688                 {
 689                 hbox = gtk_hbox_new(FALSE, 0);
 690                 gtk_box_pack_start(GTK_BOX(lw->info_box), hbox, FALSE, FALSE, 0);
 691                 gtk_widget_show(hbox);
 692                 }
 693         else
 694                 {
 695                 hbox = lw->info_box;
 696                 }
 697         lw->info_details = layout_status_label(NULL, hbox, TRUE, 0, TRUE);
 698         if (!small_format) gtk_box_pack_start(GTK_BOX(hbox), lw->info_color, FALSE, FALSE, 0);
 699         lw->info_zoom = layout_status_label(NULL, hbox, FALSE, ZOOM_LABEL_WIDTH, FALSE);
 700 }
 701
 702 /*
 703  *-----------------------------------------------------------------------------
 704  * views
 705  *-----------------------------------------------------------------------------
 706  */
 707
 708 static GtkWidget *layout_tools_new(LayoutWindow *lw)
 709 {
 710         lw->dir_view = layout_tool_setup(lw);
 711         return lw->dir_view;
 712 }
 713
 714 static void layout_list_status_cb(ViewFileList *vfl, gpointer data)
 715 {
 716         LayoutWindow *lw = data;
 717
 718         layout_status_update_info(lw, NULL);
 719 }
 720
 721 static void layout_list_thumb_cb(ViewFileList *vfl, gdouble val, const gchar *text, gpointer data)
 722 {
 723         LayoutWindow *lw = data;
 724
 725         layout_status_update_progress(lw, val, text);
 726 }
 727
 728 static void layout_icon_status_cb(ViewFileIcon *vfi, gpointer data)
 729 {
 730         LayoutWindow *lw = data;
 731
 732         layout_status_update_info(lw, NULL);
 733 }
 734
 735 static void layout_icon_thumb_cb(ViewFileIcon *vfi, gdouble val, const gchar *text, gpointer data)
 736 {
 737         LayoutWindow *lw = data;
 738
 739         layout_status_update_progress(lw, val, text);
 740 }
 741
 742 static GtkWidget *layout_list_new(LayoutWindow *lw)
 743 {
 744         if (lw->icon_view)
 745                 {
 746                 lw->vfi = vficon_new(NULL);
 747                 vficon_set_layout(lw->vfi, lw);
 748
 749                 vficon_set_status_func(lw->vfi, layout_icon_status_cb, lw);
 750                 vficon_set_thumb_status_func(lw->vfi, layout_icon_thumb_cb, lw);
 751
 752                 return lw->vfi->widget;
 753                 }
 754
 755         lw->vfl = vflist_new(NULL, lw->thumbs_enabled);
 756         vflist_set_layout(lw->vfl, lw);
 757
 758         vflist_set_status_func(lw->vfl, layout_list_status_cb, lw);
 759         vflist_set_thumb_status_func(lw->vfl, layout_list_thumb_cb, lw);
 760
 761         return lw->vfl->widget;
 762 }
 763
 764 static void layout_list_sync_thumb(LayoutWindow *lw)
 765 {
 766         if (lw->vfl) vflist_thumb_set(lw->vfl, lw->thumbs_enabled);
 767 }
 768
 769 static void layout_list_sync_marks(LayoutWindow *lw)
 770 {
 771         if (lw->vfl) vflist_marks_set(lw->vfl, lw->marks_enabled);
 772 }
 773
 774 static void layout_list_scroll_to_subpart(LayoutWindow *lw, const gchar *needle)
 775 {
 776         if (!lw) return;
 777 #if 0
 778         if (lw->vfl) vflist_scroll_to_subpart(lw->vfl, needle);
 779         if (lw->vfi) vficon_scroll_to_subpart(lw->vfi, needle);
 780 #endif
 781 }
 782
 783 GList *layout_list(LayoutWindow *lw)
 784 {
 785         if (!layout_valid(&lw)) return NULL;
 786
 787         if (lw->vfl) return vflist_get_list(lw->vfl);
 788         if (lw->vfi) return vficon_get_list(lw->vfi);
 789
 790         return NULL;
 791 }
 792
 793 gint layout_list_count(LayoutWindow *lw, gint64 *bytes)
 794 {
 795         if (!layout_valid(&lw)) return 0;
 796
 797         if (lw->vfl) return vflist_count(lw->vfl, bytes);
 798         if (lw->vfi) return vficon_count(lw->vfi, bytes);
 799
 800         return 0;
 801 }
 802
 803 const gchar *layout_list_get_path(LayoutWindow *lw, gint index)
 804 {
 805         if (!layout_valid(&lw)) return NULL;
 806
 807         if (lw->vfl) return vflist_index_get_path(lw->vfl, index);
 808         if (lw->vfi) return vficon_index_get_path(lw->vfi, index);
 809
 810         return NULL;
 811 }
 812
 813 gint layout_list_get_index(LayoutWindow *lw, const gchar *path)
 814 {
 815         if (!layout_valid(&lw)) return -1;
 816
 817         if (lw->vfl) return vflist_index_by_path(lw->vfl, path);
 818         if (lw->vfi) return vficon_index_by_path(lw->vfi, path);
 819
 820         return -1;
 821 }
 822
 823 void layout_list_sync_path(LayoutWindow *lw, const gchar *path)
 824 {
 825         if (!layout_valid(&lw)) return;
 826
 827         if (lw->vfl) vflist_select_by_path(lw->vfl, path);
 828         if (lw->vfi) vficon_select_by_path(lw->vfi, path);
 829 }
 830
 831 static void layout_list_sync_sort(LayoutWindow *lw)
 832 {
 833         if (!layout_valid(&lw)) return;
 834
 835         if (lw->vfl) vflist_sort_set(lw->vfl, lw->sort_method, lw->sort_ascend);
 836         if (lw->vfi) vficon_sort_set(lw->vfi, lw->sort_method, lw->sort_ascend);
 837 }
 838
 839 GList *layout_selection_list(LayoutWindow *lw)
 840 {
 841         if (!layout_valid(&lw)) return NULL;
 842
 843         if (layout_image_get_collection(lw, NULL))
 844                 {
 845                 const gchar *path;
 846
 847                 path = layout_image_get_path(lw);
 848                 if (path) return g_list_append(NULL, g_strdup(path));
 849                 return NULL;
 850                 }
 851
 852         if (lw->vfl) return vflist_selection_get_list(lw->vfl);
 853         if (lw->vfi) return vficon_selection_get_list(lw->vfi);
 854
 855         return NULL;
 856 }
 857
 858 GList *layout_selection_list_by_index(LayoutWindow *lw)
 859 {
 860         if (!layout_valid(&lw)) return NULL;
 861
 862         if (lw->vfl) return vflist_selection_get_list_by_index(lw->vfl);
 863         if (lw->vfi) return vficon_selection_get_list_by_index(lw->vfi);
 864
 865         return NULL;
 866 }
 867
 868 gint layout_selection_count(LayoutWindow *lw, gint64 *bytes)
 869 {
 870         if (!layout_valid(&lw)) return 0;
 871
 872         if (lw->vfl) return vflist_selection_count(lw->vfl, bytes);
 873         if (lw->vfi) return vficon_selection_count(lw->vfi, bytes);
 874
 875         return 0;
 876 }
 877
 878 void layout_select_all(LayoutWindow *lw)
 879 {
 880         if (!layout_valid(&lw)) return;
 881
 882         if (lw->vfl) vflist_select_all(lw->vfl);
 883         if (lw->vfi) vficon_select_all(lw->vfi);
 884 }
 885
 886 void layout_select_none(LayoutWindow *lw)
 887 {
 888         if (!layout_valid(&lw)) return;
 889
 890         if (lw->vfl) vflist_select_none(lw->vfl);
 891         if (lw->vfi) vficon_select_none(lw->vfi);
 892 }
 893
 894 /*
 895  *-----------------------------------------------------------------------------
 896  * access
 897  *-----------------------------------------------------------------------------
 898  */
 899
 900 const gchar *layout_get_path(LayoutWindow *lw)
 901 {
 902         if (!layout_valid(&lw)) return NULL;
 903         return lw->path;
 904 }
 905
 906 static void layout_sync_path(LayoutWindow *lw)
 907 {
 908         if (!lw->path) return;
 909
 910         lw->last_time = filetime(lw->path);
 911
 912         gtk_entry_set_text(GTK_ENTRY(lw->path_entry), lw->path);
 913         if (lw->vdl) vdlist_set_path(lw->vdl, lw->path);
 914         if (lw->vdt) vdtree_set_path(lw->vdt, lw->path);
 915
 916         if (lw->vfl) vflist_set_path(lw->vfl, lw->path);
 917         if (lw->vfi) vficon_set_path(lw->vfi, lw->path);
 918 }
 919
 920 gint layout_set_path(LayoutWindow *lw, const gchar *path)
 921 {
 922         gint have_file = FALSE;
 923
 924         if (!layout_valid(&lw)) return FALSE;
 925
 926         if (!path || !isname(path)) return FALSE;
 927         if (lw->path && path && strcmp(path, lw->path) == 0)
 928                 {
 929                 return TRUE;
 930                 }
 931
 932         if (isdir(path))
 933                 {
 934                 g_free(lw->path);
 935                 lw->path = g_strdup(path);
 936                 }
 937         else
 938                 {
 939                 gchar *base;
 940
 941                 base = remove_level_from_path(path);
 942                 if (lw->path && strcmp(lw->path, base) == 0)
 943                         {
 944                         g_free(base);
 945                         }
 946                 else if (isdir(base))
 947                         {
 948                         g_free(lw->path);
 949                         lw->path = base;
 950                         }
 951                 else
 952                         {
 953                         g_free(base);
 954                         return FALSE;
 955                         }
 956                 if (isfile(path)) have_file = TRUE;
 957                 }
 958
 959         if (lw->path_entry) tab_completion_append_to_history(lw->path_entry, lw->path);
 960         layout_sync_path(lw);
 961
 962         if (have_file)
 963                 {
 964                 gint row;
 965
 966                 row = layout_list_get_index(lw, path);
 967                 if (row >= 0)
 968                         {
 969                         layout_image_set_index(lw, row);
 970                         }
 971                 else
 972                         {
 973                         layout_image_set_path(lw, path);
 974                         }
 975                 }
 976         else if (!lazy_image_sync)
 977                 {
 978                 layout_image_set_index(lw, 0);
 979                 }
 980
 981         return TRUE;
 982 }
 983
 984 static void layout_refresh_lists(LayoutWindow *lw)
 985 {
 986         if (lw->path) lw->last_time = filetime(lw->path);
 987
 988         if (lw->vdl) vdlist_refresh(lw->vdl);
 989         if (lw->vdt) vdtree_refresh(lw->vdt);
 990
 991         if (lw->vfl) vflist_refresh(lw->vfl);
 992         if (lw->vfi) vficon_refresh(lw->vfi);
 993 }
 994
 995 static void layout_refresh_by_time(LayoutWindow *lw)
 996 {
 997         layout_refresh_lists(lw);
 998
 999         if (lw->image && filetime(layout_image_get_path(lw)) >= lw->last_time)
1000                 {
1001                 layout_image_refresh(lw);
1002                 }
1003 }
1004
1005 void layout_refresh(LayoutWindow *lw)
1006 {
1007         if (!layout_valid(&lw)) return;
1008
1009         if (debug) printf("layout refresh\n");
1010
1011         layout_refresh_lists(lw);
1012
1013         if (lw->image) layout_image_refresh(lw);
1014 }
1015
1016 static gint layout_check_for_update_cb(gpointer data)
1017 {
1018         LayoutWindow *lw = data;
1019
1020         if (!update_on_time_change) return TRUE;
1021
1022         if (lw->path)
1023                 {
1024                 time_t new_time;
1025
1026                 new_time = filetime(lw->path);
1027
1028                 if (new_time > 0 && new_time > lw->last_time)
1029                         {
1030                         if (debug) printf("layout path time changed, refreshing...\n");
1031                         layout_refresh_by_time(lw);
1032                         }
1033                 }
1034
1035         return TRUE;
1036 }
1037
1038 void layout_thumb_set(LayoutWindow *lw, gint enable)
1039 {
1040         if (!layout_valid(&lw)) return;
1041
1042         if (lw->thumbs_enabled == enable) return;
1043
1044         lw->thumbs_enabled = enable;
1045
1046         layout_util_sync_thumb(lw);
1047         layout_list_sync_thumb(lw);
1048 }
1049
1050 void layout_marks_set(LayoutWindow *lw, gint enable)
1051 {
1052         if (!layout_valid(&lw)) return;
1053
1054         if (lw->marks_enabled == enable) return;
1055
1056         lw->marks_enabled = enable;
1057
1058     //  layout_util_sync_marks(lw);
1059     layout_list_sync_marks(lw);
1060
1061 }
1062
1063 gint layout_thumb_get(LayoutWindow *lw)
1064 {
1065         if (!layout_valid(&lw)) return FALSE;
1066
1067         return lw->thumbs_enabled;
1068 }
1069
1070 void layout_sort_set(LayoutWindow *lw, SortType type, gint ascend)
1071 {
1072         if (!layout_valid(&lw)) return;
1073         if (lw->sort_method == type && lw->sort_ascend == ascend) return;
1074
1075         lw->sort_method = type;
1076         lw->sort_ascend = ascend;
1077
1078         if (lw->info_sort) gtk_label_set_text(GTK_LABEL(GTK_BIN(lw->info_sort)->child),
1079                                               sort_type_get_text(type));
1080         layout_list_sync_sort(lw);
1081 }
1082
1083 gint layout_sort_get(LayoutWindow *lw, SortType *type, gint *ascend)
1084 {
1085         if (!layout_valid(&lw)) return FALSE;
1086
1087         if (type) *type = lw->sort_method;
1088         if (ascend) *ascend = lw->sort_ascend;
1089
1090         return TRUE;
1091 }
1092
1093 gint layout_geometry_get(LayoutWindow *lw, gint *x, gint *y, gint *w, gint *h)
1094 {
1095         if (!layout_valid(&lw)) return FALSE;
1096
1097         gdk_window_get_root_origin(lw->window->window, x, y);
1098         gdk_drawable_get_size(lw->window->window, w, h);
1099
1100         return TRUE;
1101 }
1102
1103 gint layout_geometry_get_dividers(LayoutWindow *lw, gint *h, gint *v)
1104 {
1105         if (!layout_valid(&lw)) return FALSE;
1106
1107         if (lw->h_pane && GTK_PANED(lw->h_pane)->child1->allocation.x >= 0)
1108                 {
1109                 *h = GTK_PANED(lw->h_pane)->child1->allocation.width;
1110                 }
1111         else if (h != &lw->div_h)
1112                 {
1113                 *h = lw->div_h;
1114                 }
1115
1116         if (lw->v_pane && GTK_PANED(lw->v_pane)->child1->allocation.x >= 0)
1117                 {
1118                 *v = GTK_PANED(lw->v_pane)->child1->allocation.height;
1119                 }
1120         else if (v != &lw->div_v)
1121                 {
1122                 *v = lw->div_v;
1123                 }
1124
1125         return TRUE;
1126 }
1127
1128 void layout_views_set(LayoutWindow *lw, gint tree, gint icons)
1129 {
1130         if (!layout_valid(&lw)) return;
1131
1132         if (lw->tree_view == tree && lw->icon_view == icons) return;
1133
1134         lw->tree_view = tree;
1135         lw->icon_view = icons;
1136
1137         layout_style_set(lw, -1, NULL);
1138 }
1139
1140 gint layout_views_get(LayoutWindow *lw, gint *tree, gint *icons)
1141 {
1142         if (!layout_valid(&lw)) return FALSE;
1143
1144         *tree = lw->tree_view;
1145         *icons = lw->icon_view;
1146
1147         return TRUE;
1148 }
1149
1150 /*
1151  *-----------------------------------------------------------------------------
1152  * location utils
1153  *-----------------------------------------------------------------------------
1154  */
1155
1156 static gint layout_location_single(LayoutLocation l)
1157 {
1158         return (l == LAYOUT_LEFT ||
1159                 l == LAYOUT_RIGHT ||
1160                 l == LAYOUT_TOP ||
1161                 l == LAYOUT_BOTTOM);
1162 }
1163
1164 static gint layout_location_vertical(LayoutLocation l)
1165 {
1166         return (l & LAYOUT_TOP ||
1167                 l & LAYOUT_BOTTOM);
1168 }
1169
1170 static gint layout_location_first(LayoutLocation l)
1171 {
1172         return (l & LAYOUT_TOP ||
1173                 l & LAYOUT_LEFT);
1174 }
1175
1176 static LayoutLocation layout_grid_compass(LayoutWindow *lw)
1177 {
1178         if (layout_location_single(lw->dir_location)) return lw->dir_location;
1179         if (layout_location_single(lw->file_location)) return lw->file_location;
1180         return lw->image_location;
1181 }
1182
1183 static void layout_location_compute(LayoutLocation l1, LayoutLocation l2,
1184                                     GtkWidget *s1, GtkWidget *s2,
1185                                     GtkWidget **d1, GtkWidget **d2)
1186 {
1187         LayoutLocation l;
1188
1189         l = l1 & l2;    /* get common compass direction */
1190         l = l1 - l;     /* remove it */
1191
1192         if (layout_location_first(l))
1193                 {
1194                 *d1 = s1;
1195                 *d2 = s2;
1196                 }
1197         else
1198                 {
1199                 *d1 = s2;
1200                 *d2 = s1;
1201                 }
1202 }
1203
1204 /*
1205  *-----------------------------------------------------------------------------
1206  * tools window (for floating/hidden)
1207  *-----------------------------------------------------------------------------
1208  */
1209
1210 gint layout_geometry_get_tools(LayoutWindow *lw, gint *x, gint *y, gint *w, gint *h, gint *divider_pos)
1211 {
1212         if (!layout_valid(&lw)) return FALSE;
1213
1214         if (!lw->tools || !GTK_WIDGET_VISIBLE(lw->tools))
1215                 {
1216                 /* use the stored values (sort of breaks success return value) */
1217
1218                 *divider_pos = lw->div_float;
1219
1220                 return FALSE;
1221                 }
1222
1223         gdk_window_get_root_origin(lw->tools->window, x, y);
1224         gdk_drawable_get_size(lw->tools->window, w, h);
1225
1226         if (GTK_IS_VPANED(lw->tools_pane))
1227                 {
1228                 *divider_pos = GTK_PANED(lw->tools_pane)->child1->allocation.height;
1229                 }
1230         else
1231                 {
1232                 *divider_pos = GTK_PANED(lw->tools_pane)->child1->allocation.width;
1233                 }
1234
1235         return TRUE;
1236 }
1237
1238 static void layout_tools_geometry_sync(LayoutWindow *lw)
1239 {
1240         layout_geometry_get_tools(lw, &float_window_x, &float_window_x,
1241                                   &float_window_w, &float_window_h, &lw->div_float);
1242 }
1243
1244 static void layout_tools_hide(LayoutWindow *lw, gint hide)
1245 {
1246         if (!lw->tools) return;
1247
1248         if (hide)
1249                 {
1250                 if (GTK_WIDGET_VISIBLE(lw->tools))
1251                         {
1252                         layout_tools_geometry_sync(lw);
1253                         gtk_widget_hide(lw->tools);
1254                         }
1255                 }
1256         else
1257                 {
1258                 if (!GTK_WIDGET_VISIBLE(lw->tools))
1259                         {
1260                         gtk_widget_show(lw->tools);
1261                         if (lw->vfi) vficon_refresh(lw->vfi);
1262                         }
1263                 }
1264
1265         lw->tools_hidden = hide;
1266 }
1267
1268 static gint layout_tools_delete_cb(GtkWidget *widget, GdkEventAny *event, gpointer data)
1269 {
1270         LayoutWindow *lw = data;
1271
1272         layout_tools_float_toggle(lw);
1273
1274         return TRUE;
1275 }
1276
1277 static void layout_tools_setup(LayoutWindow *lw, GtkWidget *tools, GtkWidget *files)
1278 {
1279         GtkWidget *vbox;
1280         GtkWidget *w1, *w2;
1281         gint vertical;
1282         gint new_window = FALSE;
1283
1284         vertical = (layout_location_single(lw->image_location) && !layout_location_vertical(lw->image_location)) ||
1285                    (!layout_location_single(lw->image_location) && layout_location_vertical(layout_grid_compass(lw)));
1286 #if 0
1287         layout_location_compute(lw->dir_location, lw->file_location,
1288                                 tools, files, &w1, &w2);
1289 #endif
1290         /* for now, tools/dir are always first in order */
1291         w1 = tools;
1292         w2 = files;
1293
1294         if (!lw->tools)
1295                 {
1296                 GdkGeometry geometry;
1297                 GdkWindowHints hints;
1298
1299                 lw->tools = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1300                 g_signal_connect(G_OBJECT(lw->tools), "delete_event",
1301                                  G_CALLBACK(layout_tools_delete_cb), lw);
1302                 layout_keyboard_init(lw, lw->tools);
1303
1304                 if (save_window_positions)
1305                         {
1306                         hints = GDK_HINT_USER_POS;
1307                         }
1308                 else
1309                         {
1310                         hints = 0;
1311                         }
1312
1313                 geometry.min_width = 32;
1314                 geometry.min_height = 32;
1315                 geometry.base_width = TOOLWINDOW_DEF_WIDTH;
1316                 geometry.base_height = TOOLWINDOW_DEF_HEIGHT;
1317                 gtk_window_set_geometry_hints(GTK_WINDOW(lw->tools), NULL, &geometry,
1318                                               GDK_HINT_MIN_SIZE | GDK_HINT_BASE_SIZE | hints);
1319
1320
1321                 gtk_window_set_resizable(GTK_WINDOW(lw->tools), TRUE);
1322                 gtk_window_set_title(GTK_WINDOW(lw->tools), _("GQview Tools"));
1323                 gtk_window_set_wmclass(GTK_WINDOW(lw->tools), "tools", "GQview");
1324                 gtk_container_set_border_width(GTK_CONTAINER(lw->tools), 0);
1325
1326                 window_set_icon(lw->tools, PIXBUF_INLINE_ICON_TOOLS, NULL);
1327
1328                 new_window = TRUE;
1329                 }
1330         else
1331                 {
1332                 layout_tools_geometry_sync(lw);
1333                 /* dump the contents */
1334                 gtk_widget_destroy(GTK_BIN(lw->tools)->child);
1335                 }
1336
1337         layout_actions_add_window(lw, lw->tools);
1338
1339         vbox = gtk_vbox_new(FALSE, 0);
1340         gtk_container_add(GTK_CONTAINER(lw->tools), vbox);
1341         gtk_widget_show(vbox);
1342
1343         layout_status_setup(lw, vbox, TRUE);
1344
1345         if (vertical)
1346                 {
1347                 lw->tools_pane = gtk_vpaned_new();
1348                 }
1349         else
1350                 {
1351                 lw->tools_pane = gtk_hpaned_new();
1352                 }
1353         gtk_box_pack_start(GTK_BOX(vbox), lw->tools_pane, TRUE, TRUE, 0);
1354         gtk_widget_show(lw->tools_pane);
1355
1356         gtk_paned_pack1(GTK_PANED(lw->tools_pane), w1, FALSE, TRUE);
1357         gtk_paned_pack2(GTK_PANED(lw->tools_pane), w2, TRUE, TRUE);
1358
1359         gtk_widget_show(tools);
1360         gtk_widget_show(files);
1361
1362         if (new_window)
1363                 {
1364                 if (save_window_positions)
1365                         {
1366                         gtk_window_set_default_size(GTK_WINDOW(lw->tools), float_window_w, float_window_h);
1367                         gtk_window_move(GTK_WINDOW(lw->tools), float_window_x, float_window_y);
1368                         }
1369                 else
1370                         {
1371                         if (vertical)
1372                                 {
1373                                 gtk_window_set_default_size(GTK_WINDOW(lw->tools),
1374                                                             TOOLWINDOW_DEF_WIDTH, TOOLWINDOW_DEF_HEIGHT);
1375                                 }
1376                         else
1377                                 {
1378                                 gtk_window_set_default_size(GTK_WINDOW(lw->tools),
1379                                                             TOOLWINDOW_DEF_HEIGHT, TOOLWINDOW_DEF_WIDTH);
1380                                 }
1381                         }
1382                 }
1383
1384         if (!save_window_positions)
1385                 {
1386                 if (vertical)
1387                         {
1388                         lw->div_float = MAIN_WINDOW_DIV_VPOS;
1389                         }
1390                 else
1391                         {
1392                         lw->div_float = MAIN_WINDOW_DIV_HPOS;
1393                         }
1394                 }
1395
1396         gtk_paned_set_position(GTK_PANED(lw->tools_pane), lw->div_float);
1397 }
1398
1399 /*
1400  *-----------------------------------------------------------------------------
1401  * glue (layout arrangement)
1402  *-----------------------------------------------------------------------------
1403  */
1404
1405 static void layout_grid_compute(LayoutWindow *lw,
1406                                 GtkWidget *image, GtkWidget *tools, GtkWidget *files,
1407                                 GtkWidget **w1, GtkWidget **w2, GtkWidget **w3)
1408 {
1409         /* heh, this was fun */
1410
1411         if (layout_location_single(lw->dir_location))
1412                 {
1413                 if (layout_location_first(lw->dir_location))
1414                         {
1415                         *w1 = tools;
1416                         layout_location_compute(lw->file_location, lw->image_location, files, image, w2, w3);
1417                         }
1418                 else
1419                         {
1420                         *w3 = tools;
1421                         layout_location_compute(lw->file_location, lw->image_location, files, image, w1, w2);
1422                         }
1423                 }
1424         else if (layout_location_single(lw->file_location))
1425                 {
1426                 if (layout_location_first(lw->file_location))
1427                         {
1428                         *w1 = files;
1429                         layout_location_compute(lw->dir_location, lw->image_location, tools, image, w2, w3);
1430                         }
1431                 else
1432                         {
1433                         *w3 = files;
1434                         layout_location_compute(lw->dir_location, lw->image_location, tools, image, w1, w2);
1435                         }
1436                 }
1437         else
1438                 {
1439                 /* image */
1440                 if (layout_location_first(lw->image_location))
1441                         {
1442                         *w1 = image;
1443                         layout_location_compute(lw->file_location, lw->dir_location, files, tools, w2, w3);
1444                         }
1445                 else
1446                         {
1447                         *w3 = image;
1448                         layout_location_compute(lw->file_location, lw->dir_location, files, tools, w1, w2);
1449                         }
1450                 }
1451 }
1452
1453 void layout_split_change(LayoutWindow *lw, ImageSplitMode mode)
1454 {
1455         GtkWidget *image;
1456         gint i;
1457         for (i=0; i < MAX_SPLIT_IMAGES; i++)
1458                 {
1459                 if (lw->split_images[i])
1460                         {
1461                         gtk_widget_hide(lw->split_images[i]->widget);
1462                         if (lw->split_images[i]->widget->parent != lw->utility_box)
1463                                 gtk_container_remove(GTK_CONTAINER(lw->split_images[i]->widget->parent), lw->split_images[i]->widget);
1464                         }
1465                 }
1466         gtk_container_remove(GTK_CONTAINER(lw->utility_box), lw->split_image_widget);
1467
1468         image = layout_image_setup_split(lw, mode);
1469
1470         gtk_box_pack_start(GTK_BOX(lw->utility_box), image, TRUE, TRUE, 0);
1471         gtk_box_reorder_child(GTK_BOX(lw->utility_box), image, 0);
1472         gtk_widget_show(image);
1473 }
1474
1475 static void layout_grid_setup(LayoutWindow *lw)
1476 {
1477         gint priority_location;
1478         GtkWidget *h;
1479         GtkWidget *v;
1480         GtkWidget *w1, *w2, *w3;
1481
1482         GtkWidget *image;
1483         GtkWidget *tools;
1484         GtkWidget *files;
1485
1486         layout_actions_setup(lw);
1487         layout_actions_add_window(lw, lw->window);
1488
1489         lw->group_box = gtk_vbox_new(FALSE, 0);
1490         gtk_box_pack_start(GTK_BOX(lw->main_box), lw->group_box, TRUE, TRUE, 0);
1491         gtk_widget_show(lw->group_box);
1492
1493         priority_location = layout_grid_compass(lw);
1494
1495         image = layout_image_setup_split(lw, lw->split_mode);
1496
1497
1498         tools = layout_tools_new(lw);
1499         files = layout_list_new(lw);
1500
1501         image = layout_bars_prepare(lw, image);
1502
1503         if (lw->tools_float || lw->tools_hidden)
1504                 {
1505                 gtk_box_pack_start(GTK_BOX(lw->group_box), image, TRUE, TRUE, 0);
1506                 gtk_widget_show(image);
1507
1508                 layout_tools_setup(lw, tools, files);
1509
1510                 gtk_widget_grab_focus(lw->image->widget);
1511
1512                 return;
1513                 }
1514         else if (lw->tools)
1515                 {
1516                 layout_tools_geometry_sync(lw);
1517                 gtk_widget_destroy(lw->tools);
1518                 lw->tools = NULL;
1519                 lw->tools_pane = NULL;
1520                 }
1521
1522         layout_status_setup(lw, lw->group_box, FALSE);
1523
1524         layout_grid_compute(lw, image, tools, files, &w1, &w2, &w3);
1525
1526         v = lw->v_pane = gtk_vpaned_new();
1527
1528         h = lw->h_pane = gtk_hpaned_new();
1529
1530         if (!layout_location_vertical(priority_location))
1531                 {
1532                 GtkWidget *tmp;
1533
1534                 tmp = v;
1535                 v = h;
1536                 h = tmp;
1537                 }
1538
1539         gtk_box_pack_start(GTK_BOX(lw->group_box), v, TRUE, TRUE, 0);
1540
1541         if (!layout_location_first(priority_location))
1542                 {
1543                 gtk_paned_pack1(GTK_PANED(v), h, FALSE, TRUE);
1544                 gtk_paned_pack2(GTK_PANED(v), w3, TRUE, TRUE);
1545
1546                 gtk_paned_pack1(GTK_PANED(h), w1, FALSE, TRUE);
1547                 gtk_paned_pack2(GTK_PANED(h), w2, TRUE, TRUE);
1548                 }
1549         else
1550                 {
1551                 gtk_paned_pack1(GTK_PANED(v), w1, FALSE, TRUE);
1552                 gtk_paned_pack2(GTK_PANED(v), h, TRUE, TRUE);
1553
1554                 gtk_paned_pack1(GTK_PANED(h), w2, FALSE, TRUE);
1555                 gtk_paned_pack2(GTK_PANED(h), w3, TRUE, TRUE);
1556                 }
1557
1558         gtk_widget_show(image);
1559         gtk_widget_show(tools);
1560         gtk_widget_show(files);
1561
1562         gtk_widget_show(v);
1563         gtk_widget_show(h);
1564
1565         /* fix to have image pane visible when it is left and priority widget */
1566         if (lw->div_h == -1 &&
1567             w1 == image &&
1568             !layout_location_vertical(priority_location) &&
1569             layout_location_first(priority_location))
1570                 {
1571                 gtk_widget_set_size_request(image, 200, -1);
1572                 }
1573
1574         gtk_paned_set_position(GTK_PANED(lw->h_pane), lw->div_h);
1575         gtk_paned_set_position(GTK_PANED(lw->v_pane), lw->div_v);
1576
1577         gtk_widget_grab_focus(lw->image->widget);
1578 }
1579
1580 void layout_style_set(LayoutWindow *lw, gint style, const gchar *order)
1581 {
1582         gchar *path;
1583         gint i;
1584
1585         if (!layout_valid(&lw)) return;
1586
1587         if (style != -1)
1588                 {
1589                 LayoutLocation d, f, i;
1590
1591                 layout_config_parse(style, order, &d,  &f, &i);
1592
1593                 if (lw->dir_location == d &&
1594                     lw->file_location == f &&
1595                     lw->image_location == i) return;
1596
1597                 lw->dir_location = d;
1598                 lw->file_location = f;
1599                 lw->image_location = i;
1600                 }
1601
1602         /* remember state */
1603
1604         layout_image_slideshow_stop(lw);
1605         layout_image_full_screen_stop(lw);
1606
1607         path = lw->path;
1608         lw->path = NULL;
1609         lw->image = NULL;
1610         lw->utility_box = NULL;
1611
1612         layout_geometry_get_dividers(lw, &lw->div_h, &lw->div_v);
1613
1614         /* clear it all */
1615
1616         for (i=0; i < MAX_SPLIT_IMAGES; i++)
1617                 {
1618                 if (lw->split_images[i])
1619                         {
1620                         gtk_widget_hide(lw->split_images[i]->widget);
1621                         gtk_container_remove(GTK_CONTAINER(lw->split_images[i]->widget->parent), lw->split_images[i]->widget);
1622                         }
1623                 }
1624
1625         lw->h_pane = NULL;
1626         lw->v_pane = NULL;
1627
1628         lw->toolbar = NULL;
1629         lw->thumb_button = NULL;
1630         lw->path_entry = NULL;
1631         lw->dir_view = NULL;
1632         lw->vdl = NULL;
1633         lw->vdt = NULL;
1634
1635         lw->file_view = NULL;
1636         lw->vfl = NULL;
1637         lw->vfi = NULL;
1638
1639         lw->info_box = NULL;
1640         lw->info_progress_bar = NULL;
1641         lw->info_sort = NULL;
1642         lw->info_color = NULL;
1643         lw->info_status = NULL;
1644         lw->info_details = NULL;
1645         lw->info_zoom = NULL;
1646
1647         if (lw->ui_manager) g_object_unref(lw->ui_manager);
1648         lw->ui_manager = NULL;
1649         lw->action_group = NULL;
1650
1651         gtk_container_remove(GTK_CONTAINER(lw->main_box), lw->group_box);
1652         lw->group_box = NULL;
1653
1654         /* re-fill */
1655
1656         layout_grid_setup(lw);
1657         layout_tools_hide(lw, lw->tools_hidden);
1658
1659         layout_list_sync_sort(lw);
1660         layout_util_sync(lw);
1661         layout_status_update_all(lw);
1662
1663         /* sync */
1664
1665         if (image_get_path(lw->image))
1666                 {
1667                 layout_set_path(lw, image_get_path(lw->image));
1668                 }
1669         else
1670                 {
1671                 layout_set_path(lw, path);
1672                 }
1673         image_top_window_set_sync(lw->image, (lw->tools_float || lw->tools_hidden));
1674
1675         /* clean up */
1676
1677         g_free(path);
1678 }
1679
1680 void layout_styles_update(void)
1681 {
1682         GList *work;
1683
1684         work = layout_window_list;
1685         while (work)
1686                 {
1687                 LayoutWindow *lw = work->data;
1688                 work = work->next;
1689
1690                 layout_style_set(lw, layout_style, layout_order);
1691                 }
1692 }
1693
1694 void layout_colors_update(void)
1695 {
1696         GList *work;
1697
1698         work = layout_window_list;
1699         while (work)
1700                 {
1701                 LayoutWindow *lw = work->data;
1702                 work = work->next;
1703
1704                 if (lw->image) image_background_set_black(lw->image, black_window_background);
1705                 }
1706 }
1707
1708 void layout_tools_float_toggle(LayoutWindow *lw)
1709 {
1710         gint popped;
1711
1712         if (!lw) return;
1713
1714         if (!lw->tools_hidden)
1715                 {
1716                 popped = !lw->tools_float;
1717                 }
1718         else
1719                 {
1720                 popped = TRUE;
1721                 }
1722
1723         if (lw->tools_float == popped)
1724                 {
1725                 if (popped && lw->tools_hidden)
1726                         {
1727                         layout_tools_float_set(lw, popped, FALSE);
1728                         }
1729                 }
1730         else
1731                 {
1732                 if (lw->tools_float)
1733                         {
1734                         layout_tools_float_set(lw, FALSE, FALSE);
1735                         }
1736                 else
1737                         {
1738                         layout_tools_float_set(lw, TRUE, FALSE);
1739                         }
1740                 }
1741 }
1742
1743 void layout_tools_hide_toggle(LayoutWindow *lw)
1744 {
1745         if (!lw) return;
1746
1747         layout_tools_float_set(lw, lw->tools_float, !lw->tools_hidden);
1748 }
1749
1750 void layout_tools_float_set(LayoutWindow *lw, gint popped, gint hidden)
1751 {
1752         if (!layout_valid(&lw)) return;
1753
1754         if (lw->tools_float == popped && lw->tools_hidden == hidden) return;
1755
1756         if (lw->tools_float == popped && lw->tools_float && lw->tools)
1757                 {
1758                 layout_tools_hide(lw, hidden);
1759                 return;
1760                 }
1761
1762         lw->tools_float = popped;
1763         lw->tools_hidden = hidden;
1764
1765         layout_style_set(lw, -1, NULL);
1766 }
1767
1768 gint layout_tools_float_get(LayoutWindow *lw, gint *popped, gint *hidden)
1769 {
1770         if (!layout_valid(&lw)) return FALSE;
1771
1772         *popped = lw->tools_float;
1773         *hidden = lw->tools_hidden;
1774
1775         return TRUE;
1776 }
1777
1778 void layout_toolbar_toggle(LayoutWindow *lw)
1779 {
1780         if (!layout_valid(&lw)) return;
1781         if (!lw->toolbar) return;
1782
1783         lw->toolbar_hidden = !lw->toolbar_hidden;
1784
1785         if (lw->toolbar_hidden)
1786                 {
1787                 if (GTK_WIDGET_VISIBLE(lw->toolbar)) gtk_widget_hide(lw->toolbar);
1788                 }
1789         else
1790                 {
1791                 if (!GTK_WIDGET_VISIBLE(lw->toolbar)) gtk_widget_show(lw->toolbar);
1792                 }
1793 }
1794
1795 gint layout_toolbar_hidden(LayoutWindow *lw)
1796 {
1797         if (!layout_valid(&lw)) return TRUE;
1798
1799         return lw->toolbar_hidden;
1800 }
1801
1802 /*
1803  *-----------------------------------------------------------------------------
1804  * base
1805  *-----------------------------------------------------------------------------
1806  */
1807
1808 void layout_close(LayoutWindow *lw)
1809 {
1810         if (layout_window_list && layout_window_list->next)
1811                 {
1812                 layout_free(lw);
1813                 }
1814         else
1815                 {
1816                 exit_gqview();
1817                 }
1818 }
1819
1820 void layout_free(LayoutWindow *lw)
1821 {
1822         if (!lw) return;
1823
1824         layout_window_list = g_list_remove(layout_window_list, lw);
1825
1826         if (lw->last_time_id != -1)
1827                 {
1828                 g_source_remove(lw->last_time_id);
1829                 }
1830
1831         layout_bars_close(lw);
1832
1833         gtk_widget_destroy(lw->window);
1834
1835         g_free(lw->path);
1836
1837         g_free(lw);
1838 }
1839
1840 static gint layout_delete_cb(GtkWidget *widget, GdkEventAny *event, gpointer data)
1841 {
1842         LayoutWindow *lw = data;
1843
1844         layout_close(lw);
1845         return TRUE;
1846 }
1847
1848 LayoutWindow *layout_new(const gchar *path, gint popped, gint hidden)
1849 {
1850         return layout_new_with_geometry(path, popped, hidden, NULL);
1851 }
1852
1853 LayoutWindow *layout_new_with_geometry(const gchar *path, gint popped, gint hidden,
1854                                        const gchar *geometry)
1855 {
1856         LayoutWindow *lw;
1857         GdkGeometry hint;
1858         GdkWindowHints hint_mask;
1859
1860         lw = g_new0(LayoutWindow, 1);
1861
1862         lw->thumbs_enabled = thumbnails_enabled;
1863         lw->sort_method = SORT_NAME;
1864         lw->sort_ascend = TRUE;
1865
1866         lw->tools_float = popped;
1867         lw->tools_hidden = hidden;
1868
1869         lw->toolbar_hidden = toolbar_hidden;
1870
1871         lw->utility_box = NULL;
1872         lw->bar_sort = NULL;
1873         lw->bar_sort_enabled = FALSE;
1874         lw->bar_exif = NULL;
1875         lw->bar_exif_enabled = FALSE;
1876         lw->bar_exif_size = -1;
1877         lw->bar_exif_advanced = FALSE;
1878
1879         /* default layout */
1880
1881         layout_config_parse(layout_style, layout_order,
1882                             &lw->dir_location,  &lw->file_location, &lw->image_location);
1883         lw->tree_view = layout_view_tree;
1884         lw->icon_view = layout_view_icons;
1885
1886         /* divider positions */
1887
1888         if (save_window_positions)
1889                 {
1890                 lw->div_h = window_hdivider_pos;
1891                 lw->div_v = window_vdivider_pos;
1892                 lw->div_float = float_window_divider;
1893                 }
1894         else
1895                 {
1896                 lw->div_h = MAIN_WINDOW_DIV_HPOS;
1897                 lw->div_v = MAIN_WINDOW_DIV_VPOS;
1898                 lw->div_float = MAIN_WINDOW_DIV_VPOS;
1899                 }
1900
1901         /* window */
1902
1903         lw->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1904         gtk_window_set_resizable(GTK_WINDOW(lw->window), TRUE);
1905
1906         gtk_window_set_title(GTK_WINDOW(lw->window), "GQview");
1907         gtk_window_set_wmclass(GTK_WINDOW(lw->window), "gqview", "GQview");
1908         gtk_container_set_border_width(GTK_CONTAINER(lw->window), 0);
1909
1910         window_set_icon(lw->window, NULL, NULL);
1911
1912         if (save_window_positions)
1913                 {
1914                 hint_mask = GDK_HINT_USER_POS;
1915                 }
1916         else
1917                 {
1918                 hint_mask = 0;
1919                 }
1920
1921         hint.min_width = 32;
1922         hint.min_height = 32;
1923         hint.base_width = 0;
1924         hint.base_height = 0;
1925         gtk_window_set_geometry_hints(GTK_WINDOW(lw->window), NULL, &hint,
1926                                       GDK_HINT_MIN_SIZE | GDK_HINT_BASE_SIZE | hint_mask);
1927
1928         if (save_window_positions)
1929                 {
1930                 gtk_window_set_default_size(GTK_WINDOW(lw->window), main_window_w, main_window_h);
1931                 if (!layout_window_list)
1932                         {
1933                         gtk_window_move(GTK_WINDOW(lw->window), main_window_x, main_window_y);
1934                         if (main_window_maximized) gtk_window_maximize(GTK_WINDOW(lw->window));
1935                         }
1936                 }
1937         else
1938                 {
1939                 gtk_window_set_default_size(GTK_WINDOW(lw->window), MAINWINDOW_DEF_WIDTH, MAINWINDOW_DEF_HEIGHT);
1940                 }
1941
1942         g_signal_connect(G_OBJECT(lw->window), "delete_event",
1943                          G_CALLBACK(layout_delete_cb), lw);
1944
1945         layout_keyboard_init(lw, lw->window);
1946
1947         lw->main_box = gtk_vbox_new(FALSE, 0);
1948         gtk_container_add(GTK_CONTAINER(lw->window), lw->main_box);
1949         gtk_widget_show(lw->main_box);
1950
1951         layout_grid_setup(lw);
1952         image_top_window_set_sync(lw->image, (lw->tools_float || lw->tools_hidden));
1953
1954         layout_util_sync(lw);
1955         layout_status_update_all(lw);
1956
1957         if (path)
1958                 {
1959                 layout_set_path(lw, path);
1960                 }
1961         else
1962                 {
1963                 GdkPixbuf *pixbuf;
1964
1965                 pixbuf = pixbuf_inline(PIXBUF_INLINE_LOGO);
1966                 image_change_pixbuf(lw->image, pixbuf, 1.0);
1967                 gdk_pixbuf_unref(pixbuf);
1968                 }
1969
1970         /* set up the time stat timeout */
1971         lw->last_time = 0;
1972         lw->last_time_id = g_timeout_add(5000, layout_check_for_update_cb, lw);
1973
1974         if (geometry)
1975                 {
1976                 if (!gtk_window_parse_geometry(GTK_WINDOW(lw->window), geometry))
1977                         {
1978                         print_term(_("Invalid geometry\n"));
1979                         }
1980                 }
1981
1982         gtk_widget_show(lw->window);
1983         layout_tools_hide(lw, lw->tools_hidden);
1984
1985         layout_window_list = g_list_append(layout_window_list, lw);
1986
1987         return lw;
1988 }
1989
1990 /*
1991  *-----------------------------------------------------------------------------
1992  * maintenance (for rename, move, remove)
1993  *-----------------------------------------------------------------------------
1994  */
1995
1996 static void layout_real_time_update(LayoutWindow *lw)
1997 {
1998         /* this resets the last time stamp of path so that a refresh does not occur
1999          * from an internal file operation.
2000          */
2001
2002         if (lw->path) lw->last_time = filetime(lw->path);
2003 }
2004
2005 static void layout_real_renamed(LayoutWindow *lw, const gchar *source, const gchar *dest)
2006 {
2007         gint update = FALSE;
2008
2009         if (lw->image) layout_image_maint_renamed(lw, source, dest);
2010
2011         if (lw->vfl) update |= vflist_maint_renamed(lw->vfl, source, dest);
2012         if (lw->vfi) update |= vficon_maint_renamed(lw->vfi, source, dest);
2013
2014         if (update) layout_real_time_update(lw);
2015 }
2016
2017 static void layout_real_removed(LayoutWindow *lw, const gchar *path, GList *ignore_list)
2018 {
2019         gint update = FALSE;
2020
2021         if (lw->image) layout_image_maint_removed(lw, path);
2022
2023         if (lw->vfl) update |= vflist_maint_removed(lw->vfl, path, ignore_list);
2024         if (lw->vfi) update |= vficon_maint_removed(lw->vfi, path, ignore_list);
2025
2026         if (update) layout_real_time_update(lw);
2027 }
2028
2029 static void layout_real_moved(LayoutWindow *lw, const gchar *source, const gchar *dest, GList *ignore_list)
2030 {
2031         gint update = FALSE;
2032
2033         if (lw->image) layout_image_maint_moved(lw, source, dest);
2034
2035         if (lw->vfl) update |= vflist_maint_moved(lw->vfl, source, dest, ignore_list);
2036         if (lw->vfi) update |= vficon_maint_moved(lw->vfi, source, dest, ignore_list);
2037
2038         if (update) layout_real_time_update(lw);
2039 }
2040
2041 void layout_maint_renamed(const gchar *source, const gchar *dest)
2042 {
2043         GList *work = layout_window_list;
2044         while (work)
2045                 {
2046                 LayoutWindow *lw = work->data;
2047                 work = work->next;
2048
2049                 layout_real_renamed(lw, source, dest);
2050                 }
2051 }
2052
2053 void layout_maint_removed(const gchar *path, GList *ignore_list)
2054 {
2055         GList *work = layout_window_list;
2056         while (work)
2057                 {
2058                 LayoutWindow *lw = work->data;
2059                 work = work->next;
2060
2061                 layout_real_removed(lw, path, ignore_list);
2062                 }
2063 }
2064
2065 void layout_maint_moved(const gchar *source, const gchar *dest, GList *ignore_list)
2066 {
2067         GList *work = layout_window_list;
2068         while (work)
2069                 {
2070                 LayoutWindow *lw = work->data;
2071                 work = work->next;
2072
2073                 layout_real_moved(lw, source, dest, ignore_list);
2074                 }
2075 }