// 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;

	}