?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Removed @PROGEXT@ (it was broken anyway).
[wine.git] / windows / nonclient.c
blob8a7b6c53001952c2e14bef8b50dae7dc1fa96b39
1 /*
2 * Non-client area window functions
3 *
4 * Copyright 1994 Alexandre Julliard
5 *
6 */
7
8 #include "windef.h"
9 #include "wingdi.h"
10 #include "wine/winuser16.h"
11 #include "version.h"
12 #include "win.h"
13 #include "message.h"
14 #include "user.h"
15 #include "heap.h"
16 #include "dce.h"
17 #include "cursoricon.h"
18 #include "dialog.h"
19 #include "menu.h"
20 #include "winpos.h"
21 #include "hook.h"
22 #include "scroll.h"
23 #include "nonclient.h"
24 #include "queue.h"
25 #include "selectors.h"
26 #include "tweak.h"
27 #include "debugtools.h"
28 #include "options.h"
29 #include "shellapi.h"
30 #include "cache.h"
31 #include "bitmap.h"
32
33 DEFAULT_DEBUG_CHANNEL(nonclient)
34 DECLARE_DEBUG_CHANNEL(shell)
35
36 BOOL NC_DrawGrayButton(HDC hdc, int x, int y);
37
38 static HBITMAP16 hbitmapClose = 0;
39 static HBITMAP16 hbitmapCloseD = 0;
40 static HBITMAP16 hbitmapMinimize = 0;
41 static HBITMAP16 hbitmapMinimizeD = 0;
42 static HBITMAP16 hbitmapMaximize = 0;
43 static HBITMAP16 hbitmapMaximizeD = 0;
44 static HBITMAP16 hbitmapRestore = 0;
45 static HBITMAP16 hbitmapRestoreD = 0;
46
47 BYTE lpGrayMask[] = { 0xAA, 0xA0,
48 0x55, 0x50,
49 0xAA, 0xA0,
50 0x55, 0x50,
51 0xAA, 0xA0,
52 0x55, 0x50,
53 0xAA, 0xA0,
54 0x55, 0x50,
55 0xAA, 0xA0,
56 0x55, 0x50};
57
58 #define SC_ABOUTWINE (SC_SCREENSAVE+1)
59 #define SC_PUTMARK (SC_SCREENSAVE+2)
60
61 /* Some useful macros */
62 #define HAS_DLGFRAME(style,exStyle) \
63 (((exStyle) & WS_EX_DLGMODALFRAME) || \
64 (((style) & WS_DLGFRAME) && !((style) & WS_THICKFRAME)))
65
66 #define HAS_THICKFRAME(style,exStyle) \
67 (((style) & WS_THICKFRAME) && \
68 !(((style) & (WS_DLGFRAME|WS_BORDER)) == WS_DLGFRAME))
69
70 #define HAS_THINFRAME(style) \
71 (((style) & WS_BORDER) || !((style) & (WS_CHILD | WS_POPUP)))
72
73 #define HAS_BIGFRAME(style,exStyle) \
74 (((style) & (WS_THICKFRAME | WS_DLGFRAME)) || \
75 ((exStyle) & WS_EX_DLGMODALFRAME))
76
77 #define HAS_ANYFRAME(style,exStyle) \
78 (((style) & (WS_THICKFRAME | WS_DLGFRAME | WS_BORDER)) || \
79 ((exStyle) & WS_EX_DLGMODALFRAME) || \
80 !((style) & (WS_CHILD | WS_POPUP)))
81
82 #define HAS_MENU(w) (!((w)->dwStyle & WS_CHILD) && ((w)->wIDmenu != 0))
83
84 #define ON_LEFT_BORDER(hit) \
85 (((hit) == HTLEFT) || ((hit) == HTTOPLEFT) || ((hit) == HTBOTTOMLEFT))
86 #define ON_RIGHT_BORDER(hit) \
87 (((hit) == HTRIGHT) || ((hit) == HTTOPRIGHT) || ((hit) == HTBOTTOMRIGHT))
88 #define ON_TOP_BORDER(hit) \
89 (((hit) == HTTOP) || ((hit) == HTTOPLEFT) || ((hit) == HTTOPRIGHT))
90 #define ON_BOTTOM_BORDER(hit) \
91 (((hit) == HTBOTTOM) || ((hit) == HTBOTTOMLEFT) || ((hit) == HTBOTTOMRIGHT))
92
93 /***********************************************************************
94 * WIN_WindowNeedsWMBorder
95 *
96 * This method defines the rules for a window to have a WM border,
97 * caption... It is used for consitency purposes.
98 */
99 BOOL WIN_WindowNeedsWMBorder( DWORD style, DWORD exStyle )
100 {
101 if (!(style & WS_CHILD) &&
102 Options.managed &&
103 !(exStyle & WS_EX_TOOLWINDOW) &&
104 ( ((style & WS_CAPTION) == WS_CAPTION) ||
105 (style & WS_THICKFRAME)))
106 return TRUE;
107 if (exStyle & WS_EX_TRAYWINDOW)
108 return TRUE;
109 return FALSE;
110 }
111
112 /***********************************************************************
113 * NC_AdjustRect
114 *
115 * Compute the size of the window rectangle from the size of the
116 * client rectangle.
117 */
118 static void NC_AdjustRect( LPRECT16 rect, DWORD style, BOOL menu,
119 DWORD exStyle )
120 {
121 if (TWEAK_WineLook > WIN31_LOOK)
122 ERR("Called in Win95 mode. Aiee! Please report this.\n" );
123
124 if(style & WS_ICONIC) return;
125 /* Decide if the window will be managed (see CreateWindowEx) */
126 if (!WIN_WindowNeedsWMBorder(style, exStyle))
127 {
128 if (HAS_THICKFRAME( style, exStyle ))
129 InflateRect16( rect, GetSystemMetrics(SM_CXFRAME), GetSystemMetrics(SM_CYFRAME) );
130 else
131 if (HAS_DLGFRAME( style, exStyle ))
132 InflateRect16( rect, GetSystemMetrics(SM_CXDLGFRAME), GetSystemMetrics(SM_CYDLGFRAME) );
133 else
134 if (HAS_THINFRAME( style ))
135 InflateRect16( rect, GetSystemMetrics(SM_CXBORDER), GetSystemMetrics(SM_CYBORDER));
136
137 if ((style & WS_CAPTION) == WS_CAPTION)
138 rect->top -= GetSystemMetrics(SM_CYCAPTION) - GetSystemMetrics(SM_CYBORDER);
139 }
140 if (menu) rect->top -= GetSystemMetrics(SM_CYMENU) + GetSystemMetrics(SM_CYBORDER);
141
142 if (style & WS_VSCROLL) {
143 rect->right += GetSystemMetrics(SM_CXVSCROLL) - 1;
144 if(!HAS_ANYFRAME( style, exStyle ))
145 rect->right++;
146 }
147
148 if (style & WS_HSCROLL) {
149 rect->bottom += GetSystemMetrics(SM_CYHSCROLL) - 1;
150 if(!HAS_ANYFRAME( style, exStyle ))
151 rect->bottom++;
152 }
153 }
154
155
156 /******************************************************************************
157 * NC_AdjustRectOuter95
158 *
159 * Computes the size of the "outside" parts of the window based on the
160 * parameters of the client area.
161 *
162 + PARAMS
163 * LPRECT16 rect
164 * DWORD style
165 * BOOL menu
166 * DWORD exStyle
167 *
168 * NOTES
169 * "Outer" parts of a window means the whole window frame, caption and
170 * menu bar. It does not include "inner" parts of the frame like client
171 * edge, static edge or scroll bars.
172 *
173 * Revision history
174 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
175 * Original (NC_AdjustRect95) cut & paste from NC_AdjustRect
176 *
177 * 20-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
178 * Split NC_AdjustRect95 into NC_AdjustRectOuter95 and
179 * NC_AdjustRectInner95 and added handling of Win95 styles.
180 *
181 * 28-Jul-1999 Ove Kåven (ovek@arcticnet.no)
182 * Streamlined window style checks.
183 *
184 *****************************************************************************/
185
186 static void
187 NC_AdjustRectOuter95 (LPRECT16 rect, DWORD style, BOOL menu, DWORD exStyle)
188 {
189 if(style & WS_ICONIC) return;
190
191 /* Decide if the window will be managed (see CreateWindowEx) */
192 if (!WIN_WindowNeedsWMBorder(style, exStyle))
193 {
194 if (HAS_THICKFRAME( style, exStyle ))
195 InflateRect16( rect, GetSystemMetrics(SM_CXFRAME), GetSystemMetrics(SM_CYFRAME) );
196 else
197 if (HAS_DLGFRAME( style, exStyle ))
198 InflateRect16(rect, GetSystemMetrics(SM_CXDLGFRAME), GetSystemMetrics(SM_CYDLGFRAME) );
199 else
200 if (HAS_THINFRAME( style ))
201 InflateRect16( rect, GetSystemMetrics(SM_CXBORDER), GetSystemMetrics(SM_CYBORDER));
202
203 if ((style & WS_CAPTION) == WS_CAPTION)
204 {
205 if (exStyle & WS_EX_TOOLWINDOW)
206 rect->top -= GetSystemMetrics(SM_CYSMCAPTION);
207 else
208 rect->top -= GetSystemMetrics(SM_CYCAPTION);
209 }
210 }
211
212 if (menu)
213 rect->top -= GetSystemMetrics(SM_CYMENU);
214 }
215
216
217 /******************************************************************************
218 * NC_AdjustRectInner95
219 *
220 * Computes the size of the "inside" part of the window based on the
221 * parameters of the client area.
222 *
223 + PARAMS
224 * LPRECT16 rect
225 * DWORD style
226 * DWORD exStyle
227 *
228 * NOTES
229 * "Inner" part of a window means the window frame inside of the flat
230 * window frame. It includes the client edge, the static edge and the
231 * scroll bars.
232 *
233 * Revision history
234 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
235 * Original (NC_AdjustRect95) cut & paste from NC_AdjustRect
236 *
237 * 20-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
238 * Split NC_AdjustRect95 into NC_AdjustRectOuter95 and
239 * NC_AdjustRectInner95 and added handling of Win95 styles.
240 *
241 *****************************************************************************/
242
243 static void
244 NC_AdjustRectInner95 (LPRECT16 rect, DWORD style, DWORD exStyle)
245 {
246 if(style & WS_ICONIC) return;
247
248 if (exStyle & WS_EX_CLIENTEDGE)
249 InflateRect16 (rect, GetSystemMetrics(SM_CXEDGE), GetSystemMetrics(SM_CYEDGE));
250
251 if (exStyle & WS_EX_STATICEDGE)
252 InflateRect16 (rect, GetSystemMetrics(SM_CXBORDER), GetSystemMetrics(SM_CYBORDER));
253
254 if (style & WS_VSCROLL) rect->right += GetSystemMetrics(SM_CXVSCROLL);
255 if (style & WS_HSCROLL) rect->bottom += GetSystemMetrics(SM_CYHSCROLL);
256 }
257
258
259 /***********************************************************************
260 * DrawCaption16 [USER.660] Draws a caption bar
261 *
262 * PARAMS
263 * hwnd [I]
264 * hdc [I]
265 * lpRect [I]
266 * uFlags [I]
267 *
268 * RETURNS
269 * Success:
270 * Failure:
271 */
272
273 BOOL16 WINAPI
274 DrawCaption16 (HWND16 hwnd, HDC16 hdc, const RECT16 *rect, UINT16 uFlags)
275 {
276 RECT rect32;
277
278 if (rect)
279 CONV_RECT16TO32 (rect, &rect32);
280
281 return (BOOL16)DrawCaptionTempA (hwnd, hdc, rect ? &rect32 : NULL,
282 0, 0, NULL, uFlags & 0x1F);
283 }
284
285
286 /***********************************************************************
287 * DrawCaption [USER32.154] Draws a caption bar
288 *
289 * PARAMS
290 * hwnd [I]
291 * hdc [I]
292 * lpRect [I]
293 * uFlags [I]
294 *
295 * RETURNS
296 * Success:
297 * Failure:
298 */
299
300 BOOL WINAPI
301 DrawCaption (HWND hwnd, HDC hdc, const RECT *lpRect, UINT uFlags)
302 {
303 return DrawCaptionTempA (hwnd, hdc, lpRect, 0, 0, NULL, uFlags & 0x1F);
304 }
305
306
307 /***********************************************************************
308 * DrawCaptionTemp16 [USER.657]
309 *
310 * PARAMS
311 *
312 * RETURNS
313 * Success:
314 * Failure:
315 */
316
317 BOOL16 WINAPI
318 DrawCaptionTemp16 (HWND16 hwnd, HDC16 hdc, const RECT16 *rect, HFONT16 hFont,
319 HICON16 hIcon, LPCSTR str, UINT16 uFlags)
320 {
321 RECT rect32;
322
323 if (rect)
324 CONV_RECT16TO32(rect,&rect32);
325
326 return (BOOL16)DrawCaptionTempA (hwnd, hdc, rect?&rect32:NULL, hFont,
327 hIcon, str, uFlags & 0x1F);
328 }
329
330
331 /***********************************************************************
332 * DrawCaptionTempA [USER32.599]
333 *
334 * PARAMS
335 *
336 * RETURNS
337 * Success:
338 * Failure:
339 */
340
341 BOOL WINAPI
342 DrawCaptionTempA (HWND hwnd, HDC hdc, const RECT *rect, HFONT hFont,
343 HICON hIcon, LPCSTR str, UINT uFlags)
344 {
345 RECT rc = *rect;
346
347 TRACE("(%08x,%08x,%p,%08x,%08x,\"%s\",%08x)\n",
348 hwnd, hdc, rect, hFont, hIcon, str, uFlags);
349
350 /* drawing background */
351 if (uFlags & DC_INBUTTON) {
352 FillRect (hdc, &rc, GetSysColorBrush (COLOR_3DFACE));
353
354 if (uFlags & DC_ACTIVE) {
355 HBRUSH hbr = SelectObject (hdc, CACHE_GetPattern55AABrush ());
356 PatBlt (hdc, rc.left, rc.top,
357 rc.right-rc.left, rc.bottom-rc.top, 0xFA0089);
358 SelectObject (hdc, hbr);
359 }
360 }
361 else {
362 FillRect (hdc, &rc, GetSysColorBrush ((uFlags & DC_ACTIVE) ?
363 COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION));
364 }
365
366
367 /* drawing icon */
368 if ((uFlags & DC_ICON) && !(uFlags & DC_SMALLCAP)) {
369 POINT pt;
370
371 pt.x = rc.left + 2;
372 pt.y = (rc.bottom + rc.top - GetSystemMetrics(SM_CYSMICON)) / 2;
373
374 if (hIcon) {
375 DrawIconEx (hdc, pt.x, pt.y, hIcon, GetSystemMetrics(SM_CXSMICON),
376 GetSystemMetrics(SM_CYSMICON), 0, 0, DI_NORMAL);
377 }
378 else {
379 WND* wndPtr = WIN_FindWndPtr(hwnd);
380 HICON hAppIcon = (HICON) NC_IconForWindow(wndPtr);
381 DrawIconEx (hdc, pt.x, pt.y, hAppIcon, GetSystemMetrics(SM_CXSMICON),
382 GetSystemMetrics(SM_CYSMICON), 0, 0, DI_NORMAL);
383 WIN_ReleaseWndPtr(wndPtr);
384 }
385
386 rc.left += (rc.bottom - rc.top);
387 }
388
389 /* drawing text */
390 if (uFlags & DC_TEXT) {
391 HFONT hOldFont;
392
393 if (uFlags & DC_INBUTTON)
394 SetTextColor (hdc, GetSysColor (COLOR_BTNTEXT));
395 else if (uFlags & DC_ACTIVE)
396 SetTextColor (hdc, GetSysColor (COLOR_CAPTIONTEXT));
397 else
398 SetTextColor (hdc, GetSysColor (COLOR_INACTIVECAPTIONTEXT));
399
400 SetBkMode (hdc, TRANSPARENT);
401
402 if (hFont)
403 hOldFont = SelectObject (hdc, hFont);
404 else {
405 NONCLIENTMETRICSA nclm;
406 HFONT hNewFont;
407 nclm.cbSize = sizeof(NONCLIENTMETRICSA);
408 SystemParametersInfoA (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0);
409 hNewFont = CreateFontIndirectA ((uFlags & DC_SMALLCAP) ?
410 &nclm.lfSmCaptionFont : &nclm.lfCaptionFont);
411 hOldFont = SelectObject (hdc, hNewFont);
412 }
413
414 if (str)
415 DrawTextA (hdc, str, -1, &rc,
416 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT);
417 else {
418 CHAR szText[128];
419 INT nLen;
420 nLen = GetWindowTextA (hwnd, szText, 128);
421 DrawTextA (hdc, szText, nLen, &rc,
422 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT);
423 }
424
425 if (hFont)
426 SelectObject (hdc, hOldFont);
427 else
428 DeleteObject (SelectObject (hdc, hOldFont));
429 }
430
431 /* drawing focus ??? */
432 if (uFlags & 0x2000)
433 FIXME("undocumented flag (0x2000)!\n");
434
435 return 0;
436 }
437
438
439 /***********************************************************************
440 * DrawCaptionTempW [USER32.602]
441 *
442 * PARAMS
443 *
444 * RETURNS
445 * Success:
446 * Failure:
447 */
448
449 BOOL WINAPI
450 DrawCaptionTempW (HWND hwnd, HDC hdc, const RECT *rect, HFONT hFont,
451 HICON hIcon, LPCWSTR str, UINT uFlags)
452 {
453 LPSTR p = HEAP_strdupWtoA (GetProcessHeap (), 0, str);
454 BOOL res = DrawCaptionTempA (hwnd, hdc, rect, hFont, hIcon, p, uFlags);
455 HeapFree (GetProcessHeap (), 0, p);
456 return res;
457 }
458
459
460 /***********************************************************************
461 * AdjustWindowRect16 (USER.102)
462 */
463 BOOL16 WINAPI AdjustWindowRect16( LPRECT16 rect, DWORD style, BOOL16 menu )
464 {
465 return AdjustWindowRectEx16( rect, style, menu, 0 );
466 }
467
468
469 /***********************************************************************
470 * AdjustWindowRect (USER32.2)
471 */
472 BOOL WINAPI AdjustWindowRect( LPRECT rect, DWORD style, BOOL menu )
473 {
474 return AdjustWindowRectEx( rect, style, menu, 0 );
475 }
476
477
478 /***********************************************************************
479 * AdjustWindowRectEx16 (USER.454)
480 */
481 BOOL16 WINAPI AdjustWindowRectEx16( LPRECT16 rect, DWORD style,
482 BOOL16 menu, DWORD exStyle )
483 {
484 /* Correct the window style */
485
486 if (!(style & (WS_POPUP | WS_CHILD))) /* Overlapped window */
487 style |= WS_CAPTION;
488 style &= (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME | WS_CHILD);
489 exStyle &= (WS_EX_DLGMODALFRAME | WS_EX_CLIENTEDGE |
490 WS_EX_STATICEDGE | WS_EX_TOOLWINDOW);
491 if (exStyle & WS_EX_DLGMODALFRAME) style &= ~WS_THICKFRAME;
492
493 TRACE("(%d,%d)-(%d,%d) %08lx %d %08lx\n",
494 rect->left, rect->top, rect->right, rect->bottom,
495 style, menu, exStyle );
496
497 if (TWEAK_WineLook == WIN31_LOOK)
498 NC_AdjustRect( rect, style, menu, exStyle );
499 else {
500 NC_AdjustRectOuter95( rect, style, menu, exStyle );
501 NC_AdjustRectInner95( rect, style, exStyle );
502 }
503
504 return TRUE;
505 }
506
507
508 /***********************************************************************
509 * AdjustWindowRectEx (USER32.3)
510 */
511 BOOL WINAPI AdjustWindowRectEx( LPRECT rect, DWORD style,
512 BOOL menu, DWORD exStyle )
513 {
514 RECT16 rect16;
515 BOOL ret;
516
517 CONV_RECT32TO16( rect, &rect16 );
518 ret = AdjustWindowRectEx16( &rect16, style, (BOOL16)menu, exStyle );
519 CONV_RECT16TO32( &rect16, rect );
520 return ret;
521 }
522
523
524 /***********************************************************************
525 * NC_HandleNCCalcSize
526 *
527 * Handle a WM_NCCALCSIZE message. Called from DefWindowProc().
528 */
529 LONG NC_HandleNCCalcSize( WND *pWnd, RECT *winRect )
530 {
531 RECT16 tmpRect = { 0, 0, 0, 0 };
532 LONG result = 0;
533 UINT style = (UINT) GetClassLongA(pWnd->hwndSelf, GCL_STYLE);
534
535 if (style & CS_VREDRAW) result |= WVR_VREDRAW;
536 if (style & CS_HREDRAW) result |= WVR_HREDRAW;
537
538 if( !( pWnd->dwStyle & WS_MINIMIZE ) ) {
539 if (TWEAK_WineLook == WIN31_LOOK)
540 NC_AdjustRect( &tmpRect, pWnd->dwStyle, FALSE, pWnd->dwExStyle );
541 else
542 NC_AdjustRectOuter95( &tmpRect, pWnd->dwStyle, FALSE, pWnd->dwExStyle );
543
544 winRect->left -= tmpRect.left;
545 winRect->top -= tmpRect.top;
546 winRect->right -= tmpRect.right;
547 winRect->bottom -= tmpRect.bottom;
548
549 if (HAS_MENU(pWnd)) {
550 TRACE("Calling GetMenuBarHeight with HWND 0x%x, width %d, "
551 "at (%d, %d).\n", pWnd->hwndSelf,
552 winRect->right - winRect->left,
553 -tmpRect.left, -tmpRect.top );
554
555 winRect->top +=
556 MENU_GetMenuBarHeight( pWnd->hwndSelf,
557 winRect->right - winRect->left,
558 -tmpRect.left, -tmpRect.top ) + 1;
559 }
560
561 if (TWEAK_WineLook > WIN31_LOOK) {
562 SetRect16 (&tmpRect, 0, 0, 0, 0);
563 NC_AdjustRectInner95 (&tmpRect, pWnd->dwStyle, pWnd->dwExStyle);
564 winRect->left -= tmpRect.left;
565 winRect->top -= tmpRect.top;
566 winRect->right -= tmpRect.right;
567 winRect->bottom -= tmpRect.bottom;
568 }
569 }
570 return result;
571 }
572
573
574 /***********************************************************************
575 * NC_GetInsideRect
576 *
577 * Get the 'inside' rectangle of a window, i.e. the whole window rectangle
578 * but without the borders (if any).
579 * The rectangle is in window coordinates (for drawing with GetWindowDC()).
580 */
581 static void NC_GetInsideRect( HWND hwnd, RECT *rect )
582 {
583 WND * wndPtr = WIN_FindWndPtr( hwnd );
584
585 rect->top = rect->left = 0;
586 rect->right = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
587 rect->bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
588
589 if ((wndPtr->dwStyle & WS_ICONIC) || (wndPtr->flags & WIN_MANAGED)) goto END;
590
591 /* Remove frame from rectangle */
592 if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
593 InflateRect( rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
594 else
595 if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
596 {
597 InflateRect( rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
598 /* FIXME: this isn't in NC_AdjustRect? why not? */
599 if (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME)
600 InflateRect( rect, -1, 0 );
601 }
602 else
603 if (HAS_THINFRAME( wndPtr->dwStyle ))
604 InflateRect( rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER) );
605 END:
606 WIN_ReleaseWndPtr(wndPtr);
607 return;
608 }
609
610
611 /***********************************************************************
612 * NC_GetInsideRect95
613 *
614 * Get the 'inside' rectangle of a window, i.e. the whole window rectangle
615 * but without the borders (if any).
616 * The rectangle is in window coordinates (for drawing with GetWindowDC()).
617 */
618
619 static void
620 NC_GetInsideRect95 (HWND hwnd, RECT *rect)
621 {
622 WND * wndPtr = WIN_FindWndPtr( hwnd );
623
624 rect->top = rect->left = 0;
625 rect->right = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
626 rect->bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
627
628 if ((wndPtr->dwStyle & WS_ICONIC) || (wndPtr->flags & WIN_MANAGED)) goto END;
629
630 /* Remove frame from rectangle */
631 if (HAS_THICKFRAME (wndPtr->dwStyle, wndPtr->dwExStyle))
632 {
633 InflateRect( rect, -GetSystemMetrics(SM_CXSIZEFRAME), -GetSystemMetrics(SM_CYSIZEFRAME) );
634 }
635 else if (HAS_DLGFRAME (wndPtr->dwStyle, wndPtr->dwExStyle ))
636 {
637 InflateRect( rect, -GetSystemMetrics(SM_CXFIXEDFRAME), -GetSystemMetrics(SM_CYFIXEDFRAME));
638 }
639 else if (HAS_THINFRAME (wndPtr->dwStyle))
640 {
641 InflateRect( rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER) );
642 }
643
644 /* We have additional border information if the window
645 * is a child (but not an MDI child) */
646 if ( (wndPtr->dwStyle & WS_CHILD) &&
647 ( (wndPtr->dwExStyle & WS_EX_MDICHILD) == 0 ) )
648 {
649 if (wndPtr->dwExStyle & WS_EX_CLIENTEDGE)
650 InflateRect (rect, -GetSystemMetrics(SM_CXEDGE), -GetSystemMetrics(SM_CYEDGE));
651
652 if (wndPtr->dwExStyle & WS_EX_STATICEDGE)
653 InflateRect (rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
654 }
655 END:
656 WIN_ReleaseWndPtr(wndPtr);
657 return;
658 }
659
660
661 /***********************************************************************
662 * NC_DoNCHitTest
663 *
664 * Handle a WM_NCHITTEST message. Called from NC_HandleNcHitTest().
665 */
666
667 static LONG NC_DoNCHitTest (WND *wndPtr, POINT16 pt )
668 {
669 RECT16 rect;
670
671 TRACE("hwnd=%04x pt=%d,%d\n", wndPtr->hwndSelf, pt.x, pt.y );
672
673 GetWindowRect16 (wndPtr->hwndSelf, &rect );
674 if (!PtInRect16( &rect, pt )) return HTNOWHERE;
675
676 if (wndPtr->dwStyle & WS_MINIMIZE) return HTCAPTION;
677
678 if (!(wndPtr->flags & WIN_MANAGED))
679 {
680 /* Check borders */
681 if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
682 {
683 InflateRect16( &rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
684 if (!PtInRect16( &rect, pt ))
685 {
686 /* Check top sizing border */
687 if (pt.y < rect.top)
688 {
689 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTTOPLEFT;
690 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTTOPRIGHT;
691 return HTTOP;
692 }
693 /* Check bottom sizing border */
694 if (pt.y >= rect.bottom)
695 {
696 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMLEFT;
697 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMRIGHT;
698 return HTBOTTOM;
699 }
700 /* Check left sizing border */
701 if (pt.x < rect.left)
702 {
703 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPLEFT;
704 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMLEFT;
705 return HTLEFT;
706 }
707 /* Check right sizing border */
708 if (pt.x >= rect.right)
709 {
710 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPRIGHT;
711 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMRIGHT;
712 return HTRIGHT;
713 }
714 }
715 }
716 else /* No thick frame */
717 {
718 if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
719 InflateRect16(&rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
720 else if (HAS_THINFRAME( wndPtr->dwStyle ))
721 InflateRect16(&rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
722 if (!PtInRect16( &rect, pt )) return HTBORDER;
723 }
724
725 /* Check caption */
726
727 if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
728 {
729 rect.top += GetSystemMetrics(SM_CYCAPTION) - GetSystemMetrics(SM_CYBORDER);
730 if (!PtInRect16( &rect, pt ))
731 {
732 /* Check system menu */
733 if (wndPtr->dwStyle & WS_SYSMENU)
734 rect.left += GetSystemMetrics(SM_CXSIZE);
735 if (pt.x <= rect.left) return HTSYSMENU;
736
737 /* Check maximize box */
738 if (wndPtr->dwStyle & WS_MAXIMIZEBOX)
739 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
740
741 if (pt.x >= rect.right) return HTMAXBUTTON;
742 /* Check minimize box */
743 if (wndPtr->dwStyle & WS_MINIMIZEBOX)
744 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
745 if (pt.x >= rect.right) return HTMINBUTTON;
746 return HTCAPTION;
747 }
748 }
749 }
750
751 /* Check client area */
752
753 ScreenToClient16( wndPtr->hwndSelf, &pt );
754 GetClientRect16( wndPtr->hwndSelf, &rect );
755 if (PtInRect16( &rect, pt )) return HTCLIENT;
756
757 /* Check vertical scroll bar */
758
759 if (wndPtr->dwStyle & WS_VSCROLL)
760 {
761 rect.right += GetSystemMetrics(SM_CXVSCROLL);
762 if (PtInRect16( &rect, pt )) return HTVSCROLL;
763 }
764
765 /* Check horizontal scroll bar */
766
767 if (wndPtr->dwStyle & WS_HSCROLL)
768 {
769 rect.bottom += GetSystemMetrics(SM_CYHSCROLL);
770 if (PtInRect16( &rect, pt ))
771 {
772 /* Check size box */
773 if ((wndPtr->dwStyle & WS_VSCROLL) &&
774 (pt.x >= rect.right - GetSystemMetrics(SM_CXVSCROLL)))
775 return HTSIZE;
776 return HTHSCROLL;
777 }
778 }
779
780 /* Check menu bar */
781
782 if (HAS_MENU(wndPtr))
783 {
784 if ((pt.y < 0) && (pt.x >= 0) && (pt.x < rect.right))
785 return HTMENU;
786 }
787
788 /* Should never get here */
789 return HTERROR;
790 }
791
792
793 /***********************************************************************
794 * NC_DoNCHitTest95
795 *
796 * Handle a WM_NCHITTEST message. Called from NC_HandleNCHitTest().
797 *
798 * FIXME: Just a modified copy of the Win 3.1 version.
799 */
800
801 static LONG
802 NC_DoNCHitTest95 (WND *wndPtr, POINT16 pt )
803 {
804 RECT16 rect;
805
806 TRACE("hwnd=%04x pt=%d,%d\n", wndPtr->hwndSelf, pt.x, pt.y );
807
808 GetWindowRect16 (wndPtr->hwndSelf, &rect );
809 if (!PtInRect16( &rect, pt )) return HTNOWHERE;
810
811 if (wndPtr->dwStyle & WS_MINIMIZE) return HTCAPTION;
812
813 if (!(wndPtr->flags & WIN_MANAGED))
814 {
815 /* Check borders */
816 if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
817 {
818 InflateRect16( &rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
819 if (!PtInRect16( &rect, pt ))
820 {
821 /* Check top sizing border */
822 if (pt.y < rect.top)
823 {
824 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTTOPLEFT;
825 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTTOPRIGHT;
826 return HTTOP;
827 }
828 /* Check bottom sizing border */
829 if (pt.y >= rect.bottom)
830 {
831 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMLEFT;
832 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMRIGHT;
833 return HTBOTTOM;
834 }
835 /* Check left sizing border */
836 if (pt.x < rect.left)
837 {
838 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPLEFT;
839 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMLEFT;
840 return HTLEFT;
841 }
842 /* Check right sizing border */
843 if (pt.x >= rect.right)
844 {
845 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPRIGHT;
846 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMRIGHT;
847 return HTRIGHT;
848 }
849 }
850 }
851 else /* No thick frame */
852 {
853 if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
854 InflateRect16(&rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
855 else if (HAS_THINFRAME( wndPtr->dwStyle ))
856 InflateRect16(&rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
857 if (!PtInRect16( &rect, pt )) return HTBORDER;
858 }
859
860 /* Check caption */
861
862 if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
863 {
864 if (wndPtr->dwExStyle & WS_EX_TOOLWINDOW)
865 rect.top += GetSystemMetrics(SM_CYSMCAPTION) - 1;
866 else
867 rect.top += GetSystemMetrics(SM_CYCAPTION) - 1;
868 if (!PtInRect16( &rect, pt ))
869 {
870 /* Check system menu */
871 if(wndPtr->dwStyle & WS_SYSMENU)
872 {
873 if (NC_IconForWindow(wndPtr))
874 rect.left += GetSystemMetrics(SM_CYCAPTION) - 1;
875 }
876 if (pt.x < rect.left) return HTSYSMENU;
877
878 /* Check close button */
879 if (wndPtr->dwStyle & WS_SYSMENU)
880 rect.right -= GetSystemMetrics(SM_CYCAPTION) - 1;
881 if (pt.x > rect.right) return HTCLOSE;
882
883 /* Check maximize box */
884 /* In win95 there is automatically a Maximize button when there is a minimize one*/
885 if ((wndPtr->dwStyle & WS_MAXIMIZEBOX)|| (wndPtr->dwStyle & WS_MINIMIZEBOX))
886 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
887 if (pt.x > rect.right) return HTMAXBUTTON;
888
889 /* Check minimize box */
890 /* In win95 there is automatically a Maximize button when there is a Maximize one*/
891 if ((wndPtr->dwStyle & WS_MINIMIZEBOX)||(wndPtr->dwStyle & WS_MAXIMIZEBOX))
892 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
893
894 if (pt.x > rect.right) return HTMINBUTTON;
895 return HTCAPTION;
896 }
897 }
898 }
899
900 /* Check client area */
901
902 ScreenToClient16( wndPtr->hwndSelf, &pt );
903 GetClientRect16( wndPtr->hwndSelf, &rect );
904 if (PtInRect16( &rect, pt )) return HTCLIENT;
905
906 /* Check vertical scroll bar */
907
908 if (wndPtr->dwStyle & WS_VSCROLL)
909 {
910 rect.right += GetSystemMetrics(SM_CXVSCROLL);
911 if (PtInRect16( &rect, pt )) return HTVSCROLL;
912 }
913
914 /* Check horizontal scroll bar */
915
916 if (wndPtr->dwStyle & WS_HSCROLL)
917 {
918 rect.bottom += GetSystemMetrics(SM_CYHSCROLL);
919 if (PtInRect16( &rect, pt ))
920 {
921 /* Check size box */
922 if ((wndPtr->dwStyle & WS_VSCROLL) &&
923 (pt.x >= rect.right - GetSystemMetrics(SM_CXVSCROLL)))
924 return HTSIZE;
925 return HTHSCROLL;
926 }
927 }
928
929 /* Check menu bar */
930
931 if (HAS_MENU(wndPtr))
932 {
933 if ((pt.y < 0) && (pt.x >= 0) && (pt.x < rect.right))
934 return HTMENU;
935 }
936
937 /* Should never get here */
938 return HTERROR;
939 }
940
941
942 /***********************************************************************
943 * NC_HandleNCHitTest
944 *
945 * Handle a WM_NCHITTEST message. Called from DefWindowProc().
946 */
947 LONG
948 NC_HandleNCHitTest (HWND hwnd , POINT16 pt)
949 {
950 LONG retvalue;
951 WND *wndPtr = WIN_FindWndPtr (hwnd);
952
953 if (!wndPtr)
954 return HTERROR;
955
956 if (TWEAK_WineLook == WIN31_LOOK)
957 retvalue = NC_DoNCHitTest (wndPtr, pt);
958 else
959 retvalue = NC_DoNCHitTest95 (wndPtr, pt);
960 WIN_ReleaseWndPtr(wndPtr);
961 return retvalue;
962 }
963
964
965 /***********************************************************************
966 * NC_DrawSysButton
967 */
968 void NC_DrawSysButton( HWND hwnd, HDC hdc, BOOL down )
969 {
970 RECT rect;
971 HDC hdcMem;
972 HBITMAP hbitmap;
973 WND *wndPtr = WIN_FindWndPtr( hwnd );
974
975 if( !(wndPtr->flags & WIN_MANAGED) )
976 {
977 NC_GetInsideRect( hwnd, &rect );
978 hdcMem = CreateCompatibleDC( hdc );
979 hbitmap = SelectObject( hdcMem, hbitmapClose );
980 BitBlt(hdc, rect.left, rect.top, GetSystemMetrics(SM_CXSIZE), GetSystemMetrics(SM_CYSIZE),
981 hdcMem, (wndPtr->dwStyle & WS_CHILD) ? GetSystemMetrics(SM_CXSIZE) : 0, 0,
982 down ? NOTSRCCOPY : SRCCOPY );
983 SelectObject( hdcMem, hbitmap );
984 DeleteDC( hdcMem );
985 }
986 WIN_ReleaseWndPtr(wndPtr);
987 }
988
989
990 /***********************************************************************
991 * NC_DrawMaxButton
992 */
993 static void NC_DrawMaxButton( HWND hwnd, HDC16 hdc, BOOL down )
994 {
995 RECT rect;
996 WND *wndPtr = WIN_FindWndPtr( hwnd );
997 HDC hdcMem;
998
999 if( !(wndPtr->flags & WIN_MANAGED) )
1000 {
1001 NC_GetInsideRect( hwnd, &rect );
1002 hdcMem = CreateCompatibleDC( hdc );
1003 SelectObject( hdcMem, (IsZoomed(hwnd)
1004 ? (down ? hbitmapRestoreD : hbitmapRestore)
1005 : (down ? hbitmapMaximizeD : hbitmapMaximize)) );
1006 BitBlt( hdc, rect.right - GetSystemMetrics(SM_CXSIZE) - 1, rect.top,
1007 GetSystemMetrics(SM_CXSIZE) + 1, GetSystemMetrics(SM_CYSIZE), hdcMem, 0, 0,
1008 SRCCOPY );
1009 DeleteDC( hdcMem );
1010 }
1011 WIN_ReleaseWndPtr(wndPtr);
1012
1013 }
1014
1015
1016 /***********************************************************************
1017 * NC_DrawMinButton
1018 */
1019 static void NC_DrawMinButton( HWND hwnd, HDC16 hdc, BOOL down )
1020 {
1021 RECT rect;
1022 WND *wndPtr = WIN_FindWndPtr( hwnd );
1023 HDC hdcMem;
1024
1025 if( !(wndPtr->flags & WIN_MANAGED) )
1026 {
1027 NC_GetInsideRect( hwnd, &rect );
1028 hdcMem = CreateCompatibleDC( hdc );
1029 SelectObject( hdcMem, (down ? hbitmapMinimizeD : hbitmapMinimize) );
1030 if (wndPtr->dwStyle & WS_MAXIMIZEBOX) rect.right -= GetSystemMetrics(SM_CXSIZE)+1;
1031 BitBlt( hdc, rect.right - GetSystemMetrics(SM_CXSIZE) - 1, rect.top,
1032 GetSystemMetrics(SM_CXSIZE) + 1, GetSystemMetrics(SM_CYSIZE), hdcMem, 0, 0,
1033 SRCCOPY );
1034 DeleteDC( hdcMem );
1035 }
1036 WIN_ReleaseWndPtr(wndPtr);
1037 }
1038
1039
1040 /******************************************************************************
1041 *
1042 * void NC_DrawSysButton95(
1043 * HWND hwnd,
1044 * HDC hdc,
1045 * BOOL down )
1046 *
1047 * Draws the Win95 system icon.
1048 *
1049 * Revision history
1050 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1051 * Original implementation from NC_DrawSysButton source.
1052 * 11-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1053 * Fixed most bugs.
1054 *
1055 *****************************************************************************/
1056
1057 BOOL
1058 NC_DrawSysButton95 (HWND hwnd, HDC hdc, BOOL down)
1059 {
1060 WND *wndPtr = WIN_FindWndPtr( hwnd );
1061
1062 if( !(wndPtr->flags & WIN_MANAGED) )
1063 {
1064 HICON hIcon;
1065 RECT rect;
1066
1067 NC_GetInsideRect95( hwnd, &rect );
1068
1069 hIcon = NC_IconForWindow( wndPtr );
1070
1071 if (hIcon)
1072 DrawIconEx (hdc, rect.left + 2, rect.top + 2, hIcon,
1073 GetSystemMetrics(SM_CXSMICON),
1074 GetSystemMetrics(SM_CYSMICON),
1075 0, 0, DI_NORMAL);
1076
1077 WIN_ReleaseWndPtr(wndPtr);
1078 return (hIcon != 0);
1079 }
1080 WIN_ReleaseWndPtr(wndPtr);
1081 return FALSE;
1082 }
1083
1084
1085 /******************************************************************************
1086 *
1087 * void NC_DrawCloseButton95(
1088 * HWND hwnd,
1089 * HDC hdc,
1090 * BOOL down,
1091 * BOOL bGrayed )
1092 *
1093 * Draws the Win95 close button.
1094 *
1095 * If bGrayed is true, then draw a disabled Close button
1096 *
1097 * Revision history
1098 * 11-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1099 * Original implementation from NC_DrawSysButton95 source.
1100 *
1101 *****************************************************************************/
1102
1103 static void NC_DrawCloseButton95 (HWND hwnd, HDC hdc, BOOL down, BOOL bGrayed)
1104 {
1105 RECT rect;
1106 HDC hdcMem;
1107 WND *wndPtr = WIN_FindWndPtr( hwnd );
1108
1109 if( !(wndPtr->flags & WIN_MANAGED) )
1110 {
1111 BITMAP bmp;
1112 HBITMAP hBmp, hOldBmp;
1113
1114 NC_GetInsideRect95( hwnd, &rect );
1115
1116 /* A tool window has a smaller Close button */
1117 if(wndPtr->dwExStyle & WS_EX_TOOLWINDOW)
1118 {
1119 RECT toolRect;
1120 INT iBmpHeight = 11; /* Windows does not use SM_CXSMSIZE and SM_CYSMSIZE */
1121 INT iBmpWidth = 11; /* it uses 11x11 for the close button in tool window */
1122 INT iCaptionHeight = GetSystemMetrics(SM_CYSMCAPTION);
1123
1124 toolRect.top = rect.top + (iCaptionHeight - 1 - iBmpHeight) / 2;
1125 toolRect.left = rect.right - (iCaptionHeight + 1 + iBmpWidth) / 2;
1126 toolRect.bottom = toolRect.top + iBmpHeight;
1127 toolRect.right = toolRect.left + iBmpWidth;
1128 DrawFrameControl(hdc,&toolRect,
1129 DFC_CAPTION,DFCS_CAPTIONCLOSE |
1130 down ? DFCS_PUSHED : 0 |
1131 bGrayed ? DFCS_INACTIVE : 0);
1132 }
1133 else
1134 {
1135 hdcMem = CreateCompatibleDC( hdc );
1136 hBmp = down ? hbitmapCloseD : hbitmapClose;
1137 hOldBmp = SelectObject (hdcMem, hBmp);
1138 GetObjectA (hBmp, sizeof(BITMAP), &bmp);
1139
1140 BitBlt (hdc, rect.right - (GetSystemMetrics(SM_CYCAPTION) + 1 + bmp.bmWidth) / 2,
1141 rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2,
1142 bmp.bmWidth, bmp.bmHeight, hdcMem, 0, 0, SRCCOPY);
1143
1144 if(bGrayed)
1145 NC_DrawGrayButton(hdc,rect.right - (GetSystemMetrics(SM_CYCAPTION) + 1 + bmp.bmWidth) / 2 + 2,
1146 rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2 + 2);
1147
1148 SelectObject (hdcMem, hOldBmp);
1149 DeleteDC (hdcMem);
1150 }
1151 }
1152 WIN_ReleaseWndPtr(wndPtr);
1153 }
1154
1155 /******************************************************************************
1156 *
1157 * NC_DrawMaxButton95(
1158 * HWND hwnd,
1159 * HDC16 hdc,
1160 * BOOL down
1161 * BOOL bGrayed )
1162 *
1163 * Draws the maximize button for Win95 style windows.
1164 *
1165 * If bGrayed is true, then draw a disabled Maximize button
1166 *
1167 * Bugs
1168 * Many. Spacing might still be incorrect. Need to fit a close
1169 * button between the max button and the edge.
1170 * Should scale the image with the title bar. And more...
1171 *
1172 * Revision history
1173 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1174 * Original implementation.
1175 *
1176 *****************************************************************************/
1177
1178 static void NC_DrawMaxButton95(HWND hwnd,HDC16 hdc,BOOL down, BOOL bGrayed)
1179 {
1180 RECT rect;
1181 HDC hdcMem;
1182 WND *wndPtr = WIN_FindWndPtr( hwnd );
1183
1184 if( !(wndPtr->flags & WIN_MANAGED))
1185 {
1186 BITMAP bmp;
1187 HBITMAP hBmp,hOldBmp;
1188
1189 NC_GetInsideRect95( hwnd, &rect );
1190 hdcMem = CreateCompatibleDC( hdc );
1191 hBmp = IsZoomed(hwnd) ?
1192 (down ? hbitmapRestoreD : hbitmapRestore ) :
1193 (down ? hbitmapMaximizeD: hbitmapMaximize);
1194 hOldBmp=SelectObject( hdcMem, hBmp );
1195 GetObjectA (hBmp, sizeof(BITMAP), &bmp);
1196
1197 if (wndPtr->dwStyle & WS_SYSMENU)
1198 rect.right -= GetSystemMetrics(SM_CYCAPTION) + 1;
1199
1200 BitBlt( hdc, rect.right - (GetSystemMetrics(SM_CXSIZE) + bmp.bmWidth) / 2,
1201 rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2,
1202 bmp.bmWidth, bmp.bmHeight, hdcMem, 0, 0, SRCCOPY );
1203
1204 if(bGrayed)
1205 NC_DrawGrayButton(hdc, rect.right - (GetSystemMetrics(SM_CXSIZE) + bmp.bmWidth) / 2 + 2,
1206 rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2 + 2);
1207
1208
1209 SelectObject (hdcMem, hOldBmp);
1210 DeleteDC( hdcMem );
1211 }
1212 WIN_ReleaseWndPtr(wndPtr);
1213 }
1214
1215 /******************************************************************************
1216 *
1217 * NC_DrawMinButton95(
1218 * HWND hwnd,
1219 * HDC16 hdc,
1220 * BOOL down,
1221 * BOOL bGrayed )
1222 *
1223 * Draws the minimize button for Win95 style windows.
1224 *
1225 * If bGrayed is true, then draw a disabled Minimize button
1226 *
1227 * Bugs
1228 * Many. Spacing is still incorrect. Should scale the image with the
1229 * title bar. And more...
1230 *
1231 * Revision history
1232 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1233 * Original implementation.
1234 *
1235 *****************************************************************************/
1236
1237 static void NC_DrawMinButton95(HWND hwnd,HDC16 hdc,BOOL down, BOOL bGrayed)
1238 {
1239 RECT rect;
1240 HDC hdcMem;
1241 WND *wndPtr = WIN_FindWndPtr( hwnd );
1242
1243 if( !(wndPtr->flags & WIN_MANAGED))
1244
1245 {
1246 BITMAP bmp;
1247 HBITMAP hBmp,hOldBmp;
1248
1249 NC_GetInsideRect95( hwnd, &rect );
1250
1251 hdcMem = CreateCompatibleDC( hdc );
1252 hBmp = down ? hbitmapMinimizeD : hbitmapMinimize;
1253 hOldBmp= SelectObject( hdcMem, hBmp );
1254 GetObjectA (hBmp, sizeof(BITMAP), &bmp);
1255
1256 if (wndPtr->dwStyle & WS_SYSMENU)
1257 rect.right -= GetSystemMetrics(SM_CYCAPTION) + 1;
1258
1259 /* In win 95 there is always a Maximize box when there is a Minimize one */
1260 if ((wndPtr->dwStyle & WS_MAXIMIZEBOX) || (wndPtr->dwStyle & WS_MINIMIZEBOX))
1261 rect.right += -1 - (GetSystemMetrics(SM_CXSIZE) + bmp.bmWidth) / 2;
1262
1263 BitBlt( hdc, rect.right - (GetSystemMetrics(SM_CXSIZE) + bmp.bmWidth) / 2,
1264 rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2,
1265 bmp.bmWidth, bmp.bmHeight, hdcMem, 0, 0, SRCCOPY );
1266
1267 if(bGrayed)
1268 NC_DrawGrayButton(hdc, rect.right - (GetSystemMetrics(SM_CXSIZE) + bmp.bmWidth) / 2 + 2,
1269 rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2 + 2);
1270
1271
1272 SelectObject (hdcMem, hOldBmp);
1273 DeleteDC( hdcMem );
1274 }
1275 WIN_ReleaseWndPtr(wndPtr);
1276 }
1277
1278 /***********************************************************************
1279 * NC_DrawFrame
1280 *
1281 * Draw a window frame inside the given rectangle, and update the rectangle.
1282 * The correct pen for the frame must be selected in the DC.
1283 */
1284 static void NC_DrawFrame( HDC hdc, RECT *rect, BOOL dlgFrame,
1285 BOOL active )
1286 {
1287 INT width, height;
1288
1289 if (TWEAK_WineLook != WIN31_LOOK)
1290 ERR("Called in Win95 mode. Aiee! Please report this.\n" );
1291
1292 if (dlgFrame)
1293 {
1294 width = GetSystemMetrics(SM_CXDLGFRAME) - 1;
1295 height = GetSystemMetrics(SM_CYDLGFRAME) - 1;
1296 SelectObject( hdc, GetSysColorBrush(active ? COLOR_ACTIVECAPTION :
1297 COLOR_INACTIVECAPTION) );
1298 }
1299 else
1300 {
1301 width = GetSystemMetrics(SM_CXFRAME) - 2;
1302 height = GetSystemMetrics(SM_CYFRAME) - 2;
1303 SelectObject( hdc, GetSysColorBrush(active ? COLOR_ACTIVEBORDER :
1304 COLOR_INACTIVEBORDER) );
1305 }
1306
1307 /* Draw frame */
1308 PatBlt( hdc, rect->left, rect->top,
1309 rect->right - rect->left, height, PATCOPY );
1310 PatBlt( hdc, rect->left, rect->top,
1311 width, rect->bottom - rect->top, PATCOPY );
1312 PatBlt( hdc, rect->left, rect->bottom - 1,
1313 rect->right - rect->left, -height, PATCOPY );
1314 PatBlt( hdc, rect->right - 1, rect->top,
1315 -width, rect->bottom - rect->top, PATCOPY );
1316
1317 if (dlgFrame)
1318 {
1319 InflateRect( rect, -width, -height );
1320 }
1321 else
1322 {
1323 INT decYOff = GetSystemMetrics(SM_CXFRAME) + GetSystemMetrics(SM_CXSIZE) - 1;
1324 INT decXOff = GetSystemMetrics(SM_CYFRAME) + GetSystemMetrics(SM_CYSIZE) - 1;
1325
1326 /* Draw inner rectangle */
1327
1328 SelectObject( hdc, GetStockObject(NULL_BRUSH) );
1329 Rectangle( hdc, rect->left + width, rect->top + height,
1330 rect->right - width , rect->bottom - height );
1331
1332 /* Draw the decorations */
1333
1334 MoveToEx( hdc, rect->left, rect->top + decYOff, NULL );
1335 LineTo( hdc, rect->left + width, rect->top + decYOff );
1336 MoveToEx( hdc, rect->right - 1, rect->top + decYOff, NULL );
1337 LineTo( hdc, rect->right - width - 1, rect->top + decYOff );
1338 MoveToEx( hdc, rect->left, rect->bottom - decYOff, NULL );
1339 LineTo( hdc, rect->left + width, rect->bottom - decYOff );
1340 MoveToEx( hdc, rect->right - 1, rect->bottom - decYOff, NULL );
1341 LineTo( hdc, rect->right - width - 1, rect->bottom - decYOff );
1342
1343 MoveToEx( hdc, rect->left + decXOff, rect->top, NULL );
1344 LineTo( hdc, rect->left + decXOff, rect->top + height);
1345 MoveToEx( hdc, rect->left + decXOff, rect->bottom - 1, NULL );
1346 LineTo( hdc, rect->left + decXOff, rect->bottom - height - 1 );
1347 MoveToEx( hdc, rect->right - decXOff, rect->top, NULL );
1348 LineTo( hdc, rect->right - decXOff, rect->top + height );
1349 MoveToEx( hdc, rect->right - decXOff, rect->bottom - 1, NULL );
1350 LineTo( hdc, rect->right - decXOff, rect->bottom - height - 1 );
1351
1352 InflateRect( rect, -width - 1, -height - 1 );
1353 }
1354 }
1355
1356
1357 /******************************************************************************
1358 *
1359 * void NC_DrawFrame95(
1360 * HDC hdc,
1361 * RECT *rect,
1362 * BOOL dlgFrame,
1363 * BOOL active )
1364 *
1365 * Draw a window frame inside the given rectangle, and update the rectangle.
1366 * The correct pen for the frame must be selected in the DC.
1367 *
1368 * Bugs
1369 * Many. First, just what IS a frame in Win95? Note that the 3D look
1370 * on the outer edge is handled by NC_DoNCPaint95. As is the inner
1371 * edge. The inner rectangle just inside the frame is handled by the
1372 * Caption code.
1373 *
1374 * In short, for most people, this function should be a nop (unless
1375 * you LIKE thick borders in Win95/NT4.0 -- I've been working with
1376 * them lately, but just to get this code right). Even so, it doesn't
1377 * appear to be so. It's being worked on...
1378 *
1379 * Revision history
1380 * 06-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1381 * Original implementation (based on NC_DrawFrame)
1382 * 02-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1383 * Some minor fixes.
1384 * 29-Jun-1999 Ove Kåven (ovek@arcticnet.no)
1385 * Fixed a fix or something.
1386 *
1387 *****************************************************************************/
1388
1389 static void NC_DrawFrame95(
1390 HDC hdc,
1391 RECT *rect,
1392 BOOL dlgFrame,
1393 BOOL active )
1394 {
1395 INT width, height;
1396
1397 if (dlgFrame)
1398 {
1399 width = GetSystemMetrics(SM_CXDLGFRAME) - GetSystemMetrics(SM_CXEDGE);
1400 height = GetSystemMetrics(SM_CYDLGFRAME) - GetSystemMetrics(SM_CYEDGE);
1401 }
1402 else
1403 {
1404 width = GetSystemMetrics(SM_CXFRAME) - GetSystemMetrics(SM_CXEDGE);
1405 height = GetSystemMetrics(SM_CYFRAME) - GetSystemMetrics(SM_CYEDGE);
1406 }
1407
1408 SelectObject( hdc, GetSysColorBrush(active ? COLOR_ACTIVEBORDER :
1409 COLOR_INACTIVEBORDER) );
1410
1411 /* Draw frame */
1412 PatBlt( hdc, rect->left, rect->top,
1413 rect->right - rect->left, height, PATCOPY );
1414 PatBlt( hdc, rect->left, rect->top,
1415 width, rect->bottom - rect->top, PATCOPY );
1416 PatBlt( hdc, rect->left, rect->bottom - 1,
1417 rect->right - rect->left, -height, PATCOPY );
1418 PatBlt( hdc, rect->right - 1, rect->top,
1419 -width, rect->bottom - rect->top, PATCOPY );
1420
1421 InflateRect( rect, -width, -height );
1422 }
1423
1424 /***********************************************************************
1425 * NC_DrawMovingFrame
1426 *
1427 * Draw the frame used when moving or resizing window.
1428 *
1429 * FIXME: This causes problems in Win95 mode. (why?)
1430 */
1431 static void NC_DrawMovingFrame( HDC hdc, RECT *rect, BOOL thickframe )
1432 {
1433 if (thickframe)
1434 {
1435 RECT16 r16;
1436 CONV_RECT32TO16( rect, &r16 );
1437 FastWindowFrame16( hdc, &r16, GetSystemMetrics(SM_CXFRAME),
1438 GetSystemMetrics(SM_CYFRAME), PATINVERT );
1439 }
1440 else DrawFocusRect( hdc, rect );
1441 }
1442
1443
1444 /***********************************************************************
1445 * NC_DrawCaption
1446 *
1447 * Draw the window caption.
1448 * The correct pen for the window frame must be selected in the DC.
1449 */
1450 static void NC_DrawCaption( HDC hdc, RECT *rect, HWND hwnd,
1451 DWORD style, BOOL active )
1452 {
1453 RECT r = *rect;
1454 WND * wndPtr = WIN_FindWndPtr( hwnd );
1455 char buffer[256];
1456
1457 if (wndPtr->flags & WIN_MANAGED)
1458 {
1459 WIN_ReleaseWndPtr(wndPtr);
1460 return;
1461 }
1462
1463 if (!hbitmapClose)
1464 {
1465 if (!(hbitmapClose = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_CLOSE) )))
1466 {
1467 WIN_ReleaseWndPtr(wndPtr);
1468 return;
1469 }
1470 hbitmapCloseD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_CLOSED) );
1471 hbitmapMinimize = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_REDUCE) );
1472 hbitmapMinimizeD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_REDUCED) );
1473 hbitmapMaximize = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_ZOOM) );
1474 hbitmapMaximizeD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_ZOOMD) );
1475 hbitmapRestore = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_RESTORE) );
1476 hbitmapRestoreD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_RESTORED) );
1477 }
1478
1479 if (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME)
1480 {
1481 HBRUSH hbrushOld = SelectObject(hdc, GetSysColorBrush(COLOR_WINDOW) );
1482 PatBlt( hdc, r.left, r.top, 1, r.bottom-r.top+1,PATCOPY );
1483 PatBlt( hdc, r.right-1, r.top, 1, r.bottom-r.top+1, PATCOPY );
1484 PatBlt( hdc, r.left, r.top-1, r.right-r.left, 1, PATCOPY );
1485 r.left++;
1486 r.right--;
1487 SelectObject( hdc, hbrushOld );
1488 }
1489 WIN_ReleaseWndPtr(wndPtr);
1490 MoveTo16( hdc, r.left, r.bottom );
1491 LineTo( hdc, r.right, r.bottom );
1492
1493 if (style & WS_SYSMENU)
1494 {
1495 NC_DrawSysButton( hwnd, hdc, FALSE );
1496 r.left += GetSystemMetrics(SM_CXSIZE) + 1;
1497 MoveTo16( hdc, r.left - 1, r.top );
1498 LineTo( hdc, r.left - 1, r.bottom );
1499 }
1500 if (style & WS_MAXIMIZEBOX)
1501 {
1502 NC_DrawMaxButton( hwnd, hdc, FALSE );
1503 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1504 }
1505 if (style & WS_MINIMIZEBOX)
1506 {
1507 NC_DrawMinButton( hwnd, hdc, FALSE );
1508 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1509 }
1510
1511 FillRect( hdc, &r, GetSysColorBrush(active ? COLOR_ACTIVECAPTION :
1512 COLOR_INACTIVECAPTION) );
1513
1514 if (GetWindowTextA( hwnd, buffer, sizeof(buffer) ))
1515 {
1516 if (active) SetTextColor( hdc, GetSysColor( COLOR_CAPTIONTEXT ) );
1517 else SetTextColor( hdc, GetSysColor( COLOR_INACTIVECAPTIONTEXT ) );
1518 SetBkMode( hdc, TRANSPARENT );
1519 DrawTextA( hdc, buffer, -1, &r,
1520 DT_SINGLELINE | DT_CENTER | DT_VCENTER | DT_NOPREFIX );
1521 }
1522 }
1523
1524
1525 /******************************************************************************
1526 *
1527 * NC_DrawCaption95(
1528 * HDC hdc,
1529 * RECT *rect,
1530 * HWND hwnd,
1531 * DWORD style,
1532 * BOOL active )
1533 *
1534 * Draw the window caption for Win95 style windows.
1535 * The correct pen for the window frame must be selected in the DC.
1536 *
1537 * Bugs
1538 * Hey, a function that finally works! Well, almost.
1539 * It's being worked on.
1540 *
1541 * Revision history
1542 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1543 * Original implementation.
1544 * 02-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1545 * Some minor fixes.
1546 *
1547 *****************************************************************************/
1548
1549 static void NC_DrawCaption95(
1550 HDC hdc,
1551 RECT *rect,
1552 HWND hwnd,
1553 DWORD style,
1554 DWORD exStyle,
1555 BOOL active )
1556 {
1557 RECT r = *rect;
1558 WND *wndPtr = WIN_FindWndPtr( hwnd );
1559 char buffer[256];
1560 HPEN hPrevPen;
1561 HMENU hSysMenu;
1562
1563 if (wndPtr->flags & WIN_MANAGED)
1564 {
1565 WIN_ReleaseWndPtr(wndPtr);
1566 return;
1567 }
1568 WIN_ReleaseWndPtr(wndPtr);
1569
1570 hPrevPen = SelectObject( hdc, GetSysColorPen(COLOR_3DFACE) );
1571 MoveToEx( hdc, r.left, r.bottom - 1, NULL );
1572 LineTo( hdc, r.right, r.bottom - 1 );
1573 SelectObject( hdc, hPrevPen );
1574 r.bottom--;
1575
1576 FillRect( hdc, &r, GetSysColorBrush(active ? COLOR_ACTIVECAPTION :
1577 COLOR_INACTIVECAPTION) );
1578
1579 if (!hbitmapClose) {
1580 if (!(hbitmapClose = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_CLOSE) )))
1581 return;
1582 hbitmapCloseD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_CLOSED));
1583 hbitmapMinimize = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_REDUCE) );
1584 hbitmapMinimizeD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_REDUCED) );
1585 hbitmapMaximize = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_ZOOM) );
1586 hbitmapMaximizeD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_ZOOMD) );
1587 hbitmapRestore = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_RESTORE) );
1588 hbitmapRestoreD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_RESTORED) );
1589 }
1590
1591 if ((style & WS_SYSMENU) && !(exStyle & WS_EX_TOOLWINDOW)) {
1592 if (NC_DrawSysButton95 (hwnd, hdc, FALSE))
1593 r.left += GetSystemMetrics(SM_CYCAPTION) - 1;
1594 }
1595
1596 if (style & WS_SYSMENU)
1597 {
1598 UINT state;
1599
1600 /* Go get the sysmenu */
1601 hSysMenu = GetSystemMenu(hwnd, FALSE);
1602 state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
1603
1604 /* Draw a grayed close button if disabled and a normal one if SC_CLOSE is not there */
1605 NC_DrawCloseButton95 (hwnd, hdc, FALSE,
1606 ((((state & MF_DISABLED) || (state & MF_GRAYED))) && (state != 0xFFFFFFFF)));
1607 r.right -= GetSystemMetrics(SM_CYCAPTION) - 1;
1608
1609 if ((style & WS_MAXIMIZEBOX) || (style & WS_MINIMIZEBOX))
1610 {
1611 /* In win95 the two buttons are always there */
1612 /* But if the menu item is not in the menu they're disabled*/
1613
1614 NC_DrawMaxButton95( hwnd, hdc, FALSE, (!(style & WS_MAXIMIZEBOX)));
1615 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1616
1617 NC_DrawMinButton95( hwnd, hdc, FALSE, (!(style & WS_MINIMIZEBOX)));
1618 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1619 }
1620 }
1621
1622 if (GetWindowTextA( hwnd, buffer, sizeof(buffer) )) {
1623 NONCLIENTMETRICSA nclm;
1624 HFONT hFont, hOldFont;
1625 nclm.cbSize = sizeof(NONCLIENTMETRICSA);
1626 SystemParametersInfoA (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0);
1627 if (exStyle & WS_EX_TOOLWINDOW)
1628 hFont = CreateFontIndirectA (&nclm.lfSmCaptionFont);
1629 else
1630 hFont = CreateFontIndirectA (&nclm.lfCaptionFont);
1631 hOldFont = SelectObject (hdc, hFont);
1632 if (active) SetTextColor( hdc, GetSysColor( COLOR_CAPTIONTEXT ) );
1633 else SetTextColor( hdc, GetSysColor( COLOR_INACTIVECAPTIONTEXT ) );
1634 SetBkMode( hdc, TRANSPARENT );
1635 r.left += 2;
1636 DrawTextA( hdc, buffer, -1, &r,
1637 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT );
1638 DeleteObject (SelectObject (hdc, hOldFont));
1639 }
1640 }
1641
1642
1643
1644 /***********************************************************************
1645 * NC_DoNCPaint
1646 *
1647 * Paint the non-client area. clip is currently unused.
1648 */
1649 static void NC_DoNCPaint( WND* wndPtr, HRGN clip, BOOL suppress_menupaint )
1650 {
1651 HDC hdc;
1652 RECT rect;
1653 BOOL active;
1654 HWND hwnd = wndPtr->hwndSelf;
1655
1656 if ( wndPtr->dwStyle & WS_MINIMIZE ||
1657 !WIN_IsWindowDrawable( wndPtr, 0 )) return; /* Nothing to do */
1658
1659 active = wndPtr->flags & WIN_NCACTIVATED;
1660
1661 TRACE("%04x %d\n", hwnd, active );
1662
1663 if (!(hdc = GetDCEx( hwnd, (clip > 1) ? clip : 0, DCX_USESTYLE | DCX_WINDOW |
1664 ((clip > 1) ? (DCX_INTERSECTRGN | DCX_KEEPCLIPRGN): 0) ))) return;
1665
1666 if (ExcludeVisRect16( hdc, wndPtr->rectClient.left-wndPtr->rectWindow.left,
1667 wndPtr->rectClient.top-wndPtr->rectWindow.top,
1668 wndPtr->rectClient.right-wndPtr->rectWindow.left,
1669 wndPtr->rectClient.bottom-wndPtr->rectWindow.top )
1670 == NULLREGION)
1671 {
1672 ReleaseDC( hwnd, hdc );
1673 return;
1674 }
1675
1676 rect.top = rect.left = 0;
1677 rect.right = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
1678 rect.bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
1679
1680 SelectObject( hdc, GetSysColorPen(COLOR_WINDOWFRAME) );
1681
1682 if (!(wndPtr->flags & WIN_MANAGED))
1683 {
1684 if (HAS_ANYFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
1685 {
1686 SelectObject( hdc, GetStockObject(NULL_BRUSH) );
1687 Rectangle( hdc, 0, 0, rect.right, rect.bottom );
1688 InflateRect( &rect, -1, -1 );
1689 }
1690
1691 if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
1692 NC_DrawFrame(hdc, &rect, FALSE, active );
1693 else if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
1694 NC_DrawFrame( hdc, &rect, TRUE, active );
1695
1696 if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
1697 {
1698 RECT r = rect;
1699 r.bottom = rect.top + GetSystemMetrics(SM_CYSIZE);
1700 rect.top += GetSystemMetrics(SM_CYSIZE) + GetSystemMetrics(SM_CYBORDER);
1701 NC_DrawCaption( hdc, &r, hwnd, wndPtr->dwStyle, active );
1702 }
1703 }
1704
1705 if (HAS_MENU(wndPtr))
1706 {
1707 RECT r = rect;
1708 r.bottom = rect.top + GetSystemMetrics(SM_CYMENU); /* default height */
1709 rect.top += MENU_DrawMenuBar( hdc, &r, hwnd, suppress_menupaint );
1710 }
1711
1712 /* Draw the scroll-bars */
1713
1714 if (wndPtr->dwStyle & WS_VSCROLL)
1715 SCROLL_DrawScrollBar( hwnd, hdc, SB_VERT, TRUE, TRUE );
1716 if (wndPtr->dwStyle & WS_HSCROLL)
1717 SCROLL_DrawScrollBar( hwnd, hdc, SB_HORZ, TRUE, TRUE );
1718
1719 /* Draw the "size-box" */
1720
1721 if ((wndPtr->dwStyle & WS_VSCROLL) && (wndPtr->dwStyle & WS_HSCROLL))
1722 {
1723 RECT r = rect;
1724 r.left = r.right - GetSystemMetrics(SM_CXVSCROLL) + 1;
1725 r.top = r.bottom - GetSystemMetrics(SM_CYHSCROLL) + 1;
1726 if(wndPtr->dwStyle & WS_BORDER) {
1727 r.left++;
1728 r.top++;
1729 }
1730 FillRect( hdc, &r, GetSysColorBrush(COLOR_SCROLLBAR) );
1731 }
1732
1733 ReleaseDC( hwnd, hdc );
1734 }
1735
1736
1737 /******************************************************************************
1738 *
1739 * void NC_DoNCPaint95(
1740 * WND *wndPtr,
1741 * HRGN clip,
1742 * BOOL suppress_menupaint )
1743 *
1744 * Paint the non-client area for Win95 windows. The clip region is
1745 * currently ignored.
1746 *
1747 * Bugs
1748 * grep -E -A10 -B5 \(95\)\|\(Bugs\)\|\(FIXME\) windows/nonclient.c \
1749 * misc/tweak.c controls/menu.c # :-)
1750 *
1751 * Revision history
1752 * 03-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1753 * Original implementation
1754 * 10-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1755 * Fixed some bugs.
1756 * 29-Jun-1999 Ove Kåven (ovek@arcticnet.no)
1757 * Streamlined window style checks.
1758 *
1759 *****************************************************************************/
1760
1761 static void NC_DoNCPaint95(
1762 WND *wndPtr,
1763 HRGN clip,
1764 BOOL suppress_menupaint )
1765 {
1766 HDC hdc;
1767 RECT rfuzz, rect, rectClip;
1768 BOOL active;
1769 HWND hwnd = wndPtr->hwndSelf;
1770
1771 if ( wndPtr->dwStyle & WS_MINIMIZE ||
1772 !WIN_IsWindowDrawable( wndPtr, 0 )) return; /* Nothing to do */
1773
1774 active = wndPtr->flags & WIN_NCACTIVATED;
1775
1776 TRACE("%04x %d\n", hwnd, active );
1777
1778 /* MSDN docs are pretty idiotic here, they say app CAN use clipRgn in
1779 the call to GetDCEx implying that it is allowed not to use it either.
1780 However, the suggested GetDCEx( , DCX_WINDOW | DCX_INTERSECTRGN)
1781 will cause clipRgn to be deleted after ReleaseDC().
1782 Now, how is the "system" supposed to tell what happened?
1783 */
1784
1785 if (!(hdc = GetDCEx( hwnd, (clip > 1) ? clip : 0, DCX_USESTYLE | DCX_WINDOW |
1786 ((clip > 1) ?(DCX_INTERSECTRGN | DCX_KEEPCLIPRGN) : 0) ))) return;
1787
1788
1789 if (ExcludeVisRect16( hdc, wndPtr->rectClient.left-wndPtr->rectWindow.left,
1790 wndPtr->rectClient.top-wndPtr->rectWindow.top,
1791 wndPtr->rectClient.right-wndPtr->rectWindow.left,
1792 wndPtr->rectClient.bottom-wndPtr->rectWindow.top )
1793 == NULLREGION)
1794 {
1795 ReleaseDC( hwnd, hdc );
1796 return;
1797 }
1798
1799 rect.top = rect.left = 0;
1800 rect.right = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
1801 rect.bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
1802
1803 if( clip > 1 )
1804 GetRgnBox( clip, &rectClip );
1805 else
1806 {
1807 clip = 0;
1808 rectClip = rect;
1809 }
1810
1811 SelectObject( hdc, GetSysColorPen(COLOR_WINDOWFRAME) );
1812
1813 if(!(wndPtr->flags & WIN_MANAGED)) {
1814 if (HAS_BIGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle)) {
1815 DrawEdge (hdc, &rect, EDGE_RAISED, BF_RECT | BF_ADJUST);
1816 }
1817 if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
1818 NC_DrawFrame95(hdc, &rect, FALSE, active );
1819 else if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
1820 NC_DrawFrame95( hdc, &rect, TRUE, active );
1821 else if (HAS_THINFRAME( wndPtr->dwStyle )) {
1822 SelectObject( hdc, GetStockObject(NULL_BRUSH) );
1823 Rectangle( hdc, 0, 0, rect.right, rect.bottom );
1824 }
1825
1826 if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
1827 {
1828 RECT r = rect;
1829 if (wndPtr->dwExStyle & WS_EX_TOOLWINDOW) {
1830 r.bottom = rect.top + GetSystemMetrics(SM_CYSMCAPTION);
1831 rect.top += GetSystemMetrics(SM_CYSMCAPTION);
1832 }
1833 else {
1834 r.bottom = rect.top + GetSystemMetrics(SM_CYCAPTION);
1835 rect.top += GetSystemMetrics(SM_CYCAPTION);
1836 }
1837 if( !clip || IntersectRect( &rfuzz, &r, &rectClip ) )
1838 NC_DrawCaption95 (hdc, &r, hwnd, wndPtr->dwStyle,
1839 wndPtr->dwExStyle, active);
1840 }
1841 }
1842
1843 if (HAS_MENU(wndPtr))
1844 {
1845 RECT r = rect;
1846 r.bottom = rect.top + GetSystemMetrics(SM_CYMENU);
1847
1848 TRACE("Calling DrawMenuBar with rect (%d, %d)-(%d, %d)\n",
1849 r.left, r.top, r.right, r.bottom);
1850
1851 rect.top += MENU_DrawMenuBar( hdc, &r, hwnd, suppress_menupaint ) + 1;
1852 }
1853
1854 TRACE("After MenuBar, rect is (%d, %d)-(%d, %d).\n",
1855 rect.left, rect.top, rect.right, rect.bottom );
1856
1857 if (wndPtr->dwExStyle & WS_EX_CLIENTEDGE)
1858 DrawEdge (hdc, &rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
1859
1860 if (wndPtr->dwExStyle & WS_EX_STATICEDGE)
1861 DrawEdge (hdc, &rect, BDR_SUNKENOUTER, BF_RECT | BF_ADJUST);
1862
1863 /* Draw the scroll-bars */
1864
1865 if (wndPtr->dwStyle & WS_VSCROLL)
1866 SCROLL_DrawScrollBar( hwnd, hdc, SB_VERT, TRUE, TRUE );
1867 if (wndPtr->dwStyle & WS_HSCROLL)
1868 SCROLL_DrawScrollBar( hwnd, hdc, SB_HORZ, TRUE, TRUE );
1869
1870 /* Draw the "size-box" */
1871 if ((wndPtr->dwStyle & WS_VSCROLL) && (wndPtr->dwStyle & WS_HSCROLL))
1872 {
1873 RECT r = rect;
1874 r.left = r.right - GetSystemMetrics(SM_CXVSCROLL) + 1;
1875 r.top = r.bottom - GetSystemMetrics(SM_CYHSCROLL) + 1;
1876 FillRect( hdc, &r, GetSysColorBrush(COLOR_SCROLLBAR) );
1877 }
1878
1879 ReleaseDC( hwnd, hdc );
1880 }
1881
1882
1883
1884
1885 /***********************************************************************
1886 * NC_HandleNCPaint
1887 *
1888 * Handle a WM_NCPAINT message. Called from DefWindowProc().
1889 */
1890 LONG NC_HandleNCPaint( HWND hwnd , HRGN clip)
1891 {
1892 WND* wndPtr = WIN_FindWndPtr( hwnd );
1893
1894 if( wndPtr && wndPtr->dwStyle & WS_VISIBLE )
1895 {
1896 if( wndPtr->dwStyle & WS_MINIMIZE )
1897 WINPOS_RedrawIconTitle( hwnd );
1898 else if (TWEAK_WineLook == WIN31_LOOK)
1899 NC_DoNCPaint( wndPtr, clip, FALSE );
1900 else
1901 NC_DoNCPaint95( wndPtr, clip, FALSE );
1902 }
1903 WIN_ReleaseWndPtr(wndPtr);
1904 return 0;
1905 }
1906
1907
1908 /***********************************************************************
1909 * NC_HandleNCActivate
1910 *
1911 * Handle a WM_NCACTIVATE message. Called from DefWindowProc().
1912 */
1913 LONG NC_HandleNCActivate( WND *wndPtr, WPARAM16 wParam )
1914 {
1915 WORD wStateChange;
1916
1917 if( wParam ) wStateChange = !(wndPtr->flags & WIN_NCACTIVATED);
1918 else wStateChange = wndPtr->flags & WIN_NCACTIVATED;
1919
1920 if( wStateChange )
1921 {
1922 if (wParam) wndPtr->flags |= WIN_NCACTIVATED;
1923 else wndPtr->flags &= ~WIN_NCACTIVATED;
1924
1925 if( wndPtr->dwStyle & WS_MINIMIZE )
1926 WINPOS_RedrawIconTitle( wndPtr->hwndSelf );
1927 else if (TWEAK_WineLook == WIN31_LOOK)
1928 NC_DoNCPaint( wndPtr, (HRGN)1, FALSE );
1929 else
1930 NC_DoNCPaint95( wndPtr, (HRGN)1, FALSE );
1931 }
1932 return TRUE;
1933 }
1934
1935
1936 /***********************************************************************
1937 * NC_HandleSetCursor
1938 *
1939 * Handle a WM_SETCURSOR message. Called from DefWindowProc().
1940 */
1941 LONG NC_HandleSetCursor( HWND hwnd, WPARAM16 wParam, LPARAM lParam )
1942 {
1943 if (hwnd != (HWND)wParam) return 0; /* Don't set the cursor for child windows */
1944
1945 switch(LOWORD(lParam))
1946 {
1947 case HTERROR:
1948 {
1949 WORD msg = HIWORD( lParam );
1950 if ((msg == WM_LBUTTONDOWN) || (msg == WM_MBUTTONDOWN) ||
1951 (msg == WM_RBUTTONDOWN))
1952 MessageBeep(0);
1953 }
1954 break;
1955
1956 case HTCLIENT:
1957 {
1958 HICON16 hCursor = (HICON16) GetClassWord(hwnd, GCW_HCURSOR);
1959 if(hCursor) {
1960 SetCursor16(hCursor);
1961 return TRUE;
1962 }
1963 return FALSE;
1964 }
1965
1966 case HTLEFT:
1967 case HTRIGHT:
1968 return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZEWE16 ) );
1969
1970 case HTTOP:
1971 case HTBOTTOM:
1972 return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZENS16 ) );
1973
1974 case HTTOPLEFT:
1975 case HTBOTTOMRIGHT:
1976 return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZENWSE16 ) );
1977
1978 case HTTOPRIGHT:
1979 case HTBOTTOMLEFT:
1980 return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZENESW16 ) );
1981 }
1982
1983 /* Default cursor: arrow */
1984 return (LONG)SetCursor16( LoadCursor16( 0, IDC_ARROW16 ) );
1985 }
1986
1987 /***********************************************************************
1988 * NC_GetSysPopupPos
1989 */
1990 BOOL NC_GetSysPopupPos( WND* wndPtr, RECT* rect )
1991 {
1992 if( wndPtr->hSysMenu )
1993 {
1994 if( wndPtr->dwStyle & WS_MINIMIZE )
1995 GetWindowRect( wndPtr->hwndSelf, rect );
1996 else
1997 {
1998 if (TWEAK_WineLook == WIN31_LOOK)
1999 NC_GetInsideRect( wndPtr->hwndSelf, rect );
2000 else
2001 NC_GetInsideRect95( wndPtr->hwndSelf, rect );
2002 OffsetRect( rect, wndPtr->rectWindow.left, wndPtr->rectWindow.top);
2003 if (wndPtr->dwStyle & WS_CHILD)
2004 ClientToScreen( wndPtr->parent->hwndSelf, (POINT *)rect );
2005 if (TWEAK_WineLook == WIN31_LOOK) {
2006 rect->right = rect->left + GetSystemMetrics(SM_CXSIZE);
2007 rect->bottom = rect->top + GetSystemMetrics(SM_CYSIZE);
2008 }
2009 else {
2010 rect->right = rect->left + GetSystemMetrics(SM_CYCAPTION) - 1;
2011 rect->bottom = rect->top + GetSystemMetrics(SM_CYCAPTION) - 1;
2012 }
2013 }
2014 return TRUE;
2015 }
2016 return FALSE;
2017 }
2018
2019 /***********************************************************************
2020 * NC_StartSizeMove
2021 *
2022 * Initialisation of a move or resize, when initiatied from a menu choice.
2023 * Return hit test code for caption or sizing border.
2024 */
2025 static LONG NC_StartSizeMove( WND* wndPtr, WPARAM16 wParam,
2026 POINT16 *capturePoint )
2027 {
2028 LONG hittest = 0;
2029 POINT16 pt;
2030 MSG msg;
2031 RECT rectWindow;
2032
2033 GetWindowRect(wndPtr->hwndSelf,&rectWindow);
2034
2035 if ((wParam & 0xfff0) == SC_MOVE)
2036 {
2037 /* Move pointer at the center of the caption */
2038 RECT rect;
2039 if (TWEAK_WineLook == WIN31_LOOK)
2040 NC_GetInsideRect( wndPtr->hwndSelf, &rect );
2041 else
2042 NC_GetInsideRect95( wndPtr->hwndSelf, &rect );
2043 if (wndPtr->dwStyle & WS_SYSMENU)
2044 rect.left += GetSystemMetrics(SM_CXSIZE) + 1;
2045 if (wndPtr->dwStyle & WS_MINIMIZEBOX)
2046 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
2047 if (wndPtr->dwStyle & WS_MAXIMIZEBOX)
2048 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
2049 pt.x = rectWindow.left + (rect.right - rect.left) / 2;
2050 pt.y = rectWindow.top + rect.top + GetSystemMetrics(SM_CYSIZE)/2;
2051 hittest = HTCAPTION;
2052 *capturePoint = pt;
2053 }
2054 else /* SC_SIZE */
2055 {
2056 while(!hittest)
2057 {
2058 MSG_InternalGetMessage( QMSG_WIN32A, &msg, 0, 0, MSGF_SIZE, PM_REMOVE, FALSE, NULL );
2059 switch(msg.message)
2060 {
2061 case WM_MOUSEMOVE:
2062 CONV_POINT32TO16(&msg.pt, &pt);
2063 hittest = NC_HandleNCHitTest( wndPtr->hwndSelf, pt );
2064 if ((hittest < HTLEFT) || (hittest > HTBOTTOMRIGHT))
2065 hittest = 0;
2066 break;
2067
2068 case WM_LBUTTONUP:
2069 return 0;
2070
2071 case WM_KEYDOWN:
2072 switch(msg.wParam)
2073 {
2074 case VK_UP:
2075 hittest = HTTOP;
2076 pt.x =(rectWindow.left+rectWindow.right)/2;
2077 pt.y = rectWindow.top + GetSystemMetrics(SM_CYFRAME) / 2;
2078 break;
2079 case VK_DOWN:
2080 hittest = HTBOTTOM;
2081 pt.x =(rectWindow.left+rectWindow.right)/2;
2082 pt.y = rectWindow.bottom - GetSystemMetrics(SM_CYFRAME) / 2;
2083 break;
2084 case VK_LEFT:
2085 hittest = HTLEFT;
2086 pt.x = rectWindow.left + GetSystemMetrics(SM_CXFRAME) / 2;
2087 pt.y =(rectWindow.top+rectWindow.bottom)/2;
2088 break;
2089 case VK_RIGHT:
2090 hittest = HTRIGHT;
2091 pt.x = rectWindow.right - GetSystemMetrics(SM_CXFRAME) / 2;
2092 pt.y =(rectWindow.top+rectWindow.bottom)/2;
2093 break;
2094 case VK_RETURN:
2095 case VK_ESCAPE: return 0;
2096 }
2097 }
2098 }
2099 *capturePoint = pt;
2100 }
2101 SetCursorPos( pt.x, pt.y );
2102 NC_HandleSetCursor( wndPtr->hwndSelf,
2103 wndPtr->hwndSelf, MAKELONG( hittest, WM_MOUSEMOVE ));
2104 return hittest;
2105 }
2106
2107
2108 /***********************************************************************
2109 * NC_DoSizeMove
2110 *
2111 * Perform SC_MOVE and SC_SIZE commands. `
2112 */
2113 static void NC_DoSizeMove( HWND hwnd, WORD wParam )
2114 {
2115 MSG msg;
2116 RECT sizingRect, mouseRect;
2117 HDC hdc;
2118 LONG hittest = (LONG)(wParam & 0x0f);
2119 HCURSOR16 hDragCursor = 0, hOldCursor = 0;
2120 POINT minTrack, maxTrack;
2121 POINT16 capturePoint, pt;
2122 WND * wndPtr = WIN_FindWndPtr( hwnd );
2123 BOOL thickframe = HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle );
2124 BOOL iconic = wndPtr->dwStyle & WS_MINIMIZE;
2125 BOOL moved = FALSE;
2126 DWORD dwPoint = GetMessagePos ();
2127
2128 capturePoint = pt = *(POINT16*)&dwPoint;
2129
2130 if (IsZoomed(hwnd) || !IsWindowVisible(hwnd) ||
2131 (wndPtr->flags & WIN_MANAGED)) goto END;
2132
2133 if ((wParam & 0xfff0) == SC_MOVE)
2134 {
2135 if (!(wndPtr->dwStyle & WS_CAPTION)) goto END;
2136 if (!hittest)
2137 hittest = NC_StartSizeMove( wndPtr, wParam, &capturePoint );
2138 if (!hittest) goto END;
2139 }
2140 else /* SC_SIZE */
2141 {
2142 if (!thickframe) goto END;
2143 if ( hittest && hittest != HTSYSMENU ) hittest += 2;
2144 else
2145 {
2146 SetCapture(hwnd);
2147 hittest = NC_StartSizeMove( wndPtr, wParam, &capturePoint );
2148 if (!hittest)
2149 {
2150 ReleaseCapture();
2151 goto END;
2152 }
2153 }
2154 }
2155
2156 /* Get min/max info */
2157
2158 WINPOS_GetMinMaxInfo( wndPtr, NULL, NULL, &minTrack, &maxTrack );
2159 sizingRect = wndPtr->rectWindow;
2160 if (wndPtr->dwStyle & WS_CHILD)
2161 GetClientRect( wndPtr->parent->hwndSelf, &mouseRect );
2162 else
2163 SetRect(&mouseRect, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
2164 if (ON_LEFT_BORDER(hittest))
2165 {
2166 mouseRect.left = max( mouseRect.left, sizingRect.right-maxTrack.x );
2167 mouseRect.right = min( mouseRect.right, sizingRect.right-minTrack.x );
2168 }
2169 else if (ON_RIGHT_BORDER(hittest))
2170 {
2171 mouseRect.left = max( mouseRect.left, sizingRect.left+minTrack.x );
2172 mouseRect.right = min( mouseRect.right, sizingRect.left+maxTrack.x );
2173 }
2174 if (ON_TOP_BORDER(hittest))
2175 {
2176 mouseRect.top = max( mouseRect.top, sizingRect.bottom-maxTrack.y );
2177 mouseRect.bottom = min( mouseRect.bottom,sizingRect.bottom-minTrack.y);
2178 }
2179 else if (ON_BOTTOM_BORDER(hittest))
2180 {
2181 mouseRect.top = max( mouseRect.top, sizingRect.top+minTrack.y );
2182 mouseRect.bottom = min( mouseRect.bottom, sizingRect.top+maxTrack.y );
2183 }
2184 if (wndPtr->dwStyle & WS_CHILD)
2185 {
2186 MapWindowPoints( wndPtr->parent->hwndSelf, 0,
2187 (LPPOINT)&mouseRect, 2 );
2188 }
2189 SendMessage16( hwnd, WM_ENTERSIZEMOVE, 0, 0 );
2190
2191 if (GetCapture() != hwnd) SetCapture( hwnd );
2192
2193 if (wndPtr->dwStyle & WS_CHILD)
2194 {
2195 /* Retrieve a default cache DC (without using the window style) */
2196 hdc = GetDCEx( wndPtr->parent->hwndSelf, 0, DCX_CACHE );
2197 }
2198 else
2199 { /* Grab the server only when moving top-level windows without desktop */
2200 hdc = GetDC( 0 );
2201 }
2202
2203 wndPtr->pDriver->pPreSizeMove(wndPtr);
2204
2205 if( iconic ) /* create a cursor for dragging */
2206 {
2207 HICON16 hIcon = GetClassWord(wndPtr->hwndSelf, GCW_HICON);
2208 if(!hIcon) hIcon = (HICON16) SendMessage16( hwnd, WM_QUERYDRAGICON, 0, 0L);
2209 if( hIcon ) hDragCursor = CURSORICON_IconToCursor( hIcon, TRUE );
2210 if( !hDragCursor ) iconic = FALSE;
2211 }
2212
2213 /* invert frame if WIN31_LOOK to indicate mouse click on caption */
2214 if( !iconic && TWEAK_WineLook == WIN31_LOOK )
2215 NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
2216
2217 while(1)
2218 {
2219 int dx = 0, dy = 0;
2220
2221 MSG_InternalGetMessage( QMSG_WIN32A, &msg, 0, 0, MSGF_SIZE, PM_REMOVE, FALSE, NULL );
2222
2223 /* Exit on button-up, Return, or Esc */
2224 if ((msg.message == WM_LBUTTONUP) ||
2225 ((msg.message == WM_KEYDOWN) &&
2226 ((msg.wParam == VK_RETURN) || (msg.wParam == VK_ESCAPE)))) break;
2227
2228 if (msg.message == WM_PAINT)
2229 {
2230 if(!iconic) NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
2231 UpdateWindow( msg.hwnd );
2232 if(!iconic) NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
2233 continue;
2234 }
2235 if ((msg.message != WM_KEYDOWN) && (msg.message != WM_MOUSEMOVE))
2236 continue; /* We are not interested in other messages */
2237
2238 dwPoint = GetMessagePos ();
2239 pt = *(POINT16*)&dwPoint;
2240
2241 if (msg.message == WM_KEYDOWN) switch(msg.wParam)
2242 {
2243 case VK_UP: pt.y -= 8; break;
2244 case VK_DOWN: pt.y += 8; break;
2245 case VK_LEFT: pt.x -= 8; break;
2246 case VK_RIGHT: pt.x += 8; break;
2247 }
2248
2249 pt.x = max( pt.x, mouseRect.left );
2250 pt.x = min( pt.x, mouseRect.right );
2251 pt.y = max( pt.y, mouseRect.top );
2252 pt.y = min( pt.y, mouseRect.bottom );
2253
2254 dx = pt.x - capturePoint.x;
2255 dy = pt.y - capturePoint.y;
2256
2257 if (dx || dy)
2258 {
2259 if( !moved )
2260 {
2261 moved = TRUE;
2262
2263 if( iconic ) /* ok, no system popup tracking */
2264 {
2265 hOldCursor = SetCursor(hDragCursor);
2266 ShowCursor( TRUE );
2267 WINPOS_ShowIconTitle( wndPtr, FALSE );
2268 } else if(TWEAK_WineLook != WIN31_LOOK)
2269 {
2270 NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
2271 }
2272 }
2273
2274 if (msg.message == WM_KEYDOWN) SetCursorPos( pt.x, pt.y );
2275 else
2276 {
2277 RECT newRect = sizingRect;
2278 WPARAM wpSizingHit = 0;
2279
2280 if (hittest == HTCAPTION) OffsetRect( &newRect, dx, dy );
2281 if (ON_LEFT_BORDER(hittest)) newRect.left += dx;
2282 else if (ON_RIGHT_BORDER(hittest)) newRect.right += dx;
2283 if (ON_TOP_BORDER(hittest)) newRect.top += dy;
2284 else if (ON_BOTTOM_BORDER(hittest)) newRect.bottom += dy;
2285 if(!iconic) NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
2286 capturePoint = pt;
2287
2288 /* determine the hit location */
2289 if (hittest >= HTLEFT && hittest <= HTBOTTOMRIGHT)
2290 wpSizingHit = WMSZ_LEFT + (hittest - HTLEFT);
2291 SendMessageA( hwnd, WM_SIZING, wpSizingHit, (LPARAM)&newRect );
2292
2293 if (!iconic) NC_DrawMovingFrame( hdc, &newRect, thickframe );
2294 sizingRect = newRect;
2295 }
2296 }
2297 }
2298
2299 ReleaseCapture();
2300 if( iconic )
2301 {
2302 if( moved ) /* restore cursors, show icon title later on */
2303 {
2304 ShowCursor( FALSE );
2305 SetCursor( hOldCursor );
2306 }
2307 DestroyCursor( hDragCursor );
2308 }
2309 else if(moved || TWEAK_WineLook == WIN31_LOOK)
2310 NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
2311
2312 if (wndPtr->dwStyle & WS_CHILD)
2313 ReleaseDC( wndPtr->parent->hwndSelf, hdc );
2314 else
2315 ReleaseDC( 0, hdc );
2316
2317 wndPtr->pDriver->pPostSizeMove(wndPtr);
2318
2319 if (HOOK_IsHooked( WH_CBT ))
2320 {
2321 RECT16* pr = SEGPTR_NEW(RECT16);
2322 if( pr )
2323 {
2324 CONV_RECT32TO16( &sizingRect, pr );
2325 if( HOOK_CallHooks16( WH_CBT, HCBT_MOVESIZE, hwnd,
2326 (LPARAM)SEGPTR_GET(pr)) )
2327 sizingRect = wndPtr->rectWindow;
2328 else
2329 CONV_RECT16TO32( pr, &sizingRect );
2330 SEGPTR_FREE(pr);
2331 }
2332 }
2333 SendMessage16( hwnd, WM_EXITSIZEMOVE, 0, 0 );
2334 SendMessage16( hwnd, WM_SETVISIBLE, !IsIconic16(hwnd), 0L);
2335
2336 /* window moved or resized */
2337 if (moved)
2338 {
2339 /* if the moving/resizing isn't canceled call SetWindowPos
2340 * with the new position or the new size of the window
2341 */
2342 if (!((msg.message == WM_KEYDOWN) && (msg.wParam == VK_ESCAPE)) )
2343 {
2344 /* NOTE: SWP_NOACTIVATE prevents document window activation in Word 6 */
2345 SetWindowPos( hwnd, 0, sizingRect.left, sizingRect.top,
2346 sizingRect.right - sizingRect.left,
2347 sizingRect.bottom - sizingRect.top,
2348 ( hittest == HTCAPTION ) ? SWP_NOSIZE : 0 );
2349 }
2350 }
2351
2352 if( IsWindow(hwnd) )
2353 if( wndPtr->dwStyle & WS_MINIMIZE )
2354 {
2355 /* Single click brings up the system menu when iconized */
2356
2357 if( !moved )
2358 {
2359 if( wndPtr->dwStyle & WS_SYSMENU )
2360 SendMessage16( hwnd, WM_SYSCOMMAND,
2361 SC_MOUSEMENU + HTSYSMENU, *((LPARAM*)&pt));
2362 }
2363 else WINPOS_ShowIconTitle( wndPtr, TRUE );
2364 }
2365
2366 END:
2367 WIN_ReleaseWndPtr(wndPtr);
2368 }
2369
2370
2371 /***********************************************************************
2372 * NC_TrackMinMaxBox95
2373 *
2374 * Track a mouse button press on the minimize or maximize box.
2375 *
2376 * The big difference between 3.1 and 95 is the disabled button state.
2377 * In win95 the system button can be disabled, so it can ignore the mouse
2378 * event.
2379 *
2380 */
2381 static void NC_TrackMinMaxBox95( HWND hwnd, WORD wParam )
2382 {
2383 MSG msg;
2384 POINT16 pt16;
2385 HDC hdc = GetWindowDC( hwnd );
2386 BOOL pressed = TRUE;
2387 UINT state;
2388 DWORD wndStyle = GetWindowLongA( hwnd, GWL_STYLE);
2389 HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
2390
2391 void (*paintButton)(HWND, HDC16, BOOL, BOOL);
2392
2393 if (wParam == HTMINBUTTON)
2394 {
2395 /* If the style is not present, do nothing */
2396 if (!(wndStyle & WS_MINIMIZEBOX))
2397 return;
2398
2399 /* Check if the sysmenu item for minimize is there */
2400 state = GetMenuState(hSysMenu, SC_MINIMIZE, MF_BYCOMMAND);
2401
2402 paintButton = &NC_DrawMinButton95;
2403 }
2404 else
2405 {
2406 /* If the style is not present, do nothing */
2407 if (!(wndStyle & WS_MAXIMIZEBOX))
2408 return;
2409
2410 /* Check if the sysmenu item for maximize is there */
2411 state = GetMenuState(hSysMenu, SC_MAXIMIZE, MF_BYCOMMAND);
2412
2413 paintButton = &NC_DrawMaxButton95;
2414 }
2415
2416 SetCapture( hwnd );
2417
2418 (*paintButton)( hwnd, hdc, TRUE, FALSE);
2419
2420 do
2421 {
2422 BOOL oldstate = pressed;
2423 MSG_InternalGetMessage( QMSG_WIN32A, &msg, 0, 0, 0, PM_REMOVE, FALSE, NULL );
2424 CONV_POINT32TO16( &msg.pt, &pt16 );
2425
2426 pressed = (NC_HandleNCHitTest( hwnd, pt16 ) == wParam);
2427 if (pressed != oldstate)
2428 (*paintButton)( hwnd, hdc, pressed, FALSE);
2429 } while (msg.message != WM_LBUTTONUP);
2430
2431 (*paintButton)( hwnd, hdc, FALSE, FALSE);
2432
2433 ReleaseCapture();
2434 ReleaseDC( hwnd, hdc );
2435
2436 /* If the item minimize or maximize of the sysmenu are not there */
2437 /* or if the style is not present, do nothing */
2438 if ((!pressed) || (state == 0xFFFFFFFF))
2439 return;
2440
2441 if (wParam == HTMINBUTTON)
2442 SendMessage16( hwnd, WM_SYSCOMMAND, SC_MINIMIZE, *(LONG*)&pt16 );
2443 else
2444 SendMessage16( hwnd, WM_SYSCOMMAND,
2445 IsZoomed(hwnd) ? SC_RESTORE:SC_MAXIMIZE, *(LONG*)&pt16 );
2446 }
2447
2448 /***********************************************************************
2449 * NC_TrackMinMaxBox
2450 *
2451 * Track a mouse button press on the minimize or maximize box.
2452 */
2453 static void NC_TrackMinMaxBox( HWND hwnd, WORD wParam )
2454 {
2455 MSG msg;
2456 POINT16 pt16;
2457 HDC hdc = GetWindowDC( hwnd );
2458 BOOL pressed = TRUE;
2459 void (*paintButton)(HWND, HDC16, BOOL);
2460
2461 SetCapture( hwnd );
2462
2463 if (wParam == HTMINBUTTON)
2464 paintButton = &NC_DrawMinButton;
2465 else
2466 paintButton = &NC_DrawMaxButton;
2467
2468 (*paintButton)( hwnd, hdc, TRUE);
2469
2470 do
2471 {
2472 BOOL oldstate = pressed;
2473 MSG_InternalGetMessage( QMSG_WIN32A, &msg, 0, 0, 0, PM_REMOVE, FALSE, NULL );
2474 CONV_POINT32TO16( &msg.pt, &pt16 );
2475
2476 pressed = (NC_HandleNCHitTest( hwnd, pt16 ) == wParam);
2477 if (pressed != oldstate)
2478 (*paintButton)( hwnd, hdc, pressed);
2479 } while (msg.message != WM_LBUTTONUP);
2480
2481 (*paintButton)( hwnd, hdc, FALSE);
2482
2483 ReleaseCapture();
2484 ReleaseDC( hwnd, hdc );
2485
2486 if (!pressed) return;
2487
2488 if (wParam == HTMINBUTTON)
2489 SendMessage16( hwnd, WM_SYSCOMMAND, SC_MINIMIZE, *(LONG*)&pt16 );
2490 else
2491 SendMessage16( hwnd, WM_SYSCOMMAND,
2492 IsZoomed(hwnd) ? SC_RESTORE:SC_MAXIMIZE, *(LONG*)&pt16 );
2493 }
2494
2495
2496 /***********************************************************************
2497 * NC_TrackCloseButton95
2498 *
2499 * Track a mouse button press on the Win95 close button.
2500 */
2501 static void
2502 NC_TrackCloseButton95 (HWND hwnd, WORD wParam)
2503 {
2504 MSG msg;
2505 POINT16 pt16;
2506 HDC hdc;
2507 BOOL pressed = TRUE;
2508 HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
2509 UINT state;
2510
2511 if(hSysMenu == 0)
2512 return;
2513
2514 state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
2515
2516 /* If the item close of the sysmenu is disabled or not there do nothing */
2517 if((state & MF_DISABLED) || (state & MF_GRAYED) || (state == 0xFFFFFFFF))
2518 return;
2519
2520 hdc = GetWindowDC( hwnd );
2521
2522 SetCapture( hwnd );
2523
2524 NC_DrawCloseButton95 (hwnd, hdc, TRUE, FALSE);
2525
2526 do
2527 {
2528 BOOL oldstate = pressed;
2529 MSG_InternalGetMessage( QMSG_WIN32A, &msg, 0, 0, 0, PM_REMOVE, FALSE, NULL );
2530 CONV_POINT32TO16( &msg.pt, &pt16 );
2531
2532 pressed = (NC_HandleNCHitTest( hwnd, pt16 ) == wParam);
2533 if (pressed != oldstate)
2534 NC_DrawCloseButton95 (hwnd, hdc, pressed, FALSE);
2535 } while (msg.message != WM_LBUTTONUP);
2536
2537 NC_DrawCloseButton95 (hwnd, hdc, FALSE, FALSE);
2538
2539 ReleaseCapture();
2540 ReleaseDC( hwnd, hdc );
2541 if (!pressed) return;
2542
2543 SendMessage16( hwnd, WM_SYSCOMMAND, SC_CLOSE, *(LONG*)&pt16 );
2544 }
2545
2546
2547 /***********************************************************************
2548 * NC_TrackScrollBar
2549 *
2550 * Track a mouse button press on the horizontal or vertical scroll-bar.
2551 */
2552 static void NC_TrackScrollBar( HWND hwnd, WPARAM wParam, POINT pt )
2553 {
2554 MSG16 *msg;
2555 INT scrollbar;
2556 WND *wndPtr = WIN_FindWndPtr( hwnd );
2557
2558 if ((wParam & 0xfff0) == SC_HSCROLL)
2559 {
2560 if ((wParam & 0x0f) != HTHSCROLL) goto END;
2561 scrollbar = SB_HORZ;
2562 }
2563 else /* SC_VSCROLL */
2564 {
2565 if ((wParam & 0x0f) != HTVSCROLL) goto END;
2566 scrollbar = SB_VERT;
2567 }
2568
2569 if (!(msg = SEGPTR_NEW(MSG16))) goto END;
2570 pt.x -= wndPtr->rectWindow.left;
2571 pt.y -= wndPtr->rectWindow.top;
2572 SetCapture( hwnd );
2573 SCROLL_HandleScrollEvent( hwnd, scrollbar, WM_LBUTTONDOWN, pt );
2574
2575 do
2576 {
2577 GetMessage16( SEGPTR_GET(msg), 0, 0, 0 );
2578 switch(msg->message)
2579 {
2580 case WM_LBUTTONUP:
2581 case WM_MOUSEMOVE:
2582 case WM_SYSTIMER:
2583 pt.x = LOWORD(msg->lParam) + wndPtr->rectClient.left -
2584 wndPtr->rectWindow.left;
2585 pt.y = HIWORD(msg->lParam) + wndPtr->rectClient.top -
2586 wndPtr->rectWindow.top;
2587 SCROLL_HandleScrollEvent( hwnd, scrollbar, msg->message, pt );
2588 break;
2589 default:
2590 TranslateMessage16( msg );
2591 DispatchMessage16( msg );
2592 break;
2593 }
2594 if (!IsWindow( hwnd ))
2595 {
2596 ReleaseCapture();
2597 break;
2598 }
2599 } while (msg->message != WM_LBUTTONUP);
2600 SEGPTR_FREE(msg);
2601 END:
2602 WIN_ReleaseWndPtr(wndPtr);
2603 }
2604
2605 /***********************************************************************
2606 * NC_HandleNCLButtonDown
2607 *
2608 * Handle a WM_NCLBUTTONDOWN message. Called from DefWindowProc().
2609 */
2610 LONG NC_HandleNCLButtonDown( WND* pWnd, WPARAM16 wParam, LPARAM lParam )
2611 {
2612 HWND hwnd = pWnd->hwndSelf;
2613
2614 switch(wParam) /* Hit test */
2615 {
2616 case HTCAPTION:
2617 hwnd = WIN_GetTopParent(hwnd);
2618
2619 if( WINPOS_SetActiveWindow(hwnd, TRUE, TRUE) || (GetActiveWindow() == hwnd) )
2620 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_MOVE + HTCAPTION, lParam );
2621 break;
2622
2623 case HTSYSMENU:
2624 if( pWnd->dwStyle & WS_SYSMENU )
2625 {
2626 if( !(pWnd->dwStyle & WS_MINIMIZE) )
2627 {
2628 HDC hDC = GetWindowDC(hwnd);
2629 if (TWEAK_WineLook == WIN31_LOOK)
2630 NC_DrawSysButton( hwnd, hDC, TRUE );
2631 else
2632 NC_DrawSysButton95( hwnd, hDC, TRUE );
2633 ReleaseDC( hwnd, hDC );
2634 }
2635 SendMessage16( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU + HTSYSMENU, lParam );
2636 }
2637 break;
2638
2639 case HTMENU:
2640 SendMessage16( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU, lParam );
2641 break;
2642
2643 case HTHSCROLL:
2644 SendMessage16( hwnd, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL, lParam );
2645 break;
2646
2647 case HTVSCROLL:
2648 SendMessage16( hwnd, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL, lParam );
2649 break;
2650
2651 case HTMINBUTTON:
2652 case HTMAXBUTTON:
2653 if (TWEAK_WineLook == WIN31_LOOK)
2654 NC_TrackMinMaxBox( hwnd, wParam );
2655 else
2656 NC_TrackMinMaxBox95( hwnd, wParam );
2657 break;
2658
2659 case HTCLOSE:
2660 if (TWEAK_WineLook >= WIN95_LOOK)
2661 NC_TrackCloseButton95 (hwnd, wParam);
2662 break;
2663
2664 case HTLEFT:
2665 case HTRIGHT:
2666 case HTTOP:
2667 case HTTOPLEFT:
2668 case HTTOPRIGHT:
2669 case HTBOTTOM:
2670 case HTBOTTOMLEFT:
2671 case HTBOTTOMRIGHT:
2672 /* make sure hittest fits into 0xf and doesn't overlap with HTSYSMENU */
2673 SendMessage16( hwnd, WM_SYSCOMMAND, SC_SIZE + wParam - 2, lParam);
2674 break;
2675
2676 case HTBORDER:
2677 break;
2678 }
2679 return 0;
2680 }
2681
2682
2683 /***********************************************************************
2684 * NC_HandleNCLButtonDblClk
2685 *
2686 * Handle a WM_NCLBUTTONDBLCLK message. Called from DefWindowProc().
2687 */
2688 LONG NC_HandleNCLButtonDblClk( WND *pWnd, WPARAM16 wParam, LPARAM lParam )
2689 {
2690 /*
2691 * if this is an icon, send a restore since we are handling
2692 * a double click
2693 */
2694 if (pWnd->dwStyle & WS_MINIMIZE)
2695 {
2696 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_RESTORE, lParam );
2697 return 0;
2698 }
2699
2700 switch(wParam) /* Hit test */
2701 {
2702 case HTCAPTION:
2703 /* stop processing if WS_MAXIMIZEBOX is missing */
2704 if (pWnd->dwStyle & WS_MAXIMIZEBOX)
2705 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND,
2706 (pWnd->dwStyle & WS_MAXIMIZE) ? SC_RESTORE : SC_MAXIMIZE,
2707 lParam );
2708 break;
2709
2710 case HTSYSMENU:
2711 if (!(GetClassWord(pWnd->hwndSelf, GCW_STYLE) & CS_NOCLOSE))
2712 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_CLOSE, lParam );
2713 break;
2714
2715 case HTHSCROLL:
2716 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL,
2717 lParam );
2718 break;
2719
2720 case HTVSCROLL:
2721 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL,
2722 lParam );
2723 break;
2724 }
2725 return 0;
2726 }
2727
2728
2729 /***********************************************************************
2730 * NC_HandleSysCommand
2731 *
2732 * Handle a WM_SYSCOMMAND message. Called from DefWindowProc().
2733 */
2734 LONG NC_HandleSysCommand( HWND hwnd, WPARAM16 wParam, POINT16 pt )
2735 {
2736 WND *wndPtr = WIN_FindWndPtr( hwnd );
2737 POINT pt32;
2738 UINT16 uCommand = wParam & 0xFFF0;
2739
2740 TRACE("Handling WM_SYSCOMMAND %x %d,%d\n", wParam, pt.x, pt.y );
2741
2742 if (wndPtr->dwStyle & WS_CHILD && uCommand != SC_KEYMENU )
2743 ScreenToClient16( wndPtr->parent->hwndSelf, &pt );
2744
2745 switch (uCommand)
2746 {
2747 case SC_SIZE:
2748 case SC_MOVE:
2749 NC_DoSizeMove( hwnd, wParam );
2750 break;
2751
2752 case SC_MINIMIZE:
2753 if (hwnd == GetForegroundWindow())
2754 ShowOwnedPopups(hwnd,FALSE);
2755 ShowWindow( hwnd, SW_MINIMIZE );
2756 break;
2757
2758 case SC_MAXIMIZE:
2759 if (IsIconic(hwnd) && hwnd == GetForegroundWindow())
2760 ShowOwnedPopups(hwnd,TRUE);
2761 ShowWindow( hwnd, SW_MAXIMIZE );
2762 break;
2763
2764 case SC_RESTORE:
2765 if (IsIconic(hwnd) && hwnd == GetForegroundWindow())
2766 ShowOwnedPopups(hwnd,TRUE);
2767 ShowWindow( hwnd, SW_RESTORE );
2768 break;
2769
2770 case SC_CLOSE:
2771 WIN_ReleaseWndPtr(wndPtr);
2772 return SendMessage16( hwnd, WM_CLOSE, 0, 0 );
2773
2774 case SC_VSCROLL:
2775 case SC_HSCROLL:
2776 CONV_POINT16TO32( &pt, &pt32 );
2777 NC_TrackScrollBar( hwnd, wParam, pt32 );
2778 break;
2779
2780 case SC_MOUSEMENU:
2781 CONV_POINT16TO32( &pt, &pt32 );
2782 MENU_TrackMouseMenuBar( wndPtr, wParam & 0x000F, pt32 );
2783 break;
2784
2785 case SC_KEYMENU:
2786 MENU_TrackKbdMenuBar( wndPtr , wParam , pt.x );
2787 break;
2788
2789 case SC_TASKLIST:
2790 WinExec( "taskman.exe", SW_SHOWNORMAL );
2791 break;
2792
2793 case SC_SCREENSAVE:
2794 if (wParam == SC_ABOUTWINE)
2795 {
2796 HMODULE hmodule = LoadLibraryA( "shell32.dll" );
2797 if (hmodule)
2798 {
2799 FARPROC aboutproc = GetProcAddress( hmodule, "ShellAboutA" );
2800 if (aboutproc) aboutproc( hwnd, "Wine", WINE_RELEASE_INFO, 0 );
2801 FreeLibrary( hmodule );
2802 }
2803 }
2804 else
2805 if (wParam == SC_PUTMARK)
2806 TRACE_(shell)("Mark requested by user\n");
2807 break;
2808
2809 case SC_HOTKEY:
2810 case SC_ARRANGE:
2811 case SC_NEXTWINDOW:
2812 case SC_PREVWINDOW:
2813 FIXME("unimplemented!\n");
2814 break;
2815 }
2816 WIN_ReleaseWndPtr(wndPtr);
2817 return 0;
2818 }
2819
2820 /*************************************************************
2821 * NC_DrawGrayButton
2822 *
2823 * Stub for the grayed button of the caption
2824 *
2825 *************************************************************/
2826
2827 BOOL NC_DrawGrayButton(HDC hdc, int x, int y)
2828 {
2829 HBITMAP hMaskBmp;
2830 HDC hdcMask = CreateCompatibleDC (0);
2831 HBRUSH hOldBrush;
2832
2833 hMaskBmp = CreateBitmap (12, 10, 1, 1, lpGrayMask);
2834
2835 if(hMaskBmp == 0)
2836 return FALSE;
2837
2838 SelectObject (hdcMask, hMaskBmp);
2839
2840 /* Draw the grayed bitmap using the mask */
2841 hOldBrush = SelectObject (hdc, RGB(128, 128, 128));
2842 BitBlt (hdc, x, y, 12, 10,
2843 hdcMask, 0, 0, 0xB8074A);
2844
2845 /* Clean up */
2846 SelectObject (hdc, hOldBrush);
2847 DeleteObject(hMaskBmp);
2848 DeleteDC (hdcMask);
2849
2850 return TRUE;
2851 }
2852
2853 HICON16 NC_IconForWindow(WND *wndPtr)
2854 {
2855 HICON16 hIcon = (HICON) GetClassLongA(wndPtr->hwndSelf, GCL_HICONSM);
2856 if(!hIcon) hIcon = (HICON) GetClassLongA(wndPtr->hwndSelf, GCL_HICON);
2857
2858 /* If there is no hIcon specified and this is a modal dialog, */
2859 /* get the default one. */
2860 if (!hIcon && (wndPtr->dwStyle & DS_MODALFRAME))
2861 hIcon = LoadImageA(0, MAKEINTRESOURCEA(OIC_WINEICON), IMAGE_ICON, 0, 0, LR_DEFAULTCOLOR);
2862
2863 return hIcon;
2864 }
Windows API implementation