![[tokkee]](http://tokkee.org/images/avatar.png){kind=avatar}
index 1e7b8051f147a701e8da70a246fa4f6a22487769..97713b18e1e69a557a6a998940d40f8b66792c86 100644 (file)
#include <gtk/gtkmain.h>
#include <gtk/gtksignal.h>
+#include <gtk/gtkversion.h>
#include <gtkmm.h>
#include <helper/sp-marshal.h>
+#include <helper/recthull.h>
#include <display/sp-canvas.h>
#include "display-forward.h"
#include <libnr/nr-matrix-fns.h>
#include <libnr/nr-matrix-ops.h>
#include <libnr/nr-convex-hull.h>
-#include "prefs-utils.h"
-#include "box3d-context.h"
+#include "preferences.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"
+#include "desktop.h"
+#include "sp-namedview.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 32
-
-enum {
- RENDERMODE_NORMAL,
- RENDERMODE_NOAA,
- RENDERMODE_OUTLINE
-};
+#define TILE_SIZE 16
-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,
sp_canvas_item_init (SPCanvasItem *item)
{
item->flags |= SP_CANVAS_ITEM_VISIBLE;
- item->xform = NR::Matrix(NR::identity());
+ item->xform = Geom::Matrix(Geom::identity());
}
/**
* 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 +204,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));
// this redraws only the stroke of the rect to be deleted,
// avoiding redraw of the entire area
if (SP_IS_CTRLRECT(item)) {
- SP_CTRLRECT(object)->setRectangle(NR::Rect(NR::Point(0,0),NR::Point(0,0)));
+ SP_CTRLRECT(object)->setRectangle(Geom::Rect(Geom::Point(0,0),Geom::Point(0,0)));
SP_CTRLRECT(object)->update(item->xform, 0);
} else {
redraw_if_visible (item);
* NB! affine is parent2canvas.
*/
static void
-sp_canvas_item_invoke_update (SPCanvasItem *item, NR::Matrix const &affine, unsigned int flags)
+sp_canvas_item_invoke_update (SPCanvasItem *item, Geom::Matrix const &affine, unsigned int flags)
{
/* Apply the child item's transform */
- NR::Matrix child_affine = item->xform * affine;
+ Geom::Matrix child_affine = item->xform * affine;
/* apply object flags to child flags */
int child_flags = flags & ~SP_CANVAS_UPDATE_REQUESTED;
@@ -296,15 +310,15 @@ 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
-sp_canvas_item_invoke_point (SPCanvasItem *item, NR::Point p, SPCanvasItem **actual_item)
+sp_canvas_item_invoke_point (SPCanvasItem *item, Geom::Point p, SPCanvasItem **actual_item)
{
if (SP_CANVAS_ITEM_GET_CLASS (item)->point)
return SP_CANVAS_ITEM_GET_CLASS (item)->point (item, p, actual_item);
@@ -315,12 +329,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, Geom::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 +546,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 +567,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.
*/
* Returns the product of all transformation matrices from the root item down
* to the item.
*/
-NR::Matrix sp_canvas_item_i2w_affine(SPCanvasItem const *item)
+Geom::Matrix sp_canvas_item_i2w_affine(SPCanvasItem const *item)
{
g_assert (SP_IS_CANVAS_ITEM (item)); // should we get this?
- NR::Matrix affine = NR::identity();
+ Geom::Matrix affine = Geom::identity();
while (item) {
affine *= item->xform;
/**
* Requests that the canvas queue an update for the specified item.
- *
+ *
* To be used only by item implementations.
*/
void
static void sp_canvas_group_init (SPCanvasGroup *group);
static void sp_canvas_group_destroy (GtkObject *object);
-static void sp_canvas_group_update (SPCanvasItem *item, NR::Matrix const &affine, unsigned int flags);
-static double sp_canvas_group_point (SPCanvasItem *item, NR::Point p, SPCanvasItem **actual_item);
+static void sp_canvas_group_update (SPCanvasItem *item, Geom::Matrix const &affine, unsigned int flags);
+static double sp_canvas_group_point (SPCanvasItem *item, Geom::Point p, SPCanvasItem **actual_item);
static void sp_canvas_group_render (SPCanvasItem *item, SPCanvasBuf *buf);
static SPCanvasItemClass *group_parent_class;
/**
* 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) {
* Update handler for canvas groups
*/
static void
-sp_canvas_group_update (SPCanvasItem *item, NR::Matrix const &affine, unsigned int flags)
+sp_canvas_group_update (SPCanvasItem *item, Geom::Matrix const &affine, unsigned int flags)
{
- const SPCanvasGroup *group = SP_CANVAS_GROUP (item);
- NR::ConvexHull corners(NR::Point(0, 0));
+ SPCanvasGroup const *group = SP_CANVAS_GROUP (item);
+ Geom::RectHull corners(Geom::Point(0, 0));
bool empty=true;
for (GList *list = group->items; list; list = list->next) {
@@ -768,21 +786,21 @@ sp_canvas_group_update (SPCanvasItem *item, NR::Matrix const &affine, unsigned i
if ( i->x2 > i->x1 && i->y2 > i->y1 ) {
if (empty) {
- corners = NR::ConvexHull(NR::Point(i->x1, i->y1));
+ corners = Geom::RectHull(Geom::Point(i->x1, i->y1));
empty = false;
} else {
- corners.add(NR::Point(i->x1, i->y1));
+ corners.add(Geom::Point(i->x1, i->y1));
}
- corners.add(NR::Point(i->x2, i->y2));
+ corners.add(Geom::Point(i->x2, i->y2));
}
}
- NR::Maybe<NR::Rect> const bounds = corners.bounds();
+ Geom::OptRect const bounds = corners.bounds();
if (bounds) {
- item->x1 = bounds->min()[NR::X];
- item->y1 = bounds->min()[NR::Y];
- item->x2 = bounds->max()[NR::X];
- item->y2 = bounds->max()[NR::Y];
+ item->x1 = bounds->min()[Geom::X];
+ item->y1 = bounds->min()[Geom::Y];
+ item->x2 = bounds->max()[Geom::X];
+ item->y2 = bounds->max()[Geom::Y];
} else {
// FIXME ?
item->x1 = item->x2 = item->y1 = item->y2 = 0;
@@ -793,11 +811,11 @@ sp_canvas_group_update (SPCanvasItem *item, NR::Matrix const &affine, unsigned i
* Point handler for canvas groups.
*/
static double
-sp_canvas_group_point (SPCanvasItem *item, NR::Point p, SPCanvasItem **actual_item)
+sp_canvas_group_point (SPCanvasItem *item, Geom::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[Geom::X];
+ double const y = p[Geom::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 +855,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
@@ -929,31 +947,35 @@ static void sp_canvas_dirty_rect(SPCanvas* canvas, int nl, int nt, int nr, int n
static void sp_canvas_mark_rect(SPCanvas* canvas, int nl, int nt, int nr, int nb, uint8_t val);
static int do_update (SPCanvas *canvas);
+static gboolean sp_canvas_snap_watchdog_callback(gpointer data);
+static void sp_canvas_snap_watchdog_set(SPCanvas *canvas, GdkEventMotion *event);
+static void sp_canvas_snap_watchdog_kill(SPCanvas *canvas);
+
/**
* Registers the SPCanvas class if necessary, and returns the type ID
* associated to it.
*
* \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;
+ canvas->watchdog_id = 0;
+ canvas->watchdog_event = NULL;
}
/**
(* 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 |
widget->window = gdk_window_new (gtk_widget_get_parent_window (widget), &attributes, attributes_mask);
gdk_window_set_user_data (widget->window, widget);
- if ( prefs_get_int_attribute ("options.useextinput", "value", 1) )
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ if ( prefs->getBool("/options/useextinput/value", true) )
gtk_widget_set_events(widget, attributes.event_mask);
widget->style = gtk_style_attach (widget->style, widget->window);
{
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
/* find the closest item */
if (canvas->root->flags & SP_CANVAS_ITEM_VISIBLE) {
- sp_canvas_item_invoke_point (canvas->root, NR::Point(x, y), &canvas->new_current_item);
+ sp_canvas_item_invoke_point (canvas->root, Geom::Point(x, y), &canvas->new_current_item);
} else {
canvas->new_current_item = NULL;
}
sp_canvas_button (GtkWidget *widget, GdkEventButton *event)
{
SPCanvas *canvas = SP_CANVAS (widget);
+ SPDesktop *dt = SP_ACTIVE_DESKTOP;
int retval = FALSE;
/* 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;
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
- /* Pick the current item as if the button were not pressed, and
+ if (dt) {
+ // Snapping will be on hold if we're moving the mouse at high speeds. When starting
+ // drawing a new shape we really should snap though.
+ dt->namedview->snap_manager.snapprefs.setSnapPostponedGlobally(false);
+ }
+
+ /* Pick the current item as if the button were not pressed, and
* then process the event.
*/
canvas->state = event->state;
break;
case GDK_BUTTON_RELEASE:
- /* Process the event as if the button were pressed, then repick
+ sp_canvas_snap_watchdog_callback(canvas); // If we have any pending snapping action, then invoke it now
+
+ /* Process the event as if the button were pressed, then repick
* after the button has been released
*/
canvas->state = event->state;
canvas->state = event->state;
pick_current_item (canvas, (GdkEvent *) event);
event->state ^= mask;
+
break;
default:
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)
{
+ static guint32 prev_time;
+ static boost::optional<Geom::Point> prev_pos;
+
+ 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;
+
+ SPDesktop *dt = SP_ACTIVE_DESKTOP;
+
+ // Snap when speed drops below e.g. 0.02 px/msec, or when no motion events have occured for some period.
+ // i.e. snap when we're at stand still. A speed threshold enforces snapping for tablets, which might never
+ // be fully at stand still and might keep spitting out motion events.
+ if (dt) {
+ bool const c1 = event->type == GDK_MOTION_NOTIFY;
+ bool const c21 = event->state & GDK_BUTTON1_MASK; // Snapping only occurs when dragging with the left mouse button down
+ bool const c22 = event->state & GDK_BUTTON2_MASK; // We shouldn't hold back any events when other mouse buttons have been
+ bool const c23 = event->state & GDK_BUTTON3_MASK; // pressed, e.g. when scrolling with the middle mouse button; if we do then
+ // Inkscape will get stuck in an unresponsive state
+ bool const c3 = dt->namedview->snap_manager.snapprefs.getSnapEnabledGlobally();
+ if (c1 && c21 && (!c22) && (!c23) && c3) {
+ Geom::Point event_pos(event->x, event->y);
+ guint32 event_t = gdk_event_get_time ( (GdkEvent *) event );
+
+ dt->namedview->snap_manager.snapprefs.setSnapPostponedGlobally(true); // put snapping on hold
+
+ if (prev_pos) {
+ Geom::Coord dist = Geom::L2(event_pos - *prev_pos);
+ guint32 delta_t = event_t - prev_time;
+ gdouble speed = delta_t > 0 ? dist/delta_t : 1000;
+ // std::cout << "speed = " << speed << " px/msec " << "| time passed = " << delta_t << " msec" << std::endl;
+ if (speed > 0.02) { // Jitter threshold, might be needed for tablets
+ // We're moving fast, so postpone any snapping until the next GDK_MOTION_NOTIFY event. We
+ // will keep on postponing the snapping as long as the speed is high.
+ // We must snap at some point in time though, so set a watchdog timer at some time from
+ // now, just in case there's no future motion event that drops under the speed limit (when
+ // stoppping abruptly)
+ sp_canvas_snap_watchdog_kill(canvas);
+ sp_canvas_snap_watchdog_set(canvas, event); // watchdog is reset, i.e. pushed forward in time
+ // If the watchdog expires before a new motion event is received, we will snap (as explained
+ // above). This means however that when the timer is too short, we will always snap and that the
+ // speed threshold is ineffective. In the extreme case the delay is set to zero, and snapping will
+ // be immediate, as it used to be in the old days ;-).
+ } else { // Speed is very low, so we're virtually at stand still
+ // But if we're really standing still, then we should snap now. We could use some low-pass filtering,
+ // otherwise snapping occurs for each jitter movement. For this filtering we'll leave the watchdog to expire,
+ // snap, and set a new watchdog again.
+ if (canvas->watchdog_id == 0) { // no watchdog has been set
+ // it might have already expired, so we'll set a new one; the snapping frequency will be limited by this
+ sp_canvas_snap_watchdog_set(canvas, event);
+ } // else: watchdog has been set before and we'll wait for it to expire
+ }
+ } else {
+ // This is the first GDK_MOTION_NOTIFY event, so postpone snapping and set the watchdog
+ sp_canvas_snap_watchdog_set(canvas, event);
+ }
+
+ prev_pos = event_pos;
+ prev_time = event_t;
+ }
+ }
+
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;
}
+gboolean sp_canvas_snap_watchdog_callback(gpointer data)
+{
+ // Snap NOW! For this the "postponed" flag will be reset and an the last motion event will be repeated
+ SPCanvas *canvas = reinterpret_cast<SPCanvas *>(data);
+ if (!canvas->watchdog_event) {
+ return FALSE;
+ }
+
+ SPDesktop *dt = SP_ACTIVE_DESKTOP;
+ if (dt) {
+ dt->namedview->snap_manager.snapprefs.setSnapPostponedGlobally(false);
+ }
+
+ emit_event(canvas, canvas->watchdog_event);
+ gdk_event_free(canvas->watchdog_event);
+ canvas->watchdog_event = NULL;
+ canvas->watchdog_id = 0;
+
+ return FALSE;
+}
+
+void sp_canvas_snap_watchdog_set(SPCanvas *canvas, GdkEventMotion *event)
+{
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ double value = prefs->getDoubleLimited("/options/snapdelay/value", 0, 0, 1000);
+ g_assert(canvas->watchdog_id == 0);
+ canvas->watchdog_id = g_timeout_add(value, &sp_canvas_snap_watchdog_callback, canvas);
+ g_assert(canvas->watchdog_event == NULL);
+ canvas->watchdog_event = gdk_event_copy( (GdkEvent *) event);
+}
+
+void sp_canvas_snap_watchdog_kill(SPCanvas *canvas)
+{
+ if (canvas->watchdog_id) {
+ g_source_remove(canvas->watchdog_id); // Kill the watchdog
+ canvas->watchdog_id = 0;
+ }
+
+ if (canvas->watchdog_event) {
+ gdk_event_free(canvas->watchdog_event);
+ canvas->watchdog_event = NULL;
+ }
+}
+
static void
sp_canvas_paint_single_buffer (SPCanvas *canvas, int x0, int y0, int x1, int y1, int draw_x1, int draw_y1, int draw_x2, int draw_y2, int sw)
{
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 +1732,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 +1746,30 @@ 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;
+ Inkscape::Preferences *prefs = Inkscape::Preferences::get();
+ bool fromDisplay = prefs->getBool( "/options/displayprofile/from_display");
+ 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 +1777,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 + (buf.buf_rowstride * 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);
NRRectL big_rect;
GTimeVal start_time;
int max_pixels;
- NR::Point mouse_loc;
+ Geom::Point mouse_loc;
};
/**
@@ -1664,12 +1884,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 +1919,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) {
- 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;
lo.x1 = mid;
hi.x0 = mid;
- if (setup->mouse_loc[NR::X] < mid) {
+ if (setup->mouse_loc[Geom::X] < mid) {
// Always paint towards the mouse first
return sp_canvas_paint_rect_internal(setup, lo)
&& sp_canvas_paint_rect_internal(setup, hi);
&& 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;
lo.y1 = mid;
hi.y0 = mid;
- if (setup->mouse_loc[NR::Y] < mid) {
+ if (setup->mouse_loc[Geom::Y] < mid) {
// Always paint towards the mouse first
return sp_canvas_paint_rect_internal(setup, lo)
&& sp_canvas_paint_rect_internal(setup, hi);
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;
// Save the mouse location
gint x, y;
gdk_window_get_pointer (GTK_WIDGET(canvas)->window, &x, &y, NULL);
- setup.mouse_loc = sp_canvas_window_to_world (canvas, NR::Point(x,y));
+ setup.mouse_loc = sp_canvas_window_to_world (canvas, Geom::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;
paint (SPCanvas *canvas)
{
if (canvas->need_update) {
- sp_canvas_item_invoke_update (canvas->root, NR::identity(), 0);
+ sp_canvas_item_invoke_update (canvas->root, Geom::identity(), 0);
canvas->need_update = FALSE;
}
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 */
if (canvas->need_update) {
- sp_canvas_item_invoke_update (canvas->root, NR::identity(), 0);
+ sp_canvas_item_invoke_update (canvas->root, Geom::identity(), 0);
canvas->need_update = FALSE;
}
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 +2281,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 +2304,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
@@ -2179,51 +2391,58 @@ void sp_canvas_world_to_window(SPCanvas const *canvas, double worldx, double wor
/**
* Converts point from win to world coordinates.
*/
-NR::Point sp_canvas_window_to_world(SPCanvas const *canvas, NR::Point const win)
+Geom::Point sp_canvas_window_to_world(SPCanvas const *canvas, Geom::Point const win)
{
g_assert (canvas != NULL);
g_assert (SP_IS_CANVAS (canvas));
- return NR::Point(canvas->x0 + win[0], canvas->y0 + win[1]);
+ return Geom::Point(canvas->x0 + win[0], canvas->y0 + win[1]);
}
/**
* Converts point from world to win coordinates.
*/
-NR::Point sp_canvas_world_to_window(SPCanvas const *canvas, NR::Point const world)
+Geom::Point sp_canvas_world_to_window(SPCanvas const *canvas, Geom::Point const world)
{
g_assert (canvas != NULL);
g_assert (SP_IS_CANVAS (canvas));
- return NR::Point(world[0] - canvas->x0, world[1] - canvas->y0);
+ return Geom::Point(world[0] - canvas->x0, world[1] - canvas->y0);
}
/**
* Returns true if point given in world coordinates is inside window.
*/
-bool sp_canvas_world_pt_inside_window(SPCanvas const *canvas, NR::Point const &world)
+bool sp_canvas_world_pt_inside_window(SPCanvas const *canvas, Geom::Point const &world)
{
g_assert( canvas != NULL );
g_assert(SP_IS_CANVAS(canvas));
- using NR::X;
- using NR::Y;
GtkWidget const &w = *GTK_WIDGET(canvas);
- return ( ( canvas->x0 <= world[X] ) &&
- ( canvas->y0 <= world[Y] ) &&
- ( world[X] < canvas->x0 + w.allocation.width ) &&
- ( world[Y] < canvas->y0 + w.allocation.height ) );
+ return ( ( canvas->x0 <= world[Geom::X] ) &&
+ ( canvas->y0 <= world[Geom::Y] ) &&
+ ( world[Geom::X] < canvas->x0 + w.allocation.width ) &&
+ ( world[Geom::Y] < canvas->y0 + w.allocation.height ) );
}
/**
- * Return canvas window coordinates as NR::Rect.
+ * Return canvas window coordinates as Geom::Rect.
*/
-NR::Rect SPCanvas::getViewbox() const
+Geom::Rect SPCanvas::getViewbox() const
{
GtkWidget const *w = GTK_WIDGET(this);
+ return Geom::Rect(Geom::Point(dx0, dy0),
+ Geom::Point(dx0 + w->allocation.width, dy0 + w->allocation.height));
+}
- 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)
@@ -2319,4 +2538,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 :