qgsfieldconditionalformatwidget.cpp

Go to the documentation of this file.

/***************************************************************************
    qgsfieldconditionalformatwidget.cpp
    ---------------------
    begin                : August 2015
    copyright            : (C) 2015 by Nathan Woodrow
    email                : woodrow dot nathan 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 "qgsfieldconditionalformatwidget.h"
 
#include "qgsexpressionbuilderdialog.h"
#include "qgsexpressioncontextutils.h"
#include "qgsguiutils.h"
#include "qgsmarkersymbol.h"
#include "qgsstyle.h"
#include "qgssymbol.h"
#include "qgssymbollayerutils.h"
#include "qgssymbolselectordialog.h"
#include "qgsvectorlayer.h"
 
#include <QString>
 
#include "moc_qgsfieldconditionalformatwidget.cpp"
 
using namespace Qt::StringLiterals;
 
//
// QgsFieldConditionalFormatWidget
//
 
QgsFieldConditionalFormatWidget::QgsFieldConditionalFormatWidget( QWidget *parent )
  : QgsPanelWidget( parent )
{
  setupUi( this );
  setPanelTitle( tr( "Conditional Styles" ) );
  connect( mFieldCombo, &QgsFieldComboBox::fieldChanged, this, &QgsFieldConditionalFormatWidget::fieldChanged );
  connect( fieldRadio, &QAbstractButton::clicked, this, &QgsFieldConditionalFormatWidget::typeChanged );
  connect( rowRadio, &QAbstractButton::clicked, this, &QgsFieldConditionalFormatWidget::typeChanged );
  connect( mNewButton, &QAbstractButton::clicked, this, &QgsFieldConditionalFormatWidget::addNewRule );
  connect( listView, &QAbstractItemView::clicked, this, &QgsFieldConditionalFormatWidget::ruleClicked );
  mModel = new QStandardItemModel( listView );
  listView->setModel( mModel );
 
  connect( fieldRadio, &QRadioButton::toggled, mFieldCombo, &QWidget::setEnabled );
 
  mPresets = defaultPresets();
}
 
void QgsFieldConditionalFormatWidget::setLayer( QgsVectorLayer *layer )
{
  mLayer = layer;
  mFieldCombo->setLayer( layer );
  mFieldCombo->setCurrentIndex( 0 );
  fieldChanged( mFieldCombo->currentField() );
}
 
void QgsFieldConditionalFormatWidget::ruleClicked( const QModelIndex &index )
{
  const QList<QgsConditionalStyle> styles = getStyles();
  const QgsConditionalStyle style = styles.at( index.row() );
  editStyle( index.row(), style );
}
 
void QgsFieldConditionalFormatWidget::editStyle( int editIndex, const QgsConditionalStyle &style )
{
  mEditIndex = editIndex;
  mEditing = editIndex >= 0;
  mPanelHandled = false;
 
  QgsEditConditionalFormatRuleWidget *ruleWidget = new QgsEditConditionalFormatRuleWidget();
  ruleWidget->setLayer( mLayer );
  ruleWidget->setPresets( mPresets );
  ruleWidget->loadStyle( style );
  ruleWidget->setDockMode( true );
 
  if ( fieldRadio->isChecked() && style.rule().isEmpty() )
  {
    ruleWidget->setRule( u"@value "_s );
  }
 
  connect( ruleWidget, &QgsEditConditionalFormatRuleWidget::panelAccepted, this, [this, ruleWidget] {
    if ( mPanelHandled )
    {
      // already handled the result of the panel, and the panel is being dismissed as a result
      // of an already dealt with action
      return;
    }
 
    QList<QgsConditionalStyle> styles = getStyles();
    if ( mEditing )
    {
      styles.replace( mEditIndex, ruleWidget->currentStyle() );
    }
    else
    {
      styles.append( ruleWidget->currentStyle() );
    }
 
    QString fieldName;
    if ( fieldRadio->isChecked() )
    {
      fieldName = mFieldCombo->currentField();
      mLayer->conditionalStyles()->setFieldStyles( fieldName, styles );
    }
    else if ( rowRadio->isChecked() )
    {
      mLayer->conditionalStyles()->setRowStyles( styles );
    }
 
    reloadStyles();
    emit rulesUpdated( fieldName );
  } );
 
  connect( ruleWidget, &QgsEditConditionalFormatRuleWidget::ruleSaved, this, [ruleWidget] {
    ruleWidget->acceptPanel();
  } );
 
  connect( ruleWidget, &QgsEditConditionalFormatRuleWidget::canceled, this, [this, ruleWidget] {
    mPanelHandled = true;
    ruleWidget->acceptPanel();
  } );
 
  connect( ruleWidget, &QgsEditConditionalFormatRuleWidget::ruleDeleted, this, [this, ruleWidget] {
    deleteCurrentRule();
    mPanelHandled = true;
    ruleWidget->acceptPanel();
  } );
  showPanel( ruleWidget );
}
 
void QgsFieldConditionalFormatWidget::loadStyle( const QgsConditionalStyle & )
{
}
 
QList<QgsConditionalStyle> QgsFieldConditionalFormatWidget::getStyles()
{
  QList<QgsConditionalStyle> styles;
  if ( fieldRadio->isChecked() )
  {
    styles = mLayer->conditionalStyles()->fieldStyles( mFieldCombo->currentField() );
  }
  else if ( rowRadio->isChecked() )
  {
    styles = mLayer->conditionalStyles()->rowStyles();
  }
 
  return styles;
}
 
void QgsFieldConditionalFormatWidget::addNewRule()
{
  editStyle( -1, QgsConditionalStyle() );
}
 
void QgsFieldConditionalFormatWidget::reset()
{
}
 
void QgsFieldConditionalFormatWidget::setPresets( const QList<QgsConditionalStyle> &styles )
{
  mPresets = styles;
}
 
QList<QgsConditionalStyle> QgsFieldConditionalFormatWidget::defaultPresets()
{
  QList<QgsConditionalStyle> styles;
  QgsConditionalStyle style = QgsConditionalStyle();
  style.setBackgroundColor( QColor( 154, 216, 113 ) );
  styles.append( style );
  style = QgsConditionalStyle();
  style.setBackgroundColor( QColor( 251, 193, 78 ) );
  styles.append( style );
  style = QgsConditionalStyle();
  style.setBackgroundColor( QColor( 251, 154, 153 ) );
  styles.append( style );
  style = QgsConditionalStyle();
  style.setTextColor( QColor( 154, 216, 113 ) );
  styles.append( style );
  style = QgsConditionalStyle();
  style.setTextColor( QColor( 251, 193, 78 ) );
  styles.append( style );
  style = QgsConditionalStyle();
  style.setTextColor( QColor( 251, 154, 153 ) );
  styles.append( style );
  return styles;
}
 
void QgsFieldConditionalFormatWidget::typeChanged()
{
  reloadStyles();
}
 
void QgsFieldConditionalFormatWidget::reloadStyles()
{
  mModel->clear();
 
  const auto constGetStyles = getStyles();
 
  const QSize size( Qgis::UI_SCALE_FACTOR * fontMetrics().horizontalAdvance( 'X' ) * 10, Qgis::UI_SCALE_FACTOR * fontMetrics().height() * 2 );
 
  listView->setIconSize( size );
 
  for ( const QgsConditionalStyle &style : constGetStyles )
  {
    QStandardItem *item = new QStandardItem( style.displayText() );
    item->setIcon( QIcon( style.renderPreview( size ) ) );
    mModel->appendRow( item );
  }
}
 
void QgsFieldConditionalFormatWidget::fieldChanged( const QString &fieldName )
{
  Q_UNUSED( fieldName )
  reloadStyles();
}
 
void QgsFieldConditionalFormatWidget::deleteCurrentRule()
{
  if ( !mEditing )
    return;
 
  QList<QgsConditionalStyle> styles = getStyles();
  styles.removeAt( mEditIndex );
  QString fieldName;
  if ( fieldRadio->isChecked() )
  {
    fieldName = mFieldCombo->currentField();
    mLayer->conditionalStyles()->setFieldStyles( fieldName, styles );
  }
  else if ( rowRadio->isChecked() )
  {
    mLayer->conditionalStyles()->setRowStyles( styles );
  }
 
  reloadStyles();
  emit rulesUpdated( fieldName );
}
 
void QgsFieldConditionalFormatWidget::viewRules()
{
}
 
 
//
// QgsEditConditionalFormatRuleWidget
//
 
QgsEditConditionalFormatRuleWidget::QgsEditConditionalFormatRuleWidget( QWidget *parent )
  : QgsPanelWidget( parent )
{
  setupUi( this );
 
  setPanelTitle( tr( "Edit Rule" ) );
 
  btnBackgroundColor->setColor( QColor() );
  btnTextColor->setColor( QColor() );
  checkIcon->setChecked( false );
  btnChangeIcon->setIcon( QIcon() );
  btnBackgroundColor->setToNoColor();
  btnTextColor->setToNoColor();
 
  mFontBoldBtn->setChecked( false );
  mFontItalicBtn->setChecked( false );
  mFontStrikethroughBtn->setChecked( false );
  mFontUnderlineBtn->setChecked( false );
 
  const int buttonSize = QgsGuiUtils::scaleIconSize( 24 );
  mFontUnderlineBtn->setMinimumSize( buttonSize, buttonSize );
  mFontUnderlineBtn->setMaximumSize( buttonSize, buttonSize );
  mFontStrikethroughBtn->setMinimumSize( buttonSize, buttonSize );
  mFontStrikethroughBtn->setMaximumSize( buttonSize, buttonSize );
  mFontBoldBtn->setMinimumSize( buttonSize, buttonSize );
  mFontBoldBtn->setMaximumSize( buttonSize, buttonSize );
  mFontItalicBtn->setMinimumSize( buttonSize, buttonSize );
  mFontItalicBtn->setMaximumSize( buttonSize, buttonSize );
 
  connect( mSaveRule, &QAbstractButton::clicked, this, &QgsEditConditionalFormatRuleWidget::ruleSaved );
  connect( mCancelButton, &QAbstractButton::clicked, this, &QgsEditConditionalFormatRuleWidget::canceled );
  connect( mDeleteButton, &QAbstractButton::clicked, this, &QgsEditConditionalFormatRuleWidget::ruleDeleted );
 
  connect( btnBuildExpression, &QAbstractButton::clicked, this, &QgsEditConditionalFormatRuleWidget::setExpression );
  connect( mPresetsList, static_cast<void ( QComboBox::* )( int )>( &QComboBox::currentIndexChanged ), this, &QgsEditConditionalFormatRuleWidget::presetSet );
 
  btnBackgroundColor->setAllowOpacity( true );
  btnBackgroundColor->setShowNoColor( true );
  btnTextColor->setAllowOpacity( true );
  btnTextColor->setShowNoColor( true );
  mPresetsModel = new QStandardItemModel( mPresetsList );
  mPresetsList->setModel( mPresetsModel );
 
  btnChangeIcon->setSymbolType( Qgis::SymbolType::Marker );
  btnChangeIcon->setSymbol( QgsSymbol::defaultSymbol( Qgis::GeometryType::Point ) );
  connect( checkIcon, &QCheckBox::toggled, btnChangeIcon, &QWidget::setEnabled );
}
 
void QgsEditConditionalFormatRuleWidget::setLayer( QgsVectorLayer *layer )
{
  mLayer = layer;
}
 
void QgsEditConditionalFormatRuleWidget::loadStyle( const QgsConditionalStyle &style )
{
  mRuleEdit->setText( style.rule() );
  mNameEdit->setText( style.name() );
  setFormattingFromStyle( style );
}
 
QgsConditionalStyle QgsEditConditionalFormatRuleWidget::currentStyle() const
{
  QgsConditionalStyle style;
 
  style.setRule( mRuleEdit->text() );
  style.setName( mNameEdit->text() );
 
  const QColor backColor = btnBackgroundColor->color();
  const QColor fontColor = btnTextColor->color();
 
  QFont font = mFontFamilyCmbBx->currentFont();
  font.setBold( mFontBoldBtn->isChecked() );
  font.setItalic( mFontItalicBtn->isChecked() );
  font.setStrikeOut( mFontStrikethroughBtn->isChecked() );
  font.setUnderline( mFontUnderlineBtn->isChecked() );
  style.setFont( font );
  style.setBackgroundColor( backColor );
  style.setTextColor( fontColor );
  if ( checkIcon->isChecked() )
  {
    style.setSymbol( btnChangeIcon->clonedSymbol<QgsMarkerSymbol>() );
  }
  else
  {
    style.setSymbol( nullptr );
  }
  return style;
}
 
void QgsEditConditionalFormatRuleWidget::setExpression()
{
  QgsExpressionContext context( QgsExpressionContextUtils::globalProjectLayerScopes( mLayer ) );
  context.lastScope()->addVariable( QgsExpressionContextScope::StaticVariable( u"value"_s, 0, true ) );
  context.setHighlightedVariables( QStringList() << u"value"_s );
 
  QgsExpressionBuilderDialog dlg( mLayer, mRuleEdit->text(), this, u"generic"_s, context );
  dlg.setWindowTitle( tr( "Conditional Style Rule Expression" ) );
 
  if ( dlg.exec() )
  {
    const QString expression = dlg.expressionBuilder()->expressionText();
    mRuleEdit->setText( expression );
  }
}
 
void QgsEditConditionalFormatRuleWidget::presetSet( int index )
{
  if ( index == -1 || mPresets.isEmpty() )
    return;
 
  const int styleIndex = mPresetsList->currentData( Qt::UserRole + 1 ).toInt();
  const QgsConditionalStyle style = mPresets.at( styleIndex );
  setFormattingFromStyle( style );
}
 
void QgsEditConditionalFormatRuleWidget::setFormattingFromStyle( const QgsConditionalStyle &style )
{
  btnBackgroundColor->setColor( style.backgroundColor() );
  btnTextColor->setColor( style.textColor() );
  if ( auto *lSymbol = style.symbol() )
  {
    btnChangeIcon->setSymbol( lSymbol->clone() );
    checkIcon->setChecked( true );
  }
  else
  {
    checkIcon->setChecked( false );
  }
  const QFont font = style.font();
  mFontBoldBtn->setChecked( font.bold() );
  mFontItalicBtn->setChecked( font.italic() );
  mFontStrikethroughBtn->setChecked( font.strikeOut() );
  mFontUnderlineBtn->setChecked( font.underline() );
  mFontFamilyCmbBx->setCurrentFont( font );
}
 
void QgsEditConditionalFormatRuleWidget::setPresets( const QList<QgsConditionalStyle> &styles )
{
  mPresets.clear();
  mPresetsModel->clear();
  QStandardItem *item = new QStandardItem( QString() );
  mPresetsModel->appendRow( item );
  int i = 0;
  for ( const QgsConditionalStyle &style : styles )
  {
    if ( style.isValid() )
    {
      QStandardItem *item = new QStandardItem( u"abc - 123"_s );
      if ( style.validBackgroundColor() )
        item->setBackground( style.backgroundColor() );
      if ( style.validTextColor() )
        item->setForeground( style.textColor() );
      if ( style.symbol() )
        item->setIcon( style.icon() );
      item->setFont( style.font() );
      item->setData( i, Qt::UserRole + 1 );
      mPresetsModel->appendRow( item );
      mPresets.append( style );
      i++;
    }
  }
  mPresetsList->setCurrentIndex( 0 );
}
 
void QgsEditConditionalFormatRuleWidget::setRule( const QString &rule )
{
  mRuleEdit->setText( rule );
}
 
bool QgsEditConditionalFormatRuleWidget::isCustomSet()
{
  return ( btnBackgroundColor->color().isValid() || btnTextColor->color().isValid() || mFontButtons->checkedId() != -1 );
}