def openMenu(self,position): indexes = self.ui.treeWidget.selectedIndexes() item = self.ui.treeWidget.itemAt(position) db_origin = "" #if item.parent(): # db_origin = item.parent().text(0) collec = str(item.text(0).encode("utf-8")) if len(indexes) > 0: level = 0 index = indexes[0] while index.parent().isValid(): index = index.parent() level = level + 1 menu = QMenu() #print((collec, db_origin)) if level ==0: pass else: #keyarray = GetKeys(collec, db_origin) #if "Open" in keyarray: if self.ui.combobox.currentText()==u"K线": menu.addAction(QAction("Kline", menu, checkable=True)) menu.addAction(QAction("Open", menu, checkable=True)) menu.addAction(QAction("Close", menu, checkable=True))#open up different menu with different kind of graphs menu.addAction(QAction("High", menu, checkable=True)) menu.addAction(QAction("Low", menu, checkable=True)) menu.addAction(QAction("Volume", menu, checkable=True)) #menu.addAction(QAction("P_change", menu, checkable=True)) #menu.addAction(QAction("Turnover",menu,checkable=True)) if self.ui.combobox.currentText()==u"复权": menu.addAction(QAction("Kline", menu, checkable=True)) menu.addAction(QAction("Open", menu, checkable=True)) menu.addAction(QAction("Close", menu, checkable=True)) menu.addAction(QAction("High", menu, checkable=True)) menu.addAction(QAction("Low", menu, checkable=True)) menu.addAction(QAction("Volume", menu, checkable=True)) menu.addAction(QAction("Amount", menu, checkable=True)) if self.ui.combobox.currentText()==u"分笔数据": menu.addAction(QAction("分笔", menu, checkable=True)) #for g in keyarray: #menu.addAction(QAction(g, menu, checkable=True)) menu.triggered.connect(lambda action: self.methodSelected(action, collec)) menu.exec_(self.ui.treeWidget.viewport().mapToGlobal(position))
def __init__(self, parent: MainWindowBase) -> None: super(InputsWidget, self).__init__(parent) self.setupUi(self) # parent's function pointer self.free_move_button = parent.free_move_button self.entities_point = parent.entities_point self.entities_link = parent.entities_link self.vpoints = parent.vpoint_list self.vlinks = parent.vlink_list self.main_canvas = parent.main_canvas self.solve = parent.solve self.reload_canvas = parent.reload_canvas self.output_to = parent.output_to self.conflict = parent.conflict self.dof = parent.dof self.right_input = parent.right_input self.command_stack = parent.command_stack self.set_coords_as_current = parent.set_coords_as_current self.get_back_position = parent.get_back_position # Angle panel self.dial = QRotatableView(self) self.dial.setStatusTip("Input widget of rotatable joint.") self.dial.setEnabled(False) self.dial.value_changed.connect(self.__update_var) self.dial_spinbox.valueChanged.connect(self.__set_var) self.inputs_dial_layout.addWidget(self.dial) # Play button self.variable_stop.clicked.connect(self.variable_value_reset) # Timer for play button self.inputs_play_shaft = QTimer() self.inputs_play_shaft.setInterval(10) self.inputs_play_shaft.timeout.connect(self.__change_index) # Change the point coordinates with current position self.update_pos.clicked.connect(self.set_coords_as_current) # Inputs record context menu self.pop_menu_record_list = QMenu(self) self.record_list.customContextMenuRequested.connect( self.__record_list_context_menu) self.__path_data: Dict[str, _Paths] = {}
def __init__(self, parent, menu_actions=None): """Initialiaze ReportsWidget.""" QWidget.__init__(self, parent) self.renderviews = {} self.filenames = [] self.menu_actions = menu_actions self.setWindowTitle("Reports") self.tabs = BaseTabs(self, actions=self.menu_actions, menu_use_tooltips=False) self.tabs.setMovable(True) self.tabs.setTabsClosable(True) self.tabs.tabCloseRequested.connect(self.close_tab) self.tabs.tabBar().tabMoved.connect(self.move_tab) # Progress bar self.progress_bar = QWidget(self) self.status_text = QLabel(self.progress_bar) self.spinner = QWaitingSpinner(self.progress_bar, centerOnParent=False) self.spinner.setNumberOfLines(12) self.spinner.setInnerRadius(2) progress_layout = QHBoxLayout() progress_layout.addWidget(self.spinner) progress_layout.addWidget(self.status_text) self.progress_bar.setLayout(progress_layout) self.progress_bar.hide() # Menu as corner widget if self.menu_actions: options_button = create_toolbutton(self, text='Options', icon=ima.icon('tooloptions')) options_button.setPopupMode(QToolButton.InstantPopup) menu = QMenu(self) add_actions(menu, self.menu_actions) options_button.setMenu(menu) self.tabs.setCornerWidget(options_button) layout = QVBoxLayout() layout.addWidget(self.tabs) layout.addWidget(self.progress_bar) self.setLayout(layout)
def get_toolbar_buttons(self): """Return toolbar buttons list.""" buttons = [] # Code to add the stop button if self.stop_button is None: self.stop_button = create_toolbutton( self, text=_("Stop"), icon=self.stop_icon, tip=_("Stop the current command")) self.disable_stop_button() # set click event handler self.stop_button.clicked.connect(self.stop_button_click_handler) if is_dark_interface(): self.stop_button.setStyleSheet("QToolButton{padding: 3px;}") if self.stop_button is not None: buttons.append(self.stop_button) # Reset namespace button if self.reset_button is None: self.reset_button = create_toolbutton( self, text=_("Remove"), icon=ima.icon('editdelete'), tip=_("Remove all variables"), triggered=self.reset_namespace) if is_dark_interface(): self.reset_button.setStyleSheet("QToolButton{padding: 3px;}") if self.reset_button is not None: buttons.append(self.reset_button) if self.options_button is None: options = self.get_options_menu() if options: self.options_button = create_toolbutton( self, text=_('Options'), icon=ima.icon('tooloptions')) self.options_button.setPopupMode(QToolButton.InstantPopup) menu = QMenu(self) add_actions(menu, options) self.options_button.setMenu(menu) if self.options_button is not None: buttons.append(self.options_button) return buttons
def __init__(self, parent): super(PayloadWindow, self).__init__(parent) self.logger = logging.getLogger(self.__class__.__name__) self.setContentsMargins(11, 11, 11, 11) self.progress_windows = [] self.content_widget = QWidget(self) self.addContentWidget(self.content_widget) self.widget_layout = QFormLayout(self.content_widget) self.content_widget.setLayout(self.widget_layout) self.spinner = WaitingSpinner(self, modality=Qt.WindowModal, roundness=70.0, fade=70.0, radius=15.0, lines=6, line_length=25.0, line_width=4.0, speed=1.0) self.build_name_label = QLabel("Name", self.content_widget) self.build_name_edit = QLineEdit(self.content_widget) self.widget_layout.addRow(self.build_name_label, self.build_name_edit) self.icon_label = QLabel("Icon", self.content_widget) self.icon_combobox = QComboBox(self.content_widget) self.widget_layout.addRow(self.icon_label, self.icon_combobox) self.generators_label = QLabel("Generators", self.content_widget) self.generators_list = QListWidget(self.content_widget) self.widget_layout.addRow(self.generators_label, self.generators_list) self.build_button = QPushButton("Build", self.content_widget) self.build_button.clicked.connect(self.on_build_button_clicked) self.widget_layout.addWidget(self.build_button) self.menu = QMenu(self) self.menu.setTitle("Payload") self.reload_action = QAction(self.menu) self.reload_action.setText("Reload options") self.reload_action.triggered.connect(self.setupUi) self.menu.addAction(self.reload_action) self.addMenu(self.menu)
def build_context_menu(self, index): """Build context menu for test item that given index points to.""" contextMenu = QMenu(self) if self.isExpanded(index): menuItem = create_action(self, _('Collapse'), triggered=lambda: self.collapse(index)) else: menuItem = create_action(self, _('Expand'), triggered=lambda: self.expand(index)) menuItem.setEnabled(self.model().hasChildren(index)) contextMenu.addAction(menuItem) menuItem = create_action( self, _('Go to definition'), triggered=lambda: self.go_to_test_definition(index)) test_location = self.model().data(index, Qt.UserRole) menuItem.setEnabled(test_location[0] is not None) contextMenu.addAction(menuItem) return contextMenu
def __init__(self, parent, statusbar, icon=None): """Status bar widget for displaying the current conda environment.""" self._interpreter = None super(InterpreterStatus, self).__init__(parent, statusbar, icon=icon) self.main = parent self.env_actions = [] self.path_to_env = {} conda_env = get_list_conda_envs() pyenv_env = get_list_pyenv_envs() self.envs = {**conda_env, **pyenv_env} for env in list(self.envs.keys()): path, version = self.envs[env] # Save paths in lowercase on Windows to avoid issues with # capitalization. path = path.lower() if os.name == 'nt' else path self.path_to_env[path] = env self.menu = QMenu(self) self.sig_clicked.connect(self.show_menu)
def onCustomTrackMenuRequested(self): menu = QMenu("Animator Track Context") itemTitle = menu.addAction('Create Custom Animator Track') itemTitle.setEnabled(False) menu.addSeparator() #check if there is animator track trackTypes = _MOCK.getCustomAnimatorTrackTypesForObject( self.getTarget()) if not trackTypes: return for id, clas in list(trackTypes.items()): action = menu.addAction(id) def _makeTrackCreator(trackId): return lambda x: self.addCustomAnimatorTrack(trackId) action.triggered.connect(_makeTrackCreator(id)) action.setIcon(getIcon('object_track')) menu.exec_(QtGui.QCursor.pos())
def contextMenuEvent(self, event): """Don't show some actions which have no meaning for the notebook.""" menu = QMenu(self) plugin_actions = self.parent().plugin_actions actions = plugin_actions + [ None, self.pageAction(QWebEnginePage.SelectAll), self.pageAction(QWebEnginePage.Copy), None, self.zoom_in_action, self.zoom_out_action ] if not WEBENGINE: settings = self.page().settings() settings.setAttribute(QWebEngineSettings.DeveloperExtrasEnabled, True) actions += [None, self.pageAction(QWebEnginePage.InspectElement)] add_actions(menu, actions) menu.popup(event.globalPos()) event.accept()
def __init__(self, data=None): super().__init__() self.translator = create_translator( path=os.path.join(os.path.dirname(__file__), 'translations', 'qt_{0}.qm'.format(QLocale.system().name()))) # translator self.data = None self.menu = QMenu() self.action_insert_row = self.menu.addAction(QCoreApplication.translate('PMTableView','Insert Row')) self.action_insert_row.triggered.connect(lambda: self.on_change_row_col(self.INSERT_ROW)) self.action_delete_row = self.menu.addAction(QCoreApplication.translate('PMTableView','Delete Row')) self.action_delete_row.triggered.connect(lambda: self.on_change_row_col(self.DELETE_ROW)) self.action_insert_col = self.menu.addAction(QCoreApplication.translate('PMTableView','Insert Column')) self.action_insert_col.triggered.connect(lambda: self.on_change_row_col(self.INSERT_COLUMN)) self.action_delete_col = self.menu.addAction(QCoreApplication.translate('PMTableView','Delete Column')) self.action_delete_col.triggered.connect(lambda: self.on_change_row_col(self.DELETE_COLUMN)) # self.menu.addAction("aaaaaa") if data is not None: self.set_data(data)
def __init__(self, parent): QTreeWidget.__init__(self, parent) self.setItemsExpandable(True) self.setColumnCount(1) self.itemActivated.connect(self.activated) self.itemClicked.connect(self.clicked) # Setup context menu self.menu = QMenu(self) self.collapse_all_action = None self.collapse_selection_action = None self.expand_all_action = None self.expand_selection_action = None self.common_actions = self.setup_common_actions() self.__expanded_state = None self.itemSelectionChanged.connect(self.item_selection_changed) self.item_selection_changed()
def contextMenuEvent(self, ev: QContextMenuEvent): ''' Contextmenuevent Parameters ---------- ev : QContextMenuEvent ''' ev.accept() self.d.drag_start_mouse_position = ev.pos() menu = QMenu(self) menu.addAction("Detach", self.on_detach_action_triggered) menu.addSeparator() action = menu.addAction("Close", self.close_requested) action.setEnabled(self.is_closable()) menu.addAction("Close Others", self.close_other_tabs_requested) menu.exec(self.mapToGlobal(ev.pos()))
def _mkMenu(self, sorting_dict, menu=None): if menu is None: menu = self.functionmenu menu.clear() for key in sorting_dict: if key == '___': menu.addSeparator() for operation in sorting_dict['___']: menu.addAction( operation.name, partial(self.addOperation, operation, autoconnectall=True)) else: submenu = QMenu(title=key, parent=menu) menu.addMenu(submenu) self._mkMenu(sorting_dict[key], submenu)
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 open_logger_table_menu(self, position): # Needed as a workaround for when the header column count is 0 and it becomes invisible if self.table_header.column_count == 0: self.open_header_menu(position) return selected = self.loggerTable.selectedIndexes() if not selected: return row_index = selected[0] record = self.get_record(row_index) menu = QMenu(self) view_message = menu.addAction("View message") view_message.triggered.connect( partial(self.open_text_view_dialog, row_index, False)) if record.exc_text: view_traceback = menu.addAction("View traceback") view_traceback.triggered.connect( partial(self.open_text_view_dialog, row_index, True)) menu.popup(self.table_header_view.viewport().mapToGlobal(position))
def append_qmenu(self, button_name: str, menu_text: str, menu_icon: QIcon = None) -> QMenu: button: 'QToolButton' = self.get_control_widget(button_name) action = None if button is not None: menu = button.menu() new_menu = QMenu(menu) new_menu.setTitle(menu_text) # menu.addMenu() menu.addMenu(new_menu) # if menu is None: # self.add_menu_to(button_name, [action_text], [action_command], action_icon=action_icon) # else: # action = QAction(text=action_text, parent=menu) # if action_icon is not None: # action.setIcon(action_icon) # menu.addAction(action) # action.triggered.connect(action_command) return new_menu
def __init__(self, parent=None): super().__init__(parent) self.activated.connect(self.activated_callback) self.plugin = parent.plugin self.shell = None self.reply = None # To write dialog box result self.setAlternatingRowColors(False) # Context menu self.contextMenu = QMenu(self) self.action_update_properties = self.contextMenu.addAction( "Show Properties" ) self.action_import_names = self.contextMenu.addAction( "Import Names" ) self.action_update_formulas = self.contextMenu.addAction( "Show Formulas" ) self.action_new_model = self.contextMenu.addAction( "Create New Model" ) self.action_new_space = self.contextMenu.addAction( "Create New Space" ) self.action_new_cells = self.contextMenu.addAction( "Create New Cells" ) self.action_read_model = self.contextMenu.addAction( "Read Model" ) self.action_write_model = self.contextMenu.addAction( "Write Model" ) self.action_delete_selected = self.contextMenu.addAction( "Delete Selected" ) self.action_delete_model = self.contextMenu.addAction( "Delete Model" )
def __init__(self, workflowview: QAbstractItemView, operation_filter: Callable[[OperationPlugin], bool] = None): super(WorkflowWidget, self).__init__() self.operation_filter = operation_filter self.view = workflowview self.autorun_checkbox = QCheckBox("Run Automatically") self.autorun_checkbox.setCheckState(Qt.Unchecked) self.autorun_checkbox.stateChanged.connect(self._autorun_state_changed) self.run_button = QPushButton("Run Workflow") self.run_button.clicked.connect(self.sigRunWorkflow.emit) self.view.model().workflow.attach(self._autorun) # TODO -- actually hook up the auto run OR dependent class needs to connect (see SAXSGUIPlugin) self.toolbar = QToolBar() self.addfunctionmenu = QToolButton() self.addfunctionmenu.setIcon(QIcon(path("icons/addfunction.png"))) self.addfunctionmenu.setText("Add Function") # Defer menu population to once the plugins have been loaded; otherwise, the menu may not contain anything # if this widget is init'd before all plugins have been loaded. self.functionmenu = QMenu() self.functionmenu.aboutToShow.connect(self.populateFunctionMenu) self.addfunctionmenu.setMenu(self.functionmenu) self.addfunctionmenu.setPopupMode(QToolButton.InstantPopup) self.toolbar.addWidget(self.addfunctionmenu) # self.toolbar.addAction(QIcon(path('icons/up.png')), 'Move Up') # self.toolbar.addAction(QIcon(path('icons/down.png')), 'Move Down') self.toolbar.addAction(QIcon(path("icons/folder.png")), "Load Workflow") self.toolbar.addAction(QIcon(path("icons/trash.png")), "Delete Operation", self.deleteOperation) v = QVBoxLayout() v.addWidget(self.view) h = QHBoxLayout() h.addWidget(self.autorun_checkbox) h.addWidget(self.run_button) v.addLayout(h) v.addWidget(self.toolbar) v.setContentsMargins(0, 0, 0, 0) self.setLayout(v)
def setup_options_button(self): """Add the cog menu button to the toolbar.""" if not self.options_button: # When the FigureBowser widget is instatiated outside of the # plugin (for testing purpose for instance), we need to create # the options_button and set its menu. self.options_button = create_toolbutton( self, text=_('Options'), icon=ima.icon('tooloptions')) actions = self.actions + [MENU_SEPARATOR] + self.plugin_actions self.options_menu = QMenu(self) add_actions(self.options_menu, actions) self.options_button.setMenu(self.options_menu) if self.tools_layout.itemAt(self.tools_layout.count() - 1) is None: self.tools_layout.insertWidget(self.tools_layout.count() - 1, self.options_button) else: self.tools_layout.addWidget(self.options_button)
def _make_sort_button(self): """ Make the sort button, with separate groups for ascending and descending, sorting by name or last shown :return: The sort menu button """ sort_button = QPushButton("Sort") sort_menu = QMenu() ascending_action = QAction("Ascending", sort_menu, checkable=True) ascending_action.setChecked(True) ascending_action.toggled.connect(self.presenter.set_sort_order) descending_action = QAction("Descending", sort_menu, checkable=True) order_group = QActionGroup(sort_menu) order_group.addAction(ascending_action) order_group.addAction(descending_action) number_action = QAction("Number", sort_menu, checkable=True) number_action.setChecked(True) number_action.toggled.connect( lambda: self.presenter.set_sort_type(Column.Number)) name_action = QAction("Name", sort_menu, checkable=True) name_action.toggled.connect( lambda: self.presenter.set_sort_type(Column.Name)) last_active_action = QAction("Last Active", sort_menu, checkable=True) last_active_action.toggled.connect( lambda: self.presenter.set_sort_type(Column.LastActive)) sort_type_group = QActionGroup(sort_menu) sort_type_group.addAction(number_action) sort_type_group.addAction(name_action) sort_type_group.addAction(last_active_action) sort_menu.addAction(ascending_action) sort_menu.addAction(descending_action) sort_menu.addSeparator() sort_menu.addAction(number_action) sort_menu.addAction(name_action) sort_menu.addAction(last_active_action) sort_button.setMenu(sort_menu) return sort_button
def on_mouse_press_event(self, event): """ determine whether the mode is on right button: pop out menu if it is relevant left button: get start to :param event: :return: """ # only respond when in manual picking mode if not self._inManualPickingMode: return button = event.button self._currMousePosX = event.xdata if button == 1: # left button: if a picker is selected then enter on hold mode if self._currentSelectedPicker is not None: self._mouseLeftButtonHold = True elif button == 3: # right button: pop-out menu self.menu = QMenu(self) if self._currentSelectedPicker is None: # no picker is selected action1 = QAction('Add Picker', self) action1.triggered.connect(self.menu_add_picker) self.menu.addAction(action1) else: # some picker is selected action2 = QAction('Delete Picker', self) action2.triggered.connect(self.menu_delete_picker) self.menu.addAction(action2) # add other required actions self.menu.popup(QCursor.pos()) # END-IF-ELSE return
def _make_context_menu(self): """ Makes the context menu with options relating to plots :return: The context menu, and export sub-menu with a list of export types """ context_menu = QMenu() context_menu.addAction("Show", self.presenter.show_multiple_selected) context_menu.addAction("Hide", self.presenter.hide_selected_plots) context_menu.addAction("Delete", self.presenter.close_action_called) context_menu.addAction("Rename", self.rename_selected_in_context_menu) export_menu = context_menu.addMenu("Export") for text, extension in EXPORT_TYPES: export_menu.addAction( text, lambda ext=extension: self.presenter.export_plots_called(ext)) return context_menu, export_menu
def contextMenuEvent(self, event): """Show a custom context menu.""" point = event.pos() menu = QMenu("Actions", self) menu.addAction(self.turn_on_act) menu.addAction(self.turn_off_act) menu.addAction(self.ctrlloop_close_act) menu.addAction(self.ctrlloop_open_act) menu.addAction(self.set_current_sp_act) if not self._dev_list[0].dev in ('FCH', 'FCV'): menu.addAction(self.set_slowref_act) menu.addAction(self.reset_act) menu.addAction(self.wfmupdate_on_act) menu.addAction(self.wfmupdate_off_act) menu.addAction(self.updparms_act) menu.addSeparator() action = menu.addAction('Show Connections...') action.triggered.connect(self.show_connections) menu.popup(self.mapToGlobal(point))
def _setup_menu(self, show_callable_attributes=False, show_special_attributes=False): """Sets up the main menu.""" self.tools_layout = QHBoxLayout() callable_attributes = create_toolbutton( self, text=_("Show callable attributes"), icon=ima.icon("class"), toggled=self._toggle_show_callable_attributes_action) callable_attributes.setCheckable(True) callable_attributes.setChecked(show_callable_attributes) self.tools_layout.addWidget(callable_attributes) special_attributes = create_toolbutton( self, text=_("Show __special__ attributes"), icon=ima.icon("private2"), toggled=self._toggle_show_special_attributes_action) special_attributes.setCheckable(True) special_attributes.setChecked(show_special_attributes) self.tools_layout.addWidget(special_attributes) self.tools_layout.addStretch() self.options_button = create_toolbutton(self, text=_('Options'), icon=ima.icon('tooloptions')) self.options_button.setPopupMode(QToolButton.InstantPopup) self.show_cols_submenu = QMenu(self) self.options_button.setMenu(self.show_cols_submenu) # Don't show menu arrow and remove padding if is_dark_interface(): self.options_button.setStyleSheet( ("QToolButton::menu-indicator{image: none;}\n" "QToolButton{padding: 3px;}")) else: self.options_button.setStyleSheet( "QToolButton::menu-indicator{image: none;}") self.tools_layout.addWidget(self.options_button)
def __init__(self, redis, parent=None): super(RedisTree, self).__init__(parent) self.load_ui() ui = self.ui self.redis = redis self.source_model = RedisKeyModel(redis) self.sort_filter_model = QSortFilterProxyModel() self.sort_filter_model.setFilterRole(KeyNameRole) self.sort_filter_model.setSourceModel(self.source_model) ui.tree.setModel(self.sort_filter_model) selection = ui.tree.selectionModel() selection.currentChanged.connect(self._on_current_changed) selection.selectionChanged.connect(self._on_selection_changed) # TODO: fix bug search of type "bl04:" still gives no result ui.filter_container.setVisible(False) add_menu = QMenu("Add") ui.add_string_action = add_menu.addAction("string") ui.add_list_action = add_menu.addAction("list") ui.add_set_action = add_menu.addAction("set") ui.add_hash_action = add_menu.addAction("hash") add_button = QToolButton() add_button.setMenu(add_menu) add_button.setPopupMode(QToolButton.InstantPopup) add_button.setIcon(QIcon.fromTheme("list-add")) ui.add_key_action = ui.db_toolbar.insertWidget(ui.remove_key_action, add_button) ui.add_string_action.triggered.connect( functools.partial(self._on_add_key, "string")) ui.add_list_action.triggered.connect( functools.partial(self._on_add_key, "list")) ui.add_set_action.triggered.connect( functools.partial(self._on_add_key, "set")) ui.add_hash_action.triggered.connect( functools.partial(self._on_add_key, "hash")) ui.update_db_action.triggered.connect(self._on_update_db) ui.flush_db_action.triggered.connect(self._on_flush_db) ui.remove_key_action.triggered.connect(self._on_remove_key) ui.touch_key_action.triggered.connect(self._on_touch_key) ui.persist_key_action.triggered.connect(self._on_persist_key) ui.copy_key_action.triggered.connect(self._on_copy_key) ui.filter_edit.textChanged.connect(self._on_filter_changed)
def add_toggle_view_action_to_menu(self, toggle_view_action: QAction, group: str, group_icon: QIcon) -> QAction: ''' Adds a toggle view action to the the internal view menu. You can either manage the insertion of the toggle view actions in your application or you can add the actions to the internal view menu and then simply insert the menu object into your. Parameters ---------- toggle_view_action : QAction group : str group_icon : QIcon Returns ------- value : QAction ''' order = self._mgr.menu_insertion_order alphabetically_sorted = ( InsertionOrder.by_spelling == order ) if not group: self._mgr.add_action_to_menu(toggle_view_action, self._mgr.view_menu, alphabetically_sorted) return toggle_view_action try: group_menu = self._mgr.view_menu_groups[group] except KeyError: group_menu = QMenu(group, self) group_menu.setIcon(group_icon) self._mgr.add_action_to_menu( group_menu.menuAction(), self._mgr.view_menu, alphabetically_sorted) self._mgr.view_menu_groups[group] = group_menu self._mgr.add_action_to_menu(toggle_view_action, group_menu, alphabetically_sorted) return group_menu.menuAction()
def __init__(self, plugin_handler): """ @type plugin_handler: PluginHandler """ enabled = len(plugin_handler) > 0 super(PluginsTool, self).__init__("Plugins", "tools/plugins", resourceIcon("ide/plugin"), enabled, popup_menu=True) self.__plugins = {} menu = QMenu() for plugin in plugin_handler: plugin_runner = PluginRunner(plugin) plugin_runner.setPluginFinishedCallback(self.trigger) self.__plugins[plugin] = plugin_runner plugin_action = menu.addAction(plugin.getName()) plugin_action.setToolTip(plugin.getDescription()) plugin_action.triggered.connect(plugin_runner.run) self.getAction().setMenu(menu)
def __init__(self, model: QAbstractItemModel): super(DataResourceView, self).__init__() self._model = model # type: QAbstractItemModel self.setModel(self._model) self.doubleClicked.connect(self.open) self.setSelectionMode(self.ExtendedSelection) self.setSelectionBehavior(self.SelectRows) self.setContextMenuPolicy(Qt.CustomContextMenu) self.customContextMenuRequested.connect(self.menuRequested) self.menu = QMenu() standardActions = [ QAction("Open", self), QAction("Open Externally", self), QAction("Enable/Disable Streaming", self), QAction("Delete", self), ] self.menu.addActions(standardActions) standardActions[0].triggered.connect(self.open) standardActions[1].triggered.connect(self.openExternally)
def test_context_menu_added_for_scripted_plot_with_errors(self): self.ax.plot([0, 15000], [0, 15000], label='MyLabel') self.ax.errorbar([0, 15000], [0, 14000], yerr=[10, 10000], label='MyLabel 2') main_menu = QMenu() # QMenu always seems to have 1 child when empty, # but just making sure the count as expected at this point in the test self.assertEqual(1, len(main_menu.children())) # plot above doesn't have errors, nor is a MantidAxes # so no context menu will be added self.interactor.add_error_bars_menu(main_menu, self.ax) added_menu = main_menu.children()[1] # actions should have been added now, which for this case are only `Show all` and `Hide all` self.assertTrue( any(FigureInteraction.SHOW_ERROR_BARS_BUTTON_TEXT == child.text() for child in added_menu.children())) self.assertTrue( any(FigureInteraction.HIDE_ERROR_BARS_BUTTON_TEXT == child.text() for child in added_menu.children()))