Python QtGui.QMenu类代码示例

 def __init__(self, parent, plot):
     QMenu.__init__(self, plot.name(), parent)
     color_menu = CurveColorMenu(self,plot)
     marker_menu = CurveMarkerMenu(self,plot)
     self.addMenu(color_menu)
     self.addMenu(marker_menu)
     self.addAction('&Remove', lambda: parent.track.remove_plot(plot))

    def contextMenuEvent(self, event):
        menu = QMenu(self)

        Action = menu.addAction("delete row")
        Action.triggered.connect(self.deleteRow)

        menu.exec_(event.globalPos())

 def create_menu_switch_sink(self):
     sink_menu = QMenu(i18n("Move To"), self.popup_menu)
     sinks = self.veromix.get_sink_widgets()
     for sink in sinks:
         action = QAction(sink.name(), self.popup_menu)
         sink_menu.addAction(action)
     self.popup_menu.addMenu(sink_menu)

class ScripterMenu(QObject):
    """
    Scripter menu item in mainWindow menubar
    """

    def __init__(self, parent):
        QObject.__init__(self, parent)
        self.setObjectName("Menu")
        self.popup = QMenu(i18n("Scripter"))
        MenuHooks().insertMenuAfter("E&xtras", self.popup)
        self._load_entries()


    def _load_entries(self):
        for path in [scripter_path, os.path.expanduser("~/.scribus/scripter/")]:
            autoload_path = os.path.join(path, "autoload")
            if not os.path.exists(autoload_path):
                continue
            sys.path.insert(0, autoload_path)
            from scribusscript import load_scripts
            self.autoload_scripts = scripts = load_scripts(autoload_path)
            for sd in scripts:
                try:
                    sd.install()
                except:
                    excepthook.show_current_error(i18n("Error installing %r") % sd.name)


    def addAction(self, title, callback, *args):
        self.popup.addAction(title, callback, *args)


    def addSeparator(self):
        self.popup.addSeparator()

 def contextMenuEvent(self, event): 
     if event.reason() == event.Mouse: 
         pos = event.globalPos() 
         item = self.itemAt(event.pos()) 
     else: 
         pos = None 
         selection = self.selectedItems() 
         if selection: 
             item = selection[0] 
         else: 
             item = self.currentItem() 
             if item is None: 
                 item = self.invisibleRootItem().child(0) 
         if item is not None: 
             parent = item.parent() 
             while parent is not None: 
                 parent.setExpanded(True) 
                 parent = parent.parent() 
             itemrect = self.visualItemRect(item) 
             portrect = self.viewport().rect() 
             if not portrect.contains(itemrect.topLeft()): 
                 self.scrollToItem( 
                     item, QTreeWidget.PositionAtCenter) 
                 itemrect = self.visualItemRect(item) 
             itemrect.setLeft(portrect.left()) 
             itemrect.setWidth(portrect.width()) 
             pos = self.mapToGlobal(itemrect.center()) 
     if pos is not None: 
         menu = QMenu(self) 
         menu.addAction(item.text(0)) 
         menu.popup(pos) 
     event.accept() 

 def showSnippets(self, evt):
     popupmenu = QMenu()
     for name, snippet in self.snippets.iteritems():
         action = QAction(self.tr(name), self.btnSnippets)
         action.triggered[()].connect(lambda snippet=snippet: self.editor.insert(snippet))
         popupmenu.addAction(action)
     popupmenu.exec_(QCursor.pos())

    def __createContextMenu( self ):
        " Creates context menu for the table raws "
        self.__contextMenu = QMenu( self )
        self.__callersMenu = QMenu( "Callers", self )
        self.__outsideCallersMenu = QMenu( "Outside callers", self )
        self.__calleesMenu = QMenu( "Callees", self )
        self.__outsideCalleesMenu = QMenu( "Outside callees", self )
        self.__contextMenu.addMenu( self.__callersMenu )
        self.__contextMenu.addMenu( self.__outsideCallersMenu )
        self.__contextMenu.addSeparator()
        self.__contextMenu.addMenu( self.__calleesMenu )
        self.__contextMenu.addMenu( self.__outsideCalleesMenu )
        self.__contextMenu.addSeparator()
        self.__disasmAct = self.__contextMenu.addAction(
                                    PixmapCache().getIcon( 'disasmmenu.png' ),
                                    "Disassemble", self.__onDisassemble )

        self.__callersMenu.triggered.connect( self.__onCallContextMenu )
        self.__outsideCallersMenu.triggered.connect( self.__onCallContextMenu )
        self.__calleesMenu.triggered.connect( self.__onCallContextMenu )
        self.__outsideCalleesMenu.triggered.connect( self.__onCallContextMenu )

        self.__table.setContextMenuPolicy( Qt.CustomContextMenu )
        self.__table.customContextMenuRequested.connect( self.__showContextMenu )
        return

    def __init__(self):
        QWidget.__init__(self)
        self._line_edit = ClearableLineEdit()

        self._calendar_button = QToolButton()
        self._calendar_button.setPopupMode(QToolButton.InstantPopup)
        self._calendar_button.setFixedSize(26, 26)
        self._calendar_button.setAutoRaise(True)
        self._calendar_button.setIcon(resourceIcon("calendar.png"))
        self._calendar_button.setStyleSheet("QToolButton::menu-indicator { image: none; }")

        tool_menu = QMenu(self._calendar_button)
        self._calendar_widget = QCalendarWidget(tool_menu)
        action = QWidgetAction(tool_menu)
        action.setDefaultWidget(self._calendar_widget)
        tool_menu.addAction(action)
        self._calendar_button.setMenu(tool_menu)

        layout = QHBoxLayout()
        layout.setMargin(0)
        layout.addWidget(self._line_edit)
        layout.addWidget(self._calendar_button)
        self.setLayout(layout)

        self._calendar_widget.activated.connect(self.setDate)

class centro(QGraphicsPixmapItem):
      def __init__(self, *args):
            QGraphicsPixmapItem.__init__(self, *args)
            self.setPixmap(QPixmap("sprites/calle/centro.png"))
            self.setTransformOriginPoint(self.boundingRect().width()/2.0,self.boundingRect().height()/2.0)
            self.setZValue(1)
            self.menu = QMenu()
            self.Actions =[] #arreglo de acciones 
            self.Actions.append( self.menu.addAction("girar clockwise") )
            self.Actions.append( self.menu.addAction("girar anti-clockwise") )
            self.Actions.append( self.menu.addAction("Duplicar") )
            self.Actions.append( self.menu.addAction("Eliminar") )
            self.menu.triggered[QAction].connect(self.test)
            self.offset=QPointF(0,0)
      def test(self,act):
            print act.text()
            if act.text()=="girar clockwise":
                  self.setRotation(self.rotation()-45)
            if act.text()=="girar anti-clockwise":
                  self.setRotation(self.rotation()+45)
            if act.text()=="Duplicar":
                  self.scene().addItem(centro())
            if act.text()=="Eliminar":
                  self.scene().removeItem(self)
      def contextMenuEvent(self,event):
            self.menu.popup(event.screenPos())
      def mousePressEvent(self, event):
            p = event.pos()
            self.offset= QPointF(p.x()*1.0,p.y()*1.0)
      def mouseMoveEvent(self, event):
            #print self.offset,event.scenePos()
            self.setPos(event.scenePos()-self.offset)

class BaseTabs(QTabWidget):
    def __init__(self, parent, actions=None, menu=None):
        QTabWidget.__init__(self, parent)
        if menu is None:
            self.menu = QMenu(self)
            if actions:
                add_actions(self.menu, actions)
        else:
            self.menu = menu
        
    def contextMenuEvent(self, event):
        """Override Qt method"""
        if self.menu:
            self.menu.popup(event.globalPos())
            
    def mousePressEvent(self, event):
        """Override Qt method"""
        if event.button() == Qt.MidButton:
            index = self.tabBar().tabAt(event.pos())
            if index >= 0:
                self.emit(SIGNAL("close_tab(int)"), index)
                event.accept()
                return
        QTabWidget.mousePressEvent(self, event)
        
    def keyPressEvent(self, event):
        """Override Qt method"""
        ctrl = event.modifiers() & Qt.ControlModifier
        key = event.key()
        handled = False
        if ctrl and self.count() > 0:
            index = self.currentIndex()
            if key == Qt.Key_PageUp and index > 0:
                self.setCurrentIndex(index-1)
                handled = True
            elif key == Qt.Key_PageDown and index < self.count()-1:
                self.setCurrentIndex(index+1)
                handled = True
        if handled:
            event.accept()
        else:
            QTabWidget.keyPressEvent(self, event)
        
    def set_close_function(self, func):
        """Setting Tabs close function
        None -> tabs are not closable"""
        state = func is not None
        if state:
            self.connect(self, SIGNAL("close_tab(int)"), func)
        try:
            # Assuming Qt >= 4.5
            QTabWidget.setTabsClosable(self, state)
            self.connect(self, SIGNAL("tabCloseRequested(int)"), func)
        except AttributeError:
            # Workaround for Qt < 4.5
            close_button = create_toolbutton(self, triggered=func,
                                             icon=get_icon("fileclose.png"),
                                             tip=translate("Tabs",
                                                           "Close current tab"))
            self.setCornerWidget(close_button if state else None)

    def __init__(self, parent, mainWindow, tags, selectItem = None):
        QMenu.__init__(self, tags,  parent)
	self.tags = tags       
        self.__mainWindow = mainWindow
        self.callbackSelected = selectItem
        self.loader = loader.loader()
        self.Load()

class FilterSetWidget(QWidget, Ui_FilterSetWidget):

    def __init__(self, parent=None):
        super(FilterSetWidget, self).__init__(parent)
        self.setupUi(self)
        self._filterSetActionGroup = QActionGroup(self)
        self._filterSetActionGroup.addAction(self.saveFilterSetAction)
        self._filterSetActionGroup.addAction(self.reloadFilterSetAction)
        self._filterSetActionGroup.addAction(self.deleteFilterSetAction)
        self._filterSetActionGroup.addAction(self.exportFilterSetAction)
        self._filterSetMenu = QMenu(self)
        self._filterSetMenu.addActions(self._filterSetActionGroup.actions())
        self.filterSetTool.setMenu(self._filterSetMenu)
        self.filterSetTool.setDefaultAction(self.saveFilterSetAction)

    def setFilterSet(self, filterSet):
        self.setFilterSetKey(filterSet.key)
        if filterSet.source == 'ark':
            self.saveFilterSetAction.setEnabled(False)
            self.deleteFilterSetAction.setEnabled(False)
            self.filterSetTool.setDefaultAction(self.reloadFilterSetAction)
        else:
            self.saveFilterSetAction.setEnabled(True)
            self.deleteFilterSetAction.setEnabled(True)
            self.filterSetTool.setDefaultAction(self.saveFilterSetAction)

    def setFilterSetKey(self, key):
        self.filterSetCombo.setCurrentIndex(self.filterSetCombo.findData(key))

    def currentFilterSetKey(self):
        return self.filterSetCombo.itemData(self.filterSetCombo.currentIndex())

    def currentFilterSetName(self):
        return self.filterSetCombo.currentText()

    def __showPyflakesContextMenu( self, pos ):
        " Triggered when the icon context menu is requested "
        if self.__currentUUID is None:
            return
        if self.__currentUUID not in self.__flakesResults:
            return

        messages = self.__flakesResults[ self.__currentUUID ].messages
        if not messages:
            return

        # Check that there is at least one non -1 lineno message
        foundLinedMessage = False
        for item in messages:
            if item[ 1 ] != -1:
                foundLinedMessage = True
                break
        if not foundLinedMessage:
            return

        # OK, we have something to show
        contextMenu = QMenu( self.__uiLabel )
        for item in messages:
            act = contextMenu.addAction(
                        PixmapCache().getIcon( 'pyflakesmsgmarker.png' ),
                        "Line " + str( item[ 1 ] ) + ": " + item[ 0 ] )
            act.setData( QVariant( item[ 1 ] ) )
        self.connect( contextMenu, SIGNAL( "triggered(QAction*)" ),
                      self.__onContextMenu )
        contextMenu.popup( self.__uiLabel.mapToGlobal( pos ) )
        return

 def create_menubar(self): 
    # Create File Menu
    self.fileMenu = QMenu("&File")
    self.fileMenu.addAction(self.mbNew)      
    self.fileMenu.addAction(self.mbOpen)
    self.fileMenu.addSeparator()
    self.fileMenu.addAction(self.mbSave)  
    self.fileMenu.addAction(self.mbSaveAs)  
    self.fileMenu.addSeparator()
    self.fileMenu.addAction(self.mbClose) 
    self.fileMenu.addAction(self.mbExit)
    # Create Script Menu 
    self.scriptMenu = QMenu("&Script")
    self.scriptMenu.addAction(self.mbRun)
    self.scriptMenu.addAction(self.mbStop)
    self.scriptMenu.addAction(self.mbDebug)
    # Create Help Menu
    self.helpMenu = QMenu("&Help")
    self.helpMenu.addAction(self.mbHelp)
    self.helpMenu.addAction(self.mbAbout)
    # Add menus to menubar
    menubar = self.menuBar()
    menubar.addMenu(self.fileMenu)
    menubar.addMenu(self.scriptMenu)
    menubar.addMenu(self.helpMenu)

    def set_menu_registry(self, menu_registry):
        self.menu_registry = menu_registry

        for menu_instance in self.menu_registry.menus():
            try:
                menu_instance.setCanvasMainWindow(self)

                custom_menu = QMenu(menu_instance.name, self)

                sub_menus = menu_instance.getSubMenuNamesList()

                for index in range(0, len(sub_menus)):
                    if menu_instance.isSeparator(sub_menus[index]):
                        custom_menu.addSeparator()
                    else:
                        custom_action = \
                            QAction(sub_menus[index], self,
                                    objectName=sub_menus[index].lower() + "-action",
                                    toolTip=self.tr(sub_menus[index]),
                                    )

                        custom_action.triggered.connect(getattr(menu_instance, 'executeAction_' + str(index+1)))

                        custom_menu.addAction(custom_action)

                self.menuBar().addMenu(custom_menu)
            except Exception as exception:
                print("Error in creating Customized Menu: " + str(menu_instance))
                print(str(exception.args[0]))
                continue