def save_design(self, _=None):
"""Handles click on save design."""
if self.design:
# get file path
filename = self.design.save_path
if not filename:
QMessageBox.warning(
self, 'Warning', 'This will save a .metal.py script '
'that needs to be copied into a jupyter notebook to run.'
'The "Load" button has not yet been implemented.')
filename = QFileDialog.getSaveFileName(
None,
'Select a new location to save Metal design to',
self.design.get_design_name() + '.metal.py',
selectedFilter='*.metal.py')[0]
self.design.save_path = filename
# save python script to file path
pyscript = self.design.to_python_script()
with open(filename, 'w') as f:
f.write(pyscript)
#make it clear it's saving
saving_dialog = QDialog(self)
saving_dialog.setWindowModality(Qt.NonModal)
v = QVBoxLayout()
saving_dialog.setLayout(v)
v.addWidget(QLabel("Saving..."))
saving_dialog.open()
saving_dialog.show()
QTimer.singleShot(200, saving_dialog.close)
else:
self.logger.info('No design present.')
QMessageBox.warning(self, 'Warning', 'No design present! Can'
't save')
def to_login(next_window):
def _verify():
import hashlib
from datetime import datetime
day = datetime.today().strftime('%Y%m')
#signature = hashlib.sha256('jiedanjishiben'+day).hexdigest()[:6]
signature = day
password = loginUi.lineEdit_password.text()
if password == signature:
loginDialog.close()
next_window.show()
return True
else:
from PySide2.QtWidgets import QMessageBox
msg = QMessageBox()
msg.setText("请重新输入")
msg.setInformativeText("或者添加公众号获取密码")
msg.setWindowTitle("密码错误")
msg.setDetailedText("公众号: \n结丹记事本儿")
msg.setStandardButtons(QMessageBox.Ok | QMessageBox.Cancel)
retval = msg.exec_()
return retval
#msg.buttonClicked.connect(msgbtn)
loginUi = Ui_Dialog_password()
loginDialog = QDialog()
loginUi.setupUi(loginDialog)
loginUi.pushButton_login.clicked.connect(_verify)
loginDialog.show()
def submit_job(self):
if self.xsd_files_item == []: return
self.selected_items = []
for i in self.xsd_files_item:
if i.isSelected():
self.selected_items.append(str(i.file_path))
self.tmp_xvis = xvis = self.vsp.get_XVI_from_relative_xsd_files(
self.selected_items)
new_items = []
for i in xvis:
if i.status != XVI_Status.NotSubmitted:
reply = QMessageBox.information(
self.main_window, # 使用information信息框
"提示",
"包含已经提交的项目，确定再次提交？",
QMessageBox.Yes | QMessageBox.No)
if reply == QMessageBox.Yes:
new_items = self.selected_items
break
else:
return
elif i.status == XVI_Status.NotSubmitted:
new_items.append(i.relative_xsd_file_name)
self.selected_items = new_items
reply = QMessageBox.information(
self.main_window, "提示",
"将提交以下项目，请确认\n" + "\n".join(self.selected_items),
QMessageBox.Yes | QMessageBox.No)
if reply == QMessageBox.No: return
if len(self.vsp.job_submit_items) == 0:
QMessageBox.information(self.main_window, "提示",
"没有可用的Job Submit配置")
return
def ok():
job_submit = ui.chooseJobSubmit.currentText()
if job_submit == "":
QMessageBox.information(a, "提示", "选择一个Job Submit配置")
return
else:
job_submit = self.vsp.job_submit_items[job_submit]
self.tmp_note = \
QInputDialog(self.main_window).getText(self.main_window, "给这批任务添加一个备注", "任务备注")[0]
self.submit_job_run(job_submit)
a.close()
a = QDialog()
ui = Ui_submitJob()
ui.setupUi(a)
for i in self.vsp.job_submit_items:
ui.chooseJobSubmit.addItem(i)
a.show()
ui.submitJobOK.clicked.connect(ok)
def open_error_dialog(self):
error_dialog = QDialog(self)
label = QLabel()
label.setText('Sorry...\nNot support this apk.')
layout = QHBoxLayout()
layout.addWidget(label)
error_dialog.setLayout(layout)
error_dialog.show()
def show_and_close_window(qtbot: QtBot, template: QDialog):
"""
Function for displaying and then closing a window/widget. This appears to be necessary in order to make sure
some interactions with the UI are recognised. Otherwise the UI can behave as though no clicks/button presses/etc
actually took place which then causes tests to fail even though they ought to pass in theory.
:param qtbot: The qtbot testing tool.
:param template: The window/widget to be opened.
"""
template.show()
qtbot.waitForWindowShown(template)
def resize(self):
self.timer.stop()
temp=QDialog()
temp.ui=Ui_Dialog_Resize(self.image_stack[-1])
temp.ui.setupUi(temp)
temp.show()
temp.exec_()
self.image_stack.append(temp.ui.image)
self.timer.start(1)
pass
def save_image_B(self, fname):
try:
save_image(fname, self.im_array_B)
except ValueError:
dialog = QDialog(self)
msg = "Invalid filename extension.\nPlease enter a valid image extension (such as .png or .jpg)"
label = QLabel(msg)
layout = QHBoxLayout()
layout.addWidget(label)
dialog.setLayout(layout)
dialog.show()
def show_window_and_wait_for_interaction(qtbot: QtBot, template: QDialog):
"""
Helper method that allows you to examine a window during testing. Just here for convenience.
Does nothing if the test is running on Windows because this is bad for Jenkins.
:param qtbot: The qtbot testing tool.
:param template: The window/widget to be opened.
"""
if RUNNING_ON_WINDOWS:
return
template.show()
qtbot.stopForInteraction()
def _open_position_dialog(self, item: FSTTreeItem):
window = Ui_NodeFieldWindow()
dialog = QDialog(
self, Qt.WindowSystemMenuHint | Qt.WindowTitleHint
| Qt.WindowCloseButtonHint)
window.setupUi(dialog)
dialog.setWindowTitle(item.text(0))
dialog.setModal(True)
window.label.setText("Position:")
if item.node._position:
window.plainTextEdit.setPlainText(f"0x{item.node._position:X}")
else:
window.plainTextEdit.setPlainText("-1")
dialog.show()
if dialog.exec_() != QFileDialog.Accepted:
return False, ""
text = window.plainTextEdit.toPlainText()
try:
if text.startswith("0x"):
position = int(text, 16)
else:
position = int(text)
except ValueError:
dialog = JobFailedDialog(self)
dialog.setText(
f"Invalid input \"{text}\" could not be converted to int")
return False, dialog
if position < 0:
if item.node._position:
item.node._position = None
self.iso.pre_calc_metadata(self.iso.MaxSize -
self.iso.get_auto_blob_size())
self.ui.fileSystemStartInfoTextBox.setPlainText(
f"0x{item.node._fileoffset:X}")
return True, ""
else:
newPos = min(position, self.iso.MaxSize - 4) & -4
if item.node._position != newPos:
item.node._position = newPos
self.iso.pre_calc_metadata(self.iso.MaxSize -
self.iso.get_auto_blob_size())
self.ui.fileSystemStartInfoTextBox.setPlainText(
f"0x{item.node._position:X}")
return True, ""
def cropping(self):
if type(self.image_stack[-1])==type(None):
print("lol")
return
self.timer.stop()
temp=QDialog()
temp.ui=Ui_Dialog(self.image_stack[-1])
temp.ui.setupUi(temp)
temp.show()
temp.exec_()
self.image_stack.append(temp.ui.image)
self.timer.start(1)
pass
def handle_dateSelectButton(self):
# method to handle the okay button when it is pressed
def handle_okayButton():
# get date from calendar widget and create a string out of it
q_date = calendar.selectedDate()
if q_date.day() < 10:
day = str(0) + str(q_date.day())
else:
day = str(q_date.day())
if q_date.month() < 10:
month = str(0) + str(q_date.month())
else:
month = str(q_date.month())
year = str(q_date.year())
date = day + '/' + month + '/' + year
self.dateDisplay.setText(date)
popup.accept()
# method to handle the cancel button when it is pressed
def handle_cancelButton():
popup.reject()
# initialise the dialog
popup = QDialog()
popup.setWindowTitle('Select Date')
# create the widgets and connect them to functions
calendar = QCalendarWidget()
okayButton = QPushButton('Okay')
okayButton.clicked.connect(handle_okayButton)
cancelButton = QPushButton('Cancel')
cancelButton.clicked.connect(handle_cancelButton)
# initialise the layout manager
layout = QVBoxLayout()
# add the widgets to the layout manager
layout.addWidget(calendar)
layout.addWidget(cancelButton)
layout.addWidget(okayButton)
popup.setLayout(layout)
# set the dialog as modal so that the user cannot interact with the main window when the dialog is open
popup.setModal(True)
popup.show()
popup.exec_()
async def execute_dialog(dialog: QtWidgets.QDialog) -> QtWidgets.QDialog.DialogCode:
"""
An async version of dialog.exec_, internally using QDialog.show
:param dialog:
:return:
"""
future = asyncio.get_event_loop().create_future()
dialog.finished.connect(future.set_result)
try:
dialog.show()
return await future
finally:
dialog.finished.disconnect(future.set_result)
def _open_alignment_dialog(self, item: FSTTreeItem):
window = Ui_NodeFieldWindow()
dialog = QDialog(
self, Qt.WindowSystemMenuHint | Qt.WindowTitleHint
| Qt.WindowCloseButtonHint)
window.setupUi(dialog)
dialog.setWindowTitle(item.text(0))
dialog.setModal(True)
window.label.setText("Alignment:")
if item.node._alignment:
window.plainTextEdit.setPlainText(str(item.node._alignment))
else:
window.plainTextEdit.setPlainText("4")
dialog.show()
if dialog.exec_() != QFileDialog.Accepted:
return False, ""
text = window.plainTextEdit.toPlainText()
try:
if text.startswith("0x"):
alignment = int(text, 16)
else:
alignment = int(text)
except ValueError:
dialog = JobFailedDialog(self)
dialog.setText(
f"Invalid input \"{text}\" could not be converted to int")
return False, dialog
alignment = _round_up_to_power_of_2(max(4, min(alignment, 32768)))
if item.node.is_file() and item.node._alignment != alignment:
item.node._alignment = alignment
self.iso.pre_calc_metadata(self.iso.MaxSize -
self.iso.get_auto_blob_size())
self.ui.fileSystemStartInfoTextBox.setPlainText(
f"0x{item.node._fileoffset:X}")
if item.node.is_dir():
for child in item.node.rchildren():
child._alignment = _round_up_to_power_of_2(alignment)
self.iso.pre_calc_metadata(self.iso.MaxSize -
self.iso.get_auto_blob_size())
return True, ""
class DialogSteamapiKey:
steamapi_window: QDialog
def is_valid_steampi_key(self, key):
if len(key) == 32:
return True
return False
def steamapi_key_dialog(self):
self.steamapi_window = QDialog()
self.steamapi_window.setWindowTitle(_("Set steamapi key"))
self.steamapi_window.setWindowIcon(self.switcher_logo)
layout = QVBoxLayout()
self.steamapi_window.setLayout(layout)
text_label = QLabel(
_("Used for getting avatars. Get yours from <a href='https://steamcommunity.com/dev/apikey'>steam</a>"
))
apikey_edit = QLineEdit()
save_button = QPushButton(_("Save"))
text_label.setOpenExternalLinks(True)
apikey_edit.setText(self.switcher.settings.get("steam_api_key"))
layout.addWidget(text_label)
layout.addWidget(apikey_edit)
layout.addWidget(save_button)
def save_enabled():
save_button.setEnabled(
self.is_valid_steampi_key(apikey_edit.text()))
def save():
self.switcher.settings["steam_api_key"] = apikey_edit.text()
self.switcher.settings_write()
self.steamapi_window.hide()
if self.switcher.first_run:
self.import_accounts_dialog()
save_enabled()
apikey_edit.textChanged.connect(lambda: save_enabled())
save_button.clicked.connect(lambda: save())
self.steamapi_window.show()
def __disable(self):
"""Restores the ownership of the inner widget to its GraphicsNode."""
self.setWidget(None)
self.__inner_widget.setParent(None)
dialog = QDialog()
layout = QVBoxLayout()
layout.addWidget(self.__inner_widget)
dialog.setLayout(layout)
dialog.show()
self.__inner_widget.setParent(None)
self.__inner_widget.resize(self.__last_size)
self.__graphics_node.set_inner_widget(self.__inner_widget)
dialog.close()
def demo_combine_meshes():
"""
Demonstrates combining the mesh of two scene nodes
Prompt user to select two nodes to be merged and merge them.
"""
dialog = QDialog(GetQMaxMainWindow())
dialog.resize(250, 100)
dialog.setWindowTitle('DEMO - Combine 2 Nodes')
main_layout = QVBoxLayout()
label = QLabel("Combine 2 Nodes")
main_layout.addWidget(label)
combine_btn = QPushButton("Combine")
combine_btn.clicked.connect(combine_two_meshes)
main_layout.addWidget(combine_btn)
dialog.setLayout(main_layout)
dialog.show()
def colorize(self):
color_im_arr = false_color(self.im_array_A, self.im_array_B)
color_im = Image.fromarray(color_im_arr).resize((self.w, self.h))
color_im_label = QLabel()
color_im_label.setPixmap(color_im.toqpixmap())
color_im_dialog = QDialog(self)
color_im_dialog.setWindowTitle("Colorized image")
save_button = QPushButton("Save")
save_button.clicked.connect(partial(self.save_colorized, color_im_arr))
layout = QVBoxLayout()
layout.addWidget(color_im_label)
layout.addWidget(save_button)
color_im_dialog.setLayout(layout)
color_im_dialog.show()
class DialogAbout:
about_dialog: QDialog
def about_dialog(self):
self.about_dialog = QDialog(self)
self.about_dialog.setWindowTitle("About")
layout = QVBoxLayout()
self.about_dialog.setLayout(layout)
text_label = QLabel(
_("Steam account switcher<br>"
"Author: Tommi Saira <[email protected]><br>"
"Url: <a href='https://github.com/tommis/steam_account_switcher'>github.com/tommis/steam_account_switcher</a>"
))
text_label.setOpenExternalLinks(True)
layout.addWidget(text_label)
self.about_dialog.show()
def reminder(self):
box = QDialog(self)
algo = self.algoCombo.currentText()
pixmap = QPixmap(f'images/{algo.lower()}.png')
labelImage = QLabel()
labelImage.setPixmap(pixmap)
labelImage.setAlignment(Qt.AlignHCenter)
labelText = QLabel(algoDict[algo].__doc__)
labelText.setAlignment(Qt.AlignJustify)
box.setWindowTitle(f"{algo} reminder")
layout = QVBoxLayout()
layout.addWidget(labelImage)
layout.addWidget(labelText)
box.setLayout(layout)
box.show()
def __toggle_widget_dialog(self, event: "QMouseEvent"):
"""Shows the Node `inner_widget` on a new dialog. The content of the node is
substituted with a button that hides the dialog and shows the inner_widget back
in the node when pressed.
"""
node_inner_widget = self._proxy_widget.widget()
previous_node_size = node_inner_widget.size()
show_here_button = QPushButton("Show here")
show_here_button.setMinimumSize(200, 100)
# Replace the node widget with the button
self.set_inner_widget(show_here_button)
# Create a new dialog for displaying the node widget
dialog = QDialog()
dialog.setWindowTitle(self._node.title)
layout = QVBoxLayout()
layout.addWidget(node_inner_widget)
dialog.setLayout(layout)
dialog.show()
def place_widget_back_in_node():
# Widgets embedded in nodes can't have parents
node_inner_widget.setParent(None)
node_inner_widget.resize(previous_node_size)
self.set_inner_widget(node_inner_widget)
dialog.close()
# The widget will be displayed back in the node when the dialog is closed or
# when the "show here" button is pressed
dialog.finished.connect(place_widget_back_in_node)
show_here_button.clicked.connect(place_widget_back_in_node)
def handle_eftEnterButton(self):
# method to handle the okay button when it is pressed
def handle_okayButton():
machine_1_value = H.char_remover(self, machine_1.text())
machine_2_value = H.char_remover(self, machine_2.text())
machine_3_value = H.char_remover(self, machine_3.text())
machine_prev_value = H.char_remover(self, machine_prev.text())
global_temp_dict['eftpos 1'] = H.dollar_adder(
self, machine_1_value)
global_temp_dict['eftpos 2'] = H.dollar_adder(
self, machine_2_value)
global_temp_dict['eftpos 3'] = H.dollar_adder(
self, machine_3_value)
global_temp_dict['eftpos prev'] = H.dollar_adder(
self, machine_prev_value)
eft_arr = [machine_1_value, machine_2_value, machine_3_value]
eft_total = 0
for value in eft_arr:
if value != None:
eft_total += value
if machine_prev_value != None:
eft_total -= machine_prev_value
ftd_eft_total = H.dollar_adder(self, eft_total)
if ftd_eft_total == '-':
self.eftEnterButton.setText('Enter Values')
else:
self.eftEnterButton.setText(ftd_eft_total)
popup.accept()
# method to handle the cancel button when it is pressed
def handle_cancelButton():
popup.reject()
# initialise the dialog
popup = QDialog()
popup.setWindowTitle('Enter Eftpos Machine Values')
# create the widgets and connect them to functions
machine_1_label = QLabel()
machine_1_label.setText('Eftpos Machine 1')
machine_1 = QLineEdit()
machine_2_label = QLabel()
machine_2_label.setText('Eftpos Machine 2')
machine_2 = QLineEdit()
machine_3_label = QLabel()
machine_3_label.setText('Eftpos Machine 3')
machine_3 = QLineEdit()
machine_prev_label = QLabel()
machine_prev_label.setText('Previous Day\'s Eftpos (if applicable)')
machine_prev = QLineEdit()
okayButton = QPushButton('Okay')
okayButton.clicked.connect(handle_okayButton)
cancelButton = QPushButton('Cancel')
cancelButton.clicked.connect(handle_cancelButton)
# initialise values
machine_1.setText(global_temp_dict['eftpos 1'])
machine_2.setText(global_temp_dict['eftpos 2'])
machine_3.setText(global_temp_dict['eftpos 3'])
machine_prev.setText(global_temp_dict['eftpos prev'])
# initialise the layout manager
layout = QGridLayout()
# add the widgets to the layout manager
layout.addWidget(machine_1_label, 0, 0)
layout.addWidget(machine_1, 0, 1)
layout.addWidget(machine_2_label, 1, 0)
layout.addWidget(machine_2, 1, 1)
layout.addWidget(machine_3_label, 2, 0)
layout.addWidget(machine_3, 2, 1)
layout.addWidget(machine_prev_label, 3, 0)
layout.addWidget(machine_prev, 3, 1)
layout.addWidget(cancelButton, 4, 0, 1, 2)
layout.addWidget(okayButton, 5, 0, 1, 2)
popup.setLayout(layout)
# set the dialog as modal so that the user cannot interact with the main window when the dialog is open
popup.setModal(True)
popup.show()
popup.exec_()
class FieldWidget(QFrame):
# Used for deletion of field
something_clicked = Signal()
def dataset_type_changed(self, _):
self.value_line_edit.validator(
).dataset_type_combo = self.value_type_combo
self.value_line_edit.validator(
).field_type_combo = self.field_type_combo
self.value_line_edit.validator().validate(self.value_line_edit.text(),
0)
def __init__(
self,
possible_field_names=None,
parent: QListWidget = None,
instrument: "Instrument" = None, # noqa: F821
hide_name_field: bool = False,
):
super(FieldWidget, self).__init__(parent)
if possible_field_names is None:
possible_field_names = []
self.edit_dialog = QDialog(parent=self)
self.attrs_dialog = FieldAttrsDialog(parent=self)
self.instrument = instrument
self.field_name_edit = FieldNameLineEdit(possible_field_names)
self.hide_name_field = hide_name_field
if hide_name_field:
self.name = str(uuid.uuid4())
self.units_line_edit = QLineEdit()
self.unit_validator = UnitValidator()
self.units_line_edit.setValidator(self.unit_validator)
self.unit_validator.is_valid.connect(
partial(validate_line_edit, self.units_line_edit))
self.units_line_edit.setPlaceholderText(CommonAttrs.UNITS)
self.field_type_combo = QComboBox()
self.field_type_combo.addItems([item.value for item in FieldType])
self.field_type_combo.currentIndexChanged.connect(
self.field_type_changed)
fix_horizontal_size = QSizePolicy()
fix_horizontal_size.setHorizontalPolicy(QSizePolicy.Fixed)
self.field_type_combo.setSizePolicy(fix_horizontal_size)
self.value_type_combo = QComboBox()
self.value_type_combo.addItems(list(DATASET_TYPE.keys()))
self.value_type_combo.currentIndexChanged.connect(
self.dataset_type_changed)
self.value_line_edit = QLineEdit()
self.value_line_edit.setPlaceholderText("value")
self._set_up_value_validator(False)
self.dataset_type_changed(0)
self.nx_class_combo = QComboBox()
self.edit_button = QPushButton("Edit")
edit_button_size = 50
self.edit_button.setMaximumSize(edit_button_size, edit_button_size)
self.edit_button.setSizePolicy(fix_horizontal_size)
self.edit_button.clicked.connect(self.show_edit_dialog)
self.attrs_button = QPushButton("Attrs")
self.attrs_button.setMaximumSize(edit_button_size, edit_button_size)
self.attrs_button.setSizePolicy(fix_horizontal_size)
self.attrs_button.clicked.connect(self.show_attrs_dialog)
self.layout = QHBoxLayout()
self.layout.addWidget(self.field_name_edit)
self.layout.addWidget(self.field_type_combo)
self.layout.addWidget(self.value_line_edit)
self.layout.addWidget(self.nx_class_combo)
self.layout.addWidget(self.edit_button)
self.layout.addWidget(self.value_type_combo)
self.layout.addWidget(self.units_line_edit)
self.layout.addWidget(self.attrs_button)
self.layout.setAlignment(Qt.AlignLeft)
self.setLayout(self.layout)
self.setFrameShadow(QFrame.Raised)
self.setFrameShape(QFrame.StyledPanel)
# Allow selecting this field widget in a list by clicking on it's contents
self.field_name_edit.installEventFilter(self)
if parent is not None:
self._set_up_name_validator()
self.field_name_edit.validator().is_valid.emit(False)
self.value_line_edit.installEventFilter(self)
self.nx_class_combo.installEventFilter(self)
# These cause odd double-clicking behaviour when using an event filter so just connecting to the clicked() signals instead.
self.edit_button.clicked.connect(self.something_clicked)
self.value_type_combo.highlighted.connect(self.something_clicked)
self.field_type_combo.highlighted.connect(self.something_clicked)
# Set the layout for the default field type
self.field_type_changed()
def _set_up_name_validator(self):
field_widgets = []
for i in range(self.parent().count()):
field_widgets.append(self.parent().itemWidget(
self.parent().item(i)))
self.field_name_edit.setValidator(
NameValidator(field_widgets, invalid_names=INVALID_FIELD_NAMES))
self.field_name_edit.validator().is_valid.connect(
partial(
validate_line_edit,
self.field_name_edit,
tooltip_on_accept="Field name is valid.",
tooltip_on_reject=f"Field name is not valid",
))
@property
def field_type(self) -> FieldType:
return FieldType(self.field_type_combo.currentText())
@field_type.setter
def field_type(self, field_type: str):
self.field_type_combo.setCurrentText(field_type)
self.field_type_changed()
@property
def name(self) -> str:
return self.field_name_edit.text()
@name.setter
def name(self, name: str):
self.field_name_edit.setText(name)
@property
def dtype(self) -> Union[h5py.Datatype, h5py.SoftLink, h5py.Group]:
if self.field_type == FieldType.scalar_dataset:
return self.value.dtype
if self.field_type == FieldType.array_dataset:
return self.table_view.model.array.dtype
if self.field_type == FieldType.link:
return h5py.SoftLink
if self.field_type == FieldType.kafka_stream:
return h5py.Group
@dtype.setter
def dtype(self, dtype: h5py.Datatype):
type_map = {
np.object: "String",
np.float64: "Float",
np.int64: "Integer"
}
for item in type_map.keys():
if dtype == item:
self.value_type_combo.setCurrentText(type_map[item])
return
self.value_type_combo.setCurrentText(
next(key for key, value in DATASET_TYPE.items() if value == dtype))
@property
def attrs(self) -> h5py.Dataset.attrs:
return self.value.attrs
@attrs.setter
def attrs(self, field: h5py.Dataset):
self.attrs_dialog.fill_existing_attrs(field)
@property
def value(self) -> Union[h5py.Dataset, h5py.Group, h5py.SoftLink]:
return_object = None
if self.field_type == FieldType.scalar_dataset:
dtype = DATASET_TYPE[self.value_type_combo.currentText()]
val = self.value_line_edit.text()
if dtype == h5py.special_dtype(vlen=str):
return_object = create_temporary_in_memory_file(
).create_dataset(name=self.name, dtype=dtype, data=val)
else:
return_object = create_temporary_in_memory_file(
).create_dataset(name=self.name, dtype=dtype, data=dtype(val))
elif self.field_type == FieldType.array_dataset:
# Squeeze the array so 1D arrays can exist. Should not affect dimensional arrays.
return_object = create_temporary_in_memory_file().create_dataset(
name=self.name, data=np.squeeze(self.table_view.model.array))
elif self.field_type == FieldType.kafka_stream:
return_object = self.streams_widget.get_stream_group()
elif self.field_type == FieldType.link:
return_object = h5py.SoftLink(self.value_line_edit.text())
else:
logging.error(f"unknown field type: {self.name}")
if self.field_type != FieldType.link:
for attr_name, attr_value in self.attrs_dialog.get_attrs().items():
self.instrument.nexus.set_attribute_value(
return_object, attr_name, attr_value)
if self.units and self.units is not None:
self.instrument.nexus.set_attribute_value(
return_object, CommonAttrs.UNITS, self.units)
return return_object
@value.setter
def value(self, value):
if self.field_type == FieldType.scalar_dataset:
self.value_line_edit.setText(to_string(value))
elif self.field_type == FieldType.array_dataset:
self.table_view.model.array = value
elif self.field_type == FieldType.link:
self.value_line_edit.setText(value)
@property
def units(self):
return self.units_line_edit.text()
@units.setter
def units(self, new_units):
self.units_line_edit.setText(new_units)
def eventFilter(self, watched: QObject, event: QEvent) -> bool:
if event.type() == QEvent.MouseButtonPress:
self.something_clicked.emit()
return True
else:
return False
def field_type_changed(self):
self.edit_dialog = QDialog(parent=self)
self._set_up_value_validator(False)
if self.field_type == FieldType.scalar_dataset:
self.set_visibility(True, False, False, True)
elif self.field_type == FieldType.array_dataset:
self.set_visibility(False, False, True, True)
self.table_view = ArrayDatasetTableWidget()
elif self.field_type == FieldType.kafka_stream:
self.set_visibility(False,
False,
True,
False,
show_name_line_edit=True)
self.streams_widget = StreamFieldsWidget(self.edit_dialog)
elif self.field_type == FieldType.link:
self.set_visibility(True, False, False, False)
self._set_up_value_validator(True)
elif self.field_type == FieldType.nx_class:
self.set_visibility(False, True, False, False)
def _set_up_value_validator(self, is_link: bool):
self.value_line_edit.setValidator(None)
if is_link:
self.value_line_edit.setValidator(
HDFLocationExistsValidator(self.instrument.nexus.nexus_file,
self.field_type_combo))
tooltip_on_accept = "Valid HDF path"
tooltip_on_reject = "HDF Path is not valid"
else:
self.value_line_edit.setValidator(
FieldValueValidator(
self.field_type_combo,
self.value_type_combo,
FieldType.scalar_dataset.value,
))
tooltip_on_accept = "Value is cast-able to numpy type."
tooltip_on_reject = "Value is not cast-able to selected numpy type."
self.value_line_edit.validator().is_valid.connect(
partial(
validate_line_edit,
self.value_line_edit,
tooltip_on_accept=tooltip_on_accept,
tooltip_on_reject=tooltip_on_reject,
))
self.value_line_edit.validator().validate(self.value_line_edit.text(),
None)
def set_visibility(
self,
show_value_line_edit: bool,
show_nx_class_combo: bool,
show_edit_button: bool,
show_value_type_combo: bool,
show_name_line_edit: bool = True,
):
self.value_line_edit.setVisible(show_value_line_edit)
self.nx_class_combo.setVisible(show_nx_class_combo)
self.edit_button.setVisible(show_edit_button)
self.value_type_combo.setVisible(show_value_type_combo)
self.field_name_edit.setVisible(show_name_line_edit
and not self.hide_name_field)
def show_edit_dialog(self):
if self.field_type == FieldType.array_dataset:
self.edit_dialog.setLayout(QGridLayout())
self.table_view.model.update_array_dtype(
DATASET_TYPE[self.value_type_combo.currentText()])
self.edit_dialog.layout().addWidget(self.table_view)
self.edit_dialog.setWindowTitle(
f"Edit {self.value_type_combo.currentText()} Array field")
elif self.field_type == FieldType.kafka_stream:
self.edit_dialog.setLayout(QFormLayout())
self.edit_dialog.layout().addWidget(self.streams_widget)
elif self.field_type.currentText() == FieldType.nx_class:
# TODO: show nx class panels
pass
self.edit_dialog.show()
def show_attrs_dialog(self):
self.attrs_dialog.show()
from PySide2.QtWidgets import QApplication
from PySide2.QtWidgets import QDialog, QVBoxLayout, QPushButton
app = QApplication([])
dialog = QDialog()
layout = QVBoxLayout()
layout.addWidget(QPushButton('Top'))
layout.addWidget(QPushButton('Bottom'))
dialog.setLayout(layout)
dialog.show()
app.exec_()
class NotificationsDialog(object):
def __init__(self, parent, parent_window, notifications, dp=None):
self._dialog = QDialog(parent_window)
self._dp = dp
self._notifications = notifications
self._parent = parent
self._parent_window = parent_window
self._dialog.setWindowIcon(QIcon(':/images/icon.png'))
self._ui = Ui_Dialog()
self._ui.setupUi(self._dialog)
self._init_ui()
def _init_ui(self):
self._dialog.setWindowFlags(Qt.Dialog)
self._dialog.setAttribute(Qt.WA_TranslucentBackground)
self._dialog.setAttribute(Qt.WA_MacFrameworkScaled)
self._notifications_list = NotificationsList(self._dp)
self._ui.notifications_area.setWidget(self._notifications_list)
self._ui.notifications_area.verticalScrollBar().valueChanged.connect(
self._on_list_scroll_changed)
self._old_main_resize_event = self._ui.centralwidget.resizeEvent
self._ui.centralwidget.resizeEvent = self._main_resize_event
self._loader_movie = QMovie(":/images/loader.gif")
self._ui.loader_label.setMovie(self._loader_movie)
def show(self, on_finished):
def finished():
self.show_cursor_normal()
self._dialog.finished.disconnect(finished)
on_finished()
logger.debug("Opening notifications dialog")
screen_width = QApplication.desktop().width()
parent_x = self._dialog.parent().x()
parent_width = self._dialog.parent().width()
width = self._dialog.width()
offset = 16
if parent_x + parent_width / 2 > screen_width / 2:
x = parent_x - width - offset
if x < 0:
x = 0
else:
x = parent_x + parent_width + offset
diff = x + width - screen_width
if diff > 0:
x -= diff
self._dialog.move(x, self._dialog.parent().y())
# Execute dialog
self._dialog.finished.connect(finished)
if not self._parent.load_notifications(show_loading=True):
self.show_notifications()
self._dialog.raise_()
self._dialog.show()
def raise_dialog(self):
self._dialog.raise_()
def close(self):
self._dialog.reject()
def show_cursor_loading(self, show_movie=False):
if show_movie:
self._ui.notifications_pages.setCurrentIndex(2)
self._loader_movie.start()
else:
self._dialog.setCursor(Qt.WaitCursor)
self._parent_window.setCursor(Qt.WaitCursor)
def show_cursor_normal(self):
self._dialog.setCursor(Qt.ArrowCursor)
self._parent_window.setCursor(Qt.ArrowCursor)
if self._loader_movie.state() == QMovie.Running:
self._loader_movie.stop()
def show_notifications(self):
if not self._notifications:
self._ui.notifications_pages.setCurrentIndex(1)
else:
self._ui.notifications_pages.setCurrentIndex(0)
self._notifications_list.show_notifications(self._notifications)
self.show_cursor_normal()
def _on_list_scroll_changed(self, *args, **kwargs):
# value = self._ui.notifications_area.verticalScrollBar().value()
# logger.debug("Scroll value %s", value)
if self._parent.all_loaded or self._parent.is_querying:
return
if self._notifications_list.loading_needed(self._parent.limit):
logger.debug("Loading notifications")
self._parent.load_notifications()
def _main_resize_event(self, e):
self._old_main_resize_event(e)
self._notifications_list.setFixedWidth(
self._ui.notifications_pages.width() - 8)
self._on_list_scroll_changed()
def run_command(self, command_list):
try:
if len(self.vsp.job_submit_items) == 0:
QMessageBox.information(self.main_window, "提示",
"没有可用的Job Submit配置")
return
def ok():
job_submit = ui.chooseJobSubmit.currentText()
if job_submit == "":
QMessageBox.information(a, "提示", "选择一个Job Submit配置")
return
else:
job_submit = self.vsp.job_submit_items[job_submit]
a.close()
def command_run(*args):
sf = SFTP_SSH_Utils(host=job_submit.host,
port=job_submit.port,
username=job_submit.username,
password=job_submit.password)
a, b, c = sf.ssh_run_command(args)
print(a)
print(b)
print(c)
return a, b, c, 1
class SJT(QThread):
def __init__(self, job_submit_confg, *args):
super().__init__()
self.status = None
self.jc = job_submit_confg
self.args = args
def run(self):
print(self.args)
self.output = command_run(self.args[0])
self.status = self.output[3]
self.output = self.output[:3]
def get_output(self):
return self.output
try:
thread = SJT(job_submit, command_list)
thread.start()
while True:
q = thread.status
if q == None:
QCoreApplication.processEvents()
continue
elif q == 1:
try:
string = ""
for i in thread.output[1]:
string += str(i,
encoding="utf-8") + "\n"
# 提交成功才更新节点信息
self.main_window_ui.commandOutput.setText(
string)
self.command_output = string
return
except:
traceback.print_exc()
QMessageBox.information(
self.main_window, '提示', "command运行失败")
return
except:
traceback.print_exc()
a = QDialog()
ui = Ui_submitJob()
ui.setupUi(a)
for i in self.vsp.job_submit_items:
ui.chooseJobSubmit.addItem(i)
a.show()
ui.submitJobOK.clicked.connect(ok)
except:
traceback.print_exc()
def handle_lottoPayEnterButton(self):
# method to handle the okay button when it is pressed
def handle_okayButton():
instants_cash_value = H.char_remover(self, instants_cash.text())
prizes_paid_value = H.char_remover(self, prizes_paid.text())
global_temp_dict['instants cash'] = H.dollar_adder(
self, instants_cash_value)
global_temp_dict['total prizes'] = H.dollar_adder(
self, prizes_paid_value)
if (prizes_paid_value and instants_cash_value) != None:
lotto_pay_total = prizes_paid_value - instants_cash_value
ftd_lotto_pay_total = H.dollar_adder(self, lotto_pay_total)
if ftd_lotto_pay_total == '-':
self.lottoPayEnterButton.setText('Enter Values')
else:
self.lottoPayEnterButton.setText(ftd_lotto_pay_total)
popup.accept()
else:
self.lottoPayEnterButton.setText('Enter Values')
popup.reject()
# method to handle the cancel button when it is pressed
def handle_cancelButton():
popup.reject()
# initialise the dialog
popup = QDialog()
popup.setWindowTitle('Enter Lotto Payout Values')
# create the widgets and connect them to functions
instants_cash_label = QLabel()
instants_cash_label.setText('Instants Cash')
instants_cash = QLineEdit()
prizes_paid_label = QLabel()
prizes_paid_label.setText('Total Prizes Paid')
prizes_paid = QLineEdit()
okayButton = QPushButton('Okay')
okayButton.clicked.connect(handle_okayButton)
cancelButton = QPushButton('Cancel')
cancelButton.clicked.connect(handle_cancelButton)
# initialise values
instants_cash.setText(global_temp_dict['instants cash'])
prizes_paid.setText(global_temp_dict['total prizes'])
# initialise the layout manager
layout = QGridLayout()
# add the widgets to the layout manager
layout.addWidget(prizes_paid_label, 0, 0)
layout.addWidget(prizes_paid, 0, 1)
layout.addWidget(instants_cash_label, 1, 0)
layout.addWidget(instants_cash, 1, 1)
layout.addWidget(cancelButton, 2, 0, 1, 2)
layout.addWidget(okayButton, 3, 0, 1, 2)
popup.setLayout(layout)
# set the dialog as modal so that the user cannot interact with the main window when the dialog is open
popup.setModal(True)
popup.show()
popup.exec_()
class VideoCompareView(object):
def __init__(self, parent=None):
self.widget = QWidget()
self.setting_widget = Ui_video_pre_settings()
self.setting_widget.setupUi(self.widget)
self.scene = QGraphicsScene()
self.imageview = ImageView(self.scene, self.widget)
self.setting_widget.videoview.addWidget(self.imageview)
parent.addWidget(self.widget)
# init params
self.video_valid = False
self.process_speed = 33
self.skip_frames = 0
self.processing_video = False
self.video_timer = QTimer()
self.video_timer.timeout.connect(self.open_frame)
# init func
self.setting_widget.openvideo.clicked.connect(self.open_video)
self.setting_widget.open_rtsp.clicked.connect(self.open_rtsp)
self.setting_widget.skipframe.valueChanged.connect(self.set_skip_frame)
self.imageview.sigDragEvent.connect(self.open_video_path)
def set_skip_frame(self, value):
# self.skip_frames = self.setting_widget.skipframe.value()
self.skip_frames = value
self.vertify_video()
def open_video(self):
videopath = QFileDialog.getOpenFileName(None, '打开文件', './',
'video files(*.mp4)')
if (videopath[0] != ''):
self.open_video_path(videopath[0])
def open_video_path(self, string):
self.setting_widget.path.setText(string)
self.vertify_video()
# self.set_ui_enable(True)
def open_rtsp(self):
self.rtsp_config_window = QDialog()
self.rtsp_config_ui = Ui_RtspConfigView()
self.rtsp_config_ui.setupUi(self.rtsp_config_window)
self.rtsp_config_window.show()
self.rtsp_config_ui.buttonBox.clicked.connect(self.rtsp_config)
def rtsp_config(self):
username = self.rtsp_config_ui.username.text()
password = self.rtsp_config_ui.password.text()
ip = self.rtsp_config_ui.ip.text()
port = self.rtsp_config_ui.port.text()
# 移动设备需要通过adb映射端口
if (self.rtsp_config_ui.isphoto.isChecked() == True):
command = "forward tcp:" + port + ' ' + "tcp:" + port
os.system("adb " + command)
os.system("kdb " + command)
rtsp_path = "rtsp://" + username + ":" + password + "@" + ip + ":" + port
self.open_video_path(rtsp_path)
def vertify_video(self):
# 输出参数初始化
# self.frame_count = 0
self.vidcap = cv2.VideoCapture(self.setting_widget.path.text())
# 片头调过多少帧
self.vidcap.set(cv2.CAP_PROP_POS_FRAMES, self.skip_frames)
success, frame = self.vidcap.read()
if success:
self.display(frame)
self.video_valid = True
else:
self.critical_window_show('视频打不开')
self.video_valid = False
return
def display(self, img):
self.scene.clear()
self.scene.addPixmap(
QPixmap(
QImage(img, img.shape[1], img.shape[0], QImage.Format_BGR888)))
def open_frame(self):
success, frame = self.vidcap.read()
if success:
# self.frame_count += 1
self.display(frame)
else:
self.video_timer.stop()
self.processing_video = False
self.video_valid = False
def set_speed(self, value):
speed = value * 33
if (self.processing_video == True
and int(speed) != self.process_speed):
self.process_speed = int(speed)
self.stop_video()
self.start_video()
def start_video(self):
if (self.video_valid == True):
self.processing_video = True
# 增加定时器，每100ms进行一帧的处理
self.video_timer.start(self.process_speed)
def stop_video(self):
self.processing_video = False
self.video_timer.stop()
def restart_video(self):
self.stop_video()
self.vertify_video()
self.start_video()
def critical_window_show(self, str):
reply = QMessageBox.critical(self.widget, '警告', str, QMessageBox.Yes,
QMessageBox.Yes)
return
def handle_lottoEnterButton(self):
# method to handle the okay button when it is pressed
def handle_okayButton():
gross_sales_value = H.char_remover(self, gross_sales.text())
instants_comm_value = H.char_remover(self, instants_comm.text())
instants_net_value = H.char_remover(self, instants_net.text())
global_temp_dict['gross sales'] = H.dollar_adder(
self, gross_sales_value)
global_temp_dict['instants comm'] = H.dollar_adder(
self, instants_comm_value)
global_temp_dict['instants net'] = H.dollar_adder(
self, instants_net_value)
if (gross_sales_value and instants_comm_value
and instants_net_value) != None:
lotto_total = gross_sales_value - instants_comm_value - instants_net_value
ftd_lotto_total = H.dollar_adder(self, lotto_total)
if ftd_lotto_total == '-':
self.lottoEnterButton.setText('Enter Values')
else:
self.lottoEnterButton.setText(ftd_lotto_total)
popup.accept()
else:
self.lottoEnterButton.setText('Enter Values')
popup.reject()
# method to handle the cancel button when it is pressed
def handle_cancelButton():
popup.reject()
# initialise the dialog
popup = QDialog()
popup.setWindowTitle('Enter Lotto Values')
# create the widgets and connect them to functions
gross_sales_label = QLabel()
gross_sales_label.setText('Gross Sales')
gross_sales = QLineEdit()
instants_comm_label = QLabel()
instants_comm_label.setText('Instants Commission')
instants_comm = QLineEdit()
instants_net_label = QLabel()
instants_net_label.setText('Instants Net')
instants_net = QLineEdit()
okayButton = QPushButton('Okay')
okayButton.clicked.connect(handle_okayButton)
cancelButton = QPushButton('Cancel')
cancelButton.clicked.connect(handle_cancelButton)
# initialise values
gross_sales.setText(global_temp_dict['gross sales'])
instants_comm.setText(global_temp_dict['instants comm'])
instants_net.setText(global_temp_dict['instants net'])
# initialise the layout manager
layout = QGridLayout()
# add the widgets to the layout manager
layout.addWidget(gross_sales_label, 0, 0)
layout.addWidget(gross_sales, 0, 1)
layout.addWidget(instants_comm_label, 1, 0)
layout.addWidget(instants_comm, 1, 1)
layout.addWidget(instants_net_label, 2, 0)
layout.addWidget(instants_net, 2, 1)
layout.addWidget(cancelButton, 3, 0, 1, 2)
layout.addWidget(okayButton, 4, 0, 1, 2)
popup.setLayout(layout)
# set the dialog as modal so that the user cannot interact with the main window when the dialog is open
popup.setModal(True)
popup.show()
popup.exec_()
class Plotter(FigureCanvasQTAgg):
def __init__(self, xtitle=None, ytitle=None, width=5, height=4, dpi=100):
fig = Figure(figsize=(width, height), dpi=dpi)
self.axes = fig.add_subplot(111)
self.axes.autoscale(enable=True)
super().__init__(fig)
self._createDialog()
self._needsUpdating = False
self.updateTimer = QTimer()
self.updateTimer.setSingleShot(False)
self.updateTimer.setInterval(UPDATE_INTERVAL)
self.updateTimer.timeout.connect(self._updateFigure)
self.updateThread = QThread()
self.updateThread.started.connect(self._refreshFigure)
self.xdata = list(range(MAXIMUM_POINTS))
self.ydata = [0] * MAXIMUM_POINTS
#The following lines may not be correct
self.xtitle = xtitle
self.ytitle = ytitle
self.xtitle("SAMPLE X")
# self._plot_ref = None
self._showDialog()
self.updateTimer.start()
def _updateFigure(self):
if self._needsUpdating:
self.updateThread.start()
def _refreshFigure(self):
# if self._plot_ref is None:
# self._plot_ref, = self.axes.plot(self.xdata, self.ydata, 'r', marker='o', markersize=12)
# else:
# self._plot_ref.set_xdata(self.xdata)
# self._plot_ref.set_ydata(self.ydata)
self.axes.cla()
self.axes.plot(self.xdata, self.ydata, 'r', marker='o', markersize=12)
if self.xtitle is not None:
self.axes.xtitle(self.xtitle)
if self.ytitle is not None:
self.axes.ytitle(self.ytitle)
self.draw()
self._needsUpdating = False
def _createDialog(self):
self.plotDialog = QDialog()
self.plotDialog.setWindowTitle("Processing Plot")
dialogButtons = QDialogButtonBox(QDialogButtonBox.Close)
dialogButtons.clicked.connect(self._closeDialog)
layout = QVBoxLayout()
self.toolbar = NavigationToolbar(self, self.plotDialog)
layout.addWidget(self.toolbar)
layout.addWidget(self)
layout.addWidget(dialogButtons)
self.plotDialog.setLayout(layout)
def _closeDialog(self):
self.plotDialog.close()
def _showDialog(self):
self.plotDialog.show()
def addNewData(self, x, y):
#Check data validity
x = np.array(x).flatten()
y = np.array(y).flatten()
if x.size != y.size:
print(
"Problem with adding new values to the plot, x and y should have the same length"
)
return
#TODO: Add other validation conditions
#Add data to class
length = x.shape[0]
self.xdata = self.xdata[-(MAXIMUM_POINTS - length):] + x.tolist()
self.ydata = self.ydata[-(MAXIMUM_POINTS - length):] + y.tolist()
#flag it for updates
self._needsUpdating = True
def __del__(self):
self.plotDialog.close()
while not self.updateThread.isFinished():
pass
def handle_scratchiesPayEnterButton(self):
# method to handle the okay button when it is pressed
def handle_okayButton():
instants_cash_value = H.char_remover(self, instants_cash.text())
free_instants_value = H.char_remover(self, free_instants.text())
global_temp_dict['instants cash'] = H.dollar_adder(
self, instants_cash_value)
global_temp_dict['free instants'] = H.dollar_adder(
self, free_instants_value)
scratchies_pay_arr = [instants_cash_value, free_instants_value]
scratchies_pay_total = 0
for value in scratchies_pay_arr:
if value != None:
scratchies_pay_total += value
ftd_scratchies_pay_total = H.dollar_adder(self,
scratchies_pay_total)
if ftd_scratchies_pay_total == '-':
self.scratchiesPayEnterButton.setText('Enter Values')
else:
self.scratchiesPayEnterButton.setText(ftd_scratchies_pay_total)
popup.accept()
# method to handle the cancel button when it is pressed
def handle_cancelButton():
popup.reject()
# initialise the dialog
popup = QDialog()
popup.setWindowTitle('Enter Scratchies Payout Values')
# create the widgets and connect them to functions
instants_cash_label = QLabel()
instants_cash_label.setText('Instants Cash')
instants_cash = QLineEdit()
free_instants_label = QLabel()
free_instants_label.setText('Free Instants')
free_instants = QLineEdit()
okayButton = QPushButton('Okay')
okayButton.clicked.connect(handle_okayButton)
cancelButton = QPushButton('Cancel')
cancelButton.clicked.connect(handle_cancelButton)
# initialise values
instants_cash.setText(global_temp_dict['instants cash'])
free_instants.setText(global_temp_dict['free instants'])
# initialise the layout manager
layout = QGridLayout()
# add the widgets to the layout manager
layout.addWidget(instants_cash_label, 0, 0)
layout.addWidget(instants_cash, 0, 1)
layout.addWidget(free_instants_label, 1, 0)
layout.addWidget(free_instants, 1, 1)
layout.addWidget(cancelButton, 2, 0, 1, 2)
layout.addWidget(okayButton, 3, 0, 1, 2)
popup.setLayout(layout)
# set the dialog as modal so that the user cannot interact with the main window when the dialog is open
popup.setModal(True)
popup.show()
popup.exec_()
