Source code for qwt.scale_widget
# -*- coding: utf-8 -*-
#
# Licensed under the terms of the Qwt License
# Copyright (c) 2002 Uwe Rathmann, for the original C++ code
# Copyright (c) 2015 Pierre Raybaut, for the Python translation/optimization
# (see LICENSE file for more details)
"""
QwtScaleWidget
--------------
.. autoclass:: QwtScaleWidget
:members:
"""
from qwt.scale_draw import QwtScaleDraw
from qwt.scale_engine import QwtLinearScaleEngine
from qwt.color_map import QwtLinearColorMap
from qwt.text import QwtText
from qwt.painter import QwtPainter
from qwt.interval import QwtInterval
from qwt.color_map import QwtColorMap
from qwt.qt.QtGui import (QWidget, QSizePolicy, QPainter, QStyleOption, QStyle,
QPalette)
from qwt.qt.QtCore import Qt, QRectF, QSize, Signal
import numpy as np
class ColorBar(object):
def __init__(self):
self.isEnabled = None
self.width = None
self.interval = QwtInterval()
self.colorMap = QwtColorMap()
class QwtScaleWidget_PrivateData(object):
def __init__(self):
self.scaleDraw = None
self.borderDist = [None] * 2
self.minBorderDist = [None] * 2
self.scaleLength = None
self.margin = None
self.titleOffset = None
self.spacing = None
self.title = QwtText()
self.layoutFlags = None
self.colorBar = ColorBar()
[docs]class QwtScaleWidget(QWidget):
"""
A Widget which contains a scale
This Widget can be used to decorate composite widgets with
a scale.
Layout flags:
* `QwtScaleWidget.TitleInverted`: The title of vertical scales is painted from top to bottom. Otherwise it is painted from bottom to top.
.. py:class:: QwtScaleWidget([parent=None])
Alignment default is `QwtScaleDraw.LeftScale`.
:param parent: Parent widget
:type parent: QWidget or None
.. py:class:: QwtScaleWidget(align, parent)
:param int align: Alignment
:param QWidget parent: Parent widget
"""
SIG_SCALE_DIV_CHANGED = Signal()
# enum LayoutFlag
TitleInverted = 1
def __init__(self, *args):
self.__data = None
align = QwtScaleDraw.LeftScale
if len(args) == 0:
parent = None
elif len(args) == 1:
parent, = args
elif len(args) == 2:
align, parent = args
else:
raise TypeError("%s() takes 0, 1 or 2 argument(s) (%s given)"\
% (self.__class__.__name__, len(args)))
super(QwtScaleWidget, self).__init__(parent)
self.initScale(align)
[docs] def initScale(self, align):
"""
Initialize the scale
:param int align: Alignment
"""
self.__data = QwtScaleWidget_PrivateData()
self.__data.layoutFlags = 0
if align == QwtScaleDraw.RightScale:
self.__data.layoutFlags |= self.TitleInverted
self.__data.borderDist = [0, 0]
self.__data.minBorderDist = [0, 0]
self.__data.margin = 4
self.__data.titleOffset = 0
self.__data.spacing = 2
self.__data.scaleDraw = QwtScaleDraw()
self.__data.scaleDraw.setAlignment(align)
self.__data.scaleDraw.setLength(10)
self.__data.scaleDraw.setScaleDiv(
QwtLinearScaleEngine().divideScale(0.0, 100.0, 10, 5))
self.__data.colorBar.colorMap = QwtLinearColorMap()
self.__data.colorBar.isEnabled = False
self.__data.colorBar.width = 10
flags = Qt.AlignmentFlag(Qt.AlignHCenter|Qt.TextExpandTabs|Qt.TextWordWrap)
self.__data.title.setRenderFlags(flags)
self.__data.title.setFont(self.font())
policy = QSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.Fixed)
if self.__data.scaleDraw.orientation() == Qt.Vertical:
policy.transpose()
self.setSizePolicy(policy)
self.setAttribute(Qt.WA_WState_OwnSizePolicy, False)
[docs] def setLayoutFlag(self, flag, on=True):
"""
Toggle an layout flag
:param int flag: Layout flag
:param bool on: True/False
.. seealso::
:py:meth:`testLayoutFlag()`
"""
if (self.__data.layoutFlags & flag != 0) != on:
if on:
self.__data.layoutFlags |= flag
else:
self.__data.layoutFlags &= ~flag
[docs] def testLayoutFlag(self, flag):
"""
Test a layout flag
:param int flag: Layout flag
:return: True/False
.. seealso::
:py:meth:`setLayoutFlag()`
"""
return self.__data.layoutFlags & flag
[docs] def setTitle(self, title):
"""
Give title new text contents
:param title: New title
:type title: qwt.text.QwtText or str
.. seealso::
:py:meth:`title()`
"""
if isinstance(title, QwtText):
flags = title.renderFlags() & (~ int(Qt.AlignTop|Qt.AlignBottom))
title.setRenderFlags(flags)
if title != self.__data.title:
self.__data.title = title
self.layoutScale()
else:
if self.__data.title.text() != title:
self.__data.title.setText(title)
self.layoutScale()
[docs] def setAlignment(self, alignment):
"""
Change the alignment
:param int alignment: New alignment
Valid alignment values: see :py:class:`qwt.scale_draw.QwtScaleDraw`
.. seealso::
:py:meth:`alignment()`
"""
if self.__data.scaleDraw:
self.__data.scaleDraw.setAlignment(alignment)
if not self.testAttribute(Qt.WA_WState_OwnSizePolicy):
policy = QSizePolicy(QSizePolicy.MinimumExpanding,
QSizePolicy.Fixed)
if self.__data.scaleDraw.orientation() == Qt.Vertical:
policy.transpose()
self.setSizePolicy(policy)
self.setAttribute(Qt.WA_WState_OwnSizePolicy, False)
self.layoutScale()
[docs] def alignment(self):
"""
:return: position
.. seealso::
:py:meth:`setAlignment()`
"""
if not self.scaleDraw():
return QwtScaleDraw.LeftScale
return self.scaleDraw().alignment()
[docs] def setBorderDist(self, dist1, dist2):
"""
Specify distances of the scale's endpoints from the
widget's borders. The actual borders will never be less
than minimum border distance.
:param int dist1: Left or top Distance
:param int dist2: Right or bottom distance
.. seealso::
:py:meth:`borderDist()`
"""
if dist1 != self.__data.borderDist[0] or\
dist2 != self.__data.borderDist[1]:
self.__data.borderDist = [dist1, dist2]
self.layoutScale()
[docs] def setMargin(self, margin):
"""
Specify the margin to the colorBar/base line.
:param int margin: Margin
.. seealso::
:py:meth:`margin()`
"""
margin = max([0, margin])
if margin != self.__data.margin:
self.__data.margin = margin
self.layoutScale()
[docs] def setSpacing(self, spacing):
"""
Specify the distance between color bar, scale and title
:param int spacing: Spacing
.. seealso::
:py:meth:`spacing()`
"""
spacing = max([0, spacing])
if spacing != self.__data.spacing:
self.__data.spacing = spacing
self.layoutScale()
[docs] def setLabelAlignment(self, alignment):
"""
Change the alignment for the labels.
:param int spacing: Spacing
.. seealso::
:py:meth:`QwtScaleDraw.setLabelAlignment()`,
:py:meth:`setLabelRotation()`
"""
self.__data.scaleDraw.setLabelAlignment(alignment)
self.layoutScale()
[docs] def setLabelRotation(self, rotation):
"""
Change the rotation for the labels.
:param float rotation: Rotation
.. seealso::
:py:meth:`QwtScaleDraw.setLabelRotation()`,
:py:meth:`setLabelFlags()`
"""
self.__data.scaleDraw.setLabelRotation(rotation)
self.layoutScale()
[docs] def setScaleDraw(self, scaleDraw):
"""
Set a scale draw
scaleDraw has to be created with new and will be deleted in
class destructor or the next call of `setScaleDraw()`.
scaleDraw will be initialized with the attributes of
the previous scaleDraw object.
:param qwt.scale_draw.QwtScaleDraw scaleDraw: ScaleDraw object
.. seealso::
:py:meth:`scaleDraw()`
"""
if scaleDraw is None or scaleDraw == self.__data.scaleDraw:
return
sd = self.__data.scaleDraw
if sd is not None:
scaleDraw.setAlignment(sd.alignment())
scaleDraw.setScaleDiv(sd.scaleDiv())
transform = None
if sd.scaleMap().transformation():
transform = sd.scaleMap().transformation().copy()
scaleDraw.setTransformation(transform)
self.__data.scaleDraw = scaleDraw
self.layoutScale()
[docs] def scaleDraw(self):
"""
:return: scaleDraw of this scale
.. seealso::
:py:meth:`QwtScaleDraw.setScaleDraw()`
"""
return self.__data.scaleDraw
[docs] def title(self):
"""
:return: title
.. seealso::
:py:meth:`setTitle`
"""
return self.__data.title
[docs] def startBorderDist(self):
"""
:return: start border distance
.. seealso::
:py:meth:`setBorderDist`
"""
return self.__data.borderDist[0]
[docs] def endBorderDist(self):
"""
:return: end border distance
.. seealso::
:py:meth:`setBorderDist`
"""
return self.__data.borderDist[1]
[docs] def margin(self):
"""
:return: margin
.. seealso::
:py:meth:`setMargin`
"""
return self.__data.margin
[docs] def spacing(self):
"""
:return: distance between scale and title
.. seealso::
:py:meth:`setSpacing`
"""
return self.__data.spacing
def paintEvent(self, event):
painter = QPainter(self)
painter.setClipRegion(event.region())
opt = QStyleOption()
opt.initFrom(self)
self.style().drawPrimitive(QStyle.PE_Widget, opt, painter, self)
self.draw(painter)
[docs] def draw(self, painter):
"""
Draw the scale
:param QPainter painter: Painter
"""
self.__data.scaleDraw.draw(painter, self.palette())
if self.__data.colorBar.isEnabled and\
self.__data.colorBar.width > 0 and\
self.__data.colorBar.interval.isValid():
self.drawColorBar(painter, self.colorBarRect(self.contentsRect()))
r = self.contentsRect()
if self.__data.scaleDraw.orientation() == Qt.Horizontal:
r.setLeft(r.left() + self.__data.borderDist[0])
r.setWidth(r.width() - self.__data.borderDist[1])
else:
r.setTop(r.top() + self.__data.borderDist[0])
r.setHeight(r.height() - self.__data.borderDist[1])
if not self.__data.title.isEmpty():
self.drawTitle(painter, self.__data.scaleDraw.alignment(), r)
[docs] def colorBarRect(self, rect):
"""
Calculate the the rectangle for the color bar
:param QRectF rect: Bounding rectangle for all components of the scale
:return: Rectangle for the color bar
"""
cr = QRectF(rect)
if self.__data.scaleDraw.orientation() == Qt.Horizontal:
cr.setLeft(cr.left() + self.__data.borderDist[0])
cr.setWidth(cr.width() - self.__data.borderDist[1] + 1)
else:
cr.setTop(cr.top() + self.__data.borderDist[0])
cr.setHeight(cr.height() - self.__data.borderDist[1] + 1)
sda = self.__data.scaleDraw.alignment()
if sda == QwtScaleDraw.LeftScale:
cr.setLeft(cr.right()-self.__data.margin-self.__data.colorBar.width)
cr.setWidth(self.__data.colorBar.width)
elif sda == QwtScaleDraw.RightScale:
cr.setLeft(cr.left()+self.__data.margin)
cr.setWidth(self.__data.colorBar.width)
elif sda == QwtScaleDraw.BottomScale:
cr.setTop(cr.top()+self.__data.margin)
cr.setHeight(self.__data.colorBar.width)
elif sda == QwtScaleDraw.TopScale:
cr.setTop(cr.bottom()-self.__data.margin-self.__data.colorBar.width)
cr.setHeight(self.__data.colorBar.width)
return cr
def resizeEvent(self, event):
self.layoutScale(False)
[docs] def layoutScale(self, update_geometry=True):
"""
Recalculate the scale's geometry and layout based on
the current geometry and fonts.
:param bool update_geometry: Notify the layout system and call update to redraw the scale
"""
bd0, bd1 = self.getBorderDistHint()
if self.__data.borderDist[0] > bd0:
bd0 = self.__data.borderDist[0]
if self.__data.borderDist[1] > bd1:
bd1 = self.__data.borderDist[1]
colorBarWidth = 0
if self.__data.colorBar.isEnabled and\
self.__data.colorBar.interval.isValid():
colorBarWidth = self.__data.colorBar.width + self.__data.spacing
r = self.contentsRect()
if self.__data.scaleDraw.orientation() == Qt.Vertical:
y = r.top() + bd0
length = r.height() - (bd0 +bd1)
if self.__data.scaleDraw.alignment() == QwtScaleDraw.LeftScale:
x = r.right() - 1. - self.__data.margin - colorBarWidth
else:
x = r.left() + self.__data.margin + colorBarWidth
else:
x = r.left() + bd0
length = r.width() - (bd0 + bd1)
if self.__data.scaleDraw.alignment() == QwtScaleDraw.BottomScale:
y = r.top() + self.__data.margin + colorBarWidth
else:
y = r.bottom() - 1. - self.__data.margin - colorBarWidth
self.__data.scaleDraw.move(x, y)
self.__data.scaleDraw.setLength(length)
extent = np.ceil(self.__data.scaleDraw.extent(self.font()))
self.__data.titleOffset = self.__data.margin + self.__data.spacing +\
colorBarWidth + extent
if update_geometry:
self.updateGeometry()
self.update()
[docs] def drawColorBar(self, painter, rect):
"""
Draw the color bar of the scale widget
:param QPainter painter: Painter
:param QRectF rect: Bounding rectangle for the color bar
.. seealso::
:py:meth:`setColorBarEnabled()`
"""
if not self.__data.colorBar.interval.isValid():
return
sd = self.__data.scaleDraw
QwtPainter.drawColorBar(painter, self.__data.colorBar.colorMap,
self.__data.colorBar.interval.normalized(),
sd.scaleMap(), sd.orientation(), rect)
[docs] def drawTitle(self, painter, align, rect):
"""
Rotate and paint a title according to its position into a given rectangle.
:param QPainter painter: Painter
:param int align: Alignment
:param QRectF rect: Bounding rectangle
"""
r = rect
flags = self.__data.title.renderFlags()\
&(~ int(Qt.AlignTop|Qt.AlignBottom|Qt.AlignVCenter))
if align == QwtScaleDraw.LeftScale:
angle = -90.
flags |= Qt.AlignTop
r.setRect(r.left(), r.bottom(), r.height(),
r.width()-self.__data.titleOffset)
elif align == QwtScaleDraw.RightScale:
angle = -90.
flags |= Qt.AlignTop
r.setRect(r.left()+self.__data.titleOffset, r.bottom(), r.height(),
r.width()-self.__data.titleOffset)
elif align == QwtScaleDraw.BottomScale:
angle = 0.
flags |= Qt.AlignBottom
r.setTop(r.top()+self.__data.titleOffset)
else:
angle = 0.
flags |= Qt.AlignTop
r.setBottom(r.bottom()-self.__data.titleOffset)
if self.__data.layoutFlags & self.TitleInverted:
if align in (QwtScaleDraw.LeftScale, QwtScaleDraw.RightScale):
angle = -angle
r.setRect(r.x()+r.height(), r.y()-r.width(),
r.width(), r.height())
painter.save()
painter.setFont(self.font())
painter.setPen(self.palette().color(QPalette.Text))
painter.translate(r.x(), r.y())
if angle != 0.:
painter.rotate(angle)
title = self.__data.title
title.setRenderFlags(flags)
title.draw(painter, QRectF(0., 0., r.width(), r.height()))
painter.restore()
[docs] def scaleChange(self):
"""
Notify a change of the scale
This method can be overloaded by derived classes. The default
implementation updates the geometry and repaints the widget.
"""
self.layoutScale()
def sizeHint(self):
return self.minimumSizeHint()
def minimumSizeHint(self):
o = self.__data.scaleDraw.orientation()
length = 0
mbd1, mbd2 = self.getBorderDistHint()
length += max([0, self.__data.borderDist[0]-mbd1])
length += max([0, self.__data.borderDist[1]-mbd2])
length += self.__data.scaleDraw.minLength(self.font())
dim = self.dimForLength(length, self.font())
if length < dim:
length = dim
dim = self.dimForLength(length, self.font())
size = QSize(length+2, dim)
if o == Qt.Vertical:
size.transpose()
left, right, top, bottom = self.getContentsMargins()
return size + QSize(left + right, top + bottom)
[docs] def titleHeightForWidth(self, width):
"""
Find the height of the title for a given width.
:param int width: Width
:return: Height
"""
return np.ceil(self.__data.title.heightForWidth(width, self.font()))
[docs] def dimForLength(self, length, scaleFont):
"""
Find the minimum dimension for a given length.
dim is the height, length the width seen in direction of the title.
:param int length: width for horizontal, height for vertical scales
:param QFont scaleFont: Font of the scale
:return: height for horizontal, width for vertical scales
"""
extent = np.ceil(self.__data.scaleDraw.extent(scaleFont))
dim = self.__data.margin + extent + 1
if not self.__data.title.isEmpty():
dim += self.titleHeightForWidth(length)+self.__data.spacing
if self.__data.colorBar.isEnabled and self.__data.colorBar.interval.isValid():
dim += self.__data.colorBar.width+self.__data.spacing
return dim
[docs] def getBorderDistHint(self):
"""
Calculate a hint for the border distances.
This member function calculates the distance
of the scale's endpoints from the widget borders which
is required for the mark labels to fit into the widget.
The maximum of this distance an the minimum border distance
is returned.
:param int start: Return parameter for the border width at the beginning of the scale
:param int end: Return parameter for the border width at the end of the scale
.. warning::
The minimum border distance depends on the font.
.. seealso::
:py:meth:`setMinBorderDist()`, :py:meth:`getMinBorderDist()`,
:py:meth:`setBorderDist()`
"""
start, end = self.__data.scaleDraw.getBorderDistHint(self.font())
if start < self.__data.minBorderDist[0]:
start = self.__data.minBorderDist[0]
if end < self.__data.minBorderDist[1]:
end = self.__data.minBorderDist[1]
return start, end
[docs] def setMinBorderDist(self, start, end):
"""
Set a minimum value for the distances of the scale's endpoints from
the widget borders. This is useful to avoid that the scales
are "jumping", when the tick labels or their positions change
often.
:param int start: Minimum for the start border
:param int end: Minimum for the end border
.. seealso::
:py:meth:`getMinBorderDist()`, :py:meth:`getBorderDistHint()`
"""
self.__data.minBorderDist = [start, end]
[docs] def getMinBorderDist(self):
"""
Get the minimum value for the distances of the scale's endpoints from
the widget borders.
:param int start: Return parameter for the border width at the beginning of the scale
:param int end: Return parameter for the border width at the end of the scale
.. seealso::
:py:meth:`setMinBorderDist()`, :py:meth:`getBorderDistHint()`
"""
return self.__data.minBorderDist
[docs] def setScaleDiv(self, scaleDiv):
"""
Assign a scale division
The scale division determines where to set the tick marks.
:param qwt.scale_div.QwtScaleDiv scaleDiv: Scale Division
.. seealso::
For more information about scale divisions,
see :py:class:`qwt.scale_div.QwtScaleDiv`.
"""
sd = self.__data.scaleDraw
if sd.scaleDiv() != scaleDiv:
sd.setScaleDiv(scaleDiv)
self.layoutScale()
self.SIG_SCALE_DIV_CHANGED.emit()
[docs] def setTransformation(self, transformation):
"""
Set the transformation
:param qwt.transform.Transform transformation: Transformation
.. seealso::
:py:meth:`qwt.scale_draw.QwtAbstractScaleDraw.scaleDraw()`,
:py:class:`qwt.scale_map.QwtScaleMap`
"""
self.__data.scaleDraw.setTransformation(transformation)
self.layoutScale()
[docs] def setColorBarEnabled(self, on):
"""
En/disable a color bar associated to the scale
:param bool on: On/Off
.. seealso::
:py:meth:`isColorBarEnabled()`, :py:meth:`setColorBarWidth()`
"""
if on != self.__data.colorBar.isEnabled:
self.__data.colorBar.isEnabled = on
self.layoutScale()
[docs] def isColorBarEnabled(self):
"""
:return: True, when the color bar is enabled
.. seealso::
:py:meth:`setColorBarEnabled()`, :py:meth:`setColorBarWidth()`
"""
return self.__data.colorBar.isEnabled
[docs] def setColorBarWidth(self, width):
"""
Set the width of the color bar
:param int width: Width
.. seealso::
:py:meth:`colorBarWidth()`, :py:meth:`setColorBarEnabled()`
"""
if width != self.__data.colorBar.width:
self.__data.colorBar.width = width
if self.isColorBarEnabled():
self.layoutScale()
[docs] def colorBarWidth(self):
"""
:return: Width of the color bar
.. seealso::
:py:meth:`setColorBarWidth()`, :py:meth:`setColorBarEnabled()`
"""
return self.__data.colorBar.width
[docs] def colorBarInterval(self):
"""
:return: Value interval for the color bar
.. seealso::
:py:meth:`setColorMap()`, :py:meth:`colorMap()`
"""
return self.__data.colorBar.interval
[docs] def setColorMap(self, interval, colorMap):
"""
Set the color map and value interval, that are used for displaying
the color bar.
:param qwt.interval.QwtInterval interval: Value interval
:param qwt.color_map.QwtColorMap colorMap: Color map
.. seealso::
:py:meth:`colorMap()`, :py:meth:`colorBarInterval()`
"""
self.__data.colorBar.interval = interval
if colorMap != self.__data.colorBar.colorMap:
self.__data.colorBar.colorMap = colorMap
if self.isColorBarEnabled():
self.layoutScale()
[docs] def colorMap(self):
"""
:return: Color map
.. seealso::
:py:meth:`setColorMap()`, :py:meth:`colorBarInterval()`
"""
return self.__data.colorBar.colorMap