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