synfig-studio/trunk/src/gtkmm/layeractionmanager.cpp

   1 /* === S Y N F I G ========================================================= */
   2 /*!     \file layeractionmanager.cpp
   3 **      \brief Template File
   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 "layeractionmanager.h"
  34 #include "layertree.h"
  35 #include <synfig/context.h>
  36 #include <synfigapp/action_param.h>
  37 #include "instance.h"
  38 #include <synfigapp/selectionmanager.h>
  39
  40 #include "general.h"
  41
  42 #endif
  43
  44 /* === U S I N G =========================================================== */
  45
  46 using namespace std;
  47 using namespace etl;
  48 using namespace synfig;
  49 using namespace studio;
  50
  51 static const guint no_prev_popup((guint)-1);
  52
  53 /* === M A C R O S ========================================================= */
  54
  55 //#define ONE_ACTION_GROUP 1
  56
  57 /* === G L O B A L S ======================================================= */
  58
  59 /* === P R O C E D U R E S ================================================= */
  60
  61 /* === M E T H O D S ======================================================= */
  62
  63 LayerActionManager::LayerActionManager():
  64         action_group_(Gtk::ActionGroup::create()),
  65         popup_id_(no_prev_popup),
  66         action_group_copy_paste(Gtk::ActionGroup::create()),
  67         queued(false)
  68 {
  69         action_cut_=Gtk::Action::create(
  70                 "cut",
  71                 Gtk::StockID("gtk-cut")
  72         );
  73         action_cut_->signal_activate().connect(
  74                 sigc::mem_fun(
  75                         *this,
  76                         &LayerActionManager::cut
  77                 )
  78         );
  79         action_copy_=Gtk::Action::create(
  80                 "copy",
  81                 Gtk::StockID("gtk-copy")
  82         );
  83         action_copy_->signal_activate().connect(
  84                 sigc::mem_fun(
  85                         *this,
  86                         &LayerActionManager::copy
  87                 )
  88         );
  89         action_paste_=Gtk::Action::create(
  90                 "paste",
  91                 Gtk::StockID("gtk-paste")
  92         );
  93         action_paste_->signal_activate().connect(
  94                 sigc::mem_fun(
  95                         *this,
  96                         &LayerActionManager::paste
  97                 )
  98         );
  99
 100
 101         action_amount_inc_=Gtk::Action::create(
 102                 "amount-inc",
 103                 Gtk::StockID("gtk-add"),
 104                 _("Increase Amount"),_("Increase Amount")
 105         );
 106         action_amount_inc_->signal_activate().connect(
 107                 sigc::mem_fun(
 108                         *this,
 109                         &LayerActionManager::amount_inc
 110                 )
 111         );
 112
 113         action_amount_dec_=Gtk::Action::create(
 114                 "amount-dec",
 115                 Gtk::StockID("gtk-remove"),
 116                 _("Decrease Amount"),_("Decrease Amount")
 117         );
 118         action_amount_dec_->signal_activate().connect(
 119                 sigc::mem_fun(
 120                         *this,
 121                         &LayerActionManager::amount_dec
 122                 )
 123         );
 124
 125         action_amount_=Gtk::Action::create(
 126                 "amount",
 127                 Gtk::StockID("gtk-index"),
 128                 _("Amount"),_("Amount")
 129         );
 130
 131
 132 }
 133
 134 LayerActionManager::~LayerActionManager()
 135 {
 136 }
 137
 138 void
 139 LayerActionManager::set_ui_manager(const Glib::RefPtr<Gtk::UIManager> &x)
 140 {
 141         clear();
 142
 143 #ifdef ONE_ACTION_GROUP
 144         if(ui_manager_) get_ui_manager()->remove_action_group(action_group_);
 145         ui_manager_=x;
 146         if(ui_manager_) get_ui_manager()->insert_action_group(action_group_);
 147 #else
 148         ui_manager_=x;
 149 #endif
 150 }
 151
 152 void
 153 LayerActionManager::set_layer_tree(LayerTree* x)
 154 {
 155         selection_changed_connection.disconnect();
 156         layer_tree_=x;
 157         if(layer_tree_)
 158         {
 159                 selection_changed_connection=layer_tree_->get_selection()->signal_changed().connect(
 160                         sigc::mem_fun(*this,&LayerActionManager::queue_refresh)
 161                 );
 162         }
 163 }
 164
 165 void
 166 LayerActionManager::set_canvas_interface(const etl::handle<synfigapp::CanvasInterface> &x)
 167 {
 168         canvas_interface_=x;
 169 }
 170
 171 void
 172 LayerActionManager::clear()
 173 {
 174         if(ui_manager_)
 175         {
 176                 // Clear out old stuff
 177                 if(popup_id_!=no_prev_popup)
 178                 {
 179                         get_ui_manager()->remove_ui(popup_id_);
 180                         if(action_group_)get_ui_manager()->ensure_update();
 181                         popup_id_=no_prev_popup;
 182                         if(action_group_)while(!action_group_->get_actions().empty())action_group_->remove(*action_group_->get_actions().begin());
 183 #ifdef ONE_ACTION_GROUP
 184 #else
 185                         if(action_group_)get_ui_manager()->remove_action_group(action_group_);
 186                         action_group_=Gtk::ActionGroup::create();
 187 #endif
 188                 }
 189         }
 190
 191         while(!update_connection_list.empty())
 192         {
 193                 update_connection_list.front().disconnect();
 194                 update_connection_list.pop_front();
 195         }
 196 }
 197
 198 void
 199 LayerActionManager::queue_refresh()
 200 {
 201         if(queued)
 202                 return;
 203
 204         //queue_refresh_connection.disconnect();
 205         queue_refresh_connection=Glib::signal_idle().connect(
 206                 sigc::bind_return(
 207                         sigc::mem_fun(*this,&LayerActionManager::refresh),
 208                         false
 209                 )
 210         );
 211
 212         queued=true;
 213 }
 214
 215 void
 216 LayerActionManager::refresh()
 217 {
 218         if(queued)
 219         {
 220                 queued=false;
 221                 //queue_refresh_connection.disconnect();
 222         }
 223
 224
 225         clear();
 226
 227         // Make sure we are ready
 228         if(!ui_manager_ || !layer_tree_ || !canvas_interface_)
 229         {
 230                 synfig::error("LayerActionManager::refresh(): Not ready!");
 231                 return;
 232         }
 233
 234
 235         String ui_info, ui_toolbar_info;
 236
 237         action_paste_->set_sensitive(!clipboard_.empty());
 238         action_group_->add(action_paste_);
 239
 240         if(layer_tree_->get_selection()->count_selected_rows()!=0)
 241         {
 242                 bool multiple_selected(layer_tree_->get_selection()->count_selected_rows()>1);
 243                 Layer::Handle layer(layer_tree_->get_selected_layer());
 244
 245                 {
 246                         bool canvas_set(false);
 247                         synfigapp::Action::ParamList param_list;
 248                         param_list.add("time",get_canvas_interface()->get_time());
 249                         param_list.add("canvas_interface",get_canvas_interface());
 250                         {
 251                                 synfigapp::SelectionManager::LayerList layer_list(layer_tree_->get_selected_layers());
 252                                 synfigapp::SelectionManager::LayerList::iterator iter;
 253                                 action_copy_->set_sensitive(!layer_list.empty());
 254                                 action_cut_->set_sensitive(!layer_list.empty());
 255                                 action_group_->add(action_copy_);
 256                                 action_group_->add(action_cut_);
 257
 258                                 action_amount_inc_->set_sensitive(!layer_list.empty());
 259                                 action_amount_dec_->set_sensitive(!layer_list.empty());
 260                                 action_amount_->set_sensitive(!layer_list.empty());
 261                                 action_group_->add(action_amount_inc_);
 262                                 action_group_->add(action_amount_dec_);
 263                                 action_group_->add(action_amount_);
 264
 265                                 for(iter=layer_list.begin();iter!=layer_list.end();++iter)
 266                                 {
 267                                         update_connection_list.push_back(
 268                                                 (*iter)->signal_changed().connect(
 269                                                         sigc::mem_fun(*this, &LayerActionManager::queue_refresh)
 270                                                 )
 271                                         );
 272
 273                                         if(!canvas_set)
 274                                         {
 275                                                 param_list.add("canvas",Canvas::Handle((*iter)->get_canvas()));
 276                                                 canvas_set=true;
 277                                                 update_connection_list.push_back(
 278                                                         (*iter)->get_canvas()->signal_changed().connect(
 279                                                                 sigc::mem_fun(*this, &LayerActionManager::queue_refresh)
 280                                                         )
 281                                                 );
 282                                         }
 283                                         param_list.add("layer",Layer::Handle(*iter));
 284                                 }
 285                         }
 286
 287                         if(!multiple_selected && layer->get_name()=="PasteCanvas")
 288                         {
 289                                 action_group_->add(Gtk::Action::create(
 290                                         "select-all-child-layers",
 291                                         Gtk::StockID("synfig-select_all_child_layers"),
 292                                         _("Select All Child Layers"),
 293                                         _("Select All Child Layers")),
 294                                         sigc::bind(sigc::mem_fun(*layer_tree_,
 295                                                                                          &studio::LayerTree::select_all_children_layers),
 296                                                            Layer::LooseHandle(layer)));
 297                                 ui_info+="<menuitem action='select-all-child-layers'/>";
 298                                 ui_toolbar_info+="<toolbar action='toolbar-layer'><toolitem action='select-all-child-layers'/></toolbar>";
 299                         }
 300                         handle<studio::Instance>::cast_static(get_canvas_interface()->get_instance())->
 301                                 add_actions_to_group(action_group_, ui_info,   param_list, synfigapp::Action::CATEGORY_LAYER);
 302                 }
 303         }
 304
 305         ui_info=("<ui>"
 306                            "<popup action='menu-main'>"
 307                              "<menu action='menu-layer'>" +
 308                                    ui_info +
 309                                    "<separator/>"
 310                                "<menuitem action='cut' />"
 311                                    "<menuitem action='copy' />"
 312                                    "<menuitem action='paste' />"
 313                                    "<separator/>"
 314                              "</menu>"
 315                            "</popup>" +
 316                          ui_toolbar_info +
 317                          "</ui>");
 318         popup_id_=get_ui_manager()->add_ui_from_string(ui_info);
 319 #ifdef ONE_ACTION_GROUP
 320 #else
 321         get_ui_manager()->insert_action_group(action_group_);
 322 #endif
 323 }
 324
 325 void
 326 LayerActionManager::cut()
 327 {
 328         copy();
 329         if(action_group_->get_action("action-layer_remove"))
 330                 action_group_->get_action("action-layer_remove")->activate();
 331 }
 332
 333 void
 334 LayerActionManager::copy()
 335 {
 336         synfigapp::SelectionManager::LayerList layer_list(layer_tree_->get_selected_layers());
 337         clipboard_.clear();
 338         synfig::GUID guid;
 339
 340         while(!layer_list.empty())
 341         {
 342                 clipboard_.push_back(layer_list.front()->clone(guid));
 343                 layer_list.pop_front();
 344         }
 345
 346         action_paste_->set_sensitive(!clipboard_.empty());
 347
 348         //queue_refresh();
 349 }
 350
 351 void
 352 LayerActionManager::paste()
 353 {
 354         synfig::GUID guid;
 355
 356         // Create the action group
 357         synfigapp::Action::PassiveGrouper group(get_canvas_interface()->get_instance().get(),_("Paste"));
 358
 359         Canvas::Handle canvas(get_canvas_interface()->get_canvas());
 360         int depth(0);
 361
 362         // we are temporarily using the layer to hold something
 363         Layer::Handle layer(layer_tree_->get_selected_layer());
 364         if(layer)
 365         {
 366                 depth=layer->get_depth();
 367                 canvas=layer->get_canvas();
 368         }
 369
 370         synfigapp::SelectionManager::LayerList layer_selection;
 371
 372         for(std::list<synfig::Layer::Handle>::iterator iter=clipboard_.begin();iter!=clipboard_.end();++iter)
 373         {
 374                 layer=(*iter)->clone(guid);
 375                 layer_selection.push_back(layer);
 376                 synfigapp::Action::Handle       action(synfigapp::Action::create("layer_add"));
 377
 378                 assert(action);
 379                 if(!action)
 380                         return;
 381
 382                 action->set_param("canvas",canvas);
 383                 action->set_param("canvas_interface",etl::loose_handle<synfigapp::CanvasInterface>(get_canvas_interface()));
 384                 action->set_param("new",layer);
 385
 386                 if(!action->is_ready())
 387                 {
 388                         return;
 389                 }
 390
 391                 if(!get_instance()->perform_action(action))
 392                 {
 393                         return;
 394                 }
 395
 396                 // synfig::info("DEPTH=%d",depth);
 397
 398                 // Action to move the layer (if necessary)
 399                 if(depth>0)
 400                 {
 401                         synfigapp::Action::Handle       action(synfigapp::Action::create("layer_move"));
 402
 403                         assert(action);
 404                         if(!action)
 405                                 return;
 406
 407                         action->set_param("canvas",canvas);
 408                         action->set_param("canvas_interface",etl::loose_handle<synfigapp::CanvasInterface>(get_canvas_interface()));
 409                         action->set_param("layer",layer);
 410                         action->set_param("new_index",depth);
 411
 412                         if(!action->is_ready())
 413                         {
 414                                 //get_ui_interface()->error(_("Move Action Not Ready"));
 415                                 //return 0;
 416                                 return;
 417                         }
 418
 419                         if(!get_instance()->perform_action(action))
 420                         {
 421                                 //get_ui_interface()->error(_("Move Action Not Ready"));
 422                                 //return 0;
 423                                 return;
 424                         }
 425                 }
 426                 depth++;
 427
 428                 // automatically export the Index parameter of Duplicate layers when pasting
 429                 int index = 1;
 430                 export_dup_nodes(layer, canvas, index);
 431         }
 432         get_canvas_interface()->get_selection_manager()->clear_selected_layers();
 433         get_canvas_interface()->get_selection_manager()->set_selected_layers(layer_selection);
 434 }
 435
 436 void
 437 LayerActionManager::export_dup_nodes(synfig::Layer::Handle layer, Canvas::Handle canvas, int &index)
 438 {
 439         // automatically export the Index parameter of Duplicate layers when pasting
 440         if (layer->get_name() == "duplicate")
 441                 while (true)
 442                 {
 443                         String name = strprintf(_("Index %d"), index++);
 444                         try
 445                         {
 446                                 canvas->find_value_node(name);
 447                         }
 448                         catch (Exception::IDNotFound x)
 449                         {
 450                                 get_canvas_interface()->add_value_node(layer->dynamic_param_list().find("index")->second, name);
 451                                 break;
 452                         }
 453                 }
 454         else
 455         {
 456                 Layer::ParamList param_list(layer->get_param_list());
 457                 for (Layer::ParamList::const_iterator iter(param_list.begin())
 458                                  ; iter != param_list.end()
 459                                  ; iter++)
 460                         if (layer->dynamic_param_list().count(iter->first)==0 && iter->second.get_type()==ValueBase::TYPE_CANVAS)
 461                         {
 462                                 Canvas::Handle subcanvas(iter->second.get(Canvas::Handle()));
 463                                 if (subcanvas && subcanvas->is_inline())
 464                                         for (Context iter = subcanvas->get_context(); iter != subcanvas->end(); iter++)
 465                                                 export_dup_nodes(*iter, canvas, index);
 466                         }
 467
 468                 for (Layer::DynamicParamList::const_iterator iter(layer->dynamic_param_list().begin())
 469                                  ; iter != layer->dynamic_param_list().end()
 470                                  ; iter++)
 471                         if (iter->second->get_type()==ValueBase::TYPE_CANVAS)
 472                         {
 473                                 Canvas::Handle canvas((*iter->second)(0).get(Canvas::Handle()));
 474                                 if (canvas->is_inline())
 475                                         //! \todo do we need to implement this?  and if so, shouldn't we check all canvases, not just the one at t=0s?
 476                                         warning("%s:%d not yet implemented - do we need to export duplicate valuenodes in dynamic canvas parameters?", __FILE__, __LINE__);
 477                         }
 478         }
 479 }
 480
 481 void
 482 LayerActionManager::amount_inc()
 483 {
 484         float adjust(0.1);
 485
 486         // Create the action group
 487         synfigapp::Action::PassiveGrouper group(get_canvas_interface()->get_instance().get(),_("Decrease Amount"));
 488
 489         if(adjust>0)
 490                 group.set_name(_("Increase Amount"));
 491
 492         synfigapp::SelectionManager::LayerList layer_list(layer_tree_->get_selected_layers());
 493
 494         while(!layer_list.empty())
 495         {
 496                 ValueBase value(layer_list.front()->get_param("amount"));
 497                 if(value.same_type_as(Real()))
 498                 {
 499                         get_canvas_interface()->change_value(synfigapp::ValueDesc(layer_list.front(),"amount"),value.get(Real())+adjust);
 500                 }
 501                 layer_list.pop_front();
 502         }
 503 }
 504
 505 void
 506 LayerActionManager::amount_dec()
 507 {
 508         float adjust(-0.1);
 509
 510         // Create the action group
 511         synfigapp::Action::PassiveGrouper group(get_canvas_interface()->get_instance().get(),_("Decrease Amount"));
 512
 513         if(adjust>0)
 514                 group.set_name(_("Increase Amount"));
 515
 516         synfigapp::SelectionManager::LayerList layer_list(layer_tree_->get_selected_layers());
 517
 518         while(!layer_list.empty())
 519         {
 520                 ValueBase value(layer_list.front()->get_param("amount"));
 521                 if(value.same_type_as(Real()))
 522                 {
 523                         get_canvas_interface()->change_value(synfigapp::ValueDesc(layer_list.front(),"amount"),value.get(Real())+adjust);
 524                 }
 525                 layer_list.pop_front();
 526         }
 527 }