configure: Use --rpath when linking dlls too.
[wine] / dlls / user / nonclient.c
1 /*
2  * Non-client area window functions
3  *
4  * Copyright 1994 Alexandre Julliard
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20
21 #include "config.h"
22
23 #include <stdarg.h>
24
25 #include "windef.h"
26 #include "winbase.h"
27 #include "wingdi.h"
28 #include "wine/winuser16.h"
29 #include "wownt32.h"
30 #include "win.h"
31 #include "user_private.h"
32 #include "controls.h"
33 #include "winpos.h"
34 #include "shellapi.h"
35 #include "wine/debug.h"
36
37 WINE_DEFAULT_DEBUG_CHANNEL(nonclient);
38
39 BOOL NC_DrawGrayButton(HDC hdc, int x, int y);
40
41 static const BYTE lpGrayMask[] = { 0xAA, 0xA0,
42                                    0x55, 0x50,
43                                    0xAA, 0xA0,
44                                    0x55, 0x50,
45                                    0xAA, 0xA0,
46                                    0x55, 0x50,
47                                    0xAA, 0xA0,
48                                    0x55, 0x50,
49                                    0xAA, 0xA0,
50                                    0x55, 0x50};
51
52 #define SC_ABOUTWINE            (SC_SCREENSAVE+1)
53 #define SC_PUTMARK              (SC_SCREENSAVE+2)
54
55   /* Some useful macros */
56 #define HAS_DLGFRAME(style,exStyle) \
57     (((exStyle) & WS_EX_DLGMODALFRAME) || \
58      (((style) & WS_DLGFRAME) && !((style) & WS_THICKFRAME)))
59
60 #define HAS_THICKFRAME(style,exStyle) \
61     (((style) & WS_THICKFRAME) && \
62      !(((style) & (WS_DLGFRAME|WS_BORDER)) == WS_DLGFRAME))
63
64 #define HAS_THINFRAME(style) \
65     (((style) & WS_BORDER) || !((style) & (WS_CHILD | WS_POPUP)))
66
67 #define HAS_BIGFRAME(style,exStyle) \
68     (((style) & (WS_THICKFRAME | WS_DLGFRAME)) || \
69      ((exStyle) & WS_EX_DLGMODALFRAME))
70
71 #define HAS_STATICOUTERFRAME(style,exStyle) \
72     (((exStyle) & (WS_EX_STATICEDGE|WS_EX_DLGMODALFRAME)) == \
73      WS_EX_STATICEDGE)
74
75 #define HAS_ANYFRAME(style,exStyle) \
76     (((style) & (WS_THICKFRAME | WS_DLGFRAME | WS_BORDER)) || \
77      ((exStyle) & WS_EX_DLGMODALFRAME) || \
78      !((style) & (WS_CHILD | WS_POPUP)))
79
80 #define HAS_MENU(w)  ((((w)->dwStyle & (WS_CHILD | WS_POPUP)) != WS_CHILD) && ((w)->wIDmenu != 0))
81
82
83 /******************************************************************************
84  * NC_AdjustRectOuter
85  *
86  * Computes the size of the "outside" parts of the window based on the
87  * parameters of the client area.
88  *
89  * PARAMS
90  *     LPRECT  rect
91  *     DWORD  style
92  *     BOOL  menu
93  *     DWORD  exStyle
94  *
95  * NOTES
96  *     "Outer" parts of a window means the whole window frame, caption and
97  *     menu bar. It does not include "inner" parts of the frame like client
98  *     edge, static edge or scroll bars.
99  *
100  *****************************************************************************/
101
102 static void
103 NC_AdjustRectOuter (LPRECT rect, DWORD style, BOOL menu, DWORD exStyle)
104 {
105     int adjust;
106     if(style & WS_ICONIC) return;
107
108     if ((exStyle & (WS_EX_STATICEDGE|WS_EX_DLGMODALFRAME)) ==
109         WS_EX_STATICEDGE)
110     {
111         adjust = 1; /* for the outer frame always present */
112     }
113     else
114     {
115         adjust = 0;
116         if ((exStyle & WS_EX_DLGMODALFRAME) ||
117             (style & (WS_THICKFRAME|WS_DLGFRAME))) adjust = 2; /* outer */
118     }
119     if (style & WS_THICKFRAME)
120         adjust +=  ( GetSystemMetrics (SM_CXFRAME)
121                    - GetSystemMetrics (SM_CXDLGFRAME)); /* The resize border */
122     if ((style & (WS_BORDER|WS_DLGFRAME)) ||
123         (exStyle & WS_EX_DLGMODALFRAME))
124         adjust++; /* The other border */
125
126     InflateRect (rect, adjust, adjust);
127
128     if ((style & WS_CAPTION) == WS_CAPTION)
129     {
130         if (exStyle & WS_EX_TOOLWINDOW)
131             rect->top -= GetSystemMetrics(SM_CYSMCAPTION);
132         else
133             rect->top -= GetSystemMetrics(SM_CYCAPTION);
134     }
135     if (menu) rect->top -= GetSystemMetrics(SM_CYMENU);
136 }
137
138
139 /******************************************************************************
140  * NC_AdjustRectInner
141  *
142  * Computes the size of the "inside" part of the window based on the
143  * parameters of the client area.
144  *
145  * PARAMS
146  *     LPRECT   rect
147  *     DWORD    style
148  *     DWORD    exStyle
149  *
150  * NOTES
151  *     "Inner" part of a window means the window frame inside of the flat
152  *     window frame. It includes the client edge, the static edge and the
153  *     scroll bars.
154  *
155  *****************************************************************************/
156
157 static void
158 NC_AdjustRectInner (LPRECT rect, DWORD style, DWORD exStyle)
159 {
160     if(style & WS_ICONIC) return;
161
162     if (exStyle & WS_EX_CLIENTEDGE)
163         InflateRect(rect, GetSystemMetrics(SM_CXEDGE), GetSystemMetrics(SM_CYEDGE));
164
165     if (style & WS_VSCROLL)
166     {
167         if((exStyle & WS_EX_LEFTSCROLLBAR) != 0)
168             rect->left  -= GetSystemMetrics(SM_CXVSCROLL);
169         else
170             rect->right += GetSystemMetrics(SM_CXVSCROLL);
171     }
172     if (style & WS_HSCROLL) rect->bottom += GetSystemMetrics(SM_CYHSCROLL);
173 }
174
175
176
177 static HICON NC_IconForWindow( HWND hwnd )
178 {
179     HICON hIcon = 0;
180     WND *wndPtr = WIN_GetPtr( hwnd );
181
182     if (wndPtr && wndPtr != WND_OTHER_PROCESS && wndPtr != WND_DESKTOP)
183     {
184         hIcon = wndPtr->hIconSmall;
185         if (!hIcon) hIcon = wndPtr->hIcon;
186         WIN_ReleasePtr( wndPtr );
187     }
188     if (!hIcon) hIcon = (HICON) GetClassLongPtrW( hwnd, GCLP_HICONSM );
189     if (!hIcon) hIcon = (HICON) GetClassLongPtrW( hwnd, GCLP_HICON );
190
191     /* If there is no hIcon specified and this is a modal dialog,
192      * get the default one.
193      */
194     if (!hIcon && (GetWindowLongW( hwnd, GWL_STYLE ) & DS_MODALFRAME))
195         hIcon = LoadImageW(0, (LPCWSTR)IDI_WINLOGO, IMAGE_ICON, 0, 0, LR_DEFAULTCOLOR);
196     return hIcon;
197 }
198
199 /* Draws the bar part(ie the big rectangle) of the caption */
200 static void NC_DrawCaptionBar (HDC hdc, const RECT *rect, DWORD dwStyle, 
201                                BOOL active, BOOL gradient)
202 {
203     if (gradient)
204     {
205         TRIVERTEX vertices[6];
206         DWORD colLeft = 
207             GetSysColor (active ? COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION);
208         DWORD colRight = 
209             GetSysColor (active ? COLOR_GRADIENTACTIVECAPTION 
210                                 : COLOR_GRADIENTINACTIVECAPTION);
211         int v;
212         int buttonsAreaSize = GetSystemMetrics(SM_CYCAPTION) - 1;
213         static GRADIENT_RECT mesh[] = {{0, 1}, {2, 3}, {4, 5}};
214     
215         for (v = 0; v < 3; v++)
216         {
217             vertices[v].Red = GetRValue (colLeft) << 8;
218             vertices[v].Green = GetGValue (colLeft) << 8;
219             vertices[v].Blue = GetBValue (colLeft) << 8;
220             vertices[v].Alpha = 0x8000;
221             vertices[v+3].Red = GetRValue (colRight) << 8;
222             vertices[v+3].Green = GetGValue (colRight) << 8;
223             vertices[v+3].Blue = GetBValue (colRight) << 8;
224             vertices[v+3].Alpha = 0x8000;
225         }
226     
227         if ((dwStyle & WS_SYSMENU) 
228             && ((dwStyle & WS_MAXIMIZEBOX) || (dwStyle & WS_MINIMIZEBOX)))
229             buttonsAreaSize += 2 * (GetSystemMetrics(SM_CXSIZE) + 1);
230         
231         /* area behind icon; solid filled with left color */
232         vertices[0].x = rect->left;
233         vertices[0].y = rect->top;
234         if (dwStyle & WS_SYSMENU) 
235             vertices[1].x = 
236                 min (rect->left + GetSystemMetrics(SM_CXSMICON), rect->right);
237         else
238             vertices[1].x = vertices[0].x;
239         vertices[1].y = rect->bottom;
240         
241         /* area behind text; gradient */
242         vertices[2].x = vertices[1].x;
243         vertices[2].y = rect->top;
244         vertices[3].x = max (vertices[2].x, rect->right - buttonsAreaSize);
245         vertices[3].y = rect->bottom;
246         
247         /* area behind buttons; solid filled with right color */
248         vertices[4].x = vertices[3].x;
249         vertices[4].y = rect->top;
250         vertices[5].x = rect->right;
251         vertices[5].y = rect->bottom;
252         
253         GdiGradientFill (hdc, vertices, 6, mesh, 3, GRADIENT_FILL_RECT_H);
254     }
255     else
256         FillRect (hdc, rect, GetSysColorBrush (active ?
257                   COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION));
258 }
259
260 /***********************************************************************
261  *              DrawCaption (USER32.@) Draws a caption bar
262  *
263  * PARAMS
264  *     hwnd   [I]
265  *     hdc    [I]
266  *     lpRect [I]
267  *     uFlags [I]
268  *
269  * RETURNS
270  *     Success:
271  *     Failure:
272  */
273
274 BOOL WINAPI
275 DrawCaption (HWND hwnd, HDC hdc, const RECT *lpRect, UINT uFlags)
276 {
277     return DrawCaptionTempW (hwnd, hdc, lpRect, 0, 0, NULL, uFlags & 0x103F);
278 }
279
280
281 /***********************************************************************
282  *              DrawCaptionTempA (USER32.@)
283  */
284 BOOL WINAPI DrawCaptionTempA (HWND hwnd, HDC hdc, const RECT *rect, HFONT hFont,
285                               HICON hIcon, LPCSTR str, UINT uFlags)
286 {
287     LPWSTR strW;
288     INT len;
289     BOOL ret = FALSE;
290
291     if (!(uFlags & DC_TEXT) || !str)
292         return DrawCaptionTempW( hwnd, hdc, rect, hFont, hIcon, NULL, uFlags );
293
294     len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
295     if ((strW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
296     {
297         MultiByteToWideChar( CP_ACP, 0, str, -1, strW, len );
298         ret = DrawCaptionTempW (hwnd, hdc, rect, hFont, hIcon, strW, uFlags);
299         HeapFree( GetProcessHeap (), 0, strW );
300     }
301     return ret;
302 }
303
304
305 /***********************************************************************
306  *              DrawCaptionTempW (USER32.@)
307  */
308 BOOL WINAPI DrawCaptionTempW (HWND hwnd, HDC hdc, const RECT *rect, HFONT hFont,
309                               HICON hIcon, LPCWSTR str, UINT uFlags)
310 {
311     RECT   rc = *rect;
312
313     TRACE("(%p,%p,%p,%p,%p,%s,%08x)\n",
314           hwnd, hdc, rect, hFont, hIcon, debugstr_w(str), uFlags);
315
316     /* drawing background */
317     if (uFlags & DC_INBUTTON) {
318         FillRect (hdc, &rc, GetSysColorBrush (COLOR_3DFACE));
319
320         if (uFlags & DC_ACTIVE) {
321             HBRUSH hbr = SelectObject (hdc, SYSCOLOR_55AABrush);
322             PatBlt (hdc, rc.left, rc.top,
323                       rc.right-rc.left, rc.bottom-rc.top, 0xFA0089);
324             SelectObject (hdc, hbr);
325         }
326     }
327     else {
328         DWORD style = GetWindowLongW (hwnd, GWL_STYLE);
329         NC_DrawCaptionBar (hdc, rect, style, uFlags & DC_ACTIVE, uFlags & DC_GRADIENT);
330     }
331
332
333     /* drawing icon */
334     if ((uFlags & DC_ICON) && !(uFlags & DC_SMALLCAP)) {
335         POINT pt;
336
337         pt.x = rc.left + 2;
338         pt.y = (rc.bottom + rc.top - GetSystemMetrics(SM_CYSMICON)) / 2;
339
340         if (!hIcon) hIcon = NC_IconForWindow(hwnd);
341         DrawIconEx (hdc, pt.x, pt.y, hIcon, GetSystemMetrics(SM_CXSMICON),
342                     GetSystemMetrics(SM_CYSMICON), 0, 0, DI_NORMAL);
343         rc.left += (rc.bottom - rc.top);
344     }
345
346     /* drawing text */
347     if (uFlags & DC_TEXT) {
348         HFONT hOldFont;
349
350         if (uFlags & DC_INBUTTON)
351             SetTextColor (hdc, GetSysColor (COLOR_BTNTEXT));
352         else if (uFlags & DC_ACTIVE)
353             SetTextColor (hdc, GetSysColor (COLOR_CAPTIONTEXT));
354         else
355             SetTextColor (hdc, GetSysColor (COLOR_INACTIVECAPTIONTEXT));
356
357         SetBkMode (hdc, TRANSPARENT);
358
359         if (hFont)
360             hOldFont = SelectObject (hdc, hFont);
361         else {
362             NONCLIENTMETRICSW nclm;
363             HFONT hNewFont;
364             nclm.cbSize = sizeof(NONCLIENTMETRICSW);
365             SystemParametersInfoW (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0);
366             hNewFont = CreateFontIndirectW ((uFlags & DC_SMALLCAP) ?
367                 &nclm.lfSmCaptionFont : &nclm.lfCaptionFont);
368             hOldFont = SelectObject (hdc, hNewFont);
369         }
370
371         if (str)
372             DrawTextW (hdc, str, -1, &rc,
373                          DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT);
374         else {
375             WCHAR szText[128];
376             INT nLen;
377             nLen = GetWindowTextW (hwnd, szText, 128);
378             DrawTextW (hdc, szText, nLen, &rc,
379                          DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT);
380         }
381
382         if (hFont)
383             SelectObject (hdc, hOldFont);
384         else
385             DeleteObject (SelectObject (hdc, hOldFont));
386     }
387
388     /* drawing focus ??? */
389     if (uFlags & 0x2000)
390         FIXME("undocumented flag (0x2000)!\n");
391
392     return 0;
393 }
394
395
396 /***********************************************************************
397  *              AdjustWindowRect (USER32.@)
398  */
399 BOOL WINAPI AdjustWindowRect( LPRECT rect, DWORD style, BOOL menu )
400 {
401     return AdjustWindowRectEx( rect, style, menu, 0 );
402 }
403
404
405 /***********************************************************************
406  *              AdjustWindowRectEx (USER32.@)
407  */
408 BOOL WINAPI AdjustWindowRectEx( LPRECT rect, DWORD style, BOOL menu, DWORD exStyle )
409 {
410     /* Correct the window style */
411     style &= (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME | WS_CHILD);
412     exStyle &= (WS_EX_DLGMODALFRAME | WS_EX_CLIENTEDGE |
413                 WS_EX_STATICEDGE | WS_EX_TOOLWINDOW);
414     if (exStyle & WS_EX_DLGMODALFRAME) style &= ~WS_THICKFRAME;
415
416     TRACE("(%ld,%ld)-(%ld,%ld) %08lx %d %08lx\n",
417           rect->left, rect->top, rect->right, rect->bottom,
418           style, menu, exStyle );
419
420     NC_AdjustRectOuter( rect, style, menu, exStyle );
421     NC_AdjustRectInner( rect, style, exStyle );
422
423     return TRUE;
424 }
425
426
427 /***********************************************************************
428  *           NC_HandleNCCalcSize
429  *
430  * Handle a WM_NCCALCSIZE message. Called from DefWindowProc().
431  */
432 LRESULT NC_HandleNCCalcSize( HWND hwnd, RECT *winRect )
433 {
434     RECT tmpRect = { 0, 0, 0, 0 };
435     LRESULT result = 0;
436     LONG cls_style = GetClassLongW(hwnd, GCL_STYLE);
437     LONG style = GetWindowLongW( hwnd, GWL_STYLE );
438     LONG exStyle = GetWindowLongW( hwnd, GWL_EXSTYLE );
439
440     if (cls_style & CS_VREDRAW) result |= WVR_VREDRAW;
441     if (cls_style & CS_HREDRAW) result |= WVR_HREDRAW;
442
443     if (!IsIconic(hwnd))
444     {
445         NC_AdjustRectOuter( &tmpRect, style, FALSE, exStyle );
446
447         winRect->left   -= tmpRect.left;
448         winRect->top    -= tmpRect.top;
449         winRect->right  -= tmpRect.right;
450         winRect->bottom -= tmpRect.bottom;
451
452         if (((style & (WS_CHILD | WS_POPUP)) != WS_CHILD) && GetMenu(hwnd))
453         {
454             TRACE("Calling GetMenuBarHeight with hwnd %p, width %ld, at (%ld, %ld).\n",
455                   hwnd, winRect->right - winRect->left, -tmpRect.left, -tmpRect.top );
456
457             winRect->top +=
458                 MENU_GetMenuBarHeight( hwnd,
459                                        winRect->right - winRect->left,
460                                        -tmpRect.left, -tmpRect.top );
461         }
462
463         if( exStyle & WS_EX_CLIENTEDGE)
464             if( winRect->right - winRect->left > 2 * GetSystemMetrics(SM_CXEDGE) &&
465                    winRect->bottom - winRect->top > 2 * GetSystemMetrics(SM_CYEDGE))
466                 InflateRect( winRect, - GetSystemMetrics(SM_CXEDGE),
467                         - GetSystemMetrics(SM_CYEDGE));
468
469         if (style & WS_VSCROLL)
470             if( winRect->right - winRect->left >= GetSystemMetrics(SM_CXVSCROLL)){
471                 if((exStyle & WS_EX_LEFTSCROLLBAR) != 0)
472                     winRect->left  += GetSystemMetrics(SM_CXVSCROLL);
473                 else
474                     winRect->right -= GetSystemMetrics(SM_CXVSCROLL);
475             }
476
477         if (style & WS_HSCROLL)
478             if( winRect->bottom - winRect->top > GetSystemMetrics(SM_CYHSCROLL))
479                     winRect->bottom -= GetSystemMetrics(SM_CYHSCROLL);
480
481         if (winRect->top > winRect->bottom)
482             winRect->bottom = winRect->top;
483
484         if (winRect->left > winRect->right)
485             winRect->right = winRect->left;
486     }
487     return result;
488 }
489
490
491 /***********************************************************************
492  *           NC_GetInsideRect
493  *
494  * Get the 'inside' rectangle of a window, i.e. the whole window rectangle
495  * but without the borders (if any).
496  * The rectangle is in window coordinates (for drawing with GetWindowDC()).
497  */
498 static void NC_GetInsideRect( HWND hwnd, RECT *rect )
499 {
500     WND *wndPtr = WIN_GetPtr( hwnd );
501
502     if (!wndPtr || wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP) return;
503
504     rect->top    = rect->left = 0;
505     rect->right  = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
506     rect->bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
507
508     if (wndPtr->dwStyle & WS_ICONIC) goto END;
509
510     /* Remove frame from rectangle */
511     if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
512     {
513         InflateRect( rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
514     }
515     else if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
516     {
517         InflateRect( rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
518     }
519     else if (HAS_THINFRAME( wndPtr->dwStyle ))
520     {
521         InflateRect( rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER) );
522     }
523
524     /* We have additional border information if the window
525      * is a child (but not an MDI child) */
526     if ( (wndPtr->dwStyle & WS_CHILD)  &&
527          ( (wndPtr->dwExStyle & WS_EX_MDICHILD) == 0 ) )
528     {
529         if (wndPtr->dwExStyle & WS_EX_CLIENTEDGE)
530             InflateRect (rect, -GetSystemMetrics(SM_CXEDGE), -GetSystemMetrics(SM_CYEDGE));
531         if (wndPtr->dwExStyle & WS_EX_STATICEDGE)
532             InflateRect (rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
533     }
534
535 END:
536     WIN_ReleasePtr( wndPtr );
537 }
538
539
540 /***********************************************************************
541  * NC_DoNCHitTest
542  *
543  * Handle a WM_NCHITTEST message. Called from NC_HandleNCHitTest().
544  *
545  * FIXME:  Just a modified copy of the Win 3.1 version.
546  */
547
548 static LRESULT NC_DoNCHitTest (WND *wndPtr, POINT pt )
549 {
550     RECT rect, rcClient;
551     POINT ptClient;
552
553     TRACE("hwnd=%p pt=%ld,%ld\n", wndPtr->hwndSelf, pt.x, pt.y );
554
555     GetWindowRect(wndPtr->hwndSelf, &rect );
556     if (!PtInRect( &rect, pt )) return HTNOWHERE;
557
558     if (wndPtr->dwStyle & WS_MINIMIZE) return HTCAPTION;
559
560     /* Check client area */
561     ptClient = pt;
562     ScreenToClient( wndPtr->hwndSelf, &ptClient );
563     GetClientRect( wndPtr->hwndSelf, &rcClient );
564     if (PtInRect( &rcClient, ptClient )) return HTCLIENT;
565
566     /* Check borders */
567     if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
568     {
569         InflateRect( &rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
570         if (!PtInRect( &rect, pt ))
571         {
572             /* Check top sizing border */
573             if (pt.y < rect.top)
574             {
575                 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTTOPLEFT;
576                 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTTOPRIGHT;
577                 return HTTOP;
578             }
579             /* Check bottom sizing border */
580             if (pt.y >= rect.bottom)
581             {
582                 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMLEFT;
583                 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMRIGHT;
584                 return HTBOTTOM;
585             }
586             /* Check left sizing border */
587             if (pt.x < rect.left)
588             {
589                 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPLEFT;
590                 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMLEFT;
591                 return HTLEFT;
592             }
593             /* Check right sizing border */
594             if (pt.x >= rect.right)
595             {
596                 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPRIGHT;
597                 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMRIGHT;
598                 return HTRIGHT;
599             }
600         }
601     }
602     else  /* No thick frame */
603     {
604         if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
605             InflateRect(&rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
606         else if (HAS_THINFRAME( wndPtr->dwStyle ))
607             InflateRect(&rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
608         if (!PtInRect( &rect, pt )) return HTBORDER;
609     }
610
611     /* Check caption */
612
613     if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
614     {
615         if (wndPtr->dwExStyle & WS_EX_TOOLWINDOW)
616             rect.top += GetSystemMetrics(SM_CYSMCAPTION) - 1;
617         else
618             rect.top += GetSystemMetrics(SM_CYCAPTION) - 1;
619         if (!PtInRect( &rect, pt ))
620         {
621             BOOL min_or_max_box = (wndPtr->dwStyle & WS_MAXIMIZEBOX) ||
622                                   (wndPtr->dwStyle & WS_MINIMIZEBOX);
623             /* Check system menu */
624             if ((wndPtr->dwStyle & WS_SYSMENU) && !(wndPtr->dwExStyle & WS_EX_TOOLWINDOW))
625             {
626                 if (NC_IconForWindow(wndPtr->hwndSelf))
627                     rect.left += GetSystemMetrics(SM_CYCAPTION) - 1;
628             }
629             if (pt.x < rect.left) return HTSYSMENU;
630
631             /* Check close button */
632             if (wndPtr->dwStyle & WS_SYSMENU)
633                 rect.right -= GetSystemMetrics(SM_CYCAPTION) - 1;
634             if (pt.x > rect.right) return HTCLOSE;
635
636             /* Check maximize box */
637             /* In win95 there is automatically a Maximize button when there is a minimize one*/
638             if (min_or_max_box && !(wndPtr->dwExStyle & WS_EX_TOOLWINDOW))
639                 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
640             if (pt.x > rect.right) return HTMAXBUTTON;
641
642             /* Check minimize box */
643             /* In win95 there is automatically a Maximize button when there is a Maximize one*/
644             if (min_or_max_box && !(wndPtr->dwExStyle & WS_EX_TOOLWINDOW))
645                 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
646
647             if (pt.x > rect.right) return HTMINBUTTON;
648             return HTCAPTION;
649         }
650     }
651
652       /* Check vertical scroll bar */
653
654     if (wndPtr->dwStyle & WS_VSCROLL)
655     {
656         if((wndPtr->dwExStyle & WS_EX_LEFTSCROLLBAR) != 0)
657             rcClient.left -= GetSystemMetrics(SM_CXVSCROLL);
658         else
659             rcClient.right += GetSystemMetrics(SM_CXVSCROLL);
660         if (PtInRect( &rcClient, ptClient )) return HTVSCROLL;
661     }
662
663       /* Check horizontal scroll bar */
664
665     if (wndPtr->dwStyle & WS_HSCROLL)
666     {
667         rcClient.bottom += GetSystemMetrics(SM_CYHSCROLL);
668         if (PtInRect( &rcClient, ptClient ))
669         {
670             /* Check size box */
671             if ((wndPtr->dwStyle & WS_VSCROLL) &&
672                 ((((wndPtr->dwExStyle & WS_EX_LEFTSCROLLBAR) != 0) && (ptClient.x <= rcClient.left + GetSystemMetrics(SM_CXVSCROLL))) ||
673                 (((wndPtr->dwExStyle & WS_EX_LEFTSCROLLBAR) == 0) && (ptClient.x >= rcClient.right - GetSystemMetrics(SM_CXVSCROLL)))))
674                 return HTSIZE;
675             return HTHSCROLL;
676         }
677     }
678
679       /* Check menu bar */
680
681     if (HAS_MENU(wndPtr))
682     {
683         if ((ptClient.y < 0) && (ptClient.x >= 0) && (ptClient.x < rcClient.right))
684             return HTMENU;
685     }
686
687     /* Has to return HTNOWHERE if nothing was found
688        Could happen when a window has a customized non client area */
689     return HTNOWHERE;
690 }
691
692
693 /***********************************************************************
694  * NC_HandleNCHitTest
695  *
696  * Handle a WM_NCHITTEST message. Called from DefWindowProc().
697  */
698 LRESULT NC_HandleNCHitTest (HWND hwnd , POINT pt)
699 {
700     LRESULT retvalue;
701     WND *wndPtr = WIN_GetPtr( hwnd );
702
703     if (!wndPtr || wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP) return HTERROR;
704
705     retvalue = NC_DoNCHitTest (wndPtr, pt);
706     WIN_ReleasePtr( wndPtr );
707     return retvalue;
708 }
709
710
711 /******************************************************************************
712  *
713  *   NC_DrawSysButton
714  *
715  *   Draws the system icon.
716  *
717  *****************************************************************************/
718 BOOL NC_DrawSysButton (HWND hwnd, HDC hdc, BOOL down)
719 {
720     HICON hIcon = NC_IconForWindow( hwnd );
721
722     if (hIcon)
723     {
724         RECT rect;
725         NC_GetInsideRect( hwnd, &rect );
726         DrawIconEx (hdc, rect.left + 2, rect.top + 1, hIcon,
727                     GetSystemMetrics(SM_CXSMICON),
728                     GetSystemMetrics(SM_CYSMICON), 0, 0, DI_NORMAL);
729     }
730     return (hIcon != 0);
731 }
732
733
734 /******************************************************************************
735  *
736  *   NC_DrawCloseButton
737  *
738  *   Draws the close button.
739  *
740  *   If bGrayed is true, then draw a disabled Close button
741  *
742  *****************************************************************************/
743
744 static void NC_DrawCloseButton (HWND hwnd, HDC hdc, BOOL down, BOOL bGrayed)
745 {
746     RECT rect;
747
748     NC_GetInsideRect( hwnd, &rect );
749
750     /* A tool window has a smaller Close button */
751     if (GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_TOOLWINDOW)
752     {
753         INT iBmpHeight = 11; /* Windows does not use SM_CXSMSIZE and SM_CYSMSIZE   */
754         INT iBmpWidth = 11;  /* it uses 11x11 for  the close button in tool window */
755         INT iCaptionHeight = GetSystemMetrics(SM_CYSMCAPTION);
756
757         rect.top = rect.top + (iCaptionHeight - 1 - iBmpHeight) / 2;
758         rect.left = rect.right - (iCaptionHeight + 1 + iBmpWidth) / 2;
759         rect.bottom = rect.top + iBmpHeight;
760         rect.right = rect.left + iBmpWidth;
761     }
762     else
763     {
764         rect.left = rect.right - GetSystemMetrics(SM_CXSIZE) - 1;
765         rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 1;
766         rect.top += 2;
767         rect.right -= 2;
768     }
769     DrawFrameControl( hdc, &rect, DFC_CAPTION,
770                       (DFCS_CAPTIONCLOSE |
771                        (down ? DFCS_PUSHED : 0) |
772                        (bGrayed ? DFCS_INACTIVE : 0)) );
773 }
774
775 /******************************************************************************
776  *   NC_DrawMaxButton
777  *
778  *   Draws the maximize button for windows.
779  *   If bGrayed is true, then draw a disabled Maximize button
780  */
781 static void NC_DrawMaxButton(HWND hwnd,HDC hdc,BOOL down, BOOL bGrayed)
782 {
783     RECT rect;
784     UINT flags;
785
786     /* never draw maximize box when window has WS_EX_TOOLWINDOW style */
787     if (GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_TOOLWINDOW)
788         return;
789
790     flags = IsZoomed(hwnd) ? DFCS_CAPTIONRESTORE : DFCS_CAPTIONMAX;
791
792     NC_GetInsideRect( hwnd, &rect );
793     if (GetWindowLongW( hwnd, GWL_STYLE) & WS_SYSMENU)
794         rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
795     rect.left = rect.right - GetSystemMetrics(SM_CXSIZE);
796     rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 1;
797     rect.top += 2;
798     rect.right -= 2;
799     if (down) flags |= DFCS_PUSHED;
800     if (bGrayed) flags |= DFCS_INACTIVE;
801     DrawFrameControl( hdc, &rect, DFC_CAPTION, flags );
802 }
803
804 /******************************************************************************
805  *   NC_DrawMinButton
806  *
807  *   Draws the minimize button for windows.
808  *   If bGrayed is true, then draw a disabled Minimize button
809  */
810 static void  NC_DrawMinButton(HWND hwnd,HDC hdc,BOOL down, BOOL bGrayed)
811 {
812     RECT rect;
813     UINT flags = DFCS_CAPTIONMIN;
814     DWORD style = GetWindowLongW( hwnd, GWL_STYLE );
815
816     /* never draw minimize box when window has WS_EX_TOOLWINDOW style */
817     if (GetWindowLongW( hwnd, GWL_EXSTYLE ) & WS_EX_TOOLWINDOW)
818         return;
819
820     NC_GetInsideRect( hwnd, &rect );
821     if (style & WS_SYSMENU)
822         rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
823     if (style & (WS_MAXIMIZEBOX|WS_MINIMIZEBOX))
824         rect.right -= GetSystemMetrics(SM_CXSIZE) - 2;
825     rect.left = rect.right - GetSystemMetrics(SM_CXSIZE);
826     rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 1;
827     rect.top += 2;
828     rect.right -= 2;
829     if (down) flags |= DFCS_PUSHED;
830     if (bGrayed) flags |= DFCS_INACTIVE;
831     DrawFrameControl( hdc, &rect, DFC_CAPTION, flags );
832 }
833
834 /******************************************************************************
835  *
836  *   NC_DrawFrame
837  *
838  *   Draw a window frame inside the given rectangle, and update the rectangle.
839  *
840  *   Bugs
841  *        Many.  First, just what IS a frame in Win95?  Note that the 3D look
842  *        on the outer edge is handled by NC_DoNCPaint.  As is the inner
843  *        edge.  The inner rectangle just inside the frame is handled by the
844  *        Caption code.
845  *
846  *        In short, for most people, this function should be a nop (unless
847  *        you LIKE thick borders in Win95/NT4.0 -- I've been working with
848  *        them lately, but just to get this code right).  Even so, it doesn't
849  *        appear to be so.  It's being worked on...
850  *
851  *****************************************************************************/
852
853 static void  NC_DrawFrame( HDC  hdc, RECT  *rect, BOOL  active, DWORD style, DWORD exStyle)
854 {
855     INT width, height;
856
857     /* Firstly the "thick" frame */
858     if (style & WS_THICKFRAME)
859     {
860         width = GetSystemMetrics(SM_CXFRAME) - GetSystemMetrics(SM_CXDLGFRAME);
861         height = GetSystemMetrics(SM_CYFRAME) - GetSystemMetrics(SM_CYDLGFRAME);
862
863         SelectObject( hdc, GetSysColorBrush(active ? COLOR_ACTIVEBORDER :
864                                             COLOR_INACTIVEBORDER) );
865         /* Draw frame */
866         PatBlt( hdc, rect->left, rect->top,
867                   rect->right - rect->left, height, PATCOPY );
868         PatBlt( hdc, rect->left, rect->top,
869                   width, rect->bottom - rect->top, PATCOPY );
870         PatBlt( hdc, rect->left, rect->bottom - 1,
871                   rect->right - rect->left, -height, PATCOPY );
872         PatBlt( hdc, rect->right - 1, rect->top,
873                   -width, rect->bottom - rect->top, PATCOPY );
874
875         InflateRect( rect, -width, -height );
876     }
877
878     /* Now the other bit of the frame */
879     if ((style & (WS_BORDER|WS_DLGFRAME)) ||
880         (exStyle & WS_EX_DLGMODALFRAME))
881     {
882         width = GetSystemMetrics(SM_CXDLGFRAME) - GetSystemMetrics(SM_CXEDGE);
883         height = GetSystemMetrics(SM_CYDLGFRAME) - GetSystemMetrics(SM_CYEDGE);
884         /* This should give a value of 1 that should also work for a border */
885
886         SelectObject( hdc, GetSysColorBrush(
887                       (exStyle & (WS_EX_DLGMODALFRAME|WS_EX_CLIENTEDGE)) ?
888                           COLOR_3DFACE :
889                       (exStyle & WS_EX_STATICEDGE) ?
890                           COLOR_WINDOWFRAME :
891                       (style & (WS_DLGFRAME|WS_THICKFRAME)) ?
892                           COLOR_3DFACE :
893                       /* else */
894                           COLOR_WINDOWFRAME));
895
896         /* Draw frame */
897         PatBlt( hdc, rect->left, rect->top,
898                   rect->right - rect->left, height, PATCOPY );
899         PatBlt( hdc, rect->left, rect->top,
900                   width, rect->bottom - rect->top, PATCOPY );
901         PatBlt( hdc, rect->left, rect->bottom - 1,
902                   rect->right - rect->left, -height, PATCOPY );
903         PatBlt( hdc, rect->right - 1, rect->top,
904                   -width, rect->bottom - rect->top, PATCOPY );
905
906         InflateRect( rect, -width, -height );
907     }
908 }
909
910
911 /******************************************************************************
912  *
913  *   NC_DrawCaption
914  *
915  *   Draw the window caption for windows.
916  *   The correct pen for the window frame must be selected in the DC.
917  *
918  *****************************************************************************/
919
920 static void  NC_DrawCaption( HDC  hdc, RECT *rect, HWND hwnd, DWORD  style, 
921                              DWORD  exStyle, BOOL active )
922 {
923     RECT  r = *rect;
924     WCHAR buffer[256];
925     HPEN  hPrevPen;
926     HMENU hSysMenu;
927     BOOL gradient = FALSE;
928
929     hPrevPen = SelectObject( hdc, SYSCOLOR_GetPen(
930                      ((exStyle & (WS_EX_STATICEDGE|WS_EX_CLIENTEDGE|
931                                  WS_EX_DLGMODALFRAME)) == WS_EX_STATICEDGE) ?
932                       COLOR_WINDOWFRAME : COLOR_3DFACE) );
933     MoveToEx( hdc, r.left, r.bottom - 1, NULL );
934     LineTo( hdc, r.right, r.bottom - 1 );
935     SelectObject( hdc, hPrevPen );
936     r.bottom--;
937
938     SystemParametersInfoW (SPI_GETGRADIENTCAPTIONS, 0, &gradient, 0);
939     NC_DrawCaptionBar (hdc, rect, style, active, gradient);
940
941     if ((style & WS_SYSMENU) && !(exStyle & WS_EX_TOOLWINDOW)) {
942         if (NC_DrawSysButton (hwnd, hdc, FALSE))
943             r.left += GetSystemMetrics(SM_CXSMICON) + 2;
944     }
945
946     if (style & WS_SYSMENU)
947     {
948         UINT state;
949
950         /* Go get the sysmenu */
951         hSysMenu = GetSystemMenu(hwnd, FALSE);
952         state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
953
954         /* Draw a grayed close button if disabled or if SC_CLOSE is not there */
955         NC_DrawCloseButton (hwnd, hdc, FALSE,
956                             (state & (MF_DISABLED | MF_GRAYED)) || (state == 0xFFFFFFFF));
957         r.right -= GetSystemMetrics(SM_CYCAPTION) - 1;
958
959         if ((style & WS_MAXIMIZEBOX) || (style & WS_MINIMIZEBOX))
960         {
961             /* In win95 the two buttons are always there */
962             /* But if the menu item is not in the menu they're disabled*/
963
964             NC_DrawMaxButton( hwnd, hdc, FALSE, (!(style & WS_MAXIMIZEBOX)));
965             r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
966
967             NC_DrawMinButton( hwnd, hdc, FALSE,  (!(style & WS_MINIMIZEBOX)));
968             r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
969         }
970     }
971
972     if (InternalGetWindowText( hwnd, buffer, sizeof(buffer)/sizeof(WCHAR) ))
973     {
974         NONCLIENTMETRICSW nclm;
975         HFONT hFont, hOldFont;
976         nclm.cbSize = sizeof(nclm);
977         SystemParametersInfoW (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0);
978         if (exStyle & WS_EX_TOOLWINDOW)
979             hFont = CreateFontIndirectW (&nclm.lfSmCaptionFont);
980         else
981             hFont = CreateFontIndirectW (&nclm.lfCaptionFont);
982         hOldFont = SelectObject (hdc, hFont);
983         if (active) SetTextColor( hdc, GetSysColor( COLOR_CAPTIONTEXT ) );
984         else SetTextColor( hdc, GetSysColor( COLOR_INACTIVECAPTIONTEXT ) );
985         SetBkMode( hdc, TRANSPARENT );
986         r.left += 2;
987         DrawTextW( hdc, buffer, -1, &r,
988                      DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT );
989         DeleteObject (SelectObject (hdc, hOldFont));
990     }
991 }
992
993
994 /******************************************************************************
995  *   NC_DoNCPaint
996  *
997  *   Paint the non-client area for windows.
998  */
999 static void  NC_DoNCPaint( HWND  hwnd, HRGN  clip, BOOL  suppress_menupaint )
1000 {
1001     HDC hdc;
1002     RECT rfuzz, rect, rectClip;
1003     BOOL active;
1004     WND *wndPtr;
1005     DWORD dwStyle, dwExStyle;
1006     WORD flags;
1007     HRGN hrgn;
1008     RECT rectClient, rectWindow;
1009     int has_menu;
1010
1011     if (!(wndPtr = WIN_GetPtr( hwnd )) || wndPtr == WND_OTHER_PROCESS) return;
1012     has_menu = HAS_MENU(wndPtr);
1013     dwStyle = wndPtr->dwStyle;
1014     dwExStyle = wndPtr->dwExStyle;
1015     flags = wndPtr->flags;
1016     rectWindow = wndPtr->rectWindow;
1017     WIN_ReleasePtr( wndPtr );
1018
1019     if ( dwStyle & WS_MINIMIZE ||
1020          !WIN_IsWindowDrawable( hwnd, 0 )) return; /* Nothing to do */
1021
1022     active  = flags & WIN_NCACTIVATED;
1023
1024     TRACE("%p %d\n", hwnd, active );
1025
1026     /* MSDN docs are pretty idiotic here, they say app CAN use clipRgn in
1027        the call to GetDCEx implying that it is allowed not to use it either.
1028        However, the suggested GetDCEx(    , DCX_WINDOW | DCX_INTERSECTRGN)
1029        will cause clipRgn to be deleted after ReleaseDC().
1030        Now, how is the "system" supposed to tell what happened?
1031      */
1032
1033     GetClientRect( hwnd, &rectClient );
1034     MapWindowPoints( hwnd, 0, (POINT *)&rectClient, 2 );
1035     hrgn = CreateRectRgnIndirect( &rectClient );
1036
1037     if (clip > (HRGN)1)
1038     {
1039         CombineRgn( hrgn, clip, hrgn, RGN_DIFF );
1040         hdc = GetDCEx( hwnd, hrgn, DCX_USESTYLE | DCX_WINDOW | DCX_INTERSECTRGN );
1041     }
1042     else
1043     {
1044         hdc = GetDCEx( hwnd, hrgn, DCX_USESTYLE | DCX_WINDOW | DCX_EXCLUDERGN );
1045     }
1046
1047     if (!hdc) return;
1048
1049     rect.top = rect.left = 0;
1050     rect.right  = rectWindow.right - rectWindow.left;
1051     rect.bottom = rectWindow.bottom - rectWindow.top;
1052     GetClipBox( hdc, &rectClip );
1053
1054     SelectObject( hdc, SYSCOLOR_GetPen(COLOR_WINDOWFRAME) );
1055
1056     if (HAS_STATICOUTERFRAME(dwStyle, dwExStyle)) {
1057         DrawEdge (hdc, &rect, BDR_SUNKENOUTER, BF_RECT | BF_ADJUST);
1058     }
1059     else if (HAS_BIGFRAME( dwStyle, dwExStyle)) {
1060         DrawEdge (hdc, &rect, EDGE_RAISED, BF_RECT | BF_ADJUST);
1061     }
1062
1063     NC_DrawFrame(hdc, &rect, active, dwStyle, dwExStyle );
1064
1065     if ((dwStyle & WS_CAPTION) == WS_CAPTION)
1066     {
1067         RECT  r = rect;
1068         if (dwExStyle & WS_EX_TOOLWINDOW) {
1069             r.bottom = rect.top + GetSystemMetrics(SM_CYSMCAPTION);
1070             rect.top += GetSystemMetrics(SM_CYSMCAPTION);
1071         }
1072         else {
1073             r.bottom = rect.top + GetSystemMetrics(SM_CYCAPTION);
1074             rect.top += GetSystemMetrics(SM_CYCAPTION);
1075         }
1076         if( IntersectRect( &rfuzz, &r, &rectClip ) )
1077             NC_DrawCaption(hdc, &r, hwnd, dwStyle, dwExStyle, active);
1078     }
1079
1080     if (has_menu)
1081     {
1082         RECT r = rect;
1083         r.bottom = rect.top + GetSystemMetrics(SM_CYMENU);
1084
1085         TRACE("Calling DrawMenuBar with rect (%ld, %ld)-(%ld, %ld)\n",
1086               r.left, r.top, r.right, r.bottom);
1087
1088         rect.top += MENU_DrawMenuBar( hdc, &r, hwnd, suppress_menupaint ) + 1;
1089     }
1090
1091     TRACE("After MenuBar, rect is (%ld, %ld)-(%ld, %ld).\n",
1092           rect.left, rect.top, rect.right, rect.bottom );
1093
1094     if (dwExStyle & WS_EX_CLIENTEDGE)
1095         DrawEdge (hdc, &rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
1096
1097     /* Draw the scroll-bars */
1098
1099     if (dwStyle & WS_VSCROLL)
1100         SCROLL_DrawScrollBar( hwnd, hdc, SB_VERT, TRUE, TRUE );
1101     if (dwStyle & WS_HSCROLL)
1102         SCROLL_DrawScrollBar( hwnd, hdc, SB_HORZ, TRUE, TRUE );
1103
1104     /* Draw the "size-box" */
1105     if ((dwStyle & WS_VSCROLL) && (dwStyle & WS_HSCROLL))
1106     {
1107         RECT r = rect;
1108         if((dwExStyle & WS_EX_LEFTSCROLLBAR) != 0)
1109             r.right = r.left + GetSystemMetrics(SM_CXVSCROLL) + 1;
1110         else
1111             r.left = r.right - GetSystemMetrics(SM_CXVSCROLL) + 1;
1112         r.top  = r.bottom - GetSystemMetrics(SM_CYHSCROLL) + 1;
1113         FillRect( hdc, &r,  GetSysColorBrush(COLOR_SCROLLBAR) );
1114     }
1115
1116     ReleaseDC( hwnd, hdc );
1117 }
1118
1119
1120
1121
1122 /***********************************************************************
1123  *           NC_HandleNCPaint
1124  *
1125  * Handle a WM_NCPAINT message. Called from DefWindowProc().
1126  */
1127 LRESULT NC_HandleNCPaint( HWND hwnd , HRGN clip)
1128 {
1129     DWORD dwStyle = GetWindowLongW( hwnd, GWL_STYLE );
1130
1131     if( dwStyle & WS_VISIBLE )
1132     {
1133         if( dwStyle & WS_MINIMIZE )
1134             WINPOS_RedrawIconTitle( hwnd );
1135         else
1136             NC_DoNCPaint( hwnd, clip, FALSE );
1137     }
1138     return 0;
1139 }
1140
1141
1142 /***********************************************************************
1143  *           NC_HandleNCActivate
1144  *
1145  * Handle a WM_NCACTIVATE message. Called from DefWindowProc().
1146  */
1147 LRESULT NC_HandleNCActivate( HWND hwnd, WPARAM wParam )
1148 {
1149     WND* wndPtr = WIN_GetPtr( hwnd );
1150
1151     if (!wndPtr || wndPtr == WND_OTHER_PROCESS) return FALSE;
1152
1153     /* Lotus Notes draws menu descriptions in the caption of its main
1154      * window. When it wants to restore original "system" view, it just
1155      * sends WM_NCACTIVATE message to itself. Any optimizations here in
1156      * attempt to minimize redrawings lead to a not restored caption.
1157      */
1158     if (wParam) wndPtr->flags |= WIN_NCACTIVATED;
1159     else wndPtr->flags &= ~WIN_NCACTIVATED;
1160     WIN_ReleasePtr( wndPtr );
1161
1162     if (IsIconic(hwnd))
1163         WINPOS_RedrawIconTitle( hwnd );
1164     else
1165         NC_DoNCPaint( hwnd, (HRGN)1, FALSE );
1166
1167     return TRUE;
1168 }
1169
1170
1171 /***********************************************************************
1172  *           NC_HandleSetCursor
1173  *
1174  * Handle a WM_SETCURSOR message. Called from DefWindowProc().
1175  */
1176 LRESULT NC_HandleSetCursor( HWND hwnd, WPARAM wParam, LPARAM lParam )
1177 {
1178     hwnd = WIN_GetFullHandle( (HWND)wParam );
1179
1180     switch((short)LOWORD(lParam))
1181     {
1182     case HTERROR:
1183         {
1184             WORD msg = HIWORD( lParam );
1185             if ((msg == WM_LBUTTONDOWN) || (msg == WM_MBUTTONDOWN) ||
1186                 (msg == WM_RBUTTONDOWN) || (msg == WM_XBUTTONDOWN))
1187                 MessageBeep(0);
1188         }
1189         break;
1190
1191     case HTCLIENT:
1192         {
1193             HCURSOR hCursor = (HCURSOR)GetClassLongPtrW(hwnd, GCLP_HCURSOR);
1194             if(hCursor) {
1195                 SetCursor(hCursor);
1196                 return TRUE;
1197             }
1198             return FALSE;
1199         }
1200
1201     case HTLEFT:
1202     case HTRIGHT:
1203         return (LRESULT)SetCursor( LoadCursorA( 0, (LPSTR)IDC_SIZEWE ) );
1204
1205     case HTTOP:
1206     case HTBOTTOM:
1207         return (LRESULT)SetCursor( LoadCursorA( 0, (LPSTR)IDC_SIZENS ) );
1208
1209     case HTTOPLEFT:
1210     case HTBOTTOMRIGHT:
1211         return (LRESULT)SetCursor( LoadCursorA( 0, (LPSTR)IDC_SIZENWSE ) );
1212
1213     case HTTOPRIGHT:
1214     case HTBOTTOMLEFT:
1215         return (LRESULT)SetCursor( LoadCursorA( 0, (LPSTR)IDC_SIZENESW ) );
1216     }
1217
1218     /* Default cursor: arrow */
1219     return (LRESULT)SetCursor( LoadCursorA( 0, (LPSTR)IDC_ARROW ) );
1220 }
1221
1222 /***********************************************************************
1223  *           NC_GetSysPopupPos
1224  */
1225 void NC_GetSysPopupPos( HWND hwnd, RECT* rect )
1226 {
1227     if (IsIconic(hwnd)) GetWindowRect( hwnd, rect );
1228     else
1229     {
1230         WND *wndPtr = WIN_GetPtr( hwnd );
1231         if (!wndPtr || wndPtr == WND_OTHER_PROCESS || wndPtr == WND_DESKTOP) return;
1232
1233         NC_GetInsideRect( hwnd, rect );
1234         OffsetRect( rect, wndPtr->rectWindow.left, wndPtr->rectWindow.top);
1235         if (wndPtr->dwStyle & WS_CHILD)
1236             ClientToScreen( GetParent(hwnd), (POINT *)rect );
1237         rect->right = rect->left + GetSystemMetrics(SM_CYCAPTION) - 1;
1238         rect->bottom = rect->top + GetSystemMetrics(SM_CYCAPTION) - 1;
1239         WIN_ReleasePtr( wndPtr );
1240     }
1241 }
1242
1243 /***********************************************************************
1244  *           NC_TrackMinMaxBox
1245  *
1246  * Track a mouse button press on the minimize or maximize box.
1247  *
1248  * The big difference between 3.1 and 95 is the disabled button state.
1249  * In win95 the system button can be disabled, so it can ignore the mouse
1250  * event.
1251  *
1252  */
1253 static void NC_TrackMinMaxBox( HWND hwnd, WORD wParam )
1254 {
1255     MSG msg;
1256     HDC hdc = GetWindowDC( hwnd );
1257     BOOL pressed = TRUE;
1258     UINT state;
1259     DWORD wndStyle = GetWindowLongW( hwnd, GWL_STYLE);
1260     HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
1261
1262     void  (*paintButton)(HWND, HDC, BOOL, BOOL);
1263
1264     if (wParam == HTMINBUTTON)
1265     {
1266         /* If the style is not present, do nothing */
1267         if (!(wndStyle & WS_MINIMIZEBOX))
1268             return;
1269
1270         /* Check if the sysmenu item for minimize is there  */
1271         state = GetMenuState(hSysMenu, SC_MINIMIZE, MF_BYCOMMAND);
1272
1273         paintButton = &NC_DrawMinButton;
1274     }
1275     else
1276     {
1277         /* If the style is not present, do nothing */
1278         if (!(wndStyle & WS_MAXIMIZEBOX))
1279             return;
1280
1281         /* Check if the sysmenu item for maximize is there  */
1282         state = GetMenuState(hSysMenu, SC_MAXIMIZE, MF_BYCOMMAND);
1283
1284         paintButton = &NC_DrawMaxButton;
1285     }
1286
1287     SetCapture( hwnd );
1288
1289     (*paintButton)( hwnd, hdc, TRUE, FALSE);
1290
1291     while(1)
1292     {
1293         BOOL oldstate = pressed;
1294
1295         if (!GetMessageW( &msg, 0, WM_MOUSEFIRST, WM_MOUSELAST )) break;
1296         if (CallMsgFilterW( &msg, MSGF_MAX )) continue;
1297
1298         if(msg.message == WM_LBUTTONUP)
1299             break;
1300
1301         if(msg.message != WM_MOUSEMOVE)
1302             continue;
1303
1304         pressed = (NC_HandleNCHitTest( hwnd, msg.pt ) == wParam);
1305         if (pressed != oldstate)
1306            (*paintButton)( hwnd, hdc, pressed, FALSE);
1307     }
1308
1309     if(pressed)
1310         (*paintButton)(hwnd, hdc, FALSE, FALSE);
1311
1312     ReleaseCapture();
1313     ReleaseDC( hwnd, hdc );
1314
1315     /* If the item minimize or maximize of the sysmenu are not there */
1316     /* or if the style is not present, do nothing */
1317     if ((!pressed) || (state == 0xFFFFFFFF))
1318         return;
1319
1320     if (wParam == HTMINBUTTON)
1321         SendMessageA( hwnd, WM_SYSCOMMAND, SC_MINIMIZE, MAKELONG(msg.pt.x,msg.pt.y) );
1322     else
1323         SendMessageA( hwnd, WM_SYSCOMMAND,
1324                       IsZoomed(hwnd) ? SC_RESTORE:SC_MAXIMIZE, MAKELONG(msg.pt.x,msg.pt.y) );
1325 }
1326
1327 /***********************************************************************
1328  * NC_TrackCloseButton
1329  *
1330  * Track a mouse button press on the Win95 close button.
1331  */
1332 static void NC_TrackCloseButton (HWND hwnd, WORD wParam)
1333 {
1334     MSG msg;
1335     HDC hdc;
1336     BOOL pressed = TRUE;
1337     HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
1338     UINT state;
1339
1340     if(hSysMenu == 0)
1341         return;
1342
1343     state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
1344
1345     /* If the item close of the sysmenu is disabled or not there do nothing */
1346     if((state & MF_DISABLED) || (state & MF_GRAYED) || (state == 0xFFFFFFFF))
1347         return;
1348
1349     hdc = GetWindowDC( hwnd );
1350
1351     SetCapture( hwnd );
1352
1353     NC_DrawCloseButton (hwnd, hdc, TRUE, FALSE);
1354
1355     while(1)
1356     {
1357         BOOL oldstate = pressed;
1358
1359         if (!GetMessageW( &msg, 0, WM_MOUSEFIRST, WM_MOUSELAST )) break;
1360         if (CallMsgFilterW( &msg, MSGF_MAX )) continue;
1361
1362         if(msg.message == WM_LBUTTONUP)
1363             break;
1364
1365         if(msg.message != WM_MOUSEMOVE)
1366             continue;
1367
1368         pressed = (NC_HandleNCHitTest( hwnd, msg.pt ) == wParam);
1369         if (pressed != oldstate)
1370            NC_DrawCloseButton (hwnd, hdc, pressed, FALSE);
1371     }
1372
1373     if(pressed)
1374         NC_DrawCloseButton (hwnd, hdc, FALSE, FALSE);
1375
1376     ReleaseCapture();
1377     ReleaseDC( hwnd, hdc );
1378     if (!pressed) return;
1379
1380     SendMessageA( hwnd, WM_SYSCOMMAND, SC_CLOSE, MAKELONG(msg.pt.x,msg.pt.y) );
1381 }
1382
1383
1384 /***********************************************************************
1385  *           NC_TrackScrollBar
1386  *
1387  * Track a mouse button press on the horizontal or vertical scroll-bar.
1388  */
1389 static void NC_TrackScrollBar( HWND hwnd, WPARAM wParam, POINT pt )
1390 {
1391     INT scrollbar;
1392
1393     if ((wParam & 0xfff0) == SC_HSCROLL)
1394     {
1395         if ((wParam & 0x0f) != HTHSCROLL) return;
1396         scrollbar = SB_HORZ;
1397     }
1398     else  /* SC_VSCROLL */
1399     {
1400         if ((wParam & 0x0f) != HTVSCROLL) return;
1401         scrollbar = SB_VERT;
1402     }
1403     SCROLL_TrackScrollBar( hwnd, scrollbar, pt );
1404 }
1405
1406
1407 /***********************************************************************
1408  *           NC_HandleNCLButtonDown
1409  *
1410  * Handle a WM_NCLBUTTONDOWN message. Called from DefWindowProc().
1411  */
1412 LRESULT NC_HandleNCLButtonDown( HWND hwnd, WPARAM wParam, LPARAM lParam )
1413 {
1414     LONG style = GetWindowLongW( hwnd, GWL_STYLE );
1415
1416     switch(wParam)  /* Hit test */
1417     {
1418     case HTCAPTION:
1419         {
1420             HWND top = GetAncestor( hwnd, GA_ROOT );
1421
1422             if (FOCUS_MouseActivate( top ) || (GetActiveWindow() == top))
1423                 SendMessageW( hwnd, WM_SYSCOMMAND, SC_MOVE + HTCAPTION, lParam );
1424             break;
1425         }
1426
1427     case HTSYSMENU:
1428          if( style & WS_SYSMENU )
1429          {
1430              if( !(style & WS_MINIMIZE) )
1431              {
1432                 HDC hDC = GetWindowDC(hwnd);
1433                 NC_DrawSysButton( hwnd, hDC, TRUE );
1434                 ReleaseDC( hwnd, hDC );
1435              }
1436              SendMessageW( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU + HTSYSMENU, lParam );
1437          }
1438          break;
1439
1440     case HTMENU:
1441         SendMessageW( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU, lParam );
1442         break;
1443
1444     case HTHSCROLL:
1445         SendMessageW( hwnd, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL, lParam );
1446         break;
1447
1448     case HTVSCROLL:
1449         SendMessageW( hwnd, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL, lParam );
1450         break;
1451
1452     case HTMINBUTTON:
1453     case HTMAXBUTTON:
1454         NC_TrackMinMaxBox( hwnd, wParam );
1455         break;
1456
1457     case HTCLOSE:
1458         NC_TrackCloseButton (hwnd, wParam);
1459         break;
1460
1461     case HTLEFT:
1462     case HTRIGHT:
1463     case HTTOP:
1464     case HTTOPLEFT:
1465     case HTTOPRIGHT:
1466     case HTBOTTOM:
1467     case HTBOTTOMLEFT:
1468     case HTBOTTOMRIGHT:
1469         /* Old comment:
1470          * "make sure hittest fits into 0xf and doesn't overlap with HTSYSMENU"
1471          * This was previously done by setting wParam=SC_SIZE + wParam - 2
1472          */
1473         /* But that is not what WinNT does. Instead it sends this. This
1474          * is easy to differentiate from HTSYSMENU, because HTSYSMENU adds
1475          * SC_MOUSEMENU into wParam.
1476          */
1477         SendMessageW( hwnd, WM_SYSCOMMAND, SC_SIZE + wParam - (HTLEFT-WMSZ_LEFT), lParam);
1478         break;
1479
1480     case HTBORDER:
1481         break;
1482     }
1483     return 0;
1484 }
1485
1486
1487 /***********************************************************************
1488  *           NC_HandleNCLButtonDblClk
1489  *
1490  * Handle a WM_NCLBUTTONDBLCLK message. Called from DefWindowProc().
1491  */
1492 LRESULT NC_HandleNCLButtonDblClk( HWND hwnd, WPARAM wParam, LPARAM lParam )
1493 {
1494     /*
1495      * if this is an icon, send a restore since we are handling
1496      * a double click
1497      */
1498     if (IsIconic(hwnd))
1499     {
1500         SendMessageW( hwnd, WM_SYSCOMMAND, SC_RESTORE, lParam );
1501         return 0;
1502     }
1503
1504     switch(wParam)  /* Hit test */
1505     {
1506     case HTCAPTION:
1507         /* stop processing if WS_MAXIMIZEBOX is missing */
1508         if (GetWindowLongW( hwnd, GWL_STYLE ) & WS_MAXIMIZEBOX)
1509             SendMessageW( hwnd, WM_SYSCOMMAND,
1510                           IsZoomed(hwnd) ? SC_RESTORE : SC_MAXIMIZE, lParam );
1511         break;
1512
1513     case HTSYSMENU:
1514         {
1515             HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
1516             UINT state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
1517
1518             /* If the item close of the sysmenu is disabled or not there do nothing */
1519             if ((state & (MF_DISABLED | MF_GRAYED)) || (state == 0xFFFFFFFF))
1520                 break;
1521
1522             SendMessageW( hwnd, WM_SYSCOMMAND, SC_CLOSE, lParam );
1523             break;
1524         }
1525
1526     case HTHSCROLL:
1527         SendMessageW( hwnd, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL, lParam );
1528         break;
1529
1530     case HTVSCROLL:
1531         SendMessageW( hwnd, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL, lParam );
1532         break;
1533     }
1534     return 0;
1535 }
1536
1537
1538 /***********************************************************************
1539  *           NC_HandleSysCommand
1540  *
1541  * Handle a WM_SYSCOMMAND message. Called from DefWindowProc().
1542  */
1543 LRESULT NC_HandleSysCommand( HWND hwnd, WPARAM wParam, LPARAM lParam )
1544 {
1545     TRACE("Handling WM_SYSCOMMAND %x %lx\n", wParam, lParam );
1546
1547     if (HOOK_CallHooks( WH_CBT, HCBT_SYSCOMMAND, wParam, lParam, TRUE ))
1548         return 0;
1549
1550     switch (wParam & 0xfff0)
1551     {
1552     case SC_SIZE:
1553     case SC_MOVE:
1554         USER_Driver->pSysCommandSizeMove( hwnd, wParam );
1555         break;
1556
1557     case SC_MINIMIZE:
1558         if (hwnd == GetForegroundWindow())
1559             ShowOwnedPopups(hwnd,FALSE);
1560         ShowWindow( hwnd, SW_MINIMIZE );
1561         break;
1562
1563     case SC_MAXIMIZE:
1564         if (IsIconic(hwnd) && hwnd == GetForegroundWindow())
1565             ShowOwnedPopups(hwnd,TRUE);
1566         ShowWindow( hwnd, SW_MAXIMIZE );
1567         break;
1568
1569     case SC_RESTORE:
1570         if (IsIconic(hwnd) && hwnd == GetForegroundWindow())
1571             ShowOwnedPopups(hwnd,TRUE);
1572         ShowWindow( hwnd, SW_RESTORE );
1573         break;
1574
1575     case SC_CLOSE:
1576         return SendMessageA( hwnd, WM_CLOSE, 0, 0 );
1577
1578     case SC_VSCROLL:
1579     case SC_HSCROLL:
1580         {
1581             POINT pt;
1582             pt.x = (short)LOWORD(lParam);
1583             pt.y = (short)HIWORD(lParam);
1584             NC_TrackScrollBar( hwnd, wParam, pt );
1585         }
1586         break;
1587
1588     case SC_MOUSEMENU:
1589         {
1590             POINT pt;
1591             pt.x = (short)LOWORD(lParam);
1592             pt.y = (short)HIWORD(lParam);
1593             MENU_TrackMouseMenuBar( hwnd, wParam & 0x000F, pt );
1594         }
1595         break;
1596
1597     case SC_KEYMENU:
1598         MENU_TrackKbdMenuBar( hwnd, wParam, (WCHAR)lParam );
1599         break;
1600
1601     case SC_TASKLIST:
1602         WinExec( "taskman.exe", SW_SHOWNORMAL );
1603         break;
1604
1605     case SC_SCREENSAVE:
1606         if (wParam == SC_ABOUTWINE)
1607         {
1608             HMODULE hmodule = LoadLibraryA( "shell32.dll" );
1609             if (hmodule)
1610             {
1611                 FARPROC aboutproc = GetProcAddress( hmodule, "ShellAboutA" );
1612                 if (aboutproc) aboutproc( hwnd, PACKAGE_NAME, PACKAGE_STRING, 0 );
1613                 FreeLibrary( hmodule );
1614             }
1615         }
1616         else
1617           if (wParam == SC_PUTMARK)
1618             DPRINTF("Debug mark requested by user\n");
1619         break;
1620
1621     case SC_HOTKEY:
1622     case SC_ARRANGE:
1623     case SC_NEXTWINDOW:
1624     case SC_PREVWINDOW:
1625         FIXME("unimplemented WM_SYSCOMMAND %04x!\n", wParam);
1626         break;
1627     }
1628     return 0;
1629 }
1630
1631 /*************************************************************
1632 *  NC_DrawGrayButton
1633 *
1634 * Stub for the grayed button of the caption
1635 *
1636 *************************************************************/
1637
1638 BOOL NC_DrawGrayButton(HDC hdc, int x, int y)
1639 {
1640     HBITMAP hMaskBmp;
1641     HDC hdcMask;
1642     HBRUSH hOldBrush;
1643
1644     hMaskBmp = CreateBitmap (12, 10, 1, 1, lpGrayMask);
1645
1646     if(hMaskBmp == 0)
1647         return FALSE;
1648
1649     hdcMask = CreateCompatibleDC (0);
1650     SelectObject (hdcMask, hMaskBmp);
1651
1652     /* Draw the grayed bitmap using the mask */
1653     hOldBrush = SelectObject (hdc, (HGDIOBJ)RGB(128, 128, 128));
1654     BitBlt (hdc, x, y, 12, 10,
1655             hdcMask, 0, 0, 0xB8074A);
1656
1657     /* Clean up */
1658     SelectObject (hdc, hOldBrush);
1659     DeleteObject(hMaskBmp);
1660     DeleteDC (hdcMask);
1661
1662     return TRUE;
1663 }
1664
1665 /***********************************************************************
1666  *              GetTitleBarInfo (USER32.@)
1667  * TODO: Handle STATE_SYSTEM_PRESSED
1668  */
1669 BOOL WINAPI GetTitleBarInfo(HWND hwnd, PTITLEBARINFO tbi) {
1670     DWORD dwStyle;
1671     DWORD dwExStyle;
1672     RECT wndRect;
1673
1674     TRACE("(%p %p)\n", hwnd, tbi);
1675
1676     if(tbi->cbSize != sizeof(TITLEBARINFO)) {
1677         TRACE("Invalid TITLEBARINFO size: %ld\n", tbi->cbSize);
1678         SetLastError(ERROR_INVALID_PARAMETER);
1679         return FALSE;
1680     }
1681     dwStyle = GetWindowLongW(hwnd, GWL_STYLE);
1682     dwExStyle = GetWindowLongW(hwnd, GWL_EXSTYLE);
1683     NC_GetInsideRect(hwnd, &tbi->rcTitleBar);
1684
1685     GetWindowRect(hwnd, &wndRect);
1686
1687     tbi->rcTitleBar.top += wndRect.top;
1688     tbi->rcTitleBar.left += wndRect.left;
1689     tbi->rcTitleBar.right += wndRect.left;
1690
1691     tbi->rcTitleBar.bottom = tbi->rcTitleBar.top;
1692     if(dwExStyle & WS_EX_TOOLWINDOW)
1693         tbi->rcTitleBar.bottom += GetSystemMetrics(SM_CYSMCAPTION);
1694     else {
1695         tbi->rcTitleBar.bottom += GetSystemMetrics(SM_CYCAPTION);
1696         tbi->rcTitleBar.left += GetSystemMetrics(SM_CXSIZE);
1697     }
1698
1699     ZeroMemory(&tbi->rgstate, sizeof(tbi->rgstate));
1700     /* Does the title bar always have STATE_SYSTEM_FOCUSABLE?
1701      * Under XP it seems to
1702      */
1703     tbi->rgstate[0] = STATE_SYSTEM_FOCUSABLE;
1704     if(dwStyle & WS_CAPTION) {
1705         tbi->rgstate[1] = STATE_SYSTEM_INVISIBLE;
1706         if(dwStyle & WS_SYSMENU) {
1707             if(!(dwStyle & (WS_MINIMIZEBOX|WS_MAXIMIZEBOX))) {
1708                 tbi->rgstate[2] = STATE_SYSTEM_INVISIBLE;
1709                 tbi->rgstate[3] = STATE_SYSTEM_INVISIBLE;
1710             }
1711             else {
1712                 if(!(dwStyle & WS_MINIMIZEBOX))
1713                     tbi->rgstate[2] = STATE_SYSTEM_UNAVAILABLE;
1714                 if(!(dwStyle & WS_MAXIMIZEBOX))
1715                     tbi->rgstate[3] = STATE_SYSTEM_UNAVAILABLE;
1716             }
1717             if(!(dwExStyle & WS_EX_CONTEXTHELP))
1718                 tbi->rgstate[4] = STATE_SYSTEM_INVISIBLE;
1719             if(GetClassLongW(hwnd, GCL_STYLE) & CS_NOCLOSE)
1720                 tbi->rgstate[5] = STATE_SYSTEM_UNAVAILABLE;
1721         }
1722         else {
1723             tbi->rgstate[2] = STATE_SYSTEM_INVISIBLE;
1724             tbi->rgstate[3] = STATE_SYSTEM_INVISIBLE;
1725             tbi->rgstate[4] = STATE_SYSTEM_INVISIBLE;
1726             tbi->rgstate[5] = STATE_SYSTEM_INVISIBLE;
1727         }
1728     }
1729     else
1730         tbi->rgstate[0] |= STATE_SYSTEM_INVISIBLE;
1731     return TRUE;
1732 }