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

// The data members of the class CGridLay are as follows:-

// iGridRange - the range of cells that define the grid boundary.

// iVisibleRange - the range of cells within the grid that are visible

// in the active window. iVisibleRange.iFrom is the cell reference

// of the top left cell in the window with respect to iGridRange

// (i.e not necessarily (1, 1)). iVisibleRange.iTo is the cell that is

// partially visible at the bottom right of the window.

// *iGridTable, *iGridImg - allows access to the data in these classes.

// *iColumnWidthMap,*iRowHeightMap - pointers to an array of column/row heights/widths

// 

//

#include <s32strm.h>

#include "GRDSTD.H"

#include "GRDMAP.H"

#include "GRDPANIC.H"

#define KRgbGridForeground			TRgb(0,0,0)			// Black

#define KRgbGridBackground			TRgb(255,255,255)	// White

#define KRgbGridLines				TRgb(170,170,170)	// Light Gray

#define KRgbGridLabelSeparators		TRgb(0,0,0)

RWriteStream& operator<<(RWriteStream& aStream,const TInt& aInt)

	{

	aStream.WriteInt32L(aInt);

	return aStream;

	}

RReadStream& operator>>(RReadStream &aStream,TInt& aInt)

	{

	aInt = aStream.ReadInt32L();

	return aStream;

	}

//

// TGridColors class

//

EXPORT_C TGridColors::TGridColors() :

	iForeground(KRgbGridForeground),

	iBackground(KRgbGridBackground),

	iLines(KRgbGridLines),

	iLabelSeparators(KRgbGridLabelSeparators)

/** Default constructor.

Sets the colours to their default values: foreground colour to the RGB value 

TRgb(0,0,0), background colour to the RGB value TRgb(255,255,255), the colour 

of lines to the RGB value TRgb(170,170,170), and the colour of label separators 

to the RGB value TRgb(0,0,0). */

	{

	}

EXPORT_C TGridColors::TGridColors(TRgb aForeground, TRgb aBackground, TRgb aLines, TRgb aLabelSeparators) :

	iForeground(aForeground),

	iBackground(aBackground),

	iLines(aLines),

	iLabelSeparators(aLabelSeparators)

/** Constructor setting the colour values.

@param aForeground The foreground colour value.

@param aBackground The background colour value.

@param aLines The colour of lines.

@param aLabelSeparators The colour of label separators. */

	{

	}

// CGridLay stuff

EXPORT_C CGridLay::CGridLay(MGraphicsDeviceMap* aGraphicsDeviceMap)

	: iGraphicsDeviceMap(aGraphicsDeviceMap)

/** Constructor taking an object that implements mapping between twips and device-specific 

units.

@param aGraphicsDeviceMap An object that implements the interface for mapping 

between twips and device-specific units. Typically, this is a TZoomFactor 

object. */

	{

	}

LOCAL_C void CopyIntArrayL(const CArrayFix<TInt>* aSource,CArrayFix<TInt>*& aDest)

	{

	TInt count=aSource->Count();

	aDest = new(ELeave) CArrayFixFlat<TInt>(Max(count,1));

	for (TInt ii=0;ii<count;ii++)

		aDest->AppendL((*aSource)[ii]);

	}

EXPORT_C void CGridLay::ConstructL(CGridLay* aGridLay,CGridImg* aGridImg)

//

// Constructs a partial gridLay object for printing with the same data as the passed object.

// - Assumes the zoom factor has already been set

// - New Sparse maps are created

/** A second-phase constructor, taking an existing grid layout object, that constructs 

a partial layout object for printing.

The function assumes that the zoom factor has already been set.

@param aGridLay Pointer to an existing grid layout object.

@param aGridImg Pointer to an existing grid image object. */

	{

	iGridImg=aGridImg;

	iGridTable=aGridLay->iGridTable;

	iGridRange=aGridLay->iGridRange;

	iColumnWidthMap = CSparseMap::NewL(aGridLay->iColumnWidthMap);

	CopyIntArrayL(aGridLay->iHardRowPageBreaks,iHardRowPageBreaks);

	CopyIntArrayL(aGridLay->iHardColumnPageBreaks,iHardColumnPageBreaks);

	iPageSizeInTwips=aGridLay->iPageSizeInTwips;

	iRowHeightMap = CSparseMap::NewL(aGridLay->iRowHeightMap);

	RecalcPixelSparseMaps();

	iFlags=aGridLay->iFlags;

	if (IsPaginated())

		{

		ClearPagination();

		PaginateL();

		}

	}

EXPORT_C void CGridLay::ConstructL(const MGridTable *aGridTable,CGridImg *aGridImg,TInt aNoOfRows,TInt aNoOfCols)

/** A second-phase constructor for constructing the object with definite row boundaries.

@param aGridTable A pointer to the grid table.

@param aGridImg Pointer to a grid image object.

@param aNoOfRows The number of rows in the grid.

@param aNoOfCols The number of columns in the grid. */

	{

	TRangeRef gridRange(0,0,aNoOfRows-1,aNoOfCols-1);

	ConstructL(aGridTable,aGridImg,gridRange);

	}

EXPORT_C void CGridLay::ConstructL(const MGridTable *aGridTable,CGridImg *aGridImg,TInt aNoOfCols)

/** A second-phase constructor for constructing the object with indefinite row 

boundaries.

@param aGridTable A pointer to the grid table.

@param aGridImg Pointer to a grid image object.

@param aNoOfCols The number of columns in the grid. */

	{

	SetIndefiniteRowBoundaries(ETrue);

	TRangeRef gridRange(-KMaxTInt,0,KMaxTInt,aNoOfCols-1);

	ConstructL(aGridTable,aGridImg,gridRange);

	}

void CGridLay::ConstructL(const MGridTable *aGridTable,CGridImg *aGridImg,const TRangeRef& aGridRange)

// Initialization of member data in CGridLay

	{

	iGridTable = aGridTable;

	iGridImg = aGridImg;

	iGridRange = aGridRange;

	iColumnWidthMap = CSparseMap::NewL();

	iRowHeightMap = CSparseMap::NewL();

	iHardRowPageBreaks = new(ELeave) CArrayFixFlat<TInt>(1);

	iHardColumnPageBreaks = new(ELeave) CArrayFixFlat<TInt>(1);

	SetGridToDefault();

	if (iGridImg)

		iGridImg->ConstructSelectedL(iGridRange);

	iHasChanged=EFalse;

	}

EXPORT_C void CGridLay::SetGridImgL(CGridImg* aGridImg)

/** Sets the specified grid image object.

@param aGridImg The grid image object that draws the contents of the grid. */

	{

	__ASSERT_DEBUG(aGridImg!=NULL,Panic(EGridLayInvalidGridImg));

	iGridImg=aGridImg;

	iGridImg->ResetReferencePoints();

	ResetVisibleToCell();

	iGridImg->CheckSideLabelWidth();

	iGridImg->ConstructSelectedL(iGridRange);

	if (IsPaginated())	// Internalize will fail to paginate if NULL gridimg

		{

		ClearPagination();

		PaginateL();

		}

	}

EXPORT_C CGridLay::~CGridLay()

/** Destructor.

Frees resources prior to destruction of the object. */

	{

	delete iColumnWidthMap;

	delete iRowHeightMap;

	delete iColumnPageMap;

	delete iRowPageMap;

	delete iHardRowPageBreaks;

	delete iHardColumnPageBreaks;

	}

EXPORT_C void CGridLay::SetGraphicsDeviceMap(MGraphicsDeviceMap* aGraphicsDeviceMap)

/** Sets the graphics device map to be used.

@param aGraphicsDeviceMap The graphics device map: an interface for mapping 

between twips and device-specific units. */

	{

	__ASSERT_DEBUG(iGridImg!=NULL,Panic(EGridLayInvalidGridImg));

	iGraphicsDeviceMap=aGraphicsDeviceMap;

	RecalcPixelSparseMaps();

	iGridImg->ResetReferencePoints();

	ResetVisibleToCell();

	}

EXPORT_C void CGridLay::SetGridToDefault()

/** Resets the grid to its default layout. */

	{

	iRowHeightMap->ResetArray();

	iColumnWidthMap->ResetArray();

	iRowHeightMap->SetDefaultValueInTwips(EInitialDefaultRowHeightInTwips);

	iColumnWidthMap->SetDefaultValueInTwips(EInitialDefaultColumnWidthInTwips);

	RecalcPixelSparseMaps();

	ClearPagination();

	iHardRowPageBreaks->Reset();

	iHardColumnPageBreaks->Reset();

	iMinRowHeightInPixels=0;

	iMinColumnWidthInPixels=0;

	TBool isIndefiniteRowBoundaries=IsIndefiniteRowBoundaries();

	iFlags=EIsTopLabels|EIsSideLabels|EIsHorizontalGridLines|EIsVerticalGridLines|EIsGridLabelSeparators

		|EIsCursorVisible|EIsHighlightVisible|EIsPrintedGridLines|EIsAutoClearGridCells;

	if (iGridImg)

		{

		iGridImg->SetGridLay(this);

		iGridImg->ResetReferencePoints();

		}

	if (isIndefiniteRowBoundaries)

		{

		iFlags|=EIsIndefiniteRowBoundaries;

		iVisibleRange.iFrom.iRow=0;

		}

	else

		iVisibleRange.iFrom.iRow=iGridRange.iFrom.iRow;

	iVisibleRange.iFrom.iCol=iGridRange.iFrom.iCol;

	if (iGridImg)

		{

		ResetVisibleToCell();

		iGridImg->CheckSideLabelWidth();

		}

	}

EXPORT_C void CGridLay::SetVisibleRange(const TCellRef& aTopLeftCell)

/** Scrolls the grid so that the specified cell is visible in the top left corner 

of the grid.

@param aTopLeftCell The cell to be made visible in the top left corner of 

the visible grid. */

	{

	iVisibleRange.iFrom = aTopLeftCell;

	ResetVisibleToCell();

	}

EXPORT_C TPoint CGridLay::ExposeCell(const TCellRef &aCell)

/** Scrolls the grid by the minimum necessary to allow the specified cell to become 

visible.

@param aCell The cell to be made visible.

@return The number of pixels scrolled, in the x and y directions. */

	{

	TCellRef cell=aCell;

	LimitCellToVisible(cell);

	TCellRef newVisFromCell=iVisibleRange.iFrom;

	TInt visibilityCorr = (IsVisibleToRowFullyVisible()) ? 0 : 1;

	if (iVisibleRange.iTo.iRow>=iVisibleRange.iFrom.iRow)

		{

	    if (cell.iRow+visibilityCorr>iVisibleRange.iTo.iRow)

		    {

		    if (iVisibleRange.iFrom.iRow!=iVisibleRange.iTo.iRow)

			    CalcVisibleFromRow(cell.iRow+1,newVisFromCell.iRow);

		    else

			    newVisFromCell.iRow=cell.iRow;

		    }

	    else if (cell.iRow<iVisibleRange.iFrom.iRow)

		    newVisFromCell.iRow=cell.iRow;

        }

	visibilityCorr = (IsVisibleToColumnFullyVisible()) ? 0 : 1;

	if (iVisibleRange.iTo.iCol>=iVisibleRange.iFrom.iCol)

		{

	    if (cell.iCol+visibilityCorr>iVisibleRange.iTo.iCol)

		    {

		    if (iVisibleRange.iFrom.iCol!=iVisibleRange.iTo.iCol)

			    CalcVisibleFromColumn(cell.iCol+1,newVisFromCell.iCol);

		    else

			    newVisFromCell.iCol=cell.iCol;

		    }

	    else if (cell.iCol<iVisibleRange.iFrom.iCol)

		    newVisFromCell.iCol=cell.iCol;

        }

	TPoint offset=CalcOffsetBetweenCells(iVisibleRange.iFrom,newVisFromCell);

	SetVisibleRange(newVisFromCell);

	return (offset);

	}

EXPORT_C TPoint CGridLay::ExposeCellToTopLeft(const TCellRef &aCell)

/** Scrolls the grid by the minimum necessary so that the specified cell is in 

the top left corner of the visible grid.

@param aCell The cell to be made visible in the top left corner of the visible 

grid.

@return The number of pixels scrolled, in the x and y directions. */

	{

	TCellRef cell=aCell;

	LimitCellToVisible(cell);

	TPoint offset=CalcOffsetBetweenCells(iVisibleRange.iFrom,cell);

	SetVisibleRange(cell);

	return offset;

	}

EXPORT_C TPoint CGridLay::PageScroll(TMoveDirectionAndAmount aPageScroll)

// Same as CalcScroll but updates iVisibleRange to the new value.

/** Scrolls the grid by one page.

@param aPageScroll The direction and amount by which to scroll.

@return The number of pixels scrolled, in the x and y directions. This represents 

the amount of scrolling required to move from the start of the old visible 

range to the start of the new visible range. */

	{

	TRangeRef newVisRange;

	newVisRange.iFrom=CalcVisibleFromCellAfterPageScroll(aPageScroll);

	TPoint offset=CalcOffsetBetweenCells(iVisibleRange.iFrom,newVisRange.iFrom);

	SetVisibleRange(newVisRange.iFrom);

	return offset;

	}

TInt CGridLay::ColumnWidthInPixels(TInt aCol) const

	{

	return iColumnWidthMap->ValueInPixels(aCol);

	}

EXPORT_C TInt CGridLay::ColumnWidthInTwips(TInt aCol) const

/** Gets the width of the specified column.

@param aCol The column number.

@return The width of the column, in twips. */

	{

	return iColumnWidthMap->ValueInTwips(aCol);

	}

void CGridLay::SetColumnWidthInPixelsL(TInt aCol,TInt aWidthInPixels)

//

// Set the given column to the given width. Ensures that the visible range is

// left with sensible values

//	

	{

	__ASSERT_DEBUG(iGraphicsDeviceMap!=NULL,Panic(EGridNullGraphicsDeviceMap));

	aWidthInPixels=Max(aWidthInPixels,iMinColumnWidthInPixels);

	PreCheckColumnWidthChange(aCol,aWidthInPixels);

	iColumnWidthMap->SetL(aCol,iGraphicsDeviceMap->HorizontalPixelsToTwips(aWidthInPixels),aWidthInPixels);

	PostCheckColumnWidthChange(aCol,aWidthInPixels);

	}

void CGridLay::PreCheckColumnWidthChange(TInt aCol,TBool aNonZeroWidth)

	{

	if (aNonZeroWidth)

		{

		TInt col=aCol;

		StepColumnForward(col);

		if (IsVerticalTitleLine() && col==iTitleRange.iFrom.iCol)

			iTitleRange.iFrom.iCol=aCol;

		else if ((!IsVerticalTitleLine() || col>iTitleRange.iTo.iCol) && col==iVisibleRange.iFrom.iCol)

			iVisibleRange.iFrom.iCol=aCol;

		}

	}

void CGridLay::PostCheckColumnWidthChange(TInt aCol,TBool aNonZeroWidth)

	{

	if (!aNonZeroWidth)

		{

		if (IsVerticalTitleLine() && aCol==iTitleRange.iFrom.iCol)

			StepColumnForward(iTitleRange.iFrom.iCol);

		if (aCol==iVisibleRange.iFrom.iCol)

			StepColumnForward(iVisibleRange.iFrom.iCol);

		}

	if (iGridImg)

		iGridImg->ResetReferencePoints();

	ResetVisibleToColumn();

	iHasChanged=ETrue;

	}

EXPORT_C void CGridLay::SetColumnWidthInTwipsL(TInt aCol,TInt aWidthInTwips)

//

// Set the given column to the given width. Ensures that the visible range is

// left with sensible values

//	

/** Sets the width of the specified column.

Note that the width cannot be set smaller than the minimum defined column 

width.

@param aCol The number of the column whose width is to be set.

@param aWidthInTwips The width of the column, in twips.

@panic GRIDIMG 9 In debug mode, if no MGraphicsDeviceMap object has been set.

@see MinColumnWidthInPixels() */

	{

	TInt widthInPixels=0;

	if (iGraphicsDeviceMap)

		{

		widthInPixels=iGraphicsDeviceMap->HorizontalTwipsToPixels(aWidthInTwips);

		if (widthInPixels<iMinColumnWidthInPixels)

			{

			widthInPixels=iMinColumnWidthInPixels;

			aWidthInTwips=iGraphicsDeviceMap->HorizontalPixelsToTwips(widthInPixels);

			}

		}

	PreCheckColumnWidthChange(aCol,aWidthInTwips);

	iColumnWidthMap->SetL(aCol,aWidthInTwips,widthInPixels);

	PostCheckColumnWidthChange(aCol,aWidthInTwips);

	}

EXPORT_C TInt CGridLay::SetColumnWidthInTwipsL(TInt aStartCol,TInt aEndCol,TInt aWidthInTwips)

/** Sets the widths of all specified columns to the specified value.

@param aStartCol The first column whose width is to be set.

@param aEndCol The last column whose width is to be set.

@param aWidthInTwips The width of the columns, in twips. Note that if the specified 

columns span the whole grid, then the function sets this value as the default 

width of all columns through a call to SetDefaultColumnWidthInTwips().

@return KErrNone if successful; KErrTooBig if the difference between the two 

column numbers is greater than EMaxArrayChanges. */

	{

	if (aStartCol==iGridRange.iFrom.iCol && aEndCol==iGridRange.iTo.iCol)

		{

		SetColumnWidthsToDefault();

		SetDefaultColumnWidthInTwips(aWidthInTwips);

		}

	else if (aEndCol-aStartCol>EMaxArrayChanges)

		return KErrTooBig;

	else

		{

		for (;aStartCol<=aEndCol;aStartCol++)

			SetColumnWidthInTwipsL(aStartCol,aWidthInTwips);

		}

	iHasChanged=ETrue;

	return KErrNone;

	}

TInt CGridLay::DefaultColumnWidthInPixels() const

	{

	return iColumnWidthMap->DefaultValueInPixels();

	}

EXPORT_C TInt CGridLay::DefaultColumnWidthInTwips() const

/** Gets the default width of columns.

@return The default width of columns, in twips. */

	{

	return iColumnWidthMap->DefaultValueInTwips();

	}

void CGridLay::SetDefaultColumnWidthInPixels(TInt aWidthInPixels)

	{

	if (aWidthInPixels==0)

		return;

	__ASSERT_DEBUG(iGraphicsDeviceMap!=NULL,Panic(EGridNullGraphicsDeviceMap));

	aWidthInPixels=Max(aWidthInPixels,iMinColumnWidthInPixels);

	iColumnWidthMap->SetDefaultValueInPixels(aWidthInPixels);

	iColumnWidthMap->SetDefaultValueInTwips(iGraphicsDeviceMap->HorizontalPixelsToTwips(aWidthInPixels));

	if (iGridImg)

		iGridImg->ResetReferencePoints();

	ResetVisibleToColumn();

	iHasChanged=ETrue;

	}

EXPORT_C void CGridLay::SetDefaultColumnWidthInTwips(TInt aWidthInTwips)

/** Sets the column width default value.

Note that the width cannot be set smaller than the minimum defined column 

width.

@param aWidthInTwips The width of columns, in twips.

@see SetMinColumnWidthInPixels()

@see MinColumnWidthInPixels() */

	{

	if (aWidthInTwips==0)

		return;

	if (iGraphicsDeviceMap)

		{

		TInt widthInPixels=iGraphicsDeviceMap->HorizontalTwipsToPixels(aWidthInTwips);

		if (widthInPixels<iMinColumnWidthInPixels)

			{

			widthInPixels=iMinColumnWidthInPixels;

			aWidthInTwips=iGraphicsDeviceMap->HorizontalPixelsToTwips(widthInPixels);

			}

		iColumnWidthMap->SetDefaultValueInPixels(widthInPixels);

		}

	iColumnWidthMap->SetDefaultValueInTwips(aWidthInTwips);

	if (iGridImg)

		iGridImg->ResetReferencePoints();

	ResetVisibleToColumn();

	iHasChanged=ETrue;

	}

EXPORT_C void CGridLay::SetColumnWidthsToDefault()

/** Sets the widths of all columns to the default value.

@see SetDefaultColumnWidthInTwips() */

	{

	iColumnWidthMap->ResetArray();

	if (iGridImg)

		iGridImg->ResetReferencePoints();

	ResetVisibleToColumn();

	iHasChanged=ETrue;

	}

EXPORT_C TInt CGridLay::MinColumnWidthInPixels() const

/** Gets the minimum width of columns.

@return The minimum width of columns, in pixels. */

	{

	return iMinColumnWidthInPixels;

	}

EXPORT_C void CGridLay::SetMinColumnWidthInPixels(TInt aWidthInPixels)