0fe02e01dbc23f3211bd6a5363120b7c1acd72ca
1 #define __SP_LPE_ITEM_CPP__
3 /** \file
4 * Base class for live path effect items
5 */
6 /*
7 * Authors:
8 * Johan Engelen <j.b.c.engelen@ewi.utwente.nl>
9 * Bastien Bouclet <bgkweb@gmail.com>
10 *
11 * Copyright (C) 2008 authors
12 *
13 * Released under GNU GPL, read the file 'COPYING' for more information
14 */
16 #ifdef HAVE_CONFIG_H
17 # include "config.h"
18 #endif
20 #include "live_effects/effect.h"
21 #include "live_effects/lpe-path_length.h"
22 #include "live_effects/lpeobject.h"
23 #include "live_effects/lpeobject-reference.h"
25 #include "sp-path.h"
26 #include "sp-item-group.h"
27 #include "streq.h"
28 #include "macros.h"
29 #include "attributes.h"
30 #include "sp-lpe-item.h"
31 #include "xml/repr.h"
32 #include "uri.h"
33 #include "message-stack.h"
34 #include "inkscape.h"
35 #include "desktop.h"
36 #include "node-context.h"
37 #include "shape-editor.h"
39 #include <algorithm>
41 /* LPEItem base class */
43 static void sp_lpe_item_class_init(SPLPEItemClass *klass);
44 static void sp_lpe_item_init(SPLPEItem *lpe_item);
45 static void sp_lpe_item_finalize(GObject *object);
47 static void sp_lpe_item_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr);
48 static void sp_lpe_item_release(SPObject *object);
49 static void sp_lpe_item_set(SPObject *object, unsigned int key, gchar const *value);
50 static void sp_lpe_item_update(SPObject *object, SPCtx *ctx, guint flags);
51 static void sp_lpe_item_modified (SPObject *object, unsigned int flags);
52 static Inkscape::XML::Node *sp_lpe_item_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags);
54 static void sp_lpe_item_child_added (SPObject * object, Inkscape::XML::Node * child, Inkscape::XML::Node * ref);
55 static void sp_lpe_item_remove_child (SPObject * object, Inkscape::XML::Node * child);
57 static void sp_lpe_item_enable_path_effects(SPLPEItem *lpeitem, bool enable);
59 static void lpeobject_ref_changed(SPObject *old_ref, SPObject *ref, SPLPEItem *lpeitem);
60 static void lpeobject_ref_modified(SPObject *href, guint flags, SPLPEItem *lpeitem);
62 static void sp_lpe_item_create_original_path_recursive(SPLPEItem *lpeitem);
63 static void sp_lpe_item_cleanup_original_path_recursive(SPLPEItem *lpeitem);
64 typedef std::list<std::string> HRefList;
65 static std::string patheffectlist_write_svg(PathEffectList const & list);
66 static std::string hreflist_write_svg(HRefList const & list);
68 static SPItemClass *parent_class;
70 GType
71 sp_lpe_item_get_type()
72 {
73 static GType lpe_item_type = 0;
75 if (!lpe_item_type) {
76 GTypeInfo lpe_item_info = {
77 sizeof(SPLPEItemClass),
78 NULL, NULL,
79 (GClassInitFunc) sp_lpe_item_class_init,
80 NULL, NULL,
81 sizeof(SPLPEItem),
82 16,
83 (GInstanceInitFunc) sp_lpe_item_init,
84 NULL, /* value_table */
85 };
86 lpe_item_type = g_type_register_static(SP_TYPE_ITEM, "SPLPEItem", &lpe_item_info, (GTypeFlags)0);
87 }
88 return lpe_item_type;
89 }
91 static void
92 sp_lpe_item_class_init(SPLPEItemClass *klass)
93 {
94 GObjectClass *gobject_class;
95 SPObjectClass *sp_object_class;
97 gobject_class = (GObjectClass *) klass;
98 sp_object_class = (SPObjectClass *) klass;
99 parent_class = (SPItemClass *)g_type_class_peek_parent (klass);
101 gobject_class->finalize = sp_lpe_item_finalize;
103 sp_object_class->build = sp_lpe_item_build;
104 sp_object_class->release = sp_lpe_item_release;
105 sp_object_class->set = sp_lpe_item_set;
106 sp_object_class->update = sp_lpe_item_update;
107 sp_object_class->modified = sp_lpe_item_modified;
108 sp_object_class->write = sp_lpe_item_write;
109 sp_object_class->child_added = sp_lpe_item_child_added;
110 sp_object_class->remove_child = sp_lpe_item_remove_child;
112 klass->update_patheffect = NULL;
113 }
115 static void
116 sp_lpe_item_init(SPLPEItem *lpeitem)
117 {
118 lpeitem->path_effects_enabled = 1;
120 lpeitem->path_effect_list = new PathEffectList();
121 lpeitem->current_path_effect = NULL;
123 new (&lpeitem->lpe_modified_connection) sigc::connection();
124 }
126 static void
127 sp_lpe_item_finalize(GObject *object)
128 {
129 if (((GObjectClass *) (parent_class))->finalize) {
130 (* ((GObjectClass *) (parent_class))->finalize)(object);
131 }
132 }
134 /**
135 * Reads the Inkscape::XML::Node, and initializes SPLPEItem variables. For this to get called,
136 * our name must be associated with a repr via "sp_object_type_register". Best done through
137 * sp-object-repr.cpp's repr_name_entries array.
138 */
139 static void
140 sp_lpe_item_build(SPObject *object, SPDocument *document, Inkscape::XML::Node *repr)
141 {
142 sp_object_read_attr(object, "inkscape:path-effect");
144 if (((SPObjectClass *) parent_class)->build) {
145 ((SPObjectClass *) parent_class)->build(object, document, repr);
146 }
147 }
149 /**
150 * Drops any allocated memory.
151 */
152 static void
153 sp_lpe_item_release(SPObject *object)
154 {
155 SPLPEItem *lpeitem = (SPLPEItem *) object;
157 lpeitem->lpe_modified_connection.disconnect();
158 lpeitem->lpe_modified_connection.~connection();
160 PathEffectList::iterator it = lpeitem->path_effect_list->begin();
161 while ( it != lpeitem->path_effect_list->end() ) {
162 // unlink and delete all references in the list
163 (*it)->unlink();
164 delete *it;
165 it = lpeitem->path_effect_list->erase(it);
166 }
167 // delete the list itself
168 delete SP_LPE_ITEM(object)->path_effect_list;
170 if (((SPObjectClass *) parent_class)->release)
171 ((SPObjectClass *) parent_class)->release(object);
172 }
174 /**
175 * Sets a specific value in the SPLPEItem.
176 */
177 static void
178 sp_lpe_item_set(SPObject *object, unsigned int key, gchar const *value)
179 {
180 SPLPEItem *lpeitem = (SPLPEItem *) object;
182 switch (key) {
183 case SP_ATTR_INKSCAPE_PATH_EFFECT:
184 {
185 lpeitem->current_path_effect = NULL;
187 // Disable the path effects while populating the LPE list
188 sp_lpe_item_enable_path_effects(lpeitem, false);
190 // Clear the path effect list
191 PathEffectList::iterator it = lpeitem->path_effect_list->begin();
192 while ( it != lpeitem->path_effect_list->end() )
193 {
194 (*it)->unlink();
195 delete *it;
196 it = lpeitem->path_effect_list->erase(it);
197 }
199 // Parse the contents of "value" to rebuild the path effect reference list
200 if ( value ) {
201 std::istringstream iss(value);
202 std::string href;
203 while (std::getline(iss, href, ';'))
204 {
205 Inkscape::LivePathEffect::LPEObjectReference *path_effect_ref = new Inkscape::LivePathEffect::LPEObjectReference(SP_OBJECT(lpeitem));
206 path_effect_ref->changedSignal().connect(sigc::bind(sigc::ptr_fun(lpeobject_ref_changed), SP_LPE_ITEM(object)));
207 // Now do the attaching, which emits the changed signal.
208 // Fixme, it should not do this changed signal and updating before all effects are added to the path_effect_list
209 try {
210 path_effect_ref->link(href.c_str());
211 } catch (Inkscape::BadURIException e) {
212 g_warning("BadURIException: %s", e.what());
213 path_effect_ref->unlink();
214 delete path_effect_ref;
215 path_effect_ref = NULL;
216 }
218 if (path_effect_ref && path_effect_ref->lpeobject && path_effect_ref->lpeobject->get_lpe()) {
219 lpeitem->path_effect_list->push_back(path_effect_ref);
220 } else {
221 // something has gone wrong in finding the right patheffect. For example when the specified LPE name does not exist.
222 path_effect_ref->unlink();
223 delete path_effect_ref;
224 path_effect_ref = NULL;
225 }
226 }
227 }
229 sp_lpe_item_enable_path_effects(lpeitem, true);
230 }
231 break;
232 default:
233 if (((SPObjectClass *) parent_class)->set) {
234 ((SPObjectClass *) parent_class)->set(object, key, value);
235 }
236 break;
237 }
238 }
240 /**
241 * Receives update notifications.
242 */
243 static void
244 sp_lpe_item_update(SPObject *object, SPCtx *ctx, guint flags)
245 {
246 if (((SPObjectClass *) parent_class)->update) {
247 ((SPObjectClass *) parent_class)->update(object, ctx, flags);
248 }
250 // update the helperpaths of all LPEs applied to the item
251 // TODO: is there a more canonical place for this, since we don't have instant access to the item's nodepath?
252 // FIXME: this is called multiple (at least 3) times; how can we avoid this?
254 // FIXME: ditch inkscape_active_event_context()
255 SPEventContext *ec = inkscape_active_event_context();
256 if (!SP_IS_NODE_CONTEXT(ec)) return;
257 SPNodeContext *nc = SP_NODE_CONTEXT(ec);
258 ShapeEditor *sh = nc->shape_editor;
259 g_assert(sh);
260 if (!sh->has_nodepath()) return;
262 Inkscape::NodePath::Path *np = sh->get_nodepath();
263 sp_nodepath_update_helperpaths(np);
264 }
266 /**
267 * Sets modified flag for all sub-item views.
268 */
269 static void
270 sp_lpe_item_modified (SPObject *object, unsigned int flags)
271 {
272 if (SP_IS_GROUP(object) && (flags & SP_OBJECT_MODIFIED_FLAG) && (flags & SP_OBJECT_USER_MODIFIED_FLAG_B)) {
273 sp_lpe_item_update_patheffect(SP_LPE_ITEM(object), true, true);
274 }
276 if (((SPObjectClass *) (parent_class))->modified) {
277 (* ((SPObjectClass *) (parent_class))->modified) (object, flags);
278 }
279 }
281 /**
282 * Writes its settings to an incoming repr object, if any.
283 */
284 static Inkscape::XML::Node *
285 sp_lpe_item_write(SPObject *object, Inkscape::XML::Document *xml_doc, Inkscape::XML::Node *repr, guint flags)
286 {
287 SPLPEItem *lpeitem = (SPLPEItem *) object;
289 if ( sp_lpe_item_has_path_effect(lpeitem) ) {
290 std::string href = patheffectlist_write_svg(*lpeitem->path_effect_list);
291 repr->setAttribute("inkscape:path-effect", href.c_str());
292 } else {
293 repr->setAttribute("inkscape:path-effect", NULL);
294 }
296 if (((SPObjectClass *)(parent_class))->write) {
297 ((SPObjectClass *)(parent_class))->write(object, xml_doc, repr, flags);
298 }
300 return repr;
301 }
303 void sp_lpe_item_perform_path_effect(SPLPEItem *lpeitem, SPCurve *curve) {
304 if (!lpeitem) return;
305 if (!curve) return;
307 if (sp_lpe_item_has_path_effect(lpeitem) && sp_lpe_item_path_effects_enabled(lpeitem)) {
308 for (PathEffectList::iterator it = lpeitem->path_effect_list->begin(); it != lpeitem->path_effect_list->end(); ++it)
309 {
310 LivePathEffectObject *lpeobj = (*it)->lpeobject;
311 if (!lpeobj) {
312 /** \todo Investigate the cause of this.
313 * For example, this happens when copy pasting an object with LPE applied. Probably because the object is pasted while the effect is not yet pasted to defs, and cannot be found.
314 */
315 g_warning("sp_lpe_item_perform_path_effect - NULL lpeobj in list!");
316 return;
317 }
318 Inkscape::LivePathEffect::Effect *lpe = lpeobj->get_lpe();
319 if (!lpe) {
320 /** \todo Investigate the cause of this.
321 * Not sure, but I think this can happen when an unknown effect type is specified...
322 */
323 g_warning("sp_lpe_item_perform_path_effect - lpeobj without lpe!");
324 return;
325 }
327 if (lpe->isVisible()) {
328 if (lpe->acceptsNumClicks() > 0 && !lpe->isReady()) {
329 // if the effect expects mouse input before being applied and the input is not finished
330 // yet, we don't alter the path
331 return;
332 }
334 // Groups have their doBeforeEffect called elsewhere
335 if (!SP_IS_GROUP(lpeitem)) {
336 lpe->doBeforeEffect(lpeitem);
337 }
339 try {
340 lpe->doEffect(curve);
341 }
342 catch (std::exception & e) {
343 g_warning("Exception during LPE %s execution. \n %s", lpe->getName().c_str(), e.what());
344 if (SP_ACTIVE_DESKTOP && SP_ACTIVE_DESKTOP->messageStack()) {
345 SP_ACTIVE_DESKTOP->messageStack()->flash( Inkscape::WARNING_MESSAGE,
346 _("An exception occurred during execution of the Path Effect.") );
347 }
348 }
349 }
350 }
351 }
352 }
354 /**
355 * Calls any registered handlers for the update_patheffect action
356 */
357 void
358 sp_lpe_item_update_patheffect (SPLPEItem *lpeitem, bool wholetree, bool write)
359 {
360 #ifdef SHAPE_VERBOSE
361 g_message("sp_lpe_item_update_patheffect: %p\n", lpeitem);
362 #endif
363 g_return_if_fail (lpeitem != NULL);
364 g_return_if_fail (SP_IS_LPE_ITEM (lpeitem));
366 if (!sp_lpe_item_path_effects_enabled(lpeitem))
367 return;
369 // TODO: hack! this will be removed when path length measuring is reimplemented in a better way
370 PathEffectList lpelist = sp_lpe_item_get_effect_list(lpeitem);
371 std::list<Inkscape::LivePathEffect::LPEObjectReference *>::iterator i;
372 for (i = lpelist.begin(); i != lpelist.end(); ++i) {
373 if ((*i)->lpeobject) {
374 Inkscape::LivePathEffect::Effect *lpe = (*i)->lpeobject->get_lpe();
375 if (dynamic_cast<Inkscape::LivePathEffect::LPEPathLength *>(lpe)) {
376 if (!lpe->isVisible()) {
377 // we manually disable text for LPEPathLength
378 dynamic_cast<Inkscape::LivePathEffect::LPEPathLength *>(lpe)->hideCanvasText();
379 }
380 }
381 }
382 }
384 SPLPEItem *top;
386 if (wholetree) {
387 SPObject *prev_parent = lpeitem;
388 SPObject *parent = prev_parent->parent;
389 while (parent && SP_IS_LPE_ITEM(parent) && sp_lpe_item_has_path_effect_recursive(SP_LPE_ITEM(parent))) {
390 prev_parent = parent;
391 parent = prev_parent->parent;
392 }
393 top = SP_LPE_ITEM(prev_parent);
394 }
395 else {
396 top = lpeitem;
397 }
399 if (SP_LPE_ITEM_CLASS (G_OBJECT_GET_CLASS (top))->update_patheffect) {
400 SP_LPE_ITEM_CLASS (G_OBJECT_GET_CLASS (top))->update_patheffect (top, write);
401 }
402 }
404 /**
405 * Gets called when (re)attached to another lpeobject.
406 */
407 static void
408 lpeobject_ref_changed(SPObject *old_ref, SPObject *ref, SPLPEItem *lpeitem)
409 {
410 if (old_ref) {
411 sp_signal_disconnect_by_data(old_ref, lpeitem);
412 }
413 if ( IS_LIVEPATHEFFECT(ref) && ref != lpeitem )
414 {
415 lpeitem->lpe_modified_connection.disconnect();
416 lpeitem->lpe_modified_connection = ref->connectModified(sigc::bind(sigc::ptr_fun(&lpeobject_ref_modified), lpeitem));
417 lpeobject_ref_modified(ref, 0, lpeitem);
418 }
419 }
421 /**
422 * Gets called when lpeobject repr contents change: i.e. parameter change.
423 */
424 static void
425 lpeobject_ref_modified(SPObject */*href*/, guint /*flags*/, SPLPEItem *lpeitem)
426 {
427 sp_lpe_item_update_patheffect (lpeitem, true, true);
428 }
430 static void
431 sp_lpe_item_create_original_path_recursive(SPLPEItem *lpeitem)
432 {
433 if (SP_IS_GROUP(lpeitem)) {
434 GSList const *item_list = sp_item_group_item_list(SP_GROUP(lpeitem));
435 for ( GSList const *iter = item_list; iter; iter = iter->next ) {
436 SPObject *subitem = static_cast<SPObject *>(iter->data);
437 if (SP_IS_LPE_ITEM(subitem)) {
438 sp_lpe_item_create_original_path_recursive(SP_LPE_ITEM(subitem));
439 }
440 }
441 }
442 else if (SP_IS_PATH(lpeitem)) {
443 Inkscape::XML::Node *pathrepr = SP_OBJECT_REPR(lpeitem);
444 if ( !pathrepr->attribute("inkscape:original-d") ) {
445 pathrepr->setAttribute("inkscape:original-d", pathrepr->attribute("d"));
446 }
447 }
448 }
450 static void
451 sp_lpe_item_cleanup_original_path_recursive(SPLPEItem *lpeitem)
452 {
453 if (SP_IS_GROUP(lpeitem)) {
454 GSList const *item_list = sp_item_group_item_list(SP_GROUP(lpeitem));
455 for ( GSList const *iter = item_list; iter; iter = iter->next ) {
456 SPObject *subitem = static_cast<SPObject *>(iter->data);
457 if (SP_IS_LPE_ITEM(subitem)) {
458 sp_lpe_item_cleanup_original_path_recursive(SP_LPE_ITEM(subitem));
459 }
460 }
461 }
462 else if (SP_IS_PATH(lpeitem)) {
463 Inkscape::XML::Node *repr = SP_OBJECT_REPR(lpeitem);
464 if (!sp_lpe_item_has_path_effect_recursive(lpeitem)
465 && repr->attribute("inkscape:original-d")) {
466 repr->setAttribute("d", repr->attribute("inkscape:original-d"));
467 repr->setAttribute("inkscape:original-d", NULL);
468 }
469 else {
470 sp_lpe_item_update_patheffect(lpeitem, true, true);
471 }
472 }
473 }
475 void sp_lpe_item_add_path_effect(SPLPEItem *lpeitem, gchar *value, bool reset)
476 {
477 if (value) {
478 // Apply the path effects here because in the casse of a group, lpe->resetDefaults
479 // needs that all the subitems have their effects applied
480 sp_lpe_item_update_patheffect(lpeitem, false, true);
482 // Disable the path effects while preparing the new lpe
483 sp_lpe_item_enable_path_effects(lpeitem, false);
485 // Add the new reference to the list of LPE references
486 HRefList hreflist;
487 for (PathEffectList::const_iterator it = lpeitem->path_effect_list->begin(); it != lpeitem->path_effect_list->end(); ++it)
488 {
489 hreflist.push_back( std::string((*it)->lpeobject_href) );
490 }
491 hreflist.push_back( std::string(value) );
492 std::string hrefs = hreflist_write_svg(hreflist);
494 SP_OBJECT_REPR(lpeitem)->setAttribute("inkscape:path-effect", hrefs.c_str());
496 // make sure there is an original-d for paths!!!
497 sp_lpe_item_create_original_path_recursive(lpeitem);
499 LivePathEffectObject *lpeobj = lpeitem->path_effect_list->back()->lpeobject;
500 if (lpeobj && lpeobj->get_lpe()) {
501 Inkscape::LivePathEffect::Effect *lpe = lpeobj->get_lpe();
502 // Ask the path effect to reset itself if it doesn't have parameters yet
503 if (reset) {
504 // has to be called when all the subitems have their lpes applied
505 lpe->resetDefaults(lpeitem);
506 }
508 // perform this once when the effect is applied
509 lpe->doOnApply(SP_LPE_ITEM(lpeitem));
511 // indicate that all necessary preparations are done and the effect can be performed
512 lpe->setReady();
513 }
515 //Enable the path effects now that everything is ready to apply the new path effect
516 sp_lpe_item_enable_path_effects(lpeitem, true);
518 // Apply the path effect
519 sp_lpe_item_update_patheffect(lpeitem, true, true);
520 }
521 }
523 void sp_lpe_item_add_path_effect(SPLPEItem *lpeitem, LivePathEffectObject * new_lpeobj)
524 {
525 const gchar * repr_id = SP_OBJECT_REPR(new_lpeobj)->attribute("id");
526 gchar *hrefstr = g_strdup_printf("#%s", repr_id);
527 sp_lpe_item_add_path_effect(lpeitem, hrefstr, false);
528 g_free(hrefstr);
529 }
531 void sp_lpe_item_remove_current_path_effect(SPLPEItem *lpeitem, bool keep_paths)
532 {
533 Inkscape::LivePathEffect::LPEObjectReference* lperef = sp_lpe_item_get_current_lpereference(lpeitem);
534 if (!lperef)
535 return;
537 PathEffectList new_list = *lpeitem->path_effect_list;
538 new_list.remove(lperef); //current lpe ref is always our 'own' pointer from the path_effect_list
539 std::string r = patheffectlist_write_svg(new_list);
541 SP_OBJECT_REPR(lpeitem)->setAttribute("inkscape:path-effect", r.c_str());
543 if (!keep_paths) {
544 sp_lpe_item_cleanup_original_path_recursive(lpeitem);
545 }
546 }
548 void sp_lpe_item_remove_all_path_effects(SPLPEItem *lpeitem, bool keep_paths)
549 {
550 SP_OBJECT_REPR(lpeitem)->setAttribute("inkscape:path-effect", NULL);
552 if (!keep_paths) {
553 sp_lpe_item_cleanup_original_path_recursive(lpeitem);
554 }
555 }
557 void sp_lpe_item_down_current_path_effect(SPLPEItem *lpeitem)
558 {
559 Inkscape::LivePathEffect::LPEObjectReference* lperef = sp_lpe_item_get_current_lpereference(lpeitem);
560 if (!lperef)
561 return;
563 PathEffectList new_list = *lpeitem->path_effect_list;
564 PathEffectList::iterator cur_it = find( new_list.begin(), new_list.end(), lperef );
565 if (cur_it != new_list.end()) {
566 PathEffectList::iterator down_it = cur_it;
567 down_it++;
568 if (down_it != new_list.end()) { // perhaps current effect is already last effect
569 std::iter_swap(cur_it, down_it);
570 }
571 }
572 std::string r = patheffectlist_write_svg(new_list);
573 SP_OBJECT_REPR(lpeitem)->setAttribute("inkscape:path-effect", r.c_str());
575 sp_lpe_item_cleanup_original_path_recursive(lpeitem);
576 }
578 void sp_lpe_item_up_current_path_effect(SPLPEItem *lpeitem)
579 {
580 Inkscape::LivePathEffect::LPEObjectReference* lperef = sp_lpe_item_get_current_lpereference(lpeitem);
581 if (!lperef)
582 return;
584 PathEffectList new_list = *lpeitem->path_effect_list;
585 PathEffectList::iterator cur_it = find( new_list.begin(), new_list.end(), lperef );
586 if (cur_it != new_list.end() && cur_it != new_list.begin()) {
587 PathEffectList::iterator up_it = cur_it;
588 up_it--;
589 std::iter_swap(cur_it, up_it);
590 }
591 std::string r = patheffectlist_write_svg(new_list);
593 SP_OBJECT_REPR(lpeitem)->setAttribute("inkscape:path-effect", r.c_str());
595 sp_lpe_item_cleanup_original_path_recursive(lpeitem);
596 }
599 bool sp_lpe_item_has_path_effect(SPLPEItem *lpeitem)
600 {
601 return !lpeitem->path_effect_list->empty();
602 }
604 bool sp_lpe_item_has_path_effect_recursive(SPLPEItem *lpeitem)
605 {
606 SPObject *parent = lpeitem->parent;
607 if (parent && SP_IS_LPE_ITEM(parent)) {
608 return sp_lpe_item_has_path_effect(lpeitem) || sp_lpe_item_has_path_effect_recursive(SP_LPE_ITEM(parent));
609 }
610 else {
611 return sp_lpe_item_has_path_effect(lpeitem);
612 }
613 }
615 Inkscape::LivePathEffect::Effect*
616 sp_lpe_item_has_path_effect_of_type(SPLPEItem *lpeitem, int type)
617 {
618 std::list<Inkscape::LivePathEffect::LPEObjectReference *>::iterator i;
619 for (i = lpeitem->path_effect_list->begin(); i != lpeitem->path_effect_list->end(); ++i) {
620 Inkscape::LivePathEffect::Effect* lpe = (*i)->lpeobject->get_lpe();
621 if (lpe && (lpe->effectType() == type)) {
622 return lpe;
623 }
624 }
625 return NULL;
626 }
628 /* Return false if the item is not a path or already has a shape applied */
629 bool sp_lpe_item_can_accept_freehand_shape(SPLPEItem *lpeitem)
630 {
631 if (!SP_IS_PATH(lpeitem))
632 return false;
634 if (sp_lpe_item_has_path_effect_of_type(lpeitem, Inkscape::LivePathEffect::FREEHAND_SHAPE))
635 return false;
637 return true;
638 }
640 void sp_lpe_item_edit_next_param_oncanvas(SPLPEItem *lpeitem, SPDesktop *dt)
641 {
642 Inkscape::LivePathEffect::LPEObjectReference *lperef = sp_lpe_item_get_current_lpereference(lpeitem);
643 if (lperef && lperef->lpeobject && lperef->lpeobject->get_lpe()) {
644 lperef->lpeobject->get_lpe()->editNextParamOncanvas(SP_ITEM(lpeitem), dt);
645 }
646 }
648 static void
649 sp_lpe_item_child_added (SPObject *object, Inkscape::XML::Node *child, Inkscape::XML::Node *ref)
650 {
651 if (((SPObjectClass *) (parent_class))->child_added)
652 (* ((SPObjectClass *) (parent_class))->child_added) (object, child, ref);
654 if (SP_IS_LPE_ITEM(object) && sp_lpe_item_has_path_effect_recursive(SP_LPE_ITEM(object))) {
655 SPObject *ochild = sp_object_get_child_by_repr(object, child);
656 if ( ochild && SP_IS_LPE_ITEM(ochild) ) {
657 sp_lpe_item_create_original_path_recursive(SP_LPE_ITEM(ochild));
658 }
659 }
660 }
662 static void
663 sp_lpe_item_remove_child (SPObject * object, Inkscape::XML::Node * child)
664 {
665 if (SP_IS_LPE_ITEM(object) && sp_lpe_item_has_path_effect_recursive(SP_LPE_ITEM(object))) {
666 SPObject *ochild = sp_object_get_child_by_repr(object, child);
667 if ( ochild && SP_IS_LPE_ITEM(ochild) ) {
668 sp_lpe_item_cleanup_original_path_recursive(SP_LPE_ITEM(ochild));
669 }
670 }
672 if (((SPObjectClass *) (parent_class))->remove_child)
673 (* ((SPObjectClass *) (parent_class))->remove_child) (object, child);
674 }
676 static std::string patheffectlist_write_svg(PathEffectList const & list)
677 {
678 HRefList hreflist;
679 for (PathEffectList::const_iterator it = list.begin(); it != list.end(); ++it)
680 {
681 hreflist.push_back( std::string((*it)->lpeobject_href) );
682 }
683 return hreflist_write_svg(hreflist);
684 }
686 /**
687 * THE function that should be used to generate any patheffectlist string.
688 * one of the methods to change the effect list:
689 * - create temporary href list
690 * - populate the templist with the effects from the old list that you want to have and their order
691 * - call this function with temp list as param
692 */
693 static std::string hreflist_write_svg(HRefList const & list)
694 {
695 std::string r;
696 bool semicolon_first = false;
697 for (HRefList::const_iterator it = list.begin(); it != list.end(); ++it)
698 {
699 if (semicolon_first) {
700 r += ';';
701 }
702 semicolon_first = true;
704 r += (*it);
705 }
706 return r;
707 }
709 // Return a copy of the effect list
710 PathEffectList sp_lpe_item_get_effect_list(SPLPEItem *lpeitem)
711 {
712 return *lpeitem->path_effect_list;
713 }
715 Inkscape::LivePathEffect::LPEObjectReference* sp_lpe_item_get_current_lpereference(SPLPEItem *lpeitem)
716 {
717 if (!lpeitem->current_path_effect && !lpeitem->path_effect_list->empty())
718 sp_lpe_item_set_current_path_effect(lpeitem, lpeitem->path_effect_list->back());
720 return lpeitem->current_path_effect;
721 }
723 Inkscape::LivePathEffect::Effect* sp_lpe_item_get_current_lpe(SPLPEItem *lpeitem)
724 {
725 Inkscape::LivePathEffect::LPEObjectReference* lperef = sp_lpe_item_get_current_lpereference(lpeitem);
727 if (lperef && lperef->lpeobject)
728 return lperef->lpeobject->get_lpe();
729 else
730 return NULL;
731 }
733 bool sp_lpe_item_set_current_path_effect(SPLPEItem *lpeitem, Inkscape::LivePathEffect::LPEObjectReference* lperef)
734 {
735 for (PathEffectList::iterator it = lpeitem->path_effect_list->begin(); it != lpeitem->path_effect_list->end(); it++) {
736 if ((*it)->lpeobject_repr == lperef->lpeobject_repr) {
737 lpeobject_ref_changed(NULL, (*it)->lpeobject, SP_LPE_ITEM(lpeitem)); // FIXME: explain why this is here?
738 lpeitem->current_path_effect = (*it); // current_path_effect should always be a pointer from the path_effect_list !
739 return true;
740 }
741 }
743 return false;
744 }
746 void sp_lpe_item_replace_path_effect(SPLPEItem *lpeitem, LivePathEffectObject * old_lpeobj,
747 LivePathEffectObject * new_lpeobj)
748 {
749 HRefList hreflist;
750 for (PathEffectList::const_iterator it = lpeitem->path_effect_list->begin(); it != lpeitem->path_effect_list->end(); ++it)
751 {
752 if ((*it)->lpeobject == old_lpeobj) {
753 const gchar * repr_id = SP_OBJECT_REPR(new_lpeobj)->attribute("id");
754 gchar *hrefstr = g_strdup_printf("#%s", repr_id);
755 hreflist.push_back( std::string(hrefstr) );
756 g_free(hrefstr);
757 }
758 else {
759 hreflist.push_back( std::string((*it)->lpeobject_href) );
760 }
761 }
762 std::string r = hreflist_write_svg(hreflist);
763 SP_OBJECT_REPR(lpeitem)->setAttribute("inkscape:path-effect", r.c_str());
764 }
766 // Enable or disable the path effects of the item.
767 // The counter allows nested calls
768 static void sp_lpe_item_enable_path_effects(SPLPEItem *lpeitem, bool enable)
769 {
770 if (enable) {
771 lpeitem->path_effects_enabled++;
772 }
773 else {
774 lpeitem->path_effects_enabled--;
775 }
776 }
778 // Are the path effects enabled on this item ?
779 bool sp_lpe_item_path_effects_enabled(SPLPEItem *lpeitem)
780 {
781 return lpeitem->path_effects_enabled > 0;
782 }
784 /*
785 Local Variables:
786 mode:c++
787 c-file-style:"stroustrup"
788 c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
789 indent-tabs-mode:nil
790 fill-column:99
791 End:
792 */
793 // vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:encoding=utf-8:textwidth=99 :