Python QMenu.deleteLater方法代码示例

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

        if index != self.currentIndex():
            self.itemChanged(index)

        item = self.currentItem()

        menu = QMenu(self)

        if isinstance(item, (Table, Schema)):
            menu.addAction(self.tr("Rename"), self.rename)
            menu.addAction(self.tr("Delete"), self.delete)

            if isinstance(item, Table) and item.canBeAddedToCanvas():
                menu.addSeparator()
                menu.addAction(self.tr("Add to canvas"), self.addLayer)

        elif isinstance(item, DBPlugin):
            if item.database() is not None:
                menu.addAction(self.tr("Re-connect"), self.reconnect)
            menu.addAction(self.tr("Remove"), self.delete)

        elif not index.parent().isValid() and item.typeName() == "spatialite":
            menu.addAction(self.tr("New Connection..."), self.newConnection)

        if not menu.isEmpty():
            menu.exec_(ev.globalPos())

        menu.deleteLater()

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import deleteLater [as 别名]
 def _showImageContextMenu(self, _point):
     pixmap = self.imageLabel.getRawPixmap()
     if pixmap is None or pixmap.isNull():
         return
     m = QMenu()
     m.addAction(u"Set as category thumbnail", self._setCurrentPictureAsThumbnail)
     m.exec_(QCursor.pos())
     m.deleteLater()

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import deleteLater [as 别名]
 def contextMenuEvent(self, ev):
     item = self.itemAt(ev.pos())
     if not item:
         return
     
     mainwindow = self.parentWidget().mainwindow()
     
     selection = self.selectedItems()
     doc = self.document(item)
     
     if len(selection) <= 1 and doc:
         # a single document is right-clicked
         import documentcontextmenu
         menu = documentcontextmenu.DocumentContextMenu(mainwindow)
         menu.exec_(doc, ev.globalPos())
         menu.deleteLater()
         return
     
     menu = QMenu(mainwindow)
     save = menu.addAction(icons.get('document-save'), '')
     menu.addSeparator()
     close = menu.addAction(icons.get('document-close'), '')
     
     if len(selection) > 1:
         # multiple documents are selected
         save.setText(_("Save selected documents"))
         close.setText(_("Close selected documents"))
         documents = [self.document(item) for item in selection]
     else:
         documents = [self.document(item.child(i)) for i in range(item.childCount())]
         if item._path:
             # a directory item is right-clicked
             save.setText(_("Save documents in this folder"))
             close.setText(_("Close documents in this folder"))
         else:
             # the "Untitled" group is right-clicked
             save.setText(_("Save all untitled documents"))
             close.setText(_("Close all untitled documents"))
     
     @save.triggered.connect
     def savedocuments():
         for d in documents:
             if d.url().isEmpty() or d.isModified():
                 mainwindow.setCurrentDocument(d)
             if not mainwindow.saveDocument(d):
                 break
     
     @close.triggered.connect
     def close_documents():
         for d in documents:
             if not mainwindow.closeDocument(d):
                 break
     
     menu.exec_(ev.globalPos())
     menu.deleteLater()

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import deleteLater [as 别名]
 def _showContextMenu(self, point):
     index = self.table.indexAt(point)
     if index != None:
         if index.column() != ChatMessagesModel.MESSAGE_COLUMN:
             return
         isOwn = index.data(ChatMessagesModel.OWN_MESSAGE_ROLE).toBool()
         menu = QMenu(self)
         if isOwn:
             menu.addAction(u"Send again", partial(self._sendAgain, index))
         menu.addAction(u"Copy", partial(self._copy, index))
         menu.exec_(QCursor.pos())
         menu.deleteLater()

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import deleteLater [as 别名]
def show(position, panel, link, cursor):
    """Shows a context menu.
    
    position: The global position to pop up
    panel: The music view panel, giving access to mainwindow and view widget
    link: a popplerqt4 LinkBrowse instance or None
    cursor: a QTextCursor instance or None
    
    """
    m = QMenu(panel)
    
    # selection? -> Copy
    if panel.widget().view.surface().hasSelection():
        m.addAction(panel.actionCollection.music_copy_image)
    
    if cursor:
        a = m.addAction(icons.get("document-edit"), _("Edit in Place"))
        @a.triggered.connect
        def edit():
            from . import editinplace
            editinplace.edit(panel.widget(), cursor, position)
    elif link:
        a = m.addAction(icons.get("window-new"), _("Open Link in &New Window"))
        @a.triggered.connect
        def open_in_browser():
            import helpers
            helpers.openUrl(QUrl(link.url()))
        
        a = m.addAction(icons.get("edit-copy"), _("Copy &Link"))
        @a.triggered.connect
        def copy_link():
            QApplication.clipboard().setText(link.url())

    # no actions yet? insert Fit Width/Height
    if not m.actions():
        m.addAction(panel.actionCollection.music_fit_width)
        m.addAction(panel.actionCollection.music_fit_height)
        m.addAction(panel.actionCollection.music_zoom_original)
        m.addSeparator()
        m.addAction(panel.actionCollection.music_sync_cursor)
    
    # help
    m.addSeparator()
    a = m.addAction(icons.get("help-contents"), _("Help"))
    @a.triggered.connect
    def help():
        import userguide
        userguide.show("musicview")
    
    # show it!
    if m.actions():
        m.exec_(position)
    m.deleteLater()

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import deleteLater [as 别名]
class LapigTools:
	
	def __init__(self, iface):
		self.iface = iface
		
		self.menu = QMenu( "&LAPIG Tools", self.iface.mainWindow().menuBar() )
		self.submenu = QMenu("&Time Series Filters")
		self.menu.addMenu(self.submenu)
		
		self.tools = []
		for key, clazz in tools.__dict__.iteritems():
			if inspect.isclass(clazz) and issubclass(clazz, GenericTool) and key != 'GenericTool':
				self.tools.append(clazz(iface))

	def initGui(self):
		List = []
		ListLabel = []
		for tool in self.tools:
			listA,label = tool.initGui()
			List.append(listA)
			ListLabel.append(label)
				
		for i in range(len(List)):
			
			if (ListLabel[i] == 'Savitzky Golay Filter') or (ListLabel[i] == 'Hagens Filter'):
				self.submenu.addAction(List[i])
				self.iface.mainWindow().menuBar().insertMenu(List[i],self.menu)
			else:	
				self.menu.addAction(List[i])
				self.iface.mainWindow().menuBar().insertMenu(List[i], self.menu)
				
		
	def unload(self):
		for tool in self.tools:
			tool.unload()
		self.menu.deleteLater()	

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import deleteLater [as 别名]
class ProcessingPlugin:

    def __init__(self, iface):
        self.iface = iface

    def initGui(self):
        Processing.initialize()

        self.commander = None
        self.toolbox = ProcessingToolbox()
        self.iface.addDockWidget(Qt.RightDockWidgetArea, self.toolbox)
        self.toolbox.hide()
        Processing.addAlgListListener(self.toolbox)

        self.menu = QMenu(self.iface.mainWindow().menuBar())
        self.menu.setObjectName('processing')
        self.menu.setTitle(self.tr('Pro&cessing'))

        self.toolboxAction = self.toolbox.toggleViewAction()
        self.toolboxAction.setObjectName('toolboxAction')
        self.toolboxAction.setIcon(
            QIcon(os.path.join(cmd_folder, 'images', 'alg.png')))
        self.toolboxAction.setText(self.tr('&Toolbox'))
        self.iface.registerMainWindowAction(self.toolboxAction, 'Ctrl+Alt+T')
        self.menu.addAction(self.toolboxAction)

        self.modelerAction = QAction(
            QIcon(os.path.join(cmd_folder, 'images', 'model.png')),
            self.tr('Graphical &Modeler...'), self.iface.mainWindow())
        self.modelerAction.setObjectName('modelerAction')
        self.modelerAction.triggered.connect(self.openModeler)
        self.iface.registerMainWindowAction(self.modelerAction, 'Ctrl+Alt+M')
        self.menu.addAction(self.modelerAction)

        self.historyAction = QAction(
            QIcon(os.path.join(cmd_folder, 'images', 'history.gif')),
            self.tr('&History...'), self.iface.mainWindow())
        self.historyAction.setObjectName('historyAction')
        self.historyAction.triggered.connect(self.openHistory)
        self.iface.registerMainWindowAction(self.historyAction, 'Ctrl+Alt+H')
        self.menu.addAction(self.historyAction)

        self.configAction = QAction(
            QIcon(os.path.join(cmd_folder, 'images', 'config.png')),
            self.tr('&Options...'), self.iface.mainWindow())
        self.configAction.setObjectName('configAction')
        self.configAction.triggered.connect(self.openConfig)
        self.iface.registerMainWindowAction(self.configAction, 'Ctrl+Alt+C')
        self.menu.addAction(self.configAction)

        self.resultsAction = QAction(
            QIcon(os.path.join(cmd_folder, 'images', 'results.png')),
            self.tr('&Results Viewer...'), self.iface.mainWindow())
        self.resultsAction.setObjectName('resultsAction')
        self.resultsAction.triggered.connect(self.openResults)
        self.iface.registerMainWindowAction(self.resultsAction, 'Ctrl+Alt+R')
        self.menu.addAction(self.resultsAction)

        menuBar = self.iface.mainWindow().menuBar()
        menuBar.insertMenu(
            self.iface.firstRightStandardMenu().menuAction(), self.menu)

        self.commanderAction = QAction(
            QIcon(os.path.join(cmd_folder, 'images', 'commander.png')),
            self.tr('&Commander'), self.iface.mainWindow())
        self.commanderAction.setObjectName('commanderAction')
        self.commanderAction.triggered.connect(self.openCommander)
        self.menu.addAction(self.commanderAction)
        self.iface.registerMainWindowAction(self.commanderAction,
                                            self.tr('Ctrl+Alt+M'))

    def unload(self):
        self.toolbox.setVisible(False)
        self.menu.deleteLater()

        # delete temporary output files
        folder = tempFolder()
        if QDir(folder).exists():
            shutil.rmtree(folder, True)

        self.iface.unregisterMainWindowAction(self.commanderAction)

    def openCommander(self):
        if self.commander is None:
            self.commander = CommanderWindow(
                self.iface.mainWindow(),
                self.iface.mapCanvas())
            Processing.addAlgListListener(self.commander)
        self.commander.prepareGui()
        self.commander.show()

    def openToolbox(self):
        if self.toolbox.isVisible():
            self.toolbox.hide()
        else:
            self.toolbox.show()

    def openModeler(self):
        dlg = ModelerDialog()
        dlg.show()
#.........这里部分代码省略.........

# 需要导入模块: from PyQt4.QtGui import QMenu [as 别名]
# 或者: from PyQt4.QtGui.QMenu import deleteLater [as 别名]
 def contextMenuEvent(self, ev):
     m = QMenu(self)
     a = m.addAction(_("Configure Keyboard Shortcut ({key})").format(key = self.key() or _("None")))
     a.triggered.connect(self.editShortcut)
     m.exec_(ev.globalPos())
     m.deleteLater()