diff -r f7f0874bfe7d -r 74c9f037fd5d ui/views/fullscreenview/src/glxfullscreenview.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ui/views/fullscreenview/src/glxfullscreenview.cpp	Fri Mar 19 09:28:59 2010 +0200
@@ -0,0 +1,662 @@
+/*
+* 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 <QDebug>
+#include <QTimer>
+#include <hbmenu.h>
+#include <hbgridview.h>
+#include <hbpushbutton.h>
+#include <hbmainwindow.h>
+#include <shareuidialog.h>
+#include <hbdocumentloader.h>
+#include <QAbstractItemModel>
+#include <hbabstractviewitem.h>
+
+
+//User Includes
+#include "glxviewids.h"  //contains the view ids of all the views in photos app.
+#include "glxmodelparm.h"
+#include "glxcoverflow.h"
+#include "glxzoomslider.h"
+#include "glxzoomcontrol.h"
+#include "glxdocloaderdefs.h" //contains the definations of path, widget names and view names in docml
+#include "glxloggerenabler.h"
+#include "glxfullscreenview.h" 
+#include "glxcommandhandlers.hrh"
+#include <glxhdmicontroller.h>
+#include <glxlog.h>
+#include <glxtracer.h>
+
+
+const int KUiOffTime = 3000;
+
+GlxFullScreenView::GlxFullScreenView(HbMainWindow *window,HbDocumentLoader *DocLoader) : GlxView ( GLX_FULLSCREENVIEW_ID),
+                   mModel(NULL), mWindow( window), mCoverFlow(NULL) , mImageStrip (NULL), mUiOffTimer(NULL),
+                   mZmPushButton(NULL), mZoomSlider(NULL), mZoomControl(NULL),mSendUserActivityEvent(false),
+                   mFlipPushButton(NULL), nbrCol(0),iHdmiController(NULL)
+{
+    TRACER("GlxFullScreenView::GlxFullScreenView()" );
+    mDocLoader = DocLoader;
+    setContentFullScreen( true );
+    HbEffect::add( QString("HbGridView"), QString(":/data/transitionup.fxml"), QString( "TapShow" ));
+    HbEffect::add( QString("HbGridView"), QString(":/data/transitiondown.fxml"), QString( "TapHide" ));
+}
+
+void GlxFullScreenView::initializeView(QAbstractItemModel *model)
+{
+    TRACER("GlxFullScreenView::initializeView()" );
+
+    //Load/Retrieve the Widgets
+    loadWidgets();
+
+    //Initialize the coverflow and partially creates the coverflow with one image
+    // to make the widget light weight in order to make
+    // transition smooth 
+    QRect screen_rect = mWindow->geometry(); 
+    QSize sz(screen_rect.width(), screen_rect.height());
+    mCoverFlow->partiallyCreate( model, sz);     
+}
+
+void GlxFullScreenView::loadWidgets()
+    {
+    TRACER("GlxFullScreenView::loadWidgets()");
+    //Load the View and Widget   
+    GlxFullScreenView *view  =   static_cast<GlxFullScreenView*> (mDocLoader->findWidget(GLXFULLSCREEN_VIEW));
+    mCoverFlow               =   static_cast<GlxCoverFlow*> (mDocLoader->findWidget(GLXFULLSCREEN_COVERFLOW));
+
+    //initialise the cover flow for basic connections and the rest
+    mCoverFlow->setCoverFlow();
+
+    //Load the IMAGE STRIP & FULLSCREEN TOOLBAR[PUSH BUTTON]
+    mImageStrip              =   static_cast<HbGridView*> (mDocLoader->findWidget(GLXFULLSCREEN_FILMSTRIP));
+    mFlipPushButton          =   static_cast<HbPushButton*> (mDocLoader->findWidget(GLXFULLSCREEN_FLIP));
+
+    //When the widget is loaded/retreived the widgets are shown by default.
+    //@to do : hide the widgets by default in docml
+    mImageStrip->hide();
+    mFlipPushButton->hide();        
+    }
+
+void GlxFullScreenView::activate()
+    {
+    TRACER("GlxFullScreenView::activate()" );
+
+    mWindow->setItemVisible(Hb::AllItems, FALSE) ;
+
+    if(!mCoverFlow)
+        {
+        //retrives the widgets
+        loadWidgets();
+        }
+
+    loadViewSection();
+
+    if(mZmPushButton == NULL) {
+    mZmPushButton = new HbPushButton("ZM",this);
+    }
+
+    if(NULL == mZoomSlider) {
+    mZoomSlider = new GlxZoomSlider(this);
+    }
+
+    if(NULL == mZoomControl) {
+    mZoomControl = new GlxZoomControl(this);
+    }
+
+    addConnection(); 
+    hideUi();
+    setLayout();
+    mSendUserActivityEvent = true;  
+    if (!iHdmiController)    
+        {
+        GLX_LOG_INFO("GlxFullScreenView::activate() - CGlxHdmi" );
+        iHdmiController = CGlxHdmiController::NewL();
+        }   
+    }
+
+void GlxFullScreenView::loadViewSection()
+    {
+    TRACER("GlxFullScreenView::loadViewSection()" );
+    bool loaded =true;
+    if( mWindow->orientation() == Qt::Horizontal )
+        {
+        //Load the Landscape section for Horizontal
+        mDocLoader->load(GLXFULLSCREENDOCMLPATH,GLXFULLSCREENLSSECTION,&loaded);
+        }
+    else
+        {
+        //Load the Portrait section for Horizontal
+        mDocLoader->load(GLXFULLSCREENDOCMLPATH,GLXFULLSCREENPTSECTION,&loaded);    
+        }
+    }
+
+
+void GlxFullScreenView::resetView()
+    {
+    TRACER("GlxFullScreenView::resetView()" );
+
+    //Clear the 4 icons present in the Coverflow,so that the transition between the views are smooth
+    mCoverFlow->partiallyClean();
+
+    //Clean up the rest of the resources allocated
+    cleanUp();    
+    }
+
+void GlxFullScreenView::deActivate()
+    { 
+    TRACER("GlxFullScreenView::deActivate()" );
+
+    mWindow->setItemVisible(Hb::AllItems , TRUE);
+
+    //Clean up the rest of the resources allocated
+    cleanUp();
+
+    //deletes the iconitems in the coverflow   
+    mCoverFlow->ClearCoverFlow();
+
+    //the coverflow is not deleted as it is loaded by document loader
+    //the coverflow is initialised to null 
+    //to just reset to the initial state
+    mCoverFlow = NULL;
+    }
+
+void GlxFullScreenView::cleanUp()
+    { 
+    TRACER("GlxFullScreenView::cleanUp()" );
+
+    removeConnection();
+
+    if ( mUiOffTimer ) {
+    GLX_LOG_INFO("GlxFullScreenView::cleanUp() mUiOffTimer" );
+    mUiOffTimer->stop();
+    delete mUiOffTimer;
+    mUiOffTimer = NULL;
+    }
+
+    mSendUserActivityEvent = false;
+
+    if(mZmPushButton) {
+    GLX_LOG_INFO("GlxFullScreenView::cleanUp() delete mZmPushButton " );
+    delete mZmPushButton;
+    mZmPushButton = NULL;
+    }
+
+    if(mZoomSlider) {
+    GLX_LOG_INFO("GlxFullScreenView::cleanUp() delete mZoomSlider " );
+    delete mZoomSlider;        
+    mZoomSlider = NULL;
+    }
+
+    if(mZoomControl) {
+    GLX_LOG_INFO("GlxFullScreenView::cleanUp() delete mZoomControl " );
+    delete mZoomControl;
+    mZoomControl = NULL;
+    }
+    if (iHdmiController) {
+    GLX_LOG_INFO("GlxFullScreenView::cleanUp() delete iHdmiController " );
+    delete iHdmiController;
+    iHdmiController = NULL;
+    }
+
+    }
+
+QGraphicsItem * GlxFullScreenView::getAnimationItem(GlxEffect transitionEffect)
+    {
+    TRACER("GlxFullScreenView::getAnimationItem(GlxEffect transitionEffect)");
+    if ( transitionEffect == GRID_TO_FULLSCREEN 
+            || transitionEffect == FULLSCREEN_TO_DETAIL
+            || transitionEffect == DETAIL_TO_FULLSCREEN ) {
+            return this;
+    }
+
+    return NULL;    
+    }
+
+void GlxFullScreenView::setModel( QAbstractItemModel *model )
+    {
+    TRACER("GlxFullScreenView::setModel( QAbstractItemModel *model )");
+    GLX_LOG_INFO2("GlxFullScreenView::setModel() model %u  mModel %u", model, mModel );
+
+    mModel = model;     
+    mCoverFlow->setModel(mModel);
+    mZoomSlider->setModel(mModel);
+    mZoomControl->setModel(mModel);    
+    setImageStripModel();
+    SetImageToHdmiL(); // for the first image on screen
+    }
+
+void GlxFullScreenView::setModelContext()
+    {
+    TRACER("GlxFullScreenView::setModelContext()");
+    if ( mModel && mWindow ) {
+    GLX_LOG_INFO1("GlxFullScreenView::setModelContext %d", mWindow->orientation() );
+
+    if ( mWindow->orientation() == Qt::Horizontal ) {
+    WRITE_TIMESTAMP("set the fullscreen landscape context")
+    mModel->setData(QModelIndex(), (int)GlxContextLsFs, GlxContextRole );
+    }
+    else {
+    WRITE_TIMESTAMP("set the fullscreen portrait context")
+    mModel->setData(QModelIndex(), (int)GlxContextPtFs, GlxContextRole );
+    }
+    }
+    }
+
+void GlxFullScreenView::orientationChanged(Qt::Orientation orient)
+    {
+    TRACER("GlxFullScreenView::orientationChanged()");
+    // fullscreen thumnail size is depends on orientation of phone so change the model context before changing the layout
+    GLX_LOG_INFO1("GlxFullScreenView::orientationChanged() %d", orient );
+    setModelContext();
+    loadViewSection();
+    setLayout();
+    }
+
+void GlxFullScreenView::activateUI()
+    {
+    TRACER("GlxFullScreenView::activateUI()");
+    GLX_LOG_INFO1("GlxFullScreenView::activateUI() %d", mUiOff );
+    if(mSendUserActivityEvent){
+    mSendUserActivityEvent = false;
+    emit cancelTimer();
+    }
+    if ( mUiOff ){
+
+    if ( mUiOffTimer == NULL ) {
+    mUiOffTimer = new QTimer();
+    connect(mUiOffTimer, SIGNAL(timeout()), this, SLOT(hideUi()));
+    }
+
+    //set and scrool the current index to the center
+    QVariant variant = mModel->data( mModel->index(0,0), GlxFocusIndexRole );    
+    if ( variant.isValid() &&  variant.canConvert<int> ()  ) {
+    mImageStrip->setCurrentIndex ( mModel->index( variant.value<int>(), 0) );    
+    mImageStrip->scrollTo( mModel->index( variant.value<int>(), 0), HbGridView::PositionAtCenter ); 
+    } 
+    mImageStrip->show();
+
+    //mZmPushButton->show();
+    mFlipPushButton->setZValue( 6 + mCoverFlow->zValue() ); 
+    mFlipPushButton->show();
+    mZmPushButton->hide();
+    mUiOff = FALSE;
+    mUiOffTimer->start(KUiOffTime);
+    mCoverFlow->setUiOn(TRUE);
+    mWindow->setItemVisible(Hb::AllItems, TRUE) ;
+    HbEffect::start(mImageStrip, QString("HbGridView"), QString("TapShow"), this, "effectFinished" );        
+    }
+    else {
+    hideUi();
+    }	
+    }
+
+void GlxFullScreenView::hideUi()
+    {
+    TRACER("GlxFullScreenView::hideUi()");
+    GLX_LOG_INFO1("GlxFullScreenView::hideUi() %d", mUiOff );
+    if(mSendUserActivityEvent){
+    mSendUserActivityEvent = false;
+    emit cancelTimer();
+    }
+    HbMenu *menuWidget = menu();
+
+    //if option menu is open then no need to hide the status bar and image strip
+    if ( menuWidget->isVisible() ) { 
+    return ;
+    }
+
+    mWindow->setItemVisible(Hb::AllItems, FALSE) ;
+    if ( mImageStrip ) {
+    HbEffect::start(mImageStrip, QString("HbGridView"), QString("TapHide"), this, "effectFinished" );
+    //mImageStrip->hide();
+    }
+    mZmPushButton->hide();  
+
+    if(mFlipPushButton){
+    mFlipPushButton->hide();
+    }
+
+    if ( mUiOffTimer ) {
+    mUiOffTimer->stop();
+    }
+    mUiOff = TRUE;
+    mCoverFlow->setUiOn(FALSE);
+    }
+
+void GlxFullScreenView::changeSelectedIndex(const QModelIndex &index)
+    {
+    TRACER("GlxFullScreenView::changeSelectedIndex()");
+    GLX_LOG_INFO1("GlxFullScreenView::changeSelectedIndex() %d", index.row() );
+    QVariant variant = mModel->data( mModel->index(0,0), GlxFocusIndexRole );    
+    if ( variant.isValid() &&  variant.canConvert<int> () && ( index.row() == variant.value<int>() ) ) {
+    return;
+    }         
+    mModel->setData( index, index.row(), GlxFocusIndexRole );    
+    mZoomSlider->indexChanged(index.row());
+    // mZoomControl->indexChanged(index.row());
+    SetImageToHdmiL(); // for the image changed on swipe
+    }
+
+void GlxFullScreenView::indexChanged(const QModelIndex &index)
+    {
+    TRACER("GlxFullScreenView::indexChanged()");
+    GLX_LOG_INFO1("GlxFullScreenView::indexChanged() %d", index.row() );
+    QVariant variant = mModel->data( mModel->index(0,0), GlxFocusIndexRole );    
+    if ( variant.isValid() &&  variant.canConvert<int> () && ( index.row() == variant.value<int>() ) ) {
+    return;
+    }         
+    mModel->setData( index, index.row(), GlxFocusIndexRole );
+    mCoverFlow->indexChanged(index.row());
+    mZoomSlider->indexChanged(index.row());
+    mImageStrip->scrollTo(index, HbGridView::PositionAtCenter );
+    //mZoomControl->indexChanged(index.row());
+    SetImageToHdmiL();  // for the indexchnaged through filmstrip
+    }
+
+void GlxFullScreenView::scrollingStarted()
+    {
+    TRACER("GlxFullScreenView::scrollingStarted() ");
+    //no need to hide the ui during image strip scrolling
+    if ( mUiOffTimer ) {
+    mUiOffTimer->stop();
+    }
+    }
+
+void GlxFullScreenView::scrollingEnded()
+    {
+    TRACER("GlxFullScreenView::scrollingEnded() ");
+    if ( mUiOffTimer ) {
+    mUiOffTimer->start(KUiOffTime);
+    }
+    setVisvalWindowIndex();
+    }
+
+void GlxFullScreenView::pressed(const QModelIndex &index)
+    {
+    Q_UNUSED(index)
+    TRACER("GlxFullScreenView::pressed() ");
+    if ( mUiOffTimer ) {
+    mUiOffTimer->stop();
+    }
+    }
+
+void GlxFullScreenView::released(const QModelIndex &index)
+    {
+    Q_UNUSED(index)
+    TRACER("GlxFullScreenView::released() ");
+
+    if ( mUiOffTimer && mImageStrip->isScrolling() == false ) {
+    mUiOffTimer->start(KUiOffTime);
+    }
+    }
+
+void GlxFullScreenView::setVisvalWindowIndex()
+    {
+    TRACER("GlxFullScreenView::setVisvalWindowIndex()");
+    QList< HbAbstractViewItem * >  visibleItemList =  mImageStrip->visibleItems();
+
+    GLX_LOG_INFO1("GlxFullScreenView::setVisvalWindowIndex() %d", visibleItemList.count());    
+    if ( visibleItemList.count() <= 0 )
+        return ;
+
+    HbAbstractViewItem *item = visibleItemList.at(0);
+    GLX_LOG_INFO1("GlxFullScreenView::setVisvalWindowIndex()1 item %u", item);
+    if ( item == NULL ) 
+        return ;
+
+    GLX_LOG_INFO1("GlxFullScreenView::setVisvalWindowIndex() item %u", item);
+
+    GLX_LOG_INFO1("GlxFullScreenView::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 GlxFullScreenView::coverFlowEventHandle( GlxCoverFlowEvent e )
+    {
+    TRACER("GlxFullScreenView::coverFlowEventHandle()");
+    switch( e ){
+    case TAP_EVENT :
+        activateUI();
+        break ;
+        
+    case PANNING_START_EVENT :
+        hideUi();
+        break ;
+        
+    case EMPTY_ROW_EVENT :
+        emit actionTriggered( EGlxCmdEmptyData );
+        break ;
+        
+    default :
+        break ;
+    }    
+}
+
+void GlxFullScreenView::setLayout()
+    {
+    TRACER("GlxFullScreenView::setLayout()");
+    //TO:DO read form layout doc
+    GLX_LOG_INFO1("GlxFullScreenView::setLayout() %d", mWindow->orientation() ); 
+
+    QRect screen_rect = mWindow->geometry(); 
+    QSize sz(screen_rect.width(), screen_rect.height());
+
+
+    mCoverFlow->setItemSize(sz);
+    mZoomControl->setGeometry(screen_rect);
+    mZoomControl->setWindowSize(sz);
+
+    mZmPushButton->setZValue(6);
+    mZmPushButton->setGeometry(QRectF(0,50,50,50));    
+    }
+
+void GlxFullScreenView::addConnection()
+    {
+    TRACER("GlxFullScreenView::addConnection() " );
+    if ( mCoverFlow ) {    
+        connect( mCoverFlow, SIGNAL( coverFlowEvent( GlxCoverFlowEvent ) ), this, SLOT( coverFlowEventHandle( GlxCoverFlowEvent ) ) );
+    connect( mCoverFlow, SIGNAL(changeSelectedIndex(const QModelIndex &)), this, SLOT( changeSelectedIndex( const QModelIndex & )));
+
+    }
+
+    if ( mImageStrip ) {
+    connect(mImageStrip, SIGNAL( activated(const QModelIndex &) ), this, SLOT( indexChanged(const QModelIndex &) ));
+    connect(mImageStrip, SIGNAL( scrollingStarted()),  this, SLOT( scrollingStarted()));
+    connect(mImageStrip, SIGNAL( scrollingEnded()),    this, SLOT( scrollingEnded()));
+    connect(mImageStrip, SIGNAL( pressed(const QModelIndex &) ),      this, SLOT( pressed(const QModelIndex &) ));
+    connect(mImageStrip, SIGNAL( released(const QModelIndex &) ),     this, SLOT( released(const QModelIndex &) ));
+    }
+
+    if ( mUiOffTimer ) {
+    connect(mUiOffTimer, SIGNAL(timeout()), this, SLOT(hideUi()));
+    }
+    //for Zoom
+    if(mZmPushButton &&mZoomSlider) {
+    connect(mZmPushButton, SIGNAL(clicked()), mZoomSlider, SLOT(toggleSliderVisibility()));
+    }
+
+    if(mFlipPushButton)
+        {
+        connect(mFlipPushButton, SIGNAL(clicked()), this, SLOT(showdetailsview()), Qt::QueuedConnection);
+        }
+
+
+    if(mZoomControl && mZoomSlider) {
+    connect(mZoomSlider, SIGNAL(initialZoomFactor(int)), mZoomControl, SLOT(initialZoomFactor(int)));
+    connect(mZoomSlider, SIGNAL(valueChanged(int)), mZoomControl, SLOT(zoomImage(int)));
+    connect(mZoomControl, SIGNAL(hideFullScreenUi()), this, SLOT(hideUi()));
+    }
+
+    connect(mWindow, SIGNAL(orientationChanged(Qt::Orientation)), this, SLOT(orientationChanged(Qt::Orientation)));
+    }
+
+void GlxFullScreenView::removeConnection()
+    {
+    TRACER("GlxFullScreenView::removeConnection() " );
+
+    if ( mCoverFlow ) {    
+    GLX_LOG_INFO("GlxFullScreenView::removeConnection() mCoverFlow " );
+        disconnect( mCoverFlow, SIGNAL( coverFlowEvent( GlxCoverFlowEvent ) ), this, SLOT( coverFlowEventHandle( GlxCoverFlowEvent ) ) );
+    disconnect( mCoverFlow, SIGNAL(changeSelectedIndex(const QModelIndex &)), this, SLOT( changeSelectedIndex( const QModelIndex & )));
+
+    }
+
+    //For Image Strip
+    if ( mImageStrip ) {
+    GLX_LOG_INFO("GlxFullScreenView::removeConnection() mImageStrip " );
+    disconnect(mImageStrip, SIGNAL( activated(const QModelIndex &) ), this, SLOT( indexChanged(const QModelIndex &) ));
+    disconnect(mImageStrip, SIGNAL( scrollingStarted()), this, SLOT( scrollingStarted()));
+    disconnect(mImageStrip, SIGNAL( scrollingEnded()), this, SLOT( scrollingEnded()));
+    disconnect(mImageStrip, SIGNAL( pressed(const QModelIndex &) ), this, SLOT( pressed(const QModelIndex &) ));
+    disconnect(mImageStrip, SIGNAL( released(const QModelIndex &) ), this, SLOT( released(const QModelIndex &) ));
+    }
+
+    if ( mUiOffTimer ) {
+    GLX_LOG_INFO("GlxFullScreenView::removeConnection() mUiOffTimer  " );
+    disconnect(mUiOffTimer, SIGNAL(timeout()), this, SLOT(hideUi()));
+    }
+
+    //for Zoom
+    if(mZmPushButton &&mZoomSlider) {
+    GLX_LOG_INFO("GlxFullScreenView::removeConnection() mZoomSlider " );
+    disconnect(mZmPushButton, SIGNAL(clicked()), mZoomSlider, SLOT(toggleSliderVisibility()));
+    }
+
+    if(mZoomControl &&mZoomSlider) {
+    GLX_LOG_INFO("GlxFullScreenView::removeConnection() mZoomSlider  " );
+    disconnect(mZoomSlider, SIGNAL(initialZoomFactor(int)), mZoomControl, SLOT(initialZoomFactor(int)));
+    disconnect(mZoomSlider, SIGNAL(valueChanged(int)), mZoomControl, SLOT(zoomImage(int)));
+    disconnect(mZoomControl, SIGNAL(hideFullScreenUi()), this, SLOT(hideUi()));
+    }
+
+    //for Details view launching
+    if(mFlipPushButton) {
+    GLX_LOG_INFO("GlxFullScreenView::removeConnection() mFlipPushButton  " );
+    disconnect(mFlipPushButton, SIGNAL(clicked()), this, SLOT(showdetailsview()));
+    }
+
+    disconnect(mWindow, SIGNAL(orientationChanged(Qt::Orientation)), this, SLOT(orientationChanged(Qt::Orientation)));
+    }
+
+void GlxFullScreenView::setImageStripModel()
+    {
+    TRACER("GlxFullScreenView::setImageStripModel()" );
+    if ( mModel && mImageStrip ) {
+    mImageStrip->setModel( mModel );
+    QVariant variant = mModel->data( mModel->index(0,0), GlxFocusIndexRole );    
+    if ( variant.isValid() &&  variant.canConvert<int> () ) {
+    mImageStrip->setCurrentIndex  ( mModel->index( variant.value<int>(), 0) );  
+    } 
+    }
+    }
+
+GlxFullScreenView::~GlxFullScreenView()
+    {
+    TRACER("GlxFullScreenView::~GlxFullScreenView()" );
+	cleanUp();
+    
+	if(mImageStrip) {
+    GLX_LOG_INFO("GlxFullScreenView::cleanUp() delete mImageStrip " );
+    delete mImageStrip;
+    mImageStrip = NULL;
+    }
+
+    if(mFlipPushButton) {
+    GLX_LOG_INFO("GlxFullScreenView::cleanUp() delete mFlipPushButton " );
+    delete mFlipPushButton;
+    mFlipPushButton = NULL;
+    }
+
+    if(mCoverFlow) {
+    GLX_LOG_INFO("GlxFullScreenView::~GlxFullScreenView() delete mCoverFlow " );
+    delete mCoverFlow;
+    mCoverFlow = NULL;
+    }
+
+    if(mDocLoader != NULL)
+        {
+        mDocLoader->reset();
+        delete mDocLoader;    
+        }
+    HbEffect::remove( QString("HbGridView"), QString(":/data/transitionup.fxml"), QString( "TapShow" ));
+    HbEffect::remove( QString("HbGridView"), QString(":/data/transitiondown.fxml"), QString( "TapHide" ));  
+    }
+
+void GlxFullScreenView::showdetailsview()
+    {
+    TRACER("GlxFullScreenView::showdetailsview()" );
+    //trigger the details view to be shown
+    emit actionTriggered( EGlxCmdDetailsOpen );
+    }
+
+void GlxFullScreenView::handleUserAction(qint32 commandId)
+    {
+    TRACER("GlxFullScreenView::handleUserAction()" );
+    switch( commandId )
+        {
+        case EGlxCmdRotate :
+            //trigger the rotate Effect in CoverFlow
+            mCoverFlow->rotateImage();
+            break;
+        case EGlxCmdSend:
+            {
+            QString imagePath = (mModel->data(mModel->index(mModel->data(mModel->index(0,0),GlxFocusIndexRole).value<int>(),0),GlxUriRole)).value<QString>();
+            if(imagePath.isNull())
+                {
+                GLX_LOG_INFO("GlxFullScreenView::SendUi() path is null" );
+                }
+            qDebug() << "GlxFullScreenView::SendUi() imagePath= " << imagePath;
+
+            ShareUi dialog;
+            QList <QVariant> fileList;
+            fileList.append(QVariant(imagePath));
+            dialog.init(fileList,true);
+            }
+            break;
+        default :
+            break;
+        }
+    }
+
+void GlxFullScreenView::SetImageToHdmiL()
+    {
+    TRACER("GlxFullScreenView::SetImageToHdmiL() - CGlxHdmi 1" );
+    if (iHdmiController)
+        {
+        GLX_LOG_INFO("GlxFullScreenView::SetImageToHdmiL() - CGlxHdmi 2" );
+        // Get the image uri
+        QString imagePath = (mModel->data(mModel->index(mModel->data(mModel->index(0,0),GlxFocusIndexRole).value<int>(),0),GlxUriRole)).value<QString>();
+        if(imagePath.isNull())
+            {
+            GLX_LOG_INFO("GlxFullScreenView::SetImageToHdmiL() path is null" );
+            }
+        qDebug() << "GlxFullScreenView::SetImageToHdmiL() imagePath= " << imagePath;
+        TPtrC aPtr = reinterpret_cast<const TUint16*>(imagePath.utf16());
+
+        // Get the image Dimensions
+        QSize imageDimension = (mModel->data(mModel->index(mModel->data(mModel->index(0,0),GlxFocusIndexRole).value<int>(),0),GlxDimensionsRole)).value<QSize>();
+        TSize imageSize(imageDimension.width(),imageDimension.height());
+        
+        // Get the framecount
+        int frameCount = (mModel->data(mModel->index(mModel->data(mModel->index(0,0),GlxFocusIndexRole).value<int>(),0),GlxFrameCount)).value<int>();
+        iHdmiController->SetImageL(aPtr,imageSize, frameCount);
+        }
+    }