/*

* Copyright (c) 2003-2006 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:  

*       Base class for SMIL Player media renderers

*

*/

#include <eikenv.h>

#include <AknUtils.h>

// DRM

#include <DRMHelper.h>

#include <caf/data.h>

// LAF

#include <AknUtils.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include "SmilMediaRendererBase.h"

//These are from LAF:

const TInt KScrollBarBGColorID = 218;

const TInt KScrollBarFGColorID = 221;

const TInt KScrollBarLineColorID = 0;

using namespace ContentAccess;

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

// CSmilMediaRendererBase::CSmilMediaRendererBase

// C++ default constructor. Initializes class member variables.

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

//

CSmilMediaRendererBase::CSmilMediaRendererBase( TMsgMediaType aMediaType,

                                                MSmilMedia* aMedia, 

                                                DRMCommon& aDrmCommon, 

                                                CDRMHelper& aDrmHelper ) :

    iMediaType( aMediaType ),

    iDrmCommon( aDrmCommon ),

    iDrmHelper( aDrmHelper ),

    iDrmProtection( DRMCommon::ENoDCFFile ),

    iMedia( aMedia )

    {

    }

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

// CSmilMediaRendererBase::BaseConstructL

// Base class 2nd phase constructor. Should be called from derived classes if

// base class services are used.

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

//

void CSmilMediaRendererBase::BaseConstructL( RFile& aFileHandle )

    {

    HBufC8* drmMime = NULL; // dummy

    TUint drmData = 0;

    iDrmCommon.GetFileInfo( aFileHandle,

                            iDrmProtection,

                            drmMime,

                            iDrmUri,

                            drmData );

    delete drmMime;

    }

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

// CSmilMediaRendererBase::~CSmilMediaRendererBase

// Destructor

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

//

CSmilMediaRendererBase::~CSmilMediaRendererBase()

    {

    if( iDrmProtection != DRMCommon::ENoDCFFile &&

        iDrmRightConsumed )

        {

        iDrmHelper.Consume2( *iDrmUri,

                             Intent(),

                             CDRMHelper::EFinish );            

        }

    delete iDrmUri;

    delete iEventArray;

    }

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

// CSmilMediaRendererBase::Close

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

//

void CSmilMediaRendererBase::Close()

    {

    delete this;

    }

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

// CSmilMediaRendererBase::IsVisual

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

//

TBool CSmilMediaRendererBase::IsVisual() const

    {

    return EFalse;

    }

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

// CSmilMediaRendererBase::IsOpaque

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

//

TBool CSmilMediaRendererBase::IsOpaque() const

    {

    return EFalse;

    }

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

// CSmilMediaRendererBase::IsScrollable

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

//

TBool CSmilMediaRendererBase::IsScrollable() const

    {

    return EFalse;

    }

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

// CSmilMediaRendererBase::IsControl

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

//

TBool CSmilMediaRendererBase::IsControl() const

    {

    return ETrue;

    }

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

// CSmilMediaRendererBase::IntrinsicWidth

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

//

TInt CSmilMediaRendererBase::IntrinsicWidth() const

    {

    return 0;

    }

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

// CSmilMediaRendererBase::IntrinsicHeight

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

//

TInt CSmilMediaRendererBase::IntrinsicHeight() const

    {

    return 0;

    }

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

// CSmilMediaRendererBase::IntrinsicDuration

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

//

TSmilTime CSmilMediaRendererBase::IntrinsicDuration() const

    {

    return 0;

    }

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

// CSmilMediaRendererBase::Draw

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

//

void CSmilMediaRendererBase::Draw( CGraphicsContext& /*aGc*/,

                                   const TRect& /*aRect*/,

                                   CSmilTransitionFilter* /*aTransitionFilter*/,

                                   const MSmilFocus* /*aFocus*/ )

    {

    }

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

// void CSmilMediaRendererBase::Scroll

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

//

void CSmilMediaRendererBase::Scroll( TInt /*aDirX*/,

                                     TInt /*aDirY*/ )

    {

    }

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

// CSmilMediaRendererBase::SetVolume

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

//

void CSmilMediaRendererBase::SetVolume( TInt /*aVolume*/ )

    {

    }

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

// CSmilMediaRendererBase::MediaType

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

//

EXPORT_C TMsgMediaType CSmilMediaRendererBase::MediaType() const

    {

    return iMediaType;

    }

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

// CSmilMediaRendererBase::ActivateRendererL

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

//

EXPORT_C void CSmilMediaRendererBase::ActivateRendererL()

    {

    }

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

// CSmilMediaRendererBase::SendingDrmFileAllowedL

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

//

TBool CSmilMediaRendererBase::SendingDrmFileAllowedL( RFile& aFileHandle )

    {

    TBool result( ETrue );

    if ( iDrmProtection != DRMCommon::ENoDCFFile )

        {

        if ( iDrmProtection == DRMCommon::ESuperDistributable )

            {

            CData* content = CData::NewL( aFileHandle, KDefaultContentObject, EPeek );

            TInt sendingAllowed( 0 );

            if ( content->GetAttribute( EIsForwardable, sendingAllowed ) == KErrNone )

                {

                if ( sendingAllowed == 0)

                    {

                    result = EFalse;

                    }

                }

            else

                {

                result = EFalse;

                }

            delete content;

            }

        else

            {

            result = EFalse;

            }

        }

    return result;

    }

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

// CSmilMediaRendererBase::DrawFocus

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

//

void CSmilMediaRendererBase::DrawFocus( CGraphicsContext& aGc,

                                        const MSmilFocus* aFocus ) const

    {

    if ( aFocus )

        {

        TRect rect = iFocusRect.IsEmpty() ? aFocus->Rect() : iFocusRect;

        aGc.Reset();

        aGc.SetClippingRect( rect );

        rect.iTl.iX += 1;

        rect.iTl.iY += 1;

        aGc.SetBrushStyle(CGraphicsContext::ENullBrush);

        aGc.SetPenColor( KRgbGray );

        aGc.DrawRect( rect );

        if (aFocus->IsSelected())

            {

            aGc.SetPenColor( KRgbBlue );

            }

        else

            {

            aGc.SetPenColor( KRgbBlack );

            }

        rect.Move( -1, -1 );

        aGc.DrawRect( rect );

        }

    }

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

// CSmilMediaRendererBase::DrawScrollBars

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

//

void CSmilMediaRendererBase::DrawScrollBars( CGraphicsContext& aGc,

                                             const TRect& aRegionRect,

                                             const TRect& aMediaRect ) const

    {

    aGc.Reset();

    aGc.SetClippingRect( aRegionRect );

    aGc.SetBrushStyle( CGraphicsContext::ESolidBrush );

    TInt regionHeight = aRegionRect.Height();

    TInt regionWidth = aRegionRect.Width();

    TInt mediaHeight = aMediaRect.Height();

    TInt mediaWidth = aMediaRect.Width();

    if ( mediaWidth &&

        ( aMediaRect.iTl.iX < aRegionRect.iTl.iX ||

        aMediaRect.iBr.iX > aRegionRect.iBr.iX ) )

        {

        // Draw horizontal scrollbar...

        // Calculate relative width of the elevator

        // (using simple proportion):

        //

        //   indicatorWidth      region total width

        // ------------------ = --------------------

        // region total width    media total width

        //

        TInt indicatorWidth = regionWidth * regionWidth / mediaWidth;

        indicatorWidth = Min( indicatorWidth, regionWidth );

        // Calculate relative position of the elevator

        // (using simple proportion):

        //

        //    indicatorXPos      media to the left of region     

        // ------------------- = ---------------------------

        // region total width         media total width

        //

        TInt indicatorXPos =

            ( aRegionRect.iTl.iX - aMediaRect.iTl.iX ) * regionWidth / mediaWidth;

        indicatorXPos = Max( 0, indicatorXPos );

        // Calculate the top left Y-coordinate for the scroll bar

        // Leave space for focus + one pixel between focus & scroll bar

        TInt topLeftY = aRegionRect.iBr.iY;

        topLeftY -= KScrollElevatorSize;

        topLeftY -= 1;

        topLeftY -= KFocusSize;

        // Calculate the rect of the scroll bar elevator

        //

        TRect xIndicator( 

            TPoint( aRegionRect.iTl.iX + indicatorXPos, topLeftY ),

            TSize( indicatorWidth, KScrollElevatorSize ) );

        // Draw scroll bar background

        aGc.SetPenColor( AKN_LAF_COLOR( KScrollBarBGColorID ) );

        aGc.SetBrushColor( AKN_LAF_COLOR( KScrollBarBGColorID ) );

        aGc.DrawRect( TRect( 

            TPoint( aRegionRect.iTl.iX, xIndicator.iTl.iY ),

            TSize( regionWidth, xIndicator.Height() ) ) );

        // Draw scroll bar elevator

        aGc.SetPenColor( AKN_LAF_COLOR( KScrollBarFGColorID ) );

        aGc.SetBrushColor( AKN_LAF_COLOR( KScrollBarFGColorID ) );

        aGc.DrawRect( xIndicator );

        // Draw scroll bar vertical lines

        aGc.SetPenColor( AKN_LAF_COLOR( KScrollBarLineColorID ) );

        aGc.DrawLine( 

            TPoint( xIndicator.iTl.iX, xIndicator.iTl.iY ),

            TPoint( xIndicator.iTl.iX, xIndicator.iBr.iY ) );

        aGc.DrawLine( 

            TPoint( xIndicator.iBr.iX, xIndicator.iTl.iY ),

            TPoint( xIndicator.iBr.iX, xIndicator.iBr.iY ) );

        }

    if ( mediaHeight &&

        ( aMediaRect.iTl.iY < aRegionRect.iTl.iY ||

        aMediaRect.iBr.iY > aRegionRect.iBr.iY ) )

        {

        // Draw vertical scrollbar...

        // Calculate relative height of the elevator

        TInt indicatorHeight = regionHeight * regionHeight / mediaHeight;

        indicatorHeight = Min( indicatorHeight, regionHeight );

        // Calculate relative position of the elevator

        TInt indicatorYPos =

            ( aRegionRect.iTl.iY - aMediaRect.iTl.iY ) * regionHeight / mediaHeight;

        indicatorYPos = Max( 0, indicatorYPos );

        // Determine whether the scroll bar should be

        // on the left or on the right side of the region

        //

        // NOTE: There's one pixel wide margin both on the left

        // and the right side of the actual elevator -> thus

        // "+1" or "-1" for the x-coordinates

        TInt topLeftX = AknLayoutUtils::LayoutMirrored()

            ? aRegionRect.iTl.iX + KFocusSize + 1

            : aRegionRect.iBr.iX - KScrollElevatorSize - 1 - KFocusSize;

        // Calculate the rect of the scroll bar elevator

        //

        TRect yIndicator( 

            TPoint( topLeftX, aRegionRect.iTl.iY + indicatorYPos ),

            TSize( KScrollElevatorSize, indicatorHeight ) );

        // Draw scroll bar background

        aGc.SetPenColor( AKN_LAF_COLOR( KScrollBarBGColorID ) );

        aGc.SetBrushColor( AKN_LAF_COLOR( KScrollBarBGColorID ) );

        aGc.DrawRect( TRect( 

            TPoint( yIndicator.iTl.iX, aRegionRect.iTl.iY ),

            TSize( yIndicator.Width(), aRegionRect.Height() ) ) );

        // Draw scroll bar elevator

        aGc.SetPenColor( AKN_LAF_COLOR( KScrollBarFGColorID ) );

        aGc.SetBrushColor( AKN_LAF_COLOR( KScrollBarFGColorID ) );

        aGc.DrawRect( yIndicator );

        // Draw scroll bar horizontal lines

        aGc.SetPenColor( AKN_LAF_COLOR( KScrollBarLineColorID ) );

        aGc.DrawLine( 

            TPoint( yIndicator.iTl.iX, yIndicator.iTl.iY ),

            TPoint( yIndicator.iBr.iX, yIndicator.iTl.iY ) );

        aGc.DrawLine( 

            TPoint( yIndicator.iTl.iX, yIndicator.iBr.iY ),

            TPoint( yIndicator.iBr.iX, yIndicator.iBr.iY ) );

        }

    }

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

// CSmilMediaRendererBase::BeginActiveWait

//

// Begins active wait.

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

//

void CSmilMediaRendererBase::BeginActiveWait()

    {

    if( !iWait.IsStarted() )

        {

        TRAP_IGNORE( iEikonEnv->EikAppUi()->AddToStackL( this, ECoeStackPriorityCba ) );

        iWait.Start();

        }

    }

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

// CSmilMediaRendererBase::EndActiveWait

//

// Ends active wait.

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

//

void CSmilMediaRendererBase::EndActiveWait()

    {

    if( iWait.IsStarted() )

        {

        iEikonEnv->EikAppUi()->RemoveFromStack( this );

        if ( iEventArray )

            {

            for ( TInt current = 0; current < iEventArray->Count(); current++ )

                {

                iCoeEnv->WsSession().SimulateKeyEvent( iEventArray->At( current ) );

                }

            iEventArray->Reset();

            }

        iWait.AsyncStop();

        }

    }

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

// CSmilMediaRendererBase::Intent

//

// Returns correct access intent for this media type.

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

//

ContentAccess::TIntent CSmilMediaRendererBase::Intent() const

    {

    ContentAccess::TIntent result( ContentAccess::EUnknown );

    switch( iMediaType )

        {

        case EMsgMediaAudio:

        case EMsgMediaVideo:

            {

            result = ContentAccess::EPlay;

            break;

            }

        case EMsgMediaImage:

        case EMsgMediaText:

        case EMsgMediaSvg:

            {

            result = ContentAccess::EView;

            break;

            }

        default:

            {

            break;

            }

        }

    return result;

    }

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

// CSmilMediaRendererBase::ConsumeDRMRightsL

//

// Consumes DRM rights if media object is DRM protected.

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

//

TInt CSmilMediaRendererBase::ConsumeDRMRightsL()

    {

    TInt result( DRMCommon::EOk );

    if ( iDrmProtection != DRMCommon::ENoDCFFile &&

         !iDrmRightConsumed )

        {

        result = iDrmHelper.Consume2( *iDrmUri,

                                      Intent(),

                                      CDRMHelper::EStart );

        iDrmRightConsumed = ETrue;

        }

    return result;

    }

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

// CSmilMediaRendererBase::CheckDRMRights

//

// Checks DRM rights if media object is DRM protected.

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

//

TInt CSmilMediaRendererBase::CheckDRMRights()

    {

    TInt result( DRMCommon::EOk );