When working with a CExtGridWnd grid, you may want to find it necessary to merge cells. You can do this using the CExtGridWnd::GridCellJoinSet() method. Its nColNo and nRowNo parameters specify the top left cell in a range of merged cells and its CSize sizeJoin parameter defines the region size (see the figure below).

Please note that before using CExtGridWnd::GridCellJoinSet(), you should initialize all grid cells that will be merged. Any such a cell should be an object of a class that supports cell merging, e.g. CExtGridCellEx, which is a parent to most of grid cell classes. Although for better performance, some light weight classes in Prof-UIS do not support cell merging by default, e.g. CExtGridCellStringDM, you can always make such a class mergeable by applying a CExtGCJ template to it: CExtGCJ < CExtGridCellStringDM >.

You can split merged cells back using the same CExtGridWnd::GridCellJoinSet() in which sizeJoin is set to CSize(1,1). In any case, the method returns a boolean value that indicates if the merge/split operation succeeded.

NOTE: The cell merging requires Prof-UIS v2.83 or higher.

When a grid is sorted by one or more columns, a newly added row by default is displayed at the bottom of the grid. You should re-apply the sorting rules to the grid after some rows have been added or removed:

CExtGridWnd & wndGrid = . . .
CExtGridDataProvider & _DataProvider = wndGrid.OnGridQueryDataProvider();
_DataProvider.SortOrderUpdate( true, &wndGrid );
_DataProvider.SortOrderUpdate( false, &wndGrid );

When implementing any custom class that is derived from CExtGridCell (or any other class derived from CExtGridCell), you should move the IMPLEMENT_SERIAL macros up before the definition of the debug version of the new operator. For example, if you created a class derived from CExtGridCellString, the IMPLEMENT_SERIAL macros should look like below:

#include "StdAfx.h"

. . .

IMPLEMENT_SERIAL( CExtYourGridCell, CExtGridCellString, VERSIONABLE_SCHEMA|1 );

. . .

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

. . .

This allows you to avoid a conflict between the standard C++ operator new and a custom operator new with parameters defined in the CExtGridCell class.

CExtGridWnd supports one or more header rows both at top and at bottom. If you have at least one header row at top, you can set the width of any column by specifying the width of the corresponding cell in that header row:

OuterRowCountTopSet( 1L, false ); // Number of rows at top, the method of CExtGridWnd
CExtGridCellHeader * pCell =
   STATIC_DOWNCAST(
      CExtGridCellHeader,
      GridCellGetOuterAtTop(
         nColNo, // Column number
         0L, // Header row number, should be 0 here
         RUNTIME_CLASS(CExtGridCellHeader)
         )
      );
pCell->ExtentSet( 40, -1 ); // Minimum width
pCell->ExtentSet(50); // Current width (default value)
pCell->ExtentSet(100, 1); // Maximum width

To catch the selection change event, create a CExtGridCellComboBox-derived class and override the CExtGridCell::OnPopupListBoxSelEndOK() virtual method, which should return a value from the parent method and perform your custom actions. The OnPopupListBoxSelEndOK() virtual method is called to handle the final selection change event of the list box control in the pop-up menu tracked by the built-in button.

// *.h file:

virtual bool OnPopupListBoxSelEndOK(
    CExtPopupInplaceListBox & wndListBox,
    CExtGridCell::TrackCellStateInfo_t & _tcsi
    );


// *.cpp file:

bool CYourCellCombo::OnPopupListBoxSelEndOK(
    CExtPopupInplaceListBox & wndListBox,
    CExtGridCell::TrackCellStateInfo_t & _tcsi
    )
{
    ASSERT_VALID( this );
    ASSERT( (&_tcsi.m_cell) == this );
    ASSERT_VALID( (&wndListBox) );
    ASSERT_VALID( (&_tcsi.m_wndGrid) );

    CExtGridCellComboBox::OnPopupListBoxSelEndOK(
        wndListBox,
        _tcsi
        );

    // place your code here

    return false;
}

There is no need to create a button control and attach it to the grid cell. Actually, you only need to modify the cell style so that you can see one or more buttons in the right part of the cell. The following built-in buttons are supported:

There are two ways you can handle clicks on a cell button: at the grid window level and at the cell level. The first allows you to put the handler code in one place: use a CExtGridWnd-derived class, override its OnGridCellButtonPressed() method and return true if the click is handled. The method OnGridCellButtonPressed() takes 10 parameters, which provide all the information about the cell and the button:

virtual bool OnGridCellButtonPressed(
    CExtGridCell & _cell,
    INT nButtonType,
    const RECT & rcCellExtra,
    const RECT & rcCell,
    LONG nVisibleColNo,
    LONG nVisibleRowNo,
    LONG nColNo,
    LONG nRowNo,
    INT nColType,
    INT nRowType
    ); 

The nButtonType parameter specifies the button type and, if it is a up-down button, allows you to determine which part was pressed:

The second way of handling button clicks is overriding the OnButtonPressed() method in a CExtGridCell-derived class:

virtual void OnButtonPressed(
              CExtGridWnd & wndGrid,
              INT nButtonType,
              const RECT & rcCellExtra,
              const RECT & rcCell,
              LONG nVisibleColNo,
              LONG nVisibleRowNo,
              LONG nColNo,
              LONG nRowNo,
              INT nColType,
              INT nRowType
              );

For example, for a CExtGridCellString-derived class, the code may look like as follows:

// DECLARATION
class CYourGridCellString : public CExtGridCellString
{
public:

. . .    
    virtual void OnButtonPressed(
        CExtGridWnd & wndGrid,
        INT nButtonType,
        const RECT & rcCellExtra,
        const RECT & rcCell,
        LONG nVisibleColNo,
        LONG nVisibleRowNo,
        LONG nColNo,
        LONG nRowNo,
        INT nColType,
        INT nRowType
        );
    
}; // class CYourGridCellString


// IMPLEMENTATION:

void CYourGridCellString::OnButtonPressed(
    CExtGridWnd & wndGrid,
    INT nButtonType,
    const RECT & rcCellExtra,
    const RECT & rcCell,
    LONG nVisibleColNo,
    LONG nVisibleRowNo,
    LONG nColNo,
    LONG nRowNo,
    INT nColType,
    INT nRowType
    )
{
    ASSERT_VALID( this );
    ASSERT_VALID( (&wndGrid) );

    CExtGridCellString::OnButtonPressed(
        wndGrid,
        nButtonType,
        rcCellExtra,
        rcCell,
        nVisibleColNo,
        nVisibleRowNo,
        nColNo,
        nRowNo,
        nColType,
        nRowType
        );
    
    if( nButtonType == __EBTT_ELLIPSIS )
    {
        AfxMessageBox( _T("CYourGridCellString::OnButtonPressed") );
    }
}

The second approach is more flexible because allows you to enable and disable a cell button by overriding the CExtGridCell::OnQueryButtonInfo() method:

virtual bool OnQueryButtonInfo(
    INT nButtonType,
    bool * p_bEnabled,
    bool * p_bPressed = NULL,
    bool * p_bStayPressed = NULL,
    UINT * p_nTimerElapseValue = NULL
    ) const;

A CExtGridCell-derived class can also be used for handling clicks on the up and down parts of the spin button and updating their state independently from each other. The following methods allows you to do this:

virtual bool OnQueryEnabledIncrement() const;
virtual bool OnQueryEnabledDecrement() const;
virtual bool OnValueIncrement();
virtual bool OnValueDecrement();

You can make a cell multiline by applying the __EGCS_EX_WRAP_TEXT extended style to it:

pCell->ModifyStyleEx( __EGCS_EX_WRAP_TEXT );

The number of wrapped lines depends on the column width, row height and text length.

Here is how to set some multiline text:

pCell->TextSet( 
  _T("Line1\r\nLine2\r\nLine3\r\nLine4\r\nLine5") 
  ); 

The in-place text editor associated with any editable text cell supports multiple text input so when you are typing in some text in it and want to insert a new line, use the Ctrl+Enter key combination, which is standard for multiline edit controls.

This code demonstrates how to handle the WM_LBUTTONUP event and WM_CONTEXTMENU message. It changes the cell focus but not the selection.

// Method Headers
virtual void OnShowContextMenu( 
    LONG nColNo,
    LONG nRowNo, 
    CPoint ptTrack
    );
 
virtual bool OnGbwAnalyzeCellMouseClickEvent(
    UINT nChar, // VK_LBUTTON, VK_RBUTTON or VK_MBUTTON only
    UINT nRepCnt, // 0 - button up,
                  // 1 - single click, 
                  // 2 - double click, 
                  // 3 - post single click & begin editing
    UINT nFlags, // mouse event flags
    CPoint point // mouse pointer in client coordinates
    );

...
...
...
 
//{{AFX_MSG(CYourGridWnd)
afx_msg void OnContextMenu(CWnd* pWnd, CPoint point);
//}}AFX_MSG

// Method Implementation
BEGIN_MESSAGE_MAP(CYourGridWnd,CExtGridWnd)
    //{{AFX_MSG_MAP(CYourGridWnd)
    ON_WM_CONTEXTMENU()
    //}}AFX_MSG_MAP
END_MESSAGE_MAP()
 
...
...
...
 
void CYourGridWnd::OnShowContextMenu( 
    LONG nColNo,
    LONG nRowNo, 
    CPoint ptTrack 
    )
{
    nColNo;
    nRowNo;
    ptTrack;
    // show your context menu here
}
 
bool CYourGridWnd::OnGbwAnalyzeCellMouseClickEvent(
    UINT nChar,
    UINT nRepCnt,
    UINT nFlags,
    CPoint point
    )
{
    ASSERT_VALID( this );
    ASSERT( 0 <= nRepCnt && nRepCnt <= 3 );
    if( CExtGridWnd::OnGbwAnalyzeCellMouseClickEvent(
            nChar,
            nRepCnt,
            nFlags,
            point
            )
        )
        return true;
    if(        nChar == VK_RBUTTON
        &&    nRepCnt == 0 // 0 - button up
        )
    {
        CExtGridHitTestInfo htInfo( point );
        HitTest( htInfo, false, true );
        if(        (!htInfo.IsHoverEmpty()) && htInfo.IsValidRect() 
            &&    htInfo.m_nRowNo >= 0
            &&    (htInfo.m_dwAreaFlags&__EGBWA_INNER_CELLS) != 0
            )
        {
            CPoint ptFocus( htInfo.m_nColNo, htInfo.m_nRowNo );
            SetFocus();
            FocusSet( ptFocus, true, true, false );
 
            CPoint ptTrack( point );
            ClientToScreen( &ptTrack );
 
            OnShowContextMenu( 
                htInfo.m_nColNo,
                htInfo.m_nRowNo, 
                ptTrack 
                );
        }
        return true;
    }
    return false;
}
 
void CYourGridWnd::OnContextMenu( CWnd * pWnd, CPoint point ) 
{
    LONG nRowNo = SelectionGetLastRowInColumn( 0L );
    if( nRowNo < 0 )
        nRowNo = FocusGet().y;
    if( nRowNo >= 0 )
    {
        CRect rcCell;
        if( GridCellRectsGet(
                0L,
                nRowNo,
                0,
                0,
                &rcCell
                )
            )
        {
            CPoint ptTrack( rcCell.left, rcCell.bottom );
            ClientToScreen( &ptTrack );
            OnShowContextMenu( 
                0L,
                nRowNo,
                ptTrack 
                );        
        }
    }
}

1) Override GetScrollBarCtrl() method in a CExtExtGridWnd-derived class:

virtual CScrollBar * GetScrollBarCtrl( int nBar ) const
{
    ASSERT_VALID( this );
    if( m_hWnd == NULL || (! ::IsWindow(m_hWnd) ) )
        return NULL;
    ASSERT( nBar == SB_HORZ || nBar == SB_VERT );
    if( nBar == SB_HORZ )
    {
        if( m_wndScrollBarH.GetSafeHwnd() != NULL )
            return ( const_cast < CExtScrollBar * > ( &m_wndScrollBarH ) );
    }
    else
    {
        if( m_wndScrollBarV.GetSafeHwnd() != NULL )
            return ( const_cast < CExtScrollBar * > ( &m_wndScrollBarV ) );
    }
    return NULL;
}

2) Declare two CExtScrollBar properties:

 CExtScrollBar m_wndScrollBarH, m_wndScrollBarV;

3) Initialize the CExtScrollBar windows in the PreSubclassWindow() virtual method if your grid window is used as a custom dialog control or in the WM_CREATE message handler of the grid otherwise:

m_wndScrollBarH.m_eSO = CExtScrollBar::__ESO_BOTTOM;
m_wndScrollBarV.m_eSO = CExtScrollBar::__ESO_RIGHT;
if( ! m_wndScrollBarV.Create(
        WS_CHILD|WS_VISIBLE|SBS_VERT|SBS_RIGHTALIGN,
        CRect(0,0,0,0),
        this,
        1
        )
    )
{
    ASSERT( FALSE );
    return;
}
if( ! m_wndScrollBarH.Create(
        WS_CHILD|WS_VISIBLE|SBS_HORZ|SBS_BOTTOMALIGN,
        CRect(0,0,0,0),
        this,
        2
        )
    )
{
    ASSERT( FALSE );
    return;
}
m_wndScrollBarH.SyncReservedSpace( &m_wndScrollBarV );
m_wndScrollBarV.SyncReservedSpace( &m_wndScrollBarH );
OnSwRecalcLayout( true );

You can implement drag-and-drop for any grid derived from CExtGridWnd. Here are some key points to keep in mind:

• To enable drag-and-drop functionality, override the CExtGridWnd::OnGbwDataDndIsAllowed() virtual method: it should simply return true;
• You can suppress drag-and-drop for a particular cell(s) by overriding CExtGridWnd::OnGbwDataDndCanStart(): it should return false when appropriate;
• Implement your drag-and-drop algorithm itself in the CExtGridWnd::OnGbwDataDndDo()virtual method;
• Implement the standard IDropSource and IDropTarget interfaces so that you can catch drag-and-drop events in your application. You should implement IDropTarget whenever you want: your grid, other window, or even some other application.

You can see the implementation details in the FormEditor sample, where the user can drag-and-drop items from the toolbox onto a form.

pSomeCell->ModifyStyle( __EGCS_READ_ONLY );

pSomeCell->ModifyStyle(__EGCS_NO_INPLACE_CONTROL );

bool CExtGridCellUpDownColorPart::OnQueryEnabledIncrement() const
{
 ASSERT_VALID( this );
 if( intVal >= 255 )
  return false;
 return true;
}
 
bool CExtGridCellUpDownColorPart::OnQueryEnabledDecrement() const
{
 ASSERT_VALID( this );
 if( intVal <= 0 )
  return false;
 return true;
}

CExtGridDataSortOrder gdsoColumns;
CExtGridDataSortOrder::ITEM_INFO _soii( 
    0, // sort first column
    true // true - ascending sort order, false - descending
    );
gdsoColumns.m_arrItems.Add( _soii );
 
m_wndGrid.GridSortOrderSetup(
    false, // true - sort colums, false - sort rows
    gdsoColumns,
    false,
    false, // invert sort order
    true
);

Each column in the data grid supports three widths: minimum, maximum, and current. If these column widths are equal, the column cannot be resized.

Let's assume you need to disable resizing for column nColNo in a grid window with one header row at the top. The header cells, which are usually objects of the CExtGridCellHeader class, are used to keep column widths. So, you need to access the appropriate header cell and change the width values stored in it:

INT nColumnWidth = . . .
LONG nColNo = . . .
    // get the header cell at top for nColNo column
CExtGridCell * pCellHeader =
        wndGrid.GridCellGetOuterAtTop( nColNo, 0 );
ASSERT_VALID( pCellHeader );
// change current width
pCellHeader->ExtentSet( nColumnWidth ); 
// change minimal width
pCellHeader->ExtentSet( nColumnWidth, -1 ); 
// change maximal width
pCellHeader->ExtentSet( nColumnWidth, 1 );

To take immediate effect, just invoke:

wndGrid.OnSwRecalcLayout();
wndGrid.OnSwDoRedraw();

The selection model in the grid control is based on the array of rectangles. Each rectangle describes indices of left/top and right/bottom cells of a single rectangular selection region.

If your grid uses the single selection model, then the selection region consists of one rectangle only. The full-row and full-column selection models are also based on rectangles.

The data grid also supports two types of multiple selection models: excluded and non-excluded. The cell is assumed to be non-selected if it is covered by an even number of rectangles in the excluded model. The cell is assumed to be selected if it is covered by at least one rectangle in the non-excluded model.

LONG nRowNo = wndGrid.SelectionGetFirstRowInColumn( nColNo );
    while( nRowNo >= 0 )
    {
        . . .
        nRowNo = wndGrid.SelectionGetNextRowInColumn( nColNo, nRowNo );
    }

You can use the SelectionGetLastRowInColumn() and SelectionGetpPrevRowInColumn() methods for traversing the same rows in the reversed order from bottom to top.

You can also enumerate all the selected cells in row nRowNo by using:

LONG nColNo = wndGrid.SelectionGetFirstColumnInRow( nRowNo );
    while( nColNo >= 0 )
    {
        . . .
        nColNo = wndGrid.SelectionGetNextColumnInRow( nColNo, nRowNo );
    }

You can use the SelectionGetLastColumnInRow() and SelectionGetPrevColumnInRow() methods for traversing the same columns in the reversed order from right to left.

The SelectionGetForCell( nColNo, nRowNo ) method allows you to detect whether a cell is selected regardless the selection model. You can invoke the SelectionGetHitCount( nColNo, nRowNo ) method to get the number of rectangles covering the specified cell. The SelectionGetAreaCount() method returns the total number of rectangles. The SelectionGet(), SelectionInsertAt(), SelectionSetAt(), SelectionRemoveAt(), SelectionIsEmpty() and SelectionUnset() methods are handy when you need to perform any operation with the array of rectangles which describe the current selection region. The two SelectionSet() overloaded methods allows you to append a new rectangle and optionally to remove previous rectangles. The FocusSet() method sets both focus and selection at once.

You can override the OnGbwSelectionChanged() virtual method to track when selection changes. You can also override the OnGbwSelectionCanModify() virtual method and return false if the current selection region cannot be changed. You can do the same for the focus by overriding the OnGbwFocusChanged() and OnGbwFocusChanging() methods.