From 72f9ed8e6a94b65a3fbc9582179e6e72330ff144 Mon Sep 17 00:00:00 2001 From: Markus Engel Date: Sun, 19 Aug 2012 01:40:03 +0200 Subject: 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) --- src/sp-conn-end-pair.cpp | 2 +- src/sp-item-group.cpp | 539 +++++++++++++++++++++++++---------------------- src/sp-item-group.h | 44 ++-- src/sp-switch.cpp | 67 +++--- src/sp-switch.h | 54 +++-- 5 files changed, 386 insertions(+), 320 deletions(-) (limited to 'src') 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(); + new (&group->_display_modes) std::map(); } -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(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(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("Group of %d object", + "Group of %d 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 &p, Inkscape::SnapPreferences const *snapprefs) -{ +void CGroup::onSnappoints(std::vector &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 &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(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(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("Group of %d object", - "Group of %d 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 &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("Conditional group of %d object", "Conditional group of %d 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 #include -#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(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 -- cgit v1.2.3