source: synfigstudio/trunk/fuentes/.pc/c++11.patch/src/gui/docks/dock_timetrack.cpp @ 481

Last change on this file since 481 was 481, checked in by jrpelegrina, 4 years ago

First release to xenial

File size: 19.3 KB
Line 
1/* === S Y N F I G ========================================================= */
2/*!     \file dock_timetrack.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) 2007, 2008 Chris Moore
10**  Copyright (c) 2010 Carlos López
11**
12**      This package is free software; you can redistribute it and/or
13**      modify it under the terms of the GNU General Public License as
14**      published by the Free Software Foundation; either version 2 of
15**      the License, or (at your option) any later version.
16**
17**      This package is distributed in the hope that it will be useful,
18**      but WITHOUT ANY WARRANTY; without even the implied warranty of
19**      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20**      General Public License for more details.
21**      \endlegal
22*/
23/* ========================================================================= */
24
25/* === H E A D E R S ======================================================= */
26
27#ifdef USING_PCH
28#       include "pch.h"
29#else
30#ifdef HAVE_CONFIG_H
31#       include <config.h>
32#endif
33
34#include "docks/dock_timetrack.h"
35#include "app.h"
36
37#include <gtkmm/scrolledwindow.h>
38#include <cassert>
39#include "instance.h"
40#include <sigc++/signal.h>
41#include <sigc++/hide.h>
42#include <sigc++/slot.h>
43#include "canvasview.h"
44#include "trees/layerparamtreestore.h"
45#include "workarea.h"
46#include "widgets/widget_timeslider.h"
47#include "widgets/widget_keyframe_list.h"
48#include "general.h"
49#include "trees/layertree.h"
50#include <synfig/timepointcollect.h>
51
52#endif
53
54/* === U S I N G =========================================================== */
55
56using namespace std;
57using namespace etl;
58using namespace synfig;
59using namespace studio;
60
61/* === M A C R O S ========================================================= */
62
63/* === C L A S S E S ======================================================= */
64
65class TimeTrackView : public Gtk::TreeView
66{
67        CellRenderer_TimeTrack *cellrenderer_time_track;
68
69        Glib::RefPtr<LayerParamTreeStore> param_tree_store_;
70
71        Gtk::TreeView *mimic_tree_view;
72public:
73
74        sigc::signal<void,synfigapp::ValueDesc,std::set<synfig::Waypoint, std::less<UniqueID> >,int> signal_waypoint_clicked_timetrackview;
75
76        LayerParamTreeStore::Model model;
77
78        void set_canvas_view(handle<CanvasView> canvas_view)
79        {
80                cellrenderer_time_track->set_adjustment(canvas_view->time_adjustment());
81        }
82
83        TimeTrackView()
84        {
85                //Text attributes must be the same that layer param tree's to have aligned rows
86                Pango::AttrList attr_list;
87                {
88                        Pango::AttrInt pango_size(Pango::Attribute::create_attr_size(Pango::SCALE*8));
89                        pango_size.set_start_index(0);
90                        pango_size.set_end_index(64);
91                        attr_list.change(pango_size);
92                }
93
94                int label_index(append_column_editable(_("Name"),model.label));
95                Gtk::TreeView::Column* label_column = get_column(label_index-1);
96                label_column->set_sizing(Gtk::TREE_VIEW_COLUMN_AUTOSIZE);
97
98                {       // --- T I M E   T R A C K --------------------------------------------
99                        Gtk::TreeView::Column* column = Gtk::manage( new Gtk::TreeView::Column(_("Time Track")) );
100                        Gtk::TreeView::Column* column2 = Gtk::manage( new Gtk::TreeView::Column("Align") );
101
102                        // Set up the value-node cell-renderer
103                        cellrenderer_time_track=LayerParamTreeStore::add_cell_renderer_value_node(column);
104                        cellrenderer_time_track->property_mode()=Gtk::CELL_RENDERER_MODE_ACTIVATABLE;
105                        cellrenderer_time_track->signal_waypoint_clicked_cellrenderer().connect(sigc::mem_fun(*this, &TimeTrackView::on_waypoint_clicked_timetrackview));
106                        cellrenderer_time_track->signal_waypoint_changed().connect(sigc::mem_fun(*this, &TimeTrackView::on_waypoint_changed) );
107                        //column->add_attribute(cellrenderer_time_track->property_value_desc(), model.value_desc);
108                        //column->add_attribute(cellrenderer_time_track->property_canvas(), model.canvas);
109                        //column->add_attribute(cellrenderer_time_track->property_visible(), model.is_value_node);
110
111                        //column->pack_start(*cellrenderer_time_track);
112
113                        // Add a fixed size (same that layer param tree) empty text renderer
114                        // to align the rows with params dock when the text is taller than value_type icons height
115                        Gtk::CellRendererText* text_cellrenderer = Gtk::manage( new Gtk::CellRendererText() );
116                        text_cellrenderer->property_attributes()=attr_list;
117                        column2->pack_end(*text_cellrenderer,false);
118                        text_cellrenderer->set_fixed_size (1,-1);
119
120                        // Add a fixed size (1pixel widht, same height than value_type icon) empty (alpha) icon
121                        // to align the rows with params dock when the text is smaller than value_type icons height
122                        Gtk::CellRendererPixbuf* icon_cellrenderer = Gtk::manage( new Gtk::CellRendererPixbuf() );
123                        Glib::RefPtr<Gdk::Pixbuf> pixbuf;
124                        pixbuf=Gtk::Button().render_icon_pixbuf(Gtk::StockID("synfig-utils_timetrack_align"),Gtk::ICON_SIZE_SMALL_TOOLBAR);
125                        icon_cellrenderer->property_pixbuf() = pixbuf;
126                        column2->pack_end(*icon_cellrenderer,false);
127                        icon_cellrenderer->set_fixed_size(1,-1);
128
129                        // Finish setting up the columns
130                        column->set_reorderable();
131                        column->set_sizing(Gtk::TREE_VIEW_COLUMN_AUTOSIZE);
132                        column->set_resizable();
133                        column->set_expand(true);
134// Commented during Align rows fixing
135// http://www.synfig.org/issues/thebuggenie/synfig/issues/161
136//                      column->set_min_width(200);
137                       
138                        column2->set_resizable();
139                        column2->set_fixed_width(1);
140
141                        append_column(*column);
142                        append_column(*column2);
143                }
144                set_rules_hint();
145
146                set_expander_column(*label_column);
147                label_column->set_visible(false);
148                set_headers_visible(false);
149                set_size_request(-1,64);
150        }
151
152        bool
153        on_event(GdkEvent *event)
154        {
155                switch(event->type)
156                {
157                case GDK_SCROLL:
158                        if(mimic_tree_view)
159                        {
160                                if(event->scroll.direction==GDK_SCROLL_DOWN)
161                                {
162                                        mimic_tree_view->get_vadjustment()->set_value(
163                                                std::min(
164                                                        mimic_tree_view->get_vadjustment()->get_value()+
165                                                        mimic_tree_view->get_vadjustment()->get_step_increment(),
166                                                        mimic_tree_view->get_vadjustment()->get_upper()-
167                                                        mimic_tree_view->get_vadjustment()->get_page_size()
168                                                )
169                                        );
170                                        mimic_tree_view->get_vadjustment()->value_changed();
171                                }
172                                else if(event->scroll.direction==GDK_SCROLL_UP)
173                                {
174                                        mimic_tree_view->get_vadjustment()->set_value(
175                                                std::max(
176                                                        mimic_tree_view->get_vadjustment()->get_value()-
177                                                        mimic_tree_view->get_vadjustment()->get_step_increment(),
178                                                        mimic_tree_view->get_vadjustment()->get_lower()
179                                                )
180                                        );
181                                        mimic_tree_view->get_vadjustment()->value_changed();
182                                }
183                        }
184                        break;
185                case GDK_BUTTON_PRESS:
186                        {
187                                Gtk::TreeModel::Path path;
188                                Gtk::TreeViewColumn *column;
189                                int cell_x, cell_y;
190                                if(!get_path_at_pos(
191                                        int(event->button.x),int(event->button.y),      // x, y
192                                        path, // TreeModel::Path&
193                                        column, //TreeViewColumn*&
194                                        cell_x,cell_y //int&cell_x,int&cell_y
195                                        )
196                                ) break;
197                                const Gtk::TreeRow row = *(get_model()->get_iter(path));
198
199                                if(column && column->get_first_cell()==cellrenderer_time_track)
200                                {
201                                        Gdk::Rectangle rect;
202                                        get_cell_area(path,*column,rect);
203                                        cellrenderer_time_track->property_value_desc()=row[model.value_desc];
204                                        cellrenderer_time_track->property_canvas()=row[model.canvas];
205                                        cellrenderer_time_track->activate(event,*this,path.to_string(),rect,rect,Gtk::CellRendererState());
206                                        queue_draw_area(rect.get_x(),rect.get_y(),rect.get_width(),rect.get_height());
207                                        return true;
208                                        //return signal_param_user_click()(event->button.button,row,COLUMNID_TIME_TRACK);
209                                }
210                        }
211                        break;
212
213                case GDK_MOTION_NOTIFY:
214                        {
215                                Gtk::TreeModel::Path path;
216                                Gtk::TreeViewColumn *column;
217                                int cell_x, cell_y;
218                                if(!get_path_at_pos(
219                                        (int)event->motion.x,(int)event->motion.y,      // x, y
220                                        path, // TreeModel::Path&
221                                        column, //TreeViewColumn*&
222                                        cell_x,cell_y //int&cell_x,int&cell_y
223                                        )
224                                ) break;
225
226                                if(!get_model()->get_iter(path))
227                                        break;
228
229                                Gtk::TreeRow row = *(get_model()->get_iter(path));
230
231                                if (((event->motion.state&GDK_BUTTON1_MASK) || (event->motion.state&GDK_BUTTON3_MASK)) &&
232                                        column &&
233                                        cellrenderer_time_track == column->get_first_cell())
234                                {
235                                        Gdk::Rectangle rect;
236                                        get_cell_area(path,*column,rect);
237                                        cellrenderer_time_track->property_value_desc()=row[model.value_desc];
238                                        cellrenderer_time_track->property_canvas()=row[model.canvas];
239                                        cellrenderer_time_track->activate(event,*this,path.to_string(),rect,rect,Gtk::CellRendererState());
240                                        queue_draw();
241                                        //queue_draw_area(rect.get_x(),rect.get_y(),rect.get_width(),rect.get_height());
242                                        return true;
243                                }
244/*                              else
245                                if(last_tooltip_path.get_depth()<=0 || path!=last_tooltip_path)
246                                {
247                                        tooltips_.unset_tip(*this);
248                                        Glib::ustring tooltips_string(row[layer_model.tooltip]);
249                                        last_tooltip_path=path;
250                                        if(!tooltips_string.empty())
251                                        {
252                                                tooltips_.set_tip(*this,tooltips_string);
253                                                tooltips_.force_window();
254                                        }
255                                }
256*/
257                                return true;
258                        }
259                        break;
260                case GDK_BUTTON_RELEASE:
261                        {
262                                Gtk::TreeModel::Path path;
263                                Gtk::TreeViewColumn *column;
264                                int cell_x, cell_y;
265                                if(!get_path_at_pos(
266                                        (int)event->button.x,(int)event->button.y,      // x, y
267                                        path, // TreeModel::Path&
268                                        column, //TreeViewColumn*&
269                                        cell_x,cell_y //int&cell_x,int&cell_y
270                                        )
271                                ) break;
272
273                                if(!get_model()->get_iter(path))
274                                        break;
275
276                                Gtk::TreeRow row = *(get_model()->get_iter(path));
277
278                                if(column && cellrenderer_time_track==column->get_first_cell())
279                                {
280                                        Gdk::Rectangle rect;
281                                        get_cell_area(path,*column,rect);
282                                        cellrenderer_time_track->property_value_desc()=row[model.value_desc];
283                                        cellrenderer_time_track->property_canvas()=row[model.canvas];
284                                        cellrenderer_time_track->activate(event,*this,path.to_string(),rect,rect,Gtk::CellRendererState());
285                                        queue_draw();
286                                        queue_draw_area(rect.get_x(),rect.get_y(),rect.get_width(),rect.get_height());
287                                        return true;
288                                }
289                        }
290                        break;
291                default:
292                        break;
293                }
294                mimic_resync();
295                return Gtk::TreeView::on_event(event);
296        }
297
298        void
299        queue_draw_msg()
300        {
301                synfig::info("*************QUEUE_DRAW***************** (time track view)");
302                Widget::queue_draw();
303        }
304        void set_model(Glib::RefPtr<LayerParamTreeStore> store)
305        {
306                Gtk::TreeView::set_model(store);
307                param_tree_store_=store;
308                cellrenderer_time_track->set_canvas_interface(param_tree_store_->canvas_interface());
309                store->signal_changed().connect(sigc::mem_fun(*this, &TimeTrackView::queue_draw));
310        }
311
312        void
313        on_waypoint_changed( synfig::Waypoint waypoint , synfig::ValueNode::Handle value_node)
314        {
315                // \todo is this code used?
316                assert(0);
317
318                synfigapp::Action::ParamList param_list;
319                param_list.add("canvas",param_tree_store_->canvas_interface()->get_canvas());
320                param_list.add("canvas_interface",param_tree_store_->canvas_interface());
321                param_list.add("value_node",value_node);
322                param_list.add("waypoint",waypoint);
323        //      param_list.add("time",canvas_interface()->get_time());
324
325                etl::handle<studio::Instance>::cast_static(param_tree_store_->canvas_interface()->get_instance())->process_action("WaypointSetSmart", param_list);
326        }
327
328        void mimic(Gtk::TreeView *param_tree_view)
329        {
330                mimic_tree_view=param_tree_view;
331                param_tree_view->signal_row_expanded().connect(
332                        sigc::hide<0>(
333                        sigc::hide_return(
334                                sigc::bind<-1>(
335                                        sigc::mem_fun(
336                                                *this,
337                                                &Gtk::TreeView::expand_row
338                                        ),
339                                        false
340                                )
341                        ))
342                );
343                param_tree_view->signal_row_collapsed().connect(
344                        sigc::hide<0>(
345                        sigc::hide_return(
346                                        sigc::mem_fun(
347                                                *this,
348                                                &Gtk::TreeView::collapse_row
349                                        )
350                        ))
351                );
352                mimic_resync();
353        }
354
355        void mimic_resync()
356        {
357                if(mimic_tree_view)
358                {
359                        Glib::RefPtr<Gtk::Adjustment> adjustment(mimic_tree_view->get_vadjustment());
360                        set_vadjustment(adjustment);
361
362                        if(adjustment->get_page_size()>get_height())
363                                adjustment->set_page_size(get_height());
364/* Commented during Align rows fixing
365// http://www.synfig.org/issues/thebuggenie/synfig/issues/161
366                        int row_height = 0;
367                        if(getenv("SYNFIG_TIMETRACK_ROW_HEIGHT"))
368                                row_height = atoi(getenv("SYNFIG_TIMETRACK_ROW_HEIGHT"));
369                        if (row_height < 3)
370                                row_height = 18;
371
372                        cellrenderer_time_track->set_fixed_size(-1,row_height);
373*/
374                }
375        }
376
377        void
378        on_waypoint_clicked_timetrackview(const etl::handle<synfig::Node>& node,
379                                                                          const synfig::Time& time,
380                                                                          const synfig::Time& time_offset __attribute__ ((unused)),
381                                                                          const synfig::Time& time_dilation __attribute__ ((unused)),
382                                                                          int button)
383        {
384                std::set<synfig::Waypoint, std::less<UniqueID> > waypoint_set;
385                synfig::waypoint_collect(waypoint_set,time,node);
386
387                synfigapp::ValueDesc value_desc;
388
389                if (waypoint_set.size() == 1)
390                {
391                        ValueNode::Handle value_node(waypoint_set.begin()->get_parent_value_node());
392                        assert(value_node);
393
394                        Gtk::TreeRow row;
395                        if (param_tree_store_->find_first_value_node(value_node, row) && row)
396                                value_desc = static_cast<synfigapp::ValueDesc>(row[model.value_desc]);
397                }
398
399                if (!waypoint_set.empty())
400                        signal_waypoint_clicked_timetrackview(value_desc,waypoint_set,button);
401        }
402};
403
404/* === G L O B A L S ======================================================= */
405
406/* === P R O C E D U R E S ================================================= */
407
408/* === M E T H O D S ======================================================= */
409
410Dock_Timetrack::Dock_Timetrack():
411        Dock_CanvasSpecific("timetrack",_("Timetrack"),Gtk::StockID("synfig-timetrack"))
412{
413        table_=0;
414        widget_timeslider_= new Widget_Timeslider();
415        widget_kf_list_= new Widget_Keyframe_List();
416       
417        set_use_scrolled(false);
418
419        hscrollbar_=new Gtk::HScrollbar();
420        vscrollbar_=new Gtk::VScrollbar();
421}
422
423Dock_Timetrack::~Dock_Timetrack()
424{
425        if(table_)delete table_;
426        delete hscrollbar_;
427        delete vscrollbar_;
428        delete widget_timeslider_;
429        delete widget_kf_list_;
430}
431
432void
433Dock_Timetrack::init_canvas_view_vfunc(etl::loose_handle<CanvasView> canvas_view)
434{
435        LayerParamTreeStore::Model model;
436
437        Glib::RefPtr<LayerParamTreeStore> tree_store(
438                Glib::RefPtr<LayerParamTreeStore>::cast_dynamic(
439                        canvas_view->get_tree_model("params")
440                )
441        );
442
443        TimeTrackView* tree_view(new TimeTrackView());
444        tree_view->set_canvas_view(canvas_view);
445        tree_view->set_model(tree_store);
446        Gtk::TreeView* param_tree_view(dynamic_cast<Gtk::TreeView*>(canvas_view->get_ext_widget("params")));
447        tree_view->mimic(param_tree_view);
448        mimic_tree_view=param_tree_view;
449
450        tree_view->signal_waypoint_clicked_timetrackview.connect(sigc::mem_fun(*canvas_view, &studio::CanvasView::on_waypoint_clicked_canvasview));
451
452        studio::LayerTree* tree_layer(dynamic_cast<studio::LayerTree*>(canvas_view->get_ext_widget("layers_cmp")));
453
454        /*
455        if(!getenv("SYNFIG_TIMETRACK_HEADER_HEIGHT"))
456        */
457        tree_layer->signal_param_tree_header_height_changed().connect(sigc::mem_fun(*this, &studio::Dock_Timetrack::on_update_header_height));
458
459        canvas_view->time_adjustment()->signal_value_changed().connect(sigc::mem_fun(*tree_view,&Gtk::TreeView::queue_draw));
460        canvas_view->time_adjustment()->signal_changed().connect(sigc::mem_fun(*tree_view,&Gtk::TreeView::queue_draw));
461
462        canvas_view->set_ext_widget(get_name(),tree_view);
463        // widget_timeslider fps connection to animation render description change
464        canvas_view->canvas_interface()->signal_rend_desc_changed().connect(sigc::mem_fun(*this,&studio::Dock_Timetrack::refresh_rend_desc));
465}
466
467void
468Dock_Timetrack::refresh_selected_param()
469{
470/*      Gtk::TreeView* tree_view(
471                static_cast<Gtk::TreeView*>(get_canvas_view()->get_ext_widget(get_name()))
472        );
473        Gtk::TreeModel::iterator iter(tree_view->get_selection()->get_selected());
474
475        if(iter)
476        {
477                LayerParamTreeStore::Model model;
478                get_canvas_view()->work_area->set_selected_value_node(
479                        (synfig::ValueNode::Handle)(*iter)[model.value_node]
480                );
481        }
482        else
483        {
484                get_canvas_view()->work_area->set_selected_value_node(0);
485        }
486*/
487}
488
489/*! \fn Dock_Timetrack::refresh_rend_desc()
490**      \brief Signal handler for animation render description change
491*/
492void
493Dock_Timetrack::refresh_rend_desc()
494{
495        if(App::get_selected_canvas_view())
496        {
497                widget_timeslider_->set_global_fps(App::get_selected_canvas_view()->get_canvas()->rend_desc().get_frame_rate());
498        }
499}
500
501void
502Dock_Timetrack::changed_canvas_view_vfunc(etl::loose_handle<CanvasView> canvas_view)
503{
504        if(table_)
505        {
506                table_->hide();
507                remove(*table_);
508                clear_previous();
509                delete table_;
510                hscrollbar_->unset_adjustment();
511                vscrollbar_->unset_adjustment();
512                //widget_timeslider_->unset_adjustment();
513                table_=0;
514        }
515
516        if(canvas_view)
517        {
518                TimeTrackView* tree_view(dynamic_cast<TimeTrackView*>(canvas_view->get_ext_widget(get_name())));
519                Gtk::TreeView* param_tree_view(dynamic_cast<Gtk::TreeView*>(canvas_view->get_ext_widget("params")));
520                Gtk::ScrolledWindow* scrolled = Gtk::manage(new Gtk::ScrolledWindow);
521                scrolled->get_vscrollbar()->hide();
522                scrolled->add(*tree_view);
523                scrolled->set_policy(Gtk::POLICY_NEVER,Gtk::POLICY_AUTOMATIC);
524                scrolled->set_vadjustment(param_tree_view->get_vadjustment());
525                scrolled->show_all();
526
527                assert(tree_view);
528                // Fixed size drawing areas to align the widget_timeslider and tree_view time cursors
529                // TODO ?: one align_drawingArea.(0, 1, 0, 1) modify_bg KF's color another (0, 1, 1, 2) modify_bg TS's color
530                Gtk::DrawingArea* align_drawingArea1 = Gtk::manage(new Gtk::DrawingArea);
531                // TODO ?: one align_drawingArea.(2, 3, 0, 1) modify_bg KF's color another (2, 3, 1, 2) modify_bg TS's color
532                Gtk::DrawingArea* align_drawingArea2 = Gtk::manage(new Gtk::DrawingArea);
533#if (GTKMM_MAJOR_VERSION == 3 && GTKMM_MINOR_VERSION >= 14)
534                align_drawingArea1->set_size_request(2,-1);
535                align_drawingArea2->set_size_request(4,-1);
536#else
537                align_drawingArea1->set_size_request(4,-1);
538                align_drawingArea2->set_size_request(9,-1);
539#endif
540                widget_timeslider_->set_time_adjustment(canvas_view->time_adjustment());
541                widget_timeslider_->set_bounds_adjustment(canvas_view->time_window_adjustment());
542                widget_timeslider_->set_global_fps(canvas_view->get_canvas()->rend_desc().get_frame_rate());
543
544                widget_kf_list_->set_time_adjustment(canvas_view->time_adjustment());
545                widget_kf_list_->set_canvas_interface(canvas_view->canvas_interface());
546
547                vscrollbar_->set_adjustment(tree_view->get_vadjustment());
548                hscrollbar_->set_adjustment(canvas_view->time_window_adjustment());
549
550/*
551        0------1------2------3------4
552        |  A   |  KF  |  A   |  v   |
553        |  L   |      |  L   |  s   |
554        1--I---x------x--I---x--c---x
555        |  G   |  TS  |  G   |  r   |
556        |  N1  |      |  N2  |  o   |
557        2------x------x------x--l---x
558        |  TV  |  TV  |  TV  |  l   |
559        |      |      |      |  b   |
560        3------x------x------x------x
561        | hscrollbar
562
563KF = widget_kf_list
564TS = widget_timeslider
565TV = tree_view
566ALIGN1 = align_drawingArea1
567ALIGN2 = align_drawingArea2
568*/
569                table_=new Gtk::Table(3,4);
570                table_->attach(*align_drawingArea1, 0, 1, 0, 2, Gtk::SHRINK, Gtk::FILL);
571                table_->attach(*widget_kf_list_, 1, 2, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::SHRINK);
572                table_->attach(*widget_timeslider_, 1, 2, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::SHRINK);
573                table_->attach(*align_drawingArea2, 2, 3, 0, 2, Gtk::SHRINK, Gtk::FILL);
574                table_->attach(*scrolled, 0, 3, 2, 3, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
575                table_->attach(*hscrollbar_, 0, 3, 3, 4, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::SHRINK);
576                table_->attach(*vscrollbar_, 3, 4, 0, 3, Gtk::FILL|Gtk::SHRINK, Gtk::FILL|Gtk::EXPAND);
577                add(*table_);
578               
579                // Should be here, after the widget was attached to table
580                tree_view->add_events(Gdk::SCROLL_MASK);
581
582                //add(*last_widget_curves_);
583                table_->show_all();
584                show_all();
585        }
586        else
587        {
588                //clear_previous();
589        }
590}
591
592void
593Dock_Timetrack::on_update_header_height( int header_height)
594{
595        int width=0;
596        int height=0;
597        int kf_list_height=10;
598        mimic_tree_view->convert_bin_window_to_widget_coords(0, 0, width, height);
599        widget_timeslider_->set_size_request(-1,height-kf_list_height);
600        widget_kf_list_->set_size_request(-1,kf_list_height);
601}
Note: See TracBrowser for help on using the repository browser.