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

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 __init__(self):
        super(appWindow, self).__init__() # Figure out why AppWindow and self are both being passed to super()
        self.setGeometry(50, 50, 800, 500)
        self.setWindowTitle("OpenCouture")
        self.setWindowIcon(QtGui.QIcon('Icon.png'))

    ### MENU ACTIONS ###
        File_Quit = QtGui.QAction("&Quit Application", self)
        File_Quit.setShortcut("Ctrl+Q")
        File_Quit.setStatusTip('Exit the App')
        File_Quit.triggered.connect(self.exitApp)

    ### MENU CONFIGURATION ###
        self.statusBar()
        Menu_Main = self.menuBar()
        SubMenu_File = Menu_Main.addMenu('&File')
        SubMenu_File.addAction(File_Quit)

        self.home()       


    ### PAGES (Eventually modularize these? Include them in another file?) ###

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 initGui(self):
        """
        Initializes the plugin GUI.
        """
        self.action = QAction(
            QIcon(u'{}/images/batch.png'.format(PLUGIN_DIR)),
            'Batch GPS Importer', self.iface.mainWindow()
        )
        self.action.setObjectName('gps_importer_action')
        self.action.setWhatsThis('Configuration for Batch GPS Importer')
        self.action.setStatusTip('Batch import GPX files')
        self.action.triggered.connect(self.run)

        # add toolbar button and menu item
        self.iface.addToolBarIcon(self.action)
        self.iface.addPluginToVectorMenu('&Batch GPS Importer', self.action)

def addExisting(self):
        stations = Stations()
        for st in stations.stations:
            self.view.scene()._stations.stations.append(st)
            self.view.scene().addStation(st)
        self.view.scene()._scenarios.append(['Existing', False, 'Existing stations'])
        try:
            self.fileMenu.removeAction(self.sender())
        except:
            for act in self.fileMenu.actions():
                if act.text() == self.sender().text():
                    self.fileMenu.removeAction(act)
                    break
        subFile = QtGui.QAction(QtGui.QIcon('minus.png'), 'Existing', self)
        subFile.setStatusTip('Remove Scenario Existing')
        subFile.triggered.connect(self.removeScenario)
        self.subMenu.addAction(subFile)
        self.reshow_FloatMenu()
        self.reshow_FloatLegend()
        if self.floatstatus:
            self.floatstatus.emit(QtCore.SIGNAL('scenarios'), self.view.scene()._scenarios)
        self.view.emit(QtCore.SIGNAL('statusmsg'), 'Added Existing stations')

def initEditMenubar(self):

        """Creates entries of edit menubar and connects actions with gui methods.
        """

        editMoleculeButton = QtGui.QAction('Edit Molecule', self)
        self.connect(editMoleculeButton, QtCore.SIGNAL('triggered()'), self.editMolecule)

        removeMoleculeButton = QtGui.QAction('Remove Molecule', self)
        self.connect(removeMoleculeButton, QtCore.SIGNAL('triggered()'), self.removeMolecule)

        openWizardButton = QtGui.QAction('PyFRAP Wizard', self)
        self.connect(openWizardButton, QtCore.SIGNAL('triggered()'), self.openWizard)

        self.mbEdit.addAction(editMoleculeButton)
        self.mbEdit.addAction(removeMoleculeButton)
        self.mbEdit.addAction(openWizardButton)

def initAnalysisMenubar(self):

        """Creates entries of analysis menubar and connects actions with gui methods.
        """

        editAnalysisButton = QtGui.QAction('Analysis Settings', self)
        self.connect(editAnalysisButton, QtCore.SIGNAL('triggered()'), self.editAnalysis)

        analyzeEmbryoButton = QtGui.QAction('Analyze Embryo', self)
        self.connect(analyzeEmbryoButton, QtCore.SIGNAL('triggered()'), self.analyzeEmbryo)

        plotEmbryoAnalysisButton = QtGui.QAction('Plot Analysis Result of Embryo', self)
        self.connect(plotEmbryoAnalysisButton, QtCore.SIGNAL('triggered()'), self.plotAllDataTSOfEmbryo)

        self.mbAnalysis.addAction(editAnalysisButton)
        self.runAnalysisMB=self.mbAnalysis.addMenu('&Run Analysis')
        self.runAnalysisMB.addAction(analyzeEmbryoButton)


        self.plotAnalysisMB=self.mbAnalysis.addMenu('&Plotting')
        self.plotAnalysisMB.addAction(plotEmbryoAnalysisButton)

        return

def initGui(self):
        """Create the menu entries and toolbar icons inside the QGIS GUI."""

        self.nofa_act = QAction(self.iface.mainWindow())
        self.nofa_act.setText(self.app_name)
        nofa_icon = QIcon(os.path.join(self.plugin_dir, 'nofainsert.svg'))
        self.nofa_act.setIcon(nofa_icon)
        self.nofa_act.triggered.connect(self.run)
        self.iface.addToolBarIcon(self.nofa_act)
        self.iface.addPluginToMenu(self.app_name, self.nofa_act)

        self.con_act = QAction(self.iface.mainWindow())
        self.con_act.setText(u'Connection Parameters')
        con_icon = QIcon(
            os.path.join(self.plugin_dir, 'data', 'icons', 'options.png'))
        self.con_act.setIcon(con_icon)
        self.con_act.triggered.connect(self._open_con_dlg)
        self.iface.addPluginToMenu(self.app_name, self.con_act)

        self.ins_mw = ins_mw.InsMw(self.iface, self, self.plugin_dir)

def create_action(  self, text, slot=None, shortcut=None, 
                        icon=None, tip=None, checkable=False, 
                        signal="triggered()",enabled=True):
        """
        Simplify action creation
        """                            

        action = QtGui.QAction(text, self)
        if icon is not None:
            action.setIcon(QIcon(":/%s.png" % icon))
        if shortcut is not None:
            action.setShortcut(shortcut)
        if tip is not None:
            action.setToolTip(tip)
            action.setStatusTip(tip)
        if slot is not None:
            self.connect(action, QtCore.SIGNAL(signal), slot)
        if checkable:
            action.setCheckable(True)
        if enabled is not True:
            action.setEnabled(False)
        return action

def createActions(self):
        #self.saveAct = QtGui.QAction(QtGui.QIcon(':/images/save.png'),
                #"&Save...", self, shortcut=QtGui.QKeySequence.Save,
                #statusTip="Save the current form letter",
                #triggered=self.save)


        self.quitAct = QtGui.QAction("&Quit", self, shortcut="Ctrl+Q",
                statusTip="Quit the application", triggered=self.close)

        self.aboutAct = QtGui.QAction("&About", self,
                statusTip="Show the application's About box",
                triggered=self.about)

        self.aboutQtAct = QtGui.QAction("About &Qt", self,
                statusTip="Show the Qt library's About box",
                triggered=QtGui.qApp.aboutQt)

def keyReleaseEvent(self,e):
        # Ctrl key changes mouse cursor
        if e.key() == QtCore.Qt.Key_Control:
            QtGui.QApplication.restoreOverrideCursor()
        # check for zero to release temporary zero
        # somehow, for the numpad key in some machines, a check on Insert is needed aswell
        elif e.key() == QtCore.Qt.Key_0 or e.key() == QtCore.Qt.Key_Insert:
            self.transpTempZero = False
            self.update()

    #############################
    ## Little helper methods
    #############################

    # Helper method that sets tooltip and statustip
    # Provide an QAction and the tip text
    # This text is appended with a hotkeys and then assigned

def createTransformActions(self):
        self.transforms = []
        for i, k in enumerate(Mainframe.transform_names):
            self.transforms.append(
                QtGui.QAction(
                    QtGui.QIcon(
                        'resources/icons/arrow-' +
                        Mainframe.transform_icons[i] +
                        '.png'),
                    Lang.value(
                        'MI_' +
                        k),
                    self))
            self.transforms[-1].triggered.connect(
                self.createTransformsCallable(k))
            self.toolbar.addAction(self.transforms[-1])
            self.editMenu.addAction(self.transforms[-1])

def __init__(self, mainframeInstance):
        self.quickies = [
            {'option': 'SetPlay', 'icon': 'setplay.png', 'lang': 'QO_SetPlay'},
            {'option': 'Defence 1', 'icon': 'tries.png', 'lang': 'QO_Tries'},
            {'option': 'PostKeyPlay', 'icon': 'postkeyplay.png', 'lang': 'QO_PostKeyPlay'},
            {'option': 'Intelligent', 'icon': 'intelligent.png', 'lang': 'QO_IntelligentMode'}
        ]
        self.actions = []
        for q in self.quickies:
            action = QtGui.QAction(
                QtGui.QIcon(
                    'resources/icons/' +
                    q['icon']),
                Lang.value(
                    q['lang']),
                mainframeInstance)
            action.setCheckable(True)
            action.triggered.connect(self.makeToggleOption(q['option']))
            self.actions.append(action)

        Mainframe.sigWrapper.sigModelChanged.connect(self.onModelChanged)
        Mainframe.sigWrapper.sigLangChanged.connect(self.onLangChanged)

        self.skip_model_changed = False

def setupUi(self):
        self.playAction = QtGui.QAction(self.style().standardIcon(QtGui.QStyle.SP_MediaPlay), "Play",self, shortcut="Ctrl+P", enabled=False, triggered=self.mediaObject.play)
        self.pauseAction = QtGui.QAction(self.style().standardIcon(QtGui.QStyle.SP_MediaPause), "Pause", self, shortcut="Ctrl+A", enabled=False, triggered=self.mediaObject.pause)
        self.stopAction = QtGui.QAction(self.style().standardIcon(QtGui.QStyle.SP_MediaStop), "Stop",  self, shortcut="Ctrl+S", enabled=False,triggered=self.mediaObject.stop)
        # ?????  ?? ??? ??? ????
        bar = QtGui.QToolBar()
        bar.addAction(self.playAction)
        bar.addAction(self.pauseAction)
        bar.addAction(self.stopAction)
        self.UI.horizontalLayout_btn.addWidget(bar)
        #  ??LED??
        palette = QtGui.QPalette()
        palette.setBrush(QtGui.QPalette.Light, QtCore.Qt.darkGray)
        self.timeLcd = self.UI.lcdNumber
        self.timeLcd.setPalette(palette)
        self.timeLcd.display('00:00')
        self.setWindowFlags(QtCore.Qt.WindowMinimizeButtonHint)  # PyQT??????????
        self.setFixedSize(self.width(), self.height())   # PyQT????????:





    # button ????

def setupMenu(self):
        self.openAction = QtGui.QAction("Open",self)
        self.openAction.setShortcut("Ctrl+O")
        self.openAction.triggered.connect(self.showLevelDialog)

        self.saveAction = QtGui.QAction("Save",self)
        self.saveAction.setShortcut("Ctrl+S")
        self.saveAction.triggered.connect(self.saveLevel)
        self.saveAction.setEnabled(False)

        pathAction = QtGui.QAction("Change Game Path",self)
        pathAction.setShortcut("Ctrl+G")
        pathAction.triggered.connect(self.changeGamePath)

        self.menubar = self.menuBar()
        fileMenu = self.menubar.addMenu("File")
        fileMenu.addAction(self.openAction)
        fileMenu.addAction(self.saveAction)
        settingsMenu = self.menubar.addMenu("Settings")
        settingsMenu.addAction(pathAction)

def __init__(self, app, *args, **kwargs):
        super(FileMenu, self).__init__(*args, **kwargs)

        self.app = app
        self.load_h5_action = QtGui.QAction('Load &hdf5 ...', None)
        self.load_h5_action.triggered.connect(self.load_hdf5)

        self.load_swc_action = QtGui.QAction('Load &swc ...', None)
        self.load_swc_action.triggered.connect(self.load_swc)

        self.load_tiff_action = QtGui.QAction('Load &tiff ...', None)
        self.load_tiff_action.triggered.connect(self.load_tiff)

        self.save_hdf5_action = QtGui.QAction('&Save hdf5 ...', None)
        self.save_hdf5_action.triggered.connect(self.save_hdf5)

        self.setTitle("&File")

        self.addAction(self.load_h5_action)
        self.addAction(self.load_swc_action)
        self.addAction(self.load_tiff_action)
        self.addSeparator()
        self.addAction(self.save_hdf5_action)

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

        self.toggle_treeview = QtGui.QAction('Tree &view', self)
        self.toggle_treeview.setCheckable(True)
        self.toggle_treeview.setChecked(self.parent().roitreedockwidget.isVisible())
        self.toggle_treeview.triggered.connect(lambda b: self.parent().roitreedockwidget.setVisible(b))

        self.toggle_linescan = QtGui.QAction('&Linescan', self)
        self.toggle_linescan.setCheckable(True)
        self.toggle_linescan.setChecked(self.parent().linescandockwidget.isVisible())
        self.toggle_linescan.triggered.connect(lambda b: self.parent().linescandockwidget.setVisible(b))

        self.toggle_trace = QtGui.QAction('&Trace', self)
        self.toggle_trace.setCheckable(True)
        self.toggle_trace.setChecked(self.parent().tracedockwidget.isVisible())
        self.toggle_trace.triggered.connect(lambda b: self.parent().tracedockwidget.setVisible(b))

        self.setTitle("&View")
        self.setToolTip("Show/Hide the docked tool frames.")

        self.addAction(self.toggle_treeview)
        self.addAction(self.toggle_linescan)
        self.addAction(self.toggle_trace)

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 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 __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 createActions(self):
        self.printAct = QAction("&Print...", self, shortcut="Ctrl+P",
                enabled=False, triggered=self.print_)

        self.exitAct = QAction("E&xit", self, shortcut="Ctrl+Q",
                triggered=self.close)

        self.zoomInAct = QAction("Zoom &In (25%)", self,
                shortcut="Ctrl++", enabled=False, triggered=self.zoomIn)

        self.zoomOutAct = QAction("Zoom &Out (25%)", self,
                shortcut="Ctrl+-", enabled=False, triggered=self.zoomOut)

        self.normalSizeAct = QAction("&Normal Size", self,
                shortcut="Ctrl+S", enabled=False, triggered=self.normalSize)

        self.fitToWindowAct = QAction("&Fit to Window", self,
                enabled=False, checkable=True, shortcut="Ctrl+F",
                triggered=self.fitToWindow)

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 __init__(self, parent):
        super(DlgFavouritesEditor, self).__init__(parent)
        self.itemName = "Favourite"

        self.setWindowTitle("Favourites editor")

        self.list_view.setContextMenuPolicy(Qt.ActionsContextMenu)

        action_search_for_lyrics = QAction("Search for lyrics online", self)
        action_search_for_lyrics.triggered.connect(self.on_search_for_lyrics)
        self.list_view.addAction(action_search_for_lyrics)

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

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

        self.menu.addAction(saveAction)

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

def addMenuAction(self):
        """????????"""
        refreshAction = QtGui.QAction(u'??', self)
        refreshAction.triggered.connect(self.refresh)

        self.menu.addAction(refreshAction)

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

def initGui(self):
        self.actionImport = QtGui.QAction("Import Mapbox GL...", self.iface.mainWindow())
        self.actionImport.triggered.connect(self.importMapbox)
        self.iface.addPluginToMenu(u"Mapbox GL", self.actionImport)
        self.actionExport = QtGui.QAction("Export Mapbox GL...", self.iface.mainWindow())
        self.actionExport.triggered.connect(lambda: self.exportMapbox(False))
        self.iface.addPluginToMenu(u"Mapbox GL", self.actionExport)
        self.actionExportWithApp = QtGui.QAction("Export Mapbox GL (include test OL app)...", self.iface.mainWindow())
        self.actionExportWithApp.triggered.connect(lambda: self.exportMapbox(True))
        self.iface.addPluginToMenu(u"Mapbox GL", self.actionExportWithApp)

def init_UI(self):
        self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
        self.setWindowTitle('Dragonfly Frame Viewer')
        window = QtWidgets.QWidget()

        self.hbox = QtWidgets.QHBoxLayout()
        self.frame_panel = frame_panel.Frame_panel(self, powder=self.do_powder, compare=self.do_compare)
        self.hbox.addWidget(self.frame_panel)

        # Menu items
        menubar = self.menuBar()
        menubar.setNativeMenuBar(False)
        # Theme picker
        thememenu = menubar.addMenu('&Theme')
        self.theme = QtWidgets.QActionGroup(self, exclusive=True)
        for i, s in enumerate(map(str, list(QtWidgets.QStyleFactory.keys()))):
            a = self.theme.addAction(QtWidgets.QAction(s, self, checkable=True))
            if i == 0:
                a.setChecked(True)
            a.triggered.connect(self.theme_changed)
            thememenu.addAction(a)
        # Color map picker
        cmapmenu = menubar.addMenu('&Color Map')
        self.color_map = QtWidgets.QActionGroup(self, exclusive=True)
        for i, s in enumerate(['cubehelix', 'CMRmap', 'gray', 'gray_r', 'jet']):
            a = self.color_map.addAction(QtWidgets.QAction(s, self, checkable=True))
            if i == 0:
                a.setChecked(True)
            a.triggered.connect(self.cmap_changed)
            cmapmenu.addAction(a)

        window.setLayout(self.hbox)
        self.setCentralWidget(window)
        self.show()

def addScenario(self):
        fname = QtGui.QFileDialog.getOpenFileName(self, 'Open scenario file',
                self.scenarios, 'Scenarios (' + self.scenarios_filter + ')')
        fname = str(fname)
        if os.path.exists(fname):
            if self.sender().text() == 'Open':
                for i in range(len(self.view.scene()._scenarios) - 1, -1, -1):
                    scen = self.view.scene()._scenarios[i][0]
                    self.removeScenario(scen)
                self.subMenu.clear()
                self.subMenu2.clear()
            self.view.scene()._setupScenario(fname)
            i = fname.rfind('/')
            scen_filter = fname[i + 1:]
            comment = 'Added scenario %s' % (scen_filter)
            subFile = QtGui.QAction(QtGui.QIcon('minus.png'), scen_filter, self)
            subFile.setStatusTip('Remove Scenario ' + scen_filter)
            subFile.triggered.connect(self.removeScenario)
            self.subMenu.addAction(subFile)
            subFile2 = QtGui.QAction(QtGui.QIcon('edit.png'), scen_filter, self)
            subFile2.setStatusTip('Edit Description for ' + scen_filter)
            subFile2.triggered.connect(self.editDescription)
            self.subMenu2.addAction(subFile2)
            self.reshow_FloatMenu()
            self.reshow_FloatLegend()
            if self.floatstatus:
                self.floatstatus.emit(QtCore.SIGNAL('scenarios'), self.view.scene()._scenarios)
            self.altered_stations = True
            self.view.emit(QtCore.SIGNAL('statusmsg'), comment)
        else:
            i = fname.rfind('/')
            scen_filter = fname[i + 1:]
            comment = 'Scenario not found: %s' % (scen_filter)
            self.view.emit(QtCore.SIGNAL('statusmsg'), comment)

def initFileMenubar(self):

        """Creates entries of file menubar and connects actions with gui methods.
        """

        newMoleculeButton = QtGui.QAction('New Molecule', self)
        self.connect(newMoleculeButton, QtCore.SIGNAL('triggered()'), self.newMolecule)

        loadMoleculeButton = QtGui.QAction('Open Molecule', self)
        self.connect(loadMoleculeButton, QtCore.SIGNAL('triggered()'), self.loadMolecule)

        saveMoleculeButton = QtGui.QAction('Save Molecule', self)
        self.connect(saveMoleculeButton, QtCore.SIGNAL('triggered()'), self.saveMolecule)

        exitButton = QtGui.QAction('Exit', self)
        exitButton.setShortcut('Ctrl+Q')    
        self.connect(exitButton, QtCore.SIGNAL('triggered()'), QtCore.SLOT('close()'))

        self.mbFile.addAction(newMoleculeButton)
        self.mbFile.addAction(loadMoleculeButton)
        self.recentMB=self.mbFile.addMenu('&Open recent')
        self.mbFile.addAction(saveMoleculeButton)

        self.mbFile.addAction(exitButton)

        return

def initPinningMenubar(self):

        """Creates entries of pinning menubar and connects actions with gui methods.
        """

        defaultPinButton = QtGui.QAction('Default Pinning', self)
        self.connect(defaultPinButton, QtCore.SIGNAL('triggered()'), self.defaultPinEmbryo)

        idealPinButton = QtGui.QAction('Ideal Pinning', self)
        self.connect(idealPinButton, QtCore.SIGNAL('triggered()'), self.idealPinEmbryo)

        self.mbPinning.addAction(defaultPinButton)
        self.mbPinning.addAction(idealPinButton)

def initSettingsMenubar(self):

        """Creates entries of settings menubar and connects actions with gui methods.
        """

        setPathFileButton = QtGui.QAction('Set Path File', self)
        self.connect(setPathFileButton, QtCore.SIGNAL('triggered()'), self.setPathFile)

        setGmshButton = QtGui.QAction('Set Gmsh Path', self)
        self.connect(setGmshButton, QtCore.SIGNAL('triggered()'), self.setGmshPath)

        setFijiButton = QtGui.QAction('Set Fiji Path', self)
        self.connect(setFijiButton, QtCore.SIGNAL('triggered()'), self.setFijiPath)

        setOpenscadButton = QtGui.QAction('Set Openscad Path', self)
        self.connect(setOpenscadButton, QtCore.SIGNAL('triggered()'), self.setOpenscadPath)

        printPathsButton = QtGui.QAction('Print Paths', self)
        self.connect(printPathsButton, QtCore.SIGNAL('triggered()'), self.printPaths)

        printPathFileButton = QtGui.QAction('Print Path File Location', self)
        self.connect(printPathFileButton, QtCore.SIGNAL('triggered()'), self.printPathFile)

        checkPathsButton = QtGui.QAction('Check paths in path file', self)
        self.connect(checkPathsButton, QtCore.SIGNAL('triggered()'), self.checkPaths)

        self.mbSettings.addAction(setPathFileButton)
        self.mbSettings.addAction(setGmshButton)
        self.mbSettings.addAction(setFijiButton)
        self.mbSettings.addAction(setOpenscadButton)
        self.mbSettings.addAction(printPathsButton)
        self.mbSettings.addAction(printPathFileButton)
        self.mbSettings.addAction(checkPathsButton)

def updateRecentMBs(self):

        """Updates recently opened menubar.

        Loops through current loaded configuration ``config.recentFiles`` and appends the 5 newest entries to 
        ``self.recentActions``.

        """

        self.recentActions=[]

        for i in range(len(self.config.recentFiles)):
            if i>5:
                self.config.recentFiles.pop(i)
            else:
                self.recentActions.append(QtGui.QAction(self.config.recentFiles[i], self))
                item=self.recentActions[i]
                item.triggered.connect(functools.partial(self.openMolecule,pyfrp_misc_module.fixPath(self.config.recentFiles[i])))

                self.recentMB.addAction(item)   

        return self.recentMB        

    #---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
    #secObjectBar: Object Bar handling
    #---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

def wheelEvent(self, event):
        ctrlPressed = event.modifiers() & QtCore.Qt.ControlModifier

        deltaDegree = event.delta() / 8 # Rotation in degree
        deltaSteps  = deltaDegree / 15 # Usually one step on the mouse is 15 degrees

        if ctrlPressed:
            self.transp = max(min(self.transp+(deltaSteps*0.1),1.0),0.0)
            self.update()
        else:
            if self.zoom:
                # If shift is pressed, change zoom window size
                if event.modifiers() and QtCore.Qt.Key_Shift:
                    self.zoomSize += deltaSteps * 10
                    self.zoomSize = max( self.zoomSize, 10   )
                    self.zoomSize = min( self.zoomSize, 1000 )
                # Change zoom factor
                else:
                    self.zoomFactor += deltaSteps * 0.05
                    self.zoomFactor = max( self.zoomFactor, 0.1 )
                    self.zoomFactor = min( self.zoomFactor, 10 )
                self.update()


    #############################
    ## Little helper methods
    #############################

    # Helper method that sets tooltip and statustip
    # Provide an QAction and the tip text
    # This text is appended with a hotkeys and then assigned

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 wheelEvent(self, event):
        ctrlPressed = event.modifiers() & QtCore.Qt.ControlModifier

        deltaDegree = event.delta() / 8 # Rotation in degree
        deltaSteps  = deltaDegree / 15 # Usually one step on the mouse is 15 degrees

        if ctrlPressed:
            self.transp = max(min(self.transp+(deltaSteps*0.1),1.0),0.0)
            self.update()
        else:
            if self.zoom:
                # If shift is pressed, change zoom window size
                if event.modifiers() and QtCore.Qt.Key_Shift:
                    self.zoomSize += deltaSteps * 10
                    self.zoomSize = max( self.zoomSize, 10   )
                    self.zoomSize = min( self.zoomSize, 1000 )
                # Change zoom factor
                else:
                    self.zoomFactor += deltaSteps * 0.05
                    self.zoomFactor = max( self.zoomFactor, 0.1 )
                    self.zoomFactor = min( self.zoomFactor, 10 )
                self.update()


    #############################
    ## Little helper methods
    #############################

    # Helper method that sets tooltip and statustip
    # Provide an QAction and the tip text
    # This text is appended with a hotkeys and then assigned

def setupMenuBar(self, MainWindow):
        self.actionExit = QtGui.QAction(MainWindow)
        self.actionExit.setObjectName(_fromUtf8("actionExit"))
        self.actionExit.setShortcut('Ctrl+Q')
        self.actionExit.setStatusTip('Exit application')
        self.actionExit.triggered.connect(QtGui.qApp.quit)

        self.actionCredits = QtGui.QAction(MainWindow)
        self.actionCredits.setObjectName(_fromUtf8("actionCredits"))
        self.actionCredits.setShortcut('Ctrl+I')
        self.actionCredits.setStatusTip('Display credits')
        self.actionCredits.triggered.connect(self.showCredits)

        self.actionHelp = QtGui.QAction(MainWindow)
        self.actionHelp.setObjectName(_fromUtf8("actionHelp"))
        self.actionHelp.setShortcut('Ctrl+H')
        self.actionHelp.setStatusTip('Help and documentation')
        self.actionHelp.triggered.connect(self.showDocumentation)

        self.menubar = QtGui.QMenuBar(MainWindow)
        self.fileMenu = self.menubar.addMenu('&File')
        self.fileMenu.addAction(self.actionExit)
        self.fileMenu = self.menubar.addMenu('&Credits')
        self.fileMenu.addAction(self.actionCredits)
        self.fileMenu = self.menubar.addMenu('&Help')
        self.fileMenu.addAction(self.actionHelp)
        self.menubar.setGeometry(QtCore.QRect(0, 0, 542, 23))
        self.menubar.setDefaultUp(False)
        self.menubar.setNativeMenuBar(False)
        self.menubar.setObjectName(_fromUtf8("menubar"))

        MainWindow.setMenuBar(self.menubar)

def initGui( self ):

    # Remove Redo buttons from menus and toolbars, they can lead to crashes due
    #   to a corrupted undo stack.
    redoActionList = [action for action in self.iface.advancedDigitizeToolBar().actions() if action.objectName() == u'mActionRedo']
    if redoActionList:
        self.iface.advancedDigitizeToolBar().removeAction( redoActionList[0] )
        self.iface.editMenu().removeAction( redoActionList[0] )

    QSettings().setValue( "/shortcuts/Redo", "" ) # Override Redo shortcut

    # This block (2 options for disabling the Undo panel) didn't work
    #QSettings().setValue( '/UI/Customization/enabled', True )
    #QSettings( "QGIS", "QGISCUSTOMIZATION2" ).setValue( '/Customization/Panels/Undo', False )
    #undoDock = self.iface.mainWindow().findChild( QDockWidget, u'Undo' )
    #self.iface.removeDockWidget( undoDock )

    # Create action that will start plugin configuration
    self.actionDock = QAction(QIcon( ":/plugins/AutoFields/icon.png"), \
        "AutoFields plugin...", self.iface.mainWindow() )
    self.actionDock.triggered.connect( self.toggleDockWidget )

    self.actionExport = QAction(QIcon( ":/plugins/AutoFields/icons/export.png"), \
        "Export AutoFields to JSON file...", self.iface.mainWindow() )
    self.actionExport.triggered.connect( self.openExportDialog )

    self.actionImport = QAction(QIcon( ":/plugins/AutoFields/icons/import.png"), \
        "Import AutoFields from JSON file...", self.iface.mainWindow() )
    self.actionImport.triggered.connect( self.openImportFileDialog )

    # Add custom submenu to Vector menu
    self.iface.addPluginToVectorMenu( "&AutoFields", self.actionDock )
    self.iface.addPluginToVectorMenu( "&AutoFields", self.actionExport )
    self.iface.addPluginToVectorMenu( "&AutoFields", self.actionImport )

    # Add a custom toolbar
    self.toolbar = self.iface.addToolBar( "AutoFields" )
    self.toolbar.setObjectName("AutoFields")
    self.toolbar.addAction( self.actionDock )
    self.toolbar.addAction( self.actionExport )
    self.toolbar.addAction( self.actionImport )

    self.messageManager = MessageManager( self.messageMode, self.iface )

    self.autoFieldManager = AutoFieldManager( self.messageManager, self.iface )
    self.autoFieldManager.readAutoFields()

    self.dockWidget = AutoFieldsDockWidget( self.iface.mainWindow(), self.iface, self.autoFieldManager, self.messageManager, self.language )
    self.iface.addDockWidget( Qt.RightDockWidgetArea, self.dockWidget )

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 __init__(self, parent=None):
        QtGui.QMainWindow.__init__(self, parent)

        self.setGeometry(300, 300, 350, 300)
        self.setWindowTitle('OpenFile')

        self.textEdit = QtGui.QTextEdit()
        self.setCentralWidget(self.textEdit)
        self.statusBar()

        self._label = QtGui.QLabel("Einkaufszaehler")
        self.statusBar().addPermanentWidget(self._label)
        self.statusBar().addPermanentWidget(self._label)

        self._label.setText("BLA2")

        self.setFocus()

        openFile = QtGui.QAction(QtGui.QIcon('open.png'), 'Open', self)
        openFile.setShortcut('Ctrl+O')
        openFile.setStatusTip('Open new File')
        self.connect(openFile, QtCore.SIGNAL('triggered()'), self.showDialog)

        menubar = self.menuBar()
        fileMenu = menubar.addMenu('&File')
        fileMenu.addAction(openFile)

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)