/****************************************************************************

**

** 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 <QSortFilterProxyModel>

#include <QCompleter>

#include <QItemSelectionModel>

#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 ),

{

}

HbComboBoxPrivate::~HbComboBoxPrivate( )

{

    Q_Q(HbComboBox);

    if( mButtonTouchAreaItem ) {

    }

        if( mDropDown ) {

            delete mDropDown;

            mDropDown = 0;

        }

    }

}

void HbComboBoxPrivate::init( )

{

    createPrimitives( );

}

void HbComboBoxPrivate::createPrimitives( )

{

    Q_Q( HbComboBox );

    HbStyle::setItemName( mTextItem, "combobox_labelfield" );

    mBackgroundItem = q->style( )->createPrimitive( HbStyle::P_ComboBox_background, q );

    HbStyle::setItemName( mBackgroundItem, "text_background" );

    mButton = q->style( )->createPrimitive( HbStyle::P_ComboBox_button, q );

    HbStyle::setItemName( mButton, "combobox_button" );

    mButtonTouchAreaItem = q->style( )->createPrimitive( 

                                            HbStyle::P_ComboBoxButton_toucharea, q );

    static_cast<HbTouchArea*>(mButtonTouchAreaItem)->installEventFilter( q );

    q->setHandlesChildEvents(true);

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

}

void HbComboBoxPrivate::touchAreaPressEvent( )

{    

    Q_Q( HbComboBox );

    if (q->count() > 0) {

    }

    mIsDown = true;

    q->updatePrimitives( );

}

void HbComboBoxPrivate::touchAreaReleaseEvent(  )

{

    Q_Q( HbComboBox );

    mIsDown = false;

    q->updatePrimitives( );

    }

}

void HbComboBoxPrivate::touchAreaClicked( )

{

    Q_Q( HbComboBox );

    if ( mModel && mModel->rowCount( ) ) {

        mDropDown->setVisible( true );

        if( !mDropDown->mList ) {

            mDropDown->createList( );

            mDropDown->mList->setModel( mModel );            

            q->connect( mDropDown->mList, SIGNAL( activated( QModelIndex ) ), q,

                        SLOT( _q_textChanged( QModelIndex ) ) );

        }

        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 ) );

        }

        #ifdef HB_EFFECTS

        #endif

        positionDropDown( );        

    }

}

void HbComboBoxPrivate::vkbOpened( )

{

}

void HbComboBoxPrivate::vkbClosed()

{

    }

}

{    

    Q_UNUSED( aModel );

    Q_UNUSED( 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 );

        } else {

            mDropDown->mList->scrollTo( aModel->index( 0, 0 ) );

        }

        positionDropDown( );

        mDropDown->setVisible( true );

    }

}

void HbComboBoxPrivate::createDropDown()

{    

    if( !mIsDorpdownCreated ) {

        mDropDown = new HbComboDropDown( this );

        mIsDorpdownCreated = true;

        mDropDown->setVisible(false);

    }

}

void HbComboBoxPrivate::calculateListItemHeight()

{

    }

}

void HbComboBoxPrivate::positionDropDown( )

{

    Q_Q( HbComboBox );

    QRectF popupRect;

    QRectF sceneRect( QPointF( ), HbDeviceProfile::profile( q ).logicalSize( ) );

    QPointF widgetPos = q->scenePos( );

    QAbstractItemModel *model = mDropDown->mList->model( );

    qreal totalHeightRequd = model->rowCount( ) * mListItemHeight;

    qreal maxPopupHeight = 0.0;

    }

    if ( totalHeightRequd < maxPopupHeight ) {

        maxPopupHeight = totalHeightRequd;

    }

    QSizeF popupSize = QSizeF( q->rect( ).width( ), maxPopupHeight );

    QPointF popupPos;

    if( !mDropDown->vkbOpened ) {

        //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( ) ) {

            #ifdef HB_EFFECTS

                if ( !mHasDownEffect ) {

                     mHasDownEffect = true;

                     mHasUpEffect = false;

                     // this is temporary until proper effect theming comes.

                     //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_downl", "disappear" );

                }

            #endif

            #ifdef HB_EFFECTS

                if ( !mHasUpEffect ) {

                     // this is temporary until proper effect theming comes.

                     //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" );

                }

            #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 is temporary until proper effect theming comes.

                     //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 is temporary until proper effect theming comes.

                         //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 {

        // positioning drop down when vkb is positioned

        // drop down will come on top/below of combo based upon which side has more space

        // available 

        if ( host ) {

            if( topSpace > bottomSpace ) {

                //display drop down at top

                } else {

                    popupSize.setHeight( topSpace );

                }

                #ifdef HB_EFFECTS

                    if ( !mHasUpEffect ) {

                         mHasUpEffect = true;

                         mHasDownEffect = false;

                         // this is temporary until proper effect theming comes.

                         //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

                if( bottomSpace < maxPopupHeight ) {

                    popupSize.setHeight( bottomSpace );

                }

                #ifdef HB_EFFECTS

                    if ( !mHasDownEffect ) {

                         mHasDownEffect = true;

                         mHasUpEffect = false;

                     // this is temporary until proper effect theming comes.

                     //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

            }

        }

    }

    mDropDown->setPreferredSize( popupSize );

    mDropDown->setMinimumSize( popupSize );

    mDropDown->setMaximumSize( popupSize );

    mDropDown->setPos(popupPos);

    }

    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;

        }

        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( ) ) {

        mDropDown->setVisible( false );

    }

    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 (( mDropDown ) && ( mDropDown->isVisible() )) {

                    mDropDown->setVisible(false);

                }

            }

        }

    } else {

    }

    emit q->editTextChanged( aString );

}

void HbComboBoxPrivate::setModel( QAbstractItemModel * model )

{

    Q_Q ( HbComboBox );

    createDropDown( );    

    if ( mDropDown->isVisible( ) ) {

        mDropDown->setVisible( false );

    }

    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( mTextItem ) {

            HbStyle::setItemName( mTextItem, "" );

            delete mTextItem;

            mTextItem = 0;

            mLineEdit = new HbCustomLineEdit( q, this );

            HbStyle::setItemName( mLineEdit, "combobox_labelfield" );

            mLineEdit->backgroundItem()->setVisible(false);

        }

        q->setHandlesChildEvents( false );

        mLineEdit->setReadOnly( false );

        mLineEdit->setCursorVisibility( Hb::TextCursorVisible );

        mLineEdit->setLongPressEnabled( );

        q->repolish( );

        q->connect( mLineEdit, SIGNAL( textChanged ( QString ) ),