1 /* === S Y N F I G ========================================================= */
2 /*! \file compview.cpp
3 ** \brief writeme
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 ** === N O T E S ===========================================================
23 **
24 ** ========================================================================= */
25
26 /* === H E A D E R S ======================================================= */
27
28 #ifdef USING_PCH
29 # include "pch.h"
30 #else
31 #ifdef HAVE_CONFIG_H
32 # include <config.h>
33 #endif
34
35 #include <synfig/general.h>
36
37 #include "compview.h"
38 #include "app.h"
39 #include <gtkmm/scrolledwindow.h>
40 #include <cassert>
41 #include <iostream>
42 #include "instance.h"
43 #include "canvasview.h"
44 #include <synfigapp/action.h>
45
46 #include <gui/localization.h>
47
48 #endif
49
50 /* === M A C R O S ========================================================= */
51
52 #define ADD_TOOLBOX_BUTTON(button,stockid,tooltip) \
53 Gtk::Button *button = manage(new class Gtk::Button()); \
54 button->add(*manage(new Gtk::Image(Gtk::StockID(stockid),Gtk::IconSize(4)))); \
55 tooltip.set_tip(*button,tooltip); \
56 button->show_all()
57
58 using namespace std;
59 using namespace etl;
60 using namespace synfig;
61 using namespace studio;
62
63 #define COLUMNID_JUMP (787584)
64 #define ColumnID int
65
66 /* === G L O B A L S ======================================================= */
67
68 /* === P R O C E D U R E S ================================================= */
69
70 /* === M E T H O D S ======================================================= */
71
CompView()72 CompView::CompView():
73 Gtk::Window(Gtk::WINDOW_TOPLEVEL),
74 dialog_settings(this,"compview")
75 {
76 assert(0); //CHECK: This class does not appear to be used.
77 init_menu();
78 set_type_hint(Gdk::WINDOW_TYPE_HINT_UTILITY);
79
80 Gtk::Table *table = manage(new class Gtk::Table(2, 1, false));
81
82 instance_selector.show();
83 instance_selector.signal_changed().connect(sigc::mem_fun(this, &CompView::on_instance_selector_changed));
84
85 table->attach(instance_selector, 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK, 0, 0);
86
87 notebook=manage(new class Gtk::Notebook());
88
89 table->attach(*notebook, 0, 1, 1,2, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
90
91 notebook->append_page(*create_canvas_tree(),_("Canvases"));
92 notebook->append_page(*create_action_tree(),_("History"));
93
94
95
96 /*
97
98 studio::Instance::ImageColumnModel image_column_model;
99 image_list=manage(new class Gtk::TreeView());
100 image_list->append_column(_("Name"),image_column_model.name);
101 image_list->signal_row_activated().connect(sigc::mem_fun(*this,&CompView::on_image_activate));
102 image_list->set_rules_hint();
103
104 Gtk::Table *image_page = manage(new class Gtk::Table(2, 1, false));
105 Gtk::ScrolledWindow *image_list_scroll = manage(new class Gtk::ScrolledWindow());
106 image_list_scroll->set_can_focus(true);
107 image_list_scroll->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
108 image_list_scroll->add(*image_list);
109 image_page->attach(*image_list_scroll, 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
110 Gtk::HBox *image_buttons=manage(new class Gtk::HBox());
111 image_page->attach(*image_buttons, 0, 1, 1,2, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK, 0, 0);
112 ADD_TOOLBOX_BUTTON(button_image_new,"gtk-new",_("Create a new image"));
113 ADD_TOOLBOX_BUTTON(button_image_delete,"gtk-delete",_("Delete image"));
114 ADD_TOOLBOX_BUTTON(button_image_rename,"gtk-rename",_("Rename image"));
115 ADD_TOOLBOX_BUTTON(button_image_copy,"gtk-copy",_("Duplicate image"));
116 button_image_new->signal_clicked().connect(sigc::mem_fun(*this,&CompView::new_image));
117 button_image_delete->signal_clicked().connect(sigc::mem_fun(*this,&CompView::delete_image));
118 button_image_rename->signal_clicked().connect(sigc::mem_fun(*this,&CompView::rename_image));
119 button_image_copy->signal_clicked().connect(sigc::mem_fun(*this,&CompView::copy_image));
120 image_buttons->pack_start(*button_image_new);
121 image_buttons->pack_start(*button_image_delete);
122 image_buttons->pack_start(*button_image_rename);
123 image_buttons->pack_start(*button_image_copy);
124
125 studio::Instance::ValueNodeColumnModel valuenode_column_model;
126 valuenode_list=manage(new class Gtk::TreeView());
127 valuenode_list->append_column(_("Name"),valuenode_column_model.name);
128 valuenode_list->signal_row_activated().connect(sigc::mem_fun(*this,&CompView::on_valuenode_activate));
129 valuenode_list->set_rules_hint();
130
131 Gtk::Table *valuenode_page = manage(new class Gtk::Table(2, 1, false));
132 Gtk::ScrolledWindow *valuenode_list_scroll = manage(new class Gtk::ScrolledWindow());
133 valuenode_list_scroll->set_can_focus(true);
134 valuenode_list_scroll->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
135 valuenode_list_scroll->add(*valuenode_list);
136 valuenode_page->attach(*valuenode_list_scroll, 0, 1, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
137 Gtk::HBox *valuenode_buttons=manage(new class Gtk::HBox());
138 valuenode_page->attach(*valuenode_buttons, 0, 1, 1,2, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK, 0, 0);
139 ADD_TOOLBOX_BUTTON(button_valuenode_new,"gtk-new",_("Create a new value_node"));
140 ADD_TOOLBOX_BUTTON(button_valuenode_delete,"gtk-delete",_("Delete value_node"));
141 ADD_TOOLBOX_BUTTON(button_valuenode_rename,"gtk-rename",_("Rename value_node"));
142 ADD_TOOLBOX_BUTTON(button_valuenode_copy,"gtk-copy",_("Duplicate value_node"));
143 button_valuenode_new->signal_clicked().connect(sigc::mem_fun(*this,&CompView::new_value_node));
144 button_valuenode_delete->signal_clicked().connect(sigc::mem_fun(*this,&CompView::delete_value_node));
145 button_valuenode_rename->signal_clicked().connect(sigc::mem_fun(*this,&CompView::rename_value_node));
146 button_valuenode_copy->signal_clicked().connect(sigc::mem_fun(*this,&CompView::copy_value_node));
147 valuenode_buttons->pack_start(*button_valuenode_new);
148 valuenode_buttons->pack_start(*button_valuenode_delete);
149 valuenode_buttons->pack_start(*button_valuenode_rename);
150 valuenode_buttons->pack_start(*button_valuenode_copy);
151
152
153 notebook->append_page(*image_page,_("Images"));
154 notebook->append_page(*valuenode_page,_("ValueNodes"));
155
156 image_page->show_all();
157 valuenode_page->show_all();
158 */
159 // notebook->set_current_page(0);
160 signal_delete_event().connect(sigc::hide(sigc::mem_fun(*this, &CompView::close)));
161 App::signal_instance_created().connect(sigc::mem_fun(*this,&studio::CompView::new_instance));
162 App::signal_instance_deleted().connect(sigc::mem_fun(*this,&studio::CompView::delete_instance));
163 App::signal_instance_selected().connect(sigc::mem_fun(*this,&studio::CompView::set_selected_instance_signal));
164
165 table->show_all();
166 add(*table);
167
168
169 set_title(_("Canvas Browser"));
170 set_modal(false);
171 set_resizable(true);
172 property_window_position().set_value(Gtk::WIN_POS_NONE);
173 set_default_size(200,300);
174 }
175
~CompView()176 CompView::~CompView()
177 {
178 }
179
180 etl::loose_handle<studio::CanvasView>
get_selected_canvas_view()181 CompView::get_selected_canvas_view()
182 {
183 return get_selected_instance()->find_canvas_view(get_selected_canvas());
184 }
185
186 Gtk::Widget*
create_canvas_tree()187 CompView::create_canvas_tree()
188 {
189 studio::Instance::CanvasTreeModel canvas_tree_model;
190 canvas_tree=manage(new class Gtk::TreeView());
191 {
192 Gtk::TreeView::Column* column = Gtk::manage( new Gtk::TreeView::Column(_("ID")) );
193 // Gtk::CellRendererPixbuf* icon_cellrenderer = Gtk::manage( new Gtk::CellRendererPixbuf() );
194
195 //column->pack_start(*icon_cellrenderer,false);
196 column->pack_start(canvas_tree_model.icon, false); //false = don't expand.
197 column->pack_start(canvas_tree_model.label);
198
199 //#ifdef NDEBUG
200 // column->add_attribute(icon_cellrenderer->property_pixbuf(), canvas_tree_model.icon);
201 //#endif
202
203 canvas_tree->append_column(*column);
204 }
205 canvas_tree->set_rules_hint();
206 canvas_tree->signal_row_activated().connect(sigc::mem_fun(*this,&CompView::on_row_activate));
207 canvas_tree->signal_event().connect(sigc::mem_fun(*this,&CompView::on_tree_event));
208 canvas_tree->add_events(Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK);
209 canvas_tree->add_events(Gdk::BUTTON1_MOTION_MASK);
210 canvas_tree->show();
211
212 Gtk::ScrolledWindow *scrolledwindow = manage(new class Gtk::ScrolledWindow());
213 scrolledwindow->set_can_focus(true);
214 scrolledwindow->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
215 scrolledwindow->add(*canvas_tree);
216 scrolledwindow->set_shadow_type(Gtk::SHADOW_ETCHED_IN);
217 scrolledwindow->show();
218
219 return scrolledwindow;
220 }
221
222 Gtk::Widget*
create_action_tree()223 CompView::create_action_tree()
224 {
225 studio::HistoryTreeStore::Model history_tree_model;
226 action_tree=manage(new class Gtk::TreeView());
227 {
228 Gtk::TreeView::Column* column = Gtk::manage( new Gtk::TreeView::Column("") );
229
230 Gtk::CellRendererToggle* toggle_cr = Gtk::manage( new Gtk::CellRendererToggle() );
231 toggle_cr->signal_toggled().connect(sigc::mem_fun(*this, &studio::CompView::on_action_toggle) );
232
233 column->pack_start(*toggle_cr); //false = don't expand.
234 column->add_attribute(toggle_cr->property_active(),history_tree_model.is_active);
235 column->set_resizable();
236 column->set_clickable();
237
238 action_tree->append_column(*column);
239 }
240 /*{
241 Gtk::TreeView::Column* column = Gtk::manage( new Gtk::TreeView::Column(_("Canvas")) );
242 Gtk::CellRendererText *text_cr=Gtk::manage(new Gtk::CellRendererText());
243 text_cr->property_foreground()=Glib::ustring("#7f7f7f");
244
245 column->pack_start(*text_cr);
246 column->add_attribute(text_cr->property_text(),history_tree_model.canvas_id);
247 column->add_attribute(text_cr->property_foreground_set(),history_tree_model.is_redo);
248
249 action_tree->append_column(*column);
250 }*/
251 {
252 Gtk::TreeView::Column* column = Gtk::manage( new Gtk::TreeView::Column(_("Jump")) );
253
254 Gtk::CellRendererText* cell_renderer_jump=Gtk::manage(new Gtk::CellRendererText());
255 column->pack_start(*cell_renderer_jump,true);
256
257 cell_renderer_jump->property_text()=_("(JMP)");
258 cell_renderer_jump->property_foreground()="#003a7f";
259
260 column->set_resizable();
261 column->set_clickable();
262
263 column->set_sort_column(COLUMNID_JUMP);
264
265 action_tree->append_column(*column);
266 //column->clicked();
267 }
268 {
269 Gtk::TreeView::Column* column = Gtk::manage( new Gtk::TreeView::Column(_("Action")) );
270
271 Gtk::CellRendererText *text_cr=Gtk::manage(new Gtk::CellRendererText());
272 text_cr->property_foreground()=Glib::ustring("#7f7f7f");
273
274
275
276 //column->pack_start(history_tree_model.icon, false); //false = don't expand.
277 column->pack_start(*text_cr);
278 column->add_attribute(text_cr->property_text(),history_tree_model.name);
279 column->add_attribute(text_cr->property_foreground_set(),history_tree_model.is_redo);
280
281 action_tree->append_column(*column);
282 }
283
284
285 action_tree->set_rules_hint();
286 // action_tree->signal_row_activated().connect(sigc::mem_fun(*this,&CompView::on_row_activate));
287 action_tree->signal_event().connect(sigc::mem_fun(*this,&CompView::on_action_event));
288 // action_tree->add_events(Gdk::BUTTON_PRESS_MASK | Gdk::BUTTON_RELEASE_MASK);
289 // action_tree->add_events(Gdk::BUTTON1_MOTION_MASK);
290 action_tree->show();
291
292 Gtk::ScrolledWindow *scrolledwindow = manage(new class Gtk::ScrolledWindow());
293 scrolledwindow->set_can_focus(true);
294 scrolledwindow->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
295 scrolledwindow->add(*action_tree);
296 scrolledwindow->set_shadow_type(Gtk::SHADOW_ETCHED_IN);
297 scrolledwindow->show();
298
299 Gtk::Button* clear_button(manage(new Gtk::Button(_("Clear Undo"))));
300 clear_button->signal_pressed().connect(sigc::mem_fun(*this,&studio::CompView::clear_history));
301
302 Gtk::Button* clear_redo_button(manage(new Gtk::Button(_("Clear Redo"))));
303 clear_redo_button->signal_pressed().connect(sigc::mem_fun(*this,&studio::CompView::clear_redo));
304
305 Gtk::Table* table(manage(new Gtk::Table()));
306 table->attach(*scrolledwindow, 0, 2, 0,1, Gtk::EXPAND|Gtk::FILL, Gtk::EXPAND|Gtk::FILL, 0, 0);
307 table->attach(*clear_button, 0, 1, 1,2, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK, 0, 0);
308 table->attach(*clear_redo_button, 1, 2, 1,2, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK, 0, 0);
309
310 table->show_all();
311
312 return table;
313 }
314
315 bool
close()316 CompView::close()
317 {
318 hide();
319 return true;
320 }
321
322 void
clear_history()323 CompView::clear_history()
324 {
325
326 if (selected_instance && App::dialog_message_b2(
327 _("Clear History"),
328 _("You will not be able to undo any changes that you have made! "
329 "Are you sure you want to clear the undo stack?")
330 Gtk::MESSAGE_QUESTION,
331 _("Cancel"),
332 _("Clear"))
333 )
334 selected_instance->clear_undo_stack();
335 }
336
337
338 void
clear_redo()339 CompView::clear_redo()
340 {
341 if (selected_instance && App::dialog_message_2b(
342 _("Clear History"),
343 _("You will not be able to redo any changes that you have made! "
344 "Are you sure you want to clear the redo stack?")
345 Gtk::MESSAGE_QUESTION,
346 _("Cancel"),
347 _("Clear"))
348 )
349 selected_instance->clear_redo_stack();
350 }
351
352 void
init_menu()353 CompView::init_menu()
354 {
355 Gtk::MenuItem *item = NULL;
356
357 item = manage(new Gtk::SeparatorMenuItem());
358 item->show();
359 menu.append(*item);
360
361 item = manage(new Gtk::ImageMenuItem(Gtk::StockID("synfig-canvas_new")));
362 item->signal_activate().connect(
363 sigc::mem_fun(*this,&CompView::menu_new_canvas));
364 item->show_all();
365 menu.append(*item);
366
367 item = manage(new Gtk::ImageMenuItem(Gtk::StockID("gtk-delete")));
368 item->signal_activate().connect(
369 sigc::mem_fun(*this,&CompView::menu_delete));
370 item->show_all();
371 menu.append(*item);
372
373 item = manage(new Gtk::ImageMenuItem(Gtk::StockID("synfig-rename")));
374 item->signal_activate().connect(
375 sigc::mem_fun(*this,&CompView::menu_rename));
376 item->show_all();
377 menu.append(*item);
378 }
379
380 etl::loose_handle<synfig::Canvas>
get_selected_canvas()381 CompView::get_selected_canvas()
382 {
383 Glib::RefPtr<Gtk::TreeSelection> selection=canvas_tree->get_selection();
384
385 if(!selection || !selection->get_selected())
386 return 0;
387
388 studio::Instance::CanvasTreeModel canvas_tree_model;
389
390 return static_cast<etl::handle<synfig::Canvas> >((*selection->get_selected())[canvas_tree_model.canvas]);
391 }
392
393 void
menu_new_canvas()394 CompView::menu_new_canvas()
395 {
396 #warning Update Me!
397 #if 0
398 get_selected_canvas_view()->new_child_canvas();
399 #endif
400 }
401
402 void
menu_delete()403 CompView::menu_delete()
404 {
405 studio::App::dialog_not_implemented();
406 }
407
408 void
menu_rename()409 CompView::menu_rename()
410 {
411 studio::App::dialog_not_implemented();
412 }
413
414 void
set_selected_instance_signal(etl::handle<studio::Instance> x)415 CompView::set_selected_instance_signal(etl::handle<studio::Instance> x)
416 {
417 set_selected_instance(x);
418 }
419
420 void
set_selected_instance_(etl::handle<studio::Instance> instance)421 CompView::set_selected_instance_(etl::handle<studio::Instance> instance)
422 {
423 if(studio::App::shutdown_in_progress)
424 return;
425
426 selected_instance=instance;
427 if(instance)
428 {
429 canvas_tree->set_model(instance->canvas_tree_store());
430 action_tree->set_model(instance->history_tree_store());
431 canvas_tree->show();
432 action_tree->show();
433 }
434 else
435 {
436 canvas_tree->set_model(Glib::RefPtr< Gtk::TreeModel >());
437 action_tree->set_model(Glib::RefPtr< Gtk::TreeModel >());
438 canvas_tree->hide();
439 action_tree->hide();
440 }
441 }
442
443 void
on_instance_selector_changed()444 CompView::on_instance_selector_changed()
445 {
446 int i = instance_selector.get_active_row_number();
447 if (i < 0 || i >= (int)instances.size()) return;
448 if (selected_instance == instances[i]) return;
449 studio::App::set_selected_instance(instances[i]);
450 }
451
452 void
set_selected_instance(etl::loose_handle<studio::Instance> x)453 CompView::set_selected_instance(etl::loose_handle<studio::Instance> x)
454 {
455 if(studio::App::shutdown_in_progress)
456 return;
457
458 // if it's already selected, don't select it again
459 if (x==selected_instance)
460 return;
461
462 std::list<etl::handle<studio::Instance> >::iterator iter;
463
464 if(x)
465 {
466 int i;
467 for(i=0,iter=studio::App::instance_list.begin();iter!=studio::App::instance_list.end() && ((*iter)!=x);iter++,i++);
468
469 assert(*iter==x);
470
471 instance_selector.set_active(i);
472 }
473 else
474 instance_selector.set_active(0);
475
476 set_selected_instance_(x);
477 }
478
479 void
new_instance(etl::handle<studio::Instance> instance)480 CompView::new_instance(etl::handle<studio::Instance> instance)
481 {
482 if(studio::App::shutdown_in_progress)
483 return;
484
485 assert(instance);
486
487 etl::loose_handle<studio::Instance> loose_instance(instance);
488
489 instance->synfigapp::Instance::signal_filename_changed().connect(sigc::mem_fun(*this,&CompView::refresh_instances));
490 instance->synfigapp::Instance::signal_filename_changed().connect(
491 sigc::bind<etl::loose_handle<studio::Instance> >(
492 sigc::mem_fun(*this,&CompView::set_selected_instance),
493 loose_instance
494 )
495 );
496
497 {
498 std::string name=basename(instance->get_file_name());
499 instance_selector.append(name);
500 instances.push_back(loose_instance);
501 }
502 }
503
504 void
delete_instance(etl::handle<studio::Instance> instance)505 CompView::delete_instance(etl::handle<studio::Instance> instance)
506 {
507 if(studio::App::shutdown_in_progress)
508 return;
509
510 refresh_instances();
511
512 if(selected_instance==instance)
513 {
514 set_selected_instance(0);
515 instance_selector.set_active(0);
516 }
517 }
518
519 void
refresh_instances()520 CompView::refresh_instances()
521 {
522 if(studio::App::shutdown_in_progress)
523 return;
524
525 instances.clear();
526 instance_selector.set_active(-1);
527 instance_selector.remove_all();
528
529 std::list<etl::handle<studio::Instance> >::iterator iter;
530 for(iter=studio::App::instance_list.begin();iter!=studio::App::instance_list.end();iter++)
531 {
532 std::string name=basename((*iter)->get_file_name());
533 instance_selector.append(name);
534 instances.push_back( etl::loose_handle<studio::Instance>(*iter) );
535 }
536 }
537
538 void
on_row_activate(const Gtk::TreeModel::Path & path,Gtk::TreeViewColumn *)539 CompView::on_row_activate(const Gtk::TreeModel::Path &path, Gtk::TreeViewColumn *)
540 {
541 assert(get_selected_instance());
542 studio::Instance::CanvasTreeModel canvas_tree_model;
543 const Gtk::TreeRow row = *(get_selected_instance()->canvas_tree_store()->get_iter(path));
544 if(row[canvas_tree_model.is_canvas])
545 get_selected_instance()->focus(row[canvas_tree_model.canvas]);
546 else
547 studio::App::dialog_not_implemented();
548 }
549
550 bool
on_action_event(GdkEvent * event)551 CompView::on_action_event(GdkEvent *event)
552 {
553 studio::HistoryTreeStore::Model model;
554 switch(event->type)
555 {
556 case GDK_BUTTON_PRESS:
557 case GDK_2BUTTON_PRESS:
558 {
559 Gtk::TreeModel::Path path;
560 Gtk::TreeViewColumn *column;
561 int cell_x, cell_y;
562 if(!action_tree->get_path_at_pos(
563 int(event->button.x),int(event->button.y), // x, y
564 path, // TreeModel::Path&
565 column, //TreeViewColumn*&
566 cell_x,cell_y //int&cell_x,int&cell_y
567 )
568 ) break;
569 const Gtk::TreeRow row = *(action_tree->get_model()->get_iter(path));
570
571 //signal_user_click()(event->button.button,row,(ColumnID)column->get_sort_column_id());
572 if((ColumnID)column->get_sort_column_id()==COLUMNID_JUMP)
573 {
574 etl::handle<synfigapp::Action::Undoable> action(row[model.action]);
575 if((bool)row[model.is_undo])
576 {
577 while(get_selected_instance()->undo_action_stack().size() && get_selected_instance()->undo_action_stack().front()!=action)
578 get_selected_instance()->undo();
579 }
580 else if((bool)row[model.is_redo])
581 {
582 while(get_selected_instance()->redo_action_stack().size() && get_selected_instance()->undo_action_stack().front()!=action)
583 get_selected_instance()->redo();
584 }
585 }
586 break;
587 }
588 break;
589
590 case GDK_BUTTON_RELEASE:
591 break;
592 default:
593 break;
594 }
595 return false;
596 }
597
598 bool
on_tree_event(GdkEvent * event)599 CompView::on_tree_event(GdkEvent *event)
600 {
601 switch(event->type)
602 {
603 case GDK_BUTTON_PRESS:
604 switch(event->button.button)
605 {
606 case 3:
607 if(get_selected_canvas())
608 {
609 std::vector<Gtk::Widget*> children = menu.get_children();
610 for(std::vector<Gtk::Widget*>::iterator i = children.begin(); i != children.end(); ++i)
611 menu.remove(**i);
612
613 synfigapp::Action::ParamList param_list;
614 param_list.add("canvas",synfig::Canvas::Handle(get_selected_canvas()));
615 param_list.add("canvas_interface",get_selected_instance()->find_canvas_interface(get_selected_canvas()));
616 get_selected_instance()->find_canvas_view(get_selected_canvas())->add_actions_to_menu(&menu, param_list,synfigapp::Action::CATEGORY_CANVAS);
617 menu.popup(0,0);
618 menu.show();
619 }
620 break;
621 default:
622 break;
623 }
624 break;
625 case GDK_MOTION_NOTIFY:
626 break;
627 case GDK_BUTTON_RELEASE:
628 break;
629 default:
630 break;
631 }
632 return false;
633 }
634
635 void
on_action_toggle(const Glib::ustring & path_string)636 CompView::on_action_toggle(const Glib::ustring& path_string)
637 {
638 studio::HistoryTreeStore::Model history_tree_model;
639
640 Gtk::TreePath path(path_string);
641
642 const Gtk::TreeRow row = *(selected_instance->history_tree_store()->get_iter(path));
643
644 handle<synfigapp::Action::Undoable> action=row[history_tree_model.action];
645
646 selected_instance->synfigapp::Instance::set_action_status(action,!action->is_active());
647 }
648