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()))
