src/sp-flowdiv.cpp

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