def _check_area(self):
"""
Check if the current layout added areas cover the entire rectangle.
Rectangle given by the extreme points for the added areas.
"""
self._area_rects = []
height = self._rows + 1
area_float_rects = []
delta = 0.0001
for index, area in enumerate(self._areas):
# These areas are used with a small delta to ensure if they are
# next to each other they will not overlap.
rectf = QRectF()
rectf.setLeft(area["column"] + delta)
rectf.setRight(area["column"] + area["col_span"] - delta)
rectf.setTop(height - area["row"] - delta)
rectf.setBottom(height - area["row"] - area["row_span"] + delta)
rectf.index = index
rectf.plugin_ids = area["plugin_ids"]
area_float_rects.append(rectf)
# These areas are used to calculate the actual total area
rect = QRectF()
rect.setLeft(area["column"])
rect.setRight(area["column"] + area["col_span"])
rect.setTop(height - area["row"])
rect.setBottom(height - area["row"] - area["row_span"])
rect.index = index
rect.plugin_ids = area["plugin_ids"]
self._area_rects.append(rect)
# Check if areas are overlapping!
for rect_1 in area_float_rects:
for rect_2 in area_float_rects:
if rect_1.index != rect_2.index:
if rect_1.intersects(rect_2):
raise SpyderAPIError(
"Area with plugins {0} is overlapping area "
"with plugins {1}".format(rect_1.plugin_ids,
rect_2.plugin_ids))
# Check the total area (using corner points) versus the sum of areas
total_area = 0
tops = []
rights = []
for index, rect in enumerate(self._area_rects):
tops.append(rect.top())
rights.append(rect.right())
area = abs(rect.width() * rect.height())
total_area += area
self._areas[index]["area"] = area
if total_area != max(rights)*max(tops):
raise SpyderAPIError(
"Areas are not covering the entire section!\n"
"Either an area is missing or col_span/row_span are "
"not correctly set!"
)
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 = QRectF(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)
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 activate(self, plot, plotRect, options=0x00):
"""
Recalculate the geometry of all components.
:param qwt.plot.QwtPlot plot: Plot to be layout
:param QRectF plotRect: Rectangle where to place the components
:param options: Layout options
"""
self.invalidate()
rect = QRectF(plotRect)
self.__data.layoutData.init(plot, rect)
if (not (options & self.IgnoreLegend) and plot.legend()
and not plot.legend().isEmpty()):
self.__data.legendRect = self.layoutLegend(options, rect)
region = QRegion(rect.toRect())
rect = region.subtracted(QRegion(
self.__data.legendRect.toRect())).boundingRect()
if self.__data.legendPos == QwtPlot.LeftLegend:
rect.setLeft(rect.left() + self.__data.spacing)
elif self.__data.legendPos == QwtPlot.RightLegend:
rect.setRight(rect.right() - self.__data.spacing)
elif self.__data.legendPos == QwtPlot.TopLegend:
rect.setTop(rect.top() + self.__data.spacing)
elif self.__data.legendPos == QwtPlot.BottomLegend:
rect.setBottom(rect.bottom() - self.__data.spacing)
# +---+-----------+---+
# | Title |
# +---+-----------+---+
# | | Axis | |
# +---+-----------+---+
# | A | | A |
# | x | Canvas | x |
# | i | | i |
# | s | | s |
# +---+-----------+---+
# | | Axis | |
# +---+-----------+---+
# | Footer |
# +---+-----------+---+
# title, footer and axes include text labels. The height of each
# label depends on its line breaks, that depend on the width
# for the label. A line break in a horizontal text will reduce
# the available width for vertical texts and vice versa.
# expandLineBreaks finds the height/width for title, footer and axes
# including all line breaks.
dimTitle, dimFooter, dimAxes = self.expandLineBreaks(options, rect)
if dimTitle > 0:
self.__data.titleRect.setRect(rect.left(), rect.top(),
rect.width(), dimTitle)
rect.setTop(self.__data.titleRect.bottom() + self.__data.spacing)
if (self.__data.layoutData.scale[QwtPlot.yLeft].isEnabled !=
self.__data.layoutData.scale[QwtPlot.yRight].isEnabled):
self.__data.titleRect.setX(rect.left() +
dimAxes[QwtPlot.yLeft])
self.__data.titleRect.setWidth(rect.width() -
dimAxes[QwtPlot.yLeft] -
dimAxes[QwtPlot.yRight])
if dimFooter > 0:
self.__data.footerRect.setRect(rect.left(),
rect.bottom() - dimFooter,
rect.width(), dimFooter)
rect.setBottom(self.__data.footerRect.top() - self.__data.spacing)
if (self.__data.layoutData.scale[QwtPlot.yLeft].isEnabled !=
self.__data.layoutData.scale[QwtPlot.yRight].isEnabled):
self.__data.footerRect.setX(rect.left() +
dimAxes[QwtPlot.yLeft])
self.__data.footerRect.setWidth(rect.width() -
dimAxes[QwtPlot.yLeft] -
dimAxes[QwtPlot.yRight])
self.__data.canvasRect.setRect(
rect.x() + dimAxes[QwtPlot.yLeft],
rect.y() + dimAxes[QwtPlot.xTop],
rect.width() - dimAxes[QwtPlot.yRight] - dimAxes[QwtPlot.yLeft],
rect.height() - dimAxes[QwtPlot.xBottom] - dimAxes[QwtPlot.xTop],
)
for axis in QwtPlot.AXES:
if dimAxes[axis]:
dim = dimAxes[axis]
scaleRect = self.__data.scaleRect[axis]
scaleRect.setRect(*self.__data.canvasRect.getRect())
if axis == QwtPlot.yLeft:
scaleRect.setX(self.__data.canvasRect.left() - dim)
scaleRect.setWidth(dim)
elif axis == QwtPlot.yRight:
scaleRect.setX(self.__data.canvasRect.right())
scaleRect.setWidth(dim)
elif axis == QwtPlot.xBottom:
scaleRect.setY(self.__data.canvasRect.bottom())
scaleRect.setHeight(dim)
elif axis == QwtPlot.xTop:
scaleRect.setY(self.__data.canvasRect.top() - dim)
scaleRect.setHeight(dim)
scaleRect = scaleRect.normalized()
# +---+-----------+---+
# | <- Axis -> |
# +-^-+-----------+-^-+
# | | | | | |
# | | | |
# | A | | A |
# | x | Canvas | x |
# | i | | i |
# | s | | s |
# | | | |
# | | | | | |
# +-V-+-----------+-V-+
# | <- Axis -> |
# +---+-----------+---+
# The ticks of the axes - not the labels above - should
# be aligned to the canvas. So we try to use the empty
# corners to extend the axes, so that the label texts
# left/right of the min/max ticks are moved into them.
self.alignScales(options, self.__data.canvasRect,
self.__data.scaleRect)
if not self.__data.legendRect.isEmpty():
self.__data.legendRect = self.alignLegend(self.__data.canvasRect,
self.__data.legendRect)