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

**

** 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 <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( ):

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

    mHasDownEffect ( false ),

    mListItemHeight( -1 ),

    mDropDownRowsInPortrait( -1 ),

    mDropDownRowsInLandscape( -1 )

{

}

HbComboBoxPrivate::~HbComboBoxPrivate( )

{

    if( mButtonTouchAreaItem ) {

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

    }

        if( mDropDown ) {

            delete mDropDown;

            mDropDown = 0;

        }

    }

}

void HbComboBoxPrivate::init( )

{

    createPrimitives( );

}

void HbComboBoxPrivate::createPrimitives( )

{

    Q_Q( HbComboBox );

    mTextItem = q->style( )->createPrimitive( HbStyle::P_ComboBox_text, q );

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

}

void HbComboBoxPrivate::touchAreaPressEvent( )

{    

    Q_Q( HbComboBox );

        HbWidgetFeedback::triggered( q, Hb::InstantPressed );

    }

    mIsDown = true;

    q->updatePrimitives( );

}

void HbComboBoxPrivate::touchAreaReleaseEvent(  )

{

    Q_Q( HbComboBox );

    mIsDown = false;

    touchAreaClicked( );

    q->updatePrimitives( );

        HbWidgetFeedback::triggered( q, Hb::InstantReleased );

    }

    q->setProperty( "state", "normal" ); 

}

void HbComboBoxPrivate::touchAreaClicked( )

{

    Q_Q( HbComboBox );

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

        addDropDownToScene( );

        mDropDown->setVisible( true );

        if( !mDropDown->mList ) {

            mDropDown->createList( );

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

        }

        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

    }

}

void HbComboBoxPrivate::vkbOpened( )

{

}

{

    if( mDropDown->isVisible( ) ) {

        positionDropDown( );

    }

}

void HbComboBoxPrivate::showPopup( QAbstractItemModel *aModel, QModelIndex aIndex )

    Q_Q( HbComboBox );

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

        if( !mDropDown->mList ) {

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

        }

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

        mDropDown->setVisible( true );

    }

}

    if( !mIsDorpdownCreated ) {

        mDropDown = new HbComboDropDown( this );

        mIsDorpdownCreated = true;

    }

}

{

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

    if( mCurrentIndex.isValid( ) && mDropDown->mList->itemByIndex( mCurrentIndex ) ) {

        mListItemHeight = mDropDown->mList->itemByIndex( mCurrentIndex )->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::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;

    //read the maximum rows in drop down for different orientation from css

        if( mDropDownRowsInLandscape == -1 ) {

            HbStyleParameters params;

            q->style( )->parameters( params );

            params.addParameter( "max-rows-in-dropdown" );

            q->polish( params );

            mDropDownRowsInLandscape = params.value( "max-rows-in-dropdown" ).toInt( );

        }

        maxPopupHeight = mDropDownRowsInLandscape * mListItemHeight;

        if( mDropDownRowsInPortrait == -1 ) {

            HbStyleParameters params;

            params.addParameter( "max-rows-in-dropdown" );

            q->polish( params );

        }

        maxPopupHeight = mDropDownRowsInPortrait * mListItemHeight;

    }

    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

            #ifdef HB_EFFECTS

            #endif

        } else if( widgetPos.y( ) - maxPopupHeight  > 0.0 ) {

            popupPos = QPointF( widgetPos.x( ), widgetPos.y( ) - maxPopupHeight );

            #ifdef HB_EFFECTS

            #endif

        } else {

            qreal topScreenHeight = sceneRect.height( ) - maxPopupHeight;

            if( topScreenHeight > sceneRect.height( ) - topScreenHeight ) {

                popupPos = QPointF( widgetPos.x( ), 0.0 );

                #ifdef HB_EFFECTS

                #endif

            } else {

                popupPos = QPointF( widgetPos.x( ), sceneRect.height( ) - maxPopupHeight );

                #ifdef HB_EFFECTS

                #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 

        HbEditorInterface editorInterface( q );

        HbVkbHost *host = editorInterface.vkbHost( );

        if ( host ) {

            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

                #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

                #endif

            }

        }

    }

    mDropDown->setPreferredSize( popupSize );

    mDropDown->setMinimumSize( popupSize );

    mDropDown->setMaximumSize( popupSize );

    QGraphicsWidget *p = q;

    while ( p->parentWidget( ) ) {

        p = p->parentWidget( );

    }

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

            mLineEdit->setText( mText );

        } else {

            HbStyleOptionComboBox comboBoxOption;

            q->initStyleOption( &comboBoxOption );

        }

        mCurrentIndex = aIndex;

    } else {

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

       mLineEdit->setText( mText );

       mCurrentIndex = findData( mText );

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

    }

    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 )

{

    if( !aString.isEmpty( ) ) {

        if ( mCompleter ) {

            mCompleter->setCompletionPrefix( aString );

            mCompleter->complete( );

                }

            }

        }

    } else {

        if( mDropDown ) {

        }

        //showPopup( mModel, mCurrentIndex);

    }

    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 )

{

    if( mEditable == editable ) {

        return;

    }

    mEditable = editable;

        if( mTextItem ) {

            HbStyle::setItemName( mTextItem, "" );

            delete mTextItem;

            mTextItem = 0;

            mLineEdit = new HbCustomLineEdit( q, this );