src/layout.c

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