def setup_menu(self):
self.menu = QMenu()
clock_item = QWidgetAction(self.menu)
self.clock = QPushButton(' ')
self.clock.setProperty('objectName', 'menu')
font = self.clock.font()
font.setPixelSize(CLOCK_FONT_SIZE)
self.clock.setFont(font)
clock_item.setDefaultWidget(self.clock)
self.clock.clicked.connect(self.activate_window)
exit_item = QWidgetAction(self.menu)
label = QPushButton(EXIT_LABEL)
label.setProperty('objectName', 'menu')
exit_item.setDefaultWidget(label)
label.clicked.connect(self.activate_exit)
self.menu.addAction(clock_item)
self.menu.addAction(exit_item)
if sys.platform == 'darwin':
clock_item.button = self.clock
exit_item.button = label
self.menu.actions = [clock_item, exit_item]
self.set_up_menu_macos(self.menu)
def __init__(self, widget):
QMenu.__init__(self)
self.widget = widget
center_plot = self.addAction(_('Center Plot'))
center_plot.triggered.connect(lambda: widget.view.setRange(yRange=(
widget.left_axis[-1], widget.left_axis[-1])))
vertical_autorange = self.addAction(_('Vertical Autorange'))
vertical_autorange.triggered.connect(lambda: widget.view.autoRange())
if self.widget.filtering:
filters_menu = self.addMenu(_('Filters'))
filters_lst = []
r = QRadioButton('No Filter')
radio_action = QWidgetAction(filters_menu)
radio_action.setDefaultWidget(r)
filters_menu.addAction(radio_action)
filters_lst.append(r)
for f in self.widget.iir_filter.filters.keys():
r = QRadioButton(f)
radio_action = QWidgetAction(filters_menu)
radio_action.setDefaultWidget(r)
filters_menu.addAction(radio_action)
filters_lst.append(r)
for i, f in enumerate(filters_lst):
if i == self.current_filter:
f.setChecked(True)
self.filters = [(r,
r.clicked.connect(lambda: self.filter_chosen()))
for r in filters_lst]
if self.widget.time_synchronised:
sync_x_chbx = QCheckBox(_('\t\t\t\t\tSynchronize time'))
sync_x_chbx.setChecked(Menu.sync_chbx_state)
sync_x_chbx.stateChanged.connect(lambda i: self.state_changed(i))
sync_x = QWidgetAction(self)
sync_x.setDefaultWidget(sync_x_chbx)
self.addAction(sync_x)
def setup_menu_items(self):
"""
Setup the items listed in the menu, including a (select all) item
to check or uncheck all items at once.
"""
self.clear()
if '__select_all__' not in self._actions:
checkbox = QCheckBox('(Select All)', self.parent())
checkbox.setChecked(True)
checkbox.stateChanged.connect(self.handle_select_was_clicked)
action = QWidgetAction(self.parent())
action.setDefaultWidget(checkbox)
self._actions['__select_all__'] = action
self.addAction(self._actions['__select_all__'])
if self.client is not None:
self.addSeparator()
for item in self.items():
if item in self._actions:
self.addAction(self._actions[item])
else:
checkbox = QCheckBox(item, self.parent())
checkbox.setChecked(True)
checkbox.stateChanged.connect(self.handle_item_was_clicked)
action = QWidgetAction(self.parent())
action.setDefaultWidget(checkbox)
self.addAction(action)
self._actions[item] = action
self.setup_select_all_item()
def create_menu(self):
_menu = QMenu()
self.statsLabel = QLabel("")
self.imageLabel = QLabel()
self.updateImageStats()
self.updateImage()
label_action = QWidgetAction(self.imageLabel)
label_action.setDefaultWidget(self.imageLabel)
_menu.addAction(label_action)
# add stats label
label_action = QWidgetAction(self.statsLabel)
label_action.setDefaultWidget(self.statsLabel)
_menu.addAction(label_action)
_menu.addSeparator()
_submenu = QMenu(_menu)
_submenu.setTitle("Preferences")
_switch_submenu = QMenu(_submenu)
_switch_submenu.setTitle("Image change action")
self.onOpenAction = QAction("On Open", _switch_submenu)
self.onOpenAction.setCheckable(True)
self.onOpenAction.setChecked(self.configBool("config/switch_on_open"))
self.onOpenAction.triggered.connect(self.onOpen)
_switch_submenu.addAction(self.onOpenAction)
self.onTimerAction = QAction("Every 3sec", _switch_submenu)
self.onTimerAction.setCheckable(True)
self.onTimerAction.setChecked(
self.configBool("config/switch_every_interval"))
self.onTimerAction.triggered.connect(self.onTimer)
_switch_submenu.addAction(self.onTimerAction)
_submenu.addMenu(_switch_submenu)
self.manageDirectoryAction = QAction(self.getSourceLabel())
self.manageDirectoryAction.triggered.connect(self.manageDirectory)
_submenu.addAction(self.manageDirectoryAction)
self.showStockAction = QAction("Show stock images (ignore source)")
self.showStockAction.setCheckable(True)
self.showStockAction.setChecked(self.configBool("config/show_stock"))
self.showStockAction.triggered.connect(self.showStock)
_submenu.addAction(self.showStockAction)
_menu.addMenu(_submenu)
quiteA = QAction("Exit", _menu)
quiteA.triggered.connect(self.exit_slot)
_menu.addAction(quiteA)
self._menu = _menu
self.setContextMenu(self._menu)
def createActions(self):
self.setIcon(QIcon('./icons/sandbox.png'))
self.menu = QMenu(QApplication.desktop())
self.menu.setStyleSheet("QMenu{text-align:center}")
self.show_action = QWidgetAction(self.menu)
self.exit_action = QWidgetAction(self.menu)
self.show_action.triggered.connect(self.showWidget)
self.exit_action.triggered.connect(self.exitWidget)
self.show_action.setIcon(QIcon(QPixmap("./icons/减号.png")))
self.show_action.setIconText("显示主界面")
self.exit_action.setIcon(QIcon(QPixmap("./icons/关机.png")))
self.exit_action.setIconText("退出程序")
def __init__(self,
id_: str,
network,
graph=ig.Graph(),
interactions=pd.DataFrame()):
super().__init__()
uic.loadUi(os.path.join(os.path.dirname(__file__), 'network.ui'), self)
self.id = id_
self._name = None
self._layout = None
self._hide_isolated_nodes = False
self._isolated_nodes = []
self._network = network
self._graph = graph if isinstance(graph, ig.Graph) else ig.Graph()
self._interactions = interactions if isinstance(
interactions, pd.DataFrame) else pd.DataFrame()
# Send Scale sliders to a toolbutton menu
menu = QMenu()
action = QWidgetAction(self)
action.setDefaultWidget(self.sliderScale)
menu.addAction(action)
self.btRuler.setMenu(menu)
self.view().setScene(AnnotationsNetworkScene())
if self.unlockable:
self.btLock.toggled.connect(lambda x: self.scene().lock(x))
else:
self.btLock.hide()
self.btOptions.clicked.connect(
lambda: self.editOptionsTriggered.emit(self))
self.sliderScale.valueChanged.connect(self.on_scale_changed)
def __init__(self,
action: QAction = None,
color_group=None,
default_color=Qt.blue,
*args,
**kwargs):
super().__init__(*args, **kwargs)
self.last_color_action = action if action is not None else QAction(
self)
self._color_group = color_group
dialog_action = QWidgetAction(self)
self._dialog = QColorDialog(self)
self.btReset = None
button_box = self._dialog.findChild(QDialogButtonBox, "")
if button_box is not None:
self.btReset = button_box.addButton(QDialogButtonBox.Reset)
self._dialog.setWindowFlags(Qt.Widget)
self._dialog.setOptions(self._dialog.options()
| QColorDialog.DontUseNativeDialog)
dialog_action.setDefaultWidget(self._dialog)
# Hide pick screen color button
button = self._dialog.findChild(QAbstractButton)
if button:
button.hide()
# Load custom colors
settings = QSettings()
settings.beginGroup("Colors")
custom_colors = settings.value("Custom", [])
for i, color in enumerate(custom_colors):
self._dialog.setCustomColor(i, color)
current_color = QColor(default_color) if color_group is None\
else settings.value(f"{color_group}/Current", QColor(default_color), type=QColor)
if current_color.isValid():
self._dialog.setCurrentColor(current_color)
self.on_color_selected(current_color)
settings.endGroup()
menu = QMenu()
menu.addAction(dialog_action)
self.setMenu(menu)
self.setPopupMode(QToolButton.MenuButtonPopup)
self.setDefaultAction(self.last_color_action)
# Connect events
self.colorSelected = self._dialog.colorSelected
if self.btReset is not None:
self.btReset.clicked.connect(self.colorReset.emit)
self.currentColorChanged = self._dialog.currentColorChanged
menu.aboutToShow.connect(self._dialog.show)
self._dialog.rejected.connect(menu.hide)
self._dialog.colorSelected.connect(menu.hide)
self._dialog.colorSelected.connect(self.on_color_selected)
self.last_color_action.triggered.connect(self.on_use_last_color)
def __init__(self, name, linkedGraph, parent):
super(InputSettingsBar, self).__init__(parent)
root = QFileInfo(__file__).absolutePath()
self.cmapButton = MiniGradientButton(
gradient_name=linkedGraph.data[name].cmap_name)
self.cmapMenuDisplay = ColormapMenu(name=name,
linkedGraph=linkedGraph,
parent_settings_bar=self)
self.cmapButton.setMenu(QMenu(self.cmapButton))
showColormapMenu = QWidgetAction(self.cmapButton)
showColormapMenu.setDefaultWidget(self.cmapMenuDisplay)
self.cmapButton.menu().addAction(showColormapMenu)
self.settingsButton = MiniButton(root +
'/../../styles/assets/icons/cog.png',
parent=self)
self.deleteButton = MiniButton(root +
'/../../styles/assets/icons/close.png',
parent=self)
self.hideButton = MiniButton(root +
'/../../styles/assets/icons/eye.png',
parent=self)
self.plotButton = MiniButton(root +
'/../../styles/assets/icons/refresh.png',
parent=self)
self.addWidget(self.cmapButton)
self.addWidget(self.settingsButton)
self.addWidget(self.deleteButton)
self.addWidget(self.hideButton)
self.addWidget(self.plotButton)
self.setMinimumWidth(33 * 5)
def add_smiles_toolbar(chatik):
def smile_slot(img_path):
chatik.textEdit.insertHtml('<img src="%s" />' % img_path)
button = QToolButton(chatik)
button.setText(':-)')
button.setPopupMode(QToolButton.InstantPopup)
menu = QMenu(button)
chunks = [SMILES[x:x + 4] for x in range(0, len(SMILES), 4)]
for chunk in chunks:
menu_toolbar = QToolBar(menu)
widget_action = QWidgetAction(menu)
widget_action.setDefaultWidget(menu_toolbar)
menu.addAction(widget_action)
for file, title in chunk:
path = SMILES_DIR + file
icon = QIcon(path)
action = QAction(icon, '', chatik)
slot = partial(smile_slot, path)
action.triggered.connect(slot)
menu_toolbar.addAction(action)
button.setMenu(menu)
chatik.addToolBar('Smiles').addWidget(button)
def gui_setup(self):
main_menu = QMenu()
self.disable_suppression_menu.setEnabled(False)
self.disable_suppression_menu.triggered.connect(
self.disable_noise_suppression)
for src in pulse.source_list():
mic_menu_item = AudioMenuItem(
src.description,
self.enable_suppression_menu,
src.name,
)
self.enable_suppression_menu.addAction(mic_menu_item)
mic_menu_item.triggered.connect(self.enable_noise_suppression)
self.exit_menu.triggered.connect(self.quit)
main_menu.addMenu(self.enable_suppression_menu)
main_menu.addAction(self.disable_suppression_menu)
main_menu.addAction(self.exit_menu)
# Add slider widget
self.level_section = self.enable_suppression_menu.addSection(
self.get_section_message())
wa = QWidgetAction(self.enable_suppression_menu)
wa.setDefaultWidget(self.slider)
self.enable_suppression_menu.addAction(wa)
self.setIcon(self.disabled_icon)
self.setContextMenu(main_menu)
def init_items(self):
self.toolbar.setObjectName("maintoolbar")
self.parent.addToolBar(Qt.TopToolBarArea, self.toolbar)
self.toolbar.setMovable(False)
self.toolbar.addSeparator()
toolbar_ctx_list = QComboBox(self.parent)
toolbar_ctx_list.setDuplicatesEnabled(False)
toolbar_ctx_list.setEditable(True)
toolbar_ctx_list.currentIndexChanged[str].connect(
lambda new_tool: self.on_toolbar_tool_changed(new_tool))
toolbar_ctx_list_action = QWidgetAction(self.parent)
toolbar_ctx_list_action.setText(DEVTOOLS_COMBO_NAME)
toolbar_ctx_list_action.setDefaultWidget(toolbar_ctx_list)
self.toolbar.addAction(toolbar_ctx_list_action)
spacer = QWidget(self.parent)
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.toolbar.addWidget(spacer)
toolbar_configure_action = QAction(QIcon(":/images/configure-48.png"),
"Settings", self.parent)
toolbar_configure_action.triggered.connect(
self.parent.config_controller.show_dialog)
self.toolbar.addAction(toolbar_configure_action)
def add_element(self,
port_id: int,
portgrp_id: int,
port_name: str,
is_alternate=False):
if self._port_type == PORT_TYPE_AUDIO_JACK and is_alternate:
port_name = "CV| %s" % port_name
check_box = PortCheckBox(port_id, portgrp_id, port_name,
self._port_type, self)
action = QWidgetAction(self._parent)
action.setDefaultWidget(check_box)
if not self._portgrp_id and portgrp_id != self._last_portgrp_id:
self.addSeparator()
self._last_portgrp_id = portgrp_id
self.addAction(action)
self.elements.append({
'port_id': port_id,
'portgrp_id': portgrp_id,
'action': action,
'check_box': check_box
})
def __init__(self, parentToolBar):
super().__init__()
self.parentToolBar = parentToolBar
self.setToolTip("Toggle item visibility")
self.setMenu(QMenu(self))
self.setPopupMode(QToolButton.InstantPopup)
# self.setIcon(Icon("TODO"))
self.setFixedWidth(16)
m = 0
mainWidget = QWidget()
mainlay = QVBoxLayout()
mainlay.setContentsMargins(m, m, m, m)
mainWidget.setLayout(mainlay)
lbl = QLabel("Set preferences for visibility")
lbl.setStyleSheet("background-color: #FFFDC3; padding: 4px;")
mainlay.addWidget(lbl)
m = 5
self.grid = QGridLayout()
self.grid.setContentsMargins(m, m, m, m)
mainlay.addLayout(self.grid)
self.create_widgets()
widget_action = QWidgetAction(self)
widget_action.setDefaultWidget(mainWidget)
self.menu().addAction(widget_action)
def __init_rename_menu__(self):
rename = self.addMenu('Rename')
rename_action = QWidgetAction(self)
line_edit = QLineEdit(self.value.name)
line_edit.editingFinished.connect(
lambda: self.roi.send_name(line_edit.text()))
rename_action.setDefaultWidget(line_edit)
rename.addAction(rename_action)
def onHeaderClicked(self, index):
# only filter box column
if index in self.allowed_filter_indexes:
self.menu = QMenu(self)
self.col = index
data_unique = []
self.checkBoxes = []
deselectBtn = QPushButton("Deselect all")
deselectBtn.clicked.connect(self.deselectAll)
deselectAction = QWidgetAction(self.menu)
deselectAction.setDefaultWidget(deselectBtn)
self.menu.addAction(deselectAction)
for i in range(self.itemsTable.rowCount()):
item = self.itemsTable.item(i, index)
if item.text() not in data_unique:
data_unique.append(item.text())
checkbox = QCheckBox(item.text(), self.menu)
checkbox.setChecked(not self.itemsTable.isRowHidden(i))
checkableAction = QWidgetAction(self.menu)
checkableAction.setDefaultWidget(checkbox)
self.menu.addAction(checkableAction)
self.checkBoxes.append(checkbox)
dialogBtn = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel, Qt.Horizontal,
self.menu)
dialogBtn.accepted.connect(self.filterAndClose)
dialogBtn.rejected.connect(self.menu.close)
checkableAction = QWidgetAction(self.menu)
checkableAction.setDefaultWidget(dialogBtn)
self.menu.addAction(checkableAction)
clearBtn = QPushButton("Clear filter")
clearBtn.clicked.connect(self.clearFilter)
clearAction = QWidgetAction(self.menu)
clearAction.setDefaultWidget(clearBtn)
self.menu.addAction(clearAction)
headerPos = self.itemsTable.mapToGlobal(
self.horizontalHeader.pos())
posY = headerPos.y() + self.horizontalHeader.height()
posX = headerPos.x() + self.horizontalHeader.sectionPosition(index)
self.menu.exec_(QPoint(posX, posY))
def _createActions(self):
test = QWidgetAction(self.menu)
l = QLabel(self)
l.setText('test')
test.setDefaultWidget(ItemAction('Group'))
self.menu.addAction(test)
settingsAction = QAction('settings', self.menu)
self.menu.addAction(settingsAction)
def addItem(self, text, checked=False):
checkBox = QCheckBox(self.toolMenu)
checkBox.setText(text)
checkBox.setChecked(checked)
checkableAction = QWidgetAction(self.toolMenu)
checkableAction.setDefaultWidget(checkBox)
self.toolMenu.addAction(checkableAction)
def _init_rename_menu(self):
rename = self.addMenu('Rename')
rename_action = QWidgetAction(self)
line_edit = QLineEdit(self.roi.name)
line_edit.editingFinished.connect(
lambda: self.roi_dict.change_name(self.key, line_edit.text()))
rename_action.setDefaultWidget(line_edit)
rename.addAction(rename_action)
def _template():
""" Peripheral action separator - generator """
_label = QLabel(getattr(self._lang, f'Action{heading}Heading'))
_label.setStyleSheet('QLabel {color: gray;}')
_label.setAlignment(Qt.AlignCenter)
_action = QWidgetAction(None)
_action.setDefaultWidget(_label)
_action.setObjectName(f'{self._lang.__name__}{heading}')
yield _action
def __init__(self):
QWidget.__init__(self)
layout = QHBoxLayout(self)
self.button = QToolButton(self)
self.button.setPopupMode(QToolButton.MenuButtonPopup)
self.button.setMenu(QMenu(self.button))
self.textBox = QTextBrowser(self)
action = QWidgetAction(self.button)
action.setDefaultWidget(self.textBox)
self.button.menu().addAction(action)
layout.addWidget(self.button)
def showHeaderMenu(self, event):
self.save_columns()
menu = QMenu(self)
header_view = HeaderEditWidget(self, self.config, menu_mode=True, parent=menu)
# header_view.setFixedHeight((header_view.geometry().height()-2) * len(header_view.columns))
# box.setSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding)
action = QWidgetAction(menu)
action.setDefaultWidget(header_view)
menu.addAction(action)
menu.exec_(QCursor.pos())
header_view.save_preset()
def __init__(self, core):
super(TabButtonWidget, self).__init__()
self.setText("Icon")
self.setPopupMode(QToolButton.InstantPopup)
self.setIcon(icon("mdi.account-circle", color="white", scale_factor=1.25))
self.setToolTip("Account")
self.setIconSize(QSize(25, 25))
self.setMenu(QMenu())
action = QWidgetAction(self)
action.setDefaultWidget(MiniWidget(core))
self.menu().addAction(action)
def toQAction(act : IAction, parent : QObject) :
qact = QAction(QIcon(act.icon), act.title, parent=parent)
if act.shortcut is not None:
qact.setShortcut(act.shortcut)
children = get().queryChildren(act.id)
# action widget
if act.widget :
menu = QMenu()
wact = QWidgetAction(menu)
wact.setDefaultWidget(act.widget(menu))
menu.addAction(wact)
qact.setMenu(menu)
# wact.setText(act.title)
# wact.setIcon(QIcon(act.icon))
return qact
# single action
if act.callable is not None:
def cb(checked) :
print(act)
print(qact.text())
act.callable()
qact.triggered.connect(cb)
return qact
# sub menu
elif act.fetch is not None:
menu = QMenu()
qact.setMenu(menu)
def fresh():
acts = act.fetch(menu)
for a in acts:
menu.addAction(a)
menu.aboutToShow.connect(fresh)
menu.aboutToHide.connect(menu.clear)
return qact
else :
menu = QMenu()
qact.setMenu(menu)
for a in children:
qa = toQAction(a, qact)
menu.addAction(qa)
return qact
def __init__(self, parent=None):
super(BaseSourceView, self).__init__(parent=parent)
self._shows_amazon = False
self._source_table_widget = None
self._product_details_widget = None
self._product_links_widget = None
self._selected_source = None
self._last_add_list = None
# Set up the source selector
self.sourceBox = QComboBox(self)
source_box_action = QWidgetAction(self)
source_box_action.setDefaultWidget(self.sourceBox)
self.sourceBox.activated.connect(self.on_source_selection_changed)
self.add_toolbar_action(source_box_action)
# Create the other toolbar actions
self.action_reload_source = QAction(QIcon('icons/reload.png'),
'Reload', self)
self.action_delete_source = QAction(QIcon('icons/delete.png'),
'Delete', self)
self.action_reload_source.triggered.connect(self.reload)
self.action_delete_source.triggered.connect(self.delete_source)
self.add_toolbar_actions(
[self.action_reload_source, self.action_delete_source])
# Create some common context menu actions
self.action_add_to_list = QAction(QIcon('icons/list.png'),
'Add to list...', self)
self.action_remove_from_list = QAction(QIcon('icons/delete.png'),
'Remove from list...', self)
self.action_open_in_browser = QAction(QIcon('icons/internet.png'),
'Open in browser...', self)
self.action_open_in_google = QAction(QIcon('icons/search_google.png'),
'Open in Google...', self)
self.action_lookup_upc = QAction(QIcon('icons/barcode.png'),
'Look up UPC...', self)
self.action_unlink_products = QAction(QIcon('icons/unlink.png'),
'Unlink', self)
# Context menu connections
self.action_add_to_list.triggered.connect(self.on_add_to_list)
self.action_remove_from_list.triggered.connect(
self.on_remove_from_list)
self.action_unlink_products.triggered.connect(self.on_unlink_products)
self.action_open_in_browser.triggered.connect(self.on_open_in_browser)
self.action_open_in_google.triggered.connect(self.on_open_in_google)
self.action_lookup_upc.triggered.connect(self.on_lookup_upc)
def create_perspective_ui(self):
save_perspective_action = QAction("Create Perspective", self)
save_perspective_action.triggered.connect(self.save_perspective)
perspective_list_action = QWidgetAction(self)
self.perspective_combobox = QComboBox(self)
self.perspective_combobox.setSizeAdjustPolicy(QComboBox.AdjustToContents)
self.perspective_combobox.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.perspective_combobox.activated[str].connect(self.dock_manager.openPerspective)
perspective_list_action.setDefaultWidget(self.perspective_combobox)
self.toolBar.addSeparator()
self.toolBar.addAction(perspective_list_action)
self.toolBar.addAction(save_perspective_action)
def __init__(self):
QtWidgets.QWidget.__init__(self)
self.initPet()
# setting menu group
settings = QMenu("Settings", self)
settings.setIcon(QIcon("resources/ico/poro.ico"))
# setting -> draggable
self.drag_action = QAction("Draggable", self)
self.drag_action.setCheckable(True)
self.drag_action.setChecked(DEFAULT_DRAGGABLE)
self.drag_action.triggered.connect(self.freezeOrNot)
# setting -> opacity slider
self.opacity_action = self.initOpacitySlider(QWidgetAction(self))
settings.addAction(self.drag_action)
settings.addAction(self.opacity_action)
# about and exit action
about_action = QAction(QIcon("resources/ico/poro.ico"), "About", self)
exit_action = QAction(QIcon("resources/ico/poro.ico"), '&Exit', self)
about_action.triggered.connect(self.aboutInfo)
exit_action.triggered.connect(qApp.quit)
# init the tray_menu
tray_menu = QMenu(self)
tray_menu.addMenu(settings)
tray_menu.addAction(about_action)
tray_menu.addSeparator()
tray_menu.addAction(exit_action)
tray_icon = QSystemTrayIcon(self)
tray_icon.setIcon(QIcon("resources/ico/poro.ico"))
tray_icon.setContextMenu(tray_menu)
tray_icon.show()
ClientStatus.init()
self.count_false = 0
self.has_client_connected = False
# init thread using to monitor lol client
self.lol_client_heart_beat_thread = ClientHeartBeat(
LOL_CLIENT_HEART_BEAT_RATE)
# client 的监听信号 会发给 self.getClientInfo 这个函数
self.lol_client_heart_beat_thread.keeper.connect(self.getClientInfo)
self.thread = QThread()
# QObject 转 Qthread
self.lol_client_heart_beat_thread.moveToThread(self.thread)
self.thread.started.connect(self.lol_client_heart_beat_thread.run)
self.thread.start()
# when the signal got new position, send to ImgCatcher
self.client_info_sender.connect(statusChange)
def _create_toolbar(self, color_maps):
toolbar = QToolBar()
toolbar.setFloatable(False)
toolbar.setMovable(False)
self._layout_combo = LayoutCombo()
self._layout_combo_action = QWidgetAction(self._layout_combo)
self._layout_combo_action.setDefaultWidget(self._layout_combo)
toolbar.addAction(self._layout_combo_action)
self._layout_combo.layout_changed.connect(
self._slice_view_widget.set_plot_layout)
# self._colormap_combo = ColormapCombo(['seismic', 'spectral', 'RdGy', 'hot', 'jet', 'gray'])
self._colormap_combo = ColormapCombo(color_maps)
self._colormap_combo.currentIndexChanged[int].connect(
self._colormap_changed)
toolbar.addWidget(self._colormap_combo)
self._save_button = QToolButton()
self._save_button.setToolTip("Save as image")
self._save_button.setIcon(resource_icon("table_export.png"))
self._save_button.clicked.connect(self._save_figure)
toolbar.addWidget(self._save_button)
self._settings_button = QToolButton()
self._settings_button.setToolTip("Toggle settings visibility")
self._settings_button.setIcon(resource_icon("cog.png"))
self._settings_button.setCheckable(True)
self._settings_button.toggled.connect(self._show_settings)
toolbar.addWidget(self._settings_button)
self._help_button = QToolButton()
self._help_button.setToolTip("View help")
self._help_button.setIcon(resource_icon("help.png"))
self._help_button.setCheckable(True)
self._help_button.toggled.connect(self._show_help)
toolbar.addWidget(self._help_button)
def toggle_on_close(event):
self._settings_button.setChecked(False)
event.accept()
def toggle_on_close_help(event):
self._help_button.setChecked(False)
event.accept()
self._settings_window.closeEvent = toggle_on_close
self._help_window.closeEvent = toggle_on_close_help
self._colormap_combo.setCurrentIndex(45)
self.set_default_layout()
return toolbar
def _initContextMenu(self):
self._menu = [QMenu("Meter"), QMenu("Grid"), QMenu("Transform")]
meter_menu = self._menu[0]
cross_act = QWidgetAction(meter_menu)
cross_act.setDefaultWidget(self._show_cross_cb)
meter_menu.addAction(cross_act)
grid_menu = self._menu[1]
show_x_act = QWidgetAction(grid_menu)
show_x_act.setDefaultWidget(self._show_x_grid_cb)
grid_menu.addAction(show_x_act)
show_y_act = QWidgetAction(grid_menu)
show_y_act.setDefaultWidget(self._show_y_grid_cb)
grid_menu.addAction(show_y_act)
opacity_act = QWidgetAction(grid_menu)
widget = QWidget()
layout = QHBoxLayout()
layout.addWidget(QLabel("Opacity"))
layout.addWidget(self._grid_opacity_sld)
widget.setLayout(layout)
opacity_act.setDefaultWidget(widget)
grid_menu.addAction(opacity_act)
transform_menu = self._menu[2]
log_x_act = QWidgetAction(transform_menu)
log_x_act.setDefaultWidget(self._log_x_cb)
transform_menu.addAction(log_x_act)
log_y_act = QWidgetAction(transform_menu)
log_y_act.setDefaultWidget(self._log_y_cb)
transform_menu.addAction(log_y_act)
def setup_context_menu(self):
"""
:return:
"""
self.custMenu = QMenu("Options")
self.gridMenu = QMenu('Grid')
# Grid Menu:
# -----------------------------------------------------------
# Y-Grid checkbox
self.xGrid_Checkbox = QCheckBox()
self.xGrid_Checkbox.stateChanged.connect(self.contextMenu_xGrid_toogle)
self.xGrid_Checkbox.setText('X-Grid')
self.xGrid_Action = QWidgetAction(self.__plotWidget__)
self.xGrid_Action.setDefaultWidget(self.xGrid_Checkbox)
self.gridMenu.addAction(self.xGrid_Action)
# Check config for startup state
if self.__show_grid_x__:
self.xGrid_Checkbox.setChecked(True)
# X-Grid checkbox
self.yGrid_Checkbox = QCheckBox()
self.yGrid_Checkbox.stateChanged.connect(self.contextMenu_yGrid_toogle)
self.yGrid_Checkbox.setText('Y-Grid')
self.yGrid_Action = QWidgetAction(self.__plotWidget__)
self.yGrid_Action.setDefaultWidget(self.yGrid_Checkbox)
self.gridMenu.addAction(self.yGrid_Action)
# Check config for startup state
if self.__show_grid_y__:
self.yGrid_Checkbox.setChecked(True)
# add Menus
self.custMenu.addMenu(self.gridMenu)
self.__plotWidget__.getPlotItem().getViewBox().menu.clear()
self.__plotWidget__.getPlotItem().ctrlMenu = [self.pl_create_control_context_menu(), self.custMenu]
def create_actions(self):
self.toolBar.addAction(self.actionSaveState)
self.toolBar.setToolButtonStyle(Qt.ToolButtonTextUnderIcon)
self.actionSaveState.setIcon(svg_icon(":/adsdemo/images/save.svg"))
self.toolBar.addAction(self.actionRestoreState)
self.actionRestoreState.setIcon(
svg_icon(":/adsdemo/images/restore.svg"))
self.save_perspective_action = QAction("Create Perspective", self)
self.save_perspective_action.setIcon(
svg_icon(":/adsdemo/images/picture_in_picture.svg"))
self.save_perspective_action.triggered.connect(self.save_perspective)
self.perspective_list_action = QWidgetAction(self)
self.perspective_combo_box = QComboBox(self)
self.perspective_combo_box.setSizeAdjustPolicy(
QComboBox.AdjustToContents)
self.perspective_combo_box.setSizePolicy(QSizePolicy.Preferred,
QSizePolicy.Preferred)
self.perspective_list_action.setDefaultWidget(
self.perspective_combo_box)
self.toolBar.addSeparator()
self.toolBar.addAction(self.perspective_list_action)
self.toolBar.addAction(self.save_perspective_action)
a = self.toolBar.addAction("Create Floating Editor")
a.setProperty("Floating", True)
a.setToolTip(
"Creates floating dynamic dockable editor windows that are deleted on close"
)
a.setIcon(svg_icon(":/adsdemo/images/note_add.svg"))
a.triggered.connect(self.create_editor)
self.menuTests.addAction(a)
a = self.toolBar.addAction("Create Docked Editor")
a.setProperty("Floating", False)
a.setToolTip(
"Creates a docked editor windows that are deleted on close")
a.setIcon(svg_icon(":/adsdemo/images/docked_editor.svg"))
a.triggered.connect(self.create_editor)
self.menuTests.addAction(a)
a = self.toolBar.addAction("Create Floating Table")
a.setToolTip(
"Creates floating dynamic dockable table with millions of entries")
a.setIcon(svg_icon(":/adsdemo/images/grid_on.svg"))
a.triggered.connect(self.create_table)
self.menuTests.addAction(a)
self.menuTests.addSeparator()
a = self.menuTests.addAction("Show Status Dialog")
a.triggered.connect(self.show_status_dialog)
self.menuTests.addSeparator()
