diff -r 666f914201fb -r 2fe1408b6811 epoc32/include/grdstd.h --- a/epoc32/include/grdstd.h Tue Nov 24 13:55:44 2009 +0000 +++ b/epoc32/include/grdstd.h Tue Mar 16 16:12:26 2010 +0000 @@ -1,1 +1,753 @@ -grdstd.h +// 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 the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members +// which accompanies this distribution, and is available +// at the URL "http://www.symbianfoundation.org/legal/licencesv10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +#if !defined(__GRDSTD_H__) +#define __GRDSTD_H__ + +#if !defined(__E32STD_H__) +#include +#endif +#if !defined(__GDI_H__) +#include +#endif +#if !defined(__GRDCELLS_H__) +#include +#endif +#if !defined(__GRDDEF_H__) +#include +#endif + + + +class MGridTable +/** An interface that can be implemented to provide row and column information. + +Note that for grids that have indefinite row boundaries, an implementation +is mandatory. + +A concrete implementation is passed to a CGridLay object through its CGridLay::ConstructL() +functions or its CGridLay::SetGridTable() function. + +@publishedAll +@released */ + { +public: + enum + { + /** The number of rows returned by the default implementation of RowExtent(). */ + EDefaultRowExtent=20, + /** The number of columns returned by the default implementation of ColumnExtent(). */ + EDefaultColumnExtent=20 + }; +public: + IMPORT_C virtual TBool RequestRow(TInt aRow,TInt& aReturnRow) const;//If used should be derived from + IMPORT_C virtual TInt RowExtent() const; + IMPORT_C virtual TInt ColumnExtent() const; + }; + + +////////////////////////-> + +class TGridColors +/** The grid colour specification. + +An object of this type encapsulates the colours to be used when drawing a +grid cell. + +@publishedAll +@released +@see CGridLabelImg */ + { +public: + IMPORT_C TGridColors(); + IMPORT_C TGridColors(TRgb aForeground, TRgb aBackground, TRgb aLines, TRgb aLabelSeparators); +public: + /** The foreground colour. */ + TRgb iForeground; + /** The background colour. */ + TRgb iBackground; + /** The colour of lines. */ + TRgb iLines; + /** The colour of label separators. */ + TRgb iLabelSeparators; +// TRgb iEdge; + }; +////////////////////////-> + + +class RReadStream; +class RWriteStream; +class CStreamStore; +class CGridImg; +class CSparseMap; + + +class CGridLay : public CBase +/** Handles the layout of a grid, and controls how columns, rows and selections +appear. + +@publishedAll +@released */ + { + friend class CGridImg; +public: + /** Defines the order in which pages are printed. */ + enum TPageOrder + { + /** All pages in a horizontal line are drawn before starting on the next horizontal + line. */ + ERightThenDown, + /** All pages in a vertical line are drawn before starting on the next vertical + line to the right. */ + EDownThenRight + }; + /** Indicates whether the size of the grid should be adjusted when columns and + rows are inserted or deleted. */ + enum TFixGridRange + { + /** The grid range should not be adjusted on insertion or deletion of rows and/or columns. */ + EFixGridRange, + /** The grid range can be adjusted on insertion or deletion of rows and/or columns. */ + EAdjustGridRange + }; +public: + IMPORT_C CGridLay(MGraphicsDeviceMap* aGraphicsDeviceMap); + IMPORT_C void ConstructL(CGridLay* aGridLay,CGridImg* aGridImg);//Constructs Partial Copy + IMPORT_C void ConstructL(const MGridTable *aGridTable,CGridImg *aGridImg,TInt aNoOfRows,TInt aNoOfCols); + IMPORT_C void ConstructL(const MGridTable *aGridTable,CGridImg *aGridImg,TInt aNoOfCols); + IMPORT_C virtual ~CGridLay(); + + IMPORT_C TPoint PageScroll(TMoveDirectionAndAmount aPageScroll); + IMPORT_C TPoint ExposeCell(const TCellRef &aCell); + IMPORT_C TPoint ExposeCellToTopLeft(const TCellRef &aCell); + + IMPORT_C void SetGridImgL(CGridImg* aGridImg); + inline void SetGridTable(const MGridTable* aGridTable); + inline TRangeRef VisibleRange() const; + IMPORT_C void SetVisibleRange(const TCellRef& aTopLeftCell); + inline TRangeRef TitleRange() const; + inline TRangeRef GridRange() const; + IMPORT_C void SetGraphicsDeviceMap(MGraphicsDeviceMap* aGraphicsDeviceMap); + IMPORT_C void SetGridToDefault(); + + IMPORT_C TInt ColumnWidthInTwips(TInt aCol) const; + IMPORT_C void SetColumnWidthInTwipsL(TInt aCol,TInt aWidthInTwips); + IMPORT_C TInt SetColumnWidthInTwipsL(TInt aStartCol,TInt aEndCol,TInt aWidthInTwips); + IMPORT_C TInt DefaultColumnWidthInTwips() const; + IMPORT_C void SetDefaultColumnWidthInTwips(TInt aWidthInTwips); + IMPORT_C void SetColumnWidthsToDefault(); + IMPORT_C TInt MinColumnWidthInPixels() const; + IMPORT_C void SetMinColumnWidthInPixels(TInt aWidthInPixels); + IMPORT_C TInt ColumnWidthOfSelectedInTwips() const; + IMPORT_C void SetColumnWidthOfSelectedInTwipsL(TInt aWidthInTwips); + IMPORT_C TInt RowHeightInTwips(TInt aRow) const; + IMPORT_C void SetRowHeightInTwipsL(TInt aRow,TInt aHeightInTwips); + IMPORT_C TInt SetRowHeightInTwipsL(TInt aStartRow,TInt aEndRow,TInt aHeightInTwips); + IMPORT_C TInt DefaultRowHeightInTwips() const; + IMPORT_C void SetDefaultRowHeightInTwips(TInt aHeightInTwips); + IMPORT_C void SetRowHeightsToDefault(); + IMPORT_C TInt MinRowHeightInPixels() const; + IMPORT_C void SetMinRowHeightInPixels(TInt aHeightInPixels); + IMPORT_C TInt RowHeightOfSelectedInTwips() const; + IMPORT_C void SetRowHeightOfSelectedInTwipsL(TInt aHeightInTwips); + IMPORT_C void RecalcPixelSparseMaps(); + IMPORT_C void InsertDeleteColumns(TInt aStartCol,TInt aNoOfCols, + TFixGridRange aFixGridRange=EFixGridRange); + IMPORT_C void InsertDeleteRows(TInt aStartRow,TInt aNoOfRows, + TFixGridRange aFixGridRange=EFixGridRange); + + inline TBool IsSideLabels() const; + IMPORT_C void SetSideLabels(TBool aState); + inline TBool IsTopLabels() const; + IMPORT_C void SetTopLabels(TBool aState); + inline TBool IsVerticalGridLines() const; + IMPORT_C void SetVerticalGridLines(TBool aState); + inline TBool IsHorizontalGridLines() const; + IMPORT_C void SetHorizontalGridLines(TBool aState); + inline TBool IsGridLabelSeparators() const; + IMPORT_C void SetGridLabelSeparators(TBool aState); + inline TBool IsColumnBursting() const; + IMPORT_C void SetColumnBursting(TBool aState); + inline TBool IsCursorVisible() const; + IMPORT_C void SetCursorVisible(TBool aVisible); + inline TBool IsHighlightVisible() const; + IMPORT_C void SetHighlightVisible(TBool aVisible); + inline TBool IsRowPermanentlySelected() const; + IMPORT_C void SetRowPermanentlySelectedL(TBool aState); + inline TBool IsTitleLines() const; + inline TBool IsHorizontalTitleLine() const; + inline TBool IsVerticalTitleLine() const; + IMPORT_C void SetTitleLinesL(TBool aState); + IMPORT_C void SetTitleLinesL(const TCellRef& aCellRef); + IMPORT_C void ToggleTitleLinesL(); + inline TBool IsIndefiniteRowBoundaries() const; + inline TBool IsUniformRowHeight() const; + IMPORT_C void SetUniformRowHeight(TBool aState); + inline TBool IsUniformColumnWidth() const; + IMPORT_C void SetUniformColumnWidth(TBool aState); + inline TBool IsTopLabelDragDisabled() const; + IMPORT_C void SetTopLabelDragDisabled(TBool aState); + inline TBool IsSideLabelDragDisabled() const; + IMPORT_C void SetSideLabelDragDisabled(TBool aState); + inline TBool IsPrintedLabels() const; + IMPORT_C void SetPrintedLabels(TBool aState); + inline TBool IsPrintedGridLines() const; + IMPORT_C void SetPrintedGridLines(TBool aState); + inline TBool IsEncroachingCellBorders() const; + IMPORT_C void SetEncroachingCellBorders(TBool aState); + inline TBool IsRowSelectionDisabled() const; + IMPORT_C void SetRowSelectionDisabled(TBool aState); + inline TBool IsColumnSelectionDisabled() const; + IMPORT_C void SetColumnSelectionDisabled(TBool aState); + inline TBool IsAutoClearGridCells() const; + IMPORT_C void SetAutoClearGridCells(TBool aState); + inline TBool IsPageBreakLinesHidden() const; + IMPORT_C void SetPageBreakLinesHidden(TBool aState); + inline TBool HasChanged() const; + inline void SetHasChanged(TBool aHasChanged); + inline void SetGridEdgeColor(TRgb aColor); + + IMPORT_C TInt MinVisibleFromRow() const; + IMPORT_C TInt MinVisibleFromColumn() const; + IMPORT_C void ResetVisibleToRow(); + IMPORT_C void ResetVisibleToColumn(); + IMPORT_C void ResetVisibleToCell(); + IMPORT_C TInt RowExtent() const; + IMPORT_C TInt ColumnExtent() const; + + IMPORT_C TInt RowToYVal(TInt aRow) const; + IMPORT_C TInt RowToYVal(TInt aStartRow,TInt aEndRow) const; + IMPORT_C TInt VisibleRowToYVal(TInt aRow) const; + IMPORT_C TInt TitleRowToYVal(TInt aTitleRow) const; + IMPORT_C TInt ColumnToXVal(TInt aCol) const; + IMPORT_C TInt ColumnToXVal(TInt aStartCol,TInt aEndCol) const; + IMPORT_C TInt VisibleColumnToXVal(TInt aCol) const; + IMPORT_C TInt TitleColumnToXVal(TInt aTitleCol) const; + IMPORT_C TInt YValToRow(TInt aYVal) const; + IMPORT_C TInt YValToRow(TInt aStartRow,TInt aDisp) const; + IMPORT_C TInt YValToTitleRow(TInt aYVal) const; + IMPORT_C TInt XValToColumn(TInt aXVal) const; + IMPORT_C TInt XValToColumn(TInt aStartCol,TInt aDisp) const; + IMPORT_C TInt XValToTitleColumn(TInt aXVal) const; + IMPORT_C TCellRef PointToCell(const TPoint &aPoint) const; + IMPORT_C TCellRef PointToCell(const TCellRef &aStartCell,const TPoint &aPointDisp) const; + IMPORT_C TPoint CellToPoint(const TCellRef &aCell) const; + IMPORT_C TPoint CellToPoint(const TCellRef &aStartCell,const TCellRef &aEndCell) const; + IMPORT_C TPoint TitleCellToPoint(const TCellRef& aTitleCell) const; + IMPORT_C TRect CellToRect(const TCellRef& aCell) const; + IMPORT_C TInt YValToNearestRow(TInt aStartRow,TInt aDisp) const; + IMPORT_C TInt XValToNearestColumn(TInt aStartCol,TInt aDisp) const; + IMPORT_C TSize TopLeftTitleRangeSize() const; + + IMPORT_C void PaginateL(); + IMPORT_C void ClearPagination(); + IMPORT_C void NotifyPaginationOutOfDateL(); + inline TBool IsPaginated() const; + IMPORT_C TRangeRef PageToRange(TInt aPageNo,TPageOrder aPageOrder) const; + inline void SetPrintRange(const TRangeRef& aPrintRange); + IMPORT_C TInt NoOfPages() const; + IMPORT_C void SetPageSizeInTwipsL(const TSize& aPageSize); + inline TSize PageSizeInTwips() const; + inline TBool IsAutoPagination() const; + IMPORT_C void SetAutoPagination(TBool aState); + IMPORT_C TBool IsHardRowPageBreak(TInt aRow) const; + IMPORT_C TBool IsHardColumnPageBreak(TInt aCol) const; + IMPORT_C void SetHardRowPageBreakL(TInt aRow); + IMPORT_C void ClearHardRowPageBreakL(TInt aRow); + IMPORT_C void SetHardColumnPageBreakL(TInt aCol); + IMPORT_C void ClearHardColumnPageBreakL(TInt aCol); + IMPORT_C void ClearAllHardPageBreaksL(); + + IMPORT_C void ExternalizeL(RWriteStream &aStream) const; + IMPORT_C void InternalizeL(RReadStream &aStream); + IMPORT_C TStreamId StoreL(CStreamStore& aStore) const; + IMPORT_C void RestoreL(const CStreamStore& aStore,TStreamId aStreamId); +////////////////////////-> +// Setting the grid colors + IMPORT_C void SetGridColors(TGridColors aColors); +// Getting the grid colors + IMPORT_C const TGridColors& GridColors() const; +////////////////////////-> +private: + void SetIndefiniteRowBoundaries(TBool aState); + inline TBool IsVisibleToRowFullyVisible() const; + void SetVisibleToRowFullyVisible(TBool aState); + inline TBool IsVisibleToColumnFullyVisible() const; + void SetVisibleToColumnFullyVisible(TBool aState); + TInt ColumnWidthInPixels(TInt aCol) const; + void SetColumnWidthInPixelsL(TInt aCol,TInt aWidthInPixels); + void PreCheckColumnWidthChange(TInt aCol,TBool aNonZeroWidth); + void PostCheckColumnWidthChange(TInt aCol,TBool aNonZeroWidth); + TInt DefaultColumnWidthInPixels() const; + void SetDefaultColumnWidthInPixels(TInt aWidthInPixels); + TInt RowHeightInPixels(TInt aRow) const; + void SetRowHeightInPixelsL(TInt aRow,TInt aHeightInPixels); + void PreCheckRowHeightChange(TInt aRow,TBool aNonZeroHeight); + void PostCheckRowHeightChange(TInt aRow,TBool aNonZeroHeight); + TInt DefaultRowHeightInPixels() const; + void SetDefaultRowHeightInPixels(TInt aHeightInPixels); + TPoint CalcOffsetBetweenCells(const TCellRef& aCell1,const TCellRef& aCell2) const; + TBool LimitRow(TInt& aRow) const; + TBool LimitColumn(TInt &aColumn) const; + void LimitRow(TInt& aRow,TInt aLowerLimit,TInt aUpperLimit) const; + void LimitColumn(TInt& aCol,TInt aLowerLimit,TInt aUpperLimit) const; + TBool LimitCell(TCellRef& aCell) const; + void LimitRowToVisible(TInt& aRow) const; + void LimitColumnToVisible(TInt& aCol) const; + void LimitCellToVisible(TCellRef& aCell) const; + TBool IsCellOutOfVisibleRange(const TCellRef &aCell) const; + TBool IsCellOutOfGridRange(const TCellRef& aCell) const; + void StepRowForward(TInt& aRow) const; + void StepRowBackward(TInt& aRow) const; + void StepColumnForward(TInt& aCol) const; + void StepColumnBackward(TInt& aCol) const; + void CalcVisibleFromRow(TInt aVisibleToRow,TInt& aNewVisibleFromRow) const; + TBool CalcVisibleToRow(TInt aVisibleFromRow,TInt& aNewVisibleToRow) const; + void CalcVisibleFromColumn(TInt aVisibleToCol,TInt& aNewVisibleFromCol) const; + TBool CalcVisibleToColumn(TInt aVisibleFromCol,TInt& aNewVisibleToCol) const; + TInt CalcVisibleFromRowAfterPageScroll(TMoveDirectionAndAmount aPageScroll) const; + TInt CalcVisibleFromColumnAfterPageScroll(TMoveDirectionAndAmount aPageScroll) const; + TCellRef CalcVisibleFromCellAfterPageScroll(TMoveDirectionAndAmount aPageScroll) const; + TBool FindNextRowPageBreak(TInt aSearchStart,TInt& aFoundRow) const; + TBool FindNextColumnPageBreak(TInt aSearchStart,TInt& aFoundCol) const; + void DoMainPaginationLoopL(TInt aPageSpan,CSparseMap* aCellSpanMap,CSparseMap* aPageMap, + CArrayFix* aHardPageBreaks,TInt aStartId); + TBool RequestRow(TInt aRow,TInt& aReturnRow) const; + + void ConstructL(const MGridTable *aGridTable,CGridImg *aGridImg,const TRangeRef& aGridRange); +//private: +private: + enum + { + EMaxArrayChanges=256, + EInitialDefaultRowHeightInTwips = 300, + EInitialDefaultColumnWidthInTwips = 900 + }; + enum + { + EIsTopLabels = 0x1, + EIsSideLabels = 0x2, + EIsHorizontalGridLines = 0x4, + EIsVerticalGridLines = 0x8, + EIsColumnBursting = 0x10, + EIsCursorVisible = 0x20, + EIsRowPermanentlySelected = 0x40, + EIsHorizontalTitleLine = 0x80, + EIsVerticalTitleLine = 0x100, + EIsIndefiniteRowBoundaries = 0x200, + EIsUniformRowHeight = 0x400, + EIsUniformColumnWidth = 0x800, + EIsTopLabelDragDisabled = 0x1000, + EIsSideLabelDragDisabled = 0x2000, + EIsPaginated = 0x4000, + EIsAutoPagination = 0x8000, + EIsPrintedLabels = 0x10000, + EIsPrintedGridLines = 0x20000, + EIsVisibleToRowFullyVisible = 0x40000, + EIsVisibleToColumnFullyVisible = 0x80000, + EIsEncroachingCellBorders = 0x100000, + EIsColumnSelectionDisabled = 0x200000, + EIsRowSelectionDisabled = 0x400000, + EIsAutoClearGridCells = 0x800000, + EIsGridLabelSeparators = 0x1000000, + EIsHighlightVisible = 0x2000000, + EIsPageBreakLinesHidden = 0x4000000 + }; +private: + const MGridTable* iGridTable; + const MGraphicsDeviceMap* iGraphicsDeviceMap; //* + CGridImg* iGridImg; //* +// persistent + TRangeRef iGridRange; //* + TRangeRef iVisibleRange; + TRangeRef iTitleRange; + CSparseMap* iColumnWidthMap; //* + CSparseMap* iRowHeightMap; //* + CSparseMap* iColumnPageMap; //* + CSparseMap* iRowPageMap; //* + CArrayFix* iHardRowPageBreaks; + CArrayFix* iHardColumnPageBreaks; + TRgb iGridEdgeColor; + TInt iMinRowHeightInPixels; + TInt iMinColumnWidthInPixels; + TSize iPageSizeInTwips; //* + TUint32 iFlags; //* Starred items are used in printing +////////////////////////-> + TGridColors iColors; +////////////////////////-> +// End of persistent data + TBool iHasChanged; + }; + + + + +class CGridLabelImg : public CBase +/** Draws a grid cell's label. + +@publishedAll +@released */ + { + friend class CGridImg; +public: + IMPORT_C virtual ~CGridLabelImg(); + IMPORT_C void ConstructL(); + inline void SetGraphicsDeviceMap(MGraphicsDeviceMap* aGraphicsDeviceMap); + inline TFontSpec FontSpec() const; + IMPORT_C void ReleaseFont(); + IMPORT_C void NotifyGraphicsDeviceMapChangeL(); + inline void SetGridColors(const TGridColors& aGridColors); +protected: + IMPORT_C CGridLabelImg(const TFontSpec& aFontSpec,MGraphicsDeviceMap* aGraphicsDeviceMap); +////////////////////////-> + IMPORT_C void DrawTopLeftLabelL(CGraphicsContext* aGc,const TRect& aRect, TRgb aColor) const; +////////////////////////-> +private: + /** Draws a row label. + + @publishedAll + @released + @param aGc The graphics context to be used. + @param aRow The row for which the label is to be drawn. + @param aRect The rectangle in which the label is to be drawn. */ + virtual void DrawRowLabelL(CGraphicsContext* aGc,TInt aRow,const TRect& aRect) const=0; + /** Draws a column label. + + @publishedAll + @released + @param aGc The graphics context to be used. + @param aCol The column for which the label is to be drawn. + @param aRect The rectangle in which the label is to be drawn. */ + virtual void DrawColLabelL(CGraphicsContext* aGc,TInt aCol,const TRect& aRect) const=0; + IMPORT_C virtual void DrawTopLeftLabelL(CGraphicsContext* aGc,const TRect& aRect) const; + IMPORT_C virtual TInt SideLabelWidthInPixels(TInt aStartRow,TInt aEndRow) const; + IMPORT_C virtual TInt TopLabelHeightInPixels() const; + IMPORT_C virtual void DrawRowCursorL(CGraphicsContext* aGc,const TRect& aRect) const; +protected: + enum + { + /** The default width of side labels, in twips. + + This is used by the default implementation of SideLabelWidthInPixels(). */ + EDefaultSideLabelWidthInTwips=300, + /** The default height of top labels, in twips. + + This is used by the default implementation of TopLabelHeightInPixels(). */ + EDefaultTopLabelHeightInTwips=300 + }; +protected: + /** The nearest font to that specified in the font specification. */ + CFont* iFont; + /** The font specification in device independent terms. */ + TFontSpec iFontSpec; + /** The graphics device map, an interface for mapping between twips and device-specific + units. */ + MGraphicsDeviceMap* iGraphicsDeviceMap; + /** The grid colour specification. */ + TGridColors iGridColors; +private: + TInt iSpare; + }; + + +class CGridCellImg : public CBase +/** Draws a grid cell's contents. + +@publishedAll +@released */ + { + friend class CGridImg; +public: + IMPORT_C virtual ~CGridCellImg(); + inline TInt BurstColOffset() const; + inline TInt BurstLeft() const; + inline TInt BurstRight() const; + inline TBool IsHorizontalGridLines() const; + inline TBool IsVerticalGridLines() const; + inline void SetGridColors(const TGridColors& aGridColors); +protected: + IMPORT_C CGridCellImg(); +private: + /** Draws the contents of the specified cell. + + @publishedAll + @released + @param aGc The graphics context to be used. + @param aCell The cell whose contents are to be drawn. + @param aDrawRect The rectangle in which the cell is to be drawn. + @param aClipRect The rectangle to which drawing is clipped. */ + virtual void DrawL(CGraphicsContext* aGc,const TCellRef& aCell,const TRect& aDrawRect, + const TRect& aClipRect) const=0; + IMPORT_C virtual TInt DataWidthInPixelsL(const TCellRef& aCell) const; + IMPORT_C virtual TBool DoesCellContainDataL(const TCellRef& aCell) const; +// reserved virtual function + IMPORT_C virtual void Reserved_1(); +private: + void SetBurstingData(TInt aBurstColOffset=0,TInt aBurstLeft=0,TInt aBurstRight=0); +private: + enum { EIsHorizontalGridLines = 0x1, EIsVerticalGridLines = 0x2 }; +protected: + /** The grid colour specification. */ + TGridColors iGridColors; +private: + TInt iBurstColOffset; + TInt iBurstLeft; + TInt iBurstRight; + TUint32 iGridLineFlags; + }; + + +class MGridCursorMoveCallBack +/** An interface to a callback function that is intended to be called whenever +there is a change to the cursor position. + +If such a callback is needed, a concrete implementation is defined, instantiated +and passed to CGridImg::SetCursorMoveCallBack(). + +@publishedAll +@released */ + { +public: + /** Deals with the change to the cursor position. + + This function is called immediately before exiting the following functions: + CGridImg::SetCursorPosL(), CGridImg::SetAnchorPosL(), CGridImg::MoveCursorL(),CGridImg::ResetSelectedL(), + CGridImg::AddRangeToSelectedL(), CGridImg::AddRegionToSelectedL(), CGridImg::AddRowToSelectedL(), + CGridImg::AddColToSelectedL(). + + The function is commonly used to do any necessary redrawing. */ + virtual void HandleCursorMoveL()=0; + }; + +class RWindow; +class CWindowGc; + + +class CGridImg : public CBase +/** Draws the contents of the grid. + +@publishedAll +@released +*/ + { + friend class CGridLay; +public: + enum + { + /** Indicates that the selection state is to be maintained. + + If a region of cells is selected, then this selection is to be kept. + + Typically, this is set by a control when a drag operation is in + progress and the shift modifier key is also pressed. */ + EIsWithSelect=0x0001, + /** Indicates that the control modifier key has been pressed. */ + EIsWithControl=0x0002, + /** Indicates that a drag operation is in progress. */ + EIsWithDrag=0x0004, + /** Indicates that the cursor is the edge of the grid. */ + EIsAtBoundary=0x0008, + /** Indicates that a new cell is being selected, without dragging. */ + EIsAbsoluteMove=0x0010, + /** Indicates that a whole row is selected. */ + EIsRowSelected=0x0020, + /** Indicates that a whole column is selected. + + This also means that the label cell for the column is included in the selection. */ + EIsColumnSelected=0x0040 + }; + enum + { + /** Defines a scale value of 100. + + Scale factor values are divided into this value to calculate + drawing points, rectangles etc. */ + EScaleOneToOne=100 + }; + + enum TSelectType + { + /** Indicates that an existing selected region is to be reset (i.e. emptied) before + adding a new region. */ + ESelectOverwrite, + /** Indicates that a new region is to be appended to any existing selected region. */ + ESelectAppend + }; +public: + IMPORT_C virtual ~CGridImg(); + IMPORT_C static CGridImg* NewL(CGraphicsDevice* aGraphicsDevice,CGridCellImg* aGridCellImg,CGridLay* aGridLay); + IMPORT_C static CGridImg* NewL(CGridCellImg* aGridCellImg,CGridLay* aGridLay); //Creates Partial GridImg + inline void SetGridLay(CGridLay* aGridLay); + inline void SetWindow(RWindow* aWin); +////////////////////////-> + IMPORT_C void SetGridLabelImg(CGridLabelImg* aGridLabelImg); +////////////////////////-> + inline void SetCursorMoveCallBack(MGridCursorMoveCallBack* aCursorMoveCallBack); + inline const CGridCellRegion* Selected() const; + inline const CGridLabelImg* GridLabelImg() const; + + IMPORT_C void ScrollL(const TPoint &aOffset); + IMPORT_C void MoveCursorL(TMoveDirectionAndAmount aCursorMove,TUint aSelectState); + IMPORT_C void SetCursorWithPointerL(const TPoint& aPoint,TUint aFlagList); + IMPORT_C void ResetSelectedL(); + IMPORT_C void AddRangeToSelectedL(const TRangeRef& aRange,TSelectType aType=ESelectOverwrite); + IMPORT_C void AddRegionToSelectedL(const CArrayFix* aCellRegion,TSelectType aType=ESelectOverwrite); + IMPORT_C void AddRowToSelectedL(TInt aRow,TSelectType aType=ESelectOverwrite); + IMPORT_C void AddColToSelectedL(TInt aCol,TSelectType aType=ESelectOverwrite); + IMPORT_C void DrawL(CGraphicsContext* aGc) const; + IMPORT_C void DrawL(CGraphicsContext* aGc,const TRect& aRect) const; + IMPORT_C void DrawCellL(const TCellRef& aCell) const; + IMPORT_C void DrawRangeL(const TRangeRef& aRange) const; + IMPORT_C void DrawSelectedL() const; + IMPORT_C void DrawTitleLines() const; + IMPORT_C void ClearTitleLineRegionL(const TPoint& aCrossPoint) const; + IMPORT_C void PrintGridLinesAndCellsInRangeL(CGraphicsContext* aPrinterGc,const TRangeRef& aRange, + TInt aScaleFactor) const; + + inline TCellRef CursorPos() const; + IMPORT_C void SetCursorPosL(const TCellRef& aCursorPos); + inline TCellRef NewCursorPos() const; + inline TCellRef AnchorPos() const; + IMPORT_C void SetAnchorPosL(const TCellRef& aAnchorPos); + inline TRect GridRect() const; + IMPORT_C void SetGridRect(const TRect& aNewRect); + IMPORT_C void SetPrintGridRect(const TRect& aPrintRect); + inline TPoint TitlePoint() const; + inline TPoint MainPoint() const; + inline TRect MainRect() const; + IMPORT_C void ResetReferencePoints(); + IMPORT_C void NotifyGridRangeResize(); + + IMPORT_C void CheckSideLabelWidthAndScrollL(); + IMPORT_C TInt CheckSideLabelWidth(); + IMPORT_C TInt SideLabelWidthInPixels() const; + IMPORT_C TInt MaxSideLabelWidthInPixels() const; + IMPORT_C TInt TopLabelHeightInPixels() const; + IMPORT_C void FinishLabelDragL(); + IMPORT_C TBool StartLabelDrag(const TPoint &aPoint); + IMPORT_C TBool UpdateLabelDrag(const TPoint &aPoint); + IMPORT_C TBool StartLabelResize(TBool aIsColumnLabel, TInt aIndex); + IMPORT_C TBool UpdateLabelResize(TInt aDelta); + IMPORT_C void FinishLabelResizeL(TBool aResize); +private: + enum TDragDim {EXDrag,EYDrag,ENoDrag}; + enum TRefPoint {ETitleRef,EMainRef}; + enum TDragDraw {EDragDrawWithBitmap,EDragDrawWithoutBitmap}; + enum TArrows {EBothArrows,ESecondArrowOnly}; + enum + { + EIsLabelDraggingIgnored = 0x1, + EIsSidewaysScrollIgnored = 0x2 + }; +private: + void DrawResizingDragHiglights(const TRect& aRect); + void DrawAllGridLabelsL() const; + void DrawTopLeftGridLabelL() const; + void DrawTopGridLabelsL(TInt aStartCol,TInt aEndCol,TRefPoint aXRef=EMainRef) const; + void DrawSideGridLabelsL(TInt aStartRow,TInt aEndRow,TRefPoint aYRef=EMainRef) const; + void DrawSideGridLabelIfOnScreenL(TInt aRow) const; + void DrawAllGridLinesAndCellsL() const; + void DrawGridLinesAndCellsInRangeL(const TRangeRef& aRange,const TRect& aClipRect, + TRefPoint aXRef=EMainRef,TRefPoint aYRef=EMainRef) const; + void DrawCellsToGcL(CGraphicsContext* aGc,const TRangeRef& aRange,const TRect& aClipRect, + const TPoint& aStartPoint,TInt aScaleFactor=EScaleOneToOne) const; + void DrawBurstingCellL(CGraphicsContext* aGc,const TCellRef& aCell,const TRect& aRect,const TRect& aClipRect, + TInt aScaleFactor,TInt aBurstLeft,const TCellRef& aBurstCell) const; + TInt CalcBurstLeftL(TCellRef& aBurstCell,TInt aScaleFactor) const; + TInt CalcBurstRightL(const TCellRef& aCell,TInt aExcessRight,TInt aScaleFactor) const; + void DrawVerticalTitleLine() const; + void DrawHorizontalTitleLine() const; + void BeginRedrawAndDrawL() const; + void BeginRedrawAndDrawL(const TRect& aRect) const; + + void AppendTotalHighlightRegionL(TRegion& aRegion) const; + void AppendPartialHighlightRegionL(TRegion& aRegion,const TRect& aClipRect, + TRefPoint aXRef=EMainRef,TRefPoint aYRef=EMainRef) const; + void RemoveRowLabelFromRegionL(TInt aRow,TRegion& aRegion) const; + void HighlightMinRegionL(const TRegion &aOldRegion,const TRegion &aNewRegion); + void HighlightRegion(const TRegion &aRegion) const; + void HighlightNewRegionFromOldL(const TRegion& aOldRegion); + void DrawCursorOrRegionL(TUint aMoveFlags); + void UpdateSelectedRegion(TInt aSelectCount,TUint aMoveFlags); + void AddLabelToRegionL(TUint aMoveFlags); + void StartSelectedRegionL(TUint aMoveFlags); + TBool ScanColumnsForDrag(TInt aFromColumn,TInt aToColumn,TInt aPointerPos,TInt& aPrevious,TInt& aCurrent); + TBool ScanRowsForDrag(TInt aFromRow,TInt aToRow,TInt aPointerPos,TInt& aPrevious,TInt& aCurrent); + void DrawDraggingHighlight(const TRect aLine,TDragDraw aDragDraw); + void DrawArrowsToInMemoryBitmap(TArrows aArrows); + TPoint RelativeCellToPoint(const TCellRef& aCell,TRefPoint aXRef=EMainRef, + TRefPoint aYRef=EMainRef) const; + TCellRef RelativePointToCell(const TPoint& aPoint,TRefPoint aXRef=EMainRef, + TRefPoint aYRef=EMainRef) const; + TRect PartialCellRectL(const TCellRef& aCell,const TRect& aClipRect, + TRefPoint aXRef=EMainRef,TRefPoint aYRef=EMainRef) const; + TRect PartialRangeRect(const TRangeRef& aRange,const TRect& aClipRect, + TRefPoint aXRef=EMainRef,TRefPoint aYRef=EMainRef) const; + void CreateGc(CGraphicsContext* aGc); + void DeleteGc(); + static void CleanupGc(TAny* aObject); + void ResetGcToDefault(CGraphicsContext* aGc) const; + void ScaleDown(TPoint& aPoint,TInt aScaleFactor) const; + void ConstructSelectedL(const TRangeRef& aGridRange); + + CGridImg(CGraphicsDevice* aGraphicsDevice,CGridCellImg* aGridCellImg,CGridLay* aGridLay); + CGridImg(CGridCellImg* aGridCellImg,CGridLay* aGridLay); + void ConstructL(); + +////////////////////////-> + void SetGridColors(const TGridColors& aGridColors); +////////////////////////-> +private: + TRect iGridRect; + TPoint iTitlePoint; + TPoint iMainPoint; + TCellRef iCursorPos; // Persisted + TCellRef iNewCursorPos; + TCellRef iAnchorPos; + + CGraphicsDevice* iGraphicsDevice; + CGraphicsContext* iGcPtr; + CWindowGc* iGc; + RWindow* iWin; + CGridCellImg* iGridCellImg; //* + CGridLabelImg* iGridLabelImg; //* + CGridLay* iGridLay; //* Starred items are used in printing + CGridCellRegion* iSelected; + MGridCursorMoveCallBack* iCursorMoveCallBack; + TBool iDrawResizeLines; + TInt iDragLabel; + TInt iCurrentDragPos; + TInt iDragDiff; + TInt iDragFlags; + TDragDim iDragDim; + CFbsBitmap* iDragBmp; + TRefPoint iXRefPoint; + TRefPoint iYRefPoint; + }; + + +class TGridUtils +/** A collection of Grid utilities. + +@publishedAll +@released */ + { +public: + IMPORT_C static void FillRect(CGraphicsContext* aGc,TRgb aColor,const TRect &aRect); + }; + + +#include +#endif