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