// 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 member variables of the class CGridImg are as follows:-

// iGridRect - the coordinates of the rectangle containing the grid.

// iTitlePoint - The point at the top left of the grid not including the labels

// iMainPoint - The point at which the visible range starts (usually == iTitlePoint)

// iCursorPos - the cell reference of the current cursor position.

// iNewCursorPos - the proposed cell reference of the position that

// the cursor would occupy after a keypress.

// iAnchorPos - the cell reference of the position that the cursor must

// return to after a series of selected movements have been made.

// iGcPtr - a pointer to the current graphics context.

// iGc - the internal grid image Gc

// *iWin - a pointer to the current active window.

// *iGridLay, *iGridCellImg, *iGridLabelImg - allow access to the data in these

// other classes.

// *iSelected - allows access to the class that stores the array of selected ranges

// *iCursorMoveCallBack - a pointer to call back to an app after a cursor move

// iDragLabel - store the index of the label currently being dragged

// iCurrentDragPos - Stores the position of the label prior to it being dragged

// iDragDiff - Stores the distance between the second drag label and the pointer while a label drag is in progress

// iDragDim - Simply stores the dimension in which a label drag is in (X,Y or none)

// iDragBmp - Stores the bitmap of the dragged labels during a drag.

// iXRefPoint,iYRefPoint - Remembers which part of the grid the last pointer event was in. This is used in the

// SetCursorWithPointer() function logic.

// 

//

#include "GRDSTD.H"

#include "GRDPANIC.H"

#if !defined(__WINC__)

#include <w32std.h>

#endif

const TInt KArrowLength = 11;

const TInt KArrowBreadth = 11;

const TInt KArrowSeparation = 11;

GLDEF_C void Panic(TGridPanic aPanic)

	{

	_LIT(KGridPanic,"GRIDIMG");

	User::Panic(KGridPanic,aPanic);

	}

EXPORT_C void TGridUtils::FillRect(CGraphicsContext* aGc,TRgb aColor,const TRect &aRect)

/** Fills the specified rectangle with the specified colour.

@param aGc The graphics context to be used.

@param aColor The colour which is to fill the rectangle.

@param aRect The rectangle to be filled.

@panic GRIDIMG 0 In debug mode only, if the pointer to the graphics context 

is Null. */

	{

	__ASSERT_DEBUG(aGc!=NULL,Panic(EGridImgInvalidGC));

	aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	aGc->SetPenStyle(CGraphicsContext::ENullPen);

	aGc->SetBrushColor(aColor);

	aGc->DrawRect(aRect);

	aGc->SetPenStyle(CGraphicsContext::ESolidPen);

	aGc->SetBrushStyle(CGraphicsContext::ENullBrush);

	}

//

EXPORT_C CGridCellImg::CGridCellImg()

	: iBurstColOffset(0),

	iBurstLeft(0),

	iBurstRight(0),

	iGridLineFlags(EIsHorizontalGridLines|EIsVerticalGridLines)

/** Default constructor. */

	{

	}

EXPORT_C CGridCellImg::~CGridCellImg()

/** Destructor. */

	{

	}

EXPORT_C TInt CGridCellImg::DataWidthInPixelsL(const TCellRef& /*aCell*/) const

/**	Gets the width of the data contained in the specified cell.

@publishedAll 

@released

@param aCell The cell to be tested.

@return The width of the data, in pixels. The default implementation returns zero.*/

	{

	return 0;

	}

EXPORT_C TBool CGridCellImg::DoesCellContainDataL(const TCellRef& /*aCell*/) const

/**	Tests whether the specified cell contains data.

@publishedAll 

@released

@param aCell The cell to be tested.

@return True, if the cell contains data; false, otherwise. The default implementation returns true.*/

	{

	return ETrue;

	}

EXPORT_C void CGridCellImg::Reserved_1()

	{

// No implementation yet

	}

void CGridCellImg::SetBurstingData(TInt aBurstColOffset,TInt aBurstLeft,TInt aBurstRight)

	{

	iBurstColOffset=aBurstColOffset;

	iBurstLeft=aBurstLeft;

	iBurstRight=aBurstRight;

	}

//

EXPORT_C CGridLabelImg::CGridLabelImg(const TFontSpec& aFontSpec,MGraphicsDeviceMap* aGraphicsDeviceMap)

	: iFontSpec(aFontSpec),

	iGraphicsDeviceMap(aGraphicsDeviceMap)

/** Constructor taking specified parameters.

@param aFontSpec A font specification in device independent terms.

@param aGraphicsDeviceMap An interface for mapping between twips and device-specific 

units. */

	{

	}

EXPORT_C CGridLabelImg::~CGridLabelImg()

/** Destructor.

Releases resources before the object is destroyed. Specifically, it releases 

the font acquired when the object was constructed. */

	{

	if (iGraphicsDeviceMap && iFont)

		iGraphicsDeviceMap->ReleaseFont(iFont);

	}

EXPORT_C void CGridLabelImg::ConstructL()

/** Implements the second phase of two-phase construction.

Specifically, it gets the nearest font to that specified in the font specification 

passed to the constructor. */

	{

	NotifyGraphicsDeviceMapChangeL();

	}

EXPORT_C void CGridLabelImg::DrawTopLeftLabelL(CGraphicsContext* aGc,const TRect& aRect) const

/** Fills the specified rectangle with a colour.

The default implementation fills the specified rectangle with the background 

colour value as defined by the grid colour specification in iGridColors.

@publishedAll 

@released 

@param aGc The graphics context to be used.

@param aRect The rectangle to be filled.

@see TGridColors */

	{

//	TGridUtils::FillRect(aGc,KGridBackgroundColor,aRect);

//->

	TGridUtils::FillRect(aGc, iGridColors.iBackground, aRect);

	}

EXPORT_C void CGridLabelImg::DrawTopLeftLabelL(CGraphicsContext* aGc,const TRect& aRect, TRgb aColor) const

/** Fills the specified rectangle with the specified colour.

@param aGc The graphics context to be used.

@param aRect The rectangle to be filled.

@param aColor The colour which is to fill the rectangle. */

	{

	TGridUtils::FillRect(aGc, aColor, aRect);

	}

//->

EXPORT_C TInt CGridLabelImg::SideLabelWidthInPixels(TInt /*aStartRow*/,TInt /*aEndRow*/) const

/** Gets the width of the side labels.

@publishedAll 

@released 

@param aStartRow A start row. The default implementation does not use this value, 

but a derived class can use this to define the start of a range of rows, 

which may be useful if side labels have variable widths.

@param aEndRow An end row. The default implementation does not use this value, 

but a derived class can use this to define the end of a range of rows, 

which may be useful if side labels have variable widths.

@return The width value, in pixels. The default implementation returns the 

pixel value corresponding to the twips value EDefaultSideLabelWidthInTwips, 

as converted by the graphics device map function MGraphicsDeviceMap::HorizontalTwipsToPixels(). */

	{

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

	return iGraphicsDeviceMap->HorizontalTwipsToPixels(EDefaultSideLabelWidthInTwips);

	}

EXPORT_C TInt CGridLabelImg::TopLabelHeightInPixels() const

/** Gets the height of the top labels.

@publishedAll 

@released 

@return The height value, in pixels. The default implementation returns the 

pixel value corresponding to the twips value EDefaultTopLabelHeightInTwips, 

as converted by the graphics device map function MGraphicsDeviceMap::VerticalTwipsToPixels(). */

	{

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

	return iGraphicsDeviceMap->VerticalTwipsToPixels(EDefaultTopLabelHeightInTwips);

	}

EXPORT_C void CGridLabelImg::DrawRowCursorL(CGraphicsContext* /*aGc*/,const TRect& /*aRect*/) const

/** Draws a cursor to identify a row.

The default implementation is empty.

@publishedAll 

@released 

@param aGc The graphics context to be used.

@param aRect The rectangle in which the cursor is to be drawn. */

//

// To be overridden from if used

//

	{}

EXPORT_C void CGridLabelImg::ReleaseFont()

//

// Should be called before any change in the zoom factor device

/** Releases the font.

This is called by the destructor, and should be called before calling SetGraphicsDeviceMap().

@see ConstructL() */

	{

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

	iGraphicsDeviceMap->ReleaseFont(iFont);

	iFont=NULL;

	}

EXPORT_C void CGridLabelImg::NotifyGraphicsDeviceMapChangeL()

/** Deals with the result of changing the graphics device map, i.e. the interface 

for mapping between twips and device-specific units.

The function releases the existing font, and then tries to get the nearest 

font to that specified in the font specification.

@see ConstructL()

@see SetGraphicsDeviceMap() */

	{

	ReleaseFont();

	User::LeaveIfError(iGraphicsDeviceMap->GetNearestFontInTwips(iFont,iFontSpec));

	}

//

EXPORT_C CGridImg* CGridImg::NewL(CGridCellImg* aGridCellImg,CGridLay* aGridLay)

/** Creates a new grid image object suitable for printing.

@param aGridCellImg A pointer to an object that draws the contents of a 

single cell.

@param aGridLay A pointer to the object that controls the layout of rows and 

columns.

@return A pointer to the new grid image object. */

	{

//->

	CGridImg* self = new(ELeave) CGridImg(aGridCellImg,aGridLay);

	if (aGridLay && aGridCellImg)

		aGridCellImg->SetGridColors(aGridLay->GridColors());

	return self;

//->

//	return new(ELeave) CGridImg(aGridCellImg,aGridLay);

	}

CGridImg::CGridImg(CGridCellImg* aGridCellImg,CGridLay* aGridLay)

//

// Construct a partial gridImg object for printing with the same data as the passed gridImg

// and a handle to the passed gridLay

	: iGridCellImg(aGridCellImg),

	iGridLay(aGridLay)

	{

	}

EXPORT_C CGridImg* CGridImg::NewL(CGraphicsDevice* aGraphicsDevice,CGridCellImg* aGridCellImg,CGridLay* aGridLay)

/** Creates a new grid image object.

@param aGraphicsDevice The graphics device to be used for drawing.

@param aGridCellImg A pointer to an object that draws the contents of a single 

cell.

@param aGridLay A pointer to the object that controls the layout of rows and 

columns.

@return A pointer to the new grid image object. */

	{

	CGridImg* self=new(ELeave) CGridImg(aGraphicsDevice,aGridCellImg,aGridLay);

	CleanupStack::PushL(self);

//->

	if (aGridLay && aGridCellImg)

		aGridCellImg->SetGridColors(aGridLay->GridColors());

//->

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CGridImg::CGridImg(CGraphicsDevice *aGraphicsDevice,CGridCellImg *aGridCellImg,CGridLay* aGridLay)

	: iGraphicsDevice(aGraphicsDevice),

	iGridCellImg(aGridCellImg),

	iGridLay(aGridLay),

	iDragLabel(0),

	iCurrentDragPos(0),

	iDragDiff(0),

	iDragFlags(0),

	iDragDim(ENoDrag),

	iXRefPoint(EMainRef),

	iYRefPoint(EMainRef)

	{

	}

void CGridImg::ConstructL()

	{

#if !defined(__WINC__)

	if (iGraphicsDevice)

		User::LeaveIfError(iGraphicsDevice->CreateContext((CGraphicsContext*&)iGc));

#endif

	}

EXPORT_C CGridImg::~CGridImg()

/** Destructor.

Frees resources before destruction of the object. */

	{

#if !defined(__WINC__)

	delete iGc;

	delete iDragBmp;

#endif

	delete iSelected;

	}

void CGridImg::ConstructSelectedL(const TRangeRef& aGridRange)

	{

    delete iSelected;

    iSelected=NULL; // in case next line fails

	iSelected = CGridCellRegion::NewL(aGridRange);

	}

void CGridImg::CreateGc(CGraphicsContext* aGc)

	{

	__ASSERT_DEBUG(iGcPtr==NULL,Panic(EGridImgInvalidGC));

	iGcPtr=aGc;

#if !defined(__WINC__)

    if (iGcPtr==iGc)

    	iGc->Activate(*iWin);

#endif

	}

void CGridImg::DeleteGc()

	{

	__ASSERT_DEBUG(iGcPtr!=NULL,Panic(EGridImgInvalidGC));

#if !defined(__WINC__)

	if (iGcPtr==iGc)

    	iGc->Deactivate();

#endif

	iGcPtr=NULL;

	}

void CGridImg::DrawAllGridLabelsL() const

// Draw all the grid labels

	{

	__ASSERT_DEBUG(iGcPtr!=NULL,Panic(EGridImgInvalidGC));

	DrawTopLeftGridLabelL();

	TRangeRef titleRange=iGridLay->TitleRange();

	if (iGridLay->IsHorizontalTitleLine())

		DrawSideGridLabelsL(titleRange.iFrom.iRow,titleRange.iTo.iRow-1,ETitleRef);

	if (iGridLay->IsVerticalTitleLine())

		DrawTopGridLabelsL(titleRange.iFrom.iCol,titleRange.iTo.iCol-1,ETitleRef);

	TRangeRef visRange=iGridLay->VisibleRange();

	DrawTopGridLabelsL(visRange.iFrom.iCol,visRange.iTo.iCol);

	DrawSideGridLabelsL(visRange.iFrom.iRow,visRange.iTo.iRow);

	}

void CGridImg::DrawTopLeftGridLabelL() const

// Draw top left corner label

	{

	__ASSERT_DEBUG(iGcPtr!=NULL,Panic(EGridImgInvalidGC));

	if (iGridLay->IsTopLabels() && iGridLay->IsSideLabels())

		{

		TRect rect(iGridRect.iTl,iTitlePoint);

		if (iGridLay->IsGridLabelSeparators())

			{

		    rect.Resize(-1,-1);

//->

		    iGcPtr->SetPenColor(iGridLay->GridColors().iLabelSeparators);

//		    iGcPtr->SetPenColor(KRgbGridLabelSeparators);

//->

		    TPoint start(rect.iTl.iX,rect.iBr.iY);

		    TPoint finish(rect.iBr.iX+1,rect.iBr.iY);

		    iGcPtr->DrawLine(start,finish);

		    start.SetXY(rect.iBr.iX,rect.iTl.iY);

		    iGcPtr->DrawLine(start,rect.iBr);

            }

//->

//		iGridLabelImg->DrawTopLeftLabelL(iGcPtr,rect);

		iGridLabelImg->DrawTopLeftLabelL(iGcPtr, rect, iGridLay->GridColors().iBackground);

//->

		}

	}

void CGridImg::DrawTopGridLabelsL(TInt aStartCol,TInt aEndCol,TRefPoint aXRef) const

// Draws all the top grid labels within the specified column range

	{

	__ASSERT_DEBUG(iGcPtr!=NULL,Panic(EGridImgInvalidGC));

	if (!iGridLay->IsTopLabels() || iGridLabelImg==NULL)

		return;

	TInt separatorCorr=(iGridLay->IsGridLabelSeparators()) ? 1 : 0;

	TRect rect;

	rect.iTl.iY=iGridRect.iTl.iY;

	rect.iBr.iY=iTitlePoint.iY-separatorCorr;

	rect.iTl.iX=((aXRef==ETitleRef) ? iGridLay->TitleColumnToXVal(aStartCol) :

		iGridLay->ColumnToXVal(aStartCol));

	rect.iBr.iX=rect.iTl.iX-separatorCorr;

	TBool doGrayFill=EFalse;

	TRangeRef visRange=iGridLay->VisibleRange();

	if (aEndCol>=visRange.iTo.iCol)

		{

		aEndCol=visRange.iTo.iCol;

		if (aEndCol>iGridLay->GridRange().iTo.iCol)

			{

			aEndCol--;

			doGrayFill=ETrue;

			}

		}

	iGcPtr->SetClippingRect(TRect(iTitlePoint.iX,iGridRect.iTl.iY,iGridRect.iBr.iX,iTitlePoint.iY));

	if (iGridLay->IsGridLabelSeparators())

		{

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

			{

			rect.iBr.iX+=iGridLay->ColumnWidthInPixels(ii);

			iGridLabelImg->DrawColLabelL(iGcPtr,ii,rect);

			rect.iTl.iX=rect.iBr.iX;

//->

		    iGcPtr->SetPenColor(iGridLay->GridColors().iLabelSeparators);

//			iGcPtr->SetPenColor(KRgbGridLabelSeparators);

//->

			iGcPtr->DrawLine(rect.iTl,rect.iBr);

			rect.iTl.iX++;

			}

		}

	else

		{

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

			{

			rect.iBr.iX+=iGridLay->ColumnWidthInPixels(ii);

			iGridLabelImg->DrawColLabelL(iGcPtr,ii,rect);

			rect.iTl.iX=rect.iBr.iX;

			}

		}

	if (doGrayFill)	

		{

		TGridUtils::FillRect(iGcPtr,iGridLay->iGridEdgeColor,

			TRect(rect.iTl.iX,rect.iTl.iY,iGridRect.iBr.iX,rect.iBr.iY+separatorCorr));

		}

	if (iGridLay->IsGridLabelSeparators())

		{

	    rect.iBr.iX++;

//->

	    iGcPtr->SetPenColor(iGridLay->GridColors().iLabelSeparators);

//	    iGcPtr->SetPenColor(KRgbGridLabelSeparators);

	    iGcPtr->DrawLine(TPoint(iTitlePoint.iX,rect.iBr.iY),rect.iBr);

//->

        }

	iGcPtr->CancelClippingRect();

	}

void CGridImg::DrawSideGridLabelsL(TInt aStartRow,TInt aEndRow,TRefPoint aYRef) const

	{

	//

	// Draw all the side grid labels within the specified row range

	//

	__ASSERT_DEBUG(iGcPtr!=NULL,Panic(EGridImgInvalidGC));

	if (!iGridLay->IsSideLabels() || iGridLabelImg==NULL)

		return;

	TInt separatorCorr=(iGridLay->IsGridLabelSeparators()) ? 1 : 0;

	TRect rect;

	rect.iTl.iX=iGridRect.iTl.iX;

	rect.iBr.iX=iTitlePoint.iX-separatorCorr;

	rect.iTl.iY=((aYRef==ETitleRef) ? iGridLay->TitleRowToYVal(aStartRow) :

		iGridLay->RowToYVal(aStartRow));

	TInt startY=rect.iTl.iY;

	rect.iBr.iY=rect.iTl.iY-separatorCorr;

	TBool doGrayFill=EFalse;

	TRangeRef visRange=iGridLay->VisibleRange();

	if (aEndRow>=visRange.iTo.iRow)

		{

		aEndRow=visRange.iTo.iRow;

		TInt reqRow;

		if (iGridLay->RequestRow(aEndRow,reqRow))

			{

			if (aEndRow!=reqRow)

				{

				aEndRow--;

				doGrayFill=ETrue;

				}

			}

		else

			{

			aEndRow=aStartRow-1;	// guarantees not to go into loop

			doGrayFill=ETrue;

			}

		}

	iGcPtr->SetClippingRect(TRect(iGridRect.iTl.iX,iTitlePoint.iY,iTitlePoint.iX,iGridRect.iBr.iY));

	if (iGridLay->IsGridLabelSeparators())

		{

		for (TInt ii=aStartRow;ii<=aEndRow;ii++)

			{

			rect.iBr.iY+=iGridLay->RowHeightInPixels(ii);

			iGridLabelImg->DrawRowLabelL(iGcPtr,ii,rect);

			if (ii==iCursorPos.iRow)

				iGridLabelImg->DrawRowCursorL(iGcPtr,rect);

			rect.iTl.iY=rect.iBr.iY;

//->

		    iGcPtr->SetPenColor(iGridLay->GridColors().iLabelSeparators);

//			iGcPtr->SetPenColor(KRgbGridLabelSeparators);

//->

			iGcPtr->DrawLine(rect.iTl,rect.iBr);

			rect.iTl.iY++;

			}

		}

	else