def _add_simple_query_item(self,
field_name: str,
operator: str = '=',
value=None):
"""
Adds a simple query item
"""
combo = QComboBox()
combo.addItem('=')
combo.addItem('<')
combo.addItem('<=')
combo.addItem('>')
combo.addItem('>=')
combo.addItem('<>')
combo.setCurrentIndex(combo.findText(operator))
button = QToolButton()
button.setIcon(GuiUtils.get_icon('remove.svg'))
button.setAutoRaise(True)
filter_item = QTreeWidgetItem()
filter_item.setText(0, field_name)
filter_item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable
| Qt.ItemIsEditable)
filter_item.setText(2, value)
self.simple_query_list.addTopLevelItem(filter_item)
self.simple_query_list.setItemWidget(filter_item, 1, combo)
self.simple_query_list.setItemWidget(filter_item, 3, button)
button.clicked.connect(partial(self._remove_simple_item, filter_item))
class AlgorithmDialogBase(BASE, WIDGET):
def __init__(self, alg):
super(AlgorithmDialogBase,
self).__init__(iface.mainWindow() if iface else None)
self.setupUi(self)
# don't collapse parameters panel
self.splitter.setCollapsible(0, False)
# add collapse button to splitter
splitterHandle = self.splitter.handle(1)
handleLayout = QVBoxLayout()
handleLayout.setContentsMargins(0, 0, 0, 0)
self.btnCollapse = QToolButton(splitterHandle)
self.btnCollapse.setAutoRaise(True)
self.btnCollapse.setFixedSize(12, 12)
self.btnCollapse.setCursor(Qt.ArrowCursor)
handleLayout.addWidget(self.btnCollapse)
handleLayout.addStretch()
splitterHandle.setLayout(handleLayout)
self.settings = QgsSettings()
self.splitter.restoreState(
self.settings.value("/Processing/dialogBaseSplitter",
QByteArray()))
self.restoreGeometry(
self.settings.value("/Processing/dialogBase", QByteArray()))
self.splitterState = self.splitter.saveState()
self.splitterChanged(0, 0)
self.executed = False
self.mainWidget = None
self.alg = alg
self.setWindowTitle(self.alg.displayName())
self.buttonBox.rejected.connect(self.reject)
self.buttonBox.accepted.connect(self.accept)
# Rename OK button to Run
self.btnRun = self.buttonBox.button(QDialogButtonBox.Ok)
self.btnRun.setText(self.tr('Run'))
self.buttonCancel.setEnabled(False)
self.btnClose = self.buttonBox.button(QDialogButtonBox.Close)
self.buttonBox.helpRequested.connect(self.openHelp)
self.btnCollapse.clicked.connect(self.toggleCollapsed)
self.splitter.splitterMoved.connect(self.splitterChanged)
# desktop = QDesktopWidget()
# if desktop.physicalDpiX() > 96:
# self.txtHelp.setZoomFactor(desktop.physicalDpiX() / 96)
algHelp = self.formatHelp(self.alg)
if algHelp is None:
self.textShortHelp.hide()
else:
self.textShortHelp.document().setDefaultStyleSheet(
'''.summary { margin-left: 10px; margin-right: 10px; }
h2 { color: #555555; padding-bottom: 15px; }
a { text-decoration: none; color: #3498db; font-weight: bold; }
p { color: #666666; }
b { color: #333333; }
dl dd { margin-bottom: 5px; }'''
)
self.textShortHelp.setHtml(algHelp)
def linkClicked(url):
webbrowser.open(url.toString())
self.textShortHelp.anchorClicked.connect(linkClicked)
self.showDebug = ProcessingConfig.getSetting(
ProcessingConfig.SHOW_DEBUG_IN_DIALOG)
def createFeedback(self):
feedback = AlgorithmDialogFeedback(self)
feedback.progressChanged.connect(self.setPercentage)
feedback.error.connect(self.error)
feedback.progress_text.connect(self.setText)
feedback.info.connect(self.setInfo)
feedback.command_info.connect(self.setCommand)
feedback.debug_info.connect(self.setDebugInfo)
feedback.console_info.connect(self.setConsoleInfo)
self.buttonCancel.clicked.connect(feedback.cancel)
return feedback
def formatHelp(self, alg):
text = alg.shortHelpString()
if not text:
return None
return "<h2>%s</h2>%s" % (alg.displayName(), "".join(
["<p>%s</p>" % s for s in text.split("\n")]))
def closeEvent(self, event):
self._saveGeometry()
super(AlgorithmDialogBase, self).closeEvent(event)
def setMainWidget(self, widget):
if self.mainWidget is not None:
QgsProject.instance().layerWasAdded.disconnect(
self.mainWidget.layerRegistryChanged)
QgsProject.instance().layersWillBeRemoved.disconnect(
self.mainWidget.layerRegistryChanged)
self.mainWidget = widget
self.tabWidget.widget(0).layout().addWidget(self.mainWidget)
QgsProject.instance().layerWasAdded.connect(
self.mainWidget.layerRegistryChanged)
QgsProject.instance().layersWillBeRemoved.connect(
self.mainWidget.layerRegistryChanged)
def error(self, msg):
self.setInfo(msg, True)
self.resetGUI()
self.tabWidget.setCurrentIndex(1)
def resetGUI(self):
self.lblProgress.setText('')
self.progressBar.setMaximum(100)
self.progressBar.setValue(0)
self.btnRun.setEnabled(True)
self.btnClose.setEnabled(True)
def setInfo(self, msg, error=False, escape_html=True):
if error:
self.txtLog.append(
'<span style="color:red">{}</span><br />'.format(msg,
quote=False))
elif escape_html:
self.txtLog.append(html.escape(msg))
else:
self.txtLog.append(msg)
def setCommand(self, cmd):
if self.showDebug:
self.txtLog.append('<code>{}<code>'.format(
html.escape(cmd, quote=False)))
def setDebugInfo(self, msg):
if self.showDebug:
self.txtLog.append('<span style="color:blue">{}</span>'.format(
html.escape(msg, quote=False)))
def setConsoleInfo(self, msg):
if self.showDebug:
self.txtLog.append(
'<code><span style="color:darkgray">{}</span></code>'.format(
html.escape(msg, quote=False)))
def setPercentage(self, value):
if self.progressBar.maximum() == 0:
self.progressBar.setMaximum(100)
self.progressBar.setValue(value)
def setText(self, text):
self.lblProgress.setText(text)
self.setInfo(text, False)
def getParamValues(self):
return {}
def accept(self):
pass
def reject(self):
self._saveGeometry()
super(AlgorithmDialogBase, self).reject()
def finish(self, successful, result, context, feedback):
pass
def toggleCollapsed(self):
if self.helpCollapsed:
self.splitter.restoreState(self.splitterState)
self.btnCollapse.setArrowType(Qt.RightArrow)
else:
self.splitterState = self.splitter.saveState()
self.splitter.setSizes([1, 0])
self.btnCollapse.setArrowType(Qt.LeftArrow)
self.helpCollapsed = not self.helpCollapsed
def splitterChanged(self, pos, index):
if self.splitter.sizes()[1] == 0:
self.helpCollapsed = True
self.btnCollapse.setArrowType(Qt.LeftArrow)
else:
self.helpCollapsed = False
self.btnCollapse.setArrowType(Qt.RightArrow)
def openHelp(self):
algHelp = self.alg.helpUrl()
if not algHelp:
algHelp = QgsHelp.helpUrl("processing_algs/{}/{}".format(
self.alg.provider().id(), self.alg.id())).toString()
if algHelp not in [None, ""]:
webbrowser.open(algHelp)
def _saveGeometry(self):
self.settings.setValue("/Processing/dialogBaseSplitter",
self.splitter.saveState())
self.settings.setValue("/Processing/dialogBase", self.saveGeometry())
class InvalidParameterValue(Exception):
def __init__(self, param, widget):
(self.parameter, self.widget) = (param, widget)
class AlgorithmDialogBase(BASE, WIDGET):
def __init__(self, alg):
super(AlgorithmDialogBase, self).__init__(iface.mainWindow() if iface else None)
self.setupUi(self)
# don't collapse parameters panel
self.splitter.setCollapsible(0, False)
# add collapse button to splitter
splitterHandle = self.splitter.handle(1)
handleLayout = QVBoxLayout()
handleLayout.setContentsMargins(0, 0, 0, 0)
self.btnCollapse = QToolButton(splitterHandle)
self.btnCollapse.setAutoRaise(True)
self.btnCollapse.setFixedSize(12, 12)
self.btnCollapse.setCursor(Qt.ArrowCursor)
handleLayout.addWidget(self.btnCollapse)
handleLayout.addStretch()
splitterHandle.setLayout(handleLayout)
self.settings = QgsSettings()
self.splitter.restoreState(self.settings.value("/Processing/dialogBaseSplitter", QByteArray()))
self.restoreGeometry(self.settings.value("/Processing/dialogBase", QByteArray()))
self.splitterState = self.splitter.saveState()
self.splitterChanged(0, 0)
self.executed = False
self.mainWidget = None
self.alg = alg
self.setWindowTitle(self.alg.displayName())
self.buttonBox.rejected.connect(self.reject)
self.buttonBox.accepted.connect(self.accept)
# Rename OK button to Run
self.btnRun = self.buttonBox.button(QDialogButtonBox.Ok)
self.btnRun.setText(self.tr('Run'))
self.buttonCancel.setEnabled(False)
self.btnClose = self.buttonBox.button(QDialogButtonBox.Close)
self.buttonBox.helpRequested.connect(self.openHelp)
self.btnCollapse.clicked.connect(self.toggleCollapsed)
self.splitter.splitterMoved.connect(self.splitterChanged)
# desktop = QDesktopWidget()
# if desktop.physicalDpiX() > 96:
# self.txtHelp.setZoomFactor(desktop.physicalDpiX() / 96)
algHelp = self.formatHelp(self.alg)
if algHelp is None:
self.textShortHelp.hide()
else:
self.textShortHelp.document().setDefaultStyleSheet('''.summary { margin-left: 10px; margin-right: 10px; }
h2 { color: #555555; padding-bottom: 15px; }
a { text-decoration: none; color: #3498db; font-weight: bold; }
p { color: #666666; }
b { color: #333333; }
dl dd { margin-bottom: 5px; }''')
self.textShortHelp.setHtml(algHelp)
def linkClicked(url):
webbrowser.open(url.toString())
self.textShortHelp.anchorClicked.connect(linkClicked)
self.showDebug = ProcessingConfig.getSetting(
ProcessingConfig.SHOW_DEBUG_IN_DIALOG)
def createFeedback(self):
feedback = AlgorithmDialogFeedback(self)
feedback.progressChanged.connect(self.setPercentage)
feedback.error.connect(self.error)
feedback.progress_text.connect(self.setText)
feedback.info.connect(self.setInfo)
feedback.command_info.connect(self.setCommand)
feedback.debug_info.connect(self.setDebugInfo)
feedback.console_info.connect(self.setConsoleInfo)
self.buttonCancel.clicked.connect(feedback.cancel)
return feedback
def formatHelp(self, alg):
text = alg.shortHelpString()
if not text:
return None
return "<h2>%s</h2>%s" % (alg.displayName(), "".join(["<p>%s</p>" % s for s in text.split("\n")]))
def closeEvent(self, event):
self._saveGeometry()
super(AlgorithmDialogBase, self).closeEvent(event)
def setMainWidget(self, widget):
if self.mainWidget is not None:
QgsProject.instance().layerWasAdded.disconnect(self.mainWidget.layerRegistryChanged)
QgsProject.instance().layersWillBeRemoved.disconnect(self.mainWidget.layerRegistryChanged)
self.mainWidget = widget
self.tabWidget.widget(0).layout().addWidget(self.mainWidget)
QgsProject.instance().layerWasAdded.connect(self.mainWidget.layerRegistryChanged)
QgsProject.instance().layersWillBeRemoved.connect(self.mainWidget.layerRegistryChanged)
def error(self, msg):
self.setInfo(msg, True)
self.resetGUI()
self.tabWidget.setCurrentIndex(1)
def resetGUI(self):
self.lblProgress.setText('')
self.progressBar.setMaximum(100)
self.progressBar.setValue(0)
self.btnRun.setEnabled(True)
self.btnClose.setEnabled(True)
def setInfo(self, msg, error=False, escape_html=True):
if error:
self.txtLog.append('<span style="color:red">{}</span><br />'.format(msg, quote=False))
elif escape_html:
self.txtLog.append(html.escape(msg))
else:
self.txtLog.append(msg)
def setCommand(self, cmd):
if self.showDebug:
self.txtLog.append('<code>{}<code>'.format(html.escape(cmd, quote=False)))
def setDebugInfo(self, msg):
if self.showDebug:
self.txtLog.append('<span style="color:blue">{}</span>'.format(html.escape(msg, quote=False)))
def setConsoleInfo(self, msg):
if self.showDebug:
self.txtLog.append('<code><span style="color:darkgray">{}</span></code>'.format(html.escape(msg, quote=False)))
def setPercentage(self, value):
if self.progressBar.maximum() == 0:
self.progressBar.setMaximum(100)
self.progressBar.setValue(value)
def setText(self, text):
self.lblProgress.setText(text)
self.setInfo(text, False)
def getParamValues(self):
return {}
def accept(self):
pass
def reject(self):
self._saveGeometry()
super(AlgorithmDialogBase, self).reject()
def finish(self, successful, result, context, feedback):
pass
def toggleCollapsed(self):
if self.helpCollapsed:
self.splitter.restoreState(self.splitterState)
self.btnCollapse.setArrowType(Qt.RightArrow)
else:
self.splitterState = self.splitter.saveState()
self.splitter.setSizes([1, 0])
self.btnCollapse.setArrowType(Qt.LeftArrow)
self.helpCollapsed = not self.helpCollapsed
def splitterChanged(self, pos, index):
if self.splitter.sizes()[1] == 0:
self.helpCollapsed = True
self.btnCollapse.setArrowType(Qt.LeftArrow)
else:
self.helpCollapsed = False
self.btnCollapse.setArrowType(Qt.RightArrow)
def openHelp(self):
algHelp = self.alg.helpUrl()
if not algHelp:
algHelp = QgsHelp.helpUrl("processing_algs/{}/{}".format(
self.alg.provider().id(), self.alg.id())).toString()
if algHelp not in [None, ""]:
webbrowser.open(algHelp)
def _saveGeometry(self):
self.settings.setValue("/Processing/dialogBaseSplitter", self.splitter.saveState())
self.settings.setValue("/Processing/dialogBase", self.saveGeometry())
class InvalidParameterValue(Exception):
def __init__(self, param, widget):
(self.parameter, self.widget) = (param, widget)
class PythonConsoleWidget(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setWindowTitle(
QCoreApplication.translate("PythonConsole", "Python Console"))
self.settings = QgsSettings()
self.shell = ShellScintilla(self)
self.setFocusProxy(self.shell)
self.shellOut = ShellOutputScintilla(self)
self.tabEditorWidget = EditorTabWidget(self)
# ------------ UI -------------------------------
self.splitterEditor = QSplitter(self)
self.splitterEditor.setOrientation(Qt.Horizontal)
self.splitterEditor.setHandleWidth(6)
self.splitterEditor.setChildrenCollapsible(True)
self.shellOutWidget = QWidget(self)
self.shellOutWidget.setLayout(QVBoxLayout())
self.shellOutWidget.layout().setContentsMargins(0, 0, 0, 0)
self.shellOutWidget.layout().addWidget(self.shellOut)
self.splitter = QSplitter(self.splitterEditor)
self.splitter.setOrientation(Qt.Vertical)
self.splitter.setHandleWidth(3)
self.splitter.setChildrenCollapsible(False)
self.splitter.addWidget(self.shellOutWidget)
self.splitter.addWidget(self.shell)
# self.splitterEditor.addWidget(self.tabEditorWidget)
self.splitterObj = QSplitter(self.splitterEditor)
self.splitterObj.setHandleWidth(3)
self.splitterObj.setOrientation(Qt.Horizontal)
# self.splitterObj.setSizes([0, 0])
# self.splitterObj.setStretchFactor(0, 1)
self.widgetEditor = QWidget(self.splitterObj)
self.widgetFind = QWidget(self)
self.listClassMethod = QTreeWidget(self.splitterObj)
self.listClassMethod.setColumnCount(2)
objInspLabel = QCoreApplication.translate("PythonConsole",
"Object Inspector")
self.listClassMethod.setHeaderLabels([objInspLabel, ''])
self.listClassMethod.setColumnHidden(1, True)
self.listClassMethod.setAlternatingRowColors(True)
# self.splitterEditor.addWidget(self.widgetEditor)
# self.splitterObj.addWidget(self.listClassMethod)
# self.splitterObj.addWidget(self.widgetEditor)
# Hide side editor on start up
self.splitterObj.hide()
self.listClassMethod.hide()
# Hide search widget on start up
self.widgetFind.hide()
icon_size = iface.iconSize(
dockedToolbar=True) if iface else QSize(16, 16)
sizes = self.splitter.sizes()
self.splitter.setSizes(sizes)
# ----------------Restore Settings------------------------------------
self.restoreSettingsConsole()
# ------------------Toolbar Editor-------------------------------------
# Action for Open File
openFileBt = QCoreApplication.translate("PythonConsole",
"Open Script...")
self.openFileButton = QAction(self)
self.openFileButton.setCheckable(False)
self.openFileButton.setEnabled(True)
self.openFileButton.setIcon(
QgsApplication.getThemeIcon("console/iconOpenConsole.png"))
self.openFileButton.setMenuRole(QAction.PreferencesRole)
self.openFileButton.setIconVisibleInMenu(True)
self.openFileButton.setToolTip(openFileBt)
self.openFileButton.setText(openFileBt)
openExtEditorBt = QCoreApplication.translate(
"PythonConsole", "Open in External Editor")
self.openInEditorButton = QAction(self)
self.openInEditorButton.setCheckable(False)
self.openInEditorButton.setEnabled(True)
self.openInEditorButton.setIcon(
QgsApplication.getThemeIcon("console/iconShowEditorConsole.png"))
self.openInEditorButton.setMenuRole(QAction.PreferencesRole)
self.openInEditorButton.setIconVisibleInMenu(True)
self.openInEditorButton.setToolTip(openExtEditorBt)
self.openInEditorButton.setText(openExtEditorBt)
# Action for Save File
saveFileBt = QCoreApplication.translate("PythonConsole", "Save")
self.saveFileButton = QAction(self)
self.saveFileButton.setCheckable(False)
self.saveFileButton.setEnabled(False)
self.saveFileButton.setIcon(
QgsApplication.getThemeIcon("console/iconSaveConsole.png"))
self.saveFileButton.setMenuRole(QAction.PreferencesRole)
self.saveFileButton.setIconVisibleInMenu(True)
self.saveFileButton.setToolTip(saveFileBt)
self.saveFileButton.setText(saveFileBt)
# Action for Save File As
saveAsFileBt = QCoreApplication.translate("PythonConsole",
"Save As...")
self.saveAsFileButton = QAction(self)
self.saveAsFileButton.setCheckable(False)
self.saveAsFileButton.setEnabled(True)
self.saveAsFileButton.setIcon(
QgsApplication.getThemeIcon("console/iconSaveAsConsole.png"))
self.saveAsFileButton.setMenuRole(QAction.PreferencesRole)
self.saveAsFileButton.setIconVisibleInMenu(True)
self.saveAsFileButton.setToolTip(saveAsFileBt)
self.saveAsFileButton.setText(saveAsFileBt)
# Action Cut
cutEditorBt = QCoreApplication.translate("PythonConsole", "Cut")
self.cutEditorButton = QAction(self)
self.cutEditorButton.setCheckable(False)
self.cutEditorButton.setEnabled(True)
self.cutEditorButton.setIcon(
QgsApplication.getThemeIcon("mActionEditCut.svg"))
self.cutEditorButton.setMenuRole(QAction.PreferencesRole)
self.cutEditorButton.setIconVisibleInMenu(True)
self.cutEditorButton.setToolTip(cutEditorBt)
self.cutEditorButton.setText(cutEditorBt)
# Action Copy
copyEditorBt = QCoreApplication.translate("PythonConsole", "Copy")
self.copyEditorButton = QAction(self)
self.copyEditorButton.setCheckable(False)
self.copyEditorButton.setEnabled(True)
self.copyEditorButton.setIcon(
QgsApplication.getThemeIcon("mActionEditCopy.svg"))
self.copyEditorButton.setMenuRole(QAction.PreferencesRole)
self.copyEditorButton.setIconVisibleInMenu(True)
self.copyEditorButton.setToolTip(copyEditorBt)
self.copyEditorButton.setText(copyEditorBt)
# Action Paste
pasteEditorBt = QCoreApplication.translate("PythonConsole", "Paste")
self.pasteEditorButton = QAction(self)
self.pasteEditorButton.setCheckable(False)
self.pasteEditorButton.setEnabled(True)
self.pasteEditorButton.setIcon(
QgsApplication.getThemeIcon("mActionEditPaste.svg"))
self.pasteEditorButton.setMenuRole(QAction.PreferencesRole)
self.pasteEditorButton.setIconVisibleInMenu(True)
self.pasteEditorButton.setToolTip(pasteEditorBt)
self.pasteEditorButton.setText(pasteEditorBt)
# Action Run Script (subprocess)
runScriptEditorBt = QCoreApplication.translate("PythonConsole",
"Run script")
self.runScriptEditorButton = QAction(self)
self.runScriptEditorButton.setCheckable(False)
self.runScriptEditorButton.setEnabled(True)
self.runScriptEditorButton.setIcon(
QgsApplication.getThemeIcon("console/iconRunScriptConsole.png"))
self.runScriptEditorButton.setMenuRole(QAction.PreferencesRole)
self.runScriptEditorButton.setIconVisibleInMenu(True)
self.runScriptEditorButton.setToolTip(runScriptEditorBt)
self.runScriptEditorButton.setText(runScriptEditorBt)
# Action Run Script (subprocess)
commentEditorBt = QCoreApplication.translate("PythonConsole",
"Comment")
self.commentEditorButton = QAction(self)
self.commentEditorButton.setCheckable(False)
self.commentEditorButton.setEnabled(True)
self.commentEditorButton.setIcon(
QgsApplication.getThemeIcon(
"console/iconCommentEditorConsole.png"))
self.commentEditorButton.setMenuRole(QAction.PreferencesRole)
self.commentEditorButton.setIconVisibleInMenu(True)
self.commentEditorButton.setToolTip(commentEditorBt)
self.commentEditorButton.setText(commentEditorBt)
# Action Run Script (subprocess)
uncommentEditorBt = QCoreApplication.translate("PythonConsole",
"Uncomment")
self.uncommentEditorButton = QAction(self)
self.uncommentEditorButton.setCheckable(False)
self.uncommentEditorButton.setEnabled(True)
self.uncommentEditorButton.setIcon(
QgsApplication.getThemeIcon(
"console/iconUncommentEditorConsole.png"))
self.uncommentEditorButton.setMenuRole(QAction.PreferencesRole)
self.uncommentEditorButton.setIconVisibleInMenu(True)
self.uncommentEditorButton.setToolTip(uncommentEditorBt)
self.uncommentEditorButton.setText(uncommentEditorBt)
# Action for Object browser
objList = QCoreApplication.translate("PythonConsole",
"Object Inspector...")
self.objectListButton = QAction(self)
self.objectListButton.setCheckable(True)
self.objectListButton.setEnabled(
self.settings.value("pythonConsole/enableObjectInsp",
False,
type=bool))
self.objectListButton.setIcon(
QgsApplication.getThemeIcon("console/iconClassBrowserConsole.png"))
self.objectListButton.setMenuRole(QAction.PreferencesRole)
self.objectListButton.setIconVisibleInMenu(True)
self.objectListButton.setToolTip(objList)
self.objectListButton.setText(objList)
# Action for Find text
findText = QCoreApplication.translate("PythonConsole", "Find Text")
self.findTextButton = QAction(self)
self.findTextButton.setCheckable(True)
self.findTextButton.setEnabled(True)
self.findTextButton.setIcon(
QgsApplication.getThemeIcon("console/iconSearchEditorConsole.png"))
self.findTextButton.setMenuRole(QAction.PreferencesRole)
self.findTextButton.setIconVisibleInMenu(True)
self.findTextButton.setToolTip(findText)
self.findTextButton.setText(findText)
# ----------------Toolbar Console-------------------------------------
# Action Show Editor
showEditor = QCoreApplication.translate("PythonConsole", "Show Editor")
self.showEditorButton = QAction(self)
self.showEditorButton.setEnabled(True)
self.showEditorButton.setCheckable(True)
self.showEditorButton.setIcon(
QgsApplication.getThemeIcon("console/iconShowEditorConsole.png"))
self.showEditorButton.setMenuRole(QAction.PreferencesRole)
self.showEditorButton.setIconVisibleInMenu(True)
self.showEditorButton.setToolTip(showEditor)
self.showEditorButton.setText(showEditor)
# Action for Clear button
clearBt = QCoreApplication.translate("PythonConsole", "Clear Console")
self.clearButton = QAction(self)
self.clearButton.setCheckable(False)
self.clearButton.setEnabled(True)
self.clearButton.setIcon(
QgsApplication.getThemeIcon("console/iconClearConsole.png"))
self.clearButton.setMenuRole(QAction.PreferencesRole)
self.clearButton.setIconVisibleInMenu(True)
self.clearButton.setToolTip(clearBt)
self.clearButton.setText(clearBt)
# Action for settings
optionsBt = QCoreApplication.translate("PythonConsole", "Options...")
self.optionsButton = QAction(self)
self.optionsButton.setCheckable(False)
self.optionsButton.setEnabled(True)
self.optionsButton.setIcon(
QgsApplication.getThemeIcon("console/iconSettingsConsole.png"))
self.optionsButton.setMenuRole(QAction.PreferencesRole)
self.optionsButton.setIconVisibleInMenu(True)
self.optionsButton.setToolTip(optionsBt)
self.optionsButton.setText(optionsBt)
# Action for Run script
runBt = QCoreApplication.translate("PythonConsole", "Run Command")
self.runButton = QAction(self)
self.runButton.setCheckable(False)
self.runButton.setEnabled(True)
self.runButton.setIcon(
QgsApplication.getThemeIcon("console/iconRunConsole.png"))
self.runButton.setMenuRole(QAction.PreferencesRole)
self.runButton.setIconVisibleInMenu(True)
self.runButton.setToolTip(runBt)
self.runButton.setText(runBt)
# Help action
helpBt = QCoreApplication.translate("PythonConsole", "Help...")
self.helpButton = QAction(self)
self.helpButton.setCheckable(False)
self.helpButton.setEnabled(True)
self.helpButton.setIcon(
QgsApplication.getThemeIcon("console/iconHelpConsole.png"))
self.helpButton.setMenuRole(QAction.PreferencesRole)
self.helpButton.setIconVisibleInMenu(True)
self.helpButton.setToolTip(helpBt)
self.helpButton.setText(helpBt)
self.toolBar = QToolBar()
self.toolBar.setEnabled(True)
self.toolBar.setFocusPolicy(Qt.NoFocus)
self.toolBar.setContextMenuPolicy(Qt.DefaultContextMenu)
self.toolBar.setLayoutDirection(Qt.LeftToRight)
self.toolBar.setIconSize(icon_size)
self.toolBar.setMovable(False)
self.toolBar.setFloatable(False)
self.toolBar.addAction(self.clearButton)
self.toolBar.addAction(self.runButton)
self.toolBar.addSeparator()
self.toolBar.addAction(self.showEditorButton)
self.toolBar.addSeparator()
self.toolBar.addAction(self.optionsButton)
self.toolBar.addAction(self.helpButton)
self.toolBarEditor = QToolBar()
self.toolBarEditor.setEnabled(False)
self.toolBarEditor.setFocusPolicy(Qt.NoFocus)
self.toolBarEditor.setContextMenuPolicy(Qt.DefaultContextMenu)
self.toolBarEditor.setLayoutDirection(Qt.LeftToRight)
self.toolBarEditor.setIconSize(icon_size)
self.toolBarEditor.setMovable(False)
self.toolBarEditor.setFloatable(False)
self.toolBarEditor.addAction(self.openFileButton)
self.toolBarEditor.addAction(self.openInEditorButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.saveFileButton)
self.toolBarEditor.addAction(self.saveAsFileButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.runScriptEditorButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.findTextButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.cutEditorButton)
self.toolBarEditor.addAction(self.copyEditorButton)
self.toolBarEditor.addAction(self.pasteEditorButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.commentEditorButton)
self.toolBarEditor.addAction(self.uncommentEditorButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.objectListButton)
self.widgetButton = QWidget()
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.widgetButton.sizePolicy().hasHeightForWidth())
self.widgetButton.setSizePolicy(sizePolicy)
self.widgetButtonEditor = QWidget(self.widgetEditor)
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.widgetButtonEditor.sizePolicy().hasHeightForWidth())
self.widgetButtonEditor.setSizePolicy(sizePolicy)
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.shellOut.sizePolicy().hasHeightForWidth())
self.shellOut.setSizePolicy(sizePolicy)
self.shellOut.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.shell.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
# ------------ Layout -------------------------------
self.mainLayout = QGridLayout(self)
self.mainLayout.setMargin(0)
self.mainLayout.setSpacing(0)
self.mainLayout.addWidget(self.widgetButton, 0, 0, 1, 1)
self.mainLayout.addWidget(self.splitterEditor, 0, 1, 1, 1)
self.shellOutWidget.layout().insertWidget(0, self.toolBar)
self.layoutEditor = QGridLayout(self.widgetEditor)
self.layoutEditor.setMargin(0)
self.layoutEditor.setSpacing(0)
self.layoutEditor.addWidget(self.toolBarEditor, 0, 1, 1, 1)
self.layoutEditor.addWidget(self.widgetButtonEditor, 1, 0, 2, 1)
self.layoutEditor.addWidget(self.tabEditorWidget, 1, 1, 1, 1)
self.layoutEditor.addWidget(self.widgetFind, 2, 1, 1, 1)
# Layout for the find widget
self.layoutFind = QGridLayout(self.widgetFind)
self.layoutFind.setContentsMargins(0, 0, 0, 0)
self.lineEditFind = QgsFilterLineEdit()
placeHolderTxt = QCoreApplication.translate("PythonConsole",
"Enter text to find...")
self.lineEditFind.setPlaceholderText(placeHolderTxt)
self.findNextButton = QToolButton()
self.findNextButton.setEnabled(False)
toolTipfindNext = QCoreApplication.translate("PythonConsole",
"Find Next")
self.findNextButton.setToolTip(toolTipfindNext)
self.findNextButton.setIcon(
QgsApplication.getThemeIcon(
"console/iconSearchNextEditorConsole.png"))
self.findNextButton.setIconSize(QSize(24, 24))
self.findNextButton.setAutoRaise(True)
self.findPrevButton = QToolButton()
self.findPrevButton.setEnabled(False)
toolTipfindPrev = QCoreApplication.translate("PythonConsole",
"Find Previous")
self.findPrevButton.setToolTip(toolTipfindPrev)
self.findPrevButton.setIcon(
QgsApplication.getThemeIcon(
"console/iconSearchPrevEditorConsole.png"))
self.findPrevButton.setIconSize(QSize(24, 24))
self.findPrevButton.setAutoRaise(True)
self.caseSensitive = QCheckBox()
caseSensTr = QCoreApplication.translate("PythonConsole",
"Case Sensitive")
self.caseSensitive.setText(caseSensTr)
self.wholeWord = QCheckBox()
wholeWordTr = QCoreApplication.translate("PythonConsole", "Whole Word")
self.wholeWord.setText(wholeWordTr)
self.wrapAround = QCheckBox()
self.wrapAround.setChecked(True)
wrapAroundTr = QCoreApplication.translate("PythonConsole",
"Wrap Around")
self.wrapAround.setText(wrapAroundTr)
self.layoutFind.addWidget(self.lineEditFind, 0, 1, 1, 1)
self.layoutFind.addWidget(self.findPrevButton, 0, 2, 1, 1)
self.layoutFind.addWidget(self.findNextButton, 0, 3, 1, 1)
self.layoutFind.addWidget(self.caseSensitive, 0, 4, 1, 1)
self.layoutFind.addWidget(self.wholeWord, 0, 5, 1, 1)
self.layoutFind.addWidget(self.wrapAround, 0, 6, 1, 1)
# ------------ Add first Tab in Editor -------------------------------
# self.tabEditorWidget.newTabEditor(tabName='first', filename=None)
# ------------ Signal -------------------------------
self.findTextButton.triggered.connect(self._toggleFind)
self.objectListButton.toggled.connect(self.toggleObjectListWidget)
self.commentEditorButton.triggered.connect(self.commentCode)
self.uncommentEditorButton.triggered.connect(self.uncommentCode)
self.runScriptEditorButton.triggered.connect(self.runScriptEditor)
self.cutEditorButton.triggered.connect(self.cutEditor)
self.copyEditorButton.triggered.connect(self.copyEditor)
self.pasteEditorButton.triggered.connect(self.pasteEditor)
self.showEditorButton.toggled.connect(self.toggleEditor)
self.clearButton.triggered.connect(self.shellOut.clearConsole)
self.optionsButton.triggered.connect(self.openSettings)
self.runButton.triggered.connect(self.shell.entered)
self.openFileButton.triggered.connect(self.openScriptFile)
self.openInEditorButton.triggered.connect(self.openScriptFileExtEditor)
self.saveFileButton.triggered.connect(self.saveScriptFile)
self.saveAsFileButton.triggered.connect(self.saveAsScriptFile)
self.helpButton.triggered.connect(self.openHelp)
self.listClassMethod.itemClicked.connect(self.onClickGoToLine)
self.lineEditFind.returnPressed.connect(self._findNext)
self.findNextButton.clicked.connect(self._findNext)
self.findPrevButton.clicked.connect(self._findPrev)
self.lineEditFind.textChanged.connect(self._textFindChanged)
self.findScut = QShortcut(QKeySequence.Find, self.widgetEditor)
self.findScut.setContext(Qt.WidgetWithChildrenShortcut)
self.findScut.activated.connect(self._openFind)
self.findNextScut = QShortcut(QKeySequence.FindNext, self.widgetEditor)
self.findNextScut.setContext(Qt.WidgetWithChildrenShortcut)
self.findNextScut.activated.connect(self._findNext)
self.findPreviousScut = QShortcut(QKeySequence.FindPrevious,
self.widgetEditor)
self.findPreviousScut.setContext(Qt.WidgetWithChildrenShortcut)
self.findPreviousScut.activated.connect(self._findPrev)
# Escape on editor hides the find bar
self.findScut = QShortcut(Qt.Key_Escape, self.widgetEditor)
self.findScut.setContext(Qt.WidgetWithChildrenShortcut)
self.findScut.activated.connect(self._closeFind)
def _toggleFind(self):
self.tabEditorWidget.currentWidget().newEditor.toggleFindWidget()
def _openFind(self):
self.tabEditorWidget.currentWidget().newEditor.openFindWidget()
def _closeFind(self):
self.tabEditorWidget.currentWidget().newEditor.closeFindWidget()
def _findNext(self):
self.tabEditorWidget.currentWidget().newEditor.findText(True)
def _findPrev(self):
self.tabEditorWidget.currentWidget().newEditor.findText(False)
def _textFindChanged(self):
if self.lineEditFind.text():
self.findNextButton.setEnabled(True)
self.findPrevButton.setEnabled(True)
self.tabEditorWidget.currentWidget().newEditor.findText(
True, showMessage=False, findFirst=True)
else:
self.lineEditFind.setStyleSheet('')
self.findNextButton.setEnabled(False)
self.findPrevButton.setEnabled(False)
def onClickGoToLine(self, item, column):
tabEditor = self.tabEditorWidget.currentWidget().newEditor
if item.text(1) == 'syntaxError':
check = tabEditor.syntaxCheck(fromContextMenu=False)
if check and not tabEditor.isReadOnly():
self.tabEditorWidget.currentWidget().save()
return
linenr = int(item.text(1))
itemName = str(item.text(0))
charPos = itemName.find(' ')
if charPos != -1:
objName = itemName[0:charPos]
else:
objName = itemName
tabEditor.goToLine(objName, linenr)
def toggleEditor(self, checked):
self.splitterObj.show() if checked else self.splitterObj.hide()
if not self.tabEditorWidget:
self.tabEditorWidget.enableToolBarEditor(checked)
self.tabEditorWidget.restoreTabsOrAddNew()
def toggleObjectListWidget(self, checked):
self.listClassMethod.show() if checked else self.listClassMethod.hide()
def pasteEditor(self):
self.tabEditorWidget.currentWidget().newEditor.paste()
def cutEditor(self):
self.tabEditorWidget.currentWidget().newEditor.cut()
def copyEditor(self):
self.tabEditorWidget.currentWidget().newEditor.copy()
def runScriptEditor(self):
self.tabEditorWidget.currentWidget().newEditor.runScriptCode()
def commentCode(self):
self.tabEditorWidget.currentWidget().newEditor.commentEditorCode(True)
def uncommentCode(self):
self.tabEditorWidget.currentWidget().newEditor.commentEditorCode(False)
def openScriptFileExtEditor(self):
tabWidget = self.tabEditorWidget.currentWidget()
path = tabWidget.path
import subprocess
try:
subprocess.Popen([os.environ['EDITOR'], path])
except KeyError:
QDesktopServices.openUrl(QUrl.fromLocalFile(path))
def openScriptFile(self):
lastDirPath = self.settings.value("pythonConsole/lastDirPath",
QDir.homePath())
openFileTr = QCoreApplication.translate("PythonConsole", "Open File")
fileList, selected_filter = QFileDialog.getOpenFileNames(
self, openFileTr, lastDirPath, "Script file (*.py)")
if fileList:
for pyFile in fileList:
for i in range(self.tabEditorWidget.count()):
tabWidget = self.tabEditorWidget.widget(i)
if tabWidget.path == pyFile:
self.tabEditorWidget.setCurrentWidget(tabWidget)
break
else:
tabName = QFileInfo(pyFile).fileName()
self.tabEditorWidget.newTabEditor(tabName, pyFile)
lastDirPath = QFileInfo(pyFile).path()
self.settings.setValue("pythonConsole/lastDirPath", pyFile)
self.updateTabListScript(pyFile, action='append')
def saveScriptFile(self):
tabWidget = self.tabEditorWidget.currentWidget()
try:
tabWidget.save()
except (IOError, OSError) as error:
msgText = QCoreApplication.translate(
'PythonConsole',
'The file <b>{0}</b> could not be saved. Error: {1}').format(
tabWidget.path, error.strerror)
self.callWidgetMessageBarEditor(msgText, 2, False)
def saveAsScriptFile(self, index=None):
tabWidget = self.tabEditorWidget.currentWidget()
if not index:
index = self.tabEditorWidget.currentIndex()
if not tabWidget.path:
fileName = self.tabEditorWidget.tabText(index) + '.py'
folder = self.settings.value("pythonConsole/lastDirPath",
QDir.home())
pathFileName = os.path.join(folder, fileName)
fileNone = True
else:
pathFileName = tabWidget.path
fileNone = False
saveAsFileTr = QCoreApplication.translate("PythonConsole",
"Save File As")
filename, filter = QFileDialog.getSaveFileName(self, saveAsFileTr,
pathFileName,
"Script file (*.py)")
if filename:
try:
tabWidget.save(filename)
except (IOError, OSError) as error:
msgText = QCoreApplication.translate(
'PythonConsole',
'The file <b>{0}</b> could not be saved. Error: {1}'
).format(tabWidget.path, error.strerror)
self.callWidgetMessageBarEditor(msgText, 2, False)
if fileNone:
tabWidget.path = None
else:
tabWidget.path = pathFileName
return
if not fileNone:
self.updateTabListScript(pathFileName, action='remove')
def openHelp(self):
QgsHelp.openHelp("plugins/python_console.html")
def openSettings(self):
if optionsDialog(self).exec_():
self.shell.refreshSettingsShell()
self.shellOut.refreshSettingsOutput()
self.tabEditorWidget.refreshSettingsEditor()
def callWidgetMessageBar(self, text):
self.shellOut.widgetMessageBar(iface, text)
def callWidgetMessageBarEditor(self, text, level, timed):
self.tabEditorWidget.widgetMessageBar(iface, text, level, timed)
def updateTabListScript(self, script, action=None):
if action == 'remove':
self.tabListScript.remove(script)
elif action == 'append':
if not self.tabListScript:
self.tabListScript = []
if script not in self.tabListScript:
self.tabListScript.append(script)
else:
self.tabListScript = []
self.settings.setValue("pythonConsole/tabScripts", self.tabListScript)
def saveSettingsConsole(self):
self.settings.setValue("pythonConsole/splitterConsole",
self.splitter.saveState())
self.settings.setValue("pythonConsole/splitterObj",
self.splitterObj.saveState())
self.settings.setValue("pythonConsole/splitterEditor",
self.splitterEditor.saveState())
self.shell.writeHistoryFile(True)
def restoreSettingsConsole(self):
storedTabScripts = self.settings.value("pythonConsole/tabScripts", [])
self.tabListScript = storedTabScripts
self.splitter.restoreState(
self.settings.value("pythonConsole/splitterConsole", QByteArray()))
self.splitterEditor.restoreState(
self.settings.value("pythonConsole/splitterEditor", QByteArray()))
self.splitterObj.restoreState(
self.settings.value("pythonConsole/splitterObj", QByteArray()))
class PositionDisplay(QWidget):
'''
Widget to display the mouse position on the canvas in geographic coordinates (lat/lon)
The display format can be altered.
'''
__FORMATS = ('DD', 'DDM', 'DMDS')
exportPosition = pyqtSignal(str)
def __init__(self, iface, parent=None):
'''Constructor
:param iface: An interface instance that will be passed to this class
which provides the hook by which you can manipulate the QGIS
application at run time.
:type iface: QgsInterface
'''
super(PositionDisplay, self).__init__(parent)
self.setObjectName('positionDisplay')
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 3, 0)
self.button = QToolButton(self)
self.button.setObjectName('toolButtonFormat')
self.button.clicked.connect(self.switchCoordinateFormat)
self.button.setAutoRaise(True)
layout.addWidget(self.button)
self.label = QLineEdit('--- ---')
self.label.setReadOnly(True)
self.label.setAlignment(Qt.AlignHCenter)
self.label.setStyleSheet('font-weight: bold;')
layout.addWidget(self.label)
self.setLayout(layout)
s = QSettings()
self.format = s.value('PosiView/PositionDisplay/Format', defaultValue=1, type=int)
self.button.setText(self.__FORMATS[self.format])
canvas = iface.mapCanvas()
crsDest = QgsCoordinateReferenceSystem('EPSG:4326')
crsSrc = canvas.mapSettings().destinationCrs()
self.xform = QgsCoordinateTransform(crsSrc, crsDest, QgsProject.instance())
canvas.xyCoordinates.connect(self.mouseMoved)
canvas.destinationCrsChanged.connect(self.mapCrsHasChanged)
self.canvas = canvas
@pyqtSlot(name='on_toolButtonFormat_clicked')
def switchCoordinateFormat(self):
self.format = (self.format + 1) % 3
self.button.setText(self.tr(self.__FORMATS[self.format]))
s = QSettings()
s.setValue('PosiView/PositionDisplay/Format', self.format)
@pyqtSlot()
def mapCrsHasChanged(self):
crsSrc = self.canvas.mapSettings().destinationCrs()
self.xform.setSourceCrs(crsSrc)
@pyqtSlot(QgsPointXY)
def mouseMoved(self, point):
pt = self.xform.transform(point)
pos = self.posToStr(pt)
self.label.setText(pos)
self.exportPosition.emit(pos)
def posToStr(self, pos):
if self.format == 0:
return '{:.6f}, {:.6f}'.format(pos.y(), pos.x())
if self.format == 1:
return ', '.join(QgsCoordinateFormatter.format(pos, QgsCoordinateFormatter.FormatDegreesMinutes, 4).rsplit(',')[::-1])
if self.format == 2:
return ', '.join(QgsCoordinateFormatter.format(pos, QgsCoordinateFormatter.FormatDegreesMinutesSeconds, 2).rsplit(',')[::-1])
class MapWidget(Ui_CanvasWidget, QMainWindow):
def __init__(self, parent=None):
super(MapWidget, self).__init__(parent)
self.setupUi(self)
self.snapping = True
icon = roam_style.iconsize()
self.projecttoolbar.setIconSize(QSize(icon, icon))
self.defaultextent = None
self.current_form = None
self.last_form = None
self.layerbuttons = []
self.editfeaturestack = []
self.lastgpsposition = None
self.project = None
self.gps = None
self.gpslogging = None
self.selectionbands = defaultdict(partial(QgsRubberBand, self.canvas))
self.bridge = QgsLayerTreeMapCanvasBridge(
QgsProject.instance().layerTreeRoot(), self.canvas)
self.bridge.setAutoSetupOnFirstLayer(False)
self.canvas.setCanvasColor(Qt.white)
self.canvas.enableAntiAliasing(True)
self.snappingutils = SnappingUtils(self.canvas, self)
self.canvas.setSnappingUtils(self.snappingutils)
threadcount = QThread.idealThreadCount()
threadcount = 2 if threadcount > 2 else 1
QgsApplication.setMaxThreads(threadcount)
self.canvas.setParallelRenderingEnabled(True)
self.canvas.setFrameStyle(QFrame.NoFrame)
self.editgroup = QActionGroup(self)
self.editgroup.setExclusive(True)
self.editgroup.addAction(self.actionPan)
self.editgroup.addAction(self.actionZoom_In)
self.editgroup.addAction(self.actionZoom_Out)
self.editgroup.addAction(self.actionInfo)
self.actionGPS = GPSAction(self.canvas, self)
self.projecttoolbar.addAction(self.actionGPS)
if roam.config.settings.get('north_arrow', False):
self.northarrow = NorthArrow(":/icons/north", self.canvas)
self.northarrow.setPos(10, 10)
self.canvas.scene().addItem(self.northarrow)
smallmode = roam.config.settings.get("smallmode", False)
self.projecttoolbar.setSmallMode(smallmode)
self.projecttoolbar.setContextMenuPolicy(Qt.CustomContextMenu)
gpsspacewidget = QWidget()
gpsspacewidget.setMinimumWidth(30)
gpsspacewidget.setSizePolicy(QSizePolicy.Expanding,
QSizePolicy.Expanding)
self.topspaceraction = self.projecttoolbar.insertWidget(
self.actionGPS, gpsspacewidget)
self.dataentryselection = QAction(self.projecttoolbar)
self.dataentryaction = self.projecttoolbar.insertAction(
self.topspaceraction, self.dataentryselection)
self.dataentryselection.triggered.connect(self.select_data_entry)
self.gpsMarker = GPSMarker(self.canvas)
self.gpsMarker.hide()
self.currentfeatureband = CurrentSelection(self.canvas)
self.currentfeatureband.setIconSize(30)
self.currentfeatureband.setWidth(10)
self.currentfeatureband.setColor(QColor(88, 64, 173, 50))
self.currentfeatureband.setOutlineColour(QColor(88, 64, 173))
self.gpsband = QgsRubberBand(self.canvas)
self.gpsband.setColor(QColor(165, 111, 212, 75))
self.gpsband.setWidth(5)
RoamEvents.refresh_map.connect(self.refresh_map)
RoamEvents.editgeometry.connect(self.queue_feature_for_edit)
RoamEvents.selectioncleared.connect(self.clear_selection)
RoamEvents.selectionchanged.connect(self.highlight_selection)
RoamEvents.openfeatureform.connect(self.feature_form_loaded)
RoamEvents.sync_complete.connect(self.refresh_map)
RoamEvents.snappingChanged.connect(self.snapping_changed)
self.snappingbutton = QToolButton()
self.snappingbutton.setText("Snapping: On")
self.snappingbutton.setAutoRaise(True)
self.snappingbutton.pressed.connect(self.toggle_snapping)
spacer = QWidget()
spacer2 = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
spacer2.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.scalewidget = QgsScaleComboBox()
self.scalebutton = QToolButton()
self.scalebutton.setAutoRaise(True)
self.scalebutton.setMaximumHeight(self.statusbar.height())
self.scalebutton.pressed.connect(self.selectscale)
self.scalebutton.setText("Scale")
self.scalelist = BigList(parent=self.canvas,
centeronparent=True,
showsave=False)
self.scalelist.hide()
self.scalelist.setlabel("Map Scale")
self.scalelist.setmodel(self.scalewidget.model())
self.scalelist.closewidget.connect(self.scalelist.close)
self.scalelist.itemselected.connect(self.update_scale_from_item)
self.scalelist.itemselected.connect(self.scalelist.close)
self.positionlabel = QLabel('')
self.gpslabel = QLabel("GPS: Not active")
self.gpslabelposition = QLabel("")
self.statusbar.addWidget(self.snappingbutton)
self.statusbar.addWidget(spacer2)
self.statusbar.addWidget(self.gpslabel)
self.statusbar.addWidget(self.gpslabelposition)
self.statusbar.addPermanentWidget(self.scalebutton)
self.canvas.extentsChanged.connect(self.update_status_label)
self.canvas.scaleChanged.connect(self.update_status_label)
self.connectButtons()
scalebar_enabled = roam.config.settings.get('scale_bar', False)
self.scalebar_enabled = False
if scalebar_enabled:
roam.utils.warning(
"Unsupported feature: Scale bar support not ported to QGIS 3 API yet."
)
RoamEvents.raisemessage(
"Unsupported feature",
"Scale bar support not ported to QGIS 3 API yet",
level=RoamEvents.CRITICAL)
self.scalebar_enabled = False
# self.scalebar = ScaleBarItem(self.canvas)
# self.canvas.scene().addItem(self.scalebar)
def clear_plugins(self) -> None:
"""
Clear all the plugin added toolbars from the map interface.
"""
toolbars = self.findChildren(QToolBar)
for toolbar in toolbars:
if toolbar.property("plugin_toolbar"):
toolbar.unload()
self.removeToolBar(toolbar)
toolbar.deleteLater()
def add_plugins(self, pluginnames) -> None:
"""
Add the given plugins to to the mapping interface.
Adds the toolbars the plugin exposes as new toolbars for the user.
:param pluginnames: The names of the plugins to load. Must already be loaded
by the plugin loader
"""
for name in pluginnames:
# Get the plugin
try:
plugin_mod = plugins.loaded_plugins[name]
except KeyError:
continue
if not hasattr(plugin_mod, 'toolbars'):
roam.utils.warning(
"No toolbars() function found in {}".format(name))
continue
toolbars = plugin_mod.toolbars()
self.load_plugin_toolbars(toolbars)
def load_plugin_toolbars(self, toolbars):
"""
Load the plugin toolbars into the mapping interface.
:param toolbars: The list of toolbars class objects to load.
:return:
"""
for ToolBarClass in toolbars:
toolbar = ToolBarClass(plugins.api, self)
self.addToolBar(Qt.BottomToolBarArea, toolbar)
toolbar.setProperty("plugin_toolbar", True)
def snapping_changed(self, snapping):
"""
Called when the snapping settings have changed. Updates the label in the status bar.
:param snapping:
"""
self.snapping = snapping
if snapping:
self.snappingbutton.setText("Snapping: On")
else:
self.snappingbutton.setText("Snapping: Off")
def toggle_snapping(self):
"""
Toggle snapping on or off.
"""
self.snapping = not self.snapping
try:
self.canvas.mapTool().toggle_snapping()
except AttributeError:
pass
RoamEvents.snappingChanged.emit(self.snapping)
def selectscale(self):
"""
Show the select scale widget.
:return:
"""
self.scalelist.show()
def update_scale_from_item(self, index):
"""
Update the canvas scale from the selected scale item.
:param index: The index of the selected item.
"""
scale, _ = self.scalewidget.toDouble(index.data(Qt.DisplayRole))
self.canvas.zoomScale(1.0 / scale)
def update_gps_fixed_label(self, fixed, gpsinfo):
if not fixed:
self.gpslabel.setText("GPS: Acquiring fix")
self.gpslabelposition.setText("")
quality_mappings = {
0: "invalid",
1: "GPS",
2: "DGPS",
3: "PPS",
4: "Real Time Kinematic",
5: "Float RTK",
6: "Estimated",
7: "Manual input mode",
8: "Simulation mode"
}
def update_gps_label(self, position, gpsinfo):
"""
Update the GPS label in the status bar with the GPS status.
:param position: The current GPS position.
:param gpsinfo: The current extra GPS information.
"""
if not self.gps.connected:
return
fixtype = self.quality_mappings.get(gpsinfo.quality, "")
self.gpslabel.setText(
"DOP P:<b>{0:.2f}</b> H:<b>{1:.2f}</b> V:<b>{2:.2f}</b> "
"Fix: <b>{3}</b> "
"Sats: <b>{4}</b> ".format(gpsinfo.pdop, gpsinfo.hdop,
gpsinfo.vdop, fixtype,
gpsinfo.satellitesUsed))
places = roam.config.settings.get("gpsplaces", 8)
self.gpslabelposition.setText("X: <b>{x:.{places}f}</b> "
"Y: <b>{y:.{places}f}</b> "
"Z: <b>{z}m</b> ".format(
x=position.x(),
y=position.y(),
z=gpsinfo.elevation,
places=places))
def gps_disconnected(self):
self.gpslabel.setText("GPS: Not Active")
self.gpslabelposition.setText("")
self.gpsMarker.hide()
def zoom_to_feature(self, feature):
"""
Zoom to the given feature in the map.
:param feature:
:return:
"""
box = feature.geometry().boundingBox()
xmin, xmax, ymin, ymax = box.xMinimum(), box.xMaximum(), box.yMinimum(
), box.yMaximum()
xmin -= 5
xmax += 5
ymin -= 5
ymax += 5
box = QgsRectangle(xmin, ymin, xmax, ymax)
self.canvas.setExtent(box)
self.canvas.refresh()
def update_status_label(self, *args) -> None:
"""
Update the status bar labels when the information has changed.
"""
extent = self.canvas.extent()
self.positionlabel.setText("Map Center: {}".format(
extent.center().toString()))
scale = 1.0 / self.canvas.scale()
scale = self.scalewidget.toString(scale)
self.scalebutton.setText(scale)
def refresh_map(self) -> None:
"""
Refresh the map
"""
self.canvas.refresh()
def updatescale(self) -> None:
"""
Update the scale of the map with the current scale from the scale widget
:return:
"""
self.canvas.zoomScale(1.0 / self.scalewidget.scale())
@property
def crs(self) -> QgsCoordinateReferenceSystem:
"""
Get the CRS used that is being used in the canvas
:return: The QgsCoordinateReferenceSystem that is used by the canvas
"""
return self.canvas.mapSettings().destinationCrs()
def feature_form_loaded(self, form, feature, *args):
"""
Called when the feature form is loaded.
:param form: The Form object. Holds a reference to the forms layer.
:param feature: The current capture feature
"""
self.currentfeatureband.setToGeometry(feature.geometry(),
form.QGISLayer)
def highlight_selection(self, results):
"""
Highlight the selection on the canvas. This updates all selected objects based on the result set.
:param results: A dict-of-list of layer-features.
"""
self.clear_selection()
for layer, features in results.items():
band = self.selectionbands[layer]
band.setColor(QColor(255, 0, 0))
band.setIconSize(25)
band.setWidth(5)
band.setBrushStyle(Qt.NoBrush)
band.reset(layer.geometryType())
band.setZValue(self.currentfeatureband.zValue() - 1)
for feature in features:
band.addGeometry(feature.geometry(), layer)
self.canvas.update()
def highlight_active_selection(self, layer, feature, features):
"""
Update the current active selected feature.
:param layer: The layer of the active feature.
:param feature: The active feature.
:param features: The other features in the set to show as non active selection.
:return:
"""
self.clear_selection()
self.highlight_selection({layer: features})
self.currentfeatureband.setToGeometry(feature.geometry(), layer)
self.canvas.update()
def clear_selection(self):
"""
Clear the selection from the canvas. Resets all selection rubber bands.
:return:
"""
# Clear the main selection rubber band
self.canvas.scene().update()
self.currentfeatureband.reset()
# Clear the rest
for band in self.selectionbands.values():
band.reset()
self.canvas.update()
self.editfeaturestack = []
def queue_feature_for_edit(self, form, feature):
"""
Push a feature on the edit stack so the feature can have the geometry edited.
:note: This is a big hack and I don't like it!
:param form: The form for the current feature
:param feature: The active feature.
"""
def trigger_default_action():
for action in self.projecttoolbar.actions():
if action.property('dataentry') and action.isdefault:
action.trigger()
self.canvas.currentLayer().startEditing()
self.canvas.mapTool().setEditMode(True, feature.geometry(),
feature)
break
self.editfeaturestack.append((form, feature))
self.save_current_form()
self.load_form(form)
trigger_default_action()
def save_current_form(self):
self.last_form = self.current_form
def restore_last_form(self):
self.load_form(self.last_form)
def clear_temp_objects(self):
"""
Clear all temp objects from the canvas.
:return:
"""
def clear_tool_band():
"""
Clear the rubber band of the active tool if it has one
"""
tool = self.canvas.mapTool()
if hasattr(tool, "clearBand"):
tool.clearBand()
self.currentfeatureband.reset()
clear_tool_band()
def settings_updated(self, settings):
"""
Called when the settings have been updated in the Roam config.
:param settings: A dict of the settings.
"""
self.actionGPS.updateGPSPort()
gpslogging = settings.get('gpslogging', True)
if self.gpslogging:
self.gpslogging.logging = gpslogging
smallmode = settings.get("smallmode", False)
self.projecttoolbar.setSmallMode(smallmode)
def set_gps(self, gps, logging):
"""
Set the GPS for the map widget. Connects GPS signals
"""
self.gps = gps
self.gpslogging = logging
self.gps.gpsfixed.connect(self.update_gps_fixed_label)
self.gps.gpsposition.connect(self.update_gps_label)
self.gps.gpsposition.connect(self.gps_update_canvas)
self.gps.firstfix.connect(self.gps_first_fix)
self.gps.gpsdisconnected.connect(self.gps_disconnected)
self.gpsMarker.setgps(self.gps)
self.actionGPS.setgps(gps)
def gps_update_canvas(self, position, gpsinfo):
"""
Updates the map canvas based on the GPS position. By default if the GPS is outside the canvas
extent the canvas will move to center on the GPS. Can be turned off in settings.
:param postion: The current GPS position.
:param gpsinfo: The extra GPS information
"""
# Recenter map if we go outside of the 95% of the area
if self.gpslogging.logging:
self.gpsband.addPoint(position)
self.gpsband.show()
if roam.config.settings.get('gpscenter', True):
if not self.lastgpsposition == position:
self.lastgpsposition = position
rect = QgsRectangle(position, position)
extentlimt = QgsRectangle(self.canvas.extent())
extentlimt.scale(0.95)
if not extentlimt.contains(position):
self.zoom_to_location(position)
self.gpsMarker.show()
self.gpsMarker.setCenter(position, gpsinfo)
def gps_first_fix(self, postion, gpsinfo):
"""
Called the first time the GPS gets a fix. If set this will zoom to the GPS after the first fix
:param postion: The current GPS position.
:param gpsinfo: The extra GPS information
"""
zoomtolocation = roam.config.settings.get('gpszoomonfix', True)
if zoomtolocation:
self.canvas.zoomScale(1000)
self.zoom_to_location(postion)
def zoom_to_location(self, position):
"""
Zoom to ta given position on the map..
"""
rect = QgsRectangle(position, position)
self.canvas.setExtent(rect)
self.canvas.refresh()
def select_data_entry(self):
"""
Open the form selection widget to allow the user to pick the active capture form.
"""
def showformerror(form):
pass
def actions():
for form in self.project.forms:
if not self.form_valid_for_capture(form):
continue
action = form.createuiaction()
valid, failreasons = form.valid
if not valid:
roam.utils.warning("Form {} failed to load".format(
form.label))
roam.utils.warning("Reasons {}".format(failreasons))
action.triggered.connect(partial(showformerror, form))
else:
action.triggered.connect(partial(self.load_form, form))
yield action
formpicker = PickActionDialog(msg="Select data entry form", wrap=5)
formpicker.addactions(actions())
formpicker.exec_()
def project_loaded(self, project):
"""
Called when the project is loaded. Main entry point for a loade project.
:param project: The Roam project that has been loaded.
"""
self.snappingutils.setConfig(QgsProject.instance().snappingConfig())
self.project = project
self.actionPan.trigger()
firstform = self.first_capture_form()
if firstform:
self.load_form(firstform)
self.dataentryselection.setVisible(True)
else:
self.dataentryselection.setVisible(False)
# Enable the raster layers button only if the project contains a raster layer.
layers = roam.api.utils.layers()
hasrasters = any(layer.type() == QgsMapLayer.RasterLayer
for layer in layers)
self.actionRaster.setEnabled(hasrasters)
self.defaultextent = self.canvas.extent()
roam.utils.info("Extent: {}".format(self.defaultextent.toString()))
self.infoTool.selectionlayers = project.selectlayersmapping()
self.canvas.refresh()
projectscales, _ = QgsProject.instance().readBoolEntry(
"Scales", "/useProjectScales")
if projectscales:
projectscales, _ = QgsProject.instance().readListEntry(
"Scales", "/ScalesList")
self.scalewidget.updateScales(projectscales)
else:
scales = [
"1:50000", "1:25000", "1:10000", "1:5000", "1:2500", "1:1000",
"1:500", "1:250", "1:200", "1:100"
]
scales = roam.config.settings.get('scales', scales)
self.scalewidget.updateScales(scales)
if self.scalebar_enabled:
self.scalebar.update()
red = QgsProject.instance().readNumEntry("Gui", "/CanvasColorRedPart",
255)[0]
green = QgsProject.instance().readNumEntry("Gui",
"/CanvasColorGreenPart",
255)[0]
blue = QgsProject.instance().readNumEntry("Gui",
"/CanvasColorBluePart",
255)[0]
myColor = QColor(red, green, blue)
self.canvas.setCanvasColor(myColor)
self.actionPan.toggle()
self.clear_plugins()
self.add_plugins(project.enabled_plugins)
def setMapTool(self, tool, *args):
"""
Set the active map tool in the canvas.
:param tool: The QgsMapTool to set.
"""
if tool == self.canvas.mapTool():
return
if hasattr(tool, "setSnapping"):
tool.setSnapping(self.snapping)
self.canvas.setMapTool(tool)
def connectButtons(self):
"""
Connect the default buttons in the interface. Zoom, pan, etc
"""
def connectAction(action, tool):
action.toggled.connect(partial(self.setMapTool, tool))
def cursor(name):
pix = QPixmap(name)
pix = pix.scaled(QSize(24, 24))
return QCursor(pix)
self.zoomInTool = QgsMapToolZoom(self.canvas, False)
self.zoomOutTool = QgsMapToolZoom(self.canvas, True)
self.panTool = QgsMapToolPan(self.canvas)
self.infoTool = InfoTool(self.canvas)
self.infoTool.setAction(self.actionInfo)
self.zoomInTool.setAction(self.actionZoom_In)
self.zoomOutTool.setAction(self.actionZoom_Out)
self.panTool.setAction(self.actionPan)
connectAction(self.actionZoom_In, self.zoomInTool)
connectAction(self.actionZoom_Out, self.zoomOutTool)
connectAction(self.actionPan, self.panTool)
connectAction(self.actionInfo, self.infoTool)
self.zoomInTool.setCursor(cursor(':/icons/in'))
self.zoomOutTool.setCursor(cursor(':/icons/out'))
self.infoTool.setCursor(cursor(':/icons/select'))
self.actionRaster.triggered.connect(self.toggle_raster_layers)
self.actionHome.triggered.connect(self.homeview)
def homeview(self):
"""
Zoom the mapview canvas to the extents the project was opened at i.e. the
default extent.
"""
if self.defaultextent:
self.canvas.setExtent(self.defaultextent)
self.canvas.refresh()
def form_valid_for_capture(self, form):
"""
Check if the given form is valid for capture.
:param form: The form to check.
:return: True if valid form for capture
"""
return form.has_geometry and self.project.layer_can_capture(
form.QGISLayer)
def first_capture_form(self):
"""
Return the first valid form for capture.
"""
for form in self.project.forms:
if self.form_valid_for_capture(form):
return form
def load_form(self, form):
"""
Load the given form so it's the active one for capture
:param form: The form to load
"""
self.clear_capture_tools()
self.dataentryselection.setIcon(QIcon(form.icon))
self.dataentryselection.setText(form.icontext)
self.create_capture_buttons(form)
self.current_form = form
def create_capture_buttons(self, form):
"""
Create the capture buttons in the toolbar for the given form.
:param form: The active form.
"""
tool = form.getMaptool()(self.canvas, form.settings)
for action in tool.actions:
# Create the action here.
if action.ismaptool:
action.toggled.connect(partial(self.setMapTool, tool))
# Set the action as a data entry button so we can remove it later.
action.setProperty("dataentry", True)
self.editgroup.addAction(action)
self.layerbuttons.append(action)
self.projecttoolbar.insertAction(self.topspaceraction, action)
action.setChecked(action.isdefault)
if hasattr(tool, 'geometryComplete'):
add = partial(self.add_new_feature, form)
tool.geometryComplete.connect(add)
else:
tool.finished.connect(self.openForm)
tool.error.connect(self.show_invalid_geometry_message)
def show_invalid_geometry_message(self, message) -> None:
"""
Shows the message to the user if the there is a invalid geometry capture.
:param message: The message to show the user.
"""
RoamEvents.raisemessage("Invalid geometry capture",
message,
level=RoamEvents.CRITICAL)
if self.canvas.currentLayer() is not None:
self.canvas.currentLayer().rollBack()
RoamEvents.editgeometry_invalid.emit()
def add_new_feature(self, form, geometry: QgsGeometry):
"""
Add a new new feature to the given layer
:param form: The form to use for the new feature.
:param geometry: The new geometry to create the feature for.
"""
# NOTE This function is doing too much, acts as add and also edit.
layer = form.QGISLayer
if geometry.isMultipart():
geometry.convertToMultiType()
# Transform the new geometry back into the map layers geometry if it's needed
transform = self.canvas.mapSettings().layerTransform(layer)
if transform.isValid():
geometry.transform(transform,
QgsCoordinateTransform.ReverseTransform)
try:
form, feature = self.editfeaturestack.pop()
self.editfeaturegeometry(form, feature, newgeometry=geometry)
return
except IndexError:
pass
feature = form.new_feature(geometry=geometry)
RoamEvents.load_feature_form(form, feature, editmode=False)
def editfeaturegeometry(self, form, feature, newgeometry):
# TODO Extract into function.
layer = form.QGISLayer
layer.startEditing()
feature.setGeometry(newgeometry)
layer.updateFeature(feature)
saved = layer.commitChanges()
if not saved:
map(roam.utils.error, layer.commitErrors())
self.canvas.refresh()
self.currentfeatureband.setToGeometry(feature.geometry(), layer)
RoamEvents.editgeometry_complete.emit(form, feature)
self.canvas.mapTool().setEditMode(False, None, None)
self.restore_last_form()
def clear_capture_tools(self):
"""
Clear the capture tools from the toolbar.
:return: True if the capture button was active at the time of clearing.
"""
captureselected = False
for action in self.projecttoolbar.actions():
if action.objectName() == "capture" and action.isChecked():
captureselected = True
if action.property('dataentry'):
self.projecttoolbar.removeAction(action)
return captureselected
def toggle_raster_layers(self) -> None:
"""
Toggle all raster layers on or off.
"""
# Freeze the canvas to save on UI refresh
dlg = PickActionDialog(msg="Raster visibility")
actions = [
(":/icons/raster_0", "Off", partial(self._set_basemaps_opacity,
0), "photo_off"),
(":/icons/raster_25", "25%",
partial(self._set_basemaps_opacity, .25), "photo_25"),
(":/icons/raster_50", "50%",
partial(self._set_basemaps_opacity, .50), "photo_50"),
(":/icons/raster_75", "75%",
partial(self._set_basemaps_opacity, .75), "photo_75"),
(":/icons/raster_100", "100%",
partial(self._set_basemaps_opacity, 1), "photo_100"),
]
# ":/icons/raster_100"), "100%", self, triggered=partial(self._set_raster_layer_value, 1),
# objectName="photo_100")
dialog_actions = []
for action in actions:
icon = QIcon(action[0])
qaction = QAction(icon,
action[1],
self,
triggered=action[2],
objectName=action[3])
dialog_actions.append(qaction)
dlg.addactions(dialog_actions)
dlg.exec_()
def _set_basemaps_opacity(self, value=0) -> None:
"""
Set the opacity for all basemap raster layers.
:param value: The opacity value betwen 0 and 1
"""
tree = QgsProject.instance().layerTreeRoot()
for node in tree.findLayers():
layer = node.layer()
if node.layer().type() == QgsMapLayer.RasterLayer:
if value > 0:
node.setItemVisibilityChecked(Qt.Checked)
renderer = layer.renderer()
renderer.setOpacity(value)
if value == 0:
node.setItemVisibilityChecked(Qt.Unchecked)
self.canvas.refresh()
def cleanup(self):
"""
Clean up when the project has changed.
:return:
"""
# TODO Review cleanup
# self.bridge.clear()
self.gpsband.reset()
self.gpsband.hide()
self.clear_selection()
self.clear_temp_objects()
self.clear_capture_tools()
for action in self.layerbuttons:
self.editgroup.removeAction(action)
class PythonConsoleWidget(QWidget):
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.setWindowTitle(QCoreApplication.translate("PythonConsole", "Python Console"))
self.settings = QgsSettings()
self.shell = ShellScintilla(self)
self.setFocusProxy(self.shell)
self.shellOut = ShellOutputScintilla(self)
self.tabEditorWidget = EditorTabWidget(self)
# ------------ UI -------------------------------
self.splitterEditor = QSplitter(self)
self.splitterEditor.setOrientation(Qt.Horizontal)
self.splitterEditor.setHandleWidth(6)
self.splitterEditor.setChildrenCollapsible(True)
self.shellOutWidget = QWidget(self)
self.shellOutWidget.setLayout(QVBoxLayout())
self.shellOutWidget.layout().setContentsMargins(0, 0, 0, 0)
self.shellOutWidget.layout().addWidget(self.shellOut)
self.splitter = QSplitter(self.splitterEditor)
self.splitter.setOrientation(Qt.Vertical)
self.splitter.setHandleWidth(3)
self.splitter.setChildrenCollapsible(False)
self.splitter.addWidget(self.shellOutWidget)
self.splitter.addWidget(self.shell)
# self.splitterEditor.addWidget(self.tabEditorWidget)
self.splitterObj = QSplitter(self.splitterEditor)
self.splitterObj.setHandleWidth(3)
self.splitterObj.setOrientation(Qt.Horizontal)
# self.splitterObj.setSizes([0, 0])
# self.splitterObj.setStretchFactor(0, 1)
self.widgetEditor = QWidget(self.splitterObj)
self.widgetFind = QWidget(self)
self.listClassMethod = QTreeWidget(self.splitterObj)
self.listClassMethod.setColumnCount(2)
objInspLabel = QCoreApplication.translate("PythonConsole", "Object Inspector")
self.listClassMethod.setHeaderLabels([objInspLabel, ''])
self.listClassMethod.setColumnHidden(1, True)
self.listClassMethod.setAlternatingRowColors(True)
# self.splitterEditor.addWidget(self.widgetEditor)
# self.splitterObj.addWidget(self.listClassMethod)
# self.splitterObj.addWidget(self.widgetEditor)
# Hide side editor on start up
self.splitterObj.hide()
self.listClassMethod.hide()
# Hide search widget on start up
self.widgetFind.hide()
sizes = self.splitter.sizes()
self.splitter.setSizes(sizes)
# ----------------Restore Settings------------------------------------
self.restoreSettingsConsole()
# ------------------Toolbar Editor-------------------------------------
# Action for Open File
openFileBt = QCoreApplication.translate("PythonConsole", "Open Script...")
self.openFileButton = QAction(self)
self.openFileButton.setCheckable(False)
self.openFileButton.setEnabled(True)
self.openFileButton.setIcon(QgsApplication.getThemeIcon("console/iconOpenConsole.png"))
self.openFileButton.setMenuRole(QAction.PreferencesRole)
self.openFileButton.setIconVisibleInMenu(True)
self.openFileButton.setToolTip(openFileBt)
self.openFileButton.setText(openFileBt)
openExtEditorBt = QCoreApplication.translate("PythonConsole", "Open in External Editor")
self.openInEditorButton = QAction(self)
self.openInEditorButton.setCheckable(False)
self.openInEditorButton.setEnabled(True)
self.openInEditorButton.setIcon(QgsApplication.getThemeIcon("console/iconShowEditorConsole.png"))
self.openInEditorButton.setMenuRole(QAction.PreferencesRole)
self.openInEditorButton.setIconVisibleInMenu(True)
self.openInEditorButton.setToolTip(openExtEditorBt)
self.openInEditorButton.setText(openExtEditorBt)
# Action for Save File
saveFileBt = QCoreApplication.translate("PythonConsole", "Save")
self.saveFileButton = QAction(self)
self.saveFileButton.setCheckable(False)
self.saveFileButton.setEnabled(False)
self.saveFileButton.setIcon(QgsApplication.getThemeIcon("console/iconSaveConsole.png"))
self.saveFileButton.setMenuRole(QAction.PreferencesRole)
self.saveFileButton.setIconVisibleInMenu(True)
self.saveFileButton.setToolTip(saveFileBt)
self.saveFileButton.setText(saveFileBt)
# Action for Save File As
saveAsFileBt = QCoreApplication.translate("PythonConsole", "Save As...")
self.saveAsFileButton = QAction(self)
self.saveAsFileButton.setCheckable(False)
self.saveAsFileButton.setEnabled(True)
self.saveAsFileButton.setIcon(QgsApplication.getThemeIcon("console/iconSaveAsConsole.png"))
self.saveAsFileButton.setMenuRole(QAction.PreferencesRole)
self.saveAsFileButton.setIconVisibleInMenu(True)
self.saveAsFileButton.setToolTip(saveAsFileBt)
self.saveAsFileButton.setText(saveAsFileBt)
# Action Cut
cutEditorBt = QCoreApplication.translate("PythonConsole", "Cut")
self.cutEditorButton = QAction(self)
self.cutEditorButton.setCheckable(False)
self.cutEditorButton.setEnabled(True)
self.cutEditorButton.setIcon(QgsApplication.getThemeIcon("mActionEditCut.svg"))
self.cutEditorButton.setMenuRole(QAction.PreferencesRole)
self.cutEditorButton.setIconVisibleInMenu(True)
self.cutEditorButton.setToolTip(cutEditorBt)
self.cutEditorButton.setText(cutEditorBt)
# Action Copy
copyEditorBt = QCoreApplication.translate("PythonConsole", "Copy")
self.copyEditorButton = QAction(self)
self.copyEditorButton.setCheckable(False)
self.copyEditorButton.setEnabled(True)
self.copyEditorButton.setIcon(QgsApplication.getThemeIcon("mActionEditCopy.svg"))
self.copyEditorButton.setMenuRole(QAction.PreferencesRole)
self.copyEditorButton.setIconVisibleInMenu(True)
self.copyEditorButton.setToolTip(copyEditorBt)
self.copyEditorButton.setText(copyEditorBt)
# Action Paste
pasteEditorBt = QCoreApplication.translate("PythonConsole", "Paste")
self.pasteEditorButton = QAction(self)
self.pasteEditorButton.setCheckable(False)
self.pasteEditorButton.setEnabled(True)
self.pasteEditorButton.setIcon(QgsApplication.getThemeIcon("mActionEditPaste.svg"))
self.pasteEditorButton.setMenuRole(QAction.PreferencesRole)
self.pasteEditorButton.setIconVisibleInMenu(True)
self.pasteEditorButton.setToolTip(pasteEditorBt)
self.pasteEditorButton.setText(pasteEditorBt)
# Action Run Script (subprocess)
runScriptEditorBt = QCoreApplication.translate("PythonConsole", "Run script")
self.runScriptEditorButton = QAction(self)
self.runScriptEditorButton.setCheckable(False)
self.runScriptEditorButton.setEnabled(True)
self.runScriptEditorButton.setIcon(QgsApplication.getThemeIcon("console/iconRunScriptConsole.png"))
self.runScriptEditorButton.setMenuRole(QAction.PreferencesRole)
self.runScriptEditorButton.setIconVisibleInMenu(True)
self.runScriptEditorButton.setToolTip(runScriptEditorBt)
self.runScriptEditorButton.setText(runScriptEditorBt)
# Action Run Script (subprocess)
commentEditorBt = QCoreApplication.translate("PythonConsole", "Comment")
self.commentEditorButton = QAction(self)
self.commentEditorButton.setCheckable(False)
self.commentEditorButton.setEnabled(True)
self.commentEditorButton.setIcon(QgsApplication.getThemeIcon("console/iconCommentEditorConsole.png"))
self.commentEditorButton.setMenuRole(QAction.PreferencesRole)
self.commentEditorButton.setIconVisibleInMenu(True)
self.commentEditorButton.setToolTip(commentEditorBt)
self.commentEditorButton.setText(commentEditorBt)
# Action Run Script (subprocess)
uncommentEditorBt = QCoreApplication.translate("PythonConsole", "Uncomment")
self.uncommentEditorButton = QAction(self)
self.uncommentEditorButton.setCheckable(False)
self.uncommentEditorButton.setEnabled(True)
self.uncommentEditorButton.setIcon(QgsApplication.getThemeIcon("console/iconUncommentEditorConsole.png"))
self.uncommentEditorButton.setMenuRole(QAction.PreferencesRole)
self.uncommentEditorButton.setIconVisibleInMenu(True)
self.uncommentEditorButton.setToolTip(uncommentEditorBt)
self.uncommentEditorButton.setText(uncommentEditorBt)
# Action for Object browser
objList = QCoreApplication.translate("PythonConsole", "Object Inspector...")
self.objectListButton = QAction(self)
self.objectListButton.setCheckable(True)
self.objectListButton.setEnabled(self.settings.value("pythonConsole/enableObjectInsp",
False, type=bool))
self.objectListButton.setIcon(QgsApplication.getThemeIcon("console/iconClassBrowserConsole.png"))
self.objectListButton.setMenuRole(QAction.PreferencesRole)
self.objectListButton.setIconVisibleInMenu(True)
self.objectListButton.setToolTip(objList)
self.objectListButton.setText(objList)
# Action for Find text
findText = QCoreApplication.translate("PythonConsole", "Find Text")
self.findTextButton = QAction(self)
self.findTextButton.setCheckable(True)
self.findTextButton.setEnabled(True)
self.findTextButton.setIcon(QgsApplication.getThemeIcon("console/iconSearchEditorConsole.png"))
self.findTextButton.setMenuRole(QAction.PreferencesRole)
self.findTextButton.setIconVisibleInMenu(True)
self.findTextButton.setToolTip(findText)
self.findTextButton.setText(findText)
# ----------------Toolbar Console-------------------------------------
# Action Show Editor
showEditor = QCoreApplication.translate("PythonConsole", "Show Editor")
self.showEditorButton = QAction(self)
self.showEditorButton.setEnabled(True)
self.showEditorButton.setCheckable(True)
self.showEditorButton.setIcon(QgsApplication.getThemeIcon("console/iconShowEditorConsole.png"))
self.showEditorButton.setMenuRole(QAction.PreferencesRole)
self.showEditorButton.setIconVisibleInMenu(True)
self.showEditorButton.setToolTip(showEditor)
self.showEditorButton.setText(showEditor)
# Action for Clear button
clearBt = QCoreApplication.translate("PythonConsole", "Clear Console")
self.clearButton = QAction(self)
self.clearButton.setCheckable(False)
self.clearButton.setEnabled(True)
self.clearButton.setIcon(QgsApplication.getThemeIcon("console/iconClearConsole.png"))
self.clearButton.setMenuRole(QAction.PreferencesRole)
self.clearButton.setIconVisibleInMenu(True)
self.clearButton.setToolTip(clearBt)
self.clearButton.setText(clearBt)
# Action for settings
optionsBt = QCoreApplication.translate("PythonConsole", "Options...")
self.optionsButton = QAction(self)
self.optionsButton.setCheckable(False)
self.optionsButton.setEnabled(True)
self.optionsButton.setIcon(QgsApplication.getThemeIcon("console/iconSettingsConsole.png"))
self.optionsButton.setMenuRole(QAction.PreferencesRole)
self.optionsButton.setIconVisibleInMenu(True)
self.optionsButton.setToolTip(optionsBt)
self.optionsButton.setText(optionsBt)
# Action menu for class
actionClassBt = QCoreApplication.translate("PythonConsole", "Import Class")
self.actionClass = QAction(self)
self.actionClass.setCheckable(False)
self.actionClass.setEnabled(True)
self.actionClass.setIcon(QgsApplication.getThemeIcon("console/iconClassConsole.png"))
self.actionClass.setMenuRole(QAction.PreferencesRole)
self.actionClass.setIconVisibleInMenu(True)
self.actionClass.setToolTip(actionClassBt)
self.actionClass.setText(actionClassBt)
# Action for Run script
runBt = QCoreApplication.translate("PythonConsole", "Run Command")
self.runButton = QAction(self)
self.runButton.setCheckable(False)
self.runButton.setEnabled(True)
self.runButton.setIcon(QgsApplication.getThemeIcon("console/iconRunConsole.png"))
self.runButton.setMenuRole(QAction.PreferencesRole)
self.runButton.setIconVisibleInMenu(True)
self.runButton.setToolTip(runBt)
self.runButton.setText(runBt)
# Help action
helpBt = QCoreApplication.translate("PythonConsole", "Help...")
self.helpButton = QAction(self)
self.helpButton.setCheckable(False)
self.helpButton.setEnabled(True)
self.helpButton.setIcon(QgsApplication.getThemeIcon("console/iconHelpConsole.png"))
self.helpButton.setMenuRole(QAction.PreferencesRole)
self.helpButton.setIconVisibleInMenu(True)
self.helpButton.setToolTip(helpBt)
self.helpButton.setText(helpBt)
self.toolBar = QToolBar()
self.toolBar.setEnabled(True)
self.toolBar.setFocusPolicy(Qt.NoFocus)
self.toolBar.setContextMenuPolicy(Qt.DefaultContextMenu)
self.toolBar.setLayoutDirection(Qt.LeftToRight)
self.toolBar.setIconSize(QSize(16, 16))
self.toolBar.setMovable(False)
self.toolBar.setFloatable(False)
self.toolBar.addAction(self.clearButton)
self.toolBar.addAction(self.actionClass)
self.toolBar.addAction(self.runButton)
self.toolBar.addSeparator()
self.toolBar.addAction(self.showEditorButton)
self.toolBar.addSeparator()
self.toolBar.addAction(self.optionsButton)
self.toolBar.addAction(self.helpButton)
self.toolBarEditor = QToolBar()
self.toolBarEditor.setEnabled(False)
self.toolBarEditor.setFocusPolicy(Qt.NoFocus)
self.toolBarEditor.setContextMenuPolicy(Qt.DefaultContextMenu)
self.toolBarEditor.setLayoutDirection(Qt.LeftToRight)
self.toolBarEditor.setIconSize(QSize(16, 16))
self.toolBarEditor.setMovable(False)
self.toolBarEditor.setFloatable(False)
self.toolBarEditor.addAction(self.openFileButton)
self.toolBarEditor.addAction(self.openInEditorButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.saveFileButton)
self.toolBarEditor.addAction(self.saveAsFileButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.runScriptEditorButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.findTextButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.cutEditorButton)
self.toolBarEditor.addAction(self.copyEditorButton)
self.toolBarEditor.addAction(self.pasteEditorButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.commentEditorButton)
self.toolBarEditor.addAction(self.uncommentEditorButton)
self.toolBarEditor.addSeparator()
self.toolBarEditor.addAction(self.objectListButton)
# Menu Import Class
default_command = {
(QCoreApplication.translate("PythonConsole", "Import Processing Class"),
QgsApplication.getThemeIcon("console/iconProcessingConsole.png")):
["import processing"],
(QCoreApplication.translate("PythonConsole", "Import PyQt.QtCore Class"),
QgsApplication.getThemeIcon("console/iconQtCoreConsole.png")):
["from qgis.PyQt.QtCore import *"],
(QCoreApplication.translate("PythonConsole", "Import PyQt.QtGui Class"),
QgsApplication.getThemeIcon("console/iconQtGuiConsole.png")):
["from qgis.PyQt.QtGui import *", "from qgis.PyQt.QtWidgets import *"]
}
self.classMenu = QMenu()
for (title, icon), commands in list(default_command.items()):
action = self.classMenu.addAction(icon, title)
action.triggered.connect(partial(self.shell.commandConsole, commands))
cM = self.toolBar.widgetForAction(self.actionClass)
cM.setMenu(self.classMenu)
cM.setPopupMode(QToolButton.InstantPopup)
self.widgetButton = QWidget()
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.widgetButton.sizePolicy().hasHeightForWidth())
self.widgetButton.setSizePolicy(sizePolicy)
self.widgetButtonEditor = QWidget(self.widgetEditor)
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.widgetButtonEditor.sizePolicy().hasHeightForWidth())
self.widgetButtonEditor.setSizePolicy(sizePolicy)
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.shellOut.sizePolicy().hasHeightForWidth())
self.shellOut.setSizePolicy(sizePolicy)
self.shellOut.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.shell.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
# ------------ Layout -------------------------------
self.mainLayout = QGridLayout(self)
self.mainLayout.setMargin(0)
self.mainLayout.setSpacing(0)
self.mainLayout.addWidget(self.widgetButton, 0, 0, 1, 1)
self.mainLayout.addWidget(self.splitterEditor, 0, 1, 1, 1)
self.shellOutWidget.layout().insertWidget(0, self.toolBar)
self.layoutEditor = QGridLayout(self.widgetEditor)
self.layoutEditor.setMargin(0)
self.layoutEditor.setSpacing(0)
self.layoutEditor.addWidget(self.toolBarEditor, 0, 1, 1, 1)
self.layoutEditor.addWidget(self.widgetButtonEditor, 1, 0, 2, 1)
self.layoutEditor.addWidget(self.tabEditorWidget, 1, 1, 1, 1)
self.layoutEditor.addWidget(self.widgetFind, 2, 1, 1, 1)
# Layout for the find widget
self.layoutFind = QGridLayout(self.widgetFind)
self.layoutFind.setContentsMargins(0, 0, 0, 0)
self.lineEditFind = QgsFilterLineEdit()
placeHolderTxt = QCoreApplication.translate("PythonConsole", "Enter text to find...")
self.lineEditFind.setPlaceholderText(placeHolderTxt)
self.findNextButton = QToolButton()
self.findNextButton.setEnabled(False)
toolTipfindNext = QCoreApplication.translate("PythonConsole", "Find Next")
self.findNextButton.setToolTip(toolTipfindNext)
self.findNextButton.setIcon(QgsApplication.getThemeIcon("console/iconSearchNextEditorConsole.png"))
self.findNextButton.setIconSize(QSize(24, 24))
self.findNextButton.setAutoRaise(True)
self.findPrevButton = QToolButton()
self.findPrevButton.setEnabled(False)
toolTipfindPrev = QCoreApplication.translate("PythonConsole", "Find Previous")
self.findPrevButton.setToolTip(toolTipfindPrev)
self.findPrevButton.setIcon(QgsApplication.getThemeIcon("console/iconSearchPrevEditorConsole.png"))
self.findPrevButton.setIconSize(QSize(24, 24))
self.findPrevButton.setAutoRaise(True)
self.caseSensitive = QCheckBox()
caseSensTr = QCoreApplication.translate("PythonConsole", "Case Sensitive")
self.caseSensitive.setText(caseSensTr)
self.wholeWord = QCheckBox()
wholeWordTr = QCoreApplication.translate("PythonConsole", "Whole Word")
self.wholeWord.setText(wholeWordTr)
self.wrapAround = QCheckBox()
self.wrapAround.setChecked(True)
wrapAroundTr = QCoreApplication.translate("PythonConsole", "Wrap Around")
self.wrapAround.setText(wrapAroundTr)
self.layoutFind.addWidget(self.lineEditFind, 0, 1, 1, 1)
self.layoutFind.addWidget(self.findPrevButton, 0, 2, 1, 1)
self.layoutFind.addWidget(self.findNextButton, 0, 3, 1, 1)
self.layoutFind.addWidget(self.caseSensitive, 0, 4, 1, 1)
self.layoutFind.addWidget(self.wholeWord, 0, 5, 1, 1)
self.layoutFind.addWidget(self.wrapAround, 0, 6, 1, 1)
# ------------ Add first Tab in Editor -------------------------------
# self.tabEditorWidget.newTabEditor(tabName='first', filename=None)
# ------------ Signal -------------------------------
self.findTextButton.triggered.connect(self._toggleFind)
self.objectListButton.toggled.connect(self.toggleObjectListWidget)
self.commentEditorButton.triggered.connect(self.commentCode)
self.uncommentEditorButton.triggered.connect(self.uncommentCode)
self.runScriptEditorButton.triggered.connect(self.runScriptEditor)
self.cutEditorButton.triggered.connect(self.cutEditor)
self.copyEditorButton.triggered.connect(self.copyEditor)
self.pasteEditorButton.triggered.connect(self.pasteEditor)
self.showEditorButton.toggled.connect(self.toggleEditor)
self.clearButton.triggered.connect(self.shellOut.clearConsole)
self.optionsButton.triggered.connect(self.openSettings)
self.runButton.triggered.connect(self.shell.entered)
self.openFileButton.triggered.connect(self.openScriptFile)
self.openInEditorButton.triggered.connect(self.openScriptFileExtEditor)
self.saveFileButton.triggered.connect(self.saveScriptFile)
self.saveAsFileButton.triggered.connect(self.saveAsScriptFile)
self.helpButton.triggered.connect(self.openHelp)
self.listClassMethod.itemClicked.connect(self.onClickGoToLine)
self.lineEditFind.returnPressed.connect(self._findNext)
self.findNextButton.clicked.connect(self._findNext)
self.findPrevButton.clicked.connect(self._findPrev)
self.lineEditFind.textChanged.connect(self._textFindChanged)
self.findScut = QShortcut(QKeySequence.Find, self.widgetEditor)
self.findScut.setContext(Qt.WidgetWithChildrenShortcut)
self.findScut.activated.connect(self._openFind)
self.findNextScut = QShortcut(QKeySequence.FindNext, self.widgetEditor)
self.findNextScut.setContext(Qt.WidgetWithChildrenShortcut)
self.findNextScut.activated.connect(self._findNext)
self.findPreviousScut = QShortcut(QKeySequence.FindPrevious, self.widgetEditor)
self.findPreviousScut.setContext(Qt.WidgetWithChildrenShortcut)
self.findPreviousScut.activated.connect(self._findPrev)
# Escape on editor hides the find bar
self.findScut = QShortcut(Qt.Key_Escape, self.widgetEditor)
self.findScut.setContext(Qt.WidgetWithChildrenShortcut)
self.findScut.activated.connect(self._closeFind)
def _toggleFind(self):
self.tabEditorWidget.currentWidget().newEditor.toggleFindWidget()
def _openFind(self):
self.tabEditorWidget.currentWidget().newEditor.openFindWidget()
def _closeFind(self):
self.tabEditorWidget.currentWidget().newEditor.closeFindWidget()
def _findNext(self):
self.tabEditorWidget.currentWidget().newEditor.findText(True)
def _findPrev(self):
self.tabEditorWidget.currentWidget().newEditor.findText(False)
def _textFindChanged(self):
if self.lineEditFind.text():
self.findNextButton.setEnabled(True)
self.findPrevButton.setEnabled(True)
self.tabEditorWidget.currentWidget().newEditor.findText(True, showMessage=False, findFirst=True)
else:
self.lineEditFind.setStyleSheet('')
self.findNextButton.setEnabled(False)
self.findPrevButton.setEnabled(False)
def onClickGoToLine(self, item, column):
tabEditor = self.tabEditorWidget.currentWidget().newEditor
if item.text(1) == 'syntaxError':
check = tabEditor.syntaxCheck(fromContextMenu=False)
if check and not tabEditor.isReadOnly():
self.tabEditorWidget.currentWidget().save()
return
linenr = int(item.text(1))
itemName = str(item.text(0))
charPos = itemName.find(' ')
if charPos != -1:
objName = itemName[0:charPos]
else:
objName = itemName
tabEditor.goToLine(objName, linenr)
def toggleEditor(self, checked):
self.splitterObj.show() if checked else self.splitterObj.hide()
if not self.tabEditorWidget:
self.tabEditorWidget.enableToolBarEditor(checked)
self.tabEditorWidget.restoreTabsOrAddNew()
def toggleObjectListWidget(self, checked):
self.listClassMethod.show() if checked else self.listClassMethod.hide()
def pasteEditor(self):
self.tabEditorWidget.currentWidget().newEditor.paste()
def cutEditor(self):
self.tabEditorWidget.currentWidget().newEditor.cut()
def copyEditor(self):
self.tabEditorWidget.currentWidget().newEditor.copy()
def runScriptEditor(self):
self.tabEditorWidget.currentWidget().newEditor.runScriptCode()
def commentCode(self):
self.tabEditorWidget.currentWidget().newEditor.commentEditorCode(True)
def uncommentCode(self):
self.tabEditorWidget.currentWidget().newEditor.commentEditorCode(False)
def openScriptFileExtEditor(self):
tabWidget = self.tabEditorWidget.currentWidget()
path = tabWidget.path
import subprocess
try:
subprocess.Popen([os.environ['EDITOR'], path])
except KeyError:
QDesktopServices.openUrl(QUrl.fromLocalFile(path))
def openScriptFile(self):
lastDirPath = self.settings.value("pythonConsole/lastDirPath", QDir.homePath())
openFileTr = QCoreApplication.translate("PythonConsole", "Open File")
fileList, selected_filter = QFileDialog.getOpenFileNames(
self, openFileTr, lastDirPath, "Script file (*.py)")
if fileList:
for pyFile in fileList:
for i in range(self.tabEditorWidget.count()):
tabWidget = self.tabEditorWidget.widget(i)
if tabWidget.path == pyFile:
self.tabEditorWidget.setCurrentWidget(tabWidget)
break
else:
tabName = QFileInfo(pyFile).fileName()
self.tabEditorWidget.newTabEditor(tabName, pyFile)
lastDirPath = QFileInfo(pyFile).path()
self.settings.setValue("pythonConsole/lastDirPath", pyFile)
self.updateTabListScript(pyFile, action='append')
def saveScriptFile(self):
tabWidget = self.tabEditorWidget.currentWidget()
try:
tabWidget.save()
except (IOError, OSError) as error:
msgText = QCoreApplication.translate('PythonConsole',
'The file <b>{0}</b> could not be saved. Error: {1}').format(tabWidget.path,
error.strerror)
self.callWidgetMessageBarEditor(msgText, 2, False)
def saveAsScriptFile(self, index=None):
tabWidget = self.tabEditorWidget.currentWidget()
if not index:
index = self.tabEditorWidget.currentIndex()
if not tabWidget.path:
fileName = self.tabEditorWidget.tabText(index) + '.py'
folder = self.settings.value("pythonConsole/lastDirPath", QDir.home())
pathFileName = os.path.join(folder, fileName)
fileNone = True
else:
pathFileName = tabWidget.path
fileNone = False
saveAsFileTr = QCoreApplication.translate("PythonConsole", "Save File As")
filename, filter = QFileDialog.getSaveFileName(self,
saveAsFileTr,
pathFileName, "Script file (*.py)")
if filename:
try:
tabWidget.save(filename)
except (IOError, OSError) as error:
msgText = QCoreApplication.translate('PythonConsole',
'The file <b>{0}</b> could not be saved. Error: {1}').format(tabWidget.path,
error.strerror)
self.callWidgetMessageBarEditor(msgText, 2, False)
if fileNone:
tabWidget.path = None
else:
tabWidget.path = pathFileName
return
if not fileNone:
self.updateTabListScript(pathFileName, action='remove')
def openHelp(self):
QgsContextHelp.run("PythonConsole")
def openSettings(self):
if optionsDialog(self).exec_():
self.shell.refreshSettingsShell()
self.shellOut.refreshSettingsOutput()
self.tabEditorWidget.refreshSettingsEditor()
def callWidgetMessageBar(self, text):
self.shellOut.widgetMessageBar(iface, text)
def callWidgetMessageBarEditor(self, text, level, timed):
self.tabEditorWidget.widgetMessageBar(iface, text, level, timed)
def updateTabListScript(self, script, action=None):
if action == 'remove':
self.tabListScript.remove(script)
elif action == 'append':
if not self.tabListScript:
self.tabListScript = []
if script not in self.tabListScript:
self.tabListScript.append(script)
else:
self.tabListScript = []
self.settings.setValue("pythonConsole/tabScripts",
self.tabListScript)
def saveSettingsConsole(self):
self.settings.setValue("pythonConsole/splitterConsole", self.splitter.saveState())
self.settings.setValue("pythonConsole/splitterObj", self.splitterObj.saveState())
self.settings.setValue("pythonConsole/splitterEditor", self.splitterEditor.saveState())
self.shell.writeHistoryFile(True)
def restoreSettingsConsole(self):
storedTabScripts = self.settings.value("pythonConsole/tabScripts", [])
self.tabListScript = storedTabScripts
self.splitter.restoreState(self.settings.value("pythonConsole/splitterConsole", QByteArray()))
self.splitterEditor.restoreState(self.settings.value("pythonConsole/splitterEditor", QByteArray()))
self.splitterObj.restoreState(self.settings.value("pythonConsole/splitterObj", QByteArray()))
class WaysCalc:
"""QGIS Plugin Implementation."""
def __init__(self, iface):
"""Constructor.
:param iface: An interface instance that will be passed to this class
which provides the hook by which you can manipulate the QGIS
application at run time.
:type iface: QgsInterface
"""
# Save reference to the QGIS interface
self.iface = iface
# initialize plugin directory
self.plugin_dir = os.path.dirname(__file__)
# initialize locale
locale = QSettings().value('locale/userLocale')[0:2]
locale_path = os.path.join(
self.plugin_dir,
'i18n',
'WaysCalc_{}.qm'.format(locale))
if os.path.exists(locale_path):
self.translator = QTranslator()
self.translator.load(locale_path)
QCoreApplication.installTranslator(self.translator)
# Declare instance attributes
self.actions = []
self.menu = self.tr(u'&WaysCalc')
# TODO: We are going to let the user set this up in a future iteration
# self.toolbar = self.iface.addToolBar(u'WaysCalc')
# self.toolbar.setObjectName(u'WaysCalc')
#print "** INITIALIZING WaysCalc"
self.pluginIsActive = False
self.dockwidget_inters_ways = None
self.dockwidget_inters_allways = None
# self.settings = None
self.IW = None #IntersectionWays
self.IAW = None #IntersectionAllWays
# noinspection PyMethodMayBeStatic
def tr(self, message):
"""Get the translation for a string using Qt translation API.
We implement this ourselves since we do not inherit QObject.
:param message: String for translation.
:type message: str, QString
:returns: Translated version of message.
:rtype: QString
"""
# noinspection PyTypeChecker,PyArgumentList,PyCallByClass
return QCoreApplication.translate('WaysCalc', message)
def initGui(self):
"""Create the menu entries and toolbar icons inside the QGIS GUI."""
# выпадающая кнопка для пересекающихся маршрутов
self.toolButton = QToolButton()
self.toolButton.setMenu(QMenu())
# setPopupMode: DelayedPopup, MenuButtonPopup, InstantPopup
self.toolButton.setPopupMode(QToolButton.InstantPopup)
self.toolButton.setAutoRaise(True)
self.toolButton_action = self.iface.addToolBarWidget(self.toolButton)
self.action_intersection = QAction(
QIcon(":/plugins/_Ways_calc/icon.png"),
u'Поиск пересечений для линейного объекта',
self.iface.mainWindow())
self.action_initLayerWays = QAction(
u"Выбор слоя для поиска пересечений",
self.iface.mainWindow())
self.action_allintersection = QAction(
QIcon(":/plugins/_Ways_calc/icon.png"),
u'Поиск пересечений всех линейных объектов',
self.iface.mainWindow())
self.iface.addPluginToMenu(u"WaysCalc", self.action_intersection)
self.iface.addPluginToMenu(u"WaysCalc", self.action_initLayerWays)
self.iface.addPluginToMenu(u"WaysCalc", self.action_allintersection)
# self.iface.addToolBarIcon(self.action_intersection)
m = self.toolButton.menu()
m.addAction(self.action_intersection)
m.addAction(self.action_initLayerWays)
m.addSeparator()
m.addAction(self.action_allintersection)
self.toolButton.setDefaultAction(self.action_intersection)
self.action_intersection.triggered.connect(self.run_intersection) # пересекающиеся маршруты
self.action_allintersection.triggered.connect(self.run_allintersection) # пересекающиеся все маршруты
self.action_initLayerWays.triggered.connect(self.run_initLayerWays) # выбор слоя сравнения
self.pointEmitterIntersection = QgsMapToolEmitPoint(self.iface.mapCanvas())
self.pointEmitterIntersection.setAction(self.action_intersection)
self.pointEmitterIntersection.canvasClicked.connect(self.pointEmitterIntersectioncanvasClicked)
self.iface.mapCanvas().currentLayerChanged.connect(self.onCurrentLayerChanged)
#--------------------------------------------------------------------------
def onClosePlugin(self):
"""Cleanup necessary items here when plugin dockwidget is closed"""
# disconnects
try:
self.dockwidget_inters_ways.closingPlugin.disconnect(self.onClosePlugin)
except:
pass
try:
self.dockwidget_inters_allways.closingPlugin.disconnect(self.onClosePlugin)
except:
pass
self.pluginIsActive = False
def unload(self):
"""Removes the plugin menu item and icon from QGIS GUI."""
self.iface.removePluginMenu(u"WaysCalc", self.action_intersection)
self.iface.removePluginMenu(u"WaysCalc", self.action_allintersection)
self.iface.removePluginMenu(u"WaysCalc", self.action_initLayerWays)
self.iface.removeToolBarIcon(self.action_intersection)
self.iface.removeToolBarIcon(self.action_intersection)
self.iface.removeToolBarIcon(self.toolButton_action)
self.action_intersection.triggered.disconnect(self.run_intersection) # пересекающиеся маршруты
self.action_allintersection.triggered.disconnect(self.run_allintersection) # пересекающиеся все маршруты
self.action_initLayerWays.triggered.disconnect(self.run_initLayerWays) # выбор слоя сравнения
self.pointEmitterIntersection.canvasClicked.connect(self.pointEmitterIntersectioncanvasClicked)
self.iface.mapCanvas().currentLayerChanged.disconnect(self.onCurrentLayerChanged)
if self.IW is not None:
self.IW.onUnLoadModule()
def init_dock_inters_ways(self, dock):
"""Run method that loads and starts the plugin"""
# if not self.pluginIsActive:
self.pluginIsActive = True
if self.dockwidget_inters_ways == None:
self.dockwidget_inters_ways = WaysCalcDockWidget()
self.dockwidget_inters_ways.closingPlugin.connect(self.onClosePlugin)
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.dockwidget_inters_ways)
self.dockwidget_inters_ways.hide()
self.dockwidget_inters_ways.setWindowTitle(u'WaysCalc: Поиск пересечений для линейного объекта')
def init_dock_inters_allways(self, dock):
"""Run method that loads and starts the plugin"""
# if not self.pluginIsActive:
self.pluginIsActive = True
if self.dockwidget_inters_allways == None:
self.dockwidget_inters_allways = WaysCalcDockWidget()
self.dockwidget_inters_allways.closingPlugin.connect(self.onClosePlugin)
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.dockwidget_inters_allways)
self.dockwidget_inters_allways.hide()
self.dockwidget_inters_allways.setWindowTitle(u'WaysCalc: Поиск пересечений всех линейных объектов')
def onCurrentLayerChanged(self):
self.iface.mapCanvas().unsetMapTool(self.pointEmitterIntersection)
#--------------------------------------------------------------------------
# def loadSettings(self):
# with open(os.path.join(self.plugin_dir, "settings.json"), "r") as read_file:
# self.settings = json.load(read_file)
#--------INTERSECTION WAYS-------------------------------------------------
def run_initLayerWays(self):
if self.IW is None:
self.init_IW()
self.IW.initLayerWays()
def run_intersection(self):
self.toolButton.setDefaultAction(self.action_intersection)
self.init_dock_inters_ways(self.dockwidget_inters_ways)
if self.IW is None:
self.init_IW()
if self.IW.checkLayers():
self.iface.mapCanvas().setMapTool(self.pointEmitterIntersection)
def pointEmitterIntersectioncanvasClicked(self, point, button):
self.IW.insersection_take_way(point)
def init_IW(self):
self.IW = IntersectionWays(self.iface, self.dockwidget_inters_ways)
#-------- END INTERSECTION WAYS---------------------------------------------
def init_IAW(self):
self.IAW = IntersectionAllWays(self.iface, self.dockwidget_inters_allways)
def run_allintersection(self):
self.init_dock_inters_allways(self.dockwidget_inters_allways)
if self.IAW is None:
self.init_IAW()
self.IAW.showClickedFeaturesList()