/*
* Copyright (c) 2004 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:  Image Transforms subsystem.
*
*/


// INCLUDE FILES

#include <e32svr.h>
#include <fbs.h>

#include "cvtimagerotator.h"
#include "CVtImageRotatorImplMirrorFlip.h"
#include "CVtImageRotatorImplClockwise.h"

// CONSTANTS

_LIT( KModuleName, "CVtImageRotator" );

// MACROS

#ifdef _DEBUG
#    define __IF_DEBUG(t) {RDebug::t;}
#else
#    define __IF_DEBUG(t)
#endif

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

// -----------------------------------------------------------------------------
// CVtImageRotator::NewL( MVtImageRotatorObserver& aObserver,
//  TPriority aPriority )
// -----------------------------------------------------------------------------
EXPORT_C CVtImageRotator* CVtImageRotator::NewL(
    MVtImageRotatorObserver& aObserver,
    TPriority aPriority)
    {
    CVtImageRotator* self = new ( ELeave ) CVtImageRotator( aObserver, aPriority );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop(); // self
    return self;
    }

// -----------------------------------------------------------------------------
// CVtImageRotator::~CVtImageRotator()
// -----------------------------------------------------------------------------
EXPORT_C CVtImageRotator::~CVtImageRotator()
    {
	Cancel();
    delete iAsyncCallBack;
    delete iHeapLock;
	delete iRotatorImpl;
    }

// -----------------------------------------------------------------------------
// CVtImageRotator::ScaleL( const CVtImage& aSource,
//  CVtImage& aTarget, const TRotationAngle& aAngle )
// -----------------------------------------------------------------------------
EXPORT_C void CVtImageRotator::RotateL( const CVtImage& aSource,
    CVtImage& aTarget, const TRotationAngle& aAngle )
    {
    if ( !IsActive() )
        {
        CreateRotatorL( aAngle );
        iRotatorImpl->SetSourceTargetL( aSource, aTarget );
        iCancelled = EFalse;
        Activate();
        iAsyncCallBack->CallBack();
        }
    else
        {
        User::Panic( KModuleName(), EBusy );
        }
    }

// -----------------------------------------------------------------------------
// CVtImageRotator::Rotate
// -----------------------------------------------------------------------------
EXPORT_C void CVtImageRotator::Rotate(
    const CVtImage& aSource,
    CVtImage& aTarget, const TRotationAngle& aAngle )
    {
    TRAPD( result, RotateL( aSource, aTarget, aAngle ) );
    if ( result != KErrNone )
        {
        Activate();
        Signal( result );
        }
    }

// -----------------------------------------------------------------------------
// CVtImageRotator::CVtImageRotator( MVtImageRotatorObserver& aObserver,
//  TPriority aPriority )
// -----------------------------------------------------------------------------
CVtImageRotator::CVtImageRotator( MVtImageRotatorObserver& aObserver,
                                  TPriority aPriority )
: CActive( aPriority ), iObserver( aObserver )
    {
    CActiveScheduler::Add( this );
    }

// -----------------------------------------------------------------------------
// CVtImageRotator::ConstructL()
// -----------------------------------------------------------------------------
void CVtImageRotator::ConstructL()
    {
    iHeapLock = new ( ELeave ) CFbsBitmap();
    iHeapLock->Create( TSize( 1, 1 ), EColor256 );
    iAsyncCallBack = new ( ELeave )
        CAsyncCallBack( TCallBack( StaticRotate, this ), Priority() );
    }

// -----------------------------------------------------------------------------
// CVtImageRotator::CreateRotatorL( const TRotationAngle& aAngle )
// -----------------------------------------------------------------------------
void CVtImageRotator::CreateRotatorL( const TRotationAngle& aAngle )
    {
    if( iRotatorImpl )
        {
        if( iRotatorImpl->SupportsRotationAngle( aAngle ) )
            {
            iRotatorImpl->SetAngle( aAngle );
            return;
            }
        delete iRotatorImpl;
        iRotatorImpl = 0;
        }

    switch( aAngle )
        {
        case E90DegreesClockwise:
        case E270DegreesClockwise:
            iRotatorImpl =
                new ( ELeave ) CVtImageRotatorImplClockwise( aAngle );
            break;

        case EMirrorHorizontalAxis:
        case EFlipVerticalAxis:
        case E180DegreesClockwise:
            iRotatorImpl =
                new ( ELeave ) CVtImageRotatorImplMirrorFlip( aAngle );
            break;

        default:
            User::Leave( KErrNotSupported );
        }
    }

// -----------------------------------------------------------------------------
// CVtImageRotator::Activate
// -----------------------------------------------------------------------------
void CVtImageRotator::Activate()
    {
    iStatus = KRequestPending;
    SetActive();
    }

// -----------------------------------------------------------------------------
// CVtImageRotator::Signal( TInt aError )
// -----------------------------------------------------------------------------
void CVtImageRotator::Signal( TInt aError )
    {
    TRequestStatus* pStatus = &iStatus;
    User::RequestComplete( pStatus, aError );
    }

// -----------------------------------------------------------------------------
// CVtImageRotator::RunL()
// -----------------------------------------------------------------------------
void CVtImageRotator::RunL()
    {
    iObserver.RotationFinished( iStatus.Int() );
    }

// -----------------------------------------------------------------------------
// CVtImageRotator::DoCancel()
// -----------------------------------------------------------------------------
void CVtImageRotator::DoCancel()
    {
    if ( iStatus == KRequestPending )
        {
        iCancelled = ETrue;
        Signal( KErrCancel );
        iObserver.RotationFinished( KErrCancel );
        }
    }

// -----------------------------------------------------------------------------
// CVtImageRotator::StaticRotate()
// -----------------------------------------------------------------------------
TInt CVtImageRotator::StaticRotate( TAny* aPtr )
    {
    CVtImageRotator* self = reinterpret_cast< CVtImageRotator* >( aPtr );
    self->DoRotate();
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// CVtImageRotator::DoRotate
// -----------------------------------------------------------------------------
void CVtImageRotator::DoRotate()
    {
    if ( !iCancelled )
        {
        TBool more;
        TBool needsLock = iRotatorImpl->NeedHeapLock();
        if( needsLock )
            {
            iHeapLock->LockHeap( ETrue );
            }
        TInt result = iRotatorImpl->Rotate( more );
        if( needsLock )
            {
            iHeapLock->UnlockHeap( ETrue );
            }
        if( !more || ( result != KErrNone ) )
            {
            Signal( result );
            }
        else
            {
            iAsyncCallBack->CallBack();
            }
        }
    }

// ========================== OTHER EXPORTED FUNCTIONS =========================

// End of File