Fix some FTBFS issues when compiling with GCC 4.3
[synfig.git] / synfig-studio / trunk / src / gtkmm / dock_navigator.cpp
1 /* === S Y N F I G ========================================================= */
2 /*!     \file dock_navigator.cpp
3 **      \brief Dock Nagivator File
4 **
5 **      $Id$
6 **
7 **      \legal
8 **      Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
9 **      Copyright (c) 2007 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 "dock_navigator.h"
34 #include "canvasview.h"
35 #include "workarea.h"
36
37 #include <cassert>
38 #include <synfig/canvas.h>
39 #include <synfig/context.h>
40 #include <synfig/target_scanline.h>
41 #include <synfig/surface.h>
42
43 #include <gtkmm/separator.h>
44
45 #include "asyncrenderer.h"
46
47 #include "general.h"
48
49 #endif
50
51 /* === U S I N G =========================================================== */
52
53 using namespace std;
54 using namespace etl;
55 using namespace synfig;
56
57 /* === M A C R O S ========================================================= */
58
59 const double log_10_2 = log(2.0);
60
61 /* === G L O B A L S ======================================================= */
62
63 /* === P R O C E D U R E S ================================================= */
64
65 /* === M E T H O D S ======================================================= */
66
67 /* === E N T R Y P O I N T ================================================= */
68 studio::Widget_NavView::Widget_NavView(CanvasView::LooseHandle cv)
69 :canvview(cv),
70 adj_zoom(0,-4,4,1,2),
71 scrolling(false),
72 surface(new synfig::Surface)
73 {
74         attach(drawto,0,4,0,1);
75
76         attach(*manage(new Gtk::HSeparator),0,4,1,2,Gtk::SHRINK|Gtk::FILL,Gtk::SHRINK|Gtk::FILL);
77
78         //zooming stuff
79         attach(zoom_print,0,1,2,3,Gtk::SHRINK|Gtk::FILL,Gtk::SHRINK|Gtk::FILL);
80         zoom_print.set_size_request(40,-1);
81
82         Gtk::HScale *s = manage(new Gtk::HScale(adj_zoom));
83         s->set_draw_value(false);
84         //s->set_update_policy(Gtk::UPDATE_DELAYED);
85         //s->signal_event().connect(sigc::mem_fun(*this,&Dock_Navigator::on_scroll_event));
86         attach(*s,1,4,2,3,Gtk::EXPAND|Gtk::FILL,Gtk::SHRINK|Gtk::FILL);
87
88         show_all();
89
90         adj_zoom.signal_value_changed().connect(sigc::mem_fun(*this,&Widget_NavView::on_number_modify));
91
92         if(cv)
93         {
94                 drawto.signal_expose_event().connect(sigc::mem_fun(*this,&Widget_NavView::on_expose_draw));
95                 drawto.signal_event().connect(sigc::mem_fun(*this,&Widget_NavView::on_mouse_event));
96
97                 drawto.add_events(Gdk::BUTTON_MOTION_MASK|Gdk::BUTTON_PRESS_MASK);
98
99                 //get_canvas_view()->canvas_interface()->signal_dirty_preview()
100                 //                              .connect(sigc::mem_fun(*this,&Widget_NavView::on_dirty_preview));
101                 get_canvas_view()->work_area->signal_rendering()
102                                                 .connect(sigc::mem_fun(*this,&Widget_NavView::on_dirty_preview));
103
104                 get_canvas_view()->work_area->signal_view_window_changed()
105                                                 .connect(sigc::mem_fun(*this,&Widget_NavView::on_workarea_view_change));
106
107                 //update with this canvas' view
108                 on_workarea_view_change();
109
110                 dirty = true;
111                 queue_draw();
112         }
113
114         adj_zoom.set_value(0);
115 }
116
117 studio::Widget_NavView::~Widget_NavView()
118 {
119 }
120
121
122 static void freegu8(const guint8 *p)
123 {
124         delete [] p;
125 }
126
127 void studio::Widget_NavView::on_start_render()
128 {
129         if(dirty)
130         {
131                 //synfig::warning("Nav: Starting render");
132                 //synfig::warning("Nav: Rendering canvas");
133                 etl::handle<Target_Scanline>    targ = surface_target(surface.get());
134
135                 targ->set_canvas(get_canvas_view()->get_canvas());
136                 targ->set_remove_alpha();
137                 targ->set_avoid_time_sync();
138                 targ->set_quality(get_canvas_view()->get_work_area()->get_quality());
139                 //synfig::info("Set the quality level to: %d", get_canvas_view()->get_work_area()->get_quality());
140
141                 //this should set it to render a single frame
142                 RendDesc        r = get_canvas_view()->get_canvas()->rend_desc();
143                 r.set_time(get_canvas_view()->canvas_interface()->get_time());
144
145                 //this changes the size of the canvas to the closest thing we can find
146                 int sw = r.get_w(), sh = r.get_h();
147
148                 //synfig::warning("Nav: source image is %d x %d", sw,sh);
149
150                 //resize so largest dimension is 128
151                 int dw = sw > sh ? 128 : sw*128/sh,
152                         dh = sh > sw ? 128 : sh*128/sw;
153
154                 //synfig::warning("Nav: dest image is %d x %d", dw,dh);
155
156                 r.set_w(dw);
157                 r.set_h(dh);
158
159                 //get the pw and ph
160                 //float pw = r.get_pw();
161                 //float ph = r.get_ph();
162
163                 //synfig::warning("Nav: pixel size is %f x %f", pw,ph);
164
165                 //this renders that single frame
166                 targ->set_rend_desc(&r);
167
168                 //synfig::warning("Nav: Building async renderer and starting it...");
169
170                 renderer = new AsyncRenderer(targ);
171                 renderer->signal_success().connect(sigc::mem_fun(*this,&Widget_NavView::on_finish_render));
172                 dirty = false;
173                 renderer->start();
174         }
175 }
176
177 void studio::Widget_NavView::on_finish_render()
178 {
179         //convert it into our pixmap
180         PixelFormat pf(PF_RGB);
181
182         //synfig::warning("Nav: It hath succeeded!!!");
183
184         //assert(renderer && renderer->has_success());
185         //synfig::warning("Nav: now we know it really succeeded");
186         if(!*surface)
187         {
188                 synfig::warning("dock_navigator: Bad surface");
189                 return;
190         }
191
192         int w = 0, h = 0;
193         int dw = surface->get_w();
194         int dh = surface->get_h();
195
196         if(prev)
197         {
198                 w = prev->get_width();
199                 h = prev->get_height();
200         }
201
202         if(w != dw || h != dh || !prev)
203         {
204                 const int total_bytes(dw*dh*synfig::channels(pf));
205
206                 //synfig::warning("Nav: Updating the pixbuf to be the right size, etc. (%d bytes)", total_bytes);
207
208                 prev.clear();
209                 guint8 *bytes = new guint8[total_bytes]; //24 bits per pixel
210
211                 //convert into our buffered dataS
212                 //synfig::warning("Nav: converting color format into buffer");
213                 convert_color_format((unsigned char *)bytes, (*surface)[0], dw*dh, pf, App::gamma);
214
215                 prev =
216                 Gdk::Pixbuf::create_from_data(
217                         bytes,  // pointer to the data
218                         Gdk::COLORSPACE_RGB, // the colorspace
219                         ((pf&PF_A)==PF_A), // has alpha?
220                         8, // bits per sample
221                         dw,     // width
222                         dh,     // height
223                         dw*synfig::channels(pf), // stride (pitch)
224                         sigc::ptr_fun(freegu8)
225                 );
226         }
227         else
228         {
229                 //synfig::warning("Nav: Don't need to resize");
230                 //convert into our buffered dataS
231                 //synfig::warning("Nav: converting color format into buffer");
232                 if(prev) //just in case we're stupid
233                 {
234                         convert_color_format((unsigned char *)prev->get_pixels(), (*surface)[0], dw*dh, pf, App::gamma);
235                 }
236         }
237         queue_draw();
238 }
239
240 /*      zoom slider is on exponential scale
241
242         map: -4,4 -> small number,1600 with 100 at 0
243
244         f(x) = 100*2^x
245 */
246
247 static double unit_to_zoom(double f)
248 {
249         return pow(2.0,f);
250 }
251
252 static double zoom_to_unit(double f)
253 {
254         if(f > 0)
255         {
256                 return log(f) / log_10_2;
257         }else return -999999.0;
258 }
259
260 bool studio::Widget_NavView::on_expose_draw(GdkEventExpose */*exp*/)
261 {
262         // don't redraw if the previous redraw is still running single-threaded
263         // or we end up destroying the renderer that's rendering it
264         if (App::single_threaded && renderer && renderer->updating)
265                 return false;
266
267         //print out the zoom
268         //HACK kind of...
269         //zoom_print.set_text(strprintf("%.1f%%",100*unit_to_zoom(adj_zoom.get_value())));
270
271         //draw the good stuff
272         on_start_render();
273
274         //if we've got a preview etc. display it...
275         if(get_canvas_view() && prev)
276         {
277                 //axis transform from units to pixel coords
278                 float xaxis = 0, yaxis = 0;
279
280                 int canvw = get_canvas_view()->get_canvas()->rend_desc().get_w();
281                 //int canvh = get_canvas_view()->get_canvas()->rend_desc().get_h();
282
283                 float pw = get_canvas_view()->get_canvas()->rend_desc().get_pw();
284                 float ph = get_canvas_view()->get_canvas()->rend_desc().get_ph();
285
286                 int w = prev->get_width();
287                 int h = prev->get_height();
288
289                 //scale up/down to the nearest pixel ratio...
290                 //and center in center
291                 int offx=0, offy=0;
292
293                 float sx, sy;
294                 int nw,nh;
295
296                 sx = drawto.get_width() / (float)w;
297                 sy = drawto.get_height() / (float)h;
298
299                 //synfig::warning("Nav redraw: now to scale the bitmap: %.3f x %.3f",sx,sy);
300
301                 //round to smallest scale (fit entire thing in window without distortion)
302                 if(sx > sy) sx = sy;
303                 //else sy = sx;
304
305                 //scaling and stuff
306                 // the point to navpixel space conversion should be:
307                 //              (navpixels / canvpixels) * (canvpixels / canvsize)
308                 //      or (navpixels / prevpixels) * (prevpixels / navpixels)
309                 xaxis = sx * w / (float)canvw;
310                 yaxis = xaxis/ph;
311                 xaxis /= pw;
312
313                 //scale to a new pixmap and then copy over to the window
314                 nw = (int)(w*sx);
315                 nh = (int)(h*sx);
316
317                 //must now center to be cool
318                 offx = (drawto.get_width() - nw)/2;
319                 offy = (drawto.get_height() - nh)/2;
320
321                 //trivial escape
322                 if(nw == 0 || nh == 0)return true;
323
324                 //draw to drawing area
325                 Glib::RefPtr<Gdk::GC>   gc = Gdk::GC::create(drawto.get_window());
326
327                 //synfig::warning("Nav: Scaling pixmap to off (%d,%d) with size (%d,%d)", offx,offy,nw, nh);
328                 Glib::RefPtr<Gdk::Pixbuf> scalepx = prev->scale_simple(nw,nh,Gdk::INTERP_NEAREST);
329
330                 //synfig::warning("Nav: Drawing scaled bitmap");
331                 drawto.get_window()->draw_pixbuf(
332                         gc, //GC
333                         scalepx, //pixbuf
334                         0, 0,   // Source X and Y
335                         offx, offy,     // Dest X and Y
336                         -1,-1,  // Width and Height
337                         Gdk::RGB_DITHER_MAX, // RgbDither
338                         2, 2 // Dither offset X and Y
339                 );
340
341                 //draw fancy red rectangle around focus point
342                 const Point &wtl = get_canvas_view()->work_area->get_window_tl(),
343                                         &wbr = get_canvas_view()->work_area->get_window_br();
344
345                 gc->set_rgb_fg_color(Gdk::Color("#ff0000"));
346                 gc->set_line_attributes(2,Gdk::LINE_SOLID,Gdk::CAP_BUTT,Gdk::JOIN_MITER);
347
348                 //it must be clamped to the drawing area though
349                 int l=0,rw=0,t=0,rh=0;
350                 const Point fp = -get_canvas_view()->work_area->get_focus_point();
351
352                 //get focus point in normal space
353                 rw = (int)(abs((wtl[0]-wbr[0])*xaxis));
354                 rh = (int)(abs((wtl[1]-wbr[1])*yaxis));
355
356                 //transform into pixel space
357                 l = (int)(drawto.get_width()/2 + fp[0]*xaxis - rw/2);
358                 t = (int)(drawto.get_height()/2 + fp[1]*yaxis - rh/2);
359
360                 //coord system:
361                 // tl : (offx,offy)
362                 // axis multipliers = xaxis,yaxis
363                 //synfig::warning("Nav: tl (%f,%f), br (%f,%f)", wtl[0],wtl[1],wbr[0],wbr[1]);
364                 //synfig::warning("Nav: tl (%f,%f), br (%f,%f)", wtl[0],wtl[1],wbr[0],wbr[1]);
365                 //synfig::warning("Nav: Drawing Rectangle (%d,%d) with dim (%d,%d)", l,t,rw,rh);
366                 drawto.get_window()->draw_rectangle(gc,false,l,t,rw,rh);
367         }
368
369         return false; //draw everything else too
370 }
371
372 void studio::Widget_NavView::on_dirty_preview()
373 {
374         dirty = true;
375         queue_draw();
376 }
377
378 bool studio::Widget_NavView::on_scroll_event(GdkEvent *event)
379 {
380         if(get_canvas_view() && get_canvas_view()->get_work_area())
381         {
382                 double z = unit_to_zoom(adj_zoom.get_value());
383
384                 switch(event->type)
385                 {
386                         case GDK_BUTTON_PRESS:
387                         {
388                                 if(event->button.button == 1)
389                                 {
390                                         scrolling = true;
391                                         get_canvas_view()->get_work_area()->set_zoom(z);
392                                         scrolling = false;
393                                 }
394                                 break;
395                         }
396
397                         case GDK_MOTION_NOTIFY:
398                         {
399                                 if(Gdk::ModifierType(event->motion.state) & Gdk::BUTTON1_MASK)
400                                 {
401                                         scrolling = true;
402                                         get_canvas_view()->get_work_area()->set_zoom(z);
403                                         scrolling = false;
404                                 }
405                                 break;
406                         }
407
408                         default:
409                                 break;
410                 }
411         }
412
413         return false;
414 }
415
416 void studio::Widget_NavView::on_number_modify()
417 {
418         double z = unit_to_zoom(adj_zoom.get_value());
419         zoom_print.set_text(strprintf("%.1f%%",z*100.0));
420         //synfig::warning("Updating zoom to %f",adj_zoom.get_value());
421
422         if(get_canvas_view() && z != get_canvas_view()->get_work_area()->get_zoom())
423         {
424                 scrolling = true;
425                 get_canvas_view()->get_work_area()->set_zoom(z);
426                 scrolling = false;
427         }
428 }
429
430 void studio::Widget_NavView::on_workarea_view_change()
431 {
432         double wz = get_canvas_view()->get_work_area()->get_zoom();
433         double z = zoom_to_unit(wz);
434
435         //synfig::warning("Updating zoom to %f -> %f",wz,z);
436         if(!scrolling && z != adj_zoom.get_value())
437         {
438                 adj_zoom.set_value(z);
439                 //adj_zoom.value_changed();
440         }
441         queue_draw();
442 }
443
444 bool studio::Widget_NavView::on_mouse_event(GdkEvent * e)
445 {
446         Point p;
447         bool    setpos = false;
448
449         if(e->type == GDK_BUTTON_PRESS && e->button.button == 1)
450         {
451                 p[0] = e->button.x - drawto.get_width()/2;
452                 p[1] = e->button.y - drawto.get_height()/2;
453
454                 setpos = true;
455         }
456
457         if(e->type == GDK_MOTION_NOTIFY && (Gdk::ModifierType(e->motion.state) & Gdk::BUTTON1_MASK))
458         {
459                 p[0] = e->motion.x - drawto.get_width()/2;
460                 p[1] = e->motion.y - drawto.get_height()/2;
461
462                 setpos = true;
463         }
464
465         if(setpos && prev && get_canvas_view())
466         {
467                 const Point &tl = get_canvas_view()->get_canvas()->rend_desc().get_tl();
468                 const Point &br = get_canvas_view()->get_canvas()->rend_desc().get_br();
469
470                 float max = abs((br[0]-tl[0]) / drawto.get_width());
471
472                 if((float(prev->get_width()) / drawto.get_width()) < (float(prev->get_height()) / drawto.get_height()))
473                         max = abs((br[1]-tl[1]) / drawto.get_height());
474
475                 float signx = (br[0]-tl[0]) < 0 ? -1 : 1;
476                 float signy = (br[1]-tl[1]) < 0 ? -1 : 1;
477
478                 Point pos;
479
480                 pos[0] = p[0] * max * signx;
481                 pos[1] = p[1] * max * signy;
482
483                 get_canvas_view()->get_work_area()->set_focus_point(-pos);
484
485                 return true;
486         }
487
488         return false;
489 }
490
491 //Navigator Dock Definitions
492
493 studio::Dock_Navigator::Dock_Navigator()
494 :Dock_CanvasSpecific("navigator",_("Navigator"),Gtk::StockID("synfig-navigator"))
495 {
496         add(dummy);
497 }
498
499 studio::Dock_Navigator::~Dock_Navigator()
500 {
501 }
502
503 void studio::Dock_Navigator::changed_canvas_view_vfunc(etl::loose_handle<CanvasView> canvas_view)
504 {
505         if(canvas_view)
506         {
507                 Widget *v = canvas_view->get_ext_widget("navview");
508
509                 if(!v)
510                 {
511                         v = new Widget_NavView(canvas_view);
512                         canvas_view->set_ext_widget("navview",v);
513                 }
514
515                 add(*v);
516         }else
517         {
518                 clear_previous();
519                 //add(dummy);
520         }
521 }