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