Python QAction.setVisible方法代码示例

# 需要导入模块: from PyQt5.QtWidgets import QAction [as 别名]
# 或者: from PyQt5.QtWidgets.QAction import setVisible [as 别名]
    def updateRecentFiles(self, menu):
        # bootstrap
        actions = menu.actions()
        for i in range(MAX_RECENT_FILES):
            try:
                action = actions[i]
            except IndexError:
                action = QAction(menu)
                menu.addAction(action)
            action.setVisible(False)
            action.triggered.connect(self.openRecentFile)
        # fill
        actions = menu.actions()
        recentFiles = settings.recentFiles()
        count = min(len(recentFiles), MAX_RECENT_FILES)
        for index, recentFile in enumerate(recentFiles[:count]):
            action = actions[index]
            shortName = os.path.basename(recentFile.rstrip(os.sep))

            action.setText(shortName)
            action.setToolTip(recentFile)
            action.setVisible(True)
        for index in range(count, MAX_RECENT_FILES):
            actions[index].setVisible(False)

        menu.setEnabled(len(recentFiles))

# 需要导入模块: from PyQt5.QtWidgets import QAction [as 别名]
# 或者: from PyQt5.QtWidgets.QAction import setVisible [as 别名]
 def addRecentMenu(self, parent_menu):
     ''' List of recently accessed files '''
     recent_menu = parent_menu.addMenu( 'Recent Files' )
     
     for i in range(0, 10):
         tmp = QAction(self)
         tmp.setVisible(False)
         recent_menu.addAction( tmp )
         tmp.triggered.connect( self.open_recent() )
     
     alist = recent_menu.actions()
     #QSettings settings;
     files = self.settings.value('RecentFileList').toStringList()
     a = alist.size()
     b = files.size()
     limit = b
     if a > b:
         limit = a
         
     for i in range(0, limit):
         file = files[i]
         if file.length() > 160:
             file = file.left(40) + ' ... ' + file.right(100)
         alist[i].setText( file )
         alist[i].setData( files[i] )
         alist[i].setVisible( True )
     
     return recent_menu

# 需要导入模块: from PyQt5.QtWidgets import QAction [as 别名]
# 或者: from PyQt5.QtWidgets.QAction import setVisible [as 别名]
class TrayIcon(QSystemTrayIcon):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.setIcon(QIcon(":/icons/logo_256x256.png"))

        quit_action = QAction("Exit", self)
        self.mute_action = QAction("Mute microphone", self)
        self.unmute_action = QAction("Unmute microphone", self)

        quit_action.triggered.connect(self.on_quit)
        self.mute_action.triggered.connect(self.on_mute)
        self.unmute_action.triggered.connect(self.on_unmute)
        self.unmute_action.setVisible(False)  #TODO: Actually determine mute state

        tray_menu = QMenu()
        tray_menu.addAction(self.mute_action)
        tray_menu.addAction(self.unmute_action)
        tray_menu.addAction(quit_action)
        self.setContextMenu(tray_menu)

        self.mixer = muteme.mixer.Mixer()
        self.setup_tcp_server()

    def setup_tcp_server(self):
        self.thread = NetworkThread(self.mute_callback)
        self.thread.start()

    def mute_callback(self, mute):
        QApplication.postEvent(self, MuteEvent(mute))

    def customEvent(self, event):
        if isinstance(event, MuteEvent):
            if event.mute:
                self.on_mute()
            else:
                self.on_unmute()

    @pyqtSlot(bool)
    def on_quit(self):
        self.thread.tcp_server.event_loop.call_soon_threadsafe(self.thread.tcp_server.event_loop.stop)
        self.thread.join()
        self.mixer.mute(False)
        qApp.quit()

    @pyqtSlot(bool)
    def on_mute(self):
        self.unmute_action.setVisible(True)
        self.mute_action.setVisible(False)
        self.mixer.mute(True)

    @pyqtSlot(bool)
    def on_unmute(self):
        self.unmute_action.setVisible(False)
        self.mute_action.setVisible(True)
        self.mixer.mute(False)

# 需要导入模块: from PyQt5.QtWidgets import QAction [as 别名]
# 或者: from PyQt5.QtWidgets.QAction import setVisible [as 别名]
 def initUI(self):
     """
     Initialize the System Tray Icon user interface.
     """
     self.setIcon(QIcon(B3_ICON_SMALL))
     #### SHOW ACTION
     show = QAction('Show', self.parent())
     show.triggered.connect(self.parent().make_visible)
     show.setVisible(True)
     #### START ALL ACTION
     start = QAction('Start all', self.parent())
     start.triggered.connect(B3App.Instance().start_all)
     start.setVisible(True)
     #### STOP ALL ACTION
     stop = QAction('Stop all', self.parent())
     stop.triggered.connect(B3App.Instance().stop_all)
     stop.setVisible(True)
     #### QUIT ACTION
     terminate = QAction('Quit', self.parent())
     terminate.triggered.connect(B3App.Instance().shutdown)
     terminate.setVisible(True)
     ## CREATE THE MENU
     menu = QMenu(self.parent())
     menu.addAction(show)
     menu.addSeparator()
     menu.addAction(start)
     menu.addAction(stop)
     menu.addSeparator()
     menu.addAction(terminate)
     ## ADD THE MENU
     self.setContextMenu(menu)
     self.activated.connect(self.onActivated)

# 需要导入模块: from PyQt5.QtWidgets import QAction [as 别名]
# 或者: from PyQt5.QtWidgets.QAction import setVisible [as 别名]
 def __init_menu_file(self):
     """
     Initialize the 'File' menu.
     """
     ####  NEW B3 INSTANCE SUBMENU ENTRY
     new_process = QAction('Add B3', self.parent())
     new_process.setShortcut('Ctrl+N')
     new_process.setStatusTip('Add a new B3')
     new_process.setIcon(QIcon(B3_ICON_SMALL))
     new_process.triggered.connect(self.parent().new_process_dialog)
     new_process.setVisible(True)
     ### INSTALL PLUGIN SUBMENU ENTRY
     install_plugin = QAction('Add Plugin', self.parent())
     install_plugin.setShortcut('Ctrl+P')
     install_plugin.setStatusTip('Install a new B3 plugin')
     install_plugin.setIcon(QIcon(ICON_PLUGINS))
     install_plugin.triggered.connect(self.parent().install_plugin)
     install_plugin.setVisible(True)
     ####  QUIT SUBMENU ENTRY
     quit_btn = QAction('Quit', self.parent())
     quit_btn.setShortcut('Ctrl+Q')
     quit_btn.setStatusTip('Shutdown B3')
     quit_btn.setIcon(QIcon(ICON_QUIT))
     quit_btn.triggered.connect(B3App.Instance().shutdown)
     quit_btn.setVisible(True)
     ## FILE MENU ENTRY
     file_menu = self.addMenu('&File')
     file_menu.addAction(new_process)
     file_menu.addAction(install_plugin)
     file_menu.addAction(quit_btn)

# 需要导入模块: from PyQt5.QtWidgets import QAction [as 别名]
# 或者: from PyQt5.QtWidgets.QAction import setVisible [as 别名]
    def __init__(self, font, parent=None):
        super().__init__(parent)
        self._font = None

        self._settingsWindow = None
        self._infoWindow = None
        self._featuresWindow = None
        self._metricsWindow = None
        self._groupsWindow = None

        menuBar = self.menuBar()
        fileMenu = QMenu(self.tr("&File"), self)
        fileMenu.addAction(self.tr("&New…"), self.newFile, QKeySequence.New)
        fileMenu.addAction(
            self.tr("&Open…"), self.openFile, QKeySequence.Open)
        # recent files
        self.recentFilesMenu = QMenu(self.tr("Open &Recent"), self)
        for i in range(MAX_RECENT_FILES):
            action = QAction(self.recentFilesMenu)
            action.setVisible(False)
            action.triggered.connect(self.openRecentFile)
            self.recentFilesMenu.addAction(action)
        self.updateRecentFiles()
        fileMenu.addMenu(self.recentFilesMenu)
        fileMenu.addAction(self.tr("&Import…"), self.importFile)
        fileMenu.addSeparator()
        fileMenu.addAction(self.tr("&Save"), self.saveFile, QKeySequence.Save)
        fileMenu.addAction(
            self.tr("Save &As…"), self.saveFileAs, QKeySequence.SaveAs)
        fileMenu.addAction(self.tr("&Export…"), self.exportFile)
        fileMenu.addAction(self.tr("&Reload From Disk"), self.reloadFile)
        fileMenu.addAction(self.tr("E&xit"), self.close, QKeySequence.Quit)
        menuBar.addMenu(fileMenu)

        editMenu = QMenu(self.tr("&Edit"), self)
        self._undoAction = editMenu.addAction(
            self.tr("&Undo"), self.undo, QKeySequence.Undo)
        self._redoAction = editMenu.addAction(
            self.tr("&Redo"), self.redo, QKeySequence.Redo)
        editMenu.addSeparator()
        self.markColorMenu = QMenu(self.tr("&Flag Color"), self)
        self.updateMarkColors()
        editMenu.addMenu(self.markColorMenu)
        cut = editMenu.addAction(self.tr("C&ut"), self.cut, QKeySequence.Cut)
        copy = editMenu.addAction(
            self.tr("&Copy"), self.copy, QKeySequence.Copy)
        copyComponent = editMenu.addAction(
            self.tr("Copy &As Component"), self.copyAsComponent, "Ctrl+Alt+C")
        paste = editMenu.addAction(
            self.tr("&Paste"), self.paste, QKeySequence.Paste)
        self._clipboardActions = (cut, copy, copyComponent, paste)
        editMenu.addSeparator()
        editMenu.addAction(self.tr("&Settings…"), self.settings)
        menuBar.addMenu(editMenu)

        fontMenu = QMenu(self.tr("&Font"), self)
        fontMenu.addAction(
            self.tr("&Add Glyphs…"), self.addGlyphs, "Ctrl+G")
        fontMenu.addAction(
            self.tr("Font &Info"), self.fontInfo, "Ctrl+Alt+I")
        fontMenu.addAction(
            self.tr("Font &Features"), self.fontFeatures, "Ctrl+Alt+F")
        fontMenu.addSeparator()
        fontMenu.addAction(self.tr("&Sort…"), self.sortGlyphs)
        menuBar.addMenu(fontMenu)

        pythonMenu = QMenu(self.tr("&Python"), self)
        pythonMenu.addAction(
            self.tr("&Scripting Window"), self.scripting, "Ctrl+Alt+R")
        pythonMenu.addAction(
            self.tr("&Output Window"), self.outputWindow, "Ctrl+Alt+O")
        menuBar.addMenu(pythonMenu)

        windowMenu = QMenu(self.tr("&Windows"), self)
        action = windowMenu.addAction(
            self.tr("&Inspector"), self.inspector, "Ctrl+I")
        # XXX: we're getting duplicate shortcut when we spawn a new window...
        action.setShortcutContext(Qt.ApplicationShortcut)
        windowMenu.addAction(
            self.tr("&Metrics Window"), self.metrics, "Ctrl+Alt+S")
        windowMenu.addAction(
            self.tr("&Groups Window"), self.groups, "Ctrl+Alt+G")
        menuBar.addMenu(windowMenu)

        helpMenu = QMenu(self.tr("&Help"), self)
        helpMenu.addAction(self.tr("&About"), self.about)
        helpMenu.addAction(
            self.tr("About &Qt"), QApplication.instance().aboutQt)
        menuBar.addMenu(helpMenu)

        cellSize = 56
        self.glyphCellView = GlyphCellView(self)
        self.glyphCellView.glyphActivated.connect(self._glyphActivated)
        self.glyphCellView.glyphsDropped.connect(self._orderChanged)
        self.glyphCellView.selectionChanged.connect(self._selectionChanged)
        self.glyphCellView.setAcceptDrops(True)
        self.glyphCellView.setCellRepresentationName("TruFont.GlyphCell")
        self.glyphCellView.setCellSize(cellSize)
        self.glyphCellView.setFocus()

#.........这里部分代码省略.........

# 需要导入模块: from PyQt5.QtWidgets import QAction [as 别名]
# 或者: from PyQt5.QtWidgets.QAction import setVisible [as 别名]
class MainWindow(QMainWindow):
    """This create the main window of the application"""
    def __init__(self):
        super(MainWindow, self).__init__()
        # remove close & maximize window buttons
        #self.setWindowFlags(Qt.CustomizeWindowHint|Qt.WindowMinimizeButtonHint)
        self.setMinimumSize(500, 666)
        #self.setMaximumSize(1000,666)
        self.mdiArea = QMdiArea()
        self.mdiArea.setHorizontalScrollBarPolicy(Qt.ScrollBarAsNeeded)
        self.mdiArea.setVerticalScrollBarPolicy(Qt.ScrollBarAsNeeded)
        self.setCentralWidget(self.mdiArea)

        self.mdiArea.subWindowActivated.connect(self.updateMenus)
        self.mdiArea.setViewMode(QMdiArea.TabbedView)

        self.windowMapper = QSignalMapper(self)
        self.windowMapper.mapped[QWidget].connect(self.setActiveSubWindow)

        self.child = None

        self.createActions()
        self.createMenus()
        self.createStatusBar()
        self.updateMenus()
        self.readSettings()
        self.setWindowTitle("LEKTURE")

        mytoolbar = QToolBar()
        #self.toolbar = self.addToolBar()
        mytoolbar.addAction(self.newAct)
        mytoolbar.addAction(self.openAct)
        mytoolbar.addAction(self.saveAct)
        mytoolbar.addAction(self.saveAsAct)
        mytoolbar.addSeparator()
        mytoolbar.addAction(self.outputsAct)
        mytoolbar.addAction(self.scenarioAct)
        self.scenarioAct.setVisible(False)
        mytoolbar.setMovable(False)
        mytoolbar.setFixedWidth(60)
        self.addToolBar(Qt.LeftToolBarArea, mytoolbar)

    def closeEvent(self, scenario):
        """method called when the main window wants to be closed"""
        self.mdiArea.closeAllSubWindows()
        if self.mdiArea.currentSubWindow():
            scenario.ignore()
        else:
            self.writeSettings()
            scenario.accept()

    def newFile(self):
        """creates a new project"""
        child = self.createProjekt()
        child.newFile()
        child.show()
        self.child = child

    def open(self):
        """open a project"""
        fileName, _ = QFileDialog.getOpenFileName(self)
        if fileName:
            existing = self.findProjekt(fileName)
            if existing:
                self.mdiArea.setActiveSubWindow(existing)
                return

            child = self.createProjekt()
            if child.loadFile(fileName):
                self.statusBar().showMessage("File loaded", 2000)
                child.show()
            else:
                child.close()

    def save(self):
        """called when user save a project"""
        if self.activeProjekt() and self.activeProjekt().save():
            self.statusBar().showMessage("File saved", 2000)
        else:
            self.statusBar().showMessage("Error when trying to save the file")

    def saveAs(self):
        """called when user save AS a project"""
        if self.activeProjekt() and self.activeProjekt().saveAs():
            self.statusBar().showMessage("File saved", 2000)
        else:
            self.statusBar().showMessage("Error when trying to save the file")

    def openFolder(self):
        """called when user calls 'reveal in finder' function"""
        if self.activeProjekt() and self.activeProjekt().openFolder():
            self.statusBar().showMessage("File revealed in Finder", 2000)

    def about(self):
        """called when user wants to know a bit more on the app"""
        import sys
        python_version = str(sys.version_info[0])
        python_version_temp = sys.version_info[1:5]
        for item in python_version_temp:
            python_version = python_version + "." + str(item)
#.........这里部分代码省略.........

# 需要导入模块: from PyQt5.QtWidgets import QAction [as 别名]
# 或者: from PyQt5.QtWidgets.QAction import setVisible [as 别名]
    def create_connects(self):
        self.ui.actionFullscreen_mode.setShortcut(QKeySequence.FullScreen)
        self.ui.actionOpen.setShortcut(QKeySequence(QKeySequence.Open))
        self.ui.actionOpen_directory.setShortcut(QKeySequence("Ctrl+Shift+O"))

        self.ui.menuEdit.aboutToShow.connect(self.on_edit_menu_about_to_show)

        self.ui.actionNew_Project.triggered.connect(self.on_new_project_action_triggered)
        self.ui.actionNew_Project.setShortcut(QKeySequence.New)
        self.ui.actionProject_settings.triggered.connect(self.on_project_settings_action_triggered)
        self.ui.actionSave_project.triggered.connect(self.save_project)
        self.ui.actionClose_project.triggered.connect(self.close_project)

        self.ui.actionAbout_AutomaticHacker.triggered.connect(self.on_show_about_clicked)
        self.ui.actionRecord.triggered.connect(self.on_show_record_dialog_action_triggered)

        self.ui.actionFullscreen_mode.triggered.connect(self.on_fullscreen_action_triggered)
        self.ui.actionSaveAllSignals.triggered.connect(self.signal_tab_controller.save_all)
        self.ui.actionCloseAllFiles.triggered.connect(self.on_close_all_files_action_triggered)
        self.ui.actionOpen.triggered.connect(self.on_open_file_action_triggered)
        self.ui.actionOpen_directory.triggered.connect(self.on_open_directory_action_triggered)
        self.ui.actionDecoding.triggered.connect(self.on_show_decoding_dialog_triggered)
        self.ui.actionSpectrum_Analyzer.triggered.connect(self.on_show_spectrum_dialog_action_triggered)
        self.ui.actionOptions.triggered.connect(self.show_options_dialog_action_triggered)
        self.ui.actionSniff_protocol.triggered.connect(self.show_proto_sniff_dialog)
        self.ui.actionAbout_Qt.triggered.connect(QApplication.instance().aboutQt)
        self.ui.actionSamples_from_csv.triggered.connect(self.on_import_samples_from_csv_action_triggered)
        self.ui.actionAuto_detect_new_signals.triggered.connect(self.on_auto_detect_new_signals_action_triggered)

        self.ui.btnFileTreeGoUp.clicked.connect(self.on_btn_file_tree_go_up_clicked)
        self.ui.fileTree.directory_open_wanted.connect(self.project_manager.set_project_folder)

        self.signal_tab_controller.frame_closed.connect(self.close_signal_frame)
        self.signal_tab_controller.signal_created.connect(self.on_signal_created)
        self.signal_tab_controller.ui.scrollArea.files_dropped.connect(self.on_files_dropped)
        self.signal_tab_controller.files_dropped.connect(self.on_files_dropped)
        self.signal_tab_controller.frame_was_dropped.connect(self.set_frame_numbers)

        self.simulator_tab_controller.open_in_analysis_requested.connect(self.on_simulator_open_in_analysis_requested)
        self.simulator_tab_controller.rx_file_saved.connect(self.adjust_for_current_file)

        self.compare_frame_controller.show_interpretation_clicked.connect(
            self.show_protocol_selection_in_interpretation)
        self.compare_frame_controller.files_dropped.connect(self.on_files_dropped)
        self.compare_frame_controller.show_decoding_clicked.connect(self.on_show_decoding_dialog_triggered)
        self.compare_frame_controller.ui.treeViewProtocols.files_dropped_on_group.connect(
            self.on_files_dropped_on_group)
        self.compare_frame_controller.participant_changed.connect(self.signal_tab_controller.on_participant_changed)
        self.compare_frame_controller.ui.treeViewProtocols.close_wanted.connect(self.on_cfc_close_wanted)
        self.compare_frame_controller.show_config_field_types_triggered.connect(
            self.on_show_field_types_config_action_triggered)

        self.compare_frame_controller.load_protocol_clicked.connect(self.on_compare_frame_controller_load_protocol_clicked)

        self.ui.lnEdtTreeFilter.textChanged.connect(self.on_file_tree_filter_text_changed)

        self.ui.tabWidget.currentChanged.connect(self.on_selected_tab_changed)
        self.project_save_timer.timeout.connect(self.save_project)

        self.ui.actionConvert_Folder_to_Project.triggered.connect(self.project_manager.convert_folder_to_project)
        self.project_manager.project_loaded_status_changed.connect(self.on_project_loaded_status_changed)
        self.project_manager.project_updated.connect(self.on_project_updated)

        self.ui.textEditProjectDescription.textChanged.connect(self.on_text_edit_project_description_text_changed)
        self.ui.tabWidget_Project.tabBarDoubleClicked.connect(self.on_project_tab_bar_double_clicked)

        self.ui.listViewParticipants.doubleClicked.connect(self.on_project_settings_action_triggered)

        self.ui.actionShowFileTree.triggered.connect(self.on_action_show_filetree_triggered)
        self.ui.actionShowFileTree.setShortcut(QKeySequence("F10"))

        self.ui.labelNonProjectMode.linkActivated.connect(self.on_label_non_project_mode_link_activated)

        self.ui.menuFile.addSeparator()
        for i in range(constants.MAX_RECENT_FILE_NR):
            recent_file_action = QAction(self)
            recent_file_action.setVisible(False)
            recent_file_action.triggered.connect(self.on_open_recent_action_triggered)
            self.recentFileActionList.append(recent_file_action)
            self.ui.menuFile.addAction(self.recentFileActionList[i])

# 需要导入模块: from PyQt5.QtWidgets import QAction [as 别名]
# 或者: from PyQt5.QtWidgets.QAction import setVisible [as 别名]

#.........这里部分代码省略.........
        self.menuEdit.addAction(self.actionMoveDown)
        self.menuEdit.addAction(self.actionDuplicateTransaction)
        self.menuEdit.addAction(self.actionMakeScheduleFromSelected)
        self.menuEdit.addAction(self.actionReconcileSelected)
        self.menuEdit.addAction(self.actionToggleReconciliationMode)
        self.menuEdit.addAction(self.actionToggleAccountExclusion)
        self.menuEdit.addSeparator()
        self.menuEdit.addAction(self.actionShowSelectedAccount)
        self.menuEdit.addAction(self.actionNavigateBack)
        self.menuEdit.addAction(self.actionJumpToAccount)
        self.menuEdit.addSeparator()
        self.menuEdit.addAction(self.actionUndo)
        self.menuEdit.addAction(self.actionRedo)
        self.menuHelp.addAction(self.actionShowHelp)
        self.menuHelp.addAction(self.actionCheckForUpdate)
        self.menuHelp.addAction(self.actionOpenDebugLog)
        self.menuHelp.addAction(self.actionAbout)
        mainmenus = [self.menuFile, self.menuEdit, self.menuView, self.menuHelp]
        for menu in mainmenus:
            self.menubar.addAction(menu.menuAction())
            setAccelKeys(menu)
        setAccelKeys(self.menubar)
        self.tabBar.setMovable(True)
        self.tabBar.setTabsClosable(True)
        self.tabBar.setExpanding(False)

        seq = QKeySequence(Qt.CTRL + Qt.SHIFT + Qt.Key_Right)
        self._shortcutNextTab = QShortcut(seq, self)
        seq = QKeySequence(Qt.CTRL + Qt.SHIFT + Qt.Key_Left)
        self._shortcutPrevTab = QShortcut(seq, self)

        # Linux setup
        if ISLINUX:
            self.actionCheckForUpdate.setVisible(False) # This only works on Windows

    def _bindSignals(self):
        self.newItemButton.clicked.connect(self.actionNewItem.trigger)
        self.deleteItemButton.clicked.connect(self.actionDeleteItem.trigger)
        self.editItemButton.clicked.connect(self.actionEditItem.trigger)
        self.graphVisibilityButton.clicked.connect(self.actionToggleGraph.trigger)
        self.piechartVisibilityButton.clicked.connect(self.actionTogglePieChart.trigger)
        self.columnsVisibilityButton.clicked.connect(self.columnsVisibilityButtonClicked)
        self.recentDocuments.mustOpenItem.connect(self.doc.open)
        self.doc.documentOpened.connect(self.recentDocuments.insertItem)
        self.doc.documentSavedAs.connect(self.recentDocuments.insertItem)
        self.doc.documentPathChanged.connect(self.documentPathChanged)
        self.tabBar.currentChanged.connect(self.currentTabChanged)
        self.tabBar.tabCloseRequested.connect(self.tabCloseRequested)
        self.tabBar.tabMoved.connect(self.tabMoved)

        # Views
        self.actionShowNetWorth.triggered.connect(self.showNetWorthTriggered)
        self.actionShowProfitLoss.triggered.connect(self.showProfitLossTriggered)
        self.actionShowTransactions.triggered.connect(self.showTransactionsTriggered)
        self.actionShowSchedules.triggered.connect(self.showSchedulesTriggered)
        self.actionShowBudgets.triggered.connect(self.showBudgetsTriggered)
        self.actionShowPreviousView.triggered.connect(self.showPreviousViewTriggered)
        self.actionShowNextView.triggered.connect(self.showNextViewTriggered)
        self.actionShowPreferences.triggered.connect(self.app.showPreferences)
        self.actionToggleGraph.triggered.connect(self.toggleGraphTriggered)
        self.actionTogglePieChart.triggered.connect(self.togglePieChartTriggered)

        # Document Edition
        self.actionNewItem.triggered.connect(self.newItemTriggered)
        self.actionNewAccountGroup.triggered.connect(self.newAccountGroupTriggered)
        self.actionDeleteItem.triggered.connect(self.deleteItemTriggered)

# 需要导入模块: from PyQt5.QtWidgets import QAction [as 别名]
# 或者: from PyQt5.QtWidgets.QAction import setVisible [as 别名]
    def __init__(self, argv):
        QMainWindow.__init__(self)
        self.setWindowTitle("SimSo: Real-Time Scheduling Simulator")

        # Possible actions:
        style = QApplication.style()

        # New
        self._newAction = QAction(
            style.standardIcon(QStyle.SP_FileDialogNewFolder), '&New', None)
        self._newAction.setShortcut(Qt.CTRL + Qt.Key_N)
        self._newAction.triggered.connect(self.fileNew)

        # Open
        self._openAction = QAction(
            style.standardIcon(QStyle.SP_DialogOpenButton), '&Open', None)
        self._openAction.setShortcut(Qt.CTRL + Qt.Key_O)
        self._openAction.triggered.connect(self.fileOpen)

        # Save
        self._saveAction = QAction(
            style.standardIcon(QStyle.SP_DialogSaveButton), '&Save', None)
        self._saveAction.setShortcut(Qt.CTRL + Qt.Key_S)
        self._saveAction.triggered.connect(self.fileSave)

        # Save As
        self._saveAsAction = QAction(
            style.standardIcon(QStyle.SP_DialogSaveButton), 'Save &As', None)
        self._saveAsAction.setShortcut(Qt.CTRL + Qt.SHIFT + Qt.Key_S)
        self._saveAsAction.triggered.connect(self.fileSaveAs)

        # Run
        self._runAction = QAction(
            style.standardIcon(QStyle.SP_MediaPlay), '&Run', None)
        self._runAction.setShortcut(Qt.CTRL + Qt.Key_R)
        self._runAction.triggered.connect(self.fileRun)

        # Show Model data
        self._modelAction = QAction('&Model data', None)
        self._modelAction.setShortcut(Qt.CTRL + Qt.Key_M)
        #self._ganttAction.setCheckable(True)
        self._modelAction.triggered.connect(self.showModelWindow)

        # Show Gantt
        self._ganttAction = QAction('&Gantt', None)
        self._ganttAction.setShortcut(Qt.CTRL + Qt.Key_G)
        self._ganttAction.setEnabled(False)
        #self._ganttAction.setCheckable(True)
        self._ganttAction.triggered.connect(self.showGantt)

        # Show Results
        self._metricsAction = QAction('&Results', None)
        self._metricsAction.setShortcut(Qt.CTRL + Qt.Key_I)
        self._metricsAction.setEnabled(False)
        #self._metricsAction.setCheckable(True)
        self._metricsAction.triggered.connect(self.showResults)

        # Show Doc
        self._docAction = QAction('&Documentation', None)
        self._docAction.triggered.connect(self.showDocumentation)

        self._aboutAction = QAction('&About SimSo', None)
        self._aboutAction.triggered.connect(self.showAbout)

        # Recent files
        self._recentFileActions = []
        for i in range(5):
            act = QAction(self)
            act.setVisible(False)
            act.triggered.connect(self.openRecentFile)
            self._recentFileActions.append(act)

        # File Menu:
        file_menu = QMenu('&File', self)
        file_menu.addAction(self._newAction)
        file_menu.addAction(self._openAction)
        file_menu.addAction(self._saveAction)
        file_menu.addAction(self._saveAsAction)
        file_menu.addAction(self._runAction)
        file_menu.addSeparator()
        for act in self._recentFileActions:
            file_menu.addAction(act)
        file_menu.addSeparator()
        file_menu.addAction('&Quit', self.fileQuit, Qt.CTRL + Qt.Key_Q)
        self.updateRecentFileActions()

        # View Menu:
        view_menu = QMenu('&View', self)
        view_menu.addAction(self._modelAction)
        view_menu.addAction(self._ganttAction)
        view_menu.addAction(self._metricsAction)

        # Help Menu:
        help_menu = QMenu('&Help', self)
        help_menu.addAction(self._docAction)
        help_menu.addAction(self._aboutAction)

        # Add menus to menuBar:
        self.menuBar().addMenu(file_menu)
        self.menuBar().addMenu(view_menu)
#.........这里部分代码省略.........

# 需要导入模块: from PyQt5.QtWidgets import QAction [as 别名]
# 或者: from PyQt5.QtWidgets.QAction import setVisible [as 别名]

#.........这里部分代码省略.........
        core.uiSettingsManager().dialogAccepted.disconnect(self._onDocumentChanged)
        if self._dock:
            self._dock.closed.disconnect(self._onDockClosed)
            self._dock.shown.disconnect(self._onDockShown)
            self._saveAction.triggered.disconnect(self._dock.onPreviewSave)

    def _onDocumentChanged(self):
        """Document or Language changed.
        Create dock, if necessary
        """
        if self._canPreview(core.workspace().currentDocument()):
            if not self._dockInstalled:
                self._createDock()
        else:
            if self._dockInstalled:
                self._removeDock()

    def _canPreview(self, document):
        """Check if the given document can be shown in the Preview dock.
        """
        if document is None:
            return False

        if document.qutepart.language() in ("Markdown", "Restructured Text") or isHtmlFile(document):
            return True

        if canUseCodeChat(document.filePath()):
            return True

        if sphinxEnabledForFile(document.filePath()):
            return True

        return False

    def _createDock(self):
        """Install dock
        """
        # create dock
        if self._dock is None:
            from enki.plugins.preview.preview import PreviewDock

            self._dock = PreviewDock()
            self._dock.closed.connect(self._onDockClosed)  # Disconnected.
            self._dock.shown.connect(self._onDockShown)  # Disconnected.

            self._saveAction = QAction(QIcon(":enkiicons/save.png"), "Save Preview as HTML", self._dock)
            self._saveAction.setShortcut(QKeySequence("Alt+Shift+P"))
            self._saveAction.triggered.connect(self._dock.onPreviewSave)  # Disconnected.

        core.mainWindow().addDockWidget(Qt.RightDockWidgetArea, self._dock)

        core.actionManager().addAction("mView/aPreview", self._dock.showAction())
        core.actionManager().addAction("mFile/aSavePreview", self._saveAction)
        self._dockInstalled = True
        if core.config()["Preview"]["Enabled"]:
            self._dock.show()

    def _onDockClosed(self):
        """Dock has been closed by user. Change Enabled option
        """
        if core.config()["Preview"]["Enabled"]:
            core.config()["Preview"]["Enabled"] = False
            core.config().flush()

    def _onDockShown(self):
        """Dock has been shown by user. Change Enabled option
        """
        if not core.config()["Preview"]["Enabled"]:
            core.config()["Preview"]["Enabled"] = True
            core.config().flush()

    def _removeDock(self):
        """Remove dock from GUI
        """
        core.actionManager().removeAction("mView/aPreview")
        core.actionManager().removeAction("mFile/aSavePreview")
        core.mainWindow().removeDockWidget(self._dock)
        self._dockInstalled = False

    def _onSettingsDialogAboutToExecute(self, dialog):
        """The UI settings dialog is about to execute. Install preview-related
           settings."""
        CodeChatSettingsWidget(dialog)
        SphinxSettingsWidget(dialog)

    def _setSphinxActionVisibility(self):
        self._sphinxAction.setVisible(core.config()["Sphinx"]["Enabled"])

    def onFileBrowserPathChanged(self):
        """Enable the onSphinxPath command only when there's a valid project
           path."""
        self._sphinxAction.setEnabled(bool(core.project().path()))

    def onSphinxPath(self):
        """Set the Sphinx path to the current project path."""
        assert core.project().path()
        core.config()["Sphinx"]["ProjectPath"] = core.project().path()
        core.config().flush()
        if core.config()["Preview"]["Enabled"] and self._dock is not None:
            self._dock._scheduleDocumentProcessing()

# 需要导入模块: from PyQt5.QtWidgets import QAction [as 别名]
# 或者: from PyQt5.QtWidgets.QAction import setVisible [as 别名]
class StatusRocker(QToolBar):
    def __init__(self, *args, **kwargs):
        super(StatusRocker, self).__init__(*args, **kwargs)
        self.setWindowFlags(Qt.WindowStaysOnTopHint)
        
        # Displays the date and time while in fullscreen mode.
        self.dateTime = QAction(self)
        self.addAction(self.dateTime)
        self.dateTimeButton = self.widgetForAction(self.dateTime)
        self.dateTimeButton.setStyleSheet("QToolButton { font-family: monospace; border-radius: 4px; padding: 2px; background: palette(highlight); color: palette(highlighted-text); }")
        self.dateTimeButton.clicked.connect(self.showCalendar)
        self.dateTime.setVisible(False)
        
        self.batteryAction = custom_widgets.BatteryAction(self)
        self.addAction(self.batteryAction)
        self.batteryWidget = self.widgetForAction(self.batteryAction)
        self.batteryWidget.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
        
        # Add stuff for linux
        self.networkManagerAction = QAction(common.complete_icon("network-idle"), "N/A", self)
        self.networkManagerAction.setToolTip("Network Management")
        self.networkManagerAction.setShortcut("Alt+N")
        self.addAction(self.networkManagerAction)
        self.networkManagerButton = self.widgetForAction(self.networkManagerAction)
        self.networkManagerButton.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
        self.addAction(self.networkManagerAction)
        if sys.platform.startswith("linux"):
            self.networkManagerMenu = QMenu(self)
            self.networkManagerMenu.aboutToShow.connect(self.aboutToShowNetworkManagerMenu)
            self.connectedToAction = QAction(self.networkManagerMenu)
            self.connectedToAction.setDisabled(True)
            self.networkManagerMenu.addAction(self.connectedToAction)
            
            self.connectAction = QAction("Connect to Wi-Fi Network...", self.networkManagerMenu)
            self.connectAction.triggered.connect(lambda: os.system("qdbus org.gnome.network_manager_applet /org/gnome/network_manager_applet ConnectToHiddenNetwork &"))
            self.networkManagerMenu.addAction(self.connectAction)
        
            self.connectionEditAction = QAction("Edit Connections...", self.networkManagerMenu)
            self.connectionEditAction.triggered.connect(lambda: os.system("nm-connection-editor &"))
            self.networkManagerMenu.addAction(self.connectionEditAction)
        
            self.networkManagerAction.triggered.connect(self.networkManagerButton.showMenu)
            self.networkManagerAction.setMenu(self.networkManagerMenu)
            self.networkManagerButton.setPopupMode(QToolButton.InstantPopup)
        else:
            self.networkManagerAction.triggered.connect(lambda: os.system("control ncpa.cpl"))
        self.timer = QTimer(timeout=self.updateNetworkStatus, parent=self)
        self.timer.start(500)
    def showCalendar(self):
        calendar.setVisible(not calendar.isVisible())
        y = self.dateTimeButton.mapToGlobal(QPoint(0,0)).y() + self.dateTimeButton.height()
        calendar.move(min(self.dateTimeButton.mapToGlobal(QPoint(0,0)).x(), common.desktop.width()-calendar.width()), self.dateTimeButton.mapToGlobal(QPoint(0,0)).y()-calendar.height() if y > common.desktop.height()-calendar.height() else y)
    def aboutToShowNetworkManagerMenu(self):
        if network.isConnectedToNetwork():
            self.connectedToAction.setText("Connected to %s" % system.get_ssid())
        else:
            self.connectedToAction.setText(tr("No Internet connection"))
    def updateNetworkStatus(self):
        self.networkManagerAction.setIcon(common.complete_icon("network-idle") if network.isConnectedToNetwork() else common.complete_icon("network-offline"))
        strength = system.get_signal_strength()
        self.networkManagerAction.setText(strength)

# 需要导入模块: from PyQt5.QtWidgets import QAction [as 别名]
# 或者: from PyQt5.QtWidgets.QAction import setVisible [as 别名]
class RecentFiles():
    """Keeps track of last opened files."""

    def __init__(self, parent = None):
        """Constructor"""
        self.parent = parent
        self.max_recent = 5
        self.recent_files = []
        self.recent_actions = []
        self.action_clear_history = QAction(self.parent)
        self.create()
        self.update()

    def create(self):
        """Creates menu actions."""
        for i in range(self.max_recent):
            action = QAction(self.parent)
            action.setIcon(QIcon(QPixmap(":/icons/action_rom.png")))
            self.recent_actions.append(action)
            self.recent_actions[i].setVisible(False)
            self.recent_actions[i].triggered.connect(self.parent.on_file_open)
            self.parent.menuRecent.addAction(self.recent_actions[i])
        self.parent.menuRecent.addSeparator()
        self.action_clear_history.setText("&Clear history")
        self.action_clear_history.setEnabled(False)
        self.action_clear_history.setVisible(True)
        self.action_clear_history.setIcon(
            QIcon(QPixmap(":/icons/action_clear.png")))
        self.action_clear_history.triggered.connect(self.clear)
        self.parent.menuRecent.addAction(self.action_clear_history)

    def is_string(self, obj):
        try:
            return isinstance(obj, basestring)
        except NameError:
            return isinstance(obj, str)

    def update(self):
        """Updates list of recent files."""
        self.recent_files = self.parent.settings.qset.value("recent_files", [])
        if not type(self.recent_files) == list:
            self.recent_files = []
        self.recent_files = list(filter(lambda x: self.is_string(x), self.recent_files))
        num_files = min(len(self.recent_files), self.max_recent)
        for i in range(num_files):
            text = QFileInfo(self.recent_files[i]).fileName()
            self.recent_actions[i].setText(text)
            self.recent_actions[i].setData(self.recent_files[i])
            self.recent_actions[i].setVisible(True)
            self.recent_actions[i].setToolTip(QFileInfo(
                self.recent_files[i]).filePath())
        for j in range(num_files, self.max_recent):
            self.recent_actions[j].setVisible(False)
        self.action_clear_history.setEnabled((num_files > 0))

    def add(self, filepath):
        """Adds file to recent files list."""
        if filepath in self.recent_files:
            self.recent_files.remove(filepath)
        self.recent_files.insert(0, filepath)
        while len(self.recent_files) > 5:
            self.recent_files.pop(len(self.recent_files) - 1)
        self.parent.settings.qset.setValue(
            "recent_files", self.recent_files)
        self.update()

    def clear(self):
        """Clears list of recent files."""
        self.parent.settings.qset.remove("recent_files")
        self.update()

# 需要导入模块: from PyQt5.QtWidgets import QAction [as 别名]
# 或者: from PyQt5.QtWidgets.QAction import setVisible [as 别名]

#.........这里部分代码省略.........
        """
        if self._canPreview(core.workspace().currentDocument()):
            if not self._dockInstalled:
                self._createDock()
        else:
            if self._dockInstalled:
                self._removeDock()

    def _canPreview(self, document):
        """Check if the given document can be shown in the Preview dock.
        """
        if document is None:
            return False

        if document.qutepart.language() in ('Markdown', 'reStructuredText') or \
           isHtmlFile(document):
            return True

        if canUseCodeChat(document.filePath()):
            return True

        if sphinxEnabledForFile(document.filePath()):
            return True

        return False

    def _createDock(self):
        """Install dock
        """
        # create dock
        if self._dock is None:
            if haveWebEngine:
                from enki.plugins.preview.preview import PreviewDock
                self._dock = PreviewDock()

                self._saveAction = QAction(QIcon(':enkiicons/save.png'),
                                           'Save Preview as HTML', self._dock)
                self._saveAction.setShortcut(QKeySequence("Alt+Shift+P"))
                self._saveAction.triggered.connect(self._dock.onPreviewSave)
            else:
                self._dock = NoWebkitDock()

        if haveWebEngine:
            core.actionManager().addAction("mFile/aSavePreview", self._saveAction)

        self._dock.closed.connect(self._onDockClosed)
        self._dock.shown.connect(self._onDockShown)
        core.mainWindow().addDockWidget(Qt.RightDockWidgetArea, self._dock)

        core.actionManager().addAction("mView/aPreview",
                                       self._dock.showAction())
        self._dockInstalled = True
        if core.config()['Preview']['Enabled']:
            self._dock.show()

    def _onDockClosed(self):
        """Dock has been closed by user. Change Enabled option
        """
        if core.config()['Preview']['Enabled']:
            core.config()['Preview']['Enabled'] = False
            core.config().flush()

    def _onDockShown(self):
        """Dock has been shown by user. Change Enabled option
        """
        if not core.config()['Preview']['Enabled']:
            core.config()['Preview']['Enabled'] = True
            core.config().flush()

    def _removeDock(self):
        """Remove dock from GUI
        """
        if haveWebEngine:
            core.actionManager().removeAction("mFile/aSavePreview")

        core.actionManager().removeAction("mView/aPreview")
        core.mainWindow().removeDockWidget(self._dock)
        self._dockInstalled = False

    def _onSettingsDialogAboutToExecute(self, dialog):
        """The UI settings dialog is about to execute. Install preview-related
           settings."""
        CodeChatSettingsWidget(dialog)
        SphinxSettingsWidget(dialog)

    def _setSphinxActionVisibility(self):
        self._sphinxAction.setVisible(core.config()['Sphinx']['Enabled'])

    def onFileBrowserPathChanged(self):
        """Enable the onSphinxPath command only when there's a valid project
           path."""
        self._sphinxAction.setEnabled(bool(core.project().path()))

    def onSphinxPath(self):
        """Set the Sphinx path to the current project path."""
        assert core.project().path()
        core.config()['Sphinx']['ProjectPath'] = core.project().path()
        core.config().flush()
        if core.config()['Preview']['Enabled'] and self._dock is not None:
            self._dock._scheduleDocumentProcessing()

# 需要导入模块: from PyQt5.QtWidgets import QAction [as 别名]
# 或者: from PyQt5.QtWidgets.QAction import setVisible [as 别名]
class DateRangeSelector(QObject):
    def __init__(self, mainwindow, view):
        QObject.__init__(self)
        self.mainwindow = mainwindow
        self.view = view
        self.model = mainwindow.model.daterange_selector
        self.model.view = self
        self._setupUi()

    def _setupUi(self):
        # Create actions
        self.actionNext = QAction(tr("Next"), self)
        self.actionNext.setShortcut("Ctrl+Alt+]")
        self.actionNext.triggered.connect(self.model.select_next_date_range)
        self.actionPrevious = QAction(tr("Previous"), self)
        self.actionPrevious.setShortcut("Ctrl+Alt+[")
        self.actionPrevious.triggered.connect(self.model.select_prev_date_range)
        self.actionToday = QAction(tr("Today"), self)
        self.actionToday.setShortcut("Ctrl+Alt+T")
        self.actionToday.triggered.connect(self.model.select_today_date_range)
        self.actionChangeToMonth = QAction(tr("Month"), self)
        self.actionChangeToMonth.setShortcut("Ctrl+Alt+1")
        self.actionChangeToMonth.triggered.connect(self.model.select_month_range)
        self.actionChangeToQuarter = QAction(tr("Quarter"), self)
        self.actionChangeToQuarter.setShortcut("Ctrl+Alt+2")
        self.actionChangeToQuarter.triggered.connect(self.model.select_quarter_range)
        self.actionChangeToYear = QAction(tr("Year"), self)
        self.actionChangeToYear.setShortcut("Ctrl+Alt+3")
        self.actionChangeToYear.triggered.connect(self.model.select_year_range)
        self.actionChangeToYearToDate = QAction(tr("Year To Date"), self)
        self.actionChangeToYearToDate.setShortcut("Ctrl+Alt+4")
        self.actionChangeToYearToDate.triggered.connect(self.model.select_year_to_date_range)
        self.actionChangeToRunningYear = QAction(tr("Running Year"), self)
        self.actionChangeToRunningYear.setShortcut("Ctrl+Alt+5")
        self.actionChangeToRunningYear.triggered.connect(self.model.select_running_year_range)
        self.actionChangeToAllTransactions = QAction(tr("All Transactions"), self)
        self.actionChangeToAllTransactions.setShortcut("Ctrl+Alt+6")
        self.actionChangeToAllTransactions.triggered.connect(self.model.select_all_transactions_range)
        self.actionChangeToCustom = QAction(tr("Custom..."), self)
        self.actionChangeToCustom.setShortcut("Ctrl+Alt+7")
        self.actionChangeToCustom.triggered.connect(self.model.invoke_custom_range_panel)
        self.actionChangeToCustom1 = QAction("Custom1", self)
        self.actionChangeToCustom1.setShortcut("Ctrl+Alt+8")
        self.actionChangeToCustom1.setVisible(False)
        self.actionChangeToCustom1.triggered.connect(self.custom1Triggered)
        self.actionChangeToCustom2 = QAction("Custom2", self)
        self.actionChangeToCustom2.setShortcut("Ctrl+Alt+9")
        self.actionChangeToCustom2.setVisible(False)
        self.actionChangeToCustom2.triggered.connect(self.custom2Triggered)
        self.actionChangeToCustom3 = QAction("Custom3", self)
        self.actionChangeToCustom3.setShortcut("Ctrl+Alt+0")
        self.actionChangeToCustom3.setVisible(False)
        self.actionChangeToCustom3.triggered.connect(self.custom3Triggered)

        # set typeButton menu
        menu = QMenu(self.view.typeButton)
        menu.addAction(self.actionChangeToMonth)
        menu.addAction(self.actionChangeToQuarter)
        menu.addAction(self.actionChangeToYear)
        menu.addAction(self.actionChangeToYearToDate)
        menu.addAction(self.actionChangeToRunningYear)
        menu.addAction(self.actionChangeToAllTransactions)
        menu.addAction(self.actionChangeToCustom)
        menu.addAction(self.actionChangeToCustom1)
        menu.addAction(self.actionChangeToCustom2)
        menu.addAction(self.actionChangeToCustom3)
        self.view.typeButton.setMenu(menu)

        # set mainwindow's date range menu
        m = self.mainwindow.menuDateRange
        m.addAction(self.actionChangeToMonth)
        m.addAction(self.actionChangeToQuarter)
        m.addAction(self.actionChangeToYear)
        m.addAction(self.actionChangeToYearToDate)
        m.addAction(self.actionChangeToRunningYear)
        m.addAction(self.actionChangeToAllTransactions)
        m.addAction(self.actionChangeToCustom)
        m.addAction(self.actionChangeToCustom1)
        m.addAction(self.actionChangeToCustom2)
        m.addAction(self.actionChangeToCustom3)
        m.addAction(self.actionPrevious)
        m.addAction(self.actionNext)
        m.addAction(self.actionToday)

        # bind prev/next button
        self.view.prevButton.clicked.connect(self.model.select_prev_date_range)
        self.view.nextButton.clicked.connect(self.model.select_next_date_range)

    # --- Event Handlers
    def custom1Triggered(self):
        self.model.select_saved_range(0)

    def custom2Triggered(self):
        self.model.select_saved_range(1)

    def custom3Triggered(self):
        self.model.select_saved_range(2)

    # --- model --> view
    def animate_backward(self):
#.........这里部分代码省略.........