def __init__(self, *args, show_tooltip=False, **kws): super().__init__(*args, **kws) self._filled_with_arch_data = dict() self._show_tooltip = show_tooltip self.vb2 = ViewBox() self.plotItem.scene().addItem(self.vb2) self.vb2.setXLink(self.plotItem) self.plotItem.getAxis('right').linkToView(self.vb2) self._updateViews() self.plotItem.vb.sigResized.connect(self._updateViews) self.carch = None # show auto adjust button self.plotItem.showButtons() # use pan mouse mode (3-button) self.plotItem.getViewBox().setMouseMode(ViewBox.PanMode) # connect sigMouseMoved self.plotItem.scene().sigMouseMoved.connect(self._handle_mouse_moved) # add new actions to menu rst_act = QAction("Clear buffers") rst_act.triggered.connect(self._resetBuffers) tsp_act = QAction("Change time span") tsp_act.triggered.connect(self._changeTimeSpan) self.plotItem.scene().contextMenu.extend([rst_act, tsp_act])
def InitMenu(self): mainMenu = self.menuBar fileMenu = mainMenu.addMenu('File') SaveRec1Action = QAction('Save Rec1 as', self) SaveRec1Action.setStatusTip('Save a copy of Rec1 and Evens') SaveRec1Action.triggered.connect(self.SaveRec1) fileMenu.addAction(SaveRec1Action) SaveJoinRecAction = QAction('Join Rec1 and Rec2 as', self) SaveJoinRecAction.setStatusTip( 'Save a copy of Rec1 and Rec2 with Tstart') SaveJoinRecAction.triggered.connect(self.SaveJoinRec) fileMenu.addAction(SaveJoinRecAction) SaveFigAction = QAction('Save Figures', self) SaveFigAction.setShortcut('Ctrl+s') SaveFigAction.setStatusTip('Save all open figures') SaveFigAction.triggered.connect(self.SaveFigures) fileMenu.addAction(SaveFigAction) CloseFigsAction = QAction('Close Figures', self) CloseFigsAction.setStatusTip('Close all open figures') CloseFigsAction.triggered.connect(self.CloseFigures) fileMenu.addAction(CloseFigsAction)
def set_context_menu_actions(self, table): """ Sets up the context menu actions for the table :type table: QTableView :param table: The table whose context menu actions will be set up. :param ws_read_function: The read function used to efficiently retrieve data directly from the workspace """ copy_action = QAction(self.COPY_ICON, "Copy", table) copy_action.triggered.connect(self.presenter.action_copy_cells) table.setContextMenuPolicy(Qt.ActionsContextMenu) table.addAction(copy_action) horizontalHeader = table.horizontalHeader() horizontalHeader.setContextMenuPolicy(Qt.CustomContextMenu) horizontalHeader.customContextMenuRequested.connect(self.custom_context_menu) verticalHeader = table.verticalHeader() verticalHeader.setContextMenuPolicy(Qt.ActionsContextMenu) verticalHeader.setSectionResizeMode(QHeaderView.Fixed) copy_spectrum_values = QAction(self.COPY_ICON, "Copy", verticalHeader) copy_spectrum_values.triggered.connect(self.presenter.action_copy_spectrum_values) delete_row = QAction(self.DELETE_ROW, "Delete Row", verticalHeader) delete_row.triggered.connect(self.presenter.action_delete_row) separator2 = self.make_separator(verticalHeader) verticalHeader.addAction(copy_spectrum_values) verticalHeader.addAction(separator2) verticalHeader.addAction(delete_row)
def _create_actions(self): self.blctrl_enbl_act = QAction("Enable Beamline Control", self) self.blctrl_enbl_act.triggered.connect( lambda: self._set_beamline_control(True)) self.blctrl_dsbl_act = QAction("Disable Beamline Control", self) self.blctrl_dsbl_act.triggered.connect( lambda: self._set_beamline_control(False))
def __init__(self, parent): """ :param parent: :return: """ base.CustomizedTreeView.__init__(self, parent) # define actions self._action_plot = QAction('Plot', self) self._action_plot.triggered.connect(self.do_plot) # to python self._action_ipython = QAction('To IPython', self) self._action_ipython.triggered.connect(self.do_copy_to_ipython) # remove from plot self._action_remove_plot = QAction('Remove from plot', self) self._action_remove_plot.triggered.connect(self.do_remove_from_plot) # delete workspace/data self._action_delete = QAction('Delete data', self) self._action_delete.triggered.connect(self.do_delete_selected_items) self._mainWindow = None self._workspaceNameList = None self.reset_gr_tree() return
def _setup_actions(self): """Creates the main window actions.""" # Show/hide callable objects self.toggle_show_callable_action = QAction( _("Show callable attributes"), self, checkable=True, shortcut=QKeySequence("Alt+C"), statusTip=_("Shows/hides attributes that are callable " "(functions, methods, etc)")) self.toggle_show_callable_action.toggled.connect( self._proxy_tree_model.setShowCallables) self.toggle_show_callable_action.toggled.connect( self.obj_tree.resize_columns_to_contents) # Show/hide special attributes self.toggle_show_special_attribute_action = QAction( _("Show __special__ attributes"), self, checkable=True, shortcut=QKeySequence("Alt+S"), statusTip=_("Shows or hides __special__ attributes")) self.toggle_show_special_attribute_action.toggled.connect( self._proxy_tree_model.setShowSpecialAttributes) self.toggle_show_special_attribute_action.toggled.connect( self.obj_tree.resize_columns_to_contents)
def setup_menu(self): menubar = self.menuBar() file_menu = menubar.addMenu('&Archivo') refresh_action = QAction(qta.icon('fa5s.sync'), '&Actualizar', self) refresh_action.setShortcut('Ctrl+A') refresh_action.setStatusTip( 'Actualizando Base de Datos de Artículos....') refresh_action.triggered.connect( scraper.scrapeAll) # Llamar al método de scrapper file_menu.addAction(refresh_action) exit_action = QAction(qta.icon('fa5.times-circle'), '&Salir', self) exit_action.setShortcut('Ctrl+Q') exit_action.setStatusTip('Saliendo de la aplicación....') exit_action.triggered.connect(QApplication.instance().closeAllWindows) file_menu.addAction(exit_action) help_menu = menubar.addMenu('&Ayuda') about_action = QAction(qta.icon('fa5s.info-circle'), '&Acerca de', self) about_action.setShortcut('Ctrl+I') about_action.setStatusTip('Acerca de...') about_action.triggered.connect(self.show_about_dialog) help_menu.addAction(about_action)
def setup_plot_spectrum_actions(self, context_menu, table): plot_spectrum_action = QAction(self.GRAPH_ICON, "Plot spectrum (values only)", self) plot_spectrum_action.triggered.connect( partial(self.presenter.action_plot_spectrum, table)) plot_spectrum_with_errors_action = QAction( self.GRAPH_ICON, "Plot spectrum (values + errors)", self) plot_spectrum_with_errors_action.triggered.connect( partial(self.presenter.action_plot_spectrum_with_errors, table)) overplot_spectrum_action = QAction(self.GRAPH_ICON, "Overplot spectrum (values only)", self) overplot_spectrum_action.triggered.connect( partial(self.presenter.action_overplot_spectrum, table)) overplot_spectrum_with_errors_action = QAction( self.GRAPH_ICON, "Overplot spectrum (values + errors)", self) overplot_spectrum_with_errors_action.triggered.connect( partial(self.presenter.action_overplot_spectrum_with_errors, table)) overplot_spectrum_action.setEnabled(can_overplot()) overplot_spectrum_with_errors_action.setEnabled(can_overplot()) separator = QAction(self) separator.setSeparator(True) list( map(context_menu.addAction, [ plot_spectrum_action, plot_spectrum_with_errors_action, separator, overplot_spectrum_action, overplot_spectrum_with_errors_action ]))
def _add_plugins_menu(self): """Add 'Plugins' menu to app menubar.""" self.plugins_menu = self.main_menu.addMenu('&Plugins') list_plugins_action = QAction("List Installed Plugins...", self._qt_window) list_plugins_action.setStatusTip('List installed plugins') list_plugins_action.triggered.connect(self._show_plugin_list) self.plugins_menu.addAction(list_plugins_action) pip_install_action = QAction("Install/Uninstall Package(s)...", self._qt_window) pip_install_action.triggered.connect(self._show_pip_install_dialog) self.plugins_menu.addAction(pip_install_action) order_plugin_action = QAction("Plugin Call Order...", self._qt_window) order_plugin_action.setStatusTip('Change call order for plugins') order_plugin_action.triggered.connect(self._show_plugin_sorter) self.plugins_menu.addAction(order_plugin_action) report_plugin_action = QAction("Plugin Errors...", self._qt_window) report_plugin_action.setStatusTip( 'Review stack traces for plugin exceptions and notify developers') report_plugin_action.triggered.connect(self._show_plugin_err_reporter) self.plugins_menu.addAction(report_plugin_action)
def _add_file_menu(self): """Add 'File' menu to app menubar.""" open_images = QAction('Open image(s)...', self._qt_window) open_images.setShortcut('Ctrl+O') open_images.setStatusTip('Open image file(s)') open_images.triggered.connect(self.qt_viewer._open_images) open_stack = QAction('Open image series as stack...', self._qt_window) open_stack.setShortcut('Ctrl+Alt+O') open_stack.setStatusTip('Open image files') open_stack.triggered.connect(self.qt_viewer._open_images_as_stack) open_folder = QAction('Open Folder...', self._qt_window) open_folder.setShortcut('Ctrl+Shift+O') open_folder.setStatusTip( 'Open a folder of image file(s) or a zarr file') open_folder.triggered.connect(self.qt_viewer._open_folder) screenshot = QAction('Screenshot', self._qt_window) screenshot.setShortcut('Ctrl+Alt+S') screenshot.setStatusTip( 'Save screenshot of current display, default .png') screenshot.triggered.connect(self.qt_viewer._save_screenshot) self.file_menu = self.main_menu.addMenu('&File') self.file_menu.addAction(open_images) self.file_menu.addAction(open_stack) self.file_menu.addAction(open_folder) self.file_menu.addAction(screenshot)
def _setup_menu(self): file_menu = self.menuBar().addMenu('File') new_action = QAction('New Notebook', self) new_action.triggered.connect(self.tabwidget.create_new_client) file_menu.addAction(new_action) open_action = QAction('Open Notebook...', self) open_action.triggered.connect(self.tabwidget.open_notebook) file_menu.addAction(open_action) save_action = QAction('Save Notebook', self) save_action.triggered.connect( lambda checked: self.tabwidget.save_notebook(self.tabwidget. currentWidget())) file_menu.addAction(save_action) saveas_action = QAction('Save As...', self) saveas_action.triggered.connect(self.tabwidget.save_as) file_menu.addAction(saveas_action) close_action = QAction('Close Notebook', self) close_action.triggered.connect( lambda checked: self.tabwidget.close_client(self.tabwidget. currentIndex())) file_menu.addAction(close_action)
def __init__(self, parent=None, show=True, off_screen=True): MainWindow.__init__(self, parent) self.frame = QFrame() vlayout = QVBoxLayout() self.vtk_widget = QtInteractor( parent=self.frame, off_screen=off_screen, stereo=False, ) vlayout.addWidget(self.vtk_widget.interactor) self.frame.setLayout(vlayout) self.setCentralWidget(self.frame) mainMenu = _create_menu_bar(parent=self) fileMenu = mainMenu.addMenu('File') self.exit_action = QAction('Exit', self) self.exit_action.setShortcut('Ctrl+Q') self.exit_action.triggered.connect(self.close) fileMenu.addAction(self.exit_action) meshMenu = mainMenu.addMenu('Mesh') self.add_sphere_action = QAction('Add Sphere', self) self.exit_action.setShortcut('Ctrl+A') self.add_sphere_action.triggered.connect(self.add_sphere) meshMenu.addAction(self.add_sphere_action) self.signal_close.connect(self.vtk_widget.close) if show: self.show()
def setScene(self, scene: FlowScene): """ setScene Parameters ---------- scene : FlowScene """ self._scene = scene super().setScene(self._scene) # setup actions del self._clear_selection_action self._clear_selection_action = QAction("Clear Selection", self) self._clear_selection_action.setShortcut(QKeySequence.Cancel) self._clear_selection_action.triggered.connect( self._scene.clearSelection) self.addAction(self._clear_selection_action) del self._delete_selection_action self._delete_selection_action = QAction("Delete Selection", self) self._delete_selection_action.setShortcut(QKeySequence.Backspace) self._delete_selection_action.setShortcut(QKeySequence.Delete) self._delete_selection_action.triggered.connect(self.delete_selected) self.addAction(self._delete_selection_action)
def __init__(self, tracker: Tracker) -> None: super().__init__() self.qttracker = QtTracker(tracker) self.bg_thread = QThread(self) self.qttracker.moveToThread(self.bg_thread) self.bg_thread.start() self.qttracker.start_recording() self.setCentralWidget(Controls(self.qttracker)) toolbar = QToolBar() self.addToolBar(toolbar) toolbar.setMovable(False) toolbar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon) self.new_action = QAction("New", self) self.new_action.setToolTip("Create a new file for tracking.") icon = self.style().standardIcon(QStyle.SP_FileIcon) self.new_action.setIcon(icon) self.new_action.triggered.connect(self.new_db) toolbar.addAction(self.new_action) self.load_action = QAction("Load", self) self.load_action.setToolTip("Load a existing file for tracking.") icon = self.style().standardIcon(QStyle.SP_DialogOpenButton) self.load_action.setIcon(icon) self.load_action.triggered.connect(self.load_db) toolbar.addAction(self.load_action)
def _rebuild_samples_menu(self): from ...plugins import _npe2, menu_item_template, plugin_manager self.open_sample_menu.clear() for plugin_name, samples in chain(_npe2.sample_iterator(), plugin_manager._sample_data.items()): multiprovider = len(samples) > 1 if multiprovider: menu = self.open_sample_menu.addMenu(plugin_name) else: menu = self.open_sample_menu for samp_name, samp_dict in samples.items(): display_name = samp_dict['display_name'].replace("&", "&&") if multiprovider: action = QAction(display_name, parent=self) else: full_name = menu_item_template.format( plugin_name, display_name) action = QAction(full_name, parent=self) def _add_sample(*args, plg=plugin_name, smp=samp_name): self._win._qt_viewer.viewer.open_sample(plg, smp) menu.addAction(action) action.triggered.connect(_add_sample)
def _set_actions_and_menus(self, nsb): """ Set actions and menus created here and used by the namespace browser editor. Although this is not ideal, it's necessary to be able to use the CollectionsEditor widget separately from this plugin. """ editor = nsb.editor # Actions editor.paste_action = self.paste_action editor.copy_action = self.copy_action editor.edit_action = self.edit_action editor.plot_action = self.plot_action editor.hist_action = self.hist_action editor.imshow_action = self.imshow_action editor.save_array_action = self.save_array_action editor.insert_action = self.insert_action editor.remove_action = self.remove_action editor.minmax_action = self.show_minmax_action editor.rename_action = self.rename_action editor.duplicate_action = self.duplicate_action editor.view_action = self.view_action # Menus editor.menu = self.context_menu editor.empty_ws_menu = self.empty_context_menu # These actions are not used for dictionaries (so we don't need them # for namespaces) but we have to create them so they can be used in # several places in CollectionsEditor. editor.insert_action_above = QAction() editor.insert_action_below = QAction()
def __init__(self, env): super().__init__() self._env = env self._extra_menu_actions = [] self._extra_toolbar_actions = [] self.update_title() main_menu = self.menuBar() self.main_menu = main_menu project_menu = main_menu.addMenu("&Project") toolbar = self.addToolBar("Top") self.toolbar = toolbar new_action = QAction("&New", self) new_action.setShortcut("Ctrl+N") new_action.setStatusTip("Create a new empty project") new_action.triggered.connect(lambda: env.new()) project_menu.addAction(new_action) open_action = QAction("&Open...", self) open_action.setShortcut("Ctrl+O") open_action.setStatusTip("Open an existing project") open_action.triggered.connect(lambda: env.open()) project_menu.addAction(open_action) save_action = QAction("&Save", self) self.save_action = save_action save_action.setShortcut("Ctrl+S") save_action.setIcon(QIcon.fromTheme("document-save")) #save_action.setIcon(self.style().standardIcon( # self.style().SP_DialogSaveButton)) save_action.setStatusTip("Save project") save_action.setEnabled(False) save_action.triggered.connect(lambda: env.save()) project_menu.addAction(save_action) toolbar.addAction(save_action) save_as_action = QAction("Save &As...", self) save_as_action.setStatusTip("Save project under a new name") save_as_action.triggered.connect(lambda: env.save_as()) project_menu.addAction(save_as_action) quit_action = QAction("&Quit", self) quit_action.setShortcut("Ctrl+Q") quit_action.setStatusTip("Quit Hildegard") quit_action.triggered.connect(self.handle_quit) project_menu.addAction(quit_action) self.tabs = QTabWidget() self.tabs.setTabsClosable(True) self.tabs.tabCloseRequested.connect( lambda index: env.close(self.tabs.widget(index).entity, quit=True)) self.tabs.currentChanged.connect(self._handle_switch_to_tab) self.setCentralWidget(self.tabs) self.statusBar()
def _add_plugins_menu(self): """Add 'Plugins' menu to app menubar.""" self.plugins_menu = self.main_menu.addMenu('&Plugins') pip_install_action = QAction("Install/Uninstall Package(s)...", self._qt_window) pip_install_action.triggered.connect(self._show_plugin_install_dialog) self.plugins_menu.addAction(pip_install_action) order_plugin_action = QAction("Plugin Call Order...", self._qt_window) order_plugin_action.setStatusTip('Change call order for plugins') order_plugin_action.triggered.connect(self._show_plugin_sorter) self.plugins_menu.addAction(order_plugin_action) report_plugin_action = QAction("Plugin Errors...", self._qt_window) report_plugin_action.setStatusTip( 'Review stack traces for plugin exceptions and notify developers') report_plugin_action.triggered.connect(self._show_plugin_err_reporter) self.plugins_menu.addAction(report_plugin_action) self._plugin_dock_widget_menu = QMenu('Add Dock Widget', self._qt_window) # Get names of all plugins providing dock widgets or functions plugin_widgets = chain(plugins.dock_widgets, plugins.function_widgets) plugin_counts = Counter(plug_name for plug_name, _ in plugin_widgets) # Add submenu for each plugin with more than 1 item for plugin_name, count in plugin_counts.items(): if count > 1: menu = QMenu(plugin_name, self._qt_window) self._plugin_menus[plugin_name] = menu self._plugin_dock_widget_menu.addMenu(menu) # Add a menu item (QAction) for each available plugin widget docks = zip(repeat("dock"), plugins.dock_widgets) funcs = zip(repeat("func"), plugins.function_widgets) for hook_type, key in chain(docks, funcs): plugin_name, wdg_name = key if plugin_name in self._plugin_menus: # this plugin has a submenu. action = QAction(wdg_name, parent=self._qt_window) self._plugin_menus[plugin_name].addAction(action) else: # this plugin only has one widget, add a namespaced menu item full_name = plugins.menu_item_template.format(*key) action = QAction(full_name, parent=self._qt_window) self._plugin_dock_widget_menu.addAction(action) def _add_widget(*args, key=key, hook_type=hook_type): if hook_type == 'dock': self._add_plugin_dock_widget(key) else: self._add_plugin_function_widget(key) action.triggered.connect(_add_widget) self.plugins_menu.addMenu(self._plugin_dock_widget_menu)
def customMenuRequested(self, position): """Builds a custom menu for items items""" index = self.indexAt(position) # type: QModelIndex menu = QMenu(self) if index.isValid(): if index.data(EnsembleModel.data_type_role ) == WorkspaceDataType.Ensemble: # Allow renaming the ensemble via the context menu rename_action = QAction("Rename Collection", menu) rename_action.triggered.connect(self._rename_action) menu.addAction(rename_action) # Allow toggling the active ensemble via the context menu # * there can only be at most 1 active ensemble # * there are only 0 active ensembles when data has not yet been loaded ??? # * opening data updates the active ensemble to that data is_active = index.data(EnsembleModel.active_role) active_text = "Active" toggle_active_action = QAction(active_text, menu) toggle_active_action.setCheckable(True) if is_active is True: toggle_active_action.setChecked(True) else: toggle_active_action.setChecked(False) toggle_active_action.setText(f"Not {active_text}") # Make sure to update the model with the active / deactivated ensemble toggle_active_action.toggled.connect(self._set_active_action) # Don't allow deactivating the active ensemble if there is only one loaded if self.model().rowCount() == 1: toggle_active_action.setEnabled(False) menu.addAction(toggle_active_action) menu.addSeparator() remove_text = "Remove " data_type_role = index.data(EnsembleModel.data_type_role) if data_type_role == WorkspaceDataType.Ensemble: remove_text += "Ensemble" elif data_type_role == WorkspaceDataType.Catalog: remove_text += "Catalog" elif data_type_role == WorkspaceDataType.Intent: remove_text += "Item" remove_action = QAction(remove_text, menu) remove_action.triggered.connect(self._remove_action) menu.addAction(remove_action) else: create_ensemble_action = QAction("Create New Collection", menu) create_ensemble_action.triggered.connect( self._create_ensemble_action) menu.addAction(create_ensemble_action) # Display menu wherever the user right-clicked menu.popup(self.viewport().mapToGlobal(position))
def __init__(self, parent=None): super(QTiffStackPlayer, self).__init__(parent) self.setWindowTitle('Tiff Stack Player') self.videoviewer = QTiffStackView() #self.videoviewer.setSizePolicy(QSizePolicy.MinimumExpanding,QSizePolicy.MinimumExpanding) #backend model (conforming to MVC design pattern) self.model = QTiffStackModel() #as controller this class contains the video index self.index = 0 self.counterconnected = False #Create new action openAction = QAction('&Open', self) openAction.setShortcut('Ctrl+O') openAction.setStatusTip('Open movie') openAction.triggered.connect(self.openFile) #Create exit action exitAction = QAction('&Exit', self) exitAction.setShortcut('Ctrl+Q') exitAction.setStatusTip('Exit application') exitAction.triggered.connect(self.exitCall) #Create menu bar and add action #QMainWindow has a default Menu Bar attribute accessible by calling self.menuBar() menuBar = self.menuBar() fileMenu = menuBar.addMenu('&File') fileMenu.addAction(openAction) fileMenu.addAction(exitAction) #add an error label errorLabel = QLabel() #This function call below sets the policy determining how the error label may be shrunk and expanded by the parent window. Syntax is 'QWidget.setSizePolicy (self, QSizePolicy.Policy hor, QSizePolicy.Policy ver)' errorLabel.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum) layout = QVBoxLayout() self.setCentralWidget(self.videoviewer) #connect the signals from the viewer to the slots on the controller. self.videoviewer.frametimer.timeout.connect(self.getFrame) self.videoviewer.frametimer.timeout.connect(self.updateCounter) self.videoviewer.slideBar.valueChanged.connect(self.sliderChanged) self.videoviewer.slideBar.valueChanged.connect(self.updateCounter) self.videoviewer.play.clicked.connect(self.whenButtonPressed) self.videoviewer.counter.valueChanged.connect(self.counterChanged) self.counterconnected = True self.show()
def _GM_Family_t(self, m, node): a = QAction('Select references to myself', self) a.triggered.connect(functools.partial(self._gm_family_1, node)) m.addAction(a) a = QAction('Select all families', self) a.triggered.connect(functools.partial(self._gm_family_2, node)) m.addAction(a) m.addSeparator() return True
def _create_actions(self): self._act_check_all = QAction("Check All", self) self._act_check_all.triggered.connect(self.check_all) self._act_uncheck_all = QAction("Uncheck All", self) self._act_uncheck_all.triggered.connect(self.uncheck_all) self._act_expand_all = QAction("Expand All", self) self._act_expand_all.triggered.connect(self.expand_all) self._act_collapse_all = QAction("Collapse All", self) self._act_collapse_all.triggered.connect(self.collapse_all)
def _createActions(self): self.openPISettingsAction = QAction(self) self.openPISettingsAction.setText("Open PI settings") self.openSweepSettingsAction = QAction(self) self.openSweepSettingsAction.setText("Open sweep settings") self.openRelockSettingsAction = QAction(self) self.openRelockSettingsAction.setText("Open relock settings") self.openIOSettingsAction = QAction(self) self.openIOSettingsAction.setText("Open IO settings")
def __init__(self, *args, **kwargs): super(MOSViewerToolbar, self).__init__(*args, **kwargs) self.setToolButtonStyle(Qt.ToolButtonTextUnderIcon) # Define the toolbar actions self.cycle_previous_action = QAction( QIcon(os.path.join(ICON_DIR, "Previous-96.png")), "Previous", self) self.cycle_next_action = QAction( QIcon(os.path.join(ICON_DIR, "Next-96.png")), "Next", self) # Include the dropdown widget self.source_select = QComboBox() # Add the items to the toolbar self.addAction(self.cycle_previous_action) self.addAction(self.cycle_next_action) self.addWidget(self.source_select) # Include a button to open spectrum in specviz self.open_specviz = QAction( QIcon(os.path.join(ICON_DIR, "External-96.png")), "Open in SpecViz", self) # Create a tool button to hold the lock axes menu object tool_button = QToolButton(self) tool_button.setText("Axes Settings") tool_button.setIcon(QIcon(os.path.join(ICON_DIR, "Settings-96.png"))) tool_button.setPopupMode(QToolButton.MenuButtonPopup) tool_button.setToolButtonStyle(Qt.ToolButtonTextUnderIcon) # Create a menu for the axes settings drop down self.settings_menu = QMenu(self) # Add lock x axis action self.lock_x_action = QAction("Lock spectral axis", self.settings_menu) self.lock_x_action.setCheckable(True) # Add lock y axis action self.lock_y_action = QAction("Lock vertical displacement axis", self.settings_menu) self.lock_y_action.setCheckable(True) # Add the actions to the menu self.settings_menu.addAction(self.lock_x_action) self.settings_menu.addAction(self.lock_y_action) # Set the menu object on the tool button tool_button.setMenu(self.settings_menu) # Create a widget action object to hold the tool button, this way the # toolbar behaves the way it's expected to tool_button_action = QWidgetAction(self) tool_button_action.setDefaultWidget(tool_button) self.addAction(tool_button_action) self.addSeparator() self.addAction(self.open_specviz)
def __init__(self, *args, menuBar, **kwargs): super().__init__(*args, **kwargs) self._run_to_tabs = collections.defaultdict(list) self._title_to_tab = {} self._tabs_from_streaming = [] self._overplot = OverPlotState.individual_tab self._overplot_target = None self._live_enabled = False self._live_run_router = RunRouter([self.route_live_stream]) self._containers = [TabbedViewingArea(self, menuBar=menuBar) for _ in range(2)] layout = QVBoxLayout() for container in self._containers: layout.addWidget(container) self.setLayout(layout) overplot_group = QActionGroup(self) self.off = QAction('&Off', self) self.off.setStatusTip('Drop streaming data.') self.individual_tab = QAction('&New Tab', self) self.individual_tab.setStatusTip('Open a new viewer tab for each Run.') self.latest_live = QAction('&Latest Live Tab', self) self.latest_live.setStatusTip('Attempt to overplot on the most recent live Run.') self.fixed = QAction('&Fixed Tab...', self) self.fixed.setStatusTip('Attempt to overplot on a specific tab.') self.fixed.setEnabled(False) overplot_group.addAction(self.off) overplot_group.addAction(self.individual_tab) overplot_group.addAction(self.latest_live) overplot_group.addAction(self.fixed) for action in overplot_group.actions(): action.setCheckable(True) overplot_group.setExclusive(True) self.off.setChecked(True) overplot_menu = menuBar().addMenu('&Streaming') overplot_menu.addActions(overplot_group.actions()) self.off.triggered.connect(self.disable_live) self.individual_tab.triggered.connect(partial(self.set_overplot_state, OverPlotState.individual_tab)) self.latest_live.triggered.connect(partial(self.set_overplot_state, OverPlotState.latest_live)) def set_overplot_target(): item, ok = QInputDialog.getItem( self, "Select Tab", "Tab", tuple(self._title_to_tab), 0, False) if not ok: # Abort and fallback to Off. Would be better to fall back to # previous state (which could be latest_live) but it's not # clear how to know what that state was. self.off.setChecked(True) return self.set_overplot_state(OverPlotState.fixed) self._overplot_target = item self.fixed.triggered.connect(set_overplot_target)
def create_actions(self): # Actions self.actions = { 'Connect': QAction("Connect", self), 'Quit': QAction("Quit", self), 'AddPlot': QAction("Add Plot", self) } self.actions['Connect'].triggered.connect(self.on_action_connect_triggered) self.actions['Quit'].triggered.connect(qApp.quit) self.actions['AddPlot'].triggered.connect(self.on_action_add_plot_triggered)
def __init__(self, parent, widthSpace=10): super().__init__() self.parent = parent self.widthSpace = widthSpace self.dateFmt = "%d %b %Y" self.headerLabels = [ 'Date', 'Time', 'Distance (km)', 'Avg. speed\n(km/h)', 'Calories', 'Gear' ] self.setHeaderLabels(self.headerLabels) self.header().setStretchLastSection(False) # make header tall enough for two rows of text (avg speed has line break) font = self.header().font() metrics = QFontMetrics(font) height = metrics.height() self.header().setMinimumHeight(height * 2) # align header text centrally for idx in range(len(self.headerLabels)): self.headerItem().setTextAlignment(idx, Qt.AlignCenter) self.setSelectionMode(QAbstractItemView.ExtendedSelection) self.makeTree() self.sortColumn = None self.sortDescending = [True for _ in range(len(self.headerLabels))] self.header().setSectionsClickable(True) self.header().sectionClicked.connect(self.sortTree) self.currentItemChanged.connect(self._itemChanged) self.itemSelectionChanged.connect(self._summariseSelected) self.sortTree(0) msg = "Browse all sessions, grouped by month. Click on the headers \n" msg += "to sort by that metric in ascending or descending order.\n" msg += "Click on a session to highlight it in the plot." self.setToolTip(msg) self.editAction = QAction("Edit") self.editAction.setShortcut(QKeySequence("Ctrl+E")) self.editAction.triggered.connect(self._editItems) self.addAction(self.editAction) self.mergeAction = QAction("Merge") self.mergeAction.setShortcut(QKeySequence("Ctrl+M")) self.mergeAction.triggered.connect(self.combineRows) self.addAction(self.mergeAction) self.setContextMenuPolicy(Qt.CustomContextMenu) self.customContextMenuRequested.connect(self._showContextMenu)
def _add_plugins_menu(self): """Add 'Plugins' menu to app menubar.""" self.plugins_menu = self.main_menu.addMenu('&Plugins') pip_install_action = QAction("Install/Uninstall Package(s)...", self._qt_window) pip_install_action.triggered.connect(self._show_plugin_install_dialog) self.plugins_menu.addAction(pip_install_action) order_plugin_action = QAction("Plugin Call Order...", self._qt_window) order_plugin_action.setStatusTip('Change call order for plugins') order_plugin_action.triggered.connect(self._show_plugin_sorter) self.plugins_menu.addAction(order_plugin_action) report_plugin_action = QAction("Plugin Errors...", self._qt_window) report_plugin_action.setStatusTip( 'Review stack traces for plugin exceptions and notify developers') report_plugin_action.triggered.connect(self._show_plugin_err_reporter) self.plugins_menu.addAction(report_plugin_action) self._plugin_dock_widget_menu = QMenu('Add Dock Widget', self._qt_window) if not plugins.dock_widgets: plugins.discover_dock_widgets() # Add a menu item (QAction) for each available plugin widget docks = zip(repeat("dock"), plugins.dock_widgets.items()) funcs = zip(repeat("func"), plugins.function_widgets.items()) for hook_type, (plugin_name, widgets) in chain(docks, funcs): multiprovider = len(widgets) > 1 if multiprovider: menu = QMenu(plugin_name, self._qt_window) self._plugin_dock_widget_menu.addMenu(menu) else: menu = self._plugin_dock_widget_menu for wdg_name in widgets: key = (plugin_name, wdg_name) if multiprovider: action = QAction(wdg_name, parent=self._qt_window) else: full_name = plugins.menu_item_template.format(*key) action = QAction(full_name, parent=self._qt_window) def _add_widget(*args, key=key, hook_type=hook_type): if hook_type == 'dock': self.add_plugin_dock_widget(*key) else: self._add_plugin_function_widget(*key) menu.addAction(action) action.triggered.connect(_add_widget) self.plugins_menu.addMenu(self._plugin_dock_widget_menu)
def _GM_IndexRange_t(self, m, node): if (node.sidsName() != CGK.ElementRange_s): v = 0 a = QAction('Range size: %d' % (v), self) m.addAction(a) else: v = node.sidsValue()[1] - node.sidsValue()[0] etp = CGU.getEnumAsString(node.sidsParent()) a = QAction('Number of elements of type [%s]: %d' % (etp, v), self) m.addAction(a) return True
def on_mouse_press_event(self, event): """ Event handling for mouse press action Args: event: Returns: """ # get the button and position information. curr_x = event.xdata curr_y = event.ydata if curr_x is None or curr_y is None: # outside of canvas return button = event.button if button == 1: # left button: no operation pass elif button == 3: # right button: # Pop-out menu self.menu = QMenu(self) if self.get_canvas().is_legend_on: # figure has legend: remove legend action1 = QAction('Hide legend', self) action1.triggered.connect(self._myCanvas.hide_legend) action2 = QAction('Legend font larger', self) action2.triggered.connect( self._myCanvas.increase_legend_font_size) action3 = QAction('Legend font smaller', self) action3.triggered.connect( self._myCanvas.decrease_legend_font_size) self.menu.addAction(action2) self.menu.addAction(action3) else: # figure does not have legend: add legend action1 = QAction('Show legend', self) action1.triggered.connect(self._myCanvas.show_legend) self.menu.addAction(action1) # pop up menu self.menu.popup(QCursor.pos()) # END-IF-ELSE return