How to make a RichEdit control resizable in the up and down directions?

Question

// RichEditReSizeable_cpp_win32.cpp : Defines the entry point for the application.
//
#include "framework.h"
#include "RichEditReSizeable_cpp_win32.h"
#define MAX_LOADSTRING 100
#ifndef MSFTEDIT_CLASS
#define MSFTEDIT_CLASS TEXT("RICHEDIT50W")
#endif
// Global Variables:
HINSTANCE hInst;                                // current instance
WCHAR szTitle[MAX_LOADSTRING];                  // The title bar text
WCHAR szWindowClass[MAX_LOADSTRING];            // the main window class name
// Forward declarations of functions included in this code module:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);
HWND hMainWnd;      // Global handle for the main window.
HWND hRichEdit;     // Global handle for the RichEdit control.
// Define initial position and size (you can change these as needed)
int x = 0;
int y = 0;
int width = 300;   // or get the client rect to size dynamically
int height = 100;
HWND hParent = hMainWnd; // or whatever the intended parent is
// Global (or static) variables to track resizing:
bool g_bResizing = false;
int  g_nDragStartY = 0;
int  g_nOrigRichEditHeight = 0;
int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPWSTR    lpCmdLine,
                     _In_ int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);
    // TODO: Place code here.
    LoadLibrary(TEXT("Msftedit.dll"));
    // Initialize global strings
    LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadStringW(hInstance, IDC_RICHEDITRESIZEABLECPPWIN32, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);
    // Perform application initialization:
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }
    HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_RICHEDITRESIZEABLECPPWIN32));
    MSG msg;
    // Main message loop:
    while (GetMessage(&msg, nullptr, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
    return (int) msg.wParam;
}
//
//  FUNCTION: MyRegisterClass()
//
//  PURPOSE: Registers the window class.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEXW wcex;
    wcex.cbSize = sizeof(WNDCLASSEX);
    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_RICHEDITRESIZEABLECPPWIN32));
    wcex.hCursor        = LoadCursor(nullptr, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = MAKEINTRESOURCEW(IDC_RICHEDITRESIZEABLECPPWIN32);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
    return RegisterClassExW(&wcex);
}
//
//   FUNCTION: InitInstance(HINSTANCE, int)
//
//   PURPOSE: Saves instance handle and creates main window
//
//   COMMENTS:
//
//        In this function, we save the instance handle in a global variable and
//        create and display the main program window.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
    hInst = hInstance; // Store instance handle in our global variable
    hMainWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, hInstance, nullptr);
    if (!hMainWnd)
    {
        return FALSE;
    }
    ShowWindow(hMainWnd, nCmdShow);
    UpdateWindow(hMainWnd);
    // Create the RichEdit control with hMainWnd as its parent.
    hRichEdit = CreateWindowEx(
        WS_EX_CLIENTEDGE,
        MSFTEDIT_CLASS,
        NULL,
        WS_CHILD | WS_VISIBLE | ES_MULTILINE | WS_VSCROLL | ES_AUTOVSCROLL,
        x, y, width, height,         // these can be updated immediately or in WM_SIZE
        hMainWnd,                    // use hMainWnd directly
        (HMENU)ID_RICHEDIT,          // control ID (make sure ID_RICHEDIT is defined)
        hInstance,
        NULL
    );
    // Optionally, reposition the RichEdit control immediately:
    RECT rc;
    GetClientRect(hMainWnd, &rc);
    int clientHeight = rc.bottom - rc.top;
    int clientWidth = rc.right - rc.left;
    int richEditHeight = clientHeight / 4;
    int richEditTop = clientHeight - richEditHeight;
    SetWindowPos(hRichEdit, NULL, 0, richEditTop, clientWidth, richEditHeight, SWP_NOZORDER);
    return TRUE;
}
//
//  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE: Processes messages for the main window.
//
//  WM_COMMAND  - process the application menu
//  WM_PAINT    - Paint the main window
//  WM_DESTROY  - post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
    case WM_LBUTTONDOWN:
    {
        // Get the click point in client coordinates.
        POINT pt = { LOWORD(lParam), HIWORD(lParam) };
        // Get the RichEdit control's rectangle in client coordinates.
        RECT rcRich;
        GetWindowRect(hRichEdit, &rcRich);
        // Map the rectangle from screen to client coordinates.
        MapWindowPoints(HWND_DESKTOP, hMainWnd, (LPPOINT)&rcRich, 2);
        // Check if the click is within the top 10 pixels of the RichEdit control.
        if (pt.y >= rcRich.top && pt.y <= rcRich.top + 10)
        {
            g_bResizing = true;
            g_nDragStartY = pt.y;
            g_nOrigRichEditHeight = rcRich.bottom - rcRich.top;
            SetCapture(hMainWnd);
        }
    }
    break;
    case WM_MOUSEMOVE:
    {
        if (g_bResizing)
        {
            // Get the current mouse position.
            POINT pt = { LOWORD(lParam), HIWORD(lParam) };
            // Calculate how far the mouse has moved in Y.
            int deltaY = pt.y - g_nDragStartY;
            // Because the control is docked at the bottom, subtract the delta.
            int newHeight = g_nOrigRichEditHeight - deltaY;
            // Enforce a minimum and maximum height.
            const int MIN_HEIGHT = 50; // minimum height in pixels
            RECT rcClient;
            GetClientRect(hMainWnd, &rcClient);
            int maxHeight = rcClient.bottom - 50;  // leave room for the rest of the window
            if (newHeight < MIN_HEIGHT)
                newHeight = MIN_HEIGHT;
            if (newHeight > maxHeight)
                newHeight = maxHeight;
            // The new top of the RichEdit is the bottom of the client area minus the new height.
            int richEditTop = rcClient.bottom - newHeight;
            SetWindowPos(hRichEdit, NULL, 0, richEditTop, rcClient.right, newHeight, SWP_NOZORDER);
        }
    }
    break;
    case WM_LBUTTONUP:
    {
        if (g_bResizing)
        {
            g_bResizing = false;
            ReleaseCapture();
        }
    }
    break;
    // Your existing message handling...
    case WM_COMMAND:
    {
        int wmId = LOWORD(wParam);
        switch (wmId)
        {
        case IDM_ABOUT:
            DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
            break;
        case IDM_EXIT:
            DestroyWindow(hWnd);
            break;
        default:
            return DefWindowProc(hWnd, message, wParam, lParam);
        }
    }
    break;
    case WM_PAINT:
    {
        PAINTSTRUCT ps;
        HDC hdc = BeginPaint(hWnd, &ps);
        EndPaint(hWnd, &ps);
    }
    break;
    case WM_SIZE:
    {
        RECT rcClient;
        GetClientRect(hWnd, &rcClient);
        // Get the current height of the RichEdit control
        RECT rcRichEdit;
        GetWindowRect(hRichEdit, &rcRichEdit);
        MapWindowPoints(HWND_DESKTOP, hWnd, (LPPOINT)&rcRichEdit, 2);
        int richEditHeight = rcRichEdit.bottom - rcRichEdit.top;
        // Keep the RichEdit control anchored at the bottom
        int richEditTop = rcClient.bottom - richEditHeight;
        SetWindowPos(hRichEdit, NULL, 0, richEditTop, rcClient.right, richEditHeight, SWP_NOZORDER);
    }
    break;
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}
// Message handler for about box.
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    UNREFERENCED_PARAMETER(lParam);
    switch (message)
    {
    case WM_INITDIALOG:
        return (INT_PTR)TRUE;
    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, LOWORD(wParam));
            return (INT_PTR)TRUE;
        }
        break;
    }
    return (INT_PTR)FALSE;
}

The code compiles and runs. Attached is the resultant window. The attempt here to make the RichEdit control re-sizeable in the upward and downward directions is not yet functional. I would like for the cursor to change to a resize icon when the mouse is placed over the top border area of the RiuchEdit. So far there does not seem to be a way to click the top border and resize the RichEdit towards the top or bottom of the main window.

How is it possible to get the RichEdit to start resizing as described?

Answer 1

If you add WS_THICKFRAME style, it will be resizable Quick test :