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
