def makeDisplay(self):
layout = QGridLayout(self)
wordLabel = QLabel(self)
self.wordLabel = wordLabel
font = wordLabel.font()
font.setPointSize(32)
font.setBold(True)
wordLabel.setFont(font)
layout.addWidget(wordLabel, 0, 0, 1, 6)
layout.setMargin(10)
group = QButtonGroup(self)
self.group = group
self.buttons = []
for i in range(4):
scoreButton = QPushButton(self, text=str(i))
scoreButton.setCheckable(True)
if i == 0:
scoreButton.setChecked(True)
scoreButton.setMaximumWidth(40)
group.addButton(scoreButton, i)
layout.addWidget(scoreButton, 1, i)
self.buttons.append(scoreButton)
self.modelSimilarity = QLabel(self, text='')
layout.addWidget(self.modelSimilarity, 2, 0)
self.setLayout(layout)
def _create_switch(self, box, layout, col, labels):
if labels is None:
return None
l = QLabel(labels[0], box)
l.setMinimumHeight(20)
l.setAlignment(Qt.AlignCenter | Qt.AlignBottom)
font = l.font()
font.setPointSize(7)
font.setBold(True)
l.setFont(font)
layout.addWidget(l, 3, col, Qt.AlignBottom | Qt.AlignCenter)
r1 = QRadioButton(box)
r1.setStyleSheet(
'QRadioButton::indicator{subcontrol-position:center;}')
layout.addWidget(r1, 4, col, Qt.AlignCenter)
r2 = QRadioButton(box)
r2.setStyleSheet(
'QRadioButton::indicator{subcontrol-position:center;}')
layout.addWidget(r2, 5, col, Qt.AlignCenter)
l = QLabel(labels[1], box)
l.setAlignment(Qt.AlignCenter)
l.setFont(font)
layout.addWidget(l, 6, col, Qt.AlignTop | Qt.AlignCenter)
g = QButtonGroup(box)
g.addButton(r1)
g.addButton(r2)
r1.setChecked(True)
return r2
class ChooseOneOfWidget(QWidget):
toggled = Signal(int, bool)
def __init__(self, title: str, index_to_label: Dict[int, str], is_vertical=True,
checked_index: Optional[int] = None, parent=None):
super().__init__(parent)
self.__mapping = {}
self.__main_layout = QVBoxLayout()
self.__group_box = QGroupBox(title)
self.__button_group = QButtonGroup()
if is_vertical:
self.__group_box_layout = QVBoxLayout()
else:
self.__group_box_layout = QHBoxLayout()
for index, label in index_to_label.items():
button = QRadioButton(label)
self.__button_group.addButton(button, index)
self.__group_box_layout.addWidget(button)
if checked_index == index:
button.setChecked(True)
self.__group_box.setLayout(self.__group_box_layout)
self.__button_group.idToggled.connect(self.__on_toggled)
self.__main_layout.addWidget(self.__group_box)
self.setLayout(self.__main_layout)
@Slot(int, bool)
def __on_toggled(self, index, is_checked):
self.toggled.emit(index, is_checked)
def get_checked(self) -> int:
return self.__button_group.checkedId()
def __init__(self, embedded: bool = False, parent: QWidget = None):
super().__init__(parent)
self._embedded = embedded
self._frame_width = VisionStyle.FRAME_WIDTH
self._frame_color = VisionStyle.EXTERNAL_FRAME_COLOR
self.man_button = GenderButton('M')
self.man_button.setChecked(True)
self.man_button.toggled.connect(self.gender_changed)
self.woman_button = GenderButton('W', add_left_border=True)
gender_button_group = QButtonGroup(self)
gender_button_group.addButton(self.man_button)
gender_button_group.addButton(self.woman_button)
h_layout = QHBoxLayout(self)
h_layout.setContentsMargins(0, 0, 0, 0)
h_layout.setSpacing(0)
h_layout.addWidget(self.man_button)
h_layout.addWidget(self.woman_button)
if not self._embedded:
self.setFrameStyle(QFrame.Box)
self.setStyleSheet(
f'GenderWidget {{ border: {self.frame_width}px solid '
f'{self.frame_color.name()}; }}')
class SimSpeedControls(QHBoxLayout):
def __init__(self,
sim_controller: SimController,
parent: Optional[QWidget] = None) -> None:
super().__init__(parent)
self.sim_controller = sim_controller
self.button_group = QButtonGroup(self)
self.buttons: dict[SimSpeedSetting, QPushButton] = {}
for speed_setting in SimSpeedSetting:
button = QPushButton(speed_setting.text)
button.setCheckable(True) # TODO: CSS
self.button_group.addButton(button, id=speed_setting.speed_factor)
self.addWidget(button)
self.buttons[speed_setting] = button
self.button_group.idPressed.connect(self.speed_changed)
self.sim_controller.sim_speed_reset.connect(self.on_sim_speed_reset)
def speed_changed(self, speed_factor: int) -> None:
setting = SimSpeedSetting.from_factor(speed_factor)
self.sim_controller.set_simulation_speed(setting)
def on_sim_speed_reset(self, speed_setting: SimSpeedSetting) -> None:
self.buttons[speed_setting].setChecked(True)
class ButtonGroupWidget(QGroupBox):
def __init__(self, parent=None):
super(ButtonGroupWidget, self).__init__(parent)
self._selectedOption = -1
self.buttonGroup = QButtonGroup()
self.layoutGroupBox = QVBoxLayout(self)
def addRadioButton(self, optionText, optionId):
print(optionText)
radioButton = QRadioButton(optionText)
radioButton.clicked.connect(self.updateOptionSelected)
self.layoutGroupBox.addWidget(radioButton)
self.buttonGroup.addButton(radioButton, optionId)
def updateOptionSelected(self):
# print(self.buttonGroup.checkedId()) # for test purpose
# self.selectedOption = self.buttonGroup.checkedId()
# print(self._selectedOption) # for test purpose
self.selectedOption = self.buttonGroup.checkedId()
QApplication.postEvent(
self, QKeyEvent(QEvent.KeyPress, Qt.Key_Enter, Qt.NoModifier))
def getSelectedOption(self):
print("get selectedOption is called")
return self._selectedOption
def setSelectedOption(self, selectedOption):
# print ("selectedOption",selectedOption)
print("set selectedOption is called")
self._selectedOption = selectedOption
self.buttonGroup.button(selectedOption).setChecked(True)
selectedOption = Property(int, getSelectedOption, setSelectedOption)
class ElchRibbon(QWidget):
def __init__(self, menus=None, *args, **kwargs):
super().__init__(*args, **kwargs)
self.setAttribute(Qt.WA_StyledBackground, True)
self.menus = menus if menus is not None else [
'Devices', 'Control', 'Setpoints', 'PID', 'Plotting', 'Logging'
]
self.menu_buttons = {
key: QPushButton(parent=self, objectName=key)
for key in self.menus
}
self.buttongroup = QButtonGroup()
elchicon = QLabel()
elchicon.setPixmap(QPixmap('Icons/ElchiHead.png'))
vbox = QVBoxLayout()
vbox.addWidget(elchicon, alignment=Qt.AlignHCenter)
for key in self.menus:
vbox.addWidget(self.menu_buttons[key])
self.buttongroup.addButton(self.menu_buttons[key])
self.menu_buttons[key].setCheckable(True)
self.menu_buttons[key].setFixedSize(150, 100)
vbox.addStretch()
vbox.setContentsMargins(0, 0, 0, 0)
vbox.setSpacing(0)
self.setMinimumWidth(150)
self.setLayout(vbox)
def group(self):
bg = QButtonGroup(self)
for w in self.widgets:
try:
bg.addButton(w.switch)
except AttributeError:
pass
bg.exclusive()
def __init__(self):
self.widget = QWidget()
layout = QVBoxLayout()
self.widget.setLayout(layout)
# Section Buttons
load_image_button = QPushButton("Load Section")
layout.addWidget(load_image_button)
load_image_button.clicked.connect(self.show_load_image_dialog)
load_image_button2 = QPushButton("Quick Load Section")
layout.addWidget(load_image_button2)
load_image_button2.clicked.connect(lambda: self.load_section(
"data/RA_10X_scans/MeA/S1_07032020.ome.tiff"))
# Scale Slider (Set Section Resolution)
self.resample_widget = LabelledSliderWidget(min=15,
max=200,
label="Scale")
layout.addLayout(self.resample_widget.layout)
self.resample_widget.connect(
lambda val: self.set_section_image_resolution(val))
self.dim_widgets = []
for dim in [
'right', 'superior', 'anterior', 'rot_lateral', 'rot_axial',
'rot_median'
]:
widget = LabelledSliderWidget(
min=-10000 if not dim.startswith('rot_') else -180,
max=10000 if not dim.startswith('rot_') else 180,
label=dim)
layout.addLayout(widget.layout)
fun = lambda d, value: self.transform_section(**{d: value})
widget.connect(partial(fun, dim))
self.dim_widgets.append((widget, fun))
# Atlas BUttons
button_hbox = QHBoxLayout()
layout.addLayout(button_hbox)
atlas_buttons = QButtonGroup(self.widget)
atlas_buttons.setExclusive(True)
atlas_buttons.buttonToggled.connect(self.atlas_button_toggled)
for resolution in [100, 25, 10]:
atlas_button = QPushButton(f"{resolution}um")
atlas_button.setCheckable(True)
button_hbox.addWidget(atlas_button)
atlas_buttons.addButton(atlas_button)
# The 10um atlas takes way too long to download at the moment.
# It needs some kind of progress bar or async download feature to be useful.
# The disabled button here shows it as an option for the future, but keeps it from being used.
if resolution == 10:
atlas_button.setDisabled(True)
class ChannelSelector(QWidget):
channelSelected = Signal(str)
channelDeselected = Signal(str)
def __init__(self):
QWidget.__init__(self)
self.setLayout(QGridLayout())
self.control_group = QButtonGroup()
self.control_group.setExclusive(False)
self.control_group.idToggled.connect(self.notifyChannel)
self.ids_to_channels = {} # {id: channel_name (str)}
self.checkboxes = {} # {channel_name: QCheckBox}
self.next_id = 0
# TODO(jacob): 4 columns is mostly an arbitrary choice; 5 seemed
# too crowded, 3 seemed too empty. Ideally we'd change this
# dynamically based on the column width.
self.num_cols = 4
def add_checkbox(self, channel_name):
if channel_name in self.checkboxes:
warnings.warn('attempted to add a duplicate checkbox to the DAQ channel selector')
return
checkbox = QCheckBox(channel_name)
self.checkboxes[channel_name] = checkbox
num_widgets = len(self.checkboxes)
row = (num_widgets - 1) // self.num_cols
col = (num_widgets - 1) % self.num_cols
self.layout().addWidget(checkbox, row, col)
self.control_group.addButton(checkbox, self.next_id)
self.ids_to_channels[self.next_id] = channel_name
self.next_id += 1
def clear_checkboxes(self):
for checkbox in self.checkboxes.values():
self.control_group.removeButton(checkbox)
self.layout().removeWidget(checkbox)
checkbox.deleteLater()
self.checkboxes = {}
self.ids_to_channels = {}
@Slot(top.PlumbingEngine)
def updateNodeList(self, plumb):
self.clear_checkboxes()
for node in plumb.nodes(data=False):
self.add_checkbox(node)
@Slot(int)
def notifyChannel(self, checkbox_id, is_checked):
channel = self.ids_to_channels[checkbox_id]
if is_checked:
self.channelSelected.emit(channel)
else:
self.channelDeselected.emit(channel)
def displayWidgets(self):
# create label and button widgets
title = QLabel("Вечерний опрос")
title.setFont(QFont('Arial', 17))
question = QLabel("Насколько плодотворно прошел Ваш день?")
question.setAlignment(Qt.AlignHCenter)
# согдание горизонтального layout-а
title_h_box = QHBoxLayout()
title_h_box.addStretch()
title_h_box.addWidget(title)
title_h_box.addStretch()
# Варианты выбора
ratings = ["Ужасно", "Ну, такое", "Нормально", "Отлично"]
ratings_h_box = QHBoxLayout()
# Устанавливаем расстояние между виджетами в горизонтальном layout-е
ratings_h_box.setSpacing(80)
ratings_h_box.addStretch()
for rating in ratings:
rate_label = QLabel(rating, self)
ratings_h_box.addWidget(rate_label)
ratings_h_box.addStretch()
cb_h_box = QHBoxLayout()
# расстояние между виджетами в горизонтальном layout-е
cb_h_box.setSpacing(100)
# Создаем контейнер для групировки QCheckBox
scale_bg = QButtonGroup(self)
cb_h_box.addStretch()
for cb in range(len(ratings)):
scale_cb = QCheckBox(str(cb), self)
cb_h_box.addWidget(scale_cb)
scale_bg.addButton(scale_cb)
cb_h_box.addStretch()
# устанавливаем функцию отработки варианта выбора
scale_bg.buttonClicked.connect(self.checkboxClicked)
close_button = QPushButton("Закрыть", self)
close_button.clicked.connect(self.close)
# Компануем вертикальный layout последовательно
# добавляя виджеты and элементы h_box layout
v_box = QVBoxLayout()
v_box.addLayout(title_h_box)
v_box.addWidget(question)
v_box.addStretch(1)
v_box.addLayout(ratings_h_box)
v_box.addLayout(cb_h_box)
v_box.addStretch(2)
v_box.addWidget(self.label)
v_box.addWidget(close_button)
self.setLayout(v_box)
class basicWindow(QWidget):
def __init__(self):
super().__init__()
self.label = QLabel('Which city do you live in?')
self.rbtn1 = QRadioButton('New York')
self.rbtn2 = QRadioButton('Houston')
self.label2 = QLabel("")
self.label3 = QLabel('Which state do you live in?')
self.rbtn3 = QRadioButton('New York')
self.rbtn4 = QRadioButton('Texas')
self.label4 = QLabel("")
self.btngroup1 = QButtonGroup()
self.btngroup2 = QButtonGroup()
self.btngroup1.addButton(self.rbtn1)
self.btngroup1.addButton(self.rbtn2)
self.btngroup2.addButton(self.rbtn3)
self.btngroup2.addButton(self.rbtn4)
self.rbtn1.toggled.connect(self.onClicked)
self.rbtn2.toggled.connect(self.onClicked)
self.rbtn3.toggled.connect(self.onClickedState)
self.rbtn4.toggled.connect(self.onClickedState)
layout = QVBoxLayout()
layout.addWidget(self.label)
layout.addWidget(self.rbtn1)
layout.addWidget(self.rbtn2)
layout.addWidget(self.label2)
layout.addWidget(self.label3)
layout.addWidget(self.rbtn3)
layout.addWidget(self.rbtn4)
layout.addWidget(self.label4)
self.setGeometry(200, 200, 300, 150)
self.setLayout(layout)
self.setWindowTitle('Radio Button Example')
self.show()
def onClicked(self):
radioBtn = self.sender()
if radioBtn.isChecked():
self.label2.setText("You live in " + radioBtn.text())
def onClickedState(self):
radioBtn = self.sender()
if radioBtn.isChecked():
self.label4.setText("You live in " + radioBtn.text())
class ElchPlotMenu(QWidget):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
controls = ['Start', 'Clear', 'Export']
self.buttons = {
key: QPushButton(parent=self, text=key, objectName=key)
for key in controls
}
self.buttons['Start'].setCheckable(True)
self.checks = {
key: QCheckBox(parent=self, text=key, objectName=key)
for key in ['Sensor PV', 'Controller PV', 'Setpoint', 'Power']
}
self.check_group = QButtonGroup()
self.check_group.setExclusive(False)
vbox = QVBoxLayout()
vbox.addWidget(QLabel(text='Plotting', objectName='Header'))
for key in controls:
vbox.addWidget(self.buttons[key])
self.buttons[key].clicked.connect({
'Start':
functools.partial(self.start_stop_plotting),
'Clear':
self.clear_pplot,
'Export':
self.export_data
}[key])
vbox.addSpacing(20)
vbox.addWidget(QLabel(text='Data sources', objectName='Header'))
for key, button in self.checks.items():
button.setChecked(True)
self.check_group.addButton(button)
vbox.addWidget(button)
vbox.addStretch()
vbox.setSpacing(10)
vbox.setContentsMargins(10, 10, 10, 10)
self.setLayout(vbox)
def start_stop_plotting(self):
pubsub.pub.sendMessage('gui.plot.start' if self.buttons['Start'].
isChecked() else 'gui.plot.stop')
def clear_pplot(self):
pubsub.pub.sendMessage('gui.plot.clear')
if self.buttons['Start'].isChecked():
self.buttons['Start'].click()
def export_data(self):
if (file_path := QFileDialog.getSaveFileName(
self, 'Save as...', 'Logs/Log.csv', 'CSV (*.csv)')[0]) != '':
pubsub.pub.sendMessage('gui.plot.export', filepath=file_path)
def _init(self):
print("Building...")
self.win = QMainWindow()
self._default_window_title = self.title
widget = QWidget()
self.win.setCentralWidget(widget)
main_layout = QHBoxLayout()
widget.setLayout(main_layout)
main_layout.addWidget(self.slice_widget)
main_layout.addWidget(self.volume_widget)
side_layout = QVBoxLayout()
main_layout.addLayout(side_layout)
load_image_button = QPushButton("Load Section")
side_layout.addWidget(load_image_button)
load_image_button.clicked.connect(self.show_load_image_dialog)
# Atlas BUttons
button_hbox = QHBoxLayout()
side_layout.addLayout(button_hbox)
atlas_buttons = QButtonGroup(self.win)
atlas_buttons.setExclusive(True)
atlas_buttons.buttonToggled.connect(self.atlas_button_toggled)
for resolution in [100, 25, 10]:
atlas_button = QPushButton(f"{resolution}um")
atlas_button.setCheckable(True)
button_hbox.addWidget(atlas_button)
atlas_buttons.addButton(atlas_button)
# The 10um atlas takes way too long to download at the moment.
# It needs some kind of progress bar or async download feature to be useful.
# The disabled button here shows it as an option for the future, but keeps it from being used.
if resolution == 10:
atlas_button.setDisabled(True)
self.title_reset_timer = Timer(interval=2, connect=lambda e: self._show_default_window_title(), iterations=1,
start=False)
self._show_default_window_title()
self.statusbar = self.win.statusBar()
self.image_coord_label = QLabel(text="Image Coords")
self.statusbar.addPermanentWidget(self.image_coord_label)
self.win.show()
def displayWidgets(self):
"""
Configura os widgets da app
"""
titl_lbl = QLabel("Pizzaria Pinocchio")
titl_lbl.setFont(QFont("Arial", 17))
qust_lbl = QLabel("Como você classificaria o atendimento hoje?")
titl_hbox = QHBoxLayout()
titl_hbox.addStretch()
titl_hbox.addWidget(titl_lbl)
titl_hbox.addStretch()
escala = ["Insatisfeito", "Médio", "Satisfeito"]
escala_hbox = QHBoxLayout()
escala_hbox.setSpacing(60)
escala_hbox.addStretch()
for eval in escala:
eval_lbl = QLabel(eval, self)
escala_hbox.addWidget(eval_lbl)
escala_hbox.addStretch()
btng_hbox = QHBoxLayout()
btng_hbox.setSpacing(100)
escala_bgrp = QButtonGroup(self)
btng_hbox.addStretch()
for btn in range(len(escala)):
eval_chkb = QCheckBox(str(btn), self)
btng_hbox.addWidget(eval_chkb)
escala_bgrp.addButton(eval_chkb)
btng_hbox.addStretch()
escala_bgrp.buttonClicked.connect(self.checkboxClicked)
close_btn = QPushButton("Fechar", self)
close_btn.clicked.connect(self.close)
vbox = QVBoxLayout()
vbox.addLayout(titl_hbox)
vbox.addWidget(qust_lbl)
vbox.addStretch(1)
vbox.addLayout(escala_hbox)
vbox.addLayout(btng_hbox)
vbox.addStretch(2)
vbox.addWidget(close_btn)
self.setLayout(vbox)
class MangaTrackerConfigWindow(QDialog, ui_configdialog.Ui_ConfigDialog):
def __init__(self, parent=None):
super(MangaTrackerConfigWindow, self).__init__(parent)
self.setupUi(self)
self.config = Config()
self.database_name_text.setText(self.config.database_name)
# Set up Show Empty Series option
self.show_empty_series_button_group = QButtonGroup()
self.show_empty_series_button_group.addButton(
self.show_empty_series_yes_button, 1)
self.show_empty_series_button_group.addButton(
self.show_empty_series_no_button, 0)
if self.config.show_empty_series:
self.show_empty_series_yes_button.setChecked(True)
else:
self.show_empty_series_no_button.setChecked(True)
# Set up Default to GUI option
self.default_to_gui_button_group = QButtonGroup()
self.default_to_gui_button_group.addButton(
self.default_to_gui_yes_button, 1)
self.default_to_gui_button_group.addButton(
self.default_to_gui_no_button, 0)
if self.config.default_to_gui:
self.default_to_gui_yes_button.setChecked(True)
else:
self.default_to_gui_no_button.setChecked(True)
self.config_save.clicked.connect(self.save_changes)
self.config_cancel.clicked.connect(self.close)
def save_changes(self):
show_empty_series = self.show_empty_series_button_group.checkedId()
self.config.set_property("show_empty_series", show_empty_series)
default_to_gui = self.default_to_gui_button_group.checkedId()
self.config.set_property("default_to_gui", default_to_gui)
name = self.database_name_text.text()
self.results_dialog = QMessageBox()
if name == self.config.database_name:
self.close()
elif is_database(name):
self.config.set_property("database_name", name)
self.results_dialog.setText("Database name has been changed. ")
self.results_dialog.show()
# set up database if table doesn't exist
DatabaseManager(name, init_database, False)
self.close()
else:
self.results_dialog.setText("Database name must match "
"the format *.db and not be "
"a pre-existing file.")
self.results_dialog.show()
class StartMineSchedDialog(QDialog):
# 定义选择信号
start_minesched_signal = Signal(str)
# 初始化
def __init__(self, config: ConfigFactory, logger: LoggerFactory,
title: str):
super(StartMineSchedDialog, self).__init__()
self.config = config
self.logger = logger
self.setWindowTitle(title)
self.setModal(True)
self.setWindowFlag(Qt.WindowContextHelpButtonHint, False)
self.layout = QVBoxLayout()
self.setLayout(self.layout)
self.start_minesched_button_group = QButtonGroup()
self.start_minesched_button_group.setExclusive(True)
self.buttons = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel, Qt.Horizontal, self)
self.minescheds = []
self.minesched_id = -1
# 设置MineSched不同版本列表
def set_minescheds(self, minescheds: list):
self.minescheds = minescheds
for _id, minesched in enumerate(self.minescheds):
minesched_item = QRadioButton(minesched)
self.start_minesched_button_group.addButton(minesched_item)
self.start_minesched_button_group.setId(minesched_item, _id)
if _id == 0:
minesched_item.setChecked(True)
self.minesched_id = 0
self.layout.addWidget(minesched_item)
self.start_minesched_button_group.buttonClicked.connect(
self.start_minesched_change)
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
self.layout.addWidget(self.buttons)
# 如果单击ok按钮
def accept(self):
# 先关闭对话框，然后发送消息
super(StartMineSchedDialog, self).accept()
self.config.set_config('minesched', 'minesched_location',
self.minescheds[self.minesched_id])
# 发送surpac启动消息
self.start_minesched_signal.emit(self.minescheds[self.minesched_id])
def start_minesched_change(self):
self.minesched_id = self.start_minesched_button_group.checkedId()
def setup_ui(self):
loader = QUiLoader()
file = QFile('./media/main_window.ui')
file.open(QFile.ReadOnly)
self._window = loader.load(file)
file.close()
self.set_title()
self.set_buttons()
# Setup combobox
self._window.transportation_combo.addItem('HSR', 'HighSpeedRail')
self._window.transportation_combo.addItem('Taxi', 'Uber,Taxi')
self._window.transportation_combo.addItem('Drive', 'Car')
self._window.transportation_combo.addItem('Scooter', 'Motorcycle')
# Setup RadioButton / CheckBox
self._window.yes_radio.setChecked(False)
self._window.no_radio.setChecked(True)
vegetarian_group = QButtonGroup(self._window)
vegetarian_group.setExclusive(True)
vegetarian_group.addButton(self._window.yes_radio)
vegetarian_group.addButton(self._window.no_radio)
self._window.absolutly_check.setChecked(True)
self._window.maybe_check.setChecked(False)
self._window.sorry_check.setChecked(False)
participate_group = QButtonGroup(self._window)
participate_group.setExclusive(True)
participate_group.addButton(self._window.absolutly_check)
participate_group.addButton(self._window.maybe_check)
participate_group.addButton(self._window.sorry_check)
# Setup SpinBox
self._window.members_spin.setRange(1, 10)
class ChoiceSurpacDialog(QDialog):
# 定义选择信号
choices_surpac_signal = Signal(str)
# 初始化
def __init__(self, config: ConfigFactory, logger: LoggerFactory,
title: str, surpacs: list):
super(ChoiceSurpacDialog, self).__init__()
self.config = config
self.logger = logger
self.setWindowTitle(title)
self.setModal(True)
self.setWindowFlag(Qt.WindowContextHelpButtonHint, False)
self.surpacs = surpacs
self.choice_surpac_button_group = QButtonGroup()
self.choice_surpac_button_group.setExclusive(True)
layout = QVBoxLayout()
for surpac_id, choice in enumerate(surpacs):
surpac_item = QRadioButton(choice)
self.choice_surpac_button_group.addButton(surpac_item)
self.choice_surpac_button_group.setId(surpac_item, surpac_id)
if surpac_id == 0:
surpac_item.setChecked(True)
self.surpac_id = 0
layout.addWidget(surpac_item)
self.choice_surpac_button_group.buttonClicked.connect(
self.choice_surpac_change)
self.buttons = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel, Qt.Horizontal, self)
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
layout.addWidget(self.buttons)
self.setLayout(layout)
def accept(self):
# 先关闭对话框，然后发送消息
super(ChoiceSurpacDialog, self).accept()
if self.config.get('master',
'surpac_location') == self.surpacs[self.surpac_id]:
pass
else:
self.choices_surpac_signal.emit(self.surpacs[self.surpac_id])
self.config.set_config('master', 'surpac_location',
self.surpacs[self.surpac_id])
def choice_surpac_change(self):
self.surpac_id = self.choice_surpac_button_group.checkedId()
class ColorAction(QWidgetAction):
colorSelected = Signal(QColor)
def __init__(self, parent=None, columns=int(0), rows=int(0), palette=list):
# QWidgetAction.__init__(self, parent)
super(ColorAction, self).__init__(parent)
self._columns = columns
self._rows = rows
if columns < 1:
self._columns = len(palette)
if rows < 1:
self._rows = len(palette)
self.palette = palette
self.init()
def init(self):
widget = QWidget()
layout = QGridLayout(widget)
layout.setSpacing(0)
layout.setContentsMargins(0, 0, 0, 0)
num = 0
self.ColorDict = dict()
self.ButtonList = QButtonGroup()
for column in range(self._columns):
for row in range(self._rows):
if num < len(self.palette):
newColor = self.palette[num]
button = QPushButton('')
button.setContentsMargins(0,0,0,0)
button.setStyleSheet("padding: 0px;margin: 0px;")
button.setFixedSize(20,20)
self.ColorDict[button] = self.palette[num]
self.ButtonList.addButton(button)
pixmap = QPixmap(20, 20)
pixmap.fill(newColor)
button.setIcon(QIcon(pixmap))
layout.addWidget(button, row, column)
num+=1
else:
break
self.ButtonList.buttonClicked.connect(self.handleButton)
self.setDefaultWidget(widget)
def handleButton(self, buttonID=QPushButton):
self.parent().hide()
self.colorSelected.emit(self.ColorDict[buttonID])
class View(QMainWindow, Ui_DsManager):
def __init__(self, *args, **kwargs):
super(View, self).__init__(*args, **kwargs)
self.setupUi(self)
def setupUi(self, DsManager):
super(View, self).setupUi(DsManager)
self.source_btn_group = QButtonGroup(self)
self.reversed_entry_btn_group = QButtonGroup(self)
self.source_btn_group.setExclusive(True)
self.reversed_entry_btn_group.setExclusive(True)
self.source_btn_group.addButton(self.cash_radio, 1)
self.source_btn_group.addButton(self.main_radio, 2)
self.source_btn_group.addButton(self.building_radio, 3)
self.reversed_entry_btn_group.addButton(self.reversed_entry_increase,
1)
self.reversed_entry_btn_group.addButton(self.reversed_entry_decrease,
2)
self.cheque_label.hide()
self.cheque_number.hide()
def view_pdf(self, pdf_js, pdf_file_name):
new_window = QMainWindow(self)
pdf_viewer = Ui_PDFViewer()
pdf_viewer.setupUi(new_window)
pdf_url = QUrl.fromLocalFile(pdf_js)
pdf_url.setQuery("file=" + pdf_file_name)
pdf_viewer.webView.load(pdf_url)
new_window.show()
@classmethod
def show_about_ds(cls):
dialog = QDialog()
about = Ui_About()
about.setupUi(dialog)
dialog.exec_()
@classmethod
def show_message(cls, message: str, logo: str):
msg = QMessageBox()
icon = QIcon()
icon.addFile(u"inc/icon.ico", QSize(), QIcon.Normal, QIcon.Off)
msg.setWindowIcon(icon)
if logo == "error":
msg.setIcon(QMessageBox.Critical)
elif logo == "info":
msg.setIcon(QMessageBox.Information)
msg.setText(message)
msg.setWindowTitle(logo)
msg.exec_()
def closeEvent(self, event):
model = Model()
model.close_connection()
event.accept()
def __init__(self):
super(MainWindow, self).__init__()
self.ui = Ui_QuestionnaireWidget()
self.ui.setupUi(self)
scale_bg = QButtonGroup(self)
scale_bg.addButton(self.ui.awfulCb)
scale_bg.addButton(self.ui.soSoCb)
scale_bg.addButton(self.ui.normalCb)
scale_bg.addButton(self.ui.excellentCb)
# устанавливаем метод отработки варианта выбора
scale_bg.buttonClicked.connect(self.checkboxClicked)
class LoginWidget(QWidget, Ui_LoginWidget):
def __init__(self):
super(LoginWidget, self).__init__()
self.setupUi(self)
self.loginButton.clicked.connect(self.login)
self.quitButton.clicked.connect(self.quit)
self.login_type = LoginType.STUDENT
self.radio_group = QButtonGroup(self)
self.radio_group.addButton(self.studentRadio, 0)
self.radio_group.addButton(self.teacherRadio, 1)
self.studentRadio.setChecked(True)
self.radio_group.buttonToggled.connect(self.toggle_login_type)
self.pwdInput.returnPressed.connect(self.login)
def login(self):
user_id = self.idInput.text()
pwd = self.pwdInput.text()
status = usermgr.login(self.login_type, user_id, pwd)
if status == 0:
user_name = usermgr.get_name()
QMessageBox.information(self, self.tr('Login Successful'),
self.tr('Welcome, {}!'.format(user_name)),
QMessageBox.Ok)
# print(m)
# self.hide()
self.close()
m = StudentMainWindow(self) if \
self.login_type == LoginType.STUDENT else \
TeacherMainWindow(self)
m.show()
else:
QMessageBox.critical(self, self.tr('Login Failed'),
self.tr('Wrong ID or password!'),
QMessageBox.Ok)
def toggle_login_type(self, selected_radio: int):
if selected_radio == self.studentRadio:
self.login_type = LoginType.STUDENT
elif selected_radio == self.teacherRadio:
self.login_type = LoginType.TEACHER
def quit(self):
self.close()
class DestinationRadioBox(QGroupBox):
def __init__(self, destinations):
super().__init__()
label = Heading('Card Destination')
label.setMinimumWidth(WIDTH)
label.setAlignment(Qt.AlignHCenter)
box = QVBoxLayout()
box.addWidget(label)
# Subclass QGroupBox for the *visual* container
self.setMaximumWidth(WIDTH_WITH_SCROLL)
# QButtonGroup is used for the *logical* grouping
self.b_group = QButtonGroup()
for button in destinations.values():
self.b_group.addButton(button)
box.addWidget(button)
self.setLayout(box)
def __init__(self, numwin: int):
super(QW_NumWin, self).__init__()
r1 = QRadioButton("one window")
r1.toggled.connect(self.checked)
r2 = QRadioButton("two window")
r2.toggled.connect(self.checked)
button_group_numwin = QButtonGroup()
button_group_numwin.addButton(r1)
button_group_numwin.addButton(r2)
if numwin == 1:
r1.setChecked(True)
else:
r2.setChecked(True)
self.layout_numwin = QHBoxLayout()
self.layout_numwin.addWidget(r1, alignment=Qt.AlignLeft)
self.layout_numwin.addWidget(r2, alignment=Qt.AlignLeft)
self.setLayout(self.layout_numwin)
class RadioLayout(QVBoxLayout):
"""Radio buttons layout with QButtonGroup"""
def __init__(self, buttons, index, parent=None):
QVBoxLayout.__init__(self)
self.setSpacing(0)
self.group = QButtonGroup()
for i, button in enumerate(buttons):
btn = QRadioButton(button)
if i == index:
btn.setChecked(True)
self.addWidget(btn)
self.group.addButton(btn, i)
def currentIndex(self):
return self.group.checkedId()
def setStyleSheet(self, style):
for btn in self.group.buttons():
btn.setStyleSheet(style)
class CheckHLayout(QHBoxLayout):
"""Check boxes hlayout with QButtonGroup"""
def __init__(self, boxes, checks, parent=None):
QHBoxLayout.__init__(self)
self.setSpacing(0)
self.group = QButtonGroup()
self.group.setExclusive(False)
for i, (box, check) in enumerate(zip(boxes, checks)):
cbx = QCheckBox(box)
cbx.setChecked(eval(check))
self.addWidget(cbx)
self.group.addButton(cbx, i)
def values(self):
return [cbx.isChecked() for cbx in self.group.buttons()]
def setStyleSheet(self, style):
for cbx in self.group.buttons():
cbx.setStyleSheet(style)
def __init__(self, parent):
super(WelcomePage, self).__init__(parent)
self.parent_wizard = weakref.proxy(parent)
self.setTitle('Welcome')
basic_radio = QRadioButton('&Basic')
basic_radio.setChecked(True)
self.advanced_radio = QRadioButton('&Advanced')
group = QButtonGroup(self)
group.addButton(basic_radio)
group.addButton(self.advanced_radio)
grid = QGridLayout(self)
grid.addWidget(basic_radio, 0, 0)
grid.addWidget(self.advanced_radio, 1, 0)
self.registerField('basic', basic_radio)
self.setLayout(grid)
class ChoiceLanguageDialog(QDialog):
# 定义选择信号
choices_language_dialog_signal = Signal(str)
# 初始化
def __init__(self, config: ConfigFactory, logger: LoggerFactory, title: str, languages: list):
super(ChoiceLanguageDialog, self).__init__()
self.config = config
self.logger = logger
self.setWindowTitle(title)
self.setModal(True)
self.setWindowFlag(Qt.WindowContextHelpButtonHint, False)
self.languages = languages
self.choice_language_button_group = QButtonGroup()
self.choice_language_button_group.setExclusive(True)
layout = QVBoxLayout()
for language_id, language in enumerate(languages):
# 显示语言提示
language_item = QRadioButton(language.split(':')[0])
self.choice_language_button_group.addButton(language_item)
self.choice_language_button_group.setId(language_item, language_id)
if language_id == 0:
language_item.setChecked(True)
self.language_id = 0
layout.addWidget(language_item)
self.choice_language_button_group.buttonClicked.connect(self.language_change)
self.buttons = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel, Qt.Horizontal, self)
self.buttons.accepted.connect(self.accept)
self.buttons.rejected.connect(self.reject)
layout.addWidget(self.buttons)
self.setLayout(layout)
def accept(self):
# 先关闭对话框，然后发送消息
super(ChoiceLanguageDialog, self).accept()
# 发送语言文件
language = self.languages[self.language_id].split(':')[1]
self.choices_language_dialog_signal.emit(language)
self.config.set_config('master', 'surpac_language_cfg', language)
def language_change(self):
self.language_id = self.choice_language_button_group.checkedId()
def __init__(self, parent):
super().__init__(parent)
self.parent_wizard = weakref.proxy(parent)
self.setTitle('Continuous criteria')
# Radio button, if yes then ask for inputs
self.yes = QRadioButton(
'&Yes, there are criteria that needs to be calculated')
no = QRadioButton(
'N&o, I will manually give a rating for every choice and criteria')
no.setChecked(True)
self.registerField('yes', self.yes)
self.yes.toggled.connect(self.toggled)
group = QButtonGroup(self)
group.addButton(self.yes)
group.addButton(no)
# Duplicated from AbstractMultiInputPage
self.line_edit = QLineEdit()
self.list_widget = QListWidget()
self.add_button = QPushButton('&Add criterion')
self.delete_button = QPushButton('&Delete')
self.line_edit.setDisabled(True)
self.list_widget.setDisabled(True)
self.add_button.setDisabled(True)
self.delete_button.setDisabled(True)
self.line_edit.returnPressed.connect(self.add_item)
self.add_button.clicked.connect(self.add_item)
self.delete_button.clicked.connect(self.delete_item)
grid = QGridLayout(self)
grid.addWidget(self.yes, 0, 0)
grid.addWidget(no, 1, 0)
grid.addWidget(self.line_edit, 2, 0)
grid.addWidget(self.add_button, 2, 1)
grid.addWidget(self.list_widget, 3, 0)
grid.addWidget(self.delete_button, 3, 1, Qt.AlignTop)
self.setLayout(grid)
