def __init__(self, parent):
QDialog.__init__(self, parent)
self.setupUi(self)
self.parent = parent
self.setWindowTitle(
QCoreApplication.translate("PythonConsole",
"Python Console - Command History"))
self.listView.setToolTip(
QCoreApplication.translate("PythonConsole",
"Double-click on item to execute"))
self.model = QStandardItemModel(self.listView)
self._reloadHistory()
self.deleteScut = QShortcut(QKeySequence(Qt.Key_Delete), self)
self.deleteScut.activated.connect(self._deleteItem)
self.listView.doubleClicked.connect(self._runHistory)
self.reloadHistory.clicked.connect(self._reloadHistory)
self.saveHistory.clicked.connect(self._saveHistory)
self.runHistoryButton.clicked.connect(self._executeSelectedHistory)
def __init__(self, parent=None):
super().__init__(parent)
self.parent = parent
self.shell = self.parent.shell
self.settings = QgsSettings()
# Creates layout for message bar
self.layout = QGridLayout(self)
self.layout.setContentsMargins(0, 0, 0, 0)
spacerItem = QSpacerItem(20, 40, QSizePolicy.Minimum,
QSizePolicy.Expanding)
self.layout.addItem(spacerItem, 1, 0, 1, 1)
# messageBar instance
self.infoBar = QgsMessageBar()
sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.infoBar.setSizePolicy(sizePolicy)
self.layout.addWidget(self.infoBar, 0, 0, 1, 1)
sys.stdout = writeOut(self, sys.stdout)
sys.stderr = writeOut(self, sys.stderr, "_traceback")
self.insertInitText()
self.refreshSettingsOutput()
self.setMinimumHeight(120)
self.setWrapMode(QsciScintilla.WrapCharacter)
self.SendScintilla(QsciScintilla.SCI_SETHSCROLLBAR, 0)
self.runScut = QShortcut(QKeySequence(Qt.CTRL + Qt.Key_E), self)
self.runScut.setContext(Qt.WidgetShortcut)
self.runScut.activated.connect(self.enteredSelected)
# Reimplemented copy action to prevent paste prompt (>>>,...) in command view
self.copyShortcut = QShortcut(QKeySequence.Copy, self)
self.copyShortcut.setContext(Qt.WidgetWithChildrenShortcut)
self.copyShortcut.activated.connect(self.copy)
self.selectAllShortcut = QShortcut(QKeySequence.SelectAll, self)
self.selectAllShortcut.setContext(Qt.WidgetWithChildrenShortcut)
self.selectAllShortcut.activated.connect(self.selectAll)
def initGui(self):
self.paste_geometry_action = QAction(self.tr('Paste Geometry'),
self.iface.mainWindow())
self.paste_geometry_action.setIcon(
QIcon(os.path.join(self.dir, 'icon.svg')))
self.paste_geometry_action.setShortcut(QKeySequence('Ctrl+Shift+G'))
self.paste_geometry_action.setToolTip(self.tr('Paste Geometry'))
self.paste_geometry_action.setStatusTip(self.description)
self.paste_geometry_action.setEnabled(False)
self.paste_geometry_action.triggered.connect(self.pasteGeometry)
self.iface.editMenu().insertAction(
self.iface.actionDeleteSelected(),
self.paste_geometry_action,
)
self.iface.digitizeToolBar().insertAction(
self.iface.actionDeleteSelected(),
self.paste_geometry_action,
)
self.iface.currentLayerChanged.connect(self._changeCurrentLayerHandle)
self._changeCurrentLayerHandle(self.iface.activeLayer())
def _fill_arc_menu(self):
""" Fill add arc menu """
# disconnect and remove previuos signals and actions
actions = self.menu.actions()
for action in actions:
action.disconnect()
self.menu.removeAction(action)
del action
action_group = self.action.property('action_group')
# Update featurecatvalues
global_vars.feature_cat = tools_gw.manage_feature_cat()
# Get list of different arc types
features_cat = global_vars.feature_cat
if features_cat is not None:
list_feature_cat = tools_os.get_values_from_dictionary(
features_cat)
for feature_cat in list_feature_cat:
if feature_cat.feature_type.upper() == 'ARC':
obj_action = QAction(str(feature_cat.id), action_group)
obj_action.setObjectName(feature_cat.id)
obj_action.setProperty('action_group', action_group)
if f"{feature_cat.shortcut_key}" not in global_vars.shortcut_keys:
obj_action.setShortcut(
QKeySequence(str(feature_cat.shortcut_key)))
try:
obj_action.setShortcutVisibleInContextMenu(True)
except Exception:
pass
self.menu.addAction(obj_action)
obj_action.triggered.connect(
partial(self.info_feature.add_feature, feature_cat))
obj_action.triggered.connect(
partial(self._save_last_selection, self.menu,
feature_cat))
def __init__(self, mgis):
QDialog.__init__(self)
self.mgis = mgis
self.mdb = self.mgis.mdb
self.tbwq = ClassTableWQ(self.mgis, self.mdb)
self.cur_wq_mod = self.tbwq.get_cur_wq_mod()
self.cur_wq_law = None
self.filling_tab = False
self.ui = loadUi(
os.path.join(self.mgis.masplugPath, 'ui/ui_tracer_laws.ui'), self)
self.ui.tab_laws.sCut_del = QShortcut(QKeySequence("Del"), self)
self.ui.tab_laws.sCut_del.activated.connect(self.short_cut_row_del)
self.bg_time = QButtonGroup()
self.bg_time.addButton(self.rb_sec, 0)
self.bg_time.addButton(self.rb_min, 1)
self.bg_time.addButton(self.rb_hour, 2)
self.bg_time.addButton(self.rb_day, 3)
self.bg_time.buttonClicked[int].connect(self.chg_time)
styled_item_delegate = QStyledItemDelegate()
styled_item_delegate.setItemEditorFactory(ItemEditorFactory())
self.ui.tab_laws.setItemDelegate(styled_item_delegate)
self.ui.actionB_edit.triggered.connect(self.edit_law)
self.ui.actionB_new.triggered.connect(self.new_law)
self.ui.actionB_delete.triggered.connect(self.delete_law)
self.ui.actionB_import.triggered.connect(self.import_csv)
self.ui.actionB_addLine.triggered.connect(self.new_time)
self.ui.actionB_delLine.triggered.connect(self.delete_time)
self.ui.b_OK_page2.accepted.connect(self.accept_page2)
self.ui.b_OK_page2.rejected.connect(self.reject_page2)
self.ui.b_OK_page1.accepted.connect(self.reject)
self.init_ui()
def setShortcut(self, shortcut):
self.keySequence = QKeySequence(shortcut)
self.assignShortcutPushButton.setChecked(False)
self.assignShortcutPushButton.setText(
self.keySequence.toString(format=QKeySequence.NativeText))
def setup_shortcut(self, keysequence):
shortcut = QShortcut(QKeySequence(keysequence), iface.mainWindow())
shortcut.setContext(Qt.ApplicationShortcut)
return shortcut
def setupUi(self):
self.setWindowTitle(self.tr("DB Manager"))
self.setWindowIcon(QIcon(":/db_manager/icon"))
self.resize(QSize(700, 500).expandedTo(self.minimumSizeHint()))
# create central tab widget and add the first 3 tabs: info, table and preview
self.tabs = QTabWidget()
self.info = InfoViewer(self)
self.tabs.addTab(self.info, self.tr("Info"))
self.table = TableViewer(self)
self.tabs.addTab(self.table, self.tr("Table"))
self.preview = LayerPreview(self)
self.tabs.addTab(self.preview, self.tr("Preview"))
self.setCentralWidget(self.tabs)
# display close button for all tabs but the first 3 ones, i.e.
# HACK: just hide the close button where not needed (GS)
self.tabs.setTabsClosable(True)
self.tabs.tabCloseRequested.connect(self.close_tab)
tabbar = self.tabs.tabBar()
for i in range(3):
btn = tabbar.tabButton(i, QTabBar.RightSide) if tabbar.tabButton(i, QTabBar.RightSide) else tabbar.tabButton(i, QTabBar.LeftSide)
btn.resize(0, 0)
btn.hide()
# Creates layout for message bar
self.layout = QGridLayout(self.info)
self.layout.setContentsMargins(0, 0, 0, 0)
spacerItem = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding)
self.layout.addItem(spacerItem, 1, 0, 1, 1)
# init messageBar instance
self.infoBar = QgsMessageBar(self.info)
sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.infoBar.setSizePolicy(sizePolicy)
self.layout.addWidget(self.infoBar, 0, 0, 1, 1)
# create database tree
self.dock = QDockWidget("Tree", self)
self.dock.setObjectName("DB_Manager_DBView")
self.dock.setFeatures(QDockWidget.DockWidgetMovable)
self.tree = DBTree(self)
self.dock.setWidget(self.tree)
self.addDockWidget(Qt.LeftDockWidgetArea, self.dock)
# create status bar
self.statusBar = QStatusBar(self)
self.setStatusBar(self.statusBar)
# create menus
self.menuBar = QMenuBar(self)
self.menuDb = QMenu(self.tr("&Database"), self)
self.menuBar.addMenu(self.menuDb)
self.menuSchema = QMenu(self.tr("&Schema"), self)
actionMenuSchema = self.menuBar.addMenu(self.menuSchema)
self.menuTable = QMenu(self.tr("&Table"), self)
actionMenuTable = self.menuBar.addMenu(self.menuTable)
self.menuHelp = None # QMenu(self.tr("&Help"), self)
# actionMenuHelp = self.menuBar.addMenu(self.menuHelp)
self.setMenuBar(self.menuBar)
# create toolbar
self.toolBar = QToolBar("Default", self)
self.toolBar.setObjectName("DB_Manager_ToolBar")
self.addToolBar(self.toolBar)
# create menus' actions
# menu DATABASE
sep = self.menuDb.addSeparator()
sep.setObjectName("DB_Manager_DbMenu_placeholder")
sep.setVisible(False)
self.actionRefresh = self.menuDb.addAction(QIcon(":/db_manager/actions/refresh"), self.tr("&Refresh"),
self.refreshActionSlot, QKeySequence("F5"))
self.actionSqlWindow = self.menuDb.addAction(QIcon(":/db_manager/actions/sql_window"), self.tr("&SQL window"),
self.runSqlWindow, QKeySequence("F2"))
self.menuDb.addSeparator()
self.actionClose = self.menuDb.addAction(QIcon(), self.tr("&Exit"), self.close, QKeySequence("CTRL+Q"))
# menu SCHEMA
sep = self.menuSchema.addSeparator()
sep.setObjectName("DB_Manager_SchemaMenu_placeholder")
sep.setVisible(False)
actionMenuSchema.setVisible(False)
# menu TABLE
sep = self.menuTable.addSeparator()
sep.setObjectName("DB_Manager_TableMenu_placeholder")
sep.setVisible(False)
self.actionImport = self.menuTable.addAction(QIcon(":/db_manager/actions/import"),
self.tr("&Import layer/file"), self.importActionSlot)
self.actionExport = self.menuTable.addAction(QIcon(":/db_manager/actions/export"), self.tr("&Export to file"),
self.exportActionSlot)
self.menuTable.addSeparator()
#self.actionShowSystemTables = self.menuTable.addAction(self.tr("Show system tables/views"), self.showSystemTables)
#self.actionShowSystemTables.setCheckable(True)
#self.actionShowSystemTables.setChecked(True)
actionMenuTable.setVisible(False)
# add actions to the toolbar
self.toolBar.addAction(self.actionRefresh)
self.toolBar.addAction(self.actionSqlWindow)
self.toolBar.addAction(self.actionImport)
self.toolBar.addAction(self.actionExport)
def __init__(self, parent=None):
super(ShellOutputScintilla, self).__init__(parent)
self.parent = parent
self.shell = self.parent.shell
self.settings = QgsSettings()
# Creates layout for message bar
self.layout = QGridLayout(self)
self.layout.setContentsMargins(0, 0, 0, 0)
spacerItem = QSpacerItem(20, 40, QSizePolicy.Minimum,
QSizePolicy.Expanding)
self.layout.addItem(spacerItem, 1, 0, 1, 1)
# messageBar instance
self.infoBar = QgsMessageBar()
sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.infoBar.setSizePolicy(sizePolicy)
self.layout.addWidget(self.infoBar, 0, 0, 1, 1)
# Enable non-ascii chars for editor
self.setUtf8(True)
sys.stdout = writeOut(self, sys.stdout)
sys.stderr = writeOut(self, sys.stderr, "_traceback")
self.insertInitText()
self.refreshSettingsOutput()
self.setReadOnly(True)
# Set the default font
font = QFont()
font.setFamily('Courier')
font.setFixedPitch(True)
font.setPointSize(10)
self.setFont(font)
self.setMarginsFont(font)
# Margin 0 is used for line numbers
self.setMarginWidth(0, 0)
self.setMarginWidth(1, 0)
self.setMarginWidth(2, 0)
#fm = QFontMetrics(font)
self.setMarginsFont(font)
self.setMarginWidth(1, "00000")
self.setMarginLineNumbers(1, True)
self.setMarginsForegroundColor(QColor("#3E3EE3"))
self.setMarginsBackgroundColor(QColor("#f9f9f9"))
self.setCaretLineVisible(True)
self.setCaretWidth(0)
self.setMinimumHeight(120)
self.setWrapMode(QsciScintilla.WrapCharacter)
self.SendScintilla(QsciScintilla.SCI_SETHSCROLLBAR, 0)
self.runScut = QShortcut(QKeySequence(Qt.CTRL + Qt.Key_E), self)
self.runScut.setContext(Qt.WidgetShortcut)
self.runScut.activated.connect(self.enteredSelected)
# Reimplemented copy action to prevent paste prompt (>>>,...) in command view
self.copyShortcut = QShortcut(QKeySequence.Copy, self)
self.copyShortcut.activated.connect(self.copy)
self.selectAllShortcut = QShortcut(QKeySequence.SelectAll, self)
self.selectAllShortcut.activated.connect(self.selectAll)
def initGui(self):
for keyseq, slot in (
(Qt.CTRL + Qt.ALT + Qt.Key_K, self.__create_group),
# (Qt.CTRL + Qt.ALT + Qt.Key_S, self.__select_next_group),
(Qt.CTRL + Qt.ALT + Qt.Key_N, self.__next_section),
(Qt.CTRL + Qt.ALT + Qt.Key_B, self.__previous_section),
(Qt.CTRL + Qt.ALT + Qt.Key_J, self.__add_section_from_selection),
):
short = QShortcut(QKeySequence(keyseq), self.__iface.mainWindow())
short.setContext(Qt.ApplicationShortcut)
short.activated.connect(slot)
self.__shortcuts.append(short)
self.__menu = QMenu("Albion")
self.__menu.aboutToShow.connect(self.__create_menu_entries)
self.__iface.mainWindow().menuBar().addMenu(self.__menu)
self.__toolbar = QToolBar("Albion")
self.__iface.addToolBar(self.__toolbar)
#self.__toolbar.addAction(
# icon("log_strati.svg"), "stratigraphic log"
#).triggered.connect(self.__log_strati_clicked)
self.__toolbar.addWidget(self.__current_graph)
self.__current_graph.currentIndexChanged[str].connect(
self.__current_graph_changed
)
self.__toolbar.addWidget(self.__current_section)
self.__current_section.currentIndexChanged[str].connect(
self.__current_section_changed
)
self.__toolbar.addAction(
icon("previous_line_big.svg"), "previous section (Ctrl+Alt+b)"
).triggered.connect(self.__previous_section)
self.__toolbar.addAction(
icon("previous_line.svg"), "previous sub section"
).triggered.connect(self.__previous_subsection)
self.__toolbar.addAction(
icon("next_line.svg"), "next sub section"
).triggered.connect(self.__next_subsection)
self.__toolbar.addAction(
icon("next_line_big.svg"), "next section (Ctrl+Alt+n)"
).triggered.connect(self.__next_section)
self.__toolbar.addAction(
icon("line_from_selected.svg"), "create temporary section"
).triggered.connect(self.__section_from_selection)
self.__viewer3d = QDockWidget("3D")
self.__viewer3d.setWidget(Viewer3d())
self.__iface.addDockWidget(Qt.LeftDockWidgetArea, self.__viewer3d)
self.__iface.mainWindow().tabifyDockWidget(
self.__iface.mainWindow().findChild(QDockWidget, "Layers"), self.__viewer3d
)
self.__viewer3d_ctrl = QToolBar("3D controls")
self.__viewer3d_ctrl.addWidget(ViewerControls(self.__viewer3d.widget()))
self.__iface.addToolBar(self.__viewer3d_ctrl)
QgsProject.instance().readProject.connect(self.__qgis__project__loaded)
self.__qgis__project__loaded() # case of reload
def __init__(self, iface, model):
"""Initialize the GUI control"""
QObject.__init__(self)
self.iface = iface
self.model = model
self.optionsDialog = None
self.path = os.path.dirname(os.path.abspath(__file__))
# load the form
self.dock = uic.loadUi(os.path.join(self.path, DOCK_WIDGET_FILE))
self.iface.addDockWidget(Qt.BottomDockWidgetArea, self.dock)
self.dock.pushButtonExportVideo.setEnabled(
False) # only enabled if there are managed layers
self.dock.pushButtonOptions.clicked.connect(self.optionsClicked)
self.dock.pushButtonExportVideo.clicked.connect(
self.exportVideoClicked)
self.dock.pushButtonToggleTime.clicked.connect(self.toggleTimeClicked)
self.dock.pushButtonArchaeology.clicked.connect(
self.archaeologyClicked)
self.dock.pushButtonBack.clicked.connect(self.backClicked)
self.dock.pushButtonForward.clicked.connect(self.forwardClicked)
self.dock.pushButtonPlay.clicked.connect(self.playClicked)
self.dock.dateTimeEditCurrentTime.dateTimeChanged.connect(
self.currentTimeChangedDateText)
# self.dock.horizontalTimeSlider.valueChanged.connect(self.currentTimeChangedSlider)
self.sliderTimer = QTimer(self)
self.sliderTimer.setInterval(250)
self.sliderTimer.setSingleShot(True)
self.sliderTimer.timeout.connect(self.currentTimeChangedSlider)
self.dock.horizontalTimeSlider.valueChanged.connect(self.startTimer)
self.dock.comboBoxTimeExtent.currentIndexChanged[str].connect(
self.currentTimeFrameTypeChanged)
self.dock.spinBoxTimeExtent.valueChanged.connect(
self.currentTimeFrameSizeChanged)
# this signal is responsible for rendering the label
self.iface.mapCanvas().renderComplete.connect(self.renderLabel)
# create shortcuts
self.focusSC = QShortcut(QKeySequence("Ctrl+Space"), self.dock)
self.focusSC.activated.connect(self.dock.horizontalTimeSlider.setFocus)
# put default values
self.dock.horizontalTimeSlider.setMinimum(conf.MIN_TIMESLIDER_DEFAULT)
self.dock.horizontalTimeSlider.setMaximum(conf.MAX_TIMESLIDER_DEFAULT)
self.dock.dateTimeEditCurrentTime.setMinimumDate(MIN_QDATE)
self.showLabel = conf.DEFAULT_SHOW_LABEL
self.exportEmpty = conf.DEFAULT_EXPORT_EMPTY
self.labelOptions = TimestampLabelConfig(self.model)
# placeholders for widgets that are added dynamically
self.bcdateSpinBox = None
# add to plugins toolbar
try:
self.action = QAction(
QCoreApplication.translate("TimeManagerGuiControl",
"Toggle visibility"),
self.iface.mainWindow())
self.action.triggered.connect(self.toggleDock)
self.iface.addPluginToMenu(
QCoreApplication.translate("TimeManagerGuiControl",
"&TimeManager"), self.action)
except Exception as e:
pass # OK for testing
def __init__(self, alg=None):
super(ModelerDialog, self).__init__(None)
self.setupUi(self)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.centralWidget().layout().insertWidget(0, self.bar)
try:
self.setDockOptions(self.dockOptions() | QMainWindow.GroupedDragging)
except:
pass
self.addDockWidget(Qt.LeftDockWidgetArea, self.propertiesDock)
self.addDockWidget(Qt.LeftDockWidgetArea, self.inputsDock)
self.addDockWidget(Qt.LeftDockWidgetArea, self.algorithmsDock)
self.tabifyDockWidget(self.inputsDock, self.algorithmsDock)
self.inputsDock.raise_()
self.zoom = 1
self.setWindowFlags(Qt.WindowMinimizeButtonHint |
Qt.WindowMaximizeButtonHint |
Qt.WindowCloseButtonHint)
settings = QgsSettings()
self.restoreState(settings.value("/Processing/stateModeler", QByteArray()))
self.restoreGeometry(settings.value("/Processing/geometryModeler", QByteArray()))
self.scene = ModelerScene(self)
self.scene.setSceneRect(QRectF(0, 0, self.CANVAS_SIZE, self.CANVAS_SIZE))
self.view.setScene(self.scene)
self.view.setAcceptDrops(True)
self.view.ensureVisible(0, 0, 10, 10)
def _dragEnterEvent(event):
if event.mimeData().hasText():
event.acceptProposedAction()
else:
event.ignore()
def _dropEvent(event):
if event.mimeData().hasText():
text = event.mimeData().text()
if text in ModelerParameterDefinitionDialog.paramTypes:
self.addInputOfType(text, event.pos())
else:
alg = QgsApplication.processingRegistry().algorithmById(text)
if alg is not None:
self._addAlgorithm(alg.getCopy(), event.pos())
event.accept()
else:
event.ignore()
def _dragMoveEvent(event):
if event.mimeData().hasText():
event.accept()
else:
event.ignore()
def _wheelEvent(event):
self.view.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
settings = QgsSettings()
factor = settings.value('/qgis/zoom_favor', 2.0)
if (event.modifiers() == Qt.ControlModifier):
factor = 1.0 + (factor - 1.0) / 20.0
if event.angleDelta().y() < 0:
factor = 1 / factor
self.view.scale(factor, factor)
self.repaintModel()
def _enterEvent(e):
QGraphicsView.enterEvent(self.view, e)
self.view.viewport().setCursor(Qt.ArrowCursor)
def _mouseReleaseEvent(e):
QGraphicsView.mouseReleaseEvent(self.view, e)
self.view.viewport().setCursor(Qt.ArrowCursor)
def _mousePressEvent(e):
if e.button() == Qt.MidButton:
self.previousMousePos = e.pos()
else:
QGraphicsView.mousePressEvent(self.view, e)
def _mouseMoveEvent(e):
if e.buttons() == Qt.MidButton:
offset = self.previousMousePos - e.pos()
self.previousMousePos = e.pos()
self.view.verticalScrollBar().setValue(self.view.verticalScrollBar().value() + offset.y())
self.view.horizontalScrollBar().setValue(self.view.horizontalScrollBar().value() + offset.x())
else:
QGraphicsView.mouseMoveEvent(self.view, e)
self.view.setDragMode(QGraphicsView.ScrollHandDrag)
self.view.dragEnterEvent = _dragEnterEvent
self.view.dropEvent = _dropEvent
self.view.dragMoveEvent = _dragMoveEvent
self.view.wheelEvent = _wheelEvent
self.view.enterEvent = _enterEvent
self.view.mousePressEvent = _mousePressEvent
self.view.mouseMoveEvent = _mouseMoveEvent
def _mimeDataInput(items):
mimeData = QMimeData()
text = items[0].text(0)
mimeData.setText(text)
return mimeData
self.inputsTree.mimeData = _mimeDataInput
self.inputsTree.setDragDropMode(QTreeWidget.DragOnly)
self.inputsTree.setDropIndicatorShown(True)
def _mimeDataAlgorithm(items):
item = items[0]
if isinstance(item, TreeAlgorithmItem):
mimeData = QMimeData()
mimeData.setText(item.alg.id())
return mimeData
self.algorithmTree.mimeData = _mimeDataAlgorithm
self.algorithmTree.setDragDropMode(QTreeWidget.DragOnly)
self.algorithmTree.setDropIndicatorShown(True)
if hasattr(self.searchBox, 'setPlaceholderText'):
self.searchBox.setPlaceholderText(self.tr('Search...'))
if hasattr(self.textName, 'setPlaceholderText'):
self.textName.setPlaceholderText(self.tr('Enter model name here'))
if hasattr(self.textGroup, 'setPlaceholderText'):
self.textGroup.setPlaceholderText(self.tr('Enter group name here'))
# Connect signals and slots
self.inputsTree.doubleClicked.connect(self.addInput)
self.searchBox.textChanged.connect(self.fillAlgorithmTree)
self.algorithmTree.doubleClicked.connect(self.addAlgorithm)
# Ctrl+= should also trigger a zoom in action
ctrlEquals = QShortcut(QKeySequence("Ctrl+="), self)
ctrlEquals.activated.connect(self.zoomIn)
try:
iconSize = int(settings.value("iconsize", 24))
except:
iconSize = 24
self.mToolbar.setIconSize(QSize(iconSize, iconSize))
self.mActionOpen.triggered.connect(self.openModel)
self.mActionSave.triggered.connect(self.save)
self.mActionSaveAs.triggered.connect(self.saveAs)
self.mActionZoomIn.triggered.connect(self.zoomIn)
self.mActionZoomOut.triggered.connect(self.zoomOut)
self.mActionZoomActual.triggered.connect(self.zoomActual)
self.mActionZoomToItems.triggered.connect(self.zoomToItems)
self.mActionExportImage.triggered.connect(self.exportAsImage)
self.mActionExportPdf.triggered.connect(self.exportAsPdf)
self.mActionExportSvg.triggered.connect(self.exportAsSvg)
self.mActionExportPython.triggered.connect(self.exportAsPython)
self.mActionEditHelp.triggered.connect(self.editHelp)
self.mActionRun.triggered.connect(self.runModel)
if alg is not None:
self.alg = alg
self.textGroup.setText(alg._group)
self.textName.setText(alg.displayName())
self.repaintModel()
else:
self.alg = ModelerAlgorithm()
self.alg.modelerdialog = self
self.fillInputsTree()
self.fillAlgorithmTree()
self.view.centerOn(0, 0)
self.alg.setModelerView(self)
self.help = None
self.hasChanged = False
def initGui(self):
self.toolbox = ProcessingToolbox()
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.toolbox)
self.toolbox.hide()
self.toolbox.visibilityChanged.connect(self.toolboxVisibilityChanged)
self.resultsDock = ResultsDock()
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.resultsDock)
self.resultsDock.hide()
self.menu = QMenu(self.iface.mainWindow().menuBar())
self.menu.setObjectName('processing')
self.menu.setTitle(self.tr('Pro&cessing'))
self.toolboxAction = QAction(self.tr('&Toolbox'),
self.iface.mainWindow())
self.toolboxAction.setCheckable(True)
self.toolboxAction.setObjectName('toolboxAction')
self.toolboxAction.setIcon(
QgsApplication.getThemeIcon("/processingAlgorithm.svg"))
self.iface.registerMainWindowAction(
self.toolboxAction,
QKeySequence('Ctrl+Alt+T').toString(QKeySequence.NativeText))
self.toolboxAction.toggled.connect(self.openToolbox)
self.iface.attributesToolBar().insertAction(
self.iface.actionOpenStatisticalSummary(), self.toolboxAction)
self.menu.addAction(self.toolboxAction)
self.modelerAction = QAction(
QgsApplication.getThemeIcon("/processingModel.svg"),
QCoreApplication.translate('ProcessingPlugin',
'Graphical &Modeler…'),
self.iface.mainWindow())
self.modelerAction.setObjectName('modelerAction')
self.modelerAction.triggered.connect(self.openModeler)
self.iface.registerMainWindowAction(
self.modelerAction,
QKeySequence('Ctrl+Alt+M').toString(QKeySequence.NativeText))
self.menu.addAction(self.modelerAction)
self.historyAction = QAction(
QgsApplication.getThemeIcon("/mIconHistory.svg"),
QCoreApplication.translate('ProcessingPlugin', '&History…'),
self.iface.mainWindow())
self.historyAction.setObjectName('historyAction')
self.historyAction.triggered.connect(self.openHistory)
self.iface.registerMainWindowAction(
self.historyAction,
QKeySequence('Ctrl+Alt+H').toString(QKeySequence.NativeText))
self.menu.addAction(self.historyAction)
self.toolbox.processingToolbar.addAction(self.historyAction)
self.resultsAction = QAction(
QgsApplication.getThemeIcon("/processingResult.svg"),
self.tr('&Results Viewer'), self.iface.mainWindow())
self.resultsAction.setCheckable(True)
self.iface.registerMainWindowAction(
self.resultsAction,
QKeySequence('Ctrl+Alt+R').toString(QKeySequence.NativeText))
self.menu.addAction(self.resultsAction)
self.toolbox.processingToolbar.addAction(self.resultsAction)
self.resultsDock.visibilityChanged.connect(
self.resultsAction.setChecked)
self.resultsAction.toggled.connect(self.resultsDock.setUserVisible)
self.toolbox.processingToolbar.addSeparator()
self.editInPlaceAction = QAction(
QgsApplication.getThemeIcon("/mActionProcessSelected.svg"),
self.tr('Edit Features In-Place'), self.iface.mainWindow())
self.editInPlaceAction.setObjectName('editInPlaceFeatures')
self.editInPlaceAction.setCheckable(True)
self.editInPlaceAction.toggled.connect(self.editSelected)
self.menu.addAction(self.editInPlaceAction)
self.toolbox.processingToolbar.addAction(self.editInPlaceAction)
self.toolbox.processingToolbar.addSeparator()
self.optionsAction = QAction(
QgsApplication.getThemeIcon("/mActionOptions.svg"),
self.tr('Options'), self.iface.mainWindow())
self.optionsAction.setObjectName('optionsAction')
self.optionsAction.triggered.connect(self.openProcessingOptions)
self.toolbox.processingToolbar.addAction(self.optionsAction)
menuBar = self.iface.mainWindow().menuBar()
menuBar.insertMenu(self.iface.firstRightStandardMenu().menuAction(),
self.menu)
self.menu.addSeparator()
initializeMenus()
createMenus()
# In-place editing button state sync
self.iface.currentLayerChanged.connect(self.sync_in_place_button_state)
self.iface.mapCanvas().selectionChanged.connect(
self.sync_in_place_button_state)
self.iface.actionToggleEditing().triggered.connect(
partial(self.sync_in_place_button_state, None))
self.sync_in_place_button_state()
def unregisterForPrintableAndQadFKeys(self):
# rimuove gli shortcut e le action relative ai caratteri stampabili
# e li memorizza in 2 liste interne: una per gi shortcut ed una per le action che sono state rimosse
del self.objList[:] # svuoto la lista
s = string.printable
for i in range(0, len(s)):
seq = QKeySequence(s[i])
obj = self.sManager.objectForSequence(seq)
if obj is not None:
self.objList.append([obj, seq])
self.sManager.setObjectKeySequence(
obj,
QKeySequence().toString()) # lo annulla
# rimuove gli shortcut e le action relative ai caratteri F2, F3, F8, F12, ESC
seq = QKeySequence(Qt.Key_F2)
obj = self.sManager.objectForSequence(seq)
if obj is not None:
self.objList.append([obj, seq])
self.sManager.setObjectKeySequence(
obj,
QKeySequence().toString()) # lo annulla
seq = QKeySequence(Qt.Key_F3)
obj = self.sManager.objectForSequence(seq)
if obj is not None:
self.objList.append([obj, seq])
self.sManager.setObjectKeySequence(
obj,
QKeySequence().toString()) # lo annulla
seq = QKeySequence(Qt.Key_F8)
obj = self.sManager.objectForSequence(seq)
if obj is not None:
self.objList.append([obj, seq])
self.sManager.setObjectKeySequence(
obj,
QKeySequence().toString()) # lo annulla
seq = QKeySequence(Qt.Key_F12)
obj = self.sManager.objectForSequence(seq)
if obj is not None:
self.objList.append([obj, seq])
self.sManager.setObjectKeySequence(
obj,
QKeySequence().toString()) # lo annulla
seq = QKeySequence(Qt.Key_Escape)
obj = self.sManager.objectForSequence(seq)
if obj is not None:
self.objList.append([obj, seq])
self.sManager.setObjectKeySequence(
obj,
QKeySequence().toString()) # lo annulla
return
def read_menu(self, project_loaded):
""" """
actions = self.iface.mainWindow().menuBar().actions()
last_action = actions[-1]
self.main_menu = QMenu("&Giswater", self.iface.mainWindow().menuBar())
self.main_menu.setObjectName("Giswater")
tools_gw.set_config_parser("menu", "load", "true", "project", "giswater")
icon_folder = f"{global_vars.plugin_dir}{os.sep}icons"
icon_path = f"{icon_folder}{os.sep}toolbars{os.sep}utilities{os.sep}99.png"
config_icon = QIcon(icon_path)
if project_loaded:
# region Toolbar
toolbars_menu = QMenu(f"Toolbars", self.iface.mainWindow().menuBar())
icon_path = f"{icon_folder}{os.sep}dialogs{os.sep}20x20{os.sep}36.png"
toolbars_icon = QIcon(icon_path)
toolbars_menu.setIcon(toolbars_icon)
self.main_menu.addMenu(toolbars_menu)
for toolbar in global_vars.giswater_settings.value(f"toolbars/list_toolbars"):
toolbar_submenu = QMenu(f"{toolbar}", self.iface.mainWindow().menuBar())
toolbars_menu.addMenu(toolbar_submenu)
buttons_toolbar = global_vars.giswater_settings.value(f"toolbars/{toolbar}")
project_exclusive = tools_gw.get_config_parser('project_exclusive', str(global_vars.project_type),
"project", "giswater")
if project_exclusive not in (None, 'None'):
project_exclusive = project_exclusive.replace(' ', '').split(',')
for index_action in buttons_toolbar:
if index_action in project_exclusive:
continue
icon_path = f"{icon_folder}{os.sep}toolbars{os.sep}{toolbar}{os.sep}{index_action}.png"
icon = QIcon(icon_path)
button_def = global_vars.giswater_settings.value(f"buttons_def/{index_action}")
text = ""
if button_def:
text = self._translate(f'{index_action}_text')
parent = self.iface.mainWindow()
ag = QActionGroup(parent)
ag.setProperty('gw_name', 'gw_QActionGroup')
if button_def is None:
continue
# Check if the class associated to the button definition exists
if hasattr(buttons, button_def):
button_class = getattr(buttons, button_def)
action_function = button_class(icon_path, button_def, text, None, ag)
action = toolbar_submenu.addAction(icon, f"{text}")
shortcut_key = tools_gw.get_config_parser("toolbars_shortcuts", f"{index_action}", "user", "init", prefix=False)
if shortcut_key:
action.setShortcuts(QKeySequence(f"{shortcut_key}"))
global_vars.shortcut_keys.append(shortcut_key)
action.triggered.connect(partial(self._clicked_event, action_function))
else:
tools_log.log_warning(f"Class '{button_def}' not imported in file '{buttons.__file__}'")
# endregion
# region Actions
actions_menu = QMenu(f"Actions", self.iface.mainWindow().menuBar())
actions_menu.setIcon(config_icon)
self.main_menu.addMenu(actions_menu)
# Action 'Get help'
action_help = actions_menu.addAction(f"Get help")
action_help_shortcut = tools_gw.get_config_parser("actions_shortcuts", f"shortcut_help", "user", "init", prefix=False)
if not action_help_shortcut:
tools_gw.set_config_parser("actions_shortcuts", f"shortcut_help", f"{action_help_shortcut}", "user", "init",
prefix=False)
action_help.setShortcuts(QKeySequence(f"{action_help_shortcut}"))
action_help.triggered.connect(tools_gw.open_dlg_help)
# Action 'Reset dialogs'
action_reset_dialogs = actions_menu.addAction(f"Reset dialogs")
action_reset_dialogs.triggered.connect(self._reset_position_dialog)
# Action 'Reset plugin
action_reset_plugin = actions_menu.addAction(f"Reset plugin")
action_reset_plugin_shortcut = tools_gw.get_config_parser("actions_shortcuts", f"shortcut_reset_plugin",
"user", "init", prefix=False)
if not action_reset_plugin_shortcut:
tools_gw.set_config_parser("actions_shortcuts", f"shortcut_reset_plugin",
f"{action_reset_plugin_shortcut}", "user", "init", prefix=False)
action_reset_plugin.setShortcuts(QKeySequence(f"{action_reset_plugin_shortcut}"))
action_reset_plugin.triggered.connect(self._reset_plugin)
# Action 'Show current selectors'
action_open_selections = actions_menu.addAction(f"Show current selectors")
action_open_selections_shortcut = tools_gw.get_config_parser("actions_shortcuts",
f"shortcut_open_curselectors", "user", "init", prefix=False)
if not action_open_selections_shortcut:
tools_gw.set_config_parser("actions_shortcuts", f"shortcut_open_curselectors",
f"{action_open_selections_shortcut}", "user", "init", prefix=False)
action_open_selections.setShortcuts(QKeySequence(f"{action_open_selections_shortcut}"))
action_open_selections.triggered.connect(self._open_current_selections)
# Action 'Toggle Log DB'
action_set_log_sql = actions_menu.addAction(f"Toggle Log DB")
log_sql_shortcut = tools_gw.get_config_parser("actions_shortcuts", f"shortcut_toggle_log_db", "user", "init", prefix=False)
if not log_sql_shortcut:
tools_gw.set_config_parser("actions_shortcuts", f"shortcut_toggle_log_db", f"{log_sql_shortcut}", "user",
"init", prefix=False)
action_set_log_sql.setShortcuts(QKeySequence(f"{log_sql_shortcut}"))
action_set_log_sql.triggered.connect(self._set_log_sql)
# endregion
# region Advanced
action_manage_file = self.main_menu.addAction(f"Advanced")
action_manage_file.triggered.connect(self._open_manage_file)
icon_path = f"{icon_folder}{os.sep}dialogs{os.sep}20x20{os.sep}105.png"
folder_icon = QIcon(icon_path)
action_manage_file.setIcon(folder_icon)
# endregion
# region Open user folder
if global_vars.user_folder_dir:
log_folder = os.path.join(global_vars.user_folder_dir, 'log')
size = tools_os.get_folder_size(log_folder)
log_folder_volume = f"{round(size / (1024 * 1024), 2)} MB"
icon_path = f"{icon_folder}{os.sep}dialogs{os.sep}20x20{os.sep}102.png"
folder_icon = QIcon(icon_path)
action_open_path = self.main_menu.addAction(f"Open folder ({log_folder_volume})")
action_open_path.setIcon(folder_icon)
action_open_path.triggered.connect(self._open_config_path)
# endregion
self.iface.mainWindow().menuBar().insertMenu(last_action, self.main_menu)
def __init__(self, iface, parent=None):
"""Constructor."""
super(FlowEstimatorDialog, self).__init__(parent)
# Set up the user interface from Designer.
# After setupUI you can access any designer object by doing
# self.<objectname>, and you can use autoconnect slots - see
# http://qt-project.org/doc/qt-4.8/designer-using-a-ui-file.html
# #widgets-and-dialogs-with-auto-connect
#QDialog.__init__(self, None, Qt.WindowStaysOnTopHint)
self.iface = iface
self.setupUi(self)
self.btnOk = self.buttonBox.button(QDialogButtonBox.Save)
#ajh: it seems this wasn't working, so I have changed from a stock OK button to a stock Save button
#self.btnOk.setText("Save Data")
self.btnClose = self.buttonBox.button(QDialogButtonBox.Close)
self.btnBrowse.clicked.connect(self.writeDirName)
self.btnLoadTXT.clicked.connect(self.loadTxt)
# ajh trying to make it work
#self.inputFile.textChanged.connect(self.run)
self.btnSampleLine.setEnabled(False)
self.btnSampleSlope.setEnabled(False)
self.calcType = 'Trap'
# add shortcut keys to zoom in the documentation tab, because why not?
# pinch zoom and crtl+scroll already work by default, although zooming is impossible if a font size is set
# I guess it would be nice to add zooming to the context menu too, or provide buttons
QShortcut(QKeySequence('Ctrl++'), self.textBrowser,
self.textBrowser.zoomIn)
QShortcut(QKeySequence('Ctrl+-'), self.textBrowser,
self.textBrowser.zoomOut)
# add matplotlib figure to dialog
self.figure = Figure()
# this controls the size of the whole dialog; if we get resizing working again I guess we need to add `, forward=True`
self.figure.set_size_inches(6, 2.8)
self.axes = self.figure.add_subplot(111)
self.figure.subplots_adjust(left=.12,
bottom=0.15,
right=.75,
top=.9,
wspace=None,
hspace=.2)
self.mplCanvas = FigureCanvas(self.figure)
#self.widgetPlotToolbar = NavigationToolbar(self.mplCanvas, self.widgetPlot)
#lstActions = self.widgetPlotToolbar.actions()
#self.widgetPlotToolbar.removeAction(lstActions[7])
self.vLayout.addWidget(self.mplCanvas)
self.vLayout.minimumSize()
#self.vLayout.addWidget(self.widgetPlotToolbar)
# ajh: change the colours; perhaps we could use a stylesheet instead
# ajh: can change the colour outside the actual graph like this
#self.figure.patch.set_facecolor("blue")
# ajh: default transparency is 1.0; good since otherwise the exported graphs have illegible axes in Windows explorer preview due to being fully transparent, and in QGIS if using a dark theme.
#self.figure.patch.set_alpha(0.5)
# ajh: patch (fill) is shown by default; good as per comment above
#self.figure.patch.set_visible(False)
# ajh: can change the background colour of the main plot like this:
#self.axes.set_facecolor("#eafff5")
# ajh: these don't seem to do anything
#self.axes.patch.set_facecolor("#eafff5")
#self.axes.patch.set_visible(True)
#self.axes.patch.set_alpha(0.0)
# and configure matplotlib params
# rcParams["font.serif"] = "Verdana, Arial, Liberation Serif"
# rcParams["font.sans-serif"] = "Tahoma, Arial, Liberation Sans"
# rcParams["font.cursive"] = "Courier New, Arial, Liberation Sans"
# rcParams["font.fantasy"] = "Comic Sans MS, Arial, Liberation Sans"
# rcParams["font.monospace"] = "Courier New, Liberation Mono"
#
#print self.cbDEM.changeEvent
self.depth.valueChanged.connect(self.run)
self.botWidth.valueChanged.connect(self.run)
self.leftSS.valueChanged.connect(self.run)
self.rightSS.valueChanged.connect(self.run)
self.n.valueChanged.connect(self.run)
self.slope.valueChanged.connect(self.run)
self.cbWSE.valueChanged.connect(self.run)
self.ft.clicked.connect(self.run)
self.m.clicked.connect(self.run)
self.cbUDwse.valueChanged.connect(self.run)
# ajh: this doesn't fix it
#self.btnRefresh.clicked.connect(self.run)
# it seems nothing has the keyboard focus initially unless we set it manually
self.tabWidget.setFocus()
self.manageGui()
# ajh: I thought this would work around the crashes, but it doesn't work properly - it only sets a maximum size (almost - it can still be made slightly taller!)
#self.setFixedSize(self.size())
# even this doesn't help
#self.setMinimumSize(self.size())
self.btnSampleLine.clicked.connect(self.sampleLine)
self.btnSampleSlope.clicked.connect(self.sampleSlope)
def initGui(self):
self.initProcessing()
plugin_dir = str(Path(__file__).resolve().parent)
main_icon = QIcon(os.path.join(plugin_dir, "icon.png"))
# Open the online help
if Qgis.QGIS_VERSION_INT >= 31000:
self.help_action_about_menu = QAction(main_icon, 'Cadastre', self.iface.mainWindow())
self.iface.pluginHelpMenu().addAction(self.help_action_about_menu)
self.help_action_about_menu.triggered.connect(self.open_help)
actions = {
"import_action": (
"database.png",
"Importer des données",
"",
self.open_import_dialog,
True
),
"search_action": (
"search.png",
"Outils de recherche",
"",
self.toggle_search_dialog,
True
),
"load_action": (
"output.png",
"Charger des données",
"",
self.open_load_dialog,
True
),
"export_action": (
"mActionSaveAsPDF.png",
"Exporter la vue",
"",
self.export_view,
True
),
"option_action": (
"config.png",
"Configurer le plugin",
"",
self.open_option_dialog,
True
),
"about_action": (
"about.png",
"À propos",
"",
self.open_about_dialog,
True
),
"help_action": (
"about.png",
"Aide",
"",
self.open_help,
True
),
"version_action": (
"about.png",
"Notes de version",
"",
self.open_message_dialog,
True
)
}
for key in actions:
icon_path = os.path.join(plugin_dir, 'icons', actions[key][0])
icon = QIcon(icon_path)
action = QAction(QIcon(icon), actions[key][1], self.iface.mainWindow())
if actions[key][2] != "":
action.setShortcut(QKeySequence(actions[key][2]))
setattr(self, key, action)
action.setEnabled(actions[key][4])
action.setObjectName(key)
action.triggered.connect(actions[key][3])
if not self.cadastre_search_dialog:
dialog = CadastreSearchDialog(self.iface)
self.cadastre_search_dialog = dialog
self.menu = QMenu("&Cadastre")
self.menu.setObjectName("Cadastre")
self.menu.setIcon(main_icon)
# Add Cadastre to Extension menu
self.menu.addAction(self.import_action)
self.menu.addAction(self.load_action)
self.menu.addSeparator()
self.menu.addAction(self.search_action)
self.menu.addAction(self.export_action)
self.menu.addSeparator()
self.menu.addAction(self.option_action)
self.menu.addAction(self.about_action)
self.menu.addAction(self.version_action)
self.menu.addAction(self.help_action)
menuBar = self.iface.mainWindow().menuBar()
menu = menuBar
for child in menuBar.children():
if child.objectName() == "mPluginMenu":
menu = child
break
menu.addMenu(self.menu)
# Add cadastre toolbar
self.toolbar = self.iface.addToolBar('&Cadastre')
self.toolbar.setObjectName("cadastreToolbar")
# Create action for "Parcelle information"
self.identifyParcelleAction = QAction(
QIcon(os.path.join(
plugin_dir,
"icons",
"toolbar",
"get-parcelle-info.png"
)),
"Infos parcelle",
self.iface.mainWindow()
)
self.identifyParcelleAction.setCheckable(True)
self.identifyParcelleAction.triggered.connect(self.setIndentifyParcelleTool)
self.toolbar.addAction(self.import_action)
self.toolbar.addAction(self.load_action)
self.toolbar.addSeparator()
self.toolbar.addAction(self.search_action)
self.toolbar.addAction(self.identifyParcelleAction)
self.toolbar.addAction(self.export_action)
self.toolbar.addSeparator()
self.toolbar.addAction(self.option_action)
self.toolbar.addAction(self.about_action)
self.setActionsExclusive()
# Disable some dialogs on CI : about and changelog
on_ci = os.getenv("QGIS_TESTING") == 'True'
# Display About window on first use
s = QSettings()
firstUse = s.value("cadastre/isFirstUse", 1, type=int)
if firstUse == 1 and not on_ci:
s.setValue("cadastre/isFirstUse", 0)
self.open_about_dialog()
# Display some messages depending on version number
mConfig = configparser.ConfigParser()
metadataFile = plugin_dir + "/metadata.txt"
mConfig.read(metadataFile, encoding='utf-8')
self.mConfig = mConfig
if not on_ci:
myVersion = mConfig.get('general', 'version').replace('.', '_')
myVersionMsg = s.value("cadastre/version_%s" % myVersion, 1, type=int)
if myVersionMsg == 1:
s.setValue("cadastre/version_%s" % myVersion, 0)
self.open_message_dialog()
# Project load or create : refresh search and identify tool
self.iface.projectRead.connect(self.onProjectRead)
self.iface.newProjectCreated.connect(self.onNewProjectCreated)
# Delete layers from table when deleted from registry
lr = QgsProject.instance()
lr.layersRemoved.connect(self.checkIdentifyParcelleTool)
self.updateSearchButton()
self.cadastre_search_dialog.visibilityChanged.connect(self.updateSearchButton)
def updateShortcutText(self):
self.keySequence = QKeySequence(self.modifiers + self.key)
#this uses QKeySequence.NativeText to show in the interface. To store data, no filter should be provided
self.assignShortcutPushButton.setText(
self.tr('Input: {0}').format(
self.keySequence.toString(format=QKeySequence.NativeText)))
def __init__(self, model=None):
super().__init__(None)
self.setAttribute(Qt.WA_DeleteOnClose)
self.setupUi(self)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.centralWidget().layout().insertWidget(0, self.bar)
try:
self.setDockOptions(self.dockOptions()
| QMainWindow.GroupedDragging)
except:
pass
self.mToolbar.setIconSize(iface.iconSize())
self.mActionOpen.setIcon(
QgsApplication.getThemeIcon('/mActionFileOpen.svg'))
self.mActionSave.setIcon(
QgsApplication.getThemeIcon('/mActionFileSave.svg'))
self.mActionSaveAs.setIcon(
QgsApplication.getThemeIcon('/mActionFileSaveAs.svg'))
self.mActionZoomActual.setIcon(
QgsApplication.getThemeIcon('/mActionZoomActual.svg'))
self.mActionZoomIn.setIcon(
QgsApplication.getThemeIcon('/mActionZoomIn.svg'))
self.mActionZoomOut.setIcon(
QgsApplication.getThemeIcon('/mActionZoomOut.svg'))
self.mActionExportImage.setIcon(
QgsApplication.getThemeIcon('/mActionSaveMapAsImage.svg'))
self.mActionZoomToItems.setIcon(
QgsApplication.getThemeIcon('/mActionZoomFullExtent.svg'))
self.mActionExportPdf.setIcon(
QgsApplication.getThemeIcon('/mActionSaveAsPDF.svg'))
self.mActionExportSvg.setIcon(
QgsApplication.getThemeIcon('/mActionSaveAsSVG.svg'))
#self.mActionExportPython.setIcon(
# QgsApplication.getThemeIcon('/mActionSaveAsPython.svg'))
self.mActionEditHelp.setIcon(
QgsApplication.getThemeIcon('/mActionEditHelpContent.svg'))
self.mActionRun.setIcon(
QgsApplication.getThemeIcon('/mActionStart.svg'))
self.addDockWidget(Qt.LeftDockWidgetArea, self.propertiesDock)
self.addDockWidget(Qt.LeftDockWidgetArea, self.inputsDock)
self.addDockWidget(Qt.LeftDockWidgetArea, self.algorithmsDock)
self.tabifyDockWidget(self.inputsDock, self.algorithmsDock)
self.inputsDock.raise_()
self.zoom = 1
self.setWindowFlags(Qt.WindowMinimizeButtonHint
| Qt.WindowMaximizeButtonHint
| Qt.WindowCloseButtonHint)
settings = QgsSettings()
self.restoreState(
settings.value("/Processing/stateModeler", QByteArray()))
self.restoreGeometry(
settings.value("/Processing/geometryModeler", QByteArray()))
self.scene = ModelerScene(self, dialog=self)
self.scene.setSceneRect(
QRectF(0, 0, self.CANVAS_SIZE, self.CANVAS_SIZE))
self.view.setScene(self.scene)
self.view.setAcceptDrops(True)
self.view.ensureVisible(0, 0, 10, 10)
def _dragEnterEvent(event):
if event.mimeData().hasText():
event.acceptProposedAction()
else:
event.ignore()
def _dropEvent(event):
if event.mimeData().hasText():
itemId = event.mimeData().text()
if itemId in [
param.id() for param in QgsApplication.instance().
processingRegistry().parameterTypes()
]:
self.addInputOfType(itemId, event.pos())
else:
alg = QgsApplication.processingRegistry(
).createAlgorithmById(itemId)
if alg is not None:
self._addAlgorithm(alg, event.pos())
event.accept()
else:
event.ignore()
def _dragMoveEvent(event):
if event.mimeData().hasText():
event.accept()
else:
event.ignore()
def _wheelEvent(event):
self.view.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
settings = QgsSettings()
factor = settings.value('/qgis/zoom_favor', 2.0)
# "Normal" mouse has an angle delta of 120, precision mouses provide data
# faster, in smaller steps
factor = 1.0 + (factor - 1.0) / 120.0 * abs(event.angleDelta().y())
if (event.modifiers() == Qt.ControlModifier):
factor = 1.0 + (factor - 1.0) / 20.0
if event.angleDelta().y() < 0:
factor = 1 / factor
self.view.scale(factor, factor)
def _enterEvent(e):
QGraphicsView.enterEvent(self.view, e)
self.view.viewport().setCursor(Qt.ArrowCursor)
def _mouseReleaseEvent(e):
QGraphicsView.mouseReleaseEvent(self.view, e)
self.view.viewport().setCursor(Qt.ArrowCursor)
def _mousePressEvent(e):
if e.button() == Qt.MidButton:
self.previousMousePos = e.pos()
else:
QGraphicsView.mousePressEvent(self.view, e)
def _mouseMoveEvent(e):
if e.buttons() == Qt.MidButton:
offset = self.previousMousePos - e.pos()
self.previousMousePos = e.pos()
self.view.verticalScrollBar().setValue(
self.view.verticalScrollBar().value() + offset.y())
self.view.horizontalScrollBar().setValue(
self.view.horizontalScrollBar().value() + offset.x())
else:
QGraphicsView.mouseMoveEvent(self.view, e)
self.view.setDragMode(QGraphicsView.ScrollHandDrag)
self.view.dragEnterEvent = _dragEnterEvent
self.view.dropEvent = _dropEvent
self.view.dragMoveEvent = _dragMoveEvent
self.view.wheelEvent = _wheelEvent
self.view.enterEvent = _enterEvent
self.view.mousePressEvent = _mousePressEvent
self.view.mouseMoveEvent = _mouseMoveEvent
def _mimeDataInput(items):
mimeData = QMimeData()
text = items[0].data(0, Qt.UserRole)
mimeData.setText(text)
return mimeData
self.inputsTree.mimeData = _mimeDataInput
self.inputsTree.setDragDropMode(QTreeWidget.DragOnly)
self.inputsTree.setDropIndicatorShown(True)
def _mimeDataAlgorithm(items):
item = items[0]
mimeData = None
if isinstance(item, TreeAlgorithmItem):
mimeData = QMimeData()
mimeData.setText(item.alg.id())
return mimeData
self.algorithmTree.mimeData = _mimeDataAlgorithm
self.algorithmTree.setDragDropMode(QTreeWidget.DragOnly)
self.algorithmTree.setDropIndicatorShown(True)
if hasattr(self.searchBox, 'setPlaceholderText'):
self.searchBox.setPlaceholderText(
QCoreApplication.translate('ModelerDialog', 'Search…'))
if hasattr(self.textName, 'setPlaceholderText'):
self.textName.setPlaceholderText(self.tr('Enter model name here'))
if hasattr(self.textGroup, 'setPlaceholderText'):
self.textGroup.setPlaceholderText(self.tr('Enter group name here'))
# Connect signals and slots
self.inputsTree.doubleClicked.connect(self.addInput)
self.searchBox.textChanged.connect(self.textChanged)
self.algorithmTree.doubleClicked.connect(self.addAlgorithm)
# Ctrl+= should also trigger a zoom in action
ctrlEquals = QShortcut(QKeySequence("Ctrl+="), self)
ctrlEquals.activated.connect(self.zoomIn)
self.mActionOpen.triggered.connect(self.openModel)
self.mActionSave.triggered.connect(self.save)
self.mActionSaveAs.triggered.connect(self.saveAs)
self.mActionZoomIn.triggered.connect(self.zoomIn)
self.mActionZoomOut.triggered.connect(self.zoomOut)
self.mActionZoomActual.triggered.connect(self.zoomActual)
self.mActionZoomToItems.triggered.connect(self.zoomToItems)
self.mActionExportImage.triggered.connect(self.exportAsImage)
self.mActionExportPdf.triggered.connect(self.exportAsPdf)
self.mActionExportSvg.triggered.connect(self.exportAsSvg)
#self.mActionExportPython.triggered.connect(self.exportAsPython)
self.mActionEditHelp.triggered.connect(self.editHelp)
self.mActionRun.triggered.connect(self.runModel)
if model is not None:
self.model = model.create()
self.model.setSourceFilePath(model.sourceFilePath())
self.textGroup.setText(self.model.group())
self.textName.setText(self.model.displayName())
self.repaintModel()
else:
self.model = QgsProcessingModelAlgorithm()
self.model.setProvider(
QgsApplication.processingRegistry().providerById('model'))
self.fillInputsTree()
self.fillTreeUsingProviders()
self.view.centerOn(0, 0)
self.help = None
self.hasChanged = False
class ShortcutChooserWidget(QtWidgets.QWidget, FORM_CLASS):
keyPressed = pyqtSignal()
def __init__(self, parent=None):
"""
Initializates ShortcutChooserWidget
"""
super(ShortcutChooserWidget, self).__init__(parent)
self.resetVariables()
self.setupUi(self)
@pyqtSlot(bool)
def on_assignShortcutPushButton_clicked(self):
"""
After button is clicked, focus is needed to use keyPressEvent and keyReleaseEvent
"""
self.setFocus()
@pyqtSlot(bool)
def on_assignShortcutPushButton_toggled(self, toggled):
"""
Button toggled reset self.modifiers and self.keys and also prepairs button text
"""
if toggled:
self.resetVariables()
self.assignShortcutPushButton.setText(self.tr('Enter Value'))
@pyqtSlot(bool, name='on_clearPushButton_clicked')
def clearAll(self):
"""
Clears push button and also resets self.modifiers and self.keys
"""
self.assignShortcutPushButton.setChecked(False)
self.assignShortcutPushButton.setText(self.tr('Assign Shortcut'))
self.resetVariables()
def resetVariables(self):
"""
Resets self.modifiers, self.key and self.keySequence to 0
"""
self.modifiers = 0
self.key = 0
self.keySequence = 0
def keyPressEvent(self, event):
"""
"""
if not self.assignShortcutPushButton.isChecked():
super(ShortcutChooserWidget, self).keyPressEvent(event)
return
key = int(event.key())
if key == Qt.Key_Meta:
self.modifiers |= Qt.META
self.updateShortcutText()
elif key == Qt.Key_Alt:
self.modifiers |= Qt.ALT
self.updateShortcutText()
elif key == Qt.Key_Control:
self.modifiers |= Qt.CTRL
self.updateShortcutText()
elif key == Qt.Key_Shift:
self.modifiers |= Qt.SHIFT
self.updateShortcutText()
elif key == Qt.Key_Escape:
self.assignShortcutPushButton.setChecked(False)
return
else:
self.key = key
self.updateShortcutText()
def keyReleaseEvent(self, event):
if not self.assignShortcutPushButton.isChecked():
super(ShortcutChooserWidget, self).keyReleaseEvent(event)
return
key = event.key()
if key == Qt.Key_Meta:
self.modifiers &= Qt.META
self.updateShortcutText()
elif key == Qt.Key_Alt:
self.modifiers &= Qt.ALT
self.updateShortcutText()
elif key == Qt.Key_Control:
self.modifiers &= Qt.CTRL
self.updateShortcutText()
elif key == Qt.Key_Shift:
self.modifiers &= Qt.SHIFT
self.updateShortcutText()
elif key == Qt.Key_Escape:
return
else:
self.assignShortcutPushButton.setChecked(False)
self.updateShortcutText()
self.setShortcut(self.keySequence)
def setEnabled(self, enabled):
if not enabled:
self.clearAll()
super(ShortcutChooserWidget, self).setEnabled(enabled)
def setShortcut(self, shortcut):
self.keySequence = QKeySequence(shortcut)
self.assignShortcutPushButton.setChecked(False)
self.assignShortcutPushButton.setText(
self.keySequence.toString(format=QKeySequence.NativeText))
def getShortcut(self, asQKeySequence=False):
if asQKeySequence:
return self.keySequence
else:
return int(self.keySequence)
def updateShortcutText(self):
self.keySequence = QKeySequence(self.modifiers + self.key)
#this uses QKeySequence.NativeText to show in the interface. To store data, no filter should be provided
self.assignShortcutPushButton.setText(
self.tr('Input: {0}').format(
self.keySequence.toString(format=QKeySequence.NativeText)))
"First select a vector layer in the layers panel.")
return
if activeLayerId != aLayer.id():
activeLayerId = aLayer.id()
myIt = None
if not myIt:
request = QgsFeatureRequest().setFlags(
QgsFeatureRequest.NoGeometry).setNoAttributes()
myIt = aLayer.getFeatures(request)
feat = next(myIt, None)
if feat:
aLayer.selectByIds([feat.id()])
if aLayer.geometryType() == QgsWkbTypes.PointGeometry:
iface.actionPanToSelected().trigger() # Pan to points
else:
iface.actionZoomToSelected().trigger() # Zoom to the rest
else:
iface.messageBar().pushInfo("Feature iterator",
"We reached the last feature of this layer already.\n" + \
"If you want to restart press the Escape key.")
shortcutEscape = QShortcut(QKeySequence(Qt.Key_Escape), iface.mapCanvas())
shortcutEscape.setContext(Qt.ApplicationShortcut)
shortcutEscape.activated.connect(escapePressed)
shortcutSpaceBar = QShortcut(QKeySequence(Qt.Key_Space), iface.mapCanvas())
shortcutSpaceBar.setContext(Qt.ApplicationShortcut)
shortcutSpaceBar.activated.connect(spaceBarPressed)
def __init__(self, model=None):
super().__init__(None)
self.setAttribute(Qt.WA_DeleteOnClose)
self.setupUi(self)
# LOTS of bug reports when we include the dock creation in the UI file
# see e.g. #16428, #19068
# So just roll it all by hand......!
self.propertiesDock = QgsDockWidget(self)
self.propertiesDock.setFeatures(
QDockWidget.DockWidgetFloatable | QDockWidget.DockWidgetMovable)
self.propertiesDock.setObjectName("propertiesDock")
propertiesDockContents = QWidget()
self.verticalDockLayout_1 = QVBoxLayout(propertiesDockContents)
self.verticalDockLayout_1.setContentsMargins(0, 0, 0, 0)
self.verticalDockLayout_1.setSpacing(0)
self.scrollArea_1 = QgsScrollArea(propertiesDockContents)
sizePolicy = QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.scrollArea_1.sizePolicy().hasHeightForWidth())
self.scrollArea_1.setSizePolicy(sizePolicy)
self.scrollArea_1.setFocusPolicy(Qt.WheelFocus)
self.scrollArea_1.setFrameShape(QFrame.NoFrame)
self.scrollArea_1.setFrameShadow(QFrame.Plain)
self.scrollArea_1.setWidgetResizable(True)
self.scrollAreaWidgetContents_1 = QWidget()
self.gridLayout = QGridLayout(self.scrollAreaWidgetContents_1)
self.gridLayout.setContentsMargins(6, 6, 6, 6)
self.gridLayout.setSpacing(4)
self.label_1 = QLabel(self.scrollAreaWidgetContents_1)
self.gridLayout.addWidget(self.label_1, 0, 0, 1, 1)
self.textName = QLineEdit(self.scrollAreaWidgetContents_1)
self.gridLayout.addWidget(self.textName, 0, 1, 1, 1)
self.label_2 = QLabel(self.scrollAreaWidgetContents_1)
self.gridLayout.addWidget(self.label_2, 1, 0, 1, 1)
self.textGroup = QLineEdit(self.scrollAreaWidgetContents_1)
self.gridLayout.addWidget(self.textGroup, 1, 1, 1, 1)
self.label_1.setText(self.tr("Name"))
self.textName.setToolTip(self.tr("Enter model name here"))
self.label_2.setText(self.tr("Group"))
self.textGroup.setToolTip(self.tr("Enter group name here"))
self.scrollArea_1.setWidget(self.scrollAreaWidgetContents_1)
self.verticalDockLayout_1.addWidget(self.scrollArea_1)
self.propertiesDock.setWidget(propertiesDockContents)
self.addDockWidget(Qt.DockWidgetArea(1), self.propertiesDock)
self.propertiesDock.setWindowTitle(self.tr("Model properties"))
self.inputsDock = QgsDockWidget(self)
self.inputsDock.setFeatures(QDockWidget.DockWidgetFloatable | QDockWidget.DockWidgetMovable)
self.inputsDock.setObjectName("inputsDock")
self.inputsDockContents = QWidget()
self.verticalLayout_3 = QVBoxLayout(self.inputsDockContents)
self.verticalLayout_3.setContentsMargins(0, 0, 0, 0)
self.scrollArea_2 = QgsScrollArea(self.inputsDockContents)
sizePolicy.setHeightForWidth(self.scrollArea_2.sizePolicy().hasHeightForWidth())
self.scrollArea_2.setSizePolicy(sizePolicy)
self.scrollArea_2.setFocusPolicy(Qt.WheelFocus)
self.scrollArea_2.setFrameShape(QFrame.NoFrame)
self.scrollArea_2.setFrameShadow(QFrame.Plain)
self.scrollArea_2.setWidgetResizable(True)
self.scrollAreaWidgetContents_2 = QWidget()
self.verticalLayout = QVBoxLayout(self.scrollAreaWidgetContents_2)
self.verticalLayout.setContentsMargins(0, 0, 0, 0)
self.verticalLayout.setSpacing(0)
self.inputsTree = QTreeWidget(self.scrollAreaWidgetContents_2)
self.inputsTree.setAlternatingRowColors(True)
self.inputsTree.header().setVisible(False)
self.verticalLayout.addWidget(self.inputsTree)
self.scrollArea_2.setWidget(self.scrollAreaWidgetContents_2)
self.verticalLayout_3.addWidget(self.scrollArea_2)
self.inputsDock.setWidget(self.inputsDockContents)
self.addDockWidget(Qt.DockWidgetArea(1), self.inputsDock)
self.inputsDock.setWindowTitle(self.tr("Inputs"))
self.algorithmsDock = QgsDockWidget(self)
self.algorithmsDock.setFeatures(QDockWidget.DockWidgetFloatable | QDockWidget.DockWidgetMovable)
self.algorithmsDock.setObjectName("algorithmsDock")
self.algorithmsDockContents = QWidget()
self.verticalLayout_4 = QVBoxLayout(self.algorithmsDockContents)
self.verticalLayout_4.setContentsMargins(0, 0, 0, 0)
self.scrollArea_3 = QgsScrollArea(self.algorithmsDockContents)
sizePolicy.setHeightForWidth(self.scrollArea_3.sizePolicy().hasHeightForWidth())
self.scrollArea_3.setSizePolicy(sizePolicy)
self.scrollArea_3.setFocusPolicy(Qt.WheelFocus)
self.scrollArea_3.setFrameShape(QFrame.NoFrame)
self.scrollArea_3.setFrameShadow(QFrame.Plain)
self.scrollArea_3.setWidgetResizable(True)
self.scrollAreaWidgetContents_3 = QWidget()
self.verticalLayout_2 = QVBoxLayout(self.scrollAreaWidgetContents_3)
self.verticalLayout_2.setContentsMargins(0, 0, 0, 0)
self.verticalLayout_2.setSpacing(4)
self.searchBox = QgsFilterLineEdit(self.scrollAreaWidgetContents_3)
self.verticalLayout_2.addWidget(self.searchBox)
self.algorithmTree = QgsProcessingToolboxTreeView(None,
QgsApplication.processingRegistry())
self.algorithmTree.setAlternatingRowColors(True)
self.algorithmTree.header().setVisible(False)
self.verticalLayout_2.addWidget(self.algorithmTree)
self.scrollArea_3.setWidget(self.scrollAreaWidgetContents_3)
self.verticalLayout_4.addWidget(self.scrollArea_3)
self.algorithmsDock.setWidget(self.algorithmsDockContents)
self.addDockWidget(Qt.DockWidgetArea(1), self.algorithmsDock)
self.algorithmsDock.setWindowTitle(self.tr("Algorithms"))
self.searchBox.setToolTip(self.tr("Enter algorithm name to filter list"))
self.searchBox.setShowSearchIcon(True)
self.bar = QgsMessageBar()
self.bar.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed)
self.centralWidget().layout().insertWidget(0, self.bar)
try:
self.setDockOptions(self.dockOptions() | QMainWindow.GroupedDragging)
except:
pass
if iface is not None:
self.mToolbar.setIconSize(iface.iconSize())
self.setStyleSheet(iface.mainWindow().styleSheet())
self.mActionOpen.setIcon(
QgsApplication.getThemeIcon('/mActionFileOpen.svg'))
self.mActionSave.setIcon(
QgsApplication.getThemeIcon('/mActionFileSave.svg'))
self.mActionSaveAs.setIcon(
QgsApplication.getThemeIcon('/mActionFileSaveAs.svg'))
self.mActionSaveInProject.setIcon(
QgsApplication.getThemeIcon('/mAddToProject.svg'))
self.mActionZoomActual.setIcon(
QgsApplication.getThemeIcon('/mActionZoomActual.svg'))
self.mActionZoomIn.setIcon(
QgsApplication.getThemeIcon('/mActionZoomIn.svg'))
self.mActionZoomOut.setIcon(
QgsApplication.getThemeIcon('/mActionZoomOut.svg'))
self.mActionExportImage.setIcon(
QgsApplication.getThemeIcon('/mActionSaveMapAsImage.svg'))
self.mActionZoomToItems.setIcon(
QgsApplication.getThemeIcon('/mActionZoomFullExtent.svg'))
self.mActionExportPdf.setIcon(
QgsApplication.getThemeIcon('/mActionSaveAsPDF.svg'))
self.mActionExportSvg.setIcon(
QgsApplication.getThemeIcon('/mActionSaveAsSVG.svg'))
#self.mActionExportPython.setIcon(
# QgsApplication.getThemeIcon('/mActionSaveAsPython.svg'))
self.mActionEditHelp.setIcon(
QgsApplication.getThemeIcon('/mActionEditHelpContent.svg'))
self.mActionRun.setIcon(
QgsApplication.getThemeIcon('/mActionStart.svg'))
self.addDockWidget(Qt.LeftDockWidgetArea, self.propertiesDock)
self.addDockWidget(Qt.LeftDockWidgetArea, self.inputsDock)
self.addDockWidget(Qt.LeftDockWidgetArea, self.algorithmsDock)
self.tabifyDockWidget(self.inputsDock, self.algorithmsDock)
self.inputsDock.raise_()
self.zoom = 1
self.setWindowFlags(Qt.WindowMinimizeButtonHint |
Qt.WindowMaximizeButtonHint |
Qt.WindowCloseButtonHint)
settings = QgsSettings()
self.restoreState(settings.value("/Processing/stateModeler", QByteArray()))
self.restoreGeometry(settings.value("/Processing/geometryModeler", QByteArray()))
self.scene = ModelerScene(self, dialog=self)
self.scene.setSceneRect(QRectF(0, 0, self.CANVAS_SIZE, self.CANVAS_SIZE))
self.view.setScene(self.scene)
self.view.setAcceptDrops(True)
self.view.ensureVisible(0, 0, 10, 10)
def _dragEnterEvent(event):
if event.mimeData().hasText() or event.mimeData().hasFormat('application/x-vnd.qgis.qgis.algorithmid'):
event.acceptProposedAction()
else:
event.ignore()
def _dropEvent(event):
if event.mimeData().hasFormat('application/x-vnd.qgis.qgis.algorithmid'):
data = event.mimeData().data('application/x-vnd.qgis.qgis.algorithmid')
stream = QDataStream(data, QIODevice.ReadOnly)
algorithm_id = stream.readQString()
alg = QgsApplication.processingRegistry().createAlgorithmById(algorithm_id)
if alg is not None:
self._addAlgorithm(alg, event.pos())
else:
assert False, algorithm_id
elif event.mimeData().hasText():
itemId = event.mimeData().text()
if itemId in [param.id() for param in QgsApplication.instance().processingRegistry().parameterTypes()]:
self.addInputOfType(itemId, event.pos())
event.accept()
else:
event.ignore()
def _dragMoveEvent(event):
if event.mimeData().hasText() or event.mimeData().hasFormat('application/x-vnd.qgis.qgis.algorithmid'):
event.accept()
else:
event.ignore()
def _wheelEvent(event):
self.view.setTransformationAnchor(QGraphicsView.AnchorUnderMouse)
settings = QgsSettings()
factor = settings.value('/qgis/zoom_favor', 2.0)
# "Normal" mouse has an angle delta of 120, precision mouses provide data
# faster, in smaller steps
factor = 1.0 + (factor - 1.0) / 120.0 * abs(event.angleDelta().y())
if (event.modifiers() == Qt.ControlModifier):
factor = 1.0 + (factor - 1.0) / 20.0
if event.angleDelta().y() < 0:
factor = 1 / factor
self.view.scale(factor, factor)
def _enterEvent(e):
QGraphicsView.enterEvent(self.view, e)
self.view.viewport().setCursor(Qt.ArrowCursor)
def _mouseReleaseEvent(e):
QGraphicsView.mouseReleaseEvent(self.view, e)
self.view.viewport().setCursor(Qt.ArrowCursor)
def _mousePressEvent(e):
if e.button() == Qt.MidButton:
self.previousMousePos = e.pos()
else:
QGraphicsView.mousePressEvent(self.view, e)
def _mouseMoveEvent(e):
if e.buttons() == Qt.MidButton:
offset = self.previousMousePos - e.pos()
self.previousMousePos = e.pos()
self.view.verticalScrollBar().setValue(self.view.verticalScrollBar().value() + offset.y())
self.view.horizontalScrollBar().setValue(self.view.horizontalScrollBar().value() + offset.x())
else:
QGraphicsView.mouseMoveEvent(self.view, e)
self.view.setDragMode(QGraphicsView.ScrollHandDrag)
self.view.dragEnterEvent = _dragEnterEvent
self.view.dropEvent = _dropEvent
self.view.dragMoveEvent = _dragMoveEvent
self.view.wheelEvent = _wheelEvent
self.view.enterEvent = _enterEvent
self.view.mousePressEvent = _mousePressEvent
self.view.mouseMoveEvent = _mouseMoveEvent
def _mimeDataInput(items):
mimeData = QMimeData()
text = items[0].data(0, Qt.UserRole)
mimeData.setText(text)
return mimeData
self.inputsTree.mimeData = _mimeDataInput
self.inputsTree.setDragDropMode(QTreeWidget.DragOnly)
self.inputsTree.setDropIndicatorShown(True)
self.algorithms_model = ModelerToolboxModel(self, QgsApplication.processingRegistry())
self.algorithmTree.setToolboxProxyModel(self.algorithms_model)
self.algorithmTree.setDragDropMode(QTreeWidget.DragOnly)
self.algorithmTree.setDropIndicatorShown(True)
self.algorithmTree.setFilters(QgsProcessingToolboxProxyModel.FilterModeler)
if hasattr(self.searchBox, 'setPlaceholderText'):
self.searchBox.setPlaceholderText(QCoreApplication.translate('ModelerDialog', 'Search…'))
if hasattr(self.textName, 'setPlaceholderText'):
self.textName.setPlaceholderText(self.tr('Enter model name here'))
if hasattr(self.textGroup, 'setPlaceholderText'):
self.textGroup.setPlaceholderText(self.tr('Enter group name here'))
# Connect signals and slots
self.inputsTree.doubleClicked.connect(self.addInput)
self.searchBox.textChanged.connect(self.algorithmTree.setFilterString)
self.algorithmTree.doubleClicked.connect(self.addAlgorithm)
# Ctrl+= should also trigger a zoom in action
ctrlEquals = QShortcut(QKeySequence("Ctrl+="), self)
ctrlEquals.activated.connect(self.zoomIn)
self.mActionOpen.triggered.connect(self.openModel)
self.mActionSave.triggered.connect(self.save)
self.mActionSaveAs.triggered.connect(self.saveAs)
self.mActionSaveInProject.triggered.connect(self.saveInProject)
self.mActionZoomIn.triggered.connect(self.zoomIn)
self.mActionZoomOut.triggered.connect(self.zoomOut)
self.mActionZoomActual.triggered.connect(self.zoomActual)
self.mActionZoomToItems.triggered.connect(self.zoomToItems)
self.mActionExportImage.triggered.connect(self.exportAsImage)
self.mActionExportPdf.triggered.connect(self.exportAsPdf)
self.mActionExportSvg.triggered.connect(self.exportAsSvg)
#self.mActionExportPython.triggered.connect(self.exportAsPython)
self.mActionEditHelp.triggered.connect(self.editHelp)
self.mActionRun.triggered.connect(self.runModel)
if model is not None:
self.model = model.create()
self.model.setSourceFilePath(model.sourceFilePath())
self.textGroup.setText(self.model.group())
self.textName.setText(self.model.displayName())
self.repaintModel()
else:
self.model = QgsProcessingModelAlgorithm()
self.model.setProvider(QgsApplication.processingRegistry().providerById('model'))
self.fillInputsTree()
self.view.centerOn(0, 0)
self.help = None
self.hasChanged = False
def initTopMenu(self):
topMenu = QMenuBar()
######################load
loadMenu = topMenu.addMenu("Load")
loadSecAct = loadMenu.addAction('Load .sec...')
loadSecAct.triggered.connect(lambda: self.loadSec(clear=True))
loadRteAct = loadMenu.addAction('Load .rte...')
loadRteAct.triggered.connect(
lambda: self.loadRteDialog.show(clearMode=True))
loadSrAct = loadMenu.addAction('Load .sr...')
loadSrAct.triggered.connect(lambda: self.loadSr(clear=True))
##################insert
insertMenu = topMenu.addMenu("Insert")
#insertMenu.setToolTipsVisible(True)
insertMenu.hovered.connect(
lambda action: action.parent().setToolTip(action.toolTip()))
insertSecAct = insertMenu.addAction('Insert .sec...')
insertSecAct.triggered.connect(
lambda: self.loadSec(row=self.rowBox.value(), clear=False))
insertSecAct.setToolTip(
'insert .sec file using selected row and direction')
insertRteAct = insertMenu.addAction('Insert .rte...')
insertRteAct.triggered.connect(
lambda: self.loadRteDialog.show(clearMode=False))
insertRteAct.setToolTip('insert .rte file at row')
insertSrAct = insertMenu.addAction('Insert .sr...')
insertSrAct.triggered.connect(
lambda: self.loadSr(row=self.rowBox.value(), clear=False))
insertSrAct.setToolTip('insert .sr file at row')
self.addFeatureAct = insertMenu.addAction('Add Selected Feature')
self.addFeatureAct.setShortcut(QKeySequence(
'Alt+1')) #focus policy of dockwidget probably important here
self.addFeatureAct.triggered.connect(self.addFeature)
self.addFeatureAct.setToolTip(
'Insert selected feature of layer using selected row and direction'
)
self.addDummyAct = insertMenu.addAction('Add Dummy')
self.addDummyAct.setShortcut(QKeySequence(
'Alt+2')) #focus policy of dockwidget probably important here
self.addDummyAct.triggered.connect(self.addDummy)
self.addDummyAct.setToolTip('Insert dummy at row')
############################################save
saveMenu = topMenu.addMenu("Save")
saveSrAct = saveMenu.addAction('Save as .sr...')
saveSrAct.triggered.connect(self.saveAsSr)
saveSecAct = saveMenu.addAction('Save as .sec...')
saveSecAct.triggered.connect(self.saveAsSec)
saveRteAct = saveMenu.addAction('Save as .rte...')
saveRteAct.triggered.connect(self.saveAsRte)
#######################help
helpMenu = topMenu.addMenu('Help')
openHelpAct = helpMenu.addAction(
'Open help (in your default web browser)')
openHelpAct.triggered.connect(self.openHelp)
self.main_widget.layout().setMenuBar(topMenu)
def __init__(self, parent=None):
super(ShellScintilla, self).__init__(parent)
code.InteractiveInterpreter.__init__(self, locals=None)
self.parent = parent
self.opening = ['(', '{', '[', "'", '"']
self.closing = [')', '}', ']', "'", '"']
self.settings = QgsSettings()
# Enable non-ascii chars for editor
self.setUtf8(True)
self.new_input_line = True
self.setMarginWidth(0, 0)
self.setMarginWidth(1, 0)
self.setMarginWidth(2, 0)
self.buffer = []
self.displayPrompt(False)
for line in _init_commands:
self.runsource(line)
self.history = []
self.historyIndex = 0
# Read history command file
self.readHistoryFile()
self.historyDlg = HistoryDialog(self)
# Brace matching: enable for a brace immediately before or after
# the current position
self.setBraceMatching(QsciScintilla.SloppyBraceMatch)
self.setMatchedBraceBackgroundColor(QColor("#b7f907"))
# Current line visible with special background color
self.setCaretWidth(2)
self.refreshSettingsShell()
# Don't want to see the horizontal scrollbar at all
# Use raw message to Scintilla here (all messages are documented
# here: http://www.scintilla.org/ScintillaDoc.html)
self.SendScintilla(QsciScintilla.SCI_SETHSCROLLBAR, 0)
# not too small
# self.setMinimumSize(500, 300)
self.setWrapMode(QsciScintilla.WrapCharacter)
self.SendScintilla(QsciScintilla.SCI_EMPTYUNDOBUFFER)
# Disable command key
ctrl, shift = self.SCMOD_CTRL << 16, self.SCMOD_SHIFT << 16
self.SendScintilla(QsciScintilla.SCI_CLEARCMDKEY, ord('L') + ctrl)
self.SendScintilla(QsciScintilla.SCI_CLEARCMDKEY, ord('T') + ctrl)
self.SendScintilla(QsciScintilla.SCI_CLEARCMDKEY, ord('D') + ctrl)
self.SendScintilla(QsciScintilla.SCI_CLEARCMDKEY, ord('Z') + ctrl)
self.SendScintilla(QsciScintilla.SCI_CLEARCMDKEY, ord('Y') + ctrl)
self.SendScintilla(QsciScintilla.SCI_CLEARCMDKEY,
ord('L') + ctrl + shift)
# New QShortcut = ctrl+space/ctrl+alt+space for Autocomplete
self.newShortcutCSS = QShortcut(
QKeySequence(Qt.CTRL + Qt.SHIFT + Qt.Key_Space), self)
self.newShortcutCAS = QShortcut(
QKeySequence(Qt.CTRL + Qt.ALT + Qt.Key_Space), self)
self.newShortcutCSS.setContext(Qt.WidgetShortcut)
self.newShortcutCAS.setContext(Qt.WidgetShortcut)
self.newShortcutCAS.activated.connect(self.autoCompleteKeyBinding)
self.newShortcutCSS.activated.connect(self.showHistory)
def initGui(self):
# port old log, ONCE ONLY!
settings = QgsSettings()
if not settings.value("/Processing/hasPortedOldLog", False, bool):
processing_history_provider = QgsGui.historyProviderRegistry().providerById('processing')
if processing_history_provider:
processing_history_provider.portOldLog()
settings.setValue("/Processing/hasPortedOldLog", True)
self.options_factory = ProcessingOptionsFactory()
self.options_factory.setTitle(self.tr('Processing'))
iface.registerOptionsWidgetFactory(self.options_factory)
self.drop_handler = ProcessingDropHandler()
iface.registerCustomDropHandler(self.drop_handler)
self.item_provider = ProcessingDataItemProvider()
QgsApplication.dataItemProviderRegistry().addProvider(self.item_provider)
self.locator_filter = AlgorithmLocatorFilter()
iface.registerLocatorFilter(self.locator_filter)
# Invalidate the locator filter for in-place when active layer changes
iface.currentLayerChanged.connect(lambda _: self.iface.invalidateLocatorResults())
self.edit_features_locator_filter = InPlaceAlgorithmLocatorFilter()
iface.registerLocatorFilter(self.edit_features_locator_filter)
self.toolbox = ProcessingToolbox()
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.toolbox)
self.toolbox.hide()
self.toolbox.visibilityChanged.connect(self.toolboxVisibilityChanged)
self.toolbox.executeWithGui.connect(self.executeAlgorithm)
self.resultsDock = ResultsDock()
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.resultsDock)
self.resultsDock.hide()
self.menu = QMenu(self.iface.mainWindow().menuBar())
self.menu.setObjectName('processing')
self.menu.setTitle(self.tr('Pro&cessing'))
self.toolboxAction = QAction(self.tr('&Toolbox'), self.iface.mainWindow())
self.toolboxAction.setCheckable(True)
self.toolboxAction.setObjectName('toolboxAction')
self.toolboxAction.setIcon(
QgsApplication.getThemeIcon("/processingAlgorithm.svg"))
self.iface.registerMainWindowAction(self.toolboxAction,
QKeySequence('Ctrl+Alt+T').toString(QKeySequence.NativeText))
self.toolboxAction.toggled.connect(self.openToolbox)
self.iface.attributesToolBar().insertAction(self.iface.actionOpenStatisticalSummary(), self.toolboxAction)
self.menu.addAction(self.toolboxAction)
self.modelerAction = QAction(
QgsApplication.getThemeIcon("/processingModel.svg"),
QCoreApplication.translate('ProcessingPlugin', '&Graphical Modeler…'), self.iface.mainWindow())
self.modelerAction.setObjectName('modelerAction')
self.modelerAction.triggered.connect(self.openModeler)
self.iface.registerMainWindowAction(self.modelerAction,
QKeySequence('Ctrl+Alt+G').toString(QKeySequence.NativeText))
self.menu.addAction(self.modelerAction)
self.historyAction = QAction(
QgsApplication.getThemeIcon("/mIconHistory.svg"),
QCoreApplication.translate('ProcessingPlugin', '&History…'), self.iface.mainWindow())
self.historyAction.setObjectName('historyAction')
self.historyAction.triggered.connect(self.openHistory)
self.iface.registerMainWindowAction(self.historyAction,
QKeySequence('Ctrl+Alt+H').toString(QKeySequence.NativeText))
self.menu.addAction(self.historyAction)
self.toolbox.processingToolbar.addAction(self.historyAction)
self.resultsAction = QAction(
QgsApplication.getThemeIcon("/processingResult.svg"),
self.tr('&Results Viewer'), self.iface.mainWindow())
self.resultsAction.setObjectName('resultsViewer')
self.resultsAction.setCheckable(True)
self.iface.registerMainWindowAction(self.resultsAction,
QKeySequence('Ctrl+Alt+R').toString(QKeySequence.NativeText))
self.menu.addAction(self.resultsAction)
self.toolbox.processingToolbar.addAction(self.resultsAction)
self.resultsDock.visibilityChanged.connect(self.resultsAction.setChecked)
self.resultsAction.toggled.connect(self.resultsDock.setUserVisible)
self.toolbox.processingToolbar.addSeparator()
self.editInPlaceAction = QAction(
QgsApplication.getThemeIcon("/mActionProcessSelected.svg"),
self.tr('Edit Features In-Place'), self.iface.mainWindow())
self.editInPlaceAction.setObjectName('editInPlaceFeatures')
self.editInPlaceAction.setCheckable(True)
self.editInPlaceAction.toggled.connect(self.editSelected)
self.menu.addAction(self.editInPlaceAction)
self.toolbox.processingToolbar.addAction(self.editInPlaceAction)
self.toolbox.processingToolbar.addSeparator()
self.optionsAction = QAction(
QgsApplication.getThemeIcon("/mActionOptions.svg"),
self.tr('Options'), self.iface.mainWindow())
self.optionsAction.setObjectName('optionsAction')
self.optionsAction.triggered.connect(self.openProcessingOptions)
self.toolbox.processingToolbar.addAction(self.optionsAction)
menuBar = self.iface.mainWindow().menuBar()
menuBar.insertMenu(
self.iface.firstRightStandardMenu().menuAction(), self.menu)
self.menu.addSeparator()
initializeMenus()
createMenus()
createButtons()
# In-place editing button state sync
self.iface.currentLayerChanged.connect(self.sync_in_place_button_state)
self.iface.mapCanvas().selectionChanged.connect(self.sync_in_place_button_state)
self.iface.actionToggleEditing().triggered.connect(partial(self.sync_in_place_button_state, None))
self.sync_in_place_button_state()
# Sync project models
self.projectModelsMenu = None
self.projectMenuAction = None
self.projectMenuSeparator = None
self.projectProvider = QgsApplication.instance().processingRegistry().providerById("project")
self.projectProvider.algorithmsLoaded.connect(self.updateProjectModelMenu)
def initGui(self):
self.toolbox = ProcessingToolbox()
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.toolbox)
self.toolbox.hide()
self.toolbox.visibilityChanged.connect(self.toolboxVisibilityChanged)
self.resultsDock = ResultsDock()
self.iface.addDockWidget(Qt.RightDockWidgetArea, self.resultsDock)
self.resultsDock.hide()
self.menu = QMenu(self.iface.mainWindow().menuBar())
self.menu.setObjectName('processing')
self.menu.setTitle(self.tr('Pro&cessing'))
self.toolboxAction = QAction(self.tr('&Toolbox'),
self.iface.mainWindow())
self.toolboxAction.setCheckable(True)
self.toolboxAction.setObjectName('toolboxAction')
self.toolboxAction.setIcon(
QgsApplication.getThemeIcon("/processingAlgorithm.svg"))
self.iface.registerMainWindowAction(
self.toolboxAction,
QKeySequence('Ctrl+Alt+T').toString(QKeySequence.NativeText))
self.toolboxAction.toggled.connect(self.openToolbox)
self.iface.attributesToolBar().insertAction(
self.iface.actionOpenStatisticalSummary(), self.toolboxAction)
self.menu.addAction(self.toolboxAction)
self.modelerAction = QAction(
QgsApplication.getThemeIcon("/processingModel.svg"),
QCoreApplication.translate('ProcessingPlugin',
'Graphical &Modeler…'),
self.iface.mainWindow())
self.modelerAction.setObjectName('modelerAction')
self.modelerAction.triggered.connect(self.openModeler)
self.iface.registerMainWindowAction(
self.modelerAction,
QKeySequence('Ctrl+Alt+M').toString(QKeySequence.NativeText))
self.menu.addAction(self.modelerAction)
self.historyAction = QAction(
QIcon(os.path.join(pluginPath, 'images', 'history.svg')),
QCoreApplication.translate('ProcessingPlugin', '&History…'),
self.iface.mainWindow())
self.historyAction.setObjectName('historyAction')
self.historyAction.triggered.connect(self.openHistory)
self.iface.registerMainWindowAction(
self.historyAction,
QKeySequence('Ctrl+Alt+H').toString(QKeySequence.NativeText))
self.menu.addAction(self.historyAction)
self.toolbox.processingToolbar.addAction(self.historyAction)
self.resultsAction = QAction(
QgsApplication.getThemeIcon("/processingResult.svg"),
self.tr('&Results Viewer'), self.iface.mainWindow())
self.resultsAction.setCheckable(True)
self.iface.registerMainWindowAction(
self.resultsAction,
QKeySequence('Ctrl+Alt+R').toString(QKeySequence.NativeText))
self.menu.addAction(self.resultsAction)
self.toolbox.processingToolbar.addAction(self.resultsAction)
self.resultsDock.visibilityChanged.connect(
self.resultsAction.setChecked)
self.resultsAction.toggled.connect(self.resultsDock.setUserVisible)
self.optionsAction = QAction(
QgsApplication.getThemeIcon("/mActionOptions.svg"),
self.tr('Options'), self.iface.mainWindow())
self.optionsAction.setObjectName('optionsAction')
self.optionsAction.triggered.connect(self.openProcessingOptions)
self.toolbox.processingToolbar.addAction(self.optionsAction)
menuBar = self.iface.mainWindow().menuBar()
menuBar.insertMenu(self.iface.firstRightStandardMenu().menuAction(),
self.menu)
self.menu.addSeparator()
initializeMenus()
createMenus()
def __init__(self, parent=None):
super(QgsCodeEditorPython, self).__init__(parent)
code.InteractiveInterpreter.__init__(self, locals=None)
self.parent = parent
self.opening = ['(', '{', '[', "'", '"']
self.closing = [')', '}', ']', "'", '"']
self.settings = QgsSettings()
self.new_input_line = True
self.buffer = []
self.continuationLine = False
self.displayPrompt(self.continuationLine)
for line in _init_commands:
self.runsource(line)
self.history = []
self.softHistory = ['']
self.softHistoryIndex = 0
# Read history command file
self.readHistoryFile()
self.historyDlg = HistoryDialog(self)
self.refreshSettingsShell()
# Don't want to see the horizontal scrollbar at all
# Use raw message to Scintilla here (all messages are documented
# here: http://www.scintilla.org/ScintillaDoc.html)
self.SendScintilla(QsciScintilla.SCI_SETHSCROLLBAR, 0)
# not too small
# self.setMinimumSize(500, 300)
self.setWrapMode(QsciScintilla.WrapCharacter)
self.SendScintilla(QsciScintilla.SCI_EMPTYUNDOBUFFER)
# Disable command key
ctrl, shift = self.SCMOD_CTRL << 16, self.SCMOD_SHIFT << 16
self.SendScintilla(QsciScintilla.SCI_CLEARCMDKEY, ord('L') + ctrl)
self.SendScintilla(QsciScintilla.SCI_CLEARCMDKEY, ord('T') + ctrl)
self.SendScintilla(QsciScintilla.SCI_CLEARCMDKEY, ord('D') + ctrl)
self.SendScintilla(QsciScintilla.SCI_CLEARCMDKEY, ord('Z') + ctrl)
self.SendScintilla(QsciScintilla.SCI_CLEARCMDKEY, ord('Y') + ctrl)
self.SendScintilla(QsciScintilla.SCI_CLEARCMDKEY,
ord('L') + ctrl + shift)
# New QShortcut = ctrl+space/ctrl+alt+space for Autocomplete
self.newShortcutCSS = QShortcut(
QKeySequence(Qt.CTRL + Qt.SHIFT + Qt.Key_Space), self)
self.newShortcutCAS = QShortcut(
QKeySequence(Qt.CTRL + Qt.ALT + Qt.Key_Space), self)
self.newShortcutCSS.setContext(Qt.WidgetShortcut)
self.newShortcutCAS.setContext(Qt.WidgetShortcut)
self.newShortcutCAS.activated.connect(self.autoComplete)
self.newShortcutCSS.activated.connect(self.showHistory)
