Merge from branch

(bzr r11950.1.19)

10 files changed, 176 insertions, 134 deletions

diff --git a/src/display/cairo-utils.cpp b/src/display/cairo-utils.cpp
index 692e31837..8eeee0277 100644
--- a/src/display/cairo-utils.cpp
+++ b/src/display/cairo-utils.cpp
@@ -27,6 +27,17 @@
 #include "style.h"
 #include "helper/geom-curves.h"
 
+namespace {
+
+/**
+ * Key for cairo_surface_t to keep track of current color interpolation value
+ * Only the address of the structure is used, it is never initialized. See:
+ * http://www.cairographics.org/manual/cairo-Types.html#cairo-user-data-key-t
+ */
+cairo_user_data_key_t ci_key;
+
+} // namespace
+
 namespace Inkscape {
 
 CairoGroup::CairoGroup(cairo_t *_ct) : ct(_ct), pushed(false) {}
@@ -586,11 +597,11 @@ void ink_cairo_surface_average_color_premul(cairo_surface_t *surface, double &r,
     a = CLAMP(a, 0.0, 1.0);
 }
 
-void srgb_to_linear( guint32* c, guint32 a ) {
+static guint32 srgb_to_linear( const guint32 c, const guint32 a ) {
 
-    *c = unpremul_alpha( *c, a );
+    const guint32 c1 = unpremul_alpha( c, a );
 
-    double cc = *c/255.0;
+    double cc = c1/255.0;
 
     if( cc < 0.04045 ) {
         cc /= 12.92;
@@ -599,16 +610,16 @@ void srgb_to_linear( guint32* c, guint32 a ) {
     }
     cc *= 255.0;
 
-    *c = (int)cc;
+    const guint32 c2 = (int)cc;
 
-    *c = premul_alpha( *c, a );
+    return premul_alpha( c2, a );
 }
 
-void linear_to_srgb( guint32* c, guint32 a ) {
+static guint32 linear_to_srgb( const guint32 c, const guint32 a ) {
 
-    *c = unpremul_alpha( *c, a );
+    const guint32 c1 = unpremul_alpha( c, a );
 
-    double cc = *c/255.0;
+    double cc = c1/255.0;
 
     if( cc < 0.0031308 ) {
         cc *= 12.92;
@@ -617,9 +628,9 @@ void linear_to_srgb( guint32* c, guint32 a ) {
     }
     cc *= 255.0;
 
-    *c = (int)cc;
+    const guint32 c2 = (int)cc;
 
-    *c = premul_alpha( *c, a );
+    return premul_alpha( c2, a );
 }
 
 int ink_cairo_surface_srgb_to_linear(cairo_surface_t *surface)
@@ -636,9 +647,9 @@ int ink_cairo_surface_srgb_to_linear(cairo_surface_t *surface)
             guint32 px = *reinterpret_cast<guint32*>(data + 4*x);
             EXTRACT_ARGB32(px, a,r,g,b)    ; // Unneeded semi-colon for indenting
             if( a != 0 ) {
-                srgb_to_linear( &r, a );
-                srgb_to_linear( &g, a );
-                srgb_to_linear( &b, a );
+                r = srgb_to_linear( r, a );
+                g = srgb_to_linear( g, a );
+                b = srgb_to_linear( b, a );
             }
             ASSEMBLE_ARGB32(px2, a,r,g,b);
             *reinterpret_cast<guint32*>(data + 4*x) = px2;
@@ -661,9 +672,9 @@ int ink_cairo_surface_linear_to_srgb(cairo_surface_t *surface)
             guint32 px = *reinterpret_cast<guint32*>(data + 4*x);
             EXTRACT_ARGB32(px, a,r,g,b)    ; // Unneeded semi-colon for indenting
             if( a != 0 ) {
-                linear_to_srgb( &r, a );
-                linear_to_srgb( &g, a );
-                linear_to_srgb( &b, a );
+                r = linear_to_srgb( r, a );
+                g = linear_to_srgb( g, a );
+                b = linear_to_srgb( b, a );
             }
             ASSEMBLE_ARGB32(px2, a,r,g,b);
             *reinterpret_cast<guint32*>(data + 4*x) = px2;
diff --git a/src/display/cairo-utils.h b/src/display/cairo-utils.h
index e88c6d4e8..2596cd969 100644
--- a/src/display/cairo-utils.h
+++ b/src/display/cairo-utils.h
@@ -82,15 +82,6 @@ public:
 
 } // namespace Inkscape
 
-/**
- * Key for cairo_surface_t to keep track of current color interpolation value
- * Only the address of the structure is used, it is never initialized. See:
- * http://www.cairographics.org/manual/cairo-Types.html#cairo-user-data-key-t
- */
-// TODO fixme check this usage. A static here in a header file is probably not doing what was intended:
-static cairo_user_data_key_t ci_key;
-
-
 SPColorInterpolation get_cairo_surface_ci(cairo_surface_t *surface);
 void set_cairo_surface_ci(cairo_surface_t *surface, SPColorInterpolation cif);
 void copy_cairo_surface_ci(cairo_surface_t *in, cairo_surface_t *out);
@@ -117,6 +108,7 @@ guint32 ink_cairo_surface_average_color(cairo_surface_t *surface);
 void ink_cairo_surface_average_color(cairo_surface_t *surface, double &r, double &g, double &b, double &a);
 void ink_cairo_surface_average_color_premul(cairo_surface_t *surface, double &r, double &g, double &b, double &a);
 
+double srgb_to_linear( const double c );
 int ink_cairo_surface_srgb_to_linear(cairo_surface_t *surface);
 int ink_cairo_surface_linear_to_srgb(cairo_surface_t *surface);
 
@@ -136,13 +128,13 @@ G_GNUC_CONST guint32 argb32_from_rgba(guint32 in);
 
 
 G_GNUC_CONST inline guint32
-premul_alpha(guint32 color, guint32 alpha)
+premul_alpha(const guint32 color, const guint32 alpha)
 {
-    guint32 temp = alpha * color + 128;
+    const guint32 temp = alpha * color + 128;
     return (temp + (temp >> 8)) >> 8;
 }
 G_GNUC_CONST inline guint32
-unpremul_alpha(guint32 color, guint32 alpha)
+unpremul_alpha(const guint32 color, const guint32 alpha)
 {
     // NOTE: you must check for alpha != 0 yourself.
     return (255 * color + alpha/2) / alpha;
@@ -162,6 +154,15 @@ void feed_pathvector_to_cairo (cairo_t *ct, Geom::PathVector const &pathv);
 #define ASSEMBLE_ARGB32(px,a,r,g,b) \
     guint32 px = (a << 24) | (r << 16) | (g << 8) | b;
 
+inline double srgb_to_linear( const double c ) {
+    if( c < 0.04045 ) {
+        return c / 12.92;
+    } else {
+        return pow( (c+0.055)/1.055, 2.4 );
+    }
+}
+
+
 namespace Inkscape {
 
 namespace Display
diff --git a/src/display/drawing-item.cpp b/src/display/drawing-item.cpp
index 1e6e44d6f..80664d822 100644
--- a/src/display/drawing-item.cpp
+++ b/src/display/drawing-item.cpp
@@ -550,10 +550,12 @@ DrawingItem::render(DrawingContext &ct, Geom::IntRect const &area, unsigned flag
     // for overlapping clip children. To fix this we use the SOURCE operator
     // instead of the default OVER.
     ict.setOperator(CAIRO_OPERATOR_SOURCE);
+    ict.paint();
     if (_clip) {
+        ict.pushGroup();
         _clip->clip(ict, *carea); // fixme: carea or area?
-    } else {
-        // if there is no clipping path, fill the entire surface with alpha = opacity.
+        ict.popGroupToSource();
+        ict.setOperator(CAIRO_OPERATOR_IN);
         ict.paint();
     }
     ict.setOperator(CAIRO_OPERATOR_OVER); // reset back to default
diff --git a/src/display/nr-filter-diffuselighting.cpp b/src/display/nr-filter-diffuselighting.cpp
index faf56a4ca..c6724e3ba 100644
--- a/src/display/nr-filter-diffuselighting.cpp
+++ b/src/display/nr-filter-diffuselighting.cpp
@@ -21,6 +21,8 @@
 #include "display/nr-filter-units.h"
 #include "display/nr-filter-utils.h"
 #include "display/nr-light.h"
+#include "svg/svg-icc-color.h"
+#include "svg/svg-color.h"
 
 namespace Inkscape {
 namespace Filters {
@@ -126,12 +128,37 @@ void FilterDiffuseLighting::render_cairo(FilterSlot &slot)
     cairo_surface_t *input = slot.getcairo(_input);
     cairo_surface_t *out = ink_cairo_surface_create_same_size(input, CAIRO_CONTENT_COLOR_ALPHA);
 
+    double r = SP_RGBA32_R_F(lighting_color);
+    double g = SP_RGBA32_G_F(lighting_color);
+    double b = SP_RGBA32_B_F(lighting_color);
+
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+
+    if (icc) {
+        guchar ru, gu, bu;
+        icc_color_to_sRGB(icc, &ru, &gu, &bu);
+        r = SP_COLOR_U_TO_F(ru);
+        g = SP_COLOR_U_TO_F(gu);
+        b = SP_COLOR_U_TO_F(bu);
+    }
+#endif
+
     // Only alpha channel of input is used, no need to check input color_interpolation_filter value.
     SPColorInterpolation ci_fp  = SP_CSS_COLOR_INTERPOLATION_AUTO;
     if( _style ) {
         ci_fp = (SPColorInterpolation)_style->color_interpolation_filters.computed;
+
+        // Lighting color is always defined in terms of sRGB, preconvert to linearRGB
+        // if color_interpolation_filters set to linearRGB (for efficiency assuming
+        // next filter primitive has same value of cif).
+        if( ci_fp == SP_CSS_COLOR_INTERPOLATION_LINEARRGB ) {
+            r = srgb_to_linear( r );
+            g = srgb_to_linear( g );
+            b = srgb_to_linear( b );
+        }
     }
     set_cairo_surface_ci(out, ci_fp );
+    guint32 color = SP_RGBA32_F_COMPOSE( r, g, b, 1.0 ); 
 
     Geom::Rect slot_area = slot.get_slot_area();
     Geom::Point p = slot_area.min();
@@ -142,15 +169,15 @@ void FilterDiffuseLighting::render_cairo(FilterSlot &slot)
     switch (light_type) {
     case DISTANT_LIGHT:
         ink_cairo_surface_synthesize(out,
-            DiffuseDistantLight(input, light.distant, lighting_color, scale, diffuseConstant));
+            DiffuseDistantLight(input, light.distant, color, scale, diffuseConstant));
         break;
     case POINT_LIGHT:
         ink_cairo_surface_synthesize(out,
-            DiffusePointLight(input, light.point, lighting_color, trans, scale, diffuseConstant, x0, y0));
+            DiffusePointLight(input, light.point, color, trans, scale, diffuseConstant, x0, y0));
         break;
     case SPOT_LIGHT:
         ink_cairo_surface_synthesize(out,
-            DiffuseSpotLight(input, light.spot, lighting_color, trans, scale, diffuseConstant, x0, y0));
+            DiffuseSpotLight(input, light.spot, color, trans, scale, diffuseConstant, x0, y0));
         break;
     default: {
         cairo_t *ct = cairo_create(out);
@@ -165,6 +192,10 @@ void FilterDiffuseLighting::render_cairo(FilterSlot &slot)
     cairo_surface_destroy(out);
 }
 
+void FilterDiffuseLighting::set_icc(SVGICCColor *icc_color) {
+    icc = icc_color;
+}
+
 void FilterDiffuseLighting::area_enlarge(Geom::IntRect &area, Geom::Affine const & /*trans*/)
 {
     // TODO: support kernelUnitLength
diff --git a/src/display/nr-filter-diffuselighting.h b/src/display/nr-filter-diffuselighting.h
index 0da6cc218..315bf9f48 100644
--- a/src/display/nr-filter-diffuselighting.h
+++ b/src/display/nr-filter-diffuselighting.h
@@ -22,6 +22,7 @@
 class SPFeDistantLight;
 class SPFePointLight;
 class SPFeSpotLight;
+class SVGICCColor;
 
 namespace Inkscape {
 namespace Filters {
@@ -32,6 +33,7 @@ public:
     static FilterPrimitive *create();
     virtual ~FilterDiffuseLighting();
     virtual void render_cairo(FilterSlot &slot);
+    virtual void set_icc(SVGICCColor *icc_color);
     virtual void area_enlarge(Geom::IntRect &area, Geom::Affine const &trans);
     virtual double complexity(Geom::Affine const &ctm);
 
@@ -46,6 +48,7 @@ public:
     guint32 lighting_color;
 
 private:
+    SVGICCColor *icc;
 };
 
 } /* namespace Filters */
diff --git a/src/display/nr-filter-flood.cpp b/src/display/nr-filter-flood.cpp
index 7117e0343..d1fe3e13f 100644
--- a/src/display/nr-filter-flood.cpp
+++ b/src/display/nr-filter-flood.cpp
@@ -45,8 +45,6 @@ void FilterFlood::render_cairo(FilterSlot &slot)
 
 #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
 
-    // DOES THIS REALLY BELONG HERE? SHOULDN'T ICC BE APPLIED AFTER ALL COMPOSITING?
-    // What if color_interpolation_filter is set to linear RGB?
     if (icc) {
         guchar ru, gu, bu;
         icc_color_to_sRGB(icc, &ru, &gu, &bu);
@@ -57,10 +55,21 @@ void FilterFlood::render_cairo(FilterSlot &slot)
 #endif
 
     cairo_surface_t *out = ink_cairo_surface_create_same_size(input, CAIRO_CONTENT_COLOR_ALPHA);
-    // color_interpolation_filter is determined by CSS value (see spec. Turbulence).
+
+    SPColorInterpolation ci_fp  = SP_CSS_COLOR_INTERPOLATION_AUTO;
     if( _style ) {
-        set_cairo_surface_ci(out, (SPColorInterpolation)_style->color_interpolation_filters.computed );
+        ci_fp = (SPColorInterpolation)_style->color_interpolation_filters.computed;
+
+        // Flood color is always defined in terms of sRGB, preconvert to linearRGB
+        // if color_interpolation_filters set to linearRGB (for efficiency assuming
+        // next filter primitive has same value of cif).
+        if( ci_fp == SP_CSS_COLOR_INTERPOLATION_LINEARRGB ) {
+            r = srgb_to_linear( r );
+            g = srgb_to_linear( g );
+            b = srgb_to_linear( b );
+        }
     }
+    set_cairo_surface_ci(out, ci_fp );
 
     // Get filter primitive area in user units
     Geom::Rect fp = filter_primitive_area( slot.get_units() );
diff --git a/src/display/nr-filter-specularlighting.cpp b/src/display/nr-filter-specularlighting.cpp
index 50f1b48c5..2ce02adee 100644
--- a/src/display/nr-filter-specularlighting.cpp
+++ b/src/display/nr-filter-specularlighting.cpp
@@ -21,6 +21,8 @@
 #include "display/nr-filter-units.h"
 #include "display/nr-filter-utils.h"
 #include "display/nr-light.h"
+#include "svg/svg-icc-color.h"
+#include "svg/svg-color.h"
 
 namespace Inkscape {
 namespace Filters {
@@ -139,12 +141,37 @@ void FilterSpecularLighting::render_cairo(FilterSlot &slot)
     cairo_surface_t *input = slot.getcairo(_input);
     cairo_surface_t *out = ink_cairo_surface_create_same_size(input, CAIRO_CONTENT_COLOR_ALPHA);
 
+    double r = SP_RGBA32_R_F(lighting_color);
+    double g = SP_RGBA32_G_F(lighting_color);
+    double b = SP_RGBA32_B_F(lighting_color);
+
+#if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
+
+    if (icc) {
+        guchar ru, gu, bu;
+        icc_color_to_sRGB(icc, &ru, &gu, &bu);
+        r = SP_COLOR_U_TO_F(ru);
+        g = SP_COLOR_U_TO_F(gu);
+        b = SP_COLOR_U_TO_F(bu);
+    }
+#endif
+
     // Only alpha channel of input is used, no need to check input color_interpolation_filter value.
     SPColorInterpolation ci_fp  = SP_CSS_COLOR_INTERPOLATION_AUTO;
     if( _style ) {
         ci_fp = (SPColorInterpolation)_style->color_interpolation_filters.computed;
+
+        // Lighting color is always defined in terms of sRGB, preconvert to linearRGB
+        // if color_interpolation_filters set to linearRGB (for efficiency assuming
+        // next filter primitive has same value of cif).
+        if( ci_fp == SP_CSS_COLOR_INTERPOLATION_LINEARRGB ) {
+            r = srgb_to_linear( r );
+            g = srgb_to_linear( g );
+            b = srgb_to_linear( b );
+        }
     }
     set_cairo_surface_ci(out, ci_fp );
+    guint32 color = SP_RGBA32_F_COMPOSE( r, g, b, 1.0 ); 
 
     Geom::Affine trans = slot.get_units().get_matrix_primitiveunits2pb();
     Geom::Point p = slot.get_slot_area().min();
@@ -157,15 +184,15 @@ void FilterSpecularLighting::render_cairo(FilterSlot &slot)
     switch (light_type) {
     case DISTANT_LIGHT:
         ink_cairo_surface_synthesize(out,
-            SpecularDistantLight(input, light.distant, lighting_color, scale, ks, se));
+            SpecularDistantLight(input, light.distant, color, scale, ks, se));
         break;
     case POINT_LIGHT:
         ink_cairo_surface_synthesize(out,
-            SpecularPointLight(input, light.point, lighting_color, trans, scale, ks, se, x0, y0));
+            SpecularPointLight(input, light.point, color, trans, scale, ks, se, x0, y0));
         break;
     case SPOT_LIGHT:
         ink_cairo_surface_synthesize(out,
-            SpecularSpotLight(input, light.spot, lighting_color, trans, scale, ks, se, x0, y0));
+            SpecularSpotLight(input, light.spot, color, trans, scale, ks, se, x0, y0));
         break;
     default: {
         cairo_t *ct = cairo_create(out);
@@ -180,6 +207,10 @@ void FilterSpecularLighting::render_cairo(FilterSlot &slot)
     cairo_surface_destroy(out);
 }
 
+void FilterSpecularLighting::set_icc(SVGICCColor *icc_color) {
+    icc = icc_color;
+}
+
 void FilterSpecularLighting::area_enlarge(Geom::IntRect &area, Geom::Affine const & /*trans*/)
 {
     // TODO: support kernelUnitLength
diff --git a/src/display/nr-filter-specularlighting.h b/src/display/nr-filter-specularlighting.h
index 33ea17a87..4f8c2d112 100644
--- a/src/display/nr-filter-specularlighting.h
+++ b/src/display/nr-filter-specularlighting.h
@@ -20,6 +20,7 @@
 class SPFeDistantLight;
 class SPFePointLight;
 class SPFeSpotLight;
+class SVGICCColor;
 
 namespace Inkscape {
 namespace Filters {
@@ -33,6 +34,7 @@ public:
     virtual ~FilterSpecularLighting();
 
     virtual void render_cairo(FilterSlot &slot);
+    virtual void set_icc(SVGICCColor *icc_color);
     virtual void area_enlarge(Geom::IntRect &area, Geom::Affine const &trans);
     virtual double complexity(Geom::Affine const &ctm);
 
@@ -48,6 +50,7 @@ public:
     guint32 lighting_color;
 
 private:
+    SVGICCColor *icc;
 };
 
 } /* namespace Filters */
diff --git a/src/display/sp-canvas.cpp b/src/display/sp-canvas.cpp
index eb51860ab..8b20ab2de 100644
--- a/src/display/sp-canvas.cpp
+++ b/src/display/sp-canvas.cpp
@@ -227,21 +227,6 @@ public:
     static int pickCurrentItem(SPCanvas *canvas, GdkEvent *event);
 
     /**
-     * Class initialization function for SPCanvasClass.
-     */
-    static void classInit(SPCanvasClass *klass);
-
-    /**
-     * Callback: object initialization for SPCanvas.
-     */
-    static void init(SPCanvas *canvas);
-
-    /**
-     * Destroy handler for SPCanvas.
-     */
-    static void dispose(GObject *object);
-
-    /**
      * The canvas widget's realize callback.
      */
     static void realize(GtkWidget *widget);
@@ -369,25 +354,11 @@ public:
     static void add_idle(SPCanvas *canvas);
 
     /**
-     * Convenience function to remove the idle handler of a canvas.
-     */
-    static void remove_idle(SPCanvas *canvas);
-
-    /**
-     * Removes the transient state of the canvas (idle handler, grabs).
-     */
-    static void shutdown_transients(SPCanvas *canvas);
-
-    /**
      * Update callback for canvas widget.
      */
     static void requestCanvasUpdate(SPCanvas *canvas);
-
-    static GtkWidgetClass *parentClass;
 };
 
-GtkWidgetClass *SPCanvasImpl::parentClass = 0;
-
 GType SPCanvasItem::getType()
 {
     static GType object_type = 0;
@@ -437,9 +408,9 @@ void sp_canvas_item_class_init(SPCanvasItemClass *klass)
                                              G_TYPE_BOOLEAN, 1,
                                              GDK_TYPE_EVENT);
 
-    gobject_class->dispose = sp_canvas_item_dispose;
+    gobject_class->dispose  = sp_canvas_item_dispose;
     gobject_class->finalize = sp_canvas_item_finalize;
-    klass->destroy = sp_canvas_item_real_destroy;
+    klass->destroy          = sp_canvas_item_real_destroy;
   
     object_signals[DESTROY] =
       g_signal_new ("destroy",
@@ -1218,68 +1189,46 @@ void SPCanvasGroup::remove(SPCanvasItem *item)
     }
 }
 
-/**
- * Registers the SPCanvas class if necessary, and returns the type ID
- * associated to it.
- *
- * @return The type ID of the SPCanvas class.
- */
-GType SPCanvas::getType(void)
-{
-    static GType type = 0;
-    if (!type) {
-        GTypeInfo info = {
-            sizeof(SPCanvasClass),
-            0, // base_init
-            0, // base_finalize
-            (GClassInitFunc)SPCanvasImpl::classInit,
-            0, // class_finalize
-            0, // class_data
-            sizeof(SPCanvas),
-            0, // n_preallocs
-            (GInstanceInitFunc)SPCanvasImpl::init,
-            0 // value_table
-        };
-        type = g_type_register_static(GTK_TYPE_WIDGET, "SPCanvas", &info, static_cast<GTypeFlags>(0));
-    }
-    return type;
-}
+static void sp_canvas_dispose            (GObject  *object);
+static void sp_canvas_shutdown_transients(SPCanvas *canvas);
 
-void SPCanvasImpl::classInit(SPCanvasClass *klass)
-{
-    GObjectClass *object_class = (GObjectClass *) klass;
-    GtkWidgetClass *widget_class = (GtkWidgetClass *) klass;
+G_DEFINE_TYPE(SPCanvas, sp_canvas, GTK_TYPE_WIDGET);
 
-    parentClass = reinterpret_cast<GtkWidgetClass *>(g_type_class_peek_parent(klass));
+static void
+sp_canvas_class_init(SPCanvasClass *klass)
+{
+    GObjectClass   *object_class = G_OBJECT_CLASS(klass);
+    GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(klass);
 
-    object_class->dispose = SPCanvasImpl::dispose;
+    object_class->dispose = sp_canvas_dispose;
 
-    widget_class->realize = SPCanvasImpl::realize;
-    widget_class->unrealize = SPCanvasImpl::unrealize;
+    widget_class->realize              = SPCanvasImpl::realize;
+    widget_class->unrealize            = SPCanvasImpl::unrealize;
 
 #if GTK_CHECK_VERSION(3,0,0)
-    widget_class->get_preferred_width = SPCanvasImpl::getPreferredWidth;
+    widget_class->get_preferred_width  = SPCanvasImpl::getPreferredWidth;
     widget_class->get_preferred_height = SPCanvasImpl::getPreferredHeight;
-    widget_class->draw = SPCanvasImpl::handleDraw;
+    widget_class->draw                 = SPCanvasImpl::handleDraw;
 #else
-    widget_class->size_request = SPCanvasImpl::sizeRequest;
-    widget_class->expose_event = SPCanvasImpl::handleExpose;
+    widget_class->size_request         = SPCanvasImpl::sizeRequest;
+    widget_class->expose_event         = SPCanvasImpl::handleExpose;
 #endif
 
-    widget_class->size_allocate = SPCanvasImpl::sizeAllocate;
-    widget_class->button_press_event = SPCanvasImpl::button;
+    widget_class->size_allocate        = SPCanvasImpl::sizeAllocate;
+    widget_class->button_press_event   = SPCanvasImpl::button;
     widget_class->button_release_event = SPCanvasImpl::button;
-    widget_class->motion_notify_event = SPCanvasImpl::handleMotion;
-    widget_class->scroll_event = SPCanvasImpl::handleScroll;
-    widget_class->key_press_event = SPCanvasImpl::handleKeyEvent;
-    widget_class->key_release_event = SPCanvasImpl::handleKeyEvent;
-    widget_class->enter_notify_event = SPCanvasImpl::handleCrossing;
-    widget_class->leave_notify_event = SPCanvasImpl::handleCrossing;
-    widget_class->focus_in_event = SPCanvasImpl::handleFocusIn;
-    widget_class->focus_out_event = SPCanvasImpl::handleFocusOut;
+    widget_class->motion_notify_event  = SPCanvasImpl::handleMotion;
+    widget_class->scroll_event         = SPCanvasImpl::handleScroll;
+    widget_class->key_press_event      = SPCanvasImpl::handleKeyEvent;
+    widget_class->key_release_event    = SPCanvasImpl::handleKeyEvent;
+    widget_class->enter_notify_event   = SPCanvasImpl::handleCrossing;
+    widget_class->leave_notify_event   = SPCanvasImpl::handleCrossing;
+    widget_class->focus_in_event       = SPCanvasImpl::handleFocusIn;
+    widget_class->focus_out_event      = SPCanvasImpl::handleFocusOut;
 }
 
-void SPCanvasImpl::init(SPCanvas *canvas)
+static void
+sp_canvas_init(SPCanvas *canvas)
 {
     gtk_widget_set_has_window (GTK_WIDGET (canvas), TRUE);
     gtk_widget_set_double_buffered (GTK_WIDGET (canvas), FALSE);
@@ -1318,7 +1267,7 @@ void SPCanvasImpl::init(SPCanvas *canvas)
     canvas->is_scrolling = false;
 }
 
-void SPCanvasImpl::remove_idle(SPCanvas *canvas)
+static void sp_canvas_remove_idle(SPCanvas *canvas)
 {
     if (canvas->idle_id) {
         g_source_remove (canvas->idle_id);
@@ -1326,7 +1275,8 @@ void SPCanvasImpl::remove_idle(SPCanvas *canvas)
     }
 }
 
-void SPCanvasImpl::shutdown_transients(SPCanvas *canvas)
+static void
+sp_canvas_shutdown_transients(SPCanvas *canvas)
 {
     // We turn off the need_redraw flag, since if the canvas is mapped again
     // it will request a redraw anyways.  We do not turn off the need_update
@@ -1352,10 +1302,11 @@ void SPCanvasImpl::shutdown_transients(SPCanvas *canvas)
 #endif
     }
 
-    remove_idle(canvas);
+    sp_canvas_remove_idle(canvas);
 }
 
-void SPCanvasImpl::dispose(GObject *object)
+static void
+sp_canvas_dispose(GObject *object)
 {
     SPCanvas *canvas = SP_CANVAS(object);
 
@@ -1364,12 +1315,12 @@ void SPCanvasImpl::dispose(GObject *object)
         canvas->root = NULL;
     }
 
-    shutdown_transients(canvas);
+    sp_canvas_shutdown_transients(canvas);
 #if defined(HAVE_LIBLCMS1) || defined(HAVE_LIBLCMS2)
     canvas->cms_key.~ustring();
 #endif
-    if (G_OBJECT_CLASS(parentClass)->dispose) {
-        (* G_OBJECT_CLASS(parentClass)->dispose)(object);
+    if (G_OBJECT_CLASS(sp_canvas_parent_class)->dispose) {
+        (* G_OBJECT_CLASS(sp_canvas_parent_class)->dispose)(object);
     }
 }
 
@@ -1388,7 +1339,7 @@ void trackLatency(GdkEvent const *event)
 
 GtkWidget *SPCanvas::createAA()
 {
-    SPCanvas *canvas = reinterpret_cast<SPCanvas *>(g_object_new(SPCanvas::getType(), NULL));
+    SPCanvas *canvas = SP_CANVAS(g_object_new(SP_TYPE_CANVAS, NULL));
     return GTK_WIDGET(canvas);
 }
 
@@ -1456,10 +1407,10 @@ void SPCanvasImpl::unrealize(GtkWidget *widget)
     canvas->grabbed_item = NULL;
     canvas->focused_item = NULL;
 
-    shutdown_transients(canvas);
+    sp_canvas_shutdown_transients(canvas);
 
-    if (GTK_WIDGET_CLASS(parentClass)->unrealize)
-        (* GTK_WIDGET_CLASS(parentClass)->unrealize)(widget);
+    if (GTK_WIDGET_CLASS(sp_canvas_parent_class)->unrealize)
+        (* GTK_WIDGET_CLASS(sp_canvas_parent_class)->unrealize)(widget);
 }
 
 
diff --git a/src/display/sp-canvas.h b/src/display/sp-canvas.h
index f0366a2e5..b570b739e 100644
--- a/src/display/sp-canvas.h
+++ b/src/display/sp-canvas.h
@@ -39,7 +39,7 @@
 
 G_BEGIN_DECLS
 
-#define SP_TYPE_CANVAS (SPCanvas::getType())
+#define SP_TYPE_CANVAS (sp_canvas_get_type())
 #define SP_CANVAS(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), SP_TYPE_CANVAS, SPCanvas))
 #define SP_IS_CANVAS(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), SP_TYPE_CANVAS))
 
@@ -71,14 +71,14 @@ G_END_DECLS
 
 class SPCanvasImpl;
 
+GType sp_canvas_get_type() G_GNUC_CONST;
+
 /**
  * Port of GnomeCanvas for inkscape needs.
  */
 struct SPCanvas {
     friend class SPCanvasImpl;
 
-    static GType getType();
-
     /**
      * Returns new canvas as widget.
      */