utils/wxPython/lib/mvctree.py

   1 """
   2 wxMVCTree is a control which handles hierarchical data. It is constructed
   3 in model-view-controller architecture, so the display of that data, and
   4 the content of the data can be changed greatly without affecting the other parts.
   5
   6 wxMVCTree actually is even more configurable than MVC normally implies, because
   7 almost every aspect of it is pluggable:
   8     wxMVCTree - Overall controller, and the window that actually gets placed
   9     in the GUI.
  10         Painter - Paints the control. The 'view' part of MVC.
  11            NodePainter - Paints just the nodes
  12            LinePainter - Paints just the lines between the nodes
  13            TextConverter - Figures out what text to print for each node
  14         Editor - Edits the contents of a node, if the model is editable.
  15         LayoutEngine - Determines initial placement of nodes
  16         Transform - Adjusts positions of nodes for movement or special effects.
  17         TreeModel - Contains the data which the rest of the control acts
  18         on. The 'model' part of MVC.
  19
  20 Author/Maintainer - Bryn Keller <xoltar@starship.python.net>
  21 """
  22
  23 #------------------------------------------------------------------------
  24 from wxPython.wx import *
  25 import os, sys, traceback
  26 #------------------------------------------------------------------------
  27
  28 class MVCTreeNode:
  29     """
  30     Used internally by wxMVCTree to manage its data. Contains information about
  31     screen placement, the actual data associated with it, and more. These are
  32     the nodes passed to all the other helper parts to do their work with.
  33     """
  34     def __init__(self, data=None, parent = None, kids = [], x = 0, y = 0):
  35         self.x = 0
  36         self.y = 0
  37         self.projx = 0
  38         self.projy = 0
  39         self.parent = parent
  40         self.kids = kids
  41         self.data = data
  42         self.expanded = false
  43         self.selected = false
  44         self.built = false
  45         self.scale = 0
  46
  47     def GetChildren(self):
  48         return self.kids
  49
  50     def GetParent(self):
  51         return self.parent
  52
  53     def Remove(self, node):
  54         try:
  55             self.kids.remove(node)
  56         except:
  57             pass
  58     def Add(self, node):
  59         self.kids.append(node)
  60         node.SetParent(self)
  61
  62     def SetParent(self, parent):
  63         if self.parent and not (self.parent is parent):
  64             self.parent.Remove(self)
  65         self.parent = parent
  66     def __str__(self):
  67         return "Node: "  + str(self.data) + " (" + str(self.x) + ", " + str(self.y) + ")"
  68     def __repr__(self):
  69         return str(self.data)
  70     def GetTreeString(self, tabs=0):
  71         s = tabs * '\t' + str(self) + '\n'
  72         for kid in self.kids:
  73             s = s + kid.GetTreeString(tabs + 1)
  74         return s
  75
  76
  77 class Editor:
  78     def __init__(self, tree):
  79         self.tree = tree
  80     def Edit(self, node):
  81         raise NotImplementedError
  82     def EndEdit(self, node, commit):
  83         raise NotImplementedError
  84     def CanEdit(self, node):
  85         raise NotImplementedError
  86
  87 class LayoutEngine:
  88     """
  89     Interface for layout engines.
  90     """
  91     def __init__(self, tree):
  92         self.tree = tree
  93     def Layout(self, node):
  94         raise NotImplementedError
  95     def GetNodeList(self):
  96         raise NotImplementedError
  97
  98 class Transform:
  99     """
 100     Transform interface.
 101     """
 102     def __init__(self, tree):
 103         self.tree = tree
 104     def Transform(self, node, offset, rotation):
 105         """
 106         This method should only change the projx and projy attributes of
 107         the node. These represent the position of the node as it should
 108         be drawn on screen. Adjusting the x and y attributes can and
 109         should cause havoc.
 110         """
 111         raise NotImplementedError
 112
 113     def GetSize(self):
 114         """
 115         Returns the size of the entire tree as laid out and transformed
 116         as a tuple
 117         """
 118         raise NotImplementedError
 119
 120 class Painter:
 121     """
 122     This is the interface that wxMVCTree expects from painters. All painters should
 123     be Painter subclasses.
 124     """
 125     def __init__(self, tree):
 126         self.tree = tree
 127         self.textcolor = wxNamedColour("BLACK")
 128         self.bgcolor = wxNamedColour("WHITE")
 129         self.fgcolor = wxNamedColour("BLUE")
 130         self.linecolor = wxNamedColour("GREY")
 131         self.font = wxFont(9, wxDEFAULT, wxNORMAL, wxNORMAL, false)
 132         self.bmp = None
 133
 134     def GetFont(self):
 135         return self.font
 136
 137     def SetFont(self, font):
 138         self.font = font
 139         self.tree.Refresh()
 140     def GetBuffer(self):
 141         return self.bmp
 142     def ClearBuffer(self):
 143         self.bmp = None
 144     def Paint(self, dc, node, doubleBuffered=1, paintBackground=1):
 145         raise NotImplementedError
 146     def GetTextColour(self):
 147         return self.textcolor
 148     def SetTextColour(self, color):
 149         self.textcolor = color
 150         self.textbrush = wxBrush(color)
 151         self.textpen = wxPen(color, 1, wxSOLID)
 152     def GetBackgroundColour(self):
 153         return self.bgcolor
 154     def SetBackgroundColour(self, color):
 155         self.bgcolor = color
 156         self.bgbrush = wxBrush(color)
 157         self.bgpen = wxPen(color, 1, wxSOLID)
 158     def GetForegroundColour(self):
 159         return self.fgcolor
 160     def SetForegroundColour(self, color):
 161         self.fgcolor = color
 162         self.fgbrush = wxBrush(color)
 163         self.fgpen = wxPen(color, 1, wxSOLID)
 164     def GetLineColour(self):
 165         return self.linecolor
 166     def SetLineColour(self, color):
 167         self.linecolor = color
 168         self.linebrush = wxBrush(color)
 169         self.linepen = wxPen( color, 1, wxSOLID)
 170     def GetForegroundPen(self):
 171         return self.fgpen
 172     def GetBackgroundPen(self):
 173         return self.bgpen
 174     def GetTextPen(self):
 175         return self.textpen
 176     def GetForegroundBrush(self):
 177         return self.fgbrush
 178     def GetBackgroundBrush(self):
 179         return self.bgbrush
 180     def GetTextBrush(self):
 181         return self.textbrush
 182     def GetLinePen(self):
 183         return self.linepen
 184     def GetLineBrush(self):
 185         return self.linebrush
 186     def OnMouse(self, evt):
 187         if evt.LeftDClick():
 188             x, y = self.tree.CalcUnscrolledPosition(evt.GetX(), evt.GetY())
 189             for item in self.rectangles:
 190                 if item[1].Contains((x,y)):
 191                     self.tree.Edit(item[0].data)
 192                     self.tree.OnNodeClick(item[0], evt)
 193                     return
 194         elif evt.ButtonDown():
 195             x, y = self.tree.CalcUnscrolledPosition(evt.GetX(), evt.GetY())
 196             for item in self.rectangles:
 197                 if item[1].Contains((x, y)):
 198                     self.tree.OnNodeClick(item[0], evt)
 199                     return
 200             for item in self.knobs:
 201                 if item[1].Contains((x, y)):
 202                     self.tree.OnKnobClick(item[0])
 203                     return
 204         evt.Skip()
 205
 206
 207 class wxTreeModel:
 208     """
 209     Interface for tree models
 210     """
 211     def GetRoot(self):
 212         raise NotImplementedError
 213     def SetRoot(self, root):
 214         raise NotImplementedError
 215     def GetChildCount(self, node):
 216         raise NotImplementedError
 217     def GetChildAt(self, node, index):
 218         raise NotImplementedError
 219     def GetParent(self, node):
 220         raise NotImplementedError
 221     def AddChild(self, parent, child):
 222         if hasattr(self, 'tree') and self.tree:
 223             self.tree.NodeAdded(parent, child)
 224     def RemoveNode(self, child):
 225         if hasattr(self, 'tree') and self.tree:
 226             self.tree.NodeRemoved(child)
 227     def InsertChild(self, parent, child, index):
 228         if hasattr(self, 'tree') and self.tree:
 229             self.tree.NodeInserted(parent, child, index)
 230     def IsLeaf(self, node):
 231         raise NotImplementedError
 232
 233     def IsEditable(self, node):
 234         return false
 235
 236     def SetEditable(self, node):
 237         return false
 238
 239 class NodePainter:
 240     """
 241     This is the interface expected of a nodepainter.
 242     """
 243     def __init__(self, painter):
 244         self.painter = painter
 245     def Paint(self, node, dc, location = None):
 246         """
 247         location should be provided only to draw in an unusual position
 248         (not the node's normal position), otherwise the node's projected x and y
 249         coordinates will be used.
 250         """
 251         raise NotImplementedError
 252
 253 class LinePainter:
 254     """
 255     The linepainter interface.
 256     """
 257     def __init__(self, painter):
 258         self.painter = painter
 259     def Paint(self, parent, child, dc):
 260         raise NotImplementedError
 261
 262 class TextConverter:
 263     """
 264     TextConverter interface.
 265     """
 266     def __init__(self, painter):
 267         self.painter = painter
 268     def Convert(node):
 269         """
 270         Should return a string. The node argument will be an
 271         MVCTreeNode.
 272         """
 273         raise NotImplementedError
 274
 275
 276 class BasicTreeModel(wxTreeModel):
 277     """
 278     A very simple treemodel implementation, but flexible enough for many needs.
 279     """
 280     def __init__(self):
 281         self.children = {}
 282         self.parents = {}
 283         self.root = None
 284     def GetRoot(self):
 285         return self.root
 286     def SetRoot(self, root):
 287         self.root = root
 288     def GetChildCount(self, node):
 289         if self.children.has_key(node):
 290             return len(self.children[node])
 291         else:
 292             return 0
 293     def GetChildAt(self, node, index):
 294         return self.children[node][index]
 295
 296     def GetParent(self, node):
 297         return self.parents[node]
 298
 299     def AddChild(self, parent, child):
 300         self.parents[child]=parent
 301         if not self.children.has_key(parent):
 302             self.children[parent]=[]
 303         self.children[parent].append(child)
 304         wxTreeModel.AddChild(self, parent, child)
 305         return child
 306
 307     def RemoveNode(self, node):
 308         parent = self.parents[node]
 309         del self.parents[node]
 310         self.children[parent].remove(node)
 311         wxTreeModel.RemoveNode(self, node)
 312
 313     def InsertChild(self, parent, child, index):
 314         self.parents[child]=parent
 315         if not self.children.has_key(parent):
 316             self.children[parent]=[]
 317         self.children[parent].insert(child, index)
 318         wxTreeModel.InsertChild(self, parent, child, index)
 319         return child
 320
 321     def IsLeaf(self, node):
 322         return not self.children.has_key(node)
 323
 324     def IsEditable(self, node):
 325         return false
 326
 327     def SetEditable(self, node, bool):
 328         return false
 329
 330
 331 class FileEditor(Editor):
 332     def Edit(self, node):
 333         treenode = self.tree.nodemap[node]
 334         self.editcomp = wxTextCtrl(self.tree, -1)
 335         for rect in self.tree.painter.rectangles:
 336             if rect[0] == treenode:
 337                 self.editcomp.SetPosition((rect[1][0], rect[1][1]))
 338                 break
 339         self.editcomp.SetValue(node.fileName)
 340         self.editcomp.SetSelection(0, len(node.fileName))
 341         self.editcomp.SetFocus()
 342         self.treenode = treenode
 343 #        EVT_KEY_DOWN(self.editcomp, self._key)
 344         EVT_KEY_UP(self.editcomp, self._key)
 345         EVT_LEFT_DOWN(self.editcomp, self._mdown)
 346         self.editcomp.CaptureMouse()
 347
 348     def CanEdit(self, node):
 349         return isinstance(node, FileWrapper)
 350
 351     def EndEdit(self, commit):
 352         if not self.tree._EditEnding(self.treenode.data):
 353             return
 354         if commit:
 355             node = self.treenode.data
 356             try:
 357                 os.rename(node.path + os.sep + node.fileName, node.path + os.sep + self.editcomp.GetValue())
 358                 node.fileName = self.editcomp.GetValue()
 359             except:
 360                 traceback.print_exc()
 361         self.editcomp.ReleaseMouse()
 362         self.editcomp.Destroy()
 363         del self.editcomp
 364         self.tree.Refresh()
 365
 366
 367     def _key(self, evt):
 368         if evt.KeyCode() == WXK_RETURN:
 369             self.EndEdit(true)
 370         elif evt.KeyCode() == WXK_ESCAPE:
 371             self.EndEdit(false)
 372         else:
 373             evt.Skip()
 374
 375     def _mdown(self, evt):
 376         if evt.IsButton():
 377             pos = evt.GetPosition()
 378             edsize = self.editcomp.GetSize()
 379             if pos.x < 0 or pos.y < 0 or pos.x > edsize.width or pos.y > edsize.height:
 380                 self.EndEdit(false)
 381
 382
 383 class FileWrapper:
 384     """
 385     Node class for FSTreeModel.
 386     """
 387     def __init__(self, path, fileName):
 388         self.path = path
 389         self.fileName = fileName
 390
 391     def __str__(self):
 392         return self.fileName
 393
 394 class FSTreeModel(BasicTreeModel):
 395     """
 396     This treemodel models the filesystem starting from a given path.
 397     """
 398     def __init__(self, path):
 399         BasicTreeModel.__init__(self)
 400         import string
 401         fw = FileWrapper(path, string.split(path, os.sep)[-1])
 402         self._Build(path, fw)
 403         self.SetRoot(fw)
 404         self._editable = true
 405     def _Build(self, path, fileWrapper):
 406         for name in os.listdir(path):
 407             fw = FileWrapper(path, name)
 408             self.AddChild(fileWrapper, fw)
 409             childName = path + os.sep + name
 410             if os.path.isdir(childName):
 411                 self._Build(childName, fw)
 412
 413     def IsEditable(self, node):
 414         return self._editable
 415
 416     def SetEditable(self, node, bool):
 417         self._editable = bool
 418
 419 class LateFSTreeModel(FSTreeModel):
 420     """
 421     This treemodel models the filesystem starting from a given path.
 422     It retrieves the directory list as requested.
 423     """
 424     def __init__(self, path):
 425         BasicTreeModel.__init__(self)
 426         import string
 427         name = string.split(path, os.sep)[-1]
 428         pathpart = path[:-len(name)]
 429         fw = FileWrapper(pathpart, name)
 430         self._Build(path, fw)
 431         self.SetRoot(fw)
 432         self._editable = true
 433         self.children = {}
 434         self.parents = {}
 435     def _Build(self, path, parent):
 436         ppath = parent.path + os.sep + parent.fileName
 437         if not os.path.isdir(ppath):
 438             return
 439         for name in os.listdir(ppath):
 440             fw = FileWrapper(ppath, name)
 441             self.AddChild(parent, fw)
 442     def GetChildCount(self, node):
 443         if self.children.has_key(node):
 444             return FSTreeModel.GetChildCount(self, node)
 445         else:
 446             self._Build(node.path, node)
 447             return FSTreeModel.GetChildCount(self, node)
 448
 449     def IsLeaf(self, node):
 450         return not os.path.isdir(node.path + os.sep + node.fileName)
 451
 452 class StrTextConverter(TextConverter):
 453     def Convert(self, node):
 454         return str(node.data)
 455
 456 class NullTransform(Transform):
 457     def GetSize(self):
 458         return tuple(self.size)
 459
 460     def Transform(self, node, offset, rotation):
 461         self.size = [0,0]
 462         list = self.tree.GetLayoutEngine().GetNodeList()
 463         for node in list:
 464             node.projx = node.x + offset[0]
 465             node.projy = node.y + offset[1]
 466             if node.projx > self.size[0]:
 467                 self.size[0] = node.projx
 468             if node.projy > self.size[1]:
 469                 self.size[1] = node.projy
 470
 471 class Rect:
 472     def __init__(self, x, y, width, height):
 473         self.x = x
 474         self.y = y
 475         self.width = width
 476         self.height = height
 477     def __getitem__(self, index):
 478         return (self.x, self.y, self.width, self.height)[index]
 479
 480     def __setitem__(self, index, value):
 481         name = ['x', 'y', 'width', 'height'][index]
 482         setattr(self, name, value)
 483
 484     def Contains(self, other):
 485         if type(other) == type(()):
 486             other = Rect(other[0], other[1], 0, 0)
 487         if other.x >= self.x:
 488             if other.y >= self.y:
 489                 if other.width + other.x <= self.width + self.x:
 490                     if other.height + other.y  <= self.height + self.y:
 491                         return true
 492         return false
 493
 494     def __str__(self):
 495         return "Rect: " + str([self.x, self.y, self.width, self.height])
 496
 497 class TreeLayout(LayoutEngine):
 498     def SetHeight(self, num):
 499         self.NODE_HEIGHT = num
 500
 501     def __init__(self, tree):
 502         LayoutEngine.__init__(self, tree)
 503         self.NODE_STEP = 20
 504         self.NODE_HEIGHT = 20
 505         self.nodelist = []
 506
 507     def Layout(self, node):
 508         self.nodelist = []
 509         self.NODE_HEIGHT = self.tree.GetFont().GetPointSize() * 2
 510         self.layoutwalk(node)
 511
 512     def GetNodeList(self):
 513         return self.nodelist
 514
 515     def layoutwalk(self, node):
 516         if node == self.tree.currentRoot:
 517             node.level = 1
 518             self.lastY = (-self.NODE_HEIGHT)
 519         node.x = self.NODE_STEP * node.level
 520         node.y = self.lastY + self.NODE_HEIGHT
 521         self.lastY = node.y
 522         self.nodelist.append(node)
 523         if node.expanded:
 524             for kid in node.kids:
 525                 kid.level = node.level + 1
 526                 self.layoutwalk(kid)
 527
 528 class TreePainter(Painter):
 529     """
 530     The default painter class. Uses double-buffering, delegates the painting of nodes and
 531     lines to helper classes deriving from NodePainter and LinePainter.
 532     """
 533     def __init__(self, tree, nodePainter = None, linePainter = None, textConverter = None):
 534         Painter.__init__(self, tree)
 535         if not nodePainter:
 536             nodePainter = TreeNodePainter(self)
 537         self.nodePainter = nodePainter
 538         if not linePainter:
 539             linePainter = TreeLinePainter(self)
 540         self.linePainter = linePainter
 541         if not textConverter:
 542             textConverter = StrTextConverter(self)
 543         self.textConverter = textConverter
 544         self.charWidths = []
 545
 546     def Paint(self, dc, node, doubleBuffered=1, paintBackground=1):
 547         if not self.charWidths:
 548             self.charWidths = []
 549             for i in range(25):
 550                 self.charWidths.append(dc.GetTextExtent("D")[0] * i)
 551             self.charHeight = dc.GetTextExtent("D")[1]
 552         self.textpen = wxPen(self.GetTextColour(), 1, wxSOLID)
 553         self.fgpen = wxPen(self.GetForegroundColour(), 1, wxSOLID)
 554         self.bgpen = wxPen(self.GetBackgroundColour(), 1, wxSOLID)
 555         self.linepen = wxPen(self.GetLineColour(), 1, wxSOLID)
 556         self.dashpen = wxPen(self.GetLineColour(), 1, wxDOT)
 557         self.textbrush = wxBrush(self.GetTextColour(), wxSOLID)
 558         self.fgbrush = wxBrush(self.GetForegroundColour(), wxSOLID)
 559         self.bgbrush = wxBrush(self.GetBackgroundColour(), wxSOLID)
 560         self.linebrush = wxPen(self.GetLineColour(), 1, wxSOLID)
 561         treesize = self.tree.GetSize()
 562         size = self.tree.transform.GetSize()
 563         size = (max(treesize.width, size[0]+50), max(treesize.height, size[1]+50))
 564         dc.BeginDrawing()
 565         if doubleBuffered:
 566             mem_dc = wxMemoryDC()
 567             if not self.GetBuffer():
 568                 self.knobs = []
 569                 self.rectangles = []
 570                 self.bmp = wxEmptyBitmap(size[0], size[1])
 571                 mem_dc.SelectObject(self.GetBuffer())
 572                 mem_dc.SetPen(self.GetBackgroundPen())
 573                 mem_dc.SetBrush(self.GetBackgroundBrush())
 574                 mem_dc.DrawRectangle(0, 0, size[0], size[1])
 575                 mem_dc.SetFont(self.tree.GetFont())
 576                 self.paintWalk(node, mem_dc)
 577             else:
 578                 mem_dc.SelectObject(self.GetBuffer())
 579             xstart, ystart = self.tree.CalcUnscrolledPosition(0,0)
 580             size = self.tree.GetClientSizeTuple()
 581             dc.Blit(xstart, ystart, size[0], size[1], mem_dc, xstart, ystart)
 582         else:
 583             if node == self.tree.currentRoot:
 584                 self.knobs = []
 585                 self.rectangles = []
 586             dc.SetPen(self.GetBackgroundPen())
 587             dc.SetBrush(self.GetBackgroundBrush())
 588             dc.SetFont(self.tree.GetFont())
 589             if paintBackground:
 590                 dc.DrawRectangle(0, 0, size[0], size[1])
 591             if node:
 592                 #Call with not paintBackground because if we are told not to paint the
 593                 #whole background, we have to paint in parts to undo selection coloring.
 594                 pb = paintBackground
 595                 self.paintWalk(node, dc, not pb)
 596         dc.EndDrawing()
 597
 598     def GetDashPen(self):
 599         return self.dashpen
 600
 601     def SetLinePen(self, pen):
 602         Painter.SetLinePen(self, pen)
 603         self.dashpen = wxPen(pen.GetColour(), 1, wxDOT)
 604
 605     def paintWalk(self, node, dc, paintRects=0):
 606         self.linePainter.Paint(node.parent, node, dc)
 607         self.nodePainter.Paint(node, dc, drawRects = paintRects)
 608         if node.expanded:
 609             for kid in node.kids:
 610                 if not self.paintWalk(kid, dc, paintRects):
 611                     return false
 612             for kid in node.kids:
 613                 px = (kid.projx - self.tree.layout.NODE_STEP) + 5
 614                 py = kid.projy + kid.height/2
 615                 if (not self.tree.model.IsLeaf(kid.data)) or ((kid.expanded or self.tree._assumeChildren) and len(kid.kids)):
 616                     dc.SetPen(self.linepen)
 617                     dc.SetBrush(self.bgbrush)
 618                     dc.DrawRectangle(px -4, py-4, 9, 9)
 619                     self.knobs.append(kid, Rect(px -4, py -4, 9, 9))
 620                     dc.SetPen(self.textpen)
 621                     if not kid.expanded:
 622                         dc.DrawLine(px, py -2, px, py + 3)
 623                     dc.DrawLine(px -2, py, px + 3, py)
 624         if node == self.tree.currentRoot:
 625             px = (node.projx - self.tree.layout.NODE_STEP) + 5
 626             py = node.projy + node.height/2
 627             dc.SetPen(self.linepen)
 628             dc.SetBrush(self.bgbrush)
 629             dc.DrawRectangle(px -4, py-4, 9, 9)
 630             self.knobs.append(node, Rect(px -4, py -4, 9, 9))
 631             dc.SetPen(self.textpen)
 632             if not node.expanded:
 633                 dc.DrawLine(px, py -2, px, py + 3)
 634             dc.DrawLine(px -2, py, px + 3, py)
 635         return true
 636
 637     def OnMouse(self, evt):
 638         Painter.OnMouse(self, evt)
 639
 640 class TreeNodePainter(NodePainter):
 641     def Paint(self, node, dc, location = None, drawRects = 0):
 642         text = self.painter.textConverter.Convert(node)
 643         extent = dc.GetTextExtent(text)
 644         node.width = extent[0]
 645         node.height = extent[1]
 646         if node.selected:
 647             dc.SetPen(self.painter.GetLinePen())
 648             dc.SetBrush(self.painter.GetForegroundBrush())
 649             dc.SetTextForeground(wxNamedColour("WHITE"))
 650             dc.DrawRectangle(node.projx -1, node.projy -1, node.width + 3, node.height + 3)
 651         else:
 652             if drawRects:
 653                 dc.SetBrush(self.painter.GetBackgroundBrush())
 654                 dc.SetPen(self.painter.GetBackgroundPen())
 655                 dc.DrawRectangle(node.projx -1, node.projy -1, node.width + 3, node.height + 3)
 656             dc.SetTextForeground(self.painter.GetTextColour())
 657         dc.DrawText(text, node.projx, node.projy)
 658         self.painter.rectangles.append((node, Rect(node.projx, node.projy, node.width, node.height)))
 659
 660 class TreeLinePainter(LinePainter):
 661     def Paint(self, parent, child, dc):
 662         dc.SetPen(self.painter.GetDashPen())
 663         px = py = cx = cy = 0
 664         if parent is None or child == self.painter.tree.currentRoot:
 665             px = (child.projx - self.painter.tree.layout.NODE_STEP) + 5
 666             py = child.projy + self.painter.tree.layout.NODE_HEIGHT/2 -2
 667             cx = child.projx
 668             cy = py
 669             dc.DrawLine(px, py, cx, cy)
 670         else:
 671             px = parent.projx + 5
 672             py = parent.projy + parent.height
 673             cx = child.projx -5
 674             cy = child.projy + self.painter.tree.layout.NODE_HEIGHT/2 -3
 675             dc.DrawLine(px, py, px, cy)
 676             dc.DrawLine(px, cy, cx, cy)
 677
 678
 679 wxEVT_MVCTREE_BEGIN_EDIT = 20204 #Start editing. Vetoable.
 680 wxEVT_MVCTREE_END_EDIT = 20205 #Stop editing. Vetoable.
 681 wxEVT_MVCTREE_DELETE_ITEM = 20206 #Item removed from model.
 682 wxEVT_MVCTREE_ITEM_EXPANDED = 20209
 683 wxEVT_MVCTREE_ITEM_EXPANDING = 20210
 684 wxEVT_MVCTREE_ITEM_COLLAPSED = 20211
 685 wxEVT_MVCTREE_ITEM_COLLAPSING = 20212
 686 wxEVT_MVCTREE_SEL_CHANGED = 20213
 687 wxEVT_MVCTREE_SEL_CHANGING = 20214 #Vetoable.
 688 wxEVT_MVCTREE_KEY_DOWN = 20215
 689 wxEVT_MVCTREE_ADD_ITEM = 20216 #Item added to model.
 690
 691 def EVT_MVCTREE_SEL_CHANGED(win, id, func):
 692     win.Connect(id, -1, wxEVT_MVCTREE_SEL_CHANGED, func)
 693
 694 def EVT_MVCTREE_SEL_CHANGING(win, id, func):
 695     win.Connect(id, -1, wxEVT_MVCTREE_SEL_CHANGING, func)
 696
 697 def EVT_MVCTREE_ITEM_EXPANDED(win, id, func):
 698     win.Connect(id, -1, wxEVT_MVCTREE_ITEM_EXPANDED, func)
 699
 700 def EVT_MVCTREE_ITEM_EXPANDING(win, id, func):
 701     win.Connect(id, -1, wxEVT_MVCTREE_ITEM_EXPANDING, func)
 702
 703 def EVT_MVCTREE_ITEM_COLLAPSED(win, id, func):
 704     win.Connect(id, -1, wxEVT_MVCTREE_ITEM_COLLAPSED, func)
 705
 706 def EVT_MVCTREE_ITEM_COLLAPSING(win, id, func):
 707     win.Connect(id, -1, wxEVT_MVCTREE_ITEM_COLLAPSING, func)
 708
 709 def EVT_MVCTREE_ADD_ITEM(win, id, func):
 710     win.Connect(id, -1, wxEVT_MVCTREE_ADD_ITEM, func)
 711
 712 def EVT_MVCTREE_DELETE_ITEM(win, id, func):
 713     win.Connect(id, -1, wxEVT_MVCTREE_DELETE_ITEM, func)
 714
 715 def EVT_MVCTREE_KEY_DOWN(win, id, func):
 716     win.Connect(id, -1, wxEVT_MVCTREE_KEY_DOWN, func)
 717
 718
 719 class wxMVCTreeEvent(wxPyCommandEvent):
 720     def __init__(self, type, id, node = None, nodes = None, keyEvent = None, **kwargs):
 721         apply(wxPyCommandEvent.__init__, (self, type, id), kwargs)
 722         self.node = node
 723         self.nodes = nodes
 724         self.keyEvent = keyEvent
 725     def GetNode(self):
 726         return self.node
 727     def GetNodes(self):
 728         return self.nodes
 729     def getKeyEvent(self):
 730         return self.keyEvent
 731
 732 class wxMVCTreeNotifyEvent(wxMVCTreeEvent):
 733     def __init__(self, type, id, node = None, nodes = None, **kwargs):
 734         apply(wxMVCTreeEvent.__init__, (self, type, id), kwargs)
 735         self.notify = wxNotifyEvent(type, id)
 736     def getNotifyEvent(self):
 737         return self.notify
 738
 739 class wxMVCTree(wxScrolledWindow):
 740     """
 741     The main mvc tree class.
 742     """
 743     def __init__(self, parent, id, model = None, layout = None, transform = None,
 744                  painter = None, *args, **kwargs):
 745         apply(wxScrolledWindow.__init__, (self, parent, id), kwargs)
 746         self.nodemap = {}
 747         self._multiselect = false
 748         self._selections = []
 749         self._assumeChildren = false
 750         self._scrollx = false
 751         self._scrolly = false
 752         self.doubleBuffered = false
 753         self._lastPhysicalSize = self.GetSize()
 754         self._editors = []
 755         if not model:
 756             model = BasicTreeModel()
 757             model.SetRoot("Root")
 758         self.SetModel(model)
 759         if not layout:
 760             layout = TreeLayout(self)
 761         self.layout = layout
 762         if not transform:
 763            transform = NullTransform(self)
 764         self.transform = transform
 765         if not painter:
 766             painter = TreePainter(self)
 767         self.painter = painter
 768         self.SetFont(wxFont(9, wxDEFAULT, wxNORMAL, wxNORMAL, false))
 769         EVT_MOUSE_EVENTS(self, self.OnMouse)
 770         EVT_KEY_DOWN(self, self.OnKeyDown)
 771         self.doubleBuffered = true
 772
 773
 774     def Refresh(self):
 775         if self.doubleBuffered:
 776             self.painter.ClearBuffer()
 777         wxScrolledWindow.Refresh(self, false)
 778
 779     def GetPainter(self):
 780         return self.painter
 781
 782     def GetLayoutEngine(self):
 783         return self.layout
 784
 785     def GetTransform(self):
 786         return self.transform
 787
 788     def __repr__(self):
 789         return "<wxMVCTree instance at %s>" % str(hex(id(self)))
 790
 791     def __str__(self):
 792         return self.__repr__()
 793
 794     def NodeAdded(self, parent, child):
 795         e = wxMVCTreeEvent(wxEVT_MVCTREE_ADD_ITEM, self.GetId(), node = child, nodes = [parent, child])
 796         self.GetEventHandler().ProcessEvent(e)
 797         self.painter.ClearBuffer()
 798
 799     def NodeInserted(self, parent, child, index):
 800         e = wxMVCTreeEvent(wxEVT_MVCTREE_ADD_ITEM, self.GetId(), node = child, nodes = [parent, child])
 801         self.GetEventHandler().ProcessEvent(e)
 802         self.painter.ClearBuffer()
 803     def NodeRemoved(self, node):
 804         e = wxMVCTreeEvent(wxEVT_MVCTREE_DELETE_ITEM, self.GetId(), node = child, nodes = [parent, child])
 805         self.GetEventHandler().ProcessEvent(e)
 806         self.painter.ClearBuffer()
 807     def OnKeyDown(self, evt):
 808         e = wxMVCTreeEvent(wxEVT_MVCTREE_KEY_DOWN, self.GetId(), keyEvent = evt)
 809         self.GetEventHandler().ProcessEvent(e)
 810
 811     def SetFont(self, font):
 812         self.painter.SetFont(font)
 813         dc = wxClientDC(self)
 814         dc.SetFont(font)
 815         self.layout.SetHeight(dc.GetTextExtent("")[1] + 18)
 816         self.painter.ClearBuffer()
 817     def GetFont(self):
 818         return self.painter.GetFont()
 819
 820     def AddEditor(self, editor):
 821         self._editors.append(editor)
 822
 823     def RemoveEditor(self, editor):
 824         self._editors.remove(editor)
 825
 826     def OnMouse(self, evt):
 827         self.painter.OnMouse(evt)
 828
 829     def OnNodeClick(self, node, mouseEvent):
 830         if node.selected and (self.IsMultiSelect() and mouseEvent.ControlDown()):
 831             self.RemoveFromSelection(node.data)
 832         else:
 833             self.AddToSelection(node.data, mouseEvent.ControlDown(), mouseEvent.ShiftDown())
 834
 835     def OnKnobClick(self, node):
 836         self.SetExpanded(node.data, not node.expanded)
 837
 838     def GetDisplayText(self, node):
 839         treenode = self.nodemap[node]
 840         return self.painter.textConverter.Convert(treenode)
 841
 842     def IsDoubleBuffered(self):
 843         return self.doubleBuffered
 844
 845     def SetDoubleBuffered(self, bool):
 846         """
 847         By default wxMVCTree is double-buffered.
 848         """
 849         self.doubleBuffered = bool
 850
 851     def GetModel(self):
 852         return self.model
 853
 854     def SetModel(self, model):
 855         """
 856         Completely change the data to be displayed.
 857         """
 858         self.model = model
 859         model.tree = self
 860         self.laidOut = 0
 861         self.transformed = 0
 862         self._selections = []
 863         self.layoutRoot = MVCTreeNode()
 864         self.layoutRoot.data = self.model.GetRoot()
 865         self.layoutRoot.expanded = true
 866         self.LoadChildren(self.layoutRoot)
 867         self.currentRoot = self.layoutRoot
 868         self.offset = [0,0]
 869         self.rotation = 0
 870         self._scrollset = None
 871         self.Refresh()
 872
 873     def GetCurrentRoot(self):
 874         return self.currentRoot
 875
 876     def LoadChildren(self, layoutNode):
 877         if layoutNode.built:
 878             return
 879         else:
 880             self.nodemap[layoutNode.data]=layoutNode
 881             for i in range(self.GetModel().GetChildCount(layoutNode.data)):
 882                 p = MVCTreeNode("RAW", layoutNode, [])
 883                 layoutNode.Add(p)
 884                 p.data = self.GetModel().GetChildAt(layoutNode.data, i)
 885                 self.nodemap[p.data]=p
 886             layoutNode.built = true
 887             if not self._assumeChildren:
 888                 for kid in layoutNode.kids:
 889                     self.LoadChildren(kid)
 890
 891     def OnEraseBackground(self, evt):
 892         pass
 893
 894     def OnSize(self, evt):
 895         size = self.GetSize()
 896         self.center = (size.width/2, size.height/2)
 897         if self._lastPhysicalSize.width < size.width or self._lastPhysicalSize.height < size.height:
 898             self.painter.ClearBuffer()
 899         self._lastPhysicalSize = size
 900
 901     def GetSelection(self):
 902         "Returns a tuple of selected nodes."
 903         return tuple(self._selections)
 904
 905     def SetSelection(self, nodeTuple):
 906         if type(nodeTuple) != type(()):
 907             nodeTuple = (nodeTuple,)
 908         e = wxMVCTreeNotifyEvent(wxEVT_MVCTREE_SEL_CHANGING, self.GetId(), nodeTuple[0], nodes = nodeTuple)
 909         self.GetEventHandler().ProcessEvent(e)
 910         if not e.notify.IsAllowed():
 911             return
 912         for node in nodeTuple:
 913             treenode = self.nodemap[node]
 914             treenode.selected = true
 915         for node in self._selections:
 916             treenode = self.nodemap[node]
 917             node.selected = false
 918         self._selections = list(nodeTuple)
 919         e = wxMVCTreeEvent(wxEVT_MVCTREE_SEL_CHANGED, self.GetId(), nodeTuple[0], nodes = nodeTuple)
 920         self.GetEventHandler().ProcessEvent(e)
 921
 922     def IsMultiSelect(self):
 923         return self._multiselect
 924
 925     def SetMultiSelect(self, bool):
 926         self._multiselect = bool
 927
 928     def IsSelected(self, node):
 929         return self.nodemap[node].selected
 930
 931     def Edit(self, node):
 932         if not self.model.IsEditable(node):
 933             return
 934         for ed in self._editors:
 935             if ed.CanEdit(node):
 936                 e = wxMVCTreeNotifyEvent(wxEVT_MVCTREE_BEGIN_EDIT, self.GetId(), node)
 937                 self.GetEventHandler().ProcessEvent(e)
 938                 if not e.notify.IsAllowed():
 939                     return
 940                 ed.Edit(node)
 941                 self._currentEditor = ed
 942                 break
 943
 944     def EndEdit(self):
 945         if self._currentEditor:
 946             self._currentEditor.EndEdit
 947             self._currentEditor = None
 948
 949     def _EditEnding(self, node):
 950         e = wxMVCTreeNotifyEvent(wxEVT_MVCTREE_END_EDIT, self.GetId(), node)
 951         self.GetEventHandler().ProcessEvent(e)
 952         if not e.notify.IsAllowed():
 953             return false
 954         self._currentEditor = None
 955         return true
 956
 957
 958     def SetExpanded(self, node, bool):
 959         treenode = self.nodemap[node]
 960         if bool:
 961             e = wxMVCTreeNotifyEvent(wxEVT_MVCTREE_ITEM_EXPANDING, self.GetId(), node)
 962             self.GetEventHandler().ProcessEvent(e)
 963             if not e.notify.IsAllowed():
 964                 return
 965             if not treenode.built:
 966                 self.LoadChildren(treenode)
 967         else:
 968             e = wxMVCTreeNotifyEvent(wxEVT_MVCTREE_ITEM_COLLAPSING, self.GetId(), node)
 969             self.GetEventHandler().ProcessEvent(e)
 970             if not e.notify.IsAllowed():
 971                 return
 972         treenode.expanded = bool
 973         e = None
 974         if treenode.expanded:
 975             e = wxMVCTreeEvent(wxEVT_MVCTREE_ITEM_EXPANDED, self.GetId(), node)
 976         else:
 977             e = wxMVCTreeEvent(wxEVT_MVCTREE_ITEM_COLLAPSED, self.GetId(), node)
 978         self.GetEventHandler().ProcessEvent(e)
 979         self.layout.Layout(self.currentRoot)
 980         self.transform.Transform(self.currentRoot, self.offset, self.rotation)
 981         self.Refresh()
 982
 983     def IsExpanded(self, node):
 984         return self.nodemap[node].expanded
 985
 986     def AddToSelection(self, nodeOrTuple, enableMulti = true, shiftMulti = false):
 987         nodeTuple = nodeOrTuple
 988         if type(nodeOrTuple)!= type(()):
 989             nodeTuple = (nodeOrTuple,)
 990         e = wxMVCTreeNotifyEvent(wxEVT_MVCTREE_SEL_CHANGING, self.GetId(), nodeTuple[0], nodes = nodeTuple)
 991         self.GetEventHandler().ProcessEvent(e)
 992         if not e.notify.IsAllowed():
 993             return
 994         changeparents = []
 995         if not (self.IsMultiSelect() and (enableMulti or shiftMulti)):
 996             for node in self._selections:
 997                 treenode = self.nodemap[node]
 998                 treenode.selected = false
 999                 changeparents.append(treenode)
1000             node = nodeTuple[0]
1001             self._selections = [node]
1002             treenode = self.nodemap[node]
1003             changeparents.append(treenode)
1004             treenode.selected = true
1005         else:
1006             if shiftMulti:
1007                 for node in nodeTuple:
1008                     treenode = self.nodemap[node]
1009                     oldtreenode = self.nodemap[self._selections[0]]
1010                     if treenode.parent == oldtreenode.parent:
1011                         found = 0
1012                         for kid in oldtreenode.parent.kids:
1013                             if kid == treenode or kid == oldtreenode:
1014                                 found = not found
1015                                 kid.selected = true
1016                                 self._selections.append(kid.data)
1017                                 changeparents.append(kid)
1018                             elif found:
1019                                 kid.selected = true
1020                                 self._selections.append(kid.data)
1021                                 changeparents.append(kid)
1022             else:
1023                 for node in nodeTuple:
1024                     try:
1025                         self._selections.index(node)
1026                     except ValueError:
1027                         self._selections.append(node)
1028                         treenode = self.nodemap[node]
1029                         treenode.selected = true
1030                         changeparents.append(treenode)
1031         e = wxMVCTreeEvent(wxEVT_MVCTREE_SEL_CHANGED, self.GetId(), nodeTuple[0], nodes = nodeTuple)
1032         self.GetEventHandler().ProcessEvent(e)
1033         dc = wxClientDC(self)
1034         self.PrepareDC(dc)
1035         for node in changeparents:
1036             if node:
1037                 self.painter.Paint(dc, node, doubleBuffered = 0, paintBackground = 0)
1038         self.painter.ClearBuffer()
1039
1040     def RemoveFromSelection(self, nodeTuple):
1041         if type(nodeTuple) != type(()):
1042             nodeTuple = (nodeTuple,)
1043         changeparents = []
1044         for node in nodeTuple:
1045             self._selections.remove(node)
1046             treenode = self.nodemap[node]
1047             changeparents.append(treenode)
1048             treenode.selected = false
1049         e = wxMVCTreeEvent(wxEVT_MVCTREE_SEL_CHANGED, self.GetId(), node, nodes = nodeTuple)
1050         self.GetEventHandler().ProcessEvent(e)
1051         dc = wxClientDC(self)
1052         self.PrepareDC(dc)
1053         for node in changeparents:
1054             if node:
1055                 self.painter.Paint(dc, node, doubleBuffered = 0, paintBackground = 0)
1056         self.painter.ClearBuffer()
1057
1058
1059     def GetBackgroundColour(self):
1060         if hasattr(self, 'painter') and self.painter:
1061             return self.painter.GetBackgroundColour()
1062         else:
1063             return wxWindow.GetBackgroundColour(self)
1064     def SetBackgroundColour(self, color):
1065         if hasattr(self, 'painter') and self.painter:
1066             self.painter.SetBackgroundColour(color)
1067         else:
1068             wxWindow.SetBackgroundColour(self, color)
1069     def GetForegroundColour(self):
1070         if hasattr(self, 'painter') and self.painter:
1071             return self.painter.GetForegroundColour()
1072         else:
1073             return wxWindow.GetBackgroundColour(self)
1074     def SetForegroundColour(self, color):
1075         if hasattr(self, 'painter') and self.painter:
1076             self.painter.SetForegroundColour(color)
1077         else:
1078             wxWindow.SetBackgroundColour(self, color)
1079
1080     def SetAssumeChildren(self, bool):
1081         self._assumeChildren = bool
1082
1083     def GetAssumeChildren(self):
1084         return self._assumeChildren
1085
1086     def OnPaint(self, evt):
1087         """
1088         Ensures that the tree has been laid out and transformed, then calls the painter
1089         to paint the control.
1090         """
1091         try:
1092             self.EnableScrolling(false, false)
1093             if not self.laidOut:
1094                 self.layout.Layout(self.currentRoot)
1095                 self.laidOut = true
1096                 self.transformed = false
1097             if not self.transformed:
1098                 self.transform.Transform(self.currentRoot, self.offset, self.rotation)
1099                 self.transformed = true
1100             tsize = None
1101             tsize = list(self.transform.GetSize())
1102             tsize[0] = tsize[0] + 50
1103             tsize[1] = tsize[1] + 50
1104             size = self.GetSizeTuple()
1105             if tsize[0] > size[0] or tsize[1] > size[1]:
1106                 if not hasattr(self, '_oldsize') or (tsize[0] > self._oldsize[0] or tsize[1] > self._oldsize[1]):
1107                     self._oldsize = tsize
1108                     oldstart = self.ViewStart()
1109                     self._lastPhysicalSize = self.GetSize()
1110                     self.SetScrollbars(10, 10, tsize[0]/10, tsize[1]/10)
1111                     self.Scroll(oldstart[0], oldstart[1])
1112             dc = wxPaintDC(self)
1113             self.PrepareDC(dc)
1114             dc.SetFont(self.GetFont())
1115             self.painter.Paint(dc, self.currentRoot, self.doubleBuffered)
1116         except:
1117             traceback.print_exc()
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129