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