金融证券系统

开发平台：

Visual C++

GridCtrl.cpp.old：源码内容

SetFocusCell(-1,-1);
int addedRows = nRows - GetRowCount();
// If we are about to lose rows, then we need to delete the GridCell objects
// in each column within each row
if (addedRows < 0) {
for (int row = nRows; row < m_nRows; row++)
{
// Delete cells
for (int col = 0; col < m_nCols; col++)
{
CGridCell* pCell = GetCell(row, col);
if (pCell) {
EmptyCell(pCell, row, col);
delete pCell;
}
}
// Delete rows
GRID_ROW* pRow = m_RowData[row];
if (pRow) delete pRow;
}
}
// Change the number of rows.
m_nRows = nRows;
m_RowData.SetSize(m_nRows);
m_arRowHeights.SetSize(nRows);
// If we have just added rows, we need to construct new elements for each cell
// and set the default row height
if (addedRows > 0) {
// initialize row heights and data
int startRow = nRows - addedRows;
for (int row = startRow; row < GetRowCount(); row++) {
m_arRowHeights[row] = m_nDefCellHeight;
m_RowData[row] = new GRID_ROW;
m_RowData[row]->SetSize(m_nCols);
for (int col = 0; col < m_nCols; col++)
{
GRID_ROW* pRow = m_RowData[row];
if (pRow) pRow->SetAt(col, CreateCell(row, col));
}
}
}
//else
// ResetSelectedRange();
if (GetSafeHwnd() && m_bAllowDraw)
{
ResetScrollBars();
Invalidate();
}
return TRUE;
}
BOOL CGridCtrl::SetColumnCount(int nCols)
{
ASSERT(nCols >= 0);
if (nCols == GetColumnCount()) return TRUE;
if (nCols < m_nFixedCols)
m_nFixedCols = nCols;
if (m_idCurrentCell.col >= nCols)
SetFocusCell(-1,-1);
int addedCols = nCols - GetColumnCount();
// If we are about to lose columns, then we need to delete the GridCell objects
// within each column
if (addedCols < 0) {
for (int row = 0; row < m_nRows; row++)
for (int col = nCols; col < GetColumnCount(); col++)
{
CGridCell* pCell = GetCell(row, col);
if (pCell) {
EmptyCell(pCell, row, col);
delete pCell;
}
}
}
// Change the number of columns.
m_nCols = nCols;
m_arColWidths.SetSize(nCols);
// Change the number of columns in each row.
for (int i = 0; i < m_nRows; i++)
if (m_RowData[i]) m_RowData[i]->SetSize(nCols);
// If we have just added columns, we need to construct new elements for each cell
// and set the default column width
if (addedCols > 0)
{
// initialized column widths
int startCol = nCols - addedCols;
for (int col = startCol; col < GetColumnCount(); col++)
m_arColWidths[col] = m_nDefCellWidth;
// initialise column data
for (int row = 0; row < m_nRows; row++)
for (col = startCol; col < GetColumnCount(); col++)
{
GRID_ROW* pRow = m_RowData[row];
if (pRow) pRow->SetAt(col, CreateCell(row,col));
}
}
//else // check for selected cell ranges
// ResetSelectedRange();
if (GetSafeHwnd() && m_bAllowDraw)
{
ResetScrollBars();
Invalidate();
}
return TRUE;
}
// Insert a column at a given position, or add to end of columns (if nColumn = -1)
int CGridCtrl::InsertColumn(LPCTSTR strHeading,
UINT nFormat /* = DT_CENTER|DT_VCENTER|DT_SINGLELINE */,
int nColumn /* = -1 */)
{
// If the insertion is for a specific column, check it's within range.
if (nColumn >= 0 && nColumn >= GetColumnCount())
return -1;
ResetSelectedRange();
// Gotta be able to at least _see_ some of the column.
if (m_nRows < 1)
SetRowCount(1);
if (nColumn < 0)
{
nColumn = m_nCols;
m_arColWidths.Add(0);
for (int row = 0; row < m_nRows; row++)
{
GRID_ROW* pRow = m_RowData[row];
if (!pRow) return -1;
pRow->Add(CreateCell(row, nColumn));
}
}
else
{
m_arColWidths.InsertAt(nColumn, (int)0);
for (int row = 0; row < m_nRows; row++)
{
GRID_ROW* pRow = m_RowData[row];
if (!pRow) return -1;
pRow->InsertAt(nColumn, CreateCell(row, nColumn));
}
}
m_nCols++;
// Initialise column data
SetItemText(0, nColumn, strHeading);
for (int row = 0; row < m_nRows; row++)
{
SetItemFormat(row, nColumn, nFormat);
}
// initialized column width
m_arColWidths[nColumn] = GetTextExtent(strHeading).cx;
if (m_idCurrentCell.col != -1 && nColumn < m_idCurrentCell.col)
m_idCurrentCell.col++;
ResetScrollBars();
return nColumn;
}
// Insert a row at a given position, or add to end of rows (if nRow = -1)
int CGridCtrl::InsertRow(LPCTSTR strHeading, int nRow /* = -1 */)
{
// If the insertion is for a specific row, check it's within range.
if (nRow >= 0 && nRow >= GetRowCount())
return -1;
ResetSelectedRange();
// Gotta be able to at least _see_ some of the row.
if (m_nCols < 1)
SetColumnCount(1);
// Adding a row to the bottom
if (nRow < 0)
{
nRow = m_nRows;
m_arRowHeights.Add(0);
m_RowData.Add(new GRID_ROW);
}
else
{
m_arRowHeights.InsertAt(nRow, (int)0);
m_RowData.InsertAt(nRow, new GRID_ROW);
}
m_nRows++;
m_RowData[nRow]->SetSize(m_nCols);
// Initialise cell data
for (int col = 0; col < m_nCols; col++)
{
GRID_ROW* pRow = m_RowData[nRow];
if (!pRow) return -1;
pRow->SetAt(col, CreateCell(nRow, col));
}
// Set row title
SetItemText(nRow, 0, strHeading);
// initialized row height
m_arRowHeights[nRow] = GetTextExtent(strHeading).cy;
if (m_idCurrentCell.row != -1 && nRow < m_idCurrentCell.row)
m_idCurrentCell.row++;
ResetScrollBars();
return nRow;
}
// Creates a new grid cell and performs any necessary initialisation
CGridCell* CGridCtrl::CreateCell(int nRow, int nCol)
{
CGridCell* pCell = new CGridCell;
if (!pCell)
return NULL;
// Make format same as cell above
if (nRow > 0 && nCol >= 0 && nCol < m_nCols)
pCell->nFormat = GetItemFormat(nRow-1, nCol);
// Make font default grid font
memcpy(&(pCell->lfFont), &m_Logfont, sizeof(LOGFONT));
return pCell;
}
// Performs any cell cleanup necessary to maintain grid integrity
void CGridCtrl::EmptyCell(CGridCell* pCell, int nRow, int nCol)
{
// Set the cells state to 0. If the cell is selected, this
// will remove the cell from the selected list.
SetItemState(nRow, nCol, 0);
// Empty strings
pCell->szText.Empty();
}
BOOL CGridCtrl::DeleteColumn(int nColumn)
{
if (nColumn < 0 || nColumn >= GetColumnCount())
return FALSE;
ResetSelectedRange();
for (int row = 0; row < GetRowCount(); row++)
{
GRID_ROW* pRow = m_RowData[row];
if (!pRow) return FALSE;
CGridCell* pCell = pRow->GetAt(nColumn);
if (pCell) {
EmptyCell(pCell, row, nColumn);
delete pCell;
}
pRow->RemoveAt(nColumn);
}
m_arColWidths.RemoveAt(nColumn);
m_nCols--;
if (nColumn < m_nFixedCols) m_nFixedCols--;
if (nColumn == m_idCurrentCell.col)
m_idCurrentCell.row = m_idCurrentCell.col = -1;
else if (nColumn < m_idCurrentCell.col)
m_idCurrentCell.col--;
ResetScrollBars();
return TRUE;
}
BOOL CGridCtrl::DeleteRow(int nRow)
{
if ( nRow < 0 || nRow >= GetRowCount())
return FALSE;
GRID_ROW* pRow = m_RowData[nRow];
if (!pRow) return FALSE;
ResetSelectedRange();
for (int col = 0; col < GetColumnCount(); col++)
{
CGridCell* pCell = pRow->GetAt(col);
if (pCell) {
EmptyCell(pCell, nRow, col);
delete pCell;
}
}
delete pRow;
m_RowData.RemoveAt(nRow);
m_arRowHeights.RemoveAt(nRow);
m_nRows--;
if (nRow < m_nFixedRows) m_nFixedRows--;
if (nRow == m_idCurrentCell.row)
m_idCurrentCell.row = m_idCurrentCell.col = -1;
else if (nRow < m_idCurrentCell.row)
m_idCurrentCell.row--;
ResetScrollBars();
return TRUE;
}
// Handy function that removes all non-fixed rows
BOOL CGridCtrl::DeleteNonFixedRows()
{
int nFixed = GetFixedRowCount();
int nCount = GetRowCount();
// Delete all data rows
for (int nRow = nCount; nRow >= nFixed; nRow--)
DeleteRow(nRow);
return TRUE;
}
// Removes all rows, columns and data from the grid.
BOOL CGridCtrl::DeleteAllItems()
{
ResetSelectedRange();
m_arColWidths.RemoveAll();
m_arRowHeights.RemoveAll();
// Delete all cells in the grid
for (int row = 0; row < m_nRows; row++)
{
GRID_ROW* pRow = m_RowData[row];
if (!pRow) continue;
for (int col = 0; col < m_nCols; col++)
{
CGridCell* pCell = pRow->GetAt(col);
if (pCell) {
EmptyCell(pCell, row, col); // TODO - this is a bit of a performance hit.
delete pCell; // better to call m_SelectedCells.RemoveAll()
} // instead. This is safer for changes though.
}
delete pRow;
}
// Remove all rows
m_RowData.RemoveAll();
m_idCurrentCell.row = m_idCurrentCell.col = -1;
m_nRows = m_nFixedRows = m_nCols = m_nFixedCols = 0;
ResetScrollBars();
return TRUE;
}
/////////////////////////////////////////////////////////////////////////////
// CGridCtrl data functions
// Set CListCtrl::GetNextItem for details
CCellID CGridCtrl::GetNextItem(CCellID& cell, int nFlags) const
{
if (nFlags & GVNI_ALL)
{ // GVNI_ALL Search whole Grid beginning from cell
// First row (cell.row) -- ONLY Columns to the right of cell
// following rows -- ALL Columns
int row = cell.row , col = cell.col + 1;
if (row <= 0) row = GetFixedRowCount();
for (; row < GetRowCount(); row++)
{
if (col <= 0 ) col = GetFixedColumnCount();
for (; col < GetColumnCount(); col++)
{
int nState = GetItemState(row, col);
if (nFlags & GVNI_DROPHILITED && nState & GVIS_DROPHILITED)
return CCellID(row, col);
if (nFlags & GVNI_FOCUSED && nState & GVIS_FOCUSED)
return CCellID(row, col);
if (nFlags & GVNI_SELECTED && nState & GVIS_SELECTED)
return CCellID(row, col);
if (nFlags & GVNI_READONLY && nState & GVIS_READONLY)
return CCellID(row, col);
if (nFlags & GVNI_MODIFIED && nState & GVIS_MODIFIED)
return CCellID(row, col);
}
// go to First Column
col=GetFixedColumnCount();
}
}
else if ((nFlags & GVNI_BELOW) && (nFlags & GVNI_TORIGHT))
{ // GVNI_AREA Search Grid beginning from cell to Lower-Right of Grid
// Only rows starting with cell.row and below
// All rows -- ONLY Columns to the right of cell
int row = cell.row;
if (row <= 0) row = GetFixedRowCount();
for (; row < GetRowCount(); row++)
{
int col = cell.col + 1;
if (col <= 0) col = GetFixedColumnCount();
for (; col < GetColumnCount(); col++)
{
int nState = GetItemState(row, col);
if (nFlags & GVNI_DROPHILITED && nState & GVIS_DROPHILITED)
return CCellID(row, col);
if (nFlags & GVNI_FOCUSED && nState & GVIS_FOCUSED)
return CCellID(row, col);
if (nFlags & GVNI_SELECTED && nState & GVIS_SELECTED)
return CCellID(row, col);
if (nFlags & GVNI_READONLY && nState & GVIS_READONLY)
return CCellID(row, col);
if (nFlags & GVNI_MODIFIED && nState & GVIS_MODIFIED)
return CCellID(row, col);
}
}
}
else if (nFlags & GVNI_ABOVE)
{
for (int row = cell.row-1; row >= GetFixedRowCount(); row--)
{
int nState = GetItemState(row, cell.col);
if (nFlags & GVNI_DROPHILITED && nState & GVIS_DROPHILITED)
return CCellID(row, cell.col);
if (nFlags & GVNI_FOCUSED && nState & GVIS_FOCUSED)
return CCellID(row, cell.col);
if (nFlags & GVNI_SELECTED && nState & GVIS_SELECTED)
return CCellID(row, cell.col);
if (nFlags & GVNI_READONLY && nState & GVIS_READONLY)
return CCellID(row, cell.col);
if (nFlags & GVNI_MODIFIED && nState & GVIS_MODIFIED)
return CCellID(row, cell.col);
}
}
else if (nFlags & GVNI_BELOW)
{
for (int row = cell.row+1; row < GetRowCount(); row++)
{
int nState = GetItemState(row, cell.col);
if (nFlags & GVNI_DROPHILITED && nState & GVIS_DROPHILITED)
return CCellID(row, cell.col);
if (nFlags & GVNI_FOCUSED && nState & GVIS_FOCUSED)
return CCellID(row, cell.col);
if (nFlags & GVNI_SELECTED && nState & GVIS_SELECTED)
return CCellID(row, cell.col);
if (nFlags & GVNI_READONLY && nState & GVIS_READONLY)
return CCellID(row, cell.col);
if (nFlags & GVNI_MODIFIED && nState & GVIS_MODIFIED)
return CCellID(row, cell.col);
}
}
else if (nFlags & GVNI_TOLEFT)
{
for (int col = cell.col-1; col >= GetFixedColumnCount(); col--)
{
int nState = GetItemState(cell.row, col);
if (nFlags & GVNI_DROPHILITED && nState & GVIS_DROPHILITED)
return CCellID(cell.row, col);
if (nFlags & GVNI_FOCUSED && nState & GVIS_FOCUSED)
return CCellID(cell.row, col);
if (nFlags & GVNI_SELECTED && nState & GVIS_SELECTED)
return CCellID(cell.row, col);
if (nFlags & GVNI_READONLY && nState & GVIS_READONLY)
return CCellID(cell.row, col);
if (nFlags & GVNI_MODIFIED && nState & GVIS_MODIFIED)
return CCellID(cell.row, col);
}
}
else if (nFlags & GVNI_TORIGHT)
{
for (int col = cell.col+1; col < GetColumnCount(); col++)
{
int nState = GetItemState(cell.row, col);
if (nFlags & GVNI_DROPHILITED && nState & GVIS_DROPHILITED)
return CCellID(cell.row, col);
if (nFlags & GVNI_FOCUSED && nState & GVIS_FOCUSED)
return CCellID(cell.row, col);
if (nFlags & GVNI_SELECTED && nState & GVIS_SELECTED)
return CCellID(cell.row, col);
if (nFlags & GVNI_READONLY && nState & GVIS_READONLY)
return CCellID(cell.row, col);
if (nFlags & GVNI_MODIFIED && nState & GVIS_MODIFIED)
return CCellID(cell.row, col);
}
}
return CCellID(-1, -1);
}
// Sorts on a given column using the cell text
BOOL CGridCtrl::SortTextItems(int nCol, BOOL bAscending)
{
ResetSelectedRange();
SetFocusCell(-1,-1);
return SortTextItems(nCol, bAscending, GetFixedRowCount(),-1);
}
// recursive sort implementation
BOOL CGridCtrl::SortTextItems(int nCol, BOOL bAscending, int low, int high)
{
if (nCol >= GetColumnCount()) return FALSE;
if (high == -1) high = GetRowCount() - 1;
int lo = low;
int hi = high;
if( hi <= lo ) return FALSE;
CString midItem = GetItemText( (lo+hi)/2, nCol );
// loop through the list until indices cross
while( lo <= hi )
{
// Find the first element that is greater than or equal to the partition
// element starting from the left Index.
if( bAscending )
while (lo < high && GetItemText(lo, nCol) < midItem)
++lo;
else
while (lo < high && GetItemText(lo, nCol) > midItem)
++lo;
// Find an element that is smaller than or equal to the partition
// element starting from the right Index.
if( bAscending )
while (hi > low && GetItemText(hi, nCol) > midItem)
--hi;
else
while (hi > low && GetItemText(hi, nCol) < midItem)
--hi;
// If the indexes have not crossed, swap if the items are not equal
if (lo <= hi)
{
// swap only if the items are not equal
if (GetItemText(lo, nCol) != GetItemText(hi, nCol))
{
for (int col = 0; col < GetColumnCount(); col++)
{
CGridCell *pCell = GetCell(lo, col);
SetCell(lo, col, GetCell(hi, col));
SetCell(hi, col, pCell);
}
UINT nRowHeight = m_arRowHeights[lo];
m_arRowHeights[lo] = m_arRowHeights[hi];
m_arRowHeights[hi] = nRowHeight;
}
++lo;
--hi;
}
}
// If the right index has not reached the left side of array
// must now sort the left partition.
if( low < hi )
SortTextItems(nCol, bAscending, low, hi);
// If the left index has not reached the right side of array
// must now sort the right partition.
if( lo < high )
SortTextItems(nCol, bAscending, lo, high);
return TRUE;
}
// Sorts on a given column using the supplied compare function (see CListCtrl::SortItems)
BOOL CGridCtrl::SortItems(PFNLVCOMPARE pfnCompare, int nCol, BOOL bAscending,
LPARAM data /* = 0 */)
{
ResetSelectedRange();
SetFocusCell(-1,-1);
return SortItems(pfnCompare, nCol, bAscending, data, GetFixedRowCount(), -1);
}
// recursive sort implementation
BOOL CGridCtrl::SortItems(PFNLVCOMPARE pfnCompare, int nCol, BOOL bAscending, LPARAM data,
int low, int high)
{
if (nCol >= GetColumnCount()) return FALSE;
if (high == -1) high = GetRowCount() - 1;
int lo = low;
int hi = high;
if( hi <= lo ) return FALSE;
LPARAM midItem = GetItemData( (lo+hi)/2, nCol );
// loop through the list until indices cross
while( lo <= hi )
{
// Find the first element that is greater than or equal to the partition
// element starting from the left Index.
if( bAscending )
while (lo < high && pfnCompare(GetItemData(lo, nCol), midItem, data) < 0)
++lo;
else
while (lo < high && pfnCompare(GetItemData(lo, nCol), midItem, data) > 0)
++lo;
// Find an element that is smaller than or equal to the partition
// element starting from the right Index.
if( bAscending )
while (hi > low && pfnCompare(GetItemData(hi, nCol), midItem, data) > 0)
--hi;
else
while (hi > low && pfnCompare(GetItemData(hi, nCol), midItem, data) < 0)
--hi;
// If the indexes have not crossed, swap if the items are not equal
if (lo <= hi)
{
// swap only if the items are not equal
if (pfnCompare(GetItemData(lo, nCol), GetItemData(hi, nCol), data) != 0)
{
for (int col = 0; col < GetColumnCount(); col++)
{
CGridCell *pCell = GetCell(lo, col);
SetCell(lo, col, GetCell(hi, col));
SetCell(hi, col, pCell);
}
UINT nRowHeight = m_arRowHeights[lo];
m_arRowHeights[lo] = m_arRowHeights[hi];
m_arRowHeights[hi] = nRowHeight;
}
++lo;
--hi;
}
}
// If the right index has not reached the left side of array
// must now sort the left partition.
if( low < hi )
SortItems(pfnCompare, nCol, bAscending, data, low, hi);
// If the left index has not reached the right side of array
// must now sort the right partition.
if( lo < high )
SortItems(pfnCompare, nCol, bAscending, data, lo, high);
return TRUE;
}
/////////////////////////////////////////////////////////////////////////////
// CGridCtrl data functions
BOOL CGridCtrl::SetItem(const GV_ITEM* pItem)
{
if (!pItem)
return FALSE;
CGridCell* pCell = GetCell(pItem->row, pItem->col);
if (!pCell)
return FALSE;
if (pItem->mask & GVIF_TEXT) pCell->szText = pItem->szText;
if (pItem->mask & GVIF_PARAM) pCell->lParam = pItem->lParam;
if (pItem->mask & GVIF_IMAGE) pCell->iImage = pItem->iImage;
if (pItem->mask & GVIF_STATE) pCell->state = pItem->state;
if (pItem->mask & GVIF_FORMAT) pCell->nFormat = pItem->nFormat;
if (pItem->mask & GVIF_BKCLR) pCell->crBkClr = pItem->crBkClr;
if (pItem->mask & GVIF_FGCLR) pCell->crFgClr = pItem->crFgClr;
if (pItem->mask & GVIF_FONT) memcpy(&(pCell->lfFont), &(pItem->lfFont), sizeof(LOGFONT));
return TRUE;
}
BOOL CGridCtrl::GetItem(GV_ITEM* pItem)
{
if (!pItem)
return FALSE;
CGridCell* pCell = GetCell(pItem->row, pItem->col);
if (!pCell)
return FALSE;
if (pItem->mask & GVIF_TEXT) pItem->szText = GetItemText(pItem->row, pItem->col);
if (pItem->mask & GVIF_PARAM) pItem->lParam = pCell->lParam;
if (pItem->mask & GVIF_IMAGE) pItem->iImage = pCell->iImage;
if (pItem->mask & GVIF_STATE) pItem->state = pCell->state;
if (pItem->mask & GVIF_FORMAT) pItem->nFormat = pCell->nFormat;
if (pItem->mask & GVIF_BKCLR) pItem->crBkClr = pCell->crBkClr;
if (pItem->mask & GVIF_FGCLR) pItem->crFgClr = pCell->crFgClr;
if (pItem->mask & GVIF_FONT) memcpy(&(pItem->lfFont), &(pCell->lfFont), sizeof(LOGFONT));
return TRUE;
}
BOOL CGridCtrl::SetItemText(int nRow, int nCol, LPCTSTR str)
{
CGridCell* pCell = GetCell(nRow, nCol);
if (!pCell)
return FALSE;
pCell->szText = str;
return TRUE;
}
BOOL CGridCtrl::SetItemData(int nRow, int nCol, LPARAM lParam)
{
CGridCell* pCell = GetCell(nRow, nCol);
if (!pCell)
return FALSE;
pCell->lParam = lParam;
return TRUE;
}
LPARAM CGridCtrl::GetItemData(int nRow, int nCol) const
{
CGridCell* pCell = GetCell(nRow, nCol);
if (!pCell)
return (LPARAM) 0;
return pCell->lParam;
}
BOOL CGridCtrl::SetItemImage(int nRow, int nCol, int iImage)
{
CGridCell* pCell = GetCell(nRow, nCol);
if (!pCell)
return FALSE;
pCell->iImage = iImage;
return TRUE;
}
int CGridCtrl::GetItemImage(int nRow, int nCol) const
{
CGridCell* pCell = GetCell(nRow, nCol);
ASSERT(pCell);
if (!pCell)
return -1;
return pCell->iImage;
}
BOOL CGridCtrl::SetItemState(int nRow, int nCol, UINT state)
{
CGridCell* pCell = GetCell(nRow, nCol);
ASSERT(pCell);
if (!pCell)
return FALSE;
// If the cell is being unselected, remove it from the selected list
if ((pCell->state & GVIS_SELECTED) && !(state & GVIS_SELECTED))
{
CCellID cell;
DWORD key = MAKELONG(nRow, nCol);
if (m_SelectedCellMap.Lookup(key, (CCellID&)cell))
m_SelectedCellMap.RemoveKey(key);
}
// If cell is being selected, add it to the list of selected cells
else if (!(pCell->state & GVIS_SELECTED) && (state & GVIS_SELECTED))
{
CCellID cell(nRow, nCol);
m_SelectedCellMap.SetAt(MAKELONG(nRow, nCol), cell);
}
// Set the cell's state
pCell->state = state;
return TRUE;
}
UINT CGridCtrl::GetItemState(int nRow, int nCol) const
{
CGridCell* pCell = GetCell(nRow, nCol);
ASSERT(pCell);
if (!pCell)
return 0;
return pCell->state;
}
BOOL CGridCtrl::SetItemFormat(int nRow, int nCol, UINT nFormat)
{
CGridCell* pCell = GetCell(nRow, nCol);
ASSERT(pCell);
if (!pCell)
return FALSE;
pCell->nFormat = nFormat;
return TRUE;
}
UINT CGridCtrl::GetItemFormat(int nRow, int nCol) const
{
CGridCell* pCell = GetCell(nRow, nCol);
ASSERT(pCell);
if (!pCell)
return 0;
return pCell->nFormat;
}
BOOL CGridCtrl::SetItemBkColour(int nRow, int nCol, COLORREF cr /* = CLR_DEFAULT */)
{
CGridCell* pCell = GetCell(nRow, nCol);
ASSERT(pCell);
if (!pCell)
return FALSE;
pCell->crBkClr = cr;
return TRUE;
}
COLORREF CGridCtrl::GetItemBkColour(int nRow, int nCol) const
{
CGridCell* pCell = GetCell(nRow, nCol);
ASSERT(pCell);
if (!pCell)
return 0;
return pCell->crBkClr;
}
BOOL CGridCtrl::SetItemFgColour(int nRow, int nCol, COLORREF cr /* = CLR_DEFAULT */)
{
CGridCell* pCell = GetCell(nRow, nCol);
ASSERT(pCell);
if (!pCell)
return FALSE;
pCell->crFgClr = cr;
return TRUE;
}
COLORREF CGridCtrl::GetItemFgColour(int nRow, int nCol) const
{
CGridCell* pCell = GetCell(nRow, nCol);
ASSERT(pCell);
if (!pCell)
return 0;
return pCell->crFgClr;
}
BOOL CGridCtrl::SetItemFont(int nRow, int nCol, LOGFONT* lf)
{
CGridCell* pCell = GetCell(nRow, nCol);
ASSERT(pCell);
if (!pCell)
return FALSE;
memcpy(&(pCell->lfFont), lf, sizeof(LOGFONT));
return TRUE;
}
LOGFONT* CGridCtrl::GetItemFont(int nRow, int nCol)
{
CGridCell* pCell = GetCell(nRow, nCol);
ASSERT(pCell);
if (!pCell)
return &m_Logfont;
return &(pCell->lfFont);
}
////////////////////////////////////////////////////////////////////////////////////
// Row/Column size functions
long CGridCtrl::GetVirtualWidth() const
{
long lVirtualWidth = 0;
int iColCount = GetColumnCount();
for (int i = 0; i < iColCount; i++)
lVirtualWidth += m_arColWidths[i];
return lVirtualWidth;
}
long CGridCtrl::GetVirtualHeight() const
{
long lVirtualHeight = 0;
int iRowCount = GetRowCount();
for (int i = 0; i < iRowCount; i++)
lVirtualHeight += m_arRowHeights[i];
return lVirtualHeight;
}
int CGridCtrl::GetRowHeight(int nRow) const
{
ASSERT(nRow >= 0 && nRow < m_nRows);
if (nRow < 0 || nRow >= m_nRows) return -1;
return m_arRowHeights[nRow];
}
int CGridCtrl::GetColumnWidth(int nCol) const
{
ASSERT(nCol >= 0 && nCol < m_nCols);
if (nCol < 0 || nCol >= m_nCols) return -1;
return m_arColWidths[nCol];
}
BOOL CGridCtrl::SetRowHeight(int nRow, int height)
{
ASSERT(nRow >= 0 && nRow < m_nRows && height >= 0);
if (nRow < 0 || nRow >= m_nRows || height < 0) return FALSE;
m_arRowHeights[nRow] = height;
return TRUE;
}
BOOL CGridCtrl::SetColumnWidth(int nCol, int width)
{
ASSERT(nCol >= 0 && nCol < m_nCols && width >= 0);
if (nCol < 0 || nCol >= m_nCols || width < 0) return FALSE;
m_arColWidths[nCol] = width;
return TRUE;
}
int CGridCtrl::GetFixedRowHeight() const
{
int nHeight = 0;
for (int i = 0; i < m_nFixedRows; i++)
nHeight += GetRowHeight(i);
return nHeight;
}
int CGridCtrl::GetFixedColumnWidth() const
{
int nWidth = 0;
for (int i = 0; i < m_nFixedCols; i++)
nWidth += GetColumnWidth(i);
return nWidth;
}
BOOL CGridCtrl::AutoSizeColumn(int nCol)
{
ASSERT(nCol >= 0 && nCol < m_nCols);
if (nCol < 0 || nCol >= m_nCols) return FALSE;
CSize size;
CDC* pDC = GetDC();
if (!pDC) return FALSE;
int nWidth = 0;
int nNumRows = GetRowCount();
for (int nRow = 0; nRow < nNumRows; nRow++)
{
size = GetCellExtent(nRow, nCol, pDC);
if (size.cx > nWidth) nWidth = size.cx;
}
m_arColWidths[nCol] = nWidth;
ReleaseDC(pDC);
ResetScrollBars();
return TRUE;
}
BOOL CGridCtrl::AutoSizeRow(int nRow)
{
ASSERT(nRow >= 0 && nRow < m_nRows);
if (nRow < 0 || nRow >= m_nRows) return FALSE;
CSize size;
CDC* pDC = GetDC();
if (!pDC) return FALSE;
int nHeight = 0;
int nNumColumns = GetColumnCount();
for (int nCol = 0; nCol < nNumColumns; nCol++)
{
size = GetCellExtent(nRow, nCol, pDC);
if (size.cy > nHeight) nHeight = size.cy;
}
m_arRowHeights[nRow] = nHeight;
ReleaseDC(pDC);
ResetScrollBars();
return TRUE;
}
void CGridCtrl::AutoSizeColumns()
{
int nNumColumns = GetColumnCount();
for (int nCol = 0; nCol < nNumColumns; nCol++)
AutoSizeColumn(nCol);
}
void CGridCtrl::AutoSizeRows()
{
int nNumRows = GetRowCount();
for (int nRow = 0; nRow < nNumRows; nRow++)
AutoSizeRow(nRow);
}
// sizes all rows and columns
// faster than calling both AutoSizeColumns() and AutoSizeRows()
void CGridCtrl::AutoSize()
{
CDC* pDC = GetDC();
if (!pDC) return;
int nNumColumns = GetColumnCount();
int nNumRows = GetRowCount();
// initialize column widths to zero
for (int nCol = 0; nCol < nNumColumns; nCol++)
m_arColWidths[nCol] = 0;
// initialize row heights to zero
for (int nRow = 0; nRow < nNumRows; nRow++)
m_arRowHeights[nRow] = 0;
CSize size;
for (nCol = 0; nCol < nNumColumns; nCol++)
for (nRow = 0; nRow < nNumRows; nRow++)
{
size = GetCellExtent(nRow, nCol, pDC);
if (size.cx > (int) m_arColWidths[nCol]) m_arColWidths[nCol] = size.cx;
if (size.cy > (int) m_arRowHeights[nRow]) m_arRowHeights[nRow] = size.cy;
}
ReleaseDC(pDC);
if (m_bAllowDraw) {
ResetScrollBars();
Invalidate();
}
}
void CGridCtrl::ExpandColumnsToFit()
{
if (GetColumnCount() <= 0) return;
CRect rect;
GetClientRect(rect);
long virtualWidth = GetVirtualWidth();
int nDifference = rect.Width() - (int) virtualWidth;
int nColumnAdjustment = nDifference / GetColumnCount();
for (int i = 0; i < GetColumnCount(); i++)
m_arColWidths[i] += nColumnAdjustment;
if (nDifference > 0)
{
int leftOver = nDifference % GetColumnCount();
for (i = 0; i < leftOver; i++)
m_arColWidths[i] += 1;
}
else
{
int leftOver = (-nDifference) % GetColumnCount();
for (i = 0; i < leftOver; i++)
m_arColWidths[i] -= 1;
}
if (m_bAllowDraw)
Invalidate();
}
void CGridCtrl::ExpandRowsToFit()
{
if (GetRowCount() <= 0) return;
CRect rect;
GetClientRect(rect);
long virtualHeight = GetVirtualHeight();
int nDifference = rect.Height() - (int) virtualHeight;
int nRowAdjustment = nDifference / GetRowCount();
for (int i = 0; i < GetRowCount(); i++)
m_arRowHeights[i] += nRowAdjustment;
if (nDifference > 0)
{
int leftOver = nDifference % GetRowCount();
for (i = 0; i < leftOver; i++)
m_arRowHeights[i] += 1;
}
else
{
int leftOver = (-nDifference) % GetRowCount();
for (i = 0; i < leftOver; i++)
m_arRowHeights[i] -= 1;
}
if (m_bAllowDraw)
Invalidate();
}
void CGridCtrl::ExpandToFit()
{
ExpandColumnsToFit(); // This will remove any existing horz scrollbar
ExpandRowsToFit(); // This will remove any existing vert scrollbar
ExpandColumnsToFit(); // Just in case the first adjustment was with a vert
// scrollbar in place
}
BOOL CGridCtrl::IsCellFixed(int nRow, int nCol)
{
return (nRow < GetFixedRowCount() || nCol < GetFixedColumnCount());
}
void CGridCtrl::SetModified(BOOL bModified /*=TRUE*/, int nRow /*=-1*/, int nCol /*=-1*/)
{
if (nRow > 0 && nCol > 0)
{
if (bModified)
{
SetItemState(nRow, nCol, GetItemState(nRow, nCol) | GVIS_MODIFIED);
m_bModified = TRUE;
}
else
SetItemState(nRow, nCol, GetItemState(nRow, nCol) & ~GVIS_MODIFIED);
}
else
m_bModified = bModified;
if (!m_bModified)
{
for (int row = 0; row < GetRowCount(); row++)
for (int col = 0; col < GetColumnCount(); col++)
SetItemState(row, col, GetItemState(row, col) & ~GVIS_MODIFIED);
}
}
BOOL CGridCtrl::GetModified(int nRow /*=-1*/, int nCol /*=-1*/)
{
if (nRow > 0 && nCol > 0)
return ( (GetItemState(nRow, nCol) & GVIS_MODIFIED) == GVIS_MODIFIED );
else
return m_bModified;
}
/////////////////////////////////////////////////////////////////////////////////////
// GridCtrl cell visibility tests and invalidation/redraw functions
// EnsureVisible supplied by Roelf Werkman
void CGridCtrl::EnsureVisible(int nRow, int nCol)
{
CCellRange VisibleCells = GetVisibleNonFixedCellRange();
int right = nCol - VisibleCells.GetMaxCol();
int left = VisibleCells.GetMinCol() - nCol;
int down = nRow - VisibleCells.GetMaxRow();
int up = VisibleCells.GetMinRow() - nRow;
while (right > 0)
{
SendMessage(WM_HSCROLL, SB_LINERIGHT, 0);
right--;
}
while (left > 0)
{
SendMessage(WM_HSCROLL, SB_LINELEFT, 0);
left--;
}
while (down > 0)
{
SendMessage(WM_VSCROLL, SB_LINEDOWN, 0);
down--;
}
while (up > 0)
{
SendMessage(WM_VSCROLL, SB_LINEUP, 0);
up--;
}
// Move one more if we only see a snall bit of the cell
CRect rectCell, rectWindow;
GetCellRect(nRow, nCol, rectCell);
GetClientRect(rectWindow);
if (rectCell.right > rectWindow.right)
SendMessage(WM_HSCROLL, SB_LINERIGHT, 0);
if (rectCell.bottom > rectWindow.bottom)
SendMessage(WM_VSCROLL, SB_LINEDOWN, 0);
}
BOOL CGridCtrl::IsCellEditable(CCellID &cell) const
{
return IsCellEditable(cell.row, cell.col);
}
BOOL CGridCtrl::IsCellEditable(int nRow, int nCol) const
{
return IsEditable() && ((GetItemState(nRow, nCol) & GVIS_READONLY) != GVIS_READONLY);
}
BOOL CGridCtrl::IsCellVisible(CCellID cell) const
{
return IsCellVisible(cell.row, cell.col);
}
BOOL CGridCtrl::IsCellVisible(int nRow, int nCol) const
{
if (!IsWindow(m_hWnd))
return FALSE;
int x,y;
CCellID TopLeft;
if (nCol >= GetFixedColumnCount() || nRow >= GetFixedRowCount())
{
TopLeft = GetTopleftNonFixedCell();
if (nCol >= GetFixedColumnCount() && nCol < TopLeft.col) return FALSE;
if (nRow >= GetFixedRowCount() && nRow < TopLeft.row) return FALSE;
}
CRect rect;
GetClientRect(rect);
if (nCol < GetFixedColumnCount())
{
x = 0;
for (int i = 0; i <= nCol; i++)
{
if (x >= rect.right) return FALSE;
x += GetColumnWidth(i);
}
}
else
{
x = GetFixedColumnWidth();
for (int i = TopLeft.col; i <= nCol; i++)
{
if (x >= rect.right) return FALSE;
x += GetColumnWidth(i);
}
}
if (nRow < GetFixedRowCount())
{
y = 0;
for (int i = 0; i <= nRow; i++)
{
if (y >= rect.bottom) return FALSE;
y += GetRowHeight(i);
}
}
else
{
if (nRow < TopLeft.row) return FALSE;
y = GetFixedRowHeight();
for (int i = TopLeft.row; i <= nRow; i++)
{
if (y >= rect.bottom) return FALSE;
y += GetRowHeight(i);
}
}
return TRUE;
}
BOOL CGridCtrl::InvalidateCellRect(const CCellID& cell)
{
if (!::IsWindow(GetSafeHwnd()) || !m_bAllowDraw)
return FALSE;
ASSERT(IsValid(cell));
if (!IsCellVisible(cell.row, cell.col)) return FALSE;
CRect rect;
if (!GetCellRect(cell, rect)) return FALSE;
rect.right++; rect.bottom++;
InvalidateRect(rect, TRUE);
return TRUE;
}
BOOL CGridCtrl::InvalidateCellRect(const CCellRange& cellRange)
{
ASSERT(IsValid(cellRange));
if (!::IsWindow(GetSafeHwnd()) || !m_bAllowDraw) return FALSE;
CCellRange visibleCellRange = GetVisibleNonFixedCellRange().Intersect(cellRange);
CRect rect;
if (!GetCellRangeRect(visibleCellRange, rect)) return FALSE;
rect.right++; rect.bottom++;
InvalidateRect(rect, TRUE);
return TRUE;
}
/////////////////////////////////////////////////////////////////////////////
// CGridCtrl Mouse stuff
// Handles mouse wheel notifications
// Note - if this doesn't work for win95 then use OnRegisteredMouseWheel instead
#if !defined(_WIN32_WCE) && (_MFC_VER >= 0x0421)
BOOL CGridCtrl::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt)
{
// A m_nRowsPerWheelNotch value less than 0 indicates that the mouse
// wheel scrolls whole pages, not just lines.
if (m_nRowsPerWheelNotch == -1)
{
int nPagesScrolled = zDelta / 120;
if (nPagesScrolled > 0)
for (int i = 0; i < nPagesScrolled; i++)
PostMessage(WM_VSCROLL, SB_PAGEUP, 0);
else
for (int i = 0; i > nPagesScrolled; i--)
PostMessage(WM_VSCROLL, SB_PAGEDOWN, 0);
}
else
{
int nRowsScrolled = m_nRowsPerWheelNotch * zDelta / 120;
if (nRowsScrolled > 0)
for (int i = 0; i < nRowsScrolled; i++)
PostMessage(WM_VSCROLL, SB_LINEUP, 0);
else
for (int i = 0; i > nRowsScrolled; i--)
PostMessage(WM_VSCROLL, SB_LINEDOWN, 0);
}
return CWnd::OnMouseWheel(nFlags, zDelta, pt);
}
#endif // !defined(_WIN32_WCE) && (_MFC_VER >= 0x0421)
void CGridCtrl::OnMouseMove(UINT nFlags, CPoint point)
{
CRect rect;
GetClientRect(rect);
#ifndef GRIDCONTROL_NO_DRAGDROP
// If outside client area, return (unless we are drag n dropping)
if (m_MouseMode != MOUSE_DRAGGING && !rect.PtInRect(point))
return;
#endif
// If the left mouse button is up, then test to see if row/column sizing is imminent
if (!(nFlags & MK_LBUTTON)
|| (m_MouseMode == MOUSE_NOTHING && (nFlags & MK_LBUTTON)))
{
if (m_bAllowColumnResize && MouseOverColumnResizeArea(point))
{
if (m_MouseMode != MOUSE_OVER_COL_DIVIDE)
{
SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZEWE));
m_MouseMode = MOUSE_OVER_COL_DIVIDE;
}
}
else if (m_bAllowRowResize && MouseOverRowResizeArea(point))
{
if (m_MouseMode != MOUSE_OVER_ROW_DIVIDE)
{
SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZENS));
m_MouseMode = MOUSE_OVER_ROW_DIVIDE;
}
}
else if (m_MouseMode != MOUSE_NOTHING)
{
SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
m_MouseMode = MOUSE_NOTHING;
}
#ifndef GRIDCONTROL_NO_TITLETIPS
if (m_MouseMode == MOUSE_NOTHING && m_bTitleTips)
{
CCellID idCurrentCell = GetCellFromPt(point);
CRect TextRect, CellRect;
if (GetTextRect(idCurrentCell.row, idCurrentCell.col, TextRect) &&
GetCellRect(idCurrentCell.row, idCurrentCell.col, CellRect))
m_TitleTip.Show(TextRect,
GetItemText(idCurrentCell.row, idCurrentCell.col),
0,
CellRect,
GetItemFont(idCurrentCell.row, idCurrentCell.col));
}
#endif
m_LastMousePoint = point;
return;
}
if (!IsValid(m_LeftClickDownCell))
{
m_LastMousePoint = point;
return;
}
// If the left mouse button is down, then process appropriately
if (nFlags & MK_LBUTTON)
{
switch(m_MouseMode)
{
case MOUSE_SELECT_ALL:
break;
case MOUSE_SELECT_COL:
case MOUSE_SELECT_ROW:
case MOUSE_SELECT_CELLS:
{
CCellID idCurrentCell = GetCellFromPt(point);
if (!IsValid(idCurrentCell))
return;
if (idCurrentCell != GetFocusCell())
{
OnSelecting(idCurrentCell);
//SetFocusCell(max(idCurrentCell.row, m_nFixedRows),
// max(idCurrentCell.col, m_nFixedCols));
if (idCurrentCell.row >= m_nFixedRows &&
idCurrentCell.col >= m_nFixedCols)
{
SetFocusCell(idCurrentCell);
}
}
break;
}
case MOUSE_SIZING_COL:
{
CDC* pDC = GetDC();
if (!pDC) break;
CRect oldInvertedRect(m_LastMousePoint.x, rect.top,
m_LastMousePoint.x + 2, rect.bottom);
pDC->InvertRect(&oldInvertedRect);
CRect newInvertedRect(point.x, rect.top,
point.x + 2, rect.bottom);
pDC->InvertRect(&newInvertedRect);
ReleaseDC(pDC);
}
break;
case MOUSE_SIZING_ROW:
{
CDC* pDC = GetDC();
if (!pDC) break;
CRect oldInvertedRect(rect.left, m_LastMousePoint.y,
rect.right, m_LastMousePoint.y + 2);
pDC->InvertRect(&oldInvertedRect);
CRect newInvertedRect(rect.left, point.y,
rect.right, point.y + 2);
pDC->InvertRect(&newInvertedRect);
ReleaseDC(pDC);
}
break;
#ifndef GRIDCONTROL_NO_DRAGDROP
case MOUSE_PREPARE_DRAG:
OnBeginDrag();
break;
#endif
}
}
m_LastMousePoint = point;
}
void CGridCtrl::OnLButtonDblClk(UINT nFlags, CPoint point)
{
if (m_MouseMode == MOUSE_OVER_COL_DIVIDE)
{
CCellID cell = GetCellFromPt(point);
ASSERT(IsValid(cell));
CPoint start;
if (!GetCellOrigin(0, cell.col, &start)) return;
if (point.x - start.x <= m_nResizeCaptureRange) // Clicked right of border
cell.col--;
AutoSizeColumn(cell.col);
Invalidate();
}
else if (m_MouseMode == MOUSE_OVER_ROW_DIVIDE)
{
CCellID cell = GetCellFromPt(point);
ASSERT(IsValid(cell));
CPoint start;
if (!GetCellOrigin(0, cell.col, &start)) return;
if (point.y - start.y <= m_nResizeCaptureRange) // Clicked below border
cell.row--;
AutoSizeRow(cell.row);
Invalidate();
}
else if (m_MouseMode == MOUSE_NOTHING)
{
if (m_LeftClickDownCell.row >= m_nFixedRows &&
IsValid(m_LeftClickDownCell) &&
m_LeftClickDownCell.col >= m_nFixedCols)
{
OnEditCell(m_idCurrentCell.row, m_idCurrentCell.col, VK_LBUTTON);
}
else if (m_bListMode)
{
CCellID cell = GetCellFromPt(point);
if (!IsValid(cell)) return;
if (cell.row >= m_nFixedRows && cell.col < GetFixedColumnCount())
OnEditCell(cell.row, cell.col, VK_LBUTTON);
}
}
CWnd::OnLButtonDblClk(nFlags, point);
}
void CGridCtrl::OnLButtonDown(UINT nFlags, CPoint point)
{
HWND hOldFocusWnd = ::GetFocus();
m_LeftClickDownPoint = point;
m_LeftClickDownCell = GetCellFromPt(point);
if (!IsValid(m_LeftClickDownCell)) return;
m_SelectionStartCell = (nFlags & MK_SHIFT)? m_idCurrentCell : m_LeftClickDownCell;
SetFocus(); // Auto-destroy any InPlaceEdit's
// If the user clicks on the current cell, then prepare to edit it.
// (If the user moves the mouse, then dragging occurs)
if (m_LeftClickDownCell == m_idCurrentCell)
{
m_MouseMode = MOUSE_PREPARE_EDIT;
return;
}
else if (m_MouseMode != MOUSE_OVER_COL_DIVIDE &&
m_MouseMode != MOUSE_OVER_ROW_DIVIDE)
{
SetFocusCell(-1,-1);
SetFocusCell(max(m_LeftClickDownCell.row, m_nFixedRows),
max(m_LeftClickDownCell.col, m_nFixedCols));
}
#ifndef GRIDCONTROL_NO_DRAGDROP
// If the user clicks on a selected cell, then prepare to drag it.
// (If the user moves the mouse, then dragging occurs)
if (m_bAllowDragAndDrop && hOldFocusWnd == GetSafeHwnd() &&
GetItemState(m_LeftClickDownCell.row, m_LeftClickDownCell.col) & GVNI_SELECTED)
{
m_MouseMode = MOUSE_PREPARE_DRAG;
return;
}
#endif
SetCapture();
if (m_MouseMode == MOUSE_NOTHING)
{
if (m_bAllowColumnResize && MouseOverColumnResizeArea(point))
{
if (m_MouseMode != MOUSE_OVER_COL_DIVIDE)
{
SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZEWE));
m_MouseMode = MOUSE_OVER_COL_DIVIDE;
}
}
else if (m_bAllowRowResize && MouseOverRowResizeArea(point))
{
if (m_MouseMode != MOUSE_OVER_ROW_DIVIDE)
{
SetCursor(AfxGetApp()->LoadStandardCursor(IDC_SIZENS));
m_MouseMode = MOUSE_OVER_ROW_DIVIDE;
}
}
//else if (m_MouseMode != MOUSE_NOTHING)
//{
// SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
// m_MouseMode = MOUSE_NOTHING;
//}
}
if (m_MouseMode == MOUSE_OVER_COL_DIVIDE) // sizing column
{
m_MouseMode = MOUSE_SIZING_COL;
CPoint start;
if (!GetCellOrigin(0, m_LeftClickDownCell.col, &start)) return;
CRect rect;
GetClientRect(rect);
CRect invertedRect(point.x, rect.top, point.x + 2, rect.bottom);
CDC* pDC = GetDC();
if (pDC) {
pDC->InvertRect(&invertedRect);
ReleaseDC(pDC);
}
if (point.x - start.x <= m_nResizeCaptureRange) // clicked right of border
if (!GetCellOrigin(0, --m_LeftClickDownCell.col, &start)) return;
rect.left = start.x;
ClientToScreen(rect);
#ifndef _WIN32_WCE_NO_CURSOR
ClipCursor(rect);
#endif
}
else if (m_MouseMode == MOUSE_OVER_ROW_DIVIDE) // sizing row
{
m_MouseMode = MOUSE_SIZING_ROW;
CPoint start;
if (!GetCellOrigin(m_LeftClickDownCell, &start)) return;
CRect rect;
GetClientRect(rect);
CRect invertedRect(rect.left, point.y, rect.right, point.y + 2);
CDC* pDC = GetDC();
if (pDC) {
pDC->InvertRect(&invertedRect);
ReleaseDC(pDC);
}
if (point.y - start.y <= m_nResizeCaptureRange) // clicked below border
if (!GetCellOrigin(--m_LeftClickDownCell.row, 0, &start)) return;
rect.top = start.y;
ClientToScreen(rect);
#ifndef _WIN32_WCE_NO_CURSOR
ClipCursor(rect);
#endif
}
else // not sizing or editing -- selecting
{
// If Ctrl pressed, save the current cell selection. This will get added
// to the new cell selection at the end of the cell selection process
m_PrevSelectedCellMap.RemoveAll();
if (nFlags & MK_CONTROL) {
for (POSITION pos = m_SelectedCellMap.GetStartPosition(); pos != NULL; )
{
DWORD key;
CCellID cell;
m_SelectedCellMap.GetNextAssoc(pos, key, (CCellID&)cell);
m_PrevSelectedCellMap.SetAt(key, cell);
}
}
if (m_LeftClickDownCell.row < GetFixedRowCount())
OnFixedRowClick(m_LeftClickDownCell);
else if (m_LeftClickDownCell.col < GetFixedColumnCount())
OnFixedColumnClick(m_LeftClickDownCell);
else
{
m_MouseMode = m_bListMode? MOUSE_SELECT_ROW : MOUSE_SELECT_CELLS;
OnSelecting(m_LeftClickDownCell);
}
m_nTimerID = SetTimer(WM_LBUTTONDOWN, m_nTimerInterval, 0);
}
m_LastMousePoint = point;
}
void CGridCtrl::OnLButtonUp(UINT nFlags, CPoint point)
{
CWnd::OnLButtonUp(nFlags, point);
#ifndef _WIN32_WCE_NO_CURSOR
ClipCursor(NULL);
#endif
if (GetCapture()->GetSafeHwnd() == GetSafeHwnd())
{
ReleaseCapture();
KillTimer(m_nTimerID);
m_nTimerID = 0;
}
// m_MouseMode == MOUSE_PREPARE_EDIT only if user clicked down on current cell
// and then didn't move mouse before clicking up (releasing button)
if (m_MouseMode == MOUSE_PREPARE_EDIT)
{
OnEditCell(m_idCurrentCell.row, m_idCurrentCell.col, VK_LBUTTON);
}
#ifndef GRIDCONTROL_NO_DRAGDROP
// m_MouseMode == MOUSE_PREPARE_DRAG only if user clicked down on a selected cell
// and then didn't move mouse before clicking up (releasing button)
else if (m_MouseMode == MOUSE_PREPARE_DRAG)
{
ResetSelectedRange();
}
#endif
else if (m_MouseMode == MOUSE_SIZING_COL)
{
CRect rect;
GetClientRect(rect);
CRect invertedRect(m_LastMousePoint.x, rect.top, m_LastMousePoint.x + 2, rect.bottom);
CDC* pDC = GetDC();
if (pDC) {
pDC->InvertRect(&invertedRect);
ReleaseDC(pDC);
}
if (m_LeftClickDownPoint != point)
{
CPoint start;
if (!GetCellOrigin(m_LeftClickDownCell, &start)) return;
SetColumnWidth(m_LeftClickDownCell.col, point.x - start.x);
ResetScrollBars();
Invalidate();
}
}
else if (m_MouseMode == MOUSE_SIZING_ROW)
{
CRect rect;
GetClientRect(rect);
CRect invertedRect(rect.left, m_LastMousePoint.y, rect.right, m_LastMousePoint.y + 2);
CDC* pDC = GetDC();
if (pDC) {
pDC->InvertRect(&invertedRect);
ReleaseDC(pDC);
}
if (m_LeftClickDownPoint != point)
{
CPoint start;
if (!GetCellOrigin(m_LeftClickDownCell, &start)) return;
SetRowHeight(m_LeftClickDownCell.row, point.y - start.y);
ResetScrollBars();
Invalidate();
}
}
m_MouseMode = MOUSE_NOTHING;
#ifndef _WIN32_WCE_NO_CURSOR
SetCursor(AfxGetApp()->LoadStandardCursor(IDC_ARROW));
#endif
if (!IsValid(m_LeftClickDownCell)) return;
CWnd *pOwner = GetOwner();
if (pOwner && IsWindow(pOwner->m_hWnd))
pOwner->PostMessage(WM_COMMAND, MAKELONG(GetDlgCtrlID(), BN_CLICKED),
(LPARAM) GetSafeHwnd());
}
#if !defined(_WIN32_WCE_NO_PRINTING) && !defined(GRIDCONTROL_NO_PRINTING)
/////////////////////////////////////////////////////////////////////////////
// CGridCtrl printing
void CGridCtrl::Print()
{
CDC dc;
CPrintDialog printDlg(FALSE);
if (printDlg.DoModal() != IDOK) // Get printer settings from user
return;
dc.Attach(printDlg.GetPrinterDC()); // attach a printer DC
dc.m_bPrinting = TRUE;
CString strTitle;
strTitle.LoadString(AFX_IDS_APP_TITLE);
DOCINFO di; // Initialise print doc details
memset(&di, 0, sizeof (DOCINFO));
di.cbSize = sizeof (DOCINFO);
di.lpszDocName = strTitle;
BOOL bPrintingOK = dc.StartDoc(&di); // Begin a new print job
CPrintInfo Info;
Info.m_rectDraw.SetRect(0,0, dc.GetDeviceCaps(HORZRES), dc.GetDeviceCaps(VERTRES));
OnBeginPrinting(&dc, &Info); // Initialise printing
for (UINT page = Info.GetMinPage(); page <= Info.GetMaxPage() && bPrintingOK; page++)
{
dc.StartPage(); // begin new page
Info.m_nCurPage = page;
OnPrint(&dc, &Info); // Print page
bPrintingOK = (dc.EndPage() > 0); // end page
}
OnEndPrinting(&dc, &Info); // Clean up after printing
if (bPrintingOK)
dc.EndDoc(); // end a print job
else
dc.AbortDoc(); // abort job.
dc.Detach(); // detach the printer DC
}
/////////////////////////////////////////////////////////////////////////////
// CGridCtrl printing overridables - for Doc/View print/print preview framework
void CGridCtrl::OnBeginPrinting(CDC *pDC, CPrintInfo *pInfo)
{
// OnBeginPrinting() is called after the user has committed to
// printing by OK'ing the Print dialog, and after the framework
// has created a CDC object for the printer or the preview view.
// This is the right opportunity to set up the page range.
// Given the CDC object, we can determine how many rows will
// fit on a page, so we can in turn determine how many printed
// pages represent the entire document.
ASSERT(pDC && pInfo);
if (!pDC || !pInfo) return;
int nMaxRowCount = GetRowCount() - GetFixedRowCount();
if (!nMaxRowCount) return;
// Get a DC for the current window (will be a screen DC for print previewing)
CDC *pCurrentDC = GetDC(); // will have dimensions of the client area
if (!pCurrentDC) return;
CSize PaperPixelsPerInch(pDC->GetDeviceCaps(LOGPIXELSX), pDC->GetDeviceCaps(LOGPIXELSY));
CSize ScreenPixelsPerInch(pCurrentDC->GetDeviceCaps(LOGPIXELSX), pCurrentDC->GetDeviceCaps(LOGPIXELSY));
// Create the printer font
int nFontSize = -9;
CString strFontName = "Times New Roman";
m_PrinterFont.CreateFont(nFontSize, 0,0,0, FW_NORMAL, 0,0,0, DEFAULT_CHARSET,
OUT_CHARACTER_PRECIS, CLIP_CHARACTER_PRECIS, DEFAULT_QUALITY,
DEFAULT_PITCH | FF_DONTCARE, strFontName);
CFont *pOldFont = pDC->SelectObject(&m_PrinterFont);
// Get the average character width (in GridCtrl units) and hence the margins
m_CharSize = pDC->GetTextExtent(_T("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSATUVWXYZ"),52);
m_CharSize.cx /= 52;
int nMargins = (LEFT_MARGIN+RIGHT_MARGIN)*m_CharSize.cx;
// Get the page sizes (physical and logical)
m_PaperSize = CSize(pDC->GetDeviceCaps(HORZRES), pDC->GetDeviceCaps(VERTRES));
m_LogicalPageSize.cx = GetVirtualWidth()+nMargins;
#ifdef _WIN32_WCE
m_LogicalPageSize.cy = (m_LogicalPageSize.cx * m_PaperSize.cy) / m_PaperSize.cx;
#else
m_LogicalPageSize.cy = MulDiv(m_LogicalPageSize.cx, m_PaperSize.cy, m_PaperSize.cx);
#endif
m_nPageHeight = m_LogicalPageSize.cy - GetFixedRowHeight()
- (HEADER_HEIGHT+FOOTER_HEIGHT + 2*GAP)*m_CharSize.cy;
// Get the number of pages. Assumes no row is bigger than the page size.
int nTotalRowHeight = 0;
int nNumPages = 1;
for (int row = GetFixedRowCount(); row < GetRowCount(); row++)
{
nTotalRowHeight += GetRowHeight(row);
if (nTotalRowHeight > m_nPageHeight) {
nNumPages++;
nTotalRowHeight = GetRowHeight(row);
}
}
// Set up the print info
pInfo->SetMaxPage(nNumPages);
pInfo->m_nCurPage = 1; // start printing at page# 1
ReleaseDC(pCurrentDC);
pDC->SelectObject(pOldFont);
}
void CGridCtrl::OnPrint(CDC *pDC, CPrintInfo *pInfo)
{
if (!pDC || !pInfo) return;
//CRect rcPage(pInfo->m_rectDraw);
CFont *pOldFont = pDC->SelectObject(&m_PrinterFont);
// Set the page map mode to use GridCtrl units, and setup margin
pDC->SetMapMode(MM_ANISOTROPIC);
pDC->SetWindowExt(m_LogicalPageSize);
pDC->SetViewportExt(m_PaperSize);
pDC->SetWindowOrg(-LEFT_MARGIN*m_CharSize.cx, 0);
// Header
pInfo->m_rectDraw.top = 0;
pInfo->m_rectDraw.left = 0;
pInfo->m_rectDraw.right = m_LogicalPageSize.cx - (LEFT_MARGIN+RIGHT_MARGIN)*m_CharSize.cx;
pInfo->m_rectDraw.bottom = HEADER_HEIGHT*m_CharSize.cy;
PrintHeader(pDC, pInfo);
pDC->OffsetWindowOrg(0, -HEADER_HEIGHT*m_CharSize.cy);
// Gap between header and column headings
pDC->OffsetWindowOrg(0, -GAP*m_CharSize.cy);
// Print the column headings
pInfo->m_rectDraw.bottom = GetFixedRowHeight();
PrintColumnHeadings(pDC, pInfo);
pDC->OffsetWindowOrg(0, -GetFixedRowHeight());
// We need to find out which row to start printing for this page.
int nTotalRowHeight = 0;
UINT nNumPages = 1;
int nCurrPrintRow = GetFixedRowCount();
while (nCurrPrintRow < GetRowCount() && nNumPages < pInfo->m_nCurPage)
{
nTotalRowHeight += GetRowHeight(nCurrPrintRow);
if (nTotalRowHeight > m_nPageHeight) {
nNumPages++;
if (nNumPages == pInfo->m_nCurPage) break;
nTotalRowHeight = GetRowHeight(nCurrPrintRow);
}
nCurrPrintRow++;
}
if (nCurrPrintRow >= GetRowCount()) return;
// Draw as many rows as will fit on the printed page.
// Clip the printed page so that there is no partially shown
// row at the bottom of the page (the same row which will be fully
// shown at the top of the next page).
BOOL bFirstPrintedRow = TRUE;
CRect rect;
rect.bottom = -1;
while (nCurrPrintRow < GetRowCount())
{
rect.top = rect.bottom+1;
rect.bottom = rect.top + GetRowHeight(nCurrPrintRow) - 1;
if (rect.bottom > m_nPageHeight) break; // Gone past end of page
rect.right = -1;
for (int col = 0; col < GetColumnCount(); col++)
{
rect.left = rect.right+1;
rect.right = rect.left + GetColumnWidth(col) - 1;
DrawCell(pDC, nCurrPrintRow, col, rect);
if (m_nGridLines == GVL_BOTH || m_nGridLines == GVL_HORZ)
{
int Overlap = (col == 0)? 0:1;
pDC->MoveTo(rect.left-Overlap, rect.bottom);
pDC->LineTo(rect.right, rect.bottom);
if (nCurrPrintRow == 0) {
pDC->MoveTo(rect.left-Overlap, rect.top);
pDC->LineTo(rect.right, rect.top);
}
}
if (m_nGridLines == GVL_BOTH || m_nGridLines == GVL_VERT)
{
int Overlap = (bFirstPrintedRow)? 0:1;
pDC->MoveTo(rect.right, rect.top-Overlap);
pDC->LineTo(rect.right, rect.bottom);
if (col == 0) {
pDC->MoveTo(rect.left, rect.top-Overlap);
pDC->LineTo(rect.left, rect.bottom);
}
}
}
nCurrPrintRow++;
bFirstPrintedRow = FALSE;
}
// Footer
pInfo->m_rectDraw.bottom = FOOTER_HEIGHT*m_CharSize.cy;
pDC->SetWindowOrg(-LEFT_MARGIN*m_CharSize.cx, -m_LogicalPageSize.cy + FOOTER_HEIGHT*m_CharSize.cy);
PrintFooter(pDC, pInfo);
// SetWindowOrg back for next page
pDC->SetWindowOrg(0,0);
pDC->SelectObject(pOldFont);
}
void CGridCtrl::PrintColumnHeadings(CDC *pDC, CPrintInfo* /*pInfo*/)
{
CFont *pOldFont = pDC->SelectObject(&m_PrinterFont);
CRect rect;
rect.bottom = -1;
for (int row = 0; row < GetFixedRowCount(); row++)
{
rect.top = rect.bottom+1;
rect.bottom = rect.top + GetRowHeight(row) - 1;
rect.right = -1;
for (int col = 0; col < GetColumnCount(); col++)
{
rect.left = rect.right+1;
rect.right = rect.left + GetColumnWidth(col) - 1;
DrawFixedCell(pDC, row, col, rect);
if (m_nGridLines == GVL_BOTH || m_nGridLines == GVL_HORZ)
{
int Overlap = (col == 0)? 0:1;
pDC->MoveTo(rect.left-Overlap, rect.bottom);
pDC->LineTo(rect.right, rect.bottom);
if (row == 0) {
pDC->MoveTo(rect.left-Overlap, rect.top);
pDC->LineTo(rect.right, rect.top);
}
}
if (m_nGridLines == GVL_BOTH || m_nGridLines == GVL_VERT)
{
int Overlap = (row == 0)? 0:1;
pDC->MoveTo(rect.right, rect.top-Overlap);
pDC->LineTo(rect.right, rect.bottom);
if (col == 0) {
pDC->MoveTo(rect.left, rect.top-Overlap);
pDC->LineTo(rect.left, rect.bottom);
}
}
}
}
pDC->SelectObject(pOldFont);
}
void CGridCtrl::PrintHeader(CDC *pDC, CPrintInfo *pInfo)
{
CRect rc(pInfo->m_rectDraw);
CString strHeaderString;
CFont BoldFont;
LOGFONT lf;
//create bold font for header and footer
VERIFY(m_PrinterFont.GetLogFont(&lf));
lf.lfWeight = FW_BOLD;
VERIFY(BoldFont.CreateFontIndirect(&lf));
CFont *pNormalFont = pDC->SelectObject(&BoldFont);
int nPrevBkMode = pDC->SetBkMode(TRANSPARENT);
// print App title on top right margin
strHeaderString.LoadString(AFX_IDS_APP_TITLE);
pDC->DrawText(strHeaderString, &rc, DT_RIGHT | DT_SINGLELINE | DT_NOPREFIX | DT_VCENTER);
// print parent window title in the centre (Gert Rijs)
CWnd *pParentWnd = GetParent();
while (pParentWnd)
{
pParentWnd->GetWindowText(strHeaderString);
if (strHeaderString.GetLength()) // can happen if it is a CView, CChildFrm has the title
break;
pParentWnd = pParentWnd->GetParent();
}
pDC->DrawText(strHeaderString, &rc, DT_CENTER | DT_SINGLELINE | DT_NOPREFIX | DT_VCENTER);
pDC->SetBkMode(nPrevBkMode);
pDC->SelectObject(pNormalFont);
BoldFont.DeleteObject();
pDC->SelectStockObject(BLACK_PEN);
pDC->MoveTo(rc.left, rc.bottom);
pDC->LineTo(rc.right, rc.bottom);
}
//print footer with a line and date, and page number
void CGridCtrl::PrintFooter(CDC *pDC, CPrintInfo *pInfo)
{
CRect rc(pInfo->m_rectDraw);
CFont BoldFont;
LOGFONT lf;
//draw line
pDC->MoveTo(rc.left, rc.top);
pDC->LineTo(rc.right, rc.top);
//create bold font for header and footer
m_PrinterFont.GetLogFont(&lf);
lf.lfWeight = FW_BOLD;
BoldFont.CreateFontIndirect(&lf);
CFont *pNormalFont = pDC->SelectObject(&BoldFont);
int nPrevBkMode = pDC->SetBkMode(TRANSPARENT);
// draw page number
CString sTemp ;
rc.OffsetRect(0, m_CharSize.cy/2);
sTemp.Format(_T("Page %d of %d"), pInfo->m_nCurPage, pInfo->GetMaxPage());
pDC->DrawText(sTemp,-1,rc, DT_LEFT | DT_SINGLELINE | DT_NOPREFIX | DT_NOCLIP | DT_VCENTER);
CTime t = CTime::GetCurrentTime();
sTemp = t.Format(_T("%c"));
pDC->DrawText(sTemp,-1,rc, DT_RIGHT | DT_SINGLELINE | DT_NOPREFIX | DT_NOCLIP | DT_VCENTER);
pDC->SetBkMode(nPrevBkMode);
pDC->SelectObject(pNormalFont);
BoldFont.DeleteObject();
}
void CGridCtrl::OnEndPrinting(CDC* /*pDC*/, CPrintInfo* /*pInfo*/)
{
m_PrinterFont.DeleteObject();
}
#endif // !defined(_WIN32_WCE_NO_PRINTING) && !defined(GRIDCONTROL_NO_PRINTING)
#ifndef _WIN32_WCE
/////////////////////////////////////////////////////////////////////////////
// CGridCtrl persistance
BOOL CGridCtrl::Save(LPCTSTR filename)
{
CStdioFile File;
CFileException ex;
if (!File.Open(filename, CFile::modeWrite | CFile::modeCreate| CFile::typeText, &ex)) {
ex.ReportError();
return FALSE;
}
TRY {
int nNumColumns = GetColumnCount();
for (int i = 0; i < nNumColumns; i++) {
File.WriteString(GetItemText(0,i));
File.WriteString((i==(nNumColumns-1))? _T("n"):_T(","));
}
for (i = 0; i < GetRowCount(); i++) {
for (int j = 0; j < nNumColumns; j++) {
File.WriteString(GetItemText(i,j));
File.WriteString((j==(nNumColumns-1))? _T("n"):_T(","));
}
}
File.Close();
}
CATCH (CFileException, e) {
AfxMessageBox(_T("Unable to save grid list"));
e->Delete();
return FALSE;
}
END_CATCH
return TRUE;
}
BOOL CGridCtrl::Load(LPCTSTR filename)
{
TCHAR *token, *end;
TCHAR buffer[1024];
CStdioFile File;
CFileException ex;
if (!File.Open(filename, CFile::modeRead | CFile::typeText)) {
ex.ReportError();
return FALSE;
}
DeleteAllItems();
TRY {
// Read Header off file
File.ReadString(buffer, 1024);
// Get first token
for (token=buffer, end=buffer;
*end && (*end != _T(',')) && (*end != _T('n')); end++);
if ((*end == _T('')) && (token == end)) token = NULL;
*end = _T('');
while (token)
{
InsertColumn(token);
// Get next token
for (token=++end; *end && (*end != _T(',')) && (*end != _T('n'));
end++);
if ((*end == _T('')) && (token == end)) token = NULL;
*end = _T('');
}
// Read in rest of data
int nItem = 0;
while (File.ReadString(buffer, 1024)) {
// Get first token
for (token=buffer, end=buffer;
*end && (*end != _T(',')) && (*end != _T('n')); end++);
if ((*end == _T('')) && (token == end)) token = NULL;
*end = _T('');
int nSubItem = 0;
while (token) {
if (!nSubItem)
InsertRow(token);
else
SetItemText(nItem, nSubItem, token);
// Get next token
for (token=++end; *end && (*end != _T(',')) && (*end != _T('n'));
end++);
if ((*end == _T('')) && (token == end)) token = NULL;
*end = _T('');
nSubItem++;
}
nItem++;
}
AutoSizeColumns();
File.Close();
}
CATCH (CFileException, e) {
AfxMessageBox(_T("Unable to load grid data"));
e->Delete();
return FALSE;
}
END_CATCH
return TRUE;
}
#endif
/////////////////////////////////////////////////////////////////////////////
// CGridCtrl overrideables
#ifndef GRIDCONTROL_NO_DRAGDROP
// This is no longer needed since I've changed to OLE drag and drop - but it's
// still cool code. :)
CImageList* CGridCtrl::CreateDragImage(CPoint *pHotSpot)
{
CDC* pDC = GetDC();
if (!pDC) return NULL;
CRect rect;
CCellID cell = GetFocusCell();
if (!GetCellRect(cell.row, cell.col, rect)) return NULL;
// Translate coordinate system
rect.BottomRight() = CPoint(rect.Width(), rect.Height());
rect.TopLeft() = CPoint(0,0);
*pHotSpot = rect.BottomRight();
// Create a new imagelist (the caller of this function has responsibility
// for deleting this list)
CImageList* pList = new CImageList;
if (!pList || !pList->Create(rect.Width(), rect.Height(), ILC_MASK, 1,1))
{
if (pList) delete pList;
return NULL;
}
// Create mem DC and bitmap
CDC MemDC;
CBitmap bm;
MemDC.CreateCompatibleDC(pDC);
bm.CreateCompatibleBitmap(pDC, rect.Width(), rect.Height());
CBitmap* pOldBitmap = MemDC.SelectObject(&bm);
MemDC.SetWindowOrg(0,0);
// Draw cell onto bitmap in memDC
DrawCell(&MemDC, cell.row, cell.col, rect, TRUE);
// Clean up
MemDC.SelectObject(pOldBitmap);
ReleaseDC(pDC);
// Add the bitmap we just drew to the image list.
pList->Add(&bm, GetTextBkColor());
bm.DeleteObject();
return pList;
}
#endif
void CGridCtrl::OnFixedRowClick(CCellID& cell)
{
if (!IsValid(cell))
return;
if (m_bListMode)
{
if (!m_bSortOnClick)
return;
CWaitCursor waiter;
if (cell.col == m_SortColumn)
m_bAscending = !m_bAscending;
else
{
m_bAscending = TRUE;
m_SortColumn = cell.col;
}
SortTextItems(m_SortColumn, m_bAscending);
Invalidate();
}
else if (cell.col < GetFixedColumnCount())
{
m_MouseMode = MOUSE_SELECT_ALL;
OnSelecting(cell);
}
else
{
m_MouseMode = MOUSE_SELECT_COL;
OnSelecting(cell);
}
}
void CGridCtrl::OnFixedColumnClick(CCellID& cell)
{
if (!IsValid(cell))
return;
// if (m_bListMode && (GetItemState(cell.row, m_nFixedCols) & GVNI_SELECTED))
// {
// OnEditCell(cell.row, cell.col, VK_LBUTTON);
// return;
// }
if (cell.row < GetFixedRowCount())
{
m_MouseMode = MOUSE_SELECT_ALL;
OnSelecting(cell);
}
else
{
m_MouseMode = MOUSE_SELECT_ROW;
OnSelecting(cell);
}
}
// Gets the extent of the text pointed to by str (no CDC needed)
// By default this uses the selected font (which is a bigger font)
CSize CGridCtrl::GetTextExtent(LPCTSTR str, BOOL bUseSelectedFont /* = TRUE */)
{
CDC* pDC = GetDC();
if (!pDC) return CSize(0,0);
CFont *pOldFont, font;
if (bUseSelectedFont)
{
LOGFONT lf;
memcpy(&lf, &m_Logfont, sizeof(LOGFONT));
lf.lfWeight = SELECTED_CELL_FONT_WEIGHT;
font.CreateFontIndirect(&lf);
pOldFont = pDC->SelectObject(&font);
}
else
pOldFont = pDC->SelectObject(&m_Font);
CSize size = pDC->GetTextExtent(str);
pDC->SelectObject(pOldFont);
ReleaseDC(pDC);
return size + CSize(2*m_nMargin, 2*m_nMargin);
}
CSize CGridCtrl::GetCellExtent(int nRow, int nCol, CDC* pDC)
{
LOGFONT *pLF = GetItemFont(nRow, nCol);
// use selected font since it's thicker
LOGFONT lf;
memcpy(&lf, pLF, sizeof(LOGFONT));
if (nRow < m_nFixedRows || nCol < m_nFixedCols)
lf.lfWeight = SELECTED_CELL_FONT_WEIGHT;
CFont font;
font.CreateFontIndirect(&lf);
CFont* pOldFont = pDC->SelectObject(&font);
CSize size = pDC->GetTextExtent(GetItemText(nRow, nCol));
pDC->SelectObject(pOldFont);
size += CSize(4*m_nMargin, 2*m_nMargin);
CSize ImageSize(0,0);
if (m_pImageList) {
int nImage = GetItemImage(nRow, nCol);
if (nImage >= 0) {
IMAGEINFO Info;
if (m_pImageList->GetImageInfo(nImage, &Info))
ImageSize = CSize(Info.rcImage.right-Info.rcImage.left+1,
Info.rcImage.bottom-Info.rcImage.top+1);
}
}
return CSize(size.cx + ImageSize.cx, max(size.cy, ImageSize.cy));
}
BOOL CGridCtrl::DrawFixedCell(CDC* pDC, int nRow, int nCol, CRect rect, BOOL bEraseBk)
{
if (!m_bAllowDraw)
return FALSE;
GV_ITEM Item;
Item.mask = GVIF_TEXT | GVIF_FORMAT | GVIF_IMAGE | GVIF_BKCLR | GVIF_FGCLR;
Item.row = nRow;
Item.col = nCol;
if (!GetItem(&Item))
return FALSE;
// Force redraw of background if custom colour
//if (Item.crBkClr != CLR_DEFAULT)
bEraseBk = TRUE;
if (bEraseBk
#if !defined(_WIN32_WCE_NO_PRINTING) && !defined(GRIDCONTROL_NO_PRINTING)
&& !pDC->IsPrinting()
#endif
)
{
CBrush brush((Item.crBkClr == CLR_DEFAULT)? GetFixedBkColor() : Item.crBkClr);
pDC->FillRect(rect, &brush);
}
pDC->SetTextColor((Item.crFgClr == CLR_DEFAULT)? GetFixedTextColor() : Item.crFgClr);
int nSavedDC = pDC->SaveDC();
// Create the appropriate font and select into DC
LOGFONT *pLF = GetItemFont(nRow, nCol);
CCellID FocusCell = GetFocusCell();
// if (IsCellFixed(nRow, nCol) && (FocusCell.row == nRow || FocusCell.col == nCol))
//{
if (FocusCell.row == nRow || FocusCell.col == nCol)
{
static LOGFONT lf;
memcpy(&lf, pLF, sizeof(LOGFONT));
lf.lfWeight = SELECTED_CELL_FONT_WEIGHT;
pLF = &lf;
}
CFont Font;
Font.CreateFontIndirect(pLF);
pDC->SelectObject(&Font);
if (IsValid(FocusCell) && (FocusCell.row == nRow || FocusCell.col == nCol))
{
rect.right++; rect.bottom++;
pDC->DrawEdge(rect, BDR_SUNKENINNER /*EDGE_RAISED*/, BF_RECT);
rect.DeflateRect(1,1);
}
else
{
CPen lightpen(PS_SOLID, 1, ::GetSysColor(COLOR_3DHIGHLIGHT)),
darkpen(PS_SOLID, 1, ::GetSysColor(COLOR_3DDKSHADOW)),
*pOldPen = pDC->GetCurrentPen();
pDC->SelectObject(&lightpen);
pDC->MoveTo(rect.right, rect.top);
pDC->LineTo(rect.left, rect.top);
pDC->LineTo(rect.left, rect.bottom);
pDC->SelectObject(&darkpen);
pDC->MoveTo(rect.right, rect.top);
pDC->LineTo(rect.right, rect.bottom);
pDC->LineTo(rect.left, rect.bottom);
pDC->SelectObject(pOldPen);
rect.DeflateRect(1,1);
}
pDC->SetBkMode(TRANSPARENT);
rect.DeflateRect(m_nMargin, 0);
if (m_pImageList && Item.iImage >= 0)
{
IMAGEINFO Info;
if (m_pImageList->GetImageInfo(Item.iImage, &Info))
{
//CRgn rgn;
//rgn.CreateRectRgnIndirect(rect);
//pDC->SelectClipRgn(&rgn);
//rgn.DeleteObject();
int nImageWidth = Info.rcImage.right-Info.rcImage.left+1;
m_pImageList->Draw(pDC, Item.iImage, rect.TopLeft(), ILD_NORMAL);
rect.left += nImageWidth+m_nMargin;
}
}
DrawText(pDC->m_hDC, Item.szText, -1, rect, Item.nFormat);
pDC->RestoreDC(nSavedDC);
Font.DeleteObject();
return TRUE;
}
BOOL CGridCtrl::DrawCell(CDC* pDC, int nRow, int nCol, CRect rect, BOOL bEraseBk)
{
if (!m_bAllowDraw)
return FALSE;
GV_ITEM Item;
Item.mask = GVIF_TEXT | GVIF_FORMAT | GVIF_STATE | GVIF_IMAGE | GVIF_BKCLR | GVIF_FGCLR;
Item.row = nRow;
Item.col = nCol;
if (!GetItem(&Item))
return FALSE;
COLORREF TextBkClr = (Item.crBkClr == CLR_DEFAULT)? GetTextBkColor() : Item.crBkClr;
COLORREF TextClr = (Item.crFgClr == CLR_DEFAULT)? GetTextColor() : Item.crFgClr;
// Force redraw of background if custom colour
//if (Item.crBkClr != CLR_DEFAULT)
bEraseBk = TRUE;
int nSavedDC = pDC->SaveDC();
pDC->SetBkMode(TRANSPARENT);
if (Item.state & GVIS_FOCUSED
#if !defined(_WIN32_WCE_NO_PRINTING) && !defined(GRIDCONTROL_NO_PRINTING)
&& !pDC->IsPrinting()
#endif
)
{
rect.right++; rect.bottom++; // FillRect doesn't draw RHS or bottom
if (bEraseBk)
{
CBrush brush(TextBkClr);
pDC->FillRect(rect, &brush);
}
rect.right--; rect.bottom--;
pDC->SelectStockObject(BLACK_PEN);
pDC->SelectStockObject(NULL_BRUSH);
pDC->Rectangle(rect);
pDC->SetTextColor(TextClr);
rect.DeflateRect(1,1);
}
else if (Item.state & GVIS_SELECTED
#if !defined(_WIN32_WCE_NO_PRINTING) && !defined(GRIDCONTROL_NO_PRINTING)
&& !pDC->IsPrinting()
#endif
)
{
rect.right++; rect.bottom++; // FillRect doesn't draw RHS or bottom
pDC->FillSolidRect(rect, ::GetSysColor(COLOR_HIGHLIGHT));
rect.right--; rect.bottom--;
pDC->SetTextColor(::GetSysColor(COLOR_HIGHLIGHTTEXT));
} else {
rect.right++; rect.bottom++; // FillRect doesn't draw RHS or bottom
if (bEraseBk)
{
CBrush brush(TextBkClr);
pDC->FillRect(rect, &brush);
}
rect.right--; rect.bottom--;
pDC->SetTextColor(TextClr);
}
if (Item.state & GVIS_DROPHILITED
#if !defined(_WIN32_WCE_NO_PRINTING) && !defined(GRIDCONTROL_NO_PRINTING)
&& !pDC->IsPrinting()
#endif
)
{
pDC->SelectStockObject(BLACK_PEN);
pDC->SelectStockObject(NULL_BRUSH);
pDC->Rectangle(rect);
}
// Create the appropriate font and select into DC
LOGFONT *pLF = GetItemFont(nRow, nCol);
//CCellID FocusCell = GetFocusCell();
//if (IsCellFixed(nRow, nCol) && (FocusCell.row == nRow || FocusCell.col == nCol))
//{
// static LOGFONT lf;
// memcpy(&lf, pLF, sizeof(LOGFONT));
// lf.lfWeight = SELECTED_CELL_FONT_WEIGHT;
// pLF = &lf;
//}
CFont Font;
Font.CreateFontIndirect(pLF);
pDC->SelectObject(&Font);
rect.DeflateRect(m_nMargin, 0);
if (m_pImageList && Item.iImage >= 0)
{
IMAGEINFO Info;
if (m_pImageList->GetImageInfo(Item.iImage, &Info))
{
//CRgn rgn;
//rgn.CreateRectRgnIndirect(rect);
//pDC->SelectClipRgn(&rgn);
//rgn.DeleteObject();
int nImageWidth = Info.rcImage.right-Info.rcImage.left+1;
m_pImageList->Draw(pDC, Item.iImage, rect.TopLeft(), ILD_NORMAL);
rect.left += nImageWidth+m_nMargin;
}
}
DrawText(pDC->m_hDC, Item.szText, -1, rect, Item.nFormat);
pDC->RestoreDC(nSavedDC);
Font.DeleteObject();
return TRUE;
}
void CGridCtrl::OnEditCell(int nRow, int nCol, UINT nChar)
{
EnsureVisible(nRow, nCol);
CCellID cell(nRow, nCol);
if (!IsValid(cell) || !IsCellEditable(nRow, nCol) || !IsCellVisible(nRow, nCol))
return;
CRect rect;
if (!GetCellRect(cell, rect)) return;
SendMessageToParent(nRow, nCol, GVN_BEGINLABELEDIT);
GV_ITEM Item;
Item.mask = GVIF_TEXT | GVIF_FORMAT;
Item.row = nRow;
Item.col = nCol;
if (!GetItem(&Item)) return;
DWORD dwStyle = ES_LEFT;
if (Item.nFormat & DT_RIGHT) dwStyle = ES_RIGHT;
else if (Item.nFormat & DT_CENTER) dwStyle = ES_CENTER;
CreateInPlaceEditControl(rect, dwStyle, IDC_INPLACE_CONTROL,
nRow, nCol, Item.szText, nChar);
}
void CGridCtrl::CreateInPlaceEditControl(CRect& rect, DWORD dwStyle, UINT nID,
int nRow, int nCol,
LPCTSTR szText, int nChar)
{
// InPlaceEdit auto-deletes itself
new CInPlaceEdit(this, rect, dwStyle, nID, nRow, nCol, szText, nChar);
}
void CGridCtrl::OnEndEditCell(int nRow, int nCol, CString str)
{
CString strCurrent = GetItemText(nRow,nCol);
if (strCurrent != str)
{
SetModified(TRUE, nRow, nCol);
SetItemText(nRow, nCol, str);
}
}
CString CGridCtrl::GetItemText(int nRow, int nCol)
{
if (nRow < 0 || nRow >= m_nRows || nCol < 0 || nCol >= m_nCols) return "";
CGridCell* pCell = GetCell(nRow, nCol);
ASSERT(pCell);
if (!pCell) return "";
return pCell->szText;
}