Python QMenu.addActions方法代码示例

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import addActions [as 别名]
 def _get_menu(self):
     # main menu
     menu = QMenu()
     main_menu_action_group = QActionGroup(menu)
     main_menu_action_group.setObjectName("main")
     # character menu
     map_action = QAction(menu)
     map_action.setText("Toggle Map")
     main_menu_action_group.addAction(map_action)
     separator = QAction(menu)
     separator.setSeparator(True)
     main_menu_action_group.addAction(separator)
     characters_action = QAction(menu)
     characters_action.setText("Switch Characters")
     main_menu_action_group.addAction(characters_action)
     separator = QAction(menu)
     separator.setSeparator(True)
     main_menu_action_group.addAction(separator)
     settings_action = QAction(menu)
     settings_action.setText("Settings")
     main_menu_action_group.addAction(settings_action)
     quit_action = QAction(menu)
     quit_action.setText("Quit")
     main_menu_action_group.addAction(quit_action)
     menu.addActions(main_menu_action_group.actions())
     menu.triggered[QAction].connect(self._menu_actions)
     return menu

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import addActions [as 别名]
 def contextMenuEvent(self, e):
     """ Event handler.
     """
     menu = QMenu(self)
     menu.addActions([self.load, self.remove, self.clearList])
     # show the menu only if the mouse is pointing a list item
     if self.itemAt(e.pos()):
         menu.popup(e.globalPos())

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import addActions [as 别名]
  def contextMenuEvent(self, event):

    menu = QMenu(self)

    menu.addActions(self.actionFaces.actions())
    menu.addSeparator()
    menu.addAction(self.actionQuit)

    menu.exec_(event.globalPos())

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import addActions [as 别名]
    def __setup_context_menu(self):
        # here's the custom menu (actions will be made in/visible as required)
        rclickmenu = QMenu(self.mod_structure_view)

        rclickmenu.addActions(
            [
                self.action_unset_toplevel,
                self.action_set_toplevel,
                self.action_rename,
                self.action_delete,
                self.action_create_directory,
            ]
        )

        return rclickmenu

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import addActions [as 别名]
    def get_rclickmenu(self, for_view):
        # here's the custom menu (actions will be made in/visible
        # as required)
        rclickmenu = QMenu(for_view)

        rclickmenu.addActions(
            [
                self.action_unset_toplevel,
                self.action_set_toplevel,
                self.action_rename,
                self.action_delete,
                self.action_create_directory,
            ]
        )

        return rclickmenu

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import addActions [as 别名]
 def __install_toolbar(self, rela_actions):
     menu = QMenu()
     tool_button = QToolButton()
     tool_button.setIcon(QIcon(":img/create_new_relation"))
     tool_button.setMenu(menu)
     tool_button.setPopupMode(QToolButton.InstantPopup)
     for item in self.TOOLBAR_ITEMS:
         if item:
             if item == "relation_menu":
                 # Install menu for relation
                 menu.addActions(rela_actions)
                 self.toolbar.addWidget(tool_button)
             else:
                 self.toolbar.addAction(self.__ACTIONS[item])
         else:
             self.toolbar.addSeparator()

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import addActions [as 别名]
    def _fill_context_menu_with_model_item_actions(self, context_menu: QMenu):
        """
        Find all model items that should be available in the context menu and create QActions for each, by
        using the available logic in popupmenu.PopupMenu.
        """
        # Get phrase folders to add to main menu
        logger.info("Rebuilding model item actions, adding all items marked for access through the tray icon.")
        folders = [folder for folder in self.config_manager.allFolders if folder.show_in_tray_menu]
        items = [item for item in self.config_manager.allItems if item.show_in_tray_menu]
        # Only extract the QActions, but discard the PopupMenu instance.
        # This is done, because the PopupMenu class is not directly usable as a context menu here.
        menu = popupmenu.PopupMenu(self.app.service, folders, items, False, "AutoKey")
        new_item_actions = menu.actions()
        context_menu.addActions(new_item_actions)
        for action in new_item_actions:  # type: QAction
            # QMenu does not take the ownership when adding QActions, so manually re-parent all actions.
            # This causes the QActions to be destroyed when the context menu is cleared or re-created.
            action.setParent(context_menu)

        if not context_menu.isEmpty():
            # Avoid a stray separator line, if no items are marked for display in the context menu.
            context_menu.addSeparator()

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import addActions [as 别名]
 def initMenu(self):
     """
     Public slot to initialize the multi project menu.
     
     @return the menu generated (QMenu)
     """
     menu = QMenu(self.tr('&Multiproject'), self.parent())
     self.recentMenu = QMenu(self.tr('Open &Recent Multiprojects'),
                             menu)
     
     self.__menus = {
         "Main": menu,
         "Recent": self.recentMenu,
     }
     
     # connect the aboutToShow signals
     self.recentMenu.aboutToShow.connect(self.__showContextMenuRecent)
     self.recentMenu.triggered.connect(self.__openRecent)
     menu.aboutToShow.connect(self.__showMenu)
     
     # build the main menu
     menu.setTearOffEnabled(True)
     menu.addActions(self.actGrp1.actions())
     self.menuRecentAct = menu.addMenu(self.recentMenu)
     menu.addSeparator()
     menu.addAction(self.closeAct)
     menu.addSeparator()
     menu.addAction(self.saveAct)
     menu.addAction(self.saveasAct)
     menu.addSeparator()
     menu.addAction(self.addProjectAct)
     menu.addSeparator()
     menu.addAction(self.propsAct)
     
     self.menu = menu
     return menu

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import addActions [as 别名]
class SuggestionsDialog(QDialog, Ui_SuggestionsDialog, WindowState):

    ROLE = 'suggestions'

    WORDS_RX = re.compile(r'[-\'"\w]+|[^\w\s]')

    STYLE_TRANSLATION, STYLE_STROKES = range(2)

    # Anatomy of the text document:
    # - "root" frame:
    #  - 0+ "suggestions" frames
    #   - 1+ "translation" frames
    #    - 1-10 "strokes" frames

    def __init__(self, engine):
        super(SuggestionsDialog, self).__init__()
        self.setupUi(self)
        suggestions = SuggestionsWidget()
        self.layout().replaceWidget(self.suggestions, suggestions)
        self.suggestions = suggestions
        self._engine = engine
        self._words = u''
        self._last_suggestions = None
        # Toolbar.
        self.layout().addWidget(ToolBar(
            self.action_ToggleOnTop,
            self.action_SelectFont,
            self.action_Clear,
        ))
        self.action_Clear.setEnabled(False)
        # Font popup menu.
        self._font_menu = QMenu()
        self._font_menu_text = QAction(_('&Text'), self._font_menu)
        self._font_menu_strokes = QAction(_('&Strokes'), self._font_menu)
        self._font_menu.addActions([self._font_menu_text, self._font_menu_strokes])
        engine.signal_connect('translated', self.on_translation)
        self.suggestions.setFocus()
        self.restore_state()
        self.finished.connect(self.save_state)

    def _get_font(self, name):
        return getattr(self.suggestions, name)

    def _set_font(self, name, font):
        setattr(self.suggestions, name, font)

    def _restore_state(self, settings):
        for name in (
            'text_font',
            'strokes_font',
        ):
            font_string = settings.value(name)
            if font_string is None:
                continue
            font = QFont()
            if not font.fromString(font_string):
                continue
            self._set_font(name, font)

    def _save_state(self, settings):
        for name in (
            'text_font',
            'strokes_font',
        ):
            font = self._get_font(name)
            font_string = font.toString()
            settings.setValue(name, font_string)

    def _show_suggestions(self, suggestion_list):
        self.suggestions.prepend(suggestion_list)
        self.action_Clear.setEnabled(True)

    @staticmethod
    def tails(ls):
        ''' Return all tail combinations (a la Haskell)

            tails :: [x] -> [[x]]
            >>> tails('abcd')
            ['abcd', 'bcd', 'cd', d']

        '''

        for i in range(len(ls)):
            yield ls[i:]

    def on_translation(self, old, new):
        for action in old:
            remove = len(action.text)
            self._words = self._words[:-remove]
            self._words = self._words + action.replace

        for action in new:
            remove = len(action.replace)
            if remove > 0:
                self._words = self._words[:-remove]
            self._words = self._words + action.text

        # Limit phrasing memory to 100 characters, because most phrases probably
        # don't exceed this length
        self._words = self._words[-100:]
#.........这里部分代码省略.........

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import addActions [as 别名]
class SuggestionsDialog(Tool, Ui_SuggestionsDialog):

    ''' Suggest possible strokes for the last written words. '''

    TITLE = _('Suggestions')
    ICON = ':/lightbulb.svg'
    ROLE = 'suggestions'
    SHORTCUT = 'Ctrl+J'

    WORD_RX = re.compile(r'(?:\w+|[^\w\s]+)\s*')

    STYLE_TRANSLATION, STYLE_STROKES = range(2)

    # Anatomy of the text document:
    # - "root" frame:
    #  - 0+ "suggestions" frames
    #   - 1+ "translation" frames
    #    - 1-10 "strokes" frames

    def __init__(self, engine):
        super(SuggestionsDialog, self).__init__(engine)
        self.setupUi(self)
        self._last_suggestions = None
        # Toolbar.
        self.layout().addWidget(ToolBar(
            self.action_ToggleOnTop,
            self.action_SelectFont,
            self.action_Clear,
        ))
        self.action_Clear.setEnabled(False)
        # Font popup menu.
        self._font_menu = QMenu()
        self._font_menu_text = QAction(_('&Text'), self._font_menu)
        self._font_menu_strokes = QAction(_('&Strokes'), self._font_menu)
        self._font_menu.addActions([self._font_menu_text, self._font_menu_strokes])
        engine.signal_connect('translated', self.on_translation)
        self.suggestions.setFocus()
        self.restore_state()
        self.finished.connect(self.save_state)

    def _get_font(self, name):
        return getattr(self.suggestions, name)

    def _set_font(self, name, font):
        setattr(self.suggestions, name, font)

    def _restore_state(self, settings):
        for name in (
            'text_font',
            'strokes_font',
        ):
            font_string = settings.value(name)
            if font_string is None:
                continue
            font = QFont()
            if not font.fromString(font_string):
                continue
            self._set_font(name, font)
        ontop = settings.value('ontop', None, bool)
        if ontop is not None:
            self.action_ToggleOnTop.setChecked(ontop)
            self.on_toggle_ontop(ontop)

    def _save_state(self, settings):
        for name in (
            'text_font',
            'strokes_font',
        ):
            font = self._get_font(name)
            font_string = font.toString()
            settings.setValue(name, font_string)
        ontop = bool(self.windowFlags() & Qt.WindowStaysOnTopHint)
        settings.setValue('ontop', ontop)

    def _show_suggestions(self, suggestion_list):
        self.suggestions.append(suggestion_list)
        self.action_Clear.setEnabled(True)

    @staticmethod
    def tails(ls):
        ''' Return all tail combinations (a la Haskell)

            tails :: [x] -> [[x]]
            >>> tails('abcd')
            ['abcd', 'bcd', 'cd', d']

        '''

        for i in range(len(ls)):
            yield ls[i:]

    def on_translation(self, old, new):

        # Check for new output.
        for a in reversed(new):
            if a.text and not a.text.isspace():
                break
        else:
            return

#.........这里部分代码省略.........

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import addActions [as 别名]
    def setupTextActions(self):
        tb = QToolBar(self)
        tb.setWindowTitle("Format Actions")
        self.addToolBar(tb)

        menu = QMenu("F&ormat", self)
        self.menuBar().addMenu(menu)

        self.actionTextBold = QAction(
                QIcon.fromTheme('format-text-bold',
                        QIcon(rsrcPath + '/textbold.png')),
                "&Bold", self, priority=QAction.LowPriority,
                shortcut=Qt.CTRL + Qt.Key_B, triggered=self.textBold,
                checkable=True)
        bold = QFont()
        bold.setBold(True)
        self.actionTextBold.setFont(bold)
        tb.addAction(self.actionTextBold)
        menu.addAction(self.actionTextBold)

        self.actionTextItalic = QAction(
                QIcon.fromTheme('format-text-italic',
                        QIcon(rsrcPath + '/textitalic.png')),
                "&Italic", self, priority=QAction.LowPriority,
                shortcut=Qt.CTRL + Qt.Key_I, triggered=self.textItalic,
                checkable=True)
        italic = QFont()
        italic.setItalic(True)
        self.actionTextItalic.setFont(italic)
        tb.addAction(self.actionTextItalic)
        menu.addAction(self.actionTextItalic)

        self.actionTextUnderline = QAction(
                QIcon.fromTheme('format-text-underline',
                        QIcon(rsrcPath + '/textunder.png')),
                "&Underline", self, priority=QAction.LowPriority,
                shortcut=Qt.CTRL + Qt.Key_U, triggered=self.textUnderline,
                checkable=True)
        underline = QFont()
        underline.setUnderline(True)
        self.actionTextUnderline.setFont(underline)
        tb.addAction(self.actionTextUnderline)
        menu.addAction(self.actionTextUnderline)

        menu.addSeparator()

        grp = QActionGroup(self, triggered=self.textAlign)

        # Make sure the alignLeft is always left of the alignRight.
        if QApplication.isLeftToRight():
            self.actionAlignLeft = QAction(
                    QIcon.fromTheme('format-justify-left',
                            QIcon(rsrcPath + '/textleft.png')),
                    "&Left", grp)
            self.actionAlignCenter = QAction(
                    QIcon.fromTheme('format-justify-center',
                            QIcon(rsrcPath + '/textcenter.png')),
                    "C&enter", grp)
            self.actionAlignRight = QAction(
                    QIcon.fromTheme('format-justify-right',
                            QIcon(rsrcPath + '/textright.png')),
                    "&Right", grp)
        else:
            self.actionAlignRight = QAction(
                    QIcon.fromTheme('format-justify-right',
                            QIcon(rsrcPath + '/textright.png')),
                    "&Right", grp)
            self.actionAlignCenter = QAction(
                    QIcon.fromTheme('format-justify-center',
                            QIcon(rsrcPath + '/textcenter.png')),
                    "C&enter", grp)
            self.actionAlignLeft = QAction(
                    QIcon.fromTheme('format-justify-left',
                            QIcon(rsrcPath + '/textleft.png')),
                    "&Left", grp)
 
        self.actionAlignJustify = QAction(
                QIcon.fromTheme('format-justify-fill',
                        QIcon(rsrcPath + '/textjustify.png')),
                "&Justify", grp)

        self.actionAlignLeft.setShortcut(Qt.CTRL + Qt.Key_L)
        self.actionAlignLeft.setCheckable(True)
        self.actionAlignLeft.setPriority(QAction.LowPriority)

        self.actionAlignCenter.setShortcut(Qt.CTRL + Qt.Key_E)
        self.actionAlignCenter.setCheckable(True)
        self.actionAlignCenter.setPriority(QAction.LowPriority)

        self.actionAlignRight.setShortcut(Qt.CTRL + Qt.Key_R)
        self.actionAlignRight.setCheckable(True)
        self.actionAlignRight.setPriority(QAction.LowPriority)

        self.actionAlignJustify.setShortcut(Qt.CTRL + Qt.Key_J)
        self.actionAlignJustify.setCheckable(True)
        self.actionAlignJustify.setPriority(QAction.LowPriority)

        tb.addActions(grp.actions())
        menu.addActions(grp.actions())
        menu.addSeparator()
#.........这里部分代码省略.........

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import addActions [as 别名]
class LibraryUI(QTreeWidget):
    trackChange = pyqtSignal(QTreeWidgetItem, int)
    unknownTrack = pyqtSignal(str)
    meta = ["TRACKNUMBER", "TITLE", "ALBUMARTIST", "ALBUM", "LENGTH", "BITRATE", "STYLE"]

    def __init__(self):
        super().__init__()
        self.setIndentation(0)
        self.setSortingEnabled(True)
        self.setContextMenuPolicy(Qt.CustomContextMenu)
        self.setSelectionMode(QAbstractItemView.ExtendedSelection)
        self.metadataUI = MetadataUI()
        self.songMenu = QMenu("Actions")
        self.addMenu = QMenu("Actions")
        self._connect_widgets()
        self._init_menus()

    def init_playlist(self, lib):
        for song_meta in lib.values():
            info = ['' for i in range(7)]
            try:
                for i in range(7):
                    if i == 4:
                        length = int(song_meta.get(self.meta[i])[0]) / 1000
                        mins = int(length / 60)
                        secs = int(length - 60 * mins)
                        info[i] = str(mins) + ":%02d" % secs
                    elif i == 5:
                        info[i] = song_meta.get(self.meta[i])[0] + " kbit/s"
                    else:
                        info[i] = song_meta.get(self.meta[i])[0]
            except:
                pass

            item = QTreeWidgetItem()
            for i in range(7):
                item.setText(i, info[i])

            item.setData(0, 1, QUrl.fromLocalFile(song_meta.get("DIR")))
            self.addTopLevelItem(item)

        headers = ["#", "Title", "Artist", "Album", "Dur.", "Bitrate", "Genre"]
        self.setColumnCount(6)
        self.header().setDefaultAlignment(Qt.AlignCenter)
        self.setHeaderLabels(headers)
        self.setColumnWidth(0, 50)
        self.setColumnWidth(1, 200)
        self.setColumnWidth(2, 150)
        self.setColumnWidth(3, 150)
        self.setColumnWidth(4, 50)
        self.setColumnWidth(5, 100)
        self.setColumnWidth(6, 50)

    def next_track(self):
        item = self.itemBelow(self.currentItem())
        if item is None:
            item = self.topLevelItem(0)
        self.setCurrentItem(item)
        self.trackChange.emit(item, 0)

    def prev_track(self):
        item = self.itemAbove(self.currentItem())
        if item is None:
            item = self.topLevelItem(self.topLeveLitemCount() - 1)
        self.setCurrentItem(item)
        self.trackChange.emit(item, 0)

    def _connect_widgets(self):
        self.customContextMenuRequested.connect(self.show_menu)
        self.metadataUI.save_metadata.connect(self.save_metadata)
        self.metadataUI.closeButton.clicked.connect(self.close_metadata)

    @pyqtSlot(QPoint)
    def show_menu(self, point):
        if self.currentItem() is None:
            self.addMenu.exec(self.mapToGlobal(point))
        else:
            self.songMenu.exec(self.mapToGlobal(point))

    def _init_menus(self):
        self._init_song_menu()
        self._init_add_menu()

    def _init_add_menu(self):
        self.menuAdd = QAction("Add Songs...", self.addMenu)
        self.addMenu.addAction(self.menuAdd)

    def _init_song_menu(self):
        self.menuPlay = QAction("Play Song", self.songMenu)
        self.menuEdit = QAction("Edit Metadata", self.songMenu)
        self.songMenu.addActions([self.menuPlay, self.menuEdit])
        self.menuPlay.triggered.connect(self.current_track)
        self.menuEdit.triggered.connect(self.show_metadata)

    def current_track(self):
        self.trackChange.emit(self.currentItem(), 0)

    def show_metadata(self):
        self.setEnabled(False)
        self.metadataUI.load_data(self.currentItem())
#.........这里部分代码省略.........

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import addActions [as 别名]
	def __init__(self, supported_exts, parent=None):
		super().__init__(parent)

		self._diasshowRunning = False
		# a dummy widget to center actions
		spacer1 = QWidget()
		spacer1.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
		self.addWidget(spacer1)

		self.supportedExts = supported_exts
		self._fromFile = self.addAction(QIcon("icons/image-outline.svg"), "", self.chooseFile) # load images from file
		self._fromFile.setToolTip("Load image")
		self._fromFolder = self.addAction(QIcon("icons/folder-open.svg"), "", self.chooseFolder) # load images from folder
		self._fromFolder.setToolTip("Load from directory")

		# View in native size, fit width, fit height or fit image
		self._imageMode = QToolButton(self)
		self._imageMode.setIcon(QIcon("icons/eye-outline.svg"))
		self._imageMode.setToolTip("Image view mode")
		self._imageMode.setPopupMode(QToolButton.InstantPopup)
		self.addWidget(self._imageMode)
		
		# imageMode menu
		imageModeMenu = QMenu(self)
		imageModeActions = QActionGroup(imageModeMenu)
		imModeAct1 = imageModeActions.addAction("Native size")
		imModeAct1.setCheckable(True)
		imModeAct1.triggered.connect(lambda: self.imageModeChanged.emit(0))
		imModeAct2 = imageModeActions.addAction("Fit in view")
		imModeAct2.setCheckable(True)
		imModeAct2.triggered.connect(lambda: self.imageModeChanged.emit(1))
		imModeAct3 = imageModeActions.addAction("Fit width")
		imModeAct3.setCheckable(True)
		imModeAct3.triggered.connect(lambda: self.imageModeChanged.emit(2))
		imModeAct4 = imageModeActions.addAction("Fit height")
		imModeAct4.setCheckable(True)
		imModeAct4.triggered.connect(lambda: self.imageModeChanged.emit(3))
		imageModeActions.setExclusive(True)
		imageModeMenu.addActions(imageModeActions.actions())
		self._imageMode.setMenu(imageModeMenu)

		
		self._imgDirection = self.addAction(QIcon("icons/arrow-move-outline.svg"), "", self.imageDirectionChanged.emit) # Horizontal or Vertical
		self._imgDirection.setToolTip("Toggle image direction")

		# start or stop diasshow
		self._playDias = self.addAction(QIcon("icons/media-play-outline.svg"), "", self.diasshowState)
		self._playDias.setToolTip("Start/stop diasshow")

		#diasshow menu
		self._diasMenu = QMenu(self)
		self._diasMenu.addAction("5 seconds", lambda: self.diasshowState(5))
		self._diasMenu.addAction("10 seconds", lambda: self.diasshowState(10))
		self._diasMenu.addAction("30 seconds", lambda: self.diasshowState(30))
		self._diasMenu.addAction("5 minutes", lambda: self.diasshowState(60*5))
		self._diasMenu.addAction("10 minutes", lambda: self.diasshowState(600))
		self._playDias.setMenu(self._diasMenu)


		self._zoomIn = self.addAction(QIcon("icons/zoom-in-outline.svg"), "", lambda: self.zoomChanged.emit(True))
		self._zoomOut = self.addAction(QIcon("icons/zoom-out-outline.svg"), "", lambda: self.zoomChanged.emit(False))
		self._rotateCW = self.addAction(QIcon("icons/rotate-cw-outline.svg"), "", self.rotateChanged.emit) # Clockwise
		self._rotateCW.setToolTip("Rotate Clockwise")
		#self._rotateCCW = self.addAction("Rotate Left") # Counter clockwise

		# a dummy widget to center actions
		spacer2 = QWidget()
		spacer2.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred)
		self.addWidget(spacer2)

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import addActions [as 别名]
class vMCDA(object):

	def __init__(self, iface):
		# Save the reference to the QGIS interface
		self.iface = iface
		#initialize plugin directory
		self.pluginDir = os.path.dirname(__file__)
		# initialize locale
		locale = QSettings().value("locale/userLocale")[0:2]
		localePath = os.path.join(self.pluginDir, 'i18n', 'opeNoise_{}.qm'.format(locale))
		if os.path.exists(localePath):
			self.translator = QTranslator()
			self.translator.load(localePath)
			if qVersion() > '4.3.3':
				QCoreApplication.installTranslator(self.translator)

	def initGui(self):	# aggiunge alla GUI di QGis i pulsanti per richiamare il plugin
		# creiamo l'azione che lancerà il plugin
		
		self.geoMCDAmenu = QMenu(QCoreApplication.translate("vectorMCDA", "&vectorMCDA"))
		self.geoMCDAmenu.setIcon(QIcon(":/plugins/VectorMCDA/icons/Tree.png"))

		self.actionWeightedSum = QAction("geoWeightedSum",self.iface.mainWindow() )
		self.actionWeightedSum.triggered.connect(self.runGeoWeightedSum )

		self.actionTOPSIS = QAction( "geoTOPSIS", self.iface.mainWindow() )
		self.actionTOPSIS.triggered.connect(self.runGeoTOPSIS )

		self.actionFuzzy = QAction( "geoFuzzy", self.iface.mainWindow() )
		self.actionFuzzy.triggered.connect(self.runGeoFuzzy )
		self.actionFuzzy.setDisabled(True)

		self.actionElectre = QAction( "geoConcordance", self.iface.mainWindow() )
		self.actionElectre.triggered.connect(self.runGeoElectre )

		self.actionPromethee = QAction( "geoPromethee", self.iface.mainWindow() )
		self.actionPromethee.triggered.connect(self.runGeoPromethee )

		self.actionRSDB = QAction( "geoRSDB", self.iface.mainWindow() )
		self.actionRSDB.triggered.connect(self.runGeoRSDB )

		self.actionRSDB = QAction( "geoRULES", self.iface.mainWindow() )
		self.actionRSDB.triggered.connect(self.runGeoRULES )

		self.actionXMCDA = QAction( "geoXMCDA", self.iface.mainWindow() )
		self.actionXMCDA.triggered.connect(self.runGeoXMCDA )
		
		self.actionUmbriaSuit = QAction( "geoUmbriaSUIT", self.iface.mainWindow() )
		self.actionUmbriaSuit.triggered.connect(self.runGeoUmbriaSuit )
		self.actionFuzzy.setDisabled(True)
		
		#self.actionTEMPLATE = QAction( "geoTEMPLATE", self.iface.mainWindow() )
		#self.actionTEMPLATE.triggered.connect(self.runGeoTEMPLATE )

		# aggiunge il plugin alla toolbar
		self.geoMCDAmenu.addActions([self.actionWeightedSum,self.actionTOPSIS,self.actionFuzzy,\
			self.actionElectre,self.actionPromethee,self.actionRSDB,self.actionXMCDA,self.actionUmbriaSuit])
		self.menu = self.iface.pluginMenu()
		self.menu.addMenu( self.geoMCDAmenu )


	def unload(self):	# rimuove dalla GUI i pulsanti aggiunti dal plugin
		#self.iface.removeToolBarIcon( self.action )
		self.iface.removePluginMenu( "&geoWeightedSum", self.actionWeightedSum )
		self.iface.removePluginMenu( "&geoTOPSIS", self.actionTOPSIS )
		self.iface.removePluginMenu( "&geoFuzzy", self.actionFuzzy )
		self.iface.removePluginMenu( "&geoConcordance", self.actionElectre )
		self.iface.removePluginMenu( "&geoPromethee", self.actionPromethee )
		self.iface.removePluginMenu( "&geoRSDB", self.actionRSDB )
		self.iface.removePluginMenu( "&geoRULES", self.actionRSDB )
		self.iface.removePluginMenu( "&geoXMCDA", self.actionXMCDA )
		self.iface.removePluginMenu( "&geoUmbriaSuit", self.actionUmbriaSuit )
		#self.iface.removePluginMenu( "&geoTEMPLATE", self.actionTEMPLATE )


	def runGeoWeightedSum(self):	# richiamato al click sull'azione
		from .geoWeightedSum import geoWeightedSumDialog
		self.activeLayer = self.iface.activeLayer()
		if ((self.activeLayer == None) or (self.activeLayer.type() != QgsMapLayer.VectorLayer)):
			result=QMessageBox.question(self.iface.mainWindow(), "VectorMCDA",
			("No active layer found\n" "Please make active one or more vector layer\n" \
            "Do you need documents or data ?"), QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
			if result  == QMessageBox.Yes:
				webbrowser.open("http://maplab.alwaysdata.net/geomcda.html")
		else:
			dlg = geoWeightedSumDialog(self.iface)
			dlg.exec_()

	def runGeoTOPSIS(self):	# richiamato al click sull'azione
		from .geoTOPSIS import geoTOPSISDialog
		self.activeLayer = self.iface.activeLayer()
		if ((self.activeLayer == None) or (self.activeLayer.type() != QgsMapLayer.VectorLayer)):
			result=QMessageBox.question(self.iface.mainWindow(), "VectorMCDA",
			("No active layer found\n" "Please make active one or more vector layer\n" \
            "Do you need documents or data ?"), QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
			if result  == QMessageBox.Yes:
				webbrowser.open("http://maplab.alwaysdata.net/geomcda.html")
		else:
			dlg = geoTOPSISDialog(self.iface)
			dlg.exec_()
#.........这里部分代码省略.........