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