void
Dock_Layers::changed_canvas_view_vfunc(etl::loose_handle<CanvasView> canvas_view)
{
if(canvas_view)
{
Gtk::Widget* tree_view(canvas_view->get_ext_widget(get_name()));
add(*tree_view);
tree_view->show();
action_group_new_layers->set_sensitive(true);
if(layer_action_manager)
{
layer_action_manager->set_layer_tree(dynamic_cast<LayerTree*>(canvas_view->get_ext_widget(get_name()+"_cmp")));
layer_action_manager->set_canvas_interface(canvas_view->canvas_interface());
layer_action_manager->refresh();
}
}
else
{
action_group_new_layers->set_sensitive(false);
if(layer_action_manager)
{
layer_action_manager->clear();
layer_action_manager->set_canvas_interface(0);
layer_action_manager->set_layer_tree(0);
}
clear_previous();
}
}
void
Dock_Curves::init_canvas_view_vfunc(etl::loose_handle<CanvasView> canvas_view)
{
//! Curves is registred thrue CanvasView::set_ext_widget
//! and will be deleted during CanvasView::~CanvasView()
//! \see CanvasView::set_ext_widget
//! \see CanvasView::~CanvasView
Widget_Curves* curves(new Widget_Curves());
curves->set_time_adjustment(canvas_view->time_adjustment());
Gtk::TreeView* param_tree_view(
static_cast<Gtk::TreeView*>(canvas_view->get_ext_widget("params"))
);
param_tree_view->get_selection()->signal_changed().connect(
sigc::bind(
sigc::bind(
sigc::ptr_fun(
_curve_selection_changed
),curves
),param_tree_view
)
);
studio::LayerTree* tree_layer(dynamic_cast<studio::LayerTree*>(canvas_view->get_ext_widget("layers_cmp")));
tree_layer->signal_param_tree_header_height_changed().connect(sigc::mem_fun(*this, &studio::Dock_Curves::on_update_header_height));
canvas_view->set_ext_widget(get_name(),curves);
}
void
Dock_Keyframes::changed_canvas_view_vfunc(etl::loose_handle<CanvasView> canvas_view)
{
if(canvas_view)
{
Gtk::Widget* tree_view(canvas_view->get_ext_widget(get_name()));
add(*tree_view);
tree_view->show();
keyframe_action_manager->set_keyframe_tree(dynamic_cast<KeyframeTree*>(canvas_view->get_ext_widget(get_name())));
keyframe_action_manager->set_canvas_interface(canvas_view->canvas_interface());
keyframe_action_manager->refresh();
}
else
{
if(keyframe_action_manager)
{
keyframe_action_manager->clear();
keyframe_action_manager->set_keyframe_tree(0);
keyframe_action_manager->set_canvas_interface(0);
}
clear_previous();
}
}
void
Dock_MetaData::init_canvas_view_vfunc(etl::loose_handle<CanvasView> canvas_view)
{
Glib::RefPtr<MetaDataTreeStore> metadata_tree_store;
metadata_tree_store=MetaDataTreeStore::create(canvas_view->canvas_interface());
MetaDataTree* metadata_tree(new MetaDataTree());
metadata_tree->set_model(metadata_tree_store);
metadata_tree->set_editable(true);
canvas_view->set_tree_model(get_name(),metadata_tree_store);
canvas_view->set_ext_widget(get_name(),metadata_tree);
}
void
Dock_LayerGroups::init_canvas_view_vfunc(etl::loose_handle<CanvasView> canvas_view)
{
Glib::RefPtr<LayerGroupTreeStore> layer_group_tree_store;
layer_group_tree_store=LayerGroupTreeStore::create(canvas_view->canvas_interface());
LayerGroupTree* layer_group_tree(new LayerGroupTree());
layer_group_tree->set_model(layer_group_tree_store);
layer_group_tree->signal_popup_layer_menu().connect(sigc::mem_fun(*canvas_view,&CanvasView::popup_layer_menu));
canvas_view->set_tree_model(get_name(),layer_group_tree_store);
canvas_view->set_ext_widget(get_name(),layer_group_tree);
}
void
Dock_Children::init_canvas_view_vfunc(etl::loose_handle<CanvasView> canvas_view)
{
Glib::RefPtr<ChildrenTreeStore> children_tree_store;
children_tree_store=ChildrenTreeStore::create(canvas_view->canvas_interface());
ChildrenTree* children_tree(new ChildrenTree());
children_tree->set_model(children_tree_store);
children_tree->set_time_adjustment(canvas_view->time_adjustment());
canvas_view->set_tree_model(get_name(),children_tree_store);
canvas_view->set_ext_widget(get_name(),children_tree);
}
void
Dock_History::init_instance_vfunc(etl::loose_handle<Instance> instance)
{
instance->signal_undo_redo_status_changed().connect(
sigc::mem_fun(*this,&Dock_History::update_undo_redo)
);
}
void
Dock_Keyframes::init_canvas_view_vfunc(etl::loose_handle<CanvasView> canvas_view)
{
Glib::RefPtr<KeyframeTreeStore> keyframe_tree_store;
keyframe_tree_store=KeyframeTreeStore::create(canvas_view->canvas_interface());
KeyframeTree* keyframe_tree(new KeyframeTree());
keyframe_tree->set_model(keyframe_tree_store);
keyframe_tree->set_editable(true);
canvas_view->set_tree_model(get_name(),keyframe_tree_store);
canvas_view->set_ext_widget(get_name(),keyframe_tree);
// keyframe actions status are connected to animation duration
canvas_view->canvas_interface()->signal_rend_desc_changed().connect(
sigc::mem_fun(*this,&studio::Dock_Keyframes::refresh_rend_desc)
);
}
void studio::Dock_Info::changed_canvas_view_vfunc(etl::loose_handle<CanvasView> canvas_view)
{
mousecon.disconnect();
if(canvas_view && canvas_view->get_work_area())
{
mousecon = get_canvas_view()->work_area->signal_cursor_moved().connect(sigc::mem_fun(*this,&Dock_Info::on_mouse_move));
}
}
void
Dock_Curves::changed_canvas_view_vfunc(etl::loose_handle<CanvasView> canvas_view)
{
if(table_)
{
table_->hide();
delete table_;
hscrollbar_->unset_adjustment();
vscrollbar_->unset_adjustment();
//widget_timeslider_->unset_adjustment();
table_=0;
}
if(canvas_view)
{
last_widget_curves_=dynamic_cast<Widget_Curves*>(
canvas_view->get_ext_widget(get_name())
);
vscrollbar_->set_adjustment(last_widget_curves_->get_range_adjustment());
hscrollbar_->set_adjustment(canvas_view->time_window_adjustment());
widget_timeslider_->set_time_adjustment(&canvas_view->time_adjustment());
widget_timeslider_->set_bounds_adjustment(&canvas_view->time_window_adjustment());
widget_timeslider_->set_global_fps(canvas_view->get_canvas()->rend_desc().get_frame_rate());
table_=new Gtk::Table(2,2);
table_->attach(*widget_timeslider_, 0, 1, 0, 1, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::SHRINK);
table_->attach(*last_widget_curves_, 0, 1, 1, 2, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::EXPAND);
table_->attach(*hscrollbar_, 0, 1, 2, 3, Gtk::FILL|Gtk::EXPAND, Gtk::FILL|Gtk::SHRINK);
table_->attach(*vscrollbar_, 1, 2, 0, 2, Gtk::FILL|Gtk::SHRINK, Gtk::FILL|Gtk::EXPAND);
add(*table_);
//add(*last_widget_curves_);
last_widget_curves_->show();
table_->show_all();
show_all();
}
else
{
//clear_previous();
}
}
void studio::Dock_Navigator::changed_canvas_view_vfunc(etl::loose_handle<CanvasView> canvas_view)
{
if(canvas_view)
{
Widget *v = canvas_view->get_ext_widget("navview");
if(!v)
{
v = new Widget_NavView(canvas_view);
canvas_view->set_ext_widget("navview",v);
}
add(*v);
}else
{
clear_previous();
//add(dummy);
}
}
String
ValueNode::get_relative_id(etl::loose_handle<const Canvas> x)const
{
assert(is_exported());
assert(canvas_);
if(x.get()==canvas_.get())
return get_id();
return canvas_->_get_relative_id(x)+':'+get_id();
}
void
Dock_MetaData::changed_canvas_view_vfunc(etl::loose_handle<CanvasView> canvas_view)
{
if(canvas_view)
{
Gtk::Widget* tree_view(canvas_view->get_ext_widget(get_name()));
add(*tree_view);
tree_view->show();
}
else
clear_previous();
}
void
Dock_Curves::init_canvas_view_vfunc(etl::loose_handle<CanvasView> canvas_view)
{
Widget_Curves* curves(new Widget_Curves());
curves->set_time_adjustment(canvas_view->time_adjustment());
Gtk::TreeView* param_tree_view(
static_cast<Gtk::TreeView*>(canvas_view->get_ext_widget("params"))
);
param_tree_view->get_selection()->signal_changed().connect(
sigc::bind(
sigc::bind(
sigc::ptr_fun(
_curve_selection_changed
),curves
),param_tree_view
)
);
canvas_view->set_ext_widget(get_name(),curves);
}
void
Dock_LayerGroups::changed_canvas_view_vfunc(etl::loose_handle<CanvasView> canvas_view)
{
if(canvas_view)
{
Gtk::Widget* tree_view(canvas_view->get_ext_widget(get_name()));
add(*tree_view);
tree_view->show();
group_action_manager->set_group_tree(dynamic_cast<LayerGroupTree*>(tree_view));
group_action_manager->set_canvas_interface(canvas_view->canvas_interface());
group_action_manager->refresh();
}
else
{
clear_previous();
group_action_manager->clear();
group_action_manager->set_canvas_interface(0);
group_action_manager->set_group_tree(0);
}
}
bool
Layer::connect_dynamic_param(const String& param, etl::loose_handle<ValueNode> value_node)
{
if (!value_node) return disconnect_dynamic_param(param);
ValueNode::Handle previous;
DynamicParamList::iterator i = dynamic_param_list_.find(param);
if (i != dynamic_param_list_.end()) previous = i->second;
if (previous == value_node)
return true;
String param_noref = param;
dynamic_param_list_[param]=ValueNode::Handle(value_node);
if (previous)
{
// fix 2353284: if two parameters in the same layer are
// connected to the same valuenode and we disconnect one of
// them, the parent-child relationship for the remaining
// connection was being deleted. now we search the parameter
// list to see if another parameter uses the same valuenode
DynamicParamList::const_iterator iter;
for (iter = dynamic_param_list().begin(); iter != dynamic_param_list().end(); iter++)
if (iter->second == previous)
break;
if (iter == dynamic_param_list().end())
remove_child(previous.get());
}
add_child(value_node.get());
if(!value_node->is_exported() && get_canvas())
value_node->set_parent_canvas(get_canvas());
dynamic_param_changed(param);
changed();
return true;
}
void
ValueBase::set(etl::loose_handle<Canvas> x)
{
clear();
if(x
#ifndef TRY_FIX_FOR_BUG_27
&& x->is_inline()
#endif
)
_set(etl::handle<Canvas>(x));
else
_set(etl::loose_handle<Canvas>(x));
assert(get(x)==x);
}
bool
Layer::connect_dynamic_param(const String& param, etl::loose_handle<ValueNode> value_node)
{
ValueNode::Handle previous(dynamic_param_list_[param]);
if(previous==value_node)
return true;
dynamic_param_list_[param]=ValueNode::Handle(value_node);
if(previous)
remove_child(previous.get());
add_child(value_node.get());
if(!value_node->is_exported() && get_canvas())
{
value_node->set_parent_canvas(get_canvas());
}
changed();
return true;
}
HistoryTreeStore::HistoryTreeStore(etl::loose_handle<studio::Instance> instance_):
Gtk::TreeStore (ModelHack()),
instance_ (instance_)
{
instance_->signal_undo().connect(sigc::mem_fun(*this,&studio::HistoryTreeStore::on_undo));
instance_->signal_redo().connect(sigc::mem_fun(*this,&studio::HistoryTreeStore::on_redo));
instance_->signal_undo_stack_cleared().connect(sigc::mem_fun(*this,&studio::HistoryTreeStore::on_undo_stack_cleared));
instance_->signal_redo_stack_cleared().connect(sigc::mem_fun(*this,&studio::HistoryTreeStore::on_redo_stack_cleared));
instance_->signal_new_action().connect(sigc::mem_fun(*this,&studio::HistoryTreeStore::on_new_action));
instance_->signal_action_status_changed().connect(sigc::mem_fun(*this,&studio::HistoryTreeStore::on_action_status_changed));
}
void
Dock_Params::init_canvas_view_vfunc(etl::loose_handle<CanvasView> canvas_view)
{
Gtk::TreeView* tree_view(
static_cast<Gtk::TreeView*>(canvas_view->get_ext_widget(get_name()))
);
if(tree_view)
{
tree_view->get_selection()->signal_changed().connect(
sigc::mem_fun(
*this,
&Dock_Params::refresh_selected_param
)
);
}
}
void
Dock_MetaData::changed_canvas_view_vfunc(etl::loose_handle<CanvasView> canvas_view)
{
if(canvas_view)
{
Gtk::Widget* tree_view(canvas_view->get_ext_widget(get_name()));
add(*tree_view);
tree_view->show();
action_group->set_sensitive(true);
}
else
{
clear_previous();
action_group->set_sensitive(false);
}
}
void
synfig::Layer::set_canvas(etl::loose_handle<Canvas> x)
{
if(canvas_!=x)
{
parent_death_connect_.disconnect();
canvas_=x;
if(x)
{
parent_death_connect_=x->signal_deleted().connect(
sigc::bind(
sigc::mem_fun(
*this,
&Layer::set_canvas
),
etl::loose_handle<synfig::Canvas>(0)
)
);
}
on_canvas_set();
}
}
void
ValueNode_StaticList::set_member_canvas(etl::loose_handle<Canvas> canvas) // line 723
{
for (vector<ReplaceableListEntry>::iterator iter = list.begin(); iter != list.end(); iter++)
{
if (getenv("SYNFIG_DEBUG_SET_PARENT_CANVAS"))
printf("%s:%d set parent canvas of member (%lx) to (%lx)\n", __FILE__, __LINE__, uintptr_t((*iter).get()), uintptr_t(canvas.get()));
(*iter)->set_parent_canvas(canvas);
}
}
void
ValueNode::set_parent_canvas(etl::loose_handle<Canvas> x)
{
canvas_=x; if(x) root_canvas_=x->get_root();
}
void
ValueNode::set_root_canvas(etl::loose_handle<Canvas> x)
{
root_canvas_=x->get_root();
}
void
Dock_Layers::init_canvas_view_vfunc(etl::loose_handle<CanvasView> canvas_view)
{
Glib::RefPtr<LayerTreeStore> layer_tree_store;
layer_tree_store=LayerTreeStore::create(canvas_view->canvas_interface());
canvas_view->set_tree_model(get_name(),layer_tree_store);
//! layer_tree is registred thrue CanvasView::set_ext_widget
//! and will be deleted during CanvasView::~CanvasView()
//! \see CanvasView::set_ext_widget
//! \see CanvasView::~CanvasView
LayerTree* layer_tree(new LayerTree());
layer_tree->set_time_adjustment(canvas_view->time_adjustment());
layer_tree->signal_edited_value().connect(
sigc::hide_return(
sigc::bind(sigc::mem_fun(*canvas_view->canvas_interface(), &synfigapp::CanvasInterface::change_value), false)
)
);
// (a) should be before (b), (b) should be before (c)
canvas_view->set_ext_widget(get_name()+"_cmp",layer_tree); // (a)
canvas_view->set_ext_widget(get_name(),&layer_tree->get_layer_tree_view());
canvas_view->set_ext_widget("params",&layer_tree->get_param_tree_view());
layer_tree->set_model(layer_tree_store); // (b)
canvas_view->set_tree_model("params",layer_tree->get_param_tree_view().get_model()); // (c)
/*
canvas_view->layermenu.items().push_back(Gtk::Menu_Helpers::StockMenuElem(Gtk::StockID("gtk-delete"),Gtk::AccelKey("Delete"),
sigc::mem_fun(*layer_tree, &LayerTree::on_delete_pressed))
);
*/
// Hide the time bar
if(canvas_view->get_canvas()->rend_desc().get_time_start()==canvas_view->get_canvas()->rend_desc().get_time_end())
canvas_view->hide_timebar();
layer_tree_store->rebuild();
present();
}
ValueNode_Bone::ValueNode_Bone(const ValueBase &value, etl::loose_handle<Canvas> canvas):
LinkableValueNode(value.get_type())
{
if (getenv("SYNFIG_DEBUG_BONE_CONSTRUCTORS"))
{
printf("\n%s:%d ------------------------------------------------------------------------\n", __FILE__, __LINE__);
printf("%s:%d --- ValueNode_Bone() for %s at %lx---\n", __FILE__, __LINE__, GET_GUID_CSTR(get_guid()), uintptr_t(this));
printf("%s:%d ------------------------------------------------------------------------\n\n", __FILE__, __LINE__);
}
Vocab ret(get_children_vocab());
set_children_vocab(ret);
Type &type = value.get_type();
if (type == type_bone_object)
{
Bone bone(value.get(Bone()));
String name(bone.get_name());
if (name.empty())
name = strprintf(_("Bone %d"), ++bone_counter);
name = unique_name(name);
set_link("name",ValueNode_Const::create(name));
#ifndef HIDE_BONE_FIELDS
set_link("origin",ValueNode_Const::create(bone.get_origin()));
set_link("angle",ValueNode_Const::create(bone.get_angle()));
set_link("scalelx",ValueNode_Const::create(bone.get_scalelx()));
set_link("scalex",ValueNode_Const::create(bone.get_scalex()));
set_link("length",ValueNode_Const::create(bone.get_length()));
set_link("width",ValueNode_Const::create(bone.get_width()));
set_link("tipwidth",ValueNode_Const::create(bone.get_tipwidth()));
set_link("bone_depth",ValueNode_Const::create(bone.get_depth()));
#endif
ValueNode_Bone::ConstHandle parent(ValueNode_Bone::Handle::cast_const(bone.get_parent()));
if (!parent) parent = get_root_bone();
set_link("parent",ValueNode_Const::create(ValueNode_Bone::Handle::cast_const(parent)));
if (getenv("SYNFIG_DEBUG_BONE_MAP"))
printf("%s:%d adding to canvas_map\n", __FILE__, __LINE__);
canvas_map[get_root_canvas()][get_guid()] = this;
if (getenv("SYNFIG_DEBUG_SET_PARENT_CANVAS"))
printf("%s:%d set parent canvas for bone %lx to %lx\n", __FILE__, __LINE__, uintptr_t(this), uintptr_t(canvas.get()));
set_parent_canvas(canvas);
show_bone_map(get_root_canvas(), __FILE__, __LINE__, strprintf("in constructor of %s at %lx", GET_GUID_CSTR(get_guid()), uintptr_t(this)));
}
else
{
throw Exception::BadType(value.get_type().description.local_name);
}
}
void
ValueNode_Bone::set_root_canvas(etl::loose_handle<Canvas> canvas)
{
GUID guid(get_guid());
Canvas::LooseHandle old_canvas(get_root_canvas());
show_bone_map(old_canvas, __FILE__, __LINE__, strprintf("before changing canvas from %lx to (%lx)", uintptr_t(old_canvas.get()), uintptr_t(canvas.get())));
LinkableValueNode::set_root_canvas(canvas);
Canvas::LooseHandle new_canvas(get_root_canvas()); // it isn't necessarily what we passed in, because set_root_canvas walks up to the root
if (new_canvas != old_canvas)
{
if (!canvas_map[old_canvas].count(guid))
warning("%s:%d the node we're moving (%lx) isn't in the map", __FILE__, __LINE__, uintptr_t(this));
canvas_map[new_canvas][guid] = canvas_map[old_canvas][guid];
canvas_map[old_canvas].erase(guid);
show_bone_map(new_canvas, __FILE__, __LINE__, strprintf("after changing canvas from %lx to %lx", uintptr_t(old_canvas.get()), uintptr_t(new_canvas.get())));
}
else
if (getenv("SYNFIG_DEBUG_BONE_MAP"))
printf("%s:%d canvases are the same\n", __FILE__, __LINE__);
}