src/pixbuf-renderer.c

   1 /*
   2  * Geeqie
   3  * (C) 2006 John Ellis
   4  * Copyright (C) 2008 - 2010 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 <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <math.h>
  17
  18 #include "main.h"
  19 #include "pixbuf-renderer.h"
  20
  21 #include "intl.h"
  22 #include "layout.h"
  23
  24 #include <gtk/gtk.h>
  25
  26
  27 /* comment this out if not using this from within Geeqie
  28  * defining GQ_BUILD does these things:
  29  *   - Sets the shift-click scroller pixbuf to a nice icon instead of a black box
  30  */
  31 #define GQ_BUILD 1
  32
  33 #ifdef GQ_BUILD
  34 #include "main.h"
  35 #include "pixbuf_util.h"
  36 #include "exif.h"
  37 #else
  38 typedef enum {
  39         EXIF_ORIENTATION_UNKNOWN        = 0,
  40         EXIF_ORIENTATION_TOP_LEFT       = 1,
  41         EXIF_ORIENTATION_TOP_RIGHT      = 2,
  42         EXIF_ORIENTATION_BOTTOM_RIGHT   = 3,
  43         EXIF_ORIENTATION_BOTTOM_LEFT    = 4,
  44         EXIF_ORIENTATION_LEFT_TOP       = 5,
  45         EXIF_ORIENTATION_RIGHT_TOP      = 6,
  46         EXIF_ORIENTATION_RIGHT_BOTTOM   = 7,
  47         EXIF_ORIENTATION_LEFT_BOTTOM    = 8
  48 } ExifOrientationType;
  49 #endif
  50
  51
  52 /* size to use when breaking up image pane for rendering */
  53 #define PR_TILE_SIZE 128
  54
  55 /* default size of tile cache (mb) */
  56 #define PR_CACHE_SIZE_DEFAULT 8
  57
  58 /* default min and max zoom */
  59 #define PR_ZOOM_MIN -32.0
  60 #define PR_ZOOM_MAX 32.0
  61
  62 /* distance to drag mouse to disable image flip */
  63 #define PR_DRAG_SCROLL_THRESHHOLD 4
  64
  65 /* increase pan rate when holding down shift */
  66 #define PR_PAN_SHIFT_MULTIPLIER 6
  67
  68 /* scroller config */
  69 #define PR_SCROLLER_UPDATES_PER_SEC 30
  70 #define PR_SCROLLER_DEAD_ZONE 6
  71
  72 /* alpha channel checkerboard background (same as gimp) */
  73 #define PR_ALPHA_CHECK1 0x00999999
  74 #define PR_ALPHA_CHECK2 0x00666666
  75 #define PR_ALPHA_CHECK_SIZE 16
  76
  77 /* when scaling image to below this size, use nearest pixel for scaling
  78  * (below about 4, the other scale types become slow generating their conversion tables)
  79  */
  80 #define PR_MIN_SCALE_SIZE 8
  81
  82 /* round A up/down to integer count of B */
  83 #define ROUND_UP(A,B)   ((gint)(((A)+(B)-1)/(B))*(B))
  84 #define ROUND_DOWN(A,B) ((gint)(((A))/(B))*(B))
  85
  86 typedef enum {
  87         TILE_RENDER_NONE = 0,   /* do nothing */
  88         TILE_RENDER_AREA,       /* render an area of the tile */
  89         TILE_RENDER_ALL         /* render the whole tile */
  90 } ImageTileRenderType;
  91
  92 typedef struct _ImageTile ImageTile;
  93 typedef struct _QueueData QueueData;
  94
  95 struct _ImageTile
  96 {
  97         GdkPixmap *pixmap;      /* off screen buffer */
  98         GdkPixbuf *pixbuf;      /* pixbuf area for zooming */
  99         gint x;                 /* x offset into image */
 100         gint y;                 /* y offset into image */
 101         gint w;                 /* width that is visible (may be less if at edge of image) */
 102         gint h;                 /* height '' */
 103
 104         gboolean blank;
 105
 106 /* render_todo: (explanation)
 107         NONE    do nothing
 108         AREA    render area of tile, usually only used when loading an image
 109                 note: will jump to an ALL if render_done is not ALL.
 110         ALL     render entire tile, if never done before w/ ALL, for expose events *only*
 111 */
 112
 113         ImageTileRenderType render_todo;        /* what to do (see above) */
 114         ImageTileRenderType render_done;        /* highest that has been done before on tile */
 115
 116         QueueData *qd;
 117         QueueData *qd2;
 118
 119         guint size;             /* est. memory used by pixmap and pixbuf */
 120 };
 121
 122 struct _QueueData
 123 {
 124         ImageTile *it;
 125         gint x;
 126         gint y;
 127         gint w;
 128         gint h;
 129         gboolean new_data;
 130 };
 131
 132 typedef struct _SourceTile SourceTile;
 133 struct _SourceTile
 134 {
 135         gint x;
 136         gint y;
 137         GdkPixbuf *pixbuf;
 138         gboolean blank;
 139 };
 140
 141 typedef struct _OverlayData OverlayData;
 142 struct _OverlayData
 143 {
 144         gint id;
 145
 146         GdkPixbuf *pixbuf;
 147         GdkWindow *window;
 148
 149         gint x;
 150         gint y;
 151
 152         OverlayRendererFlags flags;
 153 };
 154
 155 enum {
 156         SIGNAL_ZOOM = 0,
 157         SIGNAL_CLICKED,
 158         SIGNAL_SCROLL_NOTIFY,
 159         SIGNAL_RENDER_COMPLETE,
 160         SIGNAL_DRAG,
 161         SIGNAL_UPDATE_PIXEL,
 162         SIGNAL_COUNT
 163 };
 164
 165 enum {
 166         PROP_0,
 167         PROP_ZOOM_MIN,
 168         PROP_ZOOM_MAX,
 169         PROP_ZOOM_QUALITY,
 170         PROP_ZOOM_2PASS,
 171         PROP_ZOOM_EXPAND,
 172         PROP_DITHER_QUALITY,
 173         PROP_SCROLL_RESET,
 174         PROP_DELAY_FLIP,
 175         PROP_LOADING,
 176         PROP_COMPLETE,
 177         PROP_CACHE_SIZE_DISPLAY,
 178         PROP_CACHE_SIZE_TILES,
 179         PROP_WINDOW_FIT,
 180         PROP_WINDOW_LIMIT,
 181         PROP_WINDOW_LIMIT_VALUE,
 182         PROP_AUTOFIT_LIMIT,
 183         PROP_AUTOFIT_LIMIT_VALUE
 184 };
 185
 186 typedef enum {
 187         PR_ZOOM_NONE            = 0,
 188         PR_ZOOM_FORCE           = 1 << 0,
 189         PR_ZOOM_NEW             = 1 << 1,
 190         PR_ZOOM_CENTER          = 1 << 2,
 191         PR_ZOOM_INVALIDATE      = 1 << 3,
 192         PR_ZOOM_LAZY            = 1 << 4  /* wait with redraw for pixbuf_renderer_area_changed */
 193 } PrZoomFlags;
 194
 195 static guint signals[SIGNAL_COUNT] = { 0 };
 196 static GtkEventBoxClass *parent_class = NULL;
 197
 198
 199
 200 static void pixbuf_renderer_class_init(PixbufRendererClass *class);
 201 static void pixbuf_renderer_init(PixbufRenderer *pr);
 202 static void pixbuf_renderer_finalize(GObject *object);
 203 static void pixbuf_renderer_set_property(GObject *object, guint prop_id,
 204                                          const GValue *value, GParamSpec *pspec);
 205 static void pixbuf_renderer_get_property(GObject *object, guint prop_id,
 206                                          GValue *value, GParamSpec *pspec);
 207 static gboolean pixbuf_renderer_expose(GtkWidget *widget, GdkEventExpose *event);
 208
 209 static void pr_render_complete_signal(PixbufRenderer *pr);
 210
 211 static void pr_overlay_list_clear(PixbufRenderer *pr);
 212 static void pr_scroller_timer_set(PixbufRenderer *pr, gboolean start);
 213 static void pr_border_draw(PixbufRenderer *pr, gint x, gint y, gint w, gint h);
 214
 215
 216 static void pr_source_tile_free_all(PixbufRenderer *pr);
 217 static void pr_tile_free_all(PixbufRenderer *pr);
 218 static void pr_tile_invalidate_region(PixbufRenderer *pr, gint x, gint y, gint w, gint h);
 219 static gboolean pr_tile_is_visible(PixbufRenderer *pr, ImageTile *it);
 220 static void pr_queue_clear(PixbufRenderer *pr);
 221 static void pr_queue_merge(QueueData *parent, QueueData *qd);
 222 static void pr_queue(PixbufRenderer *pr, gint x, gint y, gint w, gint h,
 223                      gint clamp, ImageTileRenderType render, gboolean new_data, gboolean only_existing);
 224
 225 static void pr_redraw(PixbufRenderer *pr, gboolean new_data);
 226
 227 static void pr_zoom_sync(PixbufRenderer *pr, gdouble zoom,
 228                          PrZoomFlags flags, gint px, gint py);
 229
 230 static void pr_signals_connect(PixbufRenderer *pr);
 231 static void pr_size_cb(GtkWidget *widget, GtkAllocation *allocation, gpointer data);
 232 static void pr_hierarchy_changed_cb(GtkWidget *widget, GtkWidget *previous_toplevel, gpointer data);
 233 static void pixbuf_renderer_paint(PixbufRenderer *pr, GdkRectangle *area);
 234 static gint pr_queue_draw_idle_cb(gpointer data);
 235
 236
 237 /*
 238  *-------------------------------------------------------------------
 239  * Pixbuf Renderer object
 240  *-------------------------------------------------------------------
 241  */
 242
 243 GType pixbuf_renderer_get_type(void)
 244 {
 245         static GType pixbuf_renderer_type = 0;
 246
 247         if (!pixbuf_renderer_type)
 248                 {
 249                 static const GTypeInfo pixbuf_renderer_info =
 250                         {
 251                         sizeof(PixbufRendererClass), /* class_size */
 252                         NULL,           /* base_init */
 253                         NULL,           /* base_finalize */
 254                         (GClassInitFunc)pixbuf_renderer_class_init,
 255                         NULL,           /* class_finalize */
 256                         NULL,           /* class_data */
 257                         sizeof(PixbufRenderer), /* instance_size */
 258                         0,              /* n_preallocs */
 259                         (GInstanceInitFunc)pixbuf_renderer_init, /* instance_init */
 260                         NULL,           /* value_table */
 261                         };
 262
 263                 pixbuf_renderer_type = g_type_register_static(GTK_TYPE_EVENT_BOX, "PixbufRenderer",
 264                                                               &pixbuf_renderer_info, 0);
 265                 }
 266
 267         return pixbuf_renderer_type;
 268 }
 269
 270 static void pixbuf_renderer_class_init(PixbufRendererClass *class)
 271 {
 272         GObjectClass *gobject_class = G_OBJECT_CLASS(class);
 273         GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(class);
 274
 275         parent_class = g_type_class_peek_parent(class);
 276
 277         gobject_class->set_property = pixbuf_renderer_set_property;
 278         gobject_class->get_property = pixbuf_renderer_get_property;
 279
 280         gobject_class->finalize = pixbuf_renderer_finalize;
 281
 282         widget_class->expose_event = pixbuf_renderer_expose;
 283
 284         g_object_class_install_property(gobject_class,
 285                                         PROP_ZOOM_MIN,
 286                                         g_param_spec_double("zoom_min",
 287                                                             "Zoom minimum",
 288                                                             NULL,
 289                                                             -1000.0,
 290                                                             1000.0,
 291                                                             PR_ZOOM_MIN,
 292                                                             G_PARAM_READABLE | G_PARAM_WRITABLE));
 293
 294         g_object_class_install_property(gobject_class,
 295                                         PROP_ZOOM_MAX,
 296                                         g_param_spec_double("zoom_max",
 297                                                             "Zoom maximum",
 298                                                             NULL,
 299                                                             -1000.0,
 300                                                             1000.0,
 301                                                             PR_ZOOM_MIN,
 302                                                             G_PARAM_READABLE | G_PARAM_WRITABLE));
 303
 304         g_object_class_install_property(gobject_class,
 305                                         PROP_ZOOM_QUALITY,
 306                                         g_param_spec_uint("zoom_quality",
 307                                                           "Zoom quality",
 308                                                           NULL,
 309                                                           GDK_INTERP_NEAREST,
 310                                                           GDK_INTERP_HYPER,
 311                                                           GDK_INTERP_BILINEAR,
 312                                                           G_PARAM_READABLE | G_PARAM_WRITABLE));
 313
 314         g_object_class_install_property(gobject_class,
 315                                         PROP_ZOOM_2PASS,
 316                                         g_param_spec_boolean("zoom_2pass",
 317                                                              "2 pass zoom",
 318                                                              NULL,
 319                                                              TRUE,
 320                                                              G_PARAM_READABLE | G_PARAM_WRITABLE));
 321
 322         g_object_class_install_property(gobject_class,
 323                                         PROP_ZOOM_EXPAND,
 324                                         g_param_spec_boolean("zoom_expand",
 325                                                              "Expand image in autozoom.",
 326                                                              NULL,
 327                                                              FALSE,
 328                                                              G_PARAM_READABLE | G_PARAM_WRITABLE));
 329
 330         g_object_class_install_property(gobject_class,
 331                                         PROP_DITHER_QUALITY,
 332                                         g_param_spec_uint("dither_quality",
 333                                                           "Dither quality",
 334                                                           NULL,
 335                                                           GDK_RGB_DITHER_NONE,
 336                                                           GDK_RGB_DITHER_MAX,
 337                                                           GDK_RGB_DITHER_NORMAL,
 338                                                           G_PARAM_READABLE | G_PARAM_WRITABLE));
 339
 340         g_object_class_install_property(gobject_class,
 341                                         PROP_SCROLL_RESET,
 342                                         g_param_spec_uint("scroll_reset",
 343                                                           "New image scroll reset",
 344                                                           NULL,
 345                                                           PR_SCROLL_RESET_TOPLEFT,
 346                                                           PR_SCROLL_RESET_NOCHANGE,
 347                                                           PR_SCROLL_RESET_TOPLEFT,
 348                                                           G_PARAM_READABLE | G_PARAM_WRITABLE));
 349
 350         g_object_class_install_property(gobject_class,
 351                                         PROP_DELAY_FLIP,
 352                                         g_param_spec_boolean("delay_flip",
 353                                                              "Delay image update",
 354                                                              NULL,
 355                                                              FALSE,
 356                                                              G_PARAM_READABLE | G_PARAM_WRITABLE));
 357
 358         g_object_class_install_property(gobject_class,
 359                                         PROP_LOADING,
 360                                         g_param_spec_boolean("loading",
 361                                                              "Image actively loading",
 362                                                              NULL,
 363                                                              FALSE,
 364                                                              G_PARAM_READABLE | G_PARAM_WRITABLE));
 365
 366         g_object_class_install_property(gobject_class,
 367                                         PROP_COMPLETE,
 368                                         g_param_spec_boolean("complete",
 369                                                              "Image rendering complete",
 370                                                              NULL,
 371                                                              FALSE,
 372                                                              G_PARAM_READABLE | G_PARAM_WRITABLE));
 373
 374         g_object_class_install_property(gobject_class,
 375                                         PROP_CACHE_SIZE_DISPLAY,
 376                                         g_param_spec_uint("cache_display",
 377                                                           "Display cache size MB",
 378                                                           NULL,
 379                                                           0,
 380                                                           128,
 381                                                           PR_CACHE_SIZE_DEFAULT,
 382                                                           G_PARAM_READABLE | G_PARAM_WRITABLE));
 383
 384         g_object_class_install_property(gobject_class,
 385                                         PROP_CACHE_SIZE_TILES,
 386                                         g_param_spec_uint("cache_tiles",
 387                                                           "Tile cache count",
 388                                                           "Number of tiles to retain in memory at any one time.",
 389                                                           0,
 390                                                           256,
 391                                                           PR_CACHE_SIZE_DEFAULT,
 392                                                           G_PARAM_READABLE | G_PARAM_WRITABLE));
 393
 394         g_object_class_install_property(gobject_class,
 395                                         PROP_WINDOW_FIT,
 396                                         g_param_spec_boolean("window_fit",
 397                                                              "Fit window to image size",
 398                                                              NULL,
 399                                                              FALSE,
 400                                                              G_PARAM_READABLE | G_PARAM_WRITABLE));
 401
 402         g_object_class_install_property(gobject_class,
 403                                         PROP_WINDOW_LIMIT,
 404                                         g_param_spec_boolean("window_limit",
 405                                                              "Limit size of parent window",
 406                                                              NULL,
 407                                                              FALSE,
 408                                                              G_PARAM_READABLE | G_PARAM_WRITABLE));
 409
 410         g_object_class_install_property(gobject_class,
 411                                         PROP_WINDOW_LIMIT_VALUE,
 412                                         g_param_spec_uint("window_limit_value",
 413                                                           "Size limit of parent window",
 414                                                           NULL,
 415                                                           10,
 416                                                           150,
 417                                                           100,
 418                                                           G_PARAM_READABLE | G_PARAM_WRITABLE));
 419
 420         g_object_class_install_property(gobject_class,
 421                                         PROP_AUTOFIT_LIMIT,
 422                                         g_param_spec_boolean("autofit_limit",
 423                                                              "Limit size of image when autofitting",
 424                                                              NULL,
 425                                                              FALSE,
 426                                                              G_PARAM_READABLE | G_PARAM_WRITABLE));
 427
 428         g_object_class_install_property(gobject_class,
 429                                         PROP_AUTOFIT_LIMIT_VALUE,
 430                                         g_param_spec_uint("autofit_limit_value",
 431                                                           "Size limit of image when autofitting",
 432                                                           NULL,
 433                                                           10,
 434                                                           150,
 435                                                           100,
 436                                                           G_PARAM_READABLE | G_PARAM_WRITABLE));
 437
 438
 439         signals[SIGNAL_ZOOM] =
 440                 g_signal_new("zoom",
 441                              G_OBJECT_CLASS_TYPE(gobject_class),
 442                              G_SIGNAL_RUN_LAST,
 443                              G_STRUCT_OFFSET(PixbufRendererClass, zoom),
 444                              NULL, NULL,
 445                              g_cclosure_marshal_VOID__DOUBLE,
 446                              G_TYPE_NONE, 1,
 447                              G_TYPE_DOUBLE);
 448
 449         signals[SIGNAL_CLICKED] =
 450                 g_signal_new("clicked",
 451                              G_OBJECT_CLASS_TYPE(gobject_class),
 452                              G_SIGNAL_RUN_LAST,
 453                              G_STRUCT_OFFSET(PixbufRendererClass, clicked),
 454                              NULL, NULL,
 455                              g_cclosure_marshal_VOID__BOXED,
 456                              G_TYPE_NONE, 1,
 457                              GDK_TYPE_EVENT);
 458
 459         signals[SIGNAL_SCROLL_NOTIFY] =
 460                 g_signal_new("scroll-notify",
 461                              G_OBJECT_CLASS_TYPE(gobject_class),
 462                              G_SIGNAL_RUN_LAST,
 463                              G_STRUCT_OFFSET(PixbufRendererClass, scroll_notify),
 464                              NULL, NULL,
 465                              g_cclosure_marshal_VOID__VOID,
 466                              G_TYPE_NONE, 0);
 467
 468         signals[SIGNAL_RENDER_COMPLETE] =
 469                 g_signal_new("render-complete",
 470                              G_OBJECT_CLASS_TYPE(gobject_class),
 471                              G_SIGNAL_RUN_LAST,
 472                              G_STRUCT_OFFSET(PixbufRendererClass, render_complete),
 473                              NULL, NULL,
 474                              g_cclosure_marshal_VOID__VOID,
 475                              G_TYPE_NONE, 0);
 476
 477         signals[SIGNAL_DRAG] =
 478                 g_signal_new("drag",
 479                              G_OBJECT_CLASS_TYPE(gobject_class),
 480                              G_SIGNAL_RUN_LAST,
 481                              G_STRUCT_OFFSET(PixbufRendererClass, drag),
 482                              NULL, NULL,
 483                              g_cclosure_marshal_VOID__BOXED,
 484                              G_TYPE_NONE, 1,
 485                              GDK_TYPE_EVENT);
 486
 487         signals[SIGNAL_UPDATE_PIXEL] =
 488                 g_signal_new("update-pixel",
 489                              G_OBJECT_CLASS_TYPE(gobject_class),
 490                              G_SIGNAL_RUN_LAST,
 491                              G_STRUCT_OFFSET(PixbufRendererClass, update_pixel),
 492                              NULL, NULL,
 493                              g_cclosure_marshal_VOID__VOID,
 494                              G_TYPE_NONE, 0);
 495 }
 496
 497 static void pixbuf_renderer_init(PixbufRenderer *pr)
 498 {
 499         GtkWidget *box;
 500
 501         box = GTK_WIDGET(pr);
 502
 503         pr->zoom_min = PR_ZOOM_MIN;
 504         pr->zoom_max = PR_ZOOM_MAX;
 505         pr->zoom_quality = GDK_INTERP_BILINEAR;
 506         pr->zoom_2pass = FALSE;
 507
 508         pr->zoom = 1.0;
 509         pr->scale = 1.0;
 510
 511         pr->dither_quality = GDK_RGB_DITHER_NORMAL;
 512
 513         pr->scroll_reset = PR_SCROLL_RESET_TOPLEFT;
 514
 515         pr->draw_idle_id = 0;
 516
 517         pr->tile_width = PR_TILE_SIZE;
 518         pr->tile_height = PR_TILE_SIZE;
 519
 520         pr->tiles = NULL;
 521         pr->tile_cache_size = 0;
 522
 523         pr->tile_cache_max = PR_CACHE_SIZE_DEFAULT;
 524
 525         pr->scroller_id = 0;
 526         pr->scroller_overlay = -1;
 527
 528         pr->x_mouse = -1;
 529         pr->y_mouse = -1;
 530
 531         pr->source_tiles_enabled = FALSE;
 532         pr->source_tiles = NULL;
 533
 534         pr->orientation = 1;
 535
 536         pr->norm_center_x = 0.5;
 537         pr->norm_center_y = 0.5;
 538
 539         gtk_widget_set_double_buffered(box, FALSE);
 540         g_signal_connect_after(G_OBJECT(box), "size_allocate",
 541                                G_CALLBACK(pr_size_cb), pr);
 542
 543         g_signal_connect(G_OBJECT(pr), "hierarchy-changed",
 544                          G_CALLBACK(pr_hierarchy_changed_cb), pr);
 545
 546         pr_signals_connect(pr);
 547 }
 548
 549 static void pixbuf_renderer_finalize(GObject *object)
 550 {
 551         PixbufRenderer *pr;
 552
 553         pr = PIXBUF_RENDERER(object);
 554
 555         pr_queue_clear(pr);
 556         pr_tile_free_all(pr);
 557
 558
 559         if (pr->pixbuf) g_object_unref(pr->pixbuf);
 560         if (pr->spare_tile) g_object_unref(pr->spare_tile);
 561
 562         pr_scroller_timer_set(pr, FALSE);
 563         pr_overlay_list_clear(pr);
 564
 565         pr_source_tile_free_all(pr);
 566 }
 567
 568 PixbufRenderer *pixbuf_renderer_new(void)
 569 {
 570         return g_object_new(TYPE_PIXBUF_RENDERER, NULL);
 571 }
 572
 573 static void pixbuf_renderer_set_property(GObject *object, guint prop_id,
 574                                          const GValue *value, GParamSpec *pspec)
 575 {
 576         PixbufRenderer *pr;
 577
 578         pr = PIXBUF_RENDERER(object);
 579
 580         switch (prop_id)
 581                 {
 582                 case PROP_ZOOM_MIN:
 583                         pr->zoom_min = g_value_get_double(value);
 584                         break;
 585                 case PROP_ZOOM_MAX:
 586                         pr->zoom_max = g_value_get_double(value);
 587                         break;
 588                 case PROP_ZOOM_QUALITY:
 589                         pr->zoom_quality = g_value_get_uint(value);
 590                         break;
 591                 case PROP_ZOOM_2PASS:
 592                         pr->zoom_2pass = g_value_get_boolean(value);
 593                         break;
 594                 case PROP_ZOOM_EXPAND:
 595                         pr->zoom_expand = g_value_get_boolean(value);
 596                         break;
 597                 case PROP_DITHER_QUALITY:
 598                         pr->dither_quality = g_value_get_uint(value);
 599                         break;
 600                 case PROP_SCROLL_RESET:
 601                         pr->scroll_reset = g_value_get_uint(value);
 602                         break;
 603                 case PROP_DELAY_FLIP:
 604                         pr->delay_flip = g_value_get_boolean(value);
 605                         break;
 606                 case PROP_LOADING:
 607                         pr->loading = g_value_get_boolean(value);
 608                         break;
 609                 case PROP_COMPLETE:
 610                         pr->complete = g_value_get_boolean(value);
 611                         break;
 612                 case PROP_CACHE_SIZE_DISPLAY:
 613                         pr->tile_cache_max = g_value_get_uint(value);
 614                         break;
 615                 case PROP_CACHE_SIZE_TILES:
 616                         pr->source_tiles_cache_size = g_value_get_uint(value);
 617                         break;
 618                 case PROP_WINDOW_FIT:
 619                         pr->window_fit = g_value_get_boolean(value);
 620                         break;
 621                 case PROP_WINDOW_LIMIT:
 622                         pr->window_limit = g_value_get_boolean(value);
 623                         break;
 624                 case PROP_WINDOW_LIMIT_VALUE:
 625                         pr->window_limit_size = g_value_get_uint(value);
 626                         break;
 627                 case PROP_AUTOFIT_LIMIT:
 628                         pr->autofit_limit = g_value_get_boolean(value);
 629                         break;
 630                 case PROP_AUTOFIT_LIMIT_VALUE:
 631                         pr->autofit_limit_size = g_value_get_uint(value);
 632                         break;
 633                 default:
 634                         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 635                         break;
 636                 }
 637 }
 638
 639 static void pixbuf_renderer_get_property(GObject *object, guint prop_id,
 640                                          GValue *value, GParamSpec *pspec)
 641 {
 642         PixbufRenderer *pr;
 643
 644         pr = PIXBUF_RENDERER(object);
 645
 646         switch (prop_id)
 647                 {
 648                 case PROP_ZOOM_MIN:
 649                         g_value_set_double(value, pr->zoom_min);
 650                         break;
 651                 case PROP_ZOOM_MAX:
 652                         g_value_set_double(value, pr->zoom_max);
 653                         break;
 654                 case PROP_ZOOM_QUALITY:
 655                         g_value_set_uint(value, pr->zoom_quality);
 656                         break;
 657                 case PROP_ZOOM_2PASS:
 658                         g_value_set_boolean(value, pr->zoom_2pass);
 659                         break;
 660                 case PROP_ZOOM_EXPAND:
 661                         g_value_set_boolean(value, pr->zoom_expand);
 662                         break;
 663                 case PROP_DITHER_QUALITY:
 664                         g_value_set_uint(value, pr->dither_quality);
 665                         break;
 666                 case PROP_SCROLL_RESET:
 667                         g_value_set_uint(value, pr->scroll_reset);
 668                         break;
 669                 case PROP_DELAY_FLIP:
 670                         g_value_set_boolean(value, pr->delay_flip);
 671                         break;
 672                 case PROP_LOADING:
 673                         g_value_set_boolean(value, pr->loading);
 674                         break;
 675                 case PROP_COMPLETE:
 676                         g_value_set_boolean(value, pr->complete);
 677                         break;
 678                 case PROP_CACHE_SIZE_DISPLAY:
 679                         g_value_set_uint(value, pr->tile_cache_max);
 680                         break;
 681                 case PROP_CACHE_SIZE_TILES:
 682                         g_value_set_uint(value, pr->source_tiles_cache_size);
 683                         break;
 684                 case PROP_WINDOW_FIT:
 685                         g_value_set_boolean(value, pr->window_fit);
 686                         break;
 687                 case PROP_WINDOW_LIMIT:
 688                         g_value_set_boolean(value, pr->window_limit);
 689                         break;
 690                 case PROP_WINDOW_LIMIT_VALUE:
 691                         g_value_set_uint(value, pr->window_limit_size);
 692                         break;
 693                 case PROP_AUTOFIT_LIMIT:
 694                         g_value_set_boolean(value, pr->autofit_limit);
 695                         break;
 696                 case PROP_AUTOFIT_LIMIT_VALUE:
 697                         g_value_set_uint(value, pr->autofit_limit_size);
 698                         break;
 699                 default:
 700                         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 701                         break;
 702                 }
 703 }
 704
 705 static gboolean pixbuf_renderer_expose(GtkWidget *widget, GdkEventExpose *event)
 706 {
 707 #if GTK_CHECK_VERSION(2,20,0)
 708         if (gtk_widget_is_drawable(widget))
 709 #else
 710         if (GTK_WIDGET_DRAWABLE(widget))
 711 #endif
 712                 {
 713 #if GTK_CHECK_VERSION(2,20,0)
 714                 if (gtk_widget_get_has_window(widget))
 715 #else
 716                 if (!GTK_WIDGET_NO_WINDOW(widget))
 717 #endif
 718                         {
 719                         if (event->window != widget->window)
 720                                 {
 721                                 GdkRectangle area;
 722
 723                                 gdk_window_get_position(event->window, &area.x, &area.y);
 724
 725                                 area.x += event->area.x;
 726                                 area.y += event->area.y;
 727                                 area.width = event->area.width;
 728                                 area.height = event->area.height;
 729                                 pixbuf_renderer_paint(PIXBUF_RENDERER(widget), &area);
 730                                 }
 731                         else
 732                                 {
 733                                 pixbuf_renderer_paint(PIXBUF_RENDERER(widget), &event->area);
 734                                 }
 735                         }
 736                 }
 737
 738         return FALSE;
 739 }
 740
 741 /*
 742  *-------------------------------------------------------------------
 743  * misc utilities
 744  *-------------------------------------------------------------------
 745  */
 746
 747 static void widget_set_cursor(GtkWidget *widget, gint icon)
 748 {
 749         GdkCursor *cursor;
 750
 751         if (!widget->window) return;
 752
 753         if (icon == -1)
 754                 {
 755                 cursor = NULL;
 756                 }
 757         else
 758                 {
 759                 cursor = gdk_cursor_new(icon);
 760                 }
 761
 762         gdk_window_set_cursor(widget->window, cursor);
 763
 764         if (cursor) gdk_cursor_unref(cursor);
 765 }
 766
 767 static gint pixmap_calc_size(GdkPixmap *pixmap)
 768 {
 769         gint w, h, d;
 770
 771         d = gdk_drawable_get_depth(pixmap);
 772         gdk_drawable_get_size(pixmap, &w, &h);
 773         return w * h * (d / 8);
 774 }
 775
 776 static gboolean pr_clip_region(gint x, gint y, gint w, gint h,
 777                                gint clip_x, gint clip_y, gint clip_w, gint clip_h,
 778                                gint *rx, gint *ry, gint *rw, gint *rh)
 779 {
 780         if (clip_x + clip_w <= x ||
 781             clip_x >= x + w ||
 782             clip_y + clip_h <= y ||
 783             clip_y >= y + h)
 784                 {
 785                 return FALSE;
 786                 }
 787
 788         *rx = MAX(x, clip_x);
 789         *rw = MIN((x + w), (clip_x + clip_w)) - *rx;
 790
 791         *ry = MAX(y, clip_y);
 792         *rh = MIN((y + h), (clip_y + clip_h)) - *ry;
 793
 794         return TRUE;
 795 }
 796
 797 static gboolean pr_parent_window_sizable(PixbufRenderer *pr)
 798 {
 799         GdkWindowState state;
 800
 801         if (!pr->parent_window) return FALSE;
 802         if (!pr->window_fit) return FALSE;
 803         if (!GTK_WIDGET(pr)->window) return FALSE;
 804
 805         if (!pr->parent_window->window) return FALSE;
 806         state = gdk_window_get_state(pr->parent_window->window);
 807         if (state & GDK_WINDOW_STATE_MAXIMIZED) return FALSE;
 808
 809         return TRUE;
 810 }
 811
 812 static gboolean pr_parent_window_resize(PixbufRenderer *pr, gint w, gint h)
 813 {
 814         GtkWidget *widget;
 815         GtkWidget *parent;
 816         gint ww, wh;
 817
 818         if (!pr_parent_window_sizable(pr)) return FALSE;
 819
 820         if (pr->window_limit)
 821                 {
 822                 gint sw = gdk_screen_width() * pr->window_limit_size / 100;
 823                 gint sh = gdk_screen_height() * pr->window_limit_size / 100;
 824
 825                 if (w > sw) w = sw;
 826                 if (h > sh) h = sh;
 827                 }
 828
 829         widget = GTK_WIDGET(pr);
 830         parent = GTK_WIDGET(pr->parent_window);
 831
 832         w += (parent->allocation.width - widget->allocation.width);
 833         h += (parent->allocation.height - widget->allocation.height);
 834
 835         gdk_drawable_get_size(parent->window, &ww, &wh);
 836         if (w == ww && h == wh) return FALSE;
 837
 838         gdk_window_resize(parent->window, w, h);
 839
 840         return TRUE;
 841 }
 842
 843 void pixbuf_renderer_set_parent(PixbufRenderer *pr, GtkWindow *window)
 844 {
 845         g_return_if_fail(IS_PIXBUF_RENDERER(pr));
 846         g_return_if_fail(window == NULL || GTK_IS_WINDOW(window));
 847
 848         pr->parent_window = GTK_WIDGET(window);
 849 }
 850
 851 GtkWindow *pixbuf_renderer_get_parent(PixbufRenderer *pr)
 852 {
 853         g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), NULL);
 854
 855         return GTK_WINDOW(pr->parent_window);
 856 }
 857
 858
 859 /*
 860  *-------------------------------------------------------------------
 861  * overlays
 862  *-------------------------------------------------------------------
 863  */
 864
 865 static void pr_overlay_get_position(PixbufRenderer *pr, OverlayData *od,
 866                                     gint *x, gint *y, gint *w, gint *h)
 867 {
 868         gint px, py, pw, ph;
 869
 870         pw = gdk_pixbuf_get_width(od->pixbuf);
 871         ph = gdk_pixbuf_get_height(od->pixbuf);
 872         px = od->x;
 873         py = od->y;
 874
 875         if (od->flags & OVL_RELATIVE)
 876                 {
 877                 if (px < 0) px = pr->window_width - pw + px;
 878                 if (py < 0) py = pr->window_height - ph + py;
 879                 }
 880
 881         if (x) *x = px;
 882         if (y) *y = py;
 883         if (w) *w = pw;
 884         if (h) *h = ph;
 885 }
 886
 887 static void pr_overlay_init_window(PixbufRenderer *pr, OverlayData *od)
 888 {
 889         gint px, py, pw, ph;
 890         GdkWindowAttr attributes;
 891         gint attributes_mask;
 892
 893         pr_overlay_get_position(pr, od, &px, &py, &pw, &ph);
 894
 895         attributes.window_type = GDK_WINDOW_CHILD;
 896         attributes.wclass = GDK_INPUT_OUTPUT;
 897         attributes.width = pw;
 898         attributes.height = ph;
 899         attributes.event_mask = GDK_EXPOSURE_MASK;
 900         attributes_mask = 0;
 901
 902         od->window = gdk_window_new(GTK_WIDGET(pr)->window, &attributes, attributes_mask);
 903         gdk_window_set_user_data(od->window, pr);
 904         gdk_window_move(od->window, px, py);
 905         gdk_window_show(od->window);
 906 }
 907
 908 static void pr_overlay_draw(PixbufRenderer *pr, gint x, gint y, gint w, gint h,
 909                             ImageTile *it)
 910 {
 911         GtkWidget *box;
 912         GList *work;
 913
 914         box = GTK_WIDGET(pr);
 915
 916         work = pr->overlay_list;
 917         while (work)
 918                 {
 919                 OverlayData *od;
 920                 gint px, py, pw, ph;
 921                 gint rx, ry, rw, rh;
 922
 923                 od = work->data;
 924                 work = work->next;
 925
 926                 if (!od->window) pr_overlay_init_window(pr, od);
 927
 928                 pr_overlay_get_position(pr, od, &px, &py, &pw, &ph);
 929                 if (pr_clip_region(x, y, w, h, px, py, pw, ph, &rx, &ry, &rw, &rh))
 930                         {
 931                         if (!pr->overlay_buffer)
 932                                 {
 933                                 pr->overlay_buffer = gdk_pixmap_new(((GtkWidget *)pr)->window, pr->tile_width, pr->tile_height, -1);
 934                                 }
 935
 936                         if (it)
 937                                 {
 938 #if GTK_CHECK_VERSION(2,20,0)
 939                                 gdk_draw_drawable(pr->overlay_buffer, box->style->fg_gc[gtk_widget_get_state(box)],
 940 #else
 941                                 gdk_draw_drawable(pr->overlay_buffer, box->style->fg_gc[GTK_WIDGET_STATE(box)],
 942 #endif
 943                                                   it->pixmap,
 944                                                   rx - (pr->x_offset + (it->x - pr->x_scroll)),
 945                                                   ry - (pr->y_offset + (it->y - pr->y_scroll)),
 946                                                   0, 0, rw, rh);
 947                                 gdk_draw_pixbuf(pr->overlay_buffer,
 948 #if GTK_CHECK_VERSION(2,20,0)
 949                                                 box->style->fg_gc[gtk_widget_get_state(box)],
 950 #else
 951                                                 box->style->fg_gc[GTK_WIDGET_STATE(box)],
 952 #endif
 953                                                 od->pixbuf,
 954                                                 rx - px, ry - py,
 955                                                 0, 0, rw, rh,
 956                                                 pr->dither_quality, rx, ry);
 957 #if GTK_CHECK_VERSION(2,20,0)
 958                                 gdk_draw_drawable(od->window, box->style->fg_gc[gtk_widget_get_state(box)],
 959 #else
 960                                 gdk_draw_drawable(od->window, box->style->fg_gc[GTK_WIDGET_STATE(box)],
 961 #endif
 962                                                   pr->overlay_buffer,
 963                                                   0, 0,
 964                                                   rx - px, ry - py, rw, rh);
 965                                 }
 966                         else
 967                                 {
 968                                 /* no ImageTile means region may be larger than our scratch buffer */
 969                                 gint sx, sy;
 970
 971                                 for (sx = rx; sx < rx + rw; sx += pr->tile_width)
 972                                     for (sy = ry; sy < ry + rh; sy += pr->tile_height)
 973                                         {
 974                                         gint sw, sh;
 975
 976                                         sw = MIN(rx + rw - sx, pr->tile_width);
 977                                         sh = MIN(ry + rh - sy, pr->tile_height);
 978
 979                                         gdk_draw_rectangle(pr->overlay_buffer,
 980 #if GTK_CHECK_VERSION(2,20,0)
 981                                                            box->style->bg_gc[gtk_widget_get_state(box)], TRUE,
 982 #else
 983                                                            box->style->bg_gc[GTK_WIDGET_STATE(box)], TRUE,
 984 #endif
 985                                                            0, 0, sw, sh);
 986                                         gdk_draw_pixbuf(pr->overlay_buffer,
 987 #if GTK_CHECK_VERSION(2,20,0)
 988                                                         box->style->fg_gc[gtk_widget_get_state(box)],
 989 #else
 990                                                         box->style->fg_gc[GTK_WIDGET_STATE(box)],
 991 #endif
 992                                                         od->pixbuf,
 993                                                         sx - px, sy - py,
 994                                                         0, 0, sw, sh,
 995                                                         pr->dither_quality, sx, sy);
 996 #if GTK_CHECK_VERSION(2,20,0)
 997                                         gdk_draw_drawable(od->window, box->style->fg_gc[gtk_widget_get_state(box)],
 998 #else
 999                                         gdk_draw_drawable(od->window, box->style->fg_gc[GTK_WIDGET_STATE(box)],
1000 #endif
1001                                                           pr->overlay_buffer,
1002                                                           0, 0,
1003                                                           sx - px, sy - py, sw, sh);
1004                                         }
1005                                 }
1006                         }
1007                 }
1008 }
1009
1010 static void pr_overlay_queue_draw(PixbufRenderer *pr, OverlayData *od)
1011 {
1012         gint x, y, w, h;
1013
1014         pr_overlay_get_position(pr, od, &x, &y, &w, &h);
1015         pr_queue(pr, pr->x_scroll - pr->x_offset + x,
1016                  pr->y_scroll - pr->y_offset + y,
1017                  w, h,
1018                  FALSE, TILE_RENDER_ALL, FALSE, FALSE);
1019
1020         pr_border_draw(pr, x, y, w, h);
1021 }
1022
1023 static void pr_overlay_queue_all(PixbufRenderer *pr)
1024 {
1025         GList *work;
1026
1027         work = pr->overlay_list;
1028         while (work)
1029                 {
1030                 OverlayData *od = work->data;
1031                 work = work->next;
1032
1033                 pr_overlay_queue_draw(pr, od);
1034                 }
1035 }
1036
1037 static void pr_overlay_update_sizes(PixbufRenderer *pr)
1038 {
1039         GList *work;
1040
1041         work = pr->overlay_list;
1042         while (work)
1043                 {
1044                 OverlayData *od = work->data;
1045                 work = work->next;
1046
1047                 if (!od->window) pr_overlay_init_window(pr, od);
1048
1049                 if (od->flags & OVL_RELATIVE)
1050                         {
1051                         gint x, y, w, h;
1052
1053                         pr_overlay_get_position(pr, od, &x, &y, &w, &h);
1054                         gdk_window_move_resize(od->window, x, y, w, h);
1055                         }
1056                 }
1057 }
1058
1059 static OverlayData *pr_overlay_find(PixbufRenderer *pr, gint id)
1060 {
1061         GList *work;
1062
1063         work = pr->overlay_list;
1064         while (work)
1065                 {
1066                 OverlayData *od = work->data;
1067                 work = work->next;
1068
1069                 if (od->id == id) return od;
1070                 }
1071
1072         return NULL;
1073 }
1074
1075
1076 gint pixbuf_renderer_overlay_add(PixbufRenderer *pr, GdkPixbuf *pixbuf, gint x, gint y,
1077                                  OverlayRendererFlags flags)
1078 {
1079         OverlayData *od;
1080         gint id;
1081
1082         g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), -1);
1083         g_return_val_if_fail(pixbuf != NULL, -1);
1084
1085         id = 1;
1086         while (pr_overlay_find(pr, id)) id++;
1087
1088         od = g_new0(OverlayData, 1);
1089         od->id = id;
1090         od->pixbuf = pixbuf;
1091         g_object_ref(G_OBJECT(od->pixbuf));
1092         od->x = x;
1093         od->y = y;
1094         od->flags = flags;
1095
1096         pr_overlay_init_window(pr, od);
1097
1098         pr->overlay_list = g_list_append(pr->overlay_list, od);
1099
1100         pr_overlay_queue_draw(pr, od);
1101
1102         return od->id;
1103 }
1104
1105 static void pr_overlay_free(PixbufRenderer *pr, OverlayData *od)
1106 {
1107         pr->overlay_list = g_list_remove(pr->overlay_list, od);
1108
1109         if (od->pixbuf) g_object_unref(G_OBJECT(od->pixbuf));
1110         if (od->window) gdk_window_destroy(od->window);
1111         g_free(od);
1112
1113         if (!pr->overlay_list && pr->overlay_buffer)
1114                 {
1115                 g_object_unref(pr->overlay_buffer);
1116                 pr->overlay_buffer = NULL;
1117                 }
1118 }
1119
1120 static void pr_overlay_list_clear(PixbufRenderer *pr)
1121 {
1122         while (pr->overlay_list)
1123                 {
1124                 OverlayData *od;
1125
1126                 od = pr->overlay_list->data;
1127                 pr_overlay_free(pr, od);
1128                 }
1129 }
1130
1131 static void pr_overlay_list_reset_window(PixbufRenderer *pr)
1132 {
1133         GList *work;
1134
1135         if (pr->overlay_buffer) g_object_unref(pr->overlay_buffer);
1136         pr->overlay_buffer = NULL;
1137
1138         work = pr->overlay_list;
1139         while (work)
1140                 {
1141                 OverlayData *od = work->data;
1142                 work = work->next;
1143                 if (od->window) gdk_window_destroy(od->window);
1144                 od->window = NULL;
1145                 }
1146 }
1147
1148 void pixbuf_renderer_overlay_set(PixbufRenderer *pr, gint id, GdkPixbuf *pixbuf, gint x, gint y)
1149 {
1150         OverlayData *od;
1151
1152         g_return_if_fail(IS_PIXBUF_RENDERER(pr));
1153
1154         od = pr_overlay_find(pr, id);
1155         if (!od) return;
1156
1157         if (pixbuf)
1158                 {
1159                 gint px, py, pw, ph;
1160
1161                 g_object_ref(G_OBJECT(pixbuf));
1162                 g_object_unref(G_OBJECT(od->pixbuf));
1163                 od->pixbuf = pixbuf;
1164
1165                 od->x = x;
1166                 od->y = y;
1167
1168                 if (!od->window) pr_overlay_init_window(pr, od);
1169
1170                 pr_overlay_queue_draw(pr, od);
1171                 pr_overlay_get_position(pr, od, &px, &py, &pw, &ph);
1172                 gdk_window_move_resize(od->window, px, py, pw, ph);
1173                 }
1174         else
1175                 {
1176                 pr_overlay_queue_draw(pr, od);
1177                 pr_overlay_free(pr, od);
1178                 }
1179 }
1180
1181 gboolean pixbuf_renderer_overlay_get(PixbufRenderer *pr, gint id, GdkPixbuf **pixbuf, gint *x, gint *y)
1182 {
1183         OverlayData *od;
1184
1185         g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), FALSE);
1186
1187         od = pr_overlay_find(pr, id);
1188         if (!od) return FALSE;
1189
1190         if (pixbuf) *pixbuf = od->pixbuf;
1191         if (x) *x = od->x;
1192         if (y) *y = od->y;
1193
1194         return TRUE;
1195 }
1196
1197 void pixbuf_renderer_overlay_remove(PixbufRenderer *pr, gint id)
1198 {
1199         pixbuf_renderer_overlay_set(pr, id, NULL, 0, 0);
1200 }
1201
1202 static void pr_hierarchy_changed_cb(GtkWidget *widget, GtkWidget *previous_toplevel, gpointer data)
1203 {
1204         PixbufRenderer *pr = data;
1205         pr_overlay_list_reset_window(pr);
1206 }
1207
1208
1209 /*
1210  *-------------------------------------------------------------------
1211  * scroller overlay
1212  *-------------------------------------------------------------------
1213  */
1214
1215
1216 static gboolean pr_scroller_update_cb(gpointer data)
1217 {
1218         PixbufRenderer *pr = data;
1219         gint x, y;
1220         gint xinc, yinc;
1221
1222         /* this was a simple scroll by difference between scroller and mouse position,
1223          * but all this math results in a smoother result and accounts for a dead zone.
1224          */
1225
1226         if (abs(pr->scroller_xpos - pr->scroller_x) < PR_SCROLLER_DEAD_ZONE)
1227                 {
1228                 x = 0;
1229                 }
1230         else
1231                 {
1232                 gint shift = PR_SCROLLER_DEAD_ZONE / 2 * PR_SCROLLER_UPDATES_PER_SEC;
1233                 x = (pr->scroller_xpos - pr->scroller_x) / 2 * PR_SCROLLER_UPDATES_PER_SEC;
1234                 x += (x > 0) ? -shift : shift;
1235                 }
1236
1237         if (abs(pr->scroller_ypos - pr->scroller_y) < PR_SCROLLER_DEAD_ZONE)
1238                 {
1239                 y = 0;
1240                 }
1241         else
1242                 {
1243                 gint shift = PR_SCROLLER_DEAD_ZONE / 2 * PR_SCROLLER_UPDATES_PER_SEC;
1244                 y = (pr->scroller_ypos - pr->scroller_y) / 2 * PR_SCROLLER_UPDATES_PER_SEC;
1245                 y += (y > 0) ? -shift : shift;
1246                 }
1247
1248         if (abs(x) < PR_SCROLLER_DEAD_ZONE * PR_SCROLLER_UPDATES_PER_SEC)
1249                 {
1250                 xinc = x;
1251                 }
1252         else
1253                 {
1254                 xinc = pr->scroller_xinc;
1255
1256                 if (x >= 0)
1257                         {
1258                         if (xinc < 0) xinc = 0;
1259                         if (x < xinc) xinc = x;
1260                         if (x > xinc) xinc = MIN(xinc + x / PR_SCROLLER_UPDATES_PER_SEC, x);
1261                         }
1262                 else
1263                         {
1264                         if (xinc > 0) xinc = 0;
1265                         if (x > xinc) xinc = x;
1266                         if (x < xinc) xinc = MAX(xinc + x / PR_SCROLLER_UPDATES_PER_SEC, x);
1267                         }
1268                 }
1269
1270         if (abs(y) < PR_SCROLLER_DEAD_ZONE * PR_SCROLLER_UPDATES_PER_SEC)
1271                 {
1272                 yinc = y;
1273                 }
1274         else
1275                 {
1276                 yinc = pr->scroller_yinc;
1277
1278                 if (y >= 0)
1279                         {
1280                         if (yinc < 0) yinc = 0;
1281                         if (y < yinc) yinc = y;
1282                         if (y > yinc) yinc = MIN(yinc + y / PR_SCROLLER_UPDATES_PER_SEC, y);
1283                         }
1284                 else
1285                         {
1286                         if (yinc > 0) yinc = 0;
1287                         if (y > yinc) yinc = y;
1288                         if (y < yinc) yinc = MAX(yinc + y / PR_SCROLLER_UPDATES_PER_SEC, y);
1289                         }
1290                 }
1291
1292         pr->scroller_xinc = xinc;
1293         pr->scroller_yinc = yinc;
1294
1295         xinc = xinc / PR_SCROLLER_UPDATES_PER_SEC;
1296         yinc = yinc / PR_SCROLLER_UPDATES_PER_SEC;
1297
1298         pixbuf_renderer_scroll(pr, xinc, yinc);
1299
1300         return TRUE;
1301 }
1302
1303 static void pr_scroller_timer_set(PixbufRenderer *pr, gboolean start)
1304 {
1305         if (pr->scroller_id)
1306                 {
1307                 g_source_remove(pr->scroller_id);
1308                 pr->scroller_id = 0;
1309                 }
1310
1311         if (start)
1312                 {
1313                 pr->scroller_id = g_timeout_add(1000 / PR_SCROLLER_UPDATES_PER_SEC,
1314                                                 pr_scroller_update_cb, pr);
1315                 }
1316 }
1317
1318 static void pr_scroller_start(PixbufRenderer *pr, gint x, gint y)
1319 {
1320         if (pr->scroller_overlay == -1)
1321                 {
1322                 GdkPixbuf *pixbuf;
1323                 gint w, h;
1324
1325 #ifdef GQ_BUILD
1326                 pixbuf = pixbuf_inline(PIXBUF_INLINE_SCROLLER);
1327 #else
1328                 pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, 32, 32);
1329                 gdk_pixbuf_fill(pixbuf, 0x000000ff);
1330 #endif
1331                 w = gdk_pixbuf_get_width(pixbuf);
1332                 h = gdk_pixbuf_get_height(pixbuf);
1333
1334                 pr->scroller_overlay = pixbuf_renderer_overlay_add(pr, pixbuf, x - w / 2, y - h / 2, OVL_NORMAL);
1335                 g_object_unref(pixbuf);
1336                 }
1337
1338         pr->scroller_x = x;
1339         pr->scroller_y = y;
1340         pr->scroller_xpos = x;
1341         pr->scroller_ypos = y;
1342
1343         pr_scroller_timer_set(pr, TRUE);
1344 }
1345
1346 static void pr_scroller_stop(PixbufRenderer *pr)
1347 {
1348         if (!pr->scroller_id) return;
1349
1350         pixbuf_renderer_overlay_remove(pr, pr->scroller_overlay);
1351         pr->scroller_overlay = -1;
1352
1353         pr_scroller_timer_set(pr, FALSE);
1354 }
1355
1356 /*
1357  *-------------------------------------------------------------------
1358  * borders
1359  *-------------------------------------------------------------------
1360  */
1361
1362 static void pr_border_draw(PixbufRenderer *pr, gint x, gint y, gint w, gint h)
1363 {
1364         GtkWidget *box;
1365         gint rx, ry, rw, rh;
1366
1367         box = GTK_WIDGET(pr);
1368
1369         if (!box->window) return;
1370
1371         if (!pr->pixbuf && !pr->source_tiles_enabled)
1372                 {
1373                 if (pr_clip_region(x, y, w, h,
1374                                    0, 0,
1375                                    pr->window_width, pr->window_height,
1376                                    &rx, &ry, &rw, &rh))
1377                         {
1378                         gdk_window_clear_area(box->window, rx, ry, rw, rh);
1379                         pr_overlay_draw(pr, rx, ry, rw, rh, NULL);
1380                         }
1381                 return;
1382                 }
1383
1384         if (pr->vis_width < pr->window_width)
1385                 {
1386                 if (pr->x_offset > 0 &&
1387                     pr_clip_region(x, y, w, h,
1388                                    0, 0,
1389                                    pr->x_offset, pr->window_height,
1390                                    &rx, &ry, &rw, &rh))
1391                         {
1392                         gdk_window_clear_area(box->window, rx, ry, rw, rh);
1393                         pr_overlay_draw(pr, rx, ry, rw, rh, NULL);
1394                         }
1395                 if (pr->window_width - pr->vis_width - pr->x_offset > 0 &&
1396                     pr_clip_region(x, y, w, h,
1397                                    pr->x_offset + pr->vis_width, 0,
1398                                    pr->window_width - pr->vis_width - pr->x_offset, pr->window_height,
1399                                    &rx, &ry, &rw, &rh))
1400                         {
1401                         gdk_window_clear_area(box->window, rx, ry, rw, rh);
1402                         pr_overlay_draw(pr, rx, ry, rw, rh, NULL);
1403                         }
1404                 }
1405         if (pr->vis_height < pr->window_height)
1406                 {
1407                 if (pr->y_offset > 0 &&
1408                     pr_clip_region(x, y, w, h,
1409                                    pr->x_offset, 0,
1410                                    pr->vis_width, pr->y_offset,
1411                                    &rx, &ry, &rw, &rh))
1412                         {
1413                         gdk_window_clear_area(box->window, rx, ry, rw, rh);
1414                         pr_overlay_draw(pr, rx, ry, rw, rh, NULL);
1415                         }
1416                 if (pr->window_height - pr->vis_height - pr->y_offset > 0 &&
1417                     pr_clip_region(x, y, w, h,
1418                                    pr->x_offset, pr->y_offset + pr->vis_height,
1419                                    pr->vis_width, pr->window_height - pr->vis_height - pr->y_offset,
1420                                    &rx, &ry, &rw, &rh))
1421                         {
1422                         gdk_window_clear_area(box->window, rx, ry, rw, rh);
1423                         pr_overlay_draw(pr, rx, ry, rw, rh, NULL);
1424                         }
1425                 }
1426 }
1427
1428 static void pr_border_clear(PixbufRenderer *pr)
1429 {
1430         pr_border_draw(pr, 0, 0, pr->window_width, pr->window_height);
1431 }
1432
1433 void pixbuf_renderer_set_color(PixbufRenderer *pr, GdkColor *color)
1434 {
1435         GtkStyle *style;
1436         GtkWidget *widget;
1437
1438         g_return_if_fail(IS_PIXBUF_RENDERER(pr));
1439
1440         widget = GTK_WIDGET(pr);
1441
1442         if (color) {
1443                 GdkColor *slot;
1444
1445                 style = gtk_style_copy(gtk_widget_get_style(widget));
1446                 slot = &style->bg[GTK_STATE_NORMAL];
1447
1448                 slot->red = color->red;
1449                 slot->green = color->green;
1450                 slot->blue = color->blue;
1451                 }
1452         else {
1453                 style = gtk_style_copy(gtk_widget_get_default_style());
1454         }
1455
1456         gtk_widget_set_style(widget, style);
1457
1458 #if GTK_CHECK_VERSION(2,20,0)
1459         if (gtk_widget_get_visible(widget)) pr_border_clear(pr);
1460 #else
1461         if (GTK_WIDGET_VISIBLE(widget)) pr_border_clear(pr);
1462 #endif
1463 }
1464
1465
1466 /*
1467  *-------------------------------------------------------------------
1468  * source tiles
1469  *-------------------------------------------------------------------
1470  */
1471
1472 static void pr_source_tile_free(SourceTile *st)
1473 {
1474         if (!st) return;
1475
1476         if (st->pixbuf) g_object_unref(st->pixbuf);
1477         g_free(st);
1478 }
1479
1480 static void pr_source_tile_free_all(PixbufRenderer *pr)
1481 {
1482         GList *work;
1483
1484         work = pr->source_tiles;
1485         while (work)
1486                 {
1487                 SourceTile *st;
1488
1489                 st = work->data;
1490                 work = work->next;
1491
1492                 pr_source_tile_free(st);
1493                 }
1494
1495         g_list_free(pr->source_tiles);
1496         pr->source_tiles = NULL;
1497 }
1498
1499 static void pr_source_tile_unset(PixbufRenderer *pr)
1500 {
1501         pr_source_tile_free_all(pr);
1502         pr->source_tiles_enabled = FALSE;
1503 }
1504
1505 static gboolean pr_source_tile_visible(PixbufRenderer *pr, SourceTile *st)
1506 {
1507         gint x1, y1, x2, y2;
1508
1509         if (!st) return FALSE;
1510
1511         x1 = ROUND_DOWN(pr->x_scroll, pr->tile_width);
1512         y1 = ROUND_DOWN(pr->y_scroll, pr->tile_height);
1513         x2 = ROUND_UP(pr->x_scroll + pr->vis_width, pr->tile_width);
1514         y2 = ROUND_UP(pr->y_scroll + pr->vis_height, pr->tile_height);
1515
1516         return !((gdouble)st->x * pr->scale > (gdouble)x2 ||
1517                  (gdouble)(st->x + pr->source_tile_width) * pr->scale < (gdouble)x1 ||
1518                  (gdouble)st->y * pr->scale > (gdouble)y2 ||
1519                  (gdouble)(st->y + pr->source_tile_height) * pr->scale < (gdouble)y1);
1520 }
1521
1522 static SourceTile *pr_source_tile_new(PixbufRenderer *pr, gint x, gint y)
1523 {
1524         SourceTile *st = NULL;
1525         gint count;
1526
1527         g_return_val_if_fail(pr->source_tile_width >= 1 && pr->source_tile_height >= 1, NULL);
1528
1529         if (pr->source_tiles_cache_size < 4) pr->source_tiles_cache_size = 4;
1530
1531         count = g_list_length(pr->source_tiles);
1532         if (count >= pr->source_tiles_cache_size)
1533                 {
1534                 GList *work;
1535
1536                 work = g_list_last(pr->source_tiles);
1537                 while (work && count >= pr->source_tiles_cache_size)
1538                         {
1539                         SourceTile *needle;
1540
1541                         needle = work->data;
1542                         work = work->prev;
1543
1544                         if (!pr_source_tile_visible(pr, needle))
1545                                 {
1546                                 pr->source_tiles = g_list_remove(pr->source_tiles, needle);
1547
1548                                 if (pr->func_tile_dispose)
1549                                         {
1550                                         pr->func_tile_dispose(pr, needle->x, needle->y,
1551                                                               pr->source_tile_width, pr->source_tile_height,
1552                                                               needle->pixbuf, pr->func_tile_data);
1553                                         }
1554
1555                                 if (!st)
1556                                         {
1557                                         st = needle;
1558                                         }
1559                                 else
1560                                         {
1561                                         pr_source_tile_free(needle);
1562                                         }
1563
1564                                 count--;
1565                                 }
1566                         }
1567                 }
1568
1569         if (!st)
1570                 {
1571                 st = g_new0(SourceTile, 1);
1572                 st->pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8,
1573                                             pr->source_tile_width, pr->source_tile_height);
1574                 }
1575
1576         st->x = ROUND_DOWN(x, pr->source_tile_width);
1577         st->y = ROUND_DOWN(y, pr->source_tile_height);
1578         st->blank = TRUE;
1579
1580         pr->source_tiles = g_list_prepend(pr->source_tiles, st);
1581
1582         return st;
1583 }
1584
1585 static SourceTile *pr_source_tile_request(PixbufRenderer *pr, gint x, gint y)
1586 {
1587         SourceTile *st;
1588
1589         st = pr_source_tile_new(pr, x, y);
1590         if (!st) return NULL;
1591
1592         if (pr->func_tile_request &&
1593             pr->func_tile_request(pr, st->x, st->y,
1594                                    pr->source_tile_width, pr->source_tile_height, st->pixbuf, pr->func_tile_data))
1595                 {
1596                 st->blank = FALSE;
1597                 }
1598
1599         pr_tile_invalidate_region(pr, st->x * pr->scale, st->y * pr->scale,
1600                                   pr->source_tile_width * pr->scale, pr->source_tile_height * pr->scale);
1601
1602         return st;
1603 }
1604
1605 static SourceTile *pr_source_tile_find(PixbufRenderer *pr, gint x, gint y)
1606 {
1607         GList *work;
1608
1609         work = pr->source_tiles;
1610         while (work)
1611                 {
1612                 SourceTile *st = work->data;
1613
1614                 if (x >= st->x && x < st->x + pr->source_tile_width &&
1615                     y >= st->y && y < st->y + pr->source_tile_height)
1616                         {
1617                         if (work != pr->source_tiles)
1618                                 {
1619                                 pr->source_tiles = g_list_remove_link(pr->source_tiles, work);
1620                                 pr->source_tiles = g_list_concat(work, pr->source_tiles);
1621                                 }
1622                         return st;
1623                         }
1624
1625                 work = work->next;
1626                 }
1627
1628         return NULL;
1629 }
1630
1631 static GList *pr_source_tile_compute_region(PixbufRenderer *pr, gint x, gint y, gint w, gint h, gboolean request)
1632 {
1633         gint x1, y1;
1634         GList *list = NULL;
1635         gint sx, sy;
1636
1637         if (x < 0) x = 0;
1638         if (y < 0) y = 0;
1639         if (w > pr->image_width) w = pr->image_width;
1640         if (h > pr->image_height) h = pr->image_height;
1641
1642         sx = ROUND_DOWN(x, pr->source_tile_width);
1643         sy = ROUND_DOWN(y, pr->source_tile_height);
1644
1645         for (x1 = sx; x1 < x + w; x1+= pr->source_tile_width)
1646                 {
1647                 for (y1 = sy; y1 < y + h; y1 += pr->source_tile_height)
1648                         {
1649                         SourceTile *st;
1650
1651                         st = pr_source_tile_find(pr, x1, y1);
1652                         if (!st && request) st = pr_source_tile_request(pr, x1, y1);
1653
1654                         if (st) list = g_list_prepend(list, st);
1655                         }
1656                 }
1657
1658         return g_list_reverse(list);
1659 }
1660
1661 static void pr_source_tile_changed(PixbufRenderer *pr, gint x, gint y, gint width, gint height)
1662 {
1663         GList *work;
1664
1665         if (width < 1 || height < 1) return;
1666
1667         work = pr->source_tiles;
1668         while (work)
1669                 {
1670                 SourceTile *st;
1671                 gint rx, ry, rw, rh;
1672
1673                 st = work->data;
1674                 work = work->next;
1675
1676                 if (pr_clip_region(st->x, st->y, pr->source_tile_width, pr->source_tile_height,
1677                                    x, y, width, height,
1678                                    &rx, &ry, &rw, &rh))
1679                         {
1680                         GdkPixbuf *pixbuf;
1681
1682                         pixbuf = gdk_pixbuf_new_subpixbuf(st->pixbuf, rx - st->x, ry - st->y, rw, rh);
1683                         if (pr->func_tile_request &&
1684                             pr->func_tile_request(pr, rx, ry, rw, rh, pixbuf, pr->func_tile_data))
1685                                 {
1686                                 pr_tile_invalidate_region(pr, rx * pr->scale, ry * pr->scale,
1687                                                               rw * pr->scale, rh * pr->scale);
1688                                 }
1689                         g_object_unref(pixbuf);
1690                         }
1691                 }
1692 }
1693
1694 static gboolean pr_source_tile_render(PixbufRenderer *pr, ImageTile *it,
1695                                       gint x, gint y, gint w, gint h,
1696                                       gboolean new_data, gboolean fast)
1697 {
1698         GtkWidget *box;
1699         GList *list;
1700         GList *work;
1701         gboolean draw = FALSE;
1702
1703         box = GTK_WIDGET(pr);
1704
1705         if (pr->zoom == 1.0 || pr->scale == 1.0)
1706                 {
1707                 list = pr_source_tile_compute_region(pr, it->x + x, it->y + y, w, h, TRUE);
1708                 work = list;
1709                 while (work)
1710                         {
1711                         SourceTile *st;
1712                         gint rx, ry, rw, rh;
1713
1714                         st = work->data;
1715                         work = work->next;
1716
1717                         if (pr_clip_region(st->x, st->y, pr->source_tile_width, pr->source_tile_height,
1718                                            it->x + x, it->y + y, w, h,
1719                                            &rx, &ry, &rw, &rh))
1720                                 {
1721                                 if (st->blank)
1722                                         {
1723                                         gdk_draw_rectangle(it->pixmap, box->style->black_gc, TRUE,
1724                                                            rx - st->x, ry - st->y, rw, rh);
1725                                         }
1726                                 else /* (pr->zoom == 1.0 || pr->scale == 1.0) */
1727                                         {
1728                                         gdk_draw_pixbuf(it->pixmap,
1729 #if GTK_CHECK_VERSION(2,20,0)
1730                                                         box->style->fg_gc[gtk_widget_get_state(box)],
1731 #else
1732                                                         box->style->fg_gc[GTK_WIDGET_STATE(box)],
1733 #endif
1734                                                         st->pixbuf,
1735                                                         rx - st->x, ry - st->y,
1736                                                         rx - it->x, ry - it->y,
1737                                                         rw, rh,
1738                                                         pr->dither_quality, rx, ry);
1739                                         }
1740                                 }
1741                         }
1742                 }
1743         else
1744                 {
1745                 gdouble scale_x, scale_y;
1746                 gint sx, sy, sw, sh;
1747
1748                 if (pr->image_width == 0 || pr->image_height == 0) return FALSE;
1749                 scale_x = (gdouble)pr->width / pr->image_width;
1750                 scale_y = (gdouble)pr->height / pr->image_height;
1751
1752                 sx = (gdouble)(it->x + x) / scale_x;
1753                 sy = (gdouble)(it->y + y) / scale_y;
1754                 sw = (gdouble)w / scale_x;
1755                 sh = (gdouble)h / scale_y;
1756
1757                 if (pr->width < PR_MIN_SCALE_SIZE || pr->height < PR_MIN_SCALE_SIZE) fast = TRUE;
1758
1759 #if 0
1760                 /* draws red over draw region, to check for leaks (regions not filled) */
1761                 pixbuf_set_rect_fill(it->pixbuf, x, y, w, h, 255, 0, 0, 255);
1762 #endif
1763
1764                 list = pr_source_tile_compute_region(pr, sx, sy, sw, sh, TRUE);
1765                 work = list;
1766                 while (work)
1767                         {
1768                         SourceTile *st;
1769                         gint rx, ry, rw, rh;
1770                         gint stx, sty, stw, sth;
1771
1772                         st = work->data;
1773                         work = work->next;
1774
1775                         stx = floor((gdouble)st->x * scale_x);
1776                         sty = floor((gdouble)st->y * scale_y);
1777                         stw = ceil((gdouble)(st->x + pr->source_tile_width) * scale_x) - stx;
1778                         sth = ceil((gdouble)(st->y + pr->source_tile_height) * scale_y) - sty;
1779
1780                         if (pr_clip_region(stx, sty, stw, sth,
1781                                            it->x + x, it->y + y, w, h,
1782                                            &rx, &ry, &rw, &rh))
1783                                 {
1784                                 if (st->blank)
1785                                         {
1786                                         gdk_draw_rectangle(it->pixmap, box->style->black_gc, TRUE,
1787                                                            rx - st->x, ry - st->y, rw, rh);
1788                                         }
1789                                 else
1790                                         {
1791                                         gdouble offset_x;
1792                                         gdouble offset_y;
1793
1794                                         /* may need to use unfloored stx,sty values here */
1795                                         offset_x = (gdouble)(stx - it->x);
1796                                         offset_y = (gdouble)(sty - it->y);
1797
1798                                         gdk_pixbuf_scale(st->pixbuf, it->pixbuf, rx - it->x, ry - it->y, rw, rh,
1799                                                  (gdouble) 0.0 + offset_x,
1800                                                  (gdouble) 0.0 + offset_y,
1801                                                  scale_x, scale_y,
1802                                                  (fast) ? GDK_INTERP_NEAREST : pr->zoom_quality);
1803                                         draw = TRUE;
1804                                         }
1805                                 }
1806                         }
1807                 }
1808
1809         g_list_free(list);
1810
1811         return draw;
1812 }
1813
1814 void pixbuf_renderer_set_tiles(PixbufRenderer *pr, gint width, gint height,
1815                                gint tile_width, gint tile_height, gint cache_size,
1816                                PixbufRendererTileRequestFunc func_request,
1817                                PixbufRendererTileDisposeFunc func_dispose,
1818                                gpointer user_data,
1819                                gdouble zoom)
1820 {
1821         g_return_if_fail(IS_PIXBUF_RENDERER(pr));
1822         g_return_if_fail(tile_width >= 32 && tile_width >= 32);
1823         g_return_if_fail(width >= 32 && height > 32);
1824         g_return_if_fail(func_request != NULL);
1825
1826         if (pr->pixbuf) g_object_unref(pr->pixbuf);
1827         pr->pixbuf = NULL;
1828
1829         pr_source_tile_unset(pr);
1830
1831         if (cache_size < 4) cache_size = 4;
1832
1833         pr->source_tiles_enabled = TRUE;
1834         pr->source_tiles_cache_size = cache_size;
1835         pr->source_tile_width = tile_width;
1836         pr->source_tile_height = tile_height;
1837
1838         pr->image_width = width;
1839         pr->image_height = height;
1840
1841         pr->func_tile_request = func_request;
1842         pr->func_tile_dispose = func_dispose;
1843         pr->func_tile_data = user_data;
1844
1845         pr_zoom_sync(pr, zoom, PR_ZOOM_FORCE | PR_ZOOM_NEW, 0, 0);
1846         pr_redraw(pr, TRUE);
1847 }
1848
1849 void pixbuf_renderer_set_tiles_size(PixbufRenderer *pr, gint width, gint height)
1850 {
1851         g_return_if_fail(IS_PIXBUF_RENDERER(pr));
1852         g_return_if_fail(width >= 32 && height > 32);
1853
1854         if (!pr->source_tiles_enabled) return;
1855         if (pr->image_width == width && pr->image_height == height) return;
1856
1857         pr->image_width = width;
1858         pr->image_height = height;
1859
1860         pr_zoom_sync(pr, pr->zoom, PR_ZOOM_FORCE, 0, 0);
1861 }
1862
1863 gint pixbuf_renderer_get_tiles(PixbufRenderer *pr)
1864 {
1865         g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), FALSE);
1866
1867         return pr->source_tiles_enabled;
1868 }
1869
1870 static void pr_zoom_adjust_real(PixbufRenderer *pr, gdouble increment,
1871                                 PrZoomFlags flags, gint x, gint y)
1872 {
1873         gdouble zoom = pr->zoom;
1874
1875         if (increment == 0.0) return;
1876
1877         if (zoom == 0.0)
1878                 {
1879                 if (pr->scale < 1.0)
1880                         {
1881                         zoom = 0.0 - 1.0 / pr->scale;
1882                         }
1883                 else
1884                         {
1885                         zoom = pr->scale;
1886                         }
1887                 }
1888
1889         if (increment < 0.0)
1890                 {
1891                 if (zoom >= 1.0 && zoom + increment < 1.0)
1892                         {
1893                         zoom = zoom + increment - 2.0;
1894                         }
1895                 else
1896                         {
1897                         zoom = zoom + increment;
1898                         }
1899                 }
1900         else
1901                 {
1902                 if (zoom <= -1.0 && zoom + increment > -1.0)
1903                         {
1904                         zoom = zoom + increment + 2.0;
1905                         }
1906                 else
1907                         {
1908                         zoom = zoom + increment;
1909                         }
1910                 }
1911
1912         pr_zoom_sync(pr, zoom, flags, x, y);
1913 }
1914
1915 /*
1916  *-------------------------------------------------------------------
1917  * display tiles
1918  *-------------------------------------------------------------------
1919  */
1920
1921 static ImageTile *pr_tile_new(gint x, gint y, gint width, gint height)
1922 {
1923         ImageTile *it;
1924
1925         it = g_new0(ImageTile, 1);
1926
1927         it->x = x;
1928         it->y = y;
1929         it->w = width;
1930         it->h = height;
1931
1932         it->render_done = TILE_RENDER_NONE;
1933
1934         return it;
1935 }
1936
1937 static void pr_tile_free(ImageTile *it)
1938 {
1939         if (!it) return;
1940
1941         if (it->pixbuf) g_object_unref(it->pixbuf);
1942         if (it->pixmap) g_object_unref(it->pixmap);
1943
1944         g_free(it);
1945 }
1946
1947 static void pr_tile_free_all(PixbufRenderer *pr)
1948 {
1949         GList *work;
1950
1951         work = pr->tiles;
1952         while (work)
1953                 {
1954                 ImageTile *it;
1955
1956                 it = work->data;
1957                 work = work->next;
1958
1959                 pr_tile_free(it);
1960                 }
1961
1962         g_list_free(pr->tiles);
1963         pr->tiles = NULL;
1964         pr->tile_cache_size = 0;
1965 }
1966
1967 static ImageTile *pr_tile_add(PixbufRenderer *pr, gint x, gint y)
1968 {
1969         ImageTile *it;
1970
1971         it = pr_tile_new(x, y, pr->tile_width, pr->tile_height);
1972
1973         if (it->x + it->w > pr->width) it->w = pr->width - it->x;
1974         if (it->y + it->h > pr->height) it->h = pr->height - it->y;
1975
1976         pr->tiles = g_list_prepend(pr->tiles, it);
1977         pr->tile_cache_size += it->size;
1978
1979         return it;
1980 }
1981
1982 static void pr_tile_remove(PixbufRenderer *pr, ImageTile *it)
1983 {
1984         if (it->qd)
1985                 {
1986                 QueueData *qd = it->qd;
1987
1988                 it->qd = NULL;
1989                 pr->draw_queue = g_list_remove(pr->draw_queue, qd);
1990                 g_free(qd);
1991                 }
1992
1993         if (it->qd2)
1994                 {
1995                 QueueData *qd = it->qd2;
1996
1997                 it->qd2 = NULL;
1998                 pr->draw_queue_2pass = g_list_remove(pr->draw_queue_2pass, qd);
1999                 g_free(qd);
2000                 }
2001
2002         pr->tiles = g_list_remove(pr->tiles, it);
2003         pr->tile_cache_size -= it->size;
2004
2005         pr_tile_free(it);
2006 }
2007
2008 static void pr_tile_free_space(PixbufRenderer *pr, guint space, ImageTile *it)
2009 {
2010         GList *work;
2011         guint tile_max;
2012
2013         work = g_list_last(pr->tiles);
2014
2015         if (pr->source_tiles_enabled && pr->scale < 1.0)
2016                 {
2017                 gint tiles;
2018
2019                 tiles = (pr->vis_width / pr->tile_width + 1) * (pr->vis_height / pr->tile_height + 1);
2020                 tile_max = MAX(tiles * pr->tile_width * pr->tile_height * 3,
2021                                (gint)((gdouble)pr->tile_cache_max * 1048576.0 * pr->scale));
2022                 }
2023         else
2024                 {
2025                 tile_max = pr->tile_cache_max * 1048576;
2026                 }
2027
2028         while (work && pr->tile_cache_size + space > tile_max)
2029                 {
2030                 ImageTile *needle;
2031
2032                 needle = work->data;
2033                 work = work->prev;
2034                 if (needle != it &&
2035                     ((!needle->qd && !needle->qd2) || !pr_tile_is_visible(pr, needle))) pr_tile_remove(pr, needle);
2036                 }
2037 }
2038
2039 static void pr_tile_invalidate_all(PixbufRenderer *pr)
2040 {
2041         GList *work;
2042
2043         work = pr->tiles;
2044         while (work)
2045                 {
2046                 ImageTile *it;
2047
2048                 it = work->data;
2049                 work = work->next;
2050
2051                 it->render_done = TILE_RENDER_NONE;
2052                 it->render_todo = TILE_RENDER_ALL;
2053                 it->blank = FALSE;
2054
2055                 it->w = MIN(pr->tile_width, pr->width - it->x);
2056                 it->h = MIN(pr->tile_height, pr->height - it->y);
2057                 }
2058 }
2059
2060 static void pr_tile_invalidate_region(PixbufRenderer *pr, gint x, gint y, gint w, gint h)
2061 {
2062         gint x1, x2;
2063         gint y1, y2;
2064         GList *work;
2065
2066         x1 = ROUND_DOWN(x, pr->tile_width);
2067         x2 = ROUND_UP(x + w, pr->tile_width);
2068
2069         y1 = ROUND_DOWN(y, pr->tile_height);
2070         y2 = ROUND_UP(y + h, pr->tile_height);
2071
2072         work = pr->tiles;
2073         while (work)
2074                 {
2075                 ImageTile *it;
2076
2077                 it = work->data;
2078                 work = work->next;
2079
2080                 if (it->x < x2 && it->x + it->w > x1 &&
2081                     it->y < y2 && it->y + it->h > y1)
2082                         {
2083                         it->render_done = TILE_RENDER_NONE;
2084                         it->render_todo = TILE_RENDER_ALL;
2085                         }
2086                 }
2087 }
2088
2089 static ImageTile *pr_tile_get(PixbufRenderer *pr, gint x, gint y, gboolean only_existing)
2090 {
2091         GList *work;
2092
2093         work = pr->tiles;
2094         while (work)
2095                 {
2096                 ImageTile *it;
2097
2098                 it = work->data;
2099                 if (it->x == x && it->y == y)
2100                         {
2101                         pr->tiles = g_list_delete_link(pr->tiles, work);
2102                         pr->tiles = g_list_prepend(pr->tiles, it);
2103                         return it;
2104                         }
2105
2106                 work = work->next;
2107                 }
2108
2109         if (only_existing) return NULL;
2110
2111         return pr_tile_add(pr, x, y);
2112 }
2113
2114 static void pr_tile_prepare(PixbufRenderer *pr, ImageTile *it)
2115 {
2116         if (!it->pixmap)
2117                 {
2118                 GdkPixmap *pixmap;
2119                 guint size;
2120
2121                 pixmap = gdk_pixmap_new(((GtkWidget *)pr)->window, pr->tile_width, pr->tile_height, -1);
2122
2123                 size = pixmap_calc_size(pixmap);
2124                 pr_tile_free_space(pr, size, it);
2125
2126                 it->pixmap = pixmap;
2127                 it->size += size;
2128                 pr->tile_cache_size += size;
2129                 }
2130
2131         if ((pr->zoom != 1.0 || pr->source_tiles_enabled || (pr->pixbuf && gdk_pixbuf_get_has_alpha(pr->pixbuf)) ||
2132              pr->orientation != EXIF_ORIENTATION_TOP_LEFT || pr->func_post_process) && !it->pixbuf)
2133                 {
2134                 GdkPixbuf *pixbuf;
2135                 guint size;
2136 #if 0
2137 /* I don't think that we need a pixbuf with alpha channel here */
2138                 if (pr->pixbuf)
2139                         {
2140                         pixbuf = gdk_pixbuf_new(gdk_pixbuf_get_colorspace(pr->pixbuf),
2141                                                 gdk_pixbuf_get_has_alpha(pr->pixbuf),
2142                                                 gdk_pixbuf_get_bits_per_sample(pr->pixbuf),
2143                                                 pr->tile_width, pr->tile_height);
2144                         }
2145                 else
2146 #endif
2147                         {
2148                         pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, pr->tile_width, pr->tile_height);
2149                         }
2150
2151                 size = gdk_pixbuf_get_rowstride(pixbuf) * pr->tile_height;
2152                 pr_tile_free_space(pr, size, it);
2153
2154                 it->pixbuf = pixbuf;
2155                 it->size += size;
2156                 pr->tile_cache_size += size;
2157                 }
2158 }
2159
2160 /*
2161  *-------------------------------------------------------------------
2162  * drawing
2163  *-------------------------------------------------------------------
2164  */
2165
2166
2167 static void pr_tile_coords_map_orientation(PixbufRenderer *pr,
2168                                      gdouble tile_x, gdouble tile_y, /* coordinates of the tile */
2169                                      gdouble image_w, gdouble image_h,
2170                                      gdouble tile_w, gdouble tile_h,
2171                                      gdouble *res_x, gdouble *res_y)
2172 {
2173         *res_x = tile_x;
2174         *res_y = tile_y;
2175         switch (pr->orientation)
2176                 {
2177                 case EXIF_ORIENTATION_TOP_LEFT:
2178                         /* normal -- nothing to do */
2179                         break;
2180                 case EXIF_ORIENTATION_TOP_RIGHT:
2181                         /* mirrored */
2182                         *res_x = image_w - tile_x - tile_w;
2183                         break;
2184                 case EXIF_ORIENTATION_BOTTOM_RIGHT:
2185                         /* upside down */
2186                         *res_x = image_w - tile_x - tile_w;
2187                         *res_y = image_h - tile_y - tile_h;
2188                         break;
2189                 case EXIF_ORIENTATION_BOTTOM_LEFT:
2190                         /* flipped */
2191                         *res_y = image_h - tile_y - tile_h;
2192                         break;
2193                 case EXIF_ORIENTATION_LEFT_TOP:
2194                         *res_x = tile_y;
2195                         *res_y = tile_x;
2196                         break;
2197                 case EXIF_ORIENTATION_RIGHT_TOP:
2198                         /* rotated -90 (270) */
2199                         *res_x = tile_y;
2200                         *res_y = image_w - tile_x - tile_w;
2201                         break;
2202                 case EXIF_ORIENTATION_RIGHT_BOTTOM:
2203                         *res_x = image_h - tile_y - tile_h;
2204                         *res_y = image_w - tile_x - tile_w;
2205                         break;
2206                 case EXIF_ORIENTATION_LEFT_BOTTOM:
2207                         /* rotated 90 */
2208                         *res_x = image_h - tile_y - tile_h;
2209                         *res_y = tile_x;
2210                         break;
2211                 default:
2212                         /* The other values are out of range */
2213                         break;
2214                 }
2215 //      log_printf("tile coord y:%f, ih:%d, th:%f ry:%f\n", tile_y, image_h, tile_h, *res_x);
2216 }
2217
2218 static void pr_tile_region_map_orientation(PixbufRenderer *pr,
2219                                      gint area_x, gint area_y, /* coordinates of the area inside tile */
2220                                      gint tile_w, gint tile_h,
2221                                      gint area_w, gint area_h,
2222                                      gint *res_x, gint *res_y,
2223                                      gint *res_w, gint *res_h)
2224 {
2225         *res_x = area_x;
2226         *res_y = area_y;
2227         *res_w = area_w;
2228         *res_h = area_h;
2229
2230         switch (pr->orientation)
2231                 {
2232                 case EXIF_ORIENTATION_TOP_LEFT:
2233                         /* normal -- nothing to do */
2234                         break;
2235                 case EXIF_ORIENTATION_TOP_RIGHT:
2236                         /* mirrored */
2237                         *res_x = tile_w - area_x - area_w;
2238                         break;
2239                 case EXIF_ORIENTATION_BOTTOM_RIGHT:
2240                         /* upside down */
2241                         *res_x = tile_w - area_x - area_w;
2242                         *res_y = tile_h - area_y - area_h;
2243                         break;
2244                 case EXIF_ORIENTATION_BOTTOM_LEFT:
2245                         /* flipped */
2246                         *res_y = tile_h - area_y - area_h;
2247                         break;
2248                 case EXIF_ORIENTATION_LEFT_TOP:
2249                         *res_x = area_y;
2250                         *res_y = area_x;
2251                         *res_w = area_h;
2252                         *res_h = area_w;
2253                         break;
2254                 case EXIF_ORIENTATION_RIGHT_TOP:
2255                         /* rotated -90 (270) */
2256                         *res_x = area_y;
2257                         *res_y = tile_w - area_x - area_w;
2258                         *res_w = area_h;
2259                         *res_h = area_w;
2260                         break;
2261                 case EXIF_ORIENTATION_RIGHT_BOTTOM:
2262                         *res_x = tile_h - area_y - area_h;
2263                         *res_y = tile_w - area_x - area_w;
2264                         *res_w = area_h;
2265                         *res_h = area_w;
2266                         break;
2267                 case EXIF_ORIENTATION_LEFT_BOTTOM:
2268                         /* rotated 90 */
2269                         *res_x = tile_h - area_y - area_h;
2270                         *res_y = area_x;
2271                         *res_w = area_h;
2272                         *res_h = area_w;
2273                         break;
2274                 default:
2275                         /* The other values are out of range */
2276                         break;
2277                 }
2278 //      log_printf("inside y:%d, th:%d, ah:%d ry:%d\n", area_y, tile_h, area_h, *res_x);
2279 }
2280
2281 static void pr_coords_map_orientation_reverse(PixbufRenderer *pr,
2282                                      gint area_x, gint area_y,
2283                                      gint tile_w, gint tile_h,
2284                                      gint area_w, gint area_h,
2285                                      gint *res_x, gint *res_y,
2286                                      gint *res_w, gint *res_h)
2287 {
2288         *res_x = area_x;
2289         *res_y = area_y;
2290         *res_w = area_w;
2291         *res_h = area_h;
2292
2293         switch (pr->orientation)
2294                 {
2295                 case EXIF_ORIENTATION_TOP_LEFT:
2296                         /* normal -- nothing to do */
2297                         break;
2298                 case EXIF_ORIENTATION_TOP_RIGHT:
2299                         /* mirrored */
2300                         *res_x = tile_w - area_x - area_w;
2301                         break;
2302                 case EXIF_ORIENTATION_BOTTOM_RIGHT:
2303                         /* upside down */
2304                         *res_x = tile_w - area_x - area_w;
2305                         *res_y = tile_h - area_y - area_h;
2306                         break;
2307                 case EXIF_ORIENTATION_BOTTOM_LEFT:
2308                         /* flipped */
2309                         *res_y = tile_h - area_y - area_h;
2310                         break;
2311                 case EXIF_ORIENTATION_LEFT_TOP:
2312                         *res_x = area_y;
2313                         *res_y = area_x;
2314                         *res_w = area_h;
2315                         *res_h = area_w;
2316                         break;
2317                 case EXIF_ORIENTATION_RIGHT_TOP:
2318                         /* rotated -90 (270) */
2319                         *res_x = tile_w - area_y - area_h;
2320                         *res_y = area_x;
2321                         *res_w = area_h;
2322                         *res_h = area_w;
2323                         break;
2324                 case EXIF_ORIENTATION_RIGHT_BOTTOM:
2325                         *res_x = tile_w - area_y - area_h;
2326                         *res_y = tile_h - area_x - area_w;
2327                         *res_w = area_h;
2328                         *res_h = area_w;
2329                         break;
2330                 case EXIF_ORIENTATION_LEFT_BOTTOM:
2331                         /* rotated 90 */
2332                         *res_x = area_y;
2333                         *res_y = tile_h - area_x - area_w;
2334                         *res_w = area_h;
2335                         *res_h = area_w;
2336                         break;
2337                 default:
2338                         /* The other values are out of range */
2339                         break;
2340                 }
2341 }
2342
2343
2344 static GdkPixbuf *pr_get_spare_tile(PixbufRenderer *pr)
2345 {
2346         if (!pr->spare_tile) pr->spare_tile = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, pr->tile_width, pr->tile_height);
2347         return pr->spare_tile;
2348 }
2349
2350 #define COLOR_BYTES 3   /* rgb */
2351
2352 static void pr_tile_rotate_90_clockwise(PixbufRenderer *pr, GdkPixbuf **tile, gint x, gint y, gint w, gint h)
2353 {
2354         GdkPixbuf *src = *tile;
2355         GdkPixbuf *dest;
2356         gint srs, drs;
2357         guchar *s_pix, *d_pix;
2358         guchar *sp, *dp;
2359         guchar *ip, *spi, *dpi;
2360         gint i, j;
2361         gint tw = pr->tile_width;
2362
2363         srs = gdk_pixbuf_get_rowstride(src);
2364         s_pix = gdk_pixbuf_get_pixels(src);
2365         spi = s_pix + (x * COLOR_BYTES);
2366
2367         dest = pr_get_spare_tile(pr);
2368         drs = gdk_pixbuf_get_rowstride(dest);
2369         d_pix = gdk_pixbuf_get_pixels(dest);
2370         dpi = d_pix + (tw - 1) * COLOR_BYTES;
2371
2372         for (i = y; i < y + h; i++)
2373                 {
2374                 sp = spi + (i * srs);
2375                 ip = dpi - (i * COLOR_BYTES);
2376                 for (j = x; j < x + w; j++)
2377                         {
2378                         dp = ip + (j * drs);
2379                         memcpy(dp, sp, COLOR_BYTES);
2380                         sp += COLOR_BYTES;
2381                         }
2382                 }
2383
2384         pr->spare_tile = src;
2385         *tile = dest;
2386 }
2387
2388 static void pr_tile_rotate_90_counter_clockwise(PixbufRenderer *pr, GdkPixbuf **tile, gint x, gint y, gint w, gint h)
2389 {
2390         GdkPixbuf *src = *tile;
2391         GdkPixbuf *dest;
2392         gint srs, drs;
2393         guchar *s_pix, *d_pix;
2394         guchar *sp, *dp;
2395         guchar *ip, *spi, *dpi;
2396         gint i, j;
2397         gint th = pr->tile_height;
2398
2399         srs = gdk_pixbuf_get_rowstride(src);
2400         s_pix = gdk_pixbuf_get_pixels(src);
2401         spi = s_pix + (x * COLOR_BYTES);
2402
2403         dest = pr_get_spare_tile(pr);
2404         drs = gdk_pixbuf_get_rowstride(dest);
2405         d_pix = gdk_pixbuf_get_pixels(dest);
2406         dpi = d_pix + (th - 1) * drs;
2407
2408         for (i = y; i < y + h; i++)
2409                 {
2410                 sp = spi + (i * srs);
2411                 ip = dpi + (i * COLOR_BYTES);
2412                 for (j = x; j < x + w; j++)
2413                         {
2414                         dp = ip - (j * drs);
2415                         memcpy(dp, sp, COLOR_BYTES);
2416                         sp += COLOR_BYTES;
2417                         }
2418                 }
2419
2420         pr->spare_tile = src;
2421         *tile = dest;
2422 }
2423
2424 static void pr_tile_mirror_only(PixbufRenderer *pr, GdkPixbuf **tile, gint x, gint y, gint w, gint h)
2425 {
2426         GdkPixbuf *src = *tile;
2427         GdkPixbuf *dest;
2428         gint srs, drs;
2429         guchar *s_pix, *d_pix;
2430         guchar *sp, *dp;
2431         guchar *spi, *dpi;
2432         gint i, j;
2433
2434         gint tw = pr->tile_width;
2435
2436         srs = gdk_pixbuf_get_rowstride(src);
2437         s_pix = gdk_pixbuf_get_pixels(src);
2438         spi = s_pix + (x * COLOR_BYTES);
2439
2440         dest = pr_get_spare_tile(pr);
2441         drs = gdk_pixbuf_get_rowstride(dest);
2442         d_pix = gdk_pixbuf_get_pixels(dest);
2443         dpi =  d_pix + (tw - x - 1) * COLOR_BYTES;
2444
2445         for (i = y; i < y + h; i++)
2446                 {
2447                 sp = spi + (i * srs);
2448                 dp = dpi + (i * drs);
2449                 for (j = 0; j < w; j++)
2450                         {
2451                         memcpy(dp, sp, COLOR_BYTES);
2452                         sp += COLOR_BYTES;
2453                         dp -= COLOR_BYTES;
2454                         }
2455                 }
2456
2457         pr->spare_tile = src;
2458         *tile = dest;
2459 }
2460
2461 static void pr_tile_mirror_and_flip(PixbufRenderer *pr, GdkPixbuf **tile, gint x, gint y, gint w, gint h)
2462 {
2463         GdkPixbuf *src = *tile;
2464         GdkPixbuf *dest;
2465         gint srs, drs;
2466         guchar *s_pix, *d_pix;
2467         guchar *sp, *dp;
2468         guchar *spi, *dpi;
2469         gint i, j;
2470         gint tw = pr->tile_width;
2471         gint th = pr->tile_height;
2472
2473         srs = gdk_pixbuf_get_rowstride(src);
2474         s_pix = gdk_pixbuf_get_pixels(src);
2475         spi = s_pix + (x * COLOR_BYTES);
2476
2477         dest = pr_get_spare_tile(pr);
2478         drs = gdk_pixbuf_get_rowstride(dest);
2479         d_pix = gdk_pixbuf_get_pixels(dest);
2480         dpi = d_pix + (th - 1) * drs + (tw - 1) * COLOR_BYTES;
2481
2482         for (i = y; i < y + h; i++)
2483                 {
2484                 sp = s_pix + (i * srs) + (x * COLOR_BYTES);
2485                 dp = dpi - (i * drs) - (x * COLOR_BYTES);
2486                 for (j = 0; j < w; j++)
2487                         {
2488                         memcpy(dp, sp, COLOR_BYTES);
2489                         sp += COLOR_BYTES;
2490                         dp -= COLOR_BYTES;
2491                         }
2492                 }
2493
2494         pr->spare_tile = src;
2495         *tile = dest;
2496 }
2497
2498 static void pr_tile_flip_only(PixbufRenderer *pr, GdkPixbuf **tile, gint x, gint y, gint w, gint h)
2499 {
2500         GdkPixbuf *src = *tile;
2501         GdkPixbuf *dest;
2502         gint srs, drs;
2503         guchar *s_pix, *d_pix;
2504         guchar *sp, *dp;
2505         guchar *spi, *dpi;
2506         gint i;
2507         gint th = pr->tile_height;
2508
2509         srs = gdk_pixbuf_get_rowstride(src);
2510         s_pix = gdk_pixbuf_get_pixels(src);
2511         spi = s_pix + (x * COLOR_BYTES);
2512
2513         dest = pr_get_spare_tile(pr);
2514         drs = gdk_pixbuf_get_rowstride(dest);
2515         d_pix = gdk_pixbuf_get_pixels(dest);
2516         dpi = d_pix + (th - 1) * drs + (x * COLOR_BYTES);
2517
2518         for (i = y; i < y + h; i++)
2519                 {
2520                 sp = spi + (i * srs);
2521                 dp = dpi - (i * drs);
2522                 memcpy(dp, sp, w * COLOR_BYTES);
2523                 }
2524
2525         pr->spare_tile = src;
2526         *tile = dest;
2527 }
2528
2529 static void pr_tile_apply_orientation(PixbufRenderer *pr, GdkPixbuf **pixbuf, gint x, gint y, gint w, gint h)
2530 {
2531         switch (pr->orientation)
2532                 {
2533                 case EXIF_ORIENTATION_TOP_LEFT:
2534                         /* normal -- nothing to do */
2535                         break;
2536                 case EXIF_ORIENTATION_TOP_RIGHT:
2537                         /* mirrored */
2538                         {
2539                                 pr_tile_mirror_only(pr, pixbuf, x, y, w, h);
2540                         }
2541                         break;
2542                 case EXIF_ORIENTATION_BOTTOM_RIGHT:
2543                         /* upside down */
2544                         {
2545                                 pr_tile_mirror_and_flip(pr, pixbuf, x, y, w, h);
2546                         }
2547                         break;
2548                 case EXIF_ORIENTATION_BOTTOM_LEFT:
2549                         /* flipped */
2550                         {
2551                                 pr_tile_flip_only(pr, pixbuf, x, y, w, h);
2552                         }
2553                         break;
2554                 case EXIF_ORIENTATION_LEFT_TOP:
2555                         {
2556                                 pr_tile_flip_only(pr, pixbuf, x, y, w, h);
2557                                 pr_tile_rotate_90_clockwise(pr, pixbuf, x, pr->tile_height - y - h, w, h);
2558                         }
2559                         break;
2560                 case EXIF_ORIENTATION_RIGHT_TOP:
2561                         /* rotated -90 (270) */
2562                         {
2563                                 pr_tile_rotate_90_clockwise(pr, pixbuf, x, y, w, h);
2564                         }
2565                         break;
2566                 case EXIF_ORIENTATION_RIGHT_BOTTOM:
2567                         {
2568                                 pr_tile_flip_only(pr, pixbuf, x, y, w, h);
2569                                 pr_tile_rotate_90_counter_clockwise(pr, pixbuf, x, pr->tile_height - y - h, w, h);
2570                         }
2571                         break;
2572                 case EXIF_ORIENTATION_LEFT_BOTTOM:
2573                         /* rotated 90 */
2574                         {
2575                                 pr_tile_rotate_90_counter_clockwise(pr, pixbuf, x, y, w, h);
2576                         }
2577                         break;
2578                 default:
2579                         /* The other values are out of range */
2580                         break;
2581                 }
2582 }
2583
2584
2585 static void pr_tile_render(PixbufRenderer *pr, ImageTile *it,
2586                            gint x, gint y, gint w, gint h,
2587                            gboolean new_data, gboolean fast)
2588 {
2589         GtkWidget *box;
2590         gboolean has_alpha;
2591         gboolean draw = FALSE;
2592
2593         if (it->render_todo == TILE_RENDER_NONE && it->pixmap && !new_data) return;
2594
2595         if (it->render_done != TILE_RENDER_ALL)
2596                 {
2597                 x = 0;
2598                 y = 0;
2599                 w = it->w;
2600                 h = it->h;
2601                 if (!fast) it->render_done = TILE_RENDER_ALL;
2602                 }
2603         else if (it->render_todo != TILE_RENDER_AREA)
2604                 {
2605                 if (!fast) it->render_todo = TILE_RENDER_NONE;
2606                 return;
2607                 }
2608
2609         if (!fast) it->render_todo = TILE_RENDER_NONE;
2610
2611         if (new_data) it->blank = FALSE;
2612
2613         pr_tile_prepare(pr, it);
2614         has_alpha = (pr->pixbuf && gdk_pixbuf_get_has_alpha(pr->pixbuf));
2615
2616         box = GTK_WIDGET(pr);
2617
2618         /* FIXME checker colors for alpha should be configurable,
2619          * also should be drawn for blank = TRUE
2620          */
2621
2622         if (it->blank)
2623                 {
2624                 /* no data, do fast rect fill */
2625                 gdk_draw_rectangle(it->pixmap, box->style->black_gc, TRUE,
2626                                    0, 0, it->w, it->h);
2627                 }
2628         else if (pr->source_tiles_enabled)
2629                 {
2630                 draw = pr_source_tile_render(pr, it, x, y, w, h, new_data, fast);
2631                 }
2632         else if (pr->zoom == 1.0 || pr->scale == 1.0)
2633                 {
2634
2635                 gdouble src_x, src_y;
2636                 gint pb_x, pb_y;
2637                 gint pb_w, pb_h;
2638                 pr_tile_coords_map_orientation(pr, it->x, it->y,
2639                                             pr->image_width, pr->image_height,
2640                                             pr->tile_width, pr->tile_height,
2641                                             &src_x, &src_y);
2642                 pr_tile_region_map_orientation(pr, x, y,
2643                                             pr->tile_width, pr->tile_height,
2644                                             w, h,
2645                                             &pb_x, &pb_y,
2646                                             &pb_w, &pb_h);
2647
2648                 if (has_alpha)
2649                         {
2650                         gdk_pixbuf_composite_color(pr->pixbuf, it->pixbuf, pb_x, pb_y, pb_w, pb_h,
2651                                          (gdouble) 0.0 - src_x,
2652                                          (gdouble) 0.0 - src_y,
2653                                          1.0, 1.0, GDK_INTERP_NEAREST,
2654                                          255, it->x + pb_x, it->y + pb_y,
2655                                          PR_ALPHA_CHECK_SIZE, PR_ALPHA_CHECK1, PR_ALPHA_CHECK2);
2656                         pr_tile_apply_orientation(pr, &it->pixbuf, pb_x, pb_y, pb_w, pb_h);
2657                         draw = TRUE;
2658                         }
2659                 else
2660                         {
2661
2662
2663                         if (pr->orientation == EXIF_ORIENTATION_TOP_LEFT && !(pr->func_post_process && !(pr->post_process_slow && fast)))
2664                                 {
2665                                 /* faster, simple, base orientation, no postprocessing */
2666                                 gdk_draw_pixbuf(it->pixmap,
2667 #if GTK_CHECK_VERSION(2,20,0)
2668                                                 box->style->fg_gc[gtk_widget_get_state(box)],
2669 #else
2670                                                 box->style->fg_gc[GTK_WIDGET_STATE(box)],
2671 #endif
2672                                                 pr->pixbuf,
2673                                                 it->x + x, it->y + y,
2674                                                 x, y,
2675                                                 w, h,
2676                                                 pr->dither_quality, it->x + x, it->y + y);
2677                                 }
2678                         else
2679                                 {
2680                                 gdk_pixbuf_copy_area(pr->pixbuf,
2681                                                      src_x + pb_x, src_y + pb_y,
2682                                                      pb_w, pb_h,
2683                                                      it->pixbuf,
2684                                                      pb_x, pb_y);
2685                                 pr_tile_apply_orientation(pr, &it->pixbuf, pb_x, pb_y, pb_w, pb_h);
2686                                 draw = TRUE;
2687                                 }
2688                         }
2689                 }
2690         else
2691                 {
2692                 gdouble scale_x, scale_y;
2693                 gdouble src_x, src_y;
2694                 gint pb_x, pb_y;
2695                 gint pb_w, pb_h;
2696
2697                 if (pr->image_width == 0 || pr->image_height == 0) return;
2698
2699                 scale_x = (gdouble)pr->width / pr->image_width;
2700                 scale_y = (gdouble)pr->height / pr->image_height;
2701
2702                 pr_tile_coords_map_orientation(pr, it->x, it->y,
2703                                             pr->image_width * scale_x, pr->image_height * scale_y,
2704                                             pr->tile_width, pr->tile_height,
2705                                             &src_x, &src_y);
2706                 pr_tile_region_map_orientation(pr, x, y,
2707                                             pr->tile_width, pr->tile_height,
2708                                             w, h,
2709                                             &pb_x, &pb_y,
2710                                             &pb_w, &pb_h);
2711                 switch (pr->orientation)
2712                         {
2713                         gdouble tmp;
2714                         case EXIF_ORIENTATION_LEFT_TOP:
2715                         case EXIF_ORIENTATION_RIGHT_TOP:
2716                         case EXIF_ORIENTATION_RIGHT_BOTTOM:
2717                         case EXIF_ORIENTATION_LEFT_BOTTOM:
2718                                 tmp = scale_x;
2719                                 scale_x = scale_y;
2720                                 scale_y = tmp;
2721                                 break;
2722                         default:
2723                                 /* nothing to do */
2724                                 break;
2725                         }
2726
2727                 /* HACK: The pixbuf scalers get kinda buggy(crash) with extremely
2728                  * small sizes for anything but GDK_INTERP_NEAREST
2729                  */
2730                 if (pr->width < PR_MIN_SCALE_SIZE || pr->height < PR_MIN_SCALE_SIZE) fast = TRUE;
2731
2732                 if (!has_alpha)
2733                         {
2734                         gdk_pixbuf_scale(pr->pixbuf, it->pixbuf, pb_x, pb_y, pb_w, pb_h,
2735                                          (gdouble) 0.0 - src_x,
2736                                          (gdouble) 0.0 - src_y,
2737                                          scale_x, scale_y,
2738                                          (fast) ? GDK_INTERP_NEAREST : pr->zoom_quality);
2739                         }
2740                 else
2741                         {
2742                         gdk_pixbuf_composite_color(pr->pixbuf, it->pixbuf, pb_x, pb_y, pb_w, pb_h,
2743                                          (gdouble) 0.0 - src_x,
2744                                          (gdouble) 0.0 - src_y,
2745                                          scale_x, scale_y,
2746                                          (fast) ? GDK_INTERP_NEAREST : pr->zoom_quality,
2747                                          255, it->x + pb_x, it->y + pb_y,
2748                                          PR_ALPHA_CHECK_SIZE, PR_ALPHA_CHECK1, PR_ALPHA_CHECK2);
2749                         }
2750                 pr_tile_apply_orientation(pr, &it->pixbuf, pb_x, pb_y, pb_w, pb_h);
2751                 draw = TRUE;
2752                 }
2753
2754         if (draw && it->pixbuf && !it->blank)
2755                 {
2756
2757                 if (pr->func_post_process && !(pr->post_process_slow && fast))
2758                         pr->func_post_process(pr, &it->pixbuf, x, y, w, h, pr->post_process_user_data);
2759
2760                 gdk_draw_pixbuf(it->pixmap,
2761 #if GTK_CHECK_VERSION(2,20,0)
2762                                 box->style->fg_gc[gtk_widget_get_state(box)],
2763 #else
2764                                 box->style->fg_gc[GTK_WIDGET_STATE(box)],
2765 #endif
2766                                 it->pixbuf,
2767                                 x, y,
2768                                 x, y,
2769                                 w, h,
2770                                 pr->dither_quality, it->x + x, it->y + y);
2771                 }
2772
2773 #if 0
2774         /* enable this line for debugging the edges of tiles */
2775         gdk_draw_rectangle(it->pixmap, box->style->white_gc,
2776                            FALSE, 0, 0, it->w, it->h);
2777         gdk_draw_rectangle(it->pixmap, box->style->white_gc,
2778                            FALSE, x, y, w, h);
2779 #endif
2780 }
2781
2782
2783 static void pr_tile_expose(PixbufRenderer *pr, ImageTile *it,
2784                            gint x, gint y, gint w, gint h,
2785                            gboolean new_data, gboolean fast)
2786 {
2787         GtkWidget *box;
2788
2789         pr_tile_render(pr, it, x, y, w, h, new_data, fast);
2790
2791         box = GTK_WIDGET(pr);
2792
2793 #if GTK_CHECK_VERSION(2,20,0)
2794         gdk_draw_drawable(box->window, box->style->fg_gc[gtk_widget_get_state(box)],
2795 #else
2796         gdk_draw_drawable(box->window, box->style->fg_gc[GTK_WIDGET_STATE(box)],
2797 #endif
2798                           it->pixmap, x, y,
2799                           pr->x_offset + (it->x - pr->x_scroll) + x, pr->y_offset + (it->y - pr->y_scroll) + y, w, h);
2800
2801         if (pr->overlay_list)
2802                 {
2803                 pr_overlay_draw(pr, pr->x_offset + (it->x - pr->x_scroll) + x,
2804                                 pr->y_offset + (it->y - pr->y_scroll) + y,
2805                                 w, h,
2806                                 it);
2807                 }
2808 }
2809
2810
2811 static gboolean pr_tile_is_visible(PixbufRenderer *pr, ImageTile *it)
2812 {
2813         return (it->x + it->w >= pr->x_scroll && it->x < pr->x_scroll + pr->vis_width &&
2814                 it->y + it->h >= pr->y_scroll && it->y < pr->y_scroll + pr->vis_height);
2815 }
2816
2817 /*
2818  *-------------------------------------------------------------------
2819  * draw queue
2820  *-------------------------------------------------------------------
2821  */
2822
2823 static gint pr_get_queued_area(GList *work)
2824 {
2825         gint area = 0;
2826
2827         while (work)
2828                 {
2829                 QueueData *qd = work->data;
2830                 area += qd->w * qd->h;
2831                 work = work->next;
2832                 }
2833         return area;
2834 }
2835
2836
2837 static gboolean pr_queue_schedule_next_draw(PixbufRenderer *pr, gboolean force_set)
2838 {
2839         gfloat percent;
2840         gint visible_area = pr->vis_width * pr->vis_height;
2841
2842         if (!pr->loading)
2843                 {
2844                 /* 2pass prio */
2845                 DEBUG_2("redraw priority: 2pass");
2846                 pr->draw_idle_id = g_idle_add_full(G_PRIORITY_DEFAULT_IDLE, pr_queue_draw_idle_cb, pr, NULL);
2847                 return FALSE;
2848                 }
2849
2850         if (visible_area == 0)
2851                 {
2852                 /* not known yet */
2853                 percent = 100.0;
2854                 }
2855         else
2856                 {
2857                 percent = 100.0 * pr_get_queued_area(pr->draw_queue) / visible_area;
2858                 }
2859
2860         if (percent > 10.0)
2861                 {
2862                 /* we have enough data for starting intensive redrawing */
2863                 DEBUG_2("redraw priority: high %.2f %%", percent);
2864                 pr->draw_idle_id = g_idle_add_full(GDK_PRIORITY_REDRAW, pr_queue_draw_idle_cb, pr, NULL);
2865                 return FALSE;
2866                 }
2867
2868         if (percent < 1.0 || force_set)
2869                 {
2870                 /* queue is (almost) empty, wait  50 ms*/
2871                 DEBUG_2("redraw priority: wait %.2f %%", percent);
2872                 pr->draw_idle_id = g_timeout_add_full(G_PRIORITY_DEFAULT_IDLE, 50, pr_queue_draw_idle_cb, pr, NULL);
2873                 return FALSE;
2874                 }
2875
2876         /* keep the same priority as before */
2877         DEBUG_2("redraw priority: no change %.2f %%", percent);
2878         return TRUE;
2879 }
2880
2881
2882 static gboolean pr_queue_draw_idle_cb(gpointer data)
2883 {
2884         PixbufRenderer *pr = data;
2885         QueueData *qd;
2886         gboolean fast;
2887
2888
2889         if ((!pr->pixbuf && !pr->source_tiles_enabled) ||
2890             (!pr->draw_queue && !pr->draw_queue_2pass) ||
2891             !pr->draw_idle_id)
2892                 {
2893                 pr_render_complete_signal(pr);
2894
2895                 pr->draw_idle_id = 0;
2896                 return FALSE;
2897                 }
2898
2899         if (pr->draw_queue)
2900                 {
2901                 qd = pr->draw_queue->data;
2902                 fast = (pr->zoom_2pass && ((pr->zoom_quality != GDK_INTERP_NEAREST && pr->scale != 1.0) || pr->post_process_slow));
2903                 }
2904         else
2905                 {
2906                 if (pr->loading)
2907                         {
2908                         /* still loading, wait till done (also drops the higher priority) */
2909
2910                         return pr_queue_schedule_next_draw(pr, FALSE);
2911                         }
2912
2913                 qd = pr->draw_queue_2pass->data;
2914                 fast = FALSE;
2915                 }
2916
2917 #if GTK_CHECK_VERSION(2,20,0)
2918         if (gtk_widget_get_realized(pr))
2919 #else
2920         if (GTK_WIDGET_REALIZED(pr))
2921 #endif
2922                 {
2923                 if (pr_tile_is_visible(pr, qd->it))
2924                         {
2925                         pr_tile_expose(pr, qd->it, qd->x, qd->y, qd->w, qd->h, qd->new_data, fast);
2926                         }
2927                 else if (qd->new_data)
2928                         {
2929                         /* if new pixel data, and we already have a pixmap, update the tile */
2930                         qd->it->blank = FALSE;
2931                         if (qd->it->pixmap && qd->it->render_done == TILE_RENDER_ALL)
2932                                 {
2933                                 pr_tile_render(pr, qd->it, qd->x, qd->y, qd->w, qd->h, qd->new_data, fast);
2934                                 }
2935                         }
2936                 }
2937
2938         if (pr->draw_queue)
2939                 {
2940                 qd->it->qd = NULL;
2941                 pr->draw_queue = g_list_remove(pr->draw_queue, qd);
2942                 if (fast)
2943                         {
2944                         if (qd->it->qd2)
2945                                 {
2946                                 pr_queue_merge(qd->it->qd2, qd);
2947                                 g_free(qd);
2948                                 }
2949                         else
2950                                 {
2951                                 qd->it->qd2 = qd;
2952                                 pr->draw_queue_2pass = g_list_append(pr->draw_queue_2pass, qd);
2953                                 }
2954                         }
2955                 else
2956                         {
2957                         g_free(qd);
2958                         }
2959                 }
2960         else
2961                 {
2962                 qd->it->qd2 = NULL;
2963                 pr->draw_queue_2pass = g_list_remove(pr->draw_queue_2pass, qd);
2964                 g_free(qd);
2965                 }
2966
2967         if (!pr->draw_queue && !pr->draw_queue_2pass)
2968                 {
2969                 pr_render_complete_signal(pr);
2970
2971                 pr->draw_idle_id = 0;
2972                 return FALSE;
2973                 }
2974
2975                 return pr_queue_schedule_next_draw(pr, FALSE);
2976 }
2977
2978 static void pr_queue_list_free(GList *list)
2979 {
2980         GList *work;
2981
2982         work = list;
2983         while (work)
2984                 {
2985                 QueueData *qd;
2986
2987                 qd = work->data;
2988                 work = work->next;
2989
2990                 qd->it->qd = NULL;
2991                 qd->it->qd2 = NULL;
2992                 g_free(qd);
2993                 }
2994
2995         g_list_free(list);
2996 }
2997
2998 static void pr_queue_clear(PixbufRenderer *pr)
2999 {
3000         pr_queue_list_free(pr->draw_queue);
3001         pr->draw_queue = NULL;
3002
3003         pr_queue_list_free(pr->draw_queue_2pass);
3004         pr->draw_queue_2pass = NULL;
3005
3006         if (pr->draw_idle_id)
3007                 {
3008                 g_source_remove(pr->draw_idle_id);
3009                 pr->draw_idle_id = 0;
3010                 }
3011 }
3012
3013 static void pr_queue_merge(QueueData *parent, QueueData *qd)
3014 {
3015         if (parent->x + parent->w < qd->x + qd->w)
3016                 {
3017                 parent->w += (qd->x + qd->w) - (parent->x + parent->w);
3018                 }
3019         if (parent->x > qd->x)
3020                 {
3021                 parent->w += parent->x - qd->x;
3022                 parent->x = qd->x;
3023                 }
3024
3025         if (parent->y + parent->h < qd->y + qd->h)
3026                 {
3027                 parent->h += (qd->y + qd->h) - (parent->y + parent->h);
3028                 }
3029         if (parent->y > qd->y)
3030                 {
3031                 parent->h += parent->y - qd->y;
3032                 parent->y = qd->y;
3033                 }
3034
3035         parent->new_data |= qd->new_data;
3036 }
3037
3038 static gboolean pr_clamp_to_visible(PixbufRenderer *pr, gint *x, gint *y, gint *w, gint *h)
3039 {
3040         gint nx, ny;
3041         gint nw, nh;
3042         gint vx, vy;
3043         gint vw, vh;
3044
3045         vw = pr->vis_width;
3046         vh = pr->vis_height;
3047
3048         vx = pr->x_scroll;
3049         vy = pr->y_scroll;
3050
3051         if (*x + *w < vx || *x > vx + vw || *y + *h < vy || *y > vy + vh) return FALSE;
3052
3053         /* now clamp it */
3054         nx = CLAMP(*x, vx, vx + vw);
3055         nw = CLAMP(*w - (nx - *x), 1, vw);
3056
3057         ny = CLAMP(*y, vy, vy + vh);
3058         nh = CLAMP(*h - (ny - *y), 1, vh);
3059
3060         *x = nx;
3061         *y = ny;
3062         *w = nw;
3063         *h = nh;
3064
3065         return TRUE;
3066 }
3067
3068 static gboolean pr_queue_to_tiles(PixbufRenderer *pr, gint x, gint y, gint w, gint h,
3069                                   gboolean clamp, ImageTileRenderType render,
3070                                   gboolean new_data, gboolean only_existing)
3071 {
3072         gint i, j;
3073         gint x1, x2;
3074         gint y1, y2;
3075
3076         if (clamp && !pr_clamp_to_visible(pr, &x, &y, &w, &h)) return FALSE;
3077
3078         x1 = ROUND_DOWN(x, pr->tile_width);
3079         x2 = ROUND_UP(x + w, pr->tile_width);
3080
3081         y1 = ROUND_DOWN(y, pr->tile_height);
3082         y2 = ROUND_UP(y + h, pr->tile_height);
3083
3084         for (j = y1; j <= y2; j += pr->tile_height)
3085                 {
3086                 for (i = x1; i <= x2; i += pr->tile_width)
3087                         {
3088                         ImageTile *it;
3089
3090                         it = pr_tile_get(pr, i, j,
3091                                          (only_existing &&
3092                                           (i + pr->tile_width < pr->x_scroll ||
3093                                            i > pr->x_scroll + pr->vis_width ||
3094                                            j + pr->tile_height < pr->y_scroll ||
3095                                            j > pr->y_scroll + pr->vis_height)));
3096                         if (it)
3097                                 {
3098                                 QueueData *qd;
3099
3100                                 if ((render == TILE_RENDER_ALL && it->render_done != TILE_RENDER_ALL) ||
3101                                     (render == TILE_RENDER_AREA && it->render_todo != TILE_RENDER_ALL))
3102                                         {
3103                                         it->render_todo = render;
3104                                         }
3105
3106                                 qd = g_new(QueueData, 1);
3107                                 qd->it = it;
3108                                 qd->new_data = new_data;
3109
3110                                 if (i < x)
3111                                         {
3112                                         qd->x = x - i;
3113                                         }
3114                                 else
3115                                         {
3116                                         qd->x = 0;
3117                                         }
3118                                 qd->w = x + w - i - qd->x;
3119                                 if (qd->x + qd->w > pr->tile_width) qd->w = pr->tile_width - qd->x;
3120
3121                                 if (j < y)
3122                                         {
3123                                         qd->y = y - j;
3124                                         }
3125                                 else
3126                                         {
3127                                         qd->y = 0;
3128                                         }
3129                                 qd->h = y + h - j - qd->y;
3130                                 if (qd->y + qd->h > pr->tile_height) qd->h = pr->tile_height - qd->y;
3131
3132                                 if (qd->w < 1 || qd->h < 1)
3133                                         {
3134                                         g_free(qd);
3135                                         }
3136                                 else if (it->qd)
3137                                         {
3138                                         pr_queue_merge(it->qd, qd);
3139                                         g_free(qd);
3140                                         }
3141                                 else
3142                                         {
3143                                         it->qd = qd;
3144                                         pr->draw_queue = g_list_append(pr->draw_queue, qd);
3145                                         }
3146                                 }
3147                         }
3148                 }
3149
3150         return TRUE;
3151 }
3152
3153 static void pr_queue(PixbufRenderer *pr, gint x, gint y, gint w, gint h,
3154                      gboolean clamp, ImageTileRenderType render,
3155                      gboolean new_data, gboolean only_existing)
3156 {
3157         gint nx, ny;
3158
3159         nx = CLAMP(x, 0, pr->width - 1);
3160         ny = CLAMP(y, 0, pr->height - 1);
3161         w -= (nx - x);
3162         h -= (ny - y);
3163         w = CLAMP(w, 0, pr->width - nx);
3164         h = CLAMP(h, 0, pr->height - ny);
3165         if (w < 1 || h < 1) return;
3166
3167         if (pr_queue_to_tiles(pr, nx, ny, w, h, clamp, render, new_data, only_existing) &&
3168             ((!pr->draw_queue && !pr->draw_queue_2pass) || !pr->draw_idle_id))
3169                 {
3170                 if (pr->draw_idle_id)
3171                         {
3172                         g_source_remove(pr->draw_idle_id);
3173                         pr->draw_idle_id = 0;
3174                         }
3175                 pr_queue_schedule_next_draw(pr, TRUE);
3176                 }
3177 }
3178
3179 static void pr_redraw(PixbufRenderer *pr, gboolean new_data)
3180 {
3181         pr_queue_clear(pr);
3182         pr_queue(pr, 0, 0, pr->width, pr->height, TRUE, TILE_RENDER_ALL, new_data, FALSE);
3183 }
3184
3185 /*
3186  *-------------------------------------------------------------------
3187  * signal emission
3188  *-------------------------------------------------------------------
3189  */
3190
3191 static void pr_update_signal(PixbufRenderer *pr)
3192 {
3193 #if 0
3194         log_printf("FIXME: send updated signal\n");
3195 #endif
3196         DEBUG_1("%s pixbuf renderer updated - started drawing %p, img: %dx%d", get_exec_time(), pr, pr->image_width, pr->image_height);
3197         pr->debug_updated = TRUE;
3198 }
3199
3200 static void pr_zoom_signal(PixbufRenderer *pr)
3201 {
3202         g_signal_emit(pr, signals[SIGNAL_ZOOM], 0, pr->zoom);
3203 }
3204
3205 static void pr_clicked_signal(PixbufRenderer *pr, GdkEventButton *bevent)
3206 {
3207         g_signal_emit(pr, signals[SIGNAL_CLICKED], 0, bevent);
3208 }
3209
3210 static void pr_scroll_notify_signal(PixbufRenderer *pr)
3211 {
3212         g_signal_emit(pr, signals[SIGNAL_SCROLL_NOTIFY], 0);
3213 }
3214
3215 static void pr_render_complete_signal(PixbufRenderer *pr)
3216 {
3217         if (!pr->complete)
3218                 {
3219                 g_signal_emit(pr, signals[SIGNAL_RENDER_COMPLETE], 0);
3220                 g_object_set(G_OBJECT(pr), "complete", TRUE, NULL);
3221                 }
3222         if (pr->debug_updated)
3223                 {
3224                 DEBUG_1("%s pixbuf renderer done %p", get_exec_time(), pr);
3225                 pr->debug_updated = FALSE;
3226                 }
3227 }
3228
3229 static void pr_drag_signal(PixbufRenderer *pr, GdkEventButton *bevent)
3230 {
3231         g_signal_emit(pr, signals[SIGNAL_DRAG], 0, bevent);
3232 }
3233
3234 static void pr_update_pixel_signal(PixbufRenderer *pr)
3235 {
3236         g_signal_emit(pr, signals[SIGNAL_UPDATE_PIXEL], 0);
3237 }
3238
3239 /*
3240  *-------------------------------------------------------------------
3241  * sync and clamp
3242  *-------------------------------------------------------------------
3243  */
3244
3245 static void pixbuf_renderer_sync_scroll_center(PixbufRenderer *pr)
3246 {
3247         gint src_x, src_y;
3248         if (!pr->width || !pr->height) return;
3249
3250         /*
3251          * Update norm_center only if the image is bigger than the window.
3252          * With this condition the stored center survives also a temporary display
3253          * of the "broken image" icon.
3254         */
3255
3256         if (pr->width > pr->window_width)
3257                 {
3258                 src_x = pr->x_scroll + pr->vis_width / 2;
3259                 pr->norm_center_x = (gdouble)src_x / pr->width;
3260                 }
3261
3262         if (pr->height > pr->window_height)
3263                 {
3264                 src_y = pr->y_scroll + pr->vis_height / 2;
3265                 pr->norm_center_y = (gdouble)src_y / pr->height;
3266                 }
3267 }
3268
3269
3270 static gboolean pr_scroll_clamp(PixbufRenderer *pr)
3271 {
3272         gint old_xs;
3273         gint old_ys;
3274
3275         if (pr->zoom == 0.0)
3276                 {
3277                 pr->x_scroll = 0;
3278                 pr->y_scroll = 0;
3279
3280                 return FALSE;
3281                 }
3282
3283         old_xs = pr->x_scroll;
3284         old_ys = pr->y_scroll;
3285
3286         if (pr->x_offset > 0)
3287                 {
3288                 pr->x_scroll = 0;
3289                 }
3290         else
3291                 {
3292                 pr->x_scroll = CLAMP(pr->x_scroll, 0, pr->width - pr->vis_width);
3293                 }
3294
3295         if (pr->y_offset > 0)
3296                 {
3297                 pr->y_scroll = 0;
3298                 }
3299         else
3300                 {
3301                 pr->y_scroll = CLAMP(pr->y_scroll, 0, pr->height - pr->vis_height);
3302                 }
3303
3304         pixbuf_renderer_sync_scroll_center(pr);
3305
3306         return (old_xs != pr->x_scroll || old_ys != pr->y_scroll);
3307 }
3308
3309 static gboolean pr_size_clamp(PixbufRenderer *pr)
3310 {
3311         gint old_vw, old_vh;
3312
3313         old_vw = pr->vis_width;
3314         old_vh = pr->vis_height;
3315
3316         if (pr->width < pr->window_width)
3317                 {
3318                 pr->vis_width = pr->width;
3319                 pr->x_offset = (pr->window_width - pr->width) / 2;
3320                 }
3321         else
3322                 {
3323                 pr->vis_width = pr->window_width;
3324                 pr->x_offset = 0;
3325                 }
3326
3327         if (pr->height < pr->window_height)
3328                 {
3329                 pr->vis_height = pr->height;
3330                 pr->y_offset = (pr->window_height - pr->height) / 2;
3331                 }
3332         else
3333                 {
3334                 pr->vis_height = pr->window_height;
3335                 pr->y_offset = 0;
3336                 }
3337
3338         pixbuf_renderer_sync_scroll_center(pr);
3339
3340         return (old_vw != pr->vis_width || old_vh != pr->vis_height);
3341 }
3342
3343 static gboolean pr_zoom_clamp(PixbufRenderer *pr, gdouble zoom,
3344                               PrZoomFlags flags, gboolean *redrawn)
3345 {
3346         gint w, h;
3347         gdouble scale;
3348         gboolean invalid;
3349         gboolean force = !!(flags & PR_ZOOM_FORCE);
3350         gboolean new = !!(flags & PR_ZOOM_NEW);
3351         gboolean invalidate = !!(flags & PR_ZOOM_INVALIDATE);
3352         gboolean lazy = !!(flags & PR_ZOOM_LAZY);
3353
3354         zoom = CLAMP(zoom, pr->zoom_min, pr->zoom_max);
3355
3356         if (pr->zoom == zoom && !force) return FALSE;
3357
3358         w = pr->image_width;
3359         h = pr->image_height;
3360
3361         if (zoom == 0.0 && !pr->pixbuf)
3362                 {
3363                 scale = 1.0;
3364                 }
3365         else if (zoom == 0.0)
3366                 {
3367                 gint max_w;
3368                 gint max_h;
3369                 gboolean sizeable;
3370
3371                 sizeable = (new && pr_parent_window_sizable(pr));
3372
3373                 if (sizeable)
3374                         {
3375                         max_w = gdk_screen_width();
3376                         max_h = gdk_screen_height();
3377
3378                         if (pr->window_limit)
3379                                 {
3380                                 max_w = max_w * pr->window_limit_size / 100;
3381                                 max_h = max_h * pr->window_limit_size / 100;
3382                                 }
3383                         }
3384                 else
3385                         {
3386                         max_w = pr->window_width;
3387                         max_h = pr->window_height;
3388                         }
3389
3390                 if ((pr->zoom_expand && !sizeable) || w > max_w || h > max_h)
3391                         {
3392                         if ((gdouble)max_w / w > (gdouble)max_h / h)
3393                                 {
3394                                 scale = (gdouble)max_h / h;
3395                                 h = max_h;
3396                                 w = w * scale + 0.5;
3397                                 if (w > max_w) w = max_w;
3398                                 }
3399                         else
3400                                 {
3401                                 scale = (gdouble)max_w / w;
3402                                 w = max_w;
3403                                 h = h * scale + 0.5;
3404                                 if (h > max_h) h = max_h;
3405                                 }
3406
3407                         if (pr->autofit_limit)
3408                                 {
3409                                 gdouble factor = (gdouble)pr->autofit_limit_size / 100;
3410                                 w = w * factor + 0.5;
3411                                 h = h * factor + 0.5;
3412                                 scale = scale * factor;
3413                                 }
3414
3415                         if (w < 1) w = 1;
3416                         if (h < 1) h = 1;
3417                         }
3418                 else
3419                         {
3420                         scale = 1.0;
3421                         }
3422                 }
3423         else if (zoom > 0.0) /* zoom orig, in */
3424                 {
3425                 scale = zoom;
3426                 w = w * scale;
3427                 h = h * scale;
3428                 }
3429         else /* zoom out */
3430                 {
3431                 scale = 1.0 / (0.0 - zoom);
3432                 w = w * scale;
3433                 h = h * scale;
3434                 }
3435
3436         invalid = (pr->width != w || pr->height != h);
3437
3438         pr->zoom = zoom;
3439         pr->width = w;
3440         pr->height = h;
3441         pr->scale = scale;
3442
3443         if (invalidate || invalid)
3444                 {
3445                 pr_tile_invalidate_all(pr);
3446                 if (!lazy) pr_redraw(pr, TRUE);
3447                 }
3448         if (redrawn) *redrawn = (invalidate || invalid);
3449
3450         pixbuf_renderer_sync_scroll_center(pr);
3451
3452         return TRUE;
3453 }
3454
3455 static void pr_zoom_sync(PixbufRenderer *pr, gdouble zoom,
3456                          PrZoomFlags flags, gint px, gint py)
3457 {
3458         gdouble old_scale;
3459         gint old_cx, old_cy;
3460         gboolean clamped;
3461         gboolean sized;
3462         gboolean redrawn = FALSE;
3463         gboolean center_point = !!(flags & PR_ZOOM_CENTER);
3464         gboolean force = !!(flags & PR_ZOOM_FORCE);
3465         gboolean new = !!(flags & PR_ZOOM_NEW);
3466         gboolean lazy = !!(flags & PR_ZOOM_LAZY);
3467         PrZoomFlags clamp_flags = flags;
3468         gdouble old_center_x = pr->norm_center_x;
3469         gdouble old_center_y = pr->norm_center_y;
3470
3471         old_scale = pr->scale;
3472         if (center_point)
3473                 {
3474                 px = CLAMP(px, 0, pr->width);
3475                 py = CLAMP(py, 0, pr->height);
3476                 old_cx = pr->x_scroll + (px - pr->x_offset);
3477                 old_cy = pr->y_scroll + (py - pr->y_offset);
3478                 }
3479         else
3480                 {
3481                 px = py = 0;
3482                 old_cx = pr->x_scroll + pr->vis_width / 2;
3483                 old_cy = pr->y_scroll + pr->vis_height / 2;
3484                 }
3485
3486         if (force) clamp_flags |= PR_ZOOM_INVALIDATE;
3487         if (lazy) clamp_flags |= PR_ZOOM_LAZY;
3488         if (!pr_zoom_clamp(pr, zoom, clamp_flags, &redrawn)) return;
3489
3490         clamped = pr_size_clamp(pr);
3491         sized = pr_parent_window_resize(pr, pr->width, pr->height);
3492
3493         if (force && new)
3494                 {
3495                 switch (pr->scroll_reset)
3496                         {
3497                         case PR_SCROLL_RESET_NOCHANGE:
3498                                 /* maintain old scroll position */
3499                                 pr->x_scroll = ((gdouble)pr->image_width * old_center_x * pr->scale) - pr->vis_width / 2;
3500                                 pr->y_scroll = ((gdouble)pr->image_height * old_center_y * pr->scale) - pr->vis_height / 2;
3501                                 break;
3502                         case PR_SCROLL_RESET_CENTER:
3503                                 /* center new image */
3504                                 pr->x_scroll = ((gdouble)pr->image_width / 2.0 * pr->scale) - pr->vis_width / 2;
3505                                 pr->y_scroll = ((gdouble)pr->image_height / 2.0 * pr->scale) - pr->vis_height / 2;
3506                                 break;
3507                         case PR_SCROLL_RESET_TOPLEFT:
3508                         default:
3509                                 /* reset to upper left */
3510                                 pr->x_scroll = 0;
3511                                 pr->y_scroll = 0;
3512                                 break;
3513                         }
3514                 }
3515         else
3516                 {
3517                 /* user zoom does not force, so keep visible center point */
3518                 if (center_point)
3519                         {
3520                         pr->x_scroll = old_cx / old_scale * pr->scale - (px - pr->x_offset);
3521                         pr->y_scroll = old_cy / old_scale * pr->scale - (py - pr->y_offset);
3522                         }
3523                 else
3524                         {
3525                         pr->x_scroll = old_cx / old_scale * pr->scale - (pr->vis_width / 2);
3526                         pr->y_scroll = old_cy / old_scale * pr->scale - (pr->vis_height / 2);
3527                         }
3528                 }
3529
3530         pr_scroll_clamp(pr);
3531
3532         /* If the window was not sized, redraw the image - we know there will be no size/expose signal.
3533          * But even if a size is claimed, there is no guarantee that the window manager will allow it,
3534          * so redraw the window anyway :/
3535          */
3536         if (sized || clamped) pr_border_clear(pr);
3537
3538         if (lazy)
3539                 {
3540                 pr_queue_clear(pr);
3541                 }
3542         else
3543                 {
3544                 pr_redraw(pr, redrawn);
3545                 }
3546
3547         pr_scroll_notify_signal(pr);
3548         pr_zoom_signal(pr);
3549         pr_update_signal(pr);
3550 }
3551
3552 static void pr_size_sync(PixbufRenderer *pr, gint new_width, gint new_height)
3553 {
3554         gboolean zoom_changed = FALSE;
3555
3556         if (pr->window_width == new_width && pr->window_height == new_height) return;
3557
3558         pr->window_width = new_width;
3559         pr->window_height = new_height;
3560
3561         if (pr->zoom == 0.0)
3562                 {
3563                 gdouble old_scale = pr->scale;
3564                 pr_zoom_clamp(pr, 0.0, PR_ZOOM_FORCE, NULL);
3565                 zoom_changed = (old_scale != pr->scale);
3566                 }
3567
3568         pr_size_clamp(pr);
3569         pr_scroll_clamp(pr);
3570
3571         pr_overlay_update_sizes(pr);
3572
3573         /* ensure scroller remains visible */
3574         if (pr->scroller_overlay != -1)
3575                 {
3576                 gboolean update = FALSE;
3577
3578                 if (pr->scroller_x > new_width)
3579                         {
3580                         pr->scroller_x = new_width;
3581                         pr->scroller_xpos = new_width;
3582                         update = TRUE;
3583                         }
3584                 if (pr->scroller_y > new_height)
3585                         {
3586                         pr->scroller_y = new_height;
3587                         pr->scroller_ypos = new_height;
3588                         update = TRUE;
3589                         }
3590
3591                 if (update)
3592                         {
3593                         GdkPixbuf *pixbuf;
3594
3595                         if (pixbuf_renderer_overlay_get(pr, pr->scroller_overlay, &pixbuf, NULL, NULL))
3596                                 {
3597                                 gint w, h;
3598
3599                                 w = gdk_pixbuf_get_width(pixbuf);
3600                                 h = gdk_pixbuf_get_height(pixbuf);
3601                                 pixbuf_renderer_overlay_set(pr, pr->scroller_overlay, pixbuf,
3602                                                             pr->scroller_x - w / 2, pr->scroller_y - h / 2);
3603                                 }
3604                         }
3605                 }
3606
3607         pr_border_clear(pr);
3608
3609         pr_scroll_notify_signal(pr);
3610         if (zoom_changed) pr_zoom_signal(pr);
3611         pr_update_signal(pr);
3612 }
3613
3614 static void pr_size_cb(GtkWidget *widget, GtkAllocation *allocation, gpointer data)
3615 {
3616         PixbufRenderer *pr = data;
3617
3618         pr_size_sync(pr, allocation->width, allocation->height);
3619 }
3620
3621 static void pixbuf_renderer_paint(PixbufRenderer *pr, GdkRectangle *area)
3622 {
3623         gint x, y;
3624
3625         pr_border_draw(pr, area->x, area->y, area->width, area->height);
3626
3627         x = MAX(0, (gint)area->x - pr->x_offset + pr->x_scroll);
3628         y = MAX(0, (gint)area->y - pr->y_offset + pr->y_scroll);
3629
3630         pr_queue(pr, x, y,
3631                  MIN((gint)area->width, pr->width - x),
3632                  MIN((gint)area->height, pr->height - y),
3633                  FALSE, TILE_RENDER_ALL, FALSE, FALSE);
3634 }
3635
3636 /*
3637  *-------------------------------------------------------------------
3638  * scrolling
3639  *-------------------------------------------------------------------
3640  */
3641
3642 void pixbuf_renderer_scroll(PixbufRenderer *pr, gint x, gint y)
3643 {
3644         gint old_x, old_y;
3645         gint x_off, y_off;
3646         gint w, h;
3647
3648         g_return_if_fail(IS_PIXBUF_RENDERER(pr));
3649
3650         if (!pr->pixbuf && !pr->source_tiles_enabled) return;
3651
3652         old_x = pr->x_scroll;
3653         old_y = pr->y_scroll;
3654
3655         pr->x_scroll += x;
3656         pr->y_scroll += y;
3657
3658         pr_scroll_clamp(pr);
3659
3660         pixbuf_renderer_sync_scroll_center(pr);
3661
3662         if (pr->x_scroll == old_x && pr->y_scroll == old_y) return;
3663
3664         pr_scroll_notify_signal(pr);
3665
3666         x_off = pr->x_scroll - old_x;
3667         y_off = pr->y_scroll - old_y;
3668
3669         w = pr->vis_width - abs(x_off);
3670         h = pr->vis_height - abs(y_off);
3671
3672         if (w < 1 || h < 1)
3673                 {
3674                 /* scrolled completely to new material */
3675                 pr_queue(pr, 0, 0, pr->width, pr->height, TRUE, TILE_RENDER_ALL, FALSE, FALSE);
3676                 return;
3677                 }
3678         else
3679                 {
3680                 gint x1, y1;
3681                 gint x2, y2;
3682                 GtkWidget *box;
3683                 GdkGC *gc;
3684                 GdkEvent *event;
3685
3686                 if (x_off < 0)
3687                         {
3688                         x1 = abs(x_off);
3689                         x2 = 0;
3690                         }
3691                 else
3692                         {
3693                         x1 = 0;
3694                         x2 = abs(x_off);
3695                         }
3696
3697                 if (y_off < 0)
3698                         {
3699                         y1 = abs(y_off);
3700                         y2 = 0;
3701                         }
3702                 else
3703                         {
3704                         y1 = 0;
3705                         y2 = abs(y_off);
3706                         }
3707
3708                 box = GTK_WIDGET(pr);
3709
3710                 gc = gdk_gc_new(box->window);
3711                 gdk_gc_set_exposures(gc, TRUE);
3712                 gdk_draw_drawable(box->window, gc,
3713                                   box->window,
3714                                   x2 + pr->x_offset, y2 + pr->y_offset,
3715                                   x1 + pr->x_offset, y1 + pr->y_offset, w, h);
3716                 g_object_unref(gc);
3717
3718                 if (pr->overlay_list)
3719                         {
3720                         pr_overlay_queue_all(pr);
3721                         }
3722
3723                 w = pr->vis_width - w;
3724                 h = pr->vis_height - h;
3725
3726                 if (w > 0)
3727                         {
3728                         pr_queue(pr,
3729                                  x_off > 0 ? pr->x_scroll + (pr->vis_width - w) : pr->x_scroll, pr->y_scroll,
3730                                  w, pr->vis_height, TRUE, TILE_RENDER_ALL, FALSE, FALSE);
3731                         }
3732                 if (h > 0)
3733                         {
3734                         /* FIXME, to optimize this, remove overlap */
3735                         pr_queue(pr,
3736                                  pr->x_scroll, y_off > 0 ? pr->y_scroll + (pr->vis_height - h) : pr->y_scroll,
3737                                  pr->vis_width, h, TRUE, TILE_RENDER_ALL, FALSE, FALSE);
3738                         }
3739
3740                 /* process exposures here, "expose_event" seems to miss a few with obstructed windows */
3741 #if ! GTK_CHECK_VERSION(2,18,0)
3742                 while ((event = gdk_event_get_graphics_expose(box->window)) != NULL)
3743                         {
3744                         pixbuf_renderer_paint(pr, &event->expose.area);
3745
3746                         if (event->expose.count == 0)
3747                                 {
3748                                 gdk_event_free(event);
3749                                 break;
3750                                 }
3751                         gdk_event_free(event);
3752                         }
3753 #endif
3754                 }
3755 }
3756
3757 void pixbuf_renderer_scroll_to_point(PixbufRenderer *pr, gint x, gint y,
3758                                      gdouble x_align, gdouble y_align)
3759 {
3760         gint px, py;
3761         gint ax, ay;
3762
3763         x_align = CLAMP(x_align, 0.0, 1.0);
3764         y_align = CLAMP(y_align, 0.0, 1.0);
3765
3766         ax = (gdouble)pr->vis_width * x_align;
3767         ay = (gdouble)pr->vis_height * y_align;
3768
3769         px = (gdouble)x * pr->scale - (pr->x_scroll + ax);
3770         py = (gdouble)y * pr->scale - (pr->y_scroll + ay);
3771
3772         pixbuf_renderer_scroll(pr, px, py);
3773 }
3774
3775 /* get or set coordinates of viewport center in the image, in range 0.0 - 1.0 */
3776
3777 void pixbuf_renderer_get_scroll_center(PixbufRenderer *pr, gdouble *x, gdouble *y)
3778 {
3779         *x = pr->norm_center_x;
3780         *y = pr->norm_center_y;
3781 }
3782
3783 void pixbuf_renderer_set_scroll_center(PixbufRenderer *pr, gdouble x, gdouble y)
3784 {
3785         gdouble dst_x, dst_y;
3786
3787         dst_x = x * pr->width  - pr->vis_width  / 2 - pr->x_scroll + CLAMP(pr->subpixel_x_scroll, -1.0, 1.0);
3788         dst_y = y * pr->height - pr->vis_height / 2 - pr->y_scroll + CLAMP(pr->subpixel_y_scroll, -1.0, 1.0);
3789
3790         pr->subpixel_x_scroll = dst_x - (gint)dst_x;
3791         pr->subpixel_y_scroll = dst_y - (gint)dst_y;
3792
3793         pixbuf_renderer_scroll(pr, (gint)dst_x, (gint)dst_y);
3794 }
3795
3796 /*
3797  *-------------------------------------------------------------------
3798  * mouse
3799  *-------------------------------------------------------------------
3800  */
3801
3802 static gboolean pr_mouse_motion_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
3803 {
3804         PixbufRenderer *pr;
3805         gint accel;
3806
3807         /* This is a hack, but work far the best, at least for single pointer systems.
3808          * See http://bugzilla.gnome.org/show_bug.cgi?id=587714 for more. */
3809         gint x, y;
3810         gdk_window_get_pointer (bevent->window, &x, &y, NULL);
3811         bevent->x = x;
3812         bevent->y = y;
3813
3814         pr = PIXBUF_RENDERER(widget);
3815
3816         if (pr->scroller_id)
3817                 {
3818                 pr->scroller_xpos = bevent->x;
3819                 pr->scroller_ypos = bevent->y;
3820                 }
3821
3822         pr->x_mouse = bevent->x;
3823         pr->y_mouse = bevent->y;
3824         pr_update_pixel_signal(pr);
3825
3826         if (!pr->in_drag || !gdk_pointer_is_grabbed()) return FALSE;
3827
3828         if (pr->drag_moved < PR_DRAG_SCROLL_THRESHHOLD)
3829                 {
3830                 pr->drag_moved++;
3831                 }
3832         else
3833                 {
3834                 widget_set_cursor(widget, GDK_FLEUR);
3835                 }
3836
3837         if (bevent->state & GDK_CONTROL_MASK)
3838                 {
3839                 accel = PR_PAN_SHIFT_MULTIPLIER;
3840                 }
3841         else
3842                 {
3843                 accel = 1;
3844                 }
3845
3846         /* do the scroll */
3847         pixbuf_renderer_scroll(pr, (pr->drag_last_x - bevent->x) * accel,
3848                                (pr->drag_last_y - bevent->y) * accel);
3849
3850         pr_drag_signal(pr, bevent);
3851
3852         pr->drag_last_x = bevent->x;
3853         pr->drag_last_y = bevent->y;
3854
3855         /* This is recommended by the GTK+ documentation, but does not work properly.
3856          * Use deprecated way until GTK+ gets a solution for correct motion hint handling:
3857          * http://bugzilla.gnome.org/show_bug.cgi?id=587714
3858          */
3859         /* gdk_event_request_motions (bevent); */
3860         return FALSE;
3861 }
3862
3863 static gboolean pr_leave_notify_cb(GtkWidget *widget, GdkEventCrossing *cevent, gpointer data)
3864 {
3865         PixbufRenderer *pr;
3866
3867         pr = PIXBUF_RENDERER(widget);
3868         pr->x_mouse = -1;
3869         pr->y_mouse = -1;
3870
3871         pr_update_pixel_signal(pr);
3872         return FALSE;
3873 }
3874
3875 static gboolean pr_mouse_press_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
3876 {
3877         PixbufRenderer *pr;
3878         GtkWidget *parent;
3879
3880         pr = PIXBUF_RENDERER(widget);
3881
3882         if (pr->scroller_id) return TRUE;
3883
3884         switch (bevent->button)
3885                 {
3886                 case MOUSE_BUTTON_LEFT:
3887                         pr->in_drag = TRUE;
3888                         pr->drag_last_x = bevent->x;
3889                         pr->drag_last_y = bevent->y;
3890                         pr->drag_moved = 0;
3891                         gdk_pointer_grab(widget->window, FALSE,
3892                                          GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_RELEASE_MASK,
3893                                          NULL, NULL, bevent->time);
3894                         gtk_grab_add(widget);
3895                         break;
3896                 case MOUSE_BUTTON_MIDDLE:
3897                         pr->drag_moved = 0;
3898                         break;
3899                 case MOUSE_BUTTON_RIGHT:
3900                         pr_clicked_signal(pr, bevent);
3901                         break;
3902                 default:
3903                         break;
3904                 }
3905
3906         parent = gtk_widget_get_parent(widget);
3907 #if GTK_CHECK_VERSION(2,20,0)
3908         if (widget && gtk_widget_get_can_focus(parent))
3909 #else
3910         if (widget && GTK_WIDGET_CAN_FOCUS(parent))
3911 #endif
3912                 {
3913                 gtk_widget_grab_focus(parent);
3914                 }
3915
3916         return FALSE;
3917 }
3918
3919 static gboolean pr_mouse_release_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer data)
3920 {
3921         PixbufRenderer *pr;
3922
3923         pr = PIXBUF_RENDERER(widget);
3924
3925         if (pr->scroller_id)
3926                 {
3927                 pr_scroller_stop(pr);
3928                 return TRUE;
3929                 }
3930
3931 #if GTK_CHECK_VERSION(2,20,0)
3932         if (gdk_pointer_is_grabbed() && gtk_widget_has_grab(pr))
3933 #else
3934         if (gdk_pointer_is_grabbed() && GTK_WIDGET_HAS_GRAB(pr))
3935 #endif
3936                 {
3937                 gtk_grab_remove(widget);
3938                 gdk_pointer_ungrab(bevent->time);
3939                 widget_set_cursor(widget, -1);
3940                 }
3941
3942         if (pr->drag_moved < PR_DRAG_SCROLL_THRESHHOLD)
3943                 {
3944                 if (bevent->button == MOUSE_BUTTON_LEFT && (bevent->state & GDK_CONTROL_MASK))
3945                         {
3946                         pr_scroller_start(pr, bevent->x, bevent->y);
3947                         }
3948                 else if (bevent->button == MOUSE_BUTTON_LEFT || bevent->button == MOUSE_BUTTON_MIDDLE)
3949                         {
3950                         pr_clicked_signal(pr, bevent);
3951                         }
3952                 }
3953
3954         pr->in_drag = FALSE;
3955
3956         return FALSE;
3957 }
3958
3959 static gboolean pr_mouse_leave_cb(GtkWidget *widget, GdkEventCrossing *event, gpointer data)
3960 {
3961         PixbufRenderer *pr;
3962
3963         pr = PIXBUF_RENDERER(widget);
3964
3965         if (pr->scroller_id)
3966                 {
3967                 pr->scroller_xpos = pr->scroller_x;
3968                 pr->scroller_ypos = pr->scroller_y;
3969                 pr->scroller_xinc = 0;
3970                 pr->scroller_yinc = 0;
3971                 }
3972
3973         return FALSE;
3974 }
3975
3976 static void pr_mouse_drag_cb(GtkWidget *widget, GdkDragContext *context, gpointer data)
3977 {
3978         PixbufRenderer *pr;
3979
3980         pr = PIXBUF_RENDERER(widget);
3981
3982         pr->drag_moved = PR_DRAG_SCROLL_THRESHHOLD;
3983 }
3984
3985 static void pr_signals_connect(PixbufRenderer *pr)
3986 {
3987         g_signal_connect(G_OBJECT(pr), "motion_notify_event",
3988                          G_CALLBACK(pr_mouse_motion_cb), pr);
3989         g_signal_connect(G_OBJECT(pr), "button_press_event",
3990                          G_CALLBACK(pr_mouse_press_cb), pr);
3991         g_signal_connect(G_OBJECT(pr), "button_release_event",
3992                          G_CALLBACK(pr_mouse_release_cb), pr);
3993         g_signal_connect(G_OBJECT(pr), "leave_notify_event",
3994                          G_CALLBACK(pr_mouse_leave_cb), pr);
3995         g_signal_connect(G_OBJECT(pr), "hierarchy-changed",
3996                          G_CALLBACK(pr_hierarchy_changed_cb), pr);
3997         g_signal_connect(G_OBJECT(pr), "leave_notify_event",
3998                          G_CALLBACK(pr_leave_notify_cb), pr);
3999
4000         gtk_widget_set_events(GTK_WIDGET(pr), GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK |
4001                                               GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK |
4002                                               GDK_LEAVE_NOTIFY_MASK);
4003
4004         g_signal_connect(G_OBJECT(pr), "drag_begin",
4005                          G_CALLBACK(pr_mouse_drag_cb), pr);
4006
4007 }
4008
4009 /*
4010  *-------------------------------------------------------------------
4011  * public
4012  *-------------------------------------------------------------------
4013  */
4014 static void pr_pixbuf_size_sync(PixbufRenderer *pr)
4015 {
4016         if (!pr->pixbuf) return;
4017         switch (pr->orientation)
4018                 {
4019                 case EXIF_ORIENTATION_LEFT_TOP:
4020                 case EXIF_ORIENTATION_RIGHT_TOP:
4021                 case EXIF_ORIENTATION_RIGHT_BOTTOM:
4022                 case EXIF_ORIENTATION_LEFT_BOTTOM:
4023                         pr->image_width = gdk_pixbuf_get_height(pr->pixbuf);
4024                         pr->image_height = gdk_pixbuf_get_width(pr->pixbuf);
4025                         break;
4026                 default:
4027                         pr->image_width = gdk_pixbuf_get_width(pr->pixbuf);
4028                         pr->image_height = gdk_pixbuf_get_height(pr->pixbuf);
4029                 }
4030 }
4031
4032 static void pr_set_pixbuf(PixbufRenderer *pr, GdkPixbuf *pixbuf, gdouble zoom, PrZoomFlags flags)
4033 {
4034         if (pixbuf) g_object_ref(pixbuf);
4035         if (pr->pixbuf) g_object_unref(pr->pixbuf);
4036         pr->pixbuf = pixbuf;
4037
4038         if (!pr->pixbuf)
4039                 {
4040                 GtkWidget *box;
4041
4042                 /* no pixbuf so just clear the window */
4043                 pr->image_width = 0;
4044                 pr->image_height = 0;
4045                 pr->scale = 1.0;
4046                 pr->zoom = zoom; /* don't throw away the zoom value, it is set by pixbuf_renderer_move, among others,
4047                                     and used for pixbuf_renderer_zoom_get */
4048
4049                 box = GTK_WIDGET(pr);
4050
4051 #if GTK_CHECK_VERSION(2,20,0)
4052                 if (gtk_widget_get_realized(box))
4053 #else
4054                 if (GTK_WIDGET_REALIZED(box))
4055 #endif
4056                         {
4057                         gdk_window_clear(box->window);
4058                         pr_overlay_draw(pr, 0, 0, pr->window_width, pr->window_height, NULL);
4059                         }
4060
4061                 pr_update_signal(pr);
4062
4063                 return;
4064                 }
4065
4066         pr_pixbuf_size_sync(pr);
4067         pr_zoom_sync(pr, zoom, flags | PR_ZOOM_FORCE | PR_ZOOM_NEW, 0, 0);
4068 }
4069
4070 void pixbuf_renderer_set_pixbuf(PixbufRenderer *pr, GdkPixbuf *pixbuf, gdouble zoom)
4071 {
4072         g_return_if_fail(IS_PIXBUF_RENDERER(pr));
4073
4074         pr_source_tile_unset(pr);
4075
4076         pr_set_pixbuf(pr, pixbuf, zoom, 0);
4077
4078         pr_update_signal(pr);
4079 }
4080
4081 void pixbuf_renderer_set_pixbuf_lazy(PixbufRenderer *pr, GdkPixbuf *pixbuf, gdouble zoom, gint orientation)
4082 {
4083         g_return_if_fail(IS_PIXBUF_RENDERER(pr));
4084
4085         pr_source_tile_unset(pr);
4086
4087         pr->orientation = orientation;
4088         pr_set_pixbuf(pr, pixbuf, zoom, PR_ZOOM_LAZY);
4089
4090         pr_update_signal(pr);
4091 }
4092
4093 GdkPixbuf *pixbuf_renderer_get_pixbuf(PixbufRenderer *pr)
4094 {
4095         g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), NULL);
4096
4097         return pr->pixbuf;
4098 }
4099
4100 void pixbuf_renderer_set_orientation(PixbufRenderer *pr, gint orientation)
4101 {
4102         g_return_if_fail(IS_PIXBUF_RENDERER(pr));
4103
4104         pr->orientation = orientation;
4105
4106         pr_pixbuf_size_sync(pr);
4107         pr_zoom_sync(pr, pr->zoom, PR_ZOOM_FORCE, 0, 0);
4108 }
4109
4110 gint pixbuf_renderer_get_orientation(PixbufRenderer *pr)
4111 {
4112         if (!pr) return 1;
4113         return pr->orientation;
4114 }
4115
4116 void pixbuf_renderer_set_post_process_func(PixbufRenderer *pr, PixbufRendererPostProcessFunc func, gpointer user_data, gboolean slow)
4117 {
4118         g_return_if_fail(IS_PIXBUF_RENDERER(pr));
4119
4120         pr->func_post_process = func;
4121         pr->post_process_user_data = user_data;
4122         pr->post_process_slow = func && slow;
4123
4124 }
4125
4126
4127 void pixbuf_renderer_move(PixbufRenderer *pr, PixbufRenderer *source)
4128 {
4129         GObject *object;
4130         PixbufRendererScrollResetType scroll_reset;
4131
4132         g_return_if_fail(IS_PIXBUF_RENDERER(pr));
4133         g_return_if_fail(IS_PIXBUF_RENDERER(source));
4134
4135         if (pr == source) return;
4136
4137         object = G_OBJECT(pr);
4138
4139         g_object_set(object, "zoom_min", source->zoom_min, NULL);
4140         g_object_set(object, "zoom_max", source->zoom_max, NULL);
4141         g_object_set(object, "loading", source->loading, NULL);
4142
4143         pr->complete = source->complete;
4144
4145         pr->x_scroll = source->x_scroll;
4146         pr->y_scroll = source->y_scroll;
4147         pr->x_mouse  = source->x_mouse;
4148         pr->y_mouse  = source->y_mouse;
4149
4150         scroll_reset = pr->scroll_reset;
4151         pr->scroll_reset = PR_SCROLL_RESET_NOCHANGE;
4152
4153         pr->func_post_process = source->func_post_process;
4154         pr->post_process_user_data = source->post_process_user_data;
4155         pr->post_process_slow = source->post_process_slow;
4156         pr->orientation = source->orientation;
4157
4158         if (source->source_tiles_enabled)
4159                 {
4160                 pr_source_tile_unset(pr);
4161
4162                 pr->source_tiles_enabled = source->source_tiles_enabled;
4163                 pr->source_tiles_cache_size = source->source_tiles_cache_size;
4164                 pr->source_tile_width = source->source_tile_width;
4165                 pr->source_tile_height = source->source_tile_height;
4166                 pr->image_width = source->image_width;
4167                 pr->image_height = source->image_height;
4168
4169                 pr->func_tile_request = source->func_tile_request;
4170                 pr->func_tile_dispose = source->func_tile_dispose;
4171                 pr->func_tile_data = source->func_tile_data;
4172
4173                 pr->source_tiles = source->source_tiles;
4174                 source->source_tiles = NULL;
4175
4176                 pr_zoom_sync(pr, source->zoom, PR_ZOOM_FORCE | PR_ZOOM_NEW, 0, 0);
4177                 pr_redraw(pr, TRUE);
4178                 }
4179         else
4180                 {
4181                 pixbuf_renderer_set_pixbuf(pr, source->pixbuf, source->zoom);
4182                 }
4183
4184         pr->scroll_reset = scroll_reset;
4185
4186         pixbuf_renderer_set_pixbuf(source, NULL, source->zoom);
4187         pr_queue_clear(source);
4188         pr_tile_free_all(source);
4189 }
4190
4191 void pixbuf_renderer_area_changed(PixbufRenderer *pr, gint src_x, gint src_y, gint src_w, gint src_h)
4192 {
4193         gint x, y, width, height,  x1, y1, x2, y2;
4194
4195         g_return_if_fail(IS_PIXBUF_RENDERER(pr));
4196
4197         pr_coords_map_orientation_reverse(pr,
4198                                      src_x, src_y,
4199                                      pr->image_width, pr->image_height,
4200                                      src_w, src_h,
4201                                      &x, &y,
4202                                      &width, &height);
4203
4204         if (pr->source_tiles_enabled)
4205                 {
4206                 pr_source_tile_changed(pr, x, y, width, height);
4207                 }
4208
4209         if (pr->scale != 1.0 && pr->zoom_quality != GDK_INTERP_NEAREST)
4210                 {
4211                 /* increase region when using a zoom quality that may access surrounding pixels */
4212                 y -= 1;
4213                 height += 2;
4214                 }
4215
4216         x1 = (gint)floor((gdouble)x * pr->scale);
4217         y1 = (gint)floor((gdouble)y * pr->scale);
4218         x2 = (gint)ceil((gdouble)(x + width) * pr->scale);
4219         y2 = (gint)ceil((gdouble)(y + height) * pr->scale);
4220
4221         pr_queue(pr, x1, y1, x2 - x1, y2 - y1, FALSE, TILE_RENDER_AREA, TRUE, TRUE);
4222 }
4223
4224 void pixbuf_renderer_zoom_adjust(PixbufRenderer *pr, gdouble increment)
4225 {
4226         g_return_if_fail(IS_PIXBUF_RENDERER(pr));
4227
4228         pr_zoom_adjust_real(pr, increment, PR_ZOOM_NONE, 0, 0);
4229 }
4230
4231 void pixbuf_renderer_zoom_adjust_at_point(PixbufRenderer *pr, gdouble increment, gint x, gint y)
4232 {
4233         g_return_if_fail(IS_PIXBUF_RENDERER(pr));
4234
4235         pr_zoom_adjust_real(pr, increment, PR_ZOOM_CENTER, x, y);
4236 }
4237
4238 void pixbuf_renderer_zoom_set(PixbufRenderer *pr, gdouble zoom)
4239 {
4240         g_return_if_fail(IS_PIXBUF_RENDERER(pr));
4241
4242         pr_zoom_sync(pr, zoom, PR_ZOOM_NONE, 0, 0);
4243 }
4244
4245 gdouble pixbuf_renderer_zoom_get(PixbufRenderer *pr)
4246 {
4247         g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), 1.0);
4248
4249         return pr->zoom;
4250 }
4251
4252 gdouble pixbuf_renderer_zoom_get_scale(PixbufRenderer *pr)
4253 {
4254         g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), 1.0);
4255
4256         return pr->scale;
4257 }
4258
4259 void pixbuf_renderer_zoom_set_limits(PixbufRenderer *pr, gdouble min, gdouble max)
4260 {
4261         g_return_if_fail(IS_PIXBUF_RENDERER(pr));
4262
4263         if (min > 1.0 || max < 1.0) return;
4264         if (min < 1.0 && min > -1.0) return;
4265         if (min < -200.0 || max > 200.0) return;
4266
4267         if (pr->zoom_min != min)
4268                 {
4269                 pr->zoom_min = min;
4270                 g_object_notify(G_OBJECT(pr), "zoom_min");
4271                 }
4272         if (pr->zoom_max != max)
4273                 {
4274                 pr->zoom_max = max;
4275                 g_object_notify(G_OBJECT(pr), "zoom_max");
4276                 }
4277 }
4278
4279 gboolean pixbuf_renderer_get_pixel_colors(PixbufRenderer *pr, gint x_pixel, gint y_pixel,
4280                                           gint *r_mouse, gint *g_mouse, gint *b_mouse)
4281 {
4282         GdkPixbuf *pb = pr->pixbuf;
4283         gint p_alpha, prs;
4284         guchar *p_pix, *pp;
4285         gint map_x, map_y, map_w, map_h;
4286
4287         g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), FALSE);
4288         g_return_val_if_fail(r_mouse != NULL && g_mouse != NULL && b_mouse != NULL, FALSE);
4289
4290         if (!pr->pixbuf && !pr->source_tiles_enabled)
4291                 {
4292                 *r_mouse = -1;
4293                 *g_mouse = -1;
4294                 *b_mouse = -1;
4295                 return FALSE;
4296                 }
4297
4298         if (!pb) return FALSE;
4299
4300         pr_tile_region_map_orientation(pr,
4301                                         x_pixel, y_pixel,
4302                                         pr->image_width, pr->image_height,
4303                                         1, 1, /*single pixel */
4304                                         &map_x, &map_y,
4305                                         &map_w, &map_h);
4306
4307         if (map_x < 0 || map_x > gdk_pixbuf_get_width(pr->pixbuf) - 1) return  FALSE;
4308         if (map_y < 0 || map_y > gdk_pixbuf_get_height(pr->pixbuf) - 1) return  FALSE;
4309
4310         p_alpha = gdk_pixbuf_get_has_alpha(pb);
4311         prs = gdk_pixbuf_get_rowstride(pb);
4312         p_pix = gdk_pixbuf_get_pixels(pb);
4313
4314         pp = p_pix + map_y * prs + (map_x * (p_alpha ? 4 : 3));
4315         *r_mouse = *pp;
4316         pp++;
4317         *g_mouse = *pp;
4318         pp++;
4319         *b_mouse = *pp;
4320
4321         return TRUE;
4322 }
4323
4324 gboolean pixbuf_renderer_get_mouse_position(PixbufRenderer *pr, gint *x_pixel_return, gint *y_pixel_return)
4325 {
4326         gint x_pixel, y_pixel, x_pixel_clamped, y_pixel_clamped;
4327
4328         g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), FALSE);
4329         g_return_val_if_fail(x_pixel_return != NULL && y_pixel_return != NULL, FALSE);
4330
4331         if (!pr->pixbuf && !pr->source_tiles_enabled)
4332                 {
4333                 *x_pixel_return = -1;
4334                 *y_pixel_return = -1;
4335                 return FALSE;
4336                 }
4337
4338         x_pixel = floor((gdouble)(pr->x_mouse - pr->x_offset + pr->x_scroll) / pr->scale);
4339         y_pixel = floor((gdouble)(pr->y_mouse - pr->y_offset + pr->y_scroll) / pr->scale);
4340         x_pixel_clamped = CLAMP(x_pixel, 0, pr->image_width - 1);
4341         y_pixel_clamped = CLAMP(y_pixel, 0, pr->image_height - 1);
4342
4343         if(x_pixel != x_pixel_clamped || y_pixel != y_pixel_clamped)
4344                 {
4345                 /* mouse is not on pr */
4346                 x_pixel = y_pixel = -1;
4347                 }
4348
4349         *x_pixel_return = x_pixel;
4350         *y_pixel_return = y_pixel;
4351
4352         return TRUE;
4353 }
4354
4355 gboolean pixbuf_renderer_get_image_size(PixbufRenderer *pr, gint *width, gint *height)
4356 {
4357         g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), FALSE);
4358         g_return_val_if_fail(width != NULL && height != NULL, FALSE);
4359
4360         if (!pr->pixbuf && !pr->source_tiles_enabled && (!pr->image_width || !pr->image_height))
4361                 {
4362                 *width = 0;
4363                 *height = 0;
4364                 return FALSE;
4365                 }
4366
4367         *width = pr->image_width;
4368         *height = pr->image_height;
4369         return TRUE;
4370 }
4371
4372 gboolean pixbuf_renderer_get_scaled_size(PixbufRenderer *pr, gint *width, gint *height)
4373 {
4374         g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), FALSE);
4375         g_return_val_if_fail(width != NULL && height != NULL, FALSE);
4376
4377         if (!pr->pixbuf && !pr->source_tiles_enabled && (!pr->image_width || !pr->image_height))
4378                 {
4379                 *width = 0;
4380                 *height = 0;
4381                 return FALSE;
4382                 }
4383
4384         *width = pr->width;
4385         *height = pr->height;
4386         return TRUE;
4387 }
4388
4389 gboolean pixbuf_renderer_get_visible_rect(PixbufRenderer *pr, GdkRectangle *rect)
4390 {
4391         g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), FALSE);
4392         g_return_val_if_fail(rect != NULL, FALSE);
4393
4394         if ((!pr->pixbuf && !pr->source_tiles_enabled) ||
4395             !pr->scale)
4396                 {
4397                 rect->x = 0;
4398                 rect->y = 0;
4399                 rect->width = 0;
4400                 rect->height = 0;
4401                 return FALSE;
4402                 }
4403
4404         rect->x = (gint)((gdouble)pr->x_scroll / pr->scale);
4405         rect->y = (gint)((gdouble)pr->y_scroll / pr->scale);
4406         rect->width = (gint)((gdouble)pr->vis_width / pr->scale);
4407         rect->height = (gint)((gdouble)pr->vis_height / pr->scale);
4408         return TRUE;
4409 }
4410
4411 gboolean pixbuf_renderer_get_virtual_rect(PixbufRenderer *pr, GdkRectangle *rect)
4412 {
4413         g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), FALSE);
4414         g_return_val_if_fail(rect != NULL, FALSE);
4415
4416         if ((!pr->pixbuf && !pr->source_tiles_enabled))
4417                 {
4418                 rect->x = 0;
4419                 rect->y = 0;
4420                 rect->width = 0;
4421                 rect->height = 0;
4422                 return FALSE;
4423                 }
4424
4425         rect->x = pr->x_scroll;
4426         rect->y = pr->y_scroll;
4427         rect->width = pr->vis_width;
4428         rect->height = pr->vis_height;
4429         return TRUE;
4430 }
4431
4432 void pixbuf_renderer_set_size_early(PixbufRenderer *pr, guint width, guint height)
4433 {
4434         gdouble zoom;
4435         gint w, h;
4436
4437         zoom = pixbuf_renderer_zoom_get(pr);
4438         pr->image_width = width;
4439         pr->image_height = height;
4440
4441         pr_zoom_clamp(pr, zoom, PR_ZOOM_FORCE, NULL);
4442
4443         //w = width;
4444         //h = height;
4445
4446         //pr->width = width;
4447         //pr->height = height;
4448 }
4449
4450 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */