tree.py

Go to the documentation of this file.

import  string
import  wx
import  images

#---------------------------------------------------------------------------

class MyTreeCtrl(wx.TreeCtrl):
    def __init__(self, parent, id, pos, size, style):
    #    def __init__(self, parent, id, pos, size, style, log):
        wx.TreeCtrl.__init__(self, parent, id, pos, size, style)
#        self.log = log

    def OnCompareItems(self, item1, item2):
        t1 = self.GetItemText(item1)
        t2 = self.GetItemText(item2)
#        self.log.WriteText('compare: ' + t1 + ' <> ' + t2 + '\n')
        if t1 < t2: return -1
        if t1 == t2: return 0
        return 1

#---------------------------------------------------------------------------

class TreeCtrlPanel(wx.Panel):
    def __init__(self, parent):
        # Use the WANTS_CHARS style so the panel doesn't eat the Return key.
        wx.Panel.__init__(self, parent, -1, style=wx.WANTS_CHARS)
        self.Bind(wx.EVT_SIZE, self.OnSize)
        tID = wx.NewId()
        self.tree = MyTreeCtrl(self, tID, wx.DefaultPosition, wx.DefaultSize,
                               wx.TR_DEFAULT_STYLE
                               #wx.TR_HAS_BUTTONS
                               #| wx.TR_EDIT_LABELS
                               #| wx.TR_MULTIPLE
                               #| wx.TR_HIDE_ROOT
#                               , self.log
                               )
        isz = (16,16)
        il = wx.ImageList(isz[0], isz[1])
        self.fldridx     = il.Add(wx.ArtProvider_GetBitmap(wx.ART_FOLDER,      wx.ART_OTHER, isz))
        self.fldropenidx = il.Add(wx.ArtProvider_GetBitmap(wx.ART_FILE_OPEN,   wx.ART_OTHER, isz))
        self.fileidx     = il.Add(wx.ArtProvider_GetBitmap(wx.ART_NORMAL_FILE, wx.ART_OTHER, isz))
#        smileidx    = il.Add(images.getSmilesBitmap())

        self.tree.SetImageList(il)
        self.il = il

        # NOTE:  For some reason tree items have to have a data object in
        #        order to be sorted.  Since our compare just uses the labels
        #        we don't need any real data, so we'll just use None below for
        #        the item data.









#                    self.tree.SetItemImage(item, smileidx, wx.TreeItemIcon_Selected)

        self.Bind(wx.EVT_TREE_ITEM_EXPANDED, self.OnItemExpanded, self.tree)
        self.Bind(wx.EVT_TREE_ITEM_COLLAPSED, self.OnItemCollapsed, self.tree)
        self.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnSelChanged, self.tree)
        self.Bind(wx.EVT_TREE_BEGIN_LABEL_EDIT, self.OnBeginEdit, self.tree)
        self.Bind(wx.EVT_TREE_END_LABEL_EDIT, self.OnEndEdit, self.tree)
        self.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.OnActivate, self.tree)

        self.tree.Bind(wx.EVT_LEFT_DCLICK, self.OnLeftDClick)
        self.tree.Bind(wx.EVT_RIGHT_DOWN, self.OnRightDown)
        self.tree.Bind(wx.EVT_RIGHT_UP, self.OnRightUp)


    def GetItem(self):
        def getType():
            item=self.item
            while self.tree.GetItemParent(item)!=self.root:
                item=self.tree.GetItemParent(item)
            return str(self.tree.GetItemText(item))

        def getElement():
            item=self.item
            path=str(self.tree.GetItemText(item))
            while str(self.tree.GetItemText(self.tree.GetItemParent(item)))!='Elements':
                item=self.tree.GetItemParent(item)
                path=str(self.tree.GetItemText(item))+'/'+path
            path='/'+path
            return path

        def getProcessus():
            item=self.item
            return str(self.tree.GetItemText(item))

        objtype=getType()
        if (objtype=='Elements'):
            objtype='Element'
            obj=getElement()        
            return [obj,objtype]
        if (objtype=='Processus'):
            obj=getProcessus()
            return [obj,objtype]


    def OnRightDown(self, event):
        pt = event.GetPosition();
        item, flags = self.tree.HitTest(pt)
        if item:
#            self.log.WriteText("OnRightClick: %s, %s, %s\n" %
#                              (self.tree.GetItemText(item), type(item), item.__class__))
            self.tree.SelectItem(item)


    def OnRightUp(self, event):
        pt = event.GetPosition();
        item, flags = self.tree.HitTest(pt)
        if item:        
#            self.log.WriteText("OnRightUp: %s (manually starting label edit)\n"
#                               % self.tree.GetItemText(item))
            self.tree.EditLabel(item)



    def OnBeginEdit(self, event):
#        self.log.WriteText("OnBeginEdit\n")
        # show how to prevent edit...
        item = event.GetItem()
        if item and self.tree.GetItemText(item) == "The Root Item":
            wx.Bell()
#            self.log.WriteText("You can't edit this one...\n")

            # Lets just see what's visible of its children
            cookie = 0
            root = event.GetItem()
            (child, cookie) = self.tree.GetFirstChild(root)

            while child.IsOk():
#                self.log.WriteText("Child [%s] visible = %d" %
#                                   (self.tree.GetItemText(child),
#                                    self.tree.IsVisible(child)))
                (child, cookie) = self.tree.GetNextChild(root, cookie)

            event.Veto()


    def OnEndEdit(self, event):
#        self.log.WriteText("OnEndEdit: %s %s\n" %
#                           (event.IsEditCancelled(), event.GetLabel()) )
        # show how to reject edit, we'll not allow any digits
        for x in event.GetLabel():
            if x in string.digits:
#                self.log.WriteText("You can't enter digits...\n")
                event.Veto()
                return


    def OnLeftDClick(self, event):
        pt = event.GetPosition();
        item, flags = self.tree.HitTest(pt)
        if item:
#            self.log.WriteText("OnLeftDClick: %s\n" % self.tree.GetItemText(item))
            parent = self.tree.GetItemParent(item)
            if parent.IsOk():
                self.tree.SortChildren(parent)
        event.Skip()


    def OnSize(self, event):
        w,h = self.GetClientSizeTuple()
        self.tree.SetDimensions(0, 0, w, h)


    def OnExpand(self):
        self.tree.Expand(event.GetItem())

    def OnCollapse(self):
        self.tree.Collapse(event.GetItem())

    def OnItemExpanded(self, event):
        item = event.GetItem()
#        if item:
#            self.log.WriteText("OnItemCollapsed: %s\n" % self.tree.GetItemText(item))

    def OnItemCollapsed(self, event):
        item = event.GetItem()
#        if item:
#            self.log.WriteText("OnItemCollapsed: %s\n" % self.tree.GetItemText(item))

    def OnSelChanged(self, event):
        self.item = event.GetItem()
#        print "onselchanged"
#        print self.tree.GetItemText(self.item), type(self.item), self.item.__class__
#        if self.item:
#            self.log.WriteText("OnSelChanged: %s\n" % self.tree.GetItemText(self.item))
#            if wx.Platform == '__WXMSW__':
#                self.log.WriteText("BoundingRect: %s\n" %
#                                   self.tree.GetBoundingRect(self.item, True))
            #items = self.tree.GetSelections()
            #print map(self.tree.GetItemText, items)
        event.Skip()


    def OnActivate(self, event):
        if self.tree.IsExpanded(event.GetItem()):
            self.tree.Collapse(event.GetItem())
        else:
            self.tree.Expand(event.GetItem())


    def RecreateTree(self, myElements, myProcessus ):
        def makeHierarchy( parent, children, image):
#            print "call with ",self.tree.GetItemText(parent)," ",children 
            for child in range(len(children)):
                if type(children[child])==list:
#                    print "recurcive list found "
                    makeHierarchy(nChild,children[child],image)
                else:
#                    print "add item ", children[child], " at ", self.tree.GetItemText(parent)                    
                    nChild=self.tree.AppendItem(parent, children[child], image)
                    self.tree.SetItemPyData(nChild, image)
                    self.TreeItem.append(nChild)            

        _treeList = [
                     ('Elements',  myElements),
                     ('Processus', myProcessus),
                     ('Data',      []),
                     ('Documents', []),
                     ]

#        self.tree.Freeze()
        self.tree.DeleteAllItems()
        self.root = self.tree.AddRoot("Objects")

        self.tree.SetItemPyData(self.root, None)
        self.tree.SetItemImage(self.root, self.fldridx, wx.TreeItemIcon_Normal)
        self.tree.SetItemImage(self.root, self.fldropenidx, wx.TreeItemIcon_Expanded)

        treeFont = self.tree.GetFont()
        catFont = self.tree.GetFont()

        # The old native treectrl on MSW has a bug where it doesn't
        # draw all of the text for an item if the font is larger than
        # the default.  It seems to be clipping the item's label as if
        # it was the size of the same label in the default font.
        if 'wxMSW' not in wx.PlatformInfo or wx.GetApp().GetComCtl32Version() >= 600:
            treeFont.SetPointSize(treeFont.GetPointSize()+2)
            treeFont.SetWeight(wx.BOLD)
            catFont.SetWeight(wx.BOLD)

        self.tree.SetItemFont(self.root, treeFont)

        firstChild = None
        selectItem = None

        count = 0

        self.TreeItem=[self.root]

        for category, items in _treeList:
            count += 1
            child = self.tree.AppendItem(self.root, category, image=count)
#            self.tree.SetItemFont(child, catFont)
            self.tree.SetItemPyData(child, count)
            self.tree.SetItemImage(child, self.fldridx, wx.TreeItemIcon_Normal)
            self.tree.SetItemImage(child, self.fldropenidx, wx.TreeItemIcon_Expanded)
            
            if not firstChild: firstChild = child
            makeHierarchy(child, items, count)

        self.tree.Expand(self.root)
        self.item=self.root

    def SetTreeModified(self, modified):
        item = self.tree.GetSelection()
        if modified:
            image = len(_objectTypes)
        else:
            image = self.tree.GetItemPyData(item)
        self.tree.SetItemImage(item, image)

    def GetItemIdentity(self, item):
        return self.tree.GetPyData(item)
            
    def ExpandAll(self):
        self.tree.ExpandAll()

    def CollapseAll(self):
        self.tree.CollapseAll()