/*

* Copyright (c) 2002-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:  Defines the CXhtmlFileComposer class.

*

*/

#ifndef CXHTMLFILECOMPOSER_H

#define CXHTMLFILECOMPOSER_H

#include <e32base.h>

#include <f32file.h>

#include <e32math.h>

#include "xfctemplates.h"

#include "xhtmlfilecomposerconst.h"

#include "cimageinfo.h"

/**

* @class 		CXhtmlFileComposer

* @brief	Implements the printing job compose to a XHTML file.

*/

/**

* @example ExampleOfCreateXhtmlFile.cpp

* This example

*	@li creates a list of images to be included in XHTML-file as CImageInfo classes

*	@li creates a new instance of this class

*	@li calls the CreateXhtmlFileL method to create the physical file

*/

class CXhtmlFileComposer : public CBase

	{

		public:

			/**

			* @enum 	TMeasureUnit

			*

			* The measure type is used in XHTML file for describing the unit for dimensions like

			* page, frame and image sizes, frame positions at the page etc.

			* Depending of the paper size type the two units of the measure is used: inches and millimeters.

			*/

			enum TMeasureUnit

			{

				EUAInches, 		///<@brief Inch unit identifier.

				EUAMillis  		///<@brief Millimeter unit identifier.

			};

		public:

			/**  		NewL

			* @brief	Creates a new instance of XHTML file composer.

			* @param	aPath	The path the XHTML file will be located.\n

			*					If @a aPath is empty, the @ref KXFPDefaultResultPath is used to open the file

			*					server session and to create path. Otherway the file name given in method

			*					@ref CreateXhtmlFileL can be the name of the file without path.

			* @return	Pointer to the instance.

			*/

			IMPORT_C static CXhtmlFileComposer* NewL(const TDesC& aPath);

			/**  		NewLC

			* @brief	Creates a new instance of XHTML file composer and leaves it in the cleanup stack.

			* @param	aPath	The path the XHTML file will be located.\n

			*					If @a aPath is empty, the @ref KXFPDefaultResultPath is used to open the file

			*					server session and to create path. Otherway the file name given in method

			*					@ref CreateXhtmlFileL can be the name of the file without path.

			* @return	Pointer to the instance.

			*/

			IMPORT_C static CXhtmlFileComposer* NewLC(const TDesC& aPath);

			/**  		~CXhtmlFileComposer

			* @brief	Destructor.

			*/

			IMPORT_C ~CXhtmlFileComposer();

			/**			CreateXhtmlFileL

			* @brief	Writes the XHTML-Print document of the job according to the given parameters.

			* @param	aImages 	Array of the images to write in file

			* @param	aLayout 	Jobs' <em>Number up</em> setting

			* @param	aPaperSize 	Jobs' <em>Media size</em> setting

			* @param	aQuality	Jobs' <em>Quality</em> setting <b>not implemented</b>

			* @param	aXhtmlPrintFile The name of the file to generate. The file name can be given

			*						without the path, when the file is located in the @a aPath given when the

			*						instance of this class is created. The @a aXhtmlPrintFile can be also given

			*						with the path, but then the path must already exist.

			* @param	aPageCount	Returns the number of pages to print

			*/

			IMPORT_C void CreateXhtmlFileL(const RArray<CImageInfo>& aImages, const TInt aLayout,

								  const TInt aPaperSize, const TInt aQuality,

								  const TDesC& aXhtmlPrintFile, TInt& aPageCount, TBool aDataFile = EFalse);

		protected:

			/**  		ConstructL

			* @brief	Symbian second phase constructor.

			* @param	aPath	The path the XHTML file will be located.\n

			*					If @a aPath is empty, the @ref KXFPDefaultResultPath is used to open the file

			*					server session and the path is created. This ensures the argument @a aXhtmlPrintFile

			*					of the method @ref CreateXhtmlFileL can be given without path.

			*/

			void ConstructL(const TDesC& aPath);

		private:

			/**  		CXhtmlFileComposer

			* @brief	C++ constructor

			*/

			CXhtmlFileComposer();

			/**  		UnitToPixel

			* @brief	Converts current unit to pixels.

			* @param	aValue Inch/millimeter value

			* @return	Pixel value

			*/

			IMPORT_C TReal UnitToPixel(TReal aValue);

			/**  		UnitToPixel

			* @brief	Converts current unit to pixels.

			* @param	aValue Inch/millimeter value

			* @return	Pixel value

			*/

			IMPORT_C TSizeReal UnitToPixel(TSizeReal aValue);

			/**  		PixelToUnit

			* @brief	Converts pixels to current unit.

			* @param	aValue pixel value

			* @return	Inch/millimeter value

			*/

			IMPORT_C TReal PixelToUnit(TReal aValue);

			/**  		PixelToUnit

			* @brief	Converts pixels to current unit.

			* @param	aValue pixel value

			* @return	Inch/millimeter value

			*/

			IMPORT_C TSizeReal PixelToUnit(TSizeReal aValue);

			/**   		ReadTemplateL

			* @brief	Reads the template file in iFileBuf

			*/

			void ReadTemplateFileL();

			/**   		GetRatioL

			* @brief	Counts the croping and scaling of the image

			* @param	aNewSize 	Cropped and scaled size for the image

			* @param	aImageSize 	Full string to define the margin in XHTML file

			*/

			void GetRatioL(TSizeReal &aNewSize, TSizeReal aImageSize);

			/**   		ComposeUnitL

			* @brief	Converts the template to current unit (millimeters or inches) in member buffer.

			*/

			void ComposeUnitL();

			/**   		ComposeTemplateL

			* @brief	Replaces the template with string value in member buffer

			* @param	aStr	String to convert for

			* @param	aTemplate	Template to convert

			*/

			void ComposeTemplateL(const TDesC8 &aStr, const TDesC8 &aTemplate);

			/**   		ComposeTemplateL

			* @brief	Replaces the template with number value in member buffer

			* @param	aValue Number to convert for

			* @param	aTemplate Template to convert

			*/

			void ComposeTemplateL(const TInt aValue, const TDesC8 &aTemplate);

			/**   		ComposeFileL

			* @brief	Composes the data in the template in member buffer

			* @param	aImageName Image name and path

			* @param	aImgSize Image size

			*/

			void ComposeFileL(const TDes8 &aImageName, TSizeReal aImgSize, TBool aDataFile = EFalse);

			/**   		PageData

			* @brief	Collects the paper size related data to page arguments

			* @param	aPaperSize Media size

			*/

			void PageData(TInt aPaperSize);

			/**   		LayoutData

			* @brief	Collects the layout related data to image frame arguments

			* @param	aLayout Layout

			* @param	aPositions Array of the image positions on the page

			*/

			void LayoutData(TInt aLayout, RArray<TSizeReal> &aPositions);

			/**   		FinalizeBufferL

			* @brief	Trims the member buffer tail. Replacing the template strings from

			*			the buffer makes the data length in the buffer vary and generates

			*			rubbish in the end of buffer.

			* @return	Pointer to the buffer data.

			*/

			TPtrC8 FinalizeBufferL();

			/**   		SetPageTypeL

			* @brief	Creates a new XHTML div for page. Last/only one must be always @c page_last.

			*/

			void SetPageTypeL();

			/**   		GetTemplateStringL

			* @brief	Reads the requested element's template for the XHTML file.

			* @param	aStart Start marker tag for the element

			* @param	aEnd End marker tag for the element

			* @param	aTemplate Reference to the template element read

			* @return	Pointer to the template element read

			*/

			TPtrC8 GetTemplateStringL(const TDesC8& aStart, const TDesC8& aEnd, TDes8& aTemplate);

			/**   		AddTemplateStringL

			* @brief	Adds the template element in XHTML buffer

			* @param	const TDesC8& The template element to add

			* @param	const TDesC8& A marker tag to where to add the element

			*/

			void AddTemplateStringL(const TDesC8& aTemplate,const TDesC8& aTag);

			/**   		GetImageSize

			* @brief	Returns the size in pixels of the image file

			* @param	CImageInfo Image's info

			* @return	Image size

			*/

			TSizeReal GetImageSizeL(CImageInfo aImage);

			/**   		AddPageL

			* @brief	Adds the new page element in XHTML template if last one is full

			* @param	aCurrentImage Index of the current image

			* @param	aPositionIndex Reference to the index of the image position at page

			* @param	aPageCount Reference to the page counter

			* @return	True if page added, False if not.

			*/

			TBool AddPageL(TInt aCurrentImage, TInt& aPositionIndex, TInt& aPageCount);

			/**   		CreateMatrix

			* @brief	Creates a list of positions at page for the grid of images.

			* @param	aRows Number of rows at one page

			* @param	aColumns Number of columns at one page

			* @param	aPortrait Orientation of the paper vs. images

			* @param	aPositions Reference to the array of the positions

			*/

			void CreateMatrix(TInt aRows, TInt aColumns, RArray<TSizeReal>& aPositions);

			/**   		GetImageNameL

			* @brief	Returns the name of the image for IMG tag.

			* @param	aImageInfo 	Image details

			* @param	aImageName	Reference to the image name

			*/

			void GetImageNameL(CImageInfo aImageInfo, TDes8 &aImageName, TBool aDataFile = EFalse);

			/**   		SizeAndOrientationL

			* @brief	Returns the size and orientation of the image.

			* @param	aImageInfo	Image details

			* @param	aImageSize	Reference to the image size

			* @param	aFramePortrait Returns True if image is portrait, otherway False

			*/

			void SizeAndOrientationL(const CImageInfo aImageInfo, TSizeReal& aImageSize, TBool& aFramePortrait);

			/**   		ComposePositionL

			* @brief	Composes the position string identifier values in XHTML file.

			* @param	aPositionIndex index of the position to compose

			* @param	aPositions The array of the positions

			*/

			void ComposePositionL(TInt aPositionIndex, RArray<TSizeReal>& aPositions);

			/**   		FormatReal

			* @brief	Composes the position string identifier values in XHTML file.

			* @param	aNumber float number to convert

			* @param	aString Converted string type of "%f<<units>>"

			*/

			void FormatReal(TRealX aNumber, TDes8& aString);

		private:

			/** @var TSizeReal iPaperSize

			 *  Paper size to print */

			TSizeReal iPaperSize;

			/** @var TInt iPaperType

			 *  Measurement unit (millimeters or inches) in XHTML file */

			TInt iPaperType;

			/** @var TReal iPageMargin

			 *  Marginals at the page */

			TReal iPageMargin;

			/** @var TSizeReal iImageFrame

			 *  Frame to contain an image */

			TSizeReal iImageFrame;

			/** @var HBufC8* iFileBuf

			 *  Buffer to read the template file */

			HBufC8* iFileBuf;

			/** @var RFs iFsSession

			 *  File server session */

			RFs iFsSession;

			/** @var TInt iImagesPerPage

			 * Number of the images at one page */

			TInt iImagesPerPage;

			/** @var TBool iImagePortrait

			 * The orientation of the image. TRUE if portrait, FALSE if landscape */

			TBool iImagePortrait;

			/** @var TBool iPagePortrait

			 * The orientation of the page. TRUE if portrait, FALSE if landscape */

			TBool iPagePortrait;

			/** @var TBlock iPageTemplate

			 * Page element template of the XHTML file */

			TBlock iPageTemplate;

			/** @var TBlock iFrameTemplate

			 *  Frame element template of the XHTML file */

			TBlock iFrameTemplate;

			/** @var TBlock iPositionTemplate

			 *  Image position element template of the XHTML file */

			TBlock iPositionTemplate;

			/** @var TBlock iImageTemplate

			 *  Image element template of the XHTML file */

			TBlock iImageTemplate;

	};

#endif // CXHTMLFILECOMPOSER_H

//  End of File