Panel::Panel (workspace::PanelManager& panelManager
,Gdl::DockItem& dockItem
,const gchar* longName
,const gchar* stockID)
: panelManager_(panelManager)
, dockItem_(dockItem)
, panelBar_(*this, stockID)
{
// Set dockItems long-name property
Glib::Value<std::string> val;
val.init(val.value_type());
val.set(longName);
g_object_set_property (G_OBJECT (dockItem.gobj()), "long-name", val.gobj());
/* Set the grip handle */
GdlDockItemGrip *grip = GDL_DOCK_ITEM_GRIP(
gdl_dock_item_get_grip(dockItem.gobj()));
gdl_dock_item_grip_show_handle(grip);
gdl_dock_item_grip_set_label(grip, ((Widget&)panelBar_).gobj());
//gdl_dock_item_grip_set_cursor_type(grip, GDK_LEFT_PTR);
/* Set up the panel body */
// Add this panel's container to the DockItem
dockItem.add((Gtk::Widget&)*this);
/* Connect the signals */
dockItem.signal_hide().connect(
sigc::mem_fun(*this, &Panel::on_item_hidden));
dockItem.show();
}
void
MetaDataTreeStore::set_value_impl(const Gtk::TreeModel::iterator& iter, int column, const Glib::ValueBase& value)
{
if(column>=get_n_columns_vfunc())
{
g_warning("MetaDataTreeStore::set_value_impl: Bad column (%d)",column);
return;
}
if(!g_value_type_compatible(G_VALUE_TYPE(value.gobj()),get_column_type_vfunc(column)))
{
g_warning("MetaDataTreeStore::set_value_impl: Bad value type");
return;
}
if(column==model.data.index())
{
Glib::Value<Glib::ustring> x;
g_value_init(x.gobj(),model.data.type());
g_value_copy(value.gobj(),x.gobj());
synfig::String key((Glib::ustring)(*iter)[model.key]);
synfig::String new_data(x.get());
get_canvas_interface()->set_meta_data(key,new_data);
}
else
Gtk::TreeStore::set_value_impl(iter,column, value);
}
void NatnTreeMdl::get_value_vfunc(const TreeModel::iterator& iter, int column, Glib::ValueBase& value) const
{
if (IsIterValid(iter)) {
if (column < iColRec.size()) {
GType coltype = get_column_type_vfunc(column);
Glib::Value<Glib::ustring> sval;
sval.init(coltype);
string data = iNodesInfo.at(GetRowIndex(iter));
sval.set(data.c_str());
value.init(coltype);
value = sval;
}
}
}
//------------------------------------------------------------------------------
void ListModelWrapper::get_icon_value(const iterator& iter, int column, const bec::NodeId& node,
Glib::ValueBase& value) const {
if (!*_tm)
return;
static ImageCache* pixbufs = ImageCache::get_instance();
static Glib::RefPtr<Gtk::IconTheme> icon_theme = Gtk::IconTheme::get_default();
bec::IconId icon_id = (*_tm)->get_field_icon(node, column, get_icon_size());
value.init(Glib::Value<Glib::RefPtr<Gdk::Pixbuf>>::value_type());
if (icon_id != 0 && icon_id != -1) {
Glib::RefPtr<Gdk::Pixbuf> pixbuf = pixbufs->image(icon_id);
if (pixbuf) {
Glib::Value<Glib::RefPtr<Gdk::Pixbuf>> pixbufValue;
pixbufValue.init(Glib::Value<Glib::RefPtr<Gdk::Pixbuf>>::value_type());
pixbufValue.set(pixbuf);
value = pixbufValue;
}
}
}
//--------------------------------------------------------------------------------
void DbMySQLTableEditorIndexPage::set_value(const Gtk::TreeModel::iterator& iter, int column, GType type, const Glib::ValueBase& value)
{
bec::IndexColumnsListBE *columns_be = _be->get_indexes()->get_columns();
bec::NodeId node(_indexes_columns_model->node_for_iter(iter));
if ( node.is_valid() )
{
switch ( column )
{
case -2:
{
Glib::Value<std::string> v;
v.init(value.gobj());
columns_be->set_field(node, ::bec::IndexColumnsListBE::Descending, v.get() == "ASC" ? 0 : 1);
break;
}
case -8:
{
Glib::Value<bool> v;
v.init(value.gobj());
columns_be->set_column_enabled(node, v.get());
recreate_order_model();
break;
}
}
}
}
void HierTreeMdl::get_value_vfunc(const TreeModel::iterator& iter, int column, Glib::ValueBase& value) const
{
if (IsIterValid(iter)) {
if (column < iColRec.size()) {
GType coltype = get_column_type_vfunc(column);
if (column == HierTreeClrec::KCol_Name) {
Glib::Value<Glib::ustring> sval;
sval.init(coltype);
Elem* node = (Elem*) iter.gobj()->user_data;
//string data = node->EType() + ":" + node->Name();
string data = node->Name();
sval.set(data.c_str());
value.init(coltype);
value = sval;
}
else if (column == HierTreeClrec::KCol_Elem) {
Glib::Value<Elem*> sval;
sval.init(coltype);
Elem* data = (Elem*) iter.gobj()->user_data;
sval.set(data);
value.init(coltype);
value = sval;
}
}
}
}
void
ChildrenTreeStore::set_value_impl(const Gtk::TreeModel::iterator& iter, int column, const Glib::ValueBase& value)
{
if(column>=get_n_columns_vfunc())
{
g_warning("LayerTreeStore::set_value_impl: Bad column (%d)",column);
return;
}
if(!g_value_type_compatible(G_VALUE_TYPE(value.gobj()),get_column_type_vfunc(column)))
{
g_warning("LayerTreeStore::set_value_impl: Bad value type");
return;
}
try
{
if(column==model.value.index())
{
Glib::Value<synfig::ValueBase> x;
g_value_init(x.gobj(),model.value.type());
g_value_copy(value.gobj(),x.gobj());
synfigapp::ValueDesc value_desc((*iter)[model.value_desc]);
if(value_desc)
{
canvas_interface()->change_value(value_desc,x.get());
row_changed(get_path(*iter),*iter);
}
return;
}
else
CanvasTreeStore::set_value_impl(iter,column, value);
}
catch(std::exception x)
{
g_warning("%s", x.what());
}
}
//------------------------------------------------------------------------------
void ListModelWrapper::set_value_impl(const iterator& row, int column, const Glib::ValueBase& value) {
if (!*_tm)
return;
bec::NodeId node(node_for_iter(row));
if (node.is_valid()) {
const GType type = *(_columns.types() + column);
column = _columns.ui2bec(column);
if (column < 0) {
if (!_fake_column_value_setter.empty())
_fake_column_value_setter(row, column, type, value);
} else {
switch (type) {
case G_TYPE_BOOLEAN: {
Glib::Value<bool> v;
v.init(value.gobj());
lmwdprint("LMW::set_value_impl:%s node %s, column %i, value %i\n", _name.c_str(), node.repr().c_str(), column,
v.get());
(*_tm)->set_field(node, column, (ssize_t)v.get());
break;
}
case G_TYPE_INT:
case G_TYPE_UINT: {
Glib::Value<ssize_t> v;
v.init(value.gobj());
lmwdprint("LMW::set_value_impl: node %s, column %i, value %i\n", node.repr().c_str(), column, v.get());
(*_tm)->set_field(node, column, v.get());
break;
}
case G_TYPE_FLOAT:
case G_TYPE_DOUBLE: {
Glib::Value<double> v;
v.init(value.gobj());
(*_tm)->set_field(node, column, v.get());
break;
}
case G_TYPE_STRING: {
Glib::Value<std::string> v;
v.init(value.gobj());
(*_tm)->set_field(node, column, v.get());
lmwdprint("LMW::set_value: %s '%s'\n", _name.c_str(), v.get().c_str());
break;
}
default:
break;
}
}
}
}
void
CanvasTreeStore::get_value_vfunc(const Gtk::TreeModel::iterator& iter, int column, Glib::ValueBase& value)const
{
if(column==model.value.index())
{
synfigapp::ValueDesc value_desc((*iter)[model.value_desc]);
Glib::Value<synfig::ValueBase> x;
g_value_init(x.gobj(),x.value_type());
if(!value_desc)
{
x.set(ValueBase());
}
else
if(value_desc.is_const())
x.set(value_desc.get_value());
else
if(value_desc.is_value_node())
switch(value_desc.get_value_type())
{
case ValueBase::TYPE_BONE:
{
Time time(canvas_interface()->get_time());
Bone bone((*(value_desc.get_value_node()))(time).get(Bone()));
String display(String(bone.get_name()));
ValueNode_Bone::ConstHandle parent(bone.get_parent());
if (!parent->is_root())
display += " --> " + String((*parent->get_link("name"))(time).get(String()));
x.set(display);
break;
}
case ValueBase::TYPE_BONE_WEIGHT_PAIR:
{
Time time(canvas_interface()->get_time());
BoneWeightPair bone_weight_pair((*(value_desc.get_value_node()))(time).get(BoneWeightPair()));
x.set(bone_weight_pair.get_string());
break;
}
case ValueBase::TYPE_SEGMENT:
case ValueBase::TYPE_LIST:
case ValueBase::TYPE_BLINEPOINT:
x.set(ValueBase::type_local_name(value_desc.get_value_type()));
break;
default:
x.set((*value_desc.get_value_node())(canvas_interface()->get_time()));
break;
}
else
{
synfig::error(__FILE__":%d: Unable to figure out value",__LINE__);
return;
}
g_value_init(value.gobj(),x.value_type());
g_value_copy(x.gobj(),value.gobj());
}
else
if(column==model.is_value_node.index())
{
synfigapp::ValueDesc value_desc((*iter)[model.value_desc]);
Glib::Value<bool> x;
g_value_init(x.gobj(),x.value_type());
x.set(value_desc && value_desc.is_value_node());
g_value_init(value.gobj(),x.value_type());
g_value_copy(x.gobj(),value.gobj());
}
else
if(column==model.is_shared.index())
{
synfigapp::ValueDesc value_desc((*iter)[model.value_desc]);
Glib::Value<bool> x;
g_value_init(x.gobj(),x.value_type());
x.set(value_desc.is_value_node() && value_desc.get_value_node()->rcount()>1);
g_value_init(value.gobj(),x.value_type());
g_value_copy(x.gobj(),value.gobj());
}
else
if(column==model.is_exported.index())
{
synfigapp::ValueDesc value_desc((*iter)[model.value_desc]);
Glib::Value<bool> x;
g_value_init(x.gobj(),x.value_type());
x.set(value_desc.is_value_node() && value_desc.get_value_node()->is_exported());
g_value_init(value.gobj(),x.value_type());
g_value_copy(x.gobj(),value.gobj());
}
else
if(column==model.is_canvas.index())
{
synfigapp::ValueDesc value_desc((*iter)[model.value_desc]);
Glib::Value<bool> x;
g_value_init(x.gobj(),x.value_type());
x.set(!value_desc && (Canvas::Handle)(*iter)[model.canvas]);
g_value_init(value.gobj(),x.value_type());
g_value_copy(x.gobj(),value.gobj());
}
else
if(column==model.id.index())
{
synfigapp::ValueDesc value_desc((*iter)[model.value_desc]);
Glib::Value<Glib::ustring> x;
g_value_init(x.gobj(),x.value_type());
if(value_desc && value_desc.is_value_node())
x.set(value_desc.get_value_node()->get_id());
else if(!value_desc && Canvas::Handle((*iter)[model.canvas]))
x.set(Canvas::Handle((*iter)[model.canvas])->get_id());
else
return Gtk::TreeStore::get_value_vfunc(iter,column,value);
g_value_init(value.gobj(),x.value_type());
g_value_copy(x.gobj(),value.gobj());
}
else
if(column==model.is_editable.index())
{
synfigapp::ValueDesc value_desc((*iter)[model.value_desc]);
Glib::Value<bool> x;
g_value_init(x.gobj(),x.value_type());
x.set(!value_desc.is_value_node() || synfigapp::is_editable(value_desc.get_value_node()));
g_value_init(value.gobj(),x.value_type());
g_value_copy(x.gobj(),value.gobj());
}
else
if(column==model.type.index())
{
synfigapp::ValueDesc value_desc((*iter)[model.value_desc]);
String stype, lname;
Glib::Value<Glib::ustring> x;
g_value_init(x.gobj(),x.value_type());
// Set the type
if(!value_desc)
{
if((*iter)[model.is_canvas])
x.set(_("Canvas"));
}
else
{
stype=ValueBase::type_local_name(value_desc.get_value_type());
if(!value_desc.is_const())
stype+=" (" + value_desc.get_value_node()->get_local_name() + ")";
}
x.set(stype.c_str());
g_value_init(value.gobj(),x.value_type());
g_value_copy(x.gobj(),value.gobj());
}
else
if(column==model.label.index())
{
synfigapp::ValueDesc value_desc((*iter)[model.value_desc]);
Glib::Value<Glib::ustring> x;
g_value_init(x.gobj(),x.value_type());
// Set the type
if(!value_desc)
{
Canvas::Handle canvas((*iter)[model.canvas]);
if(canvas)
{
if(!canvas->get_id().empty())
x.set(canvas->get_id());
else if(!canvas->get_name().empty())
x.set(canvas->get_name());
else
x.set(_("[Unnamed]"));
// todo: what are the previous 6 lines for if we're going to overwrite it here?
x.set(_("Canvas"));
}
return Gtk::TreeStore::get_value_vfunc(iter,column,value);
}
else
{
ValueNode::Handle value_node=value_desc.get_value_node();
// Setup the row's label
if(value_node->get_id().empty())
x.set(Glib::ustring((*iter)[model.name]));
else if(Glib::ustring((*iter)[model.name]).empty())
x.set(value_node->get_id());
else
x.set(Glib::ustring((*iter)[model.name])+" ("+value_node->get_id()+')');
}
g_value_init(value.gobj(),x.value_type());
g_value_copy(x.gobj(),value.gobj());
}
else
if(column==model.icon.index())
{
synfigapp::ValueDesc value_desc((*iter)[model.value_desc]);
if(!value_desc)
return Gtk::TreeStore::get_value_vfunc(iter,column,value);
Glib::Value<Glib::RefPtr<Gdk::Pixbuf> > x;
g_value_init(x.gobj(),x.value_type());
x.set(get_tree_pixbuf(value_desc.get_value_type()));
g_value_init(value.gobj(),x.value_type());
g_value_copy(x.gobj(),value.gobj());
}
else
if(column==model.interpolation_icon.index())
{
synfigapp::ValueDesc value_desc((*iter)[model.value_desc]);
if(!value_desc)
return Gtk::TreeStore::get_value_vfunc(iter,column,value);
Glib::Value<Glib::RefPtr<Gdk::Pixbuf> > x;
g_value_init(x.gobj(),x.value_type());
x.set(get_interpolation_pixbuf(value_desc.get_interpolation()));
g_value_init(value.gobj(),x.value_type());
g_value_copy(x.gobj(),value.gobj());
}
else
if(column==model.is_static.index())
{
synfigapp::ValueDesc value_desc((*iter)[model.value_desc]);
Glib::Value<bool> x;
g_value_init(x.gobj(),x.value_type());
x.set(value_desc.get_static());
g_value_init(value.gobj(),x.value_type());
g_value_copy(x.gobj(),value.gobj());
}
else
if(column==model.interpolation_icon_visible.index())
{
synfigapp::ValueDesc value_desc((*iter)[model.value_desc]);
Glib::Value<bool> x;
g_value_init(x.gobj(),x.value_type());
bool is_visible((!value_desc.get_static())
&& (value_desc.get_interpolation()!=INTERPOLATION_UNDEFINED)
&& (value_desc.get_interpolation()!=INTERPOLATION_MANUAL)
&& (value_desc.get_interpolation()!=INTERPOLATION_NIL));
x.set(is_visible);
g_value_init(value.gobj(),x.value_type());
g_value_copy(x.gobj(),value.gobj());
}
else
Gtk::TreeStore::get_value_vfunc(iter,column,value);
}
