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()