+# 12/09/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o 2.5 compatability update.
+# o I'm a little nervous about some of it though.
+#
+# 12/20/2003 - Jeff Grimmett (grimmtooth@softhome.net)
+#
+# o wxTreeModel -> TreeModel
+# o wxMVCTree -> MVCTree
+# o wxMVCTreeEvent -> MVCTreeEvent
+# o wxMVCTreeNotifyEvent -> MVCTreeNotifyEvent
+#
+
+"""
+MVCTree is a control which handles hierarchical data. It is constructed
+in model-view-controller architecture, so the display of that data, and
+the content of the data can be changed greatly without affecting the other parts.
+
+MVCTree actually is even more configurable than MVC normally implies, because
+almost every aspect of it is pluggable:
+ MVCTree - Overall controller, and the window that actually gets placed
+ in the GUI.
+ Painter - Paints the control. The 'view' part of MVC.
+ NodePainter - Paints just the nodes
+ LinePainter - Paints just the lines between the nodes
+ TextConverter - Figures out what text to print for each node
+ Editor - Edits the contents of a node, if the model is editable.
+ LayoutEngine - Determines initial placement of nodes
+ Transform - Adjusts positions of nodes for movement or special effects.
+ TreeModel - Contains the data which the rest of the control acts
+ on. The 'model' part of MVC.
+
+Author/Maintainer - Bryn Keller <xoltar@starship.python.net>
+
+
+NOTE: This module is *not* supported in any way. Use it however you
+ wish, but be warned that dealing with any consequences is
+ entirly up to you.
+ --Robin
+"""
+
+#------------------------------------------------------------------------
+import os
+import sys
+import traceback
+import warnings
+
+import wx
+#------------------------------------------------------------------------
+
+warningmsg = r"""\
+
+################################################\
+# This module is not supported in any way! |
+# |
+# See cource code for wx.lib.mvctree for more |
+# information. |
+################################################/
+
+"""
+
+warnings.warn(warningmsg, DeprecationWarning, stacklevel=2)
+#------------------------------------------------------------------------
+
+class MVCTreeNode:
+ """
+ Used internally by MVCTree to manage its data. Contains information about
+ screen placement, the actual data associated with it, and more. These are
+ the nodes passed to all the other helper parts to do their work with.
+ """
+ def __init__(self, data=None, parent = None, kids = None, x = 0, y = 0):
+ self.x = 0
+ self.y = 0
+ self.projx = 0
+ self.projy = 0
+ self.parent = parent
+ self.kids = kids
+ if self.kids is None:
+ self.kids = []
+ self.data = data
+ self.expanded = False
+ self.selected = False
+ self.built = False
+ self.scale = 0
+
+ def GetChildren(self):
+ return self.kids
+
+ def GetParent(self):
+ return self.parent
+
+ def Remove(self, node):
+ try:
+ self.kids.remove(node)
+ except:
+ pass
+ def Add(self, node):
+ self.kids.append(node)
+ node.SetParent(self)
+
+ def SetParent(self, parent):
+ if self.parent and not (self.parent is parent):
+ self.parent.Remove(self)
+ self.parent = parent
+ def __str__(self):
+ return "Node: " + str(self.data) + " (" + str(self.x) + ", " + str(self.y) + ")"
+ def __repr__(self):
+ return str(self.data)
+ def GetTreeString(self, tabs=0):
+ s = tabs * '\t' + str(self) + '\n'
+ for kid in self.kids:
+ s = s + kid.GetTreeString(tabs + 1)
+ return s
+
+
+class Editor:
+ def __init__(self, tree):
+ self.tree = tree
+ def Edit(self, node):
+ raise NotImplementedError
+ def EndEdit(self, node, commit):
+ raise NotImplementedError
+ def CanEdit(self, node):
+ raise NotImplementedError
+
+class LayoutEngine:
+ """
+ Interface for layout engines.
+ """
+ def __init__(self, tree):
+ self.tree = tree
+ def Layout(self, node):
+ raise NotImplementedError
+ def GetNodeList(self):
+ raise NotImplementedError
+
+class Transform:
+ """
+ Transform interface.
+ """
+ def __init__(self, tree):
+ self.tree = tree
+ def Transform(self, node, offset, rotation):
+ """
+ This method should only change the projx and projy attributes of
+ the node. These represent the position of the node as it should
+ be drawn on screen. Adjusting the x and y attributes can and
+ should cause havoc.
+ """
+ raise NotImplementedError
+
+ def GetSize(self):
+ """
+ Returns the size of the entire tree as laid out and transformed
+ as a tuple
+ """
+ raise NotImplementedError
+
+class Painter:
+ """
+ This is the interface that MVCTree expects from painters. All painters should
+ be Painter subclasses.
+ """
+ def __init__(self, tree):
+ self.tree = tree
+ self.textcolor = wx.NamedColour("BLACK")
+ self.bgcolor = wx.NamedColour("WHITE")
+ self.fgcolor = wx.NamedColour("BLUE")
+ self.linecolor = wx.NamedColour("GREY")
+ self.font = wx.Font(9, wx.DEFAULT, wx.NORMAL, wx.NORMAL, False)
+ self.bmp = None
+
+ def GetFont(self):
+ return self.font
+
+ def SetFont(self, font):
+ self.font = font
+ self.tree.Refresh()
+ def GetBuffer(self):
+ return self.bmp
+ def ClearBuffer(self):
+ self.bmp = None
+ def Paint(self, dc, node, doubleBuffered=1, paintBackground=1):
+ raise NotImplementedError
+ def GetTextColour(self):
+ return self.textcolor
+ def SetTextColour(self, color):
+ self.textcolor = color
+ self.textbrush = wx.Brush(color)
+ self.textpen = wx.Pen(color, 1, wx.SOLID)
+ def GetBackgroundColour(self):
+ return self.bgcolor
+ def SetBackgroundColour(self, color):
+ self.bgcolor = color
+ self.bgbrush = wx.Brush(color)
+ self.bgpen = wx.Pen(color, 1, wx.SOLID)
+ def GetForegroundColour(self):
+ return self.fgcolor
+ def SetForegroundColour(self, color):
+ self.fgcolor = color
+ self.fgbrush = wx.Brush(color)
+ self.fgpen = wx.Pen(color, 1, wx.SOLID)
+ def GetLineColour(self):
+ return self.linecolor
+ def SetLineColour(self, color):
+ self.linecolor = color
+ self.linebrush = wx.Brush(color)
+ self.linepen = wx.Pen( color, 1, wx.SOLID)
+ def GetForegroundPen(self):
+ return self.fgpen
+ def GetBackgroundPen(self):
+ return self.bgpen
+ def GetTextPen(self):
+ return self.textpen
+ def GetForegroundBrush(self):
+ return self.fgbrush
+ def GetBackgroundBrush(self):
+ return self.bgbrush
+ def GetTextBrush(self):
+ return self.textbrush
+ def GetLinePen(self):
+ return self.linepen
+ def GetLineBrush(self):
+ return self.linebrush
+ def OnMouse(self, evt):
+ if evt.LeftDClick():
+ x, y = self.tree.CalcUnscrolledPosition(evt.GetX(), evt.GetY())
+ for item in self.rectangles:
+ if item[1].Contains((x,y)):
+ self.tree.Edit(item[0].data)
+ self.tree.OnNodeClick(item[0], evt)
+ return
+ elif evt.ButtonDown():
+ x, y = self.tree.CalcUnscrolledPosition(evt.GetX(), evt.GetY())
+ for item in self.rectangles:
+ if item[1].Contains((x, y)):
+ self.tree.OnNodeClick(item[0], evt)
+ return
+ for item in self.knobs:
+ if item[1].Contains((x, y)):
+ self.tree.OnKnobClick(item[0])
+ return
+ evt.Skip()
+
+
+class TreeModel:
+ """
+ Interface for tree models
+ """
+ def GetRoot(self):
+ raise NotImplementedError
+ def SetRoot(self, root):
+ raise NotImplementedError
+ def GetChildCount(self, node):
+ raise NotImplementedError
+ def GetChildAt(self, node, index):
+ raise NotImplementedError
+ def GetParent(self, node):
+ raise NotImplementedError
+ def AddChild(self, parent, child):
+ if hasattr(self, 'tree') and self.tree:
+ self.tree.NodeAdded(parent, child)
+ def RemoveNode(self, child):
+ if hasattr(self, 'tree') and self.tree:
+ self.tree.NodeRemoved(child)
+ def InsertChild(self, parent, child, index):
+ if hasattr(self, 'tree') and self.tree:
+ self.tree.NodeInserted(parent, child, index)
+ def IsLeaf(self, node):
+ raise NotImplementedError
+
+ def IsEditable(self, node):
+ return False
+
+ def SetEditable(self, node):
+ return False
+
+class NodePainter:
+ """
+ This is the interface expected of a nodepainter.
+ """
+ def __init__(self, painter):
+ self.painter = painter
+ def Paint(self, node, dc, location = None):
+ """
+ location should be provided only to draw in an unusual position
+ (not the node's normal position), otherwise the node's projected x and y
+ coordinates will be used.
+ """
+ raise NotImplementedError
+
+class LinePainter:
+ """
+ The linepainter interface.
+ """
+ def __init__(self, painter):
+ self.painter = painter
+ def Paint(self, parent, child, dc):
+ raise NotImplementedError
+
+class TextConverter:
+ """
+ TextConverter interface.
+ """
+ def __init__(self, painter):
+ self.painter = painter
+ def Convert(node):
+ """
+ Should return a string. The node argument will be an
+ MVCTreeNode.
+ """
+ raise NotImplementedError
+
+
+class BasicTreeModel(TreeModel):
+ """
+ A very simple treemodel implementation, but flexible enough for many needs.
+ """
+ def __init__(self):
+ self.children = {}
+ self.parents = {}
+ self.root = None
+ def GetRoot(self):
+ return self.root
+ def SetRoot(self, root):
+ self.root = root
+ def GetChildCount(self, node):
+ if self.children.has_key(node):
+ return len(self.children[node])
+ else:
+ return 0
+ def GetChildAt(self, node, index):
+ return self.children[node][index]
+
+ def GetParent(self, node):
+ return self.parents[node]
+
+ def AddChild(self, parent, child):
+ self.parents[child]=parent
+ if not self.children.has_key(parent):
+ self.children[parent]=[]
+ self.children[parent].append(child)
+ TreeModel.AddChild(self, parent, child)
+ return child
+
+ def RemoveNode(self, node):
+ parent = self.parents[node]
+ del self.parents[node]
+ self.children[parent].remove(node)
+ TreeModel.RemoveNode(self, node)
+
+ def InsertChild(self, parent, child, index):
+ self.parents[child]=parent
+ if not self.children.has_key(parent):
+ self.children[parent]=[]
+ self.children[parent].insert(child, index)
+ TreeModel.InsertChild(self, parent, child, index)
+ return child
+
+ def IsLeaf(self, node):
+ return not self.children.has_key(node)
+
+ def IsEditable(self, node):
+ return False
+
+ def SetEditable(self, node, bool):
+ return False
+
+
+class FileEditor(Editor):
+ def Edit(self, node):
+ treenode = self.tree.nodemap[node]
+ self.editcomp = wxTextCtrl(self.tree, -1)
+ for rect in self.tree.painter.rectangles:
+ if rect[0] == treenode:
+ self.editcomp.SetPosition((rect[1][0], rect[1][1]))
+ break
+ self.editcomp.SetValue(node.fileName)
+ self.editcomp.SetSelection(0, len(node.fileName))
+ self.editcomp.SetFocus()
+ self.treenode = treenode
+# self.editcomp.Bind(wx.EVT_KEY_DOWN, self._key)
+ self.editcomp.Bind(wx.EVT_KEY_UP, self._key)
+ self.editcomp.Bind(wx.EVT_LEFT_DOWN, self._mdown)
+ self.editcomp.CaptureMouse()
+
+ def CanEdit(self, node):
+ return isinstance(node, FileWrapper)
+
+ def EndEdit(self, commit):
+ if not self.tree._EditEnding(self.treenode.data):
+ return
+ if commit:
+ node = self.treenode.data
+ try:
+ os.rename(node.path + os.sep + node.fileName, node.path + os.sep + self.editcomp.GetValue())
+ node.fileName = self.editcomp.GetValue()
+ except:
+ traceback.print_exc()
+ self.editcomp.ReleaseMouse()
+ self.editcomp.Destroy()
+ del self.editcomp
+ self.tree.Refresh()
+
+
+ def _key(self, evt):
+ if evt.KeyCode() == wx.WXK_RETURN:
+ self.EndEdit(True)
+ elif evt.KeyCode() == wx.WXK_ESCAPE:
+ self.EndEdit(False)
+ else:
+ evt.Skip()
+
+ def _mdown(self, evt):
+ if evt.IsButton():
+ x, y = evt.GetPosition()
+ w, h = self.editcomp.GetSize()
+ if x < 0 or y < 0 or x > w or y > h:
+ self.EndEdit(False)
+
+
+class FileWrapper:
+ """
+ Node class for FSTreeModel.
+ """
+ def __init__(self, path, fileName):
+ self.path = path
+ self.fileName = fileName
+
+ def __str__(self):
+ return self.fileName
+
+class FSTreeModel(BasicTreeModel):
+ """
+ This treemodel models the filesystem starting from a given path.
+ """
+ def __init__(self, path):
+ BasicTreeModel.__init__(self)
+ fw = FileWrapper(path, path.split(os.sep)[-1])
+ self._Build(path, fw)
+ self.SetRoot(fw)
+ self._editable = True
+ def _Build(self, path, fileWrapper):
+ for name in os.listdir(path):
+ fw = FileWrapper(path, name)
+ self.AddChild(fileWrapper, fw)
+ childName = path + os.sep + name
+ if os.path.isdir(childName):
+ self._Build(childName, fw)
+
+ def IsEditable(self, node):
+ return self._editable
+
+ def SetEditable(self, node, bool):
+ self._editable = bool
+
+class LateFSTreeModel(FSTreeModel):
+ """
+ This treemodel models the filesystem starting from a given path.
+ It retrieves the directory list as requested.
+ """
+ def __init__(self, path):
+ BasicTreeModel.__init__(self)
+ name = path.split(os.sep)[-1]
+ pathpart = path[:-len(name)]
+ fw = FileWrapper(pathpart, name)
+ self._Build(path, fw)
+ self.SetRoot(fw)
+ self._editable = True
+ self.children = {}
+ self.parents = {}
+ def _Build(self, path, parent):
+ ppath = parent.path + os.sep + parent.fileName
+ if not os.path.isdir(ppath):
+ return
+ for name in os.listdir(ppath):
+ fw = FileWrapper(ppath, name)
+ self.AddChild(parent, fw)
+ def GetChildCount(self, node):
+ if self.children.has_key(node):
+ return FSTreeModel.GetChildCount(self, node)
+ else:
+ self._Build(node.path, node)
+ return FSTreeModel.GetChildCount(self, node)
+
+ def IsLeaf(self, node):
+ return not os.path.isdir(node.path + os.sep + node.fileName)
+
+class StrTextConverter(TextConverter):
+ def Convert(self, node):
+ return str(node.data)
+
+class NullTransform(Transform):
+ def GetSize(self):
+ return tuple(self.size)
+
+ def Transform(self, node, offset, rotation):
+ self.size = [0,0]
+ list = self.tree.GetLayoutEngine().GetNodeList()
+ for node in list:
+ node.projx = node.x + offset[0]
+ node.projy = node.y + offset[1]
+ if node.projx > self.size[0]:
+ self.size[0] = node.projx
+ if node.projy > self.size[1]:
+ self.size[1] = node.projy
+
+class Rect:
+ def __init__(self, x, y, width, height):
+ self.x = x
+ self.y = y
+ self.width = width
+ self.height = height
+ def __getitem__(self, index):
+ return (self.x, self.y, self.width, self.height)[index]
+
+ def __setitem__(self, index, value):
+ name = ['x', 'y', 'width', 'height'][index]
+ setattr(self, name, value)
+
+ def Contains(self, other):
+ if type(other) == type(()):
+ other = Rect(other[0], other[1], 0, 0)
+ if other.x >= self.x:
+ if other.y >= self.y:
+ if other.width + other.x <= self.width + self.x:
+ if other.height + other.y <= self.height + self.y:
+ return True
+ return False
+
+ def __str__(self):
+ return "Rect: " + str([self.x, self.y, self.width, self.height])
+
+class TreeLayout(LayoutEngine):
+ def SetHeight(self, num):
+ self.NODE_HEIGHT = num
+
+ def __init__(self, tree):
+ LayoutEngine.__init__(self, tree)
+ self.NODE_STEP = 20
+ self.NODE_HEIGHT = 20
+ self.nodelist = []
+
+ def Layout(self, node):
+ self.nodelist = []
+ self.NODE_HEIGHT = self.tree.GetFont().GetPointSize() * 2
+ self.layoutwalk(node)
+
+ def GetNodeList(self):
+ return self.nodelist
+
+ def layoutwalk(self, node):
+ if node == self.tree.currentRoot:
+ node.level = 1
+ self.lastY = (-self.NODE_HEIGHT)
+ node.x = self.NODE_STEP * node.level
+ node.y = self.lastY + self.NODE_HEIGHT
+ self.lastY = node.y
+ self.nodelist.append(node)
+ if node.expanded:
+ for kid in node.kids:
+ kid.level = node.level + 1
+ self.layoutwalk(kid)
+
+class TreePainter(Painter):
+ """
+ The default painter class. Uses double-buffering, delegates the painting of nodes and
+ lines to helper classes deriving from NodePainter and LinePainter.
+ """
+ def __init__(self, tree, nodePainter = None, linePainter = None, textConverter = None):
+ Painter.__init__(self, tree)
+ if not nodePainter:
+ nodePainter = TreeNodePainter(self)
+ self.nodePainter = nodePainter
+ if not linePainter:
+ linePainter = TreeLinePainter(self)
+ self.linePainter = linePainter
+ if not textConverter:
+ textConverter = StrTextConverter(self)
+ self.textConverter = textConverter
+ self.charWidths = []
+
+ def Paint(self, dc, node, doubleBuffered=1, paintBackground=1):
+ if not self.charWidths:
+ self.charWidths = []
+ for i in range(25):
+ self.charWidths.append(dc.GetTextExtent("D")[0] * i)
+ self.charHeight = dc.GetTextExtent("D")[1]
+ self.textpen = wx.Pen(self.GetTextColour(), 1, wx.SOLID)
+ self.fgpen = wx.Pen(self.GetForegroundColour(), 1, wx.SOLID)
+ self.bgpen = wx.Pen(self.GetBackgroundColour(), 1, wx.SOLID)
+ self.linepen = wx.Pen(self.GetLineColour(), 1, wx.SOLID)
+ self.dashpen = wx.Pen(self.GetLineColour(), 1, wx.DOT)
+ self.textbrush = wx.Brush(self.GetTextColour(), wx.SOLID)
+ self.fgbrush = wx.Brush(self.GetForegroundColour(), wx.SOLID)
+ self.bgbrush = wx.Brush(self.GetBackgroundColour(), wx.SOLID)
+ self.linebrush = wx.Pen(self.GetLineColour(), 1, wx.SOLID)
+ treesize = self.tree.GetSize()
+ size = self.tree.transform.GetSize()
+ size = (max(treesize.width, size[0]+50), max(treesize.height, size[1]+50))
+ dc.BeginDrawing()
+ if doubleBuffered:
+ mem_dc = wx.MemoryDC()
+ if not self.GetBuffer():
+ self.knobs = []
+ self.rectangles = []
+ self.bmp = wx.EmptyBitmap(size[0], size[1])
+ mem_dc.SelectObject(self.GetBuffer())
+ mem_dc.SetPen(self.GetBackgroundPen())
+ mem_dc.SetBrush(self.GetBackgroundBrush())
+ mem_dc.DrawRectangle(0, 0, size[0], size[1])
+ mem_dc.SetFont(self.tree.GetFont())
+ self.paintWalk(node, mem_dc)
+ else:
+ mem_dc.SelectObject(self.GetBuffer())
+ xstart, ystart = self.tree.CalcUnscrolledPosition(0,0)
+ size = self.tree.GetClientSizeTuple()
+ dc.Blit(xstart, ystart, size[0], size[1], mem_dc, xstart, ystart)
+ else:
+ if node == self.tree.currentRoot:
+ self.knobs = []
+ self.rectangles = []
+ dc.SetPen(self.GetBackgroundPen())
+ dc.SetBrush(self.GetBackgroundBrush())
+ dc.SetFont(self.tree.GetFont())
+ if paintBackground:
+ dc.DrawRectangle(0, 0, size[0], size[1])
+ if node:
+ #Call with not paintBackground because if we are told not to paint the
+ #whole background, we have to paint in parts to undo selection coloring.
+ pb = paintBackground
+ self.paintWalk(node, dc, not pb)
+ dc.EndDrawing()
+
+ def GetDashPen(self):
+ return self.dashpen
+
+ def SetLinePen(self, pen):
+ Painter.SetLinePen(self, pen)
+ self.dashpen = wx.Pen(pen.GetColour(), 1, wx.DOT)
+
+ def paintWalk(self, node, dc, paintRects=0):
+ self.linePainter.Paint(node.parent, node, dc)
+ self.nodePainter.Paint(node, dc, drawRects = paintRects)
+ if node.expanded:
+ for kid in node.kids:
+ if not self.paintWalk(kid, dc, paintRects):
+ return False
+ for kid in node.kids:
+ px = (kid.projx - self.tree.layout.NODE_STEP) + 5
+ py = kid.projy + kid.height/2
+ if (not self.tree.model.IsLeaf(kid.data)) or ((kid.expanded or self.tree._assumeChildren) and len(kid.kids)):
+ dc.SetPen(self.linepen)
+ dc.SetBrush(self.bgbrush)
+ dc.DrawRectangle(px -4, py-4, 9, 9)
+ self.knobs.append( (kid, Rect(px -4, py -4, 9, 9)) )
+ dc.SetPen(self.textpen)
+ if not kid.expanded:
+ dc.DrawLine(px, py -2, px, py + 3)
+ dc.DrawLine(px -2, py, px + 3, py)
+ if node == self.tree.currentRoot:
+ px = (node.projx - self.tree.layout.NODE_STEP) + 5
+ py = node.projy + node.height/2
+ dc.SetPen(self.linepen)
+ dc.SetBrush(self.bgbrush)
+ dc.DrawRectangle(px -4, py-4, 9, 9)
+ self.knobs.append( (node, Rect(px -4, py -4, 9, 9)) )
+ dc.SetPen(self.textpen)
+ if not node.expanded:
+ dc.DrawLine(px, py -2, px, py + 3)
+ dc.DrawLine(px -2, py, px + 3, py)
+ return True
+
+ def OnMouse(self, evt):
+ Painter.OnMouse(self, evt)
+
+class TreeNodePainter(NodePainter):
+ def Paint(self, node, dc, location = None, drawRects = 0):
+ text = self.painter.textConverter.Convert(node)
+ extent = dc.GetTextExtent(text)
+ node.width = extent[0]
+ node.height = extent[1]
+ if node.selected:
+ dc.SetPen(self.painter.GetLinePen())
+ dc.SetBrush(self.painter.GetForegroundBrush())
+ dc.SetTextForeground(wx.NamedColour("WHITE"))
+ dc.DrawRectangle(node.projx -1, node.projy -1, node.width + 3, node.height + 3)
+ else:
+ if drawRects:
+ dc.SetBrush(self.painter.GetBackgroundBrush())
+ dc.SetPen(self.painter.GetBackgroundPen())
+ dc.DrawRectangle(node.projx -1, node.projy -1, node.width + 3, node.height + 3)
+ dc.SetTextForeground(self.painter.GetTextColour())
+ dc.DrawText(text, node.projx, node.projy)
+ self.painter.rectangles.append((node, Rect(node.projx, node.projy, node.width, node.height)))
+
+class TreeLinePainter(LinePainter):
+ def Paint(self, parent, child, dc):
+ dc.SetPen(self.painter.GetDashPen())
+ px = py = cx = cy = 0
+ if parent is None or child == self.painter.tree.currentRoot:
+ px = (child.projx - self.painter.tree.layout.NODE_STEP) + 5
+ py = child.projy + self.painter.tree.layout.NODE_HEIGHT/2 -2
+ cx = child.projx
+ cy = py
+ dc.DrawLine(px, py, cx, cy)
+ else:
+ px = parent.projx + 5
+ py = parent.projy + parent.height
+ cx = child.projx -5
+ cy = child.projy + self.painter.tree.layout.NODE_HEIGHT/2 -3
+ dc.DrawLine(px, py, px, cy)
+ dc.DrawLine(px, cy, cx, cy)
+
+#>> Event defs
+wxEVT_MVCTREE_BEGIN_EDIT = wx.NewEventType() #Start editing. Vetoable.
+wxEVT_MVCTREE_END_EDIT = wx.NewEventType() #Stop editing. Vetoable.
+wxEVT_MVCTREE_DELETE_ITEM = wx.NewEventType() #Item removed from model.
+wxEVT_MVCTREE_ITEM_EXPANDED = wx.NewEventType()
+wxEVT_MVCTREE_ITEM_EXPANDING = wx.NewEventType()
+wxEVT_MVCTREE_ITEM_COLLAPSED = wx.NewEventType()
+wxEVT_MVCTREE_ITEM_COLLAPSING = wx.NewEventType()
+wxEVT_MVCTREE_SEL_CHANGED = wx.NewEventType()
+wxEVT_MVCTREE_SEL_CHANGING = wx.NewEventType() #Vetoable.
+wxEVT_MVCTREE_KEY_DOWN = wx.NewEventType()
+wxEVT_MVCTREE_ADD_ITEM = wx.NewEventType() #Item added to model.
+
+EVT_MVCTREE_SEL_CHANGED = wx.PyEventBinder(wxEVT_MVCTREE_SEL_CHANGED, 1)
+EVT_MVCTREE_SEL_CHANGING = wx.PyEventBinder(wxEVT_MVCTREE_SEL_CHANGING, 1)
+EVT_MVCTREE_ITEM_EXPANDED = wx.PyEventBinder(wxEVT_MVCTREE_ITEM_EXPANDED, 1)
+EVT_MVCTREE_ITEM_EXPANDING = wx.PyEventBinder(wxEVT_MVCTREE_ITEM_EXPANDING, 1)
+EVT_MVCTREE_ITEM_COLLAPSED = wx.PyEventBinder(wxEVT_MVCTREE_ITEM_COLLAPSED, 1)
+EVT_MVCTREE_ITEM_COLLAPSING = wx.PyEventBinder(wxEVT_MVCTREE_ITEM_COLLAPSING, 1)
+EVT_MVCTREE_ADD_ITEM = wx.PyEventBinder(wxEVT_MVCTREE_ADD_ITEM, 1)
+EVT_MVCTREE_DELETE_ITEM = wx.PyEventBinder(wxEVT_MVCTREE_DELETE_ITEM, 1)
+EVT_MVCTREE_KEY_DOWN = wx.PyEventBinder(wxEVT_MVCTREE_KEY_DOWN, 1)
+
+class MVCTreeEvent(wx.PyCommandEvent):
+ def __init__(self, type, id, node = None, nodes = None, keyEvent = None, **kwargs):
+ apply(wx.PyCommandEvent.__init__, (self, type, id), kwargs)
+ self.node = node
+ self.nodes = nodes
+ self.keyEvent = keyEvent
+ def GetNode(self):
+ return self.node
+ def GetNodes(self):
+ return self.nodes
+ def getKeyEvent(self):
+ return self.keyEvent
+
+class MVCTreeNotifyEvent(MVCTreeEvent):
+ def __init__(self, type, id, node = None, nodes = None, **kwargs):
+ apply(MVCTreeEvent.__init__, (self, type, id, node, nodes), kwargs)
+ self.notify = wx.NotifyEvent(type, id)
+ def getNotifyEvent(self):
+ return self.notify
+
+class MVCTree(wx.ScrolledWindow):
+ """
+ The main mvc tree class.
+ """
+ def __init__(self, parent, id, model = None, layout = None, transform = None,
+ painter = None, *args, **kwargs):
+ apply(wx.ScrolledWindow.__init__, (self, parent, id), kwargs)
+ self.nodemap = {}
+ self._multiselect = False
+ self._selections = []
+ self._assumeChildren = False
+ self._scrollx = False
+ self._scrolly = False
+ self.doubleBuffered = False
+ self._lastPhysicalSize = self.GetSize()
+ self._editors = []
+ if not model:
+ model = BasicTreeModel()
+ model.SetRoot("Root")
+ self.SetModel(model)
+ if not layout:
+ layout = TreeLayout(self)
+ self.layout = layout
+ if not transform:
+ transform = NullTransform(self)
+ self.transform = transform
+ if not painter:
+ painter = TreePainter(self)
+ self.painter = painter
+ self.SetFont(wx.Font(9, wx.DEFAULT, wx.NORMAL, wx.NORMAL, False))
+ self.Bind(wx.EVT_MOUSE_EVENTS, self.OnMouse)
+ self.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
+ self.doubleBuffered = True
+ self.Bind(wx.EVT_SIZE, self.OnSize)
+ self.Bind(wx.EVT_ERASE_BACKGROUND, self.OnEraseBackground)
+ self.Bind(wx.EVT_PAINT, self.OnPaint)
+
+
+ def Refresh(self):
+ if self.doubleBuffered:
+ self.painter.ClearBuffer()
+ wx.ScrolledWindow.Refresh(self, False)
+
+ def GetPainter(self):
+ return self.painter
+
+ def GetLayoutEngine(self):
+ return self.layout
+
+ def GetTransform(self):
+ return self.transform
+
+ def __repr__(self):
+ return "<MVCTree instance at %s>" % str(hex(id(self)))
+
+ def __str__(self):
+ return self.__repr__()
+
+ def NodeAdded(self, parent, child):
+ e = MVCTreeEvent(wxEVT_MVCTREE_ADD_ITEM, self.GetId(), node = child, nodes = [parent, child])
+ self.GetEventHandler().ProcessEvent(e)
+ self.painter.ClearBuffer()
+
+ def NodeInserted(self, parent, child, index):
+ e = MVCTreeEvent(wxEVT_MVCTREE_ADD_ITEM, self.GetId(), node = child, nodes = [parent, child])
+ self.GetEventHandler().ProcessEvent(e)
+ self.painter.ClearBuffer()
+
+ def NodeRemoved(self, node):
+ e = MVCTreeEvent(wxEVT_MVCTREE_DELETE_ITEM, self.GetId(), node = child, nodes = [parent, child])
+ self.GetEventHandler().ProcessEvent(e)
+ self.painter.ClearBuffer()
+
+ def OnKeyDown(self, evt):
+ e = MVCTreeEvent(wxEVT_MVCTREE_KEY_DOWN, self.GetId(), keyEvent = evt)
+ self.GetEventHandler().ProcessEvent(e)
+
+ def SetFont(self, font):
+ self.painter.SetFont(font)
+ dc = wx.ClientDC(self)
+ dc.SetFont(font)
+ self.layout.SetHeight(dc.GetTextExtent("")[1] + 18)
+ self.painter.ClearBuffer()
+
+ def GetFont(self):
+ return self.painter.GetFont()
+
+ def AddEditor(self, editor):
+ self._editors.append(editor)
+
+ def RemoveEditor(self, editor):
+ self._editors.remove(editor)
+
+ def OnMouse(self, evt):
+ self.painter.OnMouse(evt)
+
+ def OnNodeClick(self, node, mouseEvent):
+ if node.selected and (self.IsMultiSelect() and mouseEvent.ControlDown()):
+ self.RemoveFromSelection(node.data)
+ else:
+ self.AddToSelection(node.data, mouseEvent.ControlDown(), mouseEvent.ShiftDown())
+
+ def OnKnobClick(self, node):
+ self.SetExpanded(node.data, not node.expanded)
+
+ def GetDisplayText(self, node):
+ treenode = self.nodemap[node]
+ return self.painter.textConverter.Convert(treenode)
+
+ def IsDoubleBuffered(self):
+ return self.doubleBuffered
+
+ def SetDoubleBuffered(self, bool):
+ """
+ By default MVCTree is double-buffered.
+ """
+ self.doubleBuffered = bool
+
+ def GetModel(self):
+ return self.model
+
+ def SetModel(self, model):
+ """
+ Completely change the data to be displayed.
+ """
+ self.model = model
+ model.tree = self
+ self.laidOut = 0
+ self.transformed = 0
+ self._selections = []
+ self.layoutRoot = MVCTreeNode()
+ self.layoutRoot.data = self.model.GetRoot()
+ self.layoutRoot.expanded = True
+ self.LoadChildren(self.layoutRoot)
+ self.currentRoot = self.layoutRoot
+ self.offset = [0,0]
+ self.rotation = 0
+ self._scrollset = None
+ self.Refresh()
+
+ def GetCurrentRoot(self):
+ return self.currentRoot
+
+ def LoadChildren(self, layoutNode):
+ if layoutNode.built:
+ return
+ else:
+ self.nodemap[layoutNode.data]=layoutNode
+ for i in range(self.GetModel().GetChildCount(layoutNode.data)):
+ p = MVCTreeNode("RAW", layoutNode, [])
+ layoutNode.Add(p)
+ p.data = self.GetModel().GetChildAt(layoutNode.data, i)
+ self.nodemap[p.data]=p
+ layoutNode.built = True
+ if not self._assumeChildren:
+ for kid in layoutNode.kids:
+ self.LoadChildren(kid)
+
+ def OnEraseBackground(self, evt):
+ pass
+
+ def OnSize(self, evt):
+ size = self.GetSize()
+ self.center = (size.width/2, size.height/2)
+ if self._lastPhysicalSize.width < size.width or self._lastPhysicalSize.height < size.height:
+ self.painter.ClearBuffer()
+ self._lastPhysicalSize = size
+
+ def GetSelection(self):
+ "Returns a tuple of selected nodes."
+ return tuple(self._selections)
+
+ def SetSelection(self, nodeTuple):
+ if type(nodeTuple) != type(()):
+ nodeTuple = (nodeTuple,)
+ e = MVCTreeNotifyEvent(wxEVT_MVCTREE_SEL_CHANGING, self.GetId(), nodeTuple[0], nodes = nodeTuple)
+ self.GetEventHandler().ProcessEvent(e)
+ if not e.notify.IsAllowed():
+ return
+ for node in nodeTuple:
+ treenode = self.nodemap[node]
+ treenode.selected = True
+ for node in self._selections:
+ treenode = self.nodemap[node]
+ node.selected = False
+ self._selections = list(nodeTuple)
+ e = MVCTreeEvent(wxEVT_MVCTREE_SEL_CHANGED, self.GetId(), nodeTuple[0], nodes = nodeTuple)
+ self.GetEventHandler().ProcessEvent(e)
+
+ def IsMultiSelect(self):
+ return self._multiselect
+
+ def SetMultiSelect(self, bool):
+ self._multiselect = bool
+
+ def IsSelected(self, node):
+ return self.nodemap[node].selected
+
+ def Edit(self, node):
+ if not self.model.IsEditable(node):
+ return
+ for ed in self._editors:
+ if ed.CanEdit(node):
+ e = MVCTreeNotifyEvent(wxEVT_MVCTREE_BEGIN_EDIT, self.GetId(), node)
+ self.GetEventHandler().ProcessEvent(e)
+ if not e.notify.IsAllowed():
+ return
+ ed.Edit(node)
+ self._currentEditor = ed
+ break
+
+ def EndEdit(self):
+ if self._currentEditor:
+ self._currentEditor.EndEdit
+ self._currentEditor = None
+
+ def _EditEnding(self, node):
+ e = MVCTreeNotifyEvent(wxEVT_MVCTREE_END_EDIT, self.GetId(), node)
+ self.GetEventHandler().ProcessEvent(e)
+ if not e.notify.IsAllowed():
+ return False
+ self._currentEditor = None
+ return True
+
+
+ def SetExpanded(self, node, bool):
+ treenode = self.nodemap[node]
+ if bool:
+ e = MVCTreeNotifyEvent(wxEVT_MVCTREE_ITEM_EXPANDING, self.GetId(), node)
+ self.GetEventHandler().ProcessEvent(e)
+ if not e.notify.IsAllowed():
+ return
+ if not treenode.built:
+ self.LoadChildren(treenode)
+ else:
+ e = MVCTreeNotifyEvent(wxEVT_MVCTREE_ITEM_COLLAPSING, self.GetId(), node)
+ self.GetEventHandler().ProcessEvent(e)
+ if not e.notify.IsAllowed():
+ return
+ treenode.expanded = bool
+ e = None
+ if treenode.expanded:
+ e = MVCTreeEvent(wxEVT_MVCTREE_ITEM_EXPANDED, self.GetId(), node)
+ else:
+ e = MVCTreeEvent(wxEVT_MVCTREE_ITEM_COLLAPSED, self.GetId(), node)
+ self.GetEventHandler().ProcessEvent(e)
+ self.layout.Layout(self.currentRoot)
+ self.transform.Transform(self.currentRoot, self.offset, self.rotation)
+ self.Refresh()
+
+ def IsExpanded(self, node):
+ return self.nodemap[node].expanded
+
+ def AddToSelection(self, nodeOrTuple, enableMulti = True, shiftMulti = False):
+ nodeTuple = nodeOrTuple
+ if type(nodeOrTuple)!= type(()):
+ nodeTuple = (nodeOrTuple,)
+ e = MVCTreeNotifyEvent(wxEVT_MVCTREE_SEL_CHANGING, self.GetId(), nodeTuple[0], nodes = nodeTuple)
+ self.GetEventHandler().ProcessEvent(e)
+ if not e.notify.IsAllowed():
+ return
+ changeparents = []
+ if not (self.IsMultiSelect() and (enableMulti or shiftMulti)):
+ for node in self._selections:
+ treenode = self.nodemap[node]
+ treenode.selected = False
+ changeparents.append(treenode)
+ node = nodeTuple[0]
+ self._selections = [node]
+ treenode = self.nodemap[node]
+ changeparents.append(treenode)
+ treenode.selected = True
+ else:
+ if shiftMulti:
+ for node in nodeTuple:
+ treenode = self.nodemap[node]
+ oldtreenode = self.nodemap[self._selections[0]]
+ if treenode.parent == oldtreenode.parent:
+ found = 0
+ for kid in oldtreenode.parent.kids:
+ if kid == treenode or kid == oldtreenode:
+ found = not found
+ kid.selected = True
+ self._selections.append(kid.data)
+ changeparents.append(kid)
+ elif found:
+ kid.selected = True
+ self._selections.append(kid.data)
+ changeparents.append(kid)
+ else:
+ for node in nodeTuple:
+ try:
+ self._selections.index(node)
+ except ValueError:
+ self._selections.append(node)
+ treenode = self.nodemap[node]
+ treenode.selected = True
+ changeparents.append(treenode)
+ e = MVCTreeEvent(wxEVT_MVCTREE_SEL_CHANGED, self.GetId(), nodeTuple[0], nodes = nodeTuple)
+ self.GetEventHandler().ProcessEvent(e)
+ dc = wx.ClientDC(self)
+ self.PrepareDC(dc)
+ for node in changeparents:
+ if node:
+ self.painter.Paint(dc, node, doubleBuffered = 0, paintBackground = 0)
+ self.painter.ClearBuffer()
+
+ def RemoveFromSelection(self, nodeTuple):
+ if type(nodeTuple) != type(()):
+ nodeTuple = (nodeTuple,)
+ changeparents = []
+ for node in nodeTuple:
+ self._selections.remove(node)
+ treenode = self.nodemap[node]
+ changeparents.append(treenode)
+ treenode.selected = False
+ e = MVCTreeEvent(wxEVT_MVCTREE_SEL_CHANGED, self.GetId(), node, nodes = nodeTuple)
+ self.GetEventHandler().ProcessEvent(e)
+ dc = wx.ClientDC(self)
+ self.PrepareDC(dc)
+ for node in changeparents:
+ if node:
+ self.painter.Paint(dc, node, doubleBuffered = 0, paintBackground = 0)
+ self.painter.ClearBuffer()
+
+
+ def GetBackgroundColour(self):
+ if hasattr(self, 'painter') and self.painter:
+ return self.painter.GetBackgroundColour()
+ else:
+ return wx.Window.GetBackgroundColour(self)
+ def SetBackgroundColour(self, color):
+ if hasattr(self, 'painter') and self.painter:
+ self.painter.SetBackgroundColour(color)
+ else:
+ wx.Window.SetBackgroundColour(self, color)
+ def GetForegroundColour(self):
+ if hasattr(self, 'painter') and self.painter:
+ return self.painter.GetForegroundColour()
+ else:
+ return wx.Window.GetBackgroundColour(self)
+ def SetForegroundColour(self, color):
+ if hasattr(self, 'painter') and self.painter:
+ self.painter.SetForegroundColour(color)
+ else:
+ wx.Window.SetBackgroundColour(self, color)
+
+ def SetAssumeChildren(self, bool):
+ self._assumeChildren = bool
+
+ def GetAssumeChildren(self):
+ return self._assumeChildren
+
+ def OnPaint(self, evt):
+ """
+ Ensures that the tree has been laid out and transformed, then calls the painter
+ to paint the control.
+ """
+ try:
+ self.EnableScrolling(False, False)
+ if not self.laidOut:
+ self.layout.Layout(self.currentRoot)
+ self.laidOut = True
+ self.transformed = False
+ if not self.transformed:
+ self.transform.Transform(self.currentRoot, self.offset, self.rotation)
+ self.transformed = True
+ tsize = None
+ tsize = list(self.transform.GetSize())
+ tsize[0] = tsize[0] + 50
+ tsize[1] = tsize[1] + 50
+ w, h = self.GetSize()
+ if tsize[0] > w or tsize[1] > h:
+ if not hasattr(self, '_oldsize') or (tsize[0] > self._oldsize[0] or tsize[1] > self._oldsize[1]):
+ self._oldsize = tsize
+ oldstart = self.GetViewStart()
+ self._lastPhysicalSize = self.GetSize()
+ self.SetScrollbars(10, 10, tsize[0]/10, tsize[1]/10)
+ self.Scroll(oldstart[0], oldstart[1])
+ dc = wx.PaintDC(self)
+ self.PrepareDC(dc)
+ dc.SetFont(self.GetFont())
+ self.painter.Paint(dc, self.currentRoot, self.doubleBuffered)
+ except:
+ traceback.print_exc()
+
projects / wxWidgets.git / blobdiff