Add actions (add to group, ,remove from group, export, un-export, set layer descripti...
[synfig.git] / synfig-studio / src / gtkmm / widget_curves.cpp
1 /* === S Y N F I G ========================================================= */
2 /*!     \file widget_curves.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 Gerco Ballintijn
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 "widget_curves.h"
34 #include <cmath>
35 #include "app.h"
36 #include <gtkmm/drawingarea.h>
37 #include <map>
38 #include <vector>
39 #include <ETL/misc>
40 #include <sigc++/object.h>
41
42 #include "general.h"
43
44 #endif
45
46 /* === U S I N G =========================================================== */
47
48 using namespace std;
49 using namespace etl;
50 using namespace synfig;
51 using namespace studio;
52
53 /* === M A C R O S ========================================================= */
54
55 /* === G L O B A L S ======================================================= */
56
57 /* === P R O C E D U R E S ================================================= */
58
59 /*
60 void
61 studio::render_color_to_window(const Glib::RefPtr<Gdk::Drawable>& window,const Gdk::Rectangle& ca,const synfig::Color &color)
62 {
63         const int height(ca.get_height());
64         const int width(ca.get_width());
65
66         const int square_size(height/2);
67
68         Glib::RefPtr<Gdk::GC> gc(Gdk::GC::create(window));
69
70         if(color.get_alpha()!=1.0)
71         {
72                 // In this case we need to render the alpha squares
73
74                 const Color bg1(Color::blend(color,Color(0.75, 0.75, 0.75),1.0).clamped());
75                 const Color bg2(Color::blend(color,Color(0.5, 0.5, 0.5),1.0).clamped());
76
77                 Gdk::Color gdk_c1(colorconv_synfig2gdk(bg1));
78                 Gdk::Color gdk_c2(colorconv_synfig2gdk(bg2));
79
80                 bool toggle(false);
81                 for(int i=0;i<width;i+=square_size)
82                 {
83                         const int square_width(min(square_size,width-i));
84
85                         if(toggle)
86                         {
87                                 gc->set_rgb_fg_color(gdk_c1);
88                                 window->draw_rectangle(gc, true, ca.get_x()+i, ca.get_y(), square_width, square_size);
89
90                                 gc->set_rgb_fg_color(gdk_c2);
91                                 window->draw_rectangle(gc, true, ca.get_x()+i, ca.get_y()+square_size, square_width, square_size);
92                                 toggle=false;
93                         }
94                         else
95                         {
96                                 gc->set_rgb_fg_color(gdk_c2);
97                                 window->draw_rectangle(gc, true, ca.get_x()+i, ca.get_y(), square_width, square_size);
98
99                                 gc->set_rgb_fg_color(gdk_c1);
100                                 window->draw_rectangle(gc, true, ca.get_x()+i, ca.get_y()+square_size, square_width, square_size);
101                                 toggle=true;
102                         }
103                 }
104         }
105         else
106         {
107                 // In this case we have a solid color to use
108                 Gdk::Color gdk_c1(colorconv_synfig2gdk(color));
109
110                 gc->set_rgb_fg_color(gdk_c1);
111                 window->draw_rectangle(gc, true, ca.get_x(), ca.get_y(), width-1, height-1);
112         }
113         gc->set_rgb_fg_color(Gdk::Color("#ffffff"));
114         window->draw_rectangle(gc, false, ca.get_x()+1, ca.get_y()+1, width-3, height-3);
115         gc->set_rgb_fg_color(Gdk::Color("#000000"));
116         window->draw_rectangle(gc, false, ca.get_x(), ca.get_y(), width-1, height-1);
117 }
118 */
119
120 /* === C L A S S E S ======================================================= */
121
122
123
124 struct studio::Widget_Curves::Channel
125 {
126         synfig::String name;
127         Gdk::Color color;
128         std::map<synfig::Real,synfig::Real> values;
129 };
130
131 struct studio::Widget_Curves::CurveStruct : sigc::trackable
132 {
133         synfigapp::ValueDesc value_desc;
134         std::vector<Channel> channels;
135
136         CurveStruct(const synfigapp::ValueDesc& x):
137                 value_desc(x)
138         {
139                 switch(value_desc.get_value_type())
140                 {
141                         case ValueBase::TYPE_REAL:
142                                 channels.push_back(Channel());
143                                 channels.back().name="real";
144                                 channels.back().color=Gdk::Color("#007f7f");
145                                 break;
146                         case ValueBase::TYPE_TIME:
147                                 channels.push_back(Channel());
148                                 channels.back().name="time";
149                                 channels.back().color=Gdk::Color("#7f7f00");
150                                 break;
151                         case ValueBase::TYPE_INTEGER:
152                                 channels.push_back(Channel());
153                                 channels.back().name="int";
154                                 channels.back().color=Gdk::Color("#7f0000");
155                                 break;
156                         case ValueBase::TYPE_BOOL:
157                                 channels.push_back(Channel());
158                                 channels.back().name="bool";
159                                 channels.back().color=Gdk::Color("#ff7f00");
160                                 break;
161                         case ValueBase::TYPE_ANGLE:
162                                 channels.push_back(Channel());
163                                 channels.back().name="theta";
164                                 channels.back().color=Gdk::Color("#004f4f");
165                                 break;
166                         case ValueBase::TYPE_COLOR:
167                                 channels.push_back(Channel());
168                                 channels.back().name="red";
169                                 channels.back().color=Gdk::Color("#7f0000");
170                                 channels.push_back(Channel());
171                                 channels.back().name="green";
172                                 channels.back().color=Gdk::Color("#007f00");
173                                 channels.push_back(Channel());
174                                 channels.back().name="blue";
175                                 channels.back().color=Gdk::Color("#00007f");
176                                 channels.push_back(Channel());
177                                 channels.back().name="alpha";
178                                 channels.back().color=Gdk::Color("#000000");
179                                 break;
180                         case ValueBase::TYPE_VECTOR:
181                                 channels.push_back(Channel());
182                                 channels.back().name="x";
183                                 channels.back().color=Gdk::Color("#7f007f");
184                                 channels.push_back(Channel());
185                                 channels.back().name="y";
186                                 channels.back().color=Gdk::Color("#007f7f");
187                                 break;
188                         case ValueBase::TYPE_BLINEPOINT:
189                                 channels.push_back(Channel());
190                                 channels.back().name="v.x";
191                                 channels.back().color=Gdk::Color("#ff7f00");
192                                 channels.push_back(Channel());
193                                 channels.back().name="v.y";
194                                 channels.back().color=Gdk::Color("#7f3f00");
195
196                                 channels.push_back(Channel());
197                                 channels.back().name="width";
198                                 channels.back().color=Gdk::Color("#000000");
199
200                                 channels.push_back(Channel());
201                                 channels.back().name="origin";
202                                 channels.back().color=Gdk::Color("#ffffff");
203
204                                 channels.push_back(Channel());
205                                 channels.back().name="tsplit";
206                                 channels.back().color=Gdk::Color("#ff00ff");
207
208                                 channels.push_back(Channel());
209                                 channels.back().name="t1.x";
210                                 channels.back().color=Gdk::Color("#ff0000");
211                                 channels.push_back(Channel());
212                                 channels.back().name="t1.y";
213                                 channels.back().color=Gdk::Color("#7f0000");
214
215                                 channels.push_back(Channel());
216                                 channels.back().name="t2.x";
217                                 channels.back().color=Gdk::Color("#ffff00");
218                                 channels.push_back(Channel());
219                                 channels.back().name="t2.y";
220                                 channels.back().color=Gdk::Color("#7f7f00");
221                                 break;
222                         default:
223                                 throw synfig::Exception::BadType("Bad type for curves");
224                 }
225         }
226
227         void clear_all_values()
228         {
229                 std::vector<Channel>::iterator iter;
230                 for(iter=channels.begin();iter!=channels.end();++iter)
231                         iter->values.clear();
232         }
233
234         synfig::Real get_value(int chan, synfig::Real time, synfig::Real tolerance)
235         {
236                 std::map<synfig::Real,synfig::Real>::iterator iter;
237
238                 // First check to see if we have a value
239                 // that is "close enough" to the time
240                 // we are looking for
241                 iter=channels[chan].values.lower_bound(time);
242                 if(iter!=channels[chan].values.end() && iter->first-time<=tolerance)
243                         return -iter->second;
244
245                 // Since that didn't work, we now need
246                 // to go ahead and figure out what the
247                 // actual value is at that time.
248                 ValueBase value(value_desc.get_value(time));
249                 switch(value.get_type())
250                 {
251                         case ValueBase::TYPE_REAL:
252                                 channels[0].values[time]=value.get(Real());
253                                 break;
254                         case ValueBase::TYPE_TIME:
255                                 channels[0].values[time]=value.get(Time());
256                                 break;
257                         case ValueBase::TYPE_INTEGER:
258                                 channels[0].values[time]=value.get(int());
259                                 break;
260                         case ValueBase::TYPE_BOOL:
261                                 channels[0].values[time]=value.get(bool());
262                                 break;
263                         case ValueBase::TYPE_ANGLE:
264                                 channels[0].values[time]=Angle::rad(value.get(Angle())).get();
265                                 break;
266                         case ValueBase::TYPE_COLOR:
267                                 channels[0].values[time]=value.get(Color()).get_r();
268                                 channels[1].values[time]=value.get(Color()).get_g();
269                                 channels[2].values[time]=value.get(Color()).get_b();
270                                 channels[3].values[time]=value.get(Color()).get_a();
271                                 break;
272                         case ValueBase::TYPE_VECTOR:
273                                 channels[0].values[time]=value.get(Vector())[0];
274                                 channels[1].values[time]=value.get(Vector())[1];
275                                 break;
276                         case ValueBase::TYPE_BLINEPOINT:
277                                 channels[0].values[time]=value.get(BLinePoint()).get_vertex()[0];
278                                 channels[1].values[time]=value.get(BLinePoint()).get_vertex()[1];
279                                 channels[2].values[time]=value.get(BLinePoint()).get_width();
280                                 channels[3].values[time]=value.get(BLinePoint()).get_origin();
281                                 channels[4].values[time]=value.get(BLinePoint()).get_split_tangent_flag();
282                                 channels[5].values[time]=value.get(BLinePoint()).get_tangent1()[0];
283                                 channels[6].values[time]=value.get(BLinePoint()).get_tangent1()[1];
284                                 channels[7].values[time]=value.get(BLinePoint()).get_tangent2()[0];
285                                 channels[8].values[time]=value.get(BLinePoint()).get_tangent2()[1];
286                                 break;
287                         default:
288                                 return 0;
289                 }
290
291                 return -channels[chan].values[time];
292         }
293
294         static bool is_not_supported(const synfigapp::ValueDesc& x)
295         {
296                 return x.get_value_type() == ValueBase::TYPE_STRING
297                         || x.get_value_type() == ValueBase::TYPE_CANVAS
298                         || x.get_value_type() == ValueBase::TYPE_GRADIENT
299                         || x.get_value_type() == ValueBase::TYPE_LIST
300                         || x.get_value_type() == ValueBase::TYPE_SEGMENT;
301         }
302 };
303
304 /* === M E T H O D S ======================================================= */
305
306 Widget_Curves::Widget_Curves():
307         range_adjustment_(new Gtk::Adjustment(-1,-2,2,0.1,0.1,2))
308 {
309         set_size_request(64,64);
310
311         range_adjustment_->signal_changed().connect(
312                 sigc::mem_fun(
313                         *this,
314                         &Widget_Curves::queue_draw
315                 )
316         );
317         range_adjustment_->signal_value_changed().connect(
318                 sigc::mem_fun(
319                         *this,
320                         &Widget_Curves::queue_draw
321                 )
322         );
323         //set_vadjustment(*range_adjustment_);
324
325         signal_expose_event().connect(sigc::mem_fun(*this, &studio::Widget_Curves::redraw));
326         add_events(Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK);
327
328 }
329
330 Widget_Curves::~Widget_Curves()
331 {
332 }
333
334 void
335 Widget_Curves::set_time_adjustment(Gtk::Adjustment&x)
336 {
337         time_adjustment_=&x;
338         time_adjustment_->signal_changed().connect(
339                 sigc::mem_fun(
340                         *this,
341                         &Widget_Curves::queue_draw
342                 )
343         );
344         time_adjustment_->signal_value_changed().connect(
345                 sigc::mem_fun(
346                         *this,
347                         &Widget_Curves::queue_draw
348                 )
349         );
350         //set_hadjustment(*time_adjustment_);
351 }
352
353 void
354 Widget_Curves::clear()
355 {
356         curve_list_.clear();
357 }
358
359 void
360 Widget_Curves::refresh()
361 {
362         std::list<CurveStruct>::iterator curve_iter;
363         for(curve_iter=curve_list_.begin();curve_iter!=curve_list_.end();++curve_iter)
364         {
365                 curve_iter->clear_all_values();
366         }
367         queue_draw();
368 }
369
370 void
371 Widget_Curves::set_value_descs(std::list<synfigapp::ValueDesc> value_descs)
372 {
373         curve_list_.clear();
374
375         std::list<synfigapp::ValueDesc>::iterator iter;
376         for(iter=value_descs.begin();iter!=value_descs.end();++iter)
377         {
378                 if (CurveStruct::is_not_supported(*iter))
379                         continue;
380
381                 try {
382                         curve_list_.push_back(*iter);
383                         if(iter->is_value_node())
384                         {
385                                 iter->get_value_node()->signal_changed().connect(
386                                         sigc::mem_fun(
387                                                 *this,
388                                                 &studio::Widget_Curves::refresh
389                                         )
390                                 );
391                         }
392                         if(iter->parent_is_value_node())
393                         {
394                                 iter->get_parent_value_node()->signal_changed().connect(
395                                         sigc::mem_fun(
396                                                 *this,
397                                                 &studio::Widget_Curves::refresh
398                                         )
399                                 );
400                         }
401                         if(iter->parent_is_layer_param())
402                         {
403                                 iter->get_layer()->signal_changed().connect(
404                                         sigc::mem_fun(
405                                                 *this,
406                                                 &studio::Widget_Curves::refresh
407                                         )
408                                 );
409                         }
410                 }catch(synfig::Exception::BadType)
411                 {
412                         continue;
413                 }
414         }
415         queue_draw();
416 }
417
418 bool
419 Widget_Curves::on_event(GdkEvent *event)
420 {
421         switch(event->type)
422         {
423         case GDK_SCROLL:
424                 switch(event->scroll.direction)
425                 {
426                         case GDK_SCROLL_UP:
427                                 range_adjustment_->set_page_size(range_adjustment_->get_page_size()/1.25);
428                                 range_adjustment_->changed();
429                                 break;
430                         case GDK_SCROLL_DOWN:
431                                 range_adjustment_->set_page_size(range_adjustment_->get_page_size()*1.25);
432                                 range_adjustment_->changed();
433                                 break;
434                         default:
435                                 break;
436                 }
437                 break;
438         default:
439                 return Gtk::DrawingArea::on_event(event);
440                 break;
441         }
442
443         return true;
444
445 /*      switch(event->type)
446         {
447         case GDK_BUTTON_PRESS:
448                 if(event->button.button==1)
449                 {
450                         signal_activate_();
451                         return true;
452                 }
453                 if(event->button.button==3)
454                 {
455                         signal_secondary_();
456                         return true;
457                 }
458                 break;
459
460         default:
461                 break;
462         }
463         return false;
464 */
465 }
466
467 bool
468 Widget_Curves::redraw(GdkEventExpose */*bleh*/)
469 {
470         const int h(get_height());
471         const int w(get_width());
472         get_window()->clear();
473
474         if(!time_adjustment_ || !range_adjustment_ || !h || !w)
475                 return false;
476
477         if(!curve_list_.size())
478                 return false;
479
480         Glib::RefPtr<Gdk::GC> gc(Gdk::GC::create(get_window()));
481
482         const Real t_begin(time_adjustment_->get_lower());
483         const Real t_end(time_adjustment_->get_upper());
484         const Real dt((t_end-t_begin)/w);
485
486         const Real r_bottom(range_adjustment_->get_value());
487         const Real r_top(r_bottom+range_adjustment_->get_page_size());
488         const Real dr((r_top-r_bottom)/h);
489         Real r_max(-100000000);
490         Real r_min(100000000);
491
492         std::list<CurveStruct>::iterator curve_iter;
493
494         vector<Gdk::Point> points[10];
495
496         gc->set_function(Gdk::COPY);
497         gc->set_line_attributes(1,Gdk::LINE_SOLID,Gdk::CAP_BUTT,Gdk::JOIN_MITER);
498
499         // Draw zero mark
500         gc->set_rgb_fg_color(Gdk::Color("#4f4f4f"));
501         get_window()->draw_rectangle(gc, false, 0, round_to_int((0-r_bottom)/dr), w, 0);
502
503         // This try to find a valid vanvas to show the keyframes of those
504         // valuenodes. If not canvas found then no keyframes marks are shown.
505         synfig::Canvas::Handle canvas=0;
506         for(curve_iter=curve_list_.begin();curve_iter!=curve_list_.end();++curve_iter)
507         {
508                 canvas=curve_iter->value_desc.get_canvas();
509                 if(canvas)
510                         break;
511         }
512
513         if(canvas)
514         {
515         // Draw vertical lines for the keyframes marks.
516                 const synfig::KeyframeList& keyframe_list(canvas->keyframe_list());
517                 synfig::KeyframeList::const_iterator iter;
518
519                 for(iter=keyframe_list.begin();iter!=keyframe_list.end();++iter)
520                 {
521                         if(!iter->get_time().is_valid())
522                                 continue;
523
524                         const int x((int)((float)w/(t_end-t_begin)*(iter->get_time()-t_begin)));
525                         if(iter->get_time()>=t_begin && iter->get_time()<t_end)
526                         {
527                                 gc->set_rgb_fg_color(Gdk::Color("#a07f7f")); // It should be user selectable
528                                 get_window()->draw_rectangle(gc, true, x, 0, 1, h);
529                         }
530                 }
531         }
532
533         // Draw current time
534         gc->set_rgb_fg_color(Gdk::Color("#0000ff")); // It should be user selectable
535         get_window()->draw_rectangle(gc, false, round_to_int((time_adjustment_->get_value()-t_begin)/dt), 0, 0, h);
536
537         // Draw curves for the valuenodes stored in the curve list
538         for(curve_iter=curve_list_.begin();curve_iter!=curve_list_.end();++curve_iter)
539         {
540                 Real t;
541                 int i;
542                 int channels(curve_iter->channels.size());
543                 for(i=0;i<channels;i++)
544                         points[i].clear();
545
546                 for(i=0,t=t_begin;i<w;i++,t+=dt)
547                 {
548                         for(int chan=0;chan<channels;chan++)
549                         {
550                                 Real x(curve_iter->get_value(chan,t,dt));
551                                 r_max=max(r_max,x);
552                                 r_min=min(r_min,x);
553                                 points[chan].push_back(
554                                         Gdk::Point(
555                                                 i,
556                                                 round_to_int(
557                                                         (
558                                                                 x-r_bottom
559                                                         )/dr
560                                                 )
561                                         )
562                                 );
563                         }
564                 }
565
566                 for(int chan=0;chan<channels;chan++)
567                 {
568                         gc->set_rgb_fg_color(curve_iter->channels[chan].color);
569
570                         // Draw the curve
571                         get_window()->draw_lines(gc, Glib::ArrayHandle<Gdk::Point>(points[chan]));
572
573                         Glib::RefPtr<Pango::Layout> layout(Pango::Layout::create(get_pango_context()));
574
575                         layout->set_text(curve_iter->channels[chan].name);
576                         get_window()->draw_layout(gc, 1, points[chan][0].get_y()+1, layout);
577                 }
578         }
579
580         if(!curve_list_.empty())
581         {
582                 range_adjustment_->set_upper(r_max+range_adjustment_->get_page_size()/2);
583                 range_adjustment_->set_lower(r_min-range_adjustment_->get_page_size()/2);
584         }
585         get_window()->get_update_area();
586
587         return true;
588 }