src/sp-flowdiv.cpp

   1 /*
   2  */
   3
   4 #ifdef HAVE_CONFIG_H
   5 # include "config.h"
   6 #endif
   7
   8 #include "libnr/nr-matrix-ops.h"
   9 #include "xml/repr.h"
  10 //#include "svg/svg.h"
  11
  12 //#include "style.h"
  13
  14 #include "sp-flowdiv.h"
  15 #include "sp-string.h"
  16 #include "document.h"
  17
  18 static void sp_flowdiv_class_init (SPFlowdivClass *klass);
  19 static void sp_flowdiv_init (SPFlowdiv *group);
  20 static void sp_flowdiv_release (SPObject *object);
  21 static Inkscape::XML::Node *sp_flowdiv_write (SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags);
  22 static void sp_flowdiv_update (SPObject *object, SPCtx *ctx, unsigned int flags);
  23 static void sp_flowdiv_modified (SPObject *object, guint flags);
  24 static void sp_flowdiv_build (SPObject *object, SPDocument *doc, Inkscape::XML::Node *repr);
  25 static void sp_flowdiv_set (SPObject *object, unsigned int key, const gchar *value);
  26
  27 static void sp_flowtspan_class_init (SPFlowtspanClass *klass);
  28 static void sp_flowtspan_init (SPFlowtspan *group);
  29 static void sp_flowtspan_release (SPObject *object);
  30 static Inkscape::XML::Node *sp_flowtspan_write (SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags);
  31 static void sp_flowtspan_update (SPObject *object, SPCtx *ctx, unsigned int flags);
  32 static void sp_flowtspan_modified (SPObject *object, guint flags);
  33 static void sp_flowtspan_build (SPObject *object, SPDocument *doc, Inkscape::XML::Node *repr);
  34 static void sp_flowtspan_set (SPObject *object, unsigned int key, const gchar *value);
  35
  36 static void sp_flowpara_class_init (SPFlowparaClass *klass);
  37 static void sp_flowpara_init (SPFlowpara *group);
  38 static void sp_flowpara_release (SPObject *object);
  39 static Inkscape::XML::Node *sp_flowpara_write (SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags);
  40 static void sp_flowpara_update (SPObject *object, SPCtx *ctx, unsigned int flags);
  41 static void sp_flowpara_modified (SPObject *object, guint flags);
  42 static void sp_flowpara_build (SPObject *object, SPDocument *doc, Inkscape::XML::Node *repr);
  43 static void sp_flowpara_set (SPObject *object, unsigned int key, const gchar *value);
  44
  45 static void sp_flowline_class_init (SPFlowlineClass *klass);
  46 static void sp_flowline_release (SPObject *object);
  47 static void sp_flowline_init (SPFlowline *group);
  48 static Inkscape::XML::Node *sp_flowline_write (SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags);
  49 static void sp_flowline_modified (SPObject *object, guint flags);
  50
  51 static void sp_flowregionbreak_class_init (SPFlowregionbreakClass *klass);
  52 static void sp_flowregionbreak_release (SPObject *object);
  53 static void sp_flowregionbreak_init (SPFlowregionbreak *group);
  54 static Inkscape::XML::Node *sp_flowregionbreak_write (SPObject *object, Inkscape::XML::Document *doc, Inkscape::XML::Node *repr, guint flags);
  55 static void sp_flowregionbreak_modified (SPObject *object, guint flags);
  56
  57 static SPItemClass * flowdiv_parent_class;
  58 static SPItemClass * flowtspan_parent_class;
  59 static SPItemClass * flowpara_parent_class;
  60 static SPObjectClass * flowline_parent_class;
  61 static SPObjectClass * flowregionbreak_parent_class;
  62
  63 GType
  64 sp_flowdiv_get_type (void)
  65 {
  66         static GType group_type = 0;
  67         if (!group_type) {
  68                 GTypeInfo group_info = {
  69                         sizeof (SPFlowdivClass),
  70                         NULL,   /* base_init */
  71                         NULL,   /* base_finalize */
  72                         (GClassInitFunc) sp_flowdiv_class_init,
  73                         NULL,   /* class_finalize */
  74                         NULL,   /* class_data */
  75                         sizeof (SPFlowdiv),
  76                         16,     /* n_preallocs */
  77                         (GInstanceInitFunc) sp_flowdiv_init,
  78                         NULL,   /* value_table */
  79                 };
  80                 group_type = g_type_register_static (SP_TYPE_ITEM, "SPFlowdiv", &group_info, (GTypeFlags)0);
  81         }
  82         return group_type;
  83 }
  84
  85 static void
  86 sp_flowdiv_class_init (SPFlowdivClass *klass)
  87 {
  88         GObjectClass * object_class;
  89         SPObjectClass * sp_object_class;
  90
  91         object_class = (GObjectClass *) klass;
  92         sp_object_class = (SPObjectClass *) klass;
  93
  94         flowdiv_parent_class = (SPItemClass *)g_type_class_ref (SP_TYPE_ITEM);
  95
  96         sp_object_class->build = sp_flowdiv_build;
  97         sp_object_class->set = sp_flowdiv_set;
  98         sp_object_class->release = sp_flowdiv_release;
  99         sp_object_class->write = sp_flowdiv_write;
 100         sp_object_class->update = sp_flowdiv_update;
 101         sp_object_class->modified = sp_flowdiv_modified;
 102 }
 103
 104 static void
 105 sp_flowdiv_init (SPFlowdiv */*group*/)
 106 {
 107 }
 108
 109 static void
 110 sp_flowdiv_release (SPObject *object)
 111 {
 112         if (((SPObjectClass *) flowdiv_parent_class)->release)
 113                 ((SPObjectClass *) flowdiv_parent_class)->release (object);
 114 }
 115
 116 static void sp_flowdiv_update(SPObject *object, SPCtx *ctx, unsigned int flags)
 117 {
 118     SPItemCtx *ictx = reinterpret_cast<SPItemCtx *>(ctx);
 119     SPItemCtx cctx = *ictx;
 120
 121     if (((SPObjectClass *) (flowdiv_parent_class))->update) {
 122         ((SPObjectClass *) (flowdiv_parent_class))->update(object, ctx, flags);
 123     }
 124
 125     if (flags & SP_OBJECT_MODIFIED_FLAG) {
 126         flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
 127     }
 128     flags &= SP_OBJECT_MODIFIED_CASCADE;
 129
 130     GSList* l = NULL;
 131     for (SPObject *child = object->firstChild() ; child ; child = child->getNext() ) {
 132         g_object_ref( G_OBJECT(child) );
 133         l = g_slist_prepend(l, child);
 134     }
 135     l = g_slist_reverse(l);
 136     while (l) {
 137         SPObject *child = SP_OBJECT(l->data);
 138         l = g_slist_remove(l, child);
 139         if (flags || (child->uflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
 140             if (SP_IS_ITEM(child)) {
 141                 SPItem const &chi = *SP_ITEM(child);
 142                 cctx.i2doc = chi.transform * ictx->i2doc;
 143                 cctx.i2vp = chi.transform * ictx->i2vp;
 144                 child->updateDisplay((SPCtx *)&cctx, flags);
 145             } else {
 146                 child->updateDisplay(ctx, flags);
 147             }
 148         }
 149         g_object_unref( G_OBJECT(child) );
 150     }
 151 }
 152
 153 static void sp_flowdiv_modified (SPObject *object, guint flags)
 154 {
 155     if (((SPObjectClass *) (flowdiv_parent_class))->modified) {
 156         ((SPObjectClass *) (flowdiv_parent_class))->modified(object, flags);
 157     }
 158
 159     if (flags & SP_OBJECT_MODIFIED_FLAG) {
 160         flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
 161     }
 162     flags &= SP_OBJECT_MODIFIED_CASCADE;
 163
 164     GSList *l = NULL;
 165     for ( SPObject *child = object->firstChild() ; child ; child = child->getNext() ) {
 166         g_object_ref( G_OBJECT(child) );
 167         l = g_slist_prepend(l, child);
 168     }
 169     l = g_slist_reverse (l);
 170     while (l) {
 171         SPObject *child = SP_OBJECT(l->data);
 172         l = g_slist_remove(l, child);
 173         if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
 174             child->emitModified(flags);
 175         }
 176         g_object_unref( G_OBJECT(child) );
 177     }
 178 }
 179
 180 static void
 181 sp_flowdiv_build (SPObject *object, SPDocument *doc, Inkscape::XML::Node *repr)
 182 {
 183         object->_requireSVGVersion(Inkscape::Version(1, 2));
 184
 185         if (((SPObjectClass *) flowdiv_parent_class)->build)
 186                 ((SPObjectClass *) flowdiv_parent_class)->build (object, doc, repr);
 187 }
 188
 189 static void sp_flowdiv_set(SPObject *object, unsigned int key, const gchar *value)
 190 {
 191     if (((SPObjectClass *) flowdiv_parent_class)->set) {
 192         (((SPObjectClass *) flowdiv_parent_class)->set)(object, key, value);
 193     }
 194 }
 195
 196 static Inkscape::XML::Node *sp_flowdiv_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
 197 {
 198     if ( flags & SP_OBJECT_WRITE_BUILD ) {
 199         if ( repr == NULL ) {
 200             repr = xml_doc->createElement("svg:flowDiv");
 201         }
 202         GSList *l = NULL;
 203         for (SPObject* child = object->firstChild() ; child ; child = child->getNext() ) {
 204             Inkscape::XML::Node* c_repr = NULL;
 205             if ( SP_IS_FLOWTSPAN (child) ) {
 206                 c_repr = child->updateRepr(xml_doc, NULL, flags);
 207             } else if ( SP_IS_FLOWPARA(child) ) {
 208                 c_repr = child->updateRepr(xml_doc, NULL, flags);
 209             } else if ( SP_IS_STRING(child) ) {
 210                 c_repr = xml_doc->createTextNode(SP_STRING(child)->string.c_str());
 211             }
 212             if ( c_repr ) {
 213                 l = g_slist_prepend (l, c_repr);
 214             }
 215         }
 216         while ( l ) {
 217             repr->addChild((Inkscape::XML::Node *) l->data, NULL);
 218             Inkscape::GC::release((Inkscape::XML::Node *) l->data);
 219             l = g_slist_remove(l, l->data);
 220         }
 221     } else {
 222         for ( SPObject* child = object->firstChild() ; child ; child = child->getNext() ) {
 223             if ( SP_IS_FLOWTSPAN (child) ) {
 224                 child->updateRepr(flags);
 225             } else if ( SP_IS_FLOWPARA(child) ) {
 226                 child->updateRepr(flags);
 227             } else if ( SP_IS_STRING(child) ) {
 228                 child->getRepr()->setContent(SP_STRING(child)->string.c_str());
 229             }
 230         }
 231     }
 232
 233     if (((SPObjectClass *) (flowdiv_parent_class))->write) {
 234         ((SPObjectClass *) (flowdiv_parent_class))->write(object, xml_doc, repr, flags);
 235     }
 236
 237     return repr;
 238 }
 239
 240
 241 /*
 242  *
 243  */
 244
 245 GType
 246 sp_flowtspan_get_type (void)
 247 {
 248         static GType group_type = 0;
 249         if (!group_type) {
 250                 GTypeInfo group_info = {
 251                         sizeof (SPFlowtspanClass),
 252                         NULL,   /* base_init */
 253                         NULL,   /* base_finalize */
 254                         (GClassInitFunc) sp_flowtspan_class_init,
 255                         NULL,   /* class_finalize */
 256                         NULL,   /* class_data */
 257                         sizeof (SPFlowtspan),
 258                         16,     /* n_preallocs */
 259                         (GInstanceInitFunc) sp_flowtspan_init,
 260                         NULL,   /* value_table */
 261                 };
 262                 group_type = g_type_register_static (SP_TYPE_ITEM, "SPFlowtspan", &group_info, (GTypeFlags)0);
 263         }
 264         return group_type;
 265 }
 266
 267 static void
 268 sp_flowtspan_class_init (SPFlowtspanClass *klass)
 269 {
 270         GObjectClass * object_class;
 271         SPObjectClass * sp_object_class;
 272
 273         object_class = (GObjectClass *) klass;
 274         sp_object_class = (SPObjectClass *) klass;
 275
 276         flowtspan_parent_class = (SPItemClass *)g_type_class_ref (SP_TYPE_ITEM);
 277
 278         sp_object_class->build = sp_flowtspan_build;
 279         sp_object_class->set = sp_flowtspan_set;
 280         sp_object_class->release = sp_flowtspan_release;
 281         sp_object_class->write = sp_flowtspan_write;
 282         sp_object_class->update = sp_flowtspan_update;
 283         sp_object_class->modified = sp_flowtspan_modified;
 284 }
 285
 286 static void
 287 sp_flowtspan_init (SPFlowtspan */*group*/)
 288 {
 289 }
 290
 291 static void sp_flowtspan_release(SPObject *object)
 292 {
 293     if (((SPObjectClass *) flowtspan_parent_class)->release) {
 294         ((SPObjectClass *) flowtspan_parent_class)->release(object);
 295     }
 296 }
 297
 298 static void sp_flowtspan_update(SPObject *object, SPCtx *ctx, unsigned int flags)
 299 {
 300     SPItemCtx *ictx = reinterpret_cast<SPItemCtx *>(ctx);
 301     SPItemCtx cctx = *ictx;
 302
 303     if (((SPObjectClass *) (flowtspan_parent_class))->update) {
 304         ((SPObjectClass *) (flowtspan_parent_class))->update(object, ctx, flags);
 305     }
 306
 307     if (flags & SP_OBJECT_MODIFIED_FLAG) {
 308         flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
 309     }
 310     flags &= SP_OBJECT_MODIFIED_CASCADE;
 311
 312     GSList* l = NULL;
 313     for ( SPObject *child = object->firstChild() ; child ; child = child->getNext() ) {
 314         g_object_ref( G_OBJECT(child) );
 315         l = g_slist_prepend(l, child);
 316     }
 317     l = g_slist_reverse (l);
 318     while (l) {
 319         SPObject *child = SP_OBJECT(l->data);
 320         l = g_slist_remove(l, child);
 321         if (flags || (child->uflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
 322             if (SP_IS_ITEM(child)) {
 323                 SPItem const &chi = *SP_ITEM(child);
 324                 cctx.i2doc = chi.transform * ictx->i2doc;
 325                 cctx.i2vp = chi.transform * ictx->i2vp;
 326                 child->updateDisplay((SPCtx *)&cctx, flags);
 327             } else {
 328                 child->updateDisplay(ctx, flags);
 329             }
 330         }
 331         g_object_unref( G_OBJECT(child) );
 332     }
 333 }
 334
 335 static void sp_flowtspan_modified(SPObject *object, guint flags)
 336 {
 337     if (((SPObjectClass *) (flowtspan_parent_class))->modified) {
 338         ((SPObjectClass *) (flowtspan_parent_class))->modified(object, flags);
 339     }
 340
 341     if (flags & SP_OBJECT_MODIFIED_FLAG) {
 342         flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
 343     }
 344     flags &= SP_OBJECT_MODIFIED_CASCADE;
 345
 346     GSList *l = NULL;
 347     for ( SPObject *child = object->firstChild() ; child ; child = child->getNext() ) {
 348         g_object_ref( G_OBJECT(child) );
 349         l = g_slist_prepend(l, child);
 350     }
 351     l = g_slist_reverse (l);
 352     while (l) {
 353         SPObject *child = SP_OBJECT(l->data);
 354         l = g_slist_remove(l, child);
 355         if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
 356             child->emitModified(flags);
 357         }
 358         g_object_unref( G_OBJECT(child) );
 359     }
 360 }
 361
 362 static void sp_flowtspan_build(SPObject *object, SPDocument *doc, Inkscape::XML::Node *repr)
 363 {
 364     if (((SPObjectClass *) flowtspan_parent_class)->build) {
 365         ((SPObjectClass *) flowtspan_parent_class)->build(object, doc, repr);
 366     }
 367 }
 368
 369 static void sp_flowtspan_set(SPObject *object, unsigned int key, const gchar *value)
 370 {
 371     if (((SPObjectClass *) flowtspan_parent_class)->set) {
 372         (((SPObjectClass *) flowtspan_parent_class)->set)(object, key, value);
 373     }
 374 }
 375
 376 static Inkscape::XML::Node *sp_flowtspan_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
 377 {
 378     if ( flags&SP_OBJECT_WRITE_BUILD ) {
 379         if ( repr == NULL ) {
 380             repr = xml_doc->createElement("svg:flowSpan");
 381         }
 382         GSList *l = NULL;
 383         for ( SPObject* child = object->firstChild() ; child ; child = child->getNext() ) {
 384             Inkscape::XML::Node* c_repr = NULL;
 385             if ( SP_IS_FLOWTSPAN(child) ) {
 386                 c_repr = child->updateRepr(xml_doc, NULL, flags);
 387             } else if ( SP_IS_FLOWPARA(child) ) {
 388                 c_repr = child->updateRepr(xml_doc, NULL, flags);
 389             } else if ( SP_IS_STRING(child) ) {
 390                 c_repr = xml_doc->createTextNode(SP_STRING(child)->string.c_str());
 391             }
 392             if ( c_repr ) {
 393                 l = g_slist_prepend(l, c_repr);
 394             }
 395         }
 396         while ( l ) {
 397             repr->addChild((Inkscape::XML::Node *) l->data, NULL);
 398             Inkscape::GC::release((Inkscape::XML::Node *) l->data);
 399             l = g_slist_remove(l, l->data);
 400         }
 401     } else {
 402         for ( SPObject* child = object->firstChild() ; child ; child = child->getNext() ) {
 403             if ( SP_IS_FLOWTSPAN(child) ) {
 404                 child->updateRepr(flags);
 405             } else if ( SP_IS_FLOWPARA(child) ) {
 406                 child->updateRepr(flags);
 407             } else if ( SP_IS_STRING(child) ) {
 408                 SP_OBJECT_REPR(child)->setContent(SP_STRING(child)->string.c_str());
 409             }
 410         }
 411     }
 412
 413     if (((SPObjectClass *) (flowtspan_parent_class))->write) {
 414         ((SPObjectClass *) (flowtspan_parent_class))->write(object, xml_doc, repr, flags);
 415     }
 416
 417     return repr;
 418 }
 419
 420
 421
 422 /*
 423  *
 424  */
 425
 426 GType
 427 sp_flowpara_get_type (void)
 428 {
 429         static GType group_type = 0;
 430         if (!group_type) {
 431                 GTypeInfo group_info = {
 432                         sizeof (SPFlowparaClass),
 433                         NULL,   /* base_init */
 434                         NULL,   /* base_finalize */
 435                         (GClassInitFunc) sp_flowpara_class_init,
 436                         NULL,   /* class_finalize */
 437                         NULL,   /* class_data */
 438                         sizeof (SPFlowpara),
 439                         16,     /* n_preallocs */
 440                         (GInstanceInitFunc) sp_flowpara_init,
 441                         NULL,   /* value_table */
 442                 };
 443                 group_type = g_type_register_static (SP_TYPE_ITEM, "SPFlowpara", &group_info, (GTypeFlags)0);
 444         }
 445         return group_type;
 446 }
 447
 448 static void
 449 sp_flowpara_class_init (SPFlowparaClass *klass)
 450 {
 451         GObjectClass * object_class;
 452         SPObjectClass * sp_object_class;
 453
 454         object_class = (GObjectClass *) klass;
 455         sp_object_class = (SPObjectClass *) klass;
 456
 457         flowpara_parent_class = (SPItemClass *)g_type_class_ref (SP_TYPE_ITEM);
 458
 459         sp_object_class->build = sp_flowpara_build;
 460         sp_object_class->set = sp_flowpara_set;
 461         sp_object_class->release = sp_flowpara_release;
 462         sp_object_class->write = sp_flowpara_write;
 463         sp_object_class->update = sp_flowpara_update;
 464         sp_object_class->modified = sp_flowpara_modified;
 465 }
 466
 467 static void
 468 sp_flowpara_init (SPFlowpara */*group*/)
 469 {
 470 }
 471 static void
 472 sp_flowpara_release (SPObject *object)
 473 {
 474         if (((SPObjectClass *) flowpara_parent_class)->release)
 475                 ((SPObjectClass *) flowpara_parent_class)->release (object);
 476 }
 477
 478 static void sp_flowpara_update(SPObject *object, SPCtx *ctx, unsigned int flags)
 479 {
 480     SPItemCtx *ictx = reinterpret_cast<SPItemCtx *>(ctx);
 481     SPItemCtx cctx = *ictx;
 482
 483     if (((SPObjectClass *) (flowpara_parent_class))->update) {
 484         ((SPObjectClass *) (flowpara_parent_class))->update(object, ctx, flags);
 485     }
 486
 487     if (flags & SP_OBJECT_MODIFIED_FLAG) {
 488         flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
 489     }
 490     flags &= SP_OBJECT_MODIFIED_CASCADE;
 491
 492     GSList* l = NULL;
 493     for ( SPObject *child = object->firstChild() ; child ; child = child->getNext() ) {
 494         g_object_ref( G_OBJECT(child) );
 495         l = g_slist_prepend(l, child);
 496     }
 497     l = g_slist_reverse (l);
 498     while (l) {
 499         SPObject *child = SP_OBJECT(l->data);
 500         l = g_slist_remove(l, child);
 501         if (flags || (child->uflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
 502             if (SP_IS_ITEM(child)) {
 503                 SPItem const &chi = *SP_ITEM(child);
 504                 cctx.i2doc = chi.transform * ictx->i2doc;
 505                 cctx.i2vp = chi.transform * ictx->i2vp;
 506                 child->updateDisplay((SPCtx *)&cctx, flags);
 507             } else {
 508                 child->updateDisplay(ctx, flags);
 509             }
 510         }
 511         g_object_unref( G_OBJECT(child) );
 512     }
 513 }
 514
 515 static void sp_flowpara_modified(SPObject *object, guint flags)
 516 {
 517     if (((SPObjectClass *) (flowpara_parent_class))->modified) {
 518         ((SPObjectClass *) (flowpara_parent_class))->modified(object, flags);
 519     }
 520
 521     if (flags & SP_OBJECT_MODIFIED_FLAG) {
 522         flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
 523     }
 524     flags &= SP_OBJECT_MODIFIED_CASCADE;
 525
 526     GSList *l = NULL;
 527     for ( SPObject *child = object->firstChild() ; child ; child = child->getNext() ) {
 528         g_object_ref( G_OBJECT(child) );
 529         l = g_slist_prepend(l, child);
 530     }
 531     l = g_slist_reverse (l);
 532     while (l) {
 533         SPObject *child = SP_OBJECT(l->data);
 534         l = g_slist_remove(l, child);
 535         if (flags || (child->mflags & (SP_OBJECT_MODIFIED_FLAG | SP_OBJECT_CHILD_MODIFIED_FLAG))) {
 536             child->emitModified(flags);
 537         }
 538         g_object_unref( G_OBJECT(child) );
 539     }
 540 }
 541
 542 static void
 543 sp_flowpara_build (SPObject *object, SPDocument *doc, Inkscape::XML::Node *repr)
 544 {
 545         if (((SPObjectClass *) flowpara_parent_class)->build)
 546                 ((SPObjectClass *) flowpara_parent_class)->build (object, doc, repr);
 547 }
 548
 549 static void
 550 sp_flowpara_set (SPObject *object, unsigned int key, const gchar *value)
 551 {
 552         if (((SPObjectClass *) flowpara_parent_class)->set)
 553                 (((SPObjectClass *) flowpara_parent_class)->set) (object, key, value);
 554 }
 555
 556 static Inkscape::XML::Node *sp_flowpara_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
 557 {
 558     if ( flags&SP_OBJECT_WRITE_BUILD ) {
 559         if ( repr == NULL ) repr = xml_doc->createElement("svg:flowPara");
 560         GSList *l = NULL;
 561         for ( SPObject* child = object->firstChild() ; child ; child = child->getNext() ) {
 562             Inkscape::XML::Node* c_repr = NULL;
 563             if ( SP_IS_FLOWTSPAN(child) ) {
 564                 c_repr = child->updateRepr(xml_doc, NULL, flags);
 565             } else if ( SP_IS_FLOWPARA(child) ) {
 566                 c_repr = child->updateRepr(xml_doc, NULL, flags);
 567             } else if ( SP_IS_STRING(child) ) {
 568                 c_repr = xml_doc->createTextNode(SP_STRING(child)->string.c_str());
 569             }
 570             if ( c_repr ) {
 571                 l = g_slist_prepend(l, c_repr);
 572             }
 573         }
 574         while ( l ) {
 575             repr->addChild((Inkscape::XML::Node *) l->data, NULL);
 576             Inkscape::GC::release((Inkscape::XML::Node *) l->data);
 577             l = g_slist_remove(l, l->data);
 578         }
 579     } else {
 580         for ( SPObject* child = object->firstChild() ; child ; child = child->getNext() ) {
 581             if ( SP_IS_FLOWTSPAN(child) ) {
 582                 child->updateRepr(flags);
 583             } else if ( SP_IS_FLOWPARA(child) ) {
 584                 child->updateRepr(flags);
 585             } else if ( SP_IS_STRING(child) ) {
 586                 child->getRepr()->setContent(SP_STRING(child)->string.c_str());
 587             }
 588         }
 589     }
 590
 591     if (((SPObjectClass *) (flowpara_parent_class))->write) {
 592         ((SPObjectClass *) (flowpara_parent_class))->write(object, xml_doc, repr, flags);
 593     }
 594
 595     return repr;
 596 }
 597
 598 /*
 599  *
 600  */
 601
 602 GType
 603 sp_flowline_get_type (void)
 604 {
 605         static GType group_type = 0;
 606         if (!group_type) {
 607                 GTypeInfo group_info = {
 608                         sizeof (SPFlowlineClass),
 609                         NULL,   /* base_init */
 610                         NULL,   /* base_finalize */
 611                         (GClassInitFunc) sp_flowline_class_init,
 612                         NULL,   /* class_finalize */
 613                         NULL,   /* class_data */
 614                         sizeof (SPFlowline),
 615                         16,     /* n_preallocs */
 616                         (GInstanceInitFunc) sp_flowline_init,
 617                         NULL,   /* value_table */
 618                 };
 619                 group_type = g_type_register_static (SP_TYPE_OBJECT, "SPFlowline", &group_info, (GTypeFlags)0);
 620         }
 621         return group_type;
 622 }
 623
 624 static void
 625 sp_flowline_class_init (SPFlowlineClass *klass)
 626 {
 627         GObjectClass * object_class;
 628         SPObjectClass * sp_object_class;
 629
 630         object_class = (GObjectClass *) klass;
 631         sp_object_class = (SPObjectClass *) klass;
 632
 633         flowline_parent_class = (SPObjectClass *)g_type_class_ref (SP_TYPE_OBJECT);
 634
 635         sp_object_class->release = sp_flowline_release;
 636         sp_object_class->write = sp_flowline_write;
 637         sp_object_class->modified = sp_flowline_modified;
 638 }
 639
 640 static void
 641 sp_flowline_init (SPFlowline */*group*/)
 642 {
 643 }
 644 static void
 645 sp_flowline_release (SPObject *object)
 646 {
 647         if (((SPObjectClass *) flowline_parent_class)->release)
 648                 ((SPObjectClass *) flowline_parent_class)->release (object);
 649 }
 650
 651 static void
 652 sp_flowline_modified (SPObject *object, guint flags)
 653 {
 654         if (((SPObjectClass *) (flowline_parent_class))->modified)
 655                 ((SPObjectClass *) (flowline_parent_class))->modified (object, flags);
 656
 657         if (flags & SP_OBJECT_MODIFIED_FLAG) flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
 658         flags &= SP_OBJECT_MODIFIED_CASCADE;
 659 }
 660 static Inkscape::XML::Node *
 661 sp_flowline_write (SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
 662 {
 663         if ( flags&SP_OBJECT_WRITE_BUILD ) {
 664                 if ( repr == NULL ) repr = xml_doc->createElement("svg:flowLine");
 665         } else {
 666         }
 667
 668         if (((SPObjectClass *) (flowline_parent_class))->write)
 669                 ((SPObjectClass *) (flowline_parent_class))->write (object, xml_doc, repr, flags);
 670
 671         return repr;
 672 }
 673
 674 /*
 675  *
 676  */
 677
 678 GType
 679 sp_flowregionbreak_get_type (void)
 680 {
 681         static GType group_type = 0;
 682         if (!group_type) {
 683                 GTypeInfo group_info = {
 684                         sizeof (SPFlowregionbreakClass),
 685                         NULL,   /* base_init */
 686                         NULL,   /* base_finalize */
 687                         (GClassInitFunc) sp_flowregionbreak_class_init,
 688                         NULL,   /* class_finalize */
 689                         NULL,   /* class_data */
 690                         sizeof (SPFlowregionbreak),
 691                         16,     /* n_preallocs */
 692                         (GInstanceInitFunc) sp_flowregionbreak_init,
 693                         NULL,   /* value_table */
 694                 };
 695                 group_type = g_type_register_static (SP_TYPE_OBJECT, "SPFlowregionbreak", &group_info, (GTypeFlags)0);
 696         }
 697         return group_type;
 698 }
 699
 700 static void
 701 sp_flowregionbreak_class_init (SPFlowregionbreakClass *klass)
 702 {
 703         GObjectClass * object_class;
 704         SPObjectClass * sp_object_class;
 705
 706         object_class = (GObjectClass *) klass;
 707         sp_object_class = (SPObjectClass *) klass;
 708
 709         flowregionbreak_parent_class = (SPObjectClass *)g_type_class_ref (SP_TYPE_OBJECT);
 710
 711         sp_object_class->release = sp_flowregionbreak_release;
 712         sp_object_class->write = sp_flowregionbreak_write;
 713         sp_object_class->modified = sp_flowregionbreak_modified;
 714 }
 715
 716 static void
 717 sp_flowregionbreak_init (SPFlowregionbreak */*group*/)
 718 {
 719 }
 720 static void
 721 sp_flowregionbreak_release (SPObject *object)
 722 {
 723         if (((SPObjectClass *) flowregionbreak_parent_class)->release)
 724                 ((SPObjectClass *) flowregionbreak_parent_class)->release (object);
 725 }
 726
 727 static void
 728 sp_flowregionbreak_modified (SPObject *object, guint flags)
 729 {
 730         if (((SPObjectClass *) (flowregionbreak_parent_class))->modified)
 731                 ((SPObjectClass *) (flowregionbreak_parent_class))->modified (object, flags);
 732
 733         if (flags & SP_OBJECT_MODIFIED_FLAG) flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
 734         flags &= SP_OBJECT_MODIFIED_CASCADE;
 735 }
 736 static Inkscape::XML::Node *
 737 sp_flowregionbreak_write (SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
 738 {
 739         if ( flags&SP_OBJECT_WRITE_BUILD ) {
 740                 if ( repr == NULL ) repr = xml_doc->createElement("svg:flowLine");
 741         } else {
 742         }
 743
 744         if (((SPObjectClass *) (flowregionbreak_parent_class))->write)
 745                 ((SPObjectClass *) (flowregionbreak_parent_class))->write (object, xml_doc, repr, flags);
 746
 747         return repr;
 748 }
 749
 750 /*
 751   Local Variables:
 752   mode:c++
 753   c-file-style:"stroustrup"
 754   c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
 755   indent-tabs-mode:nil
 756   fill-column:99
 757   End:
 758 */
 759 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :