From a7737572814d97dfa1fc286c369e375a1f58089b Mon Sep 17 00:00:00 2001 From: Markus Engel Date: Tue, 21 Aug 2012 21:40:53 +0200 Subject: Added "virtual pad" to SPMissingGlyph. (bzr r11608.1.44) --- src/sp-missing-glyph.cpp | 104 ++++++++++++++++++++++++++++------------------- 1 file changed, 63 insertions(+), 41 deletions(-) (limited to 'src/sp-missing-glyph.cpp') diff --git a/src/sp-missing-glyph.cpp b/src/sp-missing-glyph.cpp index fdf75253e..778a9945a 100644 --- a/src/sp-missing-glyph.cpp +++ b/src/sp-missing-glyph.cpp @@ -66,8 +66,18 @@ static void sp_missing_glyph_class_init(SPMissingGlyphClass *gc) sp_object_class->write = sp_missing_glyph_write; } +CMissingGlyph::CMissingGlyph(SPMissingGlyph* mg) : CObject(mg) { + this->spmissingglyph = mg; +} + +CMissingGlyph::~CMissingGlyph() { +} + static void sp_missing_glyph_init(SPMissingGlyph *glyph) { + glyph->cmissingglyph = new CMissingGlyph(glyph); + glyph->cobject = glyph->cmissingglyph; + //TODO: correct these values: glyph->d = NULL; glyph->horiz_adv_x = 0; @@ -76,11 +86,10 @@ static void sp_missing_glyph_init(SPMissingGlyph *glyph) glyph->vert_adv_y = 0; } -static void sp_missing_glyph_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr) -{ - if (((SPObjectClass *) (parent_class))->build) { - ((SPObjectClass *) (parent_class))->build(object, document, repr); - } +void CMissingGlyph::onBuild(SPDocument* doc, Inkscape::XML::Node* repr) { + SPMissingGlyph* object = this->spmissingglyph; + + CObject::onBuild(doc, repr); object->readAttr( "d" ); object->readAttr( "horiz-adv-x" ); @@ -89,17 +98,23 @@ static void sp_missing_glyph_build(SPObject *object, SPDocument *document, Inksc object->readAttr( "vert-adv-y" ); } -static void sp_missing_glyph_release(SPObject *object) +static void sp_missing_glyph_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr) { - //SPMissingGlyph *glyph = SP_MISSING_GLYPH(object); + ((SPMissingGlyph*)object)->cmissingglyph->onBuild(document, repr); +} - if (((SPObjectClass *) parent_class)->release) { - ((SPObjectClass *) parent_class)->release(object); - } +void CMissingGlyph::onRelease() { + CObject::onRelease(); } -static void sp_missing_glyph_set(SPObject *object, unsigned int key, const gchar *value) +static void sp_missing_glyph_release(SPObject *object) { + ((SPMissingGlyph*)object)->cmissingglyph->onRelease(); +} + +void CMissingGlyph::onSet(unsigned int key, const gchar* value) { + SPMissingGlyph* object = this->spmissingglyph; + SPMissingGlyph *glyph = SP_MISSING_GLYPH(object); switch (key) { @@ -150,47 +165,54 @@ static void sp_missing_glyph_set(SPObject *object, unsigned int key, const gchar } default: { - if (((SPObjectClass *) (parent_class))->set) { - ((SPObjectClass *) (parent_class))->set(object, key, value); - } + CObject::onSet(key, value); break; } } } +static void sp_missing_glyph_set(SPObject *object, unsigned int key, const gchar *value) +{ + ((SPMissingGlyph*)object)->cmissingglyph->onSet(key, value); +} + #define COPY_ATTR(rd,rs,key) (rd)->setAttribute((key), rs->attribute(key)); -static Inkscape::XML::Node *sp_missing_glyph_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags) -{ -// SPMissingGlyph *glyph = SP_MISSING_GLYPH(object); +Inkscape::XML::Node* CMissingGlyph::onWrite(Inkscape::XML::Document* xml_doc, Inkscape::XML::Node* repr, guint flags) { + SPMissingGlyph* object = this->spmissingglyph; - if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) { - repr = xml_doc->createElement("svg:glyph"); - } + // SPMissingGlyph *glyph = SP_MISSING_GLYPH(object); -/* I am commenting out this part because I am not certain how does it work. I will have to study it later. Juca - repr->setAttribute("d", glyph->d); - sp_repr_set_svg_double(repr, "horiz-adv-x", glyph->horiz_adv_x); - sp_repr_set_svg_double(repr, "vert-origin-x", glyph->vert_origin_x); - sp_repr_set_svg_double(repr, "vert-origin-y", glyph->vert_origin_y); - sp_repr_set_svg_double(repr, "vert-adv-y", glyph->vert_adv_y); -*/ - if (repr != object->getRepr()) { - - // All the COPY_ATTR functions below use - // XML Tree directly while they shouldn't. - COPY_ATTR(repr, object->getRepr(), "d"); - COPY_ATTR(repr, object->getRepr(), "horiz-adv-x"); - COPY_ATTR(repr, object->getRepr(), "vert-origin-x"); - COPY_ATTR(repr, object->getRepr(), "vert-origin-y"); - COPY_ATTR(repr, object->getRepr(), "vert-adv-y"); - } + if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) { + repr = xml_doc->createElement("svg:glyph"); + } - if (((SPObjectClass *) (parent_class))->write) { - ((SPObjectClass *) (parent_class))->write(object, xml_doc, repr, flags); - } + /* I am commenting out this part because I am not certain how does it work. I will have to study it later. Juca + repr->setAttribute("d", glyph->d); + sp_repr_set_svg_double(repr, "horiz-adv-x", glyph->horiz_adv_x); + sp_repr_set_svg_double(repr, "vert-origin-x", glyph->vert_origin_x); + sp_repr_set_svg_double(repr, "vert-origin-y", glyph->vert_origin_y); + sp_repr_set_svg_double(repr, "vert-adv-y", glyph->vert_adv_y); + */ + if (repr != object->getRepr()) { + + // All the COPY_ATTR functions below use + // XML Tree directly while they shouldn't. + COPY_ATTR(repr, object->getRepr(), "d"); + COPY_ATTR(repr, object->getRepr(), "horiz-adv-x"); + COPY_ATTR(repr, object->getRepr(), "vert-origin-x"); + COPY_ATTR(repr, object->getRepr(), "vert-origin-y"); + COPY_ATTR(repr, object->getRepr(), "vert-adv-y"); + } + + CObject::onWrite(xml_doc, repr, flags); - return repr; + return repr; +} + +static Inkscape::XML::Node *sp_missing_glyph_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags) +{ + return ((SPMissingGlyph*)object)->cmissingglyph->onWrite(xml_doc, repr, flags); } #endif //#ifdef ENABLE_SVG_FONTS /* -- cgit v1.2.3 From a0a8d020201e0e38a63d9aa3dce228d7d9e6fb35 Mon Sep 17 00:00:00 2001 From: Markus Engel Date: Thu, 14 Mar 2013 12:42:39 +0100 Subject: Various changes. (bzr r11608.1.48) --- src/sp-missing-glyph.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/sp-missing-glyph.cpp') diff --git a/src/sp-missing-glyph.cpp b/src/sp-missing-glyph.cpp index 778a9945a..284f9d092 100644 --- a/src/sp-missing-glyph.cpp +++ b/src/sp-missing-glyph.cpp @@ -60,7 +60,7 @@ static void sp_missing_glyph_class_init(SPMissingGlyphClass *gc) parent_class = (SPObjectClass*)g_type_class_peek_parent(gc); - sp_object_class->build = sp_missing_glyph_build; + //sp_object_class->build = sp_missing_glyph_build; sp_object_class->release = sp_missing_glyph_release; sp_object_class->set = sp_missing_glyph_set; sp_object_class->write = sp_missing_glyph_write; -- cgit v1.2.3 From 957c3e4b7909d42c5a13f1b1dd583f877fc32259 Mon Sep 17 00:00:00 2001 From: Markus Engel Date: Sat, 30 Mar 2013 00:46:57 +0100 Subject: Removed function pointers from SPObject and subclasses. Added some missing virtual pads for classes that were hidden by preprocessor macros. (bzr r11608.1.55) --- src/sp-missing-glyph.cpp | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) (limited to 'src/sp-missing-glyph.cpp') diff --git a/src/sp-missing-glyph.cpp b/src/sp-missing-glyph.cpp index 284f9d092..78fc4515f 100644 --- a/src/sp-missing-glyph.cpp +++ b/src/sp-missing-glyph.cpp @@ -61,9 +61,9 @@ static void sp_missing_glyph_class_init(SPMissingGlyphClass *gc) parent_class = (SPObjectClass*)g_type_class_peek_parent(gc); //sp_object_class->build = sp_missing_glyph_build; - sp_object_class->release = sp_missing_glyph_release; - sp_object_class->set = sp_missing_glyph_set; - sp_object_class->write = sp_missing_glyph_write; +// sp_object_class->release = sp_missing_glyph_release; +// sp_object_class->set = sp_missing_glyph_set; +// sp_object_class->write = sp_missing_glyph_write; } CMissingGlyph::CMissingGlyph(SPMissingGlyph* mg) : CObject(mg) { -- cgit v1.2.3 From 7df6616da5ea2debb86838366ddf746841549cdb Mon Sep 17 00:00:00 2001 From: Markus Engel Date: Sat, 30 Mar 2013 00:56:13 +0100 Subject: Renamed virtual function names. (bzr r11608.1.57) --- src/sp-missing-glyph.cpp | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) (limited to 'src/sp-missing-glyph.cpp') diff --git a/src/sp-missing-glyph.cpp b/src/sp-missing-glyph.cpp index 6ed413f1d..227f4d802 100644 --- a/src/sp-missing-glyph.cpp +++ b/src/sp-missing-glyph.cpp @@ -47,10 +47,10 @@ static void sp_missing_glyph_init(SPMissingGlyph *glyph) glyph->vert_adv_y = 0; } -void CMissingGlyph::onBuild(SPDocument* doc, Inkscape::XML::Node* repr) { +void CMissingGlyph::build(SPDocument* doc, Inkscape::XML::Node* repr) { SPMissingGlyph* object = this->spmissingglyph; - CObject::onBuild(doc, repr); + CObject::build(doc, repr); object->readAttr( "d" ); object->readAttr( "horiz-adv-x" ); @@ -59,12 +59,12 @@ void CMissingGlyph::onBuild(SPDocument* doc, Inkscape::XML::Node* repr) { object->readAttr( "vert-adv-y" ); } -void CMissingGlyph::onRelease() { - CObject::onRelease(); +void CMissingGlyph::release() { + CObject::release(); } -void CMissingGlyph::onSet(unsigned int key, const gchar* value) { +void CMissingGlyph::set(unsigned int key, const gchar* value) { SPMissingGlyph* object = this->spmissingglyph; SPMissingGlyph *glyph = SP_MISSING_GLYPH(object); @@ -117,7 +117,7 @@ void CMissingGlyph::onSet(unsigned int key, const gchar* value) { } default: { - CObject::onSet(key, value); + CObject::set(key, value); break; } } @@ -125,7 +125,7 @@ void CMissingGlyph::onSet(unsigned int key, const gchar* value) { #define COPY_ATTR(rd,rs,key) (rd)->setAttribute((key), rs->attribute(key)); -Inkscape::XML::Node* CMissingGlyph::onWrite(Inkscape::XML::Document* xml_doc, Inkscape::XML::Node* repr, guint flags) { +Inkscape::XML::Node* CMissingGlyph::write(Inkscape::XML::Document* xml_doc, Inkscape::XML::Node* repr, guint flags) { SPMissingGlyph* object = this->spmissingglyph; // SPMissingGlyph *glyph = SP_MISSING_GLYPH(object); @@ -152,7 +152,7 @@ Inkscape::XML::Node* CMissingGlyph::onWrite(Inkscape::XML::Document* xml_doc, In COPY_ATTR(repr, object->getRepr(), "vert-adv-y"); } - CObject::onWrite(xml_doc, repr, flags); + CObject::write(xml_doc, repr, flags); return repr; } -- cgit v1.2.3 From a5d6e692d661f0bf7648e64e8fcb04588bb8f3ab Mon Sep 17 00:00:00 2001 From: Markus Engel Date: Mon, 1 Apr 2013 00:07:00 +0200 Subject: Prepared exchange of casting macros. (bzr r11608.1.63) --- src/sp-missing-glyph.cpp | 1 + 1 file changed, 1 insertion(+) (limited to 'src/sp-missing-glyph.cpp') diff --git a/src/sp-missing-glyph.cpp b/src/sp-missing-glyph.cpp index 227f4d802..b69c8f162 100644 --- a/src/sp-missing-glyph.cpp +++ b/src/sp-missing-glyph.cpp @@ -35,6 +35,7 @@ CMissingGlyph::~CMissingGlyph() { static void sp_missing_glyph_init(SPMissingGlyph *glyph) { glyph->cmissingglyph = new CMissingGlyph(glyph); + glyph->typeHierarchy.insert(typeid(SPMissingGlyph)); delete glyph->cobject; glyph->cobject = glyph->cmissingglyph; -- cgit v1.2.3 From 69f3b6f1abb2bb422935d43262e1e99aab359954 Mon Sep 17 00:00:00 2001 From: Markus Engel Date: Tue, 2 Apr 2013 01:41:30 +0200 Subject: Added constructors to SP classes. (bzr r11608.1.67) --- src/sp-missing-glyph.cpp | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) (limited to 'src/sp-missing-glyph.cpp') diff --git a/src/sp-missing-glyph.cpp b/src/sp-missing-glyph.cpp index b69c8f162..c1db6e26d 100644 --- a/src/sp-missing-glyph.cpp +++ b/src/sp-missing-glyph.cpp @@ -19,7 +19,7 @@ #include "sp-missing-glyph.h" #include "document.h" -G_DEFINE_TYPE(SPMissingGlyph, sp_missing_glyph, SP_TYPE_OBJECT); +G_DEFINE_TYPE(SPMissingGlyph, sp_missing_glyph, G_TYPE_OBJECT); static void sp_missing_glyph_class_init(SPMissingGlyphClass *gc) { @@ -32,8 +32,9 @@ CMissingGlyph::CMissingGlyph(SPMissingGlyph* mg) : CObject(mg) { CMissingGlyph::~CMissingGlyph() { } -static void sp_missing_glyph_init(SPMissingGlyph *glyph) -{ +SPMissingGlyph::SPMissingGlyph() : SPObject() { + SPMissingGlyph* glyph = this; + glyph->cmissingglyph = new CMissingGlyph(glyph); glyph->typeHierarchy.insert(typeid(SPMissingGlyph)); @@ -48,6 +49,11 @@ static void sp_missing_glyph_init(SPMissingGlyph *glyph) glyph->vert_adv_y = 0; } +static void sp_missing_glyph_init(SPMissingGlyph *glyph) +{ + new (glyph) SPMissingGlyph(); +} + void CMissingGlyph::build(SPDocument* doc, Inkscape::XML::Node* repr) { SPMissingGlyph* object = this->spmissingglyph; -- cgit v1.2.3 From d1af3566872dfff2aeec84859c87f1f8d13f79df Mon Sep 17 00:00:00 2001 From: Markus Engel Date: Tue, 2 Apr 2013 19:14:36 +0200 Subject: Registered classes with new factory. Hkern, Vkern and FeFuncX have to be rewritten, as they aren't real classes. (bzr r11608.1.69) --- src/sp-missing-glyph.cpp | 10 ++++++++++ 1 file changed, 10 insertions(+) (limited to 'src/sp-missing-glyph.cpp') diff --git a/src/sp-missing-glyph.cpp b/src/sp-missing-glyph.cpp index c1db6e26d..1a67a49ad 100644 --- a/src/sp-missing-glyph.cpp +++ b/src/sp-missing-glyph.cpp @@ -19,6 +19,16 @@ #include "sp-missing-glyph.h" #include "document.h" +#include "sp-factory.h" + +namespace { + SPObject* createMissingGlyph() { + return new SPMissingGlyph(); + } + + bool missingGlyphRegistered = SPFactory::instance().registerObject("svg:missing-glyph", createMissingGlyph); +} + G_DEFINE_TYPE(SPMissingGlyph, sp_missing_glyph, G_TYPE_OBJECT); static void sp_missing_glyph_class_init(SPMissingGlyphClass *gc) -- cgit v1.2.3 From 7b7e0294b0c06a8d3ec19b73486a91e12cf67adf Mon Sep 17 00:00:00 2001 From: Markus Engel Date: Sat, 6 Apr 2013 22:16:05 +0200 Subject: Merged more classes. (bzr r11608.1.84) --- src/sp-missing-glyph.cpp | 52 +++++++++++++++--------------------------------- 1 file changed, 16 insertions(+), 36 deletions(-) (limited to 'src/sp-missing-glyph.cpp') diff --git a/src/sp-missing-glyph.cpp b/src/sp-missing-glyph.cpp index 1a67a49ad..ef9843cea 100644 --- a/src/sp-missing-glyph.cpp +++ b/src/sp-missing-glyph.cpp @@ -29,43 +29,23 @@ namespace { bool missingGlyphRegistered = SPFactory::instance().registerObject("svg:missing-glyph", createMissingGlyph); } -G_DEFINE_TYPE(SPMissingGlyph, sp_missing_glyph, G_TYPE_OBJECT); - -static void sp_missing_glyph_class_init(SPMissingGlyphClass *gc) -{ -} - -CMissingGlyph::CMissingGlyph(SPMissingGlyph* mg) : CObject(mg) { - this->spmissingglyph = mg; -} - -CMissingGlyph::~CMissingGlyph() { -} - -SPMissingGlyph::SPMissingGlyph() : SPObject() { - SPMissingGlyph* glyph = this; - - glyph->cmissingglyph = new CMissingGlyph(glyph); - glyph->typeHierarchy.insert(typeid(SPMissingGlyph)); - - delete glyph->cobject; - glyph->cobject = glyph->cmissingglyph; +SPMissingGlyph::SPMissingGlyph() : SPObject(), CObject(this) { + delete this->cobject; + this->cobject = this; //TODO: correct these values: - glyph->d = NULL; - glyph->horiz_adv_x = 0; - glyph->vert_origin_x = 0; - glyph->vert_origin_y = 0; - glyph->vert_adv_y = 0; + this->d = NULL; + this->horiz_adv_x = 0; + this->vert_origin_x = 0; + this->vert_origin_y = 0; + this->vert_adv_y = 0; } -static void sp_missing_glyph_init(SPMissingGlyph *glyph) -{ - new (glyph) SPMissingGlyph(); +SPMissingGlyph::~SPMissingGlyph() { } -void CMissingGlyph::build(SPDocument* doc, Inkscape::XML::Node* repr) { - SPMissingGlyph* object = this->spmissingglyph; +void SPMissingGlyph::build(SPDocument* doc, Inkscape::XML::Node* repr) { + SPMissingGlyph* object = this; CObject::build(doc, repr); @@ -76,13 +56,13 @@ void CMissingGlyph::build(SPDocument* doc, Inkscape::XML::Node* repr) { object->readAttr( "vert-adv-y" ); } -void CMissingGlyph::release() { +void SPMissingGlyph::release() { CObject::release(); } -void CMissingGlyph::set(unsigned int key, const gchar* value) { - SPMissingGlyph* object = this->spmissingglyph; +void SPMissingGlyph::set(unsigned int key, const gchar* value) { + SPMissingGlyph* object = this; SPMissingGlyph *glyph = SP_MISSING_GLYPH(object); @@ -142,8 +122,8 @@ void CMissingGlyph::set(unsigned int key, const gchar* value) { #define COPY_ATTR(rd,rs,key) (rd)->setAttribute((key), rs->attribute(key)); -Inkscape::XML::Node* CMissingGlyph::write(Inkscape::XML::Document* xml_doc, Inkscape::XML::Node* repr, guint flags) { - SPMissingGlyph* object = this->spmissingglyph; +Inkscape::XML::Node* SPMissingGlyph::write(Inkscape::XML::Document* xml_doc, Inkscape::XML::Node* repr, guint flags) { + SPMissingGlyph* object = this; // SPMissingGlyph *glyph = SP_MISSING_GLYPH(object); -- cgit v1.2.3 From 27e2102f96a5554bcd5310ec11435d155773b279 Mon Sep 17 00:00:00 2001 From: Markus Engel Date: Sun, 7 Apr 2013 18:28:22 +0200 Subject: Merge Object and subclasses. Merging of SP- and C-classes complete. (bzr r11608.1.86) --- src/sp-missing-glyph.cpp | 13 +++++-------- 1 file changed, 5 insertions(+), 8 deletions(-) (limited to 'src/sp-missing-glyph.cpp') diff --git a/src/sp-missing-glyph.cpp b/src/sp-missing-glyph.cpp index ef9843cea..a3b440ab0 100644 --- a/src/sp-missing-glyph.cpp +++ b/src/sp-missing-glyph.cpp @@ -29,10 +29,7 @@ namespace { bool missingGlyphRegistered = SPFactory::instance().registerObject("svg:missing-glyph", createMissingGlyph); } -SPMissingGlyph::SPMissingGlyph() : SPObject(), CObject(this) { - delete this->cobject; - this->cobject = this; - +SPMissingGlyph::SPMissingGlyph() : SPObject() { //TODO: correct these values: this->d = NULL; this->horiz_adv_x = 0; @@ -47,7 +44,7 @@ SPMissingGlyph::~SPMissingGlyph() { void SPMissingGlyph::build(SPDocument* doc, Inkscape::XML::Node* repr) { SPMissingGlyph* object = this; - CObject::build(doc, repr); + SPObject::build(doc, repr); object->readAttr( "d" ); object->readAttr( "horiz-adv-x" ); @@ -57,7 +54,7 @@ void SPMissingGlyph::build(SPDocument* doc, Inkscape::XML::Node* repr) { } void SPMissingGlyph::release() { - CObject::release(); + SPObject::release(); } @@ -114,7 +111,7 @@ void SPMissingGlyph::set(unsigned int key, const gchar* value) { } default: { - CObject::set(key, value); + SPObject::set(key, value); break; } } @@ -149,7 +146,7 @@ Inkscape::XML::Node* SPMissingGlyph::write(Inkscape::XML::Document* xml_doc, Ink COPY_ATTR(repr, object->getRepr(), "vert-adv-y"); } - CObject::write(xml_doc, repr, flags); + SPObject::write(xml_doc, repr, flags); return repr; } -- cgit v1.2.3 From bf4a1d2d49850170b936c30cfe2b30e798716406 Mon Sep 17 00:00:00 2001 From: Markus Engel Date: Sat, 3 Aug 2013 03:03:43 +0200 Subject: Cleaned up. (bzr r11608.1.117) --- src/sp-missing-glyph.cpp | 65 +++++++++++++++++++++--------------------------- 1 file changed, 28 insertions(+), 37 deletions(-) (limited to 'src/sp-missing-glyph.cpp') diff --git a/src/sp-missing-glyph.cpp b/src/sp-missing-glyph.cpp index a3b440ab0..06b741165 100644 --- a/src/sp-missing-glyph.cpp +++ b/src/sp-missing-glyph.cpp @@ -42,15 +42,13 @@ SPMissingGlyph::~SPMissingGlyph() { } void SPMissingGlyph::build(SPDocument* doc, Inkscape::XML::Node* repr) { - SPMissingGlyph* object = this; - SPObject::build(doc, repr); - object->readAttr( "d" ); - object->readAttr( "horiz-adv-x" ); - object->readAttr( "vert-origin-x" ); - object->readAttr( "vert-origin-y" ); - object->readAttr( "vert-adv-y" ); + this->readAttr( "d" ); + this->readAttr( "horiz-adv-x" ); + this->readAttr( "vert-origin-x" ); + this->readAttr( "vert-origin-y" ); + this->readAttr( "vert-adv-y" ); } void SPMissingGlyph::release() { @@ -59,53 +57,49 @@ void SPMissingGlyph::release() { void SPMissingGlyph::set(unsigned int key, const gchar* value) { - SPMissingGlyph* object = this; - - SPMissingGlyph *glyph = SP_MISSING_GLYPH(object); - switch (key) { case SP_ATTR_D: { - if (glyph->d) { - g_free(glyph->d); + if (this->d) { + g_free(this->d); } - glyph->d = g_strdup(value); - object->requestModified(SP_OBJECT_MODIFIED_FLAG); + this->d = g_strdup(value); + this->requestModified(SP_OBJECT_MODIFIED_FLAG); break; } case SP_ATTR_HORIZ_ADV_X: { double number = value ? g_ascii_strtod(value, 0) : 0; - if (number != glyph->horiz_adv_x){ - glyph->horiz_adv_x = number; - object->requestModified(SP_OBJECT_MODIFIED_FLAG); + if (number != this->horiz_adv_x){ + this->horiz_adv_x = number; + this->requestModified(SP_OBJECT_MODIFIED_FLAG); } break; } case SP_ATTR_VERT_ORIGIN_X: { double number = value ? g_ascii_strtod(value, 0) : 0; - if (number != glyph->vert_origin_x){ - glyph->vert_origin_x = number; - object->requestModified(SP_OBJECT_MODIFIED_FLAG); + if (number != this->vert_origin_x){ + this->vert_origin_x = number; + this->requestModified(SP_OBJECT_MODIFIED_FLAG); } break; } case SP_ATTR_VERT_ORIGIN_Y: { double number = value ? g_ascii_strtod(value, 0) : 0; - if (number != glyph->vert_origin_y){ - glyph->vert_origin_y = number; - object->requestModified(SP_OBJECT_MODIFIED_FLAG); + if (number != this->vert_origin_y){ + this->vert_origin_y = number; + this->requestModified(SP_OBJECT_MODIFIED_FLAG); } break; } case SP_ATTR_VERT_ADV_Y: { double number = value ? g_ascii_strtod(value, 0) : 0; - if (number != glyph->vert_adv_y){ - glyph->vert_adv_y = number; - object->requestModified(SP_OBJECT_MODIFIED_FLAG); + if (number != this->vert_adv_y){ + this->vert_adv_y = number; + this->requestModified(SP_OBJECT_MODIFIED_FLAG); } break; } @@ -120,10 +114,6 @@ void SPMissingGlyph::set(unsigned int key, const gchar* value) { #define COPY_ATTR(rd,rs,key) (rd)->setAttribute((key), rs->attribute(key)); Inkscape::XML::Node* SPMissingGlyph::write(Inkscape::XML::Document* xml_doc, Inkscape::XML::Node* repr, guint flags) { - SPMissingGlyph* object = this; - - // SPMissingGlyph *glyph = SP_MISSING_GLYPH(object); - if ((flags & SP_OBJECT_WRITE_BUILD) && !repr) { repr = xml_doc->createElement("svg:glyph"); } @@ -135,15 +125,16 @@ Inkscape::XML::Node* SPMissingGlyph::write(Inkscape::XML::Document* xml_doc, Ink sp_repr_set_svg_double(repr, "vert-origin-y", glyph->vert_origin_y); sp_repr_set_svg_double(repr, "vert-adv-y", glyph->vert_adv_y); */ - if (repr != object->getRepr()) { + if (repr != this->getRepr()) { + // TODO // All the COPY_ATTR functions below use // XML Tree directly while they shouldn't. - COPY_ATTR(repr, object->getRepr(), "d"); - COPY_ATTR(repr, object->getRepr(), "horiz-adv-x"); - COPY_ATTR(repr, object->getRepr(), "vert-origin-x"); - COPY_ATTR(repr, object->getRepr(), "vert-origin-y"); - COPY_ATTR(repr, object->getRepr(), "vert-adv-y"); + COPY_ATTR(repr, this->getRepr(), "d"); + COPY_ATTR(repr, this->getRepr(), "horiz-adv-x"); + COPY_ATTR(repr, this->getRepr(), "vert-origin-x"); + COPY_ATTR(repr, this->getRepr(), "vert-origin-y"); + COPY_ATTR(repr, this->getRepr(), "vert-adv-y"); } SPObject::write(xml_doc, repr, flags); -- cgit v1.2.3