> ## Content Index
> Fetch the complete content index at: https://arabroot.io/llms.txt
> Use this file to discover other available public pages before exploring further.

# أول برنامج Win32 بلغة C: نافذة وحلقة الرسائل
- URL: https://arabroot.io/articles/اول-برنامج-win32-بلغة-c-نافذة-وحلقة-الرسائل/
- Published: 2026-11-20T11:41:30.000Z
- Updated: 2026-11-20T12:41:24.000Z
- Description: نكتب نافذة Win32 بلغة C ونسجل كل رسالة تصلها، ثم نجعلها عربية بـ WS_EX_LAYOUTRTL ونرى لماذا يعلن Windows بعد خمس ثوان أن البرنامج لا يستجيب.
- Author: فريق عرب رووت
- Tags: الأدلة التقنية, Windows للمسؤولين والمطورين

كل نافذة تراها على Windows، من المفكرة Notepad إلى نافذة تثبيت أي برنامج إلى رسالة الخطأ الصغيرة، تقف خلفها الفكرة نفسها: حلقة تكرار صغيرة تنتظر رسالة، ثم تسلمها لدالة تقرر ماذا تفعل بها، ثم تعود لتنتظر. وعندما يتوقف برنامج ويكتب Windows بجانب اسمه «Not Responding» ويصير لون النافذة باهتاً، فالمعنى الحرفي لهذه الكلمات أن هذه الحلقة لم تعد تقرأ رسائلها منذ خمس ثوان. وهذه الفكرة ليست من الماضي، فحتى البرامج المكتوبة بـ WinForms وWPF وWinUI تدور فيها الحلقة نفسها تحت الإطار Framework الذي تستخدمه، وما زال يجرها النظام نفسه.

وفي مقال واجهة Win32 قرأنا الدوال وأنظمة الأخطاء والنسختين A وW ببرامج صامتة تطبع نصاً فقط، وفي هذا المقال نكتب أول برنامج له نافذة بلغة C، من دون أي إطار، ونسجل في ملف كل رسالة تصل إلى دالة النافذة من لحظة إنشائها إلى لحظة إغلاقها، ثم نجعلها نافذة عربية من اليمين إلى اليسار، ونرى ما يحدث عندما ننسى سطراً واحداً من الأسطر المعتادة، وعندما تنام دالة النافذة 12 ثانية، وعندما تعمل على شاشة دقتها 150%. وكل ذلك على جهاز Windows 11 حقيقي، وبحساب مستخدم عادي Standard User، والصور كلها من نوافذ برنامجنا نفسه.

[![](https://arabroot.io/content/images/2026/11/win32-api-basics-cover-cover.webp)دليلواجهة Win32 API: كيف يكلم برنامجك نظام Windows؟نقرأ واجهة Win32 ببرامج C صغيرة على Windows 11: أين يعيش كود الدوال، ولماذا يتلف الاسم العربي مع نسخة A، وكيف تقرأ GetLastError وHRESULT دون أن يخدعك رقم قديم.](https://arabroot.io/articles/%D9%88%D8%A7%D8%AC%D9%87%D8%A9-win32-api-%D9%83%D9%8A%D9%81-%D9%8A%D9%83%D9%84%D9%85-%D8%A8%D8%B1%D9%86%D8%A7%D9%85%D8%AC%D9%83-%D9%86%D8%B8%D8%A7%D9%85-windows/)[![](https://arabroot.io/content/images/2026/11/win32-processes-files-cover-cover.webp)دليلWin32 للعمليات والملفات: CreateProcess وCreateFileنشغل برامج أخرى ونقرأ مخرجها ونفتح الملفات بلغة C على Windows 11 بصلاحيات مستخدم عادي، ونرى لماذا تتجمد الأدوات مع الأنابيب ولماذا يبقى الملف مفتوحاً بعد أن تغلقه.](https://arabroot.io/articles/win32-%D9%84%D9%84%D8%B9%D9%85%D9%84%D9%8A%D8%A7%D8%AA-%D9%88%D8%A7%D9%84%D9%85%D9%84%D9%81%D8%A7%D8%AA-createprocess-%D9%88createfile/)[![](https://arabroot.io/content/images/2026/11/windows-ui-history-cover-cover.webp)دليلمن Win32 إلى WinUI: واجهات Windows عبر أربعين سنةلماذا جاءت كل تقنية لبناء واجهات Windows من Win32 إلى WinForms وWPF وWinUI، وما الذي بقي منها، مع النافذة نفسها مبنية بأربع طرق ومقاسة بالأرقام على Windows 11.](https://arabroot.io/articles/%D9%85%D9%86-win32-%D8%A7%D9%84%D9%89-winui-%D9%88%D8%A7%D8%AC%D9%87%D8%A7%D8%AA-windows-%D8%B9%D8%A8%D8%B1-%D8%A7%D8%B1%D8%A8%D8%B9%D9%8A%D9%86-%D8%B3%D9%86%D8%A9/)

وسوف نتناول في هذا المقال ما يلي:

- الأجزاء الأربعة لأي برنامج له نافذة: نقطة الدخول، وصنف النافذة Window Class، والنافذة، وحلقة الرسائل Message Loop.
- دالة النافذة Window Procedure والرسالة WM\_PAINT، ورسم نص عربي بالدالة DrawTextW.
- ما يصل فعلاً إلى دالة النافذة: 60 رسالة في ثانية ونصف، والفرق بين الرسالة المرسلة Sent والرسالة التي تمر على الطابور Queue.
- الأزرار ومربعات النص كنوافذ أبناء Child Windows، والرسالة WM\_COMMAND.
- النافذة العربية بـ WS\_EX\_LAYOUTRTL، والخطأ الذي يعكس النص.
- ثلاثة أخطاء كلاسيكية: نسيان DefWindowProcW، ونسيان PostQuitMessage، والعمل الطويل داخل دالة النافذة.
- الدقة العالية DPI: لماذا تبدو النافذة ضبابية، وكيف تصلحها بملف البيان Manifest.

## ما الذي يحتاجه برنامج ليظهر نافذة؟

البرنامج الذي يطبع في الطرفية Console يبدأ من `main` وينتهي عندما تنتهي، أما برنامج النوافذ فهو برنامج ينتظر أغلب وقته، ولا يعرف متى سيضغط المستخدم أو يحرك الفأرة أو يغطي نافذته بنافذة أخرى ثم يكشفها. ولذلك قلبت Windows الفكرة: البرنامج لا يسأل «ماذا حدث؟» في كل لحظة، وإنما يعطي النظام دالة واحدة ويقول له: كلما حدث شيء يخص نافذتي فاستدعها. وهذه الدالة هي دالة النافذة WndProc، وما يحدث يصلها على شكل رسائل Messages، كل رسالة رقم مثل `WM_PAINT` ومعه معاملان اسمهما `wParam` و`lParam`. وتشرح Microsoft هذا النموذج في درس [Your First Windows Program](https://learn.microsoft.com/en-us/windows/win32/learnwin32/your-first-windows-program?ref=arabroot.io) وفي صفحة [About Messages and Message Queues](https://learn.microsoft.com/en-us/windows/win32/winmsg/about-messages-and-message-queues?ref=arabroot.io).

ولكي تظهر نافذة واحدة يحتاج البرنامج أربعة أجزاء، والصورة التالية تبين كيف تتصل:

![مسار الرسالة من المستخدم إلى طابور الرسائل إلى حلقة GetMessageW وDispatchMessageW ثم دالة النافذة وDefWindowProcW](https://arabroot.io/content/images/2026/11/win32-first-window-01-loop.webp)

الرسالة تدخل الطابور، والحلقة تسحبها وتسلمها لدالة النافذة، وما لا تعالجه الدالة يذهب إلى DefWindowProcW.

1. **نقطة الدخول wWinMain:** مثل `main`، ولكنها تستلم مقبض البرنامج Instance وطريقة إظهار النافذة الأولى التي طلبها من شغل البرنامج، مثل مكبرة أو مصغرة.
2. **صنف النافذة Window Class:** قالب تسجله مرة واحدة بالدالة `RegisterClassExW`، وفيه أهم شيء: عنوان دالة النافذة، ومعه شكل المؤشر Cursor ولون الخلفية. وكلمة Class هنا لا علاقة لها بالكلاس في البرمجة الكائنية، وإنما تعني «نوع نافذة»، فكل الأزرار في Windows مثلاً نوافذ من الصنف `BUTTON`.
3. **النافذة نفسها:** تنشئها `CreateWindowExW` من الصنف، مع عنوانها وحجمها ونمطها Style، وتعيد مقبض نافذة `HWND`.
4. **حلقة الرسائل:** ثلاثة أسطر في آخر `wWinMain` تبقى تدور حتى يقرر البرنامج أن ينتهي.

### لماذا صممت Windows النوافذ بالرسائل؟

قد يتساءل البعض: لماذا كل هذا الطريق الطويل؟ لماذا لا يسأل البرنامج عن حالة الفأرة كل جزء من الثانية ويرسم ما يريد؟ والإجابة أن هذا ما كانت تفعله برامج MS-DOS، وكان مقبولاً لأن برنامجاً واحداً يملك الشاشة كلها. أما عندما تعمل عدة برامج في نوافذ متداخلة على شاشة واحدة، فلا بد من طرف ثالث يعرف أي نافذة فوق أي نافذة، ولمن تذهب النقرة، ومن يحتاج أن يعيد رسم الجزء الذي انكشف، وهذا الطرف هو مدير النوافذ في النظام، والرسالة هي طريقته في أن يخبر كل برنامج بما يخصه فقط. وفي Windows القديم بنسخه 16 بت كانت كل البرامج تتشارك طابوراً واحداً للإدخال، ولم يكن النظام يوقف برنامجاً ليعطي غيره دوره، وإنما ينتظر أن يعود البرنامج إلى `GetMessage` بإرادته، وهو ما يسمى تعدد المهام التعاوني Cooperative Multitasking. فإذا علق برنامج واحد داخل دالة نافذته، توقفت الواجهة كلها. وعندما جاءت Win32 مع Windows NT صار لكل خيط ينشئ نوافذ طابوره الخاص، وصار النظام يقسم وقت المعالج بين الخيوط بنفسه، فصار البرنامج المعلق يعلق وحده، وهذا ما سوف نراه بأعيننا في قسم النافذة التي لا تستجيب، حيث نامت دالة النافذة 12 ثانية وبقي كل شيء آخر على الجهاز يعمل. ومن يريد التفاصيل الداخلية لطوابير الخيوط وكيف يوزع النظام الإدخال عليها فهي في فصل النوافذ من كتاب Windows Internals الذي تعرضه Microsoft في صفحة [Windows Internals](https://learn.microsoft.com/en-us/sysinternals/resources/windows-internals?ref=arabroot.io).

## تجهيز المختبر Lab

البرنامج كله ملف واحد `firstwin.c` في مجلد `lab` مع المقال، وفيه خيارات تشغيل تغير سلوكه لكل تجربة، مثل `--rtl` للنافذة العربية و`--hang 12` لتنام دالة النافذة، و`--log` ليكتب سطراً في ملف عن كل رسالة. ونبنيه بالمترجم MinGW-w64 داخل Container من Alpine Linux، ثم يشغله سكربت PowerShell بست طرق، ويأخذ صوراً من الشاشة لنافذته، ثم يغلقها ويحذف مجلد التشغيل:

```powershell
cd lab
docker run --rm -v "%cd%:/src" -w /src alpine:3.22 sh build.sh
powershell -NoProfile -ExecutionPolicy Bypass -File run.ps1
```

والملف `build.sh` يبني البرنامج مرتين، مرة عادية ومرة مع ملف بيان Manifest للدقة العالية سوف نصل إليه في آخر المقال، ثم يقرأ رأس الملف التنفيذي بالأداة `objdump`:

```bash
x86_64-w64-mingw32-gcc -O1 -Wall -municode -mwindows -o build/firstwin.exe firstwin.c
x86_64-w64-mingw32-windres dpi.rc -O coff -o build/dpi.res
x86_64-w64-mingw32-gcc -O1 -Wall -municode -mwindows -o build/firstwin-dpi.exe firstwin.c build/dpi.res
x86_64-w64-mingw32-objdump -p build/firstwin.exe | grep -E "^Subsystem|DLL Name"
```

والمخرج سوف يكون كما يلي:

```text
x86_64-w64-mingw32-gcc (GCC) 14.2.0
Subsystem		00000002	(Windows GUI)
	DLL Name: GDI32.dll
	DLL Name: KERNEL32.dll
	DLL Name: api-ms-win-crt-convert-l1-1-0.dll
	DLL Name: api-ms-win-crt-environment-l1-1-0.dll
	DLL Name: api-ms-win-crt-heap-l1-1-0.dll
	DLL Name: api-ms-win-crt-math-l1-1-0.dll
	DLL Name: api-ms-win-crt-private-l1-1-0.dll
	DLL Name: api-ms-win-crt-runtime-l1-1-0.dll
	DLL Name: api-ms-win-crt-stdio-l1-1-0.dll
	DLL Name: api-ms-win-crt-string-l1-1-0.dll
	DLL Name: api-ms-win-crt-time-l1-1-0.dll
	DLL Name: SHELL32.dll
	DLL Name: USER32.dll
```

وفي المخرج أعلاه لاحظ التالي:

- **Subsystem 2:** الخيار `-mwindows` كتب في رأس الملف أن البرنامج من النظام الفرعي Windows GUI، فلا يفتح له Windows نافذة طرفية سوداء عند تشغيله بالنقر المزدوج، والقيمة 3 تعني برنامج طرفية Console. وهذا الحقل وحده هو الفرق بين النوعين عند التشغيل.
- **USER32 وGDI32:** المكتبتان اللتان شرحناهما في مقال واجهة Win32، الأولى للنوافذ والرسائل والثانية للرسم.
- **SHELL32:** جاءت من دالة واحدة نستخدمها لقراءة خيارات سطر الأوامر هي `CommandLineToArgvW`.
- **api-ms-win-crt:** مكتبة C الحديثة UCRT التي يأتي بها Windows 10 و11، مقسمة إلى مجموعات API Sets بأسماء ثابتة.

والجهاز الذي شغلنا عليه المختبر Windows 11 Pro 24H2 بشاشتين، والشاشة الرئيسية دقتها 2560 في 1440 بتكبير 150%، وهذا التفصيل الأخير هو موضوع القسم الأخير من المقال.

## الكود خطوة خطوة

### تسجيل الصنف وإنشاء النافذة

أول ما تفعله `wWinMain` بعد قراءة الخيارات هو تسجيل الصنف، ثم إنشاء النافذة منه، ثم إظهارها:

```c
WNDCLASSEXW wc = { sizeof wc };
wc.lpfnWndProc = WndProc;
wc.hInstance = hInst;
wc.hCursor = LoadCursorW(NULL, (LPCWSTR)IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
wc.lpszClassName = L"ArabRootFirstWindow";
if (!RegisterClassExW(&wc)) return 1;

HWND hwnd = CreateWindowExW(g_rtl ? WS_EX_LAYOUTRTL : 0, wc.lpszClassName, L"نافذتي الأولى",
                            WS_OVERLAPPEDWINDOW, 200, 200, S(640), S(320), NULL, NULL, hInst, NULL);
if (!hwnd) {
    if (g_log) { fprintf(g_log, "CreateWindowExW returned NULL, GetLastError = %lu, messages seen = %d\n", GetLastError(), g_count); fclose(g_log); }
    return 2;
}
ShowWindow(hwnd, show);
UpdateWindow(hwnd);
```

وفي الكود أعلاه لاحظ التالي:

- **{ sizeof wc }:** أول حقل في البنية هو حجمها، وهو النمط نفسه الذي رأيناه مع `GetVersionExW`، والباقي أصفار.
- **COLOR\_WINDOW + 1:** طريقة قديمة غريبة لإعطاء لون نظام بدل فرشاة Brush، والزيادة بواحد موثقة في صفحة [RegisterClassExW](https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-registerclassexw?ref=arabroot.io) حتى لا يصير اللون رقم صفر فيظن النظام أنه لا يوجد لون.
- **العنوان العربي:** لأننا نستدعي النسخ W كلها، فالعنوان `نافذتي الأولى` يصل كما هو، ويظهر في شريط العنوان وشريط المهام Taskbar دون أي إعداد للغة.
- **WS\_OVERLAPPEDWINDOW:** نمط يجمع شريط العنوان والحدود القابلة للسحب وأزرار التصغير والتكبير والإغلاق، أي النافذة العادية.
- **الدالة S():** ماكرو صغير في البرنامج لا يفعل شيئاً إلا مع الخيار `--scale`، وسوف نرى سببه في قسم الدقة.
- **UpdateWindow:** تطلب رسماً فورياً بإرسال `WM_PAINT` مباشرة إذا كان في النافذة جزء يحتاج رسماً، بدل أن ينتظر الرسم دوره في الطابور.

### حلقة الرسائل

```c
MSG m; BOOL r;
while ((r = GetMessageW(&m, NULL, 0, 0)) != 0) {
    if (r == -1) break;
    TranslateMessage(&m);
    g_dispatching = &m;
    DispatchMessageW(&m);
    g_dispatching = NULL;
}
```

الدالة `GetMessageW` تنام حتى تصل رسالة إلى طابور الخيط، ثم تنسخها إلى `m` وتعيد قيمة غير الصفر، وعندما تصل الرسالة `WM_QUIT` تعيد صفراً فتخرج الحلقة. ولاحظ السطر `if (r == -1)`: صفحة [GetMessageW](https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-getmessagew?ref=arabroot.io) تقول إن الدالة قد تعيد `-1` عند الخطأ، مثل مقبض نافذة غير صالح، ولذلك فإن الحلقة الشائعة `while (GetMessageW(...))` تدور إلى الأبد في هذه الحالة لأن `-1` قيمة صحيحة في C. أما `TranslateMessage` فتحول ضغطات المفاتيح الخام `WM_KEYDOWN` إلى رسائل أحرف `WM_CHAR` بحسب لغة لوحة المفاتيح، وهي التي تجعل مربع النص يكتب «ب» عندما تضغط الحرف نفسه في لوحة عربية. و`DispatchMessageW` تنظر في `m.hwnd` وتستدعي دالة النافذة صاحبة الرسالة. والسطران حولها خاصان بالمختبر، ليعرف السجل أن الرسالة جاءت من الطابور.

### حلقات أخرى: PeekMessage والحلقة المتداخلة

الحلقة التي كتبناها تنام داخل `GetMessageW` حتى تصل رسالة، وهذا ما تريده في أغلب البرامج لأن البرنامج لا يستهلك المعالج وهو ينتظر. ولكن هناك برامج تريد أن تعمل في كل لحظة، مثل الألعاب التي ترسم ستين إطاراً في الثانية سواءً حرك المستخدم الفأرة أم لا. وهذه تستخدم [PeekMessageW](https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-peekmessagew?ref=arabroot.io) بالخيار `PM_REMOVE`، وهي تسحب الرسالة إن وجدت وتعود فوراً إن لم توجد، فتعالج الحلقة كل الرسائل المنتظرة ثم ترسم إطاراً ثم تعود. والثمن أن هذه الحلقة تأخذ نواة معالج كاملة طوال الوقت، لذلك لا تستخدمها في برنامج عادي، والسبب أن الحلقة لا تنام أبداً حتى عندما لا يوجد ما تفعله.

والحلقة الثانية التي لا تراها هي الحلقة المتداخلة Nested Loop. فعندما تستدعي `MessageBoxW` من داخل دالة النافذة، فإن الدالة لا تعود حتى يضغط المستخدم الزر، ومع ذلك تبقى نافذتك الأصلية تعيد رسم نفسها إذا غطيتها وكشفتها. والسبب أن `MessageBoxW` تشغل حلقة رسائل خاصة بها داخلها، تسحب رسائل كل نوافذ الخيط وتوزعها، بما فيها رسائل نافذتك، حتى ينتهي الصندوق. وتصف Microsoft الآلية نفسها في WPF في صفحة [Threading Model](https://learn.microsoft.com/en-us/dotnet/desktop/wpf/advanced/threading-model?ref=arabroot.io) تحت اسم `PushFrame`. والنتيجة العملية التي تفاجئ كثيرين أن دالة نافذتك قد تستدعى مرة أخرى وهي ما زالت داخل استدعاء سابق لم ينته، أي إعادة الدخول Reentrancy، فإذا كانت الدالة في منتصف تعديل بيانات عندما عرضت الرسالة، فقد تقرأ رسالة أخرى هذه البيانات نصف معدلة.

### دالة النافذة والرسالة WM\_PAINT

دالة النافذة `switch` كبيرة على رقم الرسالة، تعالج ما يهمها، وترسل كل ما سواه إلى `DefWindowProcW`، وهي دالة النظام التي تعرف السلوك الافتراضي لكل رسالة: سحب النافذة من شريط العنوان، وتغيير حجمها من الحدود، ورسم الإطار، وتحويل النقر على زر الإغلاق إلى `WM_CLOSE` ثم إلى `DestroyWindow`. وهذا هو الجزء الذي يرسم النص:

```c
case WM_PAINT: {
    g_paints++;
    PAINTSTRUCT ps; HDC dc = BeginPaint(hwnd, &ps);
    RECT rc; GetClientRect(hwnd, &rc); rc.left += S(24); rc.right -= S(24); rc.top += S(24);
    HFONT f = CreateFontW(-S(22), 0, 0, 0, FW_NORMAL, 0, 0, 0, DEFAULT_CHARSET, 0, 0, CLEARTYPE_QUALITY, 0, L"Segoe UI");
    HGDIOBJ old = SelectObject(dc, f);
    SetBkMode(dc, TRANSPARENT);
    UINT fl = (g_rtl && !g_sameflags) ? DT_LEFT : (DT_RIGHT | DT_RTLREADING);
    DrawTextW(dc, TEXT_AR, -1, &rc, fl | DT_WORDBREAK);
    ...
    SelectObject(dc, old); DeleteObject(f);
    EndPaint(hwnd, &ps);
    return 0; }
case WM_DESTROY:
    if (!g_noquit) PostQuitMessage(0);
    return 0;
}
return DefWindowProcW(hwnd, msg, wp, lp);
```

وهنا أهم فكرة في الرسم على Windows: البرنامج لا يرسم متى شاء، وإنما يرسم عندما يطلب منه النظام بالرسالة [WM\_PAINT](https://learn.microsoft.com/en-us/windows/win32/gdi/wm-paint?ref=arabroot.io)، وذلك عند أول ظهور، وعند تكبير النافذة، وعند كشف جزء كانت تغطيه نافذة أخرى. وبين `BeginPaint` و`EndPaint` يعطيك النظام سياق جهاز DC، واختصاراً لـ Device Context، ترسم عليه، ثم يعتبر المنطقة سليمة، فإذا نسيت `EndPaint` أو لم تستدع `BeginPaint` أصلاً فإن النظام يرى أن المنطقة ما زالت تحتاج رسماً ويرسل `WM_PAINT` مرة بعد مرة. ولاحظ أن الخط Font ينشأ ويحذف في كل رسم، وهذا مقبول في مثال صغير، وفي برنامج حقيقي تنشئه مرة واحدة في `WM_CREATE` وتحذفه في `WM_DESTROY`، لأن كل خط كائن GDI يحسب على العملية، ونسيان `DeleteObject` مرة في كل رسم ينتهي بنافذة لا ترسم شيئاً بعد ساعات. وهذه هي النتيجة الأولى من السكربت:

![نافذة Win32 عنوانها نافذتي الأولى وفيها نص عربي مرسوم بالدالة DrawTextW وسطر يذكر رقم WM_PAINT وعدد الرسائل وDPI](https://arabroot.io/content/images/2026/11/win32-first-window-02-hello.webp)

أول نافذة من firstwin.exe كما ظهرت على الشاشة، والنص كله مرسوم في WM\_PAINT.

والنافذة تقول بنفسها إنها رسمت مرة واحدة، وإن 22 رسالة وصلت إلى دالتها قبل هذا الرسم، وإن دقتها 96\. ولاحظ النقطة في آخر السطرين: في النص الأصلي هي آخر حرف بعد `C` وبعد `WM_PAINT`، وظهرت في اليسار في مكانها الصحيح لنص اتجاهه من اليمين إلى اليسار، وهذا عمل الخيار `DT_RTLREADING`. ولو حذفته لظهرت النقطة في اليمين ملتصقة بأول كلمة، لأن الاتجاه الافتراضي للفقرة في GDI من اليسار إلى اليمين، كما تقول صفحة [DrawTextW](https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-drawtextw?ref=arabroot.io).

## ماذا يصل إلى دالة النافذة؟ 60 رسالة في ثانية ونصف

شغل السكربت البرنامج بالخيار `--log`، وانتظر قليلاً، وأخذ صورة النافذة، ثم أرسل لها `WM_CLOSE` كأن المستخدم ضغط زر الإغلاق. وكل سطر في السجل رسالة، ومعها هل جاءت من الطابور `queue` أم استدعى أحد دالة النافذة مباشرة `sent`. وهذا أول السجل حتى رجوع `UpdateWindow`:

```text
exit code 0
     0 ms  sent   WM_GETMINMAXINFO           wParam=0 lParam=...
     0 ms  sent   WM_NCCREATE                wParam=0 lParam=...
    31 ms  sent   WM_NCCALCSIZE              wParam=0 lParam=...
    31 ms  sent   WM_CREATE                  wParam=0 lParam=...
    31 ms  sent   WM_SHOWWINDOW              wParam=1 lParam=0
    31 ms  sent   WM_WINDOWPOSCHANGING       wParam=0 lParam=...
    47 ms  sent   WM_WINDOWPOSCHANGING       wParam=0 lParam=...
    47 ms  sent   WM_ACTIVATEAPP             wParam=1 lParam=0
    47 ms  sent   WM_NCACTIVATE              wParam=0 lParam=0
    47 ms  sent   WM_GETICON                 wParam=2 lParam=0
    47 ms  sent   WM_GETICON                 wParam=0 lParam=0
    78 ms  sent   WM_GETICON                 wParam=1 lParam=0
    78 ms  sent   WM_ACTIVATE                wParam=1 lParam=0
   ...
   156 ms  sent   WM_PAINT                   wParam=0 lParam=0
   188 ms  --- CreateWindowExW + ShowWindow + UpdateWindow returned, 22 messages so far
```

اختصرنا قيم `lParam` التي هي عناوين في الذاكرة تتغير كل تشغيل، والسجل الكامل في الملف `out-01-messages.txt`. والصورة التالية تجمع الرسائل الـ 60 بحسب الدالة التي كانت تعمل لحظة وصولها:

![أربع مجموعات من الرسائل: داخل CreateWindowExW وداخل ShowWindow وداخل UpdateWindow وبعد بدء الحلقة حتى الإغلاق](https://arabroot.io/content/images/2026/11/win32-first-window-03-sequence.webp)

22 رسالة قبل أن تبدأ الحلقة أصلاً، وكلها sent.

وفي السجل أعلاه لاحظ التالي:

- **كل شيء قبل الحلقة sent:** 22 رسالة وصلت إلى دالة النافذة قبل أول `GetMessageW`، أي قبل أن توجد حلقة رسائل تعمل. وهذا يعني أن دالة النافذة تستدعى من داخل `CreateWindowExW` و`ShowWindow` نفسها، فإذا كانت دالتك تعتمد على متغير لم تهيئه بعد لأنك تهيئه بعد `CreateWindowExW`، فإن `WM_CREATE` سوف تراه فارغاً.
- **WM\_NCCREATE قبل WM\_CREATE:** الحرفان NC يعنيان Non-Client، أي الجزء الذي يرسمه النظام من النافذة: شريط العنوان والحدود. فالنظام يجهز الإطار أولاً بـ `WM_NCCREATE` ويحسب مساحة الداخل بـ `WM_NCCALCSIZE`، ثم يعطيك `WM_CREATE` لتجهز أنت المحتوى.
- **WM\_GETMINMAXINFO أولاً:** قبل أي شيء يسأل النظام عن أصغر وأكبر حجم مسموح للنافذة، وهي الرسالة التي تعالجها إذا أردت أن تمنع المستخدم من تصغير نافذتك عن حد معين.
- **WM\_ACTIVATE وWM\_SETFOCUS:** النافذة صارت النافذة النشطة وأخذت تركيز لوحة المفاتيح Keyboard Focus، ومعها رسائل محرر الإدخال IME، وهو الجزء الذي يدير لغات الإدخال المعقدة.

وهذا باقي السجل حتى الإغلاق، مختصراً أيضاً:

```text
   188 ms  queue  WM_DWMNCRENDERINGCHANGED   wParam=1 lParam=0
   188 ms  queue  0xC0D0                     wParam=0 lParam=0
   ...
   235 ms  sent   WM_GETOBJECT               wParam=FFFFFFFF lParam=FFFFFFFC
   235 ms  sent   0xC279                     wParam=1 lParam=0
   235 ms  sent   0x0164                     wParam=0 lParam=...
   891 ms  sent   WM_WINDOWPOSCHANGING       wParam=0 lParam=...
   891 ms  sent   WM_WINDOWPOSCHANGED        wParam=0 lParam=...
  1438 ms  sent   WM_WINDOWPOSCHANGING       wParam=0 lParam=...
  1438 ms  sent   WM_WINDOWPOSCHANGED        wParam=0 lParam=...
  1438 ms  queue  WM_CLOSE                   wParam=0 lParam=0
  1438 ms  sent   0x0090                     wParam=0 lParam=0
  ...
  1453 ms  sent   WM_DESTROY                 wParam=0 lParam=0
  1453 ms  sent   WM_NCDESTROY               wParam=0 lParam=0
  1453 ms  --- GetMessageW returned 0 (WM_QUIT), exit code 0, 60 messages, 1 WM_PAINT
```

وفي هذا الجزء لاحظ التالي:

- **أرقام بلا أسماء:** `0xC0D0` و`0xC279` أكبر من `0xC000`، وهذا المدى محجوز للرسائل المسجلة Registered Messages التي ينشئها أي برنامج بالدالة [RegisterWindowMessageW](https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-registerwindowmessagew?ref=arabroot.io) باسم نصي، فيحصل كل من يسجل الاسم نفسه على الرقم نفسه، ويختلف الرقم من جلسة إلى أخرى. أما `0x0090` و`0x0164` فرسائل داخلية لا توثقها Microsoft، وتذهب كما هي إلى `DefWindowProcW`، وهذا سبب آخر لكي لا تبتلع أي رسالة لا تعرفها.
- **WM\_GETOBJECT:** 16 رسالة من هذا النوع، وهي أسئلة تقنيات الوصول Accessibility، أي برامج قراءة الشاشة وواجهة UI Automation، عن محتوى النافذة، كما في صفحة [WM\_GETOBJECT](https://learn.microsoft.com/en-us/windows/win32/winauto/wm-getobject?ref=arabroot.io). فالنافذة لم تكد تظهر حتى سألها جزء آخر من النظام عما فيها.
- **رسائل من برنامج آخر:** الرسالتان عند 891 و1438 ميلي ثانية جاءتا من سكربت المختبر نفسه، فقد جعل النافذة فوق كل النوافذ Topmost ليأخذ صورتها ثم أعادها، بالدالة `SetWindowPos` من عملية PowerShell. فالرسالة `sent` قد تأتي من عملية أخرى تماماً، ويستدعي النظام دالة نافذتك في خيطك أنت لتنفيذها.
- **الإغلاق:** `WM_CLOSE` جاءت من الطابور لأن السكربت أرسلها بـ `PostMessage`، ثم حولتها `DefWindowProcW` إلى `DestroyWindow` فجاءت `WM_DESTROY`، فاستدعينا `PostQuitMessage`، فوضعت `WM_QUIT` في الطابور، فأعادت `GetMessageW` صفراً، وخرج البرنامج بالرمز صفر بعد 60 رسالة ورسم واحد.

والفرق بين المرسلة والتي تمر على الطابور ليس تفصيلاً أكاديمياً: الرسالة التي تمر على الطابور تنتظر دورها حتى تقرأها الحلقة، فإذا كانت الحلقة مشغولة فهي تنتظر، أما الرسالة المرسلة بـ `SendMessage` من خيط آخر فإن المرسل نفسه يتوقف حتى ترد دالة نافذتك، وهذا هو الطريق الذي ينتقل به التوقف من برنامج إلى آخر، كما سوف نرى في قسم النافذة التي لا تستجيب.

## الأزرار ومربعات النص: نوافذ داخل النافذة

الزر في Win32 ليس رسماً ترسمه بنفسك، وإنما نافذة كاملة من الصنف `BUTTON` الذي سجله النظام مسبقاً، وكذلك مربع النص من الصنف `EDIT`. وتنشئهما بالدالة نفسها `CreateWindowExW` مع النمط `WS_CHILD`، وتعطي كل واحد رقماً Control ID، وتعطيه مقبض النافذة الأم Parent:

```c
CreateWindowExW(0, L"BUTTON", L"احفظ", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, S(24), S(200), S(120), S(36), hwnd, (HMENU)ID_BUTTON, NULL, NULL);
CreateWindowExW(WS_EX_CLIENTEDGE, L"EDIT", L"اكتب هنا", WS_CHILD | WS_VISIBLE | ES_AUTOHSCROLL, S(160), S(202), S(300), S(32), hwnd, (HMENU)ID_EDIT, NULL, NULL);
```

ولكل ابن دالة نافذة يملكها النظام، تعالج الرسم والنقر والكتابة، وعندما يحدث شيء يهمك يرسل الابن إلى أمه الرسالة `WM_COMMAND` ومعها رقمه ورمز الإشعار Notification Code. والصورة التالية هي البرنامج بالخيار `--controls`:

![النافذة نفسها مع زر احفظ ومربع نص اكتب هنا في أسفلها من جهة اليسار](https://arabroot.io/content/images/2026/11/win32-first-window-04-ltr-controls.webp)

زر ومربع نص، وكل منهما نافذة ابن، والنافذة الأم ما زالت من اليسار إلى اليمين.

وفي البرامج الحقيقية نادراً ما ينشئ المطور كل ابن بسطر `CreateWindowExW` كما فعلنا، وإنما يصف النافذة كلها في قالب حوار Dialog Template داخل ملف الموارد Resources، بمواقع الأزرار والحقول ونصوصها، ثم ينشئها النظام بدالة واحدة مثل `DialogBoxW`، كما تشرح صفحة [About Dialog Boxes](https://learn.microsoft.com/en-us/windows/win32/dlgbox/about-dialog-boxes?ref=arabroot.io). والحوار له حلقته الخاصة أيضاً، وهي التي تجعل مفتاح Tab ينقل التركيز من حقل إلى آخر ومفتاح Enter يضغط الزر الافتراضي. وإذا أردت هذا السلوك في نافذة عادية مثل نافذتنا، فإن حلقة الرسائل تحتاج سطراً إضافياً يمرر كل رسالة أولاً إلى `IsDialogMessageW`، وإلا فإن Tab لا يفعل شيئاً، وهذا من الأسئلة المتكررة لمن ينشئ عناصر التحكم بنفسه.

والنص العربي في الزر ومربع النص ظهر صحيحاً، ومربع النص نفسه يكتب العربية ويحركها كما يجب لأنه يتعامل مع ثنائية الاتجاه Bidi داخلياً، ولكن ترتيب العناصر خطأ لقارئ عربي: الزر في اليسار، وأزرار العنوان في اليمين، والنافذة كلها مصممة لقارئ يبدأ من اليسار. وهنا يأتي القسم التالي.

## النافذة العربية: WS\_EX\_LAYOUTRTL

لو أردت أن تعكس النافذة بنفسك لكان عليك أن تحسب كل إحداثي من الحافة اليمنى، وأن تعيد الحساب عند كل تغيير للحجم. وبدل ذلك أضافت Microsoft في Windows 2000 ميزة المرآة Mirroring، وتشرحها صفحة [Window Features](https://learn.microsoft.com/en-us/windows/win32/winmsg/window-features?ref=arabroot.io) في قسم Window Layout and Mirroring: نمط إضافي واحد هو `WS_EX_LAYOUTRTL` يجعل نقطة الأصل (0,0) في الزاوية العليا اليمنى للنافذة، ويجعل محور x يزيد نحو اليسار، فينعكس كل شيء دون أن تغير سطراً من حسابات الإحداثيات:

![نافذتان: بلا WS_EX_LAYOUTRTL الأصل في اليسار والزر عند x=24 من اليسار، ومعه الأصل في اليمين والزر عند x=24 من اليمين](https://arabroot.io/content/images/2026/11/win32-first-window-11-mirror.webp)

الرقم نفسه في الكود، والنظام يقيسه من الجهة الأخرى.

وفي البرنامج يكفي أن نمرر النمط في أول معامل لـ `CreateWindowExW`، كما رأيت في الكود: `g_rtl ? WS_EX_LAYOUTRTL : 0`. والسكربت يقرأ النمط من النافذة بعد إنشائها ليتأكد:

```text
ltr             WS_EX = 0x00000100  WS_EX_LAYOUTRTL set: False
rtl-same-flags  WS_EX = 0x00400100  WS_EX_LAYOUTRTL set: True
rtl             WS_EX = 0x00400100  WS_EX_LAYOUTRTL set: True
```

البت `0x00400000` هو `WS_EX_LAYOUTRTL`، والبت `0x00000100` هو `WS_EX_WINDOWEDGE` الذي أضافه النظام بنفسه لأنه جزء من النافذة العادية. ولكن عندما شغلنا النسخة العربية أول مرة بالأعلام نفسها التي يرسم بها النص في النافذة العادية، أي `DT_RIGHT | DT_RTLREADING`، ظهرت هكذا:

![نافذة معكوسة صحيحة الترتيب ولكن النص فيها ملتصق باليسار وترتيب الكلمات العربية والإنجليزية مختلط](https://arabroot.io/content/images/2026/11/win32-first-window-05-rtl-wrong.webp)

النافذة معكوسة كما يجب، والنص في اليسار وترتيب كلماته مختلط.

أزرار العنوان انتقلت إلى اليسار، والزر ومربع النص انتقلا إلى اليمين، وكل هذا صحيح. أما النص فصار في اليسار، وصار ترتيب الكلمات العربية حول `Win32` و`DrawTextW` مختلطاً. والسبب أن المرآة لا تشمل النافذة فقط، وإنما سياق الرسم DC أيضاً، فـ `DT_RIGHT` صارت تعني الحافة اليسرى التي يراها المستخدم، واتجاه القراءة في سياق معكوس صار من اليمين إلى اليسار أصلاً، فلما أضفنا `DT_RTLREADING` عكسناه مرة ثانية فعاد من اليسار إلى اليمين، فرتبت الكلمات كأنها جملة إنجليزية. والإصلاح سطر واحد في الكود: في النافذة المعكوسة نرسم بـ `DT_LEFT` وحدها، أي بالأعلام نفسها التي يكتبها مطور النافذة الإنجليزية:

```c
UINT fl = (g_rtl && !g_sameflags) ? DT_LEFT : (DT_RIGHT | DT_RTLREADING);
```

وبعد الإصلاح ضغط السكربت الزر ضغطة فأرة حقيقية، بعد أن تأكد بالدالة `WindowFromPoint` أن النافذة التي تحت المؤشر هي نافذتنا، ثم أعاد المؤشر إلى مكانه، وهذه النتيجة:

![النافذة العربية المعكوسة بنص صحيح الاتجاه في اليمين وعنوانها تم الضغط على الزر](https://arabroot.io/content/images/2026/11/win32-first-window-06-rtl-clicked.webp)

النافذة العربية بعد الإصلاح، والعنوان تغير بعد الضغط على الزر.

والسجل يبين الطريق الذي سلكته الضغطة:

```text
after one click on the button the title is: تم الضغط على الزر
messages from the child controls in the last run:
    47 ms  sent   WM_PARENTNOTIFY            wParam=650001 lParam=...
    62 ms  sent   WM_COMMAND                 wParam=4000066 lParam=...
    62 ms  sent   WM_COMMAND                 wParam=3000066 lParam=...
    62 ms  sent   WM_PARENTNOTIFY            wParam=660001 lParam=...
  1766 ms  sent   WM_PARENTNOTIFY            wParam=201 lParam=DA0220
  1766 ms  sent   WM_COMMAND                 wParam=65 lParam=...
  1766 ms  sent   WM_SETTEXT                 wParam=0 lParam=...
```

وفي السجل أعلاه لاحظ التالي:

- **wParam في WM\_COMMAND:** النصف الأدنى رقم الابن والنصف الأعلى رمز الإشعار. فـ `4000066` تعني الابن `0x66`، أي 102 مربع النص، والرمز `0x400` وهو `EN_UPDATE`، ثم `0x300` وهو `EN_CHANGE`، وقد أرسلهما مربع النص عندما غيرنا خطه عند الإنشاء. أما `65` فتعني الابن `0x65`، أي 101 الزر، والرمز صفر وهو `BN_CLICKED`.
- **WM\_PARENTNOTIFY:** الابن يخبر أمه عند إنشائه، ثم عند الضغط عليه بالقيمة `0x201` وهي `WM_LBUTTONDOWN`، ومعها مكان النقرة.
- **WM\_SETTEXT:** جاءت من `SetWindowTextW` التي استدعيناها في معالجة `WM_COMMAND`، أي أن تغيير العنوان نفسه رسالة إلى دالة النافذة، تعالجها `DefWindowProcW`.

وتصميم الواجهة العربية أوسع من هذا النمط بكثير، من الأيقونات التي تنعكس والتي لا تنعكس إلى الأرقام داخل النص، وقد شرحناه في [تصميم الواجهات العربية RTL](https://arabroot.io/articles/%D8%AA%D8%B5%D9%85%D9%8A%D9%85-%D8%A7%D9%84%D9%88%D8%A7%D8%AC%D9%87%D8%A7%D8%AA-%D8%A7%D9%84%D8%B9%D8%B1%D8%A8%D9%8A%D8%A9-rtl/) وفي [التعريب والنص ثنائي الاتجاه للمطورين](https://arabroot.io/articles/%D8%A7%D9%84%D8%AA%D8%B9%D8%B1%D9%8A%D8%A8-i18n-%D9%88%D8%A7%D9%84%D9%86%D8%B5-%D8%AB%D9%86%D8%A7%D8%A6%D9%8A-%D8%A7%D9%84%D8%A7%D8%AA%D8%AC%D8%A7%D9%87-bidi-%D9%84%D9%84%D9%85%D8%B7%D9%88%D8%B1%D9%8A%D9%86/). وما يخص Win32 تحديداً أن المرآة تنتقل من الأم إلى الأبناء تلقائياً، وأن الصور Bitmaps تنعكس معها إلا إذا طلبت غير ذلك بالخيار `NOMIRRORBITMAP`، وأن أي رسم بإحداثيات تحسبها بنفسك من الشاشة لا من النافذة يحتاج انتباهاً.

## ماذا لو نسيت DefWindowProcW؟

من يكتب دالة النافذة أول مرة قد يرى السطر الأخير `return DefWindowProcW(...)` زائداً، فيكتب `return 0` لكل رسالة لا يعالجها. والخيار `--no-default` يفعل ذلك بالضبط، وهذه نتيجته:

```text
exit code 2
    16 ms  sent   WM_GETMINMAXINFO           wParam=0 lParam=...
    16 ms  sent   WM_NCCREATE                wParam=0 lParam=...
    16 ms  sent   WM_NCDESTROY               wParam=0 lParam=0
CreateWindowExW returned NULL, GetLastError = 0, messages seen = 3
```

لم تظهر نافذة أصلاً. فالرسالة [WM\_NCCREATE](https://learn.microsoft.com/en-us/windows/win32/winmsg/wm-nccreate?ref=arabroot.io) توثق أن القيمة المرجعة `TRUE` تعني «استمر في الإنشاء»، و`FALSE` تعني «ألغ الإنشاء»، وصفرنا هو `FALSE`، فألغى النظام النافذة فوراً وأرسل `WM_NCDESTROY`، وأعادت `CreateWindowExW` القيمة `NULL`. ولاحظ أن `GetLastError` أعاد صفراً، فلا يوجد أي نص يقول لك ما المشكلة، والبرنامج خرج بالرمز 2 الذي وضعناه نحن. وهذا مثال حي على قاعدة مقال واجهة Win32: الفشل هنا قرار من كودك، لا من النظام، فلا تبحث عن السبب في رقم الخطأ. ولو كانت الدالة تعيد صفراً لكل شيء إلا `WM_NCCREATE` لظهرت نافذة لا تتحرك ولا ترسم إطارها ولا تغلق، لأن كل هذا السلوك تكتبه `DefWindowProcW`، كما تقول صفحتها في [Microsoft Learn](https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-defwindowprocw?ref=arabroot.io).

## ماذا لو نسيت PostQuitMessage؟

الخطأ الثاني أخطر لأنه لا يظهر للمستخدم: النافذة تغلق بشكل طبيعي، والبرنامج يبقى. والخيار `--no-quit` يجعل `WM_DESTROY` تعود دون `PostQuitMessage`، والسكربت أغلق النافذة وانتظر ثلاث ثوان ثم نظر:

```text
3 s after WM_CLOSE: process running = True, visible windows = 0, threads = 11
   515 ms  sent   WM_KILLFOCUS               wParam=0 lParam=0
   515 ms  sent   WM_IME_SETCONTEXT          wParam=0 lParam=C000000F
   515 ms  sent   WM_IME_NOTIFY              wParam=1 lParam=0
   515 ms  sent   WM_DESTROY                 wParam=0 lParam=0
   546 ms  sent   WM_NCDESTROY               wParam=0 lParam=0
```

النافذة دمرت، والعملية ما زالت تعمل بـ 11 خيطاً ولا تملك أي نافذة ظاهرة، لأن الحلقة ما زالت داخل `GetMessageW` تنتظر رسالة لن تأتي، ولا يوجد ما يخبرها أن البرنامج انتهى، فاضطر السكربت أن ينهي العملية بنفسه. وفي الحياة الحقيقية هذا هو البرنامج الذي لا يمكنك أن تحدثه لأن «الملف مستخدم»، أو الذي تجد منه عشر نسخ في مدير المهام بعد أسبوع، وقد شرحنا كيف تجد من يقفل الملف في [الملف مفتوح في برنامج آخر](https://arabroot.io/articles/%D8%A7%D9%84%D9%85%D9%84%D9%81-%D9%85%D9%81%D8%AA%D9%88%D8%AD-%D9%81%D9%8A-%D8%A8%D8%B1%D9%86%D8%A7%D9%85%D8%AC-%D8%A7%D8%AE%D8%B1-%D9%85%D9%86-%D9%8A%D9%82%D9%81%D9%84-%D8%A7%D9%84%D9%85%D9%84%D9%81-%D9%81%D9%8A-windows/). ولماذا لا يخرج البرنامج تلقائياً عندما تدمر آخر نافذة؟ لأن Windows لا يعرف أن هذه آخر نافذة يهتم بها البرنامج، فقد يكون للبرنامج نوافذ مخفية أو عمل في الخلفية، ولذلك فإن قرار الخروج للبرنامج وحده. ويشرح Raymond Chen لماذا صممت `WM_QUIT` بهذا الشكل الخاص، ولماذا لا ترسلها بنفسك بـ `PostMessage` بدل `PostQuitMessage`، في مقاله [Modality, part 3: The WM\_QUIT message](https://devblogs.microsoft.com/oldnewthing/20050222-00/?p=36393&ref=arabroot.io) في مدونة The Old New Thing.

## النافذة التي لا تستجيب Not Responding

الآن الخطأ الذي يراه كل مستخدم Windows: البرنامج يعمل شيئاً طويلاً، كقراءة ملف كبير أو انتظار رد من السيرفر، داخل دالة النافذة نفسها. والخيار `--hang 12` يشغل مؤقتاً Timer بعد ثانيتين من ظهور النافذة، وعند `WM_TIMER` تنام الدالة 12 ثانية بالدالة `Sleep`:

```c
case WM_TIMER:
    KillTimer(hwnd, 1);
    ...
    Sleep(g_hang * 1000);                                    /* long work on the UI thread: the queue is not read */
```

والسكربت يسأل كل ثانية ثلاثة أسئلة: هل يقول Windows إن النافذة معلقة بالدالة [IsHungAppWindow](https://learn.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-ishungappwindow?ref=arabroot.io)؟ وهل ترد النافذة على رسالة فارغة `WM_NULL` خلال نصف ثانية؟ وما النافذة التي يراها المستخدم عند نقطة في شريط عنوانها؟ والمخرج سوف يكون كما يلي:

```text
t=  1.0s  IsHungAppWindow=False  WM_NULL answered within 500 ms=True   window at the title bar: firstwin
t=  2.6s  IsHungAppWindow=False  WM_NULL answered within 500 ms=False  window at the title bar: firstwin
t=  4.1s  IsHungAppWindow=False  WM_NULL answered within 500 ms=False  window at the title bar: firstwin
t=  5.6s  IsHungAppWindow=False  WM_NULL answered within 500 ms=False  window at the title bar: firstwin
t=  7.1s  IsHungAppWindow=True   WM_NULL answered within 500 ms=False  window at the title bar: firstwin
t=  8.1s  IsHungAppWindow=True   WM_NULL answered within 500 ms=False  window at the title bar: class Ghost
           ghost window: class Ghost, owner process dwm.exe, title "نافذتي الأولى"
t=  9.4s  IsHungAppWindow=True   WM_NULL answered within 500 ms=False  window at the title bar: class Ghost
...
t= 13.4s  IsHungAppWindow=True   WM_NULL answered within 500 ms=False  window at the title bar: class Ghost
t= 14.4s  IsHungAppWindow=False  WM_NULL answered within 500 ms=True   window at the title bar: firstwin
...
  2016 ms  --- window procedure starts Sleep(12 s)
 14032 ms  --- Sleep returned
 18610 ms  --- GetMessageW returned 0 (WM_QUIT), exit code 0, 94 messages, 2 WM_PAINT
```

![خط زمني: النوم من 2 إلى 14 ثانية، وWM_NULL بلا رد من 2.6، وIsHungAppWindow صحيح من 7.1 إلى 14.4، ونافذة Ghost من 8.1](https://arabroot.io/content/images/2026/11/win32-first-window-07-hang.webp)

بين أول رسالة لا يرد عليها البرنامج وحكم Windows بأنه معلق خمس ثوان.

وفي المخرج أعلاه لاحظ التالي:

- **عند 2.6 ثانية:** بدأ النوم عند 2.0، ومن أول قياس بعده لم ترد النافذة على `WM_NULL`، فأي برنامج يرسل لها `SendMessage` عادية بلا مهلة سوف يتوقف معها، وهذا ما نعنيه بانتقال التوقف من برنامج إلى آخر. ولذلك استخدم السكربت `SendMessageTimeout` بمهلة 500 ميلي ثانية.
- **عند 7.1 ثانية:** قال Windows إن النافذة معلقة، أي بعد نحو خمس ثوان من آخر رسالة قرأتها الحلقة، وهو الرقم نفسه الذي تذكره Microsoft في صفحة [Preventing Hangs in Windows Applications](https://learn.microsoft.com/en-us/windows/win32/win7appqual/preventing-hangs-in-windows-applications?ref=arabroot.io): إذا بقيت رسالة في الطابور خمس ثوان دون أن تسحب، يعلن مدير النوافذ DWM أن النافذة معلقة، مع ملاحظة أن هذه المدة قابلة للتغيير.
- **عند 8.1 ثانية:** لم تعد النافذة التي تحت المؤشر نافذتنا، وإنما نافذة من الصنف `Ghost` تملكها العملية `dwm.exe`، بالعنوان نفسه. وهذه نافذة الشبح التي يضعها النظام مكان النافذة المعلقة، بصورة آخر محتوى رسمته، ويستطيع المستخدم من خلالها أن يحرك النافذة أو يصغرها أو يغلقها، لأن الضغط على زر الإغلاق في النافذة الأصلية سوف ينتظر في الطابور مثل أي رسالة أخرى.
- **عند 14.4 ثانية:** عادت الحلقة تقرأ، فاختفت نافذة الشبح وعادت النافذة الأصلية، وعالجت الرسائل التي تراكمت، فارتفع عدد الرسائل في هذا التشغيل إلى 94 بدل 60.

وهذه نافذة الشبح كما أخذها السكربت من الشاشة عند 8.1 ثانية:

![نافذة الشبح Ghost مكان النافذة المعلقة بالمحتوى نفسه وزر التكبير معطل](https://arabroot.io/content/images/2026/11/win32-first-window-08-ghost.webp)

نافذة Ghost من dwm.exe: صورة آخر رسم، وزر التكبير معطل.

والصفحة نفسها تذكر أن نافذة الشبح تضيف «Not Responding» إلى العنوان، وفي هذا التشغيل على Windows 11 بقي عنوان الشبح كما أعادته `GetWindowText` هو `نافذتي الأولى`، وظهر التغيير في الأزرار فقط، فلا تبن أي أداة مراقبة على نص العنوان، واستخدم `IsHungAppWindow` أو `SendMessageTimeout` كما فعل السكربت.

والحل الصحيح ليس أن تخفي الشبح بالدالة `DisableProcessWindowsGhosting`، فالصفحة نفسها تحذر من أن هذا يترك المستخدم بلا طريقة لإغلاق البرنامج إلا إعادة التشغيل، وإنما أن تخرج العمل الطويل من خيط الواجهة UI Thread: شغله في خيط عامل Worker Thread، وعندما ينتهي أرسل إلى النافذة رسالة خاصة بـ `PostMessage` لتعرض النتيجة، فتبقى الحلقة تدور وتعالج الرسم والنقر طوال الوقت. وإذا كان لا بد أن ينتظر خيط الواجهة شيئاً، فهناك `MsgWaitForMultipleObjects` التي تنتظر وتستيقظ في الوقت نفسه عند وصول رسالة. والخيوط وطرق انتظارها موضوع مقال العمليات والملفات في هذه المرحلة.

وإذا وصلك برنامج معلق في الإنتاج Production ولم تكتبه أنت، فالطريق إلى السبب يبدأ من خيط الواجهة نفسه. ففي [Process Explorer](https://arabroot.io/articles/process-explorer-%D9%85%D8%AF%D9%8A%D8%B1-%D8%A7%D9%84%D9%85%D9%87%D8%A7%D9%85-%D9%83%D9%85%D8%A7-%D9%8A%D8%AC%D8%A8-%D8%A7%D9%86-%D9%8A%D9%83%D9%88%D9%86/) افتح خصائص العملية، ثم تبويب الخيوط Threads، واختر الخيط الذي أنشأ النافذة، وانظر في مكدسه Stack: إذا وجدت في أعلاه `NtDelayExecution` فهو نائم كما في مختبرنا، وإذا وجدت انتظاراً على قفل أو قراءة شبكة فأنت تعرف ماذا ينتظر. وإذا كان التعليق يحدث مرة في اليوم ولا تستطيع أن تكون أمامه، فإن الأداة [ProcDump](https://learn.microsoft.com/en-us/sysinternals/downloads/procdump?ref=arabroot.io) تملك الخيار `-h` الذي يأخذ نسخة من ذاكرة العملية عندما لا ترد نافذتها على الرسائل خمس ثوان على الأقل، بالتعريف نفسه الذي يستخدمه Windows ومدير المهام، فتعطيها للمطور ليفتحها في المنقح Debugger ويرى أين كان كل خيط لحظة التعليق.

⚠️

لا تستدع `SendMessage` بلا مهلة إلى نافذة في برنامج آخر لا تثق أنه يستجيب، فإذا كان معلقاً توقف برنامجك معه. استخدم `SendMessageTimeout` مع الخيار `SMTO_ABORTIFHUNG`، أو `PostMessage` إذا لم تكن تحتاج الرد.

## الدقة العالية DPI: لماذا تبدو النافذة ضبابية؟

كتبنا كل الأحجام في البرنامج بالبكسل Pixel: النافذة 640 في 320، والخط 22 بكسل، والزر عند 24\. وهذه الأرقام كانت معقولة عندما كانت كل الشاشات 96 نقطة في البوصة DPI، واختصاراً لـ Dots Per Inch، أما شاشة المختبر فمضبوطة على تكبير 150%، أي 144 نقطة. فكيف ظهرت النافذة بحجم معقول في الصور السابقة؟ والإجابة أن Windows كذب على البرنامج مرة أخرى كما فعل مع رقم الإصدار: البرنامج الذي لا يقول إنه يعرف الدقة يسمى DPI Unaware، فيعطيه النظام عالماً وهمياً بدقة 96، ثم يكبر صورة النافذة كلها 150% كما تكبر صورة صغيرة. ولذلك قالت النافذة في الصور السابقة إن دقتها 96\. وتشرح Microsoft هذه الأنماط في [High DPI Desktop Application Development on Windows](https://learn.microsoft.com/en-us/windows/win32/hidpi/high-dpi-desktop-application-development-on-windows?ref=arabroot.io).

والطريقة التي يقول بها البرنامج إنه يعرف الدقة هي ملف البيان، كما في [Setting the default DPI awareness for a process](https://learn.microsoft.com/en-us/windows/win32/hidpi/setting-the-default-dpi-awareness-for-a-process?ref=arabroot.io)، وهذا هو الملف الذي ضمناه في `firstwin-dpi.exe`:

```xml
<application xmlns="urn:schemas-microsoft-com:asm.v3">
  <windowsSettings>
    <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2</dpiAwareness>
  </windowsSettings>
</application>
```

وشغل السكربت ثلاث نسخ: البرنامج العادي، والبرنامج مع ملف البيان، والبرنامج مع ملف البيان والخيار `--scale` الذي يضرب كل حجم في نسبة الدقة الحقيقية مقسومة على 96\. والحجم الحقيقي على الشاشة لكل واحدة كما قاسه السكربت:

```text
firstwin.exe               on screen 938x469
firstwin-dpi.exe           on screen 622x311
firstwin-dpi.exe  --scale  on screen 942x471
```

النسخة الثانية قالت إنها تعرف الدقة، فصدقها Windows وتوقف عن تكبيرها، وبقيت الأرقام كما كتبناها بالبكسل الحقيقي، فظهرت نافذة صغيرة بخط صغير، وهي تعرف الآن أن دقتها 144:

![النافذة نفسها أصغر بخط صغير وتقول إن DPI النافذة 144](https://arabroot.io/content/images/2026/11/win32-first-window-09-dpi-small.webp)

DPI Aware بلا تكبير: صدق Windows البرنامج، والأرقام بالبكسل الحقيقي صغيرة.

وهذا هو الخطأ الذي يقع فيه من يضيف السطر إلى ملف البيان ليتخلص من الضبابية دون أن يغير الكود. أما النسخة الثالثة فحجمها مثل الأولى تقريباً، ولكن الفرق يظهر عندما تكبر الصورة، والصورة التالية جزء واحد من النسختين الأولى والثالثة مكبراً مرتين:

![مقارنة مكبرة لكلمة مرحباً: الأعلى من النسخة التي يكبرها Windows بحواف ضبابية والأسفل من النسخة التي ترسم بالدقة الحقيقية بحواف حادة](https://arabroot.io/content/images/2026/11/win32-first-window-10-dpi-zoom.webp)

الأعلى: Windows يكبر صورة نافذة رسمت بدقة 96\. الأسفل: البرنامج يرسم بنفسه بدقة 144.

في النسخة الأولى رسم البرنامج الحروف على 96 نقطة ثم كبرها النظام كصورة، فصارت حوافها ضبابية، وفي الثالثة رسمها الخط نفسه بدقة 144 فبقيت حادة. والقاعدة لأي برنامج Win32 جديد: أعلن `PerMonitorV2` في ملف البيان، واكتب أحجامك بوحدة 96 واضربها في `GetDpiForWindow` مقسومة على 96، وعالج الرسالة `WM_DPICHANGED` التي تصلك عندما يسحب المستخدم النافذة إلى شاشة دقتها مختلفة، وهو ما لم نفعله في هذا المثال لأن البرنامج يقرأ الدقة مرة واحدة عند البدء.

## وماذا يفعل WinForms وWPF فوق هذا كله؟

إذا كتبت يوماً برنامجاً بـ WinForms فقد كتبت السطر `Application.Run(new Form1())` في `Main`، وتقول صفحة [Application.Run](https://learn.microsoft.com/en-us/dotnet/api/system.windows.forms.application.run?ref=arabroot.io) إنه يبدأ «حلقة رسائل قياسية على الخيط الحالي»، أي الحلقة نفسها التي كتبناها بثلاثة أسطر. والنموذج Form نافذة Win32 لها صنف يسجله .NET، والزر `Button` في WinForms نافذة ابن من الصنف `BUTTON` نفسه الذي أنشأناه، وحدث `Click` هو `WM_COMMAND` بعد أن يترجمه الإطار إلى حدث في C#. ولذلك فإن كل ما رأيناه في هذا المقال ينطبق على WinForms حرفياً: العمل الطويل في معالج الحدث يعلق النافذة بعد خمس ثوان، و`MessageBox.Show` حلقة متداخلة، والدقة العالية تحتاج إعداداً في ملف البيان أو في المشروع.

أما WPF فيرسم كل شيء بنفسه عبر DirectX، فلا يوجد فيه زر من الصنف `BUTTON`، ولكن النافذة الخارجية ما زالت نافذة Win32 لها مقبض `HWND`، والكلاس `Dispatcher` يدير حلقة رسائل على خيط الواجهة، ويحول رسائل الإدخال القادمة من Windows إلى أحداث WPF. وكذلك WinUI الأحدث. فالأطر تغير طريقة الرسم وطريقة كتابة الكود، ولكنها لا تستطيع أن تغير العقد مع مدير النوافذ: خيط يملك النوافذ، وطابور لهذا الخيط، وحلقة يجب أن تدور. وقصة هذه الأطر وكيف جاء كل واحد منها فوق الذي قبله هي موضوع مقال واجهات Windows عبر الزمن في هذه المرحلة.

## مشكلات قابلتنا أثناء كتابة المختبر

المشكلة الأولى كانت في أخذ الصور. فأول نسخة من السكربت أخذت صورة كل نافذة بالدالة `PrintWindow`، التي تطلب من النافذة أن ترسم نفسها في صورة في الذاكرة، وهي طريقة مريحة لأنها تعمل حتى لو كانت النافذة خلف غيرها. وجاءت صورة النافذة العادية سليمة، أما صورة النافذة المعكوسة فجاء نصها مقلوباً كالمرآة، حروفاً معكوسة لا تقرأ، رغم أن النافذة على الشاشة كانت سليمة. والسبب أن `PrintWindow` لا تتعامل مع المرآة كما تتعامل معها الشاشة، فاستبدلناها بنسخ المنطقة نفسها من الشاشة بعد جعل النافذة فوق غيرها، وهذا هو سبب رسائل `WM_WINDOWPOSCHANGING` التي رأيتها في السجل. والدرس لمن يكتب اختبارات Tests للواجهات: صورة `PrintWindow` ليست بالضرورة ما يراه المستخدم.

والمشكلة الثانية كانت في ضغط الزر. فقد أرسل السكربت أولاً الرسالة `BM_CLICK` إلى الزر، ولم يتغير العنوان، ولم يظهر `WM_COMMAND` في السجل. ووجدنا بعد البحث أن `FindWindowEx` لم تجد الزر أصلاً، لأن السكربت مرر `$null` لمعامل العنوان، وPowerShell يحول `$null` إلى نص فارغ عندما يكون المعامل من نوع `string`، فصارت الدالة تبحث عن زر عنوانه فارغ. والحل هو `[NullString]::Value`، وهي حالة ستقابلها مع كل دالة Win32 تقبل `NULL` لمعامل نصي عندما تستدعيها من PowerShell.

## أخطاء شائعة Common Mistakes

- **إعادة صفر لكل رسالة لا تعالجها:** تلغي `WM_NCCREATE` إنشاء النافذة، وتلغي باقي الرسائل السلوك الافتراضي. أرسل كل ما لا تعالجه إلى `DefWindowProcW`.
- **نسيان PostQuitMessage في WM\_DESTROY:** النافذة تغلق والعملية تبقى. ضعها في النافذة الرئيسية فقط، لا في كل نافذة.
- **الحلقة while (GetMessageW(...)):** تدور إلى الأبد إذا أعادت الدالة `-1`. افحص `-1` صراحة.
- **العمل الطويل في دالة النافذة:** بعد خمس ثوان يعلن Windows أن البرنامج معلق. انقله إلى خيط عامل وأرسل النتيجة بـ `PostMessage`.
- **الرسم خارج WM\_PAINT:** ما ترسمه بـ `GetDC` في أي وقت يمسح عند أول إعادة رسم. احفظ الحالة، واطلب الرسم بـ `InvalidateRect`، وارسم في `WM_PAINT`.
- **إنشاء كائنات GDI دون حذفها:** كل خط أو فرشاة تنشئها في `WM_PAINT` دون `DeleteObject` تتراكم حتى تتوقف النافذة عن الرسم.
- **DT\_RTLREADING في نافذة WS\_EX\_LAYOUTRTL:** تعكس الاتجاه مرة ثانية. في النافذة المعكوسة ارسم كما ترسم في النافذة الإنجليزية.
- **إضافة PerMonitorV2 دون تغيير الكود:** تختفي الضبابية وتصغر النافذة. اضرب كل حجم في الدقة الحقيقية.
- **SendMessage إلى برنامج آخر بلا مهلة:** إذا علق هو علقت أنت. استخدم `SendMessageTimeout`.

## أين تبحث عندما…؟

| ترى                                          | السبب غالباً                                   | ابحث في                                 |
| -------------------------------------------- | ---------------------------------------------- | --------------------------------------- |
| CreateWindowExW تعيد NULL وGetLastError صفر  | دالة النافذة أعادت FALSE لـ WM\_NCCREATE       | ما تعيده الدالة للرسائل التي لا تعالجها |
| العملية باقية بعد إغلاق النافذة              | لا توجد PostQuitMessage                        | معالجة WM\_DESTROY                      |
| «Not Responding» ونافذة باهتة                | دالة النافذة لم تعد منذ خمس ثوان               | المكدس في Process Explorer لخيط الواجهة |
| نص عربي ملتصق باليسار ومختلط في نافذة معكوسة | DT\_RIGHT \| DT\_RTLREADING في سياق معكوس      | أعلام DrawTextW                         |
| نافذة ضبابية على شاشة 150%                   | البرنامج DPI Unaware                           | ملف البيان وGetDpiForWindow             |
| نافذة صغيرة جداً بعد إضافة Manifest          | الأحجام بالبكسل دون ضرب في الدقة               | كل رقم ثابت في الكود                    |
| الشاشة لا تتحدث بعد تغيير البيانات           | الرسم خارج WM\_PAINT أو لا يوجد InvalidateRect | مكان الرسم                              |

## تدريب عملي Practice

1. شغل `firstwin.exe --log log.txt` بنفسك، وحرك الفأرة فوق النافذة واكتب حرفاً، ثم أغلقها وابحث في السجل عن `WM_MOUSEMOVE` و`WM_SETCURSOR` و`WM_NCHITTEST`: كم رسالة جاءت من حركة واحدة؟
2. غط نصف النافذة بنافذة أخرى ثم اكشفه، وانظر هل زاد رقم `WM_PAINT` في النافذة نفسها.
3. عدل `WM_TIMER` لتشغل خيطاً بـ `CreateThread` ينام 12 ثانية ثم يرسل رسالة `WM_APP` بـ `PostMessage`، وغير العنوان عند وصولها، ثم شغل `--hang 12` وتأكد أن `IsHungAppWindow` بقيت `False`.
4. أضف معالجة `WM_DPICHANGED` إلى `firstwin-dpi.exe --scale`، واسحب النافذة بين شاشتين بدقتين مختلفتين إذا كان لديك.

## حذف المختبر Cleanup

السكربت يغلق كل نافذة يفتحها، وينهي النسخة التي لا تخرج في تجربة `--no-quit`، ويحذف مجلد التشغيل المؤقت، ولم يكتب المختبر شيئاً في السجل Registry. وهذا آخر سطر في المخرج:

```text
firstwin processes still running: 0   lab folder left: False
```

والصور `shot-*.png` تبقى في مجلد `lab` بجانب السكربت، فاحذفها إذا لم تحتجها.

## الخلاصة Summary

- برنامج النوافذ صنف تسجله، ونافذة تنشئها منه، وحلقة تسحب الرسائل وتسلمها لدالة النافذة، وكل ما لا تعالجه الدالة يذهب إلى `DefWindowProcW`.
- دالة النافذة تستدعى قبل أن تبدأ الحلقة، ومن عمليات أخرى، فلا تفترض أن كل رسالة مرت على الطابور.
- ارسم في `WM_PAINT` فقط، بين `BeginPaint` و`EndPaint`، واحذف كل كائن GDI تنشئه.
- `WS_EX_LAYOUTRTL` تعكس النافذة وأبناءها وسياق الرسم، فارسم فيها بالأعلام الإنجليزية نفسها.
- خمس ثوان دون قراءة الطابور تكفي ليعلن Windows أن برنامجك معلق ويضع مكانه نافذة Ghost، فأخرج العمل الطويل من خيط الواجهة.
- أعلن `PerMonitorV2` في ملف البيان واضرب أحجامك في الدقة الحقيقية، وإلا رأيت نافذة ضبابية أو نافذة صغيرة.

وفي المقال القادم بإذن الله نترك النوافذ وننتقل إلى العمليات والخيوط والملفات: كيف ينشئ برنامجك برنامجاً آخر بـ `CreateProcess` ويقرأ مخرجه، وكيف تعمل المقابض الموروثة، ولماذا يحتاج كل برنامج نوافذ إلى خيط عامل واحد على الأقل.

## سجل التحديثات Changelog

- نوفمبر 2026: كتابة المقال، وتشغيل المختبر على Windows 11 Pro 24H2 (البناء 26100.9711) بشاشة 150% وWindows PowerShell 5.1 وصلاحيات مستخدم عادي، والبرنامج مبني بـ MinGW-w64 GCC 14.2.0 في Container من alpine:3.22.