/*

* 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 "CVtImageScaler.h"

#include "CVtImageScalerImpl.h"

#include "CVtImageScalerImplNearest.h"

#include "CVtImageScalerImplWeightedAverage.h"

#include "CVtImageScalerImplBilinear.h"

// CONSTANTS

_LIT( KModuleName, "CVtImageScaler" );

// MACROS

#ifdef _DEBUG

#    define __IF_DEBUG(t) {RDebug::t;}

#else

#    define __IF_DEBUG(t)

#endif

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

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

// CVtImageScaler::NewL( MVtImageScalerObserver& aObserver, TQuality aQuality,

//   TPriority aPriority )

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

EXPORT_C CVtImageScaler* CVtImageScaler::NewL(

    MVtImageScalerObserver& aObserver,

    TQuality aQuality,

    TPriority aPriority )

    {

    CVtImageScaler* self = new ( ELeave ) CVtImageScaler( aObserver, aPriority );

    CleanupStack::PushL( self );

    self->ConstructL( aQuality );

    CleanupStack::Pop(); // self

    return self;

    }

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

// CVtImageScaler::~CVtImageScaler()

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

EXPORT_C CVtImageScaler::~CVtImageScaler()

    {

	Cancel();

    delete iAsyncCallBack;

    delete iHeapLock;

    delete iScalerImpl;

    }

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

// CVtImageScaler::SetQualityL( TQuality aQuality )

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

EXPORT_C void CVtImageScaler::SetQualityL( TQuality aQuality )

    {

    delete iScalerImpl;

    iScalerImpl = 0;

    switch( aQuality )

        {

        case ENearest:

            iScalerImpl = new ( ELeave ) CVtImageScalerImplNearest();

            break;

        case EWeightedAverage:

            iScalerImpl = new ( ELeave ) CVtImageScalerImplWeightedAverage();

            break;

        case EBilinear:

            iScalerImpl = new ( ELeave ) CVtImageScalerImplBilinear();

            break;

        }

    }

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

// CVtImageScaler::ScaleL( const CVtImage& aSource, CVtImage& aTarget )

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

EXPORT_C void CVtImageScaler::ScaleL(

    const CVtImage& aSource,

    CVtImage& aTarget )

    {

    if( !IsActive() )

        {

        if( !iScalerImpl )

            {

            User::Leave( KErrNotReady );

            }

        iScalerImpl->SetSourceTargetL( aSource, aTarget );

        iCancelled = EFalse;

        Activate();

        iAsyncCallBack->CallBack();

        }

    else

        {

        User::Panic( KModuleName(), EBusy );

        }

    }

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

// CVtImageScaler::Scale( const CVtImage& aSource, CVtImage& aTarget )

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

EXPORT_C void CVtImageScaler::Scale(

    const CVtImage& aSource,

    CVtImage& aTarget )

    {

    TRAPD( result, ScaleL( aSource, aTarget ) );

    if( result != KErrNone )

        {

        Activate();

        Signal( result );

        }

    }

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

// CVtImageScaler::ScaleNowL( const CVtImage& aSource, CVtImage& aTarget )

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

EXPORT_C void CVtImageScaler::ScaleNowL(

    const CVtImage& aSource, CVtImage& aTarget )

    {

    if( !iScalerImpl )

        {

        User::Leave( KErrNotReady );

        }

    iScalerImpl->SetSourceTargetL( aSource, aTarget );

    TInt result;

    TBool more;

    TBool needsLock( iScalerImpl->NeedHeapLock() );

    do

        {

        if ( needsLock )

            {

            iHeapLock->LockHeap( ETrue );

            }

        result = iScalerImpl->Scale( more );

        if ( needsLock )

            {

            iHeapLock->UnlockHeap( ETrue );

            }

        } while ( more && ( result == KErrNone ) );

    User::LeaveIfError( result );

    }

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

// CVtImageScaler::CVtImageScaler()

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

CVtImageScaler::CVtImageScaler( MVtImageScalerObserver& aObserver, TPriority aPriority )

: CActive( aPriority ), iObserver( aObserver )

    {

    CActiveScheduler::Add( this );

    }

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

// CVtImageScaler::ConstructL( TQuality aQuality )

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

void CVtImageScaler::ConstructL( TQuality aQuality )

    {

    SetQualityL( aQuality );

    iHeapLock = new ( ELeave ) CFbsBitmap();

    iHeapLock->Create( TSize( 1, 1 ), EColor256 );

    iAsyncCallBack = new ( ELeave )

        CAsyncCallBack( TCallBack( StaticScale, this ), Priority() );

    }

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

// CVtImageScaler::Activate

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

void CVtImageScaler::Activate()

    {

    iStatus = KRequestPending;

    SetActive();

    }

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

// CVtImageScaler::Signal( TInt aError )

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

void CVtImageScaler::Signal( TInt aError )

    {

    TRequestStatus* pStatus = &iStatus;

    User::RequestComplete( pStatus, aError );

    }

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

// CVtImageScaler::RunL()

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

void CVtImageScaler::RunL()

    {

    iObserver.ScalingFinished( iStatus.Int() );

    }

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

// CVtImageScaler::DoCancel()

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

void CVtImageScaler::DoCancel()

    {

    if ( iStatus == KRequestPending )

        {

        iCancelled = ETrue;

        Signal( KErrCancel );

        iObserver.ScalingFinished( KErrCancel );

        }

    }

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

// CVtImageScaler::StaticScale()

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

TInt CVtImageScaler::StaticScale( TAny* aPtr )

    {

    CVtImageScaler* self = reinterpret_cast< CVtImageScaler* >( aPtr );

    self->DoScale();

    return KErrNone;

    }

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

// CVtImageScaler::DoScale

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

void CVtImageScaler::DoScale()

    {

    if ( !iCancelled )

        {

        TBool more;

        TBool needsLock = iScalerImpl->NeedHeapLock();

        if ( needsLock )

            {

            iHeapLock->LockHeap( ETrue );

            }

        TInt result = iScalerImpl->Scale( more );

        if ( needsLock )

            {

            iHeapLock->UnlockHeap( ETrue );

            }

        if ( !more || ( result != KErrNone ) )

            {

            Signal( result );

            }

        else

            {

            iAsyncCallBack->CallBack();

            }

        }

    }

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

// End of File