CGridView Class Reference

#include <GridView.h>

Collaboration diagram for CGridView:

Public Member Functions
	CGridView ()
	~CGridView ()
bool	Create (_In_ HWND hParent)
bool	SetFont (_In_ CAtlString &FontName)
HWND	GetHwnd ()

Private Member Functions
LRESULT	OnCreate (_In_ HWND hwnd, _In_ HWND hParent)
LRESULT	OnSize (_In_ INT Width, _In_ INT Height)
VOID	OnVScroll (_In_ INT Value, _In_ INT Pos)
LRESULT	OnPaint (_In_opt_ HDC hdc)
bool	UpdateCellCoordinates ()
void	DrawGrid (_In_ LPPAINTSTRUCT PaintStruct)
void	DeleteCells ()
void	SetCellFocus (_In_ CCell *NewActiveCell)

Static Private Member Functions
static LRESULT CALLBACK	MapWndProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)

Private Attributes
CAtlStringW	m_szMapWndClass
HWND	m_hwnd
HWND	m_hParent
int	m_xNumCells
int	m_yNumCells
RECT	m_ClientCoordinates
SIZE	m_CellSize
CCell ***	m_Cells
CCell *	m_ActiveCell
INT	m_ScrollPosition
int	m_NumRows
CurrentFont	m_CurrentFont

Detailed Description

Definition at line 16 of file GridView.h.

Constructor & Destructor Documentation

CGridView()

CGridView::CGridView

(

)

Definition at line 22 of file GridView.cpp.

                     :
    m_xNumCells(20),
    m_yNumCells(10),
    m_ScrollPosition(0),
    m_NumRows(0)
{
    m_szMapWndClass = L"CharGridWClass";
}

~CGridView()

CGridView::~CGridView

(

)

Definition at line 31 of file GridView.cpp.

{
}

Member Function Documentation

Create()

bool CGridView::Create

(

_In_ HWND

hParent

)

Definition at line 36 of file GridView.cpp.

{
    WNDCLASSW wc = { 0 };
    wc.style = CS_DBLCLKS;
    wc.lpfnWndProc = MapWndProc;
    wc.cbWndExtra = sizeof(CGridView *);
    wc.hInstance = g_hInstance;
    wc.hCursor = LoadCursorW(NULL, (LPWSTR)IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    wc.lpszClassName = m_szMapWndClass;
 
    if (RegisterClassW(&wc))
    {
        m_hwnd = CreateWindowExW(0,
                                 m_szMapWndClass,
                                 NULL,
                                 WS_CHILD | WS_VISIBLE | WS_TABSTOP | WS_VSCROLL,
                                 0,0,0,0,
                                 hParent,
                                 NULL,
                                 g_hInstance,
                                 this);
 
    }
 
    return !!(m_hwnd != NULL);
}

Referenced by CCharMapWindow::OnCreate().

DeleteCells()

void CGridView::DeleteCells ( )

private

Definition at line 494 of file GridView.cpp.

{
    if (m_Cells == nullptr)
        return;
 
    // Free cells withing the 2d array
    for (int i = 0; i < m_yNumCells; i++)
        delete[] m_Cells[i];
    delete[] m_Cells;
 
    m_Cells = nullptr;
}

DrawGrid()

void CGridView::DrawGrid ( _In_ LPPAINTSTRUCT  PaintStruct )

private

Definition at line 463 of file GridView.cpp.

{
    // Calculate which glyph to start at based on scroll position
    int i;
    i = m_xNumCells * m_ScrollPosition;
 
    // Make sure we have the correct font on the DC
    HFONT hOldFont;
    hOldFont = (HFONT)SelectFont(PaintStruct->hdc,
                                 m_CurrentFont.hFont);
 
    // Traverse all the cells
    for (int y = 0; y < m_yNumCells; y++)
    for (int x = 0; x < m_xNumCells; x++)
    {
        // Update the glyph for this cell
        WCHAR ch = (WCHAR)m_CurrentFont.ValidGlyphs[i];
        m_Cells[y][x]->SetChar(ch);
 
        // Tell it to paint itself
        m_Cells[y][x]->OnPaint(*PaintStruct);
        i++;
    }
 
    SelectObject(PaintStruct->hdc, hOldFont);
 
}

Referenced by OnPaint().

GetHwnd()

HWND CGridView::GetHwnd ( )

inline

Definition at line 49 of file GridView.h.

{ return m_hwnd; }

Referenced by CCharMapWindow::OnSize().

MapWndProc()

LRESULT CALLBACK CGridView::MapWndProc ( HWND  hwnd, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

staticprivate

Definition at line 382 of file GridView.cpp.

{
    CGridView *This;
    LRESULT RetCode = 0;
 
    // Get the object pointer from window context
    This = (CGridView *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
    if (This == NULL)
    {
        // Check that this isn't a create message
        if (uMsg != WM_CREATE)
        {
            // Don't handle null info pointer
            goto HandleDefaultMessage;
        }
    }
 
    switch (uMsg)
    {
    case WM_CREATE:
    {
        // Get the object pointer from the create param
        This = (CGridView *)((LPCREATESTRUCT)lParam)->lpCreateParams;
 
        // Store the pointer in the window's global user data
        SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)This);
 
        This->OnCreate(hwnd, ((LPCREATESTRUCTW)lParam)->hwndParent);
        break;
    }
 
    case WM_SIZE:
    {
        INT Width, Height;
        Width = LOWORD(lParam);
        Height = HIWORD(lParam);
 
        This->OnSize(Width, Height);
        break;
    }
 
    case WM_VSCROLL:
    {
        INT Value, Pos;
        Value = LOWORD(wParam);
        Pos = HIWORD(wParam);
 
        This->OnVScroll(Value, Pos);
        break;
    }
 
    case WM_PAINT:
    {
        This->OnPaint((HDC)wParam);
        break;
    }
 
    case WM_DESTROY:
    {
        This->DeleteCells();
        break;
    }
 
    default:
    {
HandleDefaultMessage:
        RetCode = DefWindowProcW(hwnd, uMsg, wParam, lParam);
        break;
    }
    }
 
    return RetCode;
}

Referenced by Create().

OnCreate()

LRESULT CGridView::OnCreate ( _In_ HWND  hwnd, _In_ HWND  hParent  )

private

Definition at line 175 of file GridView.cpp.

{
    m_hwnd = hwnd;
    m_hParent = hParent;
 
    // C++ doesn't allow : "CCells ***C = new CCell***[x * y]"
    // so we have to build the 2d array up manually
    m_Cells = new CCell**[m_yNumCells]; // rows
    for (int i = 0; i < m_yNumCells; i++)
        m_Cells[i] = new CCell*[m_xNumCells]; // columns
 
    for (int y = 0; y < m_yNumCells; y++)
    for (int x = 0; x < m_xNumCells; x++)
    {
        m_Cells[y][x] = new CCell(m_hwnd);
    }
 
    // Give the first cell focus
    SetCellFocus(m_Cells[0][0]);
 
    return 0;
}

OnPaint()

LRESULT CGridView::OnPaint ( _In_opt_ HDC  hdc )

private

Definition at line 337 of file GridView.cpp.

{
    PAINTSTRUCT PaintStruct = { 0 };
    HDC LocalHdc = NULL;
    BOOL bSuccess = FALSE;
 
    // Check if we were passed a DC
    if (hdc == NULL)
    {
        // We weren't, let's get one
        LocalHdc = BeginPaint(m_hwnd, &PaintStruct);
        if (LocalHdc) bSuccess = TRUE;
    }
    else
    {
        // Use the existing DC and just get the region to paint
        bSuccess = GetUpdateRect(m_hwnd,
                                 &PaintStruct.rcPaint,
                                 TRUE);
        if (bSuccess)
        {
            // Update the struct with the DC we were passed
            PaintStruct.hdc = (HDC)hdc;
        }
    }
 
    // Make sure we have a valid DC
    if (bSuccess)
    {
        // Paint the grid and chars
        DrawGrid(&PaintStruct);
 
        if (LocalHdc)
        {
            EndPaint(m_hwnd, &PaintStruct);
        }
    }
 
    return 0;
}

OnSize()

LRESULT CGridView::OnSize ( _In_ INT  Width, _In_ INT  Height  )

private

Definition at line 202 of file GridView.cpp.

{
    // Get the client area of the main dialog
    RECT ParentRect;
    GetClientRect(m_hParent, &ParentRect);
 
    // Calculate the grid size using the parent
    m_ClientCoordinates.left = ParentRect.left + 25;
    m_ClientCoordinates.top = ParentRect.top + 50;
    m_ClientCoordinates.right = ParentRect.right - m_ClientCoordinates.left - 10;
    m_ClientCoordinates.bottom = ParentRect.bottom - m_ClientCoordinates.top - 70;
 
    // Resize the grid window
    SetWindowPos(m_hwnd,
                 NULL,
                 m_ClientCoordinates.left,
                 m_ClientCoordinates.top,
                 m_ClientCoordinates.right,
                 m_ClientCoordinates.bottom,
                 SWP_NOZORDER | SWP_SHOWWINDOW);
 
    // Get the client area we can draw on. The position we set above includes
    // a scrollbar which we obviously can't draw on. GetClientRect gives us
    // the size without the scroll, and it's more efficient than getting the
    // scroll metrics and calculating the size from that
    RECT ClientRect;
    GetClientRect(m_hwnd, &ClientRect);
    m_CellSize.cx = ClientRect.right / m_xNumCells;
    m_CellSize.cy = ClientRect.bottom / m_yNumCells;
 
    // Let all the cells know about their new coords
    UpdateCellCoordinates();
 
    // We scale the font size up or down depending on the cell size
    if (m_CurrentFont.hFont)
    {
        // Delete the existing font
        DeleteObject(m_CurrentFont.hFont);
 
        HDC hdc;
        hdc = GetDC(m_hwnd);
        if (hdc)
        {
            // Update the font size with respect to the cell size
            m_CurrentFont.Font.lfHeight = (m_CellSize.cy - 5);
            m_CurrentFont.hFont = CreateFontIndirectW(&m_CurrentFont.Font);
            ReleaseDC(m_hwnd, hdc);
        }
    }
 
    // Redraw the whole grid
    InvalidateRect(m_hwnd, &ClientRect, TRUE);
 
    return 0;
}

OnVScroll()

VOID CGridView::OnVScroll ( _In_ INT  Value, _In_ INT  Pos  )

private

Definition at line 262 of file GridView.cpp.

{
    INT PrevScrollPosition = m_ScrollPosition;
 
    switch (Value)
    {
    case SB_LINEUP:
        m_ScrollPosition -= 1;
        break;
 
    case SB_LINEDOWN:
        m_ScrollPosition += 1;
        break;
 
    case SB_PAGEUP:
        m_ScrollPosition -= m_yNumCells;
        break;
 
    case SB_PAGEDOWN:
        m_ScrollPosition += m_yNumCells;
        break;
 
    case SB_THUMBTRACK:
        m_ScrollPosition = Pos;
        break;
 
    default:
        break;
    }
 
    // Make sure we don't scroll past row 0 or max rows
    m_ScrollPosition = max(0, m_ScrollPosition);
    m_ScrollPosition = min(m_ScrollPosition, m_NumRows);
 
    // Check if there's a difference from the previous position
    INT ScrollDiff;
    ScrollDiff = PrevScrollPosition - m_ScrollPosition;
    if (ScrollDiff)
    {
        // Set the new scrollbar position in the scroll box
        SetScrollPos(m_hwnd,
                     SB_VERT,
                     m_ScrollPosition,
                     TRUE);
 
        // Check if the scrollbar has moved more than the
        // number of visible rows (draged or paged)
        if (abs(ScrollDiff) < m_yNumCells)
        {
            RECT rect;
            GetClientRect(m_hwnd, &rect);
 
            // Scroll the visible cells which remain within the grid
            // and invalidate any new ones which appear from the top / bottom
            ScrollWindowEx(m_hwnd,
                           0,
                           ScrollDiff * m_CellSize.cy,
                           &rect,
                           &rect,
                           NULL,
                           NULL,
                           SW_INVALIDATE);
        }
        else
        {
            // All the cells need to be redrawn
            InvalidateRect(m_hwnd,
                           NULL,
                           TRUE);
        }
    }
}

SetCellFocus()

void CGridView::SetCellFocus ( _In_ CCell *  NewActiveCell )

private

Definition at line 508 of file GridView.cpp.

{
    if (m_ActiveCell)
    {
        // Remove focus from any existing cell
        m_ActiveCell->SetFocus(false);
        InvalidateRect(m_hwnd, m_ActiveCell->GetCellCoordinates(), TRUE);
    }
 
    // Set the new active cell and give it focus
    m_ActiveCell = NewActiveCell;
    m_ActiveCell->SetFocus(true);
}

Referenced by OnCreate().

SetFont()

bool CGridView::SetFont

(

_In_ CAtlString &

FontName

)

Definition at line 67 of file GridView.cpp.

{
 
    // Create a temporary container for the new font
    CurrentFont NewFont = { 0 };
    NewFont.FontName = FontName;
 
    // Get the DC for the full grid window
    HDC hdc;
    hdc = GetDC(m_hwnd);
    if (hdc == NULL) return false;
 
    // Setup the logfont structure
    NewFont.Font.lfHeight = 0; // This is set in WM_SIZE
    NewFont.Font.lfCharSet = DEFAULT_CHARSET;
    StringCchCopyW(NewFont.Font.lfFaceName, LF_FACESIZE, FontName);
 
    // Get a handle to the new font
    NewFont.hFont = CreateFontIndirectW(&NewFont.Font);
    if (NewFont.hFont == NULL)
    {
        ReleaseDC(m_hwnd, hdc);
        return false;
    }
 
    // Setup an array of all possible non-BMP indices
    WCHAR ch[MAX_GLYPHS];
    for (int i = 0; i < MAX_GLYPHS; i++)
        ch[i] = (WCHAR)i;
 
    HFONT hOldFont;
    hOldFont = (HFONT)SelectObject(hdc, NewFont.hFont);
 
    // Translate all the indices into glyphs
    WORD out[MAX_GLYPHS];
    DWORD Status;
    Status = GetGlyphIndicesW(hdc,
                              ch,
                              MAX_GLYPHS,
                              out,
                              GGI_MARK_NONEXISTING_GLYPHS);
    ReleaseDC(m_hwnd, hdc);
    if (Status == GDI_ERROR)
    {
        SelectObject(hdc, hOldFont);
        return false;
    }
 
    // Loop all the glyphs looking for valid ones
    // and store those in our font data
    int j = 0;
    for (int i = 0; i < MAX_GLYPHS; i++)
    {
        if (out[i] != 0xffff)
        {
            NewFont.ValidGlyphs[j] = ch[i];
            j++;
        }
    }
    NewFont.NumValidGlyphs = j;
 
    // Calculate the number of rows required to hold all glyphs
    m_NumRows = NewFont.NumValidGlyphs / m_xNumCells;
    if (NewFont.NumValidGlyphs % m_xNumCells)
        m_NumRows += 1;
 
    // Set the scrollbar in relation to the rows
    SetScrollRange(m_hwnd, SB_VERT, 0, m_NumRows - m_yNumCells, FALSE);
 
    // We're done, update the current font
    m_CurrentFont = NewFont;
 
    // We changed the font, we'll need to repaint the whole window
    InvalidateRect(m_hwnd,
                   NULL,
                   TRUE);
 
    return true;
}

Referenced by CCharMapWindow::ChangeMapFont().

UpdateCellCoordinates()

bool CGridView::UpdateCellCoordinates ( )

private

Definition at line 154 of file GridView.cpp.

{
    // Go through all the cells and calculate
    // their coordinates within the grid
    for (int y = 0; y < m_yNumCells; y++)
    for (int x = 0; x < m_xNumCells; x++)
    {
        RECT CellCoordinates;
        CellCoordinates.left = x * m_CellSize.cx;
        CellCoordinates.top = y * m_CellSize.cy;
        CellCoordinates.right = (x + 1) * m_CellSize.cx + 1;
        CellCoordinates.bottom = (y + 1) * m_CellSize.cy + 1;
 
        m_Cells[y][x]->SetCellCoordinates(CellCoordinates);
    }
 
    return true;
}

Referenced by OnSize().

Member Data Documentation

m_ActiveCell

CCell* CGridView::m_ActiveCell

private

Definition at line 30 of file GridView.h.

Referenced by SetCellFocus().

m_Cells

CCell*** CGridView::m_Cells

private

Definition at line 29 of file GridView.h.

Referenced by DeleteCells(), DrawGrid(), OnCreate(), and UpdateCellCoordinates().

m_CellSize

SIZE CGridView::m_CellSize

private

Definition at line 28 of file GridView.h.

Referenced by OnSize(), OnVScroll(), and UpdateCellCoordinates().

m_ClientCoordinates

RECT CGridView::m_ClientCoordinates

private

Definition at line 27 of file GridView.h.

Referenced by OnSize().

m_CurrentFont

CurrentFont CGridView::m_CurrentFont

private

Definition at line 35 of file GridView.h.

Referenced by DrawGrid(), OnSize(), and SetFont().

m_hParent

HWND CGridView::m_hParent

private

Definition at line 22 of file GridView.h.

Referenced by OnCreate(), and OnSize().

m_hwnd

HWND CGridView::m_hwnd

private

Definition at line 21 of file GridView.h.

Referenced by Create(), GetHwnd(), OnCreate(), OnPaint(), OnSize(), OnVScroll(), SetCellFocus(), and SetFont().

m_NumRows

int CGridView::m_NumRows

private

Definition at line 33 of file GridView.h.

Referenced by OnVScroll(), and SetFont().

m_ScrollPosition

INT CGridView::m_ScrollPosition

private

Definition at line 32 of file GridView.h.

Referenced by DrawGrid(), and OnVScroll().

m_szMapWndClass

CAtlStringW CGridView::m_szMapWndClass

private

Definition at line 19 of file GridView.h.

Referenced by CGridView(), and Create().

m_xNumCells

int CGridView::m_xNumCells

private

Definition at line 24 of file GridView.h.

Referenced by DrawGrid(), OnCreate(), OnSize(), SetFont(), and UpdateCellCoordinates().

m_yNumCells

int CGridView::m_yNumCells

private

Definition at line 25 of file GridView.h.

Referenced by DeleteCells(), DrawGrid(), OnCreate(), OnSize(), OnVScroll(), SetFont(), and UpdateCellCoordinates().

---

The documentation for this class was generated from the following files:

• base/applications/charmap_new/GridView.h
• base/applications/charmap_new/GridView.cpp