def __init__(self): super(MainWindow, self).__init__() # The tabs, one per counter self.tabs = QTabWidget() #self.tabs.currentChanged.connect(self.currentTabChanged) #self.current_tab = 0 self.setupTabs() self.setCentralWidget(self.tabs) self.statusBar() exitAction = QAction(QIcon('exit.png'), '&Exit', self) exitAction.setShortcut('Ctrl+Q') exitAction.setStatusTip('Exit application') exitAction.triggered.connect(qApp.quit) registerAction = QAction('Register', self) registerAction.setShortcut('Ctrl+R') registerAction.setStatusTip('Register new counter entry') registerAction.triggered.connect(self.register) menuBar = self.menuBar() fileMenu = menuBar.addMenu("&File") fileMenu.addAction(registerAction) fileMenu.addAction(exitAction) self.setWindowTitle("Monepy - v %s" % version)
def load(self): self.initTranslations() cfg = SimuVis4.Globals.config cfgsec = self.name.lower() if not cfg.has_section(cfgsec): cfg.add_section(cfgsec) cfg.set_def(cfgsec, 'set_default_backend', 'yes') cfg.set_def(cfgsec, 'zoom_step_factor', '0.189207115002721') cfg.set_def(cfgsec, 'mouse_wheel_step', '15') glb = SimuVis4.Globals import matplotlib if matplotlib.__version__ < mplMinVersion or matplotlib.__version__ > mplMaxVersion: SimuVis4.Globals.logger.error(unicode(QCoreApplication.translate('MatPlot', 'MatPlot: need matplotlib version between %s and %s, but found %s')) % \ (mplMinVersion, mplMaxVersion, matplotlib.__version__)) return False self.matplotlib = matplotlib if cfg.getboolean(cfgsec, 'set_default_backend'): try: sys.path.append(os.path.split(__file__)[0]) matplotlib.use('module://backend_sv4agg') except: pass import backend_sv4agg self.backend_sv4agg = backend_sv4agg dpath = matplotlib.rcParams['datapath'] tmp = os.path.join(dpath, 'images') if os.path.isdir(tmp): dpath = tmp winIcon = QIcon(os.path.join(dpath, 'matplotlib.png')) testAction = QAction(winIcon, QCoreApplication.translate('MatPlot', '&MatPlot/PyLab Test'), SimuVis4.Globals.mainWin) testAction.setStatusTip(QCoreApplication.translate('MatPlot', 'Show a matplotlib/pylab test window')) QWidget.connect(testAction, SIGNAL("triggered()"), self.test) SimuVis4.Globals.mainWin.plugInMenu.addAction(testAction) return True
def layercontextmenu( layer, pos, parent=None ): '''Show a context menu to manipulate properties of layer. layer -- a volumina layer instance pos -- QPoint ''' menu = QMenu("Menu", parent) # Title title = QAction("%s" % layer.name, menu) title.setEnabled(False) menu.addAction(title) # Export global _has_lazyflow if _has_lazyflow: export = QAction("Export...",menu) export.setStatusTip("Export Layer...") export.triggered.connect( partial( get_settings_and_export_layer, layer, menu ) ) menu.addAction(export) menu.addSeparator() _add_actions( layer, menu ) # Layer-custom context menu items menu.addSeparator() for name, callback in layer.contexts: action = QAction(name, menu) action.triggered.connect(callback) menu.addAction(action) menu.exec_(pos)
def create_action(parent, text, shortcut=None, icon=None, tip=None, toggled=None, triggered=None, data=None, context=Qt.WindowShortcut): """Create a QAction""" action = QAction(text, parent) if triggered is not None: parent.connect(action, SIGNAL("triggered()"), triggered) if toggled is not None: parent.connect(action, SIGNAL("toggled(bool)"), toggled) action.setCheckable(True) if icon is not None: if isinstance(icon, (str, unicode)): icon = get_icon(icon) action.setIcon( icon ) if shortcut is not None: action.setShortcut(shortcut) if tip is not None: action.setToolTip(tip) action.setStatusTip(tip) if data is not None: action.setData(QVariant(data)) #TODO: Hard-code all shortcuts and choose context=Qt.WidgetShortcut # (this will avoid calling shortcuts from another dockwidget # since the context thing doesn't work quite well with these widgets) action.setShortcutContext(context) return action
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()
def initUI(self): closeAction = QAction('Close', self) closeAction.setShortcut('Ctrl+Q') closeAction.setStatusTip('Close Application') closeAction.triggered.connect(lambda: sys.exit(0)) loadAction = QAction('Load Protocol', self) loadAction.setStatusTip('Load the Default Protocol') loadAction.triggered.connect(self.find_pcl_file) menubar = self.menuBar() file_menu = menubar.addMenu('&File') file_menu.addAction(closeAction) load_menu = menubar.addMenu('&Load') load_menu.addAction(loadAction) self.toolbar = self.addToolBar('Exit') self.toolbar.addAction(closeAction) load_menu.addSeparator() for idx, recent_pcl in enumerate(self.recent_pcls): new_action = QAction("%d %s" % (idx + 1, recent_pcl['name']), self) new_action.triggered.connect(self.open_recent_pcl) new_action.setData(QVariant(recent_pcl['filename'])) load_menu.addAction(new_action) self.setWindowTitle('fealines') self.show_empty_screen() self.showMaximized()
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): icon = QIcon(icon_path) action = QAction(icon, text, parent) action.triggered.connect(callback) action.setEnabled(enabled_flag) if status_tip is not None: action.setStatusTip(status_tip) if whats_this is not None: action.setWhatsThis(whats_this) if add_to_toolbar: self.toolbar.addAction(action) if add_to_menu: self.iface.addPluginToMenu( self.menu, action) self.actions.append(action) return action
def addNewAction( self, iconPath, text, callback=None, enabled=True, checkable=False, addToMenu=True, addToToolbar=True, tip=None, whatsThis=None, parent=None): """Add a toolbar icon to the toolbar""" if parent is None: parent = self.iface.mainWindow() action = QAction(QIcon(iconPath), text, parent) if tip is not None: action.setStatusTip(tip) if whatsThis is not None: action.setWhatsThis(whatsThis) if callback is not None: action.triggered.connect(callback) action.setEnabled(enabled) action.setCheckable(checkable) self.addAction(action, addToMenu, addToToolbar) return action
def load(self): self.initTranslations() import vtk, VtkWidget, VtkWindow, Objects, Helpers self.vtk = vtk self.VtkWidget = VtkWidget self.VtkWindow = VtkWindow self.Objects = Objects self.Helpers = Helpers xpm = QPixmap() xpm.loadFromData(self.getFile('3dwin.xpm').read()) winIcon = QIcon(xpm) self.winManager = SubWinManager(glb.mainWin.workSpace, self.VtkWindow.VtkWindow, QCoreApplication.translate('VtkWindow', "Vtk Window"), winIcon) testAction = QAction(winIcon, QCoreApplication.translate('VtkWindow', '&VtkWindow Test'), glb.mainWin) testAction.setStatusTip(QCoreApplication.translate('VtkWindow', 'Show a new Vtk test window')) QWidget.connect(testAction, SIGNAL("triggered()"), self.test) glb.mainWin.plugInMenu.addAction(testAction) ftActions = glb.fileTypeActions ftActions.addType('application/x-3ds', '.3ds') ftActions.addAction(self.show3DS, ('application/x-3ds',), QCoreApplication.translate('VtkWindow', 'Open in VtkWindow'), 5) ftActions.addType('application/x-vrml', '.wrl') ftActions.addAction(self.showVRML, ('application/x-vrml',), QCoreApplication.translate('VtkWindow', 'Open in VtkWindow'), 5) return True
def createAction(self, text="", slot=None, shortcut=None, icon=None, tip=None, checkable=False, signal="triggered()"): """Create action out of keyword arguments. Return action. Keyword arguments: text -- User visible text (default "") slot -- function to call (default None) shortcut -- Key sequence (default None) icon -- Name of icon file (default None) tip -- Tooltip (default None) checkable -- Should action be checkable (default None) signal -- Signal to emit (default "triggered()") """ action = QAction(text, self) if icon is not None: action.setIcon(QIcon(":/resource/{0}.png".format(icon))) if shortcut is not None: action.setShortcut(shortcut) if tip is not None: action.setToolTip(tip) action.setStatusTip(tip) if slot is not None: self.connect(action, SIGNAL(signal), slot) if checkable: action.setCheckable(True) return action
def create_action(self, name, shortcut, status_tip, callback, enabled=True): action = QAction(name, self) action.setShortcut(shortcut) action.setStatusTip(status_tip) action.triggered.connect(callback) action.setEnabled(enabled) return action
def load(self): self.initTranslations() cfg = SimuVis4.Globals.config cfgsec = self.name.lower() if not cfg.has_section(cfgsec): cfg.add_section(cfgsec) cfg.set_def(cfgsec, 'show_config_warning', 'yes') glb = SimuVis4.Globals import matplotlib if matplotlib.__version__ < mplMinVersion or matplotlib.__version__ > mplMaxVersion: SimuVis4.Globals.logger.error(unicode(QCoreApplication.translate('MatPlot', 'MatPlot: need matplotlib version between %s and %s, but found %s')) % \ (mplMinVersion, mplMaxVersion, matplotlib.__version__)) return False self.matplotlib = matplotlib try: matplotlib.use('SV4Agg') except: if cfg.getboolean(cfgsec, 'show_config_warning'): QTimer().singleShot(8000, showConfigWarning) import backend_sv4agg self.backend_sv4agg = backend_sv4agg dpath = matplotlib.rcParams['datapath'] tmp = os.path.join(dpath, 'images') if os.path.isdir(tmp): dpath = tmp winIcon = QIcon(os.path.join(dpath, 'matplotlib.png')) testAction = QAction(winIcon, QCoreApplication.translate('MatPlot', '&MatPlot Test'), SimuVis4.Globals.mainWin) testAction.setStatusTip(QCoreApplication.translate('MatPlot', 'Show a matplotlib test window')) QWidget.connect(testAction, SIGNAL("triggered()"), self.test) SimuVis4.Globals.mainWin.plugInMenu.addAction(testAction) return True
def layercontextmenu( layer, pos, parent=None, volumeEditor = None ): '''Show a context menu to manipulate properties of layer. layer -- a volumina layer instance pos -- QPoint ''' def onExport(): if _has_lazyflow: inputArray = layer.datasources[0].request((slice(None),)).wait() expDlg = ExportDialog(parent = menu) g = Graph() piper = OpArrayPiper(g) piper.inputs["Input"].setValue(inputArray) expDlg.setInput(piper.outputs["Output"],g) expDlg.show() menu = QMenu("Menu", parent) title = QAction("%s" % layer.name, menu) title.setEnabled(False) export = QAction("Export...",menu) export.setStatusTip("Export Layer...") export.triggered.connect(onExport) menu.addAction(title) menu.addAction(export) menu.addSeparator() _add_actions( layer, menu ) menu.exec_(pos)
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)
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 __init__(self, Ui_MainWindow, timeout=1000): super(FellesGui, self).__init__() self.setAttribute(Qt.WA_DeleteOnClose) exitAction = QAction('Quit', self) exitAction.setShortcut('Ctrl+Q') exitAction.setStatusTip('Quit application') print("Push 'Ctrl+Q' to quit the application") exitAction.triggered.connect(self.close) # Create Widget for the purpose of updating the widgets periodically #self.timer = QTimer() #self.timer.timeout.connect(self.paintEvent) #self.timer.start(timeout) # --> Instantiate UI !!! This is where the widgets are initiated !!! self.buildUi(Ui_MainWindow) # --> Setup the Menu Bar fileMenu = self.menuBar().addMenu('&File') fileMenu.addAction(exitAction) # --> Order widgets to connect to their slaves self.initialiseSlaves.emit() # --> Initialise "Threads" performing the sampling ports = QFellesWidgetBaseClass.___ports___.keys() self.sampling_threads = [ FellesThread(port) for port in ports ] #self.statusBar().showMessage.connect(FellesThread.sample_failed) self.statusBar().showMessage('Idling...')
def initUI(self): self.textEdit = QTextEdit() self.textEdit.setReadOnly(True) self.setCentralWidget(self.textEdit) self.statusBar() icon_open = QIcon.fromTheme("document-open", QIcon(":/open.png")) icon_save = QIcon.fromTheme("document-save-as") icon_copy = QIcon.fromTheme("edit-copy") icon_clear = QIcon.fromTheme("edit-clear") openFile = QAction(QIcon(icon_open), 'Open', self) openFile.setShortcut('Ctrl+O') openFile.setStatusTip('Open new File') openFile.triggered.connect(self.showLoadDialog) self.saveFile = QAction(QIcon(icon_save), 'Save', self) self.saveFile.setShortcut('Ctrl+S') self.saveFile.setStatusTip('Save data to File') self.saveFile.triggered.connect(self.showSaveDialog) self.saveFile.setDisabled(True) self.clearData = QAction(QIcon(icon_clear), 'Clear', self) self.clearData.setShortcut('Ctrl+D') self.clearData.setStatusTip('Clear data') self.clearData.triggered.connect(self.clear_event) self.clearData.setDisabled(True) self.copyData = QAction(QIcon(icon_copy), 'Copy', self) self.copyData.setShortcut('Ctrl+C') self.copyData.setStatusTip('Copy data to clipboard') self.copyData.triggered.connect(self.copy_event) self.copyData.setDisabled(True) exitAction = QAction(QIcon(), 'Exit', self) exitAction.setShortcut('Ctrl+Q') exitAction.triggered.connect(qApp.quit) menubar = self.menuBar() fileMenu = menubar.addMenu('&File') fileMenu.addAction(openFile) fileMenu.addAction(self.saveFile) fileMenu.addAction(self.copyData) fileMenu.addAction(self.clearData) fileMenu.addSeparator() fileMenu.addAction(exitAction) fileToolBar = self.addToolBar("Load and Save") fileToolBar.setIconSize(QSize(22, 22)) fileToolBar.addAction(openFile) fileToolBar.addAction(self.saveFile) fileToolBar.addAction(self.copyData) fileToolBar.addAction(self.clearData) self.setGeometry(300, 300, 400, 600) self.setWindowTitle('File dialog') self.show()
class MetaSearchPlugin(object): """base plugin""" def __init__(self, iface): """init""" self.iface = iface self.context = StaticContext() self.action_run = None self.action_help = None self.dialog = None self.web_menu = "&MetaSearch" def initGui(self): """startup""" # run run_icon = QIcon("%s/%s" % (self.context.ppath, "images/MetaSearch.png")) self.action_run = QAction(run_icon, "MetaSearch", self.iface.mainWindow()) self.action_run.setWhatsThis(QCoreApplication.translate("MetaSearch", "MetaSearch plugin")) self.action_run.setStatusTip(QCoreApplication.translate("MetaSearch", "Search Metadata Catalogues")) self.action_run.triggered.connect(self.run) self.iface.addWebToolBarIcon(self.action_run) self.iface.addPluginToWebMenu(self.web_menu, self.action_run) # help help_icon = QIcon("%s/%s" % (self.context.ppath, "images/help.png")) self.action_help = QAction(help_icon, "Help", self.iface.mainWindow()) self.action_help.setWhatsThis(QCoreApplication.translate("MetaSearch", "MetaSearch plugin help")) self.action_help.setStatusTip(QCoreApplication.translate("MetaSearch", "Get Help on MetaSearch")) self.action_help.triggered.connect(self.help) self.iface.addPluginToWebMenu(self.web_menu, self.action_help) # prefab the dialog but not open it yet self.dialog = MetaSearchDialog(self.iface) def unload(self): """teardown""" # remove the plugin menu item and icon self.iface.removePluginWebMenu(self.web_menu, self.action_run) self.iface.removePluginWebMenu(self.web_menu, self.action_help) self.iface.removeWebToolBarIcon(self.action_run) def run(self): """open MetaSearch""" self.dialog.exec_() def help(self): """open help in user's default web browser""" open_url(self.context.metadata.get("general", "homepage"))
def load(self): self.initTranslations() import Meteo2Nc self.Meteo2Nc = Meteo2Nc self.menu = QMenu(QCoreApplication.translate('SmileKit', 'SMILE')) mn2ncAction = QAction(QIcon(), QCoreApplication.translate('SmileKit', 'Meteonorm weather import'), SimuVis4.Globals.mainWin) mn2ncAction.setStatusTip(QCoreApplication.translate('SmileKit', 'Convert Meteonorm weather files to netCDF format')) QObject.connect(mn2ncAction, SIGNAL("triggered()"), self.showMn2NcWindow) self.menu.addAction(mn2ncAction) SimuVis4.Globals.mainWin.plugInMenu.addMenu(self.menu) return True
def __init__(self, config): # Initialize the object as a QWidget and # set its title and minimum width QWidget.__init__(self) self.config = config self.peerList = config.peerList self.setWindowTitle('BlastShare') self.setMinimumSize(320, 480) self.setMaximumWidth(320) self.prefw = None # connects the signals! self.connect(self.peerList, SIGNAL("initTransfer"), self.sendFileToPeer) ''' Will add feature in future version ''' ''' shareFilesAction = QAction(QIcon('exit.png'), '&Share File(s)', self) shareFilesAction.setShortcut('Ctrl+O') shareFilesAction.setStatusTip('Share File(s)') shareFilesAction.triggered.connect(quitApp) ''' preferencesAction = QAction(QIcon('exit.png'), '&Preferences', self) preferencesAction.setShortcut('Ctrl+P') preferencesAction.setStatusTip('Preferences') preferencesAction.triggered.connect(self.editPreferences) exitAction = QAction(QIcon('exit.png'), '&Exit', self) exitAction.setShortcut('Ctrl+Q') exitAction.setStatusTip('Exit application') exitAction.triggered.connect(quitApp) menubar = QMenuBar() fileMenu = menubar.addMenu('&File') ''' Will enable in future versions ''' # fileMenu.addAction(shareFilesAction) fileMenu.addAction(preferencesAction) fileMenu.addAction(exitAction) layout = QVBoxLayout() layout.setContentsMargins(QMargins(0, 0, 0, 0)) self.setLayout(layout) statusBar = QStatusBar() statusBar.showMessage('Ready') layout.addWidget(menubar) layout.addWidget(self.peerList) layout.addWidget(statusBar)
def layercontextmenu( layer, pos, parent=None, volumeEditor = None ): '''Show a context menu to manipulate properties of layer. layer -- a volumina layer instance pos -- QPoint ''' def onExport(): sourceTags = [True for l in layer.datasources] for i, source in enumerate(layer.datasources): if not hasattr(source, "dataSlot"): sourceTags[i] = False if not any(sourceTags): raise RuntimeError("can not export from a non-lazyflow data source (layer=%r, datasource=%r)" % (type(layer), type(layer.datasources[0])) ) expDlg = ExportDialog(parent = menu, layername = layer.name) if not _has_lazyflow: raise RuntimeError("lazyflow not installed") import lazyflow dataSlots = [slot.dataSlot for (slot, isSlot) in zip(layer.datasources, sourceTags) if isSlot is True] op = lazyflow.operators.OpMultiArrayStacker(dataSlots[0].getRealOperator()) for slot in dataSlots: assert isinstance(slot, lazyflow.graph.Slot), "slot is of type %r" % (type(slot)) assert isinstance(slot.getRealOperator(), lazyflow.graph.Operator), "slot's operator is of type %r" % (type(slot.getRealOperator())) op.AxisFlag.setValue("c") op.Images.resize(len(dataSlots)) for i,islot in enumerate(op.Images): islot.connect(dataSlots[i]) expDlg.setInput(op.Output) expDlg.show() menu = QMenu("Menu", parent) title = QAction("%s" % layer.name, menu) title.setEnabled(False) export = QAction("Export...",menu) export.setStatusTip("Export Layer...") export.triggered.connect(onExport) menu.addAction(title) menu.addAction(export) menu.addSeparator() _add_actions( layer, menu ) menu.addSeparator() for name, callback in layer.contexts: action = QAction(name, menu) action.triggered.connect(callback) menu.addAction(action) menu.exec_(pos)
def add_action( self, icon_path, text, callback, enabled_flag=True, add_to_menu=True, add_to_toolbar=True, status_tip=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 :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 add_to_toolbar: self.toolbar.addAction(action) if add_to_menu: self.iface.addPluginToDatabaseMenu( self.menu, action) self.actions.append(action) return action
def addDockAction(self, iconPath, text, callback=None, enabled=True, checkable=False, tip=None, whatsThis=None): action = QAction(QIcon(iconPath), text, self._dock) if callback is not None: action.triggered.connect(callback) action.setEnabled(enabled) action.setCheckable(checkable) if tip is not None: action.setStatusTip(tip) if whatsThis is not None: action.setWhatsThis(whatsThis) self._dock.toolbar.addAction(action) # self.actions.append(action) return action
def __init__(self, parent=None): QMainWindow.__init__(self, parent) self.setIconSize(QSize(48, 48)) self.widtab = QTabWidget() # widtab.addTab(QLabel("Tab1"), "Tab 1") self._bba = {} # self._bba_plot_data = [] self._canvas_wid = [] # self.setCentralWidget(self.widtab) # # file menu # self.fileMenu = self.menuBar().addMenu("&File") fileQuitAction = QAction(QIcon(":/file_quit.png"), "&Quit", self) fileQuitAction.setShortcut("Ctrl+Q") fileQuitAction.setToolTip("Quit the application") fileQuitAction.setStatusTip("Quit the application") self.connect(fileQuitAction, SIGNAL("triggered()"), self.close) fileConfigAction = QAction("&Config", self) # fileOpenAction = QAction(QIcon(":file_quit.png"), "&Open...", self) fileOpenAction.setToolTip("Open an existing data file") self.connect(fileOpenAction, SIGNAL("triggered()"), self.fileOpen) self.fileMenu.addAction(fileOpenAction) self.fileMenu.addAction(fileQuitAction) self.fileMenu.addAction(fileConfigAction) self.controlMenu = self.menuBar().addMenu("&Control") controlGoAction = QAction(QIcon(":/control_play.png"), "&Go", self) controlGoAction.setShortcut("Ctrl+G") # fileQuitAction.setToolTip("Quit the application") # fileQuitAction.setStatusTip("Quit the application") # fileQuitAction.setIcon(Qt.QIcon(":/filequit.png")) self.controlMenu.addAction(controlGoAction) self.connect(controlGoAction, SIGNAL("triggered()"), self.align) # help self.helpMenu = self.menuBar().addMenu("&Help") # toolbar = QToolBar(self) # self.addToolBar(toolbar) fileToolBar = self.addToolBar("File") fileToolBar.setObjectName("FileToolBar") fileToolBar.addAction(fileQuitAction) fileToolBar.addAction(controlGoAction)
def createAction(self, text, slot=None, shortcut=None, icon=None, tip=None, checkable=False): action = QAction(text, self) if slot is not None: action.triggered.connect(slot) if shortcut is not None: action.setShortcut(shortcut) if icon is not None: action.setIcon(QIcon(":/{}.png".format(icon))) if tip is not None: action.setToolTip(tip) action.setStatusTip(tip) if checkable: action.setCheckable(True) return action
def createAction(parent, text, slot=None, shortcut=None, icon=None, tip=None, checkable=False, signal="triggered()"): action = QAction(text, parent) if icon is not None: action.setIcon(QIcon(":/%s.png" % icon)) if shortcut is not None: action.setShortcut(shortcut) if tip is not None: action.setToolTip(tip) action.setStatusTip(tip) if slot is not None: parent.connect(action, SIGNAL(signal), slot) if checkable: action.setCheckable(True) return action
def load(self): import GraphicsWindow, Items self.GraphicsWindow = GraphicsWindow self.Items = Items xpm = QPixmap() xpm.loadFromData(self.getFile('graphicswin.xpm').read()) winIcon = QIcon(xpm) self.winManager = SubWinManager(SimuVis4.Globals.mainWin.workSpace, self.GraphicsWindow.GraphicsWindow, QCoreApplication.translate('Graphics', "GraphicsView"), winIcon) testAction = QAction(winIcon, QCoreApplication.translate('Graphics', '&Graphics Test'), SimuVis4.Globals.mainWin) testAction.setStatusTip(QCoreApplication.translate('Graphics', 'Show a new graphics window')) QWidget.connect(testAction, SIGNAL("triggered()"), self.test) SimuVis4.Globals.mainWin.plugInMenu.addAction(testAction) return True
def set_menu_items(self, db, tag, names): """Some of the menus change their content dynamically in runtime. This method updates menu specified by 'tag' with the items given in 'names'. """ menu, fb = self.dynamic_menus[tag] group = QActionGroup(self, exclusive=True) menu.clear() for name in names: action = QAction(name, self, checkable=True) action.setStatusTip('Select item') action.triggered.connect(partial(fb, self, db, name)) a = group.addAction(action) menu.addAction(a) if db.selection[tag] == name: a.toggle()
def create_action(parent, text, slot=None, shortcut=None, icon=None, tip=None, checkable=False, signal="triggered()"): '''Helper function that creates QActions with a given QObject parent.''' action = QAction(text, parent) if icon is not None: action.setIcon(QIcon(":/%s.png" % icon)) if shortcut is not None: action.setShortcut(shortcut) if tip is not None: action.setToolTip(tip) action.setStatusTip(tip) if slot is not None: QObject.connect(action, SIGNAL(signal), slot) if checkable: action.setCheckable(True) return action
def createAction(self, text, slot=None, shortcut=None, icon=None, tip=None, checkable=False, signal="triggered()"): """Borrowed from 'Rapid GUI Development with PyQT by Mark Summerset'""" action = QAction(text, self) if icon is not None: action.setIcon(QIcon.fromTheme(icon, QIcon(":/%s.png" % icon))) if shortcut is not None and not shortcut.isEmpty(): action.setShortcut(shortcut) tip += " (%s)" % shortcut.toString() if tip is not None: action.setToolTip(tip) action.setStatusTip(tip) if slot is not None: self.connect(action, SIGNAL(signal), slot) if checkable: action.setCheckable() return action
def add_action(self, icon_path, text, callback, store_val, enabled_flag=True, add_to_menu=True, add_to_toolbar=True, status_tip=None, whats_this=None, parent=None, dialog=mainPlugDialog()): # type: (object, object, object, object, object, object, object, # object, object, object, object) -> object """Add a toolbar icon to the toolbar. :param store_val: This value is the position to store the Dialog within the dialog list, Note that this position can and will interfere with standard operation if it is stored in an incorrect position at this time :type store_val: int :param dialog: The dialog you wish to Display to users :type dialog: function :param icon_path: Path to the icon for this action. Can be a resource path (e.g. ':/plugins/foo/bar.png') or a normal file system path. :type icon_path: str :param text: Text that should be shown in menu items for this action. :type text: str :param callback: Function to be called when the action is triggered. :type callback: function :param enabled_flag: A flag indicating if the action should be enabled by default. Defaults to True. :type enabled_flag: bool :param add_to_menu: Flag indicating whether the action should also be added to the menu. Defaults to True. :type add_to_menu: bool :param add_to_toolbar: Flag indicating whether the action should also be added to the toolbar. Defaults to True. :type add_to_toolbar: bool :param status_tip: Optional text to show in a popup when mouse pointer hovers over the action. :type status_tip: str :param parent: Parent widget for the new action. Defaults None. :type parent: QWidget :param whats_this: Optional text to show in the status bar when the mouse pointer hovers over the action. :returns: The action that was created. Note that the action is also added to self.actions list. :rtype: QAction """ # Create the dialog (after translation) and keep reference # noinspection PyTypeChecker self.DialogStore[store_val] = dialog icon = QIcon(icon_path) action = QAction(icon, text, parent) action.triggered.connect(callback) action.setEnabled(enabled_flag) if status_tip is not None: action.setStatusTip(status_tip) if whats_this is not None: action.setWhatsThis(whats_this) if add_to_toolbar: self.toolbar.addAction(action) if add_to_menu: self.iface.addPluginToMenu(self.menu, action) self.actions.append(action) return action
def createAction(parent, label, callback=None, icon=None, tip=None, shortcut=None, data=None, toggled=False, tooltip=None, cb_arg=None, cb_args=None, iconText=None, checkable=None): """ Create a QAction @param parent: @type parent: @param label: @type label: @param callback: @type callback: @param icon: @type icon: @param tip: @type tip: @param shortcut: @type shortcut: @param data: @type data: @param toggled: @type toggled: @return: @rtype: """ action = QAction(label, parent) if toggled: if callback is not None: action.toggled.connect(callback) action.setCheckable(True) else: if callback is not None: if cb_arg is None: action.triggered.connect(callback) else: if cb_args is None: action.triggered.connect(lambda: callback(cb_arg)) else: action.triggered.connect(lambda: callback(**cb_args)) if icon: action.setIcon(icon) if shortcut: action.setShortcut(shortcut) if tip: action.setStatusTip(tip) if tooltip: action.setToolTip(tooltip) if data is not None: action.setData(data) if iconText is not None: action.setIconText(iconText) if checkable is not None: action.setCheckable(checkable) return action
def __init__(self,initlc=False): ####INITLC FOR TRACING ONLY DELETE IN PRODUCTION super(LDSMain, self).__init__() self.layers = None self.groups = None self.gpr = None self.gvs = None initcc = True #if init=False no point reading gpr vals wcount = 0 while initcc and wcount<self.MAX_WIZARD_ATTEMPTS: try: self.initConfigConnector(initlc=initlc) initcc = False break except MalformedConnectionString as mcse: ldslog.warn('Connection String malformed or missing. '+str(mcse)) self.runWizardDialog(None,None) wcount += 1 except DriverInitialisationException as die: ldslog.warn('Cannot Initialise selected driver. '+str(die)) self.runWizardDialog(None,None) wcount += 1 #self.initConfigConnector(self.DEF_RVALS) #initcc = False except Exception as e: ldslog.error('Unhandled Exception in Config Setup. '+str(e)) wcount += 1 else: raise e self.setGeometry(*self.WGEO) self.setWindowTitle('LDS Data Replicator') self.setWindowIcon(QIcon(LINZ)) self.statusbar = self.statusBar() self.statusbar.showMessage('Ready') self.controls = LDSControls(self) self.setCentralWidget(self.controls) openUCAction = QAction(QIcon(OPEN), 'Open &User Config', self) openUCAction.setShortcut('Ctrl+U') openUCAction.setStatusTip('Open User Preferences Editor') openUCAction.triggered.connect(self.launchUCEditor) openLCAction = QAction(QIcon(OPEN), 'Open &Layer Config', self) openLCAction.setShortcut('Ctrl+L') openLCAction.setStatusTip('Open Layer Config File (only applies to external LC storage)') openLCAction.triggered.connect(self.launchLCEditor) #self.enableLCEdit(openLCAction) initUCAction = QAction(QIcon(UC), 'Database &Setup Wizard', self) initUCAction.setShortcut('Ctrl+S') initUCAction.setStatusTip('Open Database Setup Wizard') initUCAction.triggered.connect(self.runWizardAction) initLCAction = QAction(QIcon(LC), 'Layer &Config Editor', self) initLCAction.setShortcut('Ctrl+C') initLCAction.setStatusTip('Open Layer Config Editor') initLCAction.triggered.connect(self.runLayerConfigAction) exitAction = QAction(QIcon(EXIT), '&Exit', self) exitAction.setShortcut('Ctrl+E') exitAction.setStatusTip('Exit Application') exitAction.triggered.connect(self.close)#qApp.quit) helpAction = QAction(QIcon(HELP), '&Help', self) helpAction.setShortcut('Ctrl+H') helpAction.setStatusTip('Open Help Document') helpAction.triggered.connect(self.launchHelpFile) self.menubar = self.menuBar() fileMenu = self.menubar.addMenu('&File') fileMenu.addAction(openUCAction) fileMenu.addAction(openLCAction) fileMenu.addSeparator() fileMenu.addAction(initUCAction) fileMenu.addAction(initLCAction) fileMenu.addSeparator() fileMenu.addAction(exitAction) helpMenu = self.menubar.addMenu('&Help') helpMenu.addAction(helpAction)
class StartOutofBoundsAngles: def __init__(self, iface): self.iface = iface self.tableSchema = 'edgv' self.geometryColumn = 'geom' self.keyColumn = 'id' self.angle = 10 def initGui(self): # cria uma ação que iniciará a configuração do plugin pai = self.iface.mainWindow() icon_path = ':/plugins/StartOutofBoundsAngles/icon.png' self.action = QAction( QIcon(icon_path), u"Acessa banco de dados para encontrar anglos fechados.", pai) self.action.setObjectName("Start database") self.action.setStatusTip(None) self.action.setWhatsThis(None) self.action.triggered.connect(self.run) # 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 run(self): ################################## ###### PEGA A LAYER ATIVA ######## ################################## layer = self.iface.activeLayer() if not layer: self.iface.messageBar().pushMessage("Erro", u"Esperando uma Active Layer!", level=QgsMessageBar.CRITICAL, duration=4) return if layer.featureCount() == 0: self.iface.messageBar().pushMessage( "Erro", u"a camada não possui feições!", level=QgsMessageBar.CRITICAL, duration=4) return parametros = layer.source().split( " " ) # recebe todos os parametros em uma lista ( senha, porta, password etc..) #################################### ###### INICIANDO CONEXÃO DB ######## #################################### # Outra opção para isso, seria usar ex: self.dbname.. self.host.. etc.. direto dentro do laço for. dbname = "" host = "" port = 0 user = "" password = "" for i in parametros: part = i.split("=") # Recebe os parametros guardados na própria Layer if "dbname" in part[0]: dbname = part[1].replace("'", "") elif "host" in part[0]: host = part[1].replace("'", "") elif "port" in part[0]: port = int(part[1].replace("'", "")) elif "user" in part[0]: user = part[1].replace("'", "") elif "password" in part[0]: password = part[1].split("|")[0].replace("'", "") print dbname, host, port, user, password # Testa se os parametros receberam os valores pretendidos, caso não, apresenta a mensagem informando.. if len(dbname) == 0 or len(host) == 0 or port == 0 or len( user) == 0 or len(password) == 0: self.iface.messageBar().pushMessage( "Erro", u'Um dos parametros não foram devidamente recebidos!', level=QgsMessageBar.CRITICAL, duration=4) return #################################### #### SETA VALORES DE CONEXÃO DB #### #################################### connection = QSqlDatabase.addDatabase('QPSQL') connection.setHostName(host) connection.setPort(port) connection.setUserName(user) connection.setPassword(password) connection.setDatabaseName(dbname) if not connection.isOpen( ): # Testa se a conexão esta recebendo os parametros adequadamente. if not connection.open(): print 'Error connecting to database!' self.iface.messageBar().pushMessage( "Erro", u'Error connecting to database!', level=QgsMessageBar.CRITICAL, duration=4) print connection.lastError().text() return #################################### ###### CRIAÇÃO DE MEMORY LAYER ##### #################################### layerCrs = layer.crs().authid() # Passa o formato (epsg: numeros) flagsLayerName = layer.name() + "_flags" flagsLayerExists = False for l in QgsMapLayerRegistry.instance().mapLayers().values( ): # Recebe todas as camadas que estão abertas if l.name() == flagsLayerName: # ao encontrar o nome pretendido.. self.flagsLayer = l # flagslayer vai receber o nome.. self.flagsLayerProvider = l.dataProvider() flagsLayerExists = True # se encontrado os parametros buscados, recebe True. break if flagsLayerExists == False: # se não encontrado os parametros buscados, recebe False. tempString = "Point?crs=" tempString += str(layerCrs) self.flagsLayer = QgsVectorLayer(tempString, flagsLayerName, "memory") self.flagsLayerProvider = self.flagsLayer.dataProvider() self.flagsLayerProvider.addAttributes([ QgsField("flagId", QVariant.Int), QgsField("geomId", QVariant.String), QgsField("motivo", QVariant.String) ]) self.flagsLayer.updateFields() self.flagsLayer.startEditing() ids = [feat.id() for feat in self.flagsLayer.getFeatures()] self.flagsLayer.deleteFeatures(ids) self.flagsLayer.commitChanges() lista_fid = [] # Iniciando lista for f in layer.getFeatures(): lista_fid.append( str(f.id()) ) # Guarda na lista. A lista de Feature ids passa tipo "int", foi convertido e guardado como "str". source = layer.source().split(" ") self.tableName = "" # Inicia vazio layerExistsInDB = False for i in source: if "table=" in i or "layername=" in i: # Se encontrar os atributos pretendidos dentre todos do for self.tableName = source[source.index(i)].split(".")[ 1] # Faz split em ponto e pega a segunda parte. self.tableName = self.tableName.replace('"', '') layerExistsInDB = True break if layerExistsInDB == False: self.iface.messageBar().pushMessage( "Erro", u"Provedor da camada corrente não provem do banco de dados!", level=QgsMessageBar.CRITICAL, duration=4) return geomType = layer.geometryType() if geomType == QGis.Line: # Busca através do SQL sql = """ WITH result AS (SELECT points."{4}", points.anchor, (degrees ( ST_Azimuth(points.anchor, points.pt1) - ST_Azimuth(points.anchor, points.pt2) )::decimal + 360) % 360 as angle FROM (SELECT ST_PointN("{3}", generate_series(1, ST_NPoints("{3}")-2)) as pt1, ST_PointN("{3}", generate_series(2, ST_NPoints("{3}")-1)) as anchor, ST_PointN("{3}", generate_series(3, ST_NPoints("{3}"))) as pt2, linestrings."{4}" as "{4}" FROM (SELECT "{4}" as "{4}", (ST_Dump("{3}")).geom as "{3}" FROM only "{0}"."{1}" ) AS linestrings WHERE ST_NPoints(linestrings."{3}") > 2 ) as points) select distinct "{4}", ST_AsText(anchor), angle from result where (result.angle % 360) < {2} or result.angle > (360.0 - ({2} % 360.0)) and result.{4} in ({5})""".format( self.tableSchema, self.tableName, self.angle, self.geometryColumn, self.keyColumn, ",".join(lista_fid)) elif geomType == QGis.Polygon: sql = """ WITH result AS (SELECT points."{4}", points.anchor, (degrees ( ST_Azimuth(points.anchor, points.pt1) - ST_Azimuth(points.anchor, points.pt2) )::decimal + 360) % 360 as angle FROM (SELECT ST_PointN("{3}", generate_series(1, ST_NPoints("{3}")-1)) as pt1, ST_PointN("{3}", generate_series(1, ST_NPoints("{3}")-1) % (ST_NPoints("{3}")-1)+1) as anchor, ST_PointN("{3}", generate_series(2, ST_NPoints("{3}")) % (ST_NPoints("{3}")-1)+1) as pt2, linestrings."{4}" as "{4}" FROM (SELECT "{4}" as "{4}", (ST_Dump(ST_Boundary(ST_ForceRHR((ST_Dump("{3}")).geom)))).geom as "{3}" FROM only "{0}"."{1}" ) AS linestrings WHERE ST_NPoints(linestrings."{3}") > 2 ) as points) select distinct "{4}", ST_AsText(anchor), angle from result where (result.angle % 360) < {2} or result.angle > (360.0 - ({2} % 360.0)) and result.{4} in ({5})""".format( self.tableSchema, self.tableName, self.angle, self.geometryColumn, self.keyColumn, ",".join(lista_fid)) query = QSqlQuery(sql) self.flagsLayer.startEditing() flagCount = 0 # iniciando contador que será referência para os IDs da camada de memória. listaFeatures = [] while query.next(): id = query.value(0) local = query.value(1) angulo = query.value(2) flagId = flagCount print id, local, angulo flagFeat = QgsFeature() flagGeom = QgsGeometry.fromWkt( local) # passa o local onde foi localizado o erro. flagFeat.setGeometry(flagGeom) flagFeat.initAttributes(3) flagFeat.setAttribute( 0, flagId ) # insere o id definido para a coluna 0 da layer de memória. flagFeat.setAttribute( 1, id ) # insere o id da geometria para a coluna 1 da layer de memória. flagFeat.setAttribute( 2, u"Ângulo para os vértices adjacentes inferior à tolerância") # TypeError: fromWkt(QString): argument 1 has unexpected type 'long' # Traceback (most recent call last): # File "/home/piangers/.qgis2/python/plugins/StartDuplic/StartDuplic.py", line 177, in run # flagGeom = QgsGeometry.fromWkt(local) # passa o local onde foi localizado o erro. listaFeatures.append(flagFeat) flagCount += 1 # incrementando o contador a cada iteração self.flagsLayerProvider.addFeatures(listaFeatures) self.flagsLayer.commitChanges() # Aplica as alterações à camada. QgsMapLayerRegistry.instance().addMapLayer( self.flagsLayer) # Adicione a camada no mapa if flagCount == 0: QgsMapLayerRegistry.instance().removeMapLayer(self.flagsLayer.id()) self.iface.messageBar().pushMessage( "Aviso", u"Não foi encontrado Flags em \"" + layer.name() + "\" !", level=QgsMessageBar.CRITICAL, duration=4) return if len(query.lastError().text()) == 1: self.iface.messageBar().pushMessage( "Aviso", "foram geradas " + str(flagCount) + " flags para a camada \"" + layer.name() + "\" !", level=QgsMessageBar.INFO, duration=4) else: self.iface.messageBar().pushMessage("Erro", u"a geração de flags falhou!", level=QgsMessageBar.CRITICAL, duration=4) print query.lastError().text()
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): """Agrega una acción la la barra de herramientas, y al menú del plugin. :param icon_path: Ruta del icono. Puede ser la ruta de un recurso recurso (ejemplo: ':/plugins/foo/bar.png') o una ruta normal del sistema de archivos :type icon_path: str :param text: Texto que será mostrado en el menu de opciones de plugin para esta accion. :type text: str :param callback: Función que será llamada cuando se hace click sobre la acción. :type callback: function :param enabled_flag: Una bandera que indica si la acción debería ser activada por defecto. Por defecto este valor esta en True. :type enabled_flag: bool :param add_to_menu: Una bandera indicando si la acción debería ser agregada al menú de opciones del plugin. Por defecto esta en True :type add_to_menu: bool :param add_to_toolbar: Una bandera indicando si la acción debería ser agregada a la barra de herramientas del plugin. Por defecto esta en True :type add_to_toolbar: bool :param status_tip: Texto opcional que aparecerá cuando el puntero del mouse se pocisione sobre la acción. :type status_tip: str :param parent: Widget padre de la nueva acción. Por defecto será None :type parent: QWidget :param whats_this: Texto opcional para mostrar en la barra de estatus, cuando el puntero del mouse se pocisione sobre la acción. :returns: La acción que fue creada. Notar que la acción también es agregada a self.actions list. :rtype: QAction """ icon = QIcon(icon_path) action = QAction(icon, text, parent) action.triggered.connect(callback) action.setEnabled(enabled_flag) if status_tip is not None: action.setStatusTip(status_tip) if whats_this is not None: action.setWhatsThis(whats_this) if add_to_toolbar: self.toolbar.addAction(action) if add_to_menu: self.iface.addPluginToMenu( self.menu, action) self.actions.append(action) return action
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 LogView(QDialog, FORM_CLASS): """ Class documentation goes here. """ rollbackLayer = pyqtSignal(QTreeWidgetItem) diffLayer = pyqtSignal() checkoutLayer = pyqtSignal(str) checkoutTag = pyqtSignal(str, str) createBranch = pyqtSignal(str) def __init__(self, parent): """ Constructor """ QDialog.__init__(self, None) self.setupUi(self) self.iface = parent.iface self.tools = PgVersionTools(parent) self.tagAction = QAction(QIcon(""), self.tr("Set Tag for current revision"), self) self.tagAction.setStatusTip(self.tr("Set Tag for current revision")) self.tagAction.triggered.connect(self.setTag) self.treeWidget.addAction(self.tagAction) self.branchAction = QAction(QIcon(""), self.tr("Branch the current revision"), self) self.branchAction.setStatusTip( self.tr("Create branch for current revision")) self.branchAction.triggered.connect(self.create_branch) self.treeWidget.addAction(self.branchAction) self.treeWidget.setContextMenuPolicy(Qt.ActionsContextMenu) def set_version_table_id(self, id): self.version_table_id = id def setLayer(self, theLayer): self.theLayer = theLayer self.setWindowTitle( self.tr('Logview for layer %s' % (self.theLayer.name()))) def createTagList(self): self.cmbTags.clear() # Add tags into tag cmb myDb = self.tools.layerDB('tags', self.theLayer) sql = "select vtag.tags_id, vtag.version_table_id, vtag.tag_text, vtag.revision \ from versions.version_tags as vtag,\ versions.version_tables as vtab \ where vtab.version_view_schema = '%s' \ and vtab.version_view_name = '%s' \ and vtab.version_table_id = vtag.version_table_id \ order by vtag.tags_id desc " % (self.tools.layerSchema( self.theLayer), self.tools.layerTable(self.theLayer)) result = myDb.read(sql) self.version_table_id = result['VERSION_TABLE_ID'][0] self.cmbTags.addItem(' ------ ', -1) for i in range(len(result['TAG_TEXT'])): self.cmbTags.addItem(result['TAG_TEXT'][i], result['REVISION'][i]) def setTag(self): result, ok = QInputDialog.getText(self, self.tr("Set Tag for Revision "), self.tr(""), QLineEdit.Normal) if ok: if self.hasTag(): QMessageBox.information( None, self.tr('Warning'), self.tr('This version is already tagged')) else: myDb = self.tools.layerDB('tags', self.theLayer) sql = "insert into versions.version_tags (version_table_id, revision, tag_text) \ values \ (%s, %s, '%s')" % (self.version_table_id, self.treeWidget.currentItem().text(0), result) myDb.run(sql) self.createTagList() def create_branch(self): result, ok = QInputDialog.getText( self, self.tr("Create branch for Revision "), self.tr(""), QLineEdit.Normal) if ok: if self.branchExists(): QMessageBox.information(None, self.tr('Warning'), self.tr('Branch already exists')) else: myDb = self.tools.layerDB('tags', self.theLayer) sql = "select versions.pgvsmakebranch(%s, '%s')" % ( self.version_table_id, result) myDb.run(sql) def branchExists(self): return False def hasTag(self): try: sql = "select count(revision) \ from versions.version_tags \ where version_table_id = %s \ and revision = %s " % (self.version_table_id, self.treeWidget.currentItem().text(0)) myDb = self.tools.layerDB('tags', self.theLayer) result = myDb.read(sql) if result['COUNT'][0] <> '0': return True else: return False except: pass @pyqtSlot() def on_btnRollback_clicked(self): try: self.rollbackLayer.emit(self.treeWidget.currentItem()) self.close() except: QMessageBox.information( None, self.tr('Warning'), self.tr('Please select a revision for checkout')) @pyqtSlot() def on_btnDiff_clicked(self): self.diffLayer.emit() self.close() @pyqtSlot() def on_btnCheckout_clicked(self): self.checkoutLayer.emit(self.treeWidget.currentItem().text(0)) self.close() @pyqtSlot() def on_buttonBox_rejected(self): """ Slot documentation goes here. """ self.close() @pyqtSlot() def on_btnTag_clicked(self): if self.cmbTags.currentIndex() > 0: self.checkoutTag.emit( self.cmbTags.itemData(self.cmbTags.currentIndex()), self.cmbTags.itemText(self.cmbTags.currentIndex()))
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) # The list of actions added to menus, so we can remove them when unloading the plugin self._menuActions = [] 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._menuActions.append(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._menuActions.append(self.menu.addMenu(self.projectionsMenu)) self._menuActions.append(self.menu.addMenu(self.conversionMenu)) self._menuActions.append(self.menu.addMenu(self.extractionMenu)) if not self.analysisMenu.isEmpty(): self._menuActions.append(self.menu.addMenu(self.analysisMenu)) self._menuActions.append(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) self._menuActions.append(self.settings) def unload(self): if not valid: return for a in self._menuActions: self.menu.removeAction(a) 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 SimpleRichText(QTextEdit): def __init__(self, focusin, focusout): QTextEdit.__init__(self) self.focusin = focusin self.focusout = focusout self.createActions() #self.setContextMenuPolicy(QtCore.Qt.ActionsContextMenu) def focusOutEvent(self, event): #print "focus out" self.focusout() def focusInEvent(self, event): self.focusin() def closeEvent(self, event): event.accept() def createActions(self): self.boldAct = QAction(self.tr("&Bold"), self) self.boldAct.setCheckable(True) self.boldAct.setShortcut(self.tr("Ctrl+B")) self.boldAct.setStatusTip(self.tr("Make the text bold")) self.connect(self.boldAct, SIGNAL("triggered()"), self.setBold) self.addAction(self.boldAct) boldFont = self.boldAct.font() boldFont.setBold(True) self.boldAct.setFont(boldFont) self.italicAct = QAction(self.tr("&Italic"), self) self.italicAct.setCheckable(True) self.italicAct.setShortcut(self.tr("Ctrl+I")) self.italicAct.setStatusTip(self.tr("Make the text italic")) self.connect(self.italicAct, SIGNAL("triggered()"), self.setItalic) self.addAction(self.italicAct) def setBold(self): format = QTextCharFormat() if self.boldAct.isChecked(): weight = QFont.Bold else: weight = QFont.Normal format.setFontWeight(weight) self.setFormat(format) def setItalic(self): format = QTextCharFormat() #format.setFontItalic(self.__italic.isChecked()) format.setFontItalic(self.italicAct.isChecked()) self.setFormat(format) def setUnderline(self): format = QTextCharFormat() format.setFontUnderline(self.__underline.isChecked()) self.setFormat(format) def setFormat(self, format): self.textCursor().mergeCharFormat(format) self.mergeCurrentCharFormat(format) def bold(self): print("bold") def italic(self): print("italic")
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 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_minimum_needs_config = None self.action_multi_buffer = 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_to_legend=False): """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) if add_to_legend: # The id is the action name without spaces, tabs ... self.iface.legendInterface().addLegendLayerAction( action, self.tr('InaSAFE'), ''.join(action.text().split()), QgsMapLayer.VectorLayer, True) self.iface.legendInterface().addLegendLayerAction( action, self.tr('InaSAFE'), ''.join(action.text().split()), QgsMapLayer.RasterLayer, True) 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, add_to_legend=True) 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_multi_buffer_action(self): """Create action for multi buffer dialog.""" icon = resources_path('img', 'icons', 'show-multi-buffer.svg') self.action_multi_buffer = QAction(QIcon(icon), self.tr('Multi Buffer'), self.iface.mainWindow()) self.action_multi_buffer.setStatusTip( self.tr('Open InaSAFE multi buffer')) self.action_multi_buffer.setWhatsThis( self.tr('Open InaSAFE multi buffer')) self.action_multi_buffer.triggered.connect(self.show_multi_buffer) self.add_action(self.action_multi_buffer, 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_show_definitions_action(self): """Create action for showing definitions.""" icon = resources_path('img', 'icons', 'defintions.svg') self.action_show_definitions = QAction(QIcon(icon), self.tr('InaSAFE Help'), self.iface.mainWindow()) self.action_show_definitions.setStatusTip(self.tr('Show InaSAFE Help')) self.action_show_definitions.setWhatsThis( self. tr('Use this to show a document describing all InaSAFE concepts.')) self.action_show_definitions.triggered.connect(self.show_definitions) self.add_action(self.action_show_definitions, add_to_toolbar=True) def _create_add_petabencana_layer_action(self): """Create action for import OSM Dialog.""" icon = resources_path('img', 'icons', 'add-petabencana-layer.svg') self.action_add_petabencana_layer = QAction( QIcon(icon), self.tr('Add PetaBencana Flood Layer'), self.iface.mainWindow()) self.action_add_petabencana_layer.setStatusTip( self.tr('Add PetaBencana Flood Layer')) self.action_add_petabencana_layer.setWhatsThis( self.tr('Use this to add a PetaBencana layer to your map. ' 'It needs internet access to function.')) self.action_add_petabencana_layer.triggered.connect( self.add_petabencana_layer) self.add_action(self.action_add_petabencana_layer, add_to_toolbar=False) 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_run_test_action(self): """Create action for running tests (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: default_package = unicode( settings.value('inasafe/testPackage', 'safe', type=str)) msg = self.tr('Run tests in %s' % default_package) self.test_button = QToolButton() self.test_button.setMenu(QMenu()) self.test_button.setPopupMode(QToolButton.MenuButtonPopup) icon = resources_path('img', 'icons', 'run-tests.svg') self.action_run_tests = QAction(QIcon(icon), msg, self.iface.mainWindow()) self.action_run_tests.setStatusTip(msg) self.action_run_tests.setWhatsThis(msg) self.action_run_tests.triggered.connect(self.run_tests) self.test_button.menu().addAction(self.action_run_tests) self.test_button.setDefaultAction(self.action_run_tests) self.action_select_package = QAction(QIcon(icon), self.tr('Select package'), self.iface.mainWindow()) self.action_select_package.setStatusTip( self.tr('Select Test Package')) self.action_select_package.setWhatsThis( self.tr('Select Test Package')) self.action_select_package.triggered.connect( self.select_test_package) self.test_button.menu().addAction(self.action_select_package) self.toolbar.addWidget(self.test_button) self.add_action(self.action_run_tests, add_to_toolbar=False) self.add_action(self.action_select_package, add_to_toolbar=False) 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_petabencana_layer_action() self._create_shakemap_converter_action() self._create_minimum_needs_action() self._create_multi_buffer_action() self._create_test_layers_action() self._create_run_test_action() self._add_spacer_to_menu() self._create_batch_runner_action() self._create_save_scenario_action() self._add_spacer_to_menu() self._create_show_definitions_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) @staticmethod def clear_modules(): """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.legendInterface().removeLegendLayerAction(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 select_test_package(self): """Select the test package.""" settings = QSettings() default_package = 'safe' user_package = unicode( settings.value('inasafe/testPackage', default_package, type=str)) test_package, _ = QInputDialog.getText( self.iface.mainWindow(), self.tr('Select the python test package'), self.tr('Select the python test package'), QLineEdit.Normal, user_package) if test_package == '': test_package = default_package settings.setValue('inasafe/testPackage', test_package) msg = self.tr('Run tests in %s' % test_package) self.action_run_tests.setWhatsThis(msg) self.action_run_tests.setText(msg) def run_tests(self): """Run unit tests in the python console.""" from PyQt4.QtGui import QDockWidget main_window = self.iface.mainWindow() action = main_window.findChild(QAction, 'mActionShowPythonDialog') action.trigger() settings = QSettings() package = unicode( settings.value('inasafe/testPackage', 'safe', type=str)) for child in main_window.findChildren(QDockWidget, 'PythonConsole'): if child.objectName() == 'PythonConsole': child.show() for widget in child.children(): if 'PythonConsoleWidget' in str(widget.__class__): # print "Console widget found" shell = widget.shell shell.runCommand( 'from inasafe.test_suite import test_package') shell.runCommand('test_package(\'%s\')' % package) break 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.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.validate_impact_function) # 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_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(), self.iface, self.dock_widget) dialog.exec_() # modal def show_multi_buffer(self): from safe.gui.tools.multi_buffer_dialog import (MultiBufferDialog) dialog = MultiBufferDialog(self.iface.mainWindow(), self.iface, self.dock_widget) 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 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 show_definitions(self): """Show InaSAFE Definitions (a report showing all key metadata). """ from safe.gui.tools.help_dialog import HelpDialog from safe.gui.tools.help import definitions_help dialog = HelpDialog(self.iface.mainWindow(), definitions_help.definitions_help()) dialog.show() # non modal def add_petabencana_layer(self): """Add petabencana layer to the map. This uses the PetaBencana API to fetch the latest floods in JK. See https://data.petabencana.id/floods """ from safe.gui.tools.peta_bencana_dialog import PetaBencanaDialog dialog = PetaBencanaDialog(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()
def add_action( self, icon_path, text, callback, enabled_flag=True, add_to_menu=True, add_to_toolbar=True, status_tip=None, whats_this=None, parent=None): """Add a toolbar icon to the toolbar. :param icon_path: Path to the icon for this action. Can be a resource path (e.g. ':/plugins/foo/bar.png') or a normal file system path. :type icon_path: str :param text: Text that should be shown in menu items for this action. :type text: str :param callback: Function to be called when the action is triggered. :type callback: function :param enabled_flag: A flag indicating if the action should be enabled by default. Defaults to True. :type enabled_flag: bool :param add_to_menu: Flag indicating whether the action should also be added to the menu. Defaults to True. :type add_to_menu: bool :param add_to_toolbar: Flag indicating whether the action should also be added to the toolbar. Defaults to True. :type add_to_toolbar: bool :param status_tip: Optional text to show in a popup when mouse pointer hovers over the action. :type status_tip: str :param parent: Parent widget for the new action. Defaults None. :type parent: QWidget :param whats_this: Optional text to show in the status bar when the mouse pointer hovers over the action. :returns: The action that was created. Note that the action is also added to self.actions list. :rtype: QAction """ # Create the dialog (after translation) and keep reference self.dlg = RNCLoaderDialog() self.dlg.pushButton.clicked.connect(self.selectRootDirectory) self.chartModel = QStandardItemModel(self.dlg.chartListView) self.filterModel = QSortFilterProxyModel() self.filterModel.setDynamicSortFilter(True) self.filterModel.setFilterCaseSensitivity(False) self.filterModel.setSourceModel(self.chartModel) self.dlg.chartListView.setModel(self.filterModel) self.dlg.filterLineEdit.textChanged.connect( self.filterModel.setFilterWildcard) icon = QIcon(icon_path) action = QAction(icon, text, parent) action.triggered.connect(callback) action.setEnabled(enabled_flag) if status_tip is not None: action.setStatusTip(status_tip) if whats_this is not None: action.setWhatsThis(whats_this) if add_to_toolbar: self.toolbar.addAction(action) if add_to_menu: self.iface.addPluginToRasterMenu( self.menu, action) self.actions.append(action) return action
def __init__(self, font, parent=None): super(MainWindow, self).__init__(parent) self.font = font self.setWindowTitle("Meridien") central_widget = QWidget(self) self.setCentralWidget(central_widget) #Center on screen resolution = QDesktopWidget().screenGeometry() self.move((resolution.width() / 2) - (self.frameSize().width() / 2), (resolution.height() / 2) - (self.frameSize().height() / 2)) """ Setting up menu bar """ close_action = QAction('Close', self) close_action.setShortcut("Ctrl+Q") close_action.setStatusTip('Leave the app') close_action.triggered.connect(lambda: self.close()) open_refinement_folder = QAction('Open Refinement Folder', self) open_refinement_folder.triggered.connect(self.open_refinement_folder) self.mainMenu = self.menuBar() self.fileMenu = self.mainMenu.addMenu('&File') self.fileMenu.addAction(open_refinement_folder) self.fileMenu.addAction(close_action) self.refinement_folder = "" create_new_fsc_plot = QAction('&New FSC plot', self) create_new_fsc_plot.triggered.connect( self.event_ontriggered_show_fsc_plot) create_new_overview_plot = QAction('&New resolution overview plot', self) create_new_overview_plot.triggered.connect( self.event_show_resolution_overview_plot) self.plotMenu = self.mainMenu.addMenu('&Plot') self.plotMenu.addAction(create_new_fsc_plot) self.plotMenu.addAction(create_new_overview_plot) """ Setup other components """ self.layout = QGridLayout(central_widget) self.setMenuBar(self.mainMenu) self.tree = QTreeWidget(self) self.tree.setHeaderHidden(True) self.layout.addWidget(self.tree, 1, 0) self.root_items_path_dictionary = {} # Threads self.threadpool = QThreadPool() self.thread_list = [] thr = QThread(self) thr.start() self.reader = DriverFileReader() self.reader.moveToThread(thr) self.thread_list.append(thr) self.timer = QTimer(self) # Connect signals self.reader.sig_sendfolders.connect(self.fill_tree) self.reader.sig_sendfsc.connect(self.show_dialog_fsc) self.tree.itemChanged.connect(self._event_select_deselect_all) self.sig_update_tree.connect(self.update_tree) self.sig_show_overview_plot.connect( self.event_show_resolution_overview_plot) self.show() self.open_refinement_folder() self.monitor = None
class MetaSearchPlugin(object): """base plugin""" def __init__(self, iface): """init""" self.iface = iface self.context = StaticContext() self.action_run = None self.action_help = None self.dialog = None self.web_menu = '&MetaSearch' LOGGER.debug('Setting up i18n') # TODO: does this work for locales like: pt_BR ? locale_name = QSettings().value("locale/userLocale")[0:2] # this one below does not pick up when you load QGIS with --lang param # locale_name = str(QLocale.system().name()).split('_')[0] LOGGER.debug('Locale name: %s', locale_name) # load if exists tr_file = os.path.join(self.context.ppath, 'locale', locale_name, 'LC_MESSAGES', 'ui.qm') if os.path.exists(tr_file): self.translator = QTranslator() result = self.translator.load(tr_file) if not result: msg = 'Failed to load translation: %s' % tr_file LOGGER.error(msg) raise RuntimeError(msg) QCoreApplication.installTranslator(self.translator) LOGGER.debug( QCoreApplication.translate('MetaSearch', 'Translation loaded: %s' % tr_file)) def initGui(self): """startup""" # run run_icon = QIcon('%s/%s' % (self.context.ppath, 'images/MetaSearch.png')) self.action_run = QAction(run_icon, 'MetaSearch', self.iface.mainWindow()) self.action_run.setWhatsThis( QCoreApplication.translate('MetaSearch', 'MetaSearch plugin')) self.action_run.setStatusTip( QCoreApplication.translate('MetaSearch', 'Search Metadata Catalogues')) self.action_run.triggered.connect(self.run) self.iface.addToolBarIcon(self.action_run) self.iface.addPluginToWebMenu(self.web_menu, self.action_run) # help help_icon = QIcon('%s/%s' % (self.context.ppath, 'images/help.png')) self.action_help = QAction(help_icon, 'Help', self.iface.mainWindow()) self.action_help.setWhatsThis( QCoreApplication.translate('MetaSearch', 'MetaSearch plugin help')) self.action_help.setStatusTip( QCoreApplication.translate('MetaSearch', 'Get Help on MetaSearch')) self.action_help.triggered.connect(self.help) self.iface.addPluginToWebMenu(self.web_menu, self.action_help) # prefab the dialog but not open it yet self.dialog = MetaSearchDialog(self.iface) def unload(self): """teardown""" # remove the plugin menu item and icon self.iface.removePluginWebMenu(self.web_menu, self.action_run) self.iface.removePluginWebMenu(self.web_menu, self.action_help) self.iface.removeToolBarIcon(self.action_run) self.iface.removeToolBarIcon(self.action_help) def run(self): """open MetaSearch""" self.dialog.exec_() def help(self): """open help in user's default web browser""" open_url(self.context.metadata.get('general', 'homepage'))
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.iface.addPluginToMenu(self.menu, action) self.actions.append(action) return action
class StartData: def __init__(self, iface): self.iface = iface self.tableSchema = 'edgv' self.geometryColumn = 'geom' self.keyColumn = 'id' def initGui(self): # cria uma ação que iniciará a configuração do plugin pai = self.iface.mainWindow() icon_path = ':/plugins/StartData/icon.png' self.action = QAction (QIcon (icon_path),u"Acessa banco de dados para revisão", pai) self.action.setObjectName ("Stard database") self.action.setStatusTip(None) self.action.setWhatsThis(None) self.action.triggered.connect(self.run) # 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 run(self): ################################## ###### PEGA A LAYER ATIVA ######## ################################## layer = self.iface.activeLayer() if not layer: self.iface.messageBar().pushMessage("Erro", u"Esperando uma Active Layer!", level=QgsMessageBar.CRITICAL, duration=4) return if layer.featureCount() == 0: self.iface.messageBar().pushMessage("Erro", u"a camada não possui feições!", level=QgsMessageBar.CRITICAL, duration=4) return parametros = layer.source().split(" ") # recebe todos os parametros em uma lista ( senha, porta, password etc..) #################################### ###### INICIANDO CONEXÃO DB ######## #################################### # Outra opção para isso, seria usar ex: self.dbname.. self.host.. etc.. direto dentro do laço for. dbname = "" host = "" port = 0 user = "" password = "" for i in parametros: part = i.split("=") # Recebe os parametros guardados na própria Layer if "dbname" in part[0]: dbname = part[1].replace("'", "") elif "host" in part[0]: host = part[1].replace("'", "") elif "port" in part[0]: port = int(part[1].replace("'", "")) elif "user" in part[0]: user = part[1].replace("'", "") elif "password" in part[0]: password = part[1].split("|")[0].replace("'", "") #print dbname, host, port, user, password # Testa se os parametros receberam os valores pretendidos, caso não, apresenta a mensagem informando.. if len(dbname) == 0 or len(host) == 0 or port == 0 or len(user) == 0 or len(password) == 0: self.iface.messageBar().pushMessage("Erro", u'Um dos parametros não foram devidamente recebidos!', level=QgsMessageBar.CRITICAL, duration=4) return #################################### #### SETA VALORES DE CONEXÃO DB #### #################################### connection = QSqlDatabase.addDatabase('QPSQL') connection.setHostName(host) connection.setPort(port) connection.setUserName(user) connection.setPassword(password) connection.setDatabaseName(dbname) if not connection.isOpen(): # Testa se a conexão esta recebendo os parametros adequadamente. if not connection.open(): print 'Error connecting to database!' self.iface.messageBar().pushMessage("Erro", u'Error connecting to database!', level=QgsMessageBar.CRITICAL, duration=4) print connection.lastError().text() return #################################### ###### CRIAÇÃO DE MEMORY LAYER ##### #################################### layerCrs = layer.crs().authid() # Passa o formato (epsg: numeros) flagsLayerName = layer.name() + "_flags" flagsLayerExists = False for l in QgsMapLayerRegistry.instance().mapLayers().values(): # Recebe todas as camadas que estão abertas if l.name() == flagsLayerName: # ao encontrar o nome pretendido.. self.flagsLayer = l # flagslayer vai receber o nome.. self.flagsLayerProvider = l.dataProvider() flagsLayerExists = True # se encontrado os parametros buscados, recebe True. break if flagsLayerExists == False: # se não encontrado os parametros buscados, recebe False. tempString = "Point?crs=" tempString += str(layerCrs) self.flagsLayer = QgsVectorLayer(tempString, flagsLayerName, "memory") self.flagsLayerProvider = self.flagsLayer.dataProvider() self.flagsLayerProvider.addAttributes([QgsField("id", QVariant.Int), QgsField("motivo", QVariant.String)]) self.flagsLayer.updateFields() self.flagsLayer.startEditing() ids = [feat.id() for feat in self.flagsLayer.getFeatures()] self.flagsLayer.deleteFeatures(ids) self.flagsLayer.commitChanges() lista_fid = [] # Iniciando lista for f in layer.getFeatures(): lista_fid.append(str(f.id())) # Guarda na lista. A lista de Feature ids passa tipo "int", foi convertido e guardado como "str". source = layer.source().split(" ") self.tableName = "" # Inicia vazio layerExistsInDB = False for i in source: if "table=" in i or "layername=" in i: # Se encontrar os atributos pretendidos dentre todos do for self.tableName = source[source.index(i)].split(".")[1] # Faz split em ponto e pega a segunda parte. self.tableName = self.tableName.replace('"', '') layerExistsInDB = True break if layerExistsInDB == False: self.iface.messageBar().pushMessage("Erro", u"Provedor da camada corrente não provem do banco de dados!", level=QgsMessageBar.CRITICAL, duration=4) return # Busca através do SQL query_string = '''select distinct (reason(ST_IsValidDetail(f."{2}",0))) AS motivo, ''' query_string += '''ST_AsText(ST_Multi(ST_SetSrid(location(ST_IsValidDetail(f."{2}",0)), ST_Srid(f.{2})))) as local from ''' query_string += '''(select "{3}", "{2}" from only "{0}"."{1}" where ST_IsValid("{2}") = 'f' and {3} in ({4})) as f''' query_string = query_string.format(self.tableSchema, self.tableName, self.geometryColumn, self.keyColumn, ",".join(lista_fid)) query = QSqlQuery(query_string) self.flagsLayer.startEditing() flagCount = 0 # iniciando contador que será referência para os IDs da camada de memória. listaFeatures = [] while query.next(): motivo = query.value(0) local = query.value(1) flagId = flagCount flagFeat = QgsFeature() flagGeom = QgsGeometry.fromWkt(local) # passa o local onde foi localizado o erro. flagFeat.setGeometry(flagGeom) flagFeat.initAttributes(2) flagFeat.setAttribute(0,flagId) # insere o id definido para a coluna 0 da layer de memória. flagFeat.setAttribute(1, motivo) # insere o motivo/razão pré-definida para a coluna 1 da layer de memória. listaFeatures.append(flagFeat) flagCount += 1 # incrementando o contador a cada iteração self.flagsLayerProvider.addFeatures(listaFeatures) self.flagsLayer.commitChanges() # Aplica as alterações à camada. QgsMapLayerRegistry.instance().addMapLayer(self.flagsLayer) # Adicione a camada no mapa ################################## ##### TROCA MARCADOR DA LAYER #### ################################## # # AQUI PRETENDO PERSONALIZAR O MARCADOR DA MEMORY LAYER, POREM A PRINCIPIO SÓ ESTA ALTERANDO A LAYER ORIGINAL. # for lay in QgsMapLayerRegistry.instance().mapLayers().values(): # if lay == flagsLayerName and not layer.name(): # # Estilo base. # line = QgsLineSymbolV2() # # Crie uma linha de marcadores. # marker_line = QgsMarkerLineSymbolLayerV2() # marker_line.setInterval(10) # # Configure o marcador. # simple_marker = QgsSimpleMarkerSymbolLayerV2() # simple_marker.setShape(QgsSimpleMarkerSymbolLayerBase.HalfSquare) # Formato # simple_marker.setSize(3) # simple_marker.setAngle(180) # simple_marker.setColor(QColor('red')) # cor # simple_marker.setOutlineColor(QColor('red')) # cor # # O marcador tem sua própria camada de símbolo. # marker = QgsMarkerSymbolV2() # marker.changeSymbolLayer(0, simple_marker) # # Adicione a camada à camada do marcador. # marker_line.setSubSymbol(marker) # # Finalmente, substitua a camada de símbolo no estilo base. # line.changeSymbolLayer(0, marker_line) # # Adicione o estilo à camada de linha. # renderer = QgsSingleSymbolRendererV2(line) # layer.setRendererV2(renderer) if flagCount == 0: QgsMapLayerRegistry.instance().removeMapLayer(self.flagsLayer.id()) self.iface.messageBar().pushMessage("Aviso", u"Não foi encontrado Flags em \"" + layer.name() + "\" !", level=QgsMessageBar.CRITICAL, duration=4) return if len(query.lastError().text()) == 1: self.iface.messageBar().pushMessage("Aviso", "foram geradas " + str(flagCount) + " flags para a camada \"" + layer.name() + "\" !", level=QgsMessageBar.INFO, duration=4) else: self.iface.messageBar().pushMessage("Erro", u"a geração de flags falhou!", level=QgsMessageBar.CRITICAL, duration=4) print query.lastError().text()
class MainWindow(QMainWindow): def __init__(self, parent=None): super(MainWindow, self).__init__(parent) self.setWindowIcon(QIcon(":/images/icon.png")) self.setCurrentFile("") # ----------- 数据 ------------- self.spreadsheet = Spreadsheet() self.setCentralWidget(self.spreadsheet) self.findDialog = None self.locationLabel = None self.formulaLabel = None self.recentFiles = None # QStringList recentFiles; self.curFile = None # QString curFile; self.MaxRecentFiles = 5 self.recentFileActions = [None] * self.MaxRecentFiles # self.separatorAction = None # # self.fileMenu = None self.editMenu = None self.selectSubMenu = None self.toolsMenu = None self.optionsMenu = None self.helpMenu = None self.fileToolBar = None self.editToolBar = None self.newAction = None self.openAction = None self.saveAction = None self.saveAsAction = None self.exitAction = None self.cutAction = None self.copyAction = None self.pasteAction = None self.deleteAction = None self.selectRowAction = None self.selectColumnAction = None self.selectAllAction = None self.findAction = None self.goToCellAction = None self.recalculateAction = None self.sortAction = None self.showGridAction = None self.autoRecalcAction = None self.aboutAction = None self.aboutQtAction = None # self.qApp = QApplication([]) # 这样写 有问题 self.createActions() self.createMenus() self.createContextMenu() self.createToolBars() self.createStatusBar() # self.readSettings() # def closeEvent(self, event): # if (self.okToContinue()): # self.writeSettings() # event.accept() # else: # event.ignore() @pyqtSlot() def newFile(self): if (self.okToContinue()): pass # spreadsheet.clear() # setCurrentFile("") @pyqtSlot() def open(self): pass @pyqtSlot() def save(self): pass @pyqtSlot() def saveAs(self): pass @pyqtSlot() def find(self): pass @pyqtSlot() def goToCell(self): pass @pyqtSlot() def sort(self): pass # 关于 @pyqtSlot() def about(self): QMessageBox.about( self, str("About Spreadsheet"), str("<h2>Spreadsheet 1.1</h2>" "<p>Copyright © 2008 Software Inc." "<p>Spreadsheet is a small application that " "demonstrates QAction, QMainWindow, QMenuBar, " "QStatusBar, QTableWidget, QToolBar, and many other " "Qt classes.")) @pyqtSlot() def openRecentFile(self): pass @pyqtSlot() def updateStatusBar(self): pass def spreadsheetModified(self): pass # 创建 Actions def createActions(self): # 新建 self.newAction = QAction(str("&New"), self) self.newAction.setIcon(QIcon(":/images/new.png")) self.newAction.setShortcut(QKeySequence.New) self.newAction.setStatusTip(str("Create a new spreadsheet file")) self.connect(self.newAction, SIGNAL("triggered()"), self, SLOT("newFile()")) # 打开 self.openAction = QAction(str("&Open..."), self) self.openAction.setIcon(QIcon(":/images/open.png")) self.openAction.setShortcut(QKeySequence.Open) self.openAction.setStatusTip(str("Open an existing spreadsheet file")) self.connect(self.openAction, SIGNAL("triggered()"), self, SLOT("open()")) # 保存 self.saveAction = QAction(str("&Save"), self) self.saveAction.setIcon(QIcon(":/images/save.png")) self.saveAction.setShortcut(QKeySequence.Save) self.saveAction.setStatusTip(str("Save the spreadsheet to disk")) self.connect(self.saveAction, SIGNAL("triggered()"), self, SLOT("save()")) # 另存为 self.saveAsAction = QAction(str("Save &As..."), self) self.saveAsAction.setStatusTip( str("Save the spreadsheet under a name")) self.connect(self.saveAsAction, SIGNAL("triggered()"), self, SLOT("saveAs()")) for i in range(self.MaxRecentFiles): self.recentFileActions[i] = QAction(self) self.recentFileActions[i].setVisible(False) self.connect(self.recentFileActions[i], SIGNAL("triggered()"), self, SLOT("openRecentFile()")) # 退出 self.exitAction = QAction(str("E&xit"), self) self.exitAction.setShortcut(str("Ctrl+Q")) self.exitAction.setStatusTip(str("Exit the application")) self.connect(self.exitAction, SIGNAL("triggered()"), self, SLOT("close()")) # ------------- # 剪切 self.cutAction = QAction(str("Cu&t"), self) self.cutAction.setIcon(QIcon(":/images/cut.png")) self.cutAction.setShortcut(QKeySequence.Cut) self.cutAction.setStatusTip( str("Cut the current selection's contents " "to the clipboard")) self.connect(self.cutAction, SIGNAL("triggered()"), self.spreadsheet, SLOT("cut()")) # 拷贝 self.copyAction = QAction(str("&Copy"), self) self.copyAction.setIcon(QIcon(":/images/copy.png")) self.copyAction.setShortcut(QKeySequence.Copy) self.copyAction.setStatusTip( str("Copy the current selection's contents " "to the clipboard")) self.connect(self.copyAction, SIGNAL("triggered()"), self.spreadsheet, SLOT("copy()")) # 黏贴 self.pasteAction = QAction(str("&Paste"), self) self.pasteAction.setIcon(QIcon(":/images/paste.png")) self.pasteAction.setShortcut(QKeySequence.Paste) self.pasteAction.setStatusTip( str("Paste the clipboard's contents into " "the current selection")) self.connect(self.pasteAction, SIGNAL("triggered()"), self.spreadsheet, SLOT("paste()")) self.deleteAction = QAction(str("&Delete"), self) self.deleteAction.setShortcut(QKeySequence.Delete) self.deleteAction.setStatusTip( str("Delete the current selection's " "contents")) # self.connect(self.deleteAction, SIGNAL("triggered()"), # self.spreadsheet, SLOT(del())) self.selectRowAction = QAction(str("&Row"), self) self.selectRowAction.setStatusTip( str("Select all the cells in the " "current row")) self.connect(self.selectRowAction, SIGNAL("triggered()"), self.spreadsheet, SLOT("selectCurrentRow()")) self.selectColumnAction = QAction(str("&Column"), self) self.selectColumnAction.setStatusTip( str("Select all the cells in the " "current column")) self.connect(self.selectColumnAction, SIGNAL("triggered()"), self.spreadsheet, SLOT("selectCurrentColumn()")) self.selectAllAction = QAction(str("&All"), self) self.selectAllAction.setShortcut(QKeySequence.SelectAll) self.selectAllAction.setStatusTip( str("Select all the cells in the " "spreadsheet")) self.connect(self.selectAllAction, SIGNAL("triggered()"), self.spreadsheet, SLOT("selectAll()")) self.findAction = QAction(str("&Find..."), self) self.findAction.setIcon(QIcon(":/images/find.png")) self.findAction.setShortcut(QKeySequence.Find) self.findAction.setStatusTip(str("Find a matching cell")) self.connect(self.findAction, SIGNAL("triggered()"), self, SLOT("find()")) self.goToCellAction = QAction(str("&Go to Cell..."), self) self.goToCellAction.setIcon(QIcon(":/images/gotocell.png")) self.goToCellAction.setShortcut(str("Ctrl+G")) self.goToCellAction.setStatusTip(str("Go to the specified cell")) self.connect(self.goToCellAction, SIGNAL("triggered()"), self, SLOT("goToCell()")) self.recalculateAction = QAction(str("&Recalculate"), self) self.recalculateAction.setShortcut(str("F9")) self.recalculateAction.setStatusTip( str("Recalculate all the " "spreadsheet's formulas")) self.connect(self.recalculateAction, SIGNAL("triggered()"), self.spreadsheet, SLOT("recalculate()")) self.sortAction = QAction(str("&Sort..."), self) self.sortAction.setStatusTip( str("Sort the selected cells or all the " "cells")) self.connect(self.sortAction, SIGNAL("triggered()"), self, SLOT("sort()")) self.showGridAction = QAction(str("&Show Grid"), self) self.showGridAction.setCheckable(True) self.showGridAction.setChecked(self.spreadsheet.showGrid()) self.showGridAction.setStatusTip( str("Show or hide the spreadsheet's " "grid")) self.connect(self.showGridAction, SIGNAL("toggled(bool)"), self.spreadsheet, SLOT("setShowGrid(bool)")) self.autoRecalcAction = QAction(str("&Auto-Recalculate"), self) self.autoRecalcAction.setCheckable(True) # self.autoRecalcAction.setChecked(self.spreadsheet.autoRecalculate()) self.autoRecalcAction.setStatusTip( str("Switch auto-recalculation on or " "off")) # self.connect(self.autoRecalcAction, SIGNAL("toggled(bool)"),\ # self.spreadsheet, SLOT("setAutoRecalculate(bool)")) self.aboutAction = QAction(str("&About"), self) self.aboutAction.setStatusTip(str("Show the application's About box")) self.connect(self.aboutAction, SIGNAL("triggered()"), self, SLOT("about()")) self.aboutQtAction = QAction(str("About &Qt"), self) self.aboutQtAction.setStatusTip(str("Show the Qt library's About box")) # self.connect(self.aboutQtAction, SIGNAL("triggered()"), self.qApp, SLOT("aboutQt()")) # 创建 菜单栏 def createMenus(self): self.fileMenu = self.menuBar().addMenu(str("&File")) self.fileMenu.addAction(self.newAction) self.fileMenu.addAction(self.openAction) self.fileMenu.addAction(self.saveAction) self.fileMenu.addAction(self.saveAsAction) self.separatorAction = self.fileMenu.addSeparator() for i in range(self.MaxRecentFiles): self.fileMenu.addAction(self.recentFileActions[i]) self.fileMenu.addSeparator() self.fileMenu.addAction(self.exitAction) self.editMenu = self.menuBar().addMenu(str("&Edit")) self.editMenu.addAction(self.cutAction) self.editMenu.addAction(self.copyAction) self.editMenu.addAction(self.pasteAction) self.editMenu.addAction(self.deleteAction) self.selectSubMenu = self.editMenu.addMenu(str("&Select")) self.selectSubMenu.addAction(self.selectRowAction) self.selectSubMenu.addAction(self.selectColumnAction) self.selectSubMenu.addAction(self.selectAllAction) self.editMenu.addSeparator() self.editMenu.addAction(self.findAction) self.editMenu.addAction(self.goToCellAction) self.toolsMenu = self.menuBar().addMenu(str("&Tools")) self.toolsMenu.addAction(self.recalculateAction) self.toolsMenu.addAction(self.sortAction) self.optionsMenu = self.menuBar().addMenu(str("&Options")) self.optionsMenu.addAction(self.showGridAction) self.optionsMenu.addAction(self.autoRecalcAction) self.menuBar().addSeparator() helpMenu = self.menuBar().addMenu(str("&Help")) helpMenu.addAction(self.aboutAction) helpMenu.addAction(self.aboutQtAction) # 添加 上下文菜单,右键快捷菜单 def createContextMenu(self): pass self.spreadsheet.addAction(self.cutAction) self.spreadsheet.addAction(self.copyAction) self.spreadsheet.addAction(self.pasteAction) self.spreadsheet.setContextMenuPolicy(Qt.ActionsContextMenu) def createToolBars(self): pass def createStatusBar(self): pass def readSettings(self): pass def writeSettings(self): pass def okToContinue(self): pass # def loadFile(const QString &fileName) def loadFile(self, fileName): pass # def saveFile(const QString &fileName) def saveFile(self, fileName): pass # def setCurrentFile(const QString &fileName) def setCurrentFile(self, fileName): pass def updateRecentFileActions(self): pass # def strippedName(const QString &fullFileName) def strippedName(self, fullFileName): pass