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
@@ -21,48 +21,51 @@
  *  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)
 {
@@ -85,74 +88,74 @@ void KNumInput::init()
     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;
@@ -181,92 +184,92 @@ void KNumInput::layout(bool deep)
 }
 
 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)
@@ -304,184 +307,184 @@ 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 );
@@ -625,140 +628,140 @@ double KDoubleNumInput::mapSliderToSpin( int val ) const
     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)
 {
@@ -891,59 +894,59 @@ public:
       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);
@@ -1006,90 +1009,90 @@ double KDoubleSpinBox::minValue() const {
 }
 
 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"