Ejemplo n.º 1
0
    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()
Ejemplo n.º 2
0
    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)
Ejemplo n.º 3
0
    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)
Ejemplo n.º 4
0
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())
Ejemplo n.º 5
0
    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)
Ejemplo n.º 6
0
    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
Ejemplo n.º 7
0
    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
Ejemplo n.º 8
0
 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)))