/****************************************************************************
**
** Copyright (C) 2008-2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (developer.feedback@nokia.com)
**
** This file is part of the HbWidgets module of the UI Extensions for Mobile.
**
** GNU Lesser General Public License Usage
** This file may be used under the terms of the GNU Lesser General Public
** License version 2.1 as published by the Free Software Foundation and
** appearing in the file LICENSE.LGPL included in the packaging of this file.
** Please review the following information to ensure the GNU Lesser General
** Public License version 2.1 requirements will be met:
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights.  These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at developer.feedback@nokia.com.
**
****************************************************************************/

#include "hbcombobox_p.h"

#include <hblistview.h>
#include <hbabstractviewitem.h>
#include <hbdeviceprofile.h>
#include <hbtoucharea.h>
#include <hbmainwindow.h>
#include <hbview.h>
#include <hbtextitem.h>
#include <hbstyleoptioncombobox_p.h>
#include <hbgraphicsscene.h>
#include <hbinputeditorinterface.h>

#include <QSortFilterProxyModel>
#include <QCompleter>
#include <QItemSelectionModel>
#include <QApplication>


#ifdef HB_EFFECTS
#include <hbeffect.h>
#include "hbeffectinternal_p.h"
#define HB_DROPD0WN_ITEM_TYPE "HB_DROPDOWN"
#endif

#include <hbtapgesture.h>

HbComboBoxPrivate::HbComboBoxPrivate( ):
    HbWidgetPrivate ( ),
    mLineEdit ( 0 ),
    mTextItem ( 0 ),
    mButton ( 0 ),
    mDropDown ( 0 ),
    mModel ( 0 ),
    mProxyModel ( 0 ),
    mCompleter ( 0 ),
    insertPolicy ( HbComboBox::InsertAtBottom ),
    mBackgroundItem ( 0 ),
    mButtonTouchAreaItem ( 0 ),
    mIsDown ( false ),
    mEditable ( false ),
    mIsDorpdownCreated( false ),
    mIsDropwnToSceneAdded( false ),
    mHasDownEffect ( false ),
    mHasUpEffect ( false ),
    mListItemHeight( -1 ),
    mDropDownRowsInPortrait( -1 ),
    mDropDownRowsInLandscape( -1 )
{
}

HbComboBoxPrivate::~HbComboBoxPrivate( )
{
    Q_Q( HbComboBox );
    if( mButtonTouchAreaItem ) {
        static_cast<HbTouchArea*>( mButtonTouchAreaItem )->removeEventFilter( q );
    }

    if ( !mDropDown ) {
        return;
    }

    //if drop down is added to scene then remove it from scene so that scene does not deletes
    //drop down again
    if( mDropDown->scene() ) {
        q->scene()->removeItem(mDropDown);
    }

    delete mDropDown;
    mDropDown = 0;
}

void HbComboBoxPrivate::init( )
{
    createPrimitives( );
}

void HbComboBoxPrivate::createPrimitives( )
{
    Q_Q( HbComboBox );

    mTextItem = HbStylePrivate::createPrimitive( HbStylePrivate::P_ComboBox_text, q );
    HbStyle::setItemName( mTextItem, "combobox_labelfield" );

    mBackgroundItem = HbStylePrivate::createPrimitive( HbStylePrivate::P_ComboBox_background, q );
    HbStyle::setItemName( mBackgroundItem, "text_background" );

    mButton = HbStylePrivate::createPrimitive( HbStylePrivate::P_ComboBox_button, q );
    HbStyle::setItemName( mButton, "combobox_button" );

    mButtonTouchAreaItem = HbStylePrivate::createPrimitive( HbStylePrivate::P_ComboBoxButton_toucharea, q );

    static_cast<HbTouchArea*>( mButtonTouchAreaItem )->grabGesture( Qt::TapGesture );
}

void HbComboBoxPrivate::touchAreaPressEvent( )
{    
    Q_Q( HbComboBox );
    if ( q->count( ) > 0 ) {
        HbWidgetFeedback::triggered( q, Hb::InstantPressed );
    }
    mIsDown = true;
    q->updatePrimitives( );
    //Update the state only when valid model is there
    if ( mModel && mModel->rowCount( ) ) {
        q->setProperty( "state", "pressed" );
    }
}

void HbComboBoxPrivate::touchAreaReleaseEvent(  )
{
    Q_Q( HbComboBox );
    mIsDown = false;
    touchAreaClicked( );
    q->updatePrimitives( );
    if ( q->count( ) > 0 ) {
        HbWidgetFeedback::triggered( q, Hb::InstantReleased );
    }

}

void HbComboBoxPrivate::touchAreaClicked( )
{
    Q_Q( HbComboBox );
    if ( mModel && mModel->rowCount( ) ) {
        addDropDownToScene( );
        mDropDown->setVisible( true );
        q->setProperty( "state", "latched" );
        if( !mDropDown->mList ) {
            mDropDown->createList( );
            mDropDown->mList->setModel( mModel );
            q->connect( mDropDown->mList, SIGNAL( activated( QModelIndex ) ), q,
                SLOT( _q_textChanged( QModelIndex ) ) );
            //send layout request so that geometries of list view item are updated
            //and proper height is fetched in calculateListItemHeight
            QEvent layoutEvent(QEvent::LayoutRequest);
            QApplication::sendEvent(mDropDown->mList->contentWidget(), &layoutEvent);
        }
        if ( mCurrentIndex.isValid( ) ) {
            if( mDropDown->mList->model( ) != mModel ) {
                mDropDown->mList->setModel( mModel );
            }
            mDropDown->mList->scrollTo( mCurrentIndex, HbAbstractItemView::PositionAtTop );
            mDropDown->mList->setCurrentIndex( mCurrentIndex, QItemSelectionModel::Select );
        } else {
            if( mDropDown->mList->model( ) != mModel ) {
                mDropDown->mList->setModel( mModel );
            }
            mDropDown->mList->scrollTo( mModel->index( 0, 0 ) );
            mDropDown->mList->setCurrentIndex( 
                mModel->index( 0, 0 ), QItemSelectionModel::Select );
        }
        positionDropDown( );
        #ifdef HB_EFFECTS
        HbEffect::start( mDropDown, HB_DROPD0WN_ITEM_TYPE, "appear" );
        #endif
    }
}

void HbComboBoxPrivate::vkbOpened( )
{

}

void HbComboBoxPrivate::vkbClosed( )
{
    if( mDropDown->isVisible( ) ) {
        positionDropDown( );
    }
}

void HbComboBoxPrivate::showPopup( QAbstractItemModel *aModel, QModelIndex aIndex )
{
    Q_Q( HbComboBox );
    if ( aModel && aModel->rowCount( ) ) {
        addDropDownToScene( );
        if( !mDropDown->mList ) {
            mDropDown->createList( );
            q->connect( mDropDown->mList, SIGNAL( activated( QModelIndex ) ), q,
                SLOT( _q_textChanged( QModelIndex ) ) );
        }
        mDropDown->mList->setModel( aModel );
        if ( aIndex.isValid( ) ) {
            mDropDown->mList->scrollTo( aIndex, HbAbstractItemView::PositionAtTop );
            mDropDown->mList->setCurrentIndex( mCurrentIndex, QItemSelectionModel::Select );
        } else {
            mDropDown->mList->scrollTo( aModel->index( 0, 0 ) );
        }
        positionDropDown( );
        if( !mDropDown->isVisible( ) ) {
            mDropDown->setVisible( true );
            #ifdef HB_EFFECTS
            HbEffect::start( mDropDown, HB_DROPD0WN_ITEM_TYPE, "appear" );
            #endif
        }
    }
}

void HbComboBoxPrivate::createDropDown( )
{
    Q_Q ( HbComboBox );
    if( !mIsDorpdownCreated ) {
        mDropDown = new HbComboDropDown( this );
        mIsDorpdownCreated = true;
        mDropDown->setVisible( false );
        q->setProperty( "state", "normal" );
    }
}

void HbComboBoxPrivate::calculateListItemHeight( )
{
    QAbstractItemModel *model = mDropDown->mList->model( );
    if( mCurrentIndex.isValid( ) && mDropDown->mList->itemByIndex( mCurrentIndex ) ) {
        mListItemHeight = mDropDown->mList->itemByIndex( mCurrentIndex )->geometry( ).height( );
    } else if( model->index( 0, 0 ).isValid( ) && 
        mDropDown->mList->itemByIndex( model->index( 0, 0 ) ) ) {

        mListItemHeight = 
            mDropDown->mList->itemByIndex( model->index( 0, 0 ) )->geometry( ).height( );
    } else {
        HbListViewItem *proto = mDropDown->mList->listItemPrototype( );
        HbListViewItem *temp = static_cast<HbListViewItem*>( proto->createItem( ) );
        mListItemHeight = temp->effectiveSizeHint( Qt::PreferredSize ).height( );
        delete temp;
        temp = 0;
    }
}

void HbComboBoxPrivate::resetGeometryChangeFlag( )
{
    Q_Q( HbComboBox );
    QGraphicsWidget *p = q;
    if( widgetGeometryChange.count() > 0 ) {
        while ( p->parentWidget( ) ) {
            p = p->parentWidget( );
            if ( !widgetGeometryChange.value( p ) ) {
                //if earlier geometry change flag was disabled then disable this flag
                p->setFlag( QGraphicsItem::ItemSendsGeometryChanges, false );
            }
        }
        widgetGeometryChange.clear();
    }
}

void HbComboBoxPrivate::showDismissEffect( )
{
    #ifdef HB_EFFECTS
    HbEffect::start( mDropDown, HB_DROPD0WN_ITEM_TYPE, "disappear", mDropDown, "dismissEffectFinished" );
    #else
    mDropDown->setVisible( false );
    #endif
}

void HbComboBoxPrivate::positionDropDown( )
{
    Q_Q( HbComboBox );
    QRectF popupRect;
    QRectF sceneRect( QPointF( ), HbDeviceProfile::profile( q ).logicalSize( ) );
    QPointF widgetPos = q->scenePos( );
    QAbstractItemModel *model = mDropDown->mList->model( );
    calculateListItemHeight( );
    qreal totalHeightRequd = model->rowCount( ) * mListItemHeight;
    qreal maxPopupHeight = 0.0;

    //calculate the maximum popup height for different orientation
    if( q->mainWindow( )->orientation( ) == Qt::Horizontal ) {
        maxPopupHeight = mDropDownRowsInLandscape * mListItemHeight;
    } else if( q->mainWindow( )->orientation( ) == Qt::Vertical ) {
        maxPopupHeight = mDropDownRowsInPortrait * mListItemHeight;
    }

    if ( totalHeightRequd < maxPopupHeight ) {
        maxPopupHeight = totalHeightRequd;
    }
    QSizeF popupSize = QSizeF( q->rect( ).width( ), maxPopupHeight );
    QPointF popupPos;

    HbEditorInterface editorInterface( q );
    HbVkbHost *host = editorInterface.vkbHost( );

    if( host && ( host->keypadStatus( ) == HbVkbHost::HbVkbStatusOpened ) ) {
        // case when vkb is visible
        // positioning drop down when vkb is positioned
        // drop down will come on top/below of combo based upon which side has more space
        // available 
        QSizeF keyBoardArea = host->keyboardArea( );
        QSize screenSize = HbDeviceProfile::profile( q ).logicalSize( );

        qreal heightDifference = screenSize.height( ) - keyBoardArea.height( );
        qreal topSpace = widgetPos.y( );
        qreal bottomSpace = heightDifference - topSpace - q->boundingRect( ).height( );

        if( topSpace > bottomSpace ) {
            //display drop down at top
            if( widgetPos.y( ) - maxPopupHeight  > 0.0 ) {
                popupPos = QPointF( widgetPos.x( ), widgetPos.y( ) - maxPopupHeight );
            } else {
                popupPos = QPointF( widgetPos.x( ), 0.0 );
                popupSize.setHeight( topSpace );
            }
            #ifdef HB_EFFECTS
            if ( !mHasUpEffect ) {
                 mHasUpEffect = true;
                 mHasDownEffect = false;
                 //this Effect will be shown when there is more space in the view bottom.
                 HbEffectInternal::add( mDropDown, "combo_appear_up", "appear" );
                 HbEffectInternal::add( mDropDown, "combo_disappear_up", "disappear" );
            }
            #endif
        } else {
            //display drop down at bottom
            popupPos = QPointF( widgetPos.x( ), widgetPos.y( ) + q->rect( ).height( ) );
            if( bottomSpace < maxPopupHeight ) {
                popupSize.setHeight( bottomSpace );
            }
            #ifdef HB_EFFECTS
            if ( !mHasDownEffect ) {
                mHasDownEffect = true;
                mHasUpEffect = false;
                //this Effect will be shown when there is more space in the view bottom.
                HbEffectInternal::add( mDropDown, "combo_appear_down", "appear" );
                HbEffectInternal::add( mDropDown, "combo_disappear_down", "disappear" );
            }
            #endif
        }
    } else {
        //this is the case when vkb is not visible

        //position of drop down in both editable and non-editable combobox depends upon
        //the available space above and below combobox
        if( ( widgetPos.y( ) + q->rect( ).height( ) + maxPopupHeight) < sceneRect.height( ) ) {
            popupPos = QPointF( widgetPos.x( ), widgetPos.y( ) + q->rect( ).height( ) );
            #ifdef HB_EFFECTS
            if ( !mHasDownEffect ) {
                 mHasDownEffect = true;
                 mHasUpEffect = false;
                 //this Effect will be shown when there is space in the view bottom.
                 HbEffectInternal::add( mDropDown, "combo_appear_down", "appear" );
                 HbEffectInternal::add( mDropDown, "combo_disappear_down", "disappear" );
            }
            #endif
        } else if( widgetPos.y( ) - maxPopupHeight  > 0.0 ) {
            popupPos = QPointF( widgetPos.x( ), widgetPos.y( ) - maxPopupHeight );
            #ifdef HB_EFFECTS
            if ( !mHasUpEffect ) {
                 //this Effect will be shown when there is no space in the view bottom
                 mHasUpEffect = true;
                 mHasDownEffect = false;
                 HbEffectInternal::add( mDropDown, "combo_appear_up", "appear" );
                 HbEffectInternal::add( mDropDown, "combo_disappear_up", "disappear" );
            }
            #endif
        } else {
            qreal topScreenHeight = sceneRect.height( ) - maxPopupHeight;
            if( topScreenHeight > sceneRect.height( ) - topScreenHeight ) {
                popupPos = QPointF( widgetPos.x( ), 0.0 );
                #ifdef HB_EFFECTS
                if ( !mHasDownEffect ) {
                    mHasDownEffect = true;
                    mHasUpEffect = false;
                    //this Effect will be shown when there is more space in the view bottom.
                    HbEffectInternal::add( mDropDown, "combo_appear_down", "appear" );
                    HbEffectInternal::add( mDropDown, "combo_disappear_down", "disappear" );
                }
                #endif
            } else {
                popupPos = QPointF( widgetPos.x( ), sceneRect.height( ) - maxPopupHeight );
                #ifdef HB_EFFECTS
                if ( !mHasUpEffect ) {
                     mHasUpEffect = true;
                     mHasDownEffect = false;
                     //this Effect will be shown when there is more space in the view bottom.
                     HbEffectInternal::add( mDropDown, "combo_appear_up", "appear" );
                     HbEffectInternal::add( mDropDown, "combo_disappear_up", "disappear" );
                }
                #endif
            }
        }
    }
    mDropDown->setPreferredSize( popupSize );
    mDropDown->setMinimumSize( popupSize );
    mDropDown->setMaximumSize( popupSize );
    mDropDown->setPos( popupPos );
    QGraphicsWidget *p = q;
    while ( p->parentWidget( ) ) {
        p = p->parentWidget( );
        //cache the original geometry change flag of parent widget
        QGraphicsItem::GraphicsItemFlags itemFlags = p->flags( );
        bool geometryFlagEnabled =  itemFlags & QGraphicsItem::ItemSendsGeometryChanges;
        widgetGeometryChange.insert(p, geometryFlagEnabled);

        //This flag is being set since geometry change notification is required for properly
        //positioning drop down when its visible and combobox position is changed for example
        //when orientation change happens.
        p->setFlag( QGraphicsItem::ItemSendsGeometryChanges );
    }
    mDropDown->setZValue( p->zValue( ) + 1 );
}

void HbComboBoxPrivate::_q_textChanged( const QModelIndex & aIndex )
{
    Q_Q( HbComboBox );
    QVariant data = mDropDown->mList->model( )->data( aIndex );
    mText = data.toString( );
    if( !mEditable ) {
        if( mLineEdit ) {
            mLineEdit->setText( mText );
        } else {
            HbStyleOptionComboBox comboBoxOption;
            q->initStyleOption( &comboBoxOption );
            HbStylePrivate::updatePrimitive( mTextItem, HbStylePrivate::P_ComboBox_text, &comboBoxOption );
        }
        mCurrentIndex = aIndex;
    } else {
       q->disconnect( mLineEdit, SIGNAL( textChanged ( QString ) ), q,
           SLOT( _q_textChanged( QString ) ) );
       mLineEdit->setText( mText );
       mCurrentIndex = findData( mText );
       q->connect( mLineEdit, SIGNAL( textChanged ( QString ) ), q, 
           SLOT( _q_textChanged( QString ) ) );
    }
    if ( mDropDown->isVisible( ) ) {
        showDismissEffect( );
        q->setProperty( "state", "normal" );
    }
    currentIndexChanged( mCurrentIndex );
}

void HbComboBoxPrivate::_q_textCompleted( const QModelIndex & aIndex )
{
    if( aIndex.isValid( ) ) {
        showPopup( mCompleter->completionModel( ) );
    }
}

void HbComboBoxPrivate::_q_textChanged( const QString & aString )
{
    Q_Q( HbComboBox );

    if( !aString.isEmpty( ) ) {
        if ( mCompleter ) {
            mCompleter->setCompletionPrefix( aString );
            mCompleter->complete( );
            if( mCompleter->currentRow( ) == -1 ) {
                if ( ( mDropDown ) && ( mDropDown->isVisible( ) ) ) {
                    mDropDown->setVisible( false );
                }
            }
        }
    } else {
        if( mDropDown ) {
            showDismissEffect( );
        }
        //showPopup( mModel, mCurrentIndex);
    }
    emit q->editTextChanged( aString );
}

void HbComboBoxPrivate::setModel( QAbstractItemModel * model )
{
    Q_Q ( HbComboBox );
    createDropDown( );    
    if ( mDropDown->isVisible( ) ) {
        mDropDown->setVisible( false );
        q->setProperty( "state", "normal" );
    }
    q->clear( );
    delete mModel;
    mModel = model;
    mModel->setParent( q );
    setCompletion( mEditable );
    if( mModel->rowCount( ) ) {
        q->setCurrentIndex( 0 );
    }
}

void HbComboBoxPrivate::setCompletion( bool completion )
{
    Q_Q( HbComboBox );
    if ( completion ) {
        if ( mCompleter ) {
            mProxyModel->setSourceModel( mModel );
            mProxyModel->sort( Qt::AscendingOrder );
            mCompleter->setModel( mProxyModel );
        } else {
            mProxyModel = new QSortFilterProxyModel( q );
            mProxyModel->setDynamicSortFilter( true );
            mProxyModel->setSortCaseSensitivity( Qt::CaseInsensitive );
            mProxyModel->setSourceModel( mModel );
            mProxyModel->sort( Qt::AscendingOrder );
            mCompleter = new QCompleter( mProxyModel, q );
            mCompleter->setCaseSensitivity( Qt::CaseInsensitive );
            mCompleter->setCompletionRole( Qt::DisplayRole );
            mCompleter->setCompletionMode( QCompleter::InlineCompletion );
            q->connect( mCompleter, SIGNAL( highlighted( QModelIndex ) ), q, 
                SLOT( _q_textCompleted( QModelIndex ) ) );
        }
    } else {
        if ( mCompleter ) {
            delete mCompleter;
            mCompleter = 0;
        }
        if ( mProxyModel ) {
            delete mProxyModel;
            mProxyModel = 0;
        }
    }
}

void HbComboBoxPrivate::setEditable(  bool editable )
{
    Q_Q( HbComboBox );
    if( mEditable == editable ) {
        return;
    }
    mEditable = editable;
    if( editable ) {
        if( mTextItem ) {
            HbStyle::setItemName( mTextItem, "" );
            delete mTextItem;
            mTextItem = 0;
            mLineEdit = new HbCustomLineEdit( q, this );
            q->connect( mLineEdit, SIGNAL( editingFinished( ) ), q, SIGNAL( editingFinished( ) ) );
            HbStyle::setItemName( mLineEdit, "combobox_labelfield" );
            mLineEdit->backgroundItem( )->setVisible( false );
        }
        q->setHandlesChildEvents( false );
        mLineEdit->setReadOnly( false );
        mLineEdit->setCursorVisibility( Hb::TextCursorVisible );
        q->repolish( );
        q->connect( mLineEdit, SIGNAL( textChanged ( QString ) ),
            q, SLOT( _q_textChanged( QString ) ) );
        setCompletion( true );
    } else {
        q->disconnect( mLineEdit, SIGNAL( textChanged ( QString ) ),
            q, SLOT( _q_textChanged( QString ) ) );
        q->setHandlesChildEvents( true );
        mLineEdit->setReadOnly( true );
        setCompletion( false );
        mLineEdit->setCursorVisibility( Hb::TextCursorHidden );
        if( mModel && mModel->rowCount( ) ) {
            QModelIndex mi = mModel->index( 0, 0 );
            if( mi.isValid( ) ) {
                mCurrentIndex = QModelIndex( mi );
                mText = q->itemText( mCurrentIndex.row( ) );
                mLineEdit->setText( mText );
            }
        }
        q->repolish( );
    }
}

QString HbComboBoxPrivate::itemText( const QModelIndex &index ) const
{
    return mModel->data( index, itemRole( ) ).toString( );
}

QIcon HbComboBoxPrivate::itemIcon( const QModelIndex &index ) const
{
    QVariant decoration = mModel->data( index, Qt::DecorationRole );
    if ( decoration.type( ) == QVariant::Icon ) {
        return QIcon( qvariant_cast<QIcon>( decoration ) );
    }
    return qvariant_cast<QIcon>( decoration );
}

int HbComboBoxPrivate::itemRole( ) const
{
    return q_func( )->isEditable( ) ? Qt::EditRole : Qt::DisplayRole;
}

void HbComboBoxPrivate::addDropDownToScene( )
{
    Q_Q( HbComboBox );
    if( !mIsDropwnToSceneAdded ) {
        if ( q->scene( ) ) {
            q->scene( )->addItem( mDropDown );
        }
        HbGraphicsScene *scene1 = static_cast<HbGraphicsScene*>( mDropDown->scene( ) );
        if( scene1 ) {
            scene1->installEventFilter( mDropDown );
            //scene1->grabGesture( Qt::TapGesture );
        }
        mIsDropwnToSceneAdded = true;
    }
}
void HbComboBoxPrivate::setCurrentIndex( const QModelIndex &mi )
{
    Q_Q( HbComboBox );
    bool indexChanged = ( mi != mCurrentIndex );
    if ( indexChanged ) {
        mCurrentIndex = QModelIndex( mi );
        mText = q->itemText( mCurrentIndex.row( ) );
        if( mEditable ) {
            q->disconnect( mLineEdit, SIGNAL( textChanged ( QString ) ), q,
                SLOT( _q_textChanged( QString ) ) );
            mLineEdit->setText( mText );
            q->connect( mLineEdit, SIGNAL( textChanged ( QString ) ),
                q, SLOT( _q_textChanged( QString ) ) );
        } else {
            if( mLineEdit ) {
                mLineEdit->setText( mText );
            } else {
                HbStyleOptionComboBox comboBoxOption;
                q->initStyleOption(&comboBoxOption);
                HbStylePrivate::updatePrimitive(
                    mTextItem, HbStylePrivate::P_ComboBox_text, &comboBoxOption );
            }
        }
        currentIndexChanged( mCurrentIndex );
    }
}

void HbComboBoxPrivate::currentIndexChanged( const QModelIndex &index )
{
    Q_Q( HbComboBox );
    emit q->currentIndexChanged( index.row( ) );
    emit q->currentIndexChanged( q->itemText ( mCurrentIndex.row( ) ) );
}

/*
 Returns the index of the item containing the given \a data for the
 given \a role; otherwise returns QModelIndex.

 The \a flags specify how the items in the combobox are searched.
 */
QModelIndex HbComboBoxPrivate::findData( const QVariant &data ) const
{
    QModelIndexList result;
    if ( mModel ) {
        QModelIndex start = mModel->index( 0, 0 );
        result = mModel->match(
            start, Qt::DisplayRole, data, 1, Qt::MatchExactly|Qt::MatchCaseSensitive );
    }
    if ( result.isEmpty( ) ) {
        return QModelIndex( );
    } else {
        return result.first( );
    }
}

#include "moc_hbcombobox.cpp"
