eric: comparison UI/BrowserModel.py

-:9986ec0e559a
+:10516539f238
 import sys
 import os
 import fnmatch
-from PyQt4.QtCore import QDir, QModelIndex, QAbstractItemModel, QFileSystemWatcher, Qt
+from PyQt4.QtCore import QDir, QModelIndex, QAbstractItemModel, \
+QFileSystemWatcher, Qt
 from PyQt4.QtGui import QImageReader, QApplication, QFont
 import UI.PixmapCache
 import Preferences
 import Utilities
 def __init__(self, parent=None, nopopulate=False):
 """
 Constructor
 @param parent reference to parent object (QObject)
-@keyparam nopopulate flag indicating to not populate the model (boolean)
+@keyparam nopopulate flag indicating to not populate the model
+(boolean)
 """
 super(BrowserModel, self).__init__(parent)
 self.progDir = None
 self.watchedItems = {}
 item = index.internalPointer()
 if index.column() < item.columnCount():
 return item.data(index.column())
 elif index.column() == item.columnCount() and \
 index.column() < self.columnCount(self.parent(index)):
-# This is for the case where an item under a multi-column parent
+# This is for the case where an item under a multi-column
-# doesn't have a value for all the columns
+# parent doesn't have a value for all the columns
 return ""
 elif role == Qt.DecorationRole:
 if index.column() == 0:
 return index.internalPointer().getIcon()
 elif role == Qt.FontRole:
 if path not in self.watchedItems:
 # just ignore the situation we don't have a reference to the item
 return
 if Preferences.getUI("BrowsersListHiddenFiles"):
-filter = QDir.Filters(QDir.AllEntries | QDir.Hidden | QDir.NoDotAndDotDot)
+filter = QDir.Filters(
+QDir.AllEntries | QDir.Hidden | QDir.NoDotAndDotDot)
 else:
 filter = QDir.Filters(QDir.AllEntries | QDir.NoDotAndDotDot)
 for itm in self.watchedItems[path]:
 oldCnt = itm.childCount()
 self.toplevelDirs = []
 tdp = Preferences.Prefs.settings.value('BrowserModel/ToplevelDirs')
 if tdp:
 self.toplevelDirs = tdp
 else:
-self.toplevelDirs.append(Utilities.toNativeSeparators(QDir.homePath()))
+self.toplevelDirs.append(
+Utilities.toNativeSeparators(QDir.homePath()))
 for d in QDir.drives():
 self.toplevelDirs.append(Utilities.toNativeSeparators(
 d.absoluteFilePath()))
 for d in self.toplevelDirs:
 itm = BrowserDirectoryItem(self.rootItem, d)
 self._addItem(itm, self.rootItem)
 def programChange(self, dirname):
 """
-Public method to change the entry for the directory of file being debugged.
+Public method to change the entry for the directory of file being
+debugged.
 @param dirname name of the directory containing the file (string)
 """
 if self.progDir:
 if dirname == self.progDir.dirName():
 return
 # remove old entry
 self._removeWatchedItem(self.progDir)
-self.beginRemoveRows(QModelIndex(), self.progDir.row(), self.progDir.row())
+self.beginRemoveRows(
+QModelIndex(), self.progDir.row(), self.progDir.row())
 self.rootItem.removeChild(self.progDir)
 self.endRemoveRows()
 self.progDir = None
 itm = BrowserDirectoryItem(self.rootItem, dirname)
 def removeToplevelDir(self, index):
 """
 Public method to remove a toplevel directory.
-@param index index of the toplevel directory to be removed (QModelIndex)
+@param index index of the toplevel directory to be removed
+(QModelIndex)
 """
 if not index.isValid():
 return
 item = index.internalPointer()
 self._addWatchedItem(parentItem)
 qdir = QDir(parentItem.dirName())
 if Preferences.getUI("BrowsersListHiddenFiles"):
-filter = QDir.Filters(QDir.AllEntries | QDir.Hidden | QDir.NoDotAndDotDot)
+filter = QDir.Filters(
+QDir.AllEntries | QDir.Hidden | QDir.NoDotAndDotDot)
 else:
 filter = QDir.Filters(QDir.AllEntries | QDir.NoDotAndDotDot)
 entryInfoList = qdir.entryInfoList(filter)
 if len(entryInfoList) > 0:
 if repopulate:
-self.beginInsertRows(self.createIndex(parentItem.row(), 0, parentItem),
+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(";")
+fileFilters = \
+Preferences.getUI("BrowsersFileFilters").split(";")
 if fileFilters:
 fn = f.fileName()
 if any([fnmatch.fnmatch(fn, ff.strip())
 for ff in fileFilters]):
 continue
 @param parentItem reference to the sys.path item to be populated
 @param repopulate flag indicating a repopulation (boolean)
 """
 if len(sys.path) > 0:
 if repopulate:
-self.beginInsertRows(self.createIndex(parentItem.row(), 0, parentItem),
+self.beginInsertRows(
+self.createIndex(parentItem.row(), 0, parentItem),
 0, len(sys.path) - 1)
 for p in sys.path:
 if p == '':
 p = os.getcwd()
 return
 keys = list(dict.keys())
 if len(keys) > 0:
 if repopulate:
-self.beginInsertRows(self.createIndex(parentItem.row(), 0, parentItem),
+self.beginInsertRows(
+self.createIndex(parentItem.row(), 0, parentItem),
 0, len(keys) - 1)
 for key in keys:
 if key.startswith("@@"):
 # special treatment done later
 continue
 for name in list(cl.methods.keys()):
 keys.append((name, 'm'))
 if len(keys) > 0:
 if repopulate:
-self.beginInsertRows(self.createIndex(parentItem.row(), 0, parentItem),
+self.beginInsertRows(
+self.createIndex(parentItem.row(), 0, parentItem),
 0, len(keys) - 1)
 for key, kind in keys:
 if kind == 'c':
 node = BrowserClassItem(parentItem, cl.classes[key], file_)
 elif kind == 'm':
-node = BrowserMethodItem(parentItem, cl.methods[key], file_)
+node = BrowserMethodItem(parentItem, cl.methods[key],
+file_)
 self._addItem(node, parentItem)
 if repopulate:
 self.endInsertRows()
 if len(cl.attributes):
 for name in list(fn.methods.keys()):
 keys.append((name, 'm'))
 if len(keys) > 0:
 if repopulate:
-self.beginInsertRows(self.createIndex(parentItem.row(), 0, parentItem),
+self.beginInsertRows(
+self.createIndex(parentItem.row(), 0, parentItem),
 0, len(keys) - 1)
 for key, kind in keys:
 if kind == 'c':
 node = BrowserClassItem(parentItem, fn.classes[key], file_)
 elif kind == 'm':
-node = BrowserMethodItem(parentItem, fn.methods[key], file_)
+node = BrowserMethodItem(parentItem, fn.methods[key],
+file_)
 self._addItem(node, parentItem)
 if repopulate:
 self.endInsertRows()
 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 parentItem reference to the class attributes item to be
+populated
 @param repopulate flag indicating a repopulation (boolean)
 """
 classAttributes = parentItem.isClassAttributes()
 attributes = parentItem.attributes()
 if not attributes:
 return
 keys = list(attributes.keys())
 if len(keys) > 0:
 if repopulate:
-self.beginInsertRows(self.createIndex(parentItem.row(), 0, parentItem),
+self.beginInsertRows(
+self.createIndex(parentItem.row(), 0, parentItem),
 0, len(keys) - 1)
 for key in keys:
 node = BrowserClassAttributeItem(parentItem, attributes[key],
 classAttributes)
 self._addItem(node, parentItem)
 def child(self, row):
 """
 Public method to get a child id.
 @param row number of child to get the id of (integer)
-@param return reference to the child item (BrowserItem)
+@return reference to the child item (BrowserItem)
 """
 return self.childItems[row]
 def children(self):
 """
 def data(self, column):
 """
 Public method to get a specific data item.
 @param column number of the requested data item (integer)
-@param return the stored data item
+@return stored data item
 """
 try:
 return self.itemData[column]
 except IndexError:
 return ""
 Public method to check, if this file is a Python script.
 @return flag indicating a Python file (boolean)
 """
 return self.fileext in Preferences.getPython("PythonExtensions") or \
-(self.fileext == "" and self.sourceLanguage in ["Python", "Python2"])
+(self.fileext == "" and self.sourceLanguage in ["Python",
+"Python2"])
 def isPython3File(self):
 """
 Public method to check, if this file is a Python3 script.
 if Preferences.getUI("BrowsersListFoldersFirst"):
 return order == Qt.DescendingOrder
 if issubclass(other.__class__, BrowserFileItem):
 sinit = os.path.basename(self._filename).startswith('__init__.py')
-oinit = os.path.basename(other.fileName()).startswith('__init__.py')
+oinit = \
+os.path.basename(other.fileName()).startswith('__init__.py')
 if sinit and not oinit:
 return order == Qt.AscendingOrder
 if not sinit and oinit:
 return order == Qt.DescendingOrder
 self.name = name
 self._classObject = cl
 self._filename = filename
 import Utilities.ClassBrowsers.ClbrBaseClasses
-self.isfunction = isinstance(self._classObject,
+self.isfunction = isinstance(
-Utilities.ClassBrowsers.ClbrBaseClasses.Function)
+self._classObject,
-self.ismodule = isinstance(self._classObject,
+Utilities.ClassBrowsers.ClbrBaseClasses.Function)
-Utilities.ClassBrowsers.ClbrBaseClasses.Module)
+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():
 self.icon = UI.PixmapCache.getIcon("method_protected.png")
 else:
 self.icon = UI.PixmapCache.getIcon("method.png")
 self.itemData[0] = "{0}({1})".format(
 name, ", ".join(self._classObject.parameters))
 # if no defaults are wanted
-# ....format(name, ", ".join([e.split('=')[0].strip() \
+# ....format(name,
-#                             for e in self._classObject.parameters]))
+#            ", ".join([e.split('=')[0].strip() \
+#                       for e in self._classObject.parameters]))
 elif self.ismodule:
 self.icon = UI.PixmapCache.getIcon("module.png")
 else:
 if cl.isPrivate():
 self.icon = UI.PixmapCache.getIcon("class_private.png")
 def lineno(self):
 """
 Public method returning the line number defining this object.
-return line number defining the object (integer)
+@return line number defining the object (integer)
 """
 return self._classObject.lineno
 def boundaries(self):
 """
 """
 if issubclass(other.__class__, BrowserCodingItem) or \
 issubclass(other.__class__, BrowserClassAttributesItem):
 return order == Qt.DescendingOrder
-if Preferences.getUI("BrowsersListContentsByOccurrence") and column == 0:
+if Preferences.getUI("BrowsersListContentsByOccurrence") and \
+column == 0:
 if order == Qt.AscendingOrder:
 return self.lineno() < other.lineno()
 else:
 return self.lineno() > other.lineno()
 else:
 self.icon = UI.PixmapCache.getIcon("method.png")
 self.itemData[0] = "{0}({1})".format(
 name, ", ".join(self._functionObject.parameters))
 # if no defaults are wanted
-# ....format(name, ", ".join(
+# ....format(name,
-#            [e.split('=')[0].strip() for e in self._functionObject.parameters]))
+#            ", ".join([e.split('=')[0].strip()
+#                       for e in self._functionObject.parameters]))
 if self._functionObject and \
 (self._functionObject.methods or self._functionObject.classes):
 self._populated = False
 self._lazyPopulation = True
 if other.name.startswith('__init__'):
 return order == Qt.DescendingOrder
 elif issubclass(other.__class__, BrowserClassAttributesItem):
 return order == Qt.DescendingOrder
-if Preferences.getUI("BrowsersListContentsByOccurrence") and column == 0:
+if Preferences.getUI("BrowsersListContentsByOccurrence") and \
+column == 0:
 if order == Qt.AscendingOrder:
 return self.lineno() < other.lineno()
 else:
 return self.lineno() > other.lineno()
 def lineno(self):
 """
 Public method returning the line number defining this object.
-return line number defining the object (integer)
+@return line number defining the object (integer)
 """
 return self._attributeObject.lineno
 def linenos(self):
 """
 Public method returning the line numbers this object is assigned to.
-return line number the object is assigned to (list of integers)
+@return line number the object is assigned to (list of integers)
 """
 return self._attributeObject.linenos[:]
 def lessThan(self, other, column, order):
 """
 @param other reference to item to compare against (BrowserItem)
 @param column column number to use for the comparison (integer)
 @param order sort order (Qt.SortOrder) (for special sorting)
 @return true, if this item is less than other (boolean)
 """
-if Preferences.getUI("BrowsersListContentsByOccurrence") and column == 0:
+if Preferences.getUI("BrowsersListContentsByOccurrence") and \
+column == 0:
 if order == Qt.AscendingOrder:
 return self.lineno() < other.lineno()
 else:
 return self.lineno() > other.lineno()

Mercurial Repositories > eric / file comparison

comparison: UI/BrowserModel.py

UI/BrowserModel.py