def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.layout = QHBoxLayout(self)
# connects to the database
self.db = Database()
self.db.connectToDatabase()
#retrieves data for the logs.
logsCount = self.db.countPictures()
# creates the table for the log view
self.logsTable = QTableWidget(logsCount[0], 4)
self.logsTable.setHorizontalHeaderLabels(
["Date", "Location", "Response", "User"])
self.populateTable()
# Formats the table to fill up all avaliable space
self.logsTable.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeMode(1))
self.logsTable.horizontalHeader().setSectionResizeMode(
0, QHeaderView.ResizeMode(3))
self.layout.addWidget(self.logsTable)
def __init__(self, parent=None):
QHeaderView.__init__(self, Qt.Vertical, parent)
self.setDefaultSectionSize(self.minimumSectionSize() + 4)
self.setMinimumSectionSize(1)
self.sectionResized.connect(
self._resize)
def setup_UI(self):
"""
Инициализация интерфейса поля морского боя
"""
cell_size = 32
self.table = QTableWidget()
self.table.setColumnCount(10)
self.table.setRowCount(10)
horizontal_header = QHeaderView(Qt.Horizontal)
horizontal_header.setDefaultSectionSize(cell_size)
self.table.setHorizontalHeader(horizontal_header)
self.table.setHorizontalHeaderLabels([c for c in "АБВГДЕЖЗИК"])
for r in range(10):
for c in range(10):
self.table.setItem(r, c, QTableWidgetItem())
self.table.setEditTriggers(QTableWidget.NoEditTriggers)
self.table.setSelectionMode(QAbstractItemView.NoSelection)
layout = QVBoxLayout()
layout.addWidget(self.table)
self.setLayout(layout)
self.init_ships()
def __init__(self, menu, parent=None):
super().__init__(parent)
self.menu = menu # self wrapper
self.head = QHeaderView(Qt.Horizontal, self)
# link to database
self.db_link = DataBase4Args()
self.null_model = QStandardItemModel()
# checking the value by its type.
self.inspector = AutoInspector()
# for collection the ArgsEditableModel
self.edit_model = {}
self.current_model = None
self.current_ref_model = None
self.current_ref_dst_model_id = None
# set the horizontal head
self.head.setStretchLastSection(True)
self.setHorizontalHeader(self.head)
# hide the vertical head
self.verticalHeader().setHidden(True)
# set width
self.setMinimumWidth(320)
self.setMaximumWidth(520)
# set pop up right menu policy
self.right_menu = QMenu()
self.setContextMenuPolicy(Qt.DefaultContextMenu)
def __init__(self, table):
QHeaderView.__init__(self, Qt.Horizontal)
self.table = table
self.customContextMenuRequested.connect(table.context_menu)
self.sectionDoubleClicked.connect(table.update_duration)
self.setDefaultSectionSize(75+5)
self.setFixedHeight(35)
self.setContextMenuPolicy(Qt.CustomContextMenu)
def __init__(self, columns):
super(TableView, self).__init__()
self.columns = columns
horizontal_header = QHeaderView(Qt.Horizontal)
horizontal_header.setSectionResizeMode(QHeaderView.Stretch)
self.setHorizontalHeader(horizontal_header)
vertical_header = QHeaderView(Qt.Vertical)
self.setVerticalHeader(vertical_header)
def __init__(self, parent=None):
QHeaderView.__init__(self, Qt.Horizontal, parent)
self.setSectionsClickable(True)
self.setStretchLastSection(True)
self.setSortIndicatorShown(True)
self.setSortIndicator(0, Qt.AscendingOrder)
self.sortOptions = [
z.split(',')
for z in ['artist,album', 'album,artist', '__numtracks,album']
]
def currentCellWidth(self, searchedIndex: QModelIndex,
leafIndex: QModelIndex, sectionIndex: int,
hv: QHeaderView) -> int:
leafsList = QModelIndexList(self.leafs(searchedIndex))
if leafsList.empty():
return hv.sectionSize(sectionIndex)
width = 0
firstLeafSectionIndex = sectionIndex - leafsList.indexOf(leafIndex)
for i in range(leafsList.size()):
width += hv.sectionSize(firstLeafSectionIndex + i)
return width
def paintSection(self, painter, rect, logicalIndex):
painter.save()
QHeaderView.paintSection(self, painter, rect, logicalIndex)
painter.restore()
if logicalIndex == 0:
option = QStyleOptionButton()
option.rect = QRect(10, 10, 10, 10)
if self.isOn:
option.state = QStyle.State_On
else:
option.state = QStyle.State_Off
self.style().drawControl(QStyle.CE_CheckBox, option, painter)
self.resizeSection(0, 34)
self.resizeSection(3, 50)
def InitMainWindow():
global listViewMode
ui.m3u8_url.setText("https://bilibili.xiang-kuyun.com/20210214/11576_c9f0a0ea/index.m3u8?sign=3e7bf3669d4d88a86e5c57d7e3d67387")
ui.save_file.setText('Z:/碰撞地球')
listViewMode = QStandardItemModel(0, 3)
listViewMode.setHorizontalHeaderLabels([' # ', '视频流地址', '状态'])
#for row in range(3):
# for column in range(3):
# item=QStandardItem('row %s,column %s'%(row,column))
# listViewMode.setItem(row,column,item)
ui.tableView.setModel(listViewMode)
ui.tableView.setColumnWidth(0, 40)
ui.tableView.setColumnWidth(1, 600)
stylesheet = "QHeaderView::section{background:#99CCFF;font: bold 11px;border-width: 2px;}"
ui.tableView.horizontalHeader().setStyleSheet(stylesheet)
#ui.tableView.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
ui.tableView.horizontalHeader().setSectionResizeMode(2, QHeaderView.ResizeMode())
ui.tableView.horizontalHeader().setSectionResizeMode(1, QHeaderView.Stretch)
ui.tableView.verticalHeader().setVisible(False)
ui.tableView.horizontalHeader().setHighlightSections(False)
stylesheet = "QTableView{background-color:white;alternate-background-color: rgb(233, 248, 254)};}"
ui.tableView.setStyleSheet(stylesheet)
def __init__(self, parent):
super(CentralWidget, self).__init__(parent)
logger.debug("CentralWidget instance created.")
self.setupUi(self)
self.dirty = False
self.configManager = None
self.recorder = iomediator.Recorder(self.scriptPage)
self.cutCopiedItems = []
for column_index in range(3):
self.treeWidget.setColumnWidth(
column_index,
cm.ConfigManager.SETTINGS[cm.COLUMN_WIDTHS][column_index])
h_view = self.treeWidget.header()
h_view.setSectionResizeMode(
QHeaderView.ResizeMode(QHeaderView.Interactive
| QHeaderView.ResizeToContents))
self.logHandler = None
self.listWidget.hide()
self.factory = None # type: ak_tree.WidgetItemFactory
self.context_menu = None # type: QMenu
self.action_clear_log = self._create_action("edit-clear-history",
"Clear Log", None,
self.on_clear_log)
self.listWidget.addAction(self.action_clear_log)
self.action_save_log = self._create_action("edit-clear-history",
"Save Log As…", None,
self.on_save_log)
self.listWidget.addAction(self.action_save_log)
def setup(self):
self.info_tree.header().hide()
self.info_tree.setColumnCount(3)
# self.info_tree.setColumnWidth(0, 100)
# self.info_tree.setColumnWidth(1, 100)
# self.info_tree.setColumnWidth(2, 100)
self.info_tree.setHeaderLabels(['Key','Value',''])
self.info_tree.header().setSectionResizeMode(QHeaderView.ResizeMode(3))
self.root.setText(0, "信息")
self.root.setText(1, "")
self.n_item_basic_info = QTreeWidgetItem(self.root)
self.n_item_basic_info.setText(0, "子切片信息: ")
self.n_item_index = self.add_item(self.n_item_basic_info, '目标编号：', '-')
self.n_item_width = self.add_item(self.n_item_basic_info, '切片宽度：', '-')
self.n_item_height = self.add_item(self.n_item_basic_info, '切片高度：', '-')
self.n_item_is_pos = self.add_item(self.n_item_basic_info, '是否存在阳性区域：', '-')
self.n_item_rate = self.add_item(self.n_item_basic_info, '阳性区域占比：', '-')
self.item_basic_info = QTreeWidgetItem(self.root)
self.item_basic_info.setText(0, '当前全切片信息：')
self.item_index = self.add_item(self.item_basic_info, '全切片编号：', '-')
self.item_width = self.add_item(self.item_basic_info, '全切片宽度：', '-')
self.item_height = self.add_item(self.item_basic_info, '全切片高度：', '-')
self.item_channels = self.add_item(self.item_basic_info, '通道数：', '-')
self.item_rate = self.add_item(self.item_basic_info, '阳性区域占比：', '-')
self.item_pixel_acc = self.add_item(self.item_basic_info, '平均像素精度：', '-')
self.item_dice = self.add_item(self.item_basic_info, 'Dice：', '-')
self.item_jaccard = self.add_item(self.item_basic_info, 'jaccard：', '-')
self.item_recall = self.add_item(self.item_basic_info, 'recall: ', '-')
self.item_precision = self.add_item(self.item_basic_info, 'precision: ', '-')
self.info_tree.addTopLevelItem(self.root)
self.info_tree.expandAll()
def deviceRemove(self):
"""
Summary: Displays a table of ever device for users to remove
"""
removeDeviceDialog = QDialog()
dialogLayout = QVBoxLayout(removeDeviceDialog)
devices = self.db.getDevices()
deviceCount = len(devices)
self.removeDeviceTable = QTableWidget(self.db.countDevices()[0], 5,
self)
self.removeDeviceTable.setHorizontalHeaderLabels(
["Name", "Purpose", "Importance", "Location", "Remove"])
# Formats the table to fill up all avaliable space
self.removeDeviceTable.horizontalHeader().setSectionResizeMode(
QHeaderView.ResizeMode(1))
self.removeDeviceTable.horizontalHeader().setSectionResizeMode(
4, QHeaderView.ResizeMode(2))
# Here is where all of the information is unpacked and inserted into the table
for deviceIndex in range(0, deviceCount):
deviceName = QTableWidgetItem("{}".format(devices[deviceIndex][0]))
devicePurpose = QTableWidgetItem("{}".format(
devices[deviceIndex][1]))
deviceImportance = QTableWidgetItem("{}".format(
devices[deviceIndex][2]))
deviceLocation = QTableWidgetItem("{}".format(
devices[deviceIndex][3]))
deviceRemove = QPushButton("Kill")
self.removeDeviceTable.setItem(deviceIndex, 0, deviceName)
self.removeDeviceTable.setItem(deviceIndex, 1, devicePurpose)
self.removeDeviceTable.setItem(deviceIndex, 2, deviceImportance)
self.removeDeviceTable.setItem(deviceIndex, 3, deviceLocation)
self.removeDeviceTable.setCellWidget(deviceIndex, 4, deviceRemove)
deviceRemove.clicked.connect(self.killDevice)
dialogLayout.addWidget(self.removeDeviceTable)
removeDeviceDialog.exec_()
def create_registered_mn_tab(self):
w = QWidget()
hw = QWidget()
self.reg_label = QLabel(self.registered_label())
self.reg_search_btn = QPushButton(_('Search'))
self.reg_search_btn.clicked.connect(self.on_reg_search)
src_model = RegisteredMNsModel(self.mn_list)
self.reg_model = Dip3FilterProxyModel()
self.reg_model.setSourceModel(src_model)
self.reg_view = QTableView()
self.reg_view.setContextMenuPolicy(Qt.CustomContextMenu)
self.reg_view.customContextMenuRequested.connect(self.create_reg_menu)
self.reg_hheader = QHeaderView(Qt.Horizontal, self.reg_view)
self.reg_hheader.setSectionResizeMode(QHeaderView.ResizeToContents)
self.reg_hheader.setStretchLastSection(True)
self.reg_view.setHorizontalHeader(self.reg_hheader)
self.reg_view.verticalHeader().hide()
self.reg_view.setModel(self.reg_model)
self.reg_view.setSelectionMode(QAbstractItemView.SingleSelection)
self.reg_view.setSelectionBehavior(QAbstractItemView.SelectRows)
self.reg_view.doubleClicked.connect(self.reg_mn_dbl_clicked)
sel_model = self.reg_view.selectionModel()
sel_model.selectionChanged.connect(self.on_reg_selection_changed)
hbox = QHBoxLayout()
vbox = QVBoxLayout()
hbox.setContentsMargins(0, 0, 0, 0)
hbox.addWidget(self.reg_label)
hbox.addStretch(1)
hbox.addWidget(self.reg_search_btn)
hw.setLayout(hbox)
vbox.addWidget(hw)
vbox.addWidget(self.reg_view)
w.setLayout(vbox)
self.addTab(w, read_QIcon('tab_search.png'), _('Registered MNs'))
if not self.mn_list.protx_loading:
self.reg_model.reload_data()
self.restore_reg_selection()
return w
def createContractTable(self):
self.contractHeaderView = QHeaderView(Qt.Horizontal)
self.contractHeaderView.resizeSections(QHeaderView.Interactive)
styleSheet = """
QHeaderView::section{
background-color: qlineargradient(x1:0, y1:0, x2:0, y2:1,
stop:0 #616161, stop: 0.5 #505050,
stop: 0.6 #434343, stop:1 #656565);
color:white;
border:0.5px solid;
}
"""
self.contractHeaderView.setStyleSheet(styleSheet)
self.contractView.setHorizontalHeader(self.contractHeaderView)
header = ["time", "open", "high", "low", "close", "volume"]
row_length = 0
col_length = 6
self.contractModel = ContractModel(row_length, col_length, header)
self.contractView.setModel(self.contractModel)
def currentCellLeft(self, searchedIndex: QModelIndex,
leafIndex: QModelIndex, sectionIndex: int,
left: int, hv: QHeaderView) -> int:
leafsList = QModelIndexList(self.leafs(searchedIndex))
if not leafsList.empty():
n = leafsList.indexOf(leafIndex)
firstLeafSectionIndex = sectionIndex - n
n -= 1
for n in range(n, 0 - 1, -1):
left -= hv.sectionSize(firstLeafSectionIndex + n)
return left
def cellSize(self, leafIndex: QModelIndex, hv: QHeaderView,
styleOptions: QStyleOptionHeader) -> QSize:
res = QSize()
variant = leafIndex.data(Qt.SizeHintRole)
if variant:
res = variant
fnt = QFont(hv.font())
var = leafIndex.data(Qt.FontRole)
if var:
fnt = var
fnt.setBold(True)
fm = QFontMetrics(fnt)
size = QSize(
fm.size(0, leafIndex.data(Qt.DisplayRole)) +
QSize(4, 0)) # WA: add more horizontal size (4px)
if leafIndex.data(Qt.UserRole):
size.transpose()
decorationsSize = QSize(hv.style().sizeFromContents(
QStyle.CT_HeaderSection, styleOptions, QSize(), hv))
emptyTextSize = QSize(fm.size(0, ""))
return res.expandedTo(size + decorationsSize - emptyTextSize)
def paintVerticalCell(self, painter: QPainter, hv: QHeaderView,
cellIndex: QModelIndex, leafIndex: QModelIndex,
logicalLeafIndex: int,
styleOptions: QStyleOptionHeader,
sectionRect: QRect, left: int):
uniopt = QStyleOptionHeader(styleOptions)
self.setForegroundBrush(uniopt, cellIndex)
self.setBackgroundBrush(uniopt, cellIndex)
width = self.cellSize(cellIndex, hv, uniopt).width()
if cellIndex == leafIndex:
width = sectionRect.width() - left
top = self.currentCellLeft(cellIndex, leafIndex, logicalLeafIndex,
sectionRect.top(), hv)
height = self.currentCellWidth(cellIndex, leafIndex,
logicalLeafIndex, hv)
r = QRect(left, top, width, height)
uniopt.text = cellIndex.data(Qt.DisplayRole)
painter.save()
uniopt.rect = r
if cellIndex.data(Qt.UserRole):
hv.style().drawControl(QStyle.CE_HeaderSection, uniopt,
painter, hv)
m = QTransform()
m.rotate(-90)
painter.setWorldMatrix(m, True)
new_r = QRect(0, 0, r.height(), r.width())
new_r.moveCenter(QPoint(-r.center().y(), r.center().x()))
uniopt.rect = new_r
hv.style().drawControl(QStyle.CE_HeaderLabel, uniopt, painter,
hv)
else:
hv.style().drawControl(QStyle.CE_Header, uniopt, painter, hv)
painter.restore()
return left + width
def setup_controller(self, user_id):
self.user_id = user_id
self.main_model = MainWindowModel(self.db_connection, 'Pracownicy')
self.table_model = TableModel(self.main_model, edit_enabled=False)
self.create_list(
Queries.query_trainer_personal,
['Imię', 'Nazwisko', 'PESEL', 'Data urodzenia', 'Nr licencji'])
self.ui.tableView.setHorizontalHeader(
QHeaderView(Qt.Horizontal, self.ui.tableView))
self.ui.tableView.setModel(self.table_model)
self.ui.tableView.horizontalHeader().setSizeAdjustPolicy(
QtWidgets.QAbstractScrollArea.AdjustToContents)
def create_tableview(self):
"""
create the table view for DMX values
"""
self.view = QTableView()
self.view.setSelectionMode(QAbstractItemView.NoSelection)
self.model = UniverseModel(self)
self.view.setModel(self.model)
# set up headers of the QTableView
v_headers = QHeaderView(Qt.Vertical)
self.view.setVerticalHeader(v_headers)
h_headers = QHeaderView(Qt.Horizontal)
self.view.setHorizontalHeader(h_headers)
if debug :
print('how many lines : ', v_headers.count())
print('how many columns : ', h_headers.count())
# set up rows and columns
for col in range(self.model.columnCount()):
self.view.setColumnWidth(col, 28)
for row in range(self.model.rowCount()):
self.view.setRowHeight(row, 20)
self.view.setMinimumHeight(350)
def _update_sort_info(header: QtWidgets.QHeaderView, index: int,
indicator: QtCore.Qt.SortOrder) -> NoReturn:
# Update header's sorting indicator according to sorting status
if indicator is not None:
header.setSortIndicator(index, indicator)
header.setSortIndicatorShown(True)
else:
header.setSortIndicatorShown(False)
def __init__(self, ui, db_connection):
super(AdminWindowController,
self).__init__(db_connection=db_connection, ui=ui)
self.main_model = MainWindowModel(db_connection, 'Pracownicy')
self.current_table = 'Pracownicy'
self.current_id = None
self.table_model = TableModel(self.main_model)
# self.create_list('Pracownicy', ['id_pracownika,imie,nazwisko,pesel,id_stanowisko,data_urodzenia'], 'id_pracownika')
self.create_list('Pracownicy', ['*'], 'id_pracownika')
self.ui.tableView.setHorizontalHeader(
QHeaderView(Qt.Horizontal, self.ui.tableView))
self.ui.tableView.horizontalHeader().setStretchLastSection(True)
self.ui.tableView.setModel(self.table_model)
self.ui.tableView.verticalHeader().setVisible(False)
style = "::section {" "background-color: pink; }"
self.ui.tableView.horizontalHeader().setStyleSheet(style)
# INITIAL STATE OF BUTTONS
self.ui.pushButton_delete.setDisabled(True)
self.edit_enabled = True
# self.ui.tableView.resizeColumnsToContents()
self.ui.tableView.horizontalHeader().setSizeAdjustPolicy(
QtWidgets.QAbstractScrollArea.AdjustToContents)
# CONNECTING FUNCTIONS TO BUTTONS
self.ui.pushButton_add.clicked.connect(self.add)
self.ui.pushButton_delete.clicked.connect(self.delete)
self.ui.tableView.clicked.connect(self.table_clicked)
#Table choice combo box
self.ui.comboBox_tables.addItems(self.main_model.tables)
self.ui.comboBox_tables.currentIndexChanged.connect(
self.table_selection_change)
#SORT BY COMBO BOX
self.ui.comboBox_sortBy.addItems(self.table_model.headers)
self.ui.comboBox_sortBy.currentIndexChanged.connect(
self.sort_selection_change)
def _setFilelistTable(self):
fileHeaderview = QHeaderView(Qt.Horizontal)
fileHeaderview.resizeSections(QHeaderView.Interactive)
styleSheet = """
QHeaderView::section{
background-color: qlineargradient(x1:0, y1:0, x2:0, y2:1,
stop:0 #616161, stop: 0.5 #505050,
stop: 0.6 #434343, stop:1 #656565);
color:white;
border:0.5px solid;
}
"""
fileHeaderview.setStyleSheet(styleSheet)
self.filelistView.setHorizontalHeader(fileHeaderview)
header = ["file name", "start date", "end date", "base"]
row_length = 0
self.col_length = 4
self.filemodel = ShiftFilelistModel(row_length, self.col_length,
header)
self.filelistView.setModel(self.filemodel)
def create_tableview(self):
"""
create the table view for DMX values
"""
self.view = QTableView()
self.view.setSelectionMode(QAbstractItemView.NoSelection)
self.model = UniverseModel(self)
self.view.setModel(self.model)
# set up headers of the QTableView
v_headers = QHeaderView(Qt.Vertical)
self.view.setVerticalHeader(v_headers)
h_headers = QHeaderView(Qt.Horizontal)
self.view.setHorizontalHeader(h_headers)
if debug:
print('how many lines : ', v_headers.count())
print('how many columns : ', h_headers.count())
# set up rows and columns
for col in range(self.model.columnCount()):
self.view.setColumnWidth(col, 28)
for row in range(self.model.rowCount()):
self.view.setRowHeight(row, 20)
self.view.setMinimumHeight(350)
def _setup_AdjustTable(self):
adjustHeaderview = QHeaderView(Qt.Horizontal)
adjustHeaderview.resizeSections(QHeaderView.Interactive)
styleSheet = """
QHeaderView::section{
background-color: qlineargradient(x1:0, y1:0, x2:0, y2:1,
stop:0 #616161, stop: 0.5 #505050,
stop: 0.6 #434343, stop:1 #656565);
color:white;
border:0.5px solid;
}
"""
adjustHeaderview.setStyleSheet(styleSheet)
self.adjustView.setHorizontalHeader(adjustHeaderview)
header = [
"first contract", "start date", "end date", "second contract",
"start date", "end date", "base point"
]
row_length = 0
col_length = 7
self.adjustmodel = ShiftAdjustModel(row_length, col_length, header)
self.adjustmodel.setContractDataDict(self.contractEditor_dict)
self.adjustmodel.setRollPointCalculator(RPByMaxVolume())
self.adjustView.setModel(self.adjustmodel)
def _unittest_task_statistics_table_model():
import time
from PyQt5.QtWidgets import QApplication, QMainWindow
app = QApplication([])
win = QMainWindow()
win.resize(800, 600)
model = _TableModel(win)
view = QTableView(win)
view.setModel(model)
view.setSortingEnabled(True)
hh = QHeaderView(Qt.Horizontal, view)
hh.setModel(model)
hh.setVisible(True)
view.setHorizontalHeader(hh)
win.setCentralWidget(view)
win.show()
def go_go_go():
for _ in range(1000):
time.sleep(0.001)
app.processEvents()
go_go_go()
model.set_data(_make_test_data())
for _ in range(5):
go_go_go()
win.close()
def _setupResultTable(self):
resultHeaderview = QHeaderView(Qt.Horizontal)
resultHeaderview.resizeSections(QHeaderView.Interactive)
styleSheet = """
QHeaderView::section{
background-color: qlineargradient(x1:0, y1:0, x2:0, y2:1,
stop:0 #616161, stop: 0.5 #505050,
stop: 0.6 #434343, stop:1 #656565);
color:white;
border:0.5px solid;
}
"""
resultHeaderview.setStyleSheet(styleSheet)
#resultHeaderview.setSectionResizeMode(QHeaderView.ResizeToContents)
self.resultView.setHorizontalHeader(resultHeaderview)
header = [
"date", "open", "high", "low", "close", "volume", "adjustment",
"contract name"
]
row_size = 0
col_size = 8
self.resultmodel = ResultModel(row_size, col_size, header)
self.resultView.setModel(self.resultmodel)
def build_models(self):
self.path_model = PathModel(self.coredata)
self.target_model = TargetModel(self.build)
self.dep_model = DependencyModel(self.coredata)
self.core_model = CoreModel(self.coredata)
self.fill_data()
self.ui.core_view.setModel(self.core_model)
hv = QHeaderView(1)
hv.setModel(self.core_model)
self.ui.core_view.setHeader(hv)
self.ui.path_view.setModel(self.path_model)
hv = QHeaderView(1)
hv.setModel(self.path_model)
self.ui.path_view.setHeader(hv)
self.ui.target_view.setModel(self.target_model)
hv = QHeaderView(1)
hv.setModel(self.target_model)
self.ui.target_view.setHeader(hv)
self.ui.dep_view.setModel(self.dep_model)
hv = QHeaderView(1)
hv.setModel(self.dep_model)
self.ui.dep_view.setHeader(hv)
self.ui.compile_button.clicked.connect(self.compile)
self.ui.test_button.clicked.connect(self.run_tests)
self.ui.install_button.clicked.connect(self.install)
self.ui.clean_button.clicked.connect(self.clean)
self.ui.save_button.clicked.connect(self.save)
def initUI(self):
self.setGeometry(100, 100, 1200, 1200)
self.display_size = 800
self.addToolBar("MY Window")
self.showMaximized()
layout = QHBoxLayout()
vbox1 = QVBoxLayout()
vbox2 = QVBoxLayout()
vbox1hbox1 = QHBoxLayout()
vbox1.setContentsMargins(0, 0, 100, 100)
vbox2.setContentsMargins(100, 0, 0, 100)
vbox2hbox1 = QHBoxLayout()
vbox2.addLayout(vbox2hbox1)
layout.addLayout(vbox1)
layout.addLayout(vbox2)
dicomButton = QPushButton('Read DICOM')
contoursButton = QPushButton('Read Contours')
gatingButton = QPushButton('Extract Diastolic Frames')
segmentButton = QPushButton('Segment')
splineButton = QPushButton('Manual Contour')
writeButton = QPushButton('Write Contours')
reportButton = QPushButton('Write Report')
dicomButton.setToolTip("Load images in .dcm format")
contoursButton.setToolTip("Load saved contours in .xml format")
gatingButton.setToolTip("Extract end diastolic images from pullback")
segmentButton.setToolTip(
"Run deep learning based segmentation of lumen and plaque")
splineButton.setToolTip(
"Manually draw new contour for lumen, plaque or stent")
writeButton.setToolTip("Save contours in .xml file")
reportButton.setToolTip(
"Write report containing, lumen, plaque and vessel areas and plaque burden"
)
hideHeader1 = QHeaderView(Qt.Vertical)
hideHeader1.hide()
hideHeader2 = QHeaderView(Qt.Horizontal)
hideHeader2.hide()
self.infoTable = QTableWidget()
self.infoTable.setRowCount(8)
self.infoTable.setColumnCount(2)
self.infoTable.setItem(0, 0, QTableWidgetItem('Patient Name'))
self.infoTable.setItem(1, 0, QTableWidgetItem('Patient DOB'))
self.infoTable.setItem(2, 0, QTableWidgetItem('Patient Sex'))
self.infoTable.setItem(3, 0, QTableWidgetItem('Pullback Speed'))
self.infoTable.setItem(4, 0, QTableWidgetItem('Resolution (mm)'))
self.infoTable.setItem(5, 0, QTableWidgetItem('Dimensions'))
self.infoTable.setItem(6, 0, QTableWidgetItem('Manufacturer'))
self.infoTable.setItem(7, 0, QTableWidgetItem('Model'))
self.infoTable.setVerticalHeader(hideHeader1)
self.infoTable.setHorizontalHeader(hideHeader2)
self.infoTable.horizontalHeader().setStretchLastSection(True)
dicomButton.clicked.connect(self.readDICOM)
contoursButton.clicked.connect(self.readContours)
segmentButton.clicked.connect(self.segment)
splineButton.clicked.connect(self.newSpline)
gatingButton.clicked.connect(self.gate)
writeButton.clicked.connect(self.writeContours)
reportButton.clicked.connect(self.report)
self.playButton = QPushButton()
pixmapi1 = getattr(QStyle, 'SP_MediaPlay')
pixmapi2 = getattr(QStyle, 'SP_MediaPause')
self.playIcon = self.style().standardIcon(pixmapi1)
self.pauseIcon = self.style().standardIcon(pixmapi2)
self.playButton.setIcon(self.playIcon)
self.playButton.clicked.connect(self.play)
self.paused = True
self.slider = Slider(Qt.Horizontal)
self.slider.valueChanged[int].connect(self.changeValue)
self.hideBox = QCheckBox('Hide Contours')
self.hideBox.setChecked(True)
self.hideBox.stateChanged[int].connect(self.changeState)
self.useGatedBox = QCheckBox('Gated Frames')
self.useGatedBox.stateChanged[int].connect(self.useGated)
self.useGatedBox.setToolTip(
"When this is checked only gated frames will be segmented and only gated frames statistics will be written to the report"
)
self.useGatedBox.setToolTipDuration(200)
self.wid = Display()
self.c = Communicate()
self.c.updateBW[int].connect(self.wid.setFrame)
self.c.updateBool[bool].connect(self.wid.setDisplay)
self.text = QLabel()
self.text.setAlignment(Qt.AlignCenter)
self.text.setText("Frame {}".format(self.slider.value()))
vbox1.addWidget(self.wid)
vbox1hbox1.addWidget(self.playButton)
vbox1hbox1.addWidget(self.slider)
vbox1.addLayout(vbox1hbox1)
vbox1.addWidget(self.text)
vbox2.addWidget(self.hideBox)
vbox2.addWidget(self.useGatedBox)
vbox2.addWidget(dicomButton)
vbox2.addWidget(contoursButton)
vbox2.addWidget(gatingButton)
vbox2.addWidget(segmentButton)
vbox2.addWidget(splineButton)
vbox2.addWidget(writeButton)
vbox2.addWidget(reportButton)
vbox2hbox1.addWidget(self.infoTable)
centralWidget = QWidget()
centralWidget.setLayout(layout)
self.setWindowIcon(QIcon('Media/thumbnail.png'))
self.setWindowTitle('DeepIVUS')
self.setCentralWidget(centralWidget)
self.show()
disclaimer = QMessageBox.about(
self, 'DeepIVUS',
'DeepIVUS is not FDA approved and should not be used for medical decisions.'
)
def __init__(self, orientation, parent=None):
QHeaderView.__init__(self, orientation, parent)
self.orientation = orientation
def create_wallet_mn_tab(self):
w = QWidget()
hw = QWidget()
self.w_label = QLabel(self.wallet_label())
self.w_add_btn = QPushButton(_('Add / Import'))
self.w_file_btn = QPushButton(_('File'))
self.w_del_btn = QPushButton(_('Remove'))
self.w_up_params_btn = QPushButton(_('Update Params'))
self.w_up_coll_btn = QPushButton(_('Change Collateral'))
self.w_protx_btn = QPushButton(_('Register'))
self.w_up_srv_btn = QPushButton(_('Update Service'))
self.w_up_reg_btn = QPushButton(_('Update Registrar'))
self.w_add_btn.clicked.connect(self.on_add_masternode)
self.w_file_btn.clicked.connect(self.on_file)
self.w_del_btn.clicked.connect(self.on_del_masternode)
self.w_up_params_btn.clicked.connect(self.on_update_params)
self.w_up_coll_btn.clicked.connect(self.on_update_collateral)
self.w_protx_btn.clicked.connect(self.on_make_pro_reg_tx)
self.w_up_srv_btn.clicked.connect(self.on_make_pro_up_srv_tx)
self.w_up_reg_btn.clicked.connect(self.on_make_pro_up_reg_tx)
self.w_view = QTableView()
self.w_view.setContextMenuPolicy(Qt.CustomContextMenu)
self.w_view.customContextMenuRequested.connect(self.create_wallet_menu)
self.w_hheader = QHeaderView(Qt.Horizontal, self.w_view)
self.w_hheader.setSectionResizeMode(QHeaderView.ResizeToContents)
self.w_hheader.setStretchLastSection(True)
self.w_view.setHorizontalHeader(self.w_hheader)
self.w_view.verticalHeader().hide()
self.w_view.setSelectionMode(QAbstractItemView.SingleSelection)
self.w_view.setSelectionBehavior(QAbstractItemView.SelectRows)
self.w_view.doubleClicked.connect(self.w_mn_dbl_clicked)
row_h = self.w_view.verticalHeader().defaultSectionSize()
self.w_hheader.setMinimumSectionSize(row_h)
src_model = WalletMNsModel(self.manager, self.mn_list, self.gui, row_h)
src_model.dataChanged.connect(self.w_data_changed)
self.w_model = Dip3FilterProxyModel()
self.w_model.setSourceModel(src_model)
self.w_view.setModel(self.w_model)
sel_model = self.w_view.selectionModel()
sel_model.selectionChanged.connect(self.on_wallet_selection_changed)
self.w_model.modelReset.connect(self.on_wallet_model_reset)
hbox = QHBoxLayout()
vbox = QVBoxLayout()
hbox.setContentsMargins(0, 0, 0, 0)
hbox.addWidget(self.w_label)
hbox.addStretch(1)
hbox.addWidget(self.w_del_btn)
hbox.addWidget(self.w_up_params_btn)
hbox.addWidget(self.w_up_coll_btn)
hbox.addWidget(self.w_protx_btn)
hbox.addWidget(self.w_up_reg_btn)
hbox.addWidget(self.w_up_srv_btn)
hbox.addWidget(self.w_file_btn)
hbox.addWidget(self.w_add_btn)
hw.setLayout(hbox)
vbox.addWidget(hw)
vbox.addWidget(self.w_view)
w.setLayout(vbox)
self.addTab(w, read_QIcon('tab_dip3.png'), _('Wallet MNs'))
if not self.mn_list.protx_loading:
self.w_model.reload_data()
return w
class Dip3TabWidget(QTabWidget):
# Signals need to notify from not Qt thread
alias_updated = pyqtSignal(str)
diff_updated = pyqtSignal(dict)
network_updated = pyqtSignal()
def __init__(self, gui, wallet, *args, **kwargs):
QTabWidget.__init__(self, *args, **kwargs)
self.tab_bar = Dip3TabBar(self)
self.setTabBar(self.tab_bar)
self.setTabPosition(QTabWidget.East)
self.gui = gui
self.wallet = wallet
self.manager = wallet.protx_manager
self.mn_list = gui.network.mn_list if gui.network else None
self.reg_cur_protx = ''
self.w_cur_alias = ''
self.w_cur_state = ''
self.w_cur_idx = None
self.wallet_mn_tab = self.create_wallet_mn_tab()
self.registerd_mn_tab = self.create_registered_mn_tab()
self.searchable_list = self.w_model
self.currentChanged.connect(self.on_tabs_current_changed)
if self.mn_list:
self.tab_bar.update_heights(self.mn_list.protx_height,
self.mn_list.llmq_human_height,
gui.network.get_local_height())
self.mn_list.register_callback(self.on_mn_list_diff_updated,
['mn-list-diff-updated'])
self.gui.network.register_callback(self.on_cb_network_updated,
['network_updated'])
self.manager.register_callback(self.on_manager_alias_updated,
['manager-alias-updated'])
self.alias_updated.connect(self.on_alias_updated)
self.diff_updated.connect(self.on_diff_updated)
self.network_updated.connect(self.on_network_updated)
@pyqtSlot()
def on_tabs_current_changed(self):
cur_widget = self.currentWidget()
if cur_widget == self.wallet_mn_tab:
self.searchable_list = self.w_model
else:
self.searchable_list = self.reg_model
def on_mn_list_diff_updated(self, key, value):
self.diff_updated.emit(value)
def on_manager_alias_updated(self, key, value):
self.alias_updated.emit(value)
def on_cb_network_updated(self, key):
self.network_updated.emit()
@pyqtSlot(str)
def on_alias_updated(self, alias):
self.w_model.reload_data()
@pyqtSlot()
def on_network_updated(self):
self.tab_bar.update_heights(None, None,
self.gui.network.get_local_height())
@pyqtSlot(dict)
def on_diff_updated(self, value):
state = value.get('state', self.mn_list.DIP3_DISABLED)
if self.mn_list.load_mns and not self.mn_list.protx_loading:
self.reg_model.reload_data()
self.w_model.reload_data()
if state == self.mn_list.DIP3_ENABLED:
self.reg_search_btn.setEnabled(True)
else:
self.reg_search_btn.setEnabled(False)
self.tab_bar.update_heights(self.mn_list.protx_height,
self.mn_list.llmq_human_height,
self.gui.network.get_local_height())
self.update_registered_label()
self.update_wallet_label()
def registered_label(self):
if not self.mn_list:
return _('Offline')
state = self.mn_list.protx_state
if state == self.mn_list.DIP3_DISABLED:
return _('DIP3 Masternodes is currently disabled.')
count = len(self.mn_list.protx_mns)
connected = self.gui.network.is_connected()
loading = connected and self.mn_list.protx_loading
ready = _('Loading') if loading else _('Found')
return (_('%s %s registered DIP3 Masternodes.') % (ready, count))
def update_registered_label(self):
self.reg_label.setText(self.registered_label())
def wallet_label(self):
mns = self.manager.mns
count = len(mns)
mn_str = _('Masternode') if count == 1 else _('Masternodes')
def_label_str = _('Wallet contains %s DIP3 %s.') % (count, mn_str)
if not self.mn_list:
return def_label_str
state = self.mn_list.protx_state
if state == self.mn_list.DIP3_DISABLED:
return (_('DIP3 Masternodes is currently disabled.'))
connected = self.gui.network.is_connected()
loading = connected and self.mn_list.protx_loading
if loading:
height = self.mn_list.protx_height
return (_('Loading DIP3 data at Height: %s.') % height)
return def_label_str
def update_wallet_label(self):
self.w_label.setText(self.wallet_label())
def create_registered_mn_tab(self):
w = QWidget()
hw = QWidget()
self.reg_label = QLabel(self.registered_label())
self.reg_search_btn = QPushButton(_('Search'))
self.reg_search_btn.clicked.connect(self.on_reg_search)
src_model = RegisteredMNsModel(self.mn_list)
self.reg_model = Dip3FilterProxyModel()
self.reg_model.setSourceModel(src_model)
self.reg_view = QTableView()
self.reg_view.setContextMenuPolicy(Qt.CustomContextMenu)
self.reg_view.customContextMenuRequested.connect(self.create_reg_menu)
self.reg_hheader = QHeaderView(Qt.Horizontal, self.reg_view)
self.reg_hheader.setSectionResizeMode(QHeaderView.ResizeToContents)
self.reg_hheader.setStretchLastSection(True)
self.reg_view.setHorizontalHeader(self.reg_hheader)
self.reg_view.verticalHeader().hide()
self.reg_view.setModel(self.reg_model)
self.reg_view.setSelectionMode(QAbstractItemView.SingleSelection)
self.reg_view.setSelectionBehavior(QAbstractItemView.SelectRows)
self.reg_view.doubleClicked.connect(self.reg_mn_dbl_clicked)
sel_model = self.reg_view.selectionModel()
sel_model.selectionChanged.connect(self.on_reg_selection_changed)
hbox = QHBoxLayout()
vbox = QVBoxLayout()
hbox.setContentsMargins(0, 0, 0, 0)
hbox.addWidget(self.reg_label)
hbox.addStretch(1)
hbox.addWidget(self.reg_search_btn)
hw.setLayout(hbox)
vbox.addWidget(hw)
vbox.addWidget(self.reg_view)
w.setLayout(vbox)
self.addTab(w, read_QIcon('tab_search.png'), _('Registered MNs'))
if not self.mn_list.protx_loading:
self.reg_model.reload_data()
return w
def create_reg_menu(self, position):
menu = QMenu()
h = self.reg_cur_protx
menu.addAction(_('Details'),
lambda: Dip3MNInfoDialog(self, protx_hash=h).show())
menu.exec_(self.reg_view.viewport().mapToGlobal(position))
def create_wallet_mn_tab(self):
w = QWidget()
hw = QWidget()
self.w_label = QLabel(self.wallet_label())
self.w_add_btn = QPushButton(_('Add / Import'))
self.w_file_btn = QPushButton(_('File'))
self.w_del_btn = QPushButton(_('Remove'))
self.w_up_params_btn = QPushButton(_('Update Params'))
self.w_up_coll_btn = QPushButton(_('Change Collateral'))
self.w_protx_btn = QPushButton(_('Register'))
self.w_up_srv_btn = QPushButton(_('Update Service'))
self.w_up_reg_btn = QPushButton(_('Update Registrar'))
self.w_add_btn.clicked.connect(self.on_add_masternode)
self.w_file_btn.clicked.connect(self.on_file)
self.w_del_btn.clicked.connect(self.on_del_masternode)
self.w_up_params_btn.clicked.connect(self.on_update_params)
self.w_up_coll_btn.clicked.connect(self.on_update_collateral)
self.w_protx_btn.clicked.connect(self.on_make_pro_reg_tx)
self.w_up_srv_btn.clicked.connect(self.on_make_pro_up_srv_tx)
self.w_up_reg_btn.clicked.connect(self.on_make_pro_up_reg_tx)
self.w_view = QTableView()
self.w_view.setContextMenuPolicy(Qt.CustomContextMenu)
self.w_view.customContextMenuRequested.connect(self.create_wallet_menu)
self.w_hheader = QHeaderView(Qt.Horizontal, self.w_view)
self.w_hheader.setSectionResizeMode(QHeaderView.ResizeToContents)
self.w_hheader.setStretchLastSection(True)
self.w_view.setHorizontalHeader(self.w_hheader)
self.w_view.verticalHeader().hide()
self.w_view.setSelectionMode(QAbstractItemView.SingleSelection)
self.w_view.setSelectionBehavior(QAbstractItemView.SelectRows)
self.w_view.doubleClicked.connect(self.w_mn_dbl_clicked)
row_h = self.w_view.verticalHeader().defaultSectionSize()
self.w_hheader.setMinimumSectionSize(row_h)
src_model = WalletMNsModel(self.manager, self.mn_list, self.gui, row_h)
src_model.dataChanged.connect(self.w_data_changed)
self.w_model = Dip3FilterProxyModel()
self.w_model.setSourceModel(src_model)
self.w_view.setModel(self.w_model)
sel_model = self.w_view.selectionModel()
sel_model.selectionChanged.connect(self.on_wallet_selection_changed)
self.w_model.modelReset.connect(self.on_wallet_model_reset)
hbox = QHBoxLayout()
vbox = QVBoxLayout()
hbox.setContentsMargins(0, 0, 0, 0)
hbox.addWidget(self.w_label)
hbox.addStretch(1)
hbox.addWidget(self.w_del_btn)
hbox.addWidget(self.w_up_params_btn)
hbox.addWidget(self.w_up_coll_btn)
hbox.addWidget(self.w_protx_btn)
hbox.addWidget(self.w_up_reg_btn)
hbox.addWidget(self.w_up_srv_btn)
hbox.addWidget(self.w_file_btn)
hbox.addWidget(self.w_add_btn)
hw.setLayout(hbox)
vbox.addWidget(hw)
vbox.addWidget(self.w_view)
w.setLayout(vbox)
self.addTab(w, read_QIcon('tab_dip3.png'), _('Wallet MNs'))
if not self.mn_list.protx_loading:
self.w_model.reload_data()
return w
@pyqtSlot()
def on_reg_search(self):
self.gui.toggle_search()
def create_wallet_menu(self, position):
a = self.w_cur_alias
s = self.w_cur_state
i = self.w_cur_idx
if not i:
return
mn = self.manager.mns.get(a)
owned = mn.is_owned
operated = mn.is_operated
protx_hash = mn.protx_hash
removed = (s == WalletMNsModel.STATE_REMOVED)
menu = QMenu()
menu.addAction(_('Remove'), self.on_del_masternode)
if not protx_hash:
menu.addAction(_('Update Params'), self.on_update_params)
if removed and owned:
menu.addAction(_('Change Collateral'), self.on_update_collateral)
if owned and not protx_hash:
menu.addAction(_('Register Masternode'), self.on_make_pro_reg_tx)
if operated and protx_hash and not removed:
menu.addAction(_('Update Service'), self.on_make_pro_up_srv_tx)
if owned and protx_hash and not removed:
menu.addAction(_('Update Registrar'), self.on_make_pro_up_reg_tx)
menu.addSeparator()
menu.addAction(_('Rename Alias'), lambda: self.w_view.edit(i))
menu.addSeparator()
menu.addAction(_('Details'),
lambda: Dip3MNInfoDialog(self, alias=a).show())
menu.exec_(self.w_view.viewport().mapToGlobal(position))
@pyqtSlot()
def on_update_collateral(self):
mn = self.manager.mns.get(self.w_cur_alias)
removed = (self.w_cur_state == WalletMNsModel.STATE_REMOVED)
if not mn or not mn.is_owned or not mn.protx_hash or not removed:
return
start_id = Dip3MasternodeWizard.COLLATERAL_PAGE
wiz = Dip3MasternodeWizard(self, mn=mn, start_id=start_id)
wiz.open()
@pyqtSlot()
def on_update_params(self):
mn = self.manager.mns.get(self.w_cur_alias)
if not mn or mn.protx_hash:
return
if mn.is_owned:
start_id = Dip3MasternodeWizard.COLLATERAL_PAGE
else:
start_id = Dip3MasternodeWizard.SERVICE_PAGE
wiz = Dip3MasternodeWizard(self, mn=mn, start_id=start_id)
wiz.open()
@pyqtSlot()
def on_make_pro_reg_tx(self):
try:
pro_reg_tx = self.manager.prepare_pro_reg_tx(self.w_cur_alias)
except ProRegTxExc as e:
self.gui.show_error(e)
return
self.gui.payto_e.setText(self.wallet.get_unused_address())
self.gui.extra_payload.set_extra_data(SPEC_PRO_REG_TX, pro_reg_tx)
self.gui.show_extra_payload()
self.gui.tabs.setCurrentIndex(self.gui.tabs.indexOf(self.gui.send_tab))
@pyqtSlot()
def on_file(self):
wiz = Dip3FileWizard(self)
wiz.open()
@pyqtSlot()
def on_add_masternode(self):
wiz = Dip3MasternodeWizard(self)
wiz.open()
@pyqtSlot()
def on_make_pro_up_srv_tx(self):
mn = self.manager.mns.get(self.w_cur_alias)
if not mn or not mn.protx_hash:
return
wiz = Dip3MasternodeWizard(self,
mn=mn,
start_id=Dip3MasternodeWizard.UPD_SRV_PAGE)
wiz.open()
@pyqtSlot()
def on_make_pro_up_reg_tx(self):
mn = self.manager.mns.get(self.w_cur_alias)
if not mn or not mn.protx_hash:
return
wiz = Dip3MasternodeWizard(self,
mn=mn,
start_id=Dip3MasternodeWizard.UPD_REG_PAGE)
wiz.open()
@pyqtSlot()
def on_del_masternode(self):
alias = self.w_cur_alias
mn = self.manager.mns.get(alias)
if not mn:
return
if not self.gui.question(
_('Do you want to remove the masternode '
'configuration for %s?') % alias):
return
if mn.protx_hash:
if not self.gui.question(
_('Masternode %s has RroRegTxHash '
'already set. Are you sure?') % alias):
return
self.manager.remove_mn(self.w_cur_alias)
self.w_model.reload_data()
@pyqtSlot()
def on_reg_selection_changed(self):
sel = self.reg_view.selectionModel()
if sel.hasSelection():
idx = sel.selectedRows()[0]
self.reg_cur_protx = idx.data()
else:
self.reg_cur_protx = ''
@pyqtSlot()
def on_wallet_model_reset(self):
self.update_wallet_label()
self.w_file_btn.show()
self.w_add_btn.show()
self.w_up_params_btn.hide()
self.w_up_coll_btn.hide()
self.w_protx_btn.hide()
self.w_up_srv_btn.hide()
self.w_up_reg_btn.hide()
self.w_del_btn.hide()
@pyqtSlot()
def on_wallet_selection_changed(self):
sel = self.w_view.selectionModel()
if not sel.hasSelection():
self.w_cur_alias = ''
self.w_cur_state = ''
self.w_cur_idx = None
self.w_add_btn.show()
self.w_file_btn.show()
self.w_protx_btn.hide()
self.w_del_btn.hide()
self.w_up_params_btn.hide()
self.w_up_coll_btn.hide()
self.w_up_srv_btn.hide()
self.w_up_reg_btn.hide()
return
self.w_add_btn.hide()
self.w_file_btn.hide()
idx = sel.selectedRows()[0]
self.w_cur_alias = idx.data()
self.w_cur_state = idx.sibling(idx.row(), 1).data(Qt.ToolTipRole)
self.w_cur_idx = idx
mn = self.manager.mns.get(self.w_cur_alias)
owned = mn.is_owned
operated = mn.is_operated
protx_hash = mn.protx_hash
removed = (self.w_cur_state == WalletMNsModel.STATE_REMOVED)
self.w_del_btn.show()
if not protx_hash:
self.w_up_params_btn.show()
else:
self.w_up_params_btn.hide()
if removed and owned:
self.w_up_coll_btn.show()
else:
self.w_up_coll_btn.hide()
if owned and not protx_hash:
self.w_protx_btn.show()
else:
self.w_protx_btn.hide()
if operated and protx_hash and not removed:
self.w_up_srv_btn.show()
else:
self.w_up_srv_btn.hide()
if owned and protx_hash and not removed:
self.w_up_reg_btn.show()
else:
self.w_up_reg_btn.hide()
@pyqtSlot(QModelIndex)
def reg_mn_dbl_clicked(self, idx):
row_idx = idx.sibling(idx.row(), 0)
d = Dip3MNInfoDialog(self, protx_hash=row_idx.data())
d.show()
@pyqtSlot(QModelIndex)
def w_mn_dbl_clicked(self, idx):
col = idx.column()
if col == WalletMNsModel.ALIAS:
return
row_idx = idx.sibling(idx.row(), 0)
d = Dip3MNInfoDialog(self, alias=row_idx.data())
d.show()
@pyqtSlot(QModelIndex)
def w_data_changed(self, idx):
sel_model = self.w_view.selectionModel()
sel_model.clear()
sel_model.setCurrentIndex(
idx, QItemSelectionModel.ClearAndSelect | QItemSelectionModel.Rows)
sel_model.select(
idx, QItemSelectionModel.ClearAndSelect | QItemSelectionModel.Rows)
def restoreHeader(widget: QHeaderView, key: str) -> None:
key += "Header"
if aqt.mw.pm.profile.get(key):
widget.restoreState(aqt.mw.pm.profile[key])
