X-Git-Url: https://git.pterodactylus.net/?a=blobdiff_plain;f=synfig-studio%2Fsrc%2Fsynfigapp%2Factions%2Flayerduplicate.cpp;fp=synfig-studio%2Fsrc%2Fsynfigapp%2Factions%2Flayerduplicate.cpp;h=c3e21df130cb57ae7ea8a5f858d0ca055708e03f;hb=a095981e18cc37a8ecc7cd237cc22b9c10329264;hp=0000000000000000000000000000000000000000;hpb=9459638ad6797b8139f1e9f0715c96076dbf0890;p=synfig.git diff --git a/synfig-studio/src/synfigapp/actions/layerduplicate.cpp b/synfig-studio/src/synfigapp/actions/layerduplicate.cpp new file mode 100644 index 0000000..c3e21df --- /dev/null +++ b/synfig-studio/src/synfigapp/actions/layerduplicate.cpp @@ -0,0 +1,222 @@ +/* === S Y N F I G ========================================================= */ +/*! \file layerduplicate.cpp +** \brief Template File +** +** $Id$ +** +** \legal +** Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley +** Copyright (c) 2008 Chris Moore +** +** This package is free software; you can redistribute it and/or +** modify it under the terms of the GNU General Public License as +** published by the Free Software Foundation; either version 2 of +** the License, or (at your option) any later version. +** +** This package is distributed in the hope that it will be useful, +** but WITHOUT ANY WARRANTY; without even the implied warranty of +** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +** General Public License for more details. +** \endlegal +*/ +/* ========================================================================= */ + +/* === H E A D E R S ======================================================= */ + +#ifdef USING_PCH +# include "pch.h" +#else +#ifdef HAVE_CONFIG_H +# include +#endif + +#include "layerduplicate.h" +#include "layeradd.h" +#include +#include + +#include + +#endif + +using namespace std; +using namespace etl; +using namespace synfig; +using namespace synfigapp; +using namespace Action; + +/* === M A C R O S ========================================================= */ + +ACTION_INIT_NO_GET_LOCAL_NAME(Action::LayerDuplicate); +ACTION_SET_NAME(Action::LayerDuplicate,"LayerDuplicate"); +ACTION_SET_LOCAL_NAME(Action::LayerDuplicate,N_("Duplicate Layer")); +ACTION_SET_TASK(Action::LayerDuplicate,"duplicate"); +ACTION_SET_CATEGORY(Action::LayerDuplicate,Action::CATEGORY_LAYER); +ACTION_SET_PRIORITY(Action::LayerDuplicate,0); +ACTION_SET_VERSION(Action::LayerDuplicate,"0.0"); +ACTION_SET_CVS_ID(Action::LayerDuplicate,"$Id$"); + +/* === G L O B A L S ======================================================= */ + +/* === P R O C E D U R E S ================================================= */ + +/* === M E T H O D S ======================================================= */ + +Action::LayerDuplicate::LayerDuplicate() +{ +} + +synfig::String +Action::LayerDuplicate::get_local_name()const +{ + return get_layer_descriptions(layers, _("Duplicate Layer"), _("Duplicate Layers")); +} + +Action::ParamVocab +Action::LayerDuplicate::get_param_vocab() +{ + ParamVocab ret(Action::CanvasSpecific::get_param_vocab()); + + ret.push_back(ParamDesc("layer",Param::TYPE_LAYER) + .set_local_name(_("Layer")) + .set_desc(_("Layer to be duplicated")) + .set_supports_multiple() + ); + + return ret; +} + +bool +Action::LayerDuplicate::is_candidate(const ParamList &x) +{ + return candidate_check(get_param_vocab(),x); +} + +bool +Action::LayerDuplicate::set_param(const synfig::String& name, const Action::Param ¶m) +{ + if(name=="layer" && param.get_type()==Param::TYPE_LAYER) + { + layers.push_back(param.get_layer()); + + return true; + } + + return Action::CanvasSpecific::set_param(name,param); +} + +bool +Action::LayerDuplicate::is_ready()const +{ + if(layers.empty()) + return false; + return Action::CanvasSpecific::is_ready(); +} + +void +Action::LayerDuplicate::prepare() +{ + if(!first_time()) + return; + + std::list::const_iterator iter; + + for(iter=layers.begin();iter!=layers.end();++iter) + { + Layer::Handle layer(*iter); + + Canvas::Handle subcanvas(layer->get_canvas()); + + // Find the iterator for the layer + Canvas::iterator iter=find(subcanvas->begin(),subcanvas->end(),layer); + + // If we couldn't find the layer in the canvas, then bail + if(*iter!=layer) + throw Error(_("This layer doesn't exist anymore.")); + + // If the subcanvas isn't the same as the canvas, + // then it had better be an inline canvas. If not, + // bail + if(get_canvas()!=subcanvas && !subcanvas->is_inline()) + throw Error(_("This layer doesn't belong to this canvas anymore")); + + Layer::Handle new_layer(layer->clone(guid)); + + { + Action::Handle action(Action::create("LayerMove")); + + action->set_param("canvas",subcanvas); + action->set_param("canvas_interface",get_canvas_interface()); + action->set_param("layer",new_layer); + action->set_param("new_index",layers.front()->get_depth()); + + add_action_front(action); + } + { + Action::Handle action(Action::create("LayerAdd")); + + action->set_param("canvas",subcanvas); + action->set_param("canvas_interface",get_canvas_interface()); + action->set_param("new",new_layer); + + add_action_front(action); + } + + // automatically export the Index parameter of Duplicate layers when duplicating + int index = 1; + export_dup_nodes(new_layer, subcanvas, index); + } +} + +void +Action::LayerDuplicate::export_dup_nodes(synfig::Layer::Handle layer, Canvas::Handle canvas, int &index) +{ + // automatically export the Index parameter of Duplicate layers when duplicating + if (layer->get_name() == "duplicate") + while (true) + { + String name = strprintf(_("Index %d"), index++); + try + { + canvas->find_value_node(name); + } + catch (Exception::IDNotFound x) + { + Action::Handle action(Action::create("ValueNodeAdd")); + + action->set_param("canvas",canvas); + action->set_param("canvas_interface",get_canvas_interface()); + action->set_param("new",layer->dynamic_param_list().find("index")->second); + action->set_param("name",name); + + add_action_front(action); + + break; + } + } + else + { + Layer::ParamList param_list(layer->get_param_list()); + for (Layer::ParamList::const_iterator iter(param_list.begin()) + ; iter != param_list.end() + ; iter++) + if (layer->dynamic_param_list().count(iter->first)==0 && iter->second.get_type()==ValueBase::TYPE_CANVAS) + { + Canvas::Handle subcanvas(iter->second.get(Canvas::Handle())); + if (subcanvas && subcanvas->is_inline()) + for (Context iter = subcanvas->get_context(); iter != subcanvas->end(); iter++) + export_dup_nodes(*iter, canvas, index); + } + + for (Layer::DynamicParamList::const_iterator iter(layer->dynamic_param_list().begin()) + ; iter != layer->dynamic_param_list().end() + ; iter++) + if (iter->second->get_type()==ValueBase::TYPE_CANVAS) + { + Canvas::Handle canvas((*iter->second)(0).get(Canvas::Handle())); + if (canvas->is_inline()) + //! \todo do we need to implement this? and if so, shouldn't we check all canvases, not just the one at t=0s? + warning("%s:%d not yet implemented - do we need to export duplicate valuenodes in dynamic canvas parameters?", __FILE__, __LINE__); + } + } +}