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