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;
}