Esempio n. 1
0
 def createFormatSettings(self):
     s = QgsTextFormat()
     s.setBuffer(self.createBufferSettings())
     s.setBackground(self.createBackgroundSettings())
     s.setShadow(self.createShadowSettings())
     s.setFont(getTestFont())
     s.setNamedStyle('Roman')
     s.setSize(5)
     s.setSizeUnit(QgsUnitTypes.RenderPoints)
     s.setSizeMapUnitScale(QgsMapUnitScale(1, 2))
     s.setColor(QColor(255, 0, 0))
     s.setOpacity(0.5)
     s.setBlendMode(QPainter.CompositionMode_Difference)
     s.setLineHeight(5)
     return s
Esempio n. 2
0
 def createFormatSettings(self):
     s = QgsTextFormat()
     s.setBuffer(self.createBufferSettings())
     s.setBackground(self.createBackgroundSettings())
     s.setShadow(self.createShadowSettings())
     s.setFont(getTestFont())
     s.setNamedStyle('Roman')
     s.setSize(5)
     s.setSizeUnit(QgsUnitTypes.RenderPoints)
     s.setSizeMapUnitScale(QgsMapUnitScale(1, 2))
     s.setColor(QColor(255, 0, 0))
     s.setOpacity(0.5)
     s.setBlendMode(QPainter.CompositionMode_Difference)
     s.setLineHeight(5)
     return s
Esempio n. 3
0
 def createFormatSettings(self):
     s = QgsTextFormat()
     s.setBuffer(self.createBufferSettings())
     s.setBackground(self.createBackgroundSettings())
     s.setShadow(self.createShadowSettings())
     font = getTestFont()
     font.setKerning(False)
     s.setFont(font)
     s.setNamedStyle('Roman')
     s.setSize(5)
     s.setSizeUnit(QgsUnitTypes.RenderPoints)
     s.setSizeMapUnitScale(QgsMapUnitScale(1, 2))
     s.setColor(QColor(255, 0, 0))
     s.setOpacity(0.5)
     s.setBlendMode(QPainter.CompositionMode_Difference)
     s.setLineHeight(5)
     s.setOrientation(QgsTextFormat.VerticalOrientation)
     s.setPreviewBackgroundColor(QColor(100, 150, 200))
     return s
Esempio n. 4
0
    def text_symbol_to_qgstextformat(
            text_symbol: TextSymbol,  # pylint: disable=too-many-locals,too-many-branches,too-many-statements
            context,
            reference_scale=None):
        """
        Converts TextSymbol to QgsTextFormat
        """
        text_format = QgsTextFormat()

        font = TextSymbolConverter.std_font_to_qfont(text_symbol.font)

        if context.unsupported_object_callback and font.family(
        ) not in QFontDatabase().families():
            if isinstance(text_symbol, TextSymbol):
                context.unsupported_object_callback(
                    'Font {} not available on system'.format(
                        text_symbol.font.font_name))

        if Qgis.QGIS_VERSION_INT >= 30900:
            font.setKerning(text_symbol.kerning)

        conversion_factor = reference_scale * 0.000352778 if reference_scale is not None else 1
        # why 5.55? why not! It's based on rendering match with ArcGIS -- there's no documentation
        # about what the ArcGIS character spacing value actually means!
        font.setLetterSpacing(
            QFont.AbsoluteSpacing,
            conversion_factor * (text_symbol.character_spacing or 0) / 5.55)

        # may need tweaking
        font.setWordSpacing(conversion_factor *
                            ((text_symbol.word_spacing / 100) - 1))

        if isinstance(text_symbol, TextSymbol):
            font.setCapitalization(
                TextSymbolConverter.CAPITALIZATION_MAP[text_symbol.case])
            if Qgis.QGIS_VERSION_INT >= 31600:
                text_format.setCapitalization(
                    TextSymbolConverter.TEXT_CAPITALIZATION_MAP[
                        text_symbol.case])

        if isinstance(text_symbol, TextSymbol):
            text_format.setLineHeight(1 + text_symbol.leading /
                                      text_symbol.font_size)

        text_format.setFont(font)
        if reference_scale is None:
            text_format.setSize(text_symbol.font_size)
            text_format.setSizeUnit(QgsUnitTypes.RenderPoints)
        else:
            text_format.setSize(text_symbol.font_size * reference_scale *
                                0.000352778)
            # todo - use normal map units
            text_format.setSizeUnit(QgsUnitTypes.RenderMetersInMapUnits)

        if Qgis.QGIS_VERSION_INT >= 32300 and text_symbol.character_width != 100:
            text_format.setStretchFactor(text_symbol.character_width)

        opacity = 1
        if isinstance(text_symbol, TextSymbol):
            color = ColorConverter.color_to_qcolor(text_symbol.color)
            # need to move opacity setting from color to dedicated setter
            opacity = color.alphaF()
            color.setAlpha(255)
            text_format.setColor(color)
            text_format.setOpacity(opacity)

        # shadow
        if text_symbol.shadow_x_offset or text_symbol.shadow_y_offset:
            shadow = QgsTextShadowSettings()
            shadow.setEnabled(True)

            shadow_color = ColorConverter.color_to_qcolor(
                text_symbol.shadow_color)
            # need to move opacity setting from color to dedicated setter
            shadow_opacity = shadow_color.alphaF()
            shadow_color.setAlpha(255)
            shadow.setColor(shadow_color)
            shadow.setOpacity(shadow_opacity)

            shadow_angle = math.degrees(
                math.atan2(text_symbol.shadow_y_offset,
                           text_symbol.shadow_x_offset))
            shadow_dist = math.sqrt(text_symbol.shadow_x_offset**2 +
                                    text_symbol.shadow_y_offset**2)

            shadow.setOffsetAngle(int(round(90 - shadow_angle)))
            if reference_scale is None:
                shadow.setOffsetDistance(context.convert_size(shadow_dist))
                shadow.setOffsetUnit(context.units)
            else:
                shadow.setOffsetDistance(shadow_dist * reference_scale *
                                         0.000352778)
                shadow.setOffsetUnit(QgsUnitTypes.RenderMetersInMapUnits)

            shadow.setBlendMode(QPainter.CompositionMode_SourceOver)

            # arc has no option for blurring shadows - we convert with a slight blur (because it's UGLY if we don't,
            # but use a lower blur then the default to give a somewhat closer match)
            shadow.setBlurRadius(0.5)

            text_format.setShadow(shadow)

        # halo
        buffer = QgsTextBufferSettings()
        if isinstance(text_symbol, TextSymbol):
            buffer.setEnabled(text_symbol.halo_enabled)
        else:
            buffer.setEnabled(bool(text_symbol.halo_symbol))

        if reference_scale is None:
            buffer.setSize(context.convert_size(text_symbol.halo_size))
            buffer.setSizeUnit(context.units)
        else:
            buffer.setSize(2 * text_symbol.halo_size * reference_scale *
                           0.000352778)
            buffer.setSizeUnit(QgsUnitTypes.RenderMetersInMapUnits)

        # QGIS has no option for halo symbols. Instead, we just get the color from the symbol
        if text_symbol.halo_symbol:
            from .symbols import SymbolConverter  # pylint: disable=import-outside-toplevel,cyclic-import
            halo_symbol = SymbolConverter.Symbol_to_QgsSymbol(
                text_symbol.halo_symbol, context)
            if halo_symbol:
                buffer_color = halo_symbol.color()
                # need to move opacity setting from color to dedicated setter
                buffer_opacity = buffer_color.alphaF()
                buffer_color.setAlpha(255)
                buffer.setColor(buffer_color)
                # in ArcMap buffer inherits text opacity, shadow does not
                buffer.setOpacity(buffer_opacity * opacity)

        text_format.setBuffer(buffer)

        if text_symbol.background_symbol:
            background = TextSymbolConverter.convert_background_symbol(
                text_symbol.background_symbol, context, reference_scale)
            if background:
                text_format.setBackground(background)

        if isinstance(text_symbol, TextSymbol):
            if text_symbol.cjk_orientation:
                if Qgis.QGIS_VERSION_INT < 30900:
                    if context.unsupported_object_callback:
                        context.unsupported_object_callback(
                            'Vertical text orientation requires QGIS 3.10 or later',
                            level=Context.WARNING)
                    else:
                        raise NotImplementedException(
                            'Vertical text orientation requires QGIS 3.10 or later'
                        )
                else:
                    text_format.setOrientation(
                        QgsTextFormat.VerticalOrientation)
        else:
            pass

        return text_format