* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <math.h>
-
-#include "main.h"
#include "pixbuf-renderer.h"
-#include "renderer-tiles.h"
-#include "intl.h"
-#include "layout.h"
+#include <cmath>
+#include <cstdlib>
+#include <cstring>
-#include <gtk/gtk.h>
+#include <config.h>
+
+#include "debug.h"
+#include "main-defines.h"
+#include "options.h"
+#include "renderer-tiles.h"
/* comment this out if not using this from within Geeqie
* defining GQ_BUILD does these things:
#define GQ_BUILD 1
#ifdef GQ_BUILD
-#include "main.h"
-#include "pixbuf-util.h"
#include "exif.h"
+#include "pixbuf-util.h"
#else
-typedef enum {
+enum ExifOrientationType {
EXIF_ORIENTATION_UNKNOWN = 0,
EXIF_ORIENTATION_TOP_LEFT = 1,
EXIF_ORIENTATION_TOP_RIGHT = 2,
EXIF_ORIENTATION_RIGHT_TOP = 6,
EXIF_ORIENTATION_RIGHT_BOTTOM = 7,
EXIF_ORIENTATION_LEFT_BOTTOM = 8
-} ExifOrientationType;
+};
#endif
/* default min and max zoom */
-#define PR_ZOOM_MIN -32.0
+#define PR_ZOOM_MIN (-32.0)
#define PR_ZOOM_MAX 32.0
/* distance to drag mouse to disable image flip */
-#define PR_DRAG_SCROLL_THRESHHOLD 4
+enum {
+ PR_DRAG_SCROLL_THRESHHOLD = 4
+};
/* increase pan rate when holding down shift */
-#define PR_PAN_SHIFT_MULTIPLIER 6
+enum {
+ PR_PAN_SHIFT_MULTIPLIER = 6
+};
/* scroller config */
-#define PR_SCROLLER_UPDATES_PER_SEC 30
-#define PR_SCROLLER_DEAD_ZONE 6
+enum {
+ PR_SCROLLER_UPDATES_PER_SEC = 30,
+ PR_SCROLLER_DEAD_ZONE = 6
+};
/* when scaling image to below this size, use nearest pixel for scaling
* (below about 4, the other scale types become slow generating their conversion tables)
*/
-#define PR_MIN_SCALE_SIZE 8
+//~ enum {
+//~ PR_MIN_SCALE_SIZE = 8
+//~ };
enum {
SIGNAL_ZOOM = 0,
PROP_ENLARGEMENT_LIMIT_VALUE
};
-typedef enum {
+enum PrZoomFlags {
PR_ZOOM_NONE = 0,
PR_ZOOM_FORCE = 1 << 0,
PR_ZOOM_NEW = 1 << 1,
PR_ZOOM_CENTER = 1 << 2,
PR_ZOOM_INVALIDATE = 1 << 3,
PR_ZOOM_LAZY = 1 << 4 /* wait with redraw for pixbuf_renderer_area_changed */
-} PrZoomFlags;
+};
static guint signals[SIGNAL_COUNT] = { 0 };
-static GtkEventBoxClass *parent_class = NULL;
+static GtkEventBoxClass *parent_class = nullptr;
*-------------------------------------------------------------------
*/
-static void pixbuf_renderer_class_init_wrapper(void *g_class, void *UNUSED(class_data))
+static void pixbuf_renderer_class_init_wrapper(void *g_class, void *)
{
- pixbuf_renderer_class_init(g_class);
+ pixbuf_renderer_class_init(static_cast<PixbufRendererClass *>(g_class));
}
-static void pixbuf_renderer_init_wrapper(PixbufRenderer *pr, void *UNUSED(class_data))
+static void pixbuf_renderer_init_wrapper(PixbufRenderer *pr, void *)
{
pixbuf_renderer_init(pr);
}
-GType pixbuf_renderer_get_type(void)
+GType pixbuf_renderer_get_type()
{
static GType pixbuf_renderer_type = 0;
static const GTypeInfo pixbuf_renderer_info =
{
sizeof(PixbufRendererClass), /* class_size */
- NULL, /* base_init */
- NULL, /* base_finalize */
- (GClassInitFunc)pixbuf_renderer_class_init_wrapper,
- NULL, /* class_finalize */
- NULL, /* class_data */
+ nullptr, /* base_init */
+ nullptr, /* base_finalize */
+ static_cast<GClassInitFunc>(pixbuf_renderer_class_init_wrapper),
+ nullptr, /* class_finalize */
+ nullptr, /* class_data */
sizeof(PixbufRenderer), /* instance_size */
0, /* n_preallocs */
- (GInstanceInitFunc)pixbuf_renderer_init_wrapper, /* instance_init */
- NULL, /* value_table */
+ reinterpret_cast<GInstanceInitFunc>(pixbuf_renderer_init_wrapper), /* instance_init */
+ nullptr, /* value_table */
};
pixbuf_renderer_type = g_type_register_static(GTK_TYPE_EVENT_BOX, "PixbufRenderer",
- &pixbuf_renderer_info, 0);
+ &pixbuf_renderer_info, static_cast<GTypeFlags>(0));
}
return pixbuf_renderer_type;
{
GObjectClass *gobject_class = G_OBJECT_CLASS(renderer_class);
- parent_class = g_type_class_peek_parent(renderer_class);
+ parent_class = static_cast<GtkEventBoxClass *>(g_type_class_peek_parent(renderer_class));
gobject_class->set_property = pixbuf_renderer_set_property;
gobject_class->get_property = pixbuf_renderer_get_property;
PROP_ZOOM_MIN,
g_param_spec_double("zoom_min",
"Zoom minimum",
- NULL,
+ nullptr,
-1000.0,
1000.0,
PR_ZOOM_MIN,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ static_cast<GParamFlags>(G_PARAM_READABLE | G_PARAM_WRITABLE)));
g_object_class_install_property(gobject_class,
PROP_ZOOM_MAX,
g_param_spec_double("zoom_max",
"Zoom maximum",
- NULL,
+ nullptr,
-1000.0,
1000.0,
PR_ZOOM_MIN,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ static_cast<GParamFlags>(G_PARAM_READABLE | G_PARAM_WRITABLE)));
g_object_class_install_property(gobject_class,
PROP_ZOOM_QUALITY,
g_param_spec_uint("zoom_quality",
"Zoom quality",
- NULL,
+ nullptr,
GDK_INTERP_NEAREST,
GDK_INTERP_BILINEAR,
GDK_INTERP_BILINEAR,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ static_cast<GParamFlags>(G_PARAM_READABLE | G_PARAM_WRITABLE)));
g_object_class_install_property(gobject_class,
PROP_ZOOM_2PASS,
g_param_spec_boolean("zoom_2pass",
"2 pass zoom",
- NULL,
+ nullptr,
TRUE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ static_cast<GParamFlags>(G_PARAM_READABLE | G_PARAM_WRITABLE)));
g_object_class_install_property(gobject_class,
PROP_ZOOM_EXPAND,
g_param_spec_boolean("zoom_expand",
"Expand image in autozoom.",
- NULL,
+ nullptr,
FALSE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ static_cast<GParamFlags>(G_PARAM_READABLE | G_PARAM_WRITABLE)));
g_object_class_install_property(gobject_class,
PROP_SCROLL_RESET,
g_param_spec_uint("scroll_reset",
"New image scroll reset",
- NULL,
+ nullptr,
PR_SCROLL_RESET_TOPLEFT,
PR_SCROLL_RESET_NOCHANGE,
PR_SCROLL_RESET_TOPLEFT,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ static_cast<GParamFlags>(G_PARAM_READABLE | G_PARAM_WRITABLE)));
g_object_class_install_property(gobject_class,
PROP_DELAY_FLIP,
g_param_spec_boolean("delay_flip",
"Delay image update",
- NULL,
+ nullptr,
FALSE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ static_cast<GParamFlags>(G_PARAM_READABLE | G_PARAM_WRITABLE)));
g_object_class_install_property(gobject_class,
PROP_LOADING,
g_param_spec_boolean("loading",
"Image actively loading",
- NULL,
+ nullptr,
FALSE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ static_cast<GParamFlags>(G_PARAM_READABLE | G_PARAM_WRITABLE)));
g_object_class_install_property(gobject_class,
PROP_COMPLETE,
g_param_spec_boolean("complete",
"Image rendering complete",
- NULL,
+ nullptr,
FALSE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ static_cast<GParamFlags>(G_PARAM_READABLE | G_PARAM_WRITABLE)));
g_object_class_install_property(gobject_class,
PROP_CACHE_SIZE_DISPLAY,
g_param_spec_uint("cache_display",
"Display cache size MiB",
- NULL,
+ nullptr,
0,
128,
PR_CACHE_SIZE_DEFAULT,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ static_cast<GParamFlags>(G_PARAM_READABLE | G_PARAM_WRITABLE)));
g_object_class_install_property(gobject_class,
PROP_CACHE_SIZE_TILES,
0,
256,
PR_CACHE_SIZE_DEFAULT,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ static_cast<GParamFlags>(G_PARAM_READABLE | G_PARAM_WRITABLE)));
g_object_class_install_property(gobject_class,
PROP_WINDOW_FIT,
g_param_spec_boolean("window_fit",
"Fit window to image size",
- NULL,
+ nullptr,
FALSE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ static_cast<GParamFlags>(G_PARAM_READABLE | G_PARAM_WRITABLE)));
g_object_class_install_property(gobject_class,
PROP_WINDOW_LIMIT,
g_param_spec_boolean("window_limit",
"Limit size of parent window",
- NULL,
+ nullptr,
FALSE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ static_cast<GParamFlags>(G_PARAM_READABLE | G_PARAM_WRITABLE)));
g_object_class_install_property(gobject_class,
PROP_WINDOW_LIMIT_VALUE,
g_param_spec_uint("window_limit_value",
"Size limit of parent window",
- NULL,
+ nullptr,
10,
150,
100,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ static_cast<GParamFlags>(G_PARAM_READABLE | G_PARAM_WRITABLE)));
g_object_class_install_property(gobject_class,
PROP_AUTOFIT_LIMIT,
g_param_spec_boolean("autofit_limit",
"Limit size of image when autofitting",
- NULL,
+ nullptr,
FALSE,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ static_cast<GParamFlags>(G_PARAM_READABLE | G_PARAM_WRITABLE)));
g_object_class_install_property(gobject_class,
PROP_AUTOFIT_LIMIT_VALUE,
g_param_spec_uint("autofit_limit_value",
"Size limit of image when autofitting",
- NULL,
+ nullptr,
10,
150,
100,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ static_cast<GParamFlags>(G_PARAM_READABLE | G_PARAM_WRITABLE)));
g_object_class_install_property(gobject_class,
PROP_ENLARGEMENT_LIMIT_VALUE,
g_param_spec_uint("enlargement_limit_value",
"Size increase limit of image when autofitting",
- NULL,
+ nullptr,
100,
999,
500,
- G_PARAM_READABLE | G_PARAM_WRITABLE));
+ static_cast<GParamFlags>(G_PARAM_READABLE | G_PARAM_WRITABLE)));
signals[SIGNAL_ZOOM] =
G_OBJECT_CLASS_TYPE(gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(PixbufRendererClass, zoom),
- NULL, NULL,
+ nullptr, nullptr,
g_cclosure_marshal_VOID__DOUBLE,
G_TYPE_NONE, 1,
G_TYPE_DOUBLE);
G_OBJECT_CLASS_TYPE(gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(PixbufRendererClass, clicked),
- NULL, NULL,
+ nullptr, nullptr,
g_cclosure_marshal_VOID__BOXED,
G_TYPE_NONE, 1,
GDK_TYPE_EVENT);
G_OBJECT_CLASS_TYPE(gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(PixbufRendererClass, scroll_notify),
- NULL, NULL,
+ nullptr, nullptr,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
G_OBJECT_CLASS_TYPE(gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(PixbufRendererClass, render_complete),
- NULL, NULL,
+ nullptr, nullptr,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
G_OBJECT_CLASS_TYPE(gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(PixbufRendererClass, drag),
- NULL, NULL,
+ nullptr, nullptr,
g_cclosure_marshal_VOID__BOXED,
G_TYPE_NONE, 1,
GDK_TYPE_EVENT);
G_OBJECT_CLASS_TYPE(gobject_class),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(PixbufRendererClass, update_pixel),
- NULL, NULL,
+ nullptr, nullptr,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
}
static RendererFuncs *pr_backend_renderer_new(PixbufRenderer *pr)
{
- //~ if (options->image.use_clutter_renderer && !options->disable_gpu)
- //~ {
-//~ #ifdef HAVE_CLUTTER
- //~ return renderer_clutter_new(pr);
-//~ #else
- //~ log_printf("Warning: Geeqie is built without clutter renderer support");
-//~ #endif
- //~ }
return renderer_tiles_new(pr);
}
pr->y_mouse = -1;
pr->source_tiles_enabled = FALSE;
- pr->source_tiles = NULL;
+ pr->source_tiles = nullptr;
pr->orientation = 1;
pr->renderer = pr_backend_renderer_new(pr);
- pr->renderer2 = NULL;
+ pr->renderer2 = nullptr;
gtk_widget_set_double_buffered(box, FALSE);
gtk_widget_set_app_paintable(box, TRUE);
pr_source_tile_free_all(pr);
}
-PixbufRenderer *pixbuf_renderer_new(void)
+PixbufRenderer *pixbuf_renderer_new()
{
- return g_object_new(TYPE_PIXBUF_RENDERER, NULL);
+ return static_cast<PixbufRenderer *>(g_object_new(TYPE_PIXBUF_RENDERER, nullptr));
}
static void pixbuf_renderer_set_property(GObject *object, guint prop_id,
pr->zoom_max = g_value_get_double(value);
break;
case PROP_ZOOM_QUALITY:
- pr->zoom_quality = g_value_get_uint(value);
+ pr->zoom_quality = static_cast<GdkInterpType>(g_value_get_uint(value));
break;
case PROP_ZOOM_2PASS:
pr->zoom_2pass = g_value_get_boolean(value);
pr->zoom_expand = g_value_get_boolean(value);
break;
case PROP_SCROLL_RESET:
- pr->scroll_reset = g_value_get_uint(value);
+ pr->scroll_reset = static_cast<PixbufRendererScrollResetType>(g_value_get_uint(value));
break;
case PROP_DELAY_FLIP:
pr->delay_flip = g_value_get_boolean(value);
pr->complete = g_value_get_boolean(value);
break;
case PROP_CACHE_SIZE_DISPLAY:
-// pr->tile_cache_max = g_value_get_uint(value);
break;
case PROP_CACHE_SIZE_TILES:
pr->source_tiles_cache_size = g_value_get_uint(value);
g_value_set_boolean(value, pr->complete);
break;
case PROP_CACHE_SIZE_DISPLAY:
-// g_value_set_uint(value, pr->tile_cache_max);
break;
case PROP_CACHE_SIZE_TILES:
g_value_set_uint(value, pr->source_tiles_cache_size);
static void widget_set_cursor(GtkWidget *widget, gint icon)
{
GdkCursor *cursor;
+ GdkDisplay *display;
if (!gtk_widget_get_window(widget)) return;
+ display = gdk_display_get_default();
+
if (icon == -1)
{
- cursor = NULL;
+ cursor = nullptr;
}
else
{
- cursor = gdk_cursor_new(icon);
+ cursor = gdk_cursor_new_for_display(display, static_cast<GdkCursorType>(icon));
}
gdk_window_set_cursor(gtk_widget_get_window(widget), cursor);
{
GtkWidget *widget;
GtkWidget *parent;
- gint ww, wh;
+ gint ww;
+ gint wh;
GtkAllocation widget_allocation;
GtkAllocation parent_allocation;
void pixbuf_renderer_set_parent(PixbufRenderer *pr, GtkWindow *window)
{
g_return_if_fail(IS_PIXBUF_RENDERER(pr));
- g_return_if_fail(window == NULL || GTK_IS_WINDOW(window));
+ g_return_if_fail(window == nullptr || GTK_IS_WINDOW(window));
pr->parent_window = GTK_WIDGET(window);
}
-GtkWindow *pixbuf_renderer_get_parent(PixbufRenderer *pr)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
+GtkWindow *pixbuf_renderer_get_parent_unused(PixbufRenderer *pr)
{
g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), NULL);
return GTK_WINDOW(pr->parent_window);
}
+#pragma GCC diagnostic pop
/*
void pixbuf_renderer_overlay_remove(PixbufRenderer *pr, gint id)
{
- pr->renderer->overlay_set(pr->renderer, id, NULL, 0, 0);
- if (pr->renderer2) pr->renderer2->overlay_set(pr->renderer2, id, NULL, 0, 0);
+ pr->renderer->overlay_set(pr->renderer, id, nullptr, 0, 0);
+ if (pr->renderer2) pr->renderer2->overlay_set(pr->renderer2, id, nullptr, 0, 0);
}
/*
static gboolean pr_scroller_update_cb(gpointer data)
{
- PixbufRenderer *pr = data;
- gint x, y;
- gint xinc, yinc;
+ auto pr = static_cast<PixbufRenderer *>(data);
+ gint x;
+ gint y;
+ gint xinc;
+ gint yinc;
/* this was a simple scroll by difference between scroller and mouse position,
* but all this math results in a smoother result and accounts for a dead zone.
if (pr->scroller_overlay == -1)
{
GdkPixbuf *pixbuf;
- gint w, h;
+ gint w;
+ gint h;
#ifdef GQ_BUILD
- pixbuf = pixbuf_inline(PIXBUF_INLINE_SCROLLER);
+ pixbuf = gdk_pixbuf_new_from_resource(GQ_RESOURCE_PATH_ICONS "/" PIXBUF_INLINE_SCROLLER ".png", nullptr);
#else
pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, 32, 32);
gdk_pixbuf_fill(pixbuf, 0x000000ff);
*-------------------------------------------------------------------
*/
-void pixbuf_renderer_set_color(PixbufRenderer *pr, GdkColor *color)
+void pixbuf_renderer_set_color(PixbufRenderer *pr, GdkRGBA *color)
{
g_return_if_fail(IS_PIXBUF_RENDERER(pr));
static void pr_source_tile_free_all(PixbufRenderer *pr)
{
- GList *work;
-
- work = pr->source_tiles;
- while (work)
- {
- SourceTile *st;
-
- st = work->data;
- work = work->next;
-
- pr_source_tile_free(st);
- }
-
- g_list_free(pr->source_tiles);
- pr->source_tiles = NULL;
+ g_list_free_full(pr->source_tiles, reinterpret_cast<GDestroyNotify>(pr_source_tile_free));
+ pr->source_tiles = nullptr;
}
static void pr_source_tile_unset(PixbufRenderer *pr)
static gboolean pr_source_tile_visible(PixbufRenderer *pr, SourceTile *st)
{
- gint x1, y1, x2, y2;
+ gint x1;
+ gint y1;
+ gint x2;
+ gint y2;
if (!st) return FALSE;
-// x1 = ROUND_DOWN(pr->x_scroll, pr->tile_width);
-// y1 = ROUND_DOWN(pr->y_scroll, pr->tile_height);
-// x2 = ROUND_UP(pr->x_scroll + pr->vis_width, pr->tile_width);
-// y2 = ROUND_UP(pr->y_scroll + pr->vis_height, pr->tile_height);
x1 = pr->x_scroll;
y1 = pr->y_scroll;
x2 = pr->x_scroll + pr->vis_width;
y2 = pr->y_scroll + pr->vis_height;
- return !((gdouble)st->x * pr->scale > (gdouble)x2 ||
- (gdouble)(st->x + pr->source_tile_width) * pr->scale < (gdouble)x1 ||
- (gdouble)st->y * pr->scale > (gdouble)y2 ||
- (gdouble)(st->y + pr->source_tile_height) * pr->scale < (gdouble)y1);
+ return static_cast<gdouble>(st->x) * pr->scale <= static_cast<gdouble>(x2) &&
+ static_cast<gdouble>(st->x + pr->source_tile_width) * pr->scale >= static_cast<gdouble>(x1) &&
+ static_cast<gdouble>(st->y) * pr->scale <= static_cast<gdouble>(y2) &&
+ static_cast<gdouble>(st->y + pr->source_tile_height) * pr->scale >= static_cast<gdouble>(y1);
}
static SourceTile *pr_source_tile_new(PixbufRenderer *pr, gint x, gint y)
{
- SourceTile *st = NULL;
+ SourceTile *st = nullptr;
gint count;
g_return_val_if_fail(pr->source_tile_width >= 1 && pr->source_tile_height >= 1, NULL);
{
SourceTile *needle;
- needle = work->data;
+ needle = static_cast<SourceTile *>(work->data);
work = work->prev;
if (!pr_source_tile_visible(pr, needle))
SourceTile *st;
st = pr_source_tile_new(pr, x, y);
- if (!st) return NULL;
+ if (!st) return nullptr;
if (pr->func_tile_request &&
pr->func_tile_request(pr, st->x, st->y,
work = pr->source_tiles;
while (work)
{
- SourceTile *st = work->data;
+ auto st = static_cast<SourceTile *>(work->data);
if (x >= st->x && x < st->x + pr->source_tile_width &&
y >= st->y && y < st->y + pr->source_tile_height)
work = work->next;
}
- return NULL;
+ return nullptr;
}
GList *pr_source_tile_compute_region(PixbufRenderer *pr, gint x, gint y, gint w, gint h, gboolean request)
{
- gint x1, y1;
- GList *list = NULL;
- gint sx, sy;
+ gint x1;
+ gint y1;
+ GList *list = nullptr;
+ gint sx;
+ gint sy;
if (x < 0) x = 0;
if (y < 0) y = 0;
while (work)
{
SourceTile *st;
- gint rx, ry, rw, rh;
+ gint rx;
+ gint ry;
+ gint rw;
+ gint rh;
- st = work->data;
+ st = static_cast<SourceTile *>(work->data);
work = work->next;
if (pr_clip_region(st->x, st->y, pr->source_tile_width, pr->source_tile_height,
g_return_if_fail(IS_PIXBUF_RENDERER(pr));
g_return_if_fail(tile_width >= 32 && tile_height >= 32);
g_return_if_fail(width >= 32 && height > 32);
- g_return_if_fail(func_request != NULL);
+ g_return_if_fail(func_request != nullptr);
if (pr->pixbuf) g_object_unref(pr->pixbuf);
- pr->pixbuf = NULL;
+ pr->pixbuf = nullptr;
pr_source_tile_unset(pr);
pr->func_tile_data = user_data;
pr_stereo_temp_disable(pr, TRUE);
- pr_zoom_sync(pr, zoom, PR_ZOOM_FORCE | PR_ZOOM_NEW, 0, 0);
+ pr_zoom_sync(pr, zoom, static_cast<PrZoomFlags>(PR_ZOOM_FORCE | PR_ZOOM_NEW), 0, 0);
}
void pixbuf_renderer_set_tiles_size(PixbufRenderer *pr, gint width, gint height)
/* The other values are out of range */
break;
}
-// log_printf("tile coord y:%f, ih:%d, th:%f ry:%f\n", tile_y, image_h, tile_h, *res_x);
}
void pr_tile_region_map_orientation(gint orientation,
/* The other values are out of range */
break;
}
-// log_printf("inside y:%d, th:%d, ah:%d ry:%d\n", area_y, tile_h, area_h, *res_x);
}
void pr_coords_map_orientation_reverse(gint orientation,
static void pixbuf_renderer_sync_scroll_center(PixbufRenderer *pr)
{
- gint src_x, src_y;
+ gint src_x;
+ gint src_y;
if (!pr->width || !pr->height) return;
/*
if (pr->width > pr->viewport_width)
{
src_x = pr->x_scroll + pr->vis_width / 2;
- pr->norm_center_x = (gdouble)src_x / pr->width;
+ pr->norm_center_x = static_cast<gdouble>(src_x) / pr->width;
}
if (pr->height > pr->viewport_height)
{
src_y = pr->y_scroll + pr->vis_height / 2;
- pr->norm_center_y = (gdouble)src_y / pr->height;
+ pr->norm_center_y = static_cast<gdouble>(src_y) / pr->height;
}
}
static gboolean pr_size_clamp(PixbufRenderer *pr)
{
- gint old_vw, old_vh;
+ gint old_vw;
+ gint old_vh;
old_vw = pr->vis_width;
old_vh = pr->vis_height;
static gboolean pr_zoom_clamp(PixbufRenderer *pr, gdouble zoom,
PrZoomFlags flags)
{
- gint w, h;
+ gint w;
+ gint h;
gdouble scale;
gboolean force = !!(flags & PR_ZOOM_FORCE);
gboolean new_z = !!(flags & PR_ZOOM_NEW);
if ((pr->zoom_expand && !sizeable) || w > max_w || h > max_h)
{
- if ((gdouble)max_w / w > (gdouble)max_h / h / pr->aspect_ratio)
+ if (static_cast<gdouble>(max_w) / w > static_cast<gdouble>(max_h) / h / pr->aspect_ratio)
{
- scale = (gdouble)max_h / h / pr->aspect_ratio;
+ scale = static_cast<gdouble>(max_h) / h / pr->aspect_ratio;
h = max_h;
w = w * scale + 0.5;
if (w > max_w) w = max_w;
}
else
{
- scale = (gdouble)max_w / w;
+ scale = static_cast<gdouble>(max_w) / w;
w = max_w;
h = h * scale * pr->aspect_ratio + 0.5;
if (h > max_h) h = max_h;
if (pr->autofit_limit)
{
- gdouble factor = (gdouble)pr->autofit_limit_size / 100;
+ gdouble factor = static_cast<gdouble>(pr->autofit_limit_size) / 100;
w = w * factor + 0.5;
h = h * factor + 0.5;
scale = scale * factor;
if (pr->zoom_expand)
{
- gdouble factor = (gdouble)pr->enlargement_limit_size / 100;
+ gdouble factor = static_cast<gdouble>(pr->enlargement_limit_size) / 100;
if (scale > factor)
{
w = w * factor / scale;
PrZoomFlags flags, gint px, gint py)
{
gdouble old_scale;
- gint old_cx, old_cy;
+ gint old_cx;
+ gint old_cy;
gboolean center_point = !!(flags & PR_ZOOM_CENTER);
gboolean force = !!(flags & PR_ZOOM_FORCE);
gboolean new_z = !!(flags & PR_ZOOM_NEW);
old_cy = pr->y_scroll + pr->vis_height / 2;
}
- if (force) clamp_flags |= PR_ZOOM_INVALIDATE;
+ if (force) clamp_flags = static_cast<PrZoomFlags>(clamp_flags | PR_ZOOM_INVALIDATE);
if (!pr_zoom_clamp(pr, zoom, clamp_flags)) return;
(void) pr_size_clamp(pr);
{
case PR_SCROLL_RESET_NOCHANGE:
/* maintain old scroll position */
- pr->x_scroll = ((gdouble)pr->image_width * old_center_x * pr->scale) - pr->vis_width / 2;
- pr->y_scroll = ((gdouble)pr->image_height * old_center_y * pr->scale * pr->aspect_ratio) - pr->vis_height / 2;
+ pr->x_scroll = (static_cast<gdouble>(pr->image_width) * old_center_x * pr->scale) - pr->vis_width / 2.0;
+ pr->y_scroll = (static_cast<gdouble>(pr->image_height) * old_center_y * pr->scale * pr->aspect_ratio) - pr->vis_height / 2.0;
break;
case PR_SCROLL_RESET_CENTER:
/* center new image */
- pr->x_scroll = ((gdouble)pr->image_width / 2.0 * pr->scale) - pr->vis_width / 2;
- pr->y_scroll = ((gdouble)pr->image_height / 2.0 * pr->scale * pr->aspect_ratio) - pr->vis_height / 2;
+ pr->x_scroll = (static_cast<gdouble>(pr->image_width) / 2.0 * pr->scale) - pr->vis_width / 2.0;
+ pr->y_scroll = (static_cast<gdouble>(pr->image_height) / 2.0 * pr->scale * pr->aspect_ratio) - pr->vis_height / 2.0;
break;
case PR_SCROLL_RESET_TOPLEFT:
default:
}
else
{
- pr->x_scroll = old_cx / old_scale * pr->scale - (pr->vis_width / 2);
- pr->y_scroll = old_cy / old_scale * pr->scale * pr->aspect_ratio - (pr->vis_height / 2);
+ pr->x_scroll = old_cx / old_scale * pr->scale - (pr->vis_width / 2.0);
+ pr->y_scroll = old_cy / old_scale * pr->scale * pr->aspect_ratio - (pr->vis_height / 2.0);
}
}
{
GdkPixbuf *pixbuf;
- if (pixbuf_renderer_overlay_get(pr, pr->scroller_overlay, &pixbuf, NULL, NULL))
+ if (pixbuf_renderer_overlay_get(pr, pr->scroller_overlay, &pixbuf, nullptr, nullptr))
{
- gint w, h;
+ gint w;
+ gint h;
w = gdk_pixbuf_get_width(pixbuf);
h = gdk_pixbuf_get_height(pixbuf);
pr_update_signal(pr);
}
-static void pr_size_cb(GtkWidget *UNUSED(widget), GtkAllocation *allocation, gpointer data)
+static void pr_size_cb(GtkWidget *, GtkAllocation *allocation, gpointer data)
{
- PixbufRenderer *pr = data;
+ auto pr = static_cast<PixbufRenderer *>(data);
pr_size_sync(pr, allocation->width, allocation->height);
}
void pixbuf_renderer_scroll(PixbufRenderer *pr, gint x, gint y)
{
- gint old_x, old_y;
- gint x_off, y_off;
+ gint old_x;
+ gint old_y;
+ gint x_off;
+ gint y_off;
g_return_if_fail(IS_PIXBUF_RENDERER(pr));
void pixbuf_renderer_scroll_to_point(PixbufRenderer *pr, gint x, gint y,
gdouble x_align, gdouble y_align)
{
- gint px, py;
- gint ax, ay;
+ gint px;
+ gint py;
+ gint ax;
+ gint ay;
x_align = CLAMP(x_align, 0.0, 1.0);
y_align = CLAMP(y_align, 0.0, 1.0);
- ax = (gdouble)pr->vis_width * x_align;
- ay = (gdouble)pr->vis_height * y_align;
+ ax = static_cast<gdouble>(pr->vis_width) * x_align;
+ ay = static_cast<gdouble>(pr->vis_height) * y_align;
- px = (gdouble)x * pr->scale - (pr->x_scroll + ax);
- py = (gdouble)y * pr->scale * pr->aspect_ratio - (pr->y_scroll + ay);
+ px = static_cast<gdouble>(x) * pr->scale - (pr->x_scroll + ax);
+ py = static_cast<gdouble>(y) * pr->scale * pr->aspect_ratio - (pr->y_scroll + ay);
pixbuf_renderer_scroll(pr, px, py);
}
void pixbuf_renderer_set_scroll_center(PixbufRenderer *pr, gdouble x, gdouble y)
{
- gdouble dst_x, dst_y;
+ gdouble dst_x;
+ gdouble dst_y;
- dst_x = x * pr->width - pr->vis_width / 2 - pr->x_scroll + CLAMP(pr->subpixel_x_scroll, -1.0, 1.0);
- dst_y = y * pr->height - pr->vis_height / 2 - pr->y_scroll + CLAMP(pr->subpixel_y_scroll, -1.0, 1.0);
+ dst_x = x * pr->width - pr->vis_width / 2.0 - pr->x_scroll + CLAMP(pr->subpixel_x_scroll, -1.0, 1.0);
+ dst_y = y * pr->height - pr->vis_height / 2.0 - pr->y_scroll + CLAMP(pr->subpixel_y_scroll, -1.0, 1.0);
- pr->subpixel_x_scroll = dst_x - (gint)dst_x;
- pr->subpixel_y_scroll = dst_y - (gint)dst_y;
+ pr->subpixel_x_scroll = dst_x - static_cast<gint>(dst_x);
+ pr->subpixel_y_scroll = dst_y - static_cast<gint>(dst_y);
- pixbuf_renderer_scroll(pr, (gint)dst_x, (gint)dst_y);
+ pixbuf_renderer_scroll(pr, static_cast<gint>(dst_x), static_cast<gint>(dst_y));
}
/*
*-------------------------------------------------------------------
*/
-static gboolean pr_mouse_motion_cb(GtkWidget *widget, GdkEventMotion *event, gpointer UNUSED(data))
+static gboolean pr_mouse_motion_cb(GtkWidget *widget, GdkEventMotion *event, gpointer)
{
PixbufRenderer *pr;
gint accel;
/* This is a hack, but work far the best, at least for single pointer systems.
* See https://bugzilla.gnome.org/show_bug.cgi?id=587714 for more. */
- gint x, y;
+ gint x;
+ gint y;
seat = gdk_display_get_default_seat(gdk_window_get_display(event->window));
device = gdk_seat_get_pointer(seat);
- gdk_window_get_device_position(event->window, device, &x, &y, NULL);
+ gdk_window_get_device_position(event->window, device, &x, &y, nullptr);
event->x = x;
event->y = y;
return FALSE;
}
-static gboolean pr_leave_notify_cb(GtkWidget *widget, GdkEventCrossing *UNUSED(cevent), gpointer UNUSED(data))
+static gboolean pr_leave_notify_cb(GtkWidget *widget, GdkEventCrossing *, gpointer)
{
PixbufRenderer *pr;
return FALSE;
}
-static gboolean pr_mouse_press_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer UNUSED(data))
+static gboolean pr_mouse_press_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer)
{
PixbufRenderer *pr;
GtkWidget *parent;
pr->drag_last_y = bevent->y;
pr->drag_moved = 0;
gdk_pointer_grab(gtk_widget_get_window(widget), FALSE,
- GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_RELEASE_MASK,
- NULL, NULL, bevent->time);
+ static_cast<GdkEventMask>(GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_RELEASE_MASK),
+ nullptr, nullptr, bevent->time);
gtk_grab_add(widget);
break;
case MOUSE_BUTTON_MIDDLE:
return FALSE;
}
-static gboolean pr_mouse_release_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer UNUSED(data))
+static gboolean pr_mouse_release_cb(GtkWidget *widget, GdkEventButton *bevent, gpointer)
{
PixbufRenderer *pr;
return FALSE;
}
-static gboolean pr_mouse_leave_cb(GtkWidget *widget, GdkEventCrossing *UNUSED(event), gpointer UNUSED(data))
+static gboolean pr_mouse_leave_cb(GtkWidget *widget, GdkEventCrossing *, gpointer)
{
PixbufRenderer *pr;
return FALSE;
}
-static void pr_mouse_drag_cb(GtkWidget *widget, GdkDragContext *UNUSED(context), gpointer UNUSED(data))
+static void pr_mouse_drag_cb(GtkWidget *widget, GdkDragContext *, gpointer)
{
PixbufRenderer *pr;
G_CALLBACK(pr_leave_notify_cb), pr);
gtk_widget_set_events(GTK_WIDGET(pr), GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK |
- GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_SCROLL_MASK |
- GDK_LEAVE_NOTIFY_MASK);
+ static_cast<GdkEventMask>(GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_SCROLL_MASK |
+ GDK_LEAVE_NOTIFY_MASK));
g_signal_connect(G_OBJECT(pr), "drag_begin",
G_CALLBACK(pr_mouse_drag_cb), pr);
*-------------------------------------------------------------------
*/
-#define COLOR_BYTES 3 /* rgb */
-#define RC 0 /* Red-Cyan */
-#define GM 1 /* Green-Magenta */
-#define YB 2 /* Yellow-Blue */
+enum {
+ COLOR_BYTES = 3, /* rgb */
+ RC = 0, /* Red-Cyan */
+ GM = 1, /* Green-Magenta */
+ YB = 2 /* Yellow-Blue */
+};
static void pr_create_anaglyph_color(GdkPixbuf *pixbuf, GdkPixbuf *right, gint x, gint y, gint w, gint h, guint mode)
{
- gint srs, drs;
- guchar *s_pix, *d_pix;
- guchar *sp, *dp;
- guchar *spi, *dpi;
- gint i, j;
+ gint srs;
+ gint drs;
+ guchar *s_pix;
+ guchar *d_pix;
+ guchar *sp;
+ guchar *dp;
+ guchar *spi;
+ guchar *dpi;
+ gint i;
+ gint j;
srs = gdk_pixbuf_get_rowstride(right);
s_pix = gdk_pixbuf_get_pixels(right);
static void pr_create_anaglyph_gray(GdkPixbuf *pixbuf, GdkPixbuf *right, gint x, gint y, gint w, gint h, guint mode)
{
- gint srs, drs;
- guchar *s_pix, *d_pix;
- guchar *sp, *dp;
- guchar *spi, *dpi;
- gint i, j;
+ gint srs;
+ gint drs;
+ guchar *s_pix;
+ guchar *d_pix;
+ guchar *sp;
+ guchar *dp;
+ guchar *spi;
+ guchar *dpi;
+ gint i;
+ gint j;
const double gc[3] = {0.299, 0.587, 0.114};
srs = gdk_pixbuf_get_rowstride(right);
static void pr_create_anaglyph_dubois(GdkPixbuf *pixbuf, GdkPixbuf *right, gint x, gint y, gint w, gint h, guint mode)
{
- gint srs, drs;
- guchar *s_pix, *d_pix;
- guchar *sp, *dp;
- guchar *spi, *dpi;
- gint i, j, k;
+ gint srs;
+ gint drs;
+ guchar *s_pix;
+ guchar *d_pix;
+ guchar *sp;
+ guchar *dp;
+ guchar *spi;
+ guchar *dpi;
+ gint i;
+ gint j;
+ gint k;
double pr_dubois_matrix[3][6];
static const double pr_dubois_matrix_RC[3][6] = {
{ 0.456, 0.500, 0.176, -0.043, -0.088, -0.002},
pr_pixbuf_size_sync(pr);
pr->renderer->update_pixbuf(pr->renderer, flags & PR_ZOOM_LAZY);
if (pr->renderer2) pr->renderer2->update_pixbuf(pr->renderer2, flags & PR_ZOOM_LAZY);
- pr_zoom_sync(pr, zoom, flags | PR_ZOOM_FORCE | PR_ZOOM_NEW, 0, 0);
+ pr_zoom_sync(pr, zoom, static_cast<PrZoomFlags>(flags | PR_ZOOM_FORCE | PR_ZOOM_NEW), 0, 0);
}
void pixbuf_renderer_set_pixbuf(PixbufRenderer *pr, GdkPixbuf *pixbuf, gdouble zoom)
pr_source_tile_unset(pr);
- pr_set_pixbuf(pr, pixbuf, zoom, 0);
+ pr_set_pixbuf(pr, pixbuf, zoom, PR_ZOOM_NONE);
pr_update_signal(pr);
}
pr_zoom_sync(pr, pr->zoom, PR_ZOOM_FORCE, 0, 0);
}
-gint pixbuf_renderer_get_orientation(PixbufRenderer *pr)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
+gint pixbuf_renderer_get_orientation_unused(PixbufRenderer *pr)
{
if (!pr) return 1;
return pr->orientation;
}
+#pragma GCC diagnostic pop
void pixbuf_renderer_set_stereo_data(PixbufRenderer *pr, StereoPixbufData stereo_data)
{
pr->func_tile_data = source->func_tile_data;
pr->source_tiles = source->source_tiles;
- source->source_tiles = NULL;
+ source->source_tiles = nullptr;
- pr_zoom_sync(pr, source->zoom, PR_ZOOM_FORCE | PR_ZOOM_NEW, 0, 0);
+ pr_zoom_sync(pr, source->zoom, static_cast<PrZoomFlags>(PR_ZOOM_FORCE | PR_ZOOM_NEW), 0, 0);
}
else
{
pr->scroll_reset = scroll_reset;
- pixbuf_renderer_set_pixbuf(source, NULL, source->zoom);
+ pixbuf_renderer_set_pixbuf(source, nullptr, source->zoom);
}
void pixbuf_renderer_copy(PixbufRenderer *pr, PixbufRenderer *source)
pr->func_tile_data = source->func_tile_data;
pr->source_tiles = source->source_tiles;
- source->source_tiles = NULL;
+ source->source_tiles = nullptr;
- pr_zoom_sync(pr, source->zoom, PR_ZOOM_FORCE | PR_ZOOM_NEW, 0, 0);
+ pr_zoom_sync(pr, source->zoom, static_cast<PrZoomFlags>(PR_ZOOM_FORCE | PR_ZOOM_NEW), 0, 0);
}
else
{
else
{
if (pr->renderer2) pr->renderer2->free(pr->renderer2);
- pr->renderer2 = NULL;
+ pr->renderer2 = nullptr;
}
if (pr->stereo_mode & PR_STEREO_HALF)
{
if (redraw)
{
pr_size_sync(pr, pr->window_width, pr->window_height); /* recalculate new viewport */
- pr_zoom_sync(pr, pr->zoom, PR_ZOOM_FORCE | PR_ZOOM_NEW, 0, 0);
+ pr_zoom_sync(pr, pr->zoom, static_cast<PrZoomFlags>(PR_ZOOM_FORCE | PR_ZOOM_NEW), 0, 0);
}
}
if (!pr->renderer) pr->renderer = pr_backend_renderer_new(pr);
pr->renderer->stereo_set(pr->renderer, PR_STEREO_NONE);
if (pr->renderer2) pr->renderer2->free(pr->renderer2);
- pr->renderer2 = NULL;
+ pr->renderer2 = nullptr;
pr->aspect_ratio = 1.0;
}
else
gint *r_mouse, gint *g_mouse, gint *b_mouse)
{
GdkPixbuf *pb = pr->pixbuf;
- gint p_alpha, prs;
- guchar *p_pix, *pp;
- gint map_x, map_y, map_w, map_h;
- size_t xoff, yoff;
+ gint p_alpha;
+ gint prs;
+ guchar *p_pix;
+ guchar *pp;
+ gint map_x;
+ gint map_y;
+ gint map_w;
+ gint map_h;
+ size_t xoff;
+ size_t yoff;
g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), FALSE);
- g_return_val_if_fail(r_mouse != NULL && g_mouse != NULL && b_mouse != NULL, FALSE);
+ g_return_val_if_fail(r_mouse != nullptr && g_mouse != nullptr && b_mouse != nullptr, FALSE);
if (!pr->pixbuf && !pr->source_tiles_enabled)
{
prs = gdk_pixbuf_get_rowstride(pb);
p_pix = gdk_pixbuf_get_pixels(pb);
- xoff = (size_t)map_x * (p_alpha ? 4 : 3);
- yoff = (size_t)map_y * prs;
+ xoff = static_cast<size_t>(map_x) * (p_alpha ? 4 : 3);
+ yoff = static_cast<size_t>(map_y) * prs;
pp = p_pix + yoff + xoff;
*r_mouse = *pp;
pp++;
gboolean pixbuf_renderer_get_mouse_position(PixbufRenderer *pr, gint *x_pixel_return, gint *y_pixel_return)
{
- gint x_pixel, y_pixel, x_pixel_clamped, y_pixel_clamped;
+ gint x_pixel;
+ gint y_pixel;
+ gint x_pixel_clamped;
+ gint y_pixel_clamped;
g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), FALSE);
- g_return_val_if_fail(x_pixel_return != NULL && y_pixel_return != NULL, FALSE);
+ g_return_val_if_fail(x_pixel_return != nullptr && y_pixel_return != nullptr, FALSE);
if (!pr->pixbuf && !pr->source_tiles_enabled)
{
return FALSE;
}
- x_pixel = floor((gdouble)(pr->x_mouse - pr->x_offset + pr->x_scroll) / pr->scale);
- y_pixel = floor((gdouble)(pr->y_mouse - pr->y_offset + pr->y_scroll) / pr->scale / pr->aspect_ratio);
+ x_pixel = floor(static_cast<gdouble>(pr->x_mouse - pr->x_offset + pr->x_scroll) / pr->scale);
+ y_pixel = floor(static_cast<gdouble>(pr->y_mouse - pr->y_offset + pr->y_scroll) / pr->scale / pr->aspect_ratio);
x_pixel_clamped = CLAMP(x_pixel, 0, pr->image_width - 1);
y_pixel_clamped = CLAMP(y_pixel, 0, pr->image_height - 1);
gboolean pixbuf_renderer_get_image_size(PixbufRenderer *pr, gint *width, gint *height)
{
g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), FALSE);
- g_return_val_if_fail(width != NULL && height != NULL, FALSE);
+ g_return_val_if_fail(width != nullptr && height != nullptr, FALSE);
if (!pr->pixbuf && !pr->source_tiles_enabled && (!pr->image_width || !pr->image_height))
{
gboolean pixbuf_renderer_get_scaled_size(PixbufRenderer *pr, gint *width, gint *height)
{
g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), FALSE);
- g_return_val_if_fail(width != NULL && height != NULL, FALSE);
+ g_return_val_if_fail(width != nullptr && height != nullptr, FALSE);
if (!pr->pixbuf && !pr->source_tiles_enabled && (!pr->image_width || !pr->image_height))
{
gboolean pixbuf_renderer_get_visible_rect(PixbufRenderer *pr, GdkRectangle *rect)
{
g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), FALSE);
- g_return_val_if_fail(rect != NULL, FALSE);
+ g_return_val_if_fail(rect != nullptr, FALSE);
if ((!pr->pixbuf && !pr->source_tiles_enabled) ||
!pr->scale)
return FALSE;
}
- rect->x = (gint)((gdouble)pr->x_scroll / pr->scale);
- rect->y = (gint)((gdouble)pr->y_scroll / pr->scale / pr->aspect_ratio);
- rect->width = (gint)((gdouble)pr->vis_width / pr->scale);
- rect->height = (gint)((gdouble)pr->vis_height / pr->scale / pr->aspect_ratio);
+ rect->x = static_cast<gint>(static_cast<gdouble>(pr->x_scroll) / pr->scale);
+ rect->y = static_cast<gint>(static_cast<gdouble>(pr->y_scroll) / pr->scale / pr->aspect_ratio);
+ rect->width = static_cast<gint>(static_cast<gdouble>(pr->vis_width) / pr->scale);
+ rect->height = static_cast<gint>(static_cast<gdouble>(pr->vis_height) / pr->scale / pr->aspect_ratio);
return TRUE;
}
-gboolean pixbuf_renderer_get_virtual_rect(PixbufRenderer *pr, GdkRectangle *rect)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
+gboolean pixbuf_renderer_get_virtual_rect_unused(PixbufRenderer *pr, GdkRectangle *rect)
{
g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), FALSE);
- g_return_val_if_fail(rect != NULL, FALSE);
+ g_return_val_if_fail(rect != nullptr, FALSE);
if ((!pr->pixbuf && !pr->source_tiles_enabled))
{
rect->height = pr->vis_height;
return TRUE;
}
+#pragma GCC diagnostic pop
-void pixbuf_renderer_set_size_early(PixbufRenderer *UNUSED(pr), guint UNUSED(width), guint UNUSED(height))
+void pixbuf_renderer_set_size_early(PixbufRenderer *, guint, guint)
{
#if 0
/** @FIXME this function does not consider the image orientation,
pr->image_height = height;
pr_zoom_clamp(pr, zoom, PR_ZOOM_FORCE, NULL);
-
- //w = width;
- //h = height;
-
- //pr->width = width;
- //pr->height = height;
#endif
}
projects / geeqie.git / blobdiff