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