def _build_ui(self):
self.label_button = QtWidgets.QPushButton(self.label, parent=self)
self.label_button.setSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Fixed)
font = QtGui.QFont("Decorative", 10)
self.label_button.setFont(font)
self.edit_button = QtWidgets.QPushButton("Edit" , parent=self)
def add_spacer(self):
self.last_row += 1
spacer_widget = QtWidgets.QWidget(self)
spacer_widget.setFixedHeight(1)
spacer_widget.setStyleSheet("background-color: #ddd")
self.layout.addWidget(spacer_widget, self.last_row, 0, 1, 6)
def _create_ammo_pickup_boxes(self, size_policy, item_database: ItemDatabase):
"""
Creates the GroupBox with SpinBoxes for selecting the pickup count of all the ammo
:param item_database:
:return:
"""
self._ammo_item_count_spinboxes = collections.defaultdict(list)
self._ammo_pickup_widgets = {}
resource_database = default_database.resource_database_for(self.game)
broad_to_category = {
"beam_related": "beam",
"morph_ball_related": "morph_ball",
"missile_related": "missile",
}
layouts_with_lines: set[tuple[Foldable, QtWidgets.QGridLayout]] = {
self._boxes_for_category[broad_to_category.get(ammo.broad_category.name, ammo.broad_category.name)][:2]
for ammo in item_database.ammo.values()
}
for box, layout in layouts_with_lines:
layout.addWidget(_create_separator(box), layout.rowCount(), 0, 1, -1)
for ammo in item_database.ammo.values():
category_box, category_layout, _ = self._boxes_for_category[broad_to_category.get(ammo.broad_category.name,
ammo.broad_category.name)]
pickup_box = QtWidgets.QGroupBox(category_box)
pickup_box.setSizePolicy(size_policy)
pickup_box.setTitle(ammo.name + "s")
layout = QtWidgets.QGridLayout(pickup_box)
layout.setObjectName(f"{ammo.name} Box Layout")
current_row = 0
def add_row(widget_a: QtWidgets.QWidget, widget_b: QtWidgets.QWidget):
nonlocal current_row
layout.addWidget(widget_a, current_row, 0)
layout.addWidget(widget_b, current_row, 1)
current_row += 1
for ammo_index, ammo_item in enumerate(ammo.items):
item = resource_database.get_by_type_and_index(ResourceType.ITEM, ammo_item)
item_count_label = QtWidgets.QLabel(pickup_box)
item_count_label.setText(item.long_name if len(ammo.items) > 1 else "Contains")
item_count_spinbox = ScrollProtectedSpinBox(pickup_box)
item_count_spinbox.setMaximum(item.max_capacity)
item_count_spinbox.valueChanged.connect(partial(self._on_update_ammo_pickup_item_count_spinbox,
ammo, ammo_index))
self._ammo_item_count_spinboxes[ammo.name].append(item_count_spinbox)
add_row(item_count_label, item_count_spinbox)
# Pickup Count
count_label = QtWidgets.QLabel(pickup_box)
count_label.setText("Pickup Count")
count_label.setToolTip("How many instances of this expansion should be placed.")
pickup_spinbox = ScrollProtectedSpinBox(pickup_box)
pickup_spinbox.setMaximum(999)
pickup_spinbox.valueChanged.connect(partial(self._on_update_ammo_pickup_num_count_spinbox, ammo))
add_row(count_label, pickup_spinbox)
if ammo.temporary:
require_major_item_check = QtWidgets.QCheckBox(pickup_box)
require_major_item_check.setText("Requires the major item to work?")
require_major_item_check.stateChanged.connect(partial(self._on_update_ammo_require_major_item, ammo))
layout.addWidget(require_major_item_check, current_row, 0, 1, 2)
current_row += 1
else:
require_major_item_check = None
expected_count = QtWidgets.QLabel(pickup_box)
expected_count.setWordWrap(True)
expected_count.setText("<TODO>")
layout.addWidget(expected_count, current_row, 0, 1, 2)
current_row += 1
self._ammo_pickup_widgets[ammo] = AmmoPickupWidgets(pickup_spinbox, expected_count,
pickup_box, require_major_item_check)
category_layout.addWidget(pickup_box)
def __init__(self, parent=None):
QtOpenGLWidgets.QOpenGLWidget.__init__(self, parent)
QtGui.QOpenGLFunctions.__init__(self)
self.m_shaderProgram = None
self.m_shaderHeightMapProgram = None
self.m_shaderBasicProgram = None
self.m_xRot = 90.0
self.m_yRot = 0.0
self.m_xLastRot = 0.0
self.m_yLastRot = 0.0
self.m_xPan = 0.0
self.m_yPan = 0.0
self.m_xLastPan = 0.0
self.m_yLastPan = 0.0
self.m_xLookAt = 0.0
self.m_yLookAt = 0.0
self.m_zLookAt = 0.0
self.m_lastPos = QtCore.QPoint(0, 0)
self.m_zoom = 1
self.m_distance = 100.0
self.m_xMin = 0.0
self.m_xMax = 0.0
self.m_yMin = 0.0
self.m_yMax = 0.0
self.m_zMin = 0.0
self.m_zMax = 0.0
self.m_xSize = 0.0
self.m_ySize = 0.0
self.m_zSize = 0.0
self.m_lineWidth = 0.0
self.m_pointSize = 0.0
self.m_antialiasing = True
self.m_msaa = True
self.m_zBuffer = True
self.m_frames = 0
self.m_fps = 0
self.m_animationFrame = 0
self.m_timerPaint = QtCore.QBasicTimer()
self.m_xRotTarget = 90.0
self.m_yRotTarget = 0.0
self.m_xRotStored = 0.0
self.m_yRotStored = 0.0
self.m_animateView = False
self.m_parserStatus = ""
self.m_speedState = ""
self.m_pinState = ""
self.m_bufferState = ""
self.m_updatesEnabled = False
self.m_projectionMatrix = QtGui.QMatrix4x4()
self.m_viewMatrix = QtGui.QMatrix4x4()
self.m_colorBackground = QtGui.QColor(255,255,255)
self.m_colorText = QtGui.QColor()
self.m_shaderDrawables : List[ShaderDrawable] = []
self.updateProjection()
self.updateView()
self.m_spendTime = QtCore.QTime()
self.m_spendTime.setHMS(0, 0, 0)
self.m_estimatedTime = QtCore.QTime()
self.m_estimatedTime.setHMS(0, 0, 0)
self.m_vsync = False
self.m_targetFps = 60
self.cmdFit = QtWidgets.QToolButton(self)
self.cmdIsometric = QtWidgets.QToolButton(self)
self.cmdTop = QtWidgets.QToolButton(self)
self.cmdFront = QtWidgets.QToolButton(self)
self.cmdLeft = QtWidgets.QToolButton(self)
self.cmdFit.setMinimumSize(QtCore.QSize(24,24))
self.cmdIsometric.setMinimumSize(QtCore.QSize(24,24))
self.cmdTop.setMinimumSize(QtCore.QSize(24,24))
self.cmdFront.setMinimumSize(QtCore.QSize(24,24))
self.cmdLeft.setMinimumSize(QtCore.QSize(24,24))
self.cmdFit.setMaximumSize(QtCore.QSize(24,24))
self.cmdIsometric.setMaximumSize(QtCore.QSize(24,24))
self.cmdTop.setMaximumSize(QtCore.QSize(24,24))
self.cmdFront.setMaximumSize(QtCore.QSize(24,24))
self.cmdLeft.setMaximumSize(QtCore.QSize(24,24))
self.cmdFit.setToolTip("Fit")
self.cmdIsometric.setToolTip("Isometric view")
self.cmdTop.setToolTip("Top view")
self.cmdFront.setToolTip("Front view")
self.cmdLeft.setToolTip("Left view")
self.cmdFit.setIcon(QtGui.QIcon(":/images/candle/fit_1.png"))
self.cmdIsometric.setIcon(QtGui.QIcon(":/images/candle/cube.png"))
self.cmdTop.setIcon(QtGui.QIcon(":/images/candle/cubeTop.png"))
self.cmdFront.setIcon(QtGui.QIcon(":/images/candle/cubeFront.png"))
self.cmdLeft.setIcon(QtGui.QIcon(":/images/candle/cubeLeft.png"))
self.cmdFit.clicked.connect(self.on_cmdFit_clicked)
self.cmdIsometric.clicked.connect(self.on_cmdIsometric_clicked)
self.cmdTop.clicked.connect(self.on_cmdTop_clicked)
self.cmdFront.clicked.connect(self.on_cmdFront_clicked)
self.cmdLeft.clicked.connect(self.on_cmdLeft_clicked)
self.rotationChanged.connect(self.onVisualizatorRotationChanged)
self.resized.connect(self.placeVisualizerButtons)
QtCore.QTimer.singleShot(1000, self.onFramesTimer)
def paint(self, *args, **kwargs):
new_args = [args[0], QtWidgets.QStyleOptionGraphicsItem()] + list(
args[2:])
super(BaseItem, self).paint(*new_args, **kwargs)
def __init__(self, parent=None):
super().__init__(parent=parent)
self._results: List[SSUResult] = []
self.setWindowTitle(self.tr("SSU Result Viewer"))
self.data_table = QtWidgets.QTableWidget(100, 100)
self.data_table.setEditTriggers(
QtWidgets.QAbstractItemView.NoEditTriggers)
self.data_table.setSelectionBehavior(
QtWidgets.QAbstractItemView.SelectRows)
self.data_table.setAlternatingRowColors(True)
self.data_table.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self.main_layout = QtWidgets.QGridLayout(self)
self.main_layout.addWidget(self.data_table, 0, 0, 1, 3)
self.previous_button = QtWidgets.QPushButton(self.tr("Previous"))
self.previous_button.setToolTip(
self.tr("Click to get back to the previous page."))
self.page_combo_box = QtWidgets.QComboBox()
self.page_combo_box.addItem(self.tr("Page {0}").format(1))
self.next_button = QtWidgets.QPushButton(self.tr("Next"))
self.next_button.setToolTip(self.tr("Click to jump to the next page."))
self.previous_button.clicked.connect(
lambda: self.page_combo_box.setCurrentIndex(
max(self.page_index - 1, 0)))
self.page_combo_box.currentIndexChanged.connect(self.update_page)
self.next_button.clicked.connect(
lambda: self.page_combo_box.setCurrentIndex(
min(self.page_index + 1, self.n_pages - 1)))
self.main_layout.addWidget(self.previous_button, 1, 0)
self.main_layout.addWidget(self.page_combo_box, 1, 1)
self.main_layout.addWidget(self.next_button, 1, 2)
self.loss_label = QtWidgets.QLabel(self.tr("Loss"))
self.loss_label.setToolTip(
self.
tr("The function to calculate the difference between prediction and observation."
))
self.loss_combo_box = QtWidgets.QComboBox()
self.loss_combo_box.addItems(built_in_losses)
self.loss_combo_box.setCurrentText("lmse")
self.loss_combo_box.currentTextChanged.connect(
lambda: self.update_page(self.page_index))
self.main_layout.addWidget(self.loss_label, 2, 0)
self.main_layout.addWidget(self.loss_combo_box, 2, 1, 1, 2)
self.menu = QtWidgets.QMenu(self.data_table)
self.menu.setShortcutAutoRepeat(True)
self.remove_action = self.menu.addAction(self.tr("Remove"))
self.remove_action.triggered.connect(self.remove_selections)
self.remove_all_action = self.menu.addAction(self.tr("Remove All"))
self.remove_all_action.triggered.connect(self.remove_all_results)
self.refer_action = self.menu.addAction(self.tr("Refer Parameters"))
self.refer_action.triggered.connect(self.refer_result)
self.show_chart_action = self.menu.addAction(self.tr("Show Chart"))
self.show_chart_action.triggered.connect(self.show_chart)
self.auto_show_selected_action = self.menu.addAction(
self.tr("Auto Show"))
self.auto_show_selected_action.setCheckable(True)
self.auto_show_selected_action.setChecked(False)
self.show_distance_action = self.menu.addAction(
self.tr("Show Loss Series"))
self.show_distance_action.triggered.connect(self.show_loss_series)
self.show_parameter_action = self.menu.addAction(
self.tr("Show Parameters"))
self.show_parameter_action.triggered.connect(self.show_parameters)
self.detect_outliers_menu = self.menu.addMenu(self.tr("Check"))
self.check_nan_and_inf_action = self.detect_outliers_menu.addAction(
self.tr("NaN / Inf"))
self.check_nan_and_inf_action.triggered.connect(self.check_nan_and_inf)
self.check_final_distances_action = self.detect_outliers_menu.addAction(
self.tr("Final Loss"))
self.check_final_distances_action.triggered.connect(
self.check_final_distances)
self.check_mean_action = self.detect_outliers_menu.addAction(
self.tr("Mean"))
self.check_mean_action.triggered.connect(
lambda: self.check_component_moments("mean"))
self.check_std_action = self.detect_outliers_menu.addAction(
self.tr("Sorting Coefficient"))
self.check_std_action.triggered.connect(
lambda: self.check_component_moments("std"))
self.check_skewness_action = self.detect_outliers_menu.addAction(
self.tr("Skewness"))
self.check_skewness_action.triggered.connect(
lambda: self.check_component_moments("skewness"))
self.check_kurtosis_action = self.detect_outliers_menu.addAction(
self.tr("Kurtosis"))
self.check_kurtosis_action.triggered.connect(
lambda: self.check_component_moments("kurtosis"))
self.check_proportion_action = self.detect_outliers_menu.addAction(
self.tr("Proportion"))
self.check_proportion_action.triggered.connect(
self.check_component_proportion)
self.data_table.customContextMenuRequested.connect(self.show_menu)
self.data_table.itemSelectionChanged.connect(self.on_selection_changed)
# necessary to add actions of menu to this widget itself,
# otherwise, the shortcuts will not be triggered
self.addActions(self.menu.actions())
self.boxplot_chart = BoxplotChart()
self.loss_chart = LossSeriesChart()
self.update_page_list()
self.update_page(self.page_index)
self.normal_msg = QtWidgets.QMessageBox(self)
self.parameter_table = None
def select_list(self):
items = [
self.list_widget.item(i) for i in range(self.list_widget.count())
]
self.list_widget.clearSelection()
for item in items[2:5]:
item.setSelected(True)
self.list_widget.setCurrentItem(items[4])
def select_tree(self):
items = [
self.tree_widget.topLevelItem(i)
for i in range(self.tree_widget.topLevelItemCount())
]
self.tree_widget.clearSelection()
for item in items[2:5]:
item.setSelected(True)
if self.sel_flag_check.isChecked():
self.tree_widget.setCurrentItem(items[4], 0,
QtCore.QItemSelectionModel.Current)
else:
self.tree_widget.setCurrentItem(items[4])
if __name__ == '__main__':
app = QtWidgets.QApplication([])
win = Demo()
win.show()
app.exec_()
def createConclusionPage():
page = QtWidgets.QWizardPage()
page.setTitle("Conclusion")
label = QtWidgets.QLabel("You are now successfully registered. Have a nice day!")
label.setWordWrap(True)
layout = QtWidgets.QVBoxLayout()
layout.addWidget(label)
page.setLayout(layout)
return page
if __name__ == '__main__':
import sys
app = QtWidgets.QApplication(sys.argv)
wizard = QtWidgets.QWizard()
wizard.addPage(createIntroPage())
wizard.addPage(createRegistrationPage())
wizard.addPage(createConclusionPage())
wizard.setWindowTitle("Trivial Wizard")
wizard.show()
sys.exit(wizard.exec_())
span = int(span)
y = FractionSlider.YMARGIN - 0.5
triangle = [
QtCore.QPointF(value * span, y),
QtCore.QPointF((value * span) + (2 * FractionSlider.XMARGIN), y),
QtCore.QPointF((value * span) + FractionSlider.XMARGIN, fm.height()),
]
painter.setPen(QtCore.Qt.yellow)
painter.setBrush(QtCore.Qt.darkYellow)
painter.drawPolygon(QtGui.QPolygonF(triangle))
if __name__ == "__main__":
import sys
app = QtWidgets.QApplication(sys.argv)
form = QtWidgets.QDialog()
sliderLabel = QtWidgets.QLabel("&Fraction")
slider = FractionSlider(denominator=12)
sliderLabel.setBuddy(slider)
denominatorLabel = QtWidgets.QLabel("&Denominator")
denominatorSpinBox = QtWidgets.QSpinBox()
denominatorLabel.setBuddy(denominatorSpinBox)
denominatorSpinBox.setRange(3, 60)
denominatorSpinBox.setValue(slider.fraction()[1])
denominatorSpinBox.setAlignment(QtCore.Qt.AlignRight | QtCore.Qt.AlignVCenter)
numeratorLabel = QtWidgets.QLabel("Numerator")
numeratorLCD = QtWidgets.QLCDNumber()
numeratorLCD.setSegmentStyle(QtWidgets.QLCDNumber.Flat)
layout = QtWidgets.QGridLayout()
layout.addWidget(sliderLabel, 0, 0)
def main():
app = qw.QApplication([])
standup = StandUpWindow()
standup.setWindowIcon(QtGui.QIcon(":/icons/window_icon.png"))
standup.show()
sys.exit(app.exec())
def main():
acc.app = QtWidgets.QApplication([])
acc.main = StartupConfiguration()
acc.main.setup_ui()
acc.app.exec()
def init_ui(self):
# Create palettes used by intervals
# NOTE : this was part of the colorContainer and addInterval rework.
# I don't even know if it is worth the tradeoff because now I store a list with two QPalettes instead of making them on the fly.
# I think it's better to avoid calling colorContainer multiple times for no reason.
_ODD_PALETTE = QtGui.QPalette()
_ODD_PALETTE.setColor(
_ODD_PALETTE.Window,
_ODD_PALETTE.color(_ODD_PALETTE.Active,
_ODD_PALETTE.AlternateBase))
_EVEN_PALETTE = QtGui.QPalette()
_EVEN_PALETTE.setColor(
_EVEN_PALETTE.Window,
_EVEN_PALETTE.color(_EVEN_PALETTE.Active, _EVEN_PALETTE.Base))
self._PALETTES = [_EVEN_PALETTE, _ODD_PALETTE]
self.layout = qw.QGridLayout(self)
# The units for these SpinBoxes is minutes but the timer uses seconds
self.session_dur_label = qw.QLabel("Session Length:")
self.session_duration = DurationSpinBox()
self.interval_options_container = qw.QWidget()
self.interval_options_grid = qw.QGridLayout(
self.interval_options_container)
focus_label = qw.QLabel("Focus Intervals")
break_label = qw.QLabel("Break Intervals")
focus_interval_scroll = qw.QScrollArea()
focus_interval_scroll.setHorizontalScrollBarPolicy(
QtCore.Qt.ScrollBarAlwaysOff)
focus_interval_scroll.setWidgetResizable(True)
focus_interval_scroll.setSizePolicy(qw.QSizePolicy.Minimum,
qw.QSizePolicy.Expanding)
focus_interval_frame = qw.QFrame()
focus_interval_frame.setFrameStyle(qw.QFrame.StyledPanel
| qw.QFrame.Sunken)
self.focus_intervals_container = qw.QVBoxLayout(focus_interval_frame)
self.focus_intervals_container.setAlignment(QtCore.Qt.AlignTop)
focus_interval_scroll.setWidget(focus_interval_frame)
break_interval_scroll = qw.QScrollArea()
break_interval_scroll.setHorizontalScrollBarPolicy(
QtCore.Qt.ScrollBarAlwaysOff)
break_interval_scroll.setWidgetResizable(True)
break_interval_scroll.setSizePolicy(qw.QSizePolicy.Minimum,
qw.QSizePolicy.Expanding)
break_interval_frame = qw.QFrame()
break_interval_frame.setFrameStyle(qw.QFrame.StyledPanel
| qw.QFrame.Sunken)
self.break_intervals_container = qw.QVBoxLayout(break_interval_frame)
self.break_intervals_container.setAlignment(QtCore.Qt.AlignTop)
break_interval_scroll.setWidget(break_interval_frame)
self.add_focus_interval = qw.QPushButton("+ Focus")
self.add_focus_interval.clicked.connect(self.addFocusInterval)
self.add_focus_interval.setToolTip("Add focus interval")
self.add_break_interval = qw.QPushButton("+ Break")
self.add_break_interval.clicked.connect(self.addBreakInterval)
self.add_break_interval.setToolTip("Add break interval")
self.interval_options_grid.addWidget(focus_label, 0, 0,
QtCore.Qt.AlignCenter)
self.interval_options_grid.addWidget(break_label, 0, 1,
QtCore.Qt.AlignCenter)
self.interval_options_grid.addWidget(focus_interval_scroll, 1, 0)
self.interval_options_grid.addWidget(break_interval_scroll, 1, 1)
self.interval_options_grid.addWidget(self.add_focus_interval, 2, 0)
self.interval_options_grid.addWidget(self.add_break_interval, 2, 1)
self.interval_options_grid.setRowStretch(1, 1)
self.layout.addWidget(self.session_dur_label, 0, 0,
QtCore.Qt.AlignRight)
self.layout.addWidget(self.session_duration, 0, 1, QtCore.Qt.AlignLeft)
self.layout.addWidget(self.interval_options_container, 1, 0, 1, 2)
self.layout.setRowStretch(1, 1)
self.addFocusInterval()
self.addBreakInterval()
def __init__(self, parent=None):
super().__init__(parent=parent)
self.setAttribute(QtCore.Qt.WA_StyledBackground, True)
self.setWindowTitle(self.tr("Dataset Loader"))
self.main_layout = QtWidgets.QGridLayout(self)
self.filename_display = QtWidgets.QLabel(self.tr("Filename Unknown"))
self.main_layout.addWidget(self.filename_display, 0, 0)
self.select_button = QtWidgets.QPushButton(self.tr("Select"))
self.select_button.clicked.connect(self.on_select_clicked)
self.main_layout.addWidget(self.select_button, 0, 1)
self.sheet_label = QtWidgets.QLabel(self.tr("Sheet Name"))
self.sheet_combo_box = QtWidgets.QComboBox()
self.sheet_combo_box.addItem(self.tr("Empty"))
self.main_layout.addWidget(self.sheet_label, 1, 0)
self.main_layout.addWidget(self.sheet_combo_box, 1, 1)
self.class_row_label = QtWidgets.QLabel(
self.tr("Row With Grain Size Classes"))
self.class_row_input = QtWidgets.QSpinBox()
self.class_row_input.setRange(1, 999)
self.main_layout.addWidget(self.class_row_label, 2, 0)
self.main_layout.addWidget(self.class_row_input, 2, 1)
self.name_column_label = QtWidgets.QLabel(
self.tr("Column With Sample Names"))
self.name_column_input = QtWidgets.QSpinBox()
self.name_column_input.setRange(1, 999)
self.main_layout.addWidget(self.name_column_label, 3, 0)
self.main_layout.addWidget(self.name_column_input, 3, 1)
self.start_row_label = QtWidgets.QLabel(
self.tr("Start Row of Distributions"))
self.start_row_input = QtWidgets.QSpinBox()
self.start_row_input.setRange(2, 999999)
self.main_layout.addWidget(self.start_row_label, 4, 0)
self.main_layout.addWidget(self.start_row_input, 4, 1)
self.start_column_label = QtWidgets.QLabel(
self.tr("Start Column of Distributions"))
self.start_column_input = QtWidgets.QSpinBox()
self.start_column_input.setRange(2, 999999)
self.main_layout.addWidget(self.start_column_label, 5, 0)
self.main_layout.addWidget(self.start_column_input, 5, 1)
self.try_load_button = QtWidgets.QPushButton(self.tr("Try Load"))
self.try_load_button.clicked.connect(self.on_try_load_clicked)
self.try_load_button.setEnabled(False)
self.main_layout.addWidget(self.try_load_button, 6, 0, 1, 2)
self.normal_msg = QtWidgets.QMessageBox(self)
self.file_dialog = QtWidgets.QFileDialog(parent=self)
self._filename = ""
def load_pet_ct(self, roi_color=None, iso_color=None, slice_view="axial",
format_metadata=True):
"""
Loads the PET/CT GUI after data has been added to PTCTDictContainer
"""
self.pt_ct_dict_container = PTCTDictContainer()
self.iso_color = iso_color
self.zoom = 1
self.current_slice_number = None
self.slice_view = slice_view
self.overlay_view = slice_view
self.display_metadata = False
self.format_metadata = format_metadata
self.dicom_view_layout = QtWidgets.QHBoxLayout()
self.radio_button_layout = QtWidgets.QHBoxLayout()
self.slider_layout = QtWidgets.QHBoxLayout()
# self.radio_button_layout.setAlignment(QtCore.Qt.AlignCenter)
# Create components
self.slider = QtWidgets.QSlider(QtCore.Qt.Vertical)
self.init_slider()
self.view = QtWidgets.QGraphicsView()
# Alpha slider
self.alpha_slider = QtWidgets.QSlider(QtCore.Qt.Horizontal)
self.init_alpha_slider()
# Slider labels
self.ct_label = QtWidgets.QLabel("CT")
self.pt_label = QtWidgets.QLabel("PET")
self.init_view()
self.scene = QtWidgets.QGraphicsScene()
# radio buttons
self.coronal_button = QRadioButton("Coronal")
self.coronal_button.setChecked(False)
self.coronal_button.toggled.connect(self.update_axis)
self.axial_button = QRadioButton("Axial")
self.axial_button.setChecked(True)
self.axial_button.toggled.connect(self.update_axis)
self.sagittal_button = QRadioButton("Sagittal")
self.sagittal_button.setChecked(False)
self.sagittal_button.toggled.connect(self.update_axis)
# Set layout
self.dicom_view_layout.addWidget(self.view)
self.dicom_view_layout.addWidget(self.slider)
self.slider_layout.addWidget(self.ct_label)
self.slider_layout.addWidget(self.alpha_slider)
self.slider_layout.addWidget(self.pt_label)
self.load_pet_ct_button.setVisible(False)
self.pet_ct_view_layout.removeWidget(self.load_pet_ct_button)
self.pet_ct_view_layout.addLayout(self.dicom_view_layout)
self.pet_ct_view_layout.addLayout(self.slider_layout)
self.pet_ct_view_layout.addLayout(self.radio_button_layout,
QtCore.Qt.AlignBottom
| QtCore.Qt.AlignCenter)
self.radio_button_layout.addWidget(self.coronal_button)
self.radio_button_layout.addWidget(self.axial_button)
self.radio_button_layout.addWidget(self.sagittal_button)
self.setLayout(self.pet_ct_view_layout)
self.update_view()
self.initialised = True
def __init__(self, options: Options, preset_manager: PresetManager,
network_client, preview: bool):
super().__init__()
self.setupUi(self)
self.setWindowTitle("Randovania {}".format(VERSION))
self._is_preview_mode = preview
self.setAcceptDrops(True)
common_qt_lib.set_default_window_icon(self)
self.setup_about_text()
self.setup_welcome_text()
self.browse_racetime_label.setText(
self.browse_racetime_label.text().replace("color:#0000ff;", ""))
self._preset_manager = preset_manager
self.network_client = network_client
if preview:
debug.set_level(2)
if randovania.is_frozen():
self.menu_bar.removeAction(self.menu_edit.menuAction())
# Signals
self.options_changed_signal.connect(self.on_options_changed)
self.GameDetailsSignal.connect(self._open_game_details)
self.InitPostShowSignal.connect(self.initialize_post_show)
self.intro_play_now_button.clicked.connect(
lambda: self.main_tab_widget.setCurrentWidget(self.tab_play))
self.open_faq_button.clicked.connect(self._open_faq)
self.open_database_viewer_button.clicked.connect(
partial(self._open_data_visualizer_for_game,
RandovaniaGame.METROID_PRIME_ECHOES))
self.import_permalink_button.clicked.connect(self._import_permalink)
self.import_game_file_button.clicked.connect(self._import_spoiler_log)
self.browse_racetime_button.clicked.connect(self._browse_racetime)
self.create_new_seed_button.clicked.connect(
lambda: self.main_tab_widget.setCurrentWidget(self.tab_create_seed
))
# Menu Bar
self.game_menus = []
self.menu_action_edits = []
for game in RandovaniaGame.sorted_all_games():
# Sub-Menu in Open Menu
game_menu = QtWidgets.QMenu(self.menu_open)
game_menu.setTitle(_t(game.long_name))
game_menu.game = game
if game.data.development_state.can_view(False):
self.menu_open.addAction(game_menu.menuAction())
self.game_menus.append(game_menu)
game_trick_details_menu = QtWidgets.QMenu(game_menu)
game_trick_details_menu.setTitle(_t("Trick Details"))
self._setup_trick_difficulties_menu_on_show(
game_trick_details_menu, game)
game_data_visualizer_action = QtGui.QAction(game_menu)
game_data_visualizer_action.setText(_t("Data Visualizer"))
game_data_visualizer_action.triggered.connect(
partial(self._open_data_visualizer_for_game, game))
game_menu.addAction(game_trick_details_menu.menuAction())
game_menu.addAction(game_data_visualizer_action)
# Data Editor
action = QtGui.QAction(self)
action.setText(_t(game.long_name))
self.menu_internal.addAction(action)
action.triggered.connect(
partial(self._open_data_editor_for_game, game))
self.menu_action_edits.append(action)
self.menu_action_edit_existing_database.triggered.connect(
self._open_data_editor_prompt)
self.menu_action_validate_seed_after.triggered.connect(
self._on_validate_seed_change)
self.menu_action_timeout_generation_after_a_time_limit.triggered.connect(
self._on_generate_time_limit_change)
self.menu_action_dark_mode.triggered.connect(
self._on_menu_action_dark_mode)
self.menu_action_experimental_games.triggered.connect(
self._on_menu_action_experimental_games)
self.menu_action_open_auto_tracker.triggered.connect(
self._open_auto_tracker)
self.menu_action_previously_generated_games.triggered.connect(
self._on_menu_action_previously_generated_games)
self.menu_action_log_files_directory.triggered.connect(
self._on_menu_action_log_files_directory)
self.menu_action_layout_editor.triggered.connect(
self._on_menu_action_layout_editor)
# Setting this event only now, so all options changed trigger only once
options.on_options_changed = self.options_changed_signal.emit
self._options = options
self.main_tab_widget.setCurrentIndex(0)
def setup_ui(self, open_pt_ct_window_instance):
if platform.system() == 'Darwin':
self.stylesheet_path = "res/stylesheet.qss"
else:
self.stylesheet_path = "res/stylesheet-win-linux.qss"
window_icon = QIcon()
window_icon.addPixmap(QPixmap(resource_path("res/images/icon.ico")),
QIcon.Normal, QIcon.Off)
open_pt_ct_window_instance.setObjectName("OpenPTCTWindowInstance")
open_pt_ct_window_instance.setWindowIcon(window_icon)
open_pt_ct_window_instance.resize(840, 530)
# Create a vertical box for containing the other elements and layouts
self.open_patient_window_instance_vertical_box = QVBoxLayout()
self.open_patient_window_instance_vertical_box.setObjectName(
"OpenPatientWindowInstanceVerticalBox")
# Create a label to prompt the user to enter the path to the directory
# that contains the DICOM files
self.open_patient_directory_prompt = QLabel()
self.open_patient_directory_prompt.setObjectName(
"OpenPatientDirectoryPrompt")
self.open_patient_directory_prompt.setAlignment(Qt.AlignLeft)
self.open_patient_window_instance_vertical_box.addWidget(
self.open_patient_directory_prompt)
# Create a horizontal box to hold the input box for the directory and
# the choose button
self.open_patient_directory_input_horizontal_box = QHBoxLayout()
self.open_patient_directory_input_horizontal_box.setObjectName(
"OpenPatientDirectoryInputHorizontalBox")
# Create a textbox to contain the path to the directory that contains
# the DICOM files
self.open_patient_directory_input_box = \
UIOpenPTCTPatientWindowDragAndDropEvent(self)
self.open_patient_directory_input_box.setObjectName(
"OpenPatientDirectoryInputBox")
self.open_patient_directory_input_box.setSizePolicy(
QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding))
self.open_patient_directory_input_box.returnPressed.connect(
self.scan_directory_for_patient)
self.open_patient_directory_input_horizontal_box.addWidget(
self.open_patient_directory_input_box)
# Create a choose button to open the file dialog
self.open_patient_directory_choose_button = QPushButton()
self.open_patient_directory_choose_button.setObjectName(
"OpenPatientDirectoryChooseButton")
self.open_patient_directory_choose_button.setSizePolicy(
QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding))
self.open_patient_directory_choose_button.resize(
self.open_patient_directory_choose_button.sizeHint().width(),
self.open_patient_directory_input_box.height())
self.open_patient_directory_choose_button.setCursor(
QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.open_patient_directory_input_horizontal_box.addWidget(
self.open_patient_directory_choose_button)
self.open_patient_directory_choose_button.clicked.connect(
self.choose_button_clicked)
# Create a widget to hold the input fields
self.open_patient_directory_input_widget = QWidget()
self.open_patient_directory_input_horizontal_box.setStretch(0, 4)
self.open_patient_directory_input_widget.setLayout(
self.open_patient_directory_input_horizontal_box)
self.open_patient_window_instance_vertical_box.addWidget(
self.open_patient_directory_input_widget)
# Create a horizontal box to hold the stop button and direction to the
# user on where to select the patient
self.open_patient_appear_prompt_and_stop_horizontal_box = QHBoxLayout()
self.open_patient_appear_prompt_and_stop_horizontal_box.setObjectName(
"OpenPatientAppearPromptAndStopHorizontalBox")
# Create a label to show direction on where the files will appear
self.open_patient_directory_appear_prompt = QLabel()
self.open_patient_directory_appear_prompt.setObjectName(
"OpenPatientDirectoryAppearPrompt")
self.open_patient_directory_appear_prompt.setAlignment(Qt.AlignLeft)
self.open_patient_appear_prompt_and_stop_horizontal_box.addWidget(
self.open_patient_directory_appear_prompt)
self.open_patient_appear_prompt_and_stop_horizontal_box.addStretch(1)
# Create a button to stop searching
self.open_patient_window_stop_button = QPushButton()
self.open_patient_window_stop_button.setObjectName(
"OpenPatientWindowStopButton")
self.open_patient_window_stop_button.setSizePolicy(
QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding))
self.open_patient_window_stop_button.resize(
self.open_patient_window_stop_button.sizeHint().width(),
self.open_patient_window_stop_button.sizeHint().height())
self.open_patient_window_stop_button.setCursor(
QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.open_patient_window_stop_button.clicked.connect(
self.stop_button_clicked)
self.open_patient_window_stop_button.setProperty(
"QPushButtonClass", "fail-button")
self.open_patient_window_stop_button.setVisible(
False) # Button doesn't show until a search commences
self.open_patient_appear_prompt_and_stop_horizontal_box.addWidget(
self.open_patient_window_stop_button)
# Create a widget to hold the layout
self.open_patient_appear_prompt_and_stop_widget = QWidget()
self.open_patient_appear_prompt_and_stop_widget.setLayout(
self.open_patient_appear_prompt_and_stop_horizontal_box)
self.open_patient_window_instance_vertical_box.addWidget(
self.open_patient_appear_prompt_and_stop_widget)
# Create a tree view list to list out all patients in the directory
# selected above
self.open_patient_window_patients_tree = QTreeWidget()
self.open_patient_window_patients_tree.setObjectName(
"OpenPatientWindowPatientsTree")
self.open_patient_window_patients_tree.setSizePolicy(
QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding))
self.open_patient_window_patients_tree.resize(
self.open_patient_window_patients_tree.sizeHint().width(),
self.open_patient_window_patients_tree.sizeHint().height())
self.open_patient_window_patients_tree.setHeaderHidden(False)
self.open_patient_window_patients_tree.setHeaderLabels([""])
self.open_patient_window_patients_tree.itemClicked.connect(
self.tree_item_clicked)
self.open_patient_window_instance_vertical_box.addWidget(
self.open_patient_window_patients_tree)
# Create a label to show what would happen if they select the patient
self.open_patient_directory_result_label = QtWidgets.QLabel()
self.open_patient_directory_result_label.setObjectName(
"OpenPatientDirectoryResultLabel")
self.open_patient_directory_result_label.setAlignment(Qt.AlignLeft)
self.open_patient_window_instance_vertical_box.addWidget(
self.open_patient_directory_result_label)
# Create a horizontal box to hold the Cancel and Open button
self.open_patient_window_patient_open_actions_horizontal_box = \
QHBoxLayout()
self.open_patient_window_patient_open_actions_horizontal_box. \
setObjectName("OpenPatientWindowPatientOpenActionsHorizontalBox")
self.open_patient_window_patient_open_actions_horizontal_box. \
addStretch(1)
# Add a button to go back/exit from the application
self.open_patient_window_exit_button = QPushButton()
self.open_patient_window_exit_button.setObjectName(
"OpenPatientWindowExitButton")
self.open_patient_window_exit_button.setSizePolicy(
QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding))
self.open_patient_window_exit_button.resize(
self.open_patient_window_stop_button.sizeHint().width(),
self.open_patient_window_stop_button.sizeHint().height())
self.open_patient_window_exit_button.setCursor(
QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.open_patient_window_exit_button.clicked.connect(
self.exit_button_clicked)
self.open_patient_window_exit_button.setProperty(
"QPushButtonClass", "fail-button")
self.open_patient_window_patient_open_actions_horizontal_box.addWidget(
self.open_patient_window_exit_button)
# Add a button to confirm opening of the patient
self.open_patient_window_confirm_button = QPushButton()
self.open_patient_window_confirm_button.setObjectName(
"OpenPatientWindowConfirmButton")
self.open_patient_window_confirm_button.setSizePolicy(
QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.MinimumExpanding))
self.open_patient_window_confirm_button.resize(
self.open_patient_window_confirm_button.sizeHint().width(),
self.open_patient_window_confirm_button.sizeHint().height())
self.open_patient_window_confirm_button.setCursor(
QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.open_patient_window_confirm_button.setDisabled(True)
self.open_patient_window_confirm_button.clicked.connect(
self.confirm_button_clicked)
self.open_patient_window_confirm_button.setProperty(
"QPushButtonClass", "success-button")
self.open_patient_window_patient_open_actions_horizontal_box.addWidget(
self.open_patient_window_confirm_button)
# Create a widget to house all of the actions button for open patient
# window
self.open_patient_window_patient_open_actions_widget = QWidget()
self.open_patient_window_patient_open_actions_widget.setLayout(
self.open_patient_window_patient_open_actions_horizontal_box)
self.open_patient_window_instance_vertical_box.addWidget(
self.open_patient_window_patient_open_actions_widget)
# Set the vertical box fourth element, the tree view, to stretch out as
# far as possible
self.open_patient_window_instance_vertical_box.setStretch(
3, 4) # Stretch the treeview out as far as possible
self.open_patient_window_instance_central_widget = QWidget()
self.open_patient_window_instance_central_widget.setObjectName(
"OpenPatientWindowInstanceCentralWidget")
self.open_patient_window_instance_central_widget.setLayout(
self.open_patient_window_instance_vertical_box)
# Create threadpool for multithreading
self.threadpool = QThreadPool()
print("Multithreading with maximum %d threads" %
self.threadpool.maxThreadCount())
# Create interrupt event for stopping the directory search
self.interrupt_flag = threading.Event()
# Bind all texts into the buttons and labels
self.retranslate_ui(open_pt_ct_window_instance)
# Set the central widget, ready for display
open_pt_ct_window_instance.setCentralWidget(
self.open_patient_window_instance_central_widget)
# Set the current stylesheet to the instance and connect it back to the
# caller through slot
_stylesheet = open(resource_path(self.stylesheet_path)).read()
open_pt_ct_window_instance.setStyleSheet(_stylesheet)
QtCore.QMetaObject.connectSlotsByName(open_pt_ct_window_instance)
def __init__(self, editor: PresetEditor, game_description: GameDescription,
window_manager: WindowManager):
super().__init__(editor)
self.setupUi(self)
self.game_description = game_description
self._window_manager = window_manager
self.trick_level_layout.setAlignment(QtCore.Qt.AlignTop)
signal_handling.on_checked(self.underwater_abuse_check,
self._on_underwater_abuse_check)
self.underwater_abuse_label.linkActivated.connect(
self._on_click_link_underwater_details)
self.trick_difficulties_layout = QtWidgets.QGridLayout()
self._slider_for_trick = {}
tricks_in_use = trick_lib.used_tricks(self.game_description)
size_policy = QtWidgets.QSizePolicy(QtWidgets.QSizePolicy.Fixed,
QtWidgets.QSizePolicy.Preferred)
self.trick_level_line_1.setVisible(
self.game_enum != RandovaniaGame.METROID_PRIME_CORRUPTION)
self.underwater_abuse_label.setText(
self.underwater_abuse_label.text().replace("color:#0000ff;", ""))
if self.game_enum != RandovaniaGame.METROID_PRIME:
for w in [
self.underwater_abuse_check, self.underwater_abuse_label
]:
w.setVisible(False)
self._create_difficulty_details_row()
row = 2
for trick in sorted(self.game_description.resource_database.trick,
key=lambda _trick: _trick.long_name):
if trick not in tricks_in_use:
continue
if row > 1:
self.trick_difficulties_layout.addItem(
QtWidgets.QSpacerItem(20, 40,
QtWidgets.QSizePolicy.Minimum,
QtWidgets.QSizePolicy.Expanding))
trick_label = QtWidgets.QLabel(self.trick_level_scroll_contents)
trick_label.setSizePolicy(size_policy)
trick_label.setWordWrap(True)
trick_label.setFixedWidth(100)
trick_label.setText(trick.long_name)
self.trick_difficulties_layout.addWidget(trick_label, row, 1, 1, 1)
slider_layout = QtWidgets.QGridLayout()
slider_layout.setHorizontalSpacing(0)
for i in range(12):
slider_layout.setColumnStretch(i, 1)
horizontal_slider = QtWidgets.QSlider(
self.trick_level_scroll_contents)
horizontal_slider.setMaximum(5)
horizontal_slider.setPageStep(2)
horizontal_slider.setOrientation(QtCore.Qt.Horizontal)
horizontal_slider.setTickPosition(QtWidgets.QSlider.TicksBelow)
horizontal_slider.setEnabled(False)
horizontal_slider.valueChanged.connect(
functools.partial(self._on_slide_trick_slider, trick))
self._slider_for_trick[trick] = horizontal_slider
slider_layout.addWidget(horizontal_slider, 0, 1, 1, 10)
used_difficulties = trick_lib.difficulties_for_trick(
self.game_description, trick)
for i, trick_level in enumerate(
enum_lib.iterate_enum(LayoutTrickLevel)):
if trick_level == LayoutTrickLevel.DISABLED or trick_level in used_difficulties:
difficulty_label = QtWidgets.QLabel(
self.trick_level_scroll_contents)
difficulty_label.setAlignment(QtCore.Qt.AlignHCenter)
difficulty_label.setText(trick_level.long_name)
slider_layout.addWidget(difficulty_label, 1, 2 * i, 1, 2)
self.trick_difficulties_layout.addLayout(slider_layout, row, 2, 1,
1)
if self._window_manager is not None:
tool_button = QtWidgets.QToolButton(
self.trick_level_scroll_contents)
tool_button.setText("?")
tool_button.clicked.connect(
functools.partial(self._open_trick_details_popup, trick))
self.trick_difficulties_layout.addWidget(
tool_button, row, 3, 1, 1)
row += 1
self.trick_level_layout.addLayout(self.trick_difficulties_layout)
def _addTreeChildren(self, pNode):
pNode.addChild(QtWidgets.QTreeWidgetItem(["Light"]))
pNode.addChild(QtWidgets.QTreeWidgetItem(["Temperature"]))
pNode.addChild(QtWidgets.QTreeWidgetItem(["Humidity"]))
pNode.addChild(QtWidgets.QTreeWidgetItem(["Moisture"]))
## DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
## THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
## (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
## OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
##
## $QT_END_LICENSE$
##
############################################################################
import sys
from PySide6 import QtCore, QtWidgets
try:
from PySide6 import QtMacExtras
except ImportError:
app = QtWidgets.QApplication(sys.argv)
messageBox = QtWidgets.QMessageBox(QtWidgets.QMessageBox.Critical, "QtMacExtras macpasteboardmime",
"This exampe only runs on macOS and QtMacExtras must be installed to run this example.",
QtWidgets.QMessageBox.Close)
messageBox.exec_()
sys.exit(1)
class VCardMime(QtMacExtras.QMacPasteboardMime):
def __init__(self, t = QtMacExtras.QMacPasteboardMime.MIME_ALL):
super(VCardMime, self).__init__(t)
def convertorName(self):
return "VCardMime"
def canConvert(self, mime, flav):
if self.mimeFor(flav) == mime:
def __init__(self, parent):
super().__init__()
self._parent = parent
self.layout = QtWidgets.QVBoxLayout()
self.frame_shape = QtWidgets.QFrame.StyledPanel
self.layout.add_widget(QtWidgets.QLabel('Suspects'))
suspect_form = QtWidgets.QFormLayout()
for suspect in Suspects.get_suspect_list():
checkbox = QtWidgets.QCheckBox()
checkbox.tristate = True
suspect_form.add_row(QtWidgets.QLabel(suspect),
checkbox)
self.layout.add_layout(suspect_form)
self.layout.add_widget(QHLine())
self.layout.add_widget(QtWidgets.QLabel('Rooms'))
room_form = QtWidgets.QFormLayout()
for room in Rooms.get_room_list():
checkbox = QtWidgets.QCheckBox()
checkbox.tristate = True
room_form.add_row(QtWidgets.QLabel(room),
checkbox)
self.layout.add_layout(room_form)
self.layout.add_widget(QHLine())
self.layout.add_widget(QtWidgets.QLabel('Weapons'))
weapon_form = QtWidgets.QFormLayout()
for weapon in Weapons.get_weapon_list():
checkbox = QtWidgets.QCheckBox()
checkbox.tristate = True
weapon_form.add_row(QtWidgets.QLabel(weapon),
checkbox)
self.layout.add_layout(weapon_form)
self.layout.add_widget(QHLine())
self.set_layout(self.layout)
def __init__(self):
super(Demo, self).__init__()
w = QtWidgets.QWidget(self)
self.setCentralWidget(w)
hlyt = QtWidgets.QHBoxLayout(w)
vlyt = QtWidgets.QVBoxLayout()
vlyt.addWidget(QtWidgets.QLabel('<b>QListWidget</b>'))
self.list_widget = QtWidgets.QListWidget(self)
self.list_widget.addItems(ITEMS)
self.list_widget.setSelectionMode(
self.list_widget.SelectionMode.ExtendedSelection)
vlyt.addWidget(self.list_widget)
button = QtWidgets.QPushButton('Select items and set current')
button.clicked.connect(self.select_list)
vlyt.addWidget(button)
hlyt.addLayout(vlyt)
vlyt = QtWidgets.QVBoxLayout()
vlyt.addWidget(QtWidgets.QLabel('<b>QTreeWidget</b>'))
self.tree_widget = QtWidgets.QTreeWidget(self)
self.tree_widget.header().setVisible(False)
self.tree_widget.setIndentation(0)
for name in ITEMS:
QtWidgets.QTreeWidgetItem(self.tree_widget, [name])
self.tree_widget.setSelectionMode(
self.tree_widget.SelectionMode.ExtendedSelection)
button = QtWidgets.QPushButton('Select items and set current')
button.clicked.connect(self.select_tree)
vlyt.addWidget(self.tree_widget)
vlyt.addWidget(button)
self.sel_flag_check = QtWidgets.QCheckBox('Pass SelectionFlag.Current')
vlyt.addWidget(self.sel_flag_check)
hlyt.addLayout(vlyt)
def __init__(self):
super().__init__()
# global self.params_cell_def
# self.cell_defs = CellDefInstances()
self.cell_def_horiz_layout = QtWidgets.QHBoxLayout()
splitter = QtWidgets.QSplitter()
self.tree = QtWidgets.QTreeWidget()
self.tree.setStyleSheet("background-color: lightgray")
# self.tree.setColumnCount(1)
header = QTreeWidgetItem(["--- Substrate or Signal---"])
self.tree.setHeaderItem(header)
cellname = QTreeWidgetItem(["virus"])
self.tree.insertTopLevelItem(0, cellname)
cellname = QTreeWidgetItem(["interferon"])
self.tree.insertTopLevelItem(1, cellname)
self.cell_def_horiz_layout.addWidget(self.tree)
self.scroll_cell_def_tree = QtWidgets.QScrollArea()
self.scroll_cell_def_tree.setWidget(self.tree)
# splitter.addWidget(self.tree)
splitter.addWidget(self.scroll_cell_def_tree)
#-------------------------------------------
# self.tab = QtWidgets.QWidget()
# self.tabs.resize(200,5)
#-------------------------------------------
label_width = 150
units_width = 70
self.scroll = QtWidgets.QScrollArea()
splitter.addWidget(self.scroll)
# self.cell_def_horiz_layout.addWidget(self.scroll)
self.params_cell_def = QtWidgets.QWidget()
self.vbox = QtWidgets.QVBoxLayout()
self.vbox.addStretch(0)
# self.cell_def_horiz_layout.addWidget(self.)
#------------------
hbox = QtWidgets.QHBoxLayout()
label = QtWidgets.QLabel("Name of substrate or signal:")
label.setFixedWidth(180)
label.setAlignment(QtCore.Qt.AlignRight)
hbox.addWidget(label)
self.cell_type_name = QLineEdit()
# Want to validate name, e.g., starts with alpha, no special chars, etc.
# self.cycle_trate0_0.setValidator(QtGui.QDoubleValidator())
# self.cycle_trate0_1.enter.connect(self.save_xml)
hbox.addWidget(self.cell_type_name)
self.vbox.addLayout(hbox)
#------------------
hbox = QtWidgets.QHBoxLayout()
label = QtWidgets.QLabel("diffusion coefficient")
label.setFixedWidth(label_width)
label.setAlignment(QtCore.Qt.AlignRight)
hbox.addWidget(label)
self.diffusion_coef = QtWidgets.QLineEdit()
self.diffusion_coef.setValidator(QtGui.QDoubleValidator())
# self.diffusion_coef.enter.connect(self.save_xml)
hbox.addWidget(self.diffusion_coef)
units = QtWidgets.QLabel("micron^2/min")
units.setFixedWidth(units_width)
hbox.addWidget(units)
self.vbox.addLayout(hbox)
#----------
hbox = QtWidgets.QHBoxLayout()
label = QtWidgets.QLabel("decay rate")
label.setFixedWidth(label_width)
label.setAlignment(QtCore.Qt.AlignRight)
hbox.addWidget(label)
self.decay_rate = QtWidgets.QLineEdit()
self.decay_rate.setValidator(QtGui.QDoubleValidator())
# self.decay_rate.enter.connect(self.save_xml)
hbox.addWidget(self.decay_rate)
units = QtWidgets.QLabel("1/min")
units.setFixedWidth(units_width)
hbox.addWidget(units)
self.vbox.addLayout(hbox)
#----------
hbox = QtWidgets.QHBoxLayout()
label = QtWidgets.QLabel("initial condition")
label.setFixedWidth(label_width)
label.setAlignment(QtCore.Qt.AlignRight)
hbox.addWidget(label)
self.init_cond = QtWidgets.QLineEdit()
self.init_cond.setValidator(QtGui.QDoubleValidator())
# self.init_cond.enter.connect(self.save_xml)
hbox.addWidget(self.init_cond)
units = QtWidgets.QLabel("mmol")
units.setFixedWidth(units_width)
hbox.addWidget(units)
self.vbox.addLayout(hbox)
#----------
hbox = QtWidgets.QHBoxLayout()
label = QtWidgets.QLabel("Dirichlet BC")
label.setFixedWidth(label_width)
label.setAlignment(QtCore.Qt.AlignRight)
hbox.addWidget(label)
self.bdy_cond = QtWidgets.QLineEdit()
self.bdy_cond.setValidator(QtGui.QDoubleValidator())
# self.bdy_cond.enter.connect(self.save_xml)
hbox.addWidget(self.bdy_cond)
units = QtWidgets.QLabel("mmol")
units.setFixedWidth(units_width)
hbox.addWidget(units)
self.dirichlet_bc_enabled = QtWidgets.QCheckBox("on/off")
# self.motility_enabled.setAlignment(QtCore.Qt.AlignRight)
# label.setFixedWidth(label_width)
hbox.addWidget(self.dirichlet_bc_enabled)
self.vbox.addLayout(hbox)
#-------------
hbox = QtWidgets.QHBoxLayout()
self.gradients = QtWidgets.QCheckBox("calculate gradients")
hbox.addWidget(self.gradients)
self.vbox.addLayout(hbox)
hbox = QtWidgets.QHBoxLayout()
self.track_in_agents = QtWidgets.QCheckBox("track in agents")
hbox.addWidget(self.track_in_agents)
self.vbox.addLayout(hbox)
#--------------------------
# Dummy widget for filler??
label = QLabel("")
label.setFixedHeight(300)
# label.setStyleSheet("background-color: orange")
label.setAlignment(QtCore.Qt.AlignCenter)
self.vbox.addWidget(label)
#==================================================================
self.params_cell_def.setLayout(self.vbox)
self.scroll.setVerticalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
self.scroll.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOn)
self.scroll.setWidgetResizable(True)
self.scroll.setWidget(self.params_cell_def)
# self.save_button = QtWidgets.QPushButton("Save")
# self.text = QtWidgets.QLabel("Hello World",alignment=QtCore.Qt.AlignCenter)
self.layout = QtWidgets.QVBoxLayout(self)
# self.layout.addWidget(self.tabs)
# self.layout.addWidget(QHLine())
# self.layout.addWidget(self.params)
# self.layout.addWidget(self.scroll)
self.layout.addWidget(splitter)
def __init__(self):
super().__init__()
self.setupUi(self)
common_qt_lib.set_default_window_icon(self)
self.game_description = default_database.game_description_for(RandovaniaGame.METROID_PRIME_CORRUPTION)
item_database = default_database.item_database_for_game(RandovaniaGame.METROID_PRIME_CORRUPTION)
world_list = self.game_description.world_list
self._index_to_combo = {}
columns = []
for i in range(2):
columns.append(QtWidgets.QVBoxLayout(self.scroll_area_contents))
self.scroll_area_layout.addLayout(columns[-1])
ids_to_merge = [5406397194789083955, # Phaaze
16039522250714156185,
10717625015048596485,
14806081023590793725,
]
nodes_to_merge = []
world_count = 0
for i, world in enumerate(world_list.worlds):
if world.extra['asset_id'] in ids_to_merge:
nodes_to_merge.extend(
node
for area in world.areas
for node in area.nodes
if isinstance(node, PickupNode)
)
continue
group = QtWidgets.QGroupBox(self.scroll_area_contents)
group.setTitle(world.name)
layout = QtWidgets.QGridLayout(group)
area_count = 0
for area in world.areas:
for node in area.nodes:
if not isinstance(node, PickupNode):
continue
node_label = QtWidgets.QLabel(world_list.node_name(node), group)
layout.addWidget(node_label, area_count, 0)
node_combo = QtWidgets.QComboBox(group)
_fill_combo(item_database, node_combo)
node_combo.currentIndexChanged.connect(self.update_layout_string)
layout.addWidget(node_combo, area_count, 1)
self._index_to_combo[node.pickup_index] = node_combo
area_count += 1
columns[world_count % len(columns)].addWidget(group)
world_count += 1
group = QtWidgets.QGroupBox(self.scroll_area_contents)
group.setTitle("Seeds")
layout = QtWidgets.QGridLayout(group)
area_count = 0
for node in nodes_to_merge:
if not isinstance(node, PickupNode):
continue
node_label = QtWidgets.QLabel(world_list.node_name(node), group)
layout.addWidget(node_label, area_count, 0)
node_combo = QtWidgets.QComboBox(group)
_fill_combo(item_database, node_combo)
node_combo.currentIndexChanged.connect(self.update_layout_string)
layout.addWidget(node_combo, area_count, 1)
self._index_to_combo[node.pickup_index] = node_combo
area_count += 1
columns[0].addWidget(group)
# world_count += 1
self.update_layout_string()
def makeGraphicsEffect(self):
if self.selected_effect is None:
self.selected_effect = QtWidgets.QGraphicsColorizeEffect()
self.selected_effect.setColor(QtCore.Qt.darkYellow)
self.selected_effect.setStrength(1)
def setupUi(self):
"""
Constructs the GUI and sets the limit of each input field.
"""
# Create a vertical Widget to hold Vertical Layout
self.vertical_layout_widget = QWidget()
self.vertical_layout = QtWidgets.QVBoxLayout()
# Create a Widget and set layout to a GridLayout
self.gridLayoutWidget = QWidget()
self.gridLayout = QtWidgets.QGridLayout(self.gridLayoutWidget)
self.gridLayout.setSizeConstraint(QLayout.SetDefaultConstraint)
self.gridLayout.setContentsMargins(0, 0, 0, 0)
self.gridLayout.setVerticalSpacing(0)
# Create horizontal spacer in the middle of the grid
hspacer = QtWidgets.QSpacerItem(QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Minimum)
self.gridLayout.addItem(hspacer, 0, 5, 16, 1)
# Labels
self.fixed_image_label = QLabel("Fixed Image: ")
fixed_image_sizePolicy = QSizePolicy(QSizePolicy.Maximum,
QSizePolicy.Preferred)
fixed_image_sizePolicy.setHorizontalStretch(0)
fixed_image_sizePolicy.setVerticalStretch(0)
fixed_image_sizePolicy.setHeightForWidth(
self.fixed_image_label.sizePolicy().hasHeightForWidth())
self.fixed_image_label.setAlignment(Qt.AlignRight | Qt.AlignTrailing
| Qt.AlignVCenter)
self.fixed_image_placeholder \
= QLabel("This is a placeholder for fixed image")
self.fixed_image_placeholder.setWordWrap(False)
self.fixed_image_placeholder.setText(str(self.fixed_image))
self.fixed_image_placeholder.setMaximumSize(200, 50)
self.moving_image_label = QLabel("Moving Image: ")
moving_image_label_sizePolicy = QSizePolicy(QSizePolicy.Maximum,
QSizePolicy.Maximum)
moving_image_label_sizePolicy.setHorizontalStretch(0)
moving_image_label_sizePolicy.setVerticalStretch(0)
moving_image_label_sizePolicy.setHeightForWidth(
self.moving_image_label.sizePolicy().hasHeightForWidth())
self.moving_image_label.setSizePolicy(moving_image_label_sizePolicy)
self.moving_image_placeholder = QLabel("This is a placeholder")
self.moving_image_placeholder.setWordWrap(False)
self.moving_image_placeholder.setText(str(self.moving_image))
self.moving_image_placeholder.setMaximumSize(200, 50)
self.gridLayout.addWidget(self.fixed_image_label, 0, 0)
self.gridLayout.addWidget(self.fixed_image_placeholder, 0, 1)
self.gridLayout.addWidget(self.moving_image_label, 0, 2)
self.gridLayout.addWidget(self.moving_image_placeholder, 0, 3)
# Default Numbers
self.default_numbers_label = QLabel("Default Numbers")
self.default_numbers_label.setAlignment(Qt.AlignLeft | Qt.AlignTrailing
| Qt.AlignVCenter)
self.gridLayout.addWidget(self.default_numbers_label, 1, 0)
self.default_number_spinBox = QSpinBox(self.gridLayoutWidget)
self.default_number_spinBox.setRange(-2147483648, 2147483647)
self.default_number_spinBox.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Fixed)
self.default_number_spinBox.setToolTip(
"Default voxel value. Defaults to -1000.")
self.gridLayout.addWidget(self.default_number_spinBox, 1, 1)
# Final Interp
self.interp_order_label = QLabel("Final Interp")
self.interp_order_label.setAlignment(Qt.AlignLeft | Qt.AlignTrailing
| Qt.AlignVCenter)
self.gridLayout.addWidget(self.interp_order_label, 2, 0)
self.interp_order_spinbox = QSpinBox(self.gridLayoutWidget)
self.interp_order_spinbox.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Fixed)
self.interp_order_spinbox.setToolTip("The final interpolation order.")
self.gridLayout.addWidget(self.interp_order_spinbox, 2, 1)
# Metric
self.metric_label = QLabel("Metric")
self.metric_label.setAlignment(QtCore.Qt.AlignLeft | Qt.AlignTrailing
| Qt.AlignVCenter)
self.gridLayout.addWidget(self.metric_label, 3, 0)
self.metric_comboBox = QComboBox()
self.metric_comboBox.addItem("correlation")
self.metric_comboBox.addItem("mean_squares")
self.metric_comboBox.addItem("mattes_mi")
self.metric_comboBox.addItem("joint_hist_mi")
self.metric_comboBox.setToolTip(
"The metric to be optimised during image registration.")
self.gridLayout.addWidget(self.metric_comboBox, 3, 1)
# Number of Iterations
self.no_of_iterations_label = QLabel("Number of Iterations")
self.no_of_iterations_label.setAlignment(Qt.AlignLeft
| Qt.AlignTrailing
| Qt.AlignVCenter)
self.gridLayout.addWidget(self.no_of_iterations_label, 4, 0)
self.no_of_iterations_spinBox = QSpinBox(self.gridLayoutWidget)
self.no_of_iterations_spinBox.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Fixed)
self.no_of_iterations_spinBox.setRange(0, 100)
self.no_of_iterations_spinBox.setToolTip(
"Number of iterations in each multi-resolution step.")
self.gridLayout.addWidget(self.no_of_iterations_spinBox, 4, 1)
# Shrink Factor
self.shrink_factor_label = QLabel("Shrink Factor")
self.shrink_factor_label.setAlignment(Qt.AlignLeft | Qt.AlignTrailing
| Qt.AlignVCenter)
self.gridLayout.addWidget(self.shrink_factor_label, 5, 0)
self.shrink_factor_qLineEdit = QLineEdit()
self.shrink_factor_qLineEdit.resize(
self.shrink_factor_qLineEdit.sizeHint().width(),
self.shrink_factor_qLineEdit.sizeHint().height())
self.shrink_factor_qLineEdit.setValidator(
QRegularExpressionValidator(
QRegularExpression("^[0-9]*[,]?[0-9]*[,]?[0-9]")))
self.shrink_factor_qLineEdit.setToolTip(
"The multi-resolution downsampling factors. Can be up to three "
"integer elements in an array. Example [8, 2, 1]")
self.gridLayout.addWidget(self.shrink_factor_qLineEdit, 5, 1)
# Optimiser
self.optimiser_label = QLabel("Optimiser")
self.optimiser_label.setAlignment(Qt.AlignLeft | Qt.AlignTrailing
| Qt.AlignVCenter)
self.gridLayout.addWidget(self.optimiser_label, 1, 2)
self.optimiser_comboBox = QComboBox(self.gridLayoutWidget)
self.optimiser_comboBox.addItem("lbfgsb")
self.optimiser_comboBox.addItem("gradient_descent")
self.optimiser_comboBox.addItem("gradient_descent_line_search")
self.optimiser_comboBox.setToolTip(
"The optimiser algorithm used for image registration.")
self.gridLayout.addWidget(self.optimiser_comboBox, 1, 3)
# Reg Method
self.reg_method_label = QLabel("Reg Method")
self.reg_method_label.setAlignment(QtCore.Qt.AlignLeft
| Qt.AlignTrailing
| Qt.AlignVCenter)
self.gridLayout.addWidget(self.reg_method_label, 2, 2)
self.reg_method_comboBox = QComboBox()
self.reg_method_comboBox.addItem("translation")
self.reg_method_comboBox.addItem("rigid")
self.reg_method_comboBox.addItem("similarity")
self.reg_method_comboBox.addItem("affine")
self.reg_method_comboBox.addItem("scaleversor")
self.reg_method_comboBox.addItem("scaleskewversor")
self.reg_method_comboBox.setToolTip(
"The linear transformation model to be used for image "
"registration.")
self.gridLayout.addWidget(self.reg_method_comboBox, 2, 3)
# Sampling Rate
self.sampling_rate_label = QLabel("Sampling Rate")
self.sampling_rate_label.setAlignment(Qt.AlignLeft | Qt.AlignTrailing
| Qt.AlignVCenter)
self.gridLayout.addWidget(self.sampling_rate_label, 3, 2)
self.sampling_rate_spinBox = QDoubleSpinBox(self.gridLayoutWidget)
self.sampling_rate_spinBox.setMinimum(0)
self.sampling_rate_spinBox.setMaximum(1)
self.sampling_rate_spinBox.setSingleStep(0.01)
self.sampling_rate_spinBox.setSizePolicy(QSizePolicy.Minimum,
QSizePolicy.Fixed)
self.sampling_rate_spinBox.setToolTip("The fraction of voxels sampled "
"during each iteration.")
self.gridLayout.addWidget(self.sampling_rate_spinBox, 3, 3)
# Smooth Sigmas
self.smooth_sigma_label = QLabel("Smooth Sigma")
self.smooth_sigma_label.setAlignment(Qt.AlignLeft | Qt.AlignTrailing
| Qt.AlignVCenter)
self.gridLayout.addWidget(self.smooth_sigma_label, 4, 2)
self.smooth_sigmas_qLineEdit = QLineEdit()
self.smooth_sigmas_qLineEdit.resize(
self.smooth_sigmas_qLineEdit.sizeHint().width(),
self.smooth_sigmas_qLineEdit.sizeHint().height())
self.smooth_sigmas_qLineEdit.setValidator(
QRegularExpressionValidator(
QRegularExpression("^[0-9]*[,]?[0-9]*[,]?[0-9]")))
self.smooth_sigmas_qLineEdit.setToolTip(
"The multi-resolution smoothing kernal scale (Gaussian). Can be "
"up to three integer elements in an array. Example [4, 2, 1]")
self.gridLayout.addWidget(self.smooth_sigmas_qLineEdit, 4, 3)
# Label to hold warning labels.
self.warning_label = QLabel()
# Button for fast mode
self.fast_mode_button = QtWidgets.QPushButton("Fast Mode")
self.fast_mode_button.setCursor(
QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.fast_mode_button.clicked.connect(self.set_fast_mode)
# Add Widgets to the vertical layout
self.vertical_layout.addWidget(self.fast_mode_button)
self.vertical_layout.addWidget(self.gridLayoutWidget)
self.vertical_layout.addWidget(self.warning_label)
# Set layout of frame to the gridlayout widget
self.auto_image_fusion_frame.setLayout(self.vertical_layout)
def __init__(self):
super().__init__()
self._dataset: Optional[Dataset] = None
self._translator: Optional[QtCore.QTranslator] = None
self._client = QGrainClient()
self.setWindowTitle("QGrain")
self.ssu_setting_dialog = SSUSettings(self)
self.emma_setting_dialog = EMMASettings(parent=self,
client=self._client)
self.udm_setting_dialog = UDMSettings(parent=self, client=self._client)
self.parameter_editor = ParameterEditor(self)
self.ssu_multicore_analyzer = SSUMulticoreAnalyzer(self)
self.tab_widget = QtWidgets.QTabWidget(self)
self.tab_widget.setTabPosition(QtWidgets.QTabWidget.West)
self.setCentralWidget(self.tab_widget)
self.dataset_generator = DatasetGenerator()
self.tab_widget.addTab(self.dataset_generator, self.tr("Generator"))
self.dataset_viewer = StatisticalAnalyzer()
self.tab_widget.addTab(self.dataset_viewer, self.tr("Statistics"))
self.pca_analyzer = PCAAnalyzer()
self.tab_widget.addTab(self.pca_analyzer, self.tr("PCA"))
self.clustering_analyzer = ClusteringAnalyzer()
self.tab_widget.addTab(self.clustering_analyzer, self.tr("Clustering"))
self.ssu_analyzer = SSUAnalyzer(self.ssu_setting_dialog,
self.parameter_editor)
self.tab_widget.addTab(self.ssu_analyzer, self.tr("SSU"))
self.emma_analyzer = EMMAAnalyzer(self.emma_setting_dialog,
self.parameter_editor,
client=self._client)
self.tab_widget.addTab(self.emma_analyzer, self.tr("EMMA"))
self.udm_analyzer = UDMAnalyzer(self.udm_setting_dialog,
self.parameter_editor,
client=self._client)
self.tab_widget.addTab(self.udm_analyzer, self.tr("UDM"))
# Open
self.open_menu = self.menuBar().addMenu(self.tr("Open"))
self.open_dataset_action = self.open_menu.addAction(
self.tr("Grain Size Dataset"))
self.open_dataset_action.triggered.connect(
lambda: self.load_dataset_dialog.show())
self.load_ssu_result_action = self.open_menu.addAction(
self.tr("SSU Results"))
self.load_ssu_result_action.triggered.connect(
self.ssu_analyzer.result_view.load_results)
self.load_emma_result_action = self.open_menu.addAction(
self.tr("EMMA Result"))
self.load_emma_result_action.triggered.connect(
self.emma_analyzer.load_result)
self.load_udm_result_action = self.open_menu.addAction(
self.tr("UDM Result"))
self.load_udm_result_action.triggered.connect(
self.udm_analyzer.load_result)
# Save
self.save_menu = self.menuBar().addMenu(self.tr("Save"))
self.save_artificial_action = self.save_menu.addAction(
self.tr("Artificial Dataset"))
self.save_artificial_action.triggered.connect(
self.dataset_generator.on_save_clicked)
self.save_statistics_action = self.save_menu.addAction(
self.tr("Statistical Result"))
self.save_statistics_action.triggered.connect(
self.on_save_statistics_clicked)
self.save_pca_action = self.save_menu.addAction(self.tr("PCA Result"))
self.save_pca_action.triggered.connect(self.on_save_pca_clicked)
self.save_clustering_action = self.save_menu.addAction(
self.tr("Clustering Result"))
self.save_clustering_action.triggered.connect(
self.clustering_analyzer.save_result)
self.save_ssu_result_action = self.save_menu.addAction(
self.tr("SSU Results"))
self.save_ssu_result_action.triggered.connect(
self.ssu_analyzer.result_view.save_results)
self.save_emma_result_action = self.save_menu.addAction(
self.tr("EMMA Result"))
self.save_emma_result_action.triggered.connect(
self.emma_analyzer.save_selected_result)
self.save_udm_result_action = self.save_menu.addAction(
self.tr("UDM Result"))
self.save_udm_result_action.triggered.connect(
self.udm_analyzer.save_selected_result)
# Config
self.config_menu = self.menuBar().addMenu(self.tr("Configure"))
self.config_ssu_action = self.config_menu.addAction(
self.tr("SSU Algorithm"))
self.config_ssu_action.triggered.connect(self.ssu_setting_dialog.show)
self.config_emma_action = self.config_menu.addAction(
self.tr("EMMA Algorithm"))
self.config_emma_action.triggered.connect(
self.emma_setting_dialog.show)
self.config_udm_action = self.config_menu.addAction(
self.tr("UDM Algorithm"))
self.config_udm_action.triggered.connect(self.udm_setting_dialog.show)
# Experimental
self.experimental_menu = self.menuBar().addMenu(
self.tr("Experimental"))
self.ssu_fit_all_action = self.experimental_menu.addAction(
self.tr("Perform SSU For All Samples"))
self.ssu_fit_all_action.triggered.connect(self.ssu_fit_all_samples)
self.convert_udm_to_ssu_action = self.experimental_menu.addAction(
self.tr("Convert Selected UDM Result To SSU Results"))
self.convert_udm_to_ssu_action.triggered.connect(
self.convert_udm_to_ssu)
self.save_all_ssu_figures_action = self.experimental_menu.addAction(
self.tr("Save Figures For All SSU Results"))
self.save_all_ssu_figures_action.triggered.connect(
self.save_all_ssu_figure)
# Language
self.language_menu = self.menuBar().addMenu(self.tr("Language"))
self.language_group = QtGui.QActionGroup(self.language_menu)
self.language_group.setExclusive(True)
self.language_actions: List[QtGui.QAction] = []
for key, name in self.supported_languages:
action = self.language_group.addAction(name)
action.setCheckable(True)
action.triggered.connect(lambda checked=False, language=key: self.
switch_language(language))
self.language_menu.addAction(action)
self.language_actions.append(action)
self.language_actions[0].setChecked(True)
# Theme
self.theme_menu = self.menuBar().addMenu(self.tr("Theme"))
self.theme_group = QtGui.QActionGroup(self.theme_menu)
self.theme_group.setExclusive(True)
self.theme_actions = []
self.default_theme_action = self.theme_group.addAction(
self.tr("Default"))
self.default_theme_action.setCheckable(True)
self.default_theme_action.setChecked(True)
self.default_theme_action.triggered.connect(lambda: apply_stylesheet(
app,
theme=os.path.join(QGRAIN_ROOT_PATH, "assets", "default_theme.xml"
),
invert_secondary=True,
extra=EXTRA))
self.theme_menu.addAction(self.default_theme_action)
self.theme_actions.append(self.default_theme_action)
self.light_theme_menu = self.theme_menu.addMenu(self.tr("Light Theme"))
self.dark_theme_menu = self.theme_menu.addMenu(self.tr("Dark Theme"))
for theme in list_themes():
theme_name = string.capwords(" ".join(theme[:-4].split("_")[1:]))
action = self.theme_group.addAction(theme_name)
action.setCheckable(True)
app = QtCore.QCoreApplication.instance()
invert = theme.startswith("light")
action.triggered.connect(
lambda checked=False, t=theme, i=invert: apply_stylesheet(
app, theme=t, invert_secondary=i, extra=EXTRA))
self.theme_actions.append(action)
if invert:
self.light_theme_menu.addAction(action)
else:
self.dark_theme_menu.addAction(action)
# Log
self.log_action = QtGui.QAction(self.tr("Log"))
self.log_action.triggered.connect(lambda: self.log_dialog.show())
self.menuBar().addAction(self.log_action)
# About
self.about_action = QtGui.QAction(self.tr("About"))
self.about_action.triggered.connect(lambda: self.about_dialog.show())
self.menuBar().addAction(self.about_action)
# Connect signals
self.ssu_multicore_analyzer.result_finished.connect(
self.ssu_analyzer.result_view.add_result)
self.load_dataset_dialog = DatasetLoader(self)
self.load_dataset_dialog.dataset_loaded.connect(self.on_dataset_loaded)
self.load_dataset_dialog.dataset_loaded.connect(
self.dataset_viewer.on_dataset_loaded)
self.load_dataset_dialog.dataset_loaded.connect(
self.pca_analyzer.on_dataset_loaded)
self.load_dataset_dialog.dataset_loaded.connect(
self.clustering_analyzer.on_dataset_loaded)
self.load_dataset_dialog.dataset_loaded.connect(
self.ssu_analyzer.on_dataset_loaded)
self.load_dataset_dialog.dataset_loaded.connect(
self.emma_analyzer.on_dataset_loaded)
self.load_dataset_dialog.dataset_loaded.connect(
self.udm_analyzer.on_dataset_loaded)
self.log_dialog = RuntimeLog(self)
self.about_dialog = About(self)
self.file_dialog = QtWidgets.QFileDialog(parent=self)
self.normal_msg = QtWidgets.QMessageBox(self)
self.close_msg = QtWidgets.QMessageBox(self)
self.close_msg.setWindowTitle(self.tr("Warning"))
self.close_msg.setText(
self.
tr("Closing this window will terminate all running tasks, are you sure to close it?"
))
self.close_msg.setStandardButtons(QtWidgets.QMessageBox.Yes
| QtWidgets.QMessageBox.No)
self.close_msg.setDefaultButton(QtWidgets.QMessageBox.No)
self.widget.setGeometry(0, 0, self.widget.width(),
self.widget.height())
# find the interaction element
self.search = self.widget.findChild(QtWidgets.QLineEdit,
"textToReplace")
self.replace = self.widget.findChild(QtWidgets.QLineEdit,
"newTextHere")
self.use_case = self.widget.findChild(QtWidgets.QCheckBox,
"caseSensitive")
# find and assing the trigger to pushbutten
self.rename_button = self.widget.findChild(QtWidgets.QPushButton,
"rename")
self.rename_button.clicked.connect(self.rename_handler)
def rename_handler(self):
search_pattern = self.search.text()
replace_pattern = self.replace.text()
use_case = self.use_case.isChecked()
rename_assets(search_pattern, replace_pattern, use_case)
app = None
if not QtWidgets.QApplication.instance():
app = QtWidgets.QApplication(sys.argv)
window = RenameGUI()
window.show()
def _add_image_layer(self):
"""Add widget showing screenshot."""
self.image_layer = QtWidgets.QLabel()
self.image_layer.setObjectName("central_widget")
self.image_layer.setScaledContents(True)
self.setCentralWidget(self.image_layer)
def create_tracker(self):
tracker_name = self.selected_tracker
if tracker_name == self._current_tracker_name or tracker_name is None:
return
self.delete_tracker()
with path_for(
self.trackers[tracker_name]).open("r") as tracker_details_file:
tracker_details = json.load(tracker_details_file)
game_enum = RandovaniaGame(tracker_details["game"])
resource_database = default_database.resource_database_for(game_enum)
for element in tracker_details["elements"]:
text_template = ""
minimum_to_check = element.get("minimum_to_check", 1)
field_to_check = FieldToCheck(
element.get("field_to_check", FieldToCheck.CAPACITY.value))
labels = []
if "image_path" in element:
paths = element["image_path"]
if not isinstance(paths, list):
paths = [paths]
visible = True
for path in paths:
image_path = get_data_path().joinpath(path)
if not image_path.exists():
logging.error("Tracker asset not found: %s",
image_path)
pixmap = QtGui.QPixmap(str(image_path))
label = ClickableLabel(self.inventory_group,
paint_with_opacity(pixmap, 0.3),
paint_with_opacity(pixmap, 1.0))
label.set_checked(False)
label.set_ignore_mouse_events(True)
label.setVisible(visible)
visible = False
labels.append(label)
elif "label" in element:
label = QtWidgets.QLabel(self.inventory_group)
label.setAlignment(QtCore.Qt.AlignCenter)
text_template = element["label"]
labels.append(label)
else:
raise ValueError(f"Invalid element: {element}")
resources = [
find_resource_info_with_long_name(resource_database.item,
resource_name)
for resource_name in element["resources"]
]
for resource, label in zip(resources, labels):
label.setToolTip(resource.long_name)
self._tracker_elements.append(
Element(labels, resources, text_template, minimum_to_check,
field_to_check))
for label in labels:
self.inventory_layout.addWidget(label, element["row"],
element["column"])
self.inventory_spacer = QtWidgets.QSpacerItem(
5, 5, QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Expanding)
self.inventory_layout.addItem(self.inventory_spacer,
self.inventory_layout.rowCount(),
self.inventory_layout.columnCount())
self._current_tracker_game = game_enum
self._update_tracker_from_hook({})
self._current_tracker_name = tracker_name
def __init__(self, parent=None):
super().__init__(parent)
self.width_size = None
self.height_size = None
self.width_size_s = None
self.width_size_e = None
self.height_size_s = None
self.height_size_e = None
self.frame_s = None
self.frame_e = None
self.frame_jump = None
self.set_bit_order = None
self.bin_type = None
self.video_type = None
self.flag_display = False
self.image_format = {"int_8": "i1", "int_16": "i2", "int_32": "i4", "int_64": "i8", "uint_8": "u1", "uint_16": "u2", "uint_32": "u4",
"uint_64": "u8", "float_16": "f2", "float_32": "f4", "float_64": "f8"}
self.raw_data_update_flag = True
self.window = QtWidgets.QWidget()
self.combo_video = QtWidgets.QComboBox(self)
self.combo_video.addItem("-Select the video type-")
self.combo_video.addItem("RAW")
self.combo_video.addItem("MP4")
self.combo_video.addItem("GIF")
self.combo_bin = QtWidgets.QComboBox(self)
self.combo_bin.addItem("-Select the binary type-")
self.combo_bin.addItem("int_8")
self.combo_bin.addItem("int_16")
self.combo_bin.addItem("int_32")
self.combo_bin.addItem("int_64")
self.combo_bin.addItem("uint_8")
self.combo_bin.addItem("uint_16")
self.combo_bin.addItem("uint_32")
self.combo_bin.addItem("uint_64")
self.combo_bin.addItem("float_16")
self.combo_bin.addItem("float_32")
self.combo_bin.addItem("float_64")
self.combo_bin.currentIndexChanged.connect(self.on_select)
self.ok = QtWidgets.QPushButton("Ok")
self.ok.setAutoDefault(False)
self.ok.setFixedWidth(100)
self.ok.clicked.connect(self.do_update)
self.grid = QtWidgets.QGridLayout()
self.grid.addWidget(self.createFirstExclusiveGroup(), 0, 0)
self.grid.addWidget(self.ok, 6, 0)
self.setWindowTitle("Saving video")
self.setStyleSheet('QMainWindow{background-color: darkgray;}')
self.window.setLayout(self.grid)
