qgsdoublespinbox.cpp

Go to the documentation of this file.

/***************************************************************************
    qgsdoublespinbox.cpp
     --------------------------------------
    Date                 : 09.2014
    Copyright            : (C) 2014 Denis Rouzaud
    Email                : denis.rouzaud@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 "qgsdoublespinbox.h"
 
#include "qgsapplication.h"
#include "qgsexpression.h"
#include "qgsexpressioncontext.h"
#include "qgsexpressioncontextutils.h"
#include "qgsfilterlineedit.h"
#include "qgslogger.h"
 
#include <QLineEdit>
#include <QMouseEvent>
#include <QSettings>
#include <QStyle>
#include <QTimer>
 
#include "moc_qgsdoublespinbox.cpp"
 
#define CLEAR_ICON_SIZE 16
 
// This is required because private implementation of
// QAbstractSpinBoxPrivate checks for specialText emptiness
// and skips specialText handling if it's empty
#ifdef _MSC_VER
static QChar SPECIAL_TEXT_WHEN_EMPTY = QChar( 0x2063 );
#else
static constexpr QChar SPECIAL_TEXT_WHEN_EMPTY = QChar( 0x2063 );
#endif
 
 
QgsDoubleSpinBox::QgsDoubleSpinBox( QWidget *parent )
  : QDoubleSpinBox( parent )
{
  mLineEdit = new QgsSpinBoxLineEdit();
  connect( mLineEdit, &QLineEdit::returnPressed, this, &QgsDoubleSpinBox::returnPressed );
 
  // By default, group separator is off
  setLineEdit( mLineEdit );
 
  const QSize msz = minimumSizeHint();
  setMinimumSize( msz.width() + CLEAR_ICON_SIZE + 9 + frameWidth() * 2 + 2, std::max( msz.height(), CLEAR_ICON_SIZE + frameWidth() * 2 + 2 ) );
 
  connect( mLineEdit, &QgsFilterLineEdit::cleared, this, &QgsDoubleSpinBox::clear );
  connect( this, static_cast<void ( QDoubleSpinBox::* )( double )>( &QDoubleSpinBox::valueChanged ), this, &QgsDoubleSpinBox::changed );
 
  mLastEditTimer = new QTimer( this );
  mLastEditTimer->setSingleShot( true );
  mLastEditTimer->setInterval( 1000 );
  connect( mLastEditTimer, &QTimer::timeout, this, &QgsDoubleSpinBox::onLastEditTimeout );
}
 
void QgsDoubleSpinBox::setShowClearButton( const bool showClearButton )
{
  mShowClearButton = showClearButton;
  mLineEdit->setShowClearButton( showClearButton );
}
 
void QgsDoubleSpinBox::setExpressionsEnabled( const bool enabled )
{
  mExpressionsEnabled = enabled;
}
 
void QgsDoubleSpinBox::changeEvent( QEvent *event )
{
  QDoubleSpinBox::changeEvent( event );
 
  if ( event->type() == QEvent::FontChange )
  {
    lineEdit()->setFont( font() );
  }
 
  mLineEdit->setShowClearButton( shouldShowClearForValue( value() ) );
}
 
void QgsDoubleSpinBox::wheelEvent( QWheelEvent *event )
{
  const double step = singleStep();
  if ( event->modifiers() & Qt::ControlModifier )
  {
    // ctrl modifier results in finer increments - 10% of usual step
    double newStep = step / 10;
    // but don't ever use an increment smaller than would be visible in the widget
    // i.e. if showing 2 decimals, smallest increment will be 0.01
    newStep = std::max( newStep, std::pow( 10.0, 0.0 - decimals() ) );
 
    setSingleStep( newStep );
 
    // clear control modifier before handing off event - Qt uses it for unwanted purposes
    // (*increasing* step size, whereas QGIS UX convention is that control modifier
    // results in finer changes!)
    event->setModifiers( event->modifiers() & ~Qt::ControlModifier );
  }
  QDoubleSpinBox::wheelEvent( event );
  setSingleStep( step );
}
 
void QgsDoubleSpinBox::focusOutEvent( QFocusEvent *event )
{
  QDoubleSpinBox::focusOutEvent( event );
  onLastEditTimeout();
}
 
void QgsDoubleSpinBox::timerEvent( QTimerEvent *event )
{
  // Process all events, which may include a mouse release event
  // Only allow the timer to trigger additional value changes if the user
  // has in fact held the mouse button, rather than the timer expiry
  // simply appearing before the mouse release in the event queue
  qApp->processEvents();
  if ( QApplication::mouseButtons() & Qt::LeftButton )
    QDoubleSpinBox::timerEvent( event );
}
 
void QgsDoubleSpinBox::paintEvent( QPaintEvent *event )
{
  mLineEdit->setShowClearButton( shouldShowClearForValue( value() ) );
  QDoubleSpinBox::paintEvent( event );
}
 
void QgsDoubleSpinBox::stepBy( int steps )
{
  const bool wasNull = mShowClearButton && value() == clearValue();
  if ( wasNull && minimum() < 0 && maximum() > 0 && !( specialValueText().isEmpty() || specialValueText() == SPECIAL_TEXT_WHEN_EMPTY ) )
  {
    // value is currently null, and range allows both positive and negative numbers
    // in this case we DON'T do the default step, as that would add one step to the NULL value,
    // which is usually the minimum acceptable value... so the user will get a very large negative number!
    // Instead, treat the initial value as 0 instead, and then perform the step.
    whileBlocking( this )->setValue( 0 );
  }
  QDoubleSpinBox::stepBy( steps );
}
 
int QgsDoubleSpinBox::editingTimeoutInterval() const
{
  return mLastEditTimer->interval();
}
 
void QgsDoubleSpinBox::setEditingTimeoutInterval( int timeout )
{
  mLastEditTimer->setInterval( timeout );
}
 
void QgsDoubleSpinBox::changed( double value )
{
  mLineEdit->setShowClearButton( shouldShowClearForValue( value ) );
  mLastEditTimer->start();
}
 
void QgsDoubleSpinBox::onLastEditTimeout()
{
  mLastEditTimer->stop();
  const double currentValue = value();
  if ( std::isnan( mLastEditTimeoutValue ) || mLastEditTimeoutValue != currentValue )
  {
    mLastEditTimeoutValue = currentValue;
    emit editingTimeout( mLastEditTimeoutValue );
  }
}
 
void QgsDoubleSpinBox::clear()
{
  setValue( clearValue() );
  if ( mLineEdit->isNull() )
    mLineEdit->clear();
}
 
void QgsDoubleSpinBox::setClearValue( double customValue, const QString &specialValueText )
{
  if ( mClearValueMode == CustomValue && mCustomClearValue == customValue && QAbstractSpinBox::specialValueText() == specialValueText )
  {
    return;
  }
 
  mClearValueMode = CustomValue;
  mCustomClearValue = customValue;
 
  if ( !specialValueText.isEmpty() )
  {
    const double v = value();
    clear();
    setSpecialValueText( specialValueText );
    setValue( v );
  }
}
 
void QgsDoubleSpinBox::setClearValueMode( QgsDoubleSpinBox::ClearValueMode mode, const QString &clearValueText )
{
  if ( mClearValueMode == mode && mCustomClearValue == 0 && QAbstractSpinBox::specialValueText() == clearValueText )
  {
    return;
  }
 
  mClearValueMode = mode;
  mCustomClearValue = 0;
 
  if ( !clearValueText.isEmpty() )
  {
    const double v = value();
    clear();
    setSpecialValueText( clearValueText );
    setValue( v );
  }
}
 
double QgsDoubleSpinBox::clearValue() const
{
  if ( mClearValueMode == MinimumValue )
    return minimum();
  else if ( mClearValueMode == MaximumValue )
    return maximum();
  else
    return mCustomClearValue;
}
 
void QgsDoubleSpinBox::setLineEditAlignment( Qt::Alignment alignment )
{
  mLineEdit->setAlignment( alignment );
}
 
void QgsDoubleSpinBox::setSpecialValueText( const QString &txt )
{
  if ( txt.isEmpty() )
  {
    QDoubleSpinBox::setSpecialValueText( SPECIAL_TEXT_WHEN_EMPTY );
    mLineEdit->setNullValue( SPECIAL_TEXT_WHEN_EMPTY );
  }
  else
  {
    QDoubleSpinBox::setSpecialValueText( txt );
    mLineEdit->setNullValue( txt );
  }
}
 
QString QgsDoubleSpinBox::stripped( const QString &originalText ) const
{
  //adapted from QAbstractSpinBoxPrivate::stripped
  //trims whitespace, prefix and suffix from spin box text
  QString text = originalText;
  if ( specialValueText().isEmpty() || text != specialValueText() )
  {
    // Strip SPECIAL_TEXT_WHEN_EMPTY
    if ( text.contains( SPECIAL_TEXT_WHEN_EMPTY ) )
      text = text.replace( SPECIAL_TEXT_WHEN_EMPTY, QString() );
    int from = 0;
    int size = text.size();
    bool changed = false;
    if ( !prefix().isEmpty() && text.startsWith( prefix() ) )
    {
      from += prefix().size();
      size -= from;
      changed = true;
    }
    if ( !suffix().isEmpty() && text.endsWith( suffix() ) )
    {
      size -= suffix().size();
      changed = true;
    }
    if ( changed )
      text = text.mid( from, size );
  }
 
  text = text.trimmed();
 
  return text;
}
 
double QgsDoubleSpinBox::valueFromText( const QString &text ) const
{
  if ( !mExpressionsEnabled )
  {
    return QDoubleSpinBox::valueFromText( text );
  }
 
  const QString trimmedText = stripped( text );
  if ( trimmedText.isEmpty() )
  {
    return mShowClearButton ? clearValue() : value();
  }
 
  QgsExpressionContext context;
  context << QgsExpressionContextUtils::globalScope() << QgsExpressionContextUtils::projectScope( QgsProject::instance() );
 
  return QgsExpression::evaluateToDouble( trimmedText, value(), &context );
}
 
QValidator::State QgsDoubleSpinBox::validate( QString &input, int &pos ) const
{
  if ( !mExpressionsEnabled )
  {
    const QValidator::State r = QDoubleSpinBox::validate( input, pos );
    return r;
  }
 
  return QValidator::Acceptable;
}
 
int QgsDoubleSpinBox::frameWidth() const
{
  return style()->pixelMetric( QStyle::PM_DefaultFrameWidth );
}
 
bool QgsDoubleSpinBox::shouldShowClearForValue( const double value ) const
{
  if ( !mShowClearButton || !isEnabled() )
  {
    return false;
  }
  return value != clearValue();
}
 
bool QgsDoubleSpinBox::isCleared() const
{
  return value() == clearValue();
}