def __init__(self, parent = None):
QTableWidget.__init__(self, parent)
# init
# ------------------------------------------------
#FIXME: move this somewhere else maybe?
self.tmpSelectedItems = []
#FIXME: what does this do? put a comment, why 30,30?
self._sigmaList = None
self._featureGroupMapping = None # Schema: [ (groupName1, [entry, entry...]),
# (groupName2, [entry, entry...]) ]
#layout
# ------------------------------------------------
self.setCornerButtonEnabled(False)
self.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.setSelectionMode(QAbstractItemView.NoSelection)
self.setShowGrid(False)
self.viewport().installEventFilter(self)
self.setMouseTracking(1)
self.verticalHeader().setHighlightSections(False)
self.verticalHeader().setSectionsClickable(True)
self.horizontalHeader().setHighlightSections(False)
self.horizontalHeader().setSectionsClickable(True)
self.horizontalHeader().setMouseTracking(True)
self.horizontalHeader().installEventFilter(self)
self.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
self.verticalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
self.itemSelectionChanged.connect(self._tableItemSelectionChanged)
self.cellDoubleClicked.connect(self._featureTableItemDoubleClicked)
self.verticalHeader().sectionClicked.connect(self._expandOrCollapseVHeader)
def __init__(self, parent, configuration):
QTableWidget.__init__(self, 5, 1, parent)
self._configuration = configuration
self._manual_change = True
self.setVerticalHeaderLabels(
["Duration (cycles)", "Duration (ms)", "Cycles / ms",
'RAM access time', 'Execution Time Model'])
self.horizontalHeader().setStretchLastSection(True)
self.horizontalHeader().hide()
self.setItem(0, 0, QTableWidgetItem(str(configuration.duration)))
self.setItem(1, 0, QTableWidgetItem(str(
float(configuration.duration) / configuration.cycles_per_ms)))
self.setItem(2, 0, QTableWidgetItem(str(configuration.cycles_per_ms)))
self.setItem(
3, 0, QTableWidgetItem(str(configuration.memory_access_time)))
item = QComboBox(self)
selected = 0
for i, (etm_name, etm_code) in \
enumerate(execution_time_model_names.items()):
item.addItem(etm_name)
if etm_code == configuration.etm:
selected = i
item.setCurrentIndex(selected)
self.setCellWidget(4, 0, item)
def activation_handler(x):
configuration.etm = execution_time_model_names[str(x)]
configuration.conf_changed()
item.activated['QString'].connect(activation_handler)
# self._update_observe_window()
self.cellChanged.connect(self._cell_changed)
def __init__(self, parent=None, featureGroups=[], sigmas=[], computeIn2d=[], window_size=3.5):
"""
Args:
featureGroups: A list with schema: [ (groupName1, [entry, entry...]),
(groupName2, [entry, entry...]), ... ]
sigmas: List of sigmas (applies to all features)
computeIn2d: List of booleans to indicate which sigma column should be computed in 2d (rather than 3d)
"""
QTableWidget.__init__(self, parent)
self.setCornerButtonEnabled(False)
self.setEditTriggers(QAbstractItemView.AllEditTriggers)
self.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.setShowGrid(False)
self.setMouseTracking(1)
self.verticalHeader().setHighlightSections(False)
self.verticalHeader().setSectionsClickable(True)
self.verticalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
self.verticalHeader().sectionPressed.disconnect()
self.verticalHeader().sectionClicked.connect(self._expandOrCollapseVHeader)
self.horizontalHeader().setHighlightSections(False)
self.horizontalHeader().setSectionsClickable(False)
# self.horizontalHeader().installEventFilter(self)
self.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
self.itemSelectionChanged.connect(self._itemSelectionChanged)
self.cellChanged.connect(self._cellChanged)
if featureGroups or sigmas or computeIn2d:
self.setup(featureGroups, sigmas, computeIn2d, window_size)
def keyPressEvent(self, event):
QTableWidget.keyPressEvent(self, event)
if event.key() == Qt.Key_Delete:
self.remove_selected_tasks()
if(event.key() == Qt.Key_C and event.modifiers() & Qt.ControlModifier):
indexes = self.selectionModel().selectedIndexes()
# TODO: mettre dans un format xml.
print("copy : ", indexes)
def __init__(self, parent, result):
QTableWidget.__init__(self, len(result.model.logs), 3, parent=parent)
self.setWindowTitle("Logs")
self.setHorizontalHeaderLabels(["Date (cycles)", "Date (ms)", "Message"])
self.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
self.horizontalHeader().setStretchLastSection(True)
self.horizontalHeader().setMinimumSectionSize(60)
self.verticalHeader().hide()
self._sim = result.model
self.result = result
self.update()
def __init__(self, parent, result):
QTableWidget.__init__(
self, len(result.model.processors) + 1, 3, parent)
self.result = result
self.setHorizontalHeaderLabels(["Total load", "Payload",
"System load", "Theoric min"])
self.setVerticalHeaderLabels(
[x.name for x in result.model.processors] + ["Average"])
self.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.update()
class Table(QWidget):
def __init__(self):
super().__init__()
self.lay = QHBoxLayout(self)
self.tableWidget = QTableWidget(self)
self.lay.addWidget(self.tableWidget)
for i in range(20):
self.tableWidget.insertRow(i)
self.tableWidget.insertColumn(i)
def group_tasks_list(self):
"""Define the Tasks Group arrangement."""
gb_tasks = QGroupBox(self.central_widget)
gb_tasks.setTitle(self.tr('List of Conversion Tasks'))
sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(gb_tasks.sizePolicy().hasHeightForWidth())
gb_tasks.setSizePolicy(sizePolicy)
hl = QHBoxLayout(gb_tasks)
self.tb_tasks = QTableWidget(gb_tasks)
self.tb_tasks.setColumnCount(4)
self.tb_tasks.setRowCount(0)
self.tb_tasks.setSelectionMode(QAbstractItemView.SingleSelection)
self.tb_tasks.setSelectionBehavior(QAbstractItemView.SelectRows)
self.tb_tasks.horizontalHeader().setSectionResizeMode(
0, QHeaderView.Stretch)
self.tb_tasks.setHorizontalHeaderLabels(
[self.tr('File Name'),
self.tr('Duration'),
self.tr('Target Quality'),
self.tr('Progress')])
self.tb_tasks.cellClicked.connect(self._enable_remove_file_action)
# Create a combo box for Target quality
self.tb_tasks.setItemDelegate(TargetQualityDelegate(parent=self))
hl.addWidget(self.tb_tasks)
self.vl2.addWidget(gb_tasks)
self.tb_tasks.doubleClicked.connect(self.update_edit_triggers)
def __init__(self):
QWidget.__init__(self)
self.win_list=windows()
self.setFixedSize(900, 600)
self.setWindowIcon(QIcon(os.path.join(get_image_file_path(),"doping.png")))
self.setWindowTitle(_("Doping profile editor (www.gpvdm.com)"))
self.win_list.set_window(self,"doping")
self.main_vbox=QVBoxLayout()
toolbar=QToolBar()
toolbar.setIconSize(QSize(48, 48))
self.save = QAction(QIcon(os.path.join(get_image_file_path(),"save.png")), _("Save"), self)
self.save.triggered.connect(self.callback_save)
toolbar.addAction(self.save)
spacer = QWidget()
spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
toolbar.addWidget(spacer)
self.help = QAction(QIcon(os.path.join(get_image_file_path(),"help.png")), _("Help"), self)
self.help.triggered.connect(self.callback_help)
toolbar.addAction(self.help)
self.main_vbox.addWidget(toolbar)
self.fig = Figure(figsize=(5,4), dpi=100)
self.ax1=None
self.show_key=True
canvas = FigureCanvas(self.fig)
#canvas.set_background('white')
#canvas.set_facecolor('white')
canvas.figure.patch.set_facecolor('white')
canvas.show()
self.main_vbox.addWidget(canvas)
self.tab = QTableWidget()
self.tab.resizeColumnsToContents()
self.tab.verticalHeader().setVisible(False)
self.tab.clear()
self.tab.setColumnCount(4)
self.tab.setSelectionBehavior(QAbstractItemView.SelectRows)
self.load()
self.build_mesh()
self.tab.cellChanged.connect(self.tab_changed)
self.main_vbox.addWidget(self.tab)
self.draw_graph()
self.setLayout(self.main_vbox)
return
def __init__(self, rows, cols, parent = None):
super(SpreadSheet, self).__init__(parent)
self.toolBar = QToolBar()
self.addToolBar(self.toolBar)
self.formulaInput = QLineEdit()
self.cellLabel = QLabel(self.toolBar)
self.cellLabel.setMinimumSize(80, 0)
self.toolBar.addWidget(self.cellLabel)
self.toolBar.addWidget(self.formulaInput)
self.table = QTableWidget(rows, cols, self)
for c in range(cols):
character = chr(ord('A') + c)
self.table.setHorizontalHeaderItem(c, QTableWidgetItem(character))
self.table.setItemPrototype(self.table.item(rows - 1, cols - 1))
self.table.setItemDelegate(SpreadSheetDelegate(self))
self.createActions()
self.updateColor(0)
self.setupMenuBar()
self.setupContents()
self.setupContextMenu()
self.setCentralWidget(self.table)
self.statusBar()
self.table.currentItemChanged.connect(self.updateStatus)
self.table.currentItemChanged.connect(self.updateColor)
self.table.currentItemChanged.connect(self.updateLineEdit)
self.table.itemChanged.connect(self.updateStatus)
self.formulaInput.returnPressed.connect(self.returnPressed)
self.table.itemChanged.connect(self.updateLineEdit)
self.setWindowTitle("Spreadsheet")
def saveZotero(self):
#Write what happens to save to zotero here
rows = list(range(0, QTableWidget.rowCount(self.dlgTable.tableWidget_Zotero)))
for row in rows:
#get the itemID(zotero key) and geometry cells from the table - itemAt(x,y)
itemKey = self.dlgTable.tableWidget_Zotero.item(row, 0).text()
request_url = 'https://api.zotero.org/users/%s/items/%s' % (self.userID, itemKey)
item_request = requests.get(request_url)
QgsMessageLog.logMessage("Item Request Response: %s" % item_request.status_code, 'LiteratureMapper', Qgis.Info)
item_json = json.load(urllib.request.urlopen(request_url))
#Put the extra string back together with the new coordinates
tablegeom = self.dlgTable.tableWidget_Zotero.item(row, 4).text()
extraZotero = item_json['data']['extra']
before_geojson = extraZotero[0 : extraZotero.find("<geojson>")]
after_geojson = extraZotero[extraZotero.find("</geojson>")+10:]
extraString = '%s<geojson>%s</geojson>%s' % (before_geojson, tablegeom, after_geojson) #build the new extraString here
QgsMessageLog.logMessage("row: %s itemKey: %s extraString: %s" % (row, itemKey, extraString), 'LiteratureMapper', Qgis.Info)
####### saving Extra field
item_json['data']['extra'] = extraString
item_json=json.dumps(item_json)
put_request = requests.put(request_url, data=item_json, headers={'Authorization': 'Bearer %s' % (self.apiKey), 'Content-Type': 'application/json'})
QgsMessageLog.logMessage("Put Response: %s" % put_request.status_code, 'LiteratureMapper', Qgis.Info)
statuscode = put_request.status_code
# Message bar for result
# TODO: make it check all the results, not just the last one
if statuscode == 204:
self.iface.messageBar().pushMessage("Locations saved to Zotero.", level=4)
#QMessageBox.information(self.dlgTable(),"Info", "Locations Saved")
else:
self.iface.messageBar().pushMessage("Failed to save locations to Zotero", level=3)
def __init__(self, parent):
super(UserManagerWidget, self).__init__(parent)
self.parent = parent
self.sort_order = 'by_name'
view.notifier.observers.append(self)
self.header_label = QLabel('Users')
self.header_widget = QWidget(self)
header_layout = QBoxLayout(QBoxLayout.LeftToRight)
header_layout.addWidget(self.header_label)
self.header_widget.setLayout(header_layout)
self.sort_by_name_btn = QPushButton('Sort by Name', self)
self.sort_by_name_btn.clicked.connect(self.sort_by_name)
self.sort_by_rank_btn = QPushButton('Sort by Rank', self)
self.sort_by_rank_btn.clicked.connect(self.sort_by_rank)
self.sort_btns_widget = QWidget(self)
sort_btns_layout = QBoxLayout(QBoxLayout.LeftToRight)
sort_btns_layout.addWidget(self.sort_by_name_btn)
sort_btns_layout.addSpacing(10)
sort_btns_layout.addWidget(self.sort_by_rank_btn)
self.sort_btns_widget.setLayout(sort_btns_layout)
self.user_list = QTableWidget(style.style_loader.TABLE_INITIAL_LENGTH, 3, self)
self.user_list.setFixedHeight(300)
self.user_list.setFixedWidth(400)
self.user_list.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self.user_list.verticalHeader().setSectionResizeMode(QHeaderView.Fixed)
self.user_list_widget = QWidget(self)
user_list_layout = QBoxLayout(QBoxLayout.LeftToRight)
user_list_layout.addWidget(self.user_list)
self.user_list_widget.setLayout(user_list_layout)
self.add_player_btn = QPushButton('Add User', self)
self.add_player_btn.clicked.connect(self.parent.show_add_user_widget)
self.remove_player_btn = QPushButton('Remove User', self)
self.remove_player_btn.clicked.connect(self.parent.show_remove_user_widget)
self.player_btns_widget = QWidget(self)
player_btn_layout = QBoxLayout(QBoxLayout.LeftToRight)
player_btn_layout.addWidget(self.add_player_btn)
player_btn_layout.addSpacing(10)
player_btn_layout.addWidget(self.remove_player_btn)
self.player_btns_widget.setLayout(player_btn_layout)
self.error = None
layout = QFormLayout()
layout.addRow(self.header_widget)
layout.addRow(self.sort_btns_widget)
layout.addRow(self.user_list_widget)
layout.addRow(self.player_btns_widget)
self.setLayout(layout)
self.update()
def __init__(self):
super().__init__()
# Create a table
self.tableWidget = QTableWidget()
self.tableWidget.setRowCount(4)
self.tableWidget.setColumnCount(2)
# Add data
self.tableWidget.setItem(0, 0, QTableWidgetItem("Cell (1,1)"))
self.tableWidget.setItem(0, 1, QTableWidgetItem("Cell (1,2)"))
self.tableWidget.setItem(1, 0, QTableWidgetItem("Cell (2,1)"))
self.tableWidget.setItem(1, 1, QTableWidgetItem("Cell (2,2)"))
self.tableWidget.setItem(2, 0, QTableWidgetItem("Cell (3,1)"))
self.tableWidget.setItem(2, 1, QTableWidgetItem("Cell (3,2)"))
self.tableWidget.setItem(3, 0, QTableWidgetItem("Cell (4,1)"))
self.tableWidget.setItem(3, 1, QTableWidgetItem("Cell (4,2)"))
# Table selection callback
self.tableWidget.doubleClicked.connect(self.on_click)
# Set the layout
layout = QVBoxLayout()
layout.addWidget(self.tableWidget)
self.setLayout(layout)
def __init__(self,index):
QWidget.__init__(self)
self.index=index
self.vbox=QVBoxLayout()
toolbar=QToolBar()
toolbar.setIconSize(QSize(48, 48))
self.tb_save = QAction(QIcon(os.path.join(get_image_file_path(),"add.png")), _("Add"), self)
self.tb_save.triggered.connect(self.callback_add_item)
toolbar.addAction(self.tb_save)
self.tb_save = QAction(QIcon(os.path.join(get_image_file_path(),"minus.png")), _("Minus"), self)
self.tb_save.triggered.connect(self.callback_delete_item)
toolbar.addAction(self.tb_save)
self.vbox.addWidget(toolbar)
self.tab = QTableWidget()
self.tab.resizeColumnsToContents()
self.tab.verticalHeader().setVisible(False)
self.create_model()
self.tab.cellChanged.connect(self.tab_changed)
self.vbox.addWidget(self.tab)
self.setLayout(self.vbox)
def __init__(self, settings, parent=None):
super(Form, self).__init__(parent)
icon = QtGui.QIcon(":/tcharmap.png")
self.setWindowIcon(icon)
self.settings = settings
self.results = []
self.entries = read_entries()
self.lineedit = VLineEdit()
self.lineedit.selectAll()
self.table = QTableWidget()
self.table.installEventFilter(self)
self.table.currentCellChanged[int, int, int, int].connect(self.copy_entry_slot)
layout = QVBoxLayout()
layout.addWidget(self.table)
layout.addWidget(self.lineedit)
self.setLayout(layout)
self.lineedit.textChanged[str].connect(self.update_query)
self.lineedit.setFocus()
self.setWindowTitle("tcharmap")
self.results = self.lookup("")
self.table.setColumnCount(3)
self.table.horizontalHeader().setStretchLastSection(True)
self.table.verticalHeader().setVisible(False)
self.table.horizontalHeader().setVisible(False)
self.table.setColumnWidth(1, 150)
self.clipboard = QApplication.clipboard()
self.resize(540, 530)
self.update_ui()
def __init__(self, parent, grammar):
super(QDialog, self).__init__(parent)
self.setModal(True)
self.setWindowTitle('LL(1) Parsing Table')
self.resize(640, 480)
layout = QVBoxLayout(self)
self.table = QTableWidget()
def build_table():
parse = build_parse_table(grammar)
states = [grammar.initial_symbol] + sorted(grammar.nonterminals - {grammar.initial_symbol})
symbols = sorted(grammar.terminals) + ['$']
self.table.setRowCount(len(states))
self.table.setColumnCount(len(symbols) + 1)
self.table.setHorizontalHeaderLabels(['NT'] + symbols)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
for row, state in enumerate(states):
self.table.setItem(row, 0, QTableWidgetItem(state))
for (state, symbol) in parse:
self.table.setItem(states.index(state),
symbols.index(symbol) + 1,
QTableWidgetItem(f'{parse[(state, symbol)]}'))
build_table()
layout.addWidget(self.table)
def initUI(self):
self.setWindowTitle("QTableWidget 例子")
self.resize(500,300);
conLayout = QHBoxLayout()
self.tableWidget= QTableWidget()
self.tableWidget.setRowCount(5)
self.tableWidget.setColumnCount(3)
conLayout.addWidget(self.tableWidget )
self.tableWidget.setHorizontalHeaderLabels(['姓名','性别','体重' ])
self.tableWidget.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
newItem = QTableWidgetItem("张三")
self.tableWidget.setItem(0, 0, newItem)
newItem = QTableWidgetItem("男")
self.tableWidget.setItem(0, 1, newItem)
newItem = QTableWidgetItem("160")
self.tableWidget.setItem(0, 2, newItem)
#表格中第二行记录
newItem = QTableWidgetItem("李四")
self.tableWidget.setItem(1, 0, newItem)
newItem = QTableWidgetItem("女")
self.tableWidget.setItem(1, 1, newItem)
newItem = QTableWidgetItem("170")
self.tableWidget.setItem(1, 2, newItem)
self.tableWidget.setContextMenuPolicy(Qt.CustomContextMenu)######允许右键产生子菜单
self.tableWidget.customContextMenuRequested.connect(self.generateMenu) ####右键菜单
self.setLayout(conLayout)
def __init__(self, parent, steps):
super(ParseStepViewer, self).__init__(parent)
self.setModal(True)
self.setWindowTitle('Parse steps view.')
self.resize(640, 480)
layout = QVBoxLayout(self)
self.table = QTableWidget()
self.table.setColumnCount(2)
self.table.setRowCount(len(steps))
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.table.setSizeAdjustPolicy(QAbstractScrollArea.AdjustToContents)
self.table.setHorizontalHeaderLabels(['Stack', 'Input'])
for row, (right, left) in enumerate(steps):
self.table.setItem(row, 0, QTableWidgetItem('$' + ''.join(left)))
self.table.setItem(row, 1, QTableWidgetItem(''.join(right) + '$'))
self.table.resizeColumnsToContents()
ok_btn = QPushButton('&Close')
ok_btn.clicked.connect(self.close)
layout.addWidget(self.table)
layout.addWidget(ok_btn)
def __init__(self, gui):
super(AdvSetTab, self).__init__()
self._ui = gui
self._config = self._ui.config
self._tran = self._ui.tran
self._parser = self._ui.configparser
self.setObjectName("advtab")
# main layout of this tab
self._layout = QGridLayout(self)
self._layout.setObjectName('advtab_layout')
# setup the new button
self._button_new = QPushButton(self)
self._button_new.setObjectName('advtab_button_new')
self._button_new.setText(self._tran.get_text(self._button_new.objectName()))
self._button_new.clicked.connect(self._new_setting)
# setup the delete button
self._button_del = QPushButton(self)
self._button_del.setObjectName('advtab_button_delete')
self._button_del.setText(self._tran.get_text(self._button_del.objectName()))
self._button_del.clicked.connect(self._delete_setting)
# setup the delete all
self._button_del_all = QPushButton(self)
self._button_del_all.setObjectName('advtab_button_delete_all')
self._button_del_all.setText(self._tran.get_text(self._button_del_all.objectName()))
self._button_del_all.clicked.connect(self._delete_config)
# setup the reset all button
self._button_res_all = QPushButton(self)
self._button_res_all.setObjectName('advtab_button_reset_all')
self._button_res_all.setText(self._tran.get_text(self._button_res_all.objectName()))
self._button_res_all.clicked.connect(self._reset_config)
# setup the option table
self._table = QTableWidget(0, 2)
self._table.setObjectName('advtab_table')
self._table.setHorizontalHeaderLabels([self._tran.get_text('option'), self._tran.get_text('value')])
self._table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
self._table.setSelectionBehavior(QAbstractItemView.SelectRows)
self._table.setSelectionMode(QAbstractItemView.SingleSelection)
self._table.setShowGrid(False)
self._table.setGeometry(0, 0, 800, 400)
self._table.itemChanged.connect(self._changed_setting)
# add the elements to the top level layout of the tab
self._layout.addWidget(self._button_new, 0, 0, 1, 1)
self._layout.addWidget(self._button_del, 0, 1, 1, 1)
self._layout.addWidget(self._button_del_all, 0, 2, 1, 1)
self._layout.addWidget(self._button_res_all, 0, 3, 1, 1)
self._layout.addWidget(self._table, 1, 0, 4, 4)
# set the array with all elements that have tooltips
self._tooltips = [
self._button_new, self._button_del,
self._button_del_all, self._button_res_all,
]
def initUI(self):
self.setGeometry(200,200,600,280)
self.setWindowTitle('Tag Indexer: List')
self.tab = QTableWidget(self)
self.tab.showGrid = False
self.tab.horizontalHeader().setSectionResizeMode(1)
self.tab.setColumnCount(3)
self.tab.cellChanged.connect(self.getMod)
lblRecherche = QLabel('Recherche: ', self)
btnRecherche = QPushButton('Rechercher', self)
btnRecherche.clicked.connect(self.rechercher)
self.recherche = QLineEdit()
self.recherche.returnPressed.connect(self.rechercher)
grid = QGridLayout()
grid.setSpacing(10)
grid.addWidget(lblRecherche, 0,0)
grid.addWidget(btnRecherche, 0, 8)
grid.addWidget(self.recherche, 0, 1, 1, 7)
grid.addWidget(self.tab,4,0, 6,9)
self.tab.setHorizontalHeaderLabels(('URL','Tags','Date d\'ajout'))
self.setLayout(grid)
self.controller.notify(GetAllEvent())
def __init__(self, parent, accountman):
QDialog.__init__(self, parent)
self.accountman = accountman
layout = QVBoxLayout()
self.setWindowTitle('Select Account')
# Create list
self.table = QTableWidget()
self.table.horizontalHeader().setHighlightSections(False)
self.table.setSelectionMode(QAbstractItemView.SingleSelection)
self.table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.table.verticalHeader().hide()
self.table.setGridStyle(QtCore.Qt.NoPen)
self.table.doubleClicked.connect(self.select)
bottom_layout = QHBoxLayout()
self.remember_chk = QCheckBox('Remember')
cancel_btn = QPushButton('Cancel')
cancel_btn.clicked.connect(self.cancel)
add_btn = QPushButton('Add')
add_btn.clicked.connect(self.add)
self.edit_btns = QComboBox()
self.edit_btns.blockSignals(True)
self.edit_btns.addItem('Edit...')
self.edit_btns.addItem('Update')
self.edit_btns.addItem('Delete')
self.edit_btns.addItem('Purge')
self.edit_btns.setItemData(1, 'Change the local password/PIN for this account', QtCore.Qt.ToolTipRole)
self.edit_btns.setItemData(2, 'Remove this account from Trackma', QtCore.Qt.ToolTipRole)
self.edit_btns.setItemData(3, 'Clear local DB for this account', QtCore.Qt.ToolTipRole)
self.edit_btns.setCurrentIndex(0)
self.edit_btns.blockSignals(False)
self.edit_btns.activated.connect(self.s_edit)
select_btn = QPushButton('Select')
select_btn.clicked.connect(self.select)
select_btn.setDefault(True)
bottom_layout.addWidget(self.remember_chk)
bottom_layout.addWidget(cancel_btn)
bottom_layout.addWidget(add_btn)
bottom_layout.addWidget(self.edit_btns)
bottom_layout.addWidget(select_btn)
# Get icons
self.icons = dict()
for libname, lib in utils.available_libs.items():
self.icons[libname] = QtGui.QIcon(lib[1])
# Populate list
self.update()
self.rebuild()
# Finish layout
layout.addWidget(self.table)
layout.addLayout(bottom_layout)
self.setLayout(layout)
def init(self):
self.fig = Figure(figsize=(5, 4), dpi=100)
self.canvas = FigureCanvas(self.fig)
self.canvas.figure.patch.set_facecolor("white")
self.main_vbox = QVBoxLayout()
toolbar = QToolBar()
toolbar.setIconSize(QSize(48, 48))
self.tb_save = QAction(QIcon(os.path.join(get_image_file_path(), "32_save.png")), _("Save image"), self)
self.tb_save.triggered.connect(self.callback_save)
toolbar.addAction(self.tb_save)
self.tb_ref = QAction(
QIcon(os.path.join(get_image_file_path(), "32_ref.png")), _("Insert reference information"), self
)
self.tb_ref.triggered.connect(self.callback_ref)
toolbar.addAction(self.tb_ref)
self.main_vbox.addWidget(toolbar)
self.main_vbox.addWidget(self.canvas)
# toolbar 2
toolbar2 = QToolBar()
toolbar2.setIconSize(QSize(48, 48))
self.tb_add = QAction(QIcon(os.path.join(get_image_file_path(), "add.png")), _("Add section"), self)
self.tb_add.triggered.connect(self.callback_add_section)
toolbar2.addAction(self.tb_add)
self.tb_remove = QAction(QIcon(os.path.join(get_image_file_path(), "minus.png")), _("Delete section"), self)
self.tb_remove.triggered.connect(self.callback_remove_item)
toolbar2.addAction(self.tb_remove)
self.tb_move = QAction(QIcon(os.path.join(get_image_file_path(), "down.png")), _("Move down"), self)
self.tb_move.triggered.connect(self.callback_move_down)
toolbar2.addAction(self.tb_move)
self.main_vbox.addWidget(toolbar2)
self.tab = QTableWidget()
self.tab.resizeColumnsToContents()
self.tab.verticalHeader().setVisible(False)
self.main_vbox.addWidget(self.tab)
self.setLayout(self.main_vbox)
self.load_data()
self.build_mesh()
self.draw_graph()
self.tab.cellChanged.connect(self.on_cell_edited)
def __init__(self, title, numVar, numCons, typeVar, objCrit, parent=None):
super(InputTableModel, self).__init__(parent)
self.problem = None
self.problemTitle = title
self.numVariables = numVar
self.numConstraints = numCons
self.objCriterion = objCrit
self.typeVariable = typeVar
self.tableModel = QTableWidget(self.numConstraints+1, self.numVariables+2)
self.tableModel.setItemDelegate(Delegate(self))
listVariables = []
for m in range(self.numVariables):
listVariables.append("X"+str(m))
listVariables.extend(["Direction","R.H.S"])
#Generar Filas
listConstraints = ["Objetive"]
for m in range(self.numConstraints):
listConstraints.append("C"+str(m))
combo = QComboBox()
combo.addItem('<')
combo.addItem('<=')
combo.addItem('=')
combo.addItem('>=')
combo.addItem('>')
self.tableModel.setCellWidget(m+1, self.numVariables, combo)
#listConstraints.extend(["LowerBound","UpperBound", "VariableType"])
self.tableModel.setCellWidget(0, self.numVariables, QLabel(""))
self.tableModel.setHorizontalHeaderLabels(listVariables)
self.tableModel.setVerticalHeaderLabels(listConstraints)
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
buttonBox.accepted.connect(self.verify)
buttonBox.rejected.connect(self.reject)
f = "Problem Title: "
if self.objCriterion == True:
f = f + self.problemTitle + " - Objetive: Maximitation"
else:
f = f + self.problemTitle + " - Objetive: Minimization"
t = QLabel(f)
mainLayout = QVBoxLayout()
mainLayout.addWidget(t)
mainLayout.addWidget(self.tableModel)
mainLayout.addWidget(buttonBox)
width = self.tableModel.columnWidth(1)*(self.tableModel.columnCount()+1)
height = self.tableModel.rowHeight(0)*(self.tableModel.rowCount()+4)
self.resize(QSize(width, height))
self.setWindowTitle("Input Problem Model")
self.setLayout(mainLayout)
def initUI(self):
btn1 = QPushButton("Player")
btn2 = QPushButton("Bank")
for btn in [btn1, btn2]:
btn.setMinimumWidth(100)
btn.setMinimumHeight(70)
self.lbl = QLabel('$0')
self.lbl.setFrameShape(QFrame.WinPanel)
self.lbl.setFrameShadow(QFrame.Sunken)
# self.lbl.setContentsMargins(15, 15, 15, 15)
self.lbl.setMinimumHeight(30)
self.lbl.setMinimumWidth(100)
self.lbl.setStyleSheet("""
.QLabel {
color: red
}
""")
lbl2 = QLabel('Bet: ')
hlabels = ['partner', 'level', 'index', 'play', 'bet', 'result', 'net']
vlabels = [gambler.name for gambler in self.game.gamblers]
self.tbl = QTableWidget(len(vlabels), len(hlabels))
self.tbl.setHorizontalHeaderLabels(hlabels)
self.tbl.setVerticalHeaderLabels(vlabels)
lbl_box = QHBoxLayout()
lbl_box.addWidget(lbl2)
lbl_box.addWidget(self.lbl)
lbl_box.addStretch(1)
# lbl_box.setContentsMargins(10, 10, 10, 10)
btn_box = QHBoxLayout()
btn_box.addWidget(btn1)
btn_box.addWidget(btn2)
btn_box.addLayout(lbl_box)
btn_box.addStretch(1)
tbl_box = QHBoxLayout()
tbl_box.addWidget(self.tbl)
layout = QVBoxLayout()
layout.addLayout(btn_box)
# layout.addLayout(lbl_box)
layout.addLayout(tbl_box)
layout.addStretch(1)
# tbl.resizeColumnsToContents()
# tbl.resizeRowsToContents()
btn1.clicked.connect(self.buttonClicked)
btn2.clicked.connect(self.buttonClicked)
self.setLayout(layout)
self.setGeometry(300, 300, 800, 400)
self.setWindowTitle('Event Sender')
self.show()
def setupItemsTable(self):
self.itemsTable = QTableWidget(len(self.items), 2)
for row, item in enumerate(self.items):
name = QTableWidgetItem(item)
name.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
self.itemsTable.setItem(row, 0, name)
quantity = QTableWidgetItem('1')
self.itemsTable.setItem(row, 1, quantity)
def __init__(self, parent, configuration, simulation_tab):
QTableWidget.__init__(self, 5, 2, parent)
self._header = ['Scheduler', 'Scheduler Path',
'Overhead schedule (cycles)',
'Overhead on activate (cycles)',
'Overhead on terminate (cycles)']
self._dict_header = {
'scheduler': 0,
'scheduler_path': 1,
'overhead_schedule': 2,
'overhead_activate': 3,
'overhead_terminate': 4
}
self._configuration = configuration
self._simulation_tab = simulation_tab
self.refresh_table()
self.cellChanged.connect(self._cell_changed)
self.cellActivated.connect(self._cell_activated)
def createFilesTable(self):
self.filesTable = QTableWidget(0, 2)
self.filesTable.setSelectionBehavior(QAbstractItemView.SelectRows)
self.filesTable.setHorizontalHeaderLabels(("File Name", "Size"))
self.filesTable.horizontalHeader().setSectionResizeMode(0, QHeaderView.Stretch)
self.filesTable.verticalHeader().hide()
self.filesTable.setShowGrid(False)
self.filesTable.cellActivated.connect(self.openFileOfItem)
def __init__(self, parent, configuration):
self._ignore_cell_changed = False
self._manual_change = True
self._configuration = configuration
self._caches_list = configuration.caches_list
QTableWidget.__init__(self, len(self._caches_list), 5, parent)
self.horizontalHeader().setStretchLastSection(True)
self.horizontalHeader().setSectionResizeMode(QHeaderView.ResizeToContents)
self.setHorizontalHeaderLabels(["id", "Name", "Size", 'Access Time',
"Miss penalty"])
self.setVerticalHeaderLabels([""])
self.verticalHeader().hide()
self.setSelectionBehavior(QAbstractItemView.SelectRows)
curRow = 0
for cache in self._caches_list:
self._add_cache_to_table(curRow, cache)
curRow += 1
self.cellChanged.connect(self._cell_changed)
def __init__(self, parent=None):
super(Example, self).__init__(parent)
QApplication.setStyle(QStyleFactory.create('Fusion'))
# -------------- QCOMBOBOX ----------------------
cbx = QComboBox()
# agregar lista de nombres de estilos disponibles
cbx.addItems(QStyleFactory.keys())
# responder al evento cambio de texto
cbx.currentTextChanged.connect(self.textChanged)
# seleccionar el ultimo elemento
cbx.setItemText(4, 'Fusion')
# -------------- QLISTWIDGET ---------------------
items = ['Ubuntu', 'Linux', 'Mac OS', 'Windows', 'Fedora', 'Chrome OS', 'Android', 'Windows Phone']
self.lv = QListWidget()
self.lv.addItems(items)
self.lv.itemSelectionChanged.connect(self.itemChanged)
# -------------- QTABLEWIDGET --------------------
self.table = QTableWidget(10, 3)
# establecer nombre de cabecera de las columnas
self.table.setHorizontalHeaderLabels(['Nombre', 'Edad', 'Nacionalidad'])
# evento producido cuando cambia el elemento seleccionado
self.table.itemSelectionChanged.connect(self.tableItemChanged)
# alternar color de fila
self.table.setAlternatingRowColors(True)
# seleccionar solo filas
self.table.setSelectionBehavior(QTableWidget.SelectRows)
# usar seleccion simple, una fila a la vez
self.table.setSelectionMode(QTableWidget.SingleSelection)
table_data = [
("Alice", 15, "Panama"),
("Dana", 25, "Chile"),
("Fernada", 18, "Ecuador")
]
# agregar cada uno de los elementos al QTableWidget
for i, (name, age, city) in enumerate(table_data):
self.table.setItem(i, 0, QTableWidgetItem(name))
self.table.setItem(i, 1, QTableWidgetItem(str(age)))
self.table.setItem(i, 2, QTableWidgetItem(city))
vbx = QVBoxLayout()
vbx.addWidget(QPushButton('Tutoriales PyQT-5'))
vbx.setAlignment(Qt.AlignTop)
vbx.addWidget(cbx)
vbx.addWidget(self.lv)
vbx.addWidget(self.table)
self.setWindowTitle("Items View")
self.resize(362, 320)
self.setLayout(vbx)
def __init__(self):
QWidget.__init__(self)
self.rebuild_mat_list()
self.doping_window=False
self.cost_window=False
self.optics_window=False
self.main_vbox=QVBoxLayout()
self.toolbar=QToolBar()
self.toolbar.setIconSize(QSize(32, 32))
self.tb_add = QAction(QIcon(os.path.join(get_image_file_path(),"add.png")), _("Add device layer"), self)
self.tb_add.triggered.connect(self.on_add_item_clicked)
self.toolbar.addAction(self.tb_add)
self.tb_remove = QAction(QIcon(os.path.join(get_image_file_path(),"minus.png")), _("Delete device layer"), self)
self.tb_remove.triggered.connect(self.on_remove_item_clicked)
self.toolbar.addAction(self.tb_remove)
self.tb_remove= QAction(QIcon(os.path.join(get_image_file_path(),"down.png")), _("Move device layer"), self)
self.tb_remove.triggered.connect(self.on_move_down)
self.toolbar.addAction(self.tb_remove)
self.tb_doping = QAction(QIcon(os.path.join(get_image_file_path(),"doping.png")), _("Doping"), self)
self.tb_doping.triggered.connect(self.callback_doping)
self.toolbar.addAction(self.tb_doping)
self.optics_button = QAction(QIcon(os.path.join(get_image_file_path(),"optics.png")), _("Optical simulation"), self)
self.optics_button.triggered.connect(self.callback_optics_sim)
self.toolbar.addAction(self.optics_button)
self.tb_open = QAction(QIcon(os.path.join(get_image_file_path(),"organic_material.png")), _("Look at the materials database"), self)
self.tb_open.triggered.connect(self.callback_view_materials)
self.toolbar.addAction(self.tb_open)
self.cost = QAction(QIcon(os.path.join(get_image_file_path(),"cost.png")), _("Calculate the cost of the solar cell"), self)
self.cost.triggered.connect(self.callback_cost)
self.toolbar.addAction(self.cost)
self.main_vbox.addWidget(self.toolbar)
self.tab = QTableWidget()
self.tab.resizeColumnsToContents()
self.tab.verticalHeader().setVisible(False)
self.create_model()
self.tab.cellChanged.connect(self.tab_changed)
self.main_vbox.addWidget(self.tab)
self.setLayout(self.main_vbox)
def initUI(self, data):
self.data = data
header, self.csv_data = head_tail(self.data.csv_data)
# display most recent csv_data at top
self.csv_data.reverse()
self.num_rows = len(self.csv_data)
self.num_cols = len(header)
# make table
self.table = QTableWidget(self.num_rows, self.num_cols)
# remove numbers from rows
self.table.verticalHeader().setVisible(False)
# set headers
self.table.setHorizontalHeaderLabels(header)
# put data in table
for row, data in enumerate(self.csv_data):
date, dur, act, rate = data.split(',')
item0 = QTableWidgetItem(date)
item1 = QTableWidgetItem(dur)
item2 = QTableWidgetItem(act)
item3 = QTableWidgetItem(rate)
self.table.setItem(row, 0, item0)
self.table.setItem(row, 1, item1)
self.table.setItem(row, 2, item2)
self.table.setItem(row, 3, item3)
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
buttonBox.accepted.connect(self.apply_changes)
buttonBox.rejected.connect(self.reject)
for i in range(self.num_rows):
self.table.setColumnWidth(i, 110)
# for some reason, self.table.width() returns a number larger than
# it should be
width = (self.num_cols + 0.1) * self.table.columnWidth(0)
# exaplin how this window works
# self.explain.setText() should be applied in the derived classes
self.explain = QLabel(wordWrap=True)
self.explain.setMinimumWidth(width)
self.explain.setText('')
self.layout = QVBoxLayout()
self.layout.addWidget(self.explain)
self.layout.addWidget(self.table)
self.layout.addWidget(buttonBox)
self.resize(width, 400)
self.setLayout(self.layout)
self.setWindowTitle('Table dialog')
class DropSiteWindow(QWidget):
def __init__(self):
super(DropSiteWindow, self).__init__()
self.abstractLabel = QLabel(
"This example accepts drags from other applications and "
"displays the MIME types provided by the drag object.")
self.abstractLabel.setWordWrap(True)
self.abstractLabel.adjustSize()
self.dropArea = DropArea()
self.dropArea.changed.connect(self.updateFormatsTable)
self.formatsTable = QTableWidget()
self.formatsTable.setColumnCount(2)
self.formatsTable.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.formatsTable.setHorizontalHeaderLabels(["Format", "Content"])
self.formatsTable.horizontalHeader().setStretchLastSection(True)
self.clearButton = QPushButton("Clear")
self.quitButton = QPushButton("Quit")
self.buttonBox = QDialogButtonBox()
self.buttonBox.addButton(self.clearButton, QDialogButtonBox.ActionRole)
self.buttonBox.addButton(self.quitButton, QDialogButtonBox.RejectRole)
self.quitButton.pressed.connect(self.close)
self.clearButton.pressed.connect(self.dropArea.clear)
mainLayout = QVBoxLayout()
mainLayout.addWidget(self.abstractLabel)
mainLayout.addWidget(self.dropArea)
mainLayout.addWidget(self.formatsTable)
mainLayout.addWidget(self.buttonBox)
self.setLayout(mainLayout)
self.setWindowTitle("Drop Site")
self.setMinimumSize(350, 500)
def updateFormatsTable(self, mimeData=None):
self.formatsTable.setRowCount(0)
if mimeData is None:
return
for format in mimeData.formats():
formatItem = QTableWidgetItem(format)
formatItem.setFlags(Qt.ItemIsEnabled)
formatItem.setTextAlignment(Qt.AlignTop | Qt.AlignLeft)
if format == "text/plain":
text = mimeData.text().strip()
elif format == "text/html":
text = mimeData.html().strip()
elif format == "text/uri-list":
text = " ".join([url.toString() for url in mimeData.urls()])
else:
text = " ".join(
["%02X" % ord(datum) for datum in mimeData.data(format)])
row = self.formatsTable.rowCount()
self.formatsTable.insertRow(row)
self.formatsTable.setItem(row, 0, QTableWidgetItem(format))
self.formatsTable.setItem(row, 1, QTableWidgetItem(text))
self.formatsTable.resizeColumnToContents(0)
def setupUi(self, MainWindow):
resolution = QDesktopWidget().screenGeometry(self)
print("resol : ", resolution.size())
MainWindow.resize(resolution.size()) #1200 800
#메인 화면 색상py
self.setStyleSheet("color: black;" "background-color: white;")
font = QFont()
font.setFamily("NanumGothic")
MainWindow.setFont(font)
self.centralwidget = QWidget(MainWindow)
self.label = QLabel(self.centralwidget)
self.label.setGeometry(QRect(20, 20, 101, 31))
font = QFont()
font.setFamily("NanumGothic")
font.setPointSize(18)
font.setBold(True)
font.setWeight(75)
self.label.setFont(font)
self.button_add = QPushButton(self.centralwidget)
self.button_add.setGeometry(QRect(60, 730, 131, 34))
#버튼 스타일 변경
self.button_add.setStyleSheet(staticValues.blueButtonStyleSheet)
self.button_add.setFont(staticValues.buttonFont)
self.button_modi = QPushButton(self.centralwidget)
self.button_modi.setGeometry(QRect(260, 730, 131, 34))
self.button_modi.setStyleSheet(staticValues.blueButtonStyleSheet)
self.button_modi.setFont(staticValues.buttonFont)
self.button_del = QPushButton(self.centralwidget)
self.button_del.setGeometry(QRect(460, 730, 131, 34))
self.button_del.setStyleSheet(staticValues.redButtonStyleSheet)
self.button_del.setFont(staticValues.buttonFont)
self.button_upload = QPushButton(self.centralwidget)
self.button_upload.setGeometry(QRect(790, 730, 131, 34))
self.button_upload.setStyleSheet(staticValues.grayButtonStyleSheet)
self.button_upload.setFont(staticValues.buttonFont)
self.tabWidget = QTabWidget(self.centralwidget)
self.tabWidget.setGeometry(
QRect(40, 70,
resolution.size().height - 80, 621))
self.tab = QWidget()
self.tab.layout = QVBoxLayout()
self.tabWidget.addTab(self.tab, "회원 목록")
self.tableWidget = QTableWidget(self.tab)
self.tableWidget.setGeometry(
QRect(0, 0,
self.tabWidget.size().height - 100, self.tabWidget - 30))
self.tableWidget.setObjectName("회원 목록")
self.tableWidget.setColumnCount(13)
self.tableWidget.setRowCount(0)
self.tableWidget.setSelectionBehavior(QAbstractItemView.SelectRows)
self.tableWidget.setHorizontalHeaderLabels([
"회원 ID", "단톡방", "코인명", "구매", "입금", "판매", "출근", "보유잔량", "총구매금액",
"총판매금액", "수익", "평단가", "지갑주소"
])
MainWindow.setCentralWidget(self.centralwidget)
self.retranslateUi(MainWindow)
self.tabWidget.setCurrentIndex(0)
QMetaObject.connectSlotsByName(MainWindow)
class App(QWidget):
def __init__(self):
super().__init__()
self.button = QPushButton('Enter', self)
self.textbox = QLineEdit(self)
from PyQt5.QtWidgets import QLabel
self.barGraph = QWidget()
self.tableWidget = QTableWidget()
self.layout = QVBoxLayout()
self.title = 'Youtube Comment Section Analyzer'
self.message = 'Enter a youtube url below to begin analyzing the comment section'
self.left = 0
self.top = 0
self.width = 300
self.height = 200
self.initUI()
def initUI(self):
self.setWindowTitle(self.title)
self.setGeometry(self.left, self.top, self.width, self.height)
self.textBox()
self.layout.addWidget(self.tableWidget)
self.layout.addWidget(self.textbox)
self.layout.addWidget(self.button)
self.setLayout(self.layout)
# Show widget
self.show()
def textBox(self):
# textbox
self.textbox.move(20, 20)
# button
self.button.move(20, 80)
# to onClick
self.button.clicked.connect(self.onClick)
self.show()
@pyqtSlot()
def onClick(self):
textboxValue = self.textbox.text()
commonwordcount10, commonword10 = vid(textboxValue)
self.textbox.setText("")
self.createTable(commonwordcount10, commonword10)
self.createBarGraph(commonwordcount10,commonword10)
def createTable(self, commonwordcount10, commonword10):
# Create table
rowCount = 10
columnCount = 2
self.tableWidget.setRowCount(rowCount)
self.tableWidget.setColumnCount(columnCount)
i = 0
for word in commonword10:
self.tableWidget.setItem(i, 0, QTableWidgetItem(commonword10[i]))
self.tableWidget.setItem(i, 1, QTableWidgetItem(str(commonwordcount10[i])))
i += 1
self.tableWidget.move(0, 0)
def createBarGraph(self, commonwordcount10, commonword10):
xdict = dict(enumerate(commonwordcount10))
x = np.arange(10)
self.barGraph = pg.PlotWidget()
#self.layout.addWidget(self.barGraph)
win = pg.plot()
# properties
self.barGraph.setLabel('left', "Occurrence")
self.barGraph.setLabel('bottom', 'Word')
self.barGraph.setXRange(0, 10)
self.barGraph.setYRange(0, 50)
stringaxis = pg.AxisItem(orientation='bottom')
stringaxis.setTicks([xdict.items()])
self.barGraph = pg.BarGraphItem(x=list(xdict.keys()), height=commonwordcount10, width=0.6, brush='r')
win.addItem(self.barGraph)
self.setLayout(self.layout)
class ListBox(QMainWindow):
def __init__(self):
super(ListBox, self).__init__()
self.fileList = []
self.folderlist = []
self.allFolders = []
self.dir = QDir.homePath()
self.subdir = QDir.homePath()
self.setGeometry(0, 0, 800, 450)
self.setMinimumSize(500, 300)
self.setContentsMargins(10, 10, 10, 0)
self.setWindowIcon(QIcon.fromTheme('kfind'))
self.setWindowTitle("Find Files")
##toolbar######################################################
self.tb = self.addToolBar("Tools")
self.tb.setMovable(False)
self.tb.setContextMenuPolicy(Qt.PreventContextMenu)
self.findEdit = QLineEdit("*")
self.findAct = QAction(QIcon.fromTheme('edit-find'),
"find",
self,
statusTip="find Files",
triggered=self.findMyFiles)
self.findEdit.addAction(self.findAct, QLineEdit.LeadingPosition)
self.findEdit.setPlaceholderText("find")
self.findEdit.setToolTip("for example: *word*")
self.findEdit.setStatusTip("for example: *word*")
self.tb.addWidget(self.findEdit)
self.findEdit.returnPressed.connect(self.findMyFiles)
self.tb.addSeparator()
self.folderEdit = QLineEdit()
self.folderAct = QAction(QIcon.fromTheme('document-open'),
"change Folder",
self,
statusTip="change Folder",
triggered=self.changeFolder)
self.folderEdit.addAction(self.folderAct, QLineEdit.LeadingPosition)
self.folderEdit.setPlaceholderText("insert folder path")
self.folderEdit.setText(self.dir)
# self.folderEdit.textChanged.connect(self.setDir)
self.folderEdit.returnPressed.connect(self.findMyFiles)
self.tb.addWidget(self.folderEdit)
self.tb.addSeparator()
# self.addToolBarBreak()
self.noDot = QCheckBox("include hidden files")
# self.tb2 = self.addToolBar("hidden")
# self.tb2.addWidget(self.noDot)
##Listbox##########################################################
self.lb = QTableWidget()
self.lb.setSelectionBehavior(QAbstractItemView.SelectRows)
self.lb.setColumnCount(2)
self.lb.setColumnWidth(0, 300)
# self.lb.setSelectionBehavior(self.lb.SelectRows)
self.lb.setSelectionMode(self.lb.SingleSelection)
self.lb.cellDoubleClicked.connect(self.doubleClicked)
self.lb.itemClicked.connect(self.getItem)
self.lb.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.lb.horizontalHeader().setStretchLastSection(True)
self.lb.setAlternatingRowColors(True)
self.verticalHeader = QHeaderView(Qt.Vertical)
self.lb.setVerticalHeader(self.verticalHeader)
self.lb.horizontalHeader().setStretchLastSection(True)
self.lb.setHorizontalHeaderItem(0, QTableWidgetItem("Filename"))
self.lb.setHorizontalHeaderItem(1, QTableWidgetItem("Path"))
self.verticalHeader.setDefaultSectionSize(24)
self.lb.verticalHeader().hide()
self.lb.setToolTip(
"double click first column to open file\nsecond column to open file parent folder"
)
self.setCentralWidget(self.lb)
self.findEdit.setFocus()
self.statusBar().showMessage("Ready")
print("Welcome\nPython Version: " + sys.version[:5])
print("home is: " + home)
self.setStyleSheet(stylesheet(self))
self.copyBtn = QPushButton("copy filepath")
self.copyBtn.clicked.connect(self.copyPath)
self.copyBtn.setFlat(True)
self.statusBar().addPermanentWidget(self.copyBtn)
self.dir = self.folderEdit.text()
# self.show()
## def ####################################
def removeAllRows(self):
print("removing all rows")
for row in range(0, self.lb.rowCount()):
self.lb.removeRow(row)
def removeDuplicates(self):
for row in range(self.lb.rowCount()):
if self.lb.item(row, 1) == self.lb.item(row + 1, 1):
print("removing Row", str(row))
self.lb.removeRow(row)
def selectedRow(self):
if self.lb.selectionModel().hasSelection():
row = self.lb.selectionModel().selectedIndexes()[0].row()
return int(row)
def selectedColumn(self):
column = self.lb.selectionModel().selectedIndexes()[0].column()
return int(column)
def getItem(self):
row = self.selectedRow()
column = self.selectedColumn()
item = self.lb.item(row, column)
if column == 1:
myfile = item.text()
else:
myfile = self.lb.item(row, 1).text() + "/" + self.lb.item(
row, 0).text()
self.msg(myfile, 0)
def copyPath(self):
if self.lb.selectionModel().hasSelection():
row = self.selectedRow()
column = self.selectedColumn()
myfile = self.lb.item(row, 1).text() + "/" + self.lb.item(
row, 0).text()
clip = QApplication.clipboard()
clip.setText(myfile)
self.msg("filepath copied!", 0)
else:
self.msg("nothing selected!", 0)
def doubleClicked(self):
row = self.selectedRow()
column = self.selectedColumn()
item = self.lb.item(row, column)
if column == 1:
myfile = item.text()
else:
myfile = self.lb.item(row, 1).text() + "/" + self.lb.item(
row, 0).text()
if QFile.exists(myfile):
print("file exists: ", myfile)
QDesktopServices.openUrl(QUrl("file://" + myfile))
def setFolder(self):
self.dir = ""
self.folderEdit.setText(self.cmb.currentText())
if not self.findEdit.text() == "*":
self.setDir()
self.findMyFiles()
else:
message = "please type a word to find"
self.msg(message, 0)
self.msgbox(message)
def setDir(self):
self.dir = self.folderEdit.text()
def findMyFiles(self):
self.folderlist = []
self.allFolders = []
self.lb.clearContents()
self.dir = self.folderEdit.text()
if not self.findEdit.text() == "*":
self.lb.setRowCount(0)
self.findFiles(self.dir)
self.findFolders(self.dir)
self.findSufolders()
self.getFiles()
self.removeDuplicates()
if not self.lb.rowCount() == 0:
self.msg("found " + str(self.lb.rowCount()) + " Files", 0)
else:
self.msg("nothing found", 0)
else:
message = "please type a word to find"
self.msg(message, 0)
self.msgbox(message)
def findFolders(self, path):
fileName = "*"
currentDir = QDir(path)
if self.noDot.isChecked():
files = currentDir.entryList([fileName], QDir.AllDirs)
else:
files = currentDir.entryList([fileName],
QDir.AllDirs | QDir.NoDotAndDotDot)
for line in files:
self.folderlist.append(path + "/" + line)
def findSufolders(self):
for folders in self.folderlist:
self.allFolders.append(folders)
self.findNewFolders(folders)
def findNewFolders(self, path):
fileName = "*"
currentDir = QDir(path)
files = currentDir.entryList([fileName],
QDir.AllDirs | QDir.NoDotAndDotDot)
for line in files:
self.allFolders.append(path + "/" + line)
self.findNewFolders(path + "/" + line)
def findFiles(self, path):
findName = self.findEdit.text()
currentDir = QDir(path)
self.msg("searching in " + currentDir.path(), 0)
files = currentDir.entryList([findName], QDir.AllEntries | QDir.System
| QDir.Drives)
for line in files:
self.lb.insertRow(0)
self.lb.setItem(0, 0, QTableWidgetItem(line))
self.lb.setItem(0, 1, QTableWidgetItem(path)) # + "/" + line))
def getFiles(self):
for mf in self.allFolders:
self.findFiles(mf)
def changeFolder(self):
newfolder = QFileDialog.getExistingDirectory(self, "Find Files",
self.dir)
if newfolder:
self.folderEdit.setText(newfolder)
def closeEvent(self, event):
print("goodbye")
def msg(self, message, timeout):
self.statusBar().showMessage(message, timeout)
def msgbox(self, message):
QMessageBox.warning(self,
"'Find Files' Message",
message,
defaultButton=QMessageBox.Ok)
def iniciaComponentes(self):
self.setWindowTitle('Screble')
#Configuração do botão que adiciona as palavras
self.botaoAddWord = QPushButton('Add Word')
self.botaoAddWord.setToolTip('Botão para adicionar uma palavra')
self.botaoAddWord.clicked.connect(self.clickbotao_addWord)
#Configuração dos labels do player 1
self.label1 = QLabel('Player1:')
self.label1Pts = QLabel('0')
#Configuração dos labels do player 2
self.label2 = QLabel('Player2:')
self.label2Pts = QLabel('0')
#Configuração do identificador textual da coluna para adicionamento da palavra
self.editRow = QSpinBox()
self.editRow.setMinimum(1)
self.editRow.setMaximum(15)
self.labelRow = QLabel('Linha:')
#Configuração do identificador textual da coluna para adicionamento da palavra
self.editCol = QSpinBox()
self.editCol.setMinimum(1)
self.editCol.setMaximum(15)
self.labelCol = QLabel('Coluna:')
#Configuração dos edits que conterão a palavra a ser adicionada e a direção da mesma
self.comboDir = QComboBox()
self.comboDir.addItem("V")
self.comboDir.addItem("H")
self.labelDir = QLabel('Direção:')
self.editWord = QLineEdit('Palavra')
self.labelWord = QLabel('Palavra:')
#Configuração da matriz que contem as letras e bonus das palavras colocadas
self.tabela_matriz = QTableWidget()
self.tabela_matriz.setColumnCount(15)
self.tabela_matriz.setRowCount(15)
self.tabela_matriz.setShowGrid(True)
self.tabela_matriz.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.setaLetrasIniciais()
self.tabela_matriz.resizeColumnsToContents()
self.tabela_matriz.resizeRowsToContents()
#Configuração do label das letras disponíveis
self.labelDisponiveis = QLabel('Letras disponíveis:')
self.labelLetras = QLabel('')
#Configuração do edit que conterá as letras a serem trocadas
self.editTroca = QLineEdit('')
#Configuração do botão que troca as letras
self.botaoTrocaLetras = QPushButton('Troca letras')
self.botaoTrocaLetras.setToolTip('Botão para trocar suas letras')
self.botaoTrocaLetras.clicked.connect(self.clickbotao_trocaLetra)
#Configuração do botão de passar a vez
self.botaoPassaVez = QPushButton('Passar vez')
self.botaoPassaVez.setToolTip('Botão para passar sua rodada')
#self.botaoPassaVez.clicked.connect(self.clickbotao_passaVez)
#Configuração dos layouts
main_layout = QVBoxLayout()
# Header
layout = QHBoxLayout()
layout.addWidget(self.label1)
layout.addWidget(self.label1Pts)
layout.addStretch()
layout.addWidget(self.label2)
layout.addWidget(self.label2Pts)
main_layout.addLayout(layout)
# Main Vision
layout = QHBoxLayout()
layout.addWidget(self.tabela_matriz)
l = QVBoxLayout()
l.addWidget(self.labelDisponiveis)
l.addWidget(self.labelLetras)
l1 = QHBoxLayout()
l1.addWidget(self.editTroca)
l1.addWidget(self.botaoTrocaLetras)
l1.addWidget(self.botaoPassaVez)
l.addLayout(l1)
layout.addLayout(l)
main_layout.addLayout(layout)
# Footer
layout = QVBoxLayout()
l = QHBoxLayout()
l.addWidget(self.labelRow)
l.addWidget(self.editRow)
l.addWidget(self.labelCol)
l.addWidget(self.editCol)
l.addWidget(self.labelDir)
l.addWidget(self.comboDir)
l.addWidget(self.labelWord)
l.addWidget(self.editWord)
layout.addLayout(l)
layout.addWidget(self.botaoAddWord)
main_layout.addLayout(layout)
#Input do layout completo
self.setLayout(main_layout)
self.setGeometry(50, 50, 1220, 450)
class ScadaGui(QWidget):
def __init__(self, redirect_sys_out=True):
self.redirect_sys_out = redirect_sys_out
super(ScadaGui, self).__init__()
self.initUI()
def initUI(self):
# creating widgets
self._dgridPage = QWidget()
self._networkPage = QWidget()
# self._plotPage[0] = QWidget()
self._plotPage = {}
# create tabs
self._tabs = QTabWidget(self)
self._tabs.addTab(self._dgridPage, "dgrid")
self._tabs.addTab(self._networkPage, "network")
self._tabs.setTabsClosable(True)
self._tabs.tabCloseRequested[int].connect(self.tabClosedRequested)
# self._tabs.addTab(self._plotPage, "plots")
# create the network image display
self._networkDisp = QtSvg.QSvgWidget('IEEE_30BusDC.svg')
self._networkDisp.setMaximumSize(600, 500)
# create the table for the measurements
self._dgridValues = QTableWidget(10, 31, self._dgridPage)
self._configure_table()
# create the plot
# self._plotCanvas = MyMplCanvas(self._plotPage, width=lamda10, height=4, dpi=100)
# self._plotToolbar = NavigationToolbar(self._plotCanvas, self._plotPage)
self._plotCanvas = {}
self._plotToolbar = {}
# create the shell
self._scadaShell = ScadaShell(self)
# setting the layout of the first tab, i.e., dgrid
dgridLayout = QVBoxLayout(self._dgridPage)
dgridLayout.addWidget(self._dgridValues)
# setting the layout of the second tab, i.e., network
networkLayout = QVBoxLayout(self._networkPage)
networkLayout.addWidget(self._networkDisp)
# setting the layout of the third tab, i.e., plots
# plotLayout = QVBoxLayout(self._plotPage)
# plotLayout.addWidget(self._plotCanvas)
# plotLayout.addWidget(self._plotToolbar)
# setting the layout of the main page
self._mainLayout = QVBoxLayout()
self._mainLayout.addWidget(self._tabs)
self._mainLayout.addWidget(self._scadaShell)
self.setLayout(self._mainLayout)
self.setWindowTitle("Distributed Optimization SCADA")
self.setMinimumSize(1100, 600)
self.setWindowIcon(QtGui.QIcon('DOscada.png'))
self._scadaShell.setFocus()
def set_window_title(self, title):
self.setWindowTitle(title)
def tabClosedRequested(self, tab_index):
if tab_index >= 2:
self._tabs.removeTab(tab_index)
self._current_plot = -1
def _configure_table(self):
# configure the row header for the table
self._dgridValues.setVerticalHeaderItem(0, QTableWidgetItem("ON"))
self._dgridValues.setVerticalHeaderItem(1, QTableWidgetItem("A2O[ms]"))
self._dgridValues.setVerticalHeaderItem(2, QTableWidgetItem("V[pu]"))
self._dgridValues.setVerticalHeaderItem(3, QTableWidgetItem("P[pu]"))
self._dgridValues.setVerticalHeaderItem(4, QTableWidgetItem("Trip"))
self._dgridValues.setVerticalHeaderItem(5, QTableWidgetItem("ADMM"))
self._dgridValues.setVerticalHeaderItem(6,
QTableWidgetItem("Opt [ms]"))
self._dgridValues.setVerticalHeaderItem(7,
QTableWidgetItem("RPC [ms]"))
self._dgridValues.setVerticalHeaderItem(8, QTableWidgetItem("V* [pu]"))
self._dgridValues.setVerticalHeaderItem(9, QTableWidgetItem("P* [pu]"))
# configure the column header of the table
for i in range(0, 31):
self._dgridValues.setHorizontalHeaderItem(
i, QTableWidgetItem(str(i + 1)))
self._dgridValues.horizontalHeaderItem(i).setForeground(
QtGui.QColor(255, 0, 0, 255))
# set the font-color for the generators columns in green
self._dgridValues.horizontalHeaderItem(0).setForeground(
QtGui.QColor(13, 148, 22, 255))
self._dgridValues.horizontalHeaderItem(1).setForeground(
QtGui.QColor(13, 148, 22, 255))
self._dgridValues.horizontalHeaderItem(12).setForeground(
QtGui.QColor(13, 148, 22, 255))
self._dgridValues.horizontalHeaderItem(21).setForeground(
QtGui.QColor(13, 148, 22, 255))
self._dgridValues.horizontalHeaderItem(22).setForeground(
QtGui.QColor(13, 148, 22, 255))
self._dgridValues.horizontalHeaderItem(26).setForeground(
QtGui.QColor(13, 148, 22, 255))
font = self._dgridValues.horizontalHeader().font()
font.setBold(True)
self._dgridValues.horizontalHeader().setFont(font)
# hide columns that don't have a coresponding network node
self._dgridValues.setColumnHidden(4, True)
self._dgridValues.setColumnHidden(8, True)
self._dgridValues.setColumnHidden(10, True)
# populate the table with empty cells
for col in range(0, 31):
for row in range(0, 10):
self._dgridValues.setItem(row, col, QTableWidgetItem(" "))
font = self._dgridValues.item(row, col).font()
font.setPixelSize(8)
self._dgridValues.item(row, col).setFont(font)
self._dgridValues.resizeColumnsToContents()
self._dgridValues.resizeRowsToContents()
def set_current_plot(self, plot_no):
self._current_plot = plot_no
def add_plot_tab(self, plot_no, plot_name):
self._current_plot = plot_no
self._plotPage[plot_no] = QWidget()
self._tabs.addTab(self._plotPage[plot_no],
str(plot_no) + " - " + plot_name)
# create the plot
self._plotCanvas[plot_no] = MyMplCanvas(self._plotPage[plot_no],
width=5,
height=4,
dpi=100)
self._plotToolbar[plot_no] = NavigationToolbar(
self._plotCanvas[plot_no], self._plotPage[plot_no])
# setting the layout of the third tab, i.e., plots
plotLayout = QVBoxLayout(self._plotPage[plot_no])
plotLayout.addWidget(self._plotCanvas[plot_no])
plotLayout.addWidget(self._plotToolbar[plot_no])
def agent_connected(self, ano):
self._dgridValues.item(0, ano - 1).setText("ON")
self._dgridValues.resizeRowsToContents()
self._dgridValues.viewport().update()
def agent_running_admm(self, ano):
self._dgridValues.item(5, ano - 1).setText("ON")
self._dgridValues.resizeRowsToContents()
self._dgridValues.viewport().update()
def agent_disconnected(self, ano):
self._dgridValues.item(0, ano - 1).setText("OFF")
self._dgridValues.resizeRowsToContents()
self._dgridValues.viewport().update()
def agent_update_values(self, ano, dt_opal, v_meas, p_meas, trip):
self._dgridValues.item(1, ano - 1).setText('{:4.3f}'.format(dt_opal))
self._dgridValues.item(2, ano - 1).setText('{:4.3f}'.format(v_meas))
self._dgridValues.item(3, ano - 1).setText('{:4.3f}'.format(p_meas))
self._dgridValues.item(4, ano - 1).setText('{:4.3f}'.format(trip))
self._dgridValues.resizeColumnsToContents()
self._dgridValues.viewport().update()
def agent_finished_admm(self, ano, dt_opt, dt_rpc, v_ref, p_ref):
self._dgridValues.item(5, ano - 1).setText('OFF')
self._dgridValues.item(6, ano - 1).setText('{:4.3f}'.format(dt_opt))
self._dgridValues.item(7, ano - 1).setText('{:4.3f}'.format(dt_rpc))
self._dgridValues.item(8, ano - 1).setText('{:4.3f}'.format(v_ref))
self._dgridValues.item(9, ano - 1).setText('{:4.3f}'.format(p_ref))
self._dgridValues.resizeColumnsToContents()
self._dgridValues.viewport().update()
def plot_data(self, x, y, marker, label):
if self._current_plot == -1:
self._scadaShell.log_text("No plot selected!")
else:
self._plotCanvas[self._current_plot].update_figure(
x, y, marker, label)
def plot_hold(self, holdon):
if self._current_plot == -1:
self._scadaShell.log_text("No plot selected!")
else:
self._plotCanvas[self._current_plot].plot_hold(holdon)
def setData(self, data):
self.clear()
self.TableWidgets.clear()
self.ColorSettings = QSettings("ExcelDiffer", "Color")
hightlight = self.ColorSettings.value("hightlight")
for sheet in data:
tableWidget = QTableWidget()
tableWidget.cellClicked.connect(self.cellClicked.emit)
tableWidget.horizontalScrollBar().valueChanged.connect(
self.hbarchange.emit)
tableWidget.verticalScrollBar().valueChanged.connect(
self.vbarchange.emit)
tableWidget.setStyleSheet("selection-background-color: " +
hightlight + ";selection-color:black")
hlable = []
vlable = []
for i in range(sheet["col"]):
hlable.append(self.intToABC(i + 1))
for i in range(sheet["row"]):
vlable.append(str(i + 1))
tableWidget.setRowCount(sheet["row"])
tableWidget.setColumnCount(sheet["col"])
tableWidget.setVerticalHeaderLabels(vlable)
tableWidget.setHorizontalHeaderLabels(hlable)
tableWidget.setEditTriggers(QAbstractItemView.NoEditTriggers)
for i in range(sheet["row"]):
for j in range(sheet["col"]):
value = sheet["data"][i][j].value
if sheet["data"][i][j].ctype == 3:
value = xlrd.xldate.xldate_as_datetime(
value, 0).strftime('%Y/%m/%d %H:%M:%S')
tableWidget.setItem(i, j, QTableWidgetItem(str(value)))
for span in sheet["merged"]:
tableWidget.setSpan(span[0], span[2], span[1] - span[0],
span[3] - span[2])
QTableWidget.resizeColumnsToContents(tableWidget)
QTableWidget.resizeRowsToContents(tableWidget)
self.TableWidgets.append(tableWidget)
self.addTab(tableWidget, sheet["name"])
def initUI(self):
self.setWindowTitle("QTableWidget範例")
self.resize(430, 230)
conLayout = QHBoxLayout()
tableWidget = QTableWidget()
tableWidget.setRowCount(4)
tableWidget.setColumnCount(3)
conLayout.addWidget(tableWidget)
tableWidget.setHorizontalHeaderLabels(['姓名', '性別', '體重(kg)'])
newItem = QTableWidgetItem("張三")
newItem.setTextAlignment(Qt.AlignRight | Qt.AlignBottom)
tableWidget.setItem(0, 0, newItem)
newItem = QTableWidgetItem("男")
tableWidget.setItem(0, 1, newItem)
newItem = QTableWidgetItem("160")
tableWidget.setItem(0, 2, newItem)
self.setLayout(conLayout)
class Window(QWidget):
def __init__(self):
super().__init__(flags=Qt.FramelessWindowHint)
self.offset = None
self.predictions = []
self.push_button_quit = QPushButton(self)
self.push_button_minimize = QPushButton(self)
self.text_edit_title = QTextEdit(self)
self.text_edit_matches_found = QTextEdit(self)
self.text_edit_last_update_time = QTextEdit(self)
self.table_widget = QTableWidget(0, 4, self)
self.label = QLabel(self)
self.label.setPixmap(
QPixmap(os.path.dirname(__file__) + '/images/title_bar_icon.png'))
self.label.resize(720, 50)
self.label.move(0, -5)
self.label.stackUnder(self.table_widget)
self.label = QLabel(self)
self.label.setPixmap(
QPixmap(os.path.dirname(__file__) + '/images/title_icon.png'))
self.label.resize(35, 35)
self.label.move(5, 5)
self.label.stackUnder(self.table_widget)
self.bg_label = QLabel(self)
self.bg_label.setPixmap(
QPixmap(os.path.dirname(__file__) + '/images/bg_image.png'))
self.bg_label.resize(720, 690)
self.bg_label.move(0, 0)
self.bg_label.stackUnder(self.label)
self.bg_label.stackUnder(self.text_edit_last_update_time)
self.bg_label.stackUnder(self.text_edit_matches_found)
self.thread = Threader(self)
self.thread.authResult.connect(self.handleAuthResult)
self.thread.updateStart.connect(self.handleStartUpdate)
self.thread.start()
self.initUi()
self.setWindowIcon(
QIcon(os.path.dirname(__file__) + '/images/taskbar_icon.png'))
self.setWindowTitle('The Predictor')
self.setMinimumSize(QSize(720, 690))
self.setMaximumSize(QSize(720, 690))
def initUi(self):
font = QFont('Calibri', 14)
stylesheet = '''
QTextEdit#matches_found, QTextEdit#update_time {
color: rgb(154,157,161);
background-color: rgb(42,62,97);
border: none;
}
QTextEdit#title {
color: white;
}
QPushButton#quit {
border: none;
}
QPushButton#quit:hover {
background-image: url(os.path.dirname(__file__) + "/images/red-x.png");
background-repeat: no-repeat;
}
QPushButton#minimize {
border: none;
}
QPushButton#minimize:hover {
background-color: rgb(40, 67, 115);
}
QTableView::item
{
background: black;
}
'''
layout = QGridLayout()
layout.setSpacing(50)
self.push_button_quit.setObjectName('quit')
self.push_button_quit.move(678, 3)
self.push_button_quit.resize(40, 40)
self.push_button_quit.setStyleSheet(stylesheet)
self.push_button_quit.stackUnder(self.table_widget)
self.push_button_quit.setIcon(
QIcon(os.path.dirname(__file__) + '/images/x.png'))
self.push_button_quit.clicked.connect(self.button_quit)
self.push_button_quit.setToolTip('Close app')
self.push_button_quit.toolTip()
self.push_button_minimize.setObjectName('minimize')
self.push_button_minimize.move(640, 5)
self.push_button_minimize.resize(34, 34)
self.push_button_minimize.setStyleSheet(stylesheet)
self.push_button_minimize.stackUnder(self.table_widget)
self.push_button_minimize.setIcon(
QIcon(os.path.dirname(__file__) + '/images/-.png'))
self.push_button_minimize.clicked.connect(self.button_minimize)
self.push_button_minimize.setToolTip('Minimize app\'s window')
self.text_edit_title.setObjectName('title')
self.text_edit_title.setText('The Predictor')
self.text_edit_title.setFont(QFont('Calibri', 20))
self.text_edit_title.setDisabled(True)
self.text_edit_title.setStyleSheet(
'color:rgb(183, 206, 247);background: transparent;border: none;')
self.text_edit_title.move(40, 0)
self.text_edit_title.resize(270, 60)
self.text_edit_title.stackUnder(self.table_widget)
self.text_edit_title.show()
self.text_edit_matches_found.setObjectName('matches_found')
self.text_edit_matches_found.setFont(font)
self.text_edit_matches_found.setDisabled(True)
self.text_edit_matches_found.setStyleSheet(stylesheet)
self.text_edit_matches_found.move(70, 68)
self.text_edit_matches_found.resize(270, 40)
self.text_edit_matches_found.setToolTip(
'Message box, which signalising about updating \n'
'of the results table or showing reason \n'
'why a results table is empty.')
self.text_edit_matches_found.setToolTipDuration(5000)
self.text_edit_matches_found.hide()
self.text_edit_last_update_time.setObjectName('update_time')
self.text_edit_last_update_time.setFont(font)
self.text_edit_last_update_time.setDisabled(True)
self.text_edit_last_update_time.setStyleSheet(stylesheet)
self.text_edit_last_update_time.move(380, 68)
self.text_edit_last_update_time.resize(270, 40)
self.text_edit_last_update_time.setToolTip(
'Message box, showing a timestamp of last check or \n'
'update of a results table.')
self.text_edit_last_update_time.setToolTipDuration(5000)
self.text_edit_last_update_time.hide()
self.setLayout(layout)
layout.setContentsMargins(60, 130, 60, 60)
self.table_widget.setHorizontalHeaderLabels(
('Team 1', 'Team 2', 'Map', 'Prediction'))
self.table_widget.horizontalHeader().setSectionResizeMode(
QHeaderView.Fixed)
self.table_widget.horizontalHeader().setHighlightSections(False)
self.table_widget.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.table_widget.horizontalHeader().setStyleSheet(
'::section{color:rgb(154,157,161); '
'background: rgb(24, 39, 66);}')
self.table_widget.setStyleSheet(
'QTableView{background: rgb(31, 53, 89);border: none;}')
for i in range(4):
self.table_widget.setColumnWidth(i, 150)
self.table_widget.setSelectionBehavior(QTableView.SelectRows)
self.table_widget.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.table_widget.verticalHeader().setVisible(False)
layout.addWidget(self.table_widget)
def button_minimize(self):
self.showMinimized()
def button_quit(self):
self.close()
def handleAuthResult(self, result):
"""Function receives signals from a predicting thread and renew a result`s table"""
self.table_widget.setRowCount(0)
self.text_edit_last_update_time.setText(
datetime.datetime.now().strftime('%H:%M:%S %d-%m-%Y'))
self.text_edit_last_update_time.setAlignment(Qt.AlignCenter)
self.text_edit_last_update_time.show()
if len(result) == 2 and 'int' in str(type(result[1])):
self.text_edit_matches_found.setText(result[0])
self.text_edit_matches_found.setAlignment(Qt.AlignCenter)
self.text_edit_matches_found.show()
else:
self.text_edit_matches_found.hide()
for n, item in enumerate(result):
split_item = item.split(':')
self.table_widget.insertRow(n)
r, g, b = (40, 90, 150) if n % 2 == 0 else (65, 85, 145)
# Put predictions into the table
for cell in range(4):
self.table_widget.setItem(
n, cell, QTableWidgetItem(str(split_item[cell])))
self.table_widget.item(n,
cell).setBackground(QColor(r, g, b))
self.table_widget.item(n, cell).setTextAlignment(
Qt.AlignCenter)
self.table_widget.item(n, 3).setToolTip(
'W1 means The Predictor predicts that "Team 1" will win, \n'
'otherwise W2 means The Predictor predicts \n'
'that "Team 2" will win.')
def handleStartUpdate(self, result):
"""Signals a predictions update"""
self.text_edit_matches_found.setText(result)
self.text_edit_matches_found.show()
# Next 3 mouse event handlers are used to allow a window dragging
def mousePressEvent(self, event):
if event.button() == Qt.LeftButton:
self.offset = event.pos()
else:
super().mousePressEvent(event)
def mouseMoveEvent(self, event):
if self.offset is not None and event.buttons() == Qt.LeftButton:
self.move(self.pos() + event.pos() - self.offset)
else:
super().mouseMoveEvent(event)
def mouseReleaseEvent(self, event):
super().mouseReleaseEvent(event)
def result_panel_0():
results_label = QLabel('')
table = QTableWidget()
return [[results_label], [table]]
class PYQT_BD(QWidget):
def __init__(self, parent=None):
super(PYQT_BD, self).__init__(parent)
# Creamos una tabla en donde organizaremos los datos
self.table = QTableWidget(0, 3)
self.table.setHorizontalHeaderLabels(['ID', 'NOMBRE', 'APELLIDO'
]) # Tabla con 3 columnas
self.table.setAlternatingRowColors(True)
self.table.setEditTriggers(QTableWidget.NoEditTriggers)
self.table.setSelectionBehavior(QTableWidget.SelectRows)
self.table.setSelectionMode(QTableWidget.SingleSelection)
self.lblID = QLabel("ID:") # Campo de texto para ingresar ID
self.txtID = QLineEdit()
self.txtID.setPlaceholderText("Numero identificador unico")
self.lblName = QLabel("Nombre:") # Campo de texto para ingresar nombre
self.txtName = QLineEdit()
self.txtName.setPlaceholderText("Nombre de la persona")
self.lblApellido = QLabel(
"Apellido:") # Campo de texto para ingresar apellido
self.txtApellido = QLineEdit()
self.txtApellido.setPlaceholderText("Apellido de la persona")
grid = QGridLayout(
) # Declaramo sun gridlayout en donde ingresaremos todos los widget
grid.addWidget(self.lblID, 0, 0)
grid.addWidget(self.txtID, 0, 1)
grid.addWidget(self.lblName, 1, 0)
grid.addWidget(self.txtName, 1, 1)
grid.addWidget(self.lblApellido, 2, 0)
grid.addWidget(self.txtApellido, 2, 1)
btnCargar = QPushButton(
'Cargar Datos') # Boton para cargar y mostrar los datos
btnCargar.clicked.connect(
self.cargarDatos) # función al hacer click sobre el boton
btnInsertar = QPushButton('Insertar') # Boton agregar datos
btnInsertar.clicked.connect(
self.insertarDatos) # función al hacer click sobre el boton
btnEliminar = QPushButton('Eliminar') # Boton para eliminar datos
btnEliminar.clicked.connect(self.eliminarDatos)
hbx = QHBoxLayout() # Declaramos un QHBoxLayout
# Agregamos los elementos al layout
hbx.addWidget(btnCargar)
hbx.addWidget(btnInsertar)
hbx.addWidget(btnEliminar)
vbx = QVBoxLayout()
vbx.addLayout(grid)
vbx.addLayout(hbx)
vbx.setAlignment(Qt.AlignTop)
vbx.addWidget(self.table)
self.setWindowTitle(
"PyQT - Base de datos (SQLite)") # Titulo de la ventana
self.resize(362, 320) # Tamaño de la ventana
self.setLayout(vbx) # Layout de la ventana
# Método para agregar datos a la base de datos
def cargarDatos(self, event):
index = 0
query = QSqlQuery() # Intancia del Query
# Ejecutamos el query "select * from personas"
# El cual nos devolvera todos los datos d ela tabla "personas"
query.exec_("select * from personas")
# Iteramos los datos recividos
while query.next():
ids = query.value(0) # ID
nombre = query.value(1) # NOMBRE
apellido = query.value(2) # APELLIDO
# Ahora organizamos los datos en la tabla creada anteriormente
self.table.setRowCount(index + 1)
self.table.setItem(index, 0, QTableWidgetItem(str(ids)))
self.table.setItem(index, 1, QTableWidgetItem(nombre))
self.table.setItem(index, 2, QTableWidgetItem(apellido))
index += 1
# Método para insertar datos en la base de datos
def insertarDatos(self, event):
# Obtenemos los valores de los campos de texto
ids = int(self.txtID.text())
nombre = self.txtName.text()
apellido = self.txtApellido.text()
query = QSqlQuery() # Instancia de Query
# Ejecutamos una sentencia para insertar los datos
# De los campos de texto
query.exec_("insert into personas values({0}, '{1}', '{2}')".format(
ids, nombre, apellido))
# Mpetodo para eliminar datos d ela base de datos
def eliminarDatos(self, event):
# select = fila seleccionada en la tabla
selected = self.table.currentIndex()
if not selected.isValid() or len(self.table.selectedItems()) < 1:
return
ids = self.table.selectedItems()[0] # valor de tabla
query = QSqlQuery() # instancia de Query
# Ejecutamos una sentencia. Eliminara toda fila cuyo
# Valor de id sea igual al seleccionado
query.exec_("delete from personas where id = " + ids.text())
self.table.removeRow(selected.row()) # Removemos la fila
self.table.setCurrentIndex(QModelIndex())
# Método para crear la base de datos
def db_connect(
self, filename, server
): # Recibe dos parametros: nombre de la base de datos, y el tipo.
db = QSqlDatabase.addDatabase(server) # Creamos la base de datos
db.setDatabaseName(filename) # Le asignamos un nombre
if not db.open(): # En caso de que no se abra
QMessageBox.critical(
None, "Error al abrir la base de datos.\n\n"
"Click para cancelar y salir.", QMessageBox.Cancel)
return False
return True
# Método para crear la tabla personas
def db_create(self):
query = QSqlQuery() # Instancia de Query
#Ejecutamos la sentencia para crear la tabla personas con 3 columnas
query.exec_("create table personas(id int primary key, "
"firstname varchar(20), lastname varchar(20))")
# Agregamos algunos datos de prueba
query.exec_("insert into personas values(101, 'Danny', 'Young')")
query.exec_("insert into personas values(102, 'Christine', 'Holand')")
query.exec_("insert into personas values(103, 'Lars', 'Gordon')")
query.exec_(
"insert into personas values(104, 'Roberto', 'Robitaille')")
query.exec_(
"insert into personas values(105, 'Maria', 'Papadopoulos')")
# Método para ejecutar la base de datos
def init(self, filename, server):
import os # Importamos os
if not os.path.exists(filename):
self.db_connect(filename, server) # Llamamos a "db_connect"
self.db_create() # Llamamis a "db_create"
else:
self.db_connect(filename, server)
class ScanRecordTable(QGroupBox):
""" GUI component. Displays a list of previous scan results. Selecting a scan causes
details of the scan to appear in other GUI components (list of barcodes in the barcode
table and image of the puck in the image frame).
"""
COLUMNS = [
'Date', 'Time', 'Plate Barcode', 'Valid', 'Invalid', 'Empty',
'Plate Type'
]
def __init__(self, barcode_table, image_frame, holder_frame, result_frame,
options):
super(ScanRecordTable, self).__init__()
# Read the store from file
store_writer = StoreWriter(options.get_store_directory(), "store")
store_loader = StoreLoader(options.get_store_directory(), "store")
self._store = Store(store_writer,
store_loader.load_records_from_file())
self._options = options
self._barcodeTable = barcode_table
self._image_frame = image_frame
self._holder_frame = holder_frame
self._result_frame = result_frame
self.setTitle("Scan Records")
self.setMaximumWidth(1330)
self._init_ui()
def _init_ui(self):
# Create record table - lists all the records in the store
self._table = QTableWidget()
self._table.setMinimumWidth(720) #900
self._table.setMinimumHeight(400)
self._table.setColumnCount(len(self.COLUMNS))
self._table.setHorizontalHeaderLabels(self.COLUMNS)
self._table.setSelectionBehavior(
QtWidgets.QAbstractItemView.SelectRows)
# Delete button - deletes selected records
btn_delete = QtWidgets.QPushButton('Delete')
btn_delete.setToolTip('Delete selected scan/s')
btn_delete.resize(btn_delete.sizeHint())
btn_delete.clicked.connect(self._delete_selected_records)
hbox = QHBoxLayout()
hbox.setSpacing(10)
hbox.addWidget(btn_delete)
hbox.addStretch(1)
vbox = QVBoxLayout()
vbox.addWidget(self._table)
vbox.addLayout(hbox)
self.setLayout(vbox)
def cell_pressed_action_triggered(self, to_run_on_table_clicked):
self._table.cellPressed.connect(to_run_on_table_clicked)
self._table.cellPressed.connect(self._record_selected)
def add_record_frame(self, holder_barcode, plate, holder_img, pins_img):
""" Add a new scan frame - creates a new record if its a new puck, else merges with previous record"""
self._store.merge_record(holder_barcode, plate, holder_img, pins_img)
self._load_store_records()
if self._options.scan_clipboard.value():
self._barcodeTable.copy_to_clipboard()
def _load_store_records(self):
""" Populate the record table with all of the records in the store.
"""
self._table.clearContents()
self._table.setRowCount(self._store.size())
for n, record in enumerate(self._store.records):
items = [
record.date, record.time, record.holder_barcode,
record.num_valid_barcodes, record.num_unread_slots,
record.num_empty_slots, record.plate_type
]
valid_empty = record.num_valid_barcodes + record.num_empty_slots
if valid_empty == record.num_slots:
color = self._options.col_ok()
elif valid_empty < record.num_slots and record.num_valid_barcodes > 0:
color = self._options.col_accept()
else:
color = self._options.col_bad()
color.a = 192
for m, item in enumerate(items):
new_item = QtWidgets.QTableWidgetItem(str(item))
new_item.setBackground(color.to_qt())
new_item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self._table.setItem(n, m, new_item)
# Display the first (most recent) record
self._table.setCurrentCell(0, 0)
self._record_selected()
def _record_selected(self):
""" Called when a row is selected, causes details of the selected record to be
displayed (list of barcodes in the barcode table and image of the scan in the
image frame).
"""
try:
# Clear all events
QtWidgets.QApplication.processEvents()
row = self._table.selectionModel().selectedRows()[0].row()
record = self._store.get_record(row)
self._barcodeTable.populate(record.holder_barcode, record.barcodes)
marked_image = record.get_marked_image(self._options)
image = record.get_image()
holder_image = record.get_holder_image()
self._image_frame.display_image(image)
self._holder_frame.display_image(holder_image)
self._result_frame.display_image(marked_image)
except IndexError:
self._barcodeTable.clear()
# self._imageFrame.clear_frame("Record table empty\nNothing to display")
def _delete_selected_records(self):
""" Called when the 'Delete' button is pressed. Deletes all of the selected records
(and the associated images) from the store and from disk. Asks for user confirmation.
"""
# Display a confirmation dialog to check that user wants to proceed with deletion
quit_msg = "This operation cannot be undone.\nAre you sure you want to delete these record/s?"
reply = QtWidgets.QMessageBox.warning(self, 'Confirm Delete', quit_msg,
QtWidgets.QMessageBox.Yes,
QtWidgets.QMessageBox.No)
# If yes, find the appropriate records and delete them
if reply == QMessageBox.Yes:
rows = self._table.selectionModel().selectedRows()
records_to_delete = []
for row in rows:
index = row.row()
record = self._store.get_record(index)
records_to_delete.append(record)
if self._options.backup.value():
self._store.backup_records(
self._options.get_backup_directory())
self._store.delete_records(records_to_delete)
self._load_store_records()
def is_latest_holder_barcode(self, holder_barcode):
return self._store.is_latest_holder_barcode(holder_barcode)
class Ui_Processing(QDialog):
last_count = 0
count = 0
grt_flag = False
git_flag = False
gpt_flag = False
gft_flag = False
def __init__(self):
super().__init__()
self.processUI()
def report_view(self):
webbrowser.open("http://117.16.11.8:8888")
def processUI(self):
### remove title bar
self.setWindowFlags(QtCore.Qt.FramelessWindowHint
| QtCore.Qt.WindowStaysOnBottomHint)
### background image and Fixed Size
back_label = QLabel(self)
back = QPixmap('.\\img\\33_back.png')
back_label.setPixmap(back)
self.setFixedSize(back.width(), back.height())
### close Button
self.close_Btn = QPushButton('', self)
self.close_Btn.setIcon(QIcon('.\\img\\close_Btn.png'))
self.close_Btn.setFixedSize(20, 20)
self.close_Btn.setIconSize(QtCore.QSize(30, 30))
self.close_Btn.move(back.width() - 40, 20)
self.close_Btn.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
### GIF set
self.moviee = QLabel(self)
self.movie = QtGui.QMovie(".\\img\\Processing.gif")
self.moviee.setMovie(self.movie)
self.moviee.setGeometry(50, 28, 320, 150)
self.movie.start()
### Pause Button
self.P_btn = QPushButton('', self)
self.P_btn.setIcon(QIcon('.\\img\\Pause.png'))
self.P_btn.setIconSize(QtCore.QSize(170, 90))
self.P_btn.setFixedSize(150, 70)
self.P_btn.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.P_btn.move(420, 60)
### Continue Button
self.C_btn = QPushButton('', self)
self.C_btn.setIcon(QIcon('.\\img\\Continue.png'))
self.C_btn.setIconSize(QtCore.QSize(170, 90))
self.C_btn.setFixedSize(150, 70)
self.C_btn.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.C_btn.move(420, 60)
### Cancel Button
self.Can_btn = QPushButton('', self)
self.Can_btn.setIcon(QIcon('.\\img\\Cancel.png'))
self.Can_btn.setIconSize(QtCore.QSize(170, 90))
self.Can_btn.setFixedSize(150, 70)
self.Can_btn.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.Can_btn.move(600, 60)
### Start Button
self.S_btn = QPushButton('', self)
self.S_btn.setIcon(QIcon('.\\img\\Start.png'))
self.S_btn.setIconSize(QtCore.QSize(170, 90))
self.S_btn.setFixedSize(150, 70)
self.S_btn.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.S_btn.move(600, 60)
### hide btn P & S
self.C_btn.setVisible(False)
self.S_btn.setVisible(False)
### Table Widget
self.tableWidget = QTableWidget(self)
self.tableWidget.setFixedSize(760, 370)
self.tableWidget.move(30, 200)
self.tableWidget.setColumnCount(3)
self.tableWidget.setColumnWidth(0, self.tableWidget.width() / 5.5)
self.tableWidget.setColumnWidth(1, self.tableWidget.width() / 2.5)
self.tableWidget.setColumnWidth(2, self.tableWidget.width() / 2.5)
### Btn Clicked
self.P_btn.clicked.connect(self.P_btn_clicked)
self.C_btn.clicked.connect(self.C_btn_clicked)
self.Can_btn.clicked.connect(self.Can_btn_clicked)
self.S_btn.clicked.connect(self.S_btn_clicked)
self.close_Btn.clicked.connect(self.close_Btn_clicked)
self.show()
self.gipThread = get_ip_thread(self)
self.gipThread.gipEvent.connect(self.gipThreadEventHandler)
self.gipThreadStart()
self.gregThread = get_registry_thread(self)
self.gregThread.gregEvent.connect(self.gregThreadEventHandler)
self.gregThreadStart()
self.gprocThread = get_proc_thread(self)
self.gprocThread.gprocEvent.connect(self.gprocThreadEventHandler)
self.gprocThreadStart()
self.gfileThread = get_file_thread(self)
self.gfileThread.gfileEvent.connect(self.gfileThreadEventHandler)
self.gfileThreadStart()
def complete_scan(self, grt_flag, git_flag, gpt_flag, gft_flag):
if (grt_flag and git_flag and gpt_flag and gft_flag):
button_flag = QMessageBox.question(
self, '완료', "보고서를 확인하시겠습니까?", QMessageBox.Yes | QMessageBox.No,
QMessageBox.No)
if button_flag == QMessageBox.Yes:
self.report_view()
exit()
else:
exit()
@pyqtSlot()
def gipThreadStart(self):
self.gipThread.start()
@pyqtSlot(list)
def gipThreadEventHandler(self, ip_data):
self.count += self.last_count
self.count += len(ip_data)
self.tableWidget.setRowCount(self.count)
self.tableWidget.setColumnCount(3)
i = self.last_count
for k in ip_data:
self.tableWidget.setItem(i, 0, QTableWidgetItem("Warning"))
self.tableWidget.setItem(i, 1, QTableWidgetItem(k))
self.tableWidget.setItem(i, 2, QTableWidgetItem(""))
i = i + 1
self.last_count = i
self.git_flag = True
@pyqtSlot()
def gregThreadStart(self):
self.gregThread.start()
@pyqtSlot(list)
def gregThreadEventHandler(self, reg_data):
self.count += self.last_count
self.count += len(reg_data) - 1
self.tableWidget.setRowCount(self.count)
self.tableWidget.setColumnCount(3)
i = self.last_count
for reg_k in reg_data:
self.tableWidget.setItem(i, 0, QTableWidgetItem("Warning"))
self.tableWidget.setItem(i, 1, QTableWidgetItem(reg_k))
self.tableWidget.setItem(i, 2, QTableWidgetItem(""))
i = i + 1
self.last_count = i
self.grt_flag = True
@pyqtSlot()
def gprocThreadStart(self):
self.gprocThread.start()
@pyqtSlot(dict)
def gprocThreadEventHandler(self, proc_data):
self.count += self.last_count
self.count += len(proc_data) - 1
self.tableWidget.setRowCount(self.count)
self.tableWidget.setColumnCount(3)
i = self.last_count
for proc_k in proc_data.keys():
self.tableWidget.setItem(i, 0, QTableWidgetItem("Warning"))
self.tableWidget.setItem(i, 1, QTableWidgetItem(proc_k))
self.tableWidget.setItem(i, 2, QTableWidgetItem(proc_data[proc_k]))
i = i + 1
self.last_count = i
self.gpt_flag = True
@pyqtSlot()
def gfileThreadStart(self):
self.gfileThread.start()
@pyqtSlot(dict)
def gfileThreadEventHandler(self, file_data):
self.count += self.last_count
self.count += len(file_data) - 2
self.tableWidget.setRowCount(self.count)
self.tableWidget.setColumnCount(3)
i = self.last_count
for k in file_data.keys():
print(i)
if file_data[k] == "":
self.tableWidget.setItem(i, 0, QTableWidgetItem("Info"))
else:
self.tableWidget.setItem(i, 0, QTableWidgetItem("Warning"))
self.tableWidget.setItem(i, 1, QTableWidgetItem(k))
self.tableWidget.setItem(i, 2, QTableWidgetItem(file_data[k]))
i = i + 1
self.last_count = i
self.gft_flag = True
self.complete_scan(self.grt_flag, self.git_flag, self.gpt_flag,
self.gft_flag)
### clicked btn event show and hide
def P_btn_clicked(self):
self.P_btn.setVisible(False)
self.C_btn.setVisible(True)
self.movie.stop()
def C_btn_clicked(self):
self.C_btn.setVisible(False)
self.P_btn.setVisible(True)
self.movie.start()
def Can_btn_clicked(self):
self.Can_btn.setVisible(False)
self.S_btn.setVisible(True)
self.P_btn.setVisible(False)
self.C_btn.setVisible(False)
self.movie.stop()
def S_btn_clicked(self):
self.S_btn.setVisible(False)
self.P_btn.setVisible(True)
self.C_btn.setVisible(False)
self.Can_btn.setVisible(True)
self.movie.start()
### Close_Btn_clicked = Go Tray or Exit
def close_Btn_clicked(self):
self.UI = GoTrayUI()
self.UI.show()
def setupUi(self, widget):
now = datetime.now()
widget.resize(2000, 1200)
widget.setWindowIcon(QIcon("icons/bookkeeping.ico"))
widget.setToolTipDuration(-1)
widget.setStyleSheet("QPushButton:hover{\n"
"background-color: silver;\n"
"}")
# SHOW CHART BUTTON
self.chartBtn = QPushButton(widget)
self.chartBtn.setGeometry(1620, 20, 250, 110)
self.chartBtn.setStyleSheet("background: lightgreen;\n"
"color: white;\n"
"font-size: 40px;")
self.chartBtn.setText("Диаграмма")
# SELECT TYPES CHARTS
self.TypesCharts = QComboBox(widget)
self.TypesCharts.setGeometry(1650, 150, 200, 40)
self.TypesCharts.setStyleSheet("font-size: 30px;")
self.TypesCharts.addItem("общая")
self.TypesCharts.addItem("по времени")
self.TypesCharts.addItem("по типам")
self.TypesCharts.addItem("по продуктам")
# TAB WIDGET EXPENSES AND INCOME
self.MainTab = QTabWidget(widget)
self.MainTab.setGeometry(1, 10, 1480, 1110)
# TEBLE EXPENSES
self.tableExpenses = QTableWidget(widget)
self.tableExpenses.setGeometry(5, 5, 1480, 1110)
self.tableExpenses.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.tableExpenses.setAutoScroll(True)
self.tableExpenses.setRowCount(1000)
self.tableExpenses.setColumnCount(5)
self.tableExpenses.horizontalHeader().setDefaultSectionSize(270)
self.tableExpenses.verticalHeader().setDefaultSectionSize(50)
self.tableExpenses.setStyleSheet(u"font-size: 30px;")
self.tableExpenses.setHorizontalHeaderLabels(
('Сумма', 'Продукт', 'Дата', 'Тип', 'Источник'))
# TEBLE INCOME
self.tableIncome = QTableWidget(widget)
self.tableIncome.setGeometry(5, 5, 1480, 1110)
self.tableIncome.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.tableIncome.setAutoScroll(True)
self.tableIncome.setRowCount(1000)
self.tableIncome.setColumnCount(5)
self.tableIncome.horizontalHeader().setDefaultSectionSize(270)
self.tableIncome.verticalHeader().setDefaultSectionSize(50)
self.tableIncome.setStyleSheet(u"font-size: 30px;")
self.tableIncome.setHorizontalHeaderLabels(
('Сумма', 'Продукт', 'Дата', 'Тип', 'Источник'))
self.tableGave = QTableWidget(widget)
self.tableGave.setGeometry(5, 5, 1480, 1110)
self.tableGave.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.tableGave.setAutoScroll(True)
self.tableGave.setRowCount(1000)
self.tableGave.setColumnCount(4)
self.tableGave.horizontalHeader().setDefaultSectionSize(338)
self.tableGave.verticalHeader().setDefaultSectionSize(50)
self.tableGave.setStyleSheet(u"font-size: 30px;")
self.tableGave.setHorizontalHeaderLabels(
('Сумма', 'Кому', 'Когда', 'Вернули'))
self.tableTook = QTableWidget(widget)
self.tableTook.setGeometry(5, 5, 1480, 1110)
self.tableTook.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOn)
self.tableTook.setAutoScroll(True)
self.tableTook.setRowCount(1000)
self.tableTook.setColumnCount(4)
self.tableTook.horizontalHeader().setDefaultSectionSize(338)
self.tableTook.verticalHeader().setDefaultSectionSize(50)
self.tableTook.setStyleSheet(u"font-size: 30px;")
self.tableTook.setHorizontalHeaderLabels(
('Сумма', 'У кого', 'Когда', 'Использовал'))
# ADD TAB TO TabWidget FOR EXPENSES AND INCOME
self.MainTab.addTab(self.tableExpenses, "Расходы")
self.MainTab.addTab(self.tableIncome, "Доходы")
self.MainTab.addTab(self.tableTook, "Взял")
self.MainTab.addTab(self.tableGave, "Дал")
# TOTAL EXPENSES AND INCOME LABEL
self.TotalLabel = QLabel(widget)
self.TotalLabel.setGeometry(10, 1130, 1000, 60)
self.TotalLabel.setStyleSheet("font-size: 39px;")
self.TotalLabel.setText("Итоговй расход: ")
# TOTAL LABEL
self.TotalLabel_2 = QLabel(widget)
self.TotalLabel_2.setGeometry(550, 1130, 1000, 60)
self.TotalLabel_2.setStyleSheet("font-size: 39px;")
self.TotalLabel_2.setText("Итог: ")
self.percentTotalLabel = QLabel(widget)
self.percentTotalLabel.setGeometry(850, 1130, 1000, 60)
self.percentTotalLabel.setStyleSheet("font-size: 39px;\n"
"color: green;")
# GROUP BOX (DELET EXPENSES AND INCOME)
self.groupBoxType = QGroupBox(widget)
self.groupBoxType.setGeometry(1500, 200, 480, 300)
self.groupBoxType.setStyleSheet("font-size: 30px;")
# ROW DELET
self.RowDelet = QSpinBox(self.groupBoxType)
self.RowDelet.setGeometry(250, 80, 200, 50)
self.RowDelet.setMaximum(1000000)
self.RowDelet.setMinimum(1)
# BUTTON FOR DELETE EXPENSES OR INCOME
self.DeletBtn = QPushButton(self.groupBoxType)
self.DeletBtn.setGeometry(140, 210, 220, 70)
self.DeletBtn.setStyleSheet("background: lightgreen;\n"
"color: white;\n"
"font-size: 40px;")
self.DeletBtn.setText("Удалить")
# ROW LABEL
self.RowLabel = QLabel(self.groupBoxType)
self.RowLabel.setGeometry(30, 80, 200, 50)
self.RowLabel.setStyleSheet("font-size: 30px;")
# GROUP BOX (ADD EXPENSES)
self.groupBox = QGroupBox(widget)
self.groupBox.setGeometry(1500, 560, 480, 600)
self.groupBox.setStyleSheet("font-size: 30px;")
self.groupBox.setTitle("Удалить Расход")
# ADD BUTTON
self.Add = QPushButton(self.groupBox)
self.Add.setGeometry(110, 480, 230, 110)
self.Add.setStyleSheet("background-color: lightgreen;\n"
"color: white;\n"
"font-size: 50px;")
self.Add.setText("Добавить")
# PRICE LABEL
self.PriceLabel = QLabel(self.groupBox)
self.PriceLabel.setGeometry(20, 50, 130, 31)
self.PriceLabel.setStyleSheet("font-size: 30px;")
# PRICE ENTERY
self.PriceEntery = QLineEdit(self.groupBox)
self.PriceEntery.setGeometry(200, 40, 200, 50)
self.PriceEntery.setTabletTracking(False)
self.PriceEntery.setContextMenuPolicy(Qt.DefaultContextMenu)
self.PriceEntery.setAutoFillBackground(False)
self.PriceEntery.setFrame(True)
self.PriceEntery.setEchoMode(QLineEdit.Normal)
self.PriceEntery.setCursorPosition(0)
self.PriceEntery.setDragEnabled(False)
self.PriceEntery.setCursorMoveStyle(Qt.LogicalMoveStyle)
self.PriceEntery.setClearButtonEnabled(False)
# PRODUCT LABEL
self.ProductLabel = QLabel(self.groupBox)
self.ProductLabel.setGeometry(20, 135, 130, 31)
self.ProductLabel.setStyleSheet("font-size: 30px;")
# PRODUCT ENTERY
self.ProductEntery = QLineEdit(self.groupBox)
self.ProductEntery.setGeometry(200, 125, 200, 50)
self.ProductEntery.setTabletTracking(False)
self.ProductEntery.setContextMenuPolicy(Qt.DefaultContextMenu)
self.ProductEntery.setAutoFillBackground(False)
self.ProductEntery.setFrame(True)
self.ProductEntery.setEchoMode(QLineEdit.Normal)
self.ProductEntery.setCursorPosition(0)
self.ProductEntery.setDragEnabled(False)
self.ProductEntery.setCursorMoveStyle(Qt.LogicalMoveStyle)
self.ProductEntery.setClearButtonEnabled(False)
# TYPE LABEL
self.TypeLabel = QLabel(self.groupBox)
self.TypeLabel.setGeometry(20, 200, 130, 40)
self.TypeLabel.setStyleSheet("font-size: 30px;")
# TYPE ENTERY
self.TypeEntery = QComboBox(self.groupBox)
self.TypeEntery.setGeometry(200, 200, 200, 40)
self.TypeEntery.addItem("продукты")
self.TypeEntery.addItem("транспорт")
self.TypeEntery.addItem("развлечения")
self.TypeEntery.addItem("техника")
self.TypeEntery.addItem("одежда")
self.TypeEntery.addItem("учёба")
self.TypeEntery.addItem("книги")
self.TypeEntery.addItem("другое")
# DATE LABEL
self.DateLabel = QLabel(self.groupBox)
self.DateLabel.setGeometry(20, 270, 130, 31)
self.DateLabel.setStyleSheet("font-size: 30px;")
# DATE ENTERY
self.DateEntery = QDateEdit(self.groupBox)
self.DateEntery.setGeometry(200, 270, 200, 40)
self.DateEntery.setDate(QDate(now.year, now.month, now.day))
self.sourceLabel = QLabel(self.groupBox)
self.sourceLabel.setGeometry(20, 350, 130, 31)
self.sourceLabel.setText("Источник")
self.sourceEntery = QComboBox(self.groupBox)
self.sourceEntery.setGeometry(200, 350, 200, 40)
self.sourceEntery.addItem("мои деньги")
self.retranslateUi(widget)
QMetaObject.connectSlotsByName(widget)
def set_text(table: QTableWidget, row, col, text):
item = table.item(row, col)
text = ('%s' if type(text) in [int, str] else '%a') % text
if item is None or item.text() != text:
table.setItem(row, col, QTableWidgetItem(text))
class mzMLTableView(QWidget):
"""
Main Widget of the TableEditor app
"""
def __init__(self, *args):
# set variable self.testForTime to True to see Runtimes
# the following 2 if constructs can be used to determine
# timing
# just put them around whatever should be timed
# self.testForTime = False
# if self.testForTime:
# starttime = timeit.default_timer()
# print("Starttime of overall Initiation : ", starttime)
# if self.testForTime:
# rt = timeit.default_timer() - starttime
# print("Runtime of overall Initiation was : ", rt)
QWidget.__init__(self, *args)
self.df = pd.DataFrame()
self.tdf = Tdf
self.drawtableactive = False
self.initTable()
self.initButtons()
self.changeListener()
"""
Layout for the entire View
"""
layout = QVBoxLayout()
layout.addWidget(self.buttons)
layout.addWidget(self.table)
self.setLayout(layout)
self.resize(1280, 720)
def initTable(self):
"""
initializes Table
"""
self.tablefile_loaded = False
self.loaded_table = ""
self.table = QTableWidget()
self.table.setRowCount(0)
self.table.setSortingEnabled(True)
self.header = [
'Group', 'Fraction', 'Spectra Filepath', 'Label', 'Sample'
]
self.table.setColumnCount(len(self.header))
self.table.setHorizontalHeaderLabels(self.header)
self.header = self.table.horizontalHeader()
for col in range(len(self.header)):
if col != 2:
self.header.setSectionResizeMode(col,
QHeaderView.ResizeToContents)
else:
self.header.setSectionResizeMode(col, QHeaderView.Stretch)
def initButtons(self):
"""
initializes Buttons
"""
self.buttons = QWidget()
self.textbox = QLineEdit(self)
self.textbox.move(20, 20)
self.textbox.setFixedHeight(20)
self.textbox.setToolTip("Filter the experimental layout " +
"according to Spectra Filepath " +
"column. It will be dynamically \n" +
"updated as soon as 2 characters " +
"are inserted.")
Buttons = [
QPushButton('Load Project'),
QPushButton('Load Table'),
QPushButton('Save Table'),
QPushButton('Add File'),
QPushButton('Remove File'),
QPushButton('Group'),
QPushButton('Fraction'),
QPushButton('Label'),
QPushButton('Select All')
]
# Buttonlayout
buttonlayout = QHBoxLayout()
for button in Buttons:
buttonlayout.addWidget(button)
buttonlayout.addWidget(self.textbox)
self.buttons.setLayout(buttonlayout)
# Connections for Buttons and their apropriate functions
Buttons[0].clicked.connect(self.loadBtnFn)
Buttons[0].setToolTip("Load a directory with .mzML files to " +
"generate your own eperimental layout. " +
"For mzML filenames, \"F\" is the regular \n" +
"expression for fraction, while \"G\" or " +
"\"FG\"is the regular expression for the " +
"fraction groups.")
Buttons[1].clicked.connect(self.importBtn)
Buttons[1].setToolTip("Load an existing experimental layout, as " +
".csv or .tsv to display and modify it.")
Buttons[2].clicked.connect(self.exportBtn)
Buttons[2].setToolTip("Save the experimental layout as .csv or " +
".tsv file. .csv is the default option")
Buttons[3].clicked.connect(self.loadFile)
Buttons[3].setToolTip("Load an additional single .mzML file " +
"to the experimental layout.")
Buttons[4].clicked.connect(self.RemoveBtn)
Buttons[4].setToolTip("Remove one or more selected .mzML " +
"files from the experimental layout.")
Buttons[5].clicked.connect(self.GroupBtn)
Buttons[5].setToolTip("Set the fraction group of selected rows " +
"to a given number.")
Buttons[6].clicked.connect(self.FractionBtn)
Buttons[6].setToolTip("Set the fraction of selected rows to a " +
"specific number or use a range to define " +
"multiple fractions. This function is \n" +
"also able to work over multiple fraction " +
"groups and sets the group according to the " +
"fraction number.")
Buttons[7].clicked.connect(self.LabelBtn)
Buttons[7].setToolTip("Set the number of labels, the program will " +
"generate the necessary rows and will also " +
"define the samplenumber for you. You can \n" +
"apply the option to continue samplenumbers " +
"over mutliple fraction groups to combine " +
"two sample preparations.")
Buttons[8].clicked.connect(self.SelectAllBtn)
# init changelistener on textbox
self.textbox.textChanged[str].connect(self.filterTable)
def getDataFrame(self):
return self.tdf.getTable(self)
def drawTable(self):
"""
draws a table with the dataframe table model in tableDataFrame
"""
self.drawtableactive = True
tabledf = Tdf.getTable(self)
# print(tabledf) # For debugging
rowcount = len(tabledf.index)
colcount = len(tabledf.columns)
self.table.setRowCount(rowcount)
for r in range(rowcount):
row = tabledf.index[r]
for c in range(colcount):
col = tabledf.columns[c]
if col == 'Spectra_Filepath':
path = tabledf.at[row, col].split("/")
name = path[len(path) - 1]
self.table.setItem(r, c, QTableWidgetItem(name))
else:
item = str(tabledf.at[row, col])
self.table.setItem(r, c, QTableWidgetItem(item))
self.drawtableactive = False
def importBtn(self, file: str = ""):
"""
Imports table files, currently working are csv and tsv
"""
options = QFileDialog.Options()
if not file:
file, _ = QFileDialog.getOpenFileName(
self,
"QFileDialog.getOpenFileName()",
"",
"All Files (*);;tsv (*.tsv);; csv (*.csv)",
options=options)
if file:
df = fh.importTable(self, file)
Tdf.setTable(self, df)
self.drawTable()
self.tablefile_loaded = True
file = file.split("/")[-1]
self.loaded_table = file
def exportBtn(self):
"""
Exports the table to csv or tsv;default is csv
"""
options = QFileDialog.Options()
file, _ = QFileDialog.getSaveFileName(
self,
"QFileDialog.getSaveFileName()",
"",
"All Files (*);;tsv (*.tsv);; csv (*.csv)",
options=options)
if file:
self.tablefile_loaded = True
fpath = file.split("/")[-1]
self.loaded_table = fpath
df = Tdf.getTable(self)
temp = file.split("/")
fileName = temp[len(temp) - 1]
length = len(fileName)
if length < 4:
ftype = "csv"
file = file + ".csv"
elif fileName.find('.csv', length - 4) != -1:
ftype = "csv"
elif fileName.find('.tsv', length - 4) != -1:
ftype = "tsv"
else:
ftype = "csv"
file = file + ".csv"
fh.exportTable(self, df, file, ftype)
def loadBtnFn(self):
"""
provides a dialog to get the path for a directory
and load the directory into the table.
"""
dlg = QFileDialog(self)
filePath = dlg.getExistingDirectory()
if filePath != '':
self.loadDir(filePath)
def loadDir(self, filepath: str):
Files = fh.getFiles(self, filepath)
delimiters = ["_"]
preparedFiles = fh.tagfiles(self, Files, delimiters[0])
rawTable = fh.createRawTable(self, preparedFiles, filepath)
Tdf.setTable(self, rawTable)
self.drawTable()
def loadFile(self, file: str = ""):
"""
provides a filedialog to load an additional file to the dataframe
"""
options = QFileDialog.Options()
if not file:
file, _ = QFileDialog.getOpenFileName(
self,
"QFileDialog.getOpenFileName()",
"",
"All Files (*);;mzML Files (*.mzML)",
options=options)
if file:
cdf = Tdf.getTable(self)
filelist = []
filePath = file.rsplit("/", 1)[0]
temp = file.split("/")
fileName = temp[len(temp) - 1]
if file:
# print(file)
filelist.append(fileName)
tagged_file = fh.tagfiles(self, filelist)
df = fh.createRawTable(self, tagged_file, filePath)
ndf = cdf.append(df, ignore_index=True)
Tdf.setTable(self, ndf)
self.drawTable()
else:
return False
def getSelRows(self) -> list:
"""
Function which returns a list of the Indexes of selected Rows
todo: needs to be adjusted to fit the datamodel:
so far index of table is only matching index of dataframe
in first iteration, as soon as remove is called twice it crashes.
"""
selindexes = self.table.selectionModel().selectedRows()
selrows = []
for index in sorted(selindexes):
row = index.row()
selrows.append(row)
return selrows
def GroupBtn(self):
"""
Enables the user to change the group of selected rows to a given
number.
"""
selrows = self.getSelRows()
groupnum, ok = QInputDialog.getInt(self, "Group Number",
"Enter Integer Groupnumber")
if ok:
Tdf.modifyGroup(self, selrows, groupnum)
self.drawTable()
def RemoveBtn(self):
"""
Enables the user to remove selected rows
"""
selrows = self.getSelRows()
Tdf.rmvRow(self, selrows)
self.drawTable()
def FractionBtn(self):
"""
Enables the user to change the Fraction of selected rows to a given
number or give a range.
"""
selrows = self.getSelRows()
# first inputdialog
fracmin, ok = QInputDialog.getInt(
self, "Fraction",
"Enter minimal Fractionnumber " + "or single Fractionnumber")
# second inputdialog if first is accepted
if ok:
fracmax, ok = QInputDialog.getInt(
self, "Fraction", "Enter maximal Fractionnumber " +
"or 0 for single Fractionnumber")
if ok:
# decision if multiple fractions are set or just one
if fracmax != 0:
if fracmax > fracmin:
# third messagedialog
rep = QMessageBox.question(
self, "Fraction Group?",
"Do you want to infer a " +
"Fraction Group from the " + "given range?",
(QMessageBox.Yes | QMessageBox.No), QMessageBox.No)
# when confirmed the fraction froup is set
# when max fraction is reached.
if rep == QMessageBox.Yes:
Tdf.modifyFraction(self, selrows, fracmin, fracmax)
fractions = fracmax - fracmin + 1
numgroups = math.ceil(len(selrows) / fractions)
splicelist = [0]
for g in range(1, numgroups + 1):
splicelist.append(g * fractions)
splicelist.append(len(selrows))
for group in range(1, numgroups + 1):
indexa = splicelist[group - 1]
indexb = splicelist[group]
subrows = selrows[indexa:indexb]
Tdf.modifyGroup(self, subrows, group)
else:
Tdf.modifyFraction(self, selrows, fracmin, fracmax)
elif fracmax == fracmin:
Tdf.modifyFraction(self, selrows, fracmin)
else:
QMessageBox.warning(
self, "Error",
"Please use " + "a higher integer " +
"number for the maximum " + "fractionnumber.")
else:
Tdf.modifyFraction(self, selrows, fracmin)
self.drawTable()
def LabelBtn(self):
"""
Let the user choose the number of labels, it will generate
the labels for the copied rows and also links the sample to
the label. Gives an option to continue the samplecount
over fraction groups.
"""
labelnum, ok = QInputDialog.getInt(
self, "Label",
"Please specify the multiplicity " + "of the selected rows")
if ok:
rep = QMessageBox.question(
self, "Continuous Sample", "Does the samplenumber " +
"continue over multiple " + "fraction groups?",
(QMessageBox.Yes | QMessageBox.No), QMessageBox.No)
if rep == QMessageBox.Yes:
try:
Tdf.modifyLabelSample(self, labelnum, True)
except ValueError:
QMessageBox.about(self, "Warning",
"Unfortunaly, " + "your Number was <1")
else:
try:
Tdf.modifyLabelSample(self, labelnum, False)
except ValueError:
QMessageBox.about(self, "Warning",
"Unfortunaly, " + "your Number was <1")
self.drawTable()
def SelectAllBtn(self):
"""
Selects all Rows of the Table
"""
self.table.setSelectionMode(QAbstractItemView.MultiSelection)
for i in range(self.table.rowCount()):
selected = self.getSelRows()
for j in range(len(selected)):
if i == selected[j]:
self.table.selectRow(i)
self.table.selectRow(i)
self.table.setSelectionMode(QAbstractItemView.ExtendedSelection)
def updateTableView(self, rows):
tabledf = Tdf.getTable(self)
rowcount = len(tabledf.index)
for i in range(rowcount):
self.table.setRowHidden(i, True)
for i in rows:
self.table.setRowHidden(i, False)
def filterTable(self):
"""
get changes from textbox and update table when
more than 3 characters are given.
then update table with the rows that
contain the input in the give column.
"""
tb = self.textbox
givencolumn = "Spectra_Filepath"
tbinput = tb.text()
ft = Tdf.getTable(self)
validDf = not (ft.empty or ft.dropna().empty)
# print(validDf) # for debugging
# print(type(ft)) # for debugging
if len(tbinput) >= 2:
rowstoshow = ft[ft[givencolumn].str.contains(tbinput)]
self.updateTableView(rowstoshow.index)
else:
self.updateTableView(ft.index)
def changeListener(self):
self.table.itemChanged.connect(self.editField)
def editField(self):
if len(self.table.selectedItems()) == 1:
if not self.drawtableactive:
itemchanged = self.table.currentItem()
newvalue = itemchanged.text()
row = itemchanged.row()
column = itemchanged.column()
if column != 2:
Tdf.modifyField(self, row, column, newvalue)
self.drawTable()
else:
QMessageBox.about(
self, "Warning", "Please only, " +
"modify attribute columns," + "not the filepath.\n" +
"To change the filepath," + "use remove and add file.")
self.drawTable()
class TableLineDiaolg(EditDialog, metaclass=QtABCMeta):
def __init__(self, data):
""" Base class for displaying the timesheet as a table for editing.
Implementations of `customise()` and `apply_changes()` will need
to be provided.
You may wish to set `self.explain.setText()` and
`self.setWindowTitle()` in `customise()`.
Parameters
----------
data : Data object
object which holds all the csv data
"""
try:
super().__init__(data)
self.initUI(data)
self.customise()
except RuntimeError as err:
title = '{}'.format(err)
msg = "Please open or create a timesheet before trying to edit it."
QMessageBox.warning(self, title, msg)
def initUI(self, data):
self.data = data
header, self.csv_data = head_tail(self.data.csv_data)
# display most recent csv_data at top
self.csv_data.reverse()
self.num_rows = len(self.csv_data)
self.num_cols = len(header)
# make table
self.table = QTableWidget(self.num_rows, self.num_cols)
# remove numbers from rows
self.table.verticalHeader().setVisible(False)
# set headers
self.table.setHorizontalHeaderLabels(header)
# put data in table
for row, data in enumerate(self.csv_data):
date, dur, act, rate = data.split(',')
item0 = QTableWidgetItem(date)
item1 = QTableWidgetItem(dur)
item2 = QTableWidgetItem(act)
item3 = QTableWidgetItem(rate)
self.table.setItem(row, 0, item0)
self.table.setItem(row, 1, item1)
self.table.setItem(row, 2, item2)
self.table.setItem(row, 3, item3)
buttonBox = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
buttonBox.accepted.connect(self.apply_changes)
buttonBox.rejected.connect(self.reject)
for i in range(self.num_rows):
self.table.setColumnWidth(i, 110)
# for some reason, self.table.width() returns a number larger than
# it should be
width = (self.num_cols + 0.1) * self.table.columnWidth(0)
# exaplin how this window works
# self.explain.setText() should be applied in the derived classes
self.explain = QLabel(wordWrap=True)
self.explain.setMinimumWidth(width)
self.explain.setText('')
self.layout = QVBoxLayout()
self.layout.addWidget(self.explain)
self.layout.addWidget(self.table)
self.layout.addWidget(buttonBox)
self.resize(width, 400)
self.setLayout(self.layout)
self.setWindowTitle('Table dialog')
@abstractmethod
def customise(self):
pass
@abstractmethod
def apply_changes(self):
pass
class DataBrowser(CodeContainer):
def __init__(self, parent):
super().__init__(parent)
self._db = ""
#self._tableColumns = '["time"]'
self._tableColumns = ''
self.dbObj = None
self._dbKwargs = "{}"
self._plots = "[]"
self._plotArgsList = "[[]]"
self._plotKwargsList = "[{}]"
self.aliases = {}
self.alias_fields_reverse = {}
layout = QVBoxLayout()
self.listWidget = QTableWidget()
now = QDateTime.currentDateTime()
self.startDateTime = QDateTimeEdit(now.addMonths(-6))
self.endDateTime = QDateTimeEdit(now)
buttonText = "Load Scans"
self.loadScansButton = QPushButton(buttonText)
layout.addWidget(self.startDateTime)
layout.addWidget(self.endDateTime)
layout.addWidget(self.loadScansButton)
layout.addWidget(self.listWidget)
self.setLayout(layout)
self.fr_thread = DBFetchResultsThread()
self.fr_thread.resultsSignal.connect(self.updateTableFromResults)
self.fr_thread.updateButtonText.connect(self.loadScansButton.setText)
self.fr_thread.finished.connect(partial(self.loadScansButton.setText, buttonText))
self.loadScansButton.clicked.connect(self.__updateTable)
self.listWidget.itemSelectionChanged.connect(self.__replot)
self.setContextMenuPolicy(Qt.CustomContextMenu)
self.customContextMenuRequested.connect(self.showMenu)
self.checked_fields = {}
self.endDateTimer = QTimer(self)
self.endDateTimer.setInterval(1500)
self.endDateTimer.timeout.connect(self.setEndTimeToNow)
self.makeMenu()
self.selected_uids = []
def selectedFields(self, uid=None):
if self.currentUid() not in self.checked_fields.keys():
return []
if uid == None:
uid = self.currentUid()
return self.checked_fields[uid]
def plotSelectedUids(self):
from bluesky.callbacks import LivePlot
for uid in self.selectedUids():
header = self.dbObj[uid]
fields = self.selectedFields(uid)
plotLPList(fields, header)
def setEndTimeToNow(self):
now = QDateTime.currentDateTime()
self.endDateTime.setDateTime(now)
def enableAutoUpdateTime(self):
self.endDateTimer.start()
def disableAutoUpdateTime(self):
self.endDateTimer.stop()
def makeMenu(self):
menu = QMenu()
action1 = QAction("Info", self)
channels = QAction("Channels", self)
current_time = QAction("Auto update end time", self, checkable=True)
view_plot = QAction("Plot checked items", self)
clear_action = menu.addAction(action1)
channels_action = menu.addAction(channels)
view_plot_action = menu.addAction(view_plot)
current_time_action = menu.addAction(current_time)
self.menu = menu
def showScrollBox(self, text):
messageBox = ScrollMessageBox(self)
messageBox.content.setText(text)
messageBox.show()
def info_text(self):
return str(self.dbObj[self.currentUid()].start)
def showMenu(self,event):
action = self.menu.exec_(self.mapToGlobal(event))
if action == None:
pass
elif action.text() == "Info":
#messageBox = ScrollMessageBox(self)
#messageBox.content.setText(str(self.dbObj[self.currentUid()].start))
#messageBox.show()
#info_text = str(self.dbObj[self.currentUid()].start)
#info_text = evalInNs(self, "self.getFunctionStdOut(scan_info(['{}']))".format(self.currentUid()))
##self.getFunctionStdOut = getFunctionStdOut
##info_text = evalInNs(self, "self.getFunctionStdOut(scan_info, ['{}'], Baseline=True)".format(self.currentUid()))
#info_text = self.getFunctionStdOut(self.print_hi)
self.showScrollBox(self.info_text())
elif action.text() == "Channels":
self.channelsBox = ChannelsBox(self)
self.channelsBox.show()
elif action.text() == "Plot checked items":
self.plotSelectedUids()
elif action.text() == "Auto update end time":
if action.isChecked():
self.enableAutoUpdateTime()
else:
self.disableAutoUpdateTime()
def __updateTable(self):
self.runCode()
self._updateTable()
def __replot(self):
self.runCode()
def updateTable(self, db, dbKwargs):
since = self.startDateTime.dateTime().toString("yyyy-MM-dd HH:mm:ss")
until = self.endDateTime.dateTime().toString("yyyy-MM-dd HH:mm:ss")
logger.info("Reading results started")
self.loadScansButton.clicked.disconnect()
self.loadScansButton.clicked.connect(self.fr_thread.cancel)
dbGen = db(since=since, until=until, **dbKwargs)
self.fr_thread.dbGen = dbGen
self.fr_thread.start()
def updateTableFromResults(self, results):
self.fr_thread.resume()
self.loadScansButton.clicked.disconnect()
self.loadScansButton.clicked.connect(self.__updateTable)
logger.info("Reading results stopped")
self.listWidget.setRowCount(len(results))
self.listWidget.setSortingEnabled(True)
self.listWidget.setSelectionBehavior(QAbstractItemView.SelectRows)
col_set=set([])
for r in results:
cols = [k for k,v in r.start.items() if not isinstance(v,Iterable) or type(v)==str]
col_set.update(cols)
cols = list(col_set)
self.listWidget.setColumnCount(len(cols))
self.listWidget.setHorizontalHeaderLabels(cols)
for i in range(len(results)):
r = results[i]
for j in range(len(cols)):
try:
field = r.start[cols[j]]
except KeyError:
logger.debug("Could not find field " + cols[j])
field = None
item = DataTableWidgetItem(str(field))
self.listWidget.setItem(i,j,item)
if self.tableColumns!="":
tableColumns = eval(self.tableColumns)
for i in range(self.listWidget.columnCount()):
#if self.listWidget.horizontalHeaderItem(i).text() not in tableColumns:
colHeader = self.listWidget.horizontalHeaderItem(i)
if colHeader.text() not in tableColumns:
self.listWidget.hideColumn(i)
self.listWidget.update()
#assert self.listWidget.isColumnHidden(i) == True
else:
self.listWidget.showColumn(i)
def findHorizontalHeaderIndex(self, key):
logger.info("horizonal header count: "+str(self.listWidget.columnCount()))
for i in range(self.listWidget.columnCount()):
#if self.listWidget.horizontalHeaderItem(i).text()==key:
colHeader = self.listWidget.horizontalHeaderItem(i)
if colHeader.text()==key:
logger.info(key + " found")
return i
return None
def currentUid(self):
uids = self.selectedUids()
if len(uids)==0:
return None
uid_col = self.findHorizontalHeaderIndex("uid")
uid_row = self.listWidget.currentRow()
return self.listWidget.item(uid_row, uid_col).text()
def selectedUids_(self):
uid_col = self.findHorizontalHeaderIndex("uid")
rows = [item.row() for item in self.listWidget.selectedItems()]
rows = list(set(rows))
uids = [self.listWidget.item(row, uid_col).text() for row in rows]
return uids
def selectedUids(self):
uids_list = self.selectedUids_()
# The purpose of the following lines is to preserve order:
uids_to_be_added = [k for k in uids_list if k not in self.selected_uids]
self.selected_uids = [k for k in self.selected_uids if k in uids_list]
self.selected_uids = self.selected_uids + uids_to_be_added
return self.selected_uids
def selectedHeaders(self):
return [self.dbObj[uid] for uid in self.selectedUids()]
def startData(self,key):
if self.currentUid() is None:
return []
return self.dbObj[self.currentUid()].start[key]
def replotHeader(self, plots, header):
#if header is None:
# return
#if plots is None:
# return
for p in plots:
if not hasattr(p, "ax"):
p._LivePlot__setup()
for p in plots:
plotHeader(p, header)
p.ax.figure.tight_layout()
def replotUid(self, plots, db, uid):
logger.info("replot uid: "+uid)
#if uid is None:
# return
#if db is None:
# return
self.replotHeader(plots, db[uid])
def replot(self, plots, db):
for uid in self.selectedUids():
self.replotUid(plots, db, uid)
def default_code(self):
return """
ui = self.ui
from functools import partial
from bsstudio.functions import widgetValue
from bsstudio.functions import makeLivePlots
db = widgetValue(eval(self.db))
self.dbObj = db
self.uid = None
plots = eval(self.plots)
for plot in plots:
plot.canvas.ax.clear()
try:
plotArgsList = widgetValue(eval(self.plotArgsList))
except TypeError:
print(self.plotArgsList)
print("databrowser plotargslist exception")
plotArgsList = None
plotKwargsList = eval(self.plotKwargsList)
dbKwargs = widgetValue(eval(self.dbKwargs))
livePlots = makeLivePlots(plots, plotArgsList, plotKwargsList)
for uid in self.selectedUids():
self.uid = uid
plots = eval(self.plots)
plotArgsList = widgetValue(eval(self.plotArgsList))
livePlots = makeLivePlots(plots, plotArgsList, plotKwargsList)
self.replotUid(livePlots, db, uid)
self._updateTable = partial(self.updateTable, db, dbKwargs)
"""[1:]
db = makeProperty("db")
dbKwargs = makeProperty("dbKwargs")
plots = makeProperty("plots")
tableColumns = makeProperty("tableColumns")
plotArgsList = makeProperty("plotArgsList")
plotKwargsList = makeProperty("plotKwargsList")
class HIT2_ProcessSelectDialog(QDialog):
def __init__(self, processes):
super(HIT2_ProcessSelectDialog, self).__init__()
self.setWindowTitle("Select Process")
btn_ok = QPushButton("OK")
btn_ok.clicked.connect(self.accept)
btn_cancel = QPushButton("Cancel")
btn_cancel.clicked.connect(self.reject)
self.process_table = QTableWidget()
self.process_table.setColumnCount(2)
self.process_table.setHorizontalHeaderLabels(("Process Name", "PID"))
self.process_table.horizontalHeader().setSectionResizeMode(
QHeaderView.Stretch)
self.process_table.setRowCount(len(processes))
self.process_table.verticalHeader().setVisible(False)
self.process_table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.process_table.setSelectionMode(QAbstractItemView.SingleSelection)
i = 0
for p in processes:
process_name_item = QTableWidgetItem(p[0])
process_name_item.setFlags(process_name_item.flags()
& ~(Qt.ItemIsEditable))
self.process_table.setItem(i, 0, process_name_item)
process_id_item = QTableWidgetItem(str(p[1]))
process_id_item.setFlags(process_id_item.flags()
& ~(Qt.ItemIsEditable))
self.process_table.setItem(i, 1, process_id_item)
i += 1
hbox = QHBoxLayout()
hbox.addStretch(1)
hbox.addWidget(btn_ok)
hbox.addWidget(btn_cancel)
vbox = QVBoxLayout()
vbox.addWidget(self.process_table)
vbox.addLayout(hbox)
self.setLayout(vbox)
def selectedProcess(self):
selectionModel = self.process_table.selectionModel()
if not selectionModel.hasSelection():
return None
if len(selectionModel.selectedRows()) > 1:
raise Exception("Supposedly impossible condition reached!")
row = selectionModel.selectedRows()[0].row()
return int(self.process_table.item(row, 1).data(0))
@classmethod
def selectProcess(cls, processes):
psd = cls(processes)
if QDialog.Accepted == psd.exec_():
return psd.selectedProcess()
return None
class MainWindow(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
# Design Window
self.setMinimumSize(QSize(1000, 825))
self.setWindowTitle("SPI/CGPA")
self.setStyleSheet('background-color:white;')
self.t = QTableWidget(self)
self.t.setRowCount(2)
self.t.setColumnCount(3)
self.t.resize(300, 200)
self.t.move(500, 300)
self.t.setDropIndicatorShown(False)
self.t.setShowGrid(False)
self.show()
class pilihPasien(QDialog):
def __init__(self):
super(pilihPasien,self).__init__()
self.InitUI()
def InitUI (self):
self.create_table()
def cek(self,row):
print(row)
self.parent().terpilih(row)
def create_table(self):
self.table = QTableWidget(self)
self.table.cellDoubleClicked.connect(self.cek)
self.table.setColumnCount(3)
self.table.setHorizontalHeaderLabels(["ID","NAMA PASIEN","NIK"])
self.table.setFixedSize(335,350)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.isiTable()
def isiTable(self):
query = ORMPasien.view_pasien()
self.table.setRowCount(len(query))
for row in range(len(query)):
self.table.setItem(row,0,QTableWidgetItem(query[row].ID_Pasien))
self.table.setItem(row,1,QTableWidgetItem(query[row].namaPasien))
self.table.setItem(row,2,QTableWidgetItem(query[row].NIK))
class MirandasWindow(QWidget):
def __init__(self, *args, **kwargs):
super().__init__()
self.p = profile.Profile()
self.p.enable()
self.estilo = int(sys.argv[1])
#Aqui basicamente se instancia e inicia todas as partes da interface
self.iniciaComponentes()
self.jogo = Jogo()
self.playerAtual = self.jogo.turno
self.alteraContexto()
self.alteraContexto()
self.ia1 = IA(self.jogo)
self.ia2 = IA(self.jogo)
#print(self.jogo.packletters[self.playerAtual])
#self.labelLetras.setText(letrasIniciais)
#Função que iniciará todos os componentes da tela
def iniciaComponentes(self):
self.setWindowTitle('Screble')
#Configuração do botão que adiciona as palavras
self.botaoAddWord = QPushButton('Add Word')
self.botaoAddWord.setToolTip('Botão para adicionar uma palavra')
self.botaoAddWord.clicked.connect(self.clickbotao_addWord)
#Configuração dos labels do player 1
self.label1 = QLabel('Player1:')
self.label1Pts = QLabel('0')
#Configuração dos labels do player 2
self.label2 = QLabel('Player2:')
self.label2Pts = QLabel('0')
#Configuração do identificador textual da coluna para adicionamento da palavra
self.editRow = QSpinBox()
self.editRow.setMinimum(1)
self.editRow.setMaximum(15)
self.labelRow = QLabel('Linha:')
#Configuração do identificador textual da coluna para adicionamento da palavra
self.editCol = QSpinBox()
self.editCol.setMinimum(1)
self.editCol.setMaximum(15)
self.labelCol = QLabel('Coluna:')
#Configuração dos edits que conterão a palavra a ser adicionada e a direção da mesma
self.comboDir = QComboBox()
self.comboDir.addItem("V")
self.comboDir.addItem("H")
self.labelDir = QLabel('Direção:')
self.editWord = QLineEdit('Palavra')
self.labelWord = QLabel('Palavra:')
#Configuração da matriz que contem as letras e bonus das palavras colocadas
self.tabela_matriz = QTableWidget()
self.tabela_matriz.setColumnCount(15)
self.tabela_matriz.setRowCount(15)
self.tabela_matriz.setShowGrid(True)
self.tabela_matriz.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.setaLetrasIniciais()
self.tabela_matriz.resizeColumnsToContents()
self.tabela_matriz.resizeRowsToContents()
#Configuração do label das letras disponíveis
self.labelDisponiveis = QLabel('Letras disponíveis:')
self.labelLetras = QLabel('')
#Configuração do edit que conterá as letras a serem trocadas
self.editTroca = QLineEdit('')
#Configuração do botão que troca as letras
self.botaoTrocaLetras = QPushButton('Troca letras')
self.botaoTrocaLetras.setToolTip('Botão para trocar suas letras')
self.botaoTrocaLetras.clicked.connect(self.clickbotao_trocaLetra)
#Configuração do botão de passar a vez
self.botaoPassaVez = QPushButton('Passar vez')
self.botaoPassaVez.setToolTip('Botão para passar sua rodada')
#self.botaoPassaVez.clicked.connect(self.clickbotao_passaVez)
#Configuração dos layouts
main_layout = QVBoxLayout()
# Header
layout = QHBoxLayout()
layout.addWidget(self.label1)
layout.addWidget(self.label1Pts)
layout.addStretch()
layout.addWidget(self.label2)
layout.addWidget(self.label2Pts)
main_layout.addLayout(layout)
# Main Vision
layout = QHBoxLayout()
layout.addWidget(self.tabela_matriz)
l = QVBoxLayout()
l.addWidget(self.labelDisponiveis)
l.addWidget(self.labelLetras)
l1 = QHBoxLayout()
l1.addWidget(self.editTroca)
l1.addWidget(self.botaoTrocaLetras)
l1.addWidget(self.botaoPassaVez)
l.addLayout(l1)
layout.addLayout(l)
main_layout.addLayout(layout)
# Footer
layout = QVBoxLayout()
l = QHBoxLayout()
l.addWidget(self.labelRow)
l.addWidget(self.editRow)
l.addWidget(self.labelCol)
l.addWidget(self.editCol)
l.addWidget(self.labelDir)
l.addWidget(self.comboDir)
l.addWidget(self.labelWord)
l.addWidget(self.editWord)
layout.addLayout(l)
layout.addWidget(self.botaoAddWord)
main_layout.addLayout(layout)
#Input do layout completo
self.setLayout(main_layout)
self.setGeometry(50, 50, 1220, 450)
#Ação do botão que adicionará uma palavra na matriz
@pyqtSlot()
def clickbotao_addWord(self):
if (self.jogo.finalJogo):
self.p.disable()
pstats.Stats(self.p).sort_stats('cumulative').print_stats(30)
string = "VITORIA "
print(str(self.jogo.points1))
print(str(self.jogo.points2))
if self.jogo.points1 > self.jogo.points2:
if self.estilo == 2:
string += "DA CPU UM !"
else:
string += "DO JOGADOR UM !"
elif self.jogo.points1 < self.jogo.points2:
if self.estilo == 0:
string += "DO JOGADOR UM !"
else:
string += "DA CPU DOIS !"
else:
string = "EMPATE DOS JOGADORES !!"
QMessageBox.about(self, "FIM DE JOGO", string)
return
row, col, word, direcao = 0, 0, '', ''
#Caso do jogador
#Caso de ser PVP
if (self.estilo == 0):
row = self.editRow.value()
col = self.editCol.value()
word = self.editWord.text().lower()
direcao = self.comboDir.currentText()
#Caso de ser PvsIA
elif (self.estilo == 1):
#Jogada do player
if self.playerAtual == 0:
#Pega todos os dados digitados
row = self.editRow.value()
col = self.editCol.value()
word = self.editWord.text().lower()
direcao = self.comboDir.currentText()
#Jogada da IA
else:
row, col, word, direcao = self.ia1.permutation(
self.jogo.packletters[1])
print('saindo ' + str(row) + ' ' + str(col) + ' ' + word +
' ' + direcao)
#Chamar troca de letra
#Caso de ser IAvsIA
else:
#Jogada da IA1
if self.playerAtual == 0:
row, col, word, direcao = self.ia1.permutation(
self.jogo.packletters[0])
print('saindo ' + str(row) + ' ' + str(col) + ' ' + word +
' ' + direcao)
#Chamar troca de letra
#Jogada da IA2
else:
row, col, word, direcao = self.ia2.permutation(
self.jogo.packletters[1])
print('saindo ' + str(row) + ' ' + str(col) + ' ' + word +
' ' + direcao)
#Chamar troca de letra
#Caso a IA queira passar a vez ele mandará uma string vazia que também serve para o jogador
self.jogo.checkFinalJogo(word)
if word == '':
if (self.estilo == 2):
self.clickbotao_trocaLetra(
self.jogo.packletters[self.jogo.playerAtual])
elif (self.estilo == 1 and self.playerAtual == 1):
self.clickbotao_trocaLetra(self.jogo.packletters[1])
else:
self.passaVez()
return 1
#Faz a checagem de erros
if self.estilo != 2 or (self.estilo == 1 and self.playerAtual == 0):
res = self.jogo.checkWord(row, col, word, direcao)
if (res != 1):
self.printError(res)
self.passaVez()
return -1
#Chama a função para calcular os pontos e a palavra final que pode ser modificada caso use-se um coringa
pontos, palavra = self.jogo.inputWord(row, col, word, direcao)
#Chama a função para colocar a palavra na matriz
self.inputWord(row, col, palavra, direcao)
self.jogo.inicio = False
#Chama a função de adicionar a pontuação
self.addPonts(pontos)
#Chamará a troca de contexto na interface e no backend
self.passaVez()
#Ação doo botão que trocara as letras do determinado player
@pyqtSlot()
def clickbotao_trocaLetra(self, letrasAntigas=[]):
if ((self.estilo == 0)
or (self.playerAtual == 0 and self.estilo == 1)):
#Pega as letras do edit, da um split para que se transforme em uma lista
letrasAntigas = self.editTroca.text().split(',')
#Chama a função de trocar letras
listaNovasLetras = self.jogo.exchangeLetters(letrasAntigas)
#Casos de erros
if (type(listaNovasLetras) == int):
self.printError(listaNovasLetras)
return -1
novasLetras = self.listToStr(listaNovasLetras)
self.labelLetras.setText(novasLetras)
self.passaVez()
#Ação do botão que adicionará uma palavra na matriz
@pyqtSlot()
def clickbotao_passaVez(self):
#Chamará a troca de contexto na interface e no backend
self.passaVez()
#Chamará a troca de contexto na interface e também no backend do jogo
def passaVez(self):
self.alteraContexto()
self.jogo.passaVez()
#Função que fará a transição de jogadas entre o jogador 1 e 2
def alteraContexto(self):
if (self.playerAtual == 0):
self.label1.setStyleSheet(
"QLabel { background-color : lightgray; color : black; }")
self.label2.setStyleSheet(
"QLabel { background-color : lightgreen; color : black; }")
self.playerAtual = 1
else:
self.label2.setStyleSheet(
"QLabel { background-color : lightgray; color : black; }")
self.label1.setStyleSheet(
"QLabel { background-color : lightgreen; color : black; }")
self.playerAtual = 0
self.labelLetras.setText(
self.listToStr(self.jogo.packletters[self.playerAtual]))
#Função que adiciona uma palavra na matriz
def inputWord(self, row, col, word, direcao):
for i in range(0, len(word)):
if (direcao == 'V'):
self.tabela_matriz.setItem(row + i - 1, col - 1,
QTableWidgetItem(word[i]))
else:
self.tabela_matriz.setItem(row - 1, col + i - 1,
QTableWidgetItem(word[i]))
#Função que adiciona pontos na pontuação de determinado jogador
def addPonts(self, pontos):
if (self.playerAtual == 0):
self.jogo.points1 += pontos
self.label1Pts.setNum(self.jogo.points1)
else:
self.jogo.points2 += pontos
self.label2Pts.setNum(self.jogo.points2)
#Função que seta as letras iniciais para que o tabuleiro fique igual ao do scrabble
def setaLetrasIniciais(self):
self.tabela_matriz.setItem(7, 7, QTableWidgetItem('*'))
for i in range(0, 15, 7):
for j in range(0, 15, 7):
if (not (i == 7 == j)):
self.tabela_matriz.setItem(i, j, QTableWidgetItem('TP'))
for i in range(1, 5):
self.tabela_matriz.setItem(i, i, QTableWidgetItem('DP'))
self.tabela_matriz.setItem(14 - i, 14 - i, QTableWidgetItem('DP'))
self.tabela_matriz.setItem(i, 14 - i, QTableWidgetItem('DP'))
self.tabela_matriz.setItem(14 - i, i, QTableWidgetItem('DP'))
for i in range(0, 15, 14):
self.tabela_matriz.setItem(3, i, QTableWidgetItem('DL'))
self.tabela_matriz.setItem(i, 3, QTableWidgetItem('DL'))
self.tabela_matriz.setItem(11, i, QTableWidgetItem('DL'))
self.tabela_matriz.setItem(i, 11, QTableWidgetItem('DL'))
for i in range(1, 15, 12):
self.tabela_matriz.setItem(5, i, QTableWidgetItem('TL'))
self.tabela_matriz.setItem(i, 5, QTableWidgetItem('TL'))
self.tabela_matriz.setItem(9, i, QTableWidgetItem('TL'))
self.tabela_matriz.setItem(i, 9, QTableWidgetItem('TL'))
for i in range(2, 15, 10):
self.tabela_matriz.setItem(6, i, QTableWidgetItem('DL'))
self.tabela_matriz.setItem(i, 6, QTableWidgetItem('DL'))
self.tabela_matriz.setItem(8, i, QTableWidgetItem('DL'))
self.tabela_matriz.setItem(i, 8, QTableWidgetItem('DL'))
for i in range(3, 15, 8):
self.tabela_matriz.setItem(7, i, QTableWidgetItem('DL'))
self.tabela_matriz.setItem(i, 7, QTableWidgetItem('DL'))
for i in range(5, 11, 4):
self.tabela_matriz.setItem(5, i, QTableWidgetItem('TL'))
self.tabela_matriz.setItem(9, i, QTableWidgetItem('TL'))
for i in range(6, 10, 2):
self.tabela_matriz.setItem(6, i, QTableWidgetItem('DL'))
self.tabela_matriz.setItem(8, i, QTableWidgetItem('DL'))
#Função que printa o erro correspondente
def printError(self, erro):
string = ''
if (erro == enumError.er_exchBigger7):
string = 'ERRO: Impossível trocar mais que 7 letras.'
elif (erro == enumError.er_exchBiggerPack):
string = 'ERRO: Impossível trocar esta quantidade pois não há esta mesma quantidade de letras disponíveis.'
elif (erro == enumError.er_exchLetterNotFound):
string = 'ERRO: Impossível trocar pois há letras a serem trocadas que você não possui.'
elif (erro == enumError.er_inWordLine):
string = 'ERRO: A palavra a ser adicionada ultrapassa o mapa horizontalmente.'
elif (erro == enumError.er_inWordCol):
string = 'ERRO: A palavra a ser adicionada ultrapassa o mapa verticalmente.'
elif (erro == enumError.er_inWordInexist):
string = 'ERRO: A palavra a ser adicionada não existe no dicionário.'
elif (erro == enumError.er_inWordInitFail):
string = 'ERRO: A palavra a ser adicionada não atravessou o centro do mapa.'
elif (erro == enumError.er_inWordNotTableUsed):
string = 'ERRO: A palavra a ser adicionada não utilizou nenhuma outra letra do mapa.'
elif (erro == enumError.er_inWordNotPossibleIn):
string = 'ERRO: A palavra a ser adicionada não pode ser montada no mapa com suas letras.'
elif (erro == enumError.er_inWordConflict):
string = 'ERRO: A palavra a ser adicionada conflitou com outras palavras já presentes no mapa'
QMessageBox.about(self, "ERROR", string)
#Função facilitadora pois é muito utilizada no módulo
def listToStr(self, lista):
string = ''
for el in lista:
string += el + ','
return string[0:-1]
def __init__(self):
super(ListBox, self).__init__()
self.fileList = []
self.folderlist = []
self.allFolders = []
self.dir = QDir.homePath()
self.subdir = QDir.homePath()
self.setGeometry(0, 0, 800, 450)
self.setMinimumSize(500, 300)
self.setContentsMargins(10, 10, 10, 0)
self.setWindowIcon(QIcon.fromTheme('kfind'))
self.setWindowTitle("Find Files")
##toolbar######################################################
self.tb = self.addToolBar("Tools")
self.tb.setMovable(False)
self.tb.setContextMenuPolicy(Qt.PreventContextMenu)
self.findEdit = QLineEdit("*")
self.findAct = QAction(QIcon.fromTheme('edit-find'),
"find",
self,
statusTip="find Files",
triggered=self.findMyFiles)
self.findEdit.addAction(self.findAct, QLineEdit.LeadingPosition)
self.findEdit.setPlaceholderText("find")
self.findEdit.setToolTip("for example: *word*")
self.findEdit.setStatusTip("for example: *word*")
self.tb.addWidget(self.findEdit)
self.findEdit.returnPressed.connect(self.findMyFiles)
self.tb.addSeparator()
self.folderEdit = QLineEdit()
self.folderAct = QAction(QIcon.fromTheme('document-open'),
"change Folder",
self,
statusTip="change Folder",
triggered=self.changeFolder)
self.folderEdit.addAction(self.folderAct, QLineEdit.LeadingPosition)
self.folderEdit.setPlaceholderText("insert folder path")
self.folderEdit.setText(self.dir)
# self.folderEdit.textChanged.connect(self.setDir)
self.folderEdit.returnPressed.connect(self.findMyFiles)
self.tb.addWidget(self.folderEdit)
self.tb.addSeparator()
# self.addToolBarBreak()
self.noDot = QCheckBox("include hidden files")
# self.tb2 = self.addToolBar("hidden")
# self.tb2.addWidget(self.noDot)
##Listbox##########################################################
self.lb = QTableWidget()
self.lb.setSelectionBehavior(QAbstractItemView.SelectRows)
self.lb.setColumnCount(2)
self.lb.setColumnWidth(0, 300)
# self.lb.setSelectionBehavior(self.lb.SelectRows)
self.lb.setSelectionMode(self.lb.SingleSelection)
self.lb.cellDoubleClicked.connect(self.doubleClicked)
self.lb.itemClicked.connect(self.getItem)
self.lb.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.lb.horizontalHeader().setStretchLastSection(True)
self.lb.setAlternatingRowColors(True)
self.verticalHeader = QHeaderView(Qt.Vertical)
self.lb.setVerticalHeader(self.verticalHeader)
self.lb.horizontalHeader().setStretchLastSection(True)
self.lb.setHorizontalHeaderItem(0, QTableWidgetItem("Filename"))
self.lb.setHorizontalHeaderItem(1, QTableWidgetItem("Path"))
self.verticalHeader.setDefaultSectionSize(24)
self.lb.verticalHeader().hide()
self.lb.setToolTip(
"double click first column to open file\nsecond column to open file parent folder"
)
self.setCentralWidget(self.lb)
self.findEdit.setFocus()
self.statusBar().showMessage("Ready")
print("Welcome\nPython Version: " + sys.version[:5])
print("home is: " + home)
self.setStyleSheet(stylesheet(self))
self.copyBtn = QPushButton("copy filepath")
self.copyBtn.clicked.connect(self.copyPath)
self.copyBtn.setFlat(True)
self.statusBar().addPermanentWidget(self.copyBtn)
self.dir = self.folderEdit.text()
class History(QGroupBox):
def __init__(self, stu_mes):
super().__init__()
self.stu_mes = stu_mes
self.body = QVBoxLayout()
self.setTitleBar()
self.setTable()
self.setOut()
self.body.addStretch()
self.setLayout(self.body)
self.initUI()
# 标题栏
def setTitleBar(self):
self.title = QLabel()
self.title.setText('借阅记录')
self.title.setFixedHeight(25)
titleLayout = QHBoxLayout()
titleLayout.addSpacing(50)
titleLayout.addWidget(self.title)
self.titleBar = QWidget()
self.titleBar.setFixedSize(900, 50)
self.titleBar.setLayout(titleLayout)
self.body.addWidget(self.titleBar)
# 创建表格
def setTable(self, val: dict = None):
self.table = QTableWidget(1, 5)
self.table.setFixedHeight(400)
self.table.setContentsMargins(10, 10, 10, 10)
self.table.verticalHeader().setVisible(False)
self.table.horizontalHeader().setVisible(False)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.table.setFocusPolicy(Qt.NoFocus)
self.table.setColumnWidth(0, 200)
self.table.setColumnWidth(1, 250)
self.table.setColumnWidth(2, 175)
self.table.setColumnWidth(3, 175)
self.table.setColumnWidth(4, 100)
self.table.setItem(0, 0, QTableWidgetItem('书号'))
self.table.setItem(0, 1, QTableWidgetItem('书名'))
self.table.setItem(0, 2, QTableWidgetItem('借书日期'))
self.table.setItem(0, 3, QTableWidgetItem('还书日期'))
self.table.setItem(0, 4, QTableWidgetItem('罚金'))
for i in range(5):
self.table.item(0, i).setTextAlignment(Qt.AlignCenter)
self.table.item(0, i).setFont(QFont('微软雅黑', 15))
self.list = database.get_log(self.stu_mes['SID'])
for i in self.list:
self.insertRow(i)
self.body.addWidget(self.table)
# 插入行
def insertRow(self, val: list):
itemBID = QTableWidgetItem(val[1])
itemBID.setTextAlignment(Qt.AlignCenter)
itemNAME = QTableWidgetItem('《' + val[2] + '》')
itemNAME.setTextAlignment(Qt.AlignCenter)
itemBEGIN = QTableWidgetItem(val[3])
itemBEGIN.setTextAlignment(Qt.AlignCenter)
itemBACK = QTableWidgetItem(val[4])
itemBACK.setTextAlignment(Qt.AlignCenter)
itemPUNISHED = QLabel()
itemPUNISHED.setText(str(val[5]))
itemPUNISHED.setAlignment(Qt.AlignCenter)
if val[5] == 0:
itemPUNISHED.setStyleSheet('''
*{
color: green;
font-size: 20px;
}
''')
else:
itemPUNISHED.setStyleSheet('''
*{
color: red;
font-size: 20px;
}
''')
self.table.insertRow(1)
self.table.setItem(1, 0, itemBID)
self.table.setItem(1, 1, itemNAME)
self.table.setItem(1, 2, itemBEGIN)
self.table.setItem(1, 3, itemBACK)
self.table.setCellWidget(1, 4, itemPUNISHED)
# 导出文件
def setOut(self):
self.outButton = QToolButton()
self.outButton.setText('导出')
self.outButton.clicked.connect(self.outFunction)
self.outButton.setFixedSize(100, 50)
outLayout = QHBoxLayout()
outLayout.addStretch()
outLayout.addWidget(self.outButton)
outWidget = QWidget()
outWidget.setLayout(outLayout)
self.body.addWidget(outWidget)
def outFunction(self):
import csv
dirName = QFileDialog.getExistingDirectory(self, '选择文件夹')
title = ['SID', 'BID', 'BNAME', 'BORROW_DATE', 'BACK_DATE', 'PUNISHED']
with open(os.path.join(dirName, self.stu_mes['SID'] + '.csv'),
'w',
newline='') as f:
writer = csv.writer(f)
writer.writerow(title)
for row in self.list:
writer.writerow(row)
def initUI(self):
self.setFixedSize(1000, 600)
self.setStyleSheet('''
*{
background-color: white;
border:0px;
}
''')
self.titleBar.setStyleSheet('''
QWidget {
border:0;
background-color: rgba(216, 216, 216, 1);
border-radius: 20px;
color: rgba(113, 118, 121, 1);
}
QLabel{
font-size: 25px;
font-family: 微软雅黑;
}
''')
self.table.setStyleSheet('''
font-size:18px;
color: black;
background-color: white;
font-family: 微软雅黑;
''')
self.outButton.setStyleSheet('''
QToolButton{
border-radius: 10px;
background-color:rgba(52, 118, 176, 1);
color: white;
font-size: 25px;
font-family: 微软雅黑;
}
''')
def processUI(self):
### remove title bar
self.setWindowFlags(QtCore.Qt.FramelessWindowHint
| QtCore.Qt.WindowStaysOnBottomHint)
### background image and Fixed Size
back_label = QLabel(self)
back = QPixmap('.\\img\\33_back.png')
back_label.setPixmap(back)
self.setFixedSize(back.width(), back.height())
### close Button
self.close_Btn = QPushButton('', self)
self.close_Btn.setIcon(QIcon('.\\img\\close_Btn.png'))
self.close_Btn.setFixedSize(20, 20)
self.close_Btn.setIconSize(QtCore.QSize(30, 30))
self.close_Btn.move(back.width() - 40, 20)
self.close_Btn.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
### GIF set
self.moviee = QLabel(self)
self.movie = QtGui.QMovie(".\\img\\Processing.gif")
self.moviee.setMovie(self.movie)
self.moviee.setGeometry(50, 28, 320, 150)
self.movie.start()
### Pause Button
self.P_btn = QPushButton('', self)
self.P_btn.setIcon(QIcon('.\\img\\Pause.png'))
self.P_btn.setIconSize(QtCore.QSize(170, 90))
self.P_btn.setFixedSize(150, 70)
self.P_btn.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.P_btn.move(420, 60)
### Continue Button
self.C_btn = QPushButton('', self)
self.C_btn.setIcon(QIcon('.\\img\\Continue.png'))
self.C_btn.setIconSize(QtCore.QSize(170, 90))
self.C_btn.setFixedSize(150, 70)
self.C_btn.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.C_btn.move(420, 60)
### Cancel Button
self.Can_btn = QPushButton('', self)
self.Can_btn.setIcon(QIcon('.\\img\\Cancel.png'))
self.Can_btn.setIconSize(QtCore.QSize(170, 90))
self.Can_btn.setFixedSize(150, 70)
self.Can_btn.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.Can_btn.move(600, 60)
### Start Button
self.S_btn = QPushButton('', self)
self.S_btn.setIcon(QIcon('.\\img\\Start.png'))
self.S_btn.setIconSize(QtCore.QSize(170, 90))
self.S_btn.setFixedSize(150, 70)
self.S_btn.setCursor(QtGui.QCursor(QtCore.Qt.PointingHandCursor))
self.S_btn.move(600, 60)
### hide btn P & S
self.C_btn.setVisible(False)
self.S_btn.setVisible(False)
### Table Widget
self.tableWidget = QTableWidget(self)
self.tableWidget.setFixedSize(760, 370)
self.tableWidget.move(30, 200)
self.tableWidget.setColumnCount(3)
self.tableWidget.setColumnWidth(0, self.tableWidget.width() / 5.5)
self.tableWidget.setColumnWidth(1, self.tableWidget.width() / 2.5)
self.tableWidget.setColumnWidth(2, self.tableWidget.width() / 2.5)
### Btn Clicked
self.P_btn.clicked.connect(self.P_btn_clicked)
self.C_btn.clicked.connect(self.C_btn_clicked)
self.Can_btn.clicked.connect(self.Can_btn_clicked)
self.S_btn.clicked.connect(self.S_btn_clicked)
self.close_Btn.clicked.connect(self.close_Btn_clicked)
self.show()
self.gipThread = get_ip_thread(self)
self.gipThread.gipEvent.connect(self.gipThreadEventHandler)
self.gipThreadStart()
self.gregThread = get_registry_thread(self)
self.gregThread.gregEvent.connect(self.gregThreadEventHandler)
self.gregThreadStart()
self.gprocThread = get_proc_thread(self)
self.gprocThread.gprocEvent.connect(self.gprocThreadEventHandler)
self.gprocThreadStart()
self.gfileThread = get_file_thread(self)
self.gfileThread.gfileEvent.connect(self.gfileThreadEventHandler)
self.gfileThreadStart()
class Books(QGroupBox):
def __init__(self, stu_mes):
super().__init__()
self.stu_mes = stu_mes
self.book_list = []
self.body = QVBoxLayout()
self.table = None
self.setTitleBar()
self.setSearchBar()
self.searchFunction()
self.setLayout(self.body)
self.setFixedSize(1100, 600)
self.setMyStyle()
# 标题栏
def setTitleBar(self):
self.title = QLabel()
self.title.setText('书籍信息')
self.title.setFixedHeight(25)
titleLayout = QHBoxLayout()
titleLayout.addSpacing(50)
titleLayout.addWidget(self.title)
self.titleBar = QWidget()
self.titleBar.setFixedSize(900, 50)
self.titleBar.setLayout(titleLayout)
self.body.addWidget(self.titleBar)
# 设置搜索框
def setSearchBar(self):
self.searchTitle = QLabel()
self.searchTitle.setText('搜索书籍')
self.searchInput = QLineEdit()
self.searchInput.setText('ID/书名/作者/出版社')
self.searchInput.setClearButtonEnabled(True)
self.searchInput.setFixedSize(400, 40)
self.searchButton = QToolButton()
self.searchButton.setFixedSize(100, 40)
self.searchButton.setText('搜索')
self.searchButton.clicked.connect(self.searchFunction)
searchLayout = QHBoxLayout()
searchLayout.addStretch()
searchLayout.addWidget(self.searchTitle)
searchLayout.addWidget(self.searchInput)
searchLayout.addWidget(self.searchButton)
searchLayout.addStretch()
self.searchWidget = QWidget()
self.searchWidget.setLayout(searchLayout)
self.body.addWidget(self.searchWidget)
# 搜索方法
def searchFunction(self):
self.book_list = database.search_book(self.searchInput.text(),
self.stu_mes['SID'])
if self.book_list == []:
print('未找到')
if self.table is not None:
self.table.deleteLater()
self.setTable()
# 设置表格
def setTable(self):
self.table = QTableWidget(1, 8)
self.table.setContentsMargins(10, 10, 10, 10)
self.table.verticalHeader().setVisible(False)
self.table.horizontalHeader().setVisible(False)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.table.setFocusPolicy(Qt.NoFocus)
self.table.setItem(0, 0, QTableWidgetItem('书号'))
self.table.setItem(0, 1, QTableWidgetItem('书名'))
self.table.setItem(0, 2, QTableWidgetItem('作者'))
self.table.setItem(0, 3, QTableWidgetItem('出版日期'))
self.table.setItem(0, 4, QTableWidgetItem('出版社'))
self.table.setItem(0, 5, QTableWidgetItem('位置'))
self.table.setItem(0, 6, QTableWidgetItem('总数/剩余'))
self.table.setItem(0, 7, QTableWidgetItem('操作'))
for i in range(8):
self.table.item(0, i).setTextAlignment(Qt.AlignCenter)
self.table.item(0, i).setFont(QFont('微软雅黑', 15))
# 显示借阅详情
for i in self.book_list:
self.insertRow(i)
self.body.addWidget(self.table)
# 插入行
def insertRow(self, val: list):
itemBID = QTableWidgetItem(val[0])
itemBID.setTextAlignment(Qt.AlignCenter)
itemNAME = QTableWidgetItem('《' + val[1] + '》')
itemNAME.setTextAlignment(Qt.AlignCenter)
itemAUTHOR = QTableWidgetItem(val[2])
itemAUTHOR.setTextAlignment(Qt.AlignCenter)
itemDATE = QTableWidgetItem(val[3])
itemDATE.setTextAlignment(Qt.AlignCenter)
itemPRESS = QTableWidgetItem(val[4])
itemPRESS.setTextAlignment(Qt.AlignCenter)
itemPOSITION = QTableWidgetItem(val[5])
itemPOSITION.setTextAlignment(Qt.AlignCenter)
itemSUM = QTableWidgetItem(str(val[6]) + '/' + str(val[7]))
itemSUM.setTextAlignment(Qt.AlignCenter)
itemOPERATE = QToolButton(self.table)
itemOPERATE.setFixedSize(70, 25)
if val[-1] == '借书':
itemOPERATE.setText('借书')
itemOPERATE.clicked.connect(lambda: self.borrowBook(val[0]))
itemOPERATE.setStyleSheet('''
*{
color: white;
font-family: 微软雅黑;
background: rgba(38, 175, 217, 1);
border: 0;
border-radius: 10px;
font-size:18px;
}
''')
else:
itemOPERATE.setText('不可借')
itemOPERATE.setEnabled(False)
itemOPERATE.setToolTip(val[-1])
QToolTip.setFont(QFont('微软雅黑', 15))
itemOPERATE.setStyleSheet('''
QToolButton{
color: white;
font-family: 微软雅黑;
background: rgba(200, 200, 200, 1);
border: 0;
border-radius: 10px;
font-size:18px;
}
QToolTip{
color: black;
border: 1px solid rgba(200, 200, 200, 1);
}
''')
itemLayout = QHBoxLayout()
itemLayout.setContentsMargins(0, 0, 0, 0)
itemLayout.addWidget(itemOPERATE)
itemWidget = QWidget()
itemWidget.setLayout(itemLayout)
self.table.insertRow(1)
self.table.setItem(1, 0, itemBID)
self.table.setItem(1, 1, itemNAME)
self.table.setItem(1, 2, itemAUTHOR)
self.table.setItem(1, 3, itemDATE)
self.table.setItem(1, 4, itemPRESS)
self.table.setItem(1, 5, itemPOSITION)
self.table.setItem(1, 6, itemSUM)
self.table.setCellWidget(1, 7, itemWidget)
def borrowBook(self, BID: str):
ans = database.borrow_book(BID, self.stu_mes['SID'])
# 刷新表格
if ans:
self.searchFunction()
def setMyStyle(self):
self.setStyleSheet('''
*{
background-color: white;
border:0px;
}
''')
self.titleBar.setStyleSheet('''
QWidget {
border:0;
background-color: rgba(216, 216, 216, 1);
border-radius: 20px;
color: rgba(113, 118, 121, 1);
}
QLabel{
font-size: 25px;
font-family: 微软雅黑;
}
''')
self.searchTitle.setStyleSheet('''
QLabel{
font-size:20px;
color: black;
font-family: 微软雅黑;
}
''')
self.searchInput.setStyleSheet('''
QLineEdit{
border: 1px solid rgba(201, 201, 201, 1);
border-radius: 5px;
color: rgba(120, 120, 120, 1)
}
''')
self.searchButton.setStyleSheet('''
QToolButton{
border-radius: 10px;
background-color:rgba(52, 118, 176, 1);
color: white;
font-size: 25px;
font-family: 微软雅黑;
}
''')
def __init__(self, parent=None):
super(PYQT_BD, self).__init__(parent)
# Creamos una tabla en donde organizaremos los datos
self.table = QTableWidget(0, 3)
self.table.setHorizontalHeaderLabels(['ID', 'NOMBRE', 'APELLIDO'
]) # Tabla con 3 columnas
self.table.setAlternatingRowColors(True)
self.table.setEditTriggers(QTableWidget.NoEditTriggers)
self.table.setSelectionBehavior(QTableWidget.SelectRows)
self.table.setSelectionMode(QTableWidget.SingleSelection)
self.lblID = QLabel("ID:") # Campo de texto para ingresar ID
self.txtID = QLineEdit()
self.txtID.setPlaceholderText("Numero identificador unico")
self.lblName = QLabel("Nombre:") # Campo de texto para ingresar nombre
self.txtName = QLineEdit()
self.txtName.setPlaceholderText("Nombre de la persona")
self.lblApellido = QLabel(
"Apellido:") # Campo de texto para ingresar apellido
self.txtApellido = QLineEdit()
self.txtApellido.setPlaceholderText("Apellido de la persona")
grid = QGridLayout(
) # Declaramo sun gridlayout en donde ingresaremos todos los widget
grid.addWidget(self.lblID, 0, 0)
grid.addWidget(self.txtID, 0, 1)
grid.addWidget(self.lblName, 1, 0)
grid.addWidget(self.txtName, 1, 1)
grid.addWidget(self.lblApellido, 2, 0)
grid.addWidget(self.txtApellido, 2, 1)
btnCargar = QPushButton(
'Cargar Datos') # Boton para cargar y mostrar los datos
btnCargar.clicked.connect(
self.cargarDatos) # función al hacer click sobre el boton
btnInsertar = QPushButton('Insertar') # Boton agregar datos
btnInsertar.clicked.connect(
self.insertarDatos) # función al hacer click sobre el boton
btnEliminar = QPushButton('Eliminar') # Boton para eliminar datos
btnEliminar.clicked.connect(self.eliminarDatos)
hbx = QHBoxLayout() # Declaramos un QHBoxLayout
# Agregamos los elementos al layout
hbx.addWidget(btnCargar)
hbx.addWidget(btnInsertar)
hbx.addWidget(btnEliminar)
vbx = QVBoxLayout()
vbx.addLayout(grid)
vbx.addLayout(hbx)
vbx.setAlignment(Qt.AlignTop)
vbx.addWidget(self.table)
self.setWindowTitle(
"PyQT - Base de datos (SQLite)") # Titulo de la ventana
self.resize(362, 320) # Tamaño de la ventana
self.setLayout(vbx) # Layout de la ventana
class LabelAssistDialog(QDialog):
"""
A simple UI for showing bookmarks and navigating to them.
FIXME: For now, this window is tied to a particular lane.
If your project has more than one lane, then each one
will have it's own bookmark window, which is kinda dumb.
"""
def __init__(self, parent, topLevelOperatorView):
super(LabelAssistDialog, self).__init__(parent)
# Create thread router to populate table on main thread
self.threadRouter = ThreadRouter(self)
# Set object classification operator view
self.topLevelOperatorView = topLevelOperatorView
self.setWindowTitle("Label Assist")
self.setMinimumWidth(500)
self.setMinimumHeight(700)
layout = QGridLayout()
layout.setContentsMargins(10, 10, 10, 10)
# Show variable importance table
rows = 0
columns = 4
self.table = QTableWidget(rows, columns)
self.table.setHorizontalHeaderLabels(
["Frame", "Max Area", "Min Area", "Labels"])
self.table.verticalHeader().setVisible(False)
# Select full row on-click and call capture double click
self.table.setSelectionBehavior(QTableView.SelectRows)
self.table.doubleClicked.connect(self._captureDoubleClick)
layout.addWidget(self.table, 1, 0, 3, 2)
# Create progress bar
self.progressBar = QProgressBar()
self.progressBar.setMinimum(0)
self.progressBar.setMaximum(0)
self.progressBar.hide()
layout.addWidget(self.progressBar, 4, 0, 1, 2)
# Create button to populate table
self.computeButton = QPushButton("Compute object info")
self.computeButton.clicked.connect(self._triggerTableUpdate)
layout.addWidget(self.computeButton, 5, 0)
# Create close button
closeButton = QPushButton("Close")
closeButton.clicked.connect(self.close)
layout.addWidget(closeButton, 5, 1)
# Set dialog layout
self.setLayout(layout)
def _triggerTableUpdate(self):
# Check that object area is included in selected features
featureNames = self.topLevelOperatorView.SelectedFeatures.value
if "Standard Object Features" not in featureNames or "Count" not in featureNames[
"Standard Object Features"]:
box = QMessageBox(
QMessageBox.Warning,
"Warning",
'Object area is not a selected feature. Please select this feature on: "Standard Object Features > Shape > Size in pixels"',
QMessageBox.NoButton,
self,
)
box.show()
return
# Clear table
self.table.clearContents()
self.table.setRowCount(0)
self.table.setSortingEnabled(False)
self.progressBar.show()
self.computeButton.setEnabled(False)
def compute_features_for_frame(tIndex, t, features):
# Compute features and labels (called in parallel from request pool)
roi = [
slice(None) for i in range(
len(self.topLevelOperatorView.LabelImages.meta.shape))
]
roi[tIndex] = slice(t, t + 1)
roi = tuple(roi)
frame = self.topLevelOperatorView.SegmentationImages(roi).wait()
frame = frame.squeeze().astype(numpy.uint32, copy=False)
# Dirty trick: We don't care what we're passing here for the 'image' parameter,
# but vigra insists that we pass *something*, so we'll cast the label image as float32.
features[t] = vigra.analysis.extractRegionFeatures(
frame.view(numpy.float32), frame, ["Count"], ignoreLabel=0)
tIndex = self.topLevelOperatorView.SegmentationImages.meta.axistags.index(
"t")
tMax = self.topLevelOperatorView.SegmentationImages.meta.shape[tIndex]
features = {}
labels = {}
def compute_all_features():
# Compute features in parallel
pool = RequestPool()
for t in range(tMax):
pool.add(
Request(
partial(compute_features_for_frame, tIndex, t,
features)))
pool.wait()
# Compute labels
labels = self.topLevelOperatorView.LabelInputs([]).wait()
req = Request(compute_all_features)
req.notify_finished(partial(self._populateTable, features, labels))
req.submit()
@threadRouted
def _populateTable(self, features, labels, *args):
self.progressBar.hide()
self.computeButton.setEnabled(True)
for time, feature in features.items():
# Insert row
rowNum = self.table.rowCount()
self.table.insertRow(self.table.rowCount())
# Get max and min object areas
areas = feature[
"Count"] # objectFeatures['Standard Object Features']['Count']
maxObjArea = numpy.max(areas[numpy.nonzero(areas)])
minObjArea = numpy.min(areas[numpy.nonzero(areas)])
# Get number of labeled objects
labelNum = numpy.count_nonzero(labels[time])
# Load fram number
item = QTableWidgetItem(str(time))
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.table.setItem(rowNum, 0, item)
# Load max object areas
item = QTableWidgetItemWithFloatSorting(
str("{: .02f}".format(maxObjArea)))
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.table.setItem(rowNum, 1, item)
# Load min object areas
item = QTableWidgetItemWithFloatSorting(
str("{: .02f}".format(minObjArea)))
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.table.setItem(rowNum, 2, item)
# Load label numbers
item = QTableWidgetItemWithFloatSorting(
str("{: .01f}".format(labelNum)))
item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsEnabled)
self.table.setItem(rowNum, 3, item)
# Resize column size to fit dialog size
self.table.horizontalHeader().setSectionResizeMode(QHeaderView.Stretch)
# Sort by max object area
self.table.setSortingEnabled(True)
self.table.sortByColumn(1, Qt.DescendingOrder)
def _captureDoubleClick(self):
# Navigate to selected frame
index = self.table.selectedIndexes()[0]
frameStr = self.table.item(index.row(), 0).text()
if frameStr:
frameNum = int(frameStr)
self.parent().editor.posModel.time = frameNum
class BorrowingBooks(QGroupBox):
def __init__(self, stu_mes):
super().__init__()
self.stu_mes = stu_mes
self.body = QVBoxLayout()
self.setTitleBar()
self.setTable()
self.setLayout(self.body)
self.initUI()
# 标题栏
def setTitleBar(self):
self.title = QLabel()
self.title.setText('借阅信息')
self.title.setFixedHeight(25)
titleLayout = QHBoxLayout()
titleLayout.addSpacing(50)
titleLayout.addWidget(self.title)
self.titleBar = QWidget()
self.titleBar.setFixedSize(900, 50)
self.titleBar.setLayout(titleLayout)
self.body.addWidget(self.titleBar)
def setTable(self, val: dict = None):
self.table = QTableWidget(1, 6)
self.table.setContentsMargins(10, 10, 10, 10)
self.table.verticalHeader().setVisible(False)
self.table.horizontalHeader().setVisible(False)
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.table.setFocusPolicy(Qt.NoFocus)
self.table.setColumnWidth(0, 150)
self.table.setColumnWidth(1, 150)
self.table.setColumnWidth(2, 175)
self.table.setColumnWidth(3, 175)
self.table.setColumnWidth(4, 100)
self.table.setColumnWidth(5, 150)
self.table.setItem(0, 0, QTableWidgetItem('书号'))
self.table.setItem(0, 1, QTableWidgetItem('书名'))
self.table.setItem(0, 2, QTableWidgetItem('借书日期'))
self.table.setItem(0, 3, QTableWidgetItem('还书日期'))
self.table.setItem(0, 4, QTableWidgetItem('罚金'))
self.table.setItem(0, 5, QTableWidgetItem('操作'))
for i in range(6):
self.table.item(0, i).setTextAlignment(Qt.AlignCenter)
self.table.item(0, i).setFont(QFont('微软雅黑', 15))
self.body.addWidget(self.table)
# 显示借阅详情
self.book_list = database.get_borrowing_books(self.stu_mes['SID'])
for i in self.book_list:
self.insertRow(i)
self.table.setStyleSheet('''
*{
font-size:18px;
color: black;
background-color: white;
font-family: 微软雅黑;
}
''')
# 插入行
def insertRow(self, val: list):
itemBID = QTableWidgetItem(val[1])
itemBID.setTextAlignment(Qt.AlignCenter)
itemNAME = QTableWidgetItem('《' + val[2] + '》')
itemNAME.setTextAlignment(Qt.AlignCenter)
itemBEGIN = QTableWidgetItem(val[3])
itemBEGIN.setTextAlignment(Qt.AlignCenter)
itemBACK = QTableWidgetItem(val[4])
itemBACK.setTextAlignment(Qt.AlignCenter)
itemPUNISHED = QLabel()
itemPUNISHED.setText('0')
itemPUNISHED.setAlignment(Qt.AlignCenter)
isPunished = database.days_between(val[4],
time.strftime("%Y-%m-%d-%H:%M"))
if isPunished <= 0:
itemPUNISHED.setStyleSheet('''
*{
color: green;
font-size:20px;
font-family: 微软雅黑;
}
''')
else:
itemPUNISHED.setText(str(isPunished))
itemPUNISHED.setStyleSheet('''
*{
color: red;
font-size:20px;
font-family: 微软雅黑;
}
''')
itemOPERATE = QToolButton(self.table)
itemOPERATE.setFixedSize(70, 25)
if isPunished <= 0:
itemOPERATE.setText('还书')
itemOPERATE.clicked.connect(lambda: self.retrurnBook(val[1]))
itemOPERATE.setStyleSheet('''
*{
color: white;
font-family: 微软雅黑;
background: rgba(38, 175, 217, 1);
border: 0;
border-radius: 10px;
font-size:18px;
}
''')
else:
itemOPERATE.setText('交罚金')
itemOPERATE.clicked.connect(lambda: self.pay(val[1], isPunished))
itemOPERATE.setStyleSheet('''
*{
color: white;
font-family: 微软雅黑;
background: rgba(222, 52, 65, 1);
border: 0;
border-radius: 10px;
font-size:18px;
}
''')
itemLayout = QHBoxLayout()
itemLayout.setContentsMargins(0, 0, 0, 0)
itemLayout.addWidget(itemOPERATE)
itemWidget = QWidget()
itemWidget.setLayout(itemLayout)
self.table.insertRow(1)
self.table.setItem(1, 0, itemBID)
self.table.setItem(1, 1, itemNAME)
self.table.setItem(1, 2, itemBEGIN)
self.table.setItem(1, 3, itemBACK)
self.table.setCellWidget(1, 4, itemPUNISHED)
self.table.setCellWidget(1, 5, itemWidget)
def retrurnBook(self, BID: str):
ans = database.return_book(BID, self.stu_mes['SID'])
# 刷新表格
if ans:
self.book_list = database.get_borrowing_books(self.stu_mes['SID'])
self.table.deleteLater()
self.setTable()
def pay(self, BID: str, PUNISH):
ans = database.pay(BID, self.stu_mes['SID'], PUNISH)
# 刷新表格
if ans:
self.book_list = database.get_borrowing_books(self.stu_mes['SID'])
self.table.deleteLater()
self.setTable()
def initUI(self):
self.setFixedSize(1000, 600)
self.setStyleSheet('''
*{
background-color: white;
border:0px;
}
''')
self.titleBar.setStyleSheet('''
QWidget {
border:0;
background-color: rgba(216, 216, 216, 1);
border-radius: 20px;
color: rgba(113, 118, 121, 1);
}
QLabel{
font-size: 25px;
font-family: 微软雅黑;
}
''')
