Python QMenu.exec方法代码示例

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import exec [as 别名]
    def contextMenuEvent(self, event):
        menu = QMenu()
        add_to_current_playlist_action = QAction('添加到当前播放列表', self)
        set_song_next_to_action = QAction('下一首播放', self)
        download_song_action = QAction('下载该歌曲', self)
        menu.addAction(add_to_current_playlist_action)
        menu.addAction(set_song_next_to_action)
        menu.addAction(download_song_action)

        if self._is_playlist_mine():
            remove_song_from_playlist_action = QAction('从歌单中删除该歌曲', self)
            menu.addAction(remove_song_from_playlist_action)
            remove_song_from_playlist_action.triggered.connect(
                self.remove_song_from_playlist)

        add_to_current_playlist_action.triggered.connect(
            self.add_song_to_current_playlist)
        set_song_next_to_action.triggered.connect(
            self.set_song_to_next)
        download_song_action.triggered.connect(self.download_song)

        point = event.pos()
        item = self.itemAt(point)
        if item is not None:
            row = self.row(item)
            self._context_menu_row = row
            menu.exec(event.globalPos())

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import exec [as 别名]
class Add_to_playlist_btn(QPushButton):
    def __init__(self):
        super().__init__('+')
        self.setToolTip('添加到歌单')
        self.menu = QMenu()
        self.playlists = []

    def mousePressEvent(self, event):
        self.set_playlists_options()
        self.menu.exec(event.globalPos())

    def set_playlists_options(self):
        playlists = ControllerApi.api.get_user_playlist()
        if not ControllerApi.api.is_response_ok(playlists):
            return
        self.playlists = playlists
        self.menu.clear()
        for playlist in playlists:
            if ControllerApi.api.is_playlist_mine(playlist):
                name = playlist['name']
                pid = playlist['id']
                action = QAction(name, self)
                action.triggered.connect(partial(self.add_to_playlist, pid))
                self.menu.addAction(action)

    def add_to_playlist(self, pid):
        if not ControllerApi.state['current_mid']:
            return False
        flag = ControllerApi.api.add_song_to_playlist(ControllerApi.state['current_mid'], pid)
        if flag:
            ControllerApi.notify_widget.show_message('◕◡◔', '加入歌单成功')
        else:
            ControllerApi.notify_widget.show_message('◕◠◔', '加入歌单失败, 可能早已在列表了哦')

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

        index = self.indexAt(event.pos())
        m = self.mMapDocument.layerModel()
        layerIndex = m.toLayerIndex(index)
        handler = MapDocumentActionHandler.instance()
        menu = QMenu()
        menu.addAction(handler.actionAddTileLayer())
        menu.addAction(handler.actionAddObjectGroup())
        menu.addAction(handler.actionAddImageLayer())
        if (layerIndex >= 0):
            menu.addAction(handler.actionDuplicateLayer())
            menu.addAction(handler.actionMergeLayerDown())
            menu.addAction(handler.actionRemoveLayer())
            menu.addSeparator()
            menu.addAction(handler.actionMoveLayerUp())
            menu.addAction(handler.actionMoveLayerDown())
            menu.addSeparator()
            menu.addAction(handler.actionToggleOtherLayers())
            menu.addSeparator()
            menu.addAction(handler.actionLayerProperties())

        menu.exec(event.globalPos())

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import exec [as 别名]
    def onContextMenu(self, pt: QPoint):
        index = self.ui.projectTree.indexAt(pt)
        newDocAction = QAction("New document", None)
        newDocAction.triggered.connect(self.window.on_actionNew_triggered)
        menu = QMenu()
        menu.addAction(newDocAction)
        if index.isValid():
            obj = index.data(Qt.UserRole)

            def newPage():
                obj.doc.appendNewPage()
                self.onDocsChanged()

            def newSym():
                obj.doc.appendNewSymbol()
                self.onDocsChanged()

            addPageAction = QAction("Add page", None)
            addPageAction.triggered.connect(newPage)
            addSymAction = QAction("Add symbol", None)
            addSymAction.triggered.connect(newSym)
            rmPageAction = QAction("Delete page", None)
            menu.addAction(addPageAction)
            menu.addAction(addSymAction)
            menu.addSeparator()
            if obj.page is not None:
                menu.addAction(rmPageAction)
        menu.exec(self.ui.projectTree.mapToGlobal(pt))

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import exec [as 别名]
class CurrentPlaylistTable(MusicTable):
    remove_signal = pyqtSignal([int])   # song id

    def __init__(self, app):
        super().__init__(app)
        self._app = app

        self._row = 0

        self.menu = QMenu()
        self.remove = QAction('从当前列表中移除', self)
        self.menu.addAction(self.remove)

        self.remove.triggered.connect(self.remove_song)

    def contextMenuEvent(self, event):
        point = event.pos()
        item = self.itemAt(point)
        if item is not None:
            row = self.row(item)
            self._row = row
            self.menu.exec(event.globalPos())

    def remove_song(self):
        song = self.songs[self._row]
        self.songs.pop(self._row)
        self.removeRow(self._row)
        self.remove_signal.emit(song.mid)

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import exec [as 别名]
 def contextMenuEvent(self, event):
     menu = QMenu()
     index = self.indexAt(event.pos())
     self.selectRow(index.row())
     song = self.model().data(index, Qt.UserRole)
     remove_song_action = QAction('移除歌曲', menu)
     remove_song_action.triggered.connect(partial(self.song_deleted.emit, song))
     menu.addAction(remove_song_action)
     menu.exec(event.globalPos())

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import exec [as 别名]
    def contextMenuEvent(self, event):
        if len(self.selectedItemList) == 2:
            widget = self.parentWidget()
            menu = QMenu(widget)

            swapAction = QAction("Swap", widget)
            swapAction.triggered.connect(self.swap)
            menu.addAction(swapAction)

            menu.exec(event.screenPos())

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

        self.menu = QMenu()

        self.quit_action = QAction("退出", self)
        self.menu.addAction(self.quit_action)

    def contextMenuEvent(self, event: QContextMenuEvent):
        self.menu.exec(event.globalPos())

    def mousePressEvent(self, event: QMouseEvent):
        self.menu.exec(event.globalPos())

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import exec [as 别名]
 def contextMenuEvent(self, event):
     terrain = self.terrainAt(self.indexAt(event.pos()))
     if (not terrain):
         return
     isExternal = terrain.tileset().isExternal()
     menu = QMenu()
     propIcon = QIcon(":images/16x16/document-properties.png")
     terrainProperties = menu.addAction(propIcon,
                                              self.tr("Terrain Properties..."))
     terrainProperties.setEnabled(not isExternal)
     Utils.setThemeIcon(terrainProperties, "document-properties")
     menu.addSeparator()
     terrainProperties.triggered.connect(self.editTerrainProperties)
     menu.exec(event.globalPos())

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import exec [as 别名]
    def show_id_context_menu(self, position):
        current_id = -1
        try:
            current_id = int(self.__ui.lbl_uav_id.text())
        except Exception:
            #print("Don't show the menu")
            return

        menu = QMenu()
        menu.addAction("Show Mission for " + str(current_id))
        menu.addAction("Show Fence for " + str(current_id))

        global_position = self.__ui.lbl_uav_id.mapToGlobal(position)
        selectedItem = menu.exec(global_position)
        
        if selectedItem.text()[0:12] == "Show Mission":
            if self.fetching_mission_for == -1: #prevent concurrent fetches
                self.fetching_mission_for = current_id
                
                self.wpFetchThread = WaypointFetchThread(self, self.__hm_state,
                                                        current_id)
                self.wpFetchThread.start()

            elif self.fetching_mission_for != current_id:
                QMessageBox.error(self, "Still fetching waypoints for " + str(current_id),
                    "Still fetching waypoints for " + str(current_id) + "\n\nCan't fetch multiple waypoints concurrently.  Wait a few more seconds for the previous fetch operation to finish.")
                return
        
        elif selectedItem.text()[0:10] == "Show Fence":
            self.fenFetchThread = FenceFetchThread(self, self.__hm_state,
                                                    current_id)
            self.fenFetchThread.start()

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import exec [as 别名]
 def on_tab_add_clicked(self):
     pos = QCursor.pos()
     planets = self.world.get_planets()
     # logger.debug('tab bar add clicked, cursor pos = ({0}, {1})'.format(pos.x(), pos.y()))
     menu = QMenu(self)
     # galaxy view
     galaxy_action = QAction(menu)
     galaxy_action.setText(self.tr('Add galaxy view'))
     galaxy_action.setData(QVariant('galaxy'))
     menu.addAction(galaxy_action)
     # planets
     menu.addSection(self.tr('-- Planet tabs: --'))
     for planet in planets:
         action = QAction(menu)
         action.setText('{0} {1}'.format(planet.name, planet.coords.coords_str()))
         action.setData(QVariant(planet.planet_id))
         menu.addAction(action)
     action_ret = menu.exec(pos)
     if action_ret is not None:
         # logger.debug('selected action data = {0}'.format(str(action_ret.data())))
         if action_ret == galaxy_action:
             logger.debug('action_ret == galaxy_action')
             self.add_tab_for_galaxy()
             return
         # else consider this is planet widget
         planet_id = int(action_ret.data())
         self.on_request_open_planet_tab(planet_id)

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import exec [as 别名]
    def showContextMenu(self, clickedObjectItem, screenPos):
        selection = self.mMapScene.selectedObjectItems()
        if (clickedObjectItem and not selection.contains(clickedObjectItem)):
            selection.clear()
            selection.insert(clickedObjectItem)
            self.mMapScene.setSelectedObjectItems(selection)
        if selection.isEmpty():
            return

        selectedObjects = self.mapDocument().selectedObjects()
        objectGroups = self.mapDocument().map().objectGroups()

        menu = QMenu()
        duplicateAction = menu.addAction(self.tr("Duplicate %n Object(s)", "", selection.size()), self.duplicateObjects)
        removeAction = menu.addAction(self.tr("Remove %n Object(s)", "", selection.size()), self.removeObjects)

        duplicateAction.setIcon(QIcon("/images/16x16/stock-duplicate-16.png"))
        removeAction.setIcon(QIcon("/images/16x16/edit-delete.png"))

        menu.addSeparator()
        menu.addAction(self.tr("Flip Horizontally"), self.flipHorizontally, QKeySequence(self.tr("X")))
        menu.addAction(self.tr("Flip Vertically"), self.flipVertically, QKeySequence(self.tr("Y")))

        objectGroup = RaiseLowerHelper.sameObjectGroup(selection)
        if (objectGroup and objectGroup.drawOrder() == ObjectGroup.DrawOrder.IndexOrder):
            menu.addSeparator()
            menu.addAction(self.tr("Raise Object"), self.raise_, QKeySequence(self.tr("PgUp")))
            menu.addAction(self.tr("Lower Object"), self.lower, QKeySequence(self.tr("PgDown")))
            menu.addAction(self.tr("Raise Object to Top"), self.raiseToTop, QKeySequence(self.tr("Home")))
            menu.addAction(self.tr("Lower Object to Bottom"), self.lowerToBottom, QKeySequence(self.tr("End")))

        if (objectGroups.size() > 1):
            menu.addSeparator()
            moveToLayerMenu = menu.addMenu(self.tr("Move %n Object(s) to Layer", "", selectedObjects.size()))
            for objectGroup in objectGroups:
                action = moveToLayerMenu.addAction(objectGroup.name())
                action.setData(objectGroup)

        menu.addSeparator()
        propIcon = QIcon("images/16x16/document-properties.png")
        propertiesAction = menu.addAction(propIcon, self.tr("Object &Properties..."))
        # TODO Implement editing of properties for multiple objects
        propertiesAction.setEnabled(selectedObjects.size() == 1)

        Utils.setThemeIcon(removeAction, "edit-delete")
        Utils.setThemeIcon(propertiesAction, "document-properties")

        action = menu.exec(screenPos)
        if not action:
            return

        if action == propertiesAction:
            mapObject = selectedObjects.first()
            self.mapDocument().setCurrentObject(mapObject)
            self.mapDocument().emitEditCurrentObject()
            return
        
        objectGroup = action.data()
        if type(objectGroup) == ObjectGroup:
            self.mapDocument().moveObjectsToGroup(self.mapDocument().selectedObjects(), objectGroup)

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import exec [as 别名]
 def showHandleContextMenu(self, clickedHandle, screenPos):
     if (clickedHandle and not self.mSelectedHandles.contains(clickedHandle)):
         self.setSelectedHandle(clickedHandle)
     n = self.mSelectedHandles.size()
     delIcon = QIcon(":images/16x16/edit-delete.png")
     delText = self.tr("Delete %n Node(s)", "", n)
     menu = QMenu()
     deleteNodesAction = menu.addAction(delIcon, delText)
     joinNodesAction = menu.addAction(self.tr("Join Nodes"))
     splitSegmentsAction = menu.addAction(self.tr("Split Segments"))
     Utils.setThemeIcon(deleteNodesAction, "edit-delete")
     joinNodesAction.setEnabled(n > 1)
     splitSegmentsAction.setEnabled(n > 1)
     deleteNodesAction.triggered.connect(self.deleteNodes)
     joinNodesAction.triggered.connect(self.joinNodes)
     splitSegmentsAction.triggered.connect(self.splitSegments)
     menu.exec(screenPos)

# 需要导入模块: from PyQt5.QtWidgets import QMenu [as 别名]
# 或者: from PyQt5.QtWidgets.QMenu import exec [as 别名]
    def contextMenuEvent(self, event):
        menu = QMenu()
        add_to_current_playlist_action = QAction('加入播放队列', self)
        play_all_playlist_action = QAction("播放歌单", self)
        menu.addAction(add_to_current_playlist_action)
        menu.addAction(play_all_playlist_action)
        add_to_current_playlist_action.triggered.connect(
            self.add_song_to_current_playlist)
        play_all_playlist_action.triggered.connect(self.play_all_playlist)
        # remove_song_from_playlist_action.triggered.connect(
        #     self.remove_song_from_playlist)

        point = event.pos()
        item = self.itemAt(point)
        if item is not None:
            row = self.row(item)
            self._context_menu_row = row
            menu.exec(event.globalPos())

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

		menu = QMenu('ctx menu', self.wnd)

		i = self.wnd.packages.currentRow()

		addb = QAction('Insert package before', self.wnd)
		adda = QAction('Insert package after', self.wnd)
		delete = QAction('Delete package', self.wnd)

		addb.triggered.connect(lambda: self.add_package(i))
		adda.triggered.connect(lambda: self.add_package(i+1))
		delete.triggered.connect(lambda: self.delete_package(i))

		menu.addAction(addb)
		menu.addAction(adda)
		menu.addAction(delete)

		menu.exec(self.wnd.packages.mapToGlobal(pos))