def show_original_size(self): action = QAction(self.app.ui.show_original_size_icon, "Original Size") action.setToolTip("Original Size") action.setStatusTip("Show original image size, Shortcuts : Shift+Left") action.setShortcuts(["Shift+Left"]) action.setCheckable(True) return action
def slideshow(self): action = QAction(self.app.ui.slideshow_icon, "Slide Show") action.setToolTip("Slide Show") action.setStatusTip("Play slideshow, Shortcuts : Alt+Return, F11") action.setShortcuts(["Alt+Return", "F11"]) action.setCheckable(True) return action
def fit_to_height(self): action = QAction(self.app.ui.fit_to_height_icon, "Fit to height") action.setToolTip("Fit to height") action.setStatusTip("Fit image to window height, Shortcuts : Shift+Up") action.setShortcuts(["Shift+Up"]) action.setCheckable(True) return action
def _init_toolbar(self): a = QAction(getIcon('color-wheel'), 'Color bar', self) a.setToolTip('Add color bar') a.setCheckable(True) a.triggered.connect(self.colorbar) self._actions['colorbar'] = a self.insertAction(self._actions['configure_subplots'], a)
def _init_toolbar(self): a = QAction(getIcon('snap'), 'Snap', self) a.setCheckable(True) a.setToolTip('Snap to data') a.triggered.connect(self.snap) self._actions['snap'] = a self.insertAction(self._actions['pan'], a)
def _cfg_action( self, menu, title, setting, icon=None, shortcut=None ): action = QAction(title, self) if icon: action.setIcon(self._ide.theme.qicon(icon)) if shortcut: action.setShortcut(shortcut) action.setToolTip( u'{} ({})'.format(title.replace(u'&', u''), shortcut) ) def change_setting(value): self._ide.extension_manager.fire( 'setting_changed', setting=setting, value=value ) action.triggered.connect(change_setting) action.setCheckable(True) action.setChecked(cfg[setting]) action.setPriority(QAction.HighPriority) menu.addAction(action) self._cfg_actions[setting] = action return action
class Tool(object): def __init__( self, name, help_link="", icon=None, enabled=True, checkable=False, popup_menu=False, ): super(Tool, self).__init__() self.__icon = icon self.__name = name self.__parent = None self.__enabled = enabled self.__checkable = checkable self.__help_link = help_link self.__is_popup_menu = popup_menu self.__action = QAction(self.getIcon(), self.getName(), None) self.__action.setIconText(self.getName()) self.__action.setEnabled(self.isEnabled()) self.__action.setCheckable(checkable) self.__action.triggered.connect(self.trigger) HelpCenter.addHelpToAction(self.__action, self.getHelpLink()) def getIcon(self): return self.__icon def getName(self): return self.__name def trigger(self): raise NotImplementedError() def setParent(self, parent): self.__parent = parent self.__action.setParent(parent) def parent(self): return self.__parent def isEnabled(self): return self.__enabled def getHelpLink(self): return self.__help_link def getAction(self): return self.__action def setVisible(self, visible): self.__action.setVisible(visible) def setEnabled(self, enabled): self.__action.setEnabled(enabled) def isPopupMenu(self): return self.__is_popup_menu
def _init_toolbar(self): a = QAction(getIcon('ruler'), 'Scale bar', self) a.setToolTip('Add scale bar') a.setCheckable(True) a.triggered.connect(self.scalebar) self._actions['scalebar'] = a self.insertAction(self._actions['configure_subplots'], a)
def create_action(parent, text, shortcut=None, icon=None, tip=None, toggled=None, triggered=None, data=None, menurole=None, context=Qt.WindowShortcut): """Create a QAction.""" action = QAction(text, parent) if triggered is not None: action.triggered.connect(triggered) if toggled is not None: action.toggled.connect(toggled) action.setCheckable(True) if icon is not None: action.setIcon(icon) if shortcut is not None: action.setShortcut(shortcut) if tip is not None: action.setToolTip(tip) action.setStatusTip(tip) if data is not None: action.setData(to_qvariant(data)) if menurole is not None: action.setMenuRole(menurole) # TODO: Hard-code all shortcuts and choose context=Qt.WidgetShortcut # (this will avoid calling shortcuts from another dockwidget # since the context thing doesn't work quite well with these widgets) action.setShortcutContext(context) return action
def create_action(parent, text, shortcut=None, icon=None, tip=None, toggled=None, triggered=None, data=None, menurole=None, context=Qt.WindowShortcut): """Create a QAction""" action = QAction(text, parent) if triggered is not None: action.triggered.connect(triggered) if toggled is not None: action.toggled.connect(toggled) action.setCheckable(True) if icon is not None: if is_text_string(icon): icon = get_icon(icon) action.setIcon(icon) if shortcut is not None: action.setShortcut(shortcut) if tip is not None: action.setToolTip(tip) action.setStatusTip(tip) if data is not None: action.setData(to_qvariant(data)) if menurole is not None: action.setMenuRole(menurole) #TODO: Hard-code all shortcuts and choose context=Qt.WidgetShortcut # (this will avoid calling shortcuts from another dockwidget # since the context thing doesn't work quite well with these widgets) action.setShortcutContext(context) return action
def fit_to_window(self): action = QAction(self.app.ui.fit_to_window_icon, "Fit to window") action.setToolTip("Fit to window") action.setStatusTip("Fit image to window size, Shortcuts : Shift+Down") action.setShortcuts(["Shift+Down"]) action.setCheckable(True) return action
def show_statusbar(self): action = QAction(self.app.ui.statusbar_icon, "Show Statusbar") action.setToolTip("Show Statusbar") action.setToolTip("Show Statusbar, Shortcuts : Ctrl+.") action.setShortcuts(["Ctrl+."]) action.setCheckable(True) return action
def fit_to_width(self): action = QAction(self.app.ui.fit_to_width_icon, "Fit to width") action.setToolTip("Fit to width") action.setStatusTip( "Fit image to window width, Shortcuts : Shift+Right") action.setShortcuts(["Shift+Right"]) action.setCheckable(True) return action
class MOSViewerToolbar(BasicToolbar): 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, parent=None, standalone=False): super(Camera, self).__init__(parent) # This prevents doing unneeded initialization # when QtDesginer loads the plugin. if parent is None and not standalone: return if not multimedia_available: return self.ui = uic.loadUi(os.path.join(WIDGET_PATH, "camera.ui"), self) self.camera = None self.imageCapture = None self.mediaRecorder = None self.isCapturingImage = False self.applicationExiting = False self.imageSettings = QImageEncoderSettings() self.audioSettings = QAudioEncoderSettings() self.videoSettings = QVideoEncoderSettings() self.videoContainerFormat = '' camera_device = QByteArray() videoDevicesGroup = QActionGroup(self) videoDevicesGroup.setExclusive(True) if not QCamera.availableDevices(): self.ui.devicesCombo.addItem("No Device") else: for deviceName in QCamera.availableDevices(): description = QCamera.deviceDescription(deviceName) self.ui.devicesCombo.addItem(description) videoDeviceAction = QAction(description, videoDevicesGroup) videoDeviceAction.setCheckable(True) videoDeviceAction.setData(deviceName) if camera_device.isEmpty(): cameraDevice = deviceName videoDeviceAction.setChecked(True) self.ui.devicesCombo.addAction(videoDeviceAction) videoDevicesGroup.triggered.connect(self.updateCameraDevice) self.ui.captureWidget.currentChanged.connect(self.updateCaptureMode) self.ui.devicesCombo.currentIndexChanged.connect(self.get_device_action) self.ui.lockButton.hide() if not IN_DESIGNER: # Start camera 2s after the UI has loaded QTimer.singleShot(2000, lambda: self.setCamera(camera_device))
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_menu_buttons(self): """ Add the two menu buttons to the tool bar. Currently two are defined: View - for changing the view of the active window Data Processing - for applying a data processing step to the data. :return: """ self._option_buttons = [ self.ui.view_option_button, self.ui.cube_option_button ] # Create the View Menu view_menu = self._dict_to_menu( OrderedDict([ ('Hide Axes', ['checkable', self._toggle_viewer_axes]), ('Hide Toolbars', ['checkable', self._toggle_toolbars]), ('Hide Spaxel Value Tooltip', ['checkable', self._toggle_hover_value]), ('Hide Stats', ['checkable', self._toggle_stats_display]), ('Convert Flux Units', lambda: self._open_dialog('Convert Flux Units', None)), ('Wavelength Units/Redshift', lambda: self._open_dialog('Wavelength Units/Redshift', None)) ])) # Add toggle RA-DEC format: format_menu = view_menu.addMenu("RA-DEC Format") format_action_group = QActionGroup(format_menu) self.ra_dec_format_menu = format_menu # Make sure to change all instances of the the names # of the formats if modifications are made to them. for format_name in ["Sexagesimal", "Decimal Degrees"]: act = QAction(format_name, format_menu) act.triggered.connect(self._toggle_all_coords_in_degrees) act.setActionGroup(format_action_group) act.setCheckable(True) act.setChecked( True) if format == "Sexagesimal" else act.setChecked(False) format_menu.addAction(act) self.ui.view_option_button.setMenu(view_menu) # Create the Data Processing Menu cube_menu = self._dict_to_menu( OrderedDict([ ('Collapse Cube', lambda: self._open_dialog('Collapse Cube', None)), ('Spatial Smoothing', lambda: self._open_dialog('Spatial Smoothing', None)), ('Moment Maps', lambda: self._open_dialog('Moment Maps', None)), ('Arithmetic Operations', lambda: self._open_dialog('Arithmetic Operations', None)) ])) self.ui.cube_option_button.setMenu(cube_menu)
def _init_menu_buttons(self): """ Add the two menu buttons to the tool bar. Currently two are defined: View - for changing the view of the active window Data Processing - for applying a data processing step to the data. :return: """ self._option_buttons = [ self.ui.view_option_button, self.ui.cube_option_button ] # Create the View Menu view_menu = self._dict_to_menu(OrderedDict([ ('Hide Axes', ['checkable', self._toggle_viewer_axes]), ('Hide Toolbars', ['checkable', self._toggle_toolbars]), ('Hide Spaxel Value Tooltip', ['checkable', self._toggle_hover_value]), ('Hide Stats', ['checkable', self._toggle_stats_display]), ('Flux Units', OrderedDict([ ('Convert Displayed Units', lambda: self._open_dialog('Convert Displayed Units', None)), ('Convert Data Values', lambda: self._open_dialog('Convert Data Values', None)), ]) ), ('Wavelength Units/Redshift', lambda: self._open_dialog('Wavelength Units/Redshift', None)) ])) # Add toggle RA-DEC format: format_menu = view_menu.addMenu("RA-DEC Format") format_action_group = QActionGroup(format_menu) self.ra_dec_format_menu = format_menu # Make sure to change all instances of the the names # of the formats if modifications are made to them. for format_name in ["Sexagesimal", "Decimal Degrees"]: act = QAction(format_name, format_menu) act.triggered.connect(self._toggle_all_coords_in_degrees) act.setActionGroup(format_action_group) act.setCheckable(True) act.setChecked(True) if format == "Sexagesimal" else act.setChecked(False) format_menu.addAction(act) self.ui.view_option_button.setMenu(view_menu) # Create the Data Processing Menu cube_menu = self._dict_to_menu(OrderedDict([ ('Collapse Cube', lambda: self._open_dialog('Collapse Cube', None)), ('Spatial Smoothing', lambda: self._open_dialog('Spatial Smoothing', None)), ('Moment Maps', lambda: self._open_dialog('Moment Maps', None)), ('Arithmetic Operations', lambda: self._open_dialog('Arithmetic Operations', None)) ])) self.ui.cube_option_button.setMenu(cube_menu)
def create_action(parent, text, shortcut=None, icon=None, tip=None, toggled=None, triggered=None, data=None, menurole=None, context=Qt.WindowShortcut): """Create a QAction""" action = QAction(text, parent) if triggered is not None: action.triggered.connect(triggered) if toggled is not None: action.toggled.connect(toggled) action.setCheckable(True) if icon is not None: if is_text_string(icon): icon = get_icon(icon) action.setIcon(icon) if tip is not None: action.setToolTip(tip) action.setStatusTip(tip) if data is not None: action.setData(to_qvariant(data)) if menurole is not None: action.setMenuRole(menurole) # Workround for Mac because setting context=Qt.WidgetShortcut # there doesn't have any effect if sys.platform == 'darwin': action._shown_shortcut = None if context == Qt.WidgetShortcut: if shortcut is not None: action._shown_shortcut = shortcut else: # This is going to be filled by # main.register_shortcut action._shown_shortcut = 'missing' else: if shortcut is not None: action.setShortcut(shortcut) action.setShortcutContext(context) else: if shortcut is not None: action.setShortcut(shortcut) action.setShortcutContext(context) return action
class Viewer(ViewerModel): """ This extends the model by attaching a Qt Window as its view. This object is meant to be exposed to the user in an interactive console. """ def __init__(self, *, show=True, title="Demo App"): # TODO Where does title thread through? super().__init__() self._widget = QtViewer(self) self._window = Window(self._widget, show=show) menu_bar = self._window._qt_window.menuBar() menu_item_control = menu_bar.addMenu("Control Actions") self.action_activate_env_destroy = QAction( "Activate 'Destroy Environment'", self._window._qt_window) self.action_activate_env_destroy.setCheckable(True) self._update_action_env_destroy_state() self.action_activate_env_destroy.triggered.connect( self._activate_env_destroy_triggered) menu_item_control.addAction(self.action_activate_env_destroy) self._widget.model.run_engine.events.status_changed.connect( self.on_update_widgets) def _update_action_env_destroy_state(self): env_destroy_activated = self._widget.model.run_engine.env_destroy_activated self.action_activate_env_destroy.setChecked(env_destroy_activated) def _activate_env_destroy_triggered(self): env_destroy_activated = self._widget.model.run_engine.env_destroy_activated self._widget.model.run_engine.activate_env_destroy( not env_destroy_activated) def on_update_widgets(self, event): self._update_action_env_destroy_state() @property def window(self): return self._window def show(self): """Resize, show, and raise the window.""" self._window.show() def close(self): """Close the window.""" self._window.close()
def __init__(self, entity, env): d = Diagram_Item(entity) d.modified_callback = self.set_modified super().__init__(d) self.modified_callback = env.set_modified self.entity = entity show_ports_action = QAction("Connection Ports", self) self._show_ports_action = show_ports_action show_ports_action.setStatusTip("Show connection ports when hovering") show_ports_action.setCheckable(True) show_ports_action.setChecked(False) show_ports_action.setIcon(QIcon.fromTheme("edit-find")) show_ports_action.triggered.connect( lambda x: d.set_show_connection_ports_on_hover(x)) self.view_menu.addAction(show_ports_action) self.tools.append(show_ports_action)
def _add_plugin_actions(self, hook_type: str, plugin_name: str, widgets: Sequence[str]): from ...plugins import menu_item_template multiprovider = len(widgets) > 1 if multiprovider: menu = NapariMenu(plugin_name, self) self.addMenu(menu) else: menu = self for wdg_name in widgets: key = (plugin_name, wdg_name) if multiprovider: action = QAction(wdg_name.replace("&", "&&"), parent=self) else: full_name = menu_item_template.format(*key) action = QAction(full_name.replace("&", "&&"), parent=self) def _add_toggle_widget(*, key=key, hook_type=hook_type): full_name = menu_item_template.format(*key) if full_name in self._win._dock_widgets.keys(): dock_widget = self._win._dock_widgets[full_name] if dock_widget.isVisible(): dock_widget.hide() else: dock_widget.show() return if hook_type == 'dock': dock_widget, _w = self._win.add_plugin_dock_widget(*key) else: dock_widget = self._win._add_plugin_function_widget(*key) # Fixes https://github.com/napari/napari/issues/3624 dock_widget.setFloating(True) dock_widget.setFloating(False) action.setCheckable(True) # check that this wasn't added to the menu already actions = [a.text() for a in menu.actions()] if action.text() not in actions: menu.addAction(action) action.triggered.connect(_add_toggle_widget)
def _dict_to_menu(self, menu_dict): '''Stolen shamelessly from specviz. Thanks!''' menu_widget = QMenu() for k, v in menu_dict.items(): if isinstance(v, dict): new_menu = menu_widget.addMenu(k) self._dict_to_menu(v, menu_widget=new_menu) else: act = QAction(k, menu_widget) if isinstance(v, list): if v[0] == 'checkable': v = v[1] act.setCheckable(True) act.setChecked(True) act.triggered.connect(v) menu_widget.addAction(act) return menu_widget
def dict_to_menu(parent, menu_dict, menu_widget=None): if not menu_widget: menu_widget = QMenu(parent) for k, v in menu_dict.items(): if isinstance(v, dict): new_menu = menu_widget.addMenu(k) dict_to_menu(v, menu_widget=new_menu) else: act = QAction(k, menu_widget) if isinstance(v, list): if v[0] == 'checkable': v = v[1] act.setCheckable(True) act.setChecked(False) act.triggered.connect(v) menu_widget.addAction(act) return menu_widget
def _dict_to_menu(self, menu_dict, menu_widget=None): '''Stolen shamelessly from specviz. Thanks!''' if not menu_widget: menu_widget = QMenu() for k, v in menu_dict.items(): if isinstance(v, dict): new_menu = menu_widget.addMenu(k) self._dict_to_menu(v, menu_widget=new_menu) else: act = QAction(k, menu_widget) if isinstance(v, list): if v[0] == 'checkable': v = v[1] act.setCheckable(True) act.setChecked(False) act.triggered.connect(v) menu_widget.addAction(act) return menu_widget
def makeAction(parent, descr, menutext, slot, icon=None, key=None, checkable=False): a = QAction(parent) a.setText(menutext) a.setStatusTip(descr) a.setToolTip(textwrap.fill(descr, 25)) if slot: a.triggered.connect(slot) if icon: a.setIcon(getIcon(icon)) if key: a.setShortcut(QKeySequence(key)) if checkable: a.setCheckable(True) return a
class MainWindowMenu(QMenu): def __init__(self, parent): super(MainWindowMenu, self).__init__(parent) self.setTitle("QtPyBotnet") self.console_action = QAction('Show console', self) self.console_action.setObjectName("show_console") self.addAction(self.console_action) self.stay_top_action = QAction("Stay on top", self) self.stay_top_action.setObjectName("stay_top_action") self.stay_top_action.setCheckable(True) self.stay_top_action.setChecked( bool(self.window().windowFlags() & Qt.WindowStaysOnTopHint)) self.addAction(self.stay_top_action) self.style_picker_action = QWidgetAction(self) self.style_picker = StylePickerHorizontal(self) self.style_picker_action.setDefaultWidget(self.style_picker) self.addAction(self.style_picker_action)
def _action(self, title, icon, shortcut, target, checkable=False, checked=False): action = QAction(title, self) if icon: action.setIcon(self._ide.theme.qicon(icon)) if shortcut: action.setShortcut(shortcut) action.setToolTip(u'{} ({})'.format(title.replace(u'&', u''), shortcut)) action.triggered.connect(target) if checkable: action.setCheckable(True) action.setChecked(checked) action.setPriority(QAction.HighPriority) return action
def addaction(name='', icon_name='', tip='', checkable=False, slot=None, toolbar=None, menu=None): """Create a new action and add it eventually to a toolbar and a menu Parameters ---------- name: (str) Displayed name if should be displayed (for instance in menus) icon_name: (str) png file name to produce the icon tip: (str) a tooltip to be displayed when hovering above the action checkable: (bool) set the checkable state of the action slot: (callable) Method or function that will be called when the action is triggered toolbar: (QToolBar) a toolbar where action should be added. menu: (QMenu) a menu where action should be added. """ if icon_name != '': icon = QtGui.QIcon() if Path(icon_name).is_file(): icon.addPixmap(QtGui.QPixmap(icon_name), QtGui.QIcon.Normal, QtGui.QIcon.Off) else: icon.addPixmap( QtGui.QPixmap(f":/icons/Icon_Library/{icon_name}.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off) action = QAction(icon, name, None) else: action = QAction(name) if slot is not None: action.connect_to(slot) action.setCheckable(checkable) action.setToolTip(tip) if toolbar is not None: toolbar.addAction(action) if menu is not None: menu.addAction(action) return action
def getContextMenus(self, event): if self._menu: return None menu = QMenu(parent=self.getViewWidget()) menu.setTitle("Slicing") if self.slice_direction != 'vertical': horizontal_action = QAction('Horizontal slice', menu) horizontal_action.toggled.connect(self.sigToggleHorizontalSlice) horizontal_action.setCheckable(True) menu.addAction(horizontal_action) if self.slice_direction != 'horizontal': vertical_action = QAction('Vertical slice', menu) vertical_action.toggled.connect(self.sigToggleVerticalSlice) vertical_action.setCheckable(True) menu.addAction(vertical_action) if self.slice_direction == 'depth': depth_action = QAction('Depth slice', menu) depth_action.toggled.connect(self.sigToggleDepthSlice) depth_action.setCheckable(True) menu.addAction(depth_action) make_primary_action = QAction('Set as Primary View', menu) make_primary_action.triggered.connect(self.makePrimary) menu.addAction(make_primary_action) self._menu = menu return menu
def generateContextMenu(self): """ Generate the window's context menu. This first calls the base class's context menu generator and then extends it with the filtering options. """ qmenu = super(MessageDisplay, self).generateContextMenu() filter_menu = qmenu.addMenu("&View") framework_action = QAction('Mantid Log Output', filter_menu) framework_action.triggered.connect(self.toggle_filter_framework_output) framework_action.setCheckable(True) framework_action.setChecked(self.showFrameworkOutput()) filter_menu.addAction(framework_action) filter_menu.addSeparator() actions_to_group = [] active_script_action = QAction("Active Tab Output", filter_menu) active_script_action.triggered.connect(self.show_active_script) actions_to_group.append(active_script_action) all_script_action = QAction('All Script Output', filter_menu) all_script_action.triggered.connect(self.show_all_scripts) actions_to_group.append(all_script_action) hide_all_script_action = QAction("Hide All Script Output", filter_menu) hide_all_script_action.triggered.connect(self.hide_all_scripts) actions_to_group.append(hide_all_script_action) action_group = QActionGroup(filter_menu) for action in actions_to_group: action_group.addAction(action) filter_menu.addAction(action) action.setCheckable(True) if self.showAllScriptOutput(): all_script_action.setChecked(True) elif self.showActiveScriptOutput(): active_script_action.setChecked(True) else: hide_all_script_action.setChecked(True) return qmenu
def create_action( parent, title, triggered=None, toggled=None, shortcut=None, icon=None, tip=None, checkable=None, context=Qt.WindowShortcut, enabled=None, ): """ Create a new QAction """ action = QAction(title, parent) if triggered: if checkable: action.triggered.connect(triggered) else: action.triggered.connect(lambda checked=False: triggered()) if checkable is not None: # Action may be checkable even if the toggled signal is not connected action.setCheckable(checkable) if toggled: action.toggled.connect(toggled) action.setCheckable(True) if icon is not None: assert isinstance(icon, QIcon) action.setIcon(icon) if shortcut is not None: action.setShortcut(shortcut) if tip is not None: action.setToolTip(tip) action.setStatusTip(tip) if enabled is not None: action.setEnabled(enabled) action.setShortcutContext(context) return action
def initUI(self): exitAct = QAction('&Exit', self) exitAct.setShortcut('Ctrl+Q') # 设置快捷键 exitAct.setStatusTip('Exit app') # 设置状态栏提醒 exitAct.triggered.connect(qApp.quit) # 子目录 impMenu = QMenu('import', self) subAct = QAction('test', self) impMenu.addAction(subAct) # check菜单 viewStatAct = QAction('View Statusbar', self) viewStatAct.setStatusTip('View statusbar') viewStatAct.setCheckable(True) # 开启打钩模式 viewStatAct.triggered.connect(self.toggleMenu) # toggleMenu会传入参数 # 状态栏 self.statusBar().showMessage('Ready') # 菜单栏 menuBar = self.menuBar() fileMenu = menuBar.addMenu('&File') fileMenu.addAction(exitAct) fileMenu.addMenu(impMenu) fileMenu.addAction(viewStatAct) self.resize(250, 150) self.center() self.setWindowTitle('Message box') self.show() # 工具栏(菜单栏某几个工具的快速使用) self.toolbar = self.addToolBar('Exti') self.toolbar.addAction(exitAct)
def initactions(self): self.clear() self.actions = [] for category in self.categories: if not category in self.panels.keys(): continue panels = self.panels[category] keys = sorted(panels.keys()) for panid in keys: if category == self.parent().category and panid == self.parent( ).panid: continue panel = panels[panid] action = QAction(panel.windowTitle()) action.setCheckable(True) action.setChecked((category, panel.panid) in self.panel.bindings) action.triggered.connect( FuncToPanel(self.func, category, panel.panid)) self.addAction(action) self.actions.append(action) self.addSeparator()
def _create_action(self, text, slot=None, shortcut=None, icon=None, tip=None, checkable=False, checked=False): """Convenience function to create actions""" action = QAction(text, self) if icon is not None: action.setIcon(QIcon(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: action.triggered.connect(slot) if checkable: action.setCheckable(True) if checked: action.setChecked(True) return action
def getMenuAction(self, menu, title='notitle', action_name='noaction', args=[], kwargs={}): # ToDo: Clean this up, it is very hacky env = {'app': QApplication.instance(), 'win': self, 'action': actions, } if action_name is not None: if action_name.startswith('settings.'): setting_id = action_name[len('settings.'):] setting = getSetting(setting_id) if setting: if setting.enum_options is not None: submenu = QMenu(parent=self, title=title) group = QActionGroup(self) group.setExclusive(True) group.triggered.connect(lambda a: setting.setValue(a.data())) def update(group, val): for act in group.actions(): if act.data() == val: act.setChecked(True) break for num, opt in enumerate(setting.enum_options): act = QAction(parent=self, text=opt) act.setCheckable(True) if setting.value == num: act.setChecked(True) act.setData(num) setting.notify(lambda v: update(group, v)) act.setActionGroup(group) submenu.addAction(act) menu.addMenu(submenu) elif setting.value_type == bool: # works for bool settings menu_action = QAction(parent=self, text=title) menu_action.setCheckable(True) menu_action.triggered.connect(setting.setValue) setting.notify(menu_action.setChecked) menu.addAction(menu_action) return try: menu_action = QAction(parent=self, text=title) mod, action = action_name.split('.', 1) method = getattr(env.get(mod, self), action) if menu_action.isCheckable(): menu_action.triggered.connect(method) else: menu_action.triggered.connect(lambda checked: method(*args, **kwargs)) menu.addAction(menu_action) return except: pass try: menu_action = QAction(parent=self, text=title) actions.bindWidget(menu_action, action_name) menu.addAction(menu_action) return except actions.InvalidAction: LOG.exception('Error binding menu action %s', action_name) menu_action = QAction(parent=self, text=title) msg = "The <b>{}</b> action specified for the " \ "<b>{}</b> menu item could not be triggered. " \ "Check the YAML config file for errors." \ .format(action_name or '', title.replace('&', '')) menu_action.triggered.connect(lambda: QMessageBox.critical(self, "Menu Action Error!", msg)) menu.addAction(menu_action)
class MOSViewerToolbar(BasicToolbar): def __init__(self, *args, **kwargs): super(MOSViewerToolbar, self).__init__(*args, **kwargs) # self.setToolButtonStyle(Qt.ToolButtonTextUnderIcon) # Define icon path icon_path = os.path.join(os.path.dirname(__file__), 'ui', 'icons') # Define the toolbar actions self.cycle_previous_action = QAction( QIcon(os.path.join(icon_path, "Previous-96.png")), "Previous", self) self.cycle_next_action = QAction( QIcon(os.path.join(icon_path, "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_path, "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_path, "Settings-96.png"))) tool_button.setPopupMode(QToolButton.MenuButtonPopup) # 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 X Axis", self.settings_menu) self.lock_x_action.setCheckable(True) # Add lock y axis action self.lock_y_action = QAction("Lock Y 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)