convert dynamic_cast<> to using QObject::inherits

2 files changed, 7 insertions, 3 deletions

diff --git a/libopie2/qt3/opieui/ocombobox.cpp b/libopie2/qt3/opieui/ocombobox.cpp
index a1dd5f5..8dbda8f 100644
--- a/libopie2/qt3/opieui/ocombobox.cpp
+++ b/libopie2/qt3/opieui/ocombobox.cpp
@@ -131,385 +131,388 @@ void OComboBox::setAutoCompletion( bool autocomplete )
     {
         if ( autocomplete )
         {
             d->olineEdit->setCompletionMode( OGlobalSettings::CompletionAuto );
             setCompletionMode( OGlobalSettings::CompletionAuto );
         }
         else
         {
             d->olineEdit->setCompletionMode( OGlobalSettings::completionMode() );
             setCompletionMode( OGlobalSettings::completionMode() );
         }
     }
 }
 
 void OComboBox::setContextMenuEnabled( bool showMenu )
 {
     if( d->olineEdit )
     {
         d->olineEdit->setContextMenuEnabled( showMenu );
         m_bEnableMenu = showMenu;
     }
 }
 
 /*
 void OComboBox::setURLDropsEnabled( bool enable )
 {
     if ( d->olineEdit )
         d->olineEdit->setURLDropsEnabled( enable );
 }
 
 bool OComboBox::isURLDropsEnabled() const
 {
     return d->olineEdit && d->olineEdit->isURLDropsEnabled();
 }
 */
 
 void OComboBox::setCompletedText( const QString& text, bool marked )
 {
     if ( d->olineEdit )
         d->olineEdit->setCompletedText( text, marked );
 }
 
 void OComboBox::setCompletedText( const QString& text )
 {
     if ( d->olineEdit )
         d->olineEdit->setCompletedText( text );
 }
 
 void OComboBox::makeCompletion( const QString& text )
 {
     if( d->olineEdit )
         d->olineEdit->makeCompletion( text );
 
     else // read-only combo completion
     {
         if( text.isNull() || !listBox() )
             return;
 
         int index = listBox()->index( listBox()->findItem( text ) );
         if( index >= 0 ) {
             setCurrentItem( index );
         }
     }
 }
 
 void OComboBox::rotateText( OCompletionBase::KeyBindingType type )
 {
     if ( d->olineEdit )
         d->olineEdit->rotateText( type );
 }
 
 bool OComboBox::eventFilter( QObject* o, QEvent* ev )
 {
     QLineEdit *edit = lineEdit();
 
     int type = ev->type();
 
     if ( o == edit )
     {
         //OCursor::autoHideEventFilter( edit, ev );
 
         if ( type == QEvent::KeyPress )
         {
             QKeyEvent *e = static_cast<QKeyEvent *>( ev );
 
             if ( e->key() == Key_Return || e->key() == Key_Enter)
             {
                 // On Return pressed event, emit both
                 // returnPressed(const QString&) and returnPressed() signals
                 emit returnPressed();
                 emit returnPressed( currentText() );
                 if ( d->olineEdit && d->olineEdit->completionBox(false) &&
                      d->olineEdit->completionBox()->isVisible() )
                     d->olineEdit->completionBox()->hide();
 
                 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
     QComboBox::setLineEdit( edit );
-    d->olineEdit = dynamic_cast<OLineEdit*>( 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 ( lineEdit()->hasSelectedText() )
     #else
     if ( lineEdit()->hasMarkedText() )
     #endif
     {
         lineEdit()->del();
     }
 }
 
 void OComboBox::deleteWordBack()
 {
     lineEdit()->cursorWordBackward(TRUE);
     #if QT_VERSION > 290
     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();
 }
 
 QStringList OHistoryCombo::historyItems() const
 {
     QStringList list;
     for ( int i = 0; i < count(); i++ )
         list.append( text( i ) );
 
     return list;
 }
 
 void OHistoryCombo::clearHistory()
 {
     OComboBox::clear();
     if ( useCompletion() )
         completionObject()->clear();
 }
 
 void OHistoryCombo::addContextMenuItems( QPopupMenu* menu )
 {
     if ( menu &&!lineEdit()->text().isEmpty())
     {
         menu->insertSeparator();
         menu->insertItem( tr("Empty Contents"), this, SLOT( slotClear()));
     }
 }
 
 void OHistoryCombo::addToHistory( const QString& item )
 {
     if ( item.isEmpty() || (count() > 0 && item == text(0) ))
         return;
 
     // remove all existing items before adding
     if ( !duplicatesEnabled() ) {
         for ( int i = 0; i < count(); i++ ) {
             if ( text( i ) == item )
                 removeItem( i );
         }
     }
 
     // now add the item
     if ( myPixProvider )
         //insertItem( myPixProvider->pixmapFor(item, KIcon::SizeSmall), item, 0);
         insertItem( myPixProvider->pixmapFor(item, 16), item, 0);
     else
         insertItem( item, 0 );
 
     int last;
     QString rmItem;
 
     bool useComp = useCompletion();
     while ( count() > maxCount() && count() > 0 ) {
         // remove the last item, as long as we are longer than maxCount()
         // remove the removed item from the completionObject if it isn't
         // anymore available at all in the combobox.
diff --git a/libopie2/qt3/opieui/oeditlistbox.cpp b/libopie2/qt3/opieui/oeditlistbox.cpp
index 3c53552..0e95274 100644
--- a/libopie2/qt3/opieui/oeditlistbox.cpp
+++ b/libopie2/qt3/opieui/oeditlistbox.cpp
@@ -222,195 +222,196 @@ void OEditListBox::moveItemUp()
     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
             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(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 ));
 
     return list;
 }
 
 void OEditListBox::virtual_hook( int, void* )
 { /*BASE::virtual_hook( id, data );*/ }
 
 
 /*======================================================================================
  * CustomEditor
  *======================================================================================*/
 
 OEditListBox::CustomEditor::CustomEditor( OComboBox *combo )
 {
     m_representationWidget = combo;
-    m_lineEdit = dynamic_cast<OLineEdit*>( combo->lineEdit() );
-    assert( m_lineEdit );
+    assert( combo->lineEdit()->inherits( "OLineEdit" ) );
+    m_lineEdit = static_cast<OLineEdit*>( combo->lineEdit() );
+
 }