reactos/base/applications/charmap_new/GridView.cpp

523 lines
12 KiB
C++
Raw Normal View History

/*
* PROJECT: ReactOS Character Map
* LICENSE: GPL - See COPYING in the top level directory
* FILE: base/applications/charmap/GridView.cpp
* PURPOSE: Class for for the window which contains the font matrix
* COPYRIGHT: Copyright 2015 Ged Murphy <gedmurphy@reactos.org>
*/
#include "precomp.h"
#include "GridView.h"
#include "Cell.h"
/* DATA *****************************************************/
extern HINSTANCE g_hInstance;
/* PUBLIC METHODS **********************************************/
CGridView::CGridView() :
m_xNumCells(20),
m_yNumCells(10),
m_ScrollPosition(0),
m_NumRows(0)
{
m_szMapWndClass = L"CharGridWClass";
}
CGridView::~CGridView()
{
}
bool
CGridView::Create(
_In_ HWND hParent
)
{
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);
}
bool
CGridView::SetFont(
_In_ CAtlString& FontName
)
{
// 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;
}
/* PRIVATE METHODS **********************************************/
bool
CGridView::UpdateCellCoordinates(
)
{
// 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;
}
LRESULT
CGridView::OnCreate(
_In_ HWND hwnd,
_In_ HWND hParent
)
{
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;
}
LRESULT
CGridView::OnSize(
_In_ INT Width,
_In_ INT Height
)
{
// 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;
}
VOID
CGridView::OnVScroll(_In_ INT Value,
_In_ INT Pos)
{
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);
}
}
}
LRESULT
CGridView::OnPaint(
_In_opt_ HDC hdc
)
{
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;
}
LRESULT
CALLBACK
CGridView::MapWndProc(
HWND hwnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam
)
{
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;
}
void
CGridView::DrawGrid(
_In_ LPPAINTSTRUCT PaintStruct
)
{
// 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);
}
void
CGridView::DeleteCells()
{
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;
}
void
CGridView::SetCellFocus(
_In_ CCell* NewActiveCell
)
{
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);
}