QString QgsSpinBox::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;
}
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().size() == 0 || text != specialValueText() )
{
int from = 0;
int size = text.size();
bool changed = false;
if ( prefix().size() && text.startsWith( prefix() ) )
{
from += prefix().size();
size -= from;
changed = true;
}
if ( suffix().size() && text.endsWith( suffix() ) )
{
size -= suffix().size();
changed = true;
}
if ( changed )
text = text.mid( from, size );
}
text = text.trimmed();
return text;
}
// normal sizeHint doesn't always work right for our case,
// because the min/max/special text aren't necessarily the longest text
QSize MinSecSpinBox::sizeHint() const
{
QSize normal = QSpinBox::sizeHint();
//this first portion copied from QAbstractSpinBox
const QFontMetrics fm(fontMetrics());
int w = 0;
QString s;
s = prefix() + textFromValue(minimum()) + suffix() + QLatin1Char(' ');
s.truncate(18);
w = qMax(w, fm.width(s));
s = prefix() + textFromValue(maximum()) + suffix() + QLatin1Char(' ');
s.truncate(18);
w = qMax(w, fm.width(s));
if (specialValueText().size()) {
s = specialValueText();
w = qMax(w, fm.width(s));
}
w += 2; // cursor blinking space
//new part (see if max - singlestep is longer)
s = textFromValue(maximum()-singleStep()) + QLatin1Char(' ');
int longwidth = fm.width(s) + 2;
int dif = longwidth - w;
if (dif > 0)
normal += QSize(dif, 0);
return normal;
}
QString DoubleSpinBox::textFromValue(double value) const {
if (!specialValueText().isEmpty() && value == d_min_val)
return specialValueText();
if (d_prec <= 14)
return locale().toString(value, d_format, d_prec);
return locale().toString(value, d_format, 6);
}
void KDoubleNumInput::updateLegacyMembers() {
// ### update legacy members that are either not private or for
// which an inlined getter exists:
m_lower = minValue();
m_upper = maxValue();
m_step = d->spin->lineStep();
m_specialvalue = specialValueText();
}
/******************************************************************************
* Set spin widget stepping to the normal or shift increment.
*/
bool SpinBox::setShiftStepping(bool shift, int currentButton)
{
if (currentButton == NO_BUTTON)
shift = false;
if (shift && !mShiftMouse)
{
/* The value is to be stepped to a multiple of the shift increment.
* Adjust the value so that after the spin widget steps it, it will be correct.
* Then, if the mouse button is held down, the spin widget will continue to
* step by the shift amount.
*/
int val = value();
int step = (currentButton == UP) ? mLineShiftStep : (currentButton == DOWN) ? -mLineShiftStep : 0;
int adjust = shiftStepAdjustment(val, step);
mShiftMouse = true;
if (adjust)
{
/* The value is to be stepped by other than the shift increment,
* presumably because it is being set to a multiple of the shift
* increment. Achieve this by making the adjustment here, and then
* allowing the normal step processing to complete the job by
* adding/subtracting the normal shift increment.
*/
if (!wrapping())
{
// Prevent the step from going past the spinbox's range, or
// to the minimum value if that has a special text unless it is
// already at the minimum value + 1.
int newval = val + adjust + step;
int svt = specialValueText().isEmpty() ? 0 : 1;
int minval = mMinValue + svt;
if (newval <= minval || newval >= mMaxValue)
{
// Stepping to the minimum or maximum value
if (svt && newval <= mMinValue && val == mMinValue)
newval = mMinValue;
else
newval = (newval <= minval) ? minval : mMaxValue;
QSpinBox::setValue(newval);
emit stepped(step);
return true;
}
// If the interim value will lie outside the spinbox's range,
// temporarily adjust the range to allow the value to be set.
int tempval = val + adjust;
if (tempval < mMinValue)
{
QSpinBox::setMinimum(tempval);
mShiftMinBound = true;
}
else if (tempval > mMaxValue)
{
QSpinBox::setMaximum(tempval);
mShiftMaxBound = true;
}
}
// Don't process changes since this new value will be stepped immediately
mSuppressSignals = true;
bool blocked = signalsBlocked();
blockSignals(true);
addValue(adjust, true);
blockSignals(blocked);
mSuppressSignals = false;
}
QSpinBox::setSingleStep(mLineShiftStep);
}
else if (!shift && mShiftMouse)
{
// Reinstate to normal (non-shift) stepping
QSpinBox::setSingleStep(mLineStep);
QSpinBox::setMinimum(mMinValue);
QSpinBox::setMaximum(mMaxValue);
mShiftMinBound = mShiftMaxBound = false;
mShiftMouse = false;
}
return false;
}