![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
index 57a6ac269b4e84a089ff6cf5a70002c7e37bd6d6..a558774c451dd35933405a22f40da46d439e5cea 100644 (file)
#include <gtk/gtkmain.h>
#include <gtk/gtksignal.h>
+#include <gtk/gtkversion.h>
#include <gtkmm.h>
#include <libnr/nr-matrix-ops.h>
#include <libnr/nr-convex-hull.h>
#include "prefs-utils.h"
-#include "box3d-context.h"
#include "inkscape.h"
#include "sodipodi-ctrlrect.h"
+#if ENABLE_LCMS
+#include "color-profile-fns.h"
+#endif // ENABLE_LCMS
+#include "display/rendermode.h"
+#include "libnr/nr-blit.h"
+#include "display/inkscape-cairo.h"
+#include "debug/gdk-event-latency-tracker.h"
+
+using Inkscape::Debug::GdkEventLatencyTracker;
+
+// GTK_CHECK_VERSION returns false on failure
+#define HAS_GDK_EVENT_REQUEST_MOTIONS GTK_CHECK_VERSION(2, 12, 0)
+
+// gtk_check_version returns non-NULL on failure
+static bool const HAS_BROKEN_MOTION_HINTS =
+ true || gtk_check_version(2, 12, 0) != NULL || !HAS_GDK_EVENT_REQUEST_MOTIONS;
// Define this to visualize the regions to be redrawn
//#define DEBUG_REDRAW 1;
-// Tiles are a way to minimize the number of redraws, eliminating too small redraws.
+// Tiles are a way to minimize the number of redraws, eliminating too small redraws.
// The canvas stores a 2D array of ints, each representing a TILE_SIZExTILE_SIZE pixels tile.
// If any part of it is dirtied, the entire tile is dirtied (its int is nonzero) and repainted.
#define TILE_SIZE 16
-enum {
- RENDERMODE_NORMAL,
- RENDERMODE_NOAA,
- RENDERMODE_OUTLINE
-};
-
-const gint sp_canvas_update_priority = G_PRIORITY_HIGH_IDLE;
+static gint const sp_canvas_update_priority = G_PRIORITY_HIGH_IDLE;
#define SP_CANVAS_WINDOW(c) (((GtkWidget *) (c))->window)
static void sp_canvas_request_update (SPCanvas *canvas);
+static void track_latency(GdkEvent const *event);
static void sp_canvas_item_class_init (SPCanvasItemClass *klass);
static void sp_canvas_item_init (SPCanvasItem *item);
static void sp_canvas_item_dispose (GObject *object);
-static void sp_canvas_item_construct (SPCanvasItem *item, SPCanvasGroup *parent, const gchar *first_arg_name, va_list args);
+static void sp_canvas_item_construct (SPCanvasItem *item, SPCanvasGroup *parent, gchar const *first_arg_name, va_list args);
static int emit_event (SPCanvas *canvas, GdkEvent *event);
{
static GType type = 0;
if (!type) {
- static const GTypeInfo info = {
+ static GTypeInfo const info = {
sizeof (SPCanvasItemClass),
NULL, NULL,
(GClassInitFunc) sp_canvas_item_class_init,
item_signals[ITEM_EVENT] = g_signal_new ("event",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (SPCanvasItemClass, event),
+ ((glong)((guint8*)&(klass->event) - (guint8*)klass)),
NULL, NULL,
sp_marshal_BOOLEAN__POINTER,
G_TYPE_BOOLEAN, 1,
* Constructs new SPCanvasItem on SPCanvasGroup.
*/
SPCanvasItem *
-sp_canvas_item_new (SPCanvasGroup *parent, GtkType type, const gchar *first_arg_name, ...)
+sp_canvas_item_new (SPCanvasGroup *parent, GtkType type, gchar const *first_arg_name, ...)
{
va_list args;
@@ -190,7 +201,7 @@ sp_canvas_item_new (SPCanvasGroup *parent, GtkType type, const gchar *first_arg_
* We make it static for encapsulation reasons since it was nowhere used.
*/
static void
-sp_canvas_item_construct (SPCanvasItem *item, SPCanvasGroup *parent, const gchar *first_arg_name, va_list args)
+sp_canvas_item_construct (SPCanvasItem *item, SPCanvasGroup *parent, gchar const *first_arg_name, va_list args)
{
g_return_if_fail (SP_IS_CANVAS_GROUP (parent));
g_return_if_fail (SP_IS_CANVAS_ITEM (item));
@@ -296,11 +307,11 @@ sp_canvas_item_invoke_update (SPCanvasItem *item, NR::Matrix const &affine, unsi
GTK_OBJECT_UNSET_FLAGS (item, SP_CANVAS_ITEM_NEED_AFFINE);
}
-/**
- * Helper function to invoke the point method of the item.
+/**
+ * Helper function to invoke the point method of the item.
*
- * The argument x, y should be in the parent's item-relative coordinate
- * system. This routine applies the inverse of the item's transform,
+ * The argument x, y should be in the parent's item-relative coordinate
+ * system. This routine applies the inverse of the item's transform,
* maintaining the affine invariant.
*/
static double
@@ -315,12 +326,12 @@ sp_canvas_item_invoke_point (SPCanvasItem *item, NR::Point p, SPCanvasItem **act
/**
* Makes the item's affine transformation matrix be equal to the specified
* matrix.
- *
+ *
* @item: A canvas item.
* @affine: An affine transformation matrix.
*/
void
-sp_canvas_item_affine_absolute (SPCanvasItem *item, NR::Matrix const& affine)
+sp_canvas_item_affine_absolute (SPCanvasItem *item, NR::Matrix const &affine)
{
item->xform = affine;
}
/**
- * Convenience function to reorder items in a group's child list.
+ * Convenience function to reorder items in a group's child list.
*
* This puts the specified link after the "before" link.
*/
/**
* Raises the item in its parent's stack by the specified number of positions.
- *
+ *
* \param item A canvas item.
* \param positions Number of steps to raise the item.
*
/**
* Grab item under cursor.
- *
+ *
* \pre !canvas->grabbed_item && item->flags & SP_CANVAS_ITEM_VISIBLE
*/
int
@@ -532,6 +543,10 @@ sp_canvas_item_grab (SPCanvasItem *item, guint event_mask, GdkCursor *cursor, gu
if (!(item->flags & SP_CANVAS_ITEM_VISIBLE))
return -1;
+ if (HAS_BROKEN_MOTION_HINTS) {
+ event_mask &= ~GDK_POINTER_MOTION_HINT_MASK;
+ }
+
/* fixme: Top hack (Lauris) */
/* fixme: If we add key masks to event mask, Gdk will abort (Lauris) */
/* fixme: But Canvas actualle does get key events, so all we need is routing these here */
@@ -549,7 +564,7 @@ sp_canvas_item_grab (SPCanvasItem *item, guint event_mask, GdkCursor *cursor, gu
/**
* Ungrabs the item, which must have been grabbed in the canvas, and ungrabs the
* mouse.
- *
+ *
* \param item A canvas item that holds a grab.
* \param etime The timestamp for ungrabbing the mouse.
*/
/**
* Requests that the canvas queue an update for the specified item.
- *
+ *
* To be used only by item implementations.
*/
void
/**
* Registers SPCanvasGroup class with Gtk and returns its type number.
*/
-GtkType
-sp_canvas_group_get_type (void)
+GType sp_canvas_group_get_type(void)
{
- static GtkType group_type = 0;
-
- if (!group_type) {
- static const GtkTypeInfo group_info = {
- "SPCanvasGroup",
- sizeof (SPCanvasGroup),
- sizeof (SPCanvasGroupClass),
- (GtkClassInitFunc) sp_canvas_group_class_init,
- (GtkObjectInitFunc) sp_canvas_group_init,
- NULL, NULL, NULL
+ static GType type = 0;
+ if (!type) {
+ GTypeInfo info = {
+ sizeof(SPCanvasGroupClass),
+ 0, // base_init
+ 0, // base_finalize
+ (GClassInitFunc)sp_canvas_group_class_init,
+ 0, // class_finalize
+ 0, // class_data
+ sizeof(SPCanvasGroup),
+ 0, // n_preallocs
+ (GInstanceInitFunc)sp_canvas_group_init,
+ 0 // value_table
};
-
- group_type = gtk_type_unique (sp_canvas_item_get_type (), &group_info);
+ type = g_type_register_static(sp_canvas_item_get_type(), "SPCanvasGroup", &info, static_cast<GTypeFlags>(0));
}
-
- return group_type;
+ return type;
}
/**
}
/**
- * Callback that destroys all items in group and calls group's virtual
+ * Callback that destroys all items in group and calls group's virtual
* destroy() function.
*/
static void
g_return_if_fail (object != NULL);
g_return_if_fail (SP_IS_CANVAS_GROUP (object));
- const SPCanvasGroup *group = SP_CANVAS_GROUP (object);
+ SPCanvasGroup const *group = SP_CANVAS_GROUP (object);
GList *list = group->items;
while (list) {
static void
sp_canvas_group_update (SPCanvasItem *item, NR::Matrix const &affine, unsigned int flags)
{
- const SPCanvasGroup *group = SP_CANVAS_GROUP (item);
+ SPCanvasGroup const *group = SP_CANVAS_GROUP (item);
NR::ConvexHull corners(NR::Point(0, 0));
bool empty=true;
@@ -777,7 +792,7 @@ sp_canvas_group_update (SPCanvasItem *item, NR::Matrix const &affine, unsigned i
}
}
- NR::Maybe<NR::Rect> const bounds = corners.bounds();
+ boost::optional<NR::Rect> const bounds = corners.bounds();
if (bounds) {
item->x1 = bounds->min()[NR::X];
item->y1 = bounds->min()[NR::Y];
@@ -795,9 +810,9 @@ sp_canvas_group_update (SPCanvasItem *item, NR::Matrix const &affine, unsigned i
static double
sp_canvas_group_point (SPCanvasItem *item, NR::Point p, SPCanvasItem **actual_item)
{
- const SPCanvasGroup *group = SP_CANVAS_GROUP (item);
- const double x = p[NR::X];
- const double y = p[NR::Y];
+ SPCanvasGroup const *group = SP_CANVAS_GROUP (item);
+ double const x = p[NR::X];
+ double const y = p[NR::Y];
int x1 = (int)(x - item->canvas->close_enough);
int y1 = (int)(y - item->canvas->close_enough);
int x2 = (int)(x + item->canvas->close_enough);
@@ -837,7 +852,7 @@ sp_canvas_group_point (SPCanvasItem *item, NR::Point p, SPCanvasItem **actual_it
static void
sp_canvas_group_render (SPCanvasItem *item, SPCanvasBuf *buf)
{
- const SPCanvasGroup *group = SP_CANVAS_GROUP (item);
+ SPCanvasGroup const *group = SP_CANVAS_GROUP (item);
for (GList *list = group->items; list; list = list->next) {
SPCanvasItem *child = (SPCanvasItem *)list->data;
sp_canvas_item_request_update (item);
}
-/**
+/**
* Removes an item from a canvas group
*/
static void
*
* \return The type ID of the SPCanvas class.
**/
-GtkType
-sp_canvas_get_type (void)
-{
- static GtkType canvas_type = 0;
-
- if (!canvas_type) {
- static const GtkTypeInfo canvas_info = {
- "SPCanvas",
- sizeof (SPCanvas),
- sizeof (SPCanvasClass),
- (GtkClassInitFunc) sp_canvas_class_init,
- (GtkObjectInitFunc) sp_canvas_init,
- NULL, NULL, NULL
+GType sp_canvas_get_type(void)
+{
+ static GType type = 0;
+ if (!type) {
+ GTypeInfo info = {
+ sizeof(SPCanvasClass),
+ 0, // base_init
+ 0, // base_finalize
+ (GClassInitFunc)sp_canvas_class_init,
+ 0, // class_finalize
+ 0, // class_data
+ sizeof(SPCanvas),
+ 0, // n_preallocs
+ (GInstanceInitFunc)sp_canvas_init,
+ 0 // value_table
};
-
- canvas_type = gtk_type_unique (GTK_TYPE_WIDGET, &canvas_info);
+ type = g_type_register_static(GTK_TYPE_WIDGET, "SPCanvas", &info, static_cast<GTypeFlags>(0));
}
-
- return canvas_type;
+ return type;
}
/**
widget_class->focus_out_event = sp_canvas_focus_out;
}
-/**
+/**
* Callback: object initialization for SPCanvas.
*/
static void
canvas->forced_redraw_count = 0;
canvas->forced_redraw_limit = -1;
+#if ENABLE_LCMS
+ canvas->enable_cms_display_adj = false;
+ canvas->cms_key = new Glib::ustring("");
+#endif // ENABLE_LCMS
+
canvas->is_scrolling = false;
}
(* GTK_OBJECT_CLASS (canvas_parent_class)->destroy) (object);
}
+static void track_latency(GdkEvent const *event) {
+ GdkEventLatencyTracker &tracker = GdkEventLatencyTracker::default_tracker();
+ boost::optional<double> latency = tracker.process(event);
+ if (latency && *latency > 2.0) {
+ g_warning("Event latency reached %f sec (%1.4f)", *latency, tracker.getSkew());
+ }
+}
+
/**
* Returns new canvas as widget.
*/
GDK_BUTTON_PRESS_MASK |
GDK_BUTTON_RELEASE_MASK |
GDK_POINTER_MOTION_MASK |
+ ( HAS_BROKEN_MOTION_HINTS ?
+ 0 : GDK_POINTER_MOTION_HINT_MASK ) |
GDK_PROXIMITY_IN_MASK |
GDK_PROXIMITY_OUT_MASK |
GDK_KEY_PRESS_MASK |
{
SPCanvas *canvas = SP_CANVAS (widget);
+ canvas->current_item = NULL;
+ canvas->grabbed_item = NULL;
+ canvas->focused_item = NULL;
+
shutdown_transients (canvas);
gdk_gc_destroy (canvas->pixmap_gc);
}
widget->allocation = *allocation;
-
+
if (GTK_WIDGET_REALIZED (widget)) {
gdk_window_move_resize (widget->window,
widget->allocation.x, widget->allocation.y,
}
/**
- * Helper that emits an event for an item in the canvas, be it the current
+ * Helper that emits an event for an item in the canvas, be it the current
* item, grabbed item, or focused item, as appropriate.
*/
static int
}
/**
- * Helper that re-picks the current item in the canvas, based on the event's
+ * Helper that re-picks the current item in the canvas, based on the event's
* coordinates and emits enter/leave events for items as appropriate.
*/
static int
/* dispatch normally regardless of the event's window if an item has
has a pointer grab in effect */
- if (!canvas->grabbed_item &&
+ if (!canvas->grabbed_item &&
event->window != SP_CANVAS_WINDOW (canvas))
return retval;
return emit_event (SP_CANVAS (widget), (GdkEvent *) event);
}
+static inline void request_motions(GdkWindow *w, GdkEventMotion *event) {
+ gdk_window_get_pointer(w, NULL, NULL, NULL);
+#if HAS_GDK_EVENT_REQUEST_MOTIONS
+ gdk_event_request_motions(event);
+#endif
+}
+
/**
* Motion event handler for the canvas.
*/
static int
sp_canvas_motion (GtkWidget *widget, GdkEventMotion *event)
{
+ int status;
SPCanvas *canvas = SP_CANVAS (widget);
+ track_latency((GdkEvent *)event);
+
if (event->window != SP_CANVAS_WINDOW (canvas))
return FALSE;
- if (canvas->grabbed_event_mask & GDK_POINTER_MOTION_HINT_MASK) {
- gint x, y;
- gdk_window_get_pointer (widget->window, &x, &y, NULL);
- event->x = x;
- event->y = y;
- }
+ if (canvas->pixmap_gc == NULL) // canvas being deleted
+ return FALSE;
canvas->state = event->state;
pick_current_item (canvas, (GdkEvent *) event);
- return emit_event (canvas, (GdkEvent *) event);
+ status = emit_event (canvas, (GdkEvent *) event);
+
+ if (event->is_hint) {
+ request_motions(widget->window, event);
+ }
+
+ return status;
}
static void
@@ -1556,7 +1602,7 @@ sp_canvas_paint_single_buffer (SPCanvas *canvas, int x0, int y0, int x1, int y1,
GtkWidget *widget = GTK_WIDGET (canvas);
SPCanvasBuf buf;
- if (canvas->rendermode != RENDERMODE_OUTLINE) {
+ if (canvas->rendermode != Inkscape::RENDERMODE_OUTLINE) {
buf.buf = nr_pixelstore_256K_new (FALSE, 0);
} else {
buf.buf = nr_pixelstore_1M_new (FALSE, 0);
@@ -1565,7 +1611,7 @@ sp_canvas_paint_single_buffer (SPCanvas *canvas, int x0, int y0, int x1, int y1,
// Mark the region clean
sp_canvas_mark_rect(canvas, x0, y0, x1, y1, 0);
- buf.buf_rowstride = sw * 3; // CAIRO FIXME: for cairo output, the buffer must be RGB unpacked, i.e. sw * 4
+ buf.buf_rowstride = sw * 4;
buf.rect.x0 = x0;
buf.rect.y0 = y0;
buf.rect.x1 = x1;
@@ -1579,12 +1625,29 @@ sp_canvas_paint_single_buffer (SPCanvas *canvas, int x0, int y0, int x1, int y1,
| (color->green & 0xff00)
| (color->blue >> 8));
buf.is_empty = true;
-
+
+ buf.ct = nr_create_cairo_context_canvasbuf (&(buf.visible_rect), &buf);
+
if (canvas->root->flags & SP_CANVAS_ITEM_VISIBLE) {
SP_CANVAS_ITEM_GET_CLASS (canvas->root)->render (canvas->root, &buf);
}
-
+
+#if ENABLE_LCMS
+ cmsHTRANSFORM transf = 0;
+ long long int fromDisplay = prefs_get_int_attribute_limited( "options.displayprofile", "from_display", 0, 0, 1 );
+ if ( fromDisplay ) {
+ transf = Inkscape::colorprofile_get_display_per( canvas->cms_key ? *(canvas->cms_key) : "" );
+ } else {
+ transf = Inkscape::colorprofile_get_display_transform();
+ }
+#endif // ENABLE_LCMS
+
if (buf.is_empty) {
+#if ENABLE_LCMS
+ if ( transf && canvas->enable_cms_display_adj ) {
+ cmsDoTransform( transf, &buf.bg_color, &buf.bg_color, 1 );
+ }
+#endif // ENABLE_LCMS
gdk_rgb_gc_set_foreground (canvas->pixmap_gc, buf.bg_color);
gdk_draw_rectangle (SP_CANVAS_WINDOW (canvas),
canvas->pixmap_gc,
@@ -1592,39 +1655,74 @@ sp_canvas_paint_single_buffer (SPCanvas *canvas, int x0, int y0, int x1, int y1,
x0 - canvas->x0, y0 - canvas->y0,
x1 - x0, y1 - y0);
} else {
-/*
-// CAIRO FIXME: after SPCanvasBuf is made 32bpp throughout, this rgb_draw below can be replaced with the below.
-// Why this must not be done currently:
-// - all canvas items (handles, nodes etc) paint themselves assuming 24bpp
-// - cairo assumes bgra, but we have rgba, so r and b get swapped (until we paint all with cairo too)
-// - it does not seem to be any faster; in fact since with 32bpp, buf contains less pixels,
-// we need more bufs to paint a given area and as a result it's even a bit slower
-
- cairo_surface_t* cst = cairo_image_surface_create_for_data (
- buf.buf,
- CAIRO_FORMAT_RGB24, // unpacked, i.e. 32 bits! one byte is unused
- x1 - x0, y1 - y0,
- buf.buf_rowstride
- );
- cairo_t *ct = gdk_cairo_create(SP_CANVAS_WINDOW (canvas));
- cairo_set_source_surface (ct, cst, x0 - canvas->x0, y0 - canvas->y0);
- cairo_paint (ct);
- cairo_destroy (ct);
- cairo_surface_finish (cst);
- cairo_surface_destroy (cst);
-*/
+
+#if ENABLE_LCMS
+ if ( transf && canvas->enable_cms_display_adj ) {
+ for ( gint yy = 0; yy < (y1 - y0); yy++ ) {
+ guchar* p = buf.buf + (sw * 3) * yy;
+ cmsDoTransform( transf, p, p, (x1 - x0) );
+ }
+ }
+#endif // ENABLE_LCMS
+
+// Now we only need to output the prepared pixmap to the actual screen, and this define chooses one
+// of the two ways to do it. The cairo way is direct and straightforward, but unfortunately
+// noticeably slower. I asked Carl Worth but he was unable so far to suggest any specific reason
+// for this slowness. So, for now we use the oldish method: squeeze out 32bpp buffer to 24bpp and
+// use gdk_draw_rgb_image_dithalign, for unfortunately gdk can only handle 24 bpp, which cairo
+// cannot handle at all. Still, this way is currently faster even despite the blit with squeeze.
+
+///#define CANVAS_OUTPUT_VIA_CAIRO
+
+#ifdef CANVAS_OUTPUT_VIA_CAIRO
+
+ buf.cst = cairo_image_surface_create_for_data (
+ buf.buf,
+ CAIRO_FORMAT_ARGB32, // unpacked, i.e. 32 bits! one byte is unused
+ x1 - x0, y1 - y0,
+ buf.buf_rowstride
+ );
+ cairo_t *window_ct = gdk_cairo_create(SP_CANVAS_WINDOW (canvas));
+ cairo_set_source_surface (window_ct, buf.cst, x0 - canvas->x0, y0 - canvas->y0);
+ cairo_paint (window_ct);
+ cairo_destroy (window_ct);
+ cairo_surface_finish (buf.cst);
+ cairo_surface_destroy (buf.cst);
+
+#else
+
+ NRPixBlock b3;
+ nr_pixblock_setup_fast (&b3, NR_PIXBLOCK_MODE_R8G8B8, x0, y0, x1, y1, TRUE);
+
+ NRPixBlock b4;
+ nr_pixblock_setup_extern (&b4, NR_PIXBLOCK_MODE_R8G8B8A8P, x0, y0, x1, y1,
+ buf.buf,
+ buf.buf_rowstride,
+ FALSE, FALSE);
+
+ // this does the 32->24 squishing, using an assembler routine:
+ nr_blit_pixblock_pixblock (&b3, &b4);
gdk_draw_rgb_image_dithalign (SP_CANVAS_WINDOW (canvas),
canvas->pixmap_gc,
x0 - canvas->x0, y0 - canvas->y0,
x1 - x0, y1 - y0,
GDK_RGB_DITHER_MAX,
- buf.buf,
+ NR_PIXBLOCK_PX(&b3),
sw * 3,
x0 - canvas->x0, y0 - canvas->y0);
+
+ nr_pixblock_release (&b3);
+ nr_pixblock_release (&b4);
+#endif
}
- if (canvas->rendermode != RENDERMODE_OUTLINE) {
+ cairo_surface_t *cst = cairo_get_target(buf.ct);
+ cairo_destroy (buf.ct);
+ cairo_surface_finish (cst);
+ cairo_surface_destroy (cst);
+
+ if (canvas->rendermode != Inkscape::RENDERMODE_OUTLINE) {
nr_pixelstore_256K_free (buf.buf);
} else {
nr_pixelstore_1M_free (buf.buf);
@@ -1664,12 +1762,12 @@ sp_canvas_paint_rect_internal (PaintRectSetup const *setup, NRRectL this_rect)
// Interrupting redraw isn't always good.
// For example, when you drag one node of a big path, only the buffer containing
// the mouse cursor will be redrawn again and again, and the rest of the path
- // will remain stale because Inkscape never has enough idle time to redraw all
- // of the screen. To work around this, such operations set a forced_redraw_limit > 0.
+ // will remain stale because Inkscape never has enough idle time to redraw all
+ // of the screen. To work around this, such operations set a forced_redraw_limit > 0.
// If this limit is set, and if we have aborted redraw more times than is allowed,
- // interrupting is blocked and we're forced to redraw full screen once
+ // interrupting is blocked and we're forced to redraw full screen once
// (after which we can again interrupt forced_redraw_limit times).
- if (setup->canvas->forced_redraw_limit < 0 ||
+ if (setup->canvas->forced_redraw_limit < 0 ||
setup->canvas->forced_redraw_count < setup->canvas->forced_redraw_limit) {
if (setup->canvas->forced_redraw_limit != -1) {
@@ -1699,8 +1797,8 @@ sp_canvas_paint_rect_internal (PaintRectSetup const *setup, NRRectL this_rect)
NRRectL lo = this_rect;
NRRectL hi = this_rect;
-/*
-This test determines the redraw strategy:
+/*
+This test determines the redraw strategy:
bw < bh (strips mode) splits across the smaller dimension of the rect and therefore (on
horizontally-stretched windows) results in redrawing in horizontal strips (from cursor point, in
The default for now is the strips mode.
*/
- if (bw < bh || bh < 2 * TILE_SIZE) {
- int mid = (this_rect.x0 + this_rect.x1) / 2;
+ if (bw < bh || bh < 2 * TILE_SIZE) {
+ // to correctly calculate the mean of two ints, we need to sum them into a larger int type
+ int mid = ((long long) this_rect.x0 + (long long) this_rect.x1) / 2;
// Make sure that mid lies on a tile boundary
mid = (mid / TILE_SIZE) * TILE_SIZE;
&& sp_canvas_paint_rect_internal(setup, lo);
}
} else {
- int mid = (this_rect.y0 + this_rect.y1) / 2;
+ // to correctly calculate the mean of two ints, we need to sum them into a larger int type
+ int mid = ((long long) this_rect.y0 + (long long) this_rect.y1) / 2;
// Make sure that mid lies on a tile boundary
mid = (mid / TILE_SIZE) * TILE_SIZE;
sp_canvas_paint_rect (SPCanvas *canvas, int xx0, int yy0, int xx1, int yy1)
{
g_return_val_if_fail (!canvas->need_update, false);
-
+
NRRectL rect;
rect.x0 = xx0;
rect.x1 = xx1;
// paint the area to redraw yellow
gdk_rgb_gc_set_foreground (canvas->pixmap_gc, 0xFFFF00);
gdk_draw_rectangle (SP_CANVAS_WINDOW (canvas),
- canvas->pixmap_gc,
- TRUE,
- rect.x0 - canvas->x0, rect.y0 - canvas->y0,
- rect.x1 - rect.x0, rect.y1 - rect.y0);
-#endif
+ canvas->pixmap_gc,
+ TRUE,
+ rect.x0 - canvas->x0, rect.y0 - canvas->y0,
+ rect.x1 - rect.x0, rect.y1 - rect.y0);
+#endif
PaintRectSetup setup;
gdk_window_get_pointer (GTK_WIDGET(canvas)->window, &x, &y, NULL);
setup.mouse_loc = sp_canvas_window_to_world (canvas, NR::Point(x,y));
- // CAIRO FIXME: the sw/sh calculations below all assume 24bpp, need fixing for 32bpp
- if (canvas->rendermode != RENDERMODE_OUTLINE) {
+ if (canvas->rendermode != Inkscape::RENDERMODE_OUTLINE) {
// use 256K as a compromise to not slow down gradients
- // 256K is the cached buffer and we need 3 channels
- setup.max_pixels = 87381; // 256K/3
+ // 256K is the cached buffer and we need 4 channels
+ setup.max_pixels = 65536; // 256K/4
} else {
// paths only, so 1M works faster
- // 1M is the cached buffer and we need 3 channels
- setup.max_pixels = 349525;
+ // 1M is the cached buffer and we need 4 channels
+ setup.max_pixels = 262144;
}
// Start the clock
void
sp_canvas_force_full_redraw_after_interruptions(SPCanvas *canvas, unsigned int count) {
g_return_if_fail(canvas != NULL);
-
+
canvas->forced_redraw_limit = count;
canvas->forced_redraw_count = 0;
}
{
SPCanvas *canvas = SP_CANVAS (widget);
- if (!GTK_WIDGET_DRAWABLE (widget) ||
+ if (!GTK_WIDGET_DRAWABLE (widget) ||
(event->window != SP_CANVAS_WINDOW (canvas)))
return FALSE;
for (int i = 0; i < n_rects; i++) {
NRRectL rect;
-
+
rect.x0 = rects[i].x + canvas->x0;
rect.y0 = rects[i].y + canvas->y0;
rect.x1 = rect.x0 + rects[i].width;
Gdk::Region to_paint;
- for (int j=canvas->tTop; j<canvas->tBottom; j++) {
- for (int i=canvas->tLeft; i<canvas->tRight; i++) {
+ for (int j=canvas->tTop; j<canvas->tBottom; j++) {
+ for (int i=canvas->tLeft; i<canvas->tRight; i++) {
int tile_index = (i - canvas->tLeft) + (j - canvas->tTop)*canvas->tileH;
if ( canvas->tiles[tile_index] ) { // if this tile is dirtied (nonzero)
static int
do_update (SPCanvas *canvas)
{
- if (!canvas->root) // canvas may have already be destroyed by closing desktop durring interrupted display!
+ if (!canvas->root || !canvas->pixmap_gc) // canvas may have already be destroyed by closing desktop durring interrupted display!
return TRUE;
/* Cause the update if necessary */
SPCanvas *canvas = SP_CANVAS (data);
- const int ret = do_update (canvas);
+ int const ret = do_update (canvas);
if (ret) {
/* Reset idle id */
}
/**
- * Scrolls canvas to specific position.
+ * Scrolls canvas to specific position (cx and cy are measured in screen pixels)
*/
void
sp_canvas_scroll_to (SPCanvas *canvas, double cx, double cy, unsigned int clear, bool is_scrolling)
@@ -2060,12 +2159,12 @@ sp_canvas_scroll_to (SPCanvas *canvas, double cx, double cy, unsigned int clear,
g_return_if_fail (canvas != NULL);
g_return_if_fail (SP_IS_CANVAS (canvas));
- int ix = (int) (cx + 0.5);
- int iy = (int) (cy + 0.5);
- int dx = ix - canvas->x0;
- int dy = iy - canvas->y0;
+ int ix = (int) round(cx); // ix and iy are the new canvas coordinates (integer screen pixels)
+ int iy = (int) round(cy); // cx might be negative, so (int)(cx + 0.5) will not do!
+ int dx = ix - canvas->x0; // dx and dy specify the displacement (scroll) of the
+ int dy = iy - canvas->y0; // canvas w.r.t its previous position
- canvas->dx0 = cx;
+ canvas->dx0 = cx; // here the 'd' stands for double, not delta!
canvas->dy0 = cy;
canvas->x0 = ix;
canvas->y0 = iy;
@@ -2083,18 +2182,9 @@ sp_canvas_scroll_to (SPCanvas *canvas, double cx, double cy, unsigned int clear,
} else {
// scrolling as part of zoom; do nothing here - the next do_update will perform full redraw
}
-
- /* update perspective lines if we are in the 3D box tool (so that infinite ones are shown correctly) */
- SPEventContext *ec = inkscape_active_event_context();
- if (SP_IS_3DBOX_CONTEXT (ec)) {
- // We could avoid redraw during panning by checking the status of is_scrolling, but this is
- // neither faster nor does it get rid of artefacts, so we update PLs unconditionally
- SP3DBoxContext *bc = SP_3DBOX_CONTEXT (ec);
- bc->_vpdrag->updateLines();
- }
}
-/**
+/**
* Updates canvas if necessary.
*/
void
@@ -2221,11 +2311,20 @@ bool sp_canvas_world_pt_inside_window(SPCanvas const *canvas, NR::Point const &w
NR::Rect SPCanvas::getViewbox() const
{
GtkWidget const *w = GTK_WIDGET(this);
-
return NR::Rect(NR::Point(dx0, dy0),
NR::Point(dx0 + w->allocation.width, dy0 + w->allocation.height));
}
+/**
+ * Return canvas window coordinates as IRect (a rectangle defined by integers).
+ */
+NR::IRect SPCanvas::getViewboxIntegers() const
+{
+ GtkWidget const *w = GTK_WIDGET(this);
+ return NR::IRect(NR::IPoint(x0, y0),
+ NR::IPoint(x0 + w->allocation.width, y0 + w->allocation.height));
+}
+
inline int sp_canvas_tile_floor(int x)
{
return (x & (~(TILE_SIZE - 1))) / TILE_SIZE;
@@ -2319,4 +2418,4 @@ void sp_canvas_mark_rect(SPCanvas* canvas, int nl, int nt, int nr, int nb, uint8
fill-column:99
End:
*/
-// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4 :
+// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :