/*

* 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 &) ));