// Copyright (c) 1998-2009 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:

//

#include <gdi.h>

#include <f32file.h>

#include <s32file.h>

#include <bautils.h>

#include <barsc.h>

#include <barsread.h>

#include "GDIPANIC.h"

_LIT(KPdrExtension,"*.PDR"); // must be capitalized

_LIT(KPdlExtension,".PDL"); // must be capitalized

_LIT(KUdlExtension,".UDL"); // must be capitalized

_LIT(KRscExtension,".RSC");

_LIT(KGdiPrintPanic,"GDI - PRINT");

_LIT(KGDIPanicDesc1, "GDI Pdr internal Panic %S, in file %S @ line %i");

_LIT(KGDIPanicDesc2, "Assert condition = \"%S\"");

enum TPdrStorePanic

	{

	EPdrModelIndexOutOfRange,

	EPdrModelUidNotFound,

	EPdrDirectoryIndexOutOfRange,

	EPdrFileIndexOutOfRange,

	EPdrPrinterDeviceExists,

	EPdrPrinterDeviceDoesNotExist,

	};

void Panic(TPdrStorePanic aPanic)

	{

	User::Panic(KGdiPrintPanic,aPanic);

	}

void PanicWithCondAndInfo(TPdrStorePanic aError, const TDesC& aCondition, const TDesC& aFileName, const TDesC& aPanicName, TInt aLine)

	{

	TBuf<256> buf;

	buf.Format(KGDIPanicDesc1, &aPanicName, &aFileName, aLine);

	RDebug::Print(buf);

	buf.Format(KGDIPanicDesc2, &aCondition);

	RDebug::Print(buf);

	Panic(aError);

	}

//

// TPrinterModelEntry

//

EXPORT_C void TPrinterModelEntry::InternalizeL(RReadStream& aStream)

/** Internalises a printer model entry from a read stream. 

The presence of this function means that the standard templated stream operator>>(), 

defined in s32strm.h, is available to internalise objects of this class.

@param aStream The read stream. */

    {

	aStream >> iModelName;

	iRequiresPrinterPort=aStream.ReadUint8L();

	aStream >> iUid;

	}

EXPORT_C void TPrinterModelEntry::ExternalizeL(RWriteStream& aStream) const

/** Externalises the printer model entry to a write stream.

The presence of this function means that the standard templated stream operator<<(), 

defined in s32strm.h, is available to externalise objects of this class.

@param aStream The write stream. */

	{

	aStream << iModelName;

	aStream.WriteUint8L((TUint8) iRequiresPrinterPort);

	aStream << iUid;

	}

//

// TPrinterModelHeader

//

EXPORT_C void TPrinterModelHeader::InternalizeL(RReadStream& aStream)

/** Internalises a printer model header from a read stream. 

The presence of this function means that the standard templated stream operator>>(), 

defined in s32strm.h, is available to internalise objects of this class.

@param aStream The read stream. */

 	{

	aStream >> iEntry;

	aStream >> iModelDataStreamId;

	}

EXPORT_C void TPrinterModelHeader::ExternalizeL(RWriteStream& aStream) const

/** Externalises the printer model header to a write stream.

The presence of this function means that the standard templated stream operator<<(), 

defined in s32strm.h, is available to externalise objects of this class.

@param aStream The write stream. */

    {

	aStream << iEntry;

	aStream << iModelDataStreamId;

	}

//

// CPrinterDevice

//

EXPORT_C CPrinterDevice::CPrinterDevice():

	CGraphicsDevice(),

	iCurrentPageSpecInTwips()

/** Standard constructor. */

	{}

EXPORT_C CPrinterDevice::~CPrinterDevice()

/** Destructor.

It frees all resources owned by the object, prior to its destruction. */

	{

	delete iControl;

	}

EXPORT_C void CPrinterDevice::SelectPageSpecInTwips(const TPageSpec& aPageSpecInTwips)

/** Sets the page specification in twips.

@param  aPageSpec The page specification in twips. */	

    {

	iCurrentPageSpecInTwips=aPageSpecInTwips;

	}

EXPORT_C TRect CPrinterDevice::PrintablePageInPixels() const

/** Gets the dimensions of the area to which the printer device can print.

These dimensions are normally less than those returned by TPageSpec::OrientedPageSize() 

because a margin exists between the boundary of the printable page and the 

absolute extent of the page.

@return The dimensions of the printer device area in pixels, respecting the 

page orientation */

	{

	return TRect(SizeInPixels());

	}

EXPORT_C void CPrinterDevice::DeleteControl()

 /** Deletes the printer control owned by this object.

The function sets the iControl member to NULL. */

    {

	delete iControl;

	iControl=NULL;

	}

EXPORT_C void CPrinterDevice::RestorePropertiesL()

/** Restores printer properties. */	

    {

	_LIT(KSystemIniFileNameSpec,"Z:\\System\\System.ini");

	RFs fs;

	User::LeaveIfError(fs.Connect());

	CleanupClosePushL(fs);

	TDriveUnit drive(static_cast<TUint>(RFs::GetSystemDrive()));

	TParse systemIniFileName;

	systemIniFileName.Set(drive.Name(), &KSystemIniFileNameSpec, NULL);

	TUint atts = 0;

	TInt ret = fs.Att(systemIniFileName.FullName(), atts);

	if (ret == KErrNone)

		{

		CDictionaryStore* dictionarystore = NULL;

		TRAPD(err,dictionarystore = CDictionaryFileStore::SystemL(fs));

		if (err == KErrNone)

			{

			CleanupStack::PushL(dictionarystore);

			if (dictionarystore->IsPresentL(Model().iUid))

				{

				RDictionaryReadStream stream;

				stream.OpenLC(*dictionarystore,Model().iUid);

				InternalizePropertiesL(stream);

				CleanupStack::PopAndDestroy(); // stream

				}

			CleanupStack::PopAndDestroy(); // dictionarystore

			}

		}

	CleanupStack::PopAndDestroy(); // fs

	}

EXPORT_C void CPrinterDevice::StorePropertiesL() const

/**  Stores the printer properties. */

    {

	RFs fs;

	User::LeaveIfError(fs.Connect());

	CleanupClosePushL(fs);

	CDictionaryStore* dictionarystore = CDictionaryFileStore::SystemLC(fs);

	RDictionaryWriteStream stream;

	stream.AssignLC(*dictionarystore,Model().iUid);

	ExternalizePropertiesL(stream);

	stream.CommitL();

	CleanupStack::PopAndDestroy(); // stream

	dictionarystore->CommitL();

	CleanupStack::PopAndDestroy(2); // dictionarystore, fs

	}

//

// CPrinterControl

//

EXPORT_C CPrinterControl::~CPrinterControl()

/**  Destructor.

It frees all resources owned by the object, prior to its destruction. */

 {

	delete iPrinterPort;

	}

EXPORT_C CPrinterControl::CPrinterControl(CPrinterPort* aPrinterPort):

	CBase(),

	iState(ENotPrinting),

	iPrinterPort(aPrinterPort)

	{}

//

// TPageSpec

//

EXPORT_C TPageSpec::TPageSpec():

	iPortraitPageSize(TSize(0,0)),

	iOrientation(EPortrait)

/** Default constructor. 

Initialises the page orientation to portrait and the page height and width 

to zero. */

	{}

EXPORT_C TPageSpec::TPageSpec(TPageOrientation anOrientation,const TSize& aSize):

	iPortraitPageSize(aSize),

	iOrientation(anOrientation)

/** Constructor with page orientation and size. 

@param aOrientation Specifies the page orientation. 

@param aSize Specifies the page size. */

 	{}

EXPORT_C void TPageSpec::InternalizeL(RReadStream& aStream)

/** Internalises a page specification object from a read stream. 

The presence of this function means that the standard templated stream operator>>(), 

defined in s32strm.h, is available to internalise objects of this class.

@param aStream The read stream. */

 	{

	iPortraitPageSize.iWidth = aStream.ReadInt32L();

	iPortraitPageSize.iHeight = aStream.ReadInt32L();

	iOrientation=(TPageSpec::TPageOrientation)aStream.ReadInt8L();

	}

EXPORT_C void TPageSpec::ExternalizeL(RWriteStream& aStream) const

/** Externalises the page specification object to a write stream.

The presence of this function means that the standard templated stream operator<<(), 

defined in s32strm.h, is available to externalise objects of this class.

@param aStream The write stream. */

 	{

	aStream.WriteInt32L(iPortraitPageSize.iWidth);

	aStream.WriteInt32L(iPortraitPageSize.iHeight);

	aStream.WriteInt8L(iOrientation);

	}

EXPORT_C TSize TPageSpec::OrientedPageSize()const

/** Gets the oriented page size.

The oriented page size is the absolute width and height of the page, respecting 

the page orientation.

@return The oriented page size (in pixels or twips). */

  	{

	if(iOrientation==EPortrait)

		return(iPortraitPageSize);

	return(TSize(iPortraitPageSize.iHeight,iPortraitPageSize.iWidth));

	}

EXPORT_C TBool TPageSpec::operator==(const TPageSpec& aPageSpec) const

/** Equality operator. 

This operator compares page specifications for equality. Two page specifications 

are equal if both their orientations and portrait page sizes are equal.

@param aPageSpec Page specification to be compared.

@return ETrue, if the page specifications are equal; EFalse, otherwise. */

   {

	return(iPortraitPageSize==aPageSpec.iPortraitPageSize &&

		iOrientation==aPageSpec.iOrientation);

	}

EXPORT_C TBool TPageSpec::operator!=(const TPageSpec& aPageSpec) const

/** Inequality operator.

This operator compares two page specifications for inequality. Two page specifications 

are unequal if one or both of their orientations and portrait page sizes differ.

@param aPageSpec Page specification to be compared.

@return ETrue, if the page specifications differ; EFalse, otherwise. */

	{

	return(!(*this==aPageSpec));

	}

// TMargins

EXPORT_C void TMargins::InternalizeL(RReadStream& aStream)

/** Internalises a set of margins from a read stream.

The presence of this function means that the standard templated stream operator>>() 

is available to internalise objects of this class.

@param aStream Stream from which the object is internalised. */

	{

	iLeft = aStream.ReadInt32L();

	iRight = aStream.ReadInt32L();

	iTop = aStream.ReadInt32L();

	iBottom = aStream.ReadInt32L();

	}

EXPORT_C void TMargins::ExternalizeL(RWriteStream& aStream) const

/** Externalises a set of margins to a write stream.

The presence of this function means that the standard templated stream operator<<() 

is available to externalise objects of this class.

@param aStream Stream to which the object is externalised. */

	{

	aStream.WriteInt32L(iLeft);

	aStream.WriteInt32L(iRight);

	aStream.WriteInt32L(iTop);

	aStream.WriteInt32L(iBottom);

	}

EXPORT_C TBool TMargins::operator==(const TMargins& aMargins) const

/** Tests margins for equality.

@param aMargins The margin to be compared with this margin. 

@return ETrue, if the margins are equal; EFalse, otherwise. */

	{

	return(iLeft==aMargins.iLeft && iRight==aMargins.iRight &&

		iTop==aMargins.iTop && iBottom==aMargins.iBottom);

	}

EXPORT_C TBool TMargins::operator!=(const TMargins& aMargins) const

/** Tests margins for inequality.

@param aMargins The margin to be compared with this margin. 

@return ETrue, if the margins are unequal; EFalse, otherwise. */

	{

	return(!(*this==aMargins));

	}

//

// CPrinterDriverUI

//

EXPORT_C CPrinterDriverUI::CPrinterDriverUI()

	{

	__DECLARE_NAME(_S("CPrinterDriverUI"));

	}

EXPORT_C TBool CPrinterDriverUI::BeforePrintL()

 /** Provides an opportunity for a dialog to be put up before printing begins.

@return ETrue, if printing is to continue; EFalse, if printing is to be cancelled. 

The default implementation returns ETrue. */

  	{

	return ETrue;

	}

EXPORT_C void CPrinterDriverUI::AfterPrintL()

 /** Provides an opportunity for a dialog to be put up after printing is complete.

The default implementation is empty. */

	{

	}

EXPORT_C void CPrinterDriverUI::SetPropertiesL()

/** Provides an opportunity for a dialog to be put up to capture or change printer 

properties.

The default implementation is empty. */

	{

	}

EXPORT_C TBool CPrinterDriverUI::CanSetProperties()

/** Tests whether printer properties can be set.

@return ETrue, if printer properties can be set; EFalse, otherwise. The default 

implementation returns EFalse. */

    {

	return EFalse;

	}

//

// CPrinterDriver

//

EXPORT_C CPrinterDriver* CPrinterDriver::NewL()

/** Constructs, and returns a pointer to a new instance for accessing a printer 

specification data store.

@return Pointer to the object for accessing a printer specification data store. */

	{

	CPrinterDriver* printerdriver=new(ELeave) CPrinterDriver;

	CleanupStack::PushL(printerdriver);

	User::LeaveIfError(printerdriver->iFs.Connect());

	CleanupStack::Pop();

	return printerdriver;

	}

EXPORT_C CPrinterDriver::~CPrinterDriver()

/** Destructor.

It frees all resources owned by the object, prior to its destruction. In particular, 

it closes the printer specification data store and any open session with the file server.  */	

    {

	Close();

	iFs.Close();

	}

EXPORT_C void CPrinterDriver::OpenPdrL(const TDesC &aName)

/**  Opens the specified printer specification data store.

@return  The name of the printer specification data store. This must be a 

valid printer specification data store,otherwise the function leaves with

KErrNotSupported. */	

    {

	Close();

	TRAPD(ret,DoOpenPdrL(aName));

	if (ret!=KErrNone)

		{

		Close();

		User::Leave(ret);

		}

	}

EXPORT_C void CPrinterDriver::Close()

/** Closes the printer specification data store and frees resources.

An open session with the file server remains open. */

	{

	delete iPdrStore,

	iPdrStore=NULL;

	iNumModels=0;

	delete[] iModelList;

	iModelList=NULL;

	DeletePrinterDevice();

	}

EXPORT_C TInt CPrinterDriver::NumModels() const

 /** Gets the number of printer models defined by the printer specification.

@return The number of printer models. */

 	{

	return iNumModels;

	}

EXPORT_C TPrinterModelEntry CPrinterDriver::Model(TInt aNum) const

/** Gets the specified printer model.

@param aNum An index into the list of printer models defined in the printer 

specification data.

@return Model specific information. */

 	{

	GDI_ASSERT_DEBUG(aNum>=0,EPdrModelIndexOutOfRange);

	GDI_ASSERT_DEBUG(aNum<iNumModels,EPdrModelIndexOutOfRange);

	return iModelList[aNum].iEntry;

	}

EXPORT_C CPrinterDevice* CPrinterDriver::CreatePrinterDeviceL(TUid aModelUid)

/** Creates the physical graphics device to be used for printing.

@param aModelUid The UID of a specific model which is defined in the printer 

specification data.

@return The physical graphics device to be used for printing.  */	

    {

	GDI_ASSERT_DEBUG(!iPrinterDevice,EPdrPrinterDeviceExists);

	TRAPD(ret,DoCreatePrinterDeviceL(aModelUid));

	if (ret!=KErrNone)

		{

		DeletePrinterDevice();

		User::Leave(ret);

		}

	return iPrinterDevice;

	}

void CPrinterDriver::LoadLibraryL(RLibrary& aLibrary,const TDesC& aExt,TUid aUid2)

	{

	TFileName filename=iPdlName;

	filename.Append(aExt);

	User::LeaveIfError(aLibrary.Load(filename));

	TUidType type=aLibrary.Type();

	if (type[1]!=aUid2 && type[2]!=iPdlUid)

		{

		aLibrary.Close();

		User::Leave(KErrNotSupported);

		}

	if (type[1]!=aUid2)

		{

		aLibrary.Close();

		User::Leave(KErrNotFound);

		}

	}

EXPORT_C CPrinterDriverUI* CPrinterDriver::CreatePrinterDriverUIL()

/** Constructs a printer specific user interface.

The user interface object is optional, but if it exists, it is implemented 

as part of a UDL (i.e. a UI DLL).

@return A pointer to the printer specific user interface, or NULL if there is 

none. */

    {

	GDI_ASSERT_DEBUG(iPrinterDevice,EPdrPrinterDeviceDoesNotExist);

	if (iUdlLibrary.Handle()==0)

		{

		TRAPD(ret,LoadLibraryL(iUdlLibrary,KUdlExtension,TUid::Uid(KUdlUidVal)));

		if (ret==KErrNotFound)

			return NULL;

		else

			User::LeaveIfError(ret);

		}

	TLibraryFunction f = iUdlLibrary.Lookup(1);

	CPrinterDriverUI* printerdriverui=(CPrinterDriverUI*)((*f)());

	CleanupStack::PushL(printerdriverui);

	User::LeaveIfError(printerdriverui->SetPrinterDevice(iPrinterDevice));

	CleanupStack::Pop();

	return printerdriverui;

	}

CPrinterDriver::CPrinterDriver()

	{}

void CPrinterDriver::DeletePrinterDevice()

	{

	iUdlLibrary.Close();

	delete iPrinterDevice;

	iPrinterDevice=NULL;

	iPdlLibrary.Close();

	}

void CPrinterDriver::DoOpenPdrL(const TDesC &aName)

	{

	Close();

	iPdrStore=CDirectFileStore::OpenL(iFs,aName,EFileStream|EFileRead|EFileShareReadersOnly);

	if (iPdrStore->Type()[1]!=TUid::Uid(KPdrStoreFileUidVal))

		User::Leave(KErrNotSupported);

	TStreamId headerid = iPdrStore->Root();

	RStoreReadStream stream;

	stream.OpenLC(*iPdrStore,headerid);

		stream >> iPdlName;

	stream >> iPdlUid;

	iNumModels = stream.ReadInt32L();

	iModelList = new(ELeave) TPrinterModelHeader[iNumModels];

	for (TInt i=0; i<iNumModels; i++)

		iModelList[i].InternalizeL(stream);

	CleanupStack::PopAndDestroy();

	}

void CPrinterDriver::DoCreatePrinterDeviceL(TUid aModelUid)

	{

	if (!iPdlName.Length())

		User::Leave(KErrGeneral); // !! find a better error number

	LoadLibraryL(iPdlLibrary,KPdlExtension,TUid::Uid(KPdlUidVal));

	TLibraryFunction f = iPdlLibrary.Lookup(1);

	iPrinterDevice=(CPrinterDevice*)((*f)());

	TInt i;

	for (i=0; (i<iNumModels) && (aModelUid!=iModelList[i].iEntry.iUid); i++)

		{

		}

	GDI_ASSERT_DEBUG(i<iNumModels,EPdrModelUidNotFound);

	User::LeaveIfError(iPrinterDevice->SetModel(iModelList[i],*iPdrStore));

	iPrinterDevice->RestorePropertiesL();

	}

//

// CPdrModelList

//

EXPORT_C CPdrModelList* CPdrModelList::NewL()

/** Constructs, and returns a pointer to a new instance of the printer model 

list interface.

@return Pointer to the new printer model list interface object. */

    {

	CPdrModelList* modellist=new(ELeave) CPdrModelList();

	CleanupStack::PushL(modellist);

	modellist->ConstructL();

	CleanupStack::Pop();

	return modellist;

	}

EXPORT_C CPdrModelList::~CPdrModelList()

/** Virtual destructor.

Frees resources owned by the object, prior to its destruction. */

	{

	delete iModelArray;

	delete iFileArray;

	if (iDirectoryArray)

		{// delete all the HBufC's

		for (TInt i=iDirectoryArray->Count()-1 ; i>=0 ; i--)

			delete (*iDirectoryArray)[i];

		delete iDirectoryArray;

		}

	iFileServer.Close();

	}

EXPORT_C TInt CPdrModelList::ModelCount() const

/** Gets the number of printer models in the printer model list.

@return The number of printer models. */

    {

	return iModelArray->Count();

	}

EXPORT_C const TPrinterModelEntry CPdrModelList::operator [] (TInt anIndex)

/** Gets printer model name.

This is the name of the printer model at the specified index within the list 

of printer models.

@param anIndex The index of the printer model within the array of printer 

models. Note that this number must be between zero and ModelCount(). 

@return Name of printer model, up to 32 characters long */

 	{

	GDI_ASSERT_DEBUG(anIndex>=0,EPdrModelIndexOutOfRange);

	GDI_ASSERT_DEBUG(anIndex<iModelArray->Count(),EPdrModelIndexOutOfRange);

	return (*iModelArray)[anIndex].iEntry;

	}

EXPORT_C TInt CPdrModelList::UidToNum(TUid aModelUid) const

/** Gets a printer model's index within the model list from its UID.

@param aModelUid The UID of the printer model.

@return The index of the printer model within the array of printer models if 

found; KErrNotFound, otherwise. */

    {

	TInt i,count=iModelArray->Count();

	for (i=0; (i<count) && (aModelUid!=(*iModelArray)[i].iEntry.iUid); i++)

		{

		}

	if (i==count)

		i=KErrNotFound;

	return i;

	}

EXPORT_C void CPdrModelList::AddDirectoryL(const TDesC& aDir)

/** Adds a directory to the list of directories to be scanned for printer models.

@param aDir The directory to be added to the list. */

	{

	HBufC* buf = HBufC::NewL(aDir.Length());

	CleanupStack::PushL(buf);

	*buf = aDir;

	iDirectoryArray->AppendL(buf);

	CleanupStack::Pop(); //buf

	}

LOCAL_C void DereferenceAndDeleteHBufC8(TAny* aPointerToPointerToHBufC8)

	{

	delete *STATIC_CAST(HBufC8**, aPointerToPointerToHBufC8);

	}

EXPORT_C CPrinterModelList* CPdrModelList::ScanForModelsL()

/** Scans through through the list of directories for all .pdr files and generates 

a list of printer models.

@return The list of model names. */

	{

	iModelArray->Reset();

	iFileArray->Reset();

	// check that there is at least one directory to parse?

	// get a list of *.pdr files in all directories specified (using AddDirectory())

	for (TInt index=iDirectoryArray->Count()-1 ; index>=0 ; index--)

		ScanDirectoryL(index);

 	// then go through the files one at a time, adding all models to the list

	TParse* parser = new(ELeave) TParse;

	CleanupStack::PushL(parser);

	TFileName* nameOfLoadedResourceFile=new(ELeave) TFileName;

	CleanupStack::PushL(nameOfLoadedResourceFile);

	TFileName* tempFileName=new(ELeave) TFileName;

	CleanupStack::PushL(tempFileName);

	RResourceFile resourceFile;

	CleanupClosePushL(resourceFile);

	HBufC8* resource=NULL;

	CleanupStack::PushL(TCleanupItem(DereferenceAndDeleteHBufC8, &resource));

	for (TInt fileNum=iFileArray->Count()-1 ; fileNum>=0 ; fileNum--)

		ListModelsL(fileNum, *parser, *nameOfLoadedResourceFile, *tempFileName, resourceFile, resource);

	CleanupStack::PopAndDestroy(5); // resource, resourceFile, tempFileName, nameOfLoadedResourceFile and parser

	// return a handle to the array of model names

	return this;

	}

EXPORT_C CPrinterDriver* CPdrModelList::CreatePrinterDriverL(TInt anIndex)

/** Creates an object for accessing the specified store that contains printer specification 

data.

@param anIndex An index into a list of files containing printer specification 

data. The files are the complete set of .pdr files found in the directories 

known to this object.

@return A pointer to the object representing the store containing the printer 

specification data. */

 	{

	GDI_ASSERT_DEBUG(anIndex>=0,EPdrModelIndexOutOfRange);

	GDI_ASSERT_DEBUG(anIndex<iModelArray->Count(),EPdrModelIndexOutOfRange);

	CPrinterDriver* driver = CPrinterDriver::NewL();

	CleanupStack::PushL(driver);

	HBufC* file = NewPathBufL(*((*iModelArray)[anIndex].iFile));

	CleanupStack::PushL(file);

	driver->OpenPdrL(*file);

	driver->CreatePrinterDeviceL((*iModelArray)[anIndex].iEntry.iUid);

	CleanupStack::PopAndDestroy();

	CleanupStack::Pop();

	return driver;

	}

 CPdrModelList::CPdrModelList():

	iModelArray(NULL),

	iFileArray(NULL),

	iDirectoryArray(NULL)

	{

	}

 void CPdrModelList::ConstructL()

	{

	__DECLARE_NAME(_S("CPdrModelList"));

	iModelArray = new(ELeave) CArrayFixSeg<TModelEntry>(5);

	iFileArray = new(ELeave) CArrayFixFlat<TFileEntry>(5);

	iDirectoryArray = new(ELeave) CArrayFixFlat<HBufC*>(1);

	User::LeaveIfError(iFileServer.Connect());

	}

void CPdrModelList::ScanDirectoryL(TInt aDirIndex)

/** Scans the given directory, parsing all files found

 If a file is of the correct type it is appended to the file list*/

	{

	GDI_ASSERT_DEBUG(aDirIndex>=0,EPdrDirectoryIndexOutOfRange);

	GDI_ASSERT_DEBUG(aDirIndex<iDirectoryArray->Count(),EPdrDirectoryIndexOutOfRange);

	TDesC* dir = (*iDirectoryArray)[aDirIndex];

	TParse path;

	path.Set(KPdrExtension,dir,NULL);

	CDir* fileList;

	TInt ret = iFileServer.GetDir(path.FullName(),KEntryAttNormal,ESortByName,fileList);

	if (ret == KErrNone)

		{

		CleanupStack::PushL(fileList);

		for (TInt i=fileList->Count()-1 ; i>=0 ; i--) 

			{

			TFileEntry& entry = iFileArray->ExtendL();

			entry.iFileName = (*fileList)[i].iName;

			entry.iDirectory = dir;

			}

		CleanupStack::PopAndDestroy(); // fileList

		}

	else if (ret == KErrNoMemory) // Ignore errors other than KErrNoMemory

		User::LeaveNoMemory();

	}

void CPdrModelList::ListModelsL(TInt aFileIndex, TParse& aParser, TFileName& aNameOfLoadedResourceFile, TFileName& aTempFileName, RResourceFile& aResourceFile, HBufC8*& aResource)

/** given a pdr file list all the models it contains in the model array */

	{

	GDI_ASSERT_DEBUG(aFileIndex>=0,EPdrFileIndexOutOfRange);

	GDI_ASSERT_DEBUG(aFileIndex<iFileArray->Count(),EPdrFileIndexOutOfRange);

	CPrinterDriver* driver = CPrinterDriver::NewL() ;

	CleanupStack::PushL(driver);

	// open the file

	HBufC* fullPath = NewPathBufL((*iFileArray)[aFileIndex]);

	TRAPD(ret,driver->OpenPdrL(*fullPath));

	delete fullPath;

	if ((ret!=KErrNone) && (ret!=KErrNotSupported))

		User::Leave(ret);

	// get info on the models one by one and insert them into the array

	if (ret==KErrNone)

		{

		TModelEntry modelentry;

		modelentry.iFile = &(*iFileArray)[aFileIndex]; // set the file pointer for the entry

		const TInt numberOfModels = driver->NumModels();

		for (TInt i=0 ; i<numberOfModels ; i++)

			{

			modelentry.iEntry=driver->Model(i);

			if (UidToNum(modelentry.iEntry.iUid)==KErrNotFound)

				{

				User::LeaveIfError(aParser.SetNoWild(KRscExtension, &modelentry.iFile->iFileName, modelentry.iFile->iDirectory));

				aTempFileName=aParser.FullName();

				BaflUtils::NearestLanguageFile(iFileServer, aTempFileName);

				if (aNameOfLoadedResourceFile.CompareF(aTempFileName)!=0)

					{

					if (!BaflUtils::FileExists(iFileServer, aTempFileName))

						{

						iModelArray->AppendL(modelentry); // no resource file found, so reverting to old behaviour (i.e. where the model-name is set from the PDR file)

						continue;

						}

					aNameOfLoadedResourceFile=KNullDesC;

					aResourceFile.OpenL(iFileServer, aTempFileName);

					HBufC8* resource=aResourceFile.AllocReadL(aResourceFile.Offset()+2); // read the first resource after the RSS_SIGNATURE resource

					delete aResource;

					aResource=resource;

					aNameOfLoadedResourceFile=aTempFileName;

					}

				TResourceReader resourceReader;

				resourceReader.SetBuffer(aResource);

				for (TInt j=resourceReader.ReadUint16()-1; ; --j)

					{

					if (j<0)

						{

						iModelArray->AppendL(modelentry); // no matching uid found in the resource file, so reverting to old behaviour (i.e. where the model-name is set from the PDR file)

						break;

						}

					TInt uid=resourceReader.ReadInt32();

					TPtrC name=resourceReader.ReadTPtrC();

					if (uid==modelentry.iEntry.iUid.iUid)

						{

						if (name.Length()>0)

							{

							modelentry.iEntry.iModelName=name;

							iModelArray->AppendL(modelentry);

							}

						break;

						}

					}

				}

			}

		}

	CleanupStack::PopAndDestroy(); // driver

	}

HBufC* CPdrModelList::NewPathBufL(const TFileEntry& aFileEntry)  

/** Create a buf of the right length and... 

 set its contents to the full filename of model aModel */

	{

	// Create a buf of the right length

	HBufC* buf = HBufC::NewL(aFileEntry.iFileName.Length()+aFileEntry.iDirectory->Length());

	// Insert the file path

	TPtr filePtr = buf->Des();

	filePtr.Append(*aFileEntry.iDirectory);

	filePtr.Append(aFileEntry.iFileName);

	return buf;

	}

// !!!!

// Retained for binary compatibility only: remove if we make a binary incompatible release

//

IMPORT_C void GDI_Reserved();

EXPORT_C void GDI_Reserved()

	{}