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