def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.setWindowFlags(Qt.Window)
self._mdi_area = QMdiArea()
self._mdi_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self._mdi_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
self.setCentralWidget(self._mdi_area)
# set the size of mid_area and DocumentViewManager based on the
# screen size.
screen = QDesktopWidget().availableGeometry()
self._mdi_area.resize(screen.width() - 30, screen.height() - 80)
self.resize(self._mdi_area.size())
self._mdi_area.subWindowActivated.connect(self.update_actions)
self._viewer_mapper = QSignalMapper(self)
self._viewer_mapper.mapped[QWidget].connect(self.set_active_sub_window)
win_title = QApplication.translate("DocumentViewManager",
"Document Viewer")
self.setWindowTitle(win_title)
self.setUnifiedTitleAndToolBarOnMac(True)
self.statusBar().showMessage(
QApplication.translate("DocumentViewManager", "Ready"))
self._doc_viewers = {}
self._create_menu_actions()
self.update_actions()
def __init__(self, main_plugin):
# create GUI
QMainWindow.__init__(self)
self.plugin = main_plugin
self.selected_date = None
self.setWindowTitle('Calendar widget')
# Set the window dimensions
self.resize(400, 300)
# vertical layout for widgets
self.vbox = QVBoxLayout()
self.setLayout(self.vbox)
# Create a calendar widget and add it to our layout
self.cal = QCalendarWidget()
self.cal.setFirstDayOfWeek(Qt.Monday)
self.vbox.addWidget(self.cal)
qd = self.get_qdate()
self.cal.setSelectedDate(QDate(*qd))
# Create a label which we will use to show the date a week from now
self.lbl = QLabel()
self.vbox.addWidget(self.lbl)
self.ok_box = QPushButton('Ok!')
self.vbox.addWidget(self.ok_box)
# Connect the clicked signal to the centre handler
self.cal.selectionChanged.connect(self.date_changed)
# Connect the clicked signal to the centre handler
# self.ok_box.clicked.connect(self.ok_selected)
self.ok_box.clicked.connect(self.ok_selected)
def closeEvent(self, e):
# save the window state
settings = QSettings()
settings.setValue("/rivergis/mainWindow/windowState", self.saveState())
settings.setValue("/rivergis/mainWindow/geometry", self.saveGeometry())
settings.setValue("/rivergis/mainWindow/flags", self.windowFlags())
self.writeSettings()
QMainWindow.closeEvent(self, e)
def __init__(self, project):
QMainWindow.__init__(self)
self.setWindowTitle("QuteGIS")
self.setWindowIcon(QIcon(Settings.iconfile))
self.canvas = QuteCanvas(self, list(project.mapLayers().values()))
self.setCentralWidget(self.canvas)
self.toolbar = self.addToolBar("QuteTools")
self.tools = qutetools.buildSet(self.canvas)
self.buildToolbar()
def closeEvent(self, event):
"""Activated anytime Mapwindow is closed either by buttons given or
if the user finds some other way to close the window.
Deletes scrap maplayers."""
try:
QgsProject.instance().removeMapLayer(self.layer)
QgsProject.instance().removeMapLayer(self.bg_layer)
except Exception:
pass
QMainWindow.closeEvent(self, event)
def closeEvent(self, event):
"""Activated anytime Mapwindow is closed either programmatically or
if the user finds some other way to close the window. Automatically
finishes the polygon if it's unconnected."""
try:
QgsProject.instance().removeMapLayer(self.bg_layer)
except Exception:
pass
self.toolDraw.finishPolygon()
QMainWindow.closeEvent(self, event)
def closeEvent(self, e):
self.unregisterAllActions()
# clear preview, this will delete the layer in preview tab
self.preview.loadPreview(None)
# save the window state
settings = QgsSettings()
settings.setValue("/DB_Manager/mainWindow/windowState", self.saveState())
settings.setValue("/DB_Manager/mainWindow/geometry", self.saveGeometry())
QMainWindow.closeEvent(self, e)
def closeEvent(self, e):
self.unregisterAllActions()
# clear preview, this will delete the layer in preview tab
self.preview.loadPreview(None)
# save the window state
settings = QgsSettings()
settings.setValue("/DB_Manager/mainWindow/windowState", self.saveState())
settings.setValue("/DB_Manager/mainWindow/geometry", self.saveGeometry())
QMainWindow.closeEvent(self, e)
def __init__(self):
QMainWindow.__init__(self)
# creating map canvas, which draws the maplayers
# setting up features like canvas color
self.canvas = QgsMapCanvas()
self.canvas.setMinimumSize(550, 700)
self.canvas.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.canvas.setCanvasColor(Qt.white)
self.canvas.enableAntiAliasing(True)
# Qmainwindow requires a central widget. Canvas is placed
self.setCentralWidget(self.canvas)
# creating each desired action
self.actionGet = QAction("Return polygon and close", self)
self.actionPan = QAction("Pan tool", self)
self.actionDraw = QAction("Polygon tool", self)
self.actionConnect = QAction("Connect polygon", self)
self.actionClear = QAction("Clear", self)
self.actionCancel = QAction("Cancel and close", self)
# these two function as on/off. the rest are clickable
self.actionPan.setCheckable(True)
self.actionDraw.setCheckable(True)
# when actions are clicked, do corresponding function
self.actionPan.triggered.connect(self.pan)
self.actionDraw.triggered.connect(self.draw)
self.actionClear.triggered.connect(self.clear)
self.actionGet.triggered.connect(self.finishedSelection)
self.actionConnect.triggered.connect(self.connect)
self.actionCancel.triggered.connect(self.cancel)
# toolbar at the top of the screen: houses actions as buttons
# change order here to change their placement on toolbar
self.toolbar = self.addToolBar("Canvas actions")
self.toolbar.setContextMenuPolicy(Qt.PreventContextMenu)
self.toolbar.setMovable(False)
self.toolbar.addAction(self.actionGet)
self.toolbar.addAction(self.actionPan)
self.toolbar.addAction(self.actionDraw)
self.toolbar.addAction(self.actionConnect)
self.toolbar.addAction(self.actionClear)
self.toolbar.addAction(self.actionCancel)
# link actions to premade map tools
self.toolPan = QgsMapToolPan(self.canvas)
self.toolPan.setAction(self.actionPan)
self.toolDraw = PolygonMapTool(self.canvas)
self.toolDraw.setAction(self.actionDraw)
# set draw tool by default
self.draw()
def closeEvent(self, event):
"""Activated anytime Mapwindow is closed either by buttons given or
if the user finds some other way to close the window. Removes
selection and deletes scrap maplayer."""
self.selection_rectangle = self.layer.boundingBoxOfSelected()
self.layer.removeSelection()
QgsProject.instance().removeMapLayer(self.layer)
try:
QgsProject.instance().removeMapLayer(self.bg_layer)
except Exception:
pass
self.blocks_flag = False
QMainWindow.closeEvent(self, event)
def closeEvent(self, event):
# disable tracing
sys.settrace(None)
settings = QSettings()
settings.setValue("/plugins/firstaid/debugger-geometry", self.saveGeometry())
settings.setValue("/plugins/firstaid/debugger-windowstate", self.saveState())
filenames = list(self.text_edits.keys())
settings.setValue("/plugins/firstaid/debugger-files", filenames)
QMainWindow.closeEvent(self, event)
def __init__(self, iface, parent=None):
QMainWindow.__init__(self, parent)
self.setAttribute(Qt.WA_DeleteOnClose)
self.setupUi()
self.iface = iface
# restore the window state
settings = QgsSettings()
self.restoreGeometry(settings.value("/DB_Manager/mainWindow/geometry", QByteArray(), type=QByteArray))
self.restoreState(settings.value("/DB_Manager/mainWindow/windowState", QByteArray(), type=QByteArray))
self.tabs.currentChanged.connect(self.tabChanged)
self.tree.selectedItemChanged.connect(self.itemChanged)
self.itemChanged(None)
def __init__(self, iface, parent=None):
QMainWindow.__init__(self, parent)
self.setAttribute(Qt.WA_DeleteOnClose)
self.setupUi()
self.iface = iface
# restore the window state
settings = QgsSettings()
self.restoreGeometry(settings.value("/DB_Manager/mainWindow/geometry", QByteArray(), type=QByteArray))
self.restoreState(settings.value("/DB_Manager/mainWindow/windowState", QByteArray(), type=QByteArray))
self.tabs.currentChanged.connect(self.tabChanged)
self.tree.selectedItemChanged.connect(self.itemChanged)
self.tree.model().dataChanged.connect(self.iface.reloadConnections)
self.itemChanged(None)
def get_iface():
"""
Will return a mock QgisInterface object with some methods implemented in a generic way.
You can further control its behavior
by using the mock infrastructure. Refer to https://docs.python.org/3/library/unittest.mock.html
for more details.
Returns
-------
QgisInterface
A mock QgisInterface
"""
start_app()
my_iface = mock.Mock(spec=QgisInterface)
my_iface.mainWindow.return_value = QMainWindow()
canvas = QgsMapCanvas(my_iface.mainWindow())
canvas.resize(QSize(400, 400))
my_iface.mapCanvas.return_value = canvas
return my_iface
def __init__(self, iface, parent=None):
QMainWindow.__init__(self, parent=parent)
# build ui
self.ui = Ui_Form() #Appelle la fenêtre
self.ui.setupUi(self) #Construit l'interface
self.setCentralWidget(self.ui.PS_Time_Viewer
) #Définit la fenêtre principal de l'interface
self.first_point = True
# Set up the user interface from Designer.
self.iface = iface
self.canvas = iface.mapCanvas() #Lie QGIS et la fenêtre
# connect signals
self.make_connection() #Relie les boutons aux actions
def qgis_app():
"""Start a QGIS application and get the iface.
Mostly inspired by
https://github.com/qgis/QGIS/blob/release-2_18/python/testing/mocked.py
The application is returned as first argument. The QgisInterface is
returned as second argument.
The parent can be accessed by iface.mainWindow()
The canvas can be access by iface.mapCanvas()
You can further control its behavior
by using the mock infrastructure.
Refer to https://docs.python.org/3/library/unittest.mock.html
for more details.
:return: The QGIS interface.
:rtype: QgisInterface
"""
from qgis.utils import iface
if iface:
# We are already in QGIS.
# I don't know if I can get the current QApplication.
# But I guess we shouldn't use it too much.
return None, iface
# We are not in QGIS, we need to start an app.
application = start_app()
my_iface = mock.Mock(spec=QgisInterface)
my_iface.mainWindow.return_value = QMainWindow()
canvas = QgsMapCanvas(my_iface.mainWindow())
canvas.resize(QSize(400, 400))
my_iface.mapCanvas.return_value = canvas
return application, my_iface
def __init__(self, iface, parent=None):
QMainWindow.__init__(self, parent)
self.setAttribute(Qt.WA_DeleteOnClose)
self.setupUi()
self.iface = iface
# restore the window state
settings = QgsSettings()
self.restoreGeometry(settings.value("/DB_Manager/mainWindow/geometry", QByteArray(), type=QByteArray))
self.restoreState(settings.value("/DB_Manager/mainWindow/windowState", QByteArray(), type=QByteArray))
self.toolBar.setIconSize(self.iface.iconSize())
self.toolBarOrientation()
self.toolBar.orientationChanged.connect(self.toolBarOrientation)
self.tabs.currentChanged.connect(self.tabChanged)
self.tree.selectedItemChanged.connect(self.itemChanged)
self.tree.model().dataChanged.connect(self.iface.reloadConnections)
self.itemChanged(None)
def showEvent(self, event):
"""
(Re)load map layers in the viewer and main canvas.
:param event: Window event
:type event: QShowEvent
"""
self.setEnabled(True)
if QTimer is not None:
QTimer.singleShot(200, self.init_mirror_map)
return QMainWindow.showEvent(self, event)
def make_iface_canvas():
my_iface = mock.Mock(spec=QgisInterface)
my_iface.mainWindow.return_value = QMainWindow()
# canvas = QgsMapCanvas(my_iface.mainWindow())
canvas = MyCanvas()
canvas.setDestinationCrs(QgsCoordinateReferenceSystem(4326))
canvas.setFrameStyle(0)
canvas.resize(400, 400)
my_iface.mapCanvas.return_value = canvas
return my_iface
def make_iface_canvas(test_async):
my_iface = mock.Mock(spec=QgisInterface)
my_iface.mainWindow.return_value = QMainWindow()
canvas = MyCanvas()
canvas.setDestinationCrs(QgsCoordinateReferenceSystem(4326))
canvas.setFrameStyle(0)
canvas.resize(400, 400)
canvas.closed.connect(test_async._stop_async)
my_iface.mapCanvas.return_value = canvas
return my_iface
def __init__(self, layer, src, dst):
QMainWindow.__init__(self)
self.canvas = QgsMapCanvas()
self.canvas.setCanvasColor(Qt.white)
self.canvas.setExtent(layer.extent())
self.canvas.setLayers([layer, src, dst, rlayer])
self.setCentralWidget(self.canvas)
self.actionZoomIn = QAction("Zoom in", self)
self.actionZoomOut = QAction("Zoom out", self)
self.actionPan = QAction("Pan", self)
self.actionZoomIn.setCheckable(True)
self.actionZoomOut.setCheckable(True)
self.actionPan.setCheckable(True)
self.actionZoomIn.triggered.connect(self.zoomIn)
self.actionZoomOut.triggered.connect(self.zoomOut)
self.actionPan.triggered.connect(self.pan)
self.toolbar = self.addToolBar("Canvas actions")
self.toolbar.addAction(self.actionZoomIn)
self.toolbar.addAction(self.actionZoomOut)
self.toolbar.addAction(self.actionPan)
# create the map tools
self.toolPan = QgsMapToolPan(self.canvas)
self.toolPan.setAction(self.actionPan)
self.toolZoomIn = QgsMapToolZoom(self.canvas, False) # false = in
self.toolZoomIn.setAction(self.actionZoomIn)
self.toolZoomOut = QgsMapToolZoom(self.canvas, True) # true = out
self.toolZoomOut.setAction(self.actionZoomOut)
self.pan()
def __init__(self, url_base):
QMainWindow.__init__(self)
# creating map canvas, which draws the maplayers
# setting up features like canvas color
self.canvas = QgsMapCanvas()
self.canvas.setMinimumSize(550, 700)
self.canvas.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.canvas.setCanvasColor(Qt.white)
#self.canvas.enableAntiAliasing(True)
self.url_base = url_base
# Qmainwindow requires a central widget. Canvas is placed
self.setCentralWidget(self.canvas)
"""'tile widths' refer to the Map proxy WMTS server's settings for displaying
data of different resolutions. If I understood correctly, these values
(got by examining properties of a layer from that server in QGIS) are
the thresholds at which a different resolution is loaded on the GRIDI-FIN
tileset. The values represent the tile size in map units (meters).
Each tile widths is tied to the corresponding resolution, which is used
to get the correct resolution legend info. The method is only an estimation,
but ought to produce good enough results for this purpose.
Smallest resolutions (1, 2, 5) are omitted since only some layers
have them. """
self.tile_widths = {
2560: 10,
5120: 20,
12800: 50,
25600: 100,
51200: 200,
128000: 500,
256000: 1000
}
# get all keys i.e. widths
self.all_widths = [i for i in self.tile_widths]
# creating background layer box and housing it with the hardcoded options
self.bg_layer_box = QComboBox()
# if ortokuva ever updates to newer versions, just change the year here
bg_layers = ['Taustakartta', 'Ortokuva_2018', 'No reference layer']
# set 'No reference layer' as the default option
self.bg_layer_box.addItems(layer for layer in bg_layers)
self.bg_layer_box.setCurrentIndex(2)
self.bg_layer_box.currentIndexChanged.connect(self.addBackgroundLayer)
# initialize the slider that will control BG layer opacity/transparency
self.opacity_slider = QSlider(Qt.Horizontal)
self.opacity_slider.setMinimum(0)
self.opacity_slider.setMaximum(100)
self.opacity_slider.setSingleStep(1)
self.opacity_slider.setMaximumWidth(100)
self.opacity_slider.valueChanged.connect(self.setBackgroundMapOpacity)
self.legend_checkbox = QCheckBox("Get attribute info on all layers")
# explanatory texts for the different widgets are stored as label widgets
bg_layer_label = QLabel(" Background: ")
bg_opacity_label = QLabel(" BG opacity: ")
data_label = QLabel("Data: ")
spacing = QLabel(" ")
# all of the data layers are housed in this combobox
self.layer_box = QComboBox()
self.layer_box.currentIndexChanged.connect(self.addLayer)
# creating each desired action
self.actionPan = QAction("Pan tool", self)
self.actionLegend = QAction("Attribute info tool", self)
self.actionCancel = QAction("Close window", self)
self.actionZoom = QAction("Zoom to full extent", self)
# these two work as on/off. the rest are clickable
self.actionPan.setCheckable(True)
self.actionLegend.setCheckable(True)
# when actions are clicked, do corresponding function
self.actionPan.triggered.connect(self.pan)
self.actionLegend.triggered.connect(self.info)
self.actionCancel.triggered.connect(self.cancel)
self.actionZoom.triggered.connect(self.zoomToExtent)
# defining two toolbars: first one houses layer and opacity selection
# the other has all the tools and functions
self.layers_toolbar = self.addToolBar("Select layers")
self.layers_toolbar.setContextMenuPolicy(Qt.PreventContextMenu)
self.layers_toolbar.setMovable(False)
self.addToolBarBreak()
self.tools_toolbar = self.addToolBar("Tools")
self.tools_toolbar.setContextMenuPolicy(Qt.PreventContextMenu)
self.tools_toolbar.setMovable(False)
# change order here to change their placement on window
# starting with the layer widgets and the corresponding label texts
self.layers_toolbar.addWidget(data_label)
self.layers_toolbar.addWidget(self.layer_box)
self.layers_toolbar.addWidget(bg_layer_label)
self.layers_toolbar.addWidget(self.bg_layer_box)
self.layers_toolbar.addWidget(bg_opacity_label)
self.layers_toolbar.addWidget(self.opacity_slider)
self.layers_toolbar.addWidget(spacing)
self.layers_toolbar.addWidget(self.legend_checkbox)
# then setting all the canvas tools on the second toolbar
self.tools_toolbar.addAction(self.actionLegend)
self.tools_toolbar.addAction(self.actionPan)
self.tools_toolbar.addAction(self.actionZoom)
self.tools_toolbar.addAction(self.actionCancel)
# a large text box that will house the legend info
self.text_browser = QTextEdit("Legend will be shown here")
self.text_browser.setReadOnly(True)
# a dock widget is required for the text browser. Docked to main window
dock_widget = QDockWidget()
dock_widget.setFeatures(QDockWidget.NoDockWidgetFeatures)
dock_widget.setWindowTitle("Legend")
dock_widget.setWidget(self.text_browser)
self.addDockWidget(Qt.RightDockWidgetArea, dock_widget)
# link actions to premade map tools
self.toolPan = QgsMapToolPan(self.canvas)
self.toolPan.setAction(self.actionPan)
self.toolClick = QgsMapToolEmitPoint(self.canvas)
self.toolClick.canvasClicked.connect(self.getLegendInfo)
# this is to ensure that the map isn't zoomed out everytime the layer changes
self.first_start = True
# this boolean is true while there is no active background layer
# needed to ensure that e.g. opacity isn't attempted to be set on a nonexisting layer
self.no_bg_layer_flag = True
# set pantool as default
self.pan()
# QDockWidget split position "jumps" when QMainWindow resized
#
# Comment:
#
# When I encountered this bug it seemed that anything which sets QDockAreaLayoutItem::KeepSize
# avoided the error. This includes things like undocking and re-docking widgets.
#
# My own terribly hacky workaround was thus:
#
# QByteArray temp = saveState();
# restoreState(temp);
#
# since restoreState sets the flag.
#
win = QMainWindow()
temp = win.saveState() # Añadido para evitar bug
canvas = QgsMapCanvas()
project = QgsProject.instance()
root = project.layerTreeRoot()
bridge = QgsLayerTreeMapCanvasBridge(root, canvas)
win.setCentralWidget(canvas)
boton = QPushButton('Botón de prueba')
dw = QDockWidget("Dock Widget de prueba ", win)
dw.setWidget(boton)
win.addDockWidget(Qt.LeftDockWidgetArea, dw)
def __init__(self, parent=None):
QMainWindow.__init__(self, parent)
self.setWindowTitle("First Aid - Debugger")
self.text_edits = {} # fully expanded path of the file -> associated SourceWidget
self.toolbar = self.addToolBar("General")
self.toolbar.setObjectName("ToolbarGeneral")
self.tab_widget = QTabWidget()
self.tab_widget.setTabsClosable(True)
self.tab_widget.tabCloseRequested.connect(self.on_tab_close_requested)
self.tab_widget.currentChanged.connect(self.on_pos_changed)
self.setCentralWidget(self.tab_widget)
_icon = lambda x: QIcon(os.path.join(os.path.dirname(__file__), "icons", x + ".svg"))
self.action_load = self.toolbar.addAction(_icon("folder-outline"), "Load Python file (Ctrl+O)", self.on_load)
self.action_load.setShortcut("Ctrl+O")
self.action_run = self.toolbar.addAction(_icon("run"), "Run Python file (Ctrl+R)", self.on_run)
self.action_run.setShortcut("Ctrl+R")
self.action_bp = self.toolbar.addAction(_icon("record"), "Toggle breakpoint (F9)", self.on_toggle_breakpoint)
self.action_bp.setShortcut("F9")
self.toolbar.addSeparator()
self.action_continue = self.toolbar.addAction(_icon("play"), "Continue (F5)", self.on_continue)
self.action_continue.setShortcut("F5")
self.action_step_into = self.toolbar.addAction(_icon("debug-step-into"), "Step into (F11)", self.on_step_into)
self.action_step_into.setShortcut("F11")
self.action_step_over = self.toolbar.addAction(_icon("debug-step-over"), "Step over (F10)", self.on_step_over)
self.action_step_over.setShortcut("F10")
self.action_step_out = self.toolbar.addAction(_icon("debug-step-out"), "Step out (Shift+F11)", self.on_step_out)
self.action_step_out.setShortcut("Shift+F11")
self.action_run_to_cursor = self.toolbar.addAction(_icon("cursor-default-outline"), "Run to cursor (Ctrl+F10)",
self.on_run_to_cursor)
self.action_run_to_cursor.setShortcut("Ctrl+F10")
self.vars_view = VariablesView()
self.frames_view = FramesView()
self.dock_frames = QDockWidget("Frames", self)
self.dock_frames.setObjectName("DockFrames")
self.dock_frames.setWidget(self.frames_view)
self.addDockWidget(Qt.BottomDockWidgetArea, self.dock_frames)
self.dock_vars = QDockWidget("Variables", self)
self.dock_vars.setObjectName("DockVariables")
self.dock_vars.setWidget(self.vars_view)
self.addDockWidget(Qt.BottomDockWidgetArea, self.dock_vars)
self.resize(800, 800)
self.debugger = Debugger(self)
self.update_buttons()
settings = QSettings()
self.restoreGeometry(settings.value("/plugins/firstaid/debugger-geometry", b''))
self.restoreState(settings.value("/plugins/firstaid/debugger-windowstate", b''))
filenames = settings.value("/plugins/firstaid/debugger-files", [])
if filenames is None:
filenames = []
# load files from previous session
for filename in filenames:
self.load_file(filename)
if self.tab_widget.count() > 1:
self.tab_widget.setCurrentIndex(0)
# start tracing
self.start_tracing()
def qgis_app(request):
"""
Creates a QGIS application, a QGIS Interface, a QGIS Settings and a set of loaded plugins. The fixture can be
parametrized with the following options:
- plugin_names: Plugin names to load
- plugin_paths: Directories where the plugins are located
- locale: Language code with the translation that the plugin has to be loaded
:param request: Fixture request. It contains the indirect parameters for fixture setup
:type request: FixtureRequest
:return: The QGIS application objects
:rtype: (QgsApplication, QgisInterface, QgsSettings, (list of object) or None)
"""
# Collect parameters
plugin_names = request.param[
'plugin_names'] if 'plugin_names' in request.param else None
plugin_paths = request.param['plugin_paths'] if 'plugin_paths' in request.param \
else [str(Path(__file__).parent.parent.parent) + '/src']
locale = request.param['locale'] if 'locale' in request.param else 'EN'
# Create a QGIS Application
# noinspection PyTypeChecker
QgsApplication.setPrefixPath('/usr', True)
qgs = QgsApplication([], True)
qgs.initQgis()
# Mock the QGIS Interface
iface = unittest.mock.Mock(spec=QgisInterface)
main_window = QMainWindow()
iface.mainWindow.return_value = main_window
canvas = QgsMapCanvas(main_window)
canvas.resize(QSize(400, 400))
iface.mapCanvas.return_value = canvas
# Create the settings
global_settings = QSettings()
global_settings.setValue('locale/userLocale', locale)
qgs_settings = QgsSettings()
qgs_settings_file = qgs_settings.fileName()
menu = QMenuBar()
main_window.setMenuBar(menu)
qgis.utils.iface = iface
for plugin_path in plugin_paths:
sys.path.insert(0, plugin_path)
qgis.utils.plugin_paths.append(plugin_path)
qgis.utils.updateAvailablePlugins()
if plugin_names is not None:
plugins = list()
if isinstance(plugin_names, str):
plugin_names = [plugin_names]
for plugin_name in plugin_names:
assert qgis.utils.loadPlugin(plugin_name)
assert qgis.utils.startPlugin(plugin_name)
plugins.append(qgis.utils.plugins[plugin_name])
yield qgs, iface, qgs_settings, plugins
for plugin_name in plugin_names:
qgis.utils.unloadPlugin(plugin_name)
del qgis.utils.plugin_times[plugin_name]
if plugin_paths is not None:
for plugin_path in plugin_paths:
sys.path.remove(plugin_path)
qgis.utils.plugin_paths.remove(plugin_path)
qgis.utils.updateAvailablePlugins()
else:
yield qgs, iface, qgs_settings, None
os.remove(qgs_settings_file)
del qgs
def __init__(self, iface):
QMainWindow.__init__(self)
self.resize(600, 600)
self.layer = None
self.iface = iface
self.dstpoints = []
self.srcpoints = []
self.filename = None
self.cursrc = None
self.curdst = None
self.xform_m2r = None
self.xform_r2m = None
self.canvas = QgsMapCanvas(self)
#self.canvas.setCachingEnabled(True)
self.canvas.setCanvasColor(Qt.white)
self.canvas.setWheelAction(QgsMapCanvas.WheelZoomToMouseCursor)
self.setCentralWidget(self.canvas)
def t(name):
return QgsApplication.getThemeIcon('/' + name)
actionZoomIn = QAction(t('mActionZoomIn.svg'), "Zoom in", self)
actionZoomOut = QAction(t('mActionZoomOut.svg'), "Zoom out", self)
actionZoomToLayer = QAction(t('mActionZoomToLayer.svg'), "Zoom To Layer", self)
actionZoomToDest = QAction("Zoom To Map", self)
actionPan = QAction(t('mActionPan.svg'), "Pan", self)
actionOpen = QAction(t('mActionFileOpen.svg'), "Open", self)
actionSave = QAction(t('mActionFileSaveAs.svg'), "Save", self)
actionAdd = QAction("Add GCP", self)
actionDeleteAll = QAction("Delete All GCPs", self)
actionZoomIn.setCheckable(True)
actionZoomOut.setCheckable(True)
actionPan.setCheckable(True)
actionAdd.setCheckable(True)
actionZoomIn.triggered.connect(self.zoomIn)
actionZoomOut.triggered.connect(self.zoomOut)
actionZoomToLayer.triggered.connect(self.zoomToLayer)
actionZoomToDest.triggered.connect(self.zoomToDest)
actionPan.triggered.connect(self.pan)
actionOpen.triggered.connect(self.showOpen)
actionSave.triggered.connect(self.savePoints)
actionAdd.triggered.connect(self.addGcp)
actionDeleteAll.triggered.connect(self.deleteAll)
self.toolbar = self.addToolBar("Canvas actions")
self.toolbar.addAction(actionOpen)
self.toolbar.addAction(actionSave)
self.toolbar.addSeparator()
self.toolbar.addAction(actionPan)
self.toolbar.addAction(actionZoomIn)
self.toolbar.addAction(actionZoomOut)
self.toolbar.addAction(actionZoomToLayer)
self.toolbar.addAction(actionZoomToDest)
self.toolbar.addSeparator()
self.toolbar.addAction(actionAdd)
self.toolbar.addSeparator()
self.toolbar.addAction(actionDeleteAll)
self.toolPan = QgsMapToolPan(self.canvas)
self.toolPan.setAction(actionPan)
self.toolZoomIn = QgsMapToolZoom(self.canvas, False)
self.toolZoomIn.setAction(actionZoomIn)
self.toolZoomOut = QgsMapToolZoom(self.canvas, True)
self.toolZoomOut.setAction(actionZoomOut)
self.toolSrcAdd = CaptureTool(self.canvas, self.iface.cadDockWidget())
self.toolSrcAdd.pointSelected.connect(self.addSrcPoint)
self.toolSrcAdd.pointDeleted.connect(self.delSrcPoint)
self.toolDestAdd = CaptureTool(self.iface.mapCanvas(), self.iface.cadDockWidget())
self.toolDestAdd.pointSelected.connect(self.addDestPoint)
self.toolDestAdd.pointDeleted.connect(self.delDestPoint)
#self.toolDestAdd.setAction(actionAdd)
self.pan()
self.overview = QgsMapOverviewCanvas(None, self.canvas)
self.overview_dock = QDockWidget("Overview")
self.overview_dock.setWidget(self.overview)
self.addDockWidget(Qt.BottomDockWidgetArea, self.overview_dock)
self.canvas.enableOverviewMode(self.overview)
statusbar = self.statusBar()
self.coordslabel = QLabel(statusbar)
self.canvas.xyCoordinates.connect(self.showMouseCoordinates)
statusbar.addPermanentWidget(self.coordslabel)
def __init__(self, iface, parent=None):
QMainWindow.__init__(self, parent)
if QApplication.overrideCursor():
QApplication.restoreOverrideCursor()
self.setAttribute(Qt.WA_DeleteOnClose)
tdir = os.path.dirname(os.path.realpath(__file__))
uif = os.path.join(tdir, "ui", "ui_rivergis.ui")
self.ui = uic.loadUi(uif, self)
self.conn = None
self.curConnName = None
self.schema = None
self.passwd = None
self.rdb = None
self.iface = iface
# self.mapRegistry = QgsMapLayerRegistry.instance()
self.rivergisPath = os.path.dirname(__file__)
self.dtms = []
# restore settings
self.readSettings()
self.menus = self.ui.menubar.findChildren(QMenu)
self.toolbars = self.findChildren(QToolBar)
# MENU Actions
# DB
self.ui.actionRefreshConnections.triggered.connect(self.connChanged)
self.ui.actionCreateNewSchema.triggered.connect(self.dbCreateSchema)
self.ui.actionDeleteSchema.triggered.connect(self.dbDeleteSchema)
self.ui.actionRASCreateRdbTables.triggered.connect(self.rasCreateRdbTables)
self.ui.actionRASLoadRdbTablesIntoQGIS.triggered.connect(self.rasLoadRdbTablesIntoQGIS)
self.ui.actionRASImportLayersIntoRdbTables.triggered.connect(self.rasImportLayersIntoRdbTables)
# Settings
self.ui.actionOptions.triggered.connect(self.options)
self.ui.actionRestoreDefaultOptions.triggered.connect(lambda: self.readSettings(defaults=True))
# RAS Geometry
# 1D
self.ui.actionRASTopology1D.triggered.connect(lambda: r1d.ras1dStreamCenterlineTopology(self))
self.ui.actionRASLengthsStations.triggered.connect(lambda: r1d.ras1dStreamCenterlineLengthsStations(self))
self.ui.actionCopyStreamCenterlines2Flowpaths.triggered.connect(lambda: r1d.ras1dStreamCenterlines2Flowpaths(self))
self.ui.actionRASStreamCenterlineAll.triggered.connect(lambda: r1d.ras1dStreamCenterlineAll(self))
self.ui.actionRASXSRiverReachNames.triggered.connect(lambda: r1d.ras1dXSRiverReachNames(self))
self.ui.actionRASXSStationing.triggered.connect(lambda: r1d.ras1dXSStationing(self))
self.ui.actionRASXSBankStations.triggered.connect(lambda: r1d.ras1dXSBankStations(self))
self.ui.actionRASXSDownstreamReachLengths.triggered.connect(lambda: r1d.ras1dXSDownstreamLengths(self))
self.ui.actionRASXSElevations.triggered.connect(lambda: r1d.ras1dXSElevations(self))
self.ui.actionRASXSAll.triggered.connect(lambda: r1d.ras1dXSAll(self))
self.ui.actionRASHealLanduseGeometries.triggered.connect(lambda: r1d.ras1dHealLanduseGeoms(self))
self.ui.actionRASManningsNValues.triggered.connect(lambda: r1d.ras1dXSExtractMannings(self))
self.ui.actionRASLevees.triggered.connect(lambda: r1d.ras1dLevees(self))
self.ui.actionRASIneffectiveFlowAreas.triggered.connect(lambda: r1d.ras1dIneffective(self))
self.ui.actionRASBlockedObstructions.triggered.connect(lambda: r1d.ras1dObstructions(self))
self.ui.actionRASXSUpdateInsertMeasuredPoints.triggered.connect(lambda: r1d.ras1dXSUpdateInsertMeasuredPts(self))
self.ui.actionRASBRRiverReachNames.triggered.connect(lambda: r1d.ras1dBRRiverReachNames(self))
self.ui.actionRASBRStationing.triggered.connect(lambda: r1d.ras1dBRStationing(self))
self.ui.actionRASBRElevations.triggered.connect(lambda: r1d.ras1dBRElevations(self))
self.ui.actionRASBRAll.triggered.connect(lambda: r1d.ras1dRASBRAll(self))
self.ui.actionRASInlRiverReachNames.triggered.connect(lambda: r1d.ras1dISRiverReachNames(self))
self.ui.actionRASInlStationing.triggered.connect(lambda: r1d.ras1dISStationing(self))
self.ui.actionRASInlElevations.triggered.connect(lambda: r1d.ras1dISElevations(self))
self.ui.actionRASInlAll.triggered.connect(lambda: r1d.ras1dISAll(self))
self.ui.actionRASLatRiverReachNames.triggered.connect(lambda: r1d.ras1dLatRiverReachNames(self))
self.ui.actionRASLatStationing.triggered.connect(lambda: r1d.ras1dLatStationing(self))
self.ui.actionRASLatElevations.triggered.connect(lambda: r1d.ras1dLatElevations(self))
self.ui.actionRASLatAll.triggered.connect(lambda: r1d.ras1dLatAll(self))
self.ui.actionRASSAElevationVolumeData.triggered.connect(lambda: r1d.ras1dSAVolumeData(self))
self.ui.actionRASSATerrainPointExtraction.triggered.connect(lambda: r1d.ras1dSAElevations(self))
self.ui.actionRASSAAll.triggered.connect(lambda: r1d.ras1dSAAll(self))
self.ui.actionRASSacAssignNearestSA.triggered.connect(lambda: r1d.ras1dSACAssignNearestSA(self))
self.ui.actionRASSacElevations.triggered.connect(lambda: r1d.ras1dSACElevations(self))
self.ui.actionRASSacAll.triggered.connect(lambda: r1d.ras1dSACAll(self))
self.ui.actionRASCreateRASGISImport.triggered.connect(lambda: r1d.ras1dCreateRasGisImportFile(self))
# 2D
self.ui.actionRASCreate2dAreaPoints.triggered.connect(lambda: r2d.ras2dCreate2dPoints(self))
self.ui.actionRASPreview2DMesh.triggered.connect(lambda: r2d.ras2dPreviewMesh(self))
self.ui.actionRASSave2DPointsToHECRASGeometry.triggered.connect(lambda: r2d.ras2dSaveMeshPtsToGeometry(self))
# HELP
self.ui.actionHelpContents.triggered.connect(self.showRGisHelp)
self.ui.actionWebsite.triggered.connect(self.showWebsite)
self.ui.actionAbout.triggered.connect(self.about)
# combos
self.ui.crsWidget.crsChanged.connect(self.updateDefaultCrs)
self.ui.connsCbo.activated.connect(self.connChanged)
self.ui.schemasCbo.activated.connect(self.schemaChanged)
# Welcome message
self.ui.textEdit.append('<b>Welcome to RiverGIS!</b><br><br>Start building your model with 3 simple steps:<br>1. <b>Choose a connection</b> to PostGIS database<br>2. choose or create database <b>schema</b> (schema = model container or folder)<br>3. select a <b>projection</b> for the river database objects (projection = Coordinate Reference System, CRS).')
self.ui.textEdit.append('<br>If you can\'t see any connection, please, create a new one from menu Layer > Add layer > Add PostGIS layers... <br>')
self.ui.textEdit.append('----------------------------------------------------------------------------')
# restore the window state
s = QSettings()
self.restoreGeometry(s.value("/rivergis/mainWindow/geometry", QByteArray(), type=QByteArray))
self.restoreState(s.value("/rivergis/mainWindow/windowState", QByteArray(), type=QByteArray))
# get PostGIS connections details and populate connections' combo
self.connChanged()
# restore settings
self.readSettings()
# set QGIS projection CRS as a default for RiverGIS
self.ui.crsWidget.setCrs(self.iface.mapCanvas().mapSettings().destinationCrs())
self.updateDefaultCrs()
# check if we should connect to previously used RDB
if self.open_last_conn:
try:
self.connChanged(conn_name=self.opts['rdb']['last_conn'],
schema_name=self.opts['rdb']['last_schema'])
except:
pass
# disable some actions until a connection to river database is established
if not self.rdb:
self.disableActions()
def __init__(self, plugin):
QMainWindow.__init__(self, plugin.iface.mainWindow())
self.setupUi(self)
self.btnSearch.setIcon(GuiUtils.get_icon('search.png'))
self.btnClearSearch.setIcon(GuiUtils.get_icon('reset.png'))
self._plugin = plugin
self.search_done = False
# self.tbPropertyPreview.set_iface(self._plugin.iface)
QTimer.singleShot(
100, lambda: self.tbPropertyPreview.set_iface(self._plugin.iface))
self.curr_profile = current_profile()
self.spatial_units = self.curr_profile.social_tenure.spatial_units
# Center me
self.move(QDesktopWidget().availableGeometry().center() -
self.frameGeometry().center())
self.sp_unit_manager = SpatialUnitManagerDockWidget(
self._plugin.iface, self._plugin)
self.geom_cols = []
for spatial_unit in self.spatial_units:
each_geom_col = self.sp_unit_manager.geom_columns(spatial_unit)
self.geom_cols.extend(each_geom_col)
# Configure notification bar
self._notif_search_config = NotificationBar(self.vl_notification)
# set whether currently logged in user has
# permissions to edit existing STR records
self._can_edit = self._plugin.STRCntGroup.canUpdate()
self._can_delete = self._plugin.STRCntGroup.canDelete()
self._can_create = self._plugin.STRCntGroup.canCreate()
# Variable used to store a reference to the
# currently selected social tenure relationship
# when displaying documents in the supporting documents tab window.
# This ensures that there are no duplicates
# when the same item is selected over and over again.
self._strID = None
self.removed_docs = None
# Used to store the root hash of the currently selected node.
self._curr_rootnode_hash = ""
self.str_model, self.str_doc_model = entity_model(
self.curr_profile.social_tenure, False, True)
self._source_doc_manager = SourceDocumentManager(
self.curr_profile.social_tenure.supporting_doc, self.str_doc_model,
self)
self._source_doc_manager.documentRemoved.connect(
self.onSourceDocumentRemoved)
self._source_doc_manager.setEditPermissions(False)
self.initGui()
self.add_spatial_unit_layer()
self.details_tree_view = DetailsTreeView(iface, self._plugin, self)
# else:
# self.details_tree_view = self._plugin.details_tree_view
self.details_tree_view.activate_feature_details(True)
self.details_tree_view.add_tree_view()
self.details_tree_view.model.clear()
count = pg_table_count(self.curr_profile.social_tenure.name)
self.setWindowTitle(
self.tr('{}{}'.format(self.windowTitle(),
'- ' + str(count) + ' rows')))
self.active_spu_id = -1
self.toolBox.setStyleSheet('''
QToolBox::tab {
background: qlineargradient(
x1: 0, y1: 0, x2: 0, y2: 1,
stop: 0 #EDEDED, stop: 0.4 #EDEDED,
stop: 0.5 #EDEDED, stop: 1.0 #D3D3D3
);
border-radius: 2px;
border-style: outset;
border-width: 2px;
height: 100px;
border-color: #C3C3C3;
}
QToolBox::tab:selected {
font: italic;
}
''')
self.details_tree_view.view.setStyleSheet('''
QTreeView:!active {
selection-background-color: #72a6d9;
}
''')
from qgis.core import *
from qgis.gui import *
from qgis.core.contextmanagers import qgisapp
from qgis.PyQt.QtCore import *
from qgis.PyQt.QtGui import *
from qgis.PyQt.QtWidgets import QMainWindow, QDockWidget, QPushButton
from moduls.QvLlegenda import QvLlegenda
from moduls.QvAtributs import QvAtributs
from moduls.QvCanvas import QvCanvas
projecteInicial = 'MapesOffline/qVista default map.qgs'
with qgisapp() as app:
win = QMainWindow()
# canvas = QvCanvas(llistaBotons=llistaBotons, posicioBotonera = 'SE', botoneraHoritzontal = True)
canvas = QgsMapCanvas()
win.setCentralWidget(canvas)
project = QgsProject.instance()
root = project.layerTreeRoot()
bridge = QgsLayerTreeMapCanvasBridge(root, canvas)
tablaAtributos = QvAtributs(canvas)
# leyenda = QvLlegenda(canvas, tablaAtributos)
boton = QPushButton('Botón de prueba')
dw = QDockWidget("Dock Widget de prueba ", win)
dw.setWidget(boton)
win.addDockWidget(Qt.LeftDockWidgetArea, dw)
win.show()
project.read(projecteInicial)
def __init__(self):
QMainWindow.__init__(self)
#self.setWindowFlags(Qt.CustomizeWindowHint)
#self.setWindowFlags(Qt.WindowMinMaxButtonsHint)
# creating map canvas, which draws the maplayers
# setting up features like canvas color
self.canvas = QgsMapCanvas()
self.canvas.setMinimumSize(550, 700)
self.canvas.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.canvas.setCanvasColor(Qt.white)
self.canvas.setSelectionColor(QColor(255,255,26,200))
self.canvas.enableAntiAliasing(True)
self.canvas.setParallelRenderingEnabled(True)
# empty list for selected polygons
self.selected_features = []
# setting up label settings: object below houses all of them
self.label_settings = QgsPalLayerSettings()
# object for text settings
text_format = QgsTextFormat()
text_format.setFont(QFont("Helvetica", 12))
text_format.setSize(7)
# setting up a white buffer around the labels
buffer_settings = QgsTextBufferSettings()
buffer_settings.setEnabled(True)
buffer_settings.setSize(0.65)
buffer_settings.setColor(Qt.white)
text_format.setBuffer(buffer_settings)
# label settings:
# fieldName = which field is shown as the label (currently Finnish name)
# placement = labels can be placed differently in relation to one another
# - see documentation for details
self.label_settings.setFormat(text_format)
self.label_settings.fieldName = "namefin"
self.label_settings.placement = 0
self.label_settings.enabled = True
# Qmainwindow requires a central widget. Canvas is placed
self.setCentralWidget(self.canvas)
# creating each desired action
self.actionGet = QAction("Return selected and close", self)
self.actionPan = QAction("Pan tool", self)
self.actionSelect = QAction("Select tool", self)
self.actionClear = QAction("Clear selection", self)
self.actionCancel = QAction("Cancel and close", self)
# these two function as on/off. the rest are clickable
self.actionPan.setCheckable(True)
self.actionSelect.setCheckable(True)
# when actions are clicked, do corresponding function
self.actionPan.triggered.connect(self.pan)
self.actionSelect.triggered.connect(self.select)
self.actionClear.triggered.connect(self.clearSelection)
self.actionGet.triggered.connect(self.finishedSelection)
self.actionCancel.triggered.connect(self.cancel)
# toolbar at the top of the screen: houses actions as buttons
# change order here to change their placement on window
self.toolbar = self.addToolBar("Canvas actions")
self.toolbar.setContextMenuPolicy(Qt.PreventContextMenu)
self.toolbar.setMovable(False)
self.toolbar.addAction(self.actionGet)
self.toolbar.addAction(self.actionPan)
self.toolbar.addAction(self.actionSelect)
self.toolbar.addAction(self.actionClear)
self.toolbar.addAction(self.actionCancel)
# link actions to premade map tools
self.toolPan = QgsMapToolPan(self.canvas)
self.toolPan.setAction(self.actionPan)
self.toolSelect = QgsMapToolIdentifyFeature(self.canvas)
self.toolSelect.setAction(self.actionSelect)
self.toolSelect.featureIdentified.connect(self.selectFeature)
self.blocks_flag = False
self.selection_rectangle = False
# set select tool as default
self.select()
bridge = QgsLayerTreeMapCanvasBridge(root, canvas)
# llegim un projecte de demo
project.read(projecteInicial)
# Instanciem la classe QvUbicacions
ubicacions = QvUbicacions(canvas)
"""
Amb aquesta linia:
ubicacions.show()
es veuria el widget suelto, separat del canvas.
Les següents línies mostren com integrar el widget 'ubicacions' com a dockWidget.
"""
windowTest = QMainWindow()
# Posem el canvas com a element central
windowTest.setCentralWidget(canvas)
# Creem un dockWdget i definim les característiques
dwUbicacions = QDockWidget("Ubicacions", windowTest)
dwUbicacions.setContextMenuPolicy(Qt.PreventContextMenu)
dwUbicacions.setAllowedAreas(Qt.RightDockWidgetArea
| Qt.LeftDockWidgetArea)
dwUbicacions.setContentsMargins(1, 1, 1, 1)
# Afegim el widget ubicacions al dockWidget
dwUbicacions.setWidget(ubicacions)
# Coloquem el dockWidget al costat esquerra de la finestra
if checkbox_str in texts:
checkbox.setChecked(True)
def resetSelection(self):
if self.mono:
return super().setCurrentIndex(-1)
for i in range(self.RESERVED_IDXS_COUNT, self.mlist.count()):
checkbox = self.mlist.itemWidget(self.mlist.item(i))
checkbox.setChecked(False)
if __name__ == "__main__":
import sys
app = QApplication(sys.argv)
win = QMainWindow()
wdg = QWidget()
wdg.setLayout(QVBoxLayout())
win.setCentralWidget(wdg)
mscb = MultiSelectComboBox(wdg)
mscb.addItem("ITA")
mscb.addItem("FRA")
mscb.addItem("GER")
mscb.addItems(["Rlz_%2d" % rlz for rlz in range(1, 100)])
mscbmono = MultiSelectComboBox(wdg, mono=True)
mscbmono.addItems(mscb.get_unselected_items())
wdg.layout().addWidget(mscb)
wdg.layout().addWidget(mscbmono)
win.show()
app.exec_()
