def __init__(self, data):
QWidget.__init__(self)
self.model = CustomTableModel(data)
self.table_view = QTableView()
self.table_view.setModel(self.model)
self.horizontal_header = self.table_view.horizontalHeader()
self.vertical_header = self.table_view.verticalHeader()
self.horizontal_header.setSectionResizeMode(
QHeaderView.ResizeToContents)
self.vertical_header.setSectionResizeMode(QHeaderView.ResizeToContents)
self.horizontal_header.setStretchLastSection(True)
self.main_layout = QHBoxLayout()
size = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
size.setHorizontalStretch(1)
self.table_view.setSizePolicy(size)
self.main_layout.addWidget(self.table_view)
self.setLayout(self.main_layout)
def __init__(self, parent: QWidget = None):
super(FrmNavProgress, self).__init__(parent)
layout = QVBoxLayout()
sizePolicy = QSizePolicy()
sizePolicy.setVerticalStretch(2)
sizePolicy.setVerticalPolicy(QSizePolicy.Preferred)
sizePolicy.setHorizontalPolicy(QSizePolicy.Preferred)
self.navProgress1 = NavProgress()
self.navProgress1.setSizePolicy(sizePolicy)
self.navProgress2 = NavProgress()
self.navProgress2.setSizePolicy(sizePolicy)
sizePolicy.setVerticalStretch(3)
self.navProgress3 = NavProgress()
self.navProgress3.setSizePolicy(sizePolicy)
self.navProgress4 = NavProgress()
self.navProgress4.setSizePolicy(sizePolicy)
self.navProgress5 = NavProgress()
self.navProgress5.setSizePolicy(sizePolicy)
self.navProgress6 = NavProgress()
self.navProgress6.setSizePolicy(sizePolicy)
layout.addWidget(self.navProgress1)
layout.addWidget(self.navProgress2)
layout.addWidget(self.navProgress3)
layout.addWidget(self.navProgress4)
layout.addWidget(self.navProgress5)
layout.addWidget(self.navProgress6)
self.setLayout(layout)
QTimer.singleShot(0, self.initForm)
def __init__(self, data):
QWidget.__init__(self)
# Getting the Model
self.model = CustomTableModel(data)
# Creating a QTableView
self.table_view = QTableView()
self.table_view.setModel(self.model)
# QTableView Headers
self.horizontal_header = self.table_view.horizontalHeader()
self.vertical_header = self.table_view.verticalHeader()
self.horizontal_header.setSectionResizeMode(QHeaderView.ResizeToContents)
self.vertical_header.setStretchLastSection(True)
# QWidget Layout
self.main_layout = QHBoxLayout()
size = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
# Left Layout
size.setHorizontalStretch(1)
self.table_view.setSizePolicy(size)
self.main_layout.addWidget(self.table_view)
# Set the layout to the QWidget
self.setLayout(self.main_layout())
def __init__(self, vfs_view, *args, **kwargs):
QWidget.__init__(self, *args, **kwargs)
self.vnode_2click_selected = None
# Getting the Model
self.source_model = VfsDirModel()
# Creating a QTableView
self.view = QTreeView()
self.view.doubleClicked.connect(self.double_clicked)
self.view.clicked.connect(self.clicked)
self.view.setSelectionBehavior(QAbstractItemView.SelectRows)
self.view.setSelectionMode(QAbstractItemView.ExtendedSelection)
font = self.view.font()
font.setPointSize(8)
self.view.setFont(font)
self.view.setModel(self.source_model)
# # QTableView Headers
self.header = self.view.header()
self.header.setSectionResizeMode(QHeaderView.ResizeToContents)
self.header.setStretchLastSection(True)
size = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
size.setHorizontalStretch(1)
self.view.setSizePolicy(size)
self.main_layout = QHBoxLayout()
self.main_layout.addWidget(self.view)
self.setLayout(self.main_layout)
self.source_model.vfs_view_set(vfs_view)
def __init__(self):
QWidget.__init__(self)
# Creating a QTableView
self.table_view = QTableView()
# QWidget Layout
self.main_layout = QHBoxLayout()
self.size = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
# generate the plot
self.fig, self.ax = plt.subplots()
self.fig.tight_layout = True
self.fig.subplots_adjust(left=0.05, right=0.95, top=0.95, bottom=0.05)
self.ax.margins(0, 0)
self.canvas = FigureCanvas(self.fig)
## Left layout
self.size.setHorizontalStretch(1)
self.table_view.setSizePolicy(self.size)
self.main_layout.addWidget(self.table_view)
## Right Layout
self.size.setHorizontalStretch(4)
self.canvas.setSizePolicy(self.size)
self.main_layout.addWidget(self.canvas)
# Creating QChartView
self.chart_view = QtCharts.QChartView()
self.chart_view.setRenderHint(QPainter.Antialiasing)
# Set the layout to the QWidget
self.setLayout(self.main_layout)
def add_purchase_row(
self,
unit_type: UnitType,
layout: QGridLayout,
row: int,
) -> None:
exist = QGroupBox()
exist.setProperty("style", "buy-box")
exist.setMaximumHeight(36)
exist.setMinimumHeight(36)
existLayout = QHBoxLayout()
exist.setLayout(existLayout)
existing_units = self.cp.base.total_units_of_type(unit_type)
unitName = QLabel(f"<b>{unit_type.name}</b>")
unitName.setSizePolicy(
QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding))
existing_units = QLabel(str(existing_units))
existing_units.setSizePolicy(
QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed))
self.existing_units_labels[unit_type] = existing_units
price = QLabel(f"<b>$ {unit_type.price}</b> M")
price.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed))
purchase_group = PurchaseGroup(unit_type, self)
self.purchase_groups[unit_type] = purchase_group
info = QGroupBox()
info.setProperty("style", "buy-box")
info.setMaximumHeight(36)
info.setMinimumHeight(36)
infolayout = QHBoxLayout()
info.setLayout(infolayout)
unitInfo = QPushButton("i")
unitInfo.setProperty("style", "btn-info")
unitInfo.setMinimumSize(16, 16)
unitInfo.setMaximumSize(16, 16)
unitInfo.clicked.connect(lambda: self.info(unit_type))
unitInfo.setSizePolicy(
QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed))
existLayout.addWidget(unitName)
existLayout.addItem(
QSpacerItem(20, 0, QSizePolicy.Minimum, QSizePolicy.Minimum))
existLayout.addWidget(existing_units)
existLayout.addItem(
QSpacerItem(20, 0, QSizePolicy.Minimum, QSizePolicy.Minimum))
existLayout.addWidget(price)
infolayout.addWidget(unitInfo)
layout.addWidget(exist, row, 1)
layout.addWidget(purchase_group, row, 2)
layout.addWidget(info, row, 3)
def add_unit_row(
self,
unit_type: GroundUnitType,
layout: QGridLayout,
row: int,
) -> None:
exist = QGroupBox()
exist.setProperty("style", "buy-box")
exist.setMaximumHeight(36)
exist.setMinimumHeight(36)
origin_inventory_layout = QHBoxLayout()
exist.setLayout(origin_inventory_layout)
origin_inventory = self.cp.base.total_units_of_type(unit_type)
unit_name = QLabel(f"<b>{unit_type.name}</b>")
unit_name.setSizePolicy(
QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding))
origin_inventory_label = QLabel(str(origin_inventory))
origin_inventory_label.setSizePolicy(
QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed))
def increase(controls: TransferControls):
nonlocal origin_inventory
nonlocal origin_inventory_label
if not origin_inventory:
return
self.transfers[unit_type] += 1
origin_inventory -= 1
controls.set_quantity(self.transfers[unit_type])
origin_inventory_label.setText(str(origin_inventory))
self.transfer_quantity_changed.emit()
def decrease(controls: TransferControls):
nonlocal origin_inventory
nonlocal origin_inventory_label
if not controls.quantity:
return
self.transfers[unit_type] -= 1
origin_inventory += 1
controls.set_quantity(self.transfers[unit_type])
origin_inventory_label.setText(str(origin_inventory))
self.transfer_quantity_changed.emit()
transfer_controls = TransferControls("->", increase, "<-", decrease)
origin_inventory_layout.addWidget(unit_name)
origin_inventory_layout.addItem(
QSpacerItem(20, 0, QSizePolicy.Minimum, QSizePolicy.Minimum))
origin_inventory_layout.addWidget(origin_inventory_label)
origin_inventory_layout.addItem(
QSpacerItem(20, 0, QSizePolicy.Minimum, QSizePolicy.Minimum))
layout.addWidget(exist, row, 1)
layout.addWidget(transfer_controls, row, 2)
def __init__(self, fig, parent=None):
FigureCanvas.__init__(self, fig)
self.setParent(parent)
size = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
size.setHeightForWidth(True)
self.setSizePolicy(size)
FigureCanvas.updateGeometry(self)
def __init__(self, parent=None):
super(TabDisplays, self).__init__(parent)
# Initialize logging
logging_conf_file = os.path.join(os.path.dirname(__file__),
'cfg/aecgviewer_aecg_logging.conf')
logging.config.fileConfig(logging_conf_file)
self.logger = logging.getLogger(__name__)
self.studyindex_info = aecg.tools.indexer.StudyInfo()
self.validator = QWidget()
self.studyinfo = QWidget()
self.statistics = QWidget()
self.waveforms = QWidget()
self.waveforms.setAccessibleName("Waveforms")
self.scatterplot = QWidget()
self.histogram = QWidget()
self.trends = QWidget()
self.xmlviewer = QWidget()
self.xml_display = QTextEdit(self.xmlviewer)
self.options = QWidget()
self.aecg_display_area = QScrollArea()
self.cbECGLayout = QComboBox()
self.aecg_display = EcgDisplayWidget(self.aecg_display_area)
self.aecg_display_area.setWidget(self.aecg_display)
self.addTab(self.validator, "Study information")
self.addTab(self.waveforms, "Waveforms")
self.addTab(self.xmlviewer, "XML")
self.addTab(self.options, "Options")
self.setup_validator()
self.setup_waveforms()
self.setup_xmlviewer()
self.setup_options()
size = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
size.setHeightForWidth(False)
self.setSizePolicy(size)
# Initialized a threpool with 2 threads 1 for the GUI, 1 for long
# tasks, so GUI remains responsive
self.threadpool = QThreadPool()
self.threadpool.setMaxThreadCount(2)
self.validator_worker = None
self.indexing_timer = QElapsedTimer()
def __init__(self, index_filename):
QWidget.__init__(self)
self.data_index = pd.DataFrame()
self.data_info = aecg.tools.indexer.StudyInfo()
self.data_index_stats = aecg.tools.indexer.StudyStats(
self.data_info, self.data_index)
# Getting the Models
self.project_loaded = ''
self.projectmodel = ProjectTreeModel()
# Creating a QTreeView for displaying the selected project index
self.project_treeview = QTreeView()
self.project_treeview.setModel(self.projectmodel)
self.phorizontal_header = self.project_treeview.header()
self.phorizontal_header.setSectionResizeMode(
QHeaderView.ResizeToContents)
self.phorizontal_header.setStretchLastSection(True)
self.sp_right = QSplitter(Qt.Orientation.Horizontal)
self.sp_left = QSplitter(Qt.Orientation.Vertical, self.sp_right)
# NavigationWidget Layout
self.main_layout = QVBoxLayout()
size = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
# Left side
# Left side - Top layout
# Left side - Bottom Layout
size.setVerticalStretch(4)
self.project_treeview.setSizePolicy(size)
self.sp_left.addWidget(self.project_treeview)
# Right side
size = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
size.setHorizontalStretch(2)
size.setHeightForWidth(False)
self.tabdisplays = TabDisplays(self)
self.sp_right.addWidget(self.tabdisplays)
self.tabdisplays.validator_data_ready.connect(
self.load_projectindex_after_validation)
self.sp_right.setSizePolicy(size)
# Set the layout to the QWidget
self.main_layout.addWidget(self.sp_right)
self.setLayout(self.main_layout)
self.tabdisplays.setCurrentWidget(self.tabdisplays.validator)
# Load study index
if index_filename and (index_filename != ""):
if os.path.exists(index_filename):
self.load_projectindex(os.path.normpath(index_filename))
else:
QMessageBox.warning(self, f"Study index file not found",
f"{index_filename} not found")
def test_text(pixmap_differ: PixmapDiffer):
actual: QPainter
expected: QPainter
with pixmap_differ.create_painters(
300, 240, 'scaled_radio_button_text') as (actual, expected):
ex_widget = QWidget()
ex_layout = QVBoxLayout(ex_widget)
ex_radio1 = QRadioButton('Lorem ipsum')
ex_radio2 = QRadioButton('Lorem ipsum')
ex_font = ex_radio1.font()
if ex_font.family() == 'Sans Serif':
# Fonts are different on Travis CI.
big_font_size = 26
small_font_size = 25
ex_radio1.setStyleSheet('QRadioButton::indicator {width: 26} '
'QRadioButton {spacing: 13}')
ex_radio2.setStyleSheet('QRadioButton::indicator {width: 25} '
'QRadioButton {spacing: 12}')
else:
big_font_size = 29
small_font_size = 28
ex_radio1.setStyleSheet('QRadioButton::indicator {width: 29} '
'QRadioButton {spacing: 14}')
ex_radio2.setStyleSheet('QRadioButton::indicator {width: 28} '
'QRadioButton {spacing: 14}')
ex_font.setPointSize(big_font_size)
ex_radio1.setFont(ex_font)
ex_font.setPointSize(small_font_size)
ex_radio2.setFont(ex_font)
ex_size_policy = QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
ex_radio1.setSizePolicy(ex_size_policy)
ex_radio2.setSizePolicy(ex_size_policy)
ex_layout.addWidget(ex_radio1)
ex_layout.addWidget(ex_radio2)
ex_layout.setStretch(0, 4)
ex_layout.setStretch(1, 1)
ex_widget.resize(300, 240)
expected.drawPixmap(0, 0, ex_widget.grab())
widget = QWidget()
layout = QVBoxLayout(widget)
radio1 = ScaledRadioButton('Lorem ipsum')
radio2 = ScaledRadioButton('Lorem ipsum')
size_policy = QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
radio1.setSizePolicy(size_policy)
radio2.setSizePolicy(size_policy)
layout.addWidget(radio1)
layout.addWidget(radio2)
layout.setStretch(0, 4)
layout.setStretch(1, 1)
widget.resize(300, 240)
actual.drawPixmap(0, 0, widget.grab())
def __init__(self, possible_field_names: List[str]):
super().__init__()
possible_field_names = [
x for x in possible_field_names if x not in INVALID_FIELD_NAMES
]
self.update_possible_fields(possible_field_names)
self.setPlaceholderText("Name of new field")
self.setMinimumWidth(160)
fix_horizontal_size = QSizePolicy()
fix_horizontal_size.setHorizontalPolicy(QSizePolicy.Fixed)
self.setSizePolicy(fix_horizontal_size)
def test_text(pixmap_differ: PixmapDiffer):
actual: QPainter
expected: QPainter
with pixmap_differ.create_painters(300, 240, 'scaled_label_text') as (
actual,
expected):
ex_widget = QWidget()
ex_layout = QVBoxLayout(ex_widget)
ex_label1 = QLabel('Lorem ipsum')
ex_label2 = QLabel('Lorem ipsum')
ex_font = ex_label1.font()
if ex_font.family() == 'Sans Serif':
# Fonts are different on Travis CI.
big_font_size = 30
small_font_size = 25
else:
big_font_size = 35
small_font_size = 28
ex_font.setPointSize(big_font_size)
ex_label1.setFont(ex_font)
ex_font.setPointSize(small_font_size)
ex_label2.setFont(ex_font)
ex_size_policy = QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
ex_label1.setSizePolicy(ex_size_policy)
ex_label1.setAlignment(Qt.AlignBottom)
ex_label2.setAlignment(Qt.AlignTop)
ex_label2.setSizePolicy(ex_size_policy)
ex_layout.addWidget(ex_label1)
ex_layout.addWidget(ex_label2)
ex_layout.setStretch(0, 4)
ex_layout.setStretch(1, 1)
ex_widget.resize(300, 240)
expected.drawPixmap(0, 0, ex_widget.grab())
widget = QWidget()
layout = QVBoxLayout(widget)
label1 = ScaledLabel('Lorem ipsum')
label2 = ScaledLabel('Lorem ipsum')
size_policy = QSizePolicy(QSizePolicy.Ignored, QSizePolicy.Ignored)
label1.setSizePolicy(size_policy)
label2.setSizePolicy(size_policy)
label1.setScaledContents(True)
label2.setScaledContents(True)
label1.setAlignment(Qt.AlignBottom)
label2.setAlignment(Qt.AlignTop)
layout.addWidget(label1)
layout.addWidget(label2)
layout.setStretch(0, 4)
layout.setStretch(1, 1)
widget.resize(300, 240)
actual.drawPixmap(0, 0, widget.grab())
def __init__(self, parent, graph: BaseGraph,
log_handlers: [StreamHandler]):
self._logger = getLogger(__name__)
for h in log_handlers:
self._logger.addHandler(h)
self._logger.debug("Initializing")
super().__init__(parent)
size_policy = QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed)
size_policy.setHorizontalStretch(0)
size_policy.setVerticalStretch(0)
size_policy.setHeightForWidth(self.sizePolicy().hasHeightForWidth())
self.setSizePolicy(size_policy)
self.setMinimumWidth(500)
self.setFrameShape(QFrame.NoFrame)
self.setFrameShadow(QFrame.Raised)
self.setLayout(QVBoxLayout(self))
self._visible = True
self._graph = graph
# self._show_hide_button = ClickAnimationButton(self)
# self._show_hide_button.setFixedSize(150, 30)
# self._show_hide_button.clicked.connect(self._set_graph_visibility)
# self.layout().addWidget(self._show_hide_button)
# self._show_hide_button.setText("Hide " + self._graph.get_title() + " graph")
self._navbar_height = 100
self._graph_height = 400
self.layout().addWidget(self._graph)
self.layout().addWidget(self._graph.get_nav_bar())
self.setFixedHeight(self._navbar_height + self._graph_height)
self._logger.debug("Initialized")
def setupUi(self, GroupBox):
if not GroupBox.objectName():
GroupBox.setObjectName(u"GroupBox")
GroupBox.resize(452, 296)
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Minimum)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(GroupBox.sizePolicy().hasHeightForWidth())
GroupBox.setSizePolicy(sizePolicy)
self.verticalLayout = QVBoxLayout(GroupBox)
self.verticalLayout.setObjectName(u"verticalLayout")
self.groupBox = QGroupBox(GroupBox)
self.groupBox.setObjectName(u"groupBox")
self.verticalLayout_3 = QVBoxLayout(self.groupBox)
self.verticalLayout_3.setObjectName(u"verticalLayout_3")
self.verticalLayout_2 = QVBoxLayout()
self.verticalLayout_2.setObjectName(u"verticalLayout_2")
self.verticalLayout_2.setContentsMargins(-1, 10, -1, -1)
self.checkBox_asp_ser = QCheckBox(self.groupBox)
self.checkBox_asp_ser.setObjectName(u"checkBox_asp_ser")
self.verticalLayout_2.addWidget(self.checkBox_asp_ser)
self.checkBox_ser_backbone = QCheckBox(self.groupBox)
self.checkBox_ser_backbone.setObjectName(u"checkBox_ser_backbone")
self.verticalLayout_2.addWidget(self.checkBox_ser_backbone)
self.checkBox_glu_his = QCheckBox(self.groupBox)
self.checkBox_glu_his.setObjectName(u"checkBox_glu_his")
self.verticalLayout_2.addWidget(self.checkBox_glu_his)
self.checkBox_his_his = QCheckBox(self.groupBox)
self.checkBox_his_his.setObjectName(u"checkBox_his_his")
self.verticalLayout_2.addWidget(self.checkBox_his_his)
self.checkBox_asp_asn = QCheckBox(self.groupBox)
self.checkBox_asp_asn.setObjectName(u"checkBox_asp_asn")
self.verticalLayout_2.addWidget(self.checkBox_asp_asn)
self.checkBox_his_ser = QCheckBox(self.groupBox)
self.checkBox_his_ser.setObjectName(u"checkBox_his_ser")
self.verticalLayout_2.addWidget(self.checkBox_his_ser)
self.checkBox_asp_backbone = QCheckBox(self.groupBox)
self.checkBox_asp_backbone.setObjectName(u"checkBox_asp_backbone")
self.verticalLayout_2.addWidget(self.checkBox_asp_backbone)
self.verticalLayout_3.addLayout(self.verticalLayout_2)
self.verticalLayout.addWidget(self.groupBox)
self.retranslateUi(GroupBox)
QMetaObject.connectSlotsByName(GroupBox)
def __init__(self,
parent=None,
graph: BaseGraph = None,
log_handlers: [StreamHandler] = None):
self._logger = getLogger(__name__)
if log_handlers:
for h in log_handlers:
self._logger.addHandler(h)
self._logger.debug("Initializing")
super().__init__(parent)
size_policy = QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed)
size_policy.setHorizontalStretch(0)
size_policy.setVerticalStretch(0)
size_policy.setHeightForWidth(self.sizePolicy().hasHeightForWidth())
self.setSizePolicy(size_policy)
self.setMinimumWidth(500)
self.setFrameShape(QFrame.NoFrame)
self.setFrameShadow(QFrame.Raised)
self.setLayout(QVBoxLayout(self))
self._graph = graph
self._graph_height = 400
if graph:
self.layout().addWidget(self._graph)
self._logger.debug("Initialized")
def __init__(self, parent, canvas):
self.logger = logging.getLogger(__name__)
self.logger.debug("Initializing")
super().__init__(parent)
size_policy = QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed)
size_policy.setHorizontalStretch(0)
size_policy.setVerticalStretch(0)
size_policy.setHeightForWidth(self.sizePolicy().hasHeightForWidth())
self.setSizePolicy(size_policy)
self.setMinimumWidth(500)
self.setFrameShape(QFrame.NoFrame)
self.setFrameShadow(QFrame.Raised)
self.setLayout(QVBoxLayout(self))
self.__visible = True
self.__canvas = canvas
self.__show_hide_button = ClickAnimationButton(self)
self.__show_hide_button.setFixedSize(150, 30)
self.__show_hide_button.clicked.connect(self.__set_graph_visibility)
self.layout().addWidget(self.__show_hide_button)
self.__navbar_height = 100
self.__canvas_height = 400
self.__show_hide_button.setText("Hide " + self.__canvas.get_title() +
" graph")
self.layout().addWidget(self.__canvas)
self.layout().addWidget(self.__canvas.get_nav_bar())
self.setFixedHeight(self.__navbar_height + self.__canvas_height)
self.logger.debug("Initialized")
def init_window(self):
# set window
self.setGeometry(100, 100, 900, 620)
import os
self.setWindowIcon(QIcon(os.path.join(path, './img/icon.png')))
self.setWindowTitle("WebCheck")
# set centralWidget
sizePolicy = QSizePolicy(QSizePolicy.Minimum, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(2)
sizePolicy.setVerticalStretch(2)
sizePolicy.setHeightForWidth(self.centralWidget.sizePolicy().hasHeightForWidth())
self.centralWidget.setSizePolicy(sizePolicy)
self.centralWidget.setMinimumSize(QSize(900, 540))
self.setCentralWidget(self.centralWidget)
# set grid layout central
self.gridLayout_central.setSpacing(0)
self.gridLayout_central.setContentsMargins(0, 0, 0, 0)
self.gridLayout_central.setRowStretch(0, 1)
self.gridLayout_central.setRowStretch(1, 10)
self.gridLayout_central.setColumnStretch(0, 1)
self.gridLayout_central.setColumnStretch(1, 3)
self.gridLayout_central.addWidget(self.navFrame, 0, 0, 9, 1)
self.gridLayout_central.addWidget(self.sitesFrame, 0, 1, 1, 1)
self.gridLayout_central.addWidget(self.stackedWidget, 1, 1, 1, 1)
def setup_ui(self):
vertical_layout = QVBoxLayout(self)
vertical_layout.setSpacing(6)
vertical_layout.setContentsMargins(11, 11, 11, 11)
splitter_v = QSplitter(self)
splitter_v.setOrientation(PySide2.QtCore.Qt.Vertical)
size_policy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
size_policy.setHorizontalStretch(0)
size_policy.setVerticalStretch(0)
size_policy.setHeightForWidth(
splitter_v.sizePolicy().hasHeightForWidth())
splitter_v.setSizePolicy(size_policy)
splitter_h = QSplitter(splitter_v)
splitter_h.setOrientation(PySide2.QtCore.Qt.Horizontal)
vertical_layout_widget = QWidget(splitter_h)
self.vertical_layout_left = QVBoxLayout(vertical_layout_widget)
self.vertical_layout_left.setSpacing(6)
self.vertical_layout_left.setSizeConstraint(
QLayout.SetDefaultConstraint)
self.vertical_layout_left.setContentsMargins(0, 0, 0, 0)
splitter_h.addWidget(vertical_layout_widget)
vertical_layout_widget2 = QWidget(splitter_h)
self.vertical_layout_right = QVBoxLayout(vertical_layout_widget2)
self.vertical_layout_right.setContentsMargins(0, 0, 0, 0)
splitter_h.addWidget(vertical_layout_widget2)
splitter_v.addWidget(splitter_h)
vertical_layout_widget3 = QWidget(splitter_v)
vertical_layout_bottom = QVBoxLayout(vertical_layout_widget3)
vertical_layout_bottom.setSpacing(6)
vertical_layout_bottom.setSizeConstraint(QLayout.SetDefaultConstraint)
vertical_layout_bottom.setContentsMargins(11, 0, 11, 11)
text_browser = QTextBrowser(vertical_layout_widget3)
vertical_layout_bottom.addWidget(text_browser)
splitter_v.addWidget(vertical_layout_widget3)
vertical_layout.addWidget(splitter_v)
def setupUi(self, Dialog):
if Dialog.objectName():
Dialog.setObjectName(u"Dialog")
Dialog.resize(878, 528)
icon = QIcon()
icon.addFile("./icon.ico")
Dialog.setWindowIcon(icon)
self.verticalLayout = QVBoxLayout(Dialog)
self.verticalLayout.setObjectName(u"verticalLayout")
self.horizontalLayout = QHBoxLayout()
self.horizontalLayout.setObjectName(u"horizontalLayout")
self.questionLable = QLabel(Dialog)
self.questionLable.setObjectName(u"questionLable")
font = QFont()
font.setFamily(u"\u5fae\u8f6f\u96c5\u9ed1")
font.setPointSize(12)
self.questionLable.setFont(font)
self.questionLable.setWordWrap(True)
self.questionLable.setMargin(0)
self.questionLable.setIndent(0)
self.horizontalLayout.addWidget(self.questionLable)
self.lcd = QLCDNumber(Dialog)
self.lcd.setObjectName(u"lcd")
sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(self.lcd.sizePolicy().hasHeightForWidth())
self.lcd.setSizePolicy(sizePolicy)
self.lcd.setMinimumSize(QSize(120, 60))
self.lcd.setSmallDecimalPoint(True)
self.lcd.setDigitCount(4)
self.lcd.setSegmentStyle(QLCDNumber.Flat)
self.lcd.setProperty("value", 120.000000000000000)
self.horizontalLayout.addWidget(self.lcd)
self.verticalLayout.addLayout(self.horizontalLayout)
self.line = QFrame(Dialog)
self.line.setObjectName(u"line")
self.line.setFrameShape(QFrame.HLine)
self.line.setFrameShadow(QFrame.Sunken)
self.verticalLayout.addWidget(self.line)
self.answerLable = QLabel(Dialog)
self.answerLable.setObjectName(u"answerLable")
font1 = QFont()
font1.setFamily(u"Yu Gothic UI")
font1.setPointSize(14)
self.answerLable.setFont(font1)
self.answerLable.setWordWrap(True)
self.verticalLayout.addWidget(self.answerLable)
self.retranslateUi(Dialog)
QMetaObject.connectSlotsByName(Dialog)
def setupUi(self, PDFViewer):
if not PDFViewer.objectName():
PDFViewer.setObjectName(u"PDFViewer")
PDFViewer.resize(820, 652)
icon = QIcon()
icon.addFile(u":/icons/icon.ico", QSize(), QIcon.Normal, QIcon.Off)
PDFViewer.setWindowIcon(icon)
self.centralwidget = QWidget(PDFViewer)
self.centralwidget.setObjectName(u"centralwidget")
self.verticalLayout = QVBoxLayout(self.centralwidget)
self.verticalLayout.setObjectName(u"verticalLayout")
self.webView = QWebView(self.centralwidget)
self.webView.setObjectName(u"webView")
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.webView.sizePolicy().hasHeightForWidth())
self.webView.setSizePolicy(sizePolicy)
self.webView.setProperty("url", QUrl(u""))
self.verticalLayout.addWidget(self.webView)
PDFViewer.setCentralWidget(self.centralwidget)
self.retranslateUi(PDFViewer)
QMetaObject.connectSlotsByName(PDFViewer)
def __init__(self, parent, monitor):
QtWidgets.QWidget.__init__(self, parent)
# create buttons
#
self.btnForceFocus = QPushButton("Force Focus")
self.btnForceFocus.setToolTip("Forces focus on the nDisplay window")
self.btnForceFocus.clicked.connect(monitor.btnForceFocus_clicked)
self.btnFixExeFlags = QPushButton("Fix ExeFlags")
self.btnFixExeFlags.setToolTip("Disables fullscreen optimizations on the executable.")
self.btnFixExeFlags.clicked.connect(monitor.btnFixExeFlags_clicked)
self.btnSoftKill = QPushButton("Soft Kill")
self.btnSoftKill.setToolTip(
"Sends a message to the master node to terminate the session.\n"
"This is preferable to the normal kill button because it ensures the nodes exit properly")
self.btnSoftKill.clicked.connect(monitor.btnSoftKill_clicked)
# arrange them in a horizontal layout
layout_buttons = QHBoxLayout()
layout_buttons.addStretch()
layout_buttons.addWidget(self.btnForceFocus)
layout_buttons.addWidget(self.btnFixExeFlags)
layout_buttons.addWidget(self.btnSoftKill)
# create table
#
self.tableview = QTableView()
self.tableview.setModel(monitor) # the monitor is the model of this tableview.
size = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
size.setHorizontalStretch(1)
self.tableview.setSizePolicy(size)
# configure resize modes on headers
self.tableview.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
self.tableview.horizontalHeader().setStretchLastSection(False)
self.tableview.verticalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
self.tableview.verticalHeader().setVisible(False)
# create layout
#
layout = QVBoxLayout()
layout.addLayout(layout_buttons)
layout.addWidget(self.tableview)
self.setLayout(layout)
def __init__(
self,
item: TransactionItemType,
recruiter: UnitTransactionFrame[TransactionItemType],
) -> None:
super().__init__()
self.item = item
self.recruiter = recruiter
self.setProperty("style", "buy-box")
self.setMaximumHeight(72)
self.setMinimumHeight(36)
layout = QHBoxLayout()
self.setLayout(layout)
self.sell_button = QPushButton("-")
self.sell_button.setProperty("style", "btn-sell")
self.sell_button.setDisabled(not recruiter.enable_sale(item))
self.sell_button.setMinimumSize(16, 16)
self.sell_button.setMaximumSize(16, 16)
self.sell_button.setSizePolicy(
QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
)
self.sell_button.clicked.connect(
lambda: self.recruiter.recruit_handler(RecruitType.SELL, self.item)
)
self.amount_bought = QLabel()
self.amount_bought.setSizePolicy(
QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
)
self.buy_button = QPushButton("+")
self.buy_button.setProperty("style", "btn-buy")
self.buy_button.setDisabled(not recruiter.enable_purchase(item))
self.buy_button.setMinimumSize(16, 16)
self.buy_button.setMaximumSize(16, 16)
self.buy_button.clicked.connect(
lambda: self.recruiter.recruit_handler(RecruitType.BUY, self.item)
)
self.buy_button.setSizePolicy(QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed))
layout.addWidget(self.sell_button)
layout.addWidget(self.amount_bought)
layout.addWidget(self.buy_button)
self.update_state()
def main():
""" Launches the main aECG viewer window
This function parses the command line arguments, intializesa logger, and
launches the main user interface window.
Command line arguments:
indexfile (str, optional): Filename of the study index file to load
logconffile (str, optional): logging configuration file
"""
# Set start method for multiprocess to spawn for all platforms
multiprocessing.set_start_method('spawn')
logging_conf_file = pkg_resources.resource_filename(
__name__, 'cfg/aecgviewer_aecg_logging.conf')
options = argparse.ArgumentParser()
options.add_argument("-i",
"--indexfile",
type=str,
help='Study index file to be loaded')
options.add_argument("-l",
"--logconffile",
type=str,
help=f'logging configuration file (default: '
f'{logging_conf_file})',
default=logging_conf_file)
args = options.parse_args()
# Initialize logging
print(f"Loading logging configuration from: {args.logconffile}")
logging.config.fileConfig(args.logconffile)
logger = logging.getLogger("aecgviewer")
for h in logger.root.handlers:
if isinstance(h, logging.FileHandler):
print(f"Logging to {h.baseFilename} file with a "
f"{type(h).__name__}")
logger.info("aECG viewer version %s loaded", aecgviewer.__version__)
app = QApplication(sys.argv)
window = MainWindow(args.indexfile)
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
sizePolicy.setHeightForWidth(False)
window.setSizePolicy(sizePolicy)
window.show()
sys.exit(app.exec_())
def _init_toolbar(self):
self.basedir = str(cbook._get_data_path('images'))
background_color = self.palette().color(self.backgroundRole())
foreground_color = self.palette().color(self.foregroundRole())
icon_color = (foreground_color
if background_color.value() < 128 else None)
for text, tooltip_text, image_file, callback in self.toolitems:
if text is None:
self.addSeparator()
else:
a = self.addAction(self._icon(image_file + '.png', icon_color),
text, getattr(self, callback))
self._actions[callback] = a
if callback in ['zoom', 'pan']:
a.setCheckable(True)
if tooltip_text is not None:
a.setToolTip(tooltip_text)
a = self.addAction(self._icon("qt4_editor_options.png", icon_color),
'Customize', self.edit_parameters)
a.setToolTip('Edit axis, curve and image parameters')
if self.coordinates:
self.locLabel = QLabel("", self)
self.locLabel.setAlignment(Qt.AlignHCenter | Qt.AlignVCenter)
self.locLabel.setSizePolicy(
QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Ignored))
labelAction = self.addWidget(self.locLabel)
labelAction.setVisible(True)
def __init__(self):
DataViewer.__init__(self)
self.vnode = None
self.text_box = QTextEdit()
self.text_box.setReadOnly(True)
font = QFont("Courier", 8)
self.text_box.setFont(font)
self.text_box.setLineWrapMode(QTextEdit.LineWrapMode.NoWrap)
size = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
self.text_box.setSizePolicy(size)
self.bttn_open_archive = QPushButton()
self.bttn_open_archive.setObjectName('bttn_open_archive')
self.bttn_open_archive.setText('Open Archive')
self.bttn_open_archive.clicked.connect(self.open_archive)
self.cmd_layout = QHBoxLayout()
self.cmd_layout.addWidget(self.bttn_open_archive)
self.main_layout = QVBoxLayout()
self.main_layout.addLayout(self.cmd_layout)
self.main_layout.addWidget(self.text_box)
self.setLayout(self.main_layout)
def __init__(self, editor: PresetEditor):
super().__init__()
self.setupUi(self)
self._editor = editor
size_policy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
self.gridLayout.setAlignment(Qt.AlignTop)
# Relevant Items
item_database = default_prime2_item_database()
self._dark_suit = item_database.major_items["Dark Suit"]
self._light_suit = item_database.major_items["Light Suit"]
self._progressive_suit = item_database.major_items["Progressive Suit"]
self._grapple_beam = item_database.major_items["Grapple Beam"]
self._screw_attack = item_database.major_items["Screw Attack"]
self._progressive_grapple = item_database.major_items["Progressive Grapple"]
self._energy_tank_item = item_database.major_items["Energy Tank"]
self._dark_ammo_item = item_database.ammo["Dark Ammo Expansion"]
self._light_ammo_item = item_database.ammo["Light Ammo Expansion"]
self._beam_ammo_item = item_database.ammo["Beam Ammo Expansion"]
self._register_alternatives_events()
self._register_random_starting_events()
self._create_categories_boxes(size_policy)
self._create_major_item_boxes(item_database)
self._create_energy_tank_box()
self._create_ammo_pickup_boxes(size_policy, item_database)
def __init__(self, editor: PresetEditor):
super().__init__()
self.setupUi(self)
self._editor = editor
size_policy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
self.item_pool_layout.setAlignment(Qt.AlignTop)
# Relevant Items
self.game = editor.game
self.game_description = default_database.game_description_for(
self.game)
item_database = default_database.item_database_for_game(self.game)
self._energy_tank_item = item_database.major_items["Energy Tank"]
self._register_random_starting_events()
self._create_categories_boxes(item_database, size_policy)
self._create_customizable_default_items(item_database)
self._create_progressive_widgets(item_database)
self._create_major_item_boxes(item_database,
self.game_description.resource_database)
self._create_energy_tank_box()
self._create_split_ammo_widgets(item_database)
self._create_ammo_pickup_boxes(size_policy, item_database)
def __init__(self, flight, game):
super(QLoadoutEditor, self).__init__("Use custom loadout")
self.flight = flight
self.game = game
self.setCheckable(True)
self.setChecked(flight.use_custom_loadout)
self.toggled.connect(self.on_toggle)
hboxLayout = QVBoxLayout(self)
layout = QGridLayout(self)
pylons = [
v for v in self.flight.unit_type.__dict__.values()
if inspect.isclass(v) and v.__name__.startswith("Pylon")
]
for i, pylon in enumerate(pylons):
label = QLabel("<b>{}</b>".format(pylon.__name__[len("Pylon"):]))
label.setSizePolicy(
QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed))
layout.addWidget(label, i, 0)
try:
pylon_number = int(pylon.__name__.split("Pylon")[1])
except:
pylon_number = i + 1
layout.addWidget(QPylonEditor(flight, pylon, pylon_number), i, 1)
hboxLayout.addLayout(layout)
hboxLayout.addStretch()
self.setLayout(hboxLayout)
def __init__(self, background_file, model_file, camera_file):
super(ManualRegistrationMainWidget, self).__init__()
if not background_file:
raise ValueError("Background image must be specified")
if not model_file:
raise ValueError("VTK model must be specified")
if not camera_file:
raise ValueError("Camera matrix must be specified")
self.setContentsMargins(0, 0, 0, 0)
self.viewer = ow.VTKOverlayWindow()
self.viewer_size_policy = \
QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.viewer.setSizePolicy(self.viewer_size_policy)
self.interactor_style = vtk.vtkInteractorStyleTrackballActor()
self.viewer.SetInteractorStyle(self.interactor_style)
self.vertical_layout = QtWidgets.QVBoxLayout(self)
self.vertical_layout.setContentsMargins(0, 0, 0, 0)
self.vertical_layout.addWidget(self.viewer)
background = cv2.imread(background_file)
model = sm.VTKSurfaceModel(model_file, [1.0, 1.0, 1.0], opacity=0.5)
camera_matrix = np.loadtxt(camera_file)
self.viewer.set_video_image(background)
self.viewer.set_camera_matrix(camera_matrix)
self.viewer.add_vtk_models([model])
