# Copyright 2004-2007 Nanorex, Inc. See LICENSE file for details. """ TreeView.py -- NO LONGER USED IN Qt4 NE1 -- display and update, for a tree widget based on QTreeView, and meant to display Nodes (with interface and semantics as in Utility.py). Assumes each node is shown in at most one place in the widget. This could in theory be changed (see code for details). $Id$ History: modelTree.py was originally written by some combination of Huaicai, Josh, and Mark. Bruce (Jan 2005) reorganized its interface with Node and Group and their subclasses (Utility.py and other modules) and rewrote a lot of the model-tree code (to fix bugs and add features), and split it into three modules: - TreeView.py (display and update), - TreeWidget.py (event handling, and some conventions suitable for all our tree widgets, if we define other ones), and - modelTree.py (customized for showing a "model tree" per se). """ assert 0, "TreeView.py is NO LONGER USED IN Qt4 NE1" #bruce 070503 Qt4 debug_painting = 0 ###@@@ DO NOT COMMIT with 1 debug_mt_updates = 0 ###@@@ DO NOT COMMIT with 1 debug_prints = 0 # whether atom_debug enables dprint; ok to commit with 0 or 1 ###@@@ some of these imports are only needed by subclasses from PyQt4.Qt import * from constants import * from chem import * from jigs import * from Utility import * from foundation.Group import Group import sys, os, time from utilities import debug_flags from qt4transition import * class ModelTreeItem(QItemDelegate): def __init__(self, name, parent, node): QItemDelegate.__init__(self) self.parentItem = parent self.name = name self.object = node self.icon = None self.childItems = [ ] def __repr__(self): return "" % (id(self), self.name) def text(self, column): raise Exception() def setIcon(self, icon): self.icon = icon def row(self): try: return self.parentItem.childItems.index(self) except: return 0 def appendChild(self, x): self.childItems.append(x) def paint(self, painter, option, index): item = index.internalPointer() x, y = option.rect.x(), option.rect.y() selected = (index in self.view.selectedIndexes()) if selected: # before background = painter.background() backgroundMode = painter.backgroundMode() painter.setBackground(self.view.palette().highlight()) painter.setBackgroundMode(Qt.OpaqueMode) if item.object.is_disabled(): # before painter.shear(0, -0.5) painter.translate(0.5 * y + 4, 0.0) painter.drawPixmap(x, y, item.icon.pixmap(16, 16)) painter.drawText(x + 20, y + 12, item.name) if item.object.is_disabled(): # after painter.translate(-0.5 * y - 4, 0.0) painter.shear(0, 0.5) if selected: # after painter.setBackground(background) painter.setBackgroundMode(backgroundMode) def _paint(self, painter, option, index): item = index.internalPointer() x, y = option.rect.x(), option.rect.y() # What's failing here is not the display mechanism. Set this flag # to True and all distance measurement jigs will be shown as disabled. # The problem is with the context menu in modelTree.py, which is not # doing the right thing with the cm_disable method somehow. The 'Disable' # option appears in the context menu, but when you choose it, cm_disable # does not get called, as verified by putting a print statement in it. TEST_TO_SEE_IF_DISABLED_DISPLAY_WORKS = False if TEST_TO_SEE_IF_DISABLED_DISPLAY_WORKS: if item.name.startswith("Distance"): def is_disabled(): return True item.object.is_disabled = is_disabled if item.object.is_disabled(): # Apply shear or other effects for "Hidden" and "Disabled" and "Selected" painter.shear(0, -0.5) painter.translate(0.5 * y + 4, 0.0) if item.icon is not None: painter.drawPixmap(x, y, item.icon.pixmap(16, 16)) painter.drawText(x + 20, y + 12, item.name) painter.translate(-0.5 * y - 4, 0.0) painter.shear(0, 0.5) else: if item.icon is not None: painter.drawPixmap(x, y, item.icon.pixmap(16, 16)) painter.drawText(x + 20, y + 12, item.name) def pr(self, indent=""): print indent, self for x in self.childItems: x.pr(indent + " ") #################################################################### class ModelTreeModel(QAbstractItemModel): def __init__(self, rootItem=None): QAbstractItemModel.__init__(self) if rootItem is None: rootItem = ModelTreeItem('Model Tree', None, None) self.rootItem = rootItem def veryShallowClone(self): # # This is part of the magic to UPDATING the model tree. We # clone the model, and call setModel on the new guy. We can # use a very shallow clone for this, the QTreeView only needs # to see the pointer change. # return ModelTreeModel(self.rootItem) def pr(self): print self self.rootItem.pr(" ") # The following methods are the the official API required by # QTreeView's idea of how QAbstractItemModel should work. def columnCount(self, parent): return 1 def data(self, index, role): if not index.isValid(): return QVariant() if role != Qt.DisplayRole: return QVariant() item = index.internalPointer() return QVariant(item.name) def flags(self, index): if not index.isValid(): return Qt.ItemIsEnabled return Qt.ItemIsEnabled | Qt.ItemIsSelectable def headerData(self, section, orientation, role): if orientation == Qt.Horizontal and role == Qt.DisplayRole: return QVariant(self.rootItem.name) return QVariant() def index(self, row, column, parent): if not parent.isValid(): parentItem = self.rootItem else: parentItem = parent.internalPointer() if not hasattr(parentItem, 'childItems'): return QModelIndex() if row >= len(parentItem.childItems): return QModelIndex() childItem = parentItem.childItems[row] if childItem: return self.createIndex(row, column, childItem) else: return QModelIndex() def parent(self, index): if not index.isValid(): return QModelIndex() childItem = index.internalPointer() if not hasattr(childItem, 'parentItem'): return self.createIndex(0, 0, childItem) parentItem = childItem.parentItem if parentItem == self.rootItem: return QModelIndex() return self.createIndex(parentItem.row(), 0, parentItem) def rowCount(self, parent): if not parent.isValid(): parentItem = self.rootItem else: parentItem = parent.internalPointer() return len(parentItem.childItems) ################################## class TreeView(QTreeView): needs_update_state = 0 initialized = 0 ####@@@@ review use of this here vs in subclasses def __init__(self, parent, win, name = None, columns = ["node tree"], size = (100, 560)): ###@@@ review all init args & instvars, here vs subclasses """Create a TreeView (superclasses include QTreeView, QScrollView, QWidget). parent is the Qt widget parent. win (required) is our main window, stored in self.win and used for debug menu (by some subclasses). and for history messages (by subclasses -- not sure if also by this class). name is used by Qt as the widget name. #k columns is a list of column names (error if not at least one, if it's supplied). Note: we create all columns requested, but the present implem is only known to work for one column; some code in it only bothers trying to support one column (e.g. it assumes everything should be done only in column 0). """ assert False # we shouldn't be using TreeWidget or TreeView any more self.win = win self._node_items = {} QTreeView.__init__(self,parent) ###@@@ would any wflags be appropriate? # try doing these first, but if that fails, do them after columns are made [as before]: qt4skipit('self.setSorting(-1)') self.setRootIsDecorated(1) qt4skipit('self.setShowSortIndicator(0) # [this used to be done after setResizePolicy]') #self.columns = columns self.setItemsExpandable(True) self.model = model = ModelTreeModel() model.rootItem.view = self self.setModel(model) self.setItemDelegate(model.rootItem) self.expandAll() self.setSelectionMode(self.MultiSelection) ## self.addColumn("col2") # experiment - worked, but resulted in unwanted ## # sort indicator in col2 (with redraw bugs) [see QHeader in Qt docs?] ## ... might work better if done after we've turned off sorting. qt4todo('self.header().setClickEnabled(0, self.header().count() - 1) #k what\'s this?') # Qt doc says it's turning off the clicked signal for clicks in a certain # section header (which one? I don't know if count() is 1 or 2 for our one column.) # [some of the following might belong in a subclass or need to be influenced by one:] qt4skipit('self.setGeometry(QRect(0, 0, size[0], size[1]))') self.setMaximumWidth(200) # make a change needed by Geoff Leach [see his mail to cad 050304], # needed (at least back then) on his Linux system and/or Qt/PyQt installation # (this relates to some reported bug whose bug number I forget) # [bruce 050408] self.setSizePolicy(QSizePolicy(QSizePolicy.Fixed,QSizePolicy.Expanding)) qt4skipit('self.setShowToolTips(True)') # bruce 050109 added this; but it doesn't seem to work ###@@@ where is item.setExpandable? implicit?? # this is not safe to do here -- subclasses need to do it themselves! # if they forget, the symptom might be that no updates seem to happen. ## self.initialized = 1 ## self.mt_update() return # from TreeView.__init__ # invalidation function for use by external code # (and by some internal code in subclasses) def expandAll(self): # # With Qt 4.2, QTreeView will have its own expandAll method. # modelIndex = QModelIndex() while True: self.expand(modelIndex) modelIndex = self.indexBelow(modelIndex) if modelIndex.row() == -1: return def itemAt(self, qpoint): # emulate the equivalent function for QTreeView index = self.indexAt(qpoint) item = index.internalPointer() assert isinstance(item, ModelTreeItem) return item def visualItemRect(self, item): # get the index for this item index = self.model.createIndex(0, 0) while True: if index.internalPointer() == item: return self.visualRect(index) if index.row() == -1: # item wasn't found assert False index = self.indexBelow(index) def mt_update(self, nodetree = None): ###@@@ review name of this function, whether subclasses need to override it """External code (or event bindings in a subclass, if they don't do enough repainting themselves) should call this when it might have changed any state that should affect what's shown in the tree. (Specifically: the ordering or grouping of nodes, or the icons or text they should display, or their open or selected state.) (BTW external code probably has no business changing node.open since it is slated to become a tree- widget-specific state in the near future.) If these changes are known to be confined to a single node and its children, that node can be passed as a second argument as a possible optimization (though as of 050113 the current implem does not take advantage of this). """ if debug_mt_updates: print "debug_mt_updates: mt_update called" self.needs_update_state = 1 # we'll respond to this in our custom method during the next paintEvent if not self.updatesEnabled(): if debug_flags.atom_debug: print_compact_stack("atom_debug: stack in mt_update when not isUpdatesEnabled: ") # Force a repaint by changing the pointer to the model, using a shallow clone. self.model = self.model.veryShallowClone() self.model.rootItem.view = self self.setModel(self.model) self.expandAll() # debugging functions [might as well keep the commented-out ones around for awhile] _last_dprinttime_stamp = None def dprinttime(self): "call this to print a timestamp before every debug line for which the same time was never before printed" if not debug_prints: return if not debug_flags.atom_debug: return import time stamp = time.asctime() #e improve if stamp != self._last_dprinttime_stamp: print print stamp self._last_dprinttime_stamp = stamp return def dprint(self, msg): if not debug_prints: return if debug_flags.atom_debug: self.dprinttime() print msg return # update-related functions, and related event-processing # (not user input events -- those should be defined in subclasses) # (###@@@ #e though we might want to override them here to mask QTreeView from seeing them -- but maybe no need) def updateContents(self): if debug_prints: self.dprinttime() print "fyi: modelTree.updateContents() called (by Qt, maybe by triggerUpdate)" print_compact_stack("stack in updateContents(): ") self.update() def resize(self): #k does this get called? no. if debug_prints: self.dprinttime() print "fyi: modelTree.resize() called (by Qt, presumably)" print_compact_stack("stack in resize(): ") return QTreeView.resize(self) ###@@@ move this? for eventual use, into a subclass, but for debug use, keep a copy here... def drawbluething(self, painter, pos = (0,0), color = Qt.blue): # bruce 050110 taken from my local canvas_b2.py "[for debugging] draw a recognizable symbol in the given QPainter, at given position, of given color" p = painter # caller should have called begin on the widget, assuming that works p.setPen(QPen(color, 3)) # 3 is pen thickness w,h = 100,9 # bbox rect size of what we draw (i think) x,y = pos # topleft of what we draw p.drawEllipse(x,y,h,h) fudge_up = 1 # 1 for h = 9, 2 for h = 10 p.drawLine(x+h, y+h/2 - fudge_up, x+w, y+h/2 - fudge_up) def paintEvent(self, event): """[This (viewportPaintEvent) turns out to be the main redrawing event for a QTreeView (in Qt3) -- not that you can tell that from the Qt docs for it. """ self.update_state_iff_needed(event) return QTreeView.paintEvent(self, event) def update_state_iff_needed(self, event): if self.needs_update_state and self.initialized: # new code 050110, see if it fixes any bugs -- defer state updates # (but should we instead do it in updateContents so it happens before that?? and/or do that here??) ###@@@ did neither for now try: self.needs_update_state = 0 # in case of exception self.update_state(event) # used to be mt_update; event is not really needed i think self.needs_update_state = 0 # in case of bug that sets this during that call # [not sure this is good, but might avoid "infrepeat"] #e also call updateContents now? let's try it, see if it helps Group formation update bug: self.updateContents() ####k syntax and doc, for both qlistview and qscrollview ####@@@@ except: self.dprinttime() print_compact_traceback("exception in update_state() or updateContents(): ") self.repaint() ###@@@ move this comment down below: # main tree-remaking function (runs more often than it would need to in a more incremental implem) # bruce 050107 renamed this 'update' -> 'mt_update'; # then bruce 050110 renamed it 'update_state' and made it # no longer public, but called inside paintEvent(?) # when mt_update records the need for this def update_state(self, paintevent): """[private] Rebuild the tree of ModelTreeItems. Details in update_state_0 docstring. [no longer named update, since that conflicts with QWidget.update] """ # Qt doc makes it clear (well, at least deducible) # that disabling updates is not redundant here, # and it says other things which lead me to guess # that it might avoid infrecur from repaint by QTreeView, # and even if not, might reduce screen flicker or other problems. if debug_mt_updates: print "debug_mt_updates: update_state called" old_UpdatesEnabled = self.updatesEnabled() if not old_UpdatesEnabled: self.dprint( "atom_debug: not old_UpdatesEnabled") # error? self.setUpdatesEnabled( False) try: self.update_state_0( paintevent) finally: self.setUpdatesEnabled( old_UpdatesEnabled) self.update() # might cause infrepeat... try it anyway [seems to be ok] #e should be no need to do an update right here, since we're only # called when a repaint is about to happen! But an updateContents # might be good, here or in the sole caller or grandcaller. ###@@@ if debug_mt_updates: print "debug_mt_updates: update_state returning normally" return def update_state_0( self, paintevent): """[private] Build or rebuild a new tree of ModelTreeItems in this widget corresponding to the node tree of the current model; ###@@@ how does subclass tell us where to look for root nodes? assume updates are disabled in this widget. (#e Someday we might do this incrementally, ie. rebuild only part of the tree depending on what has been invalidated or is measured now to be invalid, though this is not done as of 050120. Relatedly, someday we might not build items for all hidden children (items whose parent items are closed), but for now we do.) """ del paintevent # heavily revised by bruce circa 050109 [from the version called mt_update] # and split into this method and one or more subclass methods, bruce 050120 # record the current scroll position so it can later be set to something similar qt4todo('self.scrollpos = self.viewportToContents(0,0)') #self.clear() # this destroys all our ModelTreeItems! self.clear_nodeItems() # and this makes sure we don't still try to update them. # As of 050113 this is still the only place we delete listview items. # We might do this more incrementally in the future, # for nodes whose kid order or set of kids changed -- # though as far as I know, this won't fix bugs, it's just an optimization. # We don't yet take much care to avoid old node.tritem pointing to # deleted list items! (Though current code won't experience this except # when it has bugs.) If those are ever used it causes a Qt exception. # This can be fixed when node.tritem is replaced with a # per-treewidget dict from nodes to their tree items... # as has now been done [050119], with self.nodeItem(). listview = self # (would be self.widget if we were a megawidget) # subclass supplies one or more root nodes for the tree # [should be ok if this list is non-constant, but that's untested as of 050120] self.topnodes = self.get_topnodes() self.topitems = [] # rebuilt below, to correspond with topnodes self.model = model = ModelTreeModel() model.rootItem.view = self self.setItemDelegate(model.rootItem) self.setModel(model) lastitem = None ####@@@@ got to about here for node in self.topnodes: item = self.make_new_subtree_for_node(node, listview, self.model.rootItem, after = lastitem) lastitem = item self.topitems.append(item) self.expandAll() # Update open/highlighted state of all tree items [text, icon already done above] ###@@@ code copied below - merge? for item in self.topitems: self.update_open_selected_in_itemtree( item) self.post_update_topitems() # let subclass know about new self.topitems # set the scroll position to what it ought to be # [bruce circa 050113. Fixes bug 177.] qt4todo('x, y = self.scrollpos') qt4todo('self.setContentsPos( x, y)') ###@@@ not yet perfect, since we need to correct height # to be larger than needed for all items, when collapsing a group # which went below the visible area, so the group doesn't move on # screen due to QTreeView not liking empty space below the items. ## a note about why ensureItemVisible is not useful [bruce circa 050109]: ##self.ensureItemVisible(self.last_selected_node.tritem) ## this "works", but it looks pretty bad: ## - there's a lot of flickering, incl of the scrollbar (disabling updates might fix that) ## - it always puts this item at the very bottom, for the ones that would otherwise be off the bottom ## - even if this item is already visible near the top, it moves stuff, perhaps as if trying to center it. return # from update_state_0 def get_topnodes(self): "[subclasses must override this to tell us what nodes to actually show]" return [] #e a better stub/testing value might be a comment node, if there is such a node class def post_update_topitems(self): "#doc" pass def update_selection_highlighting(self): ###@@@ #e let caller pass a subset or list to do it for? """The selection state might have changed; for each item whose selection state might be different now, set it properly via item.setSelected and repaint the item. """ # [Note: this is presently only called from subclasses, because it's only useful as part of an incremental update # (otherwise the items were created with this already correct, or updated en masse right afterwards) # and so far only some subclass's own event methods do incremental updates. # But someday we'll let ourselves be given incremental inval info (by subclass event methods, or outside code) # and call this from our own update function when only certain kinds of incremental invals occurred.] ###@@@ this is way more work than needed -- just do it for single items in old xor new members of selitems lists! # we'll need to fix this to make the selection behavior look fast enough, else it'll look bad. for item in self.topitems: self.update_open_selected_in_itemtree(item, do_setOpen=0) ###@@@ code copied from above -- but this code will change, anyway. so nevermind. # w/o flag do_setOpen=0 it might do illegal changes for a slot function... not sure return # default implems, subclasses could override (but don't, so far); also, # self.isOpen(item) (nim) ought to be separated from display_prefs and not included in them. def display_prefs_for_node(self, node): """Return a dict of the *incremental* display prefs for the node, relative to whatever its parent passes as display prefs for its own kids. Any prefs that it should inherit from its parent's env should be left out of this dict. The main thing this needs to include (if this is an openable node) is whether this node should be open in this view. [Subclasses can override this.] [Using this cumbersomeness just to say whether the item is open is not worthwhile in hindsight. Fix it sometime. #e] """ res = {} if node.openable(): ###e should use item_isOpen, but that's for items... res['openable'] = True ###@@@??? see setExpandable; and discussion in ModelTreeItem docs, esp about setup() function try: node.open ###@@@ obs, will be changed except: print "fyi: bug? openable node has no .open attr: %r" % node ###@@@ soon, none will need this, i think... res['open'] = False else: res['open'] = not not node.open return res def display_prefs_for_kids_of(self, node): """Return a dict of the *incremental* display prefs for this node's kids, relative to whatever its parent passes as display prefs for its own kids. Any that should inherit from parent's env should be left out of this dict. """ return {} # basic data structure -- move this to some earlier position in the class #e def set_nodeItem(self, node, item): #050119 self._node_items[node] = item # does not destroy old item, if any! def nodeItem(self, node): """Return the ModelTreeItem currently representing Node (in self) (this item might be hidden under closed higher nodes), or None. (If this item exists, then normally item.object == node.) Note that we (usually??) insist on node.dad corresponding to item.parent, so (always) one node can be shown in at most one place (per treewidget), thus can have at most one item per treewidget. [If you want to change this, consider instead using a new layer of nodes with these properties, between the tree widget and whatever nodes you're actually showing. If you *still* want to change it, then we'll still insist, I think, on all structural state being derived from display rules (which include the per-item "open" state) and node-tree structure, so that changes to the node tree result in deterministic but perhaps multiple changes to the item tree. But if that item tree, knowing "open", is ever lazily created in, terms of real ModelTreeItems, then we might end up needing to use permanent ones which end up being that same extra layer of nodes or at least permanent-item-position-ids.] """ return self._node_items.get(node) # historical note [bruce 050119]: # this used to be stored in node.tritem (except that # attr was missing when this was None); this had two problems: # - no possibility for more than one tree widget showing the same nodes; # - there was no clear_nodeItems(), resulting in bugs from accessing # deleted Qt objects when simple incremental update schemes were tried. # Unreviewed recent comment by me: "all this seems to be for is # setSelected, setOpen, and bookkeeping, and being created". # (Presumably, for other needs, we already have the item. If we go to # item-centric updating, then conceivably we'll no longer need this at # all -- then it would be easy to let it be a one-to-many function! # Well, we might still want it (in that form) for invalidation. Though # at the moment we survive without any per-node inval, so maybe not.) def clear_nodeItems(self): self._node_items.clear() # does not destroy old items! """Bug 1070 is one of these 'underlying C/C++ object has been deleted' bugs. These come up periodically, and they make me wonder if there is something we should be doing to detect when underlying C objects get deleted, and remove our own references to them. For the present, we should try to detect such instances and clean up as best we can. Maybe the rearchitecture will resolve this problem in a more satisfactory way. - wware 051206 """ # wware 051206 fixing bug 1070 def tooltip_nodeItems(self, tooltip): """Step through the nodes for this tree, and fill in the QToolTip for the ModelTreeItems in the viewport of the QlistView for the tree.""" _node_items = self._node_items for node in _node_items.keys(): name = node.name if len(name) > 12: item = _node_items[node] try: vp = self.viewport() if not isinstance(vp, QWidget): if debug_flags.atom_debug: # See bug 2113 - this does not appear to be very serious. wware 060727 sys.stderr.write("QScrollView.viewport() should return a QWidget (bug 1457)\n") sys.stderr.write("Instead it returned " + repr(vp) + "\n") return # qrect = vp.itemRect(item) ? ? qrect = self.itemRect(item) tooltip.add(vp, qrect, node.name) except RuntimeError: qrect = None # underlying C/C++ object has been deleted # item is invalid, remove it from _node_items del _node_items[node] # update helpers; will want some revision but this is not urgent I think #e def make_new_subtree_for_node(self, node, parent, nodeParent, display_prefs = {}, after = None): """Make one or more new treeitems (ModelTreeItems) in this treewidget (a QTreeView), as needed to display the given node under the given parent (which should be a treeitem or this treewidget). The display prefs (in our argument) are the ones from the env supplied by the parent -- they don't include the ones for this node itself (e.g. whether it's open), though (someday) they might include policies for whether or not to honor those. Return the toplevel treeitem made (the one corresponding to node). ###redoc: MAYBE: Include all kids of node (as if the node was open), whether or not it's actually open. [###@@@ that might be changed, but that's how it was in the pre-050109 code.] """ # This replaces the pre-050109 Node.upMT and Group.upMT, as well as the buildNode methods they called. ## display_prefs = {} ###@@@ get from caller; includes 'open' ###@@@ as temp kluge, set node.open here?? # modify display_prefs for this node, and for kids (separately!). item_prefs = dict(display_prefs) item_prefs.update( self.display_prefs_for_node(node) ) # incls. whether node should be open in this view item_prefs['open'] = True ###@@@ imitate the old code - include all the kids kid_prefs = dict(display_prefs) kid_prefs.update( self.display_prefs_for_kids_of(node) ) # as of 050109, does nothing, but that might change soon item = self.make_new_item_for_node(node, parent, nodeParent, item_prefs, after) self.set_nodeItem(node, item) ## node.tritem = item kids = node.kids(item_prefs) lastkid = None for kid in kids: ###@@@ also gaps for dnd -- but only later when we translate this to a canvas kiditem = self.make_new_subtree_for_node( kid, item, item, kid_prefs, after = lastkid) # kiditem.setParent(item) lastkid = kiditem del kiditem ###@@@ what about dnd here?? was it grabbed from each node or passed from toplevel upMT call? ## kid.upMT(item, dnd) return item ###@@@ I think existing code would not rebuild tree except when expand/collapse; # eg would not do it just when sel changed. notsure. at least that must be why it has separate setProp. # bruce 050108 moved this back into mtree (from the Node.buildNode methods) ###@@@ qt doc explains why it comes in wrong order, and tells how to fix it def make_new_item_for_node(self, node, parent, nodeParent, display_prefs = {}, after = None): """build and return a single new tree item in this tree widget (as part of building the entire tree from scratch, or maybe an entire subtree) corresponding to node; the args are: self, this tree widget; not sure if this was avail to the orig buildnode -- maybe as one of the other args? node, the node parent, can be another tree item (ModelTreeItem) or the tree widget itself (a QTreeView) icon - the icon to use for this node dnd - whether to enable drag and drop (not sure which part of it this is about) rename - whether to enable in-place editing of the name some of these args might be replaced by computations we do here or in sole caller ###@@@ do it all ####@@@redoc below after - None, or another listview item we come after .. .must add to nodes: options to specify dnd, rename, icon(openness). NOTE: it does not add in the kids! that must be done by upMT. and only if the item should be open. """ item = ModelTreeItem(node.name, nodeParent, node) nodeParent.appendChild(item) item.display_prefs = display_prefs # needed when we update the icon item.setIcon(QIcon(node.node_icon(display_prefs))) ###@@@ and/or, update the icon directly when we open/close? qt4todo('item.setRenameEnabled(0, node.rename_enabled()) ###k what is the 0 arg?') return item def update_item_icon(self, item): ###@@@ should also use this in some other methods, i think node = item.object display_prefs = dict(item.display_prefs) # make a copy to hold local changes display_prefs.update( self.display_prefs_for_node(node) ) # patches in current 'open' pref icon = node.node_icon( display_prefs) item.setIcon(icon) # 0 is the column the pixmap is in # Qt doc doesn't say whether this repaints or updates or neither, # but something seems to make it look right after this # everything after this: new methods by bruce 050108-050110, many temporary, # as I tease apart mtree and Utility to have a clean boundary ###@@@ ###@@@@ the following should be rewritten to scan item tree, not node tree... # then maybe it would not matter if item.parent ~= node.dad. # so it'd work for viewdata nodes even if we don't make that correspondence strict. def update_open_selected_in_itemtree(self, item, do_setOpen = True, do_invisible_nodes = True): ###@@@ change to also update text, icon? anything but structure... rename?? ###@@@ this implem is temporary and wrong: self.update_items_from_nodes_open_selected(item.object, do_setOpen = do_setOpen, do_invisible_nodes = do_invisible_nodes) def update_items_from_nodes_open_selected(self, node, _guard_ = None, do_setOpen = True, do_invisible_nodes = True): # bruce 050110 temporary; deprecated, only call from above method and not for long! ###@@@ """set the properties in the model tree widget to match those in the tree datastructure #redoc """ assert _guard_ is None # this makes sure we don't supply too many positional arguments! # bruce 050110 made this from the old Node.setProp and Group.setProp methods, # deprecated now (removed asap). # this will pull them into this file; # later worry about making them item-centric not node-centric... # and about fixing them to use methods on items not in tw, so sel works better. # btw what about viewdata members (kids but not members, might not be reached here)? # is it moot? ignore for now. or ask node for all members for this use... ie all possible kids, kids_if_open... # useful in our treemaker too i guess. listview = self item = self.nodeItem(node) #bruce 050512 re bug 620: it can happen that item is None because node is newly made # since the last time the MT was fully updated. To fix comment#0 of that bug, check for this. # For details of how that can happen, see my comments in that bug report. Roughly, if you click # in MT while waiting for a long op to finish which at the end needs to remake MT and does so by # calling mt_update, it happens because Qt first processes our click, then the mt update event. # [#e One better fix might be to remake the MT at the end of the user event that messed up the nodes it shows. # Then this would happen before the click was processed so it'd be up to date... we might still want to # detect this and discard that click in case it was on the wrong item. Anyway that's all NIM for now. # Another fix would be to scan the item-tree here (as last made from a node-tree), not the new node-tree. #e] if not item: if debug_flags.atom_debug: print "atom_debug: fyi: MT node with no item (still waiting for MT.update Qt event?)" return # bruce 050512 continues: Worse, it can happen that item is no longer valid -- the first time we call a method on it, # we get an exception from PyQt "RuntimeError: underlying C/C++ object has been deleted". My bug 620 comments give # details on that as well. Let's check this here with a harmless method and get it over with: try: item.text(0) # returns text in column 0 except: if debug_flags.atom_debug: print "atom_debug: fyi: MT node with invalid item (still waiting for MT.update Qt event?)" return # Now it should be safe to use item. if do_setOpen: if node.openable(): ###e needs cleanup: use node_isOpen/isOpenable split from current item_ methods self.expandItem(item) qt4todo('item.repaint()') self.repaint() if hasattr(node, 'members'): # clean this up... won't be enough for PartGroup! ###@@@ if not do_invisible_nodes: # if the members are not visible now, don't update them now (optim, I guess) if not (node.openable() and getattr(node,'open',False)): return for kid in node.members: ###@@@ for viewdata guys, use kids_if_open self.update_items_from_nodes_open_selected(kid, do_setOpen = do_setOpen) return pass # end of class TreeView # end