src/pixbuf-renderer.h

   1 /*
   2  * Copyright (C) 2006 John Ellis
   3  * Copyright (C) 2008 - 2016 The Geeqie Team
   4  *
   5  * Author: John Ellis
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with this program; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #ifndef PIXBUF_RENDERER_H
  23 #define PIXBUF_RENDERER_H
  24
  25 #define TYPE_PIXBUF_RENDERER            (pixbuf_renderer_get_type())
  26 #define PIXBUF_RENDERER(obj)            (G_TYPE_CHECK_INSTANCE_CAST((obj), TYPE_PIXBUF_RENDERER, PixbufRenderer))
  27 #define PIXBUF_RENDERER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST((klass), TYPE_PIXBUF_RENDERER, PixbufRendererClass))
  28 #define IS_PIXBUF_RENDERER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE((obj), TYPE_PIXBUF_RENDERER))
  29 #define IS_PIXBUF_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), TYPE_PIXBUF_RENDERER))
  30 #define PIXBUF_RENDERER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS((obj), TYPE_PIXBUF_RENDERER, PixbufRendererClass))
  31
  32 /**
  33  * @def PR_ALPHA_CHECK_SIZE
  34  * alpha channel checkerboard (same as gimp)
  35  */
  36 #define PR_ALPHA_CHECK_SIZE 16
  37
  38 /**
  39  * @def PR_MIN_SCALE_SIZE
  40  * when scaling image to below this size, use nearest pixel for scaling
  41  * (below about 4, the other scale types become slow generating their conversion tables)
  42  */
  43 #define PR_MIN_SCALE_SIZE 8
  44
  45 /**
  46  * @def PR_CACHE_SIZE_DEFAULT
  47  * default size of tile cache (MiB)
  48  */
  49 #define PR_CACHE_SIZE_DEFAULT 8
  50
  51 /**
  52  * @def ROUND_UP
  53  * round A up to integer count of B
  54  */
  55 #define ROUND_UP(A,B)   ((gint)(((A)+(B)-1)/(B))*(B))
  56
  57 /**
  58  * @def ROUND_DOWN
  59  * round A down to integer count of B
  60  */
  61 #define ROUND_DOWN(A,B) ((gint)(((A))/(B))*(B))
  62
  63
  64 typedef struct _RendererFuncs RendererFuncs;
  65
  66 typedef struct _PixbufRenderer PixbufRenderer;
  67 typedef struct _PixbufRendererClass PixbufRendererClass;
  68
  69
  70 typedef gint (* PixbufRendererTileRequestFunc)(PixbufRenderer *pr, gint x, gint y,
  71                                                gint width, gint height, GdkPixbuf *pixbuf, gpointer user_data);
  72 typedef void (* PixbufRendererTileDisposeFunc)(PixbufRenderer *pr, gint x, gint y,
  73                                                gint width, gint height, GdkPixbuf *pixbuf, gpointer user_data);
  74
  75 typedef void (* PixbufRendererPostProcessFunc)(PixbufRenderer *pr, GdkPixbuf **pixbuf, gint x, gint y,
  76                                                gint width, gint height, gpointer user_data);
  77
  78 typedef enum {
  79         PR_SCROLL_RESET_TOPLEFT = 0,
  80         PR_SCROLL_RESET_CENTER,
  81         PR_SCROLL_RESET_NOCHANGE,
  82         PR_SCROLL_RESET_COUNT,
  83 } PixbufRendererScrollResetType;
  84
  85 typedef enum {
  86         TILE_RENDER_NONE = 0, /**< do nothing */
  87         TILE_RENDER_AREA, /**< render an area of the tile */
  88         TILE_RENDER_ALL /**< render the whole tile */
  89 } ImageRenderType;
  90
  91 typedef enum {
  92         OVL_NORMAL      = 0,
  93         OVL_RELATIVE    = 1 << 0, /**< x,y coordinates are relative, negative values start bottom right */
  94         /* OVL_HIDE_ON_SCROLL = 1 << 1*/ /**< hide temporarily when scrolling (not yet implemented) */
  95 } OverlayRendererFlags;
  96
  97 struct _RendererFuncs
  98 {
  99 //      void (*redraw)(void *renderer, gint x, gint y, gint w, gint h,
 100   //                   gint clamp, ImageRenderType render, gboolean new_data, gboolean only_existing);
 101     void (*area_changed)(void *renderer, gint src_x, gint src_y, gint src_w, gint src_h); /**< pixbuf area changed */
 102         void (*invalidate_region)(void *renderer, gint x, gint y, gint w, gint h);
 103         void (*scroll)(void *renderer, gint x_off, gint y_off); /**< scroll */
 104         void (*update_viewport)(void *renderer); /**< window / wiewport / border color has changed */
 105         void (*update_pixbuf)(void *renderer, gboolean lazy); /**< pixbuf has changed */
 106         void (*update_zoom)(void *renderer, gboolean lazy); /**< zoom has changed */
 107
 108         gint (*overlay_add)(void *renderer, GdkPixbuf *pixbuf, gint x, gint y, OverlayRendererFlags flags);
 109         void (*overlay_set)(void *renderer, gint id, GdkPixbuf *pixbuf, gint x, gint y);
 110         gboolean (*overlay_get)(void *renderer, gint id, GdkPixbuf **pixbuf, gint *x, gint *y);
 111
 112         void (*stereo_set)(void *renderer, gint stereo_mode); /**< set stereo mode */
 113
 114         void (*free)(void *renderer);
 115 };
 116
 117 struct _PixbufRenderer
 118 {
 119         GtkEventBox eventbox;
 120
 121         gint image_width;       /**< image actual dimensions (pixels) */
 122         gint image_height;
 123         gint stereo_pixbuf_offset_right; /**< offset of the right part of the stereo image in pixbuf */
 124         gint stereo_pixbuf_offset_left; /**< offset of the left part of the stereo image in pixbuf */
 125
 126         GdkPixbuf *pixbuf;
 127
 128         gint window_width;      /**< allocated size of window (drawing area) */
 129         gint window_height;
 130
 131         gint viewport_width;    /**< allocated size of viewport (same as window for normal mode, half of window for SBS mode) */
 132         gint viewport_height;
 133
 134         gint x_offset;          /**< offset of image start (non-zero when viewport < window) */
 135         gint y_offset;
 136
 137         gint x_mouse; /**< coordinates of the mouse taken from GtkEvent */
 138         gint y_mouse;
 139
 140         gint vis_width;         /**< dimensions of visible part of image */
 141         gint vis_height;
 142
 143         gint width;             /**< size of scaled image (result) */
 144         gint height;
 145
 146         gint x_scroll;          /**< scroll offset of image (into width, height to start drawing) */
 147         gint y_scroll;
 148
 149         gdouble norm_center_x;  /**< coordinates of viewport center in the image, in range 0.0 - 1.0 */
 150         gdouble norm_center_y;  /**< these coordinates are used for PR_SCROLL_RESET_NOCHANGE and should be preserved over periods with NULL pixbuf */
 151
 152         gdouble subpixel_x_scroll; /**< subpixel scroll alignment, used to prevent accumulation of rounding errors */
 153         gdouble subpixel_y_scroll;
 154
 155         gdouble zoom_min;
 156         gdouble zoom_max;
 157         gdouble zoom;           /**< zoom we want (0 is auto) */
 158         gdouble scale;          /**< zoom we got (should never be 0) */
 159
 160         gdouble aspect_ratio;   /**< screen pixel aspect ratio (2.0 for 3DTV SBS mode) */
 161
 162         GdkInterpType zoom_quality;
 163         gboolean zoom_2pass;
 164         gboolean zoom_expand;
 165
 166         PixbufRendererScrollResetType scroll_reset;
 167
 168         gboolean has_frame;
 169
 170         GtkWidget *parent_window;       /**< resize parent_window when image dimensions change */
 171
 172         gboolean window_fit;
 173         gboolean window_limit;
 174         gint window_limit_size;
 175
 176         gboolean autofit_limit;
 177         gint autofit_limit_size;
 178         gint enlargement_limit_size;
 179
 180         GdkColor color;
 181
 182         /*< private >*/
 183         gboolean in_drag;
 184         gint drag_last_x;
 185         gint drag_last_y;
 186         gint drag_moved;
 187
 188         gboolean source_tiles_enabled;
 189         gint source_tiles_cache_size;
 190
 191         GList *source_tiles;    /**< list of active source tiles */
 192         gint source_tile_width;
 193         gint source_tile_height;
 194
 195         PixbufRendererTileRequestFunc func_tile_request;
 196         PixbufRendererTileDisposeFunc func_tile_dispose;
 197
 198         gpointer func_tile_data;
 199
 200         PixbufRendererPostProcessFunc func_post_process;
 201         gpointer post_process_user_data;
 202         gint post_process_slow;
 203
 204         gboolean delay_flip;
 205         gboolean loading;
 206         gboolean complete;
 207         gboolean debug_updated; /**< debug only */
 208
 209         guint scroller_id; /**< event source id */
 210         gint scroller_overlay;
 211         gint scroller_x;
 212         gint scroller_y;
 213         gint scroller_xpos;
 214         gint scroller_ypos;
 215         gint scroller_xinc;
 216         gint scroller_yinc;
 217
 218         gint orientation;
 219
 220         gint stereo_mode;
 221
 222         StereoPixbufData stereo_data;
 223         gboolean stereo_temp_disable;
 224         gint stereo_fixed_width;
 225         gint stereo_fixed_height;
 226         gint stereo_fixed_x_left;
 227         gint stereo_fixed_y_left;
 228         gint stereo_fixed_x_right;
 229         gint stereo_fixed_y_right;
 230
 231         RendererFuncs *renderer;
 232         RendererFuncs *renderer2;
 233
 234         gboolean ignore_alpha;
 235 };
 236
 237 struct _PixbufRendererClass
 238 {
 239         GtkEventBoxClass parent_class;
 240
 241         void (*zoom)(PixbufRenderer *pr, gdouble zoom);
 242         void (*clicked)(PixbufRenderer *pr, GdkEventButton *event);
 243         void (*scroll_notify)(PixbufRenderer *pr);
 244         void (*update_pixel)(PixbufRenderer *pr);
 245
 246         void (*render_complete)(PixbufRenderer *pr);
 247         void (*drag)(PixbufRenderer *pr, GdkEventMotion *event);
 248 };
 249
 250
 251
 252
 253 GType pixbuf_renderer_get_type(void);
 254
 255 PixbufRenderer *pixbuf_renderer_new(void);
 256
 257 void pixbuf_renderer_set_parent(PixbufRenderer *pr, GtkWindow *window);
 258 GtkWindow *pixbuf_renderer_get_parent(PixbufRenderer *pr);
 259
 260 /**
 261  * @headerfile pixbuf_renderer_set_pixbuf
 262  * display a pixbuf
 263  */
 264 void pixbuf_renderer_set_pixbuf(PixbufRenderer *pr, GdkPixbuf *pixbuf, gdouble zoom);
 265
 266 /**
 267  * @headerfile  pixbuf_renderer_set_pixbuf_lazy
 268  * same as pixbuf_renderer_set_pixbuf but waits with redrawing for pixbuf_renderer_area_changed */
 269 void pixbuf_renderer_set_pixbuf_lazy(PixbufRenderer *pr, GdkPixbuf *pixbuf, gdouble zoom, gint orientation, StereoPixbufData stereo_data);
 270
 271
 272 GdkPixbuf *pixbuf_renderer_get_pixbuf(PixbufRenderer *pr);
 273
 274 void pixbuf_renderer_set_orientation(PixbufRenderer *pr, gint orientation);
 275 gint pixbuf_renderer_get_orientation(PixbufRenderer *pr);
 276
 277 /**
 278  * @headerfile pixbuf_renderer_set_stereo_data
 279  * sets the format of stereo data in the input pixbuf
 280  */
 281 void pixbuf_renderer_set_stereo_data(PixbufRenderer *pr, StereoPixbufData stereo_data);
 282
 283 void pixbuf_renderer_set_post_process_func(PixbufRenderer *pr, PixbufRendererPostProcessFunc func, gpointer user_data, gboolean slow);
 284
 285 /**
 286  * @headerfile pixbuf_renderer_set_tiles
 287  * display an on-request array of pixbuf tiles
 288  */
 289 void pixbuf_renderer_set_tiles(PixbufRenderer *pr, gint width, gint height,
 290                                gint tile_width, gint tile_height, gint cache_size,
 291                                PixbufRendererTileRequestFunc func_request,
 292                                PixbufRendererTileDisposeFunc func_dispose,
 293                                gpointer user_data,
 294                                gdouble zoom);
 295 void pixbuf_renderer_set_tiles_size(PixbufRenderer *pr, gint width, gint height);
 296 gint pixbuf_renderer_get_tiles(PixbufRenderer *pr);
 297
 298 /**
 299  * @headerfile pixbuf_renderer_move
 300  * move image data from source to pr, source is then set to NULL image
 301  */
 302 void pixbuf_renderer_move(PixbufRenderer *pr, PixbufRenderer *source);
 303 void pixbuf_renderer_copy(PixbufRenderer *pr, PixbufRenderer *source);
 304
 305 /**
 306  * @headerfile pixbuf_renderer_area_changed
 307  * update region of existing image
 308  */
 309 void pixbuf_renderer_area_changed(PixbufRenderer *pr, gint x, gint y, gint width, gint height);
 310
 311 /* scrolling */
 312
 313 void pixbuf_renderer_scroll(PixbufRenderer *pr, gint x, gint y);
 314 void pixbuf_renderer_scroll_to_point(PixbufRenderer *pr, gint x, gint y,
 315                                      gdouble x_align, gdouble y_align);
 316
 317 void pixbuf_renderer_get_scroll_center(PixbufRenderer *pr, gdouble *x, gdouble *y);
 318 void pixbuf_renderer_set_scroll_center(PixbufRenderer *pr, gdouble x, gdouble y);
 319 /* zoom */
 320
 321 void pixbuf_renderer_zoom_adjust(PixbufRenderer *pr, gdouble increment);
 322 void pixbuf_renderer_zoom_adjust_at_point(PixbufRenderer *pr, gdouble increment, gint x, gint y);
 323
 324 void pixbuf_renderer_zoom_set(PixbufRenderer *pr, gdouble zoom);
 325 gdouble pixbuf_renderer_zoom_get(PixbufRenderer *pr);
 326 gdouble pixbuf_renderer_zoom_get_scale(PixbufRenderer *pr);
 327
 328 void pixbuf_renderer_zoom_set_limits(PixbufRenderer *pr, gdouble min, gdouble max);
 329
 330 /* sizes */
 331
 332 gboolean pixbuf_renderer_get_image_size(PixbufRenderer *pr, gint *width, gint *height);
 333 gboolean pixbuf_renderer_get_scaled_size(PixbufRenderer *pr, gint *width, gint *height);
 334
 335 /**
 336  * @headerfile pixbuf_renderer_get_visible_rect
 337  * region of image in pixel coordinates
 338  */
 339 gboolean pixbuf_renderer_get_visible_rect(PixbufRenderer *pr, GdkRectangle *rect);
 340
 341 /**
 342  * @headerfile pixbuf_renderer_get_virtual_rect
 343  * actual size of the PixbufRenderer window minus borders,
 344  * x and y are the scroll offset and include zoom factor.
 345  */
 346 gboolean pixbuf_renderer_get_virtual_rect(PixbufRenderer *pr, GdkRectangle *rect);
 347
 348 /**
 349  * @headerfile pixbuf_renderer_set_color
 350  *  background color
 351  */
 352 void pixbuf_renderer_set_color(PixbufRenderer *pr, GdkColor *color);
 353
 354 /* overlay */
 355
 356 gint pixbuf_renderer_overlay_add(PixbufRenderer *pr, GdkPixbuf *pixbuf, gint x, gint y,
 357                                  OverlayRendererFlags flags);
 358 void pixbuf_renderer_overlay_set(PixbufRenderer *pr, gint id, GdkPixbuf *pixbuf, gint x, gint y);
 359 gboolean pixbuf_renderer_overlay_get(PixbufRenderer *pr, gint id, GdkPixbuf **pixbuf, gint *x, gint *y);
 360 void pixbuf_renderer_overlay_remove(PixbufRenderer *pr, gint id);
 361
 362 gboolean pixbuf_renderer_get_mouse_position(PixbufRenderer *pr, gint *x_pixel, gint *y_pixel);
 363
 364 /**
 365  * @headerfile pixbuf_renderer_get_pixel_colors
 366  * x_pixel and y_pixel are the pixel coordinates see #pixbuf_renderer_get_mouse_position
 367  */
 368 gboolean pixbuf_renderer_get_pixel_colors(PixbufRenderer *pr, gint x_pixel, gint y_pixel,
 369                                         gint *r_mouse, gint *g_mouse, gint *b_mouse);
 370
 371 void pixbuf_renderer_set_size_early(PixbufRenderer *pr, guint width, guint height);
 372
 373 /* stereo */
 374 void pixbuf_renderer_stereo_set(PixbufRenderer *pr, gint stereo_mode);
 375 gint pixbuf_renderer_stereo_get(PixbufRenderer *pr);
 376 void pixbuf_renderer_stereo_fixed_set(PixbufRenderer *pr, gint width, gint height, gint x1, gint y1, gint x2, gint y2);
 377
 378 /**
 379  * @struct _SourceTile
 380  * protected - for renderer use only
 381  */
 382 typedef struct _SourceTile SourceTile;
 383 struct _SourceTile
 384 {
 385         gint x;
 386         gint y;
 387         GdkPixbuf *pixbuf;
 388         gboolean blank;
 389 };
 390
 391
 392 gboolean pr_clip_region(gint x, gint y, gint w, gint h,
 393                                gint clip_x, gint clip_y, gint clip_w, gint clip_h,
 394                                gint *rx, gint *ry, gint *rw, gint *rh);
 395 void pr_render_complete_signal(PixbufRenderer *pr);
 396
 397 void pr_tile_coords_map_orientation(gint orientation,
 398                                      gdouble tile_x, gdouble tile_y, /**< coordinates of the tile */
 399                                      gdouble image_w, gdouble image_h,
 400                                      gdouble tile_w, gdouble tile_h,
 401                                      gdouble *res_x, gdouble *res_y);
 402 void pr_tile_region_map_orientation(gint orientation,
 403                                      gint area_x, gint area_y, /**< coordinates of the area inside tile */
 404                                      gint tile_w, gint tile_h,
 405                                      gint area_w, gint area_h,
 406                                      gint *res_x, gint *res_y,
 407                                      gint *res_w, gint *res_h);
 408 void pr_coords_map_orientation_reverse(gint orientation,
 409                                      gint area_x, gint area_y,
 410                                      gint tile_w, gint tile_h,
 411                                      gint area_w, gint area_h,
 412                                      gint *res_x, gint *res_y,
 413                                      gint *res_w, gint *res_h);
 414
 415 GList *pr_source_tile_compute_region(PixbufRenderer *pr, gint x, gint y, gint w, gint h, gboolean request);
 416
 417 void pr_create_anaglyph(guint mode, GdkPixbuf *pixbuf, GdkPixbuf *right, gint x, gint y, gint w, gint h);
 418
 419 void pixbuf_renderer_set_ignore_alpha(PixbufRenderer *pr, gint ignore_alpha);
 420 #endif
 421 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */