/*

* Copyright (c) 2008 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: Progress bar control

*

*/

// INCLUDE FILES

#include <eikenv.h>

#include <gulicon.h>

#include <AknUtils.h>

#include <eiklabel.h>

#include <StringLoader.h>

#include <AknsDrawUtils.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <data_caging_path_literals.hrh>

#include <mpxvideoplaybackcontrols.rsg>

#include <mpxvideoplaybackcontrols.mbg>

#include "mpxcommonvideoplaybackview.hrh"

#include "mpxvideoplaybackprogressbar.h"

#include "mpxvideoplaybackcontrolscontroller.h"

#include "mpxvideoplaybackviewfiledetails.h"

#include "mpxvideo_debug.h"

#ifdef RD_TACTILE_FEEDBACK

#include <touchfeedback.h>

#endif //RD_TACTILE_FEEDBACK

using namespace AknLayoutScalable_Apps;

// CONSTANTS

const TInt KMPXProgressSliderWidth = 20;

const TInt KMPXSliderHeightOverProgresBar = 5;

const TInt64 KMPXMicroSeconds = 1000000;

const TInt KMPXOneHourInSeconds = 3600;

const TInt KMPXProgressBarHeight = 41;

// ============================ MEMBER FUNCTIONS ===================================================

CMPXVideoPlaybackProgressBar::CMPXVideoPlaybackProgressBar(

    CMPXVideoPlaybackControlsController* aController )

    : iController( aController )

    , iPlaybackRatio( 0.0 )

    , iDownloadRatio( 0.0 )

    , iDragging( EFalse )

    , iPointerEventStarted( EFalse )

    , iWasPlaying ( EFalse )

    , iOldDLSize(0)

{

}

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

// CMPXVideoPlaybackProgressBar::ConstructL()

// Symbian 2nd phase constructor can leave.

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

//

void CMPXVideoPlaybackProgressBar::ConstructL( TRect aRect )

{

    MPX_DEBUG(_L("CMPXVideoPlaybackProgressBar::ConstructL()"));

    SetRect( TRect(0, 0, aRect.Width(), aRect.Height()) );

    SetLayoutL();

    SkinChangeL();

    //

    //  Read time format strings from AVKON resource

    //

    iMinSecFormatString = iEikonEnv->AllocReadResourceL(R_QTN_TIME_DURAT_MIN_SEC);

    iHourMinSecFormatString = iEikonEnv->AllocReadResourceL(R_QTN_TIME_DURAT_LONG);

#ifdef RD_TACTILE_FEEDBACK

    iFeedback = MTouchFeedback::Instance();

#endif //RD_TACTILE_FEEDBACK

}

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

// CMPXVideoPlaybackProgressBar::NewL()

// Two-phased constructor.

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

//

CMPXVideoPlaybackProgressBar* CMPXVideoPlaybackProgressBar::NewL(

    CMPXVideoPlaybackControlsController* aController,

    TRect aRect )

{

    MPX_DEBUG(_L("CMPXVideoPlaybackProgressBar::NewL()"));

    CMPXVideoPlaybackProgressBar* self =

        new ( ELeave ) CMPXVideoPlaybackProgressBar( aController );

    CleanupStack::PushL( self );

    self->ConstructL( aRect );

    CleanupStack::Pop();

    return self;

}

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

// CMPXVideoPlaybackProgressBar::~CMPXVideoPlaybackProgressBar()

// Destructor.

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

//

CMPXVideoPlaybackProgressBar::~CMPXVideoPlaybackProgressBar()

{

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

    if ( iMinSecFormatString )

    {

        delete iMinSecFormatString;

        iMinSecFormatString = NULL;

    }

    if ( iHourMinSecFormatString )

    {

        delete iHourMinSecFormatString;

        iHourMinSecFormatString = NULL;

    }

    if ( iLiveStreamingString )

    {

        delete iLiveStreamingString;

        iLiveStreamingString = NULL;

    }

    if ( iFrameIcon )

    {

       delete iFrameIcon;

       iFrameIcon = NULL;

    }

    if ( iPlaybackIcon )

    {

       delete iPlaybackIcon;

       iPlaybackIcon = NULL;

    }

    if ( iDownloadIcon )

    {

       delete iDownloadIcon;

       iDownloadIcon = NULL;

    }

    if ( iSliderIcon )

    {

       delete iSliderIcon;

       iSliderIcon = NULL;

    }

    if ( iSelectedSliderIcon )

    {

       delete iSelectedSliderIcon;

       iSelectedSliderIcon = NULL;

    }

    if ( iPositionLabel )

    {

        delete iPositionLabel;

        iPositionLabel = NULL;

    }

    if ( iDurationLabel )

    {

        delete iDurationLabel;

        iDurationLabel = NULL;

    }

#ifdef RD_TACTILE_FEEDBACK

    {

    }

#endif //RD_TACTILE_FEEDBACK

}

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

// CMPXVideoPlaybackProgressBar::HandleResourceChange()

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

//

void CMPXVideoPlaybackProgressBar::HandleResourceChange( TInt aType )

{

    MPX_DEBUG(_L("CMPXVideoPlaybackProgressBar::HandleResourceChange(0x%X)"), aType);

    if ( aType == KAknsMessageSkinChange )

    {

        TRAP_IGNORE( SkinChangeL() );

    }

    CCoeControl::HandleResourceChange( aType );

}

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

// CMPXVideoPlaybackProgressBar::SetLayout()

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

//

void CMPXVideoPlaybackProgressBar::SetLayoutL()

{

    MPX_DEBUG(_L("CMPXVideoPlaybackProgressBar::SetLayoutL()"));

    //

    // Calculate icon rects

    //

    TRect progressRect = Rect();

    TInt topMarginHeight = ( progressRect.iBr.iY - KMPXProgressBarHeight ) / 2 - 10;

    progressRect.iTl.iY += topMarginHeight;

    progressRect.iBr.iY = progressRect.iTl.iY + KMPXProgressBarHeight;

    TAknLayoutRect seekBarFrameRect;

    seekBarFrameRect.LayoutRect( progressRect, mup_progress_pane_cp04().LayoutLine() );

    iFrameIconRect = seekBarFrameRect.Rect();

    iSliderRect.iTl.iY = iFrameIconRect.iTl.iY - KMPXSliderHeightOverProgresBar;

    iSliderRect.iBr.iY = iFrameIconRect.iBr.iY + KMPXSliderHeightOverProgresBar;

    //

    // Create labels

    //

    if ( iPositionLabel )

    {

        delete iPositionLabel;

        iPositionLabel = NULL;

    }

    iPositionLabel = new (ELeave) CEikLabel;

    AknLayoutUtils::LayoutLabel( iPositionLabel,

                                 progressRect,

                                 mp4_progress_pane_t1().LayoutLine() ) ;

    iPositionLabel->SetContainerWindowL( *this );

    iPositionLabel->SetTextL( KNullDesC );

    iPositionLabel->MakeVisible( ETrue );

    if ( iDurationLabel )

    {

        delete iDurationLabel;

        iDurationLabel = NULL;

    }

    iDurationLabel = new (ELeave) CEikLabel;

    AknLayoutUtils::LayoutLabel( iDurationLabel,

                                 progressRect,

                                 mp4_progress_pane_t2().LayoutLine() );

    iDurationLabel->SetContainerWindowL( *this );

    iDurationLabel->SetTextL( KNullDesC );

    iDurationLabel->MakeVisible( ETrue );

}

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

// CMPXVideoPlaybackProgressBar::SkinChangeL()

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

//

void CMPXVideoPlaybackProgressBar::SkinChangeL()

{

    MPX_DEBUG(_L("CMPXVideoPlaybackProgressBar::SkinChangeL()"));

    //

    // Create icons

    //

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    TFileName iconsPath;

    iController->LocateBitmapFileL( iconsPath );

    delete iFrameIcon;

    iFrameIcon = NULL;

    iFrameIcon = AknsUtils::CreateGulIconL(

        skin,

        KAknsIIDQgnGrafMup2BarFrame,

        iconsPath,

        EMbmMpxvideoplaybackcontrolsQgn_graf_mup2_bar_frame,

        EMbmMpxvideoplaybackcontrolsQgn_graf_mup2_bar_frame_mask);

    if ( iFrameIcon )

    {

        AknIconUtils::SetSize( iFrameIcon->Bitmap(),

                               iFrameIconRect.Size(),

                               EAspectRatioNotPreserved );

    }

    delete iPlaybackIcon;

    iPlaybackIcon = NULL;

    iPlaybackIcon = AknsUtils::CreateGulIconL(

        skin,

        KAknsIIDQgnGrafMup2BarProgress2,

        iconsPath,

        EMbmMpxvideoplaybackcontrolsQgn_graf_mup2_bar_progress_2,

        EMbmMpxvideoplaybackcontrolsQgn_graf_mup2_bar_progress_2_mask);

    if ( iPlaybackIcon )

    {

        AknIconUtils::SetSize( iPlaybackIcon->Bitmap(),

                               iFrameIconRect.Size(),

                               EAspectRatioNotPreserved );

    }

    UpdateProgressBarStateL( iController->FileDetails() );

}

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

// CMPXVideoPlaybackProgressBar::HandlePointerEventL()

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

//

void CMPXVideoPlaybackProgressBar::HandlePointerEventL( const TPointerEvent& aPointerEvent )

{

    MPX_DEBUG(_L("CMPXVideoPlaybackProgressBar::HandlePointerEventL()"));

    TMPXPlaybackState state = iController->State();

    //

    //  Block pointer events in the following cases:

    //  - The clip is not seekable

    //  - The state is not playing/paused

    //  - If TV-Out is connected and the clip is DRM protected

    //

    if ( iController->FileDetails()->iSeekable &&

         ( state == EPbStatePlaying || state == EPbStatePaused ) &&

         iController->IsTvOutPlaybackAllowed() )

    {

        TReal ratio = (TReal) ( aPointerEvent.iPosition.iX - iFrameIconRect.iTl.iX )/

                      (TReal)( iFrameIconRect.Width() - KMPXProgressSliderWidth );

        if ( ratio > 1.0 )

        {

            ratio = 1.0;

        }

        else if ( ratio < 0.0 )

        {

            ratio = 0.0;

        }

        if ( aPointerEvent.iType == TPointerEvent::EButton1Down )

        {

            HandleButtonDownEventL( ratio );

        }

        else if ( aPointerEvent.iType == TPointerEvent::EDrag )

        {

            HandleDraggingEventL( ratio );

        }

        else if ( aPointerEvent.iType == TPointerEvent::EButton1Up )

        {

            HandleButtonUpEventL( ratio );

        }

    }

}

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

//   CMPXVideoPlaybackProgressBar::HandleButtonDownEventL

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

//

void CMPXVideoPlaybackProgressBar::HandleButtonDownEventL( TReal aRatio )

{

    MPX_ENTER_EXIT(_L("CMPXVideoPlaybackProgressBar::HandleButtonDownEventL()"),

                   _L("ratio = %f"), aRatio );

    iPointerEventStarted = ETrue;

    if ( iWasPlaying )

    {

        iController->HandleCommandL( EMPXPbvCmdCustomPause );

    }

#ifdef RD_TACTILE_FEEDBACK

    if ( iFeedback )

    {

#ifdef SYMBIAN_BUILD_GCE

        iFeedback->InstantFeedback( ETouchFeedbackSlider );

#else

        iFeedback->InstantFeedback( ETouchFeedbackBasic );

    }

#endif //RD_TACTILE_FEEDBACK

    iDragging = EFalse;

    //

    //  Check for PDL using the download icon

    //

    if ( iDownloadIcon && ( aRatio > iDownloadRatio ) )

    {

        aRatio = iDownloadRatio;

    }

    PositionChangedL( aRatio * iDuration, ETrue );

}

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

//   CMPXVideoPlaybackProgressBar::HandleDraggingEventL

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

//

void CMPXVideoPlaybackProgressBar::HandleDraggingEventL( TReal aRatio )

{

    MPX_ENTER_EXIT(_L("CMPXVideoPlaybackProgressBar::HandleDraggingEventL()"),

                   _L("ratio = %f"), aRatio );

#ifdef RD_TACTILE_FEEDBACK

    if ( iFeedback )

    {

#ifdef SYMBIAN_BUILD_GCE

        iFeedback->InstantFeedback( ETouchFeedbackSlider );

#else

        iFeedback->InstantFeedback( ETouchFeedbackSensitive );

    }

#endif //RD_TACTILE_FEEDBACK

    iDragging = ETrue;

    if ( iDownloadIcon && ( aRatio > iDownloadRatio ) )

    {

        aRatio = iDownloadRatio;

    }

    PositionChangedL( aRatio * iDuration, ETrue );

}

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

//   CMPXVideoPlaybackProgressBar::HandleButtonUpEventL

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

//

void CMPXVideoPlaybackProgressBar::HandleButtonUpEventL( TReal aRatio )

{

    MPX_ENTER_EXIT(_L("CMPXVideoPlaybackProgressBar::HandleButtonUpEventL()"),

                   _L("ratio = %f"), aRatio );

    iDragging = EFalse;

    if ( ( ! iDownloadIcon && aRatio == 1.0 ) ||

         ( iDownloadIcon && aRatio == 1.0 && iDownloadRatio == 1.0 ) )

    {

        iController->HandleCommandL( EMPXPbvCmdEndOfClip );

    }

    else

    {

        if ( iDownloadIcon && ( aRatio >= iDownloadRatio ) )

        {

            aRatio = iDownloadRatio;

        }

        TInt position = (TInt)( aRatio * iDuration );

        PositionChangedL( position, ETrue );

        iController->HandleCommandL( EMPXPbvCmdSetPosition, position );

        if ( iWasPlaying )

        {

            iWasPlaying = EFalse;

            iController->HandleCommandL( EMPXPbvCmdCustomPlay );

        }

    }

    iPointerEventStarted = EFalse;

}

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

//   CMPXVideoPlaybackProgressBar::Draw()

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

//

void CMPXVideoPlaybackProgressBar::Draw( const TRect& aRect ) const

{

    MPX_DEBUG(_L("CMPXVideoPlaybackProgressBar::Draw()"));

    CWindowGc& gc = SystemGc();

    gc.SetClippingRect( aRect );

    if ( iController->SetBackgroundBlack() )

    {

        if ( Window().DisplayMode() == EColor16MAP )

        {

            gc.SetDrawMode( CGraphicsContext::EDrawModeWriteAlpha );

            gc.SetBrushColor( TRgb::Color16MAP( 255 ) );

            gc.Clear( aRect );

        }

        else if ( Window().DisplayMode() == EColor16MA )

        {

            gc.SetDrawMode( CGraphicsContext::EDrawModeWriteAlpha );

            gc.SetBrushColor( TRgb::Color16MA( 0 ) );

            gc.Clear( aRect );

        }

    }

    else

    {

        gc.SetBrushColor( KRgbBlack );

        gc.SetBrushStyle( CGraphicsContext::ESolidBrush );

        gc.DrawRect( aRect );

        gc.SetBrushStyle(CGraphicsContext::ENullBrush);

    }

    //

    // If it is live streaming, don't need to draw the progress bar

    //

    if ( ! iLiveStreamingString )

    {

        if ( iFrameIcon )

        {

            gc.BitBltMasked( iFrameIconRect.iTl,

                             iFrameIcon->Bitmap(),