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

   1 /* === S Y N F I G ========================================================= */
   2 /*!     \file canvasview.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 <sigc++/adaptors/hide.h>
  34
  35 #include <ETL/clock>
  36 #include <sstream>
  37
  38 #include <gtkmm/paned.h>
  39 #include <gtkmm/scale.h>
  40 #include <gtkmm/dialog.h>
  41 #include <gtkmm/messagedialog.h>
  42 #include <gtkmm/treemodelsort.h>
  43 #include <gtkmm/buttonbox.h>
  44
  45 #include <gtk/gtktreestore.h>
  46 #include <gtk/gtkversion.h>
  47
  48 #include <synfig/valuenode_reference.h>
  49 #include <synfig/valuenode_subtract.h>
  50 #include <synfig/valuenode_linear.h>
  51 #include <synfig/valuenode_timedswap.h>
  52 #include <synfig/valuenode_scale.h>
  53 #include <synfig/valuenode_dynamiclist.h>
  54 #include <synfig/valuenode_twotone.h>
  55 #include <synfig/valuenode_stripes.h>
  56 #include <synfig/valuenode_blinecalcvertex.h>
  57 #include <synfig/valuenode_bline.h>
  58 #include <synfig/layer.h>
  59
  60 #include <synfigapp/uimanager.h>
  61 #include <synfigapp/canvasinterface.h>
  62 #include <synfigapp/selectionmanager.h>
  63 //#include <synfigapp/action_setwaypoint.h>
  64 //#include <synfigapp/action_deletewaypoint.h>
  65
  66 #include <sigc++/retype_return.h>
  67 #include <sigc++/retype.h>
  68 //#include <sigc++/hide.h>
  69
  70 #include "canvasview.h"
  71 #include "instance.h"
  72 #include "app.h"
  73 #include "cellrenderer_value.h"
  74 #include "cellrenderer_timetrack.h"
  75 #include "workarea.h"
  76 #include "dialog_color.h"
  77 #include "eventkey.h"
  78
  79 #include "state_polygon.h"
  80 #include "state_bline.h"
  81 #include "state_normal.h"
  82 #include "state_eyedrop.h"
  83 #include "state_draw.h"
  84
  85 #include "ducktransform_scale.h"
  86 #include "ducktransform_translate.h"
  87 #include "ducktransform_rotate.h"
  88
  89 #include "event_mouse.h"
  90 #include "event_layerclick.h"
  91
  92 #include "toolbox.h"
  93
  94 #include "dialog_preview.h"
  95 #include "dialog_soundselect.h"
  96
  97 #include "preview.h"
  98 #include "audiocontainer.h"
  99 #include "widget_timeslider.h"
 100
 101 #include <synfigapp/main.h>
 102 #include <synfigapp/inputdevice.h>
 103
 104 #include "general.h"
 105
 106 #endif
 107
 108 /* === U S I N G =========================================================== */
 109
 110 using namespace std;
 111 using namespace etl;
 112 using namespace synfig;
 113 using namespace studio;
 114 using namespace sigc;
 115
 116 /* === M A C R O S ========================================================= */
 117
 118 #define GRAB_HINT_DATA(y)       { \
 119                 String x; \
 120                 if(synfigapp::Main::settings().get_value(String("pref.")+y+"_hints",x)) \
 121                 { \
 122                         set_type_hint((Gdk::WindowTypeHint)atoi(x.c_str()));    \
 123                 } \
 124         }
 125
 126 #define DEFAULT_TIME_WINDOW_SIZE                (10.0)
 127
 128 #ifndef SMALL_BUTTON
 129 #define SMALL_BUTTON(button,stockid,tooltip)    \
 130         button = manage(new class Gtk::Button());       \
 131         icon=manage(new Gtk::Image(Gtk::StockID(stockid),iconsize));    \
 132         button->add(*icon);     \
 133         tooltips.set_tip(*button,tooltip);      \
 134         icon->set_padding(0,0);\
 135         icon->show();   \
 136         button->set_relief(Gtk::RELIEF_NONE); \
 137         button->show()
 138 #endif
 139
 140 #ifndef NORMAL_BUTTON
 141 #define NORMAL_BUTTON(button,stockid,tooltip)   \
 142         button = manage(new class Gtk::Button());       \
 143         icon=manage(new Gtk::Image(Gtk::StockID(stockid),Gtk::ICON_SIZE_BUTTON));       \
 144         button->add(*icon);     \
 145         tooltips.set_tip(*button,tooltip);      \
 146         icon->set_padding(0,0);\
 147         icon->show();   \
 148         /*button->set_relief(Gtk::RELIEF_NONE);*/ \
 149         button->show()
 150 #endif
 151
 152 #define NEW_SMALL_BUTTON(x,y,z) Gtk::Button *SMALL_BUTTON(x,y,z)
 153
 154 #define NOT_IMPLEMENTED_SLOT sigc::mem_fun(*reinterpret_cast<studio::CanvasViewUIInterface*>(get_ui_interface().get()),&studio::CanvasViewUIInterface::not_implemented)
 155
 156 #define SLOT_EVENT(x)   sigc::hide_return(sigc::bind(sigc::mem_fun(*this,&studio::CanvasView::process_event_key),x))
 157
 158 /* === C L A S S E S ======================================================= */
 159
 160 class studio::UniversalScrubber
 161 {
 162         CanvasView *canvas_view;
 163
 164         bool            scrubbing;
 165         etl::clock      scrub_timer;
 166
 167         sigc::connection end_scrub_connection;
 168 public:
 169         UniversalScrubber(CanvasView *canvas_view):
 170                 canvas_view(canvas_view),
 171                 scrubbing(false)
 172         {
 173                 canvas_view->canvas_interface()->signal_time_changed().connect(
 174                         sigc::mem_fun(*this,&studio::UniversalScrubber::on_time_changed)
 175                 );
 176         }
 177
 178         ~UniversalScrubber()
 179         {
 180                 end_scrub_connection.disconnect();
 181         }
 182
 183         void on_time_changed()
 184         {
 185                 // Make sure we are changing the time quickly
 186                 // before we enable scrubbing
 187                 if(!scrubbing && scrub_timer()>1)
 188                 {
 189                         scrub_timer.reset();
 190                         return;
 191                 }
 192
 193                 // If we aren't scrubbing already, enable it
 194                 if(!scrubbing)
 195                 {
 196                         scrubbing=true;
 197                         audio_container()->start_scrubbing(canvas_view->get_time());
 198                 }
 199
 200                 // Reset the scrubber ender
 201                 end_scrub_connection.disconnect();
 202                 end_scrub_connection=Glib::signal_timeout().connect(
 203                         sigc::bind_return(
 204                                 sigc::mem_fun(*this,&UniversalScrubber::end_of_scrubbing),
 205                                 false
 206                         ),
 207                         1000
 208                 );
 209
 210                 // Scrub!
 211                 audio_container()->scrub(canvas_view->get_time());
 212
 213                 scrub_timer.reset();
 214         }
 215
 216         void end_of_scrubbing()
 217         {
 218                 scrubbing=false;
 219                 audio_container()->stop_scrubbing();
 220                 scrub_timer.reset();
 221         }
 222
 223         handle<AudioContainer> audio_container()
 224         {
 225                 assert(canvas_view->audio);
 226                 return canvas_view->audio;
 227         }
 228 };
 229
 230 class studio::CanvasViewUIInterface : public synfigapp::UIInterface
 231 {
 232         CanvasView *view;
 233
 234 public:
 235
 236         CanvasViewUIInterface(CanvasView *view):
 237                 view(view)
 238         {
 239                 view->statusbar->push(_("Idle"));
 240         }
 241
 242         ~CanvasViewUIInterface()
 243         {
 244                 //view->statusbar->pop();
 245                 //view->progressbar->set_fraction(0);
 246         }
 247
 248         virtual Response yes_no(const std::string &title, const std::string &message,Response dflt=RESPONSE_YES)
 249         {
 250                 view->present();
 251                 //while(studio::App::events_pending())studio::App::iteration(false);
 252                 Gtk::Dialog dialog(
 253                         title,          // Title
 254                         *view,          // Parent
 255                         true,           // Modal
 256                         true            // use_separator
 257                 );
 258                 Gtk::Label label(message);
 259                 label.show();
 260
 261                 dialog.get_vbox()->pack_start(label);
 262                 dialog.add_button(Gtk::StockID("gtk-yes"),RESPONSE_YES);
 263                 dialog.add_button(Gtk::StockID("gtk-no"),RESPONSE_NO);
 264
 265                 dialog.set_default_response(dflt);
 266                 dialog.show();
 267                 return (Response)dialog.run();
 268         }
 269         virtual Response yes_no_cancel(const std::string &title, const std::string &message,Response dflt=RESPONSE_YES)
 270         {
 271                 view->present();
 272                 //while(studio::App::events_pending())studio::App::iteration(false);
 273                 Gtk::Dialog dialog(
 274                         title,          // Title
 275                         *view,          // Parent
 276                         true,           // Modal
 277                         true            // use_separator
 278                 );
 279                 Gtk::Label label(message);
 280                 label.show();
 281
 282                 dialog.get_vbox()->pack_start(label);
 283                 dialog.add_button(Gtk::StockID("gtk-yes"),RESPONSE_YES);
 284                 dialog.add_button(Gtk::StockID("gtk-no"),RESPONSE_NO);
 285                 dialog.add_button(Gtk::StockID("gtk-cancel"),RESPONSE_CANCEL);
 286
 287                 dialog.set_default_response(dflt);
 288                 dialog.show();
 289                 return (Response)dialog.run();
 290         }
 291         virtual Response ok_cancel(const std::string &title, const std::string &message,Response dflt=RESPONSE_OK)
 292         {
 293                 view->present();
 294                 //while(studio::App::events_pending())studio::App::iteration(false);
 295                 Gtk::Dialog dialog(
 296                         title,          // Title
 297                         *view,          // Parent
 298                         true,           // Modal
 299                         true            // use_separator
 300                 );
 301                 Gtk::Label label(message);
 302                 label.show();
 303
 304                 dialog.get_vbox()->pack_start(label);
 305                 dialog.add_button(Gtk::StockID("gtk-ok"),RESPONSE_OK);
 306                 dialog.add_button(Gtk::StockID("gtk-cancel"),RESPONSE_CANCEL);
 307
 308                 dialog.set_default_response(dflt);
 309                 dialog.show();
 310                 return (Response)dialog.run();
 311         }
 312
 313         virtual bool
 314         task(const std::string &task)
 315         {
 316                 if(!view->is_playing_)
 317                 {
 318                         view->statusbar->pop();
 319                         view->statusbar->push(task);
 320                 }
 321                 //while(studio::App::events_pending())studio::App::iteration(false);
 322                 if(view->cancel){return false;}
 323                 return true;
 324         }
 325
 326         virtual bool
 327         error(const std::string &err)
 328         {
 329                 view->statusbar->push(_("ERROR"));
 330
 331                 // If we are in the process of canceling,
 332                 // then just go ahead and return false --
 333                 // don't bother displaying a dialog
 334                 if(view->cancel)return false;
 335                 Gtk::MessageDialog dialog(*view, err, false, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_CLOSE, true);
 336                 dialog.show();
 337                 dialog.run();
 338                 view->statusbar->pop();
 339                 return true;
 340         }
 341
 342         virtual bool
 343         warning(const std::string &err)
 344         {
 345                 view->statusbar->pop();
 346                 view->statusbar->push(err);
 347
 348                 //while(studio::App::events_pending())studio::App::iteration(false);
 349                 if(view->cancel)return false;
 350                 return true;
 351         }
 352
 353         virtual bool
 354         amount_complete(int current, int total)
 355         {
 356                 if(!view->is_playing_)
 357                 {
 358                         if(!view->working_depth)
 359                         {
 360                                 if(current)
 361                                         view->stopbutton->set_sensitive(true);
 362                                 else
 363                                         view->stopbutton->set_sensitive(false);
 364                         }
 365                         float x((float)current/(float)total);
 366                         if(x<0)x=0;
 367                         else if(x>1)x=1;
 368                         view->progressbar->set_fraction(x);
 369                 }
 370                 //while(studio::App::events_pending())studio::App::iteration(false);
 371                 if(view->cancel){/*view->cancel=false;*/return false;}
 372                 return true;
 373         }
 374
 375         void
 376         not_implemented()
 377         {
 378                 error(_("Feature not yet implemented"));
 379         }
 380 };
 381
 382 class studio::CanvasViewSelectionManager : public synfigapp::SelectionManager
 383 {
 384         CanvasView *view;
 385         CanvasView::LayerTreeModel layer_tree_model;
 386         CanvasView::ChildrenTreeModel children_tree_model;
 387
 388 public:
 389         CanvasViewSelectionManager(CanvasView *view): view(view) { }
 390
 391 private:
 392         void _set_selected_layer(const synfig::Layer::Handle &layer)
 393         {
 394                 view->layer_tree->select_layer(layer);
 395 /*
 396                 // Don't change the selection while we are busy
 397                 // I cannot remember exactly why I put this here...
 398                 // It musta been for some reason, but I cannot recall.
 399                 //if(App::Busy::count)
 400                 //      return;
 401
 402                 if(view->layer_tree->get_selection()->get_selected())
 403                 {
 404                         const Gtk::TreeRow row = *(view->layer_tree->get_selection()->get_selected());
 405
 406                         // Don't do anything if that layer is already selected
 407                         if(layer == static_cast<synfig::Layer::Handle>(row[layer_tree_model.layer]))
 408                                 return;
 409                 }
 410                 Gtk::TreeModel::Children::iterator iter;
 411                 if(view->layer_tree_store()->find_layer_row(layer,iter))
 412                 {
 413                         Gtk::TreePath path(iter);
 414                         for(int i=path.get_depth();i;i--)
 415                         {
 416                                 int j;
 417                                 path=Gtk::TreePath(iter);
 418                                 for(j=i;j;j--)
 419                                         path.up();
 420                                 view->layer_tree->get_tree_view().expand_row(path,false);
 421                         }
 422                         view->layer_tree->get_tree_view().scroll_to_row(Gtk::TreePath(iter));
 423                         view->layer_tree->get_selection()->select(iter);
 424                 }
 425 */
 426         }
 427 public:
 428
 429         //! Returns the number of layers selected.
 430         virtual int get_selected_layer_count()const
 431         {
 432                 return get_selected_layers().size();
 433         }
 434
 435         //! Returns a list of the currently selected layers.
 436         virtual LayerList get_selected_layers()const
 437         {
 438 //              assert(view->layer_tree);
 439
 440                 if(!view->layer_tree) { synfig::error("%s:%d canvas_view.layer_tree not defined!?", __FILE__, __LINE__); return LayerList(); }
 441                 return view->layer_tree->get_selected_layers();
 442         }
 443
 444         //! Returns the first layer selected or an empty handle if none are selected.
 445         virtual synfig::Layer::Handle get_selected_layer()const
 446         {
 447 //              assert(view->layer_tree);
 448
 449                 if(!view->layer_tree) { synfig::error("%s:%d canvas_view.layer_tree not defined!?", __FILE__, __LINE__); return 0; }
 450                 return view->layer_tree->get_selected_layer();
 451         }
 452
 453         //! Sets which layers should be selected
 454         virtual void set_selected_layers(const LayerList &layer_list)
 455         {
 456 //              assert(view->layer_tree);
 457
 458                 if(!view->layer_tree) { synfig::error("%s:%d canvas_view.layer_tree not defined!?", __FILE__, __LINE__); return; }
 459                 view->layer_tree->select_layers(layer_list);
 460                 //view->get_smach().process_event(EVENT_REFRESH_DUCKS);
 461
 462                 //view->queue_rebuild_ducks();
 463         }
 464
 465         //! Sets which layer should be selected.
 466         virtual void set_selected_layer(const synfig::Layer::Handle &layer)
 467         {
 468 //              assert(view->layer_tree);
 469
 470                 if(!view->layer_tree) { synfig::error("canvas_view.layer_tree not defined!?"); return; }
 471                 view->layer_tree->select_layer(layer);
 472                 //view->queue_rebuild_ducks();
 473         }
 474
 475         //! Clears the layer selection list
 476         virtual void clear_selected_layers()
 477         {
 478                 if(!view->layer_tree) return;
 479                 view->layer_tree->clear_selected_layers();
 480         }
 481
 482         //! Returns the number of value_nodes selected.
 483         virtual int get_selected_children_count()const
 484         {
 485                 return get_selected_children().size();
 486         }
 487
 488         static inline void __child_grabber(const Gtk::TreeModel::iterator& iter, ChildrenList* ret)
 489         {
 490                 const CanvasView::ChildrenTreeModel children_tree_model;
 491                 synfigapp::ValueDesc value_desc((*iter)[children_tree_model.value_desc]);
 492                 if(value_desc)
 493                         ret->push_back(value_desc);
 494         }
 495
 496         //! Returns a list of the currently selected value_nodes.
 497         virtual ChildrenList get_selected_children()const
 498         {
 499                 if(!view->children_tree) return ChildrenList();
 500
 501                 Glib::RefPtr<Gtk::TreeSelection> selection=view->children_tree->get_selection();
 502
 503                 if(!selection)
 504                         return ChildrenList();
 505
 506                 ChildrenList ret;
 507
 508                 selection->selected_foreach_iter(
 509                         sigc::bind(
 510                                 sigc::ptr_fun(
 511                                         &studio::CanvasViewSelectionManager::__child_grabber
 512                                 ),
 513                                 &ret
 514                         )
 515                 );
 516
 517                 /*
 518                 Gtk::TreeModel::Children::iterator iter(view->children_tree_store()->children().begin());
 519                 iter++;
 520                 Gtk::TreeModel::Children children = iter->children();
 521                 for(iter = children.begin(); iter != children.end(); ++iter)
 522                 {
 523                         Gtk::TreeModel::Row row = *iter;
 524                         if(selection->is_selected(row))
 525                                 ret.push_back((synfigapp::ValueDesc)row[children_tree_model.value_desc]);
 526                 }
 527                 */
 528                 return ret;
 529         }
 530
 531         //! Returns the first value_node selected or an empty handle if none are selected.
 532         virtual ChildrenList::value_type get_selected_child()const
 533         {
 534                 if(!view->children_tree) return ChildrenList::value_type();
 535
 536                 ChildrenList children(get_selected_children());
 537
 538                 if(children.empty())
 539                         return ChildrenList::value_type();
 540
 541                 return children.front();
 542         }
 543
 544         //! Sets which value_nodes should be selected
 545         virtual void set_selected_children(const ChildrenList &/*children_list*/)
 546         {
 547                 return;
 548         }
 549
 550         //! Sets which value_node should be selected. Empty handle if none.
 551         virtual void set_selected_child(const ChildrenList::value_type &/*child*/)
 552         {
 553                 return;
 554         }
 555
 556         //! Clears the value_node selection list
 557         virtual void clear_selected_children()
 558         {
 559                 return;
 560         }
 561
 562         int get_selected_layer_parameter_count()const
 563         {
 564                 return get_selected_layer_parameters().size();
 565         }
 566
 567         LayerParamList get_selected_layer_parameters()const
 568         {
 569                 if(!view->layer_tree) return LayerParamList();
 570
 571                 Glib::RefPtr<Gtk::TreeSelection> selection=view->layer_tree->get_selection();
 572
 573                 if(!selection)
 574                         return LayerParamList();
 575
 576                 LayerParamList ret;
 577
 578                 Gtk::TreeModel::Children children = const_cast<CanvasView*>(view)->layer_tree_store()->children();
 579                 Gtk::TreeModel::Children::iterator iter;
 580                 for(iter = children.begin(); iter != children.end(); ++iter)
 581                 {
 582                         Gtk::TreeModel::Row row = *iter;
 583                         Gtk::TreeModel::Children::iterator iter;
 584                         for(iter=row.children().begin();iter!=row.children().end();iter++)
 585                         {
 586                                 Gtk::TreeModel::Row row = *iter;
 587                                 if(selection->is_selected(row))
 588                                         ret.push_back(LayerParam(row[layer_tree_model.layer],(Glib::ustring)row[layer_tree_model.id]));
 589                         }
 590                 }
 591                 return ret;
 592         }
 593
 594         LayerParam get_selected_layer_parameter() const
 595         {
 596                 if(!view->layer_tree) return LayerParam();
 597                 return get_selected_layer_parameters().front();
 598         }
 599
 600         void set_selected_layer_parameters(const LayerParamList &/*layer_param_list*/)
 601         {
 602                 return;
 603         }
 604
 605         void set_selected_layer_param(const LayerParam &/*layer_param*/)
 606         {
 607                 return;
 608         }
 609
 610         void clear_selected_layer_parameters()
 611         {
 612                 return;
 613         }
 614
 615 }; // END of class SelectionManager
 616
 617 CanvasView::IsWorking::IsWorking(CanvasView &canvas_view_):
 618         canvas_view_(canvas_view_)
 619 {
 620         if(!canvas_view_.working_depth)
 621                 canvas_view_.stopbutton->set_sensitive(true);
 622         canvas_view_.working_depth++;
 623         canvas_view_.cancel=false;
 624 }
 625
 626 CanvasView::IsWorking::~IsWorking()
 627 {
 628         canvas_view_.working_depth--;
 629         if(!canvas_view_.working_depth)
 630                 canvas_view_.stopbutton->set_sensitive(false);
 631 }
 632
 633 CanvasView::IsWorking::operator bool()const
 634 {
 635         if(canvas_view_.cancel)
 636                 return false;
 637         return true;
 638 }
 639
 640 /* === M E T H O D S ======================================================= */
 641
 642 CanvasView::CanvasView(etl::loose_handle<Instance> instance,etl::handle<synfigapp::CanvasInterface> canvas_interface_):
 643         smach_                                  (this),
 644         instance_                               (instance),
 645         canvas_interface_               (canvas_interface_),
 646         //layer_tree_store_             (LayerTreeStore::create(canvas_interface_)),
 647         //children_tree_store_  (ChildrenTreeStore::create(canvas_interface_)),
 648         //keyframe_tree_store_  (KeyframeTreeStore::create(canvas_interface_)),
 649         time_adjustment_                (0,0,25,0,0,0),
 650         time_window_adjustment_ (0,0,25,0,0,0),
 651         statusbar                               (manage(new class Gtk::Statusbar())),
 652
 653         timeslider                              (new Widget_Timeslider),
 654
 655         ui_interface_                   (new CanvasViewUIInterface(this)),
 656         selection_manager_              (new CanvasViewSelectionManager(this)),
 657         is_playing_                             (false),
 658
 659         working_depth                   (0),
 660         cancel                                  (false),
 661
 662         canvas_properties               (*this,canvas_interface_),
 663         canvas_options                  (this),
 664         render_settings                 (*this,canvas_interface_),
 665         waypoint_dialog                 (*this,canvas_interface_->get_canvas()),
 666         keyframe_dialog                 (*this,canvas_interface_),
 667         preview_dialog                  (new Dialog_Preview),
 668         sound_dialog                    (new Dialog_SoundSelect(*this,canvas_interface_))
 669 {
 670         layer_tree=0;
 671         children_tree=0;
 672         duck_refresh_flag=true;
 673
 674         smach_.set_default_state(&state_normal);
 675
 676         disp_audio = new Widget_Sound();
 677
 678         //synfig::info("Canvasview: Entered constructor");
 679         // Minor hack
 680         get_canvas()->set_time(0);
 681         //layer_tree_store_->rebuild();
 682
 683         // Set up the UI and Selection managers
 684         canvas_interface()->set_ui_interface(get_ui_interface());
 685         canvas_interface()->set_selection_manager(get_selection_manager());
 686         rebuild_ducks_queued=false;
 687
 688         //notebook=manage(new class Gtk::Notebook());
 689         //Gtk::VPaned *vpaned = manage(new class Gtk::VPaned());
 690         //vpaned->pack1(*create_work_area(), Gtk::EXPAND|Gtk::SHRINK);
 691         //vpaned->pack2(*notebook, Gtk::SHRINK);
 692         //vpaned->show_all();
 693
 694         //notebook->show();
 695
 696         //notebook->append_page(*create_layer_tree(),_("Layers"));
 697         //notebook->append_page(*create_children_tree(),_("Children"));
 698         //notebook->append_page(*create_keyframe_tree(),_("Keyframes"));
 699
 700         //synfig::info("Canvasview: Before big chunk of allocation and tabling stuff");
 701         //create all allocated stuff for this canvas
 702         audio = new AudioContainer();
 703
 704         Gtk::Table *layout_table= manage(new class Gtk::Table(1, 3, false));
 705         //layout_table->attach(*vpaned, 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
 706         layout_table->attach(*create_work_area(), 0, 1, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
 707         init_menus();
 708         //layout_table->attach(*App::ui_manager()->get_widget("/menu-main"), 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK|Gtk::FILL, 0, 0);
 709
 710         layout_table->attach(*create_time_bar(), 0, 1, 3, 4, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK|Gtk::FILL, 0, 0);
 711         layout_table->attach(*create_status_bar(), 0, 1, 4, 5, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK|Gtk::FILL, 0, 0);
 712
 713         update_title();
 714
 715         layout_table->show();
 716         add(*layout_table);
 717
 718         //set_transient_for(*App::toolbox);
 719
 720         //synfig::info("Canvasview: Before Signals");
 721         /*
 722  --     ** -- Signals -------------------------------------------------------------
 723         */
 724
 725         canvas_interface()->signal_dirty_preview().connect(sigc::mem_fun(*this,&studio::CanvasView::on_dirty_preview));
 726         canvas_interface()->signal_mode_changed().connect(sigc::mem_fun(*this,&studio::CanvasView::on_mode_changed));
 727
 728         canvas_interface()->signal_time_changed().connect(sigc::mem_fun(*this,&studio::CanvasView::on_time_changed));
 729
 730         //canvas_interface()->signal_time_changed().connect(sigc::mem_fun(*this,&studio::CanvasView::refresh_tables));
 731         canvas_interface()->signal_id_changed().connect(sigc::mem_fun(*this,&studio::CanvasView::on_id_changed));
 732         canvas_interface()->signal_rend_desc_changed().connect(sigc::mem_fun(*this,&studio::CanvasView::refresh_rend_desc));
 733         waypoint_dialog.signal_changed().connect(sigc::mem_fun(*this,&studio::CanvasView::on_waypoint_changed));
 734         waypoint_dialog.signal_delete().connect(sigc::mem_fun(*this,&studio::CanvasView::on_waypoint_delete));
 735
 736         //MODIFIED TIME ADJUSTMENT STUFF....
 737         time_window_adjustment().set_child_adjustment(&time_adjustment());
 738         time_window_adjustment().signal_value_changed().connect(sigc::mem_fun(*this,&studio::CanvasView::refresh_time_window));
 739         time_adjustment().signal_value_changed().connect(sigc::mem_fun(*this,&studio::CanvasView::time_was_changed));
 740
 741         work_area->signal_layer_selected().connect(sigc::mem_fun(*this,&studio::CanvasView::workarea_layer_selected));
 742         work_area->signal_input_device_changed().connect(sigc::mem_fun(*this,&studio::CanvasView::on_input_device_changed));
 743
 744         canvas_interface()->signal_canvas_added().connect(
 745                 sigc::hide(
 746                         sigc::mem_fun(*instance,&studio::Instance::refresh_canvas_tree)
 747                 )
 748         );
 749         canvas_interface()->signal_canvas_removed().connect(
 750                 sigc::hide(
 751                         sigc::mem_fun(*instance,&studio::Instance::refresh_canvas_tree)
 752                 )
 753         );
 754
 755         canvas_interface()->signal_layer_param_changed().connect(
 756                 sigc::hide(
 757                         sigc::hide(
 758                                 SLOT_EVENT(EVENT_REFRESH_DUCKS)
 759                         )
 760                 )
 761         );
 762
 763         //MUCH TIME STUFF TAKES PLACE IN HERE
 764         refresh_rend_desc();
 765         refresh_time_window();
 766
 767         /*! \todo We shouldn't need to do this at construction --
 768         **      This should be performed at the first time the window
 769         **      becomes visible.
 770         */
 771         work_area->queue_render_preview();
 772
 773         // If the canvas is really big, zoom out so that we can fit it all in the window
 774         /*! \todo In other words, this is a zoom-to-fit, and should be
 775         ** in its own function.
 776         */
 777         int w=get_canvas()->rend_desc().get_w()+70;
 778         int h=get_canvas()->rend_desc().get_h()+70;
 779         while(w>700 || h>600)
 780         {
 781                 // Minor hack:
 782                 //   zoom_out() =>
 783                 //         WorkArea::async_update_preview() =>
 784                 //           WorkArea::set_zoom(float) =>
 785                 //                 WorkArea::async_update_preview() =>
 786                 //                       desc.set_time(cur_time), where cur_time isn't initialized
 787                 work_area->set_time(0);
 788                 work_area->zoom_out();
 789                 w=round_to_int(get_canvas()->rend_desc().get_w()*work_area->get_zoom()+70);
 790                 h=round_to_int(get_canvas()->rend_desc().get_h()*work_area->get_zoom()+70);
 791         }
 792         if(w>700)w=700;
 793         if(h>600)h=600;
 794         set_default_size(w,h);
 795         property_window_position().set_value(Gtk::WIN_POS_NONE);
 796
 797         std::list<Gtk::TargetEntry> listTargets;
 798         listTargets.push_back( Gtk::TargetEntry("STRING") );
 799         listTargets.push_back( Gtk::TargetEntry("text/plain") );
 800         listTargets.push_back( Gtk::TargetEntry("image") );
 801
 802         drag_dest_set(listTargets);
 803         signal_drag_data_received().connect( sigc::mem_fun(*this, &studio::CanvasView::on_drop_drag_data_received) );
 804
 805         /*
 806         Time length(get_canvas()->rend_desc().get_time_end()-get_canvas()->rend_desc().get_time_start());
 807         if(length<10.0)
 808         {
 809                 time_window_adjustment().set_page_increment(length);
 810                 time_window_adjustment().set_page_size(length);
 811         }
 812         else
 813         {
 814                 time_window_adjustment().set_page_increment(10.0);
 815                 time_window_adjustment().set_page_size(10.0);
 816         }
 817         */
 818
 819         //synfig::info("Canvasview: Before Sound Hookup");
 820         //load sound info from meta data
 821         {
 822                 //synfig::warning("Should load Audio: %s with %s offset",apath.c_str(),aoffset.c_str());
 823
 824                 on_audio_file_notify(); //redundant setting of the metadata, but oh well, it's no big deal :)
 825                 on_audio_offset_notify();
 826
 827                 //signal connection - since they are all associated with the canvas view
 828
 829                 //hook in signals for sound options box
 830                 sound_dialog->signal_file_changed().connect(sigc::mem_fun(*this,&CanvasView::on_audio_file_change));
 831                 sound_dialog->signal_offset_changed().connect(sigc::mem_fun(*this,&CanvasView::on_audio_offset_change));
 832
 833                 //attach to the preview when it's visible
 834                 //preview_dialog->get_widget().signal_play().connect(sigc::mem_fun(*this,&CanvasView::play_audio));
 835                 //preview_dialog->get_widget().signal_stop().connect(sigc::mem_fun(*this,&CanvasView::stop_audio));
 836
 837                 //hook to metadata signals
 838                 get_canvas()->signal_meta_data_changed("audiofile").connect(sigc::mem_fun(*this,&CanvasView::on_audio_file_notify));
 839                 get_canvas()->signal_meta_data_changed("audiooffset").connect(sigc::mem_fun(*this,&CanvasView::on_audio_offset_notify));
 840
 841                 //universal_scrubber=std::auto_ptr<UniversalScrubber>(new UniversalScrubber(this));
 842         }
 843
 844         //synfig::info("Canvasview: Before Final time set up");
 845         //MORE TIME STUFF
 846         time_window_adjustment().set_value(get_canvas()->rend_desc().get_time_start());
 847         time_window_adjustment().value_changed();
 848
 849         GRAB_HINT_DATA("canvas_view");
 850         /*
 851         {
 852         set_skip_taskbar_hint(true);
 853         set_skip_pager_hint(true);
 854         set_type_hint(Gdk::WINDOW_TYPE_HINT_UTILITY);
 855         }
 856         */
 857
 858         refresh_rend_desc();
 859         hide_tables();
 860
 861         on_time_changed();
 862         //synfig::info("Canvasview: Constructor Done");
 863 }
 864
 865 CanvasView::~CanvasView()
 866 {
 867         signal_deleted()();
 868
 869         App::ui_manager()->remove_action_group(action_group);
 870
 871         // Shut down the smach
 872         smach_.egress();
 873         smach_.set_default_state(0);
 874
 875         // We want to ensure that the UI_Manager and
 876         // the selection manager get destructed right now.
 877         ui_interface_.reset();
 878         selection_manager_.reset();
 879
 880         // Delete any external widgets
 881         for(;!ext_widget_book_.empty();ext_widget_book_.erase(ext_widget_book_.begin()))
 882         {
 883                 if(ext_widget_book_.begin()->second)
 884                         delete ext_widget_book_.begin()->second;
 885         }
 886
 887         //delete preview
 888         audio.reset();
 889
 890         hide();
 891
 892         // don't be calling on_dirty_preview once this object has been deleted;
 893         // this was causing a crash before
 894         canvas_interface()->signal_dirty_preview().clear();
 895
 896         if (getenv("SYNFIG_DEBUG_DESTRUCTORS"))
 897                 synfig::info("CanvasView::~CanvasView(): Deleted");
 898 }
 899
 900 std::list<int>&
 901 CanvasView::get_pixel_sizes()
 902 {
 903         // prime factors of 120 are 2, 2, 2, 3, 5 - see TILE_SIZE in synfig-core/trunk/src/synfig/target_tile.h
 904         static int pixel_size_array[] = {2,3,4,5,6,8,10,12,15,20,24,30,40,60,120};
 905         static list<int> pixel_sizes = list<int>(pixel_size_array, pixel_size_array + sizeof(pixel_size_array) / sizeof(int));
 906
 907         return pixel_sizes;
 908 }
 909
 910 Gtk::Widget *
 911 CanvasView::create_time_bar()
 912 {
 913         Gtk::Image *icon;
 914
 915         Gtk::HScrollbar *time_window_scroll = manage(new class Gtk::HScrollbar(time_window_adjustment()));
 916         //Gtk::HScrollbar *time_scroll = manage(new class Gtk::HScrollbar(time_adjustment()));
 917         //TIME BAR TEMPORARY POSITION
 918         //Widget_Timeslider *time_scroll = manage(new Widget_Timeslider);
 919         timeslider->show();
 920         timeslider->set_time_adjustment(&time_adjustment());
 921         timeslider->set_bounds_adjustment(&time_window_adjustment());
 922         //layout_table->attach(*timeslider, 0, 1, 2, 3, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK|Gtk::FILL);
 923
 924         tooltips.set_tip(*time_window_scroll,_("Moves the time window"));
 925         tooltips.set_tip(*timeslider,_("Changes the current time"));
 926         time_window_scroll->show();
 927         timeslider->show();
 928         time_window_scroll->set_flags(Gtk::CAN_FOCUS);
 929         timeslider->set_flags(Gtk::CAN_FOCUS);
 930
 931         //time_scroll->signal_value_changed().connect(sigc::mem_fun(*work_area, &studio::WorkArea::render_preview_hook));
 932         //time_scroll->set_update_policy(Gtk::UPDATE_DISCONTINUOUS);
 933
 934         NORMAL_BUTTON(animatebutton,"gtk-yes",_("Animate"));
 935         animatebutton->signal_clicked().connect(sigc::mem_fun(*this, &studio::CanvasView::on_animate_button_pressed));
 936         animatebutton->show();
 937
 938         NORMAL_BUTTON(keyframebutton,"synfig-keyframe_lock_all",_("All Keyframes Locked"));
 939         keyframebutton->signal_clicked().connect(sigc::mem_fun(*this, &studio::CanvasView::on_keyframe_button_pressed));
 940         keyframebutton->show();
 941
 942         Gtk::Table *table= manage(new class Gtk::Table(2, 3, false));
 943
 944         //setup the audio display
 945         disp_audio->set_size_request(-1,32); //disp_audio->show();
 946         disp_audio->set_time_adjustment(&time_adjustment());
 947         disp_audio->signal_start_scrubbing().connect(
 948                 sigc::mem_fun(*audio,&AudioContainer::start_scrubbing)
 949         );
 950         disp_audio->signal_scrub().connect(
 951                 sigc::mem_fun(*audio,&AudioContainer::scrub)
 952         );
 953         disp_audio->signal_stop_scrubbing().connect(
 954                 sigc::mem_fun(*audio,&AudioContainer::stop_scrubbing)
 955         );
 956
 957         table->attach(*manage(disp_audio), 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK);
 958         table->attach(*timeslider, 0, 1, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK, 0, 0);
 959         table->attach(*time_window_scroll, 0, 1, 2, 3, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK, 0, 0);
 960
 961         table->attach(*animatebutton, 1, 2, 0, 3, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
 962         table->attach(*keyframebutton, 2, 3, 0, 3, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
 963         timebar=table;
 964         table->show();
 965         return table;
 966 }
 967
 968 Gtk::Widget *
 969 CanvasView::create_work_area()
 970 {
 971         work_area=std::auto_ptr<WorkArea>(new class studio::WorkArea(canvas_interface_));
 972         work_area->set_instance(get_instance());
 973         work_area->set_canvas(get_canvas());
 974         work_area->set_canvas_view(this);
 975         work_area->set_progress_callback(get_ui_interface().get());
 976         work_area->signal_popup_menu().connect(sigc::mem_fun(*this, &studio::CanvasView::popup_main_menu));
 977         work_area->show();
 978         return work_area.get();
 979 }
 980
 981 Gtk::Widget*
 982 CanvasView::create_status_bar()
 983 {
 984         Gtk::Image *icon;
 985         Gtk::IconSize iconsize=Gtk::IconSize::from_name("synfig-small_icon");
 986         cancel=false;
 987
 988         // Create the status bar at the bottom of the window
 989         Gtk::Table *statusbartable= manage(new class Gtk::Table(7, 1, false));
 990 //      statusbar = manage(new class Gtk::Statusbar()); // This is already done at construction
 991         progressbar =manage(new class Gtk::ProgressBar());
 992         SMALL_BUTTON(stopbutton,"gtk-stop",_("Stop"));
 993         SMALL_BUTTON(refreshbutton,"gtk-refresh",_("Refresh"));
 994         //SMALL_BUTTON(treetogglebutton,"gtk-go-down",_("Toggle Layer Tree"));
 995 //      NEW_SMALL_BUTTON(raisebutton,"gtk-go-up",_("Raise Layer"));
 996 //      NEW_SMALL_BUTTON(lowerbutton,"gtk-go-down",_("Lower Layer"));
 997         //statusbartable->attach(*treetogglebutton, 0, 1, 0, 1, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
 998 //      statusbartable->attach(*lowerbutton, 0, 1, 0, 1, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
 999 //      statusbartable->attach(*raisebutton, 1, 2, 0, 1, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
1000
1001         current_time_widget=manage(new Widget_Time);
1002         current_time_widget->set_value(get_time());
1003         current_time_widget->set_fps(get_canvas()->rend_desc().get_frame_rate());
1004         current_time_widget->signal_value_changed().connect(
1005                 sigc::mem_fun(*this,&CanvasView::on_current_time_widget_changed)
1006         );
1007
1008         statusbartable->attach(*current_time_widget, 0, 1, 0, 1, Gtk::SHRINK|Gtk::FILL, Gtk::SHRINK|Gtk::FILL, 0, 0);
1009         statusbartable->attach(*statusbar, 3, 4, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
1010         statusbartable->attach(*progressbar, 4, 5, 0, 1, Gtk::SHRINK, Gtk::EXPAND|Gtk::FILL, 0, 0);
1011         statusbartable->attach(*refreshbutton, 5, 6, 0, 1, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
1012         statusbartable->attach(*stopbutton, 6, 7, 0, 1, Gtk::SHRINK, Gtk::SHRINK, 0, 0);
1013         statusbar->set_has_resize_grip(false);
1014         statusbar->show();
1015         stopbutton->show();
1016         refreshbutton->show();
1017         progressbar->show();
1018         stopbutton->set_sensitive(false);
1019
1020         //refreshbutton->signal_clicked().connect(sigc::mem_fun(*this, &studio::CanvasView::on_refresh_pressed));
1021         //stopbutton->signal_clicked().connect(sigc::mem_fun(*this, &studio::CanvasView::stop));
1022         //treetogglebutton->signal_clicked().connect(sigc::mem_fun(*this, &studio::CanvasView::toggle_tables));
1023
1024         refreshbutton->signal_clicked().connect(SLOT_EVENT(EVENT_REFRESH));
1025         stopbutton->signal_clicked().connect(SLOT_EVENT(EVENT_STOP));
1026
1027         statusbartable->show_all();
1028         return statusbartable;
1029 }
1030
1031 void
1032 CanvasView::on_current_time_widget_changed()
1033 {
1034         set_time(current_time_widget->get_value());
1035
1036         // show the value being used - it will have been rounded to nearest frame
1037         // this was already being done elsewhere, but only if the time was really changed;
1038         // if the current time was 6f and the user edited it to 6.1f, then the 6.1f would
1039         // be left in the display without the following line to fix it
1040         current_time_widget->set_value(get_time());
1041         current_time_widget->set_position(-1); // leave the cursor at the end
1042 }
1043
1044 //      Gtk::Widget*
1045 //      CanvasView::create_children_tree()
1046 //      {
1047 //              // Create the layer tree
1048 //              children_tree=manage(new class ChildrenTree());
1049 //
1050 //              // Set up the layer tree
1051 //              //children_tree->set_model(children_tree_store());
1052 //              if(children_tree)children_tree->set_time_adjustment(time_adjustment());
1053 //              if(children_tree)children_tree->show();
1054 //
1055 //              // Connect Signals
1056 //              if(children_tree)children_tree->signal_edited_value().connect(sigc::mem_fun(*this, &studio::CanvasView::on_edited_value));
1057 //              if(children_tree)children_tree->signal_user_click().connect(sigc::mem_fun(*this, &studio::CanvasView::on_children_user_click));
1058 //              if(children_tree)children_tree->signal_waypoint_clicked_childrentree().connect(sigc::mem_fun(*this, &studio::CanvasView::on_waypoint_clicked_canvasview));
1059 //              if(children_tree)children_tree->get_selection()->signal_changed().connect(SLOT_EVENT(EVENT_REFRESH_DUCKS));
1060 //
1061 //              return children_tree;
1062 //      }
1063
1064 //      Gtk::Widget*
1065 //      CanvasView::create_keyframe_tree()
1066 //      {
1067 //              keyframe_tree=manage(new KeyframeTree());
1068 //
1069 //              //keyframe_tree->get_selection()->set_mode(Gtk::SELECTION_MULTIPLE);
1070 //              //keyframe_tree->show();
1071 //              //keyframe_tree->set_model(keyframe_tree_store());
1072 //              keyframe_tree->set_editable(true);
1073 //              //keyframe_tree->signal_edited().connect(sigc::hide_return(sigc::mem_fun(*canvas_interface(), &synfigapp::CanvasInterface::update_keyframe)));
1074 //
1075 //              keyframe_tree->signal_event().connect(sigc::mem_fun(*this, &studio::CanvasView::on_keyframe_tree_event));
1076 //
1077 //              Gtk::ScrolledWindow *scroll_layer_tree = manage(new class Gtk::ScrolledWindow());
1078 //              scroll_layer_tree->set_flags(Gtk::CAN_FOCUS);
1079 //              scroll_layer_tree->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
1080 //              scroll_layer_tree->add(*keyframe_tree);
1081 //              scroll_layer_tree->set_shadow_type(Gtk::SHADOW_ETCHED_IN);
1082 //              //scroll_layer_tree->show();
1083 //
1084 //
1085 //              Gtk::Table *layout_table= manage(new Gtk::Table(1, 2, false));
1086 //              layout_table->attach(*scroll_layer_tree, 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
1087 //
1088 //              Gtk::Image *icon;
1089 //              Gtk::IconSize iconsize(Gtk::IconSize::from_name("synfig-small_icon"));
1090 //
1091 //              NEW_SMALL_BUTTON(button_add,"gtk-add",_("New Keyframe"));
1092 //              NEW_SMALL_BUTTON(button_duplicate,"synfig-duplicate",_("Duplicate Keyframe"));
1093 //              NEW_SMALL_BUTTON(button_delete,"gtk-delete",_("Delete Keyframe"));
1094 //
1095 //              Gtk::HBox *hbox(manage(new Gtk::HBox()));
1096 //              layout_table->attach(*hbox, 0, 1, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK, 0, 0);
1097 //
1098 //              hbox->pack_start(*button_add,Gtk::PACK_SHRINK);
1099 //              hbox->pack_start(*button_duplicate,Gtk::PACK_SHRINK);
1100 //              hbox->pack_start(*button_delete,Gtk::PACK_SHRINK);
1101 //
1102 //              /*
1103 //              button_raise->set_relief(Gtk::RELIEF_HALF);
1104 //              button_lower->set_relief(Gtk::RELIEF_HALF);
1105 //              button_duplicate->set_relief(Gtk::RELIEF_HALF);
1106 //              button_delete->set_relief(Gtk::RELIEF_HALF);
1107 //              */
1108 //
1109 //              button_add->signal_clicked().connect(sigc::mem_fun(*this, &studio::CanvasView::on_keyframe_add_pressed));
1110 //              button_duplicate->signal_clicked().connect(sigc::mem_fun(*this, &studio::CanvasView::on_keyframe_duplicate_pressed));
1111 //              button_delete->signal_clicked().connect(sigc::mem_fun(*this, &studio::CanvasView::on_keyframe_remove_pressed));
1112 //
1113 //              //layout_table->show_all();
1114 //
1115 //              keyframe_tab_child=layout_table;
1116 //
1117 //
1118 //              layout_table->hide();
1119 //
1120 //              return layout_table;
1121 //      }
1122
1123 //      Gtk::Widget*
1124 //      CanvasView::create_layer_tree()
1125 //      {
1126 //              // Create the layer tree
1127 //              printf("CanvasView::create_layer_tree()\n");
1128 //              layer_tree=manage(new class LayerTree());
1129 //
1130 //              // Set up the layer tree
1131 //              //layer_tree->set_model(layer_tree_store());
1132 //              layer_tree->set_time_adjustment(time_adjustment());
1133 //              layer_tree->show();
1134 //
1135 //              // Connect Signals
1136 //              layer_tree->signal_layer_toggle().connect(sigc::mem_fun(*this, &studio::CanvasView::on_layer_toggle));
1137 //              layer_tree->signal_edited_value().connect(sigc::mem_fun(*this, &studio::CanvasView::on_edited_value));
1138 //              layer_tree->signal_layer_user_click().connect(sigc::mem_fun(*this, &studio::CanvasView::on_layer_user_click));
1139 //              layer_tree->signal_param_user_click().connect(sigc::mem_fun(*this, &studio::CanvasView::on_children_user_click));
1140 //              layer_tree->signal_waypoint_clicked_layertree().connect(sigc::mem_fun(*this, &studio::CanvasView::on_waypoint_clicked_canvasview));
1141 //              layer_tree->get_selection()->signal_changed().connect(SLOT_EVENT(EVENT_REFRESH_DUCKS));
1142 //
1143 //              layer_tree->hide();
1144 //              return layer_tree;
1145 //      }
1146
1147 void
1148 CanvasView::init_menus()
1149 {
1150 /*
1151         mainmenu.set_accel_group(get_accel_group());
1152         mainmenu.set_accel_path("<Canvas-view>");
1153
1154         filemenu.set_accel_group(get_accel_group());
1155         filemenu.set_accel_path("<Canvas-view>/File");
1156
1157         editmenu.set_accel_group(get_accel_group());
1158         editmenu.set_accel_path("<Canvas-view>/Edit");
1159
1160         layermenu.set_accel_group(get_accel_group());
1161         layermenu.set_accel_path("<Canvas-view>/Layer");
1162 */
1163         //cache the position of desired widgets
1164
1165         /*Menus to worry about:
1166         - filemenu
1167         - editmenu
1168         - layermenu
1169         - duckmaskmenu
1170         - mainmenu
1171         - canvasmenu
1172         - viewmenu
1173         */
1174         action_group = Gtk::ActionGroup::create();
1175
1176         //action_group->add( Gtk::Action::create("MenuFile", _("_File")) );
1177         action_group->add( Gtk::Action::create("new", Gtk::Stock::NEW),
1178                 sigc::hide_return(sigc::ptr_fun(&studio::App::new_instance))
1179         );
1180         action_group->add( Gtk::Action::create("open", Gtk::Stock::OPEN),
1181                 sigc::hide_return(sigc::mem_fun(*get_instance().get(), &studio::Instance::open))
1182         );
1183         action_group->add( Gtk::Action::create("save", Gtk::Stock::SAVE),
1184                 hide_return(sigc::mem_fun(*get_instance().get(), &studio::Instance::save))
1185         );
1186         action_group->add( Gtk::Action::create("save-as", Gtk::Stock::SAVE_AS),
1187                 sigc::hide_return(sigc::mem_fun(*get_instance().get(), &studio::Instance::dialog_save_as))
1188         );
1189         action_group->add( Gtk::Action::create("revert", Gtk::Stock::REVERT_TO_SAVED),
1190                 sigc::hide_return(sigc::mem_fun(*get_instance().get(), &studio::Instance::safe_revert))
1191         );
1192         action_group->add( Gtk::Action::create("cvs-add", Gtk::StockID("synfig-cvs_add")),
1193                 sigc::hide_return(sigc::mem_fun(*get_instance(), &studio::Instance::dialog_cvs_add))
1194         );
1195         action_group->add( Gtk::Action::create("cvs-update", Gtk::StockID("synfig-cvs_update")),
1196                 sigc::hide_return(sigc::mem_fun(*get_instance(), &studio::Instance::dialog_cvs_update))
1197         );
1198         action_group->add( Gtk::Action::create("cvs-revert", Gtk::StockID("synfig-cvs_revert")),
1199                 sigc::hide_return(sigc::mem_fun(*get_instance(), &studio::Instance::dialog_cvs_revert))
1200         );
1201         action_group->add( Gtk::Action::create("cvs-commit", Gtk::StockID("synfig-cvs_commit")),
1202                 sigc::hide_return(sigc::mem_fun(*get_instance(), &studio::Instance::dialog_cvs_commit))
1203         );
1204         action_group->add( Gtk::Action::create("import", _("Import")),
1205                 sigc::hide_return(sigc::mem_fun(*this, &studio::CanvasView::image_import))
1206         );
1207         action_group->add( Gtk::Action::create("render", _("Render")),
1208                 sigc::mem_fun0(render_settings,&studio::RenderSettings::present)
1209         );
1210         action_group->add( Gtk::Action::create("preview", _("Preview")),
1211                 sigc::mem_fun(*this,&CanvasView::on_preview_option)
1212         );
1213         action_group->add( Gtk::Action::create("sound", _("Sound File")),
1214                 sigc::mem_fun(*this,&CanvasView::on_audio_option)
1215         );
1216         action_group->add( Gtk::Action::create("options", _("Options")),
1217                 sigc::mem_fun0(canvas_options,&studio::CanvasOptions::present)
1218         );
1219         action_group->add( Gtk::Action::create("close", Gtk::StockID("gtk-close"), _("Close Window")),
1220                 sigc::hide_return(sigc::mem_fun(*this,&studio::CanvasView::close_view))
1221         );
1222         action_group->add( Gtk::Action::create("close-document", Gtk::StockID("gtk-close"), _("Close Document")),
1223                 sigc::hide_return(sigc::mem_fun(*this,&studio::CanvasView::close_instance))
1224         );
1225         action_group->add( Gtk::Action::create("quit", Gtk::StockID("gtk-quit"), _("Quit")),
1226                 sigc::hide_return(sigc::ptr_fun(&studio::App::quit))
1227         );
1228
1229         //action_group->add( Gtk::Action::create("undo", Gtk::StockID("gtk-undo")),
1230         //      SLOT_EVENT(EVENT_UNDO)
1231         //);
1232
1233         //action_group->add( Gtk::Action::create("redo", Gtk::StockID("gtk-redo")),
1234         //      SLOT_EVENT(EVENT_REDO)
1235         //);
1236
1237         action_group->add( Gtk::Action::create("select-all-ducks", _("Select All Ducks")),
1238                 sigc::mem_fun(*work_area,&studio::WorkArea::select_all_ducks)
1239         );
1240
1241         action_group->add( Gtk::Action::create("unselect-all-layers", _("Unselect All Layers")),
1242                 sigc::mem_fun(*this,&CanvasView::on_unselect_layers)
1243         );
1244
1245         action_group->add( Gtk::Action::create("stop", Gtk::StockID("gtk-stop")),
1246                 SLOT_EVENT(EVENT_STOP)
1247         );
1248
1249         action_group->add( Gtk::Action::create("refresh", Gtk::StockID("gtk-refresh")),
1250                 SLOT_EVENT(EVENT_REFRESH)
1251         );
1252
1253         action_group->add( Gtk::Action::create("properties", Gtk::StockID("gtk-properties")),
1254                 sigc::mem_fun0(canvas_properties,&studio::CanvasProperties::present)
1255         );
1256
1257         // Preview Quality Menu
1258         {
1259                 int i;
1260                 action_group->add( Gtk::RadioAction::create(quality_group,"quality-00", _("Use Parametric Renderer")),
1261                         sigc::bind(
1262                                 sigc::mem_fun(*work_area, &studio::WorkArea::set_quality),
1263                                 0
1264                         )
1265                 );
1266                 for(i=1;i<=10;i++)
1267                 {
1268                         String note;
1269                         if (i == 1) note = _(" (best)");
1270                         if (i == 10) note = _(" (fastest)");
1271                         Glib::RefPtr<Gtk::RadioAction> action(Gtk::RadioAction::create(quality_group,strprintf("quality-%02d",i),
1272                                                                                                                                                    strprintf(_("Set Quality to %d"),i) + note));
1273                         if (i==8)                       // default quality
1274                         {
1275                                 action->set_active();
1276                                 work_area->set_quality(i);
1277                         }
1278                         action_group->add( action,
1279                                 sigc::bind(
1280                                         sigc::mem_fun(*work_area, &studio::WorkArea::set_quality),
1281                                         i
1282                                 )
1283                         );
1284                 }
1285         }
1286
1287         // Low-Res Quality Menu
1288         {
1289                 int i;
1290                 for(list<int>::iterator iter = CanvasView::get_pixel_sizes().begin(); iter != CanvasView::get_pixel_sizes().end(); iter++)
1291                 {
1292                         i = *iter;
1293                         Glib::RefPtr<Gtk::RadioAction> action(Gtk::RadioAction::create(low_res_pixel_size_group,strprintf("lowres-pixel-%d",i),
1294                                                                                                                                                    strprintf(_("Set Low-Res pixel size to %d"),i)));
1295                         if(i==2)                        // default pixel size
1296                         {
1297                                 action->set_active();
1298                                 work_area->set_low_res_pixel_size(i);
1299                         }
1300                         action_group->add( action,
1301                                 sigc::bind(
1302                                         sigc::mem_fun(*work_area, &studio::WorkArea::set_low_res_pixel_size),
1303                                         i
1304                                 )
1305                         );
1306                 }
1307
1308                 Glib::RefPtr<Gtk::Action> action;
1309
1310                 action=Gtk::Action::create("decrease-low-res-pixel-size", _("Decrease Low-Res Pixel Size"));
1311                 action_group->add( action,sigc::mem_fun(this, &studio::CanvasView::decrease_low_res_pixel_size));
1312
1313                 action=Gtk::Action::create("increase-low-res-pixel-size",  _("Increase Low-Res Pixel Size"));
1314                 action_group->add( action, sigc::mem_fun(this, &studio::CanvasView::increase_low_res_pixel_size));
1315
1316         }
1317
1318         action_group->add( Gtk::Action::create("play", Gtk::Stock::MEDIA_PLAY),
1319                 sigc::mem_fun(*this, &studio::CanvasView::play)
1320         );
1321
1322         action_group->add( Gtk::Action::create("dialog-flipbook", _("Flipbook Dialog")),
1323                 sigc::mem_fun0(*preview_dialog, &studio::Dialog_Preview::present)
1324         );
1325
1326         {
1327                 Glib::RefPtr<Gtk::ToggleAction> action;
1328
1329                 grid_show_toggle = Gtk::ToggleAction::create("toggle-grid-show", _("Show Grid"));
1330                 grid_show_toggle->set_active(work_area->grid_status());
1331                 action_group->add(grid_show_toggle, sigc::mem_fun(*work_area, &studio::WorkArea::toggle_grid));
1332
1333                 grid_snap_toggle = Gtk::ToggleAction::create("toggle-grid-snap", _("Snap to Grid"));
1334                 grid_snap_toggle->set_active(work_area->get_grid_snap());
1335                 action_group->add(grid_snap_toggle, sigc::mem_fun(*work_area, &studio::WorkArea::toggle_grid_snap));
1336
1337                 action = Gtk::ToggleAction::create("toggle-guide-show", _("Show Guides"));
1338                 action->set_active(work_area->get_show_guides());
1339                 action_group->add(action, sigc::mem_fun(*work_area, &studio::WorkArea::toggle_guide_snap));
1340
1341                 action = Gtk::ToggleAction::create("toggle-low-res", _("Use Low-Res"));
1342                 action->set_active(work_area->get_low_resolution_flag());
1343                 action_group->add(action, sigc::mem_fun(*work_area, &studio::WorkArea::toggle_low_resolution_flag));
1344
1345                 action = Gtk::ToggleAction::create("toggle-onion-skin", _("Show Onion Skin"));
1346                 action->set_active(work_area->get_onion_skin());
1347                 action_group->add(action, sigc::mem_fun(*work_area, &studio::WorkArea::toggle_onion_skin));
1348         }
1349
1350         action_group->add( Gtk::Action::create("canvas-zoom-fit", Gtk::StockID("gtk-zoom-fit")),
1351                 sigc::mem_fun(*work_area, &studio::WorkArea::zoom_fit)
1352         );
1353         action_group->add( Gtk::Action::create("canvas-zoom-100", Gtk::StockID("gtk-zoom-100")),
1354                 sigc::mem_fun(*work_area, &studio::WorkArea::zoom_norm)
1355         );
1356
1357         {
1358                 Glib::RefPtr<Gtk::Action> action;
1359
1360                 action=Gtk::Action::create("seek-next-frame", Gtk::Stock::GO_FORWARD,_("Next Frame"),_("Next Frame"));
1361                 action_group->add(action,sigc::bind(sigc::mem_fun(*canvas_interface().get(), &synfigapp::CanvasInterface::seek_frame),1));
1362                 action=Gtk::Action::create("seek-prev-frame", Gtk::Stock::GO_BACK,_("Prev Frame"),_("Prev Frame"));
1363                 action_group->add( action, sigc::bind(sigc::mem_fun(*canvas_interface().get(), &synfigapp::CanvasInterface::seek_frame),-1));
1364
1365                 action=Gtk::Action::create("seek-next-second", Gtk::Stock::GO_FORWARD,_("Seek Forward"),_("Seek Forward"));
1366                 action_group->add(action,sigc::bind(sigc::mem_fun(*canvas_interface().get(), &synfigapp::CanvasInterface::seek_time),Time(1)));
1367                 action=Gtk::Action::create("seek-prev-second", Gtk::Stock::GO_BACK,_("Seek Backward"),_("Seek Backward"));
1368                 action_group->add( action, sigc::bind(sigc::mem_fun(*canvas_interface().get(), &synfigapp::CanvasInterface::seek_time),Time(-1)));
1369
1370                 action=Gtk::Action::create("seek-end", Gtk::Stock::GOTO_LAST,_("Seek to End"),_("Seek to End"));
1371                 action_group->add(action,sigc::bind(sigc::mem_fun(*canvas_interface().get(), &synfigapp::CanvasInterface::seek_time),Time::end()));
1372
1373                 action=Gtk::Action::create("seek-begin", Gtk::Stock::GOTO_FIRST,_("Seek to Begin"),_("Seek to Begin"));
1374                 action_group->add( action, sigc::bind(sigc::mem_fun(*canvas_interface().get(), &synfigapp::CanvasInterface::seek_time),Time::begin()));
1375
1376                 action=Gtk::Action::create("jump-next-keyframe", Gtk::Stock::GO_FORWARD,_("Jump to Next Keyframe"),_("Jump to Next Keyframe"));
1377                 action_group->add( action,sigc::mem_fun(*canvas_interface().get(), &synfigapp::CanvasInterface::jump_to_next_keyframe));
1378
1379                 action=Gtk::Action::create("jump-prev-keyframe", Gtk::Stock::GO_BACK,_("Jump to Prev Keyframe"),_("Jump to Prev Keyframe"));
1380                 action_group->add( action,sigc::mem_fun(*canvas_interface().get(), &synfigapp::CanvasInterface::jump_to_prev_keyframe));
1381
1382                 action=Gtk::Action::create("canvas-zoom-in", Gtk::Stock::ZOOM_IN);
1383                 action_group->add( action,sigc::mem_fun(*work_area, &studio::WorkArea::zoom_in));
1384
1385                 action=Gtk::Action::create("canvas-zoom-out", Gtk::Stock::ZOOM_OUT);
1386                 action_group->add( action, sigc::mem_fun(*work_area, &studio::WorkArea::zoom_out) );
1387
1388                 action=Gtk::Action::create("time-zoom-in", Gtk::Stock::ZOOM_IN, _("Zoom In on Timeline"));
1389                 action_group->add( action, sigc::mem_fun(*this, &studio::CanvasView::time_zoom_in) );
1390
1391                 action=Gtk::Action::create("time-zoom-out", Gtk::Stock::ZOOM_OUT, _("Zoom Out on Timeline"));
1392                 action_group->add( action, sigc::mem_fun(*this, &studio::CanvasView::time_zoom_out) );
1393
1394         }
1395
1396         {
1397                 Glib::RefPtr<Gtk::ToggleAction> action;
1398
1399 #define DUCK_MASK(lower,upper,string)                                                                                           \
1400                 action=Gtk::ToggleAction::create("mask-" #lower "-ducks", string);                      \
1401                 action->set_active((bool)(work_area->get_type_mask()&Duck::TYPE_##upper));      \
1402                 action_group->add(action,                                                                                                       \
1403                         sigc::bind(                                                                                                                             \
1404                                 sigc::mem_fun(*this, &studio::CanvasView::toggle_duck_mask),            \
1405                                 Duck::TYPE_##upper))
1406
1407                 DUCK_MASK(position,POSITION,_("Show Position Ducks"));
1408                 DUCK_MASK(tangent,TANGENT,_("Show Tangent Ducks"));
1409                 DUCK_MASK(vertex,VERTEX,_("Show Vertex Ducks"));
1410                 DUCK_MASK(radius,RADIUS,_("Show Radius Ducks"));
1411                 DUCK_MASK(width,WIDTH,_("Show Width Ducks"));
1412                 DUCK_MASK(angle,ANGLE,_("Show Angle Ducks"));
1413
1414 #undef DUCK_MASK
1415         }
1416
1417         add_accel_group(App::ui_manager()->get_accel_group());
1418
1419 /*      // Here is where we add the actions that may have conflicting
1420         // keyboard accelerators.
1421         {
1422                 Glib::RefPtr<Gtk::ActionGroup> accel_action_group(Gtk::ActionGroup::create("canvas_view"));
1423                 Glib::RefPtr<Gtk::Action> action;
1424
1425                 action=Gtk::Action::create("seek-next-frame", Gtk::StockID("gtk-forward"),_("Next Frame"),_("Next Frame"));
1426                 accel_action_group->add(action,sigc::bind(sigc::mem_fun(*canvas_interface().get(), &synfigapp::CanvasInterface::seek),1));
1427
1428                 action=Gtk::Action::create("seek-prev-frame", Gtk::StockID("gtk-forward"),_("Prev Frame"),_("Prev Frame"));
1429                 accel_action_group->add( action, sigc::bind(sigc::mem_fun(*canvas_interface().get(), &synfigapp::CanvasInterface::seek),-1));
1430
1431                 action=Gtk::Action::create("jump-next-keyframe", Gtk::StockID("gtk-forward"),_("Jump to Next Keyframe"),_("Jump to Next Keyframe"));
1432                 accel_action_group->add( action,sigc::mem_fun(*canvas_interface().get(), &synfigapp::CanvasInterface::jump_to_next_keyframe));
1433
1434                 action=Gtk::Action::create("jump-prev-keyframe", Gtk::StockID("gtk-back"),_("Jump to Prev Keyframe"),_("Jump to Prev Keyframe"));
1435                 accel_action_group->add( action,sigc::mem_fun(*canvas_interface().get(), &synfigapp::CanvasInterface::jump_to_prev_keyframe));
1436
1437                 action=Gtk::Action::create("canvas-zoom-in", Gtk::StockID("gtk-zoom-in"));
1438                 accel_action_group->add( action,sigc::mem_fun(*work_area, &studio::WorkArea::zoom_in));
1439
1440                 action=Gtk::Action::create("canvas-zoom-out", Gtk::StockID("gtk-zoom-out"));
1441                 accel_action_group->add( action, sigc::mem_fun(*work_area, &studio::WorkArea::zoom_out) );
1442
1443                 action=Gtk::Action::create("time-zoom-in", Gtk::StockID("gtk-zoom-in"), _("Zoom In on Timeline"));
1444                 accel_action_group->add( action, sigc::mem_fun(*this, &studio::CanvasView::time_zoom_in) );
1445
1446                 action=Gtk::Action::create("time-zoom-out", Gtk::StockID("gtk-zoom-out"), _("Zoom Out on Timeline"));
1447                 accel_action_group->add( action, sigc::mem_fun(*this, &studio::CanvasView::time_zoom_out) );
1448
1449                 Glib::RefPtr<Gtk::UIManager> accel_ui_manager(Gtk::UIManager::create());
1450
1451                 Glib::ustring ui_info =
1452                 "
1453                 <ui>
1454                         <accelerator action='seek-next-frame' />
1455                         <accelerator action='seek-prev-frame' />
1456                         <accelerator action='jump-next-keyframe' />
1457                         <accelerator action='jump-prev-keyframe' />
1458                         <accelerator action='canvas-zoom-in' />
1459                         <accelerator action='canvas-zoom-out' />
1460                         <accelerator action='time-zoom-in' />
1461                         <accelerator action='time-zoom-out' />
1462                 </ui>
1463                 ";
1464
1465                 accel_ui_manager->add_ui_from_string(ui_info);
1466                 add_accel_group(accel_ui_manager->get_accel_group());
1467
1468                 accel_ui_manager->insert_action_group(accel_action_group);
1469                 set_ref_obj("accel_ui_manager",accel_ui_manager);
1470                 set_ref_obj("accel_action_group",accel_action_group);
1471         }
1472 */
1473
1474 #if 0
1475 //
1476 //      //Test some key stuff
1477 //
1478 //      filemenu.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::StockID("gtk-save"),
1479 //              hide_return(sigc::mem_fun(*get_instance().get(), &studio::Instance::save))));
1480 //      filemenu.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::StockID("gtk-save-as"),sigc::hide_return(sigc::mem_fun(*get_instance(), &studio::Instance::dialog_save_as))));
1481 //      filemenu.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::StockID("gtk-revert-to-saved"),hide_return(sigc::mem_fun(*get_instance().get(), &studio::Instance::safe_revert))));
1482 //      filemenu.items().push_back(Gtk::Menu_Helpers::SeparatorElem());
1483 //
1484 //      filemenu.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::StockID("synfig-cvs_add"),sigc::hide_return(sigc::mem_fun(*get_instance(), &studio::Instance::dialog_cvs_add))));
1485 //      filemenu.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::StockID("synfig-cvs_update"),sigc::hide_return(sigc::mem_fun(*get_instance(), &studio::Instance::dialog_cvs_update))));
1486 //      filemenu.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::StockID("synfig-cvs_commit"),sigc::hide_return(sigc::mem_fun(*get_instance(), &studio::Instance::dialog_cvs_commit))));
1487 //
1488 //      filemenu.items().push_back(Gtk::Menu_Helpers::SeparatorElem());
1489 //      filemenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("Import..."),Gtk::AccelKey('I',Gdk::CONTROL_MASK),sigc::hide_return(sigc::mem_fun(*this, &studio::CanvasView::image_import))));
1490 //      filemenu.items().push_back(Gtk::Menu_Helpers::SeparatorElem());
1491 //      filemenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("Render"),Gtk::AccelKey("F9"),
1492 //              sigc::mem_fun(render_settings,&studio::RenderSettings::present)
1493 //      ));
1494 //      filemenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("Preview"),Gtk::AccelKey("F11"),
1495 //              sigc::mem_fun(*this,&CanvasView::on_preview_option)
1496 //      ));
1497 //      filemenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("Sound File"),
1498 //              sigc::mem_fun(*this,&CanvasView::on_audio_option)
1499 //      ));
1500 //
1501 //      filemenu.items().push_back(Gtk::Menu_Helpers::SeparatorElem());
1502 //      filemenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("Options"),Gtk::AccelKey("F12"),
1503 //              sigc::mem_fun(canvas_options,&studio::CanvasOptions::present)
1504 //      ));
1505 //      filemenu.items().push_back(Gtk::Menu_Helpers::SeparatorElem());
1506 //      filemenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("Close View"),
1507 //              sigc::hide_return(sigc::mem_fun(*this,&studio::CanvasView::close_view))
1508 //      ));
1509 //      filemenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("Close Document"),
1510 //              sigc::hide_return(sigc::mem_fun(*this,&studio::CanvasView::close_document))
1511 //      ));
1512 //
1513 //      editmenu.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::StockID("gtk-undo"),Gtk::AccelKey('Z',Gdk::CONTROL_MASK),SLOT_EVENT(EVENT_UNDO)));
1514 //      editmenu.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::StockID("gtk-redo"),Gtk::AccelKey('R',Gdk::CONTROL_MASK),SLOT_EVENT(EVENT_REDO)));
1515 //      editmenu.items().push_back(Gtk::Menu_Helpers::SeparatorElem());
1516 //      editmenu.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::StockID("gtk-cut"),NOT_IMPLEMENTED_SLOT));
1517 //      editmenu.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::StockID("gtk-copy"),NOT_IMPLEMENTED_SLOT));
1518 //      editmenu.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::StockID("gtk-paste"),NOT_IMPLEMENTED_SLOT));
1519 //      editmenu.items().push_back(Gtk::Menu_Helpers::SeparatorElem());
1520 //      editmenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("Select All Ducks"),Gtk::AccelKey('E',Gdk::CONTROL_MASK),sigc::mem_fun(*work_area,&studio::WorkArea::select_all_ducks)));
1521 //      editmenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("Unselect All Layers"),Gtk::AccelKey('D',Gdk::CONTROL_MASK),sigc::mem_fun(*this,&CanvasView::on_unselect_layers)));
1522 //      editmenu.items().push_back(Gtk::Menu_Helpers::SeparatorElem());
1523 //
1524 //      //editmenu.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::StockID("gtk-stop"),Gtk::AccelKey(GDK_Escape,static_cast<Gdk::ModifierType>(0)),sigc::hide_return(sigc::mem_fun(*this, &studio::CanvasView::stop))));
1525 //      //editmenu.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::StockID("gtk-refresh"),Gtk::AccelKey('k',Gdk::CONTROL_MASK),sigc::hide_return(sigc::mem_fun(*this, &studio::CanvasView::on_refresh_pressed))));
1526 //      editmenu.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::StockID("gtk-stop"),Gtk::AccelKey(GDK_Escape,static_cast<Gdk::ModifierType>(0)),SLOT_EVENT(EVENT_STOP)));
1527 //      editmenu.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::StockID("gtk-refresh"),Gtk::AccelKey('k',Gdk::CONTROL_MASK),SLOT_EVENT(EVENT_REFRESH)));
1528 //      editmenu.items().push_back(Gtk::Menu_Helpers::SeparatorElem());
1529 //      editmenu.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::StockID("gtk-properties"),Gtk::AccelKey("F8"),
1530 //              sigc::mem_fun(canvas_properties,&studio::CanvasProperties::present)
1531 //      ));
1532 //
1533 //      build_new_layer_menu(newlayermenu);
1534 //      layermenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("New"),newlayermenu));
1535 //
1536 //
1537 //      {
1538 //              synfigapp::Action::ParamList param_list;
1539 //              param_list.add("canvas",Canvas::Handle(get_canvas()));
1540 //              param_list.add("canvas_interface",canvas_interface());
1541 //              add_actions_to_menu(&canvasmenu, param_list,synfigapp::Action::CATEGORY_CANVAS);
1542 //      }
1543 //
1544 //
1545 //      //canvasmenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("Keyframe Dialog"),sigc::mem_fun(keyframe_dialog,&studio::Dialog_Keyframe::present)));
1546 //
1547 //      // Duck Mask Menu
1548 //      if(1)
1549 //              {
1550 //              duckmaskmenu.items().push_back(Gtk::Menu_Helpers::TearoffMenuElem());
1551 //
1552 //              duckmaskmenu.items().push_back(Gtk::Menu_Helpers::CheckMenuElem(_("Position Ducks"),Gtk::AccelKey('1',Gdk::MOD1_MASK)));
1553 //              duck_mask_position=static_cast<Gtk::CheckMenuItem*>(&duckmaskmenu.items().back());
1554 //              duck_mask_position->set_active((bool)(work_area->get_type_mask()&Duck::TYPE_POSITION));
1555 //              duck_mask_position->signal_toggled().connect(
1556 //                      sigc::bind(
1557 //                              sigc::mem_fun(*this, &studio::CanvasView::toggle_duck_mask),
1558 //                              Duck::TYPE_POSITION
1559 //                      )
1560 //              );
1561 //
1562 //              duckmaskmenu.items().push_back(Gtk::Menu_Helpers::CheckMenuElem(_("Vertex Ducks"),Gtk::AccelKey('2',Gdk::MOD1_MASK)));
1563 //              duck_mask_vertex=static_cast<Gtk::CheckMenuItem*>(&duckmaskmenu.items().back());
1564 //              duck_mask_vertex->set_active((bool)(work_area->get_type_mask()&Duck::TYPE_VERTEX));
1565 //              duck_mask_vertex->signal_toggled().connect(
1566 //                      sigc::bind(
1567 //                              sigc::mem_fun(*this, &studio::CanvasView::toggle_duck_mask),
1568 //                              Duck::TYPE_VERTEX
1569 //                      )
1570 //              );
1571 //
1572 //              duckmaskmenu.items().push_back(Gtk::Menu_Helpers::CheckMenuElem(_("Tangent Ducks"),Gtk::AccelKey('3',Gdk::MOD1_MASK)));
1573 //              duck_mask_tangent=static_cast<Gtk::CheckMenuItem*>(&duckmaskmenu.items().back());
1574 //              duck_mask_tangent->set_active((bool)(work_area->get_type_mask()&Duck::TYPE_TANGENT));
1575 //              duck_mask_tangent->signal_toggled().connect(
1576 //                      sigc::bind(
1577 //                              sigc::mem_fun(*this, &studio::CanvasView::toggle_duck_mask),
1578 //                              Duck::TYPE_TANGENT
1579 //                      )
1580 //              );
1581 //
1582 //              duckmaskmenu.items().push_back(Gtk::Menu_Helpers::CheckMenuElem(_("Radius Ducks"),Gtk::AccelKey('4',Gdk::MOD1_MASK)));
1583 //              duck_mask_radius=static_cast<Gtk::CheckMenuItem*>(&duckmaskmenu.items().back());
1584 //              duck_mask_radius->set_active((bool)(work_area->get_type_mask()&Duck::TYPE_RADIUS));
1585 //              duck_mask_radius->signal_toggled().connect(
1586 //                      sigc::bind(
1587 //                              sigc::mem_fun(*this, &studio::CanvasView::toggle_duck_mask),
1588 //                              Duck::TYPE_RADIUS
1589 //                      )
1590 //              );
1591 //
1592 //              duckmaskmenu.items().push_back(Gtk::Menu_Helpers::CheckMenuElem(_("Width Ducks"),Gtk::AccelKey('5',Gdk::MOD1_MASK)));
1593 //              duck_mask_width=static_cast<Gtk::CheckMenuItem*>(&duckmaskmenu.items().back());
1594 //              duck_mask_width->set_active((bool)(work_area->get_type_mask()&Duck::TYPE_WIDTH));
1595 //              duck_mask_width->signal_toggled().connect(
1596 //                      sigc::bind(
1597 //                              sigc::mem_fun(*this, &studio::CanvasView::toggle_duck_mask),
1598 //                              Duck::TYPE_WIDTH
1599 //                      )
1600 //              );
1601 //
1602 //              duckmaskmenu.items().push_back(Gtk::Menu_Helpers::CheckMenuElem(_("Angle Ducks"),Gtk::AccelKey('6',Gdk::MOD1_MASK)));
1603 //              duck_mask_angle=static_cast<Gtk::CheckMenuItem*>(&duckmaskmenu.items().back());
1604 //              duck_mask_angle->set_active((bool)(work_area->get_type_mask()&Duck::TYPE_ANGLE));
1605 //              duck_mask_angle->signal_toggled().connect(
1606 //                      sigc::bind(
1607 //                              sigc::mem_fun(*this, &studio::CanvasView::toggle_duck_mask),
1608 //                              Duck::TYPE_ANGLE
1609 //                      )
1610 //              );
1611 //
1612 //              viewmenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("_Mask Ducks"),duckmaskmenu));
1613 //      }
1614 //
1615 //      // Preview Quality Menu
1616 //      if(1)
1617 //      {
1618 //              qualitymenu.items().push_back(Gtk::Menu_Helpers::TearoffMenuElem());
1619 //              int i;
1620 //              qualitymenu.items().push_back(Gtk::Menu_Helpers::MenuElem(strprintf(_("Use Parametric Renderer"),0),
1621 //                      sigc::bind(
1622 //                              sigc::mem_fun(*work_area, &studio::WorkArea::set_quality),
1623 //                              0
1624 //                      )
1625 //              ));
1626 //              for(i=1;i<=10;i++)
1627 //              {
1628 //                      qualitymenu.items().push_back(Gtk::Menu_Helpers::MenuElem(strprintf(_("Set Quality to %d"),i),Gtk::AccelKey('0'+(i%10),Gdk::CONTROL_MASK),
1629 //                              sigc::bind(
1630 //                                      sigc::mem_fun(*work_area, &studio::WorkArea::set_quality),
1631 //                                      i
1632 //                              )
1633 //                      ));
1634 //              }
1635 //              viewmenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("Preview Quality"),qualitymenu));
1636 //      }
1637 //
1638 //      viewmenu.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::Stock::MEDIA_PLAY,
1639 //              sigc::mem_fun(*this, &studio::CanvasView::play)));
1640 //      viewmenu.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::StockID("Flipbook Dialog"),
1641 //              sigc::mem_fun(*preview_dialog, &studio::Dialog_Preview::present)));
1642 //
1643 //      viewmenu.items().push_back(Gtk::Menu_Helpers::SeparatorElem());
1644 //
1645 //      viewmenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("Toggle Grid Show"),Gtk::AccelKey('g',Gdk::CONTROL_MASK),
1646 //              sigc::mem_fun(*work_area, &studio::WorkArea::toggle_grid)));
1647 //      viewmenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("Toggle Grid Snap"),Gtk::AccelKey('l',Gdk::CONTROL_MASK),
1648 //              sigc::mem_fun(*work_area, &studio::WorkArea::toggle_grid_snap)));
1649 //      viewmenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("Toggle Guide Snap"),Gtk::AccelKey('k',Gdk::CONTROL_MASK),
1650 //              sigc::mem_fun(*work_area, &studio::WorkArea::toggle_guide_snap)));
1651 //      viewmenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("Toggle Low-Res"),Gtk::AccelKey('`',Gdk::CONTROL_MASK),
1652 //              sigc::mem_fun(*work_area, &studio::WorkArea::toggle_low_resolution_flag)));
1653 //
1654 //      viewmenu.items().push_back(Gtk::Menu_Helpers::SeparatorElem());
1655 //
1656 //      viewmenu.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::StockID("gtk-zoom-in"),Gtk::AccelKey('=',static_cast<Gdk::ModifierType>(0)),
1657 //              sigc::mem_fun(*work_area, &studio::WorkArea::zoom_in)));
1658 //      viewmenu.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::StockID("gtk-zoom-out"),Gtk::AccelKey('-',static_cast<Gdk::ModifierType>(0)),
1659 //              sigc::mem_fun(*work_area, &studio::WorkArea::zoom_out)));
1660 //      viewmenu.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::StockID("gtk-zoom-fit"),
1661 //              sigc::mem_fun(*work_area, &studio::WorkArea::zoom_fit)));
1662 //      viewmenu.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::StockID("gtk-zoom-100"),Gtk::AccelKey('`',static_cast<Gdk::ModifierType>(0)),
1663 //              sigc::mem_fun(*work_area, &studio::WorkArea::zoom_norm)));
1664 //      viewmenu.items().push_back(Gtk::Menu_Helpers::SeparatorElem());
1665 //
1666 //      viewmenu.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::StockID("gtk-zoom-in"),Gtk::AccelKey('+',static_cast<Gdk::ModifierType>(0)),
1667 //              sigc::mem_fun(*this, &studio::CanvasView::time_zoom_in)));
1668 //      viewmenu.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::StockID("gtk-zoom-out"),Gtk::AccelKey('_',static_cast<Gdk::ModifierType>(0)),
1669 //              sigc::mem_fun(*this, &studio::CanvasView::time_zoom_out)));
1670 //
1671 //      viewmenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("Jump to Next Keyframe"),Gtk::AccelKey(']',static_cast<Gdk::ModifierType>(0)),
1672 //              sigc::mem_fun(*canvas_interface().get(), &synfigapp::CanvasInterface::jump_to_next_keyframe)));
1673 //      viewmenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("Jump to Prev Keyframe"),Gtk::AccelKey('[',static_cast<Gdk::ModifierType>(0)),
1674 //              sigc::mem_fun(*canvas_interface().get(), &synfigapp::CanvasInterface::jump_to_prev_keyframe)));
1675 //
1676 //      mainmenu.items().push_back(Gtk::Menu_Helpers::TearoffMenuElem());
1677 //      mainmenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("_File"),filemenu));
1678 //      mainmenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("_Edit"),editmenu));
1679 //      mainmenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("_View"),viewmenu));
1680 //      mainmenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("_Canvas"),canvasmenu));
1681 //      mainmenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("_Layer"),layermenu));
1682 //
1683 //      mainmenu.accelerate(*this);
1684 //
1685 ///*
1686 //      {
1687 //
1688 //              trackmenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("New Waypoint"),NOT_IMPLEMENTED_SLOT));
1689 //              trackmenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("Delete Waypoint"),NOT_IMPLEMENTED_SLOT));
1690 //              trackmenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("Export"),NOT_IMPLEMENTED_SLOT));
1691 //              trackmenu.items().push_back(Gtk::Menu_Helpers::SeparatorElem());
1692 //              trackmenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("Properties"),NOT_IMPLEMENTED_SLOT));
1693 //      }
1694 //*/
1695 //      mainmenu.show();
1696 //      filemenu.show();
1697 //      editmenu.show();
1698 //      canvasmenu.show();
1699 //      layermenu.show();
1700 //
1701 //      keyframemenu.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::StockID("gtk-properties"),
1702 //              sigc::mem_fun(*this,&studio::CanvasView::show_keyframe_dialog)
1703 //      ));
1704 //
1705 //
1706 //      get_accel_group()->unlock();
1707 //
1708 //      //Set the accelerator paths for all the menus
1709 //      filemenu.set_accel_path("<synfig>/File");
1710 //      editmenu.set_accel_path("<synfig>/Edit");
1711 //      layermenu.set_accel_path("<synfig>/Layer");
1712 //      //mainmenu.set_accel_path("<synfig-main>");
1713 //      canvasmenu.set_accel_path("<synfig>/Canvas");
1714 //      viewmenu.set_accel_path("<synfig>/View");
1715 //      duckmaskmenu.set_accel_path("<synfig>/DuckMask");
1716 #endif
1717 }
1718
1719 void
1720 CanvasView::on_unselect_layers()
1721 {
1722         layer_tree->clear_selected_layers();
1723 }
1724
1725 void
1726 CanvasView::show_keyframe_dialog()
1727 {
1728         Glib::RefPtr<Gtk::TreeSelection> selection(keyframe_tree->get_selection());
1729         if(selection->get_selected())
1730         {
1731                 Gtk::TreeRow row(*selection->get_selected());
1732
1733                 Keyframe keyframe(row[keyframe_tree->model.keyframe]);
1734
1735                 keyframe_dialog.set_keyframe(keyframe);
1736                 keyframe_dialog.present();
1737         }
1738 }
1739
1740 void
1741 CanvasView::add_layer(synfig::String x)
1742 {
1743         Canvas::Handle canvas;
1744
1745         synfigapp::SelectionManager::LayerList layer_list(get_selection_manager()->get_selected_layers());
1746
1747         int target_depth(0);
1748
1749         if(layer_list.empty())
1750         {
1751                 canvas=get_canvas();
1752         }
1753         else
1754         {
1755                 canvas=(*layer_list.begin())->get_canvas();
1756                 target_depth=canvas->get_depth(*layer_list.begin());
1757         }
1758
1759         Layer::Handle layer(canvas_interface()->add_layer_to(x,canvas,target_depth));
1760         if(layer)
1761         {
1762                 get_selection_manager()->clear_selected_layers();
1763                 get_selection_manager()->set_selected_layer(layer);
1764         }
1765 }
1766
1767 void
1768 CanvasView::popup_layer_menu(synfig::Layer::Handle layer)
1769 {
1770         //Gtk::Menu* menu(manage(new Gtk::Menu));
1771         Gtk::Menu* menu(&parammenu);
1772         menu->items().clear();
1773
1774         synfigapp::Action::ParamList param_list;
1775         param_list.add("time",canvas_interface()->get_time());
1776         param_list.add("canvas",Canvas::Handle(layer->get_canvas()));
1777         param_list.add("canvas_interface",canvas_interface());
1778         param_list.add("layer",layer);
1779
1780         //Gtk::Menu *newlayers(manage(new Gtk::Menu()));
1781         //build_new_layer_menu(*newlayers);
1782
1783         //parammenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("New Layer"),*newlayers));
1784
1785         if(layer->get_name()=="PasteCanvas")
1786         {
1787                 menu->items().push_back(Gtk::Menu_Helpers::MenuElem(_("Select All Children"),
1788                         sigc::bind(
1789                                 sigc::mem_fun(
1790                                         *layer_tree,
1791                                         &studio::LayerTree::select_all_children_layers
1792                                 ),
1793                                 layer
1794                         )
1795                 ));
1796         }
1797
1798         add_actions_to_menu(menu, param_list,synfigapp::Action::CATEGORY_LAYER);
1799
1800         menu->popup(3,gtk_get_current_event_time());
1801 }
1802
1803 void
1804 CanvasView::register_layer_type(synfig::Layer::Book::value_type &/*lyr*/,std::map<synfig::String,Gtk::Menu*>* /*category_map*/)
1805 {
1806 /*      if(lyr.second.category==CATEGORY_DO_NOT_USE)
1807                 return;
1808
1809         if(category_map->count(lyr.second.category)==0)
1810                 (*category_map)[lyr.second.category]=manage(new Gtk::Menu());
1811
1812         (*category_map)[lyr.second.category]->items().push_back(Gtk::Menu_Helpers::MenuElem(lyr.second.local_name,
1813                 sigc::hide_return(
1814                         sigc::bind(
1815                                 sigc::mem_fun(*this,&studio::CanvasView::add_layer),
1816                                 lyr.first
1817                         )
1818                 )
1819         ));
1820 */
1821 }
1822
1823 void
1824 CanvasView::build_new_layer_menu(Gtk::Menu &/*menu*/)
1825 {
1826 /*
1827         std::map<synfig::String,Gtk::Menu*> category_map;
1828
1829         std::for_each(
1830                 synfig::Layer::book().begin(),
1831                 synfig::Layer::book().end(),
1832                 sigc::bind(
1833                         sigc::mem_fun(
1834                                 *this,
1835                                 &studio::CanvasView::register_layer_type
1836                         ),
1837                         &category_map
1838                 )
1839         );
1840
1841         menu.items().clear();
1842         menu.items().push_back(Gtk::Menu_Helpers::TearoffMenuElem());
1843
1844         std::map<synfig::String,Gtk::Menu*>::iterator iter;
1845         for(iter=category_map.begin();iter!=category_map.end();++iter)
1846                 menu.items().push_back(Gtk::Menu_Helpers::MenuElem(iter->first,*iter->second));
1847
1848         menu.show();
1849 */
1850 }
1851
1852 void
1853 CanvasView::popup_main_menu()
1854 {
1855         //mainmenu.popup(0,gtk_get_current_event_time());
1856         Gtk::Menu* menu = dynamic_cast<Gtk::Menu*>(App::ui_manager()->get_widget("/menu-main"));
1857         if(menu)
1858         {
1859                 //menu->set_accel_group(App::ui_manager()->get_accel_group());
1860                 //menu->accelerate(*this);
1861                 menu->popup(0,gtk_get_current_event_time());
1862         }
1863 }
1864
1865 void
1866 CanvasView::on_refresh_pressed()
1867 {
1868         rebuild_tables();
1869         rebuild_ducks();
1870         work_area->queue_render_preview();
1871 }
1872
1873 void
1874 CanvasView::workarea_layer_selected(synfig::Layer::Handle layer)
1875 {
1876         get_selection_manager()->clear_selected_layers();
1877         if(layer)
1878                 get_selection_manager()->set_selected_layer(layer);
1879 }
1880
1881 void
1882 CanvasView::refresh_rend_desc()
1883 {
1884         current_time_widget->set_fps(get_canvas()->rend_desc().get_frame_rate());
1885
1886         //????
1887         //synfig::info("Canvasview: Refreshing render desc info");
1888         if(!get_time().is_equal(time_adjustment().get_value()))
1889         {
1890                 time_adjustment().set_value(get_time());
1891                 time_adjustment().value_changed();
1892         }
1893
1894         Time length(get_canvas()->rend_desc().get_time_end()-get_canvas()->rend_desc().get_time_start());
1895         if(length<DEFAULT_TIME_WINDOW_SIZE)
1896         {
1897                 time_window_adjustment().set_page_increment(length);
1898                 time_window_adjustment().set_page_size(length);
1899         }
1900         else
1901         {
1902                 time_window_adjustment().set_page_increment(DEFAULT_TIME_WINDOW_SIZE);
1903                 time_window_adjustment().set_page_size(DEFAULT_TIME_WINDOW_SIZE);
1904         }
1905
1906         //set the FPS of the timeslider
1907         timeslider->set_global_fps(get_canvas()->rend_desc().get_frame_rate());
1908
1909         //set the beginning and ending time of the time slider
1910         Time begin_time=get_canvas()->rend_desc().get_time_start();
1911         Time end_time=get_canvas()->rend_desc().get_time_end();
1912
1913         // Setup the time_window adjustment
1914         time_window_adjustment().set_lower(begin_time);
1915         time_window_adjustment().set_upper(end_time);
1916         time_window_adjustment().set_step_increment(synfig::Time(1.0/get_canvas()->rend_desc().get_frame_rate()));
1917
1918         //Time length(get_canvas()->rend_desc().get_time_end()-get_canvas()->rend_desc().get_time_start());
1919         if(length < time_window_adjustment().get_page_size())
1920         {
1921                 time_window_adjustment().set_page_increment(length);
1922                 time_window_adjustment().set_page_size(length);
1923         }
1924
1925         /*synfig::info("w: %p - [%.3f,%.3f] (%.3f,%.3f) child: %p\n",
1926                                 &time_window_adjustment_, time_window_adjustment_.get_lower(),
1927                                 time_window_adjustment_.get_upper(),time_window_adjustment_.get_value(),
1928                                 time_window_adjustment_.get_page_size(),time_window_adjustment_.get_child_adjustment()
1929         );*/
1930
1931         time_window_adjustment().changed(); //only non-value stuff was changed
1932
1933         // Setup the time adjustment
1934
1935         //NOTE THESE TWO SHOULD BE CHANGED BY THE changed() CALL ABOVE
1936         //time_adjustment().set_lower(time_window_adjustment().get_value());
1937         //time_adjustment().set_upper(time_window_adjustment().get_value()+time_window_adjustment().get_page_size());
1938
1939 //      time_adjustment().set_lower(get_canvas()->rend_desc().get_time_start());
1940 //      time_adjustment().set_upper(get_canvas()->rend_desc().get_time_end());
1941         time_adjustment().set_step_increment(synfig::Time(1.0/get_canvas()->rend_desc().get_frame_rate()));
1942         time_adjustment().set_page_increment(synfig::Time(1.0));
1943         time_adjustment().set_page_size(0);
1944
1945         time_adjustment().changed();
1946
1947         /*synfig::info("w: %p - [%.3f,%.3f] (%.3f,%.3f) child: %p\n",
1948                                 &time_window_adjustment_, time_window_adjustment_.get_lower(),
1949                                 time_window_adjustment_.get_upper(),time_window_adjustment_.get_value(),
1950                                 time_window_adjustment_.get_page_size(),time_window_adjustment_.get_child_adjustment()
1951         );      */
1952
1953         if(begin_time==end_time)
1954         {
1955                 hide_timebar();
1956         }
1957         else
1958         {
1959                 show_timebar();
1960         }
1961
1962         //clamp time to big bounds...
1963         if(time_adjustment().get_value() < begin_time)
1964         {
1965                 time_adjustment().set_value(begin_time);
1966                 time_adjustment().value_changed();
1967         }
1968
1969         if(time_adjustment().get_value() > end_time)
1970         {
1971                 time_adjustment().set_value(end_time);
1972                 time_adjustment().value_changed();
1973         }
1974
1975         /*synfig::info("Time stats: \n"
1976                                 "w: %p - [%.3f,%.3f] (%.3f,%.3f) child: %p\n"
1977                                 "t: %p - [%.3f,%.3f] %.3f",
1978                                 &time_window_adjustment_, time_window_adjustment_.get_lower(),
1979                                 time_window_adjustment_.get_upper(),time_window_adjustment_.get_value(),
1980                                 time_window_adjustment_.get_page_size(),time_window_adjustment_.get_child_adjustment(),
1981                                 &time_adjustment_,time_adjustment_.get_lower(),time_adjustment_.get_upper(),
1982                                 time_adjustment_.get_value()
1983         );*/
1984
1985         work_area->queue_render_preview();
1986 }
1987
1988 bool
1989 CanvasView::close_view()
1990 {
1991         if(get_instance()->get_visible_canvases()==1)
1992                 close_instance();
1993         else
1994                 hide();
1995         return false;
1996 }
1997
1998 static bool _close_instance(etl::handle<Instance> instance)
1999 {
2000         etl::handle<Instance> argh(instance);
2001         instance->safe_close();
2002         synfig::info("closed");
2003         return false;
2004 }
2005
2006 bool
2007 CanvasView::close_instance()
2008 {
2009 #ifdef SINGLE_THREADED
2010         if (get_work_area()->get_updating())
2011         {
2012                 get_work_area()->stop_updating(true); // stop and mark as cancelled
2013
2014                 // give the workarea chances to stop updating
2015                 Glib::signal_timeout().connect(
2016                         sigc::mem_fun(*this, &CanvasView::close_instance),
2017                         250);
2018         }
2019         else
2020 #endif
2021                 Glib::signal_timeout().connect(
2022                         sigc::bind(sigc::ptr_fun(_close_instance),
2023                                            (etl::handle<Instance>)get_instance()),
2024                         250);
2025         return false;
2026 }
2027
2028 handle<CanvasView>
2029 CanvasView::create(etl::loose_handle<Instance> instance, etl::handle<synfig::Canvas> canvas)
2030 {
2031         etl::handle<studio::CanvasView> view(new CanvasView(instance,instance->synfigapp::Instance::find_canvas_interface(canvas)));
2032         instance->canvas_view_list().push_front(view);
2033         instance->signal_canvas_view_created()(view.get());
2034         return view;
2035 }
2036
2037 void
2038 CanvasView::update_title()
2039 {
2040         string title;
2041
2042         title = strprintf("%s%s\"%s\"",
2043                                           (
2044                                                   get_instance()->get_action_count()
2045                                                   ? "*"
2046                                                   : ""
2047                                           ), (
2048                                                   get_instance()->has_real_filename()
2049                                                   ? (etl::basename(get_instance()->get_file_name()) + " : ").c_str()
2050                                                   : ""
2051                                           ), (
2052                                                   get_canvas()->get_name().empty()
2053                                                   ? get_canvas()->get_id().c_str()
2054                                                   : get_canvas()->get_name().c_str()
2055                                           ));
2056
2057         if(get_instance()->synfigapp::Instance::in_repository())
2058         {
2059                 title+=" (CVS";
2060                 if(get_instance()->synfigapp::Instance::is_modified())
2061                         title+=_("-MODIFIED");
2062                 if(get_instance()->synfigapp::Instance::is_updated())
2063                         title+=_("-UPDATED");
2064                 title+=')';
2065         }
2066
2067         if(get_canvas()->is_root())
2068                 title+=_(" (Root)");
2069
2070         set_title(title);
2071 }
2072
2073 void
2074 CanvasView::on_hide()
2075 {
2076         smach_.egress();
2077         Gtk::Window::on_hide();
2078 }
2079
2080 void
2081 CanvasView::present()
2082 {
2083         grab_focus();//on_focus_in_event(0);
2084         Gtk::Window::present();
2085 }
2086
2087 bool
2088 CanvasView::on_focus_in_event(GdkEventFocus*x)
2089 {
2090         if(studio::App::get_selected_canvas_view()!=this)
2091         {
2092                 if(studio::App::get_selected_canvas_view())
2093                 {
2094                         studio::App::get_selected_canvas_view()->get_smach().process_event(EVENT_YIELD_TOOL_OPTIONS);
2095                         App::ui_manager()->remove_action_group(App::get_selected_canvas_view()->action_group);
2096                 }
2097
2098                 get_smach().process_event(EVENT_REFRESH_TOOL_OPTIONS);
2099
2100                 studio::App::set_selected_canvas_view(this);
2101
2102                 App::ui_manager()->insert_action_group(action_group);
2103         }
2104
2105         // HACK ... Questionable...?
2106         if(x)
2107                 return Gtk::Window::on_focus_in_event(x);
2108
2109         return true;
2110 }
2111
2112 bool
2113 CanvasView::on_focus_out_event(GdkEventFocus*x)
2114 {
2115         //App::ui_manager()->remove_action_group(action_group);
2116         //App::ui_manager()->ensure_update();
2117         return Gtk::Window::on_focus_out_event(x);
2118 }
2119
2120 void
2121 CanvasView::refresh_tables()
2122 {
2123 //      if(layer_tree_store_)layer_tree_store_->refresh();
2124 //      if(children_tree_store_)children_tree_store_->refresh();
2125 }
2126
2127 void
2128 CanvasView::rebuild_tables()
2129 {
2130 //      layer_tree_store_->rebuild();
2131 //      children_tree_store_->rebuild();
2132 }
2133
2134 void
2135 CanvasView::build_tables()
2136 {
2137 //      layer_tree_store_->rebuild();
2138 //      children_tree_store_->rebuild();
2139 }
2140
2141 void
2142 CanvasView::on_layer_toggle(synfig::Layer::Handle layer)
2143 {
2144         synfigapp::Action::Handle action(synfigapp::Action::create("layer_activate"));
2145         assert(action);
2146
2147         if(!action)
2148                 return;
2149
2150         action->set_param("canvas",Canvas::Handle(layer->get_canvas()));
2151         if(!action->set_param("canvas_interface",canvas_interface()))
2152 //      if(!action->set_param("canvas_interface",get_instance()->find_canvas_interface(layer->get_canvas())))
2153                 synfig::error("LayerActivate didn't like CanvasInterface...?");
2154         action->set_param("time",get_time());
2155         action->set_param("layer",layer);
2156         action->set_param("new_status",!layer->active());
2157
2158         assert(action->is_ready());
2159
2160         canvas_interface()->get_instance()->perform_action(action);
2161 }
2162
2163 void
2164 CanvasView::popup_param_menu(synfigapp::ValueDesc value_desc, float location, bool bezier)
2165 {
2166         parammenu.items().clear();
2167         get_instance()->make_param_menu(&parammenu,get_canvas(),value_desc,location,bezier);
2168
2169         parammenu.popup(3,gtk_get_current_event_time());
2170 }
2171
2172 void
2173 CanvasView::add_actions_to_menu(Gtk::Menu *menu, const synfigapp::Action::ParamList &param_list,synfigapp::Action::Category category)const
2174 {
2175         get_instance()->add_actions_to_menu(menu, param_list, category);
2176 }
2177
2178 bool
2179 CanvasView::on_layer_user_click(int button, Gtk::TreeRow /*row*/, LayerTree::ColumnID /*column_id*/)
2180 {
2181         switch(button)
2182         {
2183         case 3:
2184                 {
2185                         Gtk::MenuItem* menu = dynamic_cast<Gtk::MenuItem*>(App::ui_manager()->get_widget("/menu-main/menu-layer"));
2186                         if(menu && menu->get_submenu())
2187                         {
2188                                 //menu->set_accel_group(App::ui_manager()->get_accel_group());
2189                                 //menu->accelerate(*this);
2190                                 menu->get_submenu()->popup(button,gtk_get_current_event_time());
2191                         }
2192
2193                         #if 0
2194                         bool multiple_selected=true;
2195
2196                         if(layer_tree->get_selection()->count_selected_rows()<=1)
2197                                 multiple_selected=false;
2198
2199                         // If the clicked row is not selected, then unselect
2200                         // everything that isn't selected and select this row
2201                         if(multiple_selected && !layer_tree->get_selection()->is_selected(row))
2202                         {
2203                                 layer_tree->get_selection()->unselect_all();
2204                                 layer_tree->get_selection()->select(row);
2205                                 multiple_selected=false;
2206                         }
2207
2208                         if(column_id==COLUMNID_TIME_TRACK)
2209                                 return false;
2210
2211                         //synfigapp::ValueDesc value_desc(row[layer_param_tree_model.value_desc]);
2212                         //ValueNode::Handle value_node(row[layer_param_tree_model.value_node]);
2213                         //ValueNode::Handle parent_value_node;
2214                         //ValueBase value=row[layer_param_tree_model.value];
2215
2216                         //if(row.parent())
2217                         //{
2218                         //      parent_value_node=(*row.parent())[layer_tree_model.value_node];
2219                         //}
2220
2221                         {
2222                                 Layer::Handle layer(row[layer_tree_model.layer]);
2223                                 synfigapp::Action::ParamList param_list;
2224                                 param_list.add("time",canvas_interface()->get_time());
2225                                 param_list.add("canvas",Canvas::Handle(row[layer_tree_model.canvas]));
2226                                 param_list.add("canvas_interface",canvas_interface());
2227                                 if(!multiple_selected)
2228                                         param_list.add("layer",layer);
2229                                 else
2230                                 {
2231                                         synfigapp::SelectionManager::LayerList layer_list(get_selection_manager()->get_selected_layers());
2232                                         synfigapp::SelectionManager::LayerList::iterator iter;
2233
2234                                         for(iter=layer_list.begin();iter!=layer_list.end();++iter)
2235                                                 param_list.add("layer",Layer::Handle(*iter));
2236                                 }
2237
2238                                 parammenu.items().clear();
2239
2240                                 Gtk::Menu *newlayers(manage(new Gtk::Menu()));
2241                                 // do we need this?  the code is all #ifdef'ed out anyway
2242                                 // newlayers->signal_hide().connect(sigc::bind(sigc::ptr_fun(&delete_widget), newlayers));
2243                                 build_new_layer_menu(*newlayers);
2244
2245                                 parammenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("New Layer"),*newlayers));
2246                                 if(!multiple_selected && layer->get_name()=="PasteCanvas")
2247                                 {
2248                                         parammenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("Select All Children"),
2249                                                 sigc::bind(
2250                                                         sigc::mem_fun(
2251                                                                 *layer_tree,
2252                                                                 &studio::LayerTree::select_all_children_layers
2253                                                         ),
2254                                                         layer
2255                                                 )
2256                                         ));
2257                                 }
2258
2259                                 add_actions_to_menu(&parammenu, param_list,synfigapp::Action::CATEGORY_LAYER);
2260                                 parammenu.popup(button,gtk_get_current_event_time());
2261                                 return true;
2262                         }
2263 /*
2264                         else if(column_id==LayerTree::COLUMNID_TIME_TRACK && value_node && handle<synfig::ValueNode_Animated>::cast_dynamic(value_node))
2265                         {
2266                                 // Right-click on time track with animated
2267 //                              trackmenu.popup(0,0);
2268                                 return true;
2269                         }
2270                         else
2271                         {
2272                                 if(!multiple_selected)
2273                                 {
2274                                         popup_param_menu(value_desc);
2275                                         return true;
2276                                 }
2277                                 else
2278                                 {
2279 #warning update me!
2280 #if 0
2281                                         parammenu.items().clear();
2282                                         parammenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("Connect"),
2283                                                 hide_return(sigc::mem_fun(*canvas_interface().get(),&synfigapp::CanvasInterface::connect_selected_layer_params))
2284                                         ));
2285                                         parammenu.items().push_back(Gtk::Menu_Helpers::MenuElem(_("Disconnect"),
2286                                                 hide_return(sigc::mem_fun(*canvas_interface().get(),&synfigapp::CanvasInterface::disconnect_selected_layer_params))
2287                                         ));
2288                                         parammenu.popup(0,0);
2289 #endif
2290                                 }
2291                                 return true;
2292                         }
2293                 */
2294 #endif
2295 }
2296                 return true;
2297                 break;
2298
2299         default:
2300                 return false;
2301                 break;
2302         }
2303 }
2304
2305 bool
2306 CanvasView::on_children_user_click(int button, Gtk::TreeRow row, ChildrenTree::ColumnID column_id)
2307 {
2308         switch(button)
2309         {
2310         case 3:
2311                 {
2312                         if(column_id==COLUMNID_TIME_TRACK)
2313                                 return false;
2314                         if(!(bool)row[children_tree_model.is_canvas])
2315                         {
2316                                 synfigapp::ValueDesc value_desc=row[children_tree_model.value_desc];
2317                                 if (!value_desc)
2318                                 {
2319                                         //! \todo fix properly -- what is the child dialog for?
2320                                         synfig::info("preventing child dialog right-click crash");
2321                                         return true;
2322                                 }
2323                                 assert(value_desc);
2324                                 popup_param_menu(value_desc);
2325                                 return true;
2326                         }
2327                 }
2328                 return true;
2329                 break;
2330
2331         default:
2332                 return false;
2333                 break;
2334         }
2335 }
2336
2337 bool
2338 CanvasView::on_keyframe_tree_event(GdkEvent *event)
2339 {
2340     switch(event->type)
2341     {
2342         case GDK_BUTTON_PRESS:
2343                 switch(event->button.button)
2344                 {
2345                         case 3:
2346                         {
2347                                 //keyframemenu.popup(event->button.button,gtk_get_current_event_time());
2348                                 return true;
2349                         }
2350                         break;
2351                 }
2352                 break;
2353         case GDK_MOTION_NOTIFY:
2354                 break;
2355         case GDK_BUTTON_RELEASE:
2356                 break;
2357         default:
2358                 break;
2359         }
2360         return false;
2361 }
2362
2363 void
2364 CanvasView::refresh_time_window()
2365 {
2366         //THESE SHOULD AUTOMATICALLY BE TAKEN CARE OF
2367         //time_adjustment().set_lower(time_window_adjustment().get_value());
2368         //time_adjustment().set_upper(time_window_adjustment().get_value()+time_window_adjustment().get_page_size());
2369
2370         time_adjustment().set_page_increment(1.0); // One second
2371         time_adjustment().set_page_size(0);
2372
2373         if(get_canvas())
2374                 time_adjustment().set_step_increment(1.0/get_canvas()->rend_desc().get_frame_rate());
2375         time_adjustment().changed();
2376
2377         //NOTE THIS SHOULD HOOK INTO THE CORRECT SIGNALS...
2378         if(children_tree)
2379                 children_tree->queue_draw();
2380 }
2381
2382 void
2383 CanvasView::on_time_changed()
2384 {
2385         Time time(get_time());
2386
2387         current_time_widget->set_value(time);
2388         try {
2389                 get_canvas()->keyframe_list().find(time);
2390                 current_time_widget->modify_text(Gtk::STATE_NORMAL,Gdk::Color("#FF0000"));
2391         }catch(...){
2392                 current_time_widget->modify_text(Gtk::STATE_NORMAL,Gdk::Color("#000000"));
2393         }
2394
2395         if(get_time() != time_adjustment().get_value())
2396         {
2397                 //Recenters the window, causing it to jump (possibly undesirably... but whatever)
2398                 if(time < time_window_adjustment().get_value() ||
2399                         time > time_window_adjustment().get_value()+time_window_adjustment().get_page_size())
2400                 {
2401                         time_window_adjustment().set_value(
2402                                 time-time_window_adjustment().get_page_size()/2
2403                         );
2404                 }
2405                 time_adjustment().set_value(time);
2406                 time_adjustment().value_changed();
2407
2408                 // Shouldn't these trees just hook into
2409                 // the time changed signal...?
2410                 //YES THEY SHOULD...
2411                 if(layer_tree)layer_tree->queue_draw();
2412                 if(children_tree)children_tree->queue_draw();
2413         }
2414 }
2415
2416 void
2417 CanvasView::time_zoom_in()
2418 {
2419         float frame_rate = get_canvas()->rend_desc().get_frame_rate();
2420         Time min_page_size = 2/frame_rate;
2421
2422         time_window_adjustment().set_page_size(time_window_adjustment().get_page_size()*0.75);
2423         if (time_window_adjustment().get_page_size() < min_page_size)
2424                 time_window_adjustment().set_page_size(min_page_size);
2425         time_window_adjustment().set_page_increment(time_window_adjustment().get_page_size());
2426         time_window_adjustment().changed();
2427
2428         refresh_time_window();
2429 }
2430
2431 void
2432 CanvasView::time_zoom_out()
2433 {
2434         Time length = (get_canvas()->rend_desc().get_time_end() -
2435                                    get_canvas()->rend_desc().get_time_start());
2436
2437         time_window_adjustment().set_page_size(time_window_adjustment().get_page_size()/0.75);
2438         if (time_window_adjustment().get_page_size() > length)
2439                 time_window_adjustment().set_page_size(length);
2440         time_window_adjustment().set_page_increment(time_window_adjustment().get_page_size());
2441         time_window_adjustment().changed();
2442
2443         refresh_time_window();
2444 }
2445
2446 void
2447 CanvasView::time_was_changed()
2448 {
2449         synfig::Time time((synfig::Time)(double)time_adjustment().get_value());
2450         set_time(time);
2451 }
2452
2453 void
2454 CanvasView::on_edited_value(synfigapp::ValueDesc value_desc,synfig::ValueBase new_value)
2455 {
2456         canvas_interface()->change_value(value_desc,new_value);
2457 }
2458
2459 /*
2460 void
2461 CanvasView::on_children_edited_value(const Glib::ustring&path_string,synfig::ValueBase value)
2462 {
2463         Gtk::TreePath path(path_string);
2464
2465         const Gtk::TreeRow row = *(children_tree->get_model()->get_iter(path));
2466
2467         assert((bool)row[children_tree_model.is_value_node]);
2468
2469         synfigapp::ValueDesc value_desc=row[children_tree_model.value_desc];
2470         assert(value_desc);
2471
2472         on_edited_value(value_desc,value);
2473 }
2474 */
2475
2476 void
2477 CanvasView::on_id_changed()
2478 {
2479         update_title();
2480 }
2481
2482 void
2483 CanvasView::on_mode_changed(synfigapp::CanvasInterface::Mode mode)
2484 {
2485         // If the animate flag was set in mode...
2486         if(mode&synfigapp::MODE_ANIMATE)
2487         {
2488                 Gtk::Image *icon;
2489                 icon=manage(new Gtk::Image(Gtk::StockID("gtk-no"),Gtk::ICON_SIZE_BUTTON));
2490                 animatebutton->remove();
2491                 animatebutton->add(*icon);
2492                 tooltips.set_tip(*animatebutton,_("In Animate Editing Mode"));
2493                 icon->set_padding(0,0);
2494                 icon->show();
2495         }
2496         else
2497         {
2498                 Gtk::Image *icon;
2499                 icon=manage(new Gtk::Image(Gtk::StockID("gtk-yes"),Gtk::ICON_SIZE_BUTTON));
2500                 animatebutton->remove();
2501                 animatebutton->add(*icon);
2502                 tooltips.set_tip(*animatebutton,_("Not in Animate Editing Mode"));
2503                 icon->set_padding(0,0);
2504                 icon->show();
2505         }
2506
2507         if((mode&synfigapp::MODE_ANIMATE_FUTURE) && (mode&synfigapp::MODE_ANIMATE_PAST))
2508         {
2509                 Gtk::Image *icon;
2510                 icon=manage(new Gtk::Image(Gtk::StockID("synfig-keyframe_lock_all"),Gtk::ICON_SIZE_BUTTON));
2511                 keyframebutton->remove();
2512                 keyframebutton->add(*icon);
2513                 tooltips.set_tip(*keyframebutton,_("All Keyframes Locked"));
2514                 icon->set_padding(0,0);
2515                 icon->show();
2516         }
2517         else if((mode&synfigapp::MODE_ANIMATE_FUTURE) && !(mode&synfigapp::MODE_ANIMATE_PAST))
2518         {
2519                 Gtk::Image *icon;
2520                 icon=manage(new Gtk::Image(Gtk::StockID("synfig-keyframe_lock_future"),Gtk::ICON_SIZE_BUTTON));
2521                 keyframebutton->remove();
2522                 keyframebutton->add(*icon);
2523                 tooltips.set_tip(*keyframebutton,_("Future Keyframes Locked"));
2524                 icon->set_padding(0,0);
2525                 icon->show();
2526         }
2527         else if(!(mode&synfigapp::MODE_ANIMATE_FUTURE) && (mode&synfigapp::MODE_ANIMATE_PAST))
2528         {
2529                 Gtk::Image *icon;
2530                 icon=manage(new Gtk::Image(Gtk::StockID("synfig-keyframe_lock_past"),Gtk::ICON_SIZE_BUTTON));
2531                 keyframebutton->remove();
2532                 keyframebutton->add(*icon);
2533                 tooltips.set_tip(*keyframebutton,_("Past Keyframes Locked"));
2534                 icon->set_padding(0,0);
2535                 icon->show();
2536         }
2537         else if(!(mode&synfigapp::MODE_ANIMATE_FUTURE) && !(mode&synfigapp::MODE_ANIMATE_PAST))
2538         {
2539                 Gtk::Image *icon;
2540                 icon=manage(new Gtk::Image(Gtk::StockID("synfig-keyframe_lock_none"),Gtk::ICON_SIZE_BUTTON));
2541                 keyframebutton->remove();
2542                 keyframebutton->add(*icon);
2543                 tooltips.set_tip(*keyframebutton,_("No Keyframes Locked"));
2544                 icon->set_padding(0,0);
2545                 icon->show();
2546         }
2547
2548         work_area->queue_draw();
2549 }
2550
2551 void
2552 CanvasView::on_animate_button_pressed()
2553 {
2554         if(get_mode()&synfigapp::MODE_ANIMATE)
2555                 set_mode(get_mode()-synfigapp::MODE_ANIMATE);
2556         else
2557                 set_mode(get_mode()|synfigapp::MODE_ANIMATE);
2558 }
2559
2560 void
2561 CanvasView::on_keyframe_button_pressed()
2562 {
2563         synfigapp::CanvasInterface::Mode mode(get_mode());
2564
2565         //   future && past   -->             past
2566         if((mode&synfigapp::MODE_ANIMATE_FUTURE) && (mode&synfigapp::MODE_ANIMATE_PAST))
2567                 set_mode(get_mode()-synfigapp::MODE_ANIMATE_FUTURE);
2568         //             past   -->   future
2569         else if(!(mode&synfigapp::MODE_ANIMATE_FUTURE) && (mode&synfigapp::MODE_ANIMATE_PAST))
2570                 set_mode((get_mode()-synfigapp::MODE_ANIMATE_PAST)|synfigapp::MODE_ANIMATE_FUTURE);
2571         //   future           -->       (nothing)
2572         else if((mode&synfigapp::MODE_ANIMATE_FUTURE) && !(mode&synfigapp::MODE_ANIMATE_PAST))
2573                 set_mode(get_mode()-synfigapp::MODE_ANIMATE_FUTURE);
2574         //      (nothing)     -->   future && past
2575         else if(!(mode&synfigapp::MODE_ANIMATE_FUTURE) && !(mode&synfigapp::MODE_ANIMATE_PAST))
2576                 set_mode(get_mode()|synfigapp::MODE_ANIMATE_FUTURE|synfigapp::MODE_ANIMATE_PAST);
2577 }
2578
2579 bool
2580 CanvasView::duck_change_param(const synfig::Point &value,synfig::Layer::Handle layer, synfig::String param_name)
2581 {
2582         return canvas_interface()->change_value(synfigapp::ValueDesc(layer,param_name),value);
2583 }
2584
2585 bool
2586 CanvasView::on_duck_changed(const synfig::Point &value,const synfigapp::ValueDesc& value_desc)
2587 {
2588         if( ValueNode_BLineCalcVertex::Handle bline_vertex =
2589                 ValueNode_BLineCalcVertex::Handle::cast_dynamic(value_desc.get_value_node())
2590         )
2591         {
2592                 Real radius = 0.0;
2593                 ValueNode_BLine::Handle bline = ValueNode_BLine::Handle::cast_dynamic(bline_vertex->get_link(bline_vertex->get_link_index_from_name("bline")));
2594                 Real amount = synfig::find_closest_point(
2595                         (*bline)(get_time()),
2596                         value,
2597                         radius,
2598                         bline->get_loop()
2599                 );
2600                 return canvas_interface()->change_value(synfigapp::ValueDesc(bline_vertex,bline_vertex->get_link_index_from_name("amount")), amount);
2601         }
2602
2603         switch(value_desc.get_value_type())
2604         {
2605         case ValueBase::TYPE_REAL:
2606                 return canvas_interface()->change_value(value_desc,value.mag());
2607                 break;
2608         case ValueBase::TYPE_ANGLE:
2609                 return canvas_interface()->change_value(value_desc,Angle::tan(value[1],value[0]));
2610                 break;
2611         default:
2612                 return canvas_interface()->change_value(value_desc,value);
2613                 break;
2614         }
2615
2616         return true;
2617 }
2618
2619 bool
2620 CanvasView::on_duck_angle_changed(const synfig::Angle &rotation,const synfigapp::ValueDesc& value_desc)
2621 {
2622         // \todo will this really always be the case?
2623         assert(value_desc.get_value_type() == ValueBase::TYPE_ANGLE);
2624         return canvas_interface()->change_value(value_desc, value_desc.get_value(get_time()).get(Angle()) + rotation);
2625 }
2626
2627 void
2628 CanvasView::selected_layer_color_set(synfig::Color color)
2629 {
2630         synfigapp::SelectionManager::LayerList selected_list(get_selection_manager()->get_selected_layers());
2631         synfigapp::SelectionManager::LayerList::iterator iter;
2632
2633         // Create the action group
2634         //synfigapp::PassiveGrouper group(canvas_interface()->get_instance(),_("Set Colors"));
2635
2636         Layer::Handle layer;
2637         for(iter=selected_list.begin();iter!=selected_list.end();++iter)
2638         {
2639                 if(*iter==layer)
2640                         continue;
2641                 layer=*iter;
2642                 on_edited_value(synfigapp::ValueDesc(layer,"color"),color);
2643         }
2644 }
2645
2646 void
2647 CanvasView::rebuild_ducks_layer_(synfig::TransformStack& transform_stack, synfig::Canvas::Handle canvas, std::set<synfig::Layer::Handle>& selected_list)
2648 {
2649         int transforms(0);
2650         String layer_name;
2651
2652 #define QUEUE_REBUILD_DUCKS             sigc::mem_fun(*this,&CanvasView::queue_rebuild_ducks)
2653
2654         if(!canvas)
2655         {
2656                 synfig::warning("CanvasView::rebuild_ducks_layer_(): Layer doesn't have canvas set");
2657                 return;
2658         }
2659         for(Canvas::iterator iter(canvas->begin());iter!=canvas->end();++iter)
2660         {
2661                 Layer::Handle layer(*iter);
2662
2663                 if(selected_list.count(layer))
2664                 {
2665                         if(!curr_transform_stack_set)
2666                         {
2667                                 curr_transform_stack_set=true;
2668                                 curr_transform_stack=transform_stack;
2669                         }
2670
2671                         // This layer is currently selected.
2672                         duck_changed_connections.push_back(layer->signal_changed().connect(QUEUE_REBUILD_DUCKS));
2673
2674                         // do the bounding box thing
2675                         bbox|=transform_stack.perform(layer->get_bounding_rect());
2676
2677                         // Grab the layer's list of parameters
2678                         Layer::ParamList paramlist(layer->get_param_list());
2679
2680                         // Grab the layer vocabulary
2681                         Layer::Vocab vocab=layer->get_param_vocab();
2682                         Layer::Vocab::iterator iter;
2683
2684                         for(iter=vocab.begin();iter!=vocab.end();iter++)
2685                         {
2686                                 if(!iter->get_hidden() && !iter->get_invisible_duck())
2687                                 {
2688                                         synfigapp::ValueDesc value_desc(layer,iter->get_name());
2689                                         work_area->add_to_ducks(value_desc,this,transform_stack,&*iter);
2690                                         if(value_desc.is_value_node())
2691                                                 duck_changed_connections.push_back(value_desc.get_value_node()->signal_changed().connect(QUEUE_REBUILD_DUCKS));
2692                                 }
2693                                 if(iter->get_name()=="color")
2694                                 {
2695                                         /*
2696                                         if(!App::dialog_color->busy())
2697                                         {
2698                                                 App::dialog_color->reset();
2699                                                 App::dialog_color->set_color(layer->get_param("color").get(Color()));
2700                                                 App::dialog_color->signal_edited().connect(
2701                                                         sigc::mem_fun(
2702                                                                 *this,
2703                                                                 &studio::CanvasView::selected_layer_color_set
2704                                                         )
2705                                                 );
2706                                         }
2707                                         */
2708                                 }
2709                         }
2710                 }
2711
2712                 layer_name=layer->get_name();
2713
2714                 if(layer->active())
2715                 {
2716                         Transform::Handle trans(layer->get_transform());
2717                         if(trans)
2718                         {
2719                                 transform_stack.push(trans);
2720                                 transforms++;
2721                         }
2722
2723 /*                      // Add transforms onto the stack
2724                         if(layer_name=="Translate")
2725                         {
2726                                 transform_stack.push(synfig::Transform_Translate(layer->get_param("origin").get(Vector())));
2727                                 transforms++;
2728                         }else
2729                         if(layer_name=="Zoom")
2730                         {
2731                                 Vector scale;
2732                                 scale[0]=scale[1]=exp(layer->get_param("amount").get(Real()));
2733                                 transform_stack.push(synfig::Transform_Scale(scale,layer->get_param("center").get(Vector())));
2734                                 transforms++;
2735                         }else
2736                         if(layer_name=="stretch")
2737                         {
2738                                 Vector scale(layer->get_param("amount").get(Vector()));
2739                                 transform_stack.push(synfig::Transform_Scale(scale,layer->get_param("center").get(Vector())));
2740                                 transforms++;
2741                         }else
2742                         if(layer_name=="Rotate")
2743                         {
2744                                 transform_stack.push(synfig::Transform_Rotate(layer->get_param("amount").get(Angle()),layer->get_param("origin").get(Vector())));
2745                                 transforms++;
2746                         }
2747 */
2748                 }
2749
2750                 // If this is a paste canvas layer, then we need to
2751                 // descend into it
2752                 if(layer_name=="PasteCanvas")
2753                 {
2754                         Vector scale;
2755                         scale[0]=scale[1]=exp(layer->get_param("zoom").get(Real()));
2756                         Vector origin(layer->get_param("origin").get(Vector()));
2757
2758                         Canvas::Handle child_canvas(layer->get_param("canvas").get(Canvas::Handle()));
2759
2760                         if(!scale.is_equal_to(Vector(1,1)))
2761                                 transform_stack.push(new Transform_Scale(scale,origin));
2762                         if(!scale.is_equal_to(Vector(0,0)))
2763                                 transform_stack.push(new Transform_Translate(origin));
2764
2765                         rebuild_ducks_layer_(transform_stack,child_canvas,selected_list);
2766
2767                         if(!scale.is_equal_to(Vector(0,0)))
2768                                 transform_stack.pop();
2769                         if(!scale.is_equal_to(Vector(1,1)))
2770                                 transform_stack.pop();
2771                 }
2772         }
2773         // Remove all of the transforms we have added
2774         while(transforms--) { transform_stack.pop(); }
2775
2776 #undef QUEUE_REBUILD_DUCKS
2777 }
2778
2779 void
2780 CanvasView::queue_rebuild_ducks()
2781 {
2782 #if 0
2783         if(rebuild_ducks_queued)
2784                 return;
2785 #else
2786         if(rebuild_ducks_queued)
2787                 queue_rebuild_ducks_connection.disconnect();
2788 #endif
2789
2790         queue_rebuild_ducks_connection=Glib::signal_timeout().connect(
2791                 sigc::bind_return(
2792                         sigc::mem_fun(*this,&CanvasView::rebuild_ducks),
2793                         false
2794                 ),
2795                 50
2796         );
2797
2798         rebuild_ducks_queued=true;
2799 }
2800
2801 void
2802 CanvasView::rebuild_ducks()
2803 {
2804         /*static int i=0;
2805         i++;
2806         if(i>30)
2807                 synfig::info("%d",i/(i-i));
2808         */
2809
2810         rebuild_ducks_queued=false;
2811         //queue_rebuild_ducks_connection.disconnect();
2812
2813         if(work_area->is_dragging())
2814         {
2815                 queue_rebuild_ducks();
2816                 return;
2817         }
2818
2819         if(!duck_refresh_flag)
2820         {
2821                 duck_refresh_needed=true;
2822                 return;
2823         }
2824
2825         bbox=Rect::zero();
2826
2827         work_area->clear_ducks();
2828         work_area->set_time(get_time());
2829         get_canvas()->set_time(get_time());
2830         curr_transform_stack.clear();
2831         //curr_transform_stack.push(new Transform_Translate(Point(0,0)));
2832         curr_transform_stack_set=false;
2833
2834         for(;!duck_changed_connections.empty();duck_changed_connections.pop_back())duck_changed_connections.back().disconnect();
2835
2836         //get_canvas()->set_time(get_time());
2837         bool not_empty(false);
2838
2839         // First do the layers...
2840         do{
2841                 synfigapp::SelectionManager::LayerList selected_list(get_selection_manager()->get_selected_layers());
2842                 std::set<synfig::Layer::Handle> layer_set(selected_list.begin(),selected_list.end());
2843
2844                 if(!layer_set.empty())
2845                         not_empty=true;
2846
2847                 synfig::TransformStack transform_stack;
2848
2849                 rebuild_ducks_layer_(transform_stack, get_canvas(), layer_set);
2850
2851         }while(0);
2852
2853         // Now do the children
2854         do{
2855                 synfigapp::SelectionManager::ChildrenList selected_list(get_selection_manager()->get_selected_children());
2856                 synfigapp::SelectionManager::ChildrenList::iterator iter;
2857                 synfig::TransformStack transform_stack;
2858
2859                 if(selected_list.empty())
2860                 {
2861                         break;
2862                 }
2863                 else
2864                 {
2865                         not_empty=true;
2866                         for(iter=selected_list.begin();iter!=selected_list.end();++iter)
2867                         {
2868                                 work_area->add_to_ducks(*iter,this,transform_stack);
2869                         }
2870                 }
2871         }while(0);
2872         work_area->refresh_selected_ducks();
2873         work_area->queue_draw_preview();
2874 }
2875
2876 void
2877 CanvasView::decrease_low_res_pixel_size()
2878 {
2879         list<int> sizes = CanvasView::get_pixel_sizes();
2880         int pixel_size = work_area->get_low_res_pixel_size();
2881
2882         for (list<int>::iterator iter = sizes.begin(); iter != sizes.end(); iter++)
2883                 if (*iter == pixel_size)
2884                 {
2885                         if (iter == sizes.begin())
2886                                 // we already have the smallest low-res pixels possible - turn off low-res instead
2887                                 work_area->set_low_resolution_flag(false);
2888                         else
2889                         {
2890                                 iter--;
2891                                 Glib::RefPtr<Gtk::Action> action = action_group->get_action(strprintf("lowres-pixel-%d", *iter));
2892                                 action->activate(); // to make sure the radiobutton in the menu is updated too
2893                                 work_area->set_low_resolution_flag(true);
2894                         }
2895                         break;
2896                 }
2897 }
2898
2899 void
2900 CanvasView::increase_low_res_pixel_size()
2901 {
2902         list<int> sizes = CanvasView::get_pixel_sizes();
2903         int pixel_size = work_area->get_low_res_pixel_size();
2904
2905         if (!work_area->get_low_resolution_flag())
2906         {
2907                 work_area->set_low_resolution_flag(true);
2908                 return;
2909         }
2910
2911         for (list<int>::iterator iter = sizes.begin(); iter != sizes.end(); iter++)
2912                 if (*iter == pixel_size)
2913                 {
2914                         iter++;
2915                         if (iter != sizes.end())
2916                         {
2917                                 Glib::RefPtr<Gtk::Action> action = action_group->get_action(strprintf("lowres-pixel-%d", *iter));
2918                                 action->activate(); // to make sure the radiobutton in the menu is updated too
2919                                 work_area->set_low_resolution_flag(true);
2920                         }
2921                         break;
2922                 }
2923 }
2924
2925 void
2926 CanvasView::on_dirty_preview()
2927 {
2928         if(!is_playing_)
2929         {
2930                 IsWorking is_working(*this);
2931
2932                 work_area->queue_render_preview();
2933         }
2934 }
2935
2936 void
2937 CanvasView::play()
2938 {
2939         assert(get_canvas());
2940
2941         // If we are already busy, don't play!
2942         if(working_depth)return;
2943
2944         // Set us up as working
2945         IsWorking is_working(*this);
2946
2947         etl::clock timer;
2948         Time
2949                 time=work_area->get_time(),
2950                 endtime=get_canvas()->rend_desc().get_time_end();
2951
2952         // If we are already at the end of time, start over
2953         if(time==endtime)
2954                 time=get_canvas()->rend_desc().get_time_start();
2955
2956         is_playing_=true;
2957
2958         work_area->clear_ducks();
2959
2960         for(timer.reset(); time + timer() < endtime;)
2961         {
2962                 //Clamp the time window so we can see the time value as it races across the horizon
2963                 bool timewindreset = false;
2964
2965                 while( time + timer() > Time(time_window_adjustment().get_sub_upper()) )
2966                 {
2967                         time_window_adjustment().set_value(
2968                                         min(
2969                                                 time_window_adjustment().get_value()+time_window_adjustment().get_page_size()/2,
2970                                                 time_window_adjustment().get_upper()-time_window_adjustment().get_page_size() )
2971                                 );
2972                         timewindreset = true;
2973                 }
2974
2975                 while( time + timer() < Time(time_window_adjustment().get_sub_lower()) )
2976                 {
2977                         time_window_adjustment().set_value(
2978                                 max(
2979                                         time_window_adjustment().get_value()-time_window_adjustment().get_page_size()/2,
2980                                         time_window_adjustment().get_lower())
2981                         );
2982
2983                         timewindreset = true;
2984                 }
2985
2986                 //we need to tell people that the value changed
2987                 if(timewindreset) time_window_adjustment().value_changed();
2988
2989                 //update actual time to next step
2990                 time_adjustment().set_value(time+timer());
2991                 time_adjustment().value_changed();
2992
2993                 if(!work_area->sync_render_preview())
2994                         break;
2995
2996                 // wait for the workarea to refresh itself
2997                 while (studio::App::events_pending())
2998                         studio::App::iteration(false);
2999
3000                 if(get_cancel_status())
3001                 {
3002                         is_playing_=false;
3003                         return;
3004                 }
3005         }
3006         is_playing_=false;
3007
3008         time_adjustment().set_value(endtime);
3009         time_adjustment().value_changed();
3010 }
3011
3012 void
3013 CanvasView::show_tables()
3014 {
3015 /*
3016         Smach::event_result x(process_event_key(EVENT_TABLES_SHOW));
3017         if(x==Smach::RESULT_OK || x==Smach::RESULT_ACCEPT)
3018         {
3019                 Gtk::IconSize iconsize=Gtk::IconSize::from_name("synfig-small_icon");
3020                 treetogglebutton->remove();
3021                 treetogglebutton->add(*manage(new Gtk::Image(Gtk::StockID("gtk-go-down"),iconsize)));
3022                 treetogglebutton->show_all();
3023                 notebook->show();
3024         }
3025 */
3026 }
3027
3028 void
3029 CanvasView::hide_tables()
3030 {
3031 /*
3032         Smach::event_result x(process_event_key(EVENT_TABLES_HIDE));
3033         if(x==Smach::RESULT_OK || x==Smach::RESULT_ACCEPT)
3034         {
3035                 Gtk::IconSize iconsize=Gtk::IconSize::from_name("synfig-small_icon");
3036                 treetogglebutton->remove();
3037                 treetogglebutton->add(*manage(new Gtk::Image(Gtk::StockID("gtk-go-up"),iconsize)));
3038                 treetogglebutton->show_all();
3039                 notebook->hide();
3040         }
3041 */
3042 }
3043
3044 bool
3045 CanvasView::tables_are_visible()
3046 {
3047 //      return notebook->is_visible();
3048         return false;
3049 }
3050
3051 void
3052 CanvasView::toggle_tables()
3053 {
3054 //      if(tables_are_visible())
3055 //              hide_tables();
3056 //      else
3057 //              show_tables();
3058 }
3059
3060 void
3061 CanvasView::show_timebar()
3062 {
3063         timebar->show();
3064         current_time_widget->show();
3065
3066         //keyframe_tab_child->show();
3067         if(layer_tree)
3068                 layer_tree->set_show_timetrack(true);
3069         if(children_tree)
3070                 children_tree->set_show_timetrack(true);
3071 }
3072
3073 void
3074 CanvasView::hide_timebar()
3075 {
3076         timebar->hide();
3077         current_time_widget->hide();
3078         //keyframe_tab_child->hide();
3079         if(layer_tree)
3080                 layer_tree->set_show_timetrack(false);
3081         if(children_tree)
3082                 children_tree->set_show_timetrack(false);
3083 }
3084
3085 void
3086 CanvasView::set_sensitive_timebar(bool sensitive)
3087 {
3088         timebar->set_sensitive(sensitive);
3089         current_time_widget->set_sensitive(sensitive);
3090         //keyframe_tab_child->set_sensitive(sensitive);
3091         if(layer_tree)
3092                 layer_tree->set_sensitive(sensitive);
3093         if(children_tree)
3094                 children_tree->set_sensitive(sensitive);
3095 }
3096
3097 static void
3098 set_waypoint_model(std::set<synfig::Waypoint, std::less<UniqueID> > waypoints,
3099                                    Waypoint::Model model,
3100                                    etl::loose_handle<synfigapp::CanvasInterface> canvas_interface)
3101 {
3102         // Create the action group
3103         synfigapp::Action::PassiveGrouper group(canvas_interface->get_instance().get(),_("Change Waypoint Group"));
3104
3105         std::set<synfig::Waypoint, std::less<UniqueID> >::const_iterator iter;
3106         for(iter=waypoints.begin();iter!=waypoints.end();++iter)
3107         {
3108                 Waypoint waypoint(*iter);
3109                 waypoint.apply_model(model);
3110
3111                 synfigapp::Action::Handle action(synfigapp::Action::create("waypoint_set"));
3112
3113                 assert(action);
3114
3115                 action->set_param("canvas",canvas_interface->get_canvas());
3116                 action->set_param("canvas_interface",canvas_interface);
3117
3118                 action->set_param("waypoint",waypoint);
3119                 action->set_param("value_node",waypoint.get_parent_value_node());
3120
3121                 if(!canvas_interface->get_instance()->perform_action(action))
3122                 {
3123                         group.cancel();
3124                         return;
3125                 }
3126         }
3127 }
3128
3129 static void
3130 duplicate_waypoints(std::set<synfig::Waypoint, std::less<UniqueID> > waypoints,
3131                                         etl::loose_handle<synfigapp::CanvasInterface> canvas_interface)
3132 {
3133         // Create the action group
3134         synfigapp::Action::PassiveGrouper group(canvas_interface->get_instance().get(),_("Duplicate Waypoints"));
3135
3136         std::set<synfig::Waypoint, std::less<UniqueID> >::const_iterator iter;
3137         for (iter = waypoints.begin(); iter != waypoints.end(); iter++)
3138         {
3139                 Waypoint waypoint(*iter);
3140                 ValueNode::Handle value_node(iter->get_parent_value_node());
3141                 canvas_interface->waypoint_duplicate(value_node, waypoint);
3142         }
3143 }
3144
3145 static void
3146 remove_waypoints(std::set<synfig::Waypoint, std::less<UniqueID> > waypoints,
3147                                  etl::loose_handle<synfigapp::CanvasInterface> canvas_interface)
3148 {
3149         // Create the action group
3150         synfigapp::Action::PassiveGrouper group(canvas_interface->get_instance().get(),_("Remove Waypoints"));
3151
3152         std::set<synfig::Waypoint, std::less<UniqueID> >::const_iterator iter;
3153         for (iter = waypoints.begin(); iter != waypoints.end(); iter++)
3154         {
3155                 Waypoint waypoint(*iter);
3156                 ValueNode::Handle value_node(iter->get_parent_value_node());
3157                 canvas_interface->waypoint_remove(value_node, waypoint);
3158         }
3159 }
3160
3161 void
3162 CanvasView::on_waypoint_clicked_canvasview(synfigapp::ValueDesc value_desc,
3163                                                                                    std::set<synfig::Waypoint, std::less<UniqueID> > waypoint_set,
3164                                                                                    int button)
3165 {
3166         int size = waypoint_set.size();
3167         Waypoint waypoint(*(waypoint_set.begin()));
3168         Time time(waypoint.get_time());
3169
3170         if (size == 1)
3171         {
3172                 waypoint_dialog.set_value_desc(value_desc);
3173                 waypoint_dialog.set_waypoint(waypoint);
3174         }
3175
3176         switch(button)
3177         {
3178         case -1:
3179                 if (size == 1)
3180                         waypoint_dialog.show();
3181                 break;
3182         case 2:
3183         {
3184                 Gtk::Menu* waypoint_menu(manage(new Gtk::Menu()));
3185                 waypoint_menu->signal_hide().connect(sigc::bind(sigc::ptr_fun(&delete_widget), waypoint_menu));
3186
3187                 Gtk::Menu* interp_menu_in(manage(new Gtk::Menu()));
3188                 Gtk::Menu* interp_menu_out(manage(new Gtk::Menu()));
3189                 Gtk::Menu* interp_menu_both(manage(new Gtk::Menu()));
3190
3191                 {
3192                         Waypoint::Model model;
3193
3194                         model.reset(); model.set_before(INTERPOLATION_TCB);
3195                         interp_menu_in->items().push_back(Gtk::Menu_Helpers::MenuElem(_("_TCB"),
3196                                 sigc::bind(sigc::ptr_fun(set_waypoint_model), waypoint_set, model, canvas_interface())));
3197                         model.reset(); model.set_after(INTERPOLATION_TCB);
3198                         interp_menu_out->items().push_back(Gtk::Menu_Helpers::MenuElem(_("_TCB"),
3199                                 sigc::bind(sigc::ptr_fun(set_waypoint_model), waypoint_set, model, canvas_interface())));
3200                         model.set_before(INTERPOLATION_TCB);
3201                         interp_menu_both->items().push_back(Gtk::Menu_Helpers::MenuElem(_("_TCB"),
3202                                 sigc::bind(sigc::ptr_fun(set_waypoint_model), waypoint_set, model, canvas_interface())));
3203
3204                         model.reset(); model.set_before(INTERPOLATION_LINEAR);
3205                         interp_menu_in->items().push_back(Gtk::Menu_Helpers::MenuElem(_("_Linear"),
3206                                 sigc::bind(sigc::ptr_fun(set_waypoint_model), waypoint_set, model, canvas_interface())));
3207                         model.reset(); model.set_after(INTERPOLATION_LINEAR);
3208                         interp_menu_out->items().push_back(Gtk::Menu_Helpers::MenuElem(_("_Linear"),
3209                                 sigc::bind(sigc::ptr_fun(set_waypoint_model), waypoint_set, model, canvas_interface())));
3210                         model.set_before(INTERPOLATION_LINEAR);
3211                         interp_menu_both->items().push_back(Gtk::Menu_Helpers::MenuElem(_("_Linear"),
3212                                 sigc::bind(sigc::ptr_fun(set_waypoint_model), waypoint_set, model, canvas_interface())));
3213
3214                         model.reset(); model.set_before(INTERPOLATION_HALT);
3215                         interp_menu_in->items().push_back(Gtk::Menu_Helpers::MenuElem(_("_Ease In"),
3216                                 sigc::bind(sigc::ptr_fun(set_waypoint_model), waypoint_set, model, canvas_interface())));
3217                         model.reset(); model.set_after(INTERPOLATION_HALT);
3218                         interp_menu_out->items().push_back(Gtk::Menu_Helpers::MenuElem(_("_Ease Out"),
3219                                 sigc::bind(sigc::ptr_fun(set_waypoint_model), waypoint_set, model, canvas_interface())));
3220                         model.set_before(INTERPOLATION_HALT);
3221                         interp_menu_both->items().push_back(Gtk::Menu_Helpers::MenuElem(_("_Ease In/Out"),
3222                                 sigc::bind(sigc::ptr_fun(set_waypoint_model), waypoint_set, model, canvas_interface())));
3223
3224                         model.reset(); model.set_before(INTERPOLATION_CONSTANT);
3225                         interp_menu_in->items().push_back(Gtk::Menu_Helpers::MenuElem(_("_Constant"),
3226                                 sigc::bind(sigc::ptr_fun(set_waypoint_model), waypoint_set, model, canvas_interface())));
3227                         model.reset(); model.set_after(INTERPOLATION_CONSTANT);
3228                         interp_menu_out->items().push_back(Gtk::Menu_Helpers::MenuElem(_("_Constant"),
3229                                 sigc::bind(sigc::ptr_fun(set_waypoint_model), waypoint_set, model, canvas_interface())));
3230                         model.set_before(INTERPOLATION_CONSTANT);
3231                         interp_menu_both->items().push_back(Gtk::Menu_Helpers::MenuElem(_("_Constant"),
3232                                 sigc::bind(sigc::ptr_fun(set_waypoint_model), waypoint_set, model, canvas_interface())));
3233                 }
3234
3235                 // ------------------------------------------------------------------------
3236                 waypoint_menu->items().push_back(Gtk::Menu_Helpers::MenuElem(_("_Jump To"),
3237                         sigc::bind(sigc::mem_fun(*canvas_interface(), &synfigapp::CanvasInterface::set_time), time)));
3238
3239                 waypoint_menu->items().push_back(Gtk::Menu_Helpers::MenuElem(_("_Duplicate"),
3240                          sigc::bind(sigc::ptr_fun(duplicate_waypoints), waypoint_set, canvas_interface())));
3241
3242                 waypoint_menu->items().push_back(Gtk::Menu_Helpers::MenuElem((size == 1) ? _("_Remove") : strprintf(_("_Remove %d Waypoints"), size),
3243                          sigc::bind(sigc::ptr_fun(remove_waypoints), waypoint_set, canvas_interface())));
3244
3245                 if (size == 1 && value_desc.is_valid())
3246                         waypoint_menu->items().push_back(Gtk::Menu_Helpers::MenuElem(_("_Edit"),
3247                                 sigc::mem_fun(waypoint_dialog,&Gtk::Widget::show)));
3248
3249                 // ------------------------------------------------------------------------
3250                 waypoint_menu->items().push_back(Gtk::Menu_Helpers::SeparatorElem());
3251
3252                 // ------------------------------------------------------------------------
3253                 waypoint_menu->items().push_back(Gtk::Menu_Helpers::MenuElem(_("_Both"), *interp_menu_both));
3254                 waypoint_menu->items().push_back(Gtk::Menu_Helpers::MenuElem(_("_In"),   *interp_menu_in));
3255                 waypoint_menu->items().push_back(Gtk::Menu_Helpers::MenuElem(_("_Out"),  *interp_menu_out));
3256
3257                 // ------------------------------------------------------------------------
3258                 waypoint_menu->popup(button+1,gtk_get_current_event_time());
3259         }
3260         break;
3261
3262         default:
3263                 break;
3264         }
3265 }
3266
3267 void
3268 CanvasView::on_waypoint_changed()
3269 {
3270         synfigapp::Action::ParamList param_list;
3271         param_list.add("canvas",get_canvas());
3272         param_list.add("canvas_interface",canvas_interface());
3273         param_list.add("value_node",waypoint_dialog.get_value_desc().get_value_node());
3274         param_list.add("waypoint",waypoint_dialog.get_waypoint());
3275 //      param_list.add("time",canvas_interface()->get_time());
3276
3277         get_instance()->process_action("waypoint_set_smart", param_list);
3278 }
3279
3280 void
3281 CanvasView::on_waypoint_delete()
3282 {
3283         synfigapp::Action::ParamList param_list;
3284         param_list.add("canvas",get_canvas());
3285         param_list.add("canvas_interface",canvas_interface());
3286         param_list.add("value_node",waypoint_dialog.get_value_desc().get_value_node());
3287         param_list.add("waypoint",waypoint_dialog.get_waypoint());
3288 //      param_list.add("time",canvas_interface()->get_time());
3289
3290         get_instance()->process_action("waypoint_remove", param_list);
3291 }
3292
3293 void
3294 CanvasView::on_drop_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, int /*x*/, int /*y*/, const Gtk::SelectionData& selection_data_, guint /*info*/, guint time)
3295 {
3296         // We will make this true once we have a solid drop
3297         bool success(false);
3298         //synfig::info("Dropped data of type \"%s\"",selection_data.get_data_type());
3299         //synfig::info("Dropped data of target \"%s\"",gdk_atom_name(selection_data->target));
3300         //synfig::info("selection=\"%s\"",gdk_atom_name(selection_data->selection));
3301
3302         if ((selection_data_.get_length() >= 0) && (selection_data_.get_format() == 8))
3303         {
3304                 if(synfig::String(selection_data_.get_data_type())=="STRING")do
3305                 {
3306                         synfig::String selection_data((gchar *)(selection_data_.get_data()));
3307
3308                         Layer::Handle layer(synfig::Layer::create("Text"));
3309                         if(!layer)
3310                                 break;
3311                         if(!layer->set_param("text",ValueBase(selection_data)))
3312                                 break;
3313
3314                         synfigapp::Action::Handle       action(synfigapp::Action::create("layer_add"));
3315
3316                         assert(action);
3317                         if(!action)
3318                                 break;
3319
3320                         action->set_param("canvas",get_canvas());
3321                         action->set_param("canvas_interface",canvas_interface());
3322                         action->set_param("new",layer);
3323
3324                         if(!get_instance()->perform_action(action))
3325                                 break;
3326
3327                         // Ok, we have successfully imported at least one item.
3328                         success=true;
3329                 } while(0); // END of "STRING"
3330
3331                 if(synfig::String(selection_data_.get_data_type())=="text/plain")
3332                 {
3333                         synfig::String selection_data((gchar *)(selection_data_.get_data()));
3334
3335                         // For some reason, GTK hands us a list of URLs separated
3336                         // by not only Carriage-Returns, but also Line-Feeds.
3337                         // Line-Feeds will mess us up. Remove all the line-feeds.
3338                         while(selection_data.find_first_of('\r')!=synfig::String::npos)
3339                                 selection_data.erase(selection_data.begin()+selection_data.find_first_of('\r'));
3340
3341                         std::stringstream stream(selection_data);
3342
3343                         //synfigapp::PassiveGrouper group(canvas_interface()->get_instance(),_("Insert Image"));
3344                         while(stream)
3345                         {
3346                                 synfig::String filename,URI;
3347                                 getline(stream,filename);
3348
3349                                 // If we don't have a filename, move on.
3350                                 if(filename.empty())
3351                                         continue;
3352
3353                                 // Make sure this URL is of the "file://" type.
3354                                 URI=String(filename.begin(),filename.begin()+sizeof("file://")-1);
3355                                 if(URI!="file://")
3356                                 {
3357                                         synfig::warning("Unknown URI (%s) in \"%s\"",URI.c_str(),filename.c_str());
3358                                         continue;
3359                                 }
3360
3361                                 // Strip the "file://" part from the filename
3362                                 filename=synfig::String(filename.begin()+sizeof("file://")-1,filename.end());
3363
3364                                 String ext(filename_extension(filename));
3365                                 if (ext.size()) ext = ext.substr(1); // skip initial '.'
3366
3367                                 // If this is a SIF file, then we need to do things slightly differently
3368                                 if(ext=="sketch")
3369                                 {
3370                                         if(work_area->load_sketch(filename))
3371                                         {
3372                                                 success=true;
3373                                                 work_area->queue_draw();
3374                                         }
3375                                 }
3376                                 else
3377                                 {
3378                                         if(canvas_interface()->import(filename))
3379                                                 success=true;
3380                                 }
3381
3382                                 continue;
3383                         }
3384                 } // END of "text/plain"
3385         }
3386         else
3387                 ui_interface_->error("Drop failed: bad selection data");
3388
3389         // Finish the drag
3390         context->drag_finish(success, false, time);
3391 }
3392
3393 void
3394 CanvasView::on_keyframe_add_pressed()
3395 {
3396         synfigapp::Action::Handle action(synfigapp::Action::create("keyframe_add"));
3397
3398         if(!action)
3399         {
3400                 ui_interface_->error("I am unable to find the appropriate action");
3401                 return;
3402         }
3403
3404         action->set_param("canvas",get_canvas());
3405         action->set_param("canvas_interface",canvas_interface());
3406         action->set_param("keyframe",Keyframe(get_time()));
3407
3408         canvas_interface()->get_instance()->perform_action(action);
3409 }
3410
3411 void
3412 CanvasView::on_keyframe_duplicate_pressed()
3413 {
3414         const KeyframeTreeStore::Model model;
3415         const Gtk::TreeRow row(*keyframe_tree->get_selection()->get_selected());
3416         Keyframe keyframe;
3417         if(!row)
3418         {
3419                 ui_interface_->error("I am unable to duplicate the keyframe");
3420                 return;
3421         }
3422         keyframe=row[model.keyframe];
3423
3424         synfigapp::Action::Handle action(synfigapp::Action::create("keyframe_duplicate"));
3425
3426         if(!action)
3427         {
3428                 ui_interface_->error("I am unable to find the appropriate action");
3429                 return;
3430         }
3431
3432         action->set_param("canvas",get_canvas());
3433         action->set_param("canvas_interface",canvas_interface());
3434         action->set_param("keyframe",keyframe);
3435         action->set_param("time",get_time());
3436
3437         canvas_interface()->get_instance()->perform_action(action);
3438 }
3439
3440 void
3441 CanvasView::on_keyframe_remove_pressed()
3442 {
3443         const KeyframeTreeStore::Model model;
3444         const Gtk::TreeRow row(*keyframe_tree->get_selection()->get_selected());
3445         Keyframe keyframe;
3446         if(!row)
3447         {
3448                 ui_interface_->error("I am unable to remove the keyframe");
3449                 return;
3450         }
3451         keyframe=row[model.keyframe];
3452
3453         synfigapp::Action::Handle action(synfigapp::Action::create("keyframe_remove"));
3454
3455         if(!action)
3456         {
3457                 ui_interface_->error("I am unable to find the appropriate action");
3458                 return;
3459         }
3460
3461         action->set_param("canvas",get_canvas());
3462         action->set_param("canvas_interface",canvas_interface());
3463         action->set_param("keyframe",keyframe);
3464
3465         canvas_interface()->get_instance()->perform_action(action);
3466 }
3467
3468 void
3469 CanvasView::toggle_duck_mask(Duckmatic::Type type)
3470 {
3471         bool is_currently_on(work_area->get_type_mask()&type);
3472
3473         if(is_currently_on)
3474                 work_area->set_type_mask(work_area->get_type_mask()-type);
3475         else
3476                 work_area->set_type_mask(work_area->get_type_mask()|type);
3477
3478         work_area->queue_draw();
3479 }
3480
3481 void
3482 CanvasView::image_import()
3483 {
3484         // String filename(dirname(get_canvas()->get_file_name()));
3485         String filename("*.*");
3486         if(App::dialog_open_file(_("Import Image"), filename, IMAGE_DIR_PREFERENCE))
3487                 canvas_interface()->import(filename);
3488 }
3489
3490 Smach::event_result
3491 CanvasView::process_event_key(EventKey x)
3492 {
3493         return smach_.process_event(x);
3494 }
3495
3496 void
3497 CanvasView::on_input_device_changed(GdkDevice* device)
3498 {
3499         if(!device)
3500         {
3501                 get_smach().egress();
3502         }
3503         assert(device);
3504
3505         synfigapp::InputDevice::Handle input_device;
3506         input_device=synfigapp::Main::select_input_device(device->name);
3507         App::toolbox->change_state(input_device->get_state());
3508         process_event_key(EVENT_INPUT_DEVICE_CHANGED);
3509 }
3510
3511 void
3512 CanvasView::on_preview_option()
3513 {
3514         Dialog_PreviewOptions *po = dynamic_cast<Dialog_PreviewOptions *>(get_ext_widget("prevoptions"));
3515
3516         Canvas::Handle  canv = get_canvas();
3517
3518         if(canv)
3519         {
3520                 RendDesc &r = canv->rend_desc();
3521                 if(r.get_frame_rate())
3522                 {
3523                         float rate = 1/r.get_frame_rate();
3524                         float beg = r.get_time_start() + r.get_frame_start()*rate;
3525                         float end = r.get_time_start() + r.get_frame_end()*rate;
3526
3527                         if(!po)
3528                         {
3529                                 po = new Dialog_PreviewOptions;
3530                                 po->set_zoom(work_area->get_zoom()/2);
3531                                 po->set_fps(r.get_frame_rate()/2);
3532                                 po->set_begintime(beg);
3533                                 po->set_begin_override(false);
3534                                 po->set_endtime(end);
3535                                 po->set_end_override(false);
3536
3537                                 set_ext_widget("prevoptions",po);
3538                         }
3539                         /*po->set_zoom(work_area->get_zoom()/2);
3540                         po->set_fps(r.get_frame_rate()/2);
3541                         po->set_begintime(beg);
3542                         po->set_begin_override(false);
3543                         po->set_endtime(end);
3544                         po->set_end_override(false);*/
3545
3546                         po->set_global_fps(r.get_frame_rate());
3547                         po->signal_finish().connect(sigc::mem_fun(*this,&CanvasView::on_preview_create));
3548                         po->present();
3549                 }
3550         }
3551 }
3552
3553 void
3554 CanvasView::on_preview_create(const PreviewInfo &info)
3555 {
3556         //set all the options
3557         etl::handle<Preview>    prev = new Preview;
3558
3559         prev->set_canvasview(this);
3560         prev->set_zoom(info.zoom);
3561         prev->set_fps(info.fps);
3562         prev->set_overbegin(info.overbegin);
3563         prev->set_begintime(info.begintime);
3564         prev->set_overend(info.overend);
3565         prev->set_endtime(info.endtime);
3566         prev->set_quality(work_area->get_quality());
3567
3568         //render it out...
3569         prev->render();
3570
3571         Dialog_Preview *pd = preview_dialog.get();
3572         assert(pd);
3573
3574         pd->set_default_size(700,510);
3575         pd->set_preview(prev.get());
3576         pd->present();
3577 }
3578
3579 void
3580 CanvasView::on_audio_option()
3581 {
3582         synfig::warning("Launching Audio Options");
3583         sound_dialog->set_global_fps(get_canvas()->rend_desc().get_frame_rate());
3584         sound_dialog->present();
3585 }
3586
3587 void
3588 CanvasView::on_audio_file_change(const std::string &f)
3589 {
3590         //save in meta data - always even when not valid...
3591         canvas_interface()->set_meta_data("audiofile",f);
3592 }
3593
3594 void
3595 CanvasView::on_audio_offset_change(const synfig::Time &t)
3596 {
3597         canvas_interface()->set_meta_data("audiooffset",t.get_string());
3598 }
3599
3600 void
3601 CanvasView::on_audio_file_notify()
3602 {
3603         std::string file(get_canvas()->get_meta_data("audiofile"));
3604         if(!file.c_str()) return;
3605
3606         if(!audio->load(file,dirname(get_canvas()->get_file_name())+string("/")))
3607         {
3608                 if(file != "") synfig::warning("Could not load the file: %s", file.c_str());
3609                 get_canvas()->erase_meta_data("audiofile");
3610                 disp_audio->hide();
3611                 disp_audio->set_profile(etl::handle<AudioProfile>());
3612         }else
3613         {
3614                 //save in canvasview
3615                 synfig::warning("Getting the profile of the music stuff");
3616
3617                 //profile specific stuff for the preview widget
3618                 //similar for other attachments
3619                 Dialog_Preview *pd = preview_dialog.get();
3620                 pd->get_widget().set_audio(audio);
3621
3622                 handle<AudioProfile>    prof = audio->get_profile();
3623
3624                 if(!prof)
3625                 {
3626                         synfig::warning("Agh, I couldn't build the profile captain!");
3627                 }
3628                 pd->get_widget().set_audioprofile(prof);
3629
3630                 disp_audio->set_profile(audio->get_profile());
3631                 disp_audio->show();
3632
3633                 synfig::warning("successfully set the profiles and stuff");
3634         }
3635         disp_audio->queue_draw();
3636 }
3637
3638 void
3639 CanvasView::on_audio_offset_notify()
3640 {
3641         Time t(get_canvas()->get_meta_data("audiooffset"),get_canvas()->rend_desc().get_frame_rate());
3642         audio->set_offset(t);
3643         sound_dialog->set_offset(t);
3644         disp_audio->queue_draw();
3645
3646         // synfig::info("CanvasView::on_audio_offset_notify(): offset time set to %s",t.get_string(get_canvas()->rend_desc().get_frame_rate()).c_str());
3647 }
3648
3649 void
3650 CanvasView::play_audio(float t)
3651 {
3652         if(audio.get())
3653         {
3654                 synfig::info("Playing audio at %f s",t);
3655                 audio->play(t);
3656         }
3657 }
3658
3659 void
3660 CanvasView::stop_audio()
3661 {
3662         if(audio.get())
3663         {
3664                 audio->stop();
3665         }
3666 }
3667
3668 bool
3669 CanvasView::on_audio_scrub()
3670 {
3671         disp_audio->draw();
3672         return true;
3673 }
3674
3675 Glib::RefPtr<Glib::ObjectBase>
3676 CanvasView::get_ref_obj(const synfig::String& x)
3677 {
3678         return ref_obj_book_[x];
3679 }
3680
3681 Glib::RefPtr<const Glib::ObjectBase>
3682 CanvasView::get_ref_obj(const synfig::String& x)const
3683 {
3684         return ref_obj_book_.find(x)->second;
3685 }
3686
3687 void
3688 CanvasView::set_ref_obj(const synfig::String& x, Glib::RefPtr<Glib::ObjectBase> y)
3689 {
3690         ref_obj_book_[x]=y;
3691 }
3692
3693 Glib::RefPtr<Gtk::TreeModel>
3694 CanvasView::get_tree_model(const synfig::String& x)
3695 {
3696         return Glib::RefPtr<Gtk::TreeModel>::cast_dynamic(ref_obj_book_["_tree_model_"+x]);
3697 }
3698
3699 Glib::RefPtr<const Gtk::TreeModel>
3700 CanvasView::get_tree_model(const synfig::String& x)const
3701 {
3702         return Glib::RefPtr<Gtk::TreeModel>::cast_dynamic(ref_obj_book_.find("_tree_model_"+x)->second);
3703 }
3704
3705 void
3706 CanvasView::set_tree_model(const synfig::String& x, Glib::RefPtr<Gtk::TreeModel> y)
3707 {
3708         ref_obj_book_["_tree_model_"+x]=Glib::RefPtr<Glib::ObjectBase>::cast_static(y);
3709 }
3710
3711 Gtk::Widget*
3712 CanvasView::get_ext_widget(const synfig::String& x)
3713 {
3714         return ext_widget_book_[x];
3715 }
3716
3717 void
3718 CanvasView::set_ext_widget(const synfig::String& x, Gtk::Widget* y)
3719 {
3720         ext_widget_book_[x]=y;
3721         if(x=="layers_cmp")
3722         {
3723                 layer_tree=dynamic_cast<LayerTree*>(y);
3724
3725                 layer_tree->get_selection()->signal_changed().connect(SLOT_EVENT(EVENT_LAYER_SELECTION_CHANGED));
3726                 layer_tree->get_selection()->signal_changed().connect(SLOT_EVENT(EVENT_REFRESH_DUCKS));
3727                 layer_tree->signal_layer_user_click().connect(sigc::mem_fun(*this, &studio::CanvasView::on_layer_user_click));
3728                 layer_tree->signal_param_user_click().connect(sigc::mem_fun(*this, &studio::CanvasView::on_children_user_click));
3729                 layer_tree->signal_waypoint_clicked_layertree().connect(sigc::mem_fun(*this, &studio::CanvasView::on_waypoint_clicked_canvasview));
3730         }
3731         if(x=="children")
3732         {
3733                 children_tree=dynamic_cast<ChildrenTree*>(y);
3734                 if(children_tree)children_tree->signal_user_click().connect(sigc::mem_fun(*this, &studio::CanvasView::on_children_user_click));
3735                 if(children_tree)children_tree->signal_waypoint_clicked_childrentree().connect(sigc::mem_fun(*this, &studio::CanvasView::on_waypoint_clicked_canvasview));
3736                 if(children_tree)children_tree->get_selection()->signal_changed().connect(SLOT_EVENT(EVENT_REFRESH_DUCKS));
3737         }
3738         if(x=="keyframes")
3739                 keyframe_tree=dynamic_cast<KeyframeTree*>(y);
3740 }
3741
3742 bool
3743 CanvasView::on_delete_event(GdkEventAny* event __attribute__ ((unused)))
3744 {
3745         close_view();
3746
3747         //! \todo This causes the window to be deleted straight away - but what if we prompt 'save?' and the user cancels?
3748         //                Is there ever any need to pass on the delete event to the window here?
3749         // if(event) return Gtk::Window::on_delete_event(event);
3750
3751         return true;
3752 }