class LogViewer(ScreenWithBackButton):
def __init__(self, controller, mainWindow):
self.controller = controller
ScreenWithBackButton.__init__(self, "System Log", mainWindow)
def makeContent(self):
layout = QVBoxLayout()
self.table = QTableWidget()
layout.addWidget(self.table)
return layout
@handlePyroErrors
def displayLog(self):
entries = self.controller.getLog()
self.table.clearContents()
self.table.setRowCount(len(entries))
self.table.setColumnCount(3)
self.table.setHorizontalHeaderLabels(["Time", "Severity", "Message"])
i = 0
for entry in entries:
self.table.setItem(i, 0, QTableWidgetItem(entry.asctime))
self.table.setItem(i, 1, QTableWidgetItem(entry.levelname))
self.table.setItem(i, 2, QTableWidgetItem(entry.message))
i = i + 1
self.table.resizeColumnsToContents()
self.table.horizontalHeader().setStretchLastSection(True)
self.table.scrollToBottom()
class SelectActivities(QDialog):
select = Signal()
def __init__(self, parent = None):
super(SelectActivities, self).__init__(parent)
layout = QVBoxLayout(self)
self.table = QTableWidget(parent)
self.table.setColumnCount(3)
self.table.setHorizontalHeaderLabels(["", "Date", "Size"])
self.table.setColumnWidth(0, 25)
self.table.setColumnWidth(1, 100)
self.table.setColumnWidth(3, 80)
layout.addWidget(self.table)
self.buttonbox = QDialogButtonBox(
QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
self.buttonbox.accepted.connect(self.accept)
self.buttonbox.rejected.connect(self.reject)
self.select.connect(self._select)
layout.addWidget(self.buttonbox)
self.setMinimumSize(320, 200)
def selectActivities(self, antfiles):
logger.debug("SelectActivities.selectActivities")
self.antfiles = antfiles
self.lock = threading.Condition()
self.lock.acquire()
self.select.emit()
logger.debug("SelectActivities.selectActivities: signal emitted")
self.lock.wait()
self.lock.release()
logger.debug("SelectActivities.selectActivities: returning %s selected activities", len(self._selected))
return self._selected
def _select(self):
logger.debug("SelectActivities._select")
self.table.clear()
self.table.setRowCount(len(self.antfiles))
for row in range(len(self.antfiles)):
f = self.antfiles[row]
self.table.setCellWidget(row, 0, QCheckBox(self))
self.table.setItem(row, 1,
QTableWidgetItem(f.get_date().strftime("%d %b %Y %H:%M")))
self.table.setItem(row, 2,
QTableWidgetItem("{:d}".format(f.get_size())))
result = self.exec_()
self._selected = []
if result == QDialog.Accepted:
for i in range(len(self.antfiles)):
f = self.antfiles[i]
cb = self.table.cellWidget(i, 0)
if cb.isChecked():
self._selected.append(f)
self.lock.acquire()
logger.debug("SelectActivities._select: lock acquired")
self.lock.notify()
self.lock.release()
class DSPToolMainWindow(QMainWindow):
"""
"""
def __init__(self):
QMainWindow.__init__(self)
self.project = None
menuBar = QMenuBar()
self.fileMenu = DSPToolFileMenu(self)
menuBar.addMenu(self.fileMenu)
self.signalMenu = DSPToolSignalsMenu(self)
menuBar.addMenu(self.signalMenu)
self.setMenuBar(menuBar)
self.mainWidget=QTableWidget()
self.mainWidget.setRowCount(0)
self.mainWidget.setColumnCount(0)
scrollWidget = QScrollArea()
scrollWidget.setWidget(self.mainWidget)
scrollWidget.setWidgetResizable(True)
self.setCentralWidget(scrollWidget)
def refreshTable(self):
i = 0
for x in self.project.signalList:
j=0
self.mainWidget.setRowCount(self.mainWidget.rowCount()+1)
for y in x:
print "entrou"
if self.mainWidget.columnCount() < j+1: self.mainWidget.setColumnCount(self.mainWidget.columnCount()+1)
label = y.getImage()
self.mainWidget.setCellWidget(i,j,label)
self.mainWidget.resizeColumnsToContents()
self.mainWidget.resizeRowsToContents()
j+=1
i+=1
class ReportMovementPanel(PanelWithTable):
columnList = "EVENT_ID;EVENT_TYPE; EVENT_SUB_TYPE; EVENT_DIRECTION; ASSET_NAME; EVENT_DATE; QUANTITY; PRICE; RATE; GROSS_AMOUNT; NET_AMOUNT; COMMISSION_PERCENTAGE; COMMISSION_AMOUNT; COMMISSION_IVA_AMOUNT; TENOR; MATURITY_DATE; CUSTODY_NAME; TAX_ID; TAX_AMOUNT; COMMENT; EXTERNAL_ID".split(
";")
def __init__(self):
super(self.__class__, self).__init__()
self.layout = QtGui.QGridLayout(self)
self.reportMovementFilter = ReportMovementFilter(self)
self.layout.addWidget(self.reportMovementFilter, 1, 0,
QtCore.Qt.AlignTop)
self.layout.addWidget(self.createTable(), 1, 1, QtCore.Qt.AlignTop)
def createTable(self):
self.table = QTableWidget()
self.table.setRowCount(1000)
self.table.setColumnCount(len(self.columnList))
self.table.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
self.table.setHorizontalHeaderLabels(self.columnList)
#self.pnLTableWidget.resizeColumnsToContents()
self.table.sortItems(Constant.CONST_COLUMN_REPORT_MOVEMENT_EVENT_DATE)
self.table.resizeRowsToContents()
self.table.setFixedSize(1100, 900)
return self.table
def doSubmit(self, fromDate, toDate, movementType, assetName, custodyName):
reportMovementLO = Engine.getReportMovementList(
fromDate, toDate, movementType, assetName, custodyName)
self.table.setSortingEnabled(False)
self.table.clearContents()
self.table.setRowCount(len(reportMovementLO.movementList))
self.renderTable(reportMovementLO.movementList)
self.table.setSortingEnabled(True)
self.table.resizeRowsToContents()
def renderTable(self, tableList):
row = 0
isBold = False
for listItem in tableList:
self.addItemtoTable(self.table, listItem, row,
Constant.CONST_COLUMN_REPORT_MOVEMENT_EVENT_ID,
isBold)
self.addItemtoTable(
self.table, listItem, row,
Constant.CONST_COLUMN_REPORT_MOVEMENT_EVENT_TYPE, isBold)
self.addItemtoTable(
self.table, listItem, row,
Constant.CONST_COLUMN_REPORT_MOVEMENT_EVENT_SUB_TYPE, isBold)
self.addItemtoTable(
self.table, listItem, row,
Constant.CONST_COLUMN_REPORT_MOVEMENT_EVENT_DIRECTION, isBold)
self.addItemtoTable(
self.table, listItem, row,
Constant.CONST_COLUMN_REPORT_MOVEMENT_ASSET_NAME, isBold)
self.addItemtoTable(
self.table, listItem, row,
Constant.CONST_COLUMN_REPORT_MOVEMENT_EVENT_DATE, isBold)
self.addItemtoTable(self.table, listItem, row,
Constant.CONST_COLUMN_REPORT_MOVEMENT_QUANTITY,
isBold)
self.addItemtoTable(self.table, listItem, row,
Constant.CONST_COLUMN_REPORT_MOVEMENT_PRICE,
isBold)
self.addItemtoTable(self.table, listItem, row,
Constant.CONST_COLUMN_REPORT_MOVEMENT_RATE,
isBold)
self.addItemtoTable(
self.table, listItem, row,
Constant.CONST_COLUMN_REPORT_MOVEMENT_GROSS_AMOUNT, isBold)
self.addItemtoTable(
self.table, listItem, row,
Constant.CONST_COLUMN_REPORT_MOVEMENT_NET_AMOUNT, isBold)
self.addItemtoTable(
self.table, listItem, row,
Constant.CONST_COLUMN_REPORT_MOVEMENT_COMMISSION_PERCENTAGE,
isBold)
self.addItemtoTable(
self.table, listItem, row,
Constant.CONST_COLUMN_REPORT_MOVEMENT_COMMISSION_AMOUNT,
isBold)
self.addItemtoTable(
self.table, listItem, row,
Constant.CONST_COLUMN_REPORT_MOVEMENT_COMMISSION_IVA_AMOUNT,
isBold)
self.addItemtoTable(self.table, listItem, row,
Constant.CONST_COLUMN_REPORT_MOVEMENT_TENOR,
isBold)
self.addItemtoTable(
self.table, listItem, row,
Constant.CONST_COLUMN_REPORT_MOVEMENT_CUSTODY_NAME, isBold)
self.addItemtoTable(self.table, listItem, row,
Constant.CONST_COLUMN_REPORT_MOVEMENT_TAX_ID,
isBold)
self.addItemtoTable(
self.table, listItem, row,
Constant.CONST_COLUMN_REPORT_MOVEMENT_TAX_AMOUNT, isBold)
self.addItemtoTable(self.table, listItem, row,
Constant.CONST_COLUMN_REPORT_MOVEMENT_COMMENT,
isBold)
self.addItemtoTable(
self.table, listItem, row,
Constant.CONST_COLUMN_REPORT_MOVEMENT_EXTERNAL_ID, isBold)
row += 1
class CCParsedTab(QWidget):
def __init__(self, parser_result):
QWidget.__init__(self)
self._parser_result = parser_result
layout = QHBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
layout.setSizeConstraint(QHBoxLayout.SetMinimumSize)
self.table_widget = QTableWidget()
self.table_widget.setSelectionMode(QAbstractItemView.NoSelection)
self.table_widget.setRowCount(2)
self.table_widget.setColumnCount(2)
self.table_widget.horizontalHeader().setResizeMode(QHeaderView.Stretch)
self.table_widget.setHorizontalHeaderLabels(["Dimension", "Choice"])
self.table_widget.verticalHeader().setVisible(False)
self.table_widget.verticalHeader().setResizeMode(QHeaderView.Fixed)
self.table_widget.verticalHeader().setDefaultSectionSize(20)
sp_table = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
sp_table.setHorizontalStretch(1)
self.table_widget.setSizePolicy(sp_table)
layout.addWidget(self.table_widget)
self.text_widget = QTextEdit()
sp_text = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred)
sp_text.setHorizontalStretch(4)
self.text_widget.setReadOnly(True)
self.text_widget.setSizePolicy(sp_text)
self.text_widget.setStyleSheet('font: 9pt "Courier";')
self.text_widget.setText(self._parser_result.get_text())
layout.addWidget(self.text_widget)
self.setLayout(layout)
self._fill_table()
def _fill_table(self):
colors = ["yellow", "orange", "green", "red"]
dimensions = self._parser_result.get_dimensions()
row = 0
for dimension in dimensions:
dimension_name = QLabel(dimension[0])
dimension_name.setStyleSheet("background: %s" % colors[row % len(colors)])
self.table_widget.setCellWidget(row, 0, dimension_name)
choices_widget = QComboBox()
choices = dimension[1]
choices.insert(0, "No choice")
choices_widget.addItems(choices)
choices_widget.setStyleSheet("background: white")
choices_widget.setStyleSheet("border: none")
choices_widget.currentIndexChanged.connect(self.on_choice_change)
self.table_widget.setCellWidget(row, 1, choices_widget)
row += 1
@Slot()
def on_choice_change(self):
text = self._parser_result.get_text()
for row in range(self.table_widget.rowCount()):
label = self.table_widget.cellWidget(row, 0)
choices = self.table_widget.cellWidget(row, 1)
if choices.currentIndex() == 0:
continue
regex = self._build_regex(label.text(), choices.count() - 1)
pattern = re.compile(regex)
matches = pattern.search(text)
for match in matches.groups():
results = re.search("<(.+)>", match)
variants = [s.strip() for s in results.groups()[0].split(",")]
text = text.replace(match, variants[choices.currentIndex() - 1])
self.text_widget.setText(text)
@staticmethod
def _build_regex(dim, count):
regex = "(" + dim + "<"
for i in range(count):
regex += ".+,[ ]?"
regex = regex[:-5]
regex += ">)"
return regex
class ui(QWidget):
def __init__(self):
QWidget.__init__(self)
self.setupUI()
self.id = 1
self.lines = []
self.editable = True
self.des_sort = True
self.faker = Factory.create()
self.btn_add.clicked.connect(self.add_line)
self.btn_del.clicked.connect(self.del_line)
self.btn_modify.clicked.connect(self.modify_line)
self.btn_select_line.clicked.connect(self.select_line)
self.btn_select_single.clicked.connect(self.deny_muti_line)
self.btn_sort.clicked.connect(self.sortItem)
self.btn_set_header.clicked.connect(self.setheader)
self.btn_set_middle.clicked.connect(self.middle)
self.table.cellChanged.connect(self.cellchange)
self.btn_noframe.clicked.connect(self.noframe)
# # Sess = sessionmaker(bind = engine)
def setupUI(self):
self.setWindowTitle(windowTital)
self.resize(640, 480)
self.table = QTableWidget(self)
self.btn_add = QPushButton(u'增加')
self.btn_del = QPushButton(u'删除')
self.btn_modify = QPushButton(u'可以编辑')
self.btn_select_line = QPushButton(u'选择整行')
self.btn_select_single = QPushButton(u'禁止选多行')
self.btn_sort = QPushButton(u'以分数排序')
self.btn_set_header = QPushButton(u'标头设置')
self.btn_set_middle = QPushButton(u'文字居中加颜色')
self.btn_noframe = QPushButton(u'取消边框颜色交替')
self.spacerItem = QSpacerItem(20, 20, QSizePolicy.Minimum,
QSizePolicy.Expanding)
self.vbox = QVBoxLayout()
self.vbox.addWidget(self.btn_add)
self.vbox.addWidget(self.btn_del)
self.vbox.addWidget(self.btn_modify)
self.vbox.addWidget(self.btn_select_line)
self.vbox.addWidget(self.btn_select_single)
self.vbox.addWidget(self.btn_sort)
self.vbox.addWidget(self.btn_set_header)
self.vbox.addWidget(self.btn_set_middle)
self.vbox.addWidget(self.btn_noframe)
self.vbox.addSpacerItem(
self.spacerItem) #可以用addItem也可以用addSpacerItem方法添加，没看出哪里不一样
self.txt = QLabel()
self.txt.setMinimumHeight(50)
self.vbox2 = QVBoxLayout()
self.vbox2.addWidget(self.table)
self.vbox2.addWidget(self.txt)
self.hbox = QHBoxLayout()
self.hbox.addLayout(self.vbox2)
self.hbox.addLayout(self.vbox)
self.setLayout(self.hbox)
self.table.setColumnCount(4) ##设置列数
self.headers = [u'id', u'选择', u'姓名', u'成绩', u'住址']
self.table.setHorizontalHeaderLabels(self.headers)
self.show()
def add_line(self):
self.table.cellChanged.disconnect()
row = self.table.rowCount()
self.table.setRowCount(row + 1)
id = str(self.id)
ck = QCheckBox()
h = QHBoxLayout()
h.setAlignment(Qt.AlignCenter)
h.addWidget(ck)
w = QWidget()
w.setLayout(h)
name = self.faker.name()
score = str(random.randint(50, 99))
add = self.faker.address()
self.table.setItem(row, 0, QTableWidgetItem(id))
self.table.setCellWidget(row, 1, w)
self.table.setItem(row, 2, QTableWidgetItem(name))
self.table.setItem(row, 3, QTableWidgetItem(score))
self.table.setItem(row, 4, QTableWidgetItem(add))
self.id += 1
self.lines.append([id, ck, name, score, add])
self.settext(u'自动生成随机一行数据！,checkbox设置为居中显示')
self.table.cellChanged.connect(self.cellchange)
def del_line(self):
removeline = []
for line in self.lines:
if line[1].isChecked():
row = self.table.rowCount()
for x in range(row, 0, -1):
if line[0] == self.table.item(x - 1, 0).text():
self.table.removeRow(x - 1)
removeline.append(line)
for line in removeline:
self.lines.remove(line)
self.settext(u'删除在左边checkbox中选中的行，使用了一个笨办法取得行号\n，不知道有没有其他可以直接取得行号的方法！')
def modify_line(self):
if self.editable == True:
self.table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.btn_modify.setText(u'禁止编辑')
self.editable = False
else:
self.table.setEditTriggers(QAbstractItemView.AllEditTriggers)
self.btn_modify.setText(u'可以编辑')
self.editable = True
self.settext(u'设置，是否可以编辑整个表格')
def select_line(self):
if self.table.selectionBehavior() == 0:
self.table.setSelectionBehavior(1)
self.btn_select_line.setStyleSheet('background-color:lightblue')
else:
self.table.setSelectionBehavior(0)
self.btn_select_line.setStyleSheet('')
self.settext(u'默认时，点击单元格，只可选择一个格，此处设置为可选择整行')
def deny_muti_line(self):
if self.table.selectionMode() in [2, 3]:
self.table.setSelectionMode(QAbstractItemView.SingleSelection)
self.btn_select_single.setStyleSheet('background-color:lightblue')
else:
self.table.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.btn_select_single.setStyleSheet('')
self.settext(u'点击时会轮换以多行或单行选择，默认是可以同时选择多行')
def sortItem(self):
if self.des_sort == True:
self.table.sortItems(3, Qt.DescendingOrder)
self.des_sort = False
self.btn_sort.setStyleSheet('background-color:lightblue')
self.table.setSortingEnabled(True) # 设置表头可以自动排序
else:
self.table.sortItems(3, Qt.AscendingOrder)
self.des_sort = True
self.btn_sort.setStyleSheet('background-color:lightblue')
self.table.setSortingEnabled(False)
self.settext(u'点击时会轮换以升序降序排列，但排序时，会使自动列宽失效！')
def setheader(self):
font = QFont(u'微软雅黑', 12)
font.setBold(True)
self.table.horizontalHeader().setFont(font) # 设置表头字体
self.table.setColumnWidth(0, 50)
self.table.setColumnWidth(1, 50)
self.table.setColumnWidth(3, 100)
self.table.horizontalHeader().setSectionResizeMode(
2, QHeaderView.Stretch)
self.table.horizontalHeader().setStyleSheet(
'QHeaderView::section{background:gray}')
self.table.horizontalHeader().setFixedHeight(50)
self.table.setColumnHidden(0, True)
self.btn_set_header.setStyleSheet('background-color:lightblue')
self.settext(
u'设置标头字体及字号，隐藏ID列，设置标头除姓名外全部为固定宽度\n，设置姓名列自动扩展宽度，设置标头行高，设置标头背景色')
def middle(self):
self.btn_set_middle.setStyleSheet('background-color:lightblue')
self.table.setStyleSheet('color:green;')
row = self.table.rowCount()
for x in range(row):
for y in range(4):
if y != 1:
item = self.table.item(x, y)
item.setTextAlignment(Qt.AlignCenter)
else:
pass
self.btn_set_middle.setStyleSheet('background-color:lightblue')
self.settext(u'将文字居中显示,设置文字颜色')
def cellchange(self, row, col):
item = self.table.item(row, col)
txt = item.text()
self.settext(u'第%s行，第%s列 , 数据改变为:%s' % (row, col, txt))
def noframe(self):
self.table.setAlternatingRowColors(True)
self.table.setFrameStyle(QFrame.NoFrame)
self.table.setStyleSheet('color:green;'
'gridline-color:white;'
'border:0px solid gray')
self.settext(u'取消表的框线,\n 取消表格内框')
def settext(self, txt):
font = QFont(u'微软雅黑', 10)
self.txt.setFont(font)
self.txt.setText(txt)
class Hygiene():
""" The Hygiene Tab
"""
global logger
def __init__(self):
####
logger.info('Inside Hygiene')
self.reporthygiene_tab_2 = QWidget()
self.reporthygiene_tab_2.setObjectName("reporthygiene_tab_2")
self.vertical_23 = QVBoxLayout(self.reporthygiene_tab_2)
self.vertical_23.setObjectName("vertical_23")
self.label_1 = QLabel(self.reporthygiene_tab_2)
self.vertical_23.addWidget(self.label_1)
self.report_hyginepest_table = QTableWidget(self.reporthygiene_tab_2)
self.report_hyginepest_table.setObjectName("report_hyginepest_table")
self.report_hyginepest_table.setColumnCount(5)
self.report_hyginepest_table.setRowCount(0)
self.report_hyginepest_table.setSelectionBehavior(
QAbstractItemView.SelectRows)
item = QTableWidgetItem()
self.report_hyginepest_table.setHorizontalHeaderItem(0, item)
item = QTableWidgetItem()
self.report_hyginepest_table.setHorizontalHeaderItem(1, item)
item = QTableWidgetItem()
self.report_hyginepest_table.setHorizontalHeaderItem(2, item)
item = QTableWidgetItem()
self.report_hyginepest_table.setHorizontalHeaderItem(3, item)
item = QTableWidgetItem()
self.report_hyginepest_table.setHorizontalHeaderItem(4, item)
self.report_hyginepest_table.horizontalHeader(
).setCascadingSectionResizes(True)
self.report_hyginepest_table.horizontalHeader().setStretchLastSection(
True)
self.report_hyginepest_table.verticalHeader(
).setCascadingSectionResizes(True)
self.vertical_23.addWidget(self.report_hyginepest_table)
self.horizontal_21 = QHBoxLayout()
self.report_hyginepest_newrow_buttuon = QPushButton(
self.reporthygiene_tab_2)
self.report_hyginepest_newrow_buttuon.setObjectName(
"report_hyginepest_newrow_buttuon")
self.horizontal_21.addWidget(self.report_hyginepest_newrow_buttuon)
spacerItem23 = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.horizontal_21.addItem(spacerItem23)
# self.report_hyginepest_save_button = QPushButton(self.reporthygiene_tab_2)
# self.report_hyginepest_save_button.setObjectName("report_hyginepest_save_button")
# self.horizontal_21.addWidget(self.report_hyginepest_save_button)
self.vertical_23.addLayout(self.horizontal_21)
self.label_2 = QLabel(self.reporthygiene_tab_2)
self.vertical_23.addWidget(self.label_2)
self.report_hyginewater_table = QTableWidget(self.reporthygiene_tab_2)
self.report_hyginewater_table.setObjectName("report_hyginewater_table")
self.report_hyginewater_table.setColumnCount(5)
self.report_hyginewater_table.setRowCount(0)
self.report_hyginewater_table.setSelectionBehavior(
QAbstractItemView.SelectRows)
item = QTableWidgetItem()
self.report_hyginewater_table.setHorizontalHeaderItem(0, item)
item = QTableWidgetItem()
self.report_hyginewater_table.setHorizontalHeaderItem(1, item)
item = QTableWidgetItem()
self.report_hyginewater_table.setHorizontalHeaderItem(2, item)
item = QTableWidgetItem()
self.report_hyginewater_table.setHorizontalHeaderItem(3, item)
item = QTableWidgetItem()
self.report_hyginewater_table.setHorizontalHeaderItem(4, item)
self.report_hyginewater_table.horizontalHeader(
).setCascadingSectionResizes(True)
self.report_hyginewater_table.horizontalHeader().setStretchLastSection(
True)
self.report_hyginewater_table.verticalHeader(
).setCascadingSectionResizes(True)
self.vertical_23.addWidget(self.report_hyginewater_table)
self.horizontal_22 = QHBoxLayout()
self.report_hyginewater_newrow_buttuon = QPushButton(
self.reporthygiene_tab_2)
self.report_hyginewater_newrow_buttuon.setObjectName(
"report_hyginewater_newrow_buttuon")
self.horizontal_22.addWidget(self.report_hyginewater_newrow_buttuon)
spacerItem24 = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.horizontal_22.addItem(spacerItem24)
# self.report_hyginewater_save_button = QPushButton(self.reporthygiene_tab_2)
# self.report_hyginewater_save_button.setObjectName("report_hyginewater_save_button")
# self.horizontal_22.addWidget(self.report_hyginewater_save_button)
self.vertical_23.addLayout(self.horizontal_22)
### retanslate
self.label_1.setText(
QApplication.translate("MainWindow", "Pest Test Report", None,
QApplication.UnicodeUTF8))
self.report_hyginepest_table.horizontalHeaderItem(0).setText(
QApplication.translate("MainWindow", "Code", None,
QApplication.UnicodeUTF8))
self.report_hyginepest_table.horizontalHeaderItem(1).setText(
QApplication.translate("MainWindow", "Date", None,
QApplication.UnicodeUTF8))
self.report_hyginepest_table.horizontalHeaderItem(2).setText(
QApplication.translate("MainWindow", "Organization Name", None,
QApplication.UnicodeUTF8))
self.report_hyginepest_table.horizontalHeaderItem(3).setText(
QApplication.translate("MainWindow", "Test", None,
QApplication.UnicodeUTF8))
self.report_hyginepest_table.horizontalHeaderItem(4).setText(
QApplication.translate("MainWindow", "Description", None,
QApplication.UnicodeUTF8))
self.report_hyginepest_newrow_buttuon.setText(
QApplication.translate("MainWindow", "New Row", None,
QApplication.UnicodeUTF8))
# self.report_hyginepest_save_button.setText(
# QApplication.translate("MainWindow", "Save", None, QApplication.UnicodeUTF8))
self.label_2.setText(
QApplication.translate("MainWindow", "Water Test Report", None,
QApplication.UnicodeUTF8))
self.report_hyginewater_table.horizontalHeaderItem(0).setText(
QApplication.translate("MainWindow", "Code", None,
QApplication.UnicodeUTF8))
self.report_hyginewater_table.horizontalHeaderItem(1).setText(
QApplication.translate("MainWindow", "Date", None,
QApplication.UnicodeUTF8))
self.report_hyginewater_table.horizontalHeaderItem(2).setText(
QApplication.translate("MainWindow", "Organization Name", None,
QApplication.UnicodeUTF8))
self.report_hyginewater_table.horizontalHeaderItem(3).setText(
QApplication.translate("MainWindow", "Test", None,
QApplication.UnicodeUTF8))
self.report_hyginewater_table.horizontalHeaderItem(4).setText(
QApplication.translate("MainWindow", "Description", None,
QApplication.UnicodeUTF8))
self.report_hyginewater_newrow_buttuon.setText(
QApplication.translate("MainWindow", "New Row", None,
QApplication.UnicodeUTF8))
# self.report_hyginewater_save_button.setText(
# QApplication.translate("MainWindow", "Save", None, QApplication.UnicodeUTF8))
###signals and slots && other stuffs
self.pest = Pest()
self.water = Water()
self.report_hyginepest_table.setEditTriggers(
QAbstractItemView.NoEditTriggers)
self.report_hyginewater_table.setEditTriggers(
QAbstractItemView.NoEditTriggers)
self.load_table_rows()
self.report_hyginepest_table.itemDoubleClicked.connect(
self.popup_pest_edit)
self.report_hyginewater_table.itemDoubleClicked.connect(
self.popup_water_edit)
self.reporthygiene_tab_2.focusInEvent = self.load_rows # very important for focus
self.report_hyginepest_newrow_buttuon.clicked.connect(
self.new_pestTest) # if no focus available then we need lambda
self.report_hyginewater_newrow_buttuon.clicked.connect(
self.new_waterTest)
def new_pestTest(self, code=None):
"""
The pest report popup generator
:param code: The code of the pest report
"""
pop = HygieneReportPop(parent=self, table='pest_table', code=code)
pop.setWindowFlags(Qt.WindowTitleHint)
pop.exec_()
self.load_table_rows()
def new_waterTest(self, code=None):
"""
The water report popup generator
:param code: The code of the water report
"""
pop = HygieneReportPop(parent=self, table='water_table', code=code)
pop.setWindowFlags(Qt.WindowTitleHint)
pop.exec_()
self.load_table_rows()
def load_table_rows(self):
"""
Populates the rows for both the table
"""
logger.info('Hygiene save table initiated')
try:
data = self.pest.load_report()
if data[0]:
self.add_table_rows('pest_table', *data[1])
if not data[1]:
self.report_hyginepest_table.clearContents()
self.report_hyginepest_table.setRowCount(0)
data = self.water.load_report()
if data[0]:
self.add_table_rows('water_table', *data[1])
if not data[1]:
self.report_hyginewater_table.clearContents()
self.report_hyginewater_table.setRowCount(0)
except Exception:
if settings.level == 10:
logger.exception('raised exception')
return False, 'Some Internal Error'
def popup_pest_edit(self, item):
"""
Pops up the menu to be edited
:param item: item clicked
"""
table = self.report_hyginepest_table
model_index = table.indexFromItem(item)
row = model_index.row()
self.new_pestTest(table.item(row, 0).text())
def popup_water_edit(self, item):
"""
Pops up the menu to be edited
:param item: item clicked
"""
table = self.report_hyginewater_table
model_index = table.indexFromItem(item)
row = model_index.row()
self.new_waterTest(table.item(row, 0).text())
def add_table_rows(self, tablename, *args):
"""
adds a new row to the pes table
"""
if tablename == 'pest_table':
table = self.report_hyginepest_table
else:
table = self.report_hyginewater_table
if args:
table.setRowCount(len(args))
for row, data in enumerate(args):
table.setItem(row, 0, QTableWidgetItem(data['code']))
table.setItem(row, 1, QTableWidgetItem(data['date']))
table.setItem(row, 2, QTableWidgetItem(data['organization']))
table.setItem(row, 3, QTableWidgetItem(data['test']))
table.setItem(row, 4, QTableWidgetItem(data['description']))
table.setColumnWidth(0, (table.width() / 5) * 0.5)
table.setColumnWidth(1, (table.width() / 5) * 0.5)
table.setColumnWidth(2, table.width() / 5)
table.setColumnWidth(3, table.width() / 5)
def load_rows(self, event):
"""
loads the rows of the tables
"""
self.add_table_rows(tablename='pest_table')
self.add_table_rows(tablename='water_table')
class RecorderClipSelectionScreen(QWidget):
def __init__(self, hyperdeck, state, mainWindow):
super(RecorderClipSelectionScreen, self).__init__()
self.hyperdeck = hyperdeck
self.state = state
self.mainWindow = mainWindow
self.selected_clip = None
layout = QGridLayout()
lblTitle = TitleLabel("Select clip")
layout.addWidget(lblTitle, 0, 0, 1, 3)
self.clipTable = QTableWidget()
self.clipTable.setColumnCount(2)
self.clipTable.setHorizontalHeaderLabels(['ID', 'Clip name'])
self.clipTable.horizontalHeader().setStretchLastSection(True)
self.clipTable.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
self.clipTable.itemSelectionChanged.connect(self._onClipSelected)
layout.addWidget(self.clipTable, 1, 0, 1, 3)
b = ExpandingButton()
b.setText("Back")
b.setIcon(QIcon(":icons/go-previous"))
b.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
b.clicked.connect(mainWindow.stepBack)
layout.addWidget(b, 2, 0)
btnRefresh = ExpandingButton()
btnRefresh.setText('Refresh')
btnRefresh.setIcon(QIcon(':icons/refresh'))
btnRefresh.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
def refresh():
self.populateClipsList({})
hyperdeck.broadcastClipsList()
btnRefresh.clicked.connect(refresh)
layout.addWidget(btnRefresh, 2, 1)
self.btnSelect = ExpandingButton()
self.btnSelect.setText("Cue clip")
self.btnSelect.clicked.connect(self._cueClip)
layout.addWidget(self.btnSelect, 2, 2)
layout.setRowStretch(0, 0)
layout.setRowStretch(1, 1)
layout.setRowStretch(2, 0)
self.setLayout(layout)
self.populateClipsList(state.clip_listing)
def populateClipsList(self, clipsList):
self.selected_clip = None
self.btnSelect.setEnabled(False)
self.clipTable.clearContents()
self.clipTable.setRowCount(len(clipsList))
for idx, (clip_id, val) in enumerate(clipsList.iteritems()):
self.clipTable.setItem(idx, 0, QTableWidgetItem(str(clip_id)))
self.clipTable.setItem(idx, 1, QTableWidgetItem(val['name']))
def _updateClipSelectionFromState(self, state):
if 'clip id' in state:
clip_id = state['clip id']
for row in range(self.clipTable.rowCount()):
this_id = self.clipTable.item(row, 0)
if this_id.text() == str(clip_id):
self.clipTable.selectRow(row)
break
def _onClipSelected(self):
selected_items = self.clipTable.selectedItems()
if selected_items:
self.selected_clip = int(selected_items[0].text())
self.btnSelect.setEnabled(True)
else:
self.btnSelect.setEnabled(False)
def _cueClip(self):
if self.selected_clip:
self.mainWindow.stepBack()
self.hyperdeck.gotoClip(self.selected_clip)
class SubscriberDialog(QDialog):
if USE_MAEMO_5:
switchRequested = Signal()
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.ui = Ui_SubscriberDialog()
self.ui.setupUi(self)
self.subscriber = None
self.tableWidget = None
self.listWidget = None
if USE_MAEMO_5:
switchButton = self.ui.buttonBox.addButton(
self.tr('Switch'), QDialogButtonBox.ActionRole)
switchButton.clicked.connect(self.switchRequested)
self.tableWidget = self.ui.tableWidget
headerLabels = ('Key', 'Value', 'Type')
self.tableWidget.setColumnCount(3)
self.tableWidget.setHorizontalHeaderLabels(headerLabels)
horizontalHeader = self.tableWidget.horizontalHeader()
horizontalHeader.setStretchLastSection(True)
verticalHeader = self.tableWidget.verticalHeader()
verticalHeader.setVisible(False)
self.tableWidget.setColumnWidth(0, 200)
self.tableWidget.setColumnWidth(1, 400)
else:
desktopWidget = QDesktopWidget()
if desktopWidget.availableGeometry().width() < 400:
# Screen is too small to fit a table widget without scrolling, use a list widget instead.
self.listWidget = QListWidget()
self.listWidget.setAlternatingRowColors(True)
self.ui.verticalLayout.insertWidget(2, self.listWidget)
else:
self.tableWidget = QTableWidget()
headerLabels = ('Key', 'Value', 'Type')
self.tableWidget.setColumnCount(3)
self.tableWidget.setHorizontalHeaderLabels(headerLabels)
horizontalHeader = self.tableWidget.horizontalHeader()
horizontalHeader.setStretchLastSection(True)
self.tableWidget.verticalHeader()
self.setVisible(False)
self.ui.verticalLayout.insertWidget(2, self.tableWidget)
self.ui.connectButton.clicked.connect(self.changeSubscriberPath)
self.changeSubscriberPath()
# if the default path does not exist reset it to /
value = self.subscriber.value()
subPaths = self.subscriber.subPaths()
if not value and not subPaths:
self.ui.basePath.setText('/')
self.changeSubscriberPath()
def changeEvent(self, e):
QDialog.changeEvent(self, e)
if e.type() == QEvent.LanguageChange:
self.ui.retranslateUi(self)
def changeSubscriberPath(self):
if self.listWidget:
self.listWidget.clear()
elif self.tableWidget:
self.tableWidget.clearContents()
if not self.subscriber:
self.subscriber = QValueSpaceSubscriber(self.ui.basePath.text(),
self)
else:
self.subscriber.setPath(self.ui.basePath.text())
self.subscriber.contentsChanged.connect(self.subscriberChanged)
self.subscriber.connectNotify("contentsChanged()")
self.subscriberChanged()
def subscriberChanged(self):
subPaths = self.subscriber.subPaths()
if self.listWidget:
self.listWidget.clear()
elif self.tableWidget:
self.tableWidget.clearContents()
self.tableWidget.setRowCount(len(subPaths))
for i in xrange(len(subPaths)):
v = self.subscriber.value(subPaths[i])
if self.listWidget:
item = QListWidgetItem('%s (%s)\n%s' %
(subPaths[i], str(type(v)), str(v)))
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self.listWidget.addItem(item)
elif self.tableWidget:
pathItem = QTableWidgetItem(subPaths[i])
pathItem.setFlags(pathItem.flags() & ~Qt.ItemIsEditable)
valueItem = QTableWidgetItem(str(v))
valueItem.setFlags(pathItem.flags() & ~Qt.ItemIsEditable)
typeItem = QTableWidgetItem(str(type(v)))
typeItem.setFlags(pathItem.flags() & ~Qt.ItemIsEditable)
self.tableWidget.setItem(i, 0, pathItem)
self.tableWidget.setItem(i, 1, valueItem)
self.tableWidget.setItem(i, 2, typeItem)
class FoamDictWidget(QWidget):
"QWidget to view and edit simple Foam Dictionary"
def __init__(self, variable_setting, parent=None):
super(FoamDictWidget, self).__init__(parent)
self.buttonLayout = QHBoxLayout()
self.pushButtonInsert = QPushButton("Insert")
#self.pushButtonLoad = QPushButton("Load default")
self.pushButtonRestore = QPushButton("Restore")
self.pushButtonClear = QPushButton("Clear")
self.buttonLayout.addWidget(self.pushButtonInsert)
#self.buttonLayout.addWidget(self.pushButtonLoad)
self.buttonLayout.addWidget(self.pushButtonRestore)
self.buttonLayout.addWidget(self.pushButtonClear)
#PySide has different name other than @QtCore.pyqtSlot, but PySide.QtCore.SLOT
QtCore.QObject.connect(self.pushButtonInsert,
QtCore.SIGNAL("clicked()"), self.insertRow)
QtCore.QObject.connect(self.pushButtonRestore,
QtCore.SIGNAL("clicked()"), self.restoreDict)
QtCore.QObject.connect(self.pushButtonClear,
QtCore.SIGNAL("clicked()"), self.clearDict)
self.tableWidget = QTableWidget()
#header, should not sort, has vertical scrollbar
# set column count, fixed to 2, size of TableItem
self.tableWidget.setColumnCount(2)
#5self.tableWidget.setHorizontalHeaderItem(0, )
self.tableWidget.setHorizontalHeaderLabels(['key', 'value text'])
# set a default row count, insert as needed
self.tableWidget.setRowCount(0)
self.initialDict = variable_setting
self.restoreDict()
# debug print to console# does not work for PySide
QtCore.QObject.connect(self.tableWidget,
QtCore.SIGNAL("doubleClicked()"),
self.printDict)
self.myLayout = QVBoxLayout()
self.myLayout.addWidget(self.tableWidget)
self.myLayout.addLayout(self.buttonLayout)
self.setLayout(self.myLayout)
def dict(self):
_settings = OrderedDict()
for i in range(self.tableWidget.rowCount()):
k = self.tableWidget.item(i, 0).text()
v = self.tableWidget.item(
i, 1).text() # data() will return QVariant type-> python type
# validated by non-empty string
if k and v:
_settings[k] = v
return _settings
def updateDictView(self, varible_settings):
i = 0
self.clearDict() # will clear contents, but leave row text empty
N = self.tableWidget.rowCount()
for k, v in varible_settings.items():
# translate seq into unicode
if i >= N:
self.tableWidget.insertRow(i)
kitem = QTableWidgetItem(
unicode(k)) # also set flags and state, type
vitem = QTableWidgetItem(unicode(v))
#print(i, self.tableWidget.item(i, 0)) # debug: None
self.tableWidget.setItem(i, 0, kitem)
self.tableWidget.setItem(i, 1, vitem)
i += 1
def restoreDict(self):
self.updateDictView(self.initialDict)
#@pyqtSlot() # PySide use another name "QtCore.Slot()"
def insertRow(self):
nRows = self.tableWidget.rowCount()
self.tableWidget.insertRow(nRows) # inset one row at the end
kitem = QTableWidgetItem("") # also set flags and state, type
vitem = QTableWidgetItem("")
self.tableWidget.setItem(nRows, 0, kitem)
#print(nRows, self.tableWidget.item(nRows, 0))
self.tableWidget.setItem(nRows, 1, vitem)
def clearDict(self):
self.tableWidget.clearContents() # keep the header, clear all items
def printDict(self):
print(self.dict())
def loadDefault(self):
pass
class PnLPanel(QtGui.QWidget):
pnLColumnList = "Custody Name;Initial Position;Final Position;Cash In;Weighted Cash In; Cash Out;Weighted Cash Out;PnL;Weighted PnL;TIR;Weighted TIR".split(
";")
def __init__(self):
super(self.__class__, self).__init__()
self.layout = QtGui.QGridLayout(self)
self.pnlFilter = PnLFilter(self)
self.layout.addWidget(self.pnlFilter, 1, 0, QtCore.Qt.AlignTop)
#self.layout.setAlignment(self.pnlFilter, QtCore.Qt.AlignTop)
#self.layout.setAlignment(self.pnlFilter, QtCore.Qt.AlignLeft)
self.layout.addWidget(self.createPnLTable(), 1, 1, QtCore.Qt.AlignTop)
#self.layout.setAlignment(self.pnLTableWidget, QtCore.Qt.AlignTop)
#self.layout.setAlignment(self.pnLTableWidget, QtCore.Qt.AlignLeft)
def createPnLTable(self):
self.pnLTableWidget = QTableWidget()
self.pnLTableWidget.setRowCount(6)
self.pnLTableWidget.setColumnCount(len(self.pnLColumnList))
self.pnLTableWidget.setEditTriggers(
QtGui.QAbstractItemView.NoEditTriggers)
self.pnLTableWidget.setHorizontalHeaderLabels(self.pnLColumnList)
#self.pnLTableWidget.resizeColumnsToContents()
self.pnLTableWidget.resizeRowsToContents()
self.pnLTableWidget.setFixedSize(1100, 150)
return self.pnLTableWidget
def doSubmit(self, fromDate, toDate):
pnlLO = Engine.buildPnlLogicObject(fromDate, toDate)
self.renderPnlTable(pnlLO.pnlVOList)
def renderPnlTable(self, pnlCalculationList):
row = 0
for pnlVO in pnlCalculationList:
#ItemNameItem
ItemNameItem = QTableWidgetItemString(pnlVO.itemName, False)
self.pnLTableWidget.setItem(row,
Constant.CONST_COLUMN_PNL_ITEM_NAME,
ItemNameItem)
#initialPositionItem
initialPositionItem = QTableWidgetItemDecimal(
pnlVO.initialPosition, False)
self.pnLTableWidget.setItem(
row, Constant.CONST_COLUMN_PNL_INITIAL_POSITION,
initialPositionItem)
#finalPositionItem
finalPositionItem = QTableWidgetItemDecimal(
pnlVO.finalPosition, False)
self.pnLTableWidget.setItem(
row, Constant.CONST_COLUMN_PNL_FINAL_POSITION,
finalPositionItem)
#totalCashIn
totalCashInItem = QTableWidgetItemDecimal(pnlVO.totalCashIn, False)
self.pnLTableWidget.setItem(row, Constant.CONST_COLUMN_PNL_CASH_IN,
totalCashInItem)
#totalWeightedCashIn
totalWeightedCashInItem = QTableWidgetItemDecimal(
pnlVO.totalWeightedCashIn, False)
self.pnLTableWidget.setItem(
row, Constant.CONST_COLUMN_PNL_WEIGHTED_CASH_IN,
totalWeightedCashInItem)
#totalCashOut
totalCashOutItem = QTableWidgetItemDecimal(pnlVO.totalCashOut,
False)
self.pnLTableWidget.setItem(row,
Constant.CONST_COLUMN_PNL_CASH_OUT,
totalCashOutItem)
#totalWeightedCashOut
totalWeightedCashOutItem = QTableWidgetItemDecimal(
pnlVO.totalWeightedCashOut, False)
self.pnLTableWidget.setItem(
row, Constant.CONST_COLUMN_PNL_WEIGHTED_CASH_OUT,
totalWeightedCashOutItem)
#pnlAmount
pnlAmountItem = QTableWidgetItemDecimal(pnlVO.pnlAmount, False)
self.pnLTableWidget.setItem(row,
Constant.CONST_COLUMN_PNL_PNL_AMOUNT,
pnlAmountItem)
#pnlWeightedAmount
pnlWeightedAmountItem = QTableWidgetItemDecimal(
pnlVO.pnlWeightedAmount, False)
self.pnLTableWidget.setItem(
row, Constant.CONST_COLUMN_PNL_WEIGHTED_PNL_AMOUNT,
pnlWeightedAmountItem)
#tir
tirItem = QTableWidgetItemDecimal(pnlVO.tir, False)
self.pnLTableWidget.setItem(row, Constant.CONST_COLUMN_PNL_TIR,
tirItem)
#weightedtir
weightedTirItem = QTableWidgetItemDecimal(pnlVO.weightedTir, False)
self.pnLTableWidget.setItem(row,
Constant.CONST_COLUMN_PNL_WEIGHTED_TIR,
weightedTirItem)
row += 1
class AdminWidget(QWidget):
"""Represents admin panel"""
def __init__(self, window):
super(AdminWidget, self).__init__(window)
self.parentWidget().setWindowTitle("Administartor panel")
self.__setupMenu()
self.layout = QGridLayout(self)
self.user_table = QTableWidget(self)
self.user_table.setColumnCount(3)
self.user_table.setHorizontalHeaderLabels(["Username", "Blocked", "Password restriction"])
self.user_table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.user_table.setSelectionMode(QAbstractItemView.SingleSelection)
self.user_table.setColumnWidth(0, 210)
self.user_table.setColumnWidth(2, 170)
self.user_table.verticalHeader().hide()
changePasswordBtn = QPushButton("Change Password")
changePasswordBtn.clicked.connect(window.requestPasswordChange)
createUserBtn = QPushButton("Add User")
createUserBtn.clicked.connect(self._request_new_account)
logOutBtn = QPushButton("Logout")
logOutBtn.clicked.connect(lambda: (window.app.logOut(), window.hide(), window.requestCredentials()))
self.layout.addWidget(self.user_table, 0, 0, 1, 0)
self.layout.addWidget(changePasswordBtn, 1, 0)
self.layout.addWidget(createUserBtn, 1, 1)
self.layout.addWidget(logOutBtn, 1, 2)
self.setLayout(self.layout)
self.__loadUsers()
def __loadUsers(self):
"""Loads user's data from DB"""
users = self.parentWidget().app.getUsers()
self.user_table.clearContents()
self.user_table.setRowCount(len(users))
for i in range(len(users)):
username_item = QTableWidgetItem(users[i].username)
username_item.setFlags(username_item.flags() ^ Qt.ItemIsEditable)
blocked_checkbox = QCheckBox()
if users[i].blocked:
blocked_checkbox.setChecked(True)
def create_blocked_toggle(checkbox, user):
def blocked_toggle():
user.blocked = (1 if checkbox.isChecked() else 0)
self.parentWidget().app.updateUser(user)
self.__loadUsers()
return blocked_toggle
blocked_checkbox.toggled.connect(create_blocked_toggle(blocked_checkbox, users[i]))
password_restrict_checkbox = QCheckBox()
if users[i].restrictions:
password_restrict_checkbox.setChecked(True)
def create_password_restrict_toggle(checkbox, user):
def password_restrict_toggle():
user.restrictions = (1 if checkbox.isChecked() else 0)
self.parentWidget().app.updateUser(user)
self.__loadUsers()
return password_restrict_toggle
password_restrict_checkbox.toggled.connect(
create_password_restrict_toggle(password_restrict_checkbox, users[i]))
self.user_table.setItem(i, 0, username_item)
self.user_table.setCellWidget(i, 1, blocked_checkbox)
self.user_table.setCellWidget(i, 2, password_restrict_checkbox)
def __setupMenu(self):
add_account_action = QAction("Add account", self)
add_account_action.triggered.connect(self._request_new_account)
self.parentWidget().account_menu.addAction(add_account_action)
def _request_new_account(self):
dialog = None
def ok_handler(username):
if not 3 <= len(username) <= 20:
QMessageBox.critical(dialog, "Error", "Username's length must be between 3 and 20", modal=True)
return
user = User(username=username)
status = self.parentWidget().app.addUser(user)
{
Core.ERROR_USER_EXISTS: lambda:
QMessageBox.critical(dialog, "Error", "Username already exists", modal=True),
Core.SUCCESS: lambda: (
self.__loadUsers(),
dialog.close()
)
}[status]()
def cancel_handler():
dialog.close()
dialog = AdminWidget.AddAccountDialog(self, ok_handler, cancel_handler)
dialog.show()
class AddAccountDialog(QDialog):
def __init__(self, parent, ok_handler, cancel_handler):
super(AdminWidget.AddAccountDialog, self).__init__(parent)
self.setWindowTitle("Add account")
self.setFixedSize(300, 100)
self.setModal(True)
self.layout = QGridLayout(self)
self.username_label = QLabel(self)
self.username_label.setText("Username")
self.edit_username = QLineEdit(self)
self.buttons = QDialogButtonBox(self)
self.buttons.addButton(QDialogButtonBox.Ok)
self.buttons.addButton(QDialogButtonBox.Cancel)
self.buttons.button(QDialogButtonBox.Ok).setText("Add")
self.buttons.button(QDialogButtonBox.Cancel).setText("Cancel")
self.buttons.button(QDialogButtonBox.Cancel).clicked.connect(cancel_handler)
self.buttons.button(QDialogButtonBox.Ok).clicked.connect(lambda: ok_handler(self.edit_username.text()))
self.layout.addWidget(self.username_label, 0, 0)
self.layout.addWidget(self.edit_username, 0, 1)
self.layout.addWidget(self.buttons, 1, 0, 1, 2, Qt.AlignCenter)
self.setLayout(self.layout)
class Ui_MainWindow(QMainWindow):
"""Cette classe contient tous les widgets de notre application."""
defaultPalette = QPalette()
defaultPalette.setColor(QPalette.Base, QColor("#151515"))
defaultPalette.setColor(QPalette.Text, Qt.white)
def __init__(self):
super(Ui_MainWindow, self).__init__()
# initialise la GUI avec un exemple
self.text = "Ceci est un petit texte d'exemple."
# les variables sont en place, initialise la GUI
self.initUI()
# exécute l'exemple
self.orgText.setText(self.text)
self.encode_text(False)
self.logLab.setText(
u"Saisir du texte ou importer un fichier, puis pousser \n"
u"le bouton correspondant à l'opération souhaitée.")
def initUI(self):
"""Met en place les éléments de l'interface."""
# -+++++++------------------- main window -------------------+++++++- #
self.setWindowTitle(u"Encodage / Décodage de Huffman")
self.centerAndResize()
centralwidget = QWidget(self)
mainGrid = QGridLayout(centralwidget)
mainGrid.setColumnMinimumWidth(0, 450)
# -+++++++------------------ groupe analyse -----------------+++++++- #
analysGroup = QGroupBox(u"Analyse", centralwidget)
self.analysGrid = QGridLayout(analysGroup)
# ----------- groupe de la table des codes ---------- #
codeTableGroup = QGroupBox(u"Table des codes", analysGroup)
codeTableGrid = QGridLayout(codeTableGroup)
# un tableau pour les codes
self.codesTableModel = MyTableModel()
self.codesTable = QTableView(codeTableGroup)
self.codesTable.setModel(self.codesTableModel)
self.codesTable.setFont(QFont("Mono", 8))
self.codesTable.resizeColumnsToContents()
self.codesTable.setSortingEnabled(True)
codeTableGrid.addWidget(self.codesTable, 0, 0, 1, 1)
self.analysGrid.addWidget(codeTableGroup, 1, 0, 1, 1)
# ----------- label du ratio de compression ---------- #
self.ratioLab = QLabel(u"Ratio de compression: ", analysGroup)
font = QFont()
font.setBold(True)
font.setWeight(75)
font.setKerning(True)
self.ratioLab.setFont(font)
self.analysGrid.addWidget(self.ratioLab, 2, 0, 1, 1)
# -+++++++-------- groupe de la table de comparaison --------+++++++- #
self.compGroup = QGroupBox(analysGroup)
self.compGroup.setTitle(u"Comparaisons")
compGrid = QGridLayout(self.compGroup)
# un tableau pour le ratio
self.compTable = QTableWidget(self.compGroup)
sizePolicy = QSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
sizePolicy.setHorizontalStretch(0)
sizePolicy.setVerticalStretch(0)
sizePolicy.setHeightForWidth(
self.compTable.sizePolicy().hasHeightForWidth())
self.compTable.setSizePolicy(sizePolicy)
self.compTable.setBaseSize(QSize(0, 0))
font = QFont()
font.setWeight(50)
self.compTable.setFont(font)
self.compTable.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.compTable.setShowGrid(True)
self.compTable.setGridStyle(Qt.SolidLine)
# lignes / colonnes
self.compTable.setColumnCount(2)
self.compTable.setRowCount(3)
self.compTable.setVerticalHeaderItem(0, QTableWidgetItem("Taille (bits)"))
self.compTable.setVerticalHeaderItem(1, QTableWidgetItem("Entropie"))
self.compTable.setVerticalHeaderItem(2, QTableWidgetItem("Taille moy. (bits)"))
for i in range(2):
self.compTable.verticalHeaderItem(i).setTextAlignment(
Qt.AlignRight)
self.compTable.setHorizontalHeaderItem(0, QTableWidgetItem("ASCII"))
self.compTable.setHorizontalHeaderItem(1, QTableWidgetItem("Huffman"))
# nom des items
self.compTabASCIIMem = QTableWidgetItem()
self.compTable.setItem(0, 0, self.compTabASCIIMem)
self.compTabASCIIEnt = QTableWidgetItem()
self.compTable.setItem(1, 0, self.compTabASCIIEnt)
self.compTabASCIIAvg = QTableWidgetItem()
self.compTable.setItem(2, 0, self.compTabASCIIAvg)
self.compTabHuffMem = QTableWidgetItem()
self.compTable.setItem(0, 1, self.compTabHuffMem)
self.compTabHuffEnt = QTableWidgetItem()
self.compTable.setItem(1, 1, self.compTabHuffEnt)
self.compTabHuffAvg = QTableWidgetItem()
self.compTable.setItem(2, 1, self.compTabHuffAvg)
# parem du tableau
self.compTable.horizontalHeader().setCascadingSectionResizes(False)
self.compTable.verticalHeader().setVisible(True)
font = QFont("Mono", 8)
self.compTable.setFont(font)
compGrid.addWidget(self.compTable, 1, 0, 1, 1)
self.analysGrid.addWidget(self.compGroup, 0, 0, 1, 1)
mainGrid.addWidget(analysGroup, 0, 1, 1, 1)
# -+++++++----------------- groupe du texte -----------------+++++++- #
groupBox = QGroupBox(u"Texte", centralwidget)
textGrid = QGridLayout(groupBox)
# -+++++++------------- groupe du texte original ------------+++++++- #
orgTextGroup = QGroupBox(u"Texte original (Ctrl+T)", groupBox)
orgTextGrid = QGridLayout(orgTextGroup)
self.orgText = QTextEdit(orgTextGroup)
self.orgText.setPalette(self.defaultPalette)
orgTextGrid.addWidget(self.orgText, 0, 0, 1, 1)
textGrid.addWidget(orgTextGroup, 0, 0, 1, 2)
# -+++++++------------ groupe du texte compressé ------------+++++++- #
compressedTextGroup = QGroupBox(u"Texte compressé (Ctrl+H)", groupBox)
compressedTextGrid = QGridLayout(compressedTextGroup)
self.compressedText = QTextEdit(compressedTextGroup)
self.compressedText.setPalette(self.defaultPalette)
compressedTextGrid.addWidget(self.compressedText, 0, 0, 1, 1)
textGrid.addWidget(compressedTextGroup, 1, 0, 1, 2)
# -+++++++------------ groupe pour le texte ascii -----------+++++++- #
asciiTextGroup = QGroupBox(u"Texte ASCII", groupBox)
asciiTextGrid = QGridLayout(asciiTextGroup)
self.asciiText = QTextBrowser(asciiTextGroup)
self.asciiText.setPalette(self.defaultPalette)
asciiTextGrid.addWidget(self.asciiText, 0, 0, 1, 1)
textGrid.addWidget(asciiTextGroup, 2, 0, 1, 2)
# -+++++++-------------------- label de log -----------------+++++++- #
self.logLab = QLabel(analysGroup)
textGrid.addWidget(self.logLab, 3, 0, 1, 2)
# -+++++++----------- bouton pour encoder le texte ----------+++++++- #
self.encodeBut = QPushButton(groupBox)
self.encodeBut.setStatusTip(
u"Cliquez sur ce bouton pour encoder le texte original.")
self.encodeBut.setText(u"ENCODER")
self.encodeBut.clicked.connect(self.encode_text)
textGrid.addWidget(self.encodeBut, 4, 0, 1, 1)
# -+++++++----------- bouton pour décoder le texte ----------+++++++- #
self.decodeBut = QPushButton(groupBox)
self.decodeBut.setStatusTip(
u"Cliquez sur ce bouton pour décoder le texte compressé.")
self.decodeBut.setText(u"DÉCODER")
self.decodeBut.clicked.connect(self.decode_text)
textGrid.addWidget(self.decodeBut, 4, 1, 1, 1)
mainGrid.addWidget(groupBox, 0, 0, 1, 1)
self.setCentralWidget(centralwidget)
# -+++++++--------------- une barre de statut ---------------+++++++- #
self.setStatusBar(QStatusBar(self))
# -+++++++--------------------- le menu ---------------------+++++++- #
self.fileMenu = QMenu(u"Fichier")
self.fileMenu.addAction(u"Importer un texte...", self.open_text)
self.fileMenu.addAction(
u"Importer un texte encodé...", lambda: self.open_text(True))
self.fileMenu.addAction(u"Importer un dictionnaire...", self.open_dict)
self.fileMenu.addAction(u"Enregistrer le dictionnaire...", self.save_dict)
self.fileMenu.addAction(u"Quitter", self.close)
self.menuBar().addMenu(self.fileMenu)
QMetaObject.connectSlotsByName(self)
def open_text(self, compressed=False):
"""Ouvrir un fichier contenant un texte compressé ou non."""
fname, _ = QFileDialog.getOpenFileName(self, u'Ouvrir')
f = open(fname, 'r')
with f:
data = f.read()
if compressed:
self.compressedText.setText(data)
else:
self.orgText.setText(data)
def open_dict(self):
"""Ouvrir un dictionnaire de codes Huffman."""
fname, _ = QFileDialog.getOpenFileName(self, u'Ouvrir')
self.occ = {}
self.hCodes = {}
self.aCodes = {}
self.hCost = {}
self.aCost = {}
self.hCodes = create_dict_from_file(fname)
self.update_codes_table()
self.logLab.setText(u"Dictionnaire de Huffman importé.")
return self.hCodes
def save_dict(self):
"""Enregistrer le dictionnaire de codes Huffman."""
fname, _ = QFileDialog.getSaveFileName(self, "Enregistrer sous")
save_dict_to_file(fname, self.hCodes)
def make_tab_rows(self):
"""Génère le remplissage des lignes du tableau des codes."""
dictList = [self.occ, self.aCodes, self.hCodes, self.aCost, self.hCost]
tabList = []
charList = self.hCodes.keys() if self.hCodes else self.occ.keys()
for char in charList:
l = ["'" + char + "'"]
for dic in dictList:
try:
l.append(dic[char])
except KeyError:
l.append('')
tabList.append(l)
return tabList
def encode_text(self, wizard=True):
"""Encode le texte original."""
self.text = self.orgText.toPlainText().encode('utf-8')
if not self.text:
self.compressedText.setText(u"")
self.asciiText.setText(u"")
self.logLab.setText(
u"<font color=#A52A2A>Rien à compresser.</font>")
return
self.occ = {}
self.tree = ()
self.hCodes = {}
self.aCodes = {}
self.hCost = {}
self.aCost = {}
self.hSqueezed = []
self.aSqueezed = []
self.stringHSqueezed = ''
self.stringASqueezed = ''
if wizard:
self.launch_wizard(
EncodeWizard(self),
u"<font color=#008000>Compression achevée.</font>")
else:
self.make_occ()
self.make_tree()
self.make_codes()
self.make_cost()
self.make_encoded_text()
self.make_comp()
def decode_text(self, wizard=True):
"""Décode le texte compressé."""
self.codeString = str(
self.compressedText.toPlainText().replace(' ', ''))
if not self.codeString or not self.hCodes:
self.orgText.setText(u"")
self.asciiText.setText(u"")
if not self.codeString:
self.logLab.setText(
u"<font color=#A52A2A>Rien à décompresser.</font>")
if not self.hCodes:
self.logLab.setText(
u"<font color=#A52A2A>Dictionnaire indisponible pour la décompression.</font>")
return
self.text = ''
self.stringASqueezed = ''
if wizard:
self.launch_wizard(
DecodeWizard(self),
u"<font color=#008000>Texte décompressé.</font>")
else:
self.make_code_map()
self.make_decoded_text()
def launch_wizard(self, wizard, finishString):
"""Lance l'assistant d'en/décodage pour guider l'utilisateur.
Cache les options inaccessibles pendant l'assistant.
"""
self.logLab.setText(
u"<font color=#9E6A00>Opération en cours. "
u"Suivre les indications.</font>")
disItems = [self.orgText, self.compressedText, self.encodeBut,
self.decodeBut, self.fileMenu.actions()[1],
self.fileMenu.actions()[2], self.fileMenu.actions()[3]]
for item in disItems:
item.setEnabled(False)
self.compGroup.setVisible(False)
self.analysGrid.addWidget(wizard, 0, 0, 1, 1)
res = wizard.exec_()
if res:
self.logLab.setText(finishString)
else:
self.logLab.setText(
u"<font color=#A52A2A>Opération interrompue.</font>")
for item in disItems:
item.setEnabled(True)
self.compGroup.setVisible(True)
def update_ratio_lab(self):
"""Replace la valeur du label du ratio de compression."""
if not self.stringASqueezed:
val = '/'
else:
val = (len(self.stringHSqueezed.replace(' ', '')) /
float(len(self.stringASqueezed.replace(' ', ''))))
self.ratioLab.setText(unicode('Taux de compression: ' + str(val)))
def update_comp_table(self):
"""Met à jour le tableau de comparaison ASCII VS Huffman."""
self.compTabASCIIMem.setText(unicode(len(''.join(self.aSqueezed))))
self.compTabHuffMem.setText(unicode(len(''.join(self.hSqueezed))))
# entropie ?
self.compTabASCIIEnt.setText('0')
self.compTabHuffEnt.setText('0')
self.compTabASCIIAvg.setText(unicode(8))
self.compTabHuffAvg.setText(unicode(
average_code_length(self.hSqueezed)))
self.compTable.resizeColumnsToContents()
def update_codes_table(self, hlRow=[]):
"""Met à jour le tableau des codes et surligne les lignes de hlRow."""
self.codesTableModel.hlRow = hlRow
self.codesTableModel.emptyTable()
self.codesTableModel.fillTable(self.make_tab_rows())
self.codesTable.resizeColumnsToContents()
def centerAndResize(self):
"""Centre et redimmensionne le widget."""
screen = QDesktopWidget().screenGeometry()
self.resize(screen.width() / 1.6, screen.height() / 1.4)
size = self.geometry()
self.move(
(screen.width() - size.width()) / 2,
(screen.height() - size.height()) / 2)
#===================== METHODS FOR EN/DECODE WIZARDS =====================#
def make_encode_init(self):
self.compressedText.setText(unicode(self.stringHSqueezed))
self.asciiText.setText(unicode(self.stringASqueezed))
self.orgText.setTextColor(QColor(Qt.darkGreen))
self.orgText.setText(unicode(self.text.decode('utf-8')))
self.update_codes_table()
def make_occ(self):
self.orgText.setTextColor(QColor(Qt.white))
self.orgText.setText(unicode(self.text.decode('utf-8')))
self.occ = occurences(self.text)
self.update_codes_table([0, 1])
def make_tree(self):
self.tree = make_trie(self.occ)
self.update_codes_table()
def make_codes(self):
self.hCodes = make_codes(self.tree, {})
self.aCodes = make_ascii_codes(self.occ.keys(), {})
self.update_codes_table([2, 3])
def make_cost(self):
self.hCost = tree_cost(self.hCodes, self.occ)
self.aCost = tree_cost(self.aCodes, self.occ)
self.update_codes_table([4, 5])
def make_encoded_text(self):
self.hSqueezed = squeeze(self.text, self.hCodes)
self.aSqueezed = squeeze(self.text, self.aCodes)
self.stringHSqueezed = ' '.join(self.hSqueezed)
self.stringASqueezed = ' '.join(self.aSqueezed)
self.compressedText.setTextColor(QColor(Qt.darkGreen))
self.asciiText.setTextColor(QColor(Qt.darkYellow))
self.compressedText.setText(unicode(self.stringHSqueezed))
self.asciiText.setText(unicode(self.stringASqueezed))
self.update_codes_table()
def make_comp(self):
self.compressedText.setTextColor(QColor(Qt.white))
self.asciiText.setTextColor(QColor(Qt.white))
self.compressedText.setText(unicode(self.stringHSqueezed))
self.asciiText.setText(unicode(self.stringASqueezed))
self.update_codes_table()
self.update_comp_table()
self.update_ratio_lab()
def make_decode_init(self):
self.orgText.setText(unicode(self.text))
self.asciiText.setText(unicode(self.stringASqueezed))
self.compressedText.setTextColor(QColor(Qt.darkGreen))
self.compressedText.setText(self.compressedText.toPlainText())
def make_code_map(self):
self.compressedText.setTextColor(QColor(Qt.white))
self.compressedText.setText(self.compressedText.toPlainText())
self.orgText.setText(unicode(self.text))
self.asciiText.setText(unicode(self.stringASqueezed))
self.codeMap = dict(zip(self.hCodes.values(), self.hCodes.keys()))
self.update_codes_table([0, 3])
def make_decoded_text(self):
self.unSqueezed = unsqueeze(self.codeString, self.codeMap)
self.text = ''.join(self.unSqueezed)
self.orgText.setTextColor(QColor(Qt.darkGreen))
self.orgText.setText(unicode(self.text.decode('utf-8')))
self.asciiText.setText(unicode(self.stringASqueezed))
self.update_codes_table()
def make_ascii_decode(self):
self.orgText.setTextColor(QColor(Qt.white))
self.orgText.setText(unicode(self.text.decode('utf-8')))
self.aCodes = make_ascii_codes(self.codeMap.values(), {})
self.aSqueezed = squeeze(self.text, self.aCodes)
self.stringASqueezed = ' '.join(self.aSqueezed)
self.occ = occurences(self.text)
self.hCost = tree_cost(self.hCodes, self.occ)
self.aCost = tree_cost(self.aCodes, self.occ)
self.asciiText.setTextColor(QColor(Qt.darkGreen))
self.asciiText.setText(unicode(self.stringASqueezed))
self.update_codes_table([1, 2, 4, 5])
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.setFixedSize(800, 600)
self.centralwidget = QWidget(MainWindow)
self.centralwidget.setObjectName("centralwidget")
self.FilterLbl = QLabel(self.centralwidget)
self.FilterLbl.setGeometry(QtCore.QRect(30, 150, 60, 15))
self.FilterLbl.setObjectName("FilterLbl")
self.FilterCB = QComboBox(self.centralwidget)
self.FilterCB.setGeometry(QtCore.QRect(450, 150, 100, 22))
self.FilterCB.setObjectName("FilterCB")
self.FilterCB.addItem("")
self.FilterCB.addItem("")
self.FilterCB.addItem("")
self.FilterCB.addItem("")
self.FilterTF = QLineEdit(self.centralwidget)
self.FilterTF.setGeometry(QtCore.QRect(100, 150, 320, 20))
self.tableView = QTableWidget(self.centralwidget)
self.tableView.setGeometry(QtCore.QRect(10, 180, 781, 511))
self.tableView.setObjectName("tableView")
self.tableView.setColumnCount(4)
self.tableView.setRowCount(0)
item = QTableWidgetItem("Cena za kg/l")
self.tableView.setHorizontalHeaderItem(0, item)
item = QTableWidgetItem("Cena ze kus")
self.tableView.setHorizontalHeaderItem(1, item)
item = QTableWidgetItem(u"Gramaž")
self.tableView.setHorizontalHeaderItem(2, item)
item = QTableWidgetItem("Popis")
item.setTextAlignment(QtCore.Qt.AlignHCenter|QtCore.Qt.AlignVCenter|QtCore.Qt.AlignCenter)
font = QtGui.QFont()
font.setPointSize(8)
item.setFont(font)
self.tableView.setHorizontalHeaderItem(3, item)
self.tableView.horizontalHeader().setStretchLastSection(True)
self.SaveBtn = QPushButton(self.centralwidget)
self.SaveBtn.setGeometry(QtCore.QRect(30, 10, 100, 23))
self.SaveBtn.setObjectName("SaveBtn")
self.PrintSelectedToFileBtn = QPushButton(self.centralwidget)
self.PrintSelectedToFileBtn.setGeometry(QtCore.QRect(225, 10, 100, 23))
self.PrintSelectedToFileBtn.setObjectName("PrintSelectedToFileBtn")
self.PriceForUnitTF = QLineEdit(self.centralwidget)
self.PriceForUnitTF.setGeometry(QtCore.QRect(100, 70, 113, 20))
self.PriceForUnitTF.setObjectName("PriceForUnitTF")
self.PriceForUnitLbl = QLabel(self.centralwidget)
self.PriceForUnitLbl.setGeometry(QtCore.QRect(30, 70, 60, 13))
self.PriceForUnitLbl.setObjectName("PriceForUnitLbl")
self.ArtikelTF = QLineEdit(self.centralwidget)
self.ArtikelTF.setGeometry(QtCore.QRect(100, 100, 113, 20))
self.ArtikelTF.setObjectName("ArtikelTF")
self.ArtikelLbl = QLabel(self.centralwidget)
self.ArtikelLbl.setGeometry(QtCore.QRect(30, 100, 46, 13))
self.ArtikelLbl.setObjectName("ArtikelLbl")
self.DescriptionLbl = QLabel(self.centralwidget)
self.DescriptionLbl.setGeometry(QtCore.QRect(455, 70, 75, 13))
self.DescriptionLbl.setObjectName("DescriptionLbl")
self.UnitLbl = QLabel(self.centralwidget)
self.UnitLbl.setGeometry(QtCore.QRect(250, 70, 60, 15))
self.UnitLbl.setObjectName("UnitLbl")
self.WeightLbl = QLabel(self.centralwidget)
self.WeightLbl.setGeometry(QtCore.QRect(250, 100, 60, 13))
self.WeightLbl.setObjectName("UnitLbl")
self.WeightTF = QLineEdit(self.centralwidget)
self.WeightTF.setGeometry(QtCore.QRect(320, 100, 100, 20))
self.WeightTF.setObjectName("WeightTF")
self.UnitCB = QComboBox(self.centralwidget)
self.UnitCB.setGeometry(QtCore.QRect(320, 70, 100, 22))
self.UnitCB.setObjectName("UnitCB")
self.UnitCB.addItem("")
self.UnitCB.addItem("")
self.DescriptionTE = QPlainTextEdit(self.centralwidget)
self.DescriptionTE.setGeometry(QtCore.QRect(540, 30, 241, 61))
self.DescriptionTE.setObjectName("DescriptionTE")
self.PrintToFileBtn = QPushButton(self.centralwidget)
self.PrintToFileBtn.setGeometry(QtCore.QRect(140, 10, 75, 23))
self.PrintToFileBtn.setObjectName("PrintToFileBtn")
self.AddRecordBtn = QPushButton(self.centralwidget)
self.AddRecordBtn.setGeometry(QtCore.QRect(450, 100, 75, 23))
self.AddRecordBtn.setObjectName("AddRecordBtn")
self.SaveChangeBtn = QPushButton(self.centralwidget)
self.SaveChangeBtn.setGeometry(QtCore.QRect(550, 100, 75, 23))
self.SaveChangeBtn.setObjectName("SaveChangeBtn")
self.DeleteRecordBtn = QPushButton(self.centralwidget)
self.DeleteRecordBtn.setGeometry(QtCore.QRect(650, 100, 75, 23))
self.DeleteRecordBtn.setObjectName("DeleteRecordBtn")
MainWindow.setCentralWidget(self.centralwidget)
self.menubar = QMenuBar(MainWindow)
self.menubar.setGeometry(QtCore.QRect(0, 0, 800, 21))
self.menubar.setObjectName("menubar")
MainWindow.setMenuBar(self.menubar)
self.statusbar = QStatusBar(MainWindow)
self.statusbar.setObjectName("statusbar")
self.FilterTF.textChanged.connect(self.on_lineEdit_textChanged)
self.FilterCB.currentIndexChanged.connect(self.on_comboBox_currentIndexChanged)
self.retranslateUi(MainWindow)
QtCore.QMetaObject.connectSlotsByName(MainWindow)
def myFilter(self,col=None):
filt = self.FilterTF.text()
for ix in range(self.tableView.rowCount()):
match = False
if col == None:
for jx in range(self.tableView.columnCount()):
item = self.tableView.item(ix,jx)
if filt in item.text():
match = True
break
self.tableView.setRowHidden(ix, not match)
else:
item = self.tableView.item(ix, col)
if filt in item.text():
match = True
self.tableView.setRowHidden(ix, not match)
#@QtCore.pyqtSlot(str)
def on_lineEdit_textChanged(self, text):
self.myFilter()
#@QtCore.pyqtSlot(int)
def on_comboBox_currentIndexChanged(self, index):
self.myFilter(col=index)
def retranslateUi(self, MainWindow):
_translate = QtCore.QCoreApplication.translate
MainWindow.setWindowTitle(_translate("MainWindow", "Stitky - {0}".format(__version__)))
self.SaveBtn.setText(_translate("MainWindow", "Uloz stav tabulky"))
self.PrintSelectedToFileBtn.setText(_translate("MainWindow", "Tisk vybranych"))
self.PriceForUnitLbl.setText(_translate("MainWindow", "Cena za kus:"))
self.ArtikelLbl.setText(_translate("MainWindow", "Artikl:"))
self.DescriptionLbl.setText(_translate("MainWindow", "Popis produktu:"))
self.UnitLbl.setText(_translate("MainWindow", "Jednotka:"))
self.FilterLbl.setText(_translate("MainWindow", "Filtr:"))
self.WeightLbl.setText(_translate("MainWindow", "Hmotnost:"))
self.PrintToFileBtn.setText(_translate("MainWindow", "Vytvor txt"))
self.SaveChangeBtn.setText(_translate("MainWindow", "Uloz zmeny"))
self.AddRecordBtn.setText(_translate("MainWindow", "Pridej zaznam"))
self.DeleteRecordBtn.setText(_translate("MainWindow", "Smaz zaznam"))
self.UnitCB.setItemText(0, _translate("MainWindow", "g"))
self.UnitCB.setItemText(1, _translate("MainWindow", "ml"))
self.FilterCB.setItemText(0, _translate("MainWindow", "Cena za kg/l"))
self.FilterCB.setItemText(1, _translate("MainWindow", "Cena ze kus"))
self.FilterCB.setItemText(2, _translate("MainWindow", "Gramaz"))
self.FilterCB.setItemText(3, _translate("MainWindow", "Popis"))
class FoamDictWidget(QWidget):
"QWidget to view and edit simple Foam Dictionary"
def __init__(self, variable_setting, parent=None):
super(FoamDictWidget, self).__init__(parent)
self.buttonLayout = QHBoxLayout()
self.pushButtonInsert = QPushButton("Insert")
#self.pushButtonLoad = QPushButton("Load default")
self.pushButtonRestore = QPushButton("Restore")
self.pushButtonClear = QPushButton("Clear")
self.buttonLayout.addWidget(self.pushButtonInsert)
#self.buttonLayout.addWidget(self.pushButtonLoad)
self.buttonLayout.addWidget(self.pushButtonRestore)
self.buttonLayout.addWidget(self.pushButtonClear)
self.buttonPreview = QPushButton('Preview FoamFile write-out')
self.textPreview = QTextEdit('')
self.textPreview.setVisible(False)
self.textPreview.setEnabled(False)
self.tableWidget = QTableWidget()
#header, should not sort, has vertical scrollbar
# set column count, fixed to 2, size of TableItem
self.tableWidget.setColumnCount(2)
#5self.tableWidget.setHorizontalHeaderItem(0, )
self.tableWidget.setHorizontalHeaderLabels(['key', 'value text'])
# set a default row count, insert as needed
self.tableWidget.setRowCount(0)
#PySide has different name other than @QtCore.pyqtSlot, but PySide.QtCore.SLOT
QtCore.QObject.connect(self.pushButtonInsert, QtCore.SIGNAL("clicked()"), self.insertRow)
QtCore.QObject.connect(self.pushButtonRestore, QtCore.SIGNAL("clicked()"), self.restoreDict)
QtCore.QObject.connect(self.pushButtonClear, QtCore.SIGNAL("clicked()"), self.clearDict)
#
QtCore.QObject.connect(self.tableWidget, QtCore.SIGNAL("doubleClicked()"), self.showPreview) # does not work for PySide
QtCore.QObject.connect(self.buttonPreview, QtCore.SIGNAL("clicked()"), self.showPreview)
self._previewing = False
self.settings = variable_setting
self.restoreDict()
self.myLayout = QVBoxLayout()
self.myLayout.addLayout(self.buttonLayout)
self.myLayout.addWidget(self.tableWidget)
self.myLayout.addWidget(self.buttonPreview)
self.myLayout.addWidget(self.textPreview)
self.setLayout(self.myLayout)
def dict(self):
_settings = OrderedDict()
for i in range(self.tableWidget.rowCount()):
k = self.tableWidget.item(i, 0).text()
v = self.tableWidget.item(i, 1).text() # data() will return QVariant type-> python type
# validated by non-empty string
if k and v:
_settings[k] = v
return _settings
def setDict(self, settings):
self.settings = settings
self.updateDictView(self.settings)
def restoreDict(self):
self.updateDictView(self.settings)
def updateDictView(self, varible_settings):
i = 0
self.clearDict() # will clear contents, but leave row text empty
N = self.tableWidget.rowCount()
for k,v in varible_settings.items():
# translate seq into unicode
if i>=N:
self.tableWidget.insertRow(i)
kitem = QTableWidgetItem(k) # also set flags and state, type
vitem = QTableWidgetItem(v) # automaticall convert str to unicode to feed QWidget?
self.tableWidget.setItem(i, 0, kitem)
self.tableWidget.setItem(i, 1, vitem) # currently only works for string value !
i += 1
#@pyqtSlot() # PySide use another name "QtCore.Slot()"
def insertRow(self):
nRows = self.tableWidget.rowCount()
self.tableWidget.insertRow(nRows) # inset one row at the end
kitem = QTableWidgetItem("") # also set flags and state, type
vitem = QTableWidgetItem("")
self.tableWidget.setItem(nRows, 0, kitem)
self.tableWidget.setItem(nRows, 1, vitem)
def clearDict(self):
self.tableWidget.clearContents() # keep the header, clear all items
def showPreview(self):
if self._previewing:
self._previewing = False
self.textPreview.setVisible(False)
self.buttonPreview.setText('click to preview write out')
else:
self._previewing = True
self.buttonPreview.setText('click on text to hide preview')
# enable scrollbar ?
self.textPreview.setText(self.printDict())
self.textPreview.setVisible(True)
def loadDefault(self):
pass
def printDict(self):
dictText = "{\n"
for k,v in self.dict().items():
dictText += " {} {};\n".format(str(k), str(v))
dictText += "}"
return dictText
class MenuWeekday():
"""Tab to manage menu entry for each day"""
global logger
def __init__(self, day):
####
logger.info('Inside MenuWeekday')
self.menudetail_tab_1 = QWidget()
self.menudetail_tab_1.setObjectName("menudetail_tab_1")
self.gridLayout_20 = QGridLayout(self.menudetail_tab_1)
self.gridLayout_20.setObjectName("gridLayout_20")
self.menu_table = QTableWidget(self.menudetail_tab_1)
self.menu_table.setSortingEnabled(True)
self.menu_table.setObjectName("menu_table")
self.menu_table.setColumnCount(6)
self.menu_table.setRowCount(0)
item = QTableWidgetItem()
self.menu_table.setHorizontalHeaderItem(0, item)
item = QTableWidgetItem()
self.menu_table.setHorizontalHeaderItem(1, item)
item = QTableWidgetItem()
self.menu_table.setHorizontalHeaderItem(2, item)
item = QTableWidgetItem()
self.menu_table.setHorizontalHeaderItem(3, item)
item = QTableWidgetItem()
self.menu_table.setHorizontalHeaderItem(4, item)
item = QTableWidgetItem()
self.menu_table.setHorizontalHeaderItem(5, item)
self.menu_table.horizontalHeader().setCascadingSectionResizes(False)
self.menu_table.horizontalHeader().setStretchLastSection(True)
self.menu_table.verticalHeader().setVisible(True)
self.menu_table.verticalHeader().setCascadingSectionResizes(True)
self.gridLayout_20.addWidget(self.menu_table, 0, 0, 1, 3)
spacerItem22 = QSpacerItem(612, 20, QSizePolicy.Expanding, QSizePolicy.Minimum)
self.gridLayout_20.addItem(spacerItem22, 1, 0, 1, 1)
self.menu_table_refresh_button = QPushButton(self.menudetail_tab_1)
self.menu_table_refresh_button.setObjectName("menu_table_refresh_button")
self.gridLayout_20.addWidget(self.menu_table_refresh_button, 1, 1, 1, 1)
self.menu_table_add_button = QPushButton(self.menudetail_tab_1)
self.menu_table_add_button.setObjectName("menu_table_add_button")
self.gridLayout_20.addWidget(self.menu_table_add_button, 1, 2, 1, 1)
####retranslate
self.menu_table.horizontalHeaderItem(0).setText(
QApplication.translate("MainWindow", "Code", None, QApplication.UnicodeUTF8))
self.menu_table.horizontalHeaderItem(1).setText(
QApplication.translate("MainWindow", "Item", None, QApplication.UnicodeUTF8))
self.menu_table.horizontalHeaderItem(2).setText(
QApplication.translate("MainWindow", "Category", None, QApplication.UnicodeUTF8))
self.menu_table.horizontalHeaderItem(3).setText(
QApplication.translate("MainWindow", "Rate", None, QApplication.UnicodeUTF8))
self.menu_table.horizontalHeaderItem(4).setText(
QApplication.translate("MainWindow", "Per Day", None, QApplication.UnicodeUTF8))
self.menu_table.horizontalHeaderItem(5).setText(
QApplication.translate("MainWindow", "Available", None, QApplication.UnicodeUTF8))
self.menu_table_refresh_button.setText(
QApplication.translate("MainWindow", "Refresh", None, QApplication.UnicodeUTF8))
self.menu_table_add_button.setText(
QApplication.translate("MainWindow", "Add Dish", None, QApplication.UnicodeUTF8))
###signals and slots && other stuffs
# self.mainwindow = Ui_MainWindow # just for the ease of finding the attributes in pycharm
self.day = day
self.menu_table_add_button.clicked.connect(self.add_menu)
self.menu_table.itemDoubleClicked.connect(self.popup_edit)
self.menu_table_refresh_button.clicked.connect(self.update_menu)
self.menu_table.setSelectionBehavior(QAbstractItemView.SelectRows)
self.menu_table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.menu_table.setShowGrid(False)
self.menu_table.setAlternatingRowColors(True)
self.update_menu()
self.popup = object
self.menudetail_tab_1.setFocusPolicy(Qt.StrongFocus)
self.menudetail_tab_1.focusInEvent = self.load_rows
self.assign_shortcuts()
def assign_shortcuts(self):
"""assign shortcuts"""
QShortcut(QKeySequence(settings.custom_shortcut['key_tabcon_menumgtmonsun_view']),
self.menudetail_tab_1, self.row_selected)
QShortcut(QKeySequence(settings.custom_shortcut['key_tabcon_menumgtmonsun_refresh']),
self.menudetail_tab_1, self.update_menu)
QShortcut(QKeySequence(settings.custom_shortcut['key_tabcon_menumgtmonsun_add']),
self.menudetail_tab_1, self.add_menu)
def row_selected(self):
"""selets a row entry"""
rows = sorted(set(index.row() for index in
self.menu_table.selectedIndexes()))
if rows:
code = self.menu_table.item(rows[0], 0).text()
name = self.menu_table.item(rows[0], 1).text()
quantity = self.menu_table.item(rows[0], 4).text()
self.add_menu(code, name, quantity)
def add_menu(self, *args):
"""
:return: Pops up a new dialogue to add the menus
"""
if not args:
self.popup = AddMenuFromList(parent=self, day=self.day)
self.popup.exec_()
else:
self.popup = MenuQuantityEditPopup(parent=self, day=self.day, code=args[0], name=args[1], quantity=args[2])
self.popup.exec_()
def update_menu(self):
"""
:return:Populates the menu table
"""
menu = WeeklyMenu(day=self.day)
menulist = menu.load_dish_per_Day()
if not menulist == []:
self.add_row(*menulist)
else:
self.menu_table.clearContents()
self.menu_table.setRowCount(0)
def popup_edit(self, item):
"""
Pops up the menu to be edited
:param item: item clicked
:return:none
"""
model_index = self.menu_table.indexFromItem(item)
row = model_index.row()
code = self.menu_table.item(row, 0).text()
name = self.menu_table.item(row, 1).text()
quantity = self.menu_table.item(row, 4).text()
self.add_menu(code, name, quantity)
def add_row(self, *args):
"""creates a new row entry"""
table = self.menu_table
if args:
table.setRowCount(len(args))
for i, j in enumerate(args):
item = QTableWidgetItem(j['item_no'])
table.setItem(i, 0, item)
item = QTableWidgetItem(j['item'])
table.setItem(i, 1, item)
item = QTableWidgetItem(j['category'])
table.setItem(i, 2, item)
item = QTableWidgetItem(j['rate'])
table.setItem(i, 3, item)
item = QTableWidgetItem(j['per_day'])
table.setItem(i, 4, item)
item = QTableWidgetItem(j['available'])
table.setItem(i, 5, item)
table.setColumnWidth(0, table.width() / 6)
table.setColumnWidth(1, table.width() / 6)
table.setColumnWidth(2, table.width() / 6)
table.setColumnWidth(3, table.width() / 6)
table.setColumnWidth(4, table.width() / 6)
def load_rows(self, event):
"""
:return:checks and adds new rows
"""
self.add_row()
class ReportEmployeeTestDialogue(QDialog):
"""
Employee Report Popup Manager
"""
global logger
def __init__(self, code=None, parent=None):
logger.info('Inside ReportEmployeeTestDialogue')
super(ReportEmployeeTestDialogue, self).__init__(parent)
self.resize(500, 500)
self.vertical_23 = QVBoxLayout(self)
self.vertical_23.setObjectName("vertical_23")
self.label_1 = QLabel(self)
self.vertical_23.addWidget(self.label_1)
self.report_health_table = QTableWidget(self)
self.report_health_table.setObjectName("report_health_table")
self.report_health_table.setColumnCount(5)
self.report_health_table.setRowCount(0)
self.report_health_table.setSelectionBehavior(
QAbstractItemView.SelectRows)
item = QTableWidgetItem()
self.report_health_table.setHorizontalHeaderItem(0, item)
item = QTableWidgetItem()
self.report_health_table.setHorizontalHeaderItem(1, item)
item = QTableWidgetItem()
self.report_health_table.setHorizontalHeaderItem(2, item)
item = QTableWidgetItem()
self.report_health_table.setHorizontalHeaderItem(3, item)
item = QTableWidgetItem()
self.report_health_table.setHorizontalHeaderItem(4, item)
self.report_health_table.horizontalHeader().setCascadingSectionResizes(
True)
self.report_health_table.horizontalHeader().setStretchLastSection(True)
self.report_health_table.verticalHeader().setCascadingSectionResizes(
True)
self.vertical_23.addWidget(self.report_health_table)
self.horizontal_21 = QHBoxLayout()
self.report_health_newrow_buttuon = QPushButton(self)
self.report_health_newrow_buttuon.setObjectName(
"report_health_newrow_buttuon")
self.horizontal_21.addWidget(self.report_health_newrow_buttuon)
spacerItem23 = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.horizontal_21.addItem(spacerItem23)
self.vertical_23.addLayout(self.horizontal_21)
### retanslate
self.setWindowTitle(
QApplication.translate("MainWindow", "Health Report", None,
QApplication.UnicodeUTF8))
self.label_1.setText(
QApplication.translate("MainWindow", "Health Report", None,
QApplication.UnicodeUTF8))
self.report_health_table.horizontalHeaderItem(0).setText(
QApplication.translate("MainWindow", "Code", None,
QApplication.UnicodeUTF8))
self.report_health_table.horizontalHeaderItem(1).setText(
QApplication.translate("MainWindow", "Date", None,
QApplication.UnicodeUTF8))
self.report_health_table.horizontalHeaderItem(2).setText(
QApplication.translate("MainWindow", "Organization Name", None,
QApplication.UnicodeUTF8))
self.report_health_table.horizontalHeaderItem(3).setText(
QApplication.translate("MainWindow", "Test", None,
QApplication.UnicodeUTF8))
self.report_health_table.horizontalHeaderItem(4).setText(
QApplication.translate("MainWindow", "Description", None,
QApplication.UnicodeUTF8))
self.report_health_newrow_buttuon.setText(
QApplication.translate("MainWindow", "New Row", None,
QApplication.UnicodeUTF8))
###signals and slots && other stuffs
self.health = Health(emp_id=code)
self.report_health_table.setEditTriggers(
QAbstractItemView.NoEditTriggers)
self.load_table_rows()
self.report_health_table.itemDoubleClicked.connect(
self.popup_health_edit)
self.report_health_newrow_buttuon.clicked.connect(self.new_healthTest)
self.focusInEvent = self.load_rows
def new_healthTest(self, code=None):
"""
pops up a dialog to add a new report or edit the existing report
:param code:the code of the report
"""
try:
pop = HygieneReportPop(parent=self,
table='health_table',
code=code)
pop.setWindowFlags(Qt.WindowTitleHint)
pop.exec_()
self.load_table_rows()
except Exception:
if settings.level == 10:
logger.exception('raised exception')
return False, 'Some Internal Error'
def load_table_rows(self):
"""
loads the table of reports
"""
try:
data = self.health.load_report()
if data[0]:
self.add_table_rows(*data[1])
if not data[1]:
self.report_health_table.clearContents()
self.report_health_table.setRowCount(0)
except Exception:
if settings.level == 10:
logger.exception('raised exception')
return False, 'Some Internal Error'
def popup_health_edit(self, item):
"""
Pops up the menu to be edited
:param item: item clicked
"""
try:
table = self.report_health_table
model_index = table.indexFromItem(item)
row = model_index.row()
self.new_healthTest(table.item(row, 0).text())
except Exception:
if settings.level == 10:
logger.exception('raised exception')
return False, 'Some Internal Error'
def add_table_rows(self, *args):
"""
adds a new row to the pes table
"""
try:
table = self.report_health_table
if args:
table.setRowCount(len(args))
for row, data in enumerate(args):
table.setItem(row, 0, QTableWidgetItem(data['code']))
table.setItem(row, 1, QTableWidgetItem(data['date']))
table.setItem(row, 2,
QTableWidgetItem(data['organization']))
table.setItem(row, 3, QTableWidgetItem(data['test']))
table.setItem(row, 4,
QTableWidgetItem(data['description']))
table.setColumnWidth(0, (table.width() / 5) * 0.5)
table.setColumnWidth(1, (table.width() / 5) * 0.5)
table.setColumnWidth(2, table.width() / 5)
table.setColumnWidth(3, table.width() / 5)
except Exception:
if settings.level == 10:
logger.exception('raised exception')
return False, 'Some Internal Error'
def load_rows(self, event):
"""
loads the rows of the tables
"""
self.add_table_rows()
class TableWidgetController(AbstractViewController, Ui_TableWidget):
"""
The controller part for a data table widget. The UI part is declared
in tablewidget_v1.ui and then converted to ui_tablewidget.py.
This widget can be fed tabular data and has several options for showing it.
@since: 2010-11-10
"""
__author__ = "Moritz Wade"
__contact__ = "*****@*****.**"
__copyright__ = "Zuse Institute Berlin 2010"
def __init__(self, parent=None, host=None, title="Table", mode=None):
"""
Constructor, setting up lots of instance variables.
"""
super(TableWidgetController, self).__init__(parent)
self.setupUi(self)
self.setWindowTitle(title)
self._initialize()
self._mode = MODE_DEFAULT
self.maxValue = -1
self.host = host
self.data = None
self.dataTableHeaders = []
self.dataTableColumnData = []
self.dataTableRowCount = -1
self.dataTableRowHeaders = None
self.dataTableWidget = None
self.isColored = False
self.checkBoxShowUnits.setChecked(DEFAULT_SHOW_UNITS)
self.showUnits = DEFAULT_SHOW_UNITS
self.orientation = ORIENTATION_HORIZONTAL
self.sortColumn = -1 # default: do not sort at load
self.colorThreshold = None
self.colorThresholdBase = self.doubleSpinBox_Coloring_Threshold.value()
self.colorThresholdExponent = self.spinBox_Coloring_Exponent.value()
if mode:
self.setMode(mode)
self._updateThreshold()
def setMode(self, mode):
self._mode = mode
if mode == MODE_SUBCONDITIONS:
rtolScientificString = "{:e}".format(float(self.host.getRTol()))
exponentStr = rtolScientificString.split("e")[1]
self.spinBox_Coloring_Exponent.setValue(float(exponentStr))
self.doubleSpinBox_Coloring_Threshold.setValue(1.0)
self.label_Coloring_Threshold.setText("Anticipated Relative Measurement Error")
self.groupBox_Coloring.setChecked(True)
self.isColored = True
elif mode == MODE_JACOBIAN:
self.groupBox_Coloring.setChecked(True) # just activate coloring with default threshold
self.isColored = True
def _updateView(self, data=None):
"""
Overriding the "abstract" base class method. This does the main "drawing" of data, i.e.
generates the table and fills it with data.
"""
if data:
self.data = data
if self.data:
self._updateDataTable(self.data)
def _clearView(self):
if self.dataTableWidget:
self.dataTableWidget.clear()
def _setRowHeaders(self, dataDescriptors):
"""
Sets the given datadescriptors (from an EntityData object) as row headers
of the table, thereby checking for floats and rounding them, as not to show too
many digits after the point.
"""
if not dataDescriptors:
logging.debug("TableWidgetController._setRowHeaders(): Empty dataDescriptor list.")
return
self.dataTableRowHeaders = []
for descriptor in dataDescriptors:
try:
descriptor = float(descriptor)
descriptor = round(descriptor, 4)
except ValueError:
pass
self.dataTableRowHeaders.append(str(descriptor)) # the QTableWidget needs a list of Strings
def _computeColor(self, value):
if type(value) == str:
if value == "N/A":
return COLOR_LOW
try:
value = float(value)
except:
return None
if self._mode == MODE_DEFAULT or self._mode == MODE_JACOBIAN:
if value <= self.colorThreshold:
color = COLOR_LOW
else:
color = COLOR_HIGH
elif self._mode == MODE_SUBCONDITIONS:
if value >= self.colorThreshold:
color = COLOR_LOW
else:
percentage = (self.maxValue - value + 1) / float(
self.maxValue
) # +1 because it's the "lowest" subcondition, and represents 100%
highRed, highGreen, highBlue, highAlpha = (
COLOR_HIGH.red(),
COLOR_HIGH.green(),
COLOR_HIGH.blue(),
COLOR_HIGH.alpha(),
)
mediumRed, mediumGreen, mediumBlue, mediumAlpha = (
COLOR_MEDIUM.red(),
COLOR_MEDIUM.green(),
COLOR_MEDIUM.blue(),
COLOR_MEDIUM.alpha(),
)
diffRed, diffGreen, diffBlue, diffAlpha = (
highRed - mediumRed,
highGreen - mediumGreen,
highBlue - mediumBlue,
highAlpha - mediumAlpha,
)
valueRed = diffRed * percentage + mediumRed
valueGreen = diffGreen * percentage + mediumGreen
valueBlue = diffBlue * percentage + mediumBlue
valueAlpha = diffAlpha * percentage + mediumAlpha
color = QColor(valueRed, valueGreen, valueBlue, valueAlpha)
else:
color = QColor(0, 0, 0, 255) # transparent
return color
def _updateDataTable(self, data):
"""
Updates the data table with data from the last integration.
"""
# prepare data
self.dataTableHeaders = []
self.dataTableColumnData = []
self.dataTableRowCount = -1
self.dataTableRowHeaders = None
self.maxValue = -1
# BEGIN FOR: iterate over all data block
for (entity, entityDataList) in data.items():
for entityData in entityDataList:
dataDescriptors = entityData.dataDescriptors
if not self.dataTableRowHeaders:
self._setRowHeaders(dataDescriptors)
elif len(self.dataTableRowHeaders) != len(dataDescriptors):
logging.error(
"Different number of time points for two Species. Last Species (%s) will be skipped." % entity
)
continue
# set header for first column (dataDescriptor/Timepoint col)
# in first iteration
if len(self.dataTableHeaders) == 0:
dataDescriptorName = entityData.dataDescriptorName
dataDescriptorUnit = entityData.dataDescriptorUnit
if not dataDescriptorUnit and "timepoint" in str(dataDescriptorName).lower():
dataDescriptorUnit = self.host.optionTimeUnit
firstColHeader = ""
if dataDescriptorName:
if self.showUnits:
firstColHeader = "%s [%s]" % (dataDescriptorName, dataDescriptorUnit)
elif dataDescriptorName:
firstColHeader = "%s" % dataDescriptorName
self.dataTableHeaders.append(firstColHeader)
if len(dataDescriptors) > self.dataTableRowCount:
self.dataTableRowCount = len(dataDescriptors)
# datapoints = entityData.datapoints
datapoints = self.__convertEntityData(entityData)
# shorten datapoints
# for i, datapoint in enumerate(entityData.datapoints):
# try:
# floatValue = float(datapoint) # will jump to except if no float
# valueString = "N/A" if math.isnan(floatValue) else ' {0:-.4f}'.format(floatValue)
# datapoints.append(valueString)
# preparing color computation
# logging.debug(entityData.dataDescriptorName)
# logging.debug(entityData.dataDescriptors[i] == settingsandvalues.SUBCONDITION_HEADER_ABSOLUTE)
# if self._mode == MODE_SUBCONDITIONS\
# and entityData.dataDescriptors[i] == settingsandvalues.SUBCONDITION_HEADER_ABSOLUTE\
# and floatValue > self.maxValue\
# and floatValue < self.colorThreshold:
# self.maxValue = floatValue
# except:
# datapoints.append(str(datapoint))
# logging.debug("TableWidgetController - datapoints: %s" % datapoints) # too much overhead
# self.dataTableHeaders.append("Data species %s [%s]" % (str(speciesID), entityData.getUnit()))
if self.showUnits:
self.dataTableHeaders.append("%s [%s]" % (entity.getCombinedId(), entityData.getUnit()))
else:
self.dataTableHeaders.append("%s" % entity.getCombinedId())
self.dataTableColumnData.append(datapoints)
# END FOR:
# Put those labels into the actual data that would be the vertical/row labels.
# We can't use .setVerticalHeaderLabers() because those labels don't get sorted together with the data.
# Very weird but that seems to be the intended behaviour of Qt.
if self.orientation == ORIENTATION_VERTICAL:
self.dataTableHeaders = self.dataTableHeaders[1:] # remove unnecessary dataDescriptor name
for i in xrange(len(self.dataTableColumnData)):
entry = self.dataTableColumnData[i]
entry.insert(0, self.dataTableHeaders[i])
self.dataTableRowHeaders.insert(0, "")
else:
self.dataTableColumnData.insert(0, self.dataTableRowHeaders)
if not self.dataTableWidget: # create for the first time
tableLayout = QVBoxLayout(self.tableWrapper)
self.dataTableWidget = QTableWidget(self)
tableLayout.addWidget(self.dataTableWidget)
# prepare table
self.dataTableWidget.setSortingEnabled(
True
) # do here to avoid performance penalty (this actually does one sorting run)
if self.orientation == ORIENTATION_HORIZONTAL:
self.dataTableWidget.setColumnCount(len(self.dataTableHeaders))
self.dataTableWidget.setRowCount(self.dataTableRowCount)
self.dataTableWidget.setHorizontalHeaderLabels(self.dataTableHeaders)
elif self.orientation == ORIENTATION_VERTICAL:
self.dataTableWidget.setRowCount(len(self.dataTableHeaders))
self.dataTableWidget.setColumnCount(len(self.dataTableRowHeaders))
self.dataTableWidget.setHorizontalHeaderLabels(
self.dataTableRowHeaders
) # has to be called after setRowCount?
# put data into table
self.__addData()
# for col in xrange(len(self.dataTableColumnData)):
# for row in xrange(len(self.dataTableColumnData[col])):
# try:
# value = self.dataTableColumnData[col][row] # don't touch "values"; they could be pre-formatted strings
# newItem = SortedTableWidgetItem() # use custom item class
# newItem.setData(Qt.DisplayRole, value)
# newItem.setTextAlignment(Qt.AlignRight)
# newItem.setFont(QFont("Fixed"))
# if self.isColored:
# if not(self._mode == MODE_SUBCONDITIONS and row != 2): #color only row 2 of subcondition tables
# color = self._computeColor(value)
# if color:
# newItem.setBackground(QBrush(color))
# except Exception, e:
# logging.debug(
# "TableWidgetController._updateDataTable(): Could not put value into widget item: %s\nError: %s" % (
# value, e))
# if self.orientation == ORIENTATION_HORIZONTAL:
# self.dataTableWidget.setItem(row, col, newItem)
# elif self.orientation == ORIENTATION_VERTICAL:
# self.dataTableWidget.setItem(col, row, newItem)
if self.sortColumn != -1 and self.orientation == ORIENTATION_HORIZONTAL:
self.dataTableWidget.sortItems(self.sortColumn)
self.dataTableWidget.resizeColumnsToContents()
def __addData(self): # oddly in the vertical mode some data entries seem to be missing
for col in xrange(len(self.dataTableColumnData)):
dataList = self.dataTableColumnData[col]
for row in xrange(len(dataList)):
try:
value = dataList[row] # don't touch "values"; they could be pre-formatted strings
newItem = SortedTableWidgetItem() # use custom item class
newItem.setData(Qt.DisplayRole, value)
newItem.setTextAlignment(Qt.AlignRight)
newItem.setFont(QFont("Fixed"))
if self.isColored:
if not (
self._mode == MODE_SUBCONDITIONS and row != 2
): # color only row 2 of subcondition tables
color = self._computeColor(value)
if color:
newItem.setBackground(QBrush(color))
except Exception, e:
logging.debug(
"TableWidgetController._updateDataTable(): Could not put value into widget item: %s\nError: %s"
% (value, e)
)
if self.orientation == ORIENTATION_HORIZONTAL:
self.dataTableWidget.setItem(row, col, newItem)
elif self.orientation == ORIENTATION_VERTICAL:
self.dataTableWidget.setItem(col, row, newItem)
class MovementView(QWidget):
positionTableWidget = None
row = 0
columnList = "Asset Name;Buy Sell;Acquisition Date;Quantity;Price;Gross Amount;Net Amount;Comm %;Comm Amount; Comm VAT Amount".split(
";")
def __init__(self, movementList):
QWidget.__init__(self)
self.layout = QtGui.QGridLayout(self)
self.positionTableWidget = QTableWidget()
self.resize(800, 400)
self.positionTableWidget.setRowCount(10000)
self.positionTableWidget.setColumnCount(len(self.columnList))
self.positionTableWidget.setHorizontalHeaderLabels(self.columnList)
self.positionTableWidget.resizeColumnsToContents()
self.positionTableWidget.resizeRowsToContents()
self.layout.addWidget(self.positionTableWidget, 1, 0)
for (movement) in movementList:
self.renderMovements(movement)
self.positionTableWidget.setRowCount(self.row)
def renderMovements(self, movement):
#assetName
assetNameItem = QTableWidgetItemString(movement.asset.name, False)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_MOVEMENT_ASSET_NAME, assetNameItem)
#buysell
buySellItem = QTableWidgetItemString(movement.buySell, False)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_MOVEMENT_BUYSELL, buySellItem)
#acquisitionDate
acquisitionDateItem = QTableWidgetItemString(
movement.getAcquisitionDate(), False)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_MOVEMENT_ACQUISITION_DATE,
acquisitionDateItem)
#quantity
quantityItem = QTableWidgetItemInt(movement.quantity, False)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_MOVEMENT_QUANTITY, quantityItem)
#price
priceItem = QTableWidgetItem6Decimal(movement.price, False)
self.positionTableWidget.setItem(self.row,
Constant.CONST_COLUMN_MOVEMENT_PRICE,
priceItem)
#grossAmount
grossAmountItem = QTableWidgetItem6Decimal(movement.grossAmount, False)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_MOVEMENT_GROSS_AMOUNT,
grossAmountItem)
#netAmount
netAmountItem = QTableWidgetItem6Decimal(movement.netAmount, False)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_MOVEMENT_NET_AMOUNT, netAmountItem)
#commissionPercentage
commissionPercentageItem = QTableWidgetItem6Decimal(
movement.commissionPercentage, False)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_MOVEMENT_COMMISSION_PERCENTAGE,
commissionPercentageItem)
#commissionAmount
commissionAmountItem = QTableWidgetItem6Decimal(
movement.commissionAmount, False)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_MOVEMENT_COMMISSION_AMOUNT,
commissionAmountItem)
#commissionVATAmount
commissionVATAmountItem = QTableWidgetItem6Decimal(
movement.commissionVATAmount, False)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_MOVEMENT_COMMISSION_VAT_AMOUNT,
commissionVATAmountItem)
self.row += 1
class NotificationTab():
"""ui class for new notification tab"""
global logger
def __init__(self):
#####
logger.info('Inside PurchaseSchedule')
self.notificationTab_tab_4 = QWidget()
self.notificationTab_tab_4.setObjectName("notificationTab_tab_4")
self.gridLayout_19 = QGridLayout(self.notificationTab_tab_4)
self.gridLayout_19.setObjectName("gridLayout_19")
##
self.horizontalLayout = QHBoxLayout()
self.horizontalLayout.setObjectName("horizontalLayout")
self.title_label = QLabel(self.notificationTab_tab_4)
self.title_label.setObjectName("title_label")
self.horizontalLayout.addWidget(self.title_label)
self.gridLayout_19.addLayout(self.horizontalLayout, 0, 0, 1, 1)
##
self.horizontalLayout_6 = QHBoxLayout()
self.horizontalLayout_6.setObjectName("horizontalLayout_6")
self.id_label = QLabel(self.notificationTab_tab_4)
self.id_label.setObjectName("id_label")
self.horizontalLayout_6.addWidget(self.id_label)
self.id_line = QLineEdit(self.notificationTab_tab_4)
self.id_line.setObjectName("id_line")
self.horizontalLayout_6.addWidget(self.id_line)
self.notification_schedule_fromdate_label = QLabel(
self.notificationTab_tab_4)
self.notification_schedule_fromdate_label.setObjectName(
"notification_schedule_fromdate_label")
self.horizontalLayout_6.addWidget(
self.notification_schedule_fromdate_label)
self.notification_schedule_fromdate_dateedit = QDateEdit(
self.notificationTab_tab_4)
self.notification_schedule_fromdate_dateedit.setMaximumDate(
QDate.currentDate())
self.notification_schedule_fromdate_dateedit.setDate(
QDate.currentDate())
self.notification_schedule_fromdate_dateedit.setCalendarPopup(True)
self.notification_schedule_fromdate_dateedit.setObjectName(
"notification_schedule_fromdate_dateedit")
self.horizontalLayout_6.addWidget(
self.notification_schedule_fromdate_dateedit)
self.notification_schedule_todate_label = QLabel(
self.notificationTab_tab_4)
self.notification_schedule_todate_label.setObjectName(
"notification_schedule_todate_label")
self.horizontalLayout_6.addWidget(
self.notification_schedule_todate_label)
self.notification_schedule_todate_dateedit = QDateEdit(
self.notificationTab_tab_4)
self.notification_schedule_todate_dateedit.setMaximumDate(
QDate.currentDate())
self.notification_schedule_todate_dateedit.setDate(QDate.currentDate())
self.notification_schedule_todate_dateedit.setCalendarPopup(True)
self.notification_schedule_todate_dateedit.setObjectName(
"notification_schedule_todate_dateedit")
self.horizontalLayout_6.addWidget(
self.notification_schedule_todate_dateedit)
self.type_label = QLabel(self.notificationTab_tab_4)
self.type_label.setObjectName("type_label")
self.horizontalLayout_6.addWidget(self.type_label)
self.notification_states = QComboBox(self.notificationTab_tab_4)
self.notification_states.setObjectName("notification_states")
self.horizontalLayout_6.addWidget(self.notification_states)
self.batch_label = QLabel(self.notificationTab_tab_4)
self.batch_label.setObjectName("batch_label")
self.horizontalLayout_6.addWidget(self.batch_label)
self.notification_results = QComboBox(self.notificationTab_tab_4)
self.notification_results.setObjectName("notification_results")
self.horizontalLayout_6.addWidget(self.notification_results)
self.gridLayout_19.addLayout(self.horizontalLayout_6, 1, 0, 1, 1)
self.gridLayout_8 = QGridLayout()
self.gridLayout_8.setObjectName("gridLayout_8")
self.notification_schedule_table = QTableWidget(
self.notificationTab_tab_4)
self.notification_schedule_table.setObjectName(
"notification_schedule_table")
self.notification_schedule_table.setColumnCount(5)
self.notification_schedule_table.setRowCount(0)
self.notification_schedule_table.setWordWrap(True)
item = QTableWidgetItem()
self.notification_schedule_table.setHorizontalHeaderItem(0, item)
item = QTableWidgetItem()
self.notification_schedule_table.setHorizontalHeaderItem(1, item)
item = QTableWidgetItem()
self.notification_schedule_table.setHorizontalHeaderItem(2, item)
item = QTableWidgetItem()
self.notification_schedule_table.setHorizontalHeaderItem(3, item)
item = QTableWidgetItem()
self.notification_schedule_table.setHorizontalHeaderItem(4, item)
self.notification_schedule_table.horizontalHeader(
).setCascadingSectionResizes(True)
self.notification_schedule_table.horizontalHeader(
).setStretchLastSection(True)
self.notification_schedule_table.verticalHeader().setVisible(False)
self.notification_schedule_table.verticalHeader(
).setCascadingSectionResizes(True)
self.notification_schedule_table.verticalHeader(
).setStretchLastSection(False)
self.gridLayout_8.addWidget(self.notification_schedule_table, 0, 0, 1,
5)
self.notification_search_button = QPushButton(
self.notificationTab_tab_4)
self.notification_search_button.setObjectName(
"notification_search_button")
self.gridLayout_8.addWidget(self.notification_search_button, 1, 0, 1,
1)
spacerItem10 = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.gridLayout_8.addItem(spacerItem10, 1, 2, 1, 1)
self.notification_reset_button = QPushButton(
self.notificationTab_tab_4)
self.notification_reset_button.setObjectName(
"notification_reset_button")
self.gridLayout_8.addWidget(self.notification_reset_button, 1, 3, 1, 1)
self.notification_load_more_button = QPushButton(
self.notificationTab_tab_4)
self.notification_load_more_button.setObjectName(
"notification_load_more_button")
self.gridLayout_8.addWidget(self.notification_load_more_button, 1, 4,
1, 1)
self.gridLayout_19.addLayout(self.gridLayout_8, 2, 0, 1, 1)
###retranslate
self.title_label.setText(
QApplication.translate(
"MainWindow", "<html><head/><body><p align=\"center\">"
"<span style=\" font-weight:600;font-size:20px\">"
"<u>All Notifications</u></span></p></body></html>", None,
QApplication.UnicodeUTF8))
self.id_label.setText(
QApplication.translate("MainWindow", "Message Id", None,
QApplication.UnicodeUTF8))
self.notification_schedule_fromdate_label.setText(
QApplication.translate("MainWindow", "From Date", None,
QApplication.UnicodeUTF8))
self.notification_schedule_fromdate_dateedit.setDisplayFormat(
QApplication.translate("MainWindow", "dd/MM/yyyy", None,
QApplication.UnicodeUTF8))
self.notification_schedule_todate_label.setText(
QApplication.translate("MainWindow", "To Date", None,
QApplication.UnicodeUTF8))
self.notification_schedule_todate_dateedit.setDisplayFormat(
QApplication.translate("MainWindow", "dd/MM/yyyy", None,
QApplication.UnicodeUTF8))
self.type_label.setText(
QApplication.translate("MainWindow", "Type", None,
QApplication.UnicodeUTF8))
self.batch_label.setText(
QApplication.translate("MainWindow", "Number of Notifications",
None, QApplication.UnicodeUTF8))
self.notification_schedule_table.horizontalHeaderItem(0).setText(
QApplication.translate("MainWindow", "Message Id", None,
QApplication.UnicodeUTF8))
self.notification_schedule_table.horizontalHeaderItem(1).setText(
QApplication.translate("MainWindow", "Date", None,
QApplication.UnicodeUTF8))
self.notification_schedule_table.horizontalHeaderItem(2).setText(
QApplication.translate("MainWindow", "From", None,
QApplication.UnicodeUTF8))
self.notification_schedule_table.horizontalHeaderItem(3).setText(
QApplication.translate("MainWindow", "Message", None,
QApplication.UnicodeUTF8))
self.notification_schedule_table.horizontalHeaderItem(4).setText(
QApplication.translate("MainWindow", "State", None,
QApplication.UnicodeUTF8))
self.notification_search_button.setText(
QApplication.translate("MainWindow", "Search", None,
QApplication.UnicodeUTF8))
self.notification_reset_button.setText(
QApplication.translate("MainWindow", "Reset All", None,
QApplication.UnicodeUTF8))
self.notification_load_more_button.setText(
QApplication.translate("MainWindow", "Load More", None,
QApplication.UnicodeUTF8))
##signals and slotts && other stuffs
self.scheduletable_count = 0
self.addtable_count = 0
# self.mainwindow = Ui_MainWindow # just for the ease of finding the attributes in pycharm
self.notification_schedule_table.setEditTriggers(
QAbstractItemView.NoEditTriggers)
self.batch_number = None
self.notification_results.addItems([str(i) for i in range(1, 50, 5)])
self.notification_states.addItems(['All', 'New', 'To Do', 'Done'])
self.message = Messaging()
self.notification_load_more_button.clicked.connect(self.load_more)
self.notification_search_button.clicked.connect(self.search_messages)
self.notification_reset_button.clicked.connect(self.reset_all)
self.notificationTab_tab_4.setFocusPolicy(Qt.StrongFocus)
self.notificationTab_tab_4.focusInEvent = self.load_rows
# self.assign_shortcuts()
# def assign_shortcuts(self):
# QShortcut(QKeySequence(settings.custom_shortcut['key_tabcon_inventorynotification_search']),
# self.notificationTab_tab_4, self.search_messages)
# QShortcut(QKeySequence(settings.custom_shortcut['key_tabcon_inventorynotification_additem']),
# self.notificationTab_tab_4, self.add_new_blank_rows)
# QShortcut(QKeySequence(settings.custom_shortcut['key_tabcon_inventorynotification_print']),
# self.notificationTab_tab_4, self.commit_and_print)
# QShortcut(QKeySequence(settings.custom_shortcut['key_tabcon_inventorynotification_today']),
# self.notificationTab_tab_4, lambda: self.load_messages('today'))
# QShortcut(QKeySequence(settings.custom_shortcut['key_tabcon_inventorynotification_tommorow']),
# self.notificationTab_tab_4, lambda: self.load_messages('tomorrow'))
# QShortcut(QKeySequence(settings.custom_shortcut['key_tabcon_inventorynotification_thismonth']),
# self.notificationTab_tab_4, lambda: self.load_messages('month'))
# QShortcut(QKeySequence(settings.custom_shortcut['key_tabcon_inventorynotification_thisweek']),
# self.notificationTab_tab_4, lambda: self.load_messages('week'))
# QShortcut(QKeySequence(settings.custom_shortcut['key_tabcon_inventorynotification_clear']),
# self.notificationTab_tab_4, self.clear_table)
def add_messages(self, *args):
"""
Populates the Schedules when we load the tab
"""
table = self.notification_schedule_table
if args:
if args[0] != 'new':
table.clearContents()
table.setRowCount(0)
table.setRowCount(len(args))
for i, j in enumerate(args):
item = QTableWidgetItem(j['msg_id'])
table.setItem(i, 0, item)
item = QTableWidgetItem(j['date'])
table.setItem(i, 1, item)
item = QTableWidgetItem(
'Name:{}\nDesignation:{}\nAddress:{}'.format(
j['name'], j['designation'], j['address']))
table.setItem(i, 2, item)
item = QTableWidgetItem(
'Message Type:{}\nMessage:{}'.format(
j['msg_type'].title(), j['msg_body']))
table.setItem(i, 3, item)
states = QComboBox()
self.populate_states(states, j['msg_state'].title())
states.currentIndexChanged.connect(
lambda index, row=i: self.changed_state(row, index))
table.setCellWidget(i, 4, states)
elif args[0] == 'new':
initial = table.rowCount()
row = table.rowCount() + len(args[1])
table.setRowCount(row)
forward_range = range(initial, row)
for i, j in zip(forward_range, args[1]):
item = QTableWidgetItem(j['msg_id'])
table.setItem(i, 0, item)
item = QTableWidgetItem(j['date'])
table.setItem(i, 1, item)
item = QTableWidgetItem(
'Name:{}\nDesignation:{}\nAddress:{}'.format(
j['name'], j['designation'], j['address']))
table.setItem(i, 2, item)
item = QTableWidgetItem(
'Message Type:{}\nMessage:{}'.format(
j['msg_type'].title(), j['msg_body']))
table.setItem(i, 3, item)
states = QComboBox()
self.populate_states(states, j['msg_state'].title())
states.currentIndexChanged.connect(
lambda index, row=i: self.changed_state(row, index))
table.setCellWidget(i, 4, states)
table.setColumnWidth(0, (table.width() * 0.5) / 5)
table.setColumnWidth(1, (table.width() * 0.5) / 5)
table.setColumnWidth(2, table.width() / 5)
table.setColumnWidth(3, (table.width() * 2) / 5)
self.notification_schedule_table.resizeRowsToContents()
def populate_states(self, combo, state):
"""
fills the supplier list for each item line
:param combo: the combo box of suppliers
:return:none
"""
combo.setStyleSheet("QAbstractItemView{" "background: #4B77BE;" "}")
combo.addItems(['New', 'To Do', 'Done'])
index = combo.findText(state)
combo.setCurrentIndex(index)
def changed_state(self, row, index):
"""
fill the item combo box
:param combo: the combobox object
:return: none
"""
table = self.notification_schedule_table
data = {}
data['message_id'] = table.item(row, 0).text()
data['msg_state'] = table.cellWidget(row, 4).currentText()
msg = QMessageBox.information(
QMessageBox(), 'Alert!!',
'Do you want to change the status of the Message??',
QMessageBox.Yes | QMessageBox.No)
if msg == QMessageBox.Yes:
report = self.message.update_message(data)
if report:
_ = QMessageBox.information(QMessageBox(), 'Success!!',
'The Message was updated',
QMessageBox.Yes | QMessageBox.No)
else:
_ = QMessageBox.critical(QMessageBox(), 'Error!!',
'The Message was not updated',
QMessageBox.Yes | QMessageBox.No)
def search_messages(self):
"""
Searches for messages when search button is pressed
"""
logger.info('Notifications searching messages initiated')
from_date = self.notification_schedule_fromdate_dateedit.text()
to_date = self.notification_schedule_todate_dateedit.text()
limit = self.notification_results.currentText()
msg_id = self.id_line.text()
msg_state = self.notification_states.currentText()
dataobj = self.message.load_message(limit=limit,
from_date=from_date,
to_date=to_date,
msg_id=msg_id,
msg_state=msg_state)
if dataobj:
self.add_messages(*dataobj)
else:
self.notification_schedule_table.clearContents()
self.notification_schedule_table.setRowCount(0)
def load_more(self):
"""
Searches for messages when search button is pressed
"""
logger.info('Notifications searching messages initiated')
from_date = self.notification_schedule_fromdate_dateedit.text()
to_date = self.notification_schedule_todate_dateedit.text()
limit = self.notification_results.currentText()
msg_id = self.id_line.text()
msg_state = self.notification_states.currentText()
offset = self.notification_schedule_table.rowCount()
dataobj = self.message.load_message(limit=limit,
from_date=from_date,
to_date=to_date,
msg_id=msg_id,
msg_state=msg_state,
offset=offset)
if dataobj:
self.add_messages('new', dataobj)
else:
self.notification_schedule_table.clearContents()
self.notification_schedule_table.setRowCount(0)
def load_single_message(self, msg_id): # api
"""method to load a single message"""
self.reset_all()
dataobj = self.message.load_message(msg_id=msg_id)
if dataobj:
self.add_messages('new', dataobj)
self.id_line.setText(str(msg_id))
else:
self.notification_schedule_table.clearContents()
self.notification_schedule_table.setRowCount(0)
def load_rows(self, event):
"""
:return:loads the rows
"""
self.add_messages()
def reset_all(self):
"""
:return: resets the the data in the search text
"""
try:
self.id_line.clear()
self.notification_schedule_table.clearContents()
self.notification_schedule_table.setRowCount(0)
except Exception as _:
if settings.level == 10:
logger.exception('raised exception')
return False
class RecorderClipSelectionScreen(QWidget):
def __init__(self, hyperdeck, state, mainWindow):
super(RecorderClipSelectionScreen, self).__init__()
self.hyperdeck = hyperdeck
self.state = state
self.mainWindow = mainWindow
self.selected_clip = None
layout = QGridLayout()
lblTitle = TitleLabel("Select clip")
layout.addWidget(lblTitle, 0, 0, 1, 3)
self.clipTable = QTableWidget()
self.clipTable.setColumnCount(2)
self.clipTable.setHorizontalHeaderLabels(['ID', 'Clip name'])
self.clipTable.horizontalHeader().setStretchLastSection(True)
self.clipTable.setSelectionBehavior(
QAbstractItemView.SelectionBehavior.SelectRows)
self.clipTable.itemSelectionChanged.connect(self._onClipSelected)
layout.addWidget(self.clipTable, 1, 0, 1, 3)
b = ExpandingButton()
b.setText("Back")
b.setIcon(QIcon(":icons/go-previous"))
b.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
b.clicked.connect(mainWindow.stepBack)
layout.addWidget(b, 2, 0)
btnRefresh = ExpandingButton()
btnRefresh.setText('Refresh')
btnRefresh.setIcon(QIcon(':icons/refresh'))
btnRefresh.setToolButtonStyle(
Qt.ToolButtonStyle.ToolButtonTextBesideIcon)
def refresh():
self.populateClipsList({})
hyperdeck.broadcastClipsList()
btnRefresh.clicked.connect(refresh)
layout.addWidget(btnRefresh, 2, 1)
self.btnSelect = ExpandingButton()
self.btnSelect.setText("Cue clip")
self.btnSelect.clicked.connect(self._cueClip)
layout.addWidget(self.btnSelect, 2, 2)
layout.setRowStretch(0, 0)
layout.setRowStretch(1, 1)
layout.setRowStretch(2, 0)
self.setLayout(layout)
self.populateClipsList(state.clip_listing)
def populateClipsList(self, clipsList):
self.selected_clip = None
self.btnSelect.setEnabled(False)
self.clipTable.clearContents()
self.clipTable.setRowCount(len(clipsList))
for idx, (clip_id, val) in enumerate(clipsList.iteritems()):
self.clipTable.setItem(idx, 0, QTableWidgetItem(str(clip_id)))
self.clipTable.setItem(idx, 1, QTableWidgetItem(val['name']))
def _updateClipSelectionFromState(self, state):
if 'clip id' in state:
clip_id = state['clip id']
for row in range(self.clipTable.rowCount()):
this_id = self.clipTable.item(row, 0)
if this_id.text() == str(clip_id):
self.clipTable.selectRow(row)
break
def _onClipSelected(self):
selected_items = self.clipTable.selectedItems()
if selected_items:
self.selected_clip = int(selected_items[0].text())
self.btnSelect.setEnabled(True)
else:
self.btnSelect.setEnabled(False)
def _cueClip(self):
if self.selected_clip:
self.mainWindow.stepBack()
self.hyperdeck.gotoClip(self.selected_clip)
class SubscriberDialog(QDialog):
if USE_MAEMO_5:
switchRequested = Signal()
def __init__(self, parent=None):
QDialog.__init__(self, parent)
self.ui = Ui_SubscriberDialog()
self.ui.setupUi(self)
self.subscriber = None
self.tableWidget = None
self.listWidget = None
if USE_MAEMO_5:
switchButton = self.ui.buttonBox.addButton(self.tr('Switch'), QDialogButtonBox.ActionRole)
switchButton.clicked.connect(self.switchRequested)
self.tableWidget = self.ui.tableWidget
headerLabels = ('Key', 'Value', 'Type')
self.tableWidget.setColumnCount(3)
self.tableWidget.setHorizontalHeaderLabels(headerLabels)
horizontalHeader = self.tableWidget.horizontalHeader()
horizontalHeader.setStretchLastSection(True)
verticalHeader = self.tableWidget.verticalHeader()
verticalHeader.setVisible(False)
self.tableWidget.setColumnWidth(0, 200)
self.tableWidget.setColumnWidth(1, 400)
else:
desktopWidget = QDesktopWidget()
if desktopWidget.availableGeometry().width() < 400:
# Screen is too small to fit a table widget without scrolling, use a list widget instead.
self.listWidget = QListWidget()
self.listWidget.setAlternatingRowColors(True)
self.ui.verticalLayout.insertWidget(2, self.listWidget)
else:
self.tableWidget = QTableWidget()
headerLabels = ('Key', 'Value', 'Type')
self.tableWidget.setColumnCount(3)
self.tableWidget.setHorizontalHeaderLabels(headerLabels)
horizontalHeader = self.tableWidget.horizontalHeader()
horizontalHeader.setStretchLastSection(True)
self.tableWidget.verticalHeader()
self.setVisible(False)
self.ui.verticalLayout.insertWidget(2, self.tableWidget)
self.ui.connectButton.clicked.connect(self.changeSubscriberPath)
self.changeSubscriberPath()
# if the default path does not exist reset it to /
value = self.subscriber.value()
subPaths = self.subscriber.subPaths()
if not value and not subPaths:
self.ui.basePath.setText('/')
self.changeSubscriberPath()
def changeEvent(self, e):
QDialog.changeEvent(self, e)
if e.type() == QEvent.LanguageChange:
self.ui.retranslateUi(self)
def changeSubscriberPath(self):
if self.listWidget:
self.listWidget.clear()
elif self.tableWidget:
self.tableWidget.clearContents()
if not self.subscriber:
self.subscriber = QValueSpaceSubscriber(self.ui.basePath.text(), self)
else:
self.subscriber.setPath(self.ui.basePath.text())
self.subscriber.contentsChanged.connect(self.subscriberChanged)
self.subscriber.connectNotify("contentsChanged()")
self.subscriberChanged()
def subscriberChanged(self):
subPaths = self.subscriber.subPaths()
if self.listWidget:
self.listWidget.clear()
elif self.tableWidget:
self.tableWidget.clearContents()
self.tableWidget.setRowCount(len(subPaths))
for i in xrange(len(subPaths)):
v = self.subscriber.value(subPaths[i])
if self.listWidget:
item = QListWidgetItem('%s (%s)\n%s' % (subPaths[i], str(type(v)), str(v)))
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
self.listWidget.addItem(item)
elif self.tableWidget:
pathItem = QTableWidgetItem(subPaths[i])
pathItem.setFlags(pathItem.flags() & ~Qt.ItemIsEditable)
valueItem = QTableWidgetItem(str(v))
valueItem.setFlags(pathItem.flags() & ~Qt.ItemIsEditable)
typeItem = QTableWidgetItem(str(type(v)))
typeItem.setFlags(pathItem.flags() & ~Qt.ItemIsEditable)
self.tableWidget.setItem(i, 0, pathItem)
self.tableWidget.setItem(i, 1, valueItem)
self.tableWidget.setItem(i, 2, typeItem)
class WasteItems():
"""Item waste management tab"""
global logger
def __init__(self):
###
logger.info('Inside WasteItems')
self.wastedetail_tab_1 = QWidget()
self.wastedetail_tab_1.setObjectName("wastedetail_tab_1")
self.verticalLayout_9 = QVBoxLayout(self.wastedetail_tab_1)
self.verticalLayout_9.setObjectName("verticalLayout_9")
self.verticalLayout_8 = QVBoxLayout()
self.verticalLayout_8.setObjectName("verticalLayout_8")
self.horizontalLayout_12 = QHBoxLayout()
self.horizontalLayout_12.setObjectName("horizontalLayout_12")
self.waste_fromdate_label = QLabel(self.wastedetail_tab_1)
self.waste_fromdate_label.setObjectName('waste_fromdate_label')
self.horizontalLayout_12.addWidget(self.waste_fromdate_label)
self.waste_fromdate_dateedit = QDateEdit(self.wastedetail_tab_1)
self.waste_fromdate_dateedit.setCalendarPopup(True)
self.waste_fromdate_dateedit.setObjectName("waste_fromdate_dateedit")
self.horizontalLayout_12.addWidget(self.waste_fromdate_dateedit)
self.waste_todate_label = QLabel(self.wastedetail_tab_1)
self.waste_todate_label.setObjectName('waste_todate_label')
self.horizontalLayout_12.addWidget(self.waste_todate_label)
self.waste_todate_dateedit = QDateEdit(self.wastedetail_tab_1)
self.waste_todate_dateedit.setCalendarPopup(True)
self.waste_todate_dateedit.setObjectName("waste_todate_dateedit")
self.waste_todate_dateedit.setMaximumDate(QDate.currentDate())
self.horizontalLayout_12.addWidget(self.waste_todate_dateedit)
spacerItem28 = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.horizontalLayout_12.addItem(spacerItem28)
self.waste_table_search_button = QPushButton(self.wastedetail_tab_1)
self.waste_table_search_button.setObjectName(
"waste_table_search_button")
self.horizontalLayout_12.addWidget(self.waste_table_search_button)
self.verticalLayout_8.addLayout(self.horizontalLayout_12)
self.waste_table = QTableWidget(self.wastedetail_tab_1)
self.waste_table.setObjectName("waste_table")
self.waste_table.setColumnCount(6)
self.waste_table.setRowCount(0)
item = QTableWidgetItem()
self.waste_table.setHorizontalHeaderItem(0, item)
item = QTableWidgetItem()
self.waste_table.setHorizontalHeaderItem(1, item)
item = QTableWidgetItem()
self.waste_table.setHorizontalHeaderItem(2, item)
item = QTableWidgetItem()
self.waste_table.setHorizontalHeaderItem(3, item)
item = QTableWidgetItem()
self.waste_table.setHorizontalHeaderItem(4, item)
item = QTableWidgetItem()
self.waste_table.setHorizontalHeaderItem(5, item)
self.waste_table.horizontalHeader().setCascadingSectionResizes(False)
self.waste_table.horizontalHeader().setStretchLastSection(True)
self.waste_table.verticalHeader().setVisible(False)
self.waste_table.verticalHeader().setCascadingSectionResizes(False)
self.waste_table.setSortingEnabled(True)
self.verticalLayout_8.addWidget(self.waste_table)
self.verticalLayout_9.addLayout(self.verticalLayout_8)
##retranslate
self.waste_fromdate_label.setText(
QApplication.translate("MainWindow", "From Date", None,
QApplication.UnicodeUTF8))
self.waste_fromdate_dateedit.setDisplayFormat(
QApplication.translate("MainWindow", "dd/MM/yyyy", None,
QApplication.UnicodeUTF8))
self.waste_todate_label.setText(
QApplication.translate("MainWindow", "To Date", None,
QApplication.UnicodeUTF8))
self.waste_todate_dateedit.setDisplayFormat(
QApplication.translate("MainWindow", "dd/MM/yyyy", None,
QApplication.UnicodeUTF8))
self.waste_table_search_button.setText(
QApplication.translate("MainWindow", "Search", None,
QApplication.UnicodeUTF8))
self.waste_table.horizontalHeaderItem(0).setText(
QApplication.translate("MainWindow", "Code", None,
QApplication.UnicodeUTF8))
self.waste_table.horizontalHeaderItem(1).setText(
QApplication.translate("MainWindow", "Item", None,
QApplication.UnicodeUTF8))
self.waste_table.horizontalHeaderItem(2).setText(
QApplication.translate("MainWindow", "Category", None,
QApplication.UnicodeUTF8))
self.waste_table.horizontalHeaderItem(3).setText(
QApplication.translate("MainWindow", "Units", None,
QApplication.UnicodeUTF8))
self.waste_table.horizontalHeaderItem(4).setText(
QApplication.translate("MainWindow", "Quantity", None,
QApplication.UnicodeUTF8))
self.waste_table.horizontalHeaderItem(5).setText(
QApplication.translate("MainWindow", "Reason", None,
QApplication.UnicodeUTF8))
###signals and slots && other stuffs
# self.mainwindow = Ui_MainWindow # just for the ease of finding the attributes in pycharm
self.item = WasteIngredients()
self.waste_fromdate_dateedit.setDate(QDate.currentDate())
self.waste_todate_dateedit.setDate(QDate.currentDate())
self.waste_table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.waste_table_search_button.clicked.connect(self.search_discard)
self.wastedetail_tab_1.setFocusPolicy(Qt.StrongFocus)
self.wastedetail_tab_1.focusInEvent = self.load_rows
def load_rows(self, event=None):
"""calling add row to restructure the table every time container resizes"""
self.add_row_to_table()
def search_discard(self):
"""
searches the discard from_date and to_date
:return:none
"""
f_date = self.waste_fromdate_dateedit.text()
from_date = datetime.strptime(f_date, '%d/%m/%Y')
t_date = self.waste_todate_dateedit.text()
to_date = datetime.strptime(t_date, '%d/%m/%Y')
to_date = to_date + timedelta(hours=23, minutes=59, seconds=59)
dataobj = self.item.find_itemdiscard(from_date=from_date,
to_date=to_date)
self.add_row_to_table(*dataobj)
def add_row_to_table(self, *args):
"""
complex stuff of auto complete to be added to each combo box
:return:
"""
table = self.waste_table
if args:
table.clearContents()
table.setRowCount(0)
table.setRowCount(len(args))
for i, j in enumerate(args):
code = QTableWidgetItem(j['code'])
table.setItem(i, 0, code)
item = QTableWidgetItem(j['item'])
table.setItem(i, 1, item)
category = QTableWidgetItem(j['category'])
table.setItem(i, 2, category)
unit = QTableWidgetItem(str(j['units']))
table.setItem(i, 3, unit)
quantity = QTableWidgetItem(str(j['quantity']))
table.setItem(i, 4, quantity)
reason = QTableWidgetItem(j['reason_for_discard'])
table.setItem(i, 5, reason)
table.setColumnWidth(0, (table.width() / 6))
table.setColumnWidth(1, (table.width() / 6))
table.setColumnWidth(2, (table.width() / 6))
table.setColumnWidth(3, (table.width() / 6))
table.setColumnWidth(4, (table.width() / 6))
table.horizontalHeader().setStretchLastSection(True)
class ImportMovementPanel(PanelWithTable):
columnList = ReportMovementPanel.columnList
def __init__(self):
super(self.__class__, self).__init__()
self.layout = QtGui.QGridLayout(self)
self.importMovementFilter = ImportMovementFilter(self)
self.layout.addWidget(self.importMovementFilter, 1, 0,
QtCore.Qt.AlignTop)
self.layout.addWidget(self.createTable(), 1, 1, QtCore.Qt.AlignTop)
self.btnImport = QPushButton("Import", self)
self.btnImport.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.layout.addWidget(self.btnImport)
self.btnDelete = QPushButton("Delete", self)
self.btnDelete.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
self.layout.addWidget(self.btnDelete)
self.initListener()
def initListener(self):
self.btnImport.clicked.connect(self.doImport)
self.btnDelete.clicked.connect(self.doDelete)
def createTable(self):
self.table = QTableWidget()
self.table.setRowCount(1000)
self.table.setColumnCount(len(self.columnList) + 1)
self.table.setColumnHidden(
Constant.CONST_COLUMN_IMPORT_MOVEMENT_HIDDEN_ID, True)
self.table.setEditTriggers(QtGui.QAbstractItemView.NoEditTriggers)
self.table.setHorizontalHeaderLabels(self.columnList)
#self.pnLTableWidget.resizeColumnsToContents()
self.table.sortItems(Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_DATE)
self.table.doubleClicked.connect(self.doImportOrDelete)
self.table.resizeRowsToContents()
self.table.setFixedSize(1100, 900)
return self.table
def doSubmit(self, filePath, assetName):
self.imLO = MovementImporter().getMovementList(filePath, assetName)
self.table.setSortingEnabled(False)
self.table.clearContents()
if (self.imLO.movementList is not None):
countRowTable = len(self.imLO.movementList)
self.table.setRowCount(countRowTable)
self.renderTableForObject(self.imLO.movementList)
imLO2 = Engine.getReportMovementList(self.imLO.fromDate,
self.imLO.toDate, 'ALL',
assetName,
self.imLO.custodyName)
countRowTable += len(imLO2.movementList)
self.table.setRowCount(countRowTable)
self.renderTableForRS(imLO2.movementList)
self.table.setSortingEnabled(True)
self.table.resizeRowsToContents()
def renderTableForObject(self, tableList):
self.row = 0
isBold = False
color = QtGui.QColor(204, 255, 153)
for movement in tableList:
self.addItemtoTable2(
self.table, movement.OID, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_ID, isBold, color)
self.addItemtoTable2(
self.table, movement.externalID, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_EXTERNAL_ID, isBold,
color)
self.addItemtoTable2(self.table, movement.comment, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_COMMENT,
isBold, color)
self.addItemtoTable2(
self.table, movement.custody.name, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_CUSTODY_NAME, isBold,
color)
self.addItemtoTable2(
self.table, movement.getMovementType(), self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_TYPE, isBold,
color)
self.addItemtoTable2(
self.table, movement.getMovementSubType(), self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_SUB_TYPE, isBold,
color)
if (movement.asset is not None):
self.addItemtoTable2(
self.table, movement.asset.name, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_ASSET_NAME, isBold,
color)
if (movement.tax is not None):
self.addItemtoTable2(
self.table, "NEW", self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_TAX_ID, isBold,
color)
self.addItemtoTable2(
self.table, movement.tax.taxAmount, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_TAX_AMOUNT, isBold,
color)
if (isinstance(movement, Movement)):
self.addItemtoTable2(
self.table, movement.buySell, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_DIRECTION,
isBold, color)
self.addItemtoTable2(
self.table, movement.acquisitionDate, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_DATE, isBold,
color)
self.addItemtoTable2(
self.table, movement.quantity, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_QUANTITY, isBold,
color)
self.addItemtoTable2(
self.table, movement.price, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_PRICE, isBold, color)
self.addItemtoTable2(
self.table, movement.rate, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_RATE, isBold, color)
self.addItemtoTable2(
self.table, movement.grossAmount, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_GROSS_AMOUNT, isBold,
color)
self.addItemtoTable2(
self.table, movement.netAmount, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_NET_AMOUNT, isBold,
color)
self.addItemtoTable2(
self.table, movement.commissionPercentage, self.row,
Constant.
CONST_COLUMN_IMPORT_MOVEMENT_COMMISSION_PERCENTAGE, isBold,
color)
self.addItemtoTable2(
self.table, movement.commissionAmount, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_COMMISSION_AMOUNT,
isBold, color)
self.addItemtoTable2(
self.table, movement.commissionVATAmount, self.row,
Constant.
CONST_COLUMN_IMPORT_MOVEMENT_COMMISSION_IVA_AMOUNT, isBold,
color)
self.addItemtoTable2(
self.table, movement.tenor, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_TENOR, isBold, color)
self.addItemtoTable2(
self.table, movement.maturityDate, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_MATURITY_DATE,
isBold, color)
elif (isinstance(movement, CorporateEvent)):
self.addItemtoTable2(
self.table, movement.paymentDate, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_DATE, isBold,
color)
self.addItemtoTable2(
self.table, movement.grossAmount, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_GROSS_AMOUNT, isBold,
color)
self.addItemtoTable2(
self.table, movement.netAmount, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_NET_AMOUNT, isBold,
color)
elif (isinstance(movement, CashMovement)):
self.addItemtoTable2(
self.table, movement.inOut, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_DIRECTION,
isBold, color)
self.addItemtoTable2(
self.table, movement.movementDate, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_DATE, isBold,
color)
self.addItemtoTable2(
self.table, movement.amount, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_GROSS_AMOUNT, isBold,
color)
self.addItemtoTable2(
self.table, movement.amount, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_NET_AMOUNT, isBold,
color)
#HiddenID
self.addItemtoTable2(
self.table, self.row, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_HIDDEN_ID, isBold)
self.row += 1
def renderTableForRS(self, tableList):
isBold = False
for listItem in tableList:
self.addItemtoTable(self.table, listItem, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_ID,
isBold)
self.addItemtoTable(
self.table, listItem, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_TYPE, isBold)
self.addItemtoTable(
self.table, listItem, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_SUB_TYPE, isBold)
self.addItemtoTable(
self.table, listItem, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_DIRECTION, isBold)
self.addItemtoTable(
self.table, listItem, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_ASSET_NAME, isBold)
self.addItemtoTable(
self.table, listItem, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_DATE, isBold)
self.addItemtoTable(self.table, listItem, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_QUANTITY,
isBold)
self.addItemtoTable(self.table, listItem, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_PRICE,
isBold)
self.addItemtoTable(self.table, listItem, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_RATE,
isBold)
self.addItemtoTable(
self.table, listItem, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_GROSS_AMOUNT, isBold)
self.addItemtoTable(
self.table, listItem, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_NET_AMOUNT, isBold)
self.addItemtoTable(
self.table, listItem, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_COMMISSION_PERCENTAGE,
isBold)
self.addItemtoTable(
self.table, listItem, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_COMMISSION_AMOUNT,
isBold)
self.addItemtoTable(
self.table, listItem, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_COMMISSION_IVA_AMOUNT,
isBold)
self.addItemtoTable(self.table, listItem, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_TENOR,
isBold)
self.addItemtoTable(
self.table, listItem, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_MATURITY_DATE, isBold)
self.addItemtoTable(
self.table, listItem, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_CUSTODY_NAME, isBold)
self.addItemtoTable(self.table, listItem, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_TAX_ID,
isBold)
self.addItemtoTable(
self.table, listItem, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_TAX_AMOUNT, isBold)
self.addItemtoTable(self.table, listItem, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_COMMENT,
isBold)
self.addItemtoTable(
self.table, listItem, self.row,
Constant.CONST_COLUMN_IMPORT_MOVEMENT_EXTERNAL_ID, isBold)
self.row += 1
def doImportOrDelete(self):
index = self.getCurrentRowValue(
Constant.CONST_COLUMN_IMPORT_MOVEMENT_HIDDEN_ID)
if (index is not None):
self.doImport()
else:
self.doDelete()
def doImport(self):
index = self.getCurrentRowValue(
Constant.CONST_COLUMN_IMPORT_MOVEMENT_HIDDEN_ID)
if (index is not None):
operation = self.imLO.movementList[int(index)]
print(operation.externalID)
newID = None
taxNewID = None
if (isinstance(operation, Movement)):
rs = DaoMovement.getMovementsByExternalID(operation.externalID)
if len(rs) == 0:
if (operation.OID == "NEW"):
newID = DaoMovement.insertMovement(operation)
if (operation.tax is not None and operation.tax.OID == "NEW"):
rs = DaoTax.getTaxByExternalID(operation.tax.externalID)
if len(rs) == 0:
taxNewID = DaoTax.insert(operation.tax)
elif (isinstance(operation, CorporateEvent)):
rs = DaoCorporateEvent.getCorporateEventByExternalID(
operation.externalID)
if len(rs) == 0:
newID = DaoCorporateEvent.insert(operation)
print(newID)
if (operation.tax is not None):
rs = DaoTax.getTaxByExternalID(
operation.tax.externalID)
if len(rs) == 0:
operation.tax.originOID = newID
taxNewID = DaoTax.insert(operation.tax)
elif (isinstance(operation, CashMovement)):
rs = DaoCashMovement.getCashMovementsByExternalID(
operation.externalID)
if len(rs) == 0:
newID = DaoCashMovement.insert(operation)
box = QMessageBox()
box.setWindowTitle('ADD')
if (newID is None and taxNewID is None):
box.setText("CANNOT ADD externalID " + operation.externalID)
else:
if (newID is not None and taxNewID is not None):
box.setText("INSERTED MOVEMENT " + operation.externalID +
" NEWID: " + str(newID) + " NEWTAXID: " +
str(taxNewID))
elif (newID is not None and taxNewID is None):
box.setText("INSERTED MOVEMENT " + operation.externalID +
" NEWID: " + str(newID))
else:
box.setText("INSERTED TAX " + operation.tax.externalID +
" NEWTAXID: " + str(taxNewID))
box.exec_()
def doDelete(self):
movementOID = self.getCurrentRowValue(
Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_ID)
movementType = self.getCurrentRowValue(
Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_TYPE)
movementSubType = self.getCurrentRowValue(
Constant.CONST_COLUMN_IMPORT_MOVEMENT_EVENT_SUB_TYPE)
taxOID = self.getCurrentRowValue(
Constant.CONST_COLUMN_IMPORT_MOVEMENT_TAX_ID)
result = 0
if (movementType == Constant.CONST_MOVEMENT_TYPE
and movementSubType == Constant.CONST_MOVEMENT_SUB_TYPE):
result = DaoMovement.deleteMovement(movementOID)
print(result)
elif (movementType == Constant.CONST_MOVEMENT_TYPE
and movementSubType == Constant.CONST_CASH_MOVEMENT_SUB_TYPE):
result = DaoCashMovement.deleteCashMovement(movementOID)
print(result)
elif (movementType == Constant.CONST_CORP_EVENT_TYPE
and movementSubType == Constant.CONST_CORP_EVENT_SUB_TYPE):
if (taxOID):
taxResult = DaoTax.deleteTax(taxOID)
result = DaoCorporateEvent.deleteCorporateEvent(movementOID)
print(result)
box = QMessageBox()
box.setWindowTitle('DELETED')
if (result == 0):
box.setText("CANNOT DELETE " + movementType + "-" +
movementSubType + "-" + movementOID)
else:
if (taxOID is None or taxOID == ""):
box.setText(movementType + "-" + movementSubType + "-" +
movementOID + ": " + str(result) +
" record(s) deleted")
else:
box.setText(movementType + "-" + movementSubType + "-" +
movementOID + ": " + str(result) +
" record(s) deleted and taxID: " + taxOID + " " +
str(taxResult) + " record(s) deleted")
box.exec_()
class WasteDish():
"""Dish waste management tab"""
global logger
def __init__(self):
###
logger.info('Inside WasteDish')
self.wastedetail_tab_1 = QWidget()
self.wastedetail_tab_1.setObjectName("wastedetail_tab_1")
self.verticalLayout_9 = QVBoxLayout(self.wastedetail_tab_1)
self.verticalLayout_9.setObjectName("verticalLayout_9")
self.verticalLayout_8 = QVBoxLayout()
self.verticalLayout_8.setObjectName("verticalLayout_8")
self.horizontalLayout_12 = QHBoxLayout()
self.horizontalLayout_12.setObjectName("horizontalLayout_12")
self.waste_fromdate_label = QLabel(self.wastedetail_tab_1)
self.waste_fromdate_label.setObjectName('waste_fromdate_label')
self.horizontalLayout_12.addWidget(self.waste_fromdate_label)
self.waste_fromdate_dateedit = QDateEdit(self.wastedetail_tab_1)
self.waste_fromdate_dateedit.setCalendarPopup(True)
self.waste_fromdate_dateedit.setObjectName("waste_fromdate_dateedit")
self.horizontalLayout_12.addWidget(self.waste_fromdate_dateedit)
self.waste_todate_label = QLabel(self.wastedetail_tab_1)
self.waste_todate_label.setObjectName('waste_todate_label')
self.horizontalLayout_12.addWidget(self.waste_todate_label)
self.waste_todate_dateedit = QDateEdit(self.wastedetail_tab_1)
self.waste_todate_dateedit.setCalendarPopup(True)
self.waste_todate_dateedit.setObjectName("waste_todate_dateedit")
self.waste_todate_dateedit.setMaximumDate(QDate.currentDate())
self.horizontalLayout_12.addWidget(self.waste_todate_dateedit)
spacerItem28 = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.horizontalLayout_12.addItem(spacerItem28)
self.waste_table_search_button = QPushButton(self.wastedetail_tab_1)
self.waste_table_search_button.setObjectName(
"waste_table_search_button")
self.horizontalLayout_12.addWidget(self.waste_table_search_button)
self.verticalLayout_8.addLayout(self.horizontalLayout_12)
self.waste_table = QTableWidget(self.wastedetail_tab_1)
self.waste_table.setObjectName("waste_table")
self.waste_table.setColumnCount(5)
self.waste_table.setRowCount(0)
item = QTableWidgetItem()
self.waste_table.setHorizontalHeaderItem(0, item)
item = QTableWidgetItem()
self.waste_table.setHorizontalHeaderItem(1, item)
item = QTableWidgetItem()
self.waste_table.setHorizontalHeaderItem(2, item)
item = QTableWidgetItem()
self.waste_table.setHorizontalHeaderItem(3, item)
item = QTableWidgetItem()
self.waste_table.setHorizontalHeaderItem(4, item)
self.waste_table.horizontalHeader().setCascadingSectionResizes(False)
self.waste_table.horizontalHeader().setStretchLastSection(True)
self.waste_table.verticalHeader().setVisible(False)
self.waste_table.verticalHeader().setCascadingSectionResizes(False)
self.waste_table.setSortingEnabled(True)
self.verticalLayout_8.addWidget(self.waste_table)
self.horizontalLayout_13 = QHBoxLayout()
self.horizontalLayout_13.setObjectName("horizontalLayout_13")
self.waste_table_newrow_button = QPushButton(self.wastedetail_tab_1)
self.waste_table_newrow_button.setObjectName(
"waste_table_newrow_button")
self.horizontalLayout_13.addWidget(self.waste_table_newrow_button)
spacerItem29 = QSpacerItem(612, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.horizontalLayout_13.addItem(spacerItem29)
self.waste_table_discard_button = QPushButton(self.wastedetail_tab_1)
self.waste_table_discard_button.setObjectName(
"waste_table_discard_button")
self.horizontalLayout_13.addWidget(self.waste_table_discard_button)
self.verticalLayout_8.addLayout(self.horizontalLayout_13)
self.verticalLayout_9.addLayout(self.verticalLayout_8)
##retranslate
self.waste_fromdate_label.setText(
QApplication.translate("MainWindow", "From Date", None,
QApplication.UnicodeUTF8))
self.waste_fromdate_dateedit.setDisplayFormat(
QApplication.translate("MainWindow", "dd/MM/yyyy", None,
QApplication.UnicodeUTF8))
self.waste_todate_label.setText(
QApplication.translate("MainWindow", "To Date", None,
QApplication.UnicodeUTF8))
self.waste_todate_dateedit.setDisplayFormat(
QApplication.translate("MainWindow", "dd/MM/yyyy", None,
QApplication.UnicodeUTF8))
self.waste_table_search_button.setText(
QApplication.translate("MainWindow", "Search", None,
QApplication.UnicodeUTF8))
self.waste_table.horizontalHeaderItem(0).setText(
QApplication.translate("MainWindow", "Code", None,
QApplication.UnicodeUTF8))
self.waste_table.horizontalHeaderItem(1).setText(
QApplication.translate("MainWindow", "Item", None,
QApplication.UnicodeUTF8))
self.waste_table.horizontalHeaderItem(2).setText(
QApplication.translate("MainWindow", "Category", None,
QApplication.UnicodeUTF8))
self.waste_table.horizontalHeaderItem(3).setText(
QApplication.translate("MainWindow", "Quantity", None,
QApplication.UnicodeUTF8))
self.waste_table.horizontalHeaderItem(4).setText(
QApplication.translate("MainWindow", "Reason", None,
QApplication.UnicodeUTF8))
self.waste_table_newrow_button.setText(
QApplication.translate("MainWindow", "New Row", None,
QApplication.UnicodeUTF8))
self.waste_table_discard_button.setText(
QApplication.translate("MainWindow", "Discard Item", None,
QApplication.UnicodeUTF8))
self.wastedetail_tab_1.setTabOrder(self.waste_fromdate_dateedit,
self.waste_todate_dateedit)
self.wastedetail_tab_1.setTabOrder(self.waste_todate_dateedit,
self.waste_table_search_button)
###signals and slots && other stuffs
# self.mainwindow = Ui_MainWindow # just for the ease of finding the attributes in pycharm
self.schedule = SchedulePurchase()
self.suplier = BusinessParty(category='Supplier')
self.add = AddStockInventory()
self.item = WasteMenu()
self.waste_fromdate_dateedit.setDate(QDate.currentDate())
self.waste_todate_dateedit.setDate(QDate.currentDate())
self.waste_table.setEditTriggers(QAbstractItemView.NoEditTriggers)
self.waste_table_newrow_button.clicked.connect(self.add_new_blank_rows)
self.waste_table_discard_button.clicked.connect(self.discard)
self.waste_table_search_button.clicked.connect(self.search_discard)
self.wastedetail_tab_1.setFocusPolicy(Qt.StrongFocus)
self.wastedetail_tab_1.focusInEvent = self.load_rows
def load_rows(self, event=None):
pass
def add_new_blank_rows(self):
"""
deletes the schedules in the database
"""
table = self.waste_table
item = table.item(0, 0)
if item:
message = QMessageBox.critical(QMessageBox(), 'Warning!',
'This will remove all the entries',
QMessageBox.Ok | QMessageBox.Cancel)
if message == QMessageBox.Ok:
table.setRowCount(0)
table.clearContents()
self.add_row_to_table('new')
self.waste_table_discard_button.setVisible(True)
elif not item:
self.waste_table_discard_button.setVisible(True)
self.add_row_to_table('new')
def add_row_to_table(self, *args):
"""
complex stuff of auto complete to be added to each combo box
:return:
"""
table = self.waste_table
if args:
if args[0] != 'new':
table.clearContents()
table.setRowCount(0)
table.setRowCount(len(args))
for i, j in enumerate(args):
code = QTableWidgetItem(j['code'])
table.setItem(i, 0, code)
item = QTableWidgetItem(j['item'])
table.setItem(i, 1, item)
category = QTableWidgetItem(j['category'])
table.setItem(i, 2, category)
quantity = QTableWidgetItem(str(j['quantity']))
table.setItem(i, 3, quantity)
reason = QTableWidgetItem(j['reason_for_discard'])
table.setItem(i, 4, reason)
if args[0] == 'new':
row = table.rowCount() + 1
table.setRowCount(row)
codeline = QLineEdit()
codeline.editingFinished.connect(
lambda: self.get_details_of_code(row))
table.setCellWidget(row - 1, 0, codeline)
itemcombo = QComboBox()
self.fill_item_list(itemcombo)
itemcombo.currentIndexChanged.connect(
lambda: self.get_details_of_item(row))
table.setCellWidget(row - 1, 1, itemcombo)
category = QTableWidgetItem()
table.setItem(row - 1, 2, category)
quantity = QLineEdit()
table.setCellWidget(row - 1, 3, quantity)
combo = QComboBox()
combo.addItem("Cancelled")
combo.addItem("Mishandling")
combo.addItem("Excess")
table.setCellWidget(row - 1, 4, combo)
table.setColumnWidth(0, (table.width() / 5))
table.setColumnWidth(1, (table.width() / 5))
table.setColumnWidth(2, (table.width() / 5))
table.setColumnWidth(3, (table.width() / 5))
table.horizontalHeader().setStretchLastSection(
True
) # important to resize last section else blank space after last column
def fill_item_list(self, combo):
"""
fill the item combo box
:param combo: the combobox object
:return: none
"""
itemfield = combo
itemfield.setStyleSheet("QAbstractItemView{"
"background: #4B77BE;"
"}")
self.item.populate_item(itemfield)
def get_details_of_code(self, rowcount):
"""
fills the item, category and units based on the code
:param rowcount: the row count
:return: none
"""
row = rowcount - 1
table = self.waste_table
codeline = table.cellWidget(row, 0)
data = self.item.get_details_of_code(codeline.text())
item = table.cellWidget(row, 1)
index = item.findText(data['item'])
item.setCurrentIndex(index)
category = table.item(row, 2)
category.setText(data['category'])
def get_details_of_item(self, rowcount):
"""
fills the code, category and units based on the item
:param rowcount: the row count
:return: none
"""
row = rowcount - 1
table = self.waste_table
itemcombo = table.cellWidget(row, 1)
data = self.item.get_details_of_item(itemcombo.currentText())
code = table.cellWidget(row, 0)
code.setText(data['code'])
category = table.item(row, 2)
category.setText(data['category'])
def discard(self):
"""
saves the details in db before printing
"""
logger.info('WasteDish discard initiated')
table = self.waste_table
data = self.get_data()
if data:
for i in data:
status = self.item.discard(i)
if status:
model_index = table.indexFromItem(i['model_item'])
row = model_index.row()
table.removeRow(row)
else:
msg = QMessageBox.critical(QMessageBox(), "Error!!",
"The item cannot be discarded",
QMessageBox.Ok)
if msg == QMessageBox.Ok:
return False
def search_discard(self):
"""
searches the discard from_date and to_date
:return:none
"""
table = self.waste_table
item = table.cellWidget(0, 0)
if item:
msg = QMessageBox.critical(QMessageBox(), 'Warning!',
'This will delete all the rows added',
QMessageBox.Ok | QMessageBox.Cancel)
if msg == QMessageBox.Cancel:
return False
f_date = self.waste_fromdate_dateedit.text()
from_date = datetime.strptime(f_date, '%d/%m/%Y')
t_date = self.waste_todate_dateedit.text()
to_date = datetime.strptime(t_date, '%d/%m/%Y')
to_date = to_date + timedelta(hours=23, minutes=59, seconds=59)
dataobj = self.item.find_itemdiscard(from_date=from_date,
to_date=to_date)
self.add_row_to_table(*dataobj)
self.waste_table_discard_button.setVisible(False)
def get_data(self):
"""
:return: fetches all the data for printing
"""
table = self.waste_table
rows = table.rowCount()
dataobj = []
for i in range(rows):
dictionary = {}
item = table.cellWidget(i, 0) if table.cellWidget(
i, 0) is not None else table.item(i, 0)
dictionary['code'] = item.text()
if dictionary['code'] == '':
break
item = table.cellWidget(i, 1).currentText() if table.cellWidget(
i, 1) is not None else table.item(i, 1).text()
dictionary['item'] = item
item = table.cellWidget(i, 2) if table.cellWidget(
i, 2) is not None else table.item(i, 2)
dictionary['category'] = item.text()
item = table.cellWidget(i, 3) if table.cellWidget(
i, 3) is not None else table.item(i, 3)
dictionary['quantity'] = item.text()
if dictionary['quantity'] == '':
self.show_error('Quantity')
return False
item = table.cellWidget(i, 4).currentText() if table.cellWidget(
i, 4) is not None else table.item(i, 4).text()
dictionary['reason_for_discard'] = item
dictionary['model_item'] = table.item(i, 2)
dataobj.append(dictionary)
return dataobj
def show_error(self, text):
"""
:return: pops up an error
"""
QMessageBox.critical(QMessageBox(), "Fail!!",
"Please Enter %s properly" % text, QMessageBox.Ok)
class TableWidgetController(AbstractViewController, Ui_TableWidget):
'''
The controller part for a data table widget. The UI part is declared
in tablewidget_v1.ui and then converted to ui_tablewidget.py.
This widget can be fed tabular data and has several options for showing it.
@since: 2010-11-10
'''
__author__ = "Moritz Wade"
__contact__ = "*****@*****.**"
__copyright__ = "Zuse Institute Berlin 2010"
def __init__(self, parent=None, host=None, title="Table", mode=None):
'''
Constructor
'''
super(TableWidgetController, self).__init__(parent)
self.setupUi(self)
self.setWindowTitle(title)
self._initialize()
# self.options = {
# OPTION_SORTABLE_COLUMNS: self.checkBoxSortableColumns.isChecked(),
# }
self._mode = MODE_DEFAULT
self.maxValue = -1
self.host = host
self.data = None
self.dataTableHeaders = []
self.dataTableColumnData = []
self.dataTableRowCount = -1
self.dataTableRowHeaders = None
self.dataTableWidget = None
self.isColored = False
self.checkBoxShowUnits.setChecked(DEFAULT_SHOW_UNITS)
self.showUnits = DEFAULT_SHOW_UNITS
self.orientation = ORIENTATION_HORIZONTAL
self.sortColumn = -1 # default: do not sort at load
self.colorThreshold = None
self.colorThresholdBase = self.doubleSpinBox_Coloring_Threshold.value()
self.colorThresholdExponent = self.spinBox_Coloring_Exponent.value()
if mode:
self.setMode(mode)
self._updateThreshold()
def setMode(self, mode):
self._mode = mode
if mode == MODE_SUBCONDITIONS:
rtolScientificString = '{:e}'.format(float(self.host.getRTol()))
exponentStr = rtolScientificString.split("e")[1]
self.spinBox_Coloring_Exponent.setValue(float(exponentStr))
self.doubleSpinBox_Coloring_Threshold.setValue(1.0)
self.label_Coloring_Threshold.setText(
"Anticipated Relative Measurement Error")
self.groupBox_Coloring.setChecked(True)
self.isColored = True
elif mode == MODE_JACOBIAN:
self.groupBox_Coloring.setChecked(
True) # just activate coloring with default threshold
self.isColored = True
def _updateView(self, data=None):
'''
Overriding the "abstract" base class method. This does the main "drawing" of data, i.e.
generates the table and fills it with data.
'''
if data:
self.data = data
if self.data:
self._updateDataTable(self.data)
def _clearView(self):
if self.dataTableWidget:
self.dataTableWidget.clear()
def _setRowHeaders(self, dataDescriptors):
'''
Sets the given datadescriptors (from an EntityData object) as row headers
of the table, thereby checking for floats and rounding them, as not to show too
many digits after the point.
'''
#self.dataTableRowHeaders = dataDescriptors
if not dataDescriptors:
logging.debug(
"TableWidgetController._setRowHeaders(): Empty dataDescriptor list."
)
return
self.dataTableRowHeaders = []
for descriptor in dataDescriptors:
try:
descriptor = float(descriptor)
descriptor = round(descriptor, 4)
except ValueError:
pass
self.dataTableRowHeaders.append(
str(descriptor)) # the QTableWidget needs a list of Strings
def _computeColor(self, value):
if type(value) == str:
if value == "N/A":
return COLOR_LOW
try:
value = float(value)
except:
return None
if self._mode == MODE_DEFAULT or self._mode == MODE_JACOBIAN:
if value <= self.colorThreshold:
color = COLOR_LOW
else:
color = COLOR_HIGH
elif self._mode == MODE_SUBCONDITIONS:
if value >= self.colorThreshold:
color = COLOR_LOW
else:
#percentage = value / float(self.maxValue)
percentage = (self.maxValue - value + 1) / float(
self.maxValue
) # +1 because it's the "lowest" subconditon, and represents 100%
highRed, highGreen, highBlue, highAlpha = COLOR_HIGH.red(
), COLOR_HIGH.green(), COLOR_HIGH.blue(), COLOR_HIGH.alpha()
mediumRed, mediumGreen, mediumBlue, mediumAlpha = COLOR_MEDIUM.red(
), COLOR_MEDIUM.green(), COLOR_MEDIUM.blue(
), COLOR_MEDIUM.alpha()
diffRed, diffGreen, diffBlue, diffAlpha = highRed - mediumRed, highGreen - mediumGreen, highBlue - mediumBlue, highAlpha - mediumAlpha
valueRed = diffRed * percentage + mediumRed
valueGreen = diffGreen * percentage + mediumGreen
valueBlue = diffBlue * percentage + mediumBlue
valueAlpha = diffAlpha * percentage + mediumAlpha
color = QColor(valueRed, valueGreen, valueBlue, valueAlpha)
else:
color = QColor(0, 0, 0, 255) #transparent
return color
def _updateDataTable(self, data):
'''
Updates the data table with data from the last integration.
'''
#prepare data
self.dataTableHeaders = []
self.dataTableColumnData = []
self.dataTableRowCount = -1
self.dataTableRowHeaders = None
self.maxValue = -1
for (entity, entityDataList) in data.items():
for entityData in entityDataList:
dataDescriptors = entityData.dataDescriptors
if not self.dataTableRowHeaders:
self._setRowHeaders(dataDescriptors)
elif len(self.dataTableRowHeaders) != len(dataDescriptors):
logging.debug(
"Different number of time points for two Species. Last Species (%s) will be skipped."
% entity)
continue
# set header for first column (dataDescriptor/Timepoint col)
# in first iteration
if len(self.dataTableHeaders) == 0:
dataDescriptorName = entityData.dataDescriptorName
dataDescriptorUnit = entityData.dataDescriptorUnit
if not dataDescriptorUnit and "timepoint" in str(
dataDescriptorName).lower():
dataDescriptorUnit = self.host.optionTimeUnit
firstColHeader = ""
if dataDescriptorName:
if self.showUnits:
firstColHeader = "%s [%s]" % (dataDescriptorName,
dataDescriptorUnit)
elif dataDescriptorName:
firstColHeader = "%s" % dataDescriptorName
self.dataTableHeaders.append(firstColHeader)
#self.dataTableHeaders.append("Time species %s [%s]" % (str(speciesID), self.lineEditTimeUnit.text()))
#self.dataTableColumnData.append(timepoints)
if len(dataDescriptors) > self.dataTableRowCount:
self.dataTableRowCount = len(dataDescriptors)
#datapoints = entityData.datapoints
datapoints = []
# shorten datapoints
for i, datapoint in enumerate(entityData.datapoints):
try:
#datapoints.append(round(float(datapoint), 4))
# valueString = "%g" % (float(datapoint))
floatValue = float(
datapoint) # will jump to except if no float
valueString = "N/A" if math.isnan(
floatValue) else ' {0:-.4f}'.format(floatValue)
datapoints.append(valueString)
# preparing color computation
# logging.debug(entityData.dataDescriptorName)
# logging.debug(entityData.dataDescriptors[i] == settingsandvalues.SUBCONDITION_HEADER_ABSOLUTE)
if self._mode == MODE_SUBCONDITIONS\
and entityData.dataDescriptors[i] == settingsandvalues.SUBCONDITION_HEADER_ABSOLUTE\
and floatValue > self.maxValue\
and floatValue < self.colorThreshold:
self.maxValue = floatValue
except:
# datapoints.append(round(float("nan"), 4))
datapoints.append(str(datapoint))
# logging.debug("TableWidgetController - datapoints: %s" % datapoints) # too much overhead
#self.dataTableHeaders.append("Data species %s [%s]" % (str(speciesID), entityData.getUnit()))
if self.showUnits:
# if type(entity) == str:
# self.dataTableHeaders.append("%s" % entity)
# else:
self.dataTableHeaders.append(
"%s [%s]" %
(entity.getCombinedId(), entityData.getUnit()))
else:
self.dataTableHeaders.append("%s" % entity.getCombinedId())
self.dataTableColumnData.append(datapoints)
# if len(datapoints) > self.dataTableRowCount:
# self.dataTableRowCount = len(datapoints)
# Put those labels into the actual data that would be the vertical/row labels.
# We can't use .setVerticalHeaderLabers() because those labels don't get sorted together with the data.
# Very weird but that seems to be the intended behaviour of Qt.
if self.orientation == ORIENTATION_VERTICAL:
#self.dataTableColumnData.insert(0, self.dataTableHeaders) # handle as if it were data so that sorting works
self.dataTableHeaders = self.dataTableHeaders[
1:] # remove unnecessary dataDescriptor name
for i in xrange(len(self.dataTableColumnData)):
entry = self.dataTableColumnData[i]
entry.insert(0, self.dataTableHeaders[i])
self.dataTableRowHeaders.insert(0, "")
else:
self.dataTableColumnData.insert(0, self.dataTableRowHeaders)
#self.dataTableHeaders.insert(0,"")
if not self.dataTableWidget: # create for the first time
tableLayout = QVBoxLayout(self.tableWrapper)
self.dataTableWidget = QTableWidget(self)
tableLayout.addWidget(self.dataTableWidget)
#prepare table
self.dataTableWidget.setSortingEnabled(
True
) # do here to avoid performance penalty (this actually does one sorting run)
if self.orientation == ORIENTATION_HORIZONTAL:
self.dataTableWidget.setColumnCount(len(self.dataTableHeaders))
self.dataTableWidget.setRowCount(self.dataTableRowCount)
self.dataTableWidget.setHorizontalHeaderLabels(
self.dataTableHeaders)
# self.dataTableWidget.setVerticalHeaderLabels(
# self.dataTableRowHeaders) # has to be called after setRowCount?
elif self.orientation == ORIENTATION_VERTICAL:
self.dataTableWidget.setRowCount(len(self.dataTableHeaders))
self.dataTableWidget.setColumnCount(len(self.dataTableRowHeaders))
# self.dataTableWidget.setVerticalHeaderLabels(self.dataTableHeaders)
self.dataTableWidget.setHorizontalHeaderLabels(
self.dataTableRowHeaders
) # has to be called after setRowCount?
#put data into table
for col in xrange(len(self.dataTableColumnData)):
for row in xrange(len(self.dataTableColumnData[col])):
try:
value = self.dataTableColumnData[col][
row] # don't touch "values"; they could be pre-formatted strings
newItem = SortedTableWidgetItem() # use custom item class
newItem.setData(Qt.DisplayRole, value)
newItem.setTextAlignment(Qt.AlignRight)
newItem.setFont(QFont("Fixed"))
if self.isColored:
if not (self._mode == MODE_SUBCONDITIONS and row != 2
): #color only row 2 of subcondition tables
color = self._computeColor(value)
if color:
newItem.setBackground(QBrush(color))
except Exception, e:
logging.debug(
"TableWidgetController._updateDataTable(): Could not put value into widget item: %s\nError: %s"
% (value, e))
# newItem = SortedTableWidgetItem(str(self.dataTableColumnData[col][row]))
# newItem.setTextAlignment(Qt.AlignRight)
# newItem.setFont(QFont("Fixed"))
if self.orientation == ORIENTATION_HORIZONTAL:
self.dataTableWidget.setItem(row, col, newItem)
elif self.orientation == ORIENTATION_VERTICAL:
self.dataTableWidget.setItem(col, row, newItem)
# self.dataTableWidget.setSortingEnabled(True)
if self.sortColumn != -1:
self.dataTableWidget.sortItems(self.sortColumn)
self.dataTableWidget.resizeColumnsToContents()
class PositionPanel(QtGui.QWidget):
positionTableWidget = None
summaryTable = None
movementFilterWidget = None
row = 0
summaryRow = 0
positionColumnList = "Asset Name;Position;Unit Cost;Market Price;Change%;Invested amount;Valuated amount;Tenor;Maturity Date;Gross PNL;Net PNL;Gross%PNL;Net%PNL;Realized Pnl;%Portfolio;WeightedPNL%".split(
";")
summaryColumnList = "Custody;Asset type;Invested Amount;Valuated Amount;Net PnL;Net%PNL;Realized Pnl;RPnL + NPnL;%Portfolio;WeightedPNL%".split(
";")
def __init__(self):
super(self.__class__, self).__init__()
self.layout = QtGui.QGridLayout(self)
self.movementFilterWidget = MovementFilterWidget()
self.layout.addWidget(self.movementFilterWidget, 1, 0)
def clearTables(self):
self.row = 0
self.summaryRow = 0
self.createTable()
self.createSummaryTable()
self.createGeneralInfoPanel()
def createSummaryTable(self):
self.summaryTableWidget = QTableWidget()
self.summaryTableWidget.setRowCount(7)
self.summaryTableWidget.setColumnCount(len(self.summaryColumnList))
self.summaryTableWidget.setEditTriggers(
QtGui.QAbstractItemView.NoEditTriggers)
self.summaryTableWidget.setHorizontalHeaderLabels(
self.summaryColumnList)
#self.summaryTableWidget.setSortingEnabled(True)
#self.summaryTableWidget.sortItems(0)
self.summaryTableWidget.resizeColumnsToContents()
self.summaryTableWidget.resizeRowsToContents()
self.summaryTableWidget.setFixedSize(800, 200)
self.layout.addWidget(self.summaryTableWidget, 1, 1)
def createGeneralInfoPanel(self):
self.generalInfoPanel = QWidget()
self.generalInfoLayout = QtGui.QGridLayout(self.generalInfoPanel)
self.lblUSDMXN = QLabel("USD/MXN")
self.lblUSDMXN.font()
self.lblUSDMXN.setFont(
QtGui.QFont("MS Shell Dlg", 12, QtGui.QFont.Normal))
self.generalInfoLayout.addWidget(self.lblUSDMXN, 1, 1)
self.lblUSDMXNValue = QLabel("0")
self.lblUSDMXNValue.setFont(
QtGui.QFont("MS Shell Dlg", 12, QtGui.QFont.Bold))
self.generalInfoLayout.addWidget(self.lblUSDMXNValue, 1, 2)
self.generalInfoPanel.setFixedSize(200, 50)
self.layout.addWidget(self.generalInfoPanel, 1, 2)
def createTable(self):
self.positionTableWidget = QTableWidget()
self.positionTableWidget.setRowCount(27)
self.positionTableWidget.setColumnCount(
len(self.positionColumnList) + 1)
self.positionTableWidget.setColumnHidden(
Constant.CONST_COLUMN_POSITION_HIDDEN_ID, True)
self.positionTableWidget.setEditTriggers(
QtGui.QAbstractItemView.NoEditTriggers)
self.positionTableWidget.setHorizontalHeaderLabels(
self.positionColumnList)
#self.positionTableWidget.setSortingEnabled(True)
#self.positionTableWidget.sortItems(0)
self.positionTableWidget.doubleClicked.connect(self.openMovementView)
self.positionTableWidget.resizeColumnsToContents()
self.positionTableWidget.resizeRowsToContents()
self.layout.addWidget(self.positionTableWidget, 2, 0, 3, 3)
def renderGeneralInfoPanel(self, usdMXNvalue):
self.lblUSDMXNValue.setText(str(round(usdMXNvalue, 4)))
#self.generalInfoLayout.addWidget(self.lblUSDMXNValue, 1, 2)
def renderSummary(self, summaryDict):
for (key, summaryItem) in sorted(summaryDict.iteritems()):
if summaryItem.custodyName is None:
isBold = True
else:
isBold = False
#custodyName
custodyNameItem = QTableWidgetItemString(summaryItem.custodyName,
isBold)
self.summaryTableWidget.setItem(
self.summaryRow,
Constant.CONST_COLUMN_SUMMARY_CUST_CUSTODY_NAME,
custodyNameItem)
#assetTypeName
assetTypeNameItem = QTableWidgetItemString(summaryItem.assetType,
isBold)
self.summaryTableWidget.setItem(
self.summaryRow,
Constant.CONST_COLUMN_SUMMARY_CUST_ASSET_TYPE_NAME,
assetTypeNameItem)
#InvestedAmount
investedAmountItem = QTableWidgetItemDecimal(
summaryItem.investedAmount, isBold)
self.summaryTableWidget.setItem(
self.summaryRow,
Constant.CONST_COLUMN_SUMMARY_CUST_INVESTED_AMOUNT,
investedAmountItem)
#valuatedAmount
valuatedAmountItem = QTableWidgetItemDecimal(
summaryItem.valuatedAmount, isBold)
self.summaryTableWidget.setItem(
self.summaryRow,
Constant.CONST_COLUMN_SUMMARY_CUST_VALUATED_AMOUNT,
valuatedAmountItem)
#subTotalNetPnL
netPnLItem = QTableWidgetItemDecimal(summaryItem.netPnL, isBold)
self.summaryTableWidget.setItem(
self.summaryRow, Constant.CONST_COLUMN_SUMMARY_CUST_NET_PNL,
netPnLItem)
#netPNLPercentage
netPNLPercentageItem = QTableWidgetItemDecimal(
summaryItem.getNetPnLPercentage(), isBold)
self.summaryTableWidget.setItem(
self.summaryRow,
Constant.CONST_COLUMN_SUMMARY_CUST_NET_PNL_PERCENTAGE,
netPNLPercentageItem)
#realizedPnl
realizedPnlItem = QTableWidgetItemDecimal(summaryItem.realizedPnl,
isBold)
self.summaryTableWidget.setItem(
self.summaryRow,
Constant.CONST_COLUMN_SUMMARY_CUST_REALIZED_PNL,
realizedPnlItem)
#realizedPnlPlusNetPnL
realizedPnlPlusNetPnLItem = QTableWidgetItemDecimal(
summaryItem.realizedPnl + summaryItem.netPnL, isBold)
self.summaryTableWidget.setItem(
self.summaryRow,
Constant.CONST_COLUMN_SUMMARY_CUST_REALIZED_PNL_PLUS_NET_PNL,
realizedPnlPlusNetPnLItem)
#positionPercentage
positionPercentageItem = QTableWidgetItemDecimal(
summaryItem.positionPercentage, isBold)
self.summaryTableWidget.setItem(
self.summaryRow,
Constant.CONST_COLUMN_SUMMARY_CUST_POSITION_PERCENTAGE,
positionPercentageItem)
#weightedPnL
weightedPnLItem = QTableWidgetItemDecimal(summaryItem.weightedPnL,
isBold)
self.summaryTableWidget.setItem(
self.summaryRow,
Constant.CONST_COLUMN_SUMMARY_CUST_WEIGHTED_PNL,
weightedPnLItem)
self.summaryRow += 1
def renderSubtotal(self, positionDict, assetType, isSIC):
accValuatedAmount = Engine.getSubTotalValuatedAmount(
positionDict, assetType, isSIC)
accInvestedAmount = Engine.getSubTotalInvestedAmount(
positionDict, assetType, isSIC)
accRealizedPnl = Engine.getAccRealizedPnL(positionDict, assetType,
isSIC)
accPositionPercentage = Engine.getAccPositionPercentage(
positionDict, assetType, isSIC)
accGrossPnlPercentage = Engine.getAccGrossPnlPercentage(
positionDict, assetType, isSIC)
accNetPnlPercentage = Engine.getAccNetPnlPercentage(
positionDict, assetType, isSIC)
accNetPNL = Engine.getAccNetPNL(positionDict, assetType, isSIC)
accWeightedPNL = Engine.getAccWeightedPNL(positionDict, assetType,
isSIC)
#Invested amount
investedAmountItem = QTableWidgetItemDecimal(accInvestedAmount, True)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_POSITION_INVESTED_AMOUNT,
investedAmountItem)
#sub total valuated amount
subTotalValuatedAmountItem = QTableWidgetItemDecimal(
accValuatedAmount, True)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_POSITION_VALUATED_AMOUNT,
subTotalValuatedAmountItem)
#sub total Gross PNL
subTotalGrossPNLItem = QTableWidgetItemDecimalColor(
Engine.getSubtotalGrossPNL(positionDict, assetType, isSIC), True)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_POSITION_GROSS_PNL,
subTotalGrossPNLItem)
#sub total Net PNL
subTotalNetPNLItem = QTableWidgetItemDecimalColor(accNetPNL, True)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_POSITION_NET_PNL,
subTotalNetPNLItem)
#subTotalGrossPnLPercentage
subTotalGrossPnLPercentage = QTableWidgetItemDecimalColor(
accGrossPnlPercentage, True)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_POSITION_GROSS_PNL_PERCENTAGE,
subTotalGrossPnLPercentage)
#pnLNetPercentage
subTotalNetPnLPercentage = QTableWidgetItemDecimalColor(
accNetPnlPercentage, True)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_POSITION_GROSS_NET_PERCENTAGE,
subTotalNetPnLPercentage)
#realizedPnL
realizedPnLItem = QTableWidgetItemDecimalColor(accRealizedPnl, True)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_POSITION_REALIZED_PNL,
realizedPnLItem)
#positionPercentage
positionPercentageItem = QTableWidgetItemDecimal(
accPositionPercentage, True)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_POSITION_POSITION_PERCENTAGE,
positionPercentageItem)
#weightedPercentageItem
weightedPercentageItem = QTableWidgetItemDecimal(accWeightedPNL, True)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_POSITION_WEIGHTED_PNL,
weightedPercentageItem)
#HiddenID
hiddenIDItem = QTableWidgetItemDecimal(self.row, False)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_POSITION_HIDDEN_ID, hiddenIDItem)
def renderPositions(self, positionDict, assetType, isSIC):
positionList = Engine.getPositionByAssetType(positionDict, assetType,
isSIC)
for position in positionList:
print('rendering ' + position.getAssetName())
if (position.getTotalQuantity() != 0):
position.row = self.row
#assetName
assetNameItem = QTableWidgetItemString(position.getAssetName(),
False)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_POSITION_ASSET_NAME,
assetNameItem)
#totalQuantity
totalQuantityItem = QTableWidgetItemInt(
position.getTotalQuantity(), False)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_POSITION_QUANTITY,
totalQuantityItem)
#UnitCostOrRate
unitCostItem = QTableWidgetItemDecimal(
position.getUnitCostOrRate(), False)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_POSITION_PPP, unitCostItem)
#Market price
marketPriceItem = QTableWidgetItemDuoDecimal(
position.getMarketPrice(), position.getMarketPriceOrig())
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_POSITION_MARKET_PRICE,
marketPriceItem)
#changePercentage
changePercentageItem = QTableWidgetItemStringPlusMinus(
position.changePercentage, False)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_POSITION_CHANGE_PERCENTAGE,
changePercentageItem)
#Invested amount
investedAmountItem = QTableWidgetItemDecimal(
position.getInvestedAmount(), False)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_POSITION_INVESTED_AMOUNT,
investedAmountItem)
#Valuated amount
valuatedAmountItem = QTableWidgetItemDuoDecimal(
position.getValuatedAmount(),
position.getValuatedAmountOrig())
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_POSITION_VALUATED_AMOUNT,
valuatedAmountItem)
#Tenor
tenorItem = QTableWidgetItemDuoInt(position.tenor,
position.getElapsedDays())
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_POSITION_TENOR, tenorItem)
#Maturity Date
maturityDateItem = QTableWidgetItemString(
position.getMaturityDate(), False)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_POSITION_MATURITY_DATE,
maturityDateItem)
#GrossPnL
grossPnlItem = QTableWidgetItemDecimalColor(
position.getGrossPnL(), False)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_POSITION_GROSS_PNL,
grossPnlItem)
#netPnL
netPnlItem = QTableWidgetItemDecimalColor(
position.getNetPnL(), False)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_POSITION_NET_PNL,
netPnlItem)
#pnLGrossPercentage
pnLGrossPercentageItem = QTableWidgetItemDecimalColor(
position.getGrossPnLPercentage(), False)
self.positionTableWidget.setItem(
self.row,
Constant.CONST_COLUMN_POSITION_GROSS_PNL_PERCENTAGE,
pnLGrossPercentageItem)
#pnLNetPercentage
pnLNetPercentageItem = QTableWidgetItemDecimalColor(
position.getNetPnLPercentage(), False)
self.positionTableWidget.setItem(
self.row,
Constant.CONST_COLUMN_POSITION_GROSS_NET_PERCENTAGE,
pnLNetPercentageItem)
#realizedPnL
realizedPnLItem = QTableWidgetItemDecimalColor(
position.getConsolidatedRealizedPnl(), False)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_POSITION_REALIZED_PNL,
realizedPnLItem)
#positionPercentage
positionPercentageItem = QTableWidgetItemDecimal(
position.getPositionPercentage(), False)
self.positionTableWidget.setItem(
self.row,
Constant.CONST_COLUMN_POSITION_POSITION_PERCENTAGE,
positionPercentageItem)
#weightedPercentageItem
weightedPercentageItem = QTableWidgetItemDecimal(
position.getWeightedPnl(), False)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_POSITION_WEIGHTED_PNL,
weightedPercentageItem)
#HiddenID
hiddenIDItem = QTableWidgetItemDecimal(self.row, False)
self.positionTableWidget.setItem(
self.row, Constant.CONST_COLUMN_POSITION_HIDDEN_ID,
hiddenIDItem)
self.row += 1
self.renderSubtotal(positionDict, assetType, isSIC)
self.row += 1
def openMovementView(self):
assetName = self.positionTableWidget.item(
self.positionTableWidget.currentRow(),
Constant.CONST_COLUMN_POSITION_ASSET_NAME).text()
movementList = Engine.getMovementListByAsset(
assetName, (self.movementFilterWidget.dateFromDate.date()
).toString("yyyy-M-dd"),
(self.movementFilterWidget.dateToDate.date()
).toString("yyyy-M-dd"))
self.movementView = MovementView(movementList)
self.movementView.show()
