-rw-r--r-- | microkde/kdeui/knuminput.cpp | 61 |
1 files changed, 32 insertions, 29 deletions
diff --git a/microkde/kdeui/knuminput.cpp b/microkde/kdeui/knuminput.cpp index 335d6f4..da01a20 100644 --- a/microkde/kdeui/knuminput.cpp +++ b/microkde/kdeui/knuminput.cpp @@ -13,154 +13,157 @@ * http://www.troll.no/ * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public License * along with this library; see the file COPYING.LIB. If not, write to * the Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ //US #include <config.h> #ifdef HAVE_LIMITS_H #include <limits.h> #endif #include <assert.h> #include <math.h> #include <algorithm> #include <qlabel.h> #include <qlineedit.h> #include <qsize.h> #include <qslider.h> #include <qspinbox.h> #include <qstyle.h> +//Added by qt3to4: +#include <QResizeEvent> +#include <QEvent> #include <kglobal.h> #include <klocale.h> #include <kdebug.h> #include "knumvalidator.h" #include "knuminput.h" static inline int calcDiffByTen( int x, int y ) { // calculate ( x - y ) / 10 without overflowing ints: return ( x / 10 ) - ( y / 10 ) + ( x % 10 - y % 10 ) / 10; } // ---------------------------------------------------------------------------- KNumInput::KNumInput(QWidget* parent, const char* name) : QWidget(parent, name) { init(); } KNumInput::KNumInput(KNumInput* below, QWidget* parent, const char* name) : QWidget(parent, name) { init(); if(below) { m_next = below->m_next; m_prev = below; below->m_next = this; if(m_next) m_next->m_prev = this; } } void KNumInput::init() { m_prev = m_next = 0; m_colw1 = m_colw2 = 0; m_label = 0; m_slider = 0; m_alignment = 0; } KNumInput::~KNumInput() { if(m_prev) m_prev->m_next = m_next; if(m_next) m_next->m_prev = m_prev; } void KNumInput::setLabel(const QString & label, int a) { if(label.isEmpty()) { delete m_label; m_label = 0; m_alignment = 0; } else { if (m_label) m_label->setText(label); else m_label = new QLabel(label, this, "KNumInput::QLabel"); - m_label->setAlignment((a & (~(AlignTop|AlignBottom|AlignVCenter))) - | AlignVCenter); + m_label->setAlignment((a & (~(Qt::AlignTop|Qt::AlignBottom|Qt::AlignVCenter))) + | Qt::AlignVCenter); // if no vertical alignment set, use Top alignment - if(!(a & (AlignTop|AlignBottom|AlignVCenter))) - a |= AlignTop; + if(!(a & (Qt::AlignTop|Qt::AlignBottom|Qt::AlignVCenter))) + a |= Qt::AlignTop; m_alignment = a; } layout(true); } QString KNumInput::label() const { if (m_label) return m_label->text(); return QString::null; } void KNumInput::layout(bool deep) { int w1 = m_colw1; int w2 = m_colw2; // label sizeHint m_sizeLabel = (m_label ? m_label->sizeHint() : QSize(0,0)); - if(m_label && (m_alignment & AlignVCenter)) + if(m_label && (m_alignment & Qt::AlignVCenter)) m_colw1 = m_sizeLabel.width() + 4; else m_colw1 = 0; // slider sizeHint m_sizeSlider = (m_slider ? m_slider->sizeHint() : QSize(0, 0)); doLayout(); if(!deep) { m_colw1 = w1; m_colw2 = w2; return; } KNumInput* p = this; while(p) { p->doLayout(); w1 = QMAX(w1, p->m_colw1); w2 = QMAX(w2, p->m_colw2); p = p->m_prev; } p = m_next; while(p) { p->doLayout(); w1 = QMAX(w1, p->m_colw1); w2 = QMAX(w2, p->m_colw2); p = p->m_next; } p = this; @@ -173,108 +176,108 @@ void KNumInput::layout(bool deep) p = m_next; while(p) { p->m_colw1 = w1; p->m_colw2 = w2; p = p->m_next; } // kdDebug() << "w1 " << w1 << " w2 " << w2 << endl; } QSizePolicy KNumInput::sizePolicy() const { return QSizePolicy( QSizePolicy::Minimum, QSizePolicy::Fixed ); } QSize KNumInput::sizeHint() const { return minimumSizeHint(); } void KNumInput::setSteps(int minor, int major) { if(m_slider) m_slider->setSteps( minor, major ); } // ---------------------------------------------------------------------------- KIntSpinBox::KIntSpinBox(QWidget *parent, const char *name) : QSpinBox(0, 99, 1, parent, name) { - editor()->setAlignment(AlignRight); + setAlignment(Qt::AlignRight); val_base = 10; setValue(0); } KIntSpinBox::~KIntSpinBox() { } KIntSpinBox::KIntSpinBox(int lower, int upper, int step, int value, int base, QWidget* parent, const char* name) : QSpinBox(lower, upper, step, parent, name) { - editor()->setAlignment(AlignRight); + setAlignment(Qt::AlignRight); val_base = base; setValue(value); } void KIntSpinBox::setBase(int base) { val_base = base; } int KIntSpinBox::base() const { return val_base; } QString KIntSpinBox::mapValueToText(int v) { return QString::number(v, val_base); } int KIntSpinBox::mapTextToValue(bool* ok) { return cleanText().toInt(ok, val_base); } void KIntSpinBox::setEditFocus(bool mark) { - editor()->setFocus(); + setFocus(); if(mark) - editor()->selectAll(); + selectAll(); } // ---------------------------------------------------------------------------- class KIntNumInput::KIntNumInputPrivate { public: int referencePoint; short blockRelative; KIntNumInputPrivate( int r ) : referencePoint( r ), blockRelative( 0 ) {} }; KIntNumInput::KIntNumInput(KNumInput* below, int val, QWidget* parent, int _base, const char* name) : KNumInput(below, parent, name) { init(val, _base); } KIntNumInput::KIntNumInput(QWidget *parent, const char *name) : KNumInput(parent, name) { init(0, 10); } KIntNumInput::KIntNumInput(int val, QWidget *parent, int _base, const char *name) : KNumInput(parent, name) { init(val, _base); @@ -296,200 +299,200 @@ void KIntNumInput::init(int val, int _base) void KIntNumInput::setReferencePoint( int ref ) { // clip to valid range: ref = kMin( maxValue(), kMax( minValue(), ref ) ); d->referencePoint = ref; } int KIntNumInput::referencePoint() const { return d->referencePoint; } void KIntNumInput::spinValueChanged(int val) { if(m_slider) m_slider->setValue(val); emit valueChanged(val); } void KIntNumInput::slotEmitRelativeValueChanged( int value ) { if ( d->blockRelative || !d->referencePoint ) return; emit relativeValueChanged( double( value ) / double( d->referencePoint ) ); } void KIntNumInput::setRange(int lower, int upper, int step, bool slider) { upper = kMax(upper, lower); lower = kMin(upper, lower); m_spin->setMinValue(lower); m_spin->setMaxValue(upper); m_spin->setLineStep(step); - step = m_spin->lineStep(); // maybe QRangeControl didn't like out lineStep? + step = m_spin->singleStep(); // maybe QRangeControl didn't like out lineStep? if(slider) { if (m_slider) m_slider->setRange(lower, upper); else { m_slider = new QSlider(lower, upper, step, m_spin->value(), - QSlider::Horizontal, this); + Qt::Horizontal, this); m_slider->setTickmarks(QSlider::Below); connect(m_slider, SIGNAL(valueChanged(int)), m_spin, SLOT(setValue(int))); } // calculate (upper-lower)/10 without overflowing int's: int major = calcDiffByTen( upper, lower ); if ( major==0 ) major = step; // #### workaround Qt bug in 2.1-beta4 m_slider->setSteps(step, major); m_slider->setTickInterval(major); } else { delete m_slider; m_slider = 0; } // check that reference point is still inside valid range: setReferencePoint( referencePoint() ); layout(true); } void KIntNumInput::setMinValue(int min) { - setRange(min, m_spin->maxValue(), m_spin->lineStep(), m_slider); + setRange(min, m_spin->maxValue(), m_spin->singleStep(), m_slider); } int KIntNumInput::minValue() const { return m_spin->minValue(); } void KIntNumInput::setMaxValue(int max) { - setRange(m_spin->minValue(), max, m_spin->lineStep(), m_slider); + setRange(m_spin->minValue(), max, m_spin->singleStep(), m_slider); } int KIntNumInput::maxValue() const { return m_spin->maxValue(); } void KIntNumInput::setSuffix(const QString &suffix) { m_spin->setSuffix(suffix); layout(true); } QString KIntNumInput::suffix() const { return m_spin->suffix(); } void KIntNumInput::setPrefix(const QString &prefix) { m_spin->setPrefix(prefix); layout(true); } QString KIntNumInput::prefix() const { return m_spin->prefix(); } void KIntNumInput::setEditFocus(bool mark) { m_spin->setEditFocus(mark); } QSize KIntNumInput::minimumSizeHint() const { constPolish(); int w; int h; h = 2 + QMAX(m_sizeSpin.height(), m_sizeSlider.height()); // if in extra row, then count it here - if(m_label && (m_alignment & (AlignBottom|AlignTop))) + if(m_label && (m_alignment & (Qt::AlignBottom|Qt::AlignTop))) h += 4 + m_sizeLabel.height(); else // label is in the same row as the other widgets h = QMAX(h, m_sizeLabel.height() + 2); w = m_slider ? m_slider->sizeHint().width() + 8 : 0; w += m_colw1 + m_colw2; - if(m_alignment & (AlignTop|AlignBottom)) + if(m_alignment & (Qt::AlignTop|Qt::AlignBottom)) w = QMAX(w, m_sizeLabel.width() + 4); return QSize(w, h); } void KIntNumInput::doLayout() { m_sizeSpin = m_spin->sizeHint(); m_colw2 = m_sizeSpin.width(); if (m_label) m_label->setBuddy(m_spin); } void KIntNumInput::resizeEvent(QResizeEvent* e) { int w = m_colw1; int h = 0; - if(m_label && (m_alignment & AlignTop)) { + if(m_label && (m_alignment & Qt::AlignTop)) { m_label->setGeometry(0, 0, e->size().width(), m_sizeLabel.height()); h += m_sizeLabel.height() + 4; } - if(m_label && (m_alignment & AlignVCenter)) + if(m_label && (m_alignment & Qt::AlignVCenter)) m_label->setGeometry(0, 0, w, m_sizeSpin.height()); m_spin->setGeometry(w, h, m_slider ? m_colw2 : QMAX(m_colw2, e->size().width() - w), m_sizeSpin.height()); w += m_colw2 + 8; if(m_slider) m_slider->setGeometry(w, h, e->size().width() - w, m_sizeSpin.height()); h += m_sizeSpin.height() + 2; - if(m_label && (m_alignment & AlignBottom)) + if(m_label && (m_alignment & Qt::AlignBottom)) m_label->setGeometry(0, h, m_sizeLabel.width(), m_sizeLabel.height()); } KIntNumInput::~KIntNumInput() { delete d; } void KIntNumInput::setValue(int val) { m_spin->setValue(val); // slider value is changed by spinValueChanged } void KIntNumInput::setRelativeValue( double r ) { if ( !d->referencePoint ) return; ++d->blockRelative; setValue( int( d->referencePoint * r + 0.5 ) ); --d->blockRelative; } double KIntNumInput::relativeValue() const { if ( !d->referencePoint ) return 0; return double( value() ) / double ( d->referencePoint ); } int KIntNumInput::value() const { return m_spin->value(); } void KIntNumInput::setSpecialValueText(const QString& text) @@ -617,156 +620,156 @@ void KDoubleNumInput::updateLegacyMembers() { double KDoubleNumInput::mapSliderToSpin( int val ) const { // map [slidemin,slidemax] to [spinmin,spinmax] double spinmin = d->spin->minValue(); double spinmax = d->spin->maxValue(); double slidemin = m_slider->minValue(); // cast int to double to avoid double slidemax = m_slider->maxValue(); // overflow in rel denominator double rel = ( double(val) - slidemin ) / ( slidemax - slidemin ); return spinmin + rel * ( spinmax - spinmin ); } void KDoubleNumInput::sliderMoved(int val) { d->spin->setValue( mapSliderToSpin( val ) ); } void KDoubleNumInput::slotEmitRelativeValueChanged( double value ) { if ( !d->referencePoint ) return; emit relativeValueChanged( value / d->referencePoint ); } QSize KDoubleNumInput::minimumSizeHint() const { constPolish(); int w; int h; h = 2 + QMAX(m_sizeEdit.height(), m_sizeSlider.height()); // if in extra row, then count it here - if(m_label && (m_alignment & (AlignBottom|AlignTop))) + if(m_label && (m_alignment & (Qt::AlignBottom|Qt::AlignTop))) h += 4 + m_sizeLabel.height(); else // label is in the same row as the other widgets h = QMAX(h, m_sizeLabel.height() + 2); w = m_slider ? m_slider->sizeHint().width() + 8 : 0; w += m_colw1 + m_colw2; - if(m_alignment & (AlignTop|AlignBottom)) + if(m_alignment & (Qt::AlignTop|Qt::AlignBottom)) w = QMAX(w, m_sizeLabel.width() + 4); return QSize(w, h); } void KDoubleNumInput::resizeEvent(QResizeEvent* e) { int w = m_colw1; int h = 0; - if(m_label && (m_alignment & AlignTop)) { + if(m_label && (m_alignment & Qt::AlignTop)) { m_label->setGeometry(0, 0, e->size().width(), m_sizeLabel.height()); h += m_sizeLabel.height() + 4; } - if(m_label && (m_alignment & AlignVCenter)) + if(m_label && (m_alignment & Qt::AlignVCenter)) m_label->setGeometry(0, 0, w, m_sizeEdit.height()); d->spin->setGeometry(w, h, m_slider ? m_colw2 : e->size().width() - w, m_sizeEdit.height()); w += m_colw2 + 8; if(m_slider) m_slider->setGeometry(w, h, e->size().width() - w, m_sizeEdit.height()); h += m_sizeEdit.height() + 2; - if(m_label && (m_alignment & AlignBottom)) + if(m_label && (m_alignment & Qt::AlignBottom)) m_label->setGeometry(0, h, m_sizeLabel.width(), m_sizeLabel.height()); } void KDoubleNumInput::doLayout() { m_sizeEdit = d->spin->sizeHint(); m_colw2 = m_sizeEdit.width(); } void KDoubleNumInput::setValue(double val) { d->spin->setValue( val ); } void KDoubleNumInput::setRelativeValue( double r ) { if ( !d->referencePoint ) return; ++d->blockRelative; setValue( r * d->referencePoint ); --d->blockRelative; } void KDoubleNumInput::setReferencePoint( double ref ) { // clip to valid range: ref = kMin( maxValue(), kMax( minValue(), ref ) ); d->referencePoint = ref; } void KDoubleNumInput::setRange(double lower, double upper, double step, bool slider) { if( m_slider ) { // don't update the slider to avoid an endless recursion QSpinBox * spin = d->spin; disconnect(spin, SIGNAL(valueChanged(int)), m_slider, SLOT(setValue(int)) ); } d->spin->setRange( lower, upper, step, d->spin->precision() ); if(slider) { // upcast to base type to get the min/maxValue in int form: QSpinBox * spin = d->spin; int slmax = spin->maxValue(); int slmin = spin->minValue(); int slvalue = spin->value(); - int slstep = spin->lineStep(); + int slstep = spin->singleStep(); if (m_slider) { m_slider->setRange(slmin, slmax); m_slider->setLineStep(slstep); m_slider->setValue(slvalue); } else { m_slider = new QSlider(slmin, slmax, slstep, slvalue, - QSlider::Horizontal, this); + Qt::Horizontal, this); m_slider->setTickmarks(QSlider::Below); // feedback line: when one moves, the other moves, too: connect(m_slider, SIGNAL(valueChanged(int)), SLOT(sliderMoved(int)) ); } connect(spin, SIGNAL(valueChanged(int)), m_slider, SLOT(setValue(int)) ); // calculate ( slmax - slmin ) / 10 without overflowing ints: int major = calcDiffByTen( slmax, slmin ); if ( !major ) major = slstep; // ### needed? m_slider->setTickInterval(major); } else { delete m_slider; m_slider = 0; } setReferencePoint( referencePoint() ); layout(true); updateLegacyMembers(); } void KDoubleNumInput::setMinValue(double min) { setRange(min, maxValue(), d->spin->lineStep(), m_slider); } double KDoubleNumInput::minValue() const { return d->spin->minValue(); } @@ -883,75 +886,75 @@ public: int mapToInt( double value, bool * ok ) const { assert( ok ); const double f = factor(); if ( value > double(INT_MAX) / f ) { kdWarning() << "KDoubleSpinBox: can't represent value " << value << "in terms of fixed-point numbers with precision " << mPrecision << endl; *ok = false; return INT_MAX; } else if ( value < double(INT_MIN) / f ) { kdWarning() << "KDoubleSpinBox: can't represent value " << value << "in terms of fixed-point numbers with precision " << mPrecision << endl; *ok = false; return INT_MIN; } else { *ok = true; return int( value * f + ( value < 0 ? -0.5 : 0.5 ) ); } } double mapToDouble( int value ) const { return double(value) * basicStep(); } int mPrecision; KDoubleValidator * mValidator; }; KDoubleSpinBox::KDoubleSpinBox( QWidget * parent, const char * name ) : QSpinBox( parent, name ) { - editor()->setAlignment( Qt::AlignRight ); + setAlignment( Qt::AlignRight ); d = new Private(); updateValidator(); } KDoubleSpinBox::KDoubleSpinBox( double lower, double upper, double step, double value, int precision, QWidget * parent, const char * name ) : QSpinBox( parent, name ) { - editor()->setAlignment( Qt::AlignRight ); + setAlignment( Qt::AlignRight ); d = new Private(); setRange( lower, upper, step, precision ); setValue( value ); connect( this, SIGNAL(valueChanged(int)), SLOT(slotValueChanged(int)) ); } KDoubleSpinBox::~KDoubleSpinBox() { delete d; d = 0; } bool KDoubleSpinBox::acceptLocalizedNumbers() const { if ( !d->mValidator ) return true; // we'll set one that does; // can't do it now, since we're const return d->mValidator->acceptLocalizedNumbers(); } void KDoubleSpinBox::setAcceptLocalizedNumbers( bool accept ) { if ( !d->mValidator ) updateValidator(); d->mValidator->setAcceptLocalizedNumbers( accept ); } void KDoubleSpinBox::setRange( double lower, double upper, double step, int precision ) { lower = kMin(upper, lower); upper = kMax(upper, lower); setPrecision( precision, true ); // disable bounds checking, since setMinValue( lower ); // it's done in set{Min,Max}Value setMaxValue( upper ); // anyway and we want lower, upper setLineStep( step ); // and step to have the right precision } int KDoubleSpinBox::precision() const { @@ -998,98 +1001,98 @@ void KDoubleSpinBox::setValue( double value ) { bool ok = false; base::setValue( d->mapToInt( value, &ok ) ); assert( ok ); } } double KDoubleSpinBox::minValue() const { return d->mapToDouble( base::minValue() ); } void KDoubleSpinBox::setMinValue( double value ) { bool ok = false; int min = d->mapToInt( value, &ok ); if ( !ok ) return; base::setMinValue( min ); updateValidator(); } double KDoubleSpinBox::maxValue() const { return d->mapToDouble( base::maxValue() ); } void KDoubleSpinBox::setMaxValue( double value ) { bool ok = false; int max = d->mapToInt( value, &ok ); if ( !ok ) return; base::setMaxValue( max ); updateValidator(); } double KDoubleSpinBox::lineStep() const { - return d->mapToDouble( base::lineStep() ); + return d->mapToDouble( base::singleStep() ); } void KDoubleSpinBox::setLineStep( double step ) { bool ok = false; if ( step > maxValue() - minValue() ) base::setLineStep( 1 ); else base::setLineStep( kMax( d->mapToInt( step, &ok ), 1 ) ); } QString KDoubleSpinBox::mapValueToText( int value ) { if ( acceptLocalizedNumbers() ) return KGlobal::locale() ->formatNumber( d->mapToDouble( value ), d->mPrecision ); else return QString().setNum( d->mapToDouble( value ), 'f', d->mPrecision ); } int KDoubleSpinBox::mapTextToValue( bool * ok ) { double value; if ( acceptLocalizedNumbers() ) value = KGlobal::locale()->readNumber( cleanText(), ok ); else value = cleanText().toDouble( ok ); if ( !*ok ) return 0; if ( value > maxValue() ) value = maxValue(); else if ( value < minValue() ) value = minValue(); return d->mapToInt( value, ok ); } void KDoubleSpinBox::setValidator( const QValidator * ) { // silently discard the new validator. We don't want another one ;-) } void KDoubleSpinBox::slotValueChanged( int value ) { emit valueChanged( d->mapToDouble( value ) ); } void KDoubleSpinBox::updateValidator() { if ( !d->mValidator ) { d->mValidator = new KDoubleValidator( minValue(), maxValue(), precision(), this, "d->mValidator" ); - base::setValidator( d->mValidator ); + lineEdit()->setValidator( d->mValidator ); } else d->mValidator->setRange( minValue(), maxValue(), precision() ); } void KNumInput::virtual_hook( int, void* ) { /*BASE::virtual_hook( id, data );*/ } void KIntNumInput::virtual_hook( int id, void* data ) { KNumInput::virtual_hook( id, data ); } void KDoubleNumInput::virtual_hook( int id, void* data ) { KNumInput::virtual_hook( id, data ); } void KIntSpinBox::virtual_hook( int, void* ) { /*BASE::virtual_hook( id, data );*/ } void KDoubleSpinBox::virtual_hook( int, void* ) { /*BASE::virtual_hook( id, data );*/ } //US #include "knuminput.moc" |