Exemplo n.º 1
0
 def renderDocument(self,
                    plot,
                    filename,
                    sizeMM=(300, 200),
                    resolution=85,
                    format_=None):
     if isinstance(sizeMM, tuple):
         sizeMM = QSizeF(*sizeMM)
     if format_ is None:
         ext = osp.splitext(filename)[1]
         if not ext:
             raise TypeError(
                 "Unable to determine target format from filename")
         format_ = ext[1:]
     if plot is None or sizeMM.isEmpty() or resolution <= 0:
         return
     title = plot.title().text()
     if not title:
         title = "Plot Document"
     mmToInch = 1. / 25.4
     size = sizeMM * mmToInch * resolution
     documentRect = QRectF(0.0, 0.0, size.width(), size.height())
     fmt = format_.lower()
     if fmt in ("pdf", "ps"):
         printer = QPrinter()
         if fmt == "pdf":
             printer.setOutputFormat(QPrinter.PdfFormat)
         else:
             printer.setOutputFormat(QPrinter.PostScriptFormat)
         printer.setColorMode(QPrinter.Color)
         printer.setFullPage(True)
         printer.setPaperSize(sizeMM, QPrinter.Millimeter)
         printer.setDocName(title)
         printer.setOutputFileName(filename)
         printer.setResolution(resolution)
         painter = QPainter(printer)
         self.render(plot, painter, documentRect)
         painter.end()
     elif fmt == "svg":
         generator = QSvgGenerator()
         generator.setTitle(title)
         generator.setFileName(filename)
         generator.setResolution(resolution)
         generator.setViewBox(documentRect)
         painter = QPainter(generator)
         self.render(plot, painter, documentRect)
         painter.end()
     elif fmt in QImageWriter.supportedImageFormats():
         imageRect = documentRect.toRect()
         dotsPerMeter = int(round(resolution * mmToInch * 1000.))
         image = QImage(imageRect.size(), QImage.Format_ARGB32)
         image.setDotsPerMeterX(dotsPerMeter)
         image.setDotsPerMeterY(dotsPerMeter)
         image.fill(QColor(Qt.white).rgb())
         painter = QPainter(image)
         self.render(plot, painter, imageRect)
         painter.end()
         image.save(filename, fmt)
     else:
         raise TypeError("Unsupported file format '%s'" % fmt)
Exemplo n.º 2
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()
Exemplo n.º 3
0
 def renderDocument(self, plot, filename, sizeMM=(300, 200), resolution=85,
                    format_=None):
     if isinstance(sizeMM, tuple):
         sizeMM = QSizeF(*sizeMM)
     if format_ is None:
         ext = osp.splitext(filename)[1]
         if not ext:
             raise TypeError("Unable to determine target format from filename")
         format_ = ext[1:]
     if plot is None or sizeMM.isEmpty() or resolution <= 0:
         return
     title = plot.title().text()
     if not title:
         title = "Plot Document"
     mmToInch = 1./25.4
     size = sizeMM * mmToInch * resolution
     documentRect = QRectF(0.0, 0.0, size.width(), size.height())
     fmt = format_.lower()
     if fmt in ("pdf", "ps"):
         printer = QPrinter()
         if fmt == "pdf":
             printer.setOutputFormat(QPrinter.PdfFormat)
         else:
             printer.setOutputFormat(QPrinter.PostScriptFormat)
         printer.setColorMode(QPrinter.Color)
         printer.setFullPage(True)
         printer.setPaperSize(sizeMM, QPrinter.Millimeter)
         printer.setDocName(title)
         printer.setOutputFileName(filename)
         printer.setResolution(resolution)
         painter = QPainter(printer)
         self.render(plot, painter, documentRect)
         painter.end()
     elif fmt == "svg":
         generator = QSvgGenerator()
         generator.setTitle(title)
         generator.setFileName(filename)
         generator.setResolution(resolution)
         generator.setViewBox(documentRect)
         painter = QPainter(generator)
         self.render(plot, painter, documentRect)
         painter.end()
     elif fmt in QImageWriter.supportedImageFormats():
         imageRect = documentRect.toRect()
         dotsPerMeter = int(round(resolution*mmToInch*1000.))
         image = QImage(imageRect.size(), QImage.Format_ARGB32)
         image.setDotsPerMeterX(dotsPerMeter)
         image.setDotsPerMeterY(dotsPerMeter)
         image.fill(QColor(Qt.white).rgb())
         painter = QPainter(image)
         self.render(plot, painter, imageRect)
         painter.end()
         image.save(filename, fmt)
     else:
         raise TypeError("Unsupported file format '%s'" % fmt)
Exemplo n.º 4
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()
Exemplo n.º 5
0
 def reset(self):
     """Clear all stored commands"""
     self.__data.commands = []
     self.__data.pathInfos = []
     self.__data.boundingRect = QRectF(0.0, 0.0, -1.0, -1.0)
     self.__data.pointRect = QRectF(0.0, 0.0, -1.0, -1.0)
     self.__data.defaultSize = QSizeF()
Exemplo n.º 6
0
 def drawSimpleRichText(self, painter, rect, flags, text):
     txt = text.clone()
     painter.save()
     unscaledRect = QRectF(rect)
     if painter.font().pixelSize() < 0:
         res = qwtScreenResolution()
         pd = painter.device()
         if pd.logicalDpiX() != res.width()\
            or pd.logicalDpiY() != res.height():
             transform = QTransform()
             transform.scale(res.width() / float(pd.logicalDpiX()),
                             res.height() / float(pd.logicalDpiY()))
             painter.setWorldTransform(transform, True)
             invtrans, _ok = transform.inverted()
             unscaledRect = invtrans.mapRect(rect)
     txt.setDefaultFont(painter.font())
     txt.setPageSize(QSizeF(unscaledRect.width(), QWIDGETSIZE_MAX))
     layout = txt.documentLayout()
     height = layout.documentSize().height()
     y = unscaledRect.y()
     if flags & Qt.AlignBottom:
         y += unscaledRect.height() - height
     elif flags & Qt.AlignVCenter:
         y += (unscaledRect.height() - height) / 2
     context = QAbstractTextDocumentLayout.PaintContext()
     context.palette.setColor(QPalette.Text, painter.pen().color())
     painter.translate(unscaledRect.x(), y)
     layout.draw(painter, context)
     painter.restore()
Exemplo n.º 7
0
 def exportTo(self, plot, documentname, sizeMM=None, resolution=85):
     if plot is None:
         return
     if sizeMM is None:
         sizeMM = QSizeF(300, 200)
     filename = documentname
     imageFormats = QImageWriter.supportedImageFormats()
     filter_ = [
         "PDF documents (*.pdf)", "SVG documents (*.svg)",
         "Postscript documents (*.ps)"
     ]
     if imageFormats:
         imageFilter = "Images"
         imageFilter += " ("
         for idx, fmt in enumerate(imageFormats):
             if idx > 0:
                 imageFilter += " "
             imageFilter += "*." + str(fmt)
         imageFilter += ")"
         filter_ += [imageFilter]
     filename, _s = getsavefilename(
         plot,
         "Export File Name",
         filename,
         ";;".join(filter_),
         options=QFileDialog.DontConfirmOverwrite)
     if not filename:
         return False
     self.renderDocument(plot, filename, sizeMM, resolution)
     return True
Exemplo n.º 8
0
 def __init__(self):
     self.boundingRect = QRectF(0.0, 0.0, -1.0, -1.0)
     self.pointRect = QRectF(0.0, 0.0, -1.0, -1.0)
     self.initialTransform = None
     self.defaultSize = QSizeF()
     self.commands = []
     self.pathInfos = []
     self.renderHints = 0
Exemplo n.º 9
0
 def drawSymbol(self, painter, point_or_rect):
     if isinstance(point_or_rect, (QPointF, QPoint)):
         # drawSymbol( QPainter *, const QPointF & )
         self.drawSymbols(painter, [point_or_rect], 1)
         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()
Exemplo n.º 10
0
    def heightForWidth(self, font, flags, text, width):
        """
        Find the height for a given width

        :param QFont font: Font of the text
        :param int flags: Bitwise OR of the flags used like in QPainter::drawText
        :param str text: Text to be rendered
        :param float width: Width
        :return: Calculated height
        """
        doc = QwtRichTextDocument(text, flags, font)
        doc.setPageSize(QSizeF(width, QWIDGETSIZE_MAX))
        return doc.documentLayout().documentSize().height()
Exemplo n.º 11
0
 def textSize(self, defaultFont):
     font = QFont(self.usedFont(defaultFont), self.desktopwidget)
     if not self.__layoutCache.textSize.isValid() or\
        self.__layoutCache.font is not font:
         self.__layoutCache.textSize =\
             self.__data.textEngine.textSize(font, self.__data.renderFlags,
                                             self.__data.text)
         self.__layoutCache.font = font
     sz = self.__layoutCache.textSize
     if self.__data.layoutAttributes & self.MinimumLayout:
         (left, right, top,
          bottom) = self.__data.textEngine.textMargins(font)
         sz -= QSizeF(left + right, top + bottom)
     return sz
Exemplo n.º 12
0
def qwtFillBackground(*args):
    if len(args) == 2:
        painter, canvas = args

        rects = []
        if canvas.testAttribute(Qt.WA_StyledBackground):
            recorder = QwtStyleSheetRecorder(canvas.size())
            p = QPainter(recorder)
            qwtDrawStyledBackground(canvas, p)
            p.end()
            if recorder.background.brush.isOpaque():
                rects = recorder.clipRects
            else:
                rects += [canvas.rect()]
        else:
            r = canvas.rect()
            radius = canvas.borderRadius()
            if radius > 0.:
                sz = QSizeF(radius, radius)
                rects += [
                    QRectF(r.topLeft(), sz),
                    QRectF(r.topRight() - QPointF(radius, 0), sz),
                    QRectF(r.bottomRight() - QPointF(radius, radius), sz),
                    QRectF(r.bottomLeft() - QPointF(0, radius), sz)
                ]

        qwtFillBackground(painter, canvas, rects)

    elif len(args) == 3:
        painter, widget, fillRects = args

        if not fillRects:
            return
        if painter.hasClipping():
            clipRegion = painter.transform().map(painter.clipRegion())
        else:
            clipRegion = widget.contentsRect()
        bgWidget = qwtBackgroundWidget(widget.parentWidget())
        for fillRect in fillRects:
            rect = fillRect.toAlignedRect()
            if clipRegion.intersects(rect):
                pm = QPixmap(rect.size())
                QwtPainter.fillPixmap(bgWidget, pm,
                                      widget.mapTo(bgWidget, rect.topLeft()))
                painter.drawPixmap(rect, pm)

    else:
        raise TypeError("%s() takes 2 or 3 argument(s) (%s given)"\
                        % ("qwtFillBackground", len(args)))
Exemplo n.º 13
0
 def minimumSizeHint(self):
     sz = self.__data.text.textSize(self.font())
     mw = 2 * (self.frameWidth() + self.__data.margin)
     mh = mw
     indent = self.__data.indent
     if indent <= 0:
         indent = self.defaultIndent()
     if indent > 0:
         align = self.__data.text.renderFlags()
         if align & Qt.AlignLeft or align & Qt.AlignRight:
             mw += self.__data.indent
         elif align & Qt.AlignTop or align & Qt.AlignBottom:
             mh += self.__data.indent
     sz += QSizeF(mw, mh)
     return QSize(np.ceil(sz.width()), np.ceil(sz.height()))
Exemplo n.º 14
0
    def setDefaultSize(self, size):
        """
        The default size is used in all methods rendering the graphic,
        where no size is explicitly specified. Assigning an empty size
        means, that the default size will be calculated from the bounding 
        rectangle.
        
        :param QSizeF size: Default size

        .. seealso::
        
            :py:meth:`defaultSize()`, :py:meth:`boundingRect()`
        """
        w = max([0., size.width()])
        h = max([0., size.height()])
        self.__data.defaultSize = QSizeF(w, h)
Exemplo n.º 15
0
    def exportTo(self, plot, documentname, sizeMM=None, resolution=85):
        """
        Execute a file dialog and render the plot to the selected file

        :param qwt.plot.QwtPlot plot: Plot widget
        :param str documentName: Default document name
        :param QSizeF sizeMM: Size for the document in millimeters
        :param int resolution: Resolution in dots per Inch (dpi)
        :return: True, when exporting was successful
        
        .. seealso::
        
            :py:meth:`renderDocument()`
        """
        if plot is None:
            return
        if sizeMM is None:
            sizeMM = QSizeF(300, 200)
        filename = documentname
        imageFormats = QImageWriter.supportedImageFormats()
        filter_ = [
            "PDF documents (*.pdf)", "SVG documents (*.svg)",
            "Postscript documents (*.ps)"
        ]
        if imageFormats:
            imageFilter = "Images"
            imageFilter += " ("
            for idx, fmt in enumerate(imageFormats):
                if idx > 0:
                    imageFilter += " "
                imageFilter += "*." + str(fmt)
            imageFilter += ")"
            filter_ += [imageFilter]
        filename, _s = getsavefilename(
            plot,
            "Export File Name",
            filename,
            ";;".join(filter_),
            options=QFileDialog.DontConfirmOverwrite)
        if not filename:
            return False
        self.renderDocument(plot, filename, sizeMM, resolution)
        return True
Exemplo n.º 16
0
  def textSize(self, defaultFont):
      """
      Returns the size, that is needed to render text
 
      :param QFont defaultFont Font, used for the calculation if the text has no font
      :return: Caluclated size
      """
      font = QFont(self.usedFont(defaultFont), self._desktopwidget)
      if not self.__layoutCache.textSize.isValid() or\
         self.__layoutCache.font is not font:
          self.__layoutCache.textSize =\
              self.__data.textEngine.textSize(font, self.__data.renderFlags,
                                              self.__data.text)
          self.__layoutCache.font = font
      sz = self.__layoutCache.textSize
      if self.__data.layoutAttributes & self.MinimumLayout:
          (left, right, top,
           bottom) = self.__data.textEngine.textMargins(font)
          sz -= QSizeF(left + right, top + bottom)
      return sz
Exemplo n.º 17
0
def qwtDrawSvgSymbols(painter, points, numPoints, renderer, symbol):
    if renderer is None or not renderer.isValid():
        return
    viewBox = QRectF(renderer.viewBoxF())
    if viewBox.isEmpty():
        return
    sz = QSizeF(symbol.size())
    if not sz.isValid():
        sz = viewBox.size()
    sx = sz.width() / viewBox.width()
    sy = sz.height() / viewBox.height()
    pinPoint = QPointF(viewBox.center())
    if symbol.isPinPointEnabled():
        pinPoint = symbol.pinPoint()
    dx = sx * (pinPoint.x() - viewBox.left())
    dy = sy * (pinPoint.y() - viewBox.top())
    for pos in points:
        x = pos.x() - dx
        y = pos.y() - dy
        renderer.render(painter, QRectF(x, y, sz.width(), sz.height()))
Exemplo n.º 18
0
    def draw(self, painter, rect, flags, text):
        """
        Draw the text in a clipping rectangle

        :param QPainter painter: Painter
        :param QRectF rect: Clipping rectangle
        :param int flags: Bitwise OR of the flags like in for QPainter::drawText()
        :param str text: Text to be rendered
        """
        txt = QwtRichTextDocument(text, flags, painter.font())
        painter.save()
        unscaledRect = QRectF(rect)
        if painter.font().pixelSize() < 0:
            res = qwtScreenResolution()
            pd = painter.device()
            if pd.logicalDpiX() != res.width()\
               or pd.logicalDpiY() != res.height():
                transform = QTransform()
                transform.scale(res.width() / float(pd.logicalDpiX()),
                                res.height() / float(pd.logicalDpiY()))
                painter.setWorldTransform(transform, True)
                invtrans, _ok = transform.inverted()
                unscaledRect = invtrans.mapRect(rect)
        txt.setDefaultFont(painter.font())
        txt.setPageSize(QSizeF(unscaledRect.width(), QWIDGETSIZE_MAX))
        layout = txt.documentLayout()
        height = layout.documentSize().height()
        y = unscaledRect.y()
        if flags & Qt.AlignBottom:
            y += unscaledRect.height() - height
        elif flags & Qt.AlignVCenter:
            y += (unscaledRect.height() - height) / 2
        context = QAbstractTextDocumentLayout.PaintContext()
        context.palette.setColor(QPalette.Text, painter.pen().color())
        painter.translate(unscaledRect.x(), y)
        layout.draw(painter, context)
        painter.restore()
Exemplo n.º 19
0
def qwtDrawSvgSymbols(painter, points, numPoints, renderer, symbol):
    if renderer is None or not renderer.isValid():
        return
    viewBox = QRectF(renderer.viewBoxF())
    if viewBox.isEmpty():
        return
    sz = QSizeF(symbol.size())
    if not sz.isValid():
        sz = viewBox.size()
    sx = sz.width()/viewBox.width()
    sy = sz.height()/viewBox.height()
    pinPoint = QPointF(viewBox.center())
    if symbol.isPinPointEnabled():
        pinPoint = symbol.pinPoint()
    dx = sx*(pinPoint.x()-viewBox.left())
    dy = sy*(pinPoint.y()-viewBox.top())
    for pos in points:
        x = pos.x()-dx
        y = pos.y()-dy
        renderer.render(painter, QRectF(x, y, sz.width(), sz.height()))
Exemplo n.º 20
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.
            if self.__data.pen.style() != Qt.NoPen:
                pw = max([self.__data.pen.widthF(), 1.])
            rect.setSize(self.__data.size+QSizeF(pw, pw))
            rect.moveCenter(QPointF(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.
            if self.__data.pen.style() != Qt.NoPen:
                pw = max([self.__data.pen.widthF(), 1.])
            rect.setSize(QSizeF(self.__data.size)+QSizeF(2*pw, 2*pw))
            rect.moveCenter(QPointF(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.))
        if pinPointTranslation:
            pinPoint = QPointF(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
Exemplo n.º 21
0
 def drawLabel(self, painter, canvasRect, pos):
     """
     Align and draw the text label of the marker
     
     :param QPainter painter: Painter
     :param QRectF canvasRect: Contents rectangle of the canvas in painter coordinates
     :param QPointF pos: Position of the marker, translated into widget coordinates
     
     .. seealso::
     
         :py:meth:`drawLabel()`, 
         :py:meth:`qwt.symbol.QwtSymbol.drawSymbol()`
     """
     if self.__data.label.isEmpty():
         return
     align = Qt.Alignment(self.__data.labelAlignment)
     alignPos = QPointF(pos)
     symbolOff = QSizeF(0, 0)
     if self.__data.style == QwtPlotMarker.VLine:
         #  In VLine-style the y-position is pointless and
         #  the alignment flags are relative to the canvas
         if bool(self.__data.labelAlignment & Qt.AlignTop):
             alignPos.setY(canvasRect.top())
             align &= ~Qt.AlignTop
             align |= Qt.AlignBottom
         elif bool(self.__data.labelAlignment & Qt.AlignBottom):
             #  In HLine-style the x-position is pointless and
             #  the alignment flags are relative to the canvas
             alignPos.setY(canvasRect.bottom() - 1)
             align &= ~Qt.AlignBottom
             align |= Qt.AlignTop
         else:
             alignPos.setY(canvasRect.center().y())
     elif self.__data.style == QwtPlotMarker.HLine:
         if bool(self.__data.labelAlignment & Qt.AlignLeft):
             alignPos.setX(canvasRect.left())
             align &= ~Qt.AlignLeft
             align |= Qt.AlignRight
         elif bool(self.__data.labelAlignment & Qt.AlignRight):
             alignPos.setX(canvasRect.right() - 1)
             align &= ~Qt.AlignRight
             align |= Qt.AlignLeft
         else:
             alignPos.setX(canvasRect.center().x())
     else:
         if self.__data.symbol and\
            self.__data.symbol.style() != QwtSymbol.NoSymbol:
             symbolOff = self.__data.symbol.size() + QSizeF(1, 1)
             symbolOff /= 2
     pw2 = self.__data.pen.widthF() / 2.
     if pw2 == 0.:
         pw2 = .5
     spacing = self.__data.spacing
     xOff = max([pw2, symbolOff.width()])
     yOff = max([pw2, symbolOff.height()])
     textSize = self.__data.label.textSize(painter.font())
     if align & Qt.AlignLeft:
         alignPos.setX(alignPos.x() - (xOff + spacing))
         if self.__data.labelOrientation == Qt.Vertical:
             alignPos.setX(alignPos.x() - textSize.height())
         else:
             alignPos.setX(alignPos.x() - textSize.width())
     elif align & Qt.AlignRight:
         alignPos.setX(alignPos.x() + xOff + spacing)
     else:
         if self.__data.labelOrientation == Qt.Vertical:
             alignPos.setX(alignPos.x() - textSize.height() / 2)
         else:
             alignPos.setX(alignPos.x() - textSize.width() / 2)
     if align & Qt.AlignTop:
         alignPos.setY(alignPos.y() - (yOff + spacing))
         if self.__data.labelOrientation != Qt.Vertical:
             alignPos.setY(alignPos.y() - textSize.height())
     elif align & Qt.AlignBottom:
         alignPos.setY(alignPos.y() + yOff + spacing)
         if self.__data.labelOrientation == Qt.Vertical:
             alignPos.setY(alignPos.y() + textSize.width())
     else:
         if self.__data.labelOrientation == Qt.Vertical:
             alignPos.setY(alignPos.y() + textSize.width() / 2)
         else:
             alignPos.setY(alignPos.y() - textSize.height() / 2)
     painter.translate(alignPos.x(), alignPos.y())
     if self.__data.labelOrientation == Qt.Vertical:
         painter.rotate(-90.)
     textRect = QRectF(0, 0, textSize.width(), textSize.height())
     self.__data.label.draw(painter, textRect)
Exemplo n.º 22
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.
            if self.__data.pen.style() != Qt.NoPen:
                pw = max([self.__data.pen.widthF(), 1.])
            rect.setSize(self.__data.size + QSizeF(pw, pw))
            rect.moveCenter(QPointF(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.
            if self.__data.pen.style() != Qt.NoPen:
                pw = max([self.__data.pen.widthF(), 1.])
            rect.setSize(QSizeF(self.__data.size) + QSizeF(2 * pw, 2 * pw))
            rect.moveCenter(QPointF(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.))
        if pinPointTranslation:
            pinPoint = QPointF(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
Exemplo n.º 23
0
 def drawLabel(self, painter, canvasRect, pos):
     if self.__data.label.isEmpty():
         return
     align = Qt.Alignment(self.__data.labelAlignment)
     alignPos = QPointF(pos)
     symbolOff = QSizeF(0, 0)
     if self.__data.style == QwtPlotMarker.VLine:
         if bool(self.__data.labelAlignment & Qt.AlignTop):
             alignPos.setY(canvasRect.top())
             align &= ~Qt.AlignTop
             align |= Qt.AlignBottom
         elif bool(self.__data.labelAlignment & Qt.AlignBottom):
             alignPos.setY(canvasRect.bottom() - 1)
             align &= ~Qt.AlignBottom
             align |= Qt.AlignTop
         else:
             alignPos.setY(canvasRect.center().y())
     elif self.__data.style == QwtPlotMarker.HLine:
         if bool(self.__data.labelAlignment & Qt.AlignLeft):
             alignPos.setX(canvasRect.left())
             align &= ~Qt.AlignLeft
             align |= Qt.AlignRight
         elif bool(self.__data.labelAlignment & Qt.AlignRight):
             alignPos.setX(canvasRect.right() - 1)
             align &= ~Qt.AlignRight
             align |= Qt.AlignLeft
         else:
             alignPos.setX(canvasRect.center().x())
     else:
         if self.__data.symbol and\
            self.__data.symbol.style() != QwtSymbol.NoSymbol:
             symbolOff = self.__data.symbol.size() + QSizeF(1, 1)
             symbolOff /= 2
     pw2 = self.__data.pen.widthF() / 2.
     if pw2 == 0.:
         pw2 = .5
     spacing = self.__data.spacing
     xOff = max([pw2, symbolOff.width()])
     yOff = max([pw2, symbolOff.height()])
     textSize = self.__data.label.textSize(painter.font())
     if align & Qt.AlignLeft:
         alignPos.setX(alignPos.x() - (xOff + spacing))
         if self.__data.labelOrientation == Qt.Vertical:
             alignPos.setX(alignPos.x() - textSize.height())
         else:
             alignPos.setX(alignPos.x() - textSize.width())
     elif align & Qt.AlignRight:
         alignPos.setX(alignPos.x() + xOff + spacing)
     else:
         if self.__data.labelOrientation == Qt.Vertical:
             alignPos.setX(alignPos.x() - textSize.height() / 2)
         else:
             alignPos.setX(alignPos.x() - textSize.width() / 2)
     if align & Qt.AlignTop:
         alignPos.setY(alignPos.y() - (yOff + spacing))
         if self.__data.labelOrientation != Qt.Vertical:
             alignPos.setY(alignPos.y() - textSize.height())
     elif align & Qt.AlignBottom:
         alignPos.setY(alignPos.y() + yOff + spacing)
         if self.__data.labelOrientation == Qt.Vertical:
             alignPos.setY(alignPos.y() + textSize.width())
     else:
         if self.__data.labelOrientation == Qt.Vertical:
             alignPos.setY(alignPos.y() + textSize.width() / 2)
         else:
             alignPos.setY(alignPos.y() - textSize.height() / 2)
     painter.translate(alignPos.x(), alignPos.y())
     if self.__data.labelOrientation == Qt.Vertical:
         painter.rotate(-90.)
     textRect = QRectF(0, 0, textSize.width(), textSize.height())
     self.__data.label.draw(painter, textRect)
Exemplo n.º 24
0
 def drawLabel(self, painter, canvasRect, pos):
     if self.__data.label.isEmpty():
         return
     align = Qt.Alignment(self.__data.labelAlignment)
     alignPos = QPointF(pos)
     symbolOff = QSizeF(0, 0)
     if self.__data.style == QwtPlotMarker.VLine:
         if bool(self.__data.labelAlignment & Qt.AlignTop):
             alignPos.setY(canvasRect.top())
             align &= ~Qt.AlignTop
             align |= Qt.AlignBottom
         elif bool(self.__data.labelAlignment & Qt.AlignBottom):
             alignPos.setY(canvasRect.bottom()-1)
             align &= ~Qt.AlignBottom
             align |= Qt.AlignTop
         else:
             alignPos.setY(canvasRect.center().y())
     elif self.__data.style == QwtPlotMarker.HLine:
         if bool(self.__data.labelAlignment & Qt.AlignLeft):
             alignPos.setX(canvasRect.left())
             align &= ~Qt.AlignLeft
             align |= Qt.AlignRight
         elif bool(self.__data.labelAlignment & Qt.AlignRight):
             alignPos.setX(canvasRect.right()-1)
             align &= ~Qt.AlignRight
             align |= Qt.AlignLeft
         else:
             alignPos.setX(canvasRect.center().x())
     else:
         if self.__data.symbol and\
            self.__data.symbol.style() != QwtSymbol.NoSymbol:
             symbolOff = self.__data.symbol.size()+QSizeF(1, 1)
             symbolOff /= 2
     pw2 = self.__data.pen.widthF()/2.
     if pw2 == 0.:
         pw2 = .5
     spacing = self.__data.spacing
     xOff = max([pw2, symbolOff.width()])
     yOff = max([pw2, symbolOff.height()])
     textSize = self.__data.label.textSize(painter.font())
     if align & Qt.AlignLeft:
         alignPos.setX(alignPos.x()-(xOff+spacing))
         if self.__data.labelOrientation == Qt.Vertical:
             alignPos.setX(alignPos.x()-textSize.height())
         else:
             alignPos.setX(alignPos.x()-textSize.width())
     elif align & Qt.AlignRight:
         alignPos.setX(alignPos.x()+xOff+spacing)
     else:
         if self.__data.labelOrientation == Qt.Vertical:
             alignPos.setX(alignPos.x()-textSize.height()/2)
         else:
             alignPos.setX(alignPos.x()-textSize.width()/2)
     if align & Qt.AlignTop:
         alignPos.setY(alignPos.y()-(yOff+spacing))
         if self.__data.labelOrientation != Qt.Vertical:
             alignPos.setY(alignPos.y()-textSize.height())
     elif align & Qt.AlignBottom:
         alignPos.setY(alignPos.y()+yOff+spacing)
         if self.__data.labelOrientation == Qt.Vertical:
             alignPos.setY(alignPos.y()+textSize.width())
     else:
         if self.__data.labelOrientation == Qt.Vertical:
             alignPos.setY(alignPos.y()+textSize.width()/2)
         else:
             alignPos.setY(alignPos.y()-textSize.height()/2)
     painter.translate(alignPos.x(), alignPos.y())
     if self.__data.labelOrientation == Qt.Vertical:
         painter.rotate(-90.)
     textRect = QRectF(0, 0, textSize.width(), textSize.height())
     self.__data.label.draw(painter, textRect)
Exemplo n.º 25
0
 def setDefaultSize(self, size):
     w = max([0., size.width()])
     h = max([0., size.height()])
     self.__data.defaultSize = QSizeF(w, h)
Exemplo n.º 26
0
 def heightForWidth(self, font, flags, text, width):
     doc = QwtRichTextDocument(text, flags, font)
     doc.setPageSize(QSizeF(width, QWIDGETSIZE_MAX))
     return doc.documentLayout().documentSize().height()
Exemplo n.º 27
0
 def drawLabel(self, painter, canvasRect, pos):
     """
     Align and draw the text label of the marker
     
     :param QPainter painter: Painter
     :param QRectF canvasRect: Contents rectangle of the canvas in painter coordinates
     :param QPointF pos: Position of the marker, translated into widget coordinates
     
     .. seealso::
     
         :py:meth:`drawLabel()`, 
         :py:meth:`qwt.symbol.QwtSymbol.drawSymbol()`
     """
     if self.__data.label.isEmpty():
         return
     align = Qt.Alignment(self.__data.labelAlignment)
     alignPos = QPointF(pos)
     symbolOff = QSizeF(0, 0)
     if self.__data.style == QwtPlotMarker.VLine:
         #  In VLine-style the y-position is pointless and
         #  the alignment flags are relative to the canvas
         if bool(self.__data.labelAlignment & Qt.AlignTop):
             alignPos.setY(canvasRect.top())
             align &= ~Qt.AlignTop
             align |= Qt.AlignBottom
         elif bool(self.__data.labelAlignment & Qt.AlignBottom):
             #  In HLine-style the x-position is pointless and
             #  the alignment flags are relative to the canvas
             alignPos.setY(canvasRect.bottom()-1)
             align &= ~Qt.AlignBottom
             align |= Qt.AlignTop
         else:
             alignPos.setY(canvasRect.center().y())
     elif self.__data.style == QwtPlotMarker.HLine:
         if bool(self.__data.labelAlignment & Qt.AlignLeft):
             alignPos.setX(canvasRect.left())
             align &= ~Qt.AlignLeft
             align |= Qt.AlignRight
         elif bool(self.__data.labelAlignment & Qt.AlignRight):
             alignPos.setX(canvasRect.right()-1)
             align &= ~Qt.AlignRight
             align |= Qt.AlignLeft
         else:
             alignPos.setX(canvasRect.center().x())
     else:
         if self.__data.symbol and\
            self.__data.symbol.style() != QwtSymbol.NoSymbol:
             symbolOff = self.__data.symbol.size()+QSizeF(1, 1)
             symbolOff /= 2
     pw2 = self.__data.pen.widthF()/2.
     if pw2 == 0.:
         pw2 = .5
     spacing = self.__data.spacing
     xOff = max([pw2, symbolOff.width()])
     yOff = max([pw2, symbolOff.height()])
     textSize = self.__data.label.textSize(painter.font())
     if align & Qt.AlignLeft:
         alignPos.setX(alignPos.x()-(xOff+spacing))
         if self.__data.labelOrientation == Qt.Vertical:
             alignPos.setX(alignPos.x()-textSize.height())
         else:
             alignPos.setX(alignPos.x()-textSize.width())
     elif align & Qt.AlignRight:
         alignPos.setX(alignPos.x()+xOff+spacing)
     else:
         if self.__data.labelOrientation == Qt.Vertical:
             alignPos.setX(alignPos.x()-textSize.height()/2)
         else:
             alignPos.setX(alignPos.x()-textSize.width()/2)
     if align & Qt.AlignTop:
         alignPos.setY(alignPos.y()-(yOff+spacing))
         if self.__data.labelOrientation != Qt.Vertical:
             alignPos.setY(alignPos.y()-textSize.height())
     elif align & Qt.AlignBottom:
         alignPos.setY(alignPos.y()+yOff+spacing)
         if self.__data.labelOrientation == Qt.Vertical:
             alignPos.setY(alignPos.y()+textSize.width())
     else:
         if self.__data.labelOrientation == Qt.Vertical:
             alignPos.setY(alignPos.y()+textSize.width()/2)
         else:
             alignPos.setY(alignPos.y()-textSize.height()/2)
     painter.translate(alignPos.x(), alignPos.y())
     if self.__data.labelOrientation == Qt.Vertical:
         painter.rotate(-90.)
     textRect = QRectF(0, 0, textSize.width(), textSize.height())
     self.__data.label.draw(painter, textRect)
Exemplo n.º 28
0
 def __init__(self):
     self.textSize = QSizeF()
     self.font = None
Exemplo n.º 29
0
 def reset(self):
     self.__data.commands = []
     self.__data.pathInfos = []
     self.__data.boundingRect = QRectF(0.0, 0.0, -1.0, -1.0)
     self.__data.pointRect = QRectF(0.0, 0.0, -1.0, -1.0)
     self.__data.defaultSize = QSizeF()
Exemplo n.º 30
0
 def invalidate(self):
     self.textSize = QSizeF()