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