//------------------------------------------------------------------------------ bool TreeModelWrapper::iter_nth_child_vfunc(const iterator& parent, int n, iterator& iter) const { // dprint("%s\n", __FUNCTION__); // Sets @a iter to be the child of @a parent using the given index. The first // index is 0. If @a n is too big, or @a parent has no children, @a iter is set // to an invalid iterator and false is returned. // See also iter_nth_root_child_vfunc() bool ret = false; bec::NodeId parent_node(node_for_iter(parent)); // Invalidate iter_next reset_iter(iter); if (tm()) { if (parent_node.is_valid()) { const int children_count = tm()->count_children(parent_node); if (n >= 0 && children_count > 0 && n < children_count) { bec::NodeId child(tm()->get_child(parent_node, n)); if (child.is_valid()) { init_gtktreeiter(iter.gobj(), child); ret = true; // dprint("%s(parent->'%s', int n = %i, iter->'%s')\n", __FUNCTION__, parent_node.repr().c_str(), n, // child.repr().c_str()); } } } } return ret; }
//------------------------------------------------------------------------------ bool ListModelWrapper::iter_next_vfunc(const iterator& iter, iterator& iter_next) const { bool ret = false; bec::NodeId current_node= node_for_iter(iter); //g_message("LMW::iter_next_vfunc: %s", _name.c_str()); // Invalidate iter_next reset_iter(iter_next); if (*_tm) { if (current_node.is_valid() && (*_tm)->has_next(current_node)) { try { // Obtain parent of the current node to get number of children of the parent node current_node = (*_tm)->get_next(current_node); } catch (...) { current_node= bec::NodeId(); } // Check if the resulted nodeid is valid and setup iter_next with values pointing to the nodeid if ( current_node.is_valid() ) ret = init_gtktreeiter(iter_next.gobj(), current_node); } } return ret; }
//------------------------------------------------------------------------------ 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 TreeModelWrapper::tree_row_expanded(const iterator& iter, const Path& path) { if (tm()) { if (_expanded_rows) _expanded_rows->insert(path.to_string()); tm()->expand_node(node_for_iter(iter)); } }
//------------------------------------------------------------------------------ Gtk::TreeModel::Path ListModelWrapper::get_path_vfunc(const iterator& iter) const { const bec::NodeId node = node_for_iter(iter); Gtk::TreeModel::Path path; if (node.is_valid()) { const int node_depth = node.depth(); for (int i = 0; i < node_depth; i++) path.push_back(node[i]); } return path; }
Gtk::TreeModel::Path TreeModelWrapper::get_path_vfunc(const iterator& iter) const { bec::NodeId node = node_for_iter(iter); Gtk::TreeModel::Path path; if (node.is_valid()) { const int node_depth = node.depth(); // get path from an iterator. The iterator points to the node, so // we have to trim the root node prefix so we have a path to the tree for (int i = bec::NodeId(_root_node_path).depth(); i < node_depth; i++) path.push_back(node[i]); } return path; }
//------------------------------------------------------------------------------ int TreeModelWrapper::iter_n_children_vfunc(const iterator& iter) const { if (!_children_count_enabled) return 1; int ret = 0; bec::NodeId node(node_for_iter(iter)); if (tm() && node.is_valid()) { // can't expand here otherwise the live tree will pre-fetch everything when the tree is shown if (!_delay_expanding_nodes) // need to expand here because otherwise the backend won't know how many children the node has tm()->expand_node(node); ret = tm()->count_children(node); } return ret; }
//------------------------------------------------------------------------------ bool TreeModelWrapper::iter_parent_vfunc(const iterator& child, iterator& iter) const { // dprint("%s\n", __FUNCTION__); bool ret = false; if (tm()) { bec::NodeId node(node_for_iter(child)); if (node.is_valid()) { // Make iter (parent would be iterator) invalid from the start, just in case the code below // will fail reset_iter(iter); bec::NodeId would_be_parent(tm()->get_parent(node)); if (would_be_parent.is_valid()) { init_gtktreeiter(iter.gobj(), would_be_parent); ret = true; // dprint("%s(child->'%s', parent->'%s')\n", __FUNCTION__, bec::NodeId(tm->nodeuid_to_path(uid)).repr().c_str(), // would_be_parent.repr().c_str()); } } } return ret; }
//------------------------------------------------------------------------------ bool ListModelWrapper::iter_is_valid(const iterator& iter) const { bec::NodeId node(node_for_iter(iter)); return node.is_valid(); }
//------------------------------------------------------------------------------ void ListModelWrapper::get_value_vfunc(const iterator& iter, int column, Glib::ValueBase& value) const { if (!*_tm) return; bec::NodeId node = node_for_iter(iter); if (node.is_valid()) { const GType type = *(_columns.types() + column); column = _columns.ui2bec(column); if (column < 0) { if (!_fake_column_value_getter.empty()) _fake_column_value_getter(iter, column, type, value); } else if (type == GDK_TYPE_PIXBUF) { get_icon_value(iter, column, node, value); } else { switch (type) { case G_TYPE_BOOLEAN: { bool bv = false; (*_tm)->get_field(node, column, bv); set_glib_bool(value, bv); lmwdprint("LMW::get_value_vfunc: %s: node %s, col %i: value: %i\n", _name.c_str(), node.repr().c_str(), column, bv); break; } case G_TYPE_INT: case G_TYPE_UINT: { ssize_t iv = 0; (*_tm)->get_field(node, column, iv); set_glib_int(value, iv); lmwdprint("LMW::get_value_vfunc: %s: node %s, col %i: value: %i\n", _name.c_str(), node.repr().c_str(), column, iv); break; } case G_TYPE_LONG: case G_TYPE_ULONG: case G_TYPE_INT64: case G_TYPE_UINT64: { throw std::logic_error("Imlement long ints in get_value_func"); break; } case G_TYPE_FLOAT: case G_TYPE_DOUBLE: { double dv = 0.0; (*_tm)->get_field(node, column, dv); set_glib_double(value, dv); lmwdprint("LMW::get_value_vfunc: %s: node %s, col %i: value: %f\n", _name.c_str(), node.repr().c_str(), column, dv); break; } case G_TYPE_STRING: { std::string sv; if (column < 0) sv = (*_tm)->get_field_description(node, -column); else (*_tm)->get_field_repr(node, column, sv); set_glib_string(value, sv, true); lmwdprint("LMW::get_value_vfunc: %s: node %s, col %i: value: '%s'\n", _name.c_str(), node.repr().c_str(), column, sv.c_str()); break; } default: set_glib_string(value, "<unkn>"); break; } } } }