tree.py

用python写的ide开发环境,巨强大,不过需要wxpython的支持

            ['button', 'Buttons',
             (ID_NEW.BUTTON, 'Button', 'Create button'),
             (ID_NEW.BITMAP_BUTTON, 'BitmapButton', 'Create bitmap button'),
             (ID_NEW.RADIO_BUTTON, 'RadioButton', 'Create radio button'),
             (ID_NEW.SPIN_BUTTON, 'SpinButton', 'Create spin button'),
             ],
            ['box', 'Boxes',
             (ID_NEW.STATIC_BOX, 'StaticBox', 'Create static box'),
             (ID_NEW.CHECK_BOX, 'CheckBox', 'Create check box'),
             (ID_NEW.RADIO_BOX, 'RadioBox', 'Create radio box'),
             (ID_NEW.COMBO_BOX, 'ComboBox', 'Create combo box'),
             (ID_NEW.LIST_BOX, 'ListBox', 'Create list box'),
             (ID_NEW.CHECK_LIST, 'CheckListBox', 'Create checklist box'),
             ],
            ]
        self.stdButtons = [
            (ID_NEW.OK_BUTTON, 'OK Button', 'Create standard button'),
            (ID_NEW.YES_BUTTON, 'YES Button', 'Create standard button'),
            (ID_NEW.SAVE_BUTTON, 'SAVE Button',  'Create standard button'),
            (ID_NEW.APPLY_BUTTON, 'APPLY Button',  'Create standard button'),
            (ID_NEW.NO_BUTTON, 'NO Button',  'Create standard button'),
            (ID_NEW.CANCEL_BUTTON, 'CANCEL Button',  'Create standard button'),
            (ID_NEW.HELP_BUTTON, 'HELP Button',  'Create standard button'),
            (ID_NEW.CONTEXT_HELP_BUTTON, 'CONTEXT HELP Button', 'Create standard button'),
            ]
        self.stdButtonIDs = {
            ID_NEW.OK_BUTTON: ('wxID_OK', '&Ok'),
            ID_NEW.YES_BUTTON: ('wxID_YES', '&Yes'),
            ID_NEW.SAVE_BUTTON: ('wxID_SAVE', '&Save'),
            ID_NEW.APPLY_BUTTON: ('wxID_APPLY', '&Apply'),
            ID_NEW.NO_BUTTON: ('wxID_NO', '&No'),
            ID_NEW.CANCEL_BUTTON: ('wxID_CANCEL', '&Cancel'),
            ID_NEW.HELP_BUTTON: ('wxID_HELP', '&Help'),
            ID_NEW.CONTEXT_HELP_BUTTON: ('wxID_CONTEXT_HELP', '&Help'),
            }
        self.custom = ['custom', 'User-defined controls']
        self.customMap = {}        
        
    def addCustom(self, klass):
        n = len(self.custom)-2
        self.custom.append((ID_NEW.CUSTOM + n, klass))
        self.customMap[ID_NEW.CUSTOM + n] = klass


################################################################################

# Set menu to list items.
# Each menu command is a tuple (id, label, help)
# submenus are lists [id, label, help, submenu]
# and separators are any other type. Shift is for making
# alternative sets of IDs. (+1000).
def SetMenu(m, list, shift=False):
    for l in list:
        if type(l) == types.TupleType:
            # Shift ID
            if shift:  l = (1000 + l[0],) + l[1:]
            apply(m.Append, l)
        elif type(l) == types.ListType:
            subMenu = wx.Menu()
            SetMenu(subMenu, l[2:], shift)
            m.AppendMenu(wx.NewId(), l[0], subMenu, l[1])
        else:                           # separator
            m.AppendSeparator()

################################################################################

class HighLightBox:
    colour = None
    def __init__(self, pos, size):
        colour = g.tree.COLOUR_HL
        if size.width == -1: size.width = 0
        if size.height == -1: size.height = 0
        w = g.testWin.panel
        l1 = wx.Window(w, -1, pos, wx.Size(size.width, 2))
        l1.SetBackgroundColour(colour)
        l2 = wx.Window(w, -1, pos, wx.Size(2, size.height))
        l2.SetBackgroundColour(colour)
        l3 = wx.Window(w, -1, wx.Point(pos.x + size.width - 2, pos.y), wx.Size(2, size.height))
        l3.SetBackgroundColour(colour)
        l4 = wx.Window(w, -1, wx.Point(pos.x, pos.y + size.height - 2), wx.Size(size.width, 2))
        l4.SetBackgroundColour(colour)
        self.lines = [l1, l2, l3, l4]
        if wx.Platform == '__WXMSW__':
            for l in self.lines:
                l.Bind(wx.EVT_PAINT, self.OnPaint)
        g.testWin.highLight = self
        self.size = size
    # Repainting is not always done for these windows on Windows
    def OnPaint(self, evt):
        w = evt.GetEventObject()
        dc = wx.PaintDC(w)
        w.ClearBackground()
        dc.Destroy()
    # Move highlight to a new position
    def Replace(self, pos, size):
        if size.width == -1: size.width = 0
        if size.height == -1: size.height = 0
        self.lines[0].SetDimensions(pos.x, pos.y, size.width, 2)
        self.lines[1].SetDimensions(pos.x, pos.y, 2, size.height)
        self.lines[2].SetDimensions(pos.x + size.width - 2, pos.y, 2, size.height)
        self.lines[3].SetDimensions(pos.x, pos.y + size.height - 2, size.width, 2)
        self.size = size
    def Remove(self):
        map(wx.Window.Destroy, self.lines)
        g.testWin.highLight = None
    def Refresh(self):
        map(wx.Window.Refresh, self.lines)

# Same for drop target
class HighLightDTBox(HighLightBox):
    colour = None
    def __init__(self, pos, size):
        colour = g.tree.COLOUR_DT
        if size.width == -1: size.width = 0
        if size.height == -1: size.height = 0
        w = g.testWin.panel
        l1 = wx.Window(w, -1, pos, wx.Size(size.width, 2))
        l1.SetBackgroundColour(colour)
        l2 = wx.Window(w, -1, pos, wx.Size(2, size.height))
        l2.SetBackgroundColour(colour)
        l3 = wx.Window(w, -1, wx.Point(pos.x + size.width - 2, pos.y), wx.Size(2, size.height))
        l3.SetBackgroundColour(colour)
        l4 = wx.Window(w, -1, wx.Point(pos.x, pos.y + size.height - 2), wx.Size(size.width, 2))
        l4.SetBackgroundColour(colour)
        self.lines = [l1, l2, l3, l4]
        self.item = None
        self.size = size
    # Remove it
    def Remove(self):
        map(wx.Window.Destroy, self.lines)
        g.testWin.highLightDT = None

def updateHL(hl, hlClass, pos, size):
    # Need to recreate window if size did not change to force update
    if hl and hl.size == size:
        hl.Remove()
        hl = None
    if hl:
        hl.Replace(pos, size)
    else:
        hl = hlClass(pos, size)
    hl.Refresh()
    return hl

################################################################################

class XML_Tree(wx.TreeCtrl):
    def __init__(self, parent, id):
        # Item colour
        self.COLOUR_COMMENT  = wx.Colour(0, 0, 255)
        self.COLOUR_REF      = wx.Colour(0, 0, 128)
        self.COLOUR_HIDDEN   = wx.Colour(128, 128, 128)
        self.COLOUR_HL       = wx.Colour(255, 0, 0)
        self.COLOUR_DT       = wx.Colour(0, 64, 0)

        wx.TreeCtrl.__init__(self, parent, id,
                             style = wx.TR_HAS_BUTTONS | wx.TR_MULTIPLE | wx.TR_EDIT_LABELS)
        self.SetBackgroundColour(wx.Colour(224, 248, 224))
        self.fontComment = wx.FFont(self.GetFont().GetPointSize(),
                                    self.GetFont().GetFamily(),
                                    wx.FONTFLAG_ITALIC)
        # Register events
        wx.EVT_TREE_SEL_CHANGED(self, self.GetId(), self.OnSelChanged)
        # One works on Linux, another on Windows
        if wx.Platform == '__WXGTK__': # !!! MAC too?
            wx.EVT_TREE_ITEM_ACTIVATED(self, self.GetId(), self.OnItemActivated)
        else:
            wx.EVT_LEFT_DCLICK(self, self.OnDClick)
        wx.EVT_RIGHT_DOWN(self, self.OnRightDown)
        wx.EVT_TREE_ITEM_EXPANDED(self, self.GetId(), self.OnItemExpandedCollapsed)
        wx.EVT_TREE_ITEM_COLLAPSED(self, self.GetId(), self.OnItemExpandedCollapsed)
        self.Bind(wx.EVT_TREE_BEGIN_LABEL_EDIT, self.OnBeginLabelEdit)
        self.Bind(wx.EVT_TREE_END_LABEL_EDIT, self.OnEndLabelEdit)

        self.selection = None
        self.selectionChanging = False
        self.needUpdate = False
        self.pendingHighLight = None
        self.ctrl = self.shift = False
        self.dom = None
        # Create image list
        il = wx.ImageList(16, 16, True)
        self.rootImage = il.Add(images.getTreeRootImage().Scale(16,16).ConvertToBitmap())
        xxxComment.image = il.Add(images.getTreeCommentImage().Scale(16,16).ConvertToBitmap())
        xxxObject.image = il.Add(images.getTreeDefaultImage().Scale(16,16).ConvertToBitmap())
        xxxPanel.image = il.Add(images.getTreePanelImage().Scale(16,16).ConvertToBitmap())
        xxxDialog.image = il.Add(images.getTreeDialogImage().Scale(16,16).ConvertToBitmap())
        xxxFrame.image = il.Add(images.getTreeFrameImage().Scale(16,16).ConvertToBitmap())
        xxxMenuBar.image = il.Add(images.getTreeMenuBarImage().Scale(16,16).ConvertToBitmap())
        xxxMenu.image = il.Add(images.getTreeMenuImage().Scale(16,16).ConvertToBitmap())
        xxxMenuItem.image = il.Add(images.getTreeMenuItemImage().Scale(16,16).ConvertToBitmap())
        xxxToolBar.image = il.Add(images.getTreeToolBarImage().Scale(16,16).ConvertToBitmap())
        xxxTool.image = il.Add(images.getTreeToolImage().Scale(16,16).ConvertToBitmap())
        xxxSeparator.image = il.Add(images.getTreeSeparatorImage().Scale(16,16).ConvertToBitmap())
        xxxSizer.imageH = il.Add(images.getTreeSizerHImage().Scale(16,16).ConvertToBitmap())
        xxxSizer.imageV = il.Add(images.getTreeSizerVImage().Scale(16,16).ConvertToBitmap())
        xxxStaticBoxSizer.imageH = il.Add(images.getTreeStaticBoxSizerHImage().Scale(16,16).ConvertToBitmap())
        xxxStaticBoxSizer.imageV = il.Add(images.getTreeStaticBoxSizerVImage().Scale(16,16).ConvertToBitmap())
        xxxGridSizer.image = il.Add(images.getTreeSizerGridImage().Scale(16,16).ConvertToBitmap())
        xxxFlexGridSizer.image = il.Add(images.getTreeSizerFlexGridImage().Scale(16,16).ConvertToBitmap())
        self.il = il
        self.SetImageList(il)

    def RegisterKeyEvents(self):
        wx.EVT_KEY_DOWN(self, g.tools.OnKeyDown)
        wx.EVT_KEY_UP(self, g.tools.OnKeyUp)
        wx.EVT_ENTER_WINDOW(self, g.tools.OnMouse)
        wx.EVT_LEAVE_WINDOW(self, g.tools.OnMouse)

    def ExpandAll(self, item):
        if self.ItemHasChildren(item):
            self.Expand(item)
            i, cookie = self.GetFirstChild(item)
            children = []
            while i.IsOk():
                children.append(i)
                i, cookie = self.GetNextChild(item, cookie)
            for i in children:
                self.ExpandAll(i)
    def CollapseAll(self, item):
        if self.ItemHasChildren(item):
            i, cookie = self.GetFirstChild(item)
            children = []
            while i.IsOk():
                children.append(i)
                i, cookie = self.GetNextChild(item, cookie)
            for i in children:
                self.CollapseAll(i)
            self.Collapse(item)

    # Clear tree
    def Clear(self):
        self.UnselectAll()
        self.DeleteAllItems()
        # Add minimal structure
        if self.dom: self.dom.unlink()
        self.dom = MyDocument()
        self.dummyNode = self.dom.createComment('dummy node')
        # Create main node
        self.mainNode = self.dom.createElement('resource')
        self.dom.appendChild(self.mainNode)
        self.rootObj = xxxMainNode(self.dom)
        self.root = self.AddRoot('XML tree', self.rootImage,
                                 data=wx.TreeItemData(self.rootObj))
        self.itemColour = self.GetItemTextColour(self.root)
        self.SetItemHasChildren(self.root)
        self.testElem = self.dom.createElement('dummy')
        self.mainNode.appendChild(self.testElem)
        self.Expand(self.root)

    # Clear old data and set new
    def SetData(self, dom):
        self.UnselectAll()
        self.DeleteAllItems()
        # Add minimal structure
        if self.dom: self.dom.unlink()
        self.dom = dom
        # Find 'resource' child, add it's children
        self.mainNode = dom.documentElement
        self.rootObj = xxxMainNode(self.dom)
        self.root = self.AddRoot('XML tree', self.rootImage,
                                 data=wx.TreeItemData(self.rootObj))
        self.SetItemHasChildren(self.root)
        nodes = self.mainNode.childNodes[:]
        for node in nodes:
            if IsObject(node):
                self.AddNode(self.root, None, node)
            else:
                self.mainNode.removeChild(node)
                node.unlink()
        self.testElem = self.dom.createElement('dummy')
        if self.mainNode.firstChild:
            self.mainNode.insertBefore(self.testElem, self.mainNode.firstChild)
        else:
            self.mainNode.appendChild(self.testElem)
        self.Expand(self.root)

    # Add tree item for given parent item if node is DOM element node with
    # object/object_ref tag. xxxParent is parent xxx object
    def AddNode(self, itemParent, xxxParent, node):
        # Set item data to current node
        try:
            xxx = MakeXXXFromDOM(xxxParent, node)
        except:
            print 'ERROR: MakeXXXFromDom(%s, %s)' % (xxxParent, node)
            raise
        treeObj = xxx.treeObject()
        # Append tree item
        item = self.AppendItem(itemParent, treeObj.treeName(),
                               image=treeObj.treeImage(),
                               data=wx.TreeItemData(xxx))
        # Different color for comments and references
        if xxx.className == 'comment':
            self.SetItemTextColour(item, self.COLOUR_COMMENT)
            self.SetItemFont(item, self.fontComment)
        elif treeObj.ref:
            self.SetItemTextColour(item, self.COLOUR_REF)
        elif treeObj.hasStyle and treeObj.params.get('hidden', False):
            self.SetItemTextColour(item, self.COLOUR_HIDDEN)
        # Try to find children objects
        if treeObj.hasChildren:
            nodes = treeObj.node.childNodes[:]
            for n in nodes:
                if IsObject(n):
                    self.AddNode(item, treeObj, n)
                elif n.nodeType != minidom.Node.ELEMENT_NODE:
                    treeObj.node.removeChild(n)
                    n.unlink()

    # Insert new item at specific position
    def InsertNode(self, itemParent, parent, elem, nextItem):
        # Insert in XML tree and wxWin
        xxx = MakeXXXFromDOM(parent, elem)
        # If nextItem is None, we append to parent, otherwise insert before it
        if nextItem.IsOk():
            node = self.GetPyData(nextItem).node
            parent.node.insertBefore(elem, node)
            # Inserting before is difficult, se we insert after or first child
            index = self.ItemIndex(nextItem)
            newItem = self.InsertItemBefore(itemParent, index,
                        xxx.treeName(), image=xxx.treeImage())
            self.SetPyData(newItem, xxx)
        else:
            parent.node.appendChild(elem)
            newItem = self.AppendItem(itemParent, xxx.treeName(), image=xxx.treeImage(),
                                      data=wx.TreeItemData(xxx))
        treeObj = xxx.treeObject()
        # Different color for references and comments
        if xxx.className == 'comment':
            self.SetItemTextColour(newItem, self.COLOUR_COMMENT)
            self.SetItemFont(newItem, self.fontComment)
        elif treeObj.ref:
            self.SetItemTextColour(newItem, self.COLOUR_REF)
        elif treeObj.hasStyle and treeObj.params.get('hidden', False):
            self.SetItemTextColour(newItem, self.COLOUR_HIDDEN)
        # Add children items
        if xxx.hasChildren:
            treeObj = xxx.treeObject()
            for n in treeObj.node.childNodes:
                if IsObject(n):
                    self.AddNode(newItem, treeObj, n)
        return newItem

    # Remove leaf of tree, return it's data object
    def RemoveLeaf(self, leaf):
        xxx = self.GetPyData(leaf)
        node = xxx.node