def selectOutput(self): if isinstance(self.output, OutputDirectory): self.selectDirectory() else: popupMenu = QMenu() actionSaveToTempFile = QAction( self.tr('Save to a temporary file'), self.btnSelect) actionSaveToTempFile.triggered.connect(self.saveToTemporaryFile) popupMenu.addAction(actionSaveToTempFile) actionSaveToFile = QAction( self.tr('Save to file...'), self.btnSelect) actionSaveToFile.triggered.connect(self.selectFile) popupMenu.addAction(actionSaveToFile) if isinstance(self.output, OutputVector) \ and self.alg.provider.supportsNonFileBasedOutput(): actionSaveToMemory = QAction( self.tr('Save to memory layer'), self.btnSelect) actionSaveToMemory.triggered.connect(self.saveToMemory) popupMenu.addAction(actionSaveToMemory) actionSaveToPostGIS = QAction( self.tr('Save to PostGIS table...'), self.btnSelect) actionSaveToPostGIS.triggered.connect(self.saveToPostGIS) settings = QSettings() settings.beginGroup('/PostgreSQL/connections/') names = settings.childGroups() settings.endGroup() actionSaveToPostGIS.setEnabled(bool(names)) popupMenu.addAction(actionSaveToPostGIS) popupMenu.exec_(QCursor.pos())
def manageActions(self, modelindex, menu): """ Returns the list of actions to be loaded into the context menu of this node when a user right clicks in the treeview. Default actions are for expanding/collapsing child nodes. To be inherited by subclasses for additional custom actions. """ nullAction = QAction(NO_ACTION_ICON, QApplication.translate("BaseSTRNode", "No User Action"), self.parentWidget()) nullAction.setEnabled(False) if not self._view is None: if self._view.isExpanded(modelindex): self._expand_action.setEnabled(False) self._collapse_action.setEnabled(True) else: self._expand_action.setEnabled(True) self._collapse_action.setEnabled(False) #Disconnect then reconnect signals if self.signalReceivers(self._expand_action) > 0: self._expand_action.triggered.disconnect() if self.signalReceivers(self._collapse_action) > 0: self._collapse_action.triggered.disconnect() #Connect expand/collapse signals to the respective actions self._expand_action.triggered.connect(lambda:self._on_expand(modelindex)) self._collapse_action.triggered.connect(lambda: self._on_collapse(modelindex)) menu.addAction(self._expand_action) menu.addAction(self._collapse_action)
def __init__(self): QObject.__init__(self) self._createdActions = [] self._createdSeparators = [] self._createdMenus = [] self._currentDocument = core.workspace().currentDocument() # probably None for menu in _MENUS: if menu[2]: menuObj = core.actionManager().addMenu(menu[0], menu[1], QIcon(':/enkiicons/' + menu[2])) else: menuObj = core.actionManager().addMenu(menu[0], menu[1]) menuObj.setEnabled(False) self._createdMenus.append(menuObj) for item in _ACTIONS: if isinstance(item, tuple): # action command, path, text, shortcut, icon = item actObject = QAction(text, self) if shortcut: actObject.setShortcut(shortcut) if icon: actObject.setIcon(QIcon(':/enkiicons/' + icon)) actObject.setData(command) actObject.setEnabled(False) actObject.triggered.connect(self.onAction) core.actionManager().addAction(path, actObject) self._createdActions.append(actObject) else: # separator menuPath = item menu = core.actionManager().menu(menuPath) self._createdSeparators.append(menu.addSeparator()) core.workspace().currentDocumentChanged.connect(self.onCurrentDocumentChanged)
def __init__(self): QObject.__init__(self) self._createdActions = [] self._createdMenus = [] self._currentDocument = core.workspace().currentDocument() # probably None model = core.actionManager() for menu in _MENUS: if menu[2]: menuObj = model.addMenu(menu[0], menu[1], QIcon(':/enkiicons/' + menu[2])) else: menuObj = model.addMenu(menu[0], menu[1]) menuObj.setEnabled(False) self._createdMenus.append(menuObj) for command, path, text, shortcut, icon in _ACTIONS: actObject = QAction(text, self) if shortcut: actObject.setShortcut(shortcut) if icon: actObject.setIcon(QIcon(':/enkiicons/' + icon)) actObject.setData(command) actObject.setEnabled(False) actObject.triggered.connect(self.onAction) model.addAction(path, actObject) self._createdActions.append(actObject) core.workspace().currentDocumentChanged.connect(self.onCurrentDocumentChanged)
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)
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 manageActions(self,modelindex,menu): ''' Returns a menu for managing social tenure relationship information. ''' editReceivers = self.signalReceivers(self.editAction) if editReceivers > 0: self.editAction.triggered.disconnect() deleteReceivers = self.signalReceivers(self.deleteAction) if deleteReceivers > 0: self.deleteAction.triggered.disconnect() #Add new entities menu entityAddMenu = QMenu(QApplication.translate("STRNode","Add"),self.parentWidget()) entityAddMenu.setIcon(QIcon(":/plugins/stdm/images/icons/add.png")) #Define actions for adding related STR entities confAction = QAction(QIcon(":/plugins/stdm/images/icons/conflict.png"), QApplication.translate("STRNode","Conflict Information"),self._view) confAction.triggered.connect(lambda: self.onCreateConflict(modelindex)) #Check if conflict information already exists. If so, then no need of defining twice if self.strModel.hasConflict(): confAction.setEnabled(False) entityAddMenu.addAction(confAction) taxAction = QAction(QIcon(":/plugins/stdm/images/icons/receipt.png"), QApplication.translate("STRNode","Tax Information"),self._view) taxAction.triggered.connect(lambda: self.onCreateTaxation(modelindex)) if self.strModel.hasTaxation(): taxAction.setEnabled(False) entityAddMenu.addAction(taxAction) #Add source documents menu addSrcDocMenu = QMenu(QApplication.translate("STRNode","Source Documents"),self.parentWidget()) addSrcDocMenu.setIcon(QIcon(":/plugins/stdm/images/icons/attachment.png")) titleDeedAction = QAction(QApplication.translate("STRNode","Title Deed"),self._view) titleDeedAction.triggered.connect(lambda: self.onAddSourceDocument(TITLE_DEED)) addSrcDocMenu.addAction(titleDeedAction) notaryRefAction = QAction(QApplication.translate("STRNode","Notary Reference"),self._view) notaryRefAction.triggered.connect(lambda: self.onAddSourceDocument(NOTARY_REF)) addSrcDocMenu.addAction(notaryRefAction) statRefPaperAction = QAction(QApplication.translate("STRNode","Statutory Reference Paper"),self._view) statRefPaperAction.triggered.connect(lambda: self.onAddSourceDocument(STATUTORY_REF_PAPER)) addSrcDocMenu.addAction(statRefPaperAction) surveyorRefAction = QAction(QApplication.translate("STRNode","Surveyor Reference"),self._view) surveyorRefAction.triggered.connect(lambda: self.onAddSourceDocument(SURVEYOR_REF)) addSrcDocMenu.addAction(surveyorRefAction) entityAddMenu.addMenu(addSrcDocMenu) menu.addMenu(entityAddMenu) menu.addAction(self.editAction) menu.addAction(self.deleteAction) #Disable if the user does not have permission. if not self.parentWidget()._canEdit: menu.setEnabled(False) self.editAction.triggered.connect(lambda: self.onEdit(modelindex)) self.deleteAction.triggered.connect(lambda: self.onDelete(modelindex))
class TestPlugin3: def __init__(self, iface): self.iface = iface self.plugin_dir = os.path.dirname(__file__) self.name = u'Test Plugin 3' self.action = None self.icon_path = os.path.join( self.plugin_dir, 'images', 'test_plugin_3.png') # noinspection PyPep8Naming def initGui(self): icon = QIcon(self.icon_path) self.action = QAction(icon, u'Run', self.iface.mainWindow()) self.action.triggered.connect(self.run) self.action.setEnabled(True) self.iface.addPluginToMenu(self.name, self.action) def unload(self): self.iface.removePluginMenu(self.name, self.action) def run(self): QMessageBox.information(None, 'Testing', "Test information dialog from plugin: \n\n{0}" .format(self.name))
def build_columns_menu(self): columns_menu = QMenu(self) available_columns = self.core.get_available_columns() accounts = self.core.get_all_accounts() if len(accounts) == 0: empty_menu = QAction(i18n.get("no_registered_accounts"), self) empty_menu.setEnabled(False) columns_menu.addAction(empty_menu) else: for account in accounts: name = "%s (%s)" % (account.username, i18n.get(account.protocol_id)) account_menu = QAction(name, self) if len(available_columns[account.id_]) > 0: available_columns_menu = QMenu(self) for column in available_columns[account.id_]: item = QAction(column.slug, self) if column.__class__.__name__ == "List": # FIXME: Uncomment this after fixing the error with get_list_id in libturpial # column_id = "-".join([account.id_, column.id_]) # item.triggered.connect(partial(self.add_column, column_id)) continue else: item.triggered.connect(partial(self.add_column, column.id_)) available_columns_menu.addAction(item) account_menu.setMenu(available_columns_menu) else: account_menu.setEnabled(False) columns_menu.addAction(account_menu) return columns_menu
class ItemAutoConnecter( QObject ): def __init__( self, scene ): QObject.__init__( self, scene ) self.scene = scene self._action = QAction( "Auto Connect Items", self ) self.connect( self._action, SIGNAL( 'triggered( bool )' ), self.autoConnect ) def action( self ): return self._action def updateAction( self ): self._action.setEnabled( self.canConnect() ) def canConnect( self ): # Get all items sort by y position items = sorted( self.scene.graph.items(), key = lambda item: item.scenePos().y() ) # We need at least two items if len( items ) < 2: #print "Less than two items" return False # Top is source, bottom is sink if len( items[0].requiresPorts ) != 0 or len( items[-1].providesPorts ) != 0: #print "Top must be bottom and bottom sink" return False # Only single port items in between if len( items ) > 2 and set( sum( [ [ len( item.requiresPorts ), len( item.providesPorts ) ] for item in items[1:-1] ], [] ) ) != set([1]): #print "There are items with multiple ports" return False # Ports sequence ports = [ items[0].providesPorts[0] ] + sum( [ [ item.requiresPorts[0], item.providesPorts[0] ] for item in items[1:-1] ], [] ) + [ items[-1].requiresPorts[0] ] # Cancel if ports are already connected if max( [ len( self.scene.graph.outEdges( p ) ) for p in ports[0::2] ] ) != 0 or \ max( [ len( self.scene.graph.inEdges( p ) ) for p in ports[1::2] ] ) != 0: #print "Already connected" return False datatypes = [ p.datatype for p in ports ] if False in [ datatypes[i] == datatypes[i+1] for i in range( 0, len( datatypes ), 2 ) ]: return False return True # TODO allow more cases, respect already connected edges def autoConnect( self ): # Get all items sort by y position items = sorted( self.scene.graph.items(), key = lambda item: item.scenePos().y() ) # Connect? if not self.canConnect(): return ports = [ items[0].providesPorts[0] ] + sum( [ [ item.requiresPorts[0], item.providesPorts[0] ] for item in items[1:-1] ], [] ) + [ items[-1].requiresPorts[0] ] for i in range( 0, len( ports ), 2 ): self.scene.graph.addEdge( ports[i], ports[i+1] )
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 init(): action = QAction("Open audio in Audacity", mw) action.setShortcut('Ctrl+Shift+A') action.setEnabled(True) mw.connect(action, SIGNAL('triggered()'), open_in_audacity) mw.form.menuTools.addAction(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 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 _initialize_tree_specific_menu_entries(self, tree_instance, menu_reference, is_main_tree): """ Creates standard menu entries (that are used for both trees) for the given tree_instance @param tree_instance: Tree object that should be used. @param menu_reference: QMenu object where to add the menu entries @param is_main_tree: to differ between main and second tree. """ exchange_action = QAction("Exchange", self) QObject.connect( exchange_action, SIGNAL('triggered()'), lambda: self._menu_exchange_tree_elements(tree_instance)) menu_reference.addAction(exchange_action) data_up_action = QAction("DataUp", self) QObject.connect( data_up_action, SIGNAL('triggered()'), #call data up move lambda: QMessageBox.information(self.main_window, "Info", '''The following were susscessully moved up: ''' + "".join(tree_operations.data_up_move(tree_instance)))) menu_reference.addAction(data_up_action) data_down_action = QAction("DataDown", self) QObject.connect( data_down_action, SIGNAL('triggered()'), #call data down move lambda: QMessageBox.information(self.main_window, "Info", '''The following were successfully moved down: ''' + "".join(tree_operations.data_down_move(tree_instance) ))) menu_reference.addAction(data_down_action) data_replace_action = QAction("Replace", self) QObject.connect( data_replace_action, SIGNAL('triggered()'), lambda: self._menu_change_label_of_selected_elements(tree_instance, is_main_tree)) menu_reference.addAction(data_replace_action) data_search_and_replace_action = QAction("Search and replace", self) QObject.connect( data_search_and_replace_action, SIGNAL('triggered()'), lambda: tree_operations.data_search_and_replace(self.main_window, tree_instance)) menu_reference.addAction(data_search_and_replace_action) data_search_and_replace_action.setEnabled(False)
def addBranch(self, branch): a = QAction(self) a.setCheckable(True) if branch == vcs.app_repo.current_branch(): a.setChecked(True) a.setEnabled(False) self._acts[branch] = a self.setBranchStatus(branch)
def createAction(self, model): """ @type model: ButtonModelMixin""" action = QAction(self.button) action.setText(model.getButtonName()) action.setEnabled(model.buttonIsEnabled()) action.triggered.connect(model.buttonTriggered) model.observable().attach(ButtonModelMixin.BUTTON_STATE_CHANGED_EVENT, self.modelChanged) self.models[model] = action return action
class FieldPyculatorPlugin: def __init__(self, iface): # Save reference to the QGIS interface self.iface = iface # i18n support override_locale = QSettings().value('locale/overrideFlag', False, type=bool) if not override_locale: locale_full_name = QLocale.system().name() else: locale_full_name = QSettings().value('locale/userLocale', '', type=unicode) self.locale_path = currentPath + '/i18n/field_pyculator_' + locale_full_name[0:2] + '.qm' if path.exists(self.locale_path): self.translator = QTranslator() self.translator.load(self.locale_path) QCoreApplication.installTranslator(self.translator) def tr(self, text): return QCoreApplication.translate('FieldPyculatorPlugin', text) def initGui(self): # Create action that will start plugin configuration self.action = QAction(QIcon(':/plugins/fieldpyculatorplugin/icon.png'), self.tr('FieldPyculator'), self.iface.mainWindow()) # connect the action to the run method QObject.connect(self.action, SIGNAL('triggered()'), self.run) # Add toolbar button and menu item self.iface.addToolBarIcon(self.action) self.iface.addPluginToMenu(self.tr('&FieldPyculator'), self.action) # track layer changing QObject.connect(self.iface, SIGNAL('currentLayerChanged( QgsMapLayer* )'), self.layer_changed) # check already selected layers self.layer_changed() def unload(self): # Remove the plugin menu item and icon self.iface.removePluginMenu(self.tr('&FieldPyculator'), self.action) self.iface.removeToolBarIcon(self.action) # Remove layer changing tracking QObject.disconnect(self.iface, SIGNAL('currentLayerChanged( QgsMapLayer* )'), self.layer_changed) def layer_changed(self): layer = self.iface.activeLayer() if (layer is None) or (layer.type() != QgsMapLayer.VectorLayer): self.action.setEnabled(False) else: self.action.setEnabled(True) def run(self): # create and show the dialog self.dlg = FieldPyculatorDialog(self.iface) # show the dialog self.dlg.show()
def populate_switch_effect_menu(self, target_menu, checked_item): effect_menu = QMenu(i18n("Effect"), target_menu) for preset in LADSPAEffects().effects(): action = QAction(preset["preset_name"],effect_menu) effect_menu.addAction(action) if checked_item == preset["label"]: action.setCheckable(True) action.setChecked(True) action.setEnabled(False) target_menu.addMenu(effect_menu)
def __init__(self): QMainWindow.__init__(self) self.ui = Ui_MainWindow() self.ui.setupUi(self) self.loadTranslations() self.settings = QSettings("LVK Inc", "DataCenters") self.resourcesGraphEditor = ResourcesGraphEditor() self.demandGraphEditor = DemandGraphEditor() self.randomDialog = RandomDemandDialog() self.Vis = Vis() self.graphvis = GraphVis(self) self.demands = {} self.project = Project() # TODO: Captain, we have a problem! # For some reason, in Python 2.7 QSettings converts dicts to QVariant # So the ini file is undecypherable # This works fine in Python 3.2 by the way #if self.settings.value("vis"): #self.Vis.canvas.settings = self.settings.value("vis") #self.graphvis.settings = self.settings.value("graphVis") self.settingsDialog = SettingsDialog(self.Vis.canvas.settings, self.graphvis.settings) self.settingsDialog.ui.backup.setChecked(self.settings.value("backup").toBool()) self.settingsDialog.ui.autosave.setChecked(self.settings.value("autosave").toBool()) self.settingsDialog.ui.interval.setValue(self.settings.value("interval").toInt()[0]) i = 0 for s in self.languages: self.settingsDialog.ui.languages.addItem(s) if s == str(self.settings.value("language").toString()): self.settingsDialog.ui.languages.setCurrentIndex(i) i += 1 self.resourcesGraphEditor.setData(self.project.resources) for i in range(self.MaxRecentFiles): a = QAction(self) a.setVisible(False) a.setEnabled(False) if i <= 9: a.setShortcut(QKeySequence(self.tr("Alt+") + str(i + 1))) QObject.connect(a, SIGNAL("triggered()"), self.OpenRecentFile); self.ui.menuFile.insertAction(self.ui.actionExit, a) self.recentFileActions.append(a) self.UpdateRecentFileActions() self.basename = self.windowTitle() self.demandGraphEditor.demand_changed.connect(self.demandChanged) self.backupTimer = QTimer() self.backupTimer.setInterval(60000) self.backupTimer.setSingleShot(False) QObject.connect(self.backupTimer, SIGNAL("timeout()"), self.Backup) self.autosaveTimer = QTimer() self.autosaveTimer.setInterval(60000) self.autosaveTimer.setSingleShot(False) QObject.connect(self.autosaveTimer, SIGNAL("timeout()"), self.Autosave) self.Translate(str(self.settings.value("language", "English").toString())) self.projFilter = self.tr("Data centers projects (*.dcxml)") self.setWindowTitle(self.tr("Untitled") + " - " + self.basename) self.loadPlugins()
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 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)
class Tool(object): def __init__(self, name, help_link="", icon=None, enabled=True, checkable=False, popup_menu=False): super(Tool, self).__init__() self.__icon = icon self.__name = name self.__parent = None self.__enabled = enabled self.__checkable = checkable self.__help_link = help_link self.__is_popup_menu = popup_menu self.__action = QAction(self.getIcon(), self.getName(), None) self.__action.setIconText(self.getName()) self.__action.setEnabled(self.isEnabled()) self.__action.setCheckable(checkable) self.__action.triggered.connect(self.trigger) HelpCenter.addHelpToAction(self.__action, self.getHelpLink()) def getIcon(self): return self.__icon def getName(self): return self.__name def trigger(self): raise NotImplementedError() def setParent(self, parent): self.__parent = parent self.__action.setParent(parent) def parent(self): return self.__parent def isEnabled(self): return self.__enabled def getHelpLink(self): return self.__help_link def getAction(self): return self.__action def setVisible(self, visible): self.__action.setVisible(visible) def setEnabled(self, enabled): self.__action.setEnabled(enabled) def isPopupMenu(self): return self.__is_popup_menu
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 createAction(self, provider): icon = QIcon(':/plugins/PosiView/ledgreen.png') icon.addFile(':/plugins/PosiView/ledgrey.png', QSize(), QIcon.Disabled, QIcon.Off) action = QAction(icon, provider.name, None) button = QToolButton() button.setDefaultAction(action) action.setEnabled(False) provider.deviceConnected.connect(action.setEnabled) provider.deviceDisconnected.connect(action.setDisabled) self.signalMapper.setMapping(action, provider.name) action.triggered.connect(self.signalMapper.map) self.addAction(action) self.actions.append(action)
def context_menu_create_custom(self): self.context_menu_create_ports() self.context_menu_create_sounddevices() action_device = QAction(i18n("Default Sink"), self.popup_menu) self.popup_menu.addAction(action_device) action_device.setCheckable(True) if self.isDefaultSink(): action_device.setChecked(True) action_device.setEnabled(False) else: action_device.setChecked(False) action_device.setEnabled(True) action_device.triggered.connect(self.on_set_default_sink_triggered)
def manageActions(self,modelindex,menu): ''' Returns the list of actions to be loaded into the context menu of this node when a user right clicks in the treeview. Default action is a notification that no action item has been defined for the current node item. To be inherited by subclasses for custom actions. ''' nullAction = QAction(NO_ACTION_ICON, QApplication.translate("BaseSTRNode", "No User Action"),self.parentWidget()) nullAction.setEnabled(False) menu.addAction(nullAction)
def main(): app = QApplication(sys.argv) window = QMainWindow() central_widget = QWidget(window) start_action = QAction('Start', window) stop_action = QAction('Stop', window) toolbar = window.addToolBar('Monitor') toolbar.addAction(start_action) toolbar.addAction(stop_action) central_layout = QVBoxLayout(central_widget) monitor_name = QLabel(central_widget) central_layout.addWidget(monitor_name) state_label = QLabel(central_widget) central_layout.addWidget(state_label) combo_box = QComboBox(central_widget) items = [ ('No keys', AbstractKeyboardMonitor.IGNORE_NO_KEYS), ('Modifiers', AbstractKeyboardMonitor.IGNORE_MODIFIER_KEYS), ('Modifier combos', AbstractKeyboardMonitor.IGNORE_MODIFIER_COMBOS)] for label, userdata in items: combo_box.addItem(label, userdata) def _update_ignore_keys(index): monitor.keys_to_ignore = combo_box.itemData(index).toPyObject() combo_box.currentIndexChanged[int].connect(_update_ignore_keys) central_layout.addWidget(combo_box) central_widget.setLayout(central_layout) window.setCentralWidget(central_widget) monitor = create_keyboard_monitor(window) monitor_name.setText('Using monitor class {0}'.format( monitor.__class__.__name__)) monitor.typingStarted.connect(partial(state_label.setText, 'typing')) monitor.typingStopped.connect(partial(state_label.setText, 'not typing')) start_action.triggered.connect(monitor.start) stop_action.triggered.connect(monitor.stop) stop_action.setEnabled(False) monitor.started.connect(partial(start_action.setEnabled, False)) monitor.started.connect(partial(stop_action.setEnabled, True)) monitor.stopped.connect(partial(start_action.setEnabled, True)) monitor.stopped.connect(partial(stop_action.setEnabled, False)) window.show() app.exec_()
def __createLayout( self ): " Creates the toolbar and layout " # Buttons printButton = QAction( PixmapCache().getIcon( 'printer.png' ), 'Print', self ) printButton.triggered.connect( self.__onPrint ) printButton.setEnabled( False ) printButton.setVisible( False ) printPreviewButton = QAction( PixmapCache().getIcon( 'printpreview.png' ), 'Print preview', self ) printPreviewButton.triggered.connect( self.__onPrintPreview ) printPreviewButton.setEnabled( False ) printPreviewButton.setVisible( False ) spacer = QWidget() spacer.setSizePolicy( QSizePolicy.Expanding, QSizePolicy.Expanding ) self.lineCounterButton = QAction( PixmapCache().getIcon( 'linecounter.png' ), 'Line counter', self ) self.lineCounterButton.triggered.connect( self.onLineCounter ) # The toolbar toolbar = QToolBar( self ) toolbar.setOrientation( Qt.Vertical ) toolbar.setMovable( False ) toolbar.setAllowedAreas( Qt.RightToolBarArea ) toolbar.setIconSize( QSize( 16, 16 ) ) toolbar.setFixedWidth( 28 ) toolbar.setContentsMargins( 0, 0, 0, 0 ) toolbar.addAction( printPreviewButton ) toolbar.addAction( printButton ) toolbar.addWidget( spacer ) toolbar.addAction( self.lineCounterButton ) self.__importsBar = ImportListWidget( self.__viewer ) self.__importsBar.hide() hLayout = QHBoxLayout() hLayout.setContentsMargins( 0, 0, 0, 0 ) hLayout.setSpacing( 0 ) hLayout.addWidget( self.__viewer ) hLayout.addWidget( toolbar ) self.setLayout( hLayout ) return
def create_action(self, index_action=None, text='', toolbar=None, menu=None, is_checkable=True, function_name=None, parent=None): if parent is None: parent = self.iface.mainWindow() icon = None if index_action is not None: icon_path = self.icon_folder+index_action+'.png' if os.path.exists(icon_path): icon = QIcon(icon_path) if icon is None: action = QAction(text, parent) else: action = QAction(icon, text, parent) if toolbar is not None: toolbar.addAction(action) if menu is not None: self.iface.addPluginToMenu(menu, action) if index_action is not None: self.actions[index_action] = action else: self.actions[text] = action if function_name is not None: try: action.setCheckable(is_checkable) # Management toolbar actions if int(index_action) in (19, 21, 24, 25, 27, 28, 99): callback_function = getattr(self.mg, function_name) action.triggered.connect(callback_function) # Edit toolbar actions elif int(index_action) in (32, 33, 34, 36): callback_function = getattr(self.ed, function_name) action.triggered.connect(callback_function) # Generic function else: water_soft = function_name[:2] callback_function = getattr(self, water_soft+'_generic') action.triggered.connect(partial(callback_function, function_name)) except AttributeError: #print index_action+". Callback function not found: "+function_name action.setEnabled(False) else: action.setEnabled(False) return action
class ClassesViewer( QWidget ): """ The classes viewer widget """ def __init__( self, parent = None ): QWidget.__init__( self, parent ) self.filterEdit = None self.definitionButton = None self.findButton = None self.copyPathButton = None self.clViewer = None self.__createLayout() # create the context menu self.__menu = QMenu( self ) self.__jumpMenuItem = self.__menu.addAction( \ PixmapCache().getIcon( 'definition.png' ), 'Jump to definition', self.__goToDefinition ) self.__menu.addSeparator() self.__findMenuItem = self.__menu.addAction( \ PixmapCache().getIcon( 'findusage.png' ), 'Find occurences', self.__findWhereUsed ) self.__menu.addSeparator() self.__disasmMenuItem = self.__menu.addAction( \ PixmapCache().getIcon( 'disasmmenu.png' ), 'Disassemble', self.__onDisassemble ) self.__menu.addSeparator() self.__copyMenuItem = self.__menu.addAction( \ PixmapCache().getIcon( 'copytoclipboard.png' ), 'Copy path to clipboard', self.clViewer.copyToClipboard ) self.clViewer.setContextMenuPolicy( Qt.CustomContextMenu ) self.clViewer.customContextMenuRequested.connect( self.__handleShowContextMenu ) GlobalData().project.projectChanged.connect( self.__onProjectChanged ) self.connect( self.clViewer, SIGNAL( "selectionChanged" ), self.__selectionChanged ) self.clViewer.openingItem.connect( self.itemActivated ) self.connect( self.clViewer, SIGNAL( "modelFilesChanged" ), self.modelFilesChanged ) self.filterEdit.lineEdit().setFocus() self.__contextItem = None return def setTooltips( self, switchOn ): " Triggers the tooltips mode " self.clViewer.model().sourceModel().setTooltips( switchOn ) return def __createLayout( self ): " Helper to create the viewer layout " self.clViewer = ClassesBrowser() # Toolbar part - buttons self.definitionButton = QAction( PixmapCache().getIcon( 'definition.png' ), 'Jump to highlighted item definition', self ) self.definitionButton.triggered.connect( self.__goToDefinition ) self.findButton = QAction( PixmapCache().getIcon( 'findusage.png' ), 'Find highlighted item occurences', self ) self.findButton.triggered.connect( self.__findWhereUsed ) self.copyPathButton = QAction( PixmapCache().getIcon( 'copytoclipboard.png' ), 'Copy path to clipboard', self ) self.copyPathButton.triggered.connect( self.clViewer.copyToClipboard ) self.findNotUsedButton = QAction( PixmapCache().getIcon( 'notused.png' ), 'Unused class analysis', self ) self.findNotUsedButton.triggered.connect( self.__findNotUsed ) self.findNotUsedButton.setEnabled( False ) self.toolbar = QToolBar( self ) self.toolbar.setMovable( False ) self.toolbar.setAllowedAreas( Qt.TopToolBarArea ) self.toolbar.setIconSize( QSize( 16, 16 ) ) self.toolbar.setFixedHeight( 28 ) self.toolbar.setContentsMargins( 0, 0, 0, 0 ) self.toolbar.addAction( self.definitionButton ) self.toolbar.addAction( self.findButton ) self.toolbar.addAction( self.copyPathButton ) filterLabel = QLabel( " Filter " ) self.toolbar.addWidget( filterLabel ) self.filterEdit = CDMComboBox( True, self.toolbar ) self.filterEdit.setSizePolicy( QSizePolicy.Expanding, QSizePolicy.Expanding ) self.filterEdit.lineEdit().setToolTip( "Space separated regular expressions" ) self.toolbar.addWidget( self.filterEdit ) self.toolbar.addAction( self.findNotUsedButton ) self.filterEdit.editTextChanged.connect( self.__filterChanged ) self.filterEdit.itemAdded.connect( self.__filterItemAdded ) self.filterEdit.enterClicked.connect( self.__enterInFilter ) layout = QVBoxLayout() layout.setContentsMargins( 0, 0, 0, 0 ) layout.setSpacing( 0 ) layout.addWidget( self.toolbar ) layout.addWidget( self.clViewer ) self.setLayout( layout ) return def __filterChanged( self, text ): " Triggers when the filter text changed " self.clViewer.setFilter( text ) self.clViewer.updateCounter() return def __selectionChanged( self, index ): " Handles the changed selection " if index is None: self.__contextItem = None else: self.__contextItem = self.clViewer.model().item( index ) self.__updateButtons() return def getItemCount( self ): " Provides the number of items in the model - total, not only visible " return self.clViewer.model().sourceModel().rowCount() def itemActivated( self, path, line ): " Handles the item activation " self.filterEdit.addItem( self.filterEdit.lineEdit().text() ) return def __filterItemAdded( self ): " The filter item has been added " project = GlobalData().project if project.fileName != "": project.setFindClassHistory( self.filterEdit.getItems() ) return def __enterInFilter( self ): " ENTER key has been clicked in the filter " # check if there any records displayed if self.clViewer.model().rowCount() == 0: return # Move the focus to the list and select the first row self.clViewer.clearSelection() flags = QItemSelectionModel.SelectCurrent | QItemSelectionModel.Rows self.clViewer.setSelection( QRect( 0, 0, self.clViewer.width(), 1 ), flags ) self.clViewer.setFocus() return def __onProjectChanged( self, what ): " Triggered when a project is changed " if what == CodimensionProject.CompleteProject: self.__contextItem = None self.__updateButtons() self.filterEdit.clear() project = GlobalData().project if project.isLoaded(): self.filterEdit.editTextChanged.disconnect( self.__filterChanged ) self.filterEdit.addItems( project.findClassHistory ) self.filterEdit.editTextChanged.connect( self.__filterChanged ) self.findNotUsedButton.setEnabled( self.getItemCount() > 0 ) else: self.findNotUsedButton.setEnabled( False ) self.filterEdit.clearEditText() return def __handleShowContextMenu( self, coord ): """ Show the context menu """ index = self.clViewer.indexAt( coord ) if not index.isValid(): return # This will update the __contextItem self.__selectionChanged( index ) if self.__contextItem is None: return self.__jumpMenuItem.setEnabled( self.definitionButton.isEnabled() ) self.__findMenuItem.setEnabled( self.findButton.isEnabled() ) self.__copyMenuItem.setEnabled( self.copyPathButton.isEnabled() ) canDisassemble = self.__contextItem.canGetDisassembler() self.__disasmMenuItem.setEnabled( canDisassemble ) self.__menu.popup( QCursor.pos() ) return def __goToDefinition( self ): """ Jump to definition context menu handler """ if self.__contextItem is not None: self.clViewer.openItem( self.__contextItem ) return def __findWhereUsed( self ): """ Find where used context menu handler """ if self.__contextItem is not None: GlobalData().mainWindow.findWhereUsed( \ self.__contextItem.getPath(), self.__contextItem.sourceObj ) return def __findNotUsed( self ): " Runs the unused class analysis " GlobalData().mainWindow.onNotUsedClasses() return def __updateButtons( self ): " Updates the toolbar buttons depending on what is selected " self.definitionButton.setEnabled( False ) self.findButton.setEnabled( False ) self.copyPathButton.setEnabled( False ) if self.__contextItem is None: return if self.__contextItem.itemType == DecoratorItemType: self.definitionButton.setEnabled( True ) self.copyPathButton.setEnabled( True ) return if self.__contextItem.itemType in [ FunctionItemType, ClassItemType, AttributeItemType, GlobalItemType ]: self.definitionButton.setEnabled( True ) self.findButton.setEnabled( True ) self.copyPathButton.setEnabled( True ) return def onFileUpdated( self, fileName, uuid ): " Triggered when the file is updated " self.clViewer.onFileUpdated( fileName ) self.findNotUsedButton.setEnabled( GlobalData().project.isLoaded() and \ self.getItemCount() > 0 ) return def modelFilesChanged( self ): " Triggered when the source model has a file or files added or deleted " self.findNotUsedButton.setEnabled( GlobalData().project.isLoaded() and \ self.getItemCount() > 0 ) return def __onDisassemble( self ): " Disassembling has been requested " if self.__contextItem is not None: self.clViewer.getDisassembled( self.__contextItem )
class BreakPointViewer(QWidget): " Implements the break point viewer for a debugger " def __init__(self, parent, bpointsModel): QWidget.__init__(self, parent) self.__currentItem = None self.__createLayout(bpointsModel) GlobalData().project.projectChanged.connect(self.__onProjectChanged) self.connect(GlobalData().project, SIGNAL('projectAboutToUnload'), self.__onProjectAboutToUnload) self.connect(self.bpointsList, SIGNAL("selectionChanged"), self.__onSelectionChanged) self.connect(bpointsModel, SIGNAL('BreakpoinsChanged'), self.__onModelChanged) return def setFocus(self): " Sets the widget focus " self.bpointsList.setFocus() return def __createLayout(self, bpointsModel): " Creates the widget layout " verticalLayout = QVBoxLayout(self) verticalLayout.setContentsMargins(0, 0, 0, 0) verticalLayout.setSpacing(0) self.headerFrame = QFrame() self.headerFrame.setFrameStyle(QFrame.StyledPanel) self.headerFrame.setAutoFillBackground(True) headerPalette = self.headerFrame.palette() headerBackground = headerPalette.color(QPalette.Background) headerBackground.setRgb(min(headerBackground.red() + 30, 255), min(headerBackground.green() + 30, 255), min(headerBackground.blue() + 30, 255)) headerPalette.setColor(QPalette.Background, headerBackground) self.headerFrame.setPalette(headerPalette) self.headerFrame.setFixedHeight(24) self.__breakpointLabel = QLabel("Breakpoints") fixedSpacer = QSpacerItem(3, 3) headerLayout = QHBoxLayout() headerLayout.setContentsMargins(0, 0, 0, 0) headerLayout.addSpacerItem(fixedSpacer) headerLayout.addWidget(self.__breakpointLabel) self.headerFrame.setLayout(headerLayout) self.bpointsList = BreakPointView(self, bpointsModel) self.__editButton = QAction(PixmapCache().getIcon('bpprops.png'), "Edit breakpoint properties", self) self.__editButton.triggered.connect(self.__onEdit) self.__editButton.setEnabled(False) self.__jumpToCodeButton = QAction( PixmapCache().getIcon('gotoline.png'), "Jump to the code", self) self.__jumpToCodeButton.triggered.connect(self.__onJumpToCode) self.__jumpToCodeButton.setEnabled(False) self.__enableButton = QAction(PixmapCache().getIcon('bpenable.png'), "Enable selected breakpoint", self) self.__enableButton.triggered.connect(self.__onEnableDisable) self.__enableButton.setEnabled(False) self.__disableButton = QAction(PixmapCache().getIcon('bpdisable.png'), "Disable selected breakpoint", self) self.__disableButton.triggered.connect(self.__onEnableDisable) self.__disableButton.setEnabled(False) self.__enableAllButton = QAction( PixmapCache().getIcon('bpenableall.png'), "Enable all the breakpoint", self) self.__enableAllButton.triggered.connect(self.__onEnableAll) self.__enableAllButton.setEnabled(False) self.__disableAllButton = QAction( PixmapCache().getIcon('bpdisableall.png'), "Disable all the breakpoint", self) self.__disableAllButton.triggered.connect(self.__onDisableAll) self.__disableAllButton.setEnabled(False) self.__delButton = QAction(PixmapCache().getIcon('delitem.png'), "Delete selected breakpoint", self) self.__delButton.triggered.connect(self.__onDel) self.__delButton.setEnabled(False) self.__delAllButton = QAction(PixmapCache().getIcon('bpdelall.png'), "Delete all the breakpoint", self) self.__delAllButton.triggered.connect(self.__onDelAll) self.__delAllButton.setEnabled(False) # Toolbar self.toolbar = QToolBar() self.toolbar.setOrientation(Qt.Horizontal) self.toolbar.setMovable(False) self.toolbar.setAllowedAreas(Qt.TopToolBarArea) self.toolbar.setIconSize(QSize(16, 16)) self.toolbar.setFixedHeight(28) self.toolbar.setContentsMargins(0, 0, 0, 0) self.toolbar.addAction(self.__editButton) self.toolbar.addAction(self.__jumpToCodeButton) fixedSpacer2 = QWidget() fixedSpacer2.setFixedWidth(5) self.toolbar.addWidget(fixedSpacer2) self.toolbar.addAction(self.__enableButton) self.toolbar.addAction(self.__enableAllButton) fixedSpacer3 = QWidget() fixedSpacer3.setFixedWidth(5) self.toolbar.addWidget(fixedSpacer3) self.toolbar.addAction(self.__disableButton) self.toolbar.addAction(self.__disableAllButton) expandingSpacer = QWidget() expandingSpacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) fixedSpacer4 = QWidget() fixedSpacer4.setFixedWidth(5) self.toolbar.addWidget(fixedSpacer4) self.toolbar.addWidget(expandingSpacer) self.toolbar.addAction(self.__delButton) fixedSpacer5 = QWidget() fixedSpacer5.setFixedWidth(5) self.toolbar.addWidget(fixedSpacer5) self.toolbar.addAction(self.__delAllButton) verticalLayout.addWidget(self.headerFrame) verticalLayout.addWidget(self.toolbar) verticalLayout.addWidget(self.bpointsList) return def clear(self): " Clears the content " self.__onDelAll() self.__updateBreakpointsLabel() self.__currentItem = None return def __updateBreakpointsLabel(self): " Updates the breakpoints header label " enableCount, \ disableCount = self.bpointsList.model().sourceModel().getCounts() total = enableCount + disableCount if total > 0: self.__breakpointLabel.setText("Breakpoints (total: " + str(total) + ")") else: self.__breakpointLabel.setText("Breakpoints") return def __onProjectChanged(self, what): " Triggered when a project is changed " if what != CodimensionProject.CompleteProject: return self.clear() model = self.bpointsList.model().sourceModel() project = GlobalData().project if project.isLoaded(): bpoints = project.breakpoints else: bpoints = Settings().breakpoints for bp in bpoints: newBpoint = Breakpoint() try: if not newBpoint.deserialize(bp): # Non valid continue except: continue # Need to check if it still points to a breakable line line = newBpoint.getLineNumber() fileName = newBpoint.getAbsoluteFileName() breakableLines = getBreakpointLines(fileName, None, True) if breakableLines is not None and line in breakableLines: model.addBreakpoint(newBpoint) else: logging.warning("Breakpoint at " + fileName + ":" + str(line) + " does not point to a breakable " "line anymore (the file is invalid or was " "modified outside of the " "IDE etc.). The breakpoint is deleted.") return def __onProjectAboutToUnload(self): " Triggered before the project is unloaded " self.__serializeBreakpoints() return def __serializeBreakpoints(self): " Saves the breakpoints into a file " model = self.bpointsList.model().sourceModel() project = GlobalData().project if project.isLoaded(): project.setBreakpoints(model.serialize()) else: Settings().breakpoints = model.serialize() return def __onSelectionChanged(self, index): " Triggered when the current item is changed " if index is None: self.__currentItem = None else: srcModel = self.bpointsList.model().sourceModel() sindex = self.bpointsList.toSourceIndex(index) self.__currentItem = srcModel.getBreakPointByIndex(sindex) self.__updateButtons() return def __updateButtons(self): " Updates the buttons status " enableCount, \ disableCount = self.bpointsList.model().sourceModel().getCounts() if self.__currentItem is None: self.__editButton.setEnabled(False) self.__enableButton.setEnabled(False) self.__disableButton.setEnabled(False) self.__jumpToCodeButton.setEnabled(False) self.__delButton.setEnabled(False) else: self.__editButton.setEnabled(True) self.__enableButton.setEnabled(not self.__currentItem.isEnabled()) self.__disableButton.setEnabled(self.__currentItem.isEnabled()) self.__jumpToCodeButton.setEnabled(True) self.__delButton.setEnabled(True) self.__enableAllButton.setEnabled(disableCount > 0) self.__disableAllButton.setEnabled(enableCount > 0) self.__delAllButton.setEnabled(enableCount + disableCount > 0) return def __onEnableDisable(self): " Triggered when a breakpoint should be enabled/disabled " if self.__currentItem is None: return if self.__currentItem.isEnabled(): self.bpointsList.disableBreak() else: self.bpointsList.enableBreak() return def __onEdit(self): " Triggered when a breakpoint should be edited " if self.__currentItem is None: return dlg = BreakpointEditDialog(self.__currentItem) if dlg.exec_() == QDialog.Accepted: newBpoint = dlg.getData() if newBpoint == self.__currentItem: return model = self.bpointsList.model().sourceModel() index = model.getBreakPointIndex( self.__currentItem.getAbsoluteFileName(), self.__currentItem.getLineNumber()) model.setBreakPointByIndex(index, newBpoint) self.bpointsList.layoutDisplay() return def __onJumpToCode(self): " Triggered when should jump to source " if self.__currentItem is None: return self.bpointsList.jumpToCode(self.__currentItem.getAbsoluteFileName(), self.__currentItem.getLineNumber()) return def __onEnableAll(self): " Triggered when all the breakpoints should be enabled " self.bpointsList.enableAllBreaks() return def __onDisableAll(self): " Triggered when all the breakpoints should be disabled " self.bpointsList.disableAllBreaks() return def __onDel(self): " Triggered when a breakpoint should be deleted " if self.__currentItem is None: return self.bpointsList.deleteBreak() return def __onDelAll(self): " Triggered when all the breakpoints should be deleted " self.bpointsList.deleteAllBreaks() return def __onModelChanged(self): " Triggered when something has changed in any of the breakpoints " self.__updateBreakpointsLabel() self.__updateButtons() self.bpointsList.layoutDisplay() self.__serializeBreakpoints() return
class GeometryCopier: def __init__(self, iface): # Save reference to the QGIS interface self.iface = iface # initialize plugin directory self.plugin_dir = QFileInfo(QgsApplication.qgisUserDbFilePath()).path( ) + "/python/plugins/geometry_copier" # initialize locale locale_path = "" if sip.getapi("QVariant") > 1: # new API style locale = QSettings().value("locale/userLocale")[0:2] else: # the old API style locale = QSettings().value("locale/userLocale").toString()[0:2] if QFileInfo(self.plugin_dir).exists(): locale_path = self.plugin_dir + "/i18n/geometry_copier_" + locale + ".qm" if QFileInfo(locale_path).exists(): self.translator = QTranslator() self.translator.load(locale_path) if qVersion() > '4.3.3': QCoreApplication.installTranslator(self.translator) self._geom_buffer = None def initGui(self): # Create action that will start plugin configuration self.copy_action = QAction( QIcon(':/plugins/geometrycopier/mActionEditCopyGeom.png'), self.tr(u"Copy geometry"), self.iface.mainWindow()) self.insert_action = QAction( QIcon(':/plugins/geometrycopier/mActionEditPasteGeom.png'), self.tr(u"Insert geometry"), self.iface.mainWindow()) # connect the action to the run method QObject.connect(self.copy_action, SIGNAL("triggered()"), self.copy_geometry) QObject.connect(self.insert_action, SIGNAL("triggered()"), self.insert_geometry) # Add hotkeys self.iface.registerMainWindowAction(self.copy_action, "F7") self.iface.registerMainWindowAction(self.insert_action, "F8") # Add toolbar button and menu item self.iface.digitizeToolBar().addAction(self.copy_action) self.iface.digitizeToolBar().addAction(self.insert_action) self.iface.addPluginToVectorMenu(u"&Geometry copier", self.copy_action) self.iface.addPluginToVectorMenu(u"&Geometry copier", self.insert_action) # Add global signals QObject.connect(self.iface, SIGNAL('currentLayerChanged(QgsMapLayer *)'), self.check_buttons_state) QObject.connect(self.iface.mapCanvas(), SIGNAL('selectionChanged(QgsMapLayer *)'), self.check_buttons_state) QObject.connect(self.iface.actionToggleEditing(), SIGNAL('triggered()'), self.check_buttons_state) #iface.actionToggleEditing().triggered # init state self.check_buttons_state(None) def unload(self): self.iface.unregisterMainWindowAction(self.copy_action) self.iface.unregisterMainWindowAction(self.insert_action) self.iface.removePluginVectorMenu(u"&Geometry copier", self.copy_action) self.iface.removePluginVectorMenu(u"&Geometry copier", self.insert_action) self.iface.digitizeToolBar().removeAction(self.copy_action) self.iface.digitizeToolBar().removeAction(self.insert_action) QObject.disconnect(self.iface, SIGNAL('currentLayerChanged(QgsMapLayer *)'), self.check_buttons_state) QObject.disconnect(self.iface.mapCanvas(), SIGNAL('selectionChanged(QgsMapLayer *)'), self.check_buttons_state) QObject.disconnect(self.iface.actionToggleEditing(), SIGNAL('triggered()'), self.check_buttons_state) def check_buttons_state(self, layer=None): layer = self.iface.activeLayer() if not isinstance(layer, QgsVectorLayer): self.copy_action.setDisabled(True) self.insert_action.setDisabled(True) return sel_feat_count = layer.selectedFeatureCount() if sel_feat_count != 1: self.copy_action.setDisabled(True) self.insert_action.setDisabled(True) return self.copy_action.setEnabled(True) # copy button can be pressed! if not layer.isEditable( ) or not self._geom_buffer or self._geom_buffer.type( ) != layer.geometryType(): self.insert_action.setDisabled(True) return self.insert_action.setEnabled( True) # insert button can be pressed! (type geom??) def copy_geometry(self): layer = self.iface.activeLayer() if not isinstance(layer, QgsVectorLayer): QMessageBox.information( None, self.tr('Geometry was not copied'), self.tr('Select any vector layer and feature!')) return sel_feat_count = layer.selectedFeatureCount() if sel_feat_count != 1: QMessageBox.information(None, self.tr('Geometry was not copied'), self.tr('Select one feature!')) return feature = layer.selectedFeatures()[0] self._geom_buffer = QgsGeometry(feature.geometry()) self.check_buttons_state() def insert_geometry(self): layer = self.iface.activeLayer() if not isinstance(layer, QgsVectorLayer): QMessageBox.information( None, self.tr('Geometry can\'t be inserted'), self.tr( 'Select any vector layer and feature for inserting geom!')) return if not self._geom_buffer: QMessageBox.information(None, self.tr('Geometry can\'t be inserted'), self.tr('Buffer is empty!')) return if not layer.isEditable(): QMessageBox.critical(None, self.tr('Geometry can\'t be inserted'), self.tr('Layer is not editable!')) return if self._geom_buffer.type() != layer.geometryType( ): # and layer.geometryType() != 2: QMessageBox.critical( None, self.tr('Geometry can\'t be inserted'), self.tr('Target layer has other geometry type!')) return sel_feat_count = layer.selectedFeatureCount() if sel_feat_count != 1: QMessageBox.critical( None, self.tr('Geometry can\'t be inserted'), self.tr('Select one feature for inserting geom!')) return feature = layer.selectedFeatures()[0] layer.changeGeometry(feature.id(), QgsGeometry(self._geom_buffer)) self.iface.mapCanvas().refresh() def tr(self, text): return QCoreApplication.translate('GeometryCopier', text)
def add_action( self, name, icon_path, text, callback, toggle_flag=False, enabled_flag=True, checkable_flag=False, visible_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 name: Objectname of the action. Serves also as key for the stored actions. :type name: str :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 toggle_flag: A flag indicating if the action should connect the toggled or triggered signal by default. Defaults to triggered (False) :type toggle_flag: bool :param checkable_flag: A flag indicating if the action should be checkable by default. Defaults to False. :type checkable: bool :param visible_flag: A flag indicating if the action should be displayed by default. Defaults to True. :type visible: 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.setObjectName(name) if toggle_flag: action.toggled.connect(callback) else: action.triggered.connect(callback) action.setEnabled(enabled_flag) action.setCheckable(checkable_flag) action.setVisible(visible_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[name] = action return action
class VariableEditor(QWidget): """An editor widget for a variable. Can edit the variable name, and its attributes dictionary. """ variable_changed = Signal() def __init__(self, parent=None): QWidget.__init__(self, parent) self.setup_gui() def setup_gui(self): layout = QVBoxLayout() self.setLayout(layout) self.main_form = QFormLayout() self.main_form.setFieldGrowthPolicy(QFormLayout.AllNonFixedFieldsGrow) layout.addLayout(self.main_form) self._setup_gui_name() self._setup_gui_labels() def _setup_gui_name(self): self.name_edit = QLineEdit() self.main_form.addRow("Name:", self.name_edit) self.name_edit.editingFinished.connect(self.on_name_changed) def _setup_gui_labels(self): vlayout = QVBoxLayout() vlayout.setContentsMargins(0, 0, 0, 0) vlayout.setSpacing(1) self.labels_edit = QTreeView() self.labels_edit.setEditTriggers(QTreeView.CurrentChanged) self.labels_edit.setRootIsDecorated(False) self.labels_model = DictItemsModel() self.labels_edit.setModel(self.labels_model) self.labels_edit.selectionModel().selectionChanged.connect( self.on_label_selection_changed) # Necessary signals to know when the labels change self.labels_model.dataChanged.connect(self.on_labels_changed) self.labels_model.rowsInserted.connect(self.on_labels_changed) self.labels_model.rowsRemoved.connect(self.on_labels_changed) vlayout.addWidget(self.labels_edit) hlayout = QHBoxLayout() hlayout.setContentsMargins(0, 0, 0, 0) hlayout.setSpacing(1) self.add_label_action = QAction("+", self, toolTip="Add a new label.", triggered=self.on_add_label, enabled=False, shortcut=QKeySequence( QKeySequence.New)) self.remove_label_action = QAction(unicodedata.lookup("MINUS SIGN"), self, toolTip="Remove selected label.", triggered=self.on_remove_label, enabled=False, shortcut=QKeySequence( QKeySequence.Delete)) button_size = gui.toolButtonSizeHint() button_size = QSize(button_size, button_size) button = QToolButton(self) button.setFixedSize(button_size) button.setDefaultAction(self.add_label_action) hlayout.addWidget(button) button = QToolButton(self) button.setFixedSize(button_size) button.setDefaultAction(self.remove_label_action) hlayout.addWidget(button) hlayout.addStretch(10) vlayout.addLayout(hlayout) self.main_form.addRow("Labels:", vlayout) def set_data(self, var): """Set the variable to edit. """ self.clear() self.var = var if var is not None: self.name_edit.setText(var.name) self.labels_model.set_dict(dict(var.attributes)) self.add_label_action.setEnabled(True) else: self.add_label_action.setEnabled(False) self.remove_label_action.setEnabled(False) def get_data(self): """Retrieve the modified variable. """ name = str(self.name_edit.text()) labels = self.labels_model.get_dict() # Is the variable actually changed. if not self.is_same(): var = type(self.var)(name) var.attributes.update(labels) self.var = var else: var = self.var return var def is_same(self): """Is the current model state the same as the input. """ name = str(self.name_edit.text()) labels = self.labels_model.get_dict() return self.var and name == self.var.name and labels == self.var.attributes def clear(self): """Clear the editor state. """ self.var = None self.name_edit.setText("") self.labels_model.set_dict({}) def maybe_commit(self): if not self.is_same(): self.commit() def commit(self): """Emit a ``variable_changed()`` signal. """ self.variable_changed.emit() @Slot() def on_name_changed(self): self.maybe_commit() @Slot() def on_labels_changed(self, *args): self.maybe_commit() @Slot() def on_add_label(self): self.labels_model.appendRow([QStandardItem(""), QStandardItem("")]) row = self.labels_model.rowCount() - 1 index = self.labels_model.index(row, 0) self.labels_edit.edit(index) @Slot() def on_remove_label(self): rows = self.labels_edit.selectionModel().selectedRows() if rows: row = rows[0] self.labels_model.removeRow(row.row()) @Slot() def on_label_selection_changed(self): selected = self.labels_edit.selectionModel().selectedRows() self.remove_label_action.setEnabled(bool(len(selected)))
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 = VectorTileBulderDialog() 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 FindInFilesViewer(QWidget): " Find in files viewer tab widget " lastEntered = None def __init__(self, parent=None): QWidget.__init__(self, parent) global searchTooltip searchTooltip = Tooltip() self.__reportRegexp = None self.__reportResults = [] self.__reportShown = False self.__bufferChangeconnected = False # Prepare members for reuse self.__noneLabel = QLabel("\nNo results available") self.__noneLabel.setFrameShape(QFrame.StyledPanel) self.__noneLabel.setAlignment(Qt.AlignHCenter) self.__headerFont = self.__noneLabel.font() self.__headerFont.setPointSize(self.__headerFont.pointSize() + 4) self.__noneLabel.setFont(self.__headerFont) self.__noneLabel.setAutoFillBackground(True) noneLabelPalette = self.__noneLabel.palette() noneLabelPalette.setColor(QPalette.Background, GlobalData().skin.nolexerPaper) self.__noneLabel.setPalette(noneLabelPalette) # Keep pylint happy self.printButton = None self.clearButton = None self.printPreviewButton = None self.__createLayout(parent) self.__updateButtonsStatus() GlobalData().project.projectChanged.connect(self.__onProjectChanged) return def __createLayout(self, parent): " Creates the toolbar and layout " # Buttons self.printButton = QAction(PixmapCache().getIcon('printer.png'), 'Print', self) #printButton.setShortcut( 'Ctrl+' ) self.printButton.triggered.connect(self.__onPrint) self.printButton.setVisible(False) self.printPreviewButton = QAction( PixmapCache().getIcon('printpreview.png'), 'Print preview', self) #printPreviewButton.setShortcut( 'Ctrl+' ) self.printPreviewButton.triggered.connect(self.__onPrintPreview) self.printPreviewButton.setVisible(False) spacer = QWidget() spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self.clearButton = QAction(PixmapCache().getIcon('trash.png'), 'Clear', self) self.clearButton.triggered.connect(self.__clear) # The toolbar self.toolbar = QToolBar(self) self.toolbar.setOrientation(Qt.Vertical) self.toolbar.setMovable(False) self.toolbar.setAllowedAreas(Qt.RightToolBarArea) self.toolbar.setIconSize(QSize(16, 16)) self.toolbar.setFixedWidth(28) self.toolbar.setContentsMargins(0, 0, 0, 0) self.toolbar.addAction(self.printPreviewButton) self.toolbar.addAction(self.printButton) self.toolbar.addWidget(spacer) self.toolbar.addAction(self.clearButton) self.__resultsTree = FindResultsTreeWidget() self.__resultsTree.setAlternatingRowColors(True) self.__resultsTree.setRootIsDecorated(True) self.__resultsTree.setItemsExpandable(True) self.__resultsTree.setUniformRowHeights(True) self.__resultsTree.setItemDelegate(NoOutlineHeightDelegate(4)) headerLabels = ["File name / line", "Text"] self.__resultsTree.setHeaderLabels(headerLabels) self.__resultsTree.itemActivated.connect(self.__resultActivated) self.__resultsTree.itemClicked.connect(self.__resultClicked) self.__resultsTree.setMouseTracking(True) self.__resultsTree.itemEntered.connect(self.__itemEntered) self.__resultsTree.hide() self.__hLayout = QHBoxLayout() self.__hLayout.setContentsMargins(0, 0, 0, 0) self.__hLayout.setSpacing(0) self.__hLayout.addWidget(self.toolbar) self.__hLayout.addWidget(self.__noneLabel) self.__hLayout.addWidget(self.__resultsTree) self.setLayout(self.__hLayout) return def getResultsTree(self): " Provides a reference to the results tree " return self.__resultsTree def __updateButtonsStatus(self): " Updates the buttons status " self.printButton.setEnabled(self.__reportShown) self.printPreviewButton.setEnabled(self.__reportShown) self.clearButton.setEnabled(self.__reportShown) return def __onPrint(self): " Triggered when the print button is pressed " pass def __onPrintPreview(self): " triggered when the print preview button is pressed " pass def setFocus(self): " Overridden setFocus " self.__hLayout.setFocus() return def __onProjectChanged(self, what): " Triggered when a project is changed " if what == CodimensionProject.CompleteProject: self.__clear() return def __clear(self): " Clears the content of the vertical layout " if not self.__reportShown: return # Disconnect the buffer change signal if it is connected if self.__bufferChangeconnected: self.__bufferChangeconnected = False mainWindow = GlobalData().mainWindow editorsManager = mainWindow.editorsManagerWidget.editorsManager editorsManager.bufferModified.disconnect( self.__resultsTree.onBufferModified) self.__resultsTree.resetCache() self.__resultsTree.clear() self.__resultsTree.hide() self.__noneLabel.show() self.__reportRegexp = None self.__reportResults = [] self.__reportShown = False self.__updateButtonsStatus() return def showReport(self, regexp, results): " Shows the find in files results " self.__clear() self.__noneLabel.hide() self.__reportRegexp = regexp self.__reportResults = results # Add the complete information totalMatched = 0 for item in results: matched = len(item.matches) totalMatched += matched if matched == 1: matchText = " (1 match)" else: matchText = " (" + str(matched) + " matches)" columns = [item.fileName, matchText] fileItem = MatchTableFileItem(columns, item.bufferUUID) fileItem.setIcon(0, getFileIcon(detectFileType(item.fileName))) if item.tooltip != "": fileItem.setToolTip(0, item.tooltip) self.__resultsTree.addTopLevelItem(fileItem) # Matches for match in item.matches: columns = [str(match.line), match.text] matchItem = MatchTableItem(columns, match.tooltip) fileItem.addChild(matchItem) fileItem.setExpanded(True) # Update the header with the total number of matches headerLabels = [ "File name / line (total files: " + str(len(results)) + ")", "Text (total matches: " + str(totalMatched) + ")" ] self.__resultsTree.setHeaderLabels(headerLabels) # Resizing the table self.__resultsTree.header().resizeSections( QHeaderView.ResizeToContents) # Show the complete information self.__resultsTree.show() self.__resultsTree.buildCache() self.__reportShown = True self.__updateButtonsStatus() # Connect the buffer change signal if not connected yet if not self.__bufferChangeconnected: self.__bufferChangeconnected = True mainWindow = GlobalData().mainWindow editorsManager = mainWindow.editorsManagerWidget.editorsManager editorsManager.bufferModified.connect( self.__resultsTree.onBufferModified) return def __resultClicked(self, item, column): " Handles the single click " hideSearchTooltip() return def __resultActivated(self, item, column): " Handles the double click (or Enter) on a match " if type(item) == MatchTableItem: fileName = str(item.parent().data(0, Qt.DisplayRole).toString()) lineNumber = int(item.data(0, Qt.DisplayRole).toString()) GlobalData().mainWindow.openFile(fileName, lineNumber) hideSearchTooltip() return def __itemEntered(self, item, column): " Triggered when the mouse cursor entered a row " if type(item) != MatchTableItem: self.lastEntered = item hideSearchTooltip() return if column != 1: # Show the tooltip only for the column with results self.lastEntered = None hideSearchTooltip() return # Memorize the row height for proper tooltip displaying later global cellHeight cellHeight = self.__resultsTree.visualItemRect(item).height() if self.lastEntered != item or not inside: item.itemEntered() self.lastEntered = item return
class LogViewer(QWidget): """ The log (+stdout, +stderr) viewer widget """ def __init__(self, parent=None): QWidget.__init__(self, parent) self.__isEmpty = True self.__copyAvailable = False self.clearButton = None self.messages = None self.copyButton = None self.selectAllButton = None self.__createLayout(parent) # create the context menu self.__menu = QMenu(self) self.__selectAllMenuItem = self.__menu.addAction( PixmapCache().getIcon('selectall.png'), 'Select All', self.messages.selectAll) self.__copyMenuItem = self.__menu.addAction( PixmapCache().getIcon('copytoclipboard.png'), 'Copy', self.messages.copy) self.__menu.addSeparator() self.__clearMenuItem = self.__menu.addAction( PixmapCache().getIcon('trash.png'), 'Clear', self.__clear) self.messages.setContextMenuPolicy(Qt.CustomContextMenu) self.messages.customContextMenuRequested.connect( self.__handleShowContextMenu) self.messages.copyAvailable.connect(self.__onCopyAvailable) self.cNormalFormat = self.messages.currentCharFormat() self.cErrorFormat = self.messages.currentCharFormat() self.cErrorFormat.setForeground(QBrush(QColor(Qt.red))) self.__updateToolbarButtons() return def __createLayout(self, parent): " Helper to create the viewer layout " # Messages list area self.messages = QPlainTextEdit(parent) self.messages.setLineWrapMode(QPlainTextEdit.NoWrap) self.messages.setFont(QFont(GlobalData().skin.baseMonoFontFace)) self.messages.setReadOnly(True) self.messages.setMaximumBlockCount(MAX_LINES) # Default font size is good enough for most of the systems. # 12.0 might be good only in case of the XServer on PC (Xming). # self.messages.setFontPointSize( 12.0 ) # Buttons self.selectAllButton = QAction(PixmapCache().getIcon('selectall.png'), 'Select all', self) self.selectAllButton.triggered.connect(self.messages.selectAll) self.copyButton = QAction(PixmapCache().getIcon('copytoclipboard.png'), 'Copy to clipboard', self) self.copyButton.triggered.connect(self.messages.copy) spacer = QWidget() spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self.clearButton = QAction(PixmapCache().getIcon('trash.png'), 'Clear all', self) self.clearButton.triggered.connect(self.__clear) # Toolbar self.toolbar = QToolBar() self.toolbar.setOrientation(Qt.Vertical) self.toolbar.setMovable(False) self.toolbar.setAllowedAreas(Qt.LeftToolBarArea) self.toolbar.setIconSize(QSize(16, 16)) self.toolbar.setFixedWidth(28) self.toolbar.setContentsMargins(0, 0, 0, 0) self.toolbar.addAction(self.selectAllButton) self.toolbar.addAction(self.copyButton) self.toolbar.addWidget(spacer) self.toolbar.addAction(self.clearButton) # layout layout = QHBoxLayout() layout.setContentsMargins(0, 0, 0, 0) layout.setSpacing(0) layout.addWidget(self.toolbar) layout.addWidget(self.messages) self.setLayout(layout) return def __handleShowContextMenu(self, coord): """ Show the context menu """ self.__selectAllMenuItem.setEnabled(not self.__isEmpty) self.__copyMenuItem.setEnabled(self.__copyAvailable) self.__clearMenuItem.setEnabled(not self.__isEmpty) self.__menu.popup(QCursor.pos()) return def __appendText(self, txt, isError): " Append the text " if len(txt) == 0: return self.__isEmpty = False cursor = self.messages.textCursor() cursor.movePosition(QTextCursor.End) self.messages.setTextCursor(cursor) if isError: self.messages.setCurrentCharFormat(self.cErrorFormat) else: self.messages.setCurrentCharFormat(self.cNormalFormat) self.messages.insertPlainText(txt) self.messages.insertPlainText('\n') self.messages.ensureCursorVisible() self.__updateToolbarButtons() return def appendMessage(self, txt): " Append the regular message " self.__appendText(txt, False) #QApplication.processEvents() return def appendError(self, txt): " Append the error message " self.__appendText(txt, True) #QApplication.processEvents() return def append(self, txt): " Decides what the message is - error or not - and append it then " if txt.startswith( 'CRITICAL' ) or \ txt.startswith( 'ERROR' ) or \ txt.startswith( 'WARNING' ): self.appendError(txt) else: self.appendMessage(txt) return def __updateToolbarButtons(self): " Contextually updates toolbar buttons " self.selectAllButton.setEnabled(not self.__isEmpty) self.copyButton.setEnabled(self.__copyAvailable) self.clearButton.setEnabled(not self.__isEmpty) return def __clear(self): " Triggers when the clear function is selected " self.__isEmpty = True self.__copyAvailable = False self.messages.clear() self.__updateToolbarButtons() return def __onCopyAvailable(self, isAvailable): " Triggers on the copyAvailable signal " self.__copyAvailable = isAvailable self.__updateToolbarButtons() return def getText(self): " Provides the content as a plain text " return self.messages.toPlainText()
def add_action(self, icon_name, 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_name: Name of the icon for this action. Its a normal file ui/resources. :type icon_name: 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 = GeogigPackageCreatorDialog() icon = QIcon( os.path.join(os.path.dirname(__file__), "ui", "resources", os.path.basename(icon_name))) 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.addPluginToDatabaseMenu(self.menu, action) self.actions.append(action) return action
class DocumentViewManager(QMainWindow): """ MDI area for displaying supporting documents within a given context e.g. supporting documents for a specific household based on the lifetime of the 'SourceDocumentManager' instance. """ def __init__(self, parent=None): QMainWindow.__init__(self, parent) self.setWindowFlags(Qt.Window) self._mdi_area = QMdiArea() self._mdi_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded) self._mdi_area.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded) self.setCentralWidget(self._mdi_area) # set the size of mid_area and DocumentViewManager based on the # screen size. screen = QDesktopWidget().availableGeometry() self._mdi_area.resize(screen.width() - 30, screen.height() - 80) self.resize(self._mdi_area.size()) self._mdi_area.subWindowActivated.connect(self.update_actions) self._viewer_mapper = QSignalMapper(self) self._viewer_mapper.mapped[QWidget].connect(self.set_active_sub_window) win_title = QApplication.translate("DocumentViewManager", "Document Viewer") self.setWindowTitle(win_title) self.setUnifiedTitleAndToolBarOnMac(True) self.statusBar().showMessage( QApplication.translate("DocumentViewManager", "Ready")) self._doc_viewers = {} self._create_menu_actions() self.update_actions() def center(self): """ Move the Document viewer to the center of the screen. """ # Get the current screens' dimensions... screen = QDesktopWidget().availableGeometry() # ... and get this windows' dimensions mdi_area_size = self.frameGeometry() # The horizontal position hpos = (screen.width() - mdi_area_size.width()) / 2 # vertical position vpos = (screen.height() - mdi_area_size.height()) / 2 # repositions the window self.move(hpos, vpos) def _create_menu_actions(self): self._window_menu = self.menuBar().addMenu( QApplication.translate("DocumentViewManager", "&Windows")) self._close_act = QAction( QApplication.translate("DocumentViewManager", "Cl&ose"), self) self._close_act.setStatusTip( QApplication.translate("DocumentViewManager", "Close the active document viewer")) self._close_act.triggered.connect(self._mdi_area.closeActiveSubWindow) self._close_all_act = QAction( QApplication.translate("DocumentViewManager", "Close &All"), self) self._close_all_act.setStatusTip( QApplication.translate("DocumentViewManager", "Close all the document viewers")) self._close_all_act.triggered.connect( self._mdi_area.closeAllSubWindows) self._tile_act = QAction( QApplication.translate("DocumentViewManager", "&Tile"), self) self._tile_act.setStatusTip( QApplication.translate("DocumentViewManager", "Tile the document viewers")) self._tile_act.triggered.connect(self.tile_windows) self._cascade_act = QAction( QApplication.translate("DocumentViewManager", "&Cascade"), self) self._cascade_act.setStatusTip( QApplication.translate("DocumentViewManager", "Cascade the document viewers")) self._cascade_act.triggered.connect(self.cascade_windows) self._next_act = QAction( QApplication.translate("DocumentViewManager", "Ne&xt"), self) self._next_act.setStatusTip( QApplication.translate( "DocumentViewManager", "Move the focus to the next document viewer")) self._next_act.triggered.connect(self._mdi_area.activateNextSubWindow) self._previous_act = QAction( QApplication.translate("DocumentViewManager", "Pre&vious"), self) self._previous_act.setStatusTip( QApplication.translate( "DocumentViewManager", "Move the focus to the previous document viewer")) self._previous_act.triggered.connect( self._mdi_area.activatePreviousSubWindow) self._separator_act = QAction(self) self._separator_act.setSeparator(True) self.update_window_menu() self._window_menu.aboutToShow.connect(self.update_window_menu) def cascade_windows(self): #Cascade document windows self._mdi_area.cascadeSubWindows() def tile_windows(self): #Arrange document windows to occupy the available space in mdi area self._mdi_area.tileSubWindows() def update_actions(self): if self._mdi_area.activeSubWindow(): has_mdi_child = True else: has_mdi_child = False self._close_act.setEnabled(has_mdi_child) self._close_all_act.setEnabled(has_mdi_child) self._tile_act.setEnabled(has_mdi_child) self._cascade_act.setEnabled(has_mdi_child) self._previous_act.setEnabled(has_mdi_child) self._next_act.setEnabled(has_mdi_child) self._separator_act.setVisible(has_mdi_child) def update_window_menu(self): self._window_menu.clear() self._window_menu.addAction(self._close_act) self._window_menu.addAction(self._close_all_act) self._window_menu.addSeparator() self._window_menu.addAction(self._tile_act) self._window_menu.addAction(self._cascade_act) self._window_menu.addSeparator() self._window_menu.addAction(self._next_act) self._window_menu.addAction(self._previous_act) self._window_menu.addAction(self._separator_act) windows = self._mdi_area.subWindowList() self._separator_act.setVisible(len(windows) != 0) for i, window in enumerate(windows): text = "%d. %s" % (i + 1, window.windowTitle()) win_action = self._window_menu.addAction(text) win_action.setCheckable(True) win_action.setChecked(window is self._mdi_area.activeSubWindow()) win_action.triggered.connect(self._viewer_mapper.map) self._viewer_mapper.setMapping(win_action, window) def load_viewer(self, document_widget, visible=True): """ Open a new instance of the viewer or activate an existing one if the document had been previously loaded. :param document_widget: Contains all the necessary information required to load the specific document. :type document_widget: DocumentWidget :param visible: True to show the view manager after the viewer has been loaded, otherwise it will be the responsibility of the caller to enable visibility. :type visible: bool :returns: True if the document was successfully loaded, else False. :rtype: bool """ doc_identifier = document_widget.file_identifier() if doc_identifier in self._doc_viewers: doc_sw = self._doc_viewers[doc_identifier] self._mdi_area.setActiveSubWindow(doc_sw) doc_sw.showNormal() else: doc_viewer = self._create_viewer(document_widget) abs_doc_path = self.absolute_document_path(document_widget) if not QFile.exists(abs_doc_path): msg = QApplication.translate( "DocumentViewManager", "The selected document does not exist." "\nPlease check the supporting documents' " "repository setting.") QMessageBox.critical( self, QApplication.translate("DocumentViewManager", "Invalid Document"), msg) return False doc_viewer.load_document(abs_doc_path) self._doc_viewers[doc_identifier] = doc_viewer self._mdi_area.addSubWindow(doc_viewer) doc_viewer.show() if not self.isVisible() and visible: self.setVisible(True) if self.isMinimized(): self.showNormal() self.center() return True def set_active_sub_window(self, viewer): if viewer: self._mdi_area.setActiveSubWindow(viewer) def absolute_document_path(self, document_widget): """ Build the absolute document path using info from the document widget. :param document_widget: Instance of document widget. :return: Absolute path of the supporting document. :rtype: str """ abs_path = '' file_manager = document_widget.fileManager if not file_manager is None: network_repository = file_manager.networkPath file_id = document_widget.file_identifier() source_entity = document_widget.doc_source_entity() profile_name = current_profile().name doc_type = document_widget.doc_type_value().lower().replace( ' ', '_') file_name, file_extension = guess_extension( document_widget.displayName()) abs_path = network_repository + "/" +profile_name + '/' +\ unicode(source_entity) + "/" + unicode(doc_type) + "/" +\ unicode(file_id) + unicode(file_extension) return abs_path def reset(self): """ Removes all document viewers in the view area. The QCloseEvent sent to each sub-window will decrement the register. """ self._mdi_area.closeAllSubWindows() def _create_viewer(self, document_widget): """ Creates a new instance of a document viewer. :param document_widget: Contains all the necessary information required to load the specific document. :return: Document viewer object :rtype: DocumentViewer """ doc_viewer = DocumentViewer(self._mdi_area, document_widget.file_identifier()) doc_viewer.setAttribute(Qt.WA_DeleteOnClose) doc_viewer.setWindowTitle(document_widget.displayName()) # TODO: Incorporate logic for determining # TODO: viewer based on document type ph_viewer = PhotoViewer() # v_layout = QVBoxLayout() # v_layout.addWidget(ph_viewer) # doc_viewer.setLayout(v_layout) doc_viewer.set_view_widget(ph_viewer) doc_viewer.closed.connect(self._on_viewer_closed) return doc_viewer def remove_viewer(self, viewer_id): """ Close and remove the viewer with the specified viewer ID. """ if viewer_id in self._doc_viewers: viewer = self._doc_viewers[viewer_id] self._mdi_area.setActiveSubWindow(viewer) self._mdi_area.closeActiveSubWindow() self._on_viewer_closed(viewer_id) def _on_viewer_closed(self, file_id): """ Slot raised when a document viewer is closed. """ if file_id in self._doc_viewers: del self._doc_viewers[file_id]
class PhotoViewer(QScrollArea): """ Widget for viewing images by incorporating basic navigation options. """ def __init__(self, parent=None, photo_path=""): QScrollArea.__init__(self, parent) self.setBackgroundRole(QPalette.Dark) self._printer = QPrinter() self._lbl_photo = QLabel() self._lbl_photo.setBackgroundRole(QPalette.Base) self._lbl_photo.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored) self._lbl_photo.setScaledContents(True) self.setWidget(self._lbl_photo) self._photo_path = photo_path self._ph_image = None self._scale_factor = 1.0 self._aspect_ratio = -1 self._create_actions() if self._photo_path: self.load_document(self._photo_path) def _create_actions(self): """ Create actions for basic image navigation. """ self._zoom_in_act = QAction( QApplication.translate("PhotoViewer", "Zoom &In (25%)"), self) self._zoom_in_act.setShortcut( QApplication.translate("PhotoViewer", "Ctrl++")) self._zoom_in_act.setEnabled(False) self._zoom_in_act.triggered.connect(self.zoom_in) self._zoom_out_act = QAction( QApplication.translate("PhotoViewer", "Zoom &Out (25%)"), self) self._zoom_out_act.setShortcut( QApplication.translate("PhotoViewer", "Ctrl+-")) self._zoom_out_act.setEnabled(False) self._zoom_out_act.triggered.connect(self.zoom_out) self._normal_size_act = QAction( QApplication.translate("PhotoViewer", "&Normal Size"), self) self._normal_size_act.setShortcut( QApplication.translate("PhotoViewer", "Ctrl+S")) self._normal_size_act.setEnabled(False) self._normal_size_act.triggered.connect(self.normal_size) self._fit_to_window_act = QAction( QApplication.translate("PhotoViewer", "&Fit to Window"), self) self._fit_to_window_act.setShortcut( QApplication.translate("PhotoViewer", "Ctrl+F")) self._fit_to_window_act.setEnabled(False) self._fit_to_window_act.setCheckable(True) self._fit_to_window_act.triggered.connect(self.fit_to_window) self._print_act = QAction( QApplication.translate("PhotoViewer", "&Print"), self) self._print_act.setShortcut( QApplication.translate("PhotoViewer", "Ctrl+P")) self._print_act.setEnabled(False) self._print_act.triggered.connect(self.print_photo) def zoom_in(self): self.scale_photo(1.25) def zoom_out(self): self.scale_photo(0.8) def normal_size(self): self._lbl_photo.adjustSize() self._scale_factor = 1.0 def fit_to_window(self): fit_to_win = self._fit_to_window_act.isChecked() self.setWidgetResizable(fit_to_win) if not fit_to_win: self.normal_size() self.update_actions() def print_photo(self): print_dialog = QPrintDialog(self._printer, self) if print_dialog.exec_() == QDialog.Accepted: painter = QPainter(self._printer) rect = painter.viewport() size = self._lbl_photo.pixmap().size() size.scale(rect.size(), Qt.KeepAspectRatio) painter.setViewport(rect.x(), rect.y(), size.width(), size.height()) painter.setWindow(self._lbl_photo.pixmap().rect()) painter.drawPixmap(0, 0, self._lbl_photo.pixmap()) def wheelEvent(self, event): """ Zoom the image based on the mouse wheel rotation action. :param event: Event containing the wheel rotation info. :type event: QWheelEvent """ degrees = event.delta() / 8 num_steps = degrees / 15 if num_steps < 0: abs_num_steps = abs(num_steps) zoom_factor = 1 + (abs_num_steps * 0.25) else: zoom_factor = 1 - (num_steps * 0.2) self.scale_photo(zoom_factor) def heightForWidth(self, width): if self._aspect_ratio != -1: return width / self._aspect_ratio else: return -1 def resizeEvent(self, event): """ Event for resizing the widget based on the pixmap's aspect ratio. :param event: Contains event parameters for the resize event. :type event: QResizeEvent """ super(PhotoViewer, self).resizeEvent(event) def update_actions(self): self._zoom_out_act.setEnabled(not self._fit_to_window_act.isChecked()) self._zoom_in_act.setEnabled(not self._fit_to_window_act.isChecked()) self._normal_size_act.setEnabled( not self._fit_to_window_act.isChecked()) def scale_photo(self, factor): """ :param factor: Value by which the image will be increased/decreased in the view. :type factor: float """ if not self._lbl_photo.pixmap().isNull(): self._scale_factor *= factor self._lbl_photo.resize(self._scale_factor * self._lbl_photo.pixmap().size()) self._adjust_scroll_bar(self.horizontalScrollBar(), factor) self._adjust_scroll_bar(self.verticalScrollBar(), factor) self._zoom_in_act.setEnabled(self._scale_factor < 3.0) self._zoom_out_act.setEnabled(self._scale_factor > 0.333) def _adjust_scroll_bar(self, scroll_bar, factor): scroll_bar.setValue( int(factor * scroll_bar.value() + ((factor - 1) * scroll_bar.pageStep() / 2))) def load_document(self, photo_path): if photo_path: self._ph_image = QImage(photo_path) if self._ph_image.isNull(): return False self._photo_path = photo_path ph_pixmap = QPixmap.fromImage(self._ph_image) self._lbl_photo.setPixmap(ph_pixmap) self._scale_factor = 1.0 self._aspect_ratio = ph_pixmap.width() / ph_pixmap.height() self._fit_to_window_act.setEnabled(True) self._print_act.setEnabled(True) self._fit_to_window_act.trigger() self.update_actions() return ph_pixmap return True def photo_location(self): """ :returns: Absolute path of the photo in the central document repository. """ return self._photo_path def set_actions(self, menu): """ Add custom actions to the sub-window menu """ menu.addSeparator() menu.addAction(self._zoom_in_act) menu.addAction(self._zoom_out_act) menu.addAction(self._normal_size_act) menu.addAction(self._fit_to_window_act) menu.addSeparator() menu.addAction(self._print_act)
class VCSAnnotateViewerTabWidget(QWidget, MainWindowTabWidgetBase): " VCS annotate viewer tab widget " textEditorZoom = pyqtSignal(int) escapePressed = pyqtSignal() def __init__(self, parent): MainWindowTabWidgetBase.__init__(self) QWidget.__init__(self, parent) self.__viewer = VCSAnnotateViewer(self) self.__viewer.escapePressed.connect(self.__onEsc) self.__fileName = "" self.__shortName = "" self.__fileType = UnknownFileType self.__createLayout() self.__viewer.zoomTo(Settings().zoom) return def __onEsc(self): " Triggered when Esc is pressed " self.escapePressed.emit() return def __createLayout(self): " Creates the toolbar and layout " # Buttons printButton = QAction(PixmapCache().getIcon('printer.png'), 'Print', self) printButton.triggered.connect(self.__onPrint) printButton.setEnabled(False) printButton.setVisible(False) printPreviewButton = QAction(PixmapCache().getIcon('printpreview.png'), 'Print preview', self) printPreviewButton.triggered.connect(self.__onPrintPreview) printPreviewButton.setEnabled(False) printPreviewButton.setVisible(False) spacer = QWidget() spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self.lineCounterButton = QAction( PixmapCache().getIcon('linecounter.png'), 'Line counter', self) self.lineCounterButton.triggered.connect(self.onLineCounter) # The toolbar toolbar = QToolBar(self) toolbar.setOrientation(Qt.Vertical) toolbar.setMovable(False) toolbar.setAllowedAreas(Qt.RightToolBarArea) toolbar.setIconSize(QSize(16, 16)) toolbar.setFixedWidth(28) toolbar.setContentsMargins(0, 0, 0, 0) toolbar.addAction(printPreviewButton) toolbar.addAction(printButton) toolbar.addWidget(spacer) toolbar.addAction(self.lineCounterButton) self.__importsBar = ImportListWidget(self.__viewer) self.__importsBar.hide() hLayout = QHBoxLayout() hLayout.setContentsMargins(0, 0, 0, 0) hLayout.setSpacing(0) hLayout.addWidget(self.__viewer) hLayout.addWidget(toolbar) self.setLayout(hLayout) return def updateStatus(self): " Updates the toolbar buttons status " if self.__fileType == UnknownFileType: self.__fileType = self.getFileType() isPythonFile = self.__fileType in [PythonFileType, Python3FileType] self.lineCounterButton.setEnabled(isPythonFile) return def onZoomReset(self): " Triggered when the zoom reset button is pressed " if self.__viewer.zoom != 0: self.textEditorZoom.emit(0) return True def onZoomIn(self): " Triggered when the zoom in button is pressed " if self.__viewer.zoom < 20: self.textEditorZoom.emit(self.__viewer.zoom + 1) return True def onZoomOut(self): " Triggered when the zoom out button is pressed " if self.__viewer.zoom > -10: self.textEditorZoom.emit(self.__viewer.zoom - 1) return True def __onPrint(self): " Triggered when the print button is pressed " pass def __onPrintPreview(self): " triggered when the print preview button is pressed " pass def onLineCounter(self): " Triggered when line counter button is clicked " LineCounterDialog(None, self.__viewer).exec_() return def setFocus(self): " Overridden setFocus " self.__viewer.setFocus() return def onOpenImport(self): " Triggered when Ctrl+I is received " if self.__fileType not in [PythonFileType, Python3FileType]: return True # Python file, we may continue importLine, lineNo = isImportLine(self.__viewer) basePath = os.path.dirname(self.__fileName) if importLine: lineImports, importWhat = getImportsInLine(self.__viewer.text(), lineNo + 1) currentWord = str(self.__viewer.getCurrentWord(".")) if currentWord in lineImports: # The cursor is on some import path = resolveImport(basePath, currentWord) if path != '': GlobalData().mainWindow.openFile(path, -1) return True GlobalData().mainWindow.showStatusBarMessage( "The import '" + currentWord + "' is not resolved.", 0) return True # We are not on a certain import. # Check if it is a line with exactly one import if len(lineImports) == 1: path = resolveImport(basePath, lineImports[0]) if path == '': GlobalData().mainWindow.showStatusBarMessage( "The import '" + lineImports[0] + "' is not resolved.", 0) return True # The import is resolved. Check where we are. if currentWord in importWhat: # We are on a certain imported name in a resolved import # So, jump to the definition line line = getImportedNameDefinitionLine(path, currentWord) GlobalData().mainWindow.openFile(path, line) return True GlobalData().mainWindow.openFile(path, -1) return True # Take all the imports in the line and resolve them. self.__onImportList(basePath, lineImports) return True # Here: the cursor is not on the import line. Take all the file imports # and resolve them fileImports = getImportsList(self.__viewer.text()) if not fileImports: GlobalData().mainWindow.showStatusBarMessage( "There are no imports.", 0) return True if len(fileImports) == 1: path = resolveImport(basePath, fileImports[0]) if path == '': GlobalData().mainWindow.showStatusBarMessage( "The import '" + fileImports[0] + "' is not resolved.", 0) return True GlobalData().mainWindow.openFile(path, -1) return True self.__onImportList(basePath, fileImports) return True def __onImportList(self, basePath, imports): " Works with a list of imports " # It has already been checked that the file is a Python one resolvedList = resolveImports(basePath, imports) if not resolvedList: GlobalData().mainWindow.showStatusBarMessage( "No imports are resolved.", 0) return # Display the import selection widget self.__importsBar.showResolvedList(resolvedList) return def resizeEvent(self, event): " Resizes the import selection dialogue if necessary " QWidget.resizeEvent(self, event) self.resizeBars() return def resizeBars(self): " Resize the bars if they are shown " if not self.__importsBar.isHidden(): self.__importsBar.resize() self.__viewer.resizeCalltip() return def onPylint(self): return True def onPymetrics(self): return True def onRunScript(self, action=False): return True def onRunScriptSettings(self): return True def onProfileScript(self, action=False): return True def onProfileScriptSettings(self): return True def onImportDgm(self, action=None): return True def onImportDgmTuned(self): return True def shouldAcceptFocus(self): return True def setAnnotatedContent(self, shortName, text, lineRevisions, revisionInfo): " Sets the content " self.setShortName(shortName) self.__viewer.setAnnotatedContent(shortName, text, lineRevisions, revisionInfo) return def writeFile(self, fileName): " Writes the text to a file " return self.__viewer.writeFile(fileName) def updateModificationTime(self, fileName): return # Mandatory interface part is below def getEditor(self): " Provides the editor widget " return self.__viewer def isModified(self): " Tells if the file is modified " return False def getRWMode(self): " Tells if the file is read only " return "RO" def getFileType(self): " Provides the file type " if self.__fileType == UnknownFileType: if self.__shortName: self.__fileType = detectFileType(self.__shortName) return self.__fileType def setFileType(self, typeToSet): """ Sets the file type explicitly. It needs e.g. for .cgi files which can change its type """ self.__fileType = typeToSet return def getType(self): " Tells the widget type " return MainWindowTabWidgetBase.VCSAnnotateViewer def getLanguage(self): " Tells the content language " if self.__fileType == UnknownFileType: self.__fileType = self.getFileType() if self.__fileType != UnknownFileType: return getFileLanguage(self.__fileType) return self.__viewer.getLanguage() def getFileName(self): " Tells what file name of the widget content " return "n/a" def setFileName(self, name): " Sets the file name " raise Exception( "Setting a file name for annotate results is not applicable") def getEol(self): " Tells the EOL style " return self.__viewer.getEolIndicator() def getLine(self): " Tells the cursor line " line, pos = self.__viewer.getCursorPosition() return int(line) def getPos(self): " Tells the cursor column " line, pos = self.__viewer.getCursorPosition() return int(pos) def getEncoding(self): " Tells the content encoding " return self.__viewer.encoding def setEncoding(self, newEncoding): " Sets the new editor encoding " self.__viewer.setEncoding(newEncoding) return def getShortName(self): " Tells the display name " return self.__shortName def setShortName(self, name): " Sets the display name " self.__shortName = name self.__fileType = detectFileType(name) return
class QgsAttributeTableDialog(QDialog): ''' classdocs ''' def __init__(self, parent, vectorlayer): QDialog.__init__(self, parent) # self.w = QDialog(self) self.baseLayer = vectorlayer self.canChangeAttributes = self.validate( QgsVectorDataProvider.ChangeAttributeValues) self.canDeleteFeatures = self.validate( QgsVectorDataProvider.DeleteFeatures) self.canAddAttributes = self.validate( QgsVectorDataProvider.AddAttributes) self.canDeleteAttributes = self.validate( QgsVectorDataProvider.DeleteAttributes) self.canAddFeatures = self.validate(QgsVectorDataProvider.AddFeatures) gridLayout = QGridLayout(self) self.setLayout(gridLayout) self.setWindowTitle("Attribute Table") self.setFixedSize(QSize(800, 600)) editorToolbar = QToolBar() editorToolbar.setFixedSize(QSize(768, 48)) self.actionToggleEditing = QAction(QIcon("Resource\\edit.png"), "ToggleEditing", self) self.actionToggleEditing.triggered.connect(self.toggleEditing) if (self.canChangeAttributes or self.canDeleteFeatures or self.canAddAttributes or self.canDeleteAttributes or self.canAddFeatures) and (not self.baseLayer.isReadOnly()): self.actionToggleEditing.setEnabled(True) else: self.actionToggleEditing.setEnabled(False) self.actionToggleEditing.setCheckable(True) editorToolbar.addAction(self.actionToggleEditing) self.actionSave = QAction(QIcon("Resource\\filesave.png"), "Save Edits", self) self.actionSave.triggered.connect(self.saveEditing) self.actionSave.setCheckable(False) self.actionSave.setEnabled(False) editorToolbar.addAction(self.actionSave) self.actiondeleteRows = QAction( QIcon("Resource\\mActionDeleteSelected.png"), "Delete selected features", self) self.actiondeleteRows.triggered.connect(self.deleteRows) self.actiondeleteRows.setCheckable(False) self.actiondeleteRows.setEnabled(False) editorToolbar.addAction(self.actiondeleteRows) self.actionUnselectAll = QAction( QIcon("Resource\\mActionDeselectAll.png"), "Unselect All", self) self.actionUnselectAll.triggered.connect(self.unselectAll) self.actionUnselectAll.setCheckable(False) self.actionUnselectAll.setEnabled(True) editorToolbar.addAction(self.actionUnselectAll) self.actionSelectedToZoom = QAction( QIcon("Resource\\mActionZoomToSelected.png"), "Zoom map to the selected rows", self) self.actionSelectedToZoom.triggered.connect(self.selectedToZoom) self.actionSelectedToZoom.setCheckable(False) self.actionSelectedToZoom.setEnabled(True) editorToolbar.addAction(self.actionSelectedToZoom) gridLayout.addWidget(editorToolbar, 0, 0, 1, 1) self.model = QStandardItemModel() # self.model.itemChanged.connect(self.attributeChanged) self.attributeTable = QTableView(self) self.attributeTable.setModel(self.model) self.attributeTable.setColumnWidth(0, 200) self.attributeTable.setColumnWidth(1, 160) self.attributeTable.clicked.connect(self.tableSelectionChanged) self.attributeTable.setSortingEnabled(True) self.changeItemList = [] self.selectRows = [] self.isSave = True self.initTable() gridLayout.addWidget(self.attributeTable, 1, 0, 1, 1) # self.attributeTable.selectionChanged.connect(self.selectFeature) def tableSelectionChanged(self): idxList = self.attributeTable.selectedIndexes() if idxList != None and len(idxList) > 0: self.baseLayer.removeSelection() fidList = [] for idx in idxList: fid = int(self.model.item(idx.row()).text()) fidList.append(fid) self.baseLayer.setSelectedFeatures(fidList) def toggleEditing(self): if self.baseLayer != None: if not self.actionToggleEditing.isChecked(): if self.isSave: self.baseLayer.commitChanges() self.actionSave.setEnabled(False) self.actiondeleteRows.setEnabled(False) self.model.itemChanged.disconnect(self.attributeChanged) self.toggleEditingTable(False) else: button = QMessageBox.warning( self, "Stop Editing", "Do you want to save the changes to layer?", QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel) if (button == QMessageBox.Cancel): self.actionToggleEditing.setChecked(True) elif button == QMessageBox.Save: self.saveEditing() self.baseLayer.commitChanges() self.actionSave.setEnabled(False) self.actiondeleteRows.setEnabled(False) self.model.itemChanged.disconnect( self.attributeChanged) self.toggleEditingTable(False) else: self.initTable() self.baseLayer.commitChanges() self.actionSave.setEnabled(False) self.actiondeleteRows.setEnabled(False) self.model.itemChanged.disconnect( self.attributeChanged) self.toggleEditingTable(False) # self.isEditable = False else: self.actionSave.setEnabled(True) self.actiondeleteRows.setEnabled(True) self.baseLayer.startEditing() self.toggleEditingTable(True) self.model.itemChanged.connect(self.attributeChanged) # self.isEditable = True def toggleEditingTable(self, isEditable): columnCount = self.model.columnCount() rowCount = self.model.rowCount() col = 0 while col < columnCount: row = 0 while row < rowCount: self.model.item(row, col).setEditable(isEditable) row += 1 col += 1 def attributeChanged(self, standardItem): self.isSave = False # if not self.isDelete: self.changeItemList.append(standardItem) # featureId = standardItem.row() # self.baseLayer.changeAttributeValue(featureId, # standardItem.column(), standardItem.text()) def saveEditing(self): self.isSave = True if len(self.changeItemList) > 0: for standardItem in self.changeItemList: featureId = standardItem.row() self.baseLayer.changeAttributeValue(featureId, standardItem.column(), standardItem.text()) self.changeItemList = [] if len(self.selectRows) > 0: for id in self.selectRows: self.baseLayer.deleteFeature(id) self.selectRows = [] def initTable(self): self.model.clear() # header = QHeaderView(Qt.Horizontal) # headerModel = QStandardItemModel() layer = self.baseLayer fields = layer.pendingFields() headersList = ["fid"] for field in fields: headersList.append(field.name()) self.model.setHorizontalHeaderLabels(headersList) # headerModel.setHorizontalHeaderLabels(headersList) # header.setModel(headerModel) # self.attributeTable.setHorizontalHeader(header) if len(layer.selectedFeatures()) > 0: features = layer.selectedFeatures() else: features = layer.getFeatures() for feature in features: record = [QStandardItem(str(feature.id()))] for field in feature.fields(): name = field.name() attribute = feature.attribute(name).toString() stdItemValue = QStandardItem(attribute) stdItemValue.setEditable(False) record.append(stdItemValue) self.model.appendRow(record) def deleteRows(self): if len(self.attributeTable.selectedIndexes()) > 0: self.isSave = False selectedIndexs = self.attributeTable.selectedIndexes() k = -1 self.selectRows = [] for index in selectedIndexs: if k != index.row(): k = index.row() self.selectRows.append(k) for row in self.selectRows: self.model.takeRow(row) def unselectAll(self): if len(self.attributeTable.selectedIndexes()) > 0: self.attributeTable.clearSelection() def selectedToZoom(self): if len(self.attributeTable.selectedIndexes()) > 0: self.baseLayer.removeSelection() selectedIndexs = self.attributeTable.selectedIndexes() k = -1 self.selectRows = [] for index in selectedIndexs: if k != index.row(): k = index.row() self.selectRows.append(k) self.baseLayer.setSelectedFeatures(self.selectRows) # for row in self.selectRows: # self.model.takeRow(row) define._canvas.zoomToSelected(self.baseLayer) def validate(self, condition): if self.baseLayer.dataProvider().capabilities() & condition: return True else: return False
def createuiaction(self): action = QAction(QIcon(self.icon), self.icontext, None) if not self.valid[0]: action.setEnabled(False) action.setText(action.text() + " (invalid)") return action
class ImageView(QWidget, Script): def __init__(self): Script.__init__(self, "viewerimage") self.type = "imageview" self.icon = None self.vfs = vfs.vfs() self.reg_viewer = re.compile( ".*(JPEG|JPG|jpg|jpeg|GIF|gif|bmp|png|PNG|pbm|PBM|pgm|PGM|ppm|PPM|xpm|XPM|xbm|XBM|TIFF|tiff).*", re.IGNORECASE) self.sceneWidth = 0 def start(self, args): try: self.preview = args["preview"].value() except IndexError: self.preview = False try: self.node = args["file"].value() self.curIdx = self.node.at() except KeyError: pass def isImage(self, node): if node.size() != 0: try: type = node.dataType() except (IndexError, AttributeError, IOError): return False if self.reg_viewer.search(str(type)): return True return False def next(self): listNodes = self.node.parent().children() newIdx = self.curIdx + 1 if newIdx >= len(listNodes): newIdx = 0 while newIdx != self.curIdx: if self.isImage(listNodes[newIdx]): break newIdx += 1 if newIdx >= len(listNodes): newIdx = 0 self.curIdx = newIdx self.setImage(listNodes[self.curIdx]) def previous(self): listNodes = self.node.parent().children() newIdx = self.curIdx - 1 if newIdx < 0: newIdx = len(listNodes) - 1 while newIdx != self.curIdx: if self.isImage(listNodes[newIdx]): break newIdx -= 1 if newIdx < 0: newIdx = len(listNodes) - 1 self.curIdx = newIdx self.setImage(listNodes[self.curIdx]) def createActions(self): self.actions = QToolBar() self.actions.setObjectName("Image viewer actions") self.nextButton = QAction(QIcon(":next.png"), "Display next image", self.actions) self.previousButton = QAction(QIcon(":previous.png"), "Display previous image", self.actions) self.rotlButton = QAction(QIcon(":rotate-left.png"), "Rotate the image 90 degrees to the left", self.actions) self.rotrButton = QAction(QIcon(":rotate-right.png"), "Rotate the image 90 degrees to the right", self.actions) self.enlargeButton = QAction(QIcon(":viewmag+"), "Enlarge the image", self.actions) self.shrinkButton = QAction(QIcon(":viewmag-"), "Shrink the image", self.actions) self.fitButton = QAction(QIcon(":viewmagfit"), "Fit the image to the window", self.actions) self.normalButton = QAction(QIcon(":viewmag1"), "Show the image at its normal size", self.actions) self.actions.addAction(self.previousButton) self.actions.addAction(self.nextButton) self.actions.addAction(self.rotlButton) self.actions.addAction(self.rotrButton) self.actions.addAction(self.enlargeButton) self.actions.addAction(self.shrinkButton) self.actions.addAction(self.fitButton) self.actions.addAction(self.normalButton) self.connect(self.loadedImage, SIGNAL("available(bool)"), self.enableActions) self.connect(self.previousButton, SIGNAL("triggered()"), self.previous) self.connect(self.nextButton, SIGNAL("triggered()"), self.next) self.connect(self.rotlButton, SIGNAL("triggered()"), self.loadedImage.rotateLeft) self.connect(self.rotrButton, SIGNAL("triggered()"), self.loadedImage.rotateRight) self.connect(self.enlargeButton, SIGNAL("triggered()"), self.loadedImage.enlarge) self.connect(self.shrinkButton, SIGNAL("triggered()"), self.loadedImage.shrink) self.connect(self.fitButton, SIGNAL("triggered()"), self.loadedImage.fit) self.connect(self.normalButton, SIGNAL("triggered()"), self.loadedImage.normal) def enableActions(self, cond): self.rotlButton.setEnabled(cond) self.rotrButton.setEnabled(cond) self.enlargeButton.setEnabled(cond) self.shrinkButton.setEnabled(cond) self.fitButton.setEnabled(cond) self.normalButton.setEnabled(cond) def setImage(self, node): if not self.preview: self.imagelabel.clear() self.imagelabel.insert(QString.fromUtf8(node.absolute())) self.metadata.process(node) self.loadedImage.load(node) def g_display(self): QWidget.__init__(self, None) self.factor = 1 self.box = QHBoxLayout() self.setLayout(self.box) self.imagebox = QVBoxLayout() self.scrollArea = QScrollArea() self.loadedImage = LoadedImage(self.scrollArea) self.scrollArea.setWidget(self.loadedImage) self.scrollArea.setAlignment(Qt.AlignCenter) if not self.preview: self.createActions() self.imagelabelbox = QVBoxLayout() self.imagelabelbox.setSpacing(0) self.imagelabel = QLineEdit() self.imagelabelbox.addWidget(self.imagelabel) self.imagelabel.setReadOnly(True) self.imagebox.addWidget(self.actions) self.imagebox.addWidget(self.scrollArea) if not self.preview: self.imagebox.setAlignment(self.actions, Qt.AlignCenter) self.imagebox.addLayout(self.imagelabelbox) self.databox = QVBoxLayout() self.metadata = Metadata() self.databox.addWidget(self.metadata) if len(self.node.parent().children()) < 2: self.nextButton.setEnabled(False) self.previousButton.setEnabled(False) self.box.addLayout(self.imagebox) if not self.preview: self.box.addLayout(self.databox) self.setImage(self.node.parent().children()[self.curIdx]) def updateWidget(self): if not self.preview: self.metadata.setMaximumSize(self.width() / 4, self.height()) self.loadedImage.adjust() def resizeEvent(self, e): if not self.preview: self.metadata.setMaximumSize(self.width() / 4, self.height()) self.loadedImage.adjust()
class ProfileResultsWidget(QWidget, MainWindowTabWidgetBase): " Profiling results widget " escapePressed = pyqtSignal() def __init__(self, scriptName, params, reportTime, dataFile, parent=None): MainWindowTabWidgetBase.__init__(self) QWidget.__init__(self, parent) # The same stats object is needed for both - a table and a graph # So, parse profile output once and then pass the object further stats = pstats.Stats(dataFile) stats.calc_callees() self.__profTable = ProfileTableViewer(scriptName, params, reportTime, dataFile, stats, self) self.__profGraph = ProfileGraphViewer(scriptName, params, reportTime, dataFile, stats, self) self.__profTable.hide() self.__profTable.escapePressed.connect(self.__onEsc) self.__profGraph.escapePressed.connect(self.__onEsc) self.__createLayout() return def __createLayout(self): " Creates the toolbar and layout " # Buttons self.__toggleViewButton = QAction( PixmapCache().getIcon('tableview.png'), 'Switch to table view', self) self.__toggleViewButton.setCheckable(True) self.__toggleViewButton.toggled.connect(self.__switchView) self.__togglePathButton = QAction( PixmapCache().getIcon('longpath.png'), 'Show full paths for item location', self) self.__togglePathButton.setCheckable(True) self.__togglePathButton.toggled.connect(self.__togglePath) self.__togglePathButton.setEnabled(False) self.__printButton = QAction(PixmapCache().getIcon('printer.png'), 'Print', self) self.__printButton.triggered.connect(self.__onPrint) self.__printButton.setEnabled(False) self.__printPreviewButton = QAction( PixmapCache().getIcon('printpreview.png'), 'Print preview', self) self.__printPreviewButton.triggered.connect(self.__onPrintPreview) self.__printPreviewButton.setEnabled(False) fixedSpacer = QWidget() fixedSpacer.setFixedHeight(16) self.__zoomInButton = QAction(PixmapCache().getIcon('zoomin.png'), 'Zoom in (Ctrl+=)', self) self.__zoomInButton.setShortcut('Ctrl+=') self.__zoomInButton.triggered.connect(self.onZoomIn) self.__zoomOutButton = QAction(PixmapCache().getIcon('zoomout.png'), 'Zoom out (Ctrl+-)', self) self.__zoomOutButton.setShortcut('Ctrl+-') self.__zoomOutButton.triggered.connect(self.onZoomOut) self.__zoomResetButton = QAction( PixmapCache().getIcon('zoomreset.png'), 'Zoom reset (Ctrl+0)', self) self.__zoomResetButton.setShortcut('Ctrl+0') self.__zoomResetButton.triggered.connect(self.onZoomReset) # Toolbar toolbar = QToolBar(self) toolbar.setOrientation(Qt.Vertical) toolbar.setMovable(False) toolbar.setAllowedAreas(Qt.RightToolBarArea) toolbar.setIconSize(QSize(16, 16)) toolbar.setFixedWidth(28) toolbar.setContentsMargins(0, 0, 0, 0) toolbar.addAction(self.__toggleViewButton) toolbar.addAction(self.__togglePathButton) toolbar.addAction(self.__printPreviewButton) toolbar.addAction(self.__printButton) toolbar.addWidget(fixedSpacer) toolbar.addAction(self.__zoomInButton) toolbar.addAction(self.__zoomOutButton) toolbar.addAction(self.__zoomResetButton) hLayout = QHBoxLayout() hLayout.setContentsMargins(0, 0, 0, 0) hLayout.setSpacing(0) hLayout.addWidget(self.__profTable) hLayout.addWidget(self.__profGraph) hLayout.addWidget(toolbar) self.setLayout(hLayout) return def setFocus(self): " Overriden setFocus " if self.__profTable.isVisible(): self.__profTable.setFocus() else: self.__profGraph.setFocus() return def __onEsc(self): " Triggered when Esc is pressed " self.escapePressed.emit() return def __switchView(self, state): " Triggered when view is to be switched " if state: self.__profGraph.hide() self.__profTable.show() self.__toggleViewButton.setIcon( PixmapCache().getIcon('profdgmview.png')) self.__toggleViewButton.setToolTip('Switch to diagram view') self.__zoomInButton.setEnabled(False) self.__zoomOutButton.setEnabled(False) self.__zoomResetButton.setEnabled(False) self.__togglePathButton.setEnabled(True) self.__profTable.setFocus() else: self.__profTable.hide() self.__profGraph.show() self.__toggleViewButton.setIcon( PixmapCache().getIcon('tableview.png')) self.__toggleViewButton.setToolTip('Switch to table view') self.__zoomInButton.setEnabled(True) self.__zoomOutButton.setEnabled(True) self.__zoomResetButton.setEnabled(True) self.__togglePathButton.setEnabled(False) self.__profGraph.setFocus() return def __togglePath(self, state): " Triggered when full path/file name is switched " self.__profTable.togglePath(state) if state: self.__togglePathButton.setIcon( PixmapCache().getIcon('shortpath.png')) self.__togglePathButton.setToolTip( 'Show file names only for item location') else: self.__togglePathButton.setIcon( PixmapCache().getIcon('longpath.png')) self.__togglePathButton.setToolTip( 'Show full paths for item location') return def __onPrint(self): " Triggered on the 'print' button " pass def __onPrintPreview(self): " Triggered on the 'print preview' button " pass def isZoomApplicable(self): " Should the zoom menu items be available " return self.__profGraph.isVisible() def onZoomIn(self): " Triggered on the 'zoom in' button " if self.__profGraph.isVisible(): self.__profGraph.zoomIn() return def onZoomOut(self): " Triggered on the 'zoom out' button " if self.__profGraph.isVisible(): self.__profGraph.zoomOut() return def onZoomReset(self): " Triggered on the 'zoom reset' button " if self.__profGraph.isVisible(): self.__profGraph.resetZoom() return def isCopyAvailable(self): " Tells id the main menu copy item should be switched on " return self.__profGraph.isVisible() def isDiagramActive(self): " Tells if the diagram is active " return self.__profGraph.isVisible() def onCopy(self): " Ctrl+C triggered " if self.__profGraph.isVisible(): self.__profGraph.onCopy() return def onSaveAs(self, fileName): " Saves the diagram into a file " if self.__profGraph.isVisible(): self.__profGraph.onSaveAs(fileName) else: self.__profTable.onSaveAs(fileName) return # Mandatory interface part is below def isModified(self): " Tells if the file is modified " return False def getRWMode(self): " Tells if the file is read only " return "RO" def getType(self): " Tells the widget type " return MainWindowTabWidgetBase.ProfileViewer def getLanguage(self): " Tells the content language " return "Profiler" def getFileName(self): " Tells what file name of the widget content " return "N/A" def setFileName(self, name): " Sets the file name - not applicable" raise Exception( "Setting a file name for profile results is not applicable") def getEol(self): " Tells the EOL style " return "N/A" def getLine(self): " Tells the cursor line " return "N/A" def getPos(self): " Tells the cursor column " return "N/A" def getEncoding(self): " Tells the content encoding " return "N/A" def setEncoding(self, newEncoding): " Sets the new encoding - not applicable for the profiler results viewer " return def getShortName(self): " Tells the display name " return "Profiling results" def setShortName(self, name): " Sets the display name - not applicable " raise Exception( "Setting a file name for profiler results is not applicable")
class RunConsoleTabWidget(QWidget, MainWindowTabWidgetBase): " IO console tab widget " textEditorZoom = pyqtSignal(int) settingUpdated = pyqtSignal() def __init__(self, threadID, parent=None): MainWindowTabWidgetBase.__init__(self) QWidget.__init__(self, parent) self.__viewer = RedirectedIOConsole(self) self.connect(self.__viewer, SIGNAL('UserInput'), self.__onUserInput) self.__threadID = threadID self.__showstdin = True self.__showstdout = True self.__showstderr = True self.__createLayout() return def threadID(self): " Provides the thread ID the console linked to " return self.__threadID def __onUserInput(self, userInput): " Triggered when the user finished input in the redirected IO console " self.emit(SIGNAL('UserInput'), self.__threadID, userInput) self.__clearButton.setEnabled(True) return def __createLayout(self): " Creates the toolbar and layout " # Buttons self.__printButton = QAction(PixmapCache().getIcon('printer.png'), 'Print', self) self.__printButton.triggered.connect(self.__onPrint) self.__printButton.setEnabled(False) self.__printButton.setVisible(False) self.__printPreviewButton = QAction( PixmapCache().getIcon('printpreview.png'), 'Print preview', self) self.__printPreviewButton.triggered.connect(self.__onPrintPreview) self.__printPreviewButton.setEnabled(False) self.__printPreviewButton.setVisible(False) # self.__sendUpButton = QAction( PixmapCache().getIcon('sendioup.png'), # 'Send to Main Editing Area', self ) # self.__sendUpButton.triggered.connect( self.__sendUp ) self.__filterMenu = QMenu(self) self.__filterMenu.aboutToShow.connect(self.__filterAboutToShow) self.__filterGroup = QActionGroup(self) self.__filterShowAllAct = self.__filterMenu.addAction("Show all") self.__filterShowAllAct.setCheckable(True) self.__filterShowAllAct.setActionGroup(self.__filterGroup) self.__filterShowAllAct.triggered.connect(self.__onFilterShowAll) self.__filterShowStdoutAct = self.__filterMenu.addAction( "Show stdin and stdout") self.__filterShowStdoutAct.setCheckable(True) self.__filterShowStdoutAct.setActionGroup(self.__filterGroup) self.__filterShowStdoutAct.triggered.connect(self.__onFilterShowStdout) self.__filterShowStderrAct = self.__filterMenu.addAction( "Show stdin and stderr") self.__filterShowStderrAct.setCheckable(True) self.__filterShowStderrAct.setActionGroup(self.__filterGroup) self.__filterShowStderrAct.triggered.connect(self.__onFilterShowStderr) self.__filterButton = QToolButton(self) self.__filterButton.setIcon(PixmapCache().getIcon('iofilter.png')) self.__filterButton.setToolTip('Filtering settings') self.__filterButton.setPopupMode(QToolButton.InstantPopup) self.__filterButton.setMenu(self.__filterMenu) self.__filterButton.setFocusPolicy(Qt.NoFocus) self.__settingsMenu = QMenu(self) self.__settingsMenu.aboutToShow.connect(self.__settingsAboutToShow) self.__wrapLongLinesAct = self.__settingsMenu.addAction( "Wrap long lines") self.__wrapLongLinesAct.setCheckable(True) self.__wrapLongLinesAct.triggered.connect(self.__onWrapLongLines) self.__showEOLAct = self.__settingsMenu.addAction("Show EOL") self.__showEOLAct.setCheckable(True) self.__showEOLAct.triggered.connect(self.__onShowEOL) self.__showWhitespacesAct = self.__settingsMenu.addAction( "Show whitespaces") self.__showWhitespacesAct.setCheckable(True) self.__showWhitespacesAct.triggered.connect(self.__onShowWhitespaces) self.__autoscrollAct = self.__settingsMenu.addAction("Autoscroll") self.__autoscrollAct.setCheckable(True) self.__autoscrollAct.triggered.connect(self.__onAutoscroll) self.__showMarginAct = self.__settingsMenu.addAction( "Show timestamp margin") self.__showMarginAct.setCheckable(True) self.__showMarginAct.triggered.connect(self.__onShowMargin) self.__settingsButton = QToolButton(self) self.__settingsButton.setIcon(PixmapCache().getIcon('iosettings.png')) self.__settingsButton.setToolTip('View settings') self.__settingsButton.setPopupMode(QToolButton.InstantPopup) self.__settingsButton.setMenu(self.__settingsMenu) self.__settingsButton.setFocusPolicy(Qt.NoFocus) fixedSpacer = QWidget() fixedSpacer.setFixedHeight(8) self.__stopButton = QAction( PixmapCache().getIcon('runconsolestop.png'), 'Stop process', self) self.__stopButton.triggered.connect(self.stop) self.__stopAndCloseButton = QAction( PixmapCache().getIcon('runconsolestopclose.png'), 'Stop process and close tab', self) self.__stopAndCloseButton.triggered.connect(self.stopAndClose) spacer = QWidget() spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) self.__clearButton = QAction(PixmapCache().getIcon('trash.png'), 'Clear', self) self.__clearButton.triggered.connect(self.clear) # The toolbar toolbar = QToolBar(self) toolbar.setOrientation(Qt.Vertical) toolbar.setMovable(False) toolbar.setAllowedAreas(Qt.RightToolBarArea) toolbar.setIconSize(QSize(16, 16)) toolbar.setFixedWidth(28) toolbar.setContentsMargins(0, 0, 0, 0) # toolbar.addAction( self.__sendUpButton ) toolbar.addAction(self.__printPreviewButton) toolbar.addAction(self.__printButton) toolbar.addWidget(self.__filterButton) toolbar.addWidget(self.__settingsButton) toolbar.addWidget(fixedSpacer) toolbar.addAction(self.__stopButton) toolbar.addAction(self.__stopAndCloseButton) toolbar.addWidget(spacer) toolbar.addAction(self.__clearButton) hLayout = QHBoxLayout() hLayout.setContentsMargins(0, 0, 0, 0) hLayout.setSpacing(0) hLayout.addWidget(toolbar) hLayout.addWidget(self.__viewer) self.setLayout(hLayout) return def onZoomReset(self): " Triggered when the zoom reset button is pressed " if self.__viewer.zoom != 0: self.textEditorZoom.emit(0) return True def onZoomIn(self): " Triggered when the zoom in button is pressed " if self.__viewer.zoom < 20: self.textEditorZoom.emit(self.__viewer.zoom + 1) return True def onZoomOut(self): " Triggered when the zoom out button is pressed " if self.__viewer.zoom > -10: self.textEditorZoom.emit(self.__viewer.zoom - 1) return True def __onPrint(self): " Triggered when the print button is pressed " pass def __onPrintPreview(self): " triggered when the print preview button is pressed " pass def setFocus(self): " Overridden setFocus " self.__viewer.setFocus() return def onOpenImport(self): " Triggered when Ctrl+I is received " return True def __sendUp(self): " Triggered when requested to move the console up " return def __filterAboutToShow(self): " Triggered when filter menu is about to show " showAll = self.__showstdin and \ self.__showstdout and \ self.__showstderr onlyStdout = self.__showstdin and \ self.__showstdout and \ not self.__showstderr onlyStderr = self.__showstdin and \ not self.__showstdout and \ self.__showstderr self.__filterShowAllAct.setChecked(showAll) self.__filterShowStdoutAct.setChecked(onlyStdout) self.__filterShowStderrAct.setChecked(onlyStderr) return def __onFilterShowAll(self): " Triggered when filter show all is clicked " if self.__showstdin == True and \ self.__showstdout == True and \ self.__showstderr == True: return self.__showstdin = True self.__showstdout = True self.__showstderr = True self.__viewer.renderContent() return def __onFilterShowStdout(self): " Triggered when filter show stdout only is clicked " if self.__showstdin == True and \ self.__showstdout == True and \ self.__showstderr == False: return self.__showstdin = True self.__showstdout = True self.__showstderr = False self.__viewer.renderContent() return def __onFilterShowStderr(self): " Triggered when filter show stderr only is clicked " if self.__showstdin == True and \ self.__showstdout == False and \ self.__showstderr == True: return self.__showstdin = True self.__showstdout = False self.__showstderr = True self.__viewer.renderContent() return def __settingsAboutToShow(self): " Settings menu is about to show " self.__wrapLongLinesAct.setChecked(Settings().ioconsolelinewrap) self.__showEOLAct.setChecked(Settings().ioconsoleshoweol) self.__showWhitespacesAct.setChecked(Settings().ioconsoleshowspaces) self.__autoscrollAct.setChecked(Settings().ioconsoleautoscroll) self.__showMarginAct.setChecked(Settings().ioconsoleshowmargin) return def __onWrapLongLines(self): " Triggered when long lines setting is changed " Settings().ioconsolelinewrap = not Settings().ioconsolelinewrap self.settingUpdated.emit() return def __onShowEOL(self): " Triggered when show EOL is changed " Settings().ioconsoleshoweol = not Settings().ioconsoleshoweol self.settingUpdated.emit() return def __onShowWhitespaces(self): " Triggered when show whitespaces is changed " Settings().ioconsoleshowspaces = not Settings().ioconsoleshowspaces self.settingUpdated.emit() return def __onAutoscroll(self): " Triggered when autoscroll is changed " Settings().ioconsoleautoscroll = not Settings().ioconsoleautoscroll return def __onShowMargin(self): " Triggered when show margin is changed " Settings().ioconsoleshowmargin = not Settings().ioconsoleshowmargin self.settingUpdated.emit() return def clear(self): " Triggered when requested to clear the console " self.__viewer.clearAll() return def consoleSettingsUpdated(self): " Triggered when one of the consoles updated a common setting " if Settings().ioconsolelinewrap: self.__viewer.setWrapMode(QsciScintilla.WrapWord) else: self.__viewer.setWrapMode(QsciScintilla.WrapNone) self.__viewer.setEolVisibility(Settings().ioconsoleshoweol) if Settings().ioconsoleshowspaces: self.__viewer.setWhitespaceVisibility(QsciScintilla.WsVisible) else: self.__viewer.setWhitespaceVisibility(QsciScintilla.WsInvisible) self.__viewer.setTimestampMarginWidth() return def resizeEvent(self, event): QWidget.resizeEvent(self, event) return def onPylint(self): return True def onPymetrics(self): return True def onRunScript(self, action=False): return True def onRunScriptSettings(self): return True def onProfileScript(self, action=False): return True def onProfileScriptSettings(self): return True def onImportDgm(self, action=None): return True def onImportDgmTuned(self): return True def shouldAcceptFocus(self): return True def writeFile(self, fileName): " Writes the text to a file " return self.__viewer.writeFile(fileName) def updateModificationTime(self, fileName): return def appendIDEMessage(self, text): " Appends an IDE message " self.__viewer.appendIDEMessage(text) return def appendStdoutMessage(self, text): " Appends an stdout message " self.__viewer.appendStdoutMessage(text) return def appendStderrMessage(self, text): " Appends an stderr message " self.__viewer.appendStderrMessage(text) return def hiddenMessage(self, msg): " Returns True if the message should not be shown " if msg.msgType == IOConsoleMsg.STDERR_MESSAGE and \ not self.__showstderr: return True if msg.msgType == IOConsoleMsg.STDOUT_MESSAGE and \ not self.__showstdout: return True return False def zoomTo(self, zoomValue): " Sets the new zoom value " self.__viewer.zoomTo(zoomValue) self.__viewer.setTimestampMarginWidth() return def rawInput(self, prompt, echo): " Triggered when raw input is requested " echo = int(echo) if echo == 0: self.__viewer.inputEcho = False else: self.__viewer.inputEcho = True if prompt: self.appendStdoutMessage(prompt) self.__clearButton.setEnabled(False) self.__viewer.switchMode(self.__viewer.MODE_INPUT) return def sessionStopped(self): " Triggered when redirecting session is stopped " self.__viewer.switchMode(self.__viewer.MODE_OUTPUT) self.__clearButton.setEnabled(True) return def stop(self): " Triggered when the user requesed to stop the process " self.emit(SIGNAL('KillIOConsoleProcess'), self.__threadID) return def stopAndClose(self): " Triggered when the user requested to stop the process and close console " self.stop() self.close() return def close(self): " Triggered when the console should be closed " self.emit(SIGNAL('CloseIOConsole'), self.__threadID) return def scriptFinished(self): " Triggered when the script process finished " self.__stopButton.setEnabled(False) self.__stopAndCloseButton.setToolTip("Close tab") self.__viewer.switchMode(self.__viewer.MODE_OUTPUT) self.__clearButton.setEnabled(True) return # Mandatory interface part is below def getEditor(self): " Provides the editor widget " return self.__viewer def isModified(self): " Tells if the file is modified " return False def getRWMode(self): " Tells if the file is read only " return "IO" def getFileType(self): " Provides the file type " return TexFileType def setFileType(self, typeToSet): """ Sets the file type explicitly. It needs e.g. for .cgi files which can change its type """ raise Exception("Setting a file type is not supported by the " "IO console widget") def getType(self): " Tells the widget type " return MainWindowTabWidgetBase.IOConsole def getLanguage(self): " Tells the content language " return "IO console" def getFileName(self): " Tells what file name of the widget content " return "n/a" def setFileName(self, name): " Sets the file name " raise Exception("Setting a file name for IO console " "is not applicable") def getEol(self): " Tells the EOL style " return self.__viewer.getEolIndicator() def getLine(self): " Tells the cursor line " line, _ = self.__viewer.getCursorPosition() return int(line) def getPos(self): " Tells the cursor column " _, pos = self.__viewer.getCursorPosition() return int(pos) def getEncoding(self): " Tells the content encoding " return self.__viewer.encoding def setEncoding(self, newEncoding): " Sets the new editor encoding " raise Exception("Setting encoding is not supported by the " "IO console widget") def getShortName(self): " Tells the display name " return "IO console" def setShortName(self, name): " Sets the display name " raise Exception("Setting short name is not supported by the " "IO console widget")
class EditorRFUGeofoncier: def __init__(self, iface): # Save reference to the QGIS interface self.iface = iface self.canvas = self.iface.mapCanvas() self.map_layer_registry = QgsMapLayerRegistry.instance() # Initialize plugin directory self.plugin_dir = os.path.dirname(__file__) # Initialize locale #locale = QSettings().value(r"locale/userLocale")[0:2] #locale_path = os.path.join( # self.plugin_dir, r"i18n", r"translate_{}.qm".format(locale)) #if os.path.exists(locale_path): # self.translator = QTranslator() # self.translator.load(locale_path) # if qVersion() > r"4.3.3": # QCoreApplication.installTranslator(self.translator) self.conn = None self.rfu = None self.edge_creator = None def unload(self): # Remove the plugin menu item and icon.. self.iface.removePluginMenu(u"&Géofoncier", self.action_connector) self.iface.removeToolBarIcon(self.action_connector) def initGui(self): # Add tool bar.. self.toolbar = self.iface.addToolBar(u"Géofoncier Éditeur RFU") self.toolbar.setObjectName(r"GeofoncierRfuEditorToolBar") # Create action(s).. self.action_login = QAction(QIcon(r":/resources/btn_log_in"), u"S'identifer", self.iface.mainWindow()) self.action_login.setEnabled(True) self.action_login.setCheckable(True) self.action_connector = QAction(QIcon(r":/resources/btn_conn_rfu"), u"Connection à l'API Géofoncier", self.iface.mainWindow()) self.action_connector.setEnabled(False) self.action_connector.setCheckable(True) self.action_vtx_creator = QAction(QIcon(r":/resources/btn_add_vtx"), u"Ajouter un nœud RFU", self.iface.mainWindow()) self.action_vtx_creator.setEnabled(False) self.action_edge_creator = QAction(QIcon(r":/resources/btn_add_edge"), u"Ajouter une limite RFU", self.iface.mainWindow()) self.action_edge_creator.setEnabled(False) self.action_edge_creator.setCheckable(True) # Then add action(s) to the tool bar.. self.toolbar.addActions([ self.action_login, self.action_connector, self.action_vtx_creator, self.action_edge_creator ]) # Manage signals.. self.iface.currentLayerChanged.connect(self.on_toggled) # self.canvas.mapToolSet.connect(self.deactivate_tool) self.map_layer_registry.layersRemoved.connect(self.on_layers_removed) self.action_login.triggered.connect(self.tool_login_on_triggered) self.action_connector.triggered[bool].connect( self.tool_rfu_on_triggered) self.action_vtx_creator.triggered.connect( self.tool_vtx_creator_on_triggered) self.action_edge_creator.triggered[bool].connect( self.tool_edge_creator_on_triggered) # Initialize current layer to None (See switch_editing()).. self.current_layer = None # On iface Signals # ================ def on_toggled(self): layer = self.canvas.currentLayer() if not layer: return if layer.isEditable() and layer == self.rfu.l_vertex: self.switch_editing(layer) self.action_vtx_creator.setEnabled(True) self.action_edge_creator.setEnabled(False) QObject.connect(layer, SIGNAL(r"editingStopped()"), self.on_toggled) QObject.disconnect(layer, SIGNAL(r"editingStarted()"), self.on_toggled) elif layer.isEditable() and layer == self.rfu.l_edge: self.switch_editing(layer) self.action_vtx_creator.setEnabled(False) self.action_edge_creator.setEnabled(True) QObject.connect(layer, SIGNAL(r"editingStopped()"), self.on_toggled) QObject.disconnect(layer, SIGNAL(r"editingStarted()"), self.on_toggled) else: self.action_vtx_creator.setEnabled(False) self.action_edge_creator.setEnabled(False) QObject.connect(layer, SIGNAL(r"editingStopped()"), self.on_toggled) QObject.disconnect(layer, SIGNAL(r"editingStarted()"), self.on_toggled) def switch_editing(self, layer): old_layer = None if self.current_layer is not None: old_layer = self.current_layer QObject.disconnect( old_layer, SIGNAL(r"committedFeaturesAdded(QString, QgsFeatureList)"), self.on_committed_features_added) QObject.disconnect( old_layer, SIGNAL(r"committedFeaturesRemoved(QString, QgsFeatureIds)"), self.on_committed_features_removed) QObject.disconnect( old_layer, SIGNAL(r"attributeValueChanged(QgsFeatureId, int, QVariant)"), self.on_attribute_value_changed) QObject.disconnect( old_layer, SIGNAL(r"geometryChanged(QgsFeatureId, QgsGeometry)"), self.on_geometry_changed) self.current_layer = layer QObject.connect( layer, SIGNAL(r"committedFeaturesAdded(QString, QgsFeatureList)"), self.on_committed_features_added) QObject.connect( layer, SIGNAL(r"committedFeaturesRemoved(QString, QgsFeatureIds)"), self.on_committed_features_removed) QObject.connect( layer, SIGNAL(r"attributeValueChanged(QgsFeatureId, int, QVariant)"), self.on_attribute_value_changed) QObject.connect(layer, SIGNAL(r"geometryChanged(QgsFeatureId, QgsGeometry)"), self.on_geometry_changed) def on_committed_features_added(self, layer_id, features): self.rfu.add_features(layer_id, features) def on_committed_features_removed(self, layer_id, ft_id_list): self.rfu.remove_features(layer_id, ft_id_list) # def on_feature_added(self, fid): # feature = tools.get_feature_by_id(self.current_layer, fid) # self.rfu.add_feature(self.current_layer.id(), feature) def on_geometry_changed(self, fid, geom): feature = tools.get_feature_by_id(self.current_layer, fid) self.rfu.modify_feature(self.current_layer.id(), feature) def on_attribute_value_changed(self, fid, field_idx, value): feature = tools.get_feature_by_id(self.current_layer, fid) self.rfu.modify_feature(self.current_layer.id(), feature) # On map layer registry signals # ============================= def on_layers_removed(self, layers): self.current_layer = None # Login/logout # ============ def open_connection(self): dlg_login = GeoFoncierAPILogin() dlg_login.closed.connect(self.dlg_login_on_closed) dlg_login.opened.connect(self.dlg_login_on_opened) dlg_login.show() if not dlg_login.exec_(): return None self.conn = dlg_login.conn self.action_connector.setEnabled(True) self.iface.messageBar().pushMessage(u"Géofoncier", u"Bonjour %s %s." % (self.conn.prenom, self.conn.nom), level=QgsMessageBar.INFO, duration=6) def close_connection(self): msg = (u"Voulez-vous fermer votre session ?\n" u"Attention, toute modification sera perdue.") resp = QMessageBox.question(self.iface.mainWindow(), r"Question", msg, QMessageBox.Yes, QMessageBox.No) if resp != QMessageBox.Yes: return False # Close connection if self.rfu: self.rfu.reset() self.rfu.close() #if self.rfu.conn: # self.rfu.conn = None self.action_connector.setChecked(False) self.action_connector.setEnabled(False) self.conn = None self.iface.messageBar().pushMessage(u"Géofoncier", u"À bientôt.", level=QgsMessageBar.INFO, duration=6) # On action signals # ================= def dlg_login_on_closed(self): if self.conn == None: self.action_login.setChecked(False) def dlg_login_on_opened(self): self.action_login.setChecked(True) def tool_login_on_triggered(self, checked): if checked: self.open_connection() else: self.close_connection() def tool_rfu_on_triggered(self, checked): if checked and not self.rfu: self.rfu = RFUDockWidget(self.iface, self.canvas, self.map_layer_registry, conn=self.conn) self.rfu.setObjectName(r"RFUDockWidget") self.iface.addDockWidget(Qt.TopDockWidgetArea, self.rfu) self.rfu.closed.connect(self.rfu_on_closed) self.rfu.downloaded.connect(self.on_toggled) self.rfu.uploaded.connect(self.rfu_on_uploaded) if checked and self.rfu: self.rfu.show() if not checked: self.rfu.hide() def rfu_on_closed(self): self.action_connector.setChecked(False) def rfu_on_uploaded(self): if self.edge_creator: self.on_edge_creator_destroyed() def tool_vtx_creator_on_triggered(self): if not self.rfu.dflt_ellips_acronym: self.rfu.selected_ellips_acronym = self.rfu.dflt_ellips_acronym dlg_vtx_creator = VertexCreator( self.canvas, self.rfu.layers[0], user=self.rfu.conn.user, precision_class=self.rfu.precision_class, ellips_acronym=self.rfu.ellips_acronym, selected_ellips_acronym=self.rfu.selected_ellips_acronym, nature=self.rfu.nature, auth_creator=self.rfu.auth_creator) dlg_vtx_creator.show() if not dlg_vtx_creator.exec_(): return None def tool_edge_creator_on_triggered(self, checked=False): if not checked: self.edge_creator.close() self.edge_creator = None if checked: self.edge_creator = EdgeCreator(self.canvas, self.rfu.layers[0], self.rfu.layers[1], user=self.rfu.conn.user, auth_creator=self.rfu.auth_creator) self.edge_creator.setObjectName(r"EdgeCreatorDockWidget") self.edge_creator.destroyed.connect(self.on_edge_creator_destroyed) self.iface.addDockWidget(Qt.LeftDockWidgetArea, self.edge_creator) def on_edge_creator_destroyed(self): self.edge_creator = None return self.action_edge_creator.setChecked(False)
class OSMEditorRemoteControlPlugin: def __init__(self, iface): self.iface = iface self.action = None # noinspection PyPep8Naming def initGui(self): self.action = QAction( QIcon(join(dirname(__file__), 'icons', 'josm_icon.svg')), 'OSM Editor Remote Control', self.iface.mainWindow()) self.action.setEnabled(False) help = 'Send remote control command to OSM editor to load data at ' \ 'current map view.' self.action.setWhatsThis(help) self.action.setStatusTip(help) self.action.triggered.connect(self.run) self.iface.mapCanvas().layersChanged.connect(self.change_status) self.iface.mapCanvas().extentsChanged.connect(self.change_status) self.iface.addToolBarIcon(self.action) def unload(self): self.iface.removeToolBarIcon(self.action) def get_lon_lat_extent(self): map_canvas = self.iface.mapCanvas() extent = map_canvas.mapSettings().extent() if map_canvas.hasCrsTransformEnabled(): crs_map = map_canvas.mapSettings().destinationCrs() else: crs_map = map_canvas.currentLayer().crs() if crs_map.authid() != u'EPSG:4326': crs_4326 = QgsCoordinateReferenceSystem() crs_4326.createFromSrid(4326) return QgsCoordinateTransform(crs_map, crs_4326).transform(extent) return extent def change_status(self): if not self.iface.mapCanvas().currentLayer(): self.action.setEnabled(False) else: extent = self.get_lon_lat_extent() self.action.setEnabled( extent.width() * extent.height() < MAX_DOWNLOAD_AREA_DEG) def run(self): extent = self.get_lon_lat_extent() url = 'http://localhost:8111/load_and_zoom?' query_string = 'left=%f&right=%f&top=%f&bottom=%f' % ( extent.xMinimum(), extent.xMaximum(), extent.yMaximum(), extent.yMinimum()) url += query_string try: f = urllib.urlopen(url, proxies={}) result = f.read() f.close() if result.strip().upper() != 'OK': self.report_error('OSM reported: %s' % result) except IOError: self.report_error( 'Could not connect to the OSM editor. Is the OSM editor ' 'running?') def report_error(self, error_message): self.iface.messageBar().pushCritical( 'OSM Editor Remote Control Plugin', error_message)
class PythonConsoleWidget(QWidget): def __init__(self, parent=None): QWidget.__init__(self, parent) self.setWindowTitle(QCoreApplication.translate("PythonConsole", "Python Console")) self.settings = QSettings() self.shell = ShellScintilla(self) self.setFocusProxy(self.shell) self.shellOut = ShellOutputScintilla(self) self.tabEditorWidget = EditorTabWidget(self) ##------------ UI ------------------------------- self.splitterEditor = QSplitter(self) self.splitterEditor.setOrientation(Qt.Horizontal) self.splitterEditor.setHandleWidth(6) self.splitterEditor.setChildrenCollapsible(True) self.shellOutWidget = QWidget(self) self.shellOutWidget.setLayout(QVBoxLayout()) self.shellOutWidget.layout().setContentsMargins(0,0,0,0) self.shellOutWidget.layout().addWidget(self.shellOut) self.splitter = QSplitter(self.splitterEditor) self.splitter.setOrientation(Qt.Vertical) self.splitter.setHandleWidth(3) self.splitter.setChildrenCollapsible(False) self.splitter.addWidget(self.shellOutWidget) self.splitter.addWidget(self.shell) #self.splitterEditor.addWidget(self.tabEditorWidget) self.splitterObj = QSplitter(self.splitterEditor) self.splitterObj.setHandleWidth(3) self.splitterObj.setOrientation(Qt.Horizontal) #self.splitterObj.setSizes([0, 0]) #self.splitterObj.setStretchFactor(0, 1) self.widgetEditor = QWidget(self.splitterObj) self.widgetFind = QWidget(self) self.listClassMethod = QTreeWidget(self.splitterObj) self.listClassMethod.setColumnCount(2) objInspLabel = QCoreApplication.translate("PythonConsole", "Object Inspector") self.listClassMethod.setHeaderLabels([objInspLabel, '']) self.listClassMethod.setColumnHidden(1, True) self.listClassMethod.setAlternatingRowColors(True) #self.splitterEditor.addWidget(self.widgetEditor) #self.splitterObj.addWidget(self.listClassMethod) #self.splitterObj.addWidget(self.widgetEditor) # Hide side editor on start up self.splitterObj.hide() self.listClassMethod.hide() # Hide search widget on start up self.widgetFind.hide() sizes = self.splitter.sizes() self.splitter.setSizes(sizes) ##----------------Restore Settings------------------------------------ self.restoreSettingsConsole() ##------------------Toolbar Editor------------------------------------- ## Action for Open File openFileBt = QCoreApplication.translate("PythonConsole", "Open file") self.openFileButton = QAction(self) self.openFileButton.setCheckable(False) self.openFileButton.setEnabled(True) self.openFileButton.setIcon(QgsApplication.getThemeIcon("console/iconOpenConsole.png")) self.openFileButton.setMenuRole(QAction.PreferencesRole) self.openFileButton.setIconVisibleInMenu(True) self.openFileButton.setToolTip(openFileBt) self.openFileButton.setText(openFileBt) openExtEditorBt = QCoreApplication.translate("PythonConsole", "Open in external editor") self.openInEditorButton = QAction(self) self.openInEditorButton.setCheckable(False) self.openInEditorButton.setEnabled(True) self.openInEditorButton.setIcon(QgsApplication.getThemeIcon("console/iconShowEditorConsole.png")) self.openInEditorButton.setMenuRole(QAction.PreferencesRole) self.openInEditorButton.setIconVisibleInMenu(True) self.openInEditorButton.setToolTip(openExtEditorBt) self.openInEditorButton.setText(openExtEditorBt) ## Action for Save File saveFileBt = QCoreApplication.translate("PythonConsole", "Save") self.saveFileButton = QAction(self) self.saveFileButton.setCheckable(False) self.saveFileButton.setEnabled(False) self.saveFileButton.setIcon(QgsApplication.getThemeIcon("console/iconSaveConsole.png")) self.saveFileButton.setMenuRole(QAction.PreferencesRole) self.saveFileButton.setIconVisibleInMenu(True) self.saveFileButton.setToolTip(saveFileBt) self.saveFileButton.setText(saveFileBt) ## Action for Save File As saveAsFileBt = QCoreApplication.translate("PythonConsole", "Save As...") self.saveAsFileButton = QAction(self) self.saveAsFileButton.setCheckable(False) self.saveAsFileButton.setEnabled(True) self.saveAsFileButton.setIcon(QgsApplication.getThemeIcon("console/iconSaveAsConsole.png")) self.saveAsFileButton.setMenuRole(QAction.PreferencesRole) self.saveAsFileButton.setIconVisibleInMenu(True) self.saveAsFileButton.setToolTip(saveAsFileBt) self.saveAsFileButton.setText(saveAsFileBt) ## Action Cut cutEditorBt = QCoreApplication.translate("PythonConsole", "Cut") self.cutEditorButton = QAction(self) self.cutEditorButton.setCheckable(False) self.cutEditorButton.setEnabled(True) self.cutEditorButton.setIcon(QgsApplication.getThemeIcon("console/iconCutEditorConsole.png")) self.cutEditorButton.setMenuRole(QAction.PreferencesRole) self.cutEditorButton.setIconVisibleInMenu(True) self.cutEditorButton.setToolTip(cutEditorBt) self.cutEditorButton.setText(cutEditorBt) ## Action Copy copyEditorBt = QCoreApplication.translate("PythonConsole", "Copy") self.copyEditorButton = QAction(self) self.copyEditorButton.setCheckable(False) self.copyEditorButton.setEnabled(True) self.copyEditorButton.setIcon(QgsApplication.getThemeIcon("console/iconCopyEditorConsole.png")) self.copyEditorButton.setMenuRole(QAction.PreferencesRole) self.copyEditorButton.setIconVisibleInMenu(True) self.copyEditorButton.setToolTip(copyEditorBt) self.copyEditorButton.setText(copyEditorBt) ## Action Paste pasteEditorBt = QCoreApplication.translate("PythonConsole", "Paste") self.pasteEditorButton = QAction(self) self.pasteEditorButton.setCheckable(False) self.pasteEditorButton.setEnabled(True) self.pasteEditorButton.setIcon(QgsApplication.getThemeIcon("console/iconPasteEditorConsole.png")) self.pasteEditorButton.setMenuRole(QAction.PreferencesRole) self.pasteEditorButton.setIconVisibleInMenu(True) self.pasteEditorButton.setToolTip(pasteEditorBt) self.pasteEditorButton.setText(pasteEditorBt) ## Action Run Script (subprocess) runScriptEditorBt = QCoreApplication.translate("PythonConsole", "Run script") self.runScriptEditorButton = QAction(self) self.runScriptEditorButton.setCheckable(False) self.runScriptEditorButton.setEnabled(True) self.runScriptEditorButton.setIcon(QgsApplication.getThemeIcon("console/iconRunScriptConsole.png")) self.runScriptEditorButton.setMenuRole(QAction.PreferencesRole) self.runScriptEditorButton.setIconVisibleInMenu(True) self.runScriptEditorButton.setToolTip(runScriptEditorBt) self.runScriptEditorButton.setText(runScriptEditorBt) ## Action Run Script (subprocess) commentEditorBt = QCoreApplication.translate("PythonConsole", "Comment") self.commentEditorButton = QAction(self) self.commentEditorButton.setCheckable(False) self.commentEditorButton.setEnabled(True) self.commentEditorButton.setIcon(QgsApplication.getThemeIcon("console/iconCommentEditorConsole.png")) self.commentEditorButton.setMenuRole(QAction.PreferencesRole) self.commentEditorButton.setIconVisibleInMenu(True) self.commentEditorButton.setToolTip(commentEditorBt) self.commentEditorButton.setText(commentEditorBt) ## Action Run Script (subprocess) uncommentEditorBt = QCoreApplication.translate("PythonConsole", "Uncomment") self.uncommentEditorButton = QAction(self) self.uncommentEditorButton.setCheckable(False) self.uncommentEditorButton.setEnabled(True) self.uncommentEditorButton.setIcon(QgsApplication.getThemeIcon("console/iconUncommentEditorConsole.png")) self.uncommentEditorButton.setMenuRole(QAction.PreferencesRole) self.uncommentEditorButton.setIconVisibleInMenu(True) self.uncommentEditorButton.setToolTip(uncommentEditorBt) self.uncommentEditorButton.setText(uncommentEditorBt) ## Action for Object browser objList = QCoreApplication.translate("PythonConsole", "Object Inspector") self.objectListButton = QAction(self) self.objectListButton.setCheckable(True) self.objectListButton.setEnabled(self.settings.value("pythonConsole/enableObjectInsp", False, type=bool)) self.objectListButton.setIcon(QgsApplication.getThemeIcon("console/iconClassBrowserConsole.png")) self.objectListButton.setMenuRole(QAction.PreferencesRole) self.objectListButton.setIconVisibleInMenu(True) self.objectListButton.setToolTip(objList) self.objectListButton.setText(objList) ## Action for Find text findText = QCoreApplication.translate("PythonConsole", "Find Text") self.findTextButton = QAction(self) self.findTextButton.setCheckable(True) self.findTextButton.setEnabled(True) self.findTextButton.setIcon(QgsApplication.getThemeIcon("console/iconSearchEditorConsole.png")) self.findTextButton.setMenuRole(QAction.PreferencesRole) self.findTextButton.setIconVisibleInMenu(True) self.findTextButton.setToolTip(findText) self.findTextButton.setText(findText) ##----------------Toolbar Console------------------------------------- ## Action Show Editor showEditor = QCoreApplication.translate("PythonConsole", "Show editor") self.showEditorButton = QAction(self) self.showEditorButton.setEnabled(True) self.showEditorButton.setCheckable(True) self.showEditorButton.setIcon(QgsApplication.getThemeIcon("console/iconShowEditorConsole.png")) self.showEditorButton.setMenuRole(QAction.PreferencesRole) self.showEditorButton.setIconVisibleInMenu(True) self.showEditorButton.setToolTip(showEditor) self.showEditorButton.setText(showEditor) ## Action for Clear button clearBt = QCoreApplication.translate("PythonConsole", "Clear console") self.clearButton = QAction(self) self.clearButton.setCheckable(False) self.clearButton.setEnabled(True) self.clearButton.setIcon(QgsApplication.getThemeIcon("console/iconClearConsole.png")) self.clearButton.setMenuRole(QAction.PreferencesRole) self.clearButton.setIconVisibleInMenu(True) self.clearButton.setToolTip(clearBt) self.clearButton.setText(clearBt) ## Action for settings optionsBt = QCoreApplication.translate("PythonConsole", "Settings") self.optionsButton = QAction(self) self.optionsButton.setCheckable(False) self.optionsButton.setEnabled(True) self.optionsButton.setIcon(QgsApplication.getThemeIcon("console/iconSettingsConsole.png")) self.optionsButton.setMenuRole(QAction.PreferencesRole) self.optionsButton.setIconVisibleInMenu(True) self.optionsButton.setToolTip(optionsBt) self.optionsButton.setText(optionsBt) ## Action menu for class actionClassBt = QCoreApplication.translate("PythonConsole", "Import Class") self.actionClass = QAction(self) self.actionClass.setCheckable(False) self.actionClass.setEnabled(True) self.actionClass.setIcon(QgsApplication.getThemeIcon("console/iconClassConsole.png")) self.actionClass.setMenuRole(QAction.PreferencesRole) self.actionClass.setIconVisibleInMenu(True) self.actionClass.setToolTip(actionClassBt) self.actionClass.setText(actionClassBt) ## Import Processing class loadProcessingBt = QCoreApplication.translate("PythonConsole", "Import Processing class") self.loadProcessingButton = QAction(self) self.loadProcessingButton.setCheckable(False) self.loadProcessingButton.setEnabled(True) self.loadProcessingButton.setIcon(QgsApplication.getThemeIcon("console/iconProcessingConsole.png")) self.loadProcessingButton.setMenuRole(QAction.PreferencesRole) self.loadProcessingButton.setIconVisibleInMenu(True) self.loadProcessingButton.setToolTip(loadProcessingBt) self.loadProcessingButton.setText(loadProcessingBt) ## Import QtCore class loadQtCoreBt = QCoreApplication.translate("PythonConsole", "Import PyQt.QtCore class") self.loadQtCoreButton = QAction(self) self.loadQtCoreButton.setCheckable(False) self.loadQtCoreButton.setEnabled(True) self.loadQtCoreButton.setIcon(QgsApplication.getThemeIcon("console/iconQtCoreConsole.png")) self.loadQtCoreButton.setMenuRole(QAction.PreferencesRole) self.loadQtCoreButton.setIconVisibleInMenu(True) self.loadQtCoreButton.setToolTip(loadQtCoreBt) self.loadQtCoreButton.setText(loadQtCoreBt) ## Import QtGui class loadQtGuiBt = QCoreApplication.translate("PythonConsole", "Import PyQt.QtGui class") self.loadQtGuiButton = QAction(self) self.loadQtGuiButton.setCheckable(False) self.loadQtGuiButton.setEnabled(True) self.loadQtGuiButton.setIcon(QgsApplication.getThemeIcon("console/iconQtGuiConsole.png")) self.loadQtGuiButton.setMenuRole(QAction.PreferencesRole) self.loadQtGuiButton.setIconVisibleInMenu(True) self.loadQtGuiButton.setToolTip(loadQtGuiBt) self.loadQtGuiButton.setText(loadQtGuiBt) ## Action for Run script runBt = QCoreApplication.translate("PythonConsole", "Run command") self.runButton = QAction(self) self.runButton.setCheckable(False) self.runButton.setEnabled(True) self.runButton.setIcon(QgsApplication.getThemeIcon("console/iconRunConsole.png")) self.runButton.setMenuRole(QAction.PreferencesRole) self.runButton.setIconVisibleInMenu(True) self.runButton.setToolTip(runBt) self.runButton.setText(runBt) ## Help action helpBt = QCoreApplication.translate("PythonConsole", "Help") self.helpButton = QAction(self) self.helpButton.setCheckable(False) self.helpButton.setEnabled(True) self.helpButton.setIcon(QgsApplication.getThemeIcon("console/iconHelpConsole.png")) self.helpButton.setMenuRole(QAction.PreferencesRole) self.helpButton.setIconVisibleInMenu(True) self.helpButton.setToolTip(helpBt) self.helpButton.setText(helpBt) self.toolBar = QToolBar() self.toolBar.setEnabled(True) self.toolBar.setFocusPolicy(Qt.NoFocus) self.toolBar.setContextMenuPolicy(Qt.DefaultContextMenu) self.toolBar.setLayoutDirection(Qt.LeftToRight) self.toolBar.setIconSize(QSize(16, 16)) self.toolBar.setMovable(False) self.toolBar.setFloatable(False) self.toolBar.addAction(self.clearButton) self.toolBar.addAction(self.actionClass) self.toolBar.addAction(self.runButton) self.toolBar.addSeparator() self.toolBar.addAction(self.showEditorButton) self.toolBar.addSeparator() self.toolBar.addAction(self.optionsButton) self.toolBar.addAction(self.helpButton) self.toolBarEditor = QToolBar() self.toolBarEditor.setEnabled(False) self.toolBarEditor.setFocusPolicy(Qt.NoFocus) self.toolBarEditor.setContextMenuPolicy(Qt.DefaultContextMenu) self.toolBarEditor.setLayoutDirection(Qt.LeftToRight) self.toolBarEditor.setIconSize(QSize(16, 16)) self.toolBarEditor.setMovable(False) self.toolBarEditor.setFloatable(False) self.toolBarEditor.addAction(self.openFileButton) self.toolBarEditor.addAction(self.openInEditorButton) self.toolBarEditor.addSeparator() self.toolBarEditor.addAction(self.saveFileButton) self.toolBarEditor.addAction(self.saveAsFileButton) self.toolBarEditor.addSeparator() self.toolBarEditor.addAction(self.findTextButton) self.toolBarEditor.addSeparator() self.toolBarEditor.addAction(self.cutEditorButton) self.toolBarEditor.addAction(self.copyEditorButton) self.toolBarEditor.addAction(self.pasteEditorButton) self.toolBarEditor.addSeparator() self.toolBarEditor.addAction(self.commentEditorButton) self.toolBarEditor.addAction(self.uncommentEditorButton) self.toolBarEditor.addSeparator() self.toolBarEditor.addAction(self.objectListButton) self.toolBarEditor.addSeparator() self.toolBarEditor.addAction(self.runScriptEditorButton) ## Menu Import Class self.classMenu = QMenu() self.classMenu.addAction(self.loadProcessingButton) self.classMenu.addAction(self.loadQtCoreButton) self.classMenu.addAction(self.loadQtGuiButton) cM = self.toolBar.widgetForAction(self.actionClass) cM.setMenu(self.classMenu) cM.setPopupMode(QToolButton.InstantPopup) self.widgetButton = QWidget() sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Preferred) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.widgetButton.sizePolicy().hasHeightForWidth()) self.widgetButton.setSizePolicy(sizePolicy) self.widgetButtonEditor = QWidget(self.widgetEditor) sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Preferred) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.widgetButtonEditor.sizePolicy().hasHeightForWidth()) self.widgetButtonEditor.setSizePolicy(sizePolicy) sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding) sizePolicy.setHorizontalStretch(0) sizePolicy.setVerticalStretch(0) sizePolicy.setHeightForWidth(self.shellOut.sizePolicy().hasHeightForWidth()) self.shellOut.setSizePolicy(sizePolicy) self.shellOut.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded) self.shell.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded) ##------------ Layout ------------------------------- self.mainLayout = QGridLayout(self) self.mainLayout.setMargin(0) self.mainLayout.setSpacing(0) self.mainLayout.addWidget(self.widgetButton, 0, 0, 1, 1) self.mainLayout.addWidget(self.splitterEditor, 0, 1, 1, 1) self.shellOutWidget.layout().insertWidget(0, self.toolBar) self.layoutEditor = QGridLayout(self.widgetEditor) self.layoutEditor.setMargin(0) self.layoutEditor.setSpacing(0) self.layoutEditor.addWidget(self.toolBarEditor, 0, 1, 1, 1) self.layoutEditor.addWidget(self.widgetButtonEditor, 1, 0, 2, 1) self.layoutEditor.addWidget(self.tabEditorWidget, 1, 1, 1, 1) self.layoutEditor.addWidget(self.widgetFind, 2, 1, 1, 1) ## Layout for the find widget self.layoutFind = QGridLayout(self.widgetFind) self.layoutFind.setContentsMargins(0, 0, 0, 0) self.lineEditFind = QgsFilterLineEdit() placeHolderTxt = QCoreApplication.translate("PythonConsole", "Enter text to find...") if pyqtconfig.Configuration().qt_version >= 0x40700: self.lineEditFind.setPlaceholderText(placeHolderTxt) else: self.lineEditFind.setToolTip(placeHolderTxt) self.findNextButton = QToolButton() self.findNextButton.setEnabled(False) toolTipfindNext = QCoreApplication.translate("PythonConsole", "Find Next") self.findNextButton.setToolTip(toolTipfindNext) self.findNextButton.setIcon(QgsApplication.getThemeIcon("console/iconSearchNextEditorConsole.png")) self.findNextButton.setIconSize(QSize(24, 24)) self.findNextButton.setAutoRaise(True) self.findPrevButton = QToolButton() self.findPrevButton.setEnabled(False) toolTipfindPrev = QCoreApplication.translate("PythonConsole", "Find Previous") self.findPrevButton.setToolTip(toolTipfindPrev) self.findPrevButton.setIcon(QgsApplication.getThemeIcon("console/iconSearchPrevEditorConsole.png")) self.findPrevButton.setIconSize(QSize(24, 24)) self.findPrevButton.setAutoRaise(True) self.caseSensitive = QCheckBox() caseSensTr = QCoreApplication.translate("PythonConsole", "Case Sensitive") self.caseSensitive.setText(caseSensTr) self.wholeWord = QCheckBox() wholeWordTr = QCoreApplication.translate("PythonConsole", "Whole Word") self.wholeWord.setText(wholeWordTr) self.wrapAround = QCheckBox() self.wrapAround.setChecked(True) wrapAroundTr = QCoreApplication.translate("PythonConsole", "Wrap Around") self.wrapAround.setText(wrapAroundTr) self.layoutFind.addWidget(self.lineEditFind, 0, 1, 1, 1) self.layoutFind.addWidget(self.findPrevButton, 0, 2, 1, 1) self.layoutFind.addWidget(self.findNextButton, 0, 3, 1, 1) self.layoutFind.addWidget(self.caseSensitive, 0, 4, 1, 1) self.layoutFind.addWidget(self.wholeWord, 0, 5, 1, 1) self.layoutFind.addWidget(self.wrapAround, 0, 6, 1, 1) ##------------ Add first Tab in Editor ------------------------------- #self.tabEditorWidget.newTabEditor(tabName='first', filename=None) ##------------ Signal ------------------------------- self.findTextButton.toggled.connect(self.findTextEditor) self.objectListButton.toggled.connect(self.toggleObjectListWidget) self.commentEditorButton.triggered.connect(self.commentCode) self.uncommentEditorButton.triggered.connect(self.uncommentCode) self.runScriptEditorButton.triggered.connect(self.runScriptEditor) self.cutEditorButton.triggered.connect(self.cutEditor) self.copyEditorButton.triggered.connect(self.copyEditor) self.pasteEditorButton.triggered.connect(self.pasteEditor) self.showEditorButton.toggled.connect(self.toggleEditor) self.clearButton.triggered.connect(self.shellOut.clearConsole) self.optionsButton.triggered.connect(self.openSettings) self.loadProcessingButton.triggered.connect(self.processing) self.loadQtCoreButton.triggered.connect(self.qtCore) self.loadQtGuiButton.triggered.connect(self.qtGui) self.runButton.triggered.connect(self.shell.entered) self.openFileButton.triggered.connect(self.openScriptFile) self.openInEditorButton.triggered.connect(self.openScriptFileExtEditor) self.saveFileButton.triggered.connect(self.saveScriptFile) self.saveAsFileButton.triggered.connect(self.saveAsScriptFile) self.helpButton.triggered.connect(self.openHelp) self.connect(self.listClassMethod, SIGNAL('itemClicked(QTreeWidgetItem*, int)'), self.onClickGoToLine) self.lineEditFind.returnPressed.connect(self._findText) self.findNextButton.clicked.connect(self._findNext) self.findPrevButton.clicked.connect(self._findPrev) self.lineEditFind.textChanged.connect(self._textFindChanged) def _findText(self): self.tabEditorWidget.currentWidget().newEditor.findText(True) def _findNext(self): self.tabEditorWidget.currentWidget().newEditor.findText(True) def _findPrev(self): self.tabEditorWidget.currentWidget().newEditor.findText(False) def _textFindChanged(self): if self.lineEditFind.text(): self.findNextButton.setEnabled(True) self.findPrevButton.setEnabled(True) else: self.lineEditFind.setStyleSheet('') self.findNextButton.setEnabled(False) self.findPrevButton.setEnabled(False) def onClickGoToLine(self, item, column): tabEditor = self.tabEditorWidget.currentWidget().newEditor if item.text(1) == 'syntaxError': check = tabEditor.syntaxCheck(fromContextMenu=False) if check and not tabEditor.isReadOnly(): self.tabEditorWidget.currentWidget().save() return linenr = int(item.text(1)) itemName = str(item.text(0)) charPos = itemName.find(' ') if charPos != -1: objName = itemName[0:charPos] else: objName = itemName tabEditor.goToLine(objName, linenr) def processing(self): self.shell.commandConsole('processing') def qtCore(self): self.shell.commandConsole('qtCore') def qtGui(self): self.shell.commandConsole('qtGui') def toggleEditor(self, checked): self.splitterObj.show() if checked else self.splitterObj.hide() if not self.tabEditorWidget: self.tabEditorWidget.enableToolBarEditor(checked) self.tabEditorWidget.restoreTabsOrAddNew() def toggleObjectListWidget(self, checked): self.listClassMethod.show() if checked else self.listClassMethod.hide() def findTextEditor(self, checked): self.widgetFind.show() if checked else self.widgetFind.hide() def pasteEditor(self): self.tabEditorWidget.currentWidget().newEditor.paste() def cutEditor(self): self.tabEditorWidget.currentWidget().newEditor.cut() def copyEditor(self): self.tabEditorWidget.currentWidget().newEditor.copy() def runScriptEditor(self): self.tabEditorWidget.currentWidget().newEditor.runScriptCode() def commentCode(self): self.tabEditorWidget.currentWidget().newEditor.commentEditorCode(True) def uncommentCode(self): self.tabEditorWidget.currentWidget().newEditor.commentEditorCode(False) def openScriptFileExtEditor(self): tabWidget = self.tabEditorWidget.currentWidget() path = tabWidget.path import subprocess try: subprocess.Popen([os.environ['EDITOR'], path]) except KeyError: QDesktopServices.openUrl(QUrl.fromLocalFile(path)) def openScriptFile(self): lastDirPath = self.settings.value("pythonConsole/lastDirPath", QDir.home()) openFileTr = QCoreApplication.translate("PythonConsole", "Open File") fileList = QFileDialog.getOpenFileNames( self, openFileTr, lastDirPath, "Script file (*.py)") if fileList: for pyFile in fileList: for i in range(self.tabEditorWidget.count()): tabWidget = self.tabEditorWidget.widget(i) if tabWidget.path == pyFile: self.tabEditorWidget.setCurrentWidget(tabWidget) break else: tabName = QFileInfo(pyFile).fileName() self.tabEditorWidget.newTabEditor(tabName, pyFile) lastDirPath = QFileInfo(pyFile).path() self.settings.setValue("pythonConsole/lastDirPath", pyFile) self.updateTabListScript(pyFile, action='append') def saveScriptFile(self): tabWidget = self.tabEditorWidget.currentWidget() try: tabWidget.save() except (IOError, OSError), error: msgText = QCoreApplication.translate('PythonConsole', 'The file <b>{0}</b> could not be saved. Error: {1}').format(tabWidget.path, error.strerror) self.callWidgetMessageBarEditor(msgText, 2, False)
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 = GisGrimeFocusDialog() 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) ###########aca las conexiones a los botones############################ # set the default crs system dest_crs = self.dlg.mpsw_crs.setCrs(QgsCoordinateReferenceSystem(3116)) # funcion que guarda la ruta del archivo de salida en el text # correspondiente self.dlg.pBSearchFile.clicked.connect(self.readInputData) #funcionque conecta al boton con la funcion de convertir el scv en shape # y cargarlo self.dlg.pBImport.clicked.connect(self.validations) self.dlg.mcb_lista_csv.layerChanged.connect(self.load_fields) self.dlg.pb_clean.clicked.connect(self.clean) # funcion que habilita el radio buton de numero de features al seleccionar # el cuadro de cifras self.dlg.dsb_bandwith.valueChanged.connect(self.radio_custom_click) return action
class CatalogOTFPlugin: def __init__(self, iface): def translate(): # # For create file 'qm' # 1) Define that files need for translation: catalogotf.pro # 2) Create 'ts': pylupdate4 -verbose catalogotf.pro # 3) Edit your translation: QtLinquist # 4) Create 'qm': lrelease catalogotf_pt_BR.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.projOTF = ProjectDockWidgetCatalogOTF(iface) self.name = u"&Catalog OTF" self.dock = None name_src = "catalogotf" translate() def _connect(self, isConnect=True): signal_slot = ({ 'signal': QgsProject.instance().readProject, 'slot': self.projOTF.onReadProject }, { 'signal': QgsProject.instance().writeProject, 'slot': self.projOTF.onWriteProject }) if isConnect: for item in signal_slot: item['signal'].connect(item['slot']) else: for item in signal_slot: item['signal'].disconnect(item['slot']) def initGui(self): msgtrans = QCoreApplication.translate("CatalogOTF", "Catalog on the fly") icon = QIcon(os.path.join(os.path.dirname(__file__), 'catalogotf.svg')) self.action = QAction(icon, msgtrans, self.iface.mainWindow()) self.action.setObjectName("CatalogOTF") self.action.setWhatsThis(msgtrans) self.action.setStatusTip(msgtrans) self.action.triggered.connect(self.run) self.iface.addToolBarIcon(self.action) self.iface.addPluginToRasterMenu(self.name, self.action) self._connect() def unload(self): self.iface.removePluginMenu(self.name, self.action) self.iface.removeToolBarIcon(self.action) del self.action del self.dock self._connect(False) @pyqtSlot() def run(self): self.dock = DockWidgetCatalogOTF(self.iface) self.iface.addDockWidget(Qt.LeftDockWidgetArea, self.dock) self.action.setEnabled(False)
class TunnelDialog(WindowBaseClass, Ui_TunnelDialog): def __init__(self): WindowBaseClass.__init__(self) self.setupUi(self) self._explicitQuit = False # Tunnels self._tunnels = [] # Setup tray self.tray = Tray(self, "IOSSHy", QIcon(":/icons/network-server.png")) self.tray.activated.connect(self.activated) action = QAction("&Configure", self.tray.menu) action.setIcon(QIcon(":/icons/configure.png")) action.triggered.connect(self.show) self.tray.menu.addAction(action) self.tray.menu.setDefaultAction(action) self.tray.menu.addSeparator() self.actionNoTun = QAction("No tunnels configured", self.tray.menu) self.actionNoTun.setEnabled(False) self.tray.menu.addAction(self.actionNoTun) self.actionLastSep = self.tray.menu.addSeparator() if kde: action = QAction("&About", self.tray.menu) action.triggered.connect(self.about) self.tray.menu.addAction(action) action = QAction("&Quit", self.tray.menu) action.setIcon(QIcon(":/icons/application-exit.png")) action.setShortcut(QKeySequence(Qt.CTRL + Qt.Key_Q)) action.triggered.connect(self.quit) self.tray.menu.addAction(action) # Load settings self.readSettings() self.hide() def show(self): self.visible = True WindowBaseClass.show(self) desktop = QDesktopWidget() rect = desktop.availableGeometry(desktop.primaryScreen()) center = rect.center(); center.setX(center.x() - (self.width()/2)); center.setY(center.y() - (self.height()/2)); self.move(center); def hide(self): self.visible = False self.writeSettings() WindowBaseClass.hide(self) def closeEvent(self, event): if not self._explicitQuit: self.hide() event.ignore() def on_listTunnels_currentItemChanged(self, current, previous): self.grpTunnelProperties.setEnabled(current is not None) self.grpSshProperties.setEnabled(current is not None) if current is not None: tunnel = self._tunnels[self.listTunnels.row(current)] self.txtName.setText( tunnel.name ) self.txtHost.setText( "localhost" if tunnel.host == "" else tunnel.host ) self.txtLocalPort.setText( "0" if tunnel.localPort is None else str(tunnel.localPort) ) self.txtPort.setText( str(tunnel.port) ) self.txtSshPort.setText( str(tunnel.sshPort) ) self.txtUsername.setText( "root" if tunnel.username == "" else tunnel.username ) self.txtCommand.setText( "" if tunnel.command is None else tunnel.command ) self.chkCloseOnTerm.setChecked( Qt.Checked if tunnel.autoClose else Qt.Unchecked ) self.txtName.setFocus() self.txtName.selectAll() else: self.txtName.setText("") self.txtHost.setText("localhost") self.txtLocalPort.setText("0") self.txtPort.setText("") self.txtSshPort.setText("22") self.txtUsername.setText("root") self.txtCommand.setText("") self.chkCloseOnTerm.setChecked(Qt.Unchecked) def currentTunnel(self): try: ti = self.listTunnels.currentRow() return None if ti < 0 else self._tunnels[ti] except IndexError: return None def on_txtName_textEdited(self, text): self.currentTunnel().name = text def on_txtHost_textEdited(self, text): self.currentTunnel().host = text def on_txtLocalPort_textEdited(self, text): self.currentTunnel().localPort = text def on_txtPort_textEdited(self, text): self.currentTunnel().port = text def on_txtSshPort_textEdited(self, text): self.currentTunnel().sshPort = text def on_txtUsername_textEdited(self, text): self.currentTunnel().username = text def on_txtCommand_textEdited(self, text): self.currentTunnel().command = text def on_chkCloseOnTerm_stateChanged(self, state): if self.currentTunnel() is not None: self.currentTunnel().autoClose = state == Qt.Checked @pyqtSignature("") def on_btnAddTunnel_clicked(self): tunnel = Tunnel(self) self._tunnels.append(tunnel) self.listTunnels.setCurrentItem(tunnel.item) self.tray.menu.insertAction(self.actionLastSep, tunnel.action) self.tray.menu.removeAction(self.actionNoTun) @pyqtSignature("") def on_btnDuplicateTunnel_clicked(self): cur = self.currentTunnel() if cur is not None: tunnel = Tunnel(self) tunnel.name = cur.name+" (copy)" tunnel.host = cur.host tunnel.localPort = cur.localPort tunnel.port = cur.port tunnel.username = cur.username tunnel.command = cur.command tunnel.autoClose = cur.autoClose self._tunnels.append(tunnel) self.listTunnels.setCurrentItem(tunnel.item) self.tray.menu.insertAction(self.actionLastSep, tunnel.action) @pyqtSignature("") def on_btnRemoveTunnel_clicked(self): tunnel = self.currentTunnel() if tunnel is not None: ti = self.listTunnels.currentRow() del self._tunnels[ti] self.listTunnels.setCurrentRow(0 if ti != 0 else 1) self.listTunnels.takeItem(ti) self.listTunnels.setCurrentItem(None, QItemSelectionModel.Clear) self.tray.menu.removeAction(tunnel.action) del tunnel if len(self._tunnels) == 0: self.tray.menu.insertAction(self.actionLastSep, self.actionNoTun) def updateTooltip(self): tuninfo = [] for tunnel in self._tunnels: if tunnel.isOpen(): tuninfo.append( "<div>{name}: {host}:{port} => {local}</div>".format(name=tunnel.name, host=tunnel.host, port=tunnel.port, local=tunnel.tunnelPort) ) if tuninfo: tuninfo.insert(0, "<b>Active tunnels:</b>") self.tray.setActive() else: self.tray.setActive(False) self.tray.setToolTipSubTitle( "\n".join(tuninfo) ) def activated(self): if self.visible: self.hide() else: self.show() def readSettings(self): if os.name == 'nt': settings = QSettings() else: settings = QSettings(os.path.expanduser("~/.iosshy.ini"), QSettings.IniFormat) for name in settings.childGroups(): tunnel = Tunnel(self) tunnel.name = name tunnel.readSettings(settings) self._tunnels.append(tunnel) self.tray.menu.insertAction(self.actionLastSep, tunnel.action) self.tray.menu.removeAction(self.actionNoTun) def writeSettings(self): if os.name == 'nt': settings = QSettings() else: settings = QSettings(os.path.expanduser("~/.iosshy.ini"), QSettings.IniFormat) settings.clear() for tunnel in self._tunnels: tunnel.writeSettings(settings) def about(self): KAboutApplicationDialog(application.aboutData, self).exec_() if self.isHidden(): self.show() self.hide() def quit(self): self.writeSettings() self._explicitQuit = True self.close()
class MainWindow(QMainWindow): groups = dict() typeQListWidgetHeader = 1000 showHostsInGroups = False currentGroupName = None # used to simple detect currently selected group to show menu def __init__(self): super(MainWindow, self).__init__() self.config = Config() self.db = Database(self.config.getConnectionString()) cryptoKey = self.getCryptoKey() self.hosts = Hosts(self.db, cryptoKey) # menu used for each host self.hostMenu = QMenu() self.editAction = QAction(QIcon(':/ico/edit.svg'), "Edit", self.hostMenu) self.editAction.triggered.connect(self.editHost) self.hostMenu.addAction(self.editAction) # menu used for headers of groups self.groupsHeaderMenu = QMenu() self.editGroupAction = QAction(QIcon(':/ico/edit.svg'), "Edit group", self.groupsHeaderMenu) self.editGroupAction.triggered.connect(self.editGroup) self.deleteGroupAction = QAction(QIcon(':/ico/remove.svg'), "Delete group", self.groupsHeaderMenu) self.deleteGroupAction.triggered.connect(self.deleteGroup) self.groupsHeaderMenu.addAction(self.editGroupAction) self.groupsHeaderMenu.addAction(self.deleteGroupAction) self.duplicateAction = QAction(QIcon(':/ico/copy.svg'), "Duplicate", self.hostMenu) self.duplicateAction.triggered.connect(self.duplicateHost) self.hostMenu.addAction(self.duplicateAction) # todo: confirm for delete action self.deleteAction = QAction(QIcon(':/ico/remove.svg'), "Delete", self.hostMenu) self.deleteAction.triggered.connect(self.deleteHost) self.hostMenu.addAction(self.deleteAction) self.connectFramelessMenu = actions.generateScreenChoseMenu(self.hostMenu, self.connectFrameless, ':/ico/frameless.svg', "Connect frameless") self.hostMenu.addMenu(self.connectFramelessMenu) self.assignGroupAction = QAction("Assign group", self.hostMenu) self.assignGroupAction.triggered.connect(self.assignGroup) self.hostMenu.addAction(self.assignGroupAction) # setup main window self.ui = Ui_MainWindow() self.ui.setupUi(self) # when top level changed, we changing dock title bar self.dockWidgetTileBar = DockWidgetTitleBar() self.ui.hostsDock.setTitleBarWidget(self.dockWidgetTileBar) self.ui.hostsDock.topLevelChanged.connect(self.dockLevelChanged) # set global menu self.globalMenu = QMenu() self.globalMenu.addAction(QIcon(':/ico/add.svg'), 'Add host', self.addHost) # groups menu self.groupsMenu = QMenu("Groups") self.groupsMenu.aboutToShow.connect(self.setGroupsMenu) self.globalMenu.addMenu(self.groupsMenu) # disable menu indicator self.ui.menu.setStyleSheet("QPushButton::menu-indicator {image: none;}") self.positionMenu = QMenu("Dock position") self.positionMenu.addAction("Left", lambda: self.setDockPosition(Qt.LeftDockWidgetArea)) self.positionMenu.addAction("Right", lambda: self.setDockPosition(Qt.RightDockWidgetArea)) self.positionMenu.addAction("Float", self.setDockFloat) self.globalMenu.addMenu(self.positionMenu) self.globalMenu.addAction('Change tray icon visibility', self.changeTrayIconVisibility) self.globalMenu.addAction('Settings', self.showSettings) self.globalMenu.addAction('Quit', self.close) self.ui.menu.setMenu(self.globalMenu) # set events on hosts list self.ui.hostsList.itemDoubleClicked.connect(self.slotConnectHost) self.ui.hostsList.itemClicked.connect(self.slotShowHost) self.ui.hostsList.customContextMenuRequested.connect(self.slotShowHostContextMenu) # set tab widget self.tabWidget = MyTabWidget() self.setCentralWidget(self.tabWidget) self.tabWidget.setContextMenuPolicy(Qt.CustomContextMenu) self.tabWidget.customContextMenuRequested.connect(self.showCentralWidgetContextMenu) # set tray icon self.tray = QSystemTrayIcon(QIcon(":/ico/myrdp.svg")) self.tray.activated.connect(self.trayActivated) self.trayMenu = QMenu() self.trayMenu.addAction("Hide tray icon", self.changeTrayIconVisibility) self.connectHostMenuTray = ConnectHostMenu(self.hosts) self.connectHostMenuTray.triggered.connect(self.connectHostFromTrayMenu) self.trayMenu.addMenu(self.connectHostMenuTray) self.trayMenu.addAction("Quit", self.close) self.tray.setContextMenu(self.trayMenu) self.restoreSettings() # host list self.ui.filter.textChanged.connect(self.setHostList) self.setHostList() def getCryptoKey(self, passphrase=None): try: return self.config.getPrivateKey(passphrase) except ValueError: passwordDialog = PasswordDialog() retCode = passwordDialog.exec_() if retCode == QtGui.QDialog.Accepted: return self.getCryptoKey(passwordDialog.getPassword()) else: raise SystemError("Password required") def showSettings(self): settingsWidget = self.findChild(QWidget, "settings") if settingsWidget is None: self.settingsWidget = SettingsPage() self.settingsWidget.setObjectName("settings") self.tabWidget.insertTab(0, self.settingsWidget, QIcon(":/ico/settings.svg"), 'Settings') index = self.tabWidget.indexOf(self.settingsWidget) self.tabWidget.setCurrentIndex(index) def connectHostFromMenu(self, action): self.connectHost(str(action.text())) def connectHostFromTrayMenu(self, action): tabPage = self.connectHost(str(action.text())) if not self.isVisible(): self.tabWidget.setDetached(True, tabPage) def trayActivated(self, reason): if reason != QSystemTrayIcon.Trigger: return if self.isVisible(): self.hide() else: self.show() self.activateWindow() def changeTrayIconVisibility(self): if self.tray.isVisible(): self.tray.hide() if not self.isVisible(): self.show() else: self.tray.show() def refreshGroups(self): groupList = self.hosts.getGroupsList() for group in groupList: if group not in self.groups: # add new groups as visible self.groups[group] = True # remove not existing groups keysToDelete = set(self.groups.keys()) - set(groupList) for key in keysToDelete: self.groups.pop(key) def assignGroup(self): groups = self.hosts.getGroupsList() assignGroupDialog = AssignGroupDialog(groups) groupToAssign = assignGroupDialog.assign() if groupToAssign is not False: # None could be used to unassign the group groupToAssign = groupToAssign if groupToAssign else None for hostName in self.getSelectedHosts(): self.hosts.assignGroup(hostName, groupToAssign) self.db.tryCommit() self.setHostList() def setGroupsMenu(self): self.groupsMenu.clear() addGroupAction = self.groupsMenu.addAction('Add group') addGroupAction.triggered.connect(self.addGroup) deleteGroupAction = self.groupsMenu.addAction('Delete group') deleteGroupAction.triggered.connect(self.showDeleteGroupDialog) showHostsInGroupsAction = self.groupsMenu.addAction('Show host list in groups') showHostsInGroupsAction.triggered.connect(self.changeHostListView) showHostsInGroupsAction.setCheckable(True) showHostsInGroupsAction.setChecked(self.showHostsInGroups) self.groupsMenu.addSeparator() for group, checked in self.groups.items(): action = QAction(group, self.groupsMenu) action.setCheckable(True) action.setChecked(checked) action.triggered.connect(self.groupsVisibilityChanged) self.groupsMenu.addAction(action) def addGroup(self): groupConfigDialog = GroupConfigDialog(self.hosts.groups) resp = groupConfigDialog.add() self._processHostSubmit(resp) def groupsVisibilityChanged(self, checked): currentGroup = str(self.sender().text()) self.groups[currentGroup] = checked self.setHostList() def setDockPosition(self, dockWidgetArea): if self.ui.hostsDock.isFloating(): self.ui.hostsDock.setFloating(False) self.addDockWidget(dockWidgetArea, self.ui.hostsDock) def setDockFloat(self): if self.ui.hostsDock.isFloating(): return # default title bar must be set before is float because sometimes window make strange crash self.ui.hostsDock.setTitleBarWidget(None) self.ui.hostsDock.setFloating(True) def dockLevelChanged(self, isFloating): if isFloating: # changing title bar widget if is not none, probably true will be only once on start with saved float state if self.ui.hostsDock.titleBarWidget(): self.ui.hostsDock.setTitleBarWidget(None) else: self.ui.hostsDock.setTitleBarWidget(self.dockWidgetTileBar) def showFramelessWidget(self): self.t.show() self.t.setGeometry(self.frameGeometry()) def getCurrentHostListItemName(self): return self.ui.hostsList.currentItem().text() def getSelectedHosts(self): return [host.text() for host in self.ui.hostsList.selectedItems()] def findHostItemByName(self, name): result = self.ui.hostsList.findItems(name, Qt.MatchExactly) resultLen = len(result) if resultLen != 1: # should be only one host logger.error("Host not found. Got %d results" % resultLen) return result[0] def showCentralWidgetContextMenu(self, pos): menu = QMenu() title = self.ui.hostsDock.windowTitle() hostsDockAction = menu.addAction(title) hostsDockAction.setCheckable(True) hostsDockAction.setChecked(self.ui.hostsDock.isVisible()) hostsDockAction.triggered.connect(self.changeHostsDockWidgetVisibility) hostsDockAction = menu.addAction("Tray icon") hostsDockAction.setCheckable(True) hostsDockAction.setChecked(self.tray.isVisible()) hostsDockAction.triggered.connect(self.changeTrayIconVisibility) connectHostMenuTray = ConnectHostMenu(self.hosts, "Connect") connectHostMenuTray.triggered.connect(self.connectHostFromMenu) menu.addMenu(connectHostMenuTray) menu.exec_(self.tabWidget.mapToGlobal(pos)) def changeHostListView(self, checked): self.showHostsInGroups = checked self.setHostList() def changeHostsDockWidgetVisibility(self): isVisible = self.ui.hostsDock.isVisible() self.ui.hostsDock.setVisible(not isVisible) def isHostListHeader(self, item): if not item or item.type() == self.typeQListWidgetHeader: return True return False def slotShowHostContextMenu(self, pos): def changeMenusVisibility(isEnabled): self.connectFramelessMenu.setEnabled(isEnabled) self.editAction.setEnabled(isEnabled) self.duplicateAction.setEnabled(isEnabled) # ignore context menu for group headers item = self.ui.hostsList.itemAt(pos) if self.isHostListHeader(item): item = self.ui.hostsList.itemAt(pos) widgetItem = self.ui.hostsList.itemWidget(item) if widgetItem: self.currentGroupName = widgetItem.text() # yea I'm so dirty if self.currentGroupName != unassignedGroupName: self.groupsHeaderMenu.exec_(self.ui.hostsList.mapToGlobal(pos)) return if len(self.ui.hostsList.selectedItems()) == 1: # single menu changeMenusVisibility(True) else: changeMenusVisibility(False) self.hostMenu.exec_(self.ui.hostsList.mapToGlobal(pos)) def _processHostSubmit(self, resp): if resp["code"]: self.setHostList() hostName = resp.get("name") if hostName: hostItem = self.findHostItemByName(hostName) self.slotConnectHost(hostItem) def addHost(self): hostDialog = HostConfigDialog(self.hosts) self._processHostSubmit(hostDialog.add()) def editHost(self): hostDialog = HostConfigDialog(self.hosts) resp = hostDialog.edit(self.getCurrentHostListItemName()) self._processHostSubmit(resp) def editGroup(self): groupConfigDialog = GroupConfigDialog(self.hosts.groups) resp = groupConfigDialog.edit(self.currentGroupName) self._processHostSubmit(resp) def deleteGroup(self): retCode = self.showOkCancelMessageBox("Do you want to remove selected group? All assigned hosts " "to this group will be unassigned.", "Confirmation") if retCode == QMessageBox.Cancel: return self.hosts.deleteGroup(self.currentGroupName) self.setHostList() def showDeleteGroupDialog(self): deleteGroupDialog = DeleteGroupDialog(self.hosts) deleteGroupDialog.deleteGroup() self.setHostList() def duplicateHost(self): hostDialog = HostConfigDialog(self.hosts) resp = hostDialog.duplicate(self.getCurrentHostListItemName()) self._processHostSubmit(resp) def deleteHost(self): retCode = self.showOkCancelMessageBox("Do you want to remove selected hosts?", "Confirmation") if retCode == QMessageBox.Cancel: return for host in self.getSelectedHosts(): self.hosts.delete(host) self.setHostList() def connectFrameless(self, screenIndex=None): self.connectHost(self.getCurrentHostListItemName(), frameless=True, screenIndex=screenIndex) # Fix to release keyboard from QX11EmbedContainer, when we leave widget through wm border def leaveEvent(self, event): keyG = QWidget.keyboardGrabber() if keyG is not None: keyG.releaseKeyboard() event.accept() # needed? def setHostList(self): """ set hosts list in list view """ self.ui.hostsList.clear() self.refreshGroups() hostFilter = self.ui.filter.text() if self.showHostsInGroups: self.showHostListInGroups(hostFilter) else: self.showHostList(hostFilter) def showHostList(self, hostFilter): groupFilter = [group for group, visibility in self.groups.items() if visibility] hosts = self.hosts.getHostsListByHostNameAndGroup(hostFilter, groupFilter) self.ui.hostsList.addItems(hosts) def showHostListInGroups(self, hostFilter): hosts = self.hosts.getGroupedHostNames(hostFilter) for group, hostsList in hosts.items(): if self.groups.get(group, True): if group is None: group = unassignedGroupName groupHeader = QtGui.QListWidgetItem(type=self.typeQListWidgetHeader) groupLabel = QtGui.QLabel(str(group)) groupLabel.setProperty('class', 'group-title') self.ui.hostsList.addItem(groupHeader) self.ui.hostsList.setItemWidget(groupHeader, groupLabel) self.ui.hostsList.addItems(hostsList) def slotShowHost(self, item): # on one click we activating tab and showing options self.tabWidget.activateTab(item) def slotConnectHost(self, item): if self.isHostListHeader(item): return self.connectHost(str(item.text())) def connectHost(self, hostId, frameless=False, screenIndex=None): hostId = str(hostId) # sometimes hostId comes as QString tabPage = self.tabWidget.createTab(hostId) tabPage.reconnectionNeeded.connect(self.connectHost) if frameless: self.tabWidget.detachFrameless(tabPage, screenIndex) try: execCmd, opts = self.getCmd(tabPage, hostId) except LookupError: logger.error("Host {} not found.".format(hostId)) return ProcessManager.start(hostId, tabPage, execCmd, opts) return tabPage def getCmd(self, tabPage, hostName): host = self.hosts.get(hostName) # set tabPage widget width, height = tabPage.setSizeAndGetCurrent() # 1et widget winId to embed rdesktop winId = tabPage.x11.winId() # set remote desktop client, at this time works only with freerdp remoteClientType, remoteClientOptions = self.config.getRdpClient() remoteClient = ClientFactory(remoteClientType, **remoteClientOptions) remoteClient.setWindowParameters(winId, width, height) remoteClient.setUserAndPassword(host.user, host.password) remoteClient.setAddress(host.address) return remoteClient.getComposedCommand() def saveSettings(self): self.config.setValue("geometry", self.saveGeometry()) self.config.setValue("windowState", self.saveState()) self.config.setValue('trayIconVisibility', self.tray.isVisible()) self.config.setValue('mainWindowVisibility', self.isVisible()) self.config.setValue('groups', self.groups) self.config.setValue('showHostsInGroups', self.showHostsInGroups) def restoreSettings(self): try: self.restoreGeometry(self.config.getValue("geometry")) self.restoreState(self.config.getValue("windowState")) except Exception: logger.info("No settings to restore") # restore tray icon state trayIconVisibility = self.config.getBooleanValue('trayIconVisibility', True) self.tray.setVisible(trayIconVisibility) self.showHostsInGroups = self.config.getBooleanValue('showHostsInGroups', False) if self.tray.isVisible(): mainWindowVisibility = self.config.getBooleanValue('mainWindowVisibility', True) self.setVisible(mainWindowVisibility) else: # it tray icon is not visible, always show main window self.show() self.groups = {str(k): v for k, v in self.config.getValue('groups', {}).items()} def closeEvent(self, event): if not ProcessManager.hasActiveProcess: self.saveSettings() QCoreApplication.exit() return ret = self.showOkCancelMessageBox("Are you sure do you want to quit?", "Exit confirmation") if ret == QMessageBox.Cancel: event.ignore() return self.saveSettings() ProcessManager.killemall() event.accept() QCoreApplication.exit() def showOkCancelMessageBox(self, messageBoxText, windowTitle): msgBox = QMessageBox(self, text=messageBoxText) msgBox.setWindowTitle(windowTitle) msgBox.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel) msgBox.setIcon(QMessageBox.Question) return msgBox.exec_()
class OWPaintData(widget.OWWidget): TOOLS = [ ("Brush", "Create multiple instances", AirBrushTool, _i("brush.svg")), ("Put", "Put individual instances", PutInstanceTool, _i("put.svg")), ("Select", "Select and move instances", SelectTool, _i("select-transparent_42px.png")), ("Jitter", "Jitter instances", JitterTool, _i("jitter.svg")), ("Magnet", "Attract multiple instances", MagnetTool, _i("magnet.svg")), ("Clear", "Clear the plot", ClearTool, _i("../../../icons/Dlg_clear.png")) ] name = "Paint Data" description = "Create data by painting data points in the plane." long_description = "" icon = "icons/PaintData.svg" priority = 10 keywords = ["data", "paint", "create"] outputs = [("Data", Orange.data.Table)] inputs = [("Data", Orange.data.Table, "set_data")] autocommit = Setting(False) table_name = Setting("Painted data") attr1 = Setting("x") attr2 = Setting("y") hasAttr2 = Setting(True) brushRadius = Setting(75) density = Setting(7) want_graph = True def __init__(self): super().__init__() self.data = None self.current_tool = None self._selected_indices = None self._scatter_item = None self.labels = ["C1", "C2"] self.undo_stack = QtGui.QUndoStack(self) self.class_model = ColoredListModel(self.labels, self, flags=QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsEditable) self.class_model.dataChanged.connect(self._class_value_changed) self.class_model.rowsInserted.connect(self._class_count_changed) self.class_model.rowsRemoved.connect(self._class_count_changed) self.data = np.zeros((0, 3)) self.colors = colorpalette.ColorPaletteGenerator( len(colorpalette.DefaultRGBColors)) self.tools_cache = {} self._init_ui() def _init_ui(self): namesBox = gui.widgetBox(self.controlArea, "Names") hbox = gui.widgetBox(namesBox, orientation='horizontal', margin=0, spacing=0) gui.lineEdit(hbox, self, "attr1", "Variable X ", controlWidth=80, orientation="horizontal", enterPlaceholder=True, callback=self._attr_name_changed) gui.separator(hbox, 18) hbox = gui.widgetBox(namesBox, orientation='horizontal', margin=0, spacing=0) attr2 = gui.lineEdit(hbox, self, "attr2", "Variable Y ", controlWidth=80, orientation="horizontal", enterPlaceholder=True, callback=self._attr_name_changed) gui.checkBox(hbox, self, "hasAttr2", '', disables=attr2, labelWidth=0, callback=self.set_dimensions) gui.separator(namesBox) gui.widgetLabel(namesBox, "Labels") self.classValuesView = listView = QListView( selectionMode=QListView.SingleSelection, sizePolicy=QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Maximum)) listView.setModel(self.class_model) itemmodels.select_row(listView, 0) namesBox.layout().addWidget(listView) self.addClassLabel = QAction("+", self, toolTip="Add new class label", triggered=self.add_new_class_label) self.removeClassLabel = QAction( unicodedata.lookup("MINUS SIGN"), self, toolTip="Remove selected class label", triggered=self.remove_selected_class_label) actionsWidget = itemmodels.ModelActionsWidget( [self.addClassLabel, self.removeClassLabel], self) actionsWidget.layout().addStretch(10) actionsWidget.layout().setSpacing(1) namesBox.layout().addWidget(actionsWidget) tBox = gui.widgetBox(self.controlArea, "Tools", addSpace=True) buttonBox = gui.widgetBox(tBox, orientation="horizontal") toolsBox = gui.widgetBox(buttonBox, orientation=QtGui.QGridLayout()) self.toolActions = QtGui.QActionGroup(self) self.toolActions.setExclusive(True) self.toolButtons = [] for i, (name, tooltip, tool, icon) in enumerate(self.TOOLS): action = QAction( name, self, toolTip=tooltip, checkable=tool.checkable, icon=QIcon(icon), ) action.triggered.connect(partial(self.set_current_tool, tool)) button = QtGui.QToolButton( iconSize=QSize(24, 24), toolButtonStyle=Qt.ToolButtonTextUnderIcon, sizePolicy=QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)) button.setDefaultAction(action) self.toolButtons.append((button, tool)) toolsBox.layout().addWidget(button, i / 3, i % 3) self.toolActions.addAction(action) for column in range(3): toolsBox.layout().setColumnMinimumWidth(column, 10) toolsBox.layout().setColumnStretch(column, 1) undo = self.undo_stack.createUndoAction(self) redo = self.undo_stack.createRedoAction(self) undo.setShortcut(QtGui.QKeySequence.Undo) redo.setShortcut(QtGui.QKeySequence.Redo) self.addActions([undo, redo]) gui.separator(tBox) indBox = gui.indentedBox(tBox, sep=8) form = QtGui.QFormLayout( formAlignment=Qt.AlignLeft, labelAlignment=Qt.AlignLeft, fieldGrowthPolicy=QtGui.QFormLayout.AllNonFixedFieldsGrow) indBox.layout().addLayout(form) slider = gui.hSlider(indBox, self, "brushRadius", minValue=1, maxValue=100, createLabel=False) form.addRow("Radius", slider) slider = gui.hSlider(indBox, self, "density", None, minValue=1, maxValue=100, createLabel=False) form.addRow("Intensity", slider) gui.rubber(self.controlArea) gui.auto_commit(self.controlArea, self, "autocommit", "Send", "Send on change") # main area GUI viewbox = PaintViewBox(enableMouse=False) self.plotview = pg.PlotWidget(background="w", viewBox=viewbox) self.plotview.sizeHint = lambda: QSize( 200, 100) # Minimum size for 1-d painting self.plot = self.plotview.getPlotItem() axis_color = self.palette().color(QtGui.QPalette.Text) axis_pen = QtGui.QPen(axis_color) tickfont = QtGui.QFont(self.font()) tickfont.setPixelSize(max(int(tickfont.pixelSize() * 2 // 3), 11)) axis = self.plot.getAxis("bottom") axis.setLabel(self.attr1) axis.setPen(axis_pen) axis.setTickFont(tickfont) axis = self.plot.getAxis("left") axis.setLabel(self.attr2) axis.setPen(axis_pen) axis.setTickFont(tickfont) if not self.hasAttr2: self.plot.hideAxis('left') self.plot.hideButtons() self.plot.setXRange(0, 1, padding=0.01) self.mainArea.layout().addWidget(self.plotview) # enable brush tool self.toolActions.actions()[0].setChecked(True) self.set_current_tool(self.TOOLS[0][2]) self.graphButton.clicked.connect(self.save_graph) self.set_dimensions() def set_dimensions(self): if self.hasAttr2: self.plot.setYRange(0, 1, padding=0.01) self.plot.showAxis('left') self.plotview.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Minimum) else: self.plot.setYRange(-.5, .5, padding=0.01) self.plot.hideAxis('left') self.plotview.setSizePolicy(QSizePolicy.Ignored, QSizePolicy.Maximum) self._replot() for button, tool in self.toolButtons: if tool.only2d: button.setDisabled(not self.hasAttr2) def set_data(self, data): if data: try: y = next(cls for cls in data.domain.class_vars if cls.is_discrete) except StopIteration: y = np.ones(X.shape[0]) else: y = data[:, y].Y while len(self.class_model) < np.unique(y).size: self.add_new_class_label(undoable=False) X = np.array([scale(vals) for vals in data.X[:, :2].T]).T self.data = np.column_stack((X, y)) self._replot() def add_new_class_label(self, undoable=True): newlabel = next(label for label in namegen('C', 1) if label not in self.class_model) command = SimpleUndoCommand(lambda: self.class_model.append(newlabel), lambda: self.class_model.__delitem__(-1)) if undoable: self.undo_stack.push(command) else: command.redo() def remove_selected_class_label(self): index = self.selected_class_label() if index is None: return label = self.class_model[index] mask = self.data[:, 2] == index move_mask = self.data[~mask][:, 2] > index self.undo_stack.beginMacro("Delete class label") self.undo_stack.push(UndoCommand(DeleteIndices(mask), self)) self.undo_stack.push(UndoCommand(Move((move_mask, 2), -1), self)) self.undo_stack.push( SimpleUndoCommand(lambda: self.class_model.__delitem__(index), lambda: self.class_model.insert(index, label))) self.undo_stack.endMacro() newindex = min(max(index - 1, 0), len(self.class_model) - 1) itemmodels.select_row(self.classValuesView, newindex) def _class_count_changed(self): self.labels = list(self.class_model) self.removeClassLabel.setEnabled(len(self.class_model) > 1) self.addClassLabel.setEnabled( len(self.class_model) < self.colors.number_of_colors) if self.selected_class_label() is None: itemmodels.select_row(self.classValuesView, 0) def _class_value_changed(self, index, _): index = index.row() newvalue = self.class_model[index] oldvalue = self.labels[index] if newvalue != oldvalue: self.labels[index] = newvalue # command = Command( # lambda: self.class_model.__setitem__(index, newvalue), # lambda: self.class_model.__setitem__(index, oldvalue), # ) # self.undo_stack.push(command) def selected_class_label(self): rows = self.classValuesView.selectedIndexes() if rows: return rows[0].row() else: return None def set_current_tool(self, tool): prev_tool = self.current_tool.__class__ if self.current_tool is not None: self.current_tool.deactivate() self.current_tool.editingStarted.disconnect( self._on_editing_started) self.current_tool.editingFinished.disconnect( self._on_editing_finished) self.current_tool = None self.plot.getViewBox().tool = None if tool not in self.tools_cache: newtool = tool(self, self.plot) newtool.editingFinished.connect(self.invalidate) self.tools_cache[tool] = newtool newtool.issueCommand.connect(self._add_command) self._selected_region = QRectF() self.current_tool = tool = self.tools_cache[tool] self.plot.getViewBox().tool = tool tool.editingStarted.connect(self._on_editing_started) tool.editingFinished.connect(self._on_editing_finished) tool.activate() if not tool.checkable: self.set_current_tool(prev_tool) def _on_editing_started(self): self.undo_stack.beginMacro("macro") def _on_editing_finished(self): self.undo_stack.endMacro() def execute(self, command): if isinstance(command, (Append, DeleteIndices, Insert, Move)): if isinstance(command, (DeleteIndices, Insert)): self._selected_indices = None if isinstance(self.current_tool, SelectTool): self.current_tool._reset() self.data, undo = transform(command, self.data) self._replot() return undo else: assert False, "Non normalized command" def _add_command(self, cmd): name = "Name" if (not self.hasAttr2 and isinstance(cmd, (Move, MoveSelection, Jitter, Magnet))): # tool only supported if both x and y are enabled return if isinstance(cmd, Append): cls = self.selected_class_label() points = np.array([(p.x(), p.y() if self.hasAttr2 else 0, cls) for p in cmd.points]) self.undo_stack.push(UndoCommand(Append(points), self, text=name)) elif isinstance(cmd, Move): self.undo_stack.push(UndoCommand(cmd, self, text=name)) elif isinstance(cmd, SelectRegion): indices = [ i for i, (x, y) in enumerate(self.data[:, :2]) if cmd.region.contains(QPointF(x, y)) ] indices = np.array(indices, dtype=int) self._selected_indices = indices elif isinstance(cmd, DeleteSelection): indices = self._selected_indices if indices is not None and indices.size: self.undo_stack.push( UndoCommand(DeleteIndices(indices), self, text="Delete")) elif isinstance(cmd, MoveSelection): indices = self._selected_indices if indices is not None and indices.size: self.undo_stack.push( UndoCommand(Move((self._selected_indices, slice(0, 2)), np.array([cmd.delta.x(), cmd.delta.y()])), self, text="Move")) elif isinstance(cmd, DeleteIndices): self.undo_stack.push(UndoCommand(cmd, self, text="Delete")) elif isinstance(cmd, Insert): self.undo_stack.push(UndoCommand(cmd, self)) elif isinstance(cmd, AirBrush): data = create_data(cmd.pos.x(), cmd.pos.y(), self.brushRadius / 1000, 1 + self.density / 20, cmd.rstate) self._add_command(Append([QPointF(*p) for p in zip(*data.T)])) elif isinstance(cmd, Jitter): point = np.array([cmd.pos.x(), cmd.pos.y()]) delta = -apply_jitter(self.data[:, :2], point, self.density / 100.0, 0, cmd.rstate) self._add_command(Move((..., slice(0, 2)), delta)) elif isinstance(cmd, Magnet): point = np.array([cmd.pos.x(), cmd.pos.y()]) delta = -apply_attractor(self.data[:, :2], point, self.density / 100.0, 0) self._add_command(Move((..., slice(0, 2)), delta)) else: assert False, "unreachable" def _replot(self): def pen(color): pen = QPen(color, 1) pen.setCosmetic(True) return pen if self._scatter_item is not None: self.plot.removeItem(self._scatter_item) self._scatter_item = None nclasses = len(self.class_model) pens = [pen(self.colors[i]) for i in range(nclasses)] self._scatter_item = pg.ScatterPlotItem( self.data[:, 0], self.data[:, 1] if self.hasAttr2 else np.zeros(self.data.shape[0]), symbol="+", pen=[pens[int(ci)] for ci in self.data[:, 2]]) self.plot.addItem(self._scatter_item) def _attr_name_changed(self): self.plot.getAxis("bottom").setLabel(self.attr1) self.plot.getAxis("left").setLabel(self.attr2) self.invalidate() def invalidate(self): self.commit() def commit(self): if self.hasAttr2: X, Y = self.data[:, :2], self.data[:, 2] attrs = (Orange.data.ContinuousVariable(self.attr1), Orange.data.ContinuousVariable(self.attr2)) else: X, Y = self.data[:, np.newaxis, 0], self.data[:, 2] attrs = (Orange.data.ContinuousVariable(self.attr1), ) if len(np.unique(Y)) >= 2: domain = Orange.data.Domain( attrs, Orange.data.DiscreteVariable("Class", values=list(self.class_model))) data = Orange.data.Table.from_numpy(domain, X, Y) else: domain = Orange.data.Domain(attrs) data = Orange.data.Table.from_numpy(domain, X) data.name = self.table_name self.send("Data", data) def sizeHint(self): sh = super().sizeHint() return sh.expandedTo(QSize(1200, 800)) def onDeleteWidget(self): self.plot.clear() def save_graph(self): from Orange.widgets.data.owsave import OWSave save_img = OWSave(data=self.plotview.plotItem, file_formats=FileFormat.img_writers) save_img.exec_() def send_report(self): if self.data is None: return settings = [] if self.attr1 != "x" or self.attr2 != "y": settings += [("Axis x", self.attr1), ("Axis y", self.attr2)] settings += [("Number of points", len(self.data))] self.report_items("Painted data", settings) self.report_plot(self.plot)
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 # Actions self.action_add_layers = None self.action_add_osm_layer = None self.action_add_petabencana_layer = None self.action_batch_runner = None self.action_dock = None self.action_extent_selector = None self.action_field_mapping = None self.action_multi_exposure = None self.action_function_centric_wizard = None self.action_import_dialog = None self.action_keywords_wizard = None self.action_minimum_needs = None self.action_minimum_needs_config = None self.action_multi_buffer = None self.action_options = None self.action_run_tests = None self.action_save_scenario = None self.action_shake_converter = None self.action_show_definitions = None self.action_toggle_rubberbands = None self.action_metadata_converter = None self.translator = None self.toolbar = None self.wizard = None self.actions = [] # list of all QActions we create for InaSAFE 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) developer_mode = setting('developer_mode', False, expected_type=bool) self.hide_developer_buttons = (inasafe_release_status == 'final' and not developer_mode) # 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 :param add_to_legend: Flag indicating whether the action should also be added to the layer legend menu. Default to False. :type add_to_legend: 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, add_to_toolbar=True) def _create_geonode_uploader_action(self): """Create action for Geonode uploader dialog.""" if self.hide_developer_buttons: return icon = resources_path('img', 'icons', 'geonode.png') label = tr('Geonode Uploader') self.action_geonode = QAction(QIcon(icon), label, self.iface.mainWindow()) self.action_geonode.setStatusTip(label) self.action_geonode.setWhatsThis(label) self.action_geonode.triggered.connect(self.show_geonode_uploader) self.add_action(self.action_geonode, add_to_toolbar=False) 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, add_to_toolbar=True) def _create_show_definitions_action(self): """Create action for showing definitions / help.""" icon = resources_path('img', 'icons', 'show-inasafe-help.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_metadata_converter_action(self): """Create action for showing metadata converter dialog.""" icon = resources_path('img', 'icons', 'show-metadata-converter.svg') self.action_metadata_converter = QAction( QIcon(icon), self.tr('InaSAFE Metadata Converter'), self.iface.mainWindow()) self.action_metadata_converter.setStatusTip( self.tr('Convert metadata from version 4.3 to version 3.5.')) self.action_metadata_converter.setWhatsThis( self.tr('Use this tool to convert metadata 4.3 to version 3.5')) self.action_metadata_converter.triggered.connect( self.show_metadata_converter) self.add_action(self.action_metadata_converter, add_to_toolbar=self.full_toolbar) def _create_field_mapping_action(self): """Create action for showing field mapping dialog.""" icon = resources_path('img', 'icons', 'show-mapping-tool.svg') self.action_field_mapping = QAction( QIcon(icon), self.tr('InaSAFE Field Mapping Tool'), self.iface.mainWindow()) self.action_field_mapping.setStatusTip( self.tr('Assign field mapping to layer.')) self.action_field_mapping.setWhatsThis( self.tr('Use this tool to assign field mapping in layer.')) self.action_field_mapping.setEnabled(False) self.action_field_mapping.triggered.connect(self.show_field_mapping) self.add_action(self.action_field_mapping, add_to_toolbar=self.full_toolbar) def _create_multi_exposure_action(self): """Create action for showing the multi exposure tool.""" self.action_multi_exposure = QAction( QIcon(resources_path('img', 'icons', 'show-multi-exposure.svg')), self.tr('InaSAFE Multi Exposure Tool'), self.iface.mainWindow()) self.action_multi_exposure.setStatusTip( self.tr('Open the multi exposure tool.')) self.action_multi_exposure.setWhatsThis( self.tr('Open the multi exposure tool.')) self.action_multi_exposure.setEnabled(True) self.action_multi_exposure.triggered.connect(self.show_multi_exposure) self.add_action(self.action_multi_exposure, add_to_toolbar=self.full_toolbar) 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=self.full_toolbar) def _create_rubber_bands_action(self): """Create action for toggling rubber bands.""" icon = resources_path('img', 'icons', 'toggle-rubber-bands.svg') self.action_toggle_rubberbands = QAction( QIcon(icon), self.tr('Toggle Scenario Outlines'), self.iface.mainWindow()) message = self.tr('Toggle rubber bands showing scenario extents.') self.action_toggle_rubberbands.setStatusTip(message) self.action_toggle_rubberbands.setWhatsThis(message) # Set initial state self.action_toggle_rubberbands.setCheckable(True) flag = setting('showRubberBands', False, expected_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).""" if self.hide_developer_buttons: return 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).""" if self.hide_developer_buttons: return default_package = unicode( setting('testPackage', 'safe', expected_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_() # noinspection PyPep8Naming def initGui(self): """Gui initialisation procedure (for QGIS plugin api). .. note:: Don't change the name of this method from initGui! This method is called by QGIS and should be used to set up any graphical user interface elements that should appear in QGIS by default (i.e. before the user performs any explicit action with the plugin). """ self.toolbar = self.iface.addToolBar('InaSAFE') self.toolbar.setObjectName('InaSAFEToolBar') 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_field_mapping_action() self._create_multi_exposure_action() self._create_metadata_converter_action() self._create_osm_downloader_action() self._create_add_osm_layer_action() self._create_add_petabencana_layer_action() self._create_geonode_uploader_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()) self.iface.initializationCompleted.connect( partial(self.show_welcome_message)) 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) # Unload QGIS expressions loaded by the plugin. for qgis_expression in qgis_expressions().keys(): QgsExpression.unregisterFunction(qgis_expression) 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.""" default_package = 'safe' user_package = unicode( setting('testPackage', default_package, expected_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 set_setting('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() package = unicode(setting('testPackage', 'safe', expected_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(iface=self.iface, parent=self.iface.mainWindow()) dialog.show_option_dialog() if dialog.exec_(): # modal self.dock_widget.read_settings() from safe.gui.widgets.message import getting_started_message send_static_message(self.dock_widget, getting_started_message()) # Issue #4734, make sure to update the combobox after update the # InaSAFE option self.dock_widget.get_layers() def show_welcome_message(self): """Show the welcome message.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.options_dialog import OptionsDialog # Do not show by default show_message = False previous_version = StrictVersion(setting('previous_version')) current_version = StrictVersion(inasafe_version) # Set previous_version to the current inasafe_version set_setting('previous_version', inasafe_version) if setting('always_show_welcome_message', expected_type=bool): # Show if it the setting said so show_message = True elif previous_version < current_version: # Always show if the user installed new version show_message = True if show_message: dialog = OptionsDialog(iface=self.iface, parent=self.iface.mainWindow()) dialog.show_welcome_dialog() if dialog.exec_(): # modal self.dock_widget.read_settings() 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): """Show the multi buffer tool.""" 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 show_geonode_uploader(self): """Show the Geonode uploader dialog.""" from safe.gui.tools.geonode_uploader import GeonodeUploaderDialog dialog = GeonodeUploaderDialog(self.iface.mainWindow()) 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() # 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 show_field_mapping(self): """Show InaSAFE Field Mapping.""" from safe.gui.tools.field_mapping_dialog import FieldMappingDialog dialog = FieldMappingDialog( parent=self.iface.mainWindow(), iface=self.iface, ) if dialog.exec_(): # modal LOGGER.debug('Show field mapping accepted') self.dock_widget.layer_changed(self.iface.activeLayer()) else: LOGGER.debug('Show field mapping not accepted') def show_metadata_converter(self): """Show InaSAFE Metadata Converter.""" from safe.gui.tools.metadata_converter_dialog import ( MetadataConverterDialog) dialog = MetadataConverterDialog( parent=self.iface.mainWindow(), iface=self.iface, ) dialog.exec_() def show_multi_exposure(self): """Show InaSAFE Multi Exposure.""" from safe.gui.tools.multi_exposure_dialog import MultiExposureDialog dialog = MultiExposureDialog(self.iface.mainWindow(), self.iface) dialog.exec_() # 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 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: enable_keyword_wizard = False elif not hasattr(layer, 'providerType'): enable_keyword_wizard = False elif layer.providerType() == 'wms': enable_keyword_wizard = False else: enable_keyword_wizard = True try: if layer: if is_raster_layer(layer): enable_field_mapping_tool = False else: keywords = KeywordIO().read_keywords(layer) keywords_version = keywords.get('keyword_version') if not keywords_version: supported = False else: supported = ( is_keyword_version_supported(keywords_version)) if not supported: enable_field_mapping_tool = False else: layer_purpose = keywords.get('layer_purpose') if not layer_purpose: enable_field_mapping_tool = False else: if layer_purpose == layer_purpose_exposure['key']: layer_subcategory = keywords.get('exposure') elif layer_purpose == layer_purpose_hazard['key']: layer_subcategory = keywords.get('hazard') else: layer_subcategory = None field_groups = get_field_groups( layer_purpose, layer_subcategory) if len(field_groups) == 0: # No field group, disable field mapping tool. enable_field_mapping_tool = False else: enable_field_mapping_tool = True else: enable_field_mapping_tool = False except (KeywordNotFoundError, NoKeywordsFoundError, MetadataReadError): # No keywords, disable field mapping tool. enable_field_mapping_tool = False self.action_keywords_wizard.setEnabled(enable_keyword_wizard) self.action_field_mapping.setEnabled(enable_field_mapping_tool) 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 = BeyondTheBorderDialog() icon = QIcon(icon_path) action = QAction(icon, text, parent) action.triggered.connect(callback) action.setEnabled(enabled_flag) if status_tip is not None: action.setStatusTip(status_tip) if whats_this is not None: action.setWhatsThis(whats_this) if add_to_toolbar: self.toolbar.addAction(action) if add_to_menu: self.iface.addPluginToVectorMenu( self.menu, action) if ProcessingConfig.getSetting('ACTIVATE_R'): # RscriptFolder = processing.algs.r.RUtils.RUtils.RScriptsFolder() RscriptFolder = ProcessingConfig.getSetting('R_SCRIPTS_FOLDER') shutil.copyfile(self.plugin_dir+"/rscript/btb_LissageGrille.rsx", RscriptFolder+"/btb_LissageGrille.rsx") shutil.copyfile(self.plugin_dir+"/rscript/btb_Schematisation_de_carreaux.rsx", RscriptFolder+"/btb_Schematisation_de_carreaux.rsx") shutil.copyfile(self.plugin_dir+"/rscript/btb_Schematisation_de_carreaux.rsx.help", RscriptFolder+"/btb_Schematisation_de_carreaux.rsx.help") self.actions.append(action) return action
class Plugin(object): """The QGIS interface implementation for the InaSAFE plugin. This class acts as the 'glue' between QGIS and our custom logic. It creates a toolbar and menu bar entry and launches the InaSAFE user interface if these are activated. """ def __init__(self, iface): """Class constructor. On instantiation, the plugin instance will be assigned a copy of the QGIS iface object which will allow this plugin to access and manipulate the running QGIS instance that spawned it. :param iface:Quantum GIS iface instance. This instance is automatically passed to the plugin by QGIS when it loads the plugin. :type iface: QGisAppInterface """ # Register all the impact functions register_impact_functions() # Save reference to the QGIS interface self.iface = iface self.dock_widget = None self.action_import_dialog = None self.action_save_scenario = None self.action_batch_runner = None self.action_shake_converter = None self.action_minimum_needs = None self.action_minimum_needs_config = None self.action_impact_merge_dlg = None self.key_action = None self.action_options = None self.action_keywords_wizard = None self.action_function_centric_wizard = None self.action_extent_selector = None self.translator = None self.toolbar = None self.wizard = None self.actions = [] # list of all QActions we create for InaSAFE self.action_dock = None self.action_toggle_rubberbands = None self.message_bar_item = None # Flag indicating if toolbar should show only common icons or not self.full_toolbar = False # print self.tr('InaSAFE') # For enable/disable the keyword editor icon self.iface.currentLayerChanged.connect(self.layer_changed) # noinspection PyArgumentList def change_i18n(self, new_locale): """Change internationalisation for the plugin. Override the system locale and then see if we can get a valid translation file for whatever locale is effectively being used. :param new_locale: The new locale i.e. 'id', 'af', etc. :type new_locale: str :raises: TranslationLoadException """ os.environ['INASAFE_LANG'] = str(new_locale) LOGGER.debug( '%s %s %s' % (new_locale, QLocale.system().name(), os.environ['INASAFE_LANG'])) root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..')) translation_path = os.path.join(root, 'safe_qgis', 'i18n', 'inasafe_' + str(new_locale) + '.qm') if os.path.exists(translation_path): self.translator = QTranslator() result = self.translator.load(translation_path) if not result: message = 'Failed to load translation for %s' % new_locale raise TranslationLoadError(message) # noinspection PyTypeChecker,PyCallByClass QCoreApplication.installTranslator(self.translator) LOGGER.debug('%s %s' % (translation_path, os.path.exists(translation_path))) # noinspection PyMethodMayBeStatic def tr(self, message): """Get the translation for a string using Qt translation API. We implement this ourselves since we do not inherit QObject. :param message: String for translation. :type message: str, QString :returns: Translated version of message. :rtype: QString """ # noinspection PyTypeChecker,PyArgumentList,PyCallByClass return QCoreApplication.translate('Plugin', message) def add_action(self, action, add_to_toolbar=True): """Add a toolbar icon to the InaSAFE toolbar. :param action: The action that should be added to the toolbar. :type action: QAction :param add_to_toolbar: Flag indicating whether the action should also be added to the InaSAFE toolbar. Defaults to True. :type add_to_toolbar: bool """ # store in the class list of actions for easy plugin unloading self.actions.append(action) self.iface.addPluginToMenu(self.tr('InaSAFE'), action) if add_to_toolbar: self.toolbar.addAction(action) def _create_dock_toggle_action(self): """Create action for plugin dockable window (show/hide).""" # pylint: disable=W0201 icon = resources_path('img', 'icons', 'icon.svg') self.action_dock = QAction(QIcon(icon), self.tr('Toggle InaSAFE Dock'), self.iface.mainWindow()) self.action_dock.setObjectName('InaSAFEDockToggle') self.action_dock.setStatusTip(self.tr('Show/hide InaSAFE dock widget')) self.action_dock.setWhatsThis(self.tr('Show/hide InaSAFE dock widget')) self.action_dock.setCheckable(True) self.action_dock.setChecked(True) self.action_dock.triggered.connect(self.toggle_dock_visibility) self.add_action(self.action_dock) # -------------------------------------- # Create action for keywords creation wizard # ------------------------------------- def _create_keywords_wizard_action(self): """Create action for keywords creation wizard.""" icon = resources_path('img', 'icons', 'show-keyword-wizard.svg') self.action_keywords_wizard = QAction( QIcon(icon), self.tr('Keywords Creation Wizard'), self.iface.mainWindow()) self.action_keywords_wizard.setStatusTip( self.tr('Open InaSAFE keywords creation wizard')) self.action_keywords_wizard.setWhatsThis( self.tr('Open InaSAFE keywords creation wizard')) self.action_keywords_wizard.setEnabled(False) self.action_keywords_wizard.triggered.connect( self.show_keywords_wizard) self.add_action(self.action_keywords_wizard) def _create_analysis_wizard_action(self): """Create action for IF-centric wizard.""" icon = resources_path('img', 'icons', 'show-wizard.svg') self.action_function_centric_wizard = QAction( QIcon(icon), self.tr('Impact Function Centric Wizard'), self.iface.mainWindow()) self.action_function_centric_wizard.setStatusTip( self.tr('Open InaSAFE impact function centric wizard')) self.action_function_centric_wizard.setWhatsThis( self.tr('Open InaSAFE impact function centric wizard')) self.action_function_centric_wizard.setEnabled(True) self.action_function_centric_wizard.triggered.connect( self.show_function_centric_wizard) self.add_action(self.action_function_centric_wizard) def _create_options_dialog_action(self): """Create action for options dialog.""" icon = resources_path('img', 'icons', 'configure-inasafe.svg') self.action_options = QAction(QIcon(icon), self.tr('Options'), self.iface.mainWindow()) self.action_options.setStatusTip( self.tr('Open InaSAFE options dialog')) self.action_options.setWhatsThis( self.tr('Open InaSAFE options dialog')) self.action_options.triggered.connect(self.show_options) self.add_action(self.action_options, add_to_toolbar=self.full_toolbar) def _create_minimum_needs_action(self): """Create action for minimum needs dialog.""" icon = resources_path('img', 'icons', 'show-minimum-needs.svg') self.action_minimum_needs = QAction( QIcon(icon), self.tr('Minimum Needs Calculator'), self.iface.mainWindow()) self.action_minimum_needs.setStatusTip( self.tr('Open InaSAFE minimum needs calculator')) self.action_minimum_needs.setWhatsThis( self.tr('Open InaSAFE minimum needs calculator')) self.action_minimum_needs.triggered.connect(self.show_minimum_needs) self.add_action(self.action_minimum_needs, add_to_toolbar=self.full_toolbar) def _create_minimum_needs_options_action(self): """Create action for global minimum needs dialog.""" icon = resources_path('img', 'icons', 'show-global-minimum-needs.svg') self.action_minimum_needs_config = QAction( QIcon(icon), self.tr('Minimum Needs Configuration'), self.iface.mainWindow()) self.action_minimum_needs_config.setStatusTip( self.tr('Open InaSAFE minimum needs configuration')) self.action_minimum_needs_config.setWhatsThis( self.tr('Open InaSAFE minimum needs configuration')) self.action_minimum_needs_config.triggered.connect( self.show_minimum_needs_configuration) self.add_action(self.action_minimum_needs_config, add_to_toolbar=self.full_toolbar) def _create_shakemap_converter_action(self): """Create action for converter dialog.""" icon = resources_path('img', 'icons', 'show-converter-tool.svg') self.action_shake_converter = QAction(QIcon(icon), self.tr('Shakemap Converter'), self.iface.mainWindow()) self.action_shake_converter.setStatusTip( self.tr('Open InaSAFE Converter')) self.action_shake_converter.setWhatsThis( self.tr('Open InaSAFE Converter')) self.action_shake_converter.triggered.connect( self.show_shakemap_importer) self.add_action(self.action_shake_converter, add_to_toolbar=self.full_toolbar) def _create_batch_runner_action(self): """Create action for batch runner dialog.""" icon = resources_path('img', 'icons', 'show-batch-runner.svg') self.action_batch_runner = QAction(QIcon(icon), self.tr('Batch Runner'), self.iface.mainWindow()) self.action_batch_runner.setStatusTip(self.tr('Open Batch Runner')) self.action_batch_runner.setWhatsThis(self.tr('Open Batch Runner')) self.action_batch_runner.triggered.connect(self.show_batch_runner) self.add_action(self.action_batch_runner, add_to_toolbar=self.full_toolbar) def _create_save_scenario_action(self): """Create action for save scenario dialog.""" icon = resources_path('img', 'icons', 'save-as-scenario.svg') self.action_save_scenario = QAction(QIcon(icon), self.tr('Save Current Scenario'), self.iface.mainWindow()) message = self.tr('Save current scenario to text file') self.action_save_scenario.setStatusTip(message) self.action_save_scenario.setWhatsThis(message) # noinspection PyUnresolvedReferences self.action_save_scenario.triggered.connect(self.save_scenario) self.add_action(self.action_save_scenario, add_to_toolbar=self.full_toolbar) def _create_osm_downloader_action(self): """Create action for import OSM Dialog.""" icon = resources_path('img', 'icons', 'show-osm-download.svg') self.action_import_dialog = QAction( QIcon(icon), self.tr('OpenStreetMap Downloader'), self.iface.mainWindow()) self.action_import_dialog.setStatusTip( self.tr('OpenStreetMap Downloader')) self.action_import_dialog.setWhatsThis( self.tr('OpenStreetMap Downloader')) self.action_import_dialog.triggered.connect(self.show_osm_downloader) self.add_action(self.action_import_dialog) def _create_add_osm_layer_action(self): """Create action for import OSM Dialog.""" icon = resources_path('img', 'icons', 'add-osm-tiles-layer.svg') self.action_add_osm_layer = QAction( QIcon(icon), self.tr('Add OpenStreetMap Tile Layer'), self.iface.mainWindow()) self.action_add_osm_layer.setStatusTip( self.tr('Add OpenStreetMap Tile Layer')) self.action_add_osm_layer.setWhatsThis( self.tr('Use this to add an OSM layer to your map. ' 'It needs internet access to function.')) self.action_add_osm_layer.triggered.connect(self.add_osm_layer) self.add_action(self.action_add_osm_layer) def _create_add_petajakarta_layer_action(self): """Create action for import OSM Dialog.""" icon = resources_path('img', 'icons', 'add-petajakarta-layer.svg') self.action_add_petajakarta_layer = QAction( QIcon(icon), self.tr('Add PetaJakarta Flood Layer'), self.iface.mainWindow()) self.action_add_petajakarta_layer.setStatusTip( self.tr('Add PetaJakarta Flood Layer')) self.action_add_petajakarta_layer.setWhatsThis( self.tr('Use this to add a PetaJakarta layer to your map. ' 'It needs internet access to function.')) self.action_add_petajakarta_layer.triggered.connect( self.add_petajakarta_layer) self.add_action(self.action_add_petajakarta_layer, add_to_toolbar=False) def _create_impact_merge_action(self): """Create action for impact layer merge Dialog.""" icon = resources_path('img', 'icons', 'show-impact-merge.svg') self.action_impact_merge_dlg = QAction(QIcon(icon), self.tr('Impact Layer Merger'), self.iface.mainWindow()) self.action_impact_merge_dlg.setStatusTip( self.tr('Impact Layer Merger')) self.action_impact_merge_dlg.setWhatsThis( self.tr('Impact Layer Merger')) self.action_impact_merge_dlg.triggered.connect(self.show_impact_merge) self.add_action(self.action_impact_merge_dlg, add_to_toolbar=self.full_toolbar) def _create_rubber_bands_action(self): """Create action for toggling rubber bands.""" icon = resources_path('img', 'icons', 'toggle-rubber-bands.svg') self.action_toggle_rubberbands = QAction( QIcon(icon), self.tr('Toggle Scenario Outlines'), self.iface.mainWindow()) message = self.tr('Toggle rubber bands showing scenario extents.') self.action_toggle_rubberbands.setStatusTip(message) self.action_toggle_rubberbands.setWhatsThis(message) # Set initial state self.action_toggle_rubberbands.setCheckable(True) settings = QSettings() flag = bool(settings.value('inasafe/showRubberBands', False, type=bool)) self.action_toggle_rubberbands.setChecked(flag) # noinspection PyUnresolvedReferences self.action_toggle_rubberbands.triggered.connect( self.dock_widget.toggle_rubber_bands) self.add_action(self.action_toggle_rubberbands) def _create_analysis_extent_action(self): """Create action for analysis extent dialog.""" icon = resources_path('img', 'icons', 'set-extents-tool.svg') self.action_extent_selector = QAction(QIcon(icon), self.tr('Set Analysis Area'), self.iface.mainWindow()) self.action_extent_selector.setStatusTip( self.tr('Set the analysis area for InaSAFE')) self.action_extent_selector.setWhatsThis( self.tr('Set the analysis area for InaSAFE')) self.action_extent_selector.triggered.connect( self.show_extent_selector) self.add_action(self.action_extent_selector) def _create_test_layers_action(self): """Create action for adding layers (developer mode, non final only).""" final_release = release_status() == 'final' settings = QSettings() self.developer_mode = settings.value('inasafe/developer_mode', False, type=bool) if not final_release and self.developer_mode: icon = resources_path('img', 'icons', 'add-test-layers.svg') self.action_add_layers = QAction(QIcon(icon), self.tr('Add Test Layers'), self.iface.mainWindow()) self.action_add_layers.setStatusTip(self.tr('Add test layers')) self.action_add_layers.setWhatsThis(self.tr('Add test layers')) self.action_add_layers.triggered.connect(self.add_test_layers) self.add_action(self.action_add_layers) def _create_dock(self): """Create dockwidget and tabify it with the legend.""" # Import dock here as it needs to be imported AFTER i18n is set up from safe.gui.widgets.dock import Dock self.dock_widget = Dock(self.iface) self.dock_widget.setObjectName('InaSAFE-Dock') self.iface.addDockWidget(Qt.RightDockWidgetArea, self.dock_widget) legend_tab = self.iface.mainWindow().findChild(QApplication, 'Legend') if legend_tab: self.iface.mainWindow().tabifyDockWidget(legend_tab, self.dock_widget) self.dock_widget.raise_() def initGui(self): """Gui initialisation procedure (for QGIS plugin api). .. note:: Don't change the name of this method from initGui! This method is called by QGIS and should be used to set up any graphical user interface elements that should appear in QGIS by default (i.e. before the user performs any explicit action with the plugin). """ self.toolbar = self.iface.addToolBar('InaSAFE') self.toolbar.setObjectName('InaSAFEToolBar') self.dock_widget = None # Now create the actual dock self._create_dock() # And all the menu actions # Configuration Group self._create_dock_toggle_action() self._create_options_dialog_action() self._create_minimum_needs_options_action() self._create_analysis_extent_action() self._create_rubber_bands_action() self._add_spacer_to_menu() self._create_keywords_wizard_action() self._create_analysis_wizard_action() self._add_spacer_to_menu() self._create_osm_downloader_action() self._create_add_osm_layer_action() self._create_add_petajakarta_layer_action() self._create_shakemap_converter_action() self._create_minimum_needs_action() self._create_test_layers_action() self._add_spacer_to_menu() self._create_batch_runner_action() self._create_impact_merge_action() self._create_save_scenario_action() # Hook up a slot for when the dock is hidden using its close button # or view-panels # self.dock_widget.visibilityChanged.connect(self.toggle_inasafe_action) # Also deal with the fact that on start of QGIS dock may already be # hidden. self.action_dock.setChecked(self.dock_widget.isVisible()) def _add_spacer_to_menu(self): """Create a spacer to the menu to separate action groups.""" separator = QAction(self.iface.mainWindow()) separator.setSeparator(True) self.iface.addPluginToMenu(self.tr('InaSAFE'), separator) def clear_modules(self): """Unload inasafe functions and try to return QGIS to before InaSAFE. .. todo:: I think this function can be removed. TS. """ # next lets force remove any inasafe related modules modules = [] for module in sys.modules: if 'inasafe' in module: # Check if it is really one of our modules i.e. exists in the # plugin directory tokens = module.split('.') path = '' for myToken in tokens: path += os.path.sep + myToken parent = os.path.abspath( os.path.join(__file__, os.path.pardir, os.path.pardir)) full_path = os.path.join(parent, path + '.py') if os.path.exists(os.path.abspath(full_path)): LOGGER.debug('Removing: %s' % module) modules.append(module) for module in modules: del (sys.modules[module]) for module in sys.modules: if 'inasafe' in module: print module # Lets also clean up all the path additions that were made package_path = os.path.abspath( os.path.join(os.path.dirname(__file__), os.path.pardir)) LOGGER.debug('Path to remove: %s' % package_path) # We use a list comprehension to ensure duplicate entries are removed LOGGER.debug(sys.path) sys.path = [y for y in sys.path if package_path not in y] LOGGER.debug(sys.path) def unload(self): """GUI breakdown procedure (for QGIS plugin api). .. note:: Don't change the name of this method from unload! This method is called by QGIS and should be used to *remove* any graphical user interface elements that should appear in QGIS. """ # Remove the plugin menu item and icon if self.wizard: self.wizard.deleteLater() for myAction in self.actions: self.iface.removePluginMenu(self.tr('InaSAFE'), myAction) self.iface.removeToolBarIcon(myAction) self.iface.mainWindow().removeDockWidget(self.dock_widget) self.iface.mainWindow().removeToolBar(self.toolbar) self.dock_widget.setVisible(False) self.dock_widget.destroy() self.iface.currentLayerChanged.disconnect(self.layer_changed) def toggle_inasafe_action(self, checked): """Check or un-check the toggle inaSAFE toolbar button. This slot is called when the user hides the inaSAFE panel using its close button or using view->panels. :param checked: True if the dock should be shown, otherwise False. :type checked: bool """ self.action_dock.setChecked(checked) # Run method that performs all the real work def toggle_dock_visibility(self): """Show or hide the dock widget.""" if self.dock_widget.isVisible(): self.dock_widget.setVisible(False) else: self.dock_widget.setVisible(True) self.dock_widget.raise_() def add_test_layers(self): """Add standard test layers.""" from safe.test.utilities import load_standard_layers load_standard_layers() rect = QgsRectangle(106.806, -6.195, 106.837, -6.167) self.iface.mapCanvas().setExtent(rect) def show_extent_selector(self): """Show the extent selector widget for defining analysis extents.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.extent_selector_dialog import ExtentSelectorDialog widget = ExtentSelectorDialog( self.iface, self.iface.mainWindow(), extent=self.dock_widget.extent.user_extent, crs=self.dock_widget.extent.user_extent_crs) widget.clear_extent.connect( self.dock_widget.extent.clear_user_analysis_extent) widget.extent_defined.connect( self.dock_widget.define_user_analysis_extent) # This ensures that run button state is updated on dialog close widget.extent_selector_closed.connect( self.dock_widget.show_next_analysis_extent) # Needs to be non modal to support hide -> interact with map -> show widget.show() # non modal def show_minimum_needs(self): """Show the minimum needs dialog.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.minimum_needs.needs_calculator_dialog import ( NeedsCalculatorDialog) dialog = NeedsCalculatorDialog(self.iface.mainWindow()) dialog.exec_() def show_minimum_needs_configuration(self): """Show the minimum needs dialog.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.minimum_needs.needs_manager_dialog import ( NeedsManagerDialog) dialog = NeedsManagerDialog(parent=self.iface.mainWindow(), dock=self.dock_widget) dialog.exec_() # modal def show_impact_merge(self): """Show the impact layer merge dialog.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.impact_merge_dialog import ImpactMergeDialog dialog = ImpactMergeDialog(self.iface.mainWindow()) dialog.exec_() # modal def show_options(self): """Show the options dialog.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.options_dialog import OptionsDialog dialog = OptionsDialog(self.iface, self.dock_widget, self.iface.mainWindow()) dialog.exec_() # modal def show_keywords_wizard(self): """Show the keywords creation wizard.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.wizard_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_dialog import WizardDialog # Don't break an existing wizard session if accidentally clicked if self.wizard and self.wizard.isVisible(): return # Prevent spawning multiple copies since it is non modal if not self.wizard: self.wizard = WizardDialog(self.iface.mainWindow(), self.iface, self.dock_widget) self.wizard.set_function_centric_mode() # non-modal in order to hide for selecting user extent self.wizard.show() def show_shakemap_importer(self): """Show the converter dialog.""" # import here only so that it is AFTER i18n set up from safe.gui.tools.shake_grid.shakemap_converter_dialog import ( ShakemapConverterDialog) dialog = ShakemapConverterDialog(self.iface.mainWindow()) dialog.exec_() # modal def show_osm_downloader(self): """Show the OSM buildings downloader dialog.""" from safe.gui.tools.osm_downloader_dialog import OsmDownloaderDialog dialog = OsmDownloaderDialog(self.iface.mainWindow(), self.iface) dialog.show() # non modal def show_osm_downloader(self): """Show the OSM buildings downloader dialog.""" from safe.gui.tools.osm_downloader_dialog import OsmDownloaderDialog dialog = OsmDownloaderDialog(self.iface.mainWindow(), self.iface) dialog.show() # non modal def add_osm_layer(self): """Add OSM tile layer to the map. This uses a gdal wrapper around the OSM tile service - see the WorldOSM.gdal file for how it is constructed. """ path = resources_path('osm', 'WorldOSM.gdal') layer = QgsRasterLayer(path, self.tr('OpenStreetMap')) registry = QgsMapLayerRegistry.instance() # For older versions we just add directly to the top of legend if QGis.QGIS_VERSION_INT < 20400: # True flag adds layer directly to legend registry.addMapLayer(layer, True) return # Otherwise try to add it as the last layer in the list # False flag prevents layer being added to legend registry.addMapLayer(layer, False) root = QgsProject.instance().layerTreeRoot() index = len(root.findLayers()) + 1 # LOGGER.info('Inserting layer %s at position %s' % ( # layer.source(), index)) root.insertLayer(index, layer) QgsMapLayerRegistry.instance().addMapLayer(layer) def add_petajakarta_layer(self): """Add petajakarta layer to the map. This uses the PetaJakarta API to fetch the latest floods in JK. See https://petajakarta.org/banjir/en/data/api/#aggregates """ from safe.gui.tools.peta_jakarta_dialog import PetaJakartaDialog dialog = PetaJakartaDialog(self.iface.mainWindow(), self.iface) dialog.show() # non modal def show_batch_runner(self): """Show the batch runner dialog.""" from safe.gui.tools.batch.batch_dialog import BatchDialog dialog = BatchDialog(parent=self.iface.mainWindow(), iface=self.iface, dock=self.dock_widget) dialog.exec_() # modal def save_scenario(self): """Save current scenario to text file""" from safe.gui.tools.save_scenario import SaveScenarioDialog dialog = SaveScenarioDialog(iface=self.iface, dock=self.dock_widget) dialog.save_scenario() def _disable_keyword_tools(self): """Internal helper to disable the keyword and wizard actions.""" self.action_keywords_wizard.setEnabled(False) def layer_changed(self, layer): """Enable or disable keywords editor icon when active layer changes. :param layer: The layer that is now active. :type layer: QgsMapLayer """ if not layer: self._disable_keyword_tools() return if not hasattr(layer, 'providerType'): self._disable_keyword_tools() return if layer.providerType() == 'wms': self._disable_keyword_tools() return if is_raster_layer(layer) and layer.bandCount() > 1: self._disable_keyword_tools() return self.action_keywords_wizard.setEnabled(True) def shortcut_f7(self): """Executed when user press F7 - will show the shakemap importer.""" self.show_shakemap_importer()
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() 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: no exceptions explicitly raised. """ myOverrideFlag = QSettings().value('locale/overrideFlag', QVariant(False)).toBool() myLocaleName = None 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 TranslationLoadException(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) 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.png'), 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/keywords.png'), 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/reload.png'), 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/options.png'), 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/functions-table.png'), 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 dockwidget and tabify it with the legend #-------------------------------------- self.dockWidget = Dock(self.iface) self.iface.addDockWidget(Qt.LeftDockWidgetArea, 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.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 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 keywords editor. 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 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.showImpactFunctionsDoc()
class BaseSTRNode(object): """ Base class for all STR nodes. """ def __init__(self, data, parent=None, view=None, parentWidget=None, isChild=False, styleIfChild=True, rootDepthForHash=1, model=None): self._data = data self._children = [] self._parent = parent self._rootNodeHash = "" self._view = view self._parentWidget = parentWidget self._model = model if parent is not None: parent.addChild(self) #Inherit view from parent self._view = parent.treeView() self._parentWidget = parent.parentWidget() ''' Set the hash of the node that will be taken as the root parent node. In this case it will be level one. Level zero will not have any hash specified (just be an empty string). ''' if self.depth() == rootDepthForHash: self._rootNodeHash = gen_random_string() elif self.depth() > rootDepthForHash: self._rootNodeHash = self._parent.rootHash() #Separator for child text self.separator = ": " if isChild: if styleIfChild: self._styleIfChild = True else: self._styleIfChild = False #Default actions that will be most commonly used by the nodes with data management capabilities self.editAction = QAction( EDIT_ICON, QApplication.translate("BaseSTRNode", "Edit..."), None) self.deleteAction = QAction( DELETE_ICON, QApplication.translate("BaseSTRNode", "Delete"), None) self._expand_action = QAction( QApplication.translate("BaseSTRNode", "Expand"), self._parentWidget) self._collapse_action = QAction( QApplication.translate("BaseSTRNode", "Collapse"), self._parentWidget) def addChild(self, child): ''' Add child to the parent node. ''' self._children.append(child) def insertChild(self, position, child): ''' Append child at the specified position in the list ''' if position < 0 or position > len(self._children): return False self._children.insert(position, child) child._parent = self return True def removeChild(self, position): ''' Remove child at the specified position. ''' if position < 0 or position >= len(self._children): return False child = self._children.pop(position) child._parent = None return True def clear(self): ''' Removes all children in the node. ''' try: del self._children[:] return True except: return False def child(self, row): ''' Get the child node at the specified row. ''' if row < 0 or row >= len(self._children): return None return self._children[row] def childCount(self): ''' Number of children node with the current node as the parent. ''' return len(self._children) def children(self): ''' Returns all the node's children as a list. ''' return self._children def hasParent(self): ''' True if the node has a parent. Otherwise returns False. ''' return True if self._parent else False def parent(self): ''' The parent of this node. ''' return self._parent def treeView(self): ''' Returns the tree view that contains this node. ''' return self._view def parentWidget(self): ''' Returns the main widget that displays the social tenure relationship information. ''' return self._parentWidget def row(self): ''' Return the position of this node in the parent container. ''' if self._parent: return self.parent()._children.index(self) return 0 def icon(self): ''' Return a QIcon for decorating the node. To be implemented by subclasses. ''' return None def id(self): ''' Returns the ID of the model it represents. ''' return -1 def depth(self): ''' Returns the depth/hierarchy of this node. ''' depth = 0 item = self.parent() while item is not None: item = item.parent() depth += 1 return depth def rootHash(self): ''' Returns a hash key that is used to identify the lineage of the child nodes i.e. which node exactly is the 'forefather'. ''' return self._rootNodeHash def styleIfChild(self): ''' Style the parent _title if set to 'True'. This is a read only property. ''' return self._styleIfChild def data(self, column): ''' Returns the data item in the specified specified column index within the list. ''' if column < 0 or column >= len(self._data): raise IndexError return self._data[column] def setData(self, column, value): ''' Set the value of the node data at the given column index. ''' if column < 0 or column >= len(self._data): return False self._data[column] = value return True def model(self): """ :return: Returns the data model associated with this node. Returns 'None' if not defined. :rtype: object """ return self._model def columnCount(self): ''' Return the number of columns. ''' return len(self._data) def column(self, position): ''' Get the data in the specified column. ''' if position < 0 and position >= len(self._data): return None return self._data[position] def removeColumns(self, position, columns): ''' Removes columns in the STR node. ''' if position < 0 or position >= len(self._data): return False for c in range(columns): self._data.pop(position) return True def clearColumns(self): ''' Removes all columns in the node. ''' del self._data[:] def typeInfo(self): return "BASE_NODE" def __repr__(self): return self.typeInfo() def manageActions(self, modelindex, menu): """ Returns the list of actions to be loaded into the context menu of this node when a user right clicks in the tree view. Default actions are for expanding/collapsing child nodes. To be inherited by subclasses for additional custom actions. """ nullAction = QAction( NO_ACTION_ICON, QApplication.translate("BaseSTRNode", "No User Action"), self.parentWidget()) nullAction.setEnabled(False) if not self._view is None: if self._view.isExpanded(modelindex): self._expand_action.setEnabled(False) self._collapse_action.setEnabled(True) else: self._expand_action.setEnabled(True) self._collapse_action.setEnabled(False) #Disconnect then reconnect signals if self.signalReceivers(self._expand_action) > 0: self._expand_action.triggered.disconnect() if self.signalReceivers(self._collapse_action) > 0: self._collapse_action.triggered.disconnect() #Connect expand/collapse signals to the respective actions self._expand_action.triggered.connect( lambda: self._on_expand(modelindex)) self._collapse_action.triggered.connect( lambda: self._on_collapse(modelindex)) menu.addAction(self._expand_action) menu.addAction(self._collapse_action) def _on_expand(self, index): """ Slot raised to expand all children under this node at the specified index. :param index: Location in the data model. :type index: QModelIndex """ if index.isValid(): self._view.expand(index) def _on_collapse(self, index): """ Slot raised to collapse all children under this node at the specified index. :param index: Location in the data model. :type index: QModelIndex """ if index.isValid(): self._view.collapse(index) def onEdit(self, index): ''' Slot triggered when the Edit action of the node is triggered by the user. Subclasses to implement. ''' pass def onDelete(self, index): ''' Slot triggered when the Delete action of the node is triggered by the user. Subclasses to implement. ''' pass def signalReceivers(self, action, signal="triggered()"): ''' Convenience method that returns the number of receivers connected to the signal of the action object. ''' return action.receivers(SIGNAL(signal)) def _concat_names_values(self, display_mapping, formatter): """ Extract model values based on the properties defined by display mapping and concatenates the display-friendly property name with its corresponding value. :param display_mapping: Collection containing a tuple of column name and display name as key and column value. :type display_mapping: dict :param formatter: Collections of functions mapped to the property names that format the corresponding attribute values. :type formatter: dict :return: list of display name-value pairs. :rtype: list """ name_values = [] for col_name_prop, attr_val in display_mapping.iteritems(): prop, prop_display = col_name_prop[0], col_name_prop[1] if prop in formatter: attr_val = formatter[prop](attr_val) name_val = "%s%s %s" % (prop_display, self.separator, attr_val) name_values.append(name_val) return name_values def _property_values(self, model, display_mapping, formatter): """ Extract model values based on the properties defined by display_mapping. :param model: Instance of database model. :param display_mapping: property names and corresponding display-friendly names. :type display_mapping: dict :param formatter: Collections of functions mapped to the property names that format the corresponding attribute values. :type formatter: dict :return: Attribute values as specified in the display_mapping. :rtype: list """ attr_values = [] for prop, disp in display_mapping.iteritems(): attr_val = getattr(model, prop) if prop in formatter: attr_val = formatter[prop](attr_val) attr_values.append(attr_val) return attr_values def _display_mapping(self): """ :return: Property names and their corresponding display names. :rtype: dict """ raise NotImplementedError