imagefactory.cpp

一个symbian上成熟的小游戏源码

/*
============================================================================
 Name        : ImageFactory.cpp
 Author      : 
 Version     :
 Copyright   : Your copyright notice
 Description : CImageFactory implementation
============================================================================
*/

#include "ImageFactory.h"
#include <eikenv.h> // For CEikEnv
#include <f32file.h> // For RFs
namespace gamespace
{

CImageFactory::CImageFactory(MImageFactoryObserver* aObserver) 
: CActive(EPriorityStandard)	// Standard priority
{
	iIndexToConvert=-1;
	iObserver=aObserver;
}

void CImageFactory::ConstructL()
{
	CActiveScheduler::Add(this);				// Add to scheduler
}

CImageFactory::~CImageFactory()
{
	Cancel(); // Cancel any request, if outstanding
	// Delete instance variables if any
	Reset();
}

void CImageFactory::DoCancel()
{
	if (iDecoder)
	{
		iDecoder->Cancel();
	}
}

void CImageFactory::RunL()
{
	TInt count=iArray.Count();

	if (iStatus==KErrNone)
	{
		if (iIndexToConvert>=count-1)
		{
			//DeleteFilePathName();
			iObserver->ConvertCompleted(count,count);
			return;
		}

		ConvertL(++iIndexToConvert);
	}
	else
	{
		iObserver->ConvertFail(iIndexToConvert+1,count,*(iArray[iIndexToConvert].iFilePathName));
	}
}

CImageFactory& CImageFactory::AddImageL( const TDesC& aFilaName,TImageID id )
{
	HBufC* pFile=aFilaName.AllocLC();

	IMAGESTRUCT image;
	image.iImageId=id;
	image.iFilePathName=pFile;
	image.iBmp=NULL;
	image.iBmpMask=NULL;

	iArray.AppendL(image);
	CleanupStack::Pop();

	return *this;
}

const CFbsBitmap* CImageFactory::Image( TImageID id ) const
{
	TInt pos=FindImageId(id);
	if (pos>=0)
	{
		return iArray[pos].iBmp;
	}

	return NULL;
}

TBool CImageFactory::Image( TImageID id,CFbsBitmap*& aImage,
							  CFbsBitmap*& aImageMask ) const
{
	TInt pos=FindImageId(id);
	if (pos>=0)
	{
		aImage=iArray[pos].iBmp;
		aImageMask=iArray[pos].iBmpMask;
		return ETrue;
	}

	return EFalse;
}
TInt CImageFactory::FindImageId( TImageID id ) const
{
	IMAGESTRUCT image;
	image.iImageId=id;

	TIdentityRelation <IMAGESTRUCT> relation(FindImageById);
	TInt findPos=iArray.Find(image,relation);
	if (findPos==KErrNotFound)
	{
		return -1;
	}
	else
	{
		return findPos;
	}
}

void CImageFactory::StartConvertL()
{
	TInt count=iArray.Count();
	if (count==0)
	{
		return;
	}

	iIndexToConvert=0;
	ConvertL(iIndexToConvert);
}

void CImageFactory::ConvertL( TInt aIndex )
{
	Cancel();
	RFs& rFs=CEikonEnv::Static()->FsSession();

	IMAGESTRUCT& image=iArray[aIndex];

	//用文件构造CImageDecoder
	delete iDecoder;
	iDecoder=CImageDecoder::FileNewL(rFs,*image.iFilePathName);
	//Creates a bitmap with the specified size and display mode.
	delete image.iBmp;
	delete image.iBmpMask;
	image.iBmp=new(ELeave)CFbsBitmap;
	image.iBmpMask=new(ELeave)CFbsBitmap;

	image.iBmp->Create(iDecoder->FrameInfo().iOverallSizeInPixels,
		//iDecoder->FrameInfo().iFrameDisplayMode);
		CEikonEnv::Static()->DefaultDisplayMode());
	//EColor16MU);
	image.iBmpMask->Create(iDecoder->FrameInfo().iOverallSizeInPixels,
		EGray256);
	iDecoder->Convert(&iStatus,*(image.iBmp),*(image.iBmpMask));
	SetActive();
}

void CImageFactory::Reset()
{
	TInt count=iArray.Count();

	for (TInt i=0;i<count;i++)
	{
		DestroyImage(iArray[i]);
	}
	iArray.Reset();

	delete iDecoder;
	iDecoder=NULL;
}

TBool CImageFactory::FindImageById( const IMAGESTRUCT& aImage1,
								   const IMAGESTRUCT& aImage2 )
{
	if (aImage1.iImageId==aImage2.iImageId)
	{
		return ETrue;
	}

	return EFalse;
}

const CFbsBitmap* CImageFactory::ImageMask( TImageID id ) const
{
	TInt pos=FindImageId(id);
	if (pos>=0)
	{
		return iArray[pos].iBmpMask;
	}

	return NULL;
}

CImageFactory* CImageFactory::NewL( MImageFactoryObserver* aObserver )
{
	CImageFactory* self=new(ELeave)CImageFactory(aObserver);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop();
	return self;
}

TBool CImageFactory::DeleteImage( TImageID aId )
{
	TInt pos=FindImageId(aId);
	if (pos>=0)
	{
		DestroyImage(iArray[pos]);
		iArray.Remove(pos);
		return ETrue;
	}

	return EFalse;
}

void CImageFactory::DestroyImage( IMAGESTRUCT& image )
{
	delete image.iBmp;
	image.iBmp=NULL;
	delete image.iBmpMask;
	image.iBmpMask=NULL;
	delete image.iFilePathName;
	image.iFilePathName=NULL;
}

void MImageFactoryObserver::ConvertFail(TInt aCurrentIndex,TInt aAllNum,const TDesC& aDes)
{

}

}