public TreePosition GetParent (TreePosition pos)
		{
			var node = (TreeStoreNode) pos;
			if (node.Parent == null)
				return null;

			return node.Parent;
		}

		IterPos GetIterPos (TreePosition pos)
		{
			IterPos tpos = (IterPos) pos;
			if (tpos != null && tpos.Version != version) {
				tpos.LastChildIndex = -1;
				tpos.ChildrenCount = -1;
			}
			return tpos;
		}

		public TreePosition GetChild (TreePosition pos, int index)
		{
			var node = (TreeStoreNode) pos;
			var list = GetListForNode (node);
			if (list.Count == 0 || index >= list.Count)
				return null;

			return list [index];
		}

 public TreePosition AddChild(TreePosition pos)
 {
     IterPos tpos = (IterPos)pos;
     Gtk.TreeIter it;
     if (pos == null)
         it = Tree.AppendNode ();
     else
         it = Tree.AppendNode (tpos.Iter);
     return new IterPos (it);
 }

 public TreePosition AddChild(TreePosition pos)
 {
     version++;
     IterPos tpos = GetIterPos (pos);
     Gtk.TreeIter it;
     if (pos == null)
         it = Tree.AppendNode ();
     else
         it = Tree.AppendNode (tpos.Iter);
     return new IterPos (version, it);
 }

        Gtk.TreeIter IterFromNode (TreePosition node)
		{
			GCHandle gch;
			if (!handleHash.TryGetValue (node, out gch)) {
				gch = GCHandle.Alloc (node);
				handleHash [node] = gch;
				nodeHash [gch] = node;
			}
			Gtk.TreeIter result = Gtk.TreeIter.Zero;
			result.UserData = (IntPtr)gch;
			return result;
		}

        public TreePosition AddChild(TreePosition pos)
        {
            version++;
            IterPos tpos = GetIterPos (pos);
            Gtk.TreeIter it;
            if (pos == null)
                it = Tree.AppendNode ();
            else
                it = Tree.AppendNode (tpos.Iter);

            var node = new IterPos (version, it);
            if (NodeInserted != null)
                NodeInserted (this, new TreeNodeEventArgs (node));
            return node;
        }

		void SaveChildren (List<NodeInfo> info, TreePosition it)
		{
			int num = tree.DataSource.GetChildrenCount (it);
			for (int n=0; n<num; n++) {
				var child = tree.DataSource.GetChild (it, n);
				object id = tree.DataSource.GetValue (child, idColumn);
				NodeInfo ni = new NodeInfo ();
				ni.Id = id;
				ni.Expanded = tree.IsRowExpanded (child);
				ni.Selected = tree.IsRowSelected (child);
				info.Add (ni);
				if (tree.DataSource.GetChildrenCount (child) > 0) {
					ni.ChildInfo = new List<NodeInfo> ();
					SaveChildren (ni.ChildInfo, child);
				}
			}
		}

		void Load (List<NodeInfo> info, TreePosition it)
		{
			bool oneSelected = false;
			var infoCopy = new List<NodeInfo> (info);
			Dictionary<NodeInfo,TreePosition> nodes = new Dictionary<NodeInfo, TreePosition> ();
			
			int num = tree.DataSource.GetChildrenCount (it);
			for (int n=0; n<num; n++) {
				var child = tree.DataSource.GetChild (it, n);
				object id = tree.DataSource.GetValue (child, idColumn);
				NodeInfo ni = ExtractNodeInfo (info, id);
				if (ni != null) {
					nodes [ni] = child;
					if (ni.Expanded)
						tree.ExpandRow (child, false);
					else
						tree.CollapseRow (child);
					
					if (ni.Selected) {
						oneSelected = true;
						tree.SelectRow (child);
					}
					else
						tree.UnselectRow (child);
					
					if (ni.ChildInfo != null)
						Load (ni.ChildInfo, child);
				}
			}
			
			// If this tree level had a selected node and this node has been deleted, then
			// try to select and adjacent node
			if (!oneSelected) {
				// 'info' contains the nodes that have not been inserted
				if (info.Any (n => n.Selected)) {
					NodeInfo an = FindAdjacentNode (infoCopy, nodes, info[0]);
					if (an != null) {
						it = nodes [an];
						tree.SelectRow (it);
					}
				}
			}
		}

        public int GetChildrenCount(TreePosition pos)
        {
            if (pos == null)
                return Tree.IterNChildren ();

            IterPos tpos = GetIterPos (pos);

            if (tpos.ChildrenCount != -1)
                return tpos.ChildrenCount;

            return tpos.ChildrenCount = Tree.IterNChildren (tpos.Iter);
        }

 public void SetValue(TreePosition pos, int column, object value)
 {
     IterPos tpos = GetIterPos (pos);
     SetValue (tpos.Iter, column, value);
     if (NodeChanged != null)
         NodeChanged (this, new TreeNodeEventArgs (pos));
 }

 public void CollapseRow(TreePosition pos)
 {
     Widget.CollapseRow (Widget.Model.GetPath (((IterPos)pos).Iter));
 }

 public void ScrollToRow(TreePosition pos)
 {
     Widget.ScrollToCell (Widget.Model.GetPath (((IterPos)pos).Iter), Widget.Columns[0], false, 0, 0);
 }

 public bool IsRowExpanded(TreePosition pos)
 {
     return Widget.GetRowExpanded (Widget.Model.GetPath (((IterPos)pos).Iter));
 }

 public void ExpandToRow(TreePosition pos)
 {
     Widget.ExpandToPath (Widget.Model.GetPath (((IterPos)pos).Iter));
 }

 public TreePosition AddWiget(TreePosition pos, string name, Type type, Widget widget)
 {
     var item = new ItemWidget (type) { Widget = widget };
     return store.AddNode (pos)
         .SetValue (nameCol, name)
     //.SetValue (iconCol, Icon)
         .SetValue (widgetCol, item)
         .CurrentPosition;
 }

        public TreePosition GetChild(TreePosition pos, int index)
        {
            IterPos tpos = GetIterPos (pos);
            if (tpos != null && tpos.LastChildIndex == index)
                return new IterPos (version, tpos.LastChildIter);
            if (index == 0) {
                if (tpos != null) {
                    Gtk.TreeIter it;
                    if (Tree.IterChildren (out it, tpos.Iter)) {
                        tpos.LastChildIter = it;
                        tpos.LastChildIndex = 0;
                        return new IterPos (version, it);
                    }
                } else {
                    Gtk.TreeIter it;
                    if (Tree.GetIterFirst (out it))
                        return new IterPos (version, it);
                }
                return null;
            }

            if (tpos == null) {
                Gtk.TreeIter it;
                if (Tree.IterNthChild (out it, index))
                    return new IterPos (version, it);
                else
                    return null;
            }

            if (tpos.LastChildIndex == -1 || tpos.LastChildIndex > index) {
                Gtk.TreeIter it;
                if (Tree.IterNthChild (out it, tpos.Iter, index)) {
                    tpos.LastChildIter = it;
                    tpos.LastChildIndex = index;
                    return new IterPos (version, it);
                } else
                    return null;
            }

            // tpos.LastChildIndex < index

            Gtk.TreeIter iter = tpos.LastChildIter;
            for (int n = tpos.LastChildIndex; n < index; n++) {
                if (!Tree.IterNext (ref iter))
                    return null;
            }
            tpos.LastChildIter = iter;
            tpos.LastChildIndex = index;
            return new IterPos (version, iter);
        }

 public TreePosition GetNext(TreePosition pos)
 {
     IterPos tpos = GetIterPos (pos);
     Gtk.TreeIter it = tpos.Iter;
     if (!Tree.IterNext (ref it))
         return null;
     return new IterPos (version, it);
 }

 public void ExpandRow(TreePosition pos, bool expandedChildren)
 {
     Widget.ExpandRow (Widget.Model.GetPath (((IterPos)pos).Iter), expandedChildren);
 }

 public TreePosition GetParent(TreePosition pos)
 {
     IterPos tpos = GetIterPos (pos);
     Gtk.TreeIter it;
     if (!Tree.IterParent (out it, tpos.Iter))
         return null;
     return new IterPos (version, it);
 }