eric: comparison UI/BrowserModel.py

-:1b59c4ba121e
+:8cd4d08fa9f6
 import UI.PixmapCache
 import Preferences
 import Utilities
-BrowserItemRoot       = 0
+BrowserItemRoot = 0
-BrowserItemDirectory  = 1
+BrowserItemDirectory = 1
-BrowserItemSysPath    = 2
+BrowserItemSysPath = 2
-BrowserItemFile       = 3
+BrowserItemFile = 3
-BrowserItemClass      = 4
+BrowserItemClass = 4
-BrowserItemMethod     = 5
+BrowserItemMethod = 5
 BrowserItemAttributes = 6
-BrowserItemAttribute  = 7
+BrowserItemAttribute = 7
-BrowserItemCoding     = 8
+BrowserItemCoding = 8
 class BrowserModel(QAbstractItemModel):
 """
 Class implementing the browser model.
 """
-def __init__(self, parent = None):
+def __init__(self, parent=None):
 """
 Constructor
 @param parent reference to parent object (QObject)
 """
 if not index.isValid():
 return Qt.ItemIsEnabled
 return Qt.ItemIsEnabled | Qt.ItemIsSelectable
-def headerData(self, section, orientation, role = Qt.DisplayRole):
+def headerData(self, section, orientation, role=Qt.DisplayRole):
 """
 Public method to get the header data.
 @param section number of section to get data for (integer)
 @param orientation header orientation (Qt.Orientation)
 else:
 return self.rootItem.data(section)
 return None
-def index(self, row, column, parent = QModelIndex()):
+def index(self, row, column, parent=QModelIndex()):
 """
 Public method to create an index.
 @param row row number of the new index (integer)
 @param column column number of the new index (integer)
 @param parent index of parent item (QModelIndex)
 @return index object (QModelIndex)
 """
 # The model/view framework considers negative values out-of-bounds,
 # however in python they work when indexing into lists. So make sure
 # we return an invalid index for out-of-bounds row/col
 if row < 0 or column < 0 or \
 row >= self.rowCount(parent) or column >= self.columnCount(parent):
 return QModelIndex()
 if parentItem == self.rootItem:
 return QModelIndex()
 return self.createIndex(parentItem.row(), 0, parentItem)
-def rowCount(self, parent = QModelIndex()):
+def rowCount(self, parent=QModelIndex()):
 """
 Public method to get the number of rows.
 @param parent index of parent item (QModelIndex)
 @return number of rows (integer)
 if not parentItem.isPopulated():    # lazy population
 self.populateItem(parentItem)
 return parentItem.childCount()
-def hasChildren(self, parent = QModelIndex()):
+def hasChildren(self, parent=QModelIndex()):
 """
 Public method to check for the presence of child items.
 We always return True for normal items in order to do lazy
 population of the tree.
 cnt = itm.childCount()
 self.beginInsertRows(self.createIndex(itm.row(), 0, itm),
 cnt, cnt)
 if f.isDir():
 node = BrowserDirectoryItem(itm,
 Utilities.toNativeSeparators(f.absoluteFilePath()),
 False)
 else:
 node = BrowserFileItem(itm,
 Utilities.toNativeSeparators(f.absoluteFilePath()))
 self._addItem(node, itm)
 def saveToplevelDirs(self):
 """
 Public slot to save the toplevel directories.
 """
 Preferences.Prefs.settings.setValue('BrowserModel/ToplevelDirs',
 self.toplevelDirs)
 def _addItem(self, itm, parentItem):
 """
 Protected slot to add an item.
 @param itm reference to item to add (BrowserItem)
 @param parentItem reference to item to add to (BrowserItem)
 """
 parentItem.appendChild(itm)
-def addItem(self, itm, parent = QModelIndex()):
+def addItem(self, itm, parent=QModelIndex()):
 """
 Puplic slot to add an item.
 @param itm item to add (BrowserItem)
 @param parent index of parent item (QModelIndex)
 cnt = parentItem.childCount()
 self.beginInsertRows(parent, cnt, cnt)
 self._addItem(itm, parentItem)
 self.endInsertRows()
-def populateItem(self, parentItem, repopulate = False):
+def populateItem(self, parentItem, repopulate=False):
 """
 Public method to populate an item's subtree.
 @param parentItem reference to the item to be populated
 @param repopulate flag indicating a repopulation (boolean)
 elif parentItem.type() == BrowserItemMethod:
 self.populateMethodItem(parentItem, repopulate)
 elif parentItem.type() == BrowserItemAttributes:
 self.populateClassAttributesItem(parentItem, repopulate)
-def populateDirectoryItem(self, parentItem, repopulate = False):
+def populateDirectoryItem(self, parentItem, repopulate=False):
 """
 Public method to populate a directory item's subtree.
 @param parentItem reference to the directory item to be populated
 @param repopulate flag indicating a repopulation (boolean)
 self.beginInsertRows(self.createIndex(parentItem.row(), 0, parentItem),
 0, len(entryInfoList) - 1)
 for f in entryInfoList:
 if f.isDir():
 node = BrowserDirectoryItem(parentItem,
 Utilities.toNativeSeparators(f.absoluteFilePath()),
 False)
 else:
 fileFilters = Preferences.getUI("BrowsersFileFilters").split(";")
 if fileFilters:
 fn = f.fileName()
 Utilities.toNativeSeparators(f.absoluteFilePath()))
 self._addItem(node, parentItem)
 if repopulate:
 self.endInsertRows()
-def populateSysPathItem(self, parentItem, repopulate = False):
+def populateSysPathItem(self, parentItem, repopulate=False):
 """
 Public method to populate a sys.path item's subtree.
 @param parentItem reference to the sys.path item to be populated
 @param repopulate flag indicating a repopulation (boolean)
 node = BrowserDirectoryItem(parentItem, p)
 self._addItem(node, parentItem)
 if repopulate:
 self.endInsertRows()
-def populateFileItem(self, parentItem, repopulate = False):
+def populateFileItem(self, parentItem, repopulate=False):
 """
 Public method to populate a file item's subtree.
 @param parentItem reference to the file item to be populated
 @param repopulate flag indicating a repopulation (boolean)
 """
 moduleName = parentItem.moduleName()
 fileName = parentItem.fileName()
 try:
 dict = Utilities.ClassBrowsers.readmodule(
 moduleName, [parentItem.dirName()],
 parentItem.isPython2File() or parentItem.isPython3File())
 except ImportError:
 return
 keys = list(dict.keys())
 node = BrowserClassItem(parentItem, cl, fileName)
 self._addItem(node, parentItem)
 except AttributeError:
 pass
 if "@@Coding@@" in keys:
 node = BrowserCodingItem(parentItem,
 QApplication.translate("BrowserModel", "Coding: {0}")\
 .format(dict["@@Coding@@"].coding))
 self._addItem(node, parentItem)
 if "@@Globals@@" in keys:
 node = BrowserClassAttributesItem(parentItem,
 dict["@@Globals@@"].globals,
 QApplication.translate("BrowserModel", "Globals"))
 self._addItem(node, parentItem)
 if repopulate:
 self.endInsertRows()
-def populateClassItem(self, parentItem, repopulate = False):
+def populateClassItem(self, parentItem, repopulate=False):
 """
 Public method to populate a class item's subtree.
 @param parentItem reference to the class item to be populated
 @param repopulate flag indicating a repopulation (boolean)
 if repopulate:
 self.endInsertRows()
 if len(cl.attributes):
 node = BrowserClassAttributesItem(
 parentItem, cl.attributes,
 QApplication.translate("BrowserModel", "Attributes"))
 if repopulate:
 self.addItem(node,
 self.createIndex(parentItem.row(), 0, parentItem))
 else:
 self._addItem(node, parentItem)
 if len(cl.globals):
 node = BrowserClassAttributesItem(
 parentItem, cl.globals,
 QApplication.translate("BrowserModel", "Attributes (global)"))
 if repopulate:
 self.addItem(node,
 self.createIndex(parentItem.row(), 0, parentItem))
 else:
 self._addItem(node, parentItem)
-def populateMethodItem(self, parentItem, repopulate = False):
+def populateMethodItem(self, parentItem, repopulate=False):
 """
 Public method to populate a method item's subtree.
 @param parentItem reference to the method item to be populated
 @param repopulate flag indicating a repopulation (boolean)
 node = BrowserMethodItem(parentItem, fn.methods[key], file_)
 self._addItem(node, parentItem)
 if repopulate:
 self.endInsertRows()
-def populateClassAttributesItem(self, parentItem, repopulate = False):
+def populateClassAttributesItem(self, parentItem, repopulate=False):
 """
 Public method to populate a class attributes item's subtree.
 @param parentItem reference to the class attributes item to be populated
 @param repopulate flag indicating a repopulation (boolean)
 node = BrowserClassAttributeItem(parentItem, attributes[key])
 self._addItem(node, parentItem)
 if repopulate:
 self.endInsertRows()
 class BrowserItem(object):
 """
 Class implementing the data structure for browser items.
 """
 def __init__(self, parent, data):
 @return flag indicating a symbolic link (boolean)
 """
 return self.symlink
 class BrowserDirectoryItem(BrowserItem):
 """
 Class implementing the data structure for browser directory items.
 """
-def __init__(self, parent, dinfo, full = True):
+def __init__(self, parent, dinfo, full=True):
 """
 Constructor
 @param parent parent item
 @param dinfo dinfo is the string for the directory (string)
 else:
 self.icon = UI.PixmapCache.getIcon("dirClosed.png")
 self._populated = False
 self._lazyPopulation = True
-def setName(self, dinfo, full = True):
+def setName(self, dinfo, full=True):
 """
 Public method to set the directory name.
 @param dinfo dinfo is the string for the directory (string)
 @param full flag indicating full pathname should be displayed (boolean)
 if Preferences.getUI("BrowsersListFoldersFirst"):
 return order == Qt.AscendingOrder
 return BrowserItem.lessThan(self, other, column, order)
 class BrowserSysPathItem(BrowserItem):
 """
 Class implementing the data structure for browser sys.path items.
 """
 def __init__(self, parent):
 self.type_ = BrowserItemSysPath
 self.icon = UI.PixmapCache.getIcon("filePython.png")
 self._populated = False
 self._lazyPopulation = True
 class BrowserFileItem(BrowserItem):
 """
 Class implementing the data structure for browser file items.
 """
-def __init__(self, parent, finfo, full = True, sourceLanguage = ""):
+def __init__(self, parent, finfo, full=True, sourceLanguage=""):
 """
 Constructor
 @param parent parent item
 @param finfo the string for the file (string)
 self.symlink = True
 self.icon = UI.PixmapCache.getSymlinkIcon(pixName)
 else:
 self.icon = UI.PixmapCache.getIcon(pixName)
-def setName(self, finfo, full = True):
+def setName(self, finfo, full=True):
 """
 Public method to set the directory name.
 @param finfo the string for the file (string)
 @param full flag indicating full pathname should be displayed (boolean)
 return order == Qt.AscendingOrder
 if not sinit and oinit:
 return order == Qt.DescendingOrder
 return BrowserItem.lessThan(self, other, column, order)
 class BrowserClassItem(BrowserItem):
 """
 Class implementing the data structure for browser class items.
 """
 self.type_ = BrowserItemClass
 self.name = name
 self._classObject = cl
 self._filename = filename
 self.isfunction = isinstance(self._classObject,
 Utilities.ClassBrowsers.ClbrBaseClasses.Function)
 self.ismodule = isinstance(self._classObject,
 Utilities.ClassBrowsers.ClbrBaseClasses.Module)
 if self.isfunction:
 if cl.isPrivate():
 self.icon = UI.PixmapCache.getIcon("method_private.png")
 elif cl.isProtected():
 @return flag indicating public visibility (boolean)
 """
 return self._classObject.isPublic()
 class BrowserMethodItem(BrowserItem):
 """
 Class implementing the data structure for browser method items.
 """
 def __init__(self, parent, fn, filename):
 self.icon = UI.PixmapCache.getIcon("method_private.png")
 elif self._functionObject.isProtected():
 self.icon = UI.PixmapCache.getIcon("method_protected.png")
 else:
 self.icon = UI.PixmapCache.getIcon("method.png")
-self.itemData[0] =  "{0}({1})".format(
+self.itemData[0] = "{0}({1})".format(
 name, ", ".join(self._functionObject.parameters))
 # if no defaults are wanted
 # ....format(name, ", ".join(
 #            [e.split('=')[0].strip() for e in self._functionObject.parameters]))
 if self._functionObject and \
 @return flag indicating public visibility (boolean)
 """
 return self._functionObject.isPublic()
 class BrowserClassAttributesItem(BrowserItem):
 """
 Class implementing the data structure for browser class attributes items.
 """
 def __init__(self, parent, attributes, text):
 elif issubclass(other.__class__, BrowserClassItem) or \
 issubclass(other.__class__, BrowserMethodItem):
 return order == Qt.AscendingOrder
 return BrowserItem.lessThan(self, other, column, order)
 class BrowserClassAttributeItem(BrowserItem):
 """
 Class implementing the data structure for browser class attribute items.
 """
 else:
 return self.lineno() > other.lineno()
 return BrowserItem.lessThan(self, other, column, order)
 class BrowserCodingItem(BrowserItem):
 """
 Class implementing the data structure for browser coding items.
 """
 def __init__(self, parent, text):

Mercurial Repositories > eric / file comparison

comparison: UI/BrowserModel.py

UI/BrowserModel.py