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