wxPython-zombie 3.1.5.8__cp313-cp313-win_amd64.whl

wx/lib/mixins/treemixin.py

@@ -0,0 +1,678 @@
+#---------------------------------------------------------------------------
+# Name:        treemixin.py
+# Purpose:     This module provides three mixin classes that can be used with tree
+#              controls
+#
+# Author:
+#
+# Created:
+# RCS-ID:
+# Date:        24 September 2007
+# Copyright:
+# Version:     1.1
+# Licence:     wxWidgets license
+# Tags:        phoenix-port
+#---------------------------------------------------------------------------
+"""
+treemixin.py
+
+This module provides three mixin classes that can be used with tree
+controls:
+
+- VirtualTree is a class that, when mixed in with a tree control,
+  makes the tree control virtual, similar to a ListCtrl in virtual mode.
+  A virtual tree control builds the tree itself by means of callbacks,
+  so the programmer is freed from the burden of building the tree herself.
+
+- DragAndDrop is a mixin class that helps with dragging and dropping of
+  items. The graphical part of dragging and dropping tree items is done by
+  this mixin class. You only need to implement the OnDrop method that is
+  called when the drop happens.
+
+- ExpansionState is a mixin that can be queried for the expansion state of
+  all items in the tree to restore it later.
+
+All mixin classes work with wx.TreeCtrl, wx.gizmos.TreeListCtrl,
+and wx.lib.customtreectrl.CustomTreeCtrl. They can be used together or
+separately.
+
+The VirtualTree and DragAndDrop mixins force the wx.TR_HIDE_ROOT style.
+
+.. moduleauthor:: Frank Niessink <frank@niessink.com>
+
+License: wxWidgets license
+Version: 1.1
+Date: 24 September 2007
+
+ExpansionState is based on code and ideas from Karsten Hilbert.
+Andrea Gavana provided help with the CustomTreeCtrl integration.
+"""
+
+
+import wx
+
+
+class TreeAPIHarmonizer(object):
+    """ This class attempts to hide the differences in API between the
+    different tree controls that are part of wxPython. """
+
+    def __callSuper(self, methodName, default, *args, **kwargs):
+        # If our super class has a method called methodName, call it,
+        # otherwise return the default value.
+        superClass = super(TreeAPIHarmonizer, self)
+        if hasattr(superClass, methodName):
+            return getattr(superClass, methodName)(*args, **kwargs)
+        else:
+            return default
+
+    def GetColumnCount(self, *args, **kwargs):
+        # Only TreeListCtrl has columns, return 0 if we are mixed in
+        # with another tree control.
+        return self.__callSuper('GetColumnCount', 0, *args, **kwargs)
+
+    def GetItemType(self, *args, **kwargs):
+        # Only CustomTreeCtrl has different item types, return the
+        # default item type if we are mixed in with another tree control.
+        return self.__callSuper('GetItemType', 0, *args, **kwargs)
+
+    def SetItemType(self, item, newType):
+        # CustomTreeCtrl doesn't support changing the item type on the fly,
+        # so we create a new item and delete the old one. We currently only
+        # keep the item text, would be nicer to also retain other attributes.
+        text = self.GetItemText(item)
+        newItem = self.InsertItem(self.GetItemParent(item), item, text,
+                                  ct_type=newType)
+        self.Delete(item)
+        return newItem
+
+    def IsItemChecked(self, *args, **kwargs):
+        # Only CustomTreeCtrl supports checkable items, return False if
+        # we are mixed in with another tree control.
+        return self.__callSuper('IsItemChecked', False, *args, **kwargs)
+
+    def GetItemChecked(self, *args, **kwargs):
+        # For consistency's sake, provide a 'Get' and 'Set' method for
+        # checkable items.
+        return self.IsItemChecked(*args, **kwargs)
+
+    def SetItemChecked(self, *args, **kwargs):
+        # For consistency's sake, provide a 'Get' and 'Set' method for
+        # checkable items.
+        return self.CheckItem(*args, **kwargs)
+
+    def GetMainWindow(self, *args, **kwargs):
+        # Only TreeListCtrl has a separate main window, return self if we are
+        # mixed in with another tree control.
+        return self.__callSuper('GetMainWindow', self, *args, **kwargs)
+
+    def GetItemImage(self, item, which=wx.TreeItemIcon_Normal, column=-1):
+        # CustomTreeCtrl always wants the which argument, so provide it
+        # TreeListCtr.GetItemImage has a different order of arguments than
+        # the other tree controls. Hide the differenes.
+        if self.GetColumnCount():
+            args = (item, column, which)
+        else:
+            args = (item, which)
+        return super(TreeAPIHarmonizer, self).GetItemImage(*args)
+
+    def SetItemImage(self, item, imageIndex, which=wx.TreeItemIcon_Normal,
+                     column=-1):
+        # The SetItemImage signature is different for TreeListCtrl and
+        # other tree controls. This adapter method hides the differences.
+        if self.GetColumnCount():
+            args = (item, imageIndex, column, which)
+        else:
+            args = (item, imageIndex, which)
+        super(TreeAPIHarmonizer, self).SetItemImage(*args)
+
+    def UnselectAll(self):
+        # Unselect all items, regardless of whether we are in multiple
+        # selection mode or not.
+        if self.HasFlag(wx.TR_MULTIPLE) or (hasattr(self, 'HasAGWFlag') and self.HasAGWFlag(wx.TR_MULTIPLE)):
+            super(TreeAPIHarmonizer, self).UnselectAll()
+        else:
+            # CustomTreeCtrl Unselect() doesn't seem to work in all cases,
+            # also invoke UnselectAll just to be sure.
+            self.Unselect()
+            super(TreeAPIHarmonizer, self).UnselectAll()
+
+    def GetCount(self):
+        # TreeListCtrl correctly ignores the root item when it is hidden,
+        # but doesn't count the root item when it is visible
+        itemCount = super(TreeAPIHarmonizer, self).GetCount()
+        has_flag =  self.HasFlag(wx.TR_HIDE_ROOT) or (hasattr(self, 'HasAGWFlag') and self.HasAGWFlag(wx.TR_HIDE_ROOT))
+        if self.GetColumnCount() and not has_flag:
+            itemCount += 1
+        return itemCount
+
+    def GetSelections(self):
+        # Always return a list of selected items, regardless of whether
+        # we are in multiple selection mode or not.
+        if self.HasFlag(wx.TR_MULTIPLE) or (hasattr(self, 'HasAGWFlag') and self.HasAGWFlag(wx.TR_MULTIPLE)):
+            selections = super(TreeAPIHarmonizer, self).GetSelections()
+        else:
+            selection = self.GetSelection()
+            if selection:
+                selections = [selection]
+            else:
+                selections = []
+        # If the root item is hidden, it should never be selected,
+        # unfortunately, CustomTreeCtrl allows it to be selected.
+        if self.HasFlag(wx.TR_HIDE_ROOT) or (hasattr(self, 'HasAGWFlag') and self.HasAGWFlag(wx.TR_HIDE_ROOT)):
+            rootItem = self.GetRootItem()
+            if rootItem and rootItem in selections:
+                selections.remove(rootItem)
+        return selections
+
+    def GetFirstVisibleItem(self):
+        # TreeListCtrl raises an exception or even crashes when invoking
+        # GetFirstVisibleItem on an empty tree.
+        if self.GetRootItem():
+            return super(TreeAPIHarmonizer, self).GetFirstVisibleItem()
+        else:
+            return wx.TreeItemId()
+
+    def SelectItem(self, item, *args, **kwargs):
+        # Prevent the hidden root from being selected, otherwise TreeCtrl
+        # crashes
+        has_flag = self.HasFlag(wx.TR_HIDE_ROOT) or (hasattr(self, 'HasAGWFlag') and self.HasAGWFlag(wx.TR_HIDE_ROOT))
+        if has_flag and item == self.GetRootItem():
+            return
+        else:
+            return super(TreeAPIHarmonizer, self).SelectItem(item, *args,
+                                                             **kwargs)
+
+    def HitTest(self, *args, **kwargs):
+        """ HitTest returns a two-tuple (item, flags) for tree controls
+        without columns and a three-tuple (item, flags, column) for tree
+        controls with columns. Our caller can indicate this method to
+        always return a three-tuple no matter what tree control we're mixed
+        in with by specifying the optional argument 'alwaysReturnColumn'
+        to be True. """
+        alwaysReturnColumn = kwargs.pop('alwaysReturnColumn', False)
+        hitTestResult = super(TreeAPIHarmonizer, self).HitTest(*args, **kwargs)
+        if len(hitTestResult) == 2 and alwaysReturnColumn:
+            hitTestResult += (0,)
+        return hitTestResult
+
+    def ExpandAll(self, item=None):
+        # TreeListCtrl wants an item as argument. That's an inconsistency with
+        # the TreeCtrl API. Also, TreeCtrl doesn't allow invoking ExpandAll
+        # on a tree with hidden root node, so prevent that.
+        if self.HasFlag(wx.TR_HIDE_ROOT) or (hasattr(self, 'HasAGWFlag') and self.HasAGWFlag(wx.TR_HIDE_ROOT)):
+            rootItem = self.GetRootItem()
+            if rootItem:
+                child, cookie = self.GetFirstChild(rootItem)
+                while child:
+                    self.ExpandAllChildren(child)
+                    child, cookie = self.GetNextChild(rootItem, cookie)
+        else:
+            try:
+                super(TreeAPIHarmonizer, self).ExpandAll()
+            except TypeError:
+                if item is None:
+                    item = self.GetRootItem()
+                super(TreeAPIHarmonizer, self).ExpandAll(item)
+
+    def ExpandAllChildren(self, item):
+        # TreeListCtrl and CustomTreeCtrl don't have ExpandallChildren
+        try:
+            super(TreeAPIHarmonizer, self).ExpandAllChildren(item)
+        except AttributeError:
+            self.Expand(item)
+            child, cookie = self.GetFirstChild(item)
+            while child:
+                self.ExpandAllChildren(child)
+                child, cookie = self.GetNextChild(item, cookie)
+
+
+class TreeHelper(object):
+    """ This class provides methods that are not part of the API of any
+    tree control, but are convenient to have available. """
+
+    def GetItemChildren(self, item=None, recursively=False):
+        """ Return the children of item as a list. """
+        if not item:
+            item = self.GetRootItem()
+            if not item:
+                return []
+        children = []
+        child, cookie = self.GetFirstChild(item)
+        while child:
+            children.append(child)
+            if recursively:
+                children.extend(self.GetItemChildren(child, True))
+            child, cookie = self.GetNextChild(item, cookie)
+        return children
+
+    def GetIndexOfItem(self, item):
+        """ Return the index of item. """
+        parent = self.GetItemParent(item)
+        if parent:
+            parentIndices = self.GetIndexOfItem(parent)
+            ownIndex = self.GetItemChildren(parent).index(item)
+            return parentIndices + (ownIndex,)
+        else:
+            return ()
+
+    def GetItemByIndex(self, index):
+        """ Return the item specified by index. """
+        item = self.GetRootItem()
+        for i in index:
+            children = self.GetItemChildren(item)
+            item = children[i]
+        return item
+
+
+class VirtualTree(TreeAPIHarmonizer, TreeHelper):
+    """ This is a mixin class that can be used to allow for virtual tree
+    controls. It can be mixed in with wx.TreeCtrl, wx.gizmos.TreeListCtrl,
+    wx.lib.customtree.CustomTreeCtrl.
+
+    To use it derive a new class from this class and one of the tree
+    controls, e.g.::
+
+      class MyTree(VirtualTree, wx.TreeCtrl):
+          # Other code here
+
+
+    VirtualTree uses several callbacks (such as OnGetItemText) to
+    retrieve information needed to construct the tree and render the
+    items. To specify what item the callback needs information about,
+    the callback passes an item index. Whereas for list controls a simple
+    integer index can be used, for tree controls indicating a specific
+    item is a little bit more complicated. See below for a more detailed
+    explanation of the how index works.
+
+    Note that VirtualTree forces the wx.TR_HIDE_ROOT style.
+
+    In your subclass you *must* override OnGetItemText and
+    OnGetChildrenCount. These two methods are the minimum needed to
+    construct the tree and render the item labels. If you want to add
+    images, change fonts our colours, etc., you need to override the
+    appropriate OnGetXXX method as well.
+
+    About indices: your callbacks are passed a tuple of integers that
+    identifies the item the VirtualTree wants information about. An
+    empty tuple, i.e. (), represents the hidden root item.  A tuple with
+    one integer, e.g. (3,), represents a visible root item, in this case
+    the fourth one. A tuple with two integers, e.g. (3,0), represents a
+    child of a visible root item, in this case the first child of the
+    fourth root item.
+    """
+
+    def __init__(self, *args, **kwargs):
+        kwargs['style'] = kwargs.get('style', wx.TR_DEFAULT_STYLE) | \
+                          wx.TR_HIDE_ROOT
+        super(VirtualTree, self).__init__(*args, **kwargs)
+        self.Bind(wx.EVT_TREE_ITEM_EXPANDING, self.OnItemExpanding)
+        self.Bind(wx.EVT_TREE_ITEM_COLLAPSED, self.OnItemCollapsed)
+
+    def OnGetChildrenCount(self, index):
+        """ This function *must* be overloaded in the derived class.
+        It should return the number of child items of the item with the
+        provided index. If index == () it should return the number of
+        root items. """
+        raise NotImplementedError
+
+    def OnGetItemText(self, index, column=0):
+        """ This function *must* be overloaded in the derived class. It
+        should return the string containing the text of the specified
+        item. """
+        raise NotImplementedError
+
+    def OnGetItemFont(self, index):
+        """ This function may be overloaded in the derived class. It
+        should return the wx.Font to be used for the specified item. """
+        return wx.NullFont
+
+    def OnGetItemTextColour(self, index):
+        """ This function may be overloaded in the derived class. It
+        should return the wx.Colour to be used as text colour for the
+        specified item. """
+        return wx.NullColour
+
+    def OnGetItemBackgroundColour(self, index):
+        """ This function may be overloaded in the derived class. It
+        should return the wx.Colour to be used as background colour for
+        the specified item. """
+        return wx.NullColour
+
+    def OnGetItemImage(self, index, which=wx.TreeItemIcon_Normal, column=0):
+        """ This function may be overloaded in the derived class. It
+        should return the index of the image to be used. Don't forget
+        to associate an ImageList with the tree control. """
+        return -1
+
+    def OnGetItemType(self, index):
+        """ This function may be overloaded in the derived class, but
+        that only makes sense when this class is mixed in with a tree
+        control that supports checkable items, i.e. CustomTreeCtrl.
+        This method should return whether the item is to be normal (0,
+        the default), a checkbox (1) or a radiobutton (2).
+        Note that OnGetItemChecked needs to be implemented as well; it
+        should return whether the item is actually checked. """
+        return 0
+
+    def OnGetItemChecked(self, index):
+        """ This function may be overloaded in the derived class, but
+        that only makes sense when this class is mixed in with a tree
+        control that supports checkable items, i.e. CustomTreeCtrl.
+        This method should return whether the item is to be checked.
+        Note that OnGetItemType should return 1 (checkbox) or 2
+        (radiobutton) for this item. """
+        return False
+
+    def RefreshItems(self):
+        """ Redraws all visible items. """
+        rootItem = self.GetRootItem()
+        if not rootItem:
+            rootItem = self.AddRoot('Hidden root')
+        self.RefreshChildrenRecursively(rootItem)
+
+    def RefreshItem(self, index):
+        """ Redraws the item with the specified index. """
+        try:
+            item = self.GetItemByIndex(index)
+        except IndexError:
+            # There's no corresponding item for index, because its parent
+            # has not been expanded yet.
+            return
+        hasChildren = bool(self.OnGetChildrenCount(index))
+        self.DoRefreshItem(item, index, hasChildren)
+
+    def RefreshChildrenRecursively(self, item, itemIndex=None):
+        """ Refresh the children of item, reusing as much of the
+        existing items in the tree as possible. """
+        if itemIndex is None:
+            itemIndex = self.GetIndexOfItem(item)
+        reusableChildren = self.GetItemChildren(item)
+        for childIndex in self.ChildIndices(itemIndex):
+            if reusableChildren:
+                child = reusableChildren.pop(0)
+            else:
+                child = self.AppendItem(item, '')
+            self.RefreshItemRecursively(child, childIndex)
+        for child in reusableChildren:
+            self.Delete(child)
+
+    def RefreshItemRecursively(self, item, itemIndex):
+        """ Refresh the item and its children recursively. """
+        hasChildren = bool(self.OnGetChildrenCount(itemIndex))
+        item = self.DoRefreshItem(item, itemIndex, hasChildren)
+        # We need to refresh the children when the item is expanded and
+        # when the item has no children, because in the latter case we
+        # might have to delete old children from the tree:
+        if self.IsExpanded(item) or not hasChildren:
+            self.RefreshChildrenRecursively(item, itemIndex)
+        self.SetItemHasChildren(item, hasChildren)
+
+    def DoRefreshItem(self, item, index, hasChildren):
+        """ Refresh one item. """
+        item = self.RefreshItemType(item, index)
+        self.RefreshItemText(item, index)
+        self.RefreshColumns(item, index)
+        self.RefreshItemFont(item, index)
+        self.RefreshTextColour(item, index)
+        self.RefreshBackgroundColour(item, index)
+        self.RefreshItemImage(item, index, hasChildren)
+        self.RefreshCheckedState(item, index)
+        return item
+
+    def RefreshItemText(self, item, index):
+        self.__refreshAttribute(item, index, 'ItemText')
+
+    def RefreshColumns(self, item, index):
+        for columnIndex in range(1, self.GetColumnCount()):
+            self.__refreshAttribute(item, index, 'ItemText', columnIndex)
+
+    def RefreshItemFont(self, item, index):
+        self.__refreshAttribute(item, index, 'ItemFont')
+
+    def RefreshTextColour(self, item, index):
+        self.__refreshAttribute(item, index, 'ItemTextColour')
+
+    def RefreshBackgroundColour(self, item, index):
+        self.__refreshAttribute(item, index, 'ItemBackgroundColour')
+
+    def RefreshItemImage(self, item, index, hasChildren):
+        regularIcons = [wx.TreeItemIcon_Normal, wx.TreeItemIcon_Selected]
+        expandedIcons = [wx.TreeItemIcon_Expanded,
+                         wx.TreeItemIcon_SelectedExpanded]
+        # Refresh images in first column:
+        for icon in regularIcons:
+            self.__refreshAttribute(item, index, 'ItemImage', icon)
+        for icon in expandedIcons:
+            if hasChildren:
+                imageIndex = self.OnGetItemImage(index, icon)
+            else:
+                imageIndex = -1
+            if self.GetItemImage(item, icon) != imageIndex or imageIndex == -1:
+                self.SetItemImage(item, imageIndex, icon)
+        # Refresh images in remaining columns, if any:
+        for columnIndex in range(1, self.GetColumnCount()):
+            for icon in regularIcons:
+                self.__refreshAttribute(item, index, 'ItemImage', icon,
+                                        columnIndex)
+
+    def RefreshItemType(self, item, index):
+        return self.__refreshAttribute(item, index, 'ItemType')
+
+    def RefreshCheckedState(self, item, index):
+        self.__refreshAttribute(item, index, 'ItemChecked')
+
+    def ChildIndices(self, itemIndex):
+        childrenCount = self.OnGetChildrenCount(itemIndex)
+        return [itemIndex + (childNumber,) for childNumber \
+                in range(childrenCount)]
+
+    def OnItemExpanding(self, event):
+        self.RefreshChildrenRecursively(event.GetItem())
+        event.Skip()
+
+    def OnItemCollapsed(self, event):
+        parent = self.GetItemParent(event.GetItem())
+        if not parent:
+            parent = self.GetRootItem()
+        self.RefreshChildrenRecursively(parent)
+        event.Skip()
+
+    def __refreshAttribute(self, item, index, attribute, *args):
+        """ Refresh the specified attribute if necessary. """
+        value = getattr(self, 'OnGet%s'%attribute)(index, *args)
+        if getattr(self, 'Get%s'%attribute)(item, *args) != value:
+            return getattr(self, 'Set%s'%attribute)(item, value, *args)
+        else:
+            return item
+
+
+class DragAndDrop(TreeAPIHarmonizer, TreeHelper):
+    """ This is a mixin class that can be used to easily implement
+    dragging and dropping of tree items. It can be mixed in with
+    wx.TreeCtrl, wx.gizmos.TreeListCtrl, or wx.lib.customtree.CustomTreeCtrl.
+
+    To use it derive a new class from this class and one of the tree
+    controls, e.g.::
+
+      class MyTree(DragAndDrop, wx.TreeCtrl):
+          # Other code here
+
+
+    You *must* implement OnDrop. OnDrop is called when the user has
+    dropped an item on top of another item. It's up to you to decide how
+    to handle the drop. If you are using this mixin together with the
+    VirtualTree mixin, it makes sense to rearrange your underlying data
+    and then call RefreshItems to let the virtual tree refresh itself. """
+
+    def __init__(self, *args, **kwargs):
+        kwargs['style'] = kwargs.get('style', wx.TR_DEFAULT_STYLE) | \
+                          wx.TR_HIDE_ROOT
+        super(DragAndDrop, self).__init__(*args, **kwargs)
+        self.Bind(wx.EVT_TREE_BEGIN_DRAG, self.OnBeginDrag)
+
+    def OnDrop(self, dropItem, dragItem):
+        """ This function must be overloaded in the derived class.
+        dragItem is the item being dragged by the user. dropItem is the
+        item dragItem is dropped upon. If the user doesn't drop dragItem
+        on another item, dropItem equals the (hidden) root item of the
+        tree control. """
+        raise NotImplementedError
+
+    def OnBeginDrag(self, event):
+        # We allow only one item to be dragged at a time, to keep it simple
+        self._dragItem = event.GetItem()
+        if self.IsValidDragItem(self._dragItem):
+            self.StartDragging()
+            event.Allow()
+        else:
+            event.Veto()
+
+    def OnEndDrag(self, event):
+        self.StopDragging()
+        dropTarget = event.GetItem()
+        if not dropTarget:
+            dropTarget = self.GetRootItem()
+        if self.IsValidDropTarget(dropTarget):
+            self.UnselectAll()
+            if dropTarget != self.GetRootItem():
+                self.SelectItem(dropTarget)
+            self.OnDrop(dropTarget, self._dragItem)
+
+    def OnDragging(self, event):
+        if not event.Dragging():
+            self.StopDragging()
+            return
+        item, flags, column = self.HitTest(wx.Point(event.GetX(), event.GetY()),
+                                           alwaysReturnColumn=True)
+        if not item:
+            item = self.GetRootItem()
+        if self.IsValidDropTarget(item):
+            self.SetCursorToDragging()
+        else:
+            self.SetCursorToDroppingImpossible()
+        if flags & wx.TREE_HITTEST_ONITEMBUTTON:
+            self.Expand(item)
+        if self.GetSelections() != [item]:
+            self.UnselectAll()
+            if item != self.GetRootItem():
+                self.SelectItem(item)
+        event.Skip()
+
+    def StartDragging(self):
+        self.GetMainWindow().Bind(wx.EVT_MOTION, self.OnDragging)
+        self.Bind(wx.EVT_TREE_END_DRAG, self.OnEndDrag)
+        self.SetCursorToDragging()
+
+    def StopDragging(self):
+        self.GetMainWindow().Unbind(wx.EVT_MOTION)
+        self.Unbind(wx.EVT_TREE_END_DRAG)
+        self.ResetCursor()
+        self.UnselectAll()
+        self.SelectItem(self._dragItem)
+
+    def SetCursorToDragging(self):
+        self.GetMainWindow().SetCursor(wx.Cursor(wx.CURSOR_HAND))
+
+    def SetCursorToDroppingImpossible(self):
+        self.GetMainWindow().SetCursor(wx.Cursor(wx.CURSOR_NO_ENTRY))
+
+    def ResetCursor(self):
+        self.GetMainWindow().SetCursor(wx.NullCursor)
+
+    def IsValidDropTarget(self, dropTarget):
+        if dropTarget:
+            allChildren = self.GetItemChildren(self._dragItem, recursively=True)
+            parent = self.GetItemParent(self._dragItem)
+            return dropTarget not in [self._dragItem, parent] + allChildren
+        else:
+            return True
+
+    def IsValidDragItem(self, dragItem):
+        return dragItem and dragItem != self.GetRootItem()
+
+
+class ExpansionState(TreeAPIHarmonizer, TreeHelper):
+    """ This is a mixin class that can be used to save and restore
+    the expansion state (i.e. which items are expanded and which items
+    are collapsed) of a tree. It can be mixed in with wx.TreeCtrl,
+    wx.gizmos.TreeListCtrl, or wx.lib.customtree.CustomTreeCtrl.
+
+    To use it derive a new class from this class and one of the tree
+    controls, e.g.::
+
+      class MyTree(ExpansionState, wx.TreeCtrl):
+          # Other code here
+
+
+    By default, ExpansionState uses the position of tree items in the tree
+    to keep track of which items are expanded. This should be sufficient
+    for the simple scenario where you save the expansion state of the tree
+    when the user closes the application or file so that you can restore
+    the expansion state when the user start the application or loads that
+    file for the next session.
+
+    If you need to add or remove items between the moments of saving and
+    restoring the expansion state (e.g. in case of a multi-user application)
+    you must override GetItemIdentity so that saving and loading of the
+    expansion doesn't depend on the position of items in the tree, but
+    rather on some more stable characteristic of the underlying domain
+    object, e.g. a social security number in case of persons or an isbn
+    number in case of books. """
+
+    def GetItemIdentity(self, item):
+        """ Return a hashable object that represents the identity of the
+        item. By default this returns the position of the item in the
+        tree. You may want to override this to return the item label
+        (if you know that labels are unique and don't change), or return
+        something that represents the underlying domain object, e.g.
+        a database key. """
+        return self.GetIndexOfItem(item)
+
+    def GetExpansionState(self):
+        """ GetExpansionState() -> list of expanded items. Expanded items
+        are coded as determined by the result of GetItemIdentity(item). """
+        root = self.GetRootItem()
+        if not root:
+            return []
+        if self.HasFlag(wx.TR_HIDE_ROOT) or (hasattr(self, 'HasAGWFlag') and self.HasAGWFlag(wx.TR_HIDE_ROOT)):
+            return self.GetExpansionStateOfChildren(root)
+        else:
+            return self.GetExpansionStateOfItem(root)
+
+    def SetExpansionState(self, listOfExpandedItems):
+        """ SetExpansionState(listOfExpandedItems). Expands all tree items
+        whose identity, as determined by GetItemIdentity(item), is present
+        in the list and collapses all other tree items. """
+        root = self.GetRootItem()
+        if not root:
+            return
+        if self.HasFlag(wx.TR_HIDE_ROOT) or (hasattr(self, 'HasAGWFlag') and self.HasAGWFlag(wx.TR_HIDE_ROOT)):
+            self.SetExpansionStateOfChildren(listOfExpandedItems, root)
+        else:
+            self.SetExpansionStateOfItem(listOfExpandedItems, root)
+
+    ExpansionState = property(GetExpansionState, SetExpansionState)
+
+    def GetExpansionStateOfItem(self, item):
+        listOfExpandedItems = []
+        if self.IsExpanded(item):
+            listOfExpandedItems.append(self.GetItemIdentity(item))
+            listOfExpandedItems.extend(self.GetExpansionStateOfChildren(item))
+        return listOfExpandedItems
+
+    def GetExpansionStateOfChildren(self, item):
+        listOfExpandedItems = []
+        for child in self.GetItemChildren(item):
+            listOfExpandedItems.extend(self.GetExpansionStateOfItem(child))
+        return listOfExpandedItems
+
+    def SetExpansionStateOfItem(self, listOfExpandedItems, item):
+        if self.GetItemIdentity(item) in listOfExpandedItems:
+            self.Expand(item)
+            self.SetExpansionStateOfChildren(listOfExpandedItems, item)
+        else:
+            self.Collapse(item)
+
+    def SetExpansionStateOfChildren(self, listOfExpandedItems, item):
+        for child in self.GetItemChildren(item):
+            self.SetExpansionStateOfItem(listOfExpandedItems, child)