/*

* Copyright (c) 2010 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:  Implementation of QMPXVideoPlaybackToolBar

*

*/

#include <QTimer>

#include <QGraphicsLayout>

#include <hbeffect.h>

#include <hbaction.h>

#include <hbtoolbar.h>

#include <hbinstance.h>

#include <hbtoolbutton.h>

#include <w32std.h>

#include "mpxvideo_debug.h"

#include "hbvideobaseplaybackview.h"

#include "mpxvideoplaybacktoolbar.h"

#include "mpxcommonvideoplaybackview.hrh"

#include "mpxvideoplaybackdocumentloader.h"

#include "mpxvideoplaybackviewfiledetails.h"

#include "mpxvideoplaybackcontrolscontroller.h"

const int KSeekStartTimeOut = 700;

const int KRetrieveButtonTimeOut = 1000;

// -------------------------------------------------------------------------------------------------

// QMPXVideoPlaybackToolBar::QMPXVideoPlaybackToolBar()

// -------------------------------------------------------------------------------------------------

//

QMPXVideoPlaybackToolBar::QMPXVideoPlaybackToolBar( 

        QMPXVideoPlaybackControlsController* controller )

    : mController( controller )

    , mSeekStartTimer( NULL )

    , mRetrieveButtonTimer( NULL )

    , mSeekingState( EMPXNotSeeking )

    , mInitialized( false )

    , mNeverVisibled( true )

    , mPosition( 0 )

    , mDuration( 0 )

    , mAspectRatio( EMPXPbvCmdNaturalAspectRatio )

{

    MPX_ENTER_EXIT(_L("QMPXVideoPlaybackToolBar::QMPXVideoPlaybackToolBar"));

    mToolBar = mController->view()->toolBar();

    mToolBar->setOrientation( Qt::Horizontal );

    HbEffect::disable( mToolBar );

    mController->view()->hideItems( Hb::ToolBarItem );

    initialize();

}

// -------------------------------------------------------------------------------------------------

// QMPXVideoPlaybackToolBar::~QMPXVideoPlaybackToolBar()

// -------------------------------------------------------------------------------------------------

//

QMPXVideoPlaybackToolBar::~QMPXVideoPlaybackToolBar()

{

    MPX_DEBUG(_L("QMPXVideoPlaybackToolBar::~QMPXVideoPlaybackToolBar()"));

    HbEffect::enable( mToolBar );

    mToolBar->clearActions();

    for ( int i = 0 ; i < mButtonIcons.count() ; i++ )

    {

        if ( mButtonIcons[i] )

        {

            delete mButtonIcons[i];

        }

    }

    mButtonIcons.clear();

    if ( mSeekStartTimer )

    {

        if ( mSeekStartTimer->isActive() )

        {

            mSeekStartTimer->stop();

        }

        delete mSeekStartTimer;

        mSeekStartTimer = NULL;

    }

    if ( mRetrieveButtonTimer )

    {

        if ( mRetrieveButtonTimer->isActive() )

        {

            mRetrieveButtonTimer->stop();

        }

        delete mRetrieveButtonTimer;

        mRetrieveButtonTimer = NULL;

    }

}

// -------------------------------------------------------------------------------------------------

// QMPXVideoPlaybackToolBar::initialize()

// -------------------------------------------------------------------------------------------------

//

void QMPXVideoPlaybackToolBar::initialize()

{

    MPX_ENTER_EXIT(_L("QMPXVideoPlaybackToolBar::initialize()"));

    //

    // Don't need to initialize buttons once it gets initialized

    //

    if ( ! mInitialized )

    {

        mInitialized = true;

        QActionGroup *actionsGroup = new QActionGroup( mToolBar );

        for ( int i = 0 ; i < EMPXButtonCount ; i++ )

        {

            mButtonActions.append( new HbAction( actionsGroup ) );

        }

        for ( int i = 0 ; i < EMPXIconCount ; i++ )

        {

            mButtonIcons.append( new HbIcon() );

        }

        //

        // RW button

        //

        mButtonIcons[EMPXRWIcon]->setIconName( "qtg_mono_previous" );

        mButtonActions[EMPX2ndButton]->setIcon( *mButtonIcons[EMPXRWIcon] );

        //

        // Play/Pause button

        //

        mButtonIcons[EMPXPlayIcon]->setIconName( "qtg_mono_play" );

        mButtonIcons[EMPXPauseIcon]->setIconName( "qtg_mono_pause" );

        mButtonActions[EMPX3rdButton]->setIcon( *mButtonIcons[EMPXPlayIcon] );

        //

        // FF button

        //

        mButtonIcons[EMPXFFIcon]->setIconName( "qtg_mono_next" );

        mButtonActions[EMPX4thButton]->setIcon( *mButtonIcons[EMPXFFIcon] );

        //

        // Details button

        //

        mButtonIcons[EMPXDetailsIcon]->setIconName( "qtg_mono_info" );

        mButtonActions[EMPX5thButton]->setIcon( *mButtonIcons[EMPXDetailsIcon] );

        //

        // Aspect ratio buttons

        //

        mButtonIcons[EMPXNaturalIcon]->setIconName( "qtg_mono_aspect_ratio_natural" );

        mButtonIcons[EMPXStretchIcon]->setIconName( "qtg_mono_aspect_ratio_stretched" );

        mButtonIcons[EMPXZoomIcon]->setIconName( "qtg_mono_aspect_ratio_zoom" );

        mButtonActions[EMPX1stButton]->setIcon( *mButtonIcons[EMPXNaturalIcon] );

        //

        // Attach/Share button 

        //

        mButtonIcons[EMPXAttachIcon]->setIconName( "qtg_mono_attach" );

        mButtonIcons[EMPXShareIcon]->setIconName( "qtg_mono_share" );

        for ( int i = 0 ; i < EMPXButtonCount ; i++ )

        {

            mButtonActions[i]->setCheckable( false );

            mToolBar->addAction( mButtonActions[i] );

        }

        mDuration = (qreal)mController->fileDetails()->mDuration / (qreal)KPbMilliMultiplier;

        //

        // Create a timer for seeking. 

        // We will issue SetPosition every KSeekingTimeOut msec to show the current frame to user

        //

        mSeekStartTimer = new QTimer();

        mSeekStartTimer->setSingleShot( true );

        mSeekStartTimer->setInterval( KSeekStartTimeOut );

        //

        // get window size

        //

        RWindow *window = mController->view()->getWindow();            

        TRect displayRect = TRect( TPoint( window->Position() ), TSize( window->Size() ) );

        //

        // get window aspect ratio

        //   if device is in portrait mode, width > height

        //   if device is in landscape mode, width < height

        //

        TReal32 width = (TReal32) displayRect.Width();

        TReal32 height = (TReal32) displayRect.Height();            

        mDisplayAspectRatio = (width > height)? (width / height) : (height / width);

    }

}

// -------------------------------------------------------------------------------------------------

// QMPXVideoPlaybackToolBar::playPause()

// -------------------------------------------------------------------------------------------------

//

void QMPXVideoPlaybackToolBar::playPause()

{

    MPX_DEBUG(_L("QMPXVideoPlaybackToolBar::playPause()"));

    mController->resetDisappearingTimers( EMPXTimerReset );

    mController->handleCommand( EMPXPbvCmdPlayPause );

}

// -------------------------------------------------------------------------------------------------

// QMPXVideoPlaybackToolBar::ffPressing()

// -------------------------------------------------------------------------------------------------

//

void QMPXVideoPlaybackToolBar::ffPressing()

{

    MPX_ENTER_EXIT(_L("QMPXVideoPlaybackToolBar::ffPressing()"),

                   _L("mSeekingState = %d"), mSeekingState );

    if ( mSeekingState == EMPXNotSeeking )

    {

        mSeekingState = EMPXFastForwarding;

        mController->handleCommand( EMPXPbvCmdSeekForward );        

    }

}

// -------------------------------------------------------------------------------------------------

// QMPXVideoPlaybackToolBar::rwPressing()

// -------------------------------------------------------------------------------------------------

//

void QMPXVideoPlaybackToolBar::rwPressing()

{

    MPX_ENTER_EXIT(_L("QMPXVideoPlaybackToolBar::rwPressing()"),

                   _L("mSeekingState = %d"), mSeekingState );

    if ( mSeekingState == EMPXNotSeeking )

    {

        mSeekingState = EMPXRewinding;

        mController->handleCommand( EMPXPbvCmdSeekBackward );

    }

}

// -------------------------------------------------------------------------------------------------

// QMPXVideoPlaybackToolBar::ffReleased()

// -------------------------------------------------------------------------------------------------

//

void QMPXVideoPlaybackToolBar::ffReleased()

{

    MPX_ENTER_EXIT(_L("QMPXVideoPlaybackToolBar::ffReleased()"),

                   _L("mSeekingState = %d"), mSeekingState );

    disconnect( mSeekStartTimer, SIGNAL( timeout() ), this, SLOT( ffPressing() ) );

    if ( mSeekStartTimer->isActive() )

    {

        mSeekStartTimer->stop();

    }

    if ( mSeekingState == EMPXFastForwarding )

    {

        mController->handleCommand( EMPXPbvCmdEndSeek );        

    }

    else

    {

        int temp = mPosition + KMPXFastForward;

        MPX_DEBUG(_L("QMPXVideoPlaybackToolBar::ffReleased() temp position = %d"), temp);

        //

        // If it has the playing time which is less than KMPXFastForward, ignore

        //

        if ( temp < mDuration )

        {

            mController->handleCommand( EMPXPbvCmdSetPosition, temp );

        }

    }

    mSeekingState = EMPXNotSeeking;

    mController->resetDisappearingTimers( EMPXTimerReset );

}

// -------------------------------------------------------------------------------------------------

// QMPXVideoPlaybackToolBar::rwReleased()

// -------------------------------------------------------------------------------------------------

//

void QMPXVideoPlaybackToolBar::rwReleased()

{

    MPX_ENTER_EXIT(_L("QMPXVideoPlaybackToolBar::rwReleased()"),

                   _L("mSeekingState = %d"), mSeekingState );

    disconnect( mSeekStartTimer, SIGNAL( timeout() ), this, SLOT( rwPressing() ) );

    if ( mSeekStartTimer->isActive() )

    {

        mSeekStartTimer->stop();

    }

    if ( mSeekingState == EMPXRewinding )

    {

        mController->handleCommand( EMPXPbvCmdEndSeek );        

    }

    else

    {

        int temp = mPosition + KMPXRewind;

        MPX_DEBUG(_L("QMPXVideoPlaybackToolBar::rwReleased() temp position = %d"), temp);

        //

        // If it played less than KMPXRewind, jump to 0

        //

        if ( temp < 0 )

        {

            temp = 0;

        }

        mController->handleCommand( EMPXPbvCmdSetPosition, temp );

    }

    mSeekingState = EMPXNotSeeking;

    mController->resetDisappearingTimers( EMPXTimerReset );

}

// -------------------------------------------------------------------------------------------------

// QMPXVideoPlaybackToolBar::changeAspectRatio()

// -------------------------------------------------------------------------------------------------

//

void QMPXVideoPlaybackToolBar::changeAspectRatio()

{

    MPX_DEBUG(_L("QMPXVideoPlaybackToolBar::changeAspectRatio()"));

    mController->resetDisappearingTimers( EMPXTimerReset );

    TMPXVideoPlaybackViewCommandIds cmd = EMPXPbvCmdStretchAspectRatio;

    switch( mAspectRatio )

    {

        case EMMFZoom:

        {

            cmd = EMPXPbvCmdNaturalAspectRatio;

            break;

        }

        case EMMFStretch:

        {

            cmd = EMPXPbvCmdZoomAspectRatio;

            break;

        }

    }

    mController->handleCommand( cmd );

}

// -------------------------------------------------------------------------------------------------

// QMPXVideoPlaybackToolBar::updateState()

// -------------------------------------------------------------------------------------------------

//

void QMPXVideoPlaybackToolBar::updateState( TMPXPlaybackState state )

{

    MPX_DEBUG(_L("QMPXVideoPlaybackToolBar::updateState() state = %d"), state );

    switch ( state )

    {

        case EPbStatePlaying:

        {

            mToolBar->setEnabled( true );

            mButtonActions[EMPX3rdButton]->setIcon( *mButtonIcons[EMPXPauseIcon] );

            break;

        }

        case EPbStatePaused:

        {

            mToolBar->setEnabled( true );

            mButtonActions[EMPX3rdButton]->setIcon( *mButtonIcons[EMPXPlayIcon] );

            break;

        }

        default:

        {

            mToolBar->setEnabled( false );

            break;

        }

    }

}

// -------------------------------------------------------------------------------------------------

// QMPXVideoPlaybackToolBar::aspectRatioChanged()

// -------------------------------------------------------------------------------------------------

//

void QMPXVideoPlaybackToolBar::aspectRatioChanged( int aspectRatio )

{

    MPX_DEBUG(_L("QMPXVideoPlaybackToolBar::aspectRatioChanged() aspectRatio = %d"), aspectRatio );

    mAspectRatio = aspectRatio;

    if ( ! mController->isAttachOperation() )

    {

        switch( mAspectRatio )

        {

            case EMMFNatural:

            {

                mButtonActions[EMPX1stButton]->setIcon( *mButtonIcons[EMPXStretchIcon] );

                break;

            }

            case EMMFStretch:

            {

                mButtonActions[EMPX1stButton]->setIcon( *mButtonIcons[EMPXZoomIcon] );

                break;

            }

            default:

            {

                mButtonActions[EMPX1stButton]->setIcon( *mButtonIcons[EMPXNaturalIcon] );

                break;

            }

        }    

    }

}

// -------------------------------------------------------------------------------------------------

// QMPXVideoPlaybackToolBar::handleButtonPressed()

// -------------------------------------------------------------------------------------------------

//

void QMPXVideoPlaybackToolBar::handleButtonPressed()

{

    MPX_DEBUG(_L("QMPXVideoPlaybackToolBar::handleButtonPressed()"));

    mController->resetDisappearingTimers( EMPXTimerCancel );

}

// -------------------------------------------------------------------------------------------------

// QMPXVideoPlaybackToolBar::handleRWButtonPressed()

// -------------------------------------------------------------------------------------------------

//

void QMPXVideoPlaybackToolBar::handleRWButtonPressed()

{

    MPX_DEBUG(_L("QMPXVideoPlaybackToolBar::handleRWButtonPressed()"));

    mController->resetDisappearingTimers( EMPXTimerCancel );

    connect( mSeekStartTimer, SIGNAL( timeout() ), this, SLOT( rwPressing() ) );

    if ( mSeekStartTimer->isActive() )

    {

        mSeekStartTimer->stop();

    }

    mSeekStartTimer->start();

}

// -------------------------------------------------------------------------------------------------

// QMPXVideoPlaybackToolBar::handleFFButtonPressed()

// -------------------------------------------------------------------------------------------------

//

void QMPXVideoPlaybackToolBar::handleFFButtonPressed()

{

    MPX_DEBUG(_L("QMPXVideoPlaybackToolBar::handleButtonPressed()"));

    mController->resetDisappearingTimers( EMPXTimerCancel );

    connect( mSeekStartTimer, SIGNAL( timeout() ), this, SLOT( ffPressing() ) );

    if ( mSeekStartTimer->isActive() )

    {

        mSeekStartTimer->stop();

    }

    mSeekStartTimer->start();

}

// -------------------------------------------------------------------------------------------------

// QMPXVideoPlaybackToolBar::updateWithFileDetails()

// -------------------------------------------------------------------------------------------------

//

void QMPXVideoPlaybackToolBar::updateWithFileDetails(

        QMPXVideoPlaybackViewFileDetails* details )

{

    MPX_DEBUG(_L("QMPXVideoPlaybackToolBar::updateWithFileDetails()"));

    if ( mController->isAttachOperation() )

    {

        //

        // Show attach button

        //

        mButtonActions[EMPX1stButton]->setIcon( *mButtonIcons[EMPXAttachIcon] );

        if ( mButtons.count() )

        {

            connect( mButtons[EMPX1stButton], SIGNAL( released() ),

                     mController, SLOT( attachVideo() ) );

        }

    }

    else

    {

        if ( mController->viewMode() == EFullScreenView )

        {

            //

            // Show aspect ratio button

            //

            aspectRatioChanged( mAspectRatio );

            if ( ! details->mVideoEnabled ||

                   details->mVideoHeight <= 0 ||

                   details->mVideoWidth <= 0 ||

                   details->mTvOutConnected )

            {

                //

                // dim 'aspect ratio' buttons

                //

                mButtonActions[EMPX1stButton]->setEnabled( false );

            }

            else

            {