eric: comparison Project/ProjectBrowserModel.py

-:1b59c4ba121e
+:8cd4d08fa9f6
 import Preferences
 import Utilities
 import Utilities.ModuleParser
-ProjectBrowserItemSimpleDirectory  = 100
+ProjectBrowserItemSimpleDirectory = 100
-ProjectBrowserItemDirectory        = 101
+ProjectBrowserItemDirectory = 101
-ProjectBrowserItemFile             = 102
+ProjectBrowserItemFile = 102
-ProjectBrowserNoType          = 0
+ProjectBrowserNoType = 0
-ProjectBrowserSourceType      = 1
+ProjectBrowserSourceType = 1
-ProjectBrowserFormType        = 2
+ProjectBrowserFormType = 2
-ProjectBrowserInterfaceType   = 3
+ProjectBrowserInterfaceType = 3
 ProjectBrowserTranslationType = 4
-ProjectBrowserOthersType      = 5
+ProjectBrowserOthersType = 5
-ProjectBrowserResourceType    = 6
+ProjectBrowserResourceType = 6
 class ProjectBrowserItemMixin(object):
 """
 Class implementing common methods of project browser items.
 It is meant to be used as a mixin class.
 """
-def __init__(self, type_, bold = False):
+def __init__(self, type_, bold=False):
 """
 Constructor
 @param type_ type of file/directory in the project
 @param bold flag indicating a highlighted font
 @param type_ type to add to the list
 """
 self._projectTypes.append(type_)
 class ProjectBrowserSimpleDirectoryItem(BrowserItem, ProjectBrowserItemMixin):
 """
 Class implementing the data structure for project browser simple directory items.
 """
-def __init__(self, parent, projectType, text, path = ""):
+def __init__(self, parent, projectType, text, path=""):
 """
 Constructor
 @param parent parent item
 @param projectType type of file/directory in the project
 self.symlink = True
 self.icon = UI.PixmapCache.getSymlinkIcon("dirClosed.png")
 else:
 self.icon = UI.PixmapCache.getIcon("dirClosed.png")
-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 ProjectBrowserDirectoryItem(BrowserDirectoryItem, ProjectBrowserItemMixin):
 """
 Class implementing the data structure for project browser directory items.
 """
-def __init__(self, parent, dinfo, projectType, full = True, bold = False):
+def __init__(self, parent, dinfo, projectType, full=True, bold=False):
 """
 Constructor
 @param parent parent item
 @param dinfo dinfo is the string for the directory (string)
 BrowserDirectoryItem.__init__(self, parent, dinfo, full)
 ProjectBrowserItemMixin.__init__(self, projectType, bold)
 self.type_ = ProjectBrowserItemDirectory
 class ProjectBrowserFileItem(BrowserFileItem, ProjectBrowserItemMixin):
 """
 Class implementing the data structure for project browser file items.
 """
-def __init__(self, parent, finfo, projectType, full = True, bold = False,
+def __init__(self, parent, finfo, projectType, full=True, bold=False,
-sourceLanguage = ""):
+sourceLanguage=""):
 """
 Constructor
 @param parent parent item
 @param finfo the string for the file (string)
 BrowserFileItem.__init__(self, parent, finfo, full, sourceLanguage)
 ProjectBrowserItemMixin.__init__(self, projectType, bold)
 self.type_ = ProjectBrowserItemFile
 class ProjectBrowserModel(BrowserModel):
 """
 Class implementing the project browser model.
 @signal vcsStateChanged(str) emitted after the VCS state has changed
 self.watcher.directoryChanged.connect(self.directoryChanged)
 self.inRefresh = False
 self.projectBrowserTypes = {
-"SOURCES"      : ProjectBrowserSourceType,
+"SOURCES": ProjectBrowserSourceType,
-"FORMS"        : ProjectBrowserFormType,
+"FORMS": ProjectBrowserFormType,
-"RESOURCES"    : ProjectBrowserResourceType,
+"RESOURCES": ProjectBrowserResourceType,
-"INTERFACES"   : ProjectBrowserInterfaceType,
+"INTERFACES": ProjectBrowserInterfaceType,
-"TRANSLATIONS" : ProjectBrowserTranslationType,
+"TRANSLATIONS": ProjectBrowserTranslationType,
-"OTHERS"       : ProjectBrowserOthersType,
+"OTHERS": ProjectBrowserOthersType,
 }
 self.colorNames = {
-"A" : "VcsAdded",
+"A": "VcsAdded",
-"M" : "VcsModified",
+"M": "VcsModified",
-"O" : "VcsRemoved",
+"O": "VcsRemoved",
-"R" : "VcsReplaced",
+"R": "VcsReplaced",
-"U" : "VcsUpdate",
+"U": "VcsUpdate",
-"Z" : "VcsConflict",
+"Z": "VcsConflict",
 }
 self.itemBackgroundColors = {
-" " : QColor(),
+" ": QColor(),
-"A" : Preferences.getProjectBrowserColour(self.colorNames["A"]),
+"A": Preferences.getProjectBrowserColour(self.colorNames["A"]),
-"M" : Preferences.getProjectBrowserColour(self.colorNames["M"]),
+"M": Preferences.getProjectBrowserColour(self.colorNames["M"]),
-"O" : Preferences.getProjectBrowserColour(self.colorNames["O"]),
+"O": Preferences.getProjectBrowserColour(self.colorNames["O"]),
-"R" : Preferences.getProjectBrowserColour(self.colorNames["R"]),
+"R": Preferences.getProjectBrowserColour(self.colorNames["R"]),
-"U" : Preferences.getProjectBrowserColour(self.colorNames["U"]),
+"U": Preferences.getProjectBrowserColour(self.colorNames["U"]),
-"Z" : Preferences.getProjectBrowserColour(self.colorNames["Z"]),
+"Z": Preferences.getProjectBrowserColour(self.colorNames["Z"]),
 }
 self.highLightColor = Preferences.getProjectBrowserColour("Highlighted")
 # needed by preferencesChanged()
 except KeyError:
 return None
 return BrowserModel.data(self, index, role)
-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() == ProjectBrowserItemFile:
 self.populateFileItem(parentItem, repopulate)
 else:
 BrowserModel.populateItem(self, parentItem, repopulate)
-def populateProjectDirectoryItem(self, parentItem, repopulate = False):
+def populateProjectDirectoryItem(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)
 states = self.project.vcs.vcsAllRegisteredStates(states, dname)
 for f in entryInfoList:
 if f.isDir():
 node = ProjectBrowserDirectoryItem(parentItem,
 Utilities.toNativeSeparators(f.absoluteFilePath()),
 parentItem.getProjectTypes()[0], False)
 else:
 node = ProjectBrowserFileItem(parentItem,
 Utilities.toNativeSeparators(f.absoluteFilePath()),
 parentItem.getProjectTypes()[0])
 itm = ProjectBrowserDirectoryItem(parentItem, fname,
 self.projectBrowserTypes[key], False, bold)
 else:
 itm = ProjectBrowserFileItem(parentItem, fname,
 self.projectBrowserTypes[key], False, bold,
-sourceLanguage = sourceLanguage)
+sourceLanguage=sourceLanguage)
 self._addItem(itm, parentItem)
 if self.project.vcs is not None:
 if states[os.path.normcase(fname)] == self.project.vcs.canBeCommitted:
 itm.addVcsStatus(self.project.vcs.vcsName())
 else:
 else:
 itm.addVcsStatus("")
 self.inRefresh = False
 self.reset()
-def findParentItemByName(self, type_, name, dontSplit = False):
+def findParentItemByName(self, type_, name, dontSplit=False):
 """
 Public method to find an item given it's name.
 <b>Note</b>: This method creates all necessary parent items, if they
 don't exist.
 olditem = itm
 return (itm, pathlist[-1])
 else:
 return (self.rootItem, name)
-def findChildItem(self, text, column, parentItem = None):
+def findChildItem(self, text, column, parentItem=None):
 """
 Public method to find a child item given some text.
 @param text text to search for (string)
 @param column column to search in (integer)
 if itm.data(column) == text:
 return itm
 return None
-def addNewItem(self, typeString, name, additionalTypeStrings = []):
+def addNewItem(self, typeString, name, additionalTypeStrings=[]):
 """
 Public method to add a new item to the model.
 @param typeString string denoting the type of the new item (string)
 @param name name of the new item (string)
 sourceLanguage = self.project.pdata["PROGLANGUAGE"][0]
 else:
 sourceLanguage = ""
 itm = ProjectBrowserFileItem(parentItem, fname,
 self.projectBrowserTypes[typeString], False, bold,
-sourceLanguage = sourceLanguage)
+sourceLanguage=sourceLanguage)
 self.__addVCSStatus(itm, fname)
 if additionalTypeStrings:
 for additionalTypeString in additionalTypeStrings:
 type_ = self.projectBrowserTypes[additionalTypeString]
 itm.addProjectType(type_)
 @param name name of the item (string)
 @return index of the item found (QModelIndex)
 """
 itm = self.findItem(name)
 if itm is None:
-index =  QModelIndex()
+index = QModelIndex()
 else:
-index =  self.createIndex(itm.row(), 0, itm)
+index = self.createIndex(itm.row(), 0, itm)
 return index
 def directoryChanged(self, path):
 """
 Public slot to handle the directoryChanged signal of the watcher.
 cnt = itm.childCount()
 self.beginInsertRows(self.createIndex(itm.row(), 0, itm),
 cnt, cnt)
 if f.isDir():
 node = ProjectBrowserDirectoryItem(itm,
 Utilities.toNativeSeparators(f.absoluteFilePath()),
 itm.getProjectTypes()[0],
 False)
 else:
 node = ProjectBrowserFileItem(itm,
 Utilities.toNativeSeparators(f.absoluteFilePath()),
 itm.getProjectTypes()[0])
 self._addItem(node, itm)
 if self.project.vcs is not None:
 self.project.vcs.clearStatusCache()
 state = self.project.vcs.vcsRegisteredState(node.name())
 else:
 item.addVcsStatus(self.trUtf8("local"))
 else:
 item.addVcsStatus("")
-def __updateVCSStatus(self, item, name, recursive = True):
+def __updateVCSStatus(self, item, name, recursive=True):
 """
 Private method used to update the vcs status of a node.
 @param item item to work on
 @param name filename belonging to this item (string)
 item.setVcsStatus("")
 index = self.createIndex(item.row(), 0, item)
 self.dataChanged.emit(index, index)
-def updateVCSStatus(self, name, recursive = True):
+def updateVCSStatus(self, name, recursive=True):
 """
 Public method used to update the vcs status of a node.
 @param name filename belonging to this item (string)
 @param recursive flag indicating a recursive update (boolean)
 def changeVCSStates(self, statesList):
 """
 Public slot to record the (non normal) VCS states.
 @param statesList list of VCS state entries (list of strings) giving the
 states in the first column and the path relative to the project
 directory starting with the third column. The allowed status flags
 are:
 <ul>
 <li>"A" path was added but not yet comitted</li>
 <li>"M" path has local changes</li>
 <li>"O" path was removed</li>
 if itm:
 itemCache[name] = itm
 if itm:
 itm.setVcsState(state)
 index1 = self.createIndex(itm.row(), 0, itm)
 index2 = self.createIndex(itm.row(),
 self.rootItem.columnCount(), itm)
 self.dataChanged.emit(index1, index2)
 head, tail = os.path.split(name)
 if head != lastHead:
 if state < id_.vcsState:
 state = id_.vcsState
 if state != itm.vcsState:
 itm.setVcsState(state)
 index1 = self.createIndex(itm.row(), 0, itm)
 index2 = self.createIndex(itm.row(),
 self.rootItem.columnCount(), itm)
 self.dataChanged.emit(index1, index2)
 path, tail = os.path.split(path)
 def preferencesChanged(self):

Mercurial Repositories > eric / file comparison

comparison: Project/ProjectBrowserModel.py

Project/ProjectBrowserModel.py