#include <hggrid.h>

#include <glxmodelwrapper.h>

#include <hbpushbutton.h>

#include <HbToolBar> // Temp

#include <hbiconitem.h>

#include <hbicon.h>

      mWidget(NULL),

      mSelectionModel(NULL),

      mModelWrapper(NULL),

      mUiOnButton(NULL),

      mScrolling(FALSE),

      mIconItem(NULL)

    mModelWrapper = new GlxModelWrapper();

    mModelWrapper->setRoles(GlxQImageSmall);

    mIconItem = new HbIconItem(this);

    if(mUiOnButton == NULL) {

        mUiOnButton = new HbPushButton("UI",this);

        connect(mUiOnButton, SIGNAL(clicked(bool)), this, SLOT(uiButtonClicked(bool)));

        mUiOnButton->setGeometry(QRectF(610,0,15,15));

        mUiOnButton->setZValue(1);

        mUiOnButton->hide();

    }

    loadGridView();

    if (mUiOnButton && mUiOnButton->isVisible())

        {

        mUiOnButton->hide();

        }    

    if(mIconItem)

        {

        mIconItem->hide();

        mIconItem->resetTransform();

        mIconItem->setOpacity(0);

        mIconItem->setZValue(mIconItem->zValue()-20);

        }

    activate();

    setModel(model);

    if(model)

        {

        mModel =  model;

        QVariant variantimage = mModel->data(mModel->index(0,0),GlxDefaultImage);

        if (mWidget && variantimage.isValid() &&  variantimage.canConvert<QImage> () )

            {

            mWidget->setDefaultImage(variantimage.value<QImage>());

            }

        mModelWrapper->setModel(mModel);

        mWidget->setModel(mModelWrapper);  

        if(!mSelectionModel)

            {

            mSelectionModel = new QItemSelectionModel(mModelWrapper, this);

            connect(mSelectionModel, SIGNAL(currentChanged(const QModelIndex &, const QModelIndex &)), this, SLOT(visibleIndexChanged(const QModelIndex &, const QModelIndex &)));

            mWidget->setSelectionModel(mSelectionModel);

            }

        scrolltofocus();  // Need to do it here ?

        }

void GlxGridView::visibleIndexChanged(const QModelIndex& current, const QModelIndex& previous)

{

    if(mScrolling)

        {

        Q_UNUSED(previous);

        if(current.row() >= 0 || current.row() < mModel->rowCount())

            {

            mModel->setData(mModel->index(0,0),current.row(),GlxVisualWindowIndex);

            }

        }

}

    OstTraceFunctionEntry0( GLXGRIDVIEW_ADDTOOLBAR_ENTRY ); 

    setToolBar(toolBar);  

    hideorshowitems(mWindow->orientation());

    mWidget->setSelectionMode(HgWidget::MultiSelection);

    mWidget->setSelectionMode(HgWidget::NoSelection);

    switch( commandId ) {

            mWidget->selectAll();

            mWidget->clearSelection();

            break;        

    return mWidget->selectionModel();

        return mWidget;

    if ( transitionEffect == GRID_TO_FULLSCREEN )

        {

        if ( variant.isValid() &&  variant.canConvert<int> () ) 

            {

            } 

        else 

            {

            return mWidget;

            }

        QVariant variantimage = mModel->data(mModel->index(selIndex,0),Qt::DecorationRole);

        if ( variantimage.isValid() &&  variantimage.canConvert<HbIcon> () )

            {

            QPolygonF poly;

            if (mModelWrapper && !mWidget->getItemOutline(mModelWrapper->index(selIndex,0), poly))

                {

                return mWidget;

                }

            QRectF itemRect = poly.boundingRect();

            mIconItem->setSize(QSize(120,120));

            HbIcon tempIcon =  variantimage.value<HbIcon>();

            QPixmap tempPixmap = tempIcon.qicon().pixmap(120, 120);

            QSize sz = QSize ( 120, 120);

            tempPixmap = tempPixmap.scaled(sz, Qt::IgnoreAspectRatio );

            HbIcon tmp = HbIcon( QIcon(tempPixmap)) ;

            mIconItem->setIcon(tmp);

            mIconItem->setPos(itemRect.topLeft());

            mIconItem->setZValue(mIconItem->zValue() + 20);

            mIconItem->show();

            return mIconItem;   

            }

        else

            {

            return mWidget;

            }

        }

        return mWidget;

void GlxGridView::loadGridView()

    if(mWidget == NULL) {

        Qt::Orientation orient = mWindow->orientation();

        mWindow->viewport()->grabGesture(Qt::PanGesture);

        mWindow->viewport()->grabGesture(Qt::TapGesture);

        mWindow->viewport()->grabGesture(Qt::TapAndHoldGesture);

        mWidget = new HgGrid(orient);

        mWidget->setLongPressEnabled(true);

        mWidget->setScrollBarPolicy(HgWidget::ScrollBarAutoHide);  

        //mWidget->setItemSize(QSizeF(120,120));

        setWidget( mWidget );  

        addViewConnection();

        //hideorshowitems(orient);

void GlxGridView::orientationchanged(Qt::Orientation orient)

{

    hideorshowitems(orient);

}

void GlxGridView::hideorshowitems(Qt::Orientation orient)

    if(orient == Qt::Horizontal) 

        {

        if (mUiOnButton)

            {

            mUiOnButton->show();

            }

        setItemVisible(Hb::AllItems, FALSE) ;

        }

    else

        {

        if (mUiOnButton)

            {

            mUiOnButton->hide();

            }

        setItemVisible(Hb::AllItems, TRUE) ;

        }

}

void GlxGridView::scrolltofocus()

{

    if(mModelWrapper && mWidget)

        {

        QVariant variant = mModelWrapper->data( mModelWrapper->index(0,0), GlxFocusIndexRole );    

        if ( variant.isValid() &&  variant.canConvert<int> () ) 

            {

            mWidget->scrollTo( mModelWrapper->index( variant.value<int>(),0) );

            mModel->setData(mModel->index(0,0),variant.value<int>(),GlxVisualWindowIndex);

            }

        }

    OstTrace0( TRACE_NORMAL, GLXGRIDVIEW_ITEMCHANGE, "GlxGridView::itemChange" );    

void GlxGridView::addViewConnection()

    connect(mWindow, SIGNAL(orientationChanged(Qt::Orientation)), this, SLOT(orientationchanged(Qt::Orientation)));

    //connect(mWindow, SIGNAL(aboutToChangeOrientation()), mWidget, SLOT(aboutToChangeOrientation()));

    connect(mWindow, SIGNAL(orientationChanged(Qt::Orientation)), mWidget, SLOT(orientationChanged(Qt::Orientation)));

    connect(mWidget, SIGNAL(activated(const QModelIndex &)), SLOT( itemSelected(const QModelIndex &)));

    connect(mWidget, SIGNAL( scrollingStarted() ), this, SLOT( scrollingStarted() ) );

    connect(mWidget, SIGNAL( scrollingEnded() ), this, SLOT( scrollingEnded() ) );

    connect(mWidget, SIGNAL(longPressed(const QModelIndex &, QPointF)), SLOT( indicateLongPress(const QModelIndex &, QPointF) ) );

    if(mWidget)

        {

        disconnect(mWindow, SIGNAL(orientationChanged(Qt::Orientation)), this, SLOT(orientationchanged(Qt::Orientation)));

        //disconnect(mWindow, SIGNAL(aboutToChangeOrientation()), mWidget, SLOT(aboutToChangeOrientation()));

        disconnect(mWindow, SIGNAL(orientationChanged(Qt::Orientation)), mWidget, SLOT(orientationChanged(Qt::Orientation)));

        disconnect(mWidget, SIGNAL(activated(const QModelIndex &)),this, SLOT( itemSelected(const QModelIndex &)));

        disconnect(mWidget, SIGNAL( scrollingStarted() ), this, SLOT( scrollingStarted() ) );

        disconnect(mWidget, SIGNAL( scrollingEnded() ), this, SLOT( scrollingEnded() ) );

        disconnect(mWidget,  SIGNAL(longPressed(const QModelIndex &, QPointF)),this, SLOT( indicateLongPress(const QModelIndex &, QPointF) ) );

        }

    if ( mWidget->selectionMode() == HgWidget::MultiSelection )

        { 

        }    

   if(XQServiceUtil::isService()){

    }    

    OstTraceEventStart0( EVENT_DUP1_GLXGRIDVIEW_ITEMSELECTED_START, "Fullscreen Launch Time" );    

    if ( mModel ) 

        {

        }

    setItemVisible(Hb::AllItems, FALSE);

    emit actionTriggered( EGlxCmdFullScreenOpen ); 

void GlxGridView::scrollingStarted()

    if ((mWindow->orientation() == Qt::Horizontal))

        {

        setItemVisible(Hb::AllItems, FALSE) ;

        }    

    mScrolling = TRUE;

}

void GlxGridView::scrollingEnded()

{

    mScrolling = FALSE;

    QList<QModelIndex> visibleIndex = mWidget->getVisibleItemIndices();

    if (visibleIndex.count() <= 0)

        {

        return;

        }

    QModelIndex index = visibleIndex.at(0);

    if (  index.row() < 0 || index.row() >= mModel->rowCount() )

        {

        return;

        }    

    if(mModel)

        {

        mModel->setData( index, index.row(), GlxVisualWindowIndex);

        }

    if(mSelectionModel)

        {

        disconnect(mSelectionModel, SIGNAL(currentChanged(const QModelIndex &, const QModelIndex &)), this, SLOT(visibleIndexChanged(const QModelIndex &, const QModelIndex &)));

        delete mSelectionModel;

        }

    delete mWidget;

    delete mModelWrapper;

    if(mUiOnButton) {

        disconnect(mUiOnButton, SIGNAL(clicked(bool)), this, SLOT(uiButtonClicked(bool)));

        delete mUiOnButton;

    }

    delete mIconItem;

void GlxGridView::indicateLongPress(const QModelIndex& index, QPointF coords)

     if ( mWidget->selectionMode() == HgWidget::MultiSelection )

         { 

         return;

         }     

     if ( mModel ) 

         {

         mModel->setData( index, index.row(), GlxFocusIndexRole );

         }     

     emit itemSpecificMenuTriggered(viewId(),coords);

}

void GlxGridView::uiButtonClicked(bool /*checked*/)

{

    if (isItemVisible(Hb::TitleBarItem))  // W16  All item is Not Working , So Temp Fix

        {

        setItemVisible(Hb::AllItems, FALSE) ;

        }

    else

        {

        setItemVisible(Hb::AllItems, TRUE) ;

        }