Programmiererforum

Code: Select all

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