src/sp-lpe-item.cpp

   1 #define __SP_LPE_ITEM_CPP__
   2
   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  */
  15
  16 #ifdef HAVE_CONFIG_H
  17 # include "config.h"
  18 #endif
  19
  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"
  24
  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"
  38
  39 #include <algorithm>
  40
  41 /* LPEItem base class */
  42
  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);
  46
  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);
  53
  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);
  56
  57 static void sp_lpe_item_enable_path_effects(SPLPEItem *lpeitem, bool enable);
  58
  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);
  61
  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);
  67
  68 static SPItemClass *parent_class;
  69
  70 GType
  71 sp_lpe_item_get_type()
  72 {
  73     static GType lpe_item_type = 0;
  74
  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 }
  90
  91 static void
  92 sp_lpe_item_class_init(SPLPEItemClass *klass)
  93 {
  94     GObjectClass *gobject_class;
  95     SPObjectClass *sp_object_class;
  96
  97     gobject_class = (GObjectClass *) klass;
  98     sp_object_class = (SPObjectClass *) klass;
  99     parent_class = (SPItemClass *)g_type_class_peek_parent (klass);
 100
 101     gobject_class->finalize = sp_lpe_item_finalize;
 102
 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;
 111
 112     klass->update_patheffect = NULL;
 113 }
 114
 115 static void
 116 sp_lpe_item_init(SPLPEItem *lpeitem)
 117 {
 118     lpeitem->path_effects_enabled = 1;
 119
 120     lpeitem->path_effect_list = new PathEffectList();
 121     lpeitem->current_path_effect = NULL;
 122
 123     new (&lpeitem->lpe_modified_connection) sigc::connection();
 124 }
 125
 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 }
 133
 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");
 143
 144     if (((SPObjectClass *) parent_class)->build) {
 145         ((SPObjectClass *) parent_class)->build(object, document, repr);
 146     }
 147 }
 148
 149 /**
 150  * Drops any allocated memory.
 151  */
 152 static void
 153 sp_lpe_item_release(SPObject *object)
 154 {
 155     SPLPEItem *lpeitem = (SPLPEItem *) object;
 156
 157     lpeitem->lpe_modified_connection.disconnect();
 158     lpeitem->lpe_modified_connection.~connection();
 159
 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;
 169
 170     if (((SPObjectClass *) parent_class)->release)
 171         ((SPObjectClass *) parent_class)->release(object);
 172 }
 173
 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;
 181
 182     switch (key) {
 183         case SP_ATTR_INKSCAPE_PATH_EFFECT:
 184             {
 185                 lpeitem->current_path_effect = NULL;
 186
 187                 // Disable the path effects while populating the LPE list
 188                  sp_lpe_item_enable_path_effects(lpeitem, false);
 189
 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                 }
 198
 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                         }
 217
 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                 }
 228
 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 }
 239
 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     }
 249
 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?
 253
 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;
 261
 262     Inkscape::NodePath::Path *np = sh->get_nodepath();
 263     sp_nodepath_update_helperpaths(np);
 264 }
 265
 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     }
 275
 276     if (((SPObjectClass *) (parent_class))->modified) {
 277         (* ((SPObjectClass *) (parent_class))->modified) (object, flags);
 278     }
 279 }
 280
 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;
 288
 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     }
 295
 296     if (((SPObjectClass *)(parent_class))->write) {
 297         ((SPObjectClass *)(parent_class))->write(object, xml_doc, repr, flags);
 298     }
 299
 300     return repr;
 301 }
 302
 303 void sp_lpe_item_perform_path_effect(SPLPEItem *lpeitem, SPCurve *curve) {
 304     if (!lpeitem) return;
 305     if (!curve) return;
 306
 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             }
 326
 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                 }
 333
 334                 // Groups have their doBeforeEffect called elsewhere
 335                 if (!SP_IS_GROUP(lpeitem)) {
 336                     lpe->doBeforeEffect(lpeitem);
 337                 }
 338
 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 }
 353
 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));
 365
 366     if (!sp_lpe_item_path_effects_enabled(lpeitem))
 367         return;
 368
 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     }
 383
 384     SPLPEItem *top;
 385
 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     }
 398
 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 }
 403
 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 }
 420
 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 }
 429
 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 }
 449
 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 }
 474
 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);
 481
 482         // Disable the path effects while preparing the new lpe
 483         sp_lpe_item_enable_path_effects(lpeitem, false);
 484
 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);
 493
 494         SP_OBJECT_REPR(lpeitem)->setAttribute("inkscape:path-effect", hrefs.c_str());
 495
 496         // make sure there is an original-d for paths!!!
 497         sp_lpe_item_create_original_path_recursive(lpeitem);
 498
 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             }
 507
 508             // perform this once when the effect is applied
 509             lpe->doOnApply(SP_LPE_ITEM(lpeitem));
 510
 511             // indicate that all necessary preparations are done and the effect can be performed
 512             lpe->setReady();
 513         }
 514
 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);
 517
 518         // Apply the path effect
 519         sp_lpe_item_update_patheffect(lpeitem, true, true);
 520     }
 521 }
 522
 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 }
 530
 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;
 536
 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);
 540
 541     SP_OBJECT_REPR(lpeitem)->setAttribute("inkscape:path-effect", r.c_str());
 542
 543     if (!keep_paths) {
 544         sp_lpe_item_cleanup_original_path_recursive(lpeitem);
 545     }
 546 }
 547
 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);
 551
 552     if (!keep_paths) {
 553         sp_lpe_item_cleanup_original_path_recursive(lpeitem);
 554     }
 555 }
 556
 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;
 562
 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());
 574
 575     sp_lpe_item_cleanup_original_path_recursive(lpeitem);
 576 }
 577
 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;
 583
 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);
 592
 593     SP_OBJECT_REPR(lpeitem)->setAttribute("inkscape:path-effect", r.c_str());
 594
 595     sp_lpe_item_cleanup_original_path_recursive(lpeitem);
 596 }
 597
 598
 599 bool sp_lpe_item_has_path_effect(SPLPEItem *lpeitem)
 600 {
 601     return !lpeitem->path_effect_list->empty();
 602 }
 603
 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 }
 614
 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 }
 627
 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;
 633
 634     if (sp_lpe_item_has_path_effect_of_type(lpeitem, Inkscape::LivePathEffect::FREEHAND_SHAPE))
 635         return false;
 636
 637     return true;
 638 }
 639
 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 }
 647
 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);
 653
 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 }
 661
 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     }
 671
 672     if (((SPObjectClass *) (parent_class))->remove_child)
 673         (* ((SPObjectClass *) (parent_class))->remove_child) (object, child);
 674 }
 675
 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 }
 685
 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;
 703
 704         r += (*it);
 705     }
 706     return r;
 707 }
 708
 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 }
 714
 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());
 719
 720     return lpeitem->current_path_effect;
 721 }
 722
 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);
 726
 727     if (lperef && lperef->lpeobject)
 728         return lperef->lpeobject->get_lpe();
 729     else
 730         return NULL;
 731 }
 732
 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     }
 742
 743     return false;
 744 }
 745
 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 }
 765
 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 }
 777
 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 }
 783
 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 :