Add 2 new valuenode types: "Angle String" and "Int String".
[synfig.git] / synfig-studio / trunk / src / gtkmm / renderer_guides.cpp
1 /* === S Y N F I G ========================================================= */
2 /*!     \file renderer_guides.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 "renderer_guides.h"
33 #include "workarea.h"
34 #include <ETL/misc>
35
36 #include "general.h"
37
38 #endif
39
40 /* === U S I N G =========================================================== */
41
42 using namespace std;
43 using namespace etl;
44 using namespace synfig;
45 using namespace studio;
46
47 /* === M A C R O S ========================================================= */
48
49 /* === G L O B A L S ======================================================= */
50
51 /* === P R O C E D U R E S ================================================= */
52
53 /* === M E T H O D S ======================================================= */
54
55 Renderer_Guides::Renderer_Guides():
56         dragging(false)
57 {
58
59 }
60
61 Renderer_Guides::~Renderer_Guides()
62 {
63 }
64
65 bool
66 Renderer_Guides::get_enabled_vfunc()const
67 {
68         return get_work_area()->get_show_guides();
69 }
70
71 std::list<float>&
72 Renderer_Guides::get_guide_list_x()
73 {
74         return get_work_area()->get_guide_list_x();
75 }
76
77 std::list<float>&
78 Renderer_Guides::get_guide_list_y()
79 {
80         return get_work_area()->get_guide_list_y();
81 }
82
83 bool
84 Renderer_Guides::event_vfunc(GdkEvent* event)
85 {
86         synfig::Point mouse_pos;
87         // float bezier_click_pos;
88         // const float radius((abs(get_pw())+abs(get_ph()))*4);
89         int button_pressed(0);
90         float pressure(0);
91         bool is_mouse(false);
92         Gdk::ModifierType modifier(Gdk::ModifierType(0));
93
94         // Handle input stuff
95         if(
96                 event->any.type==GDK_MOTION_NOTIFY ||
97                 event->any.type==GDK_BUTTON_PRESS ||
98                 event->any.type==GDK_2BUTTON_PRESS ||
99                 event->any.type==GDK_3BUTTON_PRESS ||
100                 event->any.type==GDK_BUTTON_RELEASE
101         )
102         {
103                 GdkDevice *device;
104                 if(event->any.type==GDK_MOTION_NOTIFY)
105                 {
106                         device=event->motion.device;
107                         modifier=Gdk::ModifierType(event->motion.state);
108                 }
109                 else
110                 {
111                         device=event->button.device;
112                         modifier=Gdk::ModifierType(event->button.state);
113                 }
114
115                 // Make sure we recognize the device
116                 /*if(curr_input_device)
117                 {
118                         if(curr_input_device!=device)
119                         {
120                                 assert(device);
121                                 curr_input_device=device;
122                                 signal_input_device_changed()(curr_input_device);
123                         }
124                 }
125                 else*/ if(device)
126                 {
127                         //curr_input_device=device;
128                         //signal_input_device_changed()(curr_input_device);
129                 }
130
131                 //assert(curr_input_device);
132
133                 // Calculate the position of the
134                 // input device in canvas coordinates
135                 // and the buttons
136                 if(!event->button.axes)
137                 {
138                         mouse_pos=synfig::Point(screen_to_comp_coords(synfig::Point(event->button.x,event->button.y)));
139                         button_pressed=event->button.button;
140                         pressure=1.0f;
141                         is_mouse=true;
142                         if(isnan(event->button.x) || isnan(event->button.y))
143                                 return false;
144                 }
145                 else
146                 {
147                         double x(event->button.axes[0]);
148                         double y(event->button.axes[1]);
149                         if(isnan(x) || isnan(y))
150                                 return false;
151
152                         pressure=event->button.axes[2];
153                         //synfig::info("pressure=%f",pressure);
154                         pressure-=0.04f;
155                         pressure/=1.0f-0.04f;
156
157
158                         assert(!isnan(pressure));
159
160                         mouse_pos=synfig::Point(screen_to_comp_coords(synfig::Point(x,y)));
161
162                         button_pressed=event->button.button;
163
164                         if(button_pressed==1 && pressure<0 && (event->any.type!=GDK_BUTTON_RELEASE && event->any.type!=GDK_BUTTON_PRESS))
165                                 button_pressed=0;
166                         if(pressure<0)
167                                 pressure=0;
168
169                         //if(event->any.type==GDK_BUTTON_PRESS && button_pressed)
170                         //      synfig::info("Button pressed on input device = %d",event->button.button);
171
172                         //if(event->button.axes[2]>0.1)
173                         //      button_pressed=1;
174                         //else
175                         //      button_pressed=0;
176                 }
177         }
178         switch(event->type)
179     {
180         case GDK_BUTTON_PRESS:
181                 break;
182         case GDK_MOTION_NOTIFY:
183                 break;
184         case GDK_BUTTON_RELEASE:
185                 break;
186         default:
187                 break;
188         }
189
190         return false;
191 }
192
193 void
194 Renderer_Guides::render_vfunc(
195         const Glib::RefPtr<Gdk::Drawable>& drawable,
196         const Gdk::Rectangle& /*expose_area*/
197 )
198 {
199         assert(get_work_area());
200         if(!get_work_area())
201                 return;
202
203         // const synfig::RendDesc &rend_desc(get_work_area()->get_canvas()->rend_desc());
204
205         const synfig::Vector focus_point(get_work_area()->get_focus_point());
206
207         //std::vector< std::pair<Glib::RefPtr<Gdk::Pixbuf>,int> >& tile_book(get_tile_book());
208
209         int drawable_w,drawable_h;
210         drawable->get_size(drawable_w,drawable_h);
211
212         // Calculate the window coordinates of the top-left
213         // corner of the canvas.
214         // const synfig::Vector::value_type
215         //      x(focus_point[0]/get_pw()+drawable_w/2-get_w()/2),
216         //      y(focus_point[1]/get_ph()+drawable_h/2-get_h()/2);
217
218         /*const synfig::Vector::value_type window_startx(window_tl[0]);
219         const synfig::Vector::value_type window_endx(window_br[0]);
220         const synfig::Vector::value_type window_starty(window_tl[1]);
221         const synfig::Vector::value_type window_endy(window_br[1]);
222         */
223         // const int
224         //      tile_w(get_work_area()->get_tile_w()),
225         //      tile_h(get_work_area()->get_tile_h());
226
227         // const int
228         //      w(get_w()),
229         //      h(get_h());
230
231         Glib::RefPtr<Gdk::GC> gc(Gdk::GC::create(drawable));
232
233         //const synfig::Vector grid_size(get_grid_size());
234
235         const synfig::Vector::value_type window_startx(get_work_area()->get_window_tl()[0]);
236         // const synfig::Vector::value_type window_endx(get_work_area()->get_window_br()[0]);
237         const synfig::Vector::value_type window_starty(get_work_area()->get_window_tl()[1]);
238         // const synfig::Vector::value_type window_endy(get_work_area()->get_window_br()[1]);
239         const float pw(get_pw()),ph(get_ph());
240
241         // Draw out the guides
242         {
243                 gc->set_function(Gdk::COPY);
244                 gc->set_rgb_fg_color(Gdk::Color("#9f9fff"));
245                 gc->set_line_attributes(1,Gdk::LINE_ON_OFF_DASH,Gdk::CAP_BUTT,Gdk::JOIN_MITER);
246
247                 Duckmatic::GuideList::const_iterator iter;
248
249                 // vertical
250                 for(iter=get_guide_list_x().begin();iter!=get_guide_list_x().end();++iter)
251                 {
252                         const float x((*iter-window_startx)/pw);
253
254                         if(iter==get_work_area()->curr_guide)
255                                 gc->set_rgb_fg_color(Gdk::Color("#ff6f6f"));
256                         else
257                                 gc->set_rgb_fg_color(Gdk::Color("#6f6fff"));
258
259                         drawable->draw_line(gc,
260                                 round_to_int(x),
261                                 0,
262                                 round_to_int(x),
263                                 drawable_h
264                         );
265                 }
266                 // horizontal
267                 for(iter=get_guide_list_y().begin();iter!=get_guide_list_y().end();++iter)
268                 {
269                         const float y((*iter-window_starty)/ph);
270
271                         if(iter==get_work_area()->curr_guide)
272                                 gc->set_rgb_fg_color(Gdk::Color("#ff6f6f"));
273                         else
274                                 gc->set_rgb_fg_color(Gdk::Color("#6f6fff"));
275
276                         drawable->draw_line(gc,
277                                 0,
278                                 round_to_int(y),
279                                 drawable_w,
280                                 round_to_int(y)
281                         );
282                 }
283         }
284 }