/*

* 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: SmilImageRenderer implementation

*

*/

// INCLUDE FILES

#include <coemain.h>

#include <smilregioninterface.h>

#include <smilpresentation.h>

#include <smilmediainterface.h>

#include <IHLImageFactory.h>

#include <IHLViewerFactory.h>

#include <MIHLFileImage.h>

#include <MIHLBitmap.h>

#include <MIHLImageViewer.h>

#include <AknUtils.h>

#include <aknlayoutscalable_apps.cdl.h>

#include "SmilImageRenderer.h" 

#ifdef IMAGE_DEBUG

    #include "SmilMediaLogging.h"

#endif

// Scrolling is done in 1/4 steps

const TInt KScrollStepFraction = 4;

#ifdef RD_SCALABLE_UI_V2

const TInt KScrollValue = 1;

#endif

// Minimum frame delay

const TInt KMinimumFrameDelay = 100; // 100 ms

const TInt KProcessingDelayOffset = 100; // 100 ms

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

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

// CSmilImageRenderer::CSmilImageRenderer

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

//

CSmilImageRenderer::CSmilImageRenderer( MSmilMedia* aMedia,

                                        DRMCommon& aDrmCommon,

                                        CDRMHelper& aDrmHelper ) :

    CSmilMediaRendererBase( EMsgMediaImage, aMedia, aDrmCommon, aDrmHelper ),

    iTotalLength( 0 ),

    iPrevState( ENotReady ),

    iCurrState( ENotReady ),

    iProcessingDelay( TInt64( 0 ) )

#ifdef RD_SCALABLE_UI_V2

    , iNotYetDrawn( ETrue )

#endif    

    {

    iSmilObject = NULL;

    }

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

// CSmilImageRenderer::ConstructL

// Checks neccessary parameters and initializes heap member variables. 

// Converts first (and in most cases only) frame of the source image and

// calculates renderer duration.

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

//

void CSmilImageRenderer::ConstructL( RFile& aFileHandle )

    {

#ifdef IMAGE_DEBUG

    SMILUILOGGER_WRITE_TIMESTAMP( " --------------------------------" )

    SMILUILOGGER_ENTERFN( "[SMILUI] Image: ConstructL" )

    SMILUILOGGER_WRITEF( _L("[SMILUI] Image: iCurrState=%d"), iCurrState );

#endif

    BaseConstructL( aFileHandle );

    User::LeaveIfError( CheckDRMRights() );

    iSourceImage = IHLImageFactory::OpenFileImageL( aFileHandle );

    iSourceSize = iSourceImage->Size();

    iAnimation = iSourceImage->IsAnimation();

    iDestinationBitmap = IHLBitmap::CreateL();

    InitializeViewerL();

    SetupScrollingL();

    if ( iSourceImage->IsAnimation() )

        {              

        for( TInt frame = 0; frame < iSourceImage->AnimationFrameCount(); frame++ )

            {

            // iTotalLength is on millisecond and delay on microseconds.

            TInt frameDelay = iSourceImage->AnimationFrameDelay( frame ).Int() / 1000;

            if ( frameDelay < KMinimumFrameDelay )

                {

                frameDelay = KMinimumFrameDelay;

                }

            // iProvessingDelay is calculated at InitializeViewerL

            frameDelay = Max( I64INT( iProcessingDelay.Int64() ), frameDelay );

            iTotalLength = iTotalLength + frameDelay;

            }

        iMedia->RendererDurationChangedL();

        }

    else

        {

        if ( !iIsScrollable )

            {

            // Memory optimization. This is not needed

            // if image is not scrollable or animation.

            // Releases 1x bitmap size memory + possible mask

            delete iEngine;

            iEngine = NULL;

            delete iSourceImage;

            iSourceImage = NULL;

            }        

        }

#ifdef RD_SCALABLE_UI_V2    

    CCoeControl* parentControl = iMedia->Presentation()->GetPlayer()->GetControl( iMedia->Presentation() );

    SetContainerWindowL( *parentControl );

    TRect controlRect = iMedia->GetRegion()->GetRectangle();

    controlRect.Move( parentControl->Position() );

    SetRect( controlRect );

#endif    

#ifdef IMAGE_DEBUG  

    SMILUILOGGER_LEAVEFN( "[SMILUI] Image: ConstructL" )

    SMILUILOGGER_WRITEF( _L("[SMILUI] Image: iCurrState=%d"), iCurrState );

#endif

    }

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

// CSmilImageRenderer::NewL

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

//

CSmilImageRenderer* CSmilImageRenderer::NewL( RFile& aFileHandle,

                                              MSmilMedia* aMedia,

                                              DRMCommon& aDrmCommon,

                                              CDRMHelper& aDrmHelper )

    {

#ifdef IMAGE_DEBUG

    SMILUILOGGER_WRITE_TIMESTAMP( " --------------------------------" )

    SMILUILOGGER_ENTERFN( "[SMILUI] Image: NewL" )

#endif

    CSmilImageRenderer* self = new (ELeave) CSmilImageRenderer( aMedia,

                                                                aDrmCommon,

                                                                aDrmHelper );

    CleanupStack::PushL( self );

    self->ConstructL( aFileHandle );

    CleanupStack::Pop( self );

#ifdef IMAGE_DEBUG

    SMILUILOGGER_LEAVEFN( "[SMILUI] Image: NewL" )

#endif

    return self;

    }

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

// CSmilImageRenderer::~CSmilImageRenderer

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

//

CSmilImageRenderer::~CSmilImageRenderer()

    {

#ifdef IMAGE_DEBUG

    SMILUILOGGER_ENTERFN( "[SMILUI] Image: ~CSmilImageRenderer" )

    SMILUILOGGER_WRITEF( _L("[SMILUI] Image: iCurrState=%d"), iCurrState );

#endif

    delete iEngine;

    delete iDestinationBitmap;

    delete iSourceImage;

    iMedia = NULL; // For LINT

#ifdef RD_SCALABLE_UI_V2    

    delete iSBFrame;

#endif    

#ifdef IMAGE_DEBUG

    SMILUILOGGER_LEAVEFN( "[SMILUI] Image: ~CSmilImageRenderer" )

#endif

    }

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

// CSmilImageRenderer::IsVisual

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

//

TBool CSmilImageRenderer::IsVisual() const

    {

    return ETrue;

    }

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

// CSmilImageRenderer::IsOpaque

// Renderer is determined to be opaque (non-transparent) if

// mask is not present.

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

//

TBool CSmilImageRenderer::IsOpaque() const

    {

    return !iDestinationBitmap->HasMask();

    }

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

// CSmilImageRenderer::IsScrollable

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

//

TBool CSmilImageRenderer::IsScrollable() const

    {

    return iIsScrollable;

    }

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

// CSmilImageRenderer::IsControl

// All renderer are specified to be control on the base class.

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

//

TBool CSmilImageRenderer::IsControl() const

    {

    return ETrue;

    }

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

// CSmilImageRenderer::IntrinsicWidth

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

//

TInt CSmilImageRenderer::IntrinsicWidth() const

    {

    return iSourceSize.iWidth;

    }

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

// CSmilImageRenderer::IntrinsicHeight

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

//

TInt CSmilImageRenderer::IntrinsicHeight() const

    {

    return iSourceSize.iHeight;

    }

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

// CSmilImageRenderer::IntrinsicDuration

// Returns zero if still image otherwise returns sum of animation delays.

// Duration is specified on milliseconds.

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

//

TSmilTime CSmilImageRenderer::IntrinsicDuration() const

    {

#ifdef IMAGE_DEBUG

    SMILUILOGGER_WRITE_TIMESTAMP( " --------------------------------" )

    SMILUILOGGER_ENTERFN( "[SMILUI] Image: IntrinsicDuration" )

    SMILUILOGGER_WRITEF( _L("[SMILUI] Image: iCurrState=%d"), iCurrState );

    SMILUILOGGER_WRITEF( _L("[SMILUI] Image: iTotalLength=%d"), iTotalLength );

#endif

    TSmilTime result( 0 );

    if ( iAnimation )

        {

        result = iTotalLength;

        }

#ifdef IMAGE_DEBUG

    SMILUILOGGER_LEAVEFN( "[SMILUI] Image: IntrinsicDuration" )

    SMILUILOGGER_WRITEF( _L("[SMILUI] Image: iCurrState=%d"), iCurrState );

#endif

    return result;

    }

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

// CSmilImageRenderer::Draw

// Performs drawing only if renderer is visible. Transition filter

// performs its own drawings. Scroll bar and focus drawing is performed

// on functions inherited from base class.

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

//

void CSmilImageRenderer::Draw( CGraphicsContext& aGc, 

                               const TRect& aRect, 

                               CSmilTransitionFilter* aTransitionFilter, 

                               const MSmilFocus* aFocus)

    {

#ifdef IMAGE_DEBUG

    SMILUILOGGER_WRITE_TIMESTAMP( " --------------------------------" )

    SMILUILOGGER_ENTERFN( "[SMILUI] Image: Draw" )

    SMILUILOGGER_WRITEF( _L("[SMILUI] Image: iCurrState=%d"), iCurrState );

    if ( iAnimation )

        {

        SMILUILOGGER_WRITEF( _L("[SMILUI] Image: currentFrame=%d"), iEngine->AnimationFrame() );       

        }

#endif

    if ( iCurrState == EPlaying || iCurrState == EPaused )

        {

        aGc.Reset();

        if ( aTransitionFilter )

            {

            const CFbsBitmap* bitmap = NULL;

            const CFbsBitmap* mask = NULL;

            bitmap = &iDestinationBitmap->Bitmap();

            if ( iDestinationBitmap->HasMask() )

                {

                mask = &iDestinationBitmap->Mask();

                }

            aTransitionFilter->Draw( aGc, 

                                     aRect, 

                                     bitmap, 

                                     iMedia->GetRectangle().iTl, 

                                     mask );

            }

        else        

            {

            TRect destinationRect( aRect );

            destinationRect.Intersection( iMedia->GetRectangle() );

            // Rectangle that indicates what part of the bitmap should be drawn. 

            TRect sourceRect( destinationRect );

            // We have to correct the origin as sourceRect is calculated relative

            // to the bitmap top left corner coordinates and not the graphical context

            // top left coordinates into which destinationRect is related.

            sourceRect.Move( -iMedia->GetRectangle().iTl );

            // Cast graphics context to CFbsBitGc

            CBitmapContext* tmpBitmapContext = static_cast<CBitmapContext*>( &aGc );

            if ( iDestinationBitmap->HasMask() )

                {

                tmpBitmapContext->SetBrushStyle( CGraphicsContext::ENullBrush );

                }

            iDestinationBitmap->Draw( *tmpBitmapContext, 

                                      destinationRect.iTl,

                                      sourceRect );

            }

        if ( iIsScrollable )

            {

#ifdef RD_SCALABLE_UI_V2            

            TRAP_IGNORE( DrawScrollBarL() );

#else            

            DrawScrollBars( aGc, iMedia->GetRectangle(), iImageScrollRect );

#endif            

            }

        DrawFocus( aGc, aFocus );

        }

#ifdef IMAGE_DEBUG  

    SMILUILOGGER_LEAVEFN( "[SMILUI] Image: Draw" )

#endif

    }

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

// CSmilImageRenderer::DrawScrollBarL

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

//

void CSmilImageRenderer::DrawScrollBarL()

    {

#ifdef RD_SCALABLE_UI_V2    

    if ( iNotYetDrawn )

        {

        TInt regionHeight = iMedia->GetRectangle().Height();

        TInt regionWidth = iMedia->GetRectangle().Width();

        TInt imageHeight = iImageScrollRect.Height();

        TInt imageWidth = iImageScrollRect.Width();

        if ( !iSBFrame )

            {

            iSBFrame = new (ELeave) CEikScrollBarFrame( this, this, ETrue );

            iSBFrame->CreateDoubleSpanScrollBarsL(ETrue, EFalse, ETrue, ETrue ); // window owning scrollbar            

         // using this does not draw sbars correctly

         // most likely it has something to do with drawing mechanism

         //   iSBFrame->DrawBackground( EFalse, EFalse );

                 //calculating the correct scrollspans   

            TInt initialScrollSpan = imageWidth/regionWidth;

            initialScrollSpan *= KScrollStepFraction;

            initialScrollSpan += (imageWidth % regionWidth)/(regionWidth/KScrollStepFraction);

            if ( (initialScrollSpan * regionWidth) < (KScrollStepFraction*imageWidth))        

                initialScrollSpan += 1;

            iScrollSpanX = initialScrollSpan;

            initialScrollSpan = imageHeight/regionHeight;

            initialScrollSpan *= KScrollStepFraction;

            //how many times the remainder fits into the 1/KScrollStepFraction th of a page

          //  TInt muschi = (imageHeight % regionHeight)/(regionHeight/KScrollStepFraction);

            initialScrollSpan += (imageHeight % regionHeight)/(regionHeight/KScrollStepFraction);

            // if it still does not match, add one to round up the result

            if ( (initialScrollSpan * regionHeight) < (KScrollStepFraction*imageHeight))        

                initialScrollSpan += 1;

            iScrollSpanY = initialScrollSpan;

            }

        iSBFrame->SetScrollBarVisibilityL( CEikScrollBarFrame::EOn,CEikScrollBarFrame::EOn );    

        TEikScrollBarModel vSbarModel;

        vSbarModel.iThumbPosition = iThumbPosY; 

        vSbarModel.iScrollSpan = iScrollSpanY; 

        TInt indicatorHeight = regionHeight * regionHeight / iImageScrollRect.Height();

        indicatorHeight = Min( indicatorHeight, regionHeight );

        vSbarModel.iThumbSpan = KScrollStepFraction;//indicatorHeight / KSpanDivider;

        TEikScrollBarModel hSbarModel;

        hSbarModel.iThumbPosition = iThumbPosX; 

        hSbarModel.iScrollSpan = iScrollSpanX; 

        TInt indicatorWidth = regionWidth * regionWidth / iImageScrollRect.Width();

        indicatorWidth = Min( indicatorWidth, regionWidth );

        hSbarModel.iThumbSpan =  KScrollStepFraction;//indicatorWidth / KSpanDivider;

        // For EDoubleSpan type scrollbar

        TAknDoubleSpanScrollBarModel hDsSbarModel( hSbarModel );

        TAknDoubleSpanScrollBarModel vDsSbarModel( vSbarModel );

        TEikScrollBarFrameLayout layout;

        layout.iTilingMode = TEikScrollBarFrameLayout::EClientRectConstant;

 //not functional iSBFrame->TileL( &hDsSbarModel, &vDsSbarModel, rect, rect, layout );

        iSBFrame->Tile( &hDsSbarModel, &vDsSbarModel);

        TRect controlRect = iMedia->GetRegion()->GetRectangle();

        controlRect.Move( (iMedia->Presentation()->GetPlayer()->

                        GetControl( iMedia->Presentation()))->Position() );

        TAknWindowLineLayout hLayout( AknLayoutScalable_Apps::scroll_pane_cp018( 2 ) ); // laf value

		AknLayoutUtils::LayoutHorizontalScrollBar( iSBFrame, controlRect, hLayout );

		TAknWindowLineLayout vLayout( AknLayoutScalable_Apps::scroll_pane_cp016( 2 ) ); // laf value

		AknLayoutUtils::LayoutVerticalScrollBar( iSBFrame, controlRect, vLayout );

		iSBFrame->SetVFocusPosToThumbPos( vDsSbarModel.FocusPosition() );

		iSBFrame->MoveHorizThumbTo( hDsSbarModel.FocusPosition() );

        iNotYetDrawn = EFalse;

        }

#else

#endif

    }

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

// CSmilImageRenderer::Scroll

// Determines if scrolling is possible to specified direction.

// If it is calculates how many pixels can be scrolled to

// that direction (scrolling is performed on 1/4 of the original

// image size steps but can be smaller if available space limits it).

// Moving of souce rectangle and scrolling rectangle is done

// on mirror image due to they opposite coordinates. Active wait

// is used on scrolling. Active scheduler is started to 

// wait until asynchronous operation triggered by source rectangle

// moving is completed.

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

//

void CSmilImageRenderer::Scroll( TInt aDirX, TInt aDirY )

    {

#ifdef IMAGE_DEBUG

    SMILUILOGGER_WRITE_TIMESTAMP( " --------------------------------" )

    SMILUILOGGER_ENTERFN( "[SMILUI] Image: Scroll" )

#endif

    ScrollWithOutThumbUpdate( aDirX, aDirY );

#ifdef RD_SCALABLE_UI_V2

    //first moving in y-direction

    if ( iThumbPosY > 0 && aDirY < 0 ||

        iThumbPosY < iScrollSpanY-KScrollStepFraction && aDirY > 0 )

        {

        iThumbPosY += aDirY;

        iSBFrame->MoveVertThumbTo( iThumbPosY );

        }

      //then in x-direction

    if ( iThumbPosX > 0 && aDirX < 0 ||

        iThumbPosX < iScrollSpanY-KScrollStepFraction && aDirX > 0 )

        {

        iThumbPosX += aDirX;

        iSBFrame->MoveHorizThumbTo( iThumbPosX );

        }

#endif        

#ifdef IMAGE_DEBUG  

    SMILUILOGGER_LEAVEFN( "[SMILUI] Image: Scroll" )

#endif

    }

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

// CSmilImageRenderer::PrepareMediaL

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

//

void CSmilImageRenderer::PrepareMediaL()

    {

#ifdef IMAGE_DEBUG

    SMILUILOGGER_WRITE_TIMESTAMP( " --------------------------------" )

    SMILUILOGGER_ENTERFN( "[SMILUI] Image: PrepareMediaL" )

    SMILUILOGGER_WRITEF( _L("[SMILUI] Image: iCurrState=%d"), iCurrState );

#endif

    if ( iCurrState == EReady )

        {

        SetState( EHidden );

        }

#ifdef IMAGE_DEBUG