ImagePrint/ImagePrintEngine/DeviceProtocols/xhtmlfilecomposer/inc/cxhtmlfilecomposer.h
/*
* 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