src/layout_image.c

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