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