eric: comparison src/eric7/UI/BrowserModel.py

-:280a53840aa3
+:306373ccf8fd
 from PyQt6.QtCore import (
 QAbstractItemModel,
 QCoreApplication,
 QDir,
-QFileSystemWatcher,
 QModelIndex,
 QProcess,
 Qt,
 )
 from PyQt6.QtGui import QFont, QImageReader
 from PyQt6.QtWidgets import QApplication
 from eric7 import Preferences
+from eric7.EricCore import EricFileSystemWatcher
 from eric7.EricGui import EricPixmapCache
 from eric7.SystemUtilities import FileSystemUtilities
 from eric7.Utilities import ClassBrowsers
 from eric7.Utilities.ClassBrowsers import ClbrBaseClasses
 self.__sysPathItem = None
 self.__remotefsInterface = fsInterface
 if not nopopulate:
-self.watchedItems = {}
+self.watchedDirItems = {}
 self.watchedFileItems = {}
-self.watcher = QFileSystemWatcher(self)
+watcher = EricFileSystemWatcher.instance()
-self.watcher.directoryChanged.connect(self.directoryChanged)
+watcher.directoryCreated.connect(lambda x: self.entryCreated(x, isDir=True))
-self.watcher.fileChanged.connect(self.fileChanged)
+watcher.directoryDeleted.connect(lambda x: self.entryDeleted(x, isDir=True))
+watcher.fileCreated.connect(lambda x: self.entryCreated(x, isDir=False))
+watcher.fileDeleted.connect(lambda x: self.entryDeleted(x, isDir=False))
+watcher.fileModified.connect(self.fileChanged)
 rootData = QCoreApplication.translate("BrowserModel", "Name")
 self.rootItem = BrowserItem(None, rootData)
 self.__populateModel()
 if (
 dirName != ""
 and not FileSystemUtilities.isRemoteFileName(dirName)
 and not dirName.startswith(("//", "\\\\"))
 ):
-if dirName not in self.watcher.directories():
+EricFileSystemWatcher.instance().addPath(dirName)
-self.watcher.addPath(dirName)
+if dirName in self.watchedDirItems:
-if dirName in self.watchedItems:
+if itm not in self.watchedDirItems[dirName]:
-if itm not in self.watchedItems[dirName]:
+self.watchedDirItems[dirName].append(itm)
-self.watchedItems[dirName].append(itm)
 else:
-self.watchedItems[dirName] = [itm]
+self.watchedDirItems[dirName] = [itm]
 def _removeWatchedItem(self, itm):
 """
 Protected method to remove a watched item.
 """
 if isinstance(itm, BrowserDirectoryItem):
 dirName = itm.dirName()
 with contextlib.suppress(KeyError):
 with contextlib.suppress(ValueError):
-self.watchedItems[dirName].remove(itm)
+self.watchedDirItems[dirName].remove(itm)
-if len(self.watchedItems[dirName]) == 0:
+if len(self.watchedDirItems[dirName]) == 0:
-del self.watchedItems[dirName]
+del self.watchedDirItems[dirName]
-self.watcher.removePath(dirName)
+EricFileSystemWatcher.instance().removePath(dirName)
-def directoryChanged(self, path):
+def entryCreated(self, path, isDir=False):
 """
-Public slot to handle the directoryChanged signal of the watcher.
+Public method to handle the creation of a file or directory.
-@param path path of the directory
+@param path path of the created file or directory
 @type str
-"""
+@param isDir flag indicating a created directory (defaults to False)
-if path not in self.watchedItems:
+@type bool (optional)
+"""
+parentPath = os.path.dirname(path)
+if parentPath not in self.watchedDirItems:
 # just ignore the situation we don't have a reference to the item
 return
-dirFilter = (
+for itm in self.watchedDirItems[parentPath]:
-QDir.Filter.AllEntries | QDir.Filter.NoDotAndDotDot | QDir.Filter.Hidden
+cnt = itm.childCount()
-)
+self.beginInsertRows(self.createIndex(itm.row(), 0, itm), cnt, cnt)
+node = (
-for itm in self.watchedItems[path]:
+BrowserDirectoryItem(
-oldCnt = itm.childCount()
+itm,
+FileSystemUtilities.toNativeSeparators(path),
-qdir = QDir(itm.dirName())
+False,
-entryInfoList = qdir.entryInfoList(dirFilter)
-# step 1: check for new entries
-children = itm.children()
-for f in entryInfoList:
-fpath = FileSystemUtilities.toNativeSeparators(f.absoluteFilePath())
-childFound = False
-for child in children[:]:
-if child.name() == fpath:
-childFound = True
-children.remove(child)
-break
-if childFound:
-continue
-cnt = itm.childCount()
-self.beginInsertRows(self.createIndex(itm.row(), 0, itm), cnt, cnt)
-node = (
-BrowserDirectoryItem(
-itm,
-FileSystemUtilities.toNativeSeparators(f.absoluteFilePath()),
-False,
-)
-if f.isDir()
-else BrowserFileItem(
-itm,
-FileSystemUtilities.toNativeSeparators(f.absoluteFilePath()),
-)
 )
-self._addItem(node, itm)
+if isDir
-self.endInsertRows()
+else BrowserFileItem(
+itm,
-# step 2: check for removed entries
+FileSystemUtilities.toNativeSeparators(path),
-if len(entryInfoList) != itm.childCount():
+)
-for row in range(oldCnt - 1, -1, -1):
+)
-child = itm.child(row)
+self._addItem(node, itm)
-childname = FileSystemUtilities.fromNativeSeparators(child.name())
+self.endInsertRows()
-entryFound = False
-for f in entryInfoList[:]:
+def entryDeleted(self, path, isDir=False):  # noqa: U100
-if f.absoluteFilePath() == childname:
+"""
-entryFound = True
+Public method to handle the deletion of a file or directory.
-entryInfoList.remove(f)
-break
+@param path path of the deleted file or directory
-if entryFound:
+@type str
-continue
+@param isDir flag indicating a deleted directory (defaults to False)
+@type bool (optional)
+"""
+parentPath = os.path.dirname(path)
+if parentPath not in self.watchedDirItems:
+# just ignore the situation we don't have a reference to the item
+return
+for itm in self.watchedDirItems[parentPath]:
+for row in range(itm.childCount() - 1, -1, -1):
+child = itm.child(row)
+if child.name() == path:
 self._removeWatchedItem(child)
 self.beginRemoveRows(self.createIndex(itm.row(), 0, itm), row, row)
 itm.removeChild(child)
 self.endRemoveRows()
+break
 def __populateModel(self):
 """
 Private method to populate the browser model.
 """
 if (
 parentItem.type_ == BrowserItemType.File
 and fileName not in self.watchedFileItems
 ):
 # watch the file only in the file browser not the project viewer
-self.watcher.addPath(fileName)
+watcher = EricFileSystemWatcher.instance()
+watcher.addPath(fileName)
 self.watchedFileItems[fileName] = parentItem
 def repopulateFileItem(self, itm):
 """
 Public method to repopulate a file item.
 if os.path.exists(fileName):
 # the file was changed
 self.repopulateFileItem(self.watchedFileItems[fileName])
 else:
 # the file does not exist anymore
+watcher = EricFileSystemWatcher.instance()
+watcher.removePath(fileName)
 del self.watchedFileItems[fileName]
 def populateClassItem(self, parentItem, repopulate=False):
 """
 Public method to populate a class item's subtree.
 @return flag indicating a symbolic link
 @rtype bool
 """
 return self.symlink
+def lineno(self):
+"""
+Public method to return the line number of the item.
+@return line number defining the object
+@rtype int
+"""
+return 0  # just a placeholder implementation
+def colOffset(self):
+"""
+Public method to return the column offset of the item definition.
+@return column offset defining the object
+@rtype int
+"""
+return 0  # default value
 class BrowserSimpleDirectoryItem(BrowserItem):
 """
 Class implementing the data structure for browser simple directory items.
 @return tuple with start end end line number
 @rtype tuple of (int, int)
 """
 return (self._classObject.lineno, self._classObject.endlineno)
+def colOffset(self):
+"""
+Public method to return the column offset of the item definition.
+@return column offset defining the object
+@rtype int
+"""
+return self._classObject.coloffset
 def lessThan(self, other, column, order):
 """
 Public method to check, if the item is less than the other one.
 @param other reference to item to compare against
 @return tuple with start end end line number
 @rtype tuple of (int, int)
 """
 return (self._functionObject.lineno, self._functionObject.endlineno)
+def colOffset(self):
+"""
+Public method to return the column offset of the item definition.
+@return column offset defining the object
+@rtype int
+"""
+return self._functionObject.coloffset
 def lessThan(self, other, column, order):
 """
 Public method to check, if the item is less than the other one.
 @param other reference to item to compare against
 @return line number the object is assigned to
 @rtype list of int
 """
 return self._attributeObject.linenos[:]
+def colOffset(self):
+"""
+Public method to return the column offset of the item definition.
+@return column offset defining the object
+@rtype int
+"""
+return self._attributeObject.coloffset
 def lessThan(self, other, column, order):
 """
 Public method to check, if the item is less than the other one.
 @param other reference to item to compare against

Mercurial Repositories > eric / file comparison

comparison: src/eric7/UI/BrowserModel.py

src/eric7/UI/BrowserModel.py