--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/commonuisupport/grid/src/GRDLAY.CPP Tue Feb 02 01:00:49 2010 +0200
@@ -0,0 +1,2596 @@
+// 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)
+/** Sets the minimum width of columns.
+
+@param aWidthInPixels The minimum width of columns, in pixels. */
+ {
+ iMinColumnWidthInPixels=aWidthInPixels;
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C TInt CGridLay::ColumnWidthOfSelectedInTwips() const
+/** Gets the width of columns in the selected region.
+
+@return The column width, in twips, if all columns in the selected region
+have the same width; -1, otherwise.
+@panic GRIDIMG 3 If this grid layout object has no grid image object. */
+ {
+ __ASSERT_DEBUG(iGridImg!=NULL,Panic(EGridLayInvalidGridImg));
+ if (IsUniformColumnWidth())
+ return DefaultColumnWidthInTwips();
+ const CGridCellRegion* selected=iGridImg->Selected();
+ TInt count=selected->Count();
+ if (!count)
+ return ColumnWidthInTwips(iGridImg->CursorPos().iCol);
+ if (selected->IsAnyRowSelected())
+ return iColumnWidthMap->Count() ? -1 : DefaultColumnWidthInTwips();
+
+ TInt width=ColumnWidthInTwips((*selected)[count-1].iFrom.iCol);
+ for (TInt ii=0;ii<count;ii++)
+ {
+ TRangeRef range=(*selected)[ii];
+ for (;range.iFrom.iCol<=range.iTo.iCol;range.iFrom.iCol++)
+ {
+ if (ColumnWidthInTwips(range.iFrom.iCol)!=width)
+ return -1; //Inconsistent widths
+ }
+ }
+ return width;
+ }
+
+EXPORT_C void CGridLay::SetColumnWidthOfSelectedInTwipsL(TInt aWidthInTwips)
+/** Sets the widths of all columns in the selected region to the specified value.
+
+@param aWidthInTwips The column width, in twips.
+@panic GRIDIMG 3 If this grid layout object has no grid image object. */
+ {
+ __ASSERT_DEBUG(iGridImg!=NULL,Panic(EGridLayInvalidGridImg));
+ const CGridCellRegion* selected=iGridImg->Selected();
+ if (selected->IsAnyRowSelected() || IsUniformColumnWidth())
+ {
+ iColumnWidthMap->ResetArray();
+ SetDefaultColumnWidthInTwips(aWidthInTwips);
+ }
+ else
+ {
+ TInt count=selected->Count();
+ if (!count)
+ SetColumnWidthInTwipsL(iGridImg->CursorPos().iCol,aWidthInTwips);
+ for (TInt ii=0;ii<count;ii++)
+ {
+ TRangeRef range=(*selected)[ii];
+ if ((range.iTo.iCol-range.iFrom.iCol)>EMaxArrayChanges)
+ continue;
+ for (;range.iFrom.iCol<=range.iTo.iCol;range.iFrom.iCol++)
+ SetColumnWidthInTwipsL(range.iFrom.iCol,aWidthInTwips);
+ }
+ }
+ NotifyPaginationOutOfDateL();
+ }
+
+TInt CGridLay::RowHeightInPixels(TInt aRow) const
+ {
+ return iRowHeightMap->ValueInPixels(aRow);
+ }
+
+EXPORT_C TInt CGridLay::RowHeightInTwips(TInt aRow) const
+/** Gets the height of the specified row.
+
+@param aRow The row number.
+@return The height of the row, in twips. */
+ {
+ return iRowHeightMap->ValueInTwips(aRow);
+ }
+
+void CGridLay::SetRowHeightInPixelsL(TInt aRow,TInt aHeightInPixels)
+//
+// Similar to SetColumnWidthInPixelsL (remember this may be limited to the min row height)
+//
+ {
+ __ASSERT_DEBUG(iGraphicsDeviceMap!=NULL,Panic(EGridNullGraphicsDeviceMap));
+ aHeightInPixels=Max(aHeightInPixels,iMinRowHeightInPixels);
+ PreCheckRowHeightChange(aRow,aHeightInPixels);
+ iRowHeightMap->SetL(aRow,iGraphicsDeviceMap->VerticalPixelsToTwips(aHeightInPixels),aHeightInPixels);
+ PostCheckRowHeightChange(aRow,aHeightInPixels);
+ }
+
+void CGridLay::PreCheckRowHeightChange(TInt aRow,TBool aNonZeroHeight)
+ {
+ if (aNonZeroHeight)
+ {
+ TInt row=aRow;
+ StepRowForward(row);
+ if (IsHorizontalTitleLine() && row==iTitleRange.iFrom.iRow)
+ iTitleRange.iFrom.iRow=aRow;
+ else if ((!IsHorizontalTitleLine() || row>iTitleRange.iTo.iRow) && row==iVisibleRange.iFrom.iRow)
+ iVisibleRange.iFrom.iRow=aRow;
+ }
+ }
+
+void CGridLay::PostCheckRowHeightChange(TInt aRow,TBool aNonZeroHeight)
+ {
+ if (!aNonZeroHeight)
+ {
+ if (IsHorizontalTitleLine() && aRow==iTitleRange.iFrom.iRow)
+ StepRowForward(iTitleRange.iFrom.iRow);
+ if (aRow==iVisibleRange.iFrom.iRow)
+ StepRowForward(iVisibleRange.iFrom.iRow);
+ }
+ if (iGridImg)
+ iGridImg->ResetReferencePoints();
+ ResetVisibleToRow();
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::SetRowHeightInTwipsL(TInt aRow,TInt aHeightInTwips)
+//
+// Similar to SetColumnWidthInTwipsL (remember this may be limited to the min row height)
+//
+/** Sets the height of the specified row.
+
+Note that the height cannot be set smaller than the minimum defined row height.
+
+@param aRow The number of row whose height is to be set.
+@param aHeightInTwips The height of the row, in twips.
+@see MinRowHeightInPixels() */
+ {
+ TInt heightInPixels=0;
+ if (iGraphicsDeviceMap)
+ {
+ heightInPixels=iGraphicsDeviceMap->VerticalTwipsToPixels(aHeightInTwips);
+ if (heightInPixels<iMinRowHeightInPixels)
+ {
+ heightInPixels=iMinRowHeightInPixels;
+ aHeightInTwips=iGraphicsDeviceMap->VerticalPixelsToTwips(heightInPixels);
+ }
+ }
+ PreCheckRowHeightChange(aRow,aHeightInTwips);
+ iRowHeightMap->SetL(aRow,aHeightInTwips,heightInPixels);
+ PostCheckRowHeightChange(aRow,aHeightInTwips);
+ }
+
+EXPORT_C TInt CGridLay::SetRowHeightInTwipsL(TInt aStartRow,TInt aEndRow,TInt aHeightInTwips)
+/** Sets the heights of all specified rows to the specified value.
+
+@param aStartRow The first row whose height is to be set.
+@param aEndRow The last row whose height is to be set.
+@param aHeightInTwips The height of the rows, in twips. Note that if the specified
+rows span the whole grid, then the function sets this value as the default
+height of all rows through a call to SetDefaultRowHeightInTwips().
+@return KErrNone if successful; KErrTooBig if the difference between the two
+row numbers is greater than EMaxArrayChanges. */
+ {
+ if (aStartRow==iGridRange.iFrom.iRow && aEndRow==iGridRange.iTo.iRow)
+ {
+ SetRowHeightsToDefault();
+ SetDefaultRowHeightInTwips(aHeightInTwips);
+ }
+ else if (aEndRow-aStartRow>EMaxArrayChanges)
+ return KErrTooBig;
+ else
+ {
+ for (;aStartRow<=aEndRow;aStartRow++)
+ SetRowHeightInTwipsL(aStartRow,aHeightInTwips);
+ }
+ iHasChanged=ETrue;
+ return KErrNone;
+ }
+
+EXPORT_C TInt CGridLay::MinRowHeightInPixels() const
+/** Gets the minimum height of rows.
+
+@return The minimum height of rows, in pixels. */
+ {
+ return iMinRowHeightInPixels;
+ }
+
+EXPORT_C void CGridLay::SetMinRowHeightInPixels(TInt aHeightInPixels)
+/** Sets the minimum height of rows.
+
+@param aHeightInPixels The minimum height of rows, in pixels. */
+ {
+ iMinRowHeightInPixels=aHeightInPixels;
+ iHasChanged=ETrue;
+ }
+
+TInt CGridLay::DefaultRowHeightInPixels() const
+ {
+ return iRowHeightMap->DefaultValueInPixels();
+ }
+
+EXPORT_C TInt CGridLay::DefaultRowHeightInTwips() const
+/** Gets the default height of rows.
+
+@return The default height of rows, in twips, */
+ {
+ return iRowHeightMap->DefaultValueInTwips();
+ }
+
+void CGridLay::SetDefaultRowHeightInPixels(TInt aHeightInPixels)
+//
+// Remember this may be limited to the min row height
+ {
+ if (aHeightInPixels==0)
+ return;
+ __ASSERT_DEBUG(iGraphicsDeviceMap!=NULL,Panic(EGridNullGraphicsDeviceMap));
+ aHeightInPixels=Max(aHeightInPixels,iMinRowHeightInPixels);
+ iRowHeightMap->SetDefaultValueInPixels(aHeightInPixels);
+ iRowHeightMap->SetDefaultValueInTwips(iGraphicsDeviceMap->VerticalPixelsToTwips(aHeightInPixels));
+ if (iGridImg)
+ iGridImg->ResetReferencePoints();
+ ResetVisibleToRow();
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::SetDefaultRowHeightInTwips(TInt aHeightInTwips)
+/** Sets the default height of rows.
+
+Note that the height cannot be set smaller than the minimum defined row height.
+
+@param aHeightInTwips The height of rows, in twips.
+@see SetMinRowHeightInPixels()
+@see MinRowHeightInPixels() */
+ {
+ if (aHeightInTwips==0)
+ return;
+ if (iGraphicsDeviceMap)
+ {
+ TInt heightInPixels=iGraphicsDeviceMap->VerticalTwipsToPixels(aHeightInTwips);
+ if (heightInPixels<iMinRowHeightInPixels)
+ {
+ heightInPixels=iMinRowHeightInPixels;
+ aHeightInTwips=iGraphicsDeviceMap->VerticalPixelsToTwips(heightInPixels);
+ }
+ iRowHeightMap->SetDefaultValueInPixels(heightInPixels);
+ }
+ iRowHeightMap->SetDefaultValueInTwips(aHeightInTwips);
+ if (iGridImg)
+ iGridImg->ResetReferencePoints();
+ ResetVisibleToRow();
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::SetRowHeightsToDefault()
+/** Sets the heights of all rows to the default value.
+
+@see SetDefaultRowHeightInTwips() */
+ {
+ iRowHeightMap->ResetArray();
+ if (iGridImg)
+ iGridImg->ResetReferencePoints();
+ ResetVisibleToRow();
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C TInt CGridLay::RowHeightOfSelectedInTwips() const
+/** Gets the height of rows in the selected region.
+
+@return The row height, in twips, if all rows in the selected region have
+the same width; -1, otherwise.
+@panic GRIDIMG 3 If this grid layout object has no grid image object. */
+ {
+ __ASSERT_DEBUG(iGridImg!=NULL,Panic(EGridLayInvalidGridImg));
+ if (IsUniformRowHeight())
+ return DefaultRowHeightInTwips();
+ const CGridCellRegion* selected=iGridImg->Selected();
+ TInt count=selected->Count();
+ if (!count)
+ return RowHeightInTwips(iGridImg->CursorPos().iRow);
+ if (selected->IsAnyColSelected())
+ return iRowHeightMap->Count() ? -1 : DefaultRowHeightInTwips();
+
+ TInt height=RowHeightInTwips((*selected)[count-1].iFrom.iRow);
+ for (TInt ii=0;ii<count;ii++)
+ {
+ TRangeRef range=(*selected)[ii];
+ for (;range.iFrom.iRow<=range.iTo.iRow;range.iFrom.iRow++)
+ {
+ if (RowHeightInTwips(range.iFrom.iRow)!=height)
+ return -1; //Inconsistent heights
+ }
+ }
+ return height;
+ }
+
+EXPORT_C void CGridLay::SetRowHeightOfSelectedInTwipsL(TInt aHeightInTwips)
+/** Sets the heights of all rows in the selected region to the specified value.
+
+@param aHeightInTwips The row height, in twips.
+@panic GRIDIMG 3 If this grid layout object has no grid image object. */
+ {
+ __ASSERT_DEBUG(iGridImg!=NULL,Panic(EGridLayInvalidGridImg));
+ const CGridCellRegion* selected=iGridImg->Selected();
+ if (selected->IsAnyColSelected() || IsUniformRowHeight())
+ {
+ iRowHeightMap->ResetArray();
+ SetDefaultRowHeightInTwips(aHeightInTwips);
+ }
+ else
+ {
+ TInt count=selected->Count();
+ if (!count)
+ SetRowHeightInTwipsL(iGridImg->CursorPos().iRow,aHeightInTwips);
+ for (TInt ii=0;ii<count;ii++)
+ {
+ TRangeRef range=(*selected)[ii];
+ if ((range.iTo.iRow-range.iFrom.iRow)>EMaxArrayChanges)
+ continue;
+ for (;range.iFrom.iRow<=range.iTo.iRow;range.iFrom.iRow++)
+ SetRowHeightInTwipsL(range.iFrom.iRow,aHeightInTwips);
+ }
+ }
+ iHasChanged=ETrue;
+ NotifyPaginationOutOfDateL();
+ }
+
+EXPORT_C void CGridLay::RecalcPixelSparseMaps()
+/** Recalculates the internal maps that map row and column numbers to heights and
+widths respectively.
+
+Heights and widths are held as both pixel and twip values. */
+ {
+ if (!iGraphicsDeviceMap)
+ {
+ const TInt KArbitraryNonZeroValue = 100;
+ iColumnWidthMap->SetDefaultValueInPixels(KArbitraryNonZeroValue); // Must be non-zero else get divide by zero errors
+ iRowHeightMap->SetDefaultValueInPixels(KArbitraryNonZeroValue);
+ return;
+ }
+ TInt defValueInTwips=iColumnWidthMap->DefaultValueInTwips();
+ TInt defValueInPixels=iGraphicsDeviceMap->HorizontalTwipsToPixels(defValueInTwips);
+ if (defValueInPixels==0)
+ defValueInPixels=1; // cannot be zero
+ iColumnWidthMap->SetDefaultValueInPixels(defValueInPixels);
+ TInt end=iColumnWidthMap->Count();
+ {for (TInt ii=0;ii<end;ii++)
+ {
+ TSizeElement& element=(*iColumnWidthMap)[ii];
+ element.iValueInPixels=iGraphicsDeviceMap->HorizontalTwipsToPixels(element.iValueInTwips);
+ }}
+
+ defValueInTwips=iRowHeightMap->DefaultValueInTwips();
+ defValueInPixels=iGraphicsDeviceMap->VerticalTwipsToPixels(defValueInTwips);
+ if (defValueInPixels==0)
+ defValueInPixels=1;
+ iRowHeightMap->SetDefaultValueInPixels(defValueInPixels);
+ end=iRowHeightMap->Count();
+ for (TInt ii=0;ii<end;ii++)
+ {
+ TSizeElement& element=(*iRowHeightMap)[ii];
+ element.iValueInPixels=iGraphicsDeviceMap->VerticalTwipsToPixels(element.iValueInTwips);
+ }
+ }
+
+EXPORT_C void CGridLay::InsertDeleteColumns(TInt aStartCol,TInt aNoOfCols,TFixGridRange aFixGridRange)
+/** Inserts or deletes columns.
+
+Insertion causes columns to be inserted in front of the specified start column.
+Deletion causes columns in front of the specified columns to be deleted.
+
+@param aStartCol The start column.
+@param aNoOfCols The number of columns to be inserted or deleted. A positive
+number means that columns are to be inserted; a negative number means that
+columns are to be deleted.
+@param aFixGridRange Indicates whether the grid boundary is to be adjusted
+by the number of columns (increased or decreased). */
+ {
+ if (aNoOfCols==0)
+ return;
+ if (aFixGridRange==EAdjustGridRange)
+ iGridRange.iTo.iCol+=aNoOfCols;
+ iColumnWidthMap->OpenCloseGap(aStartCol,aNoOfCols,iGridRange.iTo.iCol);
+ if (iGridImg)
+ {
+ iGridImg->ResetReferencePoints();
+ ResetVisibleToColumn();
+ if (aFixGridRange==EAdjustGridRange)
+ iGridImg->NotifyGridRangeResize();
+ }
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::InsertDeleteRows(TInt aStartRow,TInt aNoOfRows,TFixGridRange aFixGridRange)
+/** Inserts or deletes rows.
+
+Insertion causes rows to be inserted below the specified start row. Deletion
+causes rows below the specified row to be deleted.
+
+@param aStartRow The start row.
+@param aNoOfRows The number of rows to be inserted or deleted. A positive number
+means that rows are to be inserted; a negative number means that rows are
+to be deleted.
+@param aFixGridRange Indicates whether the grid boundary is to be adjusted
+by the number of rows (increased or decreased). */
+ {
+ if (aNoOfRows==0)
+ return;
+ if (aFixGridRange==EAdjustGridRange)
+ iGridRange.iTo.iRow+=aNoOfRows;
+ iRowHeightMap->OpenCloseGap(aStartRow,aNoOfRows,iGridRange.iTo.iRow);
+ if (iGridImg)
+ {
+ iGridImg->ResetReferencePoints();
+ ResetVisibleToRow();
+ if (aFixGridRange==EAdjustGridRange)
+ iGridImg->NotifyGridRangeResize();
+ }
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::SetHorizontalGridLines(TBool aState)
+/** Sets whether horizontal grid lines are to be drawn.
+
+@param aState ETrue, if horizontal grid lines are to be drawn; EFalse, otherwise. */
+ {
+ if (aState)
+ iFlags|=EIsHorizontalGridLines;
+ else
+ iFlags&=~EIsHorizontalGridLines;
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::SetVerticalGridLines(TBool aState)
+/** Sets whether vertical grid lines are to be drawn.
+
+@param aState ETrue, if vertical grid lines are to be drawn; EFalse, otherwise. */
+ {
+ if (aState)
+ iFlags|=EIsVerticalGridLines;
+ else
+ iFlags&=~EIsVerticalGridLines;
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::SetSideLabels(TBool aState)
+/** Sets whether side labels are printed.
+
+@param aState ETrue, if side labels are printed; EFalse, otherwise. */
+ {
+ if (aState)
+ iFlags|=EIsSideLabels;
+ else
+ iFlags&=~EIsSideLabels;
+ if (iGridImg)
+ {
+ iGridImg->ResetReferencePoints();
+ ResetVisibleToColumn();
+ }
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::SetTopLabels(TBool aState)
+/** Sets whether top labels are printed.
+
+@param aState ETrue, if top labels are printed; EFalse, otherwise. */
+ {
+ if (aState)
+ iFlags|=EIsTopLabels;
+ else
+ iFlags&=~EIsTopLabels;
+ if (iGridImg)
+ {
+ iGridImg->ResetReferencePoints();
+ ResetVisibleToRow();
+ }
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::SetGridLabelSeparators(TBool aState)
+/** Sets whether label separators are to be drawn.
+
+@param aState ETrue, if label separators are to be drawn; EFalse, otherwise. */
+ {
+ if (aState)
+ iFlags|=EIsGridLabelSeparators;
+ else
+ iFlags&=~EIsGridLabelSeparators;
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::SetColumnBursting(TBool aState)
+/** Sets whether column bursting is to be permitted.
+
+Column bursting occurs when the contents of a cell are too wide; adjacent
+cells are then overwritten, provided they are empty.
+
+@param aState ETrue, if column bursting is to be permitted; EFalse, otherwise. */
+ {
+ if (aState)
+ iFlags|=EIsColumnBursting;
+ else
+ iFlags&=~EIsColumnBursting;
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::SetCursorVisible(TBool aVisible)
+/** Sets whether the cursor is to be visible.
+
+@param aVisible ETrue, if the cursor is to be visible; EFalse, otherwise. */
+ {
+ if (aVisible)
+ iFlags|=EIsCursorVisible;
+ else
+ iFlags&=~EIsCursorVisible;
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::SetHighlightVisible(TBool aVisible)
+/** Sets whether selected cells are to be highlighted.
+
+@param aVisible ETrue, if selected cells are to be highlighted; EFalse, otherwise. */
+ {
+ if (aVisible)
+ iFlags|=EIsHighlightVisible;
+ else
+ iFlags&=~EIsHighlightVisible;
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::SetRowPermanentlySelectedL(TBool aState)
+/** Sets whether rows are to be permanently selected.
+
+@param aState ETrue, if rows are to be permanently selected; EFalse, otherwise. */
+ {
+ if (aState)
+ iFlags|=EIsRowPermanentlySelected;
+ else
+ iFlags&=~EIsRowPermanentlySelected;
+ if (aState && iGridImg)
+ {
+ CGridCellRegion* selected = (CGridCellRegion*)iGridImg->Selected(); //!! Bit naughty
+ selected->Reset();
+ selected->AddRowL(iGridImg->CursorPos().iRow);
+ }
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::SetTitleLinesL(TBool aState)
+/** Sets whether the grid is to have both horizontal and vertical title lines.
+
+@param aState ETrue, if the grid is to have both a horizontal and vertical
+title line; EFalse, otherwise. */
+ {
+ if (!(aState || IsTitleLines()))
+ return; //No change
+ __ASSERT_DEBUG(iGridImg!=NULL,Panic(EGridLayInvalidGridImg));
+ TCellRef cursorPos=(iGridImg->Selected()->Count()) ? iGridImg->AnchorPos() :
+ iGridImg->CursorPos();
+ if (aState)
+ {
+ SetTitleLinesL(cursorPos);
+ }
+ else
+ {
+ TCellRef cell=iVisibleRange.iFrom;
+ if (IsHorizontalTitleLine())
+ cell.iRow=iTitleRange.iTo.iRow;
+ if (IsVerticalTitleLine())
+ cell.iCol=iTitleRange.iTo.iCol;
+ TPoint offset=ExposeCellToTopLeft(cell);
+ iGridImg->ScrollL(offset);
+ if (IsHorizontalTitleLine())
+ iVisibleRange.iFrom.iRow=iTitleRange.iFrom.iRow;
+ if (IsVerticalTitleLine())
+ iVisibleRange.iFrom.iCol=iTitleRange.iFrom.iCol;
+ iFlags&=~(EIsHorizontalTitleLine|EIsVerticalTitleLine);
+ offset=iGridImg->MainPoint(); //Just using offset instead of creating a new TPoint
+ iGridImg->ResetReferencePoints();
+ iGridImg->ClearTitleLineRegionL(offset);
+ }
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::SetTitleLinesL(const TCellRef& aCellRef)
+/** Sets horizontal and vertical title lines at the specified cell.
+
+@param aCellRef The cell reference at which title lines are set.
+@panic GRIDIMG 3 If this grid layout object has no grid image object. */
+ {
+ __ASSERT_DEBUG(iGridImg!=NULL,Panic(EGridLayInvalidGridImg));
+ SetTitleLinesL(EFalse); // must be cleared first
+ if (aCellRef.iRow>iVisibleRange.iFrom.iRow && aCellRef.iRow<=iVisibleRange.iTo.iRow
+ && !IsIndefiniteRowBoundaries())
+ {
+ iFlags|=EIsHorizontalTitleLine;
+ iTitleRange.iFrom.iRow=iVisibleRange.iFrom.iRow;
+ iTitleRange.iTo.iRow=iVisibleRange.iFrom.iRow=aCellRef.iRow;
+ }
+ if (aCellRef.iCol>iVisibleRange.iFrom.iCol && aCellRef.iCol<=iVisibleRange.iTo.iCol)
+ {
+ iFlags|=EIsVerticalTitleLine;
+ iTitleRange.iFrom.iCol=iVisibleRange.iFrom.iCol;
+ iTitleRange.iTo.iCol=iVisibleRange.iFrom.iCol=aCellRef.iCol;
+ }
+ if (IsTitleLines())
+ {
+ iGridImg->ResetReferencePoints();
+ iGridImg->DrawTitleLines();
+ }
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::ToggleTitleLinesL()
+/** Sets title lines on, if they are off; sets title lines off, if they are on. */
+ {
+ SetTitleLinesL(!IsTitleLines());
+ }
+
+void CGridLay::SetIndefiniteRowBoundaries(TBool aState)
+ {
+ if (aState)
+ iFlags|=EIsIndefiniteRowBoundaries;
+ else
+ iFlags&=~EIsIndefiniteRowBoundaries;
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::SetUniformRowHeight(TBool aState)
+/** Sets whether all rows are to have the same height.
+
+@param aState ETrue, if all rows are to have the same height; EFalse, otherwise. */
+ {
+ if (aState)
+ {
+ iFlags|=EIsUniformRowHeight;
+ SetRowHeightsToDefault();
+ }
+ else
+ iFlags&=~EIsUniformRowHeight;
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::SetUniformColumnWidth(TBool aState)
+/** Sets whether all columns are to have the same width.
+
+@param aState ETrue, if all columns are to have the same width; EFalse, otherwise. */
+ {
+ if (aState)
+ {
+ iFlags|=EIsUniformColumnWidth;
+ SetColumnWidthsToDefault();
+ }
+ else
+ iFlags&=~EIsUniformColumnWidth;
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::SetTopLabelDragDisabled(TBool aState)
+/** Sets whether a drag operation on the boundary between two columns is to be
+permitted.
+
+@param aState ETrue, if the drag operation is to be permitted; EFalse, otherwise. */
+ {
+ if (aState)
+ iFlags|=EIsTopLabelDragDisabled;
+ else
+ iFlags&=~EIsTopLabelDragDisabled;
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::SetSideLabelDragDisabled(TBool aState)
+/** Sets whether a drag operation on the boundary between two rows is to be permitted.
+
+@param aState ETrue, if the drag operation is to be permitted; EFalse, otherwise. */
+ {
+ if (aState)
+ iFlags|=EIsSideLabelDragDisabled;
+ else
+ iFlags&=~EIsSideLabelDragDisabled;
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::SetPrintedLabels(TBool aState)
+/** Sets whether labels are printed.
+
+@param aState ETrue if labels are printed; EFalse, otherwise. */
+ {
+ if (aState)
+ iFlags|=EIsPrintedLabels;
+ else
+ iFlags&=~EIsPrintedLabels;
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::SetPrintedGridLines(TBool aState)
+/** Sets whether grid lines are printed.
+
+@param aState ETrue if grid lines are printed; EFalse, otherwise. */
+ {
+ if (aState)
+ iFlags|=EIsPrintedGridLines;
+ else
+ iFlags&=~EIsPrintedGridLines;
+ iHasChanged=ETrue;
+ }
+
+void CGridLay::SetVisibleToRowFullyVisible(TBool aState)
+ {
+ if (aState)
+ iFlags|=EIsVisibleToRowFullyVisible;
+ else
+ iFlags&=~EIsVisibleToRowFullyVisible;
+ }
+
+void CGridLay::SetVisibleToColumnFullyVisible(TBool aState)
+ {
+ if (aState)
+ iFlags|=EIsVisibleToColumnFullyVisible;
+ else
+ iFlags&=~EIsVisibleToColumnFullyVisible;
+ }
+
+EXPORT_C void CGridLay::SetEncroachingCellBorders(TBool aState)
+/** Sets whether encroaching cell borders are permitted.
+
+Encroaching cell borders are where cell borders wider than one pixel are drawn
+inside the cell, as opposed to outside.
+
+@param aState ETrue, if encroaching cells borders are to be permitted; EFalse,
+otherwise. */
+ {
+ if (aState)
+ iFlags|=EIsEncroachingCellBorders;
+ else
+ iFlags&=~EIsEncroachingCellBorders;
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::SetRowSelectionDisabled(TBool aState)
+/** Sets whether row selection is disabled.
+
+@param aState ETrue, if row selection is disabled; EFalse, otherwise. */
+ {
+ if (aState)
+ iFlags|=EIsRowSelectionDisabled;
+ else
+ iFlags&=~EIsRowSelectionDisabled;
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::SetColumnSelectionDisabled(TBool aState)
+/** Sets whether column selection is disabled.
+
+@param aState ETrue, if column selection is disabled; EFalse, otherwise. */
+ {
+ if (aState)
+ iFlags|=EIsColumnSelectionDisabled;
+ else
+ iFlags&=~EIsColumnSelectionDisabled;
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::SetAutoClearGridCells(TBool aState)
+/** Sets whether automatic clearing of grid cells is to be done.
+
+@param aState ETrue, if automatic clearing of grid cells is to be done; EFalse,
+otherwise. */
+ {
+ if (aState)
+ iFlags|=EIsAutoClearGridCells;
+ else
+ iFlags&=~EIsAutoClearGridCells;
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::SetPageBreakLinesHidden(TBool aState)
+/** Sets whether lines marking page breaks are hidden.
+
+@param aState ETrue, if lines marking page breaks are hidden; EFalse, otherwise. */
+ {
+ if (aState)
+ iFlags|=EIsPageBreakLinesHidden;
+ else
+ iFlags&=~EIsPageBreakLinesHidden;
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C TInt CGridLay::RowToYVal(TInt aRow) const
+/** Converts the specified row number to a screen y-coordinate value.
+
+Note that the resulting value may be outside the current grid window.
+
+@param aRow The row number.
+@return The y-coordinate value. */
+ {
+ __ASSERT_DEBUG(iGridImg!=NULL,Panic(EGridLayInvalidGridImg));
+ TInt disp;
+ iRowHeightMap->IdToDisplacement(iVisibleRange.iFrom.iRow,aRow,disp);
+ return (iGridImg->MainPoint().iY+disp);
+ }
+
+EXPORT_C TInt CGridLay::RowToYVal(TInt aStartRow,TInt aEndRow) const
+/** Calculates the relative pixel distance between the two specified rows.
+
+@param aStartRow The row number of the first row.
+@param aEndRow The row number of the second row.
+@return The relative pixel distance. */
+ {
+ TInt disp;
+ iRowHeightMap->IdToDisplacement(aStartRow,aEndRow,disp);
+ return disp;
+ }
+
+EXPORT_C TInt CGridLay::VisibleRowToYVal(TInt aRow) const
+/** Converts the specified visible row number to a screen y-coordinate value.
+
+Note that the resulting value may be outside the current grid window.
+
+@param aRow The row number of the visible row.
+@return The y-coordinate value. Note that this is -1, if the row is not visible. */
+ {
+ if (aRow>iVisibleRange.iTo.iRow)
+ return -1;
+ if (aRow<iVisibleRange.iFrom.iRow)
+ {
+ if (IsHorizontalTitleLine())
+ {
+ if (aRow<iTitleRange.iFrom.iRow || aRow>=iTitleRange.iTo.iRow)
+ return -1;
+ return TitleRowToYVal(aRow);
+ }
+ return -1;
+ }
+ return RowToYVal(aRow);
+ }
+
+EXPORT_C TInt CGridLay::TitleRowToYVal(TInt aTitleRow) const
+/** Calculates the relative pixel distance between the specified row and the first
+title row.
+
+@param aTitleRow The row number.
+@return The relative pixel distance. */
+ {
+ __ASSERT_DEBUG(IsHorizontalTitleLine(),Panic(EGridLayNoTitles));
+ __ASSERT_DEBUG(iGridImg!=NULL,Panic(EGridLayInvalidGridImg));
+ TInt disp;
+ iRowHeightMap->IdToDisplacement(iTitleRange.iFrom.iRow,aTitleRow,disp);
+ return (iGridImg->TitlePoint().iY+disp);
+ }
+
+EXPORT_C TInt CGridLay::ColumnToXVal(TInt aCol) const
+/** Converts the specified column number to a screen x-coordinate value.
+
+Note that the resulting value may be outside the current grid window.
+
+@param aCol The column number.
+@return The column's x-coordinate value.
+@panic GRIDIMG 3 In debug mode, if this grid layout object has no grid image. */
+ {
+ //
+ // Converts the passed column to a relative screen 'X' coordinate.
+ //
+ __ASSERT_DEBUG(iGridImg!=NULL,Panic(EGridLayInvalidGridImg));
+ TInt disp;
+ iColumnWidthMap->IdToDisplacement(iVisibleRange.iFrom.iCol,aCol,disp);
+ return (iGridImg->MainPoint().iX+disp);
+ }
+
+EXPORT_C TInt CGridLay::ColumnToXVal(TInt aStartCol,TInt aEndCol) const
+/** Gets the distance, in pixels, between the two specified columns.
+
+@param aStartCol The first (start) column number.
+@param aEndCol The second (end) column number.
+@return The distance, in pixels. */
+ {
+ TInt disp;
+ iColumnWidthMap->IdToDisplacement(aStartCol,aEndCol,disp);
+ return disp;
+ }
+
+EXPORT_C TInt CGridLay::VisibleColumnToXVal(TInt aCol) const
+/** Converts the specified visible column number to a screen x-coordinate value.
+
+Note that the resulting value may be outside the current grid window.
+
+@param aCol The column number of the visible column.
+@return The x-coordinate value. Note that this is -1, if the column is not
+visible. */
+ {
+ if (aCol>iVisibleRange.iTo.iCol)
+ return -1;
+ if (aCol<iVisibleRange.iFrom.iCol)
+ {
+ if (IsVerticalTitleLine())
+ {
+ if (aCol<iTitleRange.iFrom.iCol || aCol>=iTitleRange.iTo.iCol)
+ return -1;
+ return TitleColumnToXVal(aCol);
+ }
+ return -1;
+ }
+ return ColumnToXVal(aCol);
+ }
+
+EXPORT_C TInt CGridLay::TitleColumnToXVal(TInt aTitleCol) const
+/** Calculates the relative pixel distance between the specified column and the
+first title column.
+
+@param aTitleCol The column number.
+@return The relative pixel distance. */
+ {
+ __ASSERT_DEBUG(IsVerticalTitleLine(),Panic(EGridLayNoTitles));
+ __ASSERT_DEBUG(iGridImg!=NULL,Panic(EGridLayInvalidGridImg));
+ TInt disp;
+ iColumnWidthMap->IdToDisplacement(iTitleRange.iFrom.iCol,aTitleCol,disp);
+ return (iGridImg->TitlePoint().iX+disp);
+ }
+
+EXPORT_C TPoint CGridLay::CellToPoint(const TCellRef &aCell) const
+/** Gets the relative screen coordinates of the top left corner of the specified
+cell.
+
+@param aCell The cell.
+@return The relative screen co-ordinates. */
+ {
+ return TPoint(ColumnToXVal(aCell.iCol),RowToYVal(aCell.iRow));
+ }
+
+EXPORT_C TPoint CGridLay::CellToPoint(const TCellRef &aStartCell,const TCellRef &aEndCell) const
+/** Gets the co-ordinate distance, in pixels, between the specified cells.
+
+@param aStartCell The start cell of the range.
+@param aEndCell The end cell of the range.
+@return The x and y values representing the distance, in pixels, between the
+two columns and the two rows, respectively, that are defined by the two cells. */
+ {
+ return TPoint(ColumnToXVal(aStartCell.iCol,aEndCell.iCol),RowToYVal(aStartCell.iRow,aEndCell.iRow));
+ }
+
+EXPORT_C TPoint CGridLay::TitleCellToPoint(const TCellRef& aTitleCell) const
+/** Gets the relative screen coordinates of the top left corner of the specified
+cell, when title lines are displayed.
+
+@param aTitleCell The cell.
+@return The relative screen co-ordinates.
+@panic GRIDIMG 3 In debug mode, if this grid layout object has no grid image.
+@panic GRIDIMG 4 In debug mode, if there is no horizontal title line and/or
+there is no vertical title line. */
+ {
+ __ASSERT_DEBUG(IsHorizontalTitleLine(),Panic(EGridLayNoTitles));
+ __ASSERT_DEBUG(IsVerticalTitleLine(),Panic(EGridLayNoTitles));
+ __ASSERT_DEBUG(iGridImg!=NULL,Panic(EGridLayInvalidGridImg));
+ TPoint point;
+ iColumnWidthMap->IdToDisplacement(iTitleRange.iFrom.iCol,aTitleCell.iCol,point.iX);
+ iRowHeightMap->IdToDisplacement(iTitleRange.iFrom.iRow,aTitleCell.iRow,point.iY);
+ return point+iGridImg->TitlePoint();
+ }
+
+EXPORT_C TRect CGridLay::CellToRect(const TCellRef& aCell) const
+/** Gets the rectangle that is occupied by the specified cell.
+
+@param aCell The cell.
+@return The occupied rectangle. Note that this excludes the cell's bottom and
+right grid lines. */
+ {
+ TRect rect(CellToPoint(aCell),TSize(0,0));
+ rect.iBr.iX+=ColumnWidthInPixels(aCell.iCol)-1;
+ rect.iBr.iY+=RowHeightInPixels(aCell.iRow)-1;
+ return rect;
+ }
+
+EXPORT_C TInt CGridLay::YValToRow(TInt aYVal) const
+/** Gets the number of the row, limited to the grid boundary, that is on or above
+the specified y-coordinate value.
+
+@param aYVal The y-coordinate value. Note that this may represent a point
+off the visible screen.
+@return The row number, limited to the grid boundary. */
+ {
+ __ASSERT_DEBUG(iGridImg!=NULL,Panic(EGridLayInvalidGridImg));
+ TInt tempYVal = iGridImg->MainPoint().iY;
+ return YValToRow(iVisibleRange.iFrom.iRow,aYVal-tempYVal);
+ }
+
+EXPORT_C TInt CGridLay::YValToRow(TInt aStartRow,TInt aDisp) const
+/** Gets the number of the row that is on or above the specified displacement from
+the specified row.
+
+@param aStartRow The row from which displacement is calculated.
+@param aDisp The displacement, in pixels.
+@return The row number at the specified displacement. */
+ {
+ TInt row;
+ iRowHeightMap->DisplacementToId(aStartRow,aDisp,row);
+ StepRowBackward(row);
+ return(row);
+ }
+
+EXPORT_C TInt CGridLay::YValToTitleRow(TInt aYVal) const
+/** Gets the number of the row that is on or above the specified y-coordinate value
+
+@param aYVal The y-coordinate value. Note that this may represent a point
+off the visible screen.
+@return The row number. Note that this may include the title row. */
+ {
+ __ASSERT_DEBUG(IsHorizontalTitleLine(),Panic(EGridLayNoTitles));
+ __ASSERT_DEBUG(iGridImg!=NULL,Panic(EGridLayInvalidGridImg));
+ TInt tempYVal = iGridImg->TitlePoint().iY;
+ return YValToRow(iTitleRange.iFrom.iRow,aYVal-tempYVal);
+ }
+
+EXPORT_C TInt CGridLay::XValToColumn(TInt aXVal) const
+/** Gets the number of the column, limited to the grid boundary, that is on or
+to the left of the specified x-coordinate value.
+
+@param aXVal The x-coordinate value. Note that this may represent a point
+off the visible screen.
+@return The column number, limited to the grid boundary. */
+ {
+ __ASSERT_DEBUG(iGridImg!=NULL,Panic(EGridLayInvalidGridImg));
+ TInt tempXVal=iGridImg->MainPoint().iX;
+ return XValToColumn(iVisibleRange.iFrom.iCol,aXVal-tempXVal);
+ }
+
+EXPORT_C TInt CGridLay::XValToColumn(TInt aStartCol,TInt aDisp) const
+/** Gets the number of the column that is on or to the left of the specified displacement
+from the specified column.
+
+@param aStartCol The column from which displacement is calculated.
+@param aDisp The displacement, in pixels.
+@return The column number at the specified displacement. */
+ {
+ TInt column;
+ iColumnWidthMap->DisplacementToId(aStartCol,aDisp,column);
+ StepColumnBackward(column);
+ return(column);
+ }
+
+EXPORT_C TInt CGridLay::XValToTitleColumn(TInt aXVal) const
+/** Gets the number of the column that is on or to the left of the specified x-coordinate
+value
+
+@param aXVal The x-coordinate value. Note that this may represent a point
+off the visible screen.
+@return The column number. Note that this may include the title column. */
+ {
+ __ASSERT_DEBUG(IsVerticalTitleLine(),Panic(EGridLayNoTitles));
+ __ASSERT_DEBUG(iGridImg!=NULL,Panic(EGridLayInvalidGridImg));
+ TInt tempXVal=iGridImg->TitlePoint().iX;
+ return XValToColumn(iTitleRange.iFrom.iCol,aXVal-tempXVal);
+ }
+
+EXPORT_C TCellRef CGridLay::PointToCell(const TPoint &aPoint) const
+/** Gets the cell reference of the cell that contains the specified screen co-ordinates.
+
+@param aPoint The screen co-ordinates.
+@return The cell reference. */
+ {
+ return TCellRef(YValToRow(aPoint.iY),XValToColumn(aPoint.iX));
+ }
+
+EXPORT_C TCellRef CGridLay::PointToCell(const TCellRef &aStartCell,const TPoint &aPointDisp) const
+/** Gets the cell reference of the cell that is displaced from the specified cell
+by the specified pixel co-ordinates.
+
+@param aStartCell The cell reference from which the displacement is based.
+@param aPointDisp The displacement.
+@return The cell at the specified displacement. */
+ {
+ return TCellRef(YValToRow(aStartCell.iRow,aPointDisp.iY),XValToColumn(aStartCell.iCol,aPointDisp.iX));
+ }
+
+EXPORT_C TSize CGridLay::TopLeftTitleRangeSize() const
+/** Gets the size of the top left range, if title lines are on.
+
+The top left range is the range of cells formed by the intersection of the
+rows and columns that form the titles.
+
+@return The size of the top left range. */
+ {
+ TSize ret;
+ if (IsHorizontalTitleLine())
+ iRowHeightMap->IdToDisplacement(iTitleRange.iFrom.iRow,iTitleRange.iTo.iRow,ret.iHeight);
+ if (IsVerticalTitleLine())
+ iColumnWidthMap->IdToDisplacement(iTitleRange.iFrom.iCol,iTitleRange.iTo.iCol,ret.iWidth);
+ return ret;
+ }
+
+EXPORT_C TInt CGridLay::YValToNearestRow(TInt aStartRow,TInt aDisp) const
+/** Gets the row that is nearest to the specified displacement from the specified
+row.
+
+@param aStartRow The row on which the displacement is based.
+@param aDisp The displacement value, in pixels.
+@return The nearest row. */
+ {
+ TInt topRow;
+ iRowHeightMap->DisplacementToId(aStartRow,aDisp,topRow);
+ StepRowForward(topRow);
+ TInt topYVal;
+ iRowHeightMap->IdToDisplacement(aStartRow,topRow,topYVal);
+ TInt bottomYVal = topYVal+RowHeightInPixels(topRow);
+ if ((aDisp-topYVal)>=(bottomYVal-aDisp))
+ StepRowForward(++topRow);
+ return (topRow);
+ }
+
+EXPORT_C TInt CGridLay::XValToNearestColumn(TInt aStartCol,TInt aDisp) const
+/** Gets the column that is nearest to the specified displacement from the specified
+column.
+
+@param aStartCol The column on which the displacement is based.
+@param aDisp The displacement value, in pixels.
+@return The nearest column. */
+ {
+ TInt leftCol;
+ iColumnWidthMap->DisplacementToId(aStartCol,aDisp,leftCol);
+ StepColumnForward(leftCol);
+ TInt leftXVal;
+ iColumnWidthMap->IdToDisplacement(aStartCol,leftCol,leftXVal);
+ TInt rightXVal = leftXVal+ColumnWidthInPixels(leftCol);
+ if ((aDisp-leftXVal)>=(rightXVal-aDisp))
+ StepColumnForward(++leftCol);
+ return (leftCol);
+ }
+
+TPoint CGridLay::CalcOffsetBetweenCells(const TCellRef& aCell1,
+ const TCellRef& aCell2) const
+//
+// Returns the scrolling offset required to get from aCell1 to aCell2
+ {
+ TPoint offset;
+ iColumnWidthMap->IdToDisplacement(aCell2.iCol,aCell1.iCol,offset.iX);
+ iRowHeightMap->IdToDisplacement(aCell2.iRow,aCell1.iRow,offset.iY);
+ return offset;
+ }
+
+TInt CGridLay::CalcVisibleFromRowAfterPageScroll(TMoveDirectionAndAmount aPageScroll) const
+//
+// Calculates what iVisibleRange.iFrom.iRow would be after aPageScroll but doesn't actually set it
+ {
+ TInt newFromRow;
+ switch (aPageScroll)
+ {
+ case EMovePageDown:
+ CalcVisibleFromRow(iVisibleRange.iFrom.iRow+1,newFromRow);
+ if (newFromRow>iVisibleRange.iFrom.iRow)
+ newFromRow=iVisibleRange.iFrom.iRow;
+ break;
+ case EMovePageUp:
+ {
+ TInt corr=IsVisibleToRowFullyVisible() ? 0 : 1;
+ corr=(CalcVisibleToRow(iVisibleRange.iTo.iRow-corr,newFromRow)) ? 1 : 0; // correct if fully visible
+ if (newFromRow == iVisibleRange.iTo.iRow)
+ newFromRow = iVisibleRange.iTo.iRow - 1;
+ else
+ CalcVisibleFromRow(newFromRow+corr,newFromRow);
+ if (newFromRow<iVisibleRange.iFrom.iRow)
+ newFromRow=iVisibleRange.iFrom.iRow;
+ }
+ break;
+ default:
+ newFromRow=iVisibleRange.iFrom.iRow;
+ break;
+ }
+ return newFromRow;
+ }
+
+TInt CGridLay::CalcVisibleFromColumnAfterPageScroll(TMoveDirectionAndAmount aPageScroll) const
+ {
+ TInt newFromColumn;
+ switch (aPageScroll)
+ {
+ case EMovePageRight:
+ CalcVisibleFromColumn(iVisibleRange.iFrom.iCol+1,newFromColumn);
+ if (newFromColumn>iVisibleRange.iFrom.iCol)
+ newFromColumn=iVisibleRange.iFrom.iCol;
+ break;
+ case EMovePageLeft:
+ {
+ TInt corr=IsVisibleToColumnFullyVisible() ? 0 : 1;
+ corr=(CalcVisibleToColumn(iVisibleRange.iTo.iCol-corr,newFromColumn)) ? 1 : 0;
+ if (newFromColumn == iVisibleRange.iTo.iCol)
+ newFromColumn = iVisibleRange.iTo.iCol - 1;
+ else
+ CalcVisibleFromColumn(newFromColumn+corr,newFromColumn);
+ if (newFromColumn<iVisibleRange.iFrom.iCol)
+ newFromColumn=iVisibleRange.iFrom.iCol;
+ }
+ break;
+ default:
+ newFromColumn=iVisibleRange.iFrom.iCol;
+ break;
+ }
+ return newFromColumn;
+ }
+
+TCellRef CGridLay::CalcVisibleFromCellAfterPageScroll(TMoveDirectionAndAmount aPageScroll) const
+ {
+ return TCellRef(CalcVisibleFromRowAfterPageScroll(aPageScroll),
+ CalcVisibleFromColumnAfterPageScroll(aPageScroll));
+ }
+
+void CGridLay::CalcVisibleFromRow(TInt aVisibleToRow,TInt& aNewVisibleFromRow) const
+ {
+ //
+ // Calculates what the VisibleRange.iFrom.iRow would be for a given
+ // VisibleRange.iTo.iRow.
+ //
+ __ASSERT_DEBUG(iGridImg!=NULL,Panic(EGridLayInvalidGridImg));
+ TInt disp=-iGridImg->MainRect().Height()-1;
+ iRowHeightMap->DisplacementToId(aVisibleToRow,disp,aNewVisibleFromRow);
+ aNewVisibleFromRow++;
+ if (IsIndefiniteRowBoundaries())
+ {
+ if (!RequestRow(aNewVisibleFromRow,aNewVisibleFromRow))
+ aNewVisibleFromRow=aVisibleToRow;
+ }
+ else
+ aNewVisibleFromRow=Max(aNewVisibleFromRow,MinVisibleFromRow());
+ StepRowForward(aNewVisibleFromRow);
+ }
+
+TBool CGridLay::CalcVisibleToRow(TInt aVisibleFromRow,TInt& aNewVisibleToRow) const
+ {
+ __ASSERT_DEBUG(iGridImg!=NULL,Panic(EGridLayInvalidGridImg));
+ TInt disp=iGridImg->MainRect().Height()+1;
+ TBool isExactDisp=iRowHeightMap->DisplacementToId(aVisibleFromRow,disp,aNewVisibleToRow);
+ if (isExactDisp)
+ aNewVisibleToRow--;
+ if (IsIndefiniteRowBoundaries())
+ {
+ if (RequestRow(TInt(aNewVisibleToRow-1),aNewVisibleToRow))
+ aNewVisibleToRow++;
+ else
+ aNewVisibleToRow=aVisibleFromRow;
+ }
+ else
+ aNewVisibleToRow=Min(aNewVisibleToRow,iGridRange.iTo.iRow+1);
+ return isExactDisp;
+ }
+
+void CGridLay::CalcVisibleFromColumn(TInt aVisibleToCol,TInt& aNewVisibleFromCol) const
+ {
+ //
+ // Calculates what the VisibleRange.iFrom.iCol would be for a given
+ // VisibleRange.iTo.iCol.
+ //
+ __ASSERT_DEBUG(iGridImg!=NULL,Panic(EGridLayInvalidGridImg));
+ TInt disp=-iGridImg->MainRect().Width()-1;
+ iColumnWidthMap->DisplacementToId(aVisibleToCol,disp,aNewVisibleFromCol);
+ aNewVisibleFromCol++;
+ aNewVisibleFromCol=Max(aNewVisibleFromCol,MinVisibleFromColumn());
+ StepColumnForward(aNewVisibleFromCol); //Guarantees to be on a non-zero width column
+ }
+
+TBool CGridLay::CalcVisibleToColumn(TInt aVisibleFromCol,TInt& aNewVisibleToCol) const
+ {
+ __ASSERT_DEBUG(iGridImg!=NULL,Panic(EGridLayInvalidGridImg));
+ TInt disp=iGridImg->MainRect().Width()+1;
+ TBool isExactDisp=iColumnWidthMap->DisplacementToId(aVisibleFromCol,disp,aNewVisibleToCol);
+ if (isExactDisp)
+ aNewVisibleToCol--;
+ aNewVisibleToCol=Min(aNewVisibleToCol,iGridRange.iTo.iCol+1);
+ return isExactDisp;
+ }
+
+EXPORT_C void CGridLay::ResetVisibleToRow()
+//
+// Resets iVisibleRange.iTo.iRow given iVisibleRange.iFrom.iRow.
+/** Resets the row number of the row that should be visible at the bottom of the
+visible area of the grid. */
+ {
+ if (!iGridImg)
+ return;
+ TBool isExactDisp=CalcVisibleToRow(iVisibleRange.iFrom.iRow,iVisibleRange.iTo.iRow);
+ SetVisibleToRowFullyVisible(isExactDisp);
+ }
+
+EXPORT_C void CGridLay::ResetVisibleToColumn()
+/** Resets the column number of the column visible at the right of the visible
+area of the grid. */
+ {
+ if (!iGridImg)
+ return;
+ TBool isExactDisp=CalcVisibleToColumn(iVisibleRange.iFrom.iCol,iVisibleRange.iTo.iCol);
+ SetVisibleToColumnFullyVisible(isExactDisp);
+ }
+
+EXPORT_C void CGridLay::ResetVisibleToCell()
+/** Resets the row and column numbers visible at the bottom, and to the right,
+of the visible area of the grid. */
+ {
+ ResetVisibleToRow();
+ ResetVisibleToColumn();
+ }
+
+TBool CGridLay::IsCellOutOfVisibleRange(const TCellRef &aCell) const
+//
+// Return ETrue if aCell is outside the visible grid (including title range)
+ {
+ if (aCell.iRow>=iVisibleRange.iTo.iRow || aCell.iCol>=iVisibleRange.iTo.iCol)
+ return ETrue;
+ if (aCell.iRow<iVisibleRange.iFrom.iRow)
+ {
+ TBool inRange=EFalse;
+ if (IsHorizontalTitleLine())
+ {
+ if (aCell.iRow<iTitleRange.iTo.iRow && aCell.iRow>=iTitleRange.iFrom.iRow)
+ inRange=ETrue;
+ }
+ if (!inRange)
+ return ETrue;
+ }
+ if (aCell.iCol<iVisibleRange.iFrom.iCol)
+ {
+ TBool inRange=EFalse;
+ if (IsVerticalTitleLine())
+ {
+ if (aCell.iCol<iTitleRange.iTo.iCol && aCell.iCol>=iTitleRange.iFrom.iCol)
+ inRange=ETrue;
+ }
+ if (!inRange)
+ return ETrue;
+ }
+ return EFalse;
+ }
+
+TBool CGridLay::IsCellOutOfGridRange(const TCellRef& aCell) const
+// Similar to LimitCell but Doesn't alter aCell
+ {
+ TCellRef cell=aCell;
+ return !LimitCell(cell);
+ }
+
+TBool CGridLay::LimitRow(TInt &aRow) const
+ {
+ TInt newRow;
+ TBool ret=RequestRow(aRow,newRow);
+ if (ret)
+ {
+ if (newRow<aRow)
+ StepRowBackward(newRow);
+ else if (newRow>aRow)
+ StepRowForward(newRow);
+ }
+ aRow=newRow;
+ return ret;
+ }
+
+TBool CGridLay::LimitColumn(TInt &aCol) const
+ {
+ if (iGridRange.iFrom.iCol>iGridRange.iTo.iCol)
+ return EFalse;
+ LimitColumn(aCol,iGridRange.iFrom.iCol,iGridRange.iTo.iCol);
+ return ETrue;
+ }
+
+void CGridLay::LimitRow(TInt& aRow,TInt aLowerLimit,TInt aUpperLimit) const
+ {
+ if (aRow>aUpperLimit)
+ {
+ aRow=aUpperLimit;
+ StepRowBackward(aRow);
+ }
+ else if (aRow<aLowerLimit)
+ {
+ aRow=aLowerLimit;
+ StepRowForward(aRow);
+ }
+ }
+
+void CGridLay::LimitColumn(TInt& aCol,TInt aLowerLimit,TInt aUpperLimit) const
+ {
+ if (aCol>aUpperLimit)
+ {
+ aCol=aUpperLimit;
+ StepColumnBackward(aCol);
+ if (aCol<aLowerLimit)
+ aCol=aLowerLimit;
+ }
+ else if (aCol<aLowerLimit)
+ {
+ aCol=aLowerLimit;
+ StepColumnForward(aCol);
+ if (aCol>aUpperLimit)
+ aCol=aUpperLimit;
+ }
+ }
+
+TBool CGridLay::LimitCell(TCellRef &aCell) const
+// Keeps the cell within the grid boundary. Returns EFalse if unable to do so
+ {
+ TBool canLimitRow=LimitRow(aCell.iRow);
+ return (LimitColumn(aCell.iCol) && canLimitRow);
+ }
+
+/*EXPORT_C void CGridLay::LimitCell(TCellRef &aCell,const TRangeRef &aLimitRange) const
+ {
+ LimitRow(aCell.iRow,aLimitRange.iFrom.iRow,aLimitRange.iTo.iRow);
+ LimitColumn(aCell.iCol,aLimitRange.iFrom.iCol,aLimitRange.iTo.iCol);
+ }*/
+
+void CGridLay::LimitRowToVisible(TInt& aRow) const
+ {
+ if (IsIndefiniteRowBoundaries())
+ LimitRow(aRow);
+ else
+ {
+ TInt minRow=MinVisibleFromRow();
+ if (minRow>iGridRange.iTo.iRow)
+ {
+ aRow=minRow;
+ return;
+ }
+ LimitRow(aRow,minRow,iGridRange.iTo.iRow);
+ }
+ }
+
+void CGridLay::LimitColumnToVisible(TInt& aCol) const
+ {
+ TInt minCol=MinVisibleFromColumn();
+ if (minCol>iGridRange.iTo.iCol)
+ {
+ aCol=minCol;
+ return;
+ }
+ LimitColumn(aCol,minCol,iGridRange.iTo.iCol);
+ }
+
+void CGridLay::LimitCellToVisible(TCellRef& aCell) const
+ {
+ LimitRowToVisible(aCell.iRow);
+ LimitColumnToVisible(aCell.iCol);
+ }
+
+void CGridLay::StepRowForward(TInt& aRow) const
+// Steps row forward to the nearest non zero row
+ {
+ for (;!RowHeightInPixels(aRow);aRow++)
+ ;
+ }
+
+void CGridLay::StepRowBackward(TInt& aRow) const
+ {
+ for (;!RowHeightInPixels(aRow);aRow--)
+ ;
+ }
+
+void CGridLay::StepColumnForward(TInt& aCol) const
+ {
+ for (;!ColumnWidthInPixels(aCol);aCol++)
+ ;
+ }
+
+void CGridLay::StepColumnBackward(TInt& aCol) const
+ {
+ for (;!ColumnWidthInPixels(aCol);aCol--)
+ ;
+ }
+
+EXPORT_C TInt CGridLay::MinVisibleFromRow() const
+/** Gets the number of the topmost row visible in the grid.
+
+@return The row number if successful else KErrUnknown. */
+ {
+ TInt minRow;
+ if (IsIndefiniteRowBoundaries())
+ {
+ if(!RequestRow(-KMaxTInt,minRow)) // Result is undefined if request row is false
+ {
+ return KErrUnknown;
+ }
+ }
+ else
+ minRow=(IsHorizontalTitleLine())?iTitleRange.iTo.iRow:iGridRange.iFrom.iRow;
+ StepRowForward(minRow);
+ return minRow;
+ }
+
+EXPORT_C TInt CGridLay::MinVisibleFromColumn() const
+/** Gets the number of the leftmost column visible in the grid.
+
+@return The column number. */
+ {
+ TInt minCol=(IsVerticalTitleLine())?iTitleRange.iTo.iCol:iGridRange.iFrom.iCol;
+ StepColumnForward(minCol);
+ return minCol;
+ }
+
+EXPORT_C void CGridLay::PaginateL()
+/** Paginates the grid.
+
+Note that when preparing the grid for printing using a CGridPrinter object,
+then use that object's CGridPrinter::PaginateL() function instead. */
+ {
+ if (IsPaginated() || !iGraphicsDeviceMap)
+ return;
+ __ASSERT_DEBUG(iRowPageMap==NULL && iColumnPageMap==NULL,Panic(EGridLayPageMapAlreadyExists));
+ iRowPageMap = CSparseMap::NewL();
+ iColumnPageMap = CSparseMap::NewL();
+
+ __ASSERT_DEBUG(iPageSizeInTwips.iWidth!=0 && iPageSizeInTwips.iHeight!=0,
+ Panic(EGridLayNoPageSizeSet));
+ TPoint pageSizeInPixels=iGraphicsDeviceMap->TwipsToPixels(iPageSizeInTwips.AsPoint());
+ if (IsPrintedLabels())
+ {
+ __ASSERT_DEBUG(iGridImg!=NULL,Panic(EGridLayInvalidGridImg));
+ if (IsSideLabels())
+ pageSizeInPixels.iX-=iGridImg->MaxSideLabelWidthInPixels();
+ if (IsTopLabels())
+ pageSizeInPixels.iY-=iGridImg->TopLabelHeightInPixels();
+ }
+ DoMainPaginationLoopL(pageSizeInPixels.iX,iColumnWidthMap,iColumnPageMap,
+ iHardColumnPageBreaks,iGridRange.iFrom.iCol);
+ TInt startRow;
+ if (RequestRow(-KMaxTInt,startRow))
+ {
+ DoMainPaginationLoopL(pageSizeInPixels.iY,iRowHeightMap,iRowPageMap,
+ iHardRowPageBreaks,startRow);
+ }
+ iFlags|=EIsPaginated;
+ iHasChanged=ETrue;
+ }
+
+void CGridLay::DoMainPaginationLoopL(TInt aPageSpan,CSparseMap* aCellSpanMap,CSparseMap* aPageMap,
+ CArrayFix<TInt>* aHardPageBreaks,TInt aStartId)
+ {
+ __ASSERT_DEBUG(aCellSpanMap->DefaultValueInPixels(),Panic(EGridMapDefaultValueIsZero));
+ TInt defIdsPerPage = aPageSpan/aCellSpanMap->DefaultValueInPixels();
+ if (defIdsPerPage==0)
+ defIdsPerPage=1; // Should always print at least 1 row/column per page
+ aPageMap->SetDefaultValueInPixels(defIdsPerPage);//!!!Misleading Units
+ TInt softCount=aCellSpanMap->Count();
+ TInt hardCount=aHardPageBreaks->Count();
+ TInt currPage=0;
+ TInt softPos=0;
+ TInt hardPos=0;
+ while (softPos<softCount || hardPos<hardCount)
+ {
+ TInt nextSoftId=(softPos<softCount) ? (*aCellSpanMap)[softPos].iId : KMaxTInt;
+ if (aStartId>nextSoftId)
+ {
+ softPos++;
+ continue;
+ }
+ TInt nextHardPb=(hardPos<hardCount) ? (*aHardPageBreaks)[hardPos] : KMaxTInt;
+ TInt nextId=Min(nextSoftId,nextHardPb);
+ TInt pageSteps=(nextId-aStartId)/defIdsPerPage;
+ currPage+=pageSteps;
+ aStartId+=(pageSteps*defIdsPerPage);
+ TInt currIdsPerPage;
+ if (nextId==nextHardPb)
+ {
+ if (nextId==aStartId)
+ {
+ hardPos++;
+ continue;
+ }
+ currIdsPerPage=nextId-aStartId;
+ hardPos++;
+ if (nextId==nextSoftId)
+ softPos++;
+ }
+ else
+ {
+ aCellSpanMap->DisplacementToId(aStartId,aPageSpan,currIdsPerPage);
+ currIdsPerPage-=aStartId;
+ if ((aStartId+currIdsPerPage)>nextHardPb)
+ {
+ currIdsPerPage=nextHardPb-aStartId;
+ hardPos++;
+ }
+ if (currIdsPerPage==0)
+ currIdsPerPage=1;
+// softPos++;
+ }
+ if (currIdsPerPage)
+ {
+ aPageMap->SetL(currPage,0/*NotUsed*/,currIdsPerPage);
+ aStartId+=currIdsPerPage;
+ currPage++;
+ }
+ }
+ }
+
+EXPORT_C void CGridLay::ClearPagination()
+/** Marks the grid as unpaginated. */
+ {
+ delete iRowPageMap;
+ iRowPageMap=NULL;
+ delete iColumnPageMap;
+ iColumnPageMap=NULL;
+ iFlags&=~EIsPaginated;
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::NotifyPaginationOutOfDateL()
+/** Notifies this object that repagination must take place.
+
+This function is called as a response to changes in the grid, such as a change
+in the page size, a change to the width of selected columns, the setting or
+removal of hard page breaks etc. */
+ {
+ if (IsPaginated())
+ {
+ ClearPagination();
+ if (IsAutoPagination())
+ PaginateL();
+ }
+ }
+
+EXPORT_C TRangeRef CGridLay::PageToRange(TInt aPageNo,TPageOrder aPageOrder) const
+/** Gets the range of cells that are on the specified page
+
+@param aPageNo The page number. The first page is assumed to be page zero.
+@param aPageOrder The page order.
+@return The range of cells.
+@panic GRIDIMG 5 In debug mode, if the grid has not been paginated. */
+ {
+ __ASSERT_DEBUG(IsPaginated(),Panic(EGridLayNotPaginated));
+ TCellRef pageRef;
+ TInt startRow;
+ if (!RequestRow(-KMaxTInt,startRow))
+ return TRangeRef();
+ TInt rowExtent=RowExtent();
+ TInt colExtent=ColumnExtent();
+ if (aPageOrder==ERightThenDown)
+ {
+ TInt noOfHorzPages;
+ iColumnPageMap->DisplacementToId(0,colExtent-1,noOfHorzPages);
+ noOfHorzPages++;
+ pageRef.iRow=aPageNo/noOfHorzPages;
+ pageRef.iCol=aPageNo-(pageRef.iRow*noOfHorzPages);
+ }
+ else
+ {
+ TInt noOfVertPages;
+ iRowPageMap->DisplacementToId(0,rowExtent-1,noOfVertPages);
+ noOfVertPages++;
+ pageRef.iCol=aPageNo/noOfVertPages;
+ pageRef.iRow=aPageNo-(pageRef.iCol*noOfVertPages);
+ }
+ TRangeRef pageRange;
+ iColumnPageMap->IdToDisplacement(0,pageRef.iCol,pageRange.iFrom.iCol);
+ pageRange.iFrom.iCol+=iGridRange.iFrom.iCol;
+ iRowPageMap->IdToDisplacement(0,pageRef.iRow,pageRange.iFrom.iRow);
+ pageRange.iFrom.iRow+=startRow;
+ pageRange.iTo.iCol=Min(pageRange.iFrom.iCol+iColumnPageMap->ValueInPixels(pageRef.iCol)-1,
+ iGridRange.iFrom.iCol+colExtent-1);
+ pageRange.iTo.iRow=Min(pageRange.iFrom.iRow+iRowPageMap->ValueInPixels(pageRef.iRow)-1,
+ startRow+rowExtent-1);
+ return pageRange;
+ }
+
+EXPORT_C TInt CGridLay::NoOfPages() const
+/** Gets the number of pages that the grid would print to.
+
+@return The number of pages.
+@panic GRIDIMG 5 In debug mode, if the grid has not been paginated. */
+ {
+ __ASSERT_DEBUG(IsPaginated(),Panic(EGridLayNotPaginated));
+ TInt noOfHorzPages;
+ iColumnPageMap->DisplacementToId(0,ColumnExtent()-1,noOfHorzPages);
+ noOfHorzPages++;
+ TInt noOfVertPages;
+ iRowPageMap->DisplacementToId(0,RowExtent()-1,noOfVertPages);
+ noOfVertPages++;
+ return noOfHorzPages*noOfVertPages;
+ }
+
+TBool CGridLay::FindNextRowPageBreak(TInt aSearchStart,TInt& aFoundRow) const
+//
+// Searches from aSearchStart and finds the next row page break (hard or soft). If one is found,
+// aFoundRow is amended and ETrue returned. Note that returned value is 1 less than the value
+// stored because the physical line break belongs to the row above the stored page break.
+ {
+ if (IsPaginated())
+ {
+ TInt startRow;
+ if (!RequestRow(-KMaxTInt,startRow))
+ return EFalse;
+ TInt rowPage;
+ iRowPageMap->DisplacementToId(0,aSearchStart-startRow,rowPage);
+ iRowPageMap->IdToDisplacement(0,rowPage+1,aFoundRow);
+ aFoundRow+=startRow-1;
+ return ETrue;
+ }
+ else
+ {
+ TKeyArrayFix key(0,ECmpTInt);
+ TInt pos;
+ aSearchStart++;
+ if (iHardRowPageBreaks->FindIsq(aSearchStart,key,pos)==0)
+ {
+ aFoundRow=aSearchStart-1;
+ return ETrue;
+ }
+ else if (pos<iHardRowPageBreaks->Count())
+ {
+ aFoundRow=(*iHardRowPageBreaks)[pos]-1;
+ return ETrue;
+ }
+ }
+ return EFalse;
+ }
+
+TBool CGridLay::FindNextColumnPageBreak(TInt aSearchStart,TInt& aFoundCol) const
+//
+// Searches from aSearchStart and finds the next column page break (hard or soft). If one is found,
+// aFoundCol is amended and ETrue returned.
+ {
+ if (IsPaginated())
+ {
+ TInt colPage;
+ iColumnPageMap->DisplacementToId(0,aSearchStart-iGridRange.iFrom.iCol,colPage);
+ iColumnPageMap->IdToDisplacement(0,colPage+1,aFoundCol);
+ aFoundCol+=iGridRange.iFrom.iCol-1;
+ return ETrue;
+ }
+ else
+ {
+ TKeyArrayFix key(0,ECmpTInt);
+ TInt pos;
+ aSearchStart++;
+ if (iHardColumnPageBreaks->FindIsq(aSearchStart,key,pos)==0)
+ {
+ aFoundCol=aSearchStart-1;
+ return ETrue;
+ }
+ else if (pos<iHardColumnPageBreaks->Count())
+ {
+ aFoundCol=(*iHardColumnPageBreaks)[pos]-1;
+ return ETrue;
+ }
+ }
+ return EFalse;
+ }
+
+EXPORT_C void CGridLay::SetPageSizeInTwipsL(const TSize& aPageSize)
+/** Sets the size of a page.
+
+@param aPageSize The size of a page, in twips. */
+ {
+ iPageSizeInTwips=aPageSize;
+ NotifyPaginationOutOfDateL();
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::SetAutoPagination(TBool aState)
+/** Sets whether automatic pagination is to be in effect.
+
+@param aState ETrue, if automatic pagination is to be in effect; EFalse, otherwise. */
+ {
+ if (aState)
+ iFlags|=EIsAutoPagination;
+ else
+ iFlags&=~EIsAutoPagination;
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::SetHardRowPageBreakL(TInt aRow)
+/** Sets a hard page break at the specified row.
+
+Note that pagination will be flagged as being out of date.
+
+@param aRow The row, immediately above which the hard page break is to occur. */
+ {
+ if (IsHardRowPageBreak(aRow))
+ return;
+ TInt startRow;
+ if (!RequestRow(-KMaxTInt,startRow) || aRow==startRow)
+ return;
+ TKeyArrayFix key(0,ECmpTInt);
+ iHardRowPageBreaks->InsertIsqL(aRow,key);
+ NotifyPaginationOutOfDateL();
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::ClearHardRowPageBreakL(TInt aRow)
+/** Removes the hard page break at the specified row.
+
+Note that pagination will be flagged as being out of date.
+
+Note also that there is no harm in calling this function if there is no hard
+page break at the specified row.
+
+@param aRow The row, immediately above which there is a hard page break. */
+ {
+ TKeyArrayFix key(0,ECmpTInt);
+ TInt pos;
+ if (iHardRowPageBreaks->FindIsq(aRow,key,pos)==0)
+ {
+ iHardRowPageBreaks->Delete(pos);
+ NotifyPaginationOutOfDateL();
+ iHasChanged=ETrue;
+ }
+ }
+
+EXPORT_C TBool CGridLay::IsHardRowPageBreak(TInt aRow) const
+/** Tests whether there is a hard page break at the specified row.
+
+@param aRow The row.
+@return True, if there is a hard page break at (i.e. immediately above) the
+specified row; false, otherwise. */
+ {
+ TKeyArrayFix key(0,ECmpTInt);
+ TInt pos;
+ if (iHardRowPageBreaks->FindIsq(aRow,key,pos)==0)
+ return ETrue;
+ return EFalse;
+ }
+
+EXPORT_C void CGridLay::SetHardColumnPageBreakL(TInt aCol)
+/** Sets a hard page break at the specified column.
+
+Note that pagination will be flagged as being out of date.
+
+@param aCol The column, immediately to the left of which the hard page break
+is to occur. */
+ {
+ if (IsHardColumnPageBreak(aCol) || aCol==iGridRange.iFrom.iCol)
+ return;
+ TKeyArrayFix key(0,ECmpTInt);
+ iHardColumnPageBreaks->InsertIsqL(aCol,key);
+ NotifyPaginationOutOfDateL();
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::ClearHardColumnPageBreakL(TInt aCol)
+/** Removes the hard page break at the specified column.
+
+Note that pagination will be flagged as being out of date.
+
+Note also that there is no harm in calling this function if there is no hard
+page break at the specified column.
+
+@param aCol The column, immediately to the left of which there is a hard page
+break. */
+ {
+ TKeyArrayFix key(0,ECmpTInt);
+ TInt pos;
+ if (iHardColumnPageBreaks->FindIsq(aCol,key,pos)==0)
+ {
+ iHardColumnPageBreaks->Delete(pos);
+ NotifyPaginationOutOfDateL();
+ iHasChanged=ETrue;
+ }
+ }
+
+EXPORT_C TBool CGridLay::IsHardColumnPageBreak(TInt aCol) const
+/** Tests whether there is a hard page break at the specified column.
+
+@param aCol The column.
+@return True, if there is a hard page break at (i.e. immediately to the left
+of) the specified column; false, otherwise. */
+ {
+ TKeyArrayFix key(0,ECmpTInt);
+ TInt pos;
+ if (iHardColumnPageBreaks->FindIsq(aCol,key,pos)==0)
+ return ETrue;
+ return EFalse;
+ }
+
+EXPORT_C void CGridLay::ClearAllHardPageBreaksL()
+/** Removes all hard page breaks; this includes all row and column page breaks.
+
+Note that pagination will be flagged as being out of date. */
+ {
+ iHardRowPageBreaks->Reset();
+ iHardColumnPageBreaks->Reset();
+ NotifyPaginationOutOfDateL();
+ iHasChanged=ETrue;
+ }
+
+EXPORT_C void CGridLay::ExternalizeL(RWriteStream &aStream) const
+/** Externalises an object of this class to a write stream.
+
+The presence of this function means that the standard templated operator<<()
+can be used to externalise objects of this class.
+
+@param aStream Stream to which the object should be externalised. */
+ {
+ aStream.WriteUint32L(iFlags);
+ aStream << iGridRange;
+ aStream << *iRowHeightMap;
+ aStream << *iColumnWidthMap;
+ aStream << *iHardRowPageBreaks;
+ aStream << *iHardColumnPageBreaks;
+ aStream.WriteInt32L(iMinRowHeightInPixels);
+ aStream.WriteInt32L(iMinColumnWidthInPixels);
+ aStream.WriteInt32L(iPageSizeInTwips.iWidth);
+ aStream.WriteInt32L(iPageSizeInTwips.iHeight);
+ if (IsTitleLines())
+ {
+ aStream << iTitleRange;
+ }
+ aStream << iVisibleRange.iFrom;
+ aStream << iGridEdgeColor;
+ ((CGridLay*)this)->iHasChanged=EFalse;
+ }
+
+EXPORT_C void CGridLay::InternalizeL(RReadStream &aStream)
+/** Internalises an object of this class from a read stream.
+
+The presence of this function means that the standard templated operator>>()
+can be used to internalise objects of this class.
+
+Note that the function has assignment semantics. It replaces the old value
+of the object with a new value read from the read stream.
+
+@param aStream Stream from which the object is to be internalised. */
+ {
+ iFlags = aStream.ReadUint32L();
+ aStream >> iGridRange;
+ if (iGridImg)
+ iGridImg->NotifyGridRangeResize();
+ aStream >> *iRowHeightMap;
+ aStream >> *iColumnWidthMap;
+ aStream >> *iHardRowPageBreaks;
+ aStream >> *iHardColumnPageBreaks;
+ RecalcPixelSparseMaps();
+ iMinRowHeightInPixels=aStream.ReadInt32L();
+ iMinColumnWidthInPixels=aStream.ReadInt32L();
+ iPageSizeInTwips.iWidth=aStream.ReadInt32L();
+ iPageSizeInTwips.iHeight=aStream.ReadInt32L();
+ if (IsPaginated() && iGridImg)
+ {
+ ClearPagination();
+ PaginateL();
+ }
+ if (IsTitleLines())
+ {
+ aStream >> iTitleRange;
+ }
+ if (IsRowPermanentlySelected())
+ SetRowPermanentlySelectedL(ETrue); //To add row to selection region
+ if (iGridImg)
+ iGridImg->ResetReferencePoints();
+ aStream >> iVisibleRange.iFrom;
+ if (iGridImg)
+ {
+ ResetVisibleToCell();
+ iGridImg->CheckSideLabelWidth();
+ }
+ aStream >> iGridEdgeColor;
+ iHasChanged=EFalse;
+ }
+
+EXPORT_C TStreamId CGridLay::StoreL(CStreamStore& aStore) const
+/** Externalises this object to a stream in the specified store.
+
+@param aStore The store in which the stream is to be created and stored.
+@return The Id of the created stream. */
+ {
+ RStoreWriteStream stream;
+ TStreamId streamId = stream.CreateLC(aStore);
+ ExternalizeL(stream);
+ stream.CommitL();
+ CleanupStack::PopAndDestroy();
+ return streamId;
+ }
+
+EXPORT_C void CGridLay::RestoreL(const CStreamStore& aStore,TStreamId aStreamId)
+/** Internalises this object from the specified stream in the specified store.
+
+Note that the function has assignment semantics. It replaces the old value
+of this object with a new value read from the specified stream.
+
+@param aStore The store containing the stream.
+@param aStreamId The Id of the stream from which this object is to be internalised. */
+ {
+ RStoreReadStream stream;
+ stream.OpenLC(aStore,aStreamId);
+ InternalizeL(stream);
+ CleanupStack::PopAndDestroy();
+ }
+
+TBool CGridLay::RequestRow(TInt aRow,TInt& aReturnRow) const
+ {
+ if (IsIndefiniteRowBoundaries())
+ return iGridTable->RequestRow(aRow,aReturnRow);
+ if (aRow<iGridRange.iFrom.iRow)
+ aReturnRow=iGridRange.iFrom.iRow;
+ else if (aRow>iGridRange.iTo.iRow)
+ aReturnRow=iGridRange.iTo.iRow;
+ else
+ aReturnRow=aRow;
+ return iGridRange.iFrom.iRow<=iGridRange.iTo.iRow;
+ }
+
+EXPORT_C TInt CGridLay::RowExtent() const
+/** Gets the number of rows in the range.
+
+@return The number of rows. */
+ {
+ TInt gridRowExtent=iGridRange.iTo.iRow-iGridRange.iFrom.iRow+1;
+ if (gridRowExtent<0)
+ gridRowExtent=KMaxTInt; // In case gridrange is v. large (i.e. indefinite row boundaries)
+ return Min(iGridTable->RowExtent(),gridRowExtent);
+ }
+
+EXPORT_C TInt CGridLay::ColumnExtent() const
+/** Gets the number of columns in the range.
+
+@return The number of columns. */
+ {
+ return Min(iGridTable->ColumnExtent(),iGridRange.iTo.iCol-iGridRange.iFrom.iCol+1);
+ }
+
+//
+
+EXPORT_C TBool MGridTable::RequestRow(TInt /*aRow*/,TInt& /*aReturnRow*/) const
+/** Translates a requested row.
+
+Typically, the function is called by grid before it attempts a redraw in order
+to determine how many rows can be drawn. For example, if a request for row 16
+were to be translated as row 11, then it would imply that there are only 11
+rows in this rowset, and cause grid to draw accordingly.
+
+An implementation must be provided for grids that have indefinite row boundaries.
+
+The default implementation raises a panic.
+
+@param aRow The row to be translated.
+@param aReturnRow On return, the row that corresponds to the requested row.
+@return True, if a row is returned; false, if no rows can be returned.
+@panic GRIDIMG 8 Always raised by the default implementation.*/
+ {
+ Panic(EGridTableInvalidRequestRow);
+ return EFalse;
+ }
+
+EXPORT_C TInt MGridTable::RowExtent() const
+/** Gets the number of rows in the grid.
+
+@return The number of rows in the grid. The default implementation returns
+the value EDefaultRowExtent. */
+ {
+ return EDefaultRowExtent;
+ }
+
+EXPORT_C TInt MGridTable::ColumnExtent() const
+/** Gets the number of columns in the grid.
+
+@return The number of columns in the grid. The default implementation returns
+the value EDefaultColumnExtent. */
+ {
+ return EDefaultColumnExtent;
+ }
+
+// Setting the grid colors
+
+EXPORT_C void CGridLay::SetGridColors(TGridColors aColors)
+/** Sets the collection of colours to be used to draw the grid.
+
+@param aColors The grid colour definitions. */
+ {
+ iColors = aColors;
+ iGridImg->SetGridColors(aColors);
+ }
+
+// Getting the grid colors
+
+EXPORT_C const TGridColors& CGridLay::GridColors() const
+/** Gets the collection of colours used to draw the grid.
+
+@return The grid colour definitions. */
+ {
+ return iColors;
+ }