class ProcessingDirnoProviderPlugin: def __init__(self, iface): self.provider = DirnoAlgorithmProvider() self.iface = iface def initGui(self): Processing.addProvider(self.provider) self.profilAction = QAction(QIcon(os.path.dirname(__file__) + "/icons/iconProvider.png"), "Ajouter un profil", self.iface.mainWindow()) self.profilAction.setObjectName("dirnoAction") self.profilAction.setWhatsThis("Dirno plugin") self.profilAction.setStatusTip("This is status tip") #QObject.connect(self.profilAction, SIGNAL("triggered()"), self.run) # add toolbar button and menu item #self.iface.addToolBarIcon(self.profilAction) self.iface.addPluginToMenu("&Dirno scripts", self.profilAction) self.profilAction.triggered.connect(self.launchDirnoAlgorithProfilDialog) def unload(self): Processing.removeProvider(self.provider) self.iface.removePluginMenu("&Dirno scripts", self.profilAction) #self.iface.removeToolBarIcon(self.profilAction) def launchDirnoAlgorithProfilDialog(self): return DirnoAlgorithmProfilDialog()
class MapSwipePlugin: def __init__(self, iface): def translate(): # # For create file 'qm' # 1) Define that files need for translation: mapswipetool.pro # 2) Create 'ts': pylupdate4 -verbose mapswipetool.pro # 3) Edit your translation: QtLinquist # 4) Create 'qm': lrelease *.ts # dirname = os.path.dirname(os.path.abspath(__file__)) locale = QSettings().value("locale/userLocale") localePath = os.path.join(dirname, "i18n", "%s_%s.qm" % (name_src, locale)) if os.path.exists(localePath): self.translator = QTranslator() self.translator.load(localePath) if qVersion() > '4.3.3': QCoreApplication.installTranslator(self.translator) self.iface = iface self.canvas = iface.mapCanvas() self.action = None # Define by initGui self.tool = MapSwipeTool(self.iface) self.prevTool = None # Define by run name_src = "mapswipetool" translate() def initGui(self): title = "Map swipe tool" icon = QIcon( os.path.join(os.path.dirname(__file__), 'mapswipetool.png')) self.action = QAction(icon, title, self.iface.mainWindow()) self.action.setObjectName("MapSwipeTool") self.action.setWhatsThis(title) self.action.setStatusTip(title) self.action.triggered.connect(self.run) self.menu = "&Map swipe tool" # Maptool self.action.setCheckable(True) self.tool.setAction(self.action) self.iface.addToolBarIcon(self.action) self.iface.addPluginToMenu(self.menu, self.action) def unload(self): self.canvas.unsetMapTool(self.tool) self.iface.removeToolBarIcon(self.action) self.iface.removePluginMenu(self.menu, self.action) del self.action @pyqtSlot() def run(self): if self.canvas.mapTool() != self.tool: self.prevTool = self.canvas.mapTool() self.canvas.setMapTool(self.tool) else: self.canvas.setMapTool(self.prevTool)
def addAction(self, action, checked=None, autoBuild=True): """ Adds the inputed action to this widget's action group. This will auto-\ create a new group if no group is already defined. :param action | <QAction> || <str> :return <QAction> """ # clear the holder actions = self._actionGroup.actions() if actions and actions[0].objectName() == 'place_holder': self._actionGroup.removeAction(actions[0]) actions[0].deleteLater() # create an action from the name if not isinstance(action, QAction): action_name = str(action) action = QAction(action_name, self) action.setObjectName(action_name) action.setCheckable(self.isCheckable()) # auto-check the first option if checked or (not self._actionGroup.actions() and checked is None): action.setChecked(True) self._actionGroup.addAction(action) if autoBuild: self.rebuild() return action
class MapSwipePlugin: def __init__(self, iface): def translate(): # # For create file 'qm' # 1) Define that files need for translation: mapswipetool.pro # 2) Create 'ts': pylupdate4 -verbose mapswipetool.pro # 3) Edit your translation: QtLinquist # 4) Create 'qm': lrelease *.ts # dirname = os.path.dirname( os.path.abspath(__file__) ) locale = QSettings().value("locale/userLocale") localePath = os.path.join( dirname, "i18n", "%s_%s.qm" % ( name_src, locale ) ) if os.path.exists(localePath): self.translator = QTranslator() self.translator.load(localePath) if qVersion() > '4.3.3': QCoreApplication.installTranslator(self.translator) self.iface = iface self.canvas = iface.mapCanvas() self.action = None # Define by initGui self.tool = MapSwipeTool( self.iface ) self.prevTool = None # Define by run name_src = "mapswipetool" translate() def initGui(self): title = "Map swipe tool" icon = QIcon( os.path.join( os.path.dirname(__file__), 'mapswipetool.png' ) ) self.action = QAction( icon, title, self.iface.mainWindow() ) self.action.setObjectName( "MapSwipeTool" ) self.action.setWhatsThis( title ) self.action.setStatusTip( title ) self.action.triggered.connect( self.run ) self.menu = "&Map swipe tool" # Maptool self.action.setCheckable( True ) self.tool.setAction( self.action ) self.iface.addToolBarIcon( self.action ) self.iface.addPluginToMenu( self.menu, self.action ) def unload(self): self.canvas.unsetMapTool( self.tool ) self.iface.removeToolBarIcon( self.action ) self.iface.removePluginMenu( self.menu, self.action ) del self.action @pyqtSlot() def run(self): if self.canvas.mapTool() != self.tool: self.prevTool = self.canvas.mapTool() self.canvas.setMapTool( self.tool ) else: self.canvas.setMapTool( self.prevTool )
class Interpreter(MDockWidget): def __init__(self, mainWindow=None): MDockWidget.__init__(self, mainWindow) self.__mainWindow = mainWindow self.icon = QIcon(":interpreter.png") self.addAction(mainWindow) self.g_display() def g_display(self): self.setWidget(InterpreterView(self)) self.setWindowTitle(QApplication.translate("Interpreter", "Interpreter", None, QApplication.UnicodeUTF8)) def addAction(self, mainWindow): self.__action = QAction(self) self.__action.setCheckable(True) self.__action.setChecked(True) self.__action.setObjectName("actionCoreInformations") self.__action.setText(QApplication.translate("MainWindow", "DFF interpreter", None, QApplication.UnicodeUTF8)) mainWindow.menuWindow.addAction(self.__action) self.connect(self.__action, SIGNAL("triggered()"), self.changeVisibleInformations) def changeVisibleInformations(self): if not self.isVisible() : self.setVisible(True) self.__action.setChecked(True) else : self.setVisible(False) self.__action.setChecked(False)
class ToggleActiveLayerPlugin: def __init__(self, iface): self.iface = iface self.canvas = iface.mapCanvas() self.action = None self.tool = ToggleActiveLayerMapTool( self.iface ) def initGui(self): title = "Toggle visibility of active layer" icon = QIcon( os.path.join( os.path.dirname(__file__), 'toggleactivelayer.png' ) ) self.action = QAction( icon, title, self.iface.mainWindow() ) self.action.setObjectName( "ToggleActiveLayerPlugin" ) self.action.setWhatsThis( title ) self.action.setStatusTip( title ) self.action.triggered.connect( self.run ) # Maptool self.action.setCheckable( True ) self.tool.setAction( self.action ) self.iface.addToolBarIcon( self.action ) def unload(self): self.canvas.unsetMapTool( self.tool ) self.iface.removeToolBarIcon( self.action ) del self.action @pyqtSlot() def run(self): if self.canvas.mapTool() != self.tool: self.canvas.setMapTool( self.tool)
def createCaptureButtons(self, form, wasselected): tool = form.getMaptool()(self.canvas) action = QAction(QIcon(":/icons/capture"), "Capture", None) action.setObjectName("capture") action.setCheckable(True) action.toggled.connect(partial(self.setMapTool, tool)) if isinstance(tool, PointTool): add = partial(self.addNewFeature, form) tool.geometryComplete.connect(add) else: tool.finished.connect(self.openForm) tool.error.connect(partial(self.showToolError, form.label)) # Set the action as a data entry button so we can remove it later. action.setProperty("dataentry", True) self.actionGPSFeature.setVisible(not tool.isEditTool()) self.projecttoolbar.insertAction(self.topspaceraction, action) self.projecttoolbar.insertAction(self.topspaceraction, self.actionGPSFeature) self.editgroup.addAction(action) self.layerbuttons.append(action) action.setChecked(wasselected)
class DBManagerPlugin: def __init__(self, iface): self.iface = iface self.dlg = None def initGui(self): self.action = QAction( QIcon(":/db_manager/icon"), QApplication.translate("DBManagerPlugin", "DB Manager"), self.iface.mainWindow()) self.action.setObjectName("dbManager") QObject.connect(self.action, SIGNAL("triggered()"), self.run) # Add toolbar button and menu item if hasattr(self.iface, 'addDatabaseToolBarIcon'): self.iface.addDatabaseToolBarIcon(self.action) else: self.iface.addToolBarIcon(self.action) if hasattr(self.iface, 'addPluginToDatabaseMenu'): self.iface.addPluginToDatabaseMenu( QApplication.translate("DBManagerPlugin", "DB Manager"), self.action) else: self.iface.addPluginToMenu( QApplication.translate("DBManagerPlugin", "DB Manager"), self.action) def unload(self): # Remove the plugin menu item and icon if hasattr(self.iface, 'removePluginDatabaseMenu'): self.iface.removePluginDatabaseMenu( QApplication.translate("DBManagerPlugin", "DB Manager"), self.action) else: self.iface.removePluginMenu( QApplication.translate("DBManagerPlugin", "DB Manager"), self.action) if hasattr(self.iface, 'removeDatabaseToolBarIcon'): self.iface.removeDatabaseToolBarIcon(self.action) else: self.iface.removeToolBarIcon(self.action) if self.dlg is not None: self.dlg.close() def run(self): # keep opened only one instance if self.dlg is None: from db_manager import DBManager self.dlg = DBManager(self.iface) QObject.connect(self.dlg, SIGNAL("destroyed(QObject *)"), self.onDestroyed) self.dlg.show() self.dlg.raise_() self.dlg.setWindowState(self.dlg.windowState() & ~Qt.WindowMinimized) self.dlg.activateWindow() def onDestroyed(self, obj): self.dlg = None
def getActions(self): """ @rtype: list of QAction """ advanced_toggle_action = QAction("Show Advanced Options", self) advanced_toggle_action.setObjectName("AdvancedSimulationOptions") advanced_toggle_action.setCheckable(True) advanced_toggle_action.setChecked(False) advanced_toggle_action.toggled.connect(self.toggleAdvanced) return [advanced_toggle_action]
def cancelform(self, *args): dlg = PickActionDialog(msg="Discard form changes?") self.expandAction = QAction(QIcon(":/icons/expand"), "Expand Panel", self) discardaction = QAction("Discard", self, triggered=self._cancel_form) discardaction.setObjectName("discard") noaction = QAction("No", self) dlg.addactions([noaction, discardaction]) dlg.exec_()
def applyButtons(profile): if profile.buttons is None: return for toolbar in customToolbarsWidgets[::-1]: toolbar.setVisible(False) iface.mainWindow().removeToolBar(toolbar) del toolbar del customToolbarsWidgets[:] currentToolbars = [el for el in iface.mainWindow().children() if isinstance(el, QToolBar)] customToolbars = defaultdict(list) toolbars = profile.buttons for toolbar in currentToolbars: if toolbar.objectName() in toolbars: hasVisibleActions = False actions = toolbar.actions() for i, action in enumerate(actions): objectName = action.objectName() or str(i) if objectName in toolbars[toolbar.objectName()]: location = toolbars[toolbar.objectName()][objectName] if location is not None: newAction = QAction(action.icon(), action.text(), iface.mainWindow()) newAction.triggered.connect(action.trigger) objectName = "%s_%i" % (location, len(customToolbars[location])) newAction.setObjectName(objectName) customToolbars[location].append(newAction) action.setVisible(False) else: hasVisibleActions = True action.setVisible(True) else: if toolbars[toolbar.objectName()]: action.setVisible(False) else: #If toolbar definition is empty, means all buttons should be added hasVisibleActions = True action.setVisible(True) if isinstance(action, QWidgetAction) and not isinstance(action.defaultWidget(), QToolButton) and action.defaultWidget() is not None: action.defaultWidget().setMinimumWidth(300) #action.defaultWidget().setMaximumWidth(400) toolbar.setVisible(hasVisibleActions) else: toolbar.setVisible(False) for name, actions in customToolbars.iteritems(): toolbar = iface.mainWindow().addToolBar(name) toolbar.setObjectName("toolbar_%s" % name) customToolbarsWidgets.append(toolbar) for action in actions: toolbar.addAction(action)
class QGISTester: def __init__(self, iface): # Save reference to the QGIS interface self.iface = iface # initialize plugin directory self.plugin_dir = os.path.dirname(QFile.decodeName(__file__)) # initialize locale locale = QSettings().value('locale/userLocale')[0:2] locale_path = os.path.join(self.plugin_dir, 'i18n', 'QGISTester_{}.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.menu = self.tr("&QGIS Tester") def tr(self, message): """Get the translation for a string using Qt translation API.""" return QCoreApplication.translate('QGISTester', message) def initGui(self): # Create action that will start plugin configuration icon_path = os.path.join(self.plugin_dir, "icon.png") self.action = QAction(QIcon(icon_path), self.tr("Test your QGIS!"), self.iface.mainWindow()) self.action.setObjectName("QGISTester_Test") # Connect the action to the run method self.action.triggered.connect(self.run) # Add toolbar button and menu item self.iface.addPluginToMenu(self.menu, self.action) if debug_mode: self.iface.addToolBarIcon(self.action) def unload(self): """Remove the plugin menu item and icon""" self.iface.removePluginMenu(self.menu, self.action) if debug_mode: self.iface.removeToolBarIcon(self.action) def run(self): # Import the code for the dialog from qgis_tester_dialog import QGISTesterDialog # Create the dialog dlg = QGISTesterDialog() # show the dialog dlg.show() # Run the dialog event loop dlg.exec_()
class CatalogPLPlugin: icon = QIcon(os.path.join(os.path.dirname(__file__), 'catalogpl.png')) pluginName = "Catalog Planet Labs" def __init__(self, iface): self.iface = iface self.name = u"&Catalog Planet Labs" self.msgBar = iface.messageBar() self.action = None self.ctl = CatalogPL(self.iface, CatalogPLPlugin.icon) CatalogPL.copyExpression() def initGui(self): msgtrans = "Catalog Planet Labs" self.action = QAction(CatalogPLPlugin.icon, msgtrans, self.iface.mainWindow()) self.action.setObjectName("CatalogPL") self.action.setWhatsThis(msgtrans) self.action.setStatusTip(msgtrans) self.action.triggered.connect(self.run) self.ctl.enableRun.connect(self.action.setEnabled) self.iface.addToolBarIcon(self.action) self.iface.addPluginToRasterMenu(self.name, self.action) def unload(self): self.iface.removePluginMenu(self.name, self.action) self.iface.removeToolBarIcon(self.action) del self.action del self.ctl @pyqtSlot() def run(self): if self.iface.mapCanvas().layerCount() == 0: msg = "Need layer(s) in map" self.iface.messageBar().pushMessage(CatalogPLPlugin.pluginName, msg, QgsMessageBar.WARNING, 2) return if not self.ctl.isHostLive: self.ctl.hostLive() if not self.ctl.isHostLive: return if not self.ctl.hasRegisterKey: self.ctl.registerKey() if not self.ctl.hasRegisterKey: return self.ctl.downloadScenes()
def __createMenu(self): file_menu = self.menuBar().addMenu("&File") file_menu.addAction("Close", self.__quit) self.__view_menu = self.menuBar().addMenu("&View") """ @rtype: list of QAction """ advanced_toggle_action = QAction("Show Advanced Options", self) advanced_toggle_action.setObjectName("AdvancedSimulationOptions") advanced_toggle_action.setCheckable(True) advanced_toggle_action.setChecked(False) advanced_toggle_action.toggled.connect(self.toggleAdvancedMode) self.__view_menu.addAction(advanced_toggle_action)
def clear(self, autoBuild=True): """ Clears the actions for this widget. """ for action in self._actionGroup.actions(): self._actionGroup.removeAction(action) action = QAction('', self) action.setObjectName('place_holder') # self._currentAction = None self._actionGroup.addAction(action) if autoBuild: self.rebuild()
class DBManagerPlugin: def __init__(self, iface): self.iface = iface self.dlg = None def initGui(self): self.action = QAction(QIcon(":/db_manager/icon"), QApplication.translate("DBManagerPlugin", "DB Manager"), self.iface.mainWindow()) self.action.setObjectName("dbManager") QObject.connect(self.action, SIGNAL("triggered()"), self.run) # Add toolbar button and menu item if hasattr(self.iface, 'addDatabaseToolBarIcon'): self.iface.addDatabaseToolBarIcon(self.action) else: self.iface.addToolBarIcon(self.action) if hasattr(self.iface, 'addPluginToDatabaseMenu'): self.iface.addPluginToDatabaseMenu(QApplication.translate("DBManagerPlugin", "DB Manager"), self.action) else: self.iface.addPluginToMenu(QApplication.translate("DBManagerPlugin", "DB Manager"), self.action) def unload(self): # Remove the plugin menu item and icon if hasattr(self.iface, 'removePluginDatabaseMenu'): self.iface.removePluginDatabaseMenu(QApplication.translate("DBManagerPlugin", "DB Manager"), self.action) else: self.iface.removePluginMenu(QApplication.translate("DBManagerPlugin", "DB Manager"), self.action) if hasattr(self.iface, 'removeDatabaseToolBarIcon'): self.iface.removeDatabaseToolBarIcon(self.action) else: self.iface.removeToolBarIcon(self.action) if self.dlg is not None: self.dlg.close() def run(self): # keep opened only one instance if self.dlg is None: from db_manager import DBManager self.dlg = DBManager(self.iface) QObject.connect(self.dlg, SIGNAL("destroyed(QObject *)"), self.onDestroyed) self.dlg.show() self.dlg.raise_() self.dlg.setWindowState(self.dlg.windowState() & ~Qt.WindowMinimized) self.dlg.activateWindow() def onDestroyed(self, obj): self.dlg = None
class RasterLegendSensitivePlugin: def __init__(self, iface): self.iface = iface self.name = u"Raster legend &sensitive" self.dock = None def initGui(self): msg = "Raster legend sensitive" icon = QIcon( os.path.join(os.path.dirname(__file__), 'rasterlegendsensitive.svg')) self.action = QAction(icon, msg, self.iface.mainWindow()) self.action.setObjectName("RasterLegendSensitive") self.action.setWhatsThis(msg) self.action.setStatusTip(msg) self.action.setCheckable(True) self.action.triggered.connect(self.run) self.iface.addRasterToolBarIcon(self.action) self.iface.addPluginToRasterMenu(self.name, self.action) self.dock = DockWidgetRasterLegendSensitive(self.iface) self.iface.addDockWidget(Qt.LeftDockWidgetArea, self.dock) self.dock.visibilityChanged.connect(self.dockVisibilityChanged) def unload(self): self.iface.removeRasterToolBarIcon(self.action) self.iface.removePluginRasterMenu(self.name, self.action) self.dock.close() del self.dock self.dock = None del self.action @pyqtSlot() def run(self): if self.dock.isVisible(): self.dock.hide() else: self.dock.show() @pyqtSlot(bool) def dockVisibilityChanged(self, visible): self.action.setChecked(visible) self.dock.visibility(visible)
class GetFeatureSelected: def __init__(self, iface): self.iface = iface def initGui(self): # cria uma ação que iniciará a configuração do plugin path = self.iface.mainWindow() icon_path = ':/plugins/GetFeatureSelected/i.png' self.action = QAction( QIcon(icon_path), u"Pega as Feições de uma camada selecionada e envia seu(s)s id(s) no campo filtro", path) self.action.setObjectName("Get Feature Selected") self.action.setStatusTip(None) self.action.setWhatsThis(None) QObject.connect(self.action, SIGNAL("triggered()"), self.GetFeatureSelected) # Adicionar o botão icone self.iface.addToolBarIcon(self.action) def unload(self): # remove o item de ícone do QGIS GUI. self.iface.removeToolBarIcon(self.action) def GetFeatureSelected(self): canvas = self.iface.mapCanvas() layer = canvas.currentLayer() if layer: count = layer.selectedFeatureCount() selectedId = layer.selectedFeaturesIds() print selectedId expressao = '(' for l in selectedId: expressao = expressao + str(l) + ',' expressao = expressao[:-1] expressao = expressao + ')' layer.setSubsetString('"id" IN %s' % expressao) print layer.setSubsetString('"id" IN %s' % expressao)
class GeoJSONExportPlugin: """QGIS Plugin that export geojson into a remote place""" def __init__(self, iface): """Initialization of the plugin""" # save reference to the QGIS interface self.iface = iface def initGui(self): """Initialize the GUI of the plugin""" self.action = QAction( QIcon(":/plugins/GeoJSONExportPlugin/img/icon.png"), "GeoJSON Export Plugin", self.iface.mainWindow()) self.action.setObjectName("testAction") self.action.setWhatsThis("Configuration for test plugin") self.action.setStatusTip("This is status tip") QObject.connect(self.action, SIGNAL("triggered()"), self.run) self.iface.addToolBarIcon(self.action) def unload(self): """Unload the plugin""" self.iface.removeToolBarIcon(self.action) def get_vector_layers(self): """Returns all the opened vector layers""" layers = self.iface.legendInterface().layers() vector_layers = [] for layer in layers: print layer.id() layerType = layer.type() if layerType == qgis.core.QgsMapLayer.VectorLayer: vector_layers.append(layer) return vector_layers def run(self): """Runs the plugin when the user activate it""" project_filename = qgis.core.QgsProject.instance().fileName() print '-' print project_filename if not project_filename: project_filename = u'Undefined' project_filename = project_filename.encode('utf-8') vector_layers = self.get_vector_layers() dlg = GeoJSONExportPluginDialog(project_filename, vector_layers) dlg.exec_()
def __createMenu(self): file_menu = self.menuBar().addMenu("&File") file_menu.addAction("Close", self.__quit) self.__view_menu = self.menuBar().addMenu("&View") self.__help_menu = self.menuBar().addMenu("&Help") """:type: QMenu""" """ @rtype: list of QAction """ advanced_toggle_action = QAction("Show Advanced Options", self) advanced_toggle_action.setObjectName("AdvancedSimulationOptions") advanced_toggle_action.setCheckable(True) advanced_toggle_action.setChecked(False) advanced_toggle_action.toggled.connect(self.toggleAdvancedMode) self.__view_menu.addAction(advanced_toggle_action) """ @rtype: list of QAction """ show_about = self.__help_menu.addAction("About") show_about.setMenuRole(QAction.ApplicationSpecificRole) show_about.triggered.connect(self.__showAboutMessage)
class AuxiliaryWindowPlugin: def __init__(self, iface): self.iface = iface self.plugin = ContainerAuxiliaryWindow(iface.mainWindow()) self.namePlugin = "&Auxiliary Window" def _connect(self, isConnect=True): signal_slot = ({ 'signal': QgsProject.instance().readProject, 'slot': self.plugin.onReadProject }, { 'signal': QgsProject.instance().writeProject, 'slot': self.plugin.onWriteProject }) if isConnect: for item in signal_slot: item['signal'].connect(item['slot']) else: for item in signal_slot: item['signal'].disconnect(item['slot']) def initGui(self): title = "Auxiliary window" icon = QIcon( os.path.join(os.path.dirname(__file__), 'auxiliarywindow.png')) self.action = QAction(icon, title, self.iface.mainWindow()) self.action.setObjectName("AuxiliaryWindow") self.action.setWhatsThis(title) self.action.setStatusTip(title) self.action.triggered.connect(self.run) self.iface.addToolBarIcon(self.action) self.iface.addPluginToMenu(self.namePlugin, self.action) self._connect() def unload(self): self.iface.removeToolBarIcon(self.action) self.iface.removePluginMenu(self.namePlugin, self.action) del self.action self._connect(False) self.plugin.close() @pyqtSlot() def run(self): self.plugin.run()
def action(name, parent=None, collection=None): """Returns a QAction with text and icon for the given snippet name. Returns None is no such snippet is available. If collection is provided, it is used to set shortcuts to the action. """ title = snippets.title(name) if not title: return a = QAction(parent) a.setObjectName(name) a.setText(title.replace('&', '&&')) icon = snippets.icon(name) if icon: a.setIcon(icon) if collection: shortcuts = collection.shortcuts(name) if shortcuts: a.setShortcuts(shortcuts) return a
def create_action(self, action_name, action_group, icon_num=None, text=None): """ Creates a new action with selected parameters """ icon = None icon_folder = self.plugin_dir + '/icons/' icon_path = icon_folder + icon_num + '.png' if os.path.exists(icon_path): icon = QIcon(icon_path) if icon is None: action = QAction(text, action_group) else: action = QAction(icon, text, action_group) action.setObjectName(action_name) return action
class AuxiliaryWindowPlugin: def __init__(self, iface): self.iface = iface self.plugin = ContainerAuxiliaryWindow( iface.mainWindow() ) self.namePlugin = "&Auxiliary Window" def _connect(self, isConnect = True): signal_slot = ( { 'signal': QgsProject.instance().readProject, 'slot': self.plugin.onReadProject }, { 'signal': QgsProject.instance().writeProject, 'slot': self.plugin.onWriteProject } ) if isConnect: for item in signal_slot: item['signal'].connect( item['slot'] ) else: for item in signal_slot: item['signal'].disconnect( item['slot'] ) def initGui(self): title = "Auxiliary window" icon = QIcon( os.path.join( os.path.dirname(__file__), 'auxiliarywindow.png' ) ) self.action = QAction( icon, title, self.iface.mainWindow() ) self.action.setObjectName( "AuxiliaryWindow" ) self.action.setWhatsThis( title ) self.action.setStatusTip( title ) self.action.triggered.connect( self.run ) self.iface.addToolBarIcon( self.action ) self.iface.addPluginToMenu( self.namePlugin, self.action) self._connect() def unload(self): self.iface.removeToolBarIcon( self.action ) self.iface.removePluginMenu( self.namePlugin, self.action) del self.action self._connect( False ) self.plugin.close() @pyqtSlot() def run(self): self.plugin.run()
class SearchLayers: def __init__(self, iface): self.iface = iface self.searchDialog = None def initGui(self): # Create the menu items in the Plugin menu and attach the icon to the toolbar icon = QIcon(os.path.dirname(__file__) + "/icon.png") self.searchAction = QAction(icon, "Search Layers", self.iface.mainWindow()) self.searchAction.setObjectName('searchLayers') self.searchAction.triggered.connect(self.showSearchDialog) self.iface.addToolBarIcon(self.searchAction) self.iface.addPluginToMenu("Search Layers", self.searchAction) # Help icon = QIcon(os.path.dirname(__file__) + '/help.png') self.helpAction = QAction(icon, "Help", self.iface.mainWindow()) self.helpAction.setObjectName('searchLayersHelp') self.helpAction.triggered.connect(self.help) self.iface.addPluginToMenu('Search Layers', self.helpAction) def unload(self): self.iface.removePluginMenu('Search Layers', self.searchAction) self.iface.removePluginMenu('Search Layers', self.helpAction) self.iface.removeToolBarIcon(self.searchAction) def showSearchDialog(self): if self.searchDialog is None: # All the work is done in the LayerSearchDialog self.searchDialog = LayerSearchDialog(self.iface, self.iface.mainWindow()) self.searchDialog.show() def help(self): '''Display a help page''' url = QUrl.fromLocalFile(os.path.dirname(__file__) + "/index.html").toString() webbrowser.open(url, new=2)
def addAction(self, action): """ Adds the inputed action to this widget's action group. This will auto-\ create a new group if no group is already defined. :param action | <QAction> || <str> :return <QAction> """ if (not isinstance(action, QAction)): action_name = str(action) action = QAction(action_name, self) action.setObjectName(action_name) action.setCheckable(True) if (not self._actionGroup): self._actionGroup = QActionGroup(self) action.setChecked(True) self._actionGroup.addAction(action) self.reset() return action
def addAction( self, action ): """ Adds the inputed action to this widget's action group. This will auto-\ create a new group if no group is already defined. :param action | <QAction> || <str> :return <QAction> """ if ( not isinstance(action, QAction) ): action_name = str(action) action = QAction(action_name, self) action.setObjectName(action_name) action.setCheckable(True) if ( not self._actionGroup ): self._actionGroup = QActionGroup(self) action.setChecked(True) self._actionGroup.addAction(action) self.reset() return action
def addMenus(self): if self.profilesMenu is not None: self.profilesMenu.clear() self.actions = defaultdict(list) settings = QSettings() defaultProfile = settings.value('profilesplugin/LastProfile', 'Default', unicode) autoLoad = settings.value('profilesplugin/AutoLoad', False, bool) for k, v in profiles.iteritems(): action = QAction(k, self.iface.mainWindow()) action.setCheckable(True) if k == defaultProfile and autoLoad: action.setChecked(True) action.triggered.connect(lambda _, menuName=k: self.applyProfile(menuName)) action.setObjectName('mProfilesPlugin_' + k) self.actions[v.group].append(action) actions = self.iface.mainWindow().menuBar().actions() settingsMenu = None self.profilesGroup = QActionGroup(self.iface.mainWindow()) if self.profilesMenu is None: for action in actions: if action.menu().objectName() == 'mSettingsMenu': settingsMenu = action.menu() self.profilesMenu = QMenu(settingsMenu) self.profilesMenu.setObjectName('mProfilesPlugin') self.profilesMenu.setTitle(self.tr('Profiles')) settingsMenu.addMenu(self.profilesMenu) break if self.profilesMenu is not None: for k,v in self.actions.iteritems(): submenu = QMenu(self.profilesMenu) submenu.setObjectName('mProfilesPlugin_submenu_' + k) submenu.setTitle(k) for action in v: self.profilesGroup.addAction(action) submenu.addAction(action) self.profilesMenu.addMenu(submenu) self.profilesMenu.addSeparator() settings = QSettings() def _setAutoLoad(): settings.setValue('profilesplugin/AutoLoad', self.autoloadAction.isChecked()) self.autoloadAction = QAction(self.tr('Auto-load last profile on QGIS start'), iface.mainWindow()) self.autoloadAction.setCheckable(True) autoLoad = settings.value('profilesplugin/AutoLoad', False, bool) self.autoloadAction.setChecked(autoLoad) self.autoloadAction.setObjectName('mProfilesPluginAutoLoad') self.autoloadAction.triggered.connect(_setAutoLoad) self.profilesMenu.addAction(self.autoloadAction) self.saveProfileAction = QAction(self.tr('Profiles manager...'), self.iface.mainWindow()) self.saveProfileAction.setObjectName('mProfilesPluginProfilesManager') self.saveProfileAction.triggered.connect(self.saveProfile) self.profilesMenu.addAction(self.saveProfileAction) self.showHelpAction = QAction(self.tr('Help'), self.iface.mainWindow()) self.showHelpAction.setIcon(QgsApplication.getThemeIcon('/mActionHelpContents.svg')) self.showHelpAction.setObjectName('mProfilesPluginShowHelp') self.showHelpAction.triggered.connect(self.showHelp) self.profilesMenu.addAction(self.showHelpAction)
class TalkEditorApp(FreeseerApp): '''Freeseer talk database editor main gui class''' def __init__(self, config, db): FreeseerApp.__init__(self) self.config = config self.db = db icon = QIcon() icon.addPixmap(QPixmap(':/freeseer/logo.png'), QIcon.Normal, QIcon.Off) self.setWindowIcon(icon) self.resize(960, 600) # # Setup Layout # self.mainWidget = QWidget() self.mainLayout = QVBoxLayout() self.mainWidget.setLayout(self.mainLayout) self.setCentralWidget(self.mainWidget) self.mainLayout.setAlignment(QtCore.Qt.AlignTop) # Add the Title Row (Use BOLD / Big Font) #self.titleLayout = QHBoxLayout() #self.backButton = QPushButton('Back to Recorder') #if backButton: # Only show the back button if requested by caller # self.titleLayout.addWidget(self.backButton) #self.titleLayout.addStretch() # Add custom widgets self.commandButtons = CommandButtons() self.tableView = QTableView() self.tableView.setSortingEnabled(True) self.tableView.setSelectionBehavior(QAbstractItemView.SelectRows) self.talkDetailsWidget = TalkDetailsWidget() self.importTalksWidget = ImportTalksWidget() self.mainLayout.addWidget(self.importTalksWidget) #self.mainLayout.addLayout(self.titleLayout) self.mainLayout.addWidget(self.commandButtons) self.mainLayout.addWidget(self.tableView) self.mainLayout.addWidget(self.talkDetailsWidget) self.mainLayout.addWidget(self.importTalksWidget) # --- End Layout # Initialize geometry, to be used for restoring window positioning. self.geometry = None # # Setup Menubar # self.actionExportCsv = QAction(self) self.actionExportCsv.setObjectName('actionExportCsv') self.actionRemoveAll = QAction(self) self.actionRemoveAll.setObjectName('actionRemoveAll') # Actions self.menuFile.insertAction(self.actionExit, self.actionExportCsv) self.menuFile.insertAction(self.actionExit, self.actionRemoveAll) # --- End Menubar # # TableView Connections # self.connect(self.tableView, SIGNAL('activated(const QModelIndex)'), self.talk_selected) self.connect(self.tableView, SIGNAL('selected(const QModelIndex)'), self.talk_selected) self.connect(self.tableView, SIGNAL('clicked(const QModelIndex)'), self.talk_selected) # Import Widget self.connect(self.importTalksWidget.csvRadioButton, SIGNAL('toggled(bool)'), self.toggle_import) self.connect(self.importTalksWidget.importButton, SIGNAL('clicked()'), self.import_talks) self.connect(self.importTalksWidget.cancelButton, SIGNAL('clicked()'), self.hide_import_talks_widget) self.importTalksWidget.setHidden(True) self.connect(self.importTalksWidget.csvFileSelectButton, QtCore.SIGNAL('clicked()'), self.csv_file_select) self.connect(self.importTalksWidget.csvLineEdit, QtCore.SIGNAL('returnPressed()'), self.importTalksWidget.importButton.click) self.connect(self.importTalksWidget.rssLineEdit, QtCore.SIGNAL('returnPressed()'), self.importTalksWidget.importButton.click) self.connect(self.actionExportCsv, QtCore.SIGNAL('triggered()'), self.export_talks_to_csv) self.connect(self.actionRemoveAll, QtCore.SIGNAL('triggered()'), self.confirm_reset) # Command Buttons self.connect(self.commandButtons.removeButton, SIGNAL('clicked()'), self.remove_talk) self.connect(self.commandButtons.removeAllButton, SIGNAL('clicked()'), self.confirm_reset) self.connect(self.commandButtons.importButton, SIGNAL('clicked()'), self.show_import_talks_widget) self.connect(self.commandButtons.exportButton, SIGNAL('clicked()'), self.export_talks_to_csv) self.connect(self.commandButtons.searchButton, SIGNAL('clicked()'), self.search_talks) self.connect(self.commandButtons.searchLineEdit, SIGNAL('textEdited(QString)'), self.search_talks) self.connect(self.commandButtons.searchLineEdit, SIGNAL('returnPressed()'), self.search_talks) # Talk Details Buttons self.connect(self.talkDetailsWidget.addButton, SIGNAL('clicked()'), self.clear_talk_details_widget) self.connect(self.talkDetailsWidget.saveButton, SIGNAL('clicked()'), self.add_talk) # Load default language actions = self.menuLanguage.actions() for action in actions: if action.data().toString() == self.config.default_language: action.setChecked(True) self.translate(action) break # Load Talk Database self.load_presentations_model() # Setup Autocompletion self.update_autocomple_fields() # Select first item #self.tableView.setCurrentIndex(self.proxy.index(0,0)) #self.talk_selected(self.proxy.index(0,0)) # # Translation # def retranslate(self): self.setWindowTitle(self.app.translate("TalkEditorApp", "Freeseer Talk Editor")) # # Reusable Strings # self.confirmDBClearTitleString = self.app.translate("TalkEditorApp", "Remove All Talks from Database") self.confirmDBClearQuestionString = self.app.translate("TalkEditorApp", "Are you sure you want to clear the DB?") # --- End Reusable Strings # # Menubar # self.actionExportCsv.setText(self.app.translate("TalkEditorApp", "&Export to CSV")) self.actionRemoveAll.setText(self.app.translate("TalkEditorApp", "&Remove All Talks")) # --- End Menubar # # TalkDetailsWidget # self.talkDetailsWidget.titleLabel.setText(self.app.translate("TalkEditorApp", "Title")) self.talkDetailsWidget.presenterLabel.setText(self.app.translate("TalkEditorApp", "Presenter")) self.talkDetailsWidget.categoryLabel.setText(self.app.translate("TalkEditorApp", "Category")) self.talkDetailsWidget.eventLabel.setText(self.app.translate("TalkEditorApp", "Event")) self.talkDetailsWidget.roomLabel.setText(self.app.translate("TalkEditorApp", "Room")) self.talkDetailsWidget.dateLabel.setText(self.app.translate("TalkEditorApp", "Date")) self.talkDetailsWidget.timeLabel.setText(self.app.translate("TalkEditorApp", "Time")) # --- End TalkDetailsWidget # # Import Talks Widget Translations # self.importTalksWidget.rssRadioButton.setText(self.app.translate("TalkEditorApp", "RSS URL")) self.importTalksWidget.csvRadioButton.setText(self.app.translate("TalkEditorApp", "CSV File")) self.importTalksWidget.importButton.setText(self.app.translate("TalkEditorApp", "Import")) # --- End Talks Widget Translations # # Command Button Translations\ # #self.commandButtons.addButton.setText(self.app.translate("TalkEditorApp", "Add")) self.commandButtons.importButton.setText(self.app.translate("TalkEditorApp", "Import")) self.commandButtons.exportButton.setText(self.app.translate("TalkEditorApp", "Export")) self.commandButtons.removeButton.setText(self.app.translate("TalkEditorApp", "Remove")) self.commandButtons.removeAllButton.setText(self.app.translate("TalkEditorApp", "Remove All")) # --- End Command Butotn Translations # # Search Widget Translations # self.commandButtons.searchButton.setText(self.app.translate("TalkEditorApp", "Search")) # --- End Command Button Translations def load_presentations_model(self): # Load Presentation Model self.presentationModel = self.db.get_presentations_model() self.proxy = QSortFilterProxyModel() self.proxy.setSourceModel(self.presentationModel) self.tableView.setModel(self.proxy) self.proxy.setFilterCaseSensitivity(QtCore.Qt.CaseInsensitive) # Fill table whitespace. self.tableView.horizontalHeader().setStretchLastSection(False) self.tableView.horizontalHeader().setResizeMode(1, QHeaderView.Stretch) # Hide the ID field self.tableView.setColumnHidden(0, True) # Map data to widgets self.mapper = QDataWidgetMapper() self.mapper.setModel(self.proxy) self.mapper.addMapping(self.talkDetailsWidget.titleLineEdit, 1) self.mapper.addMapping(self.talkDetailsWidget.presenterLineEdit, 2) self.mapper.addMapping(self.talkDetailsWidget.categoryLineEdit, 4) self.mapper.addMapping(self.talkDetailsWidget.eventLineEdit, 5) self.mapper.addMapping(self.talkDetailsWidget.roomLineEdit, 6) self.mapper.addMapping(self.talkDetailsWidget.descriptionTextEdit, 3) self.mapper.addMapping(self.talkDetailsWidget.dateEdit, 7) self.mapper.addMapping(self.talkDetailsWidget.timeEdit, 8) # Load StringLists self.titleList = QStringList(self.db.get_string_list("Title")) #self.speakerList = QStringList(self.db.get_speaker_list()) #self.categoryList = QStringList(self.db.get_category_list()) #self.eventList = QStringList(self.db.get_event_list()) #self.roomList = QStringList(self.db.get_room_list()) #Disble input self.talkDetailsWidget.disable_input_fields() def search_talks(self): # The default value is 0. If the value is -1, the keys will be read from all columns. self.proxy.setFilterKeyColumn(-1) self.proxy.setFilterFixedString(self.commandButtons.searchLineEdit.text()) def talk_selected(self, model): self.talkDetailsWidget.saveButton.setEnabled(False) self.mapper.setCurrentIndex(model.row()) self.talkDetailsWidget.enable_input_fields() def toggle_import(self): if self.importTalksWidget.csvRadioButton.isChecked(): self.importTalksWidget.csvLineEdit.setEnabled(True) self.importTalksWidget.csvFileSelectButton.setEnabled(True) self.importTalksWidget.rssLineEdit.setEnabled(False) else: self.importTalksWidget.csvLineEdit.setEnabled(False) self.importTalksWidget.csvFileSelectButton.setEnabled(False) self.importTalksWidget.rssLineEdit.setEnabled(True) def show_import_talks_widget(self): self.commandButtons.setHidden(True) self.tableView.setHidden(True) self.talkDetailsWidget.setHidden(True) self.importTalksWidget.setHidden(False) def hide_import_talks_widget(self): self.commandButtons.setHidden(False) self.tableView.setHidden(False) self.talkDetailsWidget.setHidden(False) self.importTalksWidget.setHidden(True) def add_talk(self): date = self.talkDetailsWidget.dateEdit.date() time = self.talkDetailsWidget.timeEdit.time() #datetime = QtCore.QDateTime(date, time) presentation = Presentation( unicode(self.talkDetailsWidget.titleLineEdit.text()), unicode(self.talkDetailsWidget.presenterLineEdit.text()), unicode(self.talkDetailsWidget.descriptionTextEdit.toPlainText()), unicode(self.talkDetailsWidget.categoryLineEdit.text()), unicode(self.talkDetailsWidget.eventLineEdit.text()), unicode(self.talkDetailsWidget.roomLineEdit.text()), unicode(date.toString(QtCore.Qt.ISODate)), unicode(time.toString(QtCore.Qt.ISODate))) # Do not add talks if they are empty strings if (len(presentation.title) == 0): return self.db.insert_presentation(presentation) # Update Model, Refreshes TableView self.presentationModel.select() # Select Last Row self.tableView.selectRow(self.presentationModel.rowCount() - 1) self.tableView.setCurrentIndex(self.proxy.index(self.proxy.rowCount() - 1, 0)) self.talk_selected(self.proxy.index(self.proxy.rowCount() - 1, 0)) self.update_autocomple_fields() self.talkDetailsWidget.disable_input_fields() def clear_talk_details_widget(self): self.talkDetailsWidget.saveButton.setEnabled(True) self.talkDetailsWidget.enable_input_fields() self.talkDetailsWidget.titleLineEdit.clear() self.talkDetailsWidget.presenterLineEdit.clear() self.talkDetailsWidget.descriptionTextEdit.clear() #self.talkDetailsWidget.categoryLineEdit.clear() #self.talkDetailsWidget.eventLineEdit.clear() #self.talkDetailsWidget.roomLineEdit.clear() self.presentationModel.select() def remove_talk(self): try: rows_selected = self.tableView.selectionModel().selectedRows() except: return # Reversed because rows in list change position once row is removed for row in reversed(rows_selected): self.presentationModel.removeRow(row.row()) def load_talk(self): try: self.tableView.currentIndex().row() except: return self.mapper.addMapping(self.talkDetailsWidget.roomLineEdit, 6) self.presentationModel.select() def reset(self): self.db.clear_database() self.presentationModel.select() def confirm_reset(self): """Presents a confirmation dialog to ask the user if they are sure they wish to remove the talk database. If Yes call the reset() function""" confirm = QMessageBox.question(self, self.confirmDBClearTitleString, self.confirmDBClearQuestionString, QMessageBox.Yes | QMessageBox.No, QMessageBox.No) if confirm == QMessageBox.Yes: self.reset() def add_talks_from_rss(self): rss_url = unicode(self.importTalksWidget.rssLineEdit.text()) if rss_url: self.db.add_talks_from_rss(rss_url) self.presentationModel.select() self.hide_import_talks_widget() else: error = QMessageBox() error.setText("Please enter a RSS URL") error.exec_() def closeEvent(self, event): log.info('Exiting talk database editor...') self.geometry = self.saveGeometry() event.accept() def csv_file_select(self): fname = QFileDialog.getOpenFileName( self, 'Select file', "", "*.csv") if fname: self.importTalksWidget.csvLineEdit.setText(fname) def add_talks_from_csv(self): fname = self.importTalksWidget.csvLineEdit.text() if fname: self.db.add_talks_from_csv(fname) self.presentationModel.select() self.hide_import_talks_widget() else: error = QMessageBox() error.setText("Please select a file") error.exec_() def import_talks(self): if self.importTalksWidget.csvRadioButton.isChecked(): self.add_talks_from_csv() else: self.add_talks_from_rss() self.update_autocomple_fields() def export_talks_to_csv(self): fname = QFileDialog.getSaveFileName(self, 'Select file', "", "*.csv") if fname: self.db.export_talks_to_csv(fname) def update_autocomple_fields(self): self.titleList = QStringList(self.db.get_string_list("Title")) self.speakerList = QStringList(self.db.get_string_list("Speaker")) self.categoryList = QStringList(self.db.get_string_list("Category")) self.eventList = QStringList(self.db.get_string_list("Event")) self.roomList = QStringList(self.db.get_string_list("Room")) self.titleCompleter = QCompleter(self.titleList) self.titleCompleter.setCaseSensitivity(Qt.CaseInsensitive) self.speakerCompleter = QCompleter(self.speakerList) self.speakerCompleter.setCaseSensitivity(Qt.CaseInsensitive) self.categoryCompleter = QCompleter(self.categoryList) self.categoryCompleter.setCaseSensitivity(Qt.CaseInsensitive) self.eventCompleter = QCompleter(self.eventList) self.eventCompleter.setCaseSensitivity(Qt.CaseInsensitive) self.roomCompleter = QCompleter(self.roomList) self.roomCompleter.setCaseSensitivity(Qt.CaseInsensitive) self.talkDetailsWidget.titleLineEdit.setCompleter(self.titleCompleter) self.talkDetailsWidget.presenterLineEdit.setCompleter(self.speakerCompleter) self.talkDetailsWidget.categoryLineEdit.setCompleter(self.categoryCompleter) self.talkDetailsWidget.eventLineEdit.setCompleter(self.eventCompleter) self.talkDetailsWidget.roomLineEdit.setCompleter(self.roomCompleter)
class Plugin(object): """The QGIS interface implementation for the InaSAFE plugin. This class acts as the 'glue' between QGIS and our custom logic. It creates a toolbar and menu bar entry and launches the InaSAFE user interface if these are activated. """ def __init__(self, iface): """Class constructor. On instantiation, the plugin instance will be assigned a copy of the QGIS iface object which will allow this plugin to access and manipulate the running QGIS instance that spawned it. :param iface:Quantum GIS iface instance. This instance is automatically passed to the plugin by QGIS when it loads the plugin. :type iface: QGisAppInterface """ # Register all the impact functions register_impact_functions() # Save reference to the QGIS interface self.iface = iface self.dock_widget = None self.action_import_dialog = None self.action_save_scenario = None self.action_batch_runner = None self.action_shake_converter = None self.action_minimum_needs = None self.action_global_minimum_needs = None self.action_impact_merge_dlg = None self.key_action = None self.action_options = None self.action_keywords_dialog = None self.action_keywords_wizard = None self.action_function_centric_wizard = None self.action_extent_selector = None self.translator = None self.toolbar = None self.actions = [] # list of all QActions we create for InaSAFE self.action_dock = None self.action_toggle_rubberbands = None self.message_bar_item = None # Flag indicating if toolbar should show only common icons or not self.full_toolbar = False # print self.tr('InaSAFE') # For enable/disable the keyword editor icon self.iface.currentLayerChanged.connect(self.layer_changed) # noinspection PyArgumentList def change_i18n(self, new_locale): """Change internationalisation for the plugin. Override the system locale and then see if we can get a valid translation file for whatever locale is effectively being used. :param new_locale: The new locale i.e. 'id', 'af', etc. :type new_locale: str :raises: TranslationLoadException """ os.environ['INASAFE_LANG'] = str(new_locale) LOGGER.debug('%s %s %s' % ( new_locale, QLocale.system().name(), os.environ['INASAFE_LANG'])) root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..')) translation_path = os.path.join( root, 'safe_qgis', 'i18n', 'inasafe_' + str(new_locale) + '.qm') if os.path.exists(translation_path): self.translator = QTranslator() result = self.translator.load(translation_path) if not result: message = 'Failed to load translation for %s' % new_locale raise TranslationLoadError(message) # noinspection PyTypeChecker,PyCallByClass QCoreApplication.installTranslator(self.translator) LOGGER.debug('%s %s' % ( translation_path, os.path.exists(translation_path))) # 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('Plugin', message) def add_action(self, action, add_to_toolbar=True): """Add a toolbar icon to the InaSAFE toolbar. :param action: The action that should be added to the toolbar. :type action: QAction :param add_to_toolbar: Flag indicating whether the action should also be added to the InaSAFE toolbar. Defaults to True. :type add_to_toolbar: bool """ # store in the class list of actions for easy plugin unloading self.actions.append(action) self.iface.addPluginToMenu(self.tr('InaSAFE'), action) if add_to_toolbar: self.toolbar.addAction(action) def _create_dock_toggle_action(self): """Create action for plugin dockable window (show/hide).""" # pylint: disable=W0201 icon = resources_path('img', 'icons', 'icon.svg') self.action_dock = QAction( QIcon(icon), self.tr('Toggle InaSAFE Dock'), self.iface.mainWindow()) self.action_dock.setObjectName('InaSAFEDockToggle') self.action_dock.setStatusTip(self.tr( 'Show/hide InaSAFE dock widget')) self.action_dock.setWhatsThis(self.tr( 'Show/hide InaSAFE dock widget')) self.action_dock.setCheckable(True) self.action_dock.setChecked(True) self.action_dock.triggered.connect(self.toggle_dock_visibility) self.add_action(self.action_dock) def _create_keywords_action(self): """Create action for keywords editor.""" icon = resources_path('img', 'icons', 'show-keyword-editor.svg') self.action_keywords_dialog = QAction( QIcon(icon), self.tr('InaSAFE Keyword Editor'), self.iface.mainWindow()) self.action_keywords_dialog.setStatusTip(self.tr( 'Open InaSAFE keywords editor')) self.action_keywords_dialog.setWhatsThis(self.tr( 'Open InaSAFE keywords editor')) self.action_keywords_dialog.setEnabled(False) self.action_keywords_dialog.triggered.connect( self.show_keywords_editor) self.add_action( self.action_keywords_dialog, add_to_toolbar=self.full_toolbar) def _create_keywords_wizard_action(self): """Create action for keywords creation wizard.""" icon = resources_path('img', 'icons', 'show-keyword-wizard.svg') self.action_keywords_wizard = QAction( QIcon(icon), self.tr('InaSAFE Keywords Creation Wizard'), self.iface.mainWindow()) self.action_keywords_wizard.setStatusTip(self.tr( 'Open InaSAFE keywords creation wizard')) self.action_keywords_wizard.setWhatsThis(self.tr( 'Open InaSAFE keywords creation wizard')) self.action_keywords_wizard.setEnabled(False) self.action_keywords_wizard.triggered.connect( self.show_keywords_wizard) self.add_action(self.action_keywords_wizard) def _create_analysis_wizard_action(self): """Create action for IF-centric wizard.""" icon = resources_path('img', 'icons', 'show-wizard.svg') self.action_function_centric_wizard = QAction( QIcon(icon), self.tr('InaSAFE Impact Function Centric Wizard'), self.iface.mainWindow()) self.action_function_centric_wizard.setStatusTip(self.tr( 'Open InaSAFE impact function centric wizard')) self.action_function_centric_wizard.setWhatsThis(self.tr( 'Open InaSAFE impact function centric wizard')) self.action_function_centric_wizard.setEnabled(True) self.action_function_centric_wizard.triggered.connect( self.show_function_centric_wizard) self.add_action(self.action_function_centric_wizard) def _create_options_dialog_action(self): """Create action for options dialog.""" icon = resources_path('img', 'icons', 'configure-inasafe.svg') self.action_options = QAction( QIcon(icon), self.tr('InaSAFE Options'), self.iface.mainWindow()) self.action_options.setStatusTip(self.tr( 'Open InaSAFE options dialog')) self.action_options.setWhatsThis(self.tr( 'Open InaSAFE options dialog')) self.action_options.triggered.connect(self.show_options) self.add_action(self.action_options, add_to_toolbar=self.full_toolbar) def _create_minimum_needs_action(self): """Create action for minimum needs dialog.""" icon = resources_path('img', 'icons', 'show-minimum-needs.svg') self.action_minimum_needs = QAction( QIcon(icon), self.tr('InaSAFE Minimum Needs Tool'), self.iface.mainWindow()) self.action_minimum_needs.setStatusTip(self.tr( 'Open InaSAFE minimum needs tool')) self.action_minimum_needs.setWhatsThis(self.tr( 'Open InaSAFE minimum needs tool')) self.action_minimum_needs.triggered.connect(self.show_minimum_needs) self.add_action( self.action_minimum_needs, add_to_toolbar=self.full_toolbar) def _create_minimum_needs_options_action(self): """Create action for global minimum needs dialog.""" icon = resources_path('img', 'icons', 'show-global-minimum-needs.svg') self.action_global_minimum_needs = QAction( QIcon(icon), self.tr('InaSAFE Global Minimum Needs Configuration'), self.iface.mainWindow()) self.action_global_minimum_needs.setStatusTip(self.tr( 'Open InaSAFE global minimum needs configuration')) self.action_global_minimum_needs.setWhatsThis(self.tr( 'Open InaSAFE global minimum needs configuration')) self.action_global_minimum_needs.triggered.connect( self.show_global_minimum_needs_configuration) self.add_action( self.action_global_minimum_needs, add_to_toolbar=self.full_toolbar) def _create_shakemap_converter_action(self): """Create action for converter dialog.""" icon = resources_path('img', 'icons', 'show-converter-tool.svg') self.action_shake_converter = QAction( QIcon(icon), self.tr('InaSAFE Converter'), self.iface.mainWindow()) self.action_shake_converter.setStatusTip(self.tr( 'Open InaSAFE Converter')) self.action_shake_converter.setWhatsThis(self.tr( 'Open InaSAFE Converter')) self.action_shake_converter.triggered.connect( self.show_shakemap_importer) self.add_action( self.action_shake_converter, add_to_toolbar=self.full_toolbar) def _create_batch_runner_action(self): """Create action for batch runner dialog.""" icon = resources_path('img', 'icons', 'show-batch-runner.svg') self.action_batch_runner = QAction( QIcon(icon), self.tr('InaSAFE Batch Runner'), self.iface.mainWindow()) self.action_batch_runner.setStatusTip(self.tr( 'Open InaSAFE Batch Runner')) self.action_batch_runner.setWhatsThis(self.tr( 'Open InaSAFE Batch Runner')) self.action_batch_runner.triggered.connect(self.show_batch_runner) self.add_action( self.action_batch_runner, add_to_toolbar=self.full_toolbar) def _create_save_scenario_action(self): """Create action for save scenario dialog.""" icon = resources_path('img', 'icons', 'save-as-scenario.svg') self.action_save_scenario = QAction( QIcon(icon), self.tr('Save Current Scenario'), self.iface.mainWindow()) message = self.tr('Save current scenario to text file') self.action_save_scenario.setStatusTip(message) self.action_save_scenario.setWhatsThis(message) # noinspection PyUnresolvedReferences self.action_save_scenario.triggered.connect(self.save_scenario) self.add_action( self.action_save_scenario, add_to_toolbar=self.full_toolbar) def _create_osm_downloader_action(self): """Create action for import OSM Dialog.""" icon = resources_path('img', 'icons', 'show-osm-download.svg') self.action_import_dialog = QAction( QIcon(icon), self.tr('InaSAFE OpenStreetMap Downloader'), self.iface.mainWindow()) self.action_import_dialog.setStatusTip(self.tr( 'InaSAFE OpenStreetMap Downloader')) self.action_import_dialog.setWhatsThis(self.tr( 'InaSAFE OpenStreetMap Downloader')) self.action_import_dialog.triggered.connect(self.show_osm_downloader) self.add_action(self.action_import_dialog) def _create_impact_merge_action(self): """Create action for impact layer merge Dialog.""" icon = resources_path('img', 'icons', 'show-impact-merge.svg') self.action_impact_merge_dlg = QAction( QIcon(icon), self.tr('InaSAFE Impact Layer Merge'), self.iface.mainWindow()) self.action_impact_merge_dlg.setStatusTip(self.tr( 'InaSAFE Impact Layer Merge')) self.action_impact_merge_dlg.setWhatsThis(self.tr( 'InaSAFE Impact Layer Merge')) self.action_impact_merge_dlg.triggered.connect(self.show_impact_merge) self.add_action( self.action_impact_merge_dlg, add_to_toolbar=self.full_toolbar) def _create_rubber_bands_action(self): """Create action for toggling rubber bands.""" icon = resources_path('img', 'icons', 'toggle-rubber-bands.svg') self.action_toggle_rubberbands = QAction( QIcon(icon), self.tr('Toggle Scenario Outlines'), self.iface.mainWindow()) message = self.tr('Toggle rubber bands showing scenarion extents.') self.action_toggle_rubberbands.setStatusTip(message) self.action_toggle_rubberbands.setWhatsThis(message) # Set initial state self.action_toggle_rubberbands.setCheckable(True) settings = QSettings() flag = bool(settings.value( 'inasafe/showRubberBands', False, type=bool)) self.action_toggle_rubberbands.setChecked(flag) # noinspection PyUnresolvedReferences self.action_toggle_rubberbands.triggered.connect( self.dock_widget.toggle_rubber_bands) self.add_action(self.action_toggle_rubberbands) def _create_analysis_extent_action(self): """Create action for analysis extent dialog.""" icon = resources_path('img', 'icons', 'set-extents-tool.svg') self.action_extent_selector = QAction( QIcon(icon), self.tr('Set InaSAFE Analysis Area'), self.iface.mainWindow()) self.action_extent_selector.setStatusTip(self.tr( 'Set the analysis area for InaSAFE')) self.action_extent_selector.setWhatsThis(self.tr( 'Set the analysis area for InaSAFE')) self.action_extent_selector.triggered.connect( self.show_extent_selector) self.add_action(self.action_extent_selector) def _create_test_layers_action(self): """Create action for adding layers (developer mode, non final only).""" final_release = release_status() == 'final' settings = QSettings() self.developer_mode = settings.value( 'inasafe/developer_mode', False, type=bool) if not final_release and self.developer_mode: icon = resources_path('img', 'icons', 'add-test-layers.svg') self.action_add_layers = QAction( QIcon(icon), self.tr('Add Some Test Layers'), self.iface.mainWindow()) self.action_add_layers.setStatusTip(self.tr( 'Add some test layers')) self.action_add_layers.setWhatsThis(self.tr( 'Add some test layers')) self.action_add_layers.triggered.connect( self.add_test_layers) self.add_action(self.action_add_layers) def _create_dock(self): """Create dockwidget and tabify it with the legend.""" # Import dock here as it needs to be imported AFTER i18n is set up from safe.gui.widgets.dock import Dock self.dock_widget = Dock(self.iface) self.iface.addDockWidget(Qt.RightDockWidgetArea, self.dock_widget) legend_tab = self.iface.mainWindow().findChild(QApplication, 'Legend') if legend_tab: self.iface.mainWindow().tabifyDockWidget( legend_tab, self.dock_widget) self.dock_widget.raise_() def initGui(self): """Gui initialisation procedure (for QGIS plugin api). .. note:: Don't change the name of this method from initGui! This method is called by QGIS and should be used to set up any graphical user interface elements that should appear in QGIS by default (i.e. before the user performs any explicit action with the plugin). """ self.toolbar = self.iface.addToolBar('InaSAFE') self.toolbar.setObjectName('InaSAFEToolBar') self.dock_widget = None # Now create the actual dock self._create_dock() # And all the menu actions # Configuration Group self._create_options_dialog_action() self._create_minimum_needs_options_action() self._create_analysis_extent_action() self._create_dock_toggle_action() self._create_rubber_bands_action() # TODO: add menu separator - Wizards self._create_keywords_wizard_action() self._create_analysis_wizard_action() # TODO: add menu separator - Data self._create_osm_downloader_action() self._create_shakemap_converter_action() self._create_minimum_needs_action() self._create_test_layers_action() # TODO: add menu separator - Analysis self._create_batch_runner_action() self._create_impact_merge_action() self._create_save_scenario_action() # TODO: This action (and related code) will be deprecated # keywords dialog to be replaced by keywords wizard self._create_keywords_action() # Hook up a slot for when the dock is hidden using its close button # or view-panels # self.dock_widget.visibilityChanged.connect(self.toggle_inasafe_action) # Also deal with the fact that on start of QGIS dock may already be # hidden. self.action_dock.setChecked(self.dock_widget.isVisible()) def clear_modules(self): """Unload inasafe functions and try to return QGIS to before InaSAFE. .. todo:: I think this function can be removed. TS. """ # next lets force remove any inasafe related modules modules = [] for module in sys.modules: if 'inasafe' in module: # Check if it is really one of our modules i.e. exists in the # plugin directory tokens = module.split('.') path = '' for myToken in tokens: path += os.path.sep + myToken parent = os.path.abspath(os.path.join( __file__, os.path.pardir, os.path.pardir)) full_path = os.path.join(parent, path + '.py') if os.path.exists(os.path.abspath(full_path)): LOGGER.debug('Removing: %s' % module) modules.append(module) for module in modules: del (sys.modules[module]) for module in sys.modules: if 'inasafe' in module: print module # Lets also clean up all the path additions that were made package_path = os.path.abspath(os.path.join( os.path.dirname(__file__), os.path.pardir)) LOGGER.debug('Path to remove: %s' % package_path) # We use a list comprehension to ensure duplicate entries are removed LOGGER.debug(sys.path) sys.path = [y for y in sys.path if package_path not in y] LOGGER.debug(sys.path) def unload(self): """GUI breakdown procedure (for QGIS plugin api). .. note:: Don't change the name of this method from unload! This method is called by QGIS and should be used to *remove* any graphical user interface elements that should appear in QGIS. """ # Remove the plugin menu item and icon for myAction in self.actions: self.iface.removePluginMenu(self.tr('InaSAFE'), myAction) self.iface.removeToolBarIcon(myAction) self.iface.mainWindow().removeDockWidget(self.dock_widget) self.iface.mainWindow().removeToolBar(self.toolbar) self.dock_widget.setVisible(False) self.dock_widget.destroy() self.iface.currentLayerChanged.disconnect(self.layer_changed) def toggle_inasafe_action(self, checked): """Check or un-check the toggle inaSAFE toolbar button. This slot is called when the user hides the inaSAFE panel using its close button or using view->panels. :param checked: True if the dock should be shown, otherwise False. :type checked: bool """ self.action_dock.setChecked(checked) # Run method that performs all the real work def toggle_dock_visibility(self): """Show or hide the dock widget.""" if self.dock_widget.isVisible(): self.dock_widget.setVisible(False) else: self.dock_widget.setVisible(True) self.dock_widget.raise_() def add_test_layers(self): """Add standard test layers.""" from safe.test.utilities import load_standard_layers load_standard_layers() def show_extent_selector(self): """Show the extent selector widget for defining analysis extents.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.extent_selector_dialog import ExtentSelectorDialog widget = ExtentSelectorDialog( self.iface, self.iface.mainWindow(), extent=self.dock_widget.extent.user_extent, crs=self.dock_widget.extent.user_extent_crs) widget.clear_extent.connect( self.dock_widget.extent.clear_user_analysis_extent) widget.extent_defined.connect( self.dock_widget.define_user_analysis_extent) # Needs to be non modal to support hide -> interact with map -> show widget.show() # non modal def show_minimum_needs(self): """Show the minimum needs dialog.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.minimum_needs.needs_calculator_dialog import ( NeedsCalculatorDialog ) dialog = NeedsCalculatorDialog(self.iface.mainWindow()) dialog.show() # non modal def show_global_minimum_needs_configuration(self): """Show the minimum needs dialog.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.minimum_needs.needs_manager_dialog import ( NeedsManagerDialog) dialog = NeedsManagerDialog( parent=self.iface.mainWindow(), dock=self.dock_widget) dialog.exec_() # modal def show_impact_merge(self): """Show the impact layer merge dialog.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.impact_merge_dialog import ImpactMergeDialog dialog = ImpactMergeDialog(self.iface.mainWindow()) dialog.exec_() # modal def show_options(self): """Show the options dialog.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.options_dialog import OptionsDialog dialog = OptionsDialog( self.iface, self.dock_widget, self.iface.mainWindow()) dialog.exec_() # modal def show_keywords_editor(self): """Show the keywords editor.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.keywords_dialog import KeywordsDialog # Next block is a fix for #776 if self.iface.activeLayer() is None: return try: keyword_io = KeywordIO() keyword_io.read_keywords(self.iface.activeLayer()) except UnsupportedProviderError: # noinspection PyUnresolvedReferences,PyCallByClass # noinspection PyTypeChecker,PyArgumentList QMessageBox.warning( None, self.tr('Unsupported layer type'), self.tr( 'The layer you have selected cannot be used for ' 'analysis because its data type is unsupported.')) return # End of fix for #776 # Fix for #793 except NoKeywordsFoundError: # we will create them from scratch in the dialog pass # End of fix for #793 # Fix for filtered-layer except InvalidParameterError, e: # noinspection PyTypeChecker,PyTypeChecker,PyArgumentList QMessageBox.warning( None, self.tr('Invalid Layer'), e.message ) return dialog = KeywordsDialog( self.iface.mainWindow(), self.iface, self.dock_widget) dialog.exec_() # modal
class ProfilesPlugin: def __init__(self, iface): self.iface = iface QSettings().setValue('/UI/Customization/enabled', False) try: from profiles.tests import testerplugin from qgistester.tests import addTestModule addTestModule(testerplugin, 'Profiles plugin') except: pass self.userProfileAction = None self.profilesMenu = None iface.initializationCompleted.connect(self.initProfile) def unload(self): if self.profilesMenu is not None: self.profilesMenu.deleteLater() self.iface.removePluginMenu(self.tr('Profiles'), self.autoloadAction) self.iface.removePluginMenu(self.tr('Profiles'), self.saveProfileAction) try: from profiles.tests import testerplugin from qgistester.tests import removeTestModule removeTestModule(testerplugin, 'Profiles plugin') except: pass saveCurrentPluginState() def initGui(self): self.addMenus() def addMenus(self): if self.profilesMenu is not None: self.profilesMenu.clear() self.actions = defaultdict(list) settings = QSettings() defaultProfile = settings.value('profilesplugin/LastProfile', 'Default', unicode) autoLoad = settings.value('profilesplugin/AutoLoad', False, bool) for k, v in profiles.iteritems(): action = QAction(k, self.iface.mainWindow()) action.setCheckable(True) if k == defaultProfile and autoLoad: action.setChecked(True) action.triggered.connect(lambda _, menuName=k: self.applyProfile(menuName)) action.setObjectName('mProfilesPlugin_' + k) self.actions[v.group].append(action) actions = self.iface.mainWindow().menuBar().actions() settingsMenu = None self.profilesGroup = QActionGroup(self.iface.mainWindow()) if self.profilesMenu is None: for action in actions: if action.menu().objectName() == 'mSettingsMenu': settingsMenu = action.menu() self.profilesMenu = QMenu(settingsMenu) self.profilesMenu.setObjectName('mProfilesPlugin') self.profilesMenu.setTitle(self.tr('Profiles')) settingsMenu.addMenu(self.profilesMenu) break if self.profilesMenu is not None: for k,v in self.actions.iteritems(): submenu = QMenu(self.profilesMenu) submenu.setObjectName('mProfilesPlugin_submenu_' + k) submenu.setTitle(k) for action in v: self.profilesGroup.addAction(action) submenu.addAction(action) self.profilesMenu.addMenu(submenu) self.profilesMenu.addSeparator() settings = QSettings() def _setAutoLoad(): settings.setValue('profilesplugin/AutoLoad', self.autoloadAction.isChecked()) self.autoloadAction = QAction(self.tr('Auto-load last profile on QGIS start'), iface.mainWindow()) self.autoloadAction.setCheckable(True) autoLoad = settings.value('profilesplugin/AutoLoad', False, bool) self.autoloadAction.setChecked(autoLoad) self.autoloadAction.setObjectName('mProfilesPluginAutoLoad') self.autoloadAction.triggered.connect(_setAutoLoad) self.profilesMenu.addAction(self.autoloadAction) self.saveProfileAction = QAction(self.tr('Profiles manager...'), self.iface.mainWindow()) self.saveProfileAction.setObjectName('mProfilesPluginProfilesManager') self.saveProfileAction.triggered.connect(self.saveProfile) self.profilesMenu.addAction(self.saveProfileAction) self.showHelpAction = QAction(self.tr('Help'), self.iface.mainWindow()) self.showHelpAction.setIcon(QgsApplication.getThemeIcon('/mActionHelpContents.svg')) self.showHelpAction.setObjectName('mProfilesPluginShowHelp') self.showHelpAction.triggered.connect(self.showHelp) self.profilesMenu.addAction(self.showHelpAction) def applyProfile(self, name): profile = profiles.get(name) applyProfile(profile) def initProfile(self): settings = QSettings() autoLoad = settings.value('profilesplugin/AutoLoad', False, bool) if autoLoad: profileName = settings.value('profilesplugin/LastProfile', '', unicode) if profileName in profiles: profile = profiles[profileName] if not profile.hasToInstallPlugins(): applyProfile(profile, False) def saveProfile(self): dlg = ProfileManager(iface.mainWindow()) dlg.exec_() def showHelp(self): if not QDesktopServices.openUrl( QUrl('file://{}'.format(os.path.join(pluginPath, 'docs', 'html', 'index.html')))): QMessageBox.warning(None, self.tr('Error'), self.tr('Can not open help URL in browser')) def tr(self, text): return QCoreApplication.translate('Profiles', text)
class FreeseerApp(QMainWindow): def __init__(self, config): super(FreeseerApp, self).__init__() self.config = config self.icon = QIcon() self.icon.addPixmap(QPixmap(_fromUtf8(":/freeseer/logo.png")), QIcon.Normal, QIcon.Off) self.setWindowIcon(self.icon) self.aboutDialog = AboutDialog() self.aboutDialog.setModal(True) self.logDialog = LogDialog() # # Translator # self.app = QApplication.instance() self.current_language = None self.uiTranslator = QTranslator() self.uiTranslator.load(":/languages/tr_en_US.qm") self.app.installTranslator(self.uiTranslator) self.langActionGroup = QActionGroup(self) self.langActionGroup.setExclusive(True) QTextCodec.setCodecForTr(QTextCodec.codecForName('utf-8')) self.connect(self.langActionGroup, SIGNAL('triggered(QAction *)'), self.translate) # --- Translator # # Setup Menubar # self.menubar = self.menuBar() self.menubar.setGeometry(QRect(0, 0, 500, 50)) self.menubar.setObjectName(_fromUtf8("menubar")) self.menuFile = QMenu(self.menubar) self.menuFile.setObjectName(_fromUtf8("menuFile")) self.menuLanguage = QMenu(self.menubar) self.menuLanguage.setObjectName(_fromUtf8("menuLanguage")) self.menuHelp = QMenu(self.menubar) self.menuHelp.setObjectName(_fromUtf8("menuHelp")) exitIcon = QIcon.fromTheme("application-exit") self.actionExit = QAction(self) self.actionExit.setShortcut("Ctrl+Q") self.actionExit.setObjectName(_fromUtf8("actionExit")) self.actionExit.setIcon(exitIcon) helpIcon = QIcon.fromTheme("help-contents") self.actionOnlineHelp = QAction(self) self.actionOnlineHelp.setObjectName(_fromUtf8("actionOnlineHelp")) self.actionOnlineHelp.setIcon(helpIcon) self.actionAbout = QAction(self) self.actionAbout.setObjectName(_fromUtf8("actionAbout")) self.actionAbout.setIcon(self.icon) self.actionLog = QAction(self) self.actionLog.setObjectName(_fromUtf8("actionLog")) self.actionLog.setShortcut("Ctrl+L") # Actions self.menuFile.addAction(self.actionExit) self.menuHelp.addAction(self.actionAbout) self.menuHelp.addAction(self.actionLog) self.menuHelp.addAction(self.actionOnlineHelp) self.menubar.addAction(self.menuFile.menuAction()) self.menubar.addAction(self.menuLanguage.menuAction()) self.menubar.addAction(self.menuHelp.menuAction()) self.setupLanguageMenu() # --- End Menubar self.connect(self.actionExit, SIGNAL('triggered()'), self.close) self.connect(self.actionAbout, SIGNAL('triggered()'), self.aboutDialog.show) self.connect(self.actionLog, SIGNAL('triggered()'), self.logDialog.show) self.connect(self.actionOnlineHelp, SIGNAL('triggered()'), self.openOnlineHelp) self.retranslateFreeseerApp() self.aboutDialog.aboutWidget.retranslate("en_US") def openOnlineHelp(self): """Opens a link to the Freeseer Online Help""" url = QUrl("http://freeseer.readthedocs.org") QDesktopServices.openUrl(url) def translate(self, action): """Translates the GUI via menu action. When a language is selected from the language menu, this function is called and the language to be changed to is retrieved. """ self.current_language = str( action.data().toString()).strip("tr_").rstrip(".qm") log.info("Switching language to: %s" % action.text()) self.uiTranslator.load(":/languages/tr_%s.qm" % self.current_language) self.app.installTranslator(self.uiTranslator) self.retranslateFreeseerApp() self.aboutDialog.aboutWidget.retranslate(self.current_language) self.retranslate() self.logDialog.retranslate() def retranslate(self): """ Reimplement this function to provide translations to your app. """ pass def retranslateFreeseerApp(self): # # Menubar # self.menuFile.setTitle(self.app.translate("FreeseerApp", "&File")) self.menuLanguage.setTitle( self.app.translate("FreeseerApp", "&Language")) self.menuHelp.setTitle(self.app.translate("FreeseerApp", "&Help")) self.actionExit.setText(self.app.translate("FreeseerApp", "&Quit")) self.actionAbout.setText(self.app.translate("FreeseerApp", "&About")) self.actionLog.setText(self.app.translate("FreeseerApp", "View &Log")) self.actionOnlineHelp.setText( self.app.translate("FreeseerApp", "Online Documentation")) # --- Menubar def setupLanguageMenu(self): self.languages = QDir(":/languages").entryList() if self.current_language is None: self.current_language = QLocale.system().name( ) # Retrieve Current Locale from the operating system. log.debug("Detected user's locale as %s" % self.current_language) for language in self.languages: translator = QTranslator( ) # Create a translator to translate Language Display Text. translator.load(":/languages/%s" % language) language_display_text = translator.translate( "Translation", "Language Display Text") languageAction = QAction(self) languageAction.setCheckable(True) languageAction.setText(language_display_text) languageAction.setData(language) self.menuLanguage.addAction(languageAction) self.langActionGroup.addAction(languageAction)
class ProcessingPlugin: def __init__(self, iface): self.iface = iface def initGui(self): Processing.initialize() self.commander = None self.toolbox = ProcessingToolbox() self.iface.addDockWidget(Qt.RightDockWidgetArea, self.toolbox) self.toolbox.hide() Processing.addAlgListListener(self.toolbox) self.menu = QMenu(self.iface.mainWindow().menuBar()) self.menu.setObjectName('processing') self.menu.setTitle(self.tr('Pro&cessing')) self.toolboxAction = self.toolbox.toggleViewAction() self.toolboxAction.setObjectName('toolboxAction') self.toolboxAction.setIcon( QIcon(os.path.join(cmd_folder, 'images', 'alg.png'))) self.toolboxAction.setText(self.tr('&Toolbox')) self.iface.registerMainWindowAction(self.toolboxAction, 'Ctrl+Alt+T') self.menu.addAction(self.toolboxAction) self.modelerAction = QAction( QIcon(os.path.join(cmd_folder, 'images', 'model.png')), self.tr('Graphical &Modeler...'), self.iface.mainWindow()) self.modelerAction.setObjectName('modelerAction') self.modelerAction.triggered.connect(self.openModeler) self.iface.registerMainWindowAction(self.modelerAction, 'Ctrl+Alt+M') self.menu.addAction(self.modelerAction) self.historyAction = QAction( QIcon(os.path.join(cmd_folder, 'images', 'history.gif')), self.tr('&History...'), self.iface.mainWindow()) self.historyAction.setObjectName('historyAction') self.historyAction.triggered.connect(self.openHistory) self.iface.registerMainWindowAction(self.historyAction, 'Ctrl+Alt+H') self.menu.addAction(self.historyAction) self.configAction = QAction( QIcon(os.path.join(cmd_folder, 'images', 'config.png')), self.tr('&Options...'), self.iface.mainWindow()) self.configAction.setObjectName('configAction') self.configAction.triggered.connect(self.openConfig) self.iface.registerMainWindowAction(self.configAction, 'Ctrl+Alt+C') self.menu.addAction(self.configAction) self.resultsAction = QAction( QIcon(os.path.join(cmd_folder, 'images', 'results.png')), self.tr('&Results Viewer...'), self.iface.mainWindow()) self.resultsAction.setObjectName('resultsAction') self.resultsAction.triggered.connect(self.openResults) self.iface.registerMainWindowAction(self.resultsAction, 'Ctrl+Alt+R') self.menu.addAction(self.resultsAction) menuBar = self.iface.mainWindow().menuBar() menuBar.insertMenu(self.iface.firstRightStandardMenu().menuAction(), self.menu) self.commanderAction = QAction( QIcon(os.path.join(cmd_folder, 'images', 'commander.png')), self.tr('&Commander'), self.iface.mainWindow()) self.commanderAction.setObjectName('commanderAction') self.commanderAction.triggered.connect(self.openCommander) self.menu.addAction(self.commanderAction) self.iface.registerMainWindowAction(self.commanderAction, self.tr('Ctrl+Alt+M')) def unload(self): self.toolbox.setVisible(False) self.menu.deleteLater() # delete temporary output files folder = tempFolder() if QDir(folder).exists(): shutil.rmtree(folder, True) self.iface.unregisterMainWindowAction(self.commanderAction) def openCommander(self): if self.commander is None: self.commander = CommanderWindow(self.iface.mainWindow(), self.iface.mapCanvas()) Processing.addAlgListListener(self.commander) self.commander.prepareGui() self.commander.show() def openToolbox(self): if self.toolbox.isVisible(): self.toolbox.hide() else: self.toolbox.show() def openModeler(self): dlg = ModelerDialog() dlg.show() dlg.exec_() if dlg.update: self.toolbox.updateProvider('model') def openResults(self): dlg = ResultsDialog() dlg.show() dlg.exec_() def openHistory(self): dlg = HistoryDialog() dlg.exec_() def openConfig(self): dlg = ConfigDialog(self.toolbox) dlg.exec_() def tr(self, message): return QCoreApplication.translate('ProcessingPlugin', message)
class GdalTools: def __init__(self, iface): if not valid: return # Save reference to the QGIS interface self.iface = iface try: self.QgisVersion = unicode(QGis.QGIS_VERSION_INT) except: self.QgisVersion = unicode(QGis.qgisVersion)[0] if QGis.QGIS_VERSION[0:3] < "1.5": # For i18n support userPluginPath = qgis.utils.home_plugin_path + "/GdalTools" systemPluginPath = qgis.utils.sys_plugin_path + "/GdalTools" overrideLocale = QSettings().value("locale/overrideFlag", False, type=bool) if not overrideLocale: localeFullName = QLocale.system().name() else: localeFullName = QSettings().value("locale/userLocale", "", type=str) if QFileInfo(userPluginPath).exists(): translationPath = userPluginPath + "/i18n/GdalTools_" + localeFullName + ".qm" else: translationPath = systemPluginPath + "/i18n/GdalTools_" + localeFullName + ".qm" self.localePath = translationPath if QFileInfo(self.localePath).exists(): self.translator = QTranslator() self.translator.load(self.localePath) QCoreApplication.installTranslator(self.translator) def initGui(self): if not valid: return if int(self.QgisVersion) < 1: QMessageBox.warning( self.iface.getMainWindow(), "Gdal Tools", QCoreApplication.translate("GdalTools", "QGIS version detected: ") + unicode(self.QgisVersion) + ".xx\n" + QCoreApplication.translate( "GdalTools", "This version of Gdal Tools requires at least QGIS version 1.0.0\nPlugin will not be enabled." )) return None from tools.GdalTools_utils import GdalConfig, LayerRegistry self.GdalVersionNum = GdalConfig.versionNum() LayerRegistry.setIface(self.iface) # find the Raster menu rasterMenu = None menu_bar = self.iface.mainWindow().menuBar() actions = menu_bar.actions() rasterText = QCoreApplication.translate("QgisApp", "&Raster") for a in actions: if a.menu() is not None and a.menu().title() == rasterText: rasterMenu = a.menu() break if rasterMenu is None: # no Raster menu, create and insert it before the Help menu self.menu = QMenu(rasterText, self.iface.mainWindow()) lastAction = actions[len(actions) - 1] menu_bar.insertMenu(lastAction, self.menu) else: self.menu = rasterMenu self.menu.addSeparator() # projections menu (Warp (Reproject), Assign projection) self.projectionsMenu = QMenu( QCoreApplication.translate("GdalTools", "Projections"), self.iface.mainWindow()) self.projectionsMenu.setObjectName("projectionsMenu") self.warp = QAction( QIcon(":/icons/warp.png"), QCoreApplication.translate("GdalTools", "Warp (Reproject)..."), self.iface.mainWindow()) self.warp.setObjectName("warp") self.warp.setStatusTip( QCoreApplication.translate( "GdalTools", "Warp an image into a new coordinate system")) QObject.connect(self.warp, SIGNAL("triggered()"), self.doWarp) self.projection = QAction( QIcon(":icons/projection-add.png"), QCoreApplication.translate("GdalTools", "Assign Projection..."), self.iface.mainWindow()) self.projection.setObjectName("projection") self.projection.setStatusTip( QCoreApplication.translate("GdalTools", "Add projection info to the raster")) QObject.connect(self.projection, SIGNAL("triggered()"), self.doProjection) self.extractProj = QAction( QIcon(":icons/projection-export.png"), QCoreApplication.translate("GdalTools", "Extract Projection..."), self.iface.mainWindow()) self.extractProj.setObjectName("extractProj") self.extractProj.setStatusTip( QCoreApplication.translate( "GdalTools", "Extract projection information from raster(s)")) QObject.connect(self.extractProj, SIGNAL("triggered()"), self.doExtractProj) self.projectionsMenu.addActions( [self.warp, self.projection, self.extractProj]) # conversion menu (Rasterize (Vector to raster), Polygonize (Raster to vector), Translate, RGB to PCT, PCT to RGB) self.conversionMenu = QMenu( QCoreApplication.translate("GdalTools", "Conversion"), self.iface.mainWindow()) self.conversionMenu.setObjectName("conversionMenu") if self.GdalVersionNum >= 1300: self.rasterize = QAction( QIcon(":/icons/rasterize.png"), QCoreApplication.translate("GdalTools", "Rasterize (Vector to Raster)..."), self.iface.mainWindow()) self.rasterize.setObjectName("rasterize") self.rasterize.setStatusTip( QCoreApplication.translate( "GdalTools", "Burns vector geometries into a raster")) QObject.connect(self.rasterize, SIGNAL("triggered()"), self.doRasterize) self.conversionMenu.addAction(self.rasterize) if self.GdalVersionNum >= 1600: self.polygonize = QAction( QIcon(":/icons/polygonize.png"), QCoreApplication.translate("GdalTools", "Polygonize (Raster to Vector)..."), self.iface.mainWindow()) self.polygonize.setObjectName("polygonize") self.polygonize.setStatusTip( QCoreApplication.translate( "GdalTools", "Produces a polygon feature layer from a raster")) QObject.connect(self.polygonize, SIGNAL("triggered()"), self.doPolygonize) self.conversionMenu.addAction(self.polygonize) self.translate = QAction( QIcon(":/icons/translate.png"), QCoreApplication.translate("GdalTools", "Translate (Convert Format)..."), self.iface.mainWindow()) self.translate.setObjectName("translate") self.translate.setStatusTip( QCoreApplication.translate( "GdalTools", "Converts raster data between different formats")) QObject.connect(self.translate, SIGNAL("triggered()"), self.doTranslate) self.paletted = QAction( QIcon(":icons/24-to-8-bits.png"), QCoreApplication.translate("GdalTools", "RGB to PCT..."), self.iface.mainWindow()) self.paletted.setObjectName("paletted") self.paletted.setStatusTip( QCoreApplication.translate( "GdalTools", "Convert a 24bit RGB image to 8bit paletted")) QObject.connect(self.paletted, SIGNAL("triggered()"), self.doPaletted) self.rgb = QAction( QIcon(":icons/8-to-24-bits.png"), QCoreApplication.translate("GdalTools", "PCT to RGB..."), self.iface.mainWindow()) self.rgb.setObjectName("rgb") self.rgb.setStatusTip( QCoreApplication.translate( "GdalTools", "Convert an 8bit paletted image to 24bit RGB")) QObject.connect(self.rgb, SIGNAL("triggered()"), self.doRGB) self.conversionMenu.addActions( [self.translate, self.paletted, self.rgb]) # extraction menu (Clipper, Contour) self.extractionMenu = QMenu( QCoreApplication.translate("GdalTools", "Extraction"), self.iface.mainWindow()) self.extractionMenu.setObjectName("extractionMenu") if self.GdalVersionNum >= 1600: self.contour = QAction( QIcon(":/icons/contour.png"), QCoreApplication.translate("GdalTools", "Contour..."), self.iface.mainWindow()) self.contour.setObjectName("contour") self.contour.setStatusTip( QCoreApplication.translate( "GdalTools", "Builds vector contour lines from a DEM")) QObject.connect(self.contour, SIGNAL("triggered()"), self.doContour) self.extractionMenu.addAction(self.contour) self.clipper = QAction( QIcon(":icons/raster-clip.png"), QCoreApplication.translate("GdalTools", "Clipper..."), self.iface.mainWindow()) self.clipper.setObjectName("clipper") #self.clipper.setStatusTip( QCoreApplication.translate( "GdalTools", "Converts raster data between different formats") ) QObject.connect(self.clipper, SIGNAL("triggered()"), self.doClipper) self.extractionMenu.addActions([self.clipper]) # analysis menu (DEM (Terrain model), Grid (Interpolation), Near black, Proximity (Raster distance), Sieve) self.analysisMenu = QMenu( QCoreApplication.translate("GdalTools", "Analysis"), self.iface.mainWindow()) self.analysisMenu.setObjectName("analysisMenu") if self.GdalVersionNum >= 1600: self.sieve = QAction( QIcon(":/icons/sieve.png"), QCoreApplication.translate("GdalTools", "Sieve..."), self.iface.mainWindow()) self.sieve.setObjectName("sieve") self.sieve.setStatusTip( QCoreApplication.translate("GdalTools", "Removes small raster polygons")) QObject.connect(self.sieve, SIGNAL("triggered()"), self.doSieve) self.analysisMenu.addAction(self.sieve) if self.GdalVersionNum >= 1500: self.nearBlack = QAction( QIcon(":/icons/nearblack.png"), QCoreApplication.translate("GdalTools", "Near Black..."), self.iface.mainWindow()) self.nearBlack.setObjectName("nearBlack") self.nearBlack.setStatusTip( QCoreApplication.translate( "GdalTools", "Convert nearly black/white borders to exact value")) QObject.connect(self.nearBlack, SIGNAL("triggered()"), self.doNearBlack) self.analysisMenu.addAction(self.nearBlack) if self.GdalVersionNum >= 1700: self.fillNodata = QAction( QIcon(":/icons/fillnodata.png"), QCoreApplication.translate("GdalTools", "Fill nodata..."), self.iface.mainWindow()) self.fillNodata.setObjectName("fillNodata") self.fillNodata.setStatusTip( QCoreApplication.translate( "GdalTools", "Fill raster regions by interpolation from edges")) QObject.connect(self.fillNodata, SIGNAL("triggered()"), self.doFillNodata) self.analysisMenu.addAction(self.fillNodata) if self.GdalVersionNum >= 1600: self.proximity = QAction( QIcon(":/icons/proximity.png"), QCoreApplication.translate("GdalTools", "Proximity (Raster Distance)..."), self.iface.mainWindow()) self.proximity.setObjectName("proximity") self.proximity.setStatusTip( QCoreApplication.translate("GdalTools", "Produces a raster proximity map")) QObject.connect(self.proximity, SIGNAL("triggered()"), self.doProximity) self.analysisMenu.addAction(self.proximity) if self.GdalVersionNum >= 1500: self.grid = QAction( QIcon(":/icons/grid.png"), QCoreApplication.translate("GdalTools", "Grid (Interpolation)..."), self.iface.mainWindow()) self.grid.setObjectName("grid") self.grid.setStatusTip( QCoreApplication.translate( "GdalTools", "Create raster from the scattered data")) QObject.connect(self.grid, SIGNAL("triggered()"), self.doGrid) self.analysisMenu.addAction(self.grid) if self.GdalVersionNum >= 1700: self.dem = QAction( QIcon(":icons/dem.png"), QCoreApplication.translate("GdalTools", "DEM (Terrain Models)..."), self.iface.mainWindow()) self.dem.setObjectName("dem") self.dem.setStatusTip( QCoreApplication.translate( "GdalTools", "Tool to analyze and visualize DEMs")) QObject.connect(self.dem, SIGNAL("triggered()"), self.doDEM) self.analysisMenu.addAction(self.dem) #self.analysisMenu.addActions( [ ] ) # miscellaneous menu (Build overviews (Pyramids), Tile index, Information, Merge, Build Virtual Raster (Catalog)) self.miscellaneousMenu = QMenu( QCoreApplication.translate("GdalTools", "Miscellaneous"), self.iface.mainWindow()) self.miscellaneousMenu.setObjectName("miscellaneousMenu") if self.GdalVersionNum >= 1600: self.buildVRT = QAction( QIcon(":/icons/vrt.png"), QCoreApplication.translate( "GdalTools", "Build Virtual Raster (Catalog)..."), self.iface.mainWindow()) self.buildVRT.setObjectName("buildVRT") self.buildVRT.setStatusTip( QCoreApplication.translate( "GdalTools", "Builds a VRT from a list of datasets")) QObject.connect(self.buildVRT, SIGNAL("triggered()"), self.doBuildVRT) self.miscellaneousMenu.addAction(self.buildVRT) self.merge = QAction( QIcon(":/icons/merge.png"), QCoreApplication.translate("GdalTools", "Merge..."), self.iface.mainWindow()) self.merge.setObjectName("merge") self.merge.setStatusTip( QCoreApplication.translate( "GdalTools", "Build a quick mosaic from a set of images")) QObject.connect(self.merge, SIGNAL("triggered()"), self.doMerge) self.info = QAction( QIcon(":/icons/raster-info.png"), QCoreApplication.translate("GdalTools", "Information..."), self.iface.mainWindow()) self.info.setObjectName("info") self.info.setStatusTip( QCoreApplication.translate( "GdalTools", "Lists information about raster dataset")) QObject.connect(self.info, SIGNAL("triggered()"), self.doInfo) self.overview = QAction( QIcon(":icons/raster-overview.png"), QCoreApplication.translate("GdalTools", "Build Overviews (Pyramids)..."), self.iface.mainWindow()) self.overview.setObjectName("overview") self.overview.setStatusTip( QCoreApplication.translate("GdalTools", "Builds or rebuilds overview images")) QObject.connect(self.overview, SIGNAL("triggered()"), self.doOverview) self.tileindex = QAction( QIcon(":icons/tiles.png"), QCoreApplication.translate("GdalTools", "Tile Index..."), self.iface.mainWindow()) self.tileindex.setObjectName("tileindex") self.tileindex.setStatusTip( QCoreApplication.translate( "GdalTools", "Build a shapefile as a raster tileindex")) QObject.connect(self.tileindex, SIGNAL("triggered()"), self.doTileIndex) self.miscellaneousMenu.addActions( [self.merge, self.info, self.overview, self.tileindex]) self.menu.addMenu(self.projectionsMenu) self.menu.addMenu(self.conversionMenu) self.menu.addMenu(self.extractionMenu) if not self.analysisMenu.isEmpty(): self.menu.addMenu(self.analysisMenu) self.menu.addMenu(self.miscellaneousMenu) self.settings = QAction( QCoreApplication.translate("GdalTools", "GdalTools Settings..."), self.iface.mainWindow()) self.settings.setObjectName("settings") self.settings.setStatusTip( QCoreApplication.translate("GdalTools", "Various settings for Gdal Tools")) QObject.connect(self.settings, SIGNAL("triggered()"), self.doSettings) self.menu.addAction(self.settings) def unload(self): if not valid: return pass def doBuildVRT(self): from tools.doBuildVRT import GdalToolsDialog as BuildVRT d = BuildVRT(self.iface) self.runToolDialog(d) def doContour(self): from tools.doContour import GdalToolsDialog as Contour d = Contour(self.iface) self.runToolDialog(d) def doRasterize(self): from tools.doRasterize import GdalToolsDialog as Rasterize d = Rasterize(self.iface) self.runToolDialog(d) def doPolygonize(self): from tools.doPolygonize import GdalToolsDialog as Polygonize d = Polygonize(self.iface) self.runToolDialog(d) def doMerge(self): from tools.doMerge import GdalToolsDialog as Merge d = Merge(self.iface) self.runToolDialog(d) def doSieve(self): from tools.doSieve import GdalToolsDialog as Sieve d = Sieve(self.iface) self.runToolDialog(d) def doProximity(self): from tools.doProximity import GdalToolsDialog as Proximity d = Proximity(self.iface) self.runToolDialog(d) def doNearBlack(self): from tools.doNearBlack import GdalToolsDialog as NearBlack d = NearBlack(self.iface) self.runToolDialog(d) def doFillNodata(self): from tools.doFillNodata import GdalToolsDialog as FillNodata d = FillNodata(self.iface) self.runToolDialog(d) def doWarp(self): from tools.doWarp import GdalToolsDialog as Warp d = Warp(self.iface) self.runToolDialog(d) def doGrid(self): from tools.doGrid import GdalToolsDialog as Grid d = Grid(self.iface) self.runToolDialog(d) def doTranslate(self): from tools.doTranslate import GdalToolsDialog as Translate d = Translate(self.iface) self.runToolDialog(d) def doInfo(self): from tools.doInfo import GdalToolsDialog as Info d = Info(self.iface) self.runToolDialog(d) def doProjection(self): from tools.doProjection import GdalToolsDialog as Projection d = Projection(self.iface) self.runToolDialog(d) def doOverview(self): from tools.doOverview import GdalToolsDialog as Overview d = Overview(self.iface) self.runToolDialog(d) def doClipper(self): from tools.doClipper import GdalToolsDialog as Clipper d = Clipper(self.iface) self.runToolDialog(d) def doPaletted(self): from tools.doRgbPct import GdalToolsDialog as RgbPct d = RgbPct(self.iface) self.runToolDialog(d) def doRGB(self): from tools.doPctRgb import GdalToolsDialog as PctRgb d = PctRgb(self.iface) self.runToolDialog(d) def doTileIndex(self): from tools.doTileIndex import GdalToolsDialog as TileIndex d = TileIndex(self.iface) self.runToolDialog(d) def doExtractProj(self): from tools.doExtractProj import GdalToolsDialog as ExtractProj d = ExtractProj(self.iface) d.exec_() def doDEM(self): from tools.doDEM import GdalToolsDialog as DEM d = DEM(self.iface) self.runToolDialog(d) def runToolDialog(self, dlg): dlg.show_() dlg.exec_() del dlg def doSettings(self): from tools.doSettings import GdalToolsSettingsDialog as Settings d = Settings(self.iface) d.exec_()
class Plugin(object): """The QGIS interface implementation for the InaSAFE plugin. This class acts as the 'glue' between QGIS and our custom logic. It creates a toolbar and menu bar entry and launches the InaSAFE user interface if these are activated. """ def __init__(self, iface): """Class constructor. On instantiation, the plugin instance will be assigned a copy of the QGIS iface object which will allow this plugin to access and manipulate the running QGIS instance that spawned it. :param iface:Quantum GIS iface instance. This instance is automatically passed to the plugin by QGIS when it loads the plugin. :type iface: QGisAppInterface """ # Save reference to the QGIS interface self.iface = iface self.dock_widget = None self.action_import_dialog = None self.action_save_scenario = None self.action_batch_runner = None self.action_shake_converter = None self.action_minimum_needs = None self.action_global_minimum_needs = None self.action_impact_merge_dlg = None self.key_action = None self.action_options = None self.action_keywords_dialog = None self.action_keywords_wizard = None self.action_function_centric_wizard = None self.action_extent_selector = None self.translator = None self.toolbar = None self.actions = [] # list of all QActions we create for InaSAFE self.action_dock = None self.action_toggle_rubberbands = None self.message_bar_item = None # Flag indicating if toolbar should show only common icons or not self.full_toolbar = False # print self.tr('InaSAFE') # For enable/disable the keyword editor icon self.iface.currentLayerChanged.connect(self.layer_changed) # noinspection PyArgumentList def change_i18n(self, new_locale): """Change internationalisation for the plugin. Override the system locale and then see if we can get a valid translation file for whatever locale is effectively being used. :param new_locale: the new locale i.e. 'id', 'af', etc. :type new_locale: str :raises: TranslationLoadException """ os.environ['INASAFE_LANG'] = str(new_locale) LOGGER.debug('%s %s %s' % ( new_locale, QLocale.system().name(), os.environ['INASAFE_LANG'])) root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..')) translation_path = os.path.join( root, 'safe_qgis', 'i18n', 'inasafe_' + str(new_locale) + '.qm') if os.path.exists(translation_path): self.translator = QTranslator() result = self.translator.load(translation_path) if not result: message = 'Failed to load translation for %s' % new_locale raise TranslationLoadError(message) # noinspection PyTypeChecker,PyCallByClass QCoreApplication.installTranslator(self.translator) LOGGER.debug('%s %s' % ( translation_path, os.path.exists(translation_path))) # 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('Plugin', message) def add_action(self, action, add_to_toolbar=True): """Add a toolbar icon to the InaSAFE toolbar. :param action: The action that should be added to the toolbar. :type action: QAction :param add_to_toolbar: Flag indicating whether the action should also be added to the InaSAFE toolbar. Defaults to True. :type add_to_toolbar: bool """ # store in the class list of actions for easy plugin unloading self.actions.append(action) self.iface.addPluginToMenu(self.tr('InaSAFE'), action) if add_to_toolbar: self.toolbar.addAction(action) # noinspection PyPep8Naming def initGui(self): """Gui initialisation procedure (for QGIS plugin api). .. note:: Don't change the name of this method from initGui! This method is called by QGIS and should be used to set up any graphical user interface elements that should appear in QGIS by default (i.e. before the user performs any explicit action with the plugin). """ self.toolbar = self.iface.addToolBar('InaSAFE') self.toolbar.setObjectName('InaSAFEToolBar') # Import dock here as it needs to be imported AFTER i18n is set up from safe.gui.widgets.dock import Dock self.dock_widget = None # -------------------------------------- # Create action for plugin dockable window (show/hide) # -------------------------------------- # pylint: disable=W0201 icon = resources_path('img', 'icons', 'icon.svg') self.action_dock = QAction( QIcon(icon), self.tr('Toggle InaSAFE Dock'), self.iface.mainWindow()) self.action_dock.setObjectName('InaSAFEDockToggle') self.action_dock.setStatusTip(self.tr( 'Show/hide InaSAFE dock widget')) self.action_dock.setWhatsThis(self.tr( 'Show/hide InaSAFE dock widget')) self.action_dock.setCheckable(True) self.action_dock.setChecked(True) self.action_dock.triggered.connect(self.toggle_dock_visibility) self.add_action(self.action_dock) # -------------------------------------- # Create action for keywords editor # -------------------------------------- icon = resources_path('img', 'icons', 'show-keyword-editor.svg') self.action_keywords_dialog = QAction( QIcon(icon), self.tr('InaSAFE Keyword Editor'), self.iface.mainWindow()) self.action_keywords_dialog.setStatusTip(self.tr( 'Open InaSAFE keywords editor')) self.action_keywords_dialog.setWhatsThis(self.tr( 'Open InaSAFE keywords editor')) self.action_keywords_dialog.setEnabled(False) self.action_keywords_dialog.triggered.connect( self.show_keywords_editor) self.add_action( self.action_keywords_dialog, add_to_toolbar=self.full_toolbar) # -------------------------------------- # Create action for keywords creation wizard # ------------------------------------- icon = resources_path('img', 'icons', 'show-keyword-wizard.svg') self.action_keywords_wizard = QAction( QIcon(icon), self.tr('InaSAFE Keywords Creation Wizard'), self.iface.mainWindow()) self.action_keywords_wizard.setStatusTip(self.tr( 'Open InaSAFE keywords creation wizard')) self.action_keywords_wizard.setWhatsThis(self.tr( 'Open InaSAFE keywords creation wizard')) self.action_keywords_wizard.setEnabled(False) self.action_keywords_wizard.triggered.connect( self.show_keywords_wizard) self.add_action(self.action_keywords_wizard) # -------------------------------------- # Create action for IF-centric wizard # -------------------------------------- icon = resources_path('img', 'icons', 'show-wizard.svg') self.action_function_centric_wizard = QAction( QIcon(icon), self.tr('InaSAFE Impact Function Centric Wizard'), self.iface.mainWindow()) self.action_function_centric_wizard.setStatusTip(self.tr( 'Open InaSAFE impact function centric wizard')) self.action_function_centric_wizard.setWhatsThis(self.tr( 'Open InaSAFE impact function centric wizard')) self.action_function_centric_wizard.setEnabled(True) self.action_function_centric_wizard.triggered.connect( self.show_function_centric_wizard) self.add_action(self.action_function_centric_wizard) # -------------------------------------- # Create action for options dialog # -------------------------------------- icon = resources_path('img', 'icons', 'configure-inasafe.svg') self.action_options = QAction( QIcon(icon), self.tr('InaSAFE Options'), self.iface.mainWindow()) self.action_options.setStatusTip(self.tr( 'Open InaSAFE options dialog')) self.action_options.setWhatsThis(self.tr( 'Open InaSAFE options dialog')) self.action_options.triggered.connect(self.show_options) self.add_action(self.action_options, add_to_toolbar=self.full_toolbar) # --------------------------------------- # Create action for minimum needs dialog # --------------------------------------- icon = resources_path('img', 'icons', 'show-minimum-needs.svg') self.action_minimum_needs = QAction( QIcon(icon), self.tr('InaSAFE Minimum Needs Tool'), self.iface.mainWindow()) self.action_minimum_needs.setStatusTip(self.tr( 'Open InaSAFE minimum needs tool')) self.action_minimum_needs.setWhatsThis(self.tr( 'Open InaSAFE minimum needs tool')) self.action_minimum_needs.triggered.connect(self.show_minimum_needs) self.add_action( self.action_minimum_needs, add_to_toolbar=self.full_toolbar) # ---------------------------------------------- # Create action for global minimum needs dialog # ---------------------------------------------- icon = resources_path('img', 'icons', 'show-global-minimum-needs.svg') self.action_global_minimum_needs = QAction( QIcon(icon), self.tr('InaSAFE Global Minimum Needs Configuration'), self.iface.mainWindow()) self.action_global_minimum_needs.setStatusTip(self.tr( 'Open InaSAFE global minimum needs configuration')) self.action_global_minimum_needs.setWhatsThis(self.tr( 'Open InaSAFE global minimum needs configuration')) self.action_global_minimum_needs.triggered.connect( self.show_global_minimum_needs_configuration) self.add_action( self.action_global_minimum_needs, add_to_toolbar=self.full_toolbar) # --------------------------------------- # Create action for converter dialog # --------------------------------------- icon = resources_path('img', 'icons', 'show-converter-tool.svg') self.action_shake_converter = QAction( QIcon(icon), self.tr('InaSAFE Converter'), self.iface.mainWindow()) self.action_shake_converter.setStatusTip(self.tr( 'Open InaSAFE Converter')) self.action_shake_converter.setWhatsThis(self.tr( 'Open InaSAFE Converter')) self.action_shake_converter.triggered.connect( self.show_shakemap_importer) self.add_action( self.action_shake_converter, add_to_toolbar=self.full_toolbar) # --------------------------------------- # Create action for batch runner dialog # --------------------------------------- icon = resources_path('img', 'icons', 'show-batch-runner.svg') self.action_batch_runner = QAction( QIcon(icon), self.tr('InaSAFE Batch Runner'), self.iface.mainWindow()) self.action_batch_runner.setStatusTip(self.tr( 'Open InaSAFE Batch Runner')) self.action_batch_runner.setWhatsThis(self.tr( 'Open InaSAFE Batch Runner')) self.action_batch_runner.triggered.connect(self.show_batch_runner) self.add_action( self.action_batch_runner, add_to_toolbar=self.full_toolbar) # --------------------------------------- # Create action for save scenario dialog # --------------------------------------- icon = resources_path('img', 'icons', 'save-as-scenario.svg') self.action_save_scenario = QAction( QIcon(icon), self.tr('Save current scenario'), self.iface.mainWindow()) message = self.tr('Save current scenario to text file') self.action_save_scenario.setStatusTip(message) self.action_save_scenario.setWhatsThis(message) # noinspection PyUnresolvedReferences self.action_save_scenario.triggered.connect(self.save_scenario) self.add_action( self.action_save_scenario, add_to_toolbar=self.full_toolbar) # -------------------------------------- # Create action for import OSM Dialog # -------------------------------------- icon = resources_path('img', 'icons', 'show-osm-download.svg') self.action_import_dialog = QAction( QIcon(icon), self.tr('InaSAFE OpenStreetMap Downloader'), self.iface.mainWindow()) self.action_import_dialog.setStatusTip(self.tr( 'InaSAFE OpenStreetMap Downloader')) self.action_import_dialog.setWhatsThis(self.tr( 'InaSAFE OpenStreetMap Downloader')) self.action_import_dialog.triggered.connect(self.show_osm_downloader) self.add_action(self.action_import_dialog) # -------------------------------------- # Create action for impact layer merge Dialog # -------------------------------------- icon = resources_path('img', 'icons', 'show-impact-merge.svg') self.action_impact_merge_dlg = QAction( QIcon(icon), self.tr('InaSAFE Impact Layer Merge'), self.iface.mainWindow()) self.action_impact_merge_dlg.setStatusTip(self.tr( 'InaSAFE Impact Layer Merge')) self.action_impact_merge_dlg.setWhatsThis(self.tr( 'InaSAFE Impact Layer Merge')) self.action_impact_merge_dlg.triggered.connect(self.show_impact_merge) self.add_action( self.action_impact_merge_dlg, add_to_toolbar=self.full_toolbar) # -------------------------------------- # create dockwidget and tabify it with the legend # -------------------------------------- self.dock_widget = Dock(self.iface) self.iface.addDockWidget(Qt.RightDockWidgetArea, self.dock_widget) myLegendTab = self.iface.mainWindow().findChild(QApplication, 'Legend') if myLegendTab: self.iface.mainWindow().tabifyDockWidget( myLegendTab, self.dock_widget) self.dock_widget.raise_() # # Hook up a slot for when the dock is hidden using its close button # or view-panels # self.dock_widget.visibilityChanged.connect(self.toggle_inasafe_action) # Also deal with the fact that on start of QGIS dock may already be # hidden. self.action_dock.setChecked(self.dock_widget.isVisible()) # pylint: disable=W0201 # --------------------------------------- # Create action for toggling rubber bands # --------------------------------------- icon = resources_path('img', 'icons', 'toggle-rubber-bands.svg') self.action_toggle_rubberbands = QAction( QIcon(icon), self.tr('Toggle scenario outlines'), self.iface.mainWindow()) message = self.tr('Toggle rubber bands showing scenarion extents.') self.action_toggle_rubberbands.setStatusTip(message) self.action_toggle_rubberbands.setWhatsThis(message) # Set initial state self.action_toggle_rubberbands.setCheckable(True) settings = QSettings() flag = bool(settings.value( 'inasafe/showRubberBands', False, type=bool)) self.action_toggle_rubberbands.setChecked(flag) # noinspection PyUnresolvedReferences self.action_toggle_rubberbands.triggered.connect( self.dock_widget.toggle_rubber_bands) self.add_action(self.action_toggle_rubberbands) # --------------------------------------- # Create action for analysis extent dialog # --------------------------------------- icon = resources_path('img', 'icons', 'set-extents-tool.svg') self.action_extent_selector = QAction( QIcon(icon), self.tr('Set the analysis area for InaSAFE'), self.iface.mainWindow()) self.action_extent_selector.setStatusTip(self.tr( 'Set the analysis area for InaSAFE')) self.action_extent_selector.setWhatsThis(self.tr( 'Set the analysis area for InaSAFE')) self.action_extent_selector.triggered.connect( self.show_extent_selector) self.add_action(self.action_extent_selector) # noinspection PyMethodMayBeStatic def clear_modules(self): """Unload inasafe functions and try to return QGIS to before InaSAFE. """ from safe.impact_functions import core core.unload_plugins() # next lets force remove any inasafe related modules modules = [] for module in sys.modules: if 'inasafe' in module: # Check if it is really one of our modules i.e. exists in the # plugin directory tokens = module.split('.') path = '' for myToken in tokens: path += os.path.sep + myToken parent = os.path.abspath(os.path.join( __file__, os.path.pardir, os.path.pardir)) full_path = os.path.join(parent, path + '.py') if os.path.exists(os.path.abspath(full_path)): LOGGER.debug('Removing: %s' % module) modules.append(module) for module in modules: del (sys.modules[module]) for module in sys.modules: if 'inasafe' in module: print module # Lets also clean up all the path additions that were made package_path = os.path.abspath(os.path.join( os.path.dirname(__file__), os.path.pardir)) LOGGER.debug('Path to remove: %s' % package_path) # We use a list comprehension to ensure duplicate entries are removed LOGGER.debug(sys.path) sys.path = [y for y in sys.path if package_path not in y] LOGGER.debug(sys.path) def unload(self): """GUI breakdown procedure (for QGIS plugin api). .. note:: Don't change the name of this method from unload! This method is called by QGIS and should be used to *remove* any graphical user interface elements that should appear in QGIS. """ # Remove the plugin menu item and icon for myAction in self.actions: self.iface.removePluginMenu(self.tr('InaSAFE'), myAction) self.iface.removeToolBarIcon(myAction) self.iface.mainWindow().removeDockWidget(self.dock_widget) self.iface.mainWindow().removeToolBar(self.toolbar) self.dock_widget.setVisible(False) self.dock_widget.destroy() self.iface.currentLayerChanged.disconnect(self.layer_changed) def toggle_inasafe_action(self, checked): """Check or un-check the toggle inaSAFE toolbar button. This slot is called when the user hides the inaSAFE panel using its close button or using view->panels. :param checked: True if the dock should be shown, otherwise False. :type checked: bool """ self.action_dock.setChecked(checked) # Run method that performs all the real work def toggle_dock_visibility(self): """Show or hide the dock widget.""" if self.dock_widget.isVisible(): self.dock_widget.setVisible(False) else: self.dock_widget.setVisible(True) self.dock_widget.raise_() def show_extent_selector(self): """Show the extent selector widget for defining analysis extents.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.extent_selector_dialog import ExtentSelectorDialog widget = ExtentSelectorDialog( self.iface, self.iface.mainWindow(), extent=self.dock_widget.extent.user_extent, crs=self.dock_widget.extent.user_extent_crs) widget.clear_extent.connect( self.dock_widget.extent.clear_user_analysis_extent) widget.extent_defined.connect( self.dock_widget.define_user_analysis_extent) # Needs to be non modal to support hide -> interact with map -> show widget.show() # non modal def show_minimum_needs(self): """Show the minimum needs dialog.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.minimum_needs.needs_calculator_dialog import ( NeedsCalculatorDialog ) dialog = NeedsCalculatorDialog(self.iface.mainWindow()) dialog.show() # non modal def show_global_minimum_needs_configuration(self): """Show the minimum needs dialog.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.minimum_needs.needs_manager_dialog import ( NeedsManagerDialog) dialog = NeedsManagerDialog(self.iface.mainWindow()) dialog.exec_() # modal def show_impact_merge(self): """Show the impact layer merge dialog.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.impact_merge_dialog import ImpactMergeDialog dialog = ImpactMergeDialog(self.iface.mainWindow()) dialog.exec_() # modal def show_options(self): """Show the options dialog.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.options_dialog import OptionsDialog dialog = OptionsDialog( self.iface, self.dock_widget, self.iface.mainWindow()) dialog.exec_() # modal def show_keywords_editor(self): """Show the keywords editor.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.keywords_dialog import KeywordsDialog # Next block is a fix for #776 if self.iface.activeLayer() is None: return try: keyword_io = KeywordIO() keyword_io.read_keywords(self.iface.activeLayer()) except UnsupportedProviderError: # noinspection PyUnresolvedReferences,PyCallByClass # noinspection PyTypeChecker,PyArgumentList QMessageBox.warning( None, self.tr('Unsupported layer type'), self.tr( 'The layer you have selected cannot be used for ' 'analysis because its data type is unsupported.')) return # End of fix for #776 # Fix for #793 except NoKeywordsFoundError: # we will create them from scratch in the dialog pass # End of fix for #793 # Fix for filtered-layer except InvalidParameterError, e: # noinspection PyTypeChecker,PyTypeChecker,PyArgumentList QMessageBox.warning( None, self.tr('Invalid Layer'), e.message ) return dialog = KeywordsDialog( self.iface.mainWindow(), self.iface, self.dock_widget) dialog.exec_() # modal
class Kortforsyningen: """QGIS Plugin Implementation.""" def __init__(self, iface): # Save reference to the QGIS interface self.iface = iface self.settings = KFSettings() path = QFileInfo(os.path.realpath(__file__)).path() kf_path = path + '/kf/' if not os.path.exists(kf_path): os.makedirs(kf_path) self.settings.addSetting('cache_path', 'string', 'global', kf_path) self.settings.addSetting('kf_qlr_url', 'string', 'global', CONFIG_FILE_URL) self.local_about_file = kf_path + 'about.html' # Categories self.categories = [] self.nodes_by_index = {} self.node_count = 0 # initialize locale locale = QSettings().value('locale/userLocale')[0:2] locale_path = os.path.join( path, 'i18n', '{}.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.networkManager = QNetworkAccessManager() def initGui(self): self.config = Config(self.settings, self.networkManager) self.config.con_loaded.connect(self.createMenu) self.config.kf_con_error.connect(self.show_kf_error) self.config.kf_settings_warning.connect(self.show_kf_settings_warning) self.config.load() def show_kf_error(self, error_message): log_message(error_message) message = u'Check connection and click menu Kortforsyningen->Settings->OK' self.iface.messageBar().pushMessage(error_message, message, level=QgsMessageBar.WARNING, duration=10) def show_kf_settings_warning(self): widget = self.iface.messageBar().createMessage( self.tr('Kortforsyningen'), self.tr(u'Username/Password not set or wrong. Click menu Kortforsyningen->Settings') ) settings_btn = QPushButton(widget) settings_btn.setText(self.tr("Settings")) settings_btn.pressed.connect(self.settings_dialog) widget.layout().addWidget(settings_btn) self.iface.messageBar().pushWidget(widget, QgsMessageBar.WARNING, duration=10) def createMenu(self): self.categories = self.config.get_categories() self.category_lists = self.config.get_category_lists() """Create the menu entries and toolbar icons inside the QGIS GUI.""" icon_path = ':/plugins/Kortforsyningen/settings-cog.png' icon_path_info = ':/plugins/Kortforsyningen/icon_about.png' self.menu = QMenu(self.iface.mainWindow().menuBar()) self.menu.setObjectName(self.tr('Kortforsyningen')) self.menu.setTitle(self.tr('Kortforsyningen')) searchable_layers = [] # Add menu object for each theme self.category_menus = [] kf_helper = lambda _id: lambda: self.open_kf_node(_id) local_helper = lambda _id: lambda: self.open_local_node(_id) for category_list in self.category_lists: list_categorymenus = [] for category in category_list: category_menu = QMenu() category_menu.setTitle(category['name']) for selectable in category['selectables']: q_action = QAction( selectable['name'], self.iface.mainWindow() ) if selectable['source'] == 'kf': q_action.triggered.connect( kf_helper(selectable['id']) ) else: q_action.triggered.connect( local_helper(selectable['id']) ) category_menu.addAction(q_action) searchable_layers.append( { 'title': selectable['name'], 'category': category['name'], 'action': q_action } ) list_categorymenus.append(category_menu) self.category_menus.append(category_menu) for category_menukuf in list_categorymenus: self.menu.addMenu(category_menukuf) self.menu.addSeparator() self.septimasearchprovider = MySeptimaSearchProvider(self, searchable_layers) # Add settings self.settings_menu = QAction( QIcon(icon_path), self.tr('Settings'), self.iface.mainWindow() ) self.settings_menu.setObjectName(self.tr('Settings')) self.settings_menu.triggered.connect(self.settings_dialog) self.menu.addAction(self.settings_menu) # Add about self.about_menu = QAction( QIcon(icon_path_info), self.tr('About the plugin'), self.iface.mainWindow() ) self.about_menu.setObjectName(self.tr('About the plugin')) self.about_menu.triggered.connect(self.about_dialog) self.menu.addAction(self.about_menu) menu_bar = self.iface.mainWindow().menuBar() menu_bar.insertMenu( self.iface.firstRightStandardMenu().menuAction(), self.menu ) def open_local_node(self, id): node = self.config.get_local_maplayer_node(id) self.open_node(node, id) def open_kf_node(self, id): node = self.config.get_kf_maplayer_node(id) layer = self.open_node(node, id) def open_node(self, node, id): QgsProject.instance().read(node) layer = QgsMapLayerRegistry.instance().mapLayer(id) if layer: self.iface.legendInterface().refreshLayerSymbology(layer) #self.iface.legendInterface().moveLayer(layer, 0) self.iface.legendInterface().refreshLayerSymbology(layer) return layer else: return None # noinspection PyMethodMayBeStatic def tr(self, message): # noinspection PyTypeChecker,PyArgumentList,PyCallByClass return QCoreApplication.translate('Kortforsyningen', message) def settings_dialog(self): dlg = KFSettingsDialog(self.settings) dlg.setWidgetsFromValues() dlg.show() result = dlg.exec_() if result == 1: del dlg self.reloadMenu() def about_dialog(self): if 'KFAboutDialog' in globals(): dlg = KFAboutDialog() dlg.webView.setUrl(QUrl(ABOUT_FILE_URL)) dlg.webView.urlChanged dlg.show() result = dlg.exec_() if result == 1: del dlg else: dlg = KFAlternativeAboutDialog() dlg.buttonBox.accepted.connect(dlg.accept) dlg.buttonBox.rejected.connect(dlg.reject) dlg.textBrowser.setHtml(self.tr('<p>QGIS is having trouble showing the content of this dialog. Would you like to open it in an external browser window?</p>')) dlg.show() result = dlg.exec_() if result: webbrowser.open(ABOUT_FILE_URL) def unload(self): # Remove settings if user not asked to keep them if self.settings.value('remember_settings') is False: self.settings.setValue('username', '') self.settings.setValue('password', '') self.clearMenu(); def reloadMenu(self): self.clearMenu() self.config.load() #self.createMenu() def clearMenu(self): # Remove the submenus for submenu in self.category_menus: if submenu: submenu.deleteLater() # remove the menu bar item if self.menu: self.menu.deleteLater()
class ReportEditorApp(FreeseerApp): ''' Freeseer report editor main gui class ''' def __init__(self, config, db): FreeseerApp.__init__(self) self.config = config self.db = db icon = QIcon() icon.addPixmap(QPixmap(_fromUtf8(":/freeseer/logo.png")), QIcon.Normal, QIcon.Off) self.setWindowIcon(icon) self.resize(960, 400) self.mainWidget = QWidget() self.mainLayout = QHBoxLayout() self.mainWidget.setLayout(self.mainLayout) self.setCentralWidget(self.mainWidget) self.editorWidget = ReportEditorWidget() self.editorWidget.editor.setColumnHidden(5, True) self.mainLayout.addWidget(self.editorWidget) # Initialize geometry, to be used for restoring window positioning. self.geometry = None # # Setup Menubar # self.actionExportCsv = QAction(self) self.actionExportCsv.setObjectName(_fromUtf8("actionExportCsv")) # Actions self.menuFile.insertAction(self.actionExit, self.actionExportCsv) # --- End Menubar # # Report Editor Connections # # Editor Widget self.connect(self.editorWidget.removeButton, SIGNAL('clicked()'), self.remove_talk) self.connect(self.editorWidget.clearButton, SIGNAL('clicked()'), self.confirm_reset) self.connect(self.editorWidget.closeButton, SIGNAL('clicked()'), self.close) # Main Window Connections self.connect(self.actionExportCsv, SIGNAL('triggered()'), self.export_reports_to_csv) self.connect(self.editorWidget.editor, SIGNAL('clicked (const QModelIndex&)'), self.editorSelectionChanged) # Load default language actions = self.menuLanguage.actions() for action in actions: if action.data().toString() == self.config.default_language: action.setChecked(True) self.translate(action) break self.load_failures_model() self.editorWidget.editor.resizeColumnsToContents() self.editorWidget.editor.resizeRowsToContents() ### ### Translation ### def retranslate(self): self.setWindowTitle(self.app.translate("ReportEditorApp", "Freeseer Report Editor")) # # Reusable Strings # self.confirmDBClearTitleString = self.app.translate("ReportEditorApp", "Clear Database") self.confirmDBClearQuestionString = self.app.translate("ReportEditorApp", "Are you sure you want to clear the DB?") self.selectFileString = self.app.translate("ReportEditorApp", "Select File") # --- End Reusable Strings # # Menubar # self.actionExportCsv.setText(self.app.translate("ReportEditorApp", "&Export to CSV")) # --- End Menubar # # EditorWidget # self.editorWidget.removeButton.setText(self.app.translate("ReportEditorApp", "Remove")) self.editorWidget.clearButton.setText(self.app.translate("ReportEditorApp", "Clear")) self.editorWidget.closeButton.setText(self.app.translate("ReportEditorApp", "Close")) self.editorWidget.titleLabel.setText(self.app.translate("ReportEditorApp", "Title:")) self.editorWidget.speakerLabel.setText(self.app.translate("ReportEditorApp", "Speaker:")) self.editorWidget.descriptionLabel.setText(self.app.translate("ReportEditorApp", "Description:")) self.editorWidget.levelLabel.setText(self.app.translate("ReportEditorApp", "Level:")) self.editorWidget.eventLabel.setText(self.app.translate("ReportEditorApp", "Event:")) self.editorWidget.roomLabel.setText(self.app.translate("ReportEditorApp", "Room:")) self.editorWidget.timeLabel.setText(self.app.translate("ReportEditorApp", "Time:")) # --- End EditorWidget def load_failures_model(self): # Load Presentation Model self.failureModel = self.db.get_failures_model() editor = self.editorWidget.editor editor.setModel(self.failureModel) editor.horizontalHeader().setResizeMode(QHeaderView.Stretch) def hide_add_talk_widget(self): self.editorWidget.setHidden(False) self.addTalkWidget.setHidden(True) def add_talk(self): date = self.addTalkWidget.dateEdit.date() time = self.addTalkWidget.timeEdit.time() datetime = QDateTime(date, time) presentation = Presentation(unicode(self.addTalkWidget.titleLineEdit.text()), unicode(self.addTalkWidget.presenterLineEdit.text()), "", # description "", # level unicode(self.addTalkWidget.eventLineEdit.text()), unicode(self.addTalkWidget.roomLineEdit.text()), unicode(datetime.toString())) # Do not add talks if they are empty strings if (len(presentation.title) == 0): return self.db.insert_presentation(presentation) # cleanup self.addTalkWidget.titleLineEdit.clear() self.addTalkWidget.presenterLineEdit.clear() self.failureModel.select() self.hide_add_talk_widget() def remove_talk(self): try: row_clicked = self.editorWidget.editor.currentIndex().row() except: return self.failureModel.removeRow(row_clicked) self.failureModel.select() def reset(self): self.db.clear_report_db() self.failureModel.select() def confirm_reset(self): """ Presents a confirmation dialog to ask the user if they are sure they wish to remove the report database. If Yes call the reset() function. """ confirm = QMessageBox.question(self, self.confirmDBClearTitleString, self.confirmDBClearQuestionString, QMessageBox.Yes | QMessageBox.No, QMessageBox.No) if confirm == QMessageBox.Yes: self.reset() def closeEvent(self, event): log.info('Exiting report editor...') self.geometry = self.saveGeometry() event.accept() def editorSelectionChanged(self, index): talkId = self.failureModel.record(index.row()).value(0).toString() self.updatePresentationInfo(talkId) def updatePresentationInfo(self, talkId): p = self.db.get_presentation(talkId) if p is not None: self.editorWidget.titleLabel2.setText(p.title) self.editorWidget.speakerLabel2.setText(p.speaker) self.editorWidget.descriptionLabel2.setText(p.description) self.editorWidget.levelLabel2.setText(p.level) self.editorWidget.eventLabel2.setText(p.event) self.editorWidget.roomLabel2.setText(p.room) self.editorWidget.timeLabel2.setText(p.time) else: self.editorWidget.titleLabel2.setText("Talk not found") self.editorWidget.speakerLabel2.setText("Talk not found") self.editorWidget.descriptionLabel2.setText("Talk not found") self.editorWidget.levelLabel2.setText("Talk not found") self.editorWidget.eventLabel2.setText("Talk not found") self.editorWidget.roomLabel2.setText("Talk not found") self.editorWidget.timeLabel2.setText("Talk not found") def export_reports_to_csv(self): fname = QFileDialog.getSaveFileName(self, self.selectFileString, "", "*.csv") if fname: self.db.export_reports_to_csv(fname)
class ReportEditorApp(FreeseerApp): ''' Freeseer report editor main gui class ''' def __init__(self, config, db): FreeseerApp.__init__(self) self.config = config self.db = db icon = QIcon() icon.addPixmap(QPixmap(_fromUtf8(":/freeseer/logo.png")), QIcon.Normal, QIcon.Off) self.setWindowIcon(icon) self.resize(960, 400) self.mainWidget = QWidget() self.mainLayout = QHBoxLayout() self.mainWidget.setLayout(self.mainLayout) self.setCentralWidget(self.mainWidget) self.editorWidget = ReportEditorWidget() self.editorWidget.editor.setColumnHidden(5, True) self.mainLayout.addWidget(self.editorWidget) # Initialize geometry, to be used for restoring window positioning. self.geometry = None # # Setup Menubar # self.actionExportCsv = QAction(self) self.actionExportCsv.setObjectName(_fromUtf8("actionExportCsv")) # Actions self.menuFile.insertAction(self.actionExit, self.actionExportCsv) # --- End Menubar # # Report Editor Connections # # Editor Widget self.connect(self.editorWidget.removeButton, SIGNAL('clicked()'), self.remove_talk) self.connect(self.editorWidget.clearButton, SIGNAL('clicked()'), self.confirm_reset) self.connect(self.editorWidget.closeButton, SIGNAL('clicked()'), self.close) # Main Window Connections self.connect(self.actionExportCsv, SIGNAL('triggered()'), self.export_reports_to_csv) self.connect(self.editorWidget.editor, SIGNAL('clicked (const QModelIndex&)'), self.editorSelectionChanged) # Load default language actions = self.menuLanguage.actions() for action in actions: if action.data().toString() == self.config.default_language: action.setChecked(True) self.translate(action) break self.load_failures_model() self.editorWidget.editor.resizeColumnsToContents() self.editorWidget.editor.resizeRowsToContents() ### ### Translation ### def retranslate(self): self.setWindowTitle( self.app.translate("ReportEditorApp", "Freeseer Report Editor")) # # Reusable Strings # self.confirmDBClearTitleString = self.app.translate( "ReportEditorApp", "Clear Database") self.confirmDBClearQuestionString = self.app.translate( "ReportEditorApp", "Are you sure you want to clear the DB?") self.selectFileString = self.app.translate("ReportEditorApp", "Select File") # --- End Reusable Strings # # Menubar # self.actionExportCsv.setText( self.app.translate("ReportEditorApp", "&Export to CSV")) # --- End Menubar # # EditorWidget # self.editorWidget.removeButton.setText( self.app.translate("ReportEditorApp", "Remove")) self.editorWidget.clearButton.setText( self.app.translate("ReportEditorApp", "Clear")) self.editorWidget.closeButton.setText( self.app.translate("ReportEditorApp", "Close")) self.editorWidget.titleLabel.setText( self.app.translate("ReportEditorApp", "Title:")) self.editorWidget.speakerLabel.setText( self.app.translate("ReportEditorApp", "Speaker:")) self.editorWidget.descriptionLabel.setText( self.app.translate("ReportEditorApp", "Description:")) self.editorWidget.levelLabel.setText( self.app.translate("ReportEditorApp", "Level:")) self.editorWidget.eventLabel.setText( self.app.translate("ReportEditorApp", "Event:")) self.editorWidget.roomLabel.setText( self.app.translate("ReportEditorApp", "Room:")) self.editorWidget.startTimeLabel.setText( self.app.translate("ReportEditorApp", "Start Time:")) self.editorWidget.endTimeLabel.setText( self.app.translate("ReportEditorApp", "End Time:")) # --- End EditorWidget def load_failures_model(self): # Load Presentation Model self.failureModel = self.db.get_failures_model() editor = self.editorWidget.editor editor.setModel(self.failureModel) editor.horizontalHeader().setResizeMode(QHeaderView.Stretch) def hide_add_talk_widget(self): self.editorWidget.setHidden(False) self.addTalkWidget.setHidden(True) def add_talk(self): date = self.addTalkWidget.dateEdit.date() startTime = self.addTalkWidget.startTimeEdit.time() datetime = QDateTime(date, startTime) # original "time" is now "startTime" presentation = Presentation( unicode(self.addTalkWidget.titleLineEdit.text()), unicode(self.addTalkWidget.presenterLineEdit.text()), "", # description "", # level unicode(self.addTalkWidget.eventLineEdit.text()), unicode(self.addTalkWidget.roomLineEdit.text()), unicode(datetime.toString()), unicode(self.addTalkWidget.endTimeEdit.text())) # Do not add talks if they are empty strings if (len(presentation.title) == 0): return self.db.insert_presentation(presentation) # cleanup self.addTalkWidget.titleLineEdit.clear() self.addTalkWidget.presenterLineEdit.clear() self.failureModel.select() self.hide_add_talk_widget() def remove_talk(self): try: row_clicked = self.editorWidget.editor.currentIndex().row() except: return self.failureModel.removeRow(row_clicked) self.failureModel.select() def reset(self): self.db.clear_report_db() self.failureModel.select() def confirm_reset(self): """ Presents a confirmation dialog to ask the user if they are sure they wish to remove the report database. If Yes call the reset() function. """ confirm = QMessageBox.question(self, self.confirmDBClearTitleString, self.confirmDBClearQuestionString, QMessageBox.Yes | QMessageBox.No, QMessageBox.No) if confirm == QMessageBox.Yes: self.reset() def closeEvent(self, event): log.info('Exiting report editor...') self.geometry = self.saveGeometry() event.accept() def editorSelectionChanged(self, index): talkId = self.failureModel.record(index.row()).value(0).toString() self.updatePresentationInfo(talkId) def updatePresentationInfo(self, talkId): p = self.db.get_presentation(talkId) if p is not None: self.editorWidget.titleLabel2.setText(p.title) self.editorWidget.speakerLabel2.setText(p.speaker) self.editorWidget.descriptionLabel2.setText(p.description) self.editorWidget.levelLabel2.setText(p.level) self.editorWidget.eventLabel2.setText(p.event) self.editorWidget.roomLabel2.setText(p.room) self.editorWidget.startTimeLabel2.setText(p.startTime) self.editorWidget.endTimeLabel2.setText(p.endTime) else: self.editorWidget.titleLabel2.setText("Talk not found") self.editorWidget.speakerLabel2.setText("Talk not found") self.editorWidget.descriptionLabel2.setText("Talk not found") self.editorWidget.levelLabel2.setText("Talk not found") self.editorWidget.eventLabel2.setText("Talk not found") self.editorWidget.roomLabel2.setText("Talk not found") self.editorWidget.startTimeLabel2.setText("Talk not found") self.editorWidget.endTimeLabel2.setText("Talk not found") def export_reports_to_csv(self): fname = QFileDialog.getSaveFileName(self, self.selectFileString, "", "*.csv") if fname: self.db.export_reports_to_csv(fname)
class Qgis2threejs: def __init__(self, iface): # Save reference to the QGIS interface self.iface = iface # initialize plugin directory self.plugin_dir = os.path.dirname(QFile.decodeName(__file__)) # initialize locale #locale = QSettings().value("locale/userLocale")[0:2] #localePath = os.path.join(self.plugin_dir, 'i18n', 'qgis2threejs_{0}.qm'.format(locale)) # if os.path.exists(localePath): # self.translator = QTranslator() # self.translator.load(localePath) # if qVersion() > '4.3.3': # QCoreApplication.installTranslator(self.translator) self.objectTypeManager = None self.pluginManager = None self.exportSettings = {} self.lastTreeItemData = None self.settingsFilePath = None def initGui(self): # Create action that will start plugin configuration icon = QIcon(os.path.join(self.plugin_dir, "icon.png")) self.action = QAction(icon, u"Qgis2threejs", self.iface.mainWindow()) self.action.setObjectName("Qgis2threejs") self.settingAction = QAction(u"Settings", self.iface.mainWindow()) self.settingAction.setObjectName("Qgis2threejsSettings") # connect the action to the run method self.action.triggered.connect(self.run) self.settingAction.triggered.connect(self.setting) # Add toolbar button and web menu items self.iface.addWebToolBarIcon(self.action) self.iface.addPluginToWebMenu(u"Qgis2threejs", self.action) self.iface.addPluginToWebMenu(u"Qgis2threejs", self.settingAction) def unload(self): # Remove the web menu items and icon self.iface.removeWebToolBarIcon(self.action) self.iface.removePluginWebMenu(u"Qgis2threejs", self.action) self.iface.removePluginWebMenu(u"Qgis2threejs", self.settingAction) # remove temporary output directory removeTemporaryOutputDir() def run(self): from vectorobject import ObjectTypeManager from pluginmanager import PluginManager from qgis2threejsdialog import Qgis2threejsDialog if self.objectTypeManager is None: self.objectTypeManager = ObjectTypeManager() if self.pluginManager is None: self.pluginManager = PluginManager() # restore export settings proj_path = QgsProject.instance().fileName() settingsFilePath = proj_path + ".qto3settings" if proj_path else None if not self.exportSettings or settingsFilePath != self.settingsFilePath: if settingsFilePath and os.path.exists(settingsFilePath): self.loadExportSettings(settingsFilePath) logMessage(u"Restored export settings of this project: {0}".format( os.path.basename(proj_path))) # QgsProject.instance().title() dialog = Qgis2threejsDialog( self.iface, self.objectTypeManager, self.pluginManager, self.exportSettings, self.lastTreeItemData) # show dialog dialog.show() ret = dialog.exec_() self.exportSettings = dialog.settings(True) item = dialog.ui.treeWidget.currentItem() self.lastTreeItemData = item.data(0, Qt.UserRole) if item else None # if export succeeded, save export settings in the directory that # project file exists if ret and settingsFilePath: self.saveExportSettings(settingsFilePath) self.settingsFilePath = settingsFilePath 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 loadExportSettings(self, filename): import json with open(filename) as f: self.exportSettings = json.load(f) def saveExportSettings(self, filename): import codecs import json try: with codecs.open(filename, "w", "UTF-8") as f: json.dump( self.exportSettings, f, ensure_ascii=False, indent=2, sort_keys=True) return True except Exception as e: logMessage("Failed to save export settings: " + str(e)) return False
class TalkEditorApp(FreeseerApp): '''Freeseer talk database editor main gui class''' def __init__(self, config, db): super(TalkEditorApp, self).__init__(config) self.db = db icon = QIcon() icon.addPixmap(QPixmap(':/freeseer/logo.png'), QIcon.Normal, QIcon.Off) self.setWindowIcon(icon) self.resize(960, 600) # # Setup Layout # self.mainWidget = QWidget() self.mainLayout = QVBoxLayout() self.mainWidget.setLayout(self.mainLayout) self.setCentralWidget(self.mainWidget) self.mainLayout.setAlignment(Qt.AlignTop) # Add custom widgets self.commandButtons = CommandButtons() self.tableView = QTableView() self.tableView.setSortingEnabled(True) self.tableView.setSelectionBehavior(QAbstractItemView.SelectRows) self.talkDetailsWidget = TalkDetailsWidget() self.importTalksWidget = ImportTalksWidget() self.newTalkWidget = NewTalkWidget() self.mainLayout.addWidget(self.importTalksWidget) #self.mainLayout.addLayout(self.titleLayout) self.mainLayout.addWidget(self.commandButtons) self.mainLayout.addWidget(self.tableView) self.mainLayout.addWidget(self.talkDetailsWidget) self.mainLayout.addWidget(self.importTalksWidget) # --- End Layout # Keep track of index of the most recently selected talk self.currentTalkIndex = QPersistentModelIndex() # Prompt user to "Continue Editing", "Discard Changes" or "Save Changes" self.savePromptBox = QMessageBox() self.savePromptBox.setWindowTitle("Unsaved Changes Exist") self.savePromptBox.setIcon(QMessageBox.Information) self.savePromptBox.setText( "The talk you were editing has unsaved changes.") self.continueButton = self.savePromptBox.addButton( "Continue Editing", QMessageBox.RejectRole) self.discardButton = self.savePromptBox.addButton( "Discard Changes", QMessageBox.DestructiveRole) self.saveButton = self.savePromptBox.addButton("Save Changes", QMessageBox.AcceptRole) self.savePromptBox.setDefaultButton(self.saveButton) # Initialize geometry, to be used for restoring window positioning. self.geometry = None # # Setup Menubar # self.actionExportCsv = QAction(self) self.actionExportCsv.setObjectName('actionExportCsv') self.actionRemoveAll = QAction(self) self.actionRemoveAll.setObjectName('actionRemoveAll') # Actions self.menuFile.insertAction(self.actionExit, self.actionExportCsv) self.menuFile.insertAction(self.actionExit, self.actionRemoveAll) # --- End Menubar # # TableView Connections # self.connect(self.tableView, SIGNAL('activated(const QModelIndex)'), self.click_talk) self.connect(self.tableView, SIGNAL('selected(const QModelIndex)'), self.click_talk) self.connect(self.tableView, SIGNAL('clicked(const QModelIndex)'), self.click_talk) # Import Widget self.connect(self.importTalksWidget.csvRadioButton, SIGNAL('toggled(bool)'), self.toggle_import) self.connect(self.importTalksWidget.importButton, SIGNAL('clicked()'), self.import_talks) self.connect(self.importTalksWidget.cancelButton, SIGNAL('clicked()'), self.hide_import_talks_widget) self.importTalksWidget.setHidden(True) self.connect(self.importTalksWidget.csvFileSelectButton, SIGNAL('clicked()'), self.csv_file_select) self.connect(self.importTalksWidget.csvLineEdit, SIGNAL('returnPressed()'), self.importTalksWidget.importButton.click) self.connect(self.importTalksWidget.rssLineEdit, SIGNAL('returnPressed()'), self.importTalksWidget.importButton.click) self.connect(self.actionExportCsv, SIGNAL('triggered()'), self.export_talks_to_csv) self.connect(self.actionRemoveAll, SIGNAL('triggered()'), self.confirm_reset) # Command Buttons self.connect(self.commandButtons.addButton, SIGNAL('clicked()'), self.click_add_button) self.connect(self.commandButtons.removeButton, SIGNAL('clicked()'), self.remove_talk) self.connect(self.commandButtons.removeAllButton, SIGNAL('clicked()'), self.confirm_reset) self.connect(self.commandButtons.importButton, SIGNAL('clicked()'), self.show_import_talks_widget) self.connect(self.commandButtons.exportButton, SIGNAL('clicked()'), self.export_talks_to_csv) self.connect(self.commandButtons.searchButton, SIGNAL('clicked()'), self.search_talks) self.connect(self.commandButtons.searchLineEdit, SIGNAL('textEdited(QString)'), self.search_talks) self.connect(self.commandButtons.searchLineEdit, SIGNAL('returnPressed()'), self.search_talks) # Talk Details Buttons self.connect(self.talkDetailsWidget.saveButton, SIGNAL('clicked()'), self.update_talk) # Talk Details Widget self.connect(self.talkDetailsWidget.titleLineEdit, SIGNAL('textEdited(const QString)'), self.enable_save) self.connect(self.talkDetailsWidget.presenterLineEdit, SIGNAL('textEdited(const QString)'), self.enable_save) self.connect(self.talkDetailsWidget.categoryLineEdit, SIGNAL('textEdited(const QString)'), self.enable_save) self.connect(self.talkDetailsWidget.eventLineEdit, SIGNAL('textEdited(const QString)'), self.enable_save) self.connect(self.talkDetailsWidget.roomLineEdit, SIGNAL('textEdited(const QString)'), self.enable_save) self.connect(self.talkDetailsWidget.descriptionTextEdit, SIGNAL('modificationChanged(bool)'), self.enable_save) self.connect(self.talkDetailsWidget.dateEdit, SIGNAL('dateChanged(const QDate)'), self.enable_save) self.connect(self.talkDetailsWidget.startTimeEdit, SIGNAL('timeChanged(const QTime)'), self.enable_save) self.connect(self.talkDetailsWidget.endTimeEdit, SIGNAL('timeChanged(const QTime)'), self.enable_save) # New Talk Widget self.newTalkWidget.connect(self.newTalkWidget.addButton, SIGNAL('clicked()'), self.add_talk) self.newTalkWidget.connect(self.newTalkWidget.cancelButton, SIGNAL('clicked()'), self.newTalkWidget.reject) # Load default language actions = self.menuLanguage.actions() for action in actions: if action.data().toString() == self.config.default_language: action.setChecked(True) self.translate(action) break # Load Talk Database self.load_presentations_model() # Setup Autocompletion self.update_autocomplete_fields() self.talkDetailsWidget.saveButton.setEnabled(False) # Select first item #self.tableView.setCurrentIndex(self.proxy.index(0,0)) #self.talk_selected(self.proxy.index(0,0)) # # Translation # def retranslate(self): self.setWindowTitle( self.app.translate("TalkEditorApp", "Freeseer Talk Editor")) # # Reusable Strings # self.confirmDBClearTitleString = self.app.translate( "TalkEditorApp", "Remove All Talks from Database") self.confirmDBClearQuestionString = self.app.translate( "TalkEditorApp", "Are you sure you want to clear the DB?") self.confirmTalkDetailsClearTitleString = self.app.translate( "TalkEditorApp", "Unsaved Data") self.confirmTalkDetailsClearQuestionString = self.app.translate( "TalkEditorApp", "Unsaved talk details will be lost. Continue?") # --- End Reusable Strings # # Menubar # self.actionExportCsv.setText( self.app.translate("TalkEditorApp", "&Export to CSV")) self.actionRemoveAll.setText( self.app.translate("TalkEditorApp", "&Remove All Talks")) # --- End Menubar # # TalkDetailsWidget # self.talkDetailsWidget.titleLabel.setText( self.app.translate("TalkEditorApp", "Title")) self.talkDetailsWidget.presenterLabel.setText( self.app.translate("TalkEditorApp", "Presenter")) self.talkDetailsWidget.categoryLabel.setText( self.app.translate("TalkEditorApp", "Category")) self.talkDetailsWidget.eventLabel.setText( self.app.translate("TalkEditorApp", "Event")) self.talkDetailsWidget.roomLabel.setText( self.app.translate("TalkEditorApp", "Room")) self.talkDetailsWidget.dateLabel.setText( self.app.translate("TalkEditorApp", "Date")) self.talkDetailsWidget.startTimeLabel.setText( self.app.translate("TalkEditorApp", "Start Time")) self.talkDetailsWidget.endTimeLabel.setText( self.app.translate("TalkEditorApp", "End Time")) # --- End TalkDetailsWidget # # Import Talks Widget Translations # self.importTalksWidget.rssRadioButton.setText( self.app.translate("TalkEditorApp", "RSS URL")) self.importTalksWidget.csvRadioButton.setText( self.app.translate("TalkEditorApp", "CSV File")) self.importTalksWidget.importButton.setText( self.app.translate("TalkEditorApp", "Import")) # --- End Talks Widget Translations # # Command Button Translations\ # self.commandButtons.importButton.setText( self.app.translate("TalkEditorApp", "Import")) self.commandButtons.exportButton.setText( self.app.translate("TalkEditorApp", "Export")) self.commandButtons.addButton.setText( self.app.translate("TalkEditorApp", "Add New Talk")) self.commandButtons.removeButton.setText( self.app.translate("TalkEditorApp", "Remove")) self.commandButtons.removeAllButton.setText( self.app.translate("TalkEditorApp", "Remove All")) # --- End Command Butotn Translations # # Search Widget Translations # self.commandButtons.searchButton.setText( self.app.translate("TalkEditorApp", "Search")) # --- End Command Button Translations def load_presentations_model(self): # Load Presentation Model self.presentationModel = self.db.get_presentations_model() self.proxy = QSortFilterProxyModel() self.proxy.setSourceModel(self.presentationModel) self.tableView.setModel(self.proxy) self.proxy.setFilterCaseSensitivity(Qt.CaseInsensitive) # Fill table whitespace. self.tableView.horizontalHeader().setStretchLastSection(False) self.tableView.horizontalHeader().setResizeMode(1, QHeaderView.Stretch) # Hide the ID field self.tableView.setColumnHidden(0, True) # Map data to widgets self.mapper = QDataWidgetMapper() self.mapper.setModel(self.proxy) self.mapper.setSubmitPolicy(QDataWidgetMapper.ManualSubmit) self.mapper.addMapping(self.talkDetailsWidget.titleLineEdit, 1) self.mapper.addMapping(self.talkDetailsWidget.presenterLineEdit, 2) self.mapper.addMapping(self.talkDetailsWidget.categoryLineEdit, 4) self.mapper.addMapping(self.talkDetailsWidget.eventLineEdit, 5) self.mapper.addMapping(self.talkDetailsWidget.roomLineEdit, 6) self.mapper.addMapping(self.talkDetailsWidget.descriptionTextEdit, 3) self.mapper.addMapping(self.talkDetailsWidget.dateEdit, 7) self.mapper.addMapping(self.talkDetailsWidget.startTimeEdit, 8) self.mapper.addMapping(self.talkDetailsWidget.endTimeEdit, 9) # Load StringLists self.titleList = QStringList(self.db.get_string_list("Title")) #self.speakerList = QStringList(self.db.get_speaker_list()) #self.categoryList = QStringList(self.db.get_category_list()) #self.eventList = QStringList(self.db.get_event_list()) #self.roomList = QStringList(self.db.get_room_list()) #Disble input self.talkDetailsWidget.disable_input_fields() def search_talks(self): # The default value is 0. If the value is -1, the keys will be read from all columns. self.proxy.setFilterKeyColumn(-1) self.proxy.setFilterFixedString( self.commandButtons.searchLineEdit.text()) def show_save_prompt(self): """Prompts the user to save or discard changes, or continue editing.""" self.savePromptBox.exec_() self.savePromptBox.setDefaultButton(self.saveButton) return self.savePromptBox.clickedButton() def click_talk(self, model): """Warns user if there are unsaved changes, and selects talk clicked by the user.""" log.info("Selecting row %d", model.row()) modelRow = model.row() if self.unsaved_details_exist(): log.info("Unsaved changes exist in row %d", self.currentTalkIndex.row()) confirm = self.show_save_prompt() if confirm == self.saveButton: log.info("Saving changes in row %d...", self.currentTalkIndex.row()) self.tableView.selectRow(self.currentTalkIndex.row()) self.update_talk() newModel = self.tableView.currentIndex().sibling(modelRow, 0) self.select_talk(newModel) elif confirm == self.discardButton: log.info("Discarding changes in row %d...", self.currentTalkIndex.row()) self.talk_selected(model) else: log.info("Continue editing row %d", self.currentTalkIndex.row()) self.tableView.selectRow(self.currentTalkIndex.row()) else: self.talk_selected(model) def click_add_button(self): """Warns user if there are unsaved changes, and shows the New Talk window.""" if self.unsaved_details_exist(): log.info("Unsaved changes exist in row %d", self.currentTalkIndex.row()) confirm = self.show_save_prompt() if confirm == self.saveButton: log.info("Saving changes in row %d...", self.currentTalkIndex.row()) self.update_talk() self.show_new_talk_popup() elif confirm == self.discardButton: log.info("Discarding changes in row %d...", self.currentTalkIndex.row()) # Ensure that changes are discarded self.talk_selected(self.currentTalkIndex) self.show_new_talk_popup() else: log.info("Continue editing row %d", self.currentTalkIndex.row()) else: self.show_new_talk_popup() def talk_selected(self, model): self.mapper.setCurrentIndex(model.row()) self.talkDetailsWidget.enable_input_fields() self.talkDetailsWidget.saveButton.setEnabled(False) self.currentTalkIndex = QPersistentModelIndex(model) def toggle_import(self): if self.importTalksWidget.csvRadioButton.isChecked(): self.importTalksWidget.csvLineEdit.setEnabled(True) self.importTalksWidget.csvFileSelectButton.setEnabled(True) self.importTalksWidget.rssLineEdit.setEnabled(False) else: self.importTalksWidget.csvLineEdit.setEnabled(False) self.importTalksWidget.csvFileSelectButton.setEnabled(False) self.importTalksWidget.rssLineEdit.setEnabled(True) def show_import_talks_widget(self): self.commandButtons.setHidden(True) self.tableView.setHidden(True) self.talkDetailsWidget.setHidden(True) self.importTalksWidget.setHidden(False) def hide_import_talks_widget(self): self.commandButtons.setHidden(False) self.tableView.setHidden(False) self.talkDetailsWidget.setHidden(False) self.importTalksWidget.setHidden(True) def add_talk(self): """Adds a new talk to the database using data from the NewTalkWidget input fields""" presentation = self.create_presentation( self.newTalkWidget.talkDetailsWidget) if presentation: self.db.insert_presentation(presentation) self.newTalkWidget.accept() # Close the dialog def update_talk(self): """Updates the currently selected talk using data from the TalkEditorApp input fields""" selected_talk = self.tableView.currentIndex() if selected_talk.row( ) >= 0: # The tableView index begins at 0 and is -1 by default talk_id = selected_talk.sibling(selected_talk.row(), 0).data().toString() presentation = self.create_presentation(self.talkDetailsWidget) if presentation: self.db.update_presentation(talk_id, presentation) self.apply_changes(selected_talk) self.talkDetailsWidget.saveButton.setEnabled(False) def create_presentation(self, talkDetailsWidget): """Creates and returns an instance of Presentation using data from the input fields""" date = talkDetailsWidget.dateEdit.date() startTime = talkDetailsWidget.startTimeEdit.time() endTime = talkDetailsWidget.endTimeEdit.time() title = unicode(talkDetailsWidget.titleLineEdit.text()).strip() if title: return Presentation( unicode(talkDetailsWidget.titleLineEdit.text()).strip(), unicode(talkDetailsWidget.presenterLineEdit.text()).strip(), unicode(talkDetailsWidget.descriptionTextEdit.toPlainText()). strip(), unicode(talkDetailsWidget.categoryLineEdit.text()).strip(), unicode(talkDetailsWidget.eventLineEdit.text()).strip(), unicode(talkDetailsWidget.roomLineEdit.text()).strip(), unicode(date.toString(Qt.ISODate)), unicode(startTime.toString(Qt.ISODate)), unicode(endTime.toString(Qt.ISODate))) def show_new_talk_popup(self): """Displays a modal dialog with a talk details view When Add is selected, a new talk is added to the database using the input field data. When Cancel is selected, no talk is added. """ log.info('Opening Add Talk window...') self.clear_new_talk_fields() self.remove_new_talk_placeholder_text() self.newTalkWidget.talkDetailsWidget.titleLineEdit.setFocus() if self.newTalkWidget.exec_() == 1: self.apply_changes() self.talkDetailsWidget.disable_input_fields() else: log.info('No talk added...') def apply_changes(self, updated_talk=None): """Repopulates the model to display the effective changes Updates the autocomplete fields. Displays the updated model in the table view, and selects the newly updated/added talk. """ self.presentationModel.select() self.select_talk(updated_talk) self.update_autocomplete_fields() def select_talk(self, talk=None): """Selects the given talk in the table view If no talk is given, the last row in the table view is selected. """ if talk: row = talk.row() column = talk.column() else: row = self.presentationModel.rowCount() - 1 # Select last row column = 0 self.tableView.selectRow(row) self.tableView.setCurrentIndex(self.proxy.index(row, column)) self.talk_selected(self.proxy.index(row, column)) def remove_talk(self): try: rows_selected = self.tableView.selectionModel().selectedRows() except: return # Reversed because rows in list change position once row is removed for row in reversed(rows_selected): self.presentationModel.removeRow(row.row()) self.talkDetailsWidget.clear_input_fields() self.talkDetailsWidget.disable_input_fields() def load_talk(self): try: self.tableView.currentIndex().row() except: return self.mapper.addMapping(self.talkDetailsWidget.roomLineEdit, 6) self.presentationModel.select() def reset(self): self.db.clear_database() self.presentationModel.select() self.talkDetailsWidget.clear_input_fields() self.talkDetailsWidget.disable_input_fields() def confirm_reset(self): """Presents a confirmation dialog to ask the user if they are sure they wish to remove the talk database. If Yes call the reset() function""" confirm = QMessageBox.question(self, self.confirmDBClearTitleString, self.confirmDBClearQuestionString, QMessageBox.Yes | QMessageBox.No, QMessageBox.No) if confirm == QMessageBox.Yes: self.reset() def add_talks_from_rss(self): rss_url = unicode(self.importTalksWidget.rssLineEdit.text()) if rss_url: self.db.add_talks_from_rss(rss_url) self.presentationModel.select() self.hide_import_talks_widget() else: error = QMessageBox() error.setText("Please enter a RSS URL") error.exec_() def closeEvent(self, event): if self.unsaved_details_exist(): log.info("Unsaved changes exist in row %d", self.currentTalkIndex.row()) confirm = self.show_save_prompt() if confirm == self.saveButton: log.info("Saving changes in row %d...", self.currentTalkIndex.row()) self.update_talk() log.info('Exiting talk database editor...') self.geometry = self.saveGeometry() event.accept() elif confirm == self.discardButton: log.info("Discarding changes in row %d...", self.currentTalkIndex.row()) # Ensure that changes are discarded self.talk_selected(self.currentTalkIndex) log.info('Exiting talk database editor...') self.geometry = self.saveGeometry() event.accept() else: log.info("Continue editing row %d", self.currentTalkIndex.row()) event.ignore() else: log.info('Exiting talk database editor...') self.geometry = self.saveGeometry() event.accept() def csv_file_select(self): fname = QFileDialog.getOpenFileName(self, 'Select file', "", "*.csv") if fname: self.importTalksWidget.csvLineEdit.setText(fname) def add_talks_from_csv(self): fname = self.importTalksWidget.csvLineEdit.text() if fname: self.db.add_talks_from_csv(fname) self.presentationModel.select() self.hide_import_talks_widget() else: error = QMessageBox() error.setText("Please select a file") error.exec_() def import_talks(self): if self.importTalksWidget.csvRadioButton.isChecked(): self.add_talks_from_csv() else: self.add_talks_from_rss() self.update_autocomplete_fields() def export_talks_to_csv(self): fname = QFileDialog.getSaveFileName(self, 'Select file', "", "*.csv") if fname: self.db.export_talks_to_csv(fname) def update_autocomplete_fields(self): self.titleList = QStringList(self.db.get_string_list("Title")) self.speakerList = QStringList(self.db.get_string_list("Speaker")) self.categoryList = QStringList(self.db.get_string_list("Category")) self.eventList = QStringList(self.db.get_string_list("Event")) self.roomList = QStringList(self.db.get_string_list("Room")) self.titleCompleter = QCompleter(self.titleList) self.titleCompleter.setCaseSensitivity(Qt.CaseInsensitive) self.speakerCompleter = QCompleter(self.speakerList) self.speakerCompleter.setCaseSensitivity(Qt.CaseInsensitive) self.categoryCompleter = QCompleter(self.categoryList) self.categoryCompleter.setCaseSensitivity(Qt.CaseInsensitive) self.eventCompleter = QCompleter(self.eventList) self.eventCompleter.setCaseSensitivity(Qt.CaseInsensitive) self.roomCompleter = QCompleter(self.roomList) self.roomCompleter.setCaseSensitivity(Qt.CaseInsensitive) self.talkDetailsWidget.titleLineEdit.setCompleter(self.titleCompleter) self.talkDetailsWidget.presenterLineEdit.setCompleter( self.speakerCompleter) self.talkDetailsWidget.categoryLineEdit.setCompleter( self.categoryCompleter) self.talkDetailsWidget.eventLineEdit.setCompleter(self.eventCompleter) self.talkDetailsWidget.roomLineEdit.setCompleter(self.roomCompleter) def are_fields_enabled(self): return (self.talkDetailsWidget.titleLineEdit.isEnabled() and self.talkDetailsWidget.presenterLineEdit.isEnabled() and self.talkDetailsWidget.categoryLineEdit.isEnabled() and self.talkDetailsWidget.eventLineEdit.isEnabled() and self.talkDetailsWidget.roomLineEdit.isEnabled() and self.talkDetailsWidget.dateEdit.isEnabled() and self.talkDetailsWidget.startTimeEdit.isEnabled() and self.talkDetailsWidget.endTimeEdit.isEnabled()) def unsaved_details_exist(self): """Checks if changes have been made to new/existing talk details Looks for text in the input fields and check the enabled state of the Save Talk button If the Save Talk button is enabled, the input fields contain modified values """ return (self.talkDetailsWidget.saveButton.isEnabled() and (self.talkDetailsWidget.titleLineEdit.text() or self.talkDetailsWidget.presenterLineEdit.text() or self.talkDetailsWidget.categoryLineEdit.text() or self.talkDetailsWidget.descriptionTextEdit.toPlainText())) def enable_save(self): self.talkDetailsWidget.saveButton.setEnabled(True) def clear_new_talk_fields(self): """Removes existing data from all NewTalkWidget fields except event, room, date and time""" self.newTalkWidget.talkDetailsWidget.titleLineEdit.clear() self.newTalkWidget.talkDetailsWidget.presenterLineEdit.clear() self.newTalkWidget.talkDetailsWidget.descriptionTextEdit.clear() self.newTalkWidget.talkDetailsWidget.categoryLineEdit.clear() def remove_new_talk_placeholder_text(self): """Removes placeholder text in NewTalkWidget originally set by TalkDetailsWidget""" self.newTalkWidget.talkDetailsWidget.titleLineEdit.setPlaceholderText( "") self.newTalkWidget.talkDetailsWidget.presenterLineEdit.setPlaceholderText( "") self.newTalkWidget.talkDetailsWidget.categoryLineEdit.setPlaceholderText( "") self.newTalkWidget.talkDetailsWidget.eventLineEdit.setPlaceholderText( "") self.newTalkWidget.talkDetailsWidget.roomLineEdit.setPlaceholderText( "")
class IO(QDockWidget): def __init__(self, mainWindow): super(IO, self).__init__() self.__mainWindow = mainWindow self.addAction() self.configure() self.io = self.initIO() self.sigout = "IOOUTputtext" self.connect(self, SIGNAL(self.sigout), self.puttextout) self.sigerr = "IOERRputtext" self.connect(self, SIGNAL(self.sigerr), self.puttexterr) self.redirect = RedirectIO(self) self.cioout = CIO(self, sys.__stdout__.fileno(), self.sigout) self.cioout.start() self.cioerr = CIO(self, sys.__stderr__.fileno(), self.sigerr) self.cioerr.start() def configure(self): self.setAllowedAreas(Qt.AllDockWidgetAreas) self.setObjectName("dockWidgetBrowser") self.setWindowTitle(QApplication.translate("Log", "Log", None, QApplication.UnicodeUTF8)) def addAction(self): self.__action = QAction(self) self.__action.setCheckable(True) self.__action.setChecked(True) self.__action.setObjectName("actionCoreInformations") self.__action.setText(QApplication.translate("MainWindow", "Log", None, QApplication.UnicodeUTF8)) self.__mainWindow.menuWindow.addAction(self.__action) self.connect(self.__action, SIGNAL("triggered()"), self.changeVisibleInformations) def changeVisibleInformations(self): if not self.isVisible() : self.setVisible(True) self.__action.setChecked(True) else : self.setVisible(False) self.__action.setChecked(False) def visibilityChanged(self, bool): if not self.isVisible() : self.__action.setChecked(False) else : self.__action.setChecked(True) def initIO(self): self.iowidget = QWidget(self) self.layout = QHBoxLayout(self.iowidget) self.iowidget.setLayout(self.layout) self.tabwidget = QTabWidget(self) self.tabwidget.setElideMode(Qt.ElideRight) self.textOut = QTextEdit(self) self.textOut.setReadOnly(1) self.textOut.name = "output" self.setWidget(self.textOut) self.tabwidget.addTab(self.textOut, "Output") self.textErr = QTextEdit(self) self.textErr.setReadOnly(1) self.textErr.name = "error" self.setWidget(self.textErr) self.tabwidget.addTab(self.textErr, "Error") self.layout.addWidget(self.tabwidget) self.setWidget(self.iowidget) def puttextout(self, text): self.textOut.append(text) def puttexterr(self, text): self.textErr.append(text)
class CurveFitting(Module): """Module to fit waves to a function.""" # To add new fitting functions, do the following: # 1) Edit GUI # 2) Modify _parameterTableDefaults # 3) Create a fit[Function] method to do the fitting # 4) Call fit[Function] from doFit # Default values for parameter table # Each dict entry is a list of lists. The inner list contains a row of values. _parameterTableDefaults = { 'Polynomial': [ ['p0', 1], ['p1', 1], ['p2', 1], ], 'Sinusoid': [ ['p0', 1], ['p1', 1], ['p2', 1], ['p3', 1], ], 'Power Law': [ ['y0', 0], ['a', 1], ['k', 1], ], 'Exponential': [ ['y0', 0], ['A', 1], ['b', 1], ], 'Logarithm': [ ['y0', 0], ['a', 1], ['base', 10], ], 'Gaussian': [ ['amp', 1], ['mean', 0], ['width', 1], ], 'Lorentzian': [ ['amp', 1], ['mean', 0], ['hwhm', 1], ], } def __init__(self): Module.__init__(self) def buildWidget(self): self._widget = QWidget() self._ui = Ui_CurveFitting() self._ui.setupUi(self._widget) self.setModels() self.setupSpinBoxes() self.setupParameterTableData() # Connect button signals self._ui.doFitButton.clicked.connect(self.doFit) self._ui.closeButton.clicked.connect(self.closeWindow) self._ui.function.currentIndexChanged[str].connect(self.changeFunction) self._ui.function.currentIndexChanged[str].connect(self.connectSlotsOnFunctionChange) self._ui.initialValuesWave.activated[str].connect(self.changeInitialValuesWave) self._ui.useInitialValuesWave.toggled[bool].connect(self.changeInitialValuesWaveFromCheckbox) self._ui.useWaveForInterpolation.toggled[bool].connect(self.catchInterpolationWaveGroupBoxCheck) self._ui.useDomainForInterpolation.toggled[bool].connect(self.catchInterpolationDomainGroupBoxCheck) self.connectSlotsOnFunctionChange('') def setModels(self): # Set up model and view self._allWavesListModel = self._app.model('appWaves') self._ui.xWave.setModel(self._allWavesListModel) self._ui.yWave.setModel(self._allWavesListModel) self._ui.weightWave.setModel(self._allWavesListModel) self._ui.initialValuesWave.setModel(self._allWavesListModel) self._ui.interpolationWave.setModel(self._allWavesListModel) def setupSpinBoxes(self): self._ui.dataRangeStart.addWaveView(self._ui.xWave) self._ui.dataRangeEnd.addWaveView(self._ui.xWave) self._ui.dataRangeStart.addWaveView(self._ui.yWave) self._ui.dataRangeEnd.addWaveView(self._ui.yWave) self._ui.interpolationWaveRangeStart.addWaveView(self._ui.interpolationWave) self._ui.interpolationWaveRangeEnd.addWaveView(self._ui.interpolationWave) def setupParameterTableData(self): self._parameterTableData = {} self._currentFunction = None self.changeFunction('') def closeWindow(self): self._widget.parent().close() def connectSlotsOnFunctionChange(self, newFunctionName): """ Disconnect slots dependent on which function is chosen. If polynomial function is chosen, connect slot to update parameter table on degree change. """ # Disconnect slots try: self._ui.polynomialDegree.valueChanged[int].disconnect(self.changePolynomialDegree) except: pass # Connect polynomial degree change if Util.getWidgetValue(self._ui.function) == 'Polynomial': self._ui.polynomialDegree.valueChanged[int].connect(self.changePolynomialDegree) def catchInterpolationWaveGroupBoxCheck(self, checked): # Set the opposite check for the domain group box Util.setWidgetValue(self._ui.useDomainForInterpolation, not checked) def catchInterpolationDomainGroupBoxCheck(self, checked): # Set the opposite check for the wave group box Util.setWidgetValue(self._ui.useWaveForInterpolation, not checked) def saveParameterTable(self): """ Save the parameters for the current function to the object. """ if self._currentFunction: self._parameterTableData[self._currentFunction] = self.getCurrentParameterTable() def changeFunction(self, newFunctionName): # Save parameters for old function self.saveParameterTable() #if self._currentFunction: # self._parameterTableData[self._currentFunction] = self.getCurrentParameterTable() # Now update _currentFunction to the function that is currently selected. # If this method was called because the user selected a different function, # then this will be modified. If it was called because the fit curve button # was pressed, then its value will not be changed. self._currentFunction = Util.getWidgetValue(self._ui.function) # Enter in parameters for new function # If there are previously user-entered values, then use them # else, if a wave is selected, then use that # else, use the initial values # Either way, if there are blank entries, then use initial values for them # Clear the table, but leave all the column headers for rowIndex in range(self._ui.parameterTable.rowCount()): self._ui.parameterTable.removeRow(0) parameters = [] # If there is saved data, use it if self._currentFunction in self._parameterTableData: parameters = self._parameterTableData[self._currentFunction] # If there aren't enough rows for all the parameters, extend with # initial values. This will also occur if no parameters had been saved. savedParametersLength = len(parameters) defaultParameters = self._parameterTableDefaults[self._currentFunction] if savedParametersLength < len(defaultParameters): parameters.extend(defaultParameters[len(parameters):]) # Use wave if requested by the user if Util.getWidgetValue(self._ui.useInitialValuesWave): # Convert from QString to str waveName = str(Util.getWidgetValue(self._ui.initialValuesWave)) if self._app.waves().wave(waveName) is None: # waveName is not a name of a wave pass else: waveData = self._app.waves().wave(waveName).data() for i in range(savedParametersLength, len(defaultParameters)): parameters[i][1] = waveData[i] self.writeParametersToTable(parameters) def writeParametersToTable(self, parameters, startRow=0): # Determine how many rows the table should have numRows = startRow + len(parameters) self._ui.parameterTable.setRowCount(numRows) # Now actually write to the table for rowIndex, row in enumerate(parameters, startRow): for colIndex, value in enumerate(row): item = QTableWidgetItem(str(value)) if colIndex == 0: # parameter name, do not want it editable item.setFlags(Qt.ItemIsEnabled) self._ui.parameterTable.setItem(rowIndex, colIndex, item) def changePolynomialDegree(self, newDegree): # If decreasing the degree, just remove the last entries # If increasing the degree, # If a wave is selected, then use that for the new values # else, use the initial values desiredNumRows = newDegree + 1 currentNumRows = self._ui.parameterTable.rowCount() if desiredNumRows == currentNumRows: # Nothing to do return # Set defaults rows = [] for d in range(desiredNumRows): rows.append(['p' + str(d), 1]) self._parameterTableDefaults['Polynomial'] = rows # Update table self._ui.parameterTable.setRowCount(desiredNumRows) if desiredNumRows < currentNumRows: # We are done, because no rows need to be edited return # Degree is being increased parameters = self._parameterTableDefaults['Polynomial'][currentNumRows:desiredNumRows] if Util.getWidgetValue(self._ui.useInitialValuesWave): # Convert from QString to str waveName = str(Util.getWidgetValue(self._ui.initialValuesWave)) if self._app.waves().wave(waveName) is None: # waveName is not a name of a wave pass else: waveData = self._app.waves().wave(waveName).data(currentNumRows, desiredNumRows) for index, value in enumerate(waveData): parameters[index][1] = value self.writeParametersToTable(parameters, currentNumRows) def changeInitialValuesWaveFromCheckbox(self, checked): """ If the useInitialValuesWave checkbox is checked, then call changeInitialValuesWave. """ if checked: self.changeInitialValuesWave(str(Util.getWidgetValue(self._ui.initialValuesWave))) def changeInitialValuesWave(self, waveName): # Use the wave for as many parameters as possible # if the wave is too long, then just use the first n values # if the wave is too short, then leave the current value in place # if there is no current value, then use the initial values if Util.getWidgetValue(self._ui.useInitialValuesWave): # Get the current values, with any undefined values using the initial values parameters = self.currentParametersBackedByDefaults() # Now get the wave values parameters = self.updateParametersListWithWave(parameters, waveName) # Set the table to the parameters self.writeParametersToTable(parameters) def updateParametersListWithWave(self, parameters, waveName): """ Given a list of parameter table rows, and the name of a wave, this will update the parameter values with the entries in the wave. """ waveName = str(waveName) if self._app.waves().wave(waveName) is None: # waveName is not a name of a wave return parameters waveData = self._app.waves().wave(waveName).data(0, len(parameters)) for i in range(len(waveData)): parameters[i][1] = waveData[i] return parameters def currentParametersBackedByDefaults(self): # Start with initial values parameters = self._parameterTableDefaults[self._currentFunction] # Then get the current values and update parameters with it currentParameters = self.getCurrentParameterTable() for rowIndex, row in enumerate(currentParameters): parameters[rowIndex] = row return parameters def getCurrentParameterTable(self): """ Save data to a 2-d array mimicking the table. """ # FIXME only works with text right now. Need to add in support for check boxes # Maybe do this by creating a QTableWidgetItem option in Util.getWidgetValue # and using QTableWidget.cellWidget to get the indiv. cells table = [] row = [] for rowIndex in range(self._ui.parameterTable.rowCount()): for colIndex in range(self._ui.parameterTable.columnCount()): try: row.append(str(self._ui.parameterTable.item(rowIndex, colIndex).text())) except AttributeError: row.append('') table.append(row) row = [] return table def parameterColumnValues(self, functionName, columnNum): """ Return a list of the values of a specific column in the parameter table. """ if functionName not in self._parameterTableData: return None tableData = self._parameterTableData[functionName] values = [str(row[columnNum]) for row in tableData] return values def parameterNames(self, functionName): """ Return a list of the names of the parameters for the given function. """ return self.parameterColumnValues(functionName, 0) def parameterInitialValues(self, functionName): """ Return a list of the initial values of the parameters (NOT the default values) for the given function. """ values = self.parameterColumnValues(functionName, 1) initialValues = [float(v) if Util.isNumber(v) else 1 for v in values] return initialValues def doFit(self): # save user-defined parameters self.saveParameterTable() # Get all waves that are selected before doing anything else # If any waves are created, as they are in the output tab section, # then the wave combo boxes are refreshed, and the previous selection # is lost xWaveName = Util.getWidgetValue(self._ui.xWave) yWaveName = Util.getWidgetValue(self._ui.yWave) weightWaveName = Util.getWidgetValue(self._ui.weightWave) interpolationDomainWaveName = Util.getWidgetValue(self._ui.interpolationWave) # Get data tab dataRangeStart = Util.getWidgetValue(self._ui.dataRangeStart) dataRangeEnd = Util.getWidgetValue(self._ui.dataRangeEnd) xWave = self._app.waves().wave(xWaveName) yWave = self._app.waves().wave(yWaveName) xLength = xWave.length() yLength = yWave.length() # Verify data range limits are valid if dataRangeStart > xLength or dataRangeStart > yLength: dataRangeStart = 0 if dataRangeEnd > xLength or dataRangeEnd > yLength: dataRangeEnd = min(xLength, yLength) - 1 xData = xWave.data(dataRangeStart, dataRangeEnd + 1) yData = yWave.data(dataRangeStart, dataRangeEnd + 1) # Get weights, if required by user if Util.getWidgetValue(self._ui.useWeights): weightWave = self._app.waves().wave(weightWaveName) weightLength = weightWave.length() weightData = weightWave.data(dataRangeStart, dataRangeEnd + 1) # If weighting inversely, invert the weights if Util.getWidgetValue(self._ui.weightIndirectly): weightData = [1./w if w != 0 else 0 for w in weightData] if len(weightData) != len(yData): print "The number of weight points is not the same as the number of y points." return 1 else: weightData = None # Get output tab outputOptions = {} outputWaves = {} outputOptions['createTable'] = Util.getWidgetValue(self._ui.createTable) outputOptions['outputParameters'] = Util.getWidgetValue(self._ui.outputParameters) if outputOptions['outputParameters']: outputOptions['saveLabels'] = Util.getWidgetValue(self._ui.saveLabels) # Create saveLabels wave if outputOptions['saveLabels']: saveLabelsDestination = self._app.waves().findGoodWaveName(Util.getWidgetValue(self._ui.saveLabelsDestination)) outputWaves['saveLabelsWave'] = Wave(saveLabelsDestination, 'String') self._app.waves().addWave(outputWaves['saveLabelsWave']) # Create parameter wave parameterDestination = self._app.waves().findGoodWaveName(Util.getWidgetValue(self._ui.parameterDestination)) outputWaves['parameterWave'] = Wave(parameterDestination, 'Decimal') self._app.waves().addWave(outputWaves['parameterWave']) outputOptions['outputInterpolation'] = Util.getWidgetValue(self._ui.outputInterpolation) if outputOptions['outputInterpolation']: # Create interpolation wave interpolationDestination = self._app.waves().findGoodWaveName(Util.getWidgetValue(self._ui.interpolationDestination)) outputWaves['interpolationDestinationWave'] = Wave(interpolationDestination, 'Decimal') self._app.waves().addWave(outputWaves['interpolationDestinationWave']) if Util.getWidgetValue(self._ui.useWaveForInterpolation): # Using an already-existing wave for the interpolation points. interpolationDomainWave = self._app.waves().wave(interpolationDomainWaveName) interpolationWaveRangeStart = Util.getWidgetValue(self._ui.interpolationWaveRangeStart) interpolationWaveRangeEnd = Util.getWidgetValue(self._ui.interpolationWaveRangeEnd) outputWaves['interpolationDomainWave'] = interpolationDomainWave # Start the wave with as many blanks as necessary in order to get the destination wave # to line up correctly with the domain wave, for easy plotting. outputWaves['interpolationDestinationWave'].extend([''] * interpolationWaveRangeStart) # Verify data range limits are valid interpolationDomainLength = interpolationDomainWave.length() if interpolationWaveRangeStart > interpolationDomainLength: interpolationWaveRangeStart = 0 if interpolationWaveRangeEnd > interpolationDomainLength: interpolationWaveRangeEnd = interpolationDomainLength - 1 outputOptions['interpolationDomainWaveData'] = interpolationDomainWave.data(interpolationWaveRangeStart, interpolationWaveRangeEnd + 1) else: # Creating a new wave based on a domain and number of points. customWaveName = Util.getWidgetValue(self._ui.interpolationCustomWaveName) customLowerLimit = float(Util.getWidgetValue(self._ui.interpolationCustomLowerLimit)) customUpperLimit = float(Util.getWidgetValue(self._ui.interpolationCustomUpperLimit)) customNumPoints = Util.getWidgetValue(self._ui.interpolationCustomNumPoints) outputOptions['interpolationDomainWaveData'] = numpy.linspace(customLowerLimit, customUpperLimit, customNumPoints, endpoint=True) interpolationDomainWaveName = self._app.waves().findGoodWaveName(customWaveName) outputWaves['interpolationDomainWave'] = Wave(interpolationDomainWaveName, 'Decimal', outputOptions['interpolationDomainWaveData']) self._app.waves().addWave(outputWaves['interpolationDomainWave']) outputOptions['saveResiduals'] = Util.getWidgetValue(self._ui.saveResiduals) if outputOptions['saveResiduals']: residualsDestination = self._app.waves().findGoodWaveName(Util.getWidgetValue(self._ui.residualsDestination)) outputWaves['residualsWave'] = Wave(residualsDestination, 'Decimal') self._app.waves().addWave(outputWaves['residualsWave']) # If the fit is not done to all the data in the wave, then we need to add blanks to the beginning # of the residual wave because the residuals will only be calculated for the part of the data that # was actually fit. outputWaves['residualsWave'].extend([''] * dataRangeStart) # Save the x wave, in case it is different from the interpolationDomainWave outputWaves['xWave'] = xWave # Determine the function and call the appropriate method functionName = Util.getWidgetValue(self._ui.function) if functionName == 'Polynomial': self.fitPolynomial(xData, yData, weightData, outputWaves, outputOptions) elif functionName == 'Sinusoid': self.fitSinusoid(xData, yData, weightData, outputWaves, outputOptions) elif functionName == 'Power Law': self.fitPowerLaw(xData, yData, weightData, outputWaves, outputOptions) elif functionName == 'Exponential': self.fitExponential(xData, yData, weightData, outputWaves, outputOptions) elif functionName == 'Logarithm': self.fitLogarithm(xData, yData, weightData, outputWaves, outputOptions) elif functionName == 'Gaussian': self.fitGaussian(xData, yData, weightData, outputWaves, outputOptions) elif functionName == 'Lorentzian': self.fitLorentzian(xData, yData, weightData, outputWaves, outputOptions) def fitPolynomial(self, xData, yData, weightData=None, outputWaves={}, outputOptions={}): # Get the degree of the polynomial the user wants to use degree = Util.getWidgetValue(self._ui.polynomialDegree) def polynomialFunction(p, x): # If x is a list, then val needs to be a list # If x is a number, then val needs to be a number if isinstance(x, list): val = numpy.array([p[0]] * len(x)) else: val = p[0] # Add x, x^2, x^3, etc entries for d in range(1, degree + 1): val += numpy.multiply(p[d], numpy.power(x, d)) return val parameterNames = self.parameterNames('Polynomial') initialValues = self.parameterInitialValues('Polynomial') if initialValues is None: initialValues = [1] * degree self.fitFunction(polynomialFunction, parameterNames, initialValues, xData, yData, weightData, outputWaves, outputOptions, 'Polynomial Fit') def fitSinusoid(self, xData, yData, weightData=None, outputWaves={}, outputOptions={}): sinusoidFunction = lambda p, x: p[0] + p[1] * numpy.cos(x / p[2] * 2. * numpy.pi + p[3]) parameterNames = self.parameterNames('Sinusoid') initialValues = self.parameterInitialValues('Sinusoid') if initialValues is None: initialValues = [1, 1, 1, 1] self.fitFunction(sinusoidFunction, parameterNames, initialValues, xData, yData, weightData, outputWaves, outputOptions, 'Sinusoid Fit') def fitPowerLaw(self, xData, yData, weightData=None, outputWaves={}, outputOptions={}): powerLawFunction = lambda p, x: numpy.add(p[0], numpy.multiply(p[1], numpy.power(x, p[2]))) parameterNames = self.parameterNames('Power Law') initialValues = self.parameterInitialValues('Power Law') if initialValues is None: initialValues = [0, 1, 1] self.fitFunction(powerLawFunction, parameterNames, initialValues, xData, yData, weightData, outputWaves, outputOptions, 'Power Law Fit') def fitExponential(self, xData, yData, weightData=None, outputWaves={}, outputOptions={}): exponentialFunction = lambda p, x: numpy.add(p[0], numpy.multiply(p[1], numpy.power(numpy.e, numpy.multiply(p[2], x)))) parameterNames = self.parameterNames('Exponential') initialValues = self.parameterInitialValues('Exponential') if initialValues is None: initialValues = [0, 1, 1] self.fitFunction(exponentialFunction, parameterNames, initialValues, xData, yData, weightData, outputWaves, outputOptions, 'Exponential Fit') def fitLogarithm(self, xData, yData, weightData=None, outputWaves={}, outputOptions={}): # There is no numpy log function where you can specify a custom base, so we'll define one customBaseLog = lambda base, x: numpy.divide(numpy.log(x), numpy.log(base)) logarithmFunction = lambda p, x: numpy.add(p[0], numpy.multiply(p[1], customBaseLog(p[2], x))) parameterNames = self.parameterNames('Logarithm') initialValues = self.parameterInitialValues('Logarithm') if initialValues is None: initialValues = [0, 1, 10] self.fitFunction(logarithmFunction, parameterNames, initialValues, xData, yData, weightData, outputWaves, outputOptions, 'Logarithm Fit') def fitGaussian(self, xData, yData, weightData=None, outputWaves={}, outputOptions={}): gaussianFunction = lambda p, x: numpy.multiply(p[0], numpy.power(numpy.e, numpy.divide(-1 * numpy.power((numpy.subtract(x, p[1])), 2), 2 * numpy.power(p[2], 2)))) parameterNames = self.parameterNames('Gaussian') initialValues = self.parameterInitialValues('Gaussian') if initialValues is None: initialValues = [1, 0, 1] self.fitFunction(gaussianFunction, parameterNames, initialValues, xData, yData, weightData, outputWaves, outputOptions, 'Gaussian Fit') def fitLorentzian(self, xData, yData, weightData=None, outputWaves={}, outputOptions={}): lorentzianFunction = lambda p, x: numpy.divide(numpy.multiply(p[0], p[2]), numpy.add(numpy.power(numpy.subtract(x, p[1]), 2), numpy.power(p[2], 2))) parameterNames = self.parameterNames('Lorentzian') initialValues = self.parameterInitialValues('Lorentzian') if initialValues is None: initialValues = [1, 0, 1] self.fitFunction(lorentzianFunction, parameterNames, initialValues, xData, yData, weightData, outputWaves, outputOptions, 'Lorentzian Fit') def fitFunction(self, function, parameterNames, initialValues, xData, yData, weightData=None, outputWaves={}, outputOptions={}, tableName='Fit'): # Can also include initial guesses for the parameters, as well as sigma's for weighting of the ydata # Need to fail with error message if the leastsq call does not succeed # Do the fit result = self.fitFunctionLeastSquares(function, initialValues, xData, yData, weightData) parameters = result[0] tableWaves = [] # Deal with the parameter-related waves if outputOptions['outputParameters']: # save parameter labels if outputOptions['saveLabels']: tableWaves.append(outputWaves['saveLabelsWave']) outputWaves['saveLabelsWave'].extend(parameterNames) tableWaves.append(outputWaves['parameterWave']) # save parameters to a wave outputWaves['parameterWave'].extend(parameters) # Do the interpolation if outputOptions['outputInterpolation']: domain = outputOptions['interpolationDomainWaveData'] determinedFunction = lambda x: function(parameters, x) for val in domain: outputWaves['interpolationDestinationWave'].push(determinedFunction(val)) tableWaves.append(outputWaves['interpolationDomainWave']) tableWaves.append(outputWaves['interpolationDestinationWave']) # Do the residuals if outputOptions['saveResiduals']: residualsFunc = lambda p, x, y: numpy.subtract(y, function(p, x)) residuals = residualsFunc(parameters, xData, yData) outputWaves['residualsWave'].extend(residuals) tableWaves.append(outputWaves['xWave']) tableWaves.append(outputWaves['residualsWave']) # Create table if outputOptions['createTable']: self.createTable(tableWaves, tableName) def fitFunctionLeastSquares(self, func, guess, xData, yData, weightData=None): """ Do a least squares fit for a generic function. func must have the signature (p, x) where p is a list of parameters and x is a float. guess is the user's guess of the parameters, and must be a list of length len(p). xData and yData are the data to fit. """ if weightData is None: #errorFunc = lambda p, x, y: func(p, x) - y errorFunc = lambda p, x, y: numpy.subtract(func(p, x), y) return scipy.optimize.leastsq(errorFunc, guess[:], args=(xData, yData), full_output=True) else: errorFunc = lambda p, x, y, w: numpy.multiply(w, numpy.subtract(func(p, x), y)) return scipy.optimize.leastsq(errorFunc, guess[:], args=(xData, yData, weightData), full_output=True) #return scipy.optimize.leastsq(errorFunc, guess[:], args=(xData, yData), full_output=True) def createTable(self, waves=[], title='Fit'): if len(waves) == 0: return self._app.createTable(waves, title) def load(self): self.window = SubWindow(self._app.ui.workspace) self.menuEntry = QAction(self._app) self.menuEntry.setObjectName("actionCurveFiting") self.menuEntry.setText("Curve Fitting") self.menuEntry.triggered.connect(self.window.show) self.menu = vars(self._app.ui)["menuData"] self.menu.addAction(self.menuEntry) self.buildWidget() self.window.setWidget(self._widget) self._widget.setParent(self.window) self.window.hide() def unload(self): self._widget.deleteLater() self.window.deleteLater() self.menu.removeAction(self.menuEntry) def reload(self): self.setModels() self.setupSpinBoxes() self.setupParameterTableData() Util.setWidgetValue(self._ui.function, 'Polynomial') Util.setWidgetValue(self._ui.useInitialValuesWave, False)
class AutoFieldsDockWidget( QDockWidget, Ui_AutoFieldsDockWidget ): """ Class in charge of all the UI logic """ def __init__( self, parent, iface, autoFieldManager, messageManager, language='en' ): self.iface = iface self.msg = messageManager self.language = language QDockWidget.__init__( self, parent ) # Set up the user interface from Designer. self.setupUi( self ) self.autoFieldManager = autoFieldManager self.geometryDict = ['points','lines','polygons'] self.fieldTypesDict = ['Integer','Real','String','Date'] self.root = QgsProject.instance().layerTreeRoot() # UI stuff that wasn't set/initialized in Qt-Designer self.tblLayers.setColumnWidth( 0, 24 ) self.tblLayers.setColumnWidth( 1, 140 ) self.tblLayers.setColumnWidth( 2, 110 ) self.tblLayers.horizontalHeader().setResizeMode( 0, QHeaderView.Fixed ) self.tblLayers.sortItems(1, Qt.AscendingOrder) self.cboField.setEnabled( False ) self.cboFieldType.setItemData( 0, QVariant.Int, Qt.UserRole ) self.cboFieldType.setItemData( 1, QVariant.Double, Qt.UserRole ) self.cboFieldType.setItemData( 2, QVariant.String, Qt.UserRole ) self.cboFieldType.setItemData( 3, QVariant.Date, Qt.UserRole ) self.fieldTypeChanged( self.cboFieldType.currentIndex() ) # Update length/precision controls self.btnGroup = QButtonGroup() self.btnGroup.addButton( self.optXCoord ) self.btnGroup.addButton( self.optYCoord ) self.btnGroup.addButton( self.optLength ) self.btnGroup.addButton( self.optPerimeter ) self.btnGroup.addButton( self.optArea ) self.btnGroup.addButton( self.optDate ) self.btnGroup.addButton( self.optCustomExpression ) #self.btnGroup.addButton( self.optSpatialValue ) self.updateExpressionControls( self.optCustomExpression ) self.frameFields.setEnabled( False ) self.frameExpression.setEnabled( False ) self.populateLayersTable() QgsMapLayerRegistry.instance().legendLayersAdded.connect( self.populateLayersTable ) QgsMapLayerRegistry.instance().layersRemoved.connect( self.populateLayersTable ) # Also listen to Layer Tree node position changes self.root.addedChildren.connect( self.populateLayersTable ) self.root.removedChildren.connect( self.populateLayersTable ) self.tblLayers.itemSelectionChanged.connect( self.updateFieldAndExpressionControls ) self.optNewField.toggled.connect( self.newFieldToggled ) self.cboField.currentIndexChanged.connect( self.fieldChanged ) self.cboFieldType.currentIndexChanged.connect( self.fieldTypeChanged ) self.btnSaveAutoField.clicked.connect( self.saveAutoField ) self.btnNewCustomExpression.clicked.connect( self.setCustomExpression ) self.btnGroup.buttonClicked.connect( self.updateExpressionControls ) self.expressionDlg = None # 'List of AutoFields' Tab settings = QSettings() check = settings.value( self.autoFieldManager.settingsPrefix + "/showOnlyEnabledAutoFields", True, type=bool ) self.chkOnlyEnabledAutoFields.setChecked( check ) check = settings.value( self.autoFieldManager.settingsPrefix + "/calculateOnExistingFeatures", True, type=bool ) self.chkCalculateOnExisting.setChecked( check ) self.btnRemoveAutoFields.setEnabled( False ) self.tblAutoFields.sortItems(0, Qt.AscendingOrder) self.populateAutoFieldsTable() self.autoFieldManager.autoFieldCreated.connect( self.populateAutoFieldsTable ) self.autoFieldManager.autoFieldRemoved.connect( self.populateAutoFieldsTable ) self.autoFieldManager.autoFieldEnabled.connect( self.populateAutoFieldsTable ) self.autoFieldManager.autoFieldDisabled.connect( self.populateAutoFieldsTable ) self.tblAutoFields.itemSelectionChanged.connect( self.updateRemoveAutoFieldButton ) self.chkOnlyEnabledAutoFields.toggled.connect( self.saveShowOnlyEnabledPreference ) self.chkCalculateOnExisting.toggled.connect( self.saveCalculateOnExistingPreference ) self.btnRemoveAutoFields.clicked.connect( self.removeAutoFieldFromTable ) # Context menu self.tblAutoFields.setContextMenuPolicy( Qt.CustomContextMenu ) self.tblAutoFields.customContextMenuRequested.connect( self.openAutoFieldContextMenu ) # About Tab self.btnHelp.clicked.connect( self.openDocumentation ) def populateLayersTable( self, foo=None, foo2=None, foo3=None ): """ List vector layers that support changes in attributes and are writable. Arguments are 3 and optional because this function listens to several SIGNALs. """ # Initialize Layers Table self.tblLayers.clearContents() self.tblLayers.setRowCount( 0 ) vLayers = [] for layer in QgsMapLayerRegistry.instance().mapLayers().values(): if layer.type() == QgsMapLayer.VectorLayer: if layer.dataProvider().capabilities() & QgsVectorDataProvider.ChangeAttributeValues: if not layer.isReadOnly(): if layer.geometryType() < 3: # Avoid UnknownGeometry and NoGeometry vLayers.append( layer ) self.tblLayers.setRowCount( len( vLayers ) ) self.tblLayers.setColumnCount( 3 ) self.tblLayers.setSortingEnabled( False ) for row, lyr in enumerate( vLayers ): item = QTableWidgetItem( QIcon( ":/plugins/AutoFields/icons/" + \ self.geometryDict[lyr.geometryType()] + ".png"), str( lyr.geometryType() ) ) self.tblLayers.setItem( row, 0, item ) item = QTableWidgetItem( lyr.name() ) item.setData( Qt.UserRole, lyr.id() ) self.tblLayers.setItem( row, 1, item ) tmpTreeLayer = self.root.findLayer( lyr.id() ) if tmpTreeLayer: group = tmpTreeLayer.parent().name() self.tblLayers.setItem(row, 2, QTableWidgetItem( group if group else QApplication.translate("AutoFieldsDockWidgetPy", "< root >" ) ) ) self.tblLayers.setSortingEnabled( True ) def updateFieldAndExpressionControls( self ): """ After a selection is changed, reflect possible values in field controls """ self.msg.show( "New selection " + str(len( self.tblLayers.selectedItems() ) / 3), 'info', True ) if not self.tblLayers.selectedItems(): self.frameFields.setEnabled( False ) self.frameExpression.setEnabled( False ) return else: self.frameFields.setEnabled( True ) self.frameExpression.setEnabled( True ) # List common fields in cboField and get geometries selected geometryTypeSet = self.updateFieldList() # Update expression controls if 0 in geometryTypeSet and len( geometryTypeSet ) == 1: # Points self.optXCoord.setEnabled( True ) self.optYCoord.setEnabled( True ) self.optLength.setEnabled( False ) self.optPerimeter.setEnabled( False ) self.optArea.setEnabled( False ) elif 1 in geometryTypeSet and len( geometryTypeSet ) == 1: # Lines self.optXCoord.setEnabled( False ) self.optYCoord.setEnabled( False ) self.optLength.setEnabled( True ) self.optPerimeter.setEnabled( False ) self.optArea.setEnabled( False ) elif 2 in geometryTypeSet and len( geometryTypeSet ) == 1: # Polygons self.optXCoord.setEnabled( False ) self.optYCoord.setEnabled( False ) self.optLength.setEnabled( False ) self.optPerimeter.setEnabled( True ) self.optArea.setEnabled( True ) else: self.optXCoord.setEnabled( False ) self.optYCoord.setEnabled( False ) self.optLength.setEnabled( False ) self.optPerimeter.setEnabled( False ) self.optArea.setEnabled( False ) if not self.btnGroup.checkedButton().isEnabled(): self.optCustomExpression.setChecked( True ) # Default selection self.updateExpressionControls( self.optCustomExpression ) self.expressionDlg = None # Initialize the dialog def updateFieldList( self ): """ Update field list and return geometries selected """ commonFields = [] geometryTypeSet = set() bFirstFlag = True for item in self.tblLayers.selectedItems(): if item.column() == 1: # It's the layer name item self.msg.show( "ID " + item.data( Qt.UserRole ), 'info', True ) # Get layer id layer = QgsMapLayerRegistry.instance().mapLayer( item.data( Qt.UserRole ) ) geometryTypeSet.add( layer.geometryType() ) tmpFields = [field.name() for field in layer.dataProvider().fields()] # Get field names stored in the provider if bFirstFlag: # Initialize commonFields commonFields = tmpFields bFirstFlag = False else: # Intersect fields if commonFields: # Avoid intersecting if no common fields commonFields = list( set( commonFields ) & set( tmpFields ) ) commonFields.sort() self.msg.show( "FIELDS: "+ str(commonFields), 'info', True) self.cboField.clear() if not commonFields: self.optExistingField.setEnabled( False ) self.optNewField.setChecked( True ) else: self.optExistingField.setEnabled( True ) self.cboField.addItems( commonFields ) return geometryTypeSet def newFieldToggled( self ): """ Alternate between controls of new field and existing field """ newIsChecked = self.optNewField.isChecked() self.cboField.setEnabled( not newIsChecked ) self.lblFieldName.setEnabled( newIsChecked ) self.lblFieldType.setEnabled( newIsChecked ) self.txtFieldName.setEnabled( newIsChecked ) self.cboFieldType.setEnabled( newIsChecked ) if newIsChecked: self.fieldTypeChanged( self.cboFieldType.currentIndex() ) else: self.lblFieldLength.setEnabled( newIsChecked ) self.lblFieldPrecision.setEnabled( newIsChecked ) self.txtFieldLength.setEnabled( newIsChecked ) self.txtFieldPrecision.setEnabled( newIsChecked ) self.expressionDlg = None # Initialize the dialog def fieldTypeChanged( self, idx ): """ Update field length and field precision controls' state and values """ text = self.fieldTypesDict[idx] if text == 'Integer': self.txtFieldLength.setRange( 1, 10 ) self.txtFieldLength.setEnabled( True ) self.txtFieldPrecision.setEnabled( False ) self.lblFieldLength.setEnabled( True ) self.lblFieldPrecision.setEnabled( False ) elif text == 'Real': self.txtFieldLength.setRange( 1, 20 ) self.txtFieldPrecision.setRange( 0, 15 ) self.txtFieldLength.setEnabled( True ) self.txtFieldPrecision.setEnabled( True ) self.lblFieldLength.setEnabled( True ) self.lblFieldPrecision.setEnabled( True ) elif text == 'String': self.txtFieldLength.setRange( 1, 255 ) self.txtFieldLength.setEnabled( True ) self.txtFieldPrecision.setEnabled( False ) self.lblFieldLength.setEnabled( True ) self.lblFieldPrecision.setEnabled( False ) else: # Date self.txtFieldLength.setEnabled( False ) self.txtFieldPrecision.setEnabled( False ) self.lblFieldLength.setEnabled( False ) self.lblFieldPrecision.setEnabled( False ) def fieldChanged( self, idx ): """ Just to initialize the expression dialog if selected field changes """ self.expressionDlg = None # Initialize the dialog def saveAutoField( self ): """ Do some validation and then call AutoFieldManager """ # Check layers if not self.tblLayers.selectedItems(): self.msg.show( QApplication.translate( "AutoFieldsDockWidgetPy", "[Warning] Please first select a layer." ), 'warning' ) return # Check expression expression = u'' if self.optXCoord.isChecked(): expression = u'$x' elif self.optYCoord.isChecked(): expression = u'$y' elif self.optLength.isChecked(): expression = u'$length' elif self.optPerimeter.isChecked(): expression = u'$perimeter' elif self.optArea.isChecked(): expression = u'$area' elif self.optDate.isChecked(): expression = u'now()' elif self.optCustomExpression.isChecked(): if self.expressionDlg: expression = self.expressionDlg.expression if not self.expressionDlg or not expression: self.msg.show( QApplication.translate( "AutoFieldsDockWidgetPy", "[Warning] Please first set a valid custom expression." ), 'warning' ) return else: # optSpatialValue pass # Check fields fieldName = '' if self.optNewField.isChecked(): if self.txtFieldName.text(): fieldName = self.txtFieldName.text().strip() newField = QgsField( fieldName, self.cboFieldType.itemData( self.cboFieldType.currentIndex(), Qt.UserRole) ) length = self.txtFieldLength.value() precision = self.txtFieldPrecision.value() # Ensure length and precision are valid values when dealing with Real numbers if self.fieldTypesDict[self.cboFieldType.currentIndex()] == 'Real': if precision > length: precision = length newField.setLength( length ) newField.setPrecision( precision ) for item in self.tblLayers.selectedItems(): if item.column() == 1: # It's the layer name item layer = QgsMapLayerRegistry.instance().mapLayer( item.data( Qt.UserRole ) ) if layer.fieldNameIndex( fieldName ) != -1: self.msg.show( QApplication.translate( "AutoFieldsDockWidgetPy", "[Error] The field " ) + fieldName + \ QApplication.translate( "AutoFieldsDockWidgetPy", " already exists in layer " ) + layer.name() + ". " + \ QApplication.translate( "AutoFieldsDockWidgetPy", " If you want to create an AutoField on it, you need to choose it from 'Existing Field' list." ), 'warning' ) else: res = layer.dataProvider().addAttributes( [ newField ] ) if res: layer.updateFields() # Check if fieldName is preserved by the provider after field creation. if layer.fieldNameIndex( fieldName ) == -1: self.msg.show( QApplication.translate( "AutoFieldsDockWidgetPy", "[Error] The field " ) + fieldName + \ QApplication.translate( "AutoFieldsDockWidgetPy", " was probably created with another name by the layer (" ) + \ layer.name() + \ QApplication.translate( "AutoFieldsDockWidgetPy", ") provider. " ) + \ QApplication.translate( "AutoFieldsDockWidgetPy", " If you want to create an AutoField on it, you need to choose it from 'Existing Field' list." ), 'warning' ) else: self.doSaveAutoField( layer, fieldName, expression ) else: self.msg.show( QApplication.translate( "AutoFieldsDockWidgetPy", "[Error] Couldn't create " ) + newField.name() + \ QApplication.translate( "AutoFieldsDockWidgetPy", " field in " ) + layer.name() + \ QApplication.translate( "AutoFieldsDockWidgetPy", " layer." ), 'warning' ) # Some fields might have been created, update the field list once self.updateFieldList() else: self.msg.show( QApplication.translate( "AutoFieldsDockWidgetPy", "[Warning] Please first set a name for the new field." ), 'warning' ) return else: fieldName = self.cboField.currentText() for item in self.tblLayers.selectedItems(): if item.column() == 1: # It's the layer name item layer = QgsMapLayerRegistry.instance().mapLayer( item.data( Qt.UserRole ) ) self.doSaveAutoField( layer, fieldName, expression ) def doSaveAutoField( self, layer, fieldName, expression ): """ Repetitive logic to save or overwrite an AutoField """ # Check if the field is an AutoField and ask if we should overwrite it res = True bCalculateOnExisting = self.chkCalculateOnExisting.isChecked() if self.autoFieldManager.isFieldAnAutoField( layer, fieldName ): reply = QMessageBox.question( self.iface.mainWindow(), QApplication.translate( "AutoFieldsDockWidgetPy", "Confirmation" ), QApplication.translate( "AutoFieldsDockWidgetPy", "The field '" ) + \ fieldName + QApplication.translate( "AutoFieldsDockWidgetPy", "' from layer '" ) + layer.name() + \ QApplication.translate( "AutoFieldsDockWidgetPy", "' is already an AutoField.\nDo you want to overwrite it?" ), QMessageBox.Yes | QMessageBox.No, QMessageBox.No ) if reply == QMessageBox.Yes: res = self.autoFieldManager.overwriteAutoField( layer, fieldName, expression, calculateOnExisting=bCalculateOnExisting ) else: res = self.autoFieldManager.createAutoField( layer, fieldName, expression, calculateOnExisting=bCalculateOnExisting ) if not res: # res will only be False if create/overwriteAutoField return False self.msg.show( "[Error] The AutoField for layer '" + layer.name() + \ "' and field '" + fieldName + "' couldn't be created.", 'warning', True ) def setCustomExpression( self ): """ Initialize and show the expression builder dialog """ layer = None if len( self.tblLayers.selectedItems() ) / 3 == 1: # Single layer selected? for item in self.tblLayers.selectedItems(): if item.column() == 1: # It's the layer name item layer = QgsMapLayerRegistry.instance().mapLayer( item.data( Qt.UserRole ) ) if not self.expressionDlg: self.expressionDlg = ExpressionBuilderDialog( self.iface.mainWindow() ) context = QgsExpressionContext() context.appendScope( QgsExpressionContextUtils.globalScope() ) context.appendScope( QgsExpressionContextUtils.projectScope() ) # Initialize dialog with layer-based names and variables if single layer selected if len( self.tblLayers.selectedItems() ) / 3 == 1: context.appendScope( QgsExpressionContextUtils.layerScope( layer ) ) self.expressionDlg.expressionBuilderWidget.setLayer( layer ) self.expressionDlg.expressionBuilderWidget.loadFieldNames() # This block was borrowed from QGIS/python/plugins/processing/algs/qgis/FieldsCalculator.py da = QgsDistanceArea() da.setSourceCrs( layer.crs().srsid() ) da.setEllipsoidalMode( self.iface.mapCanvas().mapSettings().hasCrsTransformEnabled() ) da.setEllipsoid( QgsProject.instance().readEntry( 'Measure', '/Ellipsoid', GEO_NONE )[0] ) self.expressionDlg.expressionBuilderWidget.setGeomCalculator( da ) # If this layer-field is an AutoField, get its expression if self.optExistingField.isChecked(): fieldName = self.cboField.currentText() expression = self.autoFieldManager.getFieldExpression( layer, fieldName ) self.expressionDlg.expressionBuilderWidget.setExpressionText( expression ) self.expressionDlg.expression = expression # To remember it when closing/opening self.expressionDlg.expressionBuilderWidget.setExpressionContext( context ) self.expressionDlg.show() def updateExpressionControls( self, button ): """ Enable/disable push buttons when appropriate """ if button.objectName() == 'optCustomExpression': self.btnNewCustomExpression.setEnabled( True ) #self.btnNewSpatialValue.setEnabled( False ) #elif button.objectName() == 'optSpatialValue': #self.btnNewCustomExpression.setEnabled( False ) #self.btnNewSpatialValue.setEnabled( True ) else: self.btnNewCustomExpression.setEnabled( False ) #self.btnNewSpatialValue.setEnabled( False ) def populateAutoFieldsTable( self, autoFieldId=None ): """ Listens to any modification on AutoFields to update the list """ dictAutoFields = self.autoFieldManager.listAutoFields() if autoFieldId: # Just update this one if not autoFieldId in dictAutoFields: # AutoField removed self.msg.show( "[Info] Removing AutoField from table.", 'info', True ) # Iterate through AF rows and remove row where data matches AFID deleteRow = self.findRowOfItemDataInAutoFieldsTable( autoFieldId, 0) if deleteRow != -1: self.tblAutoFields.removeRow( deleteRow ) else: # if it's in the table: remove it and re-add it (from new dict) deleteRow = self.findRowOfItemDataInAutoFieldsTable( autoFieldId, 0) if deleteRow != -1: self.msg.show( "[Info] Refreshing AutoField status in table.", 'info', True ) self.tblAutoFields.removeRow( deleteRow ) self.addAutoFieldToAutoFieldsTable( autoFieldId, dictAutoFields[autoFieldId] ) else: # New AutoField, just add it to table self.msg.show( "[Info] Adding new AutoField to table.", 'info', True ) self.addAutoFieldToAutoFieldsTable( autoFieldId, dictAutoFields[autoFieldId] ) else: # Initialize AutoFields Table self.tblAutoFields.clearContents() self.tblAutoFields.setRowCount( 0 ) #self.tblAutoFields.setRowCount( len( dictAutoFields ) ) self.tblAutoFields.setColumnCount( 4 ) self.tblAutoFields.setSortingEnabled( False ) for key in dictAutoFields.keys(): autoField = dictAutoFields[key] self.addAutoFieldToAutoFieldsTable( key, autoField, False ) self.tblAutoFields.setSortingEnabled( True ) def findRowOfItemDataInAutoFieldsTable( self, data, col ): """ Get the row number that matches its data to a given data (check only the given column) """ for numRow in range( self.tblAutoFields.rowCount() ): item = self.tblAutoFields.item( numRow, col ) if item.data( Qt.UserRole ) == data: return numRow return -1 def addAutoFieldToAutoFieldsTable( self, autoFieldId, autoField, freezeSorting=True ): """ Add a whole row to the AutoFields table """ if self.chkOnlyEnabledAutoFields.isChecked() and not autoField['enabled']: return if freezeSorting: self.tblAutoFields.setSortingEnabled( False ) row = self.tblAutoFields.rowCount() self.tblAutoFields.insertRow( row ) name = autoField['layer'] if 'layerId' in autoField: lyr = QgsMapLayerRegistry.instance().mapLayer( autoField['layerId'] ) name = lyr.name() item = QTableWidgetItem( name ) item.setData( Qt.UserRole, autoFieldId ) item.setData( Qt.ToolTipRole, autoField['layer'] ) if not autoField['enabled']: item.setForeground( QBrush( Qt.gray ) ) self.tblAutoFields.setItem( row, 0, item ) item = QTableWidgetItem( autoField['field'] ) if not autoField['enabled']: item.setForeground( QBrush( Qt.gray ) ) self.tblAutoFields.setItem( row, 1, item ) item = QTableWidgetItem( autoField['expression'] ) if not autoField['enabled']: item.setForeground( QBrush( Qt.gray ) ) self.tblAutoFields.setItem( row, 2, item ) item = QTableWidgetItem( QApplication.translate( "AutoFieldsDockWidgetPy", "Enabled" ) if autoField['enabled'] else QApplication.translate( "AutoFieldsDockWidgetPy", "Disabled" ) ) item.setData( Qt.UserRole, 'enabled' if autoField['enabled'] else 'disabled' ) if not autoField['enabled']: item.setForeground( QBrush( Qt.gray ) ) self.tblAutoFields.setItem( row, 3, item ) if freezeSorting: self.tblAutoFields.setSortingEnabled( True ) def openAutoFieldContextMenu( self, position ): bLayers = False layers = QgsMapLayerRegistry.instance().mapLayers().values() for layer in layers: if layer.type() == QgsMapLayer.VectorLayer: if layer.dataProvider().capabilities() & QgsVectorDataProvider.AddFeatures: bLayers = True break item = self.tblAutoFields.itemAt( position ) if item: row = item.row() self.menu = QMenu() self.action = QAction( "Assign this AutoField to another layer", None ) self.action.setObjectName('action') if self.tblAutoFields.item( row, 3 ).data( Qt.UserRole ) == 'enabled': self.action.setEnabled( False ) self.menu.addAction( self.action ) action = self.menu.exec_(self.tblAutoFields.mapToGlobal(position)) if action and action.objectName() == 'action': if not bLayers: self.msg.show( QApplication.translate( "AutoFieldsDockWidgetPy", "First load some vector layers to QGIS to be able to assign disabled AutoFields." ), 'warning' ) return autoFieldId = self.tblAutoFields.item( row, 0 ).data( Qt.UserRole ) bCalculateOnExisting = self.chkCalculateOnExisting.isChecked() dlg = AssignAutoFieldToLayerDialog( self.iface.mainWindow(), self.autoFieldManager, autoFieldId, bCalculateOnExisting ) dlg.show() def updateRemoveAutoFieldButton( self ): """ Enable/disable button to remove AutoFields when appropriate """ self.btnRemoveAutoFields.setEnabled( len( self.tblAutoFields.selectedItems() ) / 4 ) def removeAutoFieldFromTable( self ): """ Show a confirmation dialog for all AutoFields selected. If confirmed, remove AutoFields from table. """ # Column 0 has the AutoField id autoFieldsToRemove = [ item.data( Qt.UserRole ) for item in self.tblAutoFields.selectedItems() if item.column() == 0 ] reply = QMessageBox.question( self.iface.mainWindow(), QApplication.translate( "AutoFieldsDockWidgetPy", "Confirmation" ), QApplication.translate( "AutoFieldsDockWidgetPy", "Do you really want to remove " ) + \ str(len( autoFieldsToRemove )) + \ (" AutoFields?" if len( autoFieldsToRemove ) > 1 else " AutoField?"), QMessageBox.Yes | QMessageBox.No, QMessageBox.No ) if reply == QMessageBox.Yes: for autoFieldId in autoFieldsToRemove: self.autoFieldManager.removeAutoField( autoFieldId ) def saveShowOnlyEnabledPreference( self, status ): """ Saves the preference in QSettings and updates list of AutoFields """ settings = QSettings() settings.setValue( self.autoFieldManager.settingsPrefix + "/showOnlyEnabledAutoFields" , status ) self.populateAutoFieldsTable() def saveCalculateOnExistingPreference( self, status ): """ Saves the preference in QSettings """ settings = QSettings() settings.setValue( self.autoFieldManager.settingsPrefix + "/calculateOnExistingFeatures" , status ) def openDocumentation( self ): """ Open a browser to show documentation page """ import webbrowser webbrowser.open( "http://geotux.tuxfamily.org/index.php/"+ self.language +"/geo-blogs/item/333-autofields-plugin-for-qgis" ) def disconnectAll( self ): """ Terminates all SIGNAL/SLOT connections created by this class """ QgsMapLayerRegistry.instance().legendLayersAdded.disconnect( self.populateLayersTable ) QgsMapLayerRegistry.instance().layersRemoved.disconnect( self.populateLayersTable ) self.root.addedChildren.disconnect( self.populateLayersTable ) self.root.removedChildren.disconnect( self.populateLayersTable ) self.tblLayers.itemSelectionChanged.disconnect( self.updateFieldAndExpressionControls ) self.optNewField.toggled.disconnect( self.newFieldToggled ) self.cboField.currentIndexChanged.disconnect( self.fieldChanged ) self.cboFieldType.currentIndexChanged.disconnect( self.fieldTypeChanged ) self.btnSaveAutoField.clicked.disconnect( self.saveAutoField ) self.btnNewCustomExpression.clicked.disconnect( self.setCustomExpression ) self.btnGroup.buttonClicked.disconnect( self.updateExpressionControls ) self.autoFieldManager.autoFieldCreated.disconnect( self.populateAutoFieldsTable ) self.autoFieldManager.autoFieldRemoved.disconnect( self.populateAutoFieldsTable ) self.autoFieldManager.autoFieldEnabled.disconnect( self.populateAutoFieldsTable ) self.autoFieldManager.autoFieldDisabled.disconnect( self.populateAutoFieldsTable ) self.tblAutoFields.itemSelectionChanged.disconnect( self.updateRemoveAutoFieldButton ) self.chkOnlyEnabledAutoFields.toggled.disconnect( self.saveShowOnlyEnabledPreference ) self.btnRemoveAutoFields.clicked.disconnect( self.removeAutoFieldFromTable )
class FreeseerApp(QMainWindowWithDpi): def __init__(self, config): super(FreeseerApp, self).__init__() self.config = config self.icon = QIcon() self.icon.addPixmap(QPixmap(_fromUtf8(":/freeseer/logo.png")), QIcon.Normal, QIcon.Off) self.setWindowIcon(self.icon) self.aboutDialog = AboutDialog() self.aboutDialog.setModal(True) self.logDialog = LogDialog() # # Translator # self.app = QApplication.instance() self.current_language = None self.uiTranslator = QTranslator() self.uiTranslator.load(":/languages/tr_en_US.qm") self.app.installTranslator(self.uiTranslator) self.langActionGroup = QActionGroup(self) self.langActionGroup.setExclusive(True) QTextCodec.setCodecForTr(QTextCodec.codecForName('utf-8')) self.connect(self.langActionGroup, SIGNAL('triggered(QAction *)'), self.translate) # --- Translator # # Setup Menubar # self.menubar = self.menuBar() self.menubar.setGeometry(self.qrect_with_dpi(0, 0, 500, 50)) self.menubar.setObjectName(_fromUtf8("menubar")) self.menuFile = QMenu(self.menubar) self.menuFile.setObjectName(_fromUtf8("menuFile")) self.menuLanguage = QMenu(self.menubar) self.menuLanguage.setObjectName(_fromUtf8("menuLanguage")) self.menuHelp = QMenu(self.menubar) self.menuHelp.setObjectName(_fromUtf8("menuHelp")) exitIcon = QIcon.fromTheme("application-exit") self.actionExit = QAction(self) self.actionExit.setShortcut("Ctrl+Q") self.actionExit.setObjectName(_fromUtf8("actionExit")) self.actionExit.setIcon(exitIcon) helpIcon = QIcon.fromTheme("help-contents") self.actionOnlineHelp = QAction(self) self.actionOnlineHelp.setObjectName(_fromUtf8("actionOnlineHelp")) self.actionOnlineHelp.setIcon(helpIcon) self.actionAbout = QAction(self) self.actionAbout.setObjectName(_fromUtf8("actionAbout")) self.actionAbout.setIcon(self.icon) self.actionLog = QAction(self) self.actionLog.setObjectName(_fromUtf8("actionLog")) self.actionLog.setShortcut("Ctrl+L") # Actions self.menuFile.addAction(self.actionExit) self.menuHelp.addAction(self.actionAbout) self.menuHelp.addAction(self.actionLog) self.menuHelp.addAction(self.actionOnlineHelp) self.menubar.addAction(self.menuFile.menuAction()) self.menubar.addAction(self.menuLanguage.menuAction()) self.menubar.addAction(self.menuHelp.menuAction()) self.setupLanguageMenu() # --- End Menubar self.connect(self.actionExit, SIGNAL('triggered()'), self.close) self.connect(self.actionAbout, SIGNAL('triggered()'), self.aboutDialog.show) self.connect(self.actionLog, SIGNAL('triggered()'), self.logDialog.show) self.connect(self.actionOnlineHelp, SIGNAL('triggered()'), self.openOnlineHelp) self.retranslateFreeseerApp() self.aboutDialog.aboutWidget.retranslate("en_US") def openOnlineHelp(self): """Opens a link to the Freeseer Online Help""" url = QUrl("http://freeseer.readthedocs.org") QDesktopServices.openUrl(url) def translate(self, action): """Translates the GUI via menu action. When a language is selected from the language menu, this function is called and the language to be changed to is retrieved. """ self.current_language = str(action.data().toString()).strip("tr_").rstrip(".qm") log.info("Switching language to: %s" % action.text()) self.uiTranslator.load(":/languages/tr_%s.qm" % self.current_language) self.app.installTranslator(self.uiTranslator) self.retranslateFreeseerApp() self.aboutDialog.aboutWidget.retranslate(self.current_language) self.retranslate() self.logDialog.retranslate() def retranslate(self): """ Reimplement this function to provide translations to your app. """ pass def retranslateFreeseerApp(self): # # Menubar # self.menuFile.setTitle(self.app.translate("FreeseerApp", "&File")) self.menuLanguage.setTitle(self.app.translate("FreeseerApp", "&Language")) self.menuHelp.setTitle(self.app.translate("FreeseerApp", "&Help")) self.actionExit.setText(self.app.translate("FreeseerApp", "&Quit")) self.actionAbout.setText(self.app.translate("FreeseerApp", "&About")) self.actionLog.setText(self.app.translate("FreeseerApp", "View &Log")) self.actionOnlineHelp.setText(self.app.translate("FreeseerApp", "Online Documentation")) # --- Menubar def setupLanguageMenu(self): self.languages = QDir(":/languages").entryList() if self.current_language is None: self.current_language = QLocale.system().name() # Retrieve Current Locale from the operating system. log.debug("Detected user's locale as %s" % self.current_language) for language in self.languages: translator = QTranslator() # Create a translator to translate Language Display Text. translator.load(":/languages/%s" % language) language_display_text = translator.translate("Translation", "Language Display Text") languageAction = QAction(self) languageAction.setCheckable(True) languageAction.setText(language_display_text) languageAction.setData(language) self.menuLanguage.addAction(languageAction) self.langActionGroup.addAction(languageAction)
class Plugin: """The QGIS interface implementation for the Risk in a box plugin. This class acts as the 'glue' between QGIS and our custom logic. It creates a toolbar and menubar entry and launches the InaSAFE user interface if these are activated. """ def __init__(self, iface): """Class constructor. On instantiation, the plugin instance will be assigned a copy of the QGIS iface object which will allow this plugin to access and manipulate the running QGIS instance that spawned it. Args: iface - a Quantum GIS QGisAppInterface instance. This instance is automatically passed to the plugin by QGIS when it loads the plugin. Returns: None. Raises: no exceptions explicitly raised. """ # Save reference to the QGIS interface self.iface = iface self.translator = None self.setupI18n() #print self.tr('InaSAFE') utilities.setupLogger() #noinspection PyArgumentList def setupI18n(self, thePreferredLocale=None): """Setup internationalisation for the plugin. See if QGIS wants to override the system locale and then see if we can get a valid translation file for whatever locale is effectively being used. Args: thePreferredLocale - optional parameter which if set will override any other way of determining locale.. Returns: None. Raises: TranslationLoadException """ myOverrideFlag = QSettings().value( 'locale/overrideFlag', QVariant(False)).toBool() if thePreferredLocale is not None: myLocaleName = thePreferredLocale elif myOverrideFlag: myLocaleName = QSettings().value('locale/userLocale', QVariant('')).toString() else: myLocaleName = QLocale.system().name() # NOTES: we split the locale name because we need the first two # character i.e. 'id', 'af, etc myLocaleName = str(myLocaleName).split('_')[0] # Also set the system locale to the user overridden local # so that the inasafe library functions gettext will work # .. see:: :py:func:`common.utilities` os.environ['LANG'] = str(myLocaleName) LOGGER.debug('%s %s %s %s' % ( thePreferredLocale, myOverrideFlag, QLocale.system().name(), os.environ['LANG'])) myRoot = os.path.abspath(os.path.join(os.path.dirname(__file__), '..')) myTranslationPath = os.path.join( myRoot, 'safe_qgis', 'i18n', 'inasafe_' + str(myLocaleName) + '.qm') if os.path.exists(myTranslationPath): self.translator = QTranslator() myResult = self.translator.load(myTranslationPath) if not myResult: myMessage = 'Failed to load translation for %s' % myLocaleName raise TranslationLoadError(myMessage) QCoreApplication.installTranslator(self.translator) LOGGER.debug('%s %s' % ( myTranslationPath, os.path.exists(myTranslationPath))) def tr(self, theString): """We implement this ourself since we do not inherit QObject. Args: theString - string for translation. Returns: Translated version of theString. Raises: no exceptions explicitly raised. """ return QCoreApplication.translate('Plugin', theString) #noinspection PyCallByClass def initGui(self): """Gui initialisation procedure (for QGIS plugin api). This method is called by QGIS and should be used to set up any graphical user interface elements that should appear in QGIS by default (i.e. before the user performs any explicit action with the plugin). Args: None. Returns: None. Raises: no exceptions explicitly raised. """ # Import dock here as it needs to be imported AFTER i18n is set up from safe_qgis.dock import Dock self.dockWidget = None #-------------------------------------- # Create action for plugin dockable window (show/hide) #-------------------------------------- # pylint: disable=W0201 self.actionDock = QAction( QIcon(':/plugins/inasafe/icon.svg'), self.tr('Toggle InaSAFE Dock'), self.iface.mainWindow()) self.actionDock.setObjectName('InaSAFEDockToggle') self.actionDock.setStatusTip(self.tr( 'Show/hide InaSAFE dock widget')) self.actionDock.setWhatsThis(self.tr( 'Show/hide InaSAFE dock widget')) self.actionDock.setCheckable(True) self.actionDock.setChecked(True) QObject.connect( self.actionDock, SIGNAL('triggered()'), self.showHideDockWidget) # add to plugin toolbar self.iface.addToolBarIcon(self.actionDock) # add to plugin menu self.iface.addPluginToMenu( self.tr('InaSAFE'), self.actionDock) #-------------------------------------- # Create action for keywords editor #-------------------------------------- self.actionKeywordsDialog = QAction( QIcon(':/plugins/inasafe/show-keyword-editor.svg'), self.tr('InaSAFE Keyword Editor'), self.iface.mainWindow()) self.actionKeywordsDialog.setStatusTip(self.tr( 'Open InaSAFE keywords editor')) self.actionKeywordsDialog.setWhatsThis(self.tr( 'Open InaSAFE keywords editor')) self.actionKeywordsDialog.setEnabled(False) QObject.connect( self.actionKeywordsDialog, SIGNAL('triggered()'), self.showKeywordsEditor) self.iface.addToolBarIcon(self.actionKeywordsDialog) self.iface.addPluginToMenu( self.tr('InaSAFE'), self.actionKeywordsDialog) #-------------------------------------- # Create action for reset icon #-------------------------------------- self.actionResetDock = QAction( QIcon(':/plugins/inasafe/reset-dock.svg'), self.tr('Reset Dock'), self.iface.mainWindow()) self.actionResetDock.setStatusTip(self.tr( 'Reset the InaSAFE Dock')) self.actionResetDock.setWhatsThis(self.tr( 'Reset the InaSAFE Dock')) QObject.connect( self.actionResetDock, SIGNAL('triggered()'), self.resetDock) self.iface.addToolBarIcon(self.actionResetDock) self.iface.addPluginToMenu( self.tr('InaSAFE'), self.actionResetDock) #-------------------------------------- # Create action for options dialog #-------------------------------------- self.actionOptions = QAction( QIcon(':/plugins/inasafe/configure-inasafe.svg'), self.tr('InaSAFE Options'), self.iface.mainWindow()) self.actionOptions.setStatusTip(self.tr( 'Open InaSAFE options dialog')) self.actionOptions.setWhatsThis(self.tr( 'Open InaSAFE options dialog')) QObject.connect( self.actionOptions, SIGNAL('triggered()'), self.showOptions) self.iface.addToolBarIcon(self.actionOptions) self.iface.addPluginToMenu( self.tr('InaSAFE'), self.actionOptions) #-------------------------------------- # Create action for impact functions doc dialog #-------------------------------------- self.actionImpactFunctionsDoc = QAction( QIcon(':/plugins/inasafe/show-impact-functions.svg'), self.tr('InaSAFE Impact Functions Browser'), self.iface.mainWindow()) self.actionImpactFunctionsDoc.setStatusTip(self.tr( 'Open InaSAFE Impact Functions Browser')) self.actionImpactFunctionsDoc.setWhatsThis(self.tr( 'Open InaSAFE Impact Functions Browser')) QObject.connect( self.actionImpactFunctionsDoc, SIGNAL('triggered()'), self.showImpactFunctionsDoc) self.iface.addToolBarIcon(self.actionImpactFunctionsDoc) self.iface.addPluginToMenu(self.tr('InaSAFE'), self.actionImpactFunctionsDoc) # Short cut for Open Impact Functions Doc self.keyAction = QAction("Test Plugin", self.iface.mainWindow()) self.iface.registerMainWindowAction(self.keyAction, "F7") QObject.connect(self.keyAction, SIGNAL("triggered()"), self.keyActionF7) #--------------------------------------- # Create action for minimum needs dialog #--------------------------------------- self.actionMinimumNeeds = QAction( QIcon(':/plugins/inasafe/show-minimum-needs.svg'), self.tr('InaSAFE Minimum Needs Tool'), self.iface.mainWindow()) self.actionMinimumNeeds.setStatusTip(self.tr( 'Open InaSAFE minimum needs tool')) self.actionMinimumNeeds.setWhatsThis(self.tr( 'Open InaSAFE minimum needs tool')) QObject.connect(self.actionMinimumNeeds, SIGNAL('triggered()'), self.showMinimumNeeds) self.iface.addToolBarIcon(self.actionMinimumNeeds) self.iface.addPluginToMenu(self.tr('InaSAFE'), self.actionMinimumNeeds) #--------------------------------------- # Create action for converter dialog #--------------------------------------- self.actionConverter = QAction( QIcon(':/plugins/inasafe/show-minimum-needs.svg'), self.tr('InaSAFE Converter'), self.iface.mainWindow()) self.actionConverter.setStatusTip(self.tr( 'Open InaSAFE Converter')) self.actionConverter.setWhatsThis(self.tr( 'Open InaSAFE Converter')) QObject.connect(self.actionConverter, SIGNAL('triggered()'), self.showConverter) self.iface.addToolBarIcon(self.actionConverter) self.iface.addPluginToMenu(self.tr('InaSAFE'), self.actionConverter) #-------------------------------------- # Create action for import OSM Dialog #-------------------------------------- self.actionImportDlg = QAction( QIcon(':/plugins/inasafe/osm-download.png'), self.tr('InaSAFE OpenStreetMap Downloader'), self.iface.mainWindow()) self.actionImportDlg.setStatusTip(self.tr( 'InaSAFE OpenStreetMap Downloader')) self.actionImportDlg.setWhatsThis(self.tr( 'InaSAFE OpenStreetMap Downloader')) QObject.connect( self.actionImportDlg, SIGNAL('triggered()'), self.showImportDlg) self.iface.addToolBarIcon(self.actionImportDlg) self.iface.addPluginToMenu( self.tr('InaSAFE'), self.actionImportDlg) #-------------------------------------- # create dockwidget and tabify it with the legend #-------------------------------------- self.dockWidget = Dock(self.iface) self.iface.addDockWidget(Qt.RightDockWidgetArea, self.dockWidget) myLegendTab = self.iface.mainWindow().findChild(QApplication, 'Legend') if myLegendTab: self.iface.mainWindow().tabifyDockWidget( myLegendTab, self.dockWidget) self.dockWidget.raise_() # # Hook up a slot for when the current layer is changed # QObject.connect( self.iface, SIGNAL("currentLayerChanged(QgsMapLayer*)"), self.layerChanged) # # Hook up a slot for when the dock is hidden using its close button # or view-panels # QObject.connect( self.dockWidget, SIGNAL("visibilityChanged (bool)"), self.toggleActionDock) # pylint: disable=W0201 def unload(self): """Gui breakdown procedure (for QGIS plugin api). This method is called by QGIS and should be used to *remove* any graphical user interface elements that should appear in QGIS. Args: None. Returns: None. Raises: no exceptions explicitly raised. """ # Remove the plugin menu item and icon self.iface.removePluginMenu(self.tr('InaSAFE'), self.actionDock) self.iface.removeToolBarIcon(self.actionDock) self.iface.removePluginMenu(self.tr('InaSAFE'), self.actionKeywordsDialog) self.iface.removeToolBarIcon(self.actionKeywordsDialog) self.iface.removePluginMenu(self.tr('InaSAFE'), self.actionResetDock) self.iface.removeToolBarIcon(self.actionResetDock) self.iface.removePluginMenu(self.tr('InaSAFE'), self.actionOptions) self.iface.removeToolBarIcon(self.actionOptions) self.iface.removePluginMenu(self.tr('InaSAFE'), self.actionMinimumNeeds) self.iface.removeToolBarIcon(self.actionMinimumNeeds) self.iface.removePluginMenu(self.tr('InaSAFE'), self.actionImpactFunctionsDoc) self.iface.removeToolBarIcon(self.actionImpactFunctionsDoc) self.iface.mainWindow().removeDockWidget(self.dockWidget) self.dockWidget.setVisible(False) self.dockWidget.destroy() QObject.disconnect( self.iface, SIGNAL("currentLayerChanged(QgsMapLayer*)"), self.layerChanged) def toggleActionDock(self, checked): """check or uncheck the toggle inaSAFE toolbar button. This slot is called when the user hides the inaSAFE panel using its close button or using view->panels .. see also:: :func:`Plugin.initGui`. Args: checked - if actionDock has to be checked or not Returns: None. Raises: no exceptions explicitly raised. """ self.actionDock.setChecked(checked) # Run method that performs all the real work def showHideDockWidget(self): """Show or hide the dock widget. This slot is called when the user clicks the toolbar icon or menu item associated with this plugin. It will hide or show the dock depending on its current state. .. see also:: :func:`Plugin.initGui`. Args: None. Returns: None. Raises: no exceptions explicitly raised. """ if self.dockWidget.isVisible(): self.dockWidget.setVisible(False) else: self.dockWidget.setVisible(True) self.dockWidget.raise_() def showMinimumNeeds(self): """Show the minimum needs dialog. This slot is called when the user clicks the minimum needs toolbar icon or menu item associated with this plugin. .. see also:: :func:`Plugin.initGui`. Args: None. Returns: None. Raises: no exceptions explicitly raised. """ # import here only so that it is AFTER i18n set up from safe_qgis.minimum_needs import MinimumNeeds myDialog = MinimumNeeds(self.iface.mainWindow()) myDialog.show() def showOptions(self): """Show the options dialog. This slot is called when the user clicks the options toolbar icon or menu item associated with this plugin .. see also:: :func:`Plugin.initGui`. Args: None. Returns: None. Raises: no exceptions explicitly raised. """ # import here only so that it is AFTER i18n set up from safe_qgis.options_dialog import OptionsDialog myDialog = OptionsDialog( self.iface.mainWindow(), self.iface, self.dockWidget) myDialog.show() def showKeywordsEditor(self): """Show the keywords editor. This slot is called when the user clicks the keyword editor toolbar icon or menu item associated with this plugin .. see also:: :func:`Plugin.initGui`. Args: None. Returns: None. Raises: no exceptions explicitly raised. """ # import here only so that it is AFTER i18n set up from safe_qgis.keywords_dialog import KeywordsDialog if self.iface.activeLayer() is None: return myDialog = KeywordsDialog( self.iface.mainWindow(), self.iface, self.dockWidget) myDialog.setModal(True) myDialog.show() def showImpactFunctionsDoc(self): """Show the impact function doc This slot is called when the user clicks the impact functions toolbar icon or menu item associated with this plugin .. see also:: :func:`Plugin.initGui`. Args: None. Returns: None. Raises: no exceptions explicitly raised. """ # import here only so that it is AFTER i18n set up from safe_qgis.impact_functions_doc import ImpactFunctionsDoc myDialog = ImpactFunctionsDoc(self.iface.mainWindow()) myDialog.show() def showConverter(self): """Show the converter dialog. This slot is called when the user clicks the impact functions toolbar icon or menu item associated with this plugin .. see also:: :func:`Plugin.initGui`. Args: None. Returns: None. Raises: no exceptions explicitly raised. """ # import here only so that it is AFTER i18n set up from safe_qgis.converter_dialog import ConverterDialog myDialog = ConverterDialog(self.iface.mainWindow()) myDialog.show() def showImportDlg(self): from safe_qgis.import_dialog import ImportDialog dlg = ImportDialog(self.iface.mainWindow(), self.iface) dlg.setModal(True) dlg.show() def resetDock(self): """Reset the dock to its default state. This slot is called when the user clicks the reset icon in the toolbar or the reset menu item associated with this plugin .. see also:: :func:`Plugin.initGui`. Args: None. Returns: None. Raises: no exceptions explicitly raised. """ self.dockWidget.getLayers() def layerChanged(self, theLayer): """Enable or disable the keywords editor icon. This slot is called when the user clicks the keyword editor toolbar icon or menu item associated with this plugin .. see also:: :func:`Plugin.initGui`. Args: None. Returns: None. Raises: no exceptions explicitly raised. """ if theLayer is None: self.actionKeywordsDialog.setEnabled(False) else: self.actionKeywordsDialog.setEnabled(True) self.dockWidget.layerChanged(theLayer) def keyActionF7(self): '''Executed when user press F7''' self.showConverter()
class ProcessingPlugin: def __init__(self, iface): self.iface = iface def initGui(self): Processing.initialize() self.commander = None self.toolbox = ProcessingToolbox() self.iface.addDockWidget(Qt.RightDockWidgetArea, self.toolbox) self.toolbox.hide() Processing.addAlgListListener(self.toolbox) self.menu = QMenu(self.iface.mainWindow().menuBar()) self.menu.setObjectName('processing') self.menu.setTitle(self.tr('Pro&cessing')) self.toolboxAction = self.toolbox.toggleViewAction() self.toolboxAction.setObjectName('toolboxAction') self.toolboxAction.setIcon( QIcon(os.path.join(cmd_folder, 'images', 'alg.png'))) self.toolboxAction.setText(self.tr('&Toolbox')) self.iface.registerMainWindowAction(self.toolboxAction, 'Ctrl+Alt+T') self.menu.addAction(self.toolboxAction) self.modelerAction = QAction( QIcon(os.path.join(cmd_folder, 'images', 'model.png')), self.tr('Graphical &Modeler...'), self.iface.mainWindow()) self.modelerAction.setObjectName('modelerAction') self.modelerAction.triggered.connect(self.openModeler) self.iface.registerMainWindowAction(self.modelerAction, 'Ctrl+Alt+M') self.menu.addAction(self.modelerAction) self.historyAction = QAction( QIcon(os.path.join(cmd_folder, 'images', 'history.gif')), self.tr('&History...'), self.iface.mainWindow()) self.historyAction.setObjectName('historyAction') self.historyAction.triggered.connect(self.openHistory) self.iface.registerMainWindowAction(self.historyAction, 'Ctrl+Alt+H') self.menu.addAction(self.historyAction) self.configAction = QAction( QIcon(os.path.join(cmd_folder, 'images', 'config.png')), self.tr('&Options...'), self.iface.mainWindow()) self.configAction.setObjectName('configAction') self.configAction.triggered.connect(self.openConfig) self.iface.registerMainWindowAction(self.configAction, 'Ctrl+Alt+C') self.menu.addAction(self.configAction) self.resultsAction = QAction( QIcon(os.path.join(cmd_folder, 'images', 'results.png')), self.tr('&Results Viewer...'), self.iface.mainWindow()) self.resultsAction.setObjectName('resultsAction') self.resultsAction.triggered.connect(self.openResults) self.iface.registerMainWindowAction(self.resultsAction, 'Ctrl+Alt+R') self.menu.addAction(self.resultsAction) menuBar = self.iface.mainWindow().menuBar() menuBar.insertMenu( self.iface.firstRightStandardMenu().menuAction(), self.menu) self.commanderAction = QAction( QIcon(os.path.join(cmd_folder, 'images', 'commander.png')), self.tr('&Commander'), self.iface.mainWindow()) self.commanderAction.setObjectName('commanderAction') self.commanderAction.triggered.connect(self.openCommander) self.menu.addAction(self.commanderAction) self.iface.registerMainWindowAction(self.commanderAction, self.tr('Ctrl+Alt+M')) def unload(self): self.toolbox.setVisible(False) self.menu.deleteLater() # delete temporary output files folder = tempFolder() if QDir(folder).exists(): shutil.rmtree(folder, True) self.iface.unregisterMainWindowAction(self.commanderAction) def openCommander(self): if self.commander is None: self.commander = CommanderWindow( self.iface.mainWindow(), self.iface.mapCanvas()) Processing.addAlgListListener(self.commander) self.commander.prepareGui() self.commander.show() def openToolbox(self): if self.toolbox.isVisible(): self.toolbox.hide() else: self.toolbox.show() def openModeler(self): dlg = ModelerDialog() dlg.show() dlg.exec_() if dlg.update: self.toolbox.updateProvider('model') def openResults(self): dlg = ResultsDialog() dlg.show() dlg.exec_() def openHistory(self): dlg = HistoryDialog() dlg.exec_() def openConfig(self): dlg = ConfigDialog(self.toolbox) dlg.exec_() def tr(self, message): return QCoreApplication.translate('ProcessingPlugin', message)
class TalkEditorApp(FreeseerApp): '''Freeseer talk database editor main gui class''' def __init__(self, config, db): FreeseerApp.__init__(self) self.config = config self.db = db icon = QIcon() icon.addPixmap(QPixmap(':/freeseer/logo.png'), QIcon.Normal, QIcon.Off) self.setWindowIcon(icon) self.resize(960, 600) # # Setup Layout # self.mainWidget = QWidget() self.mainLayout = QVBoxLayout() self.mainWidget.setLayout(self.mainLayout) self.setCentralWidget(self.mainWidget) self.mainLayout.setAlignment(Qt.AlignTop) # Add custom widgets self.commandButtons = CommandButtons() self.tableView = QTableView() self.tableView.setSortingEnabled(True) self.tableView.setSelectionBehavior(QAbstractItemView.SelectRows) self.talkDetailsWidget = TalkDetailsWidget() self.importTalksWidget = ImportTalksWidget() self.newTalkWidget = NewTalkWidget() self.mainLayout.addWidget(self.importTalksWidget) #self.mainLayout.addLayout(self.titleLayout) self.mainLayout.addWidget(self.commandButtons) self.mainLayout.addWidget(self.tableView) self.mainLayout.addWidget(self.talkDetailsWidget) self.mainLayout.addWidget(self.importTalksWidget) # --- End Layout # Initialize geometry, to be used for restoring window positioning. self.geometry = None # # Setup Menubar # self.actionExportCsv = QAction(self) self.actionExportCsv.setObjectName('actionExportCsv') self.actionRemoveAll = QAction(self) self.actionRemoveAll.setObjectName('actionRemoveAll') # Actions self.menuFile.insertAction(self.actionExit, self.actionExportCsv) self.menuFile.insertAction(self.actionExit, self.actionRemoveAll) # --- End Menubar # # TableView Connections # self.connect(self.tableView, SIGNAL('activated(const QModelIndex)'), self.talk_selected) self.connect(self.tableView, SIGNAL('selected(const QModelIndex)'), self.talk_selected) self.connect(self.tableView, SIGNAL('clicked(const QModelIndex)'), self.talk_selected) # Import Widget self.connect(self.importTalksWidget.csvRadioButton, SIGNAL('toggled(bool)'), self.toggle_import) self.connect(self.importTalksWidget.importButton, SIGNAL('clicked()'), self.import_talks) self.connect(self.importTalksWidget.cancelButton, SIGNAL('clicked()'), self.hide_import_talks_widget) self.importTalksWidget.setHidden(True) self.connect(self.importTalksWidget.csvFileSelectButton, SIGNAL('clicked()'), self.csv_file_select) self.connect(self.importTalksWidget.csvLineEdit, SIGNAL('returnPressed()'), self.importTalksWidget.importButton.click) self.connect(self.importTalksWidget.rssLineEdit, SIGNAL('returnPressed()'), self.importTalksWidget.importButton.click) self.connect(self.actionExportCsv, SIGNAL('triggered()'), self.export_talks_to_csv) self.connect(self.actionRemoveAll, SIGNAL('triggered()'), self.confirm_reset) # Command Buttons self.connect(self.commandButtons.addButton, SIGNAL('clicked()'), self.show_new_talk_popup) self.connect(self.commandButtons.removeButton, SIGNAL('clicked()'), self.remove_talk) self.connect(self.commandButtons.removeAllButton, SIGNAL('clicked()'), self.confirm_reset) self.connect(self.commandButtons.importButton, SIGNAL('clicked()'), self.show_import_talks_widget) self.connect(self.commandButtons.exportButton, SIGNAL('clicked()'), self.export_talks_to_csv) self.connect(self.commandButtons.searchButton, SIGNAL('clicked()'), self.search_talks) self.connect(self.commandButtons.searchLineEdit, SIGNAL('textEdited(QString)'), self.search_talks) self.connect(self.commandButtons.searchLineEdit, SIGNAL('returnPressed()'), self.search_talks) # Talk Details Buttons self.connect(self.talkDetailsWidget.saveButton, SIGNAL('clicked()'), self.update_talk) # Talk Details Widget self.connect(self.talkDetailsWidget.titleLineEdit, SIGNAL('textEdited(const QString)'), self.enable_save) self.connect(self.talkDetailsWidget.presenterLineEdit, SIGNAL('textEdited(const QString)'), self.enable_save) self.connect(self.talkDetailsWidget.categoryLineEdit, SIGNAL('textEdited(const QString)'), self.enable_save) self.connect(self.talkDetailsWidget.eventLineEdit, SIGNAL('textEdited(const QString)'), self.enable_save) self.connect(self.talkDetailsWidget.roomLineEdit, SIGNAL('textEdited(const QString)'), self.enable_save) self.connect(self.talkDetailsWidget.descriptionTextEdit, SIGNAL('modificationChanged(bool)'), self.enable_save) self.connect(self.talkDetailsWidget.dateEdit, SIGNAL('dateChanged(const QDate)'), self.enable_save) self.connect(self.talkDetailsWidget.startTimeEdit, SIGNAL('timeChanged(const QTime)'), self.enable_save) self.connect(self.talkDetailsWidget.endTimeEdit, SIGNAL('timeChanged(const QTime)'), self.enable_save) # New Talk Widget self.newTalkWidget.connect(self.newTalkWidget.addButton, SIGNAL('clicked()'), self.add_talk) self.newTalkWidget.connect(self.newTalkWidget.cancelButton, SIGNAL('clicked()'), self.newTalkWidget.reject) # Load default language actions = self.menuLanguage.actions() for action in actions: if action.data().toString() == self.config.default_language: action.setChecked(True) self.translate(action) break # Load Talk Database self.load_presentations_model() # Setup Autocompletion self.update_autocomplete_fields() self.talkDetailsWidget.saveButton.setEnabled(False) # Select first item #self.tableView.setCurrentIndex(self.proxy.index(0,0)) #self.talk_selected(self.proxy.index(0,0)) # # Translation # def retranslate(self): self.setWindowTitle(self.app.translate("TalkEditorApp", "Freeseer Talk Editor")) # # Reusable Strings # self.confirmDBClearTitleString = self.app.translate("TalkEditorApp", "Remove All Talks from Database") self.confirmDBClearQuestionString = self.app.translate("TalkEditorApp", "Are you sure you want to clear the DB?") self.confirmTalkDetailsClearTitleString = self.app.translate("TalkEditorApp", "Unsaved Data") self.confirmTalkDetailsClearQuestionString = self.app.translate("TalkEditorApp", "Unsaved talk details will be lost. Continue?") # --- End Reusable Strings # # Menubar # self.actionExportCsv.setText(self.app.translate("TalkEditorApp", "&Export to CSV")) self.actionRemoveAll.setText(self.app.translate("TalkEditorApp", "&Remove All Talks")) # --- End Menubar # # TalkDetailsWidget # self.talkDetailsWidget.titleLabel.setText(self.app.translate("TalkEditorApp", "Title")) self.talkDetailsWidget.presenterLabel.setText(self.app.translate("TalkEditorApp", "Presenter")) self.talkDetailsWidget.categoryLabel.setText(self.app.translate("TalkEditorApp", "Category")) self.talkDetailsWidget.eventLabel.setText(self.app.translate("TalkEditorApp", "Event")) self.talkDetailsWidget.roomLabel.setText(self.app.translate("TalkEditorApp", "Room")) self.talkDetailsWidget.dateLabel.setText(self.app.translate("TalkEditorApp", "Date")) self.talkDetailsWidget.startTimeLabel.setText(self.app.translate("TalkEditorApp", "Start Time")) self.talkDetailsWidget.endTimeLabel.setText(self.app.translate("TalkEditorApp", "End Time")) # --- End TalkDetailsWidget # # Import Talks Widget Translations # self.importTalksWidget.rssRadioButton.setText(self.app.translate("TalkEditorApp", "RSS URL")) self.importTalksWidget.csvRadioButton.setText(self.app.translate("TalkEditorApp", "CSV File")) self.importTalksWidget.importButton.setText(self.app.translate("TalkEditorApp", "Import")) # --- End Talks Widget Translations # # Command Button Translations\ # self.commandButtons.importButton.setText(self.app.translate("TalkEditorApp", "Import")) self.commandButtons.exportButton.setText(self.app.translate("TalkEditorApp", "Export")) self.commandButtons.addButton.setText(self.app.translate("TalkEditorApp", "Add New Talk")) self.commandButtons.removeButton.setText(self.app.translate("TalkEditorApp", "Remove")) self.commandButtons.removeAllButton.setText(self.app.translate("TalkEditorApp", "Remove All")) # --- End Command Butotn Translations # # Search Widget Translations # self.commandButtons.searchButton.setText(self.app.translate("TalkEditorApp", "Search")) # --- End Command Button Translations def load_presentations_model(self): # Load Presentation Model self.presentationModel = self.db.get_presentations_model() self.proxy = QSortFilterProxyModel() self.proxy.setSourceModel(self.presentationModel) self.tableView.setModel(self.proxy) self.proxy.setFilterCaseSensitivity(Qt.CaseInsensitive) # Fill table whitespace. self.tableView.horizontalHeader().setStretchLastSection(False) self.tableView.horizontalHeader().setResizeMode(1, QHeaderView.Stretch) # Hide the ID field self.tableView.setColumnHidden(0, True) # Map data to widgets self.mapper = QDataWidgetMapper() self.mapper.setModel(self.proxy) self.mapper.setSubmitPolicy(QDataWidgetMapper.ManualSubmit) self.mapper.addMapping(self.talkDetailsWidget.titleLineEdit, 1) self.mapper.addMapping(self.talkDetailsWidget.presenterLineEdit, 2) self.mapper.addMapping(self.talkDetailsWidget.categoryLineEdit, 4) self.mapper.addMapping(self.talkDetailsWidget.eventLineEdit, 5) self.mapper.addMapping(self.talkDetailsWidget.roomLineEdit, 6) self.mapper.addMapping(self.talkDetailsWidget.descriptionTextEdit, 3) self.mapper.addMapping(self.talkDetailsWidget.dateEdit, 7) self.mapper.addMapping(self.talkDetailsWidget.startTimeEdit, 8) self.mapper.addMapping(self.talkDetailsWidget.endTimeEdit, 9) # Load StringLists self.titleList = QStringList(self.db.get_string_list("Title")) #self.speakerList = QStringList(self.db.get_speaker_list()) #self.categoryList = QStringList(self.db.get_category_list()) #self.eventList = QStringList(self.db.get_event_list()) #self.roomList = QStringList(self.db.get_room_list()) #Disble input self.talkDetailsWidget.disable_input_fields() def search_talks(self): # The default value is 0. If the value is -1, the keys will be read from all columns. self.proxy.setFilterKeyColumn(-1) self.proxy.setFilterFixedString(self.commandButtons.searchLineEdit.text()) def talk_selected(self, model): self.mapper.setCurrentIndex(model.row()) self.talkDetailsWidget.enable_input_fields() self.talkDetailsWidget.saveButton.setEnabled(False) def toggle_import(self): if self.importTalksWidget.csvRadioButton.isChecked(): self.importTalksWidget.csvLineEdit.setEnabled(True) self.importTalksWidget.csvFileSelectButton.setEnabled(True) self.importTalksWidget.rssLineEdit.setEnabled(False) else: self.importTalksWidget.csvLineEdit.setEnabled(False) self.importTalksWidget.csvFileSelectButton.setEnabled(False) self.importTalksWidget.rssLineEdit.setEnabled(True) def show_import_talks_widget(self): self.commandButtons.setHidden(True) self.tableView.setHidden(True) self.talkDetailsWidget.setHidden(True) self.importTalksWidget.setHidden(False) def hide_import_talks_widget(self): self.commandButtons.setHidden(False) self.tableView.setHidden(False) self.talkDetailsWidget.setHidden(False) self.importTalksWidget.setHidden(True) def add_talk(self): """Adds a new talk to the database using data from the NewTalkWidget input fields""" presentation = self.create_presentation(self.newTalkWidget.talkDetailsWidget) if presentation: self.db.insert_presentation(presentation) self.newTalkWidget.accept() # Close the dialog def update_talk(self): """Updates the currently selected talk using data from the TalkEditorApp input fields""" selected_talk = self.tableView.currentIndex() if selected_talk.row() >= 0: # The tableView index begins at 0 and is -1 by default talk_id = selected_talk.sibling(selected_talk.row(), 0).data().toString() presentation = self.create_presentation(self.talkDetailsWidget) if presentation: self.db.update_presentation(talk_id, presentation) self.apply_changes(selected_talk) self.talkDetailsWidget.saveButton.setEnabled(False) def create_presentation(self, talkDetailsWidget): """Creates and returns an instance of Presentation using data from the input fields""" date = talkDetailsWidget.dateEdit.date() startTime = talkDetailsWidget.startTimeEdit.time() endTime = talkDetailsWidget.endTimeEdit.time() title = unicode(talkDetailsWidget.titleLineEdit.text()).strip() if title: return Presentation( unicode(talkDetailsWidget.titleLineEdit.text()).strip(), unicode(talkDetailsWidget.presenterLineEdit.text()).strip(), unicode(talkDetailsWidget.descriptionTextEdit.toPlainText()).strip(), unicode(talkDetailsWidget.categoryLineEdit.text()).strip(), unicode(talkDetailsWidget.eventLineEdit.text()).strip(), unicode(talkDetailsWidget.roomLineEdit.text()).strip(), unicode(date.toString(Qt.ISODate)), unicode(startTime.toString(Qt.ISODate)), unicode(endTime.toString(Qt.ISODate))) def show_new_talk_popup(self): """Displays a modal dialog with a talk details view When Add is selected, a new talk is added to the database using the input field data. When Cancel is selected, no talk is added. """ log.info('Opening Add Talk window...') self.clear_new_talk_fields() self.remove_new_talk_placeholder_text() self.newTalkWidget.talkDetailsWidget.titleLineEdit.setFocus() if self.newTalkWidget.exec_() == 1: self.apply_changes() self.talkDetailsWidget.disable_input_fields() else: log.info('No talk added...') def apply_changes(self, updated_talk=None): """Repopulates the model to display the effective changes Updates the autocomplete fields. Displays the updated model in the table view, and selects the newly updated/added talk. """ self.presentationModel.select() self.select_talk(updated_talk) self.update_autocomplete_fields() def select_talk(self, talk=None): """Selects the given talk in the table view If no talk is given, the last row in the table view is selected. """ if talk: row = talk.row() column = talk.column() else: row = self.presentationModel.rowCount() - 1 # Select last row column = 0 self.tableView.selectRow(row) self.tableView.setCurrentIndex(self.proxy.index(row, column)) self.talk_selected(self.proxy.index(row, column)) def remove_talk(self): try: rows_selected = self.tableView.selectionModel().selectedRows() except: return # Reversed because rows in list change position once row is removed for row in reversed(rows_selected): self.presentationModel.removeRow(row.row()) def load_talk(self): try: self.tableView.currentIndex().row() except: return self.mapper.addMapping(self.talkDetailsWidget.roomLineEdit, 6) self.presentationModel.select() def reset(self): self.db.clear_database() self.presentationModel.select() def confirm_reset(self): """Presents a confirmation dialog to ask the user if they are sure they wish to remove the talk database. If Yes call the reset() function""" confirm = QMessageBox.question(self, self.confirmDBClearTitleString, self.confirmDBClearQuestionString, QMessageBox.Yes | QMessageBox.No, QMessageBox.No) if confirm == QMessageBox.Yes: self.reset() def add_talks_from_rss(self): rss_url = unicode(self.importTalksWidget.rssLineEdit.text()) if rss_url: self.db.add_talks_from_rss(rss_url) self.presentationModel.select() self.hide_import_talks_widget() else: error = QMessageBox() error.setText("Please enter a RSS URL") error.exec_() def closeEvent(self, event): log.info('Exiting talk database editor...') self.geometry = self.saveGeometry() event.accept() def csv_file_select(self): fname = QFileDialog.getOpenFileName( self, 'Select file', "", "*.csv") if fname: self.importTalksWidget.csvLineEdit.setText(fname) def add_talks_from_csv(self): fname = self.importTalksWidget.csvLineEdit.text() if fname: self.db.add_talks_from_csv(fname) self.presentationModel.select() self.hide_import_talks_widget() else: error = QMessageBox() error.setText("Please select a file") error.exec_() def import_talks(self): if self.importTalksWidget.csvRadioButton.isChecked(): self.add_talks_from_csv() else: self.add_talks_from_rss() self.update_autocomplete_fields() def export_talks_to_csv(self): fname = QFileDialog.getSaveFileName(self, 'Select file', "", "*.csv") if fname: self.db.export_talks_to_csv(fname) def update_autocomplete_fields(self): self.titleList = QStringList(self.db.get_string_list("Title")) self.speakerList = QStringList(self.db.get_string_list("Speaker")) self.categoryList = QStringList(self.db.get_string_list("Category")) self.eventList = QStringList(self.db.get_string_list("Event")) self.roomList = QStringList(self.db.get_string_list("Room")) self.titleCompleter = QCompleter(self.titleList) self.titleCompleter.setCaseSensitivity(Qt.CaseInsensitive) self.speakerCompleter = QCompleter(self.speakerList) self.speakerCompleter.setCaseSensitivity(Qt.CaseInsensitive) self.categoryCompleter = QCompleter(self.categoryList) self.categoryCompleter.setCaseSensitivity(Qt.CaseInsensitive) self.eventCompleter = QCompleter(self.eventList) self.eventCompleter.setCaseSensitivity(Qt.CaseInsensitive) self.roomCompleter = QCompleter(self.roomList) self.roomCompleter.setCaseSensitivity(Qt.CaseInsensitive) self.talkDetailsWidget.titleLineEdit.setCompleter(self.titleCompleter) self.talkDetailsWidget.presenterLineEdit.setCompleter(self.speakerCompleter) self.talkDetailsWidget.categoryLineEdit.setCompleter(self.categoryCompleter) self.talkDetailsWidget.eventLineEdit.setCompleter(self.eventCompleter) self.talkDetailsWidget.roomLineEdit.setCompleter(self.roomCompleter) def are_fields_enabled(self): return (self.talkDetailsWidget.titleLineEdit.isEnabled() and self.talkDetailsWidget.presenterLineEdit.isEnabled() and self.talkDetailsWidget.categoryLineEdit.isEnabled() and self.talkDetailsWidget.eventLineEdit.isEnabled() and self.talkDetailsWidget.roomLineEdit.isEnabled() and self.talkDetailsWidget.dateEdit.isEnabled() and self.talkDetailsWidget.startTimeEdit.isEnabled() and self.talkDetailsWidget.endTimeEdit.isEnabled()) def unsaved_details_exist(self): """Checks if changes have been made to new/existing talk details Looks for text in the input fields and check the enabled state of the Save Talk button If the Save Talk button is enabled, the input fields contain modified values """ return (self.talkDetailsWidget.saveButton.isEnabled() and (self.talkDetailsWidget.titleLineEdit.text() or self.talkDetailsWidget.presenterLineEdit.text() or self.talkDetailsWidget.categoryLineEdit.text() or self.talkDetailsWidget.descriptionTextEdit.toPlainText())) def enable_save(self): self.talkDetailsWidget.saveButton.setEnabled(True) def clear_new_talk_fields(self): """Removes existing data from all NewTalkWidget fields except event, room, date and time""" self.newTalkWidget.talkDetailsWidget.titleLineEdit.clear() self.newTalkWidget.talkDetailsWidget.presenterLineEdit.clear() self.newTalkWidget.talkDetailsWidget.descriptionTextEdit.clear() self.newTalkWidget.talkDetailsWidget.categoryLineEdit.clear() def remove_new_talk_placeholder_text(self): """Removes placeholder text in NewTalkWidget originally set by TalkDetailsWidget""" self.newTalkWidget.talkDetailsWidget.titleLineEdit.setPlaceholderText("") self.newTalkWidget.talkDetailsWidget.presenterLineEdit.setPlaceholderText("") self.newTalkWidget.talkDetailsWidget.categoryLineEdit.setPlaceholderText("") self.newTalkWidget.talkDetailsWidget.eventLineEdit.setPlaceholderText("") self.newTalkWidget.talkDetailsWidget.roomLineEdit.setPlaceholderText("")
class fToolsPlugin: def __init__(self, iface): self.iface = iface try: self.QgisVersion = unicode(QGis.QGIS_VERSION_INT) except: self.QgisVersion = unicode(QGis.qgisVersion)[0] def getThemeIcon(self, icon): settings = QSettings() pluginPath = os.path.dirname(__file__) themePath = "icons" + QDir.separator() + settings.value( "/Themes", "default") + QDir.separator() + icon defaultPath = "icons" + QDir.separator() + "default" + QDir.separator( ) + icon if QFile.exists(pluginPath + QDir.separator() + themePath): return QIcon(":" + themePath) elif QFile.exists(pluginPath + QDir.separator() + defaultPath): return QIcon(":" + defaultPath) else: return QIcon() def updateThemeIcons(self, theme): self.analysisMenu.setIcon(QIcon(self.getThemeIcon("analysis.png"))) self.distMatrix.setIcon(QIcon(self.getThemeIcon("matrix.png"))) self.sumLines.setIcon(QIcon(self.getThemeIcon("sum_lines.png"))) self.pointsPoly.setIcon(QIcon(self.getThemeIcon("sum_points.png"))) self.compStats.setIcon(QIcon( self.getThemeIcon("basic_statistics.png"))) self.listUnique.setIcon(QIcon(self.getThemeIcon("unique.png"))) self.nearestNeigh.setIcon(QIcon(self.getThemeIcon("neighbour.png"))) self.meanCoords.setIcon(QIcon(self.getThemeIcon("mean.png"))) self.intLines.setIcon(QIcon(self.getThemeIcon("intersections.png"))) self.researchMenu.setIcon(QIcon(self.getThemeIcon("sampling.png"))) self.randSel.setIcon(QIcon(self.getThemeIcon("random_selection.png"))) self.randSub.setIcon(QIcon(self.getThemeIcon("sub_selection.png"))) self.randPoints.setIcon(QIcon(self.getThemeIcon("random_points.png"))) self.regPoints.setIcon(QIcon(self.getThemeIcon("regular_points.png"))) self.vectGrid.setIcon(QIcon(self.getThemeIcon("vector_grid.png"))) self.selectLocation.setIcon( QIcon(self.getThemeIcon("select_location.png"))) self.layerExtent.setIcon(QIcon(self.getThemeIcon("layer_extent.png"))) self.geoMenu.setIcon(QIcon(self.getThemeIcon("geoprocessing.png"))) self.minConvex.setIcon(QIcon(self.getThemeIcon("convex_hull.png"))) self.dynaBuffer.setIcon(QIcon(self.getThemeIcon("buffer.png"))) self.intersect.setIcon(QIcon(self.getThemeIcon("intersect.png"))) self.union.setIcon(QIcon(self.getThemeIcon("union.png"))) self.symDifference.setIcon( QIcon(self.getThemeIcon("sym_difference.png"))) self.clip.setIcon(QIcon(self.getThemeIcon("clip.png"))) self.dissolve.setIcon(QIcon(self.getThemeIcon("dissolve.png"))) self.erase.setIcon(QIcon(self.getThemeIcon("difference.png"))) self.eliminate.setIcon(QIcon(self.getThemeIcon("eliminate.png"))) self.conversionMenu.setIcon(QIcon(self.getThemeIcon("geometry.png"))) self.compGeo.setIcon(QIcon(self.getThemeIcon("export_geometry.png"))) self.checkGeom.setIcon(QIcon(self.getThemeIcon("check_geometry.png"))) self.centroids.setIcon(QIcon(self.getThemeIcon("centroids.png"))) self.delaunay.setIcon(QIcon(self.getThemeIcon("delaunay.png"))) self.voronoi.setIcon(QIcon(self.getThemeIcon("voronoi.png"))) self.extNodes.setIcon(QIcon(self.getThemeIcon("extract_nodes.png"))) self.simplify.setIcon(QIcon(self.getThemeIcon("simplify.png"))) self.densify.setIcon(QIcon(self.getThemeIcon("densify.png"))) self.multiToSingle.setIcon( QIcon(self.getThemeIcon("multi_to_single.png"))) self.singleToMulti.setIcon( QIcon(self.getThemeIcon("single_to_multi.png"))) self.polysToLines.setIcon(QIcon(self.getThemeIcon("to_lines.png"))) self.linesToPolys.setIcon(QIcon(self.getThemeIcon("to_lines.png"))) self.dataManageMenu.setIcon(QIcon(self.getThemeIcon("management.png"))) self.define.setIcon(QIcon(self.getThemeIcon("define_projection.png"))) self.spatJoin.setIcon(QIcon(self.getThemeIcon("join_location.png"))) self.splitVect.setIcon(QIcon(self.getThemeIcon("split_layer.png"))) self.mergeShapes.setIcon(QIcon(self.getThemeIcon("merge_shapes.png"))) self.spatialIndex.setIcon(QIcon( self.getThemeIcon("spatial_index.png"))) def initGui(self): if int(self.QgisVersion) < 1: QMessageBox.warning( self.iface.getMainWindow(), "fTools", QCoreApplication.translate("fTools", "QGIS version detected: ") + unicode(self.QgisVersion) + ".xx\n" + QCoreApplication.translate( "fTools", "This version of fTools requires at least QGIS version 1.0.0\nPlugin will not be enabled." )) return None QObject.connect(self.iface, SIGNAL("currentThemeChanged (QString)"), self.updateThemeIcons) self.analysisMenu = QMenu( QCoreApplication.translate("fTools", "&Analysis Tools")) self.analysisMenu.setObjectName("analysisMenu") self.distMatrix = QAction( QCoreApplication.translate("fTools", "Distance Matrix..."), self.iface.mainWindow()) self.distMatrix.setObjectName("distMatrix") self.sumLines = QAction( QCoreApplication.translate("fTools", "Sum Line Lengths..."), self.iface.mainWindow()) self.sumLines.setObjectName("sumLines") self.pointsPoly = QAction( QCoreApplication.translate("fTools", "Points in Polygon..."), self.iface.mainWindow()) self.pointsPoly.setObjectName("pointsPoly") self.compStats = QAction( QCoreApplication.translate("fTools", "Basic Statistics..."), self.iface.mainWindow()) self.compStats.setObjectName("compStats") self.listUnique = QAction( QCoreApplication.translate("fTools", "List Unique Values..."), self.iface.mainWindow()) self.listUnique.setObjectName("listUnique") self.nearestNeigh = QAction( QCoreApplication.translate("fTools", "Nearest Neighbour Analysis..."), self.iface.mainWindow()) self.nearestNeigh.setObjectName("nearestNeigh") self.meanCoords = QAction( QCoreApplication.translate("fTools", "Mean Coordinate(s)..."), self.iface.mainWindow()) self.meanCoords.setObjectName("meanCoords") self.intLines = QAction( QCoreApplication.translate("fTools", "Line Intersections..."), self.iface.mainWindow()) self.intLines.setObjectName("intLines") self.analysisMenu.addActions([ self.distMatrix, self.sumLines, self.pointsPoly, self.listUnique, self.compStats, self.nearestNeigh, self.meanCoords, self.intLines ]) self.researchMenu = QMenu( QCoreApplication.translate("fTools", "&Research Tools")) self.researchMenu.setObjectName("researchMenu") self.randSel = QAction( QCoreApplication.translate("fTools", "Random Selection..."), self.iface.mainWindow()) self.randSel.setObjectName("randSel") self.randSub = QAction( QCoreApplication.translate("fTools", "Random Selection Within Subsets..."), self.iface.mainWindow()) self.randSub.setObjectName("randSub") self.randPoints = QAction( QCoreApplication.translate("fTools", "Random Points..."), self.iface.mainWindow()) self.randPoints.setObjectName("randPoints") self.regPoints = QAction( QCoreApplication.translate("fTools", "Regular Points..."), self.iface.mainWindow()) self.regPoints.setObjectName("regPoints") self.vectGrid = QAction( QCoreApplication.translate("fTools", "Vector Grid..."), self.iface.mainWindow()) self.vectGrid.setObjectName("vectGrid") self.selectLocation = QAction( QCoreApplication.translate("fTools", "Select by Location..."), self.iface.mainWindow()) self.selectLocation.setObjectName("selectLocation") self.layerExtent = QAction( QCoreApplication.translate("fTools", "Polygon from Layer Extent..."), self.iface.mainWindow()) self.layerExtent.setObjectName("layerExtent") self.researchMenu.addActions([ self.randSel, self.randSub, self.randPoints, self.regPoints, self.vectGrid, self.selectLocation, self.layerExtent ]) self.geoMenu = QMenu( QCoreApplication.translate("fTools", "&Geoprocessing Tools")) self.geoMenu.setObjectName("geoMenu") self.minConvex = QAction( QCoreApplication.translate("fTools", "Convex Hull(s)..."), self.iface.mainWindow()) self.minConvex.setObjectName("minConvex") self.dynaBuffer = QAction( QCoreApplication.translate("fTools", "Buffer(s)..."), self.iface.mainWindow()) self.dynaBuffer.setObjectName("dynaBuffer") self.intersect = QAction( QCoreApplication.translate("fTools", "Intersect..."), self.iface.mainWindow()) self.intersect.setObjectName("intersect") self.union = QAction(QCoreApplication.translate("fTools", "Union..."), self.iface.mainWindow()) self.union.setObjectName("union") self.symDifference = QAction( QCoreApplication.translate("fTools", "Symetrical Difference..."), self.iface.mainWindow()) self.symDifference.setObjectName("symDifference") self.clip = QAction(QCoreApplication.translate("fTools", "Clip..."), self.iface.mainWindow()) self.clip.setObjectName("clip") self.dissolve = QAction( QCoreApplication.translate("fTools", "Dissolve..."), self.iface.mainWindow()) self.dissolve.setObjectName("dissolve") self.erase = QAction( QCoreApplication.translate("fTools", "Difference..."), self.iface.mainWindow()) self.erase.setObjectName("erase") self.eliminate = QAction( QCoreApplication.translate("fTools", "Eliminate Sliver Polygons..."), self.iface.mainWindow()) self.eliminate.setObjectName("eliminate") self.geoMenu.addActions([ self.minConvex, self.dynaBuffer, self.intersect, self.union, self.symDifference, self.clip, self.erase, self.dissolve, self.eliminate ]) self.conversionMenu = QMenu( QCoreApplication.translate("fTools", "G&eometry Tools")) self.conversionMenu.setObjectName("conversionMenu") self.compGeo = QAction( QCoreApplication.translate("fTools", "Export/Add Geometry Columns..."), self.iface.mainWindow()) self.compGeo.setObjectName("compGeo") self.checkGeom = QAction( QCoreApplication.translate("fTools", "Check Geometry Validity..."), self.iface.mainWindow()) self.checkGeom.setObjectName("checkGeom") self.centroids = QAction( QCoreApplication.translate("fTools", "Polygon Centroids..."), self.iface.mainWindow()) self.centroids.setObjectName("centroids") self.delaunay = QAction( QCoreApplication.translate("fTools", "Delaunay Triangulation..."), self.iface.mainWindow()) self.delaunay.setObjectName("delaunay") self.voronoi = QAction( QCoreApplication.translate("fTools", "Voronoi Polygons..."), self.iface.mainWindow()) self.voronoi.setObjectName("voronoi") self.extNodes = QAction( QCoreApplication.translate("fTools", "Extract Nodes..."), self.iface.mainWindow()) self.extNodes.setObjectName("extNodes") self.simplify = QAction( QCoreApplication.translate("fTools", "Simplify Geometries..."), self.iface.mainWindow()) self.simplify.setObjectName("simplify") self.densify = QAction( QCoreApplication.translate("fTools", "Densify Geometries..."), self.iface.mainWindow()) self.densify.setObjectName("densify") self.multiToSingle = QAction( QCoreApplication.translate("fTools", "Multipart to Singleparts..."), self.iface.mainWindow()) self.multiToSingle.setObjectName("multiToSingle") self.singleToMulti = QAction( QCoreApplication.translate("fTools", "Singleparts to Multipart..."), self.iface.mainWindow()) self.singleToMulti.setObjectName("singleToMulti") self.polysToLines = QAction( QCoreApplication.translate("fTools", "Polygons to Lines..."), self.iface.mainWindow()) self.polysToLines.setObjectName("polysToLines") self.linesToPolys = QAction( QCoreApplication.translate("fTools", "Lines to Polygons..."), self.iface.mainWindow()) self.linesToPolys.setObjectName("linesToPolys") self.conversionMenu.addActions([ self.checkGeom, self.compGeo, self.centroids, self.delaunay, self.voronoi, self.simplify, self.densify, self.multiToSingle, self.singleToMulti, self.polysToLines, self.linesToPolys, self.extNodes ]) self.dataManageMenu = QMenu( QCoreApplication.translate("fTools", "&Data Management Tools")) self.dataManageMenu.setObjectName("dataManageMenu") self.define = QAction( QCoreApplication.translate("fTools", "Define Current Projection..."), self.iface.mainWindow()) self.define.setObjectName("define") self.spatJoin = QAction( QCoreApplication.translate("fTools", "Join Attributes by Location..."), self.iface.mainWindow()) self.spatJoin.setObjectName("spatJoin") self.splitVect = QAction( QCoreApplication.translate("fTools", "Split Vector Layer..."), self.iface.mainWindow()) self.splitVect.setObjectName("splitVect") self.mergeShapes = QAction( QCoreApplication.translate("fTools", "Merge Shapefiles to One..."), self.iface.mainWindow()) self.mergeShapes.setObjectName("mergeShapes") self.spatialIndex = QAction( QCoreApplication.translate("fTools", "Create Spatial Index..."), self.iface.mainWindow()) self.spatialIndex.setObjectName("spatialIndex") self.dataManageMenu.addActions([ self.define, self.spatJoin, self.splitVect, self.mergeShapes, self.spatialIndex ]) self.updateThemeIcons("theme") self.menu = self.iface.vectorMenu() self.menu.addMenu(self.analysisMenu) self.menu.addMenu(self.researchMenu) self.menu.addMenu(self.geoMenu) self.menu.addMenu(self.conversionMenu) self.menu.addMenu(self.dataManageMenu) QObject.connect(self.distMatrix, SIGNAL("triggered()"), self.dodistMatrix) QObject.connect(self.sumLines, SIGNAL("triggered()"), self.dosumLines) QObject.connect(self.pointsPoly, SIGNAL("triggered()"), self.dopointsPoly) QObject.connect(self.compStats, SIGNAL("triggered()"), self.docompStats) QObject.connect(self.listUnique, SIGNAL("triggered()"), self.dolistUnique) QObject.connect(self.nearestNeigh, SIGNAL("triggered()"), self.donearestNeigh) QObject.connect(self.meanCoords, SIGNAL("triggered()"), self.domeanCoords) QObject.connect(self.intLines, SIGNAL("triggered()"), self.dointLines) QObject.connect(self.randSel, SIGNAL("triggered()"), self.dorandSel) QObject.connect(self.randSub, SIGNAL("triggered()"), self.dorandSub) QObject.connect(self.randPoints, SIGNAL("triggered()"), self.dorandPoints) QObject.connect(self.regPoints, SIGNAL("triggered()"), self.doregPoints) QObject.connect(self.vectGrid, SIGNAL("triggered()"), self.dovectGrid) QObject.connect(self.selectLocation, SIGNAL("triggered()"), self.doselectLocation) QObject.connect(self.layerExtent, SIGNAL("triggered()"), self.doextent) QObject.connect(self.minConvex, SIGNAL("triggered()"), self.dominConvex) QObject.connect(self.intersect, SIGNAL("triggered()"), self.dointersect) QObject.connect(self.dissolve, SIGNAL("triggered()"), self.dodissolve) QObject.connect(self.symDifference, SIGNAL("triggered()"), self.dosymdifference) QObject.connect(self.erase, SIGNAL("triggered()"), self.doerase) QObject.connect(self.union, SIGNAL("triggered()"), self.dounion) QObject.connect(self.clip, SIGNAL("triggered()"), self.doclip) QObject.connect(self.dynaBuffer, SIGNAL("triggered()"), self.dodynaBuffer) QObject.connect(self.eliminate, SIGNAL("triggered()"), self.doEliminate) QObject.connect(self.multiToSingle, SIGNAL("triggered()"), self.domultiToSingle) QObject.connect(self.singleToMulti, SIGNAL("triggered()"), self.dosingleToMulti) QObject.connect(self.checkGeom, SIGNAL("triggered()"), self.docheckGeom) QObject.connect(self.simplify, SIGNAL("triggered()"), self.doSimplify) QObject.connect(self.densify, SIGNAL("triggered()"), self.doDensify) QObject.connect(self.centroids, SIGNAL("triggered()"), self.docentroids) QObject.connect(self.delaunay, SIGNAL("triggered()"), self.dodelaunay) QObject.connect(self.voronoi, SIGNAL("triggered()"), self.dovoronoi) QObject.connect(self.polysToLines, SIGNAL("triggered()"), self.dopolysToLines) QObject.connect(self.linesToPolys, SIGNAL("triggered()"), self.dolinesToPolys) QObject.connect(self.compGeo, SIGNAL("triggered()"), self.docompGeo) QObject.connect(self.extNodes, SIGNAL("triggered()"), self.doextNodes) QObject.connect(self.define, SIGNAL("triggered()"), self.dodefine) QObject.connect(self.spatJoin, SIGNAL("triggered()"), self.dospatJoin) QObject.connect(self.splitVect, SIGNAL("triggered()"), self.dosplitVect) QObject.connect(self.mergeShapes, SIGNAL("triggered()"), self.doMergeShapes) QObject.connect(self.spatialIndex, SIGNAL("triggered()"), self.doSpatIndex) def unload(self): self.menu.removeAction(self.analysisMenu.menuAction()) self.menu.removeAction(self.researchMenu.menuAction()) self.menu.removeAction(self.geoMenu.menuAction()) self.menu.removeAction(self.conversionMenu.menuAction()) self.menu.removeAction(self.dataManageMenu.menuAction()) def doSimplify(self): d = doSimplify.Dialog(self.iface, 1) d.show() d.exec_() def doDensify(self): d = doSimplify.Dialog(self.iface, 2) d.show() d.exec_() def dopolysToLines(self): d = doGeometry.GeometryDialog(self.iface, 4) d.exec_() def dolinesToPolys(self): d = doGeometry.GeometryDialog(self.iface, 11) d.exec_() def docheckGeom(self): d = doValidate.ValidateDialog(self.iface) d.show() d.exec_() def domultiToSingle(self): d = doGeometry.GeometryDialog(self.iface, 2) d.exec_() def dosingleToMulti(self): d = doGeometry.GeometryDialog(self.iface, 1) d.exec_() def doselectLocation(self): d = doSelectByLocation.Dialog(self.iface) d.exec_() def domeanCoords(self): d = doMeanCoords.Dialog(self.iface, 1) d.exec_() def dominConvex(self): d = doGeoprocessing.GeoprocessingDialog(self.iface, 2) d.exec_() def dodynaBuffer(self): d = doGeoprocessing.GeoprocessingDialog(self.iface, 1) d.exec_() def dointersect(self): d = doGeoprocessing.GeoprocessingDialog(self.iface, 5) d.exec_() def dodissolve(self): d = doGeoprocessing.GeoprocessingDialog(self.iface, 4) d.exec_() def doerase(self): d = doGeoprocessing.GeoprocessingDialog(self.iface, 3) d.exec_() def dosymdifference(self): d = doGeoprocessing.GeoprocessingDialog(self.iface, 7) d.exec_() def dounion(self): d = doGeoprocessing.GeoprocessingDialog(self.iface, 6) d.exec_() def doclip(self): d = doGeoprocessing.GeoprocessingDialog(self.iface, 8) d.exec_() def donearestNeigh(self): d = doVisual.VisualDialog(self.iface, 4) d.exec_() def dodistMatrix(self): d = doPointDistance.Dialog(self.iface) d.exec_() def docentroids(self): d = doGeometry.GeometryDialog(self.iface, 7) d.exec_() def dodelaunay(self): d = doGeometry.GeometryDialog(self.iface, 8) d.exec_() def dovoronoi(self): d = doGeometry.GeometryDialog(self.iface, 10) d.exec_() def doextent(self): d = doGeometry.GeometryDialog(self.iface, 9) d.exec_() def dosumLines(self): d = doSumLines.Dialog(self.iface) d.exec_() def dopointsPoly(self): d = doPointsInPolygon.Dialog(self.iface) d.show() d.exec_() def dorandSel(self): d = doRandom.Dialog(self.iface) d.exec_() def dorandSub(self): d = doSubsetSelect.Dialog(self.iface) d.exec_() def dorandPoints(self): d = doRandPoints.Dialog(self.iface) d.exec_() def doregPoints(self): d = doRegPoints.Dialog(self.iface) d.exec_() def dovectGrid(self): d = doVectorGrid.Dialog(self.iface) d.exec_() def doextNodes(self): d = doGeometry.GeometryDialog(self.iface, 3) d.exec_() def dointLines(self): d = doIntersectLines.Dialog(self.iface) d.exec_() def dosplitVect(self): d = doVectorSplit.Dialog(self.iface) d.show() d.exec_() def docompGeo(self): d = doGeometry.GeometryDialog(self.iface, 5) d.exec_() def dolistUnique(self): d = doVisual.VisualDialog(self.iface, 2) d.exec_() def docompStats(self): d = doVisual.VisualDialog(self.iface, 3) d.exec_() def dodefine(self): d = doDefineProj.Dialog(self.iface) d.exec_() def dospatJoin(self): d = doSpatialJoin.Dialog(self.iface) d.exec_() def doMergeShapes(self): d = doMergeShapes.Dialog(self.iface) d.show() d.exec_() def doSpatIndex(self): d = doSpatialIndex.Dialog(self.iface) d.show() d.exec_() def doEliminate(self): d = doEliminate.Dialog(self.iface) d.exec_()
class MainWindow(QMainWindow, object): """ QMainWindow displays pipeline Parameters ---------- port : str used port to communicate with pipeline Note: The firewall must be configure to accept input/output on this port """ def __init__(self, port): super(MainWindow, self).__init__() self.setupUi(port) def setupUi(self, port): self.setObjectName("MainWindow") self.resize(600, 600) self.centralwidget = QWidget(self) p = self.centralwidget.palette() self.centralwidget.setAutoFillBackground(True) p.setColor(self.centralwidget.backgroundRole(), QColor(126, 135, 152)) self.centralwidget.setPalette(p) self.centralwidget.setObjectName("centralwidget") self.gridLayout = QGridLayout(self.centralwidget) self.gridLayout.setObjectName("gridLayout") self.setCentralWidget(self.centralwidget) self.menubar = QMenuBar(self) self.menubar.setGeometry(QRect(0, 0, 808, 25)) self.menubar.setObjectName("menubar") self.menuFile = QMenu(self.menubar) self.menuFile.setObjectName("menuFile") self.setMenuBar(self.menubar) self.statusbar = QStatusBar(self) self.statusbar.setObjectName("statusbar") self.setStatusBar(self.statusbar) self.actionQuit = QAction(self) self.actionQuit.setObjectName("actionQuit") self.menuFile.addSeparator() self.menuFile.addAction(self.actionQuit) self.menubar.addAction(self.menuFile.menuAction()) self.actionReset = QAction(self) self.actionReset.setObjectName("reset") self.menuFile.addSeparator() self.menuFile.addAction(self.actionReset) self.menubar.addAction(self.menuFile.menuAction()) # add other GUI objects self.graph_widget = GraphWidget(self.statusbar) self.gridLayout.addWidget(self.graph_widget, 1, 11, 10, 10) pixmap = QPixmap(':/images/cta-logo-mini.png') lbl = QLabel() lbl.setPixmap(pixmap) self.gridLayout.addWidget(lbl, 0, 0) p = self.graph_widget.palette() self.graph_widget.setAutoFillBackground(True) p.setColor(self.graph_widget.backgroundRole(), QColor(255, 255, 255)) # QColor(226, 235, 252)) self.graph_widget.setPalette(p) self.quitButton = QPushButton() # self.centralwidget) self.quitButton.setObjectName("quitButton") self.quitButton.setText( QApplication.translate("MainWindow", "Quit", None, QApplication.UnicodeUTF8)) self.gridLayout.addWidget(self.quitButton, 12, 0, 1, 1) self.info_label = InfoLabel(0, 4) self.info_label.setAutoFillBackground(True) self.gridLayout.addWidget(self.info_label, 1, 0, 1, 5) #self.info_label.setAlignment(PyQt4.Qt.AlignCenter); palette = QPalette() palette.setColor(self.info_label.backgroundRole(), Qt.lightGray) self.info_label.setPalette(palette) QObject.connect(self.quitButton, SIGNAL("clicked()"), self.stop) QObject.connect(self.actionQuit, SIGNAL("triggered()"), self.stop) QMetaObject.connectSlotsByName(self) self.retranslateUi() QObject.connect(self.actionQuit, SIGNAL("triggered()"), self.close) QMetaObject.connectSlotsByName(self) # Create GuiConnexion for ZMQ comminucation with pipeline self.guiconnection = GuiConnexion(gui_port=port, statusBar=self.statusbar) self.guiconnection.message.connect(self.graph_widget.pipechange) self.guiconnection.message.connect(self.info_label.pipechange) self.guiconnection.reset_message.connect(self.graph_widget.reset) self.guiconnection.reset_message.connect(self.info_label.reset) self.guiconnection.mode_message.connect(self.info_label.mode_receive) QObject.connect(self.actionReset, SIGNAL("triggered()"), self.guiconnection.reset) QMetaObject.connectSlotsByName(self) # start the process self.guiconnection.start() def retranslateUi(self): self.setWindowTitle( QApplication.translate("ctapipe flow based GUI", "ctapipe flow based GUI", None, QApplication.UnicodeUTF8)) self.menuFile.setTitle( QApplication.translate("MainWindow", "File", None, QApplication.UnicodeUTF8)) self.actionQuit.setText( QApplication.translate("MainWindow", "Quit", None, QApplication.UnicodeUTF8)) self.actionReset.setText( QApplication.translate("MainWindow", "Reset", None, QApplication.UnicodeUTF8)) def stop(self): """Method connect (via Qt slot) to exit button Stops self.guiconnection (for ZMQ communication) process. Close main_windows """ self.guiconnection.finish() self.guiconnection.join() self.close() def closeEvent(self, event): self.guiconnection.finish() self.guiconnection.join() event.accept() # let the window close
class Plugin: """The QGIS interface implementation for the InaSAFE plugin. This class acts as the 'glue' between QGIS and our custom logic. It creates a toolbar and menubar entry and launches the InaSAFE user interface if these are activated. """ def __init__(self, iface): """Class constructor. On instantiation, the plugin instance will be assigned a copy of the QGIS iface object which will allow this plugin to access and manipulate the running QGIS instance that spawned it. :param iface:Quantum GIS iface instance. This instance is automatically passed to the plugin by QGIS when it loads the plugin. :type iface: QGisAppInterface """ # Save reference to the QGIS interface self.iface = iface self.translator = None self.toolbar = None self.actions = [] # list of all QActions we create for InaSAFE self.setup_i18n() #print self.tr('InaSAFE') custom_logging.setup_logger() # For enable/disable the keyword editor icon self.iface.currentLayerChanged.connect(self.layer_changed) #noinspection PyArgumentList def setup_i18n(self, preferred_locale=None): """Setup internationalisation for the plugin. See if QGIS wants to override the system locale and then see if we can get a valid translation file for whatever locale is effectively being used. :param preferred_locale: If set will override any other way of determining locale. :type preferred_locale: str, None :raises: TranslationLoadException """ myOverrideFlag = QSettings().value('locale/overrideFlag', False) if preferred_locale is not None: myLocaleName = preferred_locale elif myOverrideFlag: myLocaleName = QSettings().value('locale/userLocale', '') else: myLocaleName = QLocale.system().name() # NOTES: we split the locale name because we need the first two # character i.e. 'id', 'af, etc myLocaleName = str(myLocaleName).split('_')[0] # Also set the system locale to the user overridden local # so that the inasafe library functions gettext will work # .. see:: :py:func:`common.utilities` os.environ['LANG'] = str(myLocaleName) LOGGER.debug('%s %s %s %s' % (preferred_locale, myOverrideFlag, QLocale.system().name(), os.environ['LANG'])) myRoot = os.path.abspath(os.path.join(os.path.dirname(__file__), '..')) myTranslationPath = os.path.join( myRoot, 'safe_qgis', 'i18n', 'inasafe_' + str(myLocaleName) + '.qm') if os.path.exists(myTranslationPath): self.translator = QTranslator() myResult = self.translator.load(myTranslationPath) if not myResult: myMessage = 'Failed to load translation for %s' % myLocaleName raise TranslationLoadError(myMessage) # noinspection PyTypeChecker QCoreApplication.installTranslator(self.translator) LOGGER.debug('%s %s' % (myTranslationPath, os.path.exists(myTranslationPath))) 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 return QCoreApplication.translate('Plugin', message) def add_action(self, action, add_to_toolbar=True): """Add a toolbar icon to the InaSAFE toolbar. :param action: The action that should be added to the toolbar. :type action: QAction :param add_to_toolbar: Flag indicating whether the action should also be added to the InaSAFE toolbar. Defaults to True. :type add_to_toolbar: bool """ # store in the class list of actions for easy plugin unloading self.actions.append(action) self.iface.addPluginToMenu(self.tr('InaSAFE'), action) if add_to_toolbar: self.toolbar.addAction(action) #noinspection PyCallByClass def initGui(self): """Gui initialisation procedure (for QGIS plugin api). .. note:: Don't change the name of this method from initGui! This method is called by QGIS and should be used to set up any graphical user interface elements that should appear in QGIS by default (i.e. before the user performs any explicit action with the plugin). """ self.toolbar = self.iface.addToolBar('InaSAFE') self.toolbar.setObjectName('InaSAFEToolBar') # Import dock here as it needs to be imported AFTER i18n is set up from safe_qgis.widgets.dock import Dock self.dockWidget = None #-------------------------------------- # Create action for plugin dockable window (show/hide) #-------------------------------------- # pylint: disable=W0201 self.actionDock = QAction(QIcon(':/plugins/inasafe/icon.svg'), self.tr('Toggle InaSAFE Dock'), self.iface.mainWindow()) self.actionDock.setObjectName('InaSAFEDockToggle') self.actionDock.setStatusTip(self.tr('Show/hide InaSAFE dock widget')) self.actionDock.setWhatsThis(self.tr('Show/hide InaSAFE dock widget')) self.actionDock.setCheckable(True) self.actionDock.setChecked(True) self.actionDock.triggered.connect(self.toggle_dock_visibility) self.add_action(self.actionDock) #-------------------------------------- # Create action for keywords editor #-------------------------------------- self.actionKeywordsDialog = QAction( QIcon(':/plugins/inasafe/show-keyword-editor.svg'), self.tr('InaSAFE Keyword Editor'), self.iface.mainWindow()) self.actionKeywordsDialog.setStatusTip( self.tr('Open InaSAFE keywords editor')) self.actionKeywordsDialog.setWhatsThis( self.tr('Open InaSAFE keywords editor')) self.actionKeywordsDialog.setEnabled(False) self.actionKeywordsDialog.triggered.connect(self.show_keywords_editor) self.add_action(self.actionKeywordsDialog) #-------------------------------------- # Create action for reset icon #-------------------------------------- self.actionResetDock = QAction( QIcon(':/plugins/inasafe/reset-dock.svg'), self.tr('Reset Dock'), self.iface.mainWindow()) self.actionResetDock.setStatusTip(self.tr('Reset the InaSAFE Dock')) self.actionResetDock.setWhatsThis(self.tr('Reset the InaSAFE Dock')) self.actionResetDock.triggered.connect(self.reset_dock) self.add_action(self.actionResetDock) #-------------------------------------- # Create action for options dialog #-------------------------------------- self.actionOptions = QAction( QIcon(':/plugins/inasafe/configure-inasafe.svg'), self.tr('InaSAFE Options'), self.iface.mainWindow()) self.actionOptions.setStatusTip(self.tr('Open InaSAFE options dialog')) self.actionOptions.setWhatsThis(self.tr('Open InaSAFE options dialog')) self.actionOptions.triggered.connect(self.show_options) self.add_action(self.actionOptions) #-------------------------------------- # Create action for impact functions doc dialog #-------------------------------------- self.actionFunctionBrowser = QAction( QIcon(':/plugins/inasafe/show-impact-functions.svg'), self.tr('InaSAFE Impact Functions Browser'), self.iface.mainWindow()) self.actionFunctionBrowser.setStatusTip( self.tr('Open InaSAFE Impact Functions Browser')) self.actionFunctionBrowser.setWhatsThis( self.tr('Open InaSAFE Impact Functions Browser')) self.actionFunctionBrowser.triggered.connect( self.show_function_browser) self.add_action(self.actionFunctionBrowser) # Short cut for Open Impact Functions Doc self.keyAction = QAction("Test Plugin", self.iface.mainWindow()) self.iface.registerMainWindowAction(self.keyAction, "F7") self.keyAction.triggered.connect(self.shortcut_f7) #--------------------------------------- # Create action for minimum needs dialog #--------------------------------------- self.actionMinimumNeeds = QAction( QIcon(':/plugins/inasafe/show-minimum-needs.svg'), self.tr('InaSAFE Minimum Needs Tool'), self.iface.mainWindow()) self.actionMinimumNeeds.setStatusTip( self.tr('Open InaSAFE minimum needs tool')) self.actionMinimumNeeds.setWhatsThis( self.tr('Open InaSAFE minimum needs tool')) self.actionMinimumNeeds.triggered.connect(self.show_minimum_needs) self.add_action(self.actionMinimumNeeds) #--------------------------------------- # Create action for converter dialog #--------------------------------------- self.actionConverter = QAction( QIcon(':/plugins/inasafe/show-converter-tool.svg'), self.tr('InaSAFE Converter'), self.iface.mainWindow()) self.actionConverter.setStatusTip(self.tr('Open InaSAFE Converter')) self.actionConverter.setWhatsThis(self.tr('Open InaSAFE Converter')) self.actionConverter.triggered.connect(self.show_shakemap_importer) self.add_action(self.actionConverter) #--------------------------------------- # Create action for batch runner dialog #--------------------------------------- self.actionBatchRunner = QAction( QIcon(':/plugins/inasafe/show-batch-runner.svg'), self.tr('InaSAFE Batch Runner'), self.iface.mainWindow()) self.actionBatchRunner.setStatusTip( self.tr('Open InaSAFE Batch Runner')) self.actionBatchRunner.setWhatsThis( self.tr('Open InaSAFE Batch Runner')) self.actionBatchRunner.triggered.connect(self.show_batch_runner) self.add_action(self.actionBatchRunner) #--------------------------------------- # Create action for batch runner dialog #--------------------------------------- self.actionSaveScenario = QAction( QIcon(':/plugins/inasafe/save-as-scenario.svg'), self.tr('Save current scenario'), self.iface.mainWindow()) myMessage = self.tr('Save current scenario to text file') self.actionSaveScenario.setStatusTip(myMessage) self.actionSaveScenario.setWhatsThis(myMessage) # noinspection PyUnresolvedReferences self.actionSaveScenario.triggered.connect(self.save_scenario) self.add_action(self.actionSaveScenario) #-------------------------------------- # Create action for import OSM Dialog #-------------------------------------- self.actionImportDlg = QAction( QIcon(':/plugins/inasafe/show-osm-download.svg'), self.tr('InaSAFE OpenStreetMap Downloader'), self.iface.mainWindow()) self.actionImportDlg.setStatusTip( self.tr('InaSAFE OpenStreetMap Downloader')) self.actionImportDlg.setWhatsThis( self.tr('InaSAFE OpenStreetMap Downloader')) self.actionImportDlg.triggered.connect(self.show_osm_downloader) self.add_action(self.actionImportDlg) #-------------------------------------- # create dockwidget and tabify it with the legend #-------------------------------------- self.dockWidget = Dock(self.iface) self.iface.addDockWidget(Qt.RightDockWidgetArea, self.dockWidget) myLegendTab = self.iface.mainWindow().findChild(QApplication, 'Legend') if myLegendTab: self.iface.mainWindow().tabifyDockWidget(myLegendTab, self.dockWidget) self.dockWidget.raise_() # # Hook up a slot for when the dock is hidden using its close button # or view-panels # self.dockWidget.visibilityChanged.connect(self.toggle_inasafe_action) # pylint: disable=W0201 def clear_modules(self): """Unload inasafe functions and try to return QGIS to before InaSAFE. """ from safe.impact_functions import core core.unload_plugins() # next lets force remove any inasafe related modules myModules = [] for myModule in sys.modules: if 'inasafe' in myModule: # Check if it is really one of our modules i.e. exists in the # plugin directory myTokens = myModule.split('.') myPath = '' for myToken in myTokens: myPath += os.path.sep + myToken myParent = os.path.abspath( os.path.join(__file__, os.path.pardir, os.path.pardir)) myFullPath = os.path.join(myParent, myPath + '.py') if os.path.exists(os.path.abspath(myFullPath)): LOGGER.debug('Removing: %s' % myModule) myModules.append(myModule) for myModule in myModules: del (sys.modules[myModule]) for myModule in sys.modules: if 'inasafe' in myModule: print myModule # Lets also clean up all the path additions that were made myPackagePath = os.path.abspath( os.path.join(os.path.dirname(__file__), os.path.pardir)) LOGGER.debug('Path to remove: %s' % myPackagePath) # We use a list comprehension to ensure duplicate entries are removed LOGGER.debug(sys.path) sys.path = [y for y in sys.path if myPackagePath not in y] LOGGER.debug(sys.path) def unload(self): """GUI breakdown procedure (for QGIS plugin api). .. note:: Don't change the name of this method from unload! This method is called by QGIS and should be used to *remove* any graphical user interface elements that should appear in QGIS. """ # Remove the plugin menu item and icon for myAction in self.actions: self.iface.removePluginMenu(self.tr('InaSAFE'), myAction) self.iface.removeToolBarIcon(myAction) self.iface.mainWindow().removeDockWidget(self.dockWidget) self.iface.mainWindow().removeToolBar(self.toolbar) self.dockWidget.setVisible(False) self.dockWidget.destroy() self.iface.currentLayerChanged.disconnect(self.layer_changed) self.clear_modules() def toggle_inasafe_action(self, checked): """Check or uncheck the toggle inaSAFE toolbar button. This slot is called when the user hides the inaSAFE panel using its close button or using view->panels. :param checked: True if the dock should be shown, otherwise False. :type checked: bool """ self.actionDock.setChecked(checked) # Run method that performs all the real work def toggle_dock_visibility(self): """Show or hide the dock widget.""" if self.dockWidget.isVisible(): self.dockWidget.setVisible(False) else: self.dockWidget.setVisible(True) self.dockWidget.raise_() def show_minimum_needs(self): """Show the minimum needs dialog.""" # import here only so that it is AFTER i18n set up from safe_qgis.tools.minimum_needs import MinimumNeeds myDialog = MinimumNeeds(self.iface.mainWindow()) myDialog.exec_() # modal def show_options(self): """Show the options dialog.""" # import here only so that it is AFTER i18n set up from safe_qgis.tools.options_dialog import OptionsDialog myDialog = OptionsDialog(self.iface, self.dockWidget, self.iface.mainWindow()) myDialog.exec_() # modal def show_keywords_editor(self): """Show the keywords editor.""" # import here only so that it is AFTER i18n set up from safe_qgis.tools.keywords_dialog import KeywordsDialog if self.iface.activeLayer() is None: return myDialog = KeywordsDialog(self.iface.mainWindow(), self.iface, self.dockWidget) myDialog.exec_() # modal def show_function_browser(self): """Show the impact function browser tool.""" # import here only so that it is AFTER i18n set up from safe_qgis.tools.function_browser import FunctionBrowser myDialog = FunctionBrowser(self.iface.mainWindow()) myDialog.exec_() # modal def show_shakemap_importer(self): """Show the converter dialog.""" # import here only so that it is AFTER i18n set up from safe_qgis.tools.shakemap_importer import ShakemapImporter myDialog = ShakemapImporter(self.iface.mainWindow()) myDialog.exec_() # modal def show_osm_downloader(self): """Show the OSM buildings downloader dialog.""" from safe_qgis.tools.osm_downloader import OsmDownloader dialog = OsmDownloader(self.iface.mainWindow(), self.iface) dialog.exec_() # modal def show_batch_runner(self): """Show the batch runner dialog.""" from safe_qgis.batch.batch_dialog import BatchDialog myDialog = BatchDialog(parent=self.iface.mainWindow(), iface=self.iface, dock=self.dockWidget) myDialog.exec_() # modal def save_scenario(self): """Save current scenario to text file,""" self.dockWidget.save_current_scenario() def reset_dock(self): """Reset the dock to its default state.""" self.dockWidget.get_layers() def layer_changed(self, layer): """Enable or disable keywords editor icon when active layer changes. :param layer: The layer that is now active. :type layer: QgsMapLayer """ if layer is None: self.actionKeywordsDialog.setEnabled(False) else: self.actionKeywordsDialog.setEnabled(True) def shortcut_f7(self): """Executed when user press F7 - will show the shakemap importer.""" self.show_shakemap_importer()
class previewDlg(QMainWindow): ''' classdocs ''' def __init__(self, parent, comp, basePMCheck, model): ''' Constructor ''' QMainWindow.__init__(self, parent) self.basePMCheck = basePMCheck # self.ui = Ui_Previewself.grbPageProperty() # self.ui.setupUi(self) self.resize(1000, 700) self.setWindowTitle("Preview Dialog") self.view = QgsComposerView(self) viewLayout = QGridLayout() viewLayout.setSpacing(0) viewLayout.setMargin(0) mHorizontalRuler = QgsComposerRuler(QgsComposerRuler.Horizontal) mVerticalRuler = QgsComposerRuler(QgsComposerRuler.Vertical) mRulerLayoutFix = QWidget() mRulerLayoutFix.setAttribute(Qt.WA_NoMousePropagation) mRulerLayoutFix.setBackgroundRole(QPalette.Window) mRulerLayoutFix.setFixedSize(mVerticalRuler.rulerSize(), mHorizontalRuler.rulerSize()) viewLayout.addWidget(mRulerLayoutFix, 0, 0) viewLayout.addWidget(mHorizontalRuler, 0, 1) viewLayout.addWidget(mVerticalRuler, 1, 0) self.view.setContentsMargins(0, 0, 0, 0) self.view.setHorizontalRuler(mHorizontalRuler) self.view.setVerticalRuler(mVerticalRuler) viewLayout.addWidget(self.view, 1, 1) # self.scene = comp self.view.setZoomLevel(1.0) self.view.setComposition(comp) self.scene = self.view.composition() layout = QVBoxLayout() hLayout = QHBoxLayout() hLayout.addLayout(viewLayout) self.mapItem = self.scene.getComposerMapById(0) self.view.scale(2.8, 2.8) self.view.setPreviewModeEnabled(True) self.toolBarAction = self.addToolBar("composer action") self.actionMapRefresh = QAction(self) self.actionMapRefresh.setObjectName("actionMapRefresh") icon3 = QIcon("Resource/Refresh.png") self.actionMapRefresh.setIcon(icon3) self.actionMapRefresh.setToolTip("Refresh") # self.textItemAction.setCheckable(True) self.connect(self.actionMapRefresh, SIGNAL("triggered()"), self.actionMapRefresh_triggered) self.toolBarAction.addAction(self.actionMapRefresh) # # self.templeteCreateAction = QAction(self) # # self.templeteCreateAction.setObjectName("createTempleteAction") # # icon4 = QIcon("Resource\\templetepointer.png") # # self.templeteCreateAction.setIcon(icon4) # # self.templeteCreateAction.setToolTip("Create Templete") # # self.templeteCreateAction.setCheckable(True) # # self.connect(self.templeteCreateAction, SIGNAL("triggered()"), self.createTempleteAction) # # self.toolBar.addAction(self.templeteCreateAction) # layout.insertWidget(0, self.toolBar) # self.scene.selectedItemChanged.connect(self.selectedItemDisplay) self.view.selectedItemChanged.connect(self.selectedItemDisplay) self.view.cursorPosChanged.connect(self.cursorPosChangedEvent) # self.connect(self.view, SIGNAL("selectedItemChanged(QgsComposerItem)"),self, SLOT("selectedItemDisplay(QgsComposerItem)")) # self.scene.composerLabelAdded.connect(self.composerLabelAddedEvent) self.view.itemRemoved.connect(self.deleteItem) # self.connect( self.view, SIGNAL( "actionFinished()" ), self.setSelectionTool) #listen out for position updates from the QgsComposerView self.propertyWidget = QWidget(self) hLayout.addWidget(self.propertyWidget) self.propertyWidget.setObjectName("propertyWidget") self.propertyWidget.resize(222, 302) self.vLayout_3 = QVBoxLayout(self.propertyWidget) self.vLayout_3.setObjectName("vLayout_3") self.groupBox = QGroupBox(self.propertyWidget) self.groupBox.setObjectName("groupBox") self.horizontalLayout_2 = QHBoxLayout(self.groupBox) self.horizontalLayout_2.setObjectName("horizontalLayout_2") self.frame = QFrame(self.groupBox) self.frame.setFrameShape(QFrame.StyledPanel) self.frame.setFrameShadow(QFrame.Raised) self.frame.setObjectName("frame") self.verticalLayout = QVBoxLayout(self.frame) self.verticalLayout.setObjectName("verticalLayout") self.label = QLabel(self.frame) self.label.setObjectName("label") self.verticalLayout.addWidget(self.label) self.labelText = QPlainTextEdit(self.frame) self.labelText.setObjectName("labelText") self.verticalLayout.addWidget(self.labelText) self.btnLabelFont = QPushButton(self.frame) self.btnLabelFont.setObjectName("btnLabelFont") self.verticalLayout.addWidget(self.btnLabelFont) self.btnLabelColor = QPushButton(self.frame) self.btnLabelColor.setObjectName("btnLabelColor") self.verticalLayout.addWidget(self.btnLabelColor) self.frame_2 = QFrame(self.frame) self.frame_2.setFrameShape(QFrame.StyledPanel) self.frame_2.setFrameShadow(QFrame.Raised) self.frame_2.setObjectName("frame_2") self.horizontalLayout = QHBoxLayout(self.frame_2) self.horizontalLayout.setObjectName("horizontalLayout") self.label_2 = QLabel(self.frame_2) self.label_2.setObjectName("label_2") self.horizontalLayout.addWidget(self.label_2) self.spinLabelRotation = QSpinBox(self.frame_2) self.spinLabelRotation.setObjectName("spinLabelRotation") self.spinLabelRotation.setMinimum(-360) self.spinLabelRotation.setMaximum(360) self.horizontalLayout.addWidget(self.spinLabelRotation) self.verticalLayout.addWidget(self.frame_2) self.chbBackgroundEnable = QCheckBox(self.frame) self.chbBackgroundEnable.setChecked(True) self.chbBackgroundEnable.setObjectName("chbBackgroundEnable") self.verticalLayout.addWidget(self.chbBackgroundEnable) self.horizontalLayout_2.addWidget(self.frame) self.vLayout_3.addWidget(self.groupBox) self.resolutionFrame = QFrame(self.frame) self.resolutionFrame.setFrameShape(QFrame.StyledPanel) self.resolutionFrame.setFrameShadow(QFrame.Raised) self.resolutionFrame.setObjectName("resolutionFrame") self.horizontalLayout4 = QHBoxLayout(self.resolutionFrame) self.horizontalLayout4.setObjectName("horizontalLayout4") self.label_resolution = QLabel(self.resolutionFrame) self.label_resolution.setObjectName("label_resolution") self.label_resolution.setText("Print Resolution (dpi):") self.horizontalLayout4.addWidget(self.label_resolution) self.spinResolution = QSpinBox(self.resolutionFrame) self.spinResolution.setObjectName("spinResolution") self.spinResolution.setMinimum(0) self.spinResolution.setMaximum(1000) self.spinResolution.setValue(300) self.horizontalLayout4.addWidget(self.spinResolution) # self.verticalLayout.addWidget(self.frame_2) self.vLayout_3.addWidget(self.resolutionFrame) self.gbTable = GroupBox(self.propertyWidget) self.gbTable.Caption = "Table" self.vLayout_3.addWidget(self.gbTable) self.mTableView = QTableView(self.gbTable) self.gbTable.Add = self.mTableView hHeder = self.mTableView.horizontalHeader() hHeder.setVisible(False) vHeder = self.mTableView.verticalHeader() vHeder.setVisible(False) # self.mTableView.setFixedHeight(70) # self.mTableView.setFixedWidth(comp.paperWidth() - 40) # self.stdItemModel = QStandardItemModel() # self. self.spaceItem = QSpacerItem(20, 40, QSizePolicy.Minimum, QSizePolicy.Expanding) self.vLayout_3.addItem(self.spaceItem) self.groupBox.setTitle("Label Property") self.label.setText("Label Text:") self.btnLabelFont.setText("Label Font") self.btnLabelColor.setText("Label Color") self.label_2.setText("Label Rotation:") self.chbBackgroundEnable.setText("Background Enable") self.groupBox.setEnabled(False) self.connect(self.btnLabelFont, SIGNAL("clicked()"), self.btnLabelFontClick) self.connect(self.btnLabelColor, SIGNAL("clicked()"), self.btnLabelColorClick) self.connect(self.chbBackgroundEnable, SIGNAL("clicked()"), self.chbBackgroundEnableClick) self.labelText.textChanged.connect(self.labelTextChanged) self.spinLabelRotation.valueChanged.connect( self.spinLabelRotationValueChanged) layout.addLayout(hLayout) # self.btnBack = QPushButton() self.btnBack.setText("back") footerLayout = QHBoxLayout() footerLayout.addWidget(self.btnBack) self.buttonBox = QDialogButtonBox(self) self.buttonBox.setOrientation(Qt.Horizontal) self.buttonBox.setStandardButtons(QDialogButtonBox.Cancel | QDialogButtonBox.Ok) self.buttonBox.setObjectName("buttonBox") footerLayout.addWidget(self.buttonBox) layout.addLayout(footerLayout) self.setLayout(layout) deleteItemKey = QShortcut(QKeySequence(Qt.Key_Delete), self) deleteItemKey.activated.connect(self.deleteItem) # self.btnBack.clicked.connect(self.back) self.connect(self.buttonBox, SIGNAL("accepted()"), self.acceptMethod) self.connect(self.buttonBox, SIGNAL("rejected()"), self.reject) self.btnCancel = self.buttonBox.button(QDialogButtonBox.Cancel) self.view.setCurrentTool(QgsComposerView.Select) self.btnLabelColor.setVisible(False) # self.btnBack.setVisible(False) self.chbBackgroundEnable.setVisible(False) # self.view.emit(SIGNAL("actionFinished")) # if self.scene.plotStyle() != QgsComposition.Preview: # self.scene.setPlotStyle(QgsComposition.Preview) # self.mapItem.setPreviewMode(QgsComposerMap.Render) # self.mapItem.updateCachedImage() # self.mapItem.setSelected(True) self.mComposition = comp self.composerMapItem = self.mComposition.composerMapItems()[0] self.composerMapItem.setUpdatesEnabled(True) self.mStdModel = model self.mTableView.setModel(self.mStdModel) self.mTableView.setSpan(0, 0, 1, 6) self.mTableView.setSpan(1, 0, 1, 2) self.mTableView.setSpan(2, 0, 2, 1) self.mTableView.setSpan(4, 0, 1, 2) self.mTableView.setSpan(5, 0, 1, 2) self.mTableView.setSpan(6, 0, 1, 2) self.mTableView.setSpan(0, 6, 1, 8) self.mTableView.setSpan(1, 7, 1, 4) self.mTableView.setSpan(1, 11, 1, 3) self.mTableView.setSpan(2, 7, 1, 4) self.mTableView.setSpan(2, 11, 1, 3) def acceptMethod(self): # self.mStdModel.setItem(0, QStandardItem("nnnnnnnn")) filePath = QFileDialog.getSaveFileName( self, "Save PDF File", QCoreApplication.applicationDirPath(), "pdf files(*.pdf )") if filePath == "": return self.mComposition.clearSelection() self.mComposition.setPrintResolution(self.spinResolution.value()) resultPdf = self.mComposition.exportAsPDF(filePath) if resultPdf: message = QMessageBox.information(self, "Result", "Successful export PDF") else: message = QMessageBox.information(self, "Result", "Don't export PDF") def rePresent(self, comp, model): self.mComposition = comp self.mStdModel = model self.view.setComposition(comp) self.scene = self.view.composition() def back(self): self.done(2) def spinLabelRotationValueChanged(self, rotationValue): self.selectedLabelItem.setItemRotation(rotationValue) def cursorPosChangedEvent(self, scenePointF): self.scenePoint = scenePointF # i = 100 def labelTextChanged(self): self.selectedLabelItem.beginCommand( "Label text changed", QgsComposerMergeCommand.ComposerLabelSetText) self.selectedLabelItem.blockSignals(True) self.selectedLabelItem.setText(self.labelText.toPlainText()) self.selectedLabelItem.update() self.selectedLabelItem.blockSignals(False) self.selectedLabelItem.endCommand() def chbBackgroundEnableClick(self): if self.chbBackgroundEnable.isChecked(): self.selectedLabelItem.setBackgroundEnabled(True) self.mapItem.updateCachedImage() else: self.selectedLabelItem.setBackgroundEnabled(False) self.mapItem.updateCachedImage() def btnLabelFontClick(self): dlgFont = QFontDialog(self) dlgFont.setCurrentFont(self.selectedLabelItem.font()) result = dlgFont.exec_() if result == 1: self.labelFont = dlgFont.selectedFont() else: self.labelFont = QFont() self.selectedLabelItem.setFont(self.labelFont) def btnLabelColorClick(self): dlgColor = QColorDialog(self) dlgColor.setCurrentColor(self.selectedLabelItem.fontColor()) result = dlgColor.exec_() if result == 1: self.labelColor = dlgColor.selectedColor() self.selectedLabelItem.setFontColor(self.labelColor) def createTempleteAction(self): if self.templeteCreateAction.isChecked() and self.basePMCheck: font = QFont("Arial", 13) font.setItalic(True) self.compLabel1 = QgsComposerLabel(self.scene) self.compLabel1.setFont(font) self.compLabel1.setText("South China Sea") self.compLabel1.setBackgroundEnabled(False) self.compLabel1.setItemPosition(156, 100) self.compLabel1.adjustSizeToText() self.compLabel1.setItemRotation(60) # mapitem = self.scene.composerMapItems() # mapitem[0].addItem(self.compLabel1) self.scene.addItem(self.compLabel1) self.compLabel2 = QgsComposerLabel(self.scene) self.compLabel2.setFont(font) self.compLabel2.setText("Straits Of Malacca") self.compLabel2.setBackgroundEnabled(False) self.compLabel2.setItemPosition(35, 100) self.compLabel2.adjustSizeToText() self.compLabel2.setItemRotation(60) self.scene.addItem(self.compLabel2) font.setItalic(False) self.compLabel3 = QgsComposerLabel(self.scene) self.compLabel3.setFont(font) self.compLabel3.setBackgroundEnabled(False) self.compLabel3.setText("THAILAND") self.compLabel3.setItemPosition(68, 60) self.compLabel3.adjustSizeToText() # self.compLabel3.setItemRotation(0.5) self.scene.addItem(self.compLabel3) # self.templeteCreateAction.setChecked(False) self.compLabel4 = QgsComposerLabel(self.scene) self.compLabel4.setFont(font) self.compLabel4.setBackgroundEnabled(False) self.compLabel4.setText("SINGAPORE") self.compLabel4.setItemPosition(141, 218) self.compLabel4.adjustSizeToText() # self.compLabel3.setItemRotation(0.5) self.scene.addItem(self.compLabel4) self.templeteCreateAction.setChecked(False) self.compLabel4.setSelected(True) elif self.templeteCreateAction.isChecked( ) and self.basePMCheck == False: font = QFont("Arial", 14) font.setItalic(True) self.compLabel5 = QgsComposerLabel(self.scene) self.compLabel5.setFont(font) self.compLabel5.setText("South China Sea") self.compLabel5.setBackgroundEnabled(False) self.compLabel5.setItemPosition(108, 86) self.compLabel5.adjustSizeToText() self.compLabel5.setItemRotation(-45) # mapitem = self.scene.composerMapItems() # mapitem[0].addItem(self.compLabel1) self.scene.addItem(self.compLabel5) self.compLabel6 = QgsComposerLabel(self.scene) self.compLabel6.setFont(font) self.compLabel6.setText("Sulu Sea") self.compLabel6.setBackgroundEnabled(False) self.compLabel6.setItemPosition(236, 38) self.compLabel6.adjustSizeToText() self.compLabel6.setItemRotation(45) self.scene.addItem(self.compLabel6) font.setItalic(False) self.compLabel7 = QgsComposerLabel(self.scene) self.compLabel7.setFont(font) self.compLabel7.setBackgroundEnabled(False) self.compLabel7.setText("Celebes Sea") self.compLabel7.setItemPosition(242, 112) self.compLabel7.adjustSizeToText() self.compLabel7.setItemRotation(-45) # self.compLabel3.setItemRotation(0.5) self.scene.addItem(self.compLabel7) # self.templeteCreateAction.setChecked(False) self.compLabel8 = QgsComposerLabel(self.scene) self.compLabel8.setFont(font) self.compLabel8.setBackgroundEnabled(False) self.compLabel8.setText("INDONESIA\n(Kalimantan)") self.compLabel8.setItemPosition(172, 148, 32, 16) # self.compLabel8.setHAlign(Qt.AlignHCenter) # self.compLabel8.setVAlign(Qt.AlignVCenter) # self.compLabel8.setFrameEnabled(False) # self.compLabel8.setItemPosition() # self.compLabel8.adjustSizeToText() # self.compLabl3.setItemRotation(0.5) self.scene.addItem(self.compLabel8) self.compLabel9 = QgsComposerLabel(self.scene) self.compLabel9.setFont(font) self.compLabel9.setBackgroundEnabled(False) self.compLabel9.setText("BRUNEI") self.compLabel9.setItemPosition(136, 83) self.compLabel9.adjustSizeToText() # self.compLabl3.setItemRotation(0.5) self.scene.addItem(self.compLabel9) self.templeteCreateAction.setChecked(False) pass def actionMapRefresh_triggered(self): self.view.setCurrentTool(QgsComposerView.AddRectangle) def setSelectionTool(self): self.view.deleteSelectedItems() font = QFont("Arial", 14) newLabelItem = QgsComposerLabel(self.scene) newLabelItem.setText("QGIS") newLabelItem.setFont(font) newLabelItem.setItemPosition(self.scenePoint.x(), self.scenePoint.y()) newLabelItem.adjustSizeToText() self.scene.addItem(newLabelItem) # selectItemPoint = self.scene.composerItemAt(self.scenePoint) newLabelItem.setSelected(True) self.groupBox.setEnabled(True) self.selectedLabelItem = newLabelItem # txt = self.selectedLabelItem.text() # textDoc = QTextDocument(txt) self.labelText.setPlainText(self.selectedLabelItem.text()) # self.scene.setSelectedItem(self.newLabelItem) self.view.setCurrentTool(QgsComposerView.Select) # self.selectedLabelItem = self.view.currentTool() self.textItemAction.setChecked(False) def selectedItemDisplay(self, item): if self.scene.plotStyle() != QgsComposition.Preview: self.scene.setPlotStyle(QgsComposition.Preview) self.mapItem.setPreviewMode(QgsComposerMap.Render) self.mapItem.updateCachedImage() item._class_ = QgsComposerLabel # selectedItems = self.scene.selectedComposerItems(True) # if isinstance(item, QgsComposerItem): # self.selectedLabelItem = item # if isinstance(item, QGraphicsRectItem): # self.selectedLabelItem = item if isinstance(item, QgsComposerLabel): self.selectedLabelItem = item self.groupBox.setEnabled(True) self.labelText.setPlainText(self.selectedLabelItem.text()) self.spinLabelRotation.setValue(self.selectedLabelItem.rotation()) else: self.groupBox.setEnabled(False) # print "debug" itemName = self.view.currentTool() if itemName == 5: item.setText("label") pass def deleteItem(self): self.view.deleteSelectedItems()
def addActions(): actn = QAction(winLegend) actn.setIcon(qgis.utils.iface.actionShowSelectedLayers().icon()) actn.setIconText('Show selected layers') actn.setObjectName('showLayer') actn.triggered.connect(self.onAction) toolBar.addAction(actn) actn = QAction(winLegend) actn.setIcon(qgis.utils.iface.actionHideSelectedLayers().icon()) actn.setIconText('Hide selected layers') actn.setObjectName('hideLayer') actn.triggered.connect(self.onAction) toolBar.addAction(actn) actn = QAction(winLegend) actn.setIcon(qgis.utils.iface.actionRemoveLayer().icon()) actn.setIconText('Remove selected layers') actn.setObjectName('removeLayer') actn.triggered.connect(self.onAction) toolBar.addAction(actn) toolBar.addSeparator() actn = QAction(winLegend) actn.setIcon(qgis.utils.iface.actionDuplicateLayer().icon()) actn.setIconText('Add selected layers from main map') actn.setObjectName('addLayer') actn.triggered.connect(self.onAction) toolBar.addAction(actn) actn = QAction(winLegend) actn.setIcon( QIcon( os.path.join(os.path.dirname(__file__), 'mActionCurrentLayer.png'))) actn.setIconText('Current layer for main map') actn.setObjectName('currentLayer') actn.triggered.connect(self.onAction) toolBar.addAction(actn) actn = QAction(winLegend) actn.setIcon( QIcon( os.path.join(os.path.dirname(__file__), 'mActionAddGroup.png'))) actn.setObjectName('syncGroup') actn.triggered.connect(self.onAction) toolBar.addAction(actn)
class Plugin: """The QGIS interface implementation for the InaSAFE plugin. This class acts as the 'glue' between QGIS and our custom logic. It creates a toolbar and menubar entry and launches the InaSAFE user interface if these are activated. """ def __init__(self, iface): """Class constructor. On instantiation, the plugin instance will be assigned a copy of the QGIS iface object which will allow this plugin to access and manipulate the running QGIS instance that spawned it. :param iface:Quantum GIS iface instance. This instance is automatically passed to the plugin by QGIS when it loads the plugin. :type iface: QGisAppInterface """ # Save reference to the QGIS interface self.iface = iface self.translator = None self.toolbar = None self.actions = [] # list of all QActions we create for InaSAFE self.setup_i18n() #print self.tr('InaSAFE') custom_logging.setup_logger() # For enable/disable the keyword editor icon self.iface.currentLayerChanged.connect(self.layer_changed) #noinspection PyArgumentList def setup_i18n(self, preferred_locale=None): """Setup internationalisation for the plugin. See if QGIS wants to override the system locale and then see if we can get a valid translation file for whatever locale is effectively being used. :param preferred_locale: If set will override any other way of determining locale. :type preferred_locale: str, None :raises: TranslationLoadException """ myOverrideFlag = QSettings().value('locale/overrideFlag', False) if preferred_locale is not None: myLocaleName = preferred_locale elif myOverrideFlag: myLocaleName = QSettings().value('locale/userLocale', '') else: myLocaleName = QLocale.system().name() # NOTES: we split the locale name because we need the first two # character i.e. 'id', 'af, etc myLocaleName = str(myLocaleName).split('_')[0] # Also set the system locale to the user overridden local # so that the inasafe library functions gettext will work # .. see:: :py:func:`common.utilities` os.environ['LANG'] = str(myLocaleName) LOGGER.debug('%s %s %s %s' % ( preferred_locale, myOverrideFlag, QLocale.system().name(), os.environ['LANG'])) myRoot = os.path.abspath(os.path.join(os.path.dirname(__file__), '..')) myTranslationPath = os.path.join( myRoot, 'safe_qgis', 'i18n', 'inasafe_' + str(myLocaleName) + '.qm') if os.path.exists(myTranslationPath): self.translator = QTranslator() myResult = self.translator.load(myTranslationPath) if not myResult: myMessage = 'Failed to load translation for %s' % myLocaleName raise TranslationLoadError(myMessage) # noinspection PyTypeChecker QCoreApplication.installTranslator(self.translator) LOGGER.debug('%s %s' % ( myTranslationPath, os.path.exists(myTranslationPath))) 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 return QCoreApplication.translate('Plugin', message) def add_action(self, action, add_to_toolbar=True): """Add a toolbar icon to the InaSAFE toolbar. :param action: The action that should be added to the toolbar. :type action: QAction :param add_to_toolbar: Flag indicating whether the action should also be added to the InaSAFE toolbar. Defaults to True. :type add_to_toolbar: bool """ # store in the class list of actions for easy plugin unloading self.actions.append(action) self.iface.addPluginToMenu(self.tr('InaSAFE'), action) if add_to_toolbar: self.toolbar.addAction(action) #noinspection PyCallByClass def initGui(self): """Gui initialisation procedure (for QGIS plugin api). .. note:: Don't change the name of this method from initGui! This method is called by QGIS and should be used to set up any graphical user interface elements that should appear in QGIS by default (i.e. before the user performs any explicit action with the plugin). """ self.toolbar = self.iface.addToolBar('InaSAFE') self.toolbar.setObjectName('InaSAFEToolBar') # Import dock here as it needs to be imported AFTER i18n is set up from safe_qgis.widgets.dock import Dock self.dockWidget = None #-------------------------------------- # Create action for plugin dockable window (show/hide) #-------------------------------------- # pylint: disable=W0201 self.actionDock = QAction( QIcon(':/plugins/inasafe/icon.svg'), self.tr('Toggle InaSAFE Dock'), self.iface.mainWindow()) self.actionDock.setObjectName('InaSAFEDockToggle') self.actionDock.setStatusTip(self.tr( 'Show/hide InaSAFE dock widget')) self.actionDock.setWhatsThis(self.tr( 'Show/hide InaSAFE dock widget')) self.actionDock.setCheckable(True) self.actionDock.setChecked(True) self.actionDock.triggered.connect(self.toggle_dock_visibility) self.add_action(self.actionDock) #-------------------------------------- # Create action for keywords editor #-------------------------------------- self.actionKeywordsDialog = QAction( QIcon(':/plugins/inasafe/show-keyword-editor.svg'), self.tr('InaSAFE Keyword Editor'), self.iface.mainWindow()) self.actionKeywordsDialog.setStatusTip(self.tr( 'Open InaSAFE keywords editor')) self.actionKeywordsDialog.setWhatsThis(self.tr( 'Open InaSAFE keywords editor')) self.actionKeywordsDialog.setEnabled(False) self.actionKeywordsDialog.triggered.connect(self.show_keywords_editor) self.add_action(self.actionKeywordsDialog) #-------------------------------------- # Create action for reset icon #-------------------------------------- self.actionResetDock = QAction( QIcon(':/plugins/inasafe/reset-dock.svg'), self.tr('Reset Dock'), self.iface.mainWindow()) self.actionResetDock.setStatusTip(self.tr( 'Reset the InaSAFE Dock')) self.actionResetDock.setWhatsThis(self.tr( 'Reset the InaSAFE Dock')) self.actionResetDock.triggered.connect(self.reset_dock) self.add_action(self.actionResetDock) #-------------------------------------- # Create action for options dialog #-------------------------------------- self.actionOptions = QAction( QIcon(':/plugins/inasafe/configure-inasafe.svg'), self.tr('InaSAFE Options'), self.iface.mainWindow()) self.actionOptions.setStatusTip(self.tr( 'Open InaSAFE options dialog')) self.actionOptions.setWhatsThis(self.tr( 'Open InaSAFE options dialog')) self.actionOptions.triggered.connect(self.show_options) self.add_action(self.actionOptions) #-------------------------------------- # Create action for impact functions doc dialog #-------------------------------------- self.actionFunctionBrowser = QAction( QIcon(':/plugins/inasafe/show-impact-functions.svg'), self.tr('InaSAFE Impact Functions Browser'), self.iface.mainWindow()) self.actionFunctionBrowser.setStatusTip(self.tr( 'Open InaSAFE Impact Functions Browser')) self.actionFunctionBrowser.setWhatsThis(self.tr( 'Open InaSAFE Impact Functions Browser')) self.actionFunctionBrowser.triggered.connect( self.show_function_browser) self.add_action(self.actionFunctionBrowser) # Short cut for Open Impact Functions Doc self.keyAction = QAction("Test Plugin", self.iface.mainWindow()) self.iface.registerMainWindowAction(self.keyAction, "F7") self.keyAction.triggered.connect(self.shortcut_f7) #--------------------------------------- # Create action for minimum needs dialog #--------------------------------------- self.actionMinimumNeeds = QAction( QIcon(':/plugins/inasafe/show-minimum-needs.svg'), self.tr('InaSAFE Minimum Needs Tool'), self.iface.mainWindow()) self.actionMinimumNeeds.setStatusTip(self.tr( 'Open InaSAFE minimum needs tool')) self.actionMinimumNeeds.setWhatsThis(self.tr( 'Open InaSAFE minimum needs tool')) self.actionMinimumNeeds.triggered.connect(self.show_minimum_needs) self.add_action(self.actionMinimumNeeds) #--------------------------------------- # Create action for converter dialog #--------------------------------------- self.actionConverter = QAction( QIcon(':/plugins/inasafe/show-converter-tool.svg'), self.tr('InaSAFE Converter'), self.iface.mainWindow()) self.actionConverter.setStatusTip(self.tr( 'Open InaSAFE Converter')) self.actionConverter.setWhatsThis(self.tr( 'Open InaSAFE Converter')) self.actionConverter.triggered.connect(self.show_shakemap_importer) self.add_action(self.actionConverter) #--------------------------------------- # Create action for batch runner dialog #--------------------------------------- self.actionBatchRunner = QAction( QIcon(':/plugins/inasafe/show-batch-runner.svg'), self.tr('InaSAFE Batch Runner'), self.iface.mainWindow()) self.actionBatchRunner.setStatusTip(self.tr( 'Open InaSAFE Batch Runner')) self.actionBatchRunner.setWhatsThis(self.tr( 'Open InaSAFE Batch Runner')) self.actionBatchRunner.triggered.connect(self.show_batch_runner) self.add_action(self.actionBatchRunner) #--------------------------------------- # Create action for batch runner dialog #--------------------------------------- self.actionSaveScenario = QAction( QIcon(':/plugins/inasafe/save-as-scenario.svg'), self.tr('Save current scenario'), self.iface.mainWindow()) myMessage = self.tr('Save current scenario to text file') self.actionSaveScenario.setStatusTip(myMessage) self.actionSaveScenario.setWhatsThis(myMessage) # noinspection PyUnresolvedReferences self.actionSaveScenario.triggered.connect(self.save_scenario) self.add_action(self.actionSaveScenario) #-------------------------------------- # Create action for import OSM Dialog #-------------------------------------- self.actionImportDlg = QAction( QIcon(':/plugins/inasafe/show-osm-download.svg'), self.tr('InaSAFE OpenStreetMap Downloader'), self.iface.mainWindow()) self.actionImportDlg.setStatusTip(self.tr( 'InaSAFE OpenStreetMap Downloader')) self.actionImportDlg.setWhatsThis(self.tr( 'InaSAFE OpenStreetMap Downloader')) self.actionImportDlg.triggered.connect(self.show_osm_downloader) self.add_action(self.actionImportDlg) #-------------------------------------- # create dockwidget and tabify it with the legend #-------------------------------------- self.dockWidget = Dock(self.iface) self.iface.addDockWidget(Qt.RightDockWidgetArea, self.dockWidget) myLegendTab = self.iface.mainWindow().findChild(QApplication, 'Legend') if myLegendTab: self.iface.mainWindow().tabifyDockWidget( myLegendTab, self.dockWidget) self.dockWidget.raise_() # # Hook up a slot for when the dock is hidden using its close button # or view-panels # self.dockWidget.visibilityChanged.connect(self.toggle_inasafe_action) # pylint: disable=W0201 def clear_modules(self): """Unload inasafe functions and try to return QGIS to before InaSAFE. """ from safe.impact_functions import core core.unload_plugins() # next lets force remove any inasafe related modules myModules = [] for myModule in sys.modules: if 'inasafe' in myModule: # Check if it is really one of our modules i.e. exists in the # plugin directory myTokens = myModule.split('.') myPath = '' for myToken in myTokens: myPath += os.path.sep + myToken myParent = os.path.abspath(os.path.join( __file__, os.path.pardir, os.path.pardir)) myFullPath = os.path.join(myParent, myPath + '.py') if os.path.exists(os.path.abspath(myFullPath)): LOGGER.debug('Removing: %s' % myModule) myModules.append(myModule) for myModule in myModules: del (sys.modules[myModule]) for myModule in sys.modules: if 'inasafe' in myModule: print myModule # Lets also clean up all the path additions that were made myPackagePath = os.path.abspath(os.path.join( os.path.dirname(__file__), os.path.pardir)) LOGGER.debug('Path to remove: %s' % myPackagePath) # We use a list comprehension to ensure duplicate entries are removed LOGGER.debug(sys.path) sys.path = [y for y in sys.path if myPackagePath not in y] LOGGER.debug(sys.path) def unload(self): """GUI breakdown procedure (for QGIS plugin api). .. note:: Don't change the name of this method from unload! This method is called by QGIS and should be used to *remove* any graphical user interface elements that should appear in QGIS. """ # Remove the plugin menu item and icon for myAction in self.actions: self.iface.removePluginMenu(self.tr('InaSAFE'), myAction) self.iface.removeToolBarIcon(myAction) self.iface.mainWindow().removeDockWidget(self.dockWidget) self.iface.mainWindow().removeToolBar(self.toolbar) self.dockWidget.setVisible(False) self.dockWidget.destroy() self.iface.currentLayerChanged.disconnect(self.layer_changed) self.clear_modules() def toggle_inasafe_action(self, checked): """Check or uncheck the toggle inaSAFE toolbar button. This slot is called when the user hides the inaSAFE panel using its close button or using view->panels. :param checked: True if the dock should be shown, otherwise False. :type checked: bool """ self.actionDock.setChecked(checked) # Run method that performs all the real work def toggle_dock_visibility(self): """Show or hide the dock widget.""" if self.dockWidget.isVisible(): self.dockWidget.setVisible(False) else: self.dockWidget.setVisible(True) self.dockWidget.raise_() def show_minimum_needs(self): """Show the minimum needs dialog.""" # import here only so that it is AFTER i18n set up from safe_qgis.tools.minimum_needs import MinimumNeeds myDialog = MinimumNeeds(self.iface.mainWindow()) myDialog.exec_() # modal def show_options(self): """Show the options dialog.""" # import here only so that it is AFTER i18n set up from safe_qgis.tools.options_dialog import OptionsDialog myDialog = OptionsDialog( self.iface, self.dockWidget, self.iface.mainWindow()) myDialog.exec_() # modal def show_keywords_editor(self): """Show the keywords editor.""" # import here only so that it is AFTER i18n set up from safe_qgis.tools.keywords_dialog import KeywordsDialog if self.iface.activeLayer() is None: return myDialog = KeywordsDialog( self.iface.mainWindow(), self.iface, self.dockWidget) myDialog.exec_() # modal def show_function_browser(self): """Show the impact function browser tool.""" # import here only so that it is AFTER i18n set up from safe_qgis.tools.function_browser import FunctionBrowser myDialog = FunctionBrowser(self.iface.mainWindow()) myDialog.exec_() # modal def show_shakemap_importer(self): """Show the converter dialog.""" # import here only so that it is AFTER i18n set up from safe_qgis.tools.shakemap_importer import ShakemapImporter myDialog = ShakemapImporter(self.iface.mainWindow()) myDialog.exec_() # modal def show_osm_downloader(self): """Show the OSM buildings downloader dialog.""" from safe_qgis.tools.osm_downloader import OsmDownloader dialog = OsmDownloader(self.iface.mainWindow(), self.iface) dialog.exec_() # modal def show_batch_runner(self): """Show the batch runner dialog.""" from safe_qgis.batch.batch_dialog import BatchDialog myDialog = BatchDialog( parent=self.iface.mainWindow(), iface=self.iface, dock=self.dockWidget) myDialog.exec_() # modal def save_scenario(self): """Save current scenario to text file,""" self.dockWidget.save_current_scenario() def reset_dock(self): """Reset the dock to its default state.""" self.dockWidget.get_layers() def layer_changed(self, layer): """Enable or disable keywords editor icon when active layer changes. :param layer: The layer that is now active. :type layer: QgsMapLayer """ if layer is None: self.actionKeywordsDialog.setEnabled(False) else: self.actionKeywordsDialog.setEnabled(True) def shortcut_f7(self): """Executed when user press F7 - will show the shakemap importer.""" self.show_shakemap_importer()
def create_action( icon_path, text, callback, enabled_flag=True, status_tip=None, whats_this=None, parent=None, object_name=None): """ # adapted from RedLayers by E. Ferreguti Create an action. :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 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. :param object_name: Optional name to identify objects during customization :type object_name: str :returns: The action that was created. :rtype: QAction """ icon = QIcon(icon_path) action = QAction(icon, text, parent) if callback: action.triggered.connect(callback) action.setEnabled(enabled_flag) if status_tip: action.setStatusTip(status_tip) if whats_this: action.setWhatsThis(whats_this) if object_name: action.setObjectName(object_name) return action
class RECS: """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', 'RECS_HOME_{}.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) # Create the dialog (after translation) and keep reference self.initdlg=InitTaskDialog() self.selectdlg = SelectTaskDialog() self.loginDlg=LogInDialog() self.taskMgrDlg=TaskManagerDialog() self.taskInfoDlg=taskInfo() self.taskFeaturesDlg=taskFeatures() #self.loadmapDlg=LoadMapDialog() # Declare instance attributes self.actions = [] self.menu = self.tr(u'&Task') self.logIn() self.selectTask() self.actions = [] self.toolbar = self.iface.addToolBar(u'Recs') self.toolbar.setObjectName(u'Recs') # layer.editingStarted.connect(editLayer() ) # TODO: We are going to let the user set this up in a future iteration #self.toolbar = self.iface.addToolBar(u'SelectTask') #self.toolbar.setObjectName(u'SelectTask') # 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('Tasks', 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 """ 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.menu = QMenu( "&Task", self.iface.mainWindow().menuBar() ) action = self.iface.mainWindow().menuBar().actions() lastAction = action[-1] self.iface.addPluginToMenu( self.menu, lastAction) self.actions.append(lastAction) return action def initGui(self): """Create the menu entries and toolbar icons inside the QGIS GUI.""" """Create the menu entries and toolbar icons inside the QGIS GUI.""" """ Task menu setting """ self.menu = QMenu(self.iface.mainWindow()) self.menu.setObjectName("task_menu_object") self.menu.setTitle("Task") """ Task """ self.action_tasks = QAction(QIcon('::/plugins/RECS/aacadisicon.png'), "Tasks", self.iface.mainWindow()) self.action_tasks.setObjectName("Task_action_object") self.action_tasks.setWhatsThis("Task Initialized") #QtCore.QObject.connect(self.action_tasks, SIGNAL("triggered()"), self.tasks) """ Initializing Task """ self.action_init_task = QAction(QIcon('::/plugins/RECS/aacadisicon.png'), "Initialize ", self.iface.mainWindow()) self.action_init_task.setObjectName("Task_action_object") self.action_init_task.setWhatsThis("Task Initialize") QtCore.QObject.connect(self.action_init_task, SIGNAL("triggered()"), self.initTask) """ Select Task """ self.action_select_task = QAction(QIcon(':/plugins/RECS/aacadisicon.png'), "Select Task", self.iface.mainWindow()) self.action_select_task.setObjectName("Task_Select_object") self.action_select_task.setWhatsThis("Select Task") QtCore.QObject.connect(self.action_select_task, SIGNAL("triggered()"), self.selectTask) """ Reload Task """ self.action_reload_task = QAction(QIcon(':/plugins/RECS/aacadisicon.png'), "Reload Task", self.iface.mainWindow()) self.action_reload_task.setObjectName("Task_Reload_object") self.action_reload_task.setWhatsThis("Reload Task") QtCore.QObject.connect(self.action_reload_task, SIGNAL("triggered()"), self.taskManager) """ Edit Task """ self.action_edit_task = QAction(QIcon(':/plugins/RECS/aacadisicon.png'), "Edit Task", self.iface.mainWindow()) self.action_edit_task.setObjectName("Task_Edit_object") self.action_edit_task.setWhatsThis("Edit Task") QtCore.QObject.connect(self.action_edit_task, SIGNAL("triggered()"), self.editLayer) """ Finish Task """ self.action_finish_task = QAction(QIcon(':/plugins/RECS/aacadisicon.png'), "Finish Task", self.iface.mainWindow()) self.action_finish_task.setObjectName("Task_Finish_object") self.action_finish_task.setWhatsThis("Edit Task") QtCore.QObject.connect(self.action_finish_task, SIGNAL("triggered()"), self.finishEditngLayer) """ Add action to the menu list """ #self.menuTask.addAction(self.action_tasks) self.menu.addAction(self.action_init_task) self.menu.addAction(self.action_select_task) self.menu.addAction(self.action_reload_task) self.menu.addAction(self.action_edit_task) self.menu.addAction(self.action_finish_task) """ Add menu to the menubar """ menubar=self.iface.mainWindow().menuBar() menubar.insertMenu(self.iface.firstRightStandardMenu().menuAction(),self.menu) """ Add icon to the toolbar """ #self.iface.addPluginToMenu(u"&load Map", self.action_loadmap) #self.iface.addToolBarIcon(self.action_init_task) def unload(self): """Removes the plugin menu item and icon from QGIS GUI.""" for action in self.actions: self.iface.removePluginMenu( self.tr(u'&Task_Manager'), action) self.iface.removeToolBarIcon(action) # remove the toolbar del self.toolbar def initTask(self): layers = self.iface.legendInterface().layers() #layer_list = [] for layer in layers: #layer_list.append(layer.name()) if layer.name() == 'PARCEL': self.iface.setActiveLayer(layer) self.initdlg.show() #layer_list=list(set(layer_list)) #self.initdlg.comboBox.addItems(layer_list) self.initdlg.setFixedSize(self.initdlg.size()) result = self.initdlg.exec_() if result: pass def selectTask(self): self.selectdlg.show() self.selectdlg.setFixedSize(self.selectdlg.size()) self.selectdlg.loadLayer() self.selectdlg.populate() result = self.selectdlg.exec_() if result: # self.selectdlg.close() pass def showTaskInfo(self): self.taskInfoDlg.show() t_id = self.taskMgrDlg.retTaskID() self.taskInfoDlg.getAttribData(t_id) #self.taskInfoDlg.populate() def taskManager(self): if self.taskMgrDlg.isVisible(): self.taskMgrDlg.loadTaskClicked() # self.taskMgrDlg.close() # self.apdockwidget.close() else: self.taskMgrDlg.show() self.apdockwidget = QDockWidget("Task Manager", self.iface.mainWindow()) self.apdockwidget.setWindowFlags(Qt.FramelessWindowHint) self.apdockwidget.setWidget(self.taskMgrDlg) self.iface.addDockWidget(Qt.RightDockWidgetArea, self.apdockwidget) self.taskMgrDlg.populate() self.taskFeatures() # rows = self.taskMgrDlg.taskListTable.rowCount() # createdByList=[] # # # for row in range(0,rows): # createdByItems=self.taskMgrDlg.taskListTable.item(row,1) # createdByList.append(createdByItems.text()) # # # createdByList=list(set(createdByList)) # self.taskMgrDlg.createByComboBox.addItems(createdByList) # self.taskMgrDlg.createByComboBox.setCurrentIndex(createdByList.index()) self.menu = QtGui.QMenu() #newTask=self.menu.addAction("New Task",self.newTask,"") newTask = self.menu.addAction("New Task", self.newTaskEvent) loadTask = self.menu.addAction("Load Task", self.loadTaskEvent) cancelTask = self.menu.addAction("Cancel Task", self.cancelTaskEvent) showTaskArea = self.menu.addAction("Show Task Area", self.showTaskAreaEvent) noTask=self.menu.addAction("No Task",self.noTaskEvent) showTaskInfo=self.menu.addAction("Show Task Info",self.showTaskInfoEvent) updateFeature=self.menu.addAction("Update Features",self.updateFeatureEvent) self.taskMgrDlg.taskListTable.addAction(newTask) self.taskMgrDlg.taskListTable.addAction(loadTask) self.taskMgrDlg.taskListTable.addAction(cancelTask) self.taskMgrDlg.taskListTable.addAction(showTaskArea) self.taskMgrDlg.taskListTable.addAction(noTask) self.taskMgrDlg.taskListTable.addAction(showTaskInfo) self.taskMgrDlg.taskListTable.addAction(updateFeature) self.taskMgrDlg.taskListTable.setContextMenuPolicy(QtCore.Qt.CustomContextMenu) self.taskMgrDlg.taskListTable.customContextMenuRequested.connect(self.contextMenuEvent) result = self.taskMgrDlg.exec_() if result: self.taskMgrDlg.populate() #self.connect(self.dateTimeEdit,SIGNAL("dateTimeChange def contextMenuEvent(self, point): self.menu.exec_(self.taskMgrDlg.taskListTable.mapToGlobal(point)) def newTaskEvent(self): self.initTask() def loadTaskEvent(self): self.taskMgrDlg.loadTaskClicked() t_id = self.taskMgrDlg.retTaskID() self.taskFeaturesDlg.populate(t_id) def cancelTaskEvent(self): self.taskMgrDlg.cancelTask() def showTaskAreaEvent(self): self.taskMgrDlg.showTaskAreaClicked() def noTaskEvent(self): print "noTask Called" def showTaskInfoEvent(self): self.showTaskInfo() def updateFeatureEvent(self): print "updateFeature" def logIn(self): self.loginDlg.show() self.loginDlg.setWindowFlags(Qt.FramelessWindowHint) result = self.loginDlg.exec_() if result: pass def loadLayer(self): self.mlr = None # QgsMapLayerRegistry.instance().removeAllMapLayers() self.mlr = QgsMapLayerRegistry.instance() uri = QgsDataSourceURI() uri.setConnection("172.20.0.71", "5432", "ncrprs_db", "postgres", "123456") uri.setDataSource("recs", "t_parcel", "parcelgeometry", "") vlayer = QgsVectorLayer(uri.uri(), "Parcel", "postgres") if vlayer.isValid(): self.mlr.addMapLayer(vlayer) else: QMessageBox.information(None, "Unable to Laod Data", "Unable to Load Layers from the Database!") return None def editLayer(self): global taskLayer global featCount layers = self.iface.legendInterface().layers() for layer in layers: if layer.name() == 'TaskLayer': taskLayer = layer taskLayerID=layer.id() self.iface.setActiveLayer(taskLayer) featCount = taskLayer.featureCount() print featCount taskLayer.startEditing() QgsProject.instance().setSnapSettingsForLayer(taskLayerID,True,2,1,20,True) def finishEditngLayer(self): """ change the edits to GML again to detect the changes """ print featCount taskLayer_shape = iface.activeLayer() QgsVectorFileWriter.writeAsVectorFormat(taskLayer_shape,"Z:\\GMLEdited\\temp.gml","utf-8",None,"GML") #QgsMapLayerRegistry.instance().removeAllMapLayers() iface.addVectorLayer("Z:\\GMLEdited\\temp.gml","EditedTaskLayer","ogr") """ Compare the two gml geometries """ doc_edited = xml.dom.minidom.parse("Z:\\GMLEdited\\temp.gml") doc_origion = xml.dom.minidom.parse("Z:\\GMLFile\\ogrGML.gml") editedParcel = doc_edited.getElementsByTagName("gml:featureMember") epLength = editedParcel.length print epLength obj = GeometryEdit() if epLength > featCount: obj.split(doc_edited,doc_origion) print "split" elif epLength < featCount: obj.merge(doc_edited,doc_origion) print "merge" else: obj.updateGeom() print "update" def taskFeatures(self): self.taskFeaturesDlg.show() self.apdockwidget = QDockWidget("Features Of Current Task", self.iface.mainWindow()) self.apdockwidget.setWindowFlags(Qt.FramelessWindowHint) self.apdockwidget.setWidget(self.taskFeaturesDlg) self.iface.addDockWidget(Qt.RightDockWidgetArea, self.apdockwidget) self.menu_feature = QtGui.QMenu() #newTask=self.menu.addAction("New Task",self.newTask,"") editAttr = self.menu_feature.addAction("Edit", self.editEvent) self.taskFeaturesDlg.currentTaskTable.addAction(editAttr) self.taskFeaturesDlg.currentTaskTable.setContextMenuPolicy(QtCore.Qt.CustomContextMenu) self.taskFeaturesDlg.currentTaskTable.customContextMenuRequested.connect(self.contextMenuEvent2) #self.connect(self.dateTimeEdit,SIGNAL("dateTimeChange def contextMenuEvent2(self, point): self.menu_feature.exec_(self.taskFeaturesDlg.currentTaskTable.mapToGlobal(point)) def editEvent(self): self.showTaskInfo()
class Plugin(object): """The QGIS interface implementation for the InaSAFE plugin. This class acts as the 'glue' between QGIS and our custom logic. It creates a toolbar and menu bar entry and launches the InaSAFE user interface if these are activated. """ def __init__(self, iface): """Class constructor. On instantiation, the plugin instance will be assigned a copy of the QGIS iface object which will allow this plugin to access and manipulate the running QGIS instance that spawned it. :param iface:Quantum GIS iface instance. This instance is automatically passed to the plugin by QGIS when it loads the plugin. :type iface: QGisAppInterface """ # Register all the impact functions register_impact_functions() # Save reference to the QGIS interface self.iface = iface self.dock_widget = None self.action_import_dialog = None self.action_save_scenario = None self.action_batch_runner = None self.action_shake_converter = None self.action_minimum_needs = None self.action_minimum_needs_config = None self.action_impact_merge_dlg = None self.key_action = None self.action_options = None self.action_keywords_wizard = None self.action_function_centric_wizard = None self.action_extent_selector = None self.translator = None self.toolbar = None self.wizard = None self.actions = [] # list of all QActions we create for InaSAFE self.action_dock = None self.action_toggle_rubberbands = None self.message_bar_item = None # Flag indicating if toolbar should show only common icons or not self.full_toolbar = False # print self.tr('InaSAFE') # For enable/disable the keyword editor icon self.iface.currentLayerChanged.connect(self.layer_changed) # noinspection PyArgumentList def change_i18n(self, new_locale): """Change internationalisation for the plugin. Override the system locale and then see if we can get a valid translation file for whatever locale is effectively being used. :param new_locale: The new locale i.e. 'id', 'af', etc. :type new_locale: str :raises: TranslationLoadException """ os.environ['INASAFE_LANG'] = str(new_locale) LOGGER.debug('%s %s %s' % ( new_locale, QLocale.system().name(), os.environ['INASAFE_LANG'])) root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..')) translation_path = os.path.join( root, 'safe_qgis', 'i18n', 'inasafe_' + str(new_locale) + '.qm') if os.path.exists(translation_path): self.translator = QTranslator() result = self.translator.load(translation_path) if not result: message = 'Failed to load translation for %s' % new_locale raise TranslationLoadError(message) # noinspection PyTypeChecker,PyCallByClass QCoreApplication.installTranslator(self.translator) LOGGER.debug('%s %s' % ( translation_path, os.path.exists(translation_path))) # 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('Plugin', message) def add_action(self, action, add_to_toolbar=True): """Add a toolbar icon to the InaSAFE toolbar. :param action: The action that should be added to the toolbar. :type action: QAction :param add_to_toolbar: Flag indicating whether the action should also be added to the InaSAFE toolbar. Defaults to True. :type add_to_toolbar: bool """ # store in the class list of actions for easy plugin unloading self.actions.append(action) self.iface.addPluginToMenu(self.tr('InaSAFE'), action) if add_to_toolbar: self.toolbar.addAction(action) def _create_dock_toggle_action(self): """Create action for plugin dockable window (show/hide).""" # pylint: disable=W0201 icon = resources_path('img', 'icons', 'icon.svg') self.action_dock = QAction( QIcon(icon), self.tr('Toggle InaSAFE Dock'), self.iface.mainWindow()) self.action_dock.setObjectName('InaSAFEDockToggle') self.action_dock.setStatusTip(self.tr( 'Show/hide InaSAFE dock widget')) self.action_dock.setWhatsThis(self.tr( 'Show/hide InaSAFE dock widget')) self.action_dock.setCheckable(True) self.action_dock.setChecked(True) self.action_dock.triggered.connect(self.toggle_dock_visibility) self.add_action(self.action_dock) # -------------------------------------- # Create action for keywords creation wizard # ------------------------------------- def _create_keywords_wizard_action(self): """Create action for keywords creation wizard.""" icon = resources_path('img', 'icons', 'show-keyword-wizard.svg') self.action_keywords_wizard = QAction( QIcon(icon), self.tr('Keywords Creation Wizard'), self.iface.mainWindow()) self.action_keywords_wizard.setStatusTip(self.tr( 'Open InaSAFE keywords creation wizard')) self.action_keywords_wizard.setWhatsThis(self.tr( 'Open InaSAFE keywords creation wizard')) self.action_keywords_wizard.setEnabled(False) self.action_keywords_wizard.triggered.connect( self.show_keywords_wizard) self.add_action(self.action_keywords_wizard) def _create_analysis_wizard_action(self): """Create action for IF-centric wizard.""" icon = resources_path('img', 'icons', 'show-wizard.svg') self.action_function_centric_wizard = QAction( QIcon(icon), self.tr('Impact Function Centric Wizard'), self.iface.mainWindow()) self.action_function_centric_wizard.setStatusTip(self.tr( 'Open InaSAFE impact function centric wizard')) self.action_function_centric_wizard.setWhatsThis(self.tr( 'Open InaSAFE impact function centric wizard')) self.action_function_centric_wizard.setEnabled(True) self.action_function_centric_wizard.triggered.connect( self.show_function_centric_wizard) self.add_action(self.action_function_centric_wizard) def _create_options_dialog_action(self): """Create action for options dialog.""" icon = resources_path('img', 'icons', 'configure-inasafe.svg') self.action_options = QAction( QIcon(icon), self.tr('Options'), self.iface.mainWindow()) self.action_options.setStatusTip(self.tr( 'Open InaSAFE options dialog')) self.action_options.setWhatsThis(self.tr( 'Open InaSAFE options dialog')) self.action_options.triggered.connect(self.show_options) self.add_action(self.action_options, add_to_toolbar=self.full_toolbar) def _create_minimum_needs_action(self): """Create action for minimum needs dialog.""" icon = resources_path('img', 'icons', 'show-minimum-needs.svg') self.action_minimum_needs = QAction( QIcon(icon), self.tr('Minimum Needs Calculator'), self.iface.mainWindow()) self.action_minimum_needs.setStatusTip(self.tr( 'Open InaSAFE minimum needs calculator')) self.action_minimum_needs.setWhatsThis(self.tr( 'Open InaSAFE minimum needs calculator')) self.action_minimum_needs.triggered.connect(self.show_minimum_needs) self.add_action( self.action_minimum_needs, add_to_toolbar=self.full_toolbar) def _create_minimum_needs_options_action(self): """Create action for global minimum needs dialog.""" icon = resources_path('img', 'icons', 'show-global-minimum-needs.svg') self.action_minimum_needs_config = QAction( QIcon(icon), self.tr('Minimum Needs Configuration'), self.iface.mainWindow()) self.action_minimum_needs_config.setStatusTip(self.tr( 'Open InaSAFE minimum needs configuration')) self.action_minimum_needs_config.setWhatsThis(self.tr( 'Open InaSAFE minimum needs configuration')) self.action_minimum_needs_config.triggered.connect( self.show_minimum_needs_configuration) self.add_action( self.action_minimum_needs_config, add_to_toolbar=self.full_toolbar) def _create_shakemap_converter_action(self): """Create action for converter dialog.""" icon = resources_path('img', 'icons', 'show-converter-tool.svg') self.action_shake_converter = QAction( QIcon(icon), self.tr('Shakemap Converter'), self.iface.mainWindow()) self.action_shake_converter.setStatusTip(self.tr( 'Open InaSAFE Converter')) self.action_shake_converter.setWhatsThis(self.tr( 'Open InaSAFE Converter')) self.action_shake_converter.triggered.connect( self.show_shakemap_importer) self.add_action( self.action_shake_converter, add_to_toolbar=self.full_toolbar) def _create_batch_runner_action(self): """Create action for batch runner dialog.""" icon = resources_path('img', 'icons', 'show-batch-runner.svg') self.action_batch_runner = QAction( QIcon(icon), self.tr('Batch Runner'), self.iface.mainWindow()) self.action_batch_runner.setStatusTip(self.tr( 'Open Batch Runner')) self.action_batch_runner.setWhatsThis(self.tr( 'Open Batch Runner')) self.action_batch_runner.triggered.connect(self.show_batch_runner) self.add_action( self.action_batch_runner, add_to_toolbar=self.full_toolbar) def _create_save_scenario_action(self): """Create action for save scenario dialog.""" icon = resources_path('img', 'icons', 'save-as-scenario.svg') self.action_save_scenario = QAction( QIcon(icon), self.tr('Save Current Scenario'), self.iface.mainWindow()) message = self.tr('Save current scenario to text file') self.action_save_scenario.setStatusTip(message) self.action_save_scenario.setWhatsThis(message) # noinspection PyUnresolvedReferences self.action_save_scenario.triggered.connect(self.save_scenario) self.add_action( self.action_save_scenario, add_to_toolbar=self.full_toolbar) def _create_osm_downloader_action(self): """Create action for import OSM Dialog.""" icon = resources_path('img', 'icons', 'show-osm-download.svg') self.action_import_dialog = QAction( QIcon(icon), self.tr('OpenStreetMap Downloader'), self.iface.mainWindow()) self.action_import_dialog.setStatusTip(self.tr( 'OpenStreetMap Downloader')) self.action_import_dialog.setWhatsThis(self.tr( 'OpenStreetMap Downloader')) self.action_import_dialog.triggered.connect(self.show_osm_downloader) self.add_action(self.action_import_dialog) def _create_add_osm_layer_action(self): """Create action for import OSM Dialog.""" icon = resources_path('img', 'icons', 'add-osm-tiles-layer.svg') self.action_add_osm_layer = QAction( QIcon(icon), self.tr('Add OpenStreetMap Tile Layer'), self.iface.mainWindow()) self.action_add_osm_layer.setStatusTip(self.tr( 'Add OpenStreetMap Tile Layer')) self.action_add_osm_layer.setWhatsThis(self.tr( 'Use this to add an OSM layer to your map. ' 'It needs internet access to function.')) self.action_add_osm_layer.triggered.connect(self.add_osm_layer) self.add_action(self.action_add_osm_layer) def _create_add_petajakarta_layer_action(self): """Create action for import OSM Dialog.""" icon = resources_path('img', 'icons', 'add-petajakarta-layer.svg') self.action_add_petajakarta_layer = QAction( QIcon(icon), self.tr('Add PetaJakarta Flood Layer'), self.iface.mainWindow()) self.action_add_petajakarta_layer.setStatusTip(self.tr( 'Add PetaJakarta Flood Layer')) self.action_add_petajakarta_layer.setWhatsThis(self.tr( 'Use this to add a PetaJakarta layer to your map. ' 'It needs internet access to function.')) self.action_add_petajakarta_layer.triggered.connect( self.add_petajakarta_layer) self.add_action( self.action_add_petajakarta_layer, add_to_toolbar=False) def _create_impact_merge_action(self): """Create action for impact layer merge Dialog.""" icon = resources_path('img', 'icons', 'show-impact-merge.svg') self.action_impact_merge_dlg = QAction( QIcon(icon), self.tr('Impact Layer Merger'), self.iface.mainWindow()) self.action_impact_merge_dlg.setStatusTip(self.tr( 'Impact Layer Merger')) self.action_impact_merge_dlg.setWhatsThis(self.tr( 'Impact Layer Merger')) self.action_impact_merge_dlg.triggered.connect(self.show_impact_merge) self.add_action( self.action_impact_merge_dlg, add_to_toolbar=self.full_toolbar) def _create_rubber_bands_action(self): """Create action for toggling rubber bands.""" icon = resources_path('img', 'icons', 'toggle-rubber-bands.svg') self.action_toggle_rubberbands = QAction( QIcon(icon), self.tr('Toggle Scenario Outlines'), self.iface.mainWindow()) message = self.tr('Toggle rubber bands showing scenario extents.') self.action_toggle_rubberbands.setStatusTip(message) self.action_toggle_rubberbands.setWhatsThis(message) # Set initial state self.action_toggle_rubberbands.setCheckable(True) settings = QSettings() flag = bool(settings.value( 'inasafe/showRubberBands', False, type=bool)) self.action_toggle_rubberbands.setChecked(flag) # noinspection PyUnresolvedReferences self.action_toggle_rubberbands.triggered.connect( self.dock_widget.toggle_rubber_bands) self.add_action(self.action_toggle_rubberbands) def _create_analysis_extent_action(self): """Create action for analysis extent dialog.""" icon = resources_path('img', 'icons', 'set-extents-tool.svg') self.action_extent_selector = QAction( QIcon(icon), self.tr('Set Analysis Area'), self.iface.mainWindow()) self.action_extent_selector.setStatusTip(self.tr( 'Set the analysis area for InaSAFE')) self.action_extent_selector.setWhatsThis(self.tr( 'Set the analysis area for InaSAFE')) self.action_extent_selector.triggered.connect( self.show_extent_selector) self.add_action(self.action_extent_selector) def _create_test_layers_action(self): """Create action for adding layers (developer mode, non final only).""" final_release = release_status() == 'final' settings = QSettings() self.developer_mode = settings.value( 'inasafe/developer_mode', False, type=bool) if not final_release and self.developer_mode: icon = resources_path('img', 'icons', 'add-test-layers.svg') self.action_add_layers = QAction( QIcon(icon), self.tr('Add Test Layers'), self.iface.mainWindow()) self.action_add_layers.setStatusTip(self.tr( 'Add test layers')) self.action_add_layers.setWhatsThis(self.tr( 'Add test layers')) self.action_add_layers.triggered.connect( self.add_test_layers) self.add_action(self.action_add_layers) def _create_dock(self): """Create dockwidget and tabify it with the legend.""" # Import dock here as it needs to be imported AFTER i18n is set up from safe.gui.widgets.dock import Dock self.dock_widget = Dock(self.iface) self.dock_widget.setObjectName('InaSAFE-Dock') self.iface.addDockWidget(Qt.RightDockWidgetArea, self.dock_widget) legend_tab = self.iface.mainWindow().findChild(QApplication, 'Legend') if legend_tab: self.iface.mainWindow().tabifyDockWidget( legend_tab, self.dock_widget) self.dock_widget.raise_() def initGui(self): """Gui initialisation procedure (for QGIS plugin api). .. note:: Don't change the name of this method from initGui! This method is called by QGIS and should be used to set up any graphical user interface elements that should appear in QGIS by default (i.e. before the user performs any explicit action with the plugin). """ self.toolbar = self.iface.addToolBar('InaSAFE') self.toolbar.setObjectName('InaSAFEToolBar') self.dock_widget = None # Now create the actual dock self._create_dock() # And all the menu actions # Configuration Group self._create_dock_toggle_action() self._create_options_dialog_action() self._create_minimum_needs_options_action() self._create_analysis_extent_action() self._create_rubber_bands_action() self._add_spacer_to_menu() self._create_keywords_wizard_action() self._create_analysis_wizard_action() self._add_spacer_to_menu() self._create_osm_downloader_action() self._create_add_osm_layer_action() self._create_add_petajakarta_layer_action() self._create_shakemap_converter_action() self._create_minimum_needs_action() self._create_test_layers_action() self._add_spacer_to_menu() self._create_batch_runner_action() self._create_impact_merge_action() self._create_save_scenario_action() # Hook up a slot for when the dock is hidden using its close button # or view-panels # self.dock_widget.visibilityChanged.connect(self.toggle_inasafe_action) # Also deal with the fact that on start of QGIS dock may already be # hidden. self.action_dock.setChecked(self.dock_widget.isVisible()) def _add_spacer_to_menu(self): """Create a spacer to the menu to separate action groups.""" separator = QAction(self.iface.mainWindow()) separator.setSeparator(True) self.iface.addPluginToMenu(self.tr('InaSAFE'), separator) def clear_modules(self): """Unload inasafe functions and try to return QGIS to before InaSAFE. .. todo:: I think this function can be removed. TS. """ # next lets force remove any inasafe related modules modules = [] for module in sys.modules: if 'inasafe' in module: # Check if it is really one of our modules i.e. exists in the # plugin directory tokens = module.split('.') path = '' for myToken in tokens: path += os.path.sep + myToken parent = os.path.abspath(os.path.join( __file__, os.path.pardir, os.path.pardir)) full_path = os.path.join(parent, path + '.py') if os.path.exists(os.path.abspath(full_path)): LOGGER.debug('Removing: %s' % module) modules.append(module) for module in modules: del (sys.modules[module]) for module in sys.modules: if 'inasafe' in module: print module # Lets also clean up all the path additions that were made package_path = os.path.abspath(os.path.join( os.path.dirname(__file__), os.path.pardir)) LOGGER.debug('Path to remove: %s' % package_path) # We use a list comprehension to ensure duplicate entries are removed LOGGER.debug(sys.path) sys.path = [y for y in sys.path if package_path not in y] LOGGER.debug(sys.path) def unload(self): """GUI breakdown procedure (for QGIS plugin api). .. note:: Don't change the name of this method from unload! This method is called by QGIS and should be used to *remove* any graphical user interface elements that should appear in QGIS. """ # Remove the plugin menu item and icon if self.wizard: self.wizard.deleteLater() for myAction in self.actions: self.iface.removePluginMenu(self.tr('InaSAFE'), myAction) self.iface.removeToolBarIcon(myAction) self.iface.mainWindow().removeDockWidget(self.dock_widget) self.iface.mainWindow().removeToolBar(self.toolbar) self.dock_widget.setVisible(False) self.dock_widget.destroy() self.iface.currentLayerChanged.disconnect(self.layer_changed) def toggle_inasafe_action(self, checked): """Check or un-check the toggle inaSAFE toolbar button. This slot is called when the user hides the inaSAFE panel using its close button or using view->panels. :param checked: True if the dock should be shown, otherwise False. :type checked: bool """ self.action_dock.setChecked(checked) # Run method that performs all the real work def toggle_dock_visibility(self): """Show or hide the dock widget.""" if self.dock_widget.isVisible(): self.dock_widget.setVisible(False) else: self.dock_widget.setVisible(True) self.dock_widget.raise_() def add_test_layers(self): """Add standard test layers.""" from safe.test.utilities import load_standard_layers load_standard_layers() rect = QgsRectangle(106.806, -6.195, 106.837, -6.167) self.iface.mapCanvas().setExtent(rect) def show_extent_selector(self): """Show the extent selector widget for defining analysis extents.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.extent_selector_dialog import ExtentSelectorDialog widget = ExtentSelectorDialog( self.iface, self.iface.mainWindow(), extent=self.dock_widget.extent.user_extent, crs=self.dock_widget.extent.user_extent_crs) widget.clear_extent.connect( self.dock_widget.extent.clear_user_analysis_extent) widget.extent_defined.connect( self.dock_widget.define_user_analysis_extent) # This ensures that run button state is updated on dialog close widget.extent_selector_closed.connect( self.dock_widget.show_next_analysis_extent) # Needs to be non modal to support hide -> interact with map -> show widget.show() # non modal def show_minimum_needs(self): """Show the minimum needs dialog.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.minimum_needs.needs_calculator_dialog import ( NeedsCalculatorDialog ) dialog = NeedsCalculatorDialog(self.iface.mainWindow()) dialog.exec_() def show_minimum_needs_configuration(self): """Show the minimum needs dialog.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.minimum_needs.needs_manager_dialog import ( NeedsManagerDialog) dialog = NeedsManagerDialog( parent=self.iface.mainWindow(), dock=self.dock_widget) dialog.exec_() # modal def show_impact_merge(self): """Show the impact layer merge dialog.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.impact_merge_dialog import ImpactMergeDialog dialog = ImpactMergeDialog(self.iface.mainWindow()) dialog.exec_() # modal def show_options(self): """Show the options dialog.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.options_dialog import OptionsDialog dialog = OptionsDialog( self.iface, self.dock_widget, self.iface.mainWindow()) dialog.exec_() # modal def show_keywords_wizard(self): """Show the keywords creation wizard.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.wizard.wizard_dialog import WizardDialog if self.iface.activeLayer() is None: return # Don't break an existing wizard session if accidentally clicked if self.wizard and self.wizard.isVisible(): return # Prevent spawning multiple copies since the IFCW is non modal if not self.wizard: self.wizard = WizardDialog( self.iface.mainWindow(), self.iface, self.dock_widget) self.wizard.set_keywords_creation_mode() self.wizard.exec_() # modal def show_function_centric_wizard(self): """Show the function centric wizard.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.wizard.wizard_dialog import WizardDialog # Don't break an existing wizard session if accidentally clicked if self.wizard and self.wizard.isVisible(): return # Prevent spawning multiple copies since it is non modal if not self.wizard: self.wizard = WizardDialog( self.iface.mainWindow(), self.iface, self.dock_widget) self.wizard.set_function_centric_mode() # non-modal in order to hide for selecting user extent self.wizard.show() def show_shakemap_importer(self): """Show the converter dialog.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.shake_grid.shakemap_converter_dialog import ( ShakemapConverterDialog) dialog = ShakemapConverterDialog(self.iface.mainWindow()) dialog.exec_() # modal def show_osm_downloader(self): """Show the OSM buildings downloader dialog.""" from safe.gui.tools.osm_downloader_dialog import OsmDownloaderDialog dialog = OsmDownloaderDialog(self.iface.mainWindow(), self.iface) dialog.show() # non modal def show_osm_downloader(self): """Show the OSM buildings downloader dialog.""" from safe.gui.tools.osm_downloader_dialog import OsmDownloaderDialog dialog = OsmDownloaderDialog(self.iface.mainWindow(), self.iface) dialog.show() # non modal def add_osm_layer(self): """Add OSM tile layer to the map. This uses a gdal wrapper around the OSM tile service - see the WorldOSM.gdal file for how it is constructed. """ path = resources_path('osm', 'WorldOSM.gdal') layer = QgsRasterLayer(path, self.tr('OpenStreetMap')) registry = QgsMapLayerRegistry.instance() # For older versions we just add directly to the top of legend if QGis.QGIS_VERSION_INT < 20400: # True flag adds layer directly to legend registry.addMapLayer(layer, True) return # Otherwise try to add it as the last layer in the list # False flag prevents layer being added to legend registry.addMapLayer(layer, False) root = QgsProject.instance().layerTreeRoot() index = len(root.findLayers()) + 1 # LOGGER.info('Inserting layer %s at position %s' % ( # layer.source(), index)) root.insertLayer(index, layer) QgsMapLayerRegistry.instance().addMapLayer(layer) def add_petajakarta_layer(self): """Add petajakarta layer to the map. This uses the PetaJakarta API to fetch the latest floods in JK. See https://petajakarta.org/banjir/en/data/api/#aggregates """ from safe.gui.tools.peta_jakarta_dialog import PetaJakartaDialog dialog = PetaJakartaDialog(self.iface.mainWindow(), self.iface) dialog.show() # non modal def show_batch_runner(self): """Show the batch runner dialog.""" from safe.gui.tools.batch.batch_dialog import BatchDialog dialog = BatchDialog( parent=self.iface.mainWindow(), iface=self.iface, dock=self.dock_widget) dialog.exec_() # modal def save_scenario(self): """Save current scenario to text file""" from safe.gui.tools.save_scenario import SaveScenarioDialog dialog = SaveScenarioDialog( iface=self.iface, dock=self.dock_widget) dialog.save_scenario() def _disable_keyword_tools(self): """Internal helper to disable the keyword and wizard actions.""" self.action_keywords_wizard.setEnabled(False) def layer_changed(self, layer): """Enable or disable keywords editor icon when active layer changes. :param layer: The layer that is now active. :type layer: QgsMapLayer """ if not layer: self._disable_keyword_tools() return if not hasattr(layer, 'providerType'): self._disable_keyword_tools() return if layer.providerType() == 'wms': self._disable_keyword_tools() return if is_raster_layer(layer) and layer.bandCount() > 1: self._disable_keyword_tools() return self.action_keywords_wizard.setEnabled(True) def shortcut_f7(self): """Executed when user press F7 - will show the shakemap importer.""" self.show_shakemap_importer()