Source Code for Module vqt.tree

  1  '''
 
  2  ''' 
  3  
 
  4  from PyQt4 import QtCore, QtGui 
  5  
 
  6  import vqt.colors as vq_colors 
  7  import visgraph.pathcore as vg_path 
  8  
 
  9 -class VQTreeSorter: 
 10  
 
 11 -    def __init__(self, colnum, asc=1): 
 12          self.colnum = colnum 
 13          self.asc = asc 
 14  
 
 15 -    def __call__(self, x1, x2): 
 16          x1val = x1.rowdata[self.colnum] 
 17          x2val = x2.rowdata[self.colnum] 
 18          if self.asc: 
 19              return cmp(x1val, x2val) 
 20  
 
 21          return cmp(x2val, x1val) 
 22  
 
 23 -class VQTreeItem(object): 
 24  
 
 25 -    def __init__(self, rowdata, parent): 
 26          self.parent = parent 
 27          self.rowdata = list(rowdata) 
 28          self.children = [] 
 29  
 
 30 -    def append(self, rowdata): 
 31          child = VQTreeItem(rowdata, self) 
 32          self.children.append(child) 
 33          return child 
 34  
 
 35 -    def child(self, row): 
 36          return self.children[row] 
 37  
 
 38 -    def childCount(self): 
 39          return len(self.children) 
 40  
 
 41 -    def columnCount(self): 
 42          return len(self.rowdata) 
 43      
 
 44 -    def data(self, column): 
 45          if column > len(self.rowdata): 
 46              return None 
 47          return str(self.rowdata[column]) 
 48  
 
 49 -    def row(self): 
 50          '''
 
 51          Retrieve our row number.
 
 52          ''' 
 53          if self.parent: 
 54              return self.parent.children.index(self) 
 55          return 0 
 56  
 
 57 -class VQTreeModel(QtCore.QAbstractItemModel): 
 58      '''
 
 59      A QT tree model that uses the tree API from visgraph
 
 60      to hold the data...
 
 61      ''' 
 62  
 
 63      columns = ( 'A first column!', 'The Second Column!') 
 64      editable = None 
 65  
 
 66 -    def __init__(self, parent=None, columns=None): 
 67  
 
 68          if columns != None: 
 69              self.columns = columns 
 70  
 
 71          QtCore.QAbstractItemModel.__init__(self, parent=parent) 
 72          self.rootnode = VQTreeItem((), None) 
 73  
 
 74          if self.editable == None: 
 75              self.editable = [False,] * len(self.columns) 
 76  
 
 77 -    def vqEdited(self, pnode, col, value): 
 78          return value 
 79  
 
 80 -    def append(self, rowdata, parent=None): 
 81          if parent == None: 
 82              parent = self.rootnode 
 83  
 
 84          pidx = self.createIndex(parent.row(), 0, parent) 
 85          i = len(parent.children) 
 86          self.beginInsertRows(pidx, i, i) 
 87          node = parent.append(rowdata) 
 88          self.endInsertRows() 
 89          self.layoutChanged.emit() 
 90          return node 
 91  
 
 92 -    def sort(self, colnum, order=0): 
 93          cmpf = VQTreeSorter(colnum, order) 
 94          self.layoutAboutToBeChanged.emit() 
 95          self.rootnode.children.sort(cmp=cmpf) 
 96          self.layoutChanged.emit() 
 97  
 
 98 -    def flags(self, index): 
 99          if not index.isValid(): 
100              return 0 
101          flags = QtCore.QAbstractItemModel.flags(self, index) 
102          col = index.column() 
103          if self.editable[col]: 
104              flags |= QtCore.Qt.ItemIsEditable 
105          return flags 
106  
 
107 -    def columnCount(self, parent=None): 
108          return len(self.columns) 
109  
 
110 -    def data(self, index, role): 
111          if not index.isValid(): 
112              return None 
113  
 
114          item = index.internalPointer() 
115          if role == QtCore.Qt.DisplayRole: 
116              return item.data(index.column()) 
117  
 
118          if role == QtCore.Qt.UserRole: 
119              return item 
120  
 
121          return None 
122  
 
123 -    def setData(self, index, value, role=QtCore.Qt.EditRole): 
124  
 
125          node = index.internalPointer() 
126          if not node: 
127              return False 
128  
 
129          # If this is the edit role, fire the vqEdited thing
 
130          if role == QtCore.Qt.EditRole: 
131              value = self.vqEdited(node, index.column(), value) 
132              if value == None: 
133                  return False 
134  
 
135          node.rowdata[index.column()] = value 
136          self.dataChanged.emit(index, index) 
137  
 
138          return True 
139  
 
140 -    def headerData(self, column, orientation, role): 
141          if ( orientation == QtCore.Qt.Horizontal and
 
142               role == QtCore.Qt.DisplayRole): 
143  
 
144              return self.columns[column] 
145  
 
146          return None 
147  
 
148 -    def index(self, row, column, parent): 
149  
 
150          if not self.hasIndex(row, column, parent): 
151              return QtCore.QModelIndex() 
152  
 
153          pitem = parent.internalPointer() 
154          if not pitem: 
155              pitem = self.rootnode 
156  
 
157          item = pitem.child(row) 
158          if not item: 
159              return QtCore.QModelIndex() 
160  
 
161          return self.createIndex(row, column, item) 
162  
 
163 -    def parent(self, index): 
164  
 
165          if not index.isValid(): 
166              return QtCore.QModelIndex() 
167  
 
168          item = index.internalPointer() 
169          if not item: 
170              return QtCore.QModelIndex() 
171          
 
172          pitem = item.parent 
173  
 
174          if pitem == self.rootnode: 
175              return QtCore.QModelIndex() 
176  
 
177          if pitem == None: 
178              return QtCore.QModelIndex() 
179  
 
180          return self.createIndex(pitem.row(), 0, pitem) 
181  
 
182 -    def rowCount(self, parent=QtCore.QModelIndex()): 
183  
 
184          if parent.column() > 0: 
185              return 0 
186  
 
187          pitem = parent.internalPointer() 
188          if not pitem: 
189              pitem = self.rootnode 
190  
 
191          return len(pitem.children) 
192      
 
193 -class VQTreeView(QtGui.QTreeView): 
194  
 
195 -    def __init__(self, parent=None, cols=None): 
196          QtGui.QTreeView.__init__(self, parent=parent) 
197          self.setSortingEnabled(True) 
198          self.setAlternatingRowColors(True) 
199  
 
200          if cols != None: 
201              model = VQTreeModel(parent=self, columns=cols) 
202              self.setModel( model ) 
203  
 
204 -    def vqSizeColumns(self): 
205          c = self.model().columnCount() 
206          for i in xrange(c): 
207              self.resizeColumnToContents(i) 
208  
 
209 -    def setModel(self, model): 
210          model.dataChanged.connect( self.dataChanged ) 
211          model.rowsInserted.connect( self.rowsInserted ) 
212          return QtGui.QTreeView.setModel(self, model) 
213