/*
* 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: Branding Animation control
*
*/

// Version : %version: 7 %


// INCLUDE FILES
#include <eikenv.h>
#include <gulicon.h>
#include <AknUtils.h>
#include <AknIconUtils.h>
#include <AknsDrawUtils.h>
#include <mpxvideoplaybackcontrols.mbg>

#include "mpxvideoplaybackbrandinganimation.h"
#include "mpxvideoplaybackcontrolscontroller.h"
#include "mpxvideo_debug.h"


const TInt KMPXRealBrandingAnimationArrayCount = 17;    // Real Branding frames' count
const TInt KMPXGenericBrandingAnimationArrayCount = 10; // Generic Branding frames' count
const TInt KMPXBrandingAnimationFrameInterval = 100000; // Represents delay between frames

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

CMPXVideoPlaybackBrandingAnimation::CMPXVideoPlaybackBrandingAnimation(
    CMPXVideoPlaybackControlsController* aController, TBool aRealFormat )
    : iIconArray( KMPXRealBrandingAnimationArrayCount )
    , iRealFormat( aRealFormat )
    , iController( aController )
{
}

// -------------------------------------------------------------------------------------------------
// CMPXVideoPlaybackBrandingAnimation::ConstructL()
// Symbian 2nd phase constructor can leave.
// -------------------------------------------------------------------------------------------------
//
void CMPXVideoPlaybackBrandingAnimation::ConstructL( TRect aRect )
{
    MPX_DEBUG(_L("CMPXVideoPlaybackBrandingAnimation::ConstructL()"));

    //
    // set rect
    //
    SetRect( TRect( 0, 0, aRect.Width(), aRect.Height() ) );
    iBrandingRect = aRect;

    //
    // construct branding timer
    //
    iBrandingTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    //
    // create branding bitmaps
    //
    CreateBitmapsL();

}

// -------------------------------------------------------------------------------------------------
// CMPXVideoPlaybackBrandingAnimation::NewL()
// Two-phased constructor.
// -------------------------------------------------------------------------------------------------
//
CMPXVideoPlaybackBrandingAnimation*
CMPXVideoPlaybackBrandingAnimation::NewL( CMPXVideoPlaybackControlsController* aController,
                                          TRect aRect,
                                          TBool aRealFormat )
{
    MPX_DEBUG(_L("CMPXVideoPlaybackBrandingAnimation::NewL()"));

    CMPXVideoPlaybackBrandingAnimation* self =
        new ( ELeave ) CMPXVideoPlaybackBrandingAnimation( aController, aRealFormat );

    CleanupStack::PushL( self );
    self->ConstructL( aRect );
    CleanupStack::Pop();
    return self;
}

// -------------------------------------------------------------------------------------------------
// CMPXVideoPlaybackBrandingAnimation::~CMPXVideoPlaybackBrandingAnimation()
// Destructor.
// -------------------------------------------------------------------------------------------------
//
CMPXVideoPlaybackBrandingAnimation::~CMPXVideoPlaybackBrandingAnimation()
{
    MPX_DEBUG(_L("CMPXVideoPlaybackBrandingAnimation::~CMPXVideoPlaybackBrandingAnimation()"));

    iIconArray.ResetAndDestroy();

    if ( iBrandingTimer )
    {
         iBrandingTimer->Cancel();
         delete iBrandingTimer;
         iBrandingTimer = NULL;
    }

}

// -------------------------------------------------------------------------------------------------
// CMPXVideoPlaybackBrandingAnimation::CreateBitmapsL()
// -------------------------------------------------------------------------------------------------
//
void CMPXVideoPlaybackBrandingAnimation::CreateBitmapsL()
{
    MPX_DEBUG(_L("CMPXVideoPlaybackBrandingAnimation::CreateBitmapsL()"));

    //
    // Create icons
    //
    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    TFileName iconsPath;
    iController->LocateBitmapFileL( iconsPath );

    TInt bitmapIndex;

    if ( iRealFormat )
    {
        //
        // first frame of Real Player Branding Animation
        //
        bitmapIndex = EMbmMpxvideoplaybackcontrolsQgn_graf_realplayer_splash_01;

        //
        // number of Real Player animation frames
        //
        iCount = KMPXRealBrandingAnimationArrayCount;
    }
    else
    {
        //
        // first frame of Generic Branding Animation
        //
        bitmapIndex = EMbmMpxvideoplaybackcontrolsQgn_graf_ring_wait_01;

        //
        // number of Generic animation frames
        //
        iCount = KMPXGenericBrandingAnimationArrayCount;
    }

    for ( TInt i = 0; i < iCount * 2; i = i + 2 )
    {
        //
        // Create icons
        //
        CGulIcon* icon = AknsUtils::CreateGulIconL( skin,
                                                    KAknsIIDQgnVideoPluginAnimBuffering,
                                                    iconsPath,
                                                    bitmapIndex + i ,
                                                    bitmapIndex + i + 1 );

        if ( icon )
        {
            //
            // push icon to the cleanup stack
            //
            CleanupStack::PushL( icon );

            //
            // Set icon size
            //
            AknIconUtils::SetSize( icon->Bitmap(), iBrandingRect.Size(), EAspectRatioPreserved );

            //
            // Append icon to array
            //
            iIconArray.AppendL( icon );

            //
            // pop icon to the cleanup stack
            //
            CleanupStack::Pop( icon );
        }
    }

    //
    // start branding timer
    //
    StartBrandingTimer();
}

// -------------------------------------------------------------------------------------------------
// CMPXVideoPlaybackBrandingAnimation::CountComponentControls()
// -------------------------------------------------------------------------------------------------
//
TInt CMPXVideoPlaybackBrandingAnimation::CountComponentControls() const
{
    return 0;
}

// -------------------------------------------------------------------------------------------------
//   CMPXVideoPlaybackBrandingAnimation::Draw()
// -------------------------------------------------------------------------------------------------
//
void CMPXVideoPlaybackBrandingAnimation::Draw( const TRect& aRect ) const
{
    MPX_DEBUG(_L("CMPXVideoPlaybackBrandingAnimation::Draw()"));

    CWindowGc& gc = SystemGc();
    gc.SetClippingRect( aRect );

    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
    {
        // draw a solid background so that the entire progress
        // bar is shown not just the area representing the
        // portion that has been played.
        gc.SetBrushColor( KRgbBlack );
        gc.SetBrushStyle( CGraphicsContext::ESolidBrush );
        gc.DrawRect( aRect );
        gc.SetBrushStyle( CGraphicsContext::ENullBrush );
    }

    //
    // draw branding animation
    //
    gc.BitBltMasked( iBrandingRect.iTl,
                     iIconArray[ iCurrentIndex ]->Bitmap(),
                     TRect( iBrandingRect.Size() ),
                     iIconArray[ iCurrentIndex ]->Mask(),
                     ETrue );
}

// -------------------------------------------------------------------------------------------------
// CMPXVideoPlaybackBrandingAnimation::StartBrandingTimer
// -------------------------------------------------------------------------------------------------
//
void CMPXVideoPlaybackBrandingAnimation::StartBrandingTimer()
{
    MPX_DEBUG(_L("CMPXVideoPlaybackBrandingAnimation::StartBrandingTimer()"));

    //
    // set branding timer
    //
    if ( ! iBrandingTimer->IsActive() )
    {
        iBrandingTimer->Start(
            0,
            KMPXBrandingAnimationFrameInterval,
            TCallBack( CMPXVideoPlaybackBrandingAnimation::BrandingTimer, this ) );
    }
}

// -------------------------------------------------------------------------------------------------
// CMPXVideoPlaybackBrandingAnimation::BrandingTimer
// -------------------------------------------------------------------------------------------------
//
TInt CMPXVideoPlaybackBrandingAnimation::BrandingTimer( TAny* aPtr )
{
    static_cast<CMPXVideoPlaybackBrandingAnimation*>(aPtr)->HandleBrandingTimer();
    return KErrNone;
}

// -------------------------------------------------------------------------------------------------
// CMPXVideoPlaybackBrandingAnimation::HandleBrandingTimer
// -------------------------------------------------------------------------------------------------
//
void CMPXVideoPlaybackBrandingAnimation::HandleBrandingTimer()
{
    //
    // keep track of the current animation frame
    //
    iCurrentIndex = (++iCurrentIndex) % iCount;

    //
    // draw the current animation frame
    //
    if ( IsVisible() )
    {
        DrawNow();
    }
}

// -------------------------------------------------------------------------------------------------
// CMPXVideoPlaybackBrandingAnimation::CancelBrandingTimer
// -------------------------------------------------------------------------------------------------
//
void CMPXVideoPlaybackBrandingAnimation::CancelBrandingTimer()
{
    MPX_DEBUG(_L("CMPXVideoPlaybackBrandingAnimation::CancelBrandingTimer()"));

    if ( iBrandingTimer->IsActive() )
    {
        iBrandingTimer->Cancel();
    }
}

//  End of File