src/layout.c

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