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 __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, 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 __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 __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 __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 __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 __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, 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, 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;
}
''')
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()
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 __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()
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()
