[sigrok-meter.git] / datamodel.py

##
## This file is part of the sigrok-meter project.
##
## Copyright (C) 2014 Jens Steinhauser <jens.steinhauser@gmail.com>
##
## This program is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation; either version 2 of the License, or
## (at your option) any later version.
##
## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with this program; if not, see <http://www.gnu.org/licenses/>.
##

import itertools
import math
import qtcompat
import sigrok.core as sr
import util

try:
    from itertools import izip
except ImportError:
    izip = zip

QtCore = qtcompat.QtCore
QtGui = qtcompat.QtGui

class Trace(object):
    '''Class to hold the measured samples.'''

    def __init__(self):
        self.samples = []
        self.new = False

    def append(self, sample):
        self.samples.append(sample)
        self.new = True

class MeasurementDataModel(QtGui.QStandardItemModel):
    '''Model to hold the measured values.'''

    '''Role used to identify and find the item.'''
    idRole = QtCore.Qt.UserRole + 1

    '''Role used to store the device vendor and model.'''
    descRole = QtCore.Qt.UserRole + 2

    '''Role used to store a dictionary with the traces.'''
    tracesRole = QtCore.Qt.UserRole + 3

    '''Role used to store the color to draw the graph of the channel.'''
    colorRole = QtCore.Qt.UserRole + 4

    def __init__(self, parent):
        super(self.__class__, self).__init__(parent)

        # Use the description text to sort the items for now, because the
        # idRole holds tuples, and using them to sort doesn't work.
        self.setSortRole(MeasurementDataModel.descRole)

        # A generator for the colors of the channels.
        self._colorgen = self._make_colorgen()

    def _make_colorgen(self):
        cols = [
            QtGui.QColor(0x8F, 0x52, 0x02), # brown
            QtGui.QColor(0x73, 0xD2, 0x16), # green
            QtGui.QColor(0xCC, 0x00, 0x00), # red
            QtGui.QColor(0x34, 0x65, 0xA4), # blue
            QtGui.QColor(0xF5, 0x79, 0x00), # orange
            QtGui.QColor(0xED, 0xD4, 0x00), # yellow
            QtGui.QColor(0x75, 0x50, 0x7B)  # violet
        ]

        def myrepeat(g, n):
            '''Repeats every element from 'g' 'n' times'.'''
            for e in g:
                for f in itertools.repeat(e, n):
                    yield f

        colorcycle = itertools.cycle(cols)
        darkness = myrepeat(itertools.count(100, 10), len(cols))

        for c, d in izip(colorcycle, darkness):
            yield QtGui.QColor(c).darker(d)

    def format_mqflags(self, mqflags):
        if sr.QuantityFlag.AC in mqflags:
            return 'AC'
        elif sr.QuantityFlag.DC in mqflags:
            return 'DC'
        else:
            return ''

    def format_value(self, mag):
        if math.isinf(mag):
            return u'\u221E'
        return '{:f}'.format(mag)

    def getItem(self, device, channel):
        '''Return the item for the device + channel combination from the
        model, or create a new item if no existing one matches.'''

        # Unique identifier for the device + channel.
        # TODO: Isn't there something better?
        uid = (
            device.vendor,
            device.model,
            device.serial_number(),
            device.connection_id(),
            channel.index
        )

        # Find the correct item in the model.
        for row in range(self.rowCount()):
            item = self.item(row)
            rid = item.data(MeasurementDataModel.idRole)
            rid = tuple(rid) # PySide returns a list.
            if uid == rid:
                return item

        # Nothing found, create a new item.
        desc = '{} {}, {}'.format(
                device.vendor, device.model, channel.name)

        item = QtGui.QStandardItem()
        item.setData(uid, MeasurementDataModel.idRole)
        item.setData(desc, MeasurementDataModel.descRole)
        item.setData({}, MeasurementDataModel.tracesRole)
        item.setData(next(self._colorgen), MeasurementDataModel.colorRole)
        self.appendRow(item)
        self.sort(0)
        return item

    @QtCore.Slot(float, sr.classes.Device, sr.classes.Channel, tuple)
    def update(self, timestamp, device, channel, data):
        '''Update the data for the device (+channel) with the most recent
        measurement from the given payload.'''

        item = self.getItem(device, channel)

        value, unit, mqflags = data
        value_str = self.format_value(value)
        unit_str = util.format_unit(unit)
        mqflags_str = self.format_mqflags(mqflags)

        # The display role is a tuple containing the value and the unit/flags.
        disp = (value_str, ' '.join([unit_str, mqflags_str]))
        item.setData(disp, QtCore.Qt.DisplayRole)

        # The samples role is a dictionary that contains the old samples for each unit.
        # Should be trimmed periodically, otherwise it grows larger and larger.
        if not math.isinf(value) and not math.isnan(value):
            sample = (timestamp, value)
            traces = item.data(MeasurementDataModel.tracesRole)

            # It's not possible to use 'collections.defaultdict' here, because
            # PySide doesn't return the original type that was passed in.
            if not (unit in traces):
                traces[unit] = Trace()
            traces[unit].append(sample)

            item.setData(traces, MeasurementDataModel.tracesRole)

    def clear_samples(self):
        '''Removes all old samples from the model.'''
        for row in range(self.rowCount()):
            idx = self.index(row, 0)
            self.setData(idx, {},
                MeasurementDataModel.tracesRole)

class MultimeterDelegate(QtGui.QStyledItemDelegate):
    '''Delegate to show the data items from a MeasurementDataModel.'''

    def __init__(self, parent, font):
        '''Initialize the delegate.

        :param font: Font used for the text.
        '''

        super(self.__class__, self).__init__(parent)

        self._nfont = font

        fi = QtGui.QFontInfo(self._nfont)
        self._nfontheight = fi.pixelSize()

        fm = QtGui.QFontMetrics(self._nfont)
        r = fm.boundingRect('-XX.XXXXXX X XX')

        w = 1.4 * r.width() + 2 * self._nfontheight
        h = 2.6 * self._nfontheight
        self._size = QtCore.QSize(w, h)

    def sizeHint(self, option=None, index=None):
        return self._size

    def _color_rect(self, outer):
        '''Returns the dimensions of the clickable rectangle.'''
        x1 = (outer.height() - self._nfontheight) / 2
        r = QtCore.QRect(x1, x1, self._nfontheight, self._nfontheight)
        r.translate(outer.topLeft())
        return r

    def paint(self, painter, options, index):
        value, unit = index.data(QtCore.Qt.DisplayRole)
        desc = index.data(MeasurementDataModel.descRole)
        color = index.data(MeasurementDataModel.colorRole)

        painter.setFont(self._nfont)

        # Draw the clickable rectangle.
        painter.fillRect(self._color_rect(options.rect), color)

        # Draw the text
        h = options.rect.height()
        p = options.rect.topLeft()
        p += QtCore.QPoint(h, (h + self._nfontheight) / 2 - 2)
        painter.drawText(p, desc + ': ' + value + ' ' + unit)

    def editorEvent(self, event, model, options, index):
        if type(event) is QtGui.QMouseEvent:
            if event.type() == QtCore.QEvent.MouseButtonPress:
                rect = self._color_rect(options.rect)
                if rect.contains(event.x(), event.y()):
                    c = index.data(MeasurementDataModel.colorRole)
                    c = QtGui.QColorDialog.getColor(c, None,
                        'Choose new color for channel')
                    if c.isValid():
                        # False if cancel is pressed (resulting in a black
                        # color).
                        item = model.itemFromIndex(index)
                        item.setData(c, MeasurementDataModel.colorRole)

                    return True

        return False
Commit	Line	Data
	1	##
	2	## This file is part of the sigrok-meter project.
	3	##
	4	## Copyright (C) 2014 Jens Steinhauser <jens.steinhauser@gmail.com>
	5	##
	6	## This program is free software; you can redistribute it and/or modify
	7	## it under the terms of the GNU General Public License as published by
	8	## the Free Software Foundation; either version 2 of the License, or
	9	## (at your option) any later version.
	10	##
	11	## This program is distributed in the hope that it will be useful,
	12	## but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	## GNU General Public License for more details.
	15	##
	16	## You should have received a copy of the GNU General Public License
	17	## along with this program; if not, see <http://www.gnu.org/licenses/>.
	18	##
	19
	20	import itertools
	21	import math
	22	import qtcompat
	23	import sigrok.core as sr
	24	import util
	25
	26	try:
	27	from itertools import izip
	28	except ImportError:
	29	izip = zip
	30
	31	QtCore = qtcompat.QtCore
	32	QtGui = qtcompat.QtGui
	33
	34	class Trace(object):
	35	'''Class to hold the measured samples.'''
	36
	37	def __init__(self):
	38	self.samples = []
	39	self.new = False
	40
	41	def append(self, sample):
	42	self.samples.append(sample)
	43	self.new = True
	44
	45	class MeasurementDataModel(QtGui.QStandardItemModel):
	46	'''Model to hold the measured values.'''
	47
	48	'''Role used to identify and find the item.'''
	49	idRole = QtCore.Qt.UserRole + 1
	50
	51	'''Role used to store the device vendor and model.'''
	52	descRole = QtCore.Qt.UserRole + 2
	53
	54	'''Role used to store a dictionary with the traces.'''
	55	tracesRole = QtCore.Qt.UserRole + 3
	56
	57	'''Role used to store the color to draw the graph of the channel.'''
	58	colorRole = QtCore.Qt.UserRole + 4
	59
	60	def __init__(self, parent):
	61	super(self.__class__, self).__init__(parent)
	62
	63	# Use the description text to sort the items for now, because the
	64	# idRole holds tuples, and using them to sort doesn't work.
	65	self.setSortRole(MeasurementDataModel.descRole)
	66
	67	# A generator for the colors of the channels.
	68	self._colorgen = self._make_colorgen()
	69
	70	def _make_colorgen(self):
	71	cols = [
	72	QtGui.QColor(0x8F, 0x52, 0x02), # brown
	73	QtGui.QColor(0x73, 0xD2, 0x16), # green
	74	QtGui.QColor(0xCC, 0x00, 0x00), # red
	75	QtGui.QColor(0x34, 0x65, 0xA4), # blue
	76	QtGui.QColor(0xF5, 0x79, 0x00), # orange
	77	QtGui.QColor(0xED, 0xD4, 0x00), # yellow
	78	QtGui.QColor(0x75, 0x50, 0x7B) # violet
	79	]
	80
	81	def myrepeat(g, n):
	82	'''Repeats every element from 'g' 'n' times'.'''
	83	for e in g:
	84	for f in itertools.repeat(e, n):
	85	yield f
	86
	87	colorcycle = itertools.cycle(cols)
	88	darkness = myrepeat(itertools.count(100, 10), len(cols))
	89
	90	for c, d in izip(colorcycle, darkness):
	91	yield QtGui.QColor(c).darker(d)
	92
	93	def format_mqflags(self, mqflags):
	94	if sr.QuantityFlag.AC in mqflags:
	95	return 'AC'
	96	elif sr.QuantityFlag.DC in mqflags:
	97	return 'DC'
	98	else:
	99	return ''
	100
	101	def format_value(self, mag):
	102	if math.isinf(mag):
	103	return u'\u221E'
	104	return '{:f}'.format(mag)
	105
	106	def getItem(self, device, channel):
	107	'''Return the item for the device + channel combination from the
	108	model, or create a new item if no existing one matches.'''
	109
	110	# Unique identifier for the device + channel.
	111	# TODO: Isn't there something better?
	112	uid = (
	113	device.vendor,
	114	device.model,
	115	device.serial_number(),
	116	device.connection_id(),
	117	channel.index
	118	)
	119
	120	# Find the correct item in the model.
	121	for row in range(self.rowCount()):
	122	item = self.item(row)
	123	rid = item.data(MeasurementDataModel.idRole)
	124	rid = tuple(rid) # PySide returns a list.
	125	if uid == rid:
	126	return item
	127
	128	# Nothing found, create a new item.
	129	desc = '{} {}, {}'.format(
	130	device.vendor, device.model, channel.name)
	131
	132	item = QtGui.QStandardItem()
	133	item.setData(uid, MeasurementDataModel.idRole)
	134	item.setData(desc, MeasurementDataModel.descRole)
	135	item.setData({}, MeasurementDataModel.tracesRole)
	136	item.setData(next(self._colorgen), MeasurementDataModel.colorRole)
	137	self.appendRow(item)
	138	self.sort(0)
	139	return item
	140
	141	@QtCore.Slot(float, sr.classes.Device, sr.classes.Channel, tuple)
	142	def update(self, timestamp, device, channel, data):
	143	'''Update the data for the device (+channel) with the most recent
	144	measurement from the given payload.'''
	145
	146	item = self.getItem(device, channel)
	147
	148	value, unit, mqflags = data
	149	value_str = self.format_value(value)
	150	unit_str = util.format_unit(unit)
	151	mqflags_str = self.format_mqflags(mqflags)
	152
	153	# The display role is a tuple containing the value and the unit/flags.
	154	disp = (value_str, ' '.join([unit_str, mqflags_str]))
	155	item.setData(disp, QtCore.Qt.DisplayRole)
	156
	157	# The samples role is a dictionary that contains the old samples for each unit.
	158	# Should be trimmed periodically, otherwise it grows larger and larger.
	159	if not math.isinf(value) and not math.isnan(value):
	160	sample = (timestamp, value)
	161	traces = item.data(MeasurementDataModel.tracesRole)
	162
	163	# It's not possible to use 'collections.defaultdict' here, because
	164	# PySide doesn't return the original type that was passed in.
	165	if not (unit in traces):
	166	traces[unit] = Trace()
	167	traces[unit].append(sample)
	168
	169	item.setData(traces, MeasurementDataModel.tracesRole)
	170
	171	def clear_samples(self):
	172	'''Removes all old samples from the model.'''
	173	for row in range(self.rowCount()):
	174	idx = self.index(row, 0)
	175	self.setData(idx, {},
	176	MeasurementDataModel.tracesRole)
	177
	178	class MultimeterDelegate(QtGui.QStyledItemDelegate):
	179	'''Delegate to show the data items from a MeasurementDataModel.'''
	180
	181	def __init__(self, parent, font):
	182	'''Initialize the delegate.
	183
	184	:param font: Font used for the text.
	185	'''
	186
	187	super(self.__class__, self).__init__(parent)
	188
	189	self._nfont = font
	190
	191	fi = QtGui.QFontInfo(self._nfont)
	192	self._nfontheight = fi.pixelSize()
	193
	194	fm = QtGui.QFontMetrics(self._nfont)
	195	r = fm.boundingRect('-XX.XXXXXX X XX')
	196
	197	w = 1.4 * r.width() + 2 * self._nfontheight
	198	h = 2.6 * self._nfontheight
	199	self._size = QtCore.QSize(w, h)
	200
	201	def sizeHint(self, option=None, index=None):
	202	return self._size
	203
	204	def _color_rect(self, outer):
	205	'''Returns the dimensions of the clickable rectangle.'''
	206	x1 = (outer.height() - self._nfontheight) / 2
	207	r = QtCore.QRect(x1, x1, self._nfontheight, self._nfontheight)
	208	r.translate(outer.topLeft())
	209	return r
	210
	211	def paint(self, painter, options, index):
	212	value, unit = index.data(QtCore.Qt.DisplayRole)
	213	desc = index.data(MeasurementDataModel.descRole)
	214	color = index.data(MeasurementDataModel.colorRole)
	215
	216	painter.setFont(self._nfont)
	217
	218	# Draw the clickable rectangle.
	219	painter.fillRect(self._color_rect(options.rect), color)
	220
	221	# Draw the text
	222	h = options.rect.height()
	223	p = options.rect.topLeft()
	224	p += QtCore.QPoint(h, (h + self._nfontheight) / 2 - 2)
	225	painter.drawText(p, desc + ': ' + value + ' ' + unit)
	226
	227	def editorEvent(self, event, model, options, index):
	228	if type(event) is QtGui.QMouseEvent:
	229	if event.type() == QtCore.QEvent.MouseButtonPress:
	230	rect = self._color_rect(options.rect)
	231	if rect.contains(event.x(), event.y()):
	232	c = index.data(MeasurementDataModel.colorRole)
	233	c = QtGui.QColorDialog.getColor(c, None,
	234	'Choose new color for channel')
	235	if c.isValid():
	236	# False if cancel is pressed (resulting in a black
	237	# color).
	238	item = model.itemFromIndex(index)
	239	item.setData(c, MeasurementDataModel.colorRole)
	240
	241	return True
	242
	243	return False