NotepadCalc.cpp

// NotepadCalc.cpp
// A combined Notepad + Calculator application using the standard Win32 API.
//
// Layout:
// +-------------------------------+------------------+
// | | [ display ] |
// | text editor | [C][(][)][Bksp] |
// | (Notepad area) | [7][8][9][ / ] |
// | | [4][5][6][ * ] |
// | | [1][2][3][ - ] |
// | | [0][.][%][ + ] |
// | | [ = ] |
// | | [ Insert into ]|
// | | [ Notepad ] |
// +-------------------------------+------------------+
// | status bar |
// +--------------------------------------------------+
//
// Features:
// - Multiline text editor (Notepad-style) backed by an EDIT control.
// - File menu: New, Open, Save, Save As, Exit (standard common dialogs).
// - Edit menu: Undo, Cut, Copy, Paste, Delete, Select All.
// - Calculator: a full clickable keypad docked on the right. Click digits and
// operators, press "=" to evaluate, then "Insert into Notepad" to drop the
// last calculation ("expression = answer") into the editor at the caret.
// - Calculator menu also has "Evaluate Selection / Line" (Ctrl+E) which
// evaluates the highlighted text (or current line) in the editor itself.
// - Status bar showing caret line/column and the last computed result.
//
// The expression evaluator supports + - * / %, parentheses, unary minus,
// floating point numbers, and standard operator precedence.
//
// Pure Win32 / C++ - no MFC, no .NET, no third-party libraries.

#ifndef UNICODE
#define UNICODE
#endif
#ifndef _UNICODE
#define _UNICODE
#endif

#include <windows.h>
#include <commdlg.h>
#include <commctrl.h>
#include <richedit.h>
#include <string>
#include <cwchar>
#include <cwctype>
#include <cmath>
#include <stdexcept>

#pragma comment(lib, "comdlg32.lib")
#pragma comment(lib, "comctl32.lib")
#pragma comment(lib, "user32.lib")
#pragma comment(lib, "gdi32.lib")

// ---------------------------------------------------------------------------
// Control / command identifiers
// ---------------------------------------------------------------------------
#define IDC_EDIT 1001 // main multiline editor
#define IDC_STATUS 1002 // status bar
#define IDC_CALC_DISPLAY 1003 // calculator read-only display

#define IDM_FILE_NEW 2001
#define IDM_FILE_OPEN 2002
#define IDM_FILE_SAVE 2003
#define IDM_FILE_SAVEAS 2004
#define IDM_FILE_EXIT 2005

#define IDM_EDIT_UNDO 2101
#define IDM_EDIT_REDO 2107
#define IDM_EDIT_CUT 2102
#define IDM_EDIT_COPY 2103
#define IDM_EDIT_PASTE 2104
#define IDM_EDIT_DELETE 2105
#define IDM_EDIT_SELALL 2106

// "Undo Checkpoints" submenu - when a typing run is committed as an undo step.
#define IDM_UNDO_TIME_OFF 2120 // radio: time interval
#define IDM_UNDO_TIME_05 2121
#define IDM_UNDO_TIME_1 2122
#define IDM_UNDO_TIME_2 2123
#define IDM_UNDO_TIME_5 2124
#define IDM_UNDO_ON_ENTER 2125 // toggle: checkpoint on Enter
#define IDM_UNDO_ON_PUNCT 2126 // toggle: checkpoint on . , ; : ! ?

#define IDM_CALC_EVAL 2201
#define IDM_CALC_PANEL 2202

// "Insert Result As" submenu - how Ctrl+E places the answer on the line.
#define IDM_EVAL_NEWLINE 2210
#define IDM_EVAL_APPEND 2211
#define IDM_EVAL_REPLACE_FULL 2212
#define IDM_EVAL_REPLACE_RESULT 2213

#define IDM_HELP_ABOUT 2301

// Calculator keypad buttons share a contiguous id range starting here.
#define IDC_CALC_BTN_BASE 3000

// Timer that closes the current undo group ~1 second after the last edit, so
// undo steps back in time-based chunks instead of one giant typing run.
#define IDT_UNDO_GROUP 1
#define UNDO_GROUP_MS 1000

// Button "kinds" decide what a click does.
enum CalcKind {
 K_CHAR, // append a character to the expression
 K_CLEAR, // clear the expression
 K_BACK, // backspace
 K_EQUALS, // evaluate
 K_INSERT // insert last calculation into the editor
};

struct CalcButton {
 int id;
 const wchar_t* label;
 CalcKind kind;
 wchar_t ch; // character to append when kind == K_CHAR
 int row; // grid row (1-based; row 0 is the display)
 int col; // grid column 0..3
 int colspan; // how many columns this button spans
 HWND hwnd; // filled in at creation time
};

// Keypad layout. Rows 1..7; the display occupies row 0 above these.
static CalcButton g_buttons[] = {
 { IDC_CALC_BTN_BASE + 0, L"C", K_CLEAR, 0, 1, 0, 1, nullptr },
 { IDC_CALC_BTN_BASE + 1, L"(", K_CHAR, L'(', 1, 1, 1, nullptr },
 { IDC_CALC_BTN_BASE + 2, L")", K_CHAR, L')', 1, 2, 1, nullptr },
 { IDC_CALC_BTN_BASE + 3, L"Bksp", K_BACK, 0, 1, 3, 1, nullptr },

 { IDC_CALC_BTN_BASE + 4, L"7", K_CHAR, L'7', 2, 0, 1, nullptr },
 { IDC_CALC_BTN_BASE + 5, L"8", K_CHAR, L'8', 2, 1, 1, nullptr },
 { IDC_CALC_BTN_BASE + 6, L"9", K_CHAR, L'9', 2, 2, 1, nullptr },
 { IDC_CALC_BTN_BASE + 7, L"/", K_CHAR, L'/', 2, 3, 1, nullptr },

 { IDC_CALC_BTN_BASE + 8, L"4", K_CHAR, L'4', 3, 0, 1, nullptr },
 { IDC_CALC_BTN_BASE + 9, L"5", K_CHAR, L'5', 3, 1, 1, nullptr },
 { IDC_CALC_BTN_BASE + 10, L"6", K_CHAR, L'6', 3, 2, 1, nullptr },
 { IDC_CALC_BTN_BASE + 11, L"*", K_CHAR, L'*', 3, 3, 1, nullptr },

 { IDC_CALC_BTN_BASE + 12, L"1", K_CHAR, L'1', 4, 0, 1, nullptr },
 { IDC_CALC_BTN_BASE + 13, L"2", K_CHAR, L'2', 4, 1, 1, nullptr },
 { IDC_CALC_BTN_BASE + 14, L"3", K_CHAR, L'3', 4, 2, 1, nullptr },
 { IDC_CALC_BTN_BASE + 15, L"-", K_CHAR, L'-', 4, 3, 1, nullptr },

 { IDC_CALC_BTN_BASE + 16, L"0", K_CHAR, L'0', 5, 0, 1, nullptr },
 { IDC_CALC_BTN_BASE + 17, L".", K_CHAR, L'.', 5, 1, 1, nullptr },
 { IDC_CALC_BTN_BASE + 18, L"%", K_CHAR, L'%', 5, 2, 1, nullptr },
 { IDC_CALC_BTN_BASE + 19, L"+", K_CHAR, L'+', 5, 3, 1, nullptr },

 { IDC_CALC_BTN_BASE + 20, L"=", K_EQUALS, 0, 6, 0, 4, nullptr },
 { IDC_CALC_BTN_BASE + 21, L"Insert into Notepad", K_INSERT, 0, 7, 0, 4, nullptr },
};
static const int g_buttonCount = (int)(sizeof(g_buttons) / sizeof(g_buttons[0]));
static const int kCalcRows = 7; // number of keypad rows (rows 1..7)

// ---------------------------------------------------------------------------
// Globals
// ---------------------------------------------------------------------------
static const wchar_t* kAppClass = L"NotepadCalcWindowClass";
static const wchar_t* kAppTitle = L"Notepad + Calculator (Win32)";

static HWND g_hMainWnd = nullptr;
static HWND g_hEdit = nullptr; // editor
static HWND g_hStatus = nullptr; // status bar
static HWND g_hCalcDisp = nullptr; // calculator display (read-only)
static HFONT g_hFont = nullptr; // editor font
static HFONT g_hBtnFont = nullptr; // keypad button font
static HFONT g_hDispFont = nullptr; // calculator display font

static std::wstring g_filePath; // current document path ("" = untitled)
static bool g_dirty = false;
static bool g_panelOn = true; // calculator panel visible? (on by default)
static bool g_undoTimerRunning = false; // checkpoint timer armed?
static UINT g_undoIntervalMs = UNDO_GROUP_MS; // 0 = time checkpoints off
static bool g_undoOnEnter = true; // checkpoint when Enter pressed
static bool g_undoOnPunct = false; // checkpoint on . , ; : ! ?

// How "Evaluate Selection / Line" (Ctrl+E) inserts the answer.
enum EvalInsertMode {
 EVAL_NEWLINE = 0, // add a new line below with "= result"
 EVAL_APPEND, // append " = result" to the end of the same line
 EVAL_REPLACE_FULL, // replace the evaluated text with "expr = result"
 EVAL_REPLACE_RESULT // replace the evaluated text with just "result"
};
static EvalInsertMode g_evalMode = EVAL_NEWLINE;

// Calculator state.
static std::wstring g_calcExpr; // expression currently shown
static std::wstring g_lastExpr; // last successfully evaluated expression
static std::wstring g_lastResult; // last result
static bool g_calcJustEvaluated = false; // result is showing; next input continues/restarts

// Pixel width reserved for the docked calculator panel.
static const int kPanelWidth = 250;

// ===========================================================================
// Expression evaluator: compact recursive-descent parser.
//
// grammar:
// expr := term (('+' | '-') term)*
// term := factor (('*' | '/' | '%') factor)*
// factor := '-' factor | '+' factor | primary
// primary:= number | '(' expr ')'
// ===========================================================================
class Evaluator {
public:
 explicit Evaluator(const std::wstring& src) : s_(src), pos_(0) {}

 double parse() {
 double v = expr();
 skipSpaces();
 if (pos_ != s_.size())
 throw std::runtime_error("unexpected trailing characters");
 return v;
 }

private:
 const std::wstring& s_;
 size_t pos_;

 void skipSpaces() {
 while (pos_ < s_.size() && iswspace(s_[pos_])) ++pos_;
 }

 wchar_t peek() {
 skipSpaces();
 return pos_ < s_.size() ? s_[pos_] : L'\0';
 }

 double expr() {
 double v = term();
 for (;;) {
 wchar_t c = peek();
 if (c == L'+') { ++pos_; v += term(); }
 else if (c == L'-') { ++pos_; v -= term(); }
 else break;
 }
 return v;
 }

 double term() {
 double v = factor();
 for (;;) {
 wchar_t c = peek();
 if (c == L'*') { ++pos_; v *= factor(); }
 else if (c == L'/') {
 ++pos_;
 double d = factor();
 if (d == 0.0) throw std::runtime_error("division by zero");
 v /= d;
 }
 else if (c == L'%') {
 ++pos_;
 double d = factor();
 if (d == 0.0) throw std::runtime_error("modulo by zero");
 v = std::fmod(v, d);
 }
 else break;
 }
 return v;
 }

 double factor() {
 wchar_t c = peek();
 if (c == L'-') { ++pos_; return -factor(); }
 if (c == L'+') { ++pos_; return factor(); }
 return primary();
 }

 double primary() {
 wchar_t c = peek();
 if (c == L'(') {
 ++pos_;
 double v = expr();
 if (peek() != L')') throw std::runtime_error("missing ')'");
 ++pos_;
 return v;
 }
 return number();
 }

 double number() {
 skipSpaces();
 size_t start = pos_;
 bool sawDigit = false;
 while (pos_ < s_.size() && iswdigit(s_[pos_])) { ++pos_; sawDigit = true; }
 if (pos_ < s_.size() && s_[pos_] == L'.') {
 ++pos_;
 while (pos_ < s_.size() && iswdigit(s_[pos_])) { ++pos_; sawDigit = true; }
 }
 if (sawDigit && pos_ < s_.size() && (s_[pos_] == L'e' || s_[pos_] == L'E')) {
 size_t save = pos_;
 ++pos_;
 if (pos_ < s_.size() && (s_[pos_] == L'+' || s_[pos_] == L'-')) ++pos_;
 bool expDigit = false;
 while (pos_ < s_.size() && iswdigit(s_[pos_])) { ++pos_; expDigit = true; }
 if (!expDigit) pos_ = save;
 }
 if (!sawDigit) throw std::runtime_error("expected a number");
 return std::wcstod(s_.substr(start, pos_ - start).c_str(), nullptr);
 }
};

// Try to evaluate; returns true on success and writes the formatted result.
static bool TryEvaluate(const std::wstring& input, std::wstring& outResult) {
 try {
 Evaluator e(input);
 double v = e.parse();

 wchar_t buf[64];
 if (v == std::floor(v) && std::fabs(v) < 1e15) {
 swprintf(buf, 64, L"%.0f", v);
 } else {
 swprintf(buf, 64, L"%.10g", v);
 }
 outResult = buf;
 return true;
 } catch (const std::exception& ex) {
 std::string msg = ex.what();
 outResult.assign(msg.begin(), msg.end());
 return false;
 }
}

// ===========================================================================
// Helpers
// ===========================================================================
static void SetStatusText(int part, const std::wstring& text) {
 if (g_hStatus)
 SendMessageW(g_hStatus, SB_SETTEXTW, (WPARAM)part, (LPARAM)text.c_str());
}

static void UpdateTitle() {
 std::wstring t = kAppTitle;
 t += L" - ";
 t += g_filePath.empty() ? L"Untitled" : g_filePath;
 if (g_dirty) t += L" *";
 SetWindowTextW(g_hMainWnd, t.c_str());
}

static void UpdateCaretStatus() {
 DWORD selStart = 0, selEnd = 0;
 SendMessageW(g_hEdit, EM_GETSEL, (WPARAM)&selStart, (LPARAM)&selEnd);
 int line = (int)SendMessageW(g_hEdit, EM_LINEFROMCHAR, (WPARAM)selStart, 0);
 int lineStart = (int)SendMessageW(g_hEdit, EM_LINEINDEX, (WPARAM)line, 0);
 int col = (int)selStart - lineStart;

 wchar_t buf[64];
 swprintf(buf, 64, L"Ln %d, Col %d", line + 1, col + 1);
 SetStatusText(0, buf);
}

static std::wstring GetEditText() {
 int len = GetWindowTextLengthW(g_hEdit);
 std::wstring s;
 s.resize((size_t)len + 1);
 // Use the actual number of characters copied: for Rich Edit the length
 // hint can be an over-estimate, and we must not keep trailing nulls.
 int copied = GetWindowTextW(g_hEdit, &s[0], len + 1);
 s.resize((size_t)(copied < 0 ? 0 : copied));
 return s;
}

static void InsertAtCaret(const std::wstring& text) {
 // Bracket the programmatic insert with EM_STOPGROUPTYPING so it forms its
 // own undo step, separate from any typing before or after it.
 SendMessageW(g_hEdit, EM_STOPGROUPTYPING, 0, 0);
 SendMessageW(g_hEdit, EM_REPLACESEL, TRUE, (LPARAM)text.c_str());
 SendMessageW(g_hEdit, EM_STOPGROUPTYPING, 0, 0);
}

// ---------------------------------------------------------------------------
// File operations
// ---------------------------------------------------------------------------
static bool DoSaveToPath(const std::wstring& path) {
 HANDLE h = CreateFileW(path.c_str(), GENERIC_WRITE, 0, nullptr,
 CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
 if (h == INVALID_HANDLE_VALUE) {
 MessageBoxW(g_hMainWnd, L"Could not open file for writing.",
 kAppTitle, MB_ICONERROR);
 return false;
 }

 std::wstring text = GetEditText();

 int u8len = WideCharToMultiByte(CP_UTF8, 0, text.c_str(), (int)text.size(),
 nullptr, 0, nullptr, nullptr);
 std::string utf8;
 utf8.resize((size_t)u8len);
 WideCharToMultiByte(CP_UTF8, 0, text.c_str(), (int)text.size(),
 &utf8[0], u8len, nullptr, nullptr);

 DWORD written = 0;
 const unsigned char bom[3] = { 0xEF, 0xBB, 0xBF };
 WriteFile(h, bom, 3, &written, nullptr);
 if (!utf8.empty())
 WriteFile(h, utf8.data(), (DWORD)utf8.size(), &written, nullptr);
 CloseHandle(h);

 g_filePath = path;
 g_dirty = false;
 UpdateTitle();
 return true;
}

static bool DoSaveAs() {
 wchar_t file[MAX_PATH] = L"";
 if (!g_filePath.empty())
 wcsncpy_s(file, g_filePath.c_str(), _TRUNCATE);

 OPENFILENAMEW ofn = {};
 ofn.lStructSize = sizeof(ofn);
 ofn.hwndOwner = g_hMainWnd;
 ofn.lpstrFilter = L"Text Files (*.txt)\0*.txt\0All Files (*.*)\0*.*\0";
 ofn.lpstrFile = file;
 ofn.nMaxFile = MAX_PATH;
 ofn.lpstrDefExt = L"txt";
 ofn.Flags = OFN_OVERWRITEPROMPT | OFN_PATHMUSTEXIST;

 if (!GetSaveFileNameW(&ofn)) return false;
 return DoSaveToPath(file);
}

static bool DoSave() {
 if (g_filePath.empty()) return DoSaveAs();
 return DoSaveToPath(g_filePath);
}

static bool ConfirmDiscard() {
 if (!g_dirty) return true;
 int r = MessageBoxW(g_hMainWnd,
 L"You have unsaved changes. Save them now?",
 kAppTitle, MB_YESNOCANCEL | MB_ICONWARNING);
 if (r == IDCANCEL) return false;
 if (r == IDYES) return DoSave();
 return true;
}

static void DoNew() {
 if (!ConfirmDiscard()) return;
 SetWindowTextW(g_hEdit, L"");
 SendMessageW(g_hEdit, EM_EMPTYUNDOBUFFER, 0, 0);
 g_filePath.clear();
 g_dirty = false;
 UpdateTitle();
}

static void DoOpen() {
 if (!ConfirmDiscard()) return;

 wchar_t file[MAX_PATH] = L"";
 OPENFILENAMEW ofn = {};
 ofn.lStructSize = sizeof(ofn);
 ofn.hwndOwner = g_hMainWnd;
 ofn.lpstrFilter = L"Text Files (*.txt)\0*.txt\0All Files (*.*)\0*.*\0";
 ofn.lpstrFile = file;
 ofn.nMaxFile = MAX_PATH;
 ofn.Flags = OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST;
 if (!GetOpenFileNameW(&ofn)) return;

 HANDLE h = CreateFileW(file, GENERIC_READ, FILE_SHARE_READ, nullptr,
 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
 if (h == INVALID_HANDLE_VALUE) {
 MessageBoxW(g_hMainWnd, L"Could not open file.", kAppTitle, MB_ICONERROR);
 return;
 }

 DWORD size = GetFileSize(h, nullptr);
 std::string raw;
 raw.resize(size);
 DWORD read = 0;
 if (size > 0) ReadFile(h, &raw[0], size, &read, nullptr);
 CloseHandle(h);
 raw.resize(read);

 const char* data = raw.data();
 int len = (int)raw.size();
 if (len >= 3 && (unsigned char)data[0] == 0xEF &&
 (unsigned char)data[1] == 0xBB && (unsigned char)data[2] == 0xBF) {
 data += 3;
 len -= 3;
 }

 int wlen = MultiByteToWideChar(CP_UTF8, 0, data, len, nullptr, 0);
 std::wstring wtext;
 wtext.resize((size_t)wlen);
 if (wlen > 0)
 MultiByteToWideChar(CP_UTF8, 0, data, len, &wtext[0], wlen);

 SetWindowTextW(g_hEdit, wtext.c_str());
 SendMessageW(g_hEdit, EM_EMPTYUNDOBUFFER, 0, 0);
 g_filePath = file;
 g_dirty = false;
 UpdateTitle();
}

// ---------------------------------------------------------------------------
// Calculator: keypad-driven
// ---------------------------------------------------------------------------
static void RefreshCalcDisplay() {
 SetWindowTextW(g_hCalcDisp, g_calcExpr.empty() ? L"0" : g_calcExpr.c_str());
}

// Append one character from a keypad press, with sensible behaviour right
// after a result is shown (digits/'(' start fresh; operators continue).
static void CalcAppend(wchar_t c) {
 bool startsNew = (iswdigit(c) || c == L'(' || c == L'.');
 if (g_calcJustEvaluated) {
 g_calcExpr = startsNew ? std::wstring() : g_lastResult;
 g_calcJustEvaluated = false;
 }
 g_calcExpr.push_back(c);
 RefreshCalcDisplay();
}

static void CalcClear() {
 g_calcExpr.clear();
 g_calcJustEvaluated = false;
 RefreshCalcDisplay();
}

static void CalcBackspace() {
 if (g_calcJustEvaluated) {
 g_calcExpr.clear();
 g_calcJustEvaluated = false;
 } else if (!g_calcExpr.empty()) {
 g_calcExpr.pop_back();
 }
 RefreshCalcDisplay();
}

static void CalcEquals() {
 if (g_calcExpr.empty()) return;
 std::wstring result;
 if (TryEvaluate(g_calcExpr, result)) {
 g_lastExpr = g_calcExpr; // remember the expression (the "variables")
 g_lastResult = result; // ...and the answer
 g_calcExpr = result; // show the answer; keep typing to continue
 g_calcJustEvaluated = true;
 RefreshCalcDisplay();
 SetStatusText(1, g_lastExpr + L" = " + result);
 } else {
 MessageBeep(MB_ICONWARNING);
 SetStatusText(1, L"Error: " + result);
 }
}

// Insert the last completed calculation ("expression = answer") into the
// editor at the caret, replacing any selection.
static void CalcInsertIntoNotepad() {
 if (g_lastResult.empty()) {
 MessageBeep(MB_ICONWARNING);
 SetStatusText(1, L"No calculation to insert yet - press = first");
 return;
 }
 std::wstring text = g_lastExpr + L" = " + g_lastResult;
 SetFocus(g_hEdit);
 InsertAtCaret(text); // marks the document dirty via EN_CHANGE
 SetStatusText(1, L"Inserted: " + text);
}

// Dispatch a keypad button press by its command id.
static bool HandleCalcButton(int id) {
 for (int i = 0; i < g_buttonCount; ++i) {
 if (g_buttons[i].id != id) continue;
 switch (g_buttons[i].kind) {
 case K_CHAR: CalcAppend(g_buttons[i].ch); break;
 case K_CLEAR: CalcClear(); break;
 case K_BACK: CalcBackspace(); break;
 case K_EQUALS: CalcEquals(); break;
 case K_INSERT: CalcInsertIntoNotepad(); break;
 }
 return true;
 }
 return false;
}

// Move the caret to the end of the line that contains character index `pos`.
static void CaretToEndOfLine(DWORD pos) {
 int line = (int)SendMessageW(g_hEdit, EM_LINEFROMCHAR, (WPARAM)pos, 0);
 int lineStart = (int)SendMessageW(g_hEdit, EM_LINEINDEX, (WPARAM)line, 0);
 int lineLen = (int)SendMessageW(g_hEdit, EM_LINELENGTH, (WPARAM)lineStart, 0);
 DWORD eol = (DWORD)(lineStart + lineLen);
 SendMessageW(g_hEdit, EM_SETSEL, eol, eol);
}

// Evaluate the editor's selection / current line (menu + Ctrl+E).
// How the answer is placed is controlled by g_evalMode (Calculator > Insert
// Result As).
static void DoEvaluateSelection() {
 // Work out the character range to evaluate and pull out its text. Rich
 // Edit indexes a line break as one character internally, so we read the
 // text through control messages (EM_GETSELTEXT / EM_GETLINE) rather than
 // slicing the WM_GETTEXT string, whose "\r\n" indices would not line up.
 CHARRANGE cr;
 SendMessageW(g_hEdit, EM_EXGETSEL, 0, (LPARAM)&cr);

 DWORD rangeStart, rangeEnd;
 std::wstring src;
 if (cr.cpMax > cr.cpMin) {
 rangeStart = (DWORD)cr.cpMin;
 rangeEnd = (DWORD)cr.cpMax;
 src.resize((size_t)(cr.cpMax - cr.cpMin) + 1);
 LRESULT n = SendMessageW(g_hEdit, EM_GETSELTEXT, 0, (LPARAM)&src[0]);
 src.resize((size_t)(n < 0 ? 0 : n));
 } else {
 int line = (int)SendMessageW(g_hEdit, EM_LINEFROMCHAR, (WPARAM)cr.cpMin, 0);
 int lineStart = (int)SendMessageW(g_hEdit, EM_LINEINDEX, (WPARAM)line, 0);
 int lineLen = (int)SendMessageW(g_hEdit, EM_LINELENGTH, (WPARAM)lineStart, 0);
 rangeStart = (DWORD)lineStart;
 rangeEnd = (DWORD)(lineStart + lineLen);
 if (lineLen > 0) {
 src.resize((size_t)lineLen + 1);
 // EM_GETLINE expects the buffer capacity (in chars) in its first WORD.
 *reinterpret_cast<WORD*>(&src[0]) = (WORD)(lineLen + 1);
 LRESULT n = SendMessageW(g_hEdit, EM_GETLINE, (WPARAM)line, (LPARAM)&src[0]);
 src.resize((size_t)(n < 0 ? 0 : n));
 }
 }

 size_t a = src.find_first_not_of(L" \t\r\n");
 size_t b = src.find_last_not_of(L" \t\r\n");
 if (a == std::wstring::npos) {
 SetStatusText(1, L"Nothing to evaluate");
 return;
 }
 std::wstring expr = src.substr(a, b - a + 1);

 std::wstring result;
 if (!TryEvaluate(expr, result)) {
 SetStatusText(1, L"Error: " + result);
 MessageBoxW(g_hMainWnd, (L"Could not evaluate expression:\n\n" +
 expr + L"\n\n" + result).c_str(),
 kAppTitle, MB_ICONWARNING);
 return;
 }

 switch (g_evalMode) {
 case EVAL_NEWLINE:
 // Leave the line untouched; add "= result" on the next line.
 CaretToEndOfLine(rangeEnd);
 InsertAtCaret(L"\r\n= " + result);
 break;

 case EVAL_APPEND:
 // Append " = result" to the end of the evaluated line.
 CaretToEndOfLine(rangeEnd);
 InsertAtCaret(L" = " + result);
 break;

 case EVAL_REPLACE_FULL:
 // Replace the evaluated text with "expr = result".
 SendMessageW(g_hEdit, EM_SETSEL, (WPARAM)rangeStart, (LPARAM)rangeEnd);
 InsertAtCaret(expr + L" = " + result);
 break;

 case EVAL_REPLACE_RESULT:
 // Replace the evaluated text with just the result.
 SendMessageW(g_hEdit, EM_SETSEL, (WPARAM)rangeStart, (LPARAM)rangeEnd);
 InsertAtCaret(result);
 break;
 }
 SetStatusText(1, L"Result: " + result);
}

// ---------------------------------------------------------------------------
// Layout / sizing
// ---------------------------------------------------------------------------
static void LayoutChildren() {
 RECT rc;
 GetClientRect(g_hMainWnd, &rc);

 SendMessageW(g_hStatus, WM_SIZE, 0, 0);
 RECT sr;
 GetWindowRect(g_hStatus, &sr);
 int statusH = sr.bottom - sr.top;

 int bottom = rc.bottom - statusH;

 int editWidth = rc.right;
 if (g_panelOn) {
 editWidth = rc.right - kPanelWidth;
 if (editWidth < 100) editWidth = 100;

 const int pad = 6;
 const int gap = 4;
 int panelX = editWidth;
 int innerX = panelX + pad;
 int innerW = rc.right - innerX - pad;
 if (innerW < 40) innerW = 40;

 // Display across the top of the panel.
 int dispH = 46;
 MoveWindow(g_hCalcDisp, innerX, pad, innerW, dispH, TRUE);
 ShowWindow(g_hCalcDisp, SW_SHOW);

 // Keypad grid below the display.
 int buttonsTop = pad + dispH + gap;
 int buttonsBottom = bottom - pad;
 int rowH = (buttonsBottom - buttonsTop) / kCalcRows;
 if (rowH < 24) rowH = 24;
 int colW = innerW / 4;

 for (int i = 0; i < g_buttonCount; ++i) {
 CalcButton& btn = g_buttons[i];
 int bx = innerX + btn.col * colW;
 int by = buttonsTop + (btn.row - 1) * rowH;
 int bw = btn.colspan * colW - gap;
 int bh = rowH - gap;
 MoveWindow(btn.hwnd, bx, by, bw, bh, TRUE);
 ShowWindow(btn.hwnd, SW_SHOW);
 }
 } else {
 ShowWindow(g_hCalcDisp, SW_HIDE);
 for (int i = 0; i < g_buttonCount; ++i)
 ShowWindow(g_buttons[i].hwnd, SW_HIDE);
 }

 MoveWindow(g_hEdit, 0, 0, editWidth, bottom, TRUE);
}

static void TogglePanel() {
 g_panelOn = !g_panelOn;
 HMENU menu = GetMenu(g_hMainWnd);
 CheckMenuItem(menu, IDM_CALC_PANEL,
 MF_BYCOMMAND | (g_panelOn ? MF_CHECKED : MF_UNCHECKED));
 LayoutChildren();
}

// Reflect the current insert mode as the checked radio item in the submenu.
static void UpdateEvalModeMenu() {
 HMENU menu = GetMenu(g_hMainWnd);
 UINT selected = IDM_EVAL_NEWLINE;
 switch (g_evalMode) {
 case EVAL_NEWLINE: selected = IDM_EVAL_NEWLINE; break;
 case EVAL_APPEND: selected = IDM_EVAL_APPEND; break;
 case EVAL_REPLACE_FULL: selected = IDM_EVAL_REPLACE_FULL; break;
 case EVAL_REPLACE_RESULT: selected = IDM_EVAL_REPLACE_RESULT; break;
 }
 CheckMenuRadioItem(menu, IDM_EVAL_NEWLINE, IDM_EVAL_REPLACE_RESULT,
 selected, MF_BYCOMMAND);
}

// Reflect the undo-checkpoint settings in the Edit > Undo Checkpoints submenu.
static void UpdateUndoMenu() {
 HMENU menu = GetMenu(g_hMainWnd);
 UINT sel = IDM_UNDO_TIME_1;
 switch (g_undoIntervalMs) {
 case 0: sel = IDM_UNDO_TIME_OFF; break;
 case 500: sel = IDM_UNDO_TIME_05; break;
 case 1000: sel = IDM_UNDO_TIME_1; break;
 case 2000: sel = IDM_UNDO_TIME_2; break;
 case 5000: sel = IDM_UNDO_TIME_5; break;
 }
 CheckMenuRadioItem(menu, IDM_UNDO_TIME_OFF, IDM_UNDO_TIME_5, sel, MF_BYCOMMAND);
 CheckMenuItem(menu, IDM_UNDO_ON_ENTER,
 MF_BYCOMMAND | (g_undoOnEnter ? MF_CHECKED : MF_UNCHECKED));
 CheckMenuItem(menu, IDM_UNDO_ON_PUNCT,
 MF_BYCOMMAND | (g_undoOnPunct ? MF_CHECKED : MF_UNCHECKED));
}

// Change the time-based checkpoint interval (0 disables it). Any pending timer
// is cancelled so the new interval takes effect from the next edit.
static void SetUndoInterval(UINT ms) {
 g_undoIntervalMs = ms;
 if (g_undoTimerRunning) {
 KillTimer(g_hMainWnd, IDT_UNDO_GROUP);
 g_undoTimerRunning = false;
 }
 UpdateUndoMenu();
}

// Characters that end an undo group when "On Punctuation" is enabled.
static bool IsPunctCheckpoint(wchar_t c) {
 return c == L'.' || c == L',' || c == L';' ||
 c == L':' || c == L'!' || c == L'?';
}

// Subclass procedure for the editor: watches typed characters so we can close
// the undo group right after an Enter or a punctuation mark (when enabled).
static LRESULT CALLBACK EditSubclassProc(HWND hWnd, UINT msg, WPARAM wParam,
 LPARAM lParam, UINT_PTR uId, DWORD_PTR) {
 if (msg == WM_CHAR) {
 wchar_t ch = (wchar_t)wParam;
 // Let the control insert the character first, then checkpoint.
 LRESULT r = DefSubclassProc(hWnd, msg, wParam, lParam);
 bool checkpoint =
 (g_undoOnEnter && (ch == L'\r' || ch == L'\n')) ||
 (g_undoOnPunct && IsPunctCheckpoint(ch));
 if (checkpoint)
 SendMessageW(hWnd, EM_STOPGROUPTYPING, 0, 0);
 return r;
 }
 if (msg == WM_NCDESTROY)
 RemoveWindowSubclass(hWnd, EditSubclassProc, uId);
 return DefSubclassProc(hWnd, msg, wParam, lParam);
}

// ---------------------------------------------------------------------------
// Menu construction
// ---------------------------------------------------------------------------
static HMENU BuildMenu() {
 HMENU menu = CreateMenu();

 HMENU file = CreatePopupMenu();
 AppendMenuW(file, MF_STRING, IDM_FILE_NEW, L"&New\tCtrl+N");
 AppendMenuW(file, MF_STRING, IDM_FILE_OPEN, L"&Open...\tCtrl+O");
 AppendMenuW(file, MF_STRING, IDM_FILE_SAVE, L"&Save\tCtrl+S");
 AppendMenuW(file, MF_STRING, IDM_FILE_SAVEAS, L"Save &As...");
 AppendMenuW(file, MF_SEPARATOR, 0, nullptr);
 AppendMenuW(file, MF_STRING, IDM_FILE_EXIT, L"E&xit");
 AppendMenuW(menu, MF_POPUP, (UINT_PTR)file, L"&File");

 HMENU edit = CreatePopupMenu();
 AppendMenuW(edit, MF_STRING, IDM_EDIT_UNDO, L"&Undo\tCtrl+Z");
 AppendMenuW(edit, MF_STRING, IDM_EDIT_REDO, L"&Redo\tCtrl+Y");
 AppendMenuW(edit, MF_SEPARATOR, 0, nullptr);
 AppendMenuW(edit, MF_STRING, IDM_EDIT_CUT, L"Cu&t\tCtrl+X");
 AppendMenuW(edit, MF_STRING, IDM_EDIT_COPY, L"&Copy\tCtrl+C");
 AppendMenuW(edit, MF_STRING, IDM_EDIT_PASTE, L"&Paste\tCtrl+V");
 AppendMenuW(edit, MF_STRING, IDM_EDIT_DELETE, L"&Delete\tDel");
 AppendMenuW(edit, MF_SEPARATOR, 0, nullptr);
 AppendMenuW(edit, MF_STRING, IDM_EDIT_SELALL, L"Select &All\tCtrl+A");

 // Submenu: when typing runs are committed as undo checkpoints.
 AppendMenuW(edit, MF_SEPARATOR, 0, nullptr);
 HMENU undo = CreatePopupMenu();
 AppendMenuW(undo, MF_STRING, IDM_UNDO_TIME_OFF, L"Time interval: &Off");
 AppendMenuW(undo, MF_STRING, IDM_UNDO_TIME_05, L"Time interval: 0.&5 seconds");
 AppendMenuW(undo, MF_STRING, IDM_UNDO_TIME_1, L"Time interval: &1 second");
 AppendMenuW(undo, MF_STRING, IDM_UNDO_TIME_2, L"Time interval: &2 seconds");
 AppendMenuW(undo, MF_STRING, IDM_UNDO_TIME_5, L"Time interval: 5 &seconds");
 AppendMenuW(undo, MF_SEPARATOR, 0, nullptr);
 AppendMenuW(undo, MF_STRING, IDM_UNDO_ON_ENTER, L"On &Enter / new line");
 AppendMenuW(undo, MF_STRING, IDM_UNDO_ON_PUNCT, L"On &punctuation ( . , ; : ! ? )");
 AppendMenuW(edit, MF_POPUP, (UINT_PTR)undo, L"Undo &Checkpoints");

 AppendMenuW(menu, MF_POPUP, (UINT_PTR)edit, L"&Edit");

 HMENU calc = CreatePopupMenu();
 AppendMenuW(calc, MF_STRING, IDM_CALC_EVAL, L"&Evaluate Selection / Line\tCtrl+E");

 // Submenu: how the evaluated answer is inserted.
 HMENU evalAs = CreatePopupMenu();
 AppendMenuW(evalAs, MF_STRING, IDM_EVAL_NEWLINE,
 L"On a &new line below (\"= result\")");
 AppendMenuW(evalAs, MF_STRING, IDM_EVAL_APPEND,
 L"&Append to the line (\"... = result\")");
 AppendMenuW(evalAs, MF_STRING, IDM_EVAL_REPLACE_FULL,
 L"&Replace with \"expr = result\"");
 AppendMenuW(evalAs, MF_STRING, IDM_EVAL_REPLACE_RESULT,
 L"Replace with &result only");
 AppendMenuW(calc, MF_POPUP, (UINT_PTR)evalAs, L"&Insert Result As");

 AppendMenuW(calc, MF_SEPARATOR, 0, nullptr);
 AppendMenuW(calc, MF_STRING | MF_CHECKED, IDM_CALC_PANEL,
 L"Show Calculator &Panel\tCtrl+P");
 AppendMenuW(menu, MF_POPUP, (UINT_PTR)calc, L"&Calculator");

 HMENU help = CreatePopupMenu();
 AppendMenuW(help, MF_STRING, IDM_HELP_ABOUT, L"&About");
 AppendMenuW(menu, MF_POPUP, (UINT_PTR)help, L"&Help");

 return menu;
}

// ---------------------------------------------------------------------------
// Keyboard accelerators
// ---------------------------------------------------------------------------
static HACCEL BuildAccelerators() {
 ACCEL acc[] = {
 { FVIRTKEY | FCONTROL, 'N', IDM_FILE_NEW },
 { FVIRTKEY | FCONTROL, 'O', IDM_FILE_OPEN },
 { FVIRTKEY | FCONTROL, 'S', IDM_FILE_SAVE },
 { FVIRTKEY | FCONTROL, 'E', IDM_CALC_EVAL },
 { FVIRTKEY | FCONTROL, 'P', IDM_CALC_PANEL },
 { FVIRTKEY | FCONTROL, 'A', IDM_EDIT_SELALL },
 { FVIRTKEY | FCONTROL, 'Z', IDM_EDIT_UNDO },
 { FVIRTKEY | FCONTROL, 'Y', IDM_EDIT_REDO },
 };
 return CreateAcceleratorTableW(acc, (int)(sizeof(acc) / sizeof(acc[0])));
}

// ===========================================================================
// Window procedure
// ===========================================================================
static LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
 switch (msg) {
 case WM_CREATE: {
 HINSTANCE hInst = ((LPCREATESTRUCT)lParam)->hInstance;

 g_hFont = CreateFontW(-16, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE,
 DEFAULT_CHARSET, OUT_DEFAULT_PRECIS,
 CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY,
 FIXED_PITCH | FF_MODERN, L"Consolas");
 g_hBtnFont = CreateFontW(-18, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE,
 DEFAULT_CHARSET, OUT_DEFAULT_PRECIS,
 CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY,
 VARIABLE_PITCH | FF_SWISS, L"Segoe UI");
 g_hDispFont = CreateFontW(-24, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE,
 DEFAULT_CHARSET, OUT_DEFAULT_PRECIS,
 CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY,
 FIXED_PITCH | FF_MODERN, L"Consolas");

 // Main editor: a Rich Edit control. Unlike the plain EDIT control
 // (single-level undo only), Rich Edit keeps a real undo/redo stack
 // whose depth we set with EM_SETUNDOLIMIT.
 g_hEdit = CreateWindowExW(
 WS_EX_CLIENTEDGE, MSFTEDIT_CLASS, L"",
 WS_CHILD | WS_VISIBLE | WS_VSCROLL | WS_HSCROLL |
 ES_MULTILINE | ES_AUTOVSCROLL | ES_AUTOHSCROLL | ES_NOHIDESEL,
 0, 0, 0, 0, hWnd, (HMENU)IDC_EDIT, hInst, nullptr);
 SendMessageW(g_hEdit, WM_SETFONT, (WPARAM)g_hFont, TRUE);
 SendMessageW(g_hEdit, EM_EXLIMITTEXT, 0, (LPARAM)0x7FFFFFFF); // lift the size cap
 SendMessageW(g_hEdit, EM_SETUNDOLIMIT, (WPARAM)128, 0); // 128 undo/redo levels
 // Rich Edit sends no notifications unless we ask: we want EN_CHANGE
 // (dirty flag) and EN_SELCHANGE (caret position in the status bar).
 SendMessageW(g_hEdit, EM_SETEVENTMASK, 0, ENM_CHANGE | ENM_SELCHANGE);
 // Subclass the editor to watch typed Enter / punctuation for checkpoints.
 SetWindowSubclass(g_hEdit, EditSubclassProc, 1, 0);

 // Calculator display (read-only, right-aligned).
 g_hCalcDisp = CreateWindowExW(
 WS_EX_CLIENTEDGE, L"EDIT", L"0",
 WS_CHILD | ES_RIGHT | ES_READONLY | ES_AUTOHSCROLL,
 0, 0, 0, 0, hWnd, (HMENU)IDC_CALC_DISPLAY, hInst, nullptr);
 SendMessageW(g_hCalcDisp, WM_SETFONT, (WPARAM)g_hDispFont, TRUE);

 // Calculator keypad buttons.
 for (int i = 0; i < g_buttonCount; ++i) {
 g_buttons[i].hwnd = CreateWindowExW(
 0, L"BUTTON", g_buttons[i].label,
 WS_CHILD | BS_PUSHBUTTON,
 0, 0, 0, 0, hWnd, (HMENU)(INT_PTR)g_buttons[i].id, hInst, nullptr);
 SendMessageW(g_buttons[i].hwnd, WM_SETFONT, (WPARAM)g_hBtnFont, TRUE);
 }

 // Status bar with two parts.
 g_hStatus = CreateWindowExW(
 0, STATUSCLASSNAMEW, nullptr,
 WS_CHILD | WS_VISIBLE | SBARS_SIZEGRIP,
 0, 0, 0, 0, hWnd, (HMENU)IDC_STATUS, hInst, nullptr);
 {
 int parts[2] = { 160, -1 };
 SendMessageW(g_hStatus, SB_SETPARTS, 2, (LPARAM)parts);
 }

 UpdateEvalModeMenu();
 UpdateUndoMenu();
 UpdateCaretStatus();
 SetStatusText(1, L"Ready");
 return 0;
 }

 case WM_SIZE:
 LayoutChildren();
 return 0;

 case WM_SETFOCUS:
 SetFocus(g_hEdit);
 return 0;

 case WM_NOTIFY: {
 // Rich Edit reports caret/selection moves via EN_SELCHANGE.
 NMHDR* nh = (NMHDR*)lParam;
 if (nh->idFrom == IDC_EDIT && nh->code == EN_SELCHANGE)
 UpdateCaretStatus();
 return 0;
 }

 case WM_TIMER:
 if (wParam == IDT_UNDO_GROUP) {
 KillTimer(hWnd, IDT_UNDO_GROUP);
 g_undoTimerRunning = false;
 // Close the current typing run; the next keystroke starts a new
 // undo action, giving ~1-second undo granularity.
 SendMessageW(g_hEdit, EM_STOPGROUPTYPING, 0, 0);
 }
 return 0;

 case WM_COMMAND: {
 WORD id = LOWORD(wParam);
 WORD code = HIWORD(wParam);

 // Keypad button clicks.
 if (code == BN_CLICKED && id >= IDC_CALC_BTN_BASE &&
 id < IDC_CALC_BTN_BASE + g_buttonCount) {
 HandleCalcButton(id);
 return 0;
 }

 // Editor notifications.
 if (id == IDC_EDIT) {
 if (code == EN_CHANGE) {
 if (!g_dirty) { g_dirty = true; UpdateTitle(); }
 UpdateCaretStatus();
 // Arm a one-shot timer (if enabled and not already running).
 // When it fires we close the undo group, so each interval's
 // worth of edits becomes a separate, undoable checkpoint.
 if (g_undoIntervalMs > 0 && !g_undoTimerRunning) {
 SetTimer(hWnd, IDT_UNDO_GROUP, g_undoIntervalMs, nullptr);
 g_undoTimerRunning = true;
 }
 }
 return 0;
 }

 switch (id) {
 case IDM_FILE_NEW: DoNew(); break;
 case IDM_FILE_OPEN: DoOpen(); break;
 case IDM_FILE_SAVE: DoSave(); break;
 case IDM_FILE_SAVEAS: DoSaveAs(); break;
 case IDM_FILE_EXIT: SendMessageW(hWnd, WM_CLOSE, 0, 0); break;

 case IDM_EDIT_UNDO: SendMessageW(g_hEdit, EM_UNDO, 0, 0); break;
 case IDM_EDIT_REDO: SendMessageW(g_hEdit, EM_REDO, 0, 0); break;
 case IDM_EDIT_CUT: SendMessageW(g_hEdit, WM_CUT, 0, 0); break;
 case IDM_EDIT_COPY: SendMessageW(g_hEdit, WM_COPY, 0, 0); break;
 case IDM_EDIT_PASTE: SendMessageW(g_hEdit, WM_PASTE, 0, 0); break;
 case IDM_EDIT_DELETE: SendMessageW(g_hEdit, WM_CLEAR, 0, 0); break;
 case IDM_EDIT_SELALL: SendMessageW(g_hEdit, EM_SETSEL, 0, -1); break;

 case IDM_UNDO_TIME_OFF: SetUndoInterval(0); break;
 case IDM_UNDO_TIME_05: SetUndoInterval(500); break;
 case IDM_UNDO_TIME_1: SetUndoInterval(1000); break;
 case IDM_UNDO_TIME_2: SetUndoInterval(2000); break;
 case IDM_UNDO_TIME_5: SetUndoInterval(5000); break;
 case IDM_UNDO_ON_ENTER: g_undoOnEnter = !g_undoOnEnter; UpdateUndoMenu(); break;
 case IDM_UNDO_ON_PUNCT: g_undoOnPunct = !g_undoOnPunct; UpdateUndoMenu(); break;

 case IDM_CALC_EVAL: DoEvaluateSelection(); break;
 case IDM_CALC_PANEL: TogglePanel(); break;

 case IDM_EVAL_NEWLINE:
 g_evalMode = EVAL_NEWLINE; UpdateEvalModeMenu(); break;
 case IDM_EVAL_APPEND:
 g_evalMode = EVAL_APPEND; UpdateEvalModeMenu(); break;
 case IDM_EVAL_REPLACE_FULL:
 g_evalMode = EVAL_REPLACE_FULL; UpdateEvalModeMenu(); break;
 case IDM_EVAL_REPLACE_RESULT:
 g_evalMode = EVAL_REPLACE_RESULT; UpdateEvalModeMenu(); break;

 case IDM_HELP_ABOUT:
 MessageBoxW(hWnd,
 L"Notepad + Calculator\n"
 L"A standard Win32 (C++) sample.\n\n"
 L"Use the keypad on the right to build a calculation, press =,\n"
 L"then \"Insert into Notepad\" to drop \"expression = answer\"\n"
 L"into the editor at the caret.\n\n"
 L"Calculator > Evaluate (Ctrl+E) evaluates the selected text or\n"
 L"current line in the editor itself.\n\n"
 L"Supports + - * / %, parentheses, decimals, and scientific\n"
 L"notation with standard operator precedence.",
 L"About", MB_ICONINFORMATION);
 break;
 }
 return 0;
 }

 case WM_CLOSE:
 if (!ConfirmDiscard()) return 0;
 DestroyWindow(hWnd);
 return 0;

 case WM_DESTROY:
 if (g_undoTimerRunning) KillTimer(hWnd, IDT_UNDO_GROUP);
 if (g_hFont) DeleteObject(g_hFont);
 if (g_hBtnFont) DeleteObject(g_hBtnFont);
 if (g_hDispFont) DeleteObject(g_hDispFont);
 PostQuitMessage(0);
 return 0;
 }
 return DefWindowProcW(hWnd, msg, wParam, lParam);
}

// ===========================================================================
// Entry point
// ===========================================================================
int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE, LPWSTR, int nCmdShow) {
 INITCOMMONCONTROLSEX icc = { sizeof(icc), ICC_BAR_CLASSES | ICC_STANDARD_CLASSES };
 InitCommonControlsEx(&icc);

 // Load the Rich Edit 4.1 control. This registers the MSFTEDIT_CLASS
 // ("RICHEDIT50W") window class used by the editor.
 HMODULE hRichEdit = LoadLibraryW(L"Msftedit.dll");
 if (!hRichEdit) {
 MessageBoxW(nullptr, L"Failed to load Msftedit.dll (Rich Edit).",
 kAppTitle, MB_ICONERROR);
 return 1;
 }

 WNDCLASSEXW wc = {};
 wc.cbSize = sizeof(wc);
 wc.style = CS_HREDRAW | CS_VREDRAW;
 wc.lpfnWndProc = WndProc;
 wc.hInstance = hInstance;
 wc.hIcon = LoadIconW(nullptr, IDI_APPLICATION);
 wc.hCursor = LoadCursorW(nullptr, IDC_ARROW);
 wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
 wc.lpszClassName = kAppClass;
 wc.hIconSm = LoadIconW(nullptr, IDI_APPLICATION);
 if (!RegisterClassExW(&wc)) {
 MessageBoxW(nullptr, L"RegisterClassEx failed.", kAppTitle, MB_ICONERROR);
 return 1;
 }

 g_hMainWnd = CreateWindowExW(
 0, kAppClass, kAppTitle,
 WS_OVERLAPPEDWINDOW,
 CW_USEDEFAULT, CW_USEDEFAULT, 1080, 640,
 nullptr, BuildMenu(), hInstance, nullptr);
 if (!g_hMainWnd) {
 MessageBoxW(nullptr, L"CreateWindowEx failed.", kAppTitle, MB_ICONERROR);
 return 1;
 }

 UpdateTitle();
 ShowWindow(g_hMainWnd, nCmdShow);
 UpdateWindow(g_hMainWnd);

 HACCEL hAccel = BuildAccelerators();

 MSG msg;
 while (GetMessageW(&msg, nullptr, 0, 0) > 0) {
 if (!TranslateAcceleratorW(g_hMainWnd, hAccel, &msg)) {
 TranslateMessage(&msg);
 DispatchMessageW(&msg);
 }
 }

 if (hAccel) DestroyAcceleratorTable(hAccel);
 FreeLibrary(hRichEdit);
 return (int)msg.wParam;
}