/*

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

*

*/

// Version : %version:  11 %

#include <QTimer>

#include <QGraphicsLayout>

#include <hbaction.h>

#include <hbtoolbar.h>

#include <hbinstance.h>

#include <hbtoolbutton.h>

#include <w32std.h>

#include "mpxvideo_debug.h"

#include "videobaseplaybackview.h"

#include "videoplaybacktoolbar.h"

#include "mpxcommonvideoplaybackview.hrh"

#include "videoplaybackdocumentloader.h"

#include "videoplaybackviewfiledetails.h"

#include "videoplaybackcontrolscontroller.h"

const int KSeekStartTimeOut = 700;

const int KRetrieveButtonTimeOut = 1000;

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

// VideoPlaybackToolBar::VideoPlaybackToolBar()

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

//

VideoPlaybackToolBar::VideoPlaybackToolBar(

        VideoPlaybackControlsController* controller )

    : mController( controller )

    , mSeekStartTimer( NULL )

    , mRetrieveButtonTimer( NULL )

    , mSeekingState( ENotSeeking )

    , mInitialized( false )

    , mPosition( 0 )

    , mDuration( 0 )

    , mAspectRatio( EMPXPbvCmdNaturalAspectRatio )

{

    MPX_ENTER_EXIT(_L("VideoPlaybackToolBar::VideoPlaybackToolBar"));

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

    mToolBar->setOrientation( Qt::Horizontal );

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

    initialize();

}

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

// VideoPlaybackToolBar::~VideoPlaybackToolBar()

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

//

VideoPlaybackToolBar::~VideoPlaybackToolBar()

{

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

    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;

    }

}

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

// VideoPlaybackToolBar::initialize()

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

//

void VideoPlaybackToolBar::initialize()

{

    MPX_ENTER_EXIT(_L("VideoPlaybackToolBar::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 < EButtonCount ; i++ )

        {

            mButtonActions.append( new HbAction( actionsGroup ) );

        }

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

        {

            mButtonIcons.append( new HbIcon() );

        }

        //

        // RW button

        //

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

        mButtonActions[E2ndButton]->setIcon( *mButtonIcons[ERWIcon] );

        //

        // Play/Pause button

        //

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

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

        mButtonActions[E3rdButton]->setIcon( *mButtonIcons[EPlayIcon] );

        //

        // FF button

        //

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

        mButtonActions[E4thButton]->setIcon( *mButtonIcons[EFFIcon] );

        //

        // Details button

        //

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

        mButtonActions[E5thButton]->setIcon( *mButtonIcons[EDetailsIcon] );

        //

        // Aspect ratio buttons

        //

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

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

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

        mButtonActions[E1stButton]->setIcon( *mButtonIcons[ENaturalIcon] );

        //

        // Attach/Share button

        //

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

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

        for ( int i = 0 ; i < EButtonCount ; 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);

    }

}

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

// VideoPlaybackToolBar::playPause()

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

//

void VideoPlaybackToolBar::playPause()

{

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

    mController->resetDisappearingTimers( ETimerReset );

    mController->handleCommand( EMPXPbvCmdPlayPause );

}

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

// VideoPlaybackToolBar::ffPressing()

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

//

void VideoPlaybackToolBar::ffPressing()

{

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

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

    if ( mSeekingState == ENotSeeking )

    {

        mSeekingState = EFastForwarding;

        mController->handleCommand( EMPXPbvCmdSeekForward );

    }

}

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

// VideoPlaybackToolBar::rwPressing()

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

//

void VideoPlaybackToolBar::rwPressing()

{

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

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

    if ( mSeekingState == ENotSeeking )

    {

        mSeekingState = ERewinding;

        mController->handleCommand( EMPXPbvCmdSeekBackward );

    }

}

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

// VideoPlaybackToolBar::ffReleased()

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

//

void VideoPlaybackToolBar::ffReleased()

{

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

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

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

    if ( mSeekStartTimer->isActive() )

    {

        mSeekStartTimer->stop();

    }

    if ( mSeekingState == EFastForwarding )

    {

        mController->handleCommand( EMPXPbvCmdEndSeek );

    }

    else

    {

        int temp = mPosition + KMPXFastForward;

        MPX_DEBUG(_L("VideoPlaybackToolBar::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 = ENotSeeking;

    mController->resetDisappearingTimers( ETimerReset );

}

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

// VideoPlaybackToolBar::rwReleased()

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

//

void VideoPlaybackToolBar::rwReleased()

{

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

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

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

    if ( mSeekStartTimer->isActive() )

    {

        mSeekStartTimer->stop();

    }

    if ( mSeekingState == ERewinding )

    {

        mController->handleCommand( EMPXPbvCmdEndSeek );

    }

    else

    {

        int temp = mPosition + KMPXRewind;

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

        //

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

        //

        if ( temp < 0 )

        {

            temp = 0;

        }

        mController->handleCommand( EMPXPbvCmdSetPosition, temp );

    }

    mSeekingState = ENotSeeking;

    mController->resetDisappearingTimers( ETimerReset );

}

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

// VideoPlaybackToolBar::changeAspectRatio()

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

//

void VideoPlaybackToolBar::changeAspectRatio()

{

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

    mController->resetDisappearingTimers( ETimerReset );

    TMPXVideoPlaybackViewCommandIds cmd = EMPXPbvCmdStretchAspectRatio;

    switch( mAspectRatio )

    {

        case EMMFZoom:

        {

            cmd = EMPXPbvCmdNaturalAspectRatio;

            break;

        }

        case EMMFStretch:

        {

            cmd = EMPXPbvCmdZoomAspectRatio;

            break;

        }

    }

    mController->handleCommand( cmd );

}

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

// VideoPlaybackToolBar::updateState()

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

//

void VideoPlaybackToolBar::updateState( TMPXPlaybackState state )

{

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

    switch ( state )

    {

        case EPbStatePlaying:

        {

            mToolBar->setEnabled( true );

            mButtonActions[E3rdButton]->setIcon( *mButtonIcons[EPauseIcon] );

            if ( ! mController->fileDetails()->mPausableStream  )

            {

                //

                // non-pausable stream, disable 'E3rdButton' action (for 'Pause' button)

                //

                mButtonActions[E3rdButton]->setEnabled( false );

            }

            break;

        }

        case EPbStatePaused:

        {

            mToolBar->setEnabled( true );

            mButtonActions[E3rdButton]->setIcon( *mButtonIcons[EPlayIcon] );

            if ( ! mButtonActions[E3rdButton]->isEnabled() )

            {

                //

                // enable 'E3rdButton' action (for 'Play' button) in 'Paused' state

                //

                mButtonActions[E3rdButton]->setEnabled( true );

            }

            break;

        }

        case EPbStatePluginSeeking:

        {

            break;

        }

        default:

        {

            mToolBar->setEnabled( false );

            break;

        }

    }

}

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

// VideoPlaybackToolBar::aspectRatioChanged()

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

//

void VideoPlaybackToolBar::aspectRatioChanged( int aspectRatio )

{

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

    mAspectRatio = aspectRatio;

    //

    // If we are in attach service or audio only view, then don't update the icon.

	// Aspect ratio icon slots are shared with attach and share icon.

	// Just update the mAspectRatio

	// and once we go back to full screen, we will show the correct aspect ratio icon

	//

    if ( ! mController->isAttachOperation() && mController->viewMode() == EFullScreenView )

    {

        switch( mAspectRatio )

        {

            case EMMFNatural:

            {

                mButtonActions[E1stButton]->setIcon( *mButtonIcons[EStretchIcon] );

                break;

            }

            case EMMFStretch:

            {

                mButtonActions[E1stButton]->setIcon( *mButtonIcons[EZoomIcon] );

                break;

            }

            default:

            {

                mButtonActions[E1stButton]->setIcon( *mButtonIcons[ENaturalIcon] );

                break;

            }

        }

    }

}

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

// VideoPlaybackToolBar::handleButtonPressed()

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

//

void VideoPlaybackToolBar::handleButtonPressed()

{

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

    mController->resetDisappearingTimers( ETimerCancel );

}

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

// VideoPlaybackToolBar::handleRWButtonPressed()

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

//

void VideoPlaybackToolBar::handleRWButtonPressed()

{

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

    mController->resetDisappearingTimers( ETimerCancel );

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

    if ( mSeekStartTimer->isActive() )

    {

        mSeekStartTimer->stop();

    }

    mSeekStartTimer->start();

}

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

// VideoPlaybackToolBar::handleFFButtonPressed()

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

//

void VideoPlaybackToolBar::handleFFButtonPressed()

{

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

    mController->resetDisappearingTimers( ETimerCancel );

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

    if ( mSeekStartTimer->isActive() )

    {

        mSeekStartTimer->stop();

    }

    mSeekStartTimer->start();

}

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

// VideoPlaybackToolBar::updateWithFileDetails()

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

//

void VideoPlaybackToolBar::updateWithFileDetails(

        VideoPlaybackViewFileDetails* details )

{

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

    if ( mController->isAttachOperation() )

    {

        //

        // Show attach button

        //

        mButtonActions[E1stButton]->setIcon( *mButtonIcons[EAttachIcon] );

        if ( mButtons.count() )

        {

            disconnect( mButtons[E1stButton], SIGNAL( released() ), 0, 0 );

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

                     mController, SLOT( attachVideo() ) );

        }

    }