Python QMenu.addMenu方法代码示例

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addMenu [as 别名]
 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))

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addMenu [as 别名]
    def process_custom_menu(self, point):
        item = self.select_item_at(point)
        if not item:
            return

        node = item.node
        menu = QMenu(self.view)

        # Populate menu
        if node.tag == 'run':
            menu.addAction(self.actGetInfoSimulationRuns)
            menu.addAction(self.actDeleteRun)
        elif node.tag == 'indicator_batches':
            menu.addAction(self.actAddNewIndicatorBatch)
        elif node.tag == 'simulation_runs':
            menu.addAction(self.actImportRun)
        elif node.tag == 'indicator_batch':
            menu.addAction(self.actAddVisualizationToBatch)
            run_batch_on_menu = QMenu('Run indicator batch on...')
            self._createBatchRunMenu(run_batch_on_menu)
            menu.addMenu(run_batch_on_menu)

        elif node.tag == 'batch_visualization': # get('type') == 'batch_visualization':
            menu.addAction(self.actConfigureExistingBatchIndicatorVis)

        self.add_default_menu_items_for_node(node, menu)

        if not menu.isEmpty():
            menu.exec_(QCursor.pos())

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addMenu [as 别名]
    def process_custom_menu(self, point):
        ''' See XmlController for documentation '''
        item = self.select_item_at(point)
        if not item:
            return
        menu = QMenu()
        node = item.node

        if node.get('executable') == 'True':
            menu.addAction(self.actRunScenario)
        elif node.get('type') in ['selectable', 'model_choice']:
            menu.addAction(self.actMoveNodeUp)
            menu.addAction(self.actMoveNodeDown)
        elif node.tag == 'models_to_run': # special case of a selectable list
            models_menu = QMenu(menu)
            models_menu.setTitle('Add model to run')
            models_menu.setIcon(IconLibrary.icon('add'))
            available_model_names = get_model_names(self.project)
            for model_name in available_model_names:
                cb = lambda x = model_name, y = self.selected_index(): self.addModel(y, x)
                action = self.create_action('model', model_name, cb)
                models_menu.addAction(action)
            menu.addMenu(models_menu)

        self.add_default_menu_items_for_node(node, menu)

        if not menu.isEmpty():
            menu.exec_(QCursor.pos())

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addMenu [as 别名]
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 item in layer.contexts:
        if isinstance(item, QAction):
            menu.addAction(item)
        elif isinstance(item, QMenu):
            menu.addMenu(item)

    menu.exec_(pos)

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addMenu [as 别名]
 def contextMenuEvent(self, e):
     menu = QMenu(self)
     subMenu = QMenu(menu)
     titleHistoryMenu = QCoreApplication.translate("PythonConsole", "Command History")
     subMenu.setTitle(titleHistoryMenu)
     subMenu.addAction(
         QCoreApplication.translate("PythonConsole", "Show"),
         self.showHistory, 'Ctrl+Shift+SPACE')
     subMenu.addSeparator()
     subMenu.addAction(
         QCoreApplication.translate("PythonConsole", "Save"),
         self.writeHistoryFile)
     subMenu.addSeparator()
     subMenu.addAction(
         QCoreApplication.translate("PythonConsole", "Clear File"),
         self.clearHistory)
     subMenu.addAction(
         QCoreApplication.translate("PythonConsole", "Clear Session"),
         self.clearHistorySession)
     menu.addMenu(subMenu)
     menu.addSeparator()
     copyAction = menu.addAction(
         QCoreApplication.translate("PythonConsole", "Copy"),
         self.copy, QKeySequence.Copy)
     pasteAction = menu.addAction(
         QCoreApplication.translate("PythonConsole", "Paste"),
         self.paste, QKeySequence.Paste)
     copyAction.setEnabled(False)
     pasteAction.setEnabled(False)
     if self.hasSelectedText():
         copyAction.setEnabled(True)
     if QApplication.clipboard().text():
         pasteAction.setEnabled(True)
     menu.exec_(self.mapToGlobal(e.pos()))

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addMenu [as 别名]
    def _menu_context_tree(self, point):
        index = self.indexAt(point)
        if not index.isValid():
            return

        item = self.itemAt(point)
        handler = None
        menu = QMenu(self)
        if item.isFolder or item.parent() is None:
            self._add_context_menu_for_folders(menu, item)
        elif not item.isFolder:
            self._add_context_menu_for_files(menu, item)
        if item.parent() is None:
            #get the extra context menu for this projectType
            handler = settings.get_project_type_handler(item.projectType)
            self._add_context_menu_for_root(menu, item)

        #menu for all items (legacy API)!
        extra_menus = self.extra_menus.get('all', ())
        #menu for all items!
        extra_menus_by_scope = self.extra_menus_by_scope['all']
        for m in (extra_menus + extra_menus_by_scope):
            if isinstance(m, QMenu):
                menu.addSeparator()
                menu.addMenu(m)
        #menu for the Project Type(if present)
        if handler:
            for m in handler.get_context_menus():
                if isinstance(m, QMenu):
                    menu.addSeparator()
                    menu.addMenu(m)
        #show the menu!
        menu.exec_(QCursor.pos())

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addMenu [as 别名]
    def _menu_context_tree(self, point, isRoot=False, root_path=None):
        index = self.indexAt(point)
        if not index.isValid() and not isRoot:
            return

        handler = None
        menu = QMenu(self)
        if isRoot or self.model().isDir(index):
            self._add_context_menu_for_folders(menu, isRoot, root_path)
        else:
            filename = self.model().fileName(index)
            lang = file_manager.get_file_extension(filename)
            self._add_context_menu_for_files(menu, lang)
        if isRoot:
            #get the extra context menu for this projectType
            handler = settings.get_project_type_handler(
                self.project.project_type)
            self._add_context_menu_for_root(menu)

        menu.addMenu(self._folding_menu)

        #menu for the Project Type(if present)
        if handler:
            for m in handler.get_context_menus():
                if isinstance(m, QMenu):
                    menu.addSeparator()
                    menu.addMenu(m)
        #show the menu!
        menu.exec_(QCursor.pos())

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addMenu [as 别名]
    def textEffectMenu(self):
        format = self.currentCharFormat()
        cursor = self.textCursor()
        blockformat = cursor.blockFormat()
        menu = QMenu("Text Effect")
        for text, shortcut, data, checked in (
                ("&Bold", "Ctrl+B", notetextedit.Bold,
                 self.fontWeight() > QFont.Normal),
                ("&Italic", "Ctrl+I", notetextedit.Italic,
                 self.fontItalic()),
                ("&Monospaced", None, notetextedit.Code,
                 self.fontFixedPitch())
                ):

            action = menu.addAction(text, self.setTextEffect)
            #if shortcut is not None:
                #action.setShortcut(QKeySequence(shortcut)) # becau
            action.setData(QVariant(data))
            action.setCheckable(True)
            action.setChecked(checked)

        menu.addSeparator()

        action = menu.addAction("Anchor", self.setTextEffect)
        action.setData(notetextedit.Anchor)

        action = menu.addAction("Code Block", self.setTextEffect)
        action.setData(notetextedit.Pre)

        action = menu.addAction("Numbered List", self.setTextEffect)
        action.setData(notetextedit.List)

        header_menu = QMenu("Header")
        action = header_menu.addAction('H1', self.setTextEffect)
        action.setData(notetextedit.H1)
        action.setCheckable(True)
        action.setChecked(self.which_header()=='H1')

        action = header_menu.addAction('H2', self.setTextEffect)
        action.setData(notetextedit.H2)
        action.setCheckable(True)
        action.setChecked(self.which_header()=='H2')

        action = header_menu.addAction('H3', self.setTextEffect)
        action.setData(notetextedit.H3)
        action.setCheckable(True)
        action.setChecked(self.which_header()=='H3')

        action = menu.addAction("Remove All Formatting", self.setTextEffect)
        action.setData(notetextedit.Remove)

        menu.addMenu(header_menu)

        menu.addSeparator()

        action = menu.addAction("Save", self.setTextEffect)
        action.setData(notetextedit.Save)

        self.ensureCursorVisible()
        menu.exec_(self.viewport().mapToGlobal(self.cursorRect().center()))

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addMenu [as 别名]
    def labelingContextMenu(self,names,op,position5d):
        menu = QMenu(self)
        menu.setObjectName("carving_context_menu")
        posItem = menu.addAction("position %d %d %d" % (position5d[1], position5d[2], position5d[3]))
        posItem.setEnabled(False)
        menu.addSeparator()
        for name in names:
            submenu = QMenu(name,menu)
            
            # Load
            loadAction = submenu.addAction("Load %s" % name)
            loadAction.triggered.connect( partial(op.loadObject, name) )
            
            # Delete
            def onDelAction(_name):
                self.confirmAndDelete([_name])
                if self.render and self._renderMgr.ready:
                    self._update_rendering()
            delAction = submenu.addAction("Delete %s" % name)
            delAction.triggered.connect( partial(onDelAction, name) )

            if self.render:
                if name in self._shownObjects3D:
                    # Remove
                    def onRemove3D(_name):
                        label = self._shownObjects3D.pop(_name)
                        self._renderMgr.removeObject(label)
                        self._update_rendering()
                    removeAction = submenu.addAction("Remove %s from 3D view" % name)
                    removeAction.triggered.connect( partial(onRemove3D, name) )
                else:
                    # Show
                    def onShow3D(_name):
                        label = self._renderMgr.addObject()
                        self._shownObjects3D[_name] = label
                        self._update_rendering()
                    showAction = submenu.addAction("Show 3D %s" % name)
                    showAction.triggered.connect( partial(onShow3D, name ) )
                        
            menu.addMenu(submenu)

        if names:
            menu.addSeparator()

        menu.addSeparator()
        if self.render:
            showSeg3DAction = menu.addAction( "Show Editing Segmentation in 3D" )
            showSeg3DAction.setCheckable(True)
            showSeg3DAction.setChecked( self._showSegmentationIn3D )
            showSeg3DAction.triggered.connect( self._toggleSegmentation3D )
        
        if op.dataIsStorable():
            menu.addAction("Save object").triggered.connect( self.onSaveButton )
        menu.addAction("Browse objects").triggered.connect( self.onShowObjectNames )
        menu.addAction("Segment").triggered.connect( self.onSegmentButton )
        menu.addAction("Clear").triggered.connect( self.topLevelOperatorView.clearCurrentLabeling )
        return menu

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addMenu [as 别名]
 def __onContextMenu( self, pos ):
     " Triggered when a context menu is requested "
     pluginMenus = self.__editorsManager.getPluginMenus()
     if pluginMenus:
         contextMenu = QMenu()
         for pluginPath, pluginMenu in pluginMenus.iteritems():
             contextMenu.addMenu( pluginMenu )
         contextMenu.exec_( QCursor.pos() )
         del contextMenu
     return

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addMenu [as 别名]
	def databaseContextMenu(self, point):
		"""
		@type point: QPoint
		"""
		databaseMenu = QMenu()
		databaseCreateMenu = databaseMenu.addMenu(QIcon('../resources/icons/application_form_add.png'), 'Create new')
		databaseCreateMenu.menuAction().setIconVisibleInMenu(True)
		databaseMenu.addMenu(databaseCreateMenu)

		createTableMenuItem = databaseCreateMenu.addAction(QIcon('../resources/icons/table.png'), 'Table')
		createTableMenuItem.setIconVisibleInMenu(True)
		createTableMenuItem.triggered.connect(self.tableTab.createTableAction)
		databaseMenu.exec_(self.mainWindow.databaseInfoTable.viewport().mapToGlobal(point))

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addMenu [as 别名]
    def context_menu_for_root(self):
        menu = QMenu(self)
        path = self.current_tree.project.path
        action_add_file = menu.addAction(QIcon(":img/new"),
                                         translations.TR_ADD_NEW_FILE)
        action_add_folder = menu.addAction(QIcon(
            ":img/openProj"), translations.TR_ADD_NEW_FOLDER)
        action_create_init = menu.addAction(translations.TR_CREATE_INIT)
        self.connect(action_add_file, SIGNAL("triggered()"),
                     lambda: self.current_tree._add_new_file(path))
        self.connect(action_add_folder, SIGNAL("triggered()"),
                     lambda: self.current_tree._add_new_folder(path))
        self.connect(action_create_init, SIGNAL("triggered()"),
                     lambda: self.current_tree._create_init(path))
        menu.addSeparator()
        actionRunProject = menu.addAction(QIcon(
            ":img/play"), translations.TR_RUN_PROJECT)
        self.connect(actionRunProject, SIGNAL("triggered()"),
                     self.current_tree._execute_project)
        if self.current_tree._added_to_console:
            actionRemoveFromConsole = menu.addAction(
                translations.TR_REMOVE_PROJECT_FROM_PYTHON_CONSOLE)
            self.connect(actionRemoveFromConsole, SIGNAL("triggered()"),
                         self.current_tree._remove_project_from_console)
        else:
            actionAdd2Console = menu.addAction(
                translations.TR_ADD_PROJECT_TO_PYTHON_CONSOLE)
            self.connect(actionAdd2Console, SIGNAL("triggered()"),
                         self.current_tree._add_project_to_console)
        actionShowFileSizeInfo = menu.addAction(translations.TR_SHOW_FILESIZE)
        self.connect(actionShowFileSizeInfo, SIGNAL("triggered()"),
                     self.current_tree.show_filesize_info)
        actionProperties = menu.addAction(QIcon(":img/pref"),
                                          translations.TR_PROJECT_PROPERTIES)
        self.connect(actionProperties, SIGNAL("triggered()"),
                     self.current_tree.open_project_properties)

        menu.addSeparator()
        action_close = menu.addAction(
            self.style().standardIcon(QStyle.SP_DialogCloseButton),
            translations.TR_CLOSE_PROJECT)
        self.connect(action_close, SIGNAL("triggered()"),
                     self.current_tree._close_project)
        #menu for the project
        for m in self.current_tree.extra_menus_by_scope['project']:
            if isinstance(m, QMenu):
                menu.addSeparator()
                menu.addMenu(m)

        #show the menu!
        menu.exec_(QCursor.pos())

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addMenu [as 别名]
    def menuContextTree(self, point):
        index = self.indexAt(point)
        if not index.isValid():
            return

        item = self.itemAt(point)
        name = item.text(0)

        menu=QMenu(self)
        if item.isFolder or item.parent() is None:
            action_add_file = menu.addAction(QIcon(resources.images['new']), 'Add New File')
            self.connect(action_add_file, SIGNAL("triggered()"), self._add_new_file)
            action_add_folder = menu.addAction(QIcon(resources.images['openProj']), 'Add New Folder')
            self.connect(action_add_folder, SIGNAL("triggered()"), self._add_new_folder)
            action_create_init = menu.addAction('Create "__init__" Complete')
            self.connect(action_create_init, SIGNAL("triggered()"), self._create_init)
        elif not item.isFolder:
            action_remove_file = menu.addAction(self.style().standardIcon(QStyle.SP_DialogCloseButton),
                'Delete File')
            self.connect(action_remove_file, SIGNAL("triggered()"), self._delete_file)
#            action_load_symbols = menu.addAction(self.style().standardIcon(QStyle.SP_DialogCloseButton),
#                'Load Symbols')
#            self.connect(action_load_symbols, SIGNAL("triggered()"), self._load_file_symbols)
        if item.parent() is None:
            menu.addSeparator()
            actionRunProject = menu.addAction(QIcon(resources.images['play']), 'Run Project')
            self.connect(actionRunProject, SIGNAL("triggered()"), self.run_project)
            actionMainProject = menu.addAction('Set as Main Project')
            self.connect(actionMainProject, SIGNAL("triggered()"), lambda: self.set_default_project(item))
            actionProperties = menu.addAction(QIcon(resources.images['pref']), 'Project Properties')
            self.connect(actionProperties, SIGNAL("triggered()"), self.open_project_properties)
            if self.extraMenus.get(item.projectType, False):
                menus = self.extraMenus[item.projectType]
                for m in menus:
                    menu.addSeparator()
                    menu.addMenu(m)
            if self.extraMenus.get(item.lang(), False):
                menus = self.extraMenus[item.lang()]
                for m in menus:
                    menu.addSeparator()
                    menu.addMenu(m)
            menu.addSeparator()
            action_refresh = menu.addAction(self.style().standardIcon(QStyle.SP_BrowserReload), 
                'Refresh Project')
            self.connect(action_refresh, SIGNAL("triggered()"), self._refresh_project)
            action_close = menu.addAction(self.style().standardIcon(QStyle.SP_DialogCloseButton), 
                'Close Project')
            self.connect(action_close, SIGNAL("triggered()"), self._close_project)
        menu.exec_(QCursor.pos())

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addMenu [as 别名]
 def prepareContextMenu(self):
     context_menu = QMenu(self)
     var = self.selectionModel().currentIndex().internalPointer()
     if isinstance(var, TreeStdVariable):
         filters.add_actions_for_all_filters(context_menu.addMenu(
             "Set Filter for %s..." % var.exp), var)
     return context_menu

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addMenu [as 别名]
 def showHeaderMenu( self, point ):
     # determine the column that was clicked on
     index = self.uiPlaylistTREE.header().logicalIndexAt(point)
     self._currentHeaderColumn = index
     
     # create the menu
     menu = QMenu(self)
     
     act = menu.addAction( 'Sort Ascending' )
     act.setIcon( resources.icon( 'img/playlist/sort_ascending.png' ) )
     act.triggered.connect( self.sortAscending )
     
     act = menu.addAction( 'Sort Descending' )
     act.setIcon( resources.icon( 'img/playlist/sort_descending.png' ) )
     act.triggered.connect( self.sortDescending )
     
     menu.addSeparator()
     
     # create a columns menu
     columns = menu.addMenu( 'Columns...' )
     columns.setIcon( resources.icon( 'img/playlist/columns.png' ) )
     
     for c, col in enumerate(self.COLUMNS):
         act = columns.addAction( col )
         act.setCheckable(True)
         act.setChecked( not self.uiPlaylistTREE.isColumnHidden(c) )
     
     columns.triggered.connect( self.toggleColumnTriggered )
     
     # popup the menu
     menu.exec_( QCursor.pos() )