// 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()
	{}