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