#include "main.h"
#include "pixbuf-renderer.h"
#include "renderer-tiles.h"
+#include "renderer-clutter.h"
#include "intl.h"
#include "layout.h"
#include <gtk/gtk.h>
-
/* comment this out if not using this from within Geeqie
* defining GQ_BUILD does these things:
* - Sets the shift-click scroller pixbuf to a nice icon instead of a black box
const GValue *value, GParamSpec *pspec);
static void pixbuf_renderer_get_property(GObject *object, guint prop_id,
GValue *value, GParamSpec *pspec);
-#if GTK_CHECK_VERSION(3,0,0)
-static gboolean pixbuf_renderer_draw(GtkWidget *widget, cairo_t *cr);
-#else
-static gboolean pixbuf_renderer_expose(GtkWidget *widget, GdkEventExpose *event);
-#endif
-
static void pr_scroller_timer_set(PixbufRenderer *pr, gboolean start);
static void pr_signals_connect(PixbufRenderer *pr);
static void pr_size_cb(GtkWidget *widget, GtkAllocation *allocation, gpointer data);
-static void pixbuf_renderer_paint(PixbufRenderer *pr, GdkRectangle *area);
static void pr_stereo_temp_disable(PixbufRenderer *pr, gboolean disable);
static void pixbuf_renderer_class_init(PixbufRendererClass *class)
{
GObjectClass *gobject_class = G_OBJECT_CLASS(class);
- GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(class);
parent_class = g_type_class_peek_parent(class);
gobject_class->finalize = pixbuf_renderer_finalize;
-#if GTK_CHECK_VERSION(3,0,0)
- widget_class->draw = pixbuf_renderer_draw;
-#else
- widget_class->expose_event = pixbuf_renderer_expose;
-#endif
-
g_object_class_install_property(gobject_class,
PROP_ZOOM_MIN,
g_param_spec_double("zoom_min",
G_TYPE_NONE, 0);
}
+static RendererFuncs *pr_backend_renderer_new(PixbufRenderer *pr)
+{
+ if (options->image.use_clutter_renderer)
+ {
+#ifdef HAVE_CLUTTER
+ return renderer_clutter_new(pr);
+#else
+ DEBUG_0("Geeqie is built without clutter renderer support");
+#endif
+ }
+ return renderer_tiles_new(pr);
+}
+
+
static void pixbuf_renderer_init(PixbufRenderer *pr)
{
GtkWidget *box;
pr->stereo_mode = PR_STEREO_NONE;
- pr->renderer = (void *)renderer_tiles_new(pr);
+ pr->renderer = pr_backend_renderer_new(pr);
pr->renderer2 = NULL;
gtk_widget_set_double_buffered(box, FALSE);
+ gtk_widget_set_app_paintable(box, TRUE);
g_signal_connect_after(G_OBJECT(box), "size_allocate",
G_CALLBACK(pr_size_cb), pr);
}
}
-#if GTK_CHECK_VERSION(3,0,0)
-
-static gboolean pixbuf_renderer_draw(GtkWidget *widget, cairo_t *cr)
-{
- if (gtk_widget_is_drawable(widget))
- {
- if (gtk_widget_get_has_window(widget))
- {
- GdkRectangle area;
- if (gdk_cairo_get_clip_rectangle(cr, &area))
- {
- pixbuf_renderer_paint(PIXBUF_RENDERER(widget), &area);
- }
- }
- }
-
- return FALSE;
-}
-
-#else
-static gboolean pixbuf_renderer_expose(GtkWidget *widget, GdkEventExpose *event)
-{
-#if GTK_CHECK_VERSION(2,20,0)
- if (gtk_widget_is_drawable(widget))
-#else
- if (GTK_WIDGET_DRAWABLE(widget))
-#endif
- {
-#if GTK_CHECK_VERSION(2,20,0)
- if (gtk_widget_get_has_window(widget))
-#else
- if (!GTK_WIDGET_NO_WINDOW(widget))
-#endif
- {
- if (event->window != gtk_widget_get_window(widget))
- {
- GdkRectangle area;
-
- gdk_window_get_position(event->window, &area.x, &area.y);
- area.x += event->area.x;
- area.y += event->area.y;
- area.width = event->area.width;
- area.height = event->area.height;
- pixbuf_renderer_paint(PIXBUF_RENDERER(widget), &area);
- }
- else
- {
- pixbuf_renderer_paint(PIXBUF_RENDERER(widget), &event->area);
- }
- }
- }
-
- return FALSE;
-}
-#endif
/*
*-------------------------------------------------------------------
*-------------------------------------------------------------------
*/
-static void pr_border_clear(PixbufRenderer *pr)
-{
- pr->renderer->border_clear(pr->renderer);
- if (pr->renderer2) pr->renderer2->border_clear(pr->renderer2);
-}
-
void pixbuf_renderer_set_color(PixbufRenderer *pr, GdkColor *color)
{
GtkStyle *style;
gtk_widget_set_style(widget, style);
-#if GTK_CHECK_VERSION(2,20,0)
- if (gtk_widget_get_visible(widget)) pr_border_clear(pr);
-#else
- if (GTK_WIDGET_VISIBLE(widget)) pr_border_clear(pr);
-#endif
-}
-
-static void pr_redraw(PixbufRenderer *pr, gboolean new_data)
-{
- pr->renderer->queue_clear(pr->renderer);
- pr->renderer->redraw(pr->renderer, 0, 0, pr->width, pr->height, TRUE, TILE_RENDER_ALL, new_data, FALSE);
- if (pr->renderer2) {
- pr->renderer2->queue_clear(pr->renderer2);
- pr->renderer2->redraw(pr->renderer2, 0, 0, pr->width, pr->height, TRUE, TILE_RENDER_ALL, new_data, FALSE);
- }
+ pr->renderer->update_viewport(pr->renderer);
+ if (pr->renderer2) pr->renderer2->update_viewport(pr->renderer2);
}
/*
pr->func_tile_dispose = func_dispose;
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_redraw(pr, TRUE);
}
void pixbuf_renderer_set_tiles_size(PixbufRenderer *pr, gint width, gint height)
static void pr_update_signal(PixbufRenderer *pr)
{
-#if 0
- log_printf("FIXME: send updated signal\n");
-#endif
DEBUG_1("%s pixbuf renderer updated - started drawing %p, img: %dx%d", get_exec_time(), pr, pr->image_width, pr->image_height);
pr->debug_updated = TRUE;
}
gint src_x, src_y;
if (!pr->width || !pr->height) return;
- /*
+ /*
* Update norm_center only if the image is bigger than the window.
* With this condition the stored center survives also a temporary display
* of the "broken image" icon.
}
static gboolean pr_zoom_clamp(PixbufRenderer *pr, gdouble zoom,
- PrZoomFlags flags, gboolean *redrawn)
+ PrZoomFlags flags)
{
gint w, h;
gdouble scale;
- gboolean invalid;
gboolean force = !!(flags & PR_ZOOM_FORCE);
gboolean new = !!(flags & PR_ZOOM_NEW);
- gboolean invalidate = !!(flags & PR_ZOOM_INVALIDATE);
- gboolean lazy = !!(flags & PR_ZOOM_LAZY);
zoom = CLAMP(zoom, pr->zoom_min, pr->zoom_max);
h = h * scale * pr->aspect_ratio;
}
- invalid = (pr->width != w || pr->height != h);
-
pr->zoom = zoom;
pr->width = w;
pr->height = h;
pr->scale = scale;
- if (invalidate || invalid)
- {
- pr->renderer->invalidate_all(pr->renderer);
- if (pr->renderer2) pr->renderer2->invalidate_all(pr->renderer2);
- if (!lazy) pr_redraw(pr, TRUE);
- }
- if (redrawn) *redrawn = (invalidate || invalid);
-
- pixbuf_renderer_sync_scroll_center(pr);
-
return TRUE;
}
{
gdouble old_scale;
gint old_cx, old_cy;
- gboolean clamped;
- gboolean sized;
- gboolean redrawn = FALSE;
gboolean center_point = !!(flags & PR_ZOOM_CENTER);
gboolean force = !!(flags & PR_ZOOM_FORCE);
gboolean new = !!(flags & PR_ZOOM_NEW);
PrZoomFlags clamp_flags = flags;
gdouble old_center_x = pr->norm_center_x;
gdouble old_center_y = pr->norm_center_y;
-
+
old_scale = pr->scale;
if (center_point)
{
}
if (force) clamp_flags |= PR_ZOOM_INVALIDATE;
- if (lazy) clamp_flags |= PR_ZOOM_LAZY;
- if (!pr_zoom_clamp(pr, zoom, clamp_flags, &redrawn)) return;
+ if (!pr_zoom_clamp(pr, zoom, clamp_flags)) return;
- clamped = pr_size_clamp(pr);
- sized = pr_parent_window_resize(pr, pr->width, pr->height);
+ (void) pr_size_clamp(pr);
+ (void) pr_parent_window_resize(pr, pr->width, pr->height);
if (force && new)
{
pr_scroll_clamp(pr);
- /* If the window was not sized, redraw the image - we know there will be no size/expose signal.
- * But even if a size is claimed, there is no guarantee that the window manager will allow it,
- * so redraw the window anyway :/
- */
- if (sized || clamped) pr_border_clear(pr);
-
- if (lazy)
- {
- pr->renderer->queue_clear(pr->renderer);
- if (pr->renderer2) pr->renderer2->queue_clear(pr->renderer2);
- }
- else
- {
- pr_redraw(pr, redrawn);
- }
+ pr->renderer->update_zoom(pr->renderer, lazy);
+ if (pr->renderer2) pr->renderer2->update_zoom(pr->renderer2, lazy);
pr_scroll_notify_signal(pr);
pr_zoom_signal(pr);
if (pr->zoom == 0.0)
{
gdouble old_scale = pr->scale;
- pr_zoom_clamp(pr, 0.0, PR_ZOOM_FORCE, NULL);
+ pr_zoom_clamp(pr, 0.0, PR_ZOOM_FORCE);
zoom_changed = (old_scale != pr->scale);
}
pr_size_clamp(pr);
pr_scroll_clamp(pr);
- pr->renderer->update_sizes(pr->renderer);
- if (pr->renderer2) pr->renderer2->update_sizes(pr->renderer2);
+ if (zoom_changed)
+ {
+ pr->renderer->update_zoom(pr->renderer, FALSE);
+ if (pr->renderer2) pr->renderer2->update_zoom(pr->renderer2, FALSE);
+ }
+
+ pr->renderer->update_viewport(pr->renderer);
+ if (pr->renderer2) pr->renderer2->update_viewport(pr->renderer2);
+
/* ensure scroller remains visible */
if (pr->scroller_overlay != -1)
}
}
- pr_border_clear(pr);
-
pr_scroll_notify_signal(pr);
if (zoom_changed) pr_zoom_signal(pr);
pr_update_signal(pr);
pr_size_sync(pr, allocation->width, allocation->height);
}
-static void pixbuf_renderer_paint(PixbufRenderer *pr, GdkRectangle *area)
-{
- gint x, y;
-
- pr->renderer->redraw(pr->renderer, area->x, area->y, area->width, area->height,
- FALSE, TILE_RENDER_ALL, FALSE, FALSE);
- if (pr->renderer2)
- {
- pr->renderer2->redraw(pr->renderer2, area->x, area->y, area->width, area->height,
- FALSE, TILE_RENDER_ALL, FALSE, FALSE);
- }
-}
-
/*
*-------------------------------------------------------------------
* scrolling
}
parent = gtk_widget_get_parent(widget);
-#if GTK_CHECK_VERSION(2,20,0)
if (widget && gtk_widget_get_can_focus(parent))
-#else
- if (widget && GTK_WIDGET_CAN_FOCUS(parent))
-#endif
{
gtk_widget_grab_focus(parent);
}
return TRUE;
}
-#if GTK_CHECK_VERSION(2,20,0)
if (gdk_pointer_is_grabbed() && gtk_widget_has_grab(GTK_WIDGET(pr)))
-#else
- if (gdk_pointer_is_grabbed() && GTK_WIDGET_HAS_GRAB(pr))
-#endif
{
gtk_grab_remove(widget);
gdk_pointer_ungrab(bevent->time);
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_BUTTON_RELEASE_MASK | GDK_BUTTON_PRESS_MASK | GDK_SCROLL_MASK |
GDK_LEAVE_NOTIFY_MASK);
g_signal_connect(G_OBJECT(pr), "drag_begin",
{ 0.456, 0.500, 0.176, -0.043, -0.088, -0.002},
{-0.040, -0.038, -0.016, 0.378, 0.734, -0.018},
{-0.015, -0.021, -0.005, -0.072, -0.113, 1.226}
- };
+ };
static void pr_create_anaglyph_dubois(GdkPixbuf *pixbuf, GdkPixbuf *right, gint x, gint y, gint w, gint h)
{
for (j = 0; j < w; j++)
{
double res[3];
- for (k = 0; k < 3; k++)
+ for (k = 0; k < 3; k++)
{
const double *m = pr_dubois_matrix[k];
res[k] = sp[0] * m[0] + sp[1] * m[1] + sp[2] * m[2] + dp[0] * m[3] + dp[1] * m[4] + dp[2] * m[5];
case EXIF_ORIENTATION_LEFT_BOTTOM:
pr->image_width = gdk_pixbuf_get_height(pr->pixbuf);
pr->image_height = gdk_pixbuf_get_width(pr->pixbuf);
- if (pr->stereo_data == STEREO_PIXBUF_SBS)
+ if (pr->stereo_data == STEREO_PIXBUF_SBS)
{
pr->image_height /= 2;
pr->stereo_pixbuf_offset_right = pr->image_height;
}
- else if (pr->stereo_data == STEREO_PIXBUF_CROSS)
+ else if (pr->stereo_data == STEREO_PIXBUF_CROSS)
{
pr->image_height /= 2;
pr->stereo_pixbuf_offset_left = pr->image_height;
default:
pr->image_width = gdk_pixbuf_get_width(pr->pixbuf);
pr->image_height = gdk_pixbuf_get_height(pr->pixbuf);
- if (pr->stereo_data == STEREO_PIXBUF_SBS)
+ if (pr->stereo_data == STEREO_PIXBUF_SBS)
{
pr->image_width /= 2;
pr->stereo_pixbuf_offset_right = pr->image_width;
}
- else if (pr->stereo_data == STEREO_PIXBUF_CROSS)
+ else if (pr->stereo_data == STEREO_PIXBUF_CROSS)
{
pr->image_width /= 2;
pr->stereo_pixbuf_offset_left = pr->image_width;
if (!pr->pixbuf)
{
- GtkWidget *box;
-
/* no pixbuf so just clear the window */
pr->image_width = 0;
pr->image_height = 0;
pr->zoom = zoom; /* don't throw away the zoom value, it is set by pixbuf_renderer_move, among others,
and used for pixbuf_renderer_zoom_get */
- box = GTK_WIDGET(pr);
-
-#if GTK_CHECK_VERSION(2,20,0)
- if (gtk_widget_get_realized(box))
-#else
- if (GTK_WIDGET_REALIZED(box))
-#endif
- {
-#if !GTK_CHECK_VERSION(3,0,0)
- gdk_window_clear(gtk_widget_get_window(box));
-#endif
- pr->renderer->overlay_draw(pr->renderer, 0, 0, pr->viewport_width, pr->viewport_height);
- if (pr->renderer2) pr->renderer2->overlay_draw(pr->renderer2, 0, 0, pr->viewport_width, pr->viewport_height);
- }
+ pr->renderer->update_pixbuf(pr->renderer, flags & PR_ZOOM_LAZY);
+ if (pr->renderer2) pr->renderer2->update_pixbuf(pr->renderer2, flags & PR_ZOOM_LAZY);
pr_update_signal(pr);
return;
}
- if (pr->stereo_mode & PR_STEREO_TEMP_DISABLE)
+ if (pr->stereo_mode & PR_STEREO_TEMP_DISABLE)
{
gint disable = !pr->pixbuf || ! pr->stereo_data;
pr_stereo_temp_disable(pr, disable);
}
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);
}
void pixbuf_renderer_set_stereo_data(PixbufRenderer *pr, StereoPixbufData stereo_data)
{
g_return_if_fail(IS_PIXBUF_RENDERER(pr));
+ if (pr->stereo_data == stereo_data) return;
+
pr->stereo_data = stereo_data;
- if (pr->stereo_mode & PR_STEREO_TEMP_DISABLE)
+ if (pr->stereo_mode & PR_STEREO_TEMP_DISABLE)
{
gint disable = !pr->pixbuf || ! pr->stereo_data;
pr_stereo_temp_disable(pr, disable);
}
pr_pixbuf_size_sync(pr);
+ pr->renderer->update_pixbuf(pr->renderer, FALSE);
+ if (pr->renderer2) pr->renderer2->update_pixbuf(pr->renderer2, FALSE);
pr_zoom_sync(pr, pr->zoom, PR_ZOOM_FORCE, 0, 0);
}
source->source_tiles = NULL;
pr_zoom_sync(pr, source->zoom, PR_ZOOM_FORCE | PR_ZOOM_NEW, 0, 0);
- pr_redraw(pr, TRUE);
}
else
{
pr->scroll_reset = scroll_reset;
pixbuf_renderer_set_pixbuf(source, NULL, source->zoom);
-// pr_queue_clear(source);
-// pr_tile_free_all(source);
+}
+
+void pixbuf_renderer_copy(PixbufRenderer *pr, PixbufRenderer *source)
+{
+ GObject *object;
+ PixbufRendererScrollResetType scroll_reset;
+
+ g_return_if_fail(IS_PIXBUF_RENDERER(pr));
+ g_return_if_fail(IS_PIXBUF_RENDERER(source));
+
+ if (pr == source) return;
+
+ object = G_OBJECT(pr);
+
+ g_object_set(object, "zoom_min", source->zoom_min, NULL);
+ g_object_set(object, "zoom_max", source->zoom_max, NULL);
+ g_object_set(object, "loading", source->loading, NULL);
+
+ pr->complete = source->complete;
+
+ pr->x_scroll = source->x_scroll;
+ pr->y_scroll = source->y_scroll;
+ pr->x_mouse = source->x_mouse;
+ pr->y_mouse = source->y_mouse;
+
+ scroll_reset = pr->scroll_reset;
+ pr->scroll_reset = PR_SCROLL_RESET_NOCHANGE;
+
+ pr->orientation = source->orientation;
+ pr->stereo_data = source->stereo_data;
+
+ if (source->source_tiles_enabled)
+ {
+ pr->source_tiles_enabled = source->source_tiles_enabled;
+ pr->source_tiles_cache_size = source->source_tiles_cache_size;
+ pr->source_tile_width = source->source_tile_width;
+ pr->source_tile_height = source->source_tile_height;
+ pr->image_width = source->image_width;
+ pr->image_height = source->image_height;
+
+ pr->func_tile_request = source->func_tile_request;
+ pr->func_tile_dispose = source->func_tile_dispose;
+ pr->func_tile_data = source->func_tile_data;
+
+ pr->source_tiles = source->source_tiles;
+ source->source_tiles = NULL;
+
+ pr_zoom_sync(pr, source->zoom, PR_ZOOM_FORCE | PR_ZOOM_NEW, 0, 0);
+ }
+ else
+ {
+ pixbuf_renderer_set_pixbuf(pr, source->pixbuf, source->zoom);
+ }
+
+ pr->scroll_reset = scroll_reset;
}
void pixbuf_renderer_area_changed(PixbufRenderer *pr, gint x, gint y, gint w, gint h)
static void pr_stereo_set(PixbufRenderer *pr)
{
- if (!pr->renderer) pr->renderer = (void *)renderer_tiles_new(pr);
+ if (!pr->renderer) pr->renderer = pr_backend_renderer_new(pr);
pr->renderer->stereo_set(pr->renderer, pr->stereo_mode & ~PR_STEREO_MIRROR_RIGHT & ~PR_STEREO_FLIP_RIGHT);
if (pr->stereo_mode & (PR_STEREO_HORIZ | PR_STEREO_VERT | PR_STEREO_FIXED))
{
- if (!pr->renderer2) pr->renderer2 = (void *)renderer_tiles_new(pr);
+ if (!pr->renderer2) pr->renderer2 = pr_backend_renderer_new(pr);
pr->renderer2->stereo_set(pr->renderer2, (pr->stereo_mode & ~PR_STEREO_MIRROR_LEFT & ~PR_STEREO_FLIP_LEFT) | PR_STEREO_RIGHT);
}
else
pr_stereo_set(pr);
- if (redraw)
+ 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->stereo_temp_disable = disable;
if (disable)
{
- if (!pr->renderer) pr->renderer = (void *)renderer_tiles_new(pr);
+ 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_size_sync(pr, pr->window_width, pr->window_height); /* recalculate new viewport */
}
-gboolean pixbuf_renderer_get_pixel_colors(PixbufRenderer *pr, gint x_pixel, gint y_pixel,
+gboolean pixbuf_renderer_get_pixel_colors(PixbufRenderer *pr, gint x_pixel, gint y_pixel,
gint *r_mouse, gint *g_mouse, gint *b_mouse)
{
GdkPixbuf *pb = pr->pixbuf;
void pixbuf_renderer_set_size_early(PixbufRenderer *pr, guint width, guint height)
{
+#if 0
+ /* FIXME: this function does not consider the image orientation,
+ so it probably only breaks something */
gdouble zoom;
gint w, h;
//pr->width = width;
//pr->height = height;
+#endif
}
/* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */
projects / geeqie.git / blobdiff