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

   1 /* === S Y N F I G ========================================================= */
   2 /*!     \file state_bline.cpp
   3 **      \brief Template File
   4 **
   5 **      $Id$
   6 **
   7 **      \legal
   8 **      Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
   9 **
  10 **      This package is free software; you can redistribute it and/or
  11 **      modify it under the terms of the GNU General Public License as
  12 **      published by the Free Software Foundation; either version 2 of
  13 **      the License, or (at your option) any later version.
  14 **
  15 **      This package is distributed in the hope that it will be useful,
  16 **      but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 **      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18 **      General Public License for more details.
  19 **      \endlegal
  20 */
  21 /* ========================================================================= */
  22
  23 /* === H E A D E R S ======================================================= */
  24
  25 #ifdef USING_PCH
  26 #       include "pch.h"
  27 #else
  28 #ifdef HAVE_CONFIG_H
  29 #       include <config.h>
  30 #endif
  31
  32 #include <gtkmm/dialog.h>
  33 #include <gtkmm/entry.h>
  34
  35 #include <synfig/valuenode_dynamiclist.h>
  36
  37 #include "state_bline.h"
  38 #include "canvasview.h"
  39 #include "workarea.h"
  40 #include "app.h"
  41 #include <synfig/valuenode_bline.h>
  42 #include <ETL/hermite>
  43 #include <ETL/calculus>
  44 #include <utility>
  45 #include "event_mouse.h"
  46 #include "event_layerclick.h"
  47 #include "toolbox.h"
  48 #include "dialog_tooloptions.h"
  49 #include <gtkmm/spinbutton.h>
  50 #include <synfig/transform.h>
  51 #include <synfigapp/main.h>
  52
  53 #endif
  54
  55 /* === U S I N G =========================================================== */
  56
  57 using namespace std;
  58 using namespace etl;
  59 using namespace synfig;
  60 using namespace studio;
  61
  62 /* === M A C R O S ========================================================= */
  63
  64 /* === G L O B A L S ======================================================= */
  65
  66 StateBLine studio::state_bline;
  67
  68 /* === C L A S S E S & S T R U C T S ======================================= */
  69
  70 class studio::StateBLine_Context : public sigc::trackable
  71 {
  72         etl::handle<CanvasView> canvas_view_;
  73         CanvasView::IsWorking is_working;
  74
  75         bool prev_table_status;
  76         bool loop_;
  77         bool prev_workarea_layer_status_;
  78
  79         int depth;
  80         Canvas::Handle canvas;
  81
  82         Gtk::Menu menu;
  83
  84         Duckmatic::Push duckmatic_push;
  85
  86         etl::handle<Duck> curr_duck;
  87
  88         etl::handle<Duck> next_duck;
  89
  90         std::list<synfig::ValueNode_Const::Handle> bline_point_list;
  91         synfigapp::Settings& settings;
  92
  93         bool on_vertex_change(const synfig::Point &point, synfig::ValueNode_Const::Handle value_node);
  94         bool on_tangent1_change(const synfig::Point &point, synfig::ValueNode_Const::Handle value_node);
  95         bool on_tangent2_change(const synfig::Point &point, synfig::ValueNode_Const::Handle value_node);
  96
  97
  98         void popup_handle_menu(synfig::ValueNode_Const::Handle value_node);
  99         void popup_vertex_menu(synfig::ValueNode_Const::Handle value_node);
 100         void popup_bezier_menu(float location, synfig::ValueNode_Const::Handle value_node);
 101
 102         void bline_detach_handle(synfig::ValueNode_Const::Handle value_node);
 103         void bline_attach_handle(synfig::ValueNode_Const::Handle value_node);
 104         void bline_delete_vertex(synfig::ValueNode_Const::Handle value_node);
 105         void bline_insert_vertex(synfig::ValueNode_Const::Handle value_node,float origin=0.5);
 106         void loop_bline();
 107         void unloop_bline();
 108
 109         void refresh_ducks(bool x=true);
 110
 111         Gtk::Table options_table;
 112         Gtk::Entry entry_id;
 113         Gtk::CheckButton checkbutton_layer_region;
 114         Gtk::CheckButton checkbutton_layer_bline;
 115         Gtk::CheckButton checkbutton_layer_curve_gradient;
 116         Gtk::CheckButton checkbutton_layer_link_offsets;
 117         Gtk::CheckButton checkbutton_auto_export;
 118         Gtk::Button button_make;
 119         Gtk::Button button_clear;
 120         Gtk::Adjustment  adj_feather;
 121         Gtk::SpinButton  spin_feather;
 122
 123
 124
 125 public:
 126
 127         int layers_to_create()const
 128         {
 129                 return
 130                         get_layer_region_flag()+
 131                         get_layer_bline_flag()+
 132                         get_layer_curve_gradient_flag();
 133         }
 134
 135         void sanity_check()
 136         {
 137                 if(layers_to_create()==0)
 138                         set_layer_region_flag(true);
 139         }
 140
 141         bool get_auto_export_flag()const { return checkbutton_auto_export.get_active(); }
 142         void set_auto_export_flag(bool x) { return checkbutton_auto_export.set_active(x); }
 143
 144         bool get_layer_region_flag()const { return checkbutton_layer_region.get_active(); }
 145         void set_layer_region_flag(bool x) { return checkbutton_layer_region.set_active(x); }
 146
 147         bool get_layer_bline_flag()const { return checkbutton_layer_bline.get_active(); }
 148         void set_layer_bline_flag(bool x) { return checkbutton_layer_bline.set_active(x); }
 149
 150         bool get_layer_curve_gradient_flag()const { return checkbutton_layer_curve_gradient.get_active(); }
 151         void set_layer_curve_gradient_flag(bool x) { return checkbutton_layer_curve_gradient.set_active(x); }
 152
 153         bool get_layer_link_offsets_flag()const { return checkbutton_layer_link_offsets.get_active(); }
 154         void set_layer_link_offsets_flag(bool x) { return checkbutton_layer_link_offsets.set_active(x); }
 155
 156         Real get_feather() const { return adj_feather.get_value(); }
 157         void set_feather(Real x) { return adj_feather.set_value(x); }
 158         synfig::String get_id()const { return entry_id.get_text(); }
 159         void set_id(const synfig::String& x) { return entry_id.set_text(x); }
 160
 161         Smach::event_result event_stop_handler(const Smach::event& x);
 162
 163         Smach::event_result event_refresh_handler(const Smach::event& x);
 164
 165         Smach::event_result event_mouse_click_handler(const Smach::event& x);
 166         Smach::event_result event_mouse_release_handler(const Smach::event& x);
 167         Smach::event_result event_mouse_motion_handler(const Smach::event& x);
 168         Smach::event_result event_refresh_tool_options(const Smach::event& x);
 169
 170         Smach::event_result event_hijack(const Smach::event& /*x*/) { return Smach::RESULT_ACCEPT; }
 171
 172         void refresh_tool_options();
 173
 174         StateBLine_Context(CanvasView* canvas_view);
 175
 176         ~StateBLine_Context();
 177
 178         const etl::handle<CanvasView>& get_canvas_view()const{return canvas_view_;}
 179         etl::handle<synfigapp::CanvasInterface> get_canvas_interface()const{return canvas_view_->canvas_interface();}
 180         synfig::Canvas::Handle get_canvas()const{return canvas_view_->get_canvas();}
 181         WorkArea * get_work_area()const{return canvas_view_->get_work_area();}
 182         const synfig::TransformStack& get_transform_stack()const { return canvas_view_->get_curr_transform_stack(); }
 183
 184         void load_settings();
 185         void save_settings();
 186         void reset();
 187         void increment_id();
 188         //void on_user_click(synfig::Point point);
 189
 190         bool run_();
 191         bool run();
 192
 193         bool egress_on_selection_change;
 194         Smach::event_result event_layer_selection_changed_handler(const Smach::event& /*x*/)
 195         {
 196                 if(egress_on_selection_change)
 197                         throw Smach::egress_exception();
 198                 return Smach::RESULT_OK;
 199         }
 200
 201 };      // END of class StateBLine_Context
 202
 203
 204 /* === M E T H O D S ======================================================= */
 205
 206 StateBLine::StateBLine():
 207         Smach::state<StateBLine_Context>("bline")
 208 {
 209         insert(event_def(EVENT_LAYER_SELECTION_CHANGED,&StateBLine_Context::event_layer_selection_changed_handler));
 210         insert(event_def(EVENT_STOP,&StateBLine_Context::event_stop_handler));
 211         insert(event_def(EVENT_REFRESH,&StateBLine_Context::event_refresh_handler));
 212         insert(event_def(EVENT_REFRESH_DUCKS,&StateBLine_Context::event_hijack));
 213         insert(event_def(EVENT_WORKAREA_MOUSE_BUTTON_DOWN,&StateBLine_Context::event_mouse_click_handler));
 214         insert(event_def(EVENT_WORKAREA_MOUSE_BUTTON_UP,&StateBLine_Context::event_mouse_release_handler));
 215         insert(event_def(EVENT_WORKAREA_MOUSE_MOTION,&StateBLine_Context::event_mouse_motion_handler));
 216         insert(event_def(EVENT_WORKAREA_MOUSE_BUTTON_DRAG,&StateBLine_Context::event_mouse_motion_handler));
 217         insert(event_def(EVENT_REFRESH_TOOL_OPTIONS,&StateBLine_Context::event_refresh_tool_options));
 218 }
 219
 220 StateBLine::~StateBLine()
 221 {
 222 }
 223
 224 void
 225 StateBLine_Context::load_settings()
 226 {
 227         String value;
 228
 229         if(settings.get_value("bline.layer_region",value) && value=="0")
 230                 set_layer_region_flag(false);
 231         else
 232                 set_layer_region_flag(true);
 233
 234         if(settings.get_value("bline.layer_bline",value) && value=="0")
 235                 set_layer_bline_flag(false);
 236         else
 237                 set_layer_bline_flag(true);
 238
 239         if(settings.get_value("bline.layer_curve_gradient",value) && value=="1")
 240                 set_layer_curve_gradient_flag(true);
 241         else
 242                 set_layer_curve_gradient_flag(false);
 243
 244         if(settings.get_value("bline.layer_link_offsets",value) && value=="0")
 245                 set_layer_link_offsets_flag(false);
 246         else
 247                 set_layer_link_offsets_flag(true);
 248
 249         if(settings.get_value("bline.auto_export",value) && value=="1")
 250                 set_auto_export_flag(true);
 251         else
 252                 set_auto_export_flag(false);
 253
 254         if(settings.get_value("bline.id",value))
 255                 set_id(value);
 256         else
 257                 set_id("NewBLine");
 258
 259         if(settings.get_value("bline.feather",value))
 260         {
 261                 Real n = atof(value.c_str());
 262                 set_feather(n);
 263         }
 264
 265         sanity_check();
 266 }
 267
 268 void
 269 StateBLine_Context::save_settings()
 270 {
 271         sanity_check();
 272         settings.set_value("bline.layer_bline",get_layer_bline_flag()?"1":"0");
 273         settings.set_value("bline.layer_region",get_layer_region_flag()?"1":"0");
 274         settings.set_value("bline.layer_curve_gradient",get_layer_curve_gradient_flag()?"1":"0");
 275         settings.set_value("bline.layer_link_offsets",get_layer_link_offsets_flag()?"1":"0");
 276         settings.set_value("bline.auto_export",get_auto_export_flag()?"1":"0");
 277         settings.set_value("bline.id",get_id().c_str());
 278         settings.set_value("bline.feather",strprintf("%f",get_feather()));
 279 }
 280
 281 void
 282 StateBLine_Context::reset()
 283 {
 284         loop_=false;
 285         bline_point_list.clear();
 286         refresh_ducks();
 287 }
 288
 289 void
 290 StateBLine_Context::increment_id()
 291 {
 292         String id(get_id());
 293         int number=1;
 294         int digits=0;
 295
 296         if(id.empty())
 297                 id="NewBLine";
 298
 299         // If there is a number
 300         // already at the end of the
 301         // id, then remove it.
 302         if(id[id.size()-1]<='9' && id[id.size()-1]>='0')
 303         {
 304                 // figure out how many digits it is
 305                 for(digits=0;(int)id.size()-1>=digits && id[id.size()-1-digits]<='9' && id[id.size()-1-digits]>='0';digits++)while(false);
 306
 307                 String str_number;
 308                 str_number=String(id,id.size()-digits,id.size());
 309                 id=String(id,0,id.size()-digits);
 310                 synfig::info("---------------- \"%s\"",str_number.c_str());
 311
 312                 number=atoi(str_number.c_str());
 313         }
 314         else
 315         {
 316                 number=1;
 317                 digits=3;
 318         }
 319
 320         number++;
 321
 322         // Add the number back onto the id
 323         {
 324                 const String format(strprintf("%%0%dd",digits));
 325                 id+=strprintf(format.c_str(),number);
 326         }
 327
 328         // Set the ID
 329         set_id(id);
 330 }
 331
 332
 333 StateBLine_Context::StateBLine_Context(CanvasView* canvas_view):
 334         canvas_view_(canvas_view),
 335         is_working(*canvas_view),
 336         loop_(false),
 337         prev_workarea_layer_status_(get_work_area()->get_allow_layer_clicks()),
 338         duckmatic_push(get_work_area()),
 339         settings(synfigapp::Main::get_selected_input_device()->settings()),
 340         entry_id(),
 341         checkbutton_layer_region(_("Fill")),
 342         checkbutton_layer_bline(_("Outline")),
 343         checkbutton_layer_curve_gradient(_("Gradient")),
 344         checkbutton_layer_link_offsets(_("Link Offsets")),
 345         checkbutton_auto_export(_("Auto Export")),
 346         button_make(_("Make")),
 347         button_clear(_("Clear")),
 348         adj_feather(0,0,10000,0.01,0.1),
 349         spin_feather(adj_feather,0.01,4)
 350 {
 351         depth=-1;
 352         egress_on_selection_change=true;
 353         load_settings();
 354
 355         // Set up the tool options dialog
 356         //options_table.attach(*manage(new Gtk::Label(_("BLine Tool"))), 0, 2, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
 357         options_table.attach(entry_id,                                                          0, 2,  1,  2, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
 358         options_table.attach(checkbutton_layer_region,                          0, 2,  2,  3, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
 359         options_table.attach(checkbutton_layer_bline,                           0, 2,  3,  4, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
 360         options_table.attach(checkbutton_layer_curve_gradient,          0, 2,  4,  5, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
 361         options_table.attach(checkbutton_layer_link_offsets,            0, 2,  5,  6, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
 362         options_table.attach(checkbutton_auto_export,                           0, 2,  6,  7, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
 363         options_table.attach(*manage(new Gtk::Label(_("Feather"))), 0, 1, 10, 11, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
 364         options_table.attach(spin_feather,                                                      1, 2, 10, 11, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
 365         //options_table.attach(button_make, 0, 2, 5, 6, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
 366         //button_make.signal_pressed().connect(sigc::mem_fun(*this,&StateBLine_Context::run));
 367         options_table.show_all();
 368         refresh_tool_options();
 369         App::dialog_tool_options->present();
 370
 371         // Turn off layer clicking
 372         get_work_area()->set_allow_layer_clicks(false);
 373
 374         // clear out the ducks
 375         get_work_area()->clear_ducks();
 376
 377         // Refresh the work area
 378         get_work_area()->queue_draw();
 379
 380         // Hide the tables if they are showing
 381         prev_table_status=get_canvas_view()->tables_are_visible();
 382         if(prev_table_status)get_canvas_view()->hide_tables();
 383
 384         // Disable the time bar
 385         get_canvas_view()->set_sensitive_timebar(false);
 386
 387         // Connect a signal
 388         //get_work_area()->signal_user_click().connect(sigc::mem_fun(*this,&studio::StateBLine_Context::on_user_click));
 389         get_canvas_view()->work_area->set_cursor(Gdk::CROSSHAIR);
 390
 391         App::toolbox->refresh();
 392 }
 393
 394 void
 395 StateBLine_Context::refresh_tool_options()
 396 {
 397         App::dialog_tool_options->clear();
 398         App::dialog_tool_options->set_widget(options_table);
 399         App::dialog_tool_options->set_local_name(_("BLine Tool"));
 400         App::dialog_tool_options->set_name("bline");
 401
 402         App::dialog_tool_options->add_button(
 403                 Gtk::StockID("gtk-execute"),
 404                 _("Make BLine and/or Region")
 405         )->signal_clicked().connect(
 406                 sigc::hide_return(sigc::mem_fun(
 407                         *this,
 408                         &StateBLine_Context::run
 409                 ))
 410         );
 411
 412         App::dialog_tool_options->add_button(
 413                 Gtk::StockID("gtk-clear"),
 414                 _("Clear current BLine")
 415         )->signal_clicked().connect(
 416                 sigc::mem_fun(
 417                         *this,
 418                         &StateBLine_Context::reset
 419                 )
 420         );
 421 }
 422
 423 Smach::event_result
 424 StateBLine_Context::event_refresh_tool_options(const Smach::event& /*x*/)
 425 {
 426         refresh_tool_options();
 427         return Smach::RESULT_ACCEPT;
 428 }
 429
 430 StateBLine_Context::~StateBLine_Context()
 431 {
 432         run();
 433
 434         save_settings();
 435         App::dialog_tool_options->clear();
 436
 437         get_canvas_view()->work_area->reset_cursor();
 438
 439         // Restore layer clicking
 440         get_work_area()->set_allow_layer_clicks(prev_workarea_layer_status_);
 441
 442         // Enable the time bar
 443         get_canvas_view()->set_sensitive_timebar(true);
 444
 445         // Bring back the tables if they were out before
 446         if(prev_table_status)get_canvas_view()->show_tables();
 447
 448 //      get_canvas_view()->get_smach().process_event(EVENT_REFRESH_DUCKS);
 449
 450         // Refresh the work area
 451         get_work_area()->queue_draw();
 452
 453         App::toolbox->refresh();
 454 }
 455
 456 Smach::event_result
 457 StateBLine_Context::event_stop_handler(const Smach::event& /*x*/)
 458 {
 459         synfig::info("STATE RotoBLine: Received Stop Event");
 460 //      run();
 461         reset();
 462 //      throw Smach::egress_exception();
 463 //      get_canvas_view()->get_smach().pop_state();
 464         return Smach::RESULT_ACCEPT;
 465 }
 466
 467 Smach::event_result
 468 StateBLine_Context::event_refresh_handler(const Smach::event& /*x*/)
 469 {
 470         synfig::info("STATE RotoBLine: Received Refresh Event");
 471         refresh_ducks();
 472         return Smach::RESULT_ACCEPT;
 473 }
 474
 475 bool
 476 StateBLine_Context::run()
 477 {
 478         sanity_check();
 479
 480         String err;
 481         bool success(false);
 482         for(int i=5;i>0 && !success;i--)try
 483         {
 484                 success=run_();
 485         }
 486         catch(String s)
 487         {
 488                 err=s;
 489         }
 490         if(!success && !err.empty())
 491         {
 492                 get_canvas_view()->get_ui_interface()->error(err);
 493         }
 494         return success;
 495 }
 496
 497 bool
 498 StateBLine_Context::run_()
 499 {
 500         curr_duck=0;
 501         next_duck=0;
 502
 503         // Now we need to generate it
 504
 505         if(bline_point_list.empty())
 506         {
 507                 return false;
 508         }
 509         if(bline_point_list.size()<2)
 510         {
 511                 //get_canvas_view()->get_ui_interface()->error(_("You need at least two (2) points to create a BLine"));
 512                 return false;
 513         }
 514
 515         do
 516         {
 517
 518                 // Create the action group
 519                 synfigapp::Action::PassiveGrouper group(get_canvas_interface()->get_instance().get(),_("New BLine"));
 520
 521                 std::vector<BLinePoint> new_list;
 522                 std::list<synfig::ValueNode_Const::Handle>::iterator iter;
 523                 const synfig::TransformStack& transform(get_transform_stack());
 524
 525                 for(iter=bline_point_list.begin();iter!=bline_point_list.end();++iter)
 526                 {
 527                         BLinePoint bline_point((*iter)->get_value().get(BLinePoint()));
 528                         Point new_vertex(transform.unperform(bline_point.get_vertex()));
 529
 530                         bline_point.set_tangent1(
 531                                 transform.unperform(
 532                                         bline_point.get_tangent1()+bline_point.get_vertex()
 533                                 ) -new_vertex
 534                         );
 535
 536                         bline_point.set_tangent2(
 537                                 transform.unperform(
 538                                         bline_point.get_tangent2()+bline_point.get_vertex()
 539                                 ) -new_vertex
 540                         );
 541
 542                         bline_point.set_vertex(new_vertex);
 543
 544                         new_list.push_back(bline_point);
 545                 }
 546
 547                 ValueNode_BLine::Handle value_node_bline(ValueNode_BLine::create(new_list));
 548                 assert(value_node_bline);
 549
 550                 ValueNode_Const::Handle value_node_offset(ValueNode_Const::create(Vector()));
 551                 assert(value_node_offset);
 552
 553                 // Set the looping flag
 554                 value_node_bline->set_loop(loop_);
 555
 556                 // Add the BLine to the canvas
 557                 if(get_auto_export_flag() && !get_canvas_interface()->add_value_node(value_node_bline,get_id()))
 558                 {
 559                         //get_canvas_view()->get_ui_interface()->error(_("Unable to add value node"));
 560                         group.cancel();
 561                         increment_id();
 562                         throw String(_("Unable to add value node"));
 563                         return false;
 564                 }
 565
 566                 Layer::Handle layer;
 567
 568                 // we are temporarily using the layer to hold something
 569                 layer=get_canvas_view()->get_selection_manager()->get_selected_layer();
 570
 571                 if(layer)
 572                 {
 573                         if(depth<0)
 574                                 depth=layer->get_depth();
 575                         if(!canvas)
 576                                 canvas=layer->get_canvas();
 577                 }
 578                 else
 579                         depth=0;
 580
 581                 if(!canvas)
 582                         canvas=get_canvas_view()->get_canvas();
 583
 584                 synfigapp::SelectionManager::LayerList layer_selection;
 585
 586                 // If we were asked to create a region layer, go ahead and do so
 587                 if(get_layer_region_flag())
 588                 {
 589                         synfigapp::PushMode push_mode(get_canvas_interface(),synfigapp::MODE_NORMAL);
 590
 591                         Layer::Handle layer(get_canvas_interface()->add_layer_to("region",canvas,depth));
 592                         assert(layer);
 593                         layer_selection.push_back(layer);
 594                         layer->set_description(get_id()+_(" Region"));
 595                         get_canvas_interface()->signal_layer_new_description()(layer,layer->get_description());
 596
 597                         if(get_feather())
 598                         {
 599                                 layer->set_param("feather",get_feather());
 600                                 get_canvas_interface()->signal_layer_param_changed()(layer,"feather");
 601                         }
 602
 603                         if(get_layer_bline_flag())
 604                                 layer->set_param("color",synfigapp::Main::get_background_color());
 605
 606                         // I don't know if it's safe to reuse the same layer_param_connect action, so I'm
 607                         // using 2 separate ones.
 608                         {
 609                                 synfigapp::Action::Handle action(synfigapp::Action::create("layer_param_connect"));
 610                                 assert(action);
 611
 612                                 action->set_param("canvas",get_canvas());
 613                                 action->set_param("canvas_interface",get_canvas_interface());
 614                                 action->set_param("layer",layer);
 615                                 if(!action->set_param("param",String("bline")))
 616                                         synfig::error("LayerParamConnect didn't like \"param\"");
 617                                 if(!action->set_param("value_node",ValueNode::Handle(value_node_bline)))
 618                                         synfig::error("LayerParamConnect didn't like \"value_node\"");
 619
 620                                 if(!get_canvas_interface()->get_instance()->perform_action(action))
 621                                 {
 622                                         //get_canvas_view()->get_ui_interface()->error(_("Unable to create Region layer"));
 623                                         group.cancel();
 624                                         throw String(_("Unable to create Region layer"));
 625                                         return false;
 626                                 }
 627                         }
 628
 629                         if (get_layer_link_offsets_flag())
 630                         {
 631                                 synfigapp::Action::Handle action(synfigapp::Action::create("layer_param_connect"));
 632                                 assert(action);
 633
 634                                 action->set_param("canvas",get_canvas());
 635                                 action->set_param("canvas_interface",get_canvas_interface());
 636                                 action->set_param("layer",layer);
 637                                 if(!action->set_param("param",String("offset")))
 638                                         synfig::error("LayerParamConnect didn't like \"param\"");
 639                                 if(!action->set_param("value_node",ValueNode::Handle(value_node_offset)))
 640                                         synfig::error("LayerParamConnect didn't like \"value_node\"");
 641
 642                                 if(!get_canvas_interface()->get_instance()->perform_action(action))
 643                                 {
 644                                         //get_canvas_view()->get_ui_interface()->error(_("Unable to create Region layer"));
 645                                         group.cancel();
 646                                         throw String(_("Unable to create Region layer"));
 647                                         return false;
 648                                 }
 649                         }
 650                 }
 651
 652                 // If we were asked to create a BLine layer, go ahead and do so
 653                 if(get_layer_bline_flag())
 654                 {
 655                         synfigapp::PushMode push_mode(get_canvas_interface(),synfigapp::MODE_NORMAL);
 656
 657                         Layer::Handle layer(get_canvas_interface()->add_layer_to("outline",canvas,depth));
 658                         assert(layer);
 659                         layer_selection.push_back(layer);
 660                         layer->set_description(get_id()+_(" Outline"));
 661                         get_canvas_interface()->signal_layer_new_description()(layer,layer->get_description());
 662                         if(get_feather())
 663                         {
 664                                 layer->set_param("feather",get_feather());
 665                                 get_canvas_interface()->signal_layer_param_changed()(layer,"feather");
 666                         }
 667
 668                         {
 669                                 synfigapp::Action::Handle action(synfigapp::Action::create("layer_param_connect"));
 670                                 assert(action);
 671
 672                                 action->set_param("canvas",get_canvas());
 673                                 action->set_param("canvas_interface",get_canvas_interface());
 674                                 action->set_param("layer",layer);
 675                                 if(!action->set_param("param",String("bline")))
 676                                         synfig::error("LayerParamConnect didn't like \"param\"");
 677                                 if(!action->set_param("value_node",ValueNode::Handle(value_node_bline)))
 678                                         synfig::error("LayerParamConnect didn't like \"value_node\"");
 679
 680                                 if(!get_canvas_interface()->get_instance()->perform_action(action))
 681                                 {
 682                                         //get_canvas_view()->get_ui_interface()->error(_("Unable to create BLine layer"));
 683                                         group.cancel();
 684                                         throw String(_("Unable to create Outline layer"));
 685                                         return false;
 686                                 }
 687                         }
 688
 689                         if (get_layer_link_offsets_flag())
 690                         {
 691                                 synfigapp::Action::Handle action(synfigapp::Action::create("layer_param_connect"));
 692                                 assert(action);
 693
 694                                 action->set_param("canvas",get_canvas());
 695                                 action->set_param("canvas_interface",get_canvas_interface());
 696                                 action->set_param("layer",layer);
 697                                 if(!action->set_param("param",String("offset")))
 698                                         synfig::error("LayerParamConnect didn't like \"param\"");
 699                                 if(!action->set_param("value_node",ValueNode::Handle(value_node_offset)))
 700                                         synfig::error("LayerParamConnect didn't like \"value_node\"");
 701
 702                                 if(!get_canvas_interface()->get_instance()->perform_action(action))
 703                                 {
 704                                         //get_canvas_view()->get_ui_interface()->error(_("Unable to create BLine layer"));
 705                                         group.cancel();
 706                                         throw String(_("Unable to create Outline layer"));
 707                                         return false;
 708                                 }
 709                         }
 710
 711                         /*if(get_layer_region_flag() && !get_auto_export_flag())
 712                         {
 713                                 get_canvas_interface()->auto_export(synfigapp::ValueDesc(layer,"bline"));
 714                         }*/
 715                 }
 716
 717
 718
 719                 // If we were asked to create a CurveGradient layer, go ahead and do so
 720                 if(get_layer_curve_gradient_flag())
 721                 {
 722                         synfigapp::PushMode push_mode(get_canvas_interface(),synfigapp::MODE_NORMAL);
 723
 724                         Layer::Handle layer(get_canvas_interface()->add_layer_to("curve_gradient",canvas,depth));
 725                         assert(layer);
 726                         layer_selection.push_back(layer);
 727                         layer->set_description(get_id()+_(" Gradient"));
 728                         get_canvas_interface()->signal_layer_new_description()(layer,layer->get_description());
 729
 730                         {
 731                                 synfigapp::Action::Handle action(synfigapp::Action::create("layer_param_connect"));
 732                                 assert(action);
 733
 734                                 action->set_param("canvas",get_canvas());
 735                                 action->set_param("canvas_interface",get_canvas_interface());
 736                                 action->set_param("layer",layer);
 737                                 if(!action->set_param("param",String("bline")))
 738                                         synfig::error("LayerParamConnect didn't like \"param\"");
 739                                 if(!action->set_param("value_node",ValueNode::Handle(value_node_bline)))
 740                                         synfig::error("LayerParamConnect didn't like \"value_node\"");
 741
 742                                 if(!get_canvas_interface()->get_instance()->perform_action(action))
 743                                 {
 744                                         //get_canvas_view()->get_ui_interface()->error(_("Unable to create BLine layer"));
 745                                         group.cancel();
 746                                         throw String(_("Unable to create Gradient layer"));
 747                                         return false;
 748                                 }
 749                         }
 750
 751                         if (get_layer_link_offsets_flag())
 752                         {
 753                                 synfigapp::Action::Handle action(synfigapp::Action::create("layer_param_connect"));
 754                                 assert(action);
 755
 756                                 action->set_param("canvas",get_canvas());
 757                                 action->set_param("canvas_interface",get_canvas_interface());
 758                                 action->set_param("layer",layer);
 759                                 if(!action->set_param("param",String("offset")))
 760                                         synfig::error("LayerParamConnect didn't like \"param\"");
 761                                 if(!action->set_param("value_node",ValueNode::Handle(value_node_offset)))
 762                                         synfig::error("LayerParamConnect didn't like \"value_node\"");
 763
 764                                 if(!get_canvas_interface()->get_instance()->perform_action(action))
 765                                 {
 766                                         //get_canvas_view()->get_ui_interface()->error(_("Unable to create BLine layer"));
 767                                         group.cancel();
 768                                         throw String(_("Unable to create Gradient layer"));
 769                                         return false;
 770                                 }
 771                         }
 772
 773                         /*if(get_layer_region_flag() && !get_auto_export_flag())
 774                         {
 775                                 get_canvas_interface()->auto_export(synfigapp::ValueDesc(layer,"bline"));
 776                         }*/
 777                 }
 778
 779                 egress_on_selection_change=false;
 780                 get_canvas_interface()->get_selection_manager()->clear_selected_layers();
 781                 get_canvas_interface()->get_selection_manager()->set_selected_layers(layer_selection);
 782                 egress_on_selection_change=true;
 783
 784                 //if(finish_bline_dialog.get_region_flag() || finish_bline_dialog.get_bline_flag())
 785                 //      get_canvas_interface()->signal_dirty_preview()();
 786
 787         } while(0);
 788
 789         reset();
 790         increment_id();
 791         return true;
 792 }
 793
 794 Smach::event_result
 795 StateBLine_Context::event_mouse_motion_handler(const Smach::event& x)
 796 {
 797         const EventMouse& event(*reinterpret_cast<const EventMouse*>(&x));
 798
 799         if(curr_duck)
 800         {
 801                 //synfig::info("Moved Duck");
 802                 Point p(get_work_area()->snap_point_to_grid(event.pos));
 803                 curr_duck->set_trans_point(p);
 804                 if(next_duck)
 805                         next_duck->set_trans_point(p);
 806                 get_work_area()->queue_draw();
 807                 return Smach::RESULT_ACCEPT;
 808         }
 809
 810         return Smach::RESULT_OK;
 811 }
 812
 813 Smach::event_result
 814 StateBLine_Context::event_mouse_release_handler(const Smach::event& /*x*/)
 815 {
 816         if(curr_duck)
 817         {
 818                 //synfig::info("Released current duck");
 819                 curr_duck->signal_edited()(curr_duck->get_point());
 820                 if(next_duck)
 821                 {
 822                         //synfig::info("grabbing next duck");
 823                         curr_duck=next_duck;
 824                         next_duck=0;
 825                 }
 826                 return Smach::RESULT_ACCEPT;
 827         }
 828         return Smach::RESULT_OK;
 829 }
 830
 831 Smach::event_result
 832 StateBLine_Context::event_mouse_click_handler(const Smach::event& x)
 833 {
 834         synfig::info("STATE BLINE: Received mouse button down Event");
 835         const EventMouse& event(*reinterpret_cast<const EventMouse*>(&x));
 836         switch(event.button)
 837         {
 838         case BUTTON_LEFT:
 839                 {
 840                         // If we are already looped up, then don't try to add anything else
 841                         if(loop_)
 842                                 return Smach::RESULT_OK;
 843
 844                         BLinePoint bline_point;
 845
 846                         bline_point.set_vertex(get_work_area()->snap_point_to_grid(event.pos));
 847                         //bline_point.set_width(synfigapp::Main::get_bline_width());
 848                         bline_point.set_width(1.0f);
 849                         bline_point.set_origin(0.5f);
 850                         bline_point.set_split_tangent_flag(false);
 851                         bline_point.set_tangent1(Vector(0,0));
 852
 853                         // set the tangent
 854                         /*
 855                         if(bline_point_list.empty())
 856                         {
 857                                 bline_point.set_tangent1(Vector(1,1));
 858                         }
 859                         else
 860                         {
 861                                 const Vector t(event.pos-bline_point_list.back()->get_value().get(BLinePoint()).get_vertex());
 862                                 bline_point.set_tangent1(t);
 863                         }
 864
 865                         if(bline_point_list.size()>1)
 866                         {
 867                                 std::list<synfig::ValueNode_Const::Handle>::iterator iter;
 868                                 iter=bline_point_list.end();
 869                                 iter--;iter--;
 870                                 BLinePoint prev(bline_point_list.back()->get_value().get(BLinePoint()));
 871                                 prev.set_tangent1(event.pos-(*iter)->get_value().get(BLinePoint()).get_vertex());
 872                                 bline_point_list.back()->set_value(prev);
 873                         };
 874                         */
 875
 876                         bline_point_list.push_back(ValueNode_Const::create(bline_point));
 877
 878                         refresh_ducks();
 879                         return Smach::RESULT_ACCEPT;
 880                 }
 881
 882         case BUTTON_RIGHT: // Intercept the right-button click to short-circut the pop-up menu
 883                 return Smach::RESULT_ACCEPT;
 884
 885         default:
 886                 return Smach::RESULT_OK;
 887         }
 888 }
 889
 890 void
 891 StateBLine_Context::refresh_ducks(bool button_down)
 892 {
 893         get_work_area()->clear_ducks();
 894         get_work_area()->queue_draw();
 895
 896         if(bline_point_list.empty())
 897                 return;
 898
 899         list<ValueNode_Const::Handle>::iterator iter;
 900
 901         handle<WorkArea::Bezier> bezier;
 902         handle<WorkArea::Duck> duck,tduck;
 903         BLinePoint bline_point;
 904
 905         for(iter=bline_point_list.begin();iter!=bline_point_list.end();++iter)
 906         {
 907                 ValueNode_Const::Handle value_node(*iter);
 908                 bline_point=(value_node->get_value().get(BLinePoint()));
 909                 assert(value_node);
 910
 911
 912                 // First add the duck associated with this vertex
 913                 duck=new WorkArea::Duck(bline_point.get_vertex());
 914                 duck->set_editable(true);
 915                 duck->set_type(Duck::TYPE_VERTEX);
 916                 duck->set_name(strprintf("%x-vertex",value_node.get()));
 917                 duck->signal_edited().connect(
 918                         sigc::bind(sigc::mem_fun(*this,&studio::StateBLine_Context::on_vertex_change),value_node)
 919                 );
 920                 duck->signal_user_click(2).connect(
 921                         sigc::bind(sigc::mem_fun(*this,&studio::StateBLine_Context::popup_vertex_menu),value_node)
 922                 );
 923                 duck->set_guid(value_node->get_guid()^GUID::hasher(0));
 924
 925                 get_work_area()->add_duck(duck);
 926
 927                 // Add the tangent1 duck
 928                 tduck=new WorkArea::Duck(bline_point.get_tangent1());
 929                 tduck->set_editable(true);
 930                 tduck->set_name(strprintf("%x-tangent1",value_node.get()));
 931                 tduck->set_origin(duck);
 932                 tduck->set_scalar(-0.33333333333333333);
 933                 tduck->set_tangent(true);
 934                 tduck->set_guid(value_node->get_guid()^GUID::hasher(3));
 935                 tduck->signal_edited().connect(
 936                         sigc::bind(sigc::mem_fun(*this,&studio::StateBLine_Context::on_tangent1_change),value_node)
 937                 );
 938                 tduck->signal_user_click(2).connect(
 939                         sigc::bind(sigc::mem_fun(*this,&studio::StateBLine_Context::popup_handle_menu),value_node)
 940                 );
 941
 942                 // See if we need to add that duck to the previous bezier
 943                 if(bezier)
 944                 {
 945                         get_work_area()->add_duck(tduck);
 946                         bezier->p2=duck;
 947                         bezier->c2=tduck;
 948
 949                         bezier->signal_user_click(2).connect(
 950                                 sigc::bind(
 951                                         sigc::mem_fun(
 952                                                 *this,
 953                                                 &studio::StateBLine_Context::popup_bezier_menu
 954                                         ),
 955                                         value_node
 956                                 )
 957                         );
 958
 959                         //get_work_area()->add_duck(bezier->c1);
 960                         //get_work_area()->add_duck(bezier->c2);
 961                         get_work_area()->add_bezier(bezier);
 962
 963                         bezier=0;
 964                 }
 965
 966                 // Now we see if we need to create a bezier
 967                 list<ValueNode_Const::Handle>::iterator next(iter);
 968                 next++;
 969
 970                 // If our next iterator is the end, then we don't need
 971                 // to add a bezier.
 972                 //if(next==bline_point_list.end() && !loop_)
 973                 //      continue;
 974
 975                 bezier=new WorkArea::Bezier();
 976
 977                 // Add the tangent2 duck
 978                 tduck=new WorkArea::Duck(bline_point.get_tangent2());
 979                 tduck->set_editable(true);
 980                 tduck->set_origin(duck);
 981                 tduck->set_scalar(0.33333333333333333);
 982                 tduck->set_tangent(true);
 983                 if(bline_point.get_split_tangent_flag())
 984                 {
 985                         tduck->set_name(strprintf("%x-tangent2",value_node.get()));
 986                         tduck->signal_edited().connect(
 987                                 sigc::bind(sigc::mem_fun(*this,&studio::StateBLine_Context::on_tangent2_change),value_node)
 988                         );
 989                 }
 990                 else
 991                 {
 992                         tduck->set_name(strprintf("%x-tangent1",value_node.get()));
 993                         tduck->signal_edited().connect(
 994                                 sigc::bind(sigc::mem_fun(*this,&studio::StateBLine_Context::on_tangent1_change),value_node)
 995                         );
 996                 }
 997                 tduck->set_guid(value_node->get_guid()^GUID::hasher(4));
 998                 tduck->signal_user_click(2).connect(
 999                         sigc::bind(sigc::mem_fun(*this,&studio::StateBLine_Context::popup_handle_menu),value_node)
1000                 );
1001
1002                 // Setup the next bezier
1003                 bezier->p1=duck;
1004                 bezier->c1=tduck;
1005
1006                 get_work_area()->add_duck(tduck);
1007                 curr_duck=tduck;
1008         }
1009
1010         // Add the loop, if requested
1011         if(bezier && loop_)
1012         {
1013                 curr_duck=0;
1014                 BLinePoint bline_point(bline_point_list.front()->get_value().get(BLinePoint()));
1015
1016                 duck=new WorkArea::Duck(bline_point.get_vertex());
1017                 duck->set_editable(true);
1018                 duck->set_name(strprintf("%x-vertex",bline_point_list.front().get()));
1019                 duck->signal_edited().connect(
1020                         sigc::bind(sigc::mem_fun(*this,&studio::StateBLine_Context::on_vertex_change),bline_point_list.front())
1021                 );
1022                 duck->signal_user_click(2).connect(
1023                         sigc::bind(sigc::mem_fun(*this,&studio::StateBLine_Context::popup_vertex_menu),bline_point_list.front())
1024                 );
1025                 get_work_area()->add_duck(duck);
1026
1027                 // Add the tangent1 duck
1028                 tduck=new WorkArea::Duck(bline_point.get_tangent1());
1029                 tduck->set_editable(true);
1030                 tduck->set_name(strprintf("%x-tangent1",bline_point_list.front().get()));
1031                 tduck->set_origin(duck);
1032                 tduck->set_scalar(-0.33333333333333333);
1033                 tduck->set_tangent(true);
1034                 tduck->signal_edited().connect(
1035                         sigc::bind(sigc::mem_fun(*this,&studio::StateBLine_Context::on_tangent1_change),bline_point_list.front())
1036                 );
1037                 tduck->signal_user_click(2).connect(
1038                         sigc::bind(sigc::mem_fun(*this,&studio::StateBLine_Context::popup_handle_menu),bline_point_list.front())
1039                 );
1040                 get_work_area()->add_duck(tduck);
1041
1042                 bezier->p2=duck;
1043                 bezier->c2=tduck;
1044
1045                 bezier->signal_user_click(2).connect(
1046                         sigc::bind(
1047                                 sigc::mem_fun(
1048                                         *this,
1049                                         &studio::StateBLine_Context::popup_bezier_menu
1050                                 ),
1051                                 bline_point_list.front()
1052                         )
1053                 );
1054
1055                 //get_work_area()->add_duck(bezier->c1);
1056                 get_work_area()->add_bezier(bezier);
1057         }
1058         if(bezier && !loop_)
1059         {
1060                 duck=new WorkArea::Duck(bline_point.get_vertex());
1061                 duck->set_editable(false);
1062                 duck->set_name("temp");
1063
1064                 // Add the tangent1 duck
1065                 tduck=new WorkArea::Duck(Vector(0,0));
1066                 tduck->set_editable(false);
1067                 tduck->set_name("ttemp");
1068                 tduck->set_origin(duck);
1069                 tduck->set_scalar(-0.33333333333333333);
1070
1071                 tduck->set_tangent(true);
1072                 bezier->p2=duck;
1073                 bezier->c2=tduck;
1074
1075                 get_work_area()->add_duck(bezier->p2);
1076                 //get_work_area()->add_duck(bezier->c2);
1077                 get_work_area()->add_bezier(bezier);
1078
1079                 duck->set_guid(GUID());
1080                 tduck->set_guid(GUID());
1081
1082                 next_duck=duck;
1083         }
1084
1085         if(!button_down)
1086         {
1087                 if(curr_duck)
1088                 {
1089                         if(next_duck)
1090                         {
1091                                 curr_duck=next_duck;
1092                                 next_duck=0;
1093                         }
1094                 }
1095         }
1096         get_work_area()->queue_draw();
1097 }
1098
1099
1100 bool
1101 StateBLine_Context::on_vertex_change(const synfig::Point &point, synfig::ValueNode_Const::Handle value_node)
1102 {
1103         BLinePoint bline_point(value_node->get_value().get(BLinePoint()));
1104         bline_point.set_vertex(point);
1105         value_node->set_value(bline_point);
1106         //refresh_ducks();
1107         return true;
1108 }
1109
1110 bool
1111 StateBLine_Context::on_tangent1_change(const synfig::Point &point, synfig::ValueNode_Const::Handle value_node)
1112 {
1113         BLinePoint bline_point(value_node->get_value().get(BLinePoint()));
1114         bline_point.set_tangent1(point);
1115         value_node->set_value(bline_point);
1116         //refresh_ducks();
1117         return true;
1118 }
1119
1120 bool
1121 StateBLine_Context::on_tangent2_change(const synfig::Point &point, synfig::ValueNode_Const::Handle value_node)
1122 {
1123         BLinePoint bline_point(value_node->get_value().get(BLinePoint()));
1124         bline_point.set_tangent2(point);
1125         value_node->set_value(bline_point);
1126         //refresh_ducks();
1127         return true;
1128 }
1129
1130 void
1131 StateBLine_Context::loop_bline()
1132 {
1133         loop_=true;
1134
1135         refresh_ducks(false);
1136 }
1137
1138 void
1139 StateBLine_Context::unloop_bline()
1140 {
1141         loop_=false;
1142
1143         refresh_ducks(false);
1144 }
1145
1146 void
1147 StateBLine_Context::popup_vertex_menu(synfig::ValueNode_Const::Handle value_node)
1148 {
1149         menu.items().clear();
1150
1151         if(loop_)
1152         {
1153                 menu.items().push_back(Gtk::Menu_Helpers::MenuElem("Unloop BLine",
1154                                 sigc::mem_fun(*this,&studio::StateBLine_Context::unloop_bline)
1155                 ));
1156         } else {
1157                 menu.items().push_back(Gtk::Menu_Helpers::MenuElem("Loop BLine",
1158                                 sigc::mem_fun(*this,&studio::StateBLine_Context::loop_bline)
1159                 ));
1160         }
1161
1162         menu.items().push_back(Gtk::Menu_Helpers::MenuElem("Delete Vertex",
1163                 sigc::bind(
1164                         sigc::mem_fun(*this,&studio::StateBLine_Context::bline_delete_vertex),
1165                         value_node
1166                 )
1167         ));
1168
1169         menu.popup(0,0);
1170 }
1171
1172 void
1173 StateBLine_Context::popup_bezier_menu(float location, synfig::ValueNode_Const::Handle value_node)
1174 {
1175         menu.items().clear();
1176
1177         menu.items().push_back(Gtk::Menu_Helpers::MenuElem("Insert Vertex",
1178                 sigc::bind(
1179                         sigc::bind(
1180                                 sigc::mem_fun(*this,&studio::StateBLine_Context::bline_insert_vertex),
1181                                 location
1182                         ),
1183                         value_node
1184                 )
1185         ));
1186
1187         menu.popup(0,0);
1188 }
1189
1190 void
1191 StateBLine_Context::bline_insert_vertex(synfig::ValueNode_Const::Handle value_node, float origin)
1192 {
1193         list<ValueNode_Const::Handle>::iterator iter;
1194
1195         for(iter=bline_point_list.begin();iter!=bline_point_list.end();++iter)
1196                 if(*iter==value_node)
1197                 {
1198                         list<ValueNode_Const::Handle>::iterator prev(iter);
1199                         --prev;
1200
1201                         BLinePoint bline_point;
1202
1203                         BLinePoint next_bline_point((*iter)->get_value().get(BLinePoint()));
1204                         BLinePoint prev_bline_point;
1205
1206                         if(iter!=bline_point_list.begin())
1207                         {
1208                                 prev_bline_point=(*prev)->get_value().get(BLinePoint());
1209                         }
1210                         else
1211                         {
1212                                 prev_bline_point.set_vertex(Point(0,0));
1213                                 prev_bline_point.set_width(next_bline_point.get_width());
1214                                 prev_bline_point.set_origin(0.5);
1215                                 prev_bline_point.set_split_tangent_flag(false);
1216                         }
1217
1218                         etl::hermite<Vector> curve(prev_bline_point.get_vertex(),next_bline_point.get_vertex(),prev_bline_point.get_tangent2(),next_bline_point.get_tangent1());
1219                         etl::derivative< etl::hermite<Vector> > deriv(curve);
1220
1221                         bline_point.set_vertex(curve(origin));
1222                         bline_point.set_width((next_bline_point.get_width()-prev_bline_point.get_width())*origin+prev_bline_point.get_width());
1223 #ifdef ETL_FIXED_DERIVATIVE
1224                         bline_point.set_tangent1(deriv(origin)*std::min(1.0f-origin,origin));
1225 #else
1226                         bline_point.set_tangent1(-deriv(origin)*std::min(1.0f-origin,origin));
1227 #endif
1228                         bline_point.set_tangent2(bline_point.get_tangent1());
1229                         bline_point.set_split_tangent_flag(false);
1230                         bline_point.set_origin(origin);
1231
1232 /*
1233                         bline_point.set_vertex((next_bline_point.get_vertex()+prev_bline_point.get_vertex())*0.5);
1234                         bline_point.set_width((next_bline_point.get_width()+prev_bline_point.get_width())*0.5);
1235                         bline_point.set_origin(origin);
1236                         bline_point.set_split_tangent_flag(false);
1237                         bline_point.set_tangent1((next_bline_point.get_vertex()-prev_bline_point.get_vertex())*0.5);
1238 */
1239
1240                         bline_point_list.insert(iter,ValueNode_Const::create(bline_point));
1241                         break;
1242                 }
1243
1244         if(iter==bline_point_list.end())
1245         {
1246                 get_canvas_view()->get_ui_interface()->error("Unable to find where to insert vertex, internal error, please report this bug");
1247         }
1248
1249         refresh_ducks(false);
1250 }
1251
1252 void
1253 StateBLine_Context::bline_delete_vertex(synfig::ValueNode_Const::Handle value_node)
1254 {
1255         list<ValueNode_Const::Handle>::iterator iter;
1256
1257         for(iter=bline_point_list.begin();iter!=bline_point_list.end();++iter)
1258                 if(*iter==value_node)
1259                 {
1260                         bline_point_list.erase(iter);
1261                         break;
1262                 }
1263         if(iter==bline_point_list.end())
1264         {
1265                 get_canvas_view()->get_ui_interface()->error("Unable to remove vertex, internal error, please report this bug");
1266         }
1267
1268         refresh_ducks(false);
1269 }
1270
1271 void
1272 StateBLine_Context::popup_handle_menu(synfig::ValueNode_Const::Handle value_node)
1273 {
1274         menu.items().clear();
1275
1276         BLinePoint bline_point(value_node->get_value().get(BLinePoint()));
1277
1278         if(bline_point.get_split_tangent_flag())
1279                 menu.items().push_back(Gtk::Menu_Helpers::MenuElem("Merge Tangents",
1280                         sigc::bind(
1281                                 sigc::mem_fun(*this,&studio::StateBLine_Context::bline_attach_handle),
1282                                 value_node
1283                         )
1284                 ));
1285         else
1286                 menu.items().push_back(Gtk::Menu_Helpers::MenuElem("Split Tangents",
1287                         sigc::bind(
1288                                 sigc::mem_fun(*this,&studio::StateBLine_Context::bline_detach_handle),
1289                                 value_node
1290                         )
1291                 ));
1292
1293         menu.popup(0,0);
1294 }
1295
1296 void
1297 StateBLine_Context::bline_detach_handle(synfig::ValueNode_Const::Handle value_node)
1298 {
1299         BLinePoint bline_point(value_node->get_value().get(BLinePoint()));
1300         bline_point.set_split_tangent_flag(true);
1301         bline_point.set_tangent2(bline_point.get_tangent1());
1302         value_node->set_value(bline_point);
1303         refresh_ducks(false);
1304 }
1305
1306 void
1307 StateBLine_Context::bline_attach_handle(synfig::ValueNode_Const::Handle value_node)
1308 {
1309         BLinePoint bline_point(value_node->get_value().get(BLinePoint()));
1310         bline_point.set_tangent1((bline_point.get_tangent1()+bline_point.get_tangent2())*0.5);
1311         bline_point.set_split_tangent_flag(false);
1312         value_node->set_value(bline_point);
1313         refresh_ducks(false);
1314 }