?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Francois Methot (Macadamian)
[wine/multimedia.git] / windows / nonclient.c
bloba2bf12d425039a13cc1002de88128b9dbabcddba
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_KEYDOWN) && (msg.message != WM_MOUSEMOVE))
2229 continue; /* We are not interested in other messages */
2230
2231 dwPoint = GetMessagePos ();
2232 pt = *(POINT16*)&dwPoint;
2233
2234 if (msg.message == WM_KEYDOWN) switch(msg.wParam)
2235 {
2236 case VK_UP: pt.y -= 8; break;
2237 case VK_DOWN: pt.y += 8; break;
2238 case VK_LEFT: pt.x -= 8; break;
2239 case VK_RIGHT: pt.x += 8; break;
2240 }
2241
2242 pt.x = max( pt.x, mouseRect.left );
2243 pt.x = min( pt.x, mouseRect.right );
2244 pt.y = max( pt.y, mouseRect.top );
2245 pt.y = min( pt.y, mouseRect.bottom );
2246
2247 dx = pt.x - capturePoint.x;
2248 dy = pt.y - capturePoint.y;
2249
2250 if (dx || dy)
2251 {
2252 if( !moved )
2253 {
2254 moved = TRUE;
2255
2256 if( iconic ) /* ok, no system popup tracking */
2257 {
2258 hOldCursor = SetCursor(hDragCursor);
2259 ShowCursor( TRUE );
2260 WINPOS_ShowIconTitle( wndPtr, FALSE );
2261 } else if(TWEAK_WineLook != WIN31_LOOK)
2262 {
2263 NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
2264 }
2265 }
2266
2267 if (msg.message == WM_KEYDOWN) SetCursorPos( pt.x, pt.y );
2268 else
2269 {
2270 RECT newRect = sizingRect;
2271 WPARAM wpSizingHit = 0;
2272
2273 if (hittest == HTCAPTION) OffsetRect( &newRect, dx, dy );
2274 if (ON_LEFT_BORDER(hittest)) newRect.left += dx;
2275 else if (ON_RIGHT_BORDER(hittest)) newRect.right += dx;
2276 if (ON_TOP_BORDER(hittest)) newRect.top += dy;
2277 else if (ON_BOTTOM_BORDER(hittest)) newRect.bottom += dy;
2278 if(!iconic) NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
2279 capturePoint = pt;
2280
2281 /* determine the hit location */
2282 if (hittest >= HTLEFT && hittest <= HTBOTTOMRIGHT)
2283 wpSizingHit = WMSZ_LEFT + (hittest - HTLEFT);
2284 SendMessageA( hwnd, WM_SIZING, wpSizingHit, (LPARAM)&newRect );
2285
2286 if (!iconic) NC_DrawMovingFrame( hdc, &newRect, thickframe );
2287 sizingRect = newRect;
2288 }
2289 }
2290 }
2291
2292 ReleaseCapture();
2293 if( iconic )
2294 {
2295 if( moved ) /* restore cursors, show icon title later on */
2296 {
2297 ShowCursor( FALSE );
2298 SetCursor( hOldCursor );
2299 }
2300 DestroyCursor( hDragCursor );
2301 }
2302 else if(moved || TWEAK_WineLook == WIN31_LOOK)
2303 NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
2304
2305 if (wndPtr->dwStyle & WS_CHILD)
2306 ReleaseDC( wndPtr->parent->hwndSelf, hdc );
2307 else
2308 ReleaseDC( 0, hdc );
2309
2310 wndPtr->pDriver->pPostSizeMove(wndPtr);
2311
2312 if (HOOK_IsHooked( WH_CBT ))
2313 {
2314 RECT16* pr = SEGPTR_NEW(RECT16);
2315 if( pr )
2316 {
2317 CONV_RECT32TO16( &sizingRect, pr );
2318 if( HOOK_CallHooks16( WH_CBT, HCBT_MOVESIZE, hwnd,
2319 (LPARAM)SEGPTR_GET(pr)) )
2320 sizingRect = wndPtr->rectWindow;
2321 else
2322 CONV_RECT16TO32( pr, &sizingRect );
2323 SEGPTR_FREE(pr);
2324 }
2325 }
2326 SendMessage16( hwnd, WM_EXITSIZEMOVE, 0, 0 );
2327 SendMessage16( hwnd, WM_SETVISIBLE, !IsIconic16(hwnd), 0L);
2328
2329 /* window moved or resized */
2330 if (moved)
2331 {
2332 /* if the moving/resizing isn't canceled call SetWindowPos
2333 * with the new position or the new size of the window
2334 */
2335 if (!((msg.message == WM_KEYDOWN) && (msg.wParam == VK_ESCAPE)) )
2336 {
2337 /* NOTE: SWP_NOACTIVATE prevents document window activation in Word 6 */
2338 SetWindowPos( hwnd, 0, sizingRect.left, sizingRect.top,
2339 sizingRect.right - sizingRect.left,
2340 sizingRect.bottom - sizingRect.top,
2341 ( hittest == HTCAPTION ) ? SWP_NOSIZE : 0 );
2342 }
2343 }
2344
2345 if( IsWindow(hwnd) )
2346 if( wndPtr->dwStyle & WS_MINIMIZE )
2347 {
2348 /* Single click brings up the system menu when iconized */
2349
2350 if( !moved )
2351 {
2352 if( wndPtr->dwStyle & WS_SYSMENU )
2353 SendMessage16( hwnd, WM_SYSCOMMAND,
2354 SC_MOUSEMENU + HTSYSMENU, *((LPARAM*)&pt));
2355 }
2356 else WINPOS_ShowIconTitle( wndPtr, TRUE );
2357 }
2358
2359 END:
2360 WIN_ReleaseWndPtr(wndPtr);
2361 }
2362
2363
2364 /***********************************************************************
2365 * NC_TrackMinMaxBox95
2366 *
2367 * Track a mouse button press on the minimize or maximize box.
2368 *
2369 * The big difference between 3.1 and 95 is the disabled button state.
2370 * In win95 the system button can be disabled, so it can ignore the mouse
2371 * event.
2372 *
2373 */
2374 static void NC_TrackMinMaxBox95( HWND hwnd, WORD wParam )
2375 {
2376 MSG msg;
2377 POINT16 pt16;
2378 HDC hdc = GetWindowDC( hwnd );
2379 BOOL pressed = TRUE;
2380 UINT state;
2381 DWORD wndStyle = GetWindowLongA( hwnd, GWL_STYLE);
2382 HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
2383
2384 void (*paintButton)(HWND, HDC16, BOOL, BOOL);
2385
2386 if (wParam == HTMINBUTTON)
2387 {
2388 /* If the style is not present, do nothing */
2389 if (!(wndStyle & WS_MINIMIZEBOX))
2390 return;
2391
2392 /* Check if the sysmenu item for minimize is there */
2393 state = GetMenuState(hSysMenu, SC_MINIMIZE, MF_BYCOMMAND);
2394
2395 paintButton = &NC_DrawMinButton95;
2396 }
2397 else
2398 {
2399 /* If the style is not present, do nothing */
2400 if (!(wndStyle & WS_MAXIMIZEBOX))
2401 return;
2402
2403 /* Check if the sysmenu item for maximize is there */
2404 state = GetMenuState(hSysMenu, SC_MAXIMIZE, MF_BYCOMMAND);
2405
2406 paintButton = &NC_DrawMaxButton95;
2407 }
2408
2409 SetCapture( hwnd );
2410
2411 (*paintButton)( hwnd, hdc, TRUE, FALSE);
2412
2413 do
2414 {
2415 BOOL oldstate = pressed;
2416 MSG_InternalGetMessage( QMSG_WIN32A, &msg, 0, 0, 0, PM_REMOVE, FALSE, NULL );
2417 CONV_POINT32TO16( &msg.pt, &pt16 );
2418
2419 pressed = (NC_HandleNCHitTest( hwnd, pt16 ) == wParam);
2420 if (pressed != oldstate)
2421 (*paintButton)( hwnd, hdc, pressed, FALSE);
2422 } while (msg.message != WM_LBUTTONUP);
2423
2424 (*paintButton)( hwnd, hdc, FALSE, FALSE);
2425
2426 ReleaseCapture();
2427 ReleaseDC( hwnd, hdc );
2428
2429 /* If the item minimize or maximize of the sysmenu are not there */
2430 /* or if the style is not present, do nothing */
2431 if ((!pressed) || (state == 0xFFFFFFFF))
2432 return;
2433
2434 if (wParam == HTMINBUTTON)
2435 SendMessage16( hwnd, WM_SYSCOMMAND, SC_MINIMIZE, *(LONG*)&pt16 );
2436 else
2437 SendMessage16( hwnd, WM_SYSCOMMAND,
2438 IsZoomed(hwnd) ? SC_RESTORE:SC_MAXIMIZE, *(LONG*)&pt16 );
2439 }
2440
2441 /***********************************************************************
2442 * NC_TrackMinMaxBox
2443 *
2444 * Track a mouse button press on the minimize or maximize box.
2445 */
2446 static void NC_TrackMinMaxBox( HWND hwnd, WORD wParam )
2447 {
2448 MSG msg;
2449 POINT16 pt16;
2450 HDC hdc = GetWindowDC( hwnd );
2451 BOOL pressed = TRUE;
2452 void (*paintButton)(HWND, HDC16, BOOL);
2453
2454 SetCapture( hwnd );
2455
2456 if (wParam == HTMINBUTTON)
2457 paintButton = &NC_DrawMinButton;
2458 else
2459 paintButton = &NC_DrawMaxButton;
2460
2461 (*paintButton)( hwnd, hdc, TRUE);
2462
2463 do
2464 {
2465 BOOL oldstate = pressed;
2466 MSG_InternalGetMessage( QMSG_WIN32A, &msg, 0, 0, 0, PM_REMOVE, FALSE, NULL );
2467 CONV_POINT32TO16( &msg.pt, &pt16 );
2468
2469 pressed = (NC_HandleNCHitTest( hwnd, pt16 ) == wParam);
2470 if (pressed != oldstate)
2471 (*paintButton)( hwnd, hdc, pressed);
2472 } while (msg.message != WM_LBUTTONUP);
2473
2474 (*paintButton)( hwnd, hdc, FALSE);
2475
2476 ReleaseCapture();
2477 ReleaseDC( hwnd, hdc );
2478
2479 if (!pressed) return;
2480
2481 if (wParam == HTMINBUTTON)
2482 SendMessage16( hwnd, WM_SYSCOMMAND, SC_MINIMIZE, *(LONG*)&pt16 );
2483 else
2484 SendMessage16( hwnd, WM_SYSCOMMAND,
2485 IsZoomed(hwnd) ? SC_RESTORE:SC_MAXIMIZE, *(LONG*)&pt16 );
2486 }
2487
2488
2489 /***********************************************************************
2490 * NC_TrackCloseButton95
2491 *
2492 * Track a mouse button press on the Win95 close button.
2493 */
2494 static void
2495 NC_TrackCloseButton95 (HWND hwnd, WORD wParam)
2496 {
2497 MSG msg;
2498 POINT16 pt16;
2499 HDC hdc;
2500 BOOL pressed = TRUE;
2501 HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
2502 UINT state;
2503
2504 if(hSysMenu == 0)
2505 return;
2506
2507 state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
2508
2509 /* If the item close of the sysmenu is disabled or not there do nothing */
2510 if((state & MF_DISABLED) || (state & MF_GRAYED) || (state == 0xFFFFFFFF))
2511 return;
2512
2513 hdc = GetWindowDC( hwnd );
2514
2515 SetCapture( hwnd );
2516
2517 NC_DrawCloseButton95 (hwnd, hdc, TRUE, FALSE);
2518
2519 do
2520 {
2521 BOOL oldstate = pressed;
2522 MSG_InternalGetMessage( QMSG_WIN32A, &msg, 0, 0, 0, PM_REMOVE, FALSE, NULL );
2523 CONV_POINT32TO16( &msg.pt, &pt16 );
2524
2525 pressed = (NC_HandleNCHitTest( hwnd, pt16 ) == wParam);
2526 if (pressed != oldstate)
2527 NC_DrawCloseButton95 (hwnd, hdc, pressed, FALSE);
2528 } while (msg.message != WM_LBUTTONUP);
2529
2530 NC_DrawCloseButton95 (hwnd, hdc, FALSE, FALSE);
2531
2532 ReleaseCapture();
2533 ReleaseDC( hwnd, hdc );
2534 if (!pressed) return;
2535
2536 SendMessage16( hwnd, WM_SYSCOMMAND, SC_CLOSE, *(LONG*)&pt16 );
2537 }
2538
2539
2540 /***********************************************************************
2541 * NC_TrackScrollBar
2542 *
2543 * Track a mouse button press on the horizontal or vertical scroll-bar.
2544 */
2545 static void NC_TrackScrollBar( HWND hwnd, WPARAM wParam, POINT pt )
2546 {
2547 MSG16 *msg;
2548 INT scrollbar;
2549 WND *wndPtr = WIN_FindWndPtr( hwnd );
2550
2551 if ((wParam & 0xfff0) == SC_HSCROLL)
2552 {
2553 if ((wParam & 0x0f) != HTHSCROLL) goto END;
2554 scrollbar = SB_HORZ;
2555 }
2556 else /* SC_VSCROLL */
2557 {
2558 if ((wParam & 0x0f) != HTVSCROLL) goto END;
2559 scrollbar = SB_VERT;
2560 }
2561
2562 if (!(msg = SEGPTR_NEW(MSG16))) goto END;
2563 pt.x -= wndPtr->rectWindow.left;
2564 pt.y -= wndPtr->rectWindow.top;
2565 SetCapture( hwnd );
2566 SCROLL_HandleScrollEvent( hwnd, scrollbar, WM_LBUTTONDOWN, pt );
2567
2568 do
2569 {
2570 GetMessage16( SEGPTR_GET(msg), 0, 0, 0 );
2571 switch(msg->message)
2572 {
2573 case WM_LBUTTONUP:
2574 case WM_MOUSEMOVE:
2575 case WM_SYSTIMER:
2576 pt.x = LOWORD(msg->lParam) + wndPtr->rectClient.left -
2577 wndPtr->rectWindow.left;
2578 pt.y = HIWORD(msg->lParam) + wndPtr->rectClient.top -
2579 wndPtr->rectWindow.top;
2580 SCROLL_HandleScrollEvent( hwnd, scrollbar, msg->message, pt );
2581 break;
2582 default:
2583 TranslateMessage16( msg );
2584 DispatchMessage16( msg );
2585 break;
2586 }
2587 if (!IsWindow( hwnd ))
2588 {
2589 ReleaseCapture();
2590 break;
2591 }
2592 } while (msg->message != WM_LBUTTONUP);
2593 SEGPTR_FREE(msg);
2594 END:
2595 WIN_ReleaseWndPtr(wndPtr);
2596 }
2597
2598 /***********************************************************************
2599 * NC_HandleNCLButtonDown
2600 *
2601 * Handle a WM_NCLBUTTONDOWN message. Called from DefWindowProc().
2602 */
2603 LONG NC_HandleNCLButtonDown( WND* pWnd, WPARAM16 wParam, LPARAM lParam )
2604 {
2605 HWND hwnd = pWnd->hwndSelf;
2606
2607 switch(wParam) /* Hit test */
2608 {
2609 case HTCAPTION:
2610 hwnd = WIN_GetTopParent(hwnd);
2611
2612 if( WINPOS_SetActiveWindow(hwnd, TRUE, TRUE) || (GetActiveWindow() == hwnd) )
2613 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_MOVE + HTCAPTION, lParam );
2614 break;
2615
2616 case HTSYSMENU:
2617 if( pWnd->dwStyle & WS_SYSMENU )
2618 {
2619 if( !(pWnd->dwStyle & WS_MINIMIZE) )
2620 {
2621 HDC hDC = GetWindowDC(hwnd);
2622 if (TWEAK_WineLook == WIN31_LOOK)
2623 NC_DrawSysButton( hwnd, hDC, TRUE );
2624 else
2625 NC_DrawSysButton95( hwnd, hDC, TRUE );
2626 ReleaseDC( hwnd, hDC );
2627 }
2628 SendMessage16( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU + HTSYSMENU, lParam );
2629 }
2630 break;
2631
2632 case HTMENU:
2633 SendMessage16( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU, lParam );
2634 break;
2635
2636 case HTHSCROLL:
2637 SendMessage16( hwnd, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL, lParam );
2638 break;
2639
2640 case HTVSCROLL:
2641 SendMessage16( hwnd, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL, lParam );
2642 break;
2643
2644 case HTMINBUTTON:
2645 case HTMAXBUTTON:
2646 if (TWEAK_WineLook == WIN31_LOOK)
2647 NC_TrackMinMaxBox( hwnd, wParam );
2648 else
2649 NC_TrackMinMaxBox95( hwnd, wParam );
2650 break;
2651
2652 case HTCLOSE:
2653 if (TWEAK_WineLook >= WIN95_LOOK)
2654 NC_TrackCloseButton95 (hwnd, wParam);
2655 break;
2656
2657 case HTLEFT:
2658 case HTRIGHT:
2659 case HTTOP:
2660 case HTTOPLEFT:
2661 case HTTOPRIGHT:
2662 case HTBOTTOM:
2663 case HTBOTTOMLEFT:
2664 case HTBOTTOMRIGHT:
2665 /* make sure hittest fits into 0xf and doesn't overlap with HTSYSMENU */
2666 SendMessage16( hwnd, WM_SYSCOMMAND, SC_SIZE + wParam - 2, lParam);
2667 break;
2668
2669 case HTBORDER:
2670 break;
2671 }
2672 return 0;
2673 }
2674
2675
2676 /***********************************************************************
2677 * NC_HandleNCLButtonDblClk
2678 *
2679 * Handle a WM_NCLBUTTONDBLCLK message. Called from DefWindowProc().
2680 */
2681 LONG NC_HandleNCLButtonDblClk( WND *pWnd, WPARAM16 wParam, LPARAM lParam )
2682 {
2683 /*
2684 * if this is an icon, send a restore since we are handling
2685 * a double click
2686 */
2687 if (pWnd->dwStyle & WS_MINIMIZE)
2688 {
2689 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_RESTORE, lParam );
2690 return 0;
2691 }
2692
2693 switch(wParam) /* Hit test */
2694 {
2695 case HTCAPTION:
2696 /* stop processing if WS_MAXIMIZEBOX is missing */
2697 if (pWnd->dwStyle & WS_MAXIMIZEBOX)
2698 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND,
2699 (pWnd->dwStyle & WS_MAXIMIZE) ? SC_RESTORE : SC_MAXIMIZE,
2700 lParam );
2701 break;
2702
2703 case HTSYSMENU:
2704 if (!(GetClassWord(pWnd->hwndSelf, GCW_STYLE) & CS_NOCLOSE))
2705 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_CLOSE, lParam );
2706 break;
2707
2708 case HTHSCROLL:
2709 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL,
2710 lParam );
2711 break;
2712
2713 case HTVSCROLL:
2714 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL,
2715 lParam );
2716 break;
2717 }
2718 return 0;
2719 }
2720
2721
2722 /***********************************************************************
2723 * NC_HandleSysCommand
2724 *
2725 * Handle a WM_SYSCOMMAND message. Called from DefWindowProc().
2726 */
2727 LONG NC_HandleSysCommand( HWND hwnd, WPARAM16 wParam, POINT16 pt )
2728 {
2729 WND *wndPtr = WIN_FindWndPtr( hwnd );
2730 POINT pt32;
2731 UINT16 uCommand = wParam & 0xFFF0;
2732
2733 TRACE("Handling WM_SYSCOMMAND %x %d,%d\n", wParam, pt.x, pt.y );
2734
2735 if (wndPtr->dwStyle & WS_CHILD && uCommand != SC_KEYMENU )
2736 ScreenToClient16( wndPtr->parent->hwndSelf, &pt );
2737
2738 switch (uCommand)
2739 {
2740 case SC_SIZE:
2741 case SC_MOVE:
2742 NC_DoSizeMove( hwnd, wParam );
2743 break;
2744
2745 case SC_MINIMIZE:
2746 if (hwnd == GetForegroundWindow())
2747 ShowOwnedPopups(hwnd,FALSE);
2748 ShowWindow( hwnd, SW_MINIMIZE );
2749 break;
2750
2751 case SC_MAXIMIZE:
2752 if (IsIconic(hwnd) && hwnd == GetForegroundWindow())
2753 ShowOwnedPopups(hwnd,TRUE);
2754 ShowWindow( hwnd, SW_MAXIMIZE );
2755 break;
2756
2757 case SC_RESTORE:
2758 if (IsIconic(hwnd) && hwnd == GetForegroundWindow())
2759 ShowOwnedPopups(hwnd,TRUE);
2760 ShowWindow( hwnd, SW_RESTORE );
2761 break;
2762
2763 case SC_CLOSE:
2764 WIN_ReleaseWndPtr(wndPtr);
2765 return SendMessage16( hwnd, WM_CLOSE, 0, 0 );
2766
2767 case SC_VSCROLL:
2768 case SC_HSCROLL:
2769 CONV_POINT16TO32( &pt, &pt32 );
2770 NC_TrackScrollBar( hwnd, wParam, pt32 );
2771 break;
2772
2773 case SC_MOUSEMENU:
2774 CONV_POINT16TO32( &pt, &pt32 );
2775 MENU_TrackMouseMenuBar( wndPtr, wParam & 0x000F, pt32 );
2776 break;
2777
2778 case SC_KEYMENU:
2779 MENU_TrackKbdMenuBar( wndPtr , wParam , pt.x );
2780 break;
2781
2782 case SC_TASKLIST:
2783 WinExec( "taskman.exe", SW_SHOWNORMAL );
2784 break;
2785
2786 case SC_SCREENSAVE:
2787 if (wParam == SC_ABOUTWINE)
2788 {
2789 HMODULE hmodule = LoadLibraryA( "shell32.dll" );
2790 if (hmodule)
2791 {
2792 FARPROC aboutproc = GetProcAddress( hmodule, "ShellAboutA" );
2793 if (aboutproc) aboutproc( hwnd, "Wine", WINE_RELEASE_INFO, 0 );
2794 FreeLibrary( hmodule );
2795 }
2796 }
2797 else
2798 if (wParam == SC_PUTMARK)
2799 TRACE_(shell)("Mark requested by user\n");
2800 break;
2801
2802 case SC_HOTKEY:
2803 case SC_ARRANGE:
2804 case SC_NEXTWINDOW:
2805 case SC_PREVWINDOW:
2806 FIXME("unimplemented!\n");
2807 break;
2808 }
2809 WIN_ReleaseWndPtr(wndPtr);
2810 return 0;
2811 }
2812
2813 /*************************************************************
2814 * NC_DrawGrayButton
2815 *
2816 * Stub for the grayed button of the caption
2817 *
2818 *************************************************************/
2819
2820 BOOL NC_DrawGrayButton(HDC hdc, int x, int y)
2821 {
2822 HBITMAP hMaskBmp;
2823 HDC hdcMask = CreateCompatibleDC (0);
2824 HBRUSH hOldBrush;
2825
2826 hMaskBmp = CreateBitmap (12, 10, 1, 1, lpGrayMask);
2827
2828 if(hMaskBmp == 0)
2829 return FALSE;
2830
2831 SelectObject (hdcMask, hMaskBmp);
2832
2833 /* Draw the grayed bitmap using the mask */
2834 hOldBrush = SelectObject (hdc, RGB(128, 128, 128));
2835 BitBlt (hdc, x, y, 12, 10,
2836 hdcMask, 0, 0, 0xB8074A);
2837
2838 /* Clean up */
2839 SelectObject (hdc, hOldBrush);
2840 DeleteObject(hMaskBmp);
2841 DeleteDC (hdcMask);
2842
2843 return TRUE;
2844 }
2845
2846 HICON16 NC_IconForWindow(WND *wndPtr)
2847 {
2848 HICON16 hIcon = (HICON) GetClassLongA(wndPtr->hwndSelf, GCL_HICONSM);
2849 if(!hIcon) hIcon = (HICON) GetClassLongA(wndPtr->hwndSelf, GCL_HICON);
2850
2851 /* If there is no hIcon specified and this is a modal dialog, */
2852 /* get the default one. */
2853 if (!hIcon && (wndPtr->dwStyle & DS_MODALFRAME))
2854 hIcon = LoadImageA(0, MAKEINTRESOURCEA(OIC_WINEICON), IMAGE_ICON, 0, 0, LR_DEFAULTCOLOR);
2855
2856 return hIcon;
2857 }
Maarten's multimedia branch