eric: comparison eric6/Debugger/VariablesViewer.py

-:b1a3094b33e1
+:47f6b0c3a293
 """
 self.parent = parent
 # Take the additional methods into account for childCount
 self.methodCount = 0
 self.childCount = 0
-self.currentCount = -1  # -1 indicates to (re)load childs
+self.currentCount = -1  # -1 indicates to (re)load children
-# Indicator that there are childs
+# Indicator that there are children
-self.hasChilds = False
+self.hasChildren = False
 # Indicator that item was at least once fully populated
 self.wasPopulated = False
-self.childs = []
+self.children = []
 # Flag to prevent endless reloading of current item while waiting on
 # a response from debugger
 self.pendigFetch = False
-# Set of childs items, which are displayed the first time or changed
+# Set of child items, which are displayed the first time or changed
 self.newItems = set()
 self.changedItems = set()
 # Name including its ID if it's a dict, set, etc.
 self.nameWithId = dvar
 def __getType(self, dtype):
 """
 Private method to process the type of the variable.
-If type is known to have childs, the corresponding flag is set.
+If type is known to have children, the corresponding flag is set.
 @param dtype type string
 @type str
 """
 # Python class?
 if dtype.startswith('class '):
 dtype = dtype[7:-1]
 # Qt related stuff?
 elif (dtype.startswith(ConfigQtNames) and
 dtype.endswith(ConfigKnownQtTypes)):
-self.hasChilds = True
+self.hasChildren = True
 elif dtype in ('instance', 'class'):
-self.hasChilds = True
+self.hasChildren = True
 vtype = ConfigVarTypeDispStrings.get(dtype, dtype)
 # Unkown types should be expandable by default
 if vtype is dtype and dtype not in self.nonExpandableTypes:
-self.hasChilds = True
+self.hasChildren = True
 self.type = QCoreApplication.translate("VariablesViewer", vtype)
 def __getValue(self, dtype, dvalue):
 """
 Private method to process the variables value.
-Define and limit value, set tooltip text.
+Define and limit value, set tooltip text. If type is known to have
-If type is known to have childs, the corresponding flag is set.
+children, the corresponding flag is set.
 @param dtype type string
 @type str
 @param dvalue value of variable encoded as utf-8
 @type str
 """
 self.indicator = VariableItem.Type2Indicators.get(dtype, '')
 if dtype == 'numpy.ndarray':
 self.childCount = int(dvalue.split('x')[0])
 dvalue = VariableItem.noOfItemsStr.format(dvalue)
-self.hasChilds = True
+self.hasChildren = True
 elif dtype in VariableItem.arrayTypes:
 self.childCount = int(dvalue)
 dvalue = VariableItem.noOfItemsStr.format(dvalue)
-self.hasChilds = True
+self.hasChildren = True
 elif dtype == "Shiboken.EnumType":
-self.hasChilds = True
+self.hasChildren = True
 elif dtype in ['str', 'unicode']:
 if VariableItem.rx_nonprintable.indexIn(dvalue) == -1:
 try:
 dvalue = ast.literal_eval(dvalue)
 self.valueShort = dvalue
 @property
 def absolutCount(self):
 """
-Public property to get the total number of childs.
+Public property to get the total number of children.
-@return total number of childs
+@return total number of children
 @rtype int
 """
 return self.childCount + self.methodCount
 @property
 @rtype bool
 """
 return self.currentCount >= (self.childCount + self.methodCount)
-class VariableModel(QAbstractItemModel):
+class VariablesModel(QAbstractItemModel):
 """
 Class implementing the data model for QTreeView.
 @signal expand trigger QTreeView to expand given index
 """
 @type VariablesViewer
 @param globalScope flag indicating global (True) or local (False)
 variables
 @type bool
 """
-super(VariableModel, self).__init__()
+super(VariablesModel, self).__init__()
 self.treeView = treeView
 self.proxyModel = treeView.proxyModel
 self.framenr = -1
 self.openItems = []
 @param reset flag to clear the expanded keys also
 @type bool
 """
 self.beginResetModel()
-self.rootNode.childs = []
+self.rootNode.children = []
 self.rootNode.newItems.clear()
 self.rootNode.changedItems.clear()
 self.rootNode.wasPopulated = False
 if reset:
 self.openItems = []
 @rtype VariableItem or None
 """
 node = self.rootNode
 for childName in pathlist or []:
-for item in node.childs:
+for item in node.children:
 if item.nameWithId == childName:
 node = item
 break
 else:
 return None
 if parent == self.rootNode:
 parentIdx = QModelIndex()
 parent.methodCount = len(vlist)
 else:
-row = parent.parent.childs.index(parent)
+row = parent.parent.children.index(parent)
 parentIdx = self.createIndex(row, 0, parent)
 if itemStartIndex == -3:
 # Item doesn't exist any more
 parentIdx = self.parent(parentIdx)
 self.beginRemoveRows(parentIdx, row, row)
-del parent.parent.childs[row]
+del parent.parent.children[row]
 self.endRemoveRows()
 parent.parent.childCount -= 1
 return
 elif itemStartIndex == -2:
 # Sort items for Python versions where dict doesn't retain order
 vlist.sort(key=lambda x: x[0])
 # Now update the table
 endIndex = idx + len(vlist)
 newChild = None
-knownChildsCount = len(parent.childs)
+knownChildrenCount = len(parent.children)
 while idx < endIndex:
 # Fetch next old item from last cycle
 try:
-child = parent.childs[idx]
+child = parent.children[idx]
 except IndexError:
 child = None
 # Fetch possible new item
 if not newChild and vlist:
 sort = newItem.sort
 # Append or insert before already existing item
 if child is None or newChild and sort < child.sort:
 self.beginInsertRows(parentIdx, idx, idx)
-parent.childs.insert(idx, newItem)
+parent.children.insert(idx, newItem)
-if knownChildsCount <= idx and not parent.wasPopulated:
+if knownChildrenCount <= idx and not parent.wasPopulated:
 parent.newItems.add(newItem)
-knownChildsCount += 1
+knownChildrenCount += 1
 else:
 parent.changedItems.add(newItem)
 self.endInsertRows()
 idx += 1
 idx += 1
 continue
 # Remove obsolete item
 self.beginRemoveRows(parentIdx, idx, idx)
-parent.childs.remove(child)
+parent.children.remove(child)
 self.endRemoveRows()
 # idx stay unchanged
-knownChildsCount -= 1
+knownChildrenCount -= 1
 # Remove items which are left over at the end of child list
 if itemStartIndex == -1:
 parent.wasPopulated = True
 self.__cleanupParentList(parent, parentIdx)
 @param parent to clean up
 @type VariableItem
 @param parentIdx the parent index as QModelIndex
 @type QModelIndex
 """
-end = len(parent.childs)
+end = len(parent.children)
 if end > parent.absolutCount:
 self.beginRemoveRows(parentIdx, parent.absolutCount, end)
-del parent.childs[parent.absolutCount:]
+del parent.children[parent.absolutCount:]
 self.endRemoveRows()
 def resetModifiedMarker(self, parentIdx=QModelIndex(), pathlist=()):
 """
 Public method to remove the modified marker from changed items.
 posPaths = {x for x in self.openItems if len(x) > pll}
 posPaths |= {x for x in self.closedItems if len(x) > pll}
 posPaths = {x[pll] for x in posPaths if x[:pll] == pathlist}
 if posPaths:
-for child in parent.childs:
+for child in parent.children:
-if child.hasChilds and child.nameWithId in posPaths:
+if child.hasChildren and child.nameWithId in posPaths:
 if child.currentCount >= 0:
 # Discard loaded elements and refresh if still expanded
 child.currentCount = -1
-row = parent.childs.index(child)
+row = parent.children.index(child)
 newParentIdx = self.index(row, 0, parentIdx)
 self.resetModifiedMarker(
 newParentIdx, pathlist + (child.nameWithId,))
 self.closedItems = []
 idxEnd = self.index(0, 2, QModelIndex())
 self.dataChanged.emit(idxStart, idxEnd)
 def columnCount(self, parent=QModelIndex()):
 """
-Public Qt slot to get the column count.
+Public method to get the column count.
 @param parent the model parent
 @type QModelIndex
 @return number of columns
 @rtype int
 """
 return 3
 def rowCount(self, parent=QModelIndex()):
 """
-Public Qt slot to get the row count.
+Public method to get the row count.
 @param parent the model parent
 @type QModelIndex
 @return number of rows
 @rtype int
 if parent.isValid():
 node = parent.internalPointer()
 else:
 node = self.rootNode
-return len(node.childs)
+return len(node.children)
 def flags(self, index):
 """
-Public Qt slot to get the item flags.
+Public method to get the item flags.
 @param index of item
 @type QModelIndex
 @return item flags
 @rtype QtCore.Qt.ItemFlag
 return Qt.ItemIsEnabled | Qt.ItemIsSelectable
 def hasChildren(self, parent=QModelIndex()):
 """
-Public Qt slot to get a flag if parent has childs.
+Public method to get a flag if parent has children.
 @param parent the model parent
 @type QModelIndex
-@return flag if parent has childs
+@return flag indicating parent has children
 @rtype bool
 """
 if not parent.isValid():
-return self.rootNode.childs != []
+return self.rootNode.children != []
-return parent.internalPointer().hasChilds
+return parent.internalPointer().hasChildren
 def index(self, row, column, parent=QModelIndex()):
 """
-Public Qt slot to get the index of item at row:column of parent.
+Public method to get the index of item at row:column of parent.
 @param row number of rows
 @type int
 @param column number of columns
 @type int
 if not parent.isValid():
 node = self.rootNode
 else:
 node = parent.internalPointer()
-return self.createIndex(row, column, node.childs[row])
+return self.createIndex(row, column, node.children[row])
 def parent(self, child):
 """
-Public Qt slot to get the parent of the given child.
+Public method to get the parent of the given child.
 @param child the model child node
 @type QModelIndex
 @return new model index for parent
 @rtype QModelIndex
 parentNode = childNode.parent
 if parentNode == self.rootNode:
 return QModelIndex()
-row = parentNode.parent.childs.index(parentNode)
+row = parentNode.parent.children.index(parentNode)
 return self.createIndex(row, 0, parentNode)
 def data(self, index, role=Qt.DisplayRole):
 """
-Public Qt slot get the role data of item.
+Public method get the role data of item.
 @param index the model index
 @type QModelIndex
 @param role the requested data role
 @type QtCore.Qt.ItemDataRole
 return None
 def headerData(self, section, orientation, role=Qt.DisplayRole):
 """
-Public Qt slot get the header names.
+Public method get the header names.
 @param section the header section (row/coulumn)
 @type int
 @param orientation the header's orientation
 @type QtCore.Qt.Orientation
 @rtype QModelIndex
 """
 if parent is None:
 parent = self.rootNode
-for child in parent.childs:
+for child in parent.children:
-if not child.hasChilds:
+if not child.hasChildren:
 continue
 if pathlist + (child.nameWithId,) in self.openItems:
 if child.populated:
 index = None
 else:
-idx = parent.childs.index(child)
+idx = parent.children.index(child)
 index = self.createIndex(idx, 0, child)
 self.expand.emit(index)
 if child.currentCount < 0:
 return index
 idxStart = self.index(0, 0, QModelIndex())
 idxEnd = self.index(0, 2, QModelIndex())
 self.dataChanged.emit(idxStart, idxEnd)
-class ProxyModel(QSortFilterProxyModel):
+class VariablesProxyModel(QSortFilterProxyModel):
 """
 Class for handling the sort operations.
 """
 def __init__(self, parent=None):
 """
 Constructor
 @param parent the parent model index
 @type QModelIndex
 """
-super(ProxyModel, self).__init__(parent)
+super(VariablesProxyModel, self).__init__(parent)
 self.setSortRole(SORT_ROLE)
 def hasChildren(self, parent):
 """
-Public Qt slot to get a flag if parent has childs.
+Public method to get a flag if parent has children.
 The given model index has to be transformed to the underlying source
 model to get the correct result.
 @param parent the model parent
 @type QModelIndex
-@return flag if parent has childs
+@return flag if parent has children
 @rtype bool
 """
 return self.sourceModel().hasChildren(self.mapToSource(parent))
 def setExpanded(self, index, state):
 """
-Public Qt slot to get a flag if parent has childs.
+Public slot to get a flag if parent has children.
 The given model index has to be transformed to the underlying source
 model to get the correct result.
 @param index item to change expanded state
 @type QModelIndex
 This view is used to display the variables of the program being
 debugged in a tree. Compound types will be shown with
 their main entry first. Once the subtree has been expanded, the
 individual entries will be shown. Double clicking an entry will
-expand or collapse the item, if it has childs and the double click
+expand or collapse the item, if it has children and the double click
 was performed on the first column of the tree, otherwise it'll
 popup a dialog showing the variables parameters in a more readable
 form. This is especially useful for lengthy strings.
 This view has two modes for displaying the global and the local
 # Massive performance gain
 self.setUniformRowHeights(True)
 # Implements sorting and filtering
-self.proxyModel = ProxyModel()
+self.proxyModel = VariablesProxyModel()
 # Variable model implements the underlying data model
-self.varModel = VariableModel(self, globalScope)
+self.varModel = VariablesModel(self, globalScope)
 self.preferencesChanged.connect(self.varModel.handlePreferencesChanged)
 self.preferencesChanged.emit()  # Force initialization of colors
 self.proxyModel.setSourceModel(self.varModel)
 self.setModel(self.proxyModel)
 def showVariables(self, vlist, frmnr):
 """
 Public method to show variables in a list.
 @param vlist the list of variables to be displayed. Each
-listentry is a tuple of three values.
+list entry is a tuple of three values.
 <ul>
 <li>the variable name (string)</li>
 <li>the variables type (string)</li>
 <li>the variables value (string)</li>
 </ul>
 """
 Public method to show variables in a list.
 @param vlist the list of subitems to be displayed.
 The first element gives the path of the
-parent variable. Each other listentry is
+parent variable. Each other list entry is
 a tuple of three values.
 <ul>
 <li>the variable name (string)</li>
 <li>the variables type (string)</li>
 <li>the variables value (string)</li>
 """
 self.varModel.clear(True)
 def verticalScrollbarValueChanged(self, value):
 """
-Public Qt slot informing about the scrollbar change.
+Public slot informing about the scrollbar change.
 @param value current value of the vertical scrollbar
 @type int
 """
 self.varModel.getMore()
 super(VariablesViewer, self).verticalScrollbarValueChanged(value)
 def resizeEvent(self, event):
 """
-Protected Qt slot informing about the widget size change.
+Protected slot informing about the widget size change.
 @param event information
 @type QResizeEvent
 """
 self.varModel.getMore()
 @param index the double clicked item
 @type QModelIndex
 """
 node = self.proxyModel.mapToSource(index).internalPointer()
-if node.hasChilds and index.column() == 0:
+if node.hasChildren and index.column() == 0:
 state = self.isExpanded(index)
 self.setExpanded(index, not state)
 else:
 self.__showVariableDetails(index)
 Private method to generate the popup menus.
 """
 self.menu = QMenu()
 self.menu.addAction(self.tr("Show Details..."), self.__showDetails)
 self.menu.addSeparator()
-self.menu.addAction(self.tr("Expand childs"), self.__expandChilds)
+self.menu.addAction(self.tr("Expand"), self.__expandChildren)
-self.menu.addAction(self.tr("Collapse childs"), self.__collapseChilds)
+self.menu.addAction(self.tr("Collapse"), self.__collapseChildren)
-self.menu.addAction(self.tr("Collapse all"), self.collapseAll)
+self.menu.addAction(self.tr("Collapse All"), self.collapseAll)
 self.menu.addSeparator()
 self.menu.addAction(self.tr("Refresh"), self.__refreshView)
 self.menu.addSeparator()
 self.menu.addAction(self.tr("Configure..."), self.__configure)
-self.menu.addAction(
+self.menu.addAction(self.tr("Variables Type Filter..."),
-QCoreApplication.translate('DebugUI', 'Varia&bles Type Filter...'),
+self.__configureFilter)
-self.__configureFilter)
 self.backMenu = QMenu()
 self.backMenu.addAction(self.tr("Refresh"), self.__refreshView)
 self.backMenu.addSeparator()
 self.backMenu.addAction(self.tr("Configure..."), self.__configure)
-self.backMenu.addAction(
+self.backMenu.addAction(self.tr("Variables Type Filter..."),
-QCoreApplication.translate('DebugUI', 'Varia&bles Type Filter...'),
+self.__configureFilter)
-self.__configureFilter)
 def __showContextMenu(self, coord):
 """
 Private slot to show the context menu.
 if self.indexAt(coord).isValid():
 self.menu.popup(gcoord)
 else:
 self.backMenu.popup(gcoord)
-def __expandChilds(self):
+def __expandChildren(self):
 """
-Private slot to expand all childs of current parent.
+Private slot to expand all child items of current parent.
 """
 index = self.currentIndex()
 node = self.proxyModel.mapToSource(index).internalPointer()
-for child in node.childs:
+for child in node.children:
-if child.hasChilds:
+if child.hasChildren:
-row = node.childs.index(child)
+row = node.children.index(child)
 idx = self.varModel.createIndex(row, 0, child)
 idx = self.proxyModel.mapFromSource(idx)
 self.expand(idx)
-def __collapseChilds(self):
+def __collapseChildren(self):
 """
-Private slot to collapse all childs of current parent.
+Private slot to collapse all child items of current parent.
 """
 index = self.currentIndex()
 node = self.proxyModel.mapToSource(index).internalPointer()
-for child in node.childs:
+for child in node.children:
-row = node.childs.index(child)
+row = node.children.index(child)
 idx = self.varModel.createIndex(row, 0, child)
 idx = self.proxyModel.mapFromSource(idx)
 if self.isExpanded(idx):
 self.collapse(idx)

Mercurial Repositories > eric / file comparison

comparison: eric6/Debugger/VariablesViewer.py

eric6/Debugger/VariablesViewer.py