update to trunk

(bzr r12588.1.10)

10 files changed, 153 insertions, 153 deletions

diff --git a/src/display/drawing-group.cpp b/src/display/drawing-group.cpp
index 6d52b89fc..b5ce18891 100644
--- a/src/display/drawing-group.cpp
+++ b/src/display/drawing-group.cpp
@@ -28,6 +28,7 @@ DrawingGroup::~DrawingGroup()
 {
     if (_style)
         sp_style_unref(_style);
+    delete _child_transform; // delete NULL; is safe
 }
 
 /**
diff --git a/src/display/drawing-item.cpp b/src/display/drawing-item.cpp
index 1af07cb44..71a7f8906 100644
--- a/src/display/drawing-item.cpp
+++ b/src/display/drawing-item.cpp
@@ -141,7 +141,14 @@ DrawingItem::appendChild(DrawingItem *item)
     assert(item->_child_type == CHILD_ORPHAN);
     item->_child_type = CHILD_NORMAL;
     _children.push_back(*item);
-    _markForUpdate(STATE_ALL, false);
+
+    // This ensures that _markForUpdate() called on the child will recurse to this item
+    item->_state = STATE_ALL;
+    // Because _markForUpdate recurses through ancestors, we can simply call it
+    // on the just-added child. This has the additional benefit that we do not
+    // rely on the appended child being in the default non-updated state.
+    // We set propagate to true, because the child might have descendants of its own.
+    item->_markForUpdate(STATE_ALL, true);
 }
 
 void
@@ -151,7 +158,9 @@ DrawingItem::prependChild(DrawingItem *item)
     assert(item->_child_type == CHILD_ORPHAN);
     item->_child_type = CHILD_NORMAL;
     _children.push_front(*item);
-    _markForUpdate(STATE_ALL, false);
+    // See appendChild for explanation
+    item->_state = STATE_ALL;
+    item->_markForUpdate(STATE_ALL, true);
 }
 
 /// Delete all regular children of this item (not mask or clip).
@@ -281,17 +290,10 @@ DrawingItem::setZOrder(unsigned z)
     _markForRendering();
 }
 
-void DrawingItem::setItemBounds(Geom::OptRect const &bounds)
-{
-    if (!bounds) return;
-    Geom::IntRect copy = bounds->roundOutwards();
-    if (_filter) _filter->area_enlarge(copy, this);
-    this->setFilterBounds(copy);
-}
-
-void DrawingItem::setFilterBounds(Geom::OptRect const &bounds)
+void
+DrawingItem::setItemBounds(Geom::OptRect const &bounds)
 {
-    if (bounds) _filter_bbox = bounds;
+    _item_bbox = bounds;
 }
 
 /**
@@ -359,10 +361,14 @@ DrawingItem::update(Geom::IntRect const &area, UpdateContext const &ctx, unsigne
 
     if (to_update & STATE_BBOX) {
         // compute drawbox
-        if (_filter && render_filters && _filter_bbox) {
-            Geom::OptRect enlarged = _filter_bbox;
-            *enlarged *= ctm();
-            _drawbox = enlarged->roundOutwards();
+        if (_filter && render_filters) {
+            Geom::OptRect enlarged = _filter->filter_effect_area(_item_bbox);
+            if (enlarged) {
+                *enlarged *= ctm();
+                _drawbox = enlarged->roundOutwards();
+            } else {
+                _drawbox = Geom::OptIntRect();
+            }
         } else {
             _drawbox = _bbox;
         }
@@ -714,8 +720,11 @@ DrawingItem::pick(Geom::Point const &p, double delta, unsigned flags)
 {
     // Sometimes there's no BBOX in state, reason unknown (bug 992817)
     // I made this not an assert to remove the warning
-    if (!(_state & STATE_BBOX) || !(_state & STATE_PICK))
+    if (!(_state & STATE_BBOX) || !(_state & STATE_PICK)) {
+        g_warning("Invalid state when picking: STATE_BBOX = %d, STATE_PICK = %d",
+                  _state & STATE_BBOX, _state & STATE_PICK);
         return NULL;
+    }
     // ignore invisible and insensitive items unless sticky
     if (!(flags & PICK_STICKY) && !(_visible && _sensitive))
         return NULL;
@@ -736,7 +745,10 @@ DrawingItem::pick(Geom::Point const &p, double delta, unsigned flags)
     }
 
     Geom::OptIntRect box = (outline || (flags & PICK_AS_CLIP)) ? _bbox : _drawbox;
-    if (!box) return NULL;
+    if (!box) {
+        g_warning("bbox unset when picking");
+        return NULL;
+    }
 
     Geom::Rect expanded = *box;
     expanded.expandBy(delta);
@@ -756,6 +768,9 @@ DrawingItem::pick(Geom::Point const &p, double delta, unsigned flags)
 void
 DrawingItem::_markForRendering()
 {
+    // TODO: this function does too much work when a large subtree
+    // is invalidated - fix
+    
     bool outline = _drawing.outline();
     Geom::OptIntRect dirty = outline ? _bbox : _drawbox;
     if (!dirty) return;
@@ -807,8 +822,8 @@ DrawingItem::_invalidateFilterBackground(Geom::IntRect const &area)
  * all children should also have the corresponding flags unset before checking
  * whether they need to be traversed. This way there is one less traversal
  * of the tree. Without this we would need to unset state bits in all children.
- * With _propagate we do this during the update call, when we have to traverse
- * the tree anyway.
+ * With _propagate we do this during the update call, when we have to recurse
+ * into children anyway.
  */
 void
 DrawingItem::_markForUpdate(unsigned flags, bool propagate)
@@ -818,15 +833,31 @@ DrawingItem::_markForUpdate(unsigned flags, bool propagate)
     }
 
     if (_state & flags) {
+        unsigned oldstate = _state;
         _state &= ~flags;
-        if (_parent) {
+        if (oldstate != _state && _parent) {
+            // If we actually reset anything in state, recurse on the parent.
             _parent->_markForUpdate(flags, false);
         } else {
+            // If nothing changed, it means our ancestors are already invalidated
+            // up to the root. Do not bother recursing, because it won't change anything.
+            // Also do this if we are the root item, because we have no more ancestors
+            // to invalidate.
             _drawing.signal_request_update.emit(this);
         }
     }
 }
 
+/**
+ * Process information related to the new style.
+ *
+ * This function is something of a hack to avoid creating an extra class in the hierarchy
+ * which would differ from DrawingItem only by having a _style member.
+ * This is mainly to the benefit of DrawingGlyphs, which use the style of their parent.
+ * This should probably be refactored some day, possibly by creating the relevant class
+ * or creating a more complex data model in DrawingText and removing DrawingGlyphs,
+ * which would cause every item to have a style.
+ */
 void
 DrawingItem::_setStyleCommon(SPStyle *&_style, SPStyle *style)
 {
@@ -834,7 +865,6 @@ DrawingItem::_setStyleCommon(SPStyle *&_style, SPStyle *style)
     if (_style) sp_style_unref(_style);
     _style = style;
 
-    // if group has a filter
     if (style->filter.set && style->getFilter()) {
         if (!_filter) {
             int primitives = sp_filter_primitive_count(SP_FILTER(style->getFilter()));
diff --git a/src/display/drawing-item.h b/src/display/drawing-item.h
index c69b996b4..e03bbd0f7 100644
--- a/src/display/drawing-item.h
+++ b/src/display/drawing-item.h
@@ -89,7 +89,7 @@ public:
 
     Geom::OptIntRect geometricBounds() const { return _bbox; }
     Geom::OptIntRect visualBounds() const { return _drawbox; }
-    Geom::OptRect filterBounds() const { return _filter_bbox; }
+    Geom::OptRect itemBounds() const { return _item_bbox; }
     Geom::Affine ctm() const { return _ctm; }
     Geom::Affine transform() const { return _transform ? *_transform : Geom::identity(); }
     Drawing &drawing() const { return _drawing; }
@@ -176,7 +176,9 @@ protected:
     Geom::Affine _ctm; ///< Total transform from item coords to display coords
     Geom::OptIntRect _bbox; ///< Bounding box in display (pixel) coords including stroke
     Geom::OptIntRect _drawbox; ///< Full visual bounding box - enlarged by filters, shrunk by clips and masks
-    Geom::OptRect _filter_bbox; ///< Used by filters when settings bounds
+    Geom::OptRect _item_bbox; ///< Geometric bounding box in item's user space.
+                              ///  This is used to compute the filter effect region and render in
+                              ///  objectBoundingBox units.
 
     DrawingItem *_clip;
     DrawingItem *_mask;
diff --git a/src/display/drawing-shape.cpp b/src/display/drawing-shape.cpp
index e689d0755..e80f12486 100644
--- a/src/display/drawing-shape.cpp
+++ b/src/display/drawing-shape.cpp
@@ -179,8 +179,8 @@ DrawingShape::_renderItem(DrawingContext &ct, Geom::IntRect const &area, unsigne
         // update fill and stroke paints.
         // this cannot be done during nr_arena_shape_update, because we need a Cairo context
         // to render svg:pattern
-        has_fill   = _nrstyle.prepareFill(ct, _bbox);
-        has_stroke = _nrstyle.prepareStroke(ct, _bbox);
+        has_fill   = _nrstyle.prepareFill(ct, _item_bbox);
+        has_stroke = _nrstyle.prepareStroke(ct, _item_bbox);
         has_stroke &= (_nrstyle.stroke_width != 0);
 
         if (has_fill || has_stroke) {
diff --git a/src/display/drawing-text.cpp b/src/display/drawing-text.cpp
index fa9ce4ff8..55d54b770 100644
--- a/src/display/drawing-text.cpp
+++ b/src/display/drawing-text.cpp
@@ -398,8 +398,8 @@ unsigned DrawingText::_renderItem(DrawingContext &ct, Geom::IntRect const &/*are
     using Geom::X;
     using Geom::Y;
 
-    has_fill   = _nrstyle.prepareFill(  ct, _bbox);
-    has_stroke = _nrstyle.prepareStroke(ct, _bbox);
+    has_fill   = _nrstyle.prepareFill(  ct, _item_bbox);
+    has_stroke = _nrstyle.prepareStroke(ct, _item_bbox);
 
     if (has_fill || has_stroke) {
         Geom::Affine rotinv;
diff --git a/src/display/guideline.cpp b/src/display/guideline.cpp
index f71bc82ef..55c1ee495 100644
--- a/src/display/guideline.cpp
+++ b/src/display/guideline.cpp
@@ -94,14 +94,20 @@ static void sp_guideline_destroy(SPCanvasItem *object)
     g_return_if_fail (SP_IS_GUIDELINE (object));
     //g_return_if_fail (SP_GUIDELINE(object)->origin != NULL);
     //g_return_if_fail (SP_IS_CTRLPOINT(SP_GUIDELINE(object)->origin));
-    
-    if (SP_GUIDELINE(object)->origin != NULL && SP_IS_CTRLPOINT(SP_GUIDELINE(object)->origin)) {
-        sp_canvas_item_destroy(SP_GUIDELINE(object)->origin);
+
+    SPGuideLine *gl = SP_GUIDELINE(object);
+
+    if (gl->origin != NULL && SP_IS_CTRLPOINT(gl->origin)) {
+        sp_canvas_item_destroy(gl->origin);
     } else {
         // FIXME: This branch shouldn't be reached (although it seems to be harmless).
         //g_error("Why can it be that gl->origin is not a valid SPCtrlPoint?\n");
     }
 
+    if (gl->label) {
+        g_free(gl->label);
+    }
+
     SP_CANVAS_ITEM_CLASS(parent_class)->destroy(object);
 }
 
diff --git a/src/display/nr-filter.cpp b/src/display/nr-filter.cpp
index c0044c5d8..af9c15cd8 100644
--- a/src/display/nr-filter.cpp
+++ b/src/display/nr-filter.cpp
@@ -114,14 +114,12 @@ int Filter::render(Inkscape::DrawingItem const *item, DrawingContext &graphic, D
 
     Geom::Affine trans = item->ctm();
 
-    // Get filter are, the filter_effect_area is already done in visualBounds
-    Geom::OptRect filter_area = item->filterBounds();
-    // Use the geometricBounds as a backup solution
+    Geom::OptRect filter_area = filter_effect_area(item->itemBounds());
     if (!filter_area) return 1;
 
     FilterUnits units(_filter_units, _primitive_units);
     units.set_ctm(trans);
-    units.set_item_bbox(filter_area);
+    units.set_item_bbox(item->itemBounds());
     units.set_filter_area(*filter_area);
 
     std::pair<double,double> resolution
@@ -201,7 +199,7 @@ void Filter::area_enlarge(Geom::IntRect &bbox, Inkscape::DrawingItem const *item
     }
 
     Geom::Rect item_bbox;
-    Geom::OptRect maybe_bbox = item->geometricBounds();
+    Geom::OptRect maybe_bbox = item->itemBounds();
     if (maybe_bbox.isEmpty()) {
         // Code below needs a bounding box
         return;
diff --git a/src/display/nr-style.cpp b/src/display/nr-style.cpp
index cd7e9575f..317f38635 100644
--- a/src/display/nr-style.cpp
+++ b/src/display/nr-style.cpp
@@ -77,6 +77,8 @@ NRStyle::~NRStyle()
     if (dash){
         delete [] dash;
     }
+    fill.clear();
+    stroke.clear();
 }
 
 void NRStyle::set(SPStyle *style)
diff --git a/src/display/sodipodi-ctrl.cpp b/src/display/sodipodi-ctrl.cpp
index 45dc38a37..3636319df 100644
--- a/src/display/sodipodi-ctrl.cpp
+++ b/src/display/sodipodi-ctrl.cpp
@@ -108,81 +108,50 @@ sp_ctrl_set_property(GObject *object, guint prop_id, const GValue *value, GParam
     ctrl = SP_CTRL (object);
 
     switch (prop_id) {
-        case ARG_SHAPE: {
-            ctrl->shape = (SPCtrlShapeType) g_value_get_int(value);
-            ctrl->build = FALSE;
-            sp_canvas_item_request_update(item);
-            }
-            break;
-
-        case ARG_MODE: {
-            ctrl->mode = (SPCtrlModeType) g_value_get_int(value);
-            ctrl->build = FALSE;
-            sp_canvas_item_request_update(item);
-            }
-            break;
-
-        case ARG_ANCHOR: {
-            ctrl->anchor = (SPAnchorType) g_value_get_int(value);
-            ctrl->build = FALSE;
-            sp_canvas_item_request_update(item);
-            }
-            break;
-
-        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);
-            }
-            break;
-
-        case ARG_FILLED: {
-            ctrl->filled = g_value_get_boolean(value);
-            ctrl->build = FALSE;
-            sp_canvas_item_request_update(item);
-            }
-            break;
-
-        case ARG_FILL_COLOR: {
-            guint32 fill = g_value_get_int(value);
-            ctrl->fill_color = fill;
-            ctrl->build = FALSE;
-            sp_canvas_item_request_update(item);
-            }
-            break;
-
-        case ARG_STROKED: {
-            ctrl->stroked = g_value_get_boolean(value);
-            ctrl->build = FALSE;
-            sp_canvas_item_request_update(item);
-            }
-            break;
-
-        case ARG_STROKE_COLOR: {
-            guint32 stroke = g_value_get_int(value);
-            ctrl->stroke_color = stroke;
-            ctrl->build = FALSE;
-            sp_canvas_item_request_update(item);
-            }
-            break;
-
-        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);
-                g_object_unref(pixbuf);
-            }
-            ctrl->build = FALSE;
-            }
-            break;
-
-        default:
-            G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
-            break;
+    case ARG_SHAPE:
+        ctrl->shape = (SPCtrlShapeType) g_value_get_int(value);
+        break;
+    case ARG_MODE:
+        ctrl->mode = (SPCtrlModeType) g_value_get_int(value);
+        break;
+    case ARG_ANCHOR:
+        ctrl->anchor = (SPAnchorType) g_value_get_int(value);
+        break;
+    case ARG_SIZE:
+        ctrl->width = (gint)(g_value_get_double(value) / 2.0);
+        ctrl->height = ctrl->width;
+        ctrl->defined = (ctrl->width > 0);
+        break;
+    case ARG_FILLED:
+        ctrl->filled = g_value_get_boolean(value);
+        break;
+    case ARG_FILL_COLOR:
+        ctrl->fill_color = (guint32)g_value_get_int(value);
+        break;
+    case ARG_STROKED:
+        ctrl->stroked = g_value_get_boolean(value);
+        break;
+    case ARG_STROKE_COLOR:
+        ctrl->stroke_color = (guint32)g_value_get_int(value);
+        break;
+    case ARG_PIXBUF:
+        pixbuf = (GdkPixbuf*) g_value_get_pointer(value);
+        // A pixbuf defines it's own size, don't mess about with size.
+        ctrl->width = gdk_pixbuf_get_width(pixbuf) / 2.0;
+        ctrl->height = gdk_pixbuf_get_height(pixbuf) / 2.0;
+        if (gdk_pixbuf_get_has_alpha(pixbuf)) {
+            ctrl->pixbuf = pixbuf;
+        } else {
+            ctrl->pixbuf = gdk_pixbuf_add_alpha(pixbuf, FALSE, 0, 0, 0);
+            g_object_unref(pixbuf);
+        }
+        break;
+    default:
+        G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
+        return; // Do not do an update
     }
+    ctrl->build = FALSE;
+    sp_canvas_item_request_update(item);
 }
 
 static void
@@ -206,7 +175,7 @@ sp_ctrl_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec
             break;
 
         case ARG_SIZE:
-            g_value_set_double(value, ctrl->span);
+            g_value_set_double(value, ctrl->width);
             break;
 
         case ARG_FILLED:
@@ -241,7 +210,8 @@ 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->width = 3;
+    ctrl->height = 3;
     ctrl->defined = TRUE;
     ctrl->shown = FALSE;
     ctrl->build = FALSE;
@@ -250,12 +220,6 @@ sp_ctrl_init (SPCtrl *ctrl)
     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;
@@ -292,16 +256,14 @@ sp_ctrl_update (SPCanvasItem *item, Geom::Affine const &affine, unsigned int fla
 
     sp_canvas_item_reset_bounds (item);
 
-    if (!ctrl->_moved) return;
-
     if (ctrl->shown) {
         item->canvas->requestRedraw(ctrl->box.left(), ctrl->box.top(), ctrl->box.right() + 1, ctrl->box.bottom() + 1);
     }
 
     if (!ctrl->defined) return;
 
-    x = (gint) ((affine[4] > 0) ? (affine[4] + 0.5) : (affine[4] - 0.5)) - ctrl->span;
-    y = (gint) ((affine[5] > 0) ? (affine[5] + 0.5) : (affine[5] - 0.5)) - ctrl->span;
+    x = (gint) ((affine[4] > 0) ? (affine[4] + 0.5) : (affine[4] - 0.5)) - ctrl->width;
+    y = (gint) ((affine[5] > 0) ? (affine[5] + 0.5) : (affine[5] - 0.5)) - ctrl->height;
 
     switch (ctrl->anchor) {
         case SP_ANCHOR_N:
@@ -312,13 +274,13 @@ sp_ctrl_update (SPCanvasItem *item, Geom::Affine const &affine, unsigned int fla
         case SP_ANCHOR_NW:
         case SP_ANCHOR_W:
         case SP_ANCHOR_SW:
-            x += ctrl->span;
+            x += ctrl->width;
             break;
 
         case SP_ANCHOR_NE:
         case SP_ANCHOR_E:
         case SP_ANCHOR_SE:
-            x -= (ctrl->span + 1);
+            x -= (ctrl->width + 1);
             break;
     }
 
@@ -331,17 +293,17 @@ sp_ctrl_update (SPCanvasItem *item, Geom::Affine const &affine, unsigned int fla
         case SP_ANCHOR_NW:
         case SP_ANCHOR_N:
         case SP_ANCHOR_NE:
-            y += ctrl->span;
+            y += ctrl->height;
             break;
 
         case SP_ANCHOR_SW:
         case SP_ANCHOR_S:
         case SP_ANCHOR_SE:
-            y -= (ctrl->span + 1);
+            y -= (ctrl->height + 1);
             break;
     }
 
-    ctrl->box = Geom::IntRect::from_xywh(x, y, 2*ctrl->span, 2*ctrl->span);
+    ctrl->box = Geom::IntRect::from_xywh(x, y, 2*ctrl->width, 2*ctrl->height);
     sp_canvas_update_bbox (item, ctrl->box.left(), ctrl->box.top(), ctrl->box.right() + 1, ctrl->box.bottom() + 1);
 }
 
@@ -360,7 +322,7 @@ static void
 sp_ctrl_build_cache (SPCtrl *ctrl)
 {
     guint32 *p, *q;
-    gint size, x, y, z, s, a, side, c;
+    gint size, x, y, z, s, a, width, height, c;
     guint32 stroke_color, fill_color;
 
     if (ctrl->filled) {
@@ -382,11 +344,11 @@ sp_ctrl_build_cache (SPCtrl *ctrl)
         stroke_color = fill_color;
     }
 
-
-    side = (ctrl->span * 2 +1);
-    c = ctrl->span;
-    size = side * side;
-    if (side < 2) return;
+    width = (ctrl->width * 2 +1);
+    height = (ctrl->height * 2 +1);
+    c = ctrl->width; // Only used for pre-set square drawing
+    size = width * height;
+    if (width < 2) return;
 
     if (ctrl->cache) delete[] ctrl->cache;
     ctrl->cache = new guint32[size];
@@ -395,19 +357,19 @@ sp_ctrl_build_cache (SPCtrl *ctrl)
         case SP_CTRL_SHAPE_SQUARE:
             p = ctrl->cache;
             // top edge
-            for (x=0; x < side; x++) {
+            for (x=0; x < width; x++) {
                 *p++ = stroke_color;
             }
             // middle
-            for (y = 2; y < side; y++) {
+            for (y = 2; y < height; y++) {
                 *p++ = stroke_color; // stroke at first and last pixel
-                for (x=2; x < side; x++) {
+                for (x=2; x < width; x++) {
                     *p++ = fill_color; // fill in the middle
                 }
                 *p++ = stroke_color;
             }
             // bottom edge
-            for (x=0; x < side; x++) {
+            for (x=0; x < width; x++) {
                 *p++ = stroke_color;
             }
             ctrl->build = TRUE;
@@ -415,19 +377,19 @@ sp_ctrl_build_cache (SPCtrl *ctrl)
 
         case SP_CTRL_SHAPE_DIAMOND:
             p = ctrl->cache;
-            for (y = 0; y < side; y++) {
+            for (y = 0; y < height; y++) {
                 z = abs (c - y);
                 for (x = 0; x < z; x++) {
                     *p++ = 0;
                 }
                 *p++ = stroke_color; x++;
-                for (; x < side - z -1; x++) {
+                for (; x < width - z -1; x++) {
                     *p++ = fill_color;
                 }
                 if (z != c) {
                     *p++ = stroke_color; x++;
                 }
-                for (; x < side; x++) {
+                for (; x < width; x++) {
                     *p++ = 0;
                 }
             }
@@ -462,7 +424,7 @@ sp_ctrl_build_cache (SPCtrl *ctrl)
                     *q-- = stroke_color;
                     x++;
                 } while (x <= c+z);
-                while (x < side) {
+                while (x < width) {
                     *p++ = 0;
                     *q-- = 0;
                     x++;
@@ -474,7 +436,7 @@ sp_ctrl_build_cache (SPCtrl *ctrl)
 
         case SP_CTRL_SHAPE_CROSS:
             p = ctrl->cache;
-            for (y = 0; y < side; y++) {
+            for (y = 0; y < height; y++) {
                 z = abs (c - y);
                 for (x = 0; x < c-z; x++) {
                     *p++ = 0;
@@ -486,7 +448,7 @@ sp_ctrl_build_cache (SPCtrl *ctrl)
                 if (z != 0) {
                     *p++ = stroke_color; x++;
                 }
-                for (; x < side; x++) {
+                for (; x < width; x++) {
                     *p++ = 0;
                 }
             }
@@ -499,12 +461,12 @@ sp_ctrl_build_cache (SPCtrl *ctrl)
                 unsigned int rs;
                 px = gdk_pixbuf_get_pixels (ctrl->pixbuf);
                 rs = gdk_pixbuf_get_rowstride (ctrl->pixbuf);
-                for (y = 0; y < side; y++){
+                for (y = 0; y < height; y++){
                     guint32 *d;
                     unsigned char *s;
                     s = px + y * rs;
-                    d = ctrl->cache + side * y;
-                    for (x = 0; x < side; x++) {
+                    d = ctrl->cache + height * y;
+                    for (x = 0; x < width; x++) {
                         if (s[3] < 0x80) {
                             *d++ = 0;
                         } else if (s[0] < 0x80) {
@@ -527,9 +489,9 @@ sp_ctrl_build_cache (SPCtrl *ctrl)
                 guint32 *px;
                 guchar *data = gdk_pixbuf_get_pixels (ctrl->pixbuf);
                 p = ctrl->cache;
-                for (y = 0; y < side; y++){
+                for (y = 0; y < height; y++){
                     px = reinterpret_cast<guint32*>(data + y * r);
-                    for (x = 0; x < side; x++) {
+                    for (x = 0; x < width; x++) {
                         *p++ = *px++;
                     }
                 }
@@ -566,8 +528,8 @@ sp_ctrl_render (SPCanvasItem *item, SPCanvasBuf *buf)
         sp_ctrl_build_cache (ctrl);
     }
 
-    int w, h;
-    w = h = (ctrl->span * 2 +1);
+    int w = (ctrl->width * 2 + 1);
+    int h = (ctrl->height * 2 + 1);
 
     // The code below works even when the target is not an image surface
     if (ctrl->mode == SP_CTRL_MODE_XOR) {
@@ -627,7 +589,6 @@ sp_ctrl_render (SPCanvasItem *item, SPCanvasBuf *buf)
 void SPCtrl::moveto (Geom::Point const p) {
     if (p != _point) {
         sp_canvas_item_affine_absolute (SP_CANVAS_ITEM (this), Geom::Affine(Geom::Translate (p)));
-        _moved = true;
     }
     _point = p;
 }
diff --git a/src/display/sodipodi-ctrl.h b/src/display/sodipodi-ctrl.h
index cd0fcadf1..ecdb896a7 100644
--- a/src/display/sodipodi-ctrl.h
+++ b/src/display/sodipodi-ctrl.h
@@ -37,7 +37,8 @@ struct SPCtrl : public SPCanvasItem {
     SPCtrlShapeType shape;
     SPCtrlModeType mode;
     SPAnchorType anchor;
-    gint span;
+    gint width;
+    gint height;
     guint defined : 1;
     guint shown   : 1;
     guint build   : 1;
@@ -45,7 +46,6 @@ struct SPCtrl : public SPCanvasItem {
     guint stroked : 1;
     guint32 fill_color;
     guint32 stroke_color;
-    bool _moved;
 
     Geom::IntRect box;   /* NB! x1 & y1 are included */
     guint32 *cache;