qgstextbuffersettings.cpp

Go to the documentation of this file.

/***************************************************************************
  qgstextbuffersettings.cpp
  -----------------
   begin                : May 2020
   copyright            : (C) Nyall Dawson
   email                : nyall dot dawson at gmail dot com
 
 ***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 
#include "qgstextbuffersettings.h"
 
#include "qgsapplication.h"
#include "qgscolorutils.h"
#include "qgspainteffectregistry.h"
#include "qgspainting.h"
#include "qgspallabeling.h"
#include "qgssymbollayerutils.h"
#include "qgstextrenderer_p.h"
#include "qgstextrendererutils.h"
#include "qgsunittypes.h"
#include "qgsvectorlayer.h"
 
#include <QString>
 
using namespace Qt::StringLiterals;
 
QgsTextBufferSettings::QgsTextBufferSettings()
{
  d = new QgsTextBufferSettingsPrivate();
}
 
QgsTextBufferSettings::QgsTextBufferSettings( const QgsTextBufferSettings &other ) //NOLINT
  : d( other.d )
{
}
QgsTextBufferSettings::QgsTextBufferSettings( QgsTextBufferSettings &&other ) //NOLINT
  : d( std::move( other.d ) )
{
}
 
QgsTextBufferSettings &QgsTextBufferSettings::operator=( const QgsTextBufferSettings &other )  //NOLINT
{
  if ( &other == this )
    return *this;
 
  d = other.d;
  return *this;
}
 
QgsTextBufferSettings &QgsTextBufferSettings::operator=( QgsTextBufferSettings &&other )  //NOLINT
{
  if ( &other == this )
    return *this;
 
  d = std::move( other.d );
  return *this;
}
 
QgsTextBufferSettings::~QgsTextBufferSettings() //NOLINT
{
 
}
 
bool QgsTextBufferSettings::operator==( const QgsTextBufferSettings &other ) const
{
  if ( d->enabled != other.enabled()
       || d->size != other.size()
       || d->sizeUnit != other.sizeUnit()
       || d->sizeMapUnitScale != other.sizeMapUnitScale()
       || d->color != other.color()
       || d->opacity != other.opacity()
       || d->fillBufferInterior != other.fillBufferInterior()
       || d->joinStyle != other.joinStyle()
       || d->blendMode != other.blendMode() )
    return false;
 
  if ( static_cast< bool >( d->paintEffect ) != static_cast< bool >( other.paintEffect() )
       || ( d->paintEffect && d->paintEffect->properties() != other.paintEffect()->properties() ) )
    return false;
 
  return true;
}
 
bool QgsTextBufferSettings::operator!=( const QgsTextBufferSettings &other ) const
{
  return !( *this == other );
}
 
bool QgsTextBufferSettings::enabled() const
{
  return d->enabled;
}
 
void QgsTextBufferSettings::setEnabled( bool enabled )
{
  d->enabled = enabled;
}
 
double QgsTextBufferSettings::size() const
{
  return d->size;
}
 
void QgsTextBufferSettings::setSize( double size )
{
  d->size = size;
}
 
Qgis::RenderUnit QgsTextBufferSettings::sizeUnit() const
{
  return d->sizeUnit;
}
 
void QgsTextBufferSettings::setSizeUnit( Qgis::RenderUnit unit )
{
  d->sizeUnit = unit;
}
 
QgsMapUnitScale QgsTextBufferSettings::sizeMapUnitScale() const
{
  return d->sizeMapUnitScale;
}
 
void QgsTextBufferSettings::setSizeMapUnitScale( const QgsMapUnitScale &scale )
{
  d->sizeMapUnitScale = scale;
}
 
QColor QgsTextBufferSettings::color() const
{
  return d->color;
}
 
void QgsTextBufferSettings::setColor( const QColor &color )
{
  d->color = color;
}
 
bool QgsTextBufferSettings::fillBufferInterior() const
{
  return d->fillBufferInterior;
}
 
void QgsTextBufferSettings::setFillBufferInterior( bool fill )
{
  d->fillBufferInterior = fill;
}
 
double QgsTextBufferSettings::opacity() const
{
  return d->opacity;
}
 
void QgsTextBufferSettings::setOpacity( double opacity )
{
  d->opacity = opacity;
}
 
Qt::PenJoinStyle QgsTextBufferSettings::joinStyle() const
{
  return d->joinStyle;
}
 
void QgsTextBufferSettings::setJoinStyle( Qt::PenJoinStyle style )
{
  d->joinStyle = style;
}
 
QPainter::CompositionMode QgsTextBufferSettings::blendMode() const
{
  return d->blendMode;
}
 
void QgsTextBufferSettings::setBlendMode( QPainter::CompositionMode mode )
{
  d->blendMode = mode;
}
 
const QgsPaintEffect *QgsTextBufferSettings::paintEffect() const
{
  return d->paintEffect.get();
}
 
void QgsTextBufferSettings::setPaintEffect( QgsPaintEffect *effect )
{
  d->paintEffect.reset( effect );
}
 
void QgsTextBufferSettings::updateDataDefinedProperties( QgsRenderContext &context, const QgsPropertyCollection &properties )
{
  if ( properties.isActive( QgsPalLayerSettings::Property::BufferDraw ) )
  {
    context.expressionContext().setOriginalValueVariable( d->enabled );
    d->enabled = properties.valueAsBool( QgsPalLayerSettings::Property::BufferDraw, context.expressionContext(), d->enabled );
  }
 
  if ( properties.isActive( QgsPalLayerSettings::Property::BufferSize ) )
  {
    context.expressionContext().setOriginalValueVariable( d->size );
    d->size = properties.valueAsDouble( QgsPalLayerSettings::Property::BufferSize, context.expressionContext(), d->size );
  }
 
  QVariant exprVal = properties.value( QgsPalLayerSettings::Property::BufferUnit, context.expressionContext() );
  if ( !QgsVariantUtils::isNull( exprVal ) )
  {
    const QString units = exprVal.toString();
    if ( !units.isEmpty() )
    {
      bool ok;
      const Qgis::RenderUnit res = QgsUnitTypes::decodeRenderUnit( units, &ok );
      if ( ok )
        d->sizeUnit = res;
    }
  }
 
  if ( properties.isActive( QgsPalLayerSettings::Property::BufferOpacity ) )
  {
    context.expressionContext().setOriginalValueVariable( d->opacity * 100 );
    const QVariant val = properties.value( QgsPalLayerSettings::Property::BufferOpacity, context.expressionContext(), d->opacity * 100 );
    if ( !QgsVariantUtils::isNull( val ) )
    {
      d->opacity = val.toDouble() / 100.0;
    }
  }
 
  if ( properties.isActive( QgsPalLayerSettings::Property::BufferColor ) )
  {
    context.expressionContext().setOriginalValueVariable( QgsSymbolLayerUtils::encodeColor( d->color ) );
    d->color = properties.valueAsColor( QgsPalLayerSettings::Property::BufferColor, context.expressionContext(), d->color );
  }
 
  if ( properties.isActive( QgsPalLayerSettings::Property::BufferBlendMode ) )
  {
    exprVal = properties.value( QgsPalLayerSettings::Property::BufferBlendMode, context.expressionContext() );
    const QString blendstr = exprVal.toString().trimmed();
    if ( !blendstr.isEmpty() )
      d->blendMode = QgsSymbolLayerUtils::decodeBlendMode( blendstr );
  }
 
  if ( properties.isActive( QgsPalLayerSettings::Property::BufferJoinStyle ) )
  {
    exprVal = properties.value( QgsPalLayerSettings::Property::BufferJoinStyle, context.expressionContext() );
    const QString joinstr = exprVal.toString().trimmed();
    if ( !joinstr.isEmpty() )
    {
      d->joinStyle = QgsSymbolLayerUtils::decodePenJoinStyle( joinstr );
    }
  }
}
 
QSet<QString> QgsTextBufferSettings::referencedFields( const QgsRenderContext & ) const
{
  return QSet< QString >(); // nothing for now
}
 
void QgsTextBufferSettings::readFromLayer( QgsVectorLayer *layer )
{
  // text buffer
  const double bufSize = layer->customProperty( u"labeling/bufferSize"_s, QVariant( 0.0 ) ).toDouble();
 
  // fix for buffer being keyed off of just its size in the past (<2.0)
  const QVariant drawBuffer = layer->customProperty( u"labeling/bufferDraw"_s, QVariant() );
  if ( drawBuffer.isValid() )
  {
    d->enabled = drawBuffer.toBool();
    d->size = bufSize;
  }
  else if ( bufSize != 0.0 )
  {
    d->enabled = true;
    d->size = bufSize;
  }
  else
  {
    // keep bufferSize at new 1.0 default
    d->enabled = false;
  }
 
  if ( layer->customProperty( u"labeling/bufferSizeUnits"_s ).toString().isEmpty() )
  {
    const bool bufferSizeInMapUnits = layer->customProperty( u"labeling/bufferSizeInMapUnits"_s ).toBool();
    d->sizeUnit = bufferSizeInMapUnits ? Qgis::RenderUnit::MapUnits : Qgis::RenderUnit::Millimeters;
  }
  else
  {
    d->sizeUnit = QgsUnitTypes::decodeRenderUnit( layer->customProperty( u"labeling/bufferSizeUnits"_s ).toString() );
  }
 
  if ( layer->customProperty( u"labeling/bufferSizeMapUnitScale"_s ).toString().isEmpty() )
  {
    //fallback to older property
    const double oldMin = layer->customProperty( u"labeling/bufferSizeMapUnitMinScale"_s, 0.0 ).toDouble();
    d->sizeMapUnitScale.minScale = oldMin != 0 ? 1.0 / oldMin : 0;
    const double oldMax = layer->customProperty( u"labeling/bufferSizeMapUnitMaxScale"_s, 0.0 ).toDouble();
    d->sizeMapUnitScale.maxScale = oldMax != 0 ? 1.0 / oldMax : 0;
  }
  else
  {
    d->sizeMapUnitScale = QgsSymbolLayerUtils::decodeMapUnitScale( layer->customProperty( u"labeling/bufferSizeMapUnitScale"_s ).toString() );
  }
  d->color = QgsTextRendererUtils::readColor( layer, u"labeling/bufferColor"_s, Qt::white, false );
  if ( layer->customProperty( u"labeling/bufferOpacity"_s ).toString().isEmpty() )
  {
    d->opacity = ( 1 - layer->customProperty( u"labeling/bufferTransp"_s ).toInt() / 100.0 ); //0 -100
  }
  else
  {
    d->opacity = ( layer->customProperty( u"labeling/bufferOpacity"_s ).toDouble() );
  }
  d->blendMode = QgsPainting::getCompositionMode(
                   static_cast< Qgis::BlendMode >( layer->customProperty( u"labeling/bufferBlendMode"_s, QVariant( static_cast< int >( Qgis::BlendMode::Normal ) ) ).toUInt() ) );
  d->joinStyle = static_cast< Qt::PenJoinStyle >( layer->customProperty( u"labeling/bufferJoinStyle"_s, QVariant( Qt::RoundJoin ) ).toUInt() );
 
  d->fillBufferInterior = !layer->customProperty( u"labeling/bufferNoFill"_s, QVariant( false ) ).toBool();
 
  if ( layer->customProperty( u"labeling/bufferEffect"_s ).isValid() )
  {
    QDomDocument doc( u"effect"_s );
    doc.setContent( layer->customProperty( u"labeling/bufferEffect"_s ).toString() );
    const QDomElement effectElem = doc.firstChildElement( u"effect"_s ).firstChildElement( u"effect"_s );
    setPaintEffect( QgsApplication::paintEffectRegistry()->createEffect( effectElem ) );
  }
  else
    setPaintEffect( nullptr );
}
 
void QgsTextBufferSettings::readXml( const QDomElement &elem )
{
  const QDomElement textBufferElem = elem.firstChildElement( u"text-buffer"_s );
  const double bufSize = textBufferElem.attribute( u"bufferSize"_s, u"0"_s ).toDouble();
 
  // fix for buffer being keyed off of just its size in the past (<2.0)
  const QVariant drawBuffer = textBufferElem.attribute( u"bufferDraw"_s );
  if ( drawBuffer.isValid() )
  {
    d->enabled = drawBuffer.toBool();
    d->size = bufSize;
  }
  else if ( bufSize != 0.0 )
  {
    d->enabled = true;
    d->size = bufSize;
  }
  else
  {
    // keep bufferSize at new 1.0 default
    d->enabled = false;
  }
 
  if ( !textBufferElem.hasAttribute( u"bufferSizeUnits"_s ) )
  {
    const bool bufferSizeInMapUnits = textBufferElem.attribute( u"bufferSizeInMapUnits"_s ).toInt();
    d->sizeUnit = bufferSizeInMapUnits ? Qgis::RenderUnit::MapUnits : Qgis::RenderUnit::Millimeters;
  }
  else
  {
    d->sizeUnit = QgsUnitTypes::decodeRenderUnit( textBufferElem.attribute( u"bufferSizeUnits"_s ) );
  }
 
  if ( !textBufferElem.hasAttribute( u"bufferSizeMapUnitScale"_s ) )
  {
    //fallback to older property
    const double oldMin = textBufferElem.attribute( u"bufferSizeMapUnitMinScale"_s, u"0"_s ).toDouble();
    d->sizeMapUnitScale.minScale = oldMin != 0 ? 1.0 / oldMin : 0;
    const double oldMax = textBufferElem.attribute( u"bufferSizeMapUnitMaxScale"_s, u"0"_s ).toDouble();
    d->sizeMapUnitScale.maxScale = oldMax != 0 ? 1.0 / oldMax : 0;
  }
  else
  {
    d->sizeMapUnitScale = QgsSymbolLayerUtils::decodeMapUnitScale( textBufferElem.attribute( u"bufferSizeMapUnitScale"_s ) );
  }
  d->color = QgsColorUtils::colorFromString( textBufferElem.attribute( u"bufferColor"_s, QgsColorUtils::colorToString( Qt::white ) ) );
 
  if ( !textBufferElem.hasAttribute( u"bufferOpacity"_s ) )
  {
    d->opacity = ( 1 - textBufferElem.attribute( u"bufferTransp"_s ).toInt() / 100.0 ); //0 -100
  }
  else
  {
    d->opacity = ( textBufferElem.attribute( u"bufferOpacity"_s ).toDouble() );
  }
 
  d->blendMode = QgsPainting::getCompositionMode(
                   static_cast< Qgis::BlendMode >( textBufferElem.attribute( u"bufferBlendMode"_s, QString::number( static_cast< int >( Qgis::BlendMode::Normal ) ) ).toUInt() ) );
  d->joinStyle = static_cast< Qt::PenJoinStyle >( textBufferElem.attribute( u"bufferJoinStyle"_s, QString::number( Qt::RoundJoin ) ).toUInt() );
  d->fillBufferInterior = !textBufferElem.attribute( u"bufferNoFill"_s, u"0"_s ).toInt();
  const QDomElement effectElem = textBufferElem.firstChildElement( u"effect"_s );
  if ( !effectElem.isNull() )
    setPaintEffect( QgsApplication::paintEffectRegistry()->createEffect( effectElem ) );
  else
    setPaintEffect( nullptr );
}
 
QDomElement QgsTextBufferSettings::writeXml( QDomDocument &doc ) const
{
  // text buffer
  QDomElement textBufferElem = doc.createElement( u"text-buffer"_s );
  textBufferElem.setAttribute( u"bufferDraw"_s, d->enabled );
  textBufferElem.setAttribute( u"bufferSize"_s, d->size );
  textBufferElem.setAttribute( u"bufferSizeUnits"_s, QgsUnitTypes::encodeUnit( d->sizeUnit ) );
  textBufferElem.setAttribute( u"bufferSizeMapUnitScale"_s, QgsSymbolLayerUtils::encodeMapUnitScale( d->sizeMapUnitScale ) );
  textBufferElem.setAttribute( u"bufferColor"_s, QgsColorUtils::colorToString( d->color ) );
  textBufferElem.setAttribute( u"bufferNoFill"_s, !d->fillBufferInterior );
  textBufferElem.setAttribute( u"bufferOpacity"_s, d->opacity );
  textBufferElem.setAttribute( u"bufferJoinStyle"_s, static_cast< unsigned int >( d->joinStyle ) );
  textBufferElem.setAttribute( u"bufferBlendMode"_s, static_cast< int >( QgsPainting::getBlendModeEnum( d->blendMode ) ) );
  if ( d->paintEffect && !QgsPaintEffectRegistry::isDefaultStack( d->paintEffect.get() ) )
    d->paintEffect->saveProperties( doc, textBufferElem );
  return textBufferElem;
}