synfig-studio/src/gtkmm/state_width.cpp

   1 /* === S Y N F I G ========================================================= */
   2 /*!     \file state_width.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) 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 <gtkmm/dialog.h>
  34 #include <gtkmm/entry.h>
  35
  36 #include <ETL/bezier>
  37
  38 #include <synfig/valuenode_dynamiclist.h>
  39 #include <synfigapp/action_system.h>
  40
  41 #include "state_width.h"
  42 #include "canvasview.h"
  43 #include "workarea.h"
  44 #include "app.h"
  45
  46 #include <synfigapp/action.h>
  47 #include "event_mouse.h"
  48 #include "event_layerclick.h"
  49 #include "toolbox.h"
  50 #include "dialog_tooloptions.h"
  51 #include <gtkmm/optionmenu.h>
  52 #include "duck.h"
  53
  54 //#include <synfigapp/value_desc.h>
  55 #include <synfigapp/main.h>
  56
  57 #include <ETL/clock>
  58
  59 #include "general.h"
  60
  61 #endif
  62
  63 /* === U S I N G =========================================================== */
  64
  65 using namespace std;
  66 using namespace etl;
  67 using namespace synfig;
  68 using namespace synfigapp;
  69 using namespace studio;
  70
  71 /* === M A C R O S ========================================================= */
  72
  73 /* === G L O B A L S ======================================================= */
  74
  75 StateWidth studio::state_width;
  76
  77 /* === C L A S S E S & S T R U C T S ======================================= */
  78
  79 class studio::StateWidth_Context : public sigc::trackable
  80 {
  81         etl::handle<CanvasView> canvas_view_;
  82         CanvasView::IsWorking is_working;
  83
  84         //Point mouse_pos;
  85
  86         handle<Duck> center;
  87         handle<Duck> radius;
  88         handle<Duck> closestpoint;
  89
  90         map<handle<Duck>,Real>  changetable;
  91
  92         etl::clock      clocktime;
  93         Real            lastt;
  94
  95         bool added;
  96
  97         void refresh_ducks();
  98
  99         bool prev_workarea_layer_clicking;
 100         bool prev_workarea_duck_clicking;
 101         Duckmatic::Type old_duckmask;
 102
 103         //Toolbox settings
 104         synfigapp::Settings& settings;
 105
 106         //Toolbox display
 107         Gtk::Table options_table;
 108
 109         Gtk::Adjustment adj_delta;
 110         Gtk::SpinButton spin_delta;
 111
 112         Gtk::Adjustment adj_radius;
 113         Gtk::SpinButton spin_radius;
 114
 115         Gtk::CheckButton check_relative;
 116
 117         void AdjustWidth(handle<Duckmatic::Bezier> c, float t, Real mult, bool invert);
 118
 119 public:
 120
 121         Real get_delta()const { return adj_delta.get_value(); }
 122         void set_delta(Real f) { adj_delta.set_value(f); }
 123
 124         Real get_radius()const { return adj_radius.get_value(); }
 125         void set_radius(Real f) { adj_radius.set_value(f); }
 126
 127         bool get_relative() const { return check_relative.get_active(); }
 128         void set_relative(bool r) { check_relative.set_active(r); }
 129
 130         void refresh_tool_options(); //to refresh the toolbox
 131
 132         //events
 133         Smach::event_result event_stop_handler(const Smach::event& x);
 134         Smach::event_result event_refresh_handler(const Smach::event& x);
 135         Smach::event_result event_mouse_handler(const Smach::event& x);
 136         Smach::event_result event_refresh_tool_options(const Smach::event& x);
 137
 138         //constructor destructor
 139         StateWidth_Context(CanvasView* canvas_view);
 140         ~StateWidth_Context();
 141
 142         //Canvas interaction
 143         const etl::handle<CanvasView>& get_canvas_view()const{return canvas_view_;}
 144         etl::handle<synfigapp::CanvasInterface> get_canvas_interface()const{return canvas_view_->canvas_interface();}
 145         synfig::Canvas::Handle get_canvas()const{return canvas_view_->get_canvas();}
 146         WorkArea * get_work_area()const{return canvas_view_->get_work_area();}
 147
 148         //Modifying settings etc.
 149         void load_settings();
 150         void save_settings();
 151         void reset();
 152
 153 };      // END of class StateWidth_Context
 154
 155 /* === M E T H O D S ======================================================= */
 156
 157 StateWidth::StateWidth():
 158         Smach::state<StateWidth_Context>("width")
 159 {
 160         insert(event_def(EVENT_STOP,&StateWidth_Context::event_stop_handler));
 161         insert(event_def(EVENT_REFRESH,&StateWidth_Context::event_refresh_handler));
 162         insert(event_def(EVENT_WORKAREA_MOUSE_BUTTON_DOWN,&StateWidth_Context::event_mouse_handler));
 163         insert(event_def(EVENT_WORKAREA_MOUSE_BUTTON_DRAG,&StateWidth_Context::event_mouse_handler));
 164         insert(event_def(EVENT_WORKAREA_MOUSE_BUTTON_UP,&StateWidth_Context::event_mouse_handler));
 165         insert(event_def(EVENT_REFRESH_TOOL_OPTIONS,&StateWidth_Context::event_refresh_tool_options));
 166 }
 167
 168 StateWidth::~StateWidth()
 169 {
 170 }
 171
 172 void
 173 StateWidth_Context::load_settings()
 174 {
 175         String value;
 176
 177         //parse the arguments yargh!
 178         if(settings.get_value("width.delta",value))
 179                 set_delta(atof(value.c_str()));
 180         else
 181                 set_delta(6);
 182
 183         if(settings.get_value("width.radius",value))
 184                 set_radius(atof(value.c_str()));
 185         else
 186                 set_radius(15);
 187
 188         //defaults to false
 189         if(settings.get_value("width.relative",value) && value == "1")
 190                 set_relative(true);
 191         else
 192                 set_relative(false);
 193 }
 194
 195 void
 196 StateWidth_Context::save_settings()
 197 {
 198         settings.set_value("width.delta",strprintf("%f",get_delta()));
 199         settings.set_value("width.radius",strprintf("%f",get_radius()));
 200         settings.set_value("width.relative",get_relative()?"1":"0");
 201 }
 202
 203 void
 204 StateWidth_Context::reset()
 205 {
 206         refresh_ducks();
 207 }
 208
 209 StateWidth_Context::StateWidth_Context(CanvasView* canvas_view):
 210         canvas_view_(canvas_view),
 211         is_working(*canvas_view),
 212         prev_workarea_layer_clicking(get_work_area()->get_allow_layer_clicks()),
 213         prev_workarea_duck_clicking(get_work_area()->get_allow_duck_clicks()),
 214         old_duckmask(get_work_area()->get_type_mask()),
 215
 216         settings(synfigapp::Main::get_selected_input_device()->settings()),
 217
 218         adj_delta(6,0,20,0.01,0.1),
 219         spin_delta(adj_delta,0.01,3),
 220
 221         adj_radius(200,0,1e50,1,10),
 222         spin_radius(adj_radius,1,1),
 223
 224         check_relative(_("Relative Growth"))
 225 {
 226         load_settings();
 227
 228         // Set up the tool options dialog
 229         options_table.attach(*manage(new Gtk::Label(_("Width Tool"))),  0, 2, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
 230
 231         //expand stuff
 232         options_table.attach(*manage(new Gtk::Label(_("Growth:"))),             0, 1, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
 233         options_table.attach(spin_delta,                                                                1, 2, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
 234
 235         options_table.attach(*manage(new Gtk::Label(_("Radius:"))),             0, 1, 2, 3, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
 236         options_table.attach(spin_radius,                                                               1, 2, 2, 3, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
 237
 238         options_table.attach(check_relative,                                                    0, 2, 3, 4, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
 239
 240         options_table.show_all();
 241
 242         refresh_tool_options();
 243         App::dialog_tool_options->present();
 244
 245         // Turn off layer clicking
 246         get_work_area()->set_allow_layer_clicks(false);
 247
 248         // clear out the ducks
 249         //get_work_area()->clear_ducks();
 250
 251         // Refresh the work area
 252         get_work_area()->queue_draw();
 253
 254         //Create the new ducks
 255         added = false;
 256
 257         if(!center)
 258         {
 259                 center = new Duck();
 260                 center->set_name("p1");
 261                 center->set_type(Duck::TYPE_POSITION);
 262         }
 263
 264         if(!radius)
 265         {
 266                 radius = new Duck();
 267                 radius->set_origin(center);
 268                 radius->set_radius(true);
 269                 radius->set_type(Duck::TYPE_RADIUS);
 270                 radius->set_name("radius");
 271         }
 272
 273         if(!closestpoint)
 274         {
 275                 closestpoint = new Duck();
 276                 closestpoint->set_name("closest");
 277                 closestpoint->set_type(Duck::TYPE_POSITION);
 278         }
 279
 280         //Disable duck clicking for the maximum coolness :)
 281         get_work_area()->set_allow_duck_clicks(false);
 282         get_work_area()->set_type_mask((Duck::Type)((int)Duck::TYPE_WIDTH + (int)Duck::TYPE_RADIUS));
 283
 284         // Turn the mouse pointer to crosshairs
 285         get_work_area()->set_cursor(Gdk::CROSSHAIR);
 286
 287         // Hide the tables if they are showing
 288         //prev_table_status=get_canvas_view()->tables_are_visible();
 289         //if(prev_table_status)get_canvas_view()->hide_tables();
 290
 291         // Disable the time bar
 292         //get_canvas_view()->set_sensitive_timebar(false);
 293
 294         // Connect a signal
 295         //get_work_area()->signal_user_click().connect(sigc::mem_fun(*this,&studio::StateWidth_Context::on_user_click));
 296
 297         App::toolbox->refresh();
 298 }
 299
 300 void
 301 StateWidth_Context::refresh_tool_options()
 302 {
 303         App::dialog_tool_options->clear();
 304         App::dialog_tool_options->set_widget(options_table);
 305         App::dialog_tool_options->set_local_name(_("Width Tool"));
 306         App::dialog_tool_options->set_name("width");
 307 }
 308
 309 Smach::event_result
 310 StateWidth_Context::event_refresh_tool_options(const Smach::event& /*x*/)
 311 {
 312         refresh_tool_options();
 313         return Smach::RESULT_ACCEPT;
 314 }
 315
 316 StateWidth_Context::~StateWidth_Context()
 317 {
 318         save_settings();
 319
 320         //remove ducks if need be
 321         if(added)
 322         {
 323                 get_work_area()->erase_duck(center);
 324                 get_work_area()->erase_duck(radius);
 325                 get_work_area()->erase_duck(closestpoint);
 326                 added = false;
 327         }
 328
 329         // Restore Duck clicking
 330         get_work_area()->set_allow_duck_clicks(prev_workarea_duck_clicking);
 331
 332         // Restore layer clicking
 333         get_work_area()->set_allow_layer_clicks(prev_workarea_layer_clicking);
 334
 335         // Restore the mouse pointer
 336         get_work_area()->reset_cursor();
 337
 338         // Restore duck masking
 339         get_work_area()->set_type_mask(old_duckmask);
 340
 341         // Tool options be rid of ye!!
 342         App::dialog_tool_options->clear();
 343
 344         // Enable the time bar
 345         //get_canvas_view()->set_sensitive_timebar(true);
 346
 347         // Bring back the tables if they were out before
 348         //if(prev_table_status)get_canvas_view()->show_tables();
 349
 350         // Refresh the work area
 351         get_work_area()->queue_draw();
 352
 353         App::toolbox->refresh();
 354 }
 355
 356 Smach::event_result
 357 StateWidth_Context::event_stop_handler(const Smach::event& /*x*/)
 358 {
 359         //throw Smach::egress_exception();
 360         throw &state_normal;
 361         return Smach::RESULT_OK;
 362 }
 363
 364 Smach::event_result
 365 StateWidth_Context::event_refresh_handler(const Smach::event& /*x*/)
 366 {
 367         refresh_ducks();
 368         return Smach::RESULT_ACCEPT;
 369 }
 370
 371 void
 372 StateWidth_Context::AdjustWidth(handle<Duckmatic::Bezier> c, float t, Real mult, bool invert)
 373 {
 374         //Leave the function if there is no curve
 375         if(!c)return;
 376
 377         Real amount1=0,amount2=0;
 378
 379         //decide how much to change each width
 380         /*
 381         t \in [0,1]
 382
 383         both pressure and multiply amount are in mult
 384                 (may want to change this to allow different types of falloff)
 385
 386         rsq is the squared distance from the point on the curve (also part of the falloff)
 387
 388
 389         */
 390         //may want to provide a different falloff function...
 391         if(t <= 0.2)
 392                 amount1 = mult;
 393         else if(t >= 0.8)
 394                 amount2 = mult;
 395         else
 396         {
 397                 t = (t-0.2)/0.6;
 398                 amount1 = (1-t)*mult;
 399                 amount2 = t*mult;
 400         }
 401
 402         if(invert)
 403         {
 404                 amount1 *= -1;
 405                 amount2 *= -1;
 406         }
 407
 408         handle<Duck>    p1 = c->p1;
 409         handle<Duck>    p2 = c->p2;
 410
 411         handle<Duck>    w1,w2;
 412
 413         //find w1,w2
 414         {
 415                 const DuckList dl = get_work_area()->get_duck_list();
 416
 417                 DuckList::const_iterator i = dl.begin();
 418
 419                 for(;i != dl.end(); ++i)
 420                 {
 421                         if((*i)->get_type() == Duck::TYPE_WIDTH)
 422                         {
 423                                 if((*i)->get_origin_duck() == p1)
 424                                 {
 425                                         w1 = *i;
 426                                 }
 427
 428                                 if((*i)->get_origin_duck() == p2)
 429                                 {
 430                                         w2 = *i;
 431                                 }
 432                         }
 433                 }
 434         }
 435
 436         if(amount1 != 0 && w1)
 437         {
 438                 Real width = w1->get_point().mag();
 439
 440                 width += amount1;
 441                 w1->set_point(Vector(width,0));
 442
 443                 //log in the list of changes...
 444                 //to truly be changed after everything is said and done
 445                 changetable[w1] = width;
 446         }
 447
 448         if(amount2 != 0 && w2)
 449         {
 450                 Real width = w2->get_point().mag();
 451
 452                 width += amount2;
 453                 w2->set_point(Vector(width,0));
 454
 455                 //log in the list of changes...
 456                 //to truly be changed after everything is said and done
 457                 changetable[w2] = width;
 458         }
 459 }
 460
 461 Smach::event_result
 462 StateWidth_Context::event_mouse_handler(const Smach::event& x)
 463 {
 464         const EventMouse& event(*reinterpret_cast<const EventMouse*>(&x));
 465
 466         //handle the click
 467         if( (event.key == EVENT_WORKAREA_MOUSE_BUTTON_DOWN || event.key == EVENT_WORKAREA_MOUSE_BUTTON_DRAG)
 468                         && event.button == BUTTON_LEFT )
 469         {
 470                 const Real pw = get_work_area()->get_pw();
 471                 const Real ph = get_work_area()->get_ph();
 472                 const Real scale = sqrt(pw*pw+ph*ph);
 473                 const Real rad = get_relative() ? scale * get_radius() : get_radius();
 474
 475                 bool invert = (event.modifier&Gdk::CONTROL_MASK);
 476
 477                 const Real threshold = 0.08;
 478
 479                 float t = 0;
 480                 Real rsq = 0;
 481
 482                 Real dtime = 1/60.0;
 483
 484                 //if we're dragging get the difference in time between now and then
 485                 if(event.key == EVENT_WORKAREA_MOUSE_BUTTON_DRAG)
 486                 {
 487                         dtime = min(1/15.0,clocktime());
 488                 }
 489                 clocktime.reset();
 490
 491                 //make way for new ducks
 492                 //get_work_area()->clear_ducks();
 493
 494                 //update positions
 495                 //mouse_pos = event.pos;
 496
 497                 center->set_point(event.pos);
 498                 if(!added)get_work_area()->add_duck(center);
 499
 500                 radius->set_scalar(rad);
 501                 if(!added)get_work_area()->add_duck(radius);
 502
 503                 //the other duck is at the current duck
 504                 closestpoint->set_point(event.pos);
 505                 if(!added)get_work_area()->add_duck(closestpoint);
 506
 507                 //get the closest curve...
 508                 handle<Duckmatic::Bezier>       c;
 509                 if(event.pressure >= threshold)
 510                         c = get_work_area()->find_bezier(event.pos,scale*8,rad,&t);
 511
 512                 //run algorithm on event.pos to get 2nd placement
 513                 if(!c.empty())
 514                 {
 515                         bezier<Point> curve;
 516                         Point p;
 517
 518                         curve[0] = c->p1->get_trans_point();
 519                         curve[1] = c->c1->get_trans_point();
 520                         curve[2] = c->c2->get_trans_point();
 521                         curve[3] = c->p2->get_trans_point();
 522
 523                         p = curve(t);
 524                         rsq = (p-event.pos).mag_squared();
 525
 526                         const Real r = rad*rad;
 527
 528                         if(rsq < r)
 529                         {
 530                                 closestpoint->set_point(curve(t));
 531
 532                                 //adjust the width...
 533                                 //squared falloff for radius... [0,1]
 534
 535                                 Real ri = (r - rsq)/r;
 536                                 AdjustWidth(c,t,ri*event.pressure*get_delta()*dtime,invert);
 537                         }
 538                 }
 539
 540                 //the points have been added
 541                 added = true;
 542
 543                 //draw where it is yo!
 544                 get_work_area()->queue_draw();
 545
 546                 return Smach::RESULT_ACCEPT;
 547         }
 548
 549         if(event.key == EVENT_WORKAREA_MOUSE_BUTTON_UP && event.button == BUTTON_LEFT)
 550         {
 551                 if(added)
 552                 {
 553                         get_work_area()->erase_duck(center);
 554                         get_work_area()->erase_duck(radius);
 555                         get_work_area()->erase_duck(closestpoint);
 556                         added = false;
 557                 }
 558
 559                 //Affect the width changes here...
 560                 map<handle<Duck>,Real>::iterator i = changetable.begin();
 561
 562                 synfigapp::Action::PassiveGrouper group(get_canvas_interface()->get_instance().get(),_("Sketch Width"));
 563                 for(; i != changetable.end(); ++i)
 564                 {
 565                         //for each duck modify IT!!!
 566                         ValueDesc desc = i->first->get_value_desc();
 567
 568                         if(     desc.get_value_type() == ValueBase::TYPE_REAL )
 569                         {
 570                                 Action::Handle action(Action::create("ValueDescSet"));
 571                                 assert(action);
 572
 573                                 action->set_param("canvas",get_canvas());
 574                                 action->set_param("canvas_interface",get_canvas_interface());
 575
 576                                 action->set_param("value_desc",desc);
 577                                 action->set_param("new_value",ValueBase(i->second));
 578                                 action->set_param("time",get_canvas_view()->get_time());
 579
 580                                 if(!action->is_ready() || !get_canvas_view()->get_instance()->perform_action(action))
 581                                 {
 582                                         group.cancel();
 583                                         synfig::warning("Changing the width action has failed");
 584                                         return Smach::RESULT_ERROR;
 585                                 }
 586                         }
 587                 }
 588
 589                 changetable.clear();
 590
 591                 get_work_area()->queue_draw();
 592
 593                 return Smach::RESULT_ACCEPT;
 594         }
 595
 596         return Smach::RESULT_OK;
 597 }
 598
 599
 600 void
 601 StateWidth_Context::refresh_ducks()
 602 {
 603         get_work_area()->clear_ducks();
 604         get_work_area()->queue_draw();
 605 }