src/layout_image.c

   1 /*
   2  * Geeqie
   3  * (C) 2006 John Ellis
   4  * Copyright (C) 2008 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_image.h"
  15
  16 #include "collect.h"
  17 #include "dnd.h"
  18 #include "editors.h"
  19 #include "filedata.h"
  20 #include "fullscreen.h"
  21 #include "image.h"
  22 #include "image-overlay.h"
  23 #include "img-view.h"
  24 #include "info.h"
  25 #include "layout.h"
  26 #include "layout_util.h"
  27 #include "menu.h"
  28 #include "pixbuf_util.h"
  29 #include "utilops.h"
  30 #include "slideshow.h"
  31 #include "ui_fileops.h"
  32 #include "ui_menu.h"
  33 #include "uri_utils.h"
  34
  35 #include <gdk/gdkkeysyms.h> /* for keyboard values */
  36
  37
  38 static GtkWidget *layout_image_pop_menu(LayoutWindow *lw);
  39 static void layout_image_set_buttons(LayoutWindow *lw);
  40
  41 /*
  42  *----------------------------------------------------------------------------
  43  * full screen overlay
  44  *----------------------------------------------------------------------------
  45  */
  46
  47 void layout_image_overlay_toggle(LayoutWindow *lw)
  48 {
  49         if (!lw) return;
  50         image_osd_toggle(lw->image);
  51 }
  52
  53 /*
  54  *----------------------------------------------------------------------------
  55  * full screen
  56  *----------------------------------------------------------------------------
  57  */
  58
  59 static void layout_image_full_screen_stop_func(FullScreenData *fs, gpointer data)
  60 {
  61         LayoutWindow *lw = data;
  62
  63         /* restore image window */
  64         lw->image = fs->normal_imd;
  65
  66         if (lw->slideshow)
  67                 {
  68                 lw->slideshow->imd = lw->image;
  69                 }
  70
  71         lw->full_screen = NULL;
  72 }
  73
  74 void layout_image_full_screen_start(LayoutWindow *lw)
  75 {
  76         if (!layout_valid(&lw)) return;
  77
  78         if (lw->full_screen) return;
  79
  80         lw->full_screen = fullscreen_start(lw->window, lw->image,
  81                                            layout_image_full_screen_stop_func, lw);
  82
  83         /* set to new image window */
  84         lw->image = lw->full_screen->imd;
  85
  86         if (lw->slideshow)
  87                 {
  88                 lw->slideshow->imd = lw->image;
  89                 }
  90
  91         layout_image_set_buttons(lw);
  92
  93         g_signal_connect(G_OBJECT(lw->full_screen->window), "key_press_event",
  94                          G_CALLBACK(layout_key_press_cb), lw);
  95
  96         layout_actions_add_window(lw, lw->full_screen->window);
  97 #if 0
  98         gtk_widget_set_sensitive(lw->window, FALSE);
  99         if (lw->tools) gtk_widget_set_sensitive(lw->tools, FALSE);
 100 #endif
 101
 102         if (image_osd_get(lw->full_screen->normal_imd) & OSD_SHOW_INFO)
 103                 {
 104                 image_osd_set(lw->image, image_osd_get(lw->full_screen->normal_imd));
 105                 image_osd_set(lw->full_screen->normal_imd, OSD_SHOW_NOTHING);
 106                 }
 107 }
 108
 109 void layout_image_full_screen_stop(LayoutWindow *lw)
 110 {
 111         if (!layout_valid(&lw)) return;
 112         if (!lw->full_screen) return;
 113
 114         if (image_osd_get(lw->full_screen->normal_imd) & OSD_SHOW_INFO)
 115                 image_osd_set(lw->full_screen->normal_imd, image_osd_get(lw->image));
 116
 117         fullscreen_stop(lw->full_screen);
 118
 119 #if 0
 120         gtk_widget_set_sensitive(lw->window, TRUE);
 121         if (lw->tools) gtk_widget_set_sensitive(lw->tools, TRUE);
 122 #endif
 123 }
 124
 125 void layout_image_full_screen_toggle(LayoutWindow *lw)
 126 {
 127         if (!layout_valid(&lw)) return;
 128         if (lw->full_screen)
 129                 {
 130                 layout_image_full_screen_stop(lw);
 131                 }
 132         else
 133                 {
 134                 layout_image_full_screen_start(lw);
 135                 }
 136 }
 137
 138 gint layout_image_full_screen_active(LayoutWindow *lw)
 139 {
 140         if (!layout_valid(&lw)) return FALSE;
 141
 142         return (lw->full_screen != NULL);
 143 }
 144
 145 /*
 146  *----------------------------------------------------------------------------
 147  * slideshow
 148  *----------------------------------------------------------------------------
 149  */
 150
 151 static void layout_image_slideshow_next(LayoutWindow *lw)
 152 {
 153         if (lw->slideshow) slideshow_next(lw->slideshow);
 154 }
 155
 156 static void layout_image_slideshow_prev(LayoutWindow *lw)
 157 {
 158         if (lw->slideshow) slideshow_prev(lw->slideshow);
 159 }
 160
 161 static void layout_image_slideshow_stop_func(SlideShowData *ss, gpointer data)
 162 {
 163         LayoutWindow *lw = data;
 164
 165         lw->slideshow = NULL;
 166         layout_status_update_info(lw, NULL);
 167 }
 168
 169 void layout_image_slideshow_start(LayoutWindow *lw)
 170 {
 171         CollectionData *cd;
 172         CollectInfo *info;
 173
 174         if (!layout_valid(&lw)) return;
 175         if (lw->slideshow) return;
 176
 177         cd = image_get_collection(lw->image, &info);
 178
 179         if (cd && info)
 180                 {
 181                 lw->slideshow = slideshow_start_from_collection(lw->image, cd,
 182                                 layout_image_slideshow_stop_func, lw, info);
 183                 }
 184         else
 185                 {
 186                 lw->slideshow = slideshow_start(lw->image, lw,
 187                                 layout_list_get_index(lw, layout_image_get_fd(lw)),
 188                                 layout_image_slideshow_stop_func, lw);
 189                 }
 190
 191         layout_status_update_info(lw, NULL);
 192 }
 193
 194 /* note that slideshow will take ownership of the list, do not free it */
 195 void layout_image_slideshow_start_from_list(LayoutWindow *lw, GList *list)
 196 {
 197         if (!layout_valid(&lw)) return;
 198
 199         if (lw->slideshow || !list)
 200                 {
 201                 filelist_free(list);
 202                 return;
 203                 }
 204
 205         lw->slideshow = slideshow_start_from_filelist(lw->image, list,
 206                                                        layout_image_slideshow_stop_func, lw);
 207
 208         layout_status_update_info(lw, NULL);
 209 }
 210
 211 void layout_image_slideshow_stop(LayoutWindow *lw)
 212 {
 213         if (!layout_valid(&lw)) return;
 214
 215         if (!lw->slideshow) return;
 216
 217         slideshow_free(lw->slideshow);
 218         /* the stop_func sets lw->slideshow to NULL for us */
 219 }
 220
 221 void layout_image_slideshow_toggle(LayoutWindow *lw)
 222 {
 223         if (!layout_valid(&lw)) return;
 224
 225         if (lw->slideshow)
 226                 {
 227                 layout_image_slideshow_stop(lw);
 228                 }
 229         else
 230                 {
 231                 layout_image_slideshow_start(lw);
 232                 }
 233 }
 234
 235 gint layout_image_slideshow_active(LayoutWindow *lw)
 236 {
 237         if (!layout_valid(&lw)) return FALSE;
 238
 239         return (lw->slideshow != NULL);
 240 }
 241
 242 gint layout_image_slideshow_pause_toggle(LayoutWindow *lw)
 243 {
 244         gint ret;
 245
 246         if (!layout_valid(&lw)) return FALSE;
 247
 248         ret = slideshow_pause_toggle(lw->slideshow);
 249
 250         layout_status_update_info(lw, NULL);
 251
 252         return ret;
 253 }
 254
 255 gint layout_image_slideshow_paused(LayoutWindow *lw)
 256 {
 257         if (!layout_valid(&lw)) return FALSE;
 258
 259         return (slideshow_paused(lw->slideshow));
 260 }
 261
 262 static gint layout_image_slideshow_continue_check(LayoutWindow *lw)
 263 {
 264         if (!lw->slideshow) return FALSE;
 265
 266         if (!slideshow_should_continue(lw->slideshow))
 267                 {
 268                 layout_image_slideshow_stop(lw);
 269                 return FALSE;
 270                 }
 271
 272         return TRUE;
 273 }
 274
 275 /*
 276  *----------------------------------------------------------------------------
 277  * pop-up menus
 278  *----------------------------------------------------------------------------
 279  */
 280
 281 static void li_pop_menu_zoom_in_cb(GtkWidget *widget, gpointer data)
 282 {
 283         LayoutWindow *lw = data;
 284
 285         layout_image_zoom_adjust(lw, get_zoom_increment());
 286 }
 287
 288 static void li_pop_menu_zoom_out_cb(GtkWidget *widget, gpointer data)
 289 {
 290         LayoutWindow *lw = data;
 291         layout_image_zoom_adjust(lw, -get_zoom_increment());
 292 }
 293
 294 static void li_pop_menu_zoom_1_1_cb(GtkWidget *widget, gpointer data)
 295 {
 296         LayoutWindow *lw = data;
 297
 298         layout_image_zoom_set(lw, 1.0);
 299 }
 300
 301 static void li_pop_menu_zoom_fit_cb(GtkWidget *widget, gpointer data)
 302 {
 303         LayoutWindow *lw = data;
 304
 305         layout_image_zoom_set(lw, 0.0);
 306 }
 307
 308 static void li_pop_menu_edit_cb(GtkWidget *widget, gpointer data)
 309 {
 310         LayoutWindow *lw;
 311         gint n;
 312
 313         lw = submenu_item_get_data(widget);
 314         n = GPOINTER_TO_INT(data);
 315
 316         if (!editor_window_flag_set(n))
 317                 {
 318                 layout_image_full_screen_stop(lw);
 319                 }
 320         file_util_start_editor_from_file(n, layout_image_get_fd(lw), lw->window);
 321 }
 322
 323 static void li_pop_menu_wallpaper_cb(GtkWidget *widget, gpointer data)
 324 {
 325         LayoutWindow *lw = data;
 326
 327         layout_image_to_root(lw);
 328 }
 329
 330 static void li_pop_menu_alter_cb(GtkWidget *widget, gpointer data)
 331 {
 332         LayoutWindow *lw = data;
 333         AlterType type;
 334
 335         lw = submenu_item_get_data(widget);
 336         type = (AlterType)GPOINTER_TO_INT(data);
 337
 338         image_alter(lw->image, type);
 339 }
 340
 341 static void li_pop_menu_info_cb(GtkWidget *widget, gpointer data)
 342 {
 343         LayoutWindow *lw = data;
 344
 345         info_window_new(layout_image_get_fd(lw), NULL, lw->full_screen ? lw->full_screen->window : NULL);
 346 }
 347
 348 static void li_pop_menu_new_cb(GtkWidget *widget, gpointer data)
 349 {
 350         LayoutWindow *lw = data;
 351
 352         view_window_new(layout_image_get_fd(lw));
 353 }
 354
 355 static GtkWidget *li_pop_menu_click_parent(GtkWidget *widget, LayoutWindow *lw)
 356 {
 357         GtkWidget *menu;
 358         GtkWidget *parent;
 359
 360         menu = gtk_widget_get_toplevel(widget);
 361         if (!menu) return NULL;
 362
 363         parent = g_object_get_data(G_OBJECT(menu), "click_parent");
 364
 365         if (!parent && lw->full_screen)
 366                 {
 367                 parent = lw->full_screen->imd->widget;
 368                 }
 369
 370         return parent;
 371 }
 372
 373 static void li_pop_menu_copy_cb(GtkWidget *widget, gpointer data)
 374 {
 375         LayoutWindow *lw = data;
 376
 377         file_util_copy(layout_image_get_fd(lw), NULL, NULL,
 378                        li_pop_menu_click_parent(widget, lw));
 379 }
 380
 381 static void li_pop_menu_copy_path_cb(GtkWidget *widget, gpointer data)
 382 {
 383         LayoutWindow *lw = data;
 384
 385         file_util_copy_path_to_clipboard(layout_image_get_fd(lw));
 386 }
 387
 388 static void li_pop_menu_move_cb(GtkWidget *widget, gpointer data)
 389 {
 390         LayoutWindow *lw = data;
 391
 392         file_util_move(layout_image_get_fd(lw), NULL, NULL,
 393                        li_pop_menu_click_parent(widget, lw));
 394 }
 395
 396 static void li_pop_menu_rename_cb(GtkWidget *widget, gpointer data)
 397 {
 398         LayoutWindow *lw = data;
 399
 400         file_util_rename(layout_image_get_fd(lw), NULL,
 401                          li_pop_menu_click_parent(widget, lw));
 402 }
 403
 404 static void li_pop_menu_delete_cb(GtkWidget *widget, gpointer data)
 405 {
 406         LayoutWindow *lw = data;
 407
 408         file_util_delete(layout_image_get_fd(lw), NULL,
 409                          li_pop_menu_click_parent(widget, lw));
 410 }
 411
 412 static void li_pop_menu_slide_start_cb(GtkWidget *widget, gpointer data)
 413 {
 414         LayoutWindow *lw = data;
 415
 416         layout_image_slideshow_start(lw);
 417 }
 418
 419 static void li_pop_menu_slide_stop_cb(GtkWidget *widget, gpointer data)
 420 {
 421         LayoutWindow *lw = data;
 422
 423         layout_image_slideshow_stop(lw);
 424 }
 425
 426 static void li_pop_menu_slide_pause_cb(GtkWidget *widget, gpointer data)
 427 {
 428         LayoutWindow *lw = data;
 429
 430         layout_image_slideshow_pause_toggle(lw);
 431 }
 432
 433 static void li_pop_menu_full_screen_cb(GtkWidget *widget, gpointer data)
 434 {
 435         LayoutWindow *lw = data;
 436
 437         layout_image_full_screen_toggle(lw);
 438 }
 439
 440 static void li_pop_menu_hide_cb(GtkWidget *widget, gpointer data)
 441 {
 442         LayoutWindow *lw = data;
 443
 444         layout_tools_hide_toggle(lw);
 445 }
 446
 447 static void li_set_layout_path_cb(GtkWidget *widget, gpointer data)
 448 {
 449         LayoutWindow *lw = data;
 450         FileData *fd;
 451
 452         if (!layout_valid(&lw)) return;
 453
 454         fd = layout_image_get_fd(lw);
 455         if (fd) layout_set_fd(lw, fd);
 456 }
 457
 458 static gint li_check_if_current_path(LayoutWindow *lw, const gchar *path)
 459 {
 460         gchar *dirname;
 461         gint ret;
 462
 463         if (!path || !layout_valid(&lw) || !lw->dir_fd) return FALSE;
 464
 465         dirname = g_path_get_dirname(path);
 466         ret = (strcmp(lw->dir_fd->path, dirname) == 0);
 467         g_free(dirname);
 468         return ret;
 469 }
 470
 471 static GtkWidget *layout_image_pop_menu(LayoutWindow *lw)
 472 {
 473         GtkWidget *menu;
 474         GtkWidget *item;
 475         GtkWidget *submenu;
 476         const gchar *path;
 477         gint fullscreen;
 478
 479         path = layout_image_get_path(lw);
 480         fullscreen = layout_image_full_screen_active(lw);
 481
 482         menu = popup_menu_short_lived();
 483
 484         menu_item_add_stock(menu, _("Zoom _in"), GTK_STOCK_ZOOM_IN, G_CALLBACK(li_pop_menu_zoom_in_cb), lw);
 485         menu_item_add_stock(menu, _("Zoom _out"), GTK_STOCK_ZOOM_OUT, G_CALLBACK(li_pop_menu_zoom_out_cb), lw);
 486         menu_item_add_stock(menu, _("Zoom _1:1"), GTK_STOCK_ZOOM_100, G_CALLBACK(li_pop_menu_zoom_1_1_cb), lw);
 487         menu_item_add_stock(menu, _("Fit image to _window"), GTK_STOCK_ZOOM_FIT, G_CALLBACK(li_pop_menu_zoom_fit_cb), lw);
 488         menu_item_add_divider(menu);
 489
 490         submenu = submenu_add_edit(menu, &item, G_CALLBACK(li_pop_menu_edit_cb), lw);
 491         if (!path) gtk_widget_set_sensitive(item, FALSE);
 492         menu_item_add_divider(submenu);
 493         menu_item_add(submenu, _("Set as _wallpaper"), G_CALLBACK(li_pop_menu_wallpaper_cb), lw);
 494
 495         item = submenu_add_alter(menu, G_CALLBACK(li_pop_menu_alter_cb), lw);
 496
 497         item = menu_item_add_stock(menu, _("_Properties"), GTK_STOCK_PROPERTIES, G_CALLBACK(li_pop_menu_info_cb), lw);
 498         if (!path) gtk_widget_set_sensitive(item, FALSE);
 499
 500         item = menu_item_add_stock(menu, _("View in _new window"), GTK_STOCK_NEW, G_CALLBACK(li_pop_menu_new_cb), lw);
 501         if (!path || fullscreen) gtk_widget_set_sensitive(item, FALSE);
 502
 503         item = menu_item_add(menu, _("_Go to directory view"), G_CALLBACK(li_set_layout_path_cb), lw);
 504         if (!path || li_check_if_current_path(lw, path)) gtk_widget_set_sensitive(item, FALSE);
 505
 506         menu_item_add_divider(menu);
 507
 508         item = menu_item_add_stock(menu, _("_Copy..."), GTK_STOCK_COPY, G_CALLBACK(li_pop_menu_copy_cb), lw);
 509         if (!path) gtk_widget_set_sensitive(item, FALSE);
 510         item = menu_item_add(menu, _("_Move..."), G_CALLBACK(li_pop_menu_move_cb), lw);
 511         if (!path) gtk_widget_set_sensitive(item, FALSE);
 512         item = menu_item_add(menu, _("_Rename..."), G_CALLBACK(li_pop_menu_rename_cb), lw);
 513         if (!path) gtk_widget_set_sensitive(item, FALSE);
 514         item = menu_item_add_stock(menu, _("_Delete..."), GTK_STOCK_DELETE, G_CALLBACK(li_pop_menu_delete_cb), lw);
 515         if (!path) gtk_widget_set_sensitive(item, FALSE);
 516
 517         if (options->show_copy_path)
 518                 {
 519                 item = menu_item_add(menu, _("_Copy path"), G_CALLBACK(li_pop_menu_copy_path_cb), lw);
 520                 if (!path) gtk_widget_set_sensitive(item, FALSE);
 521         }
 522
 523         menu_item_add_divider(menu);
 524
 525         if (layout_image_slideshow_active(lw))
 526                 {
 527                 menu_item_add(menu, _("_Stop slideshow"), G_CALLBACK(li_pop_menu_slide_stop_cb), lw);
 528                 if (layout_image_slideshow_paused(lw))
 529                         {
 530                         item = menu_item_add(menu, _("Continue slides_how"),
 531                                              G_CALLBACK(li_pop_menu_slide_pause_cb), lw);
 532                         }
 533                 else
 534                         {
 535                         item = menu_item_add(menu, _("Pause slides_how"),
 536                                              G_CALLBACK(li_pop_menu_slide_pause_cb), lw);
 537                         }
 538                 }
 539         else
 540                 {
 541                 menu_item_add(menu, _("_Start slideshow"), G_CALLBACK(li_pop_menu_slide_start_cb), lw);
 542                 item = menu_item_add(menu, _("Pause slides_how"), G_CALLBACK(li_pop_menu_slide_pause_cb), lw);
 543                 gtk_widget_set_sensitive(item, FALSE);
 544                 }
 545
 546         if (!fullscreen)
 547                 {
 548                 menu_item_add(menu, _("_Full screen"), G_CALLBACK(li_pop_menu_full_screen_cb), lw);
 549                 }
 550         else
 551                 {
 552                 menu_item_add(menu, _("Exit _full screen"), G_CALLBACK(li_pop_menu_full_screen_cb), lw);
 553                 }
 554
 555         menu_item_add_divider(menu);
 556
 557         item = menu_item_add_check(menu, _("Hide file _list"), lw->tools_hidden,
 558                                    G_CALLBACK(li_pop_menu_hide_cb), lw);
 559         if (fullscreen) gtk_widget_set_sensitive(item, FALSE);
 560
 561         return menu;
 562 }
 563
 564 static void layout_image_menu_pos_cb(GtkMenu *menu, gint *x, gint *y, gboolean *push_in, gpointer data)
 565 {
 566         LayoutWindow *lw = data;
 567
 568         gdk_window_get_origin(lw->image->pr->window, x, y);
 569         popup_menu_position_clamp(menu, x, y, 0);
 570 }
 571
 572 void layout_image_menu_popup(LayoutWindow *lw)
 573 {
 574         GtkWidget *menu;
 575
 576         menu = layout_image_pop_menu(lw);
 577         gtk_menu_popup(GTK_MENU(menu), NULL, NULL, layout_image_menu_pos_cb, lw, 0, GDK_CURRENT_TIME);
 578 }
 579
 580 /*
 581  *----------------------------------------------------------------------------
 582  * dnd
 583  *----------------------------------------------------------------------------
 584  */
 585
 586 static void layout_image_dnd_receive(GtkWidget *widget, GdkDragContext *context,
 587                                      gint x, gint y,
 588                                      GtkSelectionData *selection_data, guint info,
 589                                      guint time, gpointer data)
 590 {
 591         LayoutWindow *lw = data;
 592         gint i;
 593
 594
 595         for (i = 0; i < MAX_SPLIT_IMAGES; i++)
 596                 {
 597                 if (lw->split_images[i] && lw->split_images[i]->pr == widget)
 598                         break;
 599                 }
 600         if (i < MAX_SPLIT_IMAGES)
 601                 {
 602                 DEBUG_1("dnd image activate %d", i);
 603                 layout_image_activate(lw, i);
 604                 }
 605
 606
 607         if (info == TARGET_URI_LIST || info == TARGET_APP_COLLECTION_MEMBER)
 608                 {
 609                 CollectionData *source;
 610                 GList *list;
 611                 GList *info_list;
 612
 613                 if (info == TARGET_URI_LIST)
 614                         {
 615                         list = uri_filelist_from_text((gchar *)selection_data->data, TRUE);
 616                         source = NULL;
 617                         info_list = NULL;
 618                         }
 619                 else
 620                         {
 621                         source = collection_from_dnd_data((gchar *)selection_data->data, &list, &info_list);
 622                         }
 623
 624                 if (list)
 625                         {
 626                         FileData *fd = list->data;
 627
 628                         if (isfile(fd->path))
 629                                 {
 630                                 gchar *base;
 631                                 gint row;
 632                                 FileData *dir_fd;
 633
 634                                 base = remove_level_from_path(fd->path);
 635                                 dir_fd = file_data_new_simple(base);
 636                                 if (dir_fd != lw->dir_fd)
 637                                         {
 638                                         layout_set_fd(lw, dir_fd);
 639                                         }
 640                                 file_data_unref(dir_fd);
 641                                 g_free(base);
 642
 643                                 row = layout_list_get_index(lw, fd);
 644                                 if (source && info_list)
 645                                         {
 646                                         layout_image_set_collection(lw, source, info_list->data);
 647                                         }
 648                                 else if (row == -1)
 649                                         {
 650                                         layout_image_set_fd(lw, fd);
 651                                         }
 652                                 else
 653                                         {
 654                                         layout_image_set_index(lw, row);
 655                                         }
 656                                 }
 657                         else if (isdir(fd->path))
 658                                 {
 659                                 layout_set_fd(lw, fd);
 660                                 layout_image_set_fd(lw, NULL);
 661                                 }
 662                         }
 663
 664                 filelist_free(list);
 665                 g_list_free(info_list);
 666                 }
 667 }
 668
 669 static void layout_image_dnd_get(GtkWidget *widget, GdkDragContext *context,
 670                                  GtkSelectionData *selection_data, guint info,
 671                                  guint time, gpointer data)
 672 {
 673         LayoutWindow *lw = data;
 674         FileData *fd;
 675         gint i;
 676
 677
 678         for (i = 0; i < MAX_SPLIT_IMAGES; i++)
 679                 {
 680                 if (lw->split_images[i] && lw->split_images[i]->pr == widget)
 681                         break;
 682                 }
 683         if (i < MAX_SPLIT_IMAGES)
 684                 {
 685                 DEBUG_1("dnd get from %d", i);
 686                 fd = image_get_fd(lw->split_images[i]);
 687                 }
 688         else
 689                 fd = layout_image_get_fd(lw);
 690
 691         if (fd)
 692                 {
 693                 gchar *text = NULL;
 694                 gint len;
 695                 gint plain_text;
 696                 GList *list;
 697
 698                 switch (info)
 699                         {
 700                         case TARGET_URI_LIST:
 701                                 plain_text = FALSE;
 702                                 break;
 703                         case TARGET_TEXT_PLAIN:
 704                         default:
 705                                 plain_text = TRUE;
 706                                 break;
 707                         }
 708                 list = g_list_append(NULL, fd);
 709                 text = uri_text_from_filelist(list, &len, plain_text);
 710                 g_list_free(list);
 711                 if (text)
 712                         {
 713                         gtk_selection_data_set(selection_data, selection_data->target,
 714                                                8, (guchar *)text, len);
 715                         g_free(text);
 716                         }
 717                 }
 718         else
 719                 {
 720                 gtk_selection_data_set(selection_data, selection_data->target,
 721                                        8, NULL, 0);
 722                 }
 723 }
 724
 725 static void layout_image_dnd_end(GtkWidget *widget, GdkDragContext *context, gpointer data)
 726 {
 727         LayoutWindow *lw = data;
 728         if (context->action == GDK_ACTION_MOVE)
 729                 {
 730                 FileData *fd;
 731                 gint row;
 732
 733                 fd = layout_image_get_fd(lw);
 734                 row = layout_list_get_index(lw, fd);
 735                 if (row < 0) return;
 736
 737                 if (!isfile(fd->path))
 738                         {
 739                         if ((guint) row < layout_list_count(lw, NULL) - 1)
 740                                 {
 741                                 layout_image_next(lw);
 742                                 }
 743                         else
 744                                 {
 745                                 layout_image_prev(lw);
 746                                 }
 747                         }
 748                 layout_refresh(lw);
 749                 }
 750 }
 751
 752 static void layout_image_dnd_init(LayoutWindow *lw, gint i)
 753 {
 754         ImageWindow *imd = lw->split_images[i];
 755
 756         gtk_drag_source_set(imd->pr, GDK_BUTTON2_MASK,
 757                             dnd_file_drag_types, dnd_file_drag_types_count,
 758                             GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
 759         g_signal_connect(G_OBJECT(imd->pr), "drag_data_get",
 760                          G_CALLBACK(layout_image_dnd_get), lw);
 761         g_signal_connect(G_OBJECT(imd->pr), "drag_end",
 762                          G_CALLBACK(layout_image_dnd_end), lw);
 763
 764         gtk_drag_dest_set(imd->pr,
 765                           GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_DROP,
 766                           dnd_file_drop_types, dnd_file_drop_types_count,
 767                           GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK);
 768         g_signal_connect(G_OBJECT(imd->pr), "drag_data_received",
 769                          G_CALLBACK(layout_image_dnd_receive), lw);
 770 }
 771
 772
 773 /*
 774  *----------------------------------------------------------------------------
 775  * misc
 776  *----------------------------------------------------------------------------
 777  */
 778
 779 void layout_image_to_root(LayoutWindow *lw)
 780 {
 781         image_to_root_window(lw->image, (image_zoom_get(lw->image) == 0));
 782 }
 783
 784 /*
 785  *----------------------------------------------------------------------------
 786  * manipulation + accessors
 787  *----------------------------------------------------------------------------
 788  */
 789
 790 void layout_image_scroll(LayoutWindow *lw, gint x, gint y)
 791 {
 792         gdouble dx, dy;
 793         gint width, height, i;
 794         if (!layout_valid(&lw)) return;
 795
 796         image_scroll(lw->image, x, y);
 797
 798         if (!lw->connect_scroll) return;
 799
 800         image_get_image_size(lw->image, &width, &height);
 801         dx = (gdouble) x / width;
 802         dy = (gdouble) y / height;
 803
 804         for (i = 0; i < MAX_SPLIT_IMAGES; i++)
 805                 {
 806                 if (lw->split_images[i] && lw->split_images[i] != lw->image)
 807                         {
 808                         gdouble sx, sy;
 809                         image_get_scroll_center(lw->split_images[i], &sx, &sy);
 810                         sx += dx;
 811                         sy += dy;
 812                         image_set_scroll_center(lw->split_images[i], sx, sy);
 813                         }
 814                 }
 815
 816 }
 817
 818 void layout_image_zoom_adjust(LayoutWindow *lw, gdouble increment)
 819 {
 820         gint i;
 821         if (!layout_valid(&lw)) return;
 822
 823         image_zoom_adjust(lw->image, increment);
 824
 825         if (!lw->connect_zoom) return;
 826
 827         for (i = 0; i < MAX_SPLIT_IMAGES; i++)
 828                 {
 829                 if (lw->split_images[i] && lw->split_images[i] != lw->image)
 830                         image_zoom_adjust(lw->split_images[i], increment); ;
 831                 }
 832 }
 833
 834 void layout_image_zoom_adjust_at_point(LayoutWindow *lw, gdouble increment, gint x, gint y)
 835 {
 836         gint i;
 837         if (!layout_valid(&lw)) return;
 838
 839         image_zoom_adjust_at_point(lw->image, increment, x, y);
 840
 841         if (!lw->connect_zoom) return;
 842
 843         for (i = 0; i < MAX_SPLIT_IMAGES; i++)
 844                 {
 845                 if (lw->split_images[i] && lw->split_images[i] != lw->image)
 846                         image_zoom_adjust_at_point(lw->split_images[i], increment, x, y);
 847                 }
 848 }
 849
 850 void layout_image_zoom_set(LayoutWindow *lw, gdouble zoom)
 851 {
 852         gint i;
 853         if (!layout_valid(&lw)) return;
 854
 855         image_zoom_set(lw->image, zoom);
 856
 857         if (!lw->connect_zoom) return;
 858
 859         for (i = 0; i < MAX_SPLIT_IMAGES; i++)
 860                 {
 861                 if (lw->split_images[i] && lw->split_images[i] != lw->image)
 862                         image_zoom_set(lw->split_images[i], zoom);
 863                 }
 864 }
 865
 866 void layout_image_zoom_set_fill_geometry(LayoutWindow *lw, gint vertical)
 867 {
 868         if (!layout_valid(&lw)) return;
 869
 870         image_zoom_set_fill_geometry(lw->image, vertical);
 871 }
 872
 873 void layout_image_alter(LayoutWindow *lw, AlterType type)
 874 {
 875         if (!layout_valid(&lw)) return;
 876
 877         image_alter(lw->image, type);
 878 }
 879
 880 const gchar *layout_image_get_path(LayoutWindow *lw)
 881 {
 882         if (!layout_valid(&lw)) return NULL;
 883
 884         return image_get_path(lw->image);
 885 }
 886
 887 const gchar *layout_image_get_name(LayoutWindow *lw)
 888 {
 889         if (!layout_valid(&lw)) return NULL;
 890
 891         return image_get_name(lw->image);
 892 }
 893
 894 FileData *layout_image_get_fd(LayoutWindow *lw)
 895 {
 896         if (!layout_valid(&lw)) return NULL;
 897
 898         return image_get_fd(lw->image);
 899 }
 900
 901 CollectionData *layout_image_get_collection(LayoutWindow *lw, CollectInfo **info)
 902 {
 903         if (!layout_valid(&lw)) return NULL;
 904
 905         return image_get_collection(lw->image, info);
 906 }
 907
 908 gint layout_image_get_index(LayoutWindow *lw)
 909 {
 910         return layout_list_get_index(lw, image_get_fd(lw->image));
 911 }
 912
 913 /*
 914  *----------------------------------------------------------------------------
 915  * image changers
 916  *----------------------------------------------------------------------------
 917  */
 918
 919 void layout_image_set_fd(LayoutWindow *lw, FileData *fd)
 920 {
 921         gdouble sx, sy;
 922         if (!layout_valid(&lw)) return;
 923
 924         image_get_scroll_center(lw->image, &sx, &sy);
 925
 926         image_change_fd(lw->image, fd, image_zoom_get_default(lw->image));
 927
 928         image_set_scroll_center(lw->image, sx, sy);
 929
 930         layout_list_sync_fd(lw, fd);
 931         layout_image_slideshow_continue_check(lw);
 932         layout_bars_new_image(lw);
 933 }
 934
 935 void layout_image_set_with_ahead(LayoutWindow *lw, FileData *fd, FileData *read_ahead_fd)
 936 {
 937         if (!layout_valid(&lw)) return;
 938
 939 /*
 940 This should be handled at the caller: in vflist_select_image
 941         if (path)
 942                 {
 943                 const gchar *old_path;
 944
 945                 old_path = layout_image_get_path(lw);
 946                 if (old_path && strcmp(path, old_path) == 0) return;
 947                 }
 948 */
 949         layout_image_set_fd(lw, fd);
 950         if (options->image.enable_read_ahead) image_prebuffer_set(lw->image, read_ahead_fd);
 951 }
 952
 953 void layout_image_set_index(LayoutWindow *lw, gint index)
 954 {
 955         FileData *fd;
 956         FileData *read_ahead_fd;
 957         gint old;
 958
 959         if (!layout_valid(&lw)) return;
 960
 961         old = layout_list_get_index(lw, layout_image_get_fd(lw));
 962         fd = layout_list_get_fd(lw, index);
 963
 964         if (old > index)
 965                 {
 966                 read_ahead_fd = layout_list_get_fd(lw, index - 1);
 967                 }
 968         else
 969                 {
 970                 read_ahead_fd = layout_list_get_fd(lw, index + 1);
 971                 }
 972
 973         if (layout_selection_count(lw, 0) > 1)
 974                 {
 975                 GList *x = layout_selection_list_by_index(lw);
 976                 GList *y;
 977                 GList *last;
 978
 979                 for (last = y = x; y; y = y->next)
 980                         last = y;
 981                 for (y = x; y && (GPOINTER_TO_INT(y->data)) != index; y = y->next)
 982                         ;
 983
 984                 if (y)
 985                         {
 986                         gint newindex;
 987
 988                         if ((index > old && (index != GPOINTER_TO_INT(last->data) || old != GPOINTER_TO_INT(x->data)))
 989                             || (old == GPOINTER_TO_INT(last->data) && index == GPOINTER_TO_INT(x->data)))
 990                                 {
 991                                 if (y->next)
 992                                         newindex = GPOINTER_TO_INT(y->next->data);
 993                                 else
 994                                         newindex = GPOINTER_TO_INT(x->data);
 995                                 }
 996                         else
 997                                 {
 998                                 if (y->prev)
 999                                         newindex = GPOINTER_TO_INT(y->prev->data);
1000                                 else
1001                                         newindex = GPOINTER_TO_INT(last->data);
1002                                 }
1003
1004                         read_ahead_fd = layout_list_get_fd(lw, newindex);
1005                         }
1006
1007                 while (x)
1008                         x = g_list_remove(x, x->data);
1009                 }
1010
1011         layout_image_set_with_ahead(lw, fd, read_ahead_fd);
1012 }
1013
1014 static void layout_image_set_collection_real(LayoutWindow *lw, CollectionData *cd, CollectInfo *info, gint forward)
1015 {
1016         if (!layout_valid(&lw)) return;
1017
1018         image_change_from_collection(lw->image, cd, info, image_zoom_get_default(lw->image));
1019         if (options->image.enable_read_ahead)
1020                 {
1021                 CollectInfo *r_info;
1022                 if (forward)
1023                         {
1024                         r_info = collection_next_by_info(cd, info);
1025                         if (!r_info) r_info = collection_prev_by_info(cd, info);
1026                         }
1027                 else
1028                         {
1029                         r_info = collection_prev_by_info(cd, info);
1030                         if (!r_info) r_info = collection_next_by_info(cd, info);
1031                         }
1032                 if (r_info) image_prebuffer_set(lw->image, r_info->fd);
1033                 }
1034
1035         layout_image_slideshow_continue_check(lw);
1036         layout_bars_new_image(lw);
1037 }
1038
1039 void layout_image_set_collection(LayoutWindow *lw, CollectionData *cd, CollectInfo *info)
1040 {
1041         layout_image_set_collection_real(lw, cd, info, TRUE);
1042         layout_list_sync_fd(lw, layout_image_get_fd(lw));
1043 }
1044
1045 void layout_image_refresh(LayoutWindow *lw)
1046 {
1047         gdouble sx, sy;
1048         if (!layout_valid(&lw)) return;
1049
1050         image_get_scroll_center(lw->image, &sx, &sy);
1051         image_reload(lw->image);
1052         image_set_scroll_center(lw->image, sx, sy);
1053 }
1054
1055 void layout_image_color_profile_set(LayoutWindow *lw,
1056                                     gint input_type, gint screen_type,
1057                                     gint use_image)
1058 {
1059         if (!layout_valid(&lw)) return;
1060
1061         image_color_profile_set(lw->image, input_type, screen_type, use_image);
1062 }
1063
1064 gint layout_image_color_profile_get(LayoutWindow *lw,
1065                                     gint *input_type, gint *screen_type,
1066                                     gint *use_image)
1067 {
1068         if (!layout_valid(&lw)) return FALSE;
1069
1070         return image_color_profile_get(lw->image, input_type, screen_type, use_image);
1071 }
1072
1073 void layout_image_color_profile_set_use(LayoutWindow *lw, gint enable)
1074 {
1075         if (!layout_valid(&lw)) return;
1076
1077         image_color_profile_set_use(lw->image, enable);
1078
1079         if (lw->info_color)
1080                 {
1081 #ifndef HAVE_LCMS
1082                 enable = FALSE;
1083 #endif
1084                 gtk_widget_set_sensitive(GTK_BIN(lw->info_color)->child, enable);
1085                 }
1086 }
1087
1088 gint layout_image_color_profile_get_use(LayoutWindow *lw)
1089 {
1090         if (!layout_valid(&lw)) return FALSE;
1091
1092         return image_color_profile_get_use(lw->image);
1093 }
1094
1095 gint layout_image_color_profile_get_from_image(LayoutWindow *lw)
1096 {
1097         if (!layout_valid(&lw)) return FALSE;
1098
1099         return image_color_profile_get_from_image(lw->image);
1100 }
1101
1102 /*
1103  *----------------------------------------------------------------------------
1104  * list walkers
1105  *----------------------------------------------------------------------------
1106  */
1107
1108 void layout_image_next(LayoutWindow *lw)
1109 {
1110         gint current;
1111         CollectionData *cd;
1112         CollectInfo *info;
1113
1114         if (!layout_valid(&lw)) return;
1115
1116         if (layout_image_slideshow_active(lw))
1117                 {
1118                 layout_image_slideshow_next(lw);
1119                 return;
1120                 }
1121
1122         if (layout_selection_count(lw, 0) > 1)
1123                 {
1124                 GList *x = layout_selection_list_by_index(lw);
1125                 gint old = layout_list_get_index(lw, layout_image_get_fd(lw));
1126                 GList *y;
1127
1128                 for (y = x; y && (GPOINTER_TO_INT(y->data)) != old; y = y->next)
1129                         ;
1130                 if (y)
1131                         {
1132                         if (y->next)
1133                                 layout_image_set_index(lw, GPOINTER_TO_INT(y->next->data));
1134                         else
1135                                 layout_image_set_index(lw, GPOINTER_TO_INT(x->data));
1136                         }
1137                 while (x)
1138                         x = g_list_remove(x, x->data);
1139                 if (y) /* not dereferenced */
1140                         return;
1141                 }
1142
1143         cd = image_get_collection(lw->image, &info);
1144
1145         if (cd && info)
1146                 {
1147                 info = collection_next_by_info(cd, info);
1148                 if (info)
1149                         {
1150                         layout_image_set_collection_real(lw, cd, info, TRUE);
1151                         }
1152                 else
1153                         {
1154                         image_osd_icon(lw->image, IMAGE_OSD_LAST, -1);
1155                         }
1156                 return;
1157                 }
1158
1159         current = layout_image_get_index(lw);
1160
1161         if (current >= 0)
1162                 {
1163                 if ((guint) current < layout_list_count(lw, NULL) - 1)
1164                         {
1165                         layout_image_set_index(lw, current + 1);
1166                         }
1167                 else
1168                         {
1169                         image_osd_icon(lw->image, IMAGE_OSD_LAST, -1);
1170                         }
1171                 }
1172         else
1173                 {
1174                 layout_image_set_index(lw, 0);
1175                 }
1176 }
1177
1178 void layout_image_prev(LayoutWindow *lw)
1179 {
1180         gint current;
1181         CollectionData *cd;
1182         CollectInfo *info;
1183
1184         if (!layout_valid(&lw)) return;
1185
1186         if (layout_image_slideshow_active(lw))
1187                 {
1188                 layout_image_slideshow_prev(lw);
1189                 return;
1190                 }
1191
1192         if (layout_selection_count(lw, 0) > 1)
1193                 {
1194                 GList *x = layout_selection_list_by_index(lw);
1195                 gint old = layout_list_get_index(lw, layout_image_get_fd(lw));
1196                 GList *y;
1197                 GList *last;
1198
1199                 for (last = y = x; y; y = y->next)
1200                         last = y;
1201                 for (y = x; y && (GPOINTER_TO_INT(y->data)) != old; y = y->next)
1202                         ;
1203                 if (y)
1204                         {
1205                         if (y->prev)
1206                                 layout_image_set_index(lw, GPOINTER_TO_INT(y->prev->data));
1207                         else
1208                                 layout_image_set_index(lw, GPOINTER_TO_INT(last->data));
1209                         }
1210                 while (x)
1211                         x = g_list_remove(x, x->data);
1212                 if (y) /* not dereferenced */
1213                         return;
1214                 }
1215
1216         cd = image_get_collection(lw->image, &info);
1217
1218         if (cd && info)
1219                 {
1220                 info = collection_prev_by_info(cd, info);
1221                 if (info)
1222                         {
1223                         layout_image_set_collection_real(lw, cd, info, FALSE);
1224                         }
1225                 else
1226                         {
1227                         image_osd_icon(lw->image, IMAGE_OSD_FIRST, -1);
1228                         }
1229                 return;
1230                 }
1231
1232         current = layout_image_get_index(lw);
1233
1234         if (current >= 0)
1235                 {
1236                 if (current > 0)
1237                         {
1238                         layout_image_set_index(lw, current - 1);
1239                         }
1240                 else
1241                         {
1242                         image_osd_icon(lw->image, IMAGE_OSD_FIRST, -1);
1243                         }
1244                 }
1245         else
1246                 {
1247                 layout_image_set_index(lw, layout_list_count(lw, NULL) - 1);
1248                 }
1249 }
1250
1251 void layout_image_first(LayoutWindow *lw)
1252 {
1253         gint current;
1254         CollectionData *cd;
1255         CollectInfo *info;
1256
1257         if (!layout_valid(&lw)) return;
1258
1259         cd = image_get_collection(lw->image, &info);
1260
1261         if (cd && info)
1262                 {
1263                 CollectInfo *new;
1264                 new = collection_get_first(cd);
1265                 if (new != info) layout_image_set_collection_real(lw, cd, new, TRUE);
1266                 return;
1267                 }
1268
1269         current = layout_image_get_index(lw);
1270         if (current != 0 && layout_list_count(lw, NULL) > 0)
1271                 {
1272                 layout_image_set_index(lw, 0);
1273                 }
1274 }
1275
1276 void layout_image_last(LayoutWindow *lw)
1277 {
1278         gint current;
1279         gint count;
1280         CollectionData *cd;
1281         CollectInfo *info;
1282
1283         if (!layout_valid(&lw)) return;
1284
1285         cd = image_get_collection(lw->image, &info);
1286
1287         if (cd && info)
1288                 {
1289                 CollectInfo *new;
1290                 new = collection_get_last(cd);
1291                 if (new != info) layout_image_set_collection_real(lw, cd, new, FALSE);
1292                 return;
1293                 }
1294
1295         current = layout_image_get_index(lw);
1296         count = layout_list_count(lw, NULL);
1297         if (current != count - 1 && count > 0)
1298                 {
1299                 layout_image_set_index(lw, count - 1);
1300                 }
1301 }
1302
1303 /*
1304  *----------------------------------------------------------------------------
1305  * mouse callbacks
1306  *----------------------------------------------------------------------------
1307  */
1308
1309 static gint image_idx(LayoutWindow *lw, ImageWindow *imd)
1310 {
1311         gint i;
1312
1313         for (i = 0; i < MAX_SPLIT_IMAGES; i++)
1314                 {
1315                 if (lw->split_images[i] == imd)
1316                         break;
1317                 }
1318         if (i < MAX_SPLIT_IMAGES)
1319                 {
1320                 return i;
1321                 }
1322         return -1;
1323 }
1324
1325
1326 static void layout_image_button_cb(ImageWindow *imd, GdkEventButton *event, gpointer data)
1327 {
1328         LayoutWindow *lw = data;
1329         GtkWidget *menu;
1330
1331         switch (event->button)
1332                 {
1333                 case MOUSE_BUTTON_LEFT:
1334                         layout_image_next(lw);
1335                         break;
1336                 case MOUSE_BUTTON_MIDDLE:
1337                         layout_image_prev(lw);
1338                         break;
1339                 case MOUSE_BUTTON_RIGHT:
1340                         menu = layout_image_pop_menu(lw);
1341                         if (imd == lw->image)
1342                                 {
1343                                 g_object_set_data(G_OBJECT(menu), "click_parent", imd->widget);
1344                                 }
1345                         gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 3, event->time);
1346                         break;
1347                 default:
1348                         break;
1349                 }
1350 }
1351
1352 static void layout_image_scroll_cb(ImageWindow *imd, GdkEventScroll *event, gpointer data)
1353 {
1354         LayoutWindow *lw = data;
1355
1356         gint i = image_idx(lw, imd);
1357
1358         if (i != -1)
1359                 {
1360                 DEBUG_1("image activate scroll %d", i);
1361                 layout_image_activate(lw, i);
1362                 }
1363
1364
1365         if (event->state & GDK_CONTROL_MASK)
1366                 {
1367                 switch (event->direction)
1368                         {
1369                         case GDK_SCROLL_UP:
1370                                 layout_image_zoom_adjust_at_point(lw, get_zoom_increment(), event->x, event->y);
1371                                 break;
1372                         case GDK_SCROLL_DOWN:
1373                                 layout_image_zoom_adjust_at_point(lw, -get_zoom_increment(), event->x, event->y);
1374                                 break;
1375                         default:
1376                                 break;
1377                         }
1378                 }
1379         else if ( (event->state & GDK_SHIFT_MASK) != (guint) (options->mousewheel_scrolls))
1380                 {
1381                 switch (event->direction)
1382                         {
1383                         case GDK_SCROLL_UP:
1384                                 image_scroll(imd, 0, -MOUSEWHEEL_SCROLL_SIZE);
1385                                 break;
1386                         case GDK_SCROLL_DOWN:
1387                                 image_scroll(imd, 0, MOUSEWHEEL_SCROLL_SIZE);
1388                                 break;
1389                         case GDK_SCROLL_LEFT:
1390                                 image_scroll(imd, -MOUSEWHEEL_SCROLL_SIZE, 0);
1391                                 break;
1392                         case GDK_SCROLL_RIGHT:
1393                                 image_scroll(imd, MOUSEWHEEL_SCROLL_SIZE, 0);
1394                                 break;
1395                         default:
1396                                 break;
1397                         }
1398                 }
1399         else
1400                 {
1401                 switch (event->direction)
1402                         {
1403                         case GDK_SCROLL_UP:
1404                                 layout_image_prev(lw);
1405                                 break;
1406                         case GDK_SCROLL_DOWN:
1407                                 layout_image_next(lw);
1408                                 break;
1409                         default:
1410                                 break;
1411                         }
1412                 }
1413 }
1414
1415 static void layout_image_drag_cb(ImageWindow *imd, GdkEventButton *event, gdouble dx, gdouble dy, gpointer data)
1416 {
1417         gint i;
1418         LayoutWindow *lw = data;
1419
1420         if (!lw->connect_scroll) return;
1421
1422         for (i = 0; i < MAX_SPLIT_IMAGES; i++)
1423                 {
1424                 if (lw->split_images[i] && lw->split_images[i] != imd)
1425                         {
1426                         gdouble sx, sy;
1427
1428                         if (event->state & GDK_CONTROL_MASK)
1429                                 {
1430                                 image_get_scroll_center(imd, &sx, &sy);
1431                                 }
1432                         else
1433                                 {
1434                                 image_get_scroll_center(lw->split_images[i], &sx, &sy);
1435                                 sx += dx;
1436                                 sy += dy;
1437                                 }
1438                         image_set_scroll_center(lw->split_images[i], sx, sy);
1439                         }
1440                 }
1441 }
1442
1443 static void layout_image_button_inactive_cb(ImageWindow *imd, GdkEventButton *event, gpointer data)
1444 {
1445         LayoutWindow *lw = data;
1446         GtkWidget *menu;
1447         gint i = image_idx(lw, imd);
1448
1449         if (i != -1)
1450                 {
1451                 layout_image_activate(lw, i);
1452                 }
1453
1454         switch (event->button)
1455                 {
1456                 case MOUSE_BUTTON_RIGHT:
1457                         menu = layout_image_pop_menu(lw);
1458                         if (imd == lw->image)
1459                                 {
1460                                 g_object_set_data(G_OBJECT(menu), "click_parent", imd->widget);
1461                                 }
1462                         gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, 3, event->time);
1463                         break;
1464                 default:
1465                         break;
1466                 }
1467
1468 }
1469
1470 static void layout_image_drag_inactive_cb(ImageWindow *imd, GdkEventButton *event, gdouble dx, gdouble dy, gpointer data)
1471 {
1472         LayoutWindow *lw = data;
1473         gint i = image_idx(lw, imd);
1474
1475         if (i != -1)
1476                 {
1477                 layout_image_activate(lw, i);
1478                 }
1479
1480         /* continue as with active image */
1481         layout_image_drag_cb(imd, event, dx, dy, data);
1482 }
1483
1484
1485 static void layout_image_set_buttons(LayoutWindow *lw)
1486 {
1487         image_set_button_func(lw->image, layout_image_button_cb, lw);
1488         image_set_scroll_func(lw->image, layout_image_scroll_cb, lw);
1489 }
1490
1491 static void layout_image_set_buttons_inactive(LayoutWindow *lw, gint i)
1492 {
1493         image_set_button_func(lw->split_images[i], layout_image_button_inactive_cb, lw);
1494         image_set_scroll_func(lw->split_images[i], layout_image_scroll_cb, lw);
1495 }
1496
1497 /*
1498  *----------------------------------------------------------------------------
1499  * setup
1500  *----------------------------------------------------------------------------
1501  */
1502
1503 static void layout_image_update_cb(ImageWindow *imd, gpointer data)
1504 {
1505         LayoutWindow *lw = data;
1506         layout_status_update_image(lw);
1507 }
1508
1509 GtkWidget *layout_image_new(LayoutWindow *lw, gint i)
1510 {
1511         if (!lw->split_image_sizegroup) lw->split_image_sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_BOTH);
1512
1513         if (!lw->split_images[i])
1514                 {
1515                 lw->split_images[i] = image_new(TRUE);
1516
1517                 gtk_widget_ref(lw->split_images[i]->widget);
1518
1519                 image_background_set_color(lw->split_images[i], options->image.use_custom_border_color ? &options->image.border_color : NULL);
1520
1521                 image_auto_refresh_enable(lw->split_images[i], TRUE);
1522
1523                 layout_image_dnd_init(lw, i);
1524                 image_color_profile_set(lw->split_images[i],
1525                                         options->color_profile.input_type,
1526                                         options->color_profile.screen_type,
1527                                         options->color_profile.use_image);
1528                 image_color_profile_set_use(lw->split_images[i], options->color_profile.enabled);
1529
1530                 gtk_size_group_add_widget(lw->split_image_sizegroup, lw->split_images[i]->widget);
1531                 }
1532
1533         return lw->split_images[i]->widget;
1534 }
1535
1536 void layout_image_deactivate(LayoutWindow *lw, gint i)
1537 {
1538
1539         if (!lw->split_images[i]) return;
1540         image_set_update_func(lw->split_images[i], NULL, NULL);
1541         layout_image_set_buttons_inactive(lw, i);
1542         image_set_drag_func(lw->split_images[i], layout_image_drag_inactive_cb, lw);
1543
1544         image_attach_window(lw->split_images[i], NULL, NULL, NULL, FALSE);
1545         image_select(lw->split_images[i], FALSE);
1546 }
1547
1548
1549 void layout_image_activate(LayoutWindow *lw, gint i)
1550 {
1551         FileData *fd;
1552
1553         if (!lw->split_images[i]) return;
1554
1555         /* deactivate currently active */
1556         if (lw->active_split_image != i)
1557                 layout_image_deactivate(lw, lw->active_split_image);
1558
1559         lw->image = lw->split_images[i];
1560         lw->active_split_image = i;
1561
1562         image_set_update_func(lw->image, layout_image_update_cb, lw);
1563         layout_image_set_buttons(lw);
1564         image_set_drag_func(lw->image, layout_image_drag_cb, lw);
1565
1566         image_attach_window(lw->image, lw->window, NULL, GQ_APPNAME, FALSE);
1567
1568         /* do not hilight selected image in SPLIT_NONE */
1569         /* maybe the image should be selected always and hilight should be controled by
1570            another image option */
1571         if (lw->split_mode != SPLIT_NONE)
1572                 image_select(lw->split_images[i], TRUE);
1573         else
1574                 image_select(lw->split_images[i], FALSE);
1575
1576         fd = image_get_fd(lw->image);
1577
1578         if (fd)
1579                 {
1580 //              layout_list_sync_path(lw, path);
1581                 layout_set_fd(lw, fd);
1582                 }
1583 }
1584
1585
1586 GtkWidget *layout_image_setup_split_none(LayoutWindow *lw)
1587 {
1588         gint i;
1589
1590         lw->split_mode = SPLIT_NONE;
1591
1592         if (!lw->split_images[0])
1593                 {
1594                 layout_image_new(lw, 0);
1595                 image_set_frame(lw->split_images[0], (!lw->tools_float && !lw->tools_hidden));
1596                 image_set_selectable(lw->split_images[0], 0);
1597                 layout_image_activate(lw, 0);
1598                 }
1599         else
1600                 {
1601                 image_set_frame(lw->split_images[0], (!lw->tools_float && !lw->tools_hidden));
1602                 image_set_selectable(lw->split_images[0], 0);
1603                 }
1604
1605         for (i = 1; i < MAX_SPLIT_IMAGES; i++)
1606                 {
1607                 if (lw->split_images[i])
1608                         {
1609                         gtk_widget_unref(lw->split_images[i]->widget);
1610                         lw->split_images[i] = NULL;
1611                         }
1612                 }
1613
1614
1615         layout_image_activate(lw, 0);
1616
1617         lw->split_image_widget = lw->split_images[0]->widget;
1618
1619         return lw->split_image_widget;
1620 }
1621
1622 GtkWidget *layout_image_setup_split_hv(LayoutWindow *lw, gboolean horizontal)
1623 {
1624         GtkWidget *paned;
1625         gint i;
1626
1627         lw->split_mode = horizontal ? SPLIT_HOR : SPLIT_VERT;
1628
1629         if (!lw->split_images[0])
1630                 {
1631                 layout_image_new(lw, 0);
1632                 }
1633         image_set_frame(lw->split_images[0], 1);
1634         image_set_selectable(lw->split_images[0], 1);
1635
1636         if (!lw->split_images[1])
1637                 {
1638                 layout_image_new(lw, 1);
1639                 image_set_frame(lw->split_images[1], 1);
1640                 image_set_selectable(lw->split_images[1], 1);
1641                 if (lw->image)
1642                         {
1643                         gdouble sx, sy;
1644                         image_change_fd(lw->split_images[1],
1645                                         image_get_fd(lw->image), image_zoom_get(lw->image));
1646                         image_get_scroll_center(lw->image, &sx, &sy);
1647                         image_set_scroll_center(lw->split_images[1], sx, sy);
1648                         }
1649                 layout_image_deactivate(lw, 1);
1650                 layout_image_activate(lw, 0);
1651                 }
1652         else
1653                 {
1654                 image_set_frame(lw->split_images[1], 1);
1655                 image_set_selectable(lw->split_images[1], 1);
1656                 }
1657
1658
1659         for (i = 2; i < MAX_SPLIT_IMAGES; i++)
1660                 {
1661                 if (lw->split_images[i])
1662                         {
1663                         gtk_widget_unref(lw->split_images[i]->widget);
1664                         lw->split_images[i] = NULL;
1665                         }
1666                 }
1667
1668         if (!lw->image || lw->active_split_image < 0 || lw->active_split_image > 1)
1669                 {
1670                 layout_image_activate(lw, 0);
1671                 }
1672
1673         /* horizontal split means vpaned and vice versa */
1674         if (horizontal)
1675                 paned = gtk_vpaned_new();
1676         else
1677                 paned = gtk_hpaned_new();
1678
1679         gtk_paned_pack1(GTK_PANED(paned), lw->split_images[0]->widget, TRUE, TRUE);
1680         gtk_paned_pack2(GTK_PANED(paned), lw->split_images[1]->widget, TRUE, TRUE);
1681
1682         gtk_widget_show(lw->split_images[0]->widget);
1683         gtk_widget_show(lw->split_images[1]->widget);
1684
1685         lw->split_image_widget = paned;
1686
1687         return lw->split_image_widget;
1688
1689 }
1690
1691 GtkWidget *layout_image_setup_split_quad(LayoutWindow *lw)
1692 {
1693         GtkWidget *hpaned;
1694         GtkWidget *vpaned1;
1695         GtkWidget *vpaned2;
1696         gint i;
1697
1698         lw->split_mode = SPLIT_QUAD;
1699
1700         if (!lw->split_images[0])
1701                 {
1702                 layout_image_new(lw, 0);
1703                 }
1704
1705         image_set_frame(lw->split_images[0], 1);
1706         image_set_selectable(lw->split_images[0], 1);
1707
1708         if (!lw->split_images[1])
1709                 {
1710                 layout_image_activate(lw, 0);
1711                 }
1712
1713         for (i = 1; i < 4; i++)
1714                 if (!lw->split_images[i])
1715                         {
1716                         layout_image_new(lw, i);
1717                         image_set_frame(lw->split_images[i], 1);
1718                         image_set_selectable(lw->split_images[i], 1);
1719                         if (lw->image)
1720                                 {
1721                                 gdouble sx, sy;
1722                                 image_change_fd(lw->split_images[i],
1723                                         image_get_fd(lw->image), image_zoom_get(lw->image));
1724                                 image_get_scroll_center(lw->image, &sx, &sy);
1725                                 image_set_scroll_center(lw->split_images[i], sx, sy);
1726                                 }
1727                         layout_image_deactivate(lw, i);
1728                         }
1729                 else
1730                         {
1731                         image_set_frame(lw->split_images[i], 1);
1732                         image_set_selectable(lw->split_images[i], 1);
1733                         }
1734
1735         for (i = 4; i < MAX_SPLIT_IMAGES; i++)
1736                 {
1737                 if (lw->split_images[i])
1738                         {
1739                         gtk_widget_unref(lw->split_images[i]->widget);
1740                         lw->split_images[i] = NULL;
1741                         }
1742                 }
1743
1744
1745         if (!lw->image || lw->active_split_image < 0 || lw->active_split_image > 3)
1746                 {
1747                 layout_image_activate(lw, 0);
1748                 }
1749
1750         hpaned = gtk_hpaned_new();
1751         vpaned1 = gtk_vpaned_new();
1752         vpaned2 = gtk_vpaned_new();
1753
1754         gtk_paned_pack1(GTK_PANED(vpaned1), lw->split_images[0]->widget, TRUE, TRUE);
1755         gtk_paned_pack2(GTK_PANED(vpaned1), lw->split_images[2]->widget, TRUE, TRUE);
1756
1757         gtk_paned_pack1(GTK_PANED(vpaned2), lw->split_images[1]->widget, TRUE, TRUE);
1758         gtk_paned_pack2(GTK_PANED(vpaned2), lw->split_images[3]->widget, TRUE, TRUE);
1759
1760         gtk_paned_pack1(GTK_PANED(hpaned), vpaned1, TRUE, TRUE);
1761         gtk_paned_pack2(GTK_PANED(hpaned), vpaned2, TRUE, TRUE);
1762
1763
1764         for (i = 0; i < 4; i++)
1765                 gtk_widget_show(lw->split_images[i]->widget);
1766
1767         gtk_widget_show(vpaned1);
1768         gtk_widget_show(vpaned2);
1769
1770
1771         lw->split_image_widget = hpaned;
1772
1773         return lw->split_image_widget;
1774
1775 }
1776
1777 GtkWidget *layout_image_setup_split(LayoutWindow *lw, ImageSplitMode mode)
1778 {
1779         switch (mode)
1780                 {
1781                 case SPLIT_HOR:
1782                         return layout_image_setup_split_hv(lw, TRUE);
1783                 case SPLIT_VERT:
1784                         return layout_image_setup_split_hv(lw, FALSE);
1785                 case SPLIT_QUAD:
1786                         return layout_image_setup_split_quad(lw);
1787                 case SPLIT_NONE:
1788                 default:
1789                         return layout_image_setup_split_none(lw);
1790                 }
1791 }
1792
1793
1794 /*
1795  *-----------------------------------------------------------------------------
1796  * maintenance (for rename, move, remove)
1797  *-----------------------------------------------------------------------------
1798  */
1799
1800 static void layout_image_maint_renamed(LayoutWindow *lw, FileData *fd)
1801 {
1802         FileData *img_fd;
1803
1804         img_fd = layout_image_get_fd(lw);
1805         if (img_fd == fd)
1806                 {
1807                 image_set_fd(lw->image, fd);
1808                 layout_bars_maint_renamed(lw);
1809                 }
1810 }
1811
1812 static void layout_image_maint_removed(LayoutWindow *lw, FileData *fd)
1813 {
1814         FileData *img_fd;
1815
1816         img_fd = layout_image_get_fd(lw);
1817         if (img_fd == fd)
1818                 {
1819                 CollectionData *cd;
1820                 CollectInfo *info;
1821
1822                 cd = image_get_collection(lw->image, &info);
1823                 if (cd && info)
1824                         {
1825                         CollectInfo *new;
1826
1827                         new = collection_next_by_info(cd, info);
1828                         if (!new) new = collection_prev_by_info(cd, info);
1829
1830                         if (new)
1831                                 {
1832                                 layout_image_set_collection(lw, cd, new);
1833                                 return;
1834                                 }
1835                         }
1836
1837                 layout_image_set_fd(lw, NULL);
1838                 }
1839 }
1840
1841
1842 void layout_image_notify_cb(FileData *fd, NotifyType type, gpointer data)
1843 {
1844         LayoutWindow *lw = data;
1845
1846         if (type != NOTIFY_TYPE_CHANGE || !fd->change) return;
1847
1848         switch(fd->change->type)
1849                 {
1850                 case FILEDATA_CHANGE_MOVE:
1851                 case FILEDATA_CHANGE_RENAME:
1852                         layout_image_maint_renamed(lw, fd);
1853                         break;
1854                 case FILEDATA_CHANGE_DELETE:
1855                         layout_image_maint_removed(lw, fd);
1856                         break;
1857                 case FILEDATA_CHANGE_COPY:
1858                 case FILEDATA_CHANGE_UNSPECIFIED:
1859                         break;
1860                 }
1861
1862 }