窗口句柄为何未正确存储？

huangapple
go评论112阅读模式
英文:

Why does the window handle not get stored properly?

问题

首先，您获得了一个MCWE（可能是一种自定义窗口编辑器）。您可能比我更了解如何使用它，但我建议从头开始构建一个C++项目，然后将其添加进去。它使用Unicode字符集，请确保将子系统设置为“windows”。

在WM_CREATE消息的父窗口中，通过迭代Objects来创建窗口。

还注册了一个自定义窗口类，以便能够在该对象上进行自定义事件处理。在这个“子”过程的WM_LBUTTONDOWN中，您希望通过向其发送消息来修改另一个子窗口的文本。

输出是“Is not..”是因为窗口句柄没有正确传递，但我做错了什么？

我尝试将变量作为指针传递，但没有任何区别。

您遇到的问题可能与窗口句柄的作用域和生存期有关。在WM_CREATE消息处理程序中创建的窗口句柄只在该函数内部有效。要在其他消息处理程序中使用这些窗口句柄，您需要确保它们的生存期足够长。

一种解决方法是将窗口句柄存储在全局或静态变量中，以便在整个应用程序中访问它们。例如，在UiObjects 类中，您可以将 Canvas 和 Output 对象的窗口句柄存储为静态变量：

  1. static HWND hObjectCanvasWnd;
  2. static HWND hObjectOutputWnd;

然后，在WM_CREATE消息处理程序中将它们设置为相应窗口的句柄：

  1. hObjectCanvasWnd = CreateWindow(
  2.     Object.lpClassName, // Window class
  3.     Object.lpWindowName,    // Window text
  4.     Object.dwStyle, // Styles 
  5.     Object.x, // Horizontal position 
  6.     Object.y, // Vertical position 
  7.     Object.nWidth, // Width
  8.     Object.nHeigth, // Height
  9.     hWnd, // Parent window
  10.     Object.hMenu, // No menu.
  11.     hInstance,
  12.     NULL // Pointer not needed.
  13. );
  15. MyObjects.Objects[i].hObjectWnd = hObjectCanvasWnd;
  17. if (lstrcmp(Object.lpWindowName, L"Output") == 0)
  18. {
  19.     hObjectOutputWnd = hObjectCanvasWnd;
  20. }

现在，您可以在其他消息处理程序中使用 hObjectOutputWnd 来操作 Output 窗口。确保将相应的条件检查添加到 WM_LBUTTONDOWN 消息处理程序中，以确定您是否操作了正确的窗口。

希望这可以帮助您解决问题。如果还有其他问题，请随时提出。

英文:

First you get a MCWE. You know probably better than me how to use it but I would recommend to build a C++ project from scratch and add it then. It uses Unicode character set, make sure to use windows as the SubSystem.

  1. #include <vector>
  2. #include <windows.h>
  3. #include <windowsx.h>
  5. #using <System.dll>
  7. const int CANVAS_HOR_OFFSET = 10;
  8. const int CANVAS_VER_OFFSET = 10;
  9. const int CANVAS_WIDTH = 640;
  10. const int CANVAS_HEIGTH = 480;
  12. const int OUTPUT_VER_OFFSET = 10;
  13. const int OUTPUT_HEIGTH = 120;
  15. static class UiObjects
  16. {
  17. public:
  18.     enum ObjectClass { Custom };
  20.     struct Object {
  21.         LPWSTR lpClassName;
  22.         LPWSTR lpWindowName;
  23.         DWORD dwStyle;
  24.         LONG x;
  25.         LONG y;
  26.         LONG nWidth;
  27.         LONG nHeigth;
  28.         HMENU hMenu;
  29.         HWND hObjectWnd;
  30.         ObjectClass objectType;
  31.         COLORREF color;
  32.     };
  34.     Object Canvas, Output;
  36.     std::vector<Object> Objects;
  38.     UiObjects();
  39. } MyObjects;
  41. UiObjects::UiObjects() {
  42.     Canvas = {
  43.         L"myVirtualSandbox Canvas Class",
  44.         L"Canvas",
  45.         WS_VISIBLE | WS_CHILD | WS_BORDER,
  46.         CANVAS_HOR_OFFSET,
  47.         CANVAS_VER_OFFSET,
  48.         CANVAS_WIDTH,
  49.         CANVAS_HEIGTH,
  50.         NULL,
  51.         NULL,
  52.         ObjectClass::Custom
  53.     };
  54.     Objects.push_back(Canvas);
  56.     Output = {
  57.         L"EDIT",
  58.         L"Output",
  59.         WS_VISIBLE | WS_CHILD | WS_BORDER,
  60.         CANVAS_HOR_OFFSET,
  61.         CANVAS_VER_OFFSET + CANVAS_HEIGTH + OUTPUT_VER_OFFSET,
  62.         CANVAS_WIDTH,
  63.         OUTPUT_HEIGTH,
  64.         NULL,
  65.         NULL,
  66.         ObjectClass::Custom
  67.     };
  68.     Objects.push_back(Output);
  69. }
  71. LRESULT CALLBACK wndProc(
  72.     HWND hWnd,
  73.     UINT uMsg,
  74.     WPARAM wParam,
  75.     LPARAM lParam
  76. );
  78. LRESULT CALLBACK canvasWndProc(
  79.     HWND hWnd,
  80.     UINT uMsg,
  81.     WPARAM wParam,
  82.     LPARAM lParam
  83. );
  85. int __stdcall wWinMain(
  86.     _In_ HINSTANCE hInstance,
  87.     _In_opt_ HINSTANCE hPrevInstance,
  88.     _In_ LPWSTR lpCmdLine,
  89.     _In_ int nShowCmd
  90. ) {
  91.     const wchar_t CLASS_NAME[] = L"myVirtualSandbox Window Class";
  93.     HWND hApplicationWnd;
  94.     MSG msg = { };
  95.     // A window class defines a set of behaviors that several windows 
  96.     // might have in common. Every window must be associated with a 
  97.     // window class. To register a window class, fill in a "WNDCLASS" 
  98.     // structure and call "RegisterClass" function afterwards.
  99.     WNDCLASS applicationWndClass = { };
  101.     applicationWndClass.lpfnWndProc = wndProc;
  102.     applicationWndClass.hInstance = hInstance;
  103.     applicationWndClass.lpszClassName = CLASS_NAME;
  105.     RegisterClass(&applicationWndClass);
  107.     // Create the window.
  108.     hApplicationWnd = CreateWindow(
  109.         CLASS_NAME,                     // Window class
  110.         L"Learn to Program Windows",    // Window text
  111.         WS_OVERLAPPEDWINDOW,            // Window style
  112.         // Size and position
  113.         CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
  114.         NULL,       // Parent window    
  115.         NULL,       // Menu
  116.         hInstance,  // Instance handle
  117.         NULL        // Additional application data
  118.     );
  120.     if (hApplicationWnd == NULL)
  121.     {
  122.         return 0;
  123.     }
  125.     ShowWindow(hApplicationWnd, nShowCmd);
  127.     while (GetMessage(&msg, NULL, 0, 0) > 0)
  128.     {
  129.         TranslateMessage(&msg);
  130.         DispatchMessage(&msg);
  131.     }
  133.     return 0;
  134. }
  136. LRESULT CALLBACK wndProc(
  137.     HWND hWnd,
  138.     UINT uMsg,
  139.     WPARAM wParam,
  140.     LPARAM lParam
  141. ) {
  142.     switch (uMsg)
  143.     {
  144.     case WM_CREATE:
  145.     {
  146.         HINSTANCE hInstance;
  147.         WNDCLASS canvasWndClass;
  149.         hInstance = (HINSTANCE)GetModuleHandle(NULL);
  151.         canvasWndClass = { };
  153.         canvasWndClass.lpfnWndProc = canvasWndProc;
  154.         canvasWndClass.hInstance = hInstance;
  155.         canvasWndClass.lpszClassName = L"myVirtualSandbox Canvas Class";
  157.         RegisterClass(&canvasWndClass);
  159.         // The following loop iterates through the container of user 
  160.         // interface objects.
  161.         for (int i = 0; i < MyObjects.Objects.size(); i++) {
  162.             UiObjects::Object& Object = MyObjects.Objects[i];
  164.             HWND hObjectWnd;
  166.             hObjectWnd = CreateWindow(
  167.                 Object.lpClassName, // Window class
  168.                 Object.lpWindowName,    // Window text
  169.                 Object.dwStyle, // Styles 
  170.                 Object.x, // Horizontal position 
  171.                 Object.y, // Vertical position 
  172.                 Object.nWidth, // Width
  173.                 Object.nHeigth, // Height
  174.                 hWnd, // Parent window
  175.                 Object.hMenu, // No menu.
  176.                 hInstance,
  177.                 NULL // Pointer not needed.
  178.             );
  180.             MyObjects.Objects[i].hObjectWnd = hObjectWnd;
  181.         }
  183.         break;
  184.     }
  186.     case WM_DESTROY:
  187.     {
  188.         PostQuitMessage(0);
  189.         break;
  190.     }
  192.     // To paint the window the "WM_PAINT" message has to be 
  193.     // received by the window. It is sent by either the program 
  194.     // itself or the operating system.
  195.     case WM_PAINT:
  196.     {
  197.         // The "rcPaint" member of the "PAINTSTRCUT" structure 
  198.         // returns a "RECT" structure that specifies the upper 
  199.         // left and lower right corners of the rectangle in which 
  200.         // the painting is requested.
  201.         PAINTSTRUCT paintStruct;
  202.         HDC hDeviceContext;
  204.         HBRUSH hBrush;
  206.         hDeviceContext = BeginPaint(hWnd, &paintStruct);
  207.         hBrush = CreateSolidBrush(RGB(66,66,66));
  209.         // Paint application background.
  210.         FillRect(
  211.             hDeviceContext,
  212.             &paintStruct.rcPaint,
  213.             hBrush
  214.         );
  216.         DeleteObject(hBrush);
  218.         EndPaint(hWnd, &paintStruct);
  220.         break;
  221.     }
  222.     }
  224.     return DefWindowProc(hWnd, uMsg, wParam, lParam);
  225. }
  227. LRESULT CALLBACK canvasWndProc(
  228.     HWND hCanvasWnd,
  229.     UINT uMsg,
  230.     WPARAM wParam,
  231.     LPARAM lParam
  232. ) {
  233.     switch (uMsg)
  234.     {
  236.     case WM_LBUTTONDOWN:
  237.     {
  238.         POINT point = { };
  240.         point.x = GET_X_LPARAM(lParam);
  241.         point.y = GET_Y_LPARAM(lParam);
  243.         System::Diagnostics::Debug::WriteLine("Clicked in Canvas.");
  245.         HWND hOutputWnd = MyObjects.Output.hObjectWnd;
  247.         // Check if hObjectWnd is a valid handle
  248.         if (IsWindow(MyObjects.Output.hObjectWnd))
  249.         {
  250.             SendMessage(MyObjects.Output.hObjectWnd, WM_SETTEXT, NULL, (LPARAM)L"Test.");
  251.         }
  252.         else {
  253.             System::Diagnostics::Debug::WriteLine("Is not..");
  254.         }
  255.         break;
  256.     }
  257.     }
  259.     return DefWindowProc(hCanvasWnd, uMsg, wParam, lParam);
  260. }

I create windows by iterating through Objects in the WM_CREATE message of the parent window.

I also register a custom window class to be able to have custom event handling on that object. In case of WM_LBUTTONDOWN of this "sub"-procedure I want to modify another child windows text by sending a message to it.

The Output is "Is not.." since the window handle is not passed properly but what am I doing wrong?

I tried to pass the variable as a pointer but that didn´t make a difference at all.

答案1

得分: 0

在你的WM_CREATE循环中，你将新的HWND分配给了来自向量的Object的副本。你没有更新向量中的原始Object。

将这个：

  1. UiObjects::Object Object = MyObjects.Objects[i];

改成这样：

  1. UiObjects::Object& Object = MyObjects.Objects[i];
  2.                  ^

另外，请注意，Canvas、Output等都是与存储在Objects向量中的Object不同的独立Object。因此，你的WM_CREATE循环也没有正确更新Output.hObjectWnd等。

更新：事实上，你正在填充Canvas、Output等数据，然后将那些对象的副本推送到Objects向量中。因此，即使你的WM_CREATE代码正确地将新的HWND分配给了Objects元素，Canvas、Output等也不会正确获取HWND。

为了实现你尝试的功能，你需要将Objects向量更改为保存Object*指针而不是Object实例，例如：

  1. #include <vector>
  2. #include <windows.h>
  3. #include <windowsx.h>
  5. #using <System.dll>
  7. const int CANVAS_HOR_OFFSET = 10;
  8. const int CANVAS_VER_OFFSET = 10;
  9. const int CANVAS_WIDTH = 640;
  10. const int CANVAS_HEIGTH = 480;
  12. const int OUTPUT_VER_OFFSET = 10;
  13. const int OUTPUT_HEIGTH = 120;
  15. static class UiObjects
  16. {
  17. public:
  18.     enum ObjectClass { Custom };
  20.     struct Object {
  21.         LPWSTR lpClassName;
  22.         LPWSTR lpWindowName;
  23.         DWORD dwStyle;
  24.         LONG x;
  25.         LONG y;
  26.         LONG nWidth;
  27.         LONG nHeigth;
  28.         HMENU hMenu;
  29.         HWND hObjectWnd;
  30.         ObjectClass objectType;
  31.         COLORREF color;
  32.     };
  34.     Object Canvas, Output;
  36.     std::vector<Object*> Objects;
  38.     UiObjects();
  39. } MyObjects;
  41. UiObjects::UiObjects() {
  42.     Canvas = {
  43.         L"myVirtualSandbox Canvas Class",
  44.         L"Canvas",
  45.         WS_VISIBLE | WS_CHILD | WS_BORDER,
  46.         CANVAS_HOR_OFFSET,
  47.         CANVAS_VER_OFFSET,
  48.         CANVAS_WIDTH,
  49.         CANVAS_HEIGTH,
  50.         NULL,
  51.         NULL,
  52.         ObjectClass::Custom
  53.     };
  54.     Objects.push_back(&Canvas);
  56.     Output = {
  57.         L"EDIT",
  58.         L"Output",
  59.         WS_VISIBLE | WS_CHILD | WS_BORDER,
  60.         CANVAS_HOR_OFFSET,
  61.         CANVAS_VER_OFFSET + CANVAS_HEIGTH + OUTPUT_VER_OFFSET,
  62.         CANVAS_WIDTH,
  63.         OUTPUT_HEIGTH,
  64.         NULL,
  65.         NULL,
  66.         ObjectClass::Custom
  67.     };
  68.     Objects.push_back(&Output);
  69. }
  71. LRESULT CALLBACK wndProc(
  72.     HWND hWnd,
  73.     UINT uMsg,
  74.     WPARAM wParam,
  75.     LPARAM lParam
  76. );
  78. LRESULT CALLBACK canvasWndProc(
  79.     HWND hWnd,
  80.     UINT uMsg,
  81.     WPARAM wParam,
  82.     LPARAM lParam
  83. );
  85. int __stdcall wWinMain(
  86.     _In_ HINSTANCE hInstance,
  87.     _In_opt_ HINSTANCE hPrevInstance,
  88.     _In_ LPWSTR lpCmdLine,
  89.     _In_ int nShowCmd
  90. ) {
  91.     const wchar_t CLASS_NAME[] = L"myVirtualSandbox Window Class";
  93.     // 窗口类定义了几个窗口可能具有的行为。每个窗口必须与窗口类相关联。
  94.     // 要注册窗口类，请填写“WNDCLASS”结构，然后调用“RegisterClass”函数。
  95.     WNDCLASS applicationWndClass = { };
  97.     applicationWndClass.lpfnWndProc = wndProc;
  98.     applicationWndClass.hInstance = hInstance;
  99.     applicationWndClass.lpszClassName = CLASS_NAME;
  101.     if (!RegisterClass(&applicationWndClass))
  102.     {
  103.         return 0;
  104.     }
  106.     // 创建窗口。
  107.     HWND hApplicationWnd = CreateWindow(
  108.         CLASS_NAME,                     // 窗口类
  109.         L"Learn to Program Windows",    // 窗口文本
  110.         WS_OVERLAPPEDWINDOW,            // 窗口样式
  111.         // 大小和位置
  112.         CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
  113.         NULL,       // 父窗口
  114.         NULL,       // 菜单
  115.         hInstance,  // 实例句柄
  116.         NULL        // 附加应用程序数据
  117.     );
  119.     if (hApplicationWnd == NULL)
  120.     {
  121.         return 0;
  122.     }
  124.     ShowWindow(hApplicationWnd, nShowCmd);
  126.     MSG msg = { };
  127.     while (GetMessage(&msg, NULL, 0, 0) > 0)
  128.     {
  129.         TranslateMessage(&msg);
  130.         DispatchMessage(&msg);
  131.     }
  133.     return 0;
  134. }
  136. LRESULT CALLBACK wndProc(
  137.     HWND hWnd,
  138.     UINT uMsg,
  139.     WPARAM wParam,
  140.     LPARAM lParam
  141. ) {
  142.     switch (uMsg)
  143.     {
  144.     case WM_CREATE:
  145.     {
  146.         HINSTANCE hInstance = (HINSTANCE)GetModuleHandle(NULL);
  148.         WNDCLASS canvasWndClass = { };
  149.         canvasWndClass.lpfnWndProc = canvasWndProc;
  150.         canvasWndClass.hInstance = hInstance;
  151.         canvasWndClass.lpszClassName = L"myVirtualSandbox Canvas Class";
  153.         RegisterClass(&canvasWndClass);
  155.         // 以下循环遍历用户界面对象的容器。
  156.         for (int i = 0; i < MyObjects.Objects.size(); ++i) {
  157.             UiObjects::Object* pObject = MyObjects.Objects[i];
  159.             pObject->hObjectWnd = CreateWindow(
  160.                 pObject->lpClassName, // 窗口类
  161.                 pObject->lpWindowName,    // 窗口文本
  162.                 pObject->dwStyle, // 样式
  163.                 pObject->x, // 水平位置
  164.                 pObject->y, // 垂直位置
  165.                 pObject->Width, // 宽度
  166.                 pObject->nHeigth, // 高度
  167.                 hWnd, // 父窗口
  168.                 pObject->hMenu, // 无菜单
  169.                 hInstance,
  170.                 NULL // 指针不需要。
  171.             );
  172.         }
  174.         break;
  175.     }
  177.     case WM_DESTROY:
  178.     {
  179.         PostQuitMessage(0);
  180.         break;
  181.     }
  183.     // 要绘制窗口，必须通过窗口接收“WM_PAINT”消息。它由程序本身或操作系统发送。
  184.     case WM_PAINT:
  185.     {
  186.         // “PAINTSTRUCT”的“rcPaint”成员返回一个指定绘制请求的矩形的左上角和右下角。
  187.         PAINTSTRUCT paintStruct = { };
  189.         HDC hDeviceContext = BeginPaint(hWnd, &
  191. <details>
  192. <summary>英文:</summary>
  194. Inside your `WM_CREATE` loop, you are assigning the new `HWND` to a *copy* of the `Object` from the vector. You are not updating the original `Object` in the vector.
  196. Change this:

UiObjects::Object Object = MyObjects.Objects[i];

  2. To this:

UiObjects::Object& Object = MyObjects.Objects[i];
^

  2. Also, note that `Canvas`, `Output`, etc are separate `Object`s than the ones stored in the `Objects` vector. So, `Output.hObjectWnd` etc are likewise not being updated by your `WM_CREATE` loop, either. 
  3. ---
  4. **UPDATE**: Indeed, you are filling `Canvas`, `Output`, etc with data, and then pushing *copies* of those objects into your `Objects` vector. So, even if your `WM_CREATE` code were assigning the new `HWND`s to the `Objects` elements correctly, `Canvas`, `Output`, etc would still not get the `HWND`s correctly.
  5. To do what you are attempting, you need to change your `Objects` vector to hold `Object*` pointers instead of `Object` instances, eg:

#include <vector>
#include <windows.h>
#include <windowsx.h>

#using <System.dll>

const int CANVAS_HOR_OFFSET = 10;
const int CANVAS_VER_OFFSET = 10;
const int CANVAS_WIDTH = 640;
const int CANVAS_HEIGTH = 480;

const int OUTPUT_VER_OFFSET = 10;
const int OUTPUT_HEIGTH = 120;

static class UiObjects
{
public:
enum ObjectClass { Custom };

  1. struct Object {
  2. LPWSTR lpClassName;
  3. LPWSTR lpWindowName;
  4. DWORD dwStyle;
  5. LONG x;
  6. LONG y;
  7. LONG nWidth;
  8. LONG nHeigth;
  9. HMENU hMenu;
  10. HWND hObjectWnd;
  11. ObjectClass objectType;
  12. COLORREF color;
  13. };
  14. Object Canvas, Output;
  15. std::vector&lt;Object*&gt; Objects;
  16. UiObjects();

} MyObjects;

UiObjects::UiObjects() {
Canvas = {
L"myVirtualSandbox Canvas Class",
L"Canvas",
WS_VISIBLE | WS_CHILD | WS_BORDER,
CANVAS_HOR_OFFSET,
CANVAS_VER_OFFSET,
CANVAS_WIDTH,
CANVAS_HEIGTH,
NULL,
NULL,
ObjectClass::Custom
};
Objects.push_back(&Canvas);

  1. Output = {
  2. L&quot;EDIT&quot;,
  3. L&quot;Output&quot;,
  4. WS_VISIBLE | WS_CHILD | WS_BORDER,
  5. CANVAS_HOR_OFFSET,
  6. CANVAS_VER_OFFSET + CANVAS_HEIGTH + OUTPUT_VER_OFFSET,
  7. CANVAS_WIDTH,
  8. OUTPUT_HEIGTH,
  9. NULL,
  10. NULL,
  11. ObjectClass::Custom
  12. };
  13. Objects.push_back(&amp;Output);

}

LRESULT CALLBACK wndProc(
HWND hWnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam
);

LRESULT CALLBACK canvasWndProc(
HWND hWnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam
);

int __stdcall wWinMain(
In HINSTANCE hInstance,
In_opt HINSTANCE hPrevInstance,
In LPWSTR lpCmdLine,
In int nShowCmd
) {
const wchar_t CLASS_NAME[] = L"myVirtualSandbox Window Class";

  1. // A window class defines a set of behaviors that several windows 
  2. // might have in common. Every window must be associated with a 
  3. // window class. To register a window class, fill in a &quot;WNDCLASS&quot; 
  4. // structure and call &quot;RegisterClass&quot; function afterwards.
  5. WNDCLASS applicationWndClass = { };
  6. applicationWndClass.lpfnWndProc = wndProc;
  7. applicationWndClass.hInstance = hInstance;
  8. applicationWndClass.lpszClassName = CLASS_NAME;
  9. if (!RegisterClass(&amp;applicationWndClass))
  10. {
  11. return 0;
  12. }
  13. // Create the window.
  14. HWND hApplicationWnd = CreateWindow(
  15. CLASS_NAME,                     // Window class
  16. L&quot;Learn to Program Windows&quot;,    // Window text
  17. WS_OVERLAPPEDWINDOW,            // Window style
  18. // Size and position
  19. CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
  20. NULL,       // Parent window    
  21. NULL,       // Menu
  22. hInstance,  // Instance handle
  23. NULL        // Additional application data
  24. );
  25. if (hApplicationWnd == NULL)
  26. {
  27. return 0;
  28. }
  29. ShowWindow(hApplicationWnd, nShowCmd);
  30. MSG msg = { };
  31. while (GetMessage(&amp;msg, NULL, 0, 0) &gt; 0)
  32. {
  33. TranslateMessage(&amp;msg);
  34. DispatchMessage(&amp;msg);
  35. }
  36. return 0;

}

LRESULT CALLBACK wndProc(
HWND hWnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam
) {
switch (uMsg)
{
case WM_CREATE:
{
HINSTANCE hInstance = (HINSTANCE)GetModuleHandle(NULL);

  1.     WNDCLASS canvasWndClass = { };
  2. canvasWndClass.lpfnWndProc = canvasWndProc;
  3. canvasWndClass.hInstance = hInstance;
  4. canvasWndClass.lpszClassName = L&quot;myVirtualSandbox Canvas Class&quot;;
  5. RegisterClass(&amp;canvasWndClass);
  6. // The following loop iterates through the container of user 
  7. // interface objects.
  8. for (int i = 0; i &lt; MyObjects.Objects.size(); ++i) {
  9. UiObjects::Object* pObject = MyObjects.Objects[i];
  10. pObject-&gt;hObjectWnd = CreateWindow(
  11. pObject-&gt;lpClassName, // Window class
  12. pObject-&gt;lpWindowName,    // Window text
  13. pObject-&gt;dwStyle, // Styles 
  14. pObject-&gt;x, // Horizontal position 
  15. pObject-&gt;y, // Vertical position 
  16. pObject-&gt;Width, // Width
  17. pObject-&gt;nHeigth, // Height
  18. hWnd, // Parent window
  19. pObject-&gt;hMenu, // No menu.
  20. hInstance,
  21. NULL // Pointer not needed.
  22. );
  23. }
  24. break;
  25. }
  26. case WM_DESTROY:
  27. {
  28. PostQuitMessage(0);
  29. break;
  30. }
  31. // To paint the window the &quot;WM_PAINT&quot; message has to be 
  32. // received by the window. It is sent by either the program 
  33. // itself or the operating system.
  34. case WM_PAINT:
  35. {
  36. // The &quot;rcPaint&quot; member of the &quot;PAINTSTRCUT&quot; structure 
  37. // returns a &quot;RECT&quot; structure that specifies the upper 
  38. // left and lower right corners of the rectangle in which 
  39. // the painting is requested.
  40. PAINTSTRUCT paintStruct = { };
  41. HDC hDeviceContext = BeginPaint(hWnd, &amp;paintStruct);
  42. HBRUSH hBrush = CreateSolidBrush(RGB(66,66,66));
  43. // Paint application background.
  44. FillRect(
  45. hDeviceContext,
  46. &amp;paintStruct.rcPaint,
  47. hBrush
  48. );
  49. DeleteObject(hBrush);
  50. EndPaint(hWnd, &amp;paintStruct);
  51. break;
  52. }
  53. }
  54. return DefWindowProc(hWnd, uMsg, wParam, lParam);

}

LRESULT CALLBACK canvasWndProc(
HWND hCanvasWnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam
) {
switch (uMsg)
{

  1. case WM_LBUTTONDOWN:
  2. {
  3. POINT point = { };
  4. point.x = GET_X_LPARAM(lParam);
  5. point.y = GET_Y_LPARAM(lParam);
  6. System::Diagnostics::Debug::WriteLine(&quot;Clicked in Canvas.&quot;);
  7. HWND hOutputWnd = MyObjects.Output.hObjectWnd;
  8. // Check if hObjectWnd is a valid handle
  9. if (IsWindow(hOutputWnd))
  10. {
  11. SendMessage(hOutputWnd, WM_SETTEXT, NULL, (LPARAM)L&quot;Test.&quot;);
  12. }
  13. else {
  14. System::Diagnostics::Debug::WriteLine(&quot;Is not..&quot;);
  15. }
  16. break;
  17. }
  18. }
  19. return DefWindowProc(hCanvasWnd, uMsg, wParam, lParam);

}

  2. </details>

huangapple
  • 本文由 发表于 2023年7月13日 21:40:11
  • 转载请务必保留本文链接：https://go.coder-hub.com/76680052.html
  • c++
  • createwindow
  • hwnd
  • winapi
  • window
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定