synfig-core/src/synfig/canvas.cpp

   1 /* === S Y N F I G ========================================================= */
   2 /*!     \file canvas.cpp
   3 **      \brief Canvas Class Member Definitions
   4 **
   5 **      $Id$
   6 **
   7 **      \legal
   8 **      Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
   9 **      Copyright (c) 2007, 2008 Chris Moore
  10 **
  11 **      This package is free software; you can redistribute it and/or
  12 **      modify it under the terms of the GNU General Public License as
  13 **      published by the Free Software Foundation; either version 2 of
  14 **      the License, or (at your option) any later version.
  15 **
  16 **      This package is distributed in the hope that it will be useful,
  17 **      but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 **      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  19 **      General Public License for more details.
  20 **      \endlegal
  21 */
  22 /* ========================================================================= */
  23
  24 /* === H E A D E R S ======================================================= */
  25
  26 #ifdef USING_PCH
  27 #       include "pch.h"
  28 #else
  29 #ifdef HAVE_CONFIG_H
  30 #       include <config.h>
  31 #endif
  32
  33 #include "layer.h"
  34 #include "canvas.h"
  35 #include <cassert>
  36 #include "exception.h"
  37 #include "time.h"
  38 #include "context.h"
  39 #include "layer_pastecanvas.h"
  40 #include "loadcanvas.h"
  41 #include <sigc++/bind.h>
  42
  43 #endif
  44
  45 using namespace synfig;
  46 using namespace etl;
  47 using namespace std;
  48
  49 namespace synfig { extern Canvas::Handle open_canvas(const String &filename, String &errors, String &warnings); };
  50
  51 /* === M A C R O S ========================================================= */
  52
  53 #define ALLOW_CLONE_NON_INLINE_CANVASES
  54
  55 struct _CanvasCounter
  56 {
  57         static int counter;
  58         ~_CanvasCounter()
  59         {
  60                 if(counter)
  61                         synfig::error("%d canvases not yet deleted!",counter);
  62         }
  63 } _canvas_counter;
  64
  65 int _CanvasCounter::counter(0);
  66
  67 /* === G L O B A L S ======================================================= */
  68
  69 /* === P R O C E D U R E S ================================================= */
  70
  71 /* === M E T H O D S ======================================================= */
  72
  73 Canvas::Canvas(const String &id):
  74         id_                     (id),
  75         version_        (CURRENT_CANVAS_VERSION),
  76         cur_time_       (0),
  77         is_inline_      (false),
  78         is_dirty_       (true),
  79         op_flag_        (false)
  80 {
  81         _CanvasCounter::counter++;
  82         clear();
  83 }
  84
  85 void
  86 Canvas::on_changed()
  87 {
  88         is_dirty_=true;
  89         Node::on_changed();
  90 }
  91
  92 Canvas::~Canvas()
  93 {
  94         // we were having a crash where pastecanvas layers were still
  95         // refering to a canvas after it had been destroyed;  this code
  96         // will stop the pastecanvas layers from refering to the canvas
  97         // before the canvas is destroyed
  98
  99         // the set_sub_canvas(0) ends up deleting the parent-child link,
 100         // which deletes the current element from the set we're iterating
 101         // through, so we have to make sure we've incremented the iterator
 102         // before we mess with the pastecanvas
 103         std::set<Node*>::iterator iter = parent_set.begin();
 104         while (iter != parent_set.end())
 105         {
 106                 Layer_PasteCanvas* paste_canvas = dynamic_cast<Layer_PasteCanvas*>(*iter);
 107                 iter++;
 108                 if(paste_canvas)
 109                         paste_canvas->set_sub_canvas(0);
 110                 else
 111                         warning("destroyed canvas has a parent that is not a pastecanvas - please report if repeatable");
 112         }
 113
 114         //if(is_inline() && parent_) assert(0);
 115         _CanvasCounter::counter--;
 116         clear();
 117         begin_delete();
 118 }
 119
 120 Canvas::iterator
 121 Canvas::end()
 122 {
 123         return CanvasBase::end()-1;
 124 }
 125
 126 Canvas::const_iterator
 127 Canvas::end()const
 128 {
 129         return CanvasBase::end()-1;
 130 }
 131
 132 Canvas::reverse_iterator
 133 Canvas::rbegin()
 134 {
 135         return CanvasBase::rbegin()+1;
 136 }
 137
 138 Canvas::const_reverse_iterator
 139 Canvas::rbegin()const
 140 {
 141         return CanvasBase::rbegin()+1;
 142 }
 143
 144 int
 145 Canvas::size()const
 146 {
 147         return CanvasBase::size()-1;
 148 }
 149
 150 void
 151 Canvas::clear()
 152 {
 153         while(!empty())
 154         {
 155                 Layer::Handle layer(front());
 156                 //if(layer->count()>2)synfig::info("before layer->count()=%d",layer->count());
 157
 158                 erase(begin());
 159                 //if(layer->count()>1)synfig::info("after layer->count()=%d",layer->count());
 160         }
 161         //CanvasBase::clear();
 162
 163         // We need to keep a blank handle at the
 164         // end of the image list, and acts at
 165         // the bottom. Without it, the layers
 166         // would just continue going when polled
 167         // for a color.
 168         CanvasBase::push_back(Layer::Handle());
 169
 170         changed();
 171 }
 172
 173 bool
 174 Canvas::empty()const
 175 {
 176         return CanvasBase::size()<=1;
 177 }
 178
 179 Layer::Handle &
 180 Canvas::back()
 181 {
 182         return *(CanvasBase::end()-1);
 183 }
 184
 185 const Layer::Handle &
 186 Canvas::back()const
 187 {
 188         return *(CanvasBase::end()-1);
 189 }
 190
 191 Context
 192 Canvas::get_context()const
 193 {
 194         return begin();
 195 }
 196
 197 const ValueNodeList &
 198 Canvas::value_node_list()const
 199 {
 200         if(is_inline() && parent_)
 201                 return parent_->value_node_list();
 202         return value_node_list_;
 203 }
 204
 205 KeyframeList &
 206 Canvas::keyframe_list()
 207 {
 208         if(is_inline() && parent_)
 209                 return parent_->keyframe_list();
 210         return keyframe_list_;
 211 }
 212
 213 const KeyframeList &
 214 Canvas::keyframe_list()const
 215 {
 216         if(is_inline() && parent_)
 217                 return parent_->keyframe_list();
 218         return keyframe_list_;
 219 }
 220
 221 etl::handle<Layer>
 222 Canvas::find_layer(const Point &pos)
 223 {
 224         return get_context().hit_check(pos);
 225 }
 226
 227 static bool
 228 valid_id(const String &x)
 229 {
 230         static const char bad_chars[]=" :#@$^&()*";
 231         unsigned int i;
 232
 233         if(!x.empty() && x[0]>='0' && x[0]<='9')
 234                 return false;
 235
 236         for(i=0;i<sizeof(bad_chars);i++)
 237                 if(x.find_first_of(bad_chars[i])!=string::npos)
 238                         return false;
 239
 240         return true;
 241 }
 242
 243 void
 244 Canvas::set_id(const String &x)
 245 {
 246         if(is_inline() && parent_)
 247                 throw runtime_error("Inline Canvas cannot have an ID");
 248
 249         if(!valid_id(x))
 250                 throw runtime_error("Invalid ID");
 251         id_=x;
 252         signal_id_changed_();
 253 }
 254
 255 void
 256 Canvas::set_name(const String &x)
 257 {
 258         name_=x;
 259         signal_meta_data_changed()("name");
 260         signal_meta_data_changed("name")();
 261 }
 262
 263 void
 264 Canvas::set_author(const String &x)
 265 {
 266         author_=x;
 267         signal_meta_data_changed()("author");
 268         signal_meta_data_changed("author")();
 269 }
 270
 271 void
 272 Canvas::set_description(const String &x)
 273 {
 274         description_=x;
 275         signal_meta_data_changed()("description");
 276         signal_meta_data_changed("description")();
 277 }
 278
 279 void
 280 Canvas::set_time(Time t)const
 281 {
 282         if(is_dirty_ || !get_time().is_equal(t))
 283         {
 284 #if 0
 285                 if(is_root())
 286                 {
 287                         synfig::info("is_dirty_=%d",is_dirty_);
 288                         synfig::info("get_time()=%f",(float)get_time());
 289                         synfig::info("t=%f",(float)t);
 290                 }
 291 #endif
 292
 293                 // ...questionable
 294                 const_cast<Canvas&>(*this).cur_time_=t;
 295
 296                 is_dirty_=false;
 297                 get_context().set_time(t);
 298         }
 299         is_dirty_=false;
 300 }
 301
 302 Canvas::LooseHandle
 303 Canvas::get_root()const
 304 {
 305         return parent_?parent_->get_root().get():const_cast<synfig::Canvas *>(this);
 306 }
 307
 308 int
 309 Canvas::get_depth(etl::handle<Layer> layer)const
 310 {
 311         const_iterator iter;
 312         int i(0);
 313         for(iter=begin();iter!=end();++iter,i++)
 314         {
 315                 if(layer==*iter)
 316                         return i;
 317         }
 318         return -1;
 319 }
 320
 321 String
 322 Canvas::get_relative_id(etl::loose_handle<const Canvas> x)const
 323 {
 324         if(x->get_root()==this)
 325                 return ":";
 326         if(is_inline() && parent_)
 327                 return parent_->_get_relative_id(x);
 328         return _get_relative_id(x);
 329 }
 330
 331 String
 332 Canvas::_get_relative_id(etl::loose_handle<const Canvas> x)const
 333 {
 334         if(is_inline() && parent_)
 335                 return parent_->_get_relative_id(x);
 336
 337         if(x.get()==this)
 338                 return String();
 339
 340         if(parent()==x.get())
 341                 return get_id();
 342
 343         String id;
 344
 345         const Canvas* canvas=this;
 346
 347         for(;!canvas->is_root();canvas=canvas->parent().get())
 348                 id=':'+canvas->get_id()+id;
 349
 350         if(x && get_root()!=x->get_root())
 351         {
 352                 //String file_name=get_file_name();
 353                 //String file_path=x->get_file_path();
 354
 355                 String file_name;
 356                 if(is_absolute_path(get_file_name()))
 357                         file_name=etl::relative_path(x->get_file_path(),get_file_name());
 358                 else
 359                         file_name=get_file_name();
 360
 361                 // If the path of X is inside of file_name,
 362                 // then remove it.
 363                 //if(file_name.size()>file_path.size())
 364                 //      if(file_path==String(file_name,0,file_path.size()))
 365                 //              file_name.erase(0,file_path.size()+1);
 366
 367                 id=file_name+'#'+id;
 368         }
 369
 370         return id;
 371 }
 372
 373 ValueNode::Handle
 374 Canvas::find_value_node(const String &id)
 375 {
 376         return
 377                 ValueNode::Handle::cast_const(
 378                         const_cast<const Canvas*>(this)->find_value_node(id)
 379                 );
 380 }
 381
 382 ValueNode::ConstHandle
 383 Canvas::find_value_node(const String &id)const
 384 {
 385         if(is_inline() && parent_)
 386                 return parent_->find_value_node(id);
 387
 388         if(id.empty())
 389                 throw Exception::IDNotFound("Empty ID");
 390
 391         // If we do not have any resolution, then we assume that the
 392         // request is for this immediate canvas
 393         if(id.find_first_of(':')==string::npos && id.find_first_of('#')==string::npos)
 394                 return value_node_list_.find(id);
 395
 396         String canvas_id(id,0,id.rfind(':'));
 397         String value_node_id(id,id.rfind(':')+1);
 398         if(canvas_id.empty())
 399                 canvas_id=':';
 400         //synfig::warning("constfind:value_node_id: "+value_node_id);
 401         //synfig::warning("constfind:canvas_id: "+canvas_id);
 402
 403         String warnings;
 404         return find_canvas(canvas_id, warnings)->value_node_list_.find(value_node_id);
 405 }
 406
 407 ValueNode::Handle
 408 Canvas::surefind_value_node(const String &id)
 409 {
 410         if(is_inline() && parent_)
 411                 return parent_->surefind_value_node(id);
 412
 413         if(id.empty())
 414                 throw Exception::IDNotFound("Empty ID");
 415
 416         // If we do not have any resolution, then we assume that the
 417         // request is for this immediate canvas
 418         if(id.find_first_of(':')==string::npos && id.find_first_of('#')==string::npos)
 419                 return value_node_list_.surefind(id);
 420
 421         String canvas_id(id,0,id.rfind(':'));
 422         String value_node_id(id,id.rfind(':')+1);
 423         if(canvas_id.empty())
 424                 canvas_id=':';
 425
 426         String warnings;
 427         return surefind_canvas(canvas_id,warnings)->value_node_list_.surefind(value_node_id);
 428 }
 429
 430 void
 431 Canvas::add_value_node(ValueNode::Handle x, const String &id)
 432 {
 433         if(is_inline() && parent_)
 434                 return parent_->add_value_node(x,id);
 435 //              throw runtime_error("You cannot add a ValueNode to an inline Canvas");
 436
 437         if(x->is_exported())
 438                 throw runtime_error("ValueNode is already exported");
 439
 440         if(id.empty())
 441                 throw Exception::BadLinkName("Empty ID");
 442
 443         if(id.find_first_of(':',0)!=string::npos)
 444                 throw Exception::BadLinkName("Bad character");
 445
 446         try
 447         {
 448                 if(PlaceholderValueNode::Handle::cast_dynamic(value_node_list_.find(id)))
 449                         throw Exception::IDNotFound("add_value_node()");
 450
 451                 throw Exception::IDAlreadyExists(id);
 452         }
 453         catch(Exception::IDNotFound)
 454         {
 455                 x->set_id(id);
 456
 457                 x->set_parent_canvas(this);
 458
 459                 if(!value_node_list_.add(x))
 460                 {
 461                         synfig::error("Unable to add ValueNode");
 462                         throw std::runtime_error("Unable to add ValueNode");
 463                 }
 464
 465                 return;
 466         }
 467 }
 468
 469 /*
 470 void
 471 Canvas::rename_value_node(ValueNode::Handle x, const String &id)
 472 {
 473         if(id.empty())
 474                 throw Exception::BadLinkName("Empty ID");
 475
 476         if(id.find_first_of(": ",0)!=string::npos)
 477                 throw Exception::BadLinkName("Bad character");
 478
 479         try
 480         {
 481                 if(PlaceholderValueNode::Handle::cast_dynamic(value_node_list_.find(id)))
 482                         throw Exception::IDNotFound("rename_value_node");
 483                 throw Exception::IDAlreadyExists(id);
 484         }
 485         catch(Exception::IDNotFound)
 486         {
 487                 x->set_id(id);
 488
 489                 return;
 490         }
 491 }
 492 */
 493
 494 void
 495 Canvas::remove_value_node(ValueNode::Handle x)
 496 {
 497         if(is_inline() && parent_)
 498                 return parent_->remove_value_node(x);
 499 //              throw Exception::IDNotFound("Canvas::remove_value_node() was called from an inline canvas");
 500
 501         if(!x)
 502                 throw Exception::IDNotFound("Canvas::remove_value_node() was passed empty handle");
 503
 504         if(!value_node_list_.erase(x))
 505                 throw Exception::IDNotFound("Canvas::remove_value_node(): ValueNode was not found inside of this canvas");
 506
 507         //x->set_parent_canvas(0);
 508
 509         x->set_id("");
 510 }
 511
 512 Canvas::Handle
 513 Canvas::surefind_canvas(const String &id, String &warnings)
 514 {
 515         if(is_inline() && parent_)
 516                 return parent_->surefind_canvas(id,warnings);
 517
 518         if(id.empty())
 519                 return this;
 520
 521         // If the ID contains a "#" character, then a filename is
 522         // expected on the left side.
 523         if(id.find_first_of('#')!=string::npos)
 524         {
 525                 // If '#' is the first character, remove it
 526                 // and attempt to parse the ID again.
 527                 if(id[0]=='#')
 528                         return surefind_canvas(String(id,1),warnings);
 529
 530                 //! \todo This needs a lot more optimization
 531                 String file_name(id,0,id.find_first_of('#'));
 532                 String external_id(id,id.find_first_of('#')+1);
 533
 534                 file_name=unix_to_local_path(file_name);
 535
 536                 Canvas::Handle external_canvas;
 537
 538                 if(!is_absolute_path(file_name))
 539                         file_name = get_file_path()+ETL_DIRECTORY_SEPARATOR+file_name;
 540
 541                 // If the composition is already open, then use it.
 542                 if(externals_.count(file_name))
 543                         external_canvas=externals_[file_name];
 544                 else
 545                 {
 546                         String errors;
 547                         external_canvas=open_canvas(file_name, errors, warnings);
 548                         if(!external_canvas)
 549                                 throw runtime_error(errors);
 550                         externals_[file_name]=external_canvas;
 551                 }
 552
 553                 return Handle::cast_const(external_canvas.constant()->find_canvas(external_id, warnings));
 554         }
 555
 556         // If we do not have any resolution, then we assume that the
 557         // request is for this immediate canvas
 558         if(id.find_first_of(':')==string::npos)
 559         {
 560                 Children::iterator iter;
 561
 562                 // Search for the image in the image list,
 563                 // and return it if it is found
 564                 for(iter=children().begin();iter!=children().end();iter++)
 565                         if(id==(*iter)->get_id())
 566                                 return *iter;
 567
 568                 // Create a new canvas and return it
 569                 //synfig::warning("Implicitly creating canvas named "+id);
 570                 return new_child_canvas(id);
 571         }
 572
 573         // If the first character is the separator, then
 574         // this references the root canvas.
 575         if(id[0]==':')
 576                 return get_root()->surefind_canvas(string(id,1),warnings);
 577
 578         // Now we know that the requested Canvas is in a child
 579         // of this canvas. We have to find that canvas and
 580         // call "find_canvas" on it, and return the result.
 581
 582         String canvas_name=string(id,0,id.find_first_of(':'));
 583
 584         Canvas::Handle child_canvas=surefind_canvas(canvas_name,warnings);
 585
 586         return child_canvas->surefind_canvas(string(id,id.find_first_of(':')+1),warnings);
 587 }
 588
 589 Canvas::Handle
 590 Canvas::find_canvas(const String &id, String &warnings)
 591 {
 592         return
 593                 Canvas::Handle::cast_const(
 594                         const_cast<const Canvas*>(this)->find_canvas(id, warnings)
 595                 );
 596 }
 597
 598 Canvas::ConstHandle
 599 Canvas::find_canvas(const String &id, String &warnings)const
 600 {
 601         if(is_inline() && parent_)
 602                 return parent_->find_canvas(id, warnings);
 603
 604         if(id.empty())
 605                 return this;
 606
 607         // If the ID contains a "#" character, then a filename is
 608         // expected on the left side.
 609         if(id.find_first_of('#')!=string::npos)
 610         {
 611                 // If '#' is the first character, remove it
 612                 // and attempt to parse the ID again.
 613                 if(id[0]=='#')
 614                         return find_canvas(String(id,1), warnings);
 615
 616                 //! \todo This needs a lot more optimization
 617                 String file_name(id,0,id.find_first_of('#'));
 618                 String external_id(id,id.find_first_of('#')+1);
 619
 620                 file_name=unix_to_local_path(file_name);
 621
 622                 Canvas::Handle external_canvas;
 623
 624                 if(!is_absolute_path(file_name))
 625                         file_name = get_file_path()+ETL_DIRECTORY_SEPARATOR+file_name;
 626
 627                 // If the composition is already open, then use it.
 628                 if(externals_.count(file_name))
 629                         external_canvas=externals_[file_name];
 630                 else
 631                 {
 632                         String errors, warnings;
 633                         external_canvas=open_canvas(file_name, errors, warnings);
 634                         if(!external_canvas)
 635                                 throw runtime_error(errors);
 636                         externals_[file_name]=external_canvas;
 637                 }
 638
 639                 return Handle::cast_const(external_canvas.constant()->find_canvas(external_id, warnings));
 640         }
 641
 642         // If we do not have any resolution, then we assume that the
 643         // request is for this immediate canvas
 644         if(id.find_first_of(':')==string::npos)
 645         {
 646                 Children::const_iterator iter;
 647
 648                 // Search for the image in the image list,
 649                 // and return it if it is found
 650                 for(iter=children().begin();iter!=children().end();iter++)
 651                         if(id==(*iter)->get_id())
 652                                 return *iter;
 653
 654                 throw Exception::IDNotFound("Child Canvas in Parent Canvas: (child)"+id);
 655         }
 656
 657         // If the first character is the separator, then
 658         // this references the root canvas.
 659         if(id[0]==':')
 660                 return get_root()->find_canvas(string(id,1), warnings);
 661
 662         // Now we know that the requested Canvas is in a child
 663         // of this canvas. We have to find that canvas and
 664         // call "find_canvas" on it, and return the result.
 665
 666         String canvas_name=string(id,0,id.find_first_of(':'));
 667
 668         Canvas::ConstHandle child_canvas=find_canvas(canvas_name, warnings);
 669
 670         return child_canvas->find_canvas(string(id,id.find_first_of(':')+1), warnings);
 671 }
 672
 673 Canvas::Handle
 674 Canvas::create()
 675 {
 676         return new Canvas("Untitled");
 677 }
 678
 679 void
 680 Canvas::push_back(etl::handle<Layer> x)
 681 {
 682 //      int i(x->count());
 683         insert(end(),x);
 684         //if(x->count()!=i+1)synfig::info("push_back before %d, after %d",i,x->count());
 685 }
 686
 687 void
 688 Canvas::push_front(etl::handle<Layer> x)
 689 {
 690 //      int i(x->count());
 691         insert(begin(),x);
 692         //if(x->count()!=i+1)synfig::error("push_front before %d, after %d",i,x->count());
 693 }
 694
 695 void
 696 Canvas::insert(iterator iter,etl::handle<Layer> x)
 697 {
 698 //      int i(x->count());
 699         CanvasBase::insert(iter,x);
 700
 701         /*if(x->count()!=i+1)
 702         {
 703                 synfig::error(__FILE__":%d: Canvas::insert(): ***FAILURE*** before %d, after %d",__LINE__,i,x->count());
 704                 return;
 705                 //throw runtime_error("Canvas Insertion Failed");
 706         }*/
 707
 708         x->set_canvas(this);
 709
 710         add_child(x.get());
 711
 712         LooseHandle correct_canvas(this);
 713         //while(correct_canvas->is_inline())correct_canvas=correct_canvas->parent();
 714         Layer::LooseHandle loose_layer(x);
 715
 716         add_connection(loose_layer,
 717                                    sigc::connection::connection(
 718                                            x->signal_added_to_group().connect(
 719                                                    sigc::bind(
 720                                                            sigc::mem_fun(
 721                                                                    *correct_canvas,
 722                                                                    &Canvas::add_group_pair),
 723                                                            loose_layer))));
 724         add_connection(loose_layer,
 725                                    sigc::connection::connection(
 726                                            x->signal_removed_from_group().connect(
 727                                                    sigc::bind(
 728                                                            sigc::mem_fun(
 729                                                                    *correct_canvas,
 730                                                                    &Canvas::remove_group_pair),
 731                                                            loose_layer))));
 732
 733         if(!x->get_group().empty())
 734                 add_group_pair(x->get_group(),x);
 735
 736         changed();
 737 }
 738
 739 void
 740 Canvas::push_back_simple(etl::handle<Layer> x)
 741 {
 742         CanvasBase::insert(end(),x);
 743         changed();
 744 }
 745
 746 void
 747 Canvas::erase(iterator iter)
 748 {
 749         if(!(*iter)->get_group().empty())
 750                 remove_group_pair((*iter)->get_group(),(*iter));
 751
 752         // HACK: We really shouldn't be wiping
 753         // out these signals entirely. We should
 754         // only be removing the specific connections
 755         // that we made. At the moment, I'm too
 756         // lazy to add the code to keep track
 757         // of those connections, and no one else
 758         // is using these signals, so I'll just
 759         // leave these next two lines like they
 760         // are for now - darco 07-30-2004
 761
 762         // so don't wipe them out entirely
 763         // - dooglus 09-21-2007
 764         disconnect_connections(*iter);
 765
 766         if(!op_flag_)remove_child(iter->get());
 767
 768         CanvasBase::erase(iter);
 769         if(!op_flag_)changed();
 770 }
 771
 772 Canvas::Handle
 773 Canvas::clone(const GUID& deriv_guid)const
 774 {
 775         synfig::String name;
 776         if(is_inline())
 777                 name=_("in line");
 778         else
 779         {
 780                 name=get_id()+"_CLONE";
 781
 782 #ifndef ALLOW_CLONE_NON_INLINE_CANVASES
 783                 throw runtime_error("Cloning of non-inline canvases is not yet supported");
 784 #endif  // ALLOW_CLONE_NON_INLINE_CANVASES
 785         }
 786
 787         Handle canvas(new Canvas(name));
 788
 789         if(is_inline())
 790         {
 791                 canvas->is_inline_=true;
 792                 // \todo this was setting parent_=0 - is there a reason for that?
 793                 // this was causing bug 1838132, where cloning an inline canvas that contains an imported image fails
 794                 // it was failing to ascertain the absolute pathname of the imported image, since it needs the pathname
 795                 // of the canvas to get that, which is stored in the parent canvas
 796                 canvas->parent_=parent();
 797                 canvas->rend_desc() = rend_desc();
 798                 //canvas->set_inline(parent());
 799         }
 800
 801         canvas->set_guid(get_guid()^deriv_guid);
 802
 803         const_iterator iter;
 804         for(iter=begin();iter!=end();++iter)
 805         {
 806                 Layer::Handle layer((*iter)->clone(deriv_guid));
 807                 if(layer)
 808                 {
 809                         assert(layer.count()==1);
 810                         int presize(size());
 811                         canvas->push_back(layer);
 812                         if(!(layer.count()>1))
 813                         {
 814                                 synfig::error("Canvas::clone(): Cloned layer insertion failure!");
 815                                 synfig::error("Canvas::clone(): \tlayer.count()=%d",layer.count());
 816                                 synfig::error("Canvas::clone(): \tlayer->get_name()=%s",layer->get_name().c_str());
 817                                 synfig::error("Canvas::clone(): \tbefore size()=%d",presize);
 818                                 synfig::error("Canvas::clone(): \tafter size()=%d",size());
 819                         }
 820                         assert(layer.count()>1);
 821                 }
 822                 else
 823                 {
 824                         synfig::error("Unable to clone layer");
 825                 }
 826         }
 827
 828         canvas->signal_group_pair_removed().clear();
 829         canvas->signal_group_pair_added().clear();
 830
 831         return canvas;
 832 }
 833
 834 void
 835 Canvas::set_inline(LooseHandle parent)
 836 {
 837         if(is_inline_ && parent_)
 838         {
 839
 840         }
 841
 842         id_=_("in line");
 843         is_inline_=true;
 844         parent_=parent;
 845
 846         // Have the parent inherit all of the group stuff
 847
 848         std::map<String,std::set<etl::handle<Layer> > >::const_iterator iter;
 849
 850         for(iter=group_db_.begin();iter!=group_db_.end();++iter)
 851         {
 852                 parent->group_db_[iter->first].insert(iter->second.begin(),iter->second.end());
 853         }
 854
 855         rend_desc()=parent->rend_desc();
 856 }
 857
 858 Canvas::Handle
 859 Canvas::create_inline(Handle parent)
 860 {
 861         assert(parent);
 862         //if(parent->is_inline())
 863         //      return create_inline(parent->parent());
 864
 865         Handle canvas(new Canvas(_("in line")));
 866         canvas->set_inline(parent);
 867         return canvas;
 868 }
 869
 870 Canvas::Handle
 871 Canvas::new_child_canvas()
 872 {
 873         if(is_inline() && parent_)
 874                 return parent_->new_child_canvas();
 875 //              runtime_error("You cannot create a child Canvas in an inline Canvas");
 876
 877         // Create a new canvas
 878         children().push_back(create());
 879         Canvas::Handle canvas(children().back());
 880
 881         canvas->parent_=this;
 882
 883         canvas->rend_desc()=rend_desc();
 884
 885         return canvas;
 886 }
 887
 888 Canvas::Handle
 889 Canvas::new_child_canvas(const String &id)
 890 {
 891         if(is_inline() && parent_)
 892                 return parent_->new_child_canvas(id);
 893 //              runtime_error("You cannot create a child Canvas in an inline Canvas");
 894
 895         // Create a new canvas
 896         children().push_back(create());
 897         Canvas::Handle canvas(children().back());
 898
 899         canvas->set_id(id);
 900         canvas->parent_=this;
 901         canvas->rend_desc()=rend_desc();
 902
 903         return canvas;
 904 }
 905
 906 Canvas::Handle
 907 Canvas::add_child_canvas(Canvas::Handle child_canvas, const synfig::String& id)
 908 {
 909         if(is_inline() && parent_)
 910                 return parent_->add_child_canvas(child_canvas,id);
 911
 912         if(child_canvas->parent() && !child_canvas->is_inline())
 913                 throw std::runtime_error("Cannot add child canvas because it belongs to someone else!");
 914
 915         if(!valid_id(id))
 916                 throw runtime_error("Invalid ID");
 917
 918         try
 919         {
 920                 String warnings;
 921                 find_canvas(id, warnings);
 922                 throw Exception::IDAlreadyExists(id);
 923         }
 924         catch(Exception::IDNotFound)
 925         {
 926                 if(child_canvas->is_inline())
 927                         child_canvas->is_inline_=false;
 928                 child_canvas->id_=id;
 929                 children().push_back(child_canvas);
 930                 child_canvas->parent_=this;
 931         }
 932
 933         return child_canvas;
 934 }
 935
 936 void
 937 Canvas::remove_child_canvas(Canvas::Handle child_canvas)
 938 {
 939         if(is_inline() && parent_)
 940                 return parent_->remove_child_canvas(child_canvas);
 941
 942         if(child_canvas->parent_!=this)
 943                 throw runtime_error("Given child does not belong to me");
 944
 945         if(find(children().begin(),children().end(),child_canvas)==children().end())
 946                 throw Exception::IDNotFound(child_canvas->get_id());
 947
 948         children().remove(child_canvas);
 949
 950         child_canvas->parent_=0;
 951 }
 952
 953 void
 954 Canvas::set_file_name(const String &file_name)
 955 {
 956         if(parent())
 957                 parent()->set_file_name(file_name);
 958         else
 959         {
 960                 String old_name(file_name_);
 961                 file_name_=file_name;
 962
 963                 // when a canvas is made, its name is ""
 964                 // then, before it's saved or even edited, it gets a name like "Synfig Animation 23", in the local language
 965                 // we don't want to register the canvas' filename in the canvas map until it gets a real filename
 966                 if (old_name != "")
 967                 {
 968                         file_name_=file_name;
 969                         std::map<synfig::String, etl::loose_handle<Canvas> >::iterator iter;
 970                         for(iter=get_open_canvas_map().begin();iter!=get_open_canvas_map().end();++iter)
 971                                 if(iter->second==this)
 972                                         break;
 973                         if (iter == get_open_canvas_map().end())
 974                                 CanvasParser::register_canvas_in_map(this, file_name);
 975                         else
 976                                 signal_file_name_changed_();
 977                 }
 978         }
 979 }
 980
 981 sigc::signal<void>&
 982 Canvas::signal_file_name_changed()
 983 {
 984         if(parent())
 985                 return parent()->signal_file_name_changed();
 986         else
 987                 return signal_file_name_changed_;
 988 }
 989
 990 String
 991 Canvas::get_file_name()const
 992 {
 993         if(parent())
 994                 return parent()->get_file_name();
 995         return file_name_;
 996 }
 997
 998 String
 999 Canvas::get_file_path()const
1000 {
1001         if(parent())
1002                 return parent()->get_file_path();
1003         return dirname(file_name_);
1004 }
1005
1006 String
1007 Canvas::get_meta_data(const String& key)const
1008 {
1009         if(!meta_data_.count(key))
1010                 return String();
1011         return meta_data_.find(key)->second;
1012 }
1013
1014 void
1015 Canvas::set_meta_data(const String& key, const String& data)
1016 {
1017         if(meta_data_[key]!=data)
1018         {
1019                 meta_data_[key]=data;
1020                 signal_meta_data_changed()(key);
1021                 signal_meta_data_changed(key)();
1022         }
1023 }
1024
1025 void
1026 Canvas::erase_meta_data(const String& key)
1027 {
1028         if(meta_data_.count(key))
1029         {
1030                 meta_data_.erase(key);
1031                 signal_meta_data_changed()(key);
1032                 signal_meta_data_changed(key)();
1033         }
1034 }
1035
1036 std::list<String>
1037 Canvas::get_meta_data_keys()const
1038 {
1039         std::list<String> ret;
1040
1041         std::map<String,String>::const_iterator iter;
1042
1043         for(iter=meta_data_.begin();!(iter==meta_data_.end());++iter)
1044                 ret.push_back(iter->first);
1045
1046         return ret;
1047 }
1048
1049 /* note - the "Motion Blur" and "Duplicate" layers need the dynamic
1050                   parameters of any PasteCanvas layers they loop over to be
1051                   maintained.  When the variables in the following function
1052                   refer to "motion blur", they mean either of these two
1053                   layers. */
1054 void
1055 synfig::optimize_layers(Time time, Context context, Canvas::Handle op_canvas, bool seen_motion_blur_in_parent)
1056 {
1057         Context iter;
1058
1059         std::vector< std::pair<float,Layer::Handle> > sort_list;
1060         int i, motion_blur_i=0; // motion_blur_i is for resolving which layer comes first in the event of a z_depth tie
1061         float motion_blur_z_depth=0; // the z_depth of the least deep motion blur layer in this context
1062         bool seen_motion_blur_locally = false;
1063         bool motion_blurred; // the final result - is this layer blurred or not?
1064
1065         // If the parent didn't cause us to already be motion blurred,
1066         // check whether there's a motion blur in this context,
1067         // and if so, calculate its z_depth.
1068         if (!seen_motion_blur_in_parent)
1069                 for(iter=context,i=0;*iter;iter++,i++)
1070                 {
1071                         Layer::Handle layer=*iter;
1072
1073                         // If the layer isn't active, don't worry about it
1074                         if(!layer->active())
1075                                 continue;
1076
1077                         // Any layer with an amount of zero is implicitly disabled.
1078                         ValueBase value(layer->get_param("amount"));
1079                         if(value.get_type()==ValueBase::TYPE_REAL && value.get(Real())==0)
1080                                 continue;
1081
1082                         if(layer->get_name()=="MotionBlur" || layer->get_name()=="duplicate")
1083                         {
1084                                 float z_depth(layer->get_z_depth()*1.0001+i);
1085
1086                                 // If we've seen a motion blur before in this context...
1087                                 if (seen_motion_blur_locally)
1088                                 {
1089                                         // ... then we're only interested in this one if it's less deep...
1090                                         if (z_depth < motion_blur_z_depth)
1091                                         {
1092                                                 motion_blur_z_depth = z_depth;
1093                                                 motion_blur_i = i;
1094                                         }
1095                                 }
1096                                 // ... otherwise we're always interested in it.
1097                                 else
1098                                 {
1099                                         motion_blur_z_depth = z_depth;
1100                                         motion_blur_i = i;
1101                                         seen_motion_blur_locally = true;
1102                                 }
1103                         }
1104                 }
1105
1106         // Go ahead and start romping through the canvas to paste
1107         for(iter=context,i=0;*iter;iter++,i++)
1108         {
1109                 Layer::Handle layer=*iter;
1110                 float z_depth(layer->get_z_depth()*1.0001+i);
1111
1112                 // If the layer isn't active, don't worry about it
1113                 if(!layer->active())
1114                         continue;
1115
1116                 // Any layer with an amount of zero is implicitly disabled.
1117                 ValueBase value(layer->get_param("amount"));
1118                 if(value.get_type()==ValueBase::TYPE_REAL && value.get(Real())==0)
1119                         continue;
1120
1121                 // note: this used to include "&& paste_canvas->get_time_offset()==0", but then
1122                 //               time-shifted layers weren't being sorted by z-depth (bug #1806852)
1123                 if(layer->get_name()=="PasteCanvas")
1124                 {
1125                         Layer_PasteCanvas* paste_canvas(static_cast<Layer_PasteCanvas*>(layer.get()));
1126
1127                         // we need to blur the sub canvas if:
1128                         // our parent is blurred,
1129                         // or the child is lower than a local blur,
1130                         // or the child is at the same z_depth as a local blur, but later in the context
1131
1132 #if 0 // DEBUG
1133                         if (seen_motion_blur_in_parent)                                 synfig::info("seen BLUR in parent\n");
1134                         else if (seen_motion_blur_locally)
1135                                 if (z_depth > motion_blur_z_depth)                      synfig::info("paste is deeper than BLUR\n");
1136                                 else if (z_depth == motion_blur_z_depth) {      synfig::info("paste is same depth as BLUR\n");
1137                                         if (i > motion_blur_i)                                  synfig::info("paste is physically deeper than BLUR\n");
1138                                         else                                                                    synfig::info("paste is less physically deep than BLUR\n");
1139                                 } else                                                                          synfig::info("paste is less deep than BLUR\n");
1140                         else                                                                                    synfig::info("no BLUR at all\n");
1141 #endif  // DEBUG
1142
1143                         motion_blurred = (seen_motion_blur_in_parent ||
1144                                                           (seen_motion_blur_locally &&
1145                                                            (z_depth > motion_blur_z_depth ||
1146                                                                 (z_depth == motion_blur_z_depth && i > motion_blur_i))));
1147
1148                         Canvas::Handle sub_canvas(Canvas::create_inline(op_canvas));
1149                         Canvas::Handle paste_sub_canvas = paste_canvas->get_sub_canvas();
1150                         if(paste_sub_canvas)
1151                                 optimize_layers(time, paste_sub_canvas->get_context(),sub_canvas,motion_blurred);
1152
1153 // \todo: uncommenting the following breaks the rendering of at least examples/backdrop.sifz quite severely
1154 // #define SYNFIG_OPTIMIZE_PASTE_CANVAS
1155 #ifdef SYNFIG_OPTIMIZE_PASTE_CANVAS
1156                         Canvas::iterator sub_iter;
1157
1158                         // Determine if we can just remove the paste canvas altogether
1159                         if (paste_canvas->get_blend_method()    == Color::BLEND_COMPOSITE       &&
1160                                 paste_canvas->get_amount()                      == 1.0f                                         &&
1161                                 paste_canvas->get_zoom()                        == 0                                            &&
1162                                 paste_canvas->get_time_offset()         == 0                                            &&
1163                                 paste_canvas->get_origin()                      == Point(0,0)                           )
1164                                 try {
1165                                         for(sub_iter=sub_canvas->begin();sub_iter!=sub_canvas->end();++sub_iter)
1166                                         {
1167                                                 Layer* layer=sub_iter->get();
1168
1169                                                 // any layers that deform end up breaking things
1170                                                 // so do things the old way if we run into anything like this
1171                                                 if(!dynamic_cast<Layer_NoDeform*>(layer))
1172                                                         throw int();
1173
1174                                                 ValueBase value(layer->get_param("blend_method"));
1175                                                 if(value.get_type()!=ValueBase::TYPE_INTEGER || value.get(int())!=(int)Color::BLEND_COMPOSITE)
1176                                                         throw int();
1177                                         }
1178
1179                                         // It has turned out that we don't need a paste canvas
1180                                         // layer, so just go ahead and add all the layers onto
1181                                         // the current stack and be done with it
1182                                         while(sub_canvas->size())
1183                                         {
1184                                                 sort_list.push_back(std::pair<float,Layer::Handle>(z_depth,sub_canvas->front()));
1185                                                 //op_canvas->push_back_simple(sub_canvas->front());
1186                                                 sub_canvas->pop_front();
1187                                         }
1188                                         continue;
1189                                 }
1190                                 catch(int)
1191                                 { }
1192 #endif  // SYNFIG_OPTIMIZE_PASTE_CANVAS
1193
1194                         Layer::Handle new_layer(Layer::create("PasteCanvas"));
1195                         dynamic_cast<Layer_PasteCanvas*>(new_layer.get())->set_muck_with_time(false);
1196                         if (motion_blurred)
1197                         {
1198                                 Layer::DynamicParamList dynamic_param_list(paste_canvas->dynamic_param_list());
1199                                 for(Layer::DynamicParamList::const_iterator iter(dynamic_param_list.begin()); iter != dynamic_param_list.end(); ++iter)
1200                                         new_layer->connect_dynamic_param(iter->first, iter->second);
1201                         }
1202                         Layer::ParamList param_list(paste_canvas->get_param_list());
1203                         //param_list.erase("canvas");
1204                         new_layer->set_param_list(param_list);
1205                         dynamic_cast<Layer_PasteCanvas*>(new_layer.get())->set_sub_canvas(sub_canvas);
1206                         dynamic_cast<Layer_PasteCanvas*>(new_layer.get())->set_muck_with_time(true);
1207                         layer=new_layer;
1208                 }
1209                 else                                    // not a PasteCanvas - does it use blend method 'Straight'?
1210                 {
1211                         /* when we use the 'straight' blend method, every pixel on the layer affects the layers underneath,
1212                          * not just the non-transparent pixels; the following workarea wraps non-pastecanvas layers in a
1213                          * new pastecanvas to ensure that the straight blend affects the full plane, not just the area
1214                          * within the layer's bounding box
1215                          */
1216
1217                         // \todo: this code probably needs modification to work properly with motionblur and duplicate
1218                         etl::handle<Layer_Composite> composite = etl::handle<Layer_Composite>::cast_dynamic(layer);
1219
1220                         /* some layers (such as circle) don't touch pixels that aren't
1221                          * part of the circle, so they don't get blended correctly when
1222                          * using a straight blend.  so we encapsulate the circle, and the
1223                          * encapsulation layer takes care of the transparent pixels
1224                          * for us.  if we do that for all layers, however, then the
1225                          * distortion layers no longer work, since they have no
1226                          * context to work on.  the Layer::reads_context() method
1227                          * returns true for layers which need to be able to see
1228                          * their context.  we can't encapsulate those.
1229                          */
1230                         if (composite &&
1231                                 Color::is_straight(composite->get_blend_method()) &&
1232                                 !composite->reads_context())
1233                         {
1234                                 Canvas::Handle sub_canvas(Canvas::create_inline(op_canvas));
1235                                 // don't use clone() because it re-randomizes the seeds of any random valuenodes
1236                                 sub_canvas->push_back(composite = composite->simple_clone());
1237                                 layer = Layer::create("PasteCanvas");
1238                                 composite->set_description(strprintf("Wrapped clone of '%s'", composite->get_non_empty_description().c_str()));
1239                                 layer->set_description(strprintf("PasteCanvas wrapper for '%s'", composite->get_non_empty_description().c_str()));
1240                                 Layer_PasteCanvas* paste_canvas(static_cast<Layer_PasteCanvas*>(layer.get()));
1241                                 paste_canvas->set_blend_method(composite->get_blend_method());
1242                                 paste_canvas->set_amount(composite->get_amount());
1243                                 sub_canvas->set_time(time); // region and outline don't calculate their bounding rects until their time is set
1244                                 composite->set_blend_method(Color::BLEND_STRAIGHT); // do this before calling set_sub_canvas(), but after set_time()
1245                                 composite->set_amount(1.0f); // after set_time()
1246                                 paste_canvas->set_sub_canvas(sub_canvas);
1247                         }
1248                 }
1249
1250                 sort_list.push_back(std::pair<float,Layer::Handle>(z_depth,layer));
1251                 //op_canvas->push_back_simple(layer);
1252         }
1253
1254         //sort_list.sort();
1255         stable_sort(sort_list.begin(),sort_list.end());
1256         std::vector< std::pair<float,Layer::Handle> >::iterator iter2;
1257         for(iter2=sort_list.begin();iter2!=sort_list.end();++iter2)
1258                 op_canvas->push_back_simple(iter2->second);
1259         op_canvas->op_flag_=true;
1260 }
1261
1262 void
1263 Canvas::get_times_vfunc(Node::time_set &set) const
1264 {
1265         const_iterator  i = begin(),
1266                                 iend = end();
1267
1268         for(; i != iend; ++i)
1269         {
1270                 const Node::time_set &tset = (*i)->get_times();
1271                 set.insert(tset.begin(),tset.end());
1272         }
1273 }
1274
1275 std::set<etl::handle<Layer> >
1276 Canvas::get_layers_in_group(const String&group)
1277 {
1278         if(is_inline() && parent_)
1279                 return parent_->get_layers_in_group(group);
1280
1281         if(group_db_.count(group)==0)
1282                 return std::set<etl::handle<Layer> >();
1283         return group_db_.find(group)->second;
1284 }
1285
1286 std::set<String>
1287 Canvas::get_groups()const
1288 {
1289         if(is_inline() && parent_)
1290                 return parent_->get_groups();
1291
1292         std::set<String> ret;
1293         std::map<String,std::set<etl::handle<Layer> > >::const_iterator iter;
1294         for(iter=group_db_.begin();iter!=group_db_.end();++iter)
1295                 ret.insert(iter->first);
1296         return ret;
1297 }
1298
1299 int
1300 Canvas::get_group_count()const
1301 {
1302         if(is_inline() && parent_)
1303                 return parent_->get_group_count();
1304
1305         return group_db_.size();
1306 }
1307
1308 void
1309 Canvas::add_group_pair(String group, etl::handle<Layer> layer)
1310 {
1311         group_db_[group].insert(layer);
1312         if(group_db_[group].size()==1)
1313                 signal_group_added()(group);
1314         else
1315                 signal_group_changed()(group);
1316
1317         signal_group_pair_added()(group,layer);
1318
1319         if(is_inline()  && parent_)
1320                 return parent_->add_group_pair(group,layer);
1321 }
1322
1323 void
1324 Canvas::remove_group_pair(String group, etl::handle<Layer> layer)
1325 {
1326         group_db_[group].erase(layer);
1327
1328         signal_group_pair_removed()(group,layer);
1329
1330         if(group_db_[group].empty())
1331         {
1332                 group_db_.erase(group);
1333                 signal_group_removed()(group);
1334         }
1335         else
1336                 signal_group_changed()(group);
1337
1338         if(is_inline() && parent_)
1339                 return parent_->remove_group_pair(group,layer);
1340 }
1341
1342 void
1343 Canvas::add_connection(etl::loose_handle<Layer> layer, sigc::connection connection)
1344 {
1345         connections_[layer].push_back(connection);
1346 }
1347
1348 void
1349 Canvas::disconnect_connections(etl::loose_handle<Layer> layer)
1350 {
1351         std::vector<sigc::connection>::iterator iter;
1352         for(iter=connections_[layer].begin();iter!=connections_[layer].end();++iter)
1353                 iter->disconnect();
1354         connections_[layer].clear();
1355 }
1356
1357 void
1358 Canvas::rename_group(const String&old_name,const String&new_name)
1359 {
1360         if(is_inline() && parent_)
1361                 return parent_->rename_group(old_name,new_name);
1362
1363         {
1364                 std::map<String,std::set<etl::handle<Layer> > >::iterator iter;
1365                 iter=group_db_.find(old_name);
1366                 if(iter!=group_db_.end())
1367                 for(++iter;iter!=group_db_.end() && iter->first.find(old_name)==0;iter=group_db_.find(old_name),++iter)
1368                 {
1369                         String name(iter->first,old_name.size(),String::npos);
1370                         name=new_name+name;
1371                         rename_group(iter->first,name);
1372                 }
1373         }
1374
1375         std::set<etl::handle<Layer> > layers(get_layers_in_group(old_name));
1376         std::set<etl::handle<Layer> >::iterator iter;
1377
1378         for(iter=layers.begin();iter!=layers.end();++iter)
1379         {
1380                 (*iter)->remove_from_group(old_name);
1381                 (*iter)->add_to_group(new_name);
1382         }
1383 }
1384
1385 void
1386 Canvas::register_external_canvas(String file_name, Handle canvas)
1387 {
1388         if(!is_absolute_path(file_name)) file_name = get_file_path()+ETL_DIRECTORY_SEPARATOR+file_name;
1389         externals_[file_name] = canvas;
1390 }
1391
1392 #ifdef _DEBUG
1393 void
1394 Canvas::show_externals(String file, int line, String text) const
1395 {
1396         printf("  .----- (externals for %lx '%s')\n  |  %s:%d %s\n", ulong(this), get_name().c_str(), file.c_str(), line, text.c_str());
1397         std::map<String, Handle>::iterator iter;
1398         for (iter = externals_.begin(); iter != externals_.end(); iter++)
1399         {
1400                 synfig::String first(iter->first);
1401                 etl::loose_handle<Canvas> second(iter->second);
1402                 printf("  |    %40s : %lx (%d)\n", first.c_str(), ulong(&*second), second->count());
1403         }
1404         printf("  `-----\n\n");
1405 }
1406 #endif  // _DEBUG