/*

* 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 <QTimer>

#include <hbmenu.h>

#include <HbAction>

#include <HbToolBar>

#include <hbgridview.h>

#include <hbpushbutton.h>

#include <hbmainwindow.h>

#include <shareuidialog.h>

#include <hbdocumentloader.h>

#include <QAbstractItemModel>

#include <hbabstractviewitem.h>

#include <hbiconitem.h>

#include <QCoreApplication>

#include <xqserviceutil.h>

//User Includes

#include "glxlog.h"

#include "glxtracer.h"

#include "glxviewids.h"  //contains the view ids of all the views in photos app.

#include "glxicondefs.h" //Contains the icon names/Ids

#include "glxmodelparm.h"

#include "glxcoverflow.h"

#include "glxdocloaderdefs.h" //contains the definations of path, widget names and view names in docml

#include "glxloggerenabler.h"

#include "glxtvoutwrapper.h"

#include "glxfullscreenview.h" 

#include "glxcommandhandlers.hrh"

#include "glxzoomwidget.h"

#include "glxlocalisationstrings.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "glxfullscreenviewTraces.h"

#endif

const int KUiOffTime = 3000;

GlxFullScreenView::GlxFullScreenView(HbMainWindow *window,HbDocumentLoader *DocLoader) : 

    GlxView ( GLX_FULLSCREENVIEW_ID ), 

    mModel( NULL ), 

    mWindow( window ), 

    mCoverFlow( NULL ) , 

    mImageStrip( NULL ), 

    mUiOffTimer( NULL ),

    mBackGroundItem( NULL ),

    mTvOutWrapper( NULL ),

    mFullScreenToolBar( NULL ),

	mZoomWidget( NULL ),

	mUiOff ( false )

{

    OstTraceFunctionEntry0( GLXFULLSCREENVIEW_GLXFULLSCREENVIEW_ENTRY );

    mIconItems[0] = NULL;

    mIconItems[1] = NULL;

    mDocLoader = DocLoader;

    setContentFullScreen( true );

    HbEffect::add( QString( "HbGridView" ), QString( ":/data/transitionup.fxml" ), QString( "TapShow" ) );

    HbEffect::add( QString( "HbGridView" ), QString( ":/data/transitiondown.fxml" ), QString( "TapHide" ) );

    HbEffect::add( QString( "HbGridViewItem" ), QString( ":/data/zoomin.fxml" ), QString( "SelectHide" ) );

    HbEffect::add( QString( "HbGridViewItem" ), QString( ":/data/zoomout.fxml" ), QString( "SelectShow" ) );

    HbEffect::add( QString( "HbIconItem" ), QString( ":/data/rotatefslandscape.fxml" ), QString( "RotateFSLS" ) );

    HbEffect::add( QString( "HbIconItem" ), QString( ":/data/rotatefsprotrait.fxml" ), QString( "RotateFSPT" ) );

    OstTraceFunctionExit0( GLXFULLSCREENVIEW_GLXFULLSCREENVIEW_EXIT );

}

void GlxFullScreenView::initializeView( QAbstractItemModel *model, GlxView *preView )

{

    OstTraceFunctionEntry0( GLXFULLSCREENVIEW_INITIALIZEVIEW_ENTRY );

    // if animations is on, then Set the image to HDMI here

    if (!mTvOutWrapper){

        mTvOutWrapper = new GlxTvOutWrapper();

    }

    setHdmiModel(model);

    loadWidgets();

    /* 

     * Initialize the coverflow and partially creates the coverflow with one image

     * to make the widget light weight in order to make transition smooth 

     */

    /* 

     * Grid view is not in full screen mode so this view have some flicker after transtion is finshed 

     * and some cases in grid view status bar is visible and some cases it is not

     * so adjust the initial postion of fullscreen base on status bar visiblity.

     */

    if ( preView->compare( GLX_GRIDVIEW_ID ) && preView->isItemVisible ( Hb::StatusBarItem ) ) {

        qreal chromeHeight = 0;

        style()->parameter( "hb-param-widget-chrome-height", chromeHeight );

        mCoverFlow->partiallyCreate( model, screenSize(), -chromeHeight );

    }

    else {

        mCoverFlow->partiallyCreate( model, screenSize() );

    }

    OstTraceFunctionExit0( GLXFULLSCREENVIEW_INITIALIZEVIEW_EXIT );

}

void GlxFullScreenView::loadWidgets()

{

    OstTraceFunctionEntry0( GLXFULLSCREENVIEW_LOADWIDGETS_ENTRY );

    mCoverFlow = qobject_cast<GlxCoverFlow*> (mDocLoader->findWidget(GLXFULLSCREEN_COVERFLOW));

    mZoomWidget  =  qobject_cast<GlxZoomWidget*> (mDocLoader->findWidget(GLXFULLSCREENZOOMWIDGET));

    mZoomWidget->connectDecodeRequestToPinchEvent();

    mCoverFlow->setMultitouchFilter(mZoomWidget);

    //initialise the cover flow for basic connections and the rest

    mCoverFlow->setCoverFlow();

    mImageStrip = qobject_cast<HbGridView*> (mDocLoader->findWidget(GLXFULLSCREEN_FILMSTRIP));

    //When the widget is loaded/retreived the widgets are shown by default.

    //@to do : hide the widgets by default in docml

    mImageStrip->hide();      

	mImageStrip->setLayoutName( QString( "ImageStrip" ) ); // To distinguish in CSS file

	mImageStrip->setEnabledAnimations( HbAbstractItemView::None );

	mImageStrip->setHorizontalScrollBarPolicy( HbScrollArea::ScrollBarAlwaysOff );

    OstTraceFunctionExit0( GLXFULLSCREENVIEW_LOADWIDGETS_EXIT );

}

void GlxFullScreenView::loadFullScreenToolBar()

{

    OstTraceFunctionEntry0( GLXFULLSCREENVIEW_LOADFULLSCREENTOOLBAR_ENTRY );

    //The fullscreen tool bar is delted when ever the view is deactivated

    //so load the docml once again and retreive the object

    bool loaded =true;      

    mDocLoader->load(GLXFULLSCREENDOCMLPATH,&loaded);

    loadViewSection();

    mFullScreenToolBar = qobject_cast<HbToolBar *> (mDocLoader->findObject(QString("toolBar")));

    mFullScreenToolBar->clearActions();

    addToolBarAction( EGlxCmdDetailsOpen, GLXICON_FLIP, "Flip Action" ); //create  Flip tool bar button action

    addToolBarAction( EGlxCmdSend, GLXICON_SEND, "Send Action" );        //create  Send tool bar button action

    if( getSubState() != IMAGEVIEWER_S ) {        

        addToolBarAction( EGlxCmdDelete, GLXICON_DELETE, "Delete Action" ); //create  Delete tool bar button action

    }

    else {

        addToolBarAction( EGlxCmdHandled, GLXICON_USEIMAGE, "Use Action" ); //create  Use Image tool bar button action

    }

    OstTraceFunctionExit0( GLXFULLSCREENVIEW_LOADFULLSCREENTOOLBAR_EXIT );

}

void GlxFullScreenView::addToolBarAction( int commandId, const QString &iconName, const QString &name )

{

    HbAction *action = new HbAction( this ); 

    action->setData( commandId );

    action->setIcon( HbIcon( iconName ) ); 

    action->setObjectName( name );

    mFullScreenToolBar->addAction( action );

    connect(action, SIGNAL(triggered( )), this, SLOT(handleToolBarAction( )) ); 

}

void GlxFullScreenView::activate()

{

    OstTraceFunctionEntry0( GLXFULLSCREENVIEW_ACTIVATE_ENTRY );    

//for zoom might not be required after wk15 release

	mWindow->viewport()->setAttribute(Qt::WA_AcceptTouchEvents,true); 

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

	QCoreApplication::instance()->installEventFilter(this);

    if( !mCoverFlow ) {

        loadWidgets();  //retrives the widgets

    }

    //Loads the widgets corresponding to the orientation.

    loadViewSection();

    HbView::HbViewFlags flags( HbView::ViewTitleBarTransparent | HbView::ViewStatusBarTransparent);

    setViewFlags(flags);

	// In case of fetcher don't hide status pane and title bar

    if(!(XQServiceUtil::isService() && (0 == XQServiceUtil::interfaceName().compare(QLatin1String("com.nokia.symbian.IImageFetch"))))) {

        setViewFlags( viewFlags() | HbView::ViewTitleBarHidden | HbView::ViewStatusBarHidden );

		mUiOff = true;

	}

    else

        {

        HbAction* selectAction = new HbAction(GLX_BUTTON_SELECT);

        selectAction->setObjectName( "FS Select" );

        connect(selectAction, SIGNAL(triggered()), this, SLOT(handleFSSelect()));

        HbToolBar* toolBar = new HbToolBar();

        toolBar->setOrientation( Qt::Horizontal );

        toolBar->setVisible(true);

        toolBar->addAction(selectAction);

        setToolBar(toolBar);

        }

    mUiOffTimer = new QTimer();

    mUiOffTimer->stop();        

    mCoverFlow->setUiOn(FALSE);    

    addConnection(); 

    setLayout();

    if (!mTvOutWrapper) {

        mTvOutWrapper = new GlxTvOutWrapper();

    }

    mWindow->setAutomaticOrientationEffectEnabled( false );

    OstTraceFunctionExit0( GLXFULLSCREENVIEW_ACTIVATE_EXIT );

}

void GlxFullScreenView::handleFSSelect()

{

    emit actionTriggered( EGlxCmdFetcherSelect );

}

void GlxFullScreenView::loadViewSection()

{

    OstTraceFunctionEntry0( GLXFULLSCREENVIEW_LOADVIEWSECTION_ENTRY );    

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

    }

    OstTraceFunctionExit0( GLXFULLSCREENVIEW_LOADVIEWSECTION_EXIT );

}

void GlxFullScreenView::resetView()

{

    OstTraceFunctionEntry0( GLXFULLSCREENVIEW_RESETVIEW_ENTRY );    

    cancelSelectionAnimation(); //cancel the image selection effect before cleaning the view

    //Clean up the rest of the resources allocated

    cleanUp(); 

    //Clear the 4 icons present in the Coverflow,so that the transition between the views are smooth

    mCoverFlow->partiallyClean();

    OstTraceFunctionExit0( GLXFULLSCREENVIEW_RESETVIEW_EXIT );

}

void GlxFullScreenView::deActivate()

{ 

    OstTraceFunctionEntry0( GLXFULLSCREENVIEW_DEACTIVATE_ENTRY );    

    cancelSelectionAnimation(); //cancel the image selection effect before cleaning the view

	//Clean up the rest of the resources allocated

    cleanUp();

    QCoreApplication::instance()->removeEventFilter(this);

    //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;

    mWindow->setAutomaticOrientationEffectEnabled( true );

    OstTraceFunctionExit0( GLXFULLSCREENVIEW_DEACTIVATE_EXIT );

}

void GlxFullScreenView::cleanUp()

{ 

    OstTraceFunctionEntry0( GLXFULLSCREENVIEW_CLEANUP_ENTRY );

    removeConnection();

    if ( mUiOffTimer ) {

        OstTrace0( TRACE_NORMAL, GLXFULLSCREENVIEW_CLEANUP, "GlxFullScreenView::cleanUp() mUiOffTimer" );

        mUiOffTimer->stop();

        delete mUiOffTimer;

        mUiOffTimer = NULL;

    }

    if(mFullScreenToolBar) {

       mFullScreenToolBar->clearActions();

       mFullScreenToolBar->hide();

       mFullScreenToolBar = NULL;

    }

    if (mTvOutWrapper) {

        delete mTvOutWrapper;

        mTvOutWrapper = NULL;

    }

    if(mZoomWidget)

    {

        mZoomWidget->cleanUp();

        mZoomWidget = NULL;

    }

    OstTraceFunctionExit0( GLXFULLSCREENVIEW_CLEANUP_EXIT );

}

QGraphicsItem * 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 )

{

    OstTraceFunctionEntry0( GLXFULLSCREENVIEW_SETMODEL_ENTRY );

    OstTraceExt2( TRACE_NORMAL, GLXFULLSCREENVIEW_SETMODEL, "GlxFullScreenView::setModel; model=%x; mModel=%u", ( TUint )( model ), ( TUint ) mModel );

    mModel = model;     

	setModelContext();  

    setHdmiModel(mModel);

	mZoomWidget->setModel(mModel);  

    mCoverFlow->setModel(mModel);

    setImageStripModel();

    if(getSubState() == IMAGEVIEWER_S) {

        setTitle(GLX_IMAGE_VIEWER);

    }

	else if(getSubState() == FETCHER_S){ //do not zoom in case of fetcher

		disconnect(mCoverFlow,SIGNAL( doubleTapEventReceived(QPointF) ), mZoomWidget, SLOT( animateZoomIn(QPointF) ) );

	}

    OstTraceFunctionExit0( GLXFULLSCREENVIEW_SETMODEL_EXIT );

}

void GlxFullScreenView::setHdmiModel(QAbstractItemModel* model)

{

    if (mTvOutWrapper) {

        mTvOutWrapper->setModel(model, screenSize()); 

        mTvOutWrapper->setImagetoHDMI(); // for the first image on screen

    }    

}

void GlxFullScreenView::setModelContext()

{

    OstTraceFunctionEntry0( GLXFULLSCREENVIEW_SETMODELCONTEXT_ENTRY );

    if ( mModel && mWindow ) {

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

        }

    }

    OstTraceFunctionExit0( GLXFULLSCREENVIEW_SETMODELCONTEXT_EXIT );

}

void GlxFullScreenView::orientationChanged(Qt::Orientation orient)

{

    OstTraceFunctionEntry0( GLXFULLSCREENVIEW_ORIENTATIONCHANGED_ENTRY );

    Q_UNUSED(orient)

    // fullscreen thumnail size is depends on orientation of phone so change the model context before changing the layout

    if ( mUiOff == FALSE ) {

        mUiOffTimer->start(KUiOffTime);

    }

    setModelContext();

    loadViewSection();

    setLayout();

    if ( mZoomWidget->zValue() >= mCoverFlow->zValue() ) {

        playZoomOrientChangeAnim();

    }

    else {

        playOrientChangeAnim();

    }

    OstTraceFunctionExit0( GLXFULLSCREENVIEW_ORIENTATIONCHANGED_EXIT );

}

void GlxFullScreenView::activateUI()

{

    OstTraceFunctionEntry0( GLXFULLSCREENVIEW_ACTIVATEUI_ENTRY );

    if ( mUiOff && getSubState() != FETCHER_S ){      

        if( !mFullScreenToolBar ) {

            loadFullScreenToolBar();

        }

        mUiOff = FALSE;

        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::PositionAtTop ); 

        }

        setItemVisible( Hb::AllItems, TRUE );

        setViewFlags( viewFlags() &~ HbView::ViewTitleBarHidden &~ HbView::ViewStatusBarHidden );

        if ( mImageStrip && getSubState() != IMAGEVIEWER_S) {

            mImageStrip->show(); 

            HbEffect::start(mImageStrip, QString("HbGridView"), QString("TapShow"), this, "effectFinished" );

        }

        else if( getSubState() == IMAGEVIEWER_S){

            setTitle(GLX_IMAGE_VIEWER);

        }

        mFullScreenToolBar->setOpacity( 1 );

        mFullScreenToolBar->show();

    }

    else {

        hideUi();

    }

    OstTraceFunctionExit0( GLXFULLSCREENVIEW_ACTIVATEUI_EXIT );

}

void GlxFullScreenView::hideUi()

{

    OstTraceFunctionEntry0( GLXFULLSCREENVIEW_HIDEUI_ENTRY );

    //if option menu is open then no need to hide the status bar and image strip

    HbMenu *menuWidget = menu();

    if ( menuWidget->isVisible() ) { 

        OstTraceFunctionExit0( GLXFULLSCREENVIEW_HIDEUI_EXIT );

        return ;

    }

    mUiOff = TRUE;

	if ( getSubState() != FETCHER_S ) {

	    setViewFlags( viewFlags() | HbView::ViewTitleBarHidden | HbView::ViewStatusBarHidden );

	}

    if ( mImageStrip && ( getSubState() != IMAGEVIEWER_S && getSubState() != FETCHER_S ) ) {

        HbEffect::start( mImageStrip, QString("HbGridView"), QString("TapHide"), this, "effectFinished" );

    }

    if(mFullScreenToolBar) {

       mFullScreenToolBar->hide();

    }

    OstTraceFunctionExit0( DUP1_GLXFULLSCREENVIEW_HIDEUI_EXIT );

}

void GlxFullScreenView::changeSelectedIndex(const QModelIndex &index)

{

    OstTraceFunctionEntry0( GLXFULLSCREENVIEW_CHANGESELECTEDINDEX_ENTRY );

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

    if ( variant.isValid() &&  variant.canConvert<int> () && ( index.row() == variant.value<int>() ) ) {

        OstTraceFunctionExit0( GLXFULLSCREENVIEW_CHANGESELECTEDINDEX_EXIT );

        if (mTvOutWrapper){

            // for the image changed on deletion

            mTvOutWrapper->setImagetoHDMI();

        }

        if (mZoomWidget){

            // for the image changed on deletion

            mZoomWidget->indexChanged();

        }

        return;

    }

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

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

	mZoomWidget->indexChanged(index.row());  

    if (mTvOutWrapper){

        // for the image changed on swipe

        mTvOutWrapper->setImagetoHDMI();

    }

    OstTraceFunctionExit0( DUP1_GLXFULLSCREENVIEW_CHANGESELECTEDINDEX_EXIT );

}

void GlxFullScreenView::indexChanged(const QModelIndex &index)

{

    OstTraceFunctionEntry0( GLXFULLSCREENVIEW_INDEXCHANGED_ENTRY );    

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

    if ( variant.isValid() &&  variant.canConvert<int> () && ( index.row() == variant.value<int>() ) ) {

       OstTraceFunctionExit0( GLXFULLSCREENVIEW_INDEXCHANGED_EXIT );

       return;

    }         

    if (mTvOutWrapper){

        // for the indexchnaged through filmstrip

        mTvOutWrapper->setImagetoHDMI();

    }

    //disable the animation for the time being

    imageSelectionAnimation( index );

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

    mZoomWidget->indexChanged(index.row());

    mZoomWidget->setVisible( false );

    OstTraceFunctionExit0( DUP1_GLXFULLSCREENVIEW_INDEXCHANGED_EXIT );

}

void GlxFullScreenView::scrollingStarted()

{

    OstTraceFunctionEntry0( GLXFULLSCREENVIEW_SCROLLINGSTARTED_ENTRY );

    //no need to hide the ui during image strip scrolling

    if ( mUiOffTimer ) {

        mUiOffTimer->stop();

    }

    OstTraceFunctionExit0( GLXFULLSCREENVIEW_SCROLLINGSTARTED_EXIT );

}

void GlxFullScreenView::scrollingEnded()

{

    OstTraceFunctionEntry0( GLXFULLSCREENVIEW_SCROLLINGENDED_ENTRY );

    if ( mUiOffTimer ) {

        mUiOffTimer->start(KUiOffTime);

    }

    setVisvalWindowIndex();

    OstTraceFunctionExit0( GLXFULLSCREENVIEW_SCROLLINGENDED_EXIT );