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)
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()
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()
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 __init__(self, current_path=None):
super(self.__class__, self).__init__()
self.setupUi(self)
# Create button group
self.grp_buttons = QButtonGroup()
self.btn_import.released.connect(self.import_asset)
self.initDB()
self.getJobs()
self.parseJobPath(current_path)
self.initJob()
self.populateStages()
self.populateEntities()
# Pre-set combo boxes
self.cmb_stages.setCurrentIndex(self.stages.index(self.stage_name))
self.cmb_jobs.setCurrentIndex(self.jobs.index(self.job_name))
self.cmb_entities.setCurrentIndex(self.entities.index(
self.entity_name))
self.le_in.tagSelected.connect(self.activate_tag)
self.cmb_jobs.currentIndexChanged.connect(self.change_job)
self.cmb_stages.currentIndexChanged.connect(self.change_stage)
self.cmb_entities.currentIndexChanged.connect(self.change_entity)
self.refresh_asset_list()
# Set stylesheet
self.setStyleSheet(hou.qt.styleSheet())
self.show()
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)
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
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 __init__(self, parent=None):
super().__init__(parent)
self.parent = parent
self.lca_scores_widget = LCAScoresTab(parent)
self.lca_overview_widget = LCIAResultsTab(parent)
self.layout.setAlignment(QtCore.Qt.AlignTop)
self.layout.addLayout(get_header_layout('LCA Results'))
# buttons
button_layout = QHBoxLayout()
self.button_group = QButtonGroup()
self.button_overview = QRadioButton("Overview")
self.button_overview.setToolTip(
"Show a matrix of all functional units and all impact categories")
button_layout.addWidget(self.button_overview)
self.button_by_method = QRadioButton("by LCIA method")
self.button_by_method.setToolTip(
"Show the impacts of each functional unit for the selected impact categories"
)
self.button_by_method.setChecked(True)
self.scenario_label = QLabel("Scenario:")
self.button_group.addButton(self.button_overview, 0)
self.button_group.addButton(self.button_by_method, 1)
button_layout.addWidget(self.button_by_method)
button_layout.addWidget(self.scenario_label)
button_layout.addWidget(self.scenario_box)
button_layout.addStretch(1)
self.layout.addLayout(button_layout)
self.layout.addWidget(self.lca_scores_widget)
self.layout.addWidget(self.lca_overview_widget)
self.button_clicked(False)
self.connect_signals()
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)
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 __init__(self, parent=None):
super().__init__(parent)
self.setupUi(self)
self.setStyleSheet(qss)
self.config_widget = parent
self.check_res = None
self.btn_group = QButtonGroup(self)
#
self.res.setWordWrap(True)
self.user.setFocus()
self.host.textChanged.connect(self.host_slot)
self.port.textChanged.connect(self.textChanged_slot)
self.user.textChanged.connect(self.textChanged_slot)
self.password.textChanged.connect(self.textChanged_slot)
self.database.textChanged.connect(self.textChanged_slot)
# 右键菜单
self.ava_table.horizontalHeader().setVisible(False)
self.ava_table.setContextMenuPolicy(
Qt.CustomContextMenu) ######允许右键产生子菜单
self.ava_table.customContextMenuRequested.connect(
self.generate_menu) ####右键菜单
# btn
self.test_btn.clicked.connect(self.test_btn_slot)
self.ok_btn.clicked.connect(self.ok_btn_slot)
self.host.setText('localhost')
self.port.setText('27017')
self.url.setPlaceholderText(
"mongodb://[user:password@]host:port/database")
#
self.thread_pool = QThreadPool()
self.sig = DBObject()
self.sig.dbsig.connect(self.db_connect_result)
def __init__(self, parent, db_mngr, *db_maps):
"""
Args:
parent (DataStoreForm): tree or graph view form
db_mngr (SpineDBManager): the DB manager for interacting with the db
db_maps (iter): DiffDatabaseMapping instances
"""
super().__init__("Parameter Tag Toolbar", parent=parent)
self.db_mngr = db_mngr
self.db_maps = db_maps
label = QLabel("Parameter tag")
self.addWidget(label)
self.tag_button_group = QButtonGroup(self)
self.tag_button_group.setExclusive(False)
self.actions = []
self.db_map_ids = []
empty = QWidget()
empty.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.empty_action = self.addWidget(empty)
button = QPushButton("Manage tags...")
self.addWidget(button)
# noinspection PyUnresolvedReferences
# pylint: disable=unnecessary-lambda
button.clicked.connect(lambda checked: self.manage_tags_action_triggered.emit(checked))
self.setStyleSheet(PARAMETER_TAG_TOOLBAR_SS)
self.setObjectName("ParameterTagToolbar")
self.tag_actions_added.connect(self._add_db_map_tag_actions)
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 __init__(self,
*args,
count: int,
title: Optional[str] = "",
selected: Optional[List] = None,
default: Optional[bool] = False,
**kwargs):
super(MultiCheckWidget, self).__init__(*args, **kwargs)
# QButtonGroup is the logical container
# it allows us to get list of checked boxes more easily
self.check_group = QButtonGroup()
self.check_group.setExclusive(False) # more than one can be checked
if title != "":
self.setTitle(title)
self.setFlat(False)
else:
self.setFlat(True)
if selected is None:
selected = list(range(count)) if default else []
check_layout = QGridLayout()
self.setLayout(check_layout)
for i in range(count):
check = QCheckBox("%d" % (i))
# call signal/slot on self when one of the checkboxes is changed
check.stateChanged.connect(lambda e: self.selectionChanged.emit())
self.check_group.addButton(check, i)
check_layout.addWidget(check, i // 8, i % 8)
self.setSelected(selected)
def initPenSizeButtons(self):
self.penSize = QWidget(self)
self.penSizeLayout = QHBoxLayout()
self.penSize.setLayout(self.penSizeLayout)
# adjust pen size
self.penSize1 = QPushButton(self.penSize)
self.penSize1.setIcon(QIcon(":/resource/icon/pensize1.png"))
self.penSize1.setObjectName('1')
self.penSize1.setFixedSize(self.iconWidth, self.iconHeight)
self.penSize1.setCheckable(True)
self.penSize2 = QPushButton(self.penSize)
self.penSize2.setIcon(QIcon(":/resource/icon/pensize2.png"))
self.penSize2.setObjectName('2')
self.penSize2.setFixedSize(self.iconWidth, self.iconHeight)
self.penSize2.setCheckable(True)
self.penSize3 = QPushButton(self.penSize)
self.penSize3.setIcon(QIcon(":/resource/icon/pensize3.png"))
self.penSize3.setObjectName('3')
self.penSize3.setFixedSize(self.iconWidth, self.iconHeight)
self.penSize3.setCheckable(True)
self.sizeButtonGroup = QButtonGroup(self.penSize)
self.sizeButtonGroup.addButton(self.penSize1)
self.sizeButtonGroup.addButton(self.penSize2)
self.sizeButtonGroup.addButton(self.penSize3)
self.sizeButtonGroup.buttonClicked.connect(self.sizeButtonToggled)
self.penSizeLayout.addWidget(self.penSize1)
self.penSizeLayout.addWidget(self.penSize2)
self.penSizeLayout.addWidget(self.penSize3)
self.penSizeLayout.setSpacing(5)
self.penSizeLayout.setContentsMargins(0, 0, 0, 0)
def __init__(self, parent):
super().__init__(parent)
self._scene = QGraphicsScene(self)
self._graphics_view = QGraphicsView(self._scene, self)
layout = QVBoxLayout(self)
layout.addWidget(self._graphics_view)
self._pixmap_item = SpriteGraphicsItem(self)
self._scene.addItem(self._pixmap_item)
self._image = QImage(SPRITE_SIZE, SPRITE_SIZE, QImage.Format_ARGB32)
self.sprite = [[0] * SPRITE_SIZE] * SPRITE_SIZE
button_layout = QHBoxLayout(self)
layout.addLayout(button_layout)
self._color_button_group = QButtonGroup(self)
for color in COLORS:
button = QPushButton(self)
button.setCheckable(True)
button.setText(f"{color}")
self._color_button_group.addButton(button, color)
button_layout.addWidget(button)
self._selected_color = 0
self._color_button_group.button(self._selected_color).setChecked(True)
QObject.connect(self._color_button_group, SIGNAL("buttonClicked(int)"),
self._color_selected)
self._update_scaling()
def initialize(self):
self.setDateTimeEdits()
self.dateButtonGroup = QButtonGroup()
self.categoryButtonGroup = QButtonGroup()
self.loadDateButtonGroup()
self.loadCategoryButtonGroup()
self.setDateGroupBoxStatus(self.RADIOBUTTON_ALL_DATES)
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 initDrawButtons(self, flags):
self.drawButtonGroup = QButtonGroup(self)
# draw action buttons
if flags & constant.RECT:
self.rectButton = QPushButton(self)
self.rectButton.setIcon(QIcon(":/resource/icon/rect.png"))
self.rectButton.setFixedSize(self.iconWidth, self.iconHeight)
self.rectButton.setCheckable(True)
self.drawButtonGroup.addButton(self.rectButton)
self.hlayout.addWidget(self.rectButton)
self.button_list.append(self.rectButton)
if flags & constant.ELLIPSE:
self.ellipseButton = QPushButton(self)
self.ellipseButton.setIcon(QIcon(":/resource/icon/ellipse.png"))
self.ellipseButton.setFixedSize(self.iconWidth, self.iconHeight)
self.ellipseButton.setCheckable(True)
self.drawButtonGroup.addButton(self.ellipseButton)
self.hlayout.addWidget(self.ellipseButton)
self.button_list.append(self.ellipseButton)
if flags & constant.ARROW:
self.arrowButton = QPushButton(self)
self.arrowButton.setIcon(QIcon(":/resource/icon/arrow.png"))
self.arrowButton.setFixedSize(self.iconWidth, self.iconHeight)
self.arrowButton.setCheckable(True)
self.drawButtonGroup.addButton(self.arrowButton)
self.hlayout.addWidget(self.arrowButton)
self.button_list.append(self.arrowButton)
if flags & constant.LINE:
self.lineButton = QPushButton(self)
self.lineButton.setIcon(QIcon(":/resource/icon/line.png"))
self.lineButton.setFixedSize(self.iconWidth, self.iconHeight)
self.lineButton.setCheckable(True)
self.drawButtonGroup.addButton(self.lineButton)
self.hlayout.addWidget(self.lineButton)
self.button_list.append(self.lineButton)
if flags & constant.FREEPEN:
self.freePenButton = QPushButton(self)
self.freePenButton.setIcon(QIcon(":/resource/icon/pen.png"))
self.freePenButton.setFixedSize(self.iconWidth, self.iconHeight)
self.freePenButton.setCheckable(True)
self.drawButtonGroup.addButton(self.freePenButton)
self.hlayout.addWidget(self.freePenButton)
self.button_list.append(self.freePenButton)
if flags & constant.TEXT:
self.textButton = QPushButton(self)
self.textButton.setIcon(QIcon(":/resource/icon/text.png"))
self.textButton.setFixedSize(self.iconWidth, self.iconHeight)
self.textButton.setCheckable(True)
self.drawButtonGroup.addButton(self.textButton)
self.hlayout.addWidget(self.textButton)
self.button_list.append(self.textButton)
self.drawButtonGroup.buttonClicked.connect(self.buttonToggled)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.labels = {
key: QLabel(text=key, objectName='Header')
for key in ['Controller', 'Sensor']
}
self.device_menus = {key: QComboBox() for key in self.labels}
self.port_menus = {key: QComboBox() for key in self.labels}
self.connect_buttons = {
key: QPushButton(text='Connect', objectName=key)
for key in self.labels
}
self.buttongroup = QButtonGroup()
self.buttongroup.setExclusive(False)
self.buttongroup.buttonToggled.connect(self.connect_device)
self.unitbuttons = {
key: QRadioButton(text=key)
for key in ['Temperature', 'Voltage']
}
self.refresh_button = QPushButton(text='Refresh Serial',
objectName='Refresh')
vbox = QVBoxLayout()
vbox.setSpacing(10)
vbox.setContentsMargins(10, 10, 10, 10)
vbox.addWidget(QLabel(text='Process Variable', objectName='Header'))
for key, button in self.unitbuttons.items():
vbox.addWidget(button)
button.toggled.connect(
functools.partial(self.set_measurement_unit, unit=key))
vbox.addSpacing(20)
for key in self.labels:
self.buttongroup.addButton(self.connect_buttons[key])
self.connect_buttons[key].setCheckable(True)
vbox.addWidget(self.labels[key])
vbox.addWidget(self.device_menus[key])
vbox.addWidget(self.port_menus[key])
vbox.addWidget(self.connect_buttons[key])
vbox.addSpacing(20)
vbox.addWidget(self.refresh_button)
self.refresh_button.clicked.connect(
lambda: pubsub.pub.sendMessage('gui.request.ports'))
vbox.addStretch()
self.setLayout(vbox)
pubsub.pub.subscribe(listener=self.update_ports,
topicName='engine.answer.ports')
pubsub.pub.subscribe(listener=self.update_devices,
topicName='engine.answer.devices')
pubsub.pub.sendMessage('gui.request.ports')
def initPenColorButtons(self):
self.colorSet = QWidget(self)
self.colorLayout = QHBoxLayout()
self.colorLayout.setSpacing(5)
self.colorLayout.setContentsMargins(5, 0, 5, 0)
self.colorSet.setLayout(self.colorLayout)
self.presentColor = QPushButton(self.colorSet)
self.presentColor.setFixedSize(self.iconWidth, self.iconHeight)
self.presentColor.setEnabled(False)
# adjust pen color
self.colorPick = QWidget(self.colorSet)
self.colorGrid = QGridLayout()
self.colorGrid.setSpacing(0)
self.colorGrid.setContentsMargins(5, 0, 5, 0)
self.colorPick.setLayout(self.colorGrid)
self.colorList = [('white' , '#ffffff'),
('red' , '#ff0000'),
('green' , '#00ff00'),
('blue' , '#0000ff'),
('cyan' , '#00ffff'),
('magenta' , '#ff00ff'),
('yellow' , '#ffff00'),
('gray' , '#a0a0a4'),
('black' , '#000000'),
('darkRed' , '#800000'),
('darkGreen' , '#008000'),
('darkBlue' , '#000080'),
('darkCyan' , '#008080'),
('darkMagenta' , '#800080'),
('darkYellow' , '#808000'),
('darkGray' , '#808080')]
self.generateButtons()
self.colorButtonGroup = QButtonGroup(self)
for button in self.colorButtons:
self.colorButtonGroup.addButton(button)
self.colorButtonGroup.buttonClicked.connect(self.colorButtonToggled)
# set the layout
tmp = 0
for x in range(0, 2):
for y in range(0, int(len(self.colorList) / 2)):
self.colorGrid.addWidget(self.colorButtons[tmp], x, y)
tmp += 1
self.colorGrid.setSpacing(0)
self.colorGrid.setContentsMargins(0, 0, 0, 0)
self.colorLayout.addWidget(self.presentColor)
self.colorLayout.addWidget(self.colorPick)
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 __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)
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())
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)
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)
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 _init_widgets(self):
layout = QGridLayout()
self.main_layout.addLayout(layout)
self._status_label = QLabel(self)
row = 0
layout.addWidget(QLabel('Break on:', self), row, 0, Qt.AlignRight)
self._type_radio_group = QButtonGroup(self)
self._type_radio_group.addButton(QRadioButton('Execute', self),
BreakpointType.Execute.value)
self._type_radio_group.addButton(QRadioButton('Write', self),
BreakpointType.Write.value)
self._type_radio_group.addButton(QRadioButton('Read', self),
BreakpointType.Read.value)
for b in self._type_radio_group.buttons():
layout.addWidget(b, row, 1)
row += 1
self._type_radio_group.button(
self.breakpoint.type.value).setChecked(True)
layout.addWidget(QLabel('Address:', self), row, 0, Qt.AlignRight)
self._address_box = QAddressInput(self._on_address_changed,
self.workspace,
parent=self,
default=f'{self.breakpoint.addr:#x}')
layout.addWidget(self._address_box, row, 1)
row += 1
layout.addWidget(QLabel('Size:', self), row, 0, Qt.AlignRight)
self._size_box = QLineEdit(self)
self._size_box.setText(f'{self.breakpoint.size:#x}')
self._size_box.textChanged.connect(self._on_size_changed)
layout.addWidget(self._size_box, row, 1)
row += 1
layout.addWidget(QLabel('Comment:', self), row, 0, Qt.AlignRight)
self._comment_box = QLineEdit(self)
self._comment_box.setText(self.breakpoint.comment)
layout.addWidget(self._comment_box, row, 1)
row += 1
self.main_layout.addWidget(self._status_label)
buttons = QDialogButtonBox(parent=self)
buttons.setStandardButtons(QDialogButtonBox.StandardButton.Cancel
| QDialogButtonBox.StandardButton.Ok)
buttons.accepted.connect(self._on_ok_clicked)
buttons.rejected.connect(self.close)
self._ok_button = buttons.button(QDialogButtonBox.Ok)
self._ok_button.setEnabled(False)
self.main_layout.addWidget(buttons)
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)
