def initProperties(self): """ Public slot to initialize the properties. """ self.setFoldComments(Preferences.getEditor("PovFoldComment")) self.setFoldDirectives(Preferences.getEditor("PovFoldDirectives")) self.setFoldCompact(Preferences.getEditor("AllFoldCompact"))
def startStatusMonitor(self, project): """ Public method to start the VCS status monitor thread. @param project reference to the project object @return reference to the monitor thread (QThread) """ if project.pudata["VCSSTATUSMONITORINTERVAL"]: vcsStatusMonitorInterval = project.pudata[ "VCSSTATUSMONITORINTERVAL"][0] else: vcsStatusMonitorInterval = Preferences.getVCS( "StatusMonitorInterval") if vcsStatusMonitorInterval > 0: self.statusMonitorThread = self._createStatusMonitorThread( vcsStatusMonitorInterval, project) if self.statusMonitorThread is not None: self.statusMonitorThread.vcsStatusMonitorData.connect( self.__statusMonitorData, Qt.QueuedConnection) self.statusMonitorThread.vcsStatusMonitorStatus.connect( self.__statusMonitorStatus, Qt.QueuedConnection) self.statusMonitorThread.setAutoUpdate( Preferences.getVCS("AutoUpdate")) self.statusMonitorThread.start() else: self.statusMonitorThread = None return self.statusMonitorThread
def __init__(self, parent=None): """ Constructor @param parent reference to the parent object (QObject) """ super(E5SslErrorHandler, self).__init__(parent) caList = self.__getSystemCaCertificates() if Preferences.Prefs.settings.contains("Help/CaCertificatesDict"): # port old entries stored under 'Help' certificateDict = Preferences.toDict(Preferences.Prefs.settings.value("Help/CaCertificatesDict")) Preferences.Prefs.settings.setValue("Ssl/CaCertificatesDict", certificateDict) Preferences.Prefs.settings.remove("Help/CaCertificatesDict") else: certificateDict = Preferences.toDict(Preferences.Prefs.settings.value("Ssl/CaCertificatesDict")) for server in certificateDict: for cert in QSslCertificate.fromData(certificateDict[server]): if cert not in caList: caList.append(cert) sslCfg = QSslConfiguration.defaultConfiguration() sslCfg.setCaCertificates(caList) sslCfg.setProtocol(QSsl.AnyProtocol) try: sslCfg.setSslOption(QSsl.SslOptionDisableCompression, True) except AttributeError: pass QSslConfiguration.setDefaultConfiguration(sslCfg)
def proxyAuthenticationRequired(proxy, auth): """ Module slot to handle a proxy authentication request. @param proxy reference to the proxy object (QNetworkProxy) @param auth reference to the authenticator object (QAuthenticator) """ info = QCoreApplication.translate("E5NetworkProxyFactory", "<b>Connect to proxy '{0}' using:</b>").format( Utilities.html_encode(proxy.hostName()) ) from UI.AuthenticationDialog import AuthenticationDialog dlg = AuthenticationDialog(info, proxy.user(), True) dlg.setData(proxy.user(), proxy.password()) if dlg.exec_() == QDialog.Accepted: username, password = dlg.getData() auth.setUser(username) auth.setPassword(password) if dlg.shallSave(): scheme = schemeFromProxyType(proxy.type()) if scheme and scheme != "NoProxy": Preferences.setUI("ProxyUser/{0}".format(scheme), username) Preferences.setUI("ProxyPassword/{0}".format(scheme), password) proxy.setUser(username) proxy.setPassword(password)
def save(self): """ Public slot to save the Editor Mouse Click Handlers configuration. """ Preferences.setEditor( "MouseClickHandlersEnabled", self.mcEnabledCheckBox.isChecked())
def __init__(self, parent): """ Constructor @param parent parent widget (QWidget) """ self.tabWidgets = [] QSplitter.__init__(self, parent) ViewManager.__init__(self) self.setChildrenCollapsible(False) tw = TabWidget(self) self.addWidget(tw) self.tabWidgets.append(tw) self.currentTabWidget = tw self.currentTabWidget.showIndicator(True) tw.currentChanged.connect(self.__currentChanged) tw.installEventFilter(self) tw.tabBar().installEventFilter(self) self.setOrientation(Qt.Vertical) self.__inRemoveView = False self.maxFileNameChars = Preferences.getUI( "TabViewManagerFilenameLength") self.filenameOnly = Preferences.getUI("TabViewManagerFilenameOnly")
def __load(self): """ Private method to load the download settings. """ if self.__loaded: return size = Preferences.getHelp("DownloadManagerSize") if size.isValid(): self.resize(size) pos = Preferences.getHelp("DownloadManagerPosition") self.move(pos) downloads = Preferences.getHelp("DownloadManagerDownloads") for download in downloads: if not download[0].isEmpty() and \ download[1] != "": from .DownloadItem import DownloadItem itm = DownloadItem(parent=self) itm.setData(download) self.__addItem(itm) self.cleanupButton.setEnabled( (len(self.__downloads) - self.activeDownloads()) > 0) self.__loaded = True self.__updateActiveItemCount()
def __init__(self, configDialog): """ Constructor @param configDialog reference to the configuration dialog (ConfigurationDialog) """ super(SecurityPage, self).__init__() self.setupUi(self) self.setObjectName("SecurityPage") self.__configDlg = configDialog # set initial values self.savePasswordsCheckBox.setChecked( Preferences.getUser("SavePasswords")) self.masterPasswordCheckBox.setChecked( Preferences.getUser("UseMasterPassword")) self.masterPasswordButton.setEnabled( Preferences.getUser("UseMasterPassword")) if QWebSettings and hasattr(QWebSettings, "DnsPrefetchEnabled"): self.dnsPrefetchCheckBox.setChecked( Preferences.getHelp("DnsPrefetchEnabled")) else: self.dnsPrefetchCheckBox.setEnabled(False) self.__newPassword = "" self.__oldUseMasterPassword = Preferences.getUser("UseMasterPassword")
def accept(self): """ Public method to accept the dialog data. """ Preferences.setHelp("NoCacheHosts", self.__model.stringList()) super(NoCacheHostsDialog, self).accept()
def _getDict(cls, lang, pwl = "", pel = ""): """ Protected classmethod to get a new dictionary. @param lang the language to be used as the default (string). The string should be in language locale format (e.g. en_US, de). @keyparam pwl name of the personal/project word list (string) @keyparam pel name of the personal/project exclude list (string) @return reference to the dictionary (enchant.Dict) """ if not pwl: pwl = unicode(Preferences.getEditor("SpellCheckingPersonalWordList")) if not pwl: pwl = os.path.join(Utilities.getConfigDir(), "spelling", "pwl.dic") d = os.path.dirname(pwl) if not os.path.exists(d): os.makedirs(d) if not pel: pel = unicode(Preferences.getEditor("SpellCheckingPersonalExcludeList")) if not pel: pel = os.path.join(Utilities.getConfigDir(), "spelling", "pel.dic") d = os.path.dirname(pel) if not os.path.exists(d): os.makedirs(d) try: d = enchant.DictWithPWL(lang, pwl, pel) except: # Catch all exceptions, because if pyenchant isn't available, you # can't catch the enchant.DictNotFound error. d = None return d
def __init__(self, parent=None): """ Constructor @param parent reference to the parent widget (QWidget) """ super(PreviewerHTML, self).__init__(parent) self.setupUi(self) self.jsCheckBox.setChecked( Preferences.getUI("ShowFilePreviewJS")) self.ssiCheckBox.setChecked( Preferences.getUI("ShowFilePreviewSSI")) self.previewView.page().setLinkDelegationPolicy( QWebPage.DelegateAllLinks) self.__scrollBarPositions = {} self.__vScrollBarAtEnd = {} self.__hScrollBarAtEnd = {} self.__processingThread = PreviewProcessingThread() self.__processingThread.htmlReady.connect(self.__setHtml) self.__previewedPath = None self.__previewedEditor = None
def __init__(self): """ Constructor """ super(HelpViewersPage, self).__init__() self.setupUi(self) self.setObjectName("HelpViewersPage") self.customViewerPicker.setMode(E5PathPickerModes.OpenFileMode) self.helpViewerGroup = QButtonGroup() self.helpViewerGroup.addButton(self.helpBrowserButton) self.helpViewerGroup.addButton(self.qtAssistantButton) self.helpViewerGroup.addButton(self.webBrowserButton) self.helpViewerGroup.addButton(self.customViewerButton) # set initial values hvId = Preferences.getHelp("HelpViewerType") if hvId == 1: self.helpBrowserButton.setChecked(True) elif hvId == 2: self.qtAssistantButton.setChecked(True) elif hvId == 3: self.webBrowserButton.setChecked(True) else: self.customViewerButton.setChecked(True) self.customViewerPicker.setText( Preferences.getHelp("CustomViewer"))
def pwConvert(pw, encode=True): """ Module function to convert a plaintext password to the encoded form or vice versa. If there is an error, an empty code is returned for the encode function or the given encoded password for the decode function. @param pw password to encode (string) @param encode flag indicating an encode or decode function (boolean) @return encoded or decoded password (string) """ if pw == "": return pw if encode: # plain text -> encoded if Preferences.getUser("UseMasterPassword"): epw = pwEncrypt(pw)[0] else: epw = pwEncode(pw) return epw else: # encoded -> plain text if Preferences.getUser("UseMasterPassword"): plain, ok = pwDecrypt(pw) else: plain, ok = pwDecode(pw), True return (plain if ok else pw)
def __init__(self): """ Constructor """ super(TasksPage, self).__init__() self.setupUi(self) self.setObjectName("TasksPage") # set initial values self.tasksMarkerFixmeEdit.setText( Preferences.getTasks("TasksFixmeMarkers")) self.tasksMarkerWarningEdit.setText( Preferences.getTasks("TasksWarningMarkers")) self.tasksMarkerTodoEdit.setText( Preferences.getTasks("TasksTodoMarkers")) self.tasksMarkerNoteEdit.setText( Preferences.getTasks("TasksNoteMarkers")) self.initColour( "TasksFixmeColor", self.tasksFixmeColourButton, Preferences.getTasks) self.initColour( "TasksWarningColor", self.tasksWarningColourButton, Preferences.getTasks) self.initColour( "TasksTodoColor", self.tasksTodoColourButton, Preferences.getTasks) self.initColour( "TasksNoteColor", self.tasksNoteColourButton, Preferences.getTasks) self.clearCheckBox.setChecked(Preferences.getTasks("ClearOnFileClose"))
def preferencesChanged(self): """ Public slot to handle the preferencesChanged signal. """ ViewManager.preferencesChanged(self) self.maxFileNameChars = Preferences.getUI( "TabViewManagerFilenameLength") self.filenameOnly = Preferences.getUI("TabViewManagerFilenameOnly") for tabWidget in self.tabWidgets: for index in range(tabWidget.count()): editor = tabWidget.widget(index) if isinstance(editor, QScintilla.Editor.Editor): fn = editor.getFileName() if fn: if self.filenameOnly: txt = os.path.basename(fn) else: txt = e5App().getObject("Project")\ .getRelativePath(fn) if len(txt) > self.maxFileNameChars: txt = "...{0}".format(txt[-self.maxFileNameChars:]) if not QFileInfo(fn).isWritable(): txt = self.tr("{0} (ro)").format(txt) tabWidget.setTabText(index, txt)
def readmodule(module, path=[], isPyFile = False): ''' Read a source file and return a dictionary of classes, functions, modules, etc. . The real work of parsing the source file is delegated to the individual file parsers. @param module name of the source file (string) @param path path the file should be searched in (list of strings) @return the resulting dictionary ''' ext = os.path.splitext(module)[1].lower() if ext in __extensions["IDL"]: import idlclbr dict = idlclbr.readmodule_ex(module, path) idlclbr._modules.clear() elif ext in __extensions["Ruby"]: import rbclbr dict = rbclbr.readmodule_ex(module, path) rbclbr._modules.clear() elif ext in Preferences.getPython("PythonExtensions") or \ ext in Preferences.getPython("Python3Extensions") or \ isPyFile: import pyclbr dict = pyclbr.readmodule_ex(module, path, isPyFile = isPyFile) pyclbr._modules.clear() else: # try Python if it is without extension import pyclbr dict = pyclbr.readmodule_ex(module, path) pyclbr._modules.clear() return dict
def __captionChange(self, cap, editor): """ Private slot to handle Caption change signals from the editor. Updates the tab text and tooltip text to reflect the new caption information. @param cap Caption for the editor @param editor Editor to update the caption for """ fn = editor.getFileName() if fn: if Preferences.getUI("TabViewManagerFilenameOnly"): txt = os.path.basename(fn) else: txt = e5App().getObject("Project").getRelativePath(fn) maxFileNameChars = Preferences.getUI( "TabViewManagerFilenameLength") if len(txt) > maxFileNameChars: txt = "...{0}".format(txt[-maxFileNameChars:]) if editor.isReadOnly(): txt = self.tr("{0} (ro)").format(txt) assembly = editor.parent() index = self.indexOf(assembly) if index > -1: self.setTabText(index, txt) self.setTabToolTip(index, fn)
def __init__(self): """ Constructor """ super(HelpViewersPage, self).__init__() self.setupUi(self) self.setObjectName("HelpViewersPage") self.customViewerSelectionButton.setIcon( UI.PixmapCache.getIcon("open.png")) self.helpViewerGroup = QButtonGroup() self.helpViewerGroup.addButton(self.helpBrowserButton) self.helpViewerGroup.addButton(self.qtAssistantButton) self.helpViewerGroup.addButton(self.webBrowserButton) self.helpViewerGroup.addButton(self.customViewerButton) self.customViewerCompleter = E5FileCompleter(self.customViewerEdit) # set initial values hvId = Preferences.getHelp("HelpViewerType") if hvId == 1: self.helpBrowserButton.setChecked(True) elif hvId == 2: self.qtAssistantButton.setChecked(True) elif hvId == 3: self.webBrowserButton.setChecked(True) else: self.customViewerButton.setChecked(True) self.customViewerEdit.setText( Preferences.getHelp("CustomViewer"))
def initProperties(self): """ Public slot to initialize the properties. """ self.setIndentationWarning( Preferences.getEditor("PythonBadIndentation")) self.setFoldComments(Preferences.getEditor("PythonFoldComment")) self.setFoldQuotes(Preferences.getEditor("PythonFoldString")) if not Preferences.getEditor("PythonAutoIndent"): self.setAutoIndentStyle(QsciScintilla.AiMaintain) try: self.setV2UnicodeAllowed( Preferences.getEditor("PythonAllowV2Unicode")) self.setV3BinaryOctalAllowed( Preferences.getEditor("PythonAllowV3Binary")) self.setV3BytesAllowed(Preferences.getEditor("PythonAllowV3Bytes")) except AttributeError: pass try: self.setFoldQuotes(Preferences.getEditor("PythonFoldQuotes")) self.setStringsOverNewlineAllowed( Preferences.getEditor("PythonStringsOverNewLineAllowed")) except AttributeError: pass try: self.setHighlightSubidentifiers( Preferences.getEditor("PythonHighlightSubidentifier")) except AttributeError: pass
def initialLoadAndCheck(self, forceUpload): """ Public method to do the initial check. @keyparam forceUpload flag indicating a forced upload of the files (boolean) """ if not Preferences.getHelp("SyncEnabled"): return self.__forceUpload = forceUpload self.__remoteFilesFound = [] # check the existence of the shared directory; create it, if it is # not there if not os.path.exists(Preferences.getHelp("SyncDirectoryPath")): try: os.makedirs(Preferences.getHelp("SyncDirectoryPath")) except OSError as err: self.syncError.emit( self.tr("Error creating the shared directory.\n{0}") .format(str(err))) return self.__initialSync()
def __printPdfRequested(self, frame): """ Private slot to handle a print to PDF request. @param frame reference to the frame to be printed (QWebFrame) """ printer = QPrinter(mode=QPrinter.HighResolution) if Preferences.getPrinter("ColorMode"): printer.setColorMode(QPrinter.Color) else: printer.setColorMode(QPrinter.GrayScale) printerName = Preferences.getPrinter("PrinterName") if printerName: printer.setPrinterName(printerName) printer.setOutputFormat(QPrinter.PdfFormat) name = frame.url().path().rsplit('/', 1)[-1] if name: name = name.rsplit('.', 1)[0] name += '.pdf' printer.setOutputFileName(name) printDialog = QPrintDialog(printer, self) if printDialog.exec_() == QDialog.Accepted: try: frame.print_(printer) except AttributeError: E5MessageBox.critical( self, self.tr("eric6 Web Browser"), self.tr( """<p>Printing is not available due to a bug in""" """ PyQt5. Please upgrade.</p>""")) return
def __init__(self): """ Constructor """ ConfigurationPageBase.__init__(self) self.setupUi(self) self.setObjectName("EditorAPIsPage") self.prepareApiButton.setText(self.trUtf8("Compile APIs")) self.__apisManager = APIsManager() self.__currentAPI = None self.__inPreparation = False self.apiFileCompleter = E4FileCompleter(self.apiFileEdit) # set initial values self.pluginManager = e4App().getObject("PluginManager") self.apiAutoPrepareCheckBox.setChecked(Preferences.getEditor("AutoPrepareAPIs")) self.apis = {} apiLanguages = [""] + QScintilla.Lexers.getSupportedLanguages().keys() apiLanguages.sort() for lang in apiLanguages: if lang != "Guessed": self.apiLanguageComboBox.addItem(lang) self.currentApiLanguage = QString("") self.on_apiLanguageComboBox_activated(self.currentApiLanguage) for lang in apiLanguages[1:]: self.apis[lang] = QStringList(Preferences.getEditorAPI(lang))
def __init__(self, debugServer, passive): """ Constructor @param debugServer reference to the debug server (DebugServer) @param passive flag indicating passive connection mode (boolean) """ QObject.__init__(self) self.__isNetworked = True self.__autoContinue = False self.debugServer = debugServer self.passive = passive self.process = None self.qsock = None self.queue = [] # set default values for capabilities of clients self.clientCapabilities = ClientDefaultCapabilities self.codec = QTextCodec.codecForName( str(Preferences.getSystem("StringEncoding"))) if passive: # set translation function if Preferences.getDebugger("PathTranslation"): self.translateRemote = \ unicode(Preferences.getDebugger("PathTranslationRemote")) self.translateLocal = \ unicode(Preferences.getDebugger("PathTranslationLocal")) self.translate = self.__remoteTranslation else: self.translate = self.__identityTranslation
def __init__(self): """ Constructor """ super(ProjectBrowserPage, self).__init__() self.setupUi(self) self.setObjectName("ProjectBrowserPage") self.__currentProjectTypeIndex = 0 # set initial values self.projectTypeCombo.addItem('', '') self.__projectBrowserFlags = {'': 0} try: projectTypes = e5App().getObject("Project").getProjectTypes() for projectType in sorted(projectTypes.keys()): self.projectTypeCombo.addItem(projectTypes[projectType], projectType) self.__projectBrowserFlags[projectType] = \ Preferences.getProjectBrowserFlags(projectType) except KeyError: self.pbGroup.setEnabled(False) self.initColour( "Highlighted", self.pbHighlightedButton, Preferences.getProjectBrowserColour) self.followEditorCheckBox.setChecked( Preferences.getProject("FollowEditor")) self.followCursorLineCheckBox.setChecked( Preferences.getProject("FollowCursorLine")) self.autoPopulateCheckBox.setChecked( Preferences.getProject("AutoPopulateItems")) self.hideGeneratedCheckBox.setChecked( Preferences.getProject("HideGeneratedForms"))
def __init__(self): """ Constructor """ super(ShellPage, self).__init__() self.setupUi(self) self.setObjectName("ShellPage") # set initial values self.shellLinenoCheckBox.setChecked( Preferences.getShell("LinenoMargin")) self.shellWordWrapCheckBox.setChecked( Preferences.getShell("WrapEnabled")) self.shellACEnabledCheckBox.setChecked( Preferences.getShell("AutoCompletionEnabled")) self.shellCTEnabledCheckBox.setChecked( Preferences.getShell("CallTipsEnabled")) self.shellSyntaxHighlightingCheckBox.setChecked( Preferences.getShell("SyntaxHighlightingEnabled")) self.shellHistorySpinBox.setValue( Preferences.getShell("MaxHistoryEntries")) self.stdOutErrCheckBox.setChecked( Preferences.getShell("ShowStdOutErr")) self.monospacedFont = Preferences.getShell("MonospacedFont") self.monospacedFontSample.setFont(self.monospacedFont) self.monospacedCheckBox.setChecked( Preferences.getShell("UseMonospacedFont")) self.marginsFont = Preferences.getShell("MarginsFont") self.marginsFontSample.setFont(self.marginsFont)
def __init__(self, vcs, parent=None): """ Constructor @param vcs reference to the vcs object @param parent parent widget (QWidget) """ super(SvnBlameDialog, self).__init__(parent) self.setupUi(self) self.buttonBox.button(QDialogButtonBox.Close).setEnabled(False) self.buttonBox.button(QDialogButtonBox.Cancel).setDefault(True) self.process = QProcess() self.vcs = vcs self.blameList.headerItem().setText(self.blameList.columnCount(), "") font = Preferences.getEditorOtherFonts("MonospacedFont") self.blameList.setFont(font) self.__ioEncoding = Preferences.getSystem("IOEncoding") self.process.finished.connect(self.__procFinished) self.process.readyReadStandardOutput.connect(self.__readStdout) self.process.readyReadStandardError.connect(self.__readStderr)
def save(self): """ Public slot to save the Project Browser configuration. """ self.saveColours(Preferences.setProjectBrowserColour) Preferences.setProject( "FollowEditor", self.followEditorCheckBox.isChecked()) Preferences.setProject( "FollowCursorLine", self.followCursorLineCheckBox.isChecked()) Preferences.setProject( "AutoPopulateItems", self.autoPopulateCheckBox.isChecked()) Preferences.setProject( "HideGeneratedForms", self.hideGeneratedCheckBox.isChecked()) if self.pbGroup.isEnabled(): self.__storeProjectBrowserFlags( self.projectTypeCombo.itemData(self.__currentProjectTypeIndex)) for projectType, flags in list(self.__projectBrowserFlags.items()): if projectType != '': Preferences.setProjectBrowserFlags(projectType, flags)
def accept(self): """ Public method to accept the dialog data. """ Preferences.setHelp("SendRefererWhitelist", self.__model.stringList()) super(SendRefererWhitelistDialog, self).accept()
def __initialSyncFile(self, type_, fileName): """ Private method to do the initial synchronization of the given file. @param type_ type of the synchronization event (string one of "bookmarks", "history", "passwords", "useragents" or "speeddial") @param fileName name of the file to be synchronized (string) """ if not self.__forceUpload and \ os.path.exists( os.path.join(Preferences.getHelp("SyncDirectoryPath"), self._remoteFiles[type_])) and \ QFileInfo(fileName).lastModified() <= QFileInfo( os.path.join(Preferences.getHelp("SyncDirectoryPath"), self._remoteFiles[type_])).lastModified(): self.__downloadFile( type_, fileName, QFileInfo(os.path.join( Preferences.getHelp("SyncDirectoryPath"), self._remoteFiles[type_])).lastModified().toTime_t()) else: if os.path.exists( os.path.join(Preferences.getHelp("SyncDirectoryPath"), self._remoteFiles[type_])): self.syncStatus.emit( type_, self._messages[type_]["RemoteMissing"]) else: self.syncStatus.emit( type_, self._messages[type_]["LocalNewer"]) self.__uploadFile(type_, fileName)
def __init__(self): """ Constructor of the BackgroundService class. """ self.processes = {} self.connections = {} self.isWorking = None self.runningJob = [None, None, None, None] self.__queue = [] self.services = {} super(BackgroundService, self).__init__() networkInterface = Preferences.getDebugger("NetworkInterface") if networkInterface == "all" or '.' in networkInterface: self.hostAddress = '127.0.0.1' else: self.hostAddress = '::1' self.listen(QHostAddress(self.hostAddress)) self.newConnection.connect(self.on_newConnection) port = self.serverPort() ## Note: Need the port if started external in debugger: print('BackgroundService listening on: %i' % port) for pyName in ['Python', 'Python3']: interpreter = Preferences.getDebugger( pyName + "Interpreter") process = self.__startExternalClient(interpreter, port) if process: if pyName == 'Python': pyName = 'Python2' self.processes[pyName] = process, interpreter
def __splitterMoved(self): """ Private slot to handle the movement of the embedding splitter's handle. """ state = self.__splitter.saveState() Preferences.setUI("PreviewSplitterState", state)
def __init__(self, caption, argvList, wdList, envList, exceptions, parent=None, type=0, modfuncList=None, tracePython=False, autoClearShell=True, autoContinue=True, autoFork=False, forkChild=False): """ Constructor @param caption the caption to be displayed (string) @param argvList history list of commandline arguments (list of strings) @param wdList history list of working directories (list of strings) @param envList history list of environment settings (list of strings) @param exceptions exception reporting flag (boolean) @param parent parent widget of this dialog (QWidget) @param type type of the start dialog <ul> <li>0 = start debug dialog</li> <li>1 = start run dialog</li> <li>2 = start coverage dialog</li> <li>3 = start profile dialog</li> </ul> @keyparam modfuncList history list of module functions (list of strings) @keyparam tracePython flag indicating if the Python library should be traced as well (boolean) @keyparam autoClearShell flag indicating, that the interpreter window should be cleared automatically (boolean) @keyparam autoContinue flag indicating, that the debugger should not stop at the first executable line (boolean) @keyparam autoFork flag indicating the automatic fork mode (boolean) @keyparam forkChild flag indicating to debug the child after forking (boolean) """ super(StartDialog, self).__init__(parent) self.setModal(True) self.type = type if type == 0: from .Ui_StartDebugDialog import Ui_StartDebugDialog self.ui = Ui_StartDebugDialog() elif type == 1: from .Ui_StartRunDialog import Ui_StartRunDialog self.ui = Ui_StartRunDialog() elif type == 2: from .Ui_StartCoverageDialog import Ui_StartCoverageDialog self.ui = Ui_StartCoverageDialog() elif type == 3: from .Ui_StartProfileDialog import Ui_StartProfileDialog self.ui = Ui_StartProfileDialog() self.ui.setupUi(self) self.ui.dirButton.setIcon(UI.PixmapCache.getIcon("open.png")) self.clearButton = self.ui.buttonBox.addButton( self.tr("Clear Histories"), QDialogButtonBox.ActionRole) self.workdirCompleter = E5DirCompleter(self.ui.workdirCombo) self.setWindowTitle(caption) self.ui.cmdlineCombo.clear() self.ui.cmdlineCombo.addItems(argvList) if len(argvList) > 0: self.ui.cmdlineCombo.setCurrentIndex(0) self.ui.workdirCombo.clear() self.ui.workdirCombo.addItems(wdList) if len(wdList) > 0: self.ui.workdirCombo.setCurrentIndex(0) self.ui.environmentCombo.clear() self.ui.environmentCombo.addItems(envList) self.ui.exceptionCheckBox.setChecked(exceptions) self.ui.clearShellCheckBox.setChecked(autoClearShell) self.ui.consoleCheckBox.setEnabled( Preferences.getDebugger("ConsoleDbgCommand") != "") self.ui.consoleCheckBox.setChecked(False) if type == 0: # start debug dialog self.ui.tracePythonCheckBox.setChecked(tracePython) self.ui.tracePythonCheckBox.show() self.ui.autoContinueCheckBox.setChecked(autoContinue) self.ui.forkModeCheckBox.setChecked(autoFork) self.ui.forkChildCheckBox.setChecked(forkChild) if type == 1: # start run dialog self.ui.forkModeCheckBox.setChecked(autoFork) self.ui.forkChildCheckBox.setChecked(forkChild) if type == 3: # start coverage or profile dialog self.ui.eraseCheckBox.setChecked(True) self.__clearHistoryLists = False msh = self.minimumSizeHint() self.resize(max(self.width(), msh.width()), msh.height())
def run(self): filename = SaveImageFileDialog.run(self) bg_transparent = self._button.get_active() Preferences.screen_shot_background_transparent(bg_transparent) return filename, bg_transparent
def __init__(self): """ Constructor """ super(IrcPage, self).__init__() self.setupUi(self) self.setObjectName("IrcPage") self.timeFormatCombo.addItems(IrcPage.TimeFormats) self.dateFormatCombo.addItems(IrcPage.DateFormats) # set initial values # timestamps self.timestampGroup.setChecked(Preferences.getIrc("ShowTimestamps")) self.showDateCheckBox.setChecked( Preferences.getIrc("TimestampIncludeDate")) self.timeFormatCombo.setCurrentIndex( self.timeFormatCombo.findText(Preferences.getIrc("TimeFormat"))) self.dateFormatCombo.setCurrentIndex( self.dateFormatCombo.findText(Preferences.getIrc("DateFormat"))) # colours self.initColour("NetworkMessageColour", self.networkButton, Preferences.getIrc, byName=True) self.initColour("ServerMessageColour", self.serverButton, Preferences.getIrc, byName=True) self.initColour("ErrorMessageColour", self.errorButton, Preferences.getIrc, byName=True) self.initColour("TimestampColour", self.timestampButton, Preferences.getIrc, byName=True) self.initColour("HyperlinkColour", self.hyperlinkButton, Preferences.getIrc, byName=True) self.initColour("ChannelMessageColour", self.channelButton, Preferences.getIrc, byName=True) self.initColour("OwnNickColour", self.ownNickButton, Preferences.getIrc, byName=True) self.initColour("NickColour", self.nickButton, Preferences.getIrc, byName=True) self.initColour("JoinChannelColour", self.joinButton, Preferences.getIrc, byName=True) self.initColour("LeaveChannelColour", self.leaveButton, Preferences.getIrc, byName=True) self.initColour("ChannelInfoColour", self.infoButton, Preferences.getIrc, byName=True) # notifications self.notificationsGroup.setChecked( Preferences.getIrc("ShowNotifications")) self.joinLeaveCheckBox.setChecked(Preferences.getIrc("NotifyJoinPart")) self.messageCheckBox.setChecked(Preferences.getIrc("NotifyMessage")) self.ownNickCheckBox.setChecked(Preferences.getIrc("NotifyNick")) # IRC text colors self.initColour("IrcColor0", self.ircColor0Button, Preferences.getIrc, byName=True) self.initColour("IrcColor1", self.ircColor1Button, Preferences.getIrc, byName=True) self.initColour("IrcColor2", self.ircColor2Button, Preferences.getIrc, byName=True) self.initColour("IrcColor3", self.ircColor3Button, Preferences.getIrc, byName=True) self.initColour("IrcColor4", self.ircColor4Button, Preferences.getIrc, byName=True) self.initColour("IrcColor5", self.ircColor5Button, Preferences.getIrc, byName=True) self.initColour("IrcColor6", self.ircColor6Button, Preferences.getIrc, byName=True) self.initColour("IrcColor7", self.ircColor7Button, Preferences.getIrc, byName=True) self.initColour("IrcColor8", self.ircColor8Button, Preferences.getIrc, byName=True) self.initColour("IrcColor9", self.ircColor9Button, Preferences.getIrc, byName=True) self.initColour("IrcColor10", self.ircColor10Button, Preferences.getIrc, byName=True) self.initColour("IrcColor11", self.ircColor11Button, Preferences.getIrc, byName=True) self.initColour("IrcColor12", self.ircColor12Button, Preferences.getIrc, byName=True) self.initColour("IrcColor13", self.ircColor13Button, Preferences.getIrc, byName=True) self.initColour("IrcColor14", self.ircColor14Button, Preferences.getIrc, byName=True) self.initColour("IrcColor15", self.ircColor15Button, Preferences.getIrc, byName=True) # Automatic User Information Lookup self.whoGroup.setChecked(Preferences.getIrc("AutoUserInfoLookup")) self.whoUsersSpinBox.setValue(Preferences.getIrc("AutoUserInfoMax")) self.whoIntervalSpinBox.setValue( Preferences.getIrc("AutoUserInfoInterval")) # Markers self.markWhenHiddenCheckBox.setChecked( Preferences.getIrc("MarkPositionWhenHidden")) self.initColour("MarkerLineForegroundColour", self.markerForegroundButton, Preferences.getIrc, byName=True) self.initColour("MarkerLineBackgroundColour", self.markerBackgroundButton, Preferences.getIrc, byName=True) # Shutdown self.confirmShutdownCheckBox.setChecked( Preferences.getIrc("AskOnShutdown"))
def save(self): """ Public slot to save the Debugger Python configuration. """ Preferences.setDebugger( "Python3Interpreter", self.interpreterPicker.text()) if self.standardButton.isChecked(): dct = "standard" elif self.threadedButton.isChecked(): dct = "threaded" else: dct = "custom" Preferences.setDebugger("DebugClientType3", dct) Preferences.setDebugger( "DebugClient3", self.debugClientPicker.text()) Preferences.setDebugger( "Python3Redirect", self.pyRedirectCheckBox.isChecked()) Preferences.setDebugger( "Python3NoEncoding", self.pyNoEncodingCheckBox.isChecked()) Preferences.setDebugger( "Python3Extensions", self.sourceExtensionsEdit.text())
def __init__(self): """ Constructor """ super(EditorTypingPage, self).__init__() self.setupUi(self) self.setObjectName("EditorTypingPage") # set initial values self.pageIds = { ' ': self.stackedWidget.indexOf(self.emptyPage), 'Python': self.stackedWidget.indexOf(self.pythonPage), 'Ruby': self.stackedWidget.indexOf(self.rubyPage), 'YAML': self.stackedWidget.indexOf(self.yamlPage), } languages = sorted(list(self.pageIds.keys())) for language in languages: self.languageCombo.addItem(language, self.pageIds[language]) # Python self.pythonGroup.setChecked( Preferences.getEditorTyping("Python/EnabledTypingAids")) self.pythonInsertClosingBraceCheckBox.setChecked( Preferences.getEditorTyping("Python/InsertClosingBrace")) self.pythonSkipBraceCheckBox.setChecked( Preferences.getEditorTyping("Python/SkipBrace")) self.pythonIndentBraceCheckBox.setChecked( Preferences.getEditorTyping("Python/IndentBrace")) self.pythonInsertQuoteCheckBox.setChecked( Preferences.getEditorTyping("Python/InsertQuote")) self.pythonDedentElseCheckBox.setChecked( Preferences.getEditorTyping("Python/DedentElse")) self.pythonDedentExceptCheckBox.setChecked( Preferences.getEditorTyping("Python/DedentExcept")) self.pythonInsertImportCheckBox.setChecked( Preferences.getEditorTyping("Python/InsertImport")) self.pythonImportBraceTypeCheckBox.setChecked( Preferences.getEditorTyping("Python/ImportBraceType")) self.pythonInsertSelfCheckBox.setChecked( Preferences.getEditorTyping("Python/InsertSelf")) self.pythonInsertBlankCheckBox.setChecked( Preferences.getEditorTyping("Python/InsertBlank")) self.pythonColonDetectionCheckBox.setChecked( Preferences.getEditorTyping("Python/ColonDetection")) self.pythonDedentDefCheckBox.setChecked( Preferences.getEditorTyping("Python/DedentDef")) # Ruby self.rubyGroup.setChecked( Preferences.getEditorTyping("Ruby/EnabledTypingAids")) self.rubyInsertClosingBraceCheckBox.setChecked( Preferences.getEditorTyping("Ruby/InsertClosingBrace")) self.rubySkipBraceCheckBox.setChecked( Preferences.getEditorTyping("Ruby/SkipBrace")) self.rubyIndentBraceCheckBox.setChecked( Preferences.getEditorTyping("Ruby/IndentBrace")) self.rubyInsertQuoteCheckBox.setChecked( Preferences.getEditorTyping("Ruby/InsertQuote")) self.rubyInsertBlankCheckBox.setChecked( Preferences.getEditorTyping("Ruby/InsertBlank")) self.rubyInsertHereDocCheckBox.setChecked( Preferences.getEditorTyping("Ruby/InsertHereDoc")) self.rubyInsertInlineDocCheckBox.setChecked( Preferences.getEditorTyping("Ruby/InsertInlineDoc")) # YAML self.yamlGroup.setChecked( Preferences.getEditorTyping("Yaml/EnabledTypingAids")) self.yamlInsertClosingBraceCheckBox.setChecked( Preferences.getEditorTyping("Yaml/InsertClosingBrace")) self.yamlSkipBraceCheckBox.setChecked( Preferences.getEditorTyping("Yaml/SkipBrace")) self.yamlInsertQuoteCheckBox.setChecked( Preferences.getEditorTyping("Yaml/InsertQuote")) self.yamlAutoIndentationCheckBox.setChecked( Preferences.getEditorTyping("Yaml/AutoIndentation")) self.yamlColonDetectionCheckBox.setChecked( Preferences.getEditorTyping("Yaml/ColonDetection")) self.yamlInsertBlankDashCheckBox.setChecked( Preferences.getEditorTyping("Yaml/InsertBlankDash")) self.yamlInsertBlankColonCheckBox.setChecked( Preferences.getEditorTyping("Yaml/InsertBlankColon")) self.yamlInsertBlankQuestionCheckBox.setChecked( Preferences.getEditorTyping("Yaml/InsertBlankQuestion")) self.yamlInsertBlankCommaCheckBox.setChecked( Preferences.getEditorTyping("Yaml/InsertBlankComma")) self.on_languageCombo_activated(' ')
def save(self): """ Public slot to save the Help Viewers configuration. """ Preferences.setHelp("SingleHelpWindow", self.singleHelpWindowCheckBox.isChecked()) Preferences.setHelp("SaveGeometry", self.saveGeometryCheckBox.isChecked()) Preferences.setHelp("WebSearchSuggestions", self.webSuggestionsCheckBox.isChecked()) Preferences.setHelp("ShowPreview", self.showTabPreviews.isChecked()) Preferences.setHelp("AccessKeysEnabled", self.accessKeysCheckBox.isChecked()) Preferences.setHelp("JavaEnabled", self.javaCheckBox.isChecked()) Preferences.setHelp("JavaScriptEnabled", self.javaScriptCheckBox.isChecked()) Preferences.setHelp("JavaScriptCanOpenWindows", self.jsOpenWindowsCheckBox.isChecked()) Preferences.setHelp("JavaScriptCanAccessClipboard", self.jsClipboardCheckBox.isChecked()) Preferences.setHelp("PluginsEnabled", self.pluginsCheckBox.isChecked()) Preferences.setHelp("ClickToFlashEnabled", self.clickToFlashCheckBox.isChecked()) Preferences.setHelp("DoNotTrack", self.doNotTrackCheckBox.isChecked()) Preferences.setHelp("SendReferer", self.sendRefererCheckBox.isChecked()) Preferences.setHelp("DiskCacheEnabled", self.diskCacheCheckBox.isChecked()) Preferences.setHelp("DiskCacheSize", self.cacheSizeSpinBox.value()) if self.cacheKeepButton.isChecked(): Preferences.setHelp("CachePolicy", QNetworkRequest.PreferNetwork) elif self.cachePreferButton.isChecked(): Preferences.setHelp("CachePolicy", QNetworkRequest.PreferCache) elif self.cacheOfflineButton.isChecked(): Preferences.setHelp("CachePolicy", QNetworkRequest.AlwaysCache) Preferences.setHelp("PrintBackgrounds", self.printBackgroundsCheckBox.isChecked()) Preferences.setHelp("StartupBehavior", self.startupCombo.currentIndex()) Preferences.setHelp("HomePage", self.homePageEdit.text()) Preferences.setHelp("DefaultScheme", self.defaultSchemeCombo.currentText()) idx = self.expireHistory.currentIndex() if idx == 0: historyLimit = 1 elif idx == 1: historyLimit = 7 elif idx == 2: historyLimit = 14 elif idx == 3: historyLimit = 30 elif idx == 4: historyLimit = 365 elif idx == 5: historyLimit = -1 elif idx == 6: historyLimit = -2 Preferences.setHelp("HistoryLimit", historyLimit) languageIndex = self.languageCombo.currentIndex() if languageIndex > -1: language = self.languageCombo.itemData(languageIndex) else: # fall back to system default language = QLocale.system().language() Preferences.setHelp("SearchLanguage", language) if hasattr(QWebSettings, "SpatialNavigationEnabled"): Preferences.setHelp("SpatialNavigationEnabled", self.spatialCheckBox.isChecked()) if hasattr(QWebSettings, "LinksIncludedInFocusChain"): Preferences.setHelp("LinksIncludedInFocusChain", self.linksInFocusChainCheckBox.isChecked()) if hasattr(QWebSettings, "XSSAuditingEnabled"): Preferences.setHelp("XSSAuditingEnabled", self.xssAuditingCheckBox.isChecked()) if hasattr(QWebSettings, "SiteSpecificQuirksEnabled"): Preferences.setHelp("SiteSpecificQuirksEnabled", self.quirksCheckBox.isChecked())
def queryProxy(self, query): """ Public method to determine a proxy for a given query. @param query reference to the query object (QNetworkProxyQuery) @return list of proxies in order of preference (list of QNetworkProxy) """ if query.queryType() == QNetworkProxyQuery.UrlRequest and \ query.protocolTag() in ["http", "https", "ftp"]: # use proxy at all ? if not Preferences.getUI("UseProxy"): return [QNetworkProxy(QNetworkProxy.NoProxy)] # test for exceptions exceptions = Preferences.getUI("ProxyExceptions") if exceptions != self.__exceptions: self.__setExceptions(exceptions) urlHost = query.url().host() for matcher in self.__hostnameMatchers: if matcher.match(urlHost): return [QNetworkProxy(QNetworkProxy.NoProxy)] # determine proxy if Preferences.getUI("UseSystemProxy"): proxyList = QNetworkProxyFactory.systemProxyForQuery(query) if not Globals.isWindowsPlatform() and \ len(proxyList) == 1 and \ proxyList[0].type() == QNetworkProxy.NoProxy: # try it the Python way # scan the environment for variables named <scheme>_proxy # scan over whole environment to make this case insensitive for name, value in os.environ.items(): name = name.lower() if value and name[-6:] == '_proxy' and \ name[:-6] == query.protocolTag().lower(): url = QUrl(value) if url.scheme() == "http": proxyType = QNetworkProxy.HttpProxy elif url.scheme() == "https": proxyType = QNetworkProxy.HttpCachingProxy elif url.scheme() == "ftp": proxyType = QNetworkProxy.FtpCachingProxy else: proxyType = QNetworkProxy.HttpProxy proxy = QNetworkProxy(proxyType, url.host(), url.port(), url.userName(), url.password()) proxyList = [proxy] break if proxyList: scheme = schemeFromProxyType(proxyList[0].type()) if scheme == "": scheme = "Http" if scheme != "NoProxy": proxyList[0].setUser( Preferences.getUI("ProxyUser/{0}".format(scheme))) proxyList[0].setPassword( Preferences.getUI( "ProxyPassword/{0}".format(scheme))) return proxyList else: return [QNetworkProxy(QNetworkProxy.NoProxy)] else: if Preferences.getUI("UseHttpProxyForAll"): protocolKey = "Http" else: protocolKey = query.protocolTag().capitalize() host = Preferences.getUI("ProxyHost/{0}".format(protocolKey)) if not host: E5MessageBox.critical( None, QCoreApplication.translate( "E5NetworkProxyFactory", "Proxy Configuration Error"), QCoreApplication.translate( "E5NetworkProxyFactory", """Proxy usage was activated""" """ but no proxy host for protocol""" """ '{0}' configured.""").format(protocolKey)) return [QNetworkProxy(QNetworkProxy.DefaultProxy)] else: if protocolKey in ["Http", "Https", "Ftp"]: if query.protocolTag() == "ftp": proxyType = QNetworkProxy.FtpCachingProxy elif query.protocolTag() == "https": proxyType = QNetworkProxy.HttpCachingProxy else: proxyType = QNetworkProxy.HttpProxy proxy = QNetworkProxy( proxyType, host, Preferences.getUI("ProxyPort/" + protocolKey), Preferences.getUI("ProxyUser/" + protocolKey), Preferences.getUI("ProxyPassword/" + protocolKey)) else: proxy = QNetworkProxy(QNetworkProxy.DefaultProxy) return [proxy, QNetworkProxy(QNetworkProxy.DefaultProxy)] else: return [QNetworkProxy(QNetworkProxy.NoProxy)]
def getSaveFileFiltersList(includeAll=False, asString=False, withAdditional=True): """ Module function to get the file filter list for a save file operation. @param includeAll flag indicating the inclusion of the All Files filter (boolean) @param asString flag indicating the list should be returned as a string (boolean) @keyparam withAdditional flag indicating to include additional filters defined by the user (boolean) @return file filter list (list of strings or string) """ saveFileFiltersList = [ QCoreApplication.translate('Lexers', "Python2 Files (*.py2)"), QCoreApplication.translate('Lexers', "Python3 Files (*.py)"), QCoreApplication.translate('Lexers', "Python2 GUI Files (*.pyw2)"), QCoreApplication.translate('Lexers', "Python3 GUI Files (*.pyw)"), QCoreApplication.translate('Lexers', "Pyrex Files (*.pyx)"), QCoreApplication.translate('Lexers', "Quixote Template Files (*.ptl)"), QCoreApplication.translate('Lexers', "Ruby Files (*.rb)"), QCoreApplication.translate('Lexers', "IDL Files (*.idl)"), QCoreApplication.translate('Lexers', "C Files (*.c)"), QCoreApplication.translate('Lexers', "C++ Files (*.cpp)"), QCoreApplication.translate('Lexers', "C++/C Header Files (*.h)"), QCoreApplication.translate('Lexers', "C# Files (*.cs)"), QCoreApplication.translate('Lexers', "HTML Files (*.html)"), QCoreApplication.translate('Lexers', "PHP Files (*.php)"), QCoreApplication.translate('Lexers', "ASP Files (*.asp)"), QCoreApplication.translate('Lexers', "CSS Files (*.css)"), QCoreApplication.translate('Lexers', "QSS Files (*.qss)"), QCoreApplication.translate('Lexers', "XML Files (*.xml)"), QCoreApplication.translate('Lexers', "XSL Files (*.xsl)"), QCoreApplication.translate('Lexers', "DTD Files (*.dtd)"), QCoreApplication.translate('Lexers', "Qt Resource Files (*.qrc)"), QCoreApplication.translate('Lexers', "D Files (*.d)"), QCoreApplication.translate('Lexers', "D Interface Files (*.di)"), QCoreApplication.translate('Lexers', "Java Files (*.java)"), QCoreApplication.translate('Lexers', "JavaScript Files (*.js)"), QCoreApplication.translate('Lexers', "SQL Files (*.sql)"), QCoreApplication.translate('Lexers', "Docbook Files (*.docbook)"), QCoreApplication.translate('Lexers', "Perl Files (*.pl)"), QCoreApplication.translate('Lexers', "Perl Module Files (*.pm)"), QCoreApplication.translate('Lexers', "Lua Files (*.lua)"), QCoreApplication.translate('Lexers', "Shell Files (*.sh)"), QCoreApplication.translate('Lexers', "Batch Files (*.bat)"), QCoreApplication.translate('Lexers', "TeX Files (*.tex)"), QCoreApplication.translate('Lexers', "TeX Template Files (*.sty)"), QCoreApplication.translate('Lexers', "Diff Files (*.diff)"), QCoreApplication.translate('Lexers', "Make Files (*.mak)"), QCoreApplication.translate('Lexers', "Properties Files (*.ini)"), QCoreApplication.translate('Lexers', "Configuration Files (*.cfg)"), QCoreApplication.translate('Lexers', 'Povray Files (*.pov)'), QCoreApplication.translate('Lexers', 'CMake Files (CMakeLists.txt)'), QCoreApplication.translate('Lexers', 'CMake Macro Files (*.cmake)'), QCoreApplication.translate('Lexers', 'VHDL Files (*.vhd)'), QCoreApplication.translate('Lexers', 'TCL Files (*.tcl)'), QCoreApplication.translate('Lexers', 'Tk Files (*.tk)'), QCoreApplication.translate('Lexers', 'Fortran Files (*.f95)'), QCoreApplication.translate('Lexers', 'Fortran77 Files (*.f)'), QCoreApplication.translate('Lexers', 'Pascal Files (*.pas)'), QCoreApplication.translate('Lexers', 'PostScript Files (*.ps)'), QCoreApplication.translate('Lexers', 'YAML Files (*.yml)'), ] if QSCINTILLA_VERSION() >= 0x020501: saveFileFiltersList.extend([ QCoreApplication.translate('Lexers', 'Matlab Files (*.m)'), QCoreApplication.translate('Lexers', 'Octave Files (*.m.octave)'), ]) if QSCINTILLA_VERSION() >= 0x020802: saveFileFiltersList.append( QCoreApplication.translate('Lexers', 'Gettext Files (*.po)'), ) if QSCINTILLA_VERSION() >= 0x020803: saveFileFiltersList.append( QCoreApplication.translate('Lexers', 'CoffeeScript Files (*.coffee)'), ) for name in LexerRegistry: saveFileFiltersList.extend(LexerRegistry[name][4]) if withAdditional: saveFileFiltersList.extend( Preferences.getEditor("AdditionalSaveFilters")) saveFileFiltersList.sort() if includeAll: saveFileFiltersList.append( QCoreApplication.translate('Lexers', 'All Files (*)')) if asString: return ';;'.join(saveFileFiltersList) else: return saveFileFiltersList
def getOpenFileFiltersList(includeAll=False, asString=False, withAdditional=True): """ Module function to get the file filter list for an open file operation. @param includeAll flag indicating the inclusion of the All Files filter (boolean) @param asString flag indicating the list should be returned as a string (boolean) @keyparam withAdditional flag indicating to include additional filters defined by the user (boolean) @return file filter list (list of strings or string) """ openFileFiltersList = [ QCoreApplication.translate('Lexers', 'Python Files (*.py *.py2 *.py3)'), QCoreApplication.translate('Lexers', 'Python GUI Files (*.pyw *.pyw2 *.pyw3)'), QCoreApplication.translate('Lexers', 'Pyrex Files (*.pyx)'), QCoreApplication.translate('Lexers', 'Quixote Template Files (*.ptl)'), QCoreApplication.translate('Lexers', 'Ruby Files (*.rb)'), QCoreApplication.translate('Lexers', 'IDL Files (*.idl)'), QCoreApplication.translate('Lexers', 'C Files (*.h *.c)'), QCoreApplication.translate( 'Lexers', 'C++ Files (*.h *.hpp *.hh *.cxx *.cpp *.cc)'), QCoreApplication.translate('Lexers', 'C# Files (*.cs)'), QCoreApplication.translate('Lexers', 'HTML Files (*.html *.htm *.asp *.shtml)'), QCoreApplication.translate('Lexers', 'CSS Files (*.css)'), QCoreApplication.translate('Lexers', 'QSS Files (*.qss)'), QCoreApplication.translate( 'Lexers', 'PHP Files (*.php *.php3 *.php4 *.php5 *.phtml)'), QCoreApplication.translate( 'Lexers', 'XML Files (*.xml *.xsl *.xslt *.dtd *.svg *.xul *.xsd)'), QCoreApplication.translate('Lexers', 'Qt Resource Files (*.qrc)'), QCoreApplication.translate('Lexers', 'D Files (*.d *.di)'), QCoreApplication.translate('Lexers', 'Java Files (*.java)'), QCoreApplication.translate('Lexers', 'JavaScript Files (*.js)'), QCoreApplication.translate('Lexers', 'SQL Files (*.sql)'), QCoreApplication.translate('Lexers', 'Docbook Files (*.docbook)'), QCoreApplication.translate('Lexers', 'Perl Files (*.pl *.pm *.ph)'), QCoreApplication.translate('Lexers', 'Lua Files (*.lua)'), QCoreApplication.translate( 'Lexers', 'Tex Files (*.tex *.sty *.aux *.toc *.idx)'), QCoreApplication.translate('Lexers', 'Shell Files (*.sh)'), QCoreApplication.translate('Lexers', 'Batch Files (*.bat *.cmd)'), QCoreApplication.translate('Lexers', 'Diff Files (*.diff *.patch)'), QCoreApplication.translate('Lexers', 'Makefiles (*.mak)'), QCoreApplication.translate( 'Lexers', 'Properties Files (*.properties *.ini *.inf *.reg *.cfg' ' *.cnf *.rc)'), QCoreApplication.translate('Lexers', 'Povray Files (*.pov)'), QCoreApplication.translate( 'Lexers', 'CMake Files (CMakeLists.txt *.cmake *.ctest)'), QCoreApplication.translate('Lexers', 'VHDL Files (*.vhd *.vhdl)'), QCoreApplication.translate('Lexers', 'TCL/Tk Files (*.tcl *.tk)'), QCoreApplication.translate('Lexers', 'Fortran Files (*.f90 *.f95 *.f2k)'), QCoreApplication.translate('Lexers', 'Fortran77 Files (*.f *.for)'), QCoreApplication.translate( 'Lexers', 'Pascal Files (*.dpr *.dpk *.pas *.dfm *.inc *.pp)'), QCoreApplication.translate('Lexers', 'PostScript Files (*.ps)'), QCoreApplication.translate('Lexers', 'YAML Files (*.yaml *.yml)'), ] if QSCINTILLA_VERSION() >= 0x020501: openFileFiltersList.extend([ QCoreApplication.translate('Lexers', 'Matlab Files (*.m *.m.matlab)'), QCoreApplication.translate('Lexers', 'Octave Files (*.m *.m.octave)'), ]) if QSCINTILLA_VERSION() >= 0x020802: openFileFiltersList.append( QCoreApplication.translate('Lexers', 'Gettext Files (*.po)'), ) if QSCINTILLA_VERSION() >= 0x020803: openFileFiltersList.append( QCoreApplication.translate('Lexers', 'CoffeeScript Files (*.coffee)'), ) for name in LexerRegistry: openFileFiltersList.extend(LexerRegistry[name][3]) if withAdditional: openFileFiltersList.extend( Preferences.getEditor("AdditionalOpenFilters")) openFileFiltersList.sort() if includeAll: openFileFiltersList.append( QCoreApplication.translate('Lexers', 'All Files (*)')) if asString: return ';;'.join(openFileFiltersList) else: return openFileFiltersList
def __init__(self, commandsInterface, deviceWithLocalAccess, parent=None): """ Constructor @param commandsInterface reference to the commands interface object @type MicroPythonCommandsInterface @param deviceWithLocalAccess flag indicating the device supports file access via a local directory @type bool @param parent reference to the parent widget @type QWidget """ super(MicroPythonFileManagerWidget, self).__init__(parent) self.setupUi(self) self.__repl = parent self.__deviceWithLocalAccess = deviceWithLocalAccess self.syncButton.setIcon(UI.PixmapCache.getIcon("2rightarrow")) self.putButton.setIcon(UI.PixmapCache.getIcon("1rightarrow")) self.putAsButton.setIcon(UI.PixmapCache.getIcon("putAs")) self.getButton.setIcon(UI.PixmapCache.getIcon("1leftarrow")) self.getAsButton.setIcon(UI.PixmapCache.getIcon("getAs")) self.localUpButton.setIcon(UI.PixmapCache.getIcon("1uparrow")) self.localReloadButton.setIcon(UI.PixmapCache.getIcon("reload")) self.deviceUpButton.setIcon(UI.PixmapCache.getIcon("1uparrow")) self.deviceReloadButton.setIcon(UI.PixmapCache.getIcon("reload")) self.deviceUpButton.setEnabled(not self.__repl.isMicrobit()) self.putButton.setEnabled(False) self.putAsButton.setEnabled(False) self.getButton.setEnabled(False) self.getAsButton.setEnabled(False) self.localFileTreeWidget.header().setSortIndicator( 0, Qt.AscendingOrder) self.deviceFileTreeWidget.header().setSortIndicator( 0, Qt.AscendingOrder) self.__progressInfoDialog = None self.__fileManager = MicroPythonFileManager(commandsInterface, self) self.__fileManager.longListFiles.connect(self.__handleLongListFiles) self.__fileManager.currentDir.connect(self.__handleCurrentDir) self.__fileManager.currentDirChanged.connect(self.__handleCurrentDir) self.__fileManager.putFileDone.connect(self.__newDeviceList) self.__fileManager.getFileDone.connect(self.__handleGetDone) self.__fileManager.rsyncDone.connect(self.__handleRsyncDone) self.__fileManager.rsyncProgressMessage.connect( self.__handleRsyncProgressMessage) self.__fileManager.removeDirectoryDone.connect(self.__newDeviceList) self.__fileManager.createDirectoryDone.connect(self.__newDeviceList) self.__fileManager.deleteFileDone.connect(self.__newDeviceList) self.__fileManager.fsinfoDone.connect(self.__fsInfoResultReceived) self.__fileManager.error.connect(self.__handleError) self.localFileTreeWidget.customContextMenuRequested.connect( self.__showLocalContextMenu) self.deviceFileTreeWidget.customContextMenuRequested.connect( self.__showDeviceContextMenu) self.__localMenu = QMenu(self) self.__localMenu.addAction(self.tr("Change Directory"), self.__changeLocalDirectory) self.__localMenu.addAction(self.tr("Create Directory"), self.__createLocalDirectory) self.__localDelDirTreeAct = self.__localMenu.addAction( self.tr("Delete Directory Tree"), self.__deleteLocalDirectoryTree) self.__localMenu.addSeparator() self.__localDelFileAct = self.__localMenu.addAction( self.tr("Delete File"), self.__deleteLocalFile) self.__localMenu.addSeparator() act = self.__localMenu.addAction(self.tr("Show Hidden Files")) act.setCheckable(True) act.setChecked(Preferences.getMicroPython("ShowHiddenLocal")) act.triggered[bool].connect(self.__localHiddenChanged) self.__deviceMenu = QMenu(self) if not self.__repl.isMicrobit(): self.__deviceMenu.addAction(self.tr("Change Directory"), self.__changeDeviceDirectory) self.__deviceMenu.addAction(self.tr("Create Directory"), self.__createDeviceDirectory) if not self.__deviceWithLocalAccess: self.__devDelDirAct = self.__deviceMenu.addAction( self.tr("Delete Directory"), self.__deleteDeviceDirectory) self.__devDelDirTreeAct = self.__deviceMenu.addAction( self.tr("Delete Directory Tree"), self.__deleteDeviceDirectoryTree) self.__deviceMenu.addSeparator() self.__devDelFileAct = self.__deviceMenu.addAction( self.tr("Delete File"), self.__deleteDeviceFile) self.__deviceMenu.addSeparator() act = self.__deviceMenu.addAction(self.tr("Show Hidden Files")) act.setCheckable(True) act.setChecked(Preferences.getMicroPython("ShowHiddenDevice")) act.triggered[bool].connect(self.__deviceHiddenChanged) if not parent.isMicrobit(): self.__deviceMenu.addSeparator() self.__deviceMenu.addAction(self.tr("Show Filesystem Info"), self.__showFileSystemInfo)
def __createProgramEntry(self, description, exe, versionCommand="", versionStartsWith="", versionPosition=0, version="", versionCleanup=None, versionRe=None): """ Private method to generate a program entry. @param description descriptive text (string) @param exe name of the executable program (string) @param versionCommand command line switch to get the version info (string) if this is empty, the given version will be shown. @param versionStartsWith start of line identifying version info (string) @param versionPosition index of part containing the version info (integer) @keyparam version version string to show (string) @keyparam versionCleanup tuple of two integers giving string positions start and stop for the version string (tuple of integers) @keyparam versionRe regexp to determine the line identifying version info (string). Takes precedence over versionStartsWith. @return version string of detected or given version (string) """ itmList = self.programsList.findItems(description, Qt.MatchCaseSensitive) if itmList: itm = itmList[0] else: itm = QTreeWidgetItem(self.programsList, [description]) font = itm.font(0) font.setBold(True) itm.setFont(0, font) if not exe: itm.setText(1, self.tr("(not configured)")) else: if os.path.isabs(exe): if not Utilities.isExecutable(exe): exe = "" else: exe = Utilities.getExecutablePath(exe) if exe: if versionCommand and \ (versionStartsWith != "" or (versionRe is not None and versionRe != "")) and \ versionPosition: proc = QProcess() proc.setProcessChannelMode(QProcess.MergedChannels) proc.start(exe, [versionCommand]) finished = proc.waitForFinished(10000) if finished: output = str(proc.readAllStandardOutput(), Preferences.getSystem("IOEncoding"), 'replace') if versionRe is None: versionRe = "^{0}".format( re.escape(versionStartsWith)) versionRe = re.compile(versionRe, re.UNICODE) for line in output.splitlines(): if versionRe.search(line): try: version = line.split()[versionPosition] if versionCleanup: version = version[versionCleanup[0]: versionCleanup[1]] break except IndexError: version = self.tr("(unknown)") else: version = self.tr("(unknown)") else: version = self.tr("(not executable)") QTreeWidgetItem(itm, [exe, version]) itm.setExpanded(True) else: itm.setText(1, self.tr("(not found)")) QApplication.processEvents() self.programsList.header().resizeSections(QHeaderView.ResizeToContents) self.programsList.header().setStretchLastSection(True) return version
def __init__(self, files=[], parent=None): """ Constructor @param files list of files to compare and their label (list of two tuples of two strings) @param parent parent widget (QWidget) """ super(CompareDialog, self).__init__(parent) self.setupUi(self) self.file1Button.setIcon(UI.PixmapCache.getIcon("open.png")) self.file2Button.setIcon(UI.PixmapCache.getIcon("open.png")) self.file1Completer = E5FileCompleter(self.file1Edit) self.file2Completer = E5FileCompleter(self.file2Edit) self.diffButton = self.buttonBox.addButton(self.tr("Compare"), QDialogButtonBox.ActionRole) self.diffButton.setToolTip( self.tr("Press to perform the comparison of the two files")) self.diffButton.setEnabled(False) self.diffButton.setDefault(True) self.firstButton.setIcon(UI.PixmapCache.getIcon("2uparrow.png")) self.upButton.setIcon(UI.PixmapCache.getIcon("1uparrow.png")) self.downButton.setIcon(UI.PixmapCache.getIcon("1downarrow.png")) self.lastButton.setIcon(UI.PixmapCache.getIcon("2downarrow.png")) self.totalLabel.setText(self.tr('Total: {0}').format(0)) self.changedLabel.setText(self.tr('Changed: {0}').format(0)) self.addedLabel.setText(self.tr('Added: {0}').format(0)) self.deletedLabel.setText(self.tr('Deleted: {0}').format(0)) self.updateInterval = 20 # update every 20 lines self.vsb1 = self.contents_1.verticalScrollBar() self.hsb1 = self.contents_1.horizontalScrollBar() self.vsb2 = self.contents_2.verticalScrollBar() self.hsb2 = self.contents_2.horizontalScrollBar() self.on_synchronizeCheckBox_toggled(True) font = Preferences.getEditorOtherFonts("MonospacedFont") self.contents_1.setFontFamily(font.family()) self.contents_1.setFontPointSize(font.pointSize()) self.contents_2.setFontFamily(font.family()) self.contents_2.setFontPointSize(font.pointSize()) self.fontHeight = QFontMetrics(self.contents_1.currentFont()).height() self.cNormalFormat = self.contents_1.currentCharFormat() self.cInsertedFormat = self.contents_1.currentCharFormat() self.cInsertedFormat.setBackground(QBrush(QColor(190, 237, 190))) self.cDeletedFormat = self.contents_1.currentCharFormat() self.cDeletedFormat.setBackground(QBrush(QColor(237, 190, 190))) self.cReplacedFormat = self.contents_1.currentCharFormat() self.cReplacedFormat.setBackground(QBrush(QColor(190, 190, 237))) # connect some of our widgets explicitly self.file1Edit.textChanged.connect(self.__fileChanged) self.file2Edit.textChanged.connect(self.__fileChanged) self.vsb1.valueChanged.connect(self.__scrollBarMoved) self.vsb1.valueChanged.connect(self.vsb2.setValue) self.vsb2.valueChanged.connect(self.vsb1.setValue) self.diffParas = [] self.currentDiffPos = -1 self.markerPattern = "\0\+|\0\^|\0\-" if len(files) == 2: self.filesGroup.hide() self.file1Edit.setText(files[0][1]) self.file2Edit.setText(files[1][1]) self.file1Label.setText(files[0][0]) self.file2Label.setText(files[1][0]) self.diffButton.hide() QTimer.singleShot(0, self.on_diffButton_clicked) else: self.file1Label.hide() self.file2Label.hide()
def save(self): """ Public slot to save the Editor Typing configuration. """ # Python Preferences.setEditorTyping("Python/EnabledTypingAids", self.pythonGroup.isChecked()) Preferences.setEditorTyping( "Python/InsertClosingBrace", self.pythonInsertClosingBraceCheckBox.isChecked()) Preferences.setEditorTyping("Python/SkipBrace", self.pythonSkipBraceCheckBox.isChecked()) Preferences.setEditorTyping("Python/IndentBrace", self.pythonIndentBraceCheckBox.isChecked()) Preferences.setEditorTyping("Python/InsertQuote", self.pythonInsertQuoteCheckBox.isChecked()) Preferences.setEditorTyping("Python/DedentElse", self.pythonDedentElseCheckBox.isChecked()) Preferences.setEditorTyping( "Python/DedentExcept", self.pythonDedentExceptCheckBox.isChecked()) Preferences.setEditorTyping( "Python/InsertImport", self.pythonInsertImportCheckBox.isChecked()) Preferences.setEditorTyping( "Python/ImportBraceType", self.pythonImportBraceTypeCheckBox.isChecked()) Preferences.setEditorTyping("Python/InsertSelf", self.pythonInsertSelfCheckBox.isChecked()) Preferences.setEditorTyping("Python/InsertBlank", self.pythonInsertBlankCheckBox.isChecked()) Preferences.setEditorTyping( "Python/ColonDetection", self.pythonColonDetectionCheckBox.isChecked()) Preferences.setEditorTyping("Python/DedentDef", self.pythonDedentDefCheckBox.isChecked()) # Ruby Preferences.setEditorTyping("Ruby/EnabledTypingAids", self.rubyGroup.isChecked()) Preferences.setEditorTyping( "Ruby/InsertClosingBrace", self.rubyInsertClosingBraceCheckBox.isChecked()) Preferences.setEditorTyping("Ruby/SkipBrace", self.rubySkipBraceCheckBox.isChecked()) Preferences.setEditorTyping("Ruby/IndentBrace", self.rubyIndentBraceCheckBox.isChecked()) Preferences.setEditorTyping("Ruby/InsertQuote", self.rubyInsertQuoteCheckBox.isChecked()) Preferences.setEditorTyping("Ruby/InsertBlank", self.rubyInsertBlankCheckBox.isChecked()) Preferences.setEditorTyping("Ruby/InsertHereDoc", self.rubyInsertHereDocCheckBox.isChecked()) Preferences.setEditorTyping( "Ruby/InsertInlineDoc", self.rubyInsertInlineDocCheckBox.isChecked()) # YAML Preferences.setEditorTyping("Yaml/EnabledTypingAids", self.yamlGroup.isChecked()) Preferences.setEditorTyping( "Yaml/InsertClosingBrace", self.yamlInsertClosingBraceCheckBox.isChecked()) Preferences.setEditorTyping("Yaml/SkipBrace", self.yamlSkipBraceCheckBox.isChecked()) Preferences.setEditorTyping("Yaml/InsertQuote", self.yamlInsertQuoteCheckBox.isChecked()) Preferences.setEditorTyping( "Yaml/AutoIndentation", self.yamlAutoIndentationCheckBox.isChecked()) Preferences.setEditorTyping( "Yaml/ColonDetection", self.yamlColonDetectionCheckBox.isChecked()) Preferences.setEditorTyping( "Yaml/InsertBlankDash", self.yamlInsertBlankDashCheckBox.isChecked()) Preferences.setEditorTyping( "Yaml/InsertBlankColon", self.yamlInsertBlankColonCheckBox.isChecked()) Preferences.setEditorTyping( "Yaml/InsertBlankQuestion", self.yamlInsertBlankQuestionCheckBox.isChecked()) Preferences.setEditorTyping( "Yaml/InsertBlankComma", self.yamlInsertBlankCommaCheckBox.isChecked())
def __init__(self, configDialog): """ Constructor @param configDialog reference to the configuration dialog (ConfigurationDialog) """ super(HelpWebBrowserPage, self).__init__() self.setupUi(self) self.setObjectName("HelpWebBrowserPage") self.__configDlg = configDialog mw = configDialog.parent().parent() if hasattr(mw, "helpWindow") and mw.helpWindow is not None: self.__helpWindow = mw.helpWindow elif hasattr(mw, "currentBrowser"): self.__helpWindow = mw else: self.__helpWindow = None self.setCurrentPageButton.setEnabled(self.__helpWindow is not None) defaultSchemes = ["file://", "http://", "https://"] self.defaultSchemeCombo.addItems(defaultSchemes) self.clickToFlashCheckBox.setIcon( UI.PixmapCache.getIcon("flashBlock.png")) # set initial values self.singleHelpWindowCheckBox.setChecked( Preferences.getHelp("SingleHelpWindow")) self.saveGeometryCheckBox.setChecked( Preferences.getHelp("SaveGeometry")) self.webSuggestionsCheckBox.setChecked( Preferences.getHelp("WebSearchSuggestions")) self.showTabPreviews.setChecked(Preferences.getHelp("ShowPreview")) self.accessKeysCheckBox.setChecked( Preferences.getHelp("AccessKeysEnabled")) self.javaCheckBox.setChecked(Preferences.getHelp("JavaEnabled")) self.javaScriptCheckBox.setChecked( Preferences.getHelp("JavaScriptEnabled")) self.jsOpenWindowsCheckBox.setChecked( Preferences.getHelp("JavaScriptCanOpenWindows")) self.jsClipboardCheckBox.setChecked( Preferences.getHelp("JavaScriptCanAccessClipboard")) self.pluginsCheckBox.setChecked(Preferences.getHelp("PluginsEnabled")) self.clickToFlashCheckBox.setChecked( Preferences.getHelp("ClickToFlashEnabled")) self.doNotTrackCheckBox.setChecked(Preferences.getHelp("DoNotTrack")) self.sendRefererCheckBox.setChecked(Preferences.getHelp("SendReferer")) self.diskCacheCheckBox.setChecked( Preferences.getHelp("DiskCacheEnabled")) self.cacheSizeSpinBox.setValue(Preferences.getHelp("DiskCacheSize")) cachePolicy = Preferences.getHelp("CachePolicy") if cachePolicy == QNetworkRequest.PreferNetwork: self.cacheKeepButton.setChecked(True) elif cachePolicy == QNetworkRequest.PreferCache: self.cachePreferButton.setChecked(True) elif cachePolicy == QNetworkRequest.AlwaysCache: self.cacheOfflineButton.setChecked(True) self.printBackgroundsCheckBox.setChecked( Preferences.getHelp("PrintBackgrounds")) self.startupCombo.setCurrentIndex( Preferences.getHelp("StartupBehavior")) self.homePageEdit.setText(Preferences.getHelp("HomePage")) self.defaultSchemeCombo.setCurrentIndex( self.defaultSchemeCombo.findText( Preferences.getHelp("DefaultScheme"))) historyLimit = Preferences.getHelp("HistoryLimit") idx = 0 if historyLimit == 1: idx = 0 elif historyLimit == 7: idx = 1 elif historyLimit == 14: idx = 2 elif historyLimit == 30: idx = 3 elif historyLimit == 365: idx = 4 elif historyLimit == -1: idx = 5 elif historyLimit == -2: idx = 6 else: idx = 5 self.expireHistory.setCurrentIndex(idx) for language in range(2, QLocale.LastLanguage + 1): countries = [ l.country() for l in QLocale.matchingLocales( language, QLocale.AnyScript, QLocale.AnyCountry) ] if len(countries) > 0: self.languageCombo.addItem(QLocale.languageToString(language), language) self.languageCombo.model().sort(0) self.languageCombo.insertSeparator(0) self.languageCombo.insertItem(0, QLocale.languageToString(0), 0) index = self.languageCombo.findData( Preferences.getHelp("SearchLanguage")) if index > -1: self.languageCombo.setCurrentIndex(index) if hasattr(QWebSettings, "SpatialNavigationEnabled"): self.spatialCheckBox.setChecked( Preferences.getHelp("SpatialNavigationEnabled")) else: self.spatialCheckBox.setEnabled(False) if hasattr(QWebSettings, "LinksIncludedInFocusChain"): self.linksInFocusChainCheckBox.setChecked( Preferences.getHelp("LinksIncludedInFocusChain")) else: self.linksInFocusChainCheckBox.setEnabled(False) if hasattr(QWebSettings, "XSSAuditingEnabled"): self.xssAuditingCheckBox.setChecked( Preferences.getHelp("XSSAuditingEnabled")) else: self.xssAuditingCheckBox.setEnabled(False) if hasattr(QWebSettings, "SiteSpecificQuirksEnabled"): self.quirksCheckBox.setChecked( Preferences.getHelp("SiteSpecificQuirksEnabled")) else: self.quirksCheckBox.setEnabled(False)
def save(self): """ Public slot to save the Help Documentation configuration. """ Preferences.setHelp("Python2DocDir", self.python2DocDirEdit.text()) Preferences.setHelp("PythonDocDir", self.pythonDocDirEdit.text()) Preferences.setHelp("Qt4DocDir", self.qt4DocDirEdit.text()) Preferences.setHelp("Qt5DocDir", self.qt5DocDirEdit.text()) Preferences.setHelp("PyQt5DocDir", self.pyqt4DocDirEdit.text()) Preferences.setHelp("PyQt5DocDir", self.pyqt5DocDirEdit.text()) Preferences.setHelp("PySideDocDir", self.pysideDocDirEdit.text())
def on_programsSearchButton_clicked(self): """ Private slot to search for all supported/required programs. """ QApplication.setOverrideCursor(QCursor(Qt.WaitCursor)) QApplication.processEvents() self.programsList.clear() header = self.programsList.header() header.setSortIndicator(0, Qt.AscendingOrder) header.setSortIndicatorShown(False) # 1. do the Qt4/Qt5 programs # 1a. Translation Converter exe = Utilities.isWindowsPlatform() and \ "{0}.exe".format(Utilities.generateQtToolName("lrelease")) or \ Utilities.generateQtToolName("lrelease") exe = os.path.join(Utilities.getQtBinariesPath(), exe) version = self.__createProgramEntry( self.tr("Translation Converter (Qt)"), exe, '-version', 'lrelease', -1) # 1b. Qt Designer if Utilities.isWindowsPlatform(): exe = os.path.join( Utilities.getQtBinariesPath(), "{0}.exe".format(Utilities.generateQtToolName("designer"))) elif Utilities.isMacPlatform(): exe = Utilities.getQtMacBundle("designer") else: exe = os.path.join(Utilities.getQtBinariesPath(), Utilities.generateQtToolName("designer")) self.__createProgramEntry(self.tr("Qt Designer"), exe, version=version) # 1c. Qt Linguist if Utilities.isWindowsPlatform(): exe = os.path.join( Utilities.getQtBinariesPath(), "{0}.exe".format(Utilities.generateQtToolName("linguist"))) elif Utilities.isMacPlatform(): exe = Utilities.getQtMacBundle("linguist") else: exe = os.path.join(Utilities.getQtBinariesPath(), Utilities.generateQtToolName("linguist")) self.__createProgramEntry(self.tr("Qt Linguist"), exe, version=version) # 1d. Qt Assistant if Utilities.isWindowsPlatform(): exe = os.path.join( Utilities.getQtBinariesPath(), "{0}.exe".format(Utilities.generateQtToolName("assistant"))) elif Utilities.isMacPlatform(): exe = Utilities.getQtMacBundle("assistant") else: exe = os.path.join(Utilities.getQtBinariesPath(), Utilities.generateQtToolName("assistant")) self.__createProgramEntry(self.tr("Qt Assistant"), exe, version=version) # 2. do the PyQt programs # 2a. Translation Extractor PyQt4 self.__createProgramEntry( self.tr("Translation Extractor (Python, PyQt4)"), Utilities.isWindowsPlatform() and "pylupdate4.exe" or "pylupdate4", '-version', 'pylupdate', -1) # 2b. Forms Compiler PyQt4 self.__createProgramEntry( self.tr("Forms Compiler (Python, PyQt4)"), Utilities.isWindowsPlatform() and "pyuic4.bat" or "pyuic4", '--version', 'Python User', 4) # 2c. Resource Compiler PyQt4 self.__createProgramEntry( self.tr("Resource Compiler (Python, PyQt4)"), Utilities.isWindowsPlatform() and "pyrcc4.exe" or "pyrcc4", '-version', 'Resource Compiler', -1) # 2d. Translation Extractor PyQt5 self.__createProgramEntry( self.tr("Translation Extractor (Python, PyQt5)"), Utilities.isWindowsPlatform() and "pylupdate5.exe" or "pylupdate5", '-version', 'pylupdate', -1) # 2e. Forms Compiler PyQt5 self.__createProgramEntry( self.tr("Forms Compiler (Python, PyQt5)"), Utilities.isWindowsPlatform() and "pyuic5.bat" or "pyuic5", '--version', 'Python User', 4) # 2f. Resource Compiler PyQt5 self.__createProgramEntry( self.tr("Resource Compiler (Python, PyQt5)"), Utilities.isWindowsPlatform() and "pyrcc5.exe" or "pyrcc5", '-version', 'Resource Compiler', -1) # 3. do the PySide programs # 3a. Translation Extractor PySide self.__createProgramEntry( self.tr("Translation Extractor (Python, PySide)"), Utilities.generatePySideToolPath("pyside-lupdate"), '-version', '', -1, versionRe='lupdate') # 3b. Forms Compiler PySide self.__createProgramEntry( self.tr("Forms Compiler (Python, PySide)"), Utilities.generatePySideToolPath("pyside-uic"), '--version', 'PySide User', 5, versionCleanup=(0, -1)) # 3.c Resource Compiler PySide self.__createProgramEntry( self.tr("Resource Compiler (Python, PySide)"), Utilities.generatePySideToolPath("pyside-rcc"), '-version', 'Resource Compiler', -1) # 4. do the Ruby programs # 4a. Forms Compiler for Qt4 self.__createProgramEntry( self.tr("Forms Compiler (Ruby, Qt4)"), Utilities.isWindowsPlatform() and "rbuic4.exe" or "rbuic4", '-version', 'Qt', -1) # 4b. Resource Compiler for Qt4 self.__createProgramEntry( self.tr("Resource Compiler (Ruby, Qt4)"), Utilities.isWindowsPlatform() and "rbrcc.exe" or "rbrcc", '-version', 'Ruby Resource Compiler', -1) # 5. do the CORBA programs # 5a. omniORB exe = Preferences.getCorba("omniidl") if Utilities.isWindowsPlatform(): exe += ".exe" self.__createProgramEntry(self.tr("CORBA IDL Compiler"), exe, '-V', 'omniidl', -1) # 6. do the spell checking entry try: import enchant try: text = os.path.dirname(enchant.__file__) except AttributeError: text = "enchant" try: version = enchant.__version__ except AttributeError: version = self.tr("(unknown)") except (ImportError, AttributeError, OSError): text = "enchant" version = "" self.__createEntry(self.tr("Spell Checker - PyEnchant"), text, version) # 7. do the pygments entry try: import pygments try: text = os.path.dirname(pygments.__file__) except AttributeError: text = "pygments" try: version = pygments.__version__ except AttributeError: version = self.tr("(unknown)") except (ImportError, AttributeError, OSError): text = "pygments" version = "" self.__createEntry(self.tr("Source Highlighter - Pygments"), text, version) # do the plugin related programs pm = e5App().getObject("PluginManager") for info in pm.getPluginExeDisplayData(): if info["programEntry"]: self.__createProgramEntry( info["header"], info["exe"], versionCommand=info["versionCommand"], versionStartsWith=info["versionStartsWith"], versionPosition=info["versionPosition"], version=info["version"], versionCleanup=info["versionCleanup"], ) else: self.__createEntry(info["header"], info["text"], info["version"]) self.programsList.sortByColumn(0, Qt.AscendingOrder) QApplication.restoreOverrideCursor() self.__hasSearched = True
def save(self): """ Public slot to save the Shell configuration. """ Preferences.setShell( "LinenoMargin", self.shellLinenoCheckBox.isChecked()) Preferences.setShell( "WrapEnabled", self.shellWordWrapCheckBox.isChecked()) Preferences.setShell( "AutoCompletionEnabled", self.shellACEnabledCheckBox.isChecked()) Preferences.setShell( "CallTipsEnabled", self.shellCTEnabledCheckBox.isChecked()) Preferences.setShell( "SyntaxHighlightingEnabled", self.shellSyntaxHighlightingCheckBox.isChecked()) Preferences.setShell( "MaxHistoryEntries", self.shellHistorySpinBox.value()) Preferences.setShell( "ShowStdOutErr", self.stdOutErrCheckBox.isChecked()) Preferences.setShell("MonospacedFont", self.monospacedFont) Preferences.setShell( "UseMonospacedFont", self.monospacedCheckBox.isChecked()) Preferences.setShell("MarginsFont", self.marginsFont)
def save(self): """ Public slot to save the Viewmanager configuration. """ Preferences.setPluginManager( "ActivateExternal", self.activateExternalPluginsCheckBox.isChecked()) Preferences.setPluginManager("DownloadPath", self.downloadDirPicker.text()) Preferences.setPluginManager("KeepGenerations", self.generationsSpinBox.value()) Preferences.setPluginManager("KeepHidden", self.keepHiddenCheckBox.isChecked()) Preferences.setPluginManager("StartupCleanup", self.startupCleanupCheckBox.isChecked()) if self.noCheckRadioButton.isChecked(): period = 0 elif self.dailyCheckRadioButton.isChecked(): period = 1 elif self.weeklyCheckRadioButton.isChecked(): period = 2 elif self.monthlyCheckRadioButton.isChecked(): period = 3 elif self.alwaysCheckRadioButton.isChecked(): period = 4 Preferences.setPluginManager("UpdatesCheckInterval", period) Preferences.setPluginManager("CheckInstalledOnly", self.downloadedOnlyCheckBox.isChecked()) if self.repositoryUrlEdit.text() != self.__repositoryUrl: Preferences.setUI("PluginRepositoryUrl6", self.repositoryUrlEdit.text())
def save(self): """ Public slot to save the IRC configuration. """ # timestamps Preferences.setIrc("ShowTimestamps", self.timestampGroup.isChecked()) Preferences.setIrc( "TimestampIncludeDate", self.showDateCheckBox.isChecked()) Preferences.setIrc("TimeFormat", self.timeFormatCombo.currentText()) Preferences.setIrc("DateFormat", self.dateFormatCombo.currentText()) # notifications Preferences.setIrc( "ShowNotifications", self.notificationsGroup.isChecked()) Preferences.setIrc( "NotifyJoinPart", self.joinLeaveCheckBox.isChecked()) Preferences.setIrc("NotifyMessage", self.messageCheckBox.isChecked()) Preferences.setIrc("NotifyNick", self.ownNickCheckBox.isChecked()) # Automatic User Information Lookup Preferences.setIrc("AutoUserInfoLookup", self.whoGroup.isChecked()) Preferences.setIrc("AutoUserInfoMax", self.whoUsersSpinBox.value()) Preferences.setIrc( "AutoUserInfoInterval", self.whoIntervalSpinBox.value()) # Markers Preferences.setIrc( "MarkPositionWhenHidden", self.markWhenHiddenCheckBox.isChecked()) # Shutdown Preferences.setIrc( "AskOnShutdown", self.confirmShutdownCheckBox.isChecked()) # colours self.saveColours(Preferences.setIrc)
def __init__(self, current_file_path=''): """ FileDialog constructor. Args: current_file_path: the current directory or path to the open flow graph """ if not current_file_path: current_file_path = path.join(DEFAULT_FILE_PATH, NEW_FLOGRAPH_TITLE + Preferences.file_extension()) if self.type == OPEN_FLOW_GRAPH: FileDialogHelper.__init__(self, gtk.FILE_CHOOSER_ACTION_OPEN, 'Open a Flow Graph from a File...') self.add_and_set_filter(get_flow_graph_files_filter()) self.set_select_multiple(True) elif self.type == SAVE_FLOW_GRAPH: FileDialogHelper.__init__(self, gtk.FILE_CHOOSER_ACTION_SAVE, 'Save a Flow Graph to a File...') self.add_and_set_filter(get_flow_graph_files_filter()) self.set_current_name(path.basename(current_file_path)) elif self.type == SAVE_CONSOLE: FileDialogHelper.__init__(self, gtk.FILE_CHOOSER_ACTION_SAVE, 'Save Console to a File...') self.add_and_set_filter(get_text_files_filter()) file_path = path.splitext(path.basename(current_file_path))[0] self.set_current_name(file_path) #show the current filename elif self.type == SAVE_IMAGE: FileDialogHelper.__init__(self, gtk.FILE_CHOOSER_ACTION_SAVE, 'Save a Flow Graph Screen Shot...') self.add_and_set_filter(get_image_files_filter()) current_file_path = current_file_path + IMAGE_FILE_EXTENSION self.set_current_name(path.basename(current_file_path)) #show the current filename elif self.type == OPEN_QSS_THEME: FileDialogHelper.__init__(self, gtk.FILE_CHOOSER_ACTION_OPEN, 'Open a QSS theme...') self.add_and_set_filter(get_qss_themes_filter()) self.set_select_multiple(False) self.set_current_folder(path.dirname(current_file_path)) #current directory
def config(self, session): '''config the plugin''' Preferences.Preferences(self.session)
def save(self): """ Public slot to save the Editor General configuration. """ Preferences.setEditor( "TabWidth", self.tabwidthSlider.value()) Preferences.setEditor( "IndentWidth", self.indentwidthSlider.value()) Preferences.setEditor( "TabForIndentation", self.tabforindentationCheckBox.isChecked()) Preferences.setEditor( "TabIndents", self.tabindentsCheckBox.isChecked()) Preferences.setEditor( "ConvertTabsOnLoad", self.converttabsCheckBox.isChecked()) Preferences.setEditor( "AutoIndentation", self.autoindentCheckBox.isChecked()) Preferences.setEditor( "CommentColumn0", self.comment0CheckBox.isChecked()) virtualSpaceOptions = QsciScintillaBase.SCVS_NONE if self.vsSelectionCheckBox.isChecked(): virtualSpaceOptions |= QsciScintillaBase.SCVS_RECTANGULARSELECTION if self.vsUserCheckBox.isChecked(): virtualSpaceOptions |= QsciScintillaBase.SCVS_USERACCESSIBLE Preferences.setEditor("VirtualSpaceOptions", virtualSpaceOptions) self.__saveLanguageOverrides()
def __init__(self): """ Constructor """ super(EditorFilePage, self).__init__() self.setupUi(self) self.setObjectName("EditorFilePage") self.__showsOpenFilters = True self.openFileFilters = \ Preferences.getEditor("AdditionalOpenFilters")[:] self.saveFileFilters = \ Preferences.getEditor("AdditionalSaveFilters")[:] self.fileFiltersList.addItems(self.openFileFilters) self.__setDefaultFiltersLists() self.defaultEncodingComboBox.addItems(sorted(supportedCodecs)) # set initial values self.autosaveSlider.setValue(Preferences.getEditor("AutosaveInterval")) self.createBackupFileCheckBox.setChecked( Preferences.getEditor("CreateBackupFile")) self.defaultEncodingComboBox.setCurrentIndex( self.defaultEncodingComboBox.findText( Preferences.getEditor("DefaultEncoding"))) self.advEncodingCheckBox.setChecked( Preferences.getEditor("AdvancedEncodingDetection")) self.warnFilesizeSpinBox.setValue( Preferences.getEditor("WarnFilesize")) self.clearBreakpointsCheckBox.setChecked( Preferences.getEditor("ClearBreaksOnClose")) self.automaticReopenCheckBox.setChecked( Preferences.getEditor("AutoReopen")) self.stripWhitespaceCheckBox.setChecked( Preferences.getEditor("StripTrailingWhitespace")) self.openFilesFilterComboBox.setCurrentIndex( self.openFilesFilterComboBox.findText( Preferences.getEditor("DefaultOpenFilter"))) self.saveFilesFilterComboBox.setCurrentIndex( self.saveFilesFilterComboBox.findText( Preferences.getEditor("DefaultSaveFilter"))) self.automaticEolConversionCheckBox.setChecked( Preferences.getEditor("AutomaticEOLConversion")) eolMode = Preferences.getEditor("EOLMode") if eolMode == QsciScintilla.EolWindows: self.crlfRadioButton.setChecked(True) elif eolMode == QsciScintilla.EolMac: self.crRadioButton.setChecked(True) elif eolMode == QsciScintilla.EolUnix: self.lfRadioButton.setChecked(True) self.previewHtmlExtensionsEdit.setText(" ".join( Preferences.getEditor("PreviewHtmlFileNameExtensions"))) self.previewMarkdownExtensionsEdit.setText(" ".join( Preferences.getEditor("PreviewMarkdownFileNameExtensions"))) self.previewRestExtensionsEdit.setText(" ".join( Preferences.getEditor("PreviewRestFileNameExtensions"))) self.previewQssExtensionsEdit.setText(" ".join( Preferences.getEditor("PreviewQssFileNameExtensions")))
def __init__(self, current_file_path=''): SaveImageFileDialog.__init__(self, current_file_path) self._button = button = gtk.CheckButton('_Background transparent') self._button.set_active(Preferences.screen_shot_background_transparent()) self.set_extra_widget(button)
def save(self): """ Public slot to save the Editor File Handling configuration. """ Preferences.setEditor("AutosaveInterval", self.autosaveSlider.value()) Preferences.setEditor("CreateBackupFile", self.createBackupFileCheckBox.isChecked()) enc = self.defaultEncodingComboBox.currentText() if not enc: enc = "utf-8" Preferences.setEditor("DefaultEncoding", enc) Preferences.setEditor("AdvancedEncodingDetection", self.advEncodingCheckBox.isChecked()) Preferences.setEditor("WarnFilesize", self.warnFilesizeSpinBox.value()) Preferences.setEditor("ClearBreaksOnClose", self.clearBreakpointsCheckBox.isChecked()) Preferences.setEditor("AutoReopen", self.automaticReopenCheckBox.isChecked()) Preferences.setEditor("StripTrailingWhitespace", self.stripWhitespaceCheckBox.isChecked()) Preferences.setEditor("DefaultOpenFilter", self.openFilesFilterComboBox.currentText()) Preferences.setEditor("DefaultSaveFilter", self.saveFilesFilterComboBox.currentText()) Preferences.setEditor("AutomaticEOLConversion", self.automaticEolConversionCheckBox.isChecked()) if self.crlfRadioButton.isChecked(): Preferences.setEditor("EOLMode", QsciScintilla.EolWindows) elif self.crRadioButton.isChecked(): Preferences.setEditor("EOLMode", QsciScintilla.EolMac) elif self.lfRadioButton.isChecked(): Preferences.setEditor("EOLMode", QsciScintilla.EolUnix) self.__extractFileFilters() Preferences.setEditor("AdditionalOpenFilters", self.openFileFilters) Preferences.setEditor("AdditionalSaveFilters", self.saveFileFilters) Preferences.setEditor("PreviewHtmlFileNameExtensions", [ ext.strip() for ext in self.previewHtmlExtensionsEdit.text().split() ]) Preferences.setEditor("PreviewMarkdownFileNameExtensions", [ ext.strip() for ext in self.previewMarkdownExtensionsEdit.text().split() ]) Preferences.setEditor("PreviewRestFileNameExtensions", [ ext.strip() for ext in self.previewRestExtensionsEdit.text().split() ]) Preferences.setEditor("PreviewQssFileNameExtensions", [ ext.strip() for ext in self.previewQssExtensionsEdit.text().split() ])
def get_flow_graph_files_filter(): filter = gtk.FileFilter() filter.set_name('Flow Graph Files') filter.add_pattern('*'+Preferences.file_extension()) return filter
def _handle_action(self, action): #print action ################################################## # Initalize/Quit ################################################## if action == Actions.APPLICATION_INITIALIZE: for action in Actions.get_all_actions(): action.set_sensitive(False) #set all actions disabled #enable a select few actions for action in ( Actions.APPLICATION_QUIT, Actions.FLOW_GRAPH_NEW, Actions.FLOW_GRAPH_OPEN, Actions.FLOW_GRAPH_SAVE_AS, Actions.FLOW_GRAPH_CLOSE, Actions.ABOUT_WINDOW_DISPLAY, Actions.FLOW_GRAPH_SCREEN_CAPTURE, Actions.HELP_WINDOW_DISPLAY, Actions.TYPES_WINDOW_DISPLAY, ): action.set_sensitive(True) if not self.init_file_paths: self.init_file_paths = Preferences.files_open() if not self.init_file_paths: self.init_file_paths = [''] for file_path in self.init_file_paths: if file_path: self.main_window.new_page( file_path) #load pages from file paths if Preferences.file_open() in self.init_file_paths: self.main_window.new_page(Preferences.file_open(), show=True) if not self.get_page(): self.main_window.new_page( ) #ensure that at least a blank page exists elif action == Actions.APPLICATION_QUIT: if self.main_window.close_pages(): gtk.main_quit() exit(0) ################################################## # Selections ################################################## elif action == Actions.ELEMENT_SELECT: pass #do nothing, update routines below elif action == Actions.NOTHING_SELECT: self.get_flow_graph().unselect() ################################################## # Enable/Disable ################################################## elif action == Actions.BLOCK_ENABLE: if self.get_flow_graph().enable_selected(True): self.get_flow_graph().update() self.get_page().get_state_cache().save_new_state( self.get_flow_graph().export_data()) self.get_page().set_saved(False) elif action == Actions.BLOCK_DISABLE: if self.get_flow_graph().enable_selected(False): self.get_flow_graph().update() self.get_page().get_state_cache().save_new_state( self.get_flow_graph().export_data()) self.get_page().set_saved(False) ################################################## # Cut/Copy/Paste ################################################## elif action == Actions.BLOCK_CUT: Actions.BLOCK_COPY() Actions.ELEMENT_DELETE() elif action == Actions.BLOCK_COPY: self.clipboard = self.get_flow_graph().copy_to_clipboard() elif action == Actions.BLOCK_PASTE: if self.clipboard: self.get_flow_graph().paste_from_clipboard(self.clipboard) self.get_flow_graph().update() self.get_page().get_state_cache().save_new_state( self.get_flow_graph().export_data()) self.get_page().set_saved(False) ################################################## # Move/Rotate/Delete/Create ################################################## elif action == Actions.BLOCK_MOVE: self.get_page().get_state_cache().save_new_state( self.get_flow_graph().export_data()) self.get_page().set_saved(False) elif action == Actions.BLOCK_ROTATE_CCW: if self.get_flow_graph().rotate_selected(90): self.get_flow_graph().update() self.get_page().get_state_cache().save_new_state( self.get_flow_graph().export_data()) self.get_page().set_saved(False) elif action == Actions.BLOCK_ROTATE_CW: if self.get_flow_graph().rotate_selected(-90): self.get_flow_graph().update() self.get_page().get_state_cache().save_new_state( self.get_flow_graph().export_data()) self.get_page().set_saved(False) elif action == Actions.ELEMENT_DELETE: if self.get_flow_graph().remove_selected(): self.get_flow_graph().update() self.get_page().get_state_cache().save_new_state( self.get_flow_graph().export_data()) Actions.NOTHING_SELECT() self.get_page().set_saved(False) elif action == Actions.ELEMENT_CREATE: self.get_flow_graph().update() self.get_page().get_state_cache().save_new_state( self.get_flow_graph().export_data()) Actions.NOTHING_SELECT() self.get_page().set_saved(False) elif action == Actions.BLOCK_INC_TYPE: if self.get_flow_graph().type_controller_modify_selected(1): self.get_flow_graph().update() self.get_page().get_state_cache().save_new_state( self.get_flow_graph().export_data()) self.get_page().set_saved(False) elif action == Actions.BLOCK_DEC_TYPE: if self.get_flow_graph().type_controller_modify_selected(-1): self.get_flow_graph().update() self.get_page().get_state_cache().save_new_state( self.get_flow_graph().export_data()) self.get_page().set_saved(False) elif action == Actions.PORT_CONTROLLER_INC: if self.get_flow_graph().port_controller_modify_selected(1): self.get_flow_graph().update() self.get_page().get_state_cache().save_new_state( self.get_flow_graph().export_data()) self.get_page().set_saved(False) elif action == Actions.PORT_CONTROLLER_DEC: if self.get_flow_graph().port_controller_modify_selected(-1): self.get_flow_graph().update() self.get_page().get_state_cache().save_new_state( self.get_flow_graph().export_data()) self.get_page().set_saved(False) ################################################## # Window stuff ################################################## elif action == Actions.ABOUT_WINDOW_DISPLAY: Dialogs.AboutDialog(self.get_flow_graph().get_parent()) elif action == Actions.HELP_WINDOW_DISPLAY: Dialogs.HelpDialog() elif action == Actions.TYPES_WINDOW_DISPLAY: Dialogs.TypesDialog(self.get_flow_graph().get_parent()) elif action == Actions.ERRORS_WINDOW_DISPLAY: Dialogs.ErrorsDialog(self.get_flow_graph()) ################################################## # Param Modifications ################################################## elif action == Actions.BLOCK_PARAM_MODIFY: selected_block = self.get_flow_graph().get_selected_block() if selected_block: if PropsDialog(selected_block).run(): #save the new state self.get_flow_graph().update() self.get_page().get_state_cache().save_new_state( self.get_flow_graph().export_data()) self.get_page().set_saved(False) else: #restore the current state n = self.get_page().get_state_cache().get_current_state() self.get_flow_graph().import_data(n) self.get_flow_graph().update() ################################################## # Undo/Redo ################################################## elif action == Actions.FLOW_GRAPH_UNDO: n = self.get_page().get_state_cache().get_prev_state() if n: self.get_flow_graph().unselect() self.get_flow_graph().import_data(n) self.get_flow_graph().update() self.get_page().set_saved(False) elif action == Actions.FLOW_GRAPH_REDO: n = self.get_page().get_state_cache().get_next_state() if n: self.get_flow_graph().unselect() self.get_flow_graph().import_data(n) self.get_flow_graph().update() self.get_page().set_saved(False) ################################################## # New/Open/Save/Close ################################################## elif action == Actions.FLOW_GRAPH_NEW: self.main_window.new_page() elif action == Actions.FLOW_GRAPH_OPEN: file_paths = OpenFlowGraphFileDialog( self.get_page().get_file_path()).run() if file_paths: #open a new page for each file, show only the first for i, file_path in enumerate(file_paths): self.main_window.new_page(file_path, show=(i == 0)) elif action == Actions.FLOW_GRAPH_CLOSE: self.main_window.close_page() elif action == Actions.FLOW_GRAPH_SAVE: #read-only or undefined file path, do save-as if self.get_page().get_read_only( ) or not self.get_page().get_file_path(): Actions.FLOW_GRAPH_SAVE_AS() #otherwise try to save else: try: ParseXML.to_file(self.get_flow_graph().export_data(), self.get_page().get_file_path()) self.get_page().set_saved(True) except IOError: Messages.send_fail_save(self.get_page().get_file_path()) self.get_page().set_saved(False) elif action == Actions.FLOW_GRAPH_SAVE_AS: file_path = SaveFlowGraphFileDialog( self.get_page().get_file_path()).run() if file_path is not None: self.get_page().set_file_path(file_path) Actions.FLOW_GRAPH_SAVE() elif action == Actions.FLOW_GRAPH_SCREEN_CAPTURE: file_path = SaveImageFileDialog( self.get_page().get_file_path()).run() if file_path is not None: pixbuf = self.get_flow_graph().get_drawing_area().get_pixbuf() pixbuf.save(file_path, IMAGE_FILE_EXTENSION[1:]) ################################################## # Gen/Exec/Stop ################################################## elif action == Actions.FLOW_GRAPH_GEN: if not self.get_page().get_pid(): if not self.get_page().get_saved() or not self.get_page( ).get_file_path(): Actions.FLOW_GRAPH_SAVE( ) #only save if file path missing or not saved if self.get_page().get_saved() and self.get_page( ).get_file_path(): generator = self.get_page().get_generator() try: Messages.send_start_gen(generator.get_file_path()) generator.write() except Exception, e: Messages.send_fail_gen(e) else: self.generator = None
def getLexer(language, parent=None, pyname=""): """ Module function to instantiate a lexer object for a given language. @param language language of the lexer (string) @param parent reference to the parent object (QObject) @keyparam pyname name of the pygments lexer to use (string) @return reference to the instanciated lexer object (QsciLexer) """ if not pyname: try: if language in ["Python", "Python2", "Python3"]: from .LexerPython import LexerPython return LexerPython(language, parent) elif language == "C++": from .LexerCPP import LexerCPP return LexerCPP( parent, Preferences.getEditor("CppCaseInsensitiveKeywords")) elif language == "C#": from .LexerCSharp import LexerCSharp return LexerCSharp(parent) elif language == "IDL": from .LexerIDL import LexerIDL return LexerIDL(parent) elif language == "Java": from .LexerJava import LexerJava return LexerJava(parent) elif language == "JavaScript": from .LexerJavaScript import LexerJavaScript return LexerJavaScript(parent) elif language == "SQL": from .LexerSQL import LexerSQL return LexerSQL(parent) elif language == "HTML": from .LexerHTML import LexerHTML return LexerHTML(parent) elif language == "Perl": from .LexerPerl import LexerPerl return LexerPerl(parent) elif language == "Bash": from .LexerBash import LexerBash return LexerBash(parent) elif language == "Ruby": from .LexerRuby import LexerRuby return LexerRuby(parent) elif language == "Lua": from .LexerLua import LexerLua return LexerLua(parent) elif language == "CSS": from .LexerCSS import LexerCSS return LexerCSS(parent) elif language == "TeX": from .LexerTeX import LexerTeX return LexerTeX(parent) elif language == "Diff": from .LexerDiff import LexerDiff return LexerDiff(parent) elif language == "Makefile": from .LexerMakefile import LexerMakefile return LexerMakefile(parent) elif language == "Properties": from .LexerProperties import LexerProperties return LexerProperties(parent) elif language == "Batch": from .LexerBatch import LexerBatch return LexerBatch(parent) elif language == "D": from .LexerD import LexerD return LexerD(parent) elif language == "Povray": from .LexerPOV import LexerPOV return LexerPOV(parent) elif language == "CMake": from .LexerCMake import LexerCMake return LexerCMake(parent) elif language == "VHDL": from .LexerVHDL import LexerVHDL return LexerVHDL(parent) elif language == "TCL": from .LexerTCL import LexerTCL return LexerTCL(parent) elif language == "Fortran": from .LexerFortran import LexerFortran return LexerFortran(parent) elif language == "Fortran77": from .LexerFortran77 import LexerFortran77 return LexerFortran77(parent) elif language == "Pascal": from .LexerPascal import LexerPascal return LexerPascal(parent) elif language == "PostScript": from .LexerPostScript import LexerPostScript return LexerPostScript(parent) elif language == "XML": from .LexerXML import LexerXML return LexerXML(parent) elif language == "YAML": from .LexerYAML import LexerYAML return LexerYAML(parent) elif language == "Matlab": from .LexerMatlab import LexerMatlab return LexerMatlab(parent) elif language == "Octave": from .LexerOctave import LexerOctave return LexerOctave(parent) elif language == "QSS": from .LexerQSS import LexerQSS return LexerQSS(parent) elif language == "Gettext": from .LexerPO import LexerPO return LexerPO(parent) elif language == "CoffeeScript": from .LexerCoffeeScript import LexerCoffeeScript return LexerCoffeeScript(parent) elif language in LexerRegistry: return LexerRegistry[language][2](parent) else: return __getPygmentsLexer(parent) except ImportError: return __getPygmentsLexer(parent) else: return __getPygmentsLexer(parent, name=pyname)
def searchPackages(self, pattern, fullNameOnly=False, packageSpec=False, platform="", name="", prefix=""): """ Public method to search for a package pattern of a conda environment. @param pattern package search pattern @type str @param fullNameOnly flag indicating to search for full names only @type bool @param packageSpec flag indicating to search a package specification @type bool @param platform type of platform to be searched for @type str @param name name of the environment @type str @param prefix prefix of the environment @type str @return flag indicating success and a dictionary with package name as key and list of dictionaries containing detailed data for the found packages as values @rtype tuple of (bool, dict of list of dict) @exception RuntimeError raised to indicate an error in parameters Note: only one of name or prefix must be given. """ if name and prefix: raise RuntimeError("Only one of 'name' or 'prefix' must be given.") args = [ "search", "--json", ] if fullNameOnly: args.append("--full-name") if packageSpec: args.append("--spec") if platform: args.extend(["--platform", platform]) if name: args.extend(["--name", name]) elif prefix: args.extend(["--prefix", prefix]) args.append(pattern) exe = Preferences.getConda("CondaExecutable") if not exe: exe = "conda" packages = {} ok = False proc = QProcess() proc.start(exe, args) if proc.waitForStarted(15000): if proc.waitForFinished(30000): output = str(proc.readAllStandardOutput(), Preferences.getSystem("IOEncoding"), 'replace').strip() try: packages = json.loads(output) ok = "error" not in packages except Exception: # return values for errors is already set pass return ok, packages