/*

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

*       MsgEditor image UI control - a Message Editor Base control.

*

*/

// INCLUDE FILES

#include "MsgImageControl.h"

#include <DRMCommon.h>

#include <AknUtils.h>               // AknsUtils

#include <AknsDrawUtils.h>          // AknsDrawUtils

#include <aknlayoutscalable_apps.cdl.h>

#include <MsgEditorView.h>          // CMsgEditorView

#include <MsgEditorCommon.h>

#include <IHLImageFactory.h>        // IHLImageFactory

#include <IHLViewerFactory.h>       // IHLViewerFactory

#include <MIHLFileImage.h>          // MIHLFileImage

#include <MIHLBitmap.h>             // MIHLBitmap

#include <MIHLImageViewer.h>        // MIHLImageViewer

#include <icl/imagecodecdata.h>     // KImageTypeBMPUid

#include "MsgFrameControl.h"

#include "MsgIconControl.h"

#include "MsgBitmapControl.h"

#include "MsgMediaControlLogging.h"

// ==========================================================

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

// MACROS

// LOCAL CONSTANTS AND MACROS

const TInt KAnimationStartDelay = 500000; // 0,5s

const TInt KAnimationDelayBetweenLoops = 1000000; // 1s

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

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

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

// CMsgImageControl::CMsgImageControl

//

// Constructor.

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

//

CMsgImageControl::CMsgImageControl( MMsgBaseControlObserver& aBaseControlObserver ) : 

    CMsgMediaControl( aBaseControlObserver, EMsgComponentIdImage, EMsgImageControl )

    {

    }

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

// CMsgImageControl::ConstructL

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

//

void CMsgImageControl::ConstructL( CMsgEditorView& aParent, MMsgAsyncControlObserver* aObserver )

    {

    BaseConstructL( aParent, aObserver );    

    iBitmapControl = new( ELeave ) CMsgBitmapControl;

    iBitmapControl->SetContainerWindowL( *this );

    CalculateMaxSize();

    TRect rect( aParent.Rect() );

    if ( rect.Height() == 0 || rect.Width() == 0 )

        {

        // We have been called before view construction.

        // Set rect to screen size.

        rect.SetRect( TPoint(), iMaxSize );

        }

    SetRect( rect );

    iLoopTimer = CPeriodic::NewL( EPriorityNormal );

    }

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

// CMsgImageControl::NewL

//

// Two-phased constructor.

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

//

EXPORT_C CMsgImageControl* CMsgImageControl::NewL( CMsgEditorView& aParent,

                                                   MMsgAsyncControlObserver* aObserver )

    {

    CMsgImageControl* self = new( ELeave ) CMsgImageControl( aParent );

    CleanupStack::PushL( self );

    self->ConstructL( aParent, aObserver );

    CleanupStack::Pop( self );

    return self;

    }

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

// CMsgImageControl::~CMsgImageControl

//

// Destructor

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

//

CMsgImageControl::~CMsgImageControl()

    {

    delete iEngine;

    delete iDestinationBitmap;

    delete iSourceImage;

    delete iBitmapControl;

    delete iLoopTimer;

    }

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

// CMsgImageControl::LoadL

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

//

void CMsgImageControl::LoadL( RFile& aFileHandle )

    {

    Reset();

    iSourceImage = IHLImageFactory::OpenFileImageL( aFileHandle, 

                                                    0,  // image index

                                                    MIHLFileImage::EOptionNoDRMConsume );

    SetState( EMsgAsyncControlStateOpening );

    iDestinationBitmap = IHLBitmap::CreateL();

    TSize sourceSize( iSourceImage->Size() );

    TSize targetSize = TSize(

    	Min( sourceSize.iWidth, iMaxSize.iWidth - iFrame->FrameBorderSize().iWidth ),

		Min( sourceSize.iHeight, iMaxSize.iHeight - iFrame->FrameBorderSize().iHeight ) );

    if ( !iSourceImage->IsAnimation() &&

         ( iSourceImage->ImageType() == KImageTypeBMPUid || 

           iSourceImage->ImageType() == KImageTypeGIFUid ||

           iSourceImage->ImageType() == KImageTypePNGUid ) )

        {

        iEngine = IHLViewerFactory::CreateImageViewerL( targetSize,

                                                        *iSourceImage, 

                                                        *iDestinationBitmap, 

                                                        *this, 

                                                        MIHLImageViewer::EOptionUseBilinearInterpolation);

        }

   else

        {

        iEngine = IHLViewerFactory::CreateImageViewerL( targetSize,

                                                        *iSourceImage, 

                                                        *iDestinationBitmap, 

                                                        *this, 

                                                        0 );

        }

    }

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

// CMsgImageControl::Cancel

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

//

void CMsgImageControl::Cancel()

    {

    if ( iState == EMsgAsyncControlStateOpening )

        {

        Reset();

        SetState( EMsgAsyncControlStateIdle );

        }

    }

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

// CMsgImageControl::PlayL

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

//

void CMsgImageControl::PlayL()

    {

    if ( IsAnimation() &&

         iState >= EMsgAsyncControlStateOpening )

        {

        DoPlay( 0 );

        }

    }

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

// CMsgImageControl::PauseL

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

//

void CMsgImageControl::PauseL()

    {

    if ( IsAnimation() && 

         iState >= EMsgAsyncControlStateReady )

        {

        DoPause();

        }

    }

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

// CMsgImageControl::Stop

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

//

void CMsgImageControl::Stop()

    {    

    if ( IsAnimation() && 

         iState >= EMsgAsyncControlStateReady )

        {

        StopAnimation();

        SetState( EMsgAsyncControlStateStopped );

        }

    }

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

// CMsgImageControl::Close

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

//

void CMsgImageControl::Close()

    {

    Stop();

    SetState( EMsgAsyncControlStateIdle );

    }

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

// CMsgImageControl::IsAnimation

//

// Return ETrue if loaded image is animation.

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

//

EXPORT_C TBool CMsgImageControl::IsAnimation() const

    {

    TBool result( EFalse );

    if ( iSourceImage )

        {

        result = iSourceImage->IsAnimation();

        }

    return result;

    }

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

// CMsgImageControl::SetAnimationLoopCount

//

// Sets animation loop count (i.e. how many times animation

// is played fully through). -1 means that it is looped forever.

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

//

EXPORT_C void CMsgImageControl::SetAnimationLoopCount( TInt aCount )

    {

    iLoopCount = aCount;

    }

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

// CMsgImageControl::SetImageFileOpenOrClose

//

// Sets image file open or close.

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

//

EXPORT_C void CMsgImageControl::SetImageFileClosed( )

    {

    if ( iSourceImage )

        {

        Stop();

        delete iSourceImage;

        iSourceImage = NULL;

        delete iEngine;

        iEngine = NULL;

        SetState( EMsgAsyncControlStateIdle );

        }

    }

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

// CMsgImageControl::SetAndGetSizeL

//

// Calculates and sets the size of the control and returns new size as

// reference aSize.

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

//

void CMsgImageControl::SetAndGetSizeL( TSize& aSize )

    {

    // Adjust max height if needed

    if ( aSize.iHeight > iMaxSize.iHeight )

        {

        aSize.iHeight = iMaxSize.iHeight;

        }

    // Do not adjust the width. The width of the control must always

    // be the same as the width of the client rect.

    aSize = CalculateControlSize( aSize );

    SetSize( aSize );

    }

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

// CMsgImageControl::NotifyViewEvent

//

// Animation playback is paused if view looses focus and resumed

// when focus is again gained. Resuming happens only if animation is

// still at pause state and control is on playing state.

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

//

void CMsgImageControl::NotifyViewEvent( TMsgViewEvent aEvent, TInt aParam )

    {

    switch ( aEvent )

        {

        case EMsgViewEventViewFocusLost:

            {

            if ( iAnimationState == EAnimationPlaying )

                {

                PauseAnimation();

                }

            break;

            }

        case EMsgViewEventViewFocusGain:

            {

            if ( iAnimationState == EAnimationPaused &&

                 iState == EMsgAsyncControlStatePlaying )

                {

                StartAnimation( KAnimationStartDelay );

                }

            break;

            }

        default:

            {

            break;

            }

        }

    CMsgMediaControl::NotifyViewEvent( aEvent, aParam );

    }

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

// CMsgImageControl::Reset

//

// Empties the control.

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

//

void CMsgImageControl::Reset()

    {

    delete iEngine;

    iEngine = NULL;

    iAnimationState = EAnimationStopped;

    delete iDestinationBitmap;

    iDestinationBitmap = NULL;

    iBitmapControl->SetBitmap( NULL );

    delete iSourceImage;

    iSourceImage = NULL;

    ResetIconId();

    }

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

// CMsgImageControl::FocusChanged

//

// Updates the focus (i.e. set frame control visible/invisible).

// Calls base class implementation if icon is visible. Otherwise

// performs it's own handling.

// Frame control is redraw immediatelly if that 

// is requested and frame control state is changed. Otherwise

// normal deferred drawing is done. This is activated at 

// CCoeControl::MakeVisible if needed.

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

//

void CMsgImageControl::FocusChanged( TDrawNow aDrawNow )

    {

    if ( VisiblePlaceholder() )

        {

        CMsgMediaControl::FocusChanged( aDrawNow );

        }

    else 

        {

        TBool oldVisibility( iFrame->IsVisible() );

        iFrame->MakeVisible( IsFocused() );

        if ( aDrawNow == EDrawNow &&

             iFrame->IsVisible() != oldVisibility )

            {

            DrawNow();

            }

        }

    }

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

// CMsgImageControl::SizeChanged

//

// Called when size is changed.

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

//

void CMsgImageControl::SizeChanged()

    {

    if ( iEngine && 

         Size() != iEngine->ViewerSize() )

        {

        TSize bitmapSize = iEngine->SourceSize() ;

        TSize controlSize = iSize;

        controlSize.iWidth -= iFrame->FrameBorderSize().iWidth;

        controlSize.iHeight -= iFrame->FrameBorderSize().iHeight;

        TReal widthRatio = static_cast<TReal>( controlSize.iWidth ) / 

                           static_cast<TReal>( bitmapSize.iWidth );

        TReal heightRatio = static_cast<TReal>( controlSize.iHeight ) / 

                            static_cast<TReal>( bitmapSize.iHeight );

        TReal zoomRatio = ( widthRatio < heightRatio ) ? widthRatio : heightRatio;

        iEngine->SetViewerSize( Size() );

        iEngine->SetZoomRatio( zoomRatio );

        }

    // Size updated at the ViewerBitmapChanged when image scaling is done.

    iBitmapControl->SetPosition( Position() + CalculateImagePosition() );

    if ( iDestinationBitmap && 

         iDestinationBitmap->IsCreated() )

        {

        iFrame->SetImageSize( iDestinationBitmap->Bitmap().SizeInPixels() );

        }

    if ( iState == EMsgAsyncControlStatePlaying )

        {

        // Start animation if needed on playing state.

        StartAnimation( 0 );

        }

    CMsgMediaControl::SizeChanged();

    }

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

// CMsgImageControl::Draw

//

// Draws the basic skin background for given rectangle. 

// Image is drawn on CBitmapControl::Draw function.

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

//

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

    {

    CWindowGc& gc = SystemGc();

    if ( !VisiblePlaceholder() )

        {

        if ( !AknsDrawUtils::BackgroundBetweenRects( AknsUtils::SkinInstance(), 

                                                 AknsDrawUtils::ControlContext( this ), 

                                                 this, 

                                                 gc, 

                                                 Rect(),

                                                 iBitmapControl->Rect(),

                                                 KAknsDrawParamNoClearUnderImage ) )

            {

            gc.SetBrushColor( AKN_LAF_COLOR( 0 ) );

            gc.SetPenStyle( CGraphicsContext::ENullPen );

    		gc.SetBrushStyle( CGraphicsContext::ESolidBrush );

        	gc.DrawRect( aRect );

            }

        }

    else 

        {

        // Basic icon drawing from base class when icon is visible.

        CMsgMediaControl::Draw( aRect );

        }

    }

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

// CMmsImageControl::MakeVisible

//

// Sets same visibility to bitmap control as image control has.

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

//

void CMsgImageControl::MakeVisible( TBool aVisible )

    {

    iBitmapControl->MakeVisible( aVisible );

    CMsgMediaControl::MakeVisible( aVisible );

    }

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

// CMmsImageControl::PositionChanged

//

// Calculates new position to bitmap control as image control position

// has changed.

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

//

void CMsgImageControl::PositionChanged()

    {

    iBitmapControl->SetPosition( Position() + CalculateImagePosition() );

    CMsgMediaControl::PositionChanged();

    }

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

// CMsgImageControl::HandleResourceChange

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

//

void CMsgImageControl::HandleResourceChange( TInt aType )

    {

    CMsgMediaControl::HandleResourceChange( aType ); 

    if ( aType == KEikDynamicLayoutVariantSwitch )

        {

        CalculateMaxSize();