Added "virtual pad" to SPGroup and SPSwitch. There was some weird try by someone else.

SPGroup should work as expected, SPSwitch may still be buggy.

(bzr r11608.1.16)

5 files changed, 386 insertions, 320 deletions

diff --git a/src/sp-conn-end-pair.cpp b/src/sp-conn-end-pair.cpp
index 17e9e7397..05495477b 100644
--- a/src/sp-conn-end-pair.cpp
+++ b/src/sp-conn-end-pair.cpp
@@ -203,7 +203,7 @@ SPConnEndPair::getAttachedItems(SPItem *h2attItem[2]) const {
         // selected through the XML editor, it makes sense just to detach
         // connectors from them.
         if (SP_IS_GROUP(h2attItem[h])) {
-            if (SP_GROUP(h2attItem[h])->group->getItemCount() == 0) {
+            if (SP_GROUP(h2attItem[h])->getItemCount() == 0) {
                 // This group is empty, so detach.
                 sp_conn_end_detach(_path, h);
                 h2attItem[h] = NULL;
diff --git a/src/sp-item-group.cpp b/src/sp-item-group.cpp
index b54ec65e2..406db4d8f 100644
--- a/src/sp-item-group.cpp
+++ b/src/sp-item-group.cpp
@@ -138,90 +138,232 @@ sp_group_class_init (SPGroupClass *klass)
     lpe_item_class->update_patheffect = sp_group_update_patheffect;
 }
 
+CGroup::CGroup(SPGroup *group) : CLPEItem(group) {
+    this->spgroup = group;
+}
+
+CGroup::~CGroup() {
+}
+
 static void
 sp_group_init (SPGroup *group)
 {
+	group->cgroup = new CGroup(group);
+	group->clpeitem = group->cgroup;
+	group->citem = group->cgroup;
+	group->cobject = group->cgroup;
+
     group->_layer_mode = SPGroup::GROUP;
-    group->group = new CGroup(group);
-    new (&group->_display_modes) std::map<unsigned int, SPGroup::LayerMode>();
+        new (&group->_display_modes) std::map<unsigned int, SPGroup::LayerMode>();
 }
 
-static void sp_group_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
-{
+void CGroup::onBuild(SPDocument *document, Inkscape::XML::Node *repr) {
+	SPGroup* object = this->spgroup;
+
     object->readAttr( "inkscape:groupmode" );
 
-    if (((SPObjectClass *)parent_class)->build) {
-        ((SPObjectClass *)parent_class)->build(object, document, repr);
-    }
+    CLPEItem::onBuild(document, repr);
 }
 
-static void sp_group_release(SPObject *object) {
+// CPPIFY: remove
+static void sp_group_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
+{
+	((SPGroup*)object)->cgroup->onBuild(document, repr);
+}
+
+void CGroup::onRelease() {
+	SPGroup* object = this->spgroup;
+
     if ( SP_GROUP(object)->_layer_mode == SPGroup::LAYER ) {
         object->document->removeResource("layer", object);
     }
-    if (((SPObjectClass *)parent_class)->release) {
-        ((SPObjectClass *)parent_class)->release(object);
-    }
+
+    CLPEItem::onRelease();
+}
+
+// CPPIFY: remove
+static void sp_group_release(SPObject *object) {
+	((SPGroup*)object)->cgroup->onRelease();
 }
 
 static void
 sp_group_dispose(GObject *object)
 {
     SP_GROUP(object)->_display_modes.~map();
-    delete SP_GROUP(object)->group;
 }
 
-static void sp_group_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref)
-{
-    SPGroup *group = SP_GROUP(object);
+void CGroup::onChildAdded(Inkscape::XML::Node* child, Inkscape::XML::Node* ref) {
+    CLPEItem::onChildAdded(child, ref);
+
+    SPObject *last_child = spgroup->lastChild();
+
+    if (last_child && last_child->getRepr() == child) {
+        // optimization for the common special case where the child is being added at the end
+        SPObject *ochild = last_child;
+        if ( SP_IS_ITEM(ochild) ) {
+            /* TODO: this should be moved into SPItem somehow */
+            SPItemView *v;
+            Inkscape::DrawingItem *ac;
+
+            for (v = spgroup->display; v != NULL; v = v->next) {
+                ac = SP_ITEM (ochild)->invoke_show (v->arenaitem->drawing(), v->key, v->flags);
+
+                if (ac) {
+                    v->arenaitem->appendChild(ac);
+                }
+            }
+        }
+    } else {    // general case
+        SPObject *ochild = spgroup->get_child_by_repr(child);
+        if ( ochild && SP_IS_ITEM(ochild) ) {
+            /* TODO: this should be moved into SPItem somehow */
+            SPItemView *v;
+            Inkscape::DrawingItem *ac;
+
+            unsigned position = SP_ITEM(ochild)->pos_in_parent();
+
+            for (v = spgroup->display; v != NULL; v = v->next) {
+                ac = SP_ITEM (ochild)->invoke_show (v->arenaitem->drawing(), v->key, v->flags);
 
-    if (((SPObjectClass *) (parent_class))->child_added) {
-        (* ((SPObjectClass *) (parent_class))->child_added) (object, child, ref);
+                if (ac) {
+                    v->arenaitem->prependChild(ac);
+                    ac->setZOrder(position);
+                }
+            }
+        }
     }
 
-    group->group->onChildAdded(child);
+    spgroup->requestModified(SP_OBJECT_MODIFIED_FLAG);
+}
+
+// CPPIFY: remove
+static void sp_group_child_added(SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref)
+{
+	((SPGroup*)object)->cgroup->onChildAdded(child, ref);
 }
 
 /* fixme: hide (Lauris) */
 
+void CGroup::onRemoveChild(Inkscape::XML::Node *child) {
+    CLPEItem::onRemoveChild(child);
+
+    spgroup->requestModified(SP_OBJECT_MODIFIED_FLAG);
+}
+
+// CPPIFY: remove
 static void
 sp_group_remove_child (SPObject * object, Inkscape::XML::Node * child)
 {
-    if (((SPObjectClass *) (parent_class))->remove_child)
-        (* ((SPObjectClass *) (parent_class))->remove_child) (object, child);
+    ((SPGroup*)object)->cgroup->onRemoveChild(child);
+}
+
+void CGroup::onOrderChanged (Inkscape::XML::Node *child, Inkscape::XML::Node *old_ref, Inkscape::XML::Node *new_ref)
+{
+	CLPEItem::onOrderChanged(child, old_ref, new_ref);
 
-    SP_GROUP(object)->group->onChildRemoved(child);
+    SPObject *ochild = spgroup->get_child_by_repr(child);
+    if ( ochild && SP_IS_ITEM(ochild) ) {
+        /* TODO: this should be moved into SPItem somehow */
+        SPItemView *v;
+        unsigned position = SP_ITEM(ochild)->pos_in_parent();
+        for ( v = SP_ITEM (ochild)->display ; v != NULL ; v = v->next ) {
+            v->arenaitem->setZOrder(position);
+        }
+    }
+
+    spgroup->requestModified(SP_OBJECT_MODIFIED_FLAG);
 }
 
+// CPPIFY: remove
 static void
 sp_group_order_changed (SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *old_ref, Inkscape::XML::Node *new_ref)
 {
-    if (((SPObjectClass *) (parent_class))->order_changed)
-        (* ((SPObjectClass *) (parent_class))->order_changed) (object, child, old_ref, new_ref);
+    ((SPGroup*)object)->cgroup->onOrderChanged(child, old_ref, new_ref);
+}
+
+void CGroup::onUpdate(SPCtx *ctx, unsigned int flags) {
+    CLPEItem::onUpdate(ctx, flags);
+
+    SPItemCtx *ictx, cctx;
+
+    ictx = (SPItemCtx *) ctx;
+    cctx = *ictx;
 
-    SP_GROUP(object)->group->onOrderChanged(child, old_ref, new_ref);
+    if (flags & SP_OBJECT_MODIFIED_FLAG) {
+      flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
+    }
+
+    flags &= SP_OBJECT_MODIFIED_CASCADE;
+
+    if (flags & SP_OBJECT_STYLE_MODIFIED_FLAG) {
+        SPObject *object = spgroup;
+        for (SPItemView *v = spgroup->display; v != NULL; v = v->next) {
+            Inkscape::DrawingGroup *group = dynamic_cast<Inkscape::DrawingGroup *>(v->arenaitem);
+            group->setStyle(object->style);
+        }
+    }
+
+    GSList *l = g_slist_reverse(spgroup->childList(true, SPObject::ActionUpdate));
+    while (l) {
+        SPObject *child = SP_OBJECT (l->data);
+        l = g_slist_remove (l, child);
+        if (flags || (child->uflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
+            if (SP_IS_ITEM (child)) {
+                SPItem const &chi = *SP_ITEM(child);
+                cctx.i2doc = chi.transform * ictx->i2doc;
+                cctx.i2vp = chi.transform * ictx->i2vp;
+                child->updateDisplay((SPCtx *)&cctx, flags);
+            } else {
+                child->updateDisplay(ctx, flags);
+            }
+        }
+        g_object_unref (G_OBJECT (child));
+    }
 }
 
+// CPPIFY: remove
 static void
 sp_group_update (SPObject *object, SPCtx *ctx, unsigned int flags)
 {
-    if (((SPObjectClass *) (parent_class))->update)
-        ((SPObjectClass *) (parent_class))->update (object, ctx, flags);
+    ((SPGroup*)object)->cgroup->onUpdate(ctx, flags);
+}
+
+void CGroup::onModified(guint flags) {
+    CLPEItem::onModified(flags);
+
+    SPObject *child;
+
+    if (flags & SP_OBJECT_MODIFIED_FLAG) flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
+    flags &= SP_OBJECT_MODIFIED_CASCADE;
 
-    SP_GROUP(object)->group->onUpdate(ctx, flags);
+    if (flags & SP_OBJECT_STYLE_MODIFIED_FLAG) {
+        SPObject *object = spgroup;
+        for (SPItemView *v = spgroup->display; v != NULL; v = v->next) {
+            Inkscape::DrawingGroup *group = dynamic_cast<Inkscape::DrawingGroup *>(v->arenaitem);
+            group->setStyle(object->style);
+        }
+    }
+
+    GSList *l = g_slist_reverse(spgroup->childList(true));
+    while (l) {
+        child = SP_OBJECT (l->data);
+        l = g_slist_remove (l, child);
+        if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
+            child->emitModified(flags);
+        }
+        g_object_unref (G_OBJECT (child));
+    }
 }
 
+// CPPIFY: remove
 static void
 sp_group_modified (SPObject *object, guint flags)
 {
-    if (((SPObjectClass *) (parent_class))->modified)
-        ((SPObjectClass *) (parent_class))->modified (object, flags);
-
-    SP_GROUP(object)->group->onModified(flags);
+    ((SPGroup*)object)->cgroup->onModified(flags);
 }
 
-static Inkscape::XML::Node * sp_group_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
-{
+Inkscape::XML::Node* CGroup::onWrite(Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags) {
+	SPGroup* object = this->spgroup;
     SPGroup *group = SP_GROUP(object);
 
     if (flags & SP_OBJECT_WRITE_BUILD) {
@@ -269,32 +411,75 @@ static Inkscape::XML::Node * sp_group_write(SPObject *object, Inkscape::XML::Doc
         repr->setAttribute("inkscape:groupmode", value);
     }
 
-    if (((SPObjectClass *) (parent_class))->write) {
-        ((SPObjectClass *) (parent_class))->write (object, xml_doc, repr, flags);
-    }
+    CLPEItem::onWrite(xml_doc, repr, flags);
 
     return repr;
 }
 
+// CPPIFY: remove
+static Inkscape::XML::Node * sp_group_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
+{
+	return ((SPGroup*)object)->cgroup->onWrite(xml_doc, repr, flags);
+}
+
+Geom::OptRect CGroup::onBbox(Geom::Affine const &transform, SPItem::BBoxType bboxtype)
+{
+    Geom::OptRect bbox;
+
+    GSList *l = spgroup->childList(false, SPObject::ActionBBox);
+    while (l) {
+        SPObject *o = SP_OBJECT (l->data);
+        if (SP_IS_ITEM(o) && !SP_ITEM(o)->isHidden()) {
+            SPItem *child = SP_ITEM(o);
+            Geom::Affine const ct(child->transform * transform);
+            bbox |= child->bounds(bboxtype, ct);
+        }
+        l = g_slist_remove (l, o);
+    }
+    return bbox;
+}
+
+// CPPIFY: remove
 static Geom::OptRect
 sp_group_bbox(SPItem const *item, Geom::Affine const &transform, SPItem::BBoxType type)
 {
-    return SP_GROUP(item)->group->bounds(type, transform);
+    return ((SPGroup*)item)->cgroup->onBbox(transform, type);
+}
+
+void CGroup::onPrint(SPPrintContext *ctx) {
+    GSList *l = g_slist_reverse(spgroup->childList(false));
+    while (l) {
+        SPObject *o = SP_OBJECT (l->data);
+        if (SP_IS_ITEM(o)) {
+            SP_ITEM(o)->invoke_print (ctx);
+        }
+        l = g_slist_remove (l, o);
+    }
 }
 
+// CPPIFY: remove
 static void
 sp_group_print (SPItem * item, SPPrintContext *ctx)
 {
-    SP_GROUP(item)->group->onPrint(ctx);
+    ((SPGroup*)item)->cgroup->onPrint(ctx);
 }
 
+gchar *CGroup::onDescription() {
+    gint len = this->spgroup->getItemCount();
+    return g_strdup_printf(
+            ngettext("<b>Group</b> of <b>%d</b> object",
+                 "<b>Group</b> of <b>%d</b> objects",
+                 len), len);
+}
+
+// CPPIFY: remove
 static gchar * sp_group_description (SPItem * item)
 {
-    return SP_GROUP(item)->group->getDescription();
+    return ((SPGroup*)item)->cgroup->onDescription();
 }
 
-static void sp_group_set(SPObject *object, unsigned key, char const *value) {
-    SPGroup *group = SP_GROUP(object);
+void CGroup::onSet(unsigned int key, gchar const* value) {
+    SPGroup *group = this->spgroup;
 
     switch (key) {
         case SP_ATTR_INKSCAPE_GROUPMODE:
@@ -307,27 +492,65 @@ static void sp_group_set(SPObject *object, unsigned key, char const *value) {
             }
             break;
         default: {
-            if (((SPObjectClass *) (parent_class))->set) {
-                (* ((SPObjectClass *) (parent_class))->set)(object, key, value);
-            }
+            CLPEItem::onSet(key, value);
         }
     }
 }
 
+// CPPIFY: remove
+static void sp_group_set(SPObject *object, unsigned key, char const *value) {
+	((SPGroup*)object)->cgroup->onSet(key, value);
+}
+
+Inkscape::DrawingItem *CGroup::onShow (Inkscape::Drawing &drawing, unsigned int key, unsigned int flags) {
+    Inkscape::DrawingGroup *ai;
+    SPObject *object = spgroup;
+
+    ai = new Inkscape::DrawingGroup(drawing);
+    ai->setPickChildren(spgroup->effectiveLayerMode(key) == SPGroup::LAYER);
+    ai->setStyle(object->style);
+
+    this->spgroup->_showChildren(drawing, ai, key, flags);
+    return ai;
+}
+
+// CPPIFY: remove
 static Inkscape::DrawingItem *
 sp_group_show (SPItem *item, Inkscape::Drawing &drawing, unsigned int key, unsigned int flags)
 {
-    return SP_GROUP(item)->group->show(drawing, key, flags);
+    return ((SPGroup*)item)->cgroup->onShow(drawing, key, flags);
 }
 
+void CGroup::onHide (unsigned int key) {
+    SPItem * child;
+
+    GSList *l = g_slist_reverse(spgroup->childList(false, SPObject::ActionShow));
+    while (l) {
+        SPObject *o = SP_OBJECT (l->data);
+        if (SP_IS_ITEM (o)) {
+            child = SP_ITEM (o);
+            child->invoke_hide (key);
+        }
+        l = g_slist_remove (l, o);
+    }
+
+    // CPPIFY: This doesn't make no sense.
+    // CItem::onHide is pure and CLPEItem doesn't override it. What was the idea behind these lines?
+//    if (((SPItemClass *) parent_class)->hide)
+//        ((SPItemClass *) parent_class)->hide (spgroup, key);
+//    CLPEItem::onHide(key);
+}
+
+// CPPIFY: remove
 static void
 sp_group_hide (SPItem *item, unsigned int key)
 {
-    SP_GROUP(item)->group->hide(key);
+    ((SPGroup*)item)->cgroup->onHide(key);
 }
 
-static void sp_group_snappoints(SPItem const *item, std::vector<Inkscape::SnapCandidatePoint> &p, Inkscape::SnapPreferences const *snapprefs)
-{
+void CGroup::onSnappoints(std::vector<Inkscape::SnapCandidatePoint> &p, Inkscape::SnapPreferences const *snapprefs) {
+	SPGroup* item = this->spgroup;
+
     for ( SPObject const *o = item->firstChild(); o; o = o->getNext() )
     {
         if (SP_IS_ITEM(o)) {
@@ -336,6 +559,12 @@ static void sp_group_snappoints(SPItem const *item, std::vector<Inkscape::SnapCa
     }
 }
 
+// CPPIFY: remove
+static void sp_group_snappoints(SPItem const *item, std::vector<Inkscape::SnapCandidatePoint> &p, Inkscape::SnapPreferences const *snapprefs)
+{
+	((SPGroup*)item)->cgroup->onSnappoints(p, snapprefs);
+}
+
 
 void
 sp_item_group_ungroup (SPGroup *group, GSList **children, bool do_done)
@@ -583,152 +812,9 @@ void SPGroup::translateChildItems(Geom::Translate const &tr)
     }
 }
 
-CGroup::CGroup(SPGroup *group) {
-    _group = group;
-}
-
-CGroup::~CGroup() {
-}
-
-void CGroup::onChildAdded(Inkscape::XML::Node *child) {
-    SPObject *last_child = _group->lastChild();
-    if (last_child && last_child->getRepr() == child) {
-        // optimization for the common special case where the child is being added at the end
-        SPObject *ochild = last_child;
-        if ( SP_IS_ITEM(ochild) ) {
-            /* TODO: this should be moved into SPItem somehow */
-            SPItemView *v;
-            Inkscape::DrawingItem *ac;
-
-            for (v = _group->display; v != NULL; v = v->next) {
-                ac = SP_ITEM (ochild)->invoke_show (v->arenaitem->drawing(), v->key, v->flags);
-
-                if (ac) {
-                    v->arenaitem->appendChild(ac);
-                }
-            }
-        }
-    } else {    // general case
-        SPObject *ochild = _group->get_child_by_repr(child);
-        if ( ochild && SP_IS_ITEM(ochild) ) {
-            /* TODO: this should be moved into SPItem somehow */
-            SPItemView *v;
-            Inkscape::DrawingItem *ac;
-
-            unsigned position = SP_ITEM(ochild)->pos_in_parent();
-
-            for (v = _group->display; v != NULL; v = v->next) {
-                ac = SP_ITEM (ochild)->invoke_show (v->arenaitem->drawing(), v->key, v->flags);
-
-                if (ac) {
-                    v->arenaitem->prependChild(ac);
-                    ac->setZOrder(position);
-                }
-            }
-        }
-    }
-
-    _group->requestModified(SP_OBJECT_MODIFIED_FLAG);
-}
-
-void CGroup::onChildRemoved(Inkscape::XML::Node */*child*/) {
-    _group->requestModified(SP_OBJECT_MODIFIED_FLAG);
-}
-
-void CGroup::onUpdate(SPCtx *ctx, unsigned int flags) {
-    SPItemCtx *ictx, cctx;
-
-    ictx = (SPItemCtx *) ctx;
-    cctx = *ictx;
-
-    if (flags & SP_OBJECT_MODIFIED_FLAG) {
-      flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
-    }
-
-    flags &= SP_OBJECT_MODIFIED_CASCADE;
-
-    if (flags & SP_OBJECT_STYLE_MODIFIED_FLAG) {
-        SPObject *object = _group;
-        for (SPItemView *v = _group->display; v != NULL; v = v->next) {
-            Inkscape::DrawingGroup *group = dynamic_cast<Inkscape::DrawingGroup *>(v->arenaitem);
-            group->setStyle(object->style);
-        }
-    }
-
-    GSList *l = g_slist_reverse(_group->childList(true, SPObject::ActionUpdate));
-    while (l) {
-        SPObject *child = SP_OBJECT (l->data);
-        l = g_slist_remove (l, child);
-        if (flags || (child->uflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
-            if (SP_IS_ITEM (child)) {
-                SPItem const &chi = *SP_ITEM(child);
-                cctx.i2doc = chi.transform * ictx->i2doc;
-                cctx.i2vp = chi.transform * ictx->i2vp;
-                child->updateDisplay((SPCtx *)&cctx, flags);
-            } else {
-                child->updateDisplay(ctx, flags);
-            }
-        }
-        g_object_unref (G_OBJECT (child));
-    }
-}
-
-void CGroup::onModified(guint flags) {
-    SPObject *child;
-
-    if (flags & SP_OBJECT_MODIFIED_FLAG) flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
-    flags &= SP_OBJECT_MODIFIED_CASCADE;
-
-    if (flags & SP_OBJECT_STYLE_MODIFIED_FLAG) {
-        SPObject *object = _group;
-        for (SPItemView *v = _group->display; v != NULL; v = v->next) {
-            Inkscape::DrawingGroup *group = dynamic_cast<Inkscape::DrawingGroup *>(v->arenaitem);
-            group->setStyle(object->style);
-        }
-    }
-
-    GSList *l = g_slist_reverse(_group->childList(true));
-    while (l) {
-        child = SP_OBJECT (l->data);
-        l = g_slist_remove (l, child);
-        if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
-            child->emitModified(flags);
-        }
-        g_object_unref (G_OBJECT (child));
-    }
-}
-
-Geom::OptRect CGroup::bounds(SPItem::BBoxType type, Geom::Affine const &transform)
-{
-    Geom::OptRect bbox;
-
-    GSList *l = _group->childList(false, SPObject::ActionBBox);
-    while (l) {
-        SPObject *o = SP_OBJECT (l->data);
-        if (SP_IS_ITEM(o) && !SP_ITEM(o)->isHidden()) {
-            SPItem *child = SP_ITEM(o);
-            Geom::Affine const ct(child->transform * transform);
-            bbox |= child->bounds(type, ct);
-        }
-        l = g_slist_remove (l, o);
-    }
-    return bbox;
-}
-
-void CGroup::onPrint(SPPrintContext *ctx) {
-    GSList *l = g_slist_reverse(_group->childList(false));
-    while (l) {
-        SPObject *o = SP_OBJECT (l->data);
-        if (SP_IS_ITEM(o)) {
-            SP_ITEM(o)->invoke_print (ctx);
-        }
-        l = g_slist_remove (l, o);
-    }
-}
-
-gint CGroup::getItemCount() {
+gint SPGroup::getItemCount() {
     gint len = 0;
-    for (SPObject *o = _group->firstChild() ; o ; o = o->getNext() ) {
+    for (SPObject *o = this->firstChild() ; o ; o = o->getNext() ) {
         if (SP_IS_ITEM(o)) {
             len++;
         }
@@ -737,30 +823,10 @@ gint CGroup::getItemCount() {
     return len;
 }
 
-gchar *CGroup::getDescription() {
-    gint len = getItemCount();
-    return g_strdup_printf(
-            ngettext("<b>Group</b> of <b>%d</b> object",
-                 "<b>Group</b> of <b>%d</b> objects",
-                 len), len);
-}
-
-Inkscape::DrawingItem *CGroup::show (Inkscape::Drawing &drawing, unsigned int key, unsigned int flags) {
-    Inkscape::DrawingGroup *ai;
-    SPObject *object = _group;
-
-    ai = new Inkscape::DrawingGroup(drawing);
-    ai->setPickChildren(_group->effectiveLayerMode(key) == SPGroup::LAYER);
-    ai->setStyle(object->style);
-
-    _showChildren(drawing, ai, key, flags);
-    return ai;
-}
-
-void CGroup::_showChildren (Inkscape::Drawing &drawing, Inkscape::DrawingItem *ai, unsigned int key, unsigned int flags) {
+void SPGroup::_showChildren (Inkscape::Drawing &drawing, Inkscape::DrawingItem *ai, unsigned int key, unsigned int flags) {
     Inkscape::DrawingItem *ac = NULL;
     SPItem * child = NULL;
-    GSList *l = g_slist_reverse(_group->childList(false, SPObject::ActionShow));
+    GSList *l = g_slist_reverse(this->childList(false, SPObject::ActionShow));
     while (l) {
         SPObject *o = SP_OBJECT (l->data);
         if (SP_IS_ITEM (o)) {
@@ -772,41 +838,9 @@ void CGroup::_showChildren (Inkscape::Drawing &drawing, Inkscape::DrawingItem *a
     }
 }
 
-void CGroup::hide (unsigned int key) {
-    SPItem * child;
-
-    GSList *l = g_slist_reverse(_group->childList(false, SPObject::ActionShow));
-    while (l) {
-        SPObject *o = SP_OBJECT (l->data);
-        if (SP_IS_ITEM (o)) {
-            child = SP_ITEM (o);
-            child->invoke_hide (key);
-        }
-        l = g_slist_remove (l, o);
-    }
-
-    if (((SPItemClass *) parent_class)->hide)
-        ((SPItemClass *) parent_class)->hide (_group, key);
-}
-
-void CGroup::onOrderChanged (Inkscape::XML::Node *child, Inkscape::XML::Node *, Inkscape::XML::Node *)
-{
-    SPObject *ochild = _group->get_child_by_repr(child);
-    if ( ochild && SP_IS_ITEM(ochild) ) {
-        /* TODO: this should be moved into SPItem somehow */
-        SPItemView *v;
-        unsigned position = SP_ITEM(ochild)->pos_in_parent();
-        for ( v = SP_ITEM (ochild)->display ; v != NULL ; v = v->next ) {
-            v->arenaitem->setZOrder(position);
-        }
-    }
-
-    _group->requestModified(SP_OBJECT_MODIFIED_FLAG);
-}
+void CGroup::onUpdatePatheffect(bool write) {
+	SPGroup* lpeitem = this->spgroup;
 
-static void
-sp_group_update_patheffect (SPLPEItem *lpeitem, bool write)
-{
 #ifdef GROUP_VERBOSE
     g_message("sp_group_update_patheffect: %p\n", lpeitem);
 #endif
@@ -836,6 +870,13 @@ sp_group_update_patheffect (SPLPEItem *lpeitem, bool write)
     }
 }
 
+// CPPIFY: remove
+static void
+sp_group_update_patheffect (SPLPEItem *lpeitem, bool write)
+{
+	((SPGroup*)lpeitem)->cgroup->onUpdatePatheffect(write);
+}
+
 static void
 sp_group_perform_patheffect(SPGroup *group, SPGroup *topgroup, bool write)
 {
diff --git a/src/sp-item-group.h b/src/sp-item-group.h
index c13fa2b75..d5e8cc771 100644
--- a/src/sp-item-group.h
+++ b/src/sp-item-group.h
@@ -33,7 +33,10 @@ class DrawingItem;
 
 } // namespace Inkscape
 
-struct SPGroup : public SPLPEItem {
+class SPGroup : public SPLPEItem {
+public:
+    CGroup *cgroup;
+
     enum LayerMode { GROUP, LAYER, MASK_HELPER };
 
     LayerMode _layer_mode;
@@ -54,8 +57,9 @@ struct SPGroup : public SPLPEItem {
     void setLayerDisplayMode(unsigned int display_key, LayerMode mode);
     void translateChildItems(Geom::Translate const &tr);
 
-    CGroup *group;
-    
+    gint getItemCount();
+    void _showChildren (Inkscape::Drawing &drawing, Inkscape::DrawingItem *ai, unsigned int key, unsigned int flags);
+
 private:
     void _updateLayerMode(unsigned int display_key=0);
 };
@@ -64,33 +68,43 @@ struct SPGroupClass {
     SPLPEItemClass parent_class;
 };
 
+
 /*
  * Virtual methods of SPGroup
  */
-class CGroup {
+class CGroup : public CLPEItem {
 public:
     CGroup(SPGroup *group);
     virtual ~CGroup();
     
-    virtual void onChildAdded(Inkscape::XML::Node *child);
-    virtual void onChildRemoved(Inkscape::XML::Node *child);
+    virtual void onBuild(SPDocument *document, Inkscape::XML::Node *repr);
+   	virtual void onRelease();
+
+    virtual void onChildAdded(Inkscape::XML::Node* child, Inkscape::XML::Node* ref);
+    virtual void onRemoveChild(Inkscape::XML::Node *child);
+    virtual void onOrderChanged(Inkscape::XML::Node *child, Inkscape::XML::Node *old_ref, Inkscape::XML::Node *new_ref);
+
     virtual void onUpdate(SPCtx *ctx, unsigned int flags);
     virtual void onModified(guint flags);
-    virtual Geom::OptRect bounds(SPItem::BBoxType type, Geom::Affine const &transform);
+    virtual void onSet(unsigned int key, gchar const* value);
+
+    virtual Inkscape::XML::Node* onWrite(Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags);
+
+    virtual Geom::OptRect onBbox(Geom::Affine const &transform, SPItem::BBoxType bboxtype);
     virtual void onPrint(SPPrintContext *ctx);
-    virtual void onOrderChanged(Inkscape::XML::Node *child, Inkscape::XML::Node *old_ref, Inkscape::XML::Node *new_ref);
-    virtual gchar *getDescription();
-    virtual Inkscape::DrawingItem *show (Inkscape::Drawing &drawing, unsigned int key, unsigned int flags);
-    virtual void hide (unsigned int key);
+    virtual gchar *onDescription();
+    virtual Inkscape::DrawingItem *onShow (Inkscape::Drawing &drawing, unsigned int key, unsigned int flags);
+    virtual void onHide (unsigned int key);
 
-    gint getItemCount();
+    virtual void onSnappoints(std::vector<Inkscape::SnapCandidatePoint> &p, Inkscape::SnapPreferences const *snapprefs);
 
-protected:
-    virtual void _showChildren (Inkscape::Drawing &drawing, Inkscape::DrawingItem *ai, unsigned int key, unsigned int flags);
+    virtual void onUpdatePatheffect(bool write);
 
-    SPGroup *_group;
+protected:
+    SPGroup *spgroup;
 };
 
+
 GType sp_group_get_type (void);
 
 void sp_item_group_ungroup (SPGroup *group, GSList **children, bool do_done = true);
diff --git a/src/sp-switch.cpp b/src/sp-switch.cpp
index 500e43c9c..2c98c54fc 100644
--- a/src/sp-switch.cpp
+++ b/src/sp-switch.cpp
@@ -30,7 +30,7 @@ static void sp_switch_init (SPSwitch *group);
 
 static SPGroupClass * parent_class;
 
-GType CSwitch::getType (void)
+GType SPSwitch::getType (void)
 {
 	static GType switch_type = 0;
 	if (!switch_type) {
@@ -56,24 +56,27 @@ sp_switch_class_init (SPSwitchClass *) {
     parent_class = (SPGroupClass *)g_type_class_ref (SP_TYPE_GROUP);
 }
 
-static void sp_switch_init (SPSwitch *group)
-{
-    if (group->group)
-        delete group->group;
-
-    group->group = new CSwitch(group);
+CSwitch::CSwitch(SPSwitch* sw) : CGroup(sw) {
+	this->spswitch = sw;
 }
 
-CSwitch::CSwitch(SPGroup *group) : CGroup(group), _cached_item(NULL) {
+CSwitch::~CSwitch() {
 }
 
-CSwitch::~CSwitch() {
-    _releaseLastItem(_cached_item);
+static void sp_switch_init (SPSwitch *sw)
+{
+    sw->cswitch = new CSwitch(sw);
+    sw->cgroup = sw->cswitch;
+    sw->clpeitem = sw->cswitch;
+    sw->citem = sw->cswitch;
+    sw->cobject = sw->cswitch;
+
+    sw->_cached_item = 0;
 }
 
-SPObject *CSwitch::_evaluateFirst() {
+SPObject *SPSwitch::_evaluateFirst() {
     SPObject *first = 0;
-    for (SPObject *child = _group->firstChild() ; child && !first ; child = child->getNext() ) {
+    for (SPObject *child = this->firstChild() ; child && !first ; child = child->getNext() ) {
         if (SP_IS_ITEM(child) && sp_item_evaluate(SP_ITEM(child))) {
 	    first = child;
 	}
@@ -81,9 +84,9 @@ SPObject *CSwitch::_evaluateFirst() {
     return first;
 }
 
-GSList *CSwitch::_childList(bool add_ref, SPObject::Action action) {
+GSList *SPSwitch::_childList(bool add_ref, SPObject::Action action) {
     if ( action != SPObject::ActionGeneral ) {
-        return _group->childList(add_ref, action);
+        return this->childList(add_ref, action);
     }
 
     SPObject *child = _evaluateFirst();
@@ -96,28 +99,28 @@ GSList *CSwitch::_childList(bool add_ref, SPObject::Action action) {
     return g_slist_prepend (NULL, child);
 }
 
-gchar *CSwitch::getDescription() {
-    gint len = getItemCount();
+gchar *CSwitch::onDescription() {
+    gint len = this->spgroup->getItemCount();
     return g_strdup_printf(
             ngettext("<b>Conditional group</b> of <b>%d</b> object",
                  "<b>Conditional group</b> of <b>%d</b> objects",
                  len), len);
 }
 
-void CSwitch::onChildAdded(Inkscape::XML::Node *) {
-    _reevaluate(true);
+void CSwitch::onChildAdded(Inkscape::XML::Node* child, Inkscape::XML::Node* ref) {
+    this->spswitch->_reevaluate(true);
 }
 
-void CSwitch::onChildRemoved(Inkscape::XML::Node *) {
-    _reevaluate();
+void CSwitch::onRemoveChild(Inkscape::XML::Node *) {
+	this->spswitch->_reevaluate();
 }
 
 void CSwitch::onOrderChanged (Inkscape::XML::Node *, Inkscape::XML::Node *, Inkscape::XML::Node *)
 {
-    _reevaluate();
+	this->spswitch->_reevaluate();
 }
 
-void CSwitch::_reevaluate(bool /*add_to_drawing*/) {
+void SPSwitch::_reevaluate(bool /*add_to_drawing*/) {
     SPObject *evaluated_child = _evaluateFirst();
     if (!evaluated_child || _cached_item == evaluated_child) {
         return;
@@ -138,29 +141,29 @@ void CSwitch::_reevaluate(bool /*add_to_drawing*/) {
     }
 
     _cached_item = evaluated_child;
-    _release_connection = evaluated_child->connectRelease(sigc::bind(sigc::ptr_fun(&CSwitch::_releaseItem), this));
+    _release_connection = evaluated_child->connectRelease(sigc::bind(sigc::ptr_fun(&SPSwitch::_releaseItem), this));
 
-    _group->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
+    this->requestDisplayUpdate(SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_STYLE_MODIFIED_FLAG);
 }
 
-void CSwitch::_releaseItem(SPObject *obj, CSwitch *selection)
+void SPSwitch::_releaseItem(SPObject *obj, SPSwitch *selection)
 {
     selection->_releaseLastItem(obj);
 }
 
-void CSwitch::_releaseLastItem(SPObject *obj)
+void SPSwitch::_releaseLastItem(SPObject *obj)
 {
-    if (NULL == _cached_item || _cached_item != obj)
+    if (NULL == this->_cached_item || this->_cached_item != obj)
         return;
 
-    _release_connection.disconnect();
-    _cached_item = NULL;
+    this->_release_connection.disconnect();
+    this->_cached_item = NULL;
 }
 
-void CSwitch::_showChildren (Inkscape::Drawing &drawing, Inkscape::DrawingItem *ai, unsigned int key, unsigned int flags) {
-    SPObject *evaluated_child = _evaluateFirst();
+void SPSwitch::_showChildren (Inkscape::Drawing &drawing, Inkscape::DrawingItem *ai, unsigned int key, unsigned int flags) {
+    SPObject *evaluated_child = this->_evaluateFirst();
 
-    GSList *l = _childList(false, SPObject::ActionShow);
+    GSList *l = this->_childList(false, SPObject::ActionShow);
     while (l) {
         SPObject *o = SP_OBJECT (l->data);
         if (SP_IS_ITEM (o)) {
diff --git a/src/sp-switch.h b/src/sp-switch.h
index c2c98e3b3..6e8250c5e 100644
--- a/src/sp-switch.h
+++ b/src/sp-switch.h
@@ -17,48 +17,56 @@
 #include <stddef.h>
 #include <sigc++/connection.h>
 
-#define SP_TYPE_SWITCH            (CSwitch::getType())
+#define SP_TYPE_SWITCH            (SPSwitch::getType())
 #define SP_SWITCH(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SP_TYPE_SWITCH, SPSwitch))
 #define SP_SWITCH_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SP_TYPE_SWITCH, SPSwitchClass))
 #define SP_IS_SWITCH(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SP_TYPE_SWITCH))
 #define SP_IS_SWITCH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SP_TYPE_SWITCH))
 
-/*
- * Virtual methods of SPSwitch
- */
-class CSwitch : public CGroup {
+class CSwitch;
+
+class SPSwitch : public SPGroup {
 public:
-    CSwitch(SPGroup *group);
-    virtual ~CSwitch();
+	CSwitch* cswitch;
 
-    friend class SPSwitch;
+	static GType getType();
 
-    static GType getType();
-    
-    virtual void onChildAdded(Inkscape::XML::Node *child);
-    virtual void onChildRemoved(Inkscape::XML::Node *child);
-    virtual void onOrderChanged(Inkscape::XML::Node *child, Inkscape::XML::Node *old_ref, Inkscape::XML::Node *new_ref);
-    virtual gchar *getDescription();
+    void resetChildEvaluated() { _reevaluate(); }
+
+    GSList *_childList(bool add_ref, SPObject::Action action);
+    void _showChildren (Inkscape::Drawing &drawing, Inkscape::DrawingItem *ai, unsigned int key, unsigned int flags);
 
-protected:
-    virtual GSList *_childList(bool add_ref, SPObject::Action action);
-    virtual void _showChildren (Inkscape::Drawing &drawing, Inkscape::DrawingItem *ai, unsigned int key, unsigned int flags);
-    
     SPObject *_evaluateFirst();
     void _reevaluate(bool add_to_arena = false);
-    static void _releaseItem(SPObject *obj, CSwitch *selection);
+    static void _releaseItem(SPObject *obj, SPSwitch *selection);
     void _releaseLastItem(SPObject *obj);
 
-private:
     SPObject *_cached_item;
     sigc::connection _release_connection;
 };
 
-struct SPSwitch : public SPGroup {
-    void resetChildEvaluated() { (static_cast<CSwitch *>(group))->_reevaluate(); }
+struct SPSwitchClass : public SPGroupClass {
 };
 
-struct SPSwitchClass : public SPGroupClass {
+
+/*
+ * Virtual methods of SPSwitch
+ */
+class CSwitch : public CGroup {
+public:
+    CSwitch(SPSwitch *sw);
+    virtual ~CSwitch();
+
+    friend class SPSwitch;
+
+    virtual void onChildAdded(Inkscape::XML::Node* child, Inkscape::XML::Node* ref);
+    virtual void onRemoveChild(Inkscape::XML::Node *child);
+    virtual void onOrderChanged(Inkscape::XML::Node *child, Inkscape::XML::Node *old_ref, Inkscape::XML::Node *new_ref);
+    virtual gchar *onDescription();
+
+protected:
+    SPSwitch* spswitch;
 };
 
+
 #endif