Index: tests/glibmm_tree/main.cc
===================================================================
--- tests/glibmm_tree/main.cc	(revision 692)
+++ tests/glibmm_tree/main.cc	(working copy)
@@ -2,15 +2,15 @@
 
 #include <glibmm.h>
 
-bool echo(std::string& i)
+bool echo(Glib::Tree<std::string>& i)
 {
-  std::cout << i << ' ';
+  std::cout << i.data() << ' ';
   return false;
 }
 
-void echof(std::string& i)
+void echof(Glib::Tree<std::string>& i)
 {
-  std::cout << i << ' ';
+  std::cout << i.data() << ' ';
 }
 
 
@@ -28,8 +28,8 @@
                           tc(c),
                           te(e);
 
-  sigc::slot<bool, std::string&> echoslot = sigc::ptr_fun(echo);
-  sigc::slot<void, std::string&>echofslot = sigc::ptr_fun(echof);
+  sigc::slot<bool, Glib::Tree<std::string>&> echoslot = sigc::ptr_fun(echo);
+  sigc::slot<void, Glib::Tree<std::string>&> echofslot = sigc::ptr_fun(echof);
 
 
   ta.insert(0, tc);
@@ -39,19 +39,19 @@
   te.prepend_data(f);
 
   std::cout << "Breadth-first:" << std::endl;
-  ta.traverse(Glib::LEVEL_ORDER, Glib::TRAVERSE_LEAVES | Glib::TRAVERSE_NON_LEAVES, INT_MAX, &echoslot);
+  ta.traverse(Glib::LEVEL_ORDER, Glib::TRAVERSE_LEAVES | Glib::TRAVERSE_NON_LEAVES, INT_MAX, echoslot);
   std::cout << std::endl;
 
   std::cout << "Depth-first (pre):" << std::endl;
-  ta.traverse(Glib::PRE_ORDER, Glib::TRAVERSE_LEAVES | Glib::TRAVERSE_NON_LEAVES, INT_MAX, &echoslot);
+  ta.traverse(Glib::PRE_ORDER, Glib::TRAVERSE_LEAVES | Glib::TRAVERSE_NON_LEAVES, INT_MAX, echoslot);
   std::cout << std::endl;
 
   std::cout << "Depth-first (in):" << std::endl;
-  ta.traverse(Glib::IN_ORDER, Glib::TRAVERSE_LEAVES | Glib::TRAVERSE_NON_LEAVES, INT_MAX, &echoslot);
+  ta.traverse(Glib::IN_ORDER, Glib::TRAVERSE_LEAVES | Glib::TRAVERSE_NON_LEAVES, INT_MAX, echoslot);
   std::cout << std::endl;
 
   std::cout << "Depth-first (post):" << std::endl;
-  ta.traverse(Glib::POST_ORDER, Glib::TRAVERSE_LEAVES | Glib::TRAVERSE_NON_LEAVES, INT_MAX, &echoslot);
+  ta.traverse(Glib::POST_ORDER, Glib::TRAVERSE_LEAVES | Glib::TRAVERSE_NON_LEAVES, INT_MAX, echoslot);
   std::cout << std::endl;
 
   Glib::Tree<std::string> *tmp = ta.find(Glib::IN_ORDER, Glib::TRAVERSE_LEAVES | Glib::TRAVERSE_NON_LEAVES, e);
@@ -62,13 +62,17 @@
   if(NULL == tmp){ std::cout << a << " not found" << std::endl; }
   else{ std::cout << "Found " << (tmp->data()) << std::endl; }
 
+  tmp = ta.find(Glib::IN_ORDER, Glib::TRAVERSE_LEAVES | Glib::TRAVERSE_NON_LEAVES, "f");
+  if(NULL == tmp){ std::cout << a << " not found" << std::endl; }
+  else{ std::cout << "Found " << (tmp->data()) << std::endl; }
+
   tmp = ta.find_child(Glib::TRAVERSE_LEAVES | Glib::TRAVERSE_NON_LEAVES, e);
   if(NULL == tmp){ std::cout << e << " is not a child of " << (ta.data()) << std::endl; }
   else{ std::cout << "Mistakenly found " << e << " in " << (ta.data()) << "'s children" << std::endl; }
 
   tmp = ta.find_child(Glib::TRAVERSE_LEAVES | Glib::TRAVERSE_NON_LEAVES, c);
   if(NULL == tmp) { 
-    std::cout << c << " is the number " << ta.index_of(c) << " child of " << (ta.data()) << std::endl;
+    std::cout << c << " is the number " << ta.child_index(c) << " child of " << (ta.data()) << std::endl;
   }
   else{ std::cout << "Mistakenly didn't find " << c << " in " << (ta.data()) << "'s children" << std::endl; }
 
Index: glib/src/tree.hg
===================================================================
--- glib/src/tree.hg	(revision 692)
+++ glib/src/tree.hg	(working copy)
@@ -43,7 +43,7 @@
  * 
  * To reverse the children of a node use reverse_children().
  * 
- * To find a node use root(), find(), find_child(), index_of(), position_of(), first_child(), last_child(), nth_child(), first_sibling(), prev_sibling(), next_sibling() or last_sibling().
+ * To find a node use root(), find(), find_child(), child_index(), child_position(), first_child(), last_child(), nth_child(), first_sibling(), prev_sibling(), next_sibling() or last_sibling().
  * 
  * To get information about a node or tree use is_leaf(), is_root(), depth(), node_count(), child_count(), is_ancestor() or max_height().
  * 
@@ -58,31 +58,26 @@
 {
   _CLASS_GENERIC(Tree, GNode)
 public:
-  typedef gpointer iterator;
-  typedef sigc::slot<bool, T&>* TraverseFunc;
-  typedef sigc::slot<void, T&>* ForeachFunc;
-  typedef std::map<gpointer, Tree<T>*> NodeMap;
+  typedef sigc::slot<bool, Tree<T>&> SlotTraverse;
+  typedef sigc::slot<void, Tree<T>&> SlotForeach;
 
-  /** Creates a new Tree containing the given data. 
-   * Used to create the first node in a tree.
-   */
-  Tree()
-  : gobject_ (0),
-    owns_gobject_(false),
-    parent_(this)
+private:
+  static Tree<T>* wrap(GNode *node)
   {
+    if (!node)
+      return 0;
+
+    return reinterpret_cast<Tree<T> *>(node->data);
   }
 
-  explicit Tree(T& data)
+public:
+  explicit Tree(T& data) :
+    data_(data)
   {
-    T* tmp = new T();
-    *tmp = data;
+    gobject_ = g_node_new(reinterpret_cast<gpointer>(this));
+  };
+  
 
-    gobject_ = g_node_new(reinterpret_cast<gpointer>(tmp));
-    owns_gobject_ = true;
-    parent_ = this;
-  }
-
   _IGNORE(g_node_new)
 
   /** Removes the instance and its children from the tree,
@@ -90,26 +85,10 @@
    */
   ~Tree()
   {
-    if(this != parent_)
-    {
-      parent_->unlink(*this);
-    }
-
-    for(typename NodeMap::iterator i = children_.begin();
-      i != children_.end(); ++i)
-    {
-      delete i->second;
-    }
-  
-    if(owns_gobject_)
-    {
-      delete reinterpret_cast<T*>(gobject_->data);
-      g_node_destroy(gobject_);
-    }
-  }
+    g_node_destroy(gobj());
+  };
   _IGNORE(g_node_destroy)
 
-
   /** Inserts a Tree beneath the parent at the given position.
    *
    * @param position the position to place node at, with respect to its siblings 
@@ -119,9 +98,7 @@
    */
   Tree<T>& insert(int position, Tree<T>& node)
   {
-    children_[node.gobj()] = &node;
-    g_node_insert(gobject_, position, node.gobj());
-    node.parent(this);
+    g_node_insert(gobj(), position, node.gobj());
     return node;
   }
   _IGNORE(g_node_insert)
@@ -134,9 +111,7 @@
    */
   Tree<T>& insert_before(Tree<T>& sibling, Tree<T>& node)
   {
-    children_[node.gobj()] = &node;
-    g_node_insert_before(gobject_, sibling.gobj(), node.gobj());
-    node.parent(this);
+    g_node_insert_before(gobj(), sibling.gobj(), node.gobj());
     return node;
   }
   _IGNORE(g_node_insert_before)
@@ -149,14 +124,11 @@
    */
   Tree<T>& insert_after(Tree<T>& sibling, Tree<T>& node)
   {
-    children_[node.gobj()] = &node;
-    g_node_insert_after(gobject_, sibling.gobj(), node.gobj());
-    node.parent(this);
+    g_node_insert_after(gobj(), sibling.gobj(), node.gobj());
     return node;
   }
   _IGNORE(g_node_insert_after)
 
-
   /** Inserts a Tree as the last child.
    *
    * @param node the Tree to append
@@ -164,9 +136,7 @@
    */
   Tree<T>& append(Tree<T>& node)
   {
-    children_[node.gobj()] = &node;
-    g_node_append(gobject_, node.gobj());
-    node.parent(this);
+    g_node_append(gobj(), node.gobj());
     return node;
   }
   _IGNORE(g_node_append)
@@ -178,13 +148,11 @@
    */
   Tree<T>& prepend(Tree<T>& node)
   {
-    children_[node.gobj()] = &node;
-    g_node_prepend(gobject_, node.gobj());
-    node.parent(this);
+    g_node_prepend(gobj(), node.gobj());
     return node;
   }
   _IGNORE(g_node_prepend)
-
+  
   /** Inserts a new Tree at the given position.
    *
    * @param position the position to place the new Tree at. 
@@ -194,7 +162,7 @@
    */
   Tree<T>* insert_data(int position, T& data)
   {
-    Tree<T> *node = new Tree<T>(data);
+    Tree<T>* node = new Tree<T>(data);
     insert(position, *node);
     return node;
   }
@@ -239,14 +207,15 @@
     return node;
   }
   _IGNORE(g_node_prepend_data)
-
+  
   /** Reverses the order of the children.
    */
   void reverse_children()
   {
-    g_node_reverse_children(gobject_);
+    g_node_reverse_children(gobj());
   }
   _IGNORE(g_node_reverse_children)
+  
 
   /** Returns a pointer to the root of the tree.
    *
@@ -254,9 +223,10 @@
    */
   Tree<T>* root() const
   {
-    return (this == parent_)? parent_: parent_->root();
+    return wrap(g_node_get_root(gobj()));
   }
   _IGNORE(g_node_get_root)
+  
 
   /** Traverses a tree starting at the current node.
    * It calls the given function for each node visited. 
@@ -269,11 +239,12 @@
    * If max_depth is -1 all nodes in the tree are visited.
    * If max_depth is 1, only the root is visited.
    * If max_depth is 2, the root and its children are visited. And so on.
-   * @param func the slot to invoke for each visited child
+   * @param slot the slot to invoke for each visited child
    */
-  void traverse(TraverseType order, TraverseFlags flags, int max_depth, TraverseFunc func)
+  void traverse(TraverseType order, TraverseFlags flags, int max_depth, const SlotTraverse &slot)
   {
-    g_node_traverse(gobject_, (GTraverseType)order, (GTraverseFlags)flags, max_depth, wrap_traverse_slot, reinterpret_cast<gpointer>(func));
+    SlotTraverse slot_copy = slot;
+    g_node_traverse(gobj(), (GTraverseType)order, (GTraverseFlags)flags, max_depth, wrap_traverse_slot, reinterpret_cast<gpointer>(&slot_copy));
   }
   _IGNORE(g_node_traverse);
 
@@ -281,11 +252,12 @@
    * Note that it doesn't descend beneath the child nodes.
    *
    * @param flags Wwhich types of children are to be visited: One of TRAVERSE_ALL, TRAVERSE_LEAVES and TRAVERSE_NON_LEAVES.
-   * @param func The slot to invoke for each visited node.
+   * @param slot The slot to invoke for each visited node.
    */
-  void foreach(TraverseFlags flags, ForeachFunc func)
+  void foreach(TraverseFlags flags, const SlotForeach &slot)
   {
-    g_node_children_foreach(gobject_, (GTraverseFlags)flags, wrap_foreach_slot, reinterpret_cast<gpointer>(func));
+    SlotForeach slot_copy = slot;
+    g_node_children_foreach(gobj(), (GTraverseFlags)flags, wrap_foreach_slot, reinterpret_cast<gpointer>(&slot_copy));
   }
   _IGNORE(g_node_children_foreach)
 
@@ -297,14 +269,14 @@
    */
   Tree<T>* find_child(TraverseFlags flags, const T& data) const
   {
-    sigc::slot<void, GNode*, const T&, GNode*> real_slot = sigc::ptr_fun(on_compare_child);
-
+    sigc::slot<void,GNode*,const T&,GNode*> real_slot = sigc::ptr_fun(on_compare_child);
+    sigc::slot<void,GNode*> bound_slot;
     GNode* child = 0;
-    type_foreach_gnode_slot bound_slot = sigc::bind(real_slot, data, child);
 
-    g_node_children_foreach(gobject_, (GTraverseFlags)flags, on_wrap_compare_child, reinterpret_cast<gpointer>(&bound_slot));
+    bound_slot = sigc::bind(real_slot, data, child);
+    g_node_children_foreach(gobj(), (GTraverseFlags)flags, on_wrap_compare_child, reinterpret_cast<gpointer>(&bound_slot));
     
-    return lookup(child);
+    return wrap(child);
   }
   _IGNORE(g_node_find_child)
 
@@ -318,35 +290,14 @@
   Tree<T>* find(TraverseType order, TraverseFlags flags, const T& data) const
   {
     //We use a sigc::slot for the C callback, so we can bind some extra data.
-    sigc::slot<gboolean, GNode*, const T&, GNode**> real_slot = sigc::ptr_fun(on_compare_node);
-
+    sigc::slot<gboolean, GNode*, const T&, GNode**> real_slot = sigc::ptr_fun(find_func);
+    sigc::slot<gboolean, GNode*> bound_slot;
     GNode* child = 0;
-    type_traverse_gnode_slot bound_slot = sigc::bind(real_slot, data, &child);
-    
-    g_node_traverse(gobject_, (GTraverseType)order, (GTraverseFlags)flags, -1, on_wrap_compare_node, reinterpret_cast<gpointer>(&bound_slot));
 
-    if(0 == child)
-      return 0;
-  
-    GNode* cursor = child;
-    unsigned int depth = g_node_depth(cursor) - g_node_depth(gobject_);
-    std::stack<iterator, std::deque<iterator> > stack;
-    Tree<T>* treecursor = const_cast<Tree<T>*>(this);
-  
-    for(unsigned int i = 0; i < depth; ++i)
-    {
-      stack.push(cursor);
-      cursor = cursor->parent;
-    }
-  
-    for(;!stack.empty();stack.pop())
-    {
-      treecursor = treecursor->lookup(stack.top());
-      if(0 == treecursor)
-        return 0;
-    }
-  
-    return treecursor;
+    bound_slot = sigc::bind(real_slot, data, &child);
+    g_node_traverse(gobject_, (GTraverseType)order, (GTraverseFlags)flags, -1, on_wrap_find_func, reinterpret_cast<gpointer>(&bound_slot));
+
+    return wrap(child);
   }
   _IGNORE(g_node_find)
 
@@ -356,15 +307,14 @@
    * @return The index of the child which contains data, 
    * or -1 if the data is not found.
    */
-  int index_of(const T& data) const
+  int child_index(const T& data) const
   {
-    int index = 0;
-    for(Tree<T>* i = nth_child(index);
-      i != 0; i = nth_child(++index))
+    for(Tree<T>* i = first_child();
+      i != 0; i = i->next_sibling())
     {
       if((i->data()) == data)
       {
-        return index;
+        return child_position(*i);
       }
     }
     return -1;
@@ -378,9 +328,9 @@
    * @param child A child
    * @return The position of @a child with respect to its siblings.
    */
-  int position_of(const Tree<T>& child) const
+  int child_position(const Tree<T>& child) const
   {
-    return g_node_child_position(gobject_, const_cast<GNode*>(child.gobj()));
+    return g_node_child_position(gobj(), const_cast<GNode*>(child.gobj()));
   }
   _IGNORE(g_node_child_position)
 
@@ -390,7 +340,7 @@
    */
   Tree<T>* first_child() const
   {
-    return lookup(g_node_first_child(gobject_));
+    return wrap(g_node_first_child(gobj()));
   }
   _IGNORE(g_node_first_child)
 
@@ -400,7 +350,7 @@
    */
   Tree<T>* last_child() const
   {
-    return lookup(g_node_last_child(gobject_));
+    return wrap(g_node_last_child(gobj()));
   }
   _IGNORE(g_node_last_child)
 
@@ -410,16 +360,16 @@
    */
   Tree<T>* nth_child(int n) const
   {
-    return lookup(g_node_nth_child(gobject_, n));
+    return wrap(g_node_nth_child(gobj(), n));
   }
   _IGNORE(g_node_nth_child)
-
+  
   /** Gets the first sibling
    * @return The first sibling, or 0 if the node has no siblings.
    */
   Tree<T>* first_sibling() const
   {
-    return parent_->lookup(g_node_first_sibling(gobject_));
+    return wrap(g_node_first_sibling(gobj()));
   }
   _IGNORE(g_node_first_sibling)
 
@@ -429,7 +379,7 @@
    */
   Tree<T>* prev_sibling() const
   {
-    return parent_->lookup(g_node_prev_sibling(gobject_));
+    return wrap(g_node_prev_sibling(gobj()));
   }
   _IGNORE(g_node_prev_sibling)
 
@@ -439,7 +389,7 @@
    */
   Tree<T>* next_sibling() const
   {
-    return parent_->lookup(g_node_next_sibling(gobject_));
+    return wrap(g_node_next_sibling(gobj()));
   }
   _IGNORE(g_node_next_sibling)
 
@@ -449,7 +399,7 @@
    */
   Tree<T>* last_sibling() const
   {
-    return parent_->lookup(g_node_last_sibling(gobject_));
+    return wrap(g_node_last_sibling(gobj()));
   }
   _IGNORE(g_node_last_sibling)
 
@@ -459,7 +409,7 @@
    */
   bool is_leaf() const
   {
-    return G_NODE_IS_LEAF(gobject_);
+    return G_NODE_IS_LEAF(gobj());
   }
 
   /** Returns true if this is the root node.
@@ -468,18 +418,17 @@
    */
   bool is_root() const
   {
-    return G_NODE_IS_ROOT(gobject_);
+    return G_NODE_IS_ROOT(gobj());
   }
 
   /** Gets the depth of this node.
    * The root node has a depth of 1.
    * For the children of the root node the depth is 2. And so on.
-   *
    * @return the depth of this node
    */
   unsigned int depth() const
   {
-    return g_node_depth(gobject_);
+    return g_node_depth(gobj());
   }
   _IGNORE(g_node_depth)
 
@@ -490,7 +439,7 @@
    */
   unsigned int node_count(TraverseFlags flags) const
   {
-    return g_node_n_nodes(gobject_, (GTraverseFlags)flags);
+    return g_node_n_nodes(gobj(), (GTraverseFlags)flags);
   }
   _IGNORE(g_node_n_nodes)
 
@@ -500,7 +449,7 @@
    */
   unsigned int child_count() const
   {
-    return g_node_n_children(gobject_);
+    return g_node_n_children(gobj());
   }
   _IGNORE(g_node_n_children)
 
@@ -513,9 +462,10 @@
    */
   bool is_ancestor(const Tree<T>& descendant) const
   {
-    return g_node_is_ancestor(gobject_, const_cast<GNode*>(descendant.gobj()));
+    return g_node_is_ancestor(gobj(), const_cast<GNode*>(descendant.gobj()));
   }
   _IGNORE(g_node_is_ancestor)
+  
 
   /** Gets the maximum height of all branches beneath this node.
    * This is the maximum distance from the node to all leaf nodes.
@@ -525,7 +475,7 @@
    */
   unsigned int max_height() const
   {
-    return g_node_max_height(gobject_);
+    return g_node_max_height(gobj());
   }
   _IGNORE(g_node_max_height)
 
@@ -533,77 +483,61 @@
    */
   void unlink(Tree<T>& child)
   {
-    children_.erase(child.gobj());
-    child.parent(&child);
     g_node_unlink(child.gobj());
   }
   _IGNORE(g_node_unlink)
-
-  /// Accessor for this node's iterator
-  iterator iter() const
-  {
-    return gobject_;
-  }
-
+  
   /// Accessor for this node's data
   T& data() const
   {
-    return *(reinterpret_cast<T*>(gobject_->data));
+    return data_;
   }
 
-  /** Lookup a child by its iterator.
+
+  /** Accessor for this node's parent.
    *
-   * @param child The iterator of the desired child.
-   * @return The child if found, else 0.
+   * @return The node's parent.
    */
-  Tree<T>* lookup(const iterator child) const
+  const Tree<T>* parent() const
   {
-    typename NodeMap::const_iterator i = children_.find(child);
-    return (children_.end() == i)? 0: i->second;
+    return wrap(gobj()->parent);
   }
 
-  // For auto-wrapping
-  GNode*       gobj()       { return gobject_; }
-  const GNode* gobj() const { return gobject_; }
 
+  /// For auto-wrapping
+  GNode* gobj() const
+  {
+    return gobject_;
+  }
+
   // Leaving these unimplemented for now
   _IGNORE(g_node_copy)
   _IGNORE(g_node_copy_deep)
-
+  
+  
 protected:
+  GNode *gobject_;
+  T &data_;
 
-  /** Accessor for this node's parent.
-   *
-   * @param newparent Provides a new parent for this node. Use 0 to get the current parent.
-   * @return The node's parent.
-   */
-  Tree<T>* parent(Tree<T> *newparent = 0)
+  /// Wrapper for invoking a SlotTraverse
+  static gboolean wrap_traverse_slot(GNode *node, gpointer data)
   {
-    return (0 == newparent) ? parent_: (parent_ = newparent);
+    const SlotTraverse *slot = reinterpret_cast<const SlotTraverse *>(data);
+    return (*slot)(*wrap(node));
   }
 
-  /// Wrapper for invoking a TraverseFunc.
-  static gboolean wrap_traverse_slot(GNode* node, gpointer slot)
+  /// Wrapper for invoking a SlotForeach
+  static void wrap_foreach_slot(GNode *node, gpointer data)
   {
-    TraverseFunc tf = reinterpret_cast<TraverseFunc>(slot);
-    if(tf)
-      return ((*tf)(*(reinterpret_cast<T*>(node->data)))) ? TRUE : FALSE;
-    else
-      return FALSE;
+    const SlotForeach *slot = reinterpret_cast<const SlotForeach *>(data);
+    (*slot)(*wrap(node));
   }
+ 
 
-  /// Wrapper for invoking a ForeachFunc.
-  static void wrap_foreach_slot(GNode* node, gpointer slot)
-  {
-    ForeachFunc ff = reinterpret_cast<ForeachFunc>(slot);
-    if(ff)
-      (*ff)(*(reinterpret_cast<T*>(node->data)));
-  }
-
   /// Method for comparing a single child (Internal use).
   static void on_compare_child(GNode* node, const T& needle, GNode* result)
   {
-    if((0 != result) && ((*(reinterpret_cast<T*>(node->data))) == needle))
+    if((0 != result) && (wrap(node)->data() == needle))
     {
       result = node;
     }
@@ -612,38 +546,30 @@
   /// Wrapper for invoking a sigc::slot<void,GNode*> (Internal use).
   static void on_wrap_compare_child(GNode* node, gpointer data)
   {
-    type_foreach_gnode_slot* slot = reinterpret_cast<type_foreach_gnode_slot*>(data);
-    (*slot)(node);
+    const SlotForeach *slot = reinterpret_cast<const SlotForeach *>(data);
+    (*slot)(*wrap(node));
   }
 
   /// Method for comparing a single node (Internal use).
-  static gboolean on_compare_node(GNode* node, const T& needle, GNode** result)
+  static gboolean find_func(GNode* node, const T& needle, GNode** result)
   {
-    if((*(reinterpret_cast<T*>(node->data))) == needle)
+    if(wrap(node)->data() == needle)
     {
       *result = node;
       return TRUE;
     }
-
     return FALSE;
   }
 
   /// Wrapper for invoking a sigc::slot<gboolean,GNode*> (Internal use).
-  static gboolean on_wrap_compare_node(GNode* node, gpointer data)
+  static gboolean on_wrap_find_func(GNode* node, gpointer data)
   {
-    type_traverse_gnode_slot* slot = reinterpret_cast<type_traverse_gnode_slot*>(data);
-    return (*slot)(node);
+    const SlotTraverse *slot = reinterpret_cast<const SlotTraverse *>(data);
+    return (*slot)(*wrap(node));
   }
+};
 
-  typedef sigc::slot<gboolean, GNode*> type_traverse_gnode_slot;
-  typedef sigc::slot<void, GNode*> type_foreach_gnode_slot;
+} // namespace Glib
 
-  GNode* gobject_;
-  bool owns_gobject_;
 
-  // Some metadata must be stored.
-  NodeMap children_;
-  Tree<T>* parent_;
-};
 
-} // namespace Glib
