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

   1 /* === S Y N F I G ========================================================= */
   2 /*!     \file state_scale.cpp
   3 **      \brief Template File
   4 **
   5 **      $Id: state_scale.cpp,v 1.1.1.1 2005/01/07 03:34:37 darco Exp $
   6 **
   7 **      \legal
   8 **      Copyright (c) 2002 Robert B. Quattlebaum Jr.
   9 **
  10 **      This software and associated documentation
  11 **      are CONFIDENTIAL and PROPRIETARY property of
  12 **      the above-mentioned copyright holder.
  13 **
  14 **      You may not copy, print, publish, or in any
  15 **      other way distribute this software without
  16 **      a prior written agreement with
  17 **      the copyright holder.
  18 **      \endlegal
  19 */
  20 /* ========================================================================= */
  21
  22 /* === H E A D E R S ======================================================= */
  23
  24 #ifdef USING_PCH
  25 #       include "pch.h"
  26 #else
  27 #ifdef HAVE_CONFIG_H
  28 #       include <config.h>
  29 #endif
  30
  31 #include <gtkmm/dialog.h>
  32 #include <gtkmm/entry.h>
  33
  34 #include <synfig/valuenode_dynamiclist.h>
  35 #include <synfigapp/action_system.h>
  36
  37 #include "state_scale.h"
  38 #include "canvasview.h"
  39 #include "workarea.h"
  40 #include "app.h"
  41
  42 #include <synfigapp/action.h>
  43 #include "event_mouse.h"
  44 #include "event_layerclick.h"
  45 #include "toolbox.h"
  46 #include "dialog_tooloptions.h"
  47 #include <gtkmm/optionmenu.h>
  48 #include "duck.h"
  49 #include <synfigapp/main.h>
  50
  51 #endif
  52
  53 /* === U S I N G =========================================================== */
  54
  55 using namespace std;
  56 using namespace etl;
  57 using namespace synfig;
  58 using namespace studio;
  59
  60 /* === M A C R O S ========================================================= */
  61
  62 /* === G L O B A L S ======================================================= */
  63
  64 StateScale studio::state_scale;
  65
  66 /* === C L A S S E S & S T R U C T S ======================================= */
  67
  68 class DuckDrag_Scale : public DuckDrag_Base
  69 {
  70
  71         synfig::Vector last_scale;
  72         synfig::Vector drag_offset;
  73         synfig::Vector center;
  74         synfig::Vector snap;
  75
  76         std::vector<synfig::Vector> positions;
  77
  78         bool move_only;
  79
  80         bool bad_drag;
  81 public:
  82         bool lock_aspect;
  83         DuckDrag_Scale();
  84         void begin_duck_drag(Duckmatic* duckmatic, const synfig::Vector& begin);
  85         bool end_duck_drag(Duckmatic* duckmatic);
  86         void duck_drag(Duckmatic* duckmatic, const synfig::Vector& vector);
  87 };
  88
  89
  90 class studio::StateScale_Context : public sigc::trackable
  91 {
  92         etl::handle<CanvasView> canvas_view_;
  93
  94         synfigapp::Settings& settings;
  95
  96         etl::handle<DuckDrag_Scale> duck_dragger_;
  97
  98         Gtk::Table options_table;
  99
 100
 101         Gtk::CheckButton checkbutton_aspect_lock;
 102
 103 public:
 104
 105         bool get_aspect_lock_flag()const { return checkbutton_aspect_lock.get_active(); }
 106         void set_aspect_lock_flag(bool x) { return checkbutton_aspect_lock.set_active(x); refresh_aspect_lock_flag(); }
 107
 108         void refresh_aspect_lock_flag() { if(duck_dragger_)duck_dragger_->lock_aspect=get_aspect_lock_flag(); }
 109
 110         Smach::event_result event_refresh_tool_options(const Smach::event& x);
 111
 112         void refresh_tool_options();
 113
 114         StateScale_Context(CanvasView* canvas_view);
 115
 116         ~StateScale_Context();
 117
 118         const etl::handle<CanvasView>& get_canvas_view()const{return canvas_view_;}
 119         etl::handle<synfigapp::CanvasInterface> get_canvas_interface()const{return canvas_view_->canvas_interface();}
 120         synfig::Canvas::Handle get_canvas()const{return canvas_view_->get_canvas();}
 121         WorkArea * get_work_area()const{return canvas_view_->get_work_area();}
 122
 123         void load_settings();
 124         void save_settings();
 125 };      // END of class StateScale_Context
 126
 127 /* === M E T H O D S ======================================================= */
 128
 129 StateScale::StateScale():
 130         Smach::state<StateScale_Context>("scale")
 131 {
 132         insert(event_def(EVENT_REFRESH_TOOL_OPTIONS,&StateScale_Context::event_refresh_tool_options));
 133 }
 134
 135 StateScale::~StateScale()
 136 {
 137 }
 138
 139 void
 140 StateScale_Context::load_settings()
 141 {
 142         String value;
 143
 144         if(settings.get_value("scale.lock_aspect",value) && value=="0")
 145                 set_aspect_lock_flag(false);
 146         else
 147                 set_aspect_lock_flag(true);
 148 }
 149
 150 void
 151 StateScale_Context::save_settings()
 152 {
 153         settings.set_value("scale.lock_aspect",get_aspect_lock_flag()?"1":"0");
 154 }
 155
 156 StateScale_Context::StateScale_Context(CanvasView* canvas_view):
 157         canvas_view_(canvas_view),
 158         settings(synfigapp::Main::get_selected_input_device()->settings()),
 159         duck_dragger_(new DuckDrag_Scale()),
 160         checkbutton_aspect_lock(_("Lock Aspect Ratio"))
 161 {
 162         // Set up the tool options dialog
 163         //options_table.attach(*manage(new Gtk::Label(_("Scale Tool"))), 0, 2, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
 164         options_table.attach(checkbutton_aspect_lock, 0, 2, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
 165
 166         checkbutton_aspect_lock.signal_toggled().connect(sigc::mem_fun(*this,&StateScale_Context::refresh_aspect_lock_flag));
 167
 168         options_table.show_all();
 169         refresh_tool_options();
 170         App::dialog_tool_options->present();
 171
 172         get_work_area()->allow_layer_clicks=true;
 173         get_work_area()->set_duck_dragger(duck_dragger_);
 174
 175 //      get_canvas_view()->work_area->set_cursor(Gdk::CROSSHAIR);
 176         get_canvas_view()->work_area->reset_cursor();
 177
 178         App::toolbox->refresh();
 179
 180         set_aspect_lock_flag(true);
 181         load_settings();
 182 }
 183
 184 void
 185 StateScale_Context::refresh_tool_options()
 186 {
 187         App::dialog_tool_options->clear();
 188         App::dialog_tool_options->set_widget(options_table);
 189         App::dialog_tool_options->set_local_name(_("Scale Tool"));
 190         App::dialog_tool_options->set_name("scale");
 191 }
 192
 193 Smach::event_result
 194 StateScale_Context::event_refresh_tool_options(const Smach::event& x)
 195 {
 196         refresh_tool_options();
 197         return Smach::RESULT_ACCEPT;
 198 }
 199
 200 StateScale_Context::~StateScale_Context()
 201 {
 202         save_settings();
 203
 204         get_work_area()->clear_duck_dragger();
 205         get_canvas_view()->work_area->reset_cursor();
 206
 207         App::dialog_tool_options->clear();
 208
 209         App::toolbox->refresh();
 210 }
 211
 212
 213
 214
 215 DuckDrag_Scale::DuckDrag_Scale():
 216         lock_aspect(true)
 217 {
 218 }
 219
 220 #ifndef EPSILON
 221 #define EPSILON 0.0000001
 222 #endif
 223
 224 void
 225 DuckDrag_Scale::begin_duck_drag(Duckmatic* duckmatic, const synfig::Vector& offset)
 226 {
 227         last_scale=Vector(1,1);
 228         const DuckList selected_ducks(duckmatic->get_selected_ducks());
 229         DuckList::const_iterator iter;
 230
 231         //if(duckmatic->get_selected_ducks().size()<2)
 232         //{
 233         //      bad_drag=true;
 234 //              return;
 235 //      }
 236         bad_drag=false;
 237
 238                 drag_offset=duckmatic->find_duck(offset)->get_trans_point();
 239
 240                 //snap=drag_offset-duckmatic->snap_point_to_grid(drag_offset);
 241                 //snap=offset-drag_offset;
 242                 snap=Vector(0,0);
 243
 244         // Calculate center
 245         Point vmin(100000000,100000000);
 246         Point vmax(-100000000,-100000000);
 247         //std::set<etl::handle<Duck> >::iterator iter;
 248         positions.clear();
 249         int i;
 250         for(i=0,iter=selected_ducks.begin();iter!=selected_ducks.end();++iter,i++)
 251         {
 252                 Point p((*iter)->get_trans_point());
 253                 vmin[0]=min(vmin[0],p[0]);
 254                 vmin[1]=min(vmin[1],p[1]);
 255                 vmax[0]=max(vmax[0],p[0]);
 256                 vmax[1]=max(vmax[1],p[1]);
 257                 positions.push_back(p);
 258         }
 259         if((vmin-vmax).mag()<=EPSILON)
 260                 move_only=true;
 261         else
 262                 move_only=false;
 263
 264         center=(vmin+vmax)*0.5;
 265 }
 266
 267
 268 void
 269 DuckDrag_Scale::duck_drag(Duckmatic* duckmatic, const synfig::Vector& vector)
 270 {
 271         const DuckList selected_ducks(duckmatic->get_selected_ducks());
 272         DuckList::const_iterator iter;
 273
 274         if(bad_drag)
 275                 return;
 276
 277         //std::set<etl::handle<Duck> >::iterator iter;
 278         synfig::Vector vect(duckmatic->snap_point_to_grid(vector)-center);
 279         last_scale=vect;
 280
 281         if(move_only)
 282         {
 283                 int i;
 284                 for(i=0,iter=selected_ducks.begin();iter!=selected_ducks.end();++iter,i++)
 285                 {
 286                         if(((*iter)->get_type()!=Duck::TYPE_VERTEX&&(*iter)->get_type()!=Duck::TYPE_POSITION))continue;
 287
 288                         Vector p(positions[i]);
 289
 290                         p[0]+=vect[0];
 291                         p[1]+=vect[1];
 292                         (*iter)->set_trans_point(p);
 293                 }
 294                 for(i=0,iter=selected_ducks.begin();iter!=selected_ducks.end();++iter,i++)
 295                 {
 296                         if(!((*iter)->get_type()!=Duck::TYPE_VERTEX&&(*iter)->get_type()!=Duck::TYPE_POSITION))continue;
 297
 298                         Vector p(positions[i]);
 299
 300                         p[0]+=vect[0];
 301                         p[1]+=vect[1];
 302                         (*iter)->set_trans_point(p);
 303                 }
 304                 return;
 305         }
 306
 307         if(!lock_aspect)
 308         {
 309                 if(abs(drag_offset[0]-center[0])>EPSILON)
 310                         vect[0]/=drag_offset[0]-center[0];
 311                 else
 312                         vect[0]=1;
 313                 if(abs(drag_offset[1]-center[1])>EPSILON)
 314                         vect[1]/=drag_offset[1]-center[1];
 315                 else
 316                         vect[1]=1;
 317                 }
 318         else
 319         {
 320                 //vect[0]=vect[1]=vect.mag()*0.707106781;
 321                 Real amount(vect.mag()/(drag_offset-center).mag());
 322                 vect[0]=vect[1]=amount;
 323         }
 324
 325         if(vect[0]<EPSILON && vect[0]>-EPSILON)
 326                 vect[0]=1;
 327         if(vect[1]<EPSILON && vect[1]>-EPSILON)
 328                 vect[1]=1;
 329
 330         int i;
 331         for(i=0,iter=selected_ducks.begin();iter!=selected_ducks.end();++iter,i++)
 332         {
 333                 if(((*iter)->get_type()!=Duck::TYPE_VERTEX&&(*iter)->get_type()!=Duck::TYPE_POSITION))continue;
 334
 335                 Vector p(positions[i]-center);
 336
 337                 p[0]*=vect[0];
 338                 p[1]*=vect[1];
 339                 p+=center;
 340                 (*iter)->set_trans_point(p);
 341         }
 342         for(i=0,iter=selected_ducks.begin();iter!=selected_ducks.end();++iter,i++)
 343         {
 344                 if(!((*iter)->get_type()!=Duck::TYPE_VERTEX&&(*iter)->get_type()!=Duck::TYPE_POSITION))continue;
 345
 346                 Vector p(positions[i]-center);
 347
 348                 p[0]*=vect[0];
 349                 p[1]*=vect[1];
 350                 p+=center;
 351                 (*iter)->set_trans_point(p);
 352         }
 353
 354         last_scale=vect;
 355         //snap=Vector(0,0);
 356 }
 357
 358 bool
 359 DuckDrag_Scale::end_duck_drag(Duckmatic* duckmatic)
 360 {
 361         if(bad_drag)return false;
 362
 363         if((last_scale-Vector(1,1)).mag()>0.0001)
 364         {
 365                 duckmatic->signal_edited_selected_ducks();
 366                 return true;
 367         }
 368         else
 369         {
 370                 duckmatic->signal_user_click_selected_ducks(0);
 371                 return false;
 372         }
 373 }