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_())