diff -r c499df2dbb33 -r 2c833fc9e98f ui/views/gridview/src/glxgridview.cpp
--- a/ui/views/gridview/src/glxgridview.cpp	Mon May 03 12:31:32 2010 +0300
+++ b/ui/views/gridview/src/glxgridview.cpp	Fri May 14 15:52:22 2010 +0300
@@ -18,26 +18,22 @@
 
 
 //Includes
-#include <QDebug>
-#include <hbmenu.h>
-#include <hbaction.h>
-#include <hbtoolbar.h>
-#include <hbgridview.h>
 #include <hbmainwindow.h>
-#include <shareuidialog.h>
-#include <hbdocumentloader.h>
-#include <QAbstractItemModel>
-#include <hbabstractviewitem.h>
+#include <hggrid.h>
+#include <glxmodelwrapper.h>
+#include <hbpushbutton.h>
+#include <HbToolBar> // Temp
+#include <hbiconitem.h>
+#include <hbicon.h>
 #include <xqserviceutil.h>
 
 //User Includes
-#include "glxuistd.h"
 #include "glxviewids.h"
 #include "glxgridview.h"
 #include "glxmodelparm.h"
-#include "glxloggerenabler.h"
-#include "glxdocloaderdefs.h"
 #include "glxcommandhandlers.hrh"
+
+
 #include "OstTraceDefinitions.h"
 #ifdef OST_TRACE_COMPILER_IN_USE
 #include "glxgridviewTraces.h"
@@ -45,95 +41,126 @@
 
 GlxGridView::GlxGridView(HbMainWindow *window) 
     : GlxView ( GLX_GRIDVIEW_ID ), 
-      mGridView(NULL), 
-      mView(NULL), 
       mWindow(window), 
       mModel ( NULL), 
-      mVisualIndex(0),
-      mItem(NULL),
-      mIsLongPress (false)
+      mWidget(NULL),
+      mSelectionModel(NULL),
+      mModelWrapper(NULL),
+      mUiOnButton(NULL),
+      mScrolling(FALSE),
+      mIconItem(NULL)
 {
     OstTraceFunctionEntry0( GLXGRIDVIEW_GLXGRIDVIEW_ENTRY );
-    mDocLoader = new HbDocumentLoader();
+    mModelWrapper = new GlxModelWrapper();
+    mModelWrapper->setRoles(GlxQImageSmall);
+    mIconItem = new HbIconItem(this);
     OstTraceFunctionExit0( GLXGRIDVIEW_GLXGRIDVIEW_EXIT );
-	setContentFullScreen( true );
 }
 
 void GlxGridView::activate()
 {
     OstTraceFunctionEntry0( GLXGRIDVIEW_ACTIVATE_ENTRY );
-    loadGridView(mWindow->orientation());
-    addViewConnection();           
-    mGridView->resetTransform(); //to reset the transition effect (reset transform matrix)
-    mGridView->setOpacity( 1);
-    resetItemTransform();
+    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();
     OstTraceFunctionExit0( GLXGRIDVIEW_ACTIVATE_EXIT );
 }
 
 void GlxGridView::deActivate()
 {
     OstTraceFunctionEntry0( GLXGRIDVIEW_DEACTIVATE_ENTRY );
-    removeViewConnection();
-    mModel = NULL;
+    if (mUiOnButton && mUiOnButton->isVisible())
+        {
+        mUiOnButton->hide();
+        }    
+    if(mIconItem)
+        {
+        mIconItem->hide();
+        mIconItem->resetTransform();
+        mIconItem->setOpacity(0);
+        mIconItem->setZValue(mIconItem->zValue()-20);
+        }
     OstTraceFunctionExit0( GLXGRIDVIEW_DEACTIVATE_EXIT );
 }
 
 void GlxGridView::initializeView(QAbstractItemModel *model)
 {
-    resetItemTransform();
-    mGridView->setModel(model);
-    mModel = model;
-    loadGridView(mWindow->orientation());
-    QVariant variant = model->data( model->index(0,0), GlxFocusIndexRole );    
-    if ( variant.isValid() &&  variant.canConvert<int> () ) {
-        mGridView->scrollTo( model->index( variant.value<int>(),0), HbGridView::EnsureVisible );
-    }
+    activate();
+    setModel(model);
 }
 
 void GlxGridView::setModel(QAbstractItemModel *model) 
 {
     OstTraceFunctionEntry0( GLXGRIDVIEW_SETMODEL_ENTRY );
-    mModel =  model ;
-    mGridView->setModel(mModel);
-    QVariant variant = mModel->data( mModel->index(0,0), GlxFocusIndexRole );    
-    if ( variant.isValid() &&  variant.canConvert<int> () ) {
-        mGridView->scrollTo( mModel->index( variant.value<int>(),0), HbGridView::EnsureVisible );
-    }
+    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 ?
+        }
     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) ;
+    OstTraceFunctionEntry0( GLXGRIDVIEW_ADDTOOLBAR_ENTRY ); 
+    setToolBar(toolBar);  
+    hideorshowitems(mWindow->orientation());
     OstTraceFunctionExit0( GLXGRIDVIEW_ADDTOOLBAR_EXIT );
 }
 
 void GlxGridView::enableMarking()
 {
     OstTrace0( TRACE_NORMAL, GLXGRIDVIEW_ENABLEMARKING, "GlxGridView::enableMarking" );
-    mGridView->setSelectionMode(HbGridView::MultiSelection);
+    mWidget->setSelectionMode(HgWidget::MultiSelection);
 }
 
 void GlxGridView::disableMarking() 
 {
     OstTrace0( TRACE_NORMAL, GLXGRIDVIEW_DISABLEMARKING, "GlxGridView::disableMarking" );
-    mGridView->setSelectionMode(HbGridView::NoSelection);
+    mWidget->setSelectionMode(HgWidget::NoSelection);
 }
 
 void GlxGridView::handleUserAction(qint32 commandId)
 {
     OstTrace0( TRACE_NORMAL, GLXGRIDVIEW_HANDLEUSERACTION, "GlxGridView::handleUserAction" );
-    switch( commandId ){
+    switch( commandId ) {
         case EGlxCmdMarkAll :
-            mGridView->selectAll();
+            mWidget->selectAll();
             break;
 
         case EGlxCmdUnMarkAll :
-            mGridView->clearSelection();
-            break;
-
-        
+            mWidget->clearSelection();
+            break;        
 
         default :
             break;
@@ -143,7 +170,7 @@
 QItemSelectionModel * GlxGridView::getSelectionModel()
 {
     OstTrace0( TRACE_NORMAL, GLXGRIDVIEW_GETSELECTIONMODEL, "GlxGridView::getSelectionModel" );
-    return mGridView->selectionModel();    
+    return mWidget->selectionModel();
 }
 
 QGraphicsItem * GlxGridView::getAnimationItem(GlxEffect transitionEffect)
@@ -152,77 +179,115 @@
     int selIndex = -1;
 
     if ( transitionEffect == FULLSCREEN_TO_GRID ) {
-        return mGridView;
+        return mWidget;
     }
 
-    if ( transitionEffect == GRID_TO_FULLSCREEN ) {
+    if ( transitionEffect == GRID_TO_FULLSCREEN )
+        {
         QVariant variant = mModel->data( mModel->index(0,0), GlxFocusIndexRole );    
-        if ( variant.isValid() &&  variant.canConvert<int> () ) {
+        if ( variant.isValid() &&  variant.canConvert<int> () ) 
+            {
             selIndex = variant.value<int>();  
-        }  
-    
-        mItem = mGridView->itemByIndex( mModel->index(selIndex,0) );
-        connect(mItem, SIGNAL(destroyed()), this, SLOT( itemDestroyed()));
-        mItem->setZValue( mItem->zValue() + 20); 
-        return mItem;
-    }
+            } 
+        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 mGridView;
+        return mWidget;
     }
     OstTraceFunctionExit0( GLXGRIDVIEW_GETANIMATIONITEM_EXIT );
     return NULL;    
 }
 
-void GlxGridView::loadGridView(Qt::Orientation orient)
+void GlxGridView::loadGridView()
 {
     OstTraceFunctionEntry0( GLXGRIDVIEW_LOADGRIDVIEW_ENTRY );
-    bool loaded = false;
-    QString section;
-    GlxContextMode mode ;
-    
-    //Load the widgets accroding to the current Orientation
-    if(orient == Qt::Horizontal) {
-        section = GLX_GRIDVIEW_LSSECTION ;
-        mode = GlxContextLsGrid ;
-    }
-    else {
-        section = GLX_GRIDVIEW_PTSECTION ;
-        mode = GlxContextPtGrid ;
-    }
-
-    if (mGridView == NULL ) {       
-        mDocLoader->load(GLX_GRIDVIEW_DOCMLPATH,&loaded);
-        if(loaded) {
-            //retrieve the widgets            
-            mView = static_cast<HbView*>(mDocLoader->findWidget(QString(GLX_GRIDVIEW_VIEW)));
-            mGridView = static_cast<HbGridView*>(mDocLoader->findWidget(GLX_GRIDVIEW_GRID)); 
-            setWidget( mView );
-            mGridView->setLayoutName( QString( "GridView" ) );
-        }
-    }
-    //Load the Sections
-    mDocLoader->load(GLX_GRIDVIEW_DOCMLPATH,section,&loaded); 
-    
-    if ( mModel ) {        
-        mModel->setData(QModelIndex(), (int)mode, GlxContextRole );
+    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);
     }
     OstTraceFunctionExit0( GLXGRIDVIEW_LOADGRIDVIEW_EXIT );
 }
 
-void GlxGridView::itemDestroyed()
+void GlxGridView::orientationchanged(Qt::Orientation orient)
+{
+    hideorshowitems(orient);
+}
+void GlxGridView::hideorshowitems(Qt::Orientation orient)
 {
-    OstTrace0( TRACE_NORMAL, GLXGRIDVIEW_ITEMDESTROYED, "GlxGridView::itemDestroyed" );
-    disconnect( mItem, SIGNAL( destroyed() ), this, SLOT( itemDestroyed() ) );
-    mItem = NULL;    
+    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);
+            }
+        }
 }
 
 QVariant  GlxGridView::itemChange (GraphicsItemChange change, const QVariant &value) 
     {
-    OstTrace0( TRACE_NORMAL, GLXGRIDVIEW_ITEMCHANGE, "GlxGridView::itemChange" );
-    
+    OstTrace0( TRACE_NORMAL, GLXGRIDVIEW_ITEMCHANGE, "GlxGridView::itemChange" );    
     static bool isEmit = true;
-
     if ( isEmit && change == QGraphicsItem::ItemVisibleHasChanged && value.toBool()  ) {
     emit actionTriggered( EGlxCmdSetupItem );
     isEmit = false;
@@ -230,111 +295,126 @@
     return HbWidget::itemChange(change, value);
     }
 
-void GlxGridView::addViewConnection ()
+void GlxGridView::addViewConnection()
 {
     OstTrace0( TRACE_NORMAL, GLXGRIDVIEW_ADDVIEWCONNECTION, "GlxGridView::addViewConnection" );
-    connect(mWindow, SIGNAL(orientationChanged(Qt::Orientation)), this, SLOT(loadGridView(Qt::Orientation)));
-    connect(mGridView, SIGNAL(activated(const QModelIndex &)), this, SLOT( itemSelected(const QModelIndex &)));
-    connect( mGridView, SIGNAL( scrollingEnded() ), this, SLOT( setVisvalWindowIndex() ) );
-    connect(mGridView, SIGNAL(longPressed( HbAbstractViewItem*, QPointF )),this, SLOT( indicateLongPress( HbAbstractViewItem*, QPointF ) ) );
+    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) ) );
 }
 
 void GlxGridView::removeViewConnection ()
 {
     OstTrace0( TRACE_NORMAL, GLXGRIDVIEW_REMOVEVIEWCONNECTION, "GlxGridView::removeViewConnection" );
-    disconnect(mWindow, SIGNAL(orientationChanged(Qt::Orientation)), this, SLOT(loadGridView(Qt::Orientation)));
-    disconnect(mGridView, SIGNAL(activated(const QModelIndex &)), this, SLOT( itemSelected(const QModelIndex &)));
-    disconnect( mGridView, SIGNAL( scrollingEnded() ), this, SLOT( setVisvalWindowIndex() ) );
-    disconnect(mGridView, SIGNAL(longPressed( HbAbstractViewItem*, QPointF )),this, SLOT( indicateLongPress( HbAbstractViewItem*, 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) ) );
+        }
 }
 
-void GlxGridView::resetItemTransform()
-{
-    if ( mItem ) {
-        mItem->resetTransform(); //to reset the transition effect (reset transform matrix)
-        mItem->setOpacity( 1);
-        mItem->setZValue( mItem->zValue() - 20);
-        disconnect( mItem, SIGNAL( destroyed() ), this, SLOT( itemDestroyed() ) );
-        mItem = NULL;
-    }
-}
 
 void GlxGridView::itemSelected(const QModelIndex &  index)
 {
     OstTrace1( TRACE_NORMAL, GLXGRIDVIEW_ITEMSELECTED, "GlxGridView::itemSelected;index=%d", index.row() );
-
-    if ( mGridView->selectionMode() == HbGridView::MultiSelection ) { //in multi selection mode no need to open the full screen
+    if ( mWidget->selectionMode() == HgWidget::MultiSelection )
+        { 
         return ;
-    }
-    if ( mIsLongPress ) {
-        mIsLongPress = false;
-        return ;
-    }
-    if(XQServiceUtil::isService()){
+        }    
+   if(XQServiceUtil::isService()){
         emit gridItemSelected(index);
         return;
-    }
-    
-    OstTraceEventStart0( EVENT_DUP1_GLXGRIDVIEW_ITEMSELECTED_START, "Fullscreen Launch Time" );
-    
-    if ( mModel ) {
+    }    
+    OstTraceEventStart0( EVENT_DUP1_GLXGRIDVIEW_ITEMSELECTED_START, "Fullscreen Launch Time" );    
+    if ( mModel ) 
+        {
         mModel->setData( index, index.row(), GlxFocusIndexRole );
-    }
-    emit actionTriggered( EGlxCmdFullScreenOpen );
+        }
+    setItemVisible(Hb::AllItems, FALSE);
+    emit actionTriggered( EGlxCmdFullScreenOpen ); 
     OstTraceEventStop( EVENT_DUP1_GLXGRIDVIEW_ITEMSELECTED_STOP, "Fullscreen Launch Time", EVENT_DUP1_GLXGRIDVIEW_ITEMSELECTED_START );
 }
 
-void GlxGridView::setVisvalWindowIndex()
+void GlxGridView::scrollingStarted()
 {
-    OstTrace0( TRACE_IMPORTANT, GLXGRIDVIEW_SETVISVALWINDOWINDEX, "GlxGridView::setVisvalWindowIndex" );
-    QList< HbAbstractViewItem * >  visibleItemList =  mGridView->visibleItems();
-    qDebug("GlxGridView::setVisvalWindowIndex() %d", visibleItemList.count());    
-    OstTrace1( TRACE_IMPORTANT, DUP1_GLXGRIDVIEW_SETVISVALWINDOWINDEX, "GlxGridView::setVisvalWindowIndex;visibleitemindex=%d", 
-            visibleItemList.count() );
-    
-    if ( visibleItemList.count() <= 0 )
-        return ;
+    if ((mWindow->orientation() == Qt::Horizontal))
+        {
+        setItemVisible(Hb::AllItems, FALSE) ;
+        }    
+    mScrolling = TRUE;
+}
 
-    HbAbstractViewItem *item = visibleItemList.at(0);    
-    if ( item == NULL ) 
-        return ;
-        
-    OstTrace1( TRACE_IMPORTANT, DUP2_GLXGRIDVIEW_SETVISVALWINDOWINDEX, "GlxGridView::setVisvalWindowIndex item=%d", item );
-        OstTrace1( TRACE_IMPORTANT, DUP3_GLXGRIDVIEW_SETVISVALWINDOWINDEX, "GlxGridView::setVisvalWindowIndex;visual index=%d",
-                item->modelIndex().row() );
-        
-    if (  item->modelIndex().row() < 0 || item->modelIndex().row() >= mModel->rowCount() )
-        return ;
-    
-    mModel->setData( item->modelIndex (), item->modelIndex().row(), GlxVisualWindowIndex);
+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);
+        }
 }
 
 GlxGridView::~GlxGridView()
 {
     OstTraceFunctionEntry0( DUP1_GLXGRIDVIEW_GLXGRIDVIEW_ENTRY );
     removeViewConnection();
-    delete mGridView;
-    mGridView = NULL;
-
-    delete mDocLoader;
-    mDocLoader = NULL;
-
+    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;
     OstTraceFunctionExit0( DUP1_GLXGRIDVIEW_GLXGRIDVIEW_EXIT );
 }
 
-void GlxGridView::indicateLongPress(HbAbstractViewItem *item, QPointF coords)
+void GlxGridView::indicateLongPress(const QModelIndex& index, QPointF coords)
 {
     OstTrace0( TRACE_NORMAL, GLXGRIDVIEW_INDICATELONGPRESS, "GlxGridView::indicateLongPress" );
-    qDebug() << "GlxGridView:indicateLongPress Item " << item->modelIndex() << "long pressed at "
-    << coords;
-
-    if ( mGridView->selectionMode() == HbGridView::MultiSelection ){ //in multi selection mode no need to open the context menu
-    	return ;
-    }
+     
+     if ( mWidget->selectionMode() == HgWidget::MultiSelection )
+         { 
+         return;
+         }     
+     if ( mModel ) 
+         {
+         mModel->setData( index, index.row(), GlxFocusIndexRole );
+         }     
+     emit itemSpecificMenuTriggered(viewId(),coords);
+}
 
-    if ( mModel ) {
-    	mModel->setData( item->modelIndex(), item->modelIndex().row(), GlxFocusIndexRole );
-    }
-    mIsLongPress = true;
-    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) ;
+        }
 }
+