?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Removed DOS task fields from the NE_MODULE structure.
[wine/testsucceed.git] / windows / nonclient.c
blob5bf6daaa8ac1ccf37dc34e9c0cad346c04bb4ed4
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 /* Has to return HTNOWHERE if nothing was found
789 Could happen when a window has a customized non client area */
790 return HTNOWHERE;
791 }
792
793
794 /***********************************************************************
795 * NC_DoNCHitTest95
796 *
797 * Handle a WM_NCHITTEST message. Called from NC_HandleNCHitTest().
798 *
799 * FIXME: Just a modified copy of the Win 3.1 version.
800 */
801
802 static LONG
803 NC_DoNCHitTest95 (WND *wndPtr, POINT16 pt )
804 {
805 RECT16 rect;
806
807 TRACE("hwnd=%04x pt=%d,%d\n", wndPtr->hwndSelf, pt.x, pt.y );
808
809 GetWindowRect16 (wndPtr->hwndSelf, &rect );
810 if (!PtInRect16( &rect, pt )) return HTNOWHERE;
811
812 if (wndPtr->dwStyle & WS_MINIMIZE) return HTCAPTION;
813
814 if (!(wndPtr->flags & WIN_MANAGED))
815 {
816 /* Check borders */
817 if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
818 {
819 InflateRect16( &rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
820 if (!PtInRect16( &rect, pt ))
821 {
822 /* Check top sizing border */
823 if (pt.y < rect.top)
824 {
825 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTTOPLEFT;
826 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTTOPRIGHT;
827 return HTTOP;
828 }
829 /* Check bottom sizing border */
830 if (pt.y >= rect.bottom)
831 {
832 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMLEFT;
833 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMRIGHT;
834 return HTBOTTOM;
835 }
836 /* Check left sizing border */
837 if (pt.x < rect.left)
838 {
839 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPLEFT;
840 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMLEFT;
841 return HTLEFT;
842 }
843 /* Check right sizing border */
844 if (pt.x >= rect.right)
845 {
846 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPRIGHT;
847 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMRIGHT;
848 return HTRIGHT;
849 }
850 }
851 }
852 else /* No thick frame */
853 {
854 if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
855 InflateRect16(&rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
856 else if (HAS_THINFRAME( wndPtr->dwStyle ))
857 InflateRect16(&rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
858 if (!PtInRect16( &rect, pt )) return HTBORDER;
859 }
860
861 /* Check caption */
862
863 if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
864 {
865 if (wndPtr->dwExStyle & WS_EX_TOOLWINDOW)
866 rect.top += GetSystemMetrics(SM_CYSMCAPTION) - 1;
867 else
868 rect.top += GetSystemMetrics(SM_CYCAPTION) - 1;
869 if (!PtInRect16( &rect, pt ))
870 {
871 /* Check system menu */
872 if(wndPtr->dwStyle & WS_SYSMENU)
873 {
874 if (NC_IconForWindow(wndPtr))
875 rect.left += GetSystemMetrics(SM_CYCAPTION) - 1;
876 }
877 if (pt.x < rect.left) return HTSYSMENU;
878
879 /* Check close button */
880 if (wndPtr->dwStyle & WS_SYSMENU)
881 rect.right -= GetSystemMetrics(SM_CYCAPTION) - 1;
882 if (pt.x > rect.right) return HTCLOSE;
883
884 /* Check maximize box */
885 /* In win95 there is automatically a Maximize button when there is a minimize one*/
886 if ((wndPtr->dwStyle & WS_MAXIMIZEBOX)|| (wndPtr->dwStyle & WS_MINIMIZEBOX))
887 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
888 if (pt.x > rect.right) return HTMAXBUTTON;
889
890 /* Check minimize box */
891 /* In win95 there is automatically a Maximize button when there is a Maximize one*/
892 if ((wndPtr->dwStyle & WS_MINIMIZEBOX)||(wndPtr->dwStyle & WS_MAXIMIZEBOX))
893 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
894
895 if (pt.x > rect.right) return HTMINBUTTON;
896 return HTCAPTION;
897 }
898 }
899 }
900
901 /* Check client area */
902
903 ScreenToClient16( wndPtr->hwndSelf, &pt );
904 GetClientRect16( wndPtr->hwndSelf, &rect );
905 if (PtInRect16( &rect, pt )) return HTCLIENT;
906
907 /* Check vertical scroll bar */
908
909 if (wndPtr->dwStyle & WS_VSCROLL)
910 {
911 rect.right += GetSystemMetrics(SM_CXVSCROLL);
912 if (PtInRect16( &rect, pt )) return HTVSCROLL;
913 }
914
915 /* Check horizontal scroll bar */
916
917 if (wndPtr->dwStyle & WS_HSCROLL)
918 {
919 rect.bottom += GetSystemMetrics(SM_CYHSCROLL);
920 if (PtInRect16( &rect, pt ))
921 {
922 /* Check size box */
923 if ((wndPtr->dwStyle & WS_VSCROLL) &&
924 (pt.x >= rect.right - GetSystemMetrics(SM_CXVSCROLL)))
925 return HTSIZE;
926 return HTHSCROLL;
927 }
928 }
929
930 /* Check menu bar */
931
932 if (HAS_MENU(wndPtr))
933 {
934 if ((pt.y < 0) && (pt.x >= 0) && (pt.x < rect.right))
935 return HTMENU;
936 }
937
938 /* Has to return HTNOWHERE if nothing was found
939 Could happen when a window has a customized non client area */
940 return HTNOWHERE;
941 }
942
943
944 /***********************************************************************
945 * NC_HandleNCHitTest
946 *
947 * Handle a WM_NCHITTEST message. Called from DefWindowProc().
948 */
949 LONG
950 NC_HandleNCHitTest (HWND hwnd , POINT16 pt)
951 {
952 LONG retvalue;
953 WND *wndPtr = WIN_FindWndPtr (hwnd);
954
955 if (!wndPtr)
956 return HTERROR;
957
958 if (TWEAK_WineLook == WIN31_LOOK)
959 retvalue = NC_DoNCHitTest (wndPtr, pt);
960 else
961 retvalue = NC_DoNCHitTest95 (wndPtr, pt);
962 WIN_ReleaseWndPtr(wndPtr);
963 return retvalue;
964 }
965
966
967 /***********************************************************************
968 * NC_DrawSysButton
969 */
970 void NC_DrawSysButton( HWND hwnd, HDC hdc, BOOL down )
971 {
972 RECT rect;
973 HDC hdcMem;
974 HBITMAP hbitmap;
975 WND *wndPtr = WIN_FindWndPtr( hwnd );
976
977 if( !(wndPtr->flags & WIN_MANAGED) )
978 {
979 NC_GetInsideRect( hwnd, &rect );
980 hdcMem = CreateCompatibleDC( hdc );
981 hbitmap = SelectObject( hdcMem, hbitmapClose );
982 BitBlt(hdc, rect.left, rect.top, GetSystemMetrics(SM_CXSIZE), GetSystemMetrics(SM_CYSIZE),
983 hdcMem, (wndPtr->dwStyle & WS_CHILD) ? GetSystemMetrics(SM_CXSIZE) : 0, 0,
984 down ? NOTSRCCOPY : SRCCOPY );
985 SelectObject( hdcMem, hbitmap );
986 DeleteDC( hdcMem );
987 }
988 WIN_ReleaseWndPtr(wndPtr);
989 }
990
991
992 /***********************************************************************
993 * NC_DrawMaxButton
994 */
995 static void NC_DrawMaxButton( HWND hwnd, HDC16 hdc, BOOL down )
996 {
997 RECT rect;
998 WND *wndPtr = WIN_FindWndPtr( hwnd );
999 HDC hdcMem;
1000
1001 if( !(wndPtr->flags & WIN_MANAGED) )
1002 {
1003 NC_GetInsideRect( hwnd, &rect );
1004 hdcMem = CreateCompatibleDC( hdc );
1005 SelectObject( hdcMem, (IsZoomed(hwnd)
1006 ? (down ? hbitmapRestoreD : hbitmapRestore)
1007 : (down ? hbitmapMaximizeD : hbitmapMaximize)) );
1008 BitBlt( hdc, rect.right - GetSystemMetrics(SM_CXSIZE) - 1, rect.top,
1009 GetSystemMetrics(SM_CXSIZE) + 1, GetSystemMetrics(SM_CYSIZE), hdcMem, 0, 0,
1010 SRCCOPY );
1011 DeleteDC( hdcMem );
1012 }
1013 WIN_ReleaseWndPtr(wndPtr);
1014
1015 }
1016
1017
1018 /***********************************************************************
1019 * NC_DrawMinButton
1020 */
1021 static void NC_DrawMinButton( HWND hwnd, HDC16 hdc, BOOL down )
1022 {
1023 RECT rect;
1024 WND *wndPtr = WIN_FindWndPtr( hwnd );
1025 HDC hdcMem;
1026
1027 if( !(wndPtr->flags & WIN_MANAGED) )
1028 {
1029 NC_GetInsideRect( hwnd, &rect );
1030 hdcMem = CreateCompatibleDC( hdc );
1031 SelectObject( hdcMem, (down ? hbitmapMinimizeD : hbitmapMinimize) );
1032 if (wndPtr->dwStyle & WS_MAXIMIZEBOX) rect.right -= GetSystemMetrics(SM_CXSIZE)+1;
1033 BitBlt( hdc, rect.right - GetSystemMetrics(SM_CXSIZE) - 1, rect.top,
1034 GetSystemMetrics(SM_CXSIZE) + 1, GetSystemMetrics(SM_CYSIZE), hdcMem, 0, 0,
1035 SRCCOPY );
1036 DeleteDC( hdcMem );
1037 }
1038 WIN_ReleaseWndPtr(wndPtr);
1039 }
1040
1041
1042 /******************************************************************************
1043 *
1044 * void NC_DrawSysButton95(
1045 * HWND hwnd,
1046 * HDC hdc,
1047 * BOOL down )
1048 *
1049 * Draws the Win95 system icon.
1050 *
1051 * Revision history
1052 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1053 * Original implementation from NC_DrawSysButton source.
1054 * 11-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1055 * Fixed most bugs.
1056 *
1057 *****************************************************************************/
1058
1059 BOOL
1060 NC_DrawSysButton95 (HWND hwnd, HDC hdc, BOOL down)
1061 {
1062 WND *wndPtr = WIN_FindWndPtr( hwnd );
1063
1064 if( !(wndPtr->flags & WIN_MANAGED) )
1065 {
1066 HICON hIcon;
1067 RECT rect;
1068
1069 NC_GetInsideRect95( hwnd, &rect );
1070
1071 hIcon = NC_IconForWindow( wndPtr );
1072
1073 if (hIcon)
1074 DrawIconEx (hdc, rect.left + 2, rect.top + 2, hIcon,
1075 GetSystemMetrics(SM_CXSMICON),
1076 GetSystemMetrics(SM_CYSMICON),
1077 0, 0, DI_NORMAL);
1078
1079 WIN_ReleaseWndPtr(wndPtr);
1080 return (hIcon != 0);
1081 }
1082 WIN_ReleaseWndPtr(wndPtr);
1083 return FALSE;
1084 }
1085
1086
1087 /******************************************************************************
1088 *
1089 * void NC_DrawCloseButton95(
1090 * HWND hwnd,
1091 * HDC hdc,
1092 * BOOL down,
1093 * BOOL bGrayed )
1094 *
1095 * Draws the Win95 close button.
1096 *
1097 * If bGrayed is true, then draw a disabled Close button
1098 *
1099 * Revision history
1100 * 11-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1101 * Original implementation from NC_DrawSysButton95 source.
1102 *
1103 *****************************************************************************/
1104
1105 static void NC_DrawCloseButton95 (HWND hwnd, HDC hdc, BOOL down, BOOL bGrayed)
1106 {
1107 RECT rect;
1108 HDC hdcMem;
1109 WND *wndPtr = WIN_FindWndPtr( hwnd );
1110
1111 if( !(wndPtr->flags & WIN_MANAGED) )
1112 {
1113 BITMAP bmp;
1114 HBITMAP hBmp, hOldBmp;
1115
1116 NC_GetInsideRect95( hwnd, &rect );
1117
1118 /* A tool window has a smaller Close button */
1119 if(wndPtr->dwExStyle & WS_EX_TOOLWINDOW)
1120 {
1121 RECT toolRect;
1122 INT iBmpHeight = 11; /* Windows does not use SM_CXSMSIZE and SM_CYSMSIZE */
1123 INT iBmpWidth = 11; /* it uses 11x11 for the close button in tool window */
1124 INT iCaptionHeight = GetSystemMetrics(SM_CYSMCAPTION);
1125
1126 toolRect.top = rect.top + (iCaptionHeight - 1 - iBmpHeight) / 2;
1127 toolRect.left = rect.right - (iCaptionHeight + 1 + iBmpWidth) / 2;
1128 toolRect.bottom = toolRect.top + iBmpHeight;
1129 toolRect.right = toolRect.left + iBmpWidth;
1130 DrawFrameControl(hdc,&toolRect,
1131 DFC_CAPTION,DFCS_CAPTIONCLOSE |
1132 down ? DFCS_PUSHED : 0 |
1133 bGrayed ? DFCS_INACTIVE : 0);
1134 }
1135 else
1136 {
1137 hdcMem = CreateCompatibleDC( hdc );
1138 hBmp = down ? hbitmapCloseD : hbitmapClose;
1139 hOldBmp = SelectObject (hdcMem, hBmp);
1140 GetObjectA (hBmp, sizeof(BITMAP), &bmp);
1141
1142 BitBlt (hdc, rect.right - (GetSystemMetrics(SM_CYCAPTION) + 1 + bmp.bmWidth) / 2,
1143 rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2,
1144 bmp.bmWidth, bmp.bmHeight, hdcMem, 0, 0, SRCCOPY);
1145
1146 if(bGrayed)
1147 NC_DrawGrayButton(hdc,rect.right - (GetSystemMetrics(SM_CYCAPTION) + 1 + bmp.bmWidth) / 2 + 2,
1148 rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2 + 2);
1149
1150 SelectObject (hdcMem, hOldBmp);
1151 DeleteDC (hdcMem);
1152 }
1153 }
1154 WIN_ReleaseWndPtr(wndPtr);
1155 }
1156
1157 /******************************************************************************
1158 *
1159 * NC_DrawMaxButton95(
1160 * HWND hwnd,
1161 * HDC16 hdc,
1162 * BOOL down
1163 * BOOL bGrayed )
1164 *
1165 * Draws the maximize button for Win95 style windows.
1166 *
1167 * If bGrayed is true, then draw a disabled Maximize button
1168 *
1169 * Bugs
1170 * Many. Spacing might still be incorrect. Need to fit a close
1171 * button between the max button and the edge.
1172 * Should scale the image with the title bar. And more...
1173 *
1174 * Revision history
1175 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1176 * Original implementation.
1177 *
1178 *****************************************************************************/
1179
1180 static void NC_DrawMaxButton95(HWND hwnd,HDC16 hdc,BOOL down, BOOL bGrayed)
1181 {
1182 RECT rect;
1183 HDC hdcMem;
1184 WND *wndPtr = WIN_FindWndPtr( hwnd );
1185
1186 if( !(wndPtr->flags & WIN_MANAGED))
1187 {
1188 BITMAP bmp;
1189 HBITMAP hBmp,hOldBmp;
1190
1191 NC_GetInsideRect95( hwnd, &rect );
1192 hdcMem = CreateCompatibleDC( hdc );
1193 hBmp = IsZoomed(hwnd) ?
1194 (down ? hbitmapRestoreD : hbitmapRestore ) :
1195 (down ? hbitmapMaximizeD: hbitmapMaximize);
1196 hOldBmp=SelectObject( hdcMem, hBmp );
1197 GetObjectA (hBmp, sizeof(BITMAP), &bmp);
1198
1199 if (wndPtr->dwStyle & WS_SYSMENU)
1200 rect.right -= GetSystemMetrics(SM_CYCAPTION) + 1;
1201
1202 BitBlt( hdc, rect.right - (GetSystemMetrics(SM_CXSIZE) + bmp.bmWidth) / 2,
1203 rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2,
1204 bmp.bmWidth, bmp.bmHeight, hdcMem, 0, 0, SRCCOPY );
1205
1206 if(bGrayed)
1207 NC_DrawGrayButton(hdc, rect.right - (GetSystemMetrics(SM_CXSIZE) + bmp.bmWidth) / 2 + 2,
1208 rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2 + 2);
1209
1210
1211 SelectObject (hdcMem, hOldBmp);
1212 DeleteDC( hdcMem );
1213 }
1214 WIN_ReleaseWndPtr(wndPtr);
1215 }
1216
1217 /******************************************************************************
1218 *
1219 * NC_DrawMinButton95(
1220 * HWND hwnd,
1221 * HDC16 hdc,
1222 * BOOL down,
1223 * BOOL bGrayed )
1224 *
1225 * Draws the minimize button for Win95 style windows.
1226 *
1227 * If bGrayed is true, then draw a disabled Minimize button
1228 *
1229 * Bugs
1230 * Many. Spacing is still incorrect. Should scale the image with the
1231 * title bar. And more...
1232 *
1233 * Revision history
1234 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1235 * Original implementation.
1236 *
1237 *****************************************************************************/
1238
1239 static void NC_DrawMinButton95(HWND hwnd,HDC16 hdc,BOOL down, BOOL bGrayed)
1240 {
1241 RECT rect;
1242 HDC hdcMem;
1243 WND *wndPtr = WIN_FindWndPtr( hwnd );
1244
1245 if( !(wndPtr->flags & WIN_MANAGED))
1246
1247 {
1248 BITMAP bmp;
1249 HBITMAP hBmp,hOldBmp;
1250
1251 NC_GetInsideRect95( hwnd, &rect );
1252
1253 hdcMem = CreateCompatibleDC( hdc );
1254 hBmp = down ? hbitmapMinimizeD : hbitmapMinimize;
1255 hOldBmp= SelectObject( hdcMem, hBmp );
1256 GetObjectA (hBmp, sizeof(BITMAP), &bmp);
1257
1258 if (wndPtr->dwStyle & WS_SYSMENU)
1259 rect.right -= GetSystemMetrics(SM_CYCAPTION) + 1;
1260
1261 /* In win 95 there is always a Maximize box when there is a Minimize one */
1262 if ((wndPtr->dwStyle & WS_MAXIMIZEBOX) || (wndPtr->dwStyle & WS_MINIMIZEBOX))
1263 rect.right += -1 - (GetSystemMetrics(SM_CXSIZE) + bmp.bmWidth) / 2;
1264
1265 BitBlt( hdc, rect.right - (GetSystemMetrics(SM_CXSIZE) + bmp.bmWidth) / 2,
1266 rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2,
1267 bmp.bmWidth, bmp.bmHeight, hdcMem, 0, 0, SRCCOPY );
1268
1269 if(bGrayed)
1270 NC_DrawGrayButton(hdc, rect.right - (GetSystemMetrics(SM_CXSIZE) + bmp.bmWidth) / 2 + 2,
1271 rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2 + 2);
1272
1273
1274 SelectObject (hdcMem, hOldBmp);
1275 DeleteDC( hdcMem );
1276 }
1277 WIN_ReleaseWndPtr(wndPtr);
1278 }
1279
1280 /***********************************************************************
1281 * NC_DrawFrame
1282 *
1283 * Draw a window frame inside the given rectangle, and update the rectangle.
1284 * The correct pen for the frame must be selected in the DC.
1285 */
1286 static void NC_DrawFrame( HDC hdc, RECT *rect, BOOL dlgFrame,
1287 BOOL active )
1288 {
1289 INT width, height;
1290
1291 if (TWEAK_WineLook != WIN31_LOOK)
1292 ERR("Called in Win95 mode. Aiee! Please report this.\n" );
1293
1294 if (dlgFrame)
1295 {
1296 width = GetSystemMetrics(SM_CXDLGFRAME) - 1;
1297 height = GetSystemMetrics(SM_CYDLGFRAME) - 1;
1298 SelectObject( hdc, GetSysColorBrush(active ? COLOR_ACTIVECAPTION :
1299 COLOR_INACTIVECAPTION) );
1300 }
1301 else
1302 {
1303 width = GetSystemMetrics(SM_CXFRAME) - 2;
1304 height = GetSystemMetrics(SM_CYFRAME) - 2;
1305 SelectObject( hdc, GetSysColorBrush(active ? COLOR_ACTIVEBORDER :
1306 COLOR_INACTIVEBORDER) );
1307 }
1308
1309 /* Draw frame */
1310 PatBlt( hdc, rect->left, rect->top,
1311 rect->right - rect->left, height, PATCOPY );
1312 PatBlt( hdc, rect->left, rect->top,
1313 width, rect->bottom - rect->top, PATCOPY );
1314 PatBlt( hdc, rect->left, rect->bottom - 1,
1315 rect->right - rect->left, -height, PATCOPY );
1316 PatBlt( hdc, rect->right - 1, rect->top,
1317 -width, rect->bottom - rect->top, PATCOPY );
1318
1319 if (dlgFrame)
1320 {
1321 InflateRect( rect, -width, -height );
1322 }
1323 else
1324 {
1325 INT decYOff = GetSystemMetrics(SM_CXFRAME) + GetSystemMetrics(SM_CXSIZE) - 1;
1326 INT decXOff = GetSystemMetrics(SM_CYFRAME) + GetSystemMetrics(SM_CYSIZE) - 1;
1327
1328 /* Draw inner rectangle */
1329
1330 SelectObject( hdc, GetStockObject(NULL_BRUSH) );
1331 Rectangle( hdc, rect->left + width, rect->top + height,
1332 rect->right - width , rect->bottom - height );
1333
1334 /* Draw the decorations */
1335
1336 MoveToEx( hdc, rect->left, rect->top + decYOff, NULL );
1337 LineTo( hdc, rect->left + width, rect->top + decYOff );
1338 MoveToEx( hdc, rect->right - 1, rect->top + decYOff, NULL );
1339 LineTo( hdc, rect->right - width - 1, rect->top + decYOff );
1340 MoveToEx( hdc, rect->left, rect->bottom - decYOff, NULL );
1341 LineTo( hdc, rect->left + width, rect->bottom - decYOff );
1342 MoveToEx( hdc, rect->right - 1, rect->bottom - decYOff, NULL );
1343 LineTo( hdc, rect->right - width - 1, rect->bottom - decYOff );
1344
1345 MoveToEx( hdc, rect->left + decXOff, rect->top, NULL );
1346 LineTo( hdc, rect->left + decXOff, rect->top + height);
1347 MoveToEx( hdc, rect->left + decXOff, rect->bottom - 1, NULL );
1348 LineTo( hdc, rect->left + decXOff, rect->bottom - height - 1 );
1349 MoveToEx( hdc, rect->right - decXOff, rect->top, NULL );
1350 LineTo( hdc, rect->right - decXOff, rect->top + height );
1351 MoveToEx( hdc, rect->right - decXOff, rect->bottom - 1, NULL );
1352 LineTo( hdc, rect->right - decXOff, rect->bottom - height - 1 );
1353
1354 InflateRect( rect, -width - 1, -height - 1 );
1355 }
1356 }
1357
1358
1359 /******************************************************************************
1360 *
1361 * void NC_DrawFrame95(
1362 * HDC hdc,
1363 * RECT *rect,
1364 * BOOL dlgFrame,
1365 * BOOL active )
1366 *
1367 * Draw a window frame inside the given rectangle, and update the rectangle.
1368 * The correct pen for the frame must be selected in the DC.
1369 *
1370 * Bugs
1371 * Many. First, just what IS a frame in Win95? Note that the 3D look
1372 * on the outer edge is handled by NC_DoNCPaint95. As is the inner
1373 * edge. The inner rectangle just inside the frame is handled by the
1374 * Caption code.
1375 *
1376 * In short, for most people, this function should be a nop (unless
1377 * you LIKE thick borders in Win95/NT4.0 -- I've been working with
1378 * them lately, but just to get this code right). Even so, it doesn't
1379 * appear to be so. It's being worked on...
1380 *
1381 * Revision history
1382 * 06-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1383 * Original implementation (based on NC_DrawFrame)
1384 * 02-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1385 * Some minor fixes.
1386 * 29-Jun-1999 Ove Kåven (ovek@arcticnet.no)
1387 * Fixed a fix or something.
1388 *
1389 *****************************************************************************/
1390
1391 static void NC_DrawFrame95(
1392 HDC hdc,
1393 RECT *rect,
1394 BOOL dlgFrame,
1395 BOOL active )
1396 {
1397 INT width, height;
1398
1399 if (dlgFrame)
1400 {
1401 width = GetSystemMetrics(SM_CXDLGFRAME) - GetSystemMetrics(SM_CXEDGE);
1402 height = GetSystemMetrics(SM_CYDLGFRAME) - GetSystemMetrics(SM_CYEDGE);
1403 }
1404 else
1405 {
1406 width = GetSystemMetrics(SM_CXFRAME) - GetSystemMetrics(SM_CXEDGE);
1407 height = GetSystemMetrics(SM_CYFRAME) - GetSystemMetrics(SM_CYEDGE);
1408 }
1409
1410 SelectObject( hdc, GetSysColorBrush(active ? COLOR_ACTIVEBORDER :
1411 COLOR_INACTIVEBORDER) );
1412
1413 /* Draw frame */
1414 PatBlt( hdc, rect->left, rect->top,
1415 rect->right - rect->left, height, PATCOPY );
1416 PatBlt( hdc, rect->left, rect->top,
1417 width, rect->bottom - rect->top, PATCOPY );
1418 PatBlt( hdc, rect->left, rect->bottom - 1,
1419 rect->right - rect->left, -height, PATCOPY );
1420 PatBlt( hdc, rect->right - 1, rect->top,
1421 -width, rect->bottom - rect->top, PATCOPY );
1422
1423 InflateRect( rect, -width, -height );
1424 }
1425
1426 /***********************************************************************
1427 * NC_DrawMovingFrame
1428 *
1429 * Draw the frame used when moving or resizing window.
1430 *
1431 * FIXME: This causes problems in Win95 mode. (why?)
1432 */
1433 static void NC_DrawMovingFrame( HDC hdc, RECT *rect, BOOL thickframe )
1434 {
1435 if (thickframe)
1436 {
1437 RECT16 r16;
1438 CONV_RECT32TO16( rect, &r16 );
1439 FastWindowFrame16( hdc, &r16, GetSystemMetrics(SM_CXFRAME),
1440 GetSystemMetrics(SM_CYFRAME), PATINVERT );
1441 }
1442 else DrawFocusRect( hdc, rect );
1443 }
1444
1445
1446 /***********************************************************************
1447 * NC_DrawCaption
1448 *
1449 * Draw the window caption.
1450 * The correct pen for the window frame must be selected in the DC.
1451 */
1452 static void NC_DrawCaption( HDC hdc, RECT *rect, HWND hwnd,
1453 DWORD style, BOOL active )
1454 {
1455 RECT r = *rect;
1456 WND * wndPtr = WIN_FindWndPtr( hwnd );
1457 char buffer[256];
1458
1459 if (wndPtr->flags & WIN_MANAGED)
1460 {
1461 WIN_ReleaseWndPtr(wndPtr);
1462 return;
1463 }
1464
1465 if (!hbitmapClose)
1466 {
1467 if (!(hbitmapClose = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_CLOSE) )))
1468 {
1469 WIN_ReleaseWndPtr(wndPtr);
1470 return;
1471 }
1472 hbitmapCloseD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_CLOSED) );
1473 hbitmapMinimize = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_REDUCE) );
1474 hbitmapMinimizeD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_REDUCED) );
1475 hbitmapMaximize = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_ZOOM) );
1476 hbitmapMaximizeD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_ZOOMD) );
1477 hbitmapRestore = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_RESTORE) );
1478 hbitmapRestoreD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_RESTORED) );
1479 }
1480
1481 if (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME)
1482 {
1483 HBRUSH hbrushOld = SelectObject(hdc, GetSysColorBrush(COLOR_WINDOW) );
1484 PatBlt( hdc, r.left, r.top, 1, r.bottom-r.top+1,PATCOPY );
1485 PatBlt( hdc, r.right-1, r.top, 1, r.bottom-r.top+1, PATCOPY );
1486 PatBlt( hdc, r.left, r.top-1, r.right-r.left, 1, PATCOPY );
1487 r.left++;
1488 r.right--;
1489 SelectObject( hdc, hbrushOld );
1490 }
1491 WIN_ReleaseWndPtr(wndPtr);
1492 MoveTo16( hdc, r.left, r.bottom );
1493 LineTo( hdc, r.right, r.bottom );
1494
1495 if (style & WS_SYSMENU)
1496 {
1497 NC_DrawSysButton( hwnd, hdc, FALSE );
1498 r.left += GetSystemMetrics(SM_CXSIZE) + 1;
1499 MoveTo16( hdc, r.left - 1, r.top );
1500 LineTo( hdc, r.left - 1, r.bottom );
1501 }
1502 if (style & WS_MAXIMIZEBOX)
1503 {
1504 NC_DrawMaxButton( hwnd, hdc, FALSE );
1505 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1506 }
1507 if (style & WS_MINIMIZEBOX)
1508 {
1509 NC_DrawMinButton( hwnd, hdc, FALSE );
1510 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1511 }
1512
1513 FillRect( hdc, &r, GetSysColorBrush(active ? COLOR_ACTIVECAPTION :
1514 COLOR_INACTIVECAPTION) );
1515
1516 if (GetWindowTextA( hwnd, buffer, sizeof(buffer) ))
1517 {
1518 if (active) SetTextColor( hdc, GetSysColor( COLOR_CAPTIONTEXT ) );
1519 else SetTextColor( hdc, GetSysColor( COLOR_INACTIVECAPTIONTEXT ) );
1520 SetBkMode( hdc, TRANSPARENT );
1521 DrawTextA( hdc, buffer, -1, &r,
1522 DT_SINGLELINE | DT_CENTER | DT_VCENTER | DT_NOPREFIX );
1523 }
1524 }
1525
1526
1527 /******************************************************************************
1528 *
1529 * NC_DrawCaption95(
1530 * HDC hdc,
1531 * RECT *rect,
1532 * HWND hwnd,
1533 * DWORD style,
1534 * BOOL active )
1535 *
1536 * Draw the window caption for Win95 style windows.
1537 * The correct pen for the window frame must be selected in the DC.
1538 *
1539 * Bugs
1540 * Hey, a function that finally works! Well, almost.
1541 * It's being worked on.
1542 *
1543 * Revision history
1544 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1545 * Original implementation.
1546 * 02-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1547 * Some minor fixes.
1548 *
1549 *****************************************************************************/
1550
1551 static void NC_DrawCaption95(
1552 HDC hdc,
1553 RECT *rect,
1554 HWND hwnd,
1555 DWORD style,
1556 DWORD exStyle,
1557 BOOL active )
1558 {
1559 RECT r = *rect;
1560 WND *wndPtr = WIN_FindWndPtr( hwnd );
1561 char buffer[256];
1562 HPEN hPrevPen;
1563 HMENU hSysMenu;
1564
1565 if (wndPtr->flags & WIN_MANAGED)
1566 {
1567 WIN_ReleaseWndPtr(wndPtr);
1568 return;
1569 }
1570 WIN_ReleaseWndPtr(wndPtr);
1571
1572 hPrevPen = SelectObject( hdc, GetSysColorPen(COLOR_3DFACE) );
1573 MoveToEx( hdc, r.left, r.bottom - 1, NULL );
1574 LineTo( hdc, r.right, r.bottom - 1 );
1575 SelectObject( hdc, hPrevPen );
1576 r.bottom--;
1577
1578 FillRect( hdc, &r, GetSysColorBrush(active ? COLOR_ACTIVECAPTION :
1579 COLOR_INACTIVECAPTION) );
1580
1581 if (!hbitmapClose) {
1582 if (!(hbitmapClose = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_CLOSE) )))
1583 return;
1584 hbitmapCloseD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_CLOSED));
1585 hbitmapMinimize = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_REDUCE) );
1586 hbitmapMinimizeD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_REDUCED) );
1587 hbitmapMaximize = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_ZOOM) );
1588 hbitmapMaximizeD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_ZOOMD) );
1589 hbitmapRestore = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_RESTORE) );
1590 hbitmapRestoreD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_RESTORED) );
1591 }
1592
1593 if ((style & WS_SYSMENU) && !(exStyle & WS_EX_TOOLWINDOW)) {
1594 if (NC_DrawSysButton95 (hwnd, hdc, FALSE))
1595 r.left += GetSystemMetrics(SM_CYCAPTION) - 1;
1596 }
1597
1598 if (style & WS_SYSMENU)
1599 {
1600 UINT state;
1601
1602 /* Go get the sysmenu */
1603 hSysMenu = GetSystemMenu(hwnd, FALSE);
1604 state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
1605
1606 /* Draw a grayed close button if disabled and a normal one if SC_CLOSE is not there */
1607 NC_DrawCloseButton95 (hwnd, hdc, FALSE,
1608 ((((state & MF_DISABLED) || (state & MF_GRAYED))) && (state != 0xFFFFFFFF)));
1609 r.right -= GetSystemMetrics(SM_CYCAPTION) - 1;
1610
1611 if ((style & WS_MAXIMIZEBOX) || (style & WS_MINIMIZEBOX))
1612 {
1613 /* In win95 the two buttons are always there */
1614 /* But if the menu item is not in the menu they're disabled*/
1615
1616 NC_DrawMaxButton95( hwnd, hdc, FALSE, (!(style & WS_MAXIMIZEBOX)));
1617 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1618
1619 NC_DrawMinButton95( hwnd, hdc, FALSE, (!(style & WS_MINIMIZEBOX)));
1620 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1621 }
1622 }
1623
1624 if (GetWindowTextA( hwnd, buffer, sizeof(buffer) )) {
1625 NONCLIENTMETRICSA nclm;
1626 HFONT hFont, hOldFont;
1627 nclm.cbSize = sizeof(NONCLIENTMETRICSA);
1628 SystemParametersInfoA (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0);
1629 if (exStyle & WS_EX_TOOLWINDOW)
1630 hFont = CreateFontIndirectA (&nclm.lfSmCaptionFont);
1631 else
1632 hFont = CreateFontIndirectA (&nclm.lfCaptionFont);
1633 hOldFont = SelectObject (hdc, hFont);
1634 if (active) SetTextColor( hdc, GetSysColor( COLOR_CAPTIONTEXT ) );
1635 else SetTextColor( hdc, GetSysColor( COLOR_INACTIVECAPTIONTEXT ) );
1636 SetBkMode( hdc, TRANSPARENT );
1637 r.left += 2;
1638 DrawTextA( hdc, buffer, -1, &r,
1639 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT );
1640 DeleteObject (SelectObject (hdc, hOldFont));
1641 }
1642 }
1643
1644
1645
1646 /***********************************************************************
1647 * NC_DoNCPaint
1648 *
1649 * Paint the non-client area. clip is currently unused.
1650 */
1651 static void NC_DoNCPaint( WND* wndPtr, HRGN clip, BOOL suppress_menupaint )
1652 {
1653 HDC hdc;
1654 RECT rect;
1655 BOOL active;
1656 HWND hwnd = wndPtr->hwndSelf;
1657
1658 if ( wndPtr->dwStyle & WS_MINIMIZE ||
1659 !WIN_IsWindowDrawable( wndPtr, 0 )) return; /* Nothing to do */
1660
1661 active = wndPtr->flags & WIN_NCACTIVATED;
1662
1663 TRACE("%04x %d\n", hwnd, active );
1664
1665 if (!(hdc = GetDCEx( hwnd, (clip > 1) ? clip : 0, DCX_USESTYLE | DCX_WINDOW |
1666 ((clip > 1) ? (DCX_INTERSECTRGN | DCX_KEEPCLIPRGN): 0) ))) return;
1667
1668 if (ExcludeVisRect16( hdc, wndPtr->rectClient.left-wndPtr->rectWindow.left,
1669 wndPtr->rectClient.top-wndPtr->rectWindow.top,
1670 wndPtr->rectClient.right-wndPtr->rectWindow.left,
1671 wndPtr->rectClient.bottom-wndPtr->rectWindow.top )
1672 == NULLREGION)
1673 {
1674 ReleaseDC( hwnd, hdc );
1675 return;
1676 }
1677
1678 rect.top = rect.left = 0;
1679 rect.right = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
1680 rect.bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
1681
1682 SelectObject( hdc, GetSysColorPen(COLOR_WINDOWFRAME) );
1683
1684 if (!(wndPtr->flags & WIN_MANAGED))
1685 {
1686 if (HAS_ANYFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
1687 {
1688 SelectObject( hdc, GetStockObject(NULL_BRUSH) );
1689 Rectangle( hdc, 0, 0, rect.right, rect.bottom );
1690 InflateRect( &rect, -1, -1 );
1691 }
1692
1693 if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
1694 NC_DrawFrame(hdc, &rect, FALSE, active );
1695 else if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
1696 NC_DrawFrame( hdc, &rect, TRUE, active );
1697
1698 if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
1699 {
1700 RECT r = rect;
1701 r.bottom = rect.top + GetSystemMetrics(SM_CYSIZE);
1702 rect.top += GetSystemMetrics(SM_CYSIZE) + GetSystemMetrics(SM_CYBORDER);
1703 NC_DrawCaption( hdc, &r, hwnd, wndPtr->dwStyle, active );
1704 }
1705 }
1706
1707 if (HAS_MENU(wndPtr))
1708 {
1709 RECT r = rect;
1710 r.bottom = rect.top + GetSystemMetrics(SM_CYMENU); /* default height */
1711 rect.top += MENU_DrawMenuBar( hdc, &r, hwnd, suppress_menupaint );
1712 }
1713
1714 /* Draw the scroll-bars */
1715
1716 if (wndPtr->dwStyle & WS_VSCROLL)
1717 SCROLL_DrawScrollBar( hwnd, hdc, SB_VERT, TRUE, TRUE );
1718 if (wndPtr->dwStyle & WS_HSCROLL)
1719 SCROLL_DrawScrollBar( hwnd, hdc, SB_HORZ, TRUE, TRUE );
1720
1721 /* Draw the "size-box" */
1722
1723 if ((wndPtr->dwStyle & WS_VSCROLL) && (wndPtr->dwStyle & WS_HSCROLL))
1724 {
1725 RECT r = rect;
1726 r.left = r.right - GetSystemMetrics(SM_CXVSCROLL) + 1;
1727 r.top = r.bottom - GetSystemMetrics(SM_CYHSCROLL) + 1;
1728 if(wndPtr->dwStyle & WS_BORDER) {
1729 r.left++;
1730 r.top++;
1731 }
1732 FillRect( hdc, &r, GetSysColorBrush(COLOR_SCROLLBAR) );
1733 }
1734
1735 ReleaseDC( hwnd, hdc );
1736 }
1737
1738
1739 /******************************************************************************
1740 *
1741 * void NC_DoNCPaint95(
1742 * WND *wndPtr,
1743 * HRGN clip,
1744 * BOOL suppress_menupaint )
1745 *
1746 * Paint the non-client area for Win95 windows. The clip region is
1747 * currently ignored.
1748 *
1749 * Bugs
1750 * grep -E -A10 -B5 \(95\)\|\(Bugs\)\|\(FIXME\) windows/nonclient.c \
1751 * misc/tweak.c controls/menu.c # :-)
1752 *
1753 * Revision history
1754 * 03-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1755 * Original implementation
1756 * 10-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1757 * Fixed some bugs.
1758 * 29-Jun-1999 Ove Kåven (ovek@arcticnet.no)
1759 * Streamlined window style checks.
1760 *
1761 *****************************************************************************/
1762
1763 static void NC_DoNCPaint95(
1764 WND *wndPtr,
1765 HRGN clip,
1766 BOOL suppress_menupaint )
1767 {
1768 HDC hdc;
1769 RECT rfuzz, rect, rectClip;
1770 BOOL active;
1771 HWND hwnd = wndPtr->hwndSelf;
1772
1773 if ( wndPtr->dwStyle & WS_MINIMIZE ||
1774 !WIN_IsWindowDrawable( wndPtr, 0 )) return; /* Nothing to do */
1775
1776 active = wndPtr->flags & WIN_NCACTIVATED;
1777
1778 TRACE("%04x %d\n", hwnd, active );
1779
1780 /* MSDN docs are pretty idiotic here, they say app CAN use clipRgn in
1781 the call to GetDCEx implying that it is allowed not to use it either.
1782 However, the suggested GetDCEx( , DCX_WINDOW | DCX_INTERSECTRGN)
1783 will cause clipRgn to be deleted after ReleaseDC().
1784 Now, how is the "system" supposed to tell what happened?
1785 */
1786
1787 if (!(hdc = GetDCEx( hwnd, (clip > 1) ? clip : 0, DCX_USESTYLE | DCX_WINDOW |
1788 ((clip > 1) ?(DCX_INTERSECTRGN | DCX_KEEPCLIPRGN) : 0) ))) return;
1789
1790
1791 if (ExcludeVisRect16( hdc, wndPtr->rectClient.left-wndPtr->rectWindow.left,
1792 wndPtr->rectClient.top-wndPtr->rectWindow.top,
1793 wndPtr->rectClient.right-wndPtr->rectWindow.left,
1794 wndPtr->rectClient.bottom-wndPtr->rectWindow.top )
1795 == NULLREGION)
1796 {
1797 ReleaseDC( hwnd, hdc );
1798 return;
1799 }
1800
1801 rect.top = rect.left = 0;
1802 rect.right = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
1803 rect.bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
1804
1805 if( clip > 1 )
1806 GetRgnBox( clip, &rectClip );
1807 else
1808 {
1809 clip = 0;
1810 rectClip = rect;
1811 }
1812
1813 SelectObject( hdc, GetSysColorPen(COLOR_WINDOWFRAME) );
1814
1815 if(!(wndPtr->flags & WIN_MANAGED)) {
1816 if (HAS_BIGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle)) {
1817 DrawEdge (hdc, &rect, EDGE_RAISED, BF_RECT | BF_ADJUST);
1818 }
1819 if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
1820 NC_DrawFrame95(hdc, &rect, FALSE, active );
1821 else if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
1822 NC_DrawFrame95( hdc, &rect, TRUE, active );
1823 else if (HAS_THINFRAME( wndPtr->dwStyle )) {
1824 SelectObject( hdc, GetStockObject(NULL_BRUSH) );
1825 Rectangle( hdc, 0, 0, rect.right, rect.bottom );
1826 }
1827
1828 if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
1829 {
1830 RECT r = rect;
1831 if (wndPtr->dwExStyle & WS_EX_TOOLWINDOW) {
1832 r.bottom = rect.top + GetSystemMetrics(SM_CYSMCAPTION);
1833 rect.top += GetSystemMetrics(SM_CYSMCAPTION);
1834 }
1835 else {
1836 r.bottom = rect.top + GetSystemMetrics(SM_CYCAPTION);
1837 rect.top += GetSystemMetrics(SM_CYCAPTION);
1838 }
1839 if( !clip || IntersectRect( &rfuzz, &r, &rectClip ) )
1840 NC_DrawCaption95 (hdc, &r, hwnd, wndPtr->dwStyle,
1841 wndPtr->dwExStyle, active);
1842 }
1843 }
1844
1845 if (HAS_MENU(wndPtr))
1846 {
1847 RECT r = rect;
1848 r.bottom = rect.top + GetSystemMetrics(SM_CYMENU);
1849
1850 TRACE("Calling DrawMenuBar with rect (%d, %d)-(%d, %d)\n",
1851 r.left, r.top, r.right, r.bottom);
1852
1853 rect.top += MENU_DrawMenuBar( hdc, &r, hwnd, suppress_menupaint ) + 1;
1854 }
1855
1856 TRACE("After MenuBar, rect is (%d, %d)-(%d, %d).\n",
1857 rect.left, rect.top, rect.right, rect.bottom );
1858
1859 if (wndPtr->dwExStyle & WS_EX_CLIENTEDGE)
1860 DrawEdge (hdc, &rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
1861
1862 if (wndPtr->dwExStyle & WS_EX_STATICEDGE)
1863 DrawEdge (hdc, &rect, BDR_SUNKENOUTER, BF_RECT | BF_ADJUST);
1864
1865 /* Draw the scroll-bars */
1866
1867 if (wndPtr->dwStyle & WS_VSCROLL)
1868 SCROLL_DrawScrollBar( hwnd, hdc, SB_VERT, TRUE, TRUE );
1869 if (wndPtr->dwStyle & WS_HSCROLL)
1870 SCROLL_DrawScrollBar( hwnd, hdc, SB_HORZ, TRUE, TRUE );
1871
1872 /* Draw the "size-box" */
1873 if ((wndPtr->dwStyle & WS_VSCROLL) && (wndPtr->dwStyle & WS_HSCROLL))
1874 {
1875 RECT r = rect;
1876 r.left = r.right - GetSystemMetrics(SM_CXVSCROLL) + 1;
1877 r.top = r.bottom - GetSystemMetrics(SM_CYHSCROLL) + 1;
1878 FillRect( hdc, &r, GetSysColorBrush(COLOR_SCROLLBAR) );
1879 }
1880
1881 ReleaseDC( hwnd, hdc );
1882 }
1883
1884
1885
1886
1887 /***********************************************************************
1888 * NC_HandleNCPaint
1889 *
1890 * Handle a WM_NCPAINT message. Called from DefWindowProc().
1891 */
1892 LONG NC_HandleNCPaint( HWND hwnd , HRGN clip)
1893 {
1894 WND* wndPtr = WIN_FindWndPtr( hwnd );
1895
1896 if( wndPtr && wndPtr->dwStyle & WS_VISIBLE )
1897 {
1898 if( wndPtr->dwStyle & WS_MINIMIZE )
1899 WINPOS_RedrawIconTitle( hwnd );
1900 else if (TWEAK_WineLook == WIN31_LOOK)
1901 NC_DoNCPaint( wndPtr, clip, FALSE );
1902 else
1903 NC_DoNCPaint95( wndPtr, clip, FALSE );
1904 }
1905 WIN_ReleaseWndPtr(wndPtr);
1906 return 0;
1907 }
1908
1909
1910 /***********************************************************************
1911 * NC_HandleNCActivate
1912 *
1913 * Handle a WM_NCACTIVATE message. Called from DefWindowProc().
1914 */
1915 LONG NC_HandleNCActivate( WND *wndPtr, WPARAM16 wParam )
1916 {
1917 WORD wStateChange;
1918
1919 if( wParam ) wStateChange = !(wndPtr->flags & WIN_NCACTIVATED);
1920 else wStateChange = wndPtr->flags & WIN_NCACTIVATED;
1921
1922 if( wStateChange )
1923 {
1924 if (wParam) wndPtr->flags |= WIN_NCACTIVATED;
1925 else wndPtr->flags &= ~WIN_NCACTIVATED;
1926
1927 if( wndPtr->dwStyle & WS_MINIMIZE )
1928 WINPOS_RedrawIconTitle( wndPtr->hwndSelf );
1929 else if (TWEAK_WineLook == WIN31_LOOK)
1930 NC_DoNCPaint( wndPtr, (HRGN)1, FALSE );
1931 else
1932 NC_DoNCPaint95( wndPtr, (HRGN)1, FALSE );
1933 }
1934 return TRUE;
1935 }
1936
1937
1938 /***********************************************************************
1939 * NC_HandleSetCursor
1940 *
1941 * Handle a WM_SETCURSOR message. Called from DefWindowProc().
1942 */
1943 LONG NC_HandleSetCursor( HWND hwnd, WPARAM16 wParam, LPARAM lParam )
1944 {
1945 if (hwnd != (HWND)wParam) return 0; /* Don't set the cursor for child windows */
1946
1947 switch(LOWORD(lParam))
1948 {
1949 case HTERROR:
1950 {
1951 WORD msg = HIWORD( lParam );
1952 if ((msg == WM_LBUTTONDOWN) || (msg == WM_MBUTTONDOWN) ||
1953 (msg == WM_RBUTTONDOWN))
1954 MessageBeep(0);
1955 }
1956 break;
1957
1958 case HTCLIENT:
1959 {
1960 HICON16 hCursor = (HICON16) GetClassWord(hwnd, GCW_HCURSOR);
1961 if(hCursor) {
1962 SetCursor16(hCursor);
1963 return TRUE;
1964 }
1965 return FALSE;
1966 }
1967
1968 case HTLEFT:
1969 case HTRIGHT:
1970 return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZEWE16 ) );
1971
1972 case HTTOP:
1973 case HTBOTTOM:
1974 return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZENS16 ) );
1975
1976 case HTTOPLEFT:
1977 case HTBOTTOMRIGHT:
1978 return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZENWSE16 ) );
1979
1980 case HTTOPRIGHT:
1981 case HTBOTTOMLEFT:
1982 return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZENESW16 ) );
1983 }
1984
1985 /* Default cursor: arrow */
1986 return (LONG)SetCursor16( LoadCursor16( 0, IDC_ARROW16 ) );
1987 }
1988
1989 /***********************************************************************
1990 * NC_GetSysPopupPos
1991 */
1992 BOOL NC_GetSysPopupPos( WND* wndPtr, RECT* rect )
1993 {
1994 if( wndPtr->hSysMenu )
1995 {
1996 if( wndPtr->dwStyle & WS_MINIMIZE )
1997 GetWindowRect( wndPtr->hwndSelf, rect );
1998 else
1999 {
2000 if (TWEAK_WineLook == WIN31_LOOK)
2001 NC_GetInsideRect( wndPtr->hwndSelf, rect );
2002 else
2003 NC_GetInsideRect95( wndPtr->hwndSelf, rect );
2004 OffsetRect( rect, wndPtr->rectWindow.left, wndPtr->rectWindow.top);
2005 if (wndPtr->dwStyle & WS_CHILD)
2006 ClientToScreen( wndPtr->parent->hwndSelf, (POINT *)rect );
2007 if (TWEAK_WineLook == WIN31_LOOK) {
2008 rect->right = rect->left + GetSystemMetrics(SM_CXSIZE);
2009 rect->bottom = rect->top + GetSystemMetrics(SM_CYSIZE);
2010 }
2011 else {
2012 rect->right = rect->left + GetSystemMetrics(SM_CYCAPTION) - 1;
2013 rect->bottom = rect->top + GetSystemMetrics(SM_CYCAPTION) - 1;
2014 }
2015 }
2016 return TRUE;
2017 }
2018 return FALSE;
2019 }
2020
2021 /***********************************************************************
2022 * NC_StartSizeMove
2023 *
2024 * Initialisation of a move or resize, when initiatied from a menu choice.
2025 * Return hit test code for caption or sizing border.
2026 */
2027 static LONG NC_StartSizeMove( WND* wndPtr, WPARAM16 wParam,
2028 POINT16 *capturePoint )
2029 {
2030 LONG hittest = 0;
2031 POINT16 pt;
2032 MSG msg;
2033 RECT rectWindow;
2034
2035 GetWindowRect(wndPtr->hwndSelf,&rectWindow);
2036
2037 if ((wParam & 0xfff0) == SC_MOVE)
2038 {
2039 /* Move pointer at the center of the caption */
2040 RECT rect;
2041 if (TWEAK_WineLook == WIN31_LOOK)
2042 NC_GetInsideRect( wndPtr->hwndSelf, &rect );
2043 else
2044 NC_GetInsideRect95( wndPtr->hwndSelf, &rect );
2045 if (wndPtr->dwStyle & WS_SYSMENU)
2046 rect.left += GetSystemMetrics(SM_CXSIZE) + 1;
2047 if (wndPtr->dwStyle & WS_MINIMIZEBOX)
2048 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
2049 if (wndPtr->dwStyle & WS_MAXIMIZEBOX)
2050 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
2051 pt.x = rectWindow.left + (rect.right - rect.left) / 2;
2052 pt.y = rectWindow.top + rect.top + GetSystemMetrics(SM_CYSIZE)/2;
2053 hittest = HTCAPTION;
2054 *capturePoint = pt;
2055 }
2056 else /* SC_SIZE */
2057 {
2058 while(!hittest)
2059 {
2060 MSG_InternalGetMessage( QMSG_WIN32A, &msg, 0, 0, MSGF_SIZE, PM_REMOVE, FALSE, NULL );
2061 switch(msg.message)
2062 {
2063 case WM_MOUSEMOVE:
2064 CONV_POINT32TO16(&msg.pt, &pt);
2065 hittest = NC_HandleNCHitTest( wndPtr->hwndSelf, pt );
2066 if ((hittest < HTLEFT) || (hittest > HTBOTTOMRIGHT))
2067 hittest = 0;
2068 break;
2069
2070 case WM_LBUTTONUP:
2071 return 0;
2072
2073 case WM_KEYDOWN:
2074 switch(msg.wParam)
2075 {
2076 case VK_UP:
2077 hittest = HTTOP;
2078 pt.x =(rectWindow.left+rectWindow.right)/2;
2079 pt.y = rectWindow.top + GetSystemMetrics(SM_CYFRAME) / 2;
2080 break;
2081 case VK_DOWN:
2082 hittest = HTBOTTOM;
2083 pt.x =(rectWindow.left+rectWindow.right)/2;
2084 pt.y = rectWindow.bottom - GetSystemMetrics(SM_CYFRAME) / 2;
2085 break;
2086 case VK_LEFT:
2087 hittest = HTLEFT;
2088 pt.x = rectWindow.left + GetSystemMetrics(SM_CXFRAME) / 2;
2089 pt.y =(rectWindow.top+rectWindow.bottom)/2;
2090 break;
2091 case VK_RIGHT:
2092 hittest = HTRIGHT;
2093 pt.x = rectWindow.right - GetSystemMetrics(SM_CXFRAME) / 2;
2094 pt.y =(rectWindow.top+rectWindow.bottom)/2;
2095 break;
2096 case VK_RETURN:
2097 case VK_ESCAPE: return 0;
2098 }
2099 }
2100 }
2101 *capturePoint = pt;
2102 }
2103 SetCursorPos( pt.x, pt.y );
2104 NC_HandleSetCursor( wndPtr->hwndSelf,
2105 wndPtr->hwndSelf, MAKELONG( hittest, WM_MOUSEMOVE ));
2106 return hittest;
2107 }
2108
2109
2110 /***********************************************************************
2111 * NC_DoSizeMove
2112 *
2113 * Perform SC_MOVE and SC_SIZE commands. `
2114 */
2115 static void NC_DoSizeMove( HWND hwnd, WORD wParam )
2116 {
2117 MSG msg;
2118 RECT sizingRect, mouseRect;
2119 HDC hdc;
2120 LONG hittest = (LONG)(wParam & 0x0f);
2121 HCURSOR16 hDragCursor = 0, hOldCursor = 0;
2122 POINT minTrack, maxTrack;
2123 POINT16 capturePoint, pt;
2124 WND * wndPtr = WIN_FindWndPtr( hwnd );
2125 BOOL thickframe = HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle );
2126 BOOL iconic = wndPtr->dwStyle & WS_MINIMIZE;
2127 BOOL moved = FALSE;
2128 DWORD dwPoint = GetMessagePos ();
2129
2130 capturePoint = pt = *(POINT16*)&dwPoint;
2131
2132 if (IsZoomed(hwnd) || !IsWindowVisible(hwnd) ||
2133 (wndPtr->flags & WIN_MANAGED)) goto END;
2134
2135 if ((wParam & 0xfff0) == SC_MOVE)
2136 {
2137 if (!hittest)
2138 hittest = NC_StartSizeMove( wndPtr, wParam, &capturePoint );
2139 if (!hittest) goto END;
2140 }
2141 else /* SC_SIZE */
2142 {
2143 if (!thickframe) goto END;
2144 if ( hittest && hittest != HTSYSMENU ) hittest += 2;
2145 else
2146 {
2147 SetCapture(hwnd);
2148 hittest = NC_StartSizeMove( wndPtr, wParam, &capturePoint );
2149 if (!hittest)
2150 {
2151 ReleaseCapture();
2152 goto END;
2153 }
2154 }
2155 }
2156
2157 /* Get min/max info */
2158
2159 WINPOS_GetMinMaxInfo( wndPtr, NULL, NULL, &minTrack, &maxTrack );
2160 sizingRect = wndPtr->rectWindow;
2161 if (wndPtr->dwStyle & WS_CHILD)
2162 GetClientRect( wndPtr->parent->hwndSelf, &mouseRect );
2163 else
2164 SetRect(&mouseRect, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
2165 if (ON_LEFT_BORDER(hittest))
2166 {
2167 mouseRect.left = max( mouseRect.left, sizingRect.right-maxTrack.x );
2168 mouseRect.right = min( mouseRect.right, sizingRect.right-minTrack.x );
2169 }
2170 else if (ON_RIGHT_BORDER(hittest))
2171 {
2172 mouseRect.left = max( mouseRect.left, sizingRect.left+minTrack.x );
2173 mouseRect.right = min( mouseRect.right, sizingRect.left+maxTrack.x );
2174 }
2175 if (ON_TOP_BORDER(hittest))
2176 {
2177 mouseRect.top = max( mouseRect.top, sizingRect.bottom-maxTrack.y );
2178 mouseRect.bottom = min( mouseRect.bottom,sizingRect.bottom-minTrack.y);
2179 }
2180 else if (ON_BOTTOM_BORDER(hittest))
2181 {
2182 mouseRect.top = max( mouseRect.top, sizingRect.top+minTrack.y );
2183 mouseRect.bottom = min( mouseRect.bottom, sizingRect.top+maxTrack.y );
2184 }
2185 if (wndPtr->dwStyle & WS_CHILD)
2186 {
2187 MapWindowPoints( wndPtr->parent->hwndSelf, 0,
2188 (LPPOINT)&mouseRect, 2 );
2189 }
2190 SendMessage16( hwnd, WM_ENTERSIZEMOVE, 0, 0 );
2191
2192 if (GetCapture() != hwnd) SetCapture( hwnd );
2193
2194 if (wndPtr->dwStyle & WS_CHILD)
2195 {
2196 /* Retrieve a default cache DC (without using the window style) */
2197 hdc = GetDCEx( wndPtr->parent->hwndSelf, 0, DCX_CACHE );
2198 }
2199 else
2200 { /* Grab the server only when moving top-level windows without desktop */
2201 hdc = GetDC( 0 );
2202 }
2203
2204 wndPtr->pDriver->pPreSizeMove(wndPtr);
2205
2206 if( iconic ) /* create a cursor for dragging */
2207 {
2208 HICON16 hIcon = GetClassWord(wndPtr->hwndSelf, GCW_HICON);
2209 if(!hIcon) hIcon = (HICON16) SendMessage16( hwnd, WM_QUERYDRAGICON, 0, 0L);
2210 if( hIcon ) hDragCursor = CURSORICON_IconToCursor( hIcon, TRUE );
2211 if( !hDragCursor ) iconic = FALSE;
2212 }
2213
2214 /* invert frame if WIN31_LOOK to indicate mouse click on caption */
2215 if( !iconic && TWEAK_WineLook == WIN31_LOOK )
2216 NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
2217
2218 while(1)
2219 {
2220 int dx = 0, dy = 0;
2221
2222 MSG_InternalGetMessage( QMSG_WIN32A, &msg, 0, 0, MSGF_SIZE, PM_REMOVE, FALSE, NULL );
2223
2224 /* Exit on button-up, Return, or Esc */
2225 if ((msg.message == WM_LBUTTONUP) ||
2226 ((msg.message == WM_KEYDOWN) &&
2227 ((msg.wParam == VK_RETURN) || (msg.wParam == VK_ESCAPE)))) break;
2228
2229 if (msg.message == WM_PAINT)
2230 {
2231 if(!iconic) NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
2232 UpdateWindow( msg.hwnd );
2233 if(!iconic) NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
2234 continue;
2235 }
2236 if ((msg.message != WM_KEYDOWN) && (msg.message != WM_MOUSEMOVE))
2237 continue; /* We are not interested in other messages */
2238
2239 dwPoint = GetMessagePos ();
2240 pt = *(POINT16*)&dwPoint;
2241
2242 if (msg.message == WM_KEYDOWN) switch(msg.wParam)
2243 {
2244 case VK_UP: pt.y -= 8; break;
2245 case VK_DOWN: pt.y += 8; break;
2246 case VK_LEFT: pt.x -= 8; break;
2247 case VK_RIGHT: pt.x += 8; break;
2248 }
2249
2250 pt.x = max( pt.x, mouseRect.left );
2251 pt.x = min( pt.x, mouseRect.right );
2252 pt.y = max( pt.y, mouseRect.top );
2253 pt.y = min( pt.y, mouseRect.bottom );
2254
2255 dx = pt.x - capturePoint.x;
2256 dy = pt.y - capturePoint.y;
2257
2258 if (dx || dy)
2259 {
2260 if( !moved )
2261 {
2262 moved = TRUE;
2263
2264 if( iconic ) /* ok, no system popup tracking */
2265 {
2266 hOldCursor = SetCursor(hDragCursor);
2267 ShowCursor( TRUE );
2268 WINPOS_ShowIconTitle( wndPtr, FALSE );
2269 } else if(TWEAK_WineLook != WIN31_LOOK)
2270 {
2271 NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
2272 }
2273 }
2274
2275 if (msg.message == WM_KEYDOWN) SetCursorPos( pt.x, pt.y );
2276 else
2277 {
2278 RECT newRect = sizingRect;
2279 WPARAM wpSizingHit = 0;
2280
2281 if (hittest == HTCAPTION) OffsetRect( &newRect, dx, dy );
2282 if (ON_LEFT_BORDER(hittest)) newRect.left += dx;
2283 else if (ON_RIGHT_BORDER(hittest)) newRect.right += dx;
2284 if (ON_TOP_BORDER(hittest)) newRect.top += dy;
2285 else if (ON_BOTTOM_BORDER(hittest)) newRect.bottom += dy;
2286 if(!iconic) NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
2287 capturePoint = pt;
2288
2289 /* determine the hit location */
2290 if (hittest >= HTLEFT && hittest <= HTBOTTOMRIGHT)
2291 wpSizingHit = WMSZ_LEFT + (hittest - HTLEFT);
2292 SendMessageA( hwnd, WM_SIZING, wpSizingHit, (LPARAM)&newRect );
2293
2294 if (!iconic) NC_DrawMovingFrame( hdc, &newRect, thickframe );
2295 sizingRect = newRect;
2296 }
2297 }
2298 }
2299
2300 ReleaseCapture();
2301 if( iconic )
2302 {
2303 if( moved ) /* restore cursors, show icon title later on */
2304 {
2305 ShowCursor( FALSE );
2306 SetCursor( hOldCursor );
2307 }
2308 DestroyCursor( hDragCursor );
2309 }
2310 else if(moved || TWEAK_WineLook == WIN31_LOOK)
2311 NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
2312
2313 if (wndPtr->dwStyle & WS_CHILD)
2314 ReleaseDC( wndPtr->parent->hwndSelf, hdc );
2315 else
2316 ReleaseDC( 0, hdc );
2317
2318 wndPtr->pDriver->pPostSizeMove(wndPtr);
2319
2320 if (HOOK_IsHooked( WH_CBT ))
2321 {
2322 RECT16* pr = SEGPTR_NEW(RECT16);
2323 if( pr )
2324 {
2325 CONV_RECT32TO16( &sizingRect, pr );
2326 if( HOOK_CallHooks16( WH_CBT, HCBT_MOVESIZE, hwnd,
2327 (LPARAM)SEGPTR_GET(pr)) )
2328 sizingRect = wndPtr->rectWindow;
2329 else
2330 CONV_RECT16TO32( pr, &sizingRect );
2331 SEGPTR_FREE(pr);
2332 }
2333 }
2334 SendMessage16( hwnd, WM_EXITSIZEMOVE, 0, 0 );
2335 SendMessage16( hwnd, WM_SETVISIBLE, !IsIconic16(hwnd), 0L);
2336
2337 /* window moved or resized */
2338 if (moved)
2339 {
2340 /* if the moving/resizing isn't canceled call SetWindowPos
2341 * with the new position or the new size of the window
2342 */
2343 if (!((msg.message == WM_KEYDOWN) && (msg.wParam == VK_ESCAPE)) )
2344 {
2345 /* NOTE: SWP_NOACTIVATE prevents document window activation in Word 6 */
2346 SetWindowPos( hwnd, 0, sizingRect.left, sizingRect.top,
2347 sizingRect.right - sizingRect.left,
2348 sizingRect.bottom - sizingRect.top,
2349 ( hittest == HTCAPTION ) ? SWP_NOSIZE : 0 );
2350 }
2351 }
2352
2353 if( IsWindow(hwnd) )
2354 if( wndPtr->dwStyle & WS_MINIMIZE )
2355 {
2356 /* Single click brings up the system menu when iconized */
2357
2358 if( !moved )
2359 {
2360 if( wndPtr->dwStyle & WS_SYSMENU )
2361 SendMessage16( hwnd, WM_SYSCOMMAND,
2362 SC_MOUSEMENU + HTSYSMENU, *((LPARAM*)&pt));
2363 }
2364 else WINPOS_ShowIconTitle( wndPtr, TRUE );
2365 }
2366
2367 END:
2368 WIN_ReleaseWndPtr(wndPtr);
2369 }
2370
2371
2372 /***********************************************************************
2373 * NC_TrackMinMaxBox95
2374 *
2375 * Track a mouse button press on the minimize or maximize box.
2376 *
2377 * The big difference between 3.1 and 95 is the disabled button state.
2378 * In win95 the system button can be disabled, so it can ignore the mouse
2379 * event.
2380 *
2381 */
2382 static void NC_TrackMinMaxBox95( HWND hwnd, WORD wParam )
2383 {
2384 MSG msg;
2385 POINT16 pt16;
2386 HDC hdc = GetWindowDC( hwnd );
2387 BOOL pressed = TRUE;
2388 UINT state;
2389 DWORD wndStyle = GetWindowLongA( hwnd, GWL_STYLE);
2390 HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
2391
2392 void (*paintButton)(HWND, HDC16, BOOL, BOOL);
2393
2394 if (wParam == HTMINBUTTON)
2395 {
2396 /* If the style is not present, do nothing */
2397 if (!(wndStyle & WS_MINIMIZEBOX))
2398 return;
2399
2400 /* Check if the sysmenu item for minimize is there */
2401 state = GetMenuState(hSysMenu, SC_MINIMIZE, MF_BYCOMMAND);
2402
2403 paintButton = &NC_DrawMinButton95;
2404 }
2405 else
2406 {
2407 /* If the style is not present, do nothing */
2408 if (!(wndStyle & WS_MAXIMIZEBOX))
2409 return;
2410
2411 /* Check if the sysmenu item for maximize is there */
2412 state = GetMenuState(hSysMenu, SC_MAXIMIZE, MF_BYCOMMAND);
2413
2414 paintButton = &NC_DrawMaxButton95;
2415 }
2416
2417 SetCapture( hwnd );
2418
2419 (*paintButton)( hwnd, hdc, TRUE, FALSE);
2420
2421 do
2422 {
2423 BOOL oldstate = pressed;
2424 MSG_InternalGetMessage( QMSG_WIN32A, &msg, 0, 0, 0, PM_REMOVE, FALSE, NULL );
2425 CONV_POINT32TO16( &msg.pt, &pt16 );
2426
2427 pressed = (NC_HandleNCHitTest( hwnd, pt16 ) == wParam);
2428 if (pressed != oldstate)
2429 (*paintButton)( hwnd, hdc, pressed, FALSE);
2430 } while (msg.message != WM_LBUTTONUP);
2431
2432 (*paintButton)( hwnd, hdc, FALSE, FALSE);
2433
2434 ReleaseCapture();
2435 ReleaseDC( hwnd, hdc );
2436
2437 /* If the item minimize or maximize of the sysmenu are not there */
2438 /* or if the style is not present, do nothing */
2439 if ((!pressed) || (state == 0xFFFFFFFF))
2440 return;
2441
2442 if (wParam == HTMINBUTTON)
2443 SendMessage16( hwnd, WM_SYSCOMMAND, SC_MINIMIZE, *(LONG*)&pt16 );
2444 else
2445 SendMessage16( hwnd, WM_SYSCOMMAND,
2446 IsZoomed(hwnd) ? SC_RESTORE:SC_MAXIMIZE, *(LONG*)&pt16 );
2447 }
2448
2449 /***********************************************************************
2450 * NC_TrackMinMaxBox
2451 *
2452 * Track a mouse button press on the minimize or maximize box.
2453 */
2454 static void NC_TrackMinMaxBox( HWND hwnd, WORD wParam )
2455 {
2456 MSG msg;
2457 POINT16 pt16;
2458 HDC hdc = GetWindowDC( hwnd );
2459 BOOL pressed = TRUE;
2460 void (*paintButton)(HWND, HDC16, BOOL);
2461
2462 SetCapture( hwnd );
2463
2464 if (wParam == HTMINBUTTON)
2465 paintButton = &NC_DrawMinButton;
2466 else
2467 paintButton = &NC_DrawMaxButton;
2468
2469 (*paintButton)( hwnd, hdc, TRUE);
2470
2471 do
2472 {
2473 BOOL oldstate = pressed;
2474 MSG_InternalGetMessage( QMSG_WIN32A, &msg, 0, 0, 0, PM_REMOVE, FALSE, NULL );
2475 CONV_POINT32TO16( &msg.pt, &pt16 );
2476
2477 pressed = (NC_HandleNCHitTest( hwnd, pt16 ) == wParam);
2478 if (pressed != oldstate)
2479 (*paintButton)( hwnd, hdc, pressed);
2480 } while (msg.message != WM_LBUTTONUP);
2481
2482 (*paintButton)( hwnd, hdc, FALSE);
2483
2484 ReleaseCapture();
2485 ReleaseDC( hwnd, hdc );
2486
2487 if (!pressed) return;
2488
2489 if (wParam == HTMINBUTTON)
2490 SendMessage16( hwnd, WM_SYSCOMMAND, SC_MINIMIZE, *(LONG*)&pt16 );
2491 else
2492 SendMessage16( hwnd, WM_SYSCOMMAND,
2493 IsZoomed(hwnd) ? SC_RESTORE:SC_MAXIMIZE, *(LONG*)&pt16 );
2494 }
2495
2496
2497 /***********************************************************************
2498 * NC_TrackCloseButton95
2499 *
2500 * Track a mouse button press on the Win95 close button.
2501 */
2502 static void
2503 NC_TrackCloseButton95 (HWND hwnd, WORD wParam)
2504 {
2505 MSG msg;
2506 POINT16 pt16;
2507 HDC hdc;
2508 BOOL pressed = TRUE;
2509 HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
2510 UINT state;
2511
2512 if(hSysMenu == 0)
2513 return;
2514
2515 state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
2516
2517 /* If the item close of the sysmenu is disabled or not there do nothing */
2518 if((state & MF_DISABLED) || (state & MF_GRAYED) || (state == 0xFFFFFFFF))
2519 return;
2520
2521 hdc = GetWindowDC( hwnd );
2522
2523 SetCapture( hwnd );
2524
2525 NC_DrawCloseButton95 (hwnd, hdc, TRUE, FALSE);
2526
2527 do
2528 {
2529 BOOL oldstate = pressed;
2530 MSG_InternalGetMessage( QMSG_WIN32A, &msg, 0, 0, 0, PM_REMOVE, FALSE, NULL );
2531 CONV_POINT32TO16( &msg.pt, &pt16 );
2532
2533 pressed = (NC_HandleNCHitTest( hwnd, pt16 ) == wParam);
2534 if (pressed != oldstate)
2535 NC_DrawCloseButton95 (hwnd, hdc, pressed, FALSE);
2536 } while (msg.message != WM_LBUTTONUP);
2537
2538 NC_DrawCloseButton95 (hwnd, hdc, FALSE, FALSE);
2539
2540 ReleaseCapture();
2541 ReleaseDC( hwnd, hdc );
2542 if (!pressed) return;
2543
2544 SendMessage16( hwnd, WM_SYSCOMMAND, SC_CLOSE, *(LONG*)&pt16 );
2545 }
2546
2547
2548 /***********************************************************************
2549 * NC_TrackScrollBar
2550 *
2551 * Track a mouse button press on the horizontal or vertical scroll-bar.
2552 */
2553 static void NC_TrackScrollBar( HWND hwnd, WPARAM wParam, POINT pt )
2554 {
2555 MSG16 *msg;
2556 INT scrollbar;
2557 WND *wndPtr = WIN_FindWndPtr( hwnd );
2558
2559 if ((wParam & 0xfff0) == SC_HSCROLL)
2560 {
2561 if ((wParam & 0x0f) != HTHSCROLL) goto END;
2562 scrollbar = SB_HORZ;
2563 }
2564 else /* SC_VSCROLL */
2565 {
2566 if ((wParam & 0x0f) != HTVSCROLL) goto END;
2567 scrollbar = SB_VERT;
2568 }
2569
2570 if (!(msg = SEGPTR_NEW(MSG16))) goto END;
2571 pt.x -= wndPtr->rectWindow.left;
2572 pt.y -= wndPtr->rectWindow.top;
2573 SetCapture( hwnd );
2574 SCROLL_HandleScrollEvent( hwnd, scrollbar, WM_LBUTTONDOWN, pt );
2575
2576 do
2577 {
2578 GetMessage16( SEGPTR_GET(msg), 0, 0, 0 );
2579 switch(msg->message)
2580 {
2581 case WM_LBUTTONUP:
2582 case WM_MOUSEMOVE:
2583 case WM_SYSTIMER:
2584 pt.x = LOWORD(msg->lParam) + wndPtr->rectClient.left -
2585 wndPtr->rectWindow.left;
2586 pt.y = HIWORD(msg->lParam) + wndPtr->rectClient.top -
2587 wndPtr->rectWindow.top;
2588 SCROLL_HandleScrollEvent( hwnd, scrollbar, msg->message, pt );
2589 break;
2590 default:
2591 TranslateMessage16( msg );
2592 DispatchMessage16( msg );
2593 break;
2594 }
2595 if (!IsWindow( hwnd ))
2596 {
2597 ReleaseCapture();
2598 break;
2599 }
2600 } while (msg->message != WM_LBUTTONUP);
2601 SEGPTR_FREE(msg);
2602 END:
2603 WIN_ReleaseWndPtr(wndPtr);
2604 }
2605
2606 /***********************************************************************
2607 * NC_HandleNCLButtonDown
2608 *
2609 * Handle a WM_NCLBUTTONDOWN message. Called from DefWindowProc().
2610 */
2611 LONG NC_HandleNCLButtonDown( WND* pWnd, WPARAM16 wParam, LPARAM lParam )
2612 {
2613 HWND hwnd = pWnd->hwndSelf;
2614
2615 switch(wParam) /* Hit test */
2616 {
2617 case HTCAPTION:
2618 hwnd = WIN_GetTopParent(hwnd);
2619
2620 if( WINPOS_SetActiveWindow(hwnd, TRUE, TRUE) || (GetActiveWindow() == hwnd) )
2621 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_MOVE + HTCAPTION, lParam );
2622 break;
2623
2624 case HTSYSMENU:
2625 if( pWnd->dwStyle & WS_SYSMENU )
2626 {
2627 if( !(pWnd->dwStyle & WS_MINIMIZE) )
2628 {
2629 HDC hDC = GetWindowDC(hwnd);
2630 if (TWEAK_WineLook == WIN31_LOOK)
2631 NC_DrawSysButton( hwnd, hDC, TRUE );
2632 else
2633 NC_DrawSysButton95( hwnd, hDC, TRUE );
2634 ReleaseDC( hwnd, hDC );
2635 }
2636 SendMessage16( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU + HTSYSMENU, lParam );
2637 }
2638 break;
2639
2640 case HTMENU:
2641 SendMessage16( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU, lParam );
2642 break;
2643
2644 case HTHSCROLL:
2645 SendMessage16( hwnd, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL, lParam );
2646 break;
2647
2648 case HTVSCROLL:
2649 SendMessage16( hwnd, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL, lParam );
2650 break;
2651
2652 case HTMINBUTTON:
2653 case HTMAXBUTTON:
2654 if (TWEAK_WineLook == WIN31_LOOK)
2655 NC_TrackMinMaxBox( hwnd, wParam );
2656 else
2657 NC_TrackMinMaxBox95( hwnd, wParam );
2658 break;
2659
2660 case HTCLOSE:
2661 if (TWEAK_WineLook >= WIN95_LOOK)
2662 NC_TrackCloseButton95 (hwnd, wParam);
2663 break;
2664
2665 case HTLEFT:
2666 case HTRIGHT:
2667 case HTTOP:
2668 case HTTOPLEFT:
2669 case HTTOPRIGHT:
2670 case HTBOTTOM:
2671 case HTBOTTOMLEFT:
2672 case HTBOTTOMRIGHT:
2673 /* make sure hittest fits into 0xf and doesn't overlap with HTSYSMENU */
2674 SendMessage16( hwnd, WM_SYSCOMMAND, SC_SIZE + wParam - 2, lParam);
2675 break;
2676
2677 case HTBORDER:
2678 break;
2679 }
2680 return 0;
2681 }
2682
2683
2684 /***********************************************************************
2685 * NC_HandleNCLButtonDblClk
2686 *
2687 * Handle a WM_NCLBUTTONDBLCLK message. Called from DefWindowProc().
2688 */
2689 LONG NC_HandleNCLButtonDblClk( WND *pWnd, WPARAM16 wParam, LPARAM lParam )
2690 {
2691 /*
2692 * if this is an icon, send a restore since we are handling
2693 * a double click
2694 */
2695 if (pWnd->dwStyle & WS_MINIMIZE)
2696 {
2697 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_RESTORE, lParam );
2698 return 0;
2699 }
2700
2701 switch(wParam) /* Hit test */
2702 {
2703 case HTCAPTION:
2704 /* stop processing if WS_MAXIMIZEBOX is missing */
2705 if (pWnd->dwStyle & WS_MAXIMIZEBOX)
2706 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND,
2707 (pWnd->dwStyle & WS_MAXIMIZE) ? SC_RESTORE : SC_MAXIMIZE,
2708 lParam );
2709 break;
2710
2711 case HTSYSMENU:
2712 if (!(GetClassWord(pWnd->hwndSelf, GCW_STYLE) & CS_NOCLOSE))
2713 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_CLOSE, lParam );
2714 break;
2715
2716 case HTHSCROLL:
2717 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL,
2718 lParam );
2719 break;
2720
2721 case HTVSCROLL:
2722 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL,
2723 lParam );
2724 break;
2725 }
2726 return 0;
2727 }
2728
2729
2730 /***********************************************************************
2731 * NC_HandleSysCommand
2732 *
2733 * Handle a WM_SYSCOMMAND message. Called from DefWindowProc().
2734 */
2735 LONG NC_HandleSysCommand( HWND hwnd, WPARAM16 wParam, POINT16 pt )
2736 {
2737 WND *wndPtr = WIN_FindWndPtr( hwnd );
2738 POINT pt32;
2739 UINT16 uCommand = wParam & 0xFFF0;
2740
2741 TRACE("Handling WM_SYSCOMMAND %x %d,%d\n", wParam, pt.x, pt.y );
2742
2743 if (wndPtr->dwStyle & WS_CHILD && uCommand != SC_KEYMENU )
2744 ScreenToClient16( wndPtr->parent->hwndSelf, &pt );
2745
2746 switch (uCommand)
2747 {
2748 case SC_SIZE:
2749 case SC_MOVE:
2750 NC_DoSizeMove( hwnd, wParam );
2751 break;
2752
2753 case SC_MINIMIZE:
2754 if (hwnd == GetForegroundWindow())
2755 ShowOwnedPopups(hwnd,FALSE);
2756 ShowWindow( hwnd, SW_MINIMIZE );
2757 break;
2758
2759 case SC_MAXIMIZE:
2760 if (IsIconic(hwnd) && hwnd == GetForegroundWindow())
2761 ShowOwnedPopups(hwnd,TRUE);
2762 ShowWindow( hwnd, SW_MAXIMIZE );
2763 break;
2764
2765 case SC_RESTORE:
2766 if (IsIconic(hwnd) && hwnd == GetForegroundWindow())
2767 ShowOwnedPopups(hwnd,TRUE);
2768 ShowWindow( hwnd, SW_RESTORE );
2769 break;
2770
2771 case SC_CLOSE:
2772 WIN_ReleaseWndPtr(wndPtr);
2773 return SendMessage16( hwnd, WM_CLOSE, 0, 0 );
2774
2775 case SC_VSCROLL:
2776 case SC_HSCROLL:
2777 CONV_POINT16TO32( &pt, &pt32 );
2778 NC_TrackScrollBar( hwnd, wParam, pt32 );
2779 break;
2780
2781 case SC_MOUSEMENU:
2782 CONV_POINT16TO32( &pt, &pt32 );
2783 MENU_TrackMouseMenuBar( wndPtr, wParam & 0x000F, pt32 );
2784 break;
2785
2786 case SC_KEYMENU:
2787 MENU_TrackKbdMenuBar( wndPtr , wParam , pt.x );
2788 break;
2789
2790 case SC_TASKLIST:
2791 WinExec( "taskman.exe", SW_SHOWNORMAL );
2792 break;
2793
2794 case SC_SCREENSAVE:
2795 if (wParam == SC_ABOUTWINE)
2796 {
2797 HMODULE hmodule = LoadLibraryA( "shell32.dll" );
2798 if (hmodule)
2799 {
2800 FARPROC aboutproc = GetProcAddress( hmodule, "ShellAboutA" );
2801 if (aboutproc) aboutproc( hwnd, "Wine", WINE_RELEASE_INFO, 0 );
2802 FreeLibrary( hmodule );
2803 }
2804 }
2805 else
2806 if (wParam == SC_PUTMARK)
2807 TRACE_(shell)("Mark requested by user\n");
2808 break;
2809
2810 case SC_HOTKEY:
2811 case SC_ARRANGE:
2812 case SC_NEXTWINDOW:
2813 case SC_PREVWINDOW:
2814 FIXME("unimplemented!\n");
2815 break;
2816 }
2817 WIN_ReleaseWndPtr(wndPtr);
2818 return 0;
2819 }
2820
2821 /*************************************************************
2822 * NC_DrawGrayButton
2823 *
2824 * Stub for the grayed button of the caption
2825 *
2826 *************************************************************/
2827
2828 BOOL NC_DrawGrayButton(HDC hdc, int x, int y)
2829 {
2830 HBITMAP hMaskBmp;
2831 HDC hdcMask = CreateCompatibleDC (0);
2832 HBRUSH hOldBrush;
2833
2834 hMaskBmp = CreateBitmap (12, 10, 1, 1, lpGrayMask);
2835
2836 if(hMaskBmp == 0)
2837 return FALSE;
2838
2839 SelectObject (hdcMask, hMaskBmp);
2840
2841 /* Draw the grayed bitmap using the mask */
2842 hOldBrush = SelectObject (hdc, RGB(128, 128, 128));
2843 BitBlt (hdc, x, y, 12, 10,
2844 hdcMask, 0, 0, 0xB8074A);
2845
2846 /* Clean up */
2847 SelectObject (hdc, hOldBrush);
2848 DeleteObject(hMaskBmp);
2849 DeleteDC (hdcMask);
2850
2851 return TRUE;
2852 }
2853
2854 HICON16 NC_IconForWindow(WND *wndPtr)
2855 {
2856 HICON16 hIcon = (HICON) GetClassLongA(wndPtr->hwndSelf, GCL_HICONSM);
2857 if(!hIcon) hIcon = (HICON) GetClassLongA(wndPtr->hwndSelf, GCL_HICON);
2858
2859 /* If there is no hIcon specified and this is a modal dialog, */
2860 /* get the default one. */
2861 if (!hIcon && (wndPtr->dwStyle & DS_MODALFRAME))
2862 hIcon = LoadImageA(0, MAKEINTRESOURCEA(OIC_WINEICON), IMAGE_ICON, 0, 0, LR_DEFAULTCOLOR);
2863
2864 return hIcon;
2865 }
Quick hack tree for wine patches julliard doesn't want to commit