Documentation for target_scanline.h
[synfig.git] / synfig-studio / src / gui / states / state_zoom.cpp
1 /* === S Y N F I G ========================================================= */
2 /*!     \file state_zoom.cpp
3 **      \brief Zoom Tool Implementation 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 <sigc++/signal.h>
34 #include <sigc++/object.h>
35
36 #include <ETL/handle>
37 #include <synfig/vector.h>
38
39
40 #include "state_zoom.h"
41 #include "state_normal.h"
42 #include "event_mouse.h"
43 #include "canvasview.h"
44 #include "workarea.h"
45 #include "app.h"
46 #include "toolbox.h"
47 #include <synfigapp/main.h>
48
49 #include "general.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 StateZoom studio::state_zoom;
64
65 const float ZOOMFACTOR = 1.25f;
66
67 /* === C L A S S E S & S T R U C T S ======================================= */
68
69 class studio::StateZoom_Context : public sigc::trackable
70 {
71         etl::handle<CanvasView> canvas_view_;
72         CanvasView::IsWorking is_working;
73
74         Point p1,p2;
75
76         bool prev_workarea_layer_status_;
77
78 public:
79
80         //events
81         Smach::event_result event_stop_handler(const Smach::event& x);
82         Smach::event_result event_refresh_handler(const Smach::event& x);
83         Smach::event_result event_mouse_click_handler(const Smach::event& x);
84
85         //constructor destructor
86         StateZoom_Context(CanvasView* canvas_view);
87         ~StateZoom_Context();
88
89         //Canvas interaction
90         const etl::handle<CanvasView>& get_canvas_view()const{return canvas_view_;}
91         etl::handle<synfigapp::CanvasInterface> get_canvas_interface()const{return canvas_view_->canvas_interface();}
92         synfig::Canvas::Handle get_canvas()const{return canvas_view_->get_canvas();}
93         WorkArea * get_work_area()const{return canvas_view_->get_work_area();}
94
95         //void zoom(const Point& p1, const Point& p2);
96
97 };      // END of class StateZoom_Context
98
99 /* === M E T H O D S ======================================================= */
100
101 StateZoom::StateZoom():
102         Smach::state<StateZoom_Context>("zoom")
103 {
104         insert(event_def(EVENT_STOP,&StateZoom_Context::event_stop_handler));
105         insert(event_def(EVENT_REFRESH,&StateZoom_Context::event_refresh_handler));
106         insert(event_def(EVENT_WORKAREA_MOUSE_BUTTON_DOWN,&StateZoom_Context::event_mouse_click_handler));
107         //insert(event_def(EVENT_WORKAREA_MOUSE_BUTTON_DRAG,&StateZoom_Context::event_mouse_click_handler));
108         insert(event_def(EVENT_WORKAREA_BOX,&StateZoom_Context::event_mouse_click_handler));
109         //insert(event_def(EVENT_WORKAREA_BUTTON_CLICK,&StateZoom_Context::event_mouse_click_handler));
110         insert(event_def(EVENT_WORKAREA_MOUSE_BUTTON_UP,&StateZoom_Context::event_mouse_click_handler));
111 }
112
113 StateZoom::~StateZoom()
114 {
115 }
116
117 StateZoom_Context::StateZoom_Context(CanvasView* canvas_view):
118         canvas_view_(canvas_view),
119         is_working(*canvas_view),
120         prev_workarea_layer_status_(get_work_area()->get_allow_layer_clicks())
121 {
122         // Turn off layer clicking
123         get_work_area()->set_allow_layer_clicks(false);
124
125         // clear out the ducks
126         get_work_area()->clear_ducks(); //???
127
128         // Refresh the work area
129         get_work_area()->queue_draw();
130
131         // Hide the tables if they are showing
132         //prev_table_status=get_canvas_view()->tables_are_visible();
133         //if(prev_table_status)get_canvas_view()->hide_tables();
134
135         // Disable the time bar
136         //get_canvas_view()->set_sensitive_timebar(false);
137
138         // Connect a signal
139         //get_work_area()->signal_user_click().connect(sigc::mem_fun(*this,&studio::StateZoom_Context::on_user_click));
140         get_work_area()->set_cursor(Gdk::CROSSHAIR);
141
142         App::toolbox->refresh();
143 }
144
145 StateZoom_Context::~StateZoom_Context()
146 {
147         // Restore layer clicking
148         get_work_area()->set_allow_layer_clicks(prev_workarea_layer_status_);
149         get_work_area()->reset_cursor();
150
151         // Enable the time bar
152         //get_canvas_view()->set_sensitive_timebar(true);
153
154         // Bring back the tables if they were out before
155         //if(prev_table_status)get_canvas_view()->show_tables();
156
157         // Refresh the work area
158         get_work_area()->queue_draw();
159
160         App::toolbox->refresh();
161
162         get_canvas_view()->get_smach().process_event(EVENT_REFRESH_DUCKS);
163 }
164
165 Smach::event_result
166 StateZoom_Context::event_stop_handler(const Smach::event& /*x*/)
167 {
168         //throw Smach::egress_exception();
169         throw &state_normal;
170         return Smach::RESULT_OK;
171 }
172
173 Smach::event_result
174 StateZoom_Context::event_refresh_handler(const Smach::event& /*x*/)
175 {
176         return Smach::RESULT_ACCEPT;
177 }
178
179 Smach::event_result
180 StateZoom_Context::event_mouse_click_handler(const Smach::event& x)
181 {
182         if(x.key==EVENT_WORKAREA_BOX)
183         {
184                 const EventBox& event(*reinterpret_cast<const EventBox*>(&x));
185
186                 if(event.button==BUTTON_LEFT)
187                 {
188                         Point tl = get_work_area()->get_window_tl();
189                         Point br = get_work_area()->get_window_br();
190                         Vector  window_span = br - tl, window_middle = (br+tl)/2;
191                         Vector  box_span = event.p2 - event.p1, box_middle = (event.p1+event.p2)/2;
192                         Point newpos;
193                         float zoom;
194
195                         if(event.modifier & Gdk::CONTROL_MASK) //zoom out...
196                         {
197                                 if (window_span[0] == 0 || window_span[1] == 0) zoom = 1;
198                                 else zoom = max(abs(box_span[0]/window_span[0]), abs(box_span[1]/window_span[1]));
199
200                                 // focus_point is -1 times the real position for some reason...
201                                 // center the window so the old contents fill the drawn box
202                                 newpos = -((window_middle - box_middle)/zoom + window_middle);
203                         }
204                         else                            // zoom in
205                         {
206                                 if (box_span[0] == 0 || box_span[1] == 0) zoom = 1;
207                                 else zoom = min(abs(window_span[0]/box_span[0]), abs(window_span[1]/box_span[1]));
208
209                                 // center the window at the center of the box
210                                 newpos = -(-get_work_area()->get_focus_point() + (box_middle - window_middle));
211                         }
212
213                         get_work_area()->set_focus_point(newpos);
214                         get_work_area()->set_zoom(get_work_area()->get_zoom()*zoom);
215
216                         return Smach::RESULT_ACCEPT;
217                 }
218         }
219
220         if(x.key==EVENT_WORKAREA_MOUSE_BUTTON_UP)
221         {
222                 const EventMouse& event(*reinterpret_cast<const EventMouse*>(&x));
223
224                 if(event.button==BUTTON_LEFT)
225                 {
226                         Point evpos;
227
228                         //make the event pos be in the same space...
229                         //   The weird ass inverted center normalized space...
230                         {
231                                 const Point realcenter = (get_work_area()->get_window_tl() + get_work_area()->get_window_br())/2;
232                                 evpos = -(event.pos - realcenter) + get_work_area()->get_focus_point();
233                         }
234
235                         /*      Zooming:
236                                 focus point must zoom about the point evpos...
237
238                                 trans about an origin not 0:
239                                 p' = A(p - o) + o
240                         */
241
242                         Vector v = get_work_area()->get_focus_point() - evpos;
243
244                         if(event.modifier & Gdk::CONTROL_MASK) //zoom out...
245                         {
246                                 v*=ZOOMFACTOR;
247                                 //get_work_area()->zoom_out();
248                                 get_work_area()->set_focus_point(evpos + v);
249                                 get_work_area()->set_zoom(get_work_area()->get_zoom()/ZOOMFACTOR);
250                         }else //zoom in
251                         {
252                                 v/=ZOOMFACTOR;
253                                 //get_work_area()->zoom_in();
254                                 get_work_area()->set_focus_point(evpos + v);
255                                 get_work_area()->set_zoom(get_work_area()->get_zoom()*ZOOMFACTOR);
256                         }
257
258                         return Smach::RESULT_ACCEPT;
259                 }
260         }
261
262         return Smach::RESULT_OK;
263 }