Trunk merge

(bzr r11073.1.15)

7 files changed, 221 insertions, 148 deletions

diff --git a/src/display/canvas-grid.cpp b/src/display/canvas-grid.cpp
index 1cc6e72ed..92a1b0fb8 100644
--- a/src/display/canvas-grid.cpp
+++ b/src/display/canvas-grid.cpp
@@ -311,7 +311,7 @@ CanvasGrid::createCanvasItem(SPDesktop * desktop)
     item->grid = this;
     sp_canvas_item_show(SP_CANVAS_ITEM(item));
 
-    gtk_object_ref(GTK_OBJECT(item));    // since we're keeping a link to this item, we need to bump up the ref count
+    g_object_ref(item);    // since we're keeping a link to this item, we need to bump up the ref count
     canvasitems = g_slist_prepend(canvasitems, item);
 
     return item;
diff --git a/src/display/nr-filter-merge.cpp b/src/display/nr-filter-merge.cpp
index 28ac19a19..f1fbd7d33 100644
--- a/src/display/nr-filter-merge.cpp
+++ b/src/display/nr-filter-merge.cpp
@@ -74,7 +74,7 @@ double FilterMerge::complexity(Geom::Affine const &)
 
 bool FilterMerge::uses_background()
 {
-    for (int i = 0; i < _input_image.size(); ++i) {
+    for (unsigned int i = 0; i < _input_image.size(); ++i) {
         int input = _input_image[i];
         if (input == NR_FILTER_BACKGROUNDIMAGE || input == NR_FILTER_BACKGROUNDALPHA) {
             return true;
diff --git a/src/display/snap-indicator.cpp b/src/display/snap-indicator.cpp
index d5b8ce07f..1dd3022c7 100644
--- a/src/display/snap-indicator.cpp
+++ b/src/display/snap-indicator.cpp
@@ -23,6 +23,7 @@
 #include "preferences.h"
 #include <glibmm/i18n.h>
 #include "tools-switch.h"
+#include "enums.h"
 
 namespace Inkscape {
 namespace Display {
@@ -245,7 +246,7 @@ SnapIndicator::set_new_snaptarget(Inkscape::SnappedPoint const &p, bool pre_snap
         SPCanvasItem * canvasitem = NULL;
         canvasitem = sp_canvas_item_new(sp_desktop_tempgroup (_desktop),
                                         SP_TYPE_CTRL,
-                                        "anchor", GTK_ANCHOR_CENTER,
+                                        "anchor", SP_ANCHOR_CENTER,
                                         "size", 10.0,
                                         "stroked", TRUE,
                                         "stroke_color", pre_snap ? 0x7f7f7fff : 0xff0000ff,
@@ -345,7 +346,7 @@ SnapIndicator::set_new_snapsource(Inkscape::SnapCandidatePoint const &p)
     if (value) {
         SPCanvasItem * canvasitem = sp_canvas_item_new( sp_desktop_tempgroup (_desktop),
                                                         SP_TYPE_CTRL,
-                                                        "anchor", GTK_ANCHOR_CENTER,
+                                                        "anchor", SP_ANCHOR_CENTER,
                                                         "size", 6.0,
                                                         "stroked", TRUE,
                                                         "stroke_color", 0xff0000ff,
@@ -364,7 +365,7 @@ SnapIndicator::set_new_debugging_point(Geom::Point const &p)
     g_assert(_desktop != NULL);
     SPCanvasItem * canvasitem = sp_canvas_item_new( sp_desktop_tempgroup (_desktop),
                                                     SP_TYPE_CTRL,
-                                                    "anchor", GTK_ANCHOR_CENTER,
+                                                    "anchor", SP_ANCHOR_CENTER,
                                                     "size", 10.0,
                                                     "fill_color", 0x00ff00ff,
                                                     "stroked", FALSE,
diff --git a/src/display/sodipodi-ctrl.cpp b/src/display/sodipodi-ctrl.cpp
index 1380b491a..725ead0d6 100644
--- a/src/display/sodipodi-ctrl.cpp
+++ b/src/display/sodipodi-ctrl.cpp
@@ -29,14 +29,13 @@ enum {
 static void sp_ctrl_class_init (SPCtrlClass *klass);
 static void sp_ctrl_init (SPCtrl *ctrl);
 static void sp_ctrl_destroy (GtkObject *object);
-static void sp_ctrl_set_arg (GtkObject *object, GtkArg *arg, guint arg_id);
-
+static void sp_ctrl_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
+static void sp_ctrl_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
 static void sp_ctrl_update (SPCanvasItem *item, Geom::Affine const &affine, unsigned int flags);
 static void sp_ctrl_render (SPCanvasItem *item, SPCanvasBuf *buf);
 
 static double sp_ctrl_point (SPCanvasItem *item, Geom::Point p, SPCanvasItem **actual_item);
 
-
 static SPCanvasItemClass *parent_class;
 
 GType
@@ -66,24 +65,36 @@ sp_ctrl_class_init (SPCtrlClass *klass)
 {
     GtkObjectClass *object_class;
     SPCanvasItemClass *item_class;
+    GObjectClass *g_object_class;
 
     object_class = (GtkObjectClass *) klass;
     item_class = (SPCanvasItemClass *) klass;
+    g_object_class = (GObjectClass *) klass;
 
     parent_class = (SPCanvasItemClass *)g_type_class_peek_parent (klass);
 
-    gtk_object_add_arg_type ("SPCtrl::shape", G_TYPE_INT, G_PARAM_READWRITE, ARG_SHAPE);
-    gtk_object_add_arg_type ("SPCtrl::mode", G_TYPE_INT, G_PARAM_READWRITE, ARG_MODE);
-    gtk_object_add_arg_type ("SPCtrl::anchor", GTK_TYPE_ANCHOR_TYPE, G_PARAM_READWRITE, ARG_ANCHOR);
-    gtk_object_add_arg_type ("SPCtrl::size", G_TYPE_DOUBLE, G_PARAM_READWRITE, ARG_SIZE);
-    gtk_object_add_arg_type ("SPCtrl::pixbuf", G_TYPE_POINTER, G_PARAM_READWRITE, ARG_PIXBUF);
-    gtk_object_add_arg_type ("SPCtrl::filled", G_TYPE_BOOLEAN, G_PARAM_READWRITE, ARG_FILLED);
-    gtk_object_add_arg_type ("SPCtrl::fill_color", G_TYPE_INT, G_PARAM_READWRITE, ARG_FILL_COLOR);
-    gtk_object_add_arg_type ("SPCtrl::stroked", G_TYPE_BOOLEAN, G_PARAM_READWRITE, ARG_STROKED);
-    gtk_object_add_arg_type ("SPCtrl::stroke_color", G_TYPE_INT, G_PARAM_READWRITE, ARG_STROKE_COLOR);
-
+    g_object_class->set_property = sp_ctrl_set_property;
+    g_object_class->get_property = sp_ctrl_get_property;
     object_class->destroy = sp_ctrl_destroy;
-    object_class->set_arg = sp_ctrl_set_arg;
+
+    g_object_class_install_property (g_object_class,
+            ARG_SHAPE, g_param_spec_int ("shape", "shape", "Shape", 0, G_MAXINT, SP_CTRL_SHAPE_SQUARE, (GParamFlags) G_PARAM_READWRITE));
+    g_object_class_install_property (g_object_class,
+            ARG_MODE, g_param_spec_int ("mode", "mode", "Mode", 0, G_MAXINT, SP_CTRL_MODE_COLOR, (GParamFlags) G_PARAM_READWRITE));
+    g_object_class_install_property (g_object_class,
+            ARG_ANCHOR, g_param_spec_int ("anchor", "anchor", "Anchor", 0, G_MAXINT, SP_ANCHOR_CENTER, (GParamFlags) G_PARAM_READWRITE));
+    g_object_class_install_property (g_object_class,
+            ARG_SIZE, g_param_spec_double ("size", "size", "Size", 0.0, G_MAXDOUBLE, 8.0, (GParamFlags) G_PARAM_READWRITE));
+    g_object_class_install_property (g_object_class,
+            ARG_PIXBUF, g_param_spec_pointer ("pixbuf", "pixbuf", "Pixbuf", (GParamFlags) G_PARAM_READWRITE));
+    g_object_class_install_property (g_object_class,
+            ARG_FILLED, g_param_spec_boolean ("filled", "filled", "Filled", TRUE, (GParamFlags) G_PARAM_READWRITE));
+    g_object_class_install_property (g_object_class,
+            ARG_FILL_COLOR, g_param_spec_int ("fill_color", "fill_color", "Fill Color", G_MININT, G_MAXINT, 0x000000ff, (GParamFlags) G_PARAM_READWRITE));
+    g_object_class_install_property (g_object_class,
+            ARG_STROKED, g_param_spec_boolean ("stroked", "stroked", "Stroked", FALSE, (GParamFlags) G_PARAM_READWRITE));
+    g_object_class_install_property (g_object_class,
+            ARG_STROKE_COLOR, g_param_spec_int ("stroke_color", "stroke_color", "Stroke Color", G_MININT, G_MAXINT, 0x000000ff, (GParamFlags) G_PARAM_READWRITE));
 
     item_class->update = sp_ctrl_update;
     item_class->render = sp_ctrl_render;
@@ -91,55 +102,9 @@ sp_ctrl_class_init (SPCtrlClass *klass)
 }
 
 static void
-sp_ctrl_init (SPCtrl *ctrl)
-{
-    ctrl->shape = SP_CTRL_SHAPE_SQUARE;
-    ctrl->mode = SP_CTRL_MODE_COLOR;
-    ctrl->anchor = GTK_ANCHOR_CENTER;
-    ctrl->span = 3;
-    ctrl->defined = TRUE;
-    ctrl->shown = FALSE;
-    ctrl->build = FALSE;
-    ctrl->filled = 1;
-    ctrl->stroked = 0;
-    ctrl->fill_color = 0x000000ff;
-    ctrl->stroke_color = 0x000000ff;
-
-    // This way we make sure that the first sp_ctrl_update() call finishes properly;
-    // in subsequent calls it will not update anything it the control hasn't moved
-    // Consider for example the case in which a snap indicator is drawn at (0, 0);
-    // If moveto() is called then it will not set _moved to true because we're initially already at (0, 0)
-    ctrl->_moved = true; // Is this flag ever going to be set back to false? I can't find where that is supposed to happen
-
-    new (&ctrl->box) Geom::IntRect(0,0,0,0);
-    ctrl->cache = NULL;
-    ctrl->pixbuf = NULL;
-
-    ctrl->_point = Geom::Point(0,0);
-}
-
-static void
-sp_ctrl_destroy (GtkObject *object)
+sp_ctrl_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
 {
-    SPCtrl *ctrl;
-
-    g_return_if_fail (object != NULL);
-    g_return_if_fail (SP_IS_CTRL (object));
-
-    ctrl = SP_CTRL (object);
 
-    if (ctrl->cache) {
-        delete[] ctrl->cache;
-        ctrl->cache = NULL;
-    }
-
-    if (GTK_OBJECT_CLASS (parent_class)->destroy)
-        (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
-}
-
-static void
-sp_ctrl_set_arg (GtkObject *object, GtkArg *arg, guint arg_id)
-{
     SPCanvasItem *item;
     SPCtrl *ctrl;
     GdkPixbuf * pixbuf = NULL;
@@ -147,75 +112,182 @@ sp_ctrl_set_arg (GtkObject *object, GtkArg *arg, guint arg_id)
     item = SP_CANVAS_ITEM (object);
     ctrl = SP_CTRL (object);
 
-    switch (arg_id) {
-        case ARG_SHAPE:
-            ctrl->shape = (SPCtrlShapeType)(GTK_VALUE_INT (*arg));
+    switch (prop_id) {
+        case ARG_SHAPE: {
+            ctrl->shape = (SPCtrlShapeType) g_value_get_int(value);
             ctrl->build = FALSE;
-            sp_canvas_item_request_update (item);
+            sp_canvas_item_request_update(item);
+            }
             break;
 
-        case ARG_MODE:
-            ctrl->mode = (SPCtrlModeType)(GTK_VALUE_INT (*arg));
+        case ARG_MODE: {
+            ctrl->mode = (SPCtrlModeType) g_value_get_int(value);
             ctrl->build = FALSE;
-            sp_canvas_item_request_update (item);
+            sp_canvas_item_request_update(item);
+            }
             break;
 
-        case ARG_ANCHOR:
-            ctrl->anchor = (GtkAnchorType)(GTK_VALUE_INT (*arg));
+        case ARG_ANCHOR: {
+            ctrl->anchor = (SPAnchorType) g_value_get_int(value);
             ctrl->build = FALSE;
-            sp_canvas_item_request_update (item);
+            sp_canvas_item_request_update(item);
+            }
             break;
 
-        case ARG_SIZE:
-            ctrl->span = (gint) ((GTK_VALUE_DOUBLE (*arg) - 1.0) / 2.0 + 0.5);
+        case ARG_SIZE: {
+            ctrl->span = (gint)((g_value_get_double(value) - 1.0) / 2.0 + 0.5);
             ctrl->defined = (ctrl->span > 0);
             ctrl->build = FALSE;
-            sp_canvas_item_request_update (item);
+            sp_canvas_item_request_update(item);
+            }
             break;
 
-        case ARG_FILLED:
-            ctrl->filled = GTK_VALUE_BOOL (*arg);
+        case ARG_FILLED: {
+            ctrl->filled = g_value_get_boolean(value);
             ctrl->build = FALSE;
-            sp_canvas_item_request_update (item);
+            sp_canvas_item_request_update(item);
+            }
             break;
 
         case ARG_FILL_COLOR: {
-            guint32 fill = GTK_VALUE_INT (*arg);
+            guint32 fill = g_value_get_int(value);
             ctrl->fill_color = fill;
             ctrl->build = FALSE;
-            sp_canvas_item_request_update (item);
-            } break;
+            sp_canvas_item_request_update(item);
+            }
+            break;
 
-        case ARG_STROKED:
-            ctrl->stroked = GTK_VALUE_BOOL (*arg);
+        case ARG_STROKED: {
+            ctrl->stroked = g_value_get_boolean(value);
             ctrl->build = FALSE;
-            sp_canvas_item_request_update (item);
+            sp_canvas_item_request_update(item);
+            }
             break;
 
         case ARG_STROKE_COLOR: {
-            guint32 stroke = GTK_VALUE_INT (*arg);
+            guint32 stroke = g_value_get_int(value);
             ctrl->stroke_color = stroke;
             ctrl->build = FALSE;
-            sp_canvas_item_request_update (item);
-            } break;
+            sp_canvas_item_request_update(item);
+            }
+            break;
 
-        case ARG_PIXBUF:
-            pixbuf  = (GdkPixbuf*)(GTK_VALUE_POINTER (*arg));
-            if (gdk_pixbuf_get_has_alpha (pixbuf)) {
+        case ARG_PIXBUF: {
+            pixbuf = (GdkPixbuf*) g_value_get_pointer(value);
+            if (gdk_pixbuf_get_has_alpha(pixbuf)) {
                 ctrl->pixbuf = pixbuf;
             } else {
-                ctrl->pixbuf = gdk_pixbuf_add_alpha (pixbuf, FALSE, 0, 0, 0);
-                gdk_pixbuf_unref (pixbuf);
+                ctrl->pixbuf = gdk_pixbuf_add_alpha(pixbuf, FALSE, 0, 0, 0);
+                g_object_unref(pixbuf);
             }
             ctrl->build = FALSE;
+            }
             break;
 
         default:
+            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
             break;
     }
 }
 
 static void
+sp_ctrl_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
+{
+    SPCtrl *ctrl;
+    ctrl = SP_CTRL (object);
+
+    switch (prop_id) {
+
+        case ARG_SHAPE:
+            g_value_set_int(value, ctrl->shape);
+            break;
+
+        case ARG_MODE:
+            g_value_set_int(value, ctrl->mode);
+            break;
+
+        case ARG_ANCHOR:
+            g_value_set_int(value, ctrl->anchor);
+            break;
+
+        case ARG_SIZE:
+            g_value_set_double(value, ctrl->span);
+            break;
+
+        case ARG_FILLED:
+            g_value_set_boolean(value, ctrl->filled);
+            break;
+
+        case ARG_FILL_COLOR:
+        	g_value_set_int(value, ctrl->fill_color);
+            break;
+
+        case ARG_STROKED:
+            g_value_set_boolean(value, ctrl->stroked);
+            break;
+
+        case ARG_STROKE_COLOR:
+            g_value_set_int(value, ctrl->stroke_color);
+            break;
+
+        case ARG_PIXBUF:
+            g_value_set_pointer(value, ctrl->pixbuf);
+            break;
+
+        default:
+            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+            break;
+    }
+
+}
+static void
+sp_ctrl_init (SPCtrl *ctrl)
+{
+    ctrl->shape = SP_CTRL_SHAPE_SQUARE;
+    ctrl->mode = SP_CTRL_MODE_COLOR;
+    ctrl->anchor = SP_ANCHOR_CENTER;
+    ctrl->span = 3;
+    ctrl->defined = TRUE;
+    ctrl->shown = FALSE;
+    ctrl->build = FALSE;
+    ctrl->filled = 1;
+    ctrl->stroked = 0;
+    ctrl->fill_color = 0x000000ff;
+    ctrl->stroke_color = 0x000000ff;
+
+    // This way we make sure that the first sp_ctrl_update() call finishes properly;
+    // in subsequent calls it will not update anything it the control hasn't moved
+    // Consider for example the case in which a snap indicator is drawn at (0, 0);
+    // If moveto() is called then it will not set _moved to true because we're initially already at (0, 0)
+    ctrl->_moved = true; // Is this flag ever going to be set back to false? I can't find where that is supposed to happen
+
+    new (&ctrl->box) Geom::IntRect(0,0,0,0);
+    ctrl->cache = NULL;
+    ctrl->pixbuf = NULL;
+
+    ctrl->_point = Geom::Point(0,0);
+}
+
+static void
+sp_ctrl_destroy (GtkObject *object)
+{
+    SPCtrl *ctrl;
+
+    g_return_if_fail (object != NULL);
+    g_return_if_fail (SP_IS_CTRL (object));
+
+    ctrl = SP_CTRL (object);
+
+    if (ctrl->cache) {
+        delete[] ctrl->cache;
+        ctrl->cache = NULL;
+    }
+
+    if (GTK_OBJECT_CLASS (parent_class)->destroy)
+        (* GTK_OBJECT_CLASS (parent_class)->destroy) (object);
+}
+
+static void
 sp_ctrl_update (SPCanvasItem *item, Geom::Affine const &affine, unsigned int flags)
 {
     SPCtrl *ctrl;
@@ -240,39 +312,39 @@ sp_ctrl_update (SPCanvasItem *item, Geom::Affine const &affine, unsigned int fla
     y = (gint) ((affine[5] > 0) ? (affine[5] + 0.5) : (affine[5] - 0.5)) - ctrl->span;
 
     switch (ctrl->anchor) {
-        case GTK_ANCHOR_N:
-        case GTK_ANCHOR_CENTER:
-        case GTK_ANCHOR_S:
+        case SP_ANCHOR_N:
+        case SP_ANCHOR_CENTER:
+        case SP_ANCHOR_S:
             break;
 
-        case GTK_ANCHOR_NW:
-        case GTK_ANCHOR_W:
-        case GTK_ANCHOR_SW:
+        case SP_ANCHOR_NW:
+        case SP_ANCHOR_W:
+        case SP_ANCHOR_SW:
             x += ctrl->span;
             break;
 
-        case GTK_ANCHOR_NE:
-        case GTK_ANCHOR_E:
-        case GTK_ANCHOR_SE:
+        case SP_ANCHOR_NE:
+        case SP_ANCHOR_E:
+        case SP_ANCHOR_SE:
             x -= (ctrl->span + 1);
             break;
     }
 
     switch (ctrl->anchor) {
-        case GTK_ANCHOR_W:
-        case GTK_ANCHOR_CENTER:
-        case GTK_ANCHOR_E:
+        case SP_ANCHOR_W:
+        case SP_ANCHOR_CENTER:
+        case SP_ANCHOR_E:
             break;
 
-        case GTK_ANCHOR_NW:
-        case GTK_ANCHOR_N:
-        case GTK_ANCHOR_NE:
+        case SP_ANCHOR_NW:
+        case SP_ANCHOR_N:
+        case SP_ANCHOR_NE:
             y += ctrl->span;
             break;
 
-        case GTK_ANCHOR_SW:
-        case GTK_ANCHOR_S:
-        case GTK_ANCHOR_SE:
+        case SP_ANCHOR_SW:
+        case SP_ANCHOR_S:
+        case SP_ANCHOR_SE:
             y -= (ctrl->span + 1);
             break;
     }
diff --git a/src/display/sodipodi-ctrl.h b/src/display/sodipodi-ctrl.h
index 2617e7db2..cd0fcadf1 100644
--- a/src/display/sodipodi-ctrl.h
+++ b/src/display/sodipodi-ctrl.h
@@ -7,9 +7,9 @@
  *
  */
 
-#include <gtk/gtk.h>
 #include <gdk-pixbuf/gdk-pixbuf.h>
 #include "sp-canvas-item.h"
+#include "enums.h"
 
 
 #define SP_TYPE_CTRL            (sp_ctrl_get_type ())
@@ -36,7 +36,7 @@ typedef enum {
 struct SPCtrl : public SPCanvasItem {
     SPCtrlShapeType shape;
     SPCtrlModeType mode;
-    GtkAnchorType anchor;
+    SPAnchorType anchor;
     gint span;
     guint defined : 1;
     guint shown   : 1;
diff --git a/src/display/sp-canvas-item.h b/src/display/sp-canvas-item.h
index c70a4e241..0a6d343b2 100644
--- a/src/display/sp-canvas-item.h
+++ b/src/display/sp-canvas-item.h
@@ -54,6 +54,11 @@ struct SPCanvasItem : public GtkObject {
     double x1, y1, x2, y2;
     Geom::Rect bounds;
     Geom::Affine xform;
+    
+    // Replacement for custom GtkObject flag enumeration
+    gboolean visible;
+    gboolean need_update;
+    gboolean need_affine;
 };
 
 /**
diff --git a/src/display/sp-canvas.cpp b/src/display/sp-canvas.cpp
index 11836baa2..0f650bf4a 100644
--- a/src/display/sp-canvas.cpp
+++ b/src/display/sp-canvas.cpp
@@ -140,11 +140,6 @@ GdkWindow *getWindow(SPCanvas *canvas)
     return gtk_widget_get_window(reinterpret_cast<GtkWidget *>(canvas));
 }
 
-enum {
-    SP_CANVAS_ITEM_VISIBLE = 1 << 7,
-    SP_CANVAS_ITEM_NEED_UPDATE = 1 << 8,
-    SP_CANVAS_ITEM_NEED_AFFINE = 1 << 9
-};
 
 // SPCanvasItem
 
@@ -413,7 +408,7 @@ void sp_canvas_item_init(SPCanvasItem *item)
     // TODO items should not be visible on creation - this causes kludges with items
     // that should be initially invisible; examples of such items: node handles, the CtrlRect
     // used for rubberbanding, path outline, etc.
-    item->flags |= SP_CANVAS_ITEM_VISIBLE;
+    item->visible = TRUE;
     item->xform = Geom::Affine(Geom::identity());
 }
 
@@ -463,7 +458,7 @@ void sp_canvas_item_construct(SPCanvasItem *item, SPCanvasGroup *parent, gchar c
  */
 static void redraw_if_visible(SPCanvasItem *item)
 {
-    if (item->flags & SP_CANVAS_ITEM_VISIBLE) {
+    if(item->visible) {
         int x0 = (int)(item->x1);
         int x1 = (int)(item->x2);
         int y0 = (int)(item->y1);
@@ -490,7 +485,7 @@ void sp_canvas_item_dispose(GObject *object)
     } else {
         redraw_if_visible (item);
     }
-    item->flags &= ~SP_CANVAS_ITEM_VISIBLE;
+    item->visible = FALSE;
 
     if (item == item->canvas->current_item) {
         item->canvas->current_item = NULL;
@@ -533,11 +528,11 @@ static void sp_canvas_item_invoke_update(SPCanvasItem *item, Geom::Affine const
     // apply object flags to child flags
     int child_flags = flags & ~SP_CANVAS_UPDATE_REQUESTED;
 
-    if (item->flags & SP_CANVAS_ITEM_NEED_UPDATE) {
+    if(item->need_update) {
         child_flags |= SP_CANVAS_UPDATE_REQUESTED;
     }
 
-    if (item->flags & SP_CANVAS_ITEM_NEED_AFFINE) {
+    if(item->need_affine) {
         child_flags |= SP_CANVAS_UPDATE_AFFINE;
     }
 
@@ -547,8 +542,8 @@ static void sp_canvas_item_invoke_update(SPCanvasItem *item, Geom::Affine const
         }
     }
 
-    GTK_OBJECT_UNSET_FLAGS (item, SP_CANVAS_ITEM_NEED_UPDATE);
-    GTK_OBJECT_UNSET_FLAGS (item, SP_CANVAS_ITEM_NEED_AFFINE);
+    item->need_update = FALSE;
+    item->need_affine = FALSE;
 }
 
 /**
@@ -578,8 +573,8 @@ void sp_canvas_item_affine_absolute(SPCanvasItem *item, Geom::Affine const &affi
 {
     item->xform = affine;
 
-    if (!(item->flags & SP_CANVAS_ITEM_NEED_AFFINE)) {
-        item->flags |= SP_CANVAS_ITEM_NEED_AFFINE;
+    if (!item->need_affine) {
+        item->need_affine = TRUE;
         if (item->parent != NULL) {
             sp_canvas_item_request_update (item->parent);
         } else {
@@ -726,7 +721,7 @@ void sp_canvas_item_lower(SPCanvasItem *item, int positions)
 
 bool sp_canvas_item_is_visible(SPCanvasItem *item)
 {
-    return item->flags & SP_CANVAS_ITEM_VISIBLE;
+	return item->visible;
 }
 
 
@@ -738,11 +733,11 @@ void sp_canvas_item_show(SPCanvasItem *item)
     g_return_if_fail (item != NULL);
     g_return_if_fail (SP_IS_CANVAS_ITEM (item));
 
-    if (item->flags & SP_CANVAS_ITEM_VISIBLE) {
+    if (item->visible) {
         return;
     }
 
-    item->flags |= SP_CANVAS_ITEM_VISIBLE;
+    item->visible = TRUE;
 
     int x0 = (int)(item->x1);
     int x1 = (int)(item->x2);
@@ -763,11 +758,11 @@ void sp_canvas_item_hide(SPCanvasItem *item)
     g_return_if_fail (item != NULL);
     g_return_if_fail (SP_IS_CANVAS_ITEM (item));
 
-    if (!(item->flags & SP_CANVAS_ITEM_VISIBLE)) {
+    if (!item->visible) {
         return;
     }
 
-    item->flags &= ~SP_CANVAS_ITEM_VISIBLE;
+    item->visible = FALSE;
 
     int x0 = (int)(item->x1);
     int x1 = (int)(item->x2);
@@ -882,11 +877,11 @@ bool is_descendant(SPCanvasItem const *item, SPCanvasItem const *parent)
  */
 void sp_canvas_item_request_update(SPCanvasItem *item)
 {
-    if (item->flags & SP_CANVAS_ITEM_NEED_UPDATE) {
+    if (item->need_update) {
         return;
     }
 
-    item->flags |= SP_CANVAS_ITEM_NEED_UPDATE;
+    item->need_update = TRUE;
 
     if (item->parent != NULL) {
         // Recurse up the tree
@@ -1020,7 +1015,7 @@ double SPCanvasGroup::point(SPCanvasItem *item, Geom::Point p, SPCanvasItem **ac
             SPCanvasItem *point_item = NULL; // cater for incomplete item implementations
 
             int has_point;
-            if ((child->flags & SP_CANVAS_ITEM_VISIBLE) && SP_CANVAS_ITEM_GET_CLASS (child)->point) {
+            if (child->visible && SP_CANVAS_ITEM_GET_CLASS (child)->point) {
                 dist = sp_canvas_item_invoke_point (child, p, &point_item);
                 has_point = TRUE;
             } else {
@@ -1049,7 +1044,7 @@ void SPCanvasGroup::render(SPCanvasItem *item, SPCanvasBuf *buf)
 
     for (GList *list = group->items; list; list = list->next) {
         SPCanvasItem *child = (SPCanvasItem *)list->data;
-        if (child->flags & SP_CANVAS_ITEM_VISIBLE) {
+        if (child->visible) {
             if ((child->x1 < buf->rect.right()) &&
                 (child->y1 < buf->rect.bottom()) &&
                 (child->x2 > buf->rect.left()) &&
@@ -1068,7 +1063,7 @@ void SPCanvasGroup::viewboxChanged(SPCanvasItem *item, Geom::IntRect const &new_
     
     for (GList *list = group->items; list; list = list->next) {
         SPCanvasItem *child = (SPCanvasItem *)list->data;
-        if (child->flags & SP_CANVAS_ITEM_VISIBLE) {
+        if (child->visible) {
             if (SP_CANVAS_ITEM_GET_CLASS(child)->viewbox_changed) {
                 SP_CANVAS_ITEM_GET_CLASS(child)->viewbox_changed(child, new_area);
             }
@@ -1078,7 +1073,7 @@ void SPCanvasGroup::viewboxChanged(SPCanvasItem *item, Geom::IntRect const &new_
 
 void SPCanvasGroup::add(SPCanvasItem *item)
 {
-    gtk_object_ref( GTK_OBJECT(item) );
+    g_object_ref(item);
     g_object_ref_sink(item);
 
     if (!items) {
@@ -1100,7 +1095,7 @@ void SPCanvasGroup::remove(SPCanvasItem *item)
 
             // Unparent the child
             item->parent = NULL;
-            gtk_object_unref(GTK_OBJECT(item));
+            g_object_unref(item);
 
             // Remove it from the list
             if (children == last) {
@@ -1181,7 +1176,7 @@ void SPCanvasImpl::init(SPCanvas *canvas)
     canvas->root = SP_CANVAS_ITEM(g_object_new(SPCanvasGroup::getType(), NULL));
     canvas->root->canvas = canvas;
 
-    gtk_object_ref (GTK_OBJECT (canvas->root));
+    g_object_ref (canvas->root);
     g_object_ref_sink (canvas->root);
 
     canvas->need_repick = TRUE;
@@ -1242,7 +1237,7 @@ void SPCanvasImpl::destroy(GtkObject *object)
     SPCanvas *canvas = SP_CANVAS(object);
 
     if (canvas->root) {
-        gtk_object_unref (GTK_OBJECT (canvas->root));
+        g_object_unref (canvas->root);
         canvas->root = NULL;
     }
 
@@ -1484,10 +1479,10 @@ int SPCanvasImpl::emitEvent(SPCanvas *canvas, GdkEvent *event)
     gint finished = FALSE;
 
     while (item && !finished) {
-        gtk_object_ref (GTK_OBJECT (item));
+        g_object_ref (item);
         g_signal_emit (G_OBJECT (item), item_signals[ITEM_EVENT], 0, &ev, &finished);
         SPCanvasItem *parent = item->parent;
-        gtk_object_unref (GTK_OBJECT (item));
+        g_object_unref (item);
         item = parent;
     }
 
@@ -1571,7 +1566,7 @@ int SPCanvasImpl::pickCurrentItem(SPCanvas *canvas, GdkEvent *event)
         y += canvas->y0;
 
         // find the closest item
-        if (canvas->root->flags & SP_CANVAS_ITEM_VISIBLE) {
+        if (canvas->root->visible) {
             sp_canvas_item_invoke_point (canvas->root, Geom::Point(x, y), &canvas->new_current_item);
         } else {
             canvas->new_current_item = NULL;
@@ -1774,7 +1769,7 @@ void SPCanvasImpl::sp_canvas_paint_single_buffer(SPCanvas *canvas, Geom::IntRect
     cairo_paint(buf.ct);
     cairo_set_operator(buf.ct, CAIRO_OPERATOR_OVER);
 
-    if (canvas->root->flags & SP_CANVAS_ITEM_VISIBLE) {
+    if (canvas->root->visible) {
         SP_CANVAS_ITEM_GET_CLASS (canvas->root)->render (canvas->root, &buf);
     }