ui/views/gridview/src/glxgridview.cpp
branchRCL_3
changeset 59 8e5f6eea9c9f
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ui/views/gridview/src/glxgridview.cpp	Tue Aug 31 15:14:51 2010 +0300
@@ -0,0 +1,791 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:   ?Description
+*
+*/
+
+
+
+//Includes
+#include <hbmainwindow.h>
+#include <hggrid.h>
+#include <glxmodelwrapper.h>
+#include <hbpushbutton.h>
+#include <HbToolBar> // Temp
+#include <hbiconitem.h>
+#include <hbicon.h>
+#include <xqserviceutil.h>
+#include <hbcheckbox.h>
+#include <hblabel.h>
+#include <QString>
+#include <hbframeitem.h>
+#include <hbgroupbox.h>
+#include <hbparameterlengthlimiter.h>
+#include <QGraphicsLinearLayout>
+
+//User Includes
+#include "glxviewids.h"
+#include "glxgridview.h"
+#include "glxmodelparm.h"
+#include "glxcommandhandlers.hrh"
+#include "glxicondefs.h"
+#include "glxlocalisationstrings.h"
+#include "glxsettinginterface.h"
+
+
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "glxgridviewTraces.h"
+#endif
+
+GlxGridView::GlxGridView(HbMainWindow *window)
+    : GlxView ( GLX_GRIDVIEW_ID ),
+      mWindow(window),
+      mModel ( NULL),
+      mWidget(NULL),
+      mSelectionModel(NULL),
+      mModelWrapper(NULL),
+      mUiOnButton(NULL),      
+      mScrolling(FALSE),
+      mIconItem(NULL),
+      mMarkCheckBox(NULL),
+      mTotalImagesCount(NULL),
+      mMarkSelectHeading(NULL),
+      mMarkCountLabel(NULL),
+      mZeroItemLabel(NULL),
+      mAlbumNameHeading(NULL),
+      mMarkContainer(NULL),
+      mMarkingWidget(NULL)
+{
+    OstTraceFunctionEntry0( GLXGRIDVIEW_GLXGRIDVIEW_ENTRY );
+    mModelWrapper = new GlxModelWrapper();
+    mModelWrapper->setRoles(GlxQImageSmall);
+    mIconItem = new HbIconItem(this);
+    mSettings = GlxSettingInterface::instance() ;
+    
+    mUiOnButton = new HbPushButton(this);
+    connect(mUiOnButton, SIGNAL(clicked(bool)), this, SLOT(uiButtonClicked(bool)));
+    mUiOnButton->setGeometry(QRectF(590,0,40,40));
+    mUiOnButton->setZValue(1);
+    mUiOnButton->setIcon(HbIcon(GLXICON_WALL_UI_ON));
+    mUiOnButton->setObjectName( "UiOn Button" );
+
+    OstTraceFunctionExit0( GLXGRIDVIEW_GLXGRIDVIEW_EXIT );
+}
+
+void GlxGridView::activate()
+{
+    OstTraceFunctionEntry0( GLXGRIDVIEW_ACTIVATE_ENTRY );
+    loadGridView();
+	connect(mWindow, SIGNAL(orientationChanged(Qt::Orientation)), this, SLOT(orientationchanged(Qt::Orientation)),Qt::UniqueConnection);
+    if(mTotalImagesCount == NULL) {
+        mTotalImagesCount = new HbGroupBox(this);
+        mTotalImagesCount->setObjectName( "Count" );
+        mTotalImagesCount->hide();
+    }
+    OstTraceFunctionExit0( GLXGRIDVIEW_ACTIVATE_EXIT );
+}
+
+void GlxGridView::deActivate()
+{
+    OstTraceFunctionEntry0( GLXGRIDVIEW_DEACTIVATE_ENTRY );
+    mScrolling = FALSE;
+    if (mUiOnButton){
+        mUiOnButton->hide();
+    }
+    if(mIconItem) {
+        mIconItem->hide();
+        mIconItem->resetTransform();
+        mIconItem->setOpacity(0);
+        mIconItem->setZValue(mIconItem->zValue()-20);
+    }
+    if (mTotalImagesCount) {
+        mTotalImagesCount->hide();
+    }
+    if (mAlbumNameHeading) {
+        mAlbumNameHeading->hide();
+    }
+    if(mZeroItemLabel) {
+        mZeroItemLabel->hide();
+    }
+    
+    disconnect(mWindow, SIGNAL(orientationChanged(Qt::Orientation)), this, SLOT(orientationchanged(Qt::Orientation)));
+    OstTraceFunctionExit0( GLXGRIDVIEW_DEACTIVATE_EXIT );
+}
+
+void GlxGridView::initializeView( QAbstractItemModel *model, GlxView *preView )
+{
+    Q_UNUSED( preView )
+    activate();
+    setModel(model);
+}
+
+void GlxGridView::clearCurrentModel()
+{
+    if ( mModel ) {
+        disconnect(mModel, SIGNAL(rowsInserted(QModelIndex,int,int)), this, SLOT(showItemCount()));
+        disconnect(mModel, SIGNAL(rowsRemoved(QModelIndex,int,int)), this, SLOT(showItemCount()));
+        disconnect(mModel, SIGNAL(destroyed()), this, SLOT( clearCurrentModel()));
+        disconnect(mModel, SIGNAL(albumTitleAvailable(QString)), this, SLOT(showAlbumTitle(QString)));
+        disconnect(mModel, SIGNAL(populated()), this, SLOT( populated()));
+        mModel = NULL ;
+    }
+}
+
+void GlxGridView::initializeNewModel()
+{
+    if ( mModel ) {
+        connect(mModel, SIGNAL(rowsInserted(QModelIndex,int,int)), this, SLOT(showItemCount()));
+        connect(mModel, SIGNAL(rowsRemoved(QModelIndex,int,int)), this, SLOT(showItemCount()));
+        connect(mModel, SIGNAL(destroyed()), this, SLOT( clearCurrentModel()));
+        if(getSubState() == ALBUM_ITEM_S){
+            connect(mModel, SIGNAL(albumTitleAvailable(QString)), this, SLOT(showAlbumTitle(QString)));
+        }
+        connect(mModel, SIGNAL(populated()), this, SLOT( populated()));
+    }
+}
+
+void GlxGridView::setModel(QAbstractItemModel *model)
+{
+    OstTraceFunctionEntry0( GLXGRIDVIEW_SETMODEL_ENTRY );
+    if(model)
+        {
+        clearCurrentModel();
+        mModel = model;
+        initializeNewModel();
+        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 ?
+        showItemCount();
+        }
+    OstTraceFunctionExit0( GLXGRIDVIEW_SETMODEL_EXIT );
+}
+
+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);
+            }
+        }
+}
+
+void GlxGridView::addToolBar( HbToolBar *toolBar )
+{
+    OstTraceFunctionEntry0( GLXGRIDVIEW_ADDTOOLBAR_ENTRY );
+    setToolBar(toolBar);
+    showHbItems();
+    OstTraceFunctionExit0( GLXGRIDVIEW_ADDTOOLBAR_EXIT );
+}
+
+void GlxGridView::enableMarking()
+{
+    OstTrace0( TRACE_NORMAL, GLXGRIDVIEW_ENABLEMARKING, "GlxGridView::enableMarking" );
+    mWidget->setSelectionMode(HgWidget::MultiSelection);
+   
+    if (mMarkingWidget == NULL)
+        {
+        mMarkingWidget = new HbWidget(this);
+        mMarkContainer = new QGraphicsLinearLayout(Qt::Horizontal, 0);
+        mMarkingWidget->setLayout(mMarkContainer);
+
+        mMarkSelectHeading = new HbGroupBox(this);
+        mMarkSelectHeading->setHeading(GLX_SELECT_IMAGES);
+        mMarkSelectHeading->setObjectName("Select Photos");
+               
+        mMarkCountLabel = new HbLabel(mMarkingWidget);
+        mMarkCountLabel->setObjectName("MarkCount");
+        mMarkCountLabel->setAlignment(Qt::AlignRight | Qt::AlignVCenter);
+        
+        mMarkCheckBox = new HbCheckBox(GLX_LABEL_MARK_ALL, mMarkingWidget);
+        mMarkCheckBox->setObjectName("CheckB MarkAll");
+       
+        mMarkContainer->addItem(mMarkCheckBox);
+        mMarkContainer->addItem(mMarkCountLabel);        
+        }
+
+    hideorshowitems(mWindow->orientation());
+
+    connect( mWidget->selectionModel() , SIGNAL( selectionChanged(const QItemSelection &, const QItemSelection& ) ), this, SLOT( showMarkedItemCount() ) );
+    connect(mMarkCheckBox, SIGNAL( stateChanged(int) ), this, SLOT( stateChanged(int)));
+
+}
+
+void GlxGridView::disableMarking()
+{
+    OstTrace0( TRACE_NORMAL, GLXGRIDVIEW_DISABLEMARKING, "GlxGridView::disableMarking" );
+    mWidget->setSelectionMode(HgWidget::NoSelection);
+    disconnect( mWidget->selectionModel() , SIGNAL( selectionChanged(const QItemSelection &, const QItemSelection& ) ), this, SLOT( showMarkedItemCount() ) );
+    disconnect(mMarkCheckBox, SIGNAL( stateChanged(int) ), this, SLOT( stateChanged(int)));
+    
+    if (mMarkSelectHeading) {
+        mMarkSelectHeading->hide();
+    }
+
+    if (mMarkingWidget) {
+        mMarkingWidget->hide();
+    }     
+    
+    if (mMarkCheckBox) {
+       mMarkCheckBox->setCheckState(Qt::Unchecked);
+    }
+	
+    showHbItems();
+}
+
+void GlxGridView::stateChanged(int state)
+{
+    if(state)
+        handleUserAction(EGlxCmdMarkAll);
+    else
+        handleUserAction(EGlxCmdUnMarkAll);
+}
+
+void GlxGridView::showMarkedItemCount()
+{
+    int count = mModel->rowCount();
+    QModelIndexList indexList = mWidget->selectionModel()->selectedIndexes();
+    int markItemCount = indexList.count();
+    
+    QString text= HbParameterLengthLimiter(GLX_LABEL_MARK_COUNT).arg(markItemCount).arg(count);    
+    
+    mMarkCountLabel->setPlainText( text );    
+}
+
+void GlxGridView::showItemCount()
+{
+    int count = 0;
+    if(mModel) {
+        count = mModel->rowCount();
+        QSize deviceSize = HbDeviceProfile::current().logicalSize();
+        QSize screenSize = ( mWindow->orientation() == Qt::Vertical ) ? QSize( deviceSize.width(), deviceSize.height() )
+                                                                       : QSize( deviceSize.height(), deviceSize.width() )  ;
+        if(count) {
+            if(mZeroItemLabel) {
+                mZeroItemLabel->hide();
+            }
+            
+            if(isItemVisible(Hb::TitleBarItem)) {
+                QString text;
+                if(XQServiceUtil::isService())
+                    {
+                    showAlbumTitle(GLX_SELECT_IMAGE);
+                    }
+                else if (getSubState() == ALL_ITEM_S) {
+					if (mAlbumNameHeading) {
+                    	mAlbumNameHeading->hide();
+					}
+                    mTotalImagesCount->setGeometry(QRectF(0,0,screenSize.width(),deviceSize.height()/24));
+                    text = HbParameterLengthLimiter(GLX_GRID_VIEW_COUNT_LABEL, count); 
+                    mTotalImagesCount->setHeading ( text );
+                    mTotalImagesCount->show();
+                }
+                else if (getSubState() == ALBUM_ITEM_S) {
+                    mTotalImagesCount->hide();
+                    QVariant variant = mModel->data(mModel->index(0,0),GlxViewTitle);
+                    if (variant.toString() != NULL) {
+                        showAlbumTitle(variant.toString());
+                    }
+                }
+            }
+            else {
+                if (mTotalImagesCount) {
+                    mTotalImagesCount->hide();
+                }
+                if (mAlbumNameHeading) {
+                    mAlbumNameHeading->hide();
+                }
+            }
+
+        }
+        else {
+            bool populated = FALSE;
+            QVariant variant = mModel->data(mModel->index(0,0),GlxPopulated);
+            if (variant.isValid() &&  variant.canConvert<bool>() )
+                {
+                populated = variant.value<bool>();
+                }
+            if(populated) {
+                if (mTotalImagesCount) {
+                    mTotalImagesCount->hide();
+                }
+                if (mAlbumNameHeading) {
+                    mAlbumNameHeading->hide();
+                }
+
+                showNoImageString();
+
+                if (getSubState() == ALBUM_ITEM_S) {
+                    QVariant variant = mModel->data(mModel->index(0,0),GlxViewTitle);
+                    if (variant.toString() != NULL) {
+                        showAlbumTitle(variant.toString());
+                    }
+				}	
+            }
+        }
+    }
+}
+
+void GlxGridView::showAlbumTitle(QString aTitle)
+{
+    int count = mModel->rowCount();
+    QSize deviceSize = HbDeviceProfile::current().logicalSize();
+    QSize screenSize = ( mWindow->orientation() == Qt::Vertical ) ? QSize( deviceSize.width(), deviceSize.height() )
+                                                                   : QSize( deviceSize.height(), deviceSize.width() )  ;
+    if (mAlbumNameHeading == NULL)
+        {
+        mAlbumNameHeading = new HbGroupBox(this);
+        mAlbumNameHeading->setObjectName("Album Name");
+        }
+
+    //If fetcher service set only title text
+    if ((XQServiceUtil::isService()) && isItemVisible(Hb::TitleBarItem))
+        {
+        mAlbumNameHeading->setGeometry(QRectF(0, 0, screenSize.width(),deviceSize.height() / 24));
+        mAlbumNameHeading->setHeading(aTitle);
+        mAlbumNameHeading->show();
+        }
+    else
+        { //handle album tiltle and count display logic here
+        if (isItemVisible(Hb::TitleBarItem))
+            {
+            mAlbumNameHeading->setGeometry(QRectF(0, 0, screenSize.width(),deviceSize.height() / 24));
+            QString text = HbParameterLengthLimiter(GLX_ALBUM_NAME_COUNT_LABEL).arg(aTitle).arg(count);            
+            mAlbumNameHeading->setHeading(text);
+            mAlbumNameHeading->show();
+            }
+        }
+}
+
+void GlxGridView::showNoImageString()
+{
+    qreal chromeHeight = 0.0;
+    QSize deviceSize = HbDeviceProfile::current().logicalSize();
+    QSize screenSize = ( mWindow->orientation() == Qt::Vertical ) ? QSize( deviceSize.width(), deviceSize.height() )
+                                                                   : QSize( deviceSize.height(), deviceSize.width() )  ;
+    qreal midHeight = screenSize.height()/2;
+    if (isItemVisible(Hb::TitleBarItem)) {
+        style()->parameter("hb-param-widget-chrome-height", chromeHeight);
+        midHeight -= chromeHeight;
+    }
+    if (mZeroItemLabel == NULL) {
+        QString displayText(GLX_GRID_NO_IMAGE); 
+        mZeroItemLabel = new HbLabel(displayText, this);
+        mZeroItemLabel->setObjectName( "No Image" );
+    }
+    mZeroItemLabel->setGeometry(QRectF(0, midHeight - deviceSize.height()/16, screenSize.width(), 3*deviceSize.height()/32));
+    mZeroItemLabel->setAlignment(Qt::AlignHCenter);
+    mZeroItemLabel->show();
+   
+}
+
+void GlxGridView::populated()
+{
+      QVariant variant = mModelWrapper->data(mModelWrapper->index(0,0), GlxVisualWindowIndex );
+       int visualIndex = 0;
+       if ( variant.isValid() &&  variant.canConvert<int> () )  {
+           visualIndex = variant.value<int>();
+       }
+       mWidget->scrollTo(mModelWrapper->index(visualIndex,0));
+    showItemCount();
+}
+
+void GlxGridView::handleUserAction(qint32 commandId)
+{
+    OstTrace0( TRACE_NORMAL, GLXGRIDVIEW_HANDLEUSERACTION, "GlxGridView::handleUserAction" );
+    switch( commandId ) {
+        case EGlxCmdMarkAll :
+            mWidget->selectAll();
+            break;
+
+        case EGlxCmdUnMarkAll :
+            mWidget->clearSelection();
+            break;
+
+        case EGlxCmd3DEffectOn:
+            mSettings->setmediaWall3DEffect(1);
+            if(mWidget && !mWidget->effect3dEnabled())
+                mWidget->setEffect3dEnabled(ETrue);
+            break;
+            
+        case EGlxCmd3DEffectOff:
+            mSettings->setmediaWall3DEffect(0);
+            if(mWidget && mWidget->effect3dEnabled())
+                mWidget->setEffect3dEnabled(EFalse);
+            break;
+
+        default :
+            break;
+    }
+}
+
+QItemSelectionModel * GlxGridView::getSelectionModel()
+{
+    OstTrace0( TRACE_NORMAL, GLXGRIDVIEW_GETSELECTIONMODEL, "GlxGridView::getSelectionModel" );
+    return mWidget->selectionModel();
+}
+
+QGraphicsItem * GlxGridView::getAnimationItem(GlxEffect transitionEffect)
+{
+    OstTraceFunctionEntry0( GLXGRIDVIEW_GETANIMATIONITEM_ENTRY );
+    int selIndex = -1;
+
+    if ( transitionEffect == FULLSCREEN_TO_GRID ) {
+        return mWidget;
+    }
+
+    if ( transitionEffect == GRID_TO_FULLSCREEN )
+        {
+        QVariant variant = mModel->data( mModel->index(0,0), GlxFocusIndexRole );
+        if ( variant.isValid() &&  variant.canConvert<int> () )
+            {
+            selIndex = variant.value<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;
+            }
+        }
+
+    if ( transitionEffect == GRID_TO_ALBUMLIST  || transitionEffect == ALBUMLIST_TO_GRID ){
+        return mWidget;
+    }
+    OstTraceFunctionExit0( GLXGRIDVIEW_GETANIMATIONITEM_EXIT );
+    return NULL;
+}
+
+void GlxGridView::loadGridView()
+{
+    OstTraceFunctionEntry0( GLXGRIDVIEW_LOADGRIDVIEW_ENTRY );
+    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->setObjectName( "Media Wall" );
+        mWidget->setLongPressEnabled(true);
+        mWidget->setScrollBarPolicy(HgWidget::ScrollBarAutoHide);
+        if(XQServiceUtil::isService())
+            {
+            mWidget->setEffect3dEnabled(EFalse);
+            }
+        else
+            {
+            mWidget->setEffect3dEnabled(mSettings->mediaWall3DEffect());
+            }
+        setWidget( mWidget );
+        addViewConnection();
+    }
+    OstTraceFunctionExit0( GLXGRIDVIEW_LOADGRIDVIEW_EXIT );
+}
+
+void GlxGridView::orientationchanged(Qt::Orientation orient)
+{
+    if (mWidget && mWidget->selectionMode() == HgWidget::MultiSelection) {
+        hideorshowitems(orient);
+    }
+    showHbItems();
+}
+
+void GlxGridView::hideorshowitems(Qt::Orientation orient)
+{
+    if ( mWidget && mWidget->selectionMode() == HgWidget::NoSelection ) {
+        if( orient == Qt::Horizontal ) {
+			setItemVisible(Hb::AllItems, FALSE) ;
+        	setViewFlags(viewFlags() | HbView::ViewTitleBarHidden | HbView::ViewStatusBarHidden);
+            showItemCount();
+            if(mUiOnButton == NULL) {
+                mUiOnButton = new HbPushButton(this);
+                connect(mUiOnButton, SIGNAL(clicked(bool)), this, SLOT(uiButtonClicked(bool)));
+                mUiOnButton->setGeometry(QRectF(590,0,40,40));
+                mUiOnButton->setZValue(1);
+                mUiOnButton->setIcon(HbIcon(GLXICON_WALL_UI_ON));
+                mUiOnButton->setObjectName( "UiOn Button" );
+            }
+            mUiOnButton->show();
+        }
+        else {
+            showHbItems();
+        }
+    }
+    else if (mWidget && mWidget->selectionMode() == HgWidget::MultiSelection) {
+        setItemVisible(Hb::AllItems, FALSE) ;
+        setViewFlags(viewFlags() | HbView::ViewTitleBarHidden | HbView::ViewStatusBarHidden);
+        if (mUiOnButton) {
+            mUiOnButton->hide();
+        }
+        if (mTotalImagesCount) {
+            mTotalImagesCount->hide();
+        }
+        if (mAlbumNameHeading) {
+            mAlbumNameHeading->hide();
+        }
+        
+        QSize deviceSize = HbDeviceProfile::current().logicalSize();
+        QSize screenSize = ( mWindow->orientation() == Qt::Vertical ) ? QSize( deviceSize.width(), deviceSize.height() )
+                                                                       : QSize( deviceSize.height(), deviceSize.width() )  ;
+        
+        mMarkSelectHeading->setGeometry(QRectF(0,0,screenSize.width(),deviceSize.height()/24));       
+        mMarkingWidget->setGeometry(QRectF(0,deviceSize.height()/24,screenSize.width(),deviceSize.height()/72));          
+              
+        mMarkSelectHeading->show();
+        mMarkingWidget->show();
+        
+        showMarkedItemCount();
+        
+    }
+}
+
+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);
+            }
+        }
+}
+
+
+void GlxGridView::addViewConnection()
+{
+    OstTrace0( TRACE_NORMAL, GLXGRIDVIEW_ADDVIEWCONNECTION, "GlxGridView::addViewConnection" );
+    //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) ) );
+}
+
+void GlxGridView::removeViewConnection ()
+{
+    OstTrace0( TRACE_NORMAL, GLXGRIDVIEW_REMOVEVIEWCONNECTION, "GlxGridView::removeViewConnection" );
+    if(mWidget)
+        {
+        //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) ) );
+        }
+}
+
+
+void GlxGridView::itemSelected(const QModelIndex &  index)
+{
+    OstTrace1( TRACE_NORMAL, GLXGRIDVIEW_ITEMSELECTED, "GlxGridView::itemSelected;index=%d", index.row() );
+    if ( mWidget->selectionMode() == HgWidget::MultiSelection ) {
+        return ;
+    }
+    OstTraceEventStart0( EVENT_DUP1_GLXGRIDVIEW_ITEMSELECTED_START, "Fullscreen Launch Time" );
+    if ( mModel ) {
+        mModel->setData( index, index.row(), GlxFocusIndexRole );
+    }
+    if(XQServiceUtil::isService()){
+        qDebug("GlxGridView::itemSelected actionTriggered( EGlxCmdFetcherSelect )" );
+        emit actionTriggered( EGlxCmdFetcherSelect );
+        return;
+    }
+    emit actionTriggered( EGlxCmdFullScreenOpen );
+    OstTraceEventStop( EVENT_DUP1_GLXGRIDVIEW_ITEMSELECTED_STOP, "Fullscreen Launch Time", EVENT_DUP1_GLXGRIDVIEW_ITEMSELECTED_START );
+}
+
+void GlxGridView::scrollingStarted()
+{
+    if ((mWindow->orientation() == Qt::Horizontal)/* && mWidget->selectionMode() == HgWidget::NoSelection*/)
+        {
+        setItemVisible(Hb::AllItems, FALSE) ;
+        setViewFlags(viewFlags() | HbView::ViewTitleBarHidden | HbView::ViewStatusBarHidden);
+        if (mUiOnButton)
+            {
+            mUiOnButton->hide();
+            }
+		if (mTotalImagesCount) {
+			mTotalImagesCount->hide();
+		}
+		if (mAlbumNameHeading) {
+            mAlbumNameHeading->hide();
+		}
+    }
+
+    mScrolling = TRUE;
+}
+
+void GlxGridView::scrollingEnded()
+{
+    mScrolling = FALSE;
+    if (mUiOnButton && (mWindow->orientation() == Qt::Horizontal))
+        {
+        mUiOnButton->show();
+        }
+    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);
+        mModel->setData( index, index.row(), GlxFocusIndexRole );
+        }
+}
+
+GlxGridView::~GlxGridView()
+{
+    OstTraceFunctionEntry0( DUP1_GLXGRIDVIEW_GLXGRIDVIEW_ENTRY );
+    removeViewConnection();
+    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;
+    delete mTotalImagesCount;
+    delete mAlbumNameHeading;
+    delete mMarkSelectHeading;
+    delete mMarkCheckBox;
+    delete mMarkCountLabel;
+    delete mMarkingWidget;
+    delete mZeroItemLabel;
+    
+    OstTraceFunctionExit0( DUP1_GLXGRIDVIEW_GLXGRIDVIEW_EXIT );
+}
+
+void GlxGridView::indicateLongPress(const QModelIndex& index, QPointF coords)
+{
+    OstTrace0( TRACE_NORMAL, GLXGRIDVIEW_INDICATELONGPRESS, "GlxGridView::indicateLongPress" );
+
+     if ( mWidget->selectionMode() == HgWidget::MultiSelection )
+         {
+         return;
+         }
+     if ( mModel )
+         {
+         mModel->setData( index, index.row(), GlxFocusIndexRole );
+         }
+     emit itemSpecificMenuTriggered(viewId(),coords);
+}
+
+void GlxGridView::uiButtonClicked(bool /*checked*/)
+{
+    showHbItems();
+}
+
+void GlxGridView::showHbItems()
+{
+    if(mWidget && mWidget->selectionMode() == HgWidget::NoSelection) {
+        setItemVisible( Hb::TitleBarItem, TRUE );
+        setItemVisible( Hb::StatusBarItem, TRUE );
+        setViewFlags(viewFlags() &~ HbView::ViewTitleBarHidden &~ HbView::ViewStatusBarHidden);
+        showItemCount();
+    }    
+    updateToolBar();
+    if (mUiOnButton) {
+        mUiOnButton->hide();
+    }
+}
+
+void GlxGridView::cameraButtonClicked(bool /*checked*/)
+{
+    emit actionTriggered(EGlxCmdCameraOpen);
+}
+
+int GlxGridView::getSubState()
+{
+    int substate = NO_GRID_S;
+    if ( mModel ) {
+        QVariant variant = mModel->data( mModel->index(0,0), GlxSubStateRole );
+        if ( variant.isValid() &&  variant.canConvert<int> ()  ) {
+            substate = variant.value<int>();
+        }
+    }
+    return substate;
+}
+
+void GlxGridView::updateToolBar()
+{
+    //In the case of multiselection show the tool bar.
+    if ( mWidget && mWidget->selectionMode() == HgWidget::MultiSelection ) {
+        setItemVisible( Hb::ToolBarItem, TRUE ) ;
+        return ;
+    }
+    
+    //In Album grid it is not required to show tool bar
+    int subState = getSubState();
+    if ( subState == ALBUM_ITEM_S || subState == FETCHER_ALBUM_ITEM_S ) {
+        setItemVisible( Hb::ToolBarItem, FALSE ) ;
+    }
+    else {
+        setItemVisible( Hb::ToolBarItem, TRUE );
+    }
+}
+