api/2.18/qgspainteffectwidget_8cpp_source.html

 /***************************************************************************
     qgspainteffectwidget.cpp
     ------------------------
     begin                : January 2015
     copyright            : (C) 2015 by Nyall Dawson
     email                : nyall dot dawson at gmail.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 "qgspainteffectwidget.h"
 #include "qgslogger.h"
 #include "qgspainteffect.h"
 #include "qgsshadoweffect.h"
 #include "qgsblureffect.h"
 #include "qgsgloweffect.h"
 #include "qgstransformeffect.h"
 #include "qgscoloreffect.h"
 #include "qgsstylev2.h"
 #include "qgsvectorcolorrampv2.h"

 //
 // draw source
 //

 QgsDrawSourceWidget::QgsDrawSourceWidget( QWidget *parent )
     : QgsPaintEffectWidget( parent )
     , mEffect( nullptr )
 {
   setupUi( this );
   initGui();
 }


 void QgsDrawSourceWidget::setPaintEffect( QgsPaintEffect *effect )
 {
   if ( !effect || effect->type() != "drawSource" )
     return;

   mEffect = static_cast<QgsDrawSourceEffect*>( effect );
   initGui();
 }

 void QgsDrawSourceWidget::initGui()
 {
   if ( !mEffect )
   {
     return;
   }

   blockSignals( true );

   mTransparencySpnBx->setValue( mEffect->transparency() * 100.0 );
   mTransparencySlider->setValue( mEffect->transparency() * 1000.0 );
   mBlendCmbBx->setBlendMode( mEffect->blendMode() );
   mDrawModeComboBox->setDrawMode( mEffect->drawMode() );

   blockSignals( false );
 }

 void QgsDrawSourceWidget::blockSignals( const bool block )
 {
   mTransparencySlider->blockSignals( block );
   mTransparencySpnBx->blockSignals( block );
   mBlendCmbBx->blockSignals( block );
   mDrawModeComboBox->blockSignals( block );
 }

 void QgsDrawSourceWidget::on_mTransparencySpnBx_valueChanged( double value )
 {
   if ( !mEffect )
     return;

   mTransparencySlider->blockSignals( true );
   mTransparencySlider->setValue( value * 10.0 );
   mTransparencySlider->blockSignals( false );

   mEffect->setTransparency( value / 100.0 );
   emit changed();
 }

 void QgsDrawSourceWidget::on_mDrawModeComboBox_currentIndexChanged( int index )
 {
   Q_UNUSED( index );

   if ( !mEffect )
     return;

   mEffect->setDrawMode( mDrawModeComboBox->drawMode() );
   emit changed();
 }

 void QgsDrawSourceWidget::on_mBlendCmbBx_currentIndexChanged( int index )
 {
   Q_UNUSED( index );

   if ( !mEffect )
     return;

   mEffect->setBlendMode( mBlendCmbBx->blendMode() );
   emit changed();
 }

 void QgsDrawSourceWidget::on_mTransparencySlider_valueChanged( int value )
 {
   mTransparencySpnBx->setValue( value / 10.0 );
 }


 //
 // blur
 //

 QgsBlurWidget::QgsBlurWidget( QWidget *parent )
     : QgsPaintEffectWidget( parent )
     , mEffect( nullptr )
 {
   setupUi( this );

   mBlurTypeCombo->addItem( tr( "Stack blur (fast)" ), QgsBlurEffect::StackBlur );
   mBlurTypeCombo->addItem( tr( "Gaussian blur (quality)" ), QgsBlurEffect::GaussianBlur );

   initGui();
 }


 void QgsBlurWidget::setPaintEffect( QgsPaintEffect *effect )
 {
   if ( !effect || effect->type() != "blur" )
     return;

   mEffect = static_cast<QgsBlurEffect*>( effect );
   initGui();
 }

 void QgsBlurWidget::initGui()
 {
   if ( !mEffect )
   {
     return;
   }

   blockSignals( true );

   mBlurTypeCombo->setCurrentIndex( mBlurTypeCombo->findData( mEffect->blurMethod() ) );
   mBlurStrengthSpnBx->setValue( mEffect->blurLevel() );
   mTransparencySpnBx->setValue( mEffect->transparency() * 100.0 );
   mTransparencySlider->setValue( mEffect->transparency() * 1000.0 );
   mBlendCmbBx->setBlendMode( mEffect->blendMode() );
   mDrawModeComboBox->setDrawMode( mEffect->drawMode() );

   blockSignals( false );
 }

 void QgsBlurWidget::blockSignals( const bool block )
 {
   mBlurTypeCombo->blockSignals( block );
   mBlurStrengthSpnBx->blockSignals( block );
   mTransparencySlider->blockSignals( block );
   mTransparencySpnBx->blockSignals( block );
   mBlendCmbBx->blockSignals( block );
   mDrawModeComboBox->blockSignals( block );
 }

 void QgsBlurWidget::on_mBlurTypeCombo_currentIndexChanged( int index )
 {
   if ( !mEffect )
     return;

   QgsBlurEffect::BlurMethod method = ( QgsBlurEffect::BlurMethod ) mBlurTypeCombo->itemData( index ).toInt();
   mEffect->setBlurMethod( method );

   //also update max radius
   switch ( method )
   {
     case QgsBlurEffect::StackBlur:
       mBlurStrengthSpnBx->setMaximum( 16 );
       break;
     case QgsBlurEffect::GaussianBlur:
       mBlurStrengthSpnBx->setMaximum( 200 );
       break;
   }

   emit changed();
 }

 void QgsBlurWidget::on_mBlurStrengthSpnBx_valueChanged( int value )
 {
   if ( !mEffect )
     return;

   mEffect->setBlurLevel( value );
   emit changed();
 }

 void QgsBlurWidget::on_mTransparencySpnBx_valueChanged( double value )
 {
   if ( !mEffect )
     return;

   mTransparencySlider->blockSignals( true );
   mTransparencySlider->setValue( value * 10.0 );
   mTransparencySlider->blockSignals( false );

   mEffect->setTransparency( value / 100.0 );
   emit changed();
 }

 void QgsBlurWidget::on_mDrawModeComboBox_currentIndexChanged( int index )
 {
   Q_UNUSED( index );

   if ( !mEffect )
     return;

   mEffect->setDrawMode( mDrawModeComboBox->drawMode() );
   emit changed();
 }

 void QgsBlurWidget::on_mBlendCmbBx_currentIndexChanged( int index )
 {
   Q_UNUSED( index );

   if ( !mEffect )
     return;

   mEffect->setBlendMode( mBlendCmbBx->blendMode() );
   emit changed();
 }

 void QgsBlurWidget::on_mTransparencySlider_valueChanged( int value )
 {
   mTransparencySpnBx->setValue( value / 10.0 );
 }


 //
 // Drop Shadow
 //

 QgsShadowEffectWidget::QgsShadowEffectWidget( QWidget *parent )
     : QgsPaintEffectWidget( parent )
     , mEffect( nullptr )
 {
   setupUi( this );

   mShadowColorBtn->setAllowAlpha( false );
   mShadowColorBtn->setColorDialogTitle( tr( "Select shadow color" ) );
   mShadowColorBtn->setContext( "symbology" );

   mOffsetUnitWidget->setUnits( QgsSymbolV2::OutputUnitList() << QgsSymbolV2::MM << QgsSymbolV2::Pixel << QgsSymbolV2::MapUnit );

   initGui();
 }

 void QgsShadowEffectWidget::setPaintEffect( QgsPaintEffect *effect )
 {
   if ( !effect || ( effect->type() != "dropShadow" && effect->type() != "innerShadow" ) )
     return;

   mEffect = static_cast<QgsShadowEffect*>( effect );
   initGui();
 }

 void QgsShadowEffectWidget::initGui()
 {
   if ( !mEffect )
   {
     return;
   }

   blockSignals( true );

   mShadowOffsetAngleSpnBx->setValue( mEffect->offsetAngle() );
   mShadowOffsetAngleDial->setValue( mEffect->offsetAngle() );
   mShadowOffsetSpnBx->setValue( mEffect->offsetDistance() );
   mOffsetUnitWidget->setUnit( mEffect->offsetUnit() );
   mOffsetUnitWidget->setMapUnitScale( mEffect->offsetMapUnitScale() );
   mShadowRadiuSpnBx->setValue( mEffect->blurLevel() );
   mShadowTranspSpnBx->setValue( mEffect->transparency() * 100.0 );
   mShadowTranspSlider->setValue( mEffect->transparency() * 1000.0 );
   mShadowColorBtn->setColor( mEffect->color() );
   mShadowBlendCmbBx->setBlendMode( mEffect->blendMode() );
   mDrawModeComboBox->setDrawMode( mEffect->drawMode() );

   blockSignals( false );
 }

 void QgsShadowEffectWidget::blockSignals( const bool block )
 {
   mShadowOffsetAngleSpnBx->blockSignals( block );
   mShadowOffsetAngleDial->blockSignals( block );
   mShadowOffsetSpnBx->blockSignals( block );
   mOffsetUnitWidget->blockSignals( block );
   mShadowRadiuSpnBx->blockSignals( block );
   mShadowTranspSpnBx->blockSignals( block );
   mShadowColorBtn->blockSignals( block );
   mShadowBlendCmbBx->blockSignals( block );
   mShadowTranspSlider->blockSignals( block );
   mDrawModeComboBox->blockSignals( block );
 }

 void QgsShadowEffectWidget::on_mShadowOffsetAngleSpnBx_valueChanged( int value )
 {
   mShadowOffsetAngleDial->blockSignals( true );
   mShadowOffsetAngleDial->setValue( value );
   mShadowOffsetAngleDial->blockSignals( false );

   if ( !mEffect )
     return;

   mEffect->setOffsetAngle( value );
   emit changed();
 }

 void QgsShadowEffectWidget::on_mShadowOffsetAngleDial_valueChanged( int value )
 {
   mShadowOffsetAngleSpnBx->setValue( value );
 }

 void QgsShadowEffectWidget::on_mShadowOffsetSpnBx_valueChanged( double value )
 {
   if ( !mEffect )
     return;

   mEffect->setOffsetDistance( value );
   emit changed();
 }

 void QgsShadowEffectWidget::on_mOffsetUnitWidget_changed()
 {
   if ( !mEffect )
   {
     return;
   }

   mEffect->setOffsetUnit( mOffsetUnitWidget->unit() );
   mEffect->setOffsetMapUnitScale( mOffsetUnitWidget->getMapUnitScale() );
   emit changed();
 }

 void QgsShadowEffectWidget::on_mShadowTranspSpnBx_valueChanged( double value )
 {
   if ( !mEffect )
     return;

   mShadowTranspSlider->blockSignals( true );
   mShadowTranspSlider->setValue( value * 10.0 );
   mShadowTranspSlider->blockSignals( false );

   mEffect->setTransparency( value / 100.0 );
   emit changed();
 }

 void QgsShadowEffectWidget::on_mShadowColorBtn_colorChanged( const QColor &color )
 {
   if ( !mEffect )
     return;

   mEffect->setColor( color );
   emit changed();
 }

 void QgsShadowEffectWidget::on_mShadowRadiuSpnBx_valueChanged( int value )
 {
   if ( !mEffect )
     return;

   mEffect->setBlurLevel( value );
   emit changed();
 }

 void QgsShadowEffectWidget::on_mShadowTranspSlider_valueChanged( int value )
 {
   mShadowTranspSpnBx->setValue( value / 10.0 );
 }

 void QgsShadowEffectWidget::on_mDrawModeComboBox_currentIndexChanged( int index )
 {
   Q_UNUSED( index );

   if ( !mEffect )
     return;

   mEffect->setDrawMode( mDrawModeComboBox->drawMode() );
   emit changed();
 }

 void QgsShadowEffectWidget::on_mShadowBlendCmbBx_currentIndexChanged( int index )
 {
   Q_UNUSED( index );

   if ( !mEffect )
     return;

   mEffect->setBlendMode( mShadowBlendCmbBx->blendMode() );
   emit changed();
 }


 //
 // glow
 //

 QgsGlowWidget::QgsGlowWidget( QWidget *parent )
     : QgsPaintEffectWidget( parent )
     , mEffect( nullptr )
 {
   setupUi( this );

   mColorBtn->setAllowAlpha( false );
   mColorBtn->setColorDialogTitle( tr( "Select glow color" ) );
   mColorBtn->setContext( "symbology" );

   mSpreadUnitWidget->setUnits( QgsSymbolV2::OutputUnitList() << QgsSymbolV2::MM << QgsSymbolV2::Pixel << QgsSymbolV2::MapUnit );

   mRampComboBox->populate( QgsStyleV2::defaultStyle() );
   mRampComboBox->setShowGradientOnly( true );
   connect( mRampComboBox, SIGNAL( currentIndexChanged( int ) ), this, SLOT( applyColorRamp() ) );
   connect( mRampComboBox, SIGNAL( sourceRampEdited() ), this, SLOT( applyColorRamp() ) );
   connect( mButtonEditRamp, SIGNAL( clicked() ), mRampComboBox, SLOT( editSourceRamp() ) );

   connect( radioSingleColor, SIGNAL( toggled( bool ) ), this, SLOT( colorModeChanged() ) );

   initGui();
 }

 void QgsGlowWidget::setPaintEffect( QgsPaintEffect *effect )
 {
   if ( !effect || ( effect->type() != "outerGlow" && effect->type() != "innerGlow" ) )
     return;

   mEffect = static_cast<QgsGlowEffect*>( effect );
   initGui();
 }

 void QgsGlowWidget::initGui()
 {
   if ( !mEffect )
   {
     return;
   }

   blockSignals( true );

   mSpreadSpnBx->setValue( mEffect->spread() );
   mSpreadUnitWidget->setUnit( mEffect->spreadUnit() );
   mSpreadUnitWidget->setMapUnitScale( mEffect->spreadMapUnitScale() );
   mBlurRadiusSpnBx->setValue( mEffect->blurLevel() );
   mTranspSpnBx->setValue( mEffect->transparency() * 100.0 );
   mTranspSlider->setValue( mEffect->transparency() * 1000.0 );
   mColorBtn->setColor( mEffect->color() );
   mBlendCmbBx->setBlendMode( mEffect->blendMode() );

   if ( mEffect->ramp() )
   {
     mRampComboBox->setSourceColorRamp( mEffect->ramp() );
   }

   radioSingleColor->setChecked( mEffect->colorType() == QgsGlowEffect::SingleColor );
   mColorBtn->setEnabled( mEffect->colorType() == QgsGlowEffect::SingleColor );
   radioColorRamp->setChecked( mEffect->colorType() == QgsGlowEffect::ColorRamp );
   mRampComboBox->setEnabled( mEffect->colorType() == QgsGlowEffect::ColorRamp );
   mButtonEditRamp->setEnabled( mEffect->colorType() == QgsGlowEffect::ColorRamp );
   mDrawModeComboBox->setDrawMode( mEffect->drawMode() );

   blockSignals( false );
 }

 void QgsGlowWidget::blockSignals( const bool block )
 {
   mSpreadSpnBx->blockSignals( block );
   mSpreadUnitWidget->blockSignals( block );
   mBlurRadiusSpnBx->blockSignals( block );
   mTranspSpnBx->blockSignals( block );
   mTranspSlider->blockSignals( block );
   mColorBtn->blockSignals( block );
   mBlendCmbBx->blockSignals( block );
   mRampComboBox->blockSignals( block );
   radioSingleColor->blockSignals( block );
   radioColorRamp->blockSignals( block );
   mDrawModeComboBox->blockSignals( block );
 }

 void QgsGlowWidget::colorModeChanged()
 {
   if ( !mEffect )
   {
     return;
   }

   if ( radioSingleColor->isChecked() )
   {
     mEffect->setColorType( QgsGlowEffect::SingleColor );
   }
   else
   {
     mEffect->setColorType( QgsGlowEffect::ColorRamp );
     mEffect->setRamp( mRampComboBox->currentColorRamp() );
   }
   emit changed();
 }

 void QgsGlowWidget::on_mSpreadSpnBx_valueChanged( double value )
 {
   if ( !mEffect )
     return;

   mEffect->setSpread( value );
   emit changed();
 }

 void QgsGlowWidget::on_mSpreadUnitWidget_changed()
 {
   if ( !mEffect )
   {
     return;
   }

   mEffect->setSpreadUnit( mSpreadUnitWidget->unit() );
   mEffect->setSpreadMapUnitScale( mSpreadUnitWidget->getMapUnitScale() );
   emit changed();
 }

 void QgsGlowWidget::on_mTranspSpnBx_valueChanged( double value )
 {
   if ( !mEffect )
     return;

   mTranspSlider->blockSignals( true );
   mTranspSlider->setValue( value * 10.0 );
   mTranspSlider->blockSignals( false );

   mEffect->setTransparency( value / 100.0 );
   emit changed();
 }

 void QgsGlowWidget::on_mColorBtn_colorChanged( const QColor &color )
 {
   if ( !mEffect )
     return;

   mEffect->setColor( color );
   emit changed();
 }

 void QgsGlowWidget::on_mBlurRadiusSpnBx_valueChanged( int value )
 {
   if ( !mEffect )
     return;

   mEffect->setBlurLevel( value );
   emit changed();
 }

 void QgsGlowWidget::on_mTranspSlider_valueChanged( int value )
 {
   mTranspSpnBx->setValue( value / 10.0 );
 }

 void QgsGlowWidget::on_mBlendCmbBx_currentIndexChanged( int index )
 {
   Q_UNUSED( index );

   if ( !mEffect )
     return;

   mEffect->setBlendMode( mBlendCmbBx->blendMode() );
   emit changed();
 }

 void QgsGlowWidget::on_mDrawModeComboBox_currentIndexChanged( int index )
 {
   Q_UNUSED( index );

   if ( !mEffect )
     return;

   mEffect->setDrawMode( mDrawModeComboBox->drawMode() );
   emit changed();
 }

 void QgsGlowWidget::applyColorRamp()
 {
   if ( !mEffect )
   {
     return;
   }

   QgsVectorColorRampV2* ramp = mRampComboBox->currentColorRamp();
   if ( !ramp )
     return;

   mEffect->setRamp( ramp );
   emit changed();
 }

 //
 // transform
 //

 QgsTransformWidget::QgsTransformWidget( QWidget *parent )
     : QgsPaintEffectWidget( parent )
     , mEffect( nullptr )
 {
   setupUi( this );

   mTranslateUnitWidget->setUnits( QgsSymbolV2::OutputUnitList() << QgsSymbolV2::MM << QgsSymbolV2::Pixel << QgsSymbolV2::MapUnit );
   mSpinTranslateX->setClearValue( 0 );
   mSpinTranslateY->setClearValue( 0 );
   mSpinShearX->setClearValue( 0 );
   mSpinShearY->setClearValue( 0 );
   mSpinScaleX->setClearValue( 100.0 );
   mSpinScaleY->setClearValue( 100.0 );

   initGui();
 }


 void QgsTransformWidget::setPaintEffect( QgsPaintEffect *effect )
 {
   if ( !effect || effect->type() != "transform" )
     return;

   mEffect = static_cast<QgsTransformEffect*>( effect );
   initGui();
 }

 void QgsTransformWidget::initGui()
 {
   if ( !mEffect )
   {
     return;
   }

   blockSignals( true );

   mReflectXCheckBox->setChecked( mEffect->reflectX() );
   mReflectYCheckBox->setChecked( mEffect->reflectY() );
   mDrawModeComboBox->setDrawMode( mEffect->drawMode() );
   mSpinTranslateX->setValue( mEffect->translateX() );
   mSpinTranslateY->setValue( mEffect->translateY() );
   mTranslateUnitWidget->setUnit( mEffect->translateUnit() );
   mTranslateUnitWidget->setMapUnitScale( mEffect->translateMapUnitScale() );
   mSpinShearX->setValue( mEffect->shearX() );
   mSpinShearY->setValue( mEffect->shearY() );
   mSpinScaleX->setValue( mEffect->scaleX() * 100.0 );
   mSpinScaleY->setValue( mEffect->scaleY() * 100.0 );
   mRotationSpinBox->setValue( mEffect->rotation() );

   blockSignals( false );
 }

 void QgsTransformWidget::blockSignals( const bool block )
 {
   mDrawModeComboBox->blockSignals( block );
   mTranslateUnitWidget->blockSignals( block );
   mSpinTranslateX->blockSignals( block );
   mSpinTranslateY->blockSignals( block );
   mReflectXCheckBox->blockSignals( block );
   mReflectYCheckBox->blockSignals( block );
   mSpinShearX->blockSignals( block );
   mSpinShearY->blockSignals( block );
   mSpinScaleX->blockSignals( block );
   mSpinScaleY->blockSignals( block );
   mRotationSpinBox->blockSignals( block );
 }


 void QgsTransformWidget::on_mDrawModeComboBox_currentIndexChanged( int index )
 {
   Q_UNUSED( index );

   if ( !mEffect )
     return;

   mEffect->setDrawMode( mDrawModeComboBox->drawMode() );
   emit changed();
 }

 void QgsTransformWidget::on_mSpinTranslateX_valueChanged( double value )
 {
   if ( !mEffect )
     return;

   mEffect->setTranslateX( value );
   emit changed();
 }

 void QgsTransformWidget::on_mSpinTranslateY_valueChanged( double value )
 {
   if ( !mEffect )
     return;

   mEffect->setTranslateY( value );
   emit changed();
 }

 void QgsTransformWidget::on_mTranslateUnitWidget_changed()
 {
   if ( !mEffect )
   {
     return;
   }

   mEffect->setTranslateUnit( mTranslateUnitWidget->unit() );
   mEffect->setTranslateMapUnitScale( mTranslateUnitWidget->getMapUnitScale() );
   emit changed();
 }

 void QgsTransformWidget::on_mReflectXCheckBox_stateChanged( int state )
 {
   if ( !mEffect )
     return;

   mEffect->setReflectX( state == Qt::Checked );
   emit changed();
 }

 void QgsTransformWidget::on_mReflectYCheckBox_stateChanged( int state )
 {
   if ( !mEffect )
     return;

   mEffect->setReflectY( state == Qt::Checked );
   emit changed();
 }

 void QgsTransformWidget::on_mSpinShearX_valueChanged( double value )
 {
   if ( !mEffect )
     return;

   mEffect->setShearX( value );
   emit changed();
 }

 void QgsTransformWidget::on_mSpinShearY_valueChanged( double value )
 {
   if ( !mEffect )
     return;

   mEffect->setShearY( value );
   emit changed();
 }

 void QgsTransformWidget::on_mSpinScaleX_valueChanged( double value )
 {
   if ( !mEffect )
     return;

   mEffect->setScaleX( value / 100.0 );
   emit changed();
 }

 void QgsTransformWidget::on_mSpinScaleY_valueChanged( double value )
 {
   if ( !mEffect )
     return;

   mEffect->setScaleY( value / 100.0 );
   emit changed();
 }

 void QgsTransformWidget::on_mRotationSpinBox_valueChanged( double value )
 {
   if ( !mEffect )
     return;

   mEffect->setRotation( value );
   emit changed();
 }


 //
 // color effect
 //

 QgsColorEffectWidget::QgsColorEffectWidget( QWidget *parent )
     : QgsPaintEffectWidget( parent )
     , mEffect( nullptr )
 {
   setupUi( this );

   mBrightnessSpinBox->setClearValue( 0 );
   mContrastSpinBox->setClearValue( 0 );
   mSaturationSpinBox->setClearValue( 0 );
   mColorizeColorButton->setAllowAlpha( false );

   mGrayscaleCombo->addItem( tr( "Off" ), QgsImageOperation::GrayscaleOff );
   mGrayscaleCombo->addItem( tr( "By lightness" ), QgsImageOperation::GrayscaleLightness );
   mGrayscaleCombo->addItem( tr( "By luminosity" ), QgsImageOperation::GrayscaleLuminosity );
   mGrayscaleCombo->addItem( tr( "By average" ), QgsImageOperation::GrayscaleAverage );

   initGui();
 }

 void QgsColorEffectWidget::setPaintEffect( QgsPaintEffect *effect )
 {
   if ( !effect || effect->type() != "color" )
     return;

   mEffect = static_cast<QgsColorEffect*>( effect );
   initGui();
 }

 void QgsColorEffectWidget::initGui()
 {
   if ( !mEffect )
   {
     return;
   }

   blockSignals( true );

   mSliderBrightness->setValue( mEffect->brightness() );
   mSliderContrast->setValue( mEffect->contrast() );
   mSliderSaturation->setValue(( mEffect->saturation() - 1.0 ) * 100.0 );
   mColorizeCheck->setChecked( mEffect->colorizeOn() );
   mSliderColorizeStrength->setValue( mEffect->colorizeStrength() );
   mColorizeColorButton->setColor( mEffect->colorizeColor() );
   int grayscaleIdx = mGrayscaleCombo->findData( QVariant(( int ) mEffect->grayscaleMode() ) );
   mGrayscaleCombo->setCurrentIndex( grayscaleIdx == -1 ? 0 : grayscaleIdx );
   mTranspSpnBx->setValue( mEffect->transparency() * 100.0 );
   mTranspSlider->setValue( mEffect->transparency() * 1000.0 );
   mBlendCmbBx->setBlendMode( mEffect->blendMode() );
   mDrawModeComboBox->setDrawMode( mEffect->drawMode() );
   enableColorizeControls( mEffect->colorizeOn() );

   blockSignals( false );
 }

 void QgsColorEffectWidget::blockSignals( const bool block )
 {
   mBrightnessSpinBox->blockSignals( block );
   mContrastSpinBox->blockSignals( block );
   mSaturationSpinBox->blockSignals( block );
   mColorizeStrengthSpinBox->blockSignals( block );
   mColorizeCheck->blockSignals( block );
   mColorizeColorButton->blockSignals( block );
   mGrayscaleCombo->blockSignals( block );
   mTranspSpnBx->blockSignals( block );
   mTranspSlider->blockSignals( block );
   mBlendCmbBx->blockSignals( block );
   mDrawModeComboBox->blockSignals( block );
 }

 void QgsColorEffectWidget::enableColorizeControls( const bool enable )
 {
   mSliderColorizeStrength->setEnabled( enable );
   mColorizeStrengthSpinBox->setEnabled( enable );
   mColorizeColorButton->setEnabled( enable );
 }

 void QgsColorEffectWidget::on_mTranspSpnBx_valueChanged( double value )
 {
   if ( !mEffect )
     return;

   mTranspSlider->blockSignals( true );
   mTranspSlider->setValue( value * 10.0 );
   mTranspSlider->blockSignals( false );

   mEffect->setTransparency( value / 100.0 );
   emit changed();
 }

 void QgsColorEffectWidget::on_mBlendCmbBx_currentIndexChanged( int index )
 {
   Q_UNUSED( index );

   if ( !mEffect )
     return;

   mEffect->setBlendMode( mBlendCmbBx->blendMode() );
   emit changed();
 }

 void QgsColorEffectWidget::on_mDrawModeComboBox_currentIndexChanged( int index )
 {
   Q_UNUSED( index );

   if ( !mEffect )
     return;

   mEffect->setDrawMode( mDrawModeComboBox->drawMode() );
   emit changed();
 }

 void QgsColorEffectWidget::on_mTranspSlider_valueChanged( int value )
 {
   mTranspSpnBx->setValue( value / 10.0 );
 }

 void QgsColorEffectWidget::on_mBrightnessSpinBox_valueChanged( int value )
 {
   if ( !mEffect )
     return;

   mEffect->setBrightness( value );
   emit changed();
 }

 void QgsColorEffectWidget::on_mContrastSpinBox_valueChanged( int value )
 {
   if ( !mEffect )
     return;

   mEffect->setContrast( value );
   emit changed();
 }

 void QgsColorEffectWidget::on_mSaturationSpinBox_valueChanged( int value )
 {
   if ( !mEffect )
     return;

   mEffect->setSaturation( value / 100.0 + 1 );
   emit changed();
 }

 void QgsColorEffectWidget::on_mColorizeStrengthSpinBox_valueChanged( int value )
 {
   if ( !mEffect )
     return;

   mEffect->setColorizeStrength( value );
   emit changed();
 }

 void QgsColorEffectWidget::on_mColorizeCheck_stateChanged( int state )
 {
   if ( !mEffect )
     return;

   mEffect->setColorizeOn( state == Qt::Checked );
   enableColorizeControls( state == Qt::Checked );
   emit changed();
 }

 void QgsColorEffectWidget::on_mColorizeColorButton_colorChanged( const QColor &color )
 {
   if ( !mEffect )
     return;

   mEffect->setColorizeColor( color );
   emit changed();
 }

 void QgsColorEffectWidget::on_mGrayscaleCombo_currentIndexChanged( int index )
 {
   Q_UNUSED( index );

   if ( !mEffect )
     return;

   mEffect->setGrayscaleMode(( QgsImageOperation::GrayscaleMode ) mGrayscaleCombo->itemData( mGrayscaleCombo->currentIndex() ).toInt() );
   emit changed();
 }
QgsTransformEffect::setShearY
void setShearY(const double shearY)
Sets the y axis shearing factor.
Definition: qgstransformeffect.h:183

index
static unsigned index
Definition: mersenne-twister.cpp:36

QgsGlowWidget::QgsGlowWidget
QgsGlowWidget(QWidget *parent=nullptr)
Definition: qgspainteffectwidget.cpp:412

QWidget

QgsShadowEffect::setOffsetDistance
void setOffsetDistance(const double distance)
Sets the distance for offsetting the shadow.
Definition: qgsshadoweffect.h:77

QgsTransformEffect::setShearX
void setShearX(const double shearX)
Sets the x axis shearing factor.
Definition: qgstransformeffect.h:169

QgsDrawSourceWidget::QgsDrawSourceWidget
QgsDrawSourceWidget(QWidget *parent=nullptr)
Definition: qgspainteffectwidget.cpp:32

QWidget::setupUi
void setupUi(QWidget *widget)

QgsBlurEffect::setBlurMethod
void setBlurMethod(const BlurMethod method)
Sets the blur method (algorithm) to use for performing the blur.
Definition: qgsblureffect.h:78

QgsShadowEffect::setOffsetAngle
void setOffsetAngle(const int angle)
Sets the angle for offsetting the shadow.
Definition: qgsshadoweffect.h:62

QgsTransformEffect::setTranslateUnit
void setTranslateUnit(const QgsSymbolV2::OutputUnit unit)
Sets the units used for the transform translation.
Definition: qgstransformeffect.h:96

QgsPaintEffectWidget
Base class for effect properties widgets.
Definition: qgspainteffectwidget.h:37

QgsTransformEffect::reflectX
bool reflectX() const
Returns whether transform will be reflected along the x-axis.
Definition: qgstransformeffect.h:204

QgsGlowEffect::setSpreadUnit
void setSpreadUnit(const QgsSymbolV2::OutputUnit unit)
Sets the units used for the glow spread distance.
Definition: qgsgloweffect.h:75

QgsImageOperation::GrayscaleLightness
Definition: qgsimageoperation.h:50

QgsColorEffect::setTransparency
void setTransparency(const double transparency)
Sets the transparency for the effect.
Definition: qgscoloreffect.h:169

QgsSymbolV2::Pixel
The output shall be in pixels.
Definition: qgssymbolv2.h:70

QgsColorEffect::setColorizeColor
void setColorizeColor(const QColor &colorizeColor)
Sets the color used for colorizing a picture.
Definition: qgscoloreffect.cpp:126

QgsShadowEffect::offsetDistance
double offsetDistance() const
Returns the distance used for offsetting the shadow.
Definition: qgsshadoweffect.h:85

QgsBlurEffect::transparency
double transparency() const
Returns the transparency for the effect.
Definition: qgsblureffect.h:98

QgsPaintEffect
Base class for visual effects which can be applied to QPicture drawings.
Definition: qgspainteffect.h:49

QgsPaintEffect::setDrawMode
void setDrawMode(const DrawMode drawMode)
Sets the draw mode for the effect.
Definition: qgspainteffect.cpp:69

QgsColorEffect::setColorizeStrength
void setColorizeStrength(int colorizeStrength)
Sets the strength for colorizing a picture.
Definition: qgscoloreffect.h:153

QgsImageOperation::GrayscaleOff
Definition: qgsimageoperation.h:53

QgsTransformEffect::shearY
double shearY() const
Returns the y axis shearing factor.
Definition: qgstransformeffect.h:190

QgsBlurEffect::GaussianBlur
Definition: qgsblureffect.h:41

QgsShadowEffect::setBlurLevel
void setBlurLevel(const int level)
Sets blur level (strength) for the shadow.
Definition: qgsshadoweffect.h:48

QgsTransformEffect::scaleX
double scaleX() const
Returns the x axis scaling factor.
Definition: qgstransformeffect.h:137

QgsPaintEffect::drawMode
DrawMode drawMode() const
Returns the draw mode for the effect.
Definition: qgspainteffect.h:151

qgsvectorcolorrampv2.h

QgsGlowEffect::spreadUnit
QgsSymbolV2::OutputUnit spreadUnit() const
Returns the units used for the glow spread distance.
Definition: qgsgloweffect.h:83

QgsBlurEffect::setBlurLevel
void setBlurLevel(const int level)
Sets blur level (strength)
Definition: qgsblureffect.h:64

QgsShadowEffect::setOffsetUnit
void setOffsetUnit(const QgsSymbolV2::OutputUnit unit)
Sets the units used for the shadow offset distance.
Definition: qgsshadoweffect.h:93

QgsDrawSourceEffect::transparency
double transparency() const
Returns the transparency for the effect.
Definition: qgspainteffect.h:285

QObject::tr
QString tr(const char *sourceText, const char *disambiguation, int n)

QgsBlurEffect::blurMethod
BlurMethod blurMethod() const
Returns the blur method (algorithm) used for performing the blur.
Definition: qgsblureffect.h:84

QgsGlowEffect::setBlendMode
void setBlendMode(const QPainter::CompositionMode mode)
Sets the blend mode for the effect.
Definition: qgsgloweffect.h:169

QgsGlowEffect
Base class for paint effect which draw a glow inside or outside a picture.
Definition: qgsgloweffect.h:34

QgsTransformEffect::setTranslateY
void setTranslateY(const double translateY)
Sets the transform y translation.
Definition: qgstransformeffect.h:78

qgsblureffect.h

QgsColorEffectWidget::setPaintEffect
virtual void setPaintEffect(QgsPaintEffect *effect) override
Sets the paint effect to modify with the widget.
Definition: qgspainteffectwidget.cpp:805

QgsDrawSourceEffect::setTransparency
void setTransparency(const double transparency)
Sets the transparency for the effect.
Definition: qgspainteffect.h:278

QgsImageOperation::GrayscaleLuminosity
Definition: qgsimageoperation.h:51

QgsGlowEffect::setTransparency
void setTransparency(const double transparency)
Sets the transparency for the effect.
Definition: qgsgloweffect.h:121

QgsImageOperation::GrayscaleAverage
Definition: qgsimageoperation.h:52

QgsColorEffect::setGrayscaleMode
void setGrayscaleMode(QgsImageOperation::GrayscaleMode grayscaleMode)
Sets whether the effect should convert a picture to grayscale.
Definition: qgscoloreffect.h:104

QgsColorEffect::setBrightness
void setBrightness(int brightness)
Sets the brightness modification for the effect.
Definition: qgscoloreffect.h:58

QgsBlurEffect::StackBlur
Definition: qgsblureffect.h:40

QgsBlurEffect::BlurMethod
BlurMethod
Available blur methods (algorithms)
Definition: qgsblureffect.h:38

QgsGlowEffect::setSpreadMapUnitScale
void setSpreadMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale used for the spread distance.
Definition: qgsgloweffect.h:91

QgsGlowEffect::setBlurLevel
void setBlurLevel(const int level)
Sets blur level (strength) for the glow.
Definition: qgsgloweffect.h:107

QgsShadowEffect::blendMode
QPainter::CompositionMode blendMode() const
Returns the blend mode for the effect.
Definition: qgsshadoweffect.h:157

QgsSymbolV2::MM
The output shall be in millimeters.
Definition: qgssymbolv2.h:67

QgsTransformEffect::setScaleY
void setScaleY(const double scaleY)
Sets the y axis scaling factor.
Definition: qgstransformeffect.h:143

QgsShadowEffect::color
QColor color() const
Returns the color used for the shadow.
Definition: qgsshadoweffect.h:129

QgsDrawSourceEffect::setBlendMode
void setBlendMode(const QPainter::CompositionMode mode)
Sets the blend mode for the effect.
Definition: qgspainteffect.h:292

QgsPaintEffectWidget::changed
void changed()
Emitted when properties of the effect are changed through the widget.

QgsTransformEffect::setTranslateMapUnitScale
void setTranslateMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale used for the transform translation.
Definition: qgstransformeffect.h:114

QgsPaintEffect::type
virtual QString type() const =0
Returns the effect type.

QgsStyleV2::defaultStyle
static QgsStyleV2 * defaultStyle()
return default application-wide style
Definition: qgsstylev2.cpp:51

QgsGlowEffect::setColorType
void setColorType(GlowColorType colorType)
Sets the color mode to use for the glow.
Definition: qgsgloweffect.h:186

QgsBlurEffect::blurLevel
int blurLevel() const
Returns the blur level (strength)
Definition: qgsblureffect.h:72

QgsTransformEffect::translateX
double translateX() const
Returns the transform x translation.
Definition: qgstransformeffect.h:69

QgsGlowEffect::spreadMapUnitScale
const QgsMapUnitScale & spreadMapUnitScale() const
Returns the map unit scale used for the spread distance.
Definition: qgsgloweffect.h:99

QgsBlurWidget::QgsBlurWidget
QgsBlurWidget(QWidget *parent=nullptr)
Definition: qgspainteffectwidget.cpp:120

QgsTransformEffect::scaleY
double scaleY() const
Returns the y axis scaling factor.
Definition: qgstransformeffect.h:150

QgsSymbolV2::MapUnit
The output shall be in map unitx.
Definition: qgssymbolv2.h:68

QgsTransformEffect::translateUnit
QgsSymbolV2::OutputUnit translateUnit() const
Returns the units used for the transform translation.
Definition: qgstransformeffect.h:105

QgsTransformEffect::reflectY
bool reflectY() const
Returns whether transform will be reflected along the y-axis.
Definition: qgstransformeffect.h:218

QgsColorEffect::setColorizeOn
void setColorizeOn(bool colorizeOn)
Sets whether the effect should colorize a picture.
Definition: qgscoloreffect.h:118

qgspainteffect.h

QgsColorEffect::setContrast
void setContrast(int contrast)
Sets the contrast modification for the effect.
Definition: qgscoloreffect.h:74

QList

QColor

QgsColorEffectWidget::QgsColorEffectWidget
QgsColorEffectWidget(QWidget *parent=nullptr)
Definition: qgspainteffectwidget.cpp:786

qgscoloreffect.h

QgsGlowEffect::setSpread
void setSpread(const double spread)
Sets the spread distance for drawing the glow effect.
Definition: qgsgloweffect.h:59

QgsShadowEffectWidget::QgsShadowEffectWidget
QgsShadowEffectWidget(QWidget *parent=nullptr)
Definition: qgspainteffectwidget.cpp:247

QgsShadowEffect::blurLevel
int blurLevel() const
Returns the blur level (strength) for the shadow.
Definition: qgsshadoweffect.h:55

QgsShadowEffect::transparency
double transparency() const
Returns the transparency for the effect.
Definition: qgsshadoweffect.h:143

QgsTransformEffect::rotation
double rotation() const
Returns the transform rotation.
Definition: qgstransformeffect.h:162

QgsBlurEffect
A paint effect which blurs a source picture, using a number of different blur methods.
Definition: qgsblureffect.h:32

qgspainteffectwidget.h

QgsGlowEffect::colorType
GlowColorType colorType() const
Returns the color mode used for the glow.
Definition: qgsgloweffect.h:195

QgsDrawSourceEffect::blendMode
QPainter::CompositionMode blendMode() const
Returns the blend mode for the effect.
Definition: qgspainteffect.h:299

qgsshadoweffect.h

QgsColorEffect::grayscaleMode
QgsImageOperation::GrayscaleMode grayscaleMode() const
Returns whether the effect will convert a picture to grayscale.
Definition: qgscoloreffect.h:110

QgsTransformEffect
A paint effect which applies transformations (such as move, scale and rotate) to a picture...
Definition: qgstransformeffect.h:34

QgsTransformWidget::setPaintEffect
virtual void setPaintEffect(QgsPaintEffect *effect) override
Sets the paint effect to modify with the widget.
Definition: qgspainteffectwidget.cpp:627

QgsTransformEffect::shearX
double shearX() const
Returns the x axis shearing factor.
Definition: qgstransformeffect.h:176

QgsShadowEffect::setOffsetMapUnitScale
void setOffsetMapUnitScale(const QgsMapUnitScale &scale)
Sets the map unit scale used for the shadow offset distance.
Definition: qgsshadoweffect.h:109

QgsGlowEffect::setRamp
void setRamp(QgsVectorColorRampV2 *ramp)
Sets the color ramp for the glow.
Definition: qgsgloweffect.cpp:182

QgsGlowEffect::SingleColor
Definition: qgsgloweffect.h:42

QgsTransformEffect::setScaleX
void setScaleX(const double scaleX)
Sets the x axis scaling factor.
Definition: qgstransformeffect.h:130

QgsColorEffect::blendMode
QPainter::CompositionMode blendMode() const
Returns the blend mode for the effect.
Definition: qgscoloreffect.h:190

QgsColorEffect::setSaturation
void setSaturation(double saturation)
Sets the saturation modification for the effect.
Definition: qgscoloreffect.h:90

QgsDrawSourceWidget::setPaintEffect
virtual void setPaintEffect(QgsPaintEffect *effect) override
Sets the paint effect to modify with the widget.
Definition: qgspainteffectwidget.cpp:41

qgstransformeffect.h

QgsShadowEffectWidget::setPaintEffect
virtual void setPaintEffect(QgsPaintEffect *effect) override
Sets the paint effect to modify with the widget.
Definition: qgspainteffectwidget.cpp:262

QgsGlowEffect::ColorRamp
Definition: qgsgloweffect.h:43

QgsGlowEffect::spread
double spread() const
Returns the spread distance used for drawing the glow effect.
Definition: qgsgloweffect.h:67

QgsColorEffect::colorizeStrength
int colorizeStrength() const
Returns the strength used for colorizing a picture.
Definition: qgscoloreffect.h:162

QgsGlowEffect::blendMode
QPainter::CompositionMode blendMode() const
Returns the blend mode for the effect.
Definition: qgsgloweffect.h:176

QgsShadowEffect::setBlendMode
void setBlendMode(const QPainter::CompositionMode mode)
Sets the blend mode for the effect.
Definition: qgsshadoweffect.h:150

QgsColorEffect::saturation
double saturation() const
Returns the saturation modification for the effect.
Definition: qgscoloreffect.h:98

qgsgloweffect.h

QgsBlurEffect::blendMode
QPainter::CompositionMode blendMode() const
Returns the blend mode for the effect.
Definition: qgsblureffect.h:112

QgsTransformEffect::setTranslateX
void setTranslateX(const double translateX)
Sets the transform x translation.
Definition: qgstransformeffect.h:60

QgsColorEffect
A paint effect which alters the colors (eg brightness, contrast) in a source picture.
Definition: qgscoloreffect.h:33

QgsTransformEffect::setReflectY
void setReflectY(const bool reflectY)
Sets whether to reflect along the y-axis.
Definition: qgstransformeffect.h:211

QgsTransformWidget::QgsTransformWidget
QgsTransformWidget(QWidget *parent=nullptr)
Definition: qgspainteffectwidget.cpp:609

qgsstylev2.h

QgsShadowEffect
Base class for paint effects which offset, blurred shadows.
Definition: qgsshadoweffect.h:32

QgsTransformEffect::translateMapUnitScale
const QgsMapUnitScale & translateMapUnitScale() const
Returns the map unit scale used for the transform translation.
Definition: qgstransformeffect.h:123

QgsTransformEffect::setRotation
void setRotation(const double rotation)
Sets the transform rotation.
Definition: qgstransformeffect.h:156

QgsGlowWidget::setPaintEffect
virtual void setPaintEffect(QgsPaintEffect *effect) override
Sets the paint effect to modify with the widget.
Definition: qgspainteffectwidget.cpp:435

QgsBlurWidget::setPaintEffect
virtual void setPaintEffect(QgsPaintEffect *effect) override
Sets the paint effect to modify with the widget.
Definition: qgspainteffectwidget.cpp:133

QgsShadowEffect::offsetUnit
QgsSymbolV2::OutputUnit offsetUnit() const
Returns the units used for the shadow offset distance.
Definition: qgsshadoweffect.h:101

QgsColorEffect::setBlendMode
void setBlendMode(const QPainter::CompositionMode mode)
Sets the blend mode for the effect.
Definition: qgscoloreffect.h:183

QgsTransformEffect::setReflectX
void setReflectX(const bool reflectX)
Sets whether to reflect along the x-axis.
Definition: qgstransformeffect.h:197

QgsBlurEffect::setBlendMode
void setBlendMode(const QPainter::CompositionMode mode)
Sets the blend mode for the effect.
Definition: qgsblureffect.h:105

QgsColorEffect::transparency
double transparency() const
Returns the transparency for the effect.
Definition: qgscoloreffect.h:176

QgsDrawSourceEffect
A paint effect which draws the source picture with minor or no alterations.
Definition: qgspainteffect.h:255

QgsGlowEffect::transparency
double transparency() const
Returns the transparency for the effect.
Definition: qgsgloweffect.h:128

QgsImageOperation::GrayscaleMode
GrayscaleMode
Modes for converting a QImage to grayscale.
Definition: qgsimageoperation.h:48

QgsBlurEffect::setTransparency
void setTransparency(const double transparency)
Sets the transparency for the effect.
Definition: qgsblureffect.h:91

QgsColorEffect::colorizeOn
bool colorizeOn() const
Returns whether the effect will colorize a picture.
Definition: qgscoloreffect.h:126

QObject::connect
bool connect(const QObject *sender, const char *signal, const QObject *receiver, const char *method, Qt::ConnectionType type)

QObject::parent
QObject * parent() const

QgsColorEffect::contrast
int contrast() const
Returns the contrast modification for the effect.
Definition: qgscoloreffect.h:82

QgsVectorColorRampV2
Abstract base class for color ramps.
Definition: qgsvectorcolorrampv2.h:30

QgsShadowEffect::setColor
void setColor(const QColor &color)
Sets the color for the shadow.
Definition: qgsshadoweffect.h:123

QgsShadowEffect::offsetAngle
int offsetAngle() const
Returns the angle used for offsetting the shadow.
Definition: qgsshadoweffect.h:69

QgsGlowEffect::setColor
void setColor(const QColor &color)
Sets the color for the glow.
Definition: qgsgloweffect.h:137

QgsShadowEffect::setTransparency
void setTransparency(const double transparency)
Sets the transparency for the effect.
Definition: qgsshadoweffect.h:136

QgsGlowEffect::ramp
QgsVectorColorRampV2 * ramp() const
Returns the color ramp used for the glow.
Definition: qgsgloweffect.h:162

QgsTransformEffect::translateY
double translateY() const
Returns the transform y translation.
Definition: qgstransformeffect.h:87

QgsShadowEffect::offsetMapUnitScale
const QgsMapUnitScale & offsetMapUnitScale() const
Returns the map unit scale used for the shadow offset distance.
Definition: qgsshadoweffect.h:117

QgsColorEffect::colorizeColor
QColor colorizeColor() const
Returns the color used for colorizing a picture.
Definition: qgscoloreffect.h:144

QgsColorEffect::brightness
int brightness() const
Returns the brightness modification for the effect.
Definition: qgscoloreffect.h:66

QgsGlowEffect::blurLevel
int blurLevel() const
Returns the blur level (strength) for the glow.
Definition: qgsgloweffect.h:114

QVariant

qgslogger.h

QgsGlowEffect::color
QColor color() const
Returns the color for the glow.
Definition: qgsgloweffect.h:146