eric: comparison src/eric7/ViewManager/ViewManager.py

-:280a53840aa3
+:306373ccf8fd
 import re
 from PyQt6.Qsci import QsciScintilla
 from PyQt6.QtCore import (
 QCoreApplication,
-QFileSystemWatcher,
 QPoint,
 QSignalMapper,
 Qt,
 pyqtSignal,
 pyqtSlot,
 )
 from PyQt6.QtGui import QKeySequence, QPixmap
 from PyQt6.QtWidgets import QApplication, QDialog, QMenu, QToolBar, QWidget
 from eric7 import Preferences
+from eric7.EricCore import EricFileSystemWatcher
 from eric7.EricGui import EricPixmapCache
 from eric7.EricGui.EricAction import EricAction, createActionGroup
 from eric7.EricWidgets import EricFileDialog, EricMessageBox
 from eric7.EricWidgets.EricApplication import ericApp
 from eric7.Globals import recentNameFiles
 self.__cooperationClient = None
 self.__lastFocusWidget = None
 # initialize the file system watcher
-self.__watcher = QFileSystemWatcher(self)
+watcher = EricFileSystemWatcher.instance()
-self.__watcher.fileChanged.connect(self.__watchedFileChanged)
+watcher.fileModified.connect(self.__watchedFileChanged)
+self.__watchedFilePaths = []
 def setReferences(self, ui, dbs, remoteServerInterface):
 """
 Public method to set some references needed later on.
 )
 self.openRemoteAct.triggered.connect(self.__openRemoteFiles)
 self.openRemoteAct.setEnabled(False)
 self.fileActions.append(self.openRemoteAct)
+self.reloadAct = EricAction(
+QCoreApplication.translate("ViewManager", "Reload"),
+EricPixmapCache.getIcon("reload"),
+QCoreApplication.translate("ViewManager", "Reload"),
+0,
+0,
+self,
+"vm_file_reload",
+)
+self.reloadAct.setStatusTip(
+QCoreApplication.translate("ViewManager", "Reload the current file")
+)
+self.reloadAct.setWhatsThis(
+QCoreApplication.translate(
+"ViewManager",
+"""<b>Reload</b>"""
+"""<p>Reload the contents of current editor window. If the editor"""
+""" contents was modified, a warning will be issued.</p>""",
+)
+)
+self.reloadAct.triggered.connect(self.__reloadCurrentEditor)
+self.fileActions.append(self.reloadAct)
 self.closeActGrp = createActionGroup(self)
 self.closeAct = EricAction(
 QCoreApplication.translate("ViewManager", "Close"),
 EricPixmapCache.getIcon("closeEditor"),
 menu.setTearOffEnabled(True)
 menu.addAction(self.newAct)
 menu.addAction(self.openAct)
 menu.addAction(self.openRemoteAct)
+menu.addAction(self.reloadAct)
 self.menuRecentAct = menu.addMenu(self.recentMenu)
 menu.addMenu(self.bookmarkedMenu)
 menu.addSeparator()
 menu.addAction(self.closeAct)
 menu.addAction(self.closeAllAct)
 tb.setToolTip(QCoreApplication.translate("ViewManager", "File"))
 tb.addAction(self.newAct)
 tb.addAction(self.openAct)
 tb.addAction(self.openRemoteAct)
+tb.addAction(self.reloadAct)
 tb.addAction(self.closeAct)
 tb.addSeparator()
 tb.addAction(self.saveAct)
 tb.addAction(self.saveAsAct)
 tb.addAction(self.saveAsRemoteAct)
 if FileSystemUtilities.isPlainFileName(prog):
 prog = os.path.abspath(prog)
 # Open up the new files.
 self.openSourceFile(prog)
+@pyqtSlot()
+def __reloadCurrentEditor(self):
+"""
+Private slot to reload the contents of the current editor.
+"""
+aw = self.activeWindow()
+if aw:
+aw.reload()
 def checkDirty(self, editor, autosave=False, closeIt=False):
 """
 Public method to check the dirty status and open a message window.
 @param editor editor window to check
 @param pos position within the line to place the cursor at
 @type int
 @param addNext flag indicating to add the file next to the current
 editor
 @type bool
-@param indexes of the editor, first the split view index, second the
+@param indexes indexes of the editor, first the split view index, second the
 index within the view
 @type tuple of two int
 @return reference to the opened editor
 @rtype Editor
 """
 # insert filename into list of recently opened files
 self.addToRecentList(fn)
 return editor
+@pyqtSlot(str, int, int)
+def openSourceFileLinePos(self, fn, lineno, pos):
+"""
+Public slot to display a file in an editor at a given line and position.
+@param fn name of file to be opened
+@type str
+@param lineno line number to place the cursor at
+@type int
+@param pos position within line to position cursor at
+@type int
+"""
+self.openSourceFile(fn, lineno=lineno, pos=pos + 1)
 def __connectEditor(self, editor):
 """
 Private method to establish all editor connections.
 @param editor reference to the editor object to be connected
 editor.selectionChanged.connect(
 lambda: self.__searchReplaceWidget.selectionChanged(editor)
 )
 editor.selectionChanged.connect(lambda: self.__editorSelectionChanged(editor))
 editor.lastEditPositionAvailable.connect(self.__lastEditPositionAvailable)
-editor.zoomValueChanged.connect(lambda v: self.zoomValueChanged(v, editor))
 editor.mouseDoubleClick.connect(
 lambda pos, buttons: self.__editorDoubleClicked(editor, pos, buttons)
 )
 editor.languageChanged.connect(lambda: self.editorLanguageChanged.emit(editor))
 self.copyActGrp.setEnabled(False)
 self.viewActGrp.setEnabled(False)
 self.sbZoom.setEnabled(False)
 else:
 self.sbZoom.setEnabled(True)
-self.sbZoom.setValue(now.getZoom())
+if isinstance(now, Shell):
+self.sbZoom.setValue(now.getZoom())
 if not isinstance(now, (Editor, Shell)):
 self.searchActGrp.setEnabled(False)
 if not isinstance(now, (Editor, Shell)):
 @param value new zoom value
 @type int
 @param zoomingWidget reference to the widget triggering the slot
 @type Editor or Shell
 """
-aw = (
+if QApplication.focusWidget() == ericApp().getObject("Shell"):  # noqa: Y108
-ericApp().getObject("Shell")
+aw = ericApp().getObject("Shell")
-if QApplication.focusWidget() == ericApp().getObject("Shell")
+else:
-else self.activeWindow()
+aw = (
-)
+self.activeWindow()
+if self.activeWindow() == QApplication.focusWidget()
+else QApplication.focusWidget()
+)
 if aw and aw == zoomingWidget:
 self.sbZoom.setValue(value)
 def __clearAllFolds(self):
 """
 def __lastEditorClosed(self):
 """
 Private slot to handle the lastEditorClosed signal.
 """
+self.reloadAct.setEnabled(False)
 self.closeActGrp.setEnabled(False)
 self.saveActGrp.setEnabled(False)
 self.exportersMenuAct.setEnabled(False)
 self.printAct.setEnabled(False)
 if self.printPreviewAct:
 @type Editor
 @param setSb flag indicating an update of the status bar is wanted
 @type bool
 """
 if editor is not None:
+self.reloadAct.setEnabled(bool(editor.getFileName()))
 self.saveAct.setEnabled(editor.isModified())
 self.revertAct.setEnabled(editor.isModified())
 self.undoAct.setEnabled(editor.isUndoAvailable())
 self.redoAct.setEnabled(editor.isRedoAvailable())
 Public method to add a file to the list of monitored files.
 @param filePath path of the file to be added
 @type str
 """
-if filePath and FileSystemUtilities.isPlainFileName(filePath):
+if (
-self.__watcher.addPath(filePath)
+filePath
+and FileSystemUtilities.isPlainFileName(filePath)
+and filePath not in self.__watchedFilePaths
+):
+watcher = EricFileSystemWatcher.instance()
+watcher.addPath(filePath)
+self.__watchedFilePaths.append(filePath)
 def removeWatchedFilePath(self, filePath):
 """
 Public method to remove a file from the list of monitored files.
 @param filePath path of the file to be removed
 @type str
 """
-if self.getOpenEditorCount(
+if (
 filePath
-) == 0 and FileSystemUtilities.isPlainFileName(filePath):
+and self.getOpenEditorCount(filePath) == 0
-self.__watcher.removePath(filePath)
+and FileSystemUtilities.isPlainFileName(filePath)
+and filePath in self.__watchedFilePaths
+):
+watcher = EricFileSystemWatcher.instance()
+watcher.removePath(filePath)
+self.__watchedFilePaths.remove(filePath)
 ##################################################################
 ## Below are protected utility methods
 ##################################################################

Mercurial Repositories > eric / file comparison

comparison: src/eric7/ViewManager/ViewManager.py

src/eric7/ViewManager/ViewManager.py