eric: comparison eric6/UI/UserInterface.py

-:e01ae92db699
+:31965986ecd1
 self.multiProject = MultiProject(self.project, self)
 # Generate the debug server object
 from Debugger.DebugServer import DebugServer
 debugServer = DebugServer(self.__originalPathString,
-project=self.project)
+project=self.project, parent=self)
 # Create the background service object
 from Utilities.BackgroundService import BackgroundService
-self.backgroundService = BackgroundService()
+self.backgroundService = BackgroundService(self)
 splash.showMessage(self.tr("Initializing Plugin Manager..."))
 # Initialize the Plugin Manager (Plugins are initialized later
 from PluginManager.PluginManager import PluginManager
 layout.setSpacing(1)
 layout.addWidget(self.viewmanager.mainWidget())
 layout.addWidget(self.viewmanager.searchWidget())
 layout.addWidget(self.viewmanager.replaceWidget())
 self.viewmanager.mainWidget().setSizePolicy(
-QSizePolicy.Preferred, QSizePolicy.Expanding)
+QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Expanding)
 leftWidget.setLayout(layout)
 self.viewmanager.searchWidget().hide()
 self.viewmanager.replaceWidget().hide()
-splitter = QSplitter(Qt.Horizontal)
+splitter = QSplitter(Qt.Orientation.Horizontal)
 splitter.addWidget(leftWidget)
 self.setCentralWidget(splitter)
 # Create previewer
 logging.debug("Creating Previewer...")
 logging.debug("Creating Toolboxes Layout...")
 # Create the left toolbox
 self.lToolboxDock = self.__createDockWindow("lToolboxDock")
 self.lToolbox = E5VerticalToolBox(self.lToolboxDock)
-self.__setupDockWindow(self.lToolboxDock, Qt.LeftDockWidgetArea,
+self.__setupDockWindow(self.lToolboxDock,
-self.lToolbox, self.tr("Left Toolbox"))
+Qt.DockWidgetArea.LeftDockWidgetArea,
+self.lToolbox,
+self.tr("Left Toolbox"))
 # Create the horizontal toolbox
 self.hToolboxDock = self.__createDockWindow("hToolboxDock")
 self.hToolbox = E5HorizontalToolBox(self.hToolboxDock)
-self.__setupDockWindow(self.hToolboxDock, Qt.BottomDockWidgetArea,
+self.__setupDockWindow(self.hToolboxDock,
+Qt.DockWidgetArea.BottomDockWidgetArea,
 self.hToolbox,
 self.tr("Horizontal Toolbox"))
 # Create the right toolbox
 self.rToolboxDock = self.__createDockWindow("rToolboxDock")
 self.rToolbox = E5VerticalToolBox(self.rToolboxDock)
-self.__setupDockWindow(self.rToolboxDock, Qt.RightDockWidgetArea,
+self.__setupDockWindow(self.rToolboxDock,
-self.rToolbox, self.tr("Right Toolbox"))
+Qt.DockWidgetArea.RightDockWidgetArea,
+self.rToolbox,
+self.tr("Right Toolbox"))
 ####################################################
 ## Populate the left toolbox
 ####################################################
 self.bottomSidebar.setCurrentIndex(0)
 # create the central widget
 logging.debug("Creating central widget...")
 cw = self.centralWidget()   # save the current central widget
-self.leftSplitter = QSplitter(Qt.Horizontal)
+self.leftSplitter = QSplitter(Qt.Orientation.Horizontal)
-self.rightSplitter = QSplitter(Qt.Horizontal)
+self.rightSplitter = QSplitter(Qt.Orientation.Horizontal)
-self.verticalSplitter = QSplitter(Qt.Vertical)
+self.verticalSplitter = QSplitter(Qt.Orientation.Vertical)
 self.verticalSplitter.addWidget(cw)
 self.verticalSplitter.addWidget(self.bottomSidebar)
 self.rightSplitter.addWidget(self.verticalSplitter)
 self.rightSplitter.addWidget(self.rightSidebar)
 self.leftSplitter.addWidget(self.leftSidebar)
 @return the generated dock window (QDockWindow)
 """
 dock = QDockWidget()
 dock.setObjectName(name)
 dock.setFeatures(
-QDockWidget.DockWidgetFeatures(QDockWidget.AllDockWidgetFeatures))
+QDockWidget.DockWidgetFeatures(
+QDockWidget.DockWidgetFeature.DockWidgetClosable |
+QDockWidget.DockWidgetFeature.DockWidgetMovable |
+QDockWidget.DockWidgetFeature.DockWidgetFloatable
+)
+)
 return dock
 def __setupDockWindow(self, dock, where, widget, caption):
 """
 Private method to configure the dock window created with
 """<p>This quits the IDE. Any unsaved changes may be saved"""
 """ first. Any Python program being debugged will be stopped"""
 """ and the preferences will be written to disc.</p>"""
 ))
 self.exitAct.triggered.connect(self.__quit)
-self.exitAct.setMenuRole(QAction.QuitRole)
+self.exitAct.setMenuRole(QAction.MenuRole.QuitRole)
 self.actions.append(self.exitAct)
 self.restartAct = E5Action(
 self.tr('Restart'),
 UI.PixmapCache.getIcon("restart"),
 """<b>Preferences</b>"""
 """<p>Set the configuration items of the application"""
 """ with your prefered values.</p>"""
 ))
 self.prefAct.triggered.connect(self.showPreferences)
-self.prefAct.setMenuRole(QAction.PreferencesRole)
+self.prefAct.setMenuRole(QAction.MenuRole.PreferencesRole)
 self.actions.append(self.prefAct)
 self.prefExportAct = E5Action(
 self.tr('Export Preferences'),
 UI.PixmapCache.getIcon("configureExport"),
 self.addToolBar(starttb)
 self.addToolBar(debugtb)
 self.addToolBar(multiprojecttb)
 self.addToolBar(projecttb)
 self.addToolBar(vcstb)
-self.addToolBar(Qt.RightToolBarArea, settingstb)
+self.addToolBar(Qt.ToolBarArea.RightToolBarArea, settingstb)
-self.addToolBar(Qt.RightToolBarArea, toolstb)
+self.addToolBar(Qt.ToolBarArea.RightToolBarArea, toolstb)
 self.addToolBar(helptb)
 self.addToolBar(bookmarktb)
 self.addToolBar(spellingtb)
 self.addToolBar(unittesttb)
 self.addToolBar(profilestb)
 if not state.isEmpty():
 self.rightSidebar.restoreState(state)
 if self.__layoutType == "Toolboxes":
 # set the corner usages
-self.setCorner(Qt.TopLeftCorner,
+self.setCorner(Qt.Corner.TopLeftCorner,
-Qt.LeftDockWidgetArea)
+Qt.DockWidgetArea.LeftDockWidgetArea)
-self.setCorner(Qt.BottomLeftCorner,
+self.setCorner(Qt.Corner.BottomLeftCorner,
-Qt.LeftDockWidgetArea)
+Qt.DockWidgetArea.LeftDockWidgetArea)
-self.setCorner(Qt.TopRightCorner,
+self.setCorner(Qt.Corner.TopRightCorner,
-Qt.RightDockWidgetArea)
+Qt.DockWidgetArea.RightDockWidgetArea)
-self.setCorner(Qt.BottomRightCorner,
+self.setCorner(Qt.Corner.BottomRightCorner,
-Qt.RightDockWidgetArea)
+Qt.DockWidgetArea.RightDockWidgetArea)
 # step 3: activate the windows of the new profile
 if self.__layoutType == "Toolboxes":
 self.lToolboxDock.setVisible(self.profiles[name][1][0])
 self.hToolboxDock.setVisible(self.profiles[name][1][1])
 self.lToolbox.setCurrentWidget(self.projectBrowser)
 elif self.__layoutType == "Sidebars":
 self.leftSidebar.show()
 self.leftSidebar.setCurrentWidget(self.projectBrowser)
 self.projectBrowser.currentWidget().setFocus(
-Qt.ActiveWindowFocusReason)
+Qt.FocusReason.ActiveWindowFocusReason)
 def __activateMultiProjectBrowser(self):
 """
 Private slot to handle the activation of the project browser.
 """
 self.lToolboxDock.show()
 self.lToolbox.setCurrentWidget(self.multiProjectBrowser)
 elif self.__layoutType == "Sidebars":
 self.leftSidebar.show()
 self.leftSidebar.setCurrentWidget(self.multiProjectBrowser)
-self.multiProjectBrowser.setFocus(Qt.ActiveWindowFocusReason)
+self.multiProjectBrowser.setFocus(
+Qt.FocusReason.ActiveWindowFocusReason)
 def activateDebugViewer(self):
 """
 Public slot to handle the activation of the debug viewer.
 """
 self.rToolboxDock.show()
 self.rToolbox.setCurrentWidget(self.debugViewer)
 elif self.__layoutType == "Sidebars":
 self.rightSidebar.show()
 self.rightSidebar.setCurrentWidget(self.debugViewer)
-self.debugViewer.currentWidget().setFocus(Qt.ActiveWindowFocusReason)
+self.debugViewer.currentWidget().setFocus(
+Qt.FocusReason.ActiveWindowFocusReason)
 def __activateShell(self):
 """
 Private slot to handle the activation of the Shell window.
 """
 self.__shellParent.show()
 self.__shellParent.widget().setCurrentWidget(self.shellAssembly)
 elif self.__layoutType == "Sidebars":
 self.__shellParent.show()
 self.__shellParent.setCurrentWidget(self.shellAssembly)
-self.shell.setFocus(Qt.ActiveWindowFocusReason)
+self.shell.setFocus(Qt.FocusReason.ActiveWindowFocusReason)
 def __activateLogViewer(self):
 """
 Private slot to handle the activation of the Log Viewer.
 """
 self.hToolboxDock.show()
 self.hToolbox.setCurrentWidget(self.logViewer)
 elif self.__layoutType == "Sidebars":
 self.bottomSidebar.show()
 self.bottomSidebar.setCurrentWidget(self.logViewer)
-self.logViewer.setFocus(Qt.ActiveWindowFocusReason)
+self.logViewer.setFocus(Qt.FocusReason.ActiveWindowFocusReason)
 def __activateTaskViewer(self):
 """
 Private slot to handle the activation of the Task Viewer.
 """
 self.hToolboxDock.show()
 self.hToolbox.setCurrentWidget(self.taskViewer)
 elif self.__layoutType == "Sidebars":
 self.bottomSidebar.show()
 self.bottomSidebar.setCurrentWidget(self.taskViewer)
-self.taskViewer.setFocus(Qt.ActiveWindowFocusReason)
+self.taskViewer.setFocus(Qt.FocusReason.ActiveWindowFocusReason)
 def __activateTemplateViewer(self):
 """
 Private slot to handle the activation of the Template Viewer.
 """
 self.lToolboxDock.show()
 self.lToolbox.setCurrentWidget(self.templateViewer)
 elif self.__layoutType == "Sidebars":
 self.leftSidebar.show()
 self.leftSidebar.setCurrentWidget(self.templateViewer)
-self.templateViewer.setFocus(Qt.ActiveWindowFocusReason)
+self.templateViewer.setFocus(
+Qt.FocusReason.ActiveWindowFocusReason)
 def __activateBrowser(self):
 """
 Private slot to handle the activation of the file browser.
 """
 self.lToolboxDock.show()
 self.lToolbox.setCurrentWidget(self.browser)
 elif self.__layoutType == "Sidebars":
 self.leftSidebar.show()
 self.leftSidebar.setCurrentWidget(self.browser)
-self.browser.setFocus(Qt.ActiveWindowFocusReason)
+self.browser.setFocus(Qt.FocusReason.ActiveWindowFocusReason)
 def __toggleLeftToolbox(self):
 """
 Private slot to handle the toggle of the Left Toolbox window.
 """
 hasFocus = self.lToolbox.currentWidget().hasFocus()
 shown = self.__toggleWindow(self.lToolboxDock)
 if shown:
-self.lToolbox.currentWidget().setFocus(Qt.ActiveWindowFocusReason)
+self.lToolbox.currentWidget().setFocus(
+Qt.FocusReason.ActiveWindowFocusReason)
 else:
 if hasFocus:
 self.__activateViewmanager()
 def __toggleRightToolbox(self):
 Private slot to handle the toggle of the Right Toolbox window.
 """
 hasFocus = self.rToolbox.currentWidget().hasFocus()
 shown = self.__toggleWindow(self.rToolboxDock)
 if shown:
-self.rToolbox.currentWidget().setFocus(Qt.ActiveWindowFocusReason)
+self.rToolbox.currentWidget().setFocus(
+Qt.FocusReason.ActiveWindowFocusReason)
 else:
 if hasFocus:
 self.__activateViewmanager()
 def __toggleHorizontalToolbox(self):
 Private slot to handle the toggle of the Horizontal Toolbox window.
 """
 hasFocus = self.hToolbox.currentWidget().hasFocus()
 shown = self.__toggleWindow(self.hToolboxDock)
 if shown:
-self.hToolbox.currentWidget().setFocus(Qt.ActiveWindowFocusReason)
+self.hToolbox.currentWidget().setFocus(
+Qt.FocusReason.ActiveWindowFocusReason)
 else:
 if hasFocus:
 self.__activateViewmanager()
 def __toggleLeftSidebar(self):
 """
 hasFocus = self.leftSidebar.currentWidget().hasFocus()
 shown = self.__toggleWindow(self.leftSidebar)
 if shown:
 self.leftSidebar.currentWidget().setFocus(
-Qt.ActiveWindowFocusReason)
+Qt.FocusReason.ActiveWindowFocusReason)
 else:
 if hasFocus:
 self.__activateViewmanager()
 def __toggleRightSidebar(self):
 """
 hasFocus = self.rightSidebar.currentWidget().hasFocus()
 shown = self.__toggleWindow(self.rightSidebar)
 if shown:
 self.rightSidebar.currentWidget().setFocus(
-Qt.ActiveWindowFocusReason)
+Qt.FocusReason.ActiveWindowFocusReason)
 else:
 if hasFocus:
 self.__activateViewmanager()
 def __toggleBottomSidebar(self):
 """
 hasFocus = self.bottomSidebar.currentWidget().hasFocus()
 shown = self.__toggleWindow(self.bottomSidebar)
 if shown:
 self.bottomSidebar.currentWidget().setFocus(
-Qt.ActiveWindowFocusReason)
+Qt.FocusReason.ActiveWindowFocusReason)
 else:
 if hasFocus:
 self.__activateViewmanager()
 def activateCooperationViewer(self):
 self.rToolboxDock.show()
 self.rToolbox.setCurrentWidget(self.cooperation)
 elif self.__layoutType == "Sidebars":
 self.rightSidebar.show()
 self.rightSidebar.setCurrentWidget(self.cooperation)
-self.cooperation.setFocus(Qt.ActiveWindowFocusReason)
+self.cooperation.setFocus(Qt.FocusReason.ActiveWindowFocusReason)
 def __activateIRC(self):
 """
 Private slot to handle the activation of the IRC window.
 """
 self.rToolboxDock.show()
 self.rToolbox.setCurrentWidget(self.irc)
 elif self.__layoutType == "Sidebars":
 self.rightSidebar.show()
 self.rightSidebar.setCurrentWidget(self.irc)
-self.irc.setFocus(Qt.ActiveWindowFocusReason)
+self.irc.setFocus(Qt.FocusReason.ActiveWindowFocusReason)
 def __activateSymbolsViewer(self):
 """
 Private slot to handle the activation of the Symbols Viewer.
 """
 self.lToolboxDock.show()
 self.lToolbox.setCurrentWidget(self.symbolsViewer)
 elif self.__layoutType == "Sidebars":
 self.leftSidebar.show()
 self.leftSidebar.setCurrentWidget(self.symbolsViewer)
-self.symbolsViewer.setFocus(Qt.ActiveWindowFocusReason)
+self.symbolsViewer.setFocus(Qt.FocusReason.ActiveWindowFocusReason)
 def __activateNumbersViewer(self):
 """
 Private slot to handle the activation of the Numbers Viewer.
 """
 self.hToolboxDock.show()
 self.hToolbox.setCurrentWidget(self.numbersViewer)
 elif self.__layoutType == "Sidebars":
 self.bottomSidebar.show()
 self.bottomSidebar.setCurrentWidget(self.numbersViewer)
-self.numbersViewer.setFocus(Qt.ActiveWindowFocusReason)
+self.numbersViewer.setFocus(Qt.FocusReason.ActiveWindowFocusReason)
 def __activateViewmanager(self):
 """
 Private slot to handle the activation of the current editor.
 """
 aw = self.viewmanager.activeWindow()
 if aw is not None:
-aw.setFocus(Qt.ActiveWindowFocusReason)
+aw.setFocus(Qt.FocusReason.ActiveWindowFocusReason)
 def activateCodeDocumentationViewer(self, switchFocus=True):
 """
 Public slot to handle the activation of the Code Documentation Viewer.
 self.rightSidebar.show()
 self.rightSidebar.setCurrentWidget(
 self.codeDocumentationViewer)
 if switchFocus:
 self.codeDocumentationViewer.setFocus(
-Qt.ActiveWindowFocusReason)
+Qt.FocusReason.ActiveWindowFocusReason)
 def __activatePipWidget(self):
 """
 Private slot to handle the activation of the PyPI manager widget.
 """
 self.rToolboxDock.show()
 self.rToolbox.setCurrentWidget(self.pipWidget)
 elif self.__layoutType == "Sidebars":
 self.rightSidebar.show()
 self.rightSidebar.setCurrentWidget(self.pipWidget)
-self.pipWidget.setFocus(Qt.ActiveWindowFocusReason)
+self.pipWidget.setFocus(Qt.FocusReason.ActiveWindowFocusReason)
 def __activateCondaWidget(self):
 """
 Private slot to handle the activation of the Conda manager widget.
 """
 self.rToolboxDock.show()
 self.rToolbox.setCurrentWidget(self.condaWidget)
 elif self.__layoutType == "Sidebars":
 self.rightSidebar.show()
 self.rightSidebar.setCurrentWidget(self.condaWidget)
-self.condaWidget.setFocus(Qt.ActiveWindowFocusReason)
+self.condaWidget.setFocus(Qt.FocusReason.ActiveWindowFocusReason)
 def __activateMicroPython(self):
 """
 Private slot to handle the activation of the MicroPython widget.
 """
 self.rToolboxDock.show()
 self.rToolbox.setCurrentWidget(self.microPythonWidget)
 elif self.__layoutType == "Sidebars":
 self.rightSidebar.show()
 self.rightSidebar.setCurrentWidget(self.microPythonWidget)
-self.microPythonWidget.setFocus(Qt.ActiveWindowFocusReason)
+self.microPythonWidget.setFocus(
+Qt.FocusReason.ActiveWindowFocusReason)
 def __toggleWindow(self, w):
 """
 Private method to toggle a workspace editor window.
 Private slot to handle the tools configuration menu entry.
 """
 from Preferences.ToolConfigurationDialog import ToolConfigurationDialog
 dlg = ToolConfigurationDialog(
 self.toolGroups[self.currentToolGroup][1], self)
-if dlg.exec() == QDialog.Accepted:
+if dlg.exec() == QDialog.DialogCode.Accepted:
 self.toolGroups[self.currentToolGroup][1] = dlg.getToollist()
 self.__updateExternalToolsActions()
 def __toolGroupsConfiguration(self):
 """
 from Preferences.ToolGroupConfigurationDialog import (
 ToolGroupConfigurationDialog
 )
 dlg = ToolGroupConfigurationDialog(
 self.toolGroups, self.currentToolGroup, self)
-if dlg.exec() == QDialog.Accepted:
+if dlg.exec() == QDialog.DialogCode.Accepted:
 self.toolGroups, self.currentToolGroup = dlg.getToolGroups()
 def __createUnitTestDialog(self):
 """
 Private slot to generate the unit test dialog on demand.
 'Ensure that it is available as <b>{1}</b>.</p>')
 .format(tool['menutext'], tool['executable']))
 else:
 self.toolProcs.append((program, proc, procData))
 if tool['redirect'] == 'no':
-proc.closeReadChannel(QProcess.StandardOutput)
+proc.closeReadChannel(QProcess.ProcessChannel.StandardOutput)
-proc.closeReadChannel(QProcess.StandardError)
+proc.closeReadChannel(QProcess.ProcessChannel.StandardError)
 proc.closeWriteChannel()
 def __processToolStdout(self):
 """
 Private slot to handle the readyReadStdout signal of a tool process.
 """
 ioEncoding = Preferences.getSystem("IOEncoding")
 # loop through all running tool processes
 for program, toolProc, toolProcData in self.toolProcs:
-toolProc.setReadChannel(QProcess.StandardOutput)
+toolProc.setReadChannel(QProcess.ProcessChannel.StandardOutput)
 if (
 toolProcData[0] is None or
 toolProcData[1] not in ["insert", "replaceSelection"]
 ):
 """
 ioEncoding = Preferences.getSystem("IOEncoding")
 # loop through all running tool processes
 for program, toolProc, _toolProcData in self.toolProcs:
-toolProc.setReadChannel(QProcess.StandardError)
+toolProc.setReadChannel(QProcess.ProcessChannel.StandardError)
 while toolProc.canReadLine():
 error = str(toolProc.readLine(), ioEncoding, 'replace')
 s = "{0} - {1}".format(program, error)
 self.appendToStderr(s)
 """
 exitedProcs = []
 # loop through all running tool processes
 for program, toolProc, toolProcData in self.toolProcs:
-if toolProc.state() == QProcess.NotRunning:
+if toolProc.state() == QProcess.ProcessState.NotRunning:
 exitedProcs.append((program, toolProc, toolProcData))
 if toolProcData[0] is not None:
 if toolProcData[1] == "replaceSelection":
 text = ''.join(toolProcData[2])
 toolProcData[0].replace(text)
 @type str
 @param useSingle flag indicating to use a single browser window
 @type bool
 """
 if isinstance(home, QUrl):
-home = home.toString(QUrl.None_)
+home = home.toString(QUrl.UrlFormattingOption.None_)
 if len(home) > 0:
 homeUrl = QUrl(home)
 if not homeUrl.scheme():
 home = QUrl.fromLocalFile(home).toString()
 else:
 connectCount -= 1
 QThread.msleep(1000)
 QApplication.processEvents()
 if (
-process.state() == QProcess.NotRunning and
+process.state() == QProcess.ProcessState.NotRunning and
-process.exitStatus() == QProcess.NormalExit and
+process.exitStatus() == QProcess.ExitStatus.NormalExit and
 process.exitCode() == 100
 ):
 # Process exited prematurely due to missing pre-requisites
 return -1
 if res <= 0:
 self.__lastConfigurationPageName)
 else:
 self.__configurationDialog.showConfigurationPageByName("empty")
 self.__configurationDialog.exec()
 QApplication.processEvents()
-if self.__configurationDialog.result() == QDialog.Accepted:
+if (
+self.__configurationDialog.result() ==
+QDialog.DialogCode.Accepted
+):
 self.__configurationDialog.setPreferences()
 Preferences.syncPreferences()
 self.__preferencesChanged()
 self.__lastConfigurationPageName = (
 self.__configurationDialog.getConfigurationPageName()
 Private slot to configure the various view profiles.
 """
 from Preferences.ViewProfileDialog import ViewProfileDialog
 dlg = ViewProfileDialog(self.__layoutType, self.profiles['edit'][1],
 self.profiles['debug'][1])
-if dlg.exec() == QDialog.Accepted:
+if dlg.exec() == QDialog.DialogCode.Accepted:
 edit, debug = dlg.getVisibilities()
 self.profiles['edit'][1] = edit
 self.profiles['debug'][1] = debug
 Preferences.setUI("ViewProfiles2", self.profiles)
 if self.currentProfile == "edit":
 """
 Private slot to configure the various toolbars.
 """
 from E5Gui.E5ToolBarDialog import E5ToolBarDialog
 dlg = E5ToolBarDialog(self.toolbarManager)
-if dlg.exec() == QDialog.Accepted:
+if dlg.exec() == QDialog.DialogCode.Accepted:
 Preferences.setUI(
 "ToolbarManagerState", self.toolbarManager.saveState())
 def __configShortcuts(self):
 """
 """
 Private slot to clear the private data lists.
 """
 from .ClearPrivateDataDialog import ClearPrivateDataDialog
 dlg = ClearPrivateDataDialog(self)
-if dlg.exec() == QDialog.Accepted:
+if dlg.exec() == QDialog.DialogCode.Accepted:
 # recent files, recent projects, recent multi  projects,
 # debug histories, shell histories
 (files, projects, multiProjects, debug, shell, vcs, plugins) = (
 dlg.getData()
 )
 else:
 # try old style XML file second
 fn = os.path.join(Utilities.getConfigDir(), "eric6tasks.e6t")
 if os.path.exists(fn):
 f = QFile(fn)
-if f.open(QIODevice.ReadOnly):
+if f.open(QIODevice.OpenModeFlag.ReadOnly):
 from E5XML.TasksReader import TasksReader
 reader = TasksReader(f, viewer=self.taskViewer)
 reader.readXML()
 f.close()
 else:
 if fn.endswith(".esj"):
 res = self.__sessionFile.writeFile(fn)
 else:
 f = QFile(fn)
-if f.open(QIODevice.WriteOnly):
+if f.open(QIODevice.OpenModeFlag.WriteOnly):
 from E5XML.SessionWriter import SessionWriter
 SessionWriter(f, None).writeXML()
 f.close()
 res = True
 else:
 res = self.__sessionFile.readFile(fn)
 self.__readingSession = False
 else:
 # old XML based format
 f = QFile(fn)
-if f.open(QIODevice.ReadOnly):
+if f.open(QIODevice.OpenModeFlag.ReadOnly):
 from E5XML.SessionReader import SessionReader
 self.__readingSession = True
 reader = SessionReader(f, True)
 reader.readXML()
 self.__readingSession = False
 Public slot to show the plugins available for download.
 """
 from PluginManager.PluginRepositoryDialog import PluginRepositoryDialog
 dlg = PluginRepositoryDialog(self.pluginManager, self)
 res = dlg.exec()
-if res == (QDialog.Accepted + 1):
+if res == (QDialog.DialogCode.Accepted + 1):
 self.__installPlugins(dlg.getDownloadedPlugins())
 def __pluginsConfigure(self):
 """
 Private slot to show the plugin manager configuration page.
 self.__versionsDownloadCanceled)
 self.__versionCheckProgress.setLabelText(
 self.tr("Trying host {0}").format(url.host()))
 self.__versionCheckProgress.setValue(alternative)
 request = QNetworkRequest(url)
-request.setAttribute(QNetworkRequest.CacheLoadControlAttribute,
+request.setAttribute(
-QNetworkRequest.AlwaysNetwork)
+QNetworkRequest.Attribute.CacheLoadControlAttribute,
+QNetworkRequest.CacheLoadControl.AlwaysNetwork)
 reply = self.__networkManager.get(request)
 reply.finished.connect(lambda: self.__versionsDownloadDone(reply))
 self.__replies.append(reply)
 @pyqtSlot()
 return
 reply.deleteLater()
 if reply in self.__replies:
 self.__replies.remove(reply)
-if reply.error() == QNetworkReply.NoError:
+if reply.error() == QNetworkReply.NetworkError.NoError:
 ioEncoding = Preferences.getSystem("IOEncoding")
 versions = str(reply.readAll(), ioEncoding, 'replace').splitlines()
 reply.close()
 if (
-reply.error() != QNetworkReply.NoError or
+reply.error() != QNetworkReply.NetworkError.NoError or
 len(versions) == 0 or
 versions[0].startswith("<")
 ):
 # network error or an error page
 self.httpAlternative += 1
 @param evt reference to the show event (QShowEvent)
 """
 if self.__startup:
 if Preferences.getGeometry("MainMaximized"):
-self.setWindowState(Qt.WindowStates(Qt.WindowMaximized))
+self.setWindowState(
+Qt.WindowStates(Qt.WindowState.WindowMaximized))
 self.__startup = False
 ##########################################
 ## Support for desktop notifications below
 ##########################################

Mercurial Repositories > eric / file comparison

comparison: eric6/UI/UserInterface.py

eric6/UI/UserInterface.py