Python QMenu.addSeparator方法代码示例

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addSeparator [as 别名]
    def _create_menu(self):
        mbar = self._ui.menubar
        menu = QMenu(mbar)
        menu.setTitle("File")

        menu.addAction(self._actions['data_new'])
        menu.addAction(self._actions['session_save'])
        menu.addAction(self._actions['session_restore'])

        menu.addAction(self._actions['tab_new'])
        menu.addAction(self._actions['window_new'])
        mbar.addMenu(menu)

        menu = QMenu(mbar)
        menu.setTitle("Tab")
        menu.addAction(self._actions['tab_new'])
        menu.addAction(self._actions['window_new'])
        menu.addSeparator()
        menu.addAction(self._actions['cascade'])
        menu.addAction(self._actions['tile'])
        menu.addAction(self._actions['tab_rename'])
        mbar.addMenu(menu)

        menu = QMenu(mbar)
        menu.setTitle("Layers")
        menu.addActions(self._ui.layerWidget.actions())
        a = act("Define new component", self,
                tip="Define a new component using python expressions")
        a.triggered.connect(self._create_component)
        menu.addAction(a)

        mbar.addMenu(menu)

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addSeparator [as 别名]
    def _onTvFilesCustomContextMenuRequested(self, pos ):
        """Connected automatically by uic
        """
        menu = QMenu()
        
        menu.addAction( core.actionManager().action( "mFile/mClose/aCurrent" ) )
        menu.addAction( core.actionManager().action( "mFile/mSave/aCurrent" ) )
        menu.addAction( core.actionManager().action( "mFile/mReload/aCurrent" ) )
        menu.addSeparator()
        
        # sort menu
        sortMenu = QMenu( self )
        group = QActionGroup( sortMenu )

        group.addAction( self.tr( "Opening order" ) )
        group.addAction( self.tr( "File name" ) )
        group.addAction( self.tr( "URL" ) )
        group.addAction( self.tr( "Suffixes" ) )
        group.triggered.connect(self._onSortTriggered)
        sortMenu.addActions( group.actions() )
        
        for i, sortMode in enumerate(["OpeningOrder", "FileName", "URL", "Suffixes"]):
            action = group.actions()[i]
            action.setData( sortMode )
            action.setCheckable( True )
            if sortMode == self.model.sortMode():
                action.setChecked( True )
        
        aSortMenu = QAction( self.tr( "Sorting" ), self )
        aSortMenu.setMenu( sortMenu )
        aSortMenu.setIcon( QIcon( ":/enkiicons/sort.png" ))
        aSortMenu.setToolTip( aSortMenu.text() )
        
        menu.addAction( sortMenu.menuAction() )
        menu.exec_( self.tvFiles.mapToGlobal( pos ) )

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addSeparator [as 别名]
class MenuView(object):

    def __init__(self, menu, parent, main):
        self._main = main
        self._parent = parent

        self.hideConsoleAction = menu.addAction('Show/Hide &Console (F4)')
        self.hideConsoleAction.setCheckable(True)
        self.hideEditorAction = menu.addAction('Show/Hide &Editor (F3)')
        self.hideEditorAction.setCheckable(True)
        self.hideAllAction = menu.addAction('Show/Hide &All (F11)')
        self.hideAllAction.setCheckable(True)
        self.hideExplorerAction = menu.addAction('Show/Hide &Explorer (F2)')
        self.hideExplorerAction.setCheckable(True)
        menu.addSeparator()
        splitTabHAction = menu.addAction(QIcon(resources.images['splitH']), 'Split Tabs Horizontally (F10)')
        splitTabVAction = menu.addAction(QIcon(resources.images['splitV']), 'Split Tabs Vertically (F9)')
        menu.addSeparator()
        #Panels Properties
        self.menuProperties = QMenu('Panels Properties')
        self.splitCentralOrientation = self.menuProperties.addAction('Change Central Splitter Orientation')
        self.splitMainOrientation = self.menuProperties.addAction('Change Main Splitter Orientation')
        self.menuProperties.addSeparator()
        self.splitCentralRotate = self.menuProperties.addAction(QIcon(resources.images['splitCRotate']), 'Rotate Central Panels')
        self.splitMainRotate = self.menuProperties.addAction(QIcon(resources.images['splitMRotate']), 'Rotate GUI Panels')
        menu.addMenu(self.menuProperties)
        menu.addSeparator()
        #Zoom
        zoomInAction = menu.addAction('Zoom &In ('+OS_KEY+'+Wheel-Up)')
        zoomOutAction = menu.addAction('Zoom &Out ('+OS_KEY+'+Wheel-Down)')
        menu.addSeparator()
        fadeInAction = menu.addAction('Fade In (Alt+Wheel-Up)')
        fadeOutAction = menu.addAction('Fade Out (Alt+Wheel-Down)')

        self._parent._toolbar.addSeparator()
        self._parent._toolbar.addAction(splitTabHAction)
        self._parent._toolbar.addAction(splitTabVAction)

        QObject.connect(self.hideConsoleAction, SIGNAL("triggered()"), self._main._hide_container)
        QObject.connect(self.hideEditorAction, SIGNAL("triggered()"), self._main._hide_editor)
        QObject.connect(self.hideExplorerAction, SIGNAL("triggered()"), self._main._hide_explorer)
        QObject.connect(self.hideAllAction, SIGNAL("triggered()"), self._main._hide_all)
        QObject.connect(splitTabHAction, SIGNAL("triggered()"), lambda: self._main.split_tab(True))
        QObject.connect(splitTabVAction, SIGNAL("triggered()"), lambda: self._main.split_tab(False))
        QObject.connect(zoomInAction, SIGNAL("triggered()"), lambda: self._main._central.actual_tab().obtain_editor().zoom_in())
        QObject.connect(zoomOutAction, SIGNAL("triggered()"), lambda: self._main._central.actual_tab().obtain_editor().zoom_out())
        QObject.connect(self.splitCentralOrientation, SIGNAL("triggered()"), self._main._splitter_central_orientation)
        QObject.connect(self.splitMainOrientation, SIGNAL("triggered()"), self._main._splitter_main_orientation)
        QObject.connect(self.splitCentralRotate, SIGNAL("triggered()"), self._main._splitter_central_rotate)
        QObject.connect(self.splitMainRotate, SIGNAL("triggered()"), self._main._splitter_main_rotate)
        QObject.connect(fadeInAction, SIGNAL("triggered()"), self._fade_in)
        QObject.connect(fadeOutAction, SIGNAL("triggered()"), self._fade_out)

    def _fade_in(self):
        event = QWheelEvent(QPoint(), 120, Qt.NoButton, Qt.AltModifier)
        self._parent.wheelEvent(event)

    def _fade_out(self):
        event = QWheelEvent(QPoint(), -120, Qt.NoButton, Qt.AltModifier)
        self._parent.wheelEvent(event)

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addSeparator [as 别名]
 def showMenu( self ):
     """
     Creates a menu to display for the editing of template information.
     """
     item = self.uiMenuTREE.currentItem()
     
     menu = QMenu(self)
     act = menu.addAction('Add Menu...')
     act.setIcon(QIcon(projexui.resources.find('img/folder.png')))
     act.triggered.connect(self.createMenu)
     
     if ( item and item.data(0, Qt.UserRole) == 'menu' ):
         act = menu.addAction('Rename Menu...')
         ico = QIcon(projexui.resources.find('img/edit.png'))
         act.setIcon(ico)
         act.triggered.connect(self.renameMenu)
     
     act = menu.addAction('Add Separator')
     act.setIcon(QIcon(projexui.resources.find('img/ui/splitter.png')))
     act.triggered.connect(self.createSeparator)
     
     menu.addSeparator()
     
     act = menu.addAction('Remove Item')
     act.setIcon(QIcon(projexui.resources.find('img/remove.png')))
     act.triggered.connect(self.removeItem)
     act.setEnabled(item is not None)
     
     menu.exec_(QCursor.pos())

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

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addSeparator [as 别名]
 def showContextMenu(self, pos):
     """show context menu for item at pos"""
     mi = self.treeView.indexAt(pos)
     t, n = self.model.dsNode(mi)
     self.selectedNode = n
     self.selectedMI = mi
     m = QMenu()
     if t == 'R':
         m.addAction(QCoreApplication.translate('DataStorageBrowser', 'Close'), self.closeDatabase)
         m.addAction(QCoreApplication.translate('DataStorageBrowser', 'Reload'), self.reloadDatabase)
     elif t == 'P':
         m.addAction(QCoreApplication.translate('DataStorageBrowser', 'New sensorgroup'), self.newSensorGroup)
     elif t == 'G':
         nCharts = len(n.charts)
         if nCharts > 0:
             txt = str(QCoreApplication.translate('DataStorageBrowser', 'Show all charts (%d)')) % nCharts
             m.addAction(txt, self.showAllCharts)
             m.addAction(QCoreApplication.translate('DataStorageBrowser', 'Save all charts as images'), self.saveAllChartImages)
         m.addAction(QCoreApplication.translate('DataStorageBrowser', 'Add chart'), self.newChart)
         m.addAction(QCoreApplication.translate('DataStorageBrowser', 'Add/update data'), self.importFiles)
         m.addAction(QCoreApplication.translate('DataStorageBrowser', 'Export data'), self.exportSensors)
     elif t == 'S':
         m.addAction(QCoreApplication.translate('DataStorageBrowser', 'New plot (Qwt)'), self.showQwtPlot)
         if qwtPlotWindowActive():
             m.addAction(QCoreApplication.translate('DataStorageBrowser', 'Add to plot (Qwt)'), self.addToQwtPlot)
     elif t == 'C':
         m.addAction(QCoreApplication.translate('DataStorageBrowser', 'Show'), self.showChart)
         m.addAction(QCoreApplication.translate('DataStorageBrowser', 'Delete'), self.deleteItem)
     if t in 'RPGS':
         m.addSeparator()
         m.addAction(QCoreApplication.translate('DataStorageBrowser', 'Edit metadata'), self.editMetadata)
     a = m.exec_(self.treeView.mapToGlobal(pos))

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addSeparator [as 别名]
    def menu_right(self):
        """
        Create the context menu.
        It shows up on left click.

        Note: icons will not be displayed on every GNU/Linux
        distributions, it depends on the graphical environment.
        """

        if not self.__menu_right:
            style = QApplication.style()
            menu = QMenu()
            menu.addAction(
                style.standardIcon(QStyle.SP_FileDialogInfoView),
                Translator.get('SETTINGS'),
                self.application.show_settings,
            )
            menu.addSeparator()
            menu.addAction(
                style.standardIcon(QStyle.SP_MessageBoxQuestion),
                Translator.get('HELP'),
                self.application.open_help)
            menu.addSeparator()
            menu.addAction(
                style.standardIcon(QStyle.SP_DialogCloseButton),
                Translator.get('QUIT'),
                self.application.quit)
            self.__menu_right = menu

        return self.__menu_right

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addSeparator [as 别名]
    def showPopupMenu(self, point):
        item = self.algorithmTree.itemAt(point)
        if isinstance(item, TreeAlgorithmItem):
            alg = item.alg
            popupmenu = QMenu()
            executeAction = QAction(self.tr("Execute"), self.algorithmTree)
            executeAction.triggered.connect(self.executeAlgorithm)
            popupmenu.addAction(executeAction)
            if alg.canRunInBatchMode and not alg.allowOnlyOpenedLayers:
                executeBatchAction = QAction(self.tr("Execute as batch process"), self.algorithmTree)
                executeBatchAction.triggered.connect(self.executeAlgorithmAsBatchProcess)
                popupmenu.addAction(executeBatchAction)
            popupmenu.addSeparator()
            editRenderingStylesAction = QAction(self.tr("Edit rendering styles for outputs"), self.algorithmTree)
            editRenderingStylesAction.triggered.connect(self.editRenderingStyles)
            popupmenu.addAction(editRenderingStylesAction)
            actions = Processing.contextMenuActions
            if len(actions) > 0:
                popupmenu.addSeparator()
            for action in actions:
                action.setData(alg, self)
                if action.isEnabled():
                    contextMenuAction = QAction(action.name, self.algorithmTree)
                    contextMenuAction.triggered.connect(action.execute)
                    popupmenu.addAction(contextMenuAction)

            popupmenu.exec_(self.algorithmTree.mapToGlobal(point))

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addSeparator [as 别名]
 def createMenu( self, parent ):
     """
     Creates a new menu for the inputed parent item.
     
     :param      parent | <QMenu>
     """
     menu = QMenu(parent)
     menu.setTitle('&View')
     
     act = menu.addAction('Lock/Unlock Layout')
     act.setIcon(QIcon(projexui.resources.find('img/view/lock.png')))
     act.triggered.connect(self.toggleLocked)
     
     menu.addSeparator()
     act = menu.addAction('Export Layout as...')
     act.setIcon(QIcon(projexui.resources.find('img/view/export.png')))
     act.triggered.connect(self.exportProfile)
     
     act = menu.addAction('Import Layout from...')
     act.setIcon(QIcon(projexui.resources.find('img/view/import.png')))
     act.triggered.connect(self.importProfile)
     
     menu.addSeparator()
     act = menu.addAction('Reset Layout')
     act.setIcon(QIcon(projexui.resources.find('img/view/remove.png')))
     act.triggered.connect(self.reset)
     
     return menu

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addSeparator [as 别名]
 def showContextMenu(self, pos):
     """show context menu for item at pos"""
     mi = self.treeView.indexAt(pos)
     t, n = self.model.dsNode(mi)
     self.selectedNode = n
     self.selectedMI = mi
     m = QMenu()
     if t == 'R':
         m.addAction(QCoreApplication.translate('DataStorageBrowser', 'Close'), self.closeDatabase)
     elif t == 'P':
         pass
     elif t == 'G':
         nCharts = len(n.charts)
         if nCharts > 0:
             txt = str(QCoreApplication.translate('DataStorageBrowser', 'Show all Charts (%d)')) % nCharts
             m.addAction(txt, self.showAllCharts)
         m.addAction(QCoreApplication.translate('DataStorageBrowser', 'Add Chart'), self.newChart)
     elif t == 'S':
         m.addAction(QCoreApplication.translate('DataStorageBrowser', 'Plot (Qwt)'), self.showQwtPlot)
     elif t == 'C':
         m.addAction(QCoreApplication.translate('DataStorageBrowser', 'Show'), self.showMplChart)
         m.addAction(QCoreApplication.translate('DataStorageBrowser', 'Delete'), self.deleteItem)
     if t in 'RPGS':
         m.addSeparator()
         m.addAction(QCoreApplication.translate('DataStorageBrowser', 'Edit metadata'), self.editMetadata)
     a = m.exec_(self.treeView.mapToGlobal(pos))

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addSeparator [as 别名]
class CategorySelector( QToolButton ):
    def __init__( self, items, parent = None ):
        QToolButton.__init__( self, parent )
        self.setText( "All categories" )

        self.setPopupMode( QToolButton.InstantPopup )

        self.menu = QMenu( self )
        self.setMenu( self.menu )

        self.items = items
        self.actions = map( self.createAction, self.items )
        self.menu.addSeparator()
        self.menu.addAction( "Select All" )
        self.menu.addAction( "Select None" )

        self.connect( self.menu, SIGNAL( 'aboutToShow()' ), self.slotMenuAboutToShow )

    def createAction( self, item ):
        action = self.menu.addAction( item )
        action.setCheckable( True )
        action.setChecked( True )
        return action

    def slotMenuAboutToShow( self ):
        self.menu.setMinimumWidth( self.width() )

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addSeparator [as 别名]
    def _load_menu_combo_file(self, point):
        """ Muestra el menú """

        menu = QMenu()
        editor_container = Edis.get_component("principal")
        save_as_action = menu.addAction(QIcon(":image/save-as"),
                                        self.tr("Guardar como..."))
        reload_action = menu.addAction(QIcon(":image/reload"),
                                       self.tr("Recargar"))
        menu.addSeparator()
        compile_action = menu.addAction(QIcon(":image/build"),
                                        self.tr("Compilar"))
        execute_action = menu.addAction(QIcon(":image/run"),
                                        self.tr("Ejecutar"))
        menu.addSeparator()
        close_action = menu.addAction(QIcon(":image/close"),
                                      self.tr("Cerrar archivo"))

        # Conexiones
        self.connect(save_as_action, SIGNAL("triggered()"),
                     editor_container.save_file_as)
        self.connect(reload_action, SIGNAL("triggered()"),
                     editor_container.reload_file)
        self.connect(compile_action, SIGNAL("triggered()"),
                     editor_container.build_source_code)
        self.connect(execute_action, SIGNAL("triggered()"),
                     editor_container.run_binary)
        self.connect(close_action, SIGNAL("triggered()"),
                     editor_container.close_file)

        menu.exec_(self.mapToGlobal(point))

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

        menu = QMenu(self)
        f_all = menu.addAction(self.tr("Fold all"))
        u_all = menu.addAction(self.tr("Unfold all"))
        menu.addSeparator()
        u_class = menu.addAction(self.tr("Unfold classes"))
        u_class_method = menu.addAction(self.tr("Unfold classes and methods"))
        u_class_attr = menu.addAction(self.tr("Unfold classes and attributes"))
        menu.addSeparator()
        #save_state = menu.addAction(self.tr("Save State"))

        self.connect(f_all, SIGNAL("triggered()"),
                     lambda: self.collapseAll())
        self.connect(u_all, SIGNAL("triggered()"),
                     lambda: self.expandAll())
        self.connect(u_class, SIGNAL("triggered()"), self._unfold_class)
        self.connect(u_class_method, SIGNAL("triggered()"),
                     self._unfold_class_method)
        self.connect(u_class_attr, SIGNAL("triggered()"),
                     self._unfold_class_attribute)
        #self.connect(save_state, SIGNAL("triggered()"),
            #self._save_symbols_state)

        menu.exec_(QCursor.pos())

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import addSeparator [as 别名]
 def showContextMenu(self, pos):
     """show context menu for item at pos"""
     mi = self.treeView.indexAt(pos)
     t, n = self.model.dsNode(mi)
     self.selectedNode = n
     self.selectedMI = mi
     m = QMenu()
     if t == "R":
         m.addAction(QCoreApplication.translate("DataStorageBrowser", "Close"), self.closeDatabase)
         m.addAction(QCoreApplication.translate("DataStorageBrowser", "Reload"), self.reloadDatabase)
     elif t == "P":
         m.addAction(QCoreApplication.translate("DataStorageBrowser", "New sensorgroup"), self.newSensorGroup)
     elif t == "G":
         nCharts = len(n.getCharts())
         if nCharts > 0:
             txt = str(QCoreApplication.translate("DataStorageBrowser", "Show all charts (%d)")) % nCharts
             m.addAction(txt, self.showAllCharts)
             m.addAction(
                 QCoreApplication.translate("DataStorageBrowser", "Save all charts as images"),
                 self.saveAllChartImages,
             )
         m.addAction(QCoreApplication.translate("DataStorageBrowser", "Add chart"), self.newChart)
         m.addAction(QCoreApplication.translate("DataStorageBrowser", "Add/update data"), self.importFiles)
         m.addAction(QCoreApplication.translate("DataStorageBrowser", "Export data"), self.exportSensors)
     elif t == "S":
         m.addAction(QCoreApplication.translate("DataStorageBrowser", "New plot (Qwt)"), self.showQwtPlot)
         if qwtPlotWindowActive():
             m.addAction(QCoreApplication.translate("DataStorageBrowser", "Add to plot (Qwt)"), self.addToQwtPlot)
     elif t == "C":
         m.addAction(QCoreApplication.translate("DataStorageBrowser", "Show"), self.showChart)
         m.addAction(QCoreApplication.translate("DataStorageBrowser", "Delete"), self.deleteItem)
     if t in "RPGS":
         m.addSeparator()
         m.addAction(QCoreApplication.translate("DataStorageBrowser", "Edit metadata"), self.editMetadata)
     a = m.exec_(self.treeView.mapToGlobal(pos))

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

        menu = QMenu(self)
        f_all = menu.addAction(translations.TR_FOLD_ALL)
        u_all = menu.addAction(translations.TR_UNFOLD_ALL)
        menu.addSeparator()
        u_class = menu.addAction(translations.TR_UNFOLD_CLASSES)
        u_class_method = menu.addAction(
                         translations.TR_UNFOLD_CLASSES_AND_METHODS)
        u_class_attr = menu.addAction(
                       translations.TR_UNFOLD_CLASSES_AND_ATTRIBUTES)
        menu.addSeparator()
        #save_state = menu.addAction(self.tr("Save State"))

        self.connect(f_all, SIGNAL("triggered()"),
            lambda: self.tree.collapseAll())
        self.connect(u_all, SIGNAL("triggered()"),
            lambda: self.tree.expandAll())
        self.connect(u_class, SIGNAL("triggered()"), self._unfold_class)
        self.connect(u_class_method, SIGNAL("triggered()"),
            self._unfold_class_method)
        self.connect(u_class_attr, SIGNAL("triggered()"),
            self._unfold_class_attribute)
        #self.connect(save_state, SIGNAL("triggered()"),
            #self._save_symbols_state)

        menu.exec_(QCursor.pos())