/**
 * @file XTPGridRow.h
 *
 * @copyright
 * (c) 1998-2025 Codejock Software, All Rights Reserved.
 *
 * This source file is the property of Codejock Software and must not be
 * redistributed by any means without the explicit written permission of
 * Codejock Software.
 *
 * The use of this source code is governed by the terms and conditions specified
 * in the Toolkit Pro license agreement. Codejock Software grants you, as a
 * single software developer, the limited right to use this software on one
 * computer only.
 *
 * Contact Information:
 * support@codejock.com
 * http://www.codejock.com
 *
 */

/** @cond */
#if !defined(__XTPGRIDROW_H__)
#	define __XTPGRIDROW_H__
/** @endcond */

#	if _MSC_VER > 1000
#		pragma once
#	endif // _MSC_VER > 1000

#	include "Common/Base/Diagnostic/XTPDisableNoisyWarnings.h"

class CXTPGridRecord;
class CXTPGridControl;
class CXTPGridTip;
class CXTPGridRecordItem;
class CXTPGridRows;
class CXTPGridColumn;
class CXTPGridRecordMergeItems;
class CXTPGridSection;

struct XTP_GRIDRECORDITEM_DRAWARGS;
struct XTP_GRIDRECORDITEM_METRICS;
struct XTP_GRIDRECORDITEM_CLICKARGS;

class _XTP_EXT_CLASS CXTPGridRowBase
	: public CXTPCmdTarget
	, public CXTPAccessible
{
};

/**
 * @brief
 * CXTPGridRow class represents a row of the Grid control window.
 * @details
 * Each row item has a corresponding CXTPGridRecord and each CXTPGridRecord
 * could have a list of sub-items associated with it. By clicking a row
 * item, the user can expand and collapse the associated list of sub-items.
 *
 * CXTPGridRow handles the behavior of a grid row. It processes user
 * mouse and keyboard events, implements external control member functions,
 * and handles drawing logic for the row.
 *
 * A collection of grid row items is combined into CXTPGridRows and
 * can be accessed through the CXTPGridControl::GetRows() method.
 * @see
 * CXTPGridControl overview, CXTPGridRows, CXTPGridRecord,
 * CXTPGridRecordItem, CXTPGridGroupRow
 */
class _XTP_EXT_CLASS CXTPGridRow : public CXTPHeapObjectT<CXTPGridRowBase, CXTPGridRowAllocator>
{
	/** @cond */
	DECLARE_INTERFACE_MAP()
	DECLARE_DYNAMIC(CXTPGridRow)
	/** @endcond */
public:
	/**
	 * @brief
	 * Constructs a CXTPGridRow object.
	 */
	CXTPGridRow();

	/**
	 * @brief
	 * Destroys a CXTPGridRow object, handles cleanup and deallocation.
	 */
	virtual ~CXTPGridRow();

public:
	/**
	 * @brief
	 * Performs initial initialization for the current row.
	 * @param pRow     Pointer to the row whose settings will be copied.
	 */
	virtual void InitRow(CXTPGridRow* pRow);
	/**
	 * @brief
	 * Performs initial initialization for the current row.
	 * @param pControl Pointer to the parent Grid control.
	 * @param pSection Pointer to the parent section.
	 * @param pRecord  Pointer to the record associated with the row.
	 */
	virtual void InitRow(CXTPGridControl* pControl, CXTPGridSection* pSection,
						 CXTPGridRecord* pRecord);

	/**
	 * @brief
	 * Gets the record associated with the current row.
	 * @return
	 * A pointer to the record associated with the current row.
	 *
	 * <b>Example:</b>
	 * <pre>CXTPGridRecord* pRecord = pRow->GetRecord();</pre>
	 * @see
	 * CXTPGridRecord overview
	 */
	virtual CXTPGridRecord* GetRecord() const;

	/**
	 * @brief
	 * Draws the current row on the specified device context.
	 * @param pDC         Pointer to the device context in which the drawing occurs.
	 * @param rcRow       Position of the row in client window coordinates.
	 * @param rcClip      Position of the row in client window coordinates.
	 * @param nLeftOffset Left offset of the drawing, in pixels (horizontal scroll position).
	 * @param mergeItems  Reference to the set of merged grid records.
	 * @param nColumnFrom Index of the column to begin drawing.
	 * @param nColumnTo   Index of the column to end drawing.
	 * @details
	 * This function simply prepares data for drawing and calls the necessary
	 * drawing functions from PaintManager to draw a grid item. As such,
	 * you must provide your own implementation of PaintManager in order to
	 * change the appearance of your grid item.
	 * @see
	 * CXTPPaintManager
	 */
	virtual void Draw(CDC* pDC, CRect rcRow, CRect rcClip, int nLeftOffset,
					  CXTPGridRecordMergeItems& mergeItems, int nColumnFrom, int nColumnTo);

	virtual void DrawItemGrid(CDC* pDC, CXTPGridColumn* pColumn, CRect rcGridItem);

	/**
	 * @brief
	 * Calculates the height of the current row depending on
	 * the specified device context.
	 * @param pDC    Pointer to the device context.
	 * @param nWidth Row width.
	 * @details
	 * Row height depends of many factors: provided device context,
	 * font to print text, visibility of rows items. GetHeight()
	 * accounts for all of these factors to get the real height of row.
	 * @return
	 * The height of the row in logical units.
	 */
	virtual int GetHeight(CDC* pDC, int nWidth);

	/**
	 * @brief
	 * Gets the current row index in the view.
	 * @details
	 * GridControl draws row in some order. It depends of Index value
	 * You use GetIndex() to get current index value for particular row
	 * @return
	 * The current row index in the view.
	 */
	virtual int GetIndex() const;

	/**
	 * @brief
	 * Gets the focused state of the current row.
	 * @details
	 * Call this member function if you want to determine whether
	 * the current row is focused in the Grid control or not.
	 * @return
	 * TRUE if the current row is focused, otherwise FALSE.
	 * @see
	 * IsSelected
	 */
	virtual BOOL IsFocused() const;

	/**
	 * @brief
	 * Gets the selected state of the current row.
	 * @details
	 * Call this member function if you want to determine whether
	 * the current row is selected in the Grid control or not.
	 * @return
	 * TRUE if current row is selected, otherwise FALSE.
	 * @see
	 * IsFocused
	 */
	virtual BOOL IsSelected() const;

	/**
	 * @brief
	 * Gets the expanded state of the current row.
	 * @details
	 * Call this member function if you want to determine whether
	 * the current row is expanded in the Grid control or not.
	 * @return
	 * TRUE if the current row is expanded, otherwise FALSE.
	 * @see
	 * SetExpanded
	 */
	virtual BOOL IsExpanded() const;

	/**
	 * @brief
	 * Sets the expanded state for the current row.
	 * @param bExpanded  TRUE to expand the current row.
	 * @param bRecursive TRUE to recursively expand all levels of child rows.
	 * By default, this parameter is FALSE.
	 * @details
	 * Call this member function if you want to expand or collapse the current row.
	 * @see
	 * IsExpanded
	 */
	virtual void SetExpanded(BOOL bExpanded, BOOL bRecursive = FALSE);

	/**
	 * @brief
	 * Sets the expanded state for the current row.
	 * @param bExpanded  TRUE to expand the current row.
	 * @param bRecursive TRUE to recursively expand all levels of child rows.
	 * By default, this parameter is FALSE.
	 * @param bNotify TRUE to send notify message.
	 * @details
	 * Call this member function if you want to expand or collapse the current row.
	 * @see
	 * IsExpanded
	 */
	virtual void _SetExpanded(BOOL bExpanded, BOOL bRecursive, BOOL bNotify);

	/**
	 * @brief
	 * Sets the expanded state for the current row and its children.
	 * @param bExpanded TRUE to expand the current row and its children.
	 * @details
	 * Call this member function if you want to expand or collapse the current row
	 * and its children.
	 */
	void SetFullExpanded(BOOL bExpanded);

	/**
	 * @brief
	 * Determines the visible state of the current row.
	 * @details
	 * Call this member function if you want to determine whether
	 * the current row is visible in the Grid control or not.
	 * @return
	 * TRUE if the current row is visible, otherwise FALSE.
	 * @see
	 * SetVisible
	 */
	virtual BOOL IsVisible() const;

	/**
	 * @brief
	 * Sets the visible state for the current row.
	 * @param bVisible TRUE to set the current row to visible,
	 * FALSE to set the current row to hidden.
	 * @details
	 * Call this member function if you want to show or hide the current row.
	 * @see
	 * IsVisible
	 */
	virtual void SetVisible(BOOL bVisible);

	/**
	 * @brief
	 * Determines if the user's ability to collapse/expand rows is locked.
	 * @return
	 * TRUE if the user's ability to collapse/expand rows is locked.
	 */
	virtual BOOL IsLockExpand() const;

	/**
	 * @brief
	 * Specifies if the user's ability to collapse/expand rows should be locked.
	 *
	 * @param bLockExpand TRUE to lock the user's ability to collapse/expand rows.
	 */
	virtual void LockExpand(BOOL bLockExpand);

	/**
	 * @brief
	 * Sets the selected state for the current row.
	 * @details
	 * If multiple selection is enabled, then this row will be added to the selection.
	 * @param bSelected TRUE to select the row, FALSE to unselect the row.
	 */
	virtual void SetSelected(BOOL bSelected);

	/**
	 * @brief
	 * Selects all child items of the current row.
	 */
	virtual void SelectChilds();

	/**
	 * @brief
	 * Determines if the current row is a group row.
	 * @details
	 * Call this member function if you want to determine whether
	 * the current row is a group row or not.
	 * @return
	 * TRUE if the current row is a group row, otherwise FALSE.
	 */
	virtual BOOL IsGroupRow() const;

	/**
	 * @brief
	 * Determines which grid item, if any, is at a specified point.
	 * @param ptPoint   Point to test.
	 * @param pRectItem Pointer to a CRect object to receive the item rect.
	 * @param ppColumn  Double pointer to a CXTPGridColumn to receive
	 * the column at the specified point.
	 * @details
	 * Call this member function to hit test row contents at a specified point.
	 * @return
	 * The record item at the specified position, if any,
	 * or NULL otherwise.
	 */
	virtual CXTPGridRecordItem* HitTest(CPoint ptPoint, CRect* pRectItem = NULL,
										CXTPGridColumn** ppColumn = NULL) const;

	/**
	 * @brief
	 * Processes single mouse clicks. Called by the framework when
	 * the user has clicked the mouse button in the row area.
	 * @param ptClicked Position of the cursor, in screen coordinates,
	 * at the time of the mouse click.
	 * @details
	 * Call this member function if you want a row to process
	 * a mouse button single click message.
	 * You should provide the method with the coordinates of the
	 * mouse message to proceed.
	 * @see
	 * OnDblClick, OnMouseMove, OnContextMenu
	 */
	virtual void OnClick(CPoint ptClicked);

	/**
	 * @brief
	 * Processes mouse left button down clicks.
	 * @param pClickArgs Pointer to an XTP_GRIDRECORDITEM_CLICKARGS
	 * structure containing click arguments.
	 * @return
	 * TRUE if the implementation handles the mouse click event and no
	 * further handling is required, otherwise FALSE.
	 * @see
	 * OnLButtonUp, OnClick
	 */
	virtual BOOL OnLButtonDown(XTP_GRIDRECORDITEM_CLICKARGS* pClickArgs);

	/**
	 * @brief
	 * Processes mouse left button up clicks.
	 * @param pClickArgs Pointer to an XTP_GRIDRECORDITEM_CLICKARGS
	 * structure containing click arguments.
	 * @return
	 * TRUE if the implementation handles the mouse click event and no
	 * further handling is required, otherwise FALSE.
	 * @see
	 * OnLButtonDown, OnClick
	 */
	virtual BOOL OnLButtonUp(XTP_GRIDRECORDITEM_CLICKARGS* pClickArgs);

	/**
	 * @brief
	 * Processes double mouse clicks. Called by the framework when
	 * the user has double-clicked the mouse button in the row area.
	 * @param ptClicked Position of the cursor, in screen coordinates,
	 * at the time of the mouse click.
	 * @details
	 * Call this member function if you want a row to process
	 * a mouse button double click message.
	 * You should provide the method with the coordinates of the
	 * mouse message to proceed.
	 * @see
	 * OnClick, OnMouseMove, OnContextMenu
	 */
	virtual void OnDblClick(CPoint ptClicked);

	/**
	 * @brief
	 * Processes the move mouse event.
	 * @param nFlags Indicates whether various virtual keys are down.
	 * @param point  Point coordinates where the message was fired from.
	 * @details
	 * Call this member function if you want a row to process
	 * a mouse move message. You should provide the method with the
	 * coordinates of the mouse message to proceed and a flag
	 * showing which of virtual keys were down.
	 * @see
	 * OnClick, OnDblClick, OnContextMenu
	 */
	virtual void OnMouseMove(UINT nFlags, CPoint point);

	/**
	 * @brief
	 * Processes context menu. Called by the framework when the user
	 * has clicked the right mouse button (right clicked) in the window.
	 * @param ptClick Position of the cursor, in screen coordinates,
	 * at the time of the mouse click.
	 * @details
	 * Call this member function if you want a row to process
	 * a mouse right button down (context menu call) message.
	 * You should provide the method with the coordinates of the
	 * mouse message to proceed.
	 * @see
	 * OnClick, OnDblClick, OnMouseMove
	 */
	virtual void OnContextMenu(CPoint ptClick);

	/**
	 * @brief
	 * Shows a specified tooltip window at a specified position.
	 * @param ptTip   Screen position to show the tooltip window at.
	 * @param pTipWnd Pointer to the tooltip window to show.
	 * @details
	 * Call this member function if you want to show a
	 * grid tooltip window for this row.
	 * @see
	 * CXTPGridTip overview
	 */
	virtual void ShowToolTip(CPoint ptTip, CXTPGridTip* pTipWnd);

	/**
	 * @brief
	 * Sets the parent Grid control.
	 * @param pControl Pointer to the parent Grid control to be set.
	 * @details
	 * Call this member function to set a pointer to the
	 * CXTPGridControl which this item belongs to.
	 * @see
	 * CXTPGridControl overview
	 */
	virtual void SetControl(CXTPGridControl* pControl);

	/**
	 * @brief
	 * Gets the parent Grid control.
	 * @details
	 * Call this member function to get a pointer to the
	 * CXTPGridControl which this item belongs to.
	 * @return
	 * A pointer to the parent Grid control object.
	 * @see
	 * CXTPGridControl overview
	 */
	virtual CXTPGridControl* GetControl() const;

	/**
	 * @brief
	 * Gets the parent row of the current row.
	 * @details
	 * When grid rows are arranged as a tree view, this member
	 * function returns a pointer to the parent CXTPGridRow item.
	 * @return
	 * A pointer to the parent row of the current row, if any,
	 * or NULL if the current row does not have a parent row.
	 * @see
	 * HasParent, GetTreeDepth, GetChilds, AddChild, HasChildren
	 */
	virtual CXTPGridRow* GetParentRow() const;

	/**
	 * @brief
	 * Gets the parent rows of the current row.
	 * @details
	 * When grid rows are arranged as a tree view, this member
	 * function returns a pointer to the parent CXTPGridRows item.
	 * @return
	 * A pointer to the parent rows of the current row, if any,
	 * or NULL if the current row does not have parent rows.
	 * @see
	 * HasParent, GetTreeDepth, GetChilds, AddChild, HasChildren
	 */
	virtual CXTPGridRows* GetParentRows() const;

	/**
	 * @brief
	 * Gets the depth of the current row in tree view.
	 * @details
	 * When grid rows are arranged as a tree view, this member function
	 * returns the depth level of the row
	 * (i.e. the number of parent elements for the row.)
	 * @return
	 * The depth of the current row in tree view.
	 * @see
	 * GetParentRow, HasParent, GetChilds, AddChild, HasChildren
	 */
	virtual int GetTreeDepth() const;

	/**
	 * @brief
	 * Determines if a specified row has a parent row in tree view.
	 * @param pRow Pointer to the row to check.
	 * @details
	 * When grid rows are arranged as a tree view, this member function
	 * calculates whether the specified row has a parent row or not.
	 * @return
	 * TRUE if the specified row has a parent, otherwise FALSE.
	 * @see
	 * HasParent, GetParentRow, GetTreeDepth, GetChilds, AddChild, HasChildren
	 */
	virtual BOOL HasParent(CXTPGridRow* pRow);

	/**
	 * @brief
	 * Gets the child collection of the current row.
	 * @param bCreate TRUE to create an empty child collection for the current row
	 * if the current row does not already have a child collection.
	 * @details
	 * Call this member function to retrieve access to the current row's
	 * collection of row children.
	 * @return
	 * A pointer to the child collection of the current row.
	 * @see
	 * CXTPGridRows overview, GetParentRow, HasParent, GetTreeDepth,
	 * AddChild, HasChildren
	 */
	virtual CXTPGridRows* GetChilds(BOOL bCreate = TRUE);

	/**
	 * @brief
	 * Adds a child row to the current row.
	 * @param pRow Pointer to the child row to add.
	 * @details
	 * Call this member function if you want to add a CXTPGridRow object
	 * as a child row for the current row in tree view mode.
	 * @return
	 * A pointer to the newly added child row object.
	 * @see
	 * GetParentRow, HasParent, GetTreeDepth, GetChilds
	 */
	virtual CXTPGridRow* AddChild(CXTPGridRow* pRow);

	/**
	 * @brief
	 * Determines if the current row has child rows in tree view.
	 * @details
	 * When grid rows are arranged as a tree view, this member function
	 * calculates whether the current row has child rows or not.
	 * @return
	 * TRUE if the current row has child rows, otherwise FALSE.
	 * @see
	 * HasParent, GetParentRow, GetTreeDepth, GetChilds, AddChild, HasChildren
	 */
	virtual BOOL HasChildren() const;

	/**
	 * @brief
	 * Gets the next sibling row of the current row.
	 * @details
	 * When grid rows are arranged as a tree view, this member function
	 * returns a pointer to the next CXTPGridRow item.
	 * @return
	 * A pointer to the next sibling row of the current row, if any,
	 * or NULL if the current row does not have a next sibling row.
	 * @see
	 * HasParent, GetTreeDepth, GetChilds, AddChild, HasChildren
	 */
	virtual CXTPGridRow* GetNextSiblingRow() const;

	/**
	 * @brief
	 * Sets the coordinates of the collapse/expand button for the current row.
	 * @param rcCollapse Rectangle in grid window client coordinates.
	 * @details
	 * Call this member function to set the coordinates of the
	 * collapse/expand button for the current row. Note that it could be
	 * different depending on the row tree depth.
	 * @see
	 * GetTreeDepth, GetRect
	 */
	virtual void SetCollapseRect(CRect rcCollapse);

	/**
	 * @brief
	 * Determines if the preview item is visible for the current row.
	 * @return
	 * TRUE if the preview item is visiblefor the current row, otherwise FALSE.
	 * @see
	 * CXTPGridRecordItemPreview overview, CXTPGridRecord::GetItemPreview
	 */
	virtual BOOL IsPreviewVisible() const;

	/**
	 * @brief
	 * Determines if items are visible.
	 * @return
	 * TRUE if items are visible.
	 * @see
	 * IsPreviewVisible
	 */
	virtual BOOL IsItemsVisible() const;

	/**
	 * @brief
	 * Gets the coordinates of the row rectangle.
	 * @return
	 * The coordinates of the row rectangle in grid window client coordinates.
	 * @details
	 * Call this member function to determine the coordinates of the
	 * region where the current row is drawn on the parent window.
	 * @see
	 * SetCollapseRect
	 */
	virtual CRect GetRect() const;

	/**
	 * @brief
	 * Gets the drawing metrics of the current row.
	 * @param pDrawArgs Pointer to an XTP_GRIDRECORDITEM_DRAWARGS
	 * structure for calculating metrics.
	 * @param pItemMetrics Pointer to an XTP_GRIDRECORDITEM_METRICS
	 * @see
	 * XTP_GRIDRECORDITEM_DRAWARGS, XTP_GRIDRECORDITEM_METRICS
	 */
	virtual void GetItemMetrics(XTP_GRIDRECORDITEM_DRAWARGS* pDrawArgs,
								XTP_GRIDRECORDITEM_METRICS* pItemMetrics);

	/**
	 * @brief
	 * Gets the row depth level when the current row is a group row.
	 * @return
	 * The row depth level when the current row is a group row.
	 */
	virtual int GetGroupLevel() const;

	/**
	 * @brief
	 * Gets the rectangle of a specified item.
	 * @param pItem Pointer to a CXTPGridRecordItem object.
	 * @return
	 * The rectangle of the specified item.
	 */
	virtual CRect GetItemRect(CXTPGridRecordItem* pItem);

	/**
	 * @brief
	 * Determine if the current row is the last tree row or is not a part of a tree row.
	 * @return
	 * TRUE if the current row is the last tree row, FALSE if the current row
	 * is either not the last tree row or not a part of a tree row.
	 */
	virtual BOOL IsLastTreeRow() const;

	/**
	 * @brief
	 * Ensures that the current row is visible.
	 * This will cause the Grid control to scroll to this row.
	 * @details
	 * This method is also called by CXTPGridControl::SetFocusedRow
	 * to make the newly focused row visible.
	 */
	virtual void EnsureVisible();

public:
	/**
	 * @brief
	 * Updates the rectangle of an item.
	 * @param rcItem  Reference to the bounding rectangle of the item cell.
	 * @param pColumn Pointer to a CXTPGridColumn object; this column
	 * will be checked to determine if it is a tree column.
	 * @see
	 * CXTPGridColumn::IsTreeColumn
	 */
	virtual void ShiftTreeIndent(CRect& rcItem, CXTPGridColumn* pColumn) const;

	/**
	 * @brief
	 * Fills an XTP_GRIDRECORDITEM_METRICS structure with drawing metrics.
	 * @param pColumn  Pointer to the column of the item.
	 * @param pItem    Pointer to the item to be drawn.
	 * @param pMetrics Pointer to an XTP_GRIDRECORDITEM_METRICS
	 * structure to fill.
	 * @see
	 * GetItemMetrics
	 */
	virtual void FillMetrics(CXTPGridColumn* pColumn, CXTPGridRecordItem* pItem,
							 XTP_GRIDRECORDITEM_METRICS* pMetrics);

	/**
	 * @brief
	 * The framework calls this member function to determine whether a
	 * point is in the bounding rectangle of the specified tool.
	 * @param point Specifies the x- and y-coordinate of the cursor. These
	 * coordinates are always relative to the upper-left corner of the window
	 * @param pTI   A pointer to a TOOLINFO structure.
	 * @return
	 * If the tooltip control was found, the window control ID. If
	 * the tooltip control was not found, -1.
	 */
	virtual INT_PTR OnToolHitTest(CPoint point, TOOLINFO* pTI);

	/**
	 * @brief
	 * Determine the type of the current row (i.e. body, header, or footer).
	 * @return
	 * The type of the current row; one of the values defined by
	 * the XTPGridRowType enumeration.
	 */
	XTPGridRowType GetType() const;

	/**
	 * @brief
	 * Gets the section that the current row belongs to.
	 * @return
	 * A pointer to the section that the current row belongs to.
	 */
	CXTPGridSection* GetSection() const;

	/**
	 * @brief
	 * Determines if the current row has merged items.
	 * @return
	 * TRUE if the current row has merged items, otherwise FALSE.
	 */
	BOOL HasMergedItems() const;

	/**
	 * @brief
	 * Sets the height of the current row calculated during merge cell processing.
	 * @param nMergeHeight A new merge hight value.
	 * @details
	 * A merge height of -1 means undefined height.
	 * When calculating the height of any merge cell, the height of all related
	 * merge cells must also be calculated. These calculated values are saved
	 * to prevent repeating the same actions for all related rows.
	 */
	void SetMergeHeight(int nMergeHeight);

	/**
	 * @brief
	 * Gets the height of the current row calculated during merge cell processing.
	 * @details
	 * A merge height of -1 means undefined height.
	 * When calculating the height of any merge cell, the height of all related
	 * merge cells must also be calculated. These calculated values are saved
	 * to prevent repeating the same actions for all related rows.
	 * @return Height of row calculated during merge cell processing
	 */
	int GetMergeHeight() const;

protected:
	/**
	 * @brief
	 * Gets the rectangle of a specified item.
	 * @param pItem     Pointer to a CXTPGridRecordItem object.
	 * @param bAsMerged TRUE if the specified item is merged.
	 * @return
	 * The rectangle of the item.
	 */
	CRect GetItemRect(CXTPGridRecordItem* pItem, BOOL bAsMerged);

	/**
	 * @brief
	 * Sets the index of the current row in the corresponding rows collection.
	 * @param nNewIndex Index to be set.
	 */
	virtual void SetIndex(int nNewIndex);

	/**
	 * @brief
	 * Gets the index of the last child row in a specified child row collection.
	 * @param pChildren Pointer to a child row collection.
	 * @return
	 * The index of the last child row in the specified child row collection.
	 */
	int GetLastChildRow(CXTPGridRows* pChildren) const;

	/** @cond */
	// System accessibility support.
	virtual HRESULT GetAccessibleParent(IDispatch** ppdispParent);
	virtual HRESULT GetAccessibleChildCount(long* pcountChildren);
	virtual HRESULT GetAccessibleChild(VARIANT varChild, IDispatch** ppdispChild);
	virtual HRESULT GetAccessibleName(VARIANT varChild, BSTR* pszName);
	virtual HRESULT GetAccessibleRole(VARIANT varChild, VARIANT* pvarRole);
	virtual HRESULT AccessibleLocation(long* pxLeft, long* pyTop, long* pcxWidth, long* pcyHeight,
									   VARIANT varChild);
	virtual HRESULT AccessibleHitTest(long xLeft, long yTop, VARIANT* pvarChild);
	virtual HRESULT GetAccessibleState(VARIANT varChild, VARIANT* pvarState);
	virtual CCmdTarget* GetAccessible();
	/** @endcond */

protected:
	CXTPGridControl* m_pControl; /**< Pointer to the parent Grid control. */
	CXTPGridRecord* m_pRecord;   /**< Pointer to the associated CXTPGridRecord object. */
	CXTPGridRow* m_pParentRow;   /**< Pointer to the parent row in the tree. */
	CXTPGridRows* m_pParentRows; /**< Pointer to the parent rows in the tree. */
	CXTPGridRows* m_pChilds;	 /**< Pointer to collection of children. */
	CXTPGridSection* m_pSection; /**< Pointer to section the row belongs to. */

	CRect m_rcRow;		/**< A rectangle where a row is to be drawn. */
	CRect m_rcCollapse; /**< A rectangle with coordinates of collapse/expand bitmap. */

	int m_nIndex;	  /**< Item index. */
	int m_nGroupLevel; /**< Contains row depth level when row is a group row. */
	int m_nRowLevel;   /**< Row depth level in a tree. */

	BOOL m_bVisible;	/**< TRUE if this row should be visible, FALSE if row is hidden. */
	BOOL m_bExpanded;   /**< TRUE if row is expanded in a tree view, FALSE if row is collapsed. */
	BOOL m_bLockExpand; /**< TRUE if row cannot be expanded/collapsed by the user. */
	BOOL m_bHasSelectedChilds; /**< TRUE if the row has selected children (on any deep level). */

	int m_nPreviewHeight; /**< Height of the preview item of this row. */
	int m_nFreeHeight;	/**< Height of row in FreeHeight RC mode. */
	int m_nMergeHeight;   /**< Height of row which calculated on merge cells processing. (-1) means
							 undefined height. */
	int m_nChildIndex;	/**<  Index of row inside parent rows. */

private:
#	ifdef _XTP_ACTIVEX
	/** @cond */
	DECLARE_DISPATCH_MAP()

	DECLARE_OLETYPELIB_EX(CXTPGridRow);

	afx_msg LPDISPATCH OleGetRecord();
	afx_msg LPDISPATCH OleGetChilds();
	afx_msg LPDISPATCH OleGetParentRow();
	afx_msg LPDISPATCH OleGetSection();
	afx_msg LPDISPATCH OleGetNextSiblingRow();
	afx_msg void OleGetRect(long* Left, long* Top, long* Right, long* Bottom);
	afx_msg void OleGetItemRect(LPDISPATCH lpDispatch, long* Left, long* Top, long* Right,
								long* Bottom);
	afx_msg void OleGetItemRectAsMerged(LPDISPATCH lpDispatch, long* Left, long* Top, long* Right,
										long* Bottom, VARIANT_BOOL fAsMerged);

public:
	static CXTPGridRow* AFX_CDECL FromDispatch(LPDISPATCH pDisp);

/** @endcond */
#	endif /*_XTP_ACTIVEX*/

	/** @cond */
	friend class CXTPGridControl;
	friend class CXTPGridSelectedRows;
	friend class CXTPGridRows;
	friend class CXTPGridRecordItem;
	friend class CXTPGridSection;
	friend class CXTPGridPaintManager;
	/** @endcond */
};

AFX_INLINE void CXTPGridRow::SetIndex(int nNewIndex)
{
	m_nIndex = nNewIndex;
}

AFX_INLINE CXTPGridRecord* CXTPGridRow::GetRecord() const
{
	return m_pRecord;
}

AFX_INLINE CXTPGridRow* CXTPGridRow::GetParentRow() const
{
	return m_pParentRow;
}

AFX_INLINE void CXTPGridRow::SetControl(CXTPGridControl* pControl)
{
	m_pControl = pControl;
}

AFX_INLINE CXTPGridControl* CXTPGridRow::GetControl() const
{
	return m_pControl;
}

AFX_INLINE void CXTPGridRow::SetCollapseRect(CRect rcCollapse)
{
	m_rcCollapse = rcCollapse;
}

AFX_INLINE CRect CXTPGridRow::GetRect() const
{
	return m_rcRow;
}

AFX_INLINE int CXTPGridRow::GetGroupLevel() const
{
	return m_nGroupLevel;
}

AFX_INLINE CXTPGridRows* CXTPGridRow::GetParentRows() const
{
	return m_pParentRows;
}

AFX_INLINE CXTPGridSection* CXTPGridRow::GetSection() const
{
	return m_pSection;
}

AFX_INLINE void CXTPGridRow::SetMergeHeight(int nMergeHeight)
{
	m_nMergeHeight = nMergeHeight;
}

AFX_INLINE int CXTPGridRow::GetMergeHeight() const
{
	return m_nMergeHeight;
}
/** @cond */
#	include "Common/Base/Diagnostic/XTPEnableNoisyWarnings.h"
#endif //#if !defined(__XTPGRIDROW_H__)
/** @endcond */