?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
configure: Make the font warning more explicit about what package is missing.
[wine/multimedia.git] / dlls / user / nonclient.c
blob2f095ca302d68e95b5add8c282d6de91172f2fe1
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 "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 SendMessageW( hwnd, WM_SYSCOMMAND, SC_MINIMIZE, MAKELONG(msg.pt.x,msg.pt.y) );
1322 else
1323 SendMessageW( 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 SendMessageW( 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 SendMessageW( 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 }
Maarten's multimedia branch