Python PyQt4.QtGui 模块，QMenu() 实例源码

def setLang(self, langName):
        uiList_lang_read = self.memoData['lang'][langName]
        for ui_name in uiList_lang_read:
            ui_element = self.uiList[ui_name]
            if type(ui_element) in [ QtGui.QLabel, QtGui.QPushButton, QtGui.QAction, QtGui.QCheckBox ]:
                # uiType: QLabel, QPushButton, QAction(menuItem), QCheckBox
                if uiList_lang_read[ui_name] != "":
                    ui_element.setText(uiList_lang_read[ui_name])
            elif type(ui_element) in [ QtGui.QGroupBox, QtGui.QMenu ]:
                # uiType: QMenu, QGroupBox
                if uiList_lang_read[ui_name] != "":
                    ui_element.setTitle(uiList_lang_read[ui_name])
            elif type(ui_element) in [ QtGui.QTabWidget]:
                # uiType: QTabWidget
                tabCnt = ui_element.count()
                if uiList_lang_read[ui_name] != "":
                    tabNameList = uiList_lang_read[ui_name].split(';')
                    if len(tabNameList) == tabCnt:
                        for i in range(tabCnt):
                            if tabNameList[i] != "":
                                ui_element.setTabText(i,tabNameList[i])
            elif type(ui_element) == str:
                # uiType: string for msg
                if uiList_lang_read[ui_name] != "":
                    self.uiList[ui_name] = uiList_lang_read[ui_name]

def contextMenuEvent(self, e):
        self.rel_pos = e.pos()
        self.rowClicked = self.rowAt(self.rel_pos.y())
        if self.rowClicked == -1: return
        offset = QtCore.QPoint(self.verticalHeader().width()+3,self.horizontalHeader().height()+3)
        menu = QtGui.QMenu(self)
        if len(self.selectedIndexes())==4:
            if self.model().downloadlist[self.rowClicked].progress == '- - -':
                if self.model().downloadlist[self.rowClicked].support_resume:
                  menu.addAction(QtGui.QIcon.fromTheme('media-playback-start'), "Resume", self.pause_resume)
                else:
                  menu.addAction(QtGui.QIcon.fromTheme('view-refresh'), "Restart", self.pause_resume)
            else:
                if self.model().downloadlist[self.rowClicked].support_resume:
                    menu.addAction(QtGui.QIcon.fromTheme('media-playback-pause'), "Pause", self.pause_resume)
                else:
                    menu.addAction(QtGui.QIcon.fromTheme('process-stop'), "Stop", self.pause_resume)
            menu.addAction(QtGui.QIcon.fromTheme('edit-copy'), "Copy Address", self.copy_address)
        menu.addAction(QtGui.QIcon.fromTheme('edit-clear'), "Remove Download", self.remove_selected)
        menu.addAction(QtGui.QIcon.fromTheme('edit-delete'), "Delete File(s)", self.delete_selected)
        menu.exec_(self.mapToGlobal(self.rel_pos + offset))

def contextMenuEvent(self, event):
        '''Generate Context menu on context menu event.

        :param event: QContextMenuEvent. 
        '''
        menu = QtGui.QMenu()
        if self.substitutionTransition:
            self.contextMenuOpen = menu.addAction('Open Subnet')
            self.contextMenuOpen.triggered.connect(self.openSubnet)
            self.contextMenuImport = menu.addAction('Import Subnet')
            self.contextMenuImport.triggered.connect(self.importSubnet)
        else:
            self.contextMenuGurad = menu.addAction('Edit Guard Expression')
            self.contextMenuGurad.triggered.connect(self.editGuard)
        self.delete = menu.addAction('Delete Item')
        self.delete.triggered.connect(self.deleteItemLocal)
        menu.exec_(event.screenPos())
    #------------------------------------------------------------------------------------------------

#========================================================================================================================

def _create_slice_view_context_menu(self, subplot_index):
        context_menu = QMenu("Slice Model Reassignment Menu", self)

        def reassign(model):
            def fn():
                self._assigned_slice_models[subplot_index] = model
                self._layout_changed()

            return fn

        for model in self._context.models:
            action = QAction(model.title, self)
            action.triggered.connect(reassign(model))
            context_menu.addAction(action)

        return context_menu

def editSects(self):
        config = ConfigParser.RawConfigParser()
        config.read(self.config_file)
        sections = sorted(config.sections())
        menu = QtGui.QMenu()
        stns = []
        for section in sections:
            stns.append(menu.addAction(section))
            x = self.frameGeometry().left() + 50
            y = self.frameGeometry().y() + 50
        action = menu.exec_(QtCore.QPoint(x, y))
        if action is not None:
            section = str(action.text())
            EditSect(section, self.scenarios)
            comment = section + ' Section edited. Reload may be required.'
            self.view.emit(QtCore.SIGNAL('statusmsg'), comment)

def go_ToLoad(self):
        if len(self.view.scene().load_centre) == 1:
            j = 0
        else:
            menu = QtGui.QMenu()
            ctrs = []
            for ctr in self.view.scene().load_centre:
                ctrs.append(menu.addAction(ctr[0]))
           #      ctrs[-1].setIconVisibleInMenu(True)
            x = self.frameGeometry().left() + 50
            y = self.frameGeometry().y() + 50
            action = menu.exec_(QtCore.QPoint(x, y))
            if action is not None:
                for j in range(len(self.view.scene().load_centre)):
                    if action.text() == self.view.scene().load_centre[j][0]:
                        break
        if j < len(self.view.scene().load_centre):
            go_to = self.mapFromLonLat(QtCore.QPointF(self.view.scene().load_centre[j][2],
                    self.view.scene().load_centre[j][1]))
            self.view.centerOn(go_to)
            comment = '(%s,%s) Centred on %s Load Centre' % (
                      '{:0.4f}'.format(self.view.scene().load_centre[j][1]),
                      '{:0.4f}'.format(self.view.scene().load_centre[j][2]),
                      self.view.scene().load_centre[j][0])
            self.view.emit(QtCore.SIGNAL('statusmsg'), comment)

def editSects(self):
        config = ConfigParser.RawConfigParser()
        config.read(self.config_file)
        sections = sorted(config.sections())
        menu = QtGui.QMenu()
        stns = []
        for section in sections:
            stns.append(menu.addAction(section))
            x = self.frameGeometry().left() + 50
            y = self.frameGeometry().y() + 50
        action = menu.exec_(QtCore.QPoint(x, y))
        if action is not None:
            section = str(action.text())
            EditSect(section, None, ini_file=self.config_file)
            comment = section + ' Section edited. Reload may be required.'
            self.view.emit(QtCore.SIGNAL('statusmsg'), comment)

def __init__(self,cls,**kwargs):
            super(utilitiesClass.sensorIcon, self).__init__()
            self.cls = cls
            self.setupUi(self)
            self.hintLabel.setText(kwargs.get('hint',''))
            self.func = cls.getRaw
            self.plotnames = cls.PLOTNAMES
            self.menu = self.PermanentMenu()
            self.menu.setMinimumHeight(25)
            self.sub_menu = QtGui.QMenu('%s:%s'%(hex(cls.ADDRESS),cls.name[:15]))
            for i in cls.params: 
                mini=self.sub_menu.addMenu(i) 
                for a in cls.params[i]:
                    Callback = functools.partial(getattr(cls,i),a)      
                    mini.addAction(str(a),Callback)
            self.menu.addMenu(self.sub_menu)
            self.formLayout.insertWidget(0,self.menu)

def setup_browser_menu(self):
    #self is browser
    try:
        # used by multiple add-ons, so we check for its existence first
        menu = self.menuTags
    except:
        self.menuTags = QMenu(_("Tags"))
        action = self.menuBar().insertMenu(self.mw.form.menuTools.menuAction(), self.menuTags)
    menu = self.menuTags
    menu.addSeparator()
    unseen_menu = menu.addMenu("Unseen Card Tracking")
    a = unseen_menu.addAction('Add "Unseen" Tags to Selected Cards')
    a.setShortcut(QKeySequence("Ctrl+U"))
    self.connect(a, SIGNAL("triggered()"), lambda b=self: add_unseen_tags_to_selected(b))
    a = unseen_menu.addAction('Remove "Unseen" Tags from Selected Cards')
    a.setShortcut(QKeySequence("Ctrl+Shift+U"))
    self.connect(a, SIGNAL("triggered()"), lambda b=self: remove_unseen_tags_from_selected(b))
    a = unseen_menu.addAction('Show all Unseen Cards')
    a.setShortcut(QKeySequence("Ctrl+Alt+U"))
    self.connect(a, SIGNAL("triggered()"), lambda b=self: show_all_unseen_cards(b))

#todo: menu action to set search string to show all

def setupUi(self, Window):

        # create main window
        Window.setWindowModality(QtCore.Qt.ApplicationModal)
        Window.resize(1000,600)        


        # create menubar with File, DRASTIC and Help sections
        Window.menuBar = QtGui.QMenuBar()
        Window.menuFile = QtGui.QMenu("File", self)
        Window.menuDrastic = QtGui.QMenu("DRASTIC", self)
        Window.menuGod = QtGui.QMenu("GOD", self)
        Window.menuHelp = QtGui.QMenu("Help", self)      
        Window.setMenuBar(Window.menuBar)


        self.retranslateUi(Window)
        #QtCore.QMetaObject.connectSlotsByName(Window)

        Window.show()

def qui_menu(self, action_list_str, menu_str):
        # qui menu creation
        # syntax: self.qui_menu('right_menu_createFolder_atn;Create Folder,Ctrl+D | right_menu_openFolder_atn;Open Folder', 'right_menu')
        if menu_str not in self.uiList.keys():
            self.uiList[menu_str] = QtWidgets.QMenu()
        create_opt_list = [ x.strip() for x in action_list_str.split('|') ]
        for each_creation in create_opt_list:
            ui_info = [ x.strip() for x in each_creation.split(';') ]
            atn_name = ui_info[0]
            atn_title = ''
            atn_hotkey = ''
            if len(ui_info) > 1:
                options = ui_info[1].split(',')
                atn_title = '' if len(options) < 1 else options[0]
                atn_hotkey = '' if len(options) < 2 else options[1]
            if atn_name != '':
                if atn_name == '_':
                    self.uiList[menu_str].addSeparator()
                else:
                    if atn_name not in self.uiList.keys():
                        self.uiList[atn_name] = QtWidgets.QAction(atn_title, self)
                        if atn_hotkey != '':
                            self.uiList[atn_name].setShortcut(QtGui.QKeySequence(atn_hotkey))
                    self.uiList[menu_str].addAction(self.uiList[atn_name])

def qui_menubar(self, menu_list_str):
        if not isinstance(self, QtWidgets.QMainWindow):
            print("Warning: Only QMainWindow can have menu bar.")
            return
        menubar = self.menuBar()
        create_opt_list = [ x.strip() for x in menu_list_str.split('|') ]
        for each_creation in create_opt_list:
            ui_info = [ x.strip() for x in each_creation.split(';') ]
            menu_name = ui_info[0]
            menu_title = ''
            if len(ui_info) > 1:
                menu_title = ui_info[1]
            if menu_name not in self.uiList.keys():
                self.uiList[menu_name] = QtWidgets.QMenu(menu_title)
            menubar.addMenu(self.uiList[menu_name])
    # compatible hold function

def setLang(self, langName):
        uiList_lang_read = self.memoData['lang'][langName]
        for ui_name in uiList_lang_read:
            ui_element = self.uiList[ui_name]
            if type(ui_element) in [ QtWidgets.QLabel, QtWidgets.QPushButton, QtWidgets.QAction, QtWidgets.QCheckBox ]:
                # uiType: QLabel, QPushButton, QAction(menuItem), QCheckBox
                if uiList_lang_read[ui_name] != "":
                    ui_element.setText(uiList_lang_read[ui_name])
            elif type(ui_element) in [ QtWidgets.QGroupBox, QtWidgets.QMenu ]:
                # uiType: QMenu, QGroupBox
                if uiList_lang_read[ui_name] != "":
                    ui_element.setTitle(uiList_lang_read[ui_name])
            elif type(ui_element) in [ QtWidgets.QTabWidget]:
                # uiType: QTabWidget
                tabCnt = ui_element.count()
                if uiList_lang_read[ui_name] != "":
                    tabNameList = uiList_lang_read[ui_name].split(';')
                    if len(tabNameList) == tabCnt:
                        for i in range(tabCnt):
                            if tabNameList[i] != "":
                                ui_element.setTabText(i,tabNameList[i])
            elif type(ui_element) == str:
                # uiType: string for msg
                if uiList_lang_read[ui_name] != "":
                    self.uiList[ui_name] = uiList_lang_read[ui_name]

def setLang(self, langName):
        uiList_lang_read = self.memoData['lang'][langName]
        for ui_name in uiList_lang_read:
            ui_element = self.uiList[ui_name]
            if type(ui_element) in [ QtGui.QLabel, QtGui.QPushButton, QtGui.QAction, QtGui.QCheckBox ]:
                # uiType: QLabel, QPushButton, QAction(menuItem), QCheckBox
                if uiList_lang_read[ui_name] != "":
                    ui_element.setText(uiList_lang_read[ui_name])
            elif type(ui_element) in [ QtGui.QGroupBox, QtGui.QMenu ]:
                # uiType: QMenu, QGroupBox
                if uiList_lang_read[ui_name] != "":
                    ui_element.setTitle(uiList_lang_read[ui_name])
            elif type(ui_element) in [ QtGui.QTabWidget]:
                # uiType: QTabWidget
                tabCnt = ui_element.count()
                if uiList_lang_read[ui_name] != "":
                    tabNameList = uiList_lang_read[ui_name].split(';')
                    if len(tabNameList) == tabCnt:
                        for i in range(tabCnt):
                            if tabNameList[i] != "":
                                ui_element.setTabText(i,tabNameList[i])
            elif type(ui_element) == str:
                # uiType: string for msg
                if uiList_lang_read[ui_name] != "":
                    self.uiList[ui_name] = uiList_lang_read[ui_name]

def setLang(self, langName):
        uiList_lang_read = self.memoData['lang'][langName]
        for ui_name in uiList_lang_read:
            ui_element = self.uiList[ui_name]
            if type(ui_element) in [ QtWidgets.QLabel, QtWidgets.QPushButton, QtWidgets.QAction, QtWidgets.QCheckBox ]:
                # uiType: QLabel, QPushButton, QAction(menuItem), QCheckBox
                if uiList_lang_read[ui_name] != "":
                    ui_element.setText(uiList_lang_read[ui_name])
            elif type(ui_element) in [ QtWidgets.QGroupBox, QtWidgets.QMenu ]:
                # uiType: QMenu, QGroupBox
                if uiList_lang_read[ui_name] != "":
                    ui_element.setTitle(uiList_lang_read[ui_name])
            elif type(ui_element) in [ QtWidgets.QTabWidget]:
                # uiType: QTabWidget
                tabCnt = ui_element.count()
                if uiList_lang_read[ui_name] != "":
                    tabNameList = uiList_lang_read[ui_name].split(';')
                    if len(tabNameList) == tabCnt:
                        for i in range(tabCnt):
                            if tabNameList[i] != "":
                                ui_element.setTabText(i,tabNameList[i])
            elif type(ui_element) == str:
                # uiType: string for msg
                if uiList_lang_read[ui_name] != "":
                    self.uiList[ui_name] = uiList_lang_read[ui_name]

def setLang(self, langName):
        uiList_lang_read = self.memoData['lang'][langName]
        for ui_name in uiList_lang_read:
            ui_element = self.uiList[ui_name]
            if type(ui_element) in [ QtWidgets.QLabel, QtWidgets.QPushButton, QtWidgets.QAction, QtWidgets.QCheckBox ]:
                # uiType: QLabel, QPushButton, QAction(menuItem), QCheckBox
                if uiList_lang_read[ui_name] != "":
                    ui_element.setText(uiList_lang_read[ui_name])
            elif type(ui_element) in [ QtWidgets.QGroupBox, QtWidgets.QMenu ]:
                # uiType: QMenu, QGroupBox
                if uiList_lang_read[ui_name] != "":
                    ui_element.setTitle(uiList_lang_read[ui_name])
            elif type(ui_element) in [ QtWidgets.QTabWidget]:
                # uiType: QTabWidget
                tabCnt = ui_element.count()
                if uiList_lang_read[ui_name] != "":
                    tabNameList = uiList_lang_read[ui_name].split(';')
                    if len(tabNameList) == tabCnt:
                        for i in range(tabCnt):
                            if tabNameList[i] != "":
                                ui_element.setTabText(i,tabNameList[i])
            elif type(ui_element) == str:
                # uiType: string for msg
                if uiList_lang_read[ui_name] != "":
                    self.uiList[ui_name] = uiList_lang_read[ui_name]

def setLang(self, langName):
        uiList_lang_read = self.memoData['lang'][langName]
        for ui_name in uiList_lang_read:
            ui_element = self.uiList[ui_name]
            if type(ui_element) in [ QtWidgets.QLabel, QtWidgets.QPushButton, QtWidgets.QAction, QtWidgets.QCheckBox ]:
                # uiType: QLabel, QPushButton, QAction(menuItem), QCheckBox
                if uiList_lang_read[ui_name] != "":
                    ui_element.setText(uiList_lang_read[ui_name])
            elif type(ui_element) in [ QtWidgets.QGroupBox, QtWidgets.QMenu ]:
                # uiType: QMenu, QGroupBox
                if uiList_lang_read[ui_name] != "":
                    ui_element.setTitle(uiList_lang_read[ui_name])
            elif type(ui_element) in [ QtWidgets.QTabWidget]:
                # uiType: QTabWidget
                tabCnt = ui_element.count()
                if uiList_lang_read[ui_name] != "":
                    tabNameList = uiList_lang_read[ui_name].split(';')
                    if len(tabNameList) == tabCnt:
                        for i in range(tabCnt):
                            if tabNameList[i] != "":
                                ui_element.setTabText(i,tabNameList[i])
            elif type(ui_element) == str:
                # uiType: string for msg
                if uiList_lang_read[ui_name] != "":
                    self.uiList[ui_name] = uiList_lang_read[ui_name]

def createMenus(self):
        self.fileMenu = QtGui.QMenu("&File", self)
        self.fileMenu.addAction(self.openAct)
        self.fileMenu.addAction(self.printAct)
        self.fileMenu.addSeparator()
        self.fileMenu.addAction(self.exitAct)

        self.viewMenu = QtGui.QMenu("&View", self)
        self.viewMenu.addAction(self.zoomInAct)
        self.viewMenu.addAction(self.zoomOutAct)
        self.viewMenu.addAction(self.normalSizeAct)
        self.viewMenu.addSeparator()
        self.viewMenu.addAction(self.fitToWindowAct)

        self.helpMenu = QtGui.QMenu("&Help", self)
        self.helpMenu.addAction(self.aboutAct)
        self.helpMenu.addAction(self.aboutQtAct)

        self.menuBar().addMenu(self.fileMenu)
        self.menuBar().addMenu(self.viewMenu)
        self.menuBar().addMenu(self.helpMenu)

def contextMenuEvent(self, event):
        global name,tmp_name,opt,list1_items,curR,nxtImg_cnt,home,site,pre_opt,base_url,category

        #print name
        menu = QtGui.QMenu(self)

        history = menu.addAction("History")
        anime = menu.addAction("Animes")
        movie = menu.addAction("Movies")
        action = menu.exec_(self.mapToGlobal(event.pos()))
        if action == history:
            ui.setPreOpt()
        elif action == anime:
            category = "Animes"
        elif action == movie:
            category = "Movies"
        #super(List2, self).keyPressEvent(event)

def contextMenuEvent(self, event):
        global name,tmp_name,opt,list1_items,curR,nxtImg_cnt,home,site,pre_opt,base_url,category

        #print name
        menu = QtGui.QMenu(self)

        hd = menu.addAction("Hide Search Table")
        sideBar = menu.addAction("Show Sidebar")
        history = menu.addAction("Show History")
        action = menu.exec_(self.mapToGlobal(event.pos()))
        if action == hd:
            self.hide()
        elif action == sideBar:
            if ui.dockWidget_3.isHidden():
                ui.dockWidget_3.show()
                ui.btn1.setFocus()
            else:
                ui.dockWidget_3.hide()
                ui.list1.setFocus()
        elif action == history:
            ui.setPreOpt()

def __init__(self, pos_x,pos_y,w_wdt,w_ht,parent=None):
        QtGui.QMenu.__init__(self, "File", parent)
        self.pos_x = pos_x
        self.pos_y = pos_y
        self.w_wdt = w_wdt
        self.w_ht = w_ht

        musicMode = QtGui.QAction("&Music Mode", self)
        musicMode.triggered.connect(self.music)
        self.addAction(musicMode)

        videoMode = QtGui.QAction("&Default Mode", self)
        videoMode.triggered.connect(self.video)
        self.addAction(videoMode)

        icon = QtGui.QIcon.fromTheme("Quit")
        exitAction = QtGui.QAction(icon, "&Exit", self)
        exitAction.triggered.connect(QtGui.qApp.quit)
        #exitAction.triggered.connect(MainWindow.close())
        self.addAction(exitAction)

def openContextMenuMappingsTable(self):

        if self.ui.tableWidgetKnownMappings.rowCount() == 0:
            return

        menu = QtGui.QMenu()

        # Add delete mapping function to menu
        menu.addAction("Delete mapping").triggered.connect(self.deleteMapping)

        # Add delete all mappings function to menu
        menu.addAction("Delete all mappings").triggered.connect(self.deleteAllMappings)

        position = QtGui.QCursor.pos()

        menu.exec_(position)

def on_explorer_customContextMenuRequested(self,position):
        item = self.explorer.itemAt(position)
        if isinstance(item,explorer_widget.TextureItem):
            menu = QtGui.QMenu(self)
            menu.addAction(self.action_texture_export)
            menu.addAction(self.action_texture_replace)
            menu.exec_(self.explorer.mapToGlobal(position))

def contextMenuEvent(self, event):
        '''Generate Context menu on context menu event.

        :param event: QContextMenuEvent.   
        '''
        menu = QtGui.QMenu()
        self.delete = menu.addAction('Delete')
        self.delete.triggered.connect(self.deleteItemLocal)
        menu.exec_(event.screenPos())
    #------------------------------------------------------------------------------------------------

#========================================================================================================================

def contextMenuEvent(self, event):
        '''Generate Context menu on context menu event.

        :param event: QContextMenuEvent.
        '''
        menu = QtGui.QMenu()
        self.delete = menu.addAction('Delete')
        self.delete.triggered.connect(self.deleteItemLocal)
        self.contextMenuEditPort = menu.addAction('Edit Port')
        self.contextMenuEditPort.triggered.connect(self.editPort)
        menu.exec_(event.screenPos())
    #------------------------------------------------------------------------------------------------

def contextMenuEvent(self, event):
        '''Generate Context menu on context menu event.

        :param event: QContextMenuEvent. 
        '''
        menu = QtGui.QMenu()
        self.contextMenuPortSet = menu.addAction('Set Port')
        self.contextMenuPortSet.triggered.connect(self.setPortDiag)
        self.delete = menu.addAction('Delete')
        self.delete.triggered.connect(self.deleteItemLocal)
        menu.exec_(event.screenPos())
    #------------------------------------------------------------------------------------------------

#========================================================================================================================

def setupUi(self, EditorDialog):
        EditorDialog.setObjectName(_fromUtf8("EditorDialog"))
        EditorDialog.setWindowModality(QtCore.Qt.ApplicationModal)
        EditorDialog.resize(640, 600)
        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Preferred, QtGui.QSizePolicy.Preferred)
        sizePolicy.setHorizontalStretch(0)
        sizePolicy.setVerticalStretch(0)
        sizePolicy.setHeightForWidth(EditorDialog.sizePolicy().hasHeightForWidth())
        EditorDialog.setSizePolicy(sizePolicy)
        EditorDialog.setWindowTitle(_("LinkChecker source view"))
        self.verticalLayout = QtGui.QVBoxLayout(EditorDialog)
        self.verticalLayout.setMargin(0)
        self.verticalLayout.setObjectName(_fromUtf8("verticalLayout"))
        self.menubar = QtGui.QMenuBar(EditorDialog)
        self.menubar.setObjectName(_fromUtf8("menubar"))
        self.menuFile = QtGui.QMenu(self.menubar)
        self.menuFile.setTitle(_("&File"))
        self.menuFile.setObjectName(_fromUtf8("menuFile"))
        self.verticalLayout.addWidget(self.menubar)
        self.frame = QtGui.QFrame(EditorDialog)
        sizePolicy = QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
        sizePolicy.setHorizontalStretch(0)
        sizePolicy.setVerticalStretch(0)
        sizePolicy.setHeightForWidth(self.frame.sizePolicy().hasHeightForWidth())
        self.frame.setSizePolicy(sizePolicy)
        self.frame.setFrameShape(QtGui.QFrame.NoFrame)
        self.frame.setFrameShadow(QtGui.QFrame.Plain)
        self.frame.setLineWidth(0)
        self.frame.setObjectName(_fromUtf8("frame"))
        self.verticalLayout.addWidget(self.frame)
        self.actionSave = QtGui.QAction(EditorDialog)
        self.actionSave.setText(_("&Save"))
        self.actionSave.setShortcut(_("Ctrl+S"))
        self.actionSave.setObjectName(_fromUtf8("actionSave"))
        self.menuFile.addAction(self.actionSave)
        self.menubar.addAction(self.menuFile.menuAction())

        self.retranslateUi(EditorDialog)
        QtCore.QMetaObject.connectSlotsByName(EditorDialog)

def initMenu(self):
        """???????"""
        self.menu = QtGui.QMenu(self)    

        saveAction = QtGui.QAction(u'????', self)
        saveAction.triggered.connect(self.saveToCsv)

        self.menu.addAction(saveAction)

    #----------------------------------------------------------------------

def go_ToTown(self):
     #   to cater for windows I've created submenus
        menu = QtGui.QMenu()
        twns = []
        submenus = []
        submenus.append(QtGui.QMenu('A...'))
        titl = ''
        ctr = 0
        for town in sorted(self.view.scene()._towns.towns, key=lambda town: town.name):
            if titl == '':
                titl = town.name + ' to '
            twns.append(submenus[-1].addAction(town.name))
            twns[-1].setIconVisibleInMenu(True)
            ctr += 1
            if ctr > 25:
                titl += town.name
                submenus[-1].setTitle(titl)
                titl = ''
                menu.addMenu(submenus[-1])
                submenus.append(QtGui.QMenu(town.name[0] + '...'))
                ctr = 0
        titl += town.name
        submenus[-1].setTitle(titl)
        menu.addMenu(submenus[-1])
        x = self.frameGeometry().left() + 50
        y = self.frameGeometry().y() + 50
        action = menu.exec_(QtCore.QPoint(x, y))
        if action is not None:
            town = self.view.scene()._towns.Get_Town(action.text())
            go_to = self.mapFromLonLat(QtCore.QPointF(town.lon, town.lat))
            self.view.centerOn(go_to)
            comment = '(%s,%s) Centred on town %s' % ('{:0.4f}'.format(town.lon), '{:0.4f}'.format(town.lat),
                          town.name)
            self.view.emit(QtCore.SIGNAL('statusmsg'), comment)

def show_Grid(self):
        self.view.clear_Trace()
        menu = QtGui.QMenu()
        lins = []
       #  for li in range(len(self.view.scene().lines.lines)): #.grid_lines):
        for li in range(self.view.scene().grid_lines):
            lins.append(menu.addAction(self.view.scene().lines.lines[li].name))
            lins[-1].setIconVisibleInMenu(True)
        if self.view.scene().load_centre is not None:
            for li in range(self.view.scene().grid_lines, len(self.view.scene().lines.lines)):
                for j in range(len(self.view.scene().load_centre)):
                    if self.view.scene().lines.lines[li].coordinates[-1] == [self.view.scene().load_centre[j][1],
                       self.view.scene().load_centre[j][2]]:
                        lins.append(menu.addAction(self.view.scene().lines.lines[li].name))
                        lins[-1].setIconVisibleInMenu(True)
        x = self.frameGeometry().left() + 50
        y = self.frameGeometry().y() + 50
        action = menu.exec_(QtCore.QPoint(x, y))
        if action is not None:
            for li in range(len(self.view.scene().lines.lines)):
                if self.view.scene().lines.lines[li].name == action.text():
                    grid_path_len = self.view.traceGrid(None, coords=self.view.scene().lines.lines[li].coordinates)
            try:
                self.view.emit(QtCore.SIGNAL('statusmsg'), 'Grid traced for %s (%s, %s Km)' % (action.text(),
                               self.view.scene().lines.lines[li].line_table, '{:0.1f}'.format(grid_path_len)))
            except:
                self.view.emit(QtCore.SIGNAL('statusmsg'), 'No Grid line for %s' % action.text())

def createMenu(self,cls,addr):
        menu = self.PermanentMenu()
        menu.setMinimumHeight(25)
        sub_menu = QtGui.QMenu('%s:%s'%(hex(addr),cls.name[:15]))
        for i in cls.params: 
            mini=sub_menu.addMenu(i) 
            for a in cls.params[i]:
                Callback = functools.partial(getattr(cls,i),a)      
                mini.addAction(str(a),Callback) 
        menu.addMenu(sub_menu)
        self.paramMenus.insertWidget(0,menu)
        self.deviceMenus.append(menu)
        self.deviceMenus.append(sub_menu)

def createMenu(self,cls,addr):
        menu = self.PermanentMenu()
        menu.setMinimumHeight(25)
        sub_menu = QtGui.QMenu('%s:%s'%(hex(addr),cls.name[:15]))
        for i in cls.params: 
            mini=sub_menu.addMenu(i) 
            for a in cls.params[i]:
                Callback = functools.partial(getattr(cls,i),a)      
                mini.addAction(str(a),Callback) 
        menu.addMenu(sub_menu)
        self.paramMenus.insertWidget(1,menu)
        self.deviceMenus.append(menu)
        self.deviceMenus.append(sub_menu)

def createMenu(self,bridge):
        menu = self.PermanentMenu()
        menu.setMinimumHeight(25)
        sub_menu = QtGui.QMenu('%s:%s'%(hex(bridge.ADDRESS),bridge.name[:15]))
        for i in bridge.params: 
            mini=sub_menu.addMenu(i) 
            for a in bridge.params[i]:
                Callback = functools.partial(getattr(bridge,i),a)
                mini.addAction(str(a),Callback)
        menu.addMenu(sub_menu)
        self.paramMenus.insertWidget(0,menu)
        self.deviceMenus.append(menu)
        self.deviceMenus.append(sub_menu)

def __init__(self, icon, parent=None):
        QtGui.QSystemTrayIcon.__init__(self, icon, parent)
        menu = QtGui.QMenu(parent)

def display_shards_queue_table_context_menu(self, position):
        tablemodel = self.ui_single_file_upload.shard_queue_table_widget.model()
        rows = sorted(set(index.row() for index in
                          self.ui_single_file_upload.shard_queue_table_widget.
                          selectedIndexes()))
        i = 0
        selected_row = 0
        any_row_selected = False
        for row in rows:
            any_row_selected = True
            node_index = tablemodel.index(row, 2)  # get nodeID
            # We suppose data are strings
            selected_node_addr = str(tablemodel.data(
                node_index).toString())
            selected_node_addr_parsed = selected_node_addr.split("/")
            selected_row = row
            i += 1

        if any_row_selected:
            menu = QtGui.QMenu()
            nodeDetailsAction = menu.addAction('Node details...')
            action = menu.exec_(self.ui_single_file_upload.shard_queue_table_widget.mapToGlobal(position))

            if action == nodeDetailsAction:
                self.node_details_window = NodeDetailsUI(self, selected_node_addr_parsed[1])
                self.node_details_window.show()
                print "Node details requested"

def display_files_table_context_menu(self, position):
        tablemodel = self.ui_single_file_upload.files_queue_table_widget.model()
        rows = sorted(set(index.row() for index in
                          self.ui_single_file_upload.files_queue_table_widget.
                          selectedIndexes()))
        i = 0
        selected_row = 0
        any_row_selected = False
        for row in rows:
            any_row_selected = True
            filename_index = tablemodel.index(row, 0)  # get shard Index
            # We suppose data are strings
            self.current_selected_file_name = str(tablemodel.data(
                filename_index).toString())
            selected_row = row
            i += 1

        if any_row_selected:
            menu = QtGui.QMenu()
            fileDeleteFromTableAction = menu.addAction('Delete file from table')
            action = menu.exec_(self.ui_single_file_upload.files_queue_table_widget.mapToGlobal(position))

            if action == fileDeleteFromTableAction:
                # ask user and delete if sure
                msgBox = QtGui.QMessageBox(
                    QtGui.QMessageBox.Question,
                    'Question',
                    'Are you sure that you want to remove file '
                    '"%s" from upload queue?' %
                    str(self.current_selected_file_name),
                    QtGui.QMessageBox.Yes | QtGui.QMessageBox.No)

                result = msgBox.exec_()

                if result == QtGui.QMessageBox.Yes:
                    self.ui_single_file_upload.files_queue_table_widget.removeRow(int(selected_row))
                    print "Delete action"

def create(self):
        MainWindow = QtGui.QMainWindow()
        self.ui.setupUi(MainWindow)
        self.ui.label_2.setAlignment(QtCore.Qt.AlignCenter)
        self.sync_object = sync()
        QObject.connect(self.ui.pushButton,SIGNAL("clicked()"),self.sync_object.Login)
        QObject.connect(self.ui.pushButton_5,SIGNAL("clicked()"),self.makeTreeView)
        QObject.connect(self.ui.pushButton_2,SIGNAL("clicked()"),self.select_folder)
        # QObject.connect(self.ui.pushButton_2,SIGNAL("clicked()"),self.openFileDialog)
        self.treeMenu =  QtGui.QMenu()
        self.treeAction = QtGui.QAction('Download', self.treeMenu)
        self.treeAction.triggered.connect(self.download_folder)
        self.ui.treeWidget.addAction(self.treeAction)
        MainWindow.show()
        sys.exit(app.exec_())

def addMenuItem():
    mw.form.menuView = QMenu("&View", mw)
    mw.form.menuView.toggleHidden = QAction("Hide dotted decks", mw, checkable=True)
    mw.form.menuView.toggleHidden.toggled.connect(onToggleHidden)
    mw.form.menubar.insertMenu(mw.form.menuTools.menuAction(), mw.form.menuView)
    mw.form.menuView.addAction(mw.form.menuView.toggleHidden)

def createColorMenu(self, slot, defaultColor):
        colors = [QtCore.Qt.black, QtCore.Qt.white, QtCore.Qt.red, QtCore.Qt.blue, QtCore.Qt.yellow]
        names = ["black", "white", "red", "blue", "yellow"]

        colorMenu = QtGui.QMenu(self)
        for color, name in zip(colors, names):
            action = QtGui.QAction(name, self)
            action.setData(QtCore.QVariant(QtGui.QColor(color))) 
            action.setIcon(self.createColorIcon(color))
            action.triggered.connect(slot)
            colorMenu.addAction(action)
            if color == defaultColor:
                colorMenu.setDefaultAction(action)
        return colorMenu

def init_style_menu(self):
        self.ui_controller.styleMenu = QtGui.QMenu(self)
        self.ui_controller.lineChartAction = QtGui.QAction("Line", self)
        self.ui_controller.areaChartAction = QtGui.QAction("Area", self)
        self.ui_controller.barChartAction = QtGui.QAction("Bar", self)
        self.ui_controller.candleChartAction = QtGui.QAction("Candle", self)
        self.ui_controller.styleMenu.addAction(self.ui_controller.lineChartAction)
        self.ui_controller.styleMenu.addAction(self.ui_controller.areaChartAction)
        self.ui_controller.styleMenu.addAction(self.ui_controller.barChartAction)
        self.ui_controller.styleMenu.addAction(self.ui_controller.candleChartAction)
        self.ui_controller.styleToolButton.setMenu(self.ui_controller.styleMenu)

def init_indicator_menu(self):
        self.ui_controller.indicatorMenu = QtGui.QMenu(self)
        self.ui_controller.indicator_SMAAction = QtGui.QAction("Simple Moving Average (SMA)", self)
        self.ui_controller.indicator_EMAAction = QtGui.QAction("Exponential Moving Average (EMA)", self)
        self.ui_controller.indicator_MACDAction = QtGui.QAction("MACD", self)
        self.ui_controller.indicator_RSIAction = QtGui.QAction("Relative Strength Index (RSI)", self)
        self.ui_controller.indicatorMenu.addAction(self.ui_controller.indicator_SMAAction)
        self.ui_controller.indicatorMenu.addAction(self.ui_controller.indicator_EMAAction)
        self.ui_controller.indicatorMenu.addAction(self.ui_controller.indicator_MACDAction)
        self.ui_controller.indicatorMenu.addAction(self.ui_controller.indicator_RSIAction)
        self.ui_controller.indicatorToolButton.setMenu(self.ui_controller.indicatorMenu)

def showMenu(self, position):
        indexes = self.ui_controller.strategyListWidget.selectedIndexes()
        if len(indexes) > 0:
            menu = QtGui.QMenu()
            menu.addAction(self.ui_controller.actionRunStrategy)
            menu.addAction(self.ui_controller.actionEditStrategy)
            menu.exec_(self.ui_controller.strategyListWidget.viewport().mapToGlobal(position))

def __init__(self, trayIcon):
        """ trayIcon = the object with the methods to call
        """
        QtGui.QMenu.__init__(self)
        TrayContextMenu.instances.add(self)
        self.trayIcon = trayIcon
        self._buildMenu()

def tray_icon(self):
        self.trayicon=QtGui.QSystemTrayIcon(QtGui.QIcon(':pix/pix/tuxcut.png'))
        self.trayicon.show()
        self.menu=QtGui.QMenu()

        self.menu.addAction(self.action_change_mac)
        self.menu.addAction(self.action_quit)

        self.trayicon.setContextMenu(self.menu)
        self.trayicon.activated.connect(self.onTrayIconActivated)

def __init__(self, parent):
        super(MDImg, self).__init__(parent)

        self.tray = QtGui.QSystemTrayIcon(QtGui.QIcon('icon.ico'), self)
        self.menu = QtGui.QMenu(self)

        exitAction = QtGui.QAction(
            "E&xit", self, shortcut="Ctrl+Q",
            statusTip="Exit the application", triggered=self.close)

        self.enableAction = QtGui.QAction(
            "&Enable", self, shortcut='Ctrl+E',
            statusTip='Enable monitor the clipboard', checkable=True)

        self.historyMenu = QtGui.QMenu("&History")

        self.enableAction.setChecked(True)

        self.menu.addMenu(self.historyMenu)
        self.menu.addAction(self.enableAction)
        self.menu.addAction(exitAction)

        self.tray.setContextMenu(self.menu)
        self.tray.setToolTip('upload qiniu')
        self.history = {'urls':[], 'titles':{}}

        self.load_history()
        self.load_config()
        self.img_dir = './imgs'
        if not os.path.exists('./imgs'):
             os.mkdir('./imgs')

def mousePressEvent(self, e):
        if e.buttons() != QtCore.Qt.RightButton:
            return QtGui.QTreeWidget.mousePressEvent(self, e)

        hasSelection = len(self.selectionModel().selectedRows()) > 0

        menu = QtGui.QMenu('')

        copyAction = QtGui.QAction(Lang.value('MI_Copy'), self)
        copyAction.triggered.connect(self.onCopy)
        copyAction.setEnabled(hasSelection)
        menu.addAction(copyAction)

        cutAction = QtGui.QAction(Lang.value('MI_Cut'), self)
        cutAction.triggered.connect(self.onCut)
        cutAction.setEnabled(hasSelection)
        menu.addAction(cutAction)

        pasteAction = QtGui.QAction(Lang.value('MI_Paste'), self)
        pasteAction.triggered.connect(self.onPaste)
        pasteAction.setEnabled(len(self.clipboard.text()) > 0)
        menu.addAction(pasteAction)

        saveSelection = QtGui.QAction(Lang.value('MI_Save_selection_as'), self)
        saveSelection.triggered.connect(self.onSaveSelectionAs)
        saveSelection.setEnabled(hasSelection)
        menu.addAction(saveSelection)

        menu.exec_(e.globalPos())

def mousePressEvent(self, e):
        if not self.piece is None:
            super(ChessBoxItemManagable, self).mousePressEvent(e)
        if e.buttons() != QtCore.Qt.RightButton:
            return

        menu = QtGui.QMenu(Lang.value('MI_Fairy_pieces'))

        populateFromCurrent = QtGui.QAction(
            Lang.value('MI_Populate_from_current'), self)
        populateFromCurrent.triggered.connect(self.manager.populateFromCurrent)
        menu.addAction(populateFromCurrent)
        menu.addSeparator()

        if self.piece is None:
            addNewAction = QtGui.QAction(Lang.value('MI_Add_piece'), self)
            addNewAction.triggered.connect(self.choose)
            menu.addAction(addNewAction)
        else:
            deleteAction = QtGui.QAction(Lang.value('MI_Delete_piece'), self)
            deleteAction.triggered.connect(self.remove)
            menu.addAction(deleteAction)
        deleteAllAction = QtGui.QAction(
            Lang.value('MI_Delete_all_pieces'), self)
        deleteAllAction.triggered.connect(self.manager.deleteAll)
        menu.addAction(deleteAllAction)

        menu.addSeparator()
        for i in xrange(len(Conf.zoos)):
            action = QtGui.QAction(Conf.zoos[i]['name'], self)
            action.triggered.connect(self.manager.makeChangeZooCallable(i))
            menu.addAction(action)

        menu.exec_(e.globalPos())

def __init__(self):
        super(KeywordsInputWidget, self).__init__()
        self.kwdMenu = QtGui.QMenu(Lang.value('MI_Add_keyword'))
        # for section in sorted(Conf.keywords.keys()):
        for section in Conf.keywords.keys():
            submenu = self.kwdMenu.addMenu(section)
            for keyword in sorted(Conf.keywords[section]):
                action = QtGui.QAction(keyword, self)
                action.triggered.connect(self.createCallable(keyword))
                submenu.addAction(action)

def __init__(self, parent):
        super(YouGetPlay, self).__init__(parent)

        self.tray = QtGui.QSystemTrayIcon(QtGui.QIcon('icon.png'), self)
        self.menu = QtGui.QMenu(self)

        exitAction = QtGui.QAction(
            "E&xit", self, shortcut="Ctrl+Q",
            statusTip="Exit the application", triggered=self.close)

        self.enableAction = QtGui.QAction(
            "&Enable", self, shortcut='Ctrl+E',
            statusTip='Enable monitor the clipboard', checkable=True)

        self.historyMenu = QtGui.QMenu("&History")

        self.enableAction.setChecked(True)

        self.menu.addMenu(self.historyMenu)
        self.menu.addAction(self.enableAction)
        self.menu.addAction(exitAction)

        self.tray.setContextMenu(self.menu)
        self.tray.setToolTip('you-get play')
        self.history = {'urls':[], 'titles':{}}
        self.load_history()