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