eric: comparison UI/UserInterface.py

-:06e7d2941ead
+:331ac8f99cf8
 ErrorLogFileName = "eric6_error.log"
 def __init__(self, app, locale, splash, plugin, disabledPlugins,
 noOpenAtStartup, noCrashOpenAtStartup, disableCrashSession,
-restartArguments):
+restartArguments, originalPathString):
 """
 Constructor
 @param app reference to the application object
 @type E5Application
 support
 @type bool
 @param restartArguments list of command line parameters to be used for
 a restart
 @type list of str
+@param originalPathString original PATH environment variable
+@type str
 """
 super(UserInterface, self).__init__()
 self.__restartArgs = restartArguments[:]
 self.__noOpenAtStartup = noOpenAtStartup
 self.__noCrashOpenAtStartup = noCrashOpenAtStartup
 self.__disableCrashSession = disableCrashSession
 self.__disabledPlugins = disabledPlugins[:]
+self.__originalPathString = originalPathString
 self.__layoutType = Preferences.getUI("LayoutType")
 self.passiveMode = Preferences.getDebugger("PassiveDbgEnabled")
 g = Preferences.getGeometry("MainGeometry")
 # register it early because it is needed very soon
 e5App().registerObject("VirtualEnvManager", self.virtualenvManager)
 # Generate the debug server object
 from Debugger.DebugServer import DebugServer
-debugServer = DebugServer()
+debugServer = DebugServer(self.__originalPathString)
 # Create the background service object
 from Utilities.BackgroundService import BackgroundService
 self.backgroundService = BackgroundService()
 if self.templateViewer is not None:
 # now read the saved templates
 splash.showMessage(self.tr("Reading Templates..."))
 self.templateViewer.readTemplates()
-# now start the debug client
+# now start the debug client with the most recently used virtual
+# environment
 splash.showMessage(self.tr("Starting Debugger..."))
-debugServer.startClient(False)
+if Preferences.getShell("StartWithMostRecentlyUsedEnvironment"):
+debugServer.startClient(
+False, venvName=Preferences.getShell("LastVirtualEnvironment")
+)
+else:
+debugServer.startClient(False)
 # attributes for the network objects
 self.__networkManager = QNetworkAccessManager(self)
 self.__networkManager.proxyAuthenticationRequired.connect(
 proxyAuthenticationRequired)
 # Create the shell
 logging.debug("Creating Shell...")
 from QScintilla.Shell import ShellAssembly
 self.shellAssembly = \
-ShellAssembly(debugServer, self.viewmanager, True)
+ShellAssembly(debugServer, self.viewmanager, self.project, True)
 self.shell = self.shellAssembly.shell()
 self.hToolbox.insertItem(0, self.shellAssembly,
 UI.PixmapCache.getIcon("shell.png"),
 self.tr("Shell"))
 # Create the shell
 logging.debug("Creating Shell...")
 from QScintilla.Shell import ShellAssembly
 self.shellAssembly = \
-ShellAssembly(debugServer, self.viewmanager, True)
+ShellAssembly(debugServer, self.viewmanager, self.project, True)
 self.shell = self.shellAssembly.shell()
 self.bottomSidebar.insertTab(0, self.shellAssembly,
 UI.PixmapCache.getIcon("shell.png"),
 self.tr("Shell"))
 def __designer(self, fn=None, version=0):
 """
 Private slot to start the Qt-Designer executable.
 @param fn filename of the form to be opened
-@param version indication for the requested version (Qt 4) (integer)
+@type str
+@param version indication for the requested version (4 = Qt 4/5)
+@type int
 """
 if fn is not None and version == 0:
 # determine version from file, if not specified
 try:
 f = open(fn, "r", encoding="utf-8")
 'Ensure that it is available as <b>{0}</b>.</p>'
 ).format(designer))
 def __designer4(self):
 """
-Private slot to start the Qt-Designer 4 executable.
+Private slot to start the Qt-Designer 4/5 executable.
 """
 self.__designer(version=4)
 def __linguist(self, fn=None, version=0):
 """
 Private slot to start the Qt-Linguist executable.
 @param fn filename of the translation file to be opened
-@param version indication for the requested version (Qt 4) (integer)
+@type str
+@param version indication for the requested version (4 = Qt 4/5)
+@type int
 """
 if version < 4:
 E5MessageBox.information(
 self,
 self.tr("Qt 3 support"),
 @pyqtSlot()
 @pyqtSlot(str)
 def __linguist4(self, fn=None):
 """
-Private slot to start the Qt-Linguist 4 executable.
+Private slot to start the Qt-Linguist 4/5 executable.
 @param fn filename of the translation file to be opened
 """
 self.__linguist(fn, version=4)
 def __assistant(self, home=None, version=0):
 """
 Private slot to start the Qt-Assistant executable.
-@param home full pathname of a file to display (string)
+@param home full pathname of a file to display
-@param version indication for the requested version (Qt 4) (integer)
+@type str
+@param version indication for the requested version (4 = Qt 4/5)
+@type int
 """
 if version < 4:
 E5MessageBox.information(
 self,
 self.tr("Qt 3 support"),
 'Ensure that it is available as <b>{0}</b>.</p>'
 ).format(assistant))
 def __assistant4(self):
 """
-Private slot to start the Qt-Assistant 4 executable.
+Private slot to start the Qt-Assistant 4/5 executable.
 """
 self.__assistant(version=4)
 def __startWebBrowser(self):
 """
 @param newPassword new master password (string)
 """
 self.masterPasswordChanged.emit(oldPassword, newPassword)
 Preferences.convertPasswords(oldPassword, newPassword)
 if self.helpWindow is None:
-from Helpviewer.Passwords.PasswordManager import PasswordManager
+if WEBENGINE_AVAILABLE:
-pwManager = PasswordManager()
+from WebBrowser.Passwords.PasswordManager import \
-pwManager.masterPasswordChanged(oldPassword, newPassword)
+PasswordManager
+pwManager = PasswordManager()
+pwManager.masterPasswordChanged(oldPassword, newPassword)
+elif WEBKIT_AVAILABLE:
+from Helpviewer.Passwords.PasswordManager import \
+PasswordManager
+pwManager = PasswordManager()
+pwManager.masterPasswordChanged(oldPassword, newPassword)
 Utilities.crypto.changeRememberedMaster(newPassword)
 def __reloadAPIs(self):
 """
 Private slot to reload the api information.
 def showPluginsAvailable(self):
 """
 Public slot to show the plugins available for download.
 """
 from PluginManager.PluginRepositoryDialog import PluginRepositoryDialog
-dlg = PluginRepositoryDialog(self)
+dlg = PluginRepositoryDialog(self.pluginManager, self)
 res = dlg.exec_()
 if res == (QDialog.Accepted + 1):
 self.__installPlugins(dlg.getDownloadedPlugins())
 def __pluginsConfigure(self):
 """
 s = w.size()
 p = w.pos()
 return [p.x(), p.y(), s.width(), s.height(), not w.isHidden()]
+def getOriginalPathString(self):
+"""
+Public method to get the original PATH environment variable
+(i.e. before modifications by eric6 and PyQt5).
+@return original PATH environment variable
+@rtype str
+"""
+return self.__originalPathString
 ############################
 ## some event handlers below
 ############################
 def showEvent(self, evt):

Mercurial Repositories > eric / file comparison

comparison: UI/UserInterface.py

UI/UserInterface.py