eric: UI/UserInterface.py@c3eb7cc1ff8b (annotated)

 # -*- coding: utf-8 -*-
 # Copyright (c) 2002 - 2010 Detlev Offenbach <detlev@die-offenbachs.de>
 #
 """
 Module implementing the main user interface.
 """
 import os
 import sys
 import io
 import logging
 from PyQt4.QtCore import *
 from PyQt4.QtGui import *
 from PyQt4.Qsci import QSCINTILLA_VERSION_STR
 from PyQt4.QtNetwork import QHttp, QNetworkProxy
 from E4Gui.E4Application import e5App
 from Debugger.DebugUI import DebugUI
 from Debugger.DebugServer import DebugServer
 from Debugger.DebugViewer import DebugViewer
 from Debugger.DebugClientCapabilities import HasUnittest
 from QScintilla.Shell import Shell
 from QScintilla.Terminal import Terminal
 from QScintilla.MiniEditor import MiniEditor
 from QScintilla.SpellChecker import SpellChecker
 from PyUnit.UnittestDialog import UnittestDialog
 from Helpviewer.HelpWindow import HelpWindow
 from Preferences.ConfigurationDialog import ConfigurationDialog
 from Preferences.ViewProfileDialog import ViewProfileDialog
 from Preferences.ShortcutsDialog import ShortcutsDialog
 from Preferences.ToolConfigurationDialog import ToolConfigurationDialog
 from Preferences.ToolGroupConfigurationDialog import ToolGroupConfigurationDialog
 from Preferences.ProgramsDialog import ProgramsDialog
 from Preferences import Shortcuts
 from PluginManager.PluginManager import PluginManager
 from PluginManager.PluginInfoDialog import PluginInfoDialog
 from PluginManager.PluginInstallDialog import PluginInstallDialog
 from PluginManager.PluginUninstallDialog import PluginUninstallDialog
 from PluginManager.PluginRepositoryDialog import PluginRepositoryDialog
 from Project.Project import Project
 from Project.ProjectBrowser import ProjectBrowser
 from MultiProject.MultiProject import MultiProject
 from MultiProject.MultiProjectBrowser import MultiProjectBrowser
 from Tasks.TaskViewer import TaskViewer
 from Templates.TemplateViewer import TemplateViewer
 from .Browser import Browser
 from .Info import *
 from . import Config
 from .EmailDialog import EmailDialog
 from .DiffDialog import DiffDialog
 from .CompareDialog import CompareDialog
 from .LogView import LogViewer
 from .FindFileDialog import FindFileDialog
 from .FindFileNameDialog import FindFileNameDialog
 from .AuthenticationDialog import AuthenticationDialog
 from E4Gui.E4SingleApplication import E4SingleApplicationServer
 from E4Gui.E4Action import E4Action, createActionGroup
 from E4Gui.E4ToolBarManager import E4ToolBarManager
 from E4Gui.E4ToolBarDialog import E4ToolBarDialog
 from E4Gui.E4SqueezeLabels import E4SqueezeLabelPath
 from E4Gui.E4ToolBox import E4VerticalToolBox, E4HorizontalToolBox
 from E4Gui.E4SideBar import E4SideBar
 from E4Gui.E4TabWidget import E4TabWidget
 from VCS.StatusMonitorLed import StatusMonitorLed
 import Preferences
 import ViewManager
 import Utilities
 from Graphics.PixmapDiagram import PixmapDiagram
 from Graphics.SvgDiagram import SvgDiagram
 import UI.PixmapCache
 from E5XML.XMLUtilities import make_parser
 from E5XML.XMLErrorHandler import XMLErrorHandler, XMLFatalParseError
 from E5XML.XMLEntityResolver import XMLEntityResolver
 from E5XML.TasksHandler import TasksHandler
 from E5XML.TasksWriter import TasksWriter
 from E5XML.TemplatesHandler import TemplatesHandler
 from E5XML.TemplatesWriter import TemplatesWriter
 from E5XML.SessionWriter import SessionWriter
 from E5XML.SessionHandler import SessionHandler
 from IconEditor.IconEditorWindow import IconEditorWindow
 from eric5config import getConfig
 class Redirector(QObject):
     """
     Helper class used to redirect stdout and stderr to the log window
     @signal appendStderr(string) emitted to write data to stderr logger
     @signal appendStdout(string) emitted to write data to stdout logger
     """
     def __init__(self, stderr):
         """
         Constructor
         @param stderr flag indicating stderr is being redirected
         """
         QObject.__init__(self)
         self.stderr = stderr
         self.buffer = ''
     def __nWrite(self, n):
         """
         Private method used to write data.
         @param n max number of bytes to write
         """
         if n:
             line = self.buffer[:n]
             if self.stderr:
                 self.emit(SIGNAL('appendStderr'), line)
             else:
                 self.emit(SIGNAL('appendStdout'), line)
             self.buffer = self.buffer[n:]
     def __bufferedWrite(self):
         """
         Private method returning number of characters to write.
         @return number of characters buffered or length of buffered line (integer)
         """
         return self.buffer.rfind('\n') + 1
     def flush(self):
         """
         Public method used to flush the buffered data.
         """
         self.__nWrite(len(self.buffer))
     def write(self, s):
         """
         Public method used to write data.
         @param s data to be written (it must support the str-method)
         """
         self.buffer += str(s)
         self.__nWrite(self.__bufferedWrite())
 class UserInterface(QMainWindow):
     """
     Class implementing the main user interface.
     @signal appendStderr(QString) emitted to write data to stderr logger
     @signal appendStdout(QString) emitted to write data to stdout logger
     @signal preferencesChanged() emitted after the preferences were changed
     @signal reloadAPIs() emitted to reload the api information
     @signal showMenu(string, QMenu) emitted when a menu is about to be shown. The name
             of the menu and a reference to the menu are given.
     """
     maxFilePathLen = 100
     maxSbFilePathLen = 150
     maxMenuFilePathLen = 75
     def __init__(self, locale, splash, plugin, noOpenAtStartup, restartArguments):
         """
         Constructor
         @param locale locale to be used by the UI (string)
         @param splash reference to the splashscreen (UI.SplashScreen.SplashScreen)
         @param plugin filename of a plugin to be loaded (used for plugin development)
         @param noOpenAtStartup flag indicating that the open at startup option
             should not be executed (boolean)
         @param restartArguments list of command line parameters to be used for a
             restart (list of strings)
         """
         QMainWindow.__init__(self)
         self.__restartArgs = restartArguments[:]
         self.defaultStyleName = QApplication.style().objectName()
         self.__setStyle()
         self.maxEditorPathLen = Preferences.getUI("CaptionFilenameLength")
         self.locale = locale
         self.__noOpenAtStartup = noOpenAtStartup
         self.layout, self.embeddedShell, self.embeddedFileBrowser = \
             Preferences.getUILayout()
         self.passiveMode = Preferences.getDebugger("PassiveDbgEnabled")
         g = Preferences.getGeometry("MainGeometry")
         if g.isEmpty():
             s = QSize(800, 600)
             self.resize(s)
         else:
             self.restoreGeometry(g)
         self.__startup = True
         self.capProject = ""
         self.capEditor = ""
         self.captionShowsFilename = Preferences.getUI("CaptionShowsFilename")
         QApplication.setWindowIcon(UI.PixmapCache.getIcon("eric.png"))
         self.setWindowIcon(UI.PixmapCache.getIcon("eric.png"))
         self.__setWindowCaption()
         # load the view profiles
         self.profiles = Preferences.getUI("ViewProfiles")
         # Generate the debug server object
         debugServer = DebugServer()
         # Generate an empty project object and multi project object
         self.project = Project(self)
         self.multiProject = MultiProject(self.project, self)
         splash.showMessage(self.trUtf8("Initializing Plugin Manager..."))
         # Initialize the Plugin Manager (Plugins are initialized later
         self.pluginManager = PluginManager(self, develPlugin = plugin)
         splash.showMessage(self.trUtf8("Generating Main User Interface..."))
         # Create the main window now so that we can connect QActions to it.
         logging.debug("Creating Layout...")
         self.__createLayout(debugServer)
         # Generate the debugger part of the ui
         logging.debug("Creating Debugger UI...")
         self.debuggerUI = DebugUI(self, self.viewmanager, debugServer,
                                   self.debugViewer, self.project)
         self.debugViewer.setDebugger(self.debuggerUI)
         self.shell.setDebuggerUI(self.debuggerUI)
         # Generate the redirection helpers
         self.stdout = Redirector(False)
         self.stderr = Redirector(True)
         # Genrae the programs dialog
         logging.debug("Creating Programs Dialog...")
         self.programsDialog = ProgramsDialog(self)
         # Generate the shortcuts configuration dialog
         logging.debug("Creating Shortcuts Dialog...")
         self.shortcutsDialog = ShortcutsDialog(self, 'Shortcuts')
         # now setup the connections
         splash.showMessage(self.trUtf8("Setting up connections..."))
         self.connect(self.browser, SIGNAL('sourceFile'),
                      self.viewmanager.openSourceFile)
         self.connect(self.browser, SIGNAL('designerFile'),
                      self.__designer)
         self.connect(self.browser, SIGNAL('linguistFile'),
                      self.__linguist4)
         self.connect(self.browser, SIGNAL('projectFile'),
                      self.project.openProject)
         self.connect(self.browser, SIGNAL('multiProjectFile'),
                      self.multiProject.openMultiProject)
         self.connect(self.browser, SIGNAL('pixmapEditFile'),
                      self.__editPixmap)
         self.connect(self.browser, SIGNAL('pixmapFile'),
                      self.__showPixmap)
         self.connect(self.browser, SIGNAL('svgFile'),
                      self.__showSvg)
         self.connect(self.browser, SIGNAL('unittestOpen'),
                      self.__unittestScript)
         self.connect(self.browser, SIGNAL('trpreview'),
                      self.__TRPreviewer)
         self.connect(self.debugViewer.exceptionLogger, SIGNAL('sourceFile'),
                      self.viewmanager.openSourceFile)
         self.connect(self.debugViewer, SIGNAL('sourceFile'),
                      self.viewmanager.showDebugSource)
         self.connect(self.taskViewer, SIGNAL('displayFile'),
                      self.viewmanager.openSourceFile)
         self.connect(self.projectBrowser.psBrowser, SIGNAL('sourceFile'),
                      self.viewmanager.openSourceFile)
         self.connect(self.projectBrowser.psBrowser, SIGNAL('closeSourceWindow'),
                      self.viewmanager.closeWindow)
         self.connect(self.projectBrowser.psBrowser, SIGNAL('unittestOpen'),
                      self.__unittestScript)
         self.connect(self.projectBrowser.pfBrowser, SIGNAL('designerFile'),
                      self.__designer)
         self.connect(self.projectBrowser.pfBrowser, SIGNAL('sourceFile'),
                      self.viewmanager.openSourceFile)
         self.connect(self.projectBrowser.pfBrowser, SIGNAL('uipreview'),
                      self.__UIPreviewer)
         self.connect(self.projectBrowser.pfBrowser, SIGNAL('trpreview'),
                      self.__TRPreviewer)
         self.connect(self.projectBrowser.pfBrowser, SIGNAL('closeSourceWindow'),
                      self.viewmanager.closeWindow)
         self.connect(self.projectBrowser.pfBrowser, SIGNAL('appendStdout'),
                      self.appendToStdout)
         self.connect(self.projectBrowser.pfBrowser, SIGNAL('appendStderr'),
                      self.appendToStderr)
         self.connect(self.projectBrowser.prBrowser, SIGNAL('sourceFile'),
                      self.viewmanager.openSourceFile)
         self.connect(self.projectBrowser.prBrowser, SIGNAL('closeSourceWindow'),
                      self.viewmanager.closeWindow)
         self.connect(self.projectBrowser.prBrowser, SIGNAL('appendStdout'),
                      self.appendToStdout)
         self.connect(self.projectBrowser.prBrowser, SIGNAL('appendStderr'),
                      self.appendToStderr)
         self.connect(self.projectBrowser.ptBrowser, SIGNAL('linguistFile'),
                      self.__linguist4)
         self.connect(self.projectBrowser.ptBrowser, SIGNAL('sourceFile'),
                      self.viewmanager.openSourceFile)
         self.connect(self.projectBrowser.ptBrowser, SIGNAL('trpreview'),
                      self.__TRPreviewer)
         self.connect(self.projectBrowser.ptBrowser, SIGNAL('closeSourceWindow'),
                      self.viewmanager.closeWindow)
         self.connect(self.projectBrowser.ptBrowser, SIGNAL('appendStdout'),
                      self.appendToStdout)
         self.connect(self.projectBrowser.ptBrowser, SIGNAL('appendStderr'),
                      self.appendToStderr)
         self.connect(self.projectBrowser.piBrowser, SIGNAL('sourceFile'),
                      self.viewmanager.openSourceFile)
         self.connect(self.projectBrowser.piBrowser, SIGNAL('closeSourceWindow'),
                      self.viewmanager.closeWindow)
         self.connect(self.projectBrowser.piBrowser, SIGNAL('appendStdout'),
                      self.appendToStdout)
         self.connect(self.projectBrowser.piBrowser, SIGNAL('appendStderr'),
                      self.appendToStderr)
         self.connect(self.projectBrowser.poBrowser, SIGNAL('sourceFile'),
                      self.viewmanager.openSourceFile)
         self.connect(self.projectBrowser.poBrowser, SIGNAL('closeSourceWindow'),
                      self.viewmanager.closeWindow)
         self.connect(self.projectBrowser.poBrowser, SIGNAL('pixmapEditFile'),
                      self.__editPixmap)
         self.connect(self.projectBrowser.poBrowser, SIGNAL('pixmapFile'),
                      self.__showPixmap)
         self.connect(self.projectBrowser.poBrowser, SIGNAL('svgFile'),
                      self.__showSvg)
         self.connect(self.project, SIGNAL('sourceFile'),
                     self.viewmanager.openSourceFile)
         self.connect(self.project, SIGNAL('newProject'),
                      self.viewmanager.newProject)
         self.connect(self.project, SIGNAL('projectOpened'),
                      self.viewmanager.projectOpened)
         self.connect(self.project, SIGNAL('projectClosed'),
                      self.viewmanager.projectClosed)
         self.connect(self.project, SIGNAL('projectFileRenamed'),
                      self.viewmanager.projectFileRenamed)
         self.connect(self.project, SIGNAL('lexerAssociationsChanged'),
                      self.viewmanager.projectLexerAssociationsChanged)
         self.connect(self.project, SIGNAL('newProject'),
                      self.__newProject)
         self.connect(self.project, SIGNAL('projectOpened'),
                      self.__projectOpened)
         self.connect(self.project, SIGNAL('projectOpened'),
                      self.__activateProjectBrowser)
         self.connect(self.project, SIGNAL('projectClosed'),
                      self.__projectClosed)
         self.connect(self.multiProject, SIGNAL("multiProjectOpened"),
                      self.__activateMultiProjectBrowser)
         self.connect(self.debuggerUI, SIGNAL('resetUI'),
                      self.viewmanager.handleResetUI)
         self.connect(self.debuggerUI, SIGNAL('resetUI'),
                      self.debugViewer.handleResetUI)
         self.connect(self.debuggerUI, SIGNAL('resetUI'),
                      self.__setEditProfile)
         self.connect(self.debuggerUI, SIGNAL('debuggingStarted'),
                      self.browser.handleProgramChange)
         self.connect(self.debuggerUI, SIGNAL('debuggingStarted'),
                      self.debugViewer.exceptionLogger.debuggingStarted)
         self.connect(self.debuggerUI, SIGNAL('debuggingStarted'),
                      self.debugViewer.handleDebuggingStarted)
         self.connect(self.debuggerUI, SIGNAL('debuggingStarted'),
                      self.__programChange)
         self.connect(self.debuggerUI, SIGNAL('debuggingStarted'),
                      self.__debuggingStarted)
         self.connect(self.debuggerUI, SIGNAL('compileForms'),
                      self.projectBrowser.pfBrowser.compileChangedForms)
         self.connect(self.debuggerUI, SIGNAL('compileResources'),
                      self.projectBrowser.prBrowser.compileChangedResources)
         self.connect(debugServer, SIGNAL('passiveDebugStarted'),
                      self.debugViewer.exceptionLogger.debuggingStarted)
         self.connect(debugServer, SIGNAL('passiveDebugStarted'),
                      self.debugViewer.handleDebuggingStarted)
         self.connect(debugServer, SIGNAL('clientException'),
                      self.debugViewer.exceptionLogger.addException)
         self.connect(debugServer, SIGNAL('clientLine'),
                      self.debugViewer.breakpointViewer.highlightBreakpoint)
         self.connect(debugServer, SIGNAL('clientProcessStdout'),
                      self.appendToStdout)
         self.connect(debugServer, SIGNAL('clientProcessStderr'),
                      self.appendToStderr)
         self.connect(self.stdout, SIGNAL('appendStdout'),
                      self.appendToStdout)
         self.connect(self.stderr, SIGNAL('appendStderr'),
                      self.appendToStderr)
         self.connect(self, SIGNAL('preferencesChanged'),
                      self.viewmanager.preferencesChanged)
         self.connect(self, SIGNAL('reloadAPIs'),
                      self.viewmanager.getAPIsManager().reloadAPIs)
         self.connect(self, SIGNAL('preferencesChanged'),
                      self.logViewer.preferencesChanged)
         self.connect(self, SIGNAL('appendStdout'),
                      self.logViewer.appendToStdout)
         self.connect(self, SIGNAL('appendStderr'),
                      self.logViewer.appendToStderr)
         self.connect(self, SIGNAL('preferencesChanged'),
                      self.shell.handlePreferencesChanged)
         self.connect(self, SIGNAL('preferencesChanged'),
                      self.terminal.handlePreferencesChanged)
         self.connect(self, SIGNAL('preferencesChanged'),
                      self.project.handlePreferencesChanged)
         self.connect(self, SIGNAL('preferencesChanged'),
                      self.projectBrowser.handlePreferencesChanged)
         self.connect(self, SIGNAL('preferencesChanged'),
                      self.projectBrowser.psBrowser.handlePreferencesChanged)
         self.connect(self, SIGNAL('preferencesChanged'),
                      self.projectBrowser.pfBrowser.handlePreferencesChanged)
         self.connect(self, SIGNAL('preferencesChanged'),
                      self.projectBrowser.prBrowser.handlePreferencesChanged)
         self.connect(self, SIGNAL('preferencesChanged'),
                      self.projectBrowser.ptBrowser.handlePreferencesChanged)
         self.connect(self, SIGNAL('preferencesChanged'),
                      self.projectBrowser.piBrowser.handlePreferencesChanged)
         self.connect(self, SIGNAL('preferencesChanged'),
                      self.projectBrowser.poBrowser.handlePreferencesChanged)
         self.connect(self, SIGNAL('preferencesChanged'),
                      self.browser.handlePreferencesChanged)
         self.connect(self, SIGNAL('preferencesChanged'),
                      self.taskViewer.handlePreferencesChanged)
         self.connect(self, SIGNAL('preferencesChanged'),
                      self.pluginManager.preferencesChanged)
         self.connect(self, SIGNAL('preferencesChanged'),
                      debugServer.preferencesChanged)
         self.connect(self.viewmanager, SIGNAL('editorSaved'),
                      self.project.repopulateItem)
         self.connect(self.viewmanager, SIGNAL('lastEditorClosed'),
                      self.__lastEditorClosed)
         self.connect(self.viewmanager, SIGNAL('editorOpened'),
                      self.__editorOpened)
         self.connect(self.viewmanager, SIGNAL('changeCaption'),
                      self.__setWindowCaption)
         self.connect(self.viewmanager, SIGNAL('checkActions'),
                      self.__checkActions)
         self.connect(self.viewmanager, SIGNAL('editorChanged'),
                      self.projectBrowser.handleEditorChanged)
         # Generate the unittest dialog
         self.unittestDialog = UnittestDialog(None, self.debuggerUI.debugServer, self)
         self.connect(self.unittestDialog, SIGNAL('unittestFile'),
                      self.viewmanager.setFileLine)
         # Generate the find in project files dialog
         self.findFilesDialog = FindFileDialog(self.project)
         self.connect(self.findFilesDialog, SIGNAL('sourceFile'),
                      self.viewmanager.openSourceFile)
         self.connect(self.findFilesDialog, SIGNAL('designerFile'),
                      self.__designer)
         self.replaceFilesDialog = FindFileDialog(self.project, replaceMode = True)
         self.connect(self.replaceFilesDialog, SIGNAL('sourceFile'),
                      self.viewmanager.openSourceFile)
         self.connect(self.replaceFilesDialog, SIGNAL('designerFile'),
                      self.__designer)
         # generate the find file dialog
         self.findFileNameDialog = FindFileNameDialog(self.project)
         self.connect(self.findFileNameDialog, SIGNAL('sourceFile'),
                      self.viewmanager.openSourceFile)
         self.connect(self.findFileNameDialog, SIGNAL('designerFile'),
                      self.__designer)
         # generate the diff dialogs
         self.diffDlg = DiffDialog()
         self.compareDlg = CompareDialog()
         # create the toolbar manager object
         self.toolbarManager = E4ToolBarManager(self, self)
         self.toolbarManager.setMainWindow(self)
         # Initialize the tool groups and list of started tools
         splash.showMessage(self.trUtf8("Initializing Tools..."))
         self.toolGroups, self.currentToolGroup = Preferences.readToolGroups()
         self.toolProcs = []
         self.__initExternalToolsActions()
         # create a dummy help window for shortcuts handling
         self.dummyHelpViewer = HelpWindow(None, '.', None, 'help viewer', True, True)
         # register all relevant objects
         splash.showMessage(self.trUtf8("Registering Objects..."))
         e5App().registerObject("UserInterface", self)
         e5App().registerObject("DebugUI", self.debuggerUI)
         e5App().registerObject("DebugServer", debugServer)
         e5App().registerObject("ViewManager", self.viewmanager)
         e5App().registerObject("Project", self.project)
         e5App().registerObject("ProjectBrowser", self.projectBrowser)
         e5App().registerObject("MultiProject", self.multiProject)
         e5App().registerObject("TaskViewer", self.taskViewer)
         e5App().registerObject("TemplateViewer", self.templateViewer)
         e5App().registerObject("Shell", self.shell)
         e5App().registerObject("FindFilesDialog", self.findFilesDialog)
         e5App().registerObject("ReplaceFilesDialog", self.replaceFilesDialog)
         e5App().registerObject("DummyHelpViewer", self.dummyHelpViewer)
         e5App().registerObject("PluginManager", self.pluginManager)
         e5App().registerObject("ToolbarManager", self.toolbarManager)
         e5App().registerObject("Terminal", self.terminal)
         # Initialize the actions, menus, toolbars and statusbar
         splash.showMessage(self.trUtf8("Initializing Actions..."))
         self.__initActions()
         splash.showMessage(self.trUtf8("Initializing Menus..."))
         self.__initMenus()
         splash.showMessage(self.trUtf8("Initializing Toolbars..."))
         self.__initToolbars()
         splash.showMessage(self.trUtf8("Initializing Statusbar..."))
         self.__initStatusbar()
         # Initialise the instance variables.
         self.currentProg = None
         self.isProg = False
         self.utEditorOpen = False
         self.utProjectOpen = False
         self.inDragDrop = False
         self.setAcceptDrops(True)
         self.currentProfile = None
         self.shutdownCalled = False
         self.inCloseEevent = False
         # now redirect stdout and stderr
         # TODO: release - reenable redirection
 ##        sys.stdout = self.stdout
 ##        sys.stderr = self.stderr
         # now fire up the single application server
         if Preferences.getUI("SingleApplicationMode"):
             splash.showMessage(self.trUtf8("Initializing Single Application Server..."))
             self.SAServer = E4SingleApplicationServer()
         else:
             self.SAServer = None
         # now finalize the plugin manager setup
         self.pluginManager.finalizeSetup()
         # now activate plugins having autoload set to True
         splash.showMessage(self.trUtf8("Activating Plugins..."))
         self.pluginManager.activatePlugins()
         # now read the keyboard shortcuts for all the actions
         Shortcuts.readShortcuts()
         # restore toolbar manager state
         splash.showMessage(self.trUtf8("Restoring Toolbarmanager..."))
         self.toolbarManager.restoreState(Preferences.getUI("ToolbarManagerState"))
         # now activate the initial view profile
         self.__setEditProfile()
         # now read the saved tasks
         self.__readTasks()
         # now read the saved templates
         self.templateViewer.readTemplates()
         # now start the debug client
         debugServer.startClient(False)
         # attribute for the http client object
         self.http = None
         # attribute for the help window
         self.helpWindow = None
         # list of web addresses serving the versions file
         self.__httpAlternatives = Preferences.getUI("VersionsUrls5")
         self.__inVersionCheck = False
         self.__versionCheckProgress = None
         # set spellchecker defaults
         SpellChecker.setDefaultLanguage(
             Preferences.getEditor("SpellCheckingDefaultLanguage"))
     def __setStyle(self):
         """
         Private slot to set the style of the interface.
         """
         # step 1: set the style
         style = None
         styleName = Preferences.getUI("Style")
         if styleName != "System" and styleName in list(QStyleFactory.keys()):
             style = QStyleFactory.create(styleName)
         if style is None:
             style = QStyleFactory.create(self.defaultStyleName)
         if style is not None:
             QApplication.setStyle(style)
         # step 2: set a style sheet
         styleSheetFile = Preferences.getUI("StyleSheet")
         if styleSheetFile:
             try:
                 f = open(styleSheetFile, "r", encoding = "utf-8")
                 styleSheet = f.read()
                 f.close()
             except IOError as msg:
                 QMessageBox.warning(None,
                     self.trUtf8("Loading Style Sheet"),
                     self.trUtf8("""<p>The Qt Style Sheet file <b>{0}</b> could"""
                                 """ not be read.<br>Reason: {1}</p>""")
                         .format(styleSheetFile, str(msg)),
                     QMessageBox.StandardButtons(\
                         QMessageBox.Ok))
                 return
         else:
             styleSheet = ""
         e5App().setStyleSheet(styleSheet)
     def __createLayout(self, debugServer):
         """
         Private method to create the layout of the various windows.
         @param debugServer reference to the debug server object
         """
         # Create the view manager depending on the configuration setting
         logging.debug("Creating Viewmanager...")
         self.viewmanager = \
             ViewManager.factory(self, self, debugServer, self.pluginManager)
         centralWidget = QWidget()
         layout = QVBoxLayout()
         layout.setContentsMargins(1, 1, 1, 1)
         layout.addWidget(self.viewmanager)
         layout.addWidget(self.viewmanager.searchDlg)
         layout.addWidget(self.viewmanager.replaceDlg)
         self.viewmanager.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Expanding)
         centralWidget.setLayout(layout)
         self.setCentralWidget(centralWidget)
         self.viewmanager.searchDlg.hide()
         self.viewmanager.replaceDlg.hide()
         # Create layout with movable dock windows
         if self.layout == "DockWindows":
             logging.debug("Creating dockable windows...")
             self.__createDockWindowsLayout(debugServer)
         # Create layout with toolbox windows embedded in dock windows
         elif self.layout == "Toolboxes":
             logging.debug("Creating toolboxes...")
             self.__createToolboxesLayout(debugServer)
         # Create layout with sidebar windows embedded in dock windows
         elif self.layout == "Sidebars":
             logging.debug("Creating sidebars...")
             self.__createSidebarsLayout(debugServer)
         # Create layout with floating windows
         elif self.layout == "FloatingWindows":
             logging.debug("Creating floating windows...")
             self.__createFloatingWindowsLayout(debugServer)
         else:
             raise RuntimeError("wrong layout type given (%s)" % self.layout)
         logging.debug("Created Layout")
     def __createFloatingWindowsLayout(self, debugServer):
         """
         Private method to create the FloatingWindows layout.
         @param debugServer reference to the debug server object
         """
         # Create the project browser
         self.projectBrowser = ProjectBrowser(self.project, None,
             embeddedBrowser=(self.embeddedFileBrowser == 2))
         self.projectBrowser.setWindowTitle(self.trUtf8("Project-Viewer"))
         # Create the multi project browser
         self.multiProjectBrowser = MultiProjectBrowser(self.multiProject)
         self.multiProjectBrowser.setWindowTitle(self.trUtf8("Multiproject-Viewer"))
         # Create the debug viewer maybe without the embedded shell
         self.debugViewer = DebugViewer(debugServer, False, self.viewmanager, None,
             embeddedShell=self.embeddedShell,
             embeddedBrowser=(self.embeddedFileBrowser == 1))
         self.debugViewer.setWindowTitle(self.trUtf8("Debug-Viewer"))
         # Create the log viewer part of the user interface
         self.logViewer = LogViewer(None)
         self.logViewer.setWindowTitle(self.trUtf8("Log-Viewer"))
         # Create the task viewer part of the user interface
         self.taskViewer = TaskViewer(None, self.project)
         self.taskViewer.setWindowTitle(self.trUtf8("Task-Viewer"))
         # Create the template viewer part of the user interface
         self.templateViewer = TemplateViewer(None, self.viewmanager)
         self.templateViewer.setWindowTitle(self.trUtf8("Template-Viewer"))
         # Create the terminal
         self.terminal = Terminal(self.viewmanager)
         self.terminal.setWindowTitle(self.trUtf8("Terminal"))
         self.windows = [self.projectBrowser, None, self.debugViewer,
             None, self.logViewer, self.taskViewer, self.templateViewer,
             self.multiProjectBrowser, self.terminal]
         if self.embeddedShell:
             self.shell = self.debugViewer.shell
         else:
             # Create the shell
             self.shell = Shell(debugServer, self.viewmanager, None)
             self.windows[3] = self.shell
         if self.embeddedFileBrowser == 0:   # separate window
             # Create the file browser
             self.browser = Browser(None)
             self.browser.setWindowTitle(self.trUtf8("File-Browser"))
             self.windows[1] = self.browser
         elif self.embeddedFileBrowser == 1: # embedded in debug browser
             self.browser = self.debugViewer.browser
         else:                               # embedded in project browser
             self.browser = self.projectBrowser.fileBrowser
     def __createDockWindowsLayout(self, debugServer):
         """
         Private method to create the DockWindows layout.
         @param debugServer reference to the debug server object
         """
         # Create the project browser
         self.projectBrowserDock = self.__createDockWindow("ProjectBrowserDock")
         self.projectBrowser = ProjectBrowser(self.project, self.projectBrowserDock,
             embeddedBrowser=(self.embeddedFileBrowser == 2))
         self.__setupDockWindow(self.projectBrowserDock, Qt.LeftDockWidgetArea,
                              self.projectBrowser, self.trUtf8("Project-Viewer"))
         # Create the multi project browser
         self.multiProjectBrowserDock = \
             self.__createDockWindow("MultiProjectBrowserDock")
         self.multiProjectBrowser = MultiProjectBrowser(self.multiProject)
         self.__setupDockWindow(self.multiProjectBrowserDock, Qt.LeftDockWidgetArea,
                              self.multiProjectBrowser,
                              self.trUtf8("Multiproject-Viewer"))
         # Create the debug viewer maybe without the embedded shell
         self.debugViewerDock = self.__createDockWindow("DebugViewerDock")
         self.debugViewer = DebugViewer(debugServer, True, self.viewmanager,
             self.debugViewerDock,
             embeddedShell=self.embeddedShell,
             embeddedBrowser=(self.embeddedFileBrowser == 1))
         self.__setupDockWindow(self.debugViewerDock, Qt.RightDockWidgetArea,
                              self.debugViewer, self.trUtf8("Debug-Viewer"))
         # Create the log viewer part of the user interface
         self.logViewerDock = self.__createDockWindow("LogViewerDock")
         self.logViewer = LogViewer(self.logViewerDock)
         self.__setupDockWindow(self.logViewerDock, Qt.BottomDockWidgetArea,
                              self.logViewer, self.trUtf8("Log-Viewer"))
         # Create the task viewer part of the user interface
         self.taskViewerDock = self.__createDockWindow("TaskViewerDock")
         self.taskViewer = TaskViewer(self.taskViewerDock, self.project)
         self.__setupDockWindow(self.taskViewerDock, Qt.BottomDockWidgetArea,
                              self.taskViewer, self.trUtf8("Task-Viewer"))
         # Create the template viewer part of the user interface
         self.templateViewerDock = self.__createDockWindow("TemplateViewerDock")
         self.templateViewer = TemplateViewer(self.templateViewerDock,
                                              self.viewmanager)
         self.__setupDockWindow(self.templateViewerDock, Qt.RightDockWidgetArea,
                              self.templateViewer, self.trUtf8("Template-Viewer"))
         # Create the terminal
         self.terminalDock = self.__createDockWindow("TerminalDock")
         self.terminal = Terminal(self.viewmanager, self.terminalDock)
         self.__setupDockWindow(self.terminalDock, Qt.BottomDockWidgetArea,
                              self.terminal, self.trUtf8("Terminal"))
         self.windows = [self.projectBrowserDock, None, self.debugViewerDock,
             None, self.logViewerDock, self.taskViewerDock, self.templateViewerDock,
             self.multiProjectBrowserDock, self.terminalDock]
         if self.embeddedShell:
             self.shell = self.debugViewer.shell
         else:
             # Create the shell
             self.shellDock = self.__createDockWindow("ShellDock")
             self.shell = Shell(debugServer, self.viewmanager, self.shellDock)
             self.__setupDockWindow(self.shellDock, Qt.BottomDockWidgetArea,
                                  self.shell, self.trUtf8("Shell"))
             self.windows[3] = self.shellDock
         if self.embeddedFileBrowser == 0:   # separate window
             # Create the file browser
             self.browserDock = self.__createDockWindow("BrowserDock")
             self.browser = Browser(self.browserDock)
             self.__setupDockWindow(self.browserDock, Qt.RightDockWidgetArea,
                                  self.browser, self.trUtf8("File-Browser"))
             self.windows[1] = self.browserDock
         elif self.embeddedFileBrowser == 1: # embedded in debug browser
             self.browser = self.debugViewer.browser
         else:                               # embedded in project browser
             self.browser = self.projectBrowser.fileBrowser
     def __createToolboxesLayout(self, debugServer):
         """
         Private method to create the Toolboxes layout.
         @param debugServer reference to the debug server object
         """
         # Create the vertical toolbox
         self.vToolboxDock = self.__createDockWindow("vToolboxDock")
         self.vToolbox = E4VerticalToolBox(self.vToolboxDock)
         self.__setupDockWindow(self.vToolboxDock, Qt.LeftDockWidgetArea,
                                self.vToolbox, self.trUtf8("Vertical Toolbox"))
         # Create the horizontal toolbox
         self.hToolboxDock = self.__createDockWindow("hToolboxDock")
         self.hToolbox = E4HorizontalToolBox(self.hToolboxDock)
         self.__setupDockWindow(self.hToolboxDock, Qt.BottomDockWidgetArea,
                                self.hToolbox, self.trUtf8("Horizontal Toolbox"))
         # Create the project browser
         self.projectBrowser = ProjectBrowser(self.project, None,
             embeddedBrowser=(self.embeddedFileBrowser == 2))
         self.vToolbox.addItem(self.projectBrowser,
                               UI.PixmapCache.getIcon("projectViewer.png"),
                               self.trUtf8("Project-Viewer"))
         # Create the multi project browser
         self.multiProjectBrowser = MultiProjectBrowser(self.multiProject)
         self.vToolbox.addItem(self.multiProjectBrowser,
                               UI.PixmapCache.getIcon("multiProjectViewer.png"),
                               self.trUtf8("Multiproject-Viewer"))
         # Create the template viewer part of the user interface
         self.templateViewer = TemplateViewer(None,
                                              self.viewmanager)
         self.vToolbox.addItem(self.templateViewer,
                               UI.PixmapCache.getIcon("templateViewer.png"),
                               self.trUtf8("Template-Viewer"))
         # Create the debug viewer maybe without the embedded shell
         self.debugViewerDock = self.__createDockWindow("DebugViewerDock")
         self.debugViewer = DebugViewer(debugServer, True, self.viewmanager,
             self.debugViewerDock,
             embeddedShell=self.embeddedShell,
             embeddedBrowser=(self.embeddedFileBrowser == 1))
         self.__setupDockWindow(self.debugViewerDock, Qt.RightDockWidgetArea,
                              self.debugViewer, self.trUtf8("Debug-Viewer"))
         # Create the terminal part of the user interface
         self.terminal = Terminal(self.viewmanager)
         self.hToolbox.addItem(self.terminal,
                               UI.PixmapCache.getIcon("terminal.png"),
                               self.trUtf8("Terminal"))
         # Create the task viewer part of the user interface
         self.taskViewer = TaskViewer(None, self.project)
         self.hToolbox.addItem(self.taskViewer,
                               UI.PixmapCache.getIcon("task.png"),
                               self.trUtf8("Task-Viewer"))
         # Create the log viewer part of the user interface
         self.logViewer = LogViewer()
         self.hToolbox.addItem(self.logViewer,
                               UI.PixmapCache.getIcon("logViewer.png"),
                               self.trUtf8("Log-Viewer"))
         self.windows = [None, None, self.debugViewerDock,
             None, None, None, None, None]
         if self.embeddedShell:
             self.shell = self.debugViewer.shell
         else:
             # Create the shell
             self.shell = Shell(debugServer, self.viewmanager)
             self.hToolbox.insertItem(0, self.shell,
                                      UI.PixmapCache.getIcon("shell.png"),
                                      self.trUtf8("Shell"))
         if self.embeddedFileBrowser == 0:   # separate window
             # Create the file browser
             self.browser = Browser()
             self.vToolbox.addItem(self.browser,
                                   UI.PixmapCache.getIcon("browser.png"),
                                   self.trUtf8("File-Browser"))
         elif self.embeddedFileBrowser == 1: # embedded in debug browser
             self.browser = self.debugViewer.browser
         else:                               # embedded in project browser
             self.browser = self.projectBrowser.fileBrowser
         self.hToolbox.setCurrentIndex(0)
     def __createSidebarsLayout(self, debugServer):
         """
         Private method to create the Sidebars layout.
         @param debugServer reference to the debug server object
         """
         # Create the left sidebar
         self.leftSidebar = E4SideBar(E4SideBar.West)
         # Create the bottom sidebar
         self.bottomSidebar = E4SideBar(E4SideBar.South)
         # Create the project browser
         logging.debug("Creating Project Browser...")
         self.projectBrowser = ProjectBrowser(self.project, None,
             embeddedBrowser=(self.embeddedFileBrowser == 2))
         self.leftSidebar.addTab(self.projectBrowser,
                               UI.PixmapCache.getIcon("projectViewer.png"),
                               self.trUtf8("Project-Viewer"))
         # Create the multi project browser
         logging.debug("Creating Multiproject Browser...")
         self.multiProjectBrowser = MultiProjectBrowser(self.multiProject)
         self.leftSidebar.addTab(self.multiProjectBrowser,
                               UI.PixmapCache.getIcon("multiProjectViewer.png"),
                               self.trUtf8("Multiproject-Viewer"))
         # Create the template viewer part of the user interface
         logging.debug("Creating Template Viewer...")
         self.templateViewer = TemplateViewer(None,
                                              self.viewmanager)
         self.leftSidebar.addTab(self.templateViewer,
                               UI.PixmapCache.getIcon("templateViewer.png"),
                               self.trUtf8("Template-Viewer"))
         # Create the debug viewer maybe without the embedded shell
         logging.debug("Creating Debug Viewer...")
         self.debugViewerDock = self.__createDockWindow("DebugViewerDock")
         self.debugViewer = DebugViewer(debugServer, True, self.viewmanager,
             self.debugViewerDock,
             embeddedShell=self.embeddedShell,
             embeddedBrowser=(self.embeddedFileBrowser == 1))
         self.__setupDockWindow(self.debugViewerDock, Qt.RightDockWidgetArea,
                              self.debugViewer, self.trUtf8("Debug-Viewer"))
         # Create the terminal part of the user interface
         logging.debug("Creating Terminal...")
         self.terminal = Terminal(self.viewmanager)
         self.bottomSidebar.addTab(self.terminal,
                               UI.PixmapCache.getIcon("terminal.png"),
                               self.trUtf8("Terminal"))
         # Create the task viewer part of the user interface
         logging.debug("Creating Task Viewer...")
         self.taskViewer = TaskViewer(None, self.project)
         self.bottomSidebar.addTab(self.taskViewer,
                               UI.PixmapCache.getIcon("task.png"),
                               self.trUtf8("Task-Viewer"))
         # Create the log viewer part of the user interface
         logging.debug("Creating Log Viewer...")
         self.logViewer = LogViewer()
         self.bottomSidebar.addTab(self.logViewer,
                               UI.PixmapCache.getIcon("logViewer.png"),
                               self.trUtf8("Log-Viewer"))
         self.windows = [None, None, self.debugViewerDock,
             None, None, None, None, None]
         if self.embeddedShell:
             self.shell = self.debugViewer.shell
         else:
             # Create the shell
             logging.debug("Creating Shell...")
             self.shell = Shell(debugServer, self.viewmanager)
             self.bottomSidebar.insertTab(0, self.shell,
                                      UI.PixmapCache.getIcon("shell.png"),
                                      self.trUtf8("Shell"))
         if self.embeddedFileBrowser == 0:   # separate window
             # Create the file browser
             logging.debug("Creating File Browser...")
             self.browser = Browser()
             self.leftSidebar.addTab(self.browser,
                                   UI.PixmapCache.getIcon("browser.png"),
                                   self.trUtf8("File-Browser"))
         elif self.embeddedFileBrowser == 1: # embedded in debug browser
             self.browser = self.debugViewer.browser
         else:                               # embedded in project browser
             self.browser = self.projectBrowser.fileBrowser
         self.bottomSidebar.setCurrentIndex(0)
         # create the central widget
         logging.debug("Creating central widget...")
         cw = self.centralWidget()   # save the current central widget
         self.horizontalSplitter = QSplitter(Qt.Horizontal)
         self.verticalSplitter = QSplitter(Qt.Vertical)
         self.verticalSplitter.addWidget(cw)
         self.verticalSplitter.addWidget(self.bottomSidebar)
         self.horizontalSplitter.addWidget(self.leftSidebar)
         self.horizontalSplitter.addWidget(self.verticalSplitter)
         self.setCentralWidget(self.horizontalSplitter)
         self.leftSidebar.setSplitter(self.horizontalSplitter)
         self.bottomSidebar.setSplitter(self.verticalSplitter)
     def __configureDockareaCornerUsage(self):
         """
         Private method to configure the usage of the dockarea corners.
         """
         if Preferences.getUI("TopLeftByLeft"):
             self.setCorner(Qt.TopLeftCorner, Qt.LeftDockWidgetArea)
         else:
             self.setCorner(Qt.TopLeftCorner, Qt.TopDockWidgetArea)
         if Preferences.getUI("BottomLeftByLeft"):
             self.setCorner(Qt.BottomLeftCorner, Qt.LeftDockWidgetArea)
         else:
             self.setCorner(Qt.BottomLeftCorner, Qt.BottomDockWidgetArea)
         if Preferences.getUI("TopRightByRight"):
             self.setCorner(Qt.TopRightCorner, Qt.RightDockWidgetArea)
         else:
             self.setCorner(Qt.TopRightCorner, Qt.TopDockWidgetArea)
         if Preferences.getUI("BottomRightByRight"):
             self.setCorner(Qt.BottomRightCorner, Qt.RightDockWidgetArea)
         else:
             self.setCorner(Qt.BottomRightCorner, Qt.BottomDockWidgetArea)
     def showLogTab(self, tabname):
         """
         Public method to show a particular Log-Viewer tab.
         @param tabname string naming the tab to be shown (string)
         """
         if Preferences.getUI("LogViewerAutoRaise"):
             if self.layout == "DockWindows":
                 self.logViewerDock.show()
                 self.logViewerDock.raise_()
             elif self.layout == "Toolboxes":
                 self.hToolboxDock.show()
                 self.hToolbox.setCurrentWidget(self.logViewer)
                 self.hToolboxDock.raise_()
             elif self.layout == "Sidebars":
                 self.bottomSidebar.show()
                 self.bottomSidebar.setCurrentWidget(self.logViewer)
                 self.bottomSidebar.raise_()
                 if self.bottomSidebar.isAutoHiding():
                     self.bottomSidebar.setFocus()
     def __openOnStartup(self, startupType = None):
         """
         Private method to open the last file, project or multiproject.
         @param startupType type of startup requested (string, one of
             "Nothing", "File", "Project", "MultiProject" or "Session")
         """
         startupTypeMapping = {
             "Nothing"       : 0,
             "File"          : 1,
             "Project"       : 2,
             "MultiProject"  : 3,
             "Session"       : 4,
         }
         if startupType is None:
             startup = Preferences.getUI("OpenOnStartup")
         else:
             try:
                 startup = startupTypeMapping[startupType]
             except KeyError:
                 startup = Preferences.getUI("OpenOnStartup")
         if startup == 0:
             # open nothing
             pass
         elif startup == 1:
             # open last file
             recent = self.viewmanager.getMostRecent()
             if recent is not None:
                 self.viewmanager.openFiles(recent)
         elif startup == 2:
             # open last project
             recent = self.project.getMostRecent()
             if recent is not None:
                 self.project.openProject(recent)
         elif startup == 3:
             # open last multiproject
             recent = self.multiProject.getMostRecent()
             if recent is not None:
                 self.multiProject.openMultiProject(recent)
         elif startup == 4:
             # open from session file
             self.__readSession()
     def processArgs(self, args):
         """
         Public method to process the command line args passed to the UI.
         @param args list of files to open<br />
             The args are processed one at a time. All arguments after a
             '--' option are considered debug arguments to the program
             for the debugger. All files named before the '--' option
             are opened in a text editor, unless the argument ends in
             .e4p or .e4pz, then it is opened as a project file.
             If it ends in .e4m or .e4mz, it is opened as a multiproject.
         """
         # no args, return
         if args is None:
             if not self.__noOpenAtStartup:
                 self.__openOnStartup()
             return
         opens = 0
         # holds space delimited list of command args, if any
         argsStr = None
         # flag indicating '--' options was found
         ddseen = False
         if Utilities.isWindowsPlatform():
             argChars = ['-', '/']
         else:
             argChars = ['-']
         for arg in args:
             # handle a request to start with last session
             if arg == '--start-session':
                 self.__openOnStartup("Session")
                 # ignore all further arguments
                 return
             if arg == '--' and not ddseen:
                 ddseen = True
                 continue
             if arg[0] in argChars or ddseen:
                 if argsStr is None:
                     argsStr = arg
                 else:
                     argsStr = "%s %s" % (argsStr, arg)
                 continue
             ext = os.path.splitext(arg)[1]
             ext = os.path.normcase(ext)
             if ext in ['.e4p', '.e4pz']:
                 self.project.openProject(arg)
                 opens += 1
             elif ext in ['.e4m', '.e4mz']:
                 self.multiProject.openMultiProject(arg)
                 opens += 1
             else:
                 self.viewmanager.openFiles(arg)
                 opens += 1
 de9c2efb9d02
Started porting eric4 to Python3

Mercurial Repositories > eric / annotate

UI/UserInterface.py@c3eb7cc1ff8b (annotated)

UI/UserInterface.py