1 #define __SP_FLOWDIV_C__
3 /*
4 */
6 #ifdef HAVE_CONFIG_H
7 # include "config.h"
8 #endif
10 #include "libnr/nr-matrix-ops.h"
11 #include "xml/repr.h"
12 //#include "svg/svg.h"
14 //#include "style.h"
16 #include "sp-flowdiv.h"
17 #include "sp-string.h"
18 #include "document.h"
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);
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);
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);
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);
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);
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;
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 }
87 static void
88 sp_flowdiv_class_init (SPFlowdivClass *klass)
89 {
90 GObjectClass * object_class;
91 SPObjectClass * sp_object_class;
93 object_class = (GObjectClass *) klass;
94 sp_object_class = (SPObjectClass *) klass;
96 flowdiv_parent_class = (SPItemClass *)g_type_class_ref (SP_TYPE_ITEM);
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 }
106 static void
107 sp_flowdiv_init (SPFlowdiv *group)
108 {
109 }
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;
123 if (((SPObjectClass *) (flowdiv_parent_class))->update)
124 ((SPObjectClass *) (flowdiv_parent_class))->update (object, ctx, flags);
126 if (flags & SP_OBJECT_MODIFIED_FLAG) flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
127 flags &= SP_OBJECT_MODIFIED_CASCADE;
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;
157 if (((SPObjectClass *) (flowdiv_parent_class))->modified)
158 ((SPObjectClass *) (flowdiv_parent_class))->modified (object, flags);
160 if (flags & SP_OBJECT_MODIFIED_FLAG) flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
161 flags &= SP_OBJECT_MODIFIED_CASCADE;
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 }
179 static void
180 sp_flowdiv_build (SPObject *object, SPDocument *doc, Inkscape::XML::Node *repr)
181 {
182 object->_requireSVGVersion(Inkscape::Version(1, 2));
184 if (((SPObjectClass *) flowdiv_parent_class)->build)
185 ((SPObjectClass *) flowdiv_parent_class)->build (object, doc, repr);
186 }
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 }
195 static Inkscape::XML::Node *
196 sp_flowdiv_write (SPObject *object, Inkscape::XML::Node *repr, guint flags)
197 {
198 // SPFlowdiv *group = SP_FLOWDIV (object);
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 }
232 if (((SPObjectClass *) (flowdiv_parent_class))->write)
233 ((SPObjectClass *) (flowdiv_parent_class))->write (object, repr, flags);
235 return repr;
236 }
239 /*
240 *
241 */
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 }
265 static void
266 sp_flowtspan_class_init (SPFlowtspanClass *klass)
267 {
268 GObjectClass * object_class;
269 SPObjectClass * sp_object_class;
271 object_class = (GObjectClass *) klass;
272 sp_object_class = (SPObjectClass *) klass;
274 flowtspan_parent_class = (SPItemClass *)g_type_class_ref (SP_TYPE_ITEM);
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 }
284 static void
285 sp_flowtspan_init (SPFlowtspan *group)
286 {
287 }
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;
302 if (((SPObjectClass *) (flowtspan_parent_class))->update)
303 ((SPObjectClass *) (flowtspan_parent_class))->update (object, ctx, flags);
305 if (flags & SP_OBJECT_MODIFIED_FLAG) flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
306 flags &= SP_OBJECT_MODIFIED_CASCADE;
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;
336 if (((SPObjectClass *) (flowtspan_parent_class))->modified)
337 ((SPObjectClass *) (flowtspan_parent_class))->modified (object, flags);
339 if (flags & SP_OBJECT_MODIFIED_FLAG) flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
340 flags &= SP_OBJECT_MODIFIED_CASCADE;
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 }
404 if (((SPObjectClass *) (flowtspan_parent_class))->write)
405 ((SPObjectClass *) (flowtspan_parent_class))->write (object, repr, flags);
407 return repr;
408 }
412 /*
413 *
414 */
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 }
438 static void
439 sp_flowpara_class_init (SPFlowparaClass *klass)
440 {
441 GObjectClass * object_class;
442 SPObjectClass * sp_object_class;
444 object_class = (GObjectClass *) klass;
445 sp_object_class = (SPObjectClass *) klass;
447 flowpara_parent_class = (SPItemClass *)g_type_class_ref (SP_TYPE_ITEM);
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 }
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 }
468 static void
469 sp_flowpara_update (SPObject *object, SPCtx *ctx, unsigned int flags)
470 {
471 SPItemCtx *ictx=(SPItemCtx *) ctx;
472 SPItemCtx cctx=*ictx;
474 if (((SPObjectClass *) (flowpara_parent_class))->update)
475 ((SPObjectClass *) (flowpara_parent_class))->update (object, ctx, flags);
477 if (flags & SP_OBJECT_MODIFIED_FLAG) flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
478 flags &= SP_OBJECT_MODIFIED_CASCADE;
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;
508 if (((SPObjectClass *) (flowpara_parent_class))->modified)
509 ((SPObjectClass *) (flowpara_parent_class))->modified (object, flags);
511 if (flags & SP_OBJECT_MODIFIED_FLAG) flags |= SP_OBJECT_PARENT_MODIFIED_FLAG;
512 flags &= SP_OBJECT_MODIFIED_CASCADE;
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);
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 }
578 if (((SPObjectClass *) (flowpara_parent_class))->write)
579 ((SPObjectClass *) (flowpara_parent_class))->write (object, repr, flags);
581 return repr;
582 }
584 /*
585 *
586 */
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 }
610 static void
611 sp_flowline_class_init (SPFlowlineClass *klass)
612 {
613 GObjectClass * object_class;
614 SPObjectClass * sp_object_class;
616 object_class = (GObjectClass *) klass;
617 sp_object_class = (SPObjectClass *) klass;
619 flowline_parent_class = (SPObjectClass *)g_type_class_ref (SP_TYPE_OBJECT);
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 }
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 }
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);
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 }
655 if (((SPObjectClass *) (flowline_parent_class))->write)
656 ((SPObjectClass *) (flowline_parent_class))->write (object, repr, flags);
658 return repr;
659 }
661 /*
662 *
663 */
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 }
687 static void
688 sp_flowregionbreak_class_init (SPFlowregionbreakClass *klass)
689 {
690 GObjectClass * object_class;
691 SPObjectClass * sp_object_class;
693 object_class = (GObjectClass *) klass;
694 sp_object_class = (SPObjectClass *) klass;
696 flowregionbreak_parent_class = (SPObjectClass *)g_type_class_ref (SP_TYPE_OBJECT);
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 }
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 }
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);
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 }
732 if (((SPObjectClass *) (flowregionbreak_parent_class))->write)
733 ((SPObjectClass *) (flowregionbreak_parent_class))->write (object, repr, flags);
735 return repr;
736 }