/*

* Copyright (c) 2007 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:  Active Palette Base plugin class*

*/

/**

 * @file CActivePalettePluginBase.cpp

 * Active Palette Base plugin class

 */

// INCLUDE FILES

#include "CActivePalettePluginBase.h"

#include "ActivePalette2Logger.h"

#include "ActivePalette2Utils.h"

#include <fbs.h>

#include <bitstd.h>

#include "ActivePalette2Cfg.h"

// CONSTANTS

const TInt KAnimPhase1 = 0;

const TInt KAnimPhase2 = 1;

const TInt KAnimPhaseMax = KAnimPhase2;

const TInt KAnimNofPhases = 2;

const TInt KAnimDeviatinFactorMul = 1;

const TInt KAnimDeviatinFactorDiv = 5;

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

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

// CAnimationHelper::CAnimationHelper()

// C++ constructor

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

//

CAnimationHelper::CAnimationHelper()

    {

	// empty

    }

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

// CAnimationHelper::ConstructL()

// 2nd phase construction

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

//

void CAnimationHelper::ConstructL(const TSize aSize, const TBool aMaskNeeded)

    {

	ActivePalette2Utils::CreateDrawingObjectsL(aSize,&iFrame,&iFrameDevice,&iFrameGc);

	if (aMaskNeeded)

	    {

		ActivePalette2Utils::CreateDrawingObjectsL(EGray256,

			aSize,&iFrameMask,&iFrameMaskDevice,&iFrameMaskGc);		

	    }

    }

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

// CAnimationHelper::~CAnimationHelper()

// Destructor

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

//

CAnimationHelper::~CAnimationHelper()

    {

    // DeleteDrawingObjects checks passed pointers to ensure they are not null

	ActivePalette2Utils::DeleteDrawingObjects(&iFrame,&iFrameDevice,&iFrameGc);

	ActivePalette2Utils::DeleteDrawingObjects(&iFrameMask,&iFrameMaskDevice,&iFrameMaskGc);

    }

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

// CAnimationHelper::NewL()

// Symbian 2 phase construction

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

//

CAnimationHelper * CAnimationHelper::NewL(const TSize aSize, const TBool aMaskNeeded)

    {

	CAnimationHelper * self = new (ELeave) CAnimationHelper();

	CleanupStack::PushL(self);

	self->ConstructL(aSize, aMaskNeeded);

	CleanupStack::Pop(self);

	return self;

    }

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

// NActivePalettePluginFactory::TPluginCreationParams::PluginObserver()

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

//

EXPORT_C MActivePalettePluginObserver& NActivePalettePluginFactory::TPluginCreationParams::PluginObserver(void) const 

    { 

	return iObserver; 

    }

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

// NActivePalettePluginFactory::TPluginCreationParams::Dimensions(void)

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

//

EXPORT_C TSize NActivePalettePluginFactory::TPluginCreationParams::Dimensions(void) const

    {

	return iDimensions;	

    }

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

// NActivePalettePluginFactory::TPluginCreationParams::TPluginCreationParams()

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

//

EXPORT_C NActivePalettePluginFactory::TPluginCreationParams::TPluginCreationParams(MActivePalettePluginObserver & aObserver,

						  												  const TSize& aDimensions)

:   iObserver(aObserver),

    iDimensions(aDimensions)

    {

    }

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

// CActivePalettePluginBase::CActivePalettePluginBase()

// C++ constructor

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

//

EXPORT_C CActivePalettePluginBase::CActivePalettePluginBase(const NActivePalettePluginFactory::TPluginCreationParams & aCreationParams)

:   iPluginObserver(aCreationParams.PluginObserver())

    {

	LOGTEXT( _L( "CActivePalettePluginBase::CActivePalettePluginBase" ) );

	PluginObserver().NotifyPluginCreated(this);

    }

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

// CActivePalettePluginBase::~CActivePalettePluginBase()

// Destructor

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

//

EXPORT_C CActivePalettePluginBase::~CActivePalettePluginBase(void)

    {

	LOGTEXT( _L( "CActivePalettePluginBase::~CActivePalettePluginBase" ) );

	CBase::Delete(iAnimationHelper);

	iAnimationHelper = NULL;

	PluginObserver().NotifyPluginDestroyed(this);

    }

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

// CActivePalettePluginBase::ConstructL()

// 2nd phase constructor

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

//

EXPORT_C void CActivePalettePluginBase::ConstructL(const NActivePalettePluginFactory::TPluginCreationParams& /*aCreationParams*/, 

									               const TDesC8 & /*aCustomDataDes*/,

									               const TInt /*aCustomDataInt*/)

    {

	LOGTEXT( _L( "CActivePalettePluginBase::ConstructL" ) );

	// empty

    }

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

// CActivePalettePluginBase::Shutdown()

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

//

EXPORT_C void CActivePalettePluginBase::Shutdown(void)

    {

	LOGTEXT( _L( "CActivePalettePluginBase::Shutdown" ) );

	// empty

    }

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

// CActivePalettePluginBase::HandleMessageL()

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

//

EXPORT_C void CActivePalettePluginBase::HandleMessageL(const TInt aMessageID,

                                                       const TDesC8& /*aDataDes*/,

                                                       const TInt /*aDataInt*/)

    {

	LOGTEXT1( _L( "CActivePalettePluginBase::HandleMessageL, message ID: %d" ), aMessageID );

	// empty

	if (aMessageID)

	    {

	    // no compiler warning

	    }

    }

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

// CActivePalettePluginBase::PrepareAniFramesL()

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

//

EXPORT_C void CActivePalettePluginBase::PrepareAniFramesL(const TInt aAniType,

									  					  TPluginAnimationInfo& aAniInfo,

									  					  const TPluginAnimationInfo& aDefaultAniInfo,

				 						  	   		      const CFbsBitmap& aItemIcon,

							      		  			      const CFbsBitmap* aItemIconMask)

    {

	LOGTEXT1( _L( "CActivePalettePluginBase::PrepareAniFramesL, AniType ID: %d" ), aAniType);

	// use default animation info

	aAniInfo = aDefaultAniInfo; 

	// create data for icon and mask frames

	iAnimationHelper = CAnimationHelper::NewL(aDefaultAniInfo.iFrameSize,

											  (NULL != aItemIconMask));	

	if (aAniType)

	    {

	    // no compiler warning

	    }

	if (aItemIcon.Handle())

	    {

	    // no compiler warning

	    }

    }

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

// CActivePalettePluginBase::ReleaseAniFrames()

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

//

EXPORT_C void CActivePalettePluginBase::ReleaseAniFrames(const TInt aAniType)

    {

	LOGTEXT1( _L( "CActivePalettePluginBase::ReleaseAniFrames, AniType ID: %d" ), aAniType);

	CBase::Delete(iAnimationHelper);

	iAnimationHelper = NULL;

	if (aAniType) 

	    {

	    // no compiler warning

	    }

    }

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

// CActivePalettePluginBase::ProduceAniFrame(

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

//

EXPORT_C void CActivePalettePluginBase::ProduceAniFrame(

    TInt aAniType,

    TInt aFrameNo,

    const TPluginAnimationInfo& aAniInfo,

    const CFbsBitmap& aItemIcon,

    const CFbsBitmap* aItemIconMask,

    CFbsBitmap** aFrame,

    CFbsBitmap** aFrameMask,

    TBool& aOwnershipTransferForFrame,

    TBool& aOwnershipTransferForMask)

    {

	LOGTEXT2( 

		_L( "CActivePalettePluginBase::ProduceAniFrame, AniType ID: %d, frame no : %d" ), 

		aAniType,

		aFrameNo);

	CAnimationHelper* ani = static_cast<CAnimationHelper*>(iAnimationHelper);

	aOwnershipTransferForFrame = EFalse;

	aOwnershipTransferForMask  = EFalse;		

	*aFrame 		= ani->iFrame;

	*aFrameMask 	= ani->iFrameMask;

	// empty mask, transparent

	if (NULL != ani->iFrameMaskGc)

	    {		

		ani->iFrameMaskGc->Reset();

		ani->iFrameMaskGc->SetBrushColor(KRgbBlack);

		ani->iFrameMaskGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

		ani->iFrameMaskGc->Clear(); 

	    }

	// empty frame	

	ani->iFrameGc->Reset();

	ani->iFrameGc->SetBrushColor(KRgbWhite);

	ani->iFrameGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	ani->iFrameGc->Clear(); 

	// ani frame

	TInt phase = Min(KAnimPhaseMax, 

					 KAnimNofPhases * aFrameNo / aAniInfo.iNofFrames);

	TInt inPhaseMax = aAniInfo.iNofFrames / KAnimNofPhases;

	TInt inPhaseOfs = Min(inPhaseMax, aFrameNo - (phase * KAnimPhaseMax));

	TInt lenX = aAniInfo.iFrameSize.iWidth;

	TInt lenY = aAniInfo.iFrameSize.iHeight;

	TInt devX = lenX * KAnimDeviatinFactorMul / KAnimDeviatinFactorDiv;

	TInt devY = lenY * KAnimDeviatinFactorMul / KAnimDeviatinFactorDiv;

	TInt szx(0);

	TInt szy(0);

	TInt addX = devX * inPhaseOfs / inPhaseMax;

	TInt addY = devY * inPhaseOfs / inPhaseMax;

	switch (phase)

	    {

		case KAnimPhase1:

			szx = lenX - addX;

			szy = lenY - addY;

			break;

		case KAnimPhase2:

		default:

			szx = lenX - devX + addX;

			szy = lenY - devY + addY;

			break;

	    }

	TRect frameRect(TPoint( (lenX - szx) / 2, (lenY - szy) / 2),

					TSize(szx, szy));

	TRect iconRect(TPoint(0,0), aItemIcon.SizeInPixels());

	if (NULL != aItemIconMask && NULL != ani->iFrameMaskGc)

	    {

		ani->iFrameMaskGc->DrawBitmap(frameRect,aItemIconMask,iconRect);

	    }

	ani->iFrameGc->DrawBitmap(frameRect,&aItemIcon,iconRect);		

	if (aAniType)

	    {

	    // no compiler warning

	    }

    }

// End of File