def open_settings_dialog(self): # open a dialog with settings dialog = SettingsDialog(self, self.profilecon) dialog.exec() # update settings self.configure_plot()
def setting(self): from settingsdialog import SettingsDialog dialog = SettingsDialog(self.iface.mainWindow()) dialog.show() if dialog.exec_(): from pluginmanager import PluginManager self.pluginManager = PluginManager()
def openSettings(self): # button signals in SettingsDialog were not working on Win7/64 # if SettingsDialog was created with iface.mainWindow() as parent #self.settingsDialog = SettingsDialog(self.iface.mainWindow()) self.settingsDialog = SettingsDialog() self.settingsDialog.changed.connect(self.spline.settingsChanged) self.settingsDialog.show()
def pluginSettings(self): from settingsdialog import SettingsDialog dialog = SettingsDialog(self) if dialog.exec_(): self.pluginManager.reloadPlugins() self.pages[ppages.PAGE_DEM].initLayerComboBox()
def settings(self): oldMoveToLayer = QSettings().value("/TileLayerPlugin/moveToLayer", 0, type=int) from settingsdialog import SettingsDialog dialog = SettingsDialog(self.iface) accepted = dialog.exec_() if not accepted: return False self.downloadTimeout = dialog.ui.spinBox_downloadTimeout.value() self.navigationMessagesEnabled = dialog.ui.checkBox_NavigationMessages.checkState() moveToLayer = dialog.ui.checkBox_MoveToLayer.checkState() if moveToLayer != oldMoveToLayer: if oldMoveToLayer: self.iface.layerToolBar().removeAction(self.action) self.iface.removeAddLayerAction(self.action) else: self.iface.removePluginWebMenu(self.pluginName, self.action) if moveToLayer: self.iface.insertAddLayerAction(self.action) self.iface.layerToolBar().addAction(self.action) else: self.iface.addPluginToWebMenu(self.pluginName, self.action) return True
def settings(self): oldMoveToLayer = QSettings().value("/TileLayerPlugin/moveToLayer", 0, type=int) from settingsdialog import SettingsDialog dialog = SettingsDialog(self.iface) accepted = dialog.exec_() if not accepted: return False self.downloadTimeout = dialog.ui.spinBox_downloadTimeout.value() self.navigationMessagesEnabled = dialog.ui.checkBox_NavigationMessages.checkState( ) moveToLayer = dialog.ui.checkBox_MoveToLayer.checkState() if moveToLayer != oldMoveToLayer: if oldMoveToLayer: self.iface.layerToolBar().removeAction(self.action) self.iface.removeAddLayerAction(self.action) else: self.iface.removePluginWebMenu(self.pluginName, self.action) if moveToLayer: self.iface.insertAddLayerAction(self.action) self.iface.layerToolBar().addAction(self.action) else: self.iface.addPluginToWebMenu(self.pluginName, self.action) return True
def settings(self): from settingsdialog import SettingsDialog dialog = SettingsDialog(self.iface) dialog.show() accepted = dialog.exec_() if accepted: self.downloadTimeout = dialog.ui.spinBox_downloadTimeout.value() self.navigationMessagesEnabled = dialog.ui.checkBox_NavigationMessages.checkState( )
def __init__(self, iface): """Constructor. :param iface: An interface instance that will be passed to this class which provides the hook by which you can manipulate the QGIS application at run time. :type iface: QgsInterface """ # Save reference to the QGIS interface super(EarthMineQGIS, self).__init__() self.movingfeature = None self.iface = iface self.viewer = None self.canvas = self.iface.mapCanvas() self.settings = QSettings() # initialize plugin directory self.plugin_dir = os.path.dirname(__file__) # initialize locale locale = QSettings().value('locale/userLocale')[0:2] locale_path = os.path.join(self.plugin_dir, 'i18n', 'EarthMineQGIS_{}.qm'.format(locale)) if os.path.exists(locale_path): self.translator = QTranslator() self.translator.load(locale_path) if qVersion() > '4.3.3': QCoreApplication.installTranslator(self.translator) self.pointtool = QgsMapToolEmitPoint(self.canvas) self.pointtool.canvasClicked.connect(self.set_viewer_location) self.settingsdialog = SettingsDialog(self.iface.mainWindow()) self.actions = [] self.menu = self.tr(u'&Earthmine') self.toolbar = self.iface.addToolBar(u'EarthMineQGIS') self.toolbar.setObjectName(u'EarthMineQGIS') self.legend = self.iface.legendInterface() emcolor = QColor(1, 150, 51) self.tempband = QgsRubberBand(self.canvas, QGis.Line) self.tempband.setWidth(5) self.tempband.setColor(emcolor) self.tempbandpoints = QgsRubberBand(self.canvas, QGis.Point) self.tempbandpoints.setWidth(7) self.tempbandpoints.setColor(emcolor) self.movingband = QgsRubberBand(self.canvas, QGis.Point) self.movingband.setWidth(5) self.movingband.setColor(emcolor) self.layersignals = [] self.marker = None
def settings_button_clicked(self): s = SettingsDialog(self) ret = s.exec_() if ret == 1: Settings.save(s.settings) self.settings = Settings.read() self.refresh_shortcuts()
def settingsDialog(self): dlg = SettingsDialog(self.theme, self.palette().highlight().color().name(), parent=self) dlg.exec() if dlg.theme != self.theme or dlg.hilite_color != self.palette().highlight().color().name(): settings = QSettings(QSettings.IniFormat, QSettings.UserScope, QCoreApplication.organizationName(), QCoreApplication.applicationName()) settings.setValue("theme", dlg.theme) settings.setValue("hiliteColor", dlg.hilite_color) msgBox = QMessageBox() msgBox.setText("Please restart the app to change the theme!") msgBox.exec()
def __init__(self, iface): self.iface = iface self.plugin_dir = os.path.dirname(__file__) self.dlgSettings = SettingsDialog() self.digitizingSetup = DigitizingSetup(self.iface) self.currentMode = None self.currentLayer = None self.isBackgroundSnapping = False self.initSettings()
class SplinePlugin: def __init__(self, iface): # Save reference to the QGIS interface self.iface = iface # There is bug in SIP (Transfer of QgsMapRenderer) # http://lists.osgeo.org/pipermail/qgis-developer/2013-December/029816.html # so we have to keep reference to QgsMapRenderer self.mapRenderer = iface.mapCanvas().mapRenderer() # initialize plugin directory self.plugin_dir = os.path.dirname(__file__) # initialize locale locale = QSettings().value("locale/userLocale")[0:2] localePath = os.path.join(self.plugin_dir, 'i18n', 'splineplugin_{}.qm'.format(locale)) if os.path.exists(localePath): self.translator = QTranslator() self.translator.load(localePath) if qVersion() > '4.3.3': QCoreApplication.installTranslator(self.translator) def initGui(self): self.settingsAction = QAction( QCoreApplication.translate("Spline", "Settings"), self.iface.mainWindow()) self.settingsAction.setObjectName("splineAction") self.settingsAction.triggered.connect(self.openSettings) self.iface.addPluginToVectorMenu(u"Digitize Spline", self.settingsAction) self.spline = SplineTool(self.iface) def unload(self): # Remove the plugin menu item and icon self.iface.removePluginVectorMenu(u"Digitize Spline", self.settingsAction) del self.spline # removes its action from toolbar def run(self): pass def openSettings(self): # button signals in SettingsDialog were not working on Win7/64 # if SettingsDialog was created with iface.mainWindow() as parent #self.settingsDialog = SettingsDialog(self.iface.mainWindow()) self.settingsDialog = SettingsDialog() self.settingsDialog.changed.connect(self.spline.settingsChanged) self.settingsDialog.show()
def openSettings(self): """Open settings dialog and reload settings""" settingsDialog = SettingsDialog(self.settings) settingsDialog.exec_() if self.settings["theme"] == "dark": self.dark_theme = True self.darkstyle = self.genDarkStyle() self.style = self.darkstyle else: self.dark_theme = False self.style = self.def_style #self.app.setStyleSheet("") self.app.setStyleSheet(self.style) self.resizeElements()
class SplinePlugin: def __init__(self, iface): # Save reference to the QGIS interface self.iface = iface # There is bug in SIP (Transfer of QgsMapRenderer) # http://lists.osgeo.org/pipermail/qgis-developer/2013-December/029816.html # so we have to keep reference to QgsMapRenderer self.mapRenderer = iface.mapCanvas().mapRenderer() # initialize plugin directory self.plugin_dir = os.path.dirname(__file__) # initialize locale locale = QSettings().value("locale/userLocale")[0:2] localePath = os.path.join(self.plugin_dir, 'i18n', 'splineplugin_{}.qm'.format(locale)) if os.path.exists(localePath): self.translator = QTranslator() self.translator.load(localePath) if qVersion() > '4.3.3': QCoreApplication.installTranslator(self.translator) def initGui(self): self.settingsAction = QAction( QCoreApplication.translate("Spline", "Settings" ), self.iface.mainWindow() ) self.settingsAction.setObjectName("splineAction") self.settingsAction.triggered.connect(self.openSettings) self.iface.addPluginToVectorMenu(u"Digitize Spline", self.settingsAction) self.spline = SplineTool(self.iface) def unload(self): # Remove the plugin menu item and icon self.iface.removePluginVectorMenu(u"Digitize Spline", self.settingsAction ) del self.spline # removes its action from toolbar def run(self): pass def openSettings(self): # button signals in SettingsDialog were not working on Win7/64 # if SettingsDialog was created with iface.mainWindow() as parent #self.settingsDialog = SettingsDialog(self.iface.mainWindow()) self.settingsDialog = SettingsDialog() self.settingsDialog.changed.connect( self.spline.settingsChanged ) self.settingsDialog.show()
def __init__(self, app=None): #QMainWindow.__init__(self, None) super(MainWindow, self).__init__(None) self.setupUi(self) self.app = app self.iface = backend.pm.Iface() self.busy = QProgressIndicator(self) self.busy.setFixedSize(QSize(20, 20)) self.setWindowIcon( QIcon("/usr/share/package-manager/data/tray-zero.svg")) self.setCentralWidget(MainWidget(self)) self.cw = self.centralWidget() self.settingsDialog = SettingsDialog(self) self.initializeActions() self.initializeStatusBar() self.initializeTray() self.connectMainSignals() self.pdsMessageBox = PMessageBox(self)
def openSettings(self): # button signals in SettingsDialog were not working on Win7/64 # if SettingsDialog was created with iface.mainWindow() as parent #self.settingsDialog = SettingsDialog(self.iface.mainWindow()) self.settingsDialog = SettingsDialog() self.settingsDialog.changed.connect( self.spline.settingsChanged ) self.settingsDialog.show()
def ShowSettings(self): if not self.settings_dialog: # Create the dialog the first time it's shown self.settings_dialog = SettingsDialog() self.settings_dialog.connect("accepted()", self.di_service.ReloadSettings) self.settings_dialog.connect("accepted()", self.sky_service.ReloadSettings) self.settings_dialog.show()
def setGetSaveSettings(self): self.pluginSettingsDic = {} try: self.getSaveSettings = GetSaveSettings(self.pluginSettingsDic, self.iface, self.projName, self.Path) self.pluginSettingsDic = self.getSaveSettings.getSettings(self.pluginSettingsDic) except: pass self.settingsDialog = SettingsDialog(self.iface, self.pluginSettingsDic, self.projName, self.Path)
def titleContextMenu(self, pos): menu = QMenu() menu.setStyleSheet('background: '+self.sets.get('window.menubgcolor','#222')+'; color: '+self.sets.get('window.menucolor','#fff')+'; padding: 6px;') settingsAction = menu.addAction("Настройка") settingsAction.setIcon(QIcon(':/set.png')) menu.addSeparator() addgroupAction = menu.addAction('Добавить группу') addgroupAction.setIcon(QIcon(':/addgroup.png')) menu.addSeparator() quitAction = menu.addAction("Quit") quitAction.setIcon(QIcon(':/quit.png')) action = menu.exec_(self.sender().mapToGlobal(pos)) if action == quitAction: self.onCloseSignal.emit(self) self.close() elif action == settingsAction: dialog = SettingsDialog(self.sets, self) dialog.loadfromsets() if dialog.exec() == 1: dialog.savetosets() self.sets.save() self.applysets() elif action == addgroupAction: shladd, title, withtext = groupedit.groupAdd(self.sets.get('panel.withtext',False)) if shladd: self.glist.addList(title, (0,0),withtext)
def __init__(self, iface): """Constructor. :param iface: An interface instance that will be passed to this class which provides the hook by which you can manipulate the QGIS application at run time. :type iface: QgsInterface """ # Save reference to the QGIS interface super(EarthMineQGIS, self).__init__() self.movingfeature = None self.iface = iface self.viewer = None self.canvas = self.iface.mapCanvas() self.settings = QSettings() # initialize plugin directory self.plugin_dir = os.path.dirname(__file__) # initialize locale locale = QSettings().value("locale/userLocale")[0:2] locale_path = os.path.join(self.plugin_dir, "i18n", "EarthMineQGIS_{}.qm".format(locale)) if os.path.exists(locale_path): self.translator = QTranslator() self.translator.load(locale_path) if qVersion() > "4.3.3": QCoreApplication.installTranslator(self.translator) self.pointtool = QgsMapToolEmitPoint(self.canvas) self.pointtool.canvasClicked.connect(self.set_viewer_location) self.settingsdialog = SettingsDialog(self.iface.mainWindow()) self.actions = [] self.menu = self.tr(u"&Earthmine") self.toolbar = self.iface.addToolBar(u"EarthMineQGIS") self.toolbar.setObjectName(u"EarthMineQGIS") self.legend = self.iface.legendInterface() emcolor = QColor(1, 150, 51) self.tempband = QgsRubberBand(self.canvas, QGis.Line) self.tempband.setWidth(5) self.tempband.setColor(emcolor) self.tempbandpoints = QgsRubberBand(self.canvas, QGis.Point) self.tempbandpoints.setWidth(7) self.tempbandpoints.setColor(emcolor) self.movingband = QgsRubberBand(self.canvas, QGis.Point) self.movingband.setWidth(5) self.movingband.setColor(emcolor) self.layersignals = [] self.marker = None
def settings_dialog(self): """ Opens the settings window allowing the user to manually change the settings in the config file """ logger.info('Opening settings window') if (not SettingsDialog.singleton): SettingsDialog(self.__root, self). \ wm_iconbitmap(ICO) else: logger.warning('Found existing settings window, canceling')
def __init__(self, parent=None): KXmlGuiWindow.__init__(self, parent) self.setupUi(self) self.setWindowIcon(KIcon(":/data/package-manager.png")) self.setCentralWidget(MainWidget(self)) self.settingsDialog = SettingsDialog(self) self.initializeActions() self.initializeStatusBar() self.initializeTray() self.connectMainSignals() self.offlinemanager = OfflineManager() self.connectOfflineSignals()
def __init__(self, app = None, silence = False): QtGui.QMainWindow.__init__(self) self.setupUi(self) self.iface = backend.pm.Iface() self.setWindowIcon(QtGui.QIcon(":/data/package-manager.png")) self.connect(app, SIGNAL("aboutToQuit()"), self.slotQuit) self.setCentralWidget(MainWidget(self, silence)) self.initializeActions() if not silence: self.settingsDialog = SettingsDialog(self) self.initializeStatusBar() self.initializeTray() self.connectMainSignals()
def __init__(self, loadFile=None, fileType=None): QtGui.QMainWindow.__init__(self) self.setupUi(self) self.setWindowIcon(QtGui.QIcon(':moose_thumbnail.png')) self.settingsDialog = SettingsDialog() self.settingsDialog.hide() layout = QtGui.QVBoxLayout(self.modelTreeTab) self.modelTreeTab.setLayout(layout) layout.addWidget(self.modelTreeContainerWidget) self.modelTreeWidget.headerItem().setHidden(True) self.plotUpdateIntervalLabel.setText(self.tr('<br>Plot update interval (<b>steps</b>)')) self.runTimeLabel.setText(self.tr('<br>Run for (<b>seconds</b>)')) # self.modelTreeWidget.show() # self.mooseClassToolBox.show() ################### # self.plotsLayout = QtGui.QHBoxLayout(self.plotsGroupBox) # self.plotsGroupBox.setLayout(self.plotsLayout) # self.plotsScrollArea = QtGui.QScrollArea(self.plotsGroupBox) # self.plotsLayout.addWidget(self.plotsScrollArea) # self.plots = MoosePlots(self.plotsScrollArea) # self.plotsScrollArea.setWidget(self.plots) # self.plots.show() ################## self.plots = MoosePlots(self.plotsGroupBox) self.plotsLayout = QtGui.QHBoxLayout(self.plotsGroupBox) self.plotsGroupBox.setLayout(self.plotsLayout) self.plotsLayout.addWidget(self.plots) ###################### self.plots.show() self.isModelLoaded = False self.stopFlag = False self.mooseHandler = MHandler() self.runTimeLineEdit.setText(self.tr(str(self.mooseHandler.runTime))) self.plotUpdateIntervalLineEdit.setText(self.tr(str(self.mooseHandler.updateInterval))) self.currentDirectory = '.' self.fileType = fileType self.fileTypes = MHandler.file_types self.filter = '' self.setupActions() if loadFile is not None and fileType is not None: self.load(loadFile, fileType)
def __init__(self, app=None): KXmlGuiWindow.__init__(self, None) self.setupUi(self) self.app = app self.iface = backend.pm.Iface() self.busy = QProgressIndicator(self) self.busy.setFixedSize(QSize(20, 20)) self.setWindowIcon(KIcon(":/data/package-manager.png")) self.setCentralWidget(MainWidget(self)) self.cw = self.centralWidget() self.settingsDialog = SettingsDialog(self) self.initializeActions() self.initializeStatusBar() self.initializeTray() self.connectMainSignals() self.pdsMessageBox = PMessageBox(self)
class Plugin: def __init__(self): self.settings_dialog = None cb = self.ShowSettings # Register for when the user clicks the Settings button __script__.connect("SettingsDialogRequested()", cb) # Create the services and add them to the Internet tab self.di_service = DigitallyImportedService(clementine.internet_model, cb) self.sky_service = SkyFmService(clementine.internet_model, cb) clementine.internet_model.AddService(self.di_service) clementine.internet_model.AddService(self.sky_service) def ShowSettings(self): if not self.settings_dialog: # Create the dialog the first time it's shown self.settings_dialog = SettingsDialog() self.settings_dialog.connect("accepted()", self.di_service.ReloadSettings) self.settings_dialog.connect("accepted()", self.sky_service.ReloadSettings) self.settings_dialog.show()
def configureSettings(self): settingsDialog = SettingsDialog(self, self.settingsManager) settingsDialog.show()
class DateControl: def __init__(self, iface): # Save reference to the QGIS interface self.iface = iface # initialize plugin directory self.plugin_dir = os.path.dirname(__file__) # initialize locale locale = QSettings().value("locale/userLocale")[0:2] localePath = os.path.join(self.plugin_dir, 'i18n', 'datecontrol_{}.qm'.format(locale)) self.proj = QgsProject.instance() UriFile = str(self.proj.fileName()) self.Path = str(os.path.dirname(UriFile)) # QMessageBox.warning(None, "Path",self.Path) self.projName = UriFile[len(self.Path)+1:] if os.path.exists(localePath): self.translator = QTranslator() self.translator.load(localePath) if qVersion() > '4.3.3': QCoreApplication.installTranslator(self.translator) # Create the dialog (after translation) and keep reference self.setGetSaveSettings() self.dock = DateControlDock(self.iface, self.pluginSettingsDic) def initGui(self): # Create action that will start plugin configuration self.action = QAction(QIcon(":/plugins/datecontrol/DateControlControl.png"), u"Date control", self.iface.mainWindow()) # connect the action to the run method self.action.triggered.connect(self.run) self.settingsAction = QAction(QIcon(":/plugins/datecontrol/DateControlSettings.png"), u"Settings", self.iface.mainWindow()) self.settingsAction.triggered.connect(self.showSettings) self.convertDatesAction = QAction(QIcon(":/plugins/datecontrol/DateControlCheckDates.png"), u"Convert dates", self.iface.mainWindow()) self.convertDatesAction.triggered.connect(self.showConvertDates) # self.iface.mapCanvas().layersChanged.connect(self.layersChanged) self.iface.projectRead.connect(self.changeProject) # Add toolbar button and menu item self.iface.addToolBarIcon(self.action) self.iface.addToolBarIcon(self.settingsAction) self.iface.addToolBarIcon(self.convertDatesAction) self.iface.addPluginToMenu(u"&DateControl", self.action) self.iface.addPluginToMenu(u"&DateControl", self.settingsAction) self.iface.addPluginToMenu(u"&DateControl", self.convertDatesAction) def changeProject(self): if not QgsProject is None: self.proj = QgsProject.instance() UriFile = str(self.proj.fileName()) self.Path = str(os.path.dirname(UriFile)) self.projName = UriFile[len(self.Path)+1:] else: self.projName = "" self.setGetSaveSettings() settingsKeys = self.pluginSettingsDic.keys() self.dock = DateControlDock(self.iface, self.pluginSettingsDic) self.convertDatesDialog = convertDatesDialog(self.iface) def setGetSaveSettings(self): self.pluginSettingsDic = {} try: self.getSaveSettings = GetSaveSettings(self.pluginSettingsDic, self.iface, self.projName, self.Path) self.pluginSettingsDic = self.getSaveSettings.getSettings(self.pluginSettingsDic) except: pass self.settingsDialog = SettingsDialog(self.iface, self.pluginSettingsDic, self.projName, self.Path) # run method that performs all the real work def run(self): # show the dialog self.openDateControlDock() # try: # self.openDateControlDock() # except: # pass def showConvertDates(self): self.convertDatesDialog = convertDatesDialog(self.iface) self.convertDatesDialog.show() # Run the dialog event loop self.convertDatesDialog.exec_() def showSettings(self): self.settingsDialog.show() # Run the dialog event loop if self.settingsDialog.exec_(): self.pluginSettingsDic = self.settingsDialog.pluginSettingsDic self.dock = DateControlDock(self.iface, self.pluginSettingsDic) def openDateControlDock(self): self.dock.getLayersData() self.iface.addDockWidget(Qt.LeftDockWidgetArea, self.dock) def unload(self): # Remove the plugin menu item and icon self.dock.resetLayerQueries() self.iface.removePluginMenu(u"&DateControl", self.action) self.iface.removeToolBarIcon(self.action) self.iface.removePluginMenu(u"&DateControl", self.settingsAction) self.iface.removeToolBarIcon(self.settingsAction) self.iface.removePluginMenu(u"&DateControl", self.convertDatesAction) self.iface.removeToolBarIcon(self.convertDatesAction)
class EarthMineQGIS(QObject): """QGIS Plugin Implementation.""" def __init__(self, iface): """Constructor. :param iface: An interface instance that will be passed to this class which provides the hook by which you can manipulate the QGIS application at run time. :type iface: QgsInterface """ # Save reference to the QGIS interface super(EarthMineQGIS, self).__init__() self.movingfeature = None self.iface = iface self.viewer = None self.canvas = self.iface.mapCanvas() self.settings = QSettings() # initialize plugin directory self.plugin_dir = os.path.dirname(__file__) # initialize locale locale = QSettings().value('locale/userLocale')[0:2] locale_path = os.path.join(self.plugin_dir, 'i18n', 'EarthMineQGIS_{}.qm'.format(locale)) if os.path.exists(locale_path): self.translator = QTranslator() self.translator.load(locale_path) if qVersion() > '4.3.3': QCoreApplication.installTranslator(self.translator) self.pointtool = QgsMapToolEmitPoint(self.canvas) self.pointtool.canvasClicked.connect(self.set_viewer_location) self.settingsdialog = SettingsDialog(self.iface.mainWindow()) self.actions = [] self.menu = self.tr(u'&Earthmine') self.toolbar = self.iface.addToolBar(u'EarthMineQGIS') self.toolbar.setObjectName(u'EarthMineQGIS') self.legend = self.iface.legendInterface() emcolor = QColor(1, 150, 51) self.tempband = QgsRubberBand(self.canvas, QGis.Line) self.tempband.setWidth(5) self.tempband.setColor(emcolor) self.tempbandpoints = QgsRubberBand(self.canvas, QGis.Point) self.tempbandpoints.setWidth(7) self.tempbandpoints.setColor(emcolor) self.movingband = QgsRubberBand(self.canvas, QGis.Point) self.movingband.setWidth(5) self.movingband.setColor(emcolor) self.layersignals = [] self.marker = None def initGui(self): """Create the menu entries and toolbar icons inside the QGIS GUI.""" icon_path = ':/icons/settings' self.add_action(icon_path, text=self.tr(u'Show Settings'), callback=self.show_settings, parent=self.iface.mainWindow()) icon_path = ':/icons/viewer' self.add_action(icon_path, text=self.tr(u'Earthmine Viewer'), callback=self.open_viewer, parent=self.iface.mainWindow()) self.marker = PostionMarker(self.canvas) self.marker.hide() self.viewer = Viewer(callbackobject=self) self.viewer.trackingChanged.connect(self.marker.setTracking) self.viewer.setLocationTriggered.connect( partial(self.canvas.setMapTool, self.pointtool)) self.viewer.updateFeatures.connect(self.update_earthmine_features) self.viewer.layerChanged.connect(self.iface.setActiveLayer) self.viewer.clearLine.connect(self.clear_bands) self.viewer.closed.connect(self.remove_items) self.iface.currentLayerChanged.connect( self.viewer.update_current_layer) cursor = QCursor(QPixmap(":/icons/location")) self.pointtool.setCursor(cursor) self.pointtool.setAction(self.viewer.setlocationaction) def remove_items(self): self.marker.setTracking(False) self.disconnect_projectsignals() self.iface.actionPan().trigger() def unload(self): """Removes the plugin menu item and icon from QGIS GUI.""" self.canvas.scene().removeItem(self.marker) del self.marker self.disconnect_projectsignals() for action in self.actions: self.iface.removePluginMenu(self.tr(u'&Earthmine'), action) self.iface.removeToolBarIcon(action) del self.toolbar self.iface.removeDockWidget(self.viewer) self.viewer.deleteLater() def disconnect_projectsignals(self): safe_disconnect(QgsMapLayerRegistry.instance().layerWasAdded, self.connect_layer_signals) safe_disconnect(QgsMapLayerRegistry.instance().layersRemoved, self.layers_removed) safe_disconnect(self.canvas.layersChanged, self.layers_changed) safe_disconnect(self.iface.projectRead, self.connect_signals) safe_disconnect(self.canvas.selectionChanged, self.selection_changed) safe_disconnect(self.canvas.selectionChanged, self.viewer.selection_changed) def clear_bands(self): self.tempband.reset(QGis.Line) self.tempbandpoints.reset(QGis.Point) def visible_layers(self): """ Return the visible layers shown in the map canvas :return: """ return (layer for layer, visible in self.layers_with_states() if visible) def layers_with_states(self): for layer in maplayers(): if not layer.type() == QgsMapLayer.VectorLayer: continue if not layer.geometryType() in [QGis.Point, QGis.Line]: continue yield layer, self.legend.isLayerVisible(layer) def _layer_feature_added(self, featureid): layer = self.sender() if not layer: return self.layer_feature_added(layer, featureid) def layer_feature_added(self, layer, featureid): if not self.viewer: return feature = layer.getFeatures(QgsFeatureRequest(featureid)).next() renderer = layer.rendererV2() transform = self.coordinatetransform(layer) featuredata = to_feature_data(layer.id(), feature, renderer, transform) geomtype = layer.geometryType() layerdata = dict(id=layer.id(), geomtype=QGis.vectorGeometryType(geomtype)) self.viewer.load_features(layerdata, featuredata) def _layer_feature_delete(self, featureid): layer = self.sender() if not layer: return self.layer_feature_delete(layer, featureid) def layer_feature_delete(self, layer, featureid): if not self.viewer: return self.viewer.remove_feature(layer.id(), featureid) def _layer_geometry_changed(self, featureid, geometry): layer = self.sender() if not layer: return self.layer_geometry_changed(layer, featureid, geometry) def layer_geometry_changed(self, layer, featureid, geometry): if not self.viewer: return geomtype = layer.geometryType() if geomtype == QGis.Point: geom = geometry.asPoint() transform = self.coordinatetransform(layer) point = transform.transform( geom, QgsCoordinateTransform.ReverseTransform) location = dict(lat=point.y(), lng=point.x()) self.viewer.edit_feature(layer.id(), featureid, [location]) elif geomtype == QGis.Line: self.layer_feature_delete(layer, featureid) self.layer_feature_added(layer, featureid) def connect_layer_signals(self, layer): if not layer.type() == QgsMapLayer.VectorLayer: return layer.featureAdded.connect(self._layer_feature_added) layer.featureDeleted.connect(self._layer_feature_delete) layer.editingStarted.connect(self.layer_editstate_changed) layer.editingStopped.connect(self.layer_editstate_changed) # HACK The new style doesn't work here # http://hub.qgis.org/issues/6573 signal = SIGNAL("geometryChanged(QgsFeatureId, QgsGeometry&)") self.connect(layer, signal, self._layer_geometry_changed) self.load_layer_features(layers=[layer]) def layer_editstate_changed(self): layer = self.sender() if layer == self.iface.activeLayer(): self.viewer.layer_changed(layer) def disconnect_signals(self): self.disconnect_projectsignals() for layer in maplayers(): if not layer.type() == QgsMapLayer.VectorLayer: return safe_disconnect(layer.featureAdded, self._layer_feature_added) safe_disconnect(layer.featureDeleted, self._layer_feature_delete) safe_disconnect(layer.editingStarted, self.layer_editstate_changed) safe_disconnect(layer.editingStopped, self.layer_editstate_changed) # HACK The new style doesn't work here # http://hub.qgis.org/issues/6573 signal = SIGNAL("geometryChanged(QgsFeatureId, QgsGeometry&)") self.disconnect(layer, signal, self._layer_geometry_changed) def connect_signals(self): for layer in maplayers(): self.connect_layer_signals(layer) self.center_on_canvas() def set_viewer_location(self, point, mousebutton): transform = self.coordinatetransform() point = transform.transform(point, QgsCoordinateTransform.ReverseTransform) self.viewer.set_location(point) def distancearea(self): area = QgsDistanceArea() dest = self.canvas.mapRenderer().destinationCrs() area.setSourceCrs(dest) return area, dest.mapUnits() def coordinatetransform(self, layer=None): """ Return the transform for WGS84 -> QGIS projection. """ source = QgsCoordinateReferenceSystem() source.createFromWkt( 'GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",SPHEROID["WGS_1984",6378137.0,298.257223563]],PRIMEM["Greenwich",0.0],UNIT["Degree",0.0174532925199433]]' ) if not layer: dest = self.canvas.mapRenderer().destinationCrs() else: dest = layer.crs() transform = QgsCoordinateTransform(source, dest) return transform def earthmine_settings(self): settings = {} with settinggroup(self.settings, "plugins/Earthmine"): for key in [ 'serviceUrl', 'baseDataUrl', "apiKey", 'secretKey', 'viewerUrl' ]: if not self.settings.contains(key): raise EarthmineSettingsError("{} not set".format(key)) value = self.settings.value(key, type=str) if value is None: raise EarthmineSettingsError("{} not set".format(key)) settings[key] = value return settings @pyqtSlot() def ready(self): """ Called when the viewer is ready to be started. At this point the viewer hasn't been loaded so no other methods apart from startViewer will be handled. """ settings = self.earthmine_settings() self.viewer.startViewer(settings) @pyqtSlot() def viewerReady(self): """ Called once the viewer is loaded and ready to get location events. """ self.disconnect_signals() self.connect_signals() self.iface.projectRead.connect(self.connect_signals) self.canvas.layersChanged.connect(self.layers_changed) self.canvas.selectionChanged.connect(self.selection_changed) self.canvas.selectionChanged.connect(self.viewer.selection_changed) QgsMapLayerRegistry.instance().layersRemoved.connect( self.layers_removed) QgsMapLayerRegistry.instance().layerWasAdded.connect( self.connect_layer_signals) self.center_on_canvas() self.viewer.activelayercombo.setLayer(self.iface.activeLayer()) def center_on_canvas(self): point = self.canvas.extent().center() transform = self.coordinatetransform() point = transform.transform(point, QgsCoordinateTransform.ReverseTransform) self.viewer.set_location(point) self.viewer.infoaction.toggle() def selection_changed(self, layer): ids = [feature.id() for feature in layer.selectedFeatures()] if not ids: self.viewer.clear_selection(layer.id()) else: self.viewer.set_selection(layer.id(), ids) def layers_changed(self): layerstates = self.layers_with_states() for layer, visible in layerstates: layerid = layer.id() viewerloaded = self.viewer.layer_loaded(layerid) QgsMessageLog.instance().logMessage(layerid, "Earthmine") QgsMessageLog.instance().logMessage( "Viewer State:" + str(viewerloaded), "Earthmine") QgsMessageLog.instance().logMessage("QGIS State:" + str(visible), "Earthmine") if (viewerloaded and visible) or (not viewerloaded and not visible): QgsMessageLog.instance().logMessage("Ignoring as states match", "Earthmine") continue if viewerloaded and not visible: QgsMessageLog.instance().logMessage( "Clearing layer because viewer loaded and disabled in QGIS", "Earthmine") self.viewer.clear_layer_features(layerid) continue if not viewerloaded and visible: QgsMessageLog.instance().logMessage("Loading layer", "Earthmine") self.load_layer_features(layers=[layer]) continue def layers_removed(self, layers): for layerid in layers: self.viewer.clear_layer_features(layerid) @pyqtSlot(str, float, float) def viewChanged(self, event, yaw, angle): self.marker.setAngle(angle) self.marker.setYaw(yaw) @pyqtSlot(str, str) def getInfo(self, layerid, featureid): featureid = int(featureid) activelayer = self.iface.activeLayer() if not activelayer: return activetool = self.viewer.active_tool() if not activetool in ["Info", "Select"]: return # Only show information for the active layer if not layerid == activelayer.id(): return layer = layer_by_id(layerid) if activetool == "Select": layer.setSelectedFeatures([featureid]) elif activetool == "Info": rq = QgsFeatureRequest(featureid) feature = layer.getFeatures(rq).next() dlg = get_feature_form(layer, feature) if dlg.dialog().exec_(): self.canvas.refresh() @pyqtSlot(str, str, float, float, bool) def featureMoved(self, layerid, featureid, lat, lng, end): layer = layer_by_id(layerid) transform = self.coordinatetransform(layer) point = transform.transform(lng, lat) if not end: self.movingband.show() self.movingband.setToGeometry(QgsGeometry.fromPoint(point), layer) self.movingband.updatePosition() self.movingband.update() else: self.movingband.hide() feature = feature_by_id(layer, featureid) startpoint = feature.geometry().asPoint() dx = point.x() - startpoint.x() dy = point.y() - startpoint.y() layer.beginEditCommand("Feature Moved") # Block signals for this move as the geometry changed signal will re add the geometry on use. layer.blockSignals(True) layer.translateFeature(feature.id(), dx, dy) layer.blockSignals(False) self.canvas.refresh() layer.endEditCommand() @pyqtSlot(str, str) def onError(self, message, stacktrace=None): self.iface.messageBar().pushMessage("Earthmine", message, QgsMessageBar.WARNING) QgsMessageLog.logMessage(stacktrace, "Earthmine") @pyqtSlot(float, float, float) def addPoint(self, lat, lng, z): layer = self.viewer.active_layer if not layer.isEditable(): self.iface.messageBar().pushMessage( "Earthmine", "Selected layer isn't editable. Please enable edit mode to add features", duration=3, level=QgsMessageBar.WARNING) return transform = self.coordinatetransform(layer) point = transform.transform(lng, lat) geom = QgsGeometry.fromPoint(point) self.add_feature(layer, geom, z) def add_feature(self, layer, geom, z=None): feature = QgsFeature(layer.pendingFields()) if z and self.viewer.copyZvalue: try: feature['Z'] = z except KeyError: QgsMessageLog.log("No Z found on layer {}".format( layer.name())) pass feature.setGeometry(geom) dlg = get_feature_form(layer, feature, isadd=True) if dlg.dialog().exec_(): self.canvas.refresh() @pyqtSlot(str, bool, str) def drawLine(self, points, end, stats): points = json.loads(points) stats = json.loads(stats) QgsMessageLog.logMessage(str(stats), "Earthmine") self.tempband.reset(QGis.Line) self.tempbandpoints.reset(QGis.Point) color = QColor(self.viewer.current_action_color) self.tempband.setColor(color) self.tempbandpoints.setColor(color) layer = self.viewer.active_layer transform = self.coordinatetransform(layer) earthminepoints = [] for point in points: newpoint = transform.transform(point['lng'], point['lat']) self.tempband.addPoint(newpoint) self.tempbandpoints.addPoint(newpoint) empoint = EarthminePoint(newpoint, point) earthminepoints.append(empoint) if end and not self.viewer.mode == "Vertical": geom = self.tempband.asGeometry() self.add_feature(layer, geom) self.clear_bands() self.viewer.geom = EarthmineLine(earthminepoints, stats) self.tempband.show() self.tempbandpoints.show() @pyqtSlot(str, str, str, float) def locationChanged(self, lat, lng, yaw, angle): transform = self.coordinatetransform() point = transform.transform(float(lng), float(lat)) self.marker.setCenter(point) yaw = float(yaw) self.marker.setAngle(angle) self.marker.setYaw(yaw) self.marker.setTracking(self.viewer.tracking) if self.marker.tracking: rect = QgsRectangle(point, point) extentlimt = QgsRectangle(self.canvas.extent()) extentlimt.scale(0.95) if not extentlimt.contains(point): self.canvas.setExtent(rect) self.canvas.refresh() # Clear old features self.viewer.clear_features() self.load_layer_features(point) def update_earthmine_features(self, viewfeatures): self.viewer.clear_features() if viewfeatures: self.load_layer_features() def load_layer_features(self, point=None, layers=None): # TODO Move this logic into the viewer and let it track it's position if point is None and self.marker.map_pos is None: return if point is None: point = self.marker.map_pos area, units = self.distancearea() rect = search_area(units, area, point) if layers is None: layers = self.visible_layers() for layer in layers: transform = self.coordinatetransform(layer) # Transform the rect source = self.canvas.mapRenderer().destinationCrs() dest = layer.crs() recttransform = QgsCoordinateTransform(source, dest) rect = recttransform.transformBoundingBox(rect) features = list( get_features_in_area(layer, rect, transform, self.canvas.mapSettings())) geomtype = layer.geometryType() layerdata = dict(id=layer.id(), geomtype=QGis.vectorGeometryType(geomtype)) self.viewer.load_features(layerdata, features) # noinspection PyMethodMayBeStatic def tr(self, message): """Get the translation for a string using Qt translation API. We implement this ourselves since we do not inherit QObject. :param message: String for translation. :type message: str, QString :returns: Translated version of message. :rtype: QString """ # noinspection PyTypeChecker,PyArgumentList,PyCallByClass return QCoreApplication.translate('EarthMineQGIS', message) def add_action(self, icon_path, text, callback, enabled_flag=True, add_to_menu=True, add_to_toolbar=True, status_tip=None, whats_this=None, parent=None): """Add a toolbar icon to the InaSAFE toolbar. :param icon_path: Path to the icon for this action. Can be a resource path (e.g. ':/plugins/foo/bar.png') or a normal file system path. :type icon_path: str :param text: Text that should be shown in menu items for this action. :type text: str :param callback: Function to be called when the action is triggered. :type callback: function :param enabled_flag: A flag indicating if the action should be enabled by default. Defaults to True. :type enabled_flag: bool :param add_to_menu: Flag indicating whether the action should also be added to the menu. Defaults to True. :type add_to_menu: bool :param add_to_toolbar: Flag indicating whether the action should also be added to the toolbar. Defaults to True. :type add_to_toolbar: bool :param status_tip: Optional text to s, "Earhtmine"how in a popup when mouse pointer hovers over the action. :type status_tip: str :param parent: Parent widget for the new action. Defaults None. :type parent: QWidget :param whats_this: Optional text to show in the status bar when the mouse pointer hovers over the action. :returns: The action that was created. Note that the action is also added to self.actions list. :rtype: QAction """ icon = QIcon(icon_path) action = QAction(icon, text, parent) action.triggered.connect(callback) action.setEnabled(enabled_flag) if status_tip is not None: action.setStatusTip(status_tip) if whats_this is not None: action.setWhatsThis(whats_this) if add_to_toolbar: self.toolbar.addAction(action) if add_to_menu: self.iface.addPluginToMenu(self.menu, action) self.actions.append(action) return action def open_viewer(self): """Run method that performs all the real work""" try: settings = self.earthmine_settings() except EarthmineSettingsError as ex: self.onError(ex.message) self.show_settings() return url = settings["viewerUrl"] if not url.startswith("http"): url = url.replace("\\\\", "\\") url = QUrl.fromLocalFile(url) else: url = QUrl(url) if not self.viewer.isVisible(): self.iface.addDockWidget(Qt.RightDockWidgetArea, self.viewer) self.viewer.loadviewer(url) def show_settings(self): self.settingsdialog.show()
def showSettings(self): dlg = SettingsDialog(self) dlg.exec_()
def display_settings(self): """Display a dialog box with plugin settings.""" dialog = SettingsDialog(self) dialog.run() self.refresh()
def settings_click_cb(self, widget): dialog = SettingsDialog(widget.get_toplevel()) dialog.show()
def setting(self): from settingsdialog import SettingsDialog dialog = SettingsDialog(self.iface) dialog.show() dialog.exec_()
def on_actionConfigure_triggered(self): dialog = SettingsDialog(self.programSettings, self) dialog.rowHeightChanged.connect(self.setRowHeight) dialog.exec_()
def openSettings(self): """Open settings dialog and reload settings""" settingsDialog = SettingsDialog(self.settings) settingsDialog.exec_()
def openSettings(self): self.settingsDialog = SettingsDialog() self.settingsDialog.changed.connect(self.spline.settingsChanged) self.settingsDialog.show()
class QuickDigitize: """QGIS Plugin Implementation.""" def __init__(self, iface): """Constructor. :param iface: An interface instance that will be passed to this class which provides the hook by which you can manipulate the QGIS application at run time. :type iface: QgisInterface """ # Save reference to the QGIS interface self.iface = iface self.canvas = self.iface.mapCanvas() # initialize plugin directory self.plugin_dir = os.path.dirname(__file__) # initialize locale # locale = QSettings().value('locale/userLocale')[0:2] # locale_path = os.path.join( # self.plugin_dir, # 'i18n', # 'QuickDigitize_{}.qm'.format(locale)) userPluginPath = QFileInfo(QgsApplication.qgisUserDbFilePath()).path( ) + "/python/plugins/QuickDigitize" systemPluginPath = QgsApplication.prefixPath( ) + "/share/qgis/python/plugins/QuickDigitize" locale = QSettings().value("locale/userLocale") myLocale = locale[0:2] if QFileInfo(userPluginPath).exists(): pluginPath = userPluginPath + "/i18n/QuickDigitize_" + myLocale + ".qm" elif QFileInfo(systemPluginPath).exists(): pluginPath = systemPluginPath + "/i18n/QuickDigitize_" + myLocale + ".qm" self.locale_path = pluginPath if QFileInfo(self.locale_path).exists(): self.translator = QTranslator() self.translator.load(locale_path) if qVersion() > '4.3.3': QCoreApplication.installTranslator(self.translator) # Declare instance attributes self.actions = [] self.dlg = QuickDigitizeDialog() self.menu = self.tr(u'&QuickDigitize') # TODO: We are going to let the user set this up in a future iteration self.toolbar = self.iface.addToolBar(u'QuickDigitize') self.toolbar.setObjectName(u'QuickDigitize') self.createpointlayer = CreatePointLayerTool(self.iface, self.toolbar) self.createlinelayer = CreateLineLayerTool(self.iface, self.toolbar) self.createpolygonlayer = CreatePolygonLayerTool( self.iface, self.toolbar) self.spline = SplineTool(self.iface, self.toolbar) self.ortho = OrthogonalDigitizerTool(self.iface, self.toolbar) self.rectangle = RectTool(self.iface, self.toolbar) self.addattribute = AddAttributeTool(self.iface, self.toolbar) self.addfields = AddFieldsTool(self.iface, self.toolbar) self.showazimuth = ShowAzimuthTool(self.iface, self.toolbar) self.rotateobject = RotateObjectTool(self.iface, self.toolbar) self.addstyle = AddStyleTool(self.iface, self.toolbar) toolbars = iface.mainWindow().findChildren(QToolBar) for self.toolbar in toolbars: self.toolbar.setIconSize(QSize(48, 48)) self.dlg.lineEdit.clear() self.dlg.pushButton.clicked.connect(self.select_output_file) # noinspection PyMethodMayBeStatic def tr(self, message): """Get the translation for a string using Qt translation API. We implement this ourselves since we do not inherit QObject. :param message: String for translation. :type message: str, QString :returns: Translated version of message. :rtype: QString """ # noinspection PyTypeChecker,PyArgumentList,PyCallByClass return QCoreApplication.translate('QuickDigitize', message) def add_action(self, icon_path, text, callback, enabled_flag=True, add_to_menu=True, add_to_toolbar=True, status_tip=None, whats_this=None, parent=None): # Create the dialog (after translation) and keep reference self.dlg = QuickDigitizeDialog() icon = QIcon(icon_path) action = QAction(icon, text, parent) action.triggered.connect(callback) action.setEnabled(enabled_flag) if status_tip is not None: action.setStatusTip(status_tip) if whats_this is not None: action.setWhatsThis(whats_this) if add_to_toolbar: self.toolbar.addAction(action) if add_to_menu: self.iface.addPluginToVectorMenu(self.menu, action) self.actions.append(action) return action def initGui(self): """Create the menu entries and toolbar icons inside the QGIS GUI.""" icon_path = ':/plugins/QuickDigitize/icon.png' self.add_action(icon_path, text=self.tr(u'Quick Digitize'), callback=self.run, parent=self.iface.mainWindow()) self.settingsAction = QAction( QCoreApplication.translate("Spline", "Settings"), self.iface.mainWindow()) self.settingsAction.setObjectName("splineAction") self.settingsAction.triggered.connect(self.openSettings) self.iface.addPluginToVectorMenu(u"Digitize Spline", self.settingsAction) self.settingsAction.triggered.connect(self.openSettings) def unload(self): """Removes the plugin menu item and icon from QGIS GUI.""" for action in self.actions: self.iface.removePluginMenu(self.tr(u'&QuickDigitize'), action) self.iface.removeToolBarIcon(action) self.iface.removePluginVectorMenu(u'Digitize Spline', self.settingsAction) # remove the toolbar del self.toolbar def openSettings(self): self.settingsDialog = SettingsDialog() self.settingsDialog.changed.connect(self.spline.settingsChanged) self.settingsDialog.show() def select_output_file(self): filename = QFileDialog.getSaveFileName(self.dlg, "Select output file ", "", '*.*') self.dlg.lineEdit.setText(filename) def run(self): layers = self.iface.legendInterface().layers() layer_list = [] for layer in layers: layer_list.append(layer.name()) self.dlg.comboBox.clear() self.dlg.comboBox.addItems(layer_list) # show the dialog self.dlg.show() # Run the dialog event loop result = self.dlg.exec_() # See if OK was pressed if result: filename = self.dlg.lineEdit.text() output_file = open(filename, 'w') selectedLayerIndex = self.dlg.comboBox.currentIndex() selectedLayer = layers[selectedLayerIndex] fields = selectedLayer.pendingFields() fieldnames = [field.name() for field in fields] for f in selectedLayer.getFeatures(): line = ','.join(unicode(f[x]) for x in fieldnames) + '\n' unicode_line = line.encode('utf-8') output_file.write(unicode_line) output_file.close()
class GVDigitizingTools: def __init__(self, iface): self.iface = iface self.plugin_dir = os.path.dirname(__file__) self.dlgSettings = SettingsDialog() self.digitizingSetup = DigitizingSetup(self.iface) self.currentMode = None self.currentLayer = None self.isBackgroundSnapping = False self.initSettings() def initSettings(self): # set default if first time this ie executed settings = QSettings() method = settings.value(constants.ARC_METHOD, constants.ARC_METHOD_ANGLE) settings.setValue(constants.ARC_METHOD, method) angle = settings.value(constants.ARC_ANGLE, 3.0, type=float) settings.setValue(constants.ARC_ANGLE, angle) numberOfPoints = settings.value(constants.ARC_NUMBEROFPOINTS, 10, type=int) settings.setValue(constants.ARC_NUMBEROFPOINTS, numberOfPoints) enablePreview = settings.value(constants.PREVIEW_ENABLED, True) settings.setValue(constants.PREVIEW_ENABLED, enablePreview) enablePreviewLimit = settings.value(constants.PREVIEW_LIMIT_ENABLED, False) settings.setValue(constants.PREVIEW_LIMIT_ENABLED, enablePreviewLimit) maxLimitPreview = settings.value(constants.PREVIEW_LIMIT_MAX, 1000) settings.setValue(constants.PREVIEW_LIMIT_MAX, maxLimitPreview) def initGui(self): self.actions = [] self.createAction("actionSettings", "icons/iconSettings.png", u"Settings", self.doShowSettings, checkable=False) self.createAction("action", "icon.png", u"Digitizing tools", self.doSetupDigitizing) self.createAction("actionBackgroundSnapping", "icons/iconSnap.png", u"Snap to background layers", self.doSetupBackgroundSnapping) self.createAction("actionDrawArc", "icons/iconDrawArc.png", u"Add arc", self.doDrawArc, "Alt+Ctrl+S") self.createAction("actionExtend", "icons/iconExtend.png", u"Extend", self.doExtend, "Alt+Ctrl+E") self.createAction("actionFillet", "icons/iconFillet.png", u"Fillet", self.doFillet, "Alt+Ctrl+F") self.createAction("actionTrim", "icons/iconTrim.png", u"Trim", self.doTrim, "Alt+Ctrl+C") self.createAction("actionMirror", "icons/iconMirror.png", u"Mirror", self.doMirror, "Alt+Ctrl+W") self.createAction("actionScale", "icons/iconScale.png", u"Scale", self.doScale, "Alt+Ctrl+Z") self.createAction("actionMove", "icons/iconMove.png", u"Move", self.doMove, "Alt+Ctrl+D") self.createAction("actionCopy", "icons/iconCopy.png", u"Copy", self.doCopy, "Alt+Ctrl+X") self.createAction("actionMoveMultipleLayers", "icons/iconMoveMultipleLayers.png", u"Move from multiple layers", self.doMoveMultipleLayers, "Alt+Ctrl+Q") self.createAction("actionCopyMultipleLayers", "icons/iconCopyMultipleLayers.png", u"Copy from multiple layers", self.doCopyMultipleLayers, "Alt+Ctrl+R") self.createAction("actionParallel", "icons/iconParallel.png", u"Parallel", self.doParallel, "Alt+Ctrl+P") self.createAction("actionSplit", "icons/iconSplit.png", u"Split", self.doSplit, "Alt+Ctrl+H") self.createAction("actionCenterline", "icons/iconCenterline.png", u"Centerline", self.doCenterline, "Alt+Ctrl+J") self.createAction("actionCenterlineAdvanced", "icons/iconCenterlineAdvanced.png", u"Centerline Advanced", self.doCenterlineAdvanced, "Alt+Ctrl+K") self.createAction("actionPolygonize", "icons/iconPolygonize.png", u"Polygonize", self.doPolygonize, checkable=False) self.createAction("actionIntersect", "icons/iconIntersect.png", u"Create node at intersections", self.doIntersect, checkable=False) self.createAction("actionExplode", "icons/iconExplode.png", u"Explode multipart to single parts", self.doExplode, checkable=False) # Add toolbar button and menu item self.iface.addPluginToMenu(u"&GV Digitizing Tools", self.actionSettings) self.toolbar = self.iface.addToolBar("GV Digitizing Tools") self.toolbar.addAction(self.action) self.toolbar.addAction(self.actionBackgroundSnapping) self.toolbar.addSeparator() self.addActionGroup([ self.actionDrawArc, self.actionExtend, self.actionFillet, self.actionTrim, self.actionMirror, self.actionScale, self.actionParallel, self.actionSplit, self.actionCenterline, self.actionCenterlineAdvanced ]) self.toolbar.addSeparator() self.addActionGroup([ self.actionMove, self.actionCopy, self.actionMoveMultipleLayers, self.actionCopyMultipleLayers ]) self.toolbar.addSeparator() self.addActionGroup( [self.actionPolygonize, self.actionIntersect, self.actionExplode]) self.ignoreActions = set([ self.action, self.actionSettings, self.actionBackgroundSnapping, self.actionMoveMultipleLayers, self.actionCopyMultipleLayers, self.actionMove, self.actionCopy, self.actionParallel ]) self.action.setEnabled(True) self.actionMoveMultipleLayers.setEnabled(True) self.actionCopyMultipleLayers.setEnabled(True) self.actionParallel.setEnabled(False) self.actionBackgroundSnapping.setEnabled(True) self.extendMode = ExtendDigitizingMode(self.iface) self.extendMode.setAction(self.actionExtend) self.trimMode = TrimDigitizingMode(self.iface) self.trimMode.setAction(self.actionTrim) self.drawArcMode = DrawArcDigitizingMode(self.iface) self.drawArcMode.setAction(self.actionDrawArc) self.filletMode = FilletDigitizingMode(self.iface) self.filletMode.setAction(self.actionFillet) self.mirrorMode = MirrorDigitizingMode(self.iface, self) self.mirrorMode.setAction(self.actionMirror) self.scaleMode = ScaleDigitizingMode(self.iface, self) self.scaleMode.setAction(self.actionScale) self.moveMode = MoveDigitizingMode(self.iface, self) self.moveMode.setAction(self.actionMove) self.copyMode = CopyDigitizingMode(self.iface, self) self.copyMode.setAction(self.actionCopy) self.moveMultipleLayersMode = MoveMultipleLayersDigitizingMode( self.iface, self) self.moveMultipleLayersMode.setAction(self.actionMoveMultipleLayers) self.copyMultipleLayersMode = CopyMultipleLayersDigitizingMode( self.iface, self) self.copyMultipleLayersMode.setAction(self.actionCopyMultipleLayers) self.parallelConstraintMode = ParallelConstraintMode(self.iface) self.parallelConstraintMode.setAction(self.actionParallel) self.splitMode = SplitDigitizingMode(self.iface) self.splitMode.setAction(self.actionSplit) self.centerlineMode = CenterlineDigitizingMode(self.iface) self.centerlineMode.setAction(self.actionCenterline) self.centerlineAdvancedMode = CenterlineAdvancedDigitizingMode( self.iface) self.centerlineAdvancedMode.setAction(self.actionCenterlineAdvanced) self.explodeCommand = ExplodeCommand(self.iface) self.polygonizeCommand = PolygonizeCommand(self.iface) self.intersectCommand = IntersectCommand(self.iface) self.cadPointList = CadPointList(self.checkIsParallelEnabled) self.eventFilter = ConstraintEventFilter(self.iface, self, self.cadPointList) # to track the mouse for mouseMoveEvents to happen self.iface.mapCanvas().viewport().setMouseTracking(True) # to get the mouse events self.iface.mapCanvas().viewport().installEventFilter(self.eventFilter) self.iface.legendInterface().currentLayerChanged.connect( self.currentLayerChanged) self.currentLayer = self.iface.legendInterface().currentLayer() if self.currentLayer and self.currentLayer.type( ) == QgsMapLayer.VectorLayer: self.currentLayer.editingStopped.connect(self.editingStopped) self.currentLayer.editingStarted.connect(self.editingStarted) self.currentLayer.selectionChanged.connect(self.selectionChanged) self.iface.mapCanvas().mapToolSet.connect(self.maptoolChanged) self.maptoolChanged() self.checkCurrentLayerIsEditableLineLayer() self.checkIsMoveOrCopyEnabled() self.checkIsParallelEnabled() def unload(self): # Remove the plugin menu item and icon self.iface.removePluginMenu(u"&GV Digitizing Tools", self.actionSettings) self.iface.legendInterface().currentLayerChanged.disconnect( self.currentLayerChanged) self.currentLayer = self.iface.legendInterface().currentLayer() if self.currentLayer: try: self.currentLayer.editingStarted.disconnect( self.editingStarted) except Exception: pass try: self.currentLayer.editingStopped.disconnect( self.editingStopped) except Exception: pass try: self.currentLayer.selectionChanged.disconnect( self.selectionChanged) except: pass self.iface.mapCanvas().mapToolSet.disconnect(self.maptoolChanged) self.iface.mapCanvas().viewport().setMouseTracking(False) self.eventFilter.close() self.iface.mapCanvas().viewport().removeEventFilter(self.eventFilter) del self.toolbar def createAction(self, name, icon, tip, callback, shortcut=None, checkable=True): action = QAction(QIcon(":/plugins/gvdigitizingtools/" + icon), tip, self.iface.mainWindow()) # connect the action to the run method action.triggered.connect(callback) action.setCheckable(checkable) if shortcut: action.setShortcut(shortcut) self.__dict__[name] = action self.actions.append(action) def addActionGroup(self, actions): for action in actions: self.toolbar.addAction(action) def currentLayerChanged(self): # first cleanup events for previous layer if self.currentLayer: try: self.currentLayer.editingStarted.disconnect( self.editingStarted) except Exception: pass try: self.currentLayer.editingStopped.disconnect( self.editingStopped) except Exception: pass try: self.currentLayer.selectionChanged.disconnect( self.selectionChanged) except: pass self.currentLayer = self.iface.legendInterface().currentLayer() if self.currentLayer and self.currentLayer.type( ) == QgsMapLayer.VectorLayer: self.currentLayer.editingStopped.connect(self.editingStopped) self.currentLayer.editingStarted.connect(self.editingStarted) self.currentLayer.selectionChanged.connect(self.selectionChanged) self.checkCurrentLayerIsEditableLineLayer() self.checkIsParallelEnabled() # selectedLayers not yet updated and no event for this (have to use # currentLAyer change event) # get stuck when going from multiple to one selection QTimer.singleShot(1, self.checkIsMoveOrCopyEnabled) def editingStarted(self): self.checkCurrentLayerIsEditableLineLayer() self.checkIsParallelEnabled() self.checkIsMoveOrCopyEnabled() def editingStopped(self): self.checkCurrentLayerIsEditableLineLayer() self.checkIsParallelEnabled() self.checkIsMoveOrCopyEnabled() def selectionChanged(self): self.checkIsMoveOrCopyEnabled() def maptoolChanged(self): self.parallelConstraintMode.isRelevant = ( self.iface.mapCanvas().mapTool() is not None and self.iface.mapCanvas().mapTool().isEditTool()) def checkCurrentLayerIsEditableLineLayer(self): if self.currentLayer and self.currentLayer.type( ) == QgsMapLayer.VectorLayer and self.currentLayer.geometryType( ) == QGis.Line and self.currentLayer.isEditable(): for action in self.actions: # special processing for some actions (irrelevant or some custom processing) if action not in self.ignoreActions: action.setEnabled(True) if self.currentMode and self.currentMode != self.moveMultipleLayersMode: self.currentMode.reset() self.currentMode.setLayer(self.currentLayer) else: for action in self.actions: if action not in self.ignoreActions: action.setEnabled(False) if self.currentMode and self.currentMode != self.moveMultipleLayersMode: self.currentMode.reset() self.iface.mapCanvas().unsetMapTool(self.currentMode) self.currentMode = None def checkIsParallelEnabled(self): if (self.currentLayer and self.currentLayer.type() == QgsMapLayer.VectorLayer and self.currentLayer.geometryType() == QGis.Line and self.currentLayer.isEditable() and len(self.cadPointList) > 1 and self.digitizingSetup.enableEventFilter): self.actionParallel.setEnabled(True) else: self.actionParallel.setEnabled(False) def checkIsMoveOrCopyEnabled(self): """ Any type of geometry For Multiple... modes, no need to be editable but needs to have selection """ layers = self.iface.legendInterface().selectedLayers() isSingleEnabled = False isMultipleEnabled = False for layer in layers: if layer.type() == QgsMapLayer.VectorLayer: if layer.isEditable(): self.actionMove.setEnabled(True) self.actionCopy.setEnabled(True) isSingleEnabled = True if layer.selectedFeatureCount() > 0: self.actionMoveMultipleLayers.setEnabled(True) self.actionCopyMultipleLayers.setEnabled(True) isMultipleEnabled = True break if not isSingleEnabled: self.moveMode.reset() self.copyMode.reset() self.actionMove.setChecked(False) self.actionMove.setEnabled(False) self.actionCopy.setChecked(False) self.actionCopy.setEnabled(False) if not isMultipleEnabled: self.moveMultipleLayersMode.reset() self.copyMultipleLayersMode.reset() self.actionMoveMultipleLayers.setChecked(False) self.actionMoveMultipleLayers.setEnabled(False) self.actionCopyMultipleLayers.setChecked(False) self.actionCopyMultipleLayers.setEnabled(False) def setupMode(self): layer = self.iface.legendInterface().currentLayer() self.currentMode.setLayer(layer) self.iface.mapCanvas().setMapTool(self.currentMode) self.currentMode.reset() self.currentMode.next() def doSetupDigitizing(self): if self.action.isChecked(): self.digitizingSetup.activate() self.checkIsParallelEnabled() else: self.digitizingSetup.deactivate() self.checkIsParallelEnabled() def doSetupBackgroundSnapping(self): self.isBackgroundSnapping = self.actionBackgroundSnapping.isChecked() def doShowSettings(self): self.dlgSettings.clear() self.dlgSettings.show() result = self.dlgSettings.exec_() def doDrawArc(self): self.currentMode = self.drawArcMode self.setupMode() def doExtend(self): self.currentMode = self.extendMode self.setupMode() def doFillet(self): self.currentMode = self.filletMode self.setupMode() def doTrim(self): self.currentMode = self.trimMode self.setupMode() def doMirror(self): self.currentMode = self.mirrorMode self.setupMode() def doScale(self): self.currentMode = self.scaleMode self.setupMode() def doMove(self): self.currentMode = self.moveMode self.setupMode() def doCopy(self): self.currentMode = self.copyMode self.setupMode() def doMoveMultipleLayers(self): self.currentMode = self.moveMultipleLayersMode self.setupMode() def doCopyMultipleLayers(self): self.currentMode = self.copyMultipleLayersMode self.setupMode() def doParallel(self): if self.actionParallel.isChecked(): self.parallelConstraintMode.activate() else: self.parallelConstraintMode.deactivate() def doSplit(self): self.currentMode = self.splitMode self.setupMode() def doCenterline(self): self.currentMode = self.centerlineMode self.setupMode() def doCenterlineAdvanced(self): self.currentMode = self.centerlineAdvancedMode self.setupMode() def doPolygonize(self): self.polygonizeCommand.run() def doIntersect(self): self.intersectCommand.run() def doExplode(self): self.explodeCommand.run()
parser = argparse.ArgumentParser(description="SimpleShortcuts") parser.add_argument("-s", "--settings", help="Show the settings dialog", action="store_true") parser.add_argument("-i", "--imitate", help="Show and immediately close the main window.", action="store_true") args = parser.parse_args() app = QApplication(sys.argv) if args.settings: from settingsdialog import SettingsDialog g = SettingsDialog() else: try: g = MainUi() except Exception as err: print("An exception has occured!") print("Try opening the settings dialog with -s parameter and resaving the settings.", "You may have to delete your settings file as last resort." ) raise err g.show() if args.imitate: sys.exit() rect = app.desktop().screenGeometry()
def on_actionConfigure_triggered(self): dialog = SettingsDialog(self.programSettings, self) dialog.exec_()
class EarthMineQGIS(QObject): """QGIS Plugin Implementation.""" def __init__(self, iface): """Constructor. :param iface: An interface instance that will be passed to this class which provides the hook by which you can manipulate the QGIS application at run time. :type iface: QgsInterface """ # Save reference to the QGIS interface super(EarthMineQGIS, self).__init__() self.movingfeature = None self.iface = iface self.viewer = None self.canvas = self.iface.mapCanvas() self.settings = QSettings() # initialize plugin directory self.plugin_dir = os.path.dirname(__file__) # initialize locale locale = QSettings().value("locale/userLocale")[0:2] locale_path = os.path.join(self.plugin_dir, "i18n", "EarthMineQGIS_{}.qm".format(locale)) if os.path.exists(locale_path): self.translator = QTranslator() self.translator.load(locale_path) if qVersion() > "4.3.3": QCoreApplication.installTranslator(self.translator) self.pointtool = QgsMapToolEmitPoint(self.canvas) self.pointtool.canvasClicked.connect(self.set_viewer_location) self.settingsdialog = SettingsDialog(self.iface.mainWindow()) self.actions = [] self.menu = self.tr(u"&Earthmine") self.toolbar = self.iface.addToolBar(u"EarthMineQGIS") self.toolbar.setObjectName(u"EarthMineQGIS") self.legend = self.iface.legendInterface() emcolor = QColor(1, 150, 51) self.tempband = QgsRubberBand(self.canvas, QGis.Line) self.tempband.setWidth(5) self.tempband.setColor(emcolor) self.tempbandpoints = QgsRubberBand(self.canvas, QGis.Point) self.tempbandpoints.setWidth(7) self.tempbandpoints.setColor(emcolor) self.movingband = QgsRubberBand(self.canvas, QGis.Point) self.movingband.setWidth(5) self.movingband.setColor(emcolor) self.layersignals = [] self.marker = None def initGui(self): """Create the menu entries and toolbar icons inside the QGIS GUI.""" icon_path = ":/icons/settings" self.add_action( icon_path, text=self.tr(u"Show Settings"), callback=self.show_settings, parent=self.iface.mainWindow() ) icon_path = ":/icons/viewer" self.add_action( icon_path, text=self.tr(u"Earthmine Viewer"), callback=self.open_viewer, parent=self.iface.mainWindow() ) self.marker = PostionMarker(self.canvas) self.marker.hide() self.viewer = Viewer(callbackobject=self) self.viewer.trackingChanged.connect(self.marker.setTracking) self.viewer.setLocationTriggered.connect(partial(self.canvas.setMapTool, self.pointtool)) self.viewer.updateFeatures.connect(self.update_earthmine_features) self.viewer.layerChanged.connect(self.iface.setActiveLayer) self.viewer.clearLine.connect(self.clear_bands) self.viewer.closed.connect(self.remove_items) self.iface.currentLayerChanged.connect(self.viewer.update_current_layer) cursor = QCursor(QPixmap(":/icons/location")) self.pointtool.setCursor(cursor) self.pointtool.setAction(self.viewer.setlocationaction) def remove_items(self): self.marker.setTracking(False) self.disconnect_projectsignals() self.iface.actionPan().trigger() def unload(self): """Removes the plugin menu item and icon from QGIS GUI.""" self.canvas.scene().removeItem(self.marker) del self.marker self.disconnect_projectsignals() for action in self.actions: self.iface.removePluginMenu(self.tr(u"&Earthmine"), action) self.iface.removeToolBarIcon(action) del self.toolbar self.iface.removeDockWidget(self.viewer) self.viewer.deleteLater() def disconnect_projectsignals(self): safe_disconnect(QgsMapLayerRegistry.instance().layerWasAdded, self.connect_layer_signals) safe_disconnect(QgsMapLayerRegistry.instance().layersRemoved, self.layers_removed) safe_disconnect(self.canvas.layersChanged, self.layers_changed) safe_disconnect(self.iface.projectRead, self.connect_signals) safe_disconnect(self.canvas.selectionChanged, self.selection_changed) safe_disconnect(self.canvas.selectionChanged, self.viewer.selection_changed) def clear_bands(self): self.tempband.reset(QGis.Line) self.tempbandpoints.reset(QGis.Point) def visible_layers(self): """ Return the visible layers shown in the map canvas :return: """ return (layer for layer, visible in self.layers_with_states() if visible) def layers_with_states(self): for layer in maplayers(): if not layer.type() == QgsMapLayer.VectorLayer: continue if not layer.geometryType() in [QGis.Point, QGis.Line]: continue yield layer, self.legend.isLayerVisible(layer) def _layer_feature_added(self, featureid): layer = self.sender() if not layer: return self.layer_feature_added(layer, featureid) def layer_feature_added(self, layer, featureid): if not self.viewer: return feature = layer.getFeatures(QgsFeatureRequest(featureid)).next() renderer = layer.rendererV2() transform = self.coordinatetransform(layer) featuredata = to_feature_data(layer.id(), feature, renderer, transform) geomtype = layer.geometryType() layerdata = dict(id=layer.id(), geomtype=QGis.vectorGeometryType(geomtype)) self.viewer.load_features(layerdata, featuredata) def _layer_feature_delete(self, featureid): layer = self.sender() if not layer: return self.layer_feature_delete(layer, featureid) def layer_feature_delete(self, layer, featureid): if not self.viewer: return self.viewer.remove_feature(layer.id(), featureid) def _layer_geometry_changed(self, featureid, geometry): layer = self.sender() if not layer: return self.layer_geometry_changed(layer, featureid, geometry) def layer_geometry_changed(self, layer, featureid, geometry): if not self.viewer: return geomtype = layer.geometryType() if geomtype == QGis.Point: geom = geometry.asPoint() transform = self.coordinatetransform(layer) point = transform.transform(geom, QgsCoordinateTransform.ReverseTransform) location = dict(lat=point.y(), lng=point.x()) self.viewer.edit_feature(layer.id(), featureid, [location]) elif geomtype == QGis.Line: self.layer_feature_delete(layer, featureid) self.layer_feature_added(layer, featureid) def connect_layer_signals(self, layer): if not layer.type() == QgsMapLayer.VectorLayer: return layer.featureAdded.connect(self._layer_feature_added) layer.featureDeleted.connect(self._layer_feature_delete) layer.editingStarted.connect(self.layer_editstate_changed) layer.editingStopped.connect(self.layer_editstate_changed) # HACK The new style doesn't work here # http://hub.qgis.org/issues/6573 signal = SIGNAL("geometryChanged(QgsFeatureId, QgsGeometry&)") self.connect(layer, signal, self._layer_geometry_changed) self.load_layer_features(layers=[layer]) def layer_editstate_changed(self): layer = self.sender() if layer == self.iface.activeLayer(): self.viewer.layer_changed(layer) def disconnect_signals(self): self.disconnect_projectsignals() for layer in maplayers(): if not layer.type() == QgsMapLayer.VectorLayer: return safe_disconnect(layer.featureAdded, self._layer_feature_added) safe_disconnect(layer.featureDeleted, self._layer_feature_delete) safe_disconnect(layer.editingStarted, self.layer_editstate_changed) safe_disconnect(layer.editingStopped, self.layer_editstate_changed) # HACK The new style doesn't work here # http://hub.qgis.org/issues/6573 signal = SIGNAL("geometryChanged(QgsFeatureId, QgsGeometry&)") self.disconnect(layer, signal, self._layer_geometry_changed) def connect_signals(self): for layer in maplayers(): self.connect_layer_signals(layer) self.center_on_canvas() def set_viewer_location(self, point, mousebutton): transform = self.coordinatetransform() point = transform.transform(point, QgsCoordinateTransform.ReverseTransform) self.viewer.set_location(point) def distancearea(self): area = QgsDistanceArea() dest = self.canvas.mapRenderer().destinationCrs() area.setSourceCrs(dest) return area, dest.mapUnits() def coordinatetransform(self, layer=None): """ Return the transform for WGS84 -> QGIS projection. """ source = QgsCoordinateReferenceSystem() source.createFromWkt( 'GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",SPHEROID["WGS_1984",6378137.0,298.257223563]],PRIMEM["Greenwich",0.0],UNIT["Degree",0.0174532925199433]]' ) if not layer: dest = self.canvas.mapRenderer().destinationCrs() else: dest = layer.crs() transform = QgsCoordinateTransform(source, dest) return transform def earthmine_settings(self): settings = {} with settinggroup(self.settings, "plugins/Earthmine"): for key in ["serviceUrl", "baseDataUrl", "apiKey", "secretKey", "viewerUrl"]: if not self.settings.contains(key): raise EarthmineSettingsError("{} not set".format(key)) value = self.settings.value(key, type=str) if value is None: raise EarthmineSettingsError("{} not set".format(key)) settings[key] = value return settings @pyqtSlot() def ready(self): """ Called when the viewer is ready to be started. At this point the viewer hasn't been loaded so no other methods apart from startViewer will be handled. """ settings = self.earthmine_settings() self.viewer.startViewer(settings) @pyqtSlot() def viewerReady(self): """ Called once the viewer is loaded and ready to get location events. """ self.disconnect_signals() self.connect_signals() self.iface.projectRead.connect(self.connect_signals) self.canvas.layersChanged.connect(self.layers_changed) self.canvas.selectionChanged.connect(self.selection_changed) self.canvas.selectionChanged.connect(self.viewer.selection_changed) QgsMapLayerRegistry.instance().layersRemoved.connect(self.layers_removed) QgsMapLayerRegistry.instance().layerWasAdded.connect(self.connect_layer_signals) self.center_on_canvas() self.viewer.activelayercombo.setLayer(self.iface.activeLayer()) def center_on_canvas(self): point = self.canvas.extent().center() transform = self.coordinatetransform() point = transform.transform(point, QgsCoordinateTransform.ReverseTransform) self.viewer.set_location(point) self.viewer.infoaction.toggle() def selection_changed(self, layer): ids = [feature.id() for feature in layer.selectedFeatures()] if not ids: self.viewer.clear_selection(layer.id()) else: self.viewer.set_selection(layer.id(), ids) def layers_changed(self): layerstates = self.layers_with_states() for layer, visible in layerstates: layerid = layer.id() viewerloaded = self.viewer.layer_loaded(layerid) QgsMessageLog.instance().logMessage(layerid, "Earthmine") QgsMessageLog.instance().logMessage("Viewer State:" + str(viewerloaded), "Earthmine") QgsMessageLog.instance().logMessage("QGIS State:" + str(visible), "Earthmine") if (viewerloaded and visible) or (not viewerloaded and not visible): QgsMessageLog.instance().logMessage("Ignoring as states match", "Earthmine") continue if viewerloaded and not visible: QgsMessageLog.instance().logMessage( "Clearing layer because viewer loaded and disabled in QGIS", "Earthmine" ) self.viewer.clear_layer_features(layerid) continue if not viewerloaded and visible: QgsMessageLog.instance().logMessage("Loading layer", "Earthmine") self.load_layer_features(layers=[layer]) continue def layers_removed(self, layers): for layerid in layers: self.viewer.clear_layer_features(layerid) @pyqtSlot(str, float, float) def viewChanged(self, event, yaw, angle): self.marker.setAngle(angle) self.marker.setYaw(yaw) @pyqtSlot(str, str) def getInfo(self, layerid, featureid): featureid = int(featureid) activelayer = self.iface.activeLayer() if not activelayer: return activetool = self.viewer.active_tool() if not activetool in ["Info", "Select"]: return # Only show information for the active layer if not layerid == activelayer.id(): return layer = layer_by_id(layerid) if activetool == "Select": layer.setSelectedFeatures([featureid]) elif activetool == "Info": rq = QgsFeatureRequest(featureid) feature = layer.getFeatures(rq).next() dlg = get_feature_form(layer, feature) if dlg.dialog().exec_(): self.canvas.refresh() @pyqtSlot(str, str, float, float, bool) def featureMoved(self, layerid, featureid, lat, lng, end): layer = layer_by_id(layerid) transform = self.coordinatetransform(layer) point = transform.transform(lng, lat) if not end: self.movingband.show() self.movingband.setToGeometry(QgsGeometry.fromPoint(point), layer) self.movingband.updatePosition() self.movingband.update() else: self.movingband.hide() feature = feature_by_id(layer, featureid) startpoint = feature.geometry().asPoint() dx = point.x() - startpoint.x() dy = point.y() - startpoint.y() layer.beginEditCommand("Feature Moved") # Block signals for this move as the geometry changed signal will re add the geometry on use. layer.blockSignals(True) layer.translateFeature(feature.id(), dx, dy) layer.blockSignals(False) self.canvas.refresh() layer.endEditCommand() @pyqtSlot(str, str) def onError(self, message, stacktrace=None): self.iface.messageBar().pushMessage("Earthmine", message, QgsMessageBar.WARNING) QgsMessageLog.logMessage(stacktrace, "Earthmine") @pyqtSlot(float, float, float) def addPoint(self, lat, lng, z): layer = self.viewer.active_layer if not layer.isEditable(): self.iface.messageBar().pushMessage( "Earthmine", "Selected layer isn't editable. Please enable edit mode to add features", duration=3, level=QgsMessageBar.WARNING, ) return transform = self.coordinatetransform(layer) point = transform.transform(lng, lat) geom = QgsGeometry.fromPoint(point) self.add_feature(layer, geom, z) def add_feature(self, layer, geom, z=None): feature = QgsFeature(layer.pendingFields()) if z and self.viewer.copyZvalue: try: feature["Z"] = z except KeyError: QgsMessageLog.log("No Z found on layer {}".format(layer.name())) pass feature.setGeometry(geom) dlg = get_feature_form(layer, feature, isadd=True) if dlg.dialog().exec_(): self.canvas.refresh() @pyqtSlot(str, bool, str) def drawLine(self, points, end, stats): points = json.loads(points) stats = json.loads(stats) QgsMessageLog.logMessage(str(stats), "Earthmine") self.tempband.reset(QGis.Line) self.tempbandpoints.reset(QGis.Point) color = QColor(self.viewer.current_action_color) self.tempband.setColor(color) self.tempbandpoints.setColor(color) layer = self.viewer.active_layer transform = self.coordinatetransform(layer) earthminepoints = [] for point in points: newpoint = transform.transform(point["lng"], point["lat"]) self.tempband.addPoint(newpoint) self.tempbandpoints.addPoint(newpoint) empoint = EarthminePoint(newpoint, point) earthminepoints.append(empoint) if end and not self.viewer.mode == "Vertical": geom = self.tempband.asGeometry() self.add_feature(layer, geom) self.clear_bands() self.viewer.geom = EarthmineLine(earthminepoints, stats) self.tempband.show() self.tempbandpoints.show() @pyqtSlot(str, str, str, float) def locationChanged(self, lat, lng, yaw, angle): transform = self.coordinatetransform() point = transform.transform(float(lng), float(lat)) self.marker.setCenter(point) yaw = float(yaw) self.marker.setAngle(angle) self.marker.setYaw(yaw) self.marker.setTracking(self.viewer.tracking) if self.marker.tracking: rect = QgsRectangle(point, point) extentlimt = QgsRectangle(self.canvas.extent()) extentlimt.scale(0.95) if not extentlimt.contains(point): self.canvas.setExtent(rect) self.canvas.refresh() # Clear old features self.viewer.clear_features() self.load_layer_features(point) def update_earthmine_features(self, viewfeatures): self.viewer.clear_features() if viewfeatures: self.load_layer_features() def load_layer_features(self, point=None, layers=None): # TODO Move this logic into the viewer and let it track it's position if point is None and self.marker.map_pos is None: return if point is None: point = self.marker.map_pos area, units = self.distancearea() rect = search_area(units, area, point) if layers is None: layers = self.visible_layers() for layer in layers: transform = self.coordinatetransform(layer) # Transform the rect source = self.canvas.mapRenderer().destinationCrs() dest = layer.crs() recttransform = QgsCoordinateTransform(source, dest) rect = recttransform.transformBoundingBox(rect) features = list(get_features_in_area(layer, rect, transform, self.canvas.mapSettings())) geomtype = layer.geometryType() layerdata = dict(id=layer.id(), geomtype=QGis.vectorGeometryType(geomtype)) self.viewer.load_features(layerdata, features) # noinspection PyMethodMayBeStatic def tr(self, message): """Get the translation for a string using Qt translation API. We implement this ourselves since we do not inherit QObject. :param message: String for translation. :type message: str, QString :returns: Translated version of message. :rtype: QString """ # noinspection PyTypeChecker,PyArgumentList,PyCallByClass return QCoreApplication.translate("EarthMineQGIS", message) def add_action( self, icon_path, text, callback, enabled_flag=True, add_to_menu=True, add_to_toolbar=True, status_tip=None, whats_this=None, parent=None, ): """Add a toolbar icon to the InaSAFE toolbar. :param icon_path: Path to the icon for this action. Can be a resource path (e.g. ':/plugins/foo/bar.png') or a normal file system path. :type icon_path: str :param text: Text that should be shown in menu items for this action. :type text: str :param callback: Function to be called when the action is triggered. :type callback: function :param enabled_flag: A flag indicating if the action should be enabled by default. Defaults to True. :type enabled_flag: bool :param add_to_menu: Flag indicating whether the action should also be added to the menu. Defaults to True. :type add_to_menu: bool :param add_to_toolbar: Flag indicating whether the action should also be added to the toolbar. Defaults to True. :type add_to_toolbar: bool :param status_tip: Optional text to s, "Earhtmine"how in a popup when mouse pointer hovers over the action. :type status_tip: str :param parent: Parent widget for the new action. Defaults None. :type parent: QWidget :param whats_this: Optional text to show in the status bar when the mouse pointer hovers over the action. :returns: The action that was created. Note that the action is also added to self.actions list. :rtype: QAction """ icon = QIcon(icon_path) action = QAction(icon, text, parent) action.triggered.connect(callback) action.setEnabled(enabled_flag) if status_tip is not None: action.setStatusTip(status_tip) if whats_this is not None: action.setWhatsThis(whats_this) if add_to_toolbar: self.toolbar.addAction(action) if add_to_menu: self.iface.addPluginToMenu(self.menu, action) self.actions.append(action) return action def open_viewer(self): """Run method that performs all the real work""" try: settings = self.earthmine_settings() except EarthmineSettingsError as ex: self.onError(ex.message) self.show_settings() return url = settings["viewerUrl"] if not url.startswith("http"): url = url.replace("\\\\", "\\") url = QUrl.fromLocalFile(url) else: url = QUrl(url) if not self.viewer.isVisible(): self.iface.addDockWidget(Qt.RightDockWidgetArea, self.viewer) self.viewer.loadviewer(url) def show_settings(self): self.settingsdialog.show()
class PreencheSelecionada: """QGIS Plugin Implementation.""" def __init__(self, iface): """Constructor. :param iface: An interface instance that will be passed to this class which provides the hook by which you can manipulate the QGIS application at run time. :type iface: QgsInterface """ # Save reference to the QGIS interface self.iface = iface # initialize plugin directory self.plugin_dir = os.path.dirname(__file__) # initialize locale locale = QSettings().value('locale/userLocale')[0:2] locale_path = os.path.join(self.plugin_dir, 'i18n', 'PreencheSelecionada_{}.qm'.format(locale)) if os.path.exists(locale_path): self.translator = QTranslator() self.translator.load(locale_path) if qVersion() > '4.3.3': QCoreApplication.installTranslator(self.translator) # Declare instance attributes self.actions = [] self.menu = self.tr(u'&Preenche feicoes selecionadas') # TODO: We are going to let the user set this up in a future iteration self.toolbar = self.iface.addToolBar(u'PreencheSelecionada') self.toolbar.setObjectName(u'PreencheSelecionada') # noinspection PyMethodMayBeStatic def tr(self, message): """Get the translation for a string using Qt translation API. We implement this ourselves since we do not inherit QObject. :param message: String for translation. :type message: str, QString :returns: Translated version of message. :rtype: QString """ # noinspection PyTypeChecker,PyArgumentList,PyCallByClass return QCoreApplication.translate('PreencheSelecionada', message) def add_action(self, icon_path, text, callback, enabled_flag=True, add_to_menu=True, add_to_toolbar=True, status_tip=None, whats_this=None, parent=None): """Add a toolbar icon to the toolbar. :param icon_path: Path to the icon for this action. Can be a resource path (e.g. ':/plugins/foo/bar.png') or a normal file system path. :type icon_path: str :param text: Text that should be shown in menu items for this action. :type text: str :param callback: Function to be called when the action is triggered. :type callback: function :param enabled_flag: A flag indicating if the action should be enabled by default. Defaults to True. :type enabled_flag: bool :param add_to_menu: Flag indicating whether the action should also be added to the menu. Defaults to True. :type add_to_menu: bool :param add_to_toolbar: Flag indicating whether the action should also be added to the toolbar. Defaults to True. :type add_to_toolbar: bool :param status_tip: Optional text to show in a popup when mouse pointer hovers over the action. :type status_tip: str :param parent: Parent widget for the new action. Defaults None. :type parent: QWidget :param whats_this: Optional text to show in the status bar when the mouse pointer hovers over the action. :returns: The action that was created. Note that the action is also added to self.actions list. :rtype: QAction """ # Create the dialog (after translation) and keep reference self.dlg = PreencheSelecionadaDialog() icon = QIcon(icon_path) action = QAction(icon, text, parent) action.triggered.connect(callback) action.setEnabled(enabled_flag) if status_tip is not None: action.setStatusTip(status_tip) if whats_this is not None: action.setWhatsThis(whats_this) if add_to_toolbar: self.toolbar.addAction(action) if add_to_menu: self.iface.addPluginToMenu(self.menu, action) self.actions.append(action) return action def initGui(self): """Create the menu entries and toolbar icons inside the QGIS GUI.""" icon_path = ':/plugins/PreencheSelecionada/icon.png' self.add_action( icon_path, text=self.tr(u'Preenche feicoes selecionadas na t_interface'), callback=self.run, parent=self.iface.mainWindow()) # Cria ação para menu de ajustes self.settingsAction = QAction("Configura", self.iface.mainWindow()) self.settingsAction.setObjectName("preencheSelecionadaAction") self.settingsAction.triggered.connect(self.openSettings) # Adiciona menu de ajustes na barra Vetor self.iface.addPluginToMenu("&PreencheSelecionada: Usuario e Senha", self.settingsAction) def openSettings(self): # button signals in SettingsDialog were not working on Win7/64 # if SettingsDialog was created with iface.mainWindow() as parent #self.settingsDialog = SettingsDialog(self.iface.mainWindow()) self.settingsDialog = SettingsDialog() self.settingsDialog.show() def unload(self): """Removes the plugin menu item and icon from QGIS GUI.""" for action in self.actions: self.iface.removePluginMenu( self.tr(u'&Preenche feicoes selecionadas'), action) self.iface.removeToolBarIcon(action) # remove the toolbar del self.toolbar def run(self): """Roda método que faz todo o trabalho real""" """Executa tarefas antes de apertar o OK da janela do Complemento""" # Pega camada ativa na legenda camadaAtiva = self.iface.activeLayer() # Se não tiver nenhuma camada ativa selecionada (se não tiver nenhum dataProvider) acusa erro try: provedor = camadaAtiva.dataProvider() except: QMessageBox.information(self.iface.mainWindow(), 'Aviso', 'Selecione alguma camada') return # Se o dataProvider da camada não for Postgres também acusa erro if provedor.name() != 'postgres': QMessageBox.information( self.iface.mainWindow(), 'Aviso', 'Selecione uma camada com conexao PostGIS') return # Cria mesma URI da camada ativa uri_camadaAtiva = QgsDataSourceURI( camadaAtiva.dataProvider().dataSourceUri()) # print uri_camadaAtiva # Pega tabela selecionada para ser usada como dado da consulta tabela = uri_camadaAtiva.table() esquema = uri_camadaAtiva.schema() #print 'Tabela = ', uri.table() #print 'Esquema = ', uri.schema() # Estabelece nomes a serem usados na cláusula WHERE da consulta ultima_letra_geom = tabela[-1] dic_geom = {'a': 'poligono', 'p': 'ponto', 'l': 'linha'} sigla_classe = tabela[0:-2] #print 'sigla_classe = ', sigla_classe #print ultima_letra_geom, 'vamos ver: ', dic_geom[ultima_letra_geom] # Lista de camadas presente na legenda camadasAbertas = self.iface.legendInterface().layers() #for camada in camadasAbertas: # print camada.name() # Percorre camadas na legenda para determinar se existe a mesma classe da camada selecionada em outra escala. Caso ela exista a URI dela será adicionada # para InfoUriCamadasOutraEscala e o objeto da camada será adicionado para CamadasOutraEscala InfoUriCamadasOutraEscala = [] CamadasOutraEscala = [] for camadaLegenda in camadasAbertas: try: uri_camadaLegenda = QgsDataSourceURI( camadaLegenda.dataProvider().dataSourceUri()) # Testa para ver se é mesma camada só que em outra escala - Não está funcionando ainda if uri_camadaAtiva.table() == uri_camadaLegenda.table( ) and uri_camadaAtiva.schema() != uri_camadaLegenda.schema(): # print 'Tabela_selecao: ', uri.table(), ' Esquema_selecao: ', uri.schema(), ' diferente de Tabela_legenda: ', uri_camadaLegenda.table(), ' Esquema_legenda: ', uri_camadaLegenda.schema() #QMessageBox.information(self.iface.mainWindow(), 'Aviso', 'Tem mesma(s) camada(s) em escala diferente') if uri_camadaLegenda.uri( ) not in InfoUriCamadasOutraEscala: # print 'Vou adicionar camada' InfoUriCamadasOutraEscala.append(uri_camadaLegenda) CamadasOutraEscala.append(camadaLegenda) else: # print 'Não vou adicionar camada' pass except: pass #print InfoUriCamadasOutraEscala #print CamadasOutraEscala mensagem_uri = '' for uri in InfoUriCamadasOutraEscala: #print uri mensagem_uri = mensagem_uri + 'tabela: ' + uri.table( ) + '; esquema: ' + uri.schema() + '\n' #print 'Camadas iguais em escalas diferentes: ' + mensagem_uri QMessageBox.information( self.iface.mainWindow(), 'Aviso', 'Tem mesma(s) camada(s) em escala diferente: \n' + mensagem_uri) # Cria uma conexão ao Postgres através de QSqlDatabase - QPSQL se refere ao Postgres db = QSqlDatabase.addDatabase("QPSQL") # Dados da conexão são os mesmos da camada ativa (mesmo servidor, mesmo banco e mesma porta) db.setHostName(uri_camadaAtiva.host()) db.setDatabaseName(uri_camadaAtiva.database()) db.setPort(int(uri_camadaAtiva.port())) # Pega nome e senha de usuários nas configurações do plugin usuario = QSettings().value(SETTINGS_NAME + "/usuario", DEFAULT_USUARIO) senha = QSettings().value(SETTINGS_NAME + "/senha", DEFAULT_SENHA) #print usuario, senha # Estabelece usuário e senha para conexão com o banco db.setUserName(usuario) db.setPassword(senha) # Feições selecionadas selecao = camadaAtiva.selectedFeatures() #print selecao selecao_outras_camadas = [ camada.selectedFeatures() for camada in CamadasOutraEscala ] #print "Selecao outras camadas = ", selecao_outras_camadas # cria lista do id_objeto das feições selecionadas de todas as classes iguais de escalas diferentes presentes na legenda lista_id_objeto = [feicao['id_objeto'] for feicao in selecao] lista_id_objeto_outras_camadas = [[ feicao['id_objeto'] for feicao in camada ] for camada in selecao_outras_camadas] #print 'lista_id_objeto_outras_camadas = ', lista_id_objeto_outras_camadas #lista_unica_id_objeto_outras_camadas = [id_objeto for elemento in lista_id_objeto_outras_camadas for id_objeto in elemento] #lista_unica_id_objeto = lista_id_objeto + lista_unica_id_objeto_outras_camadas #print lista_id_objeto, type(lista_id_objeto[0]) # converte elementos da lista de id_objeto em string para usá-los na consulta lista_id_objeto = [str(el) for el in lista_id_objeto] lista_id_objeto_string = ','.join(lista_id_objeto) lista_id_objeto_outras_camadas = [[ str(subel) for subel in el ] for el in lista_id_objeto_outras_camadas] #print 'Lista de objetos de outras camadas =', lista_id_objeto_outras_camadas #lista_unica_id_objeto = [str(el) for el in lista_unica_id_objeto] #lista_unica_id_objeto_string = ','.join(lista_unica_id_objeto) #print 'vou conectar no banco' # Abre conexão ao banco de dados para adicionar os esquemas que têm tabelas espaciais contidos lá if db.open(): # Tenho que rever essa consulta string_consulta = "SELECT id_objeto_producao, id_nomebngb, nm_geografico_producao, cd_validacao_operador, tx_apontamento_crng FROM bngb_interface.t_interface WHERE id_objeto_producao IN (" + lista_id_objeto_string + ") " + \ "AND nm_esquema_base = '" + esquema + "' AND concat_ws('_', nm_sigla_categoria, nm_classe) ILIKE '" + sigla_classe + "' AND tp_geom ILIKE '" + dic_geom[ultima_letra_geom] +"' " #print "string consulta exibir comboBox = ", string_consulta msg_add = "" for indice, uri in enumerate(InfoUriCamadasOutraEscala): # Verifica se a lista de id_objeto contém algum valor (alguma seleção) if lista_id_objeto_outras_camadas[indice]: msg_add = msg_add + "UNION SELECT id_objeto_producao, id_nomebngb, nm_geografico_producao, cd_validacao_operador, tx_apontamento_crng FROM bngb_interface.t_interface WHERE id_objeto_producao IN (" + ','.join(lista_id_objeto_outras_camadas[indice]) + ") " + \ "AND nm_esquema_base = '" + uri.schema() + "' AND concat_ws('_', nm_sigla_categoria, nm_classe) ILIKE '" + sigla_classe + "' AND tp_geom ILIKE '" + dic_geom[ultima_letra_geom] +"' " string_consulta = string_consulta + msg_add #print string_consulta #print string_consulta consulta = db.exec_( string_consulta) #IN (" + lista_id_objeto_string + ")") resultado_consulta = [] # Adiciona resultados da consulta (id_objeto_producao, id_nomebngb, nm_geografico_producao) # na lista Python para posterior adição à comboBox while consulta.next(): record = consulta.record() #print 'Comecando' # Pega o id_objeto_producao (na tabela t_interface) correspondente ao id_objeto das feições selecionadas id_objeto_producao = str( record.field('id_objeto_producao').value()).decode("utf-8") #print id_objeto_producao, ' - tipo ', type(id_objeto_producao) # Pega id_nomebngb id_nomebngb = str( record.field('id_nomebngb').value()).decode("utf-8") #print id_nomebngb, ' - tipo ', type(id_nomebngb) # Pega nm_geografico_producao if isinstance( record.field('nm_geografico_producao').value(), QPyNullVariant): nome_bngb = str( record.field('nm_geografico_producao').value()).decode( "utf-8") #print nome_bngb, ' - tipo1 ', type(nome_bngb) else: nome_bngb = record.field('nm_geografico_producao').value() #print nome_bngb, ' - tipo1 ', type(nome_bngb) cd_validacao_operador = str( record.field('cd_validacao_operador').value()).decode( "utf-8") if isinstance( record.field('tx_apontamento_crng').value(), QPyNullVariant): tx_apontamento_crng = str( record.field('tx_apontamento_crng').value()).decode( "utf-8") #print nome_bngb, ' - tipo1 ', type(nome_bngb) else: tx_apontamento_crng = record.field( 'tx_apontamento_crng').value() #print nome_bngb, ' - tipo1 ', type(nome_bngb) # Tupla a ser adicionada para a lista que será posteriormente adicionada à ComboBox tupla_add = (id_objeto_producao, id_nomebngb, nome_bngb, cd_validacao_operador, tx_apontamento_crng) resultado_consulta.append(tupla_add) #print 'Resultado da consulta = ', resultado_consulta # Parei aqui. Até aqui tudo bem, resultado_consulta guarda a tupla (id_objeto_producao, id_nomebngb, nome_bngb) da t_interface referente a todos os registros selecionados nas diversas camadas da legenda que se referem a uma classe em escalas distintas # Cria lista de strings a partir de resultado_consulta para adição à ComboBox resultado_consulta_string = [] for el in resultado_consulta: item_comboBox = el[0] + '\ ' + el[1] + '\ ' + el[ 2] + '\ ' + el[3] + '\ ' + el[4] resultado_consulta_string.append(item_comboBox) #print resultado_consulta_string # Limpa e adiciona elementos na Combo Box (caixa de opção) self.dlg.comboBox.clear() self.dlg.comboBox.addItems(resultado_consulta_string) # Indica na caixa de diálogo uma linha para mostrar a camada que está sendo editada na t_interface self.dlg.lineEdit.clear() self.dlg.lineEdit.setText(uri_camadaAtiva.schema() + '.' + uri_camadaAtiva.table()) else: QMessageBox.information(self.iface.mainWindow(), 'Aviso', 'Conexao rejeitada') return # show the dialog self.dlg.show() # Run the dialog event loop result = self.dlg.exec_() """ Executa tarefas caso o OK seja pressionado """ if result: # Pega índice e tupla (id_objeto_producao, id_nomebngb, nm_geografico_producao) escolhidos no ComboBox indice = self.dlg.comboBox.currentIndex() stringSelecionada = resultado_consulta_string[indice] #print 'String Selecionada = ', stringSelecionada # Transforma opção selecionada na ComboBox em lista listastringSelecionada = stringSelecionada.split("\ ") #print 'Lista selecionada =', listastringSelecionada #print 'Lista selecionada[2] =', listastringSelecionada[2], 'tipo = ', type(listastringSelecionada[2]) listastringSelecionada[2] = listastringSelecionada[2].replace( "'", "''") listastringSelecionada[4] = listastringSelecionada[4].replace( "'", "''") print listastringSelecionada[4] #print 'Lista selecionada[2] depois =', listastringSelecionada[2], 'tipo = ', type(listastringSelecionada[2]) print print print # Estabelece string para consulta na Camada Ativa (nm_geografico_producao e tx_apontamento_crng podem ser nulos) if listastringSelecionada[2] == 'NULL': string_consulta = "UPDATE bngb_interface.t_interface SET cd_validacao_operador = '" + listastringSelecionada[ 3] + "', id_nomebngb = " + listastringSelecionada[ 1] + ", nm_geografico_producao = " + listastringSelecionada[ 2] #print "UPDATE referente à camada ativa =", string_consulta else: string_consulta = "UPDATE bngb_interface.t_interface SET cd_validacao_operador = '" + listastringSelecionada[ 3] + "', id_nomebngb = " + listastringSelecionada[ 1] + ", nm_geografico_producao = '" + listastringSelecionada[ 2] + "'" #print "UPDATE referente à camada ativa =", string_consulta if listastringSelecionada[4] == 'NULL': string_consulta = string_consulta + ", tx_apontamento_crng = " + listastringSelecionada[4] + \ " WHERE id_objeto_producao IN (" + lista_id_objeto_string + ") " + \ "AND nm_esquema_base = '" + esquema + "' AND concat_ws('_', nm_sigla_categoria, nm_classe) ILIKE '" + sigla_classe + "' AND tp_geom ILIKE '" + dic_geom[ultima_letra_geom] +"'" print u"UPDATE referente à camada ativa =", string_consulta else: string_consulta = string_consulta + ", tx_apontamento_crng = '" + listastringSelecionada[4] + \ "' WHERE id_objeto_producao IN (" + lista_id_objeto_string + ") " + \ "AND nm_esquema_base = '" + esquema + "' AND concat_ws('_', nm_sigla_categoria, nm_classe) ILIKE '" + sigla_classe + "' AND tp_geom ILIKE '" + dic_geom[ultima_letra_geom] +"'" print u"UPDATE referente à camada ativa =", string_consulta # Executa atualização (update) db.exec_(string_consulta) # Percorre a mesma classe nas outras escalas for indice, uri in enumerate(InfoUriCamadasOutraEscala): # Verifica se a lista de id_objeto contém algum valor (alguma seleção) if lista_id_objeto_outras_camadas[indice]: if listastringSelecionada[2] == 'NULL': string_consulta = "UPDATE bngb_interface.t_interface SET cd_validacao_operador = '" + listastringSelecionada[ 3] + "', id_nomebngb = " + listastringSelecionada[ 1] + ", nm_geografico_producao = " + listastringSelecionada[ 2] #print "UPDATE referente à camada auxiliar = ", string_consulta else: string_consulta = "UPDATE bngb_interface.t_interface SET cd_validacao_operador = '" + listastringSelecionada[ 3] + "', id_nomebngb = " + listastringSelecionada[ 1] + ", nm_geografico_producao = '" + listastringSelecionada[ 2] + "'" #print "UPDATE referente à camada auxiliar = ", string_consulta if listastringSelecionada[4] == 'NULL': string_consulta = string_consulta + ", tx_apontamento_crng = " + listastringSelecionada[4] + \ " WHERE id_objeto_producao IN (" + ','.join(lista_id_objeto_outras_camadas[indice]) + ") " + \ "AND nm_esquema_base = '" + uri.schema() + "' AND concat_ws('_', nm_sigla_categoria, nm_classe) ILIKE '" + sigla_classe + "' AND tp_geom ILIKE '" + dic_geom[ultima_letra_geom] +"'" print u"UPDATE referente à camada auxiliar =", string_consulta else: string_consulta = string_consulta + ", tx_apontamento_crng = '" + listastringSelecionada[4] + \ "' WHERE id_objeto_producao IN (" + ','.join(lista_id_objeto_outras_camadas[indice]) + ") " + \ "AND nm_esquema_base = '" + uri.schema() + "' AND concat_ws('_', nm_sigla_categoria, nm_classe) ILIKE '" + sigla_classe + "' AND tp_geom ILIKE '" + dic_geom[ultima_letra_geom] +"'" print u"UPDATE referente à camada auxiliar =", string_consulta # Executa atualização (update) db.exec_(string_consulta)
def initParameters(self): from settingsdialog import SettingsDialog dialog = SettingsDialog(self.iface) accepted = dialog.exec_() if not accepted: return False
parser.add_argument("-s", "--settings", help="Show the settings dialog", action="store_true") parser.add_argument("-i", "--imitate", help="Show and immediately close the main window.", action="store_true") args = parser.parse_args() app = QApplication(sys.argv) if args.settings: from settingsdialog import SettingsDialog g = SettingsDialog() else: try: g = MainUi() except Exception as err: print("An exception has occured!") print( "Try opening the settings dialog with -s parameter and resaving the settings.", "You may have to delete your settings file as last resort.") raise err g.show() if args.imitate: sys.exit() rect = app.desktop().screenGeometry()
class MainWindow(QtGui.QMainWindow, Ui_MainWindow): def __init__(self, app = None, silence = False): QtGui.QMainWindow.__init__(self) self.setupUi(self) self.iface = backend.pm.Iface() self.setWindowIcon(QtGui.QIcon(":/data/package-manager.png")) self.connect(app, SIGNAL("aboutToQuit()"), self.slotQuit) self.setCentralWidget(MainWidget(self, silence)) self.initializeActions() if not silence: self.settingsDialog = SettingsDialog(self) self.initializeStatusBar() self.initializeTray() self.connectMainSignals() def connectMainSignals(self): self.connect(self.settingsDialog, SIGNAL("packagesChanged()"), self.centralWidget().initialize) self.connect(self.settingsDialog, SIGNAL("packageViewChanged()"), self.centralWidget().updateSettings) self.connect(self.settingsDialog, SIGNAL("traySettingChanged()"), self.tray.settingsChanged) self.connect(self.centralWidget().state, SIGNAL("repositoriesChanged()"), self.tray.populateRepositoryMenu) def initializeTray(self): self.tray = Tray(self, self.iface) self.connect(self.centralWidget().operation, SIGNAL("finished(QString)"), self.trayAction) self.connect(self.tray, SIGNAL("showUpdatesSelected()"), self.trayShowUpdates) def trayShowUpdates(self): self.showUpgradeAction.setChecked(True) self.centralWidget().switchState(StateManager.UPGRADE, action=False) self.centralWidget().initialize() self.show() self.raise_() def trayAction(self, operation): if not self.isVisible() and operation in ["System.Manager.updateRepository", "System.Manager.updateAllRepositories"]: self.tray.showPopup() if self.tray.isVisible() and operation in ["System.Manager.updatePackage", "System.Manager.installPackage", "System.Manager.removePackage"]: self.tray.updateTrayUnread() def initializeStatusBar(self): self.statusLabel = QtGui.QLabel(i18n("Currently your basket is empty."), self.statusBar()) self.statusLabel.setAlignment(QtCore.Qt.AlignCenter) self.statusBar().addWidget(self.statusLabel) self.statusBar().setSizeGripEnabled(True) self.wheelMovie = QtGui.QMovie(self) self.statusLabel.setText(i18n("Currently your basket is empty.")) self.wheelMovie.setFileName(":/data/wheel.mng") self.connect(self.centralWidget(), SIGNAL("selectionStatusChanged(QString)"), self.updateStatusBar) self.connect(self.centralWidget(), SIGNAL("updatingStatus()"), self.statusWaiting) def initializeActions(self): self.toolBar = QtGui.QToolBar(self) self.toolBar.setToolButtonStyle(QtCore.Qt.ToolButtonTextBesideIcon) self.addToolBar(QtCore.Qt.TopToolBarArea, self.toolBar) self.initializeOperationActions() def initializeOperationActions(self): actionGroup = QtGui.QActionGroup(self) self.menubar = QtGui.QMenuBar(self) self.menuFile = QtGui.QMenu(i18n('File'), self.menubar) self.menuOptions = QtGui.QMenu(i18n('Settings'), self.menubar) self.menuHelp = QtGui.QMenu(i18n('Help'), self.menubar) self.quitAppAction = QtGui.QAction(KIcon(('exit', 'application-exit')), i18n("Quit"), self) self.quitAppAction.setShortcut(QtGui.QKeySequence('Ctrl+q')) self.quitAppAction.triggered.connect(self.slotQuit) self.helpAppAction = QtGui.QAction(KIcon(('help', 'help-contents')), i18n("Help"), self) self.helpAppAction.setShortcut(QtGui.QKeySequence('F1')) self.helpAppAction.triggered.connect(self.showHelp) self.menuHelp.addAction(self.helpAppAction) self.setMenuBar(self.menubar) # Action Show Installable Packages self.showInstallAction = QtGui.QAction(KIcon("list-add"), i18n("Show Installable Packages"), self) self.showInstallAction.setCheckable(True) self.showInstallAction.setChecked(True) self.showInstallAction.triggered.connect(lambda:self.centralWidget().switchState(StateManager.INSTALL)) actionGroup.addAction(self.showInstallAction) self.toolBar.addAction(self.showInstallAction) self.menuFile.addAction(self.showInstallAction) # Action Show Installed Packages self.showRemoveAction = QtGui.QAction(KIcon("list-remove"), i18n("Show Installed Packages"), self) self.showRemoveAction.setCheckable(True) self.showRemoveAction.triggered.connect(lambda:self.centralWidget().switchState(StateManager.REMOVE)) actionGroup.addAction(self.showRemoveAction) self.toolBar.addAction(self.showRemoveAction) self.menuFile.addAction(self.showRemoveAction) # Action Show Upgradable Packages self.showUpgradeAction = QtGui.QAction(KIcon("view-refresh"), i18n("Show Upgradable Packages"), self) self.showUpgradeAction.setCheckable(True) self.showUpgradeAction.triggered.connect(lambda:self.centralWidget().switchState(StateManager.UPGRADE)) actionGroup.addAction(self.showUpgradeAction) self.toolBar.addAction(self.showUpgradeAction) self.menuFile.addAction(self.showUpgradeAction) self.menuFile.addSeparator() self.menuFile.addAction(self.quitAppAction) self.showSettingsAction = QtGui.QAction(KIcon("preferences-system"), i18n("Package Manager Settings"), self) self.showSettingsAction.triggered.connect(self.showSettingsDialog) self.menuOptions.addAction(self.showSettingsAction) self.menubar.addAction(self.menuFile.menuAction()) self.menubar.addAction(self.menuOptions.menuAction()) self.menubar.addAction(self.menuHelp.menuAction()) def showSettingsDialog(self): self.settingsDialog.show() def statusWaiting(self): self.statusLabel.setMovie(self.wheelMovie) self.wheelMovie.start() def updateStatusBar(self, text): self.wheelMovie.stop() self.statusLabel.setText(text) def queryClose(self): if config.PMConfig().systemTray(): self.hide() return False return True def showHelp(self): helpDialog = helpdialog.HelpDialog(self, helpdialog.MAINAPP) helpDialog.show() def queryExit(self): if not self.iface.operationInProgress(): if self.tray.notification: self.tray.notification.close() return True return False def slotQuit(self): if self.iface.operationInProgress(): return QtCore.QCoreApplication.quit()
class MainWindow(QtGui.QMainWindow, Ui_MainWindow): """Main Window for MOOSE GUI""" def __init__(self, loadFile=None, fileType=None): QtGui.QMainWindow.__init__(self) self.setupUi(self) self.setWindowIcon(QtGui.QIcon(':moose_thumbnail.png')) self.settingsDialog = SettingsDialog() self.settingsDialog.hide() layout = QtGui.QVBoxLayout(self.modelTreeTab) self.modelTreeTab.setLayout(layout) layout.addWidget(self.modelTreeContainerWidget) self.modelTreeWidget.headerItem().setHidden(True) self.plotUpdateIntervalLabel.setText(self.tr('<br>Plot update interval (<b>steps</b>)')) self.runTimeLabel.setText(self.tr('<br>Run for (<b>seconds</b>)')) # self.modelTreeWidget.show() # self.mooseClassToolBox.show() ################### # self.plotsLayout = QtGui.QHBoxLayout(self.plotsGroupBox) # self.plotsGroupBox.setLayout(self.plotsLayout) # self.plotsScrollArea = QtGui.QScrollArea(self.plotsGroupBox) # self.plotsLayout.addWidget(self.plotsScrollArea) # self.plots = MoosePlots(self.plotsScrollArea) # self.plotsScrollArea.setWidget(self.plots) # self.plots.show() ################## self.plots = MoosePlots(self.plotsGroupBox) self.plotsLayout = QtGui.QHBoxLayout(self.plotsGroupBox) self.plotsGroupBox.setLayout(self.plotsLayout) self.plotsLayout.addWidget(self.plots) ###################### self.plots.show() self.isModelLoaded = False self.stopFlag = False self.mooseHandler = MHandler() self.runTimeLineEdit.setText(self.tr(str(self.mooseHandler.runTime))) self.plotUpdateIntervalLineEdit.setText(self.tr(str(self.mooseHandler.updateInterval))) self.currentDirectory = '.' self.fileType = fileType self.fileTypes = MHandler.file_types self.filter = '' self.setupActions() if loadFile is not None and fileType is not None: self.load(loadFile, fileType) def setupActions(self): self.connect(self.actionQuit, QtCore.SIGNAL('triggered()'), QtGui.qApp, QtCore.SLOT('closeAllWindows()')) self.connect(self.actionLoad, QtCore.SIGNAL('triggered()'), self.loadFileDialog) self.connect(self.actionSquid_Axon, QtCore.SIGNAL('triggered()'), self.loadSquid_Axon_Tutorial) self.connect(self.actionIzhikevich_Neurons, QtCore.SIGNAL('triggered()'), self.loadIzhikevich_Neurons_Tutorial) self.connect(self.actionGLCell, QtCore.SIGNAL('triggered()'), self.loadGLCellDemo) self.connect(self.actionGLView, QtCore.SIGNAL('triggered()'), self.loadGLViewDemo) self.connect(self.actionAbout_MOOSE, QtCore.SIGNAL('triggered()'), self.showAbout_MOOSE) self.connect(self.actionReset, QtCore.SIGNAL('triggered()'), self.reset) self.connect(self.actionStart, QtCore.SIGNAL('triggered()'), self.run) self.connect(self.actionStop, QtCore.SIGNAL('triggered()'), self.stop) self.connect(self.runPushButton, QtCore.SIGNAL('clicked()'), self.run) self.connect(self.resetPushButton, QtCore.SIGNAL('clicked()'), self.reset) # self.connect(self.stopPushButton, # QtCore.SIGNAL('clicked()'), # self.mooseHandler.stop) self.connect(self.plotUpdateIntervalLineEdit, QtCore.SIGNAL('editingFinished()'), self.plotUpdateIntervalSlot) self.connect(self.modelTreeWidget, QtCore.SIGNAL('itemDoubleClicked(QTreeWidgetItem *, int)'), self.popupPropertyEditor) self.connect(self.mooseHandler, QtCore.SIGNAL('updated()'), self.updatePlots) self.connect(self.runTimeLineEdit, QtCore.SIGNAL('editingFinished()'), self.runTimeSlot) self.connect(self.rescalePlotsPushButton, QtCore.SIGNAL('clicked()'), self.plots.rescalePlots) self.connect(self.actionSettings, QtCore.SIGNAL('triggered()'), self.popupSettings) for listWidget in self.mooseClassToolBox.listWidgets: self.connect(listWidget, QtCore.SIGNAL('itemDoubleClicked(QListWidgetItem*)'), self.insertMooseObjectSlot) def popupPropertyEditor(self, item, column): """Pop-up a property editor to edit the Moose object in the item""" obj = item.getMooseObject() self.propertyModel = PropertyModel(obj) self.connect(self.propertyModel, QtCore.SIGNAL('objectNameChanged(const QString&)'), item.updateSlot) self.propertyEditor = QtGui.QTableView() self.propertyEditor.setModel(self.propertyModel) self.propertyEditor.setContextMenuPolicy(Qt.CustomContextMenu) self.connect(self.propertyEditor, QtCore.SIGNAL('customContextMenuRequested ( const QPoint&)'), self.popupFieldMenu) self.propertyEditor.show() def loadFileDialog(self): fileDialog = QtGui.QFileDialog(self) fileDialog.setFileMode(QtGui.QFileDialog.ExistingFile) ffilter = '' for key in self.fileTypes.keys(): ffilter = ffilter + key + ';;' ffilter = ffilter[:-2] fileDialog.setFilter(self.tr(ffilter)) # The following version gymnastic is because QFileDialog.selectNameFilter() was introduced in Qt 4.4 qtVersion = str(QtCore.QT_VERSION_STR).split('.') major = int(qtVersion[0]) minor = int(qtVersion[1]) if (major > 4)or ((major == 4) and (minor >= 4)): for key, value in self.fileTypes.items(): if value == FileTypeChecker.type_genesis: fileDialog.selectNameFilter(key) break if fileDialog.exec_(): fileNames = fileDialog.selectedFiles() fileFilter = fileDialog.selectedFilter() fileType = self.fileTypes[str(fileFilter)] # print 'file type:', fileType directory = fileDialog.directory() # Potential bug: if user types the whole file path, does it work? - no but gives error message for fileName in fileNames: # print fileName self.load(fileName, fileType) def loadIzhikevich_Neurons_Tutorial(self): # self.mooseHandler.load('../../DEMOS/pymoose/izhikevich/Izhikevich.py', 'MOOSE') spath = sys.path[0] + '/../../DEMOS/pymoose/izhikevich/demogui_qt.py' self.mooseHandler.load(spath, 'MOOSE') def loadGLCellDemo(self): spath = sys.path[0] + '/demo/glcelldemo.py' self.mooseHandler.load(spath, 'MOOSE') def loadGLViewDemo(self): spath = sys.path[0] + '/demo/glviewdemo.py' self.mooseHandler.load(spath, 'MOOSE') def loadSquid_Axon_Tutorial(self): # self.mooseHandler.load('../../DEMOS/pymoose/squid/qtSquid.py', 'MOOSE') spath = sys.path[0] + '/../../DEMOS/pymoose/squid/qtSquid.py' self.mooseHandler.load(spath, 'MOOSE') def showAbout_MOOSE(self): about = QtCore.QT_TR_NOOP('<p>MOOSE is the Multi-scale Object Oriented Simulation Environment.</p>' '<p>It is a general purpose simulation environment for computational neuroscience and chemical kinetics.</p>' '<p>Copyright (C) 2003-2009 Upinder S. Bhalla. and NCBS</p>' '<p>It is made available under the terms of the GNU Lesser General Public License version 2.1. See the file COPYING.LIB for the full notice.</p>' '<p>homepage: <a href="http://moose.ncbs.res.in">http://moose.ncbs.res.in</a></p>') aboutDialog = QtGui.QMessageBox.information(self, self.tr('About MOOSE'), about) def plotUpdateIntervalSlot(self): try: new_interval = int(str(self.plotUpdateIntervalLineEdit.text())) self.plotUpdateInterval = new_interval except ValueError: print 'Update steps must be whole number.' self.plotUpdateIntervalLineEdit.setText(self.tr(str(self.plotUpdateInterval))) def runTimeSlot(self): try: runtime = float(str(self.runTimeLineEdit.text())) self.mooseHandler.runTime = runtime except ValueError: print 'Error in converting runtime to float' self.runTimeLineEdit.setText(self.tr(str(self.mooseHandler.updateInterval))) def run(self): #print 'Going to run' if not self.isModelLoaded: errorDialog = QtGui.QErrorMessage(self) errorDialog.setModal(True) errorDialog.showMessage('<p>You must load a model first.</p>') return # The run for update interval and replot data until the full runtime has been executed # But this too is unresponsive self.mooseHandler.run() def updatePlots(self): """Update the plots""" if self.plots is not None: self.plots.updatePlots(self.mooseHandler) self.update() self.currentTimeLabel.setText(self.tr('Current time (seconds): %g' % self.mooseHandler.currentTime())) def reset(self): if not self.isModelLoaded: QtGui.QErrorMessage.showMessage('<p>You must load a model first.</p>') else: self.mooseHandler.reset() self.plots.resetPlots() self.currentTimeLabel.setText(self.tr('Current time (seconds): %g' % self.mooseHandler.currentTime())) def load(self, fileName, fileType): # if self.isModelLoaded: # import subprocess # subprocess.call(['python', 'main.py', fileName, fileType]) fileType = FileTypeChecker(str(fileName)).fileType() print 'File is of type:', fileType self.mooseHandler.context.setCwe(self.modelTreeWidget.currentItem().getMooseObject().path) self.mooseHandler.load(fileName, fileType) self.isModelLoaded = True self.modelTreeWidget.recreateTree() if fileType is FileTypeChecker.type_sbml: self.moleculeListWidget = QtGui.QListWidget(self) self.moleculeItems = [] for molecule in self.mooseHandler.moleculeList: item = QtGui.QListWidgetItem(self.moleculeListWidget) item.setText(molecule.name) item.setData(QtCore.Qt.UserRole, QtCore.QVariant(self.tr(molecule.path))) self.moleculeItems.append(item) self.simulationWidget.layout().addWidget(self.moleculeListWidget) self.connect(self.moleculeListWidget, QtCore.SIGNAL('itemDoubleClicked(QListWidgetItem*)'), self.addMoleculeInPlot) self.moleculeListWidget.show() self.plots.loadPlots(self.mooseHandler, fileType) self.currentTimeLabel.setText(self.tr('Current time (seonds): %g' % self.mooseHandler.currentTime())) # self.update() def addMoleculeInPlot(self, item): self.mooseHandler.createTableForMolecule(str(item.text())) self.plots.loadPlots(self.mooseHandler, FileTypeChecker.type_sbml) self.plots.setVisible(True) self.modelTreeWidget.recreateTree() self.update() # Until MOOSE has a way of getting stop command from outside def stop(self): self.mooseHandler.stop() def insertMooseObjectSlot(self, item): self.modelTreeWidget.insertMooseObjectSlot(item.text()) def popupSettings(self): self.settingsDialog.show() result = self.settingsDialog.exec_() if result == self.settingsDialog.Accepted: self.mooseHandler.addSimPathList(self.settingsDialog.simPathList()) def popupFieldMenu(self, clickpoint): print 'PopupFieldMenu' index = self.propertyEditor.indexAt(clickpoint) data = self.propertyModel.data(self.propertyModel.createIndex(index.row(), 0)) print data menu = QtGui.QMenu(self.propertyEditor) self.actionPlotField = menu.addAction('Plot this field') self.connect(self.actionPlotField, QtCore.SIGNAL('triggered()'), self.plotThisFieldSlot) menu.popup(clickpoint) def plotThisFieldSlot(self): print 'plotThisFieldSlot' moose_object = self.modelTreeWidget.currentItem().getMooseObject() row = self.propertyEditor.currentIndex().row() index = self.propertyModel.createIndex(row, 0) print index.row(), index.column() field_name = self.propertyModel.data(index) table = self.mooseHandler.createTableForMolecule(moose_object, field_name) print table.path
def _settings_click_cb(self, widget): dialog = SettingsDialog(widget.get_toplevel()) dialog.show()