def drawSymbol(self, painter, point_or_rect):
"""
Draw the symbol into a rectangle
The symbol is painted centered and scaled into the target rectangle.
It is always painted uncached and the pin point is ignored.
This method is primarily intended for drawing a symbol to the legend.
:param QPainter painter: Painter
:param point_or_rect: Position or target rectangle of the symbol in screen coordinates
:type point_or_rect: QPointF or QPoint or QRectF
"""
if isinstance(point_or_rect, (QPointF, QPoint)):
# drawSymbol( QPainter *, const QPointF & )
self.drawSymbols(painter, [point_or_rect])
return
# drawSymbol( QPainter *, const QRectF & )
rect = point_or_rect
assert isinstance(rect, QRectF)
if self.__data.style == QwtSymbol.NoSymbol:
return
if self.__data.style == QwtSymbol.Graphic:
self.__data.graphic.graphic.render(painter, rect,
Qt.KeepAspectRatio)
elif self.__data.style == QwtSymbol.Path:
if self.__data.path.graphic.isNull():
self.__data.path.graphic = qwtPathGraphic(
self.__data.path.path, self.__data.pen, self.__data.brush)
self.__data.path.graphic.render(painter, rect, Qt.KeepAspectRatio)
return
elif self.__data.style == QwtSymbol.SvgDocument:
if self.__data.svg.renderer is not None:
scaledRect = QRectF()
sz = QSizeF(self.__data.svg.renderer.viewBoxF().size())
if not sz.isEmpty():
sz.scale(rect.size(), Qt.KeepAspectRatio)
scaledRect.setSize(sz)
scaledRect.moveCenter(rect.center())
else:
scaledRect = rect
self.__data.svg.renderer.render(painter, scaledRect)
else:
br = QRect(self.boundingRect())
ratio = min(
[rect.width() / br.width(),
rect.height() / br.height()])
painter.save()
painter.translate(rect.center())
painter.scale(ratio, ratio)
isPinPointEnabled = self.__data.isPinPointEnabled
self.__data.isPinPointEnabled = False
pos = QPointF()
self.renderSymbols(painter, pos, 1)
self.__data.isPinPointEnabled = isPinPointEnabled
painter.restore()
def setCenter(self, lon, lat):
"""Move the center of the visible area to new coordinates.
Update the scene rect.
Args:
lon(float): New longitude of the center.
lat(float): New latitude of the center.
"""
rect = QRectF(self.sceneRect())
pos = self.posFromLonLat(lon, lat)
rect.moveCenter(QPointF(pos[0], pos[1]))
self.setSceneRect(rect)
def setCenter(self, lon, lat):
"""Move the center of the visible area to new coordinates.
Update the scene rect.
Args:
lon(float): New longitude of the center.
lat(float): New latitude of the center.
"""
rect = QRectF(self.sceneRect())
pos = self.posFromLonLat(lon, lat)
rect.moveCenter(QPointF(pos[0], pos[1]))
self.setSceneRect(rect)
def qwtDrawStar1Symbols(painter, points, numPoints, symbol):
size = symbol.size()
painter.setPen(symbol.pen())
sqrt1_2 = np.sqrt(0.5)
r = QRectF(0, 0, size.width(), size.height())
for pos in points:
r.moveCenter(pos.toPoint())
c = QPointF(r.center())
d1 = r.width() / 2.0 * (1.0 - sqrt1_2)
painter.drawLine(r.left() + d1, r.top() + d1, r.right() - d1, r.bottom() - d1)
painter.drawLine(r.left() + d1, r.bottom() - d1, r.right() - d1, r.top() + d1)
painter.drawLine(c.x(), r.top(), c.x(), r.bottom())
painter.drawLine(r.left(), c.y(), r.right(), c.y())
def setCenter(self, lon, lat, zoom=None):
"""Move the center of the visible area to new coordinates.
Update the scene rect.
Args:
lon(float): New longitude of the center.
lat(float): New latitude of the center.
zoom(int [1:15]): Zoom Level
"""
if zoom != None and zoom < 15 and zoom > 0:
self._zoom = zoom
rect = QRectF(self.sceneRect())
pos = self.posFromLonLat(lon, lat)
rect.moveCenter(QPointF(pos[0], pos[1]))
self.setSceneRect(rect)
def create_high_dpi_drop_indicator_pixmap(
self, size: QSizeF, area: DockWidgetArea,
mode: OverlayMode) -> QPixmap:
'''
Create high dpi drop indicator pixmap
Parameters
----------
size : QSizeF
area : DockWidgetArea
mode : OverlayMode
Returns
-------
value : QPixmap
'''
border_color = self.icon_color(IconColor.frame_color)
background_color = self.icon_color(IconColor.window_background_color)
window = self.public.window()
# QT version compatibility (TODO necessary for qtpy?)
device_pixel_ratio = (window.devicePixelRatioF()
if hasattr(window, 'devicePixelRatioF')
else window.devicePixelRatio())
pixmap_size = QSizeF(size * device_pixel_ratio)
pm = QPixmap(pixmap_size.toSize())
pm.fill(QColor(0, 0, 0, 0))
p = QPainter(pm)
pen = p.pen()
shadow_rect = QRectF(pm.rect())
base_rect = QRectF()
base_rect.setSize(shadow_rect.size() * 0.7)
base_rect.moveCenter(shadow_rect.center())
# Fill
shadow_color = self.icon_color(IconColor.shadow_color)
if shadow_color.alpha() == 255:
shadow_color.setAlpha(64)
p.fillRect(shadow_rect, shadow_color)
# Drop area rect.
p.save()
area_rect = QRectF()
area_line = QLineF()
non_area_rect = QRectF()
if area == DockWidgetArea.top:
area_rect = QRectF(base_rect.x(), base_rect.y(), base_rect.width(),
base_rect.height()*.5)
non_area_rect = QRectF(base_rect.x(), shadow_rect.height()*.5,
base_rect.width(), base_rect.height()*.5)
area_line = QLineF(area_rect.bottomLeft(), area_rect.bottomRight())
elif area == DockWidgetArea.right:
area_rect = QRectF(shadow_rect.width()*.5, base_rect.y(),
base_rect.width()*.5, base_rect.height())
non_area_rect = QRectF(base_rect.x(), base_rect.y(),
base_rect.width()*.5, base_rect.height())
area_line = QLineF(area_rect.topLeft(), area_rect.bottomLeft())
elif area == DockWidgetArea.bottom:
area_rect = QRectF(base_rect.x(), shadow_rect.height()*.5,
base_rect.width(), base_rect.height()*.5)
non_area_rect = QRectF(base_rect.x(), base_rect.y(),
base_rect.width(), base_rect.height()*.5)
area_line = QLineF(area_rect.topLeft(), area_rect.topRight())
elif area == DockWidgetArea.left:
area_rect = QRectF(base_rect.x(), base_rect.y(),
base_rect.width()*.5, base_rect.height())
non_area_rect = QRectF(shadow_rect.width()*.5, base_rect.y(),
base_rect.width()*.5, base_rect.height())
area_line = QLineF(area_rect.topRight(), area_rect.bottomRight())
baseSize = base_rect.size()
if (OverlayMode.container == mode
and area != DockWidgetArea.center):
base_rect = area_rect
p.fillRect(base_rect, background_color)
if area_rect.isValid():
pen = p.pen()
pen.setColor(border_color)
Color = self.icon_color(IconColor.overlay_color)
if Color.alpha() == 255:
Color.setAlpha(64)
p.setBrush(Color)
p.setPen(Qt.NoPen)
p.drawRect(area_rect)
pen = p.pen()
pen.setWidth(1)
pen.setColor(border_color)
pen.setStyle(Qt.DashLine)
p.setPen(pen)
p.drawLine(area_line)
p.restore()
p.save()
# Draw outer border
pen = p.pen()
pen.setColor(border_color)
pen.setWidth(1)
p.setBrush(Qt.NoBrush)
p.setPen(pen)
p.drawRect(base_rect)
# draw window title bar
p.setBrush(border_color)
frame_rect = QRectF(base_rect.topLeft(),
QSizeF(base_rect.width(), baseSize.height()/10))
p.drawRect(frame_rect)
p.restore()
# Draw arrow for outer container drop indicators
if (OverlayMode.container == mode and
area != DockWidgetArea.center):
arrow_rect = QRectF()
arrow_rect.setSize(baseSize)
arrow_rect.setWidth(arrow_rect.width()/4.6)
arrow_rect.setHeight(arrow_rect.height()/2)
arrow_rect.moveCenter(QPointF(0, 0))
arrow = QPolygonF()
arrow.append(arrow_rect.topLeft())
arrow.append(QPointF(arrow_rect.right(), arrow_rect.center().y()))
arrow.append(arrow_rect.bottomLeft())
p.setPen(Qt.NoPen)
p.setBrush(self.icon_color(IconColor.arrow_color))
p.setRenderHint(QPainter.Antialiasing, True)
p.translate(non_area_rect.center().x(), non_area_rect.center().y())
if area == DockWidgetArea.top:
p.rotate(-90)
elif area == DockWidgetArea.right:
...
elif area == DockWidgetArea.bottom:
p.rotate(90)
elif area == DockWidgetArea.left:
p.rotate(180)
p.drawPolygon(arrow)
pm.setDevicePixelRatio(device_pixel_ratio)
return pm
def boundingRect(self):
"""
Calculate the bounding rectangle for a symbol at position (0,0).
:return: Bounding rectangle
"""
rect = QRectF()
pinPointTranslation = False
if self.__data.style in (QwtSymbol.Ellipse, QwtSymbol.Rect,
QwtSymbol.Hexagon):
pw = 0.0
if self.__data.pen.style() != Qt.NoPen:
pw = max([self.__data.pen.widthF(), 1.0])
rect.setSize(self.__data.size + QSizeF(pw, pw))
rect.moveCenter(QPointF(0.0, 0.0))
elif self.__data.style in (
QwtSymbol.XCross,
QwtSymbol.Diamond,
QwtSymbol.Triangle,
QwtSymbol.UTriangle,
QwtSymbol.DTriangle,
QwtSymbol.RTriangle,
QwtSymbol.LTriangle,
QwtSymbol.Star1,
QwtSymbol.Star2,
):
pw = 0.0
if self.__data.pen.style() != Qt.NoPen:
pw = max([self.__data.pen.widthF(), 1.0])
rect.setSize(QSizeF(self.__data.size) + QSizeF(2 * pw, 2 * pw))
rect.moveCenter(QPointF(0.0, 0.0))
elif self.__data.style == QwtSymbol.Path:
if self.__data.path.graphic.isNull():
self.__data.path.graphic = qwtPathGraphic(
self.__data.path.path, self.__data.pen, self.__data.brush)
rect = qwtScaleBoundingRect(self.__data.path.graphic,
self.__data.size)
pinPointTranslation = True
elif self.__data.style == QwtSymbol.Pixmap:
if self.__data.size.isEmpty():
rect.setSize(self.__data.pixmap.pixmap.size())
else:
rect.setSize(self.__data.size)
pinPointTranslation = True
elif self.__data.style == QwtSymbol.Graphic:
rect = qwtScaleBoundingRect(self.__data.graphic.graphic,
self.__data.size)
pinPointTranslation = True
elif self.__data.style == QwtSymbol.SvgDocument:
if self.__data.svg.renderer is not None:
rect = self.__data.svg.renderer.viewBoxF()
if self.__data.size.isValid() and not rect.isEmpty():
sz = QSizeF(rect.size())
sx = self.__data.size.width() / sz.width()
sy = self.__data.size.height() / sz.height()
transform = QTransform()
transform.scale(sx, sy)
rect = transform.mapRect(rect)
pinPointTranslation = True
else:
rect.setSize(self.__data.size)
rect.moveCenter(QPointF(0.0, 0.0))
if pinPointTranslation:
pinPoint = QPointF(0.0, 0.0)
if self.__data.isPinPointEnabled:
pinPoint = rect.center() - self.__data.pinPoint
rect.moveCenter(pinPoint)
r = QRect()
r.setLeft(np.floor(rect.left()))
r.setTop(np.floor(rect.top()))
r.setRight(np.floor(rect.right()))
r.setBottom(np.floor(rect.bottom()))
if self.__data.style != QwtSymbol.Pixmap:
r.adjust(-1, -1, 1, 1)
return r
def render(self, *args):
"""
.. py:method:: render(painter)
Replay all recorded painter commands
:param QPainter painter: Qt painter
.. py:method:: render(painter, size, aspectRatioMode)
Replay all recorded painter commands
The graphic is scaled to fit into the rectangle
of the given size starting at ( 0, 0 ).
:param QPainter painter: Qt painter
:param QSizeF size: Size for the scaled graphic
:param Qt.AspectRatioMode aspectRatioMode: Mode how to scale
.. py:method:: render(painter, rect, aspectRatioMode)
Replay all recorded painter commands
The graphic is scaled to fit into the given rectangle
:param QPainter painter: Qt painter
:param QRectF rect: Rectangle for the scaled graphic
:param Qt.AspectRatioMode aspectRatioMode: Mode how to scale
.. py:method:: render(painter, pos, aspectRatioMode)
Replay all recorded painter commands
The graphic is scaled to the :py:meth:`defaultSize()` and aligned
to a position.
:param QPainter painter: Qt painter
:param QPointF pos: Reference point, where to render
:param Qt.AspectRatioMode aspectRatioMode: Mode how to scale
"""
if len(args) == 1:
(painter, ) = args
if self.isNull():
return
transform = painter.transform()
painter.save()
for command in self.__data.commands:
qwtExecCommand(
painter,
command,
self.__data.renderHints,
transform,
self.__data.initialTransform,
)
painter.restore()
elif len(args) in (2, 3) and isinstance(args[1], QSizeF):
painter, size = args[:2]
aspectRatioMode = Qt.IgnoreAspectRatio
if len(args) == 3:
aspectRatioMode = args[-1]
r = QRectF(0.0, 0.0, size.width(), size.height())
self.render(painter, r, aspectRatioMode)
elif len(args) in (2, 3) and isinstance(args[1], QRectF):
painter, rect = args[:2]
aspectRatioMode = Qt.IgnoreAspectRatio
if len(args) == 3:
aspectRatioMode = args[-1]
if self.isEmpty() or rect.isEmpty():
return
sx = 1.0
sy = 1.0
if self.__data.pointRect.width() > 0.0:
sx = rect.width() / self.__data.pointRect.width()
if self.__data.pointRect.height() > 0.0:
sy = rect.height() / self.__data.pointRect.height()
scalePens = not bool(self.__data.renderHints
& self.RenderPensUnscaled)
for info in self.__data.pathInfos:
ssx = info.scaleFactorX(self.__data.pointRect, rect, scalePens)
if ssx > 0.0:
sx = min([sx, ssx])
ssy = info.scaleFactorY(self.__data.pointRect, rect, scalePens)
if ssy > 0.0:
sy = min([sy, ssy])
if aspectRatioMode == Qt.KeepAspectRatio:
s = min([sx, sy])
sx = s
sy = s
elif aspectRatioMode == Qt.KeepAspectRatioByExpanding:
s = max([sx, sy])
sx = s
sy = s
tr = QTransform()
tr.translate(
rect.center().x() - 0.5 * sx * self.__data.pointRect.width(),
rect.center().y() - 0.5 * sy * self.__data.pointRect.height(),
)
tr.scale(sx, sy)
tr.translate(-self.__data.pointRect.x(),
-self.__data.pointRect.y())
transform = painter.transform()
if not scalePens and transform.isScaling():
# we don't want to scale pens according to sx/sy,
# but we want to apply the scaling from the
# painter transformation later
self.__data.initialTransform = QTransform()
self.__data.initialTransform.scale(transform.m11(),
transform.m22())
painter.setTransform(tr, True)
self.render(painter)
painter.setTransform(transform)
self.__data.initialTransform = None
elif len(args) in (2, 3) and isinstance(args[1], QPointF):
painter, pos = args[:2]
alignment = Qt.AlignTop | Qt.AlignLeft
if len(args) == 3:
alignment = args[-1]
r = QRectF(pos, self.defaultSize())
if alignment & Qt.AlignLeft:
r.moveLeft(pos.x())
elif alignment & Qt.AlignHCenter:
r.moveCenter(QPointF(pos.x(), r.center().y()))
elif alignment & Qt.AlignRight:
r.moveRight(pos.x())
if alignment & Qt.AlignTop:
r.moveTop(pos.y())
elif alignment & Qt.AlignVCenter:
r.moveCenter(QPointF(r.center().x(), pos.y()))
elif alignment & Qt.AlignBottom:
r.moveBottom(pos.y())
self.render(painter, r)
else:
raise TypeError("%s().render() takes 1, 2 or 3 argument(s) (%s "
"given)" % (self.__class__.__name__, len(args)))
