src/layout.c

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