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 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
app = QApplication(sys.argv)
# Create and populate the tableWidget
tableWidget = QTableWidget(4, 4)
tableWidget.setItemDelegate(StarDelegate())
tableWidget.setEditTriggers(QAbstractItemView.DoubleClicked
| QAbstractItemView.SelectedClicked)
tableWidget.setSelectionBehavior(QAbstractItemView.SelectRows)
tableWidget.setHorizontalHeaderLabels(
["Title", "Genre", "Artist", "Rating"])
data = [["Mass in B-Minor", "Baroque", "J.S. Bach", 5],
["Three More Foxes", "Jazz", "Maynard Ferguson", 4],
["Sex Bomb", "Pop", "Tom Jones", 3],
["Barbie Girl", "Pop", "Aqua", 5]]
for r in range(len(data)):
tableWidget.setItem(r, 0, QTableWidgetItem(data[r][0]))
tableWidget.setItem(r, 1, QTableWidgetItem(data[r][1]))
tableWidget.setItem(r, 2, QTableWidgetItem(data[r][2]))
item = QTableWidgetItem()
item.setData(0, StarRating(data[r][3]).starCount)
tableWidget.setItem(r, 3, item)
tableWidget.resizeColumnsToContents()
tableWidget.resize(500, 300)
tableWidget.show()
sys.exit(app.exec_())
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 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 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()
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 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])
import sys
app = QApplication(sys.argv)
# Create and populate the tableWidget
tableWidget = QTableWidget(4, 4)
tableWidget.setItemDelegate(StarDelegate())
tableWidget.setEditTriggers(QAbstractItemView.DoubleClicked |
QAbstractItemView.SelectedClicked)
tableWidget.setSelectionBehavior(QAbstractItemView.SelectRows)
tableWidget.setHorizontalHeaderLabels(["Title", "Genre", "Artist", "Rating"])
data = [ ["Mass in B-Minor", "Baroque", "J.S. Bach", 5],
["Three More Foxes", "Jazz", "Maynard Ferguson", 4],
["Sex Bomb", "Pop", "Tom Jones", 3],
["Barbie Girl", "Pop", "Aqua", 5] ]
for r in range(len(data)):
tableWidget.setItem(r, 0, QTableWidgetItem(data[r][0]))
tableWidget.setItem(r, 1, QTableWidgetItem(data[r][1]))
tableWidget.setItem(r, 2, QTableWidgetItem(data[r][2]))
item = QTableWidgetItem()
item.setData(0, StarRating(data[r][3]).starCount)
tableWidget.setItem(r, 3, item)
tableWidget.resizeColumnsToContents()
tableWidget.resize(500, 300)
tableWidget.show()
sys.exit(app.exec_())
