* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#include <stdlib.h>
-#include <string.h>
-#include <math.h>
+#include <cmath>
+#include <cstdlib>
+#include <cstring>
#include "main.h"
#include "renderer-tiles.h"
#include "pixbuf-util.h"
#include "exif.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
-typedef struct _ImageTile ImageTile;
-typedef struct _QueueData QueueData;
+struct QueueData;
-struct _ImageTile
+struct ImageTile
{
cairo_surface_t *surface; /* off screen buffer */
GdkPixbuf *pixbuf; /* pixbuf area for zooming */
guint size; /* est. memory used by pixmap and pixbuf */
};
-struct _QueueData
+struct QueueData
{
ImageTile *it;
gint x;
gboolean new_data;
};
-typedef struct _OverlayData OverlayData;
-struct _OverlayData
+struct OverlayData
{
gint id;
OverlayRendererFlags flags;
};
-typedef struct _RendererTiles RendererTiles;
-
-struct _RendererTiles
+struct RendererTiles
{
RendererFuncs f;
PixbufRenderer *pr;
pr->viewport_width, pr->viewport_height,
&rx, &ry, &rw, &rh))
{
- cairo_set_source_rgb(cr, (double)pr->color.red/65535, (double)pr->color.green/65535, (double)pr->color.blue/65535);
+ cairo_set_source_rgb(cr, static_cast<double>(pr->color.red), static_cast<double>(pr->color.green), static_cast<double>(pr->color.blue));
cairo_rectangle(cr, rx + rt->stereo_off_x, ry + rt->stereo_off_y, rw, rh);
cairo_fill(cr);
- rt_overlay_draw(rt, rx, ry, rw, rh, NULL);
+ rt_overlay_draw(rt, rx, ry, rw, rh, nullptr);
}
cairo_destroy(cr);
return;
pr->x_offset, pr->viewport_height,
&rx, &ry, &rw, &rh))
{
- cairo_set_source_rgb(cr, (double)pr->color.red/65535, (double)pr->color.green/65535, (double)pr->color.blue/65535);
+ cairo_set_source_rgb(cr, static_cast<double>(pr->color.red), static_cast<double>(pr->color.green), static_cast<double>(pr->color.blue));
cairo_rectangle(cr, rx + rt->stereo_off_x, ry + rt->stereo_off_y, rw, rh);
cairo_fill(cr);
- rt_overlay_draw(rt, rx, ry, rw, rh, NULL);
+ rt_overlay_draw(rt, rx, ry, rw, rh, nullptr);
}
if (pr->viewport_width - pr->vis_width - pr->x_offset > 0 &&
pr_clip_region(x, y, w, h,
pr->viewport_width - pr->vis_width - pr->x_offset, pr->viewport_height,
&rx, &ry, &rw, &rh))
{
- cairo_set_source_rgb(cr, (double)pr->color.red/65535, (double)pr->color.green/65535, (double)pr->color.blue/65535);
+ cairo_set_source_rgb(cr, static_cast<double>(pr->color.red), static_cast<double>(pr->color.green), static_cast<double>(pr->color.blue));
cairo_rectangle(cr, rx + rt->stereo_off_x, ry + rt->stereo_off_y, rw, rh);
cairo_fill(cr);
- rt_overlay_draw(rt, rx, ry, rw, rh, NULL);
+ rt_overlay_draw(rt, rx, ry, rw, rh, nullptr);
}
}
if (pr->vis_height < pr->viewport_height)
pr->vis_width, pr->y_offset,
&rx, &ry, &rw, &rh))
{
- cairo_set_source_rgb(cr, (double)pr->color.red/65535, (double)pr->color.green/65535, (double)pr->color.blue/65535);
+ cairo_set_source_rgb(cr, static_cast<double>(pr->color.red), static_cast<double>(pr->color.green), static_cast<double>(pr->color.blue));
cairo_rectangle(cr, rx + rt->stereo_off_x, ry + rt->stereo_off_y, rw, rh);
cairo_fill(cr);
- rt_overlay_draw(rt, rx, ry, rw, rh, NULL);
+ rt_overlay_draw(rt, rx, ry, rw, rh, nullptr);
}
if (pr->viewport_height - pr->vis_height - pr->y_offset > 0 &&
pr_clip_region(x, y, w, h,
pr->vis_width, pr->viewport_height - pr->vis_height - pr->y_offset,
&rx, &ry, &rw, &rh))
{
- cairo_set_source_rgb(cr, (double)pr->color.red/65535, (double)pr->color.green/65535, (double)pr->color.blue/65535);
+ cairo_set_source_rgb(cr, static_cast<double>(pr->color.red), static_cast<double>(pr->color.green), static_cast<double>(pr->color.blue));
cairo_rectangle(cr, rx + rt->stereo_off_x, ry + rt->stereo_off_y, rw, rh);
cairo_fill(cr);
- rt_overlay_draw(rt, rx, ry, rw, rh, NULL);
+ rt_overlay_draw(rt, rx, ry, rw, rh, nullptr);
}
}
cairo_destroy(cr);
static ImageTile *rt_tile_new(gint x, gint y, gint width, gint height)
{
- ImageTile *it;
-
- it = g_new0(ImageTile, 1);
+ auto it = g_new0(ImageTile, 1);
it->x = x;
it->y = y;
static void rt_tile_free_all(RendererTiles *rt)
{
- GList *work;
-
- work = rt->tiles;
- while (work)
- {
- ImageTile *it;
-
- it = static_cast<ImageTile *>(work->data);
- work = work->next;
-
- rt_tile_free(it);
- }
-
- g_list_free(rt->tiles);
- rt->tiles = NULL;
+ g_list_free_full(rt->tiles, reinterpret_cast<GDestroyNotify>(rt_tile_free));
+ rt->tiles = nullptr;
rt->tile_cache_size = 0;
}
{
QueueData *qd = it->qd;
- it->qd = NULL;
+ it->qd = nullptr;
rt->draw_queue = g_list_remove(rt->draw_queue, qd);
g_free(qd);
}
{
QueueData *qd = it->qd2;
- it->qd2 = NULL;
+ it->qd2 = nullptr;
rt->draw_queue_2pass = g_list_remove(rt->draw_queue_2pass, qd);
g_free(qd);
}
work = work->next;
}
- if (only_existing) return NULL;
+ if (only_existing) return nullptr;
return rt_tile_add(rt, x, y);
}
-static gint pixmap_calc_size(cairo_surface_t *UNUSED(surface))
+static gint pixmap_calc_size(cairo_surface_t *)
{
-// gint w, h, d;
-
-// d = gdk_drawable_get_depth(pixmap);
-// gdk_drawable_get_size(pixmap, &w, &h);
return options->image.tile_size * options->image.tile_size * 4 / 8;
}
double y)
{
cairo_surface_t *surface;
- surface = gdk_cairo_surface_create_from_pixbuf(pixbuf, rt->hidpi_scale, NULL);
+ surface = gdk_cairo_surface_create_from_pixbuf(pixbuf, rt->hidpi_scale, nullptr);
cairo_set_source_surface(cr, surface, x, y);
cairo_fill(cr);
cairo_surface_destroy(surface);
cairo_surface_t *surface;
guint size;
- surface = gdk_window_create_similar_surface(gtk_widget_get_window((GtkWidget *)pr),
+ surface = gdk_window_create_similar_surface(gtk_widget_get_window(reinterpret_cast<GtkWidget *>(pr)),
CAIRO_CONTENT_COLOR,
rt->tile_width, rt->tile_height);
{
if (!rt->overlay_buffer)
{
- rt->overlay_buffer = gdk_window_create_similar_surface(gtk_widget_get_window((GtkWidget *)pr),
+ rt->overlay_buffer = gdk_window_create_similar_surface(gtk_widget_get_window(reinterpret_cast<GtkWidget *>(pr)),
CAIRO_CONTENT_COLOR,
rt->tile_width, rt->tile_height);
}
work = rt->overlay_list;
while (work)
{
- OverlayData *od = static_cast<OverlayData *>(work->data);
+ auto od = static_cast<OverlayData *>(work->data);
work = work->next;
rt_overlay_queue_draw(rt, od, x1, y1, x2, y2);
work = rt->overlay_list;
while (work)
{
- OverlayData *od = static_cast<OverlayData *>(work->data);
+ auto od = static_cast<OverlayData *>(work->data);
work = work->next;
if (!od->window) rt_overlay_init_window(rt, od);
work = rt->overlay_list;
while (work)
{
- OverlayData *od = static_cast<OverlayData *>(work->data);
+ auto od = static_cast<OverlayData *>(work->data);
work = work->next;
if (od->id == id) return od;
}
- return NULL;
+ return nullptr;
}
gint renderer_tiles_overlay_add(void *renderer, GdkPixbuf *pixbuf, gint x, gint y,
OverlayRendererFlags flags)
{
- RendererTiles *rt = (RendererTiles *) renderer;
+ auto rt = static_cast<RendererTiles *>(renderer);
PixbufRenderer *pr = rt->pr;
- OverlayData *od;
gint id;
g_return_val_if_fail(IS_PIXBUF_RENDERER(pr), -1);
- g_return_val_if_fail(pixbuf != NULL, -1);
+ g_return_val_if_fail(pixbuf != nullptr, -1);
id = 1;
while (rt_overlay_find(rt, id)) id++;
- od = g_new0(OverlayData, 1);
+ auto od = g_new0(OverlayData, 1);
od->id = id;
od->pixbuf = pixbuf;
g_object_ref(G_OBJECT(od->pixbuf));
if (!rt->overlay_list && rt->overlay_buffer)
{
cairo_surface_destroy(rt->overlay_buffer);
- rt->overlay_buffer = NULL;
+ rt->overlay_buffer = nullptr;
}
}
{
while (rt->overlay_list)
{
- OverlayData *od;
-
- od = static_cast<OverlayData *>(rt->overlay_list->data);
+ auto od = static_cast<OverlayData *>(rt->overlay_list->data);
rt_overlay_free(rt, od);
}
}
GList *work;
if (rt->overlay_buffer) cairo_surface_destroy(rt->overlay_buffer);
- rt->overlay_buffer = NULL;
+ rt->overlay_buffer = nullptr;
work = rt->overlay_list;
while (work)
{
- OverlayData *od = static_cast<OverlayData *>(work->data);
+ auto od = static_cast<OverlayData *>(work->data);
work = work->next;
if (od->window) gdk_window_destroy(od->window);
- od->window = NULL;
+ od->window = nullptr;
}
}
-void renderer_tiles_overlay_set(void *renderer, gint id, GdkPixbuf *pixbuf, gint UNUSED(x), gint UNUSED(y))
+void renderer_tiles_overlay_set(void *renderer, gint id, GdkPixbuf *pixbuf, gint, gint)
{
- RendererTiles *rc = (RendererTiles *)renderer;
+ auto rc = static_cast<RendererTiles *>(renderer);
PixbufRenderer *pr = rc->pr;
OverlayData *od;
gboolean renderer_tiles_overlay_get(void *renderer, gint id, GdkPixbuf **pixbuf, gint *x, gint *y)
{
- RendererTiles *rt = (RendererTiles *) renderer;
+ auto rt = static_cast<RendererTiles *>(renderer);
PixbufRenderer *pr = rt->pr;
OverlayData *od;
return TRUE;
}
-static void rt_hierarchy_changed_cb(GtkWidget *UNUSED(widget), GtkWidget *UNUSED(previous_toplevel), gpointer data)
+static void rt_hierarchy_changed_cb(GtkWidget *, GtkWidget *, gpointer data)
{
- RendererTiles *rt = static_cast<RendererTiles *>(data);
+ auto rt = static_cast<RendererTiles *>(data);
rt_overlay_list_reset_window(rt);
}
static gboolean rt_source_tile_render(RendererTiles *rt, ImageTile *it,
gint x, gint y, gint w, gint h,
- gboolean UNUSED(new_data), gboolean fast)
+ gboolean, gboolean fast)
{
PixbufRenderer *pr = rt->pr;
GList *list;
gint sx, sy, sw, sh;
if (pr->image_width == 0 || pr->image_height == 0) return FALSE;
- scale_x = (gdouble)pr->width / pr->image_width;
- scale_y = (gdouble)pr->height / pr->image_height;
+ scale_x = static_cast<gdouble>(pr->width) / pr->image_width;
+ scale_y = static_cast<gdouble>(pr->height) / pr->image_height;
- sx = (gdouble)(it->x + x) / scale_x;
- sy = (gdouble)(it->y + y) / scale_y;
- sw = (gdouble)w / scale_x;
- sh = (gdouble)h / scale_y;
+ sx = static_cast<gdouble>(it->x + x) / scale_x;
+ sy = static_cast<gdouble>(it->y + y) / scale_y;
+ sw = static_cast<gdouble>(w) / scale_x;
+ sh = static_cast<gdouble>(h) / scale_y;
if (pr->width < PR_MIN_SCALE_SIZE || pr->height < PR_MIN_SCALE_SIZE) fast = TRUE;
st = static_cast<SourceTile *>(work->data);
work = work->next;
- stx = floor((gdouble)st->x * scale_x);
- sty = floor((gdouble)st->y * scale_y);
- stw = ceil((gdouble)(st->x + pr->source_tile_width) * scale_x) - stx;
- sth = ceil((gdouble)(st->y + pr->source_tile_height) * scale_y) - sty;
+ stx = floor(static_cast<gdouble>(st->x) * scale_x);
+ sty = floor(static_cast<gdouble>(st->y) * scale_y);
+ stw = ceil(static_cast<gdouble>(st->x + pr->source_tile_width) * scale_x) - stx;
+ sth = ceil(static_cast<gdouble>(st->y + pr->source_tile_height) * scale_y) - sty;
if (pr_clip_region(stx, sty, stw, sth,
it->x + x, it->y + y, w, h,
gdouble offset_y;
/* may need to use unfloored stx,sty values here */
- offset_x = (gdouble)(stx - it->x);
- offset_y = (gdouble)(sty - it->y);
+ offset_x = static_cast<gdouble>(stx - it->x);
+ offset_y = static_cast<gdouble>(sty - it->y);
gdk_pixbuf_scale(st->pixbuf, it->pixbuf, rx - it->x, ry - it->y, rw, rh,
- (gdouble) 0.0 + offset_x,
- (gdouble) 0.0 + offset_y,
+ static_cast<gdouble>(0.0) + offset_x,
+ static_cast<gdouble>(0.0) + offset_y,
scale_x, scale_y,
(fast) ? GDK_INTERP_NEAREST : pr->zoom_quality);
draw = TRUE;
}
/**
- * @brief
- * @param has_alpha
- * @param ignore_alpha
- * @param src
- * @param dest
- * @param pb_x
- * @param pb_y
- * @param pb_w
- * @param pb_h
- * @param offset_x
- * @param offset_y
- * @param scale_x
- * @param scale_y
- * @param interp_type
- * @param check_x
- * @param check_y
+ * @brief
+ * @param has_alpha
+ * @param ignore_alpha
+ * @param src
+ * @param dest
+ * @param pb_x
+ * @param pb_y
+ * @param pb_w
+ * @param pb_h
+ * @param offset_x
+ * @param offset_y
+ * @param scale_x
+ * @param scale_y
+ * @param interp_type
+ * @param check_x
+ * @param check_y
* @param wide_image Used as a work-around for a GdkPixbuf problem. Set when image width is > 32767. Problem exhibited with gdk_pixbuf_copy_area() and GDK_INTERP_NEAREST. See #772 on GitHub Geeqie
- *
- *
+ *
+ *
*/
static void rt_tile_get_region(gboolean has_alpha, gboolean ignore_alpha,
const GdkPixbuf *src, GdkPixbuf *dest,
gint c;
guchar *psrc;
guchar *pdst;
+ guint32 red_1;
+ guint32 green_1;
+ guint32 blue_1;
+ guint32 red_2;
+ guint32 green_2;
+ guint32 blue_2;
+ guint32 alpha_1;
+ guint32 alpha_2;
if (!has_alpha)
{
{
for (c = 0; c < 3; c++)
{
- pdst[(y * drs) + x*3 + c] = psrc[(-(int)offset_y + pb_y + y) * srs + (-(int)offset_x + pb_x+x)*3 + c];
+ pdst[(y * drs) + x*3 + c] = psrc[(-static_cast<int>(offset_y) + pb_y + y) * srs + (-static_cast<int>(offset_x) + pb_x+x)*3 + c];
}
}
}
}
else
{
+ red_1=static_cast<guint32>(options->image.alpha_color_1.red * 255) << 16 & 0x00FF0000;
+ green_1=static_cast<guint32>(options->image.alpha_color_1.green * 255) << 8 & 0x0000FF00;
+ blue_1=static_cast<guint32>(options->image.alpha_color_1.blue * 255) & 0x000000FF;
+ red_2=static_cast<guint32>(options->image.alpha_color_2.red * 255) << 16 & 0x00FF0000;
+ green_2=static_cast<guint32>(options->image.alpha_color_2.green * 255) << 8 & 0x0000FF00;
+ blue_2=static_cast<guint32>(options->image.alpha_color_2.blue * 255) & 0x000000FF;
+ alpha_1 = red_1 + green_1 + blue_1;
+ alpha_2 = red_2 + green_2 + blue_2;
+
if (ignore_alpha)
{
tmppixbuf = gdk_pixbuf_add_alpha(src, FALSE, 0, 0, 0);
(scale_x == 1.0 && scale_y == 1.0) ? GDK_INTERP_NEAREST : interp_type,
255, check_x, check_y,
PR_ALPHA_CHECK_SIZE,
- ((options->image.alpha_color_1.red << 8 & 0x00FF0000) +
- (options->image.alpha_color_1.green & 0x00FF00) +
- (options->image.alpha_color_1.blue >> 8 & 0x00FF)),
- ((options->image.alpha_color_2.red << 8 & 0x00FF0000) +
- (options->image.alpha_color_2.green & 0x00FF00) +
- (options->image.alpha_color_2.blue >> 8 & 0x00FF)));
+ alpha_1,
+ alpha_2);
g_object_unref(tmppixbuf);
}
else
(scale_x == 1.0 && scale_y == 1.0) ? GDK_INTERP_NEAREST : interp_type,
255, check_x, check_y,
PR_ALPHA_CHECK_SIZE,
- ((options->image.alpha_color_1.red << 8 & 0x00FF0000) +
- (options->image.alpha_color_1.green & 0x00FF00) +
- (options->image.alpha_color_1.blue >> 8 & 0x00FF)),
- ((options->image.alpha_color_2.red << 8 & 0x00FF0000) +
- (options->image.alpha_color_2.green & 0x00FF00) +
- (options->image.alpha_color_2.blue >> 8 & 0x00FF)));
+ alpha_1,
+ alpha_2);
}
}
}
if (pr->image_width == 0 || pr->image_height == 0) return;
- scale_x = rt->hidpi_scale * (gdouble)pr->width / pr->image_width;
- scale_y = rt->hidpi_scale * (gdouble)pr->height / pr->image_height;
+ scale_x = rt->hidpi_scale * static_cast<gdouble>(pr->width) / pr->image_width;
+ scale_y = rt->hidpi_scale * static_cast<gdouble>(pr->height) / pr->image_height;
pr_tile_coords_map_orientation(orientation, it->x, it->y,
pr->width, pr->height,
rt_tile_get_region(has_alpha, pr->ignore_alpha,
pr->pixbuf, it->pixbuf, pb_x, pb_y, pb_w, pb_h,
- (gdouble) 0.0 - src_x - GET_RIGHT_PIXBUF_OFFSET(rt) * scale_x,
- (gdouble) 0.0 - src_y,
+ static_cast<gdouble>(0.0) - src_x - GET_RIGHT_PIXBUF_OFFSET(rt) * scale_x,
+ static_cast<gdouble>(0.0) - src_y,
scale_x, scale_y,
(fast) ? GDK_INTERP_NEAREST : pr->zoom_quality,
it->x + pb_x, it->y + pb_y, wide_image);
GdkPixbuf *right_pb = rt_get_spare_tile(rt);
rt_tile_get_region(has_alpha, pr->ignore_alpha,
pr->pixbuf, right_pb, pb_x, pb_y, pb_w, pb_h,
- (gdouble) 0.0 - src_x - GET_LEFT_PIXBUF_OFFSET(rt) * scale_x,
- (gdouble) 0.0 - src_y,
+ static_cast<gdouble>(0.0) - src_x - GET_LEFT_PIXBUF_OFFSET(rt) * scale_x,
+ static_cast<gdouble>(0.0) - src_y,
scale_x, scale_y,
(fast) ? GDK_INTERP_NEAREST : pr->zoom_quality,
it->x + pb_x, it->y + pb_y, wide_image);
gboolean new_data, gboolean fast)
{
PixbufRenderer *pr = rt->pr;
- //~ GtkWidget *box;
- //~ GdkWindow *window;
cairo_t *cr;
/* clamp to visible */
rt_tile_render(rt, it, x, y, w, h, new_data, fast);
- //~ box = GTK_WIDGET(pr);
- //~ window = gtk_widget_get_window(box);
-
cr = cairo_create(rt->surface);
cairo_set_source_surface(cr, it->surface, pr->x_offset + (it->x - rt->x_scroll) + rt->stereo_off_x, pr->y_offset + (it->y - rt->y_scroll) + rt->stereo_off_y);
cairo_rectangle (cr, pr->x_offset + (it->x - rt->x_scroll) + x + rt->stereo_off_x, pr->y_offset + (it->y - rt->y_scroll) + y + rt->stereo_off_y, w, h);
while (work)
{
- QueueData *qd = static_cast<QueueData *>(work->data);
+ auto qd = static_cast<QueueData *>(work->data);
area += qd->w * qd->h;
work = work->next;
}
{
/* 2pass prio */
DEBUG_2("redraw priority: 2pass");
- rt->draw_idle_id = g_idle_add_full(G_PRIORITY_DEFAULT_IDLE, rt_queue_draw_idle_cb, rt, NULL);
- return FALSE;
+ rt->draw_idle_id = g_idle_add_full(G_PRIORITY_DEFAULT_IDLE, rt_queue_draw_idle_cb, rt, nullptr);
+ return G_SOURCE_REMOVE;
}
if (visible_area == 0)
{
/* we have enough data for starting intensive redrawing */
DEBUG_2("redraw priority: high %.2f %%", percent);
- rt->draw_idle_id = g_idle_add_full(GDK_PRIORITY_REDRAW, rt_queue_draw_idle_cb, rt, NULL);
- return FALSE;
+ rt->draw_idle_id = g_idle_add_full(GDK_PRIORITY_REDRAW, rt_queue_draw_idle_cb, rt, nullptr);
+ return G_SOURCE_REMOVE;
}
if (percent < 1.0 || force_set)
{
/* queue is (almost) empty, wait 50 ms*/
DEBUG_2("redraw priority: wait %.2f %%", percent);
- rt->draw_idle_id = g_timeout_add_full(G_PRIORITY_DEFAULT_IDLE, 50, rt_queue_draw_idle_cb, rt, NULL);
- return FALSE;
+ rt->draw_idle_id = g_timeout_add_full(G_PRIORITY_DEFAULT_IDLE, 50, rt_queue_draw_idle_cb, rt, nullptr);
+ return G_SOURCE_REMOVE;
}
/* keep the same priority as before */
DEBUG_2("redraw priority: no change %.2f %%", percent);
- return TRUE;
+ return G_SOURCE_CONTINUE;
}
static gboolean rt_queue_draw_idle_cb(gpointer data)
{
- RendererTiles *rt = static_cast<RendererTiles *>(data);
+ auto rt = static_cast<RendererTiles *>(data);
PixbufRenderer *pr = rt->pr;
QueueData *qd;
gboolean fast;
pr_render_complete_signal(pr);
rt->draw_idle_id = 0;
- return FALSE;
+ return G_SOURCE_REMOVE;
}
if (rt->draw_queue)
if (rt->draw_queue)
{
- qd->it->qd = NULL;
+ qd->it->qd = nullptr;
rt->draw_queue = g_list_remove(rt->draw_queue, qd);
if (fast)
{
}
else
{
- qd->it->qd2 = NULL;
+ qd->it->qd2 = nullptr;
rt->draw_queue_2pass = g_list_remove(rt->draw_queue_2pass, qd);
g_free(qd);
}
pr_render_complete_signal(pr);
rt->draw_idle_id = 0;
- return FALSE;
+ return G_SOURCE_REMOVE;
}
return rt_queue_schedule_next_draw(rt, FALSE);
qd = static_cast<QueueData *>(work->data);
work = work->next;
- qd->it->qd = NULL;
- qd->it->qd2 = NULL;
+ qd->it->qd = nullptr;
+ qd->it->qd2 = nullptr;
g_free(qd);
}
static void rt_queue_clear(RendererTiles *rt)
{
rt_queue_list_free(rt->draw_queue);
- rt->draw_queue = NULL;
+ rt->draw_queue = nullptr;
rt_queue_list_free(rt->draw_queue_2pass);
- rt->draw_queue_2pass = NULL;
+ rt->draw_queue_2pass = nullptr;
if (rt->draw_idle_id)
{
j > rt->y_scroll + pr->vis_height)));
if (it)
{
- QueueData *qd;
-
if ((render == TILE_RENDER_ALL && it->render_done != TILE_RENDER_ALL) ||
(render == TILE_RENDER_AREA && it->render_todo != TILE_RENDER_ALL))
{
it->render_todo = render;
}
- qd = g_new(QueueData, 1);
+ auto qd = g_new(QueueData, 1);
qd->it = it;
qd->new_data = new_data;
static void rt_scroll(void *renderer, gint x_off, gint y_off)
{
- RendererTiles *rt = (RendererTiles *) renderer;
+ auto rt = static_cast<RendererTiles *>(renderer);
PixbufRenderer *pr = rt->pr;
rt_sync_scroll(rt);
static void renderer_area_changed(void *renderer, gint src_x, gint src_y, gint src_w, gint src_h)
{
- RendererTiles *rt = (RendererTiles *)renderer;
+ auto rt = static_cast<RendererTiles *>(renderer);
PixbufRenderer *pr = rt->pr;
gint x, y, width, height, x1, y1, x2, y2;
height += 2;
}
- x1 = (gint)floor((gdouble)x * pr->scale);
- y1 = (gint)floor((gdouble)y * pr->scale * pr->aspect_ratio);
- x2 = (gint)ceil((gdouble)(x + width) * pr->scale);
- y2 = (gint)ceil((gdouble)(y + height) * pr->scale * pr->aspect_ratio);
+ x1 = static_cast<gint>(floor(static_cast<gdouble>(x) * pr->scale));
+ y1 = static_cast<gint>(floor(static_cast<gdouble>(y) * pr->scale * pr->aspect_ratio));
+ x2 = static_cast<gint>(ceil(static_cast<gdouble>(x + width) * pr->scale));
+ y2 = static_cast<gint>(ceil(static_cast<gdouble>(y + height) * pr->scale * pr->aspect_ratio));
rt_queue(rt, x1, y1, x2 - x1, y2 - y1, FALSE, TILE_RENDER_AREA, TRUE, TRUE);
}
clamp, render, new_data, only_existing);
}
-static void renderer_update_pixbuf(void *renderer, gboolean UNUSED(lazy))
+static void renderer_update_pixbuf(void *renderer, gboolean)
{
- rt_queue_clear((RendererTiles *)renderer);
+ rt_queue_clear(static_cast<RendererTiles *>(renderer));
}
static void renderer_update_zoom(void *renderer, gboolean lazy)
{
- RendererTiles *rt = (RendererTiles *)renderer;
+ auto rt = static_cast<RendererTiles *>(renderer);
PixbufRenderer *pr = rt->pr;
- rt_tile_invalidate_all((RendererTiles *)renderer);
+ rt_tile_invalidate_all(static_cast<RendererTiles *>(renderer));
if (!lazy)
{
- renderer_redraw(renderer, 0, 0, pr->width, pr->height, TRUE, TILE_RENDER_ALL, TRUE, FALSE);
+ renderer_redraw(static_cast<RendererTiles *>(renderer), 0, 0, pr->width, pr->height, TRUE, TILE_RENDER_ALL, TRUE, FALSE);
}
rt_border_clear(rt);
}
static void renderer_invalidate_region(void *renderer, gint x, gint y, gint w, gint h)
{
- rt_tile_invalidate_region((RendererTiles *)renderer, x, y, w, h);
+ rt_tile_invalidate_region(static_cast<RendererTiles *>(renderer), x, y, w, h);
}
static void renderer_update_viewport(void *renderer)
{
- RendererTiles *rt = (RendererTiles *)renderer;
+ auto rt = static_cast<RendererTiles *>(renderer);
rt->stereo_off_x = 0;
rt->stereo_off_y = 0;
static void renderer_stereo_set(void *renderer, gint stereo_mode)
{
- RendererTiles *rt = (RendererTiles *)renderer;
+ auto rt = static_cast<RendererTiles *>(renderer);
rt->stereo_mode = stereo_mode;
}
static void renderer_free(void *renderer)
{
- RendererTiles *rt = (RendererTiles *)renderer;
+ auto rt = static_cast<RendererTiles *>(renderer);
rt_queue_clear(rt);
rt_tile_free_all(rt);
if (rt->spare_tile) g_object_unref(rt->spare_tile);
rt_overlay_list_clear(rt);
/* disconnect "hierarchy-changed" */
g_signal_handlers_disconnect_matched(G_OBJECT(rt->pr), G_SIGNAL_MATCH_DATA,
- 0, 0, 0, NULL, rt);
+ 0, 0, nullptr, nullptr, rt);
g_free(rt);
}
static gboolean rt_realize_cb(GtkWidget *widget, gpointer data)
{
- RendererTiles *rt = (RendererTiles *)data;
+ auto rt = static_cast<RendererTiles *>(data);
cairo_t *cr;
if (!rt->surface)
rt->surface = gdk_window_create_similar_surface(gtk_widget_get_window(widget), CAIRO_CONTENT_COLOR, gtk_widget_get_allocated_width(widget), gtk_widget_get_allocated_height(widget));
cr = cairo_create(rt->surface);
- cairo_set_source_rgb(cr, (gdouble)rt->pr->color.red / 65535, (gdouble)rt->pr->color.green / 65535, (gdouble)rt->pr->color.blue / 65535);
+ cairo_set_source_rgb(cr, static_cast<gdouble>(rt->pr->color.red), static_cast<gdouble>(rt->pr->color.green), static_cast<gdouble>(rt->pr->color.blue));
cairo_paint(cr);
cairo_destroy(cr);
}
static gboolean rt_size_allocate_cb(GtkWidget *widget, GdkRectangle *allocation, gpointer data)
{
- RendererTiles *rt = static_cast<RendererTiles *>(data);
+ auto rt = static_cast<RendererTiles *>(data);
cairo_t *cr;
cairo_surface_t *old_surface;
cr = cairo_create(rt->surface);
- cairo_set_source_rgb(cr, (gdouble)options->image.border_color.red / 65535, (gdouble)options->image.border_color.green / 65535, (gdouble)options->image.border_color.blue / 65535);
+ cairo_set_source_rgb(cr, static_cast<gdouble>(options->image.border_color.red), static_cast<gdouble>(options->image.border_color.green), static_cast<gdouble>(options->image.border_color.blue));
cairo_paint(cr);
cairo_set_source_surface(cr, old_surface, 0, 0);
cairo_paint(cr);
return FALSE;
}
-static gboolean rt_draw_cb(GtkWidget *UNUSED(widget), cairo_t *cr, gpointer data)
+static gboolean rt_draw_cb(GtkWidget *, cairo_t *cr, gpointer data)
{
- RendererTiles *rt = (RendererTiles *)data;
+ auto rt = static_cast<RendererTiles *>(data);
GList *work;
OverlayData *od;
if (rt->stereo_mode & (PR_STEREO_HORIZ | PR_STEREO_VERT))
{
cairo_push_group(cr);
- cairo_set_source_rgb(cr, (double)rt->pr->color.red / 65535, (double)rt->pr->color.green / 65535, (double)rt->pr->color.blue / 65535);
+ cairo_set_source_rgb(cr, static_cast<double>(rt->pr->color.red), static_cast<double>(rt->pr->color.green), static_cast<double>(rt->pr->color.blue));
if (rt->stereo_mode & PR_STEREO_HORIZ)
{
RendererFuncs *renderer_tiles_new(PixbufRenderer *pr)
{
- RendererTiles *rt = g_new0(RendererTiles, 1);
+ auto rt = g_new0(RendererTiles, 1);
rt->pr = pr;
rt->tile_width = options->image.tile_size;
rt->tile_height = options->image.tile_size;
- rt->tiles = NULL;
+ rt->tiles = nullptr;
rt->tile_cache_size = 0;
rt->tile_cache_max = PR_CACHE_SIZE_DEFAULT;
g_signal_connect(G_OBJECT(pr), "realize", G_CALLBACK(rt_realize_cb), rt);
g_signal_connect(G_OBJECT(pr), "size-allocate", G_CALLBACK(rt_size_allocate_cb), rt);
- return (RendererFuncs *) rt;
+ return reinterpret_cast<RendererFuncs *>(rt);
}
projects / geeqie.git / blobdiff