- make opie compilable against qte 2.3.10 snapshot

  change QT_VERSION > 290 into QT_VERSION <= 0x030000

4 files changed, 10 insertions, 10 deletions

diff --git a/libopie2/qt3/opiecore/osortablevaluelist.h b/libopie2/qt3/opiecore/osortablevaluelist.h
index f66cf25..a3f75b4 100644
--- a/libopie2/qt3/opiecore/osortablevaluelist.h
+++ b/libopie2/qt3/opiecore/osortablevaluelist.h
@@ -1,117 +1,117 @@
 /*
                              This file is part of the Opie Project
                              Originally a part of the KDE Project
                              (C) 2001 Carsten Pfeiffer <pfeiffer@kde.org>
               =.
             .=l.
            .>+-=
  _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
 .="- .-=="i,     .._         License as published by the Free Software
  - .   .-<_>     .<>         Foundation; either version 2 of the License,
      ._= =}       :          or (at your option) any later version.
     .%`+i>       _;_.
     .i_,=:_.      -<s.       This program 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.
 */
 
 #ifndef OSORTABLEVALUELIST_H
 #define OSORTABLEVALUELIST_H
 
-#if QT_VERSION > 290
+#if QT_VERSION >= 0x030000
 #include <qtl.h>
 #include <qpair.h>
 #else
 #include <opie2/otl.h>
 #include <opie2/opair.h>
 #endif
 #include <qvaluelist.h>
 
 template<class T, class Key = int> class OSortableItem : public QPair<Key,T>
 {
 public:
     OSortableItem( Key i, const T& t ) : QPair<Key, T>( i, t ) {}
     OSortableItem( const OSortableItem<T, Key> &rhs )
         : QPair<Key,T>( rhs.first, rhs.second ) {}
 
     OSortableItem() {}
 
     OSortableItem<T, Key> &operator=( const OSortableItem<T, Key>& i ) {
         first  = i.first;
         second = i.second;
         return *this;
     }
 
     // operators for sorting
     bool operator> ( const OSortableItem<T, Key>& i2 ) const {
         return (i2.first < first);
     }
     bool operator< ( const OSortableItem<T, Key>& i2 ) const {
         return (first < i2.first);
     }
     bool operator>= ( const OSortableItem<T, Key>& i2 ) const {
         return (first >= i2.first);
     }
     bool operator<= ( const OSortableItem<T, Key>& i2 ) const {
         return !(i2.first < first);
     }
     bool operator== ( const OSortableItem<T, Key>& i2 ) const {
         return (first == i2.first);
     }
     bool operator!= ( const OSortableItem<T, Key>& i2 ) const {
         return (first != i2.first);
     }
 
     T& value() {
         return second;
     }
     const T& value() const {
         return second;
     }
 
     Key index() const {
         return first;
     }
 };
 
 
 // convenience
 template <class T, class Key = int>
 class OSortableValueList : public QValueList<OSortableItem<T, Key> >
 {
 public:
     void insert( Key i, const T& t ) {
         QValueList<OSortableItem<T, Key> >::append( OSortableItem<T, Key>( i, t ) );
     }
     // add more as you please...
 
     T& operator[]( Key i ) {
         return QValueList<OSortableItem<T, Key> >::operator[]( i ).value();
     }
     const T& operator[]( Key i ) const {
         return QValueList<OSortableItem<T, Key> >::operator[]( i ).value();
     }
 
     void sort() {
         qHeapSort( *this );
     }
 };
 
 // template <class T> class OSortableValueListIterator : public QValueListIterator<OSortableItem<T>  >
 // {
 // };
 
 #endif // OSORTABLEVALUELIST_H
diff --git a/libopie2/qt3/opieui/ocombobox.cpp b/libopie2/qt3/opieui/ocombobox.cpp
index bd330e0..130112c 100644
--- a/libopie2/qt3/opieui/ocombobox.cpp
+++ b/libopie2/qt3/opieui/ocombobox.cpp
@@ -225,240 +225,240 @@ bool OComboBox::eventFilter( QObject* o, QEvent* ev )
 
                 return m_trapReturnKey;
             }
         }
     }
 
 
     // wheel-scrolling changes the current item
     if ( type == QEvent::Wheel ) {
         if ( !listBox() || listBox()->isHidden() ) {
             QWheelEvent *e = static_cast<QWheelEvent*>( ev );
             static const int WHEEL_DELTA = 120;
             int skipItems = e->delta() / WHEEL_DELTA;
             if ( e->state() & ControlButton ) // fast skipping
                 skipItems *= 10;
 
             int newItem = currentItem() - skipItems;
 
             if ( newItem < 0 )
                 newItem = 0;
             else if ( newItem >= count() )
                 newItem = count() -1;
 
             setCurrentItem( newItem );
             if ( !text( newItem ).isNull() )
                 emit activated( text( newItem ) );
             emit activated( newItem );
             e->accept();
             return true;
         }
     }
 
     return QComboBox::eventFilter( o, ev );
 }
 
 void OComboBox::setTrapReturnKey( bool grab )
 {
     m_trapReturnKey = grab;
 }
 
 bool OComboBox::trapReturnKey() const
 {
     return m_trapReturnKey;
 }
 
 /*
 void OComboBox::setEditURL( const OURL& url )
 {
     QComboBox::setEditText( url.prettyURL() );
 }
 
 void OComboBox::insertURL( const OURL& url, int index )
 {
     QComboBox::insertItem( url.prettyURL(), index );
 }
 
 void OComboBox::insertURL( const QPixmap& pixmap, const OURL& url, int index )
 {
     QComboBox::insertItem( pixmap, url.prettyURL(), index );
 }
 
 void OComboBox::changeURL( const OURL& url, int index )
 {
     QComboBox::changeItem( url.prettyURL(), index );
 }
 
 void OComboBox::changeURL( const QPixmap& pixmap, const OURL& url, int index )
 {
     QComboBox::changeItem( pixmap, url.prettyURL(), index );
 }
 */
 
 
 void OComboBox::setCompletedItems( const QStringList& items )
 {
     if ( d->olineEdit )
         d->olineEdit->setCompletedItems( items );
 }
 
 
 OCompletionBox * OComboBox::completionBox( bool create )
 {
     if ( d->olineEdit )
         return d->olineEdit->completionBox( create );
     return 0;
 }
 
 // QWidget::create() turns off mouse-Tracking which would break auto-hiding
 void OComboBox::create( WId id, bool initializeWindow, bool destroyOldWindow )
 {
     QComboBox::create( id, initializeWindow, destroyOldWindow );
     //OCursor::setAutoHideCursor( lineEdit(), true, true );
 }
 
 void OComboBox::setLineEdit( OLineEdit *edit )
 {
-    #if QT_VERSION > 290
+    #if QT_VERSION >= 0x030000
     QComboBox::setLineEdit( edit );
     if ( !edit->inherits( "OLineEdit" ) )
         d->olineEdit = 0;
     else
         d->olineEdit = static_cast<OLineEdit*>( edit );
     setDelegate( d->olineEdit );
 
     // forward some signals. We only emit returnPressed() ourselves.
     if ( d->olineEdit ) {
         connect( d->olineEdit, SIGNAL( completion(const QString&)),
                  SIGNAL( completion(const QString&)) );
         connect( d->olineEdit, SIGNAL( substringCompletion(const QString&)),
                  SIGNAL( substringCompletion(const QString&)) );
         connect( d->olineEdit,
                  SIGNAL( textRotation(OCompletionBase::KeyBindingType)),
                  SIGNAL( textRotation(OCompletionBase::KeyBindingType)) );
         connect( d->olineEdit,
                  SIGNAL( completionModeChanged(OGlobalSettings::Completion)),
                  SIGNAL( completionModeChanged(OGlobalSettings::Completion)));
 
         connect( d->olineEdit,
                  SIGNAL( aboutToShowContextMenu(QPopupMenu*)),
                  SIGNAL( aboutToShowContextMenu(QPopupMenu*)) );
     }
     #else
     #warning OComboBox is not fully functional with Qt2
     #endif
 }
 
 // Temporary functions until QT3 appears. - Seth Chaiklin 20 may 2001
 void OComboBox::deleteWordForward()
 {
     lineEdit()->cursorWordForward(TRUE);
-    #if QT_VERSION > 290
+    #if QT_VERSION >= 0x030000
     if ( lineEdit()->hasSelectedText() )
     #else
     if ( lineEdit()->hasMarkedText() )
     #endif
     {
         lineEdit()->del();
     }
 }
 
 void OComboBox::deleteWordBack()
 {
     lineEdit()->cursorWordBackward(TRUE);
-    #if QT_VERSION > 290
+    #if QT_VERSION >= 0x030000
     if ( lineEdit()->hasSelectedText() )
     #else
     if ( lineEdit()->hasMarkedText() )
     #endif
     {
         lineEdit()->del();
     }
 }
 
 void OComboBox::setCurrentItem( const QString& item, bool insert, int index )
 {
     int sel = -1;
     for (int i = 0; i < count(); ++i)
         if (text(i) == item)
         {
             sel = i;
             break;
         }
     if (sel == -1 && insert)
     {
         insertItem(item, index);
         if (index >= 0)
             sel = index;
         else
             sel = count() - 1;
     }
     setCurrentItem(sel);
 }
 
 void OComboBox::setCurrentItem(int index)
 {
     QComboBox::setCurrentItem(index);
 }
 
 
 /*======================================================================================
  * OHistoryCombo
  *======================================================================================*/
 
 // we are always read-write
 OHistoryCombo::OHistoryCombo( QWidget *parent, const char *name )
     : OComboBox( true, parent, name )
 {
     init( true ); // using completion
 }
 
 // we are always read-write
 OHistoryCombo::OHistoryCombo( bool useCompletion,
                               QWidget *parent, const char *name )
     : OComboBox( true, parent, name )
 {
     init( useCompletion );
 }
 
 void OHistoryCombo::init( bool useCompletion )
 {
     if ( useCompletion )
         completionObject()->setOrder( OCompletion::Weighted );
 
     setInsertionPolicy( NoInsertion );
     myIterateIndex = -1;
     myRotated = false;
     myPixProvider = 0L;
 
     connect( this, SIGNAL(aboutToShowContextMenu(QPopupMenu*)),
              SLOT(addContextMenuItems(QPopupMenu*)) );
     connect( this, SIGNAL( activated(int) ), SLOT( slotReset() ));
     connect( this, SIGNAL( returnPressed(const QString&) ), SLOT(slotReset()));
 }
 
 OHistoryCombo::~OHistoryCombo()
 {
     delete myPixProvider;
 }
 
 void OHistoryCombo::setHistoryItems( QStringList items,
                                      bool setCompletionList )
 {
     OComboBox::clear();
 
     // limit to maxCount()
     while ( (int) items.count() > maxCount() && !items.isEmpty() )
         items.remove( items.begin() );
 
     insertItems( items );
 
     if ( setCompletionList && useCompletion() ) {
         // we don't have any weighting information here ;(
         OCompletion *comp = completionObject();
         comp->setOrder( OCompletion::Insertion );
         comp->setItems( items );
         comp->setOrder( OCompletion::Weighted );
     }
 
     clearEdit();
 }
diff --git a/libopie2/qt3/opieui/oeditlistbox.cpp b/libopie2/qt3/opieui/oeditlistbox.cpp
index 0e95274..dcc697d 100644
--- a/libopie2/qt3/opieui/oeditlistbox.cpp
+++ b/libopie2/qt3/opieui/oeditlistbox.cpp
@@ -99,301 +99,301 @@ void OEditListBox::init( bool checkAtEntering, int buttons,
         lostButtons += 2;
 
 
     servNewButton = servRemoveButton = servUpButton = servDownButton = 0L;
     setSizePolicy(QSizePolicy(QSizePolicy::MinimumExpanding,
                               QSizePolicy::MinimumExpanding));
 
     QWidget * gb = this;
     QGridLayout * grid = new QGridLayout(gb, 7 - lostButtons, 2,
                                          ODialog::marginHint(),
                                          ODialog::spacingHint());
     grid->addRowSpacing(0, fontMetrics().lineSpacing());
     for ( int i = 1; i < 7 - lostButtons; i++ )
         grid->setRowStretch(i, 1);
 
     grid->setMargin(15);
 
     if ( representationWidget )
         representationWidget->reparent( gb, QPoint(0,0) );
     else
         m_lineEdit=new OLineEdit(gb);
 
     m_listBox = new QListBox(gb);
 
     QWidget *editingWidget = representationWidget ?
                              representationWidget : m_lineEdit;
     grid->addMultiCellWidget(editingWidget,1,1,0,1);
     grid->addMultiCellWidget(m_listBox, 2, 6 - lostButtons, 0, 0);
     int row = 2;
     if ( buttons & Add ) {
         servNewButton = new QPushButton(tr("&Add"), gb);
         servNewButton->setEnabled(false);
         connect(servNewButton, SIGNAL(clicked()), SLOT(addItem()));
 
         grid->addWidget(servNewButton, row++, 1);
     }
 
     if ( buttons & Remove ) {
         servRemoveButton = new QPushButton(tr("&Remove"), gb);
         servRemoveButton->setEnabled(false);
         connect(servRemoveButton, SIGNAL(clicked()), SLOT(removeItem()));
 
         grid->addWidget(servRemoveButton, row++, 1);
     }
 
     if ( buttons & UpDown ) {
         servUpButton = new QPushButton(tr("Move &Up"), gb);
         servUpButton->setEnabled(false);
         connect(servUpButton, SIGNAL(clicked()), SLOT(moveItemUp()));
 
         servDownButton = new QPushButton(tr("Move &Down"), gb);
         servDownButton->setEnabled(false);
         connect(servDownButton, SIGNAL(clicked()), SLOT(moveItemDown()));
 
         grid->addWidget(servUpButton, row++, 1);
         grid->addWidget(servDownButton, row++, 1);
     }
 
     connect(m_lineEdit,SIGNAL(textChanged(const QString&)),this,SLOT(typedSomething(const QString&)));
     m_lineEdit->setTrapReturnKey(true);
     connect(m_lineEdit,SIGNAL(returnPressed()),this,SLOT(addItem()));
     connect(m_listBox, SIGNAL(highlighted(int)), SLOT(enableMoveButtons(int)));
 
     // maybe supplied lineedit has some text already
     typedSomething( m_lineEdit->text() );
 }
 
 void OEditListBox::typedSomething(const QString& text)
 {
     if(currentItem() >= 0) {
         if(currentText() != m_lineEdit->text())
         {
             // IMHO changeItem() shouldn't do anything with the value
             // of currentItem() ... like changing it or emitting signals ...
             // but TT disagree with me on this one (it's been that way since ages ... grrr)
             bool block = m_listBox->signalsBlocked();
             m_listBox->blockSignals( true );
             m_listBox->changeItem(text, currentItem());
             m_listBox->blockSignals( block );
             emit changed();
         }
     }
 
     if ( !servNewButton )
         return;
 
     if (!d->m_checkAtEntering)
         servNewButton->setEnabled(!text.isEmpty());
     else
     {
         if (text.isEmpty())
         {
             servNewButton->setEnabled(false);
         }
         else
         {
-            #if QT_VERSION > 290
+            #if QT_VERSION >= 0x030000
             StringComparisonMode mode = (StringComparisonMode) (ExactMatch | CaseSensitive );
             bool enable = (m_listBox->findItem( text, mode ) == 0L);
             #else
             bool enable = (m_listBox->findItem( text ) == 0L);
             #endif
             servNewButton->setEnabled( enable );
         }
     }
 }
 
 void OEditListBox::moveItemUp()
 {
     if (!m_listBox->isEnabled())
     {
         //ONotifyClient::beep();
         return;
     }
 
     unsigned int selIndex = m_listBox->currentItem();
     if (selIndex == 0)
     {
         //ONotifyClient::beep();
         return;
     }
 
     QListBoxItem *selItem = m_listBox->item(selIndex);
     m_listBox->takeItem(selItem);
     m_listBox->insertItem(selItem, selIndex-1);
     m_listBox->setCurrentItem(selIndex - 1);
 
     emit changed();
 }
 
 void OEditListBox::moveItemDown()
 {
     if (!m_listBox->isEnabled())
     {
         //ONotifyClient::beep();
         return;
     }
 
     unsigned int selIndex = m_listBox->currentItem();
     if (selIndex == m_listBox->count() - 1)
     {
         //ONotifyClient::beep();
         return;
     }
 
     QListBoxItem *selItem = m_listBox->item(selIndex);
     m_listBox->takeItem(selItem);
     m_listBox->insertItem(selItem, selIndex+1);
     m_listBox->setCurrentItem(selIndex + 1);
 
     emit changed();
 }
 
 void OEditListBox::addItem()
 {
     // when m_checkAtEntering is true, the add-button is disabled, but this
     // slot can still be called through Key_Return/Key_Enter. So we guard
     // against this.
     if ( !servNewButton || !servNewButton->isEnabled() )
         return;
 
     const QString& currentTextLE=m_lineEdit->text();
     bool alreadyInList(false);
     //if we didn't check for dupes at the inserting we have to do it now
     if (!d->m_checkAtEntering)
     {
         // first check current item instead of dumb iterating the entire list
         if ( m_listBox->currentText() == currentTextLE )
             alreadyInList = true;
         else
         {
-            #if QT_VERSION > 290
+            #if QT_VERSION >= 0x030000
             StringComparisonMode mode = (StringComparisonMode) (ExactMatch | CaseSensitive );
             alreadyInList =(m_listBox->findItem(currentTextLE, mode) != 0);
             #else
             alreadyInList =(m_listBox->findItem(currentTextLE) != 0);
             #endif
         }
     }
 
     if ( servNewButton )
         servNewButton->setEnabled(false);
 
     bool block = m_lineEdit->signalsBlocked();
     m_lineEdit->blockSignals(true);
     m_lineEdit->clear();
     m_lineEdit->blockSignals(block);
 
     m_listBox->setSelected(currentItem(), false);
 
     if (!alreadyInList)
     {
         block = m_listBox->signalsBlocked();
         m_listBox->blockSignals( true );
         m_listBox->insertItem(currentTextLE);
         m_listBox->blockSignals( block );
         emit changed();
         emit added( currentTextLE );
     }
 }
 
 int OEditListBox::currentItem() const 
 {
     int nr = m_listBox->currentItem();
-    #if QT_VERSION > 290
+    #if QT_VERSION >= 0x030000
     if(nr >= 0 && !m_listBox->item(nr)->isSelected()) return -1;
     #else
     if(nr >= 0 && !m_listBox->isSelected(m_listBox->item(nr))) return -1;
     #endif
     return nr;
 }
 
 void OEditListBox::removeItem()
 {
     int selected = m_listBox->currentItem();
 
     if ( selected >= 0 )
     {
         QString removedText = m_listBox->currentText();
 
         m_listBox->removeItem( selected );
         if ( count() > 0 )
             m_listBox->setSelected( QMIN( selected, count() - 1 ), true );
 
         emit changed();
         emit removed( removedText );
     }
 
     if ( servRemoveButton && m_listBox->currentItem() == -1 )
         servRemoveButton->setEnabled(false);
 }
 
 void OEditListBox::enableMoveButtons(int index)
 {
     // Update the lineEdit when we select a different line.
     if(currentText() != m_lineEdit->text())
         m_lineEdit->setText(currentText());
 
     bool moveEnabled = servUpButton && servDownButton;
 
     if (moveEnabled )
     {
         if (m_listBox->count() <= 1)
         {
             servUpButton->setEnabled(false);
             servDownButton->setEnabled(false);
         }
         else if ((uint) index == (m_listBox->count() - 1))
         {
             servUpButton->setEnabled(true);
             servDownButton->setEnabled(false);
         }
         else if (index == 0)
         {
             servUpButton->setEnabled(false);
             servDownButton->setEnabled(true);
         }
         else
         {
             servUpButton->setEnabled(true);
             servDownButton->setEnabled(true);
         }
     }
 
     if ( servRemoveButton )
         servRemoveButton->setEnabled(true);
 }
 
 void OEditListBox::clear()
 {
     m_lineEdit->clear();
     m_listBox->clear();
     emit changed();
 }
 
 void OEditListBox::insertStringList(const QStringList& list, int index)
 {
     m_listBox->insertStringList(list,index);
 }
 
 void OEditListBox::insertStrList(const QStrList* list, int index)
 {
     m_listBox->insertStrList(list,index);
 }
 
 void OEditListBox::insertStrList(const QStrList& list, int index)
 {
     m_listBox->insertStrList(list,index);
 }
 
 void OEditListBox::insertStrList(const char ** list, int numStrings, int index)
 {
     m_listBox->insertStrList(list,numStrings,index);
 }
 
 QStringList OEditListBox::items() const
 {
     QStringList list;
     for ( uint i = 0; i < m_listBox->count(); i++ )
         list.append( m_listBox->text( i ));
 
diff --git a/libopie2/qt3/opieui/olineedit.cpp b/libopie2/qt3/opieui/olineedit.cpp
index 6f66fc7..b150987 100644
--- a/libopie2/qt3/opieui/olineedit.cpp
+++ b/libopie2/qt3/opieui/olineedit.cpp
@@ -52,484 +52,484 @@ typedef QString KURL; //FIXME: Revise for Opie
 class OLineEdit::OLineEditPrivate
 {
 public:
     OLineEditPrivate()
     {
         grabReturnKeyEvents = false;
         handleURLDrops = true;
         completionBox = 0L;
     }
     ~OLineEditPrivate()
     {
         delete completionBox;
     }
 
     bool grabReturnKeyEvents;
     bool handleURLDrops;
     OCompletionBox *completionBox;
 };
 
 
 /*======================================================================================
  * OLineEdit
  *======================================================================================*/
 
 OLineEdit::OLineEdit( const QString &string, QWidget *parent, const char *name )
     : QLineEdit( string, parent, name )
 {
     init();
 }
 
 OLineEdit::OLineEdit( QWidget *parent, const char *name )
     : QLineEdit( parent, name )
 {
     init();
 }
 
 OLineEdit::~OLineEdit ()
 {
     delete d;
 }
 
 void OLineEdit::init()
 {
     d = new OLineEditPrivate;
     possibleTripleClick = false;
     // Enable the context menu by default.
     setContextMenuEnabled( true );
     //OCursor::setAutoHideCursor( this, true, true );
     installEventFilter( this );
 }
 
 void OLineEdit::setCompletionMode( OGlobalSettings::Completion mode )
 {
     OGlobalSettings::Completion oldMode = completionMode();
     if ( oldMode != mode && oldMode == OGlobalSettings::CompletionPopup &&
          d->completionBox && d->completionBox->isVisible() )
         d->completionBox->hide();
 
     // If the widgets echo mode is not Normal, no completion
     // feature will be enabled even if one is requested.
     if ( echoMode() != QLineEdit::Normal )
         mode = OGlobalSettings::CompletionNone; // Override the request.
 
     OCompletionBase::setCompletionMode( mode );
 }
 
 void OLineEdit::setCompletedText( const QString& t, bool marked )
 {
     QString txt = text();
     if ( t != txt )
     {
         int curpos = marked ? txt.length() : t.length();
         validateAndSet( t, curpos, curpos, t.length() );
     }
 }
 
 void OLineEdit::setCompletedText( const QString& text )
 {
     OGlobalSettings::Completion mode = completionMode();
     bool marked = ( mode == OGlobalSettings::CompletionAuto ||
                     mode == OGlobalSettings::CompletionMan ||
                     mode == OGlobalSettings::CompletionPopup );
     setCompletedText( text, marked );
 }
 
 void OLineEdit::rotateText( OCompletionBase::KeyBindingType type )
 {
     OCompletion* comp = compObj();
     if ( comp &&
        (type == OCompletionBase::PrevCompletionMatch ||
         type == OCompletionBase::NextCompletionMatch ) )
     {
        QString input = (type == OCompletionBase::PrevCompletionMatch) ? comp->previousMatch() : comp->nextMatch();
        // Skip rotation if previous/next match is null or the same text
        if ( input.isNull() || input == displayText() )
             return;
-       #if QT_VERSION > 290
+       #if QT_VERSION >= 0x030000
        setCompletedText( input, hasSelectedText() );
        #else
        setCompletedText( input, hasMarkedText() );
        #endif
     }
 }
 
 void OLineEdit::makeCompletion( const QString& text )
 {
     OCompletion *comp = compObj();
     if ( !comp )
         return;  // No completion object...
 
     QString match = comp->makeCompletion( text );
     OGlobalSettings::Completion mode = completionMode();
     if ( mode == OGlobalSettings::CompletionPopup )
     {
         if ( match.isNull() )
         {
             if ( d->completionBox ) {
                 d->completionBox->hide();
                 d->completionBox->clear();
             }
         }
         else
             setCompletedItems( comp->allMatches() );
     }
     else
     {
         // all other completion modes
         // If no match or the same match, simply return without completing.
         if ( match.isNull() || match == text )
             return;
 
         setCompletedText( match );
     }
 }
 
 void OLineEdit::setReadOnly(bool readOnly)
 {
     QPalette p = palette();
     if (readOnly)
     {
         QColor color = p.color(QPalette::Disabled, QColorGroup::Background);
         p.setColor(QColorGroup::Base, color);
         p.setColor(QColorGroup::Background, color);
     }
     else
     {
         QColor color = p.color(QPalette::Normal, QColorGroup::Base);
         p.setColor(QColorGroup::Base, color);
         p.setColor(QColorGroup::Background, color);
     }
     setPalette(p);
 
     QLineEdit::setReadOnly (readOnly);
 }
 
 void OLineEdit::keyPressEvent( QKeyEvent *e )
 {
     qDebug( "OLineEdit::keyPressEvent()" );
     
     /*
     
     KKey key( e );
 
     if ( KStdAccel::copy().contains( key ) ) {
         copy();
         return;
     }
     else if ( KStdAccel::paste().contains( key ) ) {
         paste();
         return;
     }
     else if ( KStdAccel::cut().contains( key ) ) {
         cut();
         return;
     }
     else if ( KStdAccel::undo().contains( key ) ) {
         undo();
         return;
     }
     else if ( KStdAccel::redo().contains( key ) ) {
         redo();
         return;
     }
     else if ( KStdAccel::deleteWordBack().contains( key ) )
     {
         cursorWordBackward(TRUE);
         if ( hasSelectedText() )
             del();
 
         e->accept();
         return;
     }
     else if ( KStdAccel::deleteWordForward().contains( key ) )
     {
         // Workaround for QT bug where
         cursorWordForward(TRUE);
         if ( hasSelectedText() )
             del();
 
         e->accept();
         return;
     }
     */
     
     // Filter key-events if EchoMode is normal &
     // completion mode is not set to CompletionNone
     if ( echoMode() == QLineEdit::Normal &&
          completionMode() != OGlobalSettings::CompletionNone )
     {
         KeyBindingMap keys = getKeyBindings();
         OGlobalSettings::Completion mode = completionMode();
         bool noModifier = (e->state() == NoButton || e->state()== ShiftButton);
 
         if ( (mode == OGlobalSettings::CompletionAuto ||
               mode == OGlobalSettings::CompletionMan) && noModifier )
         {
             QString keycode = e->text();
             if ( !keycode.isNull() && keycode.unicode()->isPrint() )
             {
                 QLineEdit::keyPressEvent ( e );
                 QString txt = text();
                 int len = txt.length();
-                #if QT_VERSION > 290
+                #if QT_VERSION >= 0x030000
                 if ( !hasSelectedText() && len && cursorPosition() == len )
                 #else
                 if ( !hasMarkedText() && len && cursorPosition() == len )
                 #endif
                 {
                     if ( emitSignals() )
                         emit completion( txt );
                     if ( handleSignals() )
                         makeCompletion( txt );
                     e->accept();
                 }
                 return;
             }
         }
 
         else if ( mode == OGlobalSettings::CompletionPopup && noModifier )
         {
             qDebug( "OLineEdit::keyPressEvent() - global settings = CompletionPopup & noModifier" );
 
             QString old_txt = text();
             QLineEdit::keyPressEvent ( e );
             QString txt = text();
             int len = txt.length();
             QString keycode = e->text();
 
 
             if ( txt != old_txt && len && cursorPosition() == len &&
                  ( (!keycode.isNull() && keycode.unicode()->isPrint()) ||
                    e->key() == Key_Backspace ) )
             {
                 if ( emitSignals() )
                     emit completion( txt ); // emit when requested...
                 if ( handleSignals() )
                     makeCompletion( txt );  // handle when requested...
                 e->accept();
             }
             else if (!len && d->completionBox && d->completionBox->isVisible())
                 d->completionBox->hide();
 
             return;
         }
 
         /*else if ( mode == OGlobalSettings::CompletionShell )
         {
             // Handles completion.
             KShortcut cut;
             if ( keys[TextCompletion].isNull() )
                 cut = KStdAccel::shortcut(KStdAccel::TextCompletion);
             else
                 cut = keys[TextCompletion];
 
             if ( cut.contains( key ) )
             {
                 // Emit completion if the completion mode is CompletionShell
                 // and the cursor is at the end of the string.
                 QString txt = text();
                 int len = txt.length();
                 if ( cursorPosition() == len && len != 0 )
                 {
                     if ( emitSignals() )
                         emit completion( txt );
                     if ( handleSignals() )
                         makeCompletion( txt );
                     return;
                 }
             }
             else if ( d->completionBox )
                 d->completionBox->hide();
         }
 
         // handle rotation
         if ( mode != OGlobalSettings::CompletionNone )
         {
             // Handles previous match
             KShortcut cut;
             if ( keys[PrevCompletionMatch].isNull() )
                 cut = KStdAccel::shortcut(KStdAccel::PrevCompletion);
             else
                 cut = keys[PrevCompletionMatch];
 
             if ( cut.contains( key ) )
             {
                 if ( emitSignals() )
                     emit textRotation( OCompletionBase::PrevCompletionMatch );
                 if ( handleSignals() )
                     rotateText( OCompletionBase::PrevCompletionMatch );
                 return;
             }
 
             // Handles next match
             if ( keys[NextCompletionMatch].isNull() )
                 cut = KStdAccel::key(KStdAccel::NextCompletion);
             else
                 cut = keys[NextCompletionMatch];
 
             if ( cut.contains( key ) )
             {
                 if ( emitSignals() )
                     emit textRotation( OCompletionBase::NextCompletionMatch );
                 if ( handleSignals() )
                     rotateText( OCompletionBase::NextCompletionMatch );
                 return;
             }
         }
 
         // substring completion
         if ( compObj() )
         {
             KShortcut cut;
             if ( keys[SubstringCompletion].isNull() )
                 cut = KStdAccel::shortcut(KStdAccel::SubstringCompletion);
             else
                 cut = keys[SubstringCompletion];
 
             if ( cut.contains( key ) )
             {
                 if ( emitSignals() )
                     emit substringCompletion( text() );
                 if ( handleSignals() )
                 {
                     setCompletedItems( compObj()->substringCompletion(text()));
                     e->accept();
                 }
                 return;
             }
         } */
     }   
 
     // Let QLineEdit handle any other keys events.
     QLineEdit::keyPressEvent ( e );
 }
 
 void OLineEdit::mouseDoubleClickEvent( QMouseEvent* e )
 {
     if ( e->button() == Qt::LeftButton  )
     {
         possibleTripleClick=true;
         QTimer::singleShot( QApplication::doubleClickInterval(),this,
                             SLOT(tripleClickTimeout()) );
     }
     QLineEdit::mouseDoubleClickEvent( e );
 }
 
 void OLineEdit::mousePressEvent( QMouseEvent* e )
 {
     if ( possibleTripleClick && e->button() == Qt::LeftButton )
     {
         selectAll();
         return;
     }
     QLineEdit::mousePressEvent( e );
 }
 
 void OLineEdit::tripleClickTimeout()
 {
     possibleTripleClick=false;
 }
 
 QPopupMenu *OLineEdit::createPopupMenu()
 {
     // Return if popup menu is not enabled !!
     if ( !m_bEnableMenu )
         return 0;
 
-    #if QT_VERSION > 290
+    #if QT_VERSION >= 0x030000
     QPopupMenu *popup = QLineEdit::createPopupMenu();
     #else
     QPopupMenu *popup = new QPopupMenu();
     #warning OLineEdit is not fully functional on Qt2
     #endif
 
     // completion object is present.
     if ( compObj() )
     {
         QPopupMenu *subMenu = new QPopupMenu( popup );
         connect( subMenu, SIGNAL( activated(int) ),
                  this, SLOT( completionMenuActivated(int) ) );
 
         popup->insertSeparator();
         //popup->insertItem( SmallIconSet("completion"), i18n("Text Completion"),
         //                   subMenu );
 
         popup->insertItem( tr("Text Completion"), subMenu );
 
         subMenu->insertItem( tr("None"), NoCompletion );
         subMenu->insertItem( tr("Manual"), ShellCompletion );
         subMenu->insertItem( tr("Automatic"), AutoCompletion );
         subMenu->insertItem( tr("Dropdown List"), PopupCompletion );
         subMenu->insertItem( tr("Short Automatic"), SemiAutoCompletion );
 
         //subMenu->setAccel( KStdAccel::completion(), ShellCompletion );
         subMenu->setAccel( Key_Tab, ShellCompletion );
 
         OGlobalSettings::Completion mode = completionMode();
         subMenu->setItemChecked( NoCompletion,
                                  mode == OGlobalSettings::CompletionNone );
         subMenu->setItemChecked( ShellCompletion,
                                  mode == OGlobalSettings::CompletionShell );
         subMenu->setItemChecked( PopupCompletion,
                                  mode == OGlobalSettings::CompletionPopup );
         subMenu->setItemChecked( AutoCompletion,
                                  mode == OGlobalSettings::CompletionAuto );
         subMenu->setItemChecked( SemiAutoCompletion,
                                  mode == OGlobalSettings::CompletionMan );
         if ( mode != OGlobalSettings::completionMode() )
         {
             subMenu->insertSeparator();
             subMenu->insertItem( tr("Default"), Default );
         }
     }
     // ### do we really need this?  Yes, Please do not remove!  This
     // allows applications to extend the popup menu without having to
     // inherit from this class! (DA)
     emit aboutToShowContextMenu( popup );
 
     return popup;
 }
 
 void OLineEdit::completionMenuActivated( int id )
 {
     OGlobalSettings::Completion oldMode = completionMode();
 
     switch ( id )
     {
         case Default:
            setCompletionMode( OGlobalSettings::completionMode() ); break;
         case NoCompletion:
            setCompletionMode( OGlobalSettings::CompletionNone ); break;
         case AutoCompletion:
             setCompletionMode( OGlobalSettings::CompletionAuto ); break;
         case SemiAutoCompletion:
             setCompletionMode( OGlobalSettings::CompletionMan ); break;
         case ShellCompletion:
             setCompletionMode( OGlobalSettings::CompletionShell ); break;
         case PopupCompletion:
             setCompletionMode( OGlobalSettings::CompletionPopup ); break;
         default: return;
     }
 
     if ( oldMode != completionMode() )
     {
         if ( oldMode == OGlobalSettings::CompletionPopup &&
              d->completionBox && d->completionBox->isVisible() )
             d->completionBox->hide();
         emit completionModeChanged( completionMode() );
     }
 }
 
 /*void OLineEdit::dropEvent(QDropEvent *e)
 {
     KURL::List urlList;
     if( d->handleURLDrops && KURLDrag::decode( e, urlList ) )
     {
         QString dropText = text();
         KURL::List::ConstIterator it;
         for( it = urlList.begin() ; it != urlList.end() ; ++it )
         {
             if(!dropText.isEmpty())
                 dropText+=' ';
 
             dropText += (*it).prettyURL();