?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Added {ok,trace}_ macros to take explicit file and line number.
[wine/multimedia.git] / windows / nonclient.c
blob1f3e76547672a2bc0104f5620592bc79feee655b
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 "windef.h"
24 #include "wingdi.h"
25 #include "wine/winuser16.h"
26 #include "win.h"
27 #include "user.h"
28 #include "dce.h"
29 #include "controls.h"
30 #include "cursoricon.h"
31 #include "winpos.h"
32 #include "nonclient.h"
33 #include "wine/debug.h"
34 #include "shellapi.h"
35 #include "bitmap.h"
36
37 WINE_DEFAULT_DEBUG_CHANNEL(nonclient);
38 WINE_DECLARE_DEBUG_CHANNEL(shell);
39
40 BOOL NC_DrawGrayButton(HDC hdc, int x, int y);
41
42 static HBITMAP hbitmapClose;
43
44 static const BYTE lpGrayMask[] = { 0xAA, 0xA0,
45 0x55, 0x50,
46 0xAA, 0xA0,
47 0x55, 0x50,
48 0xAA, 0xA0,
49 0x55, 0x50,
50 0xAA, 0xA0,
51 0x55, 0x50,
52 0xAA, 0xA0,
53 0x55, 0x50};
54
55 #define SC_ABOUTWINE (SC_SCREENSAVE+1)
56 #define SC_PUTMARK (SC_SCREENSAVE+2)
57
58 /* Some useful macros */
59 #define HAS_DLGFRAME(style,exStyle) \
60 (((exStyle) & WS_EX_DLGMODALFRAME) || \
61 (((style) & WS_DLGFRAME) && !((style) & WS_THICKFRAME)))
62
63 #define HAS_THICKFRAME(style,exStyle) \
64 (((style) & WS_THICKFRAME) && \
65 !(((style) & (WS_DLGFRAME|WS_BORDER)) == WS_DLGFRAME))
66
67 #define HAS_THINFRAME(style) \
68 (((style) & WS_BORDER) || !((style) & (WS_CHILD | WS_POPUP)))
69
70 #define HAS_BIGFRAME(style,exStyle) \
71 (((style) & (WS_THICKFRAME | WS_DLGFRAME)) || \
72 ((exStyle) & WS_EX_DLGMODALFRAME))
73
74 #define HAS_STATICOUTERFRAME(style,exStyle) \
75 (((exStyle) & (WS_EX_STATICEDGE|WS_EX_DLGMODALFRAME)) == \
76 WS_EX_STATICEDGE)
77
78 #define HAS_ANYFRAME(style,exStyle) \
79 (((style) & (WS_THICKFRAME | WS_DLGFRAME | WS_BORDER)) || \
80 ((exStyle) & WS_EX_DLGMODALFRAME) || \
81 !((style) & (WS_CHILD | WS_POPUP)))
82
83 #define HAS_MENU(w) (!((w)->dwStyle & WS_CHILD) && ((w)->wIDmenu != 0))
84
85
86 /***********************************************************************
87 * NC_AdjustRect
88 *
89 * Compute the size of the window rectangle from the size of the
90 * client rectangle.
91 */
92 static void NC_AdjustRect( LPRECT rect, DWORD style, BOOL menu, DWORD exStyle )
93 {
94 if (TWEAK_WineLook > WIN31_LOOK)
95 ERR("Called in Win95 mode. Aiee! Please report this.\n" );
96
97 if(style & WS_ICONIC) return;
98
99 if (HAS_THICKFRAME( style, exStyle ))
100 InflateRect( rect, GetSystemMetrics(SM_CXFRAME), GetSystemMetrics(SM_CYFRAME) );
101 else if (HAS_DLGFRAME( style, exStyle ))
102 InflateRect( rect, GetSystemMetrics(SM_CXDLGFRAME), GetSystemMetrics(SM_CYDLGFRAME) );
103 else if (HAS_THINFRAME( style ))
104 InflateRect( rect, GetSystemMetrics(SM_CXBORDER), GetSystemMetrics(SM_CYBORDER));
105
106 if ((style & WS_CAPTION) == WS_CAPTION)
107 rect->top -= GetSystemMetrics(SM_CYCAPTION) - GetSystemMetrics(SM_CYBORDER);
108
109 if (menu) rect->top -= GetSystemMetrics(SM_CYMENU) + GetSystemMetrics(SM_CYBORDER);
110
111 if (style & WS_VSCROLL) {
112 rect->right += GetSystemMetrics(SM_CXVSCROLL) - 1;
113 if(!HAS_ANYFRAME( style, exStyle ))
114 rect->right++;
115 }
116
117 if (style & WS_HSCROLL) {
118 rect->bottom += GetSystemMetrics(SM_CYHSCROLL) - 1;
119 if(!HAS_ANYFRAME( style, exStyle ))
120 rect->bottom++;
121 }
122 }
123
124
125 /******************************************************************************
126 * NC_AdjustRectOuter95
127 *
128 * Computes the size of the "outside" parts of the window based on the
129 * parameters of the client area.
130 *
131 + PARAMS
132 * LPRECT16 rect
133 * DWORD style
134 * BOOL menu
135 * DWORD exStyle
136 *
137 * NOTES
138 * "Outer" parts of a window means the whole window frame, caption and
139 * menu bar. It does not include "inner" parts of the frame like client
140 * edge, static edge or scroll bars.
141 *
142 * Revision history
143 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
144 * Original (NC_AdjustRect95) cut & paste from NC_AdjustRect
145 *
146 * 20-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
147 * Split NC_AdjustRect95 into NC_AdjustRectOuter95 and
148 * NC_AdjustRectInner95 and added handling of Win95 styles.
149 *
150 * 28-Jul-1999 Ove Kåven (ovek@arcticnet.no)
151 * Streamlined window style checks.
152 *
153 *****************************************************************************/
154
155 static void
156 NC_AdjustRectOuter95 (LPRECT rect, DWORD style, BOOL menu, DWORD exStyle)
157 {
158 int adjust;
159 if(style & WS_ICONIC) return;
160
161 if ((exStyle & (WS_EX_STATICEDGE|WS_EX_DLGMODALFRAME)) ==
162 WS_EX_STATICEDGE)
163 {
164 adjust = 1; /* for the outer frame always present */
165 }
166 else
167 {
168 adjust = 0;
169 if ((exStyle & WS_EX_DLGMODALFRAME) ||
170 (style & (WS_THICKFRAME|WS_DLGFRAME))) adjust = 2; /* outer */
171 }
172 if (style & WS_THICKFRAME)
173 adjust += ( GetSystemMetrics (SM_CXFRAME)
174 - GetSystemMetrics (SM_CXDLGFRAME)); /* The resize border */
175 if ((style & (WS_BORDER|WS_DLGFRAME)) ||
176 (exStyle & WS_EX_DLGMODALFRAME))
177 adjust++; /* The other border */
178
179 InflateRect (rect, adjust, adjust);
180
181 if ((style & WS_CAPTION) == WS_CAPTION)
182 {
183 if (exStyle & WS_EX_TOOLWINDOW)
184 rect->top -= GetSystemMetrics(SM_CYSMCAPTION);
185 else
186 rect->top -= GetSystemMetrics(SM_CYCAPTION);
187 }
188 if (menu) rect->top -= GetSystemMetrics(SM_CYMENU);
189 }
190
191
192 /******************************************************************************
193 * NC_AdjustRectInner95
194 *
195 * Computes the size of the "inside" part of the window based on the
196 * parameters of the client area.
197 *
198 + PARAMS
199 * LPRECT16 rect
200 * DWORD style
201 * DWORD exStyle
202 *
203 * NOTES
204 * "Inner" part of a window means the window frame inside of the flat
205 * window frame. It includes the client edge, the static edge and the
206 * scroll bars.
207 *
208 * Revision history
209 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
210 * Original (NC_AdjustRect95) cut & paste from NC_AdjustRect
211 *
212 * 20-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
213 * Split NC_AdjustRect95 into NC_AdjustRectOuter95 and
214 * NC_AdjustRectInner95 and added handling of Win95 styles.
215 *
216 *****************************************************************************/
217
218 static void
219 NC_AdjustRectInner95 (LPRECT rect, DWORD style, DWORD exStyle)
220 {
221 if(style & WS_ICONIC) return;
222
223 if (exStyle & WS_EX_CLIENTEDGE)
224 InflateRect(rect, GetSystemMetrics(SM_CXEDGE), GetSystemMetrics(SM_CYEDGE));
225
226 if (style & WS_VSCROLL) rect->right += GetSystemMetrics(SM_CXVSCROLL);
227 if (style & WS_HSCROLL) rect->bottom += GetSystemMetrics(SM_CYHSCROLL);
228 }
229
230
231
232 static HICON NC_IconForWindow( HWND hwnd )
233 {
234 HICON hIcon = (HICON) GetClassLongA( hwnd, GCL_HICONSM );
235 if (!hIcon) hIcon = (HICON) GetClassLongA( hwnd, GCL_HICON );
236
237 /* If there is no hIcon specified and this is a modal dialog,
238 * get the default one.
239 */
240 if (!hIcon && (GetWindowLongA( hwnd, GWL_STYLE ) & DS_MODALFRAME))
241 hIcon = LoadImageA(0, IDI_WINLOGOA, IMAGE_ICON, 0, 0, LR_DEFAULTCOLOR);
242 return hIcon;
243 }
244
245 /***********************************************************************
246 * DrawCaption (USER32.@) Draws a caption bar
247 *
248 * PARAMS
249 * hwnd [I]
250 * hdc [I]
251 * lpRect [I]
252 * uFlags [I]
253 *
254 * RETURNS
255 * Success:
256 * Failure:
257 */
258
259 BOOL WINAPI
260 DrawCaption (HWND hwnd, HDC hdc, const RECT *lpRect, UINT uFlags)
261 {
262 return DrawCaptionTempA (hwnd, hdc, lpRect, 0, 0, NULL, uFlags & 0x1F);
263 }
264
265
266 /***********************************************************************
267 * DrawCaptionTempA (USER32.@)
268 */
269 BOOL WINAPI DrawCaptionTempA (HWND hwnd, HDC hdc, const RECT *rect, HFONT hFont,
270 HICON hIcon, LPCSTR str, UINT uFlags)
271 {
272 LPWSTR strW;
273 INT len;
274 BOOL ret = FALSE;
275
276 if (!(uFlags & DC_TEXT) || !str)
277 return DrawCaptionTempW( hwnd, hdc, rect, hFont, hIcon, NULL, uFlags );
278
279 len = MultiByteToWideChar( CP_ACP, 0, str, -1, NULL, 0 );
280 if ((strW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) )))
281 {
282 MultiByteToWideChar( CP_ACP, 0, str, -1, strW, len );
283 ret = DrawCaptionTempW (hwnd, hdc, rect, hFont, hIcon, strW, uFlags);
284 HeapFree( GetProcessHeap (), 0, strW );
285 }
286 return ret;
287 }
288
289
290 /***********************************************************************
291 * DrawCaptionTempW (USER32.@)
292 */
293 BOOL WINAPI DrawCaptionTempW (HWND hwnd, HDC hdc, const RECT *rect, HFONT hFont,
294 HICON hIcon, LPCWSTR str, UINT uFlags)
295 {
296 RECT rc = *rect;
297
298 TRACE("(%08x,%08x,%p,%08x,%08x,%s,%08x)\n",
299 hwnd, hdc, rect, hFont, hIcon, debugstr_w(str), uFlags);
300
301 /* drawing background */
302 if (uFlags & DC_INBUTTON) {
303 FillRect (hdc, &rc, GetSysColorBrush (COLOR_3DFACE));
304
305 if (uFlags & DC_ACTIVE) {
306 HBRUSH hbr = SelectObject (hdc, CACHE_GetPattern55AABrush ());
307 PatBlt (hdc, rc.left, rc.top,
308 rc.right-rc.left, rc.bottom-rc.top, 0xFA0089);
309 SelectObject (hdc, hbr);
310 }
311 }
312 else {
313 FillRect (hdc, &rc, GetSysColorBrush ((uFlags & DC_ACTIVE) ?
314 COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION));
315 }
316
317
318 /* drawing icon */
319 if ((uFlags & DC_ICON) && !(uFlags & DC_SMALLCAP)) {
320 POINT pt;
321
322 pt.x = rc.left + 2;
323 pt.y = (rc.bottom + rc.top - GetSystemMetrics(SM_CYSMICON)) / 2;
324
325 if (!hIcon) hIcon = NC_IconForWindow(hwnd);
326 DrawIconEx (hdc, pt.x, pt.y, hIcon, GetSystemMetrics(SM_CXSMICON),
327 GetSystemMetrics(SM_CYSMICON), 0, 0, DI_NORMAL);
328 rc.left += (rc.bottom - rc.top);
329 }
330
331 /* drawing text */
332 if (uFlags & DC_TEXT) {
333 HFONT hOldFont;
334
335 if (uFlags & DC_INBUTTON)
336 SetTextColor (hdc, GetSysColor (COLOR_BTNTEXT));
337 else if (uFlags & DC_ACTIVE)
338 SetTextColor (hdc, GetSysColor (COLOR_CAPTIONTEXT));
339 else
340 SetTextColor (hdc, GetSysColor (COLOR_INACTIVECAPTIONTEXT));
341
342 SetBkMode (hdc, TRANSPARENT);
343
344 if (hFont)
345 hOldFont = SelectObject (hdc, hFont);
346 else {
347 NONCLIENTMETRICSA nclm;
348 HFONT hNewFont;
349 nclm.cbSize = sizeof(NONCLIENTMETRICSA);
350 SystemParametersInfoA (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0);
351 hNewFont = CreateFontIndirectA ((uFlags & DC_SMALLCAP) ?
352 &nclm.lfSmCaptionFont : &nclm.lfCaptionFont);
353 hOldFont = SelectObject (hdc, hNewFont);
354 }
355
356 if (str)
357 DrawTextW (hdc, str, -1, &rc,
358 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT);
359 else {
360 WCHAR szText[128];
361 INT nLen;
362 nLen = GetWindowTextW (hwnd, szText, 128);
363 DrawTextW (hdc, szText, nLen, &rc,
364 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT);
365 }
366
367 if (hFont)
368 SelectObject (hdc, hOldFont);
369 else
370 DeleteObject (SelectObject (hdc, hOldFont));
371 }
372
373 /* drawing focus ??? */
374 if (uFlags & 0x2000)
375 FIXME("undocumented flag (0x2000)!\n");
376
377 return 0;
378 }
379
380
381 /***********************************************************************
382 * AdjustWindowRect (USER.102)
383 */
384 BOOL16 WINAPI AdjustWindowRect16( LPRECT16 rect, DWORD style, BOOL16 menu )
385 {
386 return AdjustWindowRectEx16( rect, style, menu, 0 );
387 }
388
389
390 /***********************************************************************
391 * AdjustWindowRect (USER32.@)
392 */
393 BOOL WINAPI AdjustWindowRect( LPRECT rect, DWORD style, BOOL menu )
394 {
395 return AdjustWindowRectEx( rect, style, menu, 0 );
396 }
397
398
399 /***********************************************************************
400 * AdjustWindowRectEx (USER.454)
401 */
402 BOOL16 WINAPI AdjustWindowRectEx16( LPRECT16 rect, DWORD style,
403 BOOL16 menu, DWORD exStyle )
404 {
405 RECT rect32;
406 BOOL ret;
407
408 CONV_RECT16TO32( rect, &rect32 );
409 ret = AdjustWindowRectEx( &rect32, style, menu, exStyle );
410 CONV_RECT32TO16( &rect32, rect );
411 return ret;
412 }
413
414
415 /***********************************************************************
416 * AdjustWindowRectEx (USER32.@)
417 */
418 BOOL WINAPI AdjustWindowRectEx( LPRECT rect, DWORD style, BOOL menu, DWORD exStyle )
419 {
420 /* Correct the window style */
421 style &= (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME | WS_CHILD);
422 exStyle &= (WS_EX_DLGMODALFRAME | WS_EX_CLIENTEDGE |
423 WS_EX_STATICEDGE | WS_EX_TOOLWINDOW);
424 if (exStyle & WS_EX_DLGMODALFRAME) style &= ~WS_THICKFRAME;
425
426 TRACE("(%d,%d)-(%d,%d) %08lx %d %08lx\n",
427 rect->left, rect->top, rect->right, rect->bottom,
428 style, menu, exStyle );
429
430 if (TWEAK_WineLook == WIN31_LOOK)
431 NC_AdjustRect( rect, style, menu, exStyle );
432 else
433 {
434 NC_AdjustRectOuter95( rect, style, menu, exStyle );
435 NC_AdjustRectInner95( rect, style, exStyle );
436 }
437 return TRUE;
438 }
439
440
441 /***********************************************************************
442 * NC_HandleNCCalcSize
443 *
444 * Handle a WM_NCCALCSIZE message. Called from DefWindowProc().
445 */
446 LONG NC_HandleNCCalcSize( HWND hwnd, RECT *winRect )
447 {
448 RECT tmpRect = { 0, 0, 0, 0 };
449 LONG result = 0;
450 LONG cls_style = GetClassLongA(hwnd, GCL_STYLE);
451 LONG style = GetWindowLongA( hwnd, GWL_STYLE );
452 LONG exStyle = GetWindowLongA( hwnd, GWL_EXSTYLE );
453
454 if (cls_style & CS_VREDRAW) result |= WVR_VREDRAW;
455 if (cls_style & CS_HREDRAW) result |= WVR_HREDRAW;
456
457 if (!IsIconic(hwnd))
458 {
459 if (TWEAK_WineLook == WIN31_LOOK)
460 NC_AdjustRect( &tmpRect, style, FALSE, exStyle );
461 else
462 NC_AdjustRectOuter95( &tmpRect, style, FALSE, exStyle );
463
464 winRect->left -= tmpRect.left;
465 winRect->top -= tmpRect.top;
466 winRect->right -= tmpRect.right;
467 winRect->bottom -= tmpRect.bottom;
468
469 if (!(style & WS_CHILD) && GetMenu(hwnd))
470 {
471 TRACE("Calling GetMenuBarHeight with HWND 0x%x, width %d, "
472 "at (%d, %d).\n", hwnd,
473 winRect->right - winRect->left,
474 -tmpRect.left, -tmpRect.top );
475
476 winRect->top +=
477 MENU_GetMenuBarHeight( hwnd,
478 winRect->right - winRect->left,
479 -tmpRect.left, -tmpRect.top ) + 1;
480 }
481
482 if (TWEAK_WineLook > WIN31_LOOK) {
483 SetRect(&tmpRect, 0, 0, 0, 0);
484 NC_AdjustRectInner95 (&tmpRect, style, exStyle);
485 winRect->left -= tmpRect.left;
486 winRect->top -= tmpRect.top;
487 winRect->right -= tmpRect.right;
488 winRect->bottom -= tmpRect.bottom;
489 }
490
491 if (winRect->top > winRect->bottom)
492 winRect->bottom = winRect->top;
493
494 if (winRect->left > winRect->right)
495 winRect->right = winRect->left;
496 }
497 return result;
498 }
499
500
501 /***********************************************************************
502 * NC_GetInsideRect
503 *
504 * Get the 'inside' rectangle of a window, i.e. the whole window rectangle
505 * but without the borders (if any).
506 * The rectangle is in window coordinates (for drawing with GetWindowDC()).
507 */
508 void NC_GetInsideRect( HWND hwnd, RECT *rect )
509 {
510 WND * wndPtr = WIN_FindWndPtr( hwnd );
511
512 rect->top = rect->left = 0;
513 rect->right = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
514 rect->bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
515
516 if (wndPtr->dwStyle & WS_ICONIC) goto END;
517
518 /* Remove frame from rectangle */
519 if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
520 {
521 InflateRect( rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
522 }
523 else if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
524 {
525 InflateRect( rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
526 /* FIXME: this isn't in NC_AdjustRect? why not? */
527 if ((TWEAK_WineLook == WIN31_LOOK) && (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME))
528 InflateRect( rect, -1, 0 );
529 }
530 else if (HAS_THINFRAME( wndPtr->dwStyle ))
531 {
532 InflateRect( rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER) );
533 }
534
535 /* We have additional border information if the window
536 * is a child (but not an MDI child) */
537 if (TWEAK_WineLook != WIN31_LOOK)
538 {
539 if ( (wndPtr->dwStyle & WS_CHILD) &&
540 ( (wndPtr->dwExStyle & WS_EX_MDICHILD) == 0 ) )
541 {
542 if (wndPtr->dwExStyle & WS_EX_CLIENTEDGE)
543 InflateRect (rect, -GetSystemMetrics(SM_CXEDGE), -GetSystemMetrics(SM_CYEDGE));
544 if (wndPtr->dwExStyle & WS_EX_STATICEDGE)
545 InflateRect (rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
546 }
547 }
548
549 END:
550 WIN_ReleaseWndPtr(wndPtr);
551 return;
552 }
553
554
555 /***********************************************************************
556 * NC_DoNCHitTest
557 *
558 * Handle a WM_NCHITTEST message. Called from NC_HandleNCHitTest().
559 */
560
561 static LONG NC_DoNCHitTest (WND *wndPtr, POINT pt )
562 {
563 RECT rect;
564
565 TRACE("hwnd=%04x pt=%ld,%ld\n", wndPtr->hwndSelf, pt.x, pt.y );
566
567 GetWindowRect(wndPtr->hwndSelf, &rect );
568 if (!PtInRect( &rect, pt )) return HTNOWHERE;
569
570 if (wndPtr->dwStyle & WS_MINIMIZE) return HTCAPTION;
571
572 /* Check borders */
573 if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
574 {
575 InflateRect( &rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
576 if (!PtInRect( &rect, pt ))
577 {
578 /* Check top sizing border */
579 if (pt.y < rect.top)
580 {
581 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTTOPLEFT;
582 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTTOPRIGHT;
583 return HTTOP;
584 }
585 /* Check bottom sizing border */
586 if (pt.y >= rect.bottom)
587 {
588 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMLEFT;
589 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMRIGHT;
590 return HTBOTTOM;
591 }
592 /* Check left sizing border */
593 if (pt.x < rect.left)
594 {
595 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPLEFT;
596 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMLEFT;
597 return HTLEFT;
598 }
599 /* Check right sizing border */
600 if (pt.x >= rect.right)
601 {
602 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPRIGHT;
603 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMRIGHT;
604 return HTRIGHT;
605 }
606 }
607 }
608 else /* No thick frame */
609 {
610 if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
611 InflateRect(&rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
612 else if (HAS_THINFRAME( wndPtr->dwStyle ))
613 InflateRect(&rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
614 if (!PtInRect( &rect, pt )) return HTBORDER;
615 }
616
617 /* Check caption */
618
619 if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
620 {
621 rect.top += GetSystemMetrics(SM_CYCAPTION) - GetSystemMetrics(SM_CYBORDER);
622 if (!PtInRect( &rect, pt ))
623 {
624 /* Check system menu */
625 if ((wndPtr->dwStyle & WS_SYSMENU) && !(wndPtr->dwExStyle & WS_EX_TOOLWINDOW))
626 rect.left += GetSystemMetrics(SM_CXSIZE);
627 if (pt.x <= rect.left) return HTSYSMENU;
628
629 /* Check maximize box */
630 if (wndPtr->dwStyle & WS_MAXIMIZEBOX)
631 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
632
633 if (pt.x >= rect.right) return HTMAXBUTTON;
634 /* Check minimize box */
635 if (wndPtr->dwStyle & WS_MINIMIZEBOX)
636 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
637 if (pt.x >= rect.right) return HTMINBUTTON;
638 return HTCAPTION;
639 }
640 }
641
642 /* Check client area */
643
644 ScreenToClient( wndPtr->hwndSelf, &pt );
645 GetClientRect( wndPtr->hwndSelf, &rect );
646 if (PtInRect( &rect, pt )) return HTCLIENT;
647
648 /* Check vertical scroll bar */
649
650 if (wndPtr->dwStyle & WS_VSCROLL)
651 {
652 rect.right += GetSystemMetrics(SM_CXVSCROLL);
653 if (PtInRect( &rect, pt )) return HTVSCROLL;
654 }
655
656 /* Check horizontal scroll bar */
657
658 if (wndPtr->dwStyle & WS_HSCROLL)
659 {
660 rect.bottom += GetSystemMetrics(SM_CYHSCROLL);
661 if (PtInRect( &rect, pt ))
662 {
663 /* Check size box */
664 if ((wndPtr->dwStyle & WS_VSCROLL) &&
665 (pt.x >= rect.right - GetSystemMetrics(SM_CXVSCROLL)))
666 return HTSIZE;
667 return HTHSCROLL;
668 }
669 }
670
671 /* Check menu bar */
672
673 if (HAS_MENU(wndPtr))
674 {
675 if ((pt.y < 0) && (pt.x >= 0) && (pt.x < rect.right))
676 return HTMENU;
677 }
678
679 /* Has to return HTNOWHERE if nothing was found
680 Could happen when a window has a customized non client area */
681 return HTNOWHERE;
682 }
683
684
685 /***********************************************************************
686 * NC_DoNCHitTest95
687 *
688 * Handle a WM_NCHITTEST message. Called from NC_HandleNCHitTest().
689 *
690 * FIXME: Just a modified copy of the Win 3.1 version.
691 */
692
693 static LONG NC_DoNCHitTest95 (WND *wndPtr, POINT pt )
694 {
695 RECT rect;
696
697 TRACE("hwnd=%04x pt=%ld,%ld\n", wndPtr->hwndSelf, pt.x, pt.y );
698
699 GetWindowRect(wndPtr->hwndSelf, &rect );
700 if (!PtInRect( &rect, pt )) return HTNOWHERE;
701
702 if (wndPtr->dwStyle & WS_MINIMIZE) return HTCAPTION;
703
704 /* Check borders */
705 if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
706 {
707 InflateRect( &rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
708 if (!PtInRect( &rect, pt ))
709 {
710 /* Check top sizing border */
711 if (pt.y < rect.top)
712 {
713 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTTOPLEFT;
714 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTTOPRIGHT;
715 return HTTOP;
716 }
717 /* Check bottom sizing border */
718 if (pt.y >= rect.bottom)
719 {
720 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMLEFT;
721 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMRIGHT;
722 return HTBOTTOM;
723 }
724 /* Check left sizing border */
725 if (pt.x < rect.left)
726 {
727 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPLEFT;
728 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMLEFT;
729 return HTLEFT;
730 }
731 /* Check right sizing border */
732 if (pt.x >= rect.right)
733 {
734 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPRIGHT;
735 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMRIGHT;
736 return HTRIGHT;
737 }
738 }
739 }
740 else /* No thick frame */
741 {
742 if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
743 InflateRect(&rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
744 else if (HAS_THINFRAME( wndPtr->dwStyle ))
745 InflateRect(&rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
746 if (!PtInRect( &rect, pt )) return HTBORDER;
747 }
748
749 /* Check caption */
750
751 if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
752 {
753 if (wndPtr->dwExStyle & WS_EX_TOOLWINDOW)
754 rect.top += GetSystemMetrics(SM_CYSMCAPTION) - 1;
755 else
756 rect.top += GetSystemMetrics(SM_CYCAPTION) - 1;
757 if (!PtInRect( &rect, pt ))
758 {
759 /* Check system menu */
760 if ((wndPtr->dwStyle & WS_SYSMENU) && !(wndPtr->dwExStyle & WS_EX_TOOLWINDOW))
761 {
762 if (NC_IconForWindow(wndPtr->hwndSelf))
763 rect.left += GetSystemMetrics(SM_CYCAPTION) - 1;
764 }
765 if (pt.x < rect.left) return HTSYSMENU;
766
767 /* Check close button */
768 if (wndPtr->dwStyle & WS_SYSMENU)
769 rect.right -= GetSystemMetrics(SM_CYCAPTION) - 1;
770 if (pt.x > rect.right) return HTCLOSE;
771
772 /* Check maximize box */
773 /* In win95 there is automatically a Maximize button when there is a minimize one*/
774 if ((wndPtr->dwStyle & WS_MAXIMIZEBOX)|| (wndPtr->dwStyle & WS_MINIMIZEBOX))
775 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
776 if (pt.x > rect.right) return HTMAXBUTTON;
777
778 /* Check minimize box */
779 /* In win95 there is automatically a Maximize button when there is a Maximize one*/
780 if ((wndPtr->dwStyle & WS_MINIMIZEBOX)||(wndPtr->dwStyle & WS_MAXIMIZEBOX))
781 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
782
783 if (pt.x > rect.right) return HTMINBUTTON;
784 return HTCAPTION;
785 }
786 }
787
788 /* Check client area */
789
790 ScreenToClient( wndPtr->hwndSelf, &pt );
791 GetClientRect( wndPtr->hwndSelf, &rect );
792 if (PtInRect( &rect, pt )) return HTCLIENT;
793
794 /* Check vertical scroll bar */
795
796 if (wndPtr->dwStyle & WS_VSCROLL)
797 {
798 rect.right += GetSystemMetrics(SM_CXVSCROLL);
799 if (PtInRect( &rect, pt )) return HTVSCROLL;
800 }
801
802 /* Check horizontal scroll bar */
803
804 if (wndPtr->dwStyle & WS_HSCROLL)
805 {
806 rect.bottom += GetSystemMetrics(SM_CYHSCROLL);
807 if (PtInRect( &rect, pt ))
808 {
809 /* Check size box */
810 if ((wndPtr->dwStyle & WS_VSCROLL) &&
811 (pt.x >= rect.right - GetSystemMetrics(SM_CXVSCROLL)))
812 return HTSIZE;
813 return HTHSCROLL;
814 }
815 }
816
817 /* Check menu bar */
818
819 if (HAS_MENU(wndPtr))
820 {
821 if ((pt.y < 0) && (pt.x >= 0) && (pt.x < rect.right))
822 return HTMENU;
823 }
824
825 /* Has to return HTNOWHERE if nothing was found
826 Could happen when a window has a customized non client area */
827 return HTNOWHERE;
828 }
829
830
831 /***********************************************************************
832 * NC_HandleNCHitTest
833 *
834 * Handle a WM_NCHITTEST message. Called from DefWindowProc().
835 */
836 LONG NC_HandleNCHitTest (HWND hwnd , POINT pt)
837 {
838 LONG retvalue;
839 WND *wndPtr = WIN_FindWndPtr (hwnd);
840
841 if (!wndPtr)
842 return HTERROR;
843
844 if (TWEAK_WineLook == WIN31_LOOK)
845 retvalue = NC_DoNCHitTest (wndPtr, pt);
846 else
847 retvalue = NC_DoNCHitTest95 (wndPtr, pt);
848 WIN_ReleaseWndPtr(wndPtr);
849 return retvalue;
850 }
851
852
853 /***********************************************************************
854 * NC_DrawSysButton
855 */
856 void NC_DrawSysButton( HWND hwnd, HDC hdc, BOOL down )
857 {
858 RECT rect;
859 HDC hdcMem;
860 HBITMAP hbitmap;
861
862 NC_GetInsideRect( hwnd, &rect );
863 hdcMem = CreateCompatibleDC( hdc );
864 hbitmap = SelectObject( hdcMem, hbitmapClose );
865 BitBlt(hdc, rect.left, rect.top, GetSystemMetrics(SM_CXSIZE), GetSystemMetrics(SM_CYSIZE),
866 hdcMem, (GetWindowLongA(hwnd,GWL_STYLE) & WS_CHILD) ? GetSystemMetrics(SM_CXSIZE) : 0, 0,
867 down ? NOTSRCCOPY : SRCCOPY );
868 SelectObject( hdcMem, hbitmap );
869 DeleteDC( hdcMem );
870 }
871
872
873 /***********************************************************************
874 * NC_DrawMaxButton
875 */
876 static void NC_DrawMaxButton( HWND hwnd, HDC16 hdc, BOOL down )
877 {
878 RECT rect;
879 UINT flags = IsZoomed(hwnd) ? DFCS_CAPTIONRESTORE : DFCS_CAPTIONMAX;
880
881 NC_GetInsideRect( hwnd, &rect );
882 rect.left = rect.right - GetSystemMetrics(SM_CXSIZE) + 1;
883 rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 1;
884 rect.top += 1;
885 rect.right -= 1;
886 if (down) flags |= DFCS_PUSHED;
887 DrawFrameControl( hdc, &rect, DFC_CAPTION, flags );
888 }
889
890
891 /***********************************************************************
892 * NC_DrawMinButton
893 */
894 static void NC_DrawMinButton( HWND hwnd, HDC16 hdc, BOOL down )
895 {
896 RECT rect;
897 UINT flags = DFCS_CAPTIONMIN;
898 DWORD style = GetWindowLongA( hwnd, GWL_STYLE );
899
900 NC_GetInsideRect( hwnd, &rect );
901 if (style & (WS_MAXIMIZEBOX|WS_MINIMIZEBOX))
902 rect.right -= GetSystemMetrics(SM_CXSIZE) - 2;
903 rect.left = rect.right - GetSystemMetrics(SM_CXSIZE) + 1;
904 rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 1;
905 rect.top += 1;
906 rect.right -= 1;
907 if (down) flags |= DFCS_PUSHED;
908 DrawFrameControl( hdc, &rect, DFC_CAPTION, flags );
909 }
910
911
912 /******************************************************************************
913 *
914 * void NC_DrawSysButton95(
915 * HWND hwnd,
916 * HDC hdc,
917 * BOOL down )
918 *
919 * Draws the Win95 system icon.
920 *
921 * Revision history
922 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
923 * Original implementation from NC_DrawSysButton source.
924 * 11-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
925 * Fixed most bugs.
926 *
927 *****************************************************************************/
928
929 BOOL
930 NC_DrawSysButton95 (HWND hwnd, HDC hdc, BOOL down)
931 {
932 HICON hIcon = NC_IconForWindow( hwnd );
933
934 if (hIcon)
935 {
936 RECT rect;
937 NC_GetInsideRect( hwnd, &rect );
938 DrawIconEx (hdc, rect.left + 1, rect.top + 1, hIcon,
939 GetSystemMetrics(SM_CXSIZE) - 1,
940 GetSystemMetrics(SM_CYSIZE) - 1, 0, 0, DI_NORMAL);
941 }
942 return (hIcon != 0);
943 }
944
945
946 /******************************************************************************
947 *
948 * void NC_DrawCloseButton95(
949 * HWND hwnd,
950 * HDC hdc,
951 * BOOL down,
952 * BOOL bGrayed )
953 *
954 * Draws the Win95 close button.
955 *
956 * If bGrayed is true, then draw a disabled Close button
957 *
958 * Revision history
959 * 11-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
960 * Original implementation from NC_DrawSysButton95 source.
961 *
962 *****************************************************************************/
963
964 static void NC_DrawCloseButton95 (HWND hwnd, HDC hdc, BOOL down, BOOL bGrayed)
965 {
966 RECT rect;
967
968 NC_GetInsideRect( hwnd, &rect );
969
970 /* A tool window has a smaller Close button */
971 if (GetWindowLongA( hwnd, GWL_EXSTYLE ) & WS_EX_TOOLWINDOW)
972 {
973 INT iBmpHeight = 11; /* Windows does not use SM_CXSMSIZE and SM_CYSMSIZE */
974 INT iBmpWidth = 11; /* it uses 11x11 for the close button in tool window */
975 INT iCaptionHeight = GetSystemMetrics(SM_CYSMCAPTION);
976
977 rect.top = rect.top + (iCaptionHeight - 1 - iBmpHeight) / 2;
978 rect.left = rect.right - (iCaptionHeight + 1 + iBmpWidth) / 2;
979 rect.bottom = rect.top + iBmpHeight;
980 rect.right = rect.left + iBmpWidth;
981 }
982 else
983 {
984 rect.left = rect.right - GetSystemMetrics(SM_CXSIZE) - 1;
985 rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 1;
986 rect.top += 2;
987 rect.right -= 2;
988 }
989 DrawFrameControl( hdc, &rect, DFC_CAPTION,
990 (DFCS_CAPTIONCLOSE |
991 (down ? DFCS_PUSHED : 0) |
992 (bGrayed ? DFCS_INACTIVE : 0)) );
993 }
994
995 /******************************************************************************
996 * NC_DrawMaxButton95
997 *
998 * Draws the maximize button for Win95 style windows.
999 * If bGrayed is true, then draw a disabled Maximize button
1000 */
1001 static void NC_DrawMaxButton95(HWND hwnd,HDC16 hdc,BOOL down, BOOL bGrayed)
1002 {
1003 RECT rect;
1004 UINT flags = IsZoomed(hwnd) ? DFCS_CAPTIONRESTORE : DFCS_CAPTIONMAX;
1005
1006 NC_GetInsideRect( hwnd, &rect );
1007 if (GetWindowLongA( hwnd, GWL_STYLE) & WS_SYSMENU)
1008 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1009 rect.left = rect.right - GetSystemMetrics(SM_CXSIZE);
1010 rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 1;
1011 rect.top += 2;
1012 rect.right -= 2;
1013 if (down) flags |= DFCS_PUSHED;
1014 if (bGrayed) flags |= DFCS_INACTIVE;
1015 DrawFrameControl( hdc, &rect, DFC_CAPTION, flags );
1016 }
1017
1018 /******************************************************************************
1019 * NC_DrawMinButton95
1020 *
1021 * Draws the minimize button for Win95 style windows.
1022 * If bGrayed is true, then draw a disabled Minimize button
1023 */
1024 static void NC_DrawMinButton95(HWND hwnd,HDC16 hdc,BOOL down, BOOL bGrayed)
1025 {
1026 RECT rect;
1027 UINT flags = DFCS_CAPTIONMIN;
1028 DWORD style = GetWindowLongA( hwnd, GWL_STYLE );
1029
1030 NC_GetInsideRect( hwnd, &rect );
1031 if (style & WS_SYSMENU)
1032 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1033 if (style & (WS_MAXIMIZEBOX|WS_MINIMIZEBOX))
1034 rect.right -= GetSystemMetrics(SM_CXSIZE) - 2;
1035 rect.left = rect.right - GetSystemMetrics(SM_CXSIZE);
1036 rect.bottom = rect.top + GetSystemMetrics(SM_CYSIZE) - 1;
1037 rect.top += 2;
1038 rect.right -= 2;
1039 if (down) flags |= DFCS_PUSHED;
1040 if (bGrayed) flags |= DFCS_INACTIVE;
1041 DrawFrameControl( hdc, &rect, DFC_CAPTION, flags );
1042 }
1043
1044 /***********************************************************************
1045 * NC_DrawFrame
1046 *
1047 * Draw a window frame inside the given rectangle, and update the rectangle.
1048 * The correct pen for the frame must be selected in the DC.
1049 */
1050 static void NC_DrawFrame( HDC hdc, RECT *rect, BOOL dlgFrame,
1051 BOOL active )
1052 {
1053 INT width, height;
1054
1055 if (TWEAK_WineLook != WIN31_LOOK)
1056 ERR("Called in Win95 mode. Aiee! Please report this.\n" );
1057
1058 if (dlgFrame)
1059 {
1060 width = GetSystemMetrics(SM_CXDLGFRAME) - 1;
1061 height = GetSystemMetrics(SM_CYDLGFRAME) - 1;
1062 SelectObject( hdc, GetSysColorBrush(active ? COLOR_ACTIVECAPTION :
1063 COLOR_INACTIVECAPTION) );
1064 }
1065 else
1066 {
1067 width = GetSystemMetrics(SM_CXFRAME) - 2;
1068 height = GetSystemMetrics(SM_CYFRAME) - 2;
1069 SelectObject( hdc, GetSysColorBrush(active ? COLOR_ACTIVEBORDER :
1070 COLOR_INACTIVEBORDER) );
1071 }
1072
1073 /* Draw frame */
1074 PatBlt( hdc, rect->left, rect->top,
1075 rect->right - rect->left, height, PATCOPY );
1076 PatBlt( hdc, rect->left, rect->top,
1077 width, rect->bottom - rect->top, PATCOPY );
1078 PatBlt( hdc, rect->left, rect->bottom - 1,
1079 rect->right - rect->left, -height, PATCOPY );
1080 PatBlt( hdc, rect->right - 1, rect->top,
1081 -width, rect->bottom - rect->top, PATCOPY );
1082
1083 if (dlgFrame)
1084 {
1085 InflateRect( rect, -width, -height );
1086 }
1087 else
1088 {
1089 INT decYOff = GetSystemMetrics(SM_CXFRAME) + GetSystemMetrics(SM_CXSIZE) - 1;
1090 INT decXOff = GetSystemMetrics(SM_CYFRAME) + GetSystemMetrics(SM_CYSIZE) - 1;
1091
1092 /* Draw inner rectangle */
1093
1094 SelectObject( hdc, GetStockObject(NULL_BRUSH) );
1095 Rectangle( hdc, rect->left + width, rect->top + height,
1096 rect->right - width , rect->bottom - height );
1097
1098 /* Draw the decorations */
1099
1100 MoveToEx( hdc, rect->left, rect->top + decYOff, NULL );
1101 LineTo( hdc, rect->left + width, rect->top + decYOff );
1102 MoveToEx( hdc, rect->right - 1, rect->top + decYOff, NULL );
1103 LineTo( hdc, rect->right - width - 1, rect->top + decYOff );
1104 MoveToEx( hdc, rect->left, rect->bottom - decYOff, NULL );
1105 LineTo( hdc, rect->left + width, rect->bottom - decYOff );
1106 MoveToEx( hdc, rect->right - 1, rect->bottom - decYOff, NULL );
1107 LineTo( hdc, rect->right - width - 1, rect->bottom - decYOff );
1108
1109 MoveToEx( hdc, rect->left + decXOff, rect->top, NULL );
1110 LineTo( hdc, rect->left + decXOff, rect->top + height);
1111 MoveToEx( hdc, rect->left + decXOff, rect->bottom - 1, NULL );
1112 LineTo( hdc, rect->left + decXOff, rect->bottom - height - 1 );
1113 MoveToEx( hdc, rect->right - decXOff, rect->top, NULL );
1114 LineTo( hdc, rect->right - decXOff, rect->top + height );
1115 MoveToEx( hdc, rect->right - decXOff, rect->bottom - 1, NULL );
1116 LineTo( hdc, rect->right - decXOff, rect->bottom - height - 1 );
1117
1118 InflateRect( rect, -width - 1, -height - 1 );
1119 }
1120 }
1121
1122
1123 /******************************************************************************
1124 *
1125 * void NC_DrawFrame95(
1126 * HDC hdc,
1127 * RECT *rect,
1128 * BOOL active,
1129 * DWORD style,
1130 * DWORD exStyle )
1131 *
1132 * Draw a window frame inside the given rectangle, and update the rectangle.
1133 *
1134 * Bugs
1135 * Many. First, just what IS a frame in Win95? Note that the 3D look
1136 * on the outer edge is handled by NC_DoNCPaint95. As is the inner
1137 * edge. The inner rectangle just inside the frame is handled by the
1138 * Caption code.
1139 *
1140 * In short, for most people, this function should be a nop (unless
1141 * you LIKE thick borders in Win95/NT4.0 -- I've been working with
1142 * them lately, but just to get this code right). Even so, it doesn't
1143 * appear to be so. It's being worked on...
1144 *
1145 * Revision history
1146 * 06-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1147 * Original implementation (based on NC_DrawFrame)
1148 * 02-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1149 * Some minor fixes.
1150 * 29-Jun-1999 Ove Kåven (ovek@arcticnet.no)
1151 * Fixed a fix or something.
1152 *
1153 *****************************************************************************/
1154
1155 static void NC_DrawFrame95(
1156 HDC hdc,
1157 RECT *rect,
1158 BOOL active,
1159 DWORD style,
1160 DWORD exStyle)
1161 {
1162 INT width, height;
1163
1164 /* Firstly the "thick" frame */
1165 if (style & WS_THICKFRAME)
1166 {
1167 width = GetSystemMetrics(SM_CXFRAME) - GetSystemMetrics(SM_CXDLGFRAME);
1168 height = GetSystemMetrics(SM_CYFRAME) - GetSystemMetrics(SM_CYDLGFRAME);
1169
1170 SelectObject( hdc, GetSysColorBrush(active ? COLOR_ACTIVEBORDER :
1171 COLOR_INACTIVEBORDER) );
1172 /* Draw frame */
1173 PatBlt( hdc, rect->left, rect->top,
1174 rect->right - rect->left, height, PATCOPY );
1175 PatBlt( hdc, rect->left, rect->top,
1176 width, rect->bottom - rect->top, PATCOPY );
1177 PatBlt( hdc, rect->left, rect->bottom - 1,
1178 rect->right - rect->left, -height, PATCOPY );
1179 PatBlt( hdc, rect->right - 1, rect->top,
1180 -width, rect->bottom - rect->top, PATCOPY );
1181
1182 InflateRect( rect, -width, -height );
1183 }
1184
1185 /* Now the other bit of the frame */
1186 if ((style & (WS_BORDER|WS_DLGFRAME)) ||
1187 (exStyle & WS_EX_DLGMODALFRAME))
1188 {
1189 width = GetSystemMetrics(SM_CXDLGFRAME) - GetSystemMetrics(SM_CXEDGE);
1190 height = GetSystemMetrics(SM_CYDLGFRAME) - GetSystemMetrics(SM_CYEDGE);
1191 /* This should give a value of 1 that should also work for a border */
1192
1193 SelectObject( hdc, GetSysColorBrush(
1194 (exStyle & (WS_EX_DLGMODALFRAME|WS_EX_CLIENTEDGE)) ?
1195 COLOR_3DFACE :
1196 (exStyle & WS_EX_STATICEDGE) ?
1197 COLOR_WINDOWFRAME :
1198 (style & (WS_DLGFRAME|WS_THICKFRAME)) ?
1199 COLOR_3DFACE :
1200 /* else */
1201 COLOR_WINDOWFRAME));
1202
1203 /* Draw frame */
1204 PatBlt( hdc, rect->left, rect->top,
1205 rect->right - rect->left, height, PATCOPY );
1206 PatBlt( hdc, rect->left, rect->top,
1207 width, rect->bottom - rect->top, PATCOPY );
1208 PatBlt( hdc, rect->left, rect->bottom - 1,
1209 rect->right - rect->left, -height, PATCOPY );
1210 PatBlt( hdc, rect->right - 1, rect->top,
1211 -width, rect->bottom - rect->top, PATCOPY );
1212
1213 InflateRect( rect, -width, -height );
1214 }
1215 }
1216
1217
1218 /***********************************************************************
1219 * NC_DrawCaption
1220 *
1221 * Draw the window caption.
1222 * The correct pen for the window frame must be selected in the DC.
1223 */
1224 static void NC_DrawCaption( HDC hdc, RECT *rect, HWND hwnd,
1225 DWORD style, BOOL active )
1226 {
1227 RECT r = *rect;
1228 char buffer[256];
1229
1230 if (!hbitmapClose)
1231 {
1232 if (!(hbitmapClose = LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_OLD_CLOSE) ))) return;
1233 }
1234
1235 if (GetWindowLongA( hwnd, GWL_EXSTYLE) & WS_EX_DLGMODALFRAME)
1236 {
1237 HBRUSH hbrushOld = SelectObject(hdc, GetSysColorBrush(COLOR_WINDOW) );
1238 PatBlt( hdc, r.left, r.top, 1, r.bottom-r.top+1,PATCOPY );
1239 PatBlt( hdc, r.right-1, r.top, 1, r.bottom-r.top+1, PATCOPY );
1240 PatBlt( hdc, r.left, r.top-1, r.right-r.left, 1, PATCOPY );
1241 r.left++;
1242 r.right--;
1243 SelectObject( hdc, hbrushOld );
1244 }
1245 MoveToEx( hdc, r.left, r.bottom, NULL );
1246 LineTo( hdc, r.right, r.bottom );
1247
1248 if (style & WS_SYSMENU)
1249 {
1250 NC_DrawSysButton( hwnd, hdc, FALSE );
1251 r.left += GetSystemMetrics(SM_CXSIZE) + 1;
1252 MoveToEx( hdc, r.left - 1, r.top, NULL );
1253 LineTo( hdc, r.left - 1, r.bottom );
1254 }
1255 FillRect( hdc, &r, GetSysColorBrush(active ? COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION) );
1256 if (style & WS_MAXIMIZEBOX)
1257 {
1258 NC_DrawMaxButton( hwnd, hdc, FALSE );
1259 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1260 }
1261 if (style & WS_MINIMIZEBOX)
1262 {
1263 NC_DrawMinButton( hwnd, hdc, FALSE );
1264 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1265 }
1266
1267 if (GetWindowTextA( hwnd, buffer, sizeof(buffer) ))
1268 {
1269 if (active) SetTextColor( hdc, GetSysColor( COLOR_CAPTIONTEXT ) );
1270 else SetTextColor( hdc, GetSysColor( COLOR_INACTIVECAPTIONTEXT ) );
1271 SetBkMode( hdc, TRANSPARENT );
1272 DrawTextA( hdc, buffer, -1, &r,
1273 DT_SINGLELINE | DT_CENTER | DT_VCENTER | DT_NOPREFIX );
1274 }
1275 }
1276
1277
1278 /******************************************************************************
1279 *
1280 * NC_DrawCaption95(
1281 * HDC hdc,
1282 * RECT *rect,
1283 * HWND hwnd,
1284 * DWORD style,
1285 * BOOL active )
1286 *
1287 * Draw the window caption for Win95 style windows.
1288 * The correct pen for the window frame must be selected in the DC.
1289 *
1290 * Bugs
1291 * Hey, a function that finally works! Well, almost.
1292 * It's being worked on.
1293 *
1294 * Revision history
1295 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1296 * Original implementation.
1297 * 02-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1298 * Some minor fixes.
1299 *
1300 *****************************************************************************/
1301
1302 static void NC_DrawCaption95(
1303 HDC hdc,
1304 RECT *rect,
1305 HWND hwnd,
1306 DWORD style,
1307 DWORD exStyle,
1308 BOOL active )
1309 {
1310 RECT r = *rect;
1311 char buffer[256];
1312 HPEN hPrevPen;
1313 HMENU hSysMenu;
1314
1315 hPrevPen = SelectObject( hdc, SYSCOLOR_GetPen(
1316 ((exStyle & (WS_EX_STATICEDGE|WS_EX_CLIENTEDGE|
1317 WS_EX_DLGMODALFRAME)) == WS_EX_STATICEDGE) ?
1318 COLOR_WINDOWFRAME : COLOR_3DFACE) );
1319 MoveToEx( hdc, r.left, r.bottom - 1, NULL );
1320 LineTo( hdc, r.right, r.bottom - 1 );
1321 SelectObject( hdc, hPrevPen );
1322 r.bottom--;
1323
1324 FillRect( hdc, &r, GetSysColorBrush(active ? COLOR_ACTIVECAPTION :
1325 COLOR_INACTIVECAPTION) );
1326
1327 if ((style & WS_SYSMENU) && !(exStyle & WS_EX_TOOLWINDOW)) {
1328 if (NC_DrawSysButton95 (hwnd, hdc, FALSE))
1329 r.left += GetSystemMetrics(SM_CYCAPTION) - 1;
1330 }
1331
1332 if (style & WS_SYSMENU)
1333 {
1334 UINT state;
1335
1336 /* Go get the sysmenu */
1337 hSysMenu = GetSystemMenu(hwnd, FALSE);
1338 state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
1339
1340 /* Draw a grayed close button if disabled and a normal one if SC_CLOSE is not there */
1341 NC_DrawCloseButton95 (hwnd, hdc, FALSE,
1342 ((((state & MF_DISABLED) || (state & MF_GRAYED))) && (state != 0xFFFFFFFF)));
1343 r.right -= GetSystemMetrics(SM_CYCAPTION) - 1;
1344
1345 if ((style & WS_MAXIMIZEBOX) || (style & WS_MINIMIZEBOX))
1346 {
1347 /* In win95 the two buttons are always there */
1348 /* But if the menu item is not in the menu they're disabled*/
1349
1350 NC_DrawMaxButton95( hwnd, hdc, FALSE, (!(style & WS_MAXIMIZEBOX)));
1351 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1352
1353 NC_DrawMinButton95( hwnd, hdc, FALSE, (!(style & WS_MINIMIZEBOX)));
1354 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1355 }
1356 }
1357
1358 if (GetWindowTextA( hwnd, buffer, sizeof(buffer) )) {
1359 NONCLIENTMETRICSA nclm;
1360 HFONT hFont, hOldFont;
1361 nclm.cbSize = sizeof(NONCLIENTMETRICSA);
1362 SystemParametersInfoA (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0);
1363 if (exStyle & WS_EX_TOOLWINDOW)
1364 hFont = CreateFontIndirectA (&nclm.lfSmCaptionFont);
1365 else
1366 hFont = CreateFontIndirectA (&nclm.lfCaptionFont);
1367 hOldFont = SelectObject (hdc, hFont);
1368 if (active) SetTextColor( hdc, GetSysColor( COLOR_CAPTIONTEXT ) );
1369 else SetTextColor( hdc, GetSysColor( COLOR_INACTIVECAPTIONTEXT ) );
1370 SetBkMode( hdc, TRANSPARENT );
1371 r.left += 2;
1372 DrawTextA( hdc, buffer, -1, &r,
1373 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT );
1374 DeleteObject (SelectObject (hdc, hOldFont));
1375 }
1376 }
1377
1378
1379
1380 /***********************************************************************
1381 * NC_DoNCPaint
1382 *
1383 * Paint the non-client area. clip is currently unused.
1384 */
1385 static void NC_DoNCPaint( HWND hwnd, HRGN clip, BOOL suppress_menupaint )
1386 {
1387 HDC hdc;
1388 RECT rect;
1389 BOOL active;
1390 WND *wndPtr;
1391 DWORD dwStyle, dwExStyle;
1392 WORD flags;
1393 RECT rectClient, rectWindow;
1394 int has_menu;
1395
1396 if (!(wndPtr = WIN_GetPtr( hwnd )) || wndPtr == WND_OTHER_PROCESS) return;
1397 has_menu = HAS_MENU(wndPtr);
1398 dwStyle = wndPtr->dwStyle;
1399 dwExStyle = wndPtr->dwExStyle;
1400 flags = wndPtr->flags;
1401 rectClient = wndPtr->rectClient;
1402 rectWindow = wndPtr->rectWindow;
1403 WIN_ReleasePtr( wndPtr );
1404
1405 if ( dwStyle & WS_MINIMIZE ||
1406 !WIN_IsWindowDrawable( hwnd, 0 )) return; /* Nothing to do */
1407
1408 active = flags & WIN_NCACTIVATED;
1409
1410 TRACE("%04x %d\n", hwnd, active );
1411
1412 if (!(hdc = GetDCEx( hwnd, (clip > 1) ? clip : 0, DCX_USESTYLE | DCX_WINDOW |
1413 ((clip > 1) ? (DCX_INTERSECTRGN | DCX_KEEPCLIPRGN): 0) ))) return;
1414
1415 if (ExcludeVisRect16( hdc, rectClient.left-rectWindow.left,
1416 rectClient.top-rectWindow.top,
1417 rectClient.right-rectWindow.left,
1418 rectClient.bottom-rectWindow.top )
1419 == NULLREGION)
1420 {
1421 ReleaseDC( hwnd, hdc );
1422 return;
1423 }
1424
1425 rect.top = rect.left = 0;
1426 rect.right = rectWindow.right - rectWindow.left;
1427 rect.bottom = rectWindow.bottom - rectWindow.top;
1428
1429 SelectObject( hdc, SYSCOLOR_GetPen(COLOR_WINDOWFRAME) );
1430
1431 if (HAS_ANYFRAME( dwStyle, dwExStyle ))
1432 {
1433 SelectObject( hdc, GetStockObject(NULL_BRUSH) );
1434 Rectangle( hdc, 0, 0, rect.right, rect.bottom );
1435 InflateRect( &rect, -1, -1 );
1436 }
1437
1438 if (HAS_THICKFRAME( dwStyle, dwExStyle ))
1439 NC_DrawFrame(hdc, &rect, FALSE, active );
1440 else if (HAS_DLGFRAME( dwStyle, dwExStyle ))
1441 NC_DrawFrame( hdc, &rect, TRUE, active );
1442
1443 if ((dwStyle & WS_CAPTION) == WS_CAPTION)
1444 {
1445 RECT r = rect;
1446 r.bottom = rect.top + GetSystemMetrics(SM_CYSIZE);
1447 rect.top += GetSystemMetrics(SM_CYSIZE) + GetSystemMetrics(SM_CYBORDER);
1448 NC_DrawCaption( hdc, &r, hwnd, dwStyle, active );
1449 }
1450
1451 if (has_menu)
1452 {
1453 RECT r = rect;
1454 r.bottom = rect.top + GetSystemMetrics(SM_CYMENU); /* default height */
1455 rect.top += MENU_DrawMenuBar( hdc, &r, hwnd, suppress_menupaint );
1456 }
1457
1458 /* Draw the scroll-bars */
1459
1460 if (dwStyle & WS_VSCROLL)
1461 SCROLL_DrawScrollBar( hwnd, hdc, SB_VERT, TRUE, TRUE );
1462 if (dwStyle & WS_HSCROLL)
1463 SCROLL_DrawScrollBar( hwnd, hdc, SB_HORZ, TRUE, TRUE );
1464
1465 /* Draw the "size-box" */
1466
1467 if ((dwStyle & WS_VSCROLL) && (dwStyle & WS_HSCROLL))
1468 {
1469 RECT r = rect;
1470 r.left = r.right - GetSystemMetrics(SM_CXVSCROLL) + 1;
1471 r.top = r.bottom - GetSystemMetrics(SM_CYHSCROLL) + 1;
1472 if(wndPtr->dwStyle & WS_BORDER) {
1473 r.left++;
1474 r.top++;
1475 }
1476 FillRect( hdc, &r, GetSysColorBrush(COLOR_SCROLLBAR) );
1477 }
1478
1479 ReleaseDC( hwnd, hdc );
1480 }
1481
1482
1483 /******************************************************************************
1484 *
1485 * void NC_DoNCPaint95(
1486 * HWND hwnd,
1487 * HRGN clip,
1488 * BOOL suppress_menupaint )
1489 *
1490 * Paint the non-client area for Win95 windows. The clip region is
1491 * currently ignored.
1492 *
1493 * Bugs
1494 * grep -E -A10 -B5 \(95\)\|\(Bugs\)\|\(FIXME\) windows/nonclient.c \
1495 * misc/tweak.c controls/menu.c # :-)
1496 *
1497 * Revision history
1498 * 03-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1499 * Original implementation
1500 * 10-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1501 * Fixed some bugs.
1502 * 29-Jun-1999 Ove Kåven (ovek@arcticnet.no)
1503 * Streamlined window style checks.
1504 *
1505 *****************************************************************************/
1506
1507 static void NC_DoNCPaint95(
1508 HWND hwnd,
1509 HRGN clip,
1510 BOOL suppress_menupaint )
1511 {
1512 HDC hdc;
1513 RECT rfuzz, rect, rectClip;
1514 BOOL active;
1515 WND *wndPtr;
1516 DWORD dwStyle, dwExStyle;
1517 WORD flags;
1518 RECT rectClient, rectWindow;
1519 int has_menu;
1520
1521 if (!(wndPtr = WIN_GetPtr( hwnd )) || wndPtr == WND_OTHER_PROCESS) return;
1522 has_menu = HAS_MENU(wndPtr);
1523 dwStyle = wndPtr->dwStyle;
1524 dwExStyle = wndPtr->dwExStyle;
1525 flags = wndPtr->flags;
1526 rectClient = wndPtr->rectClient;
1527 rectWindow = wndPtr->rectWindow;
1528 WIN_ReleasePtr( wndPtr );
1529
1530 if ( dwStyle & WS_MINIMIZE ||
1531 !WIN_IsWindowDrawable( hwnd, 0 )) return; /* Nothing to do */
1532
1533 active = flags & WIN_NCACTIVATED;
1534
1535 TRACE("%04x %d\n", hwnd, active );
1536
1537 /* MSDN docs are pretty idiotic here, they say app CAN use clipRgn in
1538 the call to GetDCEx implying that it is allowed not to use it either.
1539 However, the suggested GetDCEx( , DCX_WINDOW | DCX_INTERSECTRGN)
1540 will cause clipRgn to be deleted after ReleaseDC().
1541 Now, how is the "system" supposed to tell what happened?
1542 */
1543
1544 if (!(hdc = GetDCEx( hwnd, (clip > 1) ? clip : 0, DCX_USESTYLE | DCX_WINDOW |
1545 ((clip > 1) ?(DCX_INTERSECTRGN | DCX_KEEPCLIPRGN) : 0) ))) return;
1546
1547
1548 if (ExcludeVisRect16( hdc, rectClient.left-rectWindow.left,
1549 rectClient.top-rectWindow.top,
1550 rectClient.right-rectWindow.left,
1551 rectClient.bottom-rectWindow.top )
1552 == NULLREGION)
1553 {
1554 ReleaseDC( hwnd, hdc );
1555 return;
1556 }
1557
1558 rect.top = rect.left = 0;
1559 rect.right = rectWindow.right - rectWindow.left;
1560 rect.bottom = rectWindow.bottom - rectWindow.top;
1561
1562 if( clip > 1 )
1563 GetRgnBox( clip, &rectClip );
1564 else
1565 {
1566 clip = 0;
1567 rectClip = rect;
1568 }
1569
1570 SelectObject( hdc, SYSCOLOR_GetPen(COLOR_WINDOWFRAME) );
1571
1572 if (HAS_STATICOUTERFRAME(dwStyle, dwExStyle)) {
1573 DrawEdge (hdc, &rect, BDR_SUNKENOUTER, BF_RECT | BF_ADJUST);
1574 }
1575 else if (HAS_BIGFRAME( dwStyle, dwExStyle)) {
1576 DrawEdge (hdc, &rect, EDGE_RAISED, BF_RECT | BF_ADJUST);
1577 }
1578
1579 NC_DrawFrame95(hdc, &rect, active, dwStyle, dwExStyle );
1580
1581 if ((dwStyle & WS_CAPTION) == WS_CAPTION)
1582 {
1583 RECT r = rect;
1584 if (dwExStyle & WS_EX_TOOLWINDOW) {
1585 r.bottom = rect.top + GetSystemMetrics(SM_CYSMCAPTION);
1586 rect.top += GetSystemMetrics(SM_CYSMCAPTION);
1587 }
1588 else {
1589 r.bottom = rect.top + GetSystemMetrics(SM_CYCAPTION);
1590 rect.top += GetSystemMetrics(SM_CYCAPTION);
1591 }
1592 if( !clip || IntersectRect( &rfuzz, &r, &rectClip ) )
1593 NC_DrawCaption95 (hdc, &r, hwnd, dwStyle,
1594 dwExStyle, active);
1595 }
1596
1597 if (has_menu)
1598 {
1599 RECT r = rect;
1600 r.bottom = rect.top + GetSystemMetrics(SM_CYMENU);
1601
1602 TRACE("Calling DrawMenuBar with rect (%d, %d)-(%d, %d)\n",
1603 r.left, r.top, r.right, r.bottom);
1604
1605 rect.top += MENU_DrawMenuBar( hdc, &r, hwnd, suppress_menupaint ) + 1;
1606 }
1607
1608 TRACE("After MenuBar, rect is (%d, %d)-(%d, %d).\n",
1609 rect.left, rect.top, rect.right, rect.bottom );
1610
1611 if (dwExStyle & WS_EX_CLIENTEDGE)
1612 DrawEdge (hdc, &rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
1613
1614 /* Draw the scroll-bars */
1615
1616 if (dwStyle & WS_VSCROLL)
1617 SCROLL_DrawScrollBar( hwnd, hdc, SB_VERT, TRUE, TRUE );
1618 if (dwStyle & WS_HSCROLL)
1619 SCROLL_DrawScrollBar( hwnd, hdc, SB_HORZ, TRUE, TRUE );
1620
1621 /* Draw the "size-box" */
1622 if ((dwStyle & WS_VSCROLL) && (dwStyle & WS_HSCROLL))
1623 {
1624 RECT r = rect;
1625 r.left = r.right - GetSystemMetrics(SM_CXVSCROLL) + 1;
1626 r.top = r.bottom - GetSystemMetrics(SM_CYHSCROLL) + 1;
1627 FillRect( hdc, &r, GetSysColorBrush(COLOR_SCROLLBAR) );
1628 }
1629
1630 ReleaseDC( hwnd, hdc );
1631 }
1632
1633
1634
1635
1636 /***********************************************************************
1637 * NC_HandleNCPaint
1638 *
1639 * Handle a WM_NCPAINT message. Called from DefWindowProc().
1640 */
1641 LONG NC_HandleNCPaint( HWND hwnd , HRGN clip)
1642 {
1643 DWORD dwStyle = GetWindowLongW( hwnd, GWL_STYLE );
1644
1645 if( dwStyle & WS_VISIBLE )
1646 {
1647 if( dwStyle & WS_MINIMIZE )
1648 WINPOS_RedrawIconTitle( hwnd );
1649 else if (TWEAK_WineLook == WIN31_LOOK)
1650 NC_DoNCPaint( hwnd, clip, FALSE );
1651 else
1652 NC_DoNCPaint95( hwnd, clip, FALSE );
1653 }
1654 return 0;
1655 }
1656
1657
1658 /***********************************************************************
1659 * NC_HandleNCActivate
1660 *
1661 * Handle a WM_NCACTIVATE message. Called from DefWindowProc().
1662 */
1663 LONG NC_HandleNCActivate( HWND hwnd, WPARAM wParam )
1664 {
1665 WND* wndPtr = WIN_FindWndPtr( hwnd );
1666
1667 /* Lotus Notes draws menu descriptions in the caption of its main
1668 * window. When it wants to restore original "system" view, it just
1669 * sends WM_NCACTIVATE message to itself. Any optimizations here in
1670 * attempt to minimize redrawings lead to a not restored caption.
1671 */
1672 if (wndPtr)
1673 {
1674 if (wParam) wndPtr->flags |= WIN_NCACTIVATED;
1675 else wndPtr->flags &= ~WIN_NCACTIVATED;
1676 WIN_ReleaseWndPtr(wndPtr);
1677
1678 if (IsIconic(hwnd)) WINPOS_RedrawIconTitle( hwnd );
1679 else if (TWEAK_WineLook == WIN31_LOOK)
1680 NC_DoNCPaint( hwnd, (HRGN)1, FALSE );
1681 else
1682 NC_DoNCPaint95( hwnd, (HRGN)1, FALSE );
1683 }
1684 return TRUE;
1685 }
1686
1687
1688 /***********************************************************************
1689 * NC_HandleSetCursor
1690 *
1691 * Handle a WM_SETCURSOR message. Called from DefWindowProc().
1692 */
1693 LONG NC_HandleSetCursor( HWND hwnd, WPARAM wParam, LPARAM lParam )
1694 {
1695 hwnd = WIN_GetFullHandle( (HWND)wParam );
1696
1697 switch(LOWORD(lParam))
1698 {
1699 case HTERROR:
1700 {
1701 WORD msg = HIWORD( lParam );
1702 if ((msg == WM_LBUTTONDOWN) || (msg == WM_MBUTTONDOWN) ||
1703 (msg == WM_RBUTTONDOWN))
1704 MessageBeep(0);
1705 }
1706 break;
1707
1708 case HTCLIENT:
1709 {
1710 HCURSOR hCursor = (HCURSOR)GetClassLongA(hwnd, GCL_HCURSOR);
1711 if(hCursor) {
1712 SetCursor(hCursor);
1713 return TRUE;
1714 }
1715 return FALSE;
1716 }
1717
1718 case HTLEFT:
1719 case HTRIGHT:
1720 return (LONG)SetCursor( LoadCursorA( 0, IDC_SIZEWEA ) );
1721
1722 case HTTOP:
1723 case HTBOTTOM:
1724 return (LONG)SetCursor( LoadCursorA( 0, IDC_SIZENSA ) );
1725
1726 case HTTOPLEFT:
1727 case HTBOTTOMRIGHT:
1728 return (LONG)SetCursor( LoadCursorA( 0, IDC_SIZENWSEA ) );
1729
1730 case HTTOPRIGHT:
1731 case HTBOTTOMLEFT:
1732 return (LONG)SetCursor( LoadCursorA( 0, IDC_SIZENESWA ) );
1733 }
1734
1735 /* Default cursor: arrow */
1736 return (LONG)SetCursor( LoadCursorA( 0, IDC_ARROWA ) );
1737 }
1738
1739 /***********************************************************************
1740 * NC_GetSysPopupPos
1741 */
1742 void NC_GetSysPopupPos( HWND hwnd, RECT* rect )
1743 {
1744 if (IsIconic(hwnd)) GetWindowRect( hwnd, rect );
1745 else
1746 {
1747 WND *wndPtr = WIN_FindWndPtr( hwnd );
1748 if (!wndPtr) return;
1749
1750 NC_GetInsideRect( hwnd, rect );
1751 OffsetRect( rect, wndPtr->rectWindow.left, wndPtr->rectWindow.top);
1752 if (wndPtr->dwStyle & WS_CHILD)
1753 ClientToScreen( GetParent(hwnd), (POINT *)rect );
1754 if (TWEAK_WineLook == WIN31_LOOK) {
1755 rect->right = rect->left + GetSystemMetrics(SM_CXSIZE);
1756 rect->bottom = rect->top + GetSystemMetrics(SM_CYSIZE);
1757 }
1758 else {
1759 rect->right = rect->left + GetSystemMetrics(SM_CYCAPTION) - 1;
1760 rect->bottom = rect->top + GetSystemMetrics(SM_CYCAPTION) - 1;
1761 }
1762 WIN_ReleaseWndPtr( wndPtr );
1763 }
1764 }
1765
1766 /***********************************************************************
1767 * NC_TrackMinMaxBox95
1768 *
1769 * Track a mouse button press on the minimize or maximize box.
1770 *
1771 * The big difference between 3.1 and 95 is the disabled button state.
1772 * In win95 the system button can be disabled, so it can ignore the mouse
1773 * event.
1774 *
1775 */
1776 static void NC_TrackMinMaxBox95( HWND hwnd, WORD wParam )
1777 {
1778 MSG msg;
1779 HDC hdc = GetWindowDC( hwnd );
1780 BOOL pressed = TRUE;
1781 UINT state;
1782 DWORD wndStyle = GetWindowLongA( hwnd, GWL_STYLE);
1783 HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
1784
1785 void (*paintButton)(HWND, HDC16, BOOL, BOOL);
1786
1787 if (wParam == HTMINBUTTON)
1788 {
1789 /* If the style is not present, do nothing */
1790 if (!(wndStyle & WS_MINIMIZEBOX))
1791 return;
1792
1793 /* Check if the sysmenu item for minimize is there */
1794 state = GetMenuState(hSysMenu, SC_MINIMIZE, MF_BYCOMMAND);
1795
1796 paintButton = &NC_DrawMinButton95;
1797 }
1798 else
1799 {
1800 /* If the style is not present, do nothing */
1801 if (!(wndStyle & WS_MAXIMIZEBOX))
1802 return;
1803
1804 /* Check if the sysmenu item for maximize is there */
1805 state = GetMenuState(hSysMenu, SC_MAXIMIZE, MF_BYCOMMAND);
1806
1807 paintButton = &NC_DrawMaxButton95;
1808 }
1809
1810 SetCapture( hwnd );
1811
1812 (*paintButton)( hwnd, hdc, TRUE, FALSE);
1813
1814 while(1)
1815 {
1816 BOOL oldstate = pressed;
1817
1818 if (!GetMessageW( &msg, 0, WM_MOUSEFIRST, WM_MOUSELAST )) break;
1819 if (CallMsgFilterW( &msg, MSGF_MAX )) continue;
1820
1821 if(msg.message == WM_LBUTTONUP)
1822 break;
1823
1824 if(msg.message != WM_MOUSEMOVE)
1825 continue;
1826
1827 pressed = (NC_HandleNCHitTest( hwnd, msg.pt ) == wParam);
1828 if (pressed != oldstate)
1829 (*paintButton)( hwnd, hdc, pressed, FALSE);
1830 }
1831
1832 if(pressed)
1833 (*paintButton)(hwnd, hdc, FALSE, FALSE);
1834
1835 ReleaseCapture();
1836 ReleaseDC( hwnd, hdc );
1837
1838 /* If the item minimize or maximize of the sysmenu are not there */
1839 /* or if the style is not present, do nothing */
1840 if ((!pressed) || (state == 0xFFFFFFFF))
1841 return;
1842
1843 if (wParam == HTMINBUTTON)
1844 SendMessageA( hwnd, WM_SYSCOMMAND, SC_MINIMIZE, MAKELONG(msg.pt.x,msg.pt.y) );
1845 else
1846 SendMessageA( hwnd, WM_SYSCOMMAND,
1847 IsZoomed(hwnd) ? SC_RESTORE:SC_MAXIMIZE, MAKELONG(msg.pt.x,msg.pt.y) );
1848 }
1849
1850 /***********************************************************************
1851 * NC_TrackMinMaxBox
1852 *
1853 * Track a mouse button press on the minimize or maximize box.
1854 */
1855 static void NC_TrackMinMaxBox( HWND hwnd, WORD wParam )
1856 {
1857 MSG msg;
1858 HDC hdc = GetWindowDC( hwnd );
1859 BOOL pressed = TRUE;
1860 void (*paintButton)(HWND, HDC16, BOOL);
1861
1862 SetCapture( hwnd );
1863
1864 if (wParam == HTMINBUTTON)
1865 paintButton = &NC_DrawMinButton;
1866 else
1867 paintButton = &NC_DrawMaxButton;
1868
1869 (*paintButton)( hwnd, hdc, TRUE);
1870
1871 while(1)
1872 {
1873 BOOL oldstate = pressed;
1874
1875 if (!GetMessageW( &msg, 0, WM_MOUSEFIRST, WM_MOUSELAST )) break;
1876 if (CallMsgFilterW( &msg, MSGF_MAX )) continue;
1877
1878 if(msg.message == WM_LBUTTONUP)
1879 break;
1880
1881 if(msg.message != WM_MOUSEMOVE)
1882 continue;
1883
1884 pressed = (NC_HandleNCHitTest( hwnd, msg.pt ) == wParam);
1885 if (pressed != oldstate)
1886 (*paintButton)( hwnd, hdc, pressed);
1887 }
1888
1889 if(pressed)
1890 (*paintButton)( hwnd, hdc, FALSE);
1891
1892 ReleaseCapture();
1893 ReleaseDC( hwnd, hdc );
1894
1895 if (!pressed) return;
1896
1897 if (wParam == HTMINBUTTON)
1898 SendMessageA( hwnd, WM_SYSCOMMAND, SC_MINIMIZE, MAKELONG(msg.pt.x,msg.pt.y) );
1899 else
1900 SendMessageA( hwnd, WM_SYSCOMMAND,
1901 IsZoomed(hwnd) ? SC_RESTORE:SC_MAXIMIZE, MAKELONG(msg.pt.x,msg.pt.y) );
1902 }
1903
1904
1905 /***********************************************************************
1906 * NC_TrackCloseButton95
1907 *
1908 * Track a mouse button press on the Win95 close button.
1909 */
1910 static void
1911 NC_TrackCloseButton95 (HWND hwnd, WORD wParam)
1912 {
1913 MSG msg;
1914 HDC hdc;
1915 BOOL pressed = TRUE;
1916 HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
1917 UINT state;
1918
1919 if(hSysMenu == 0)
1920 return;
1921
1922 state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
1923
1924 /* If the item close of the sysmenu is disabled or not there do nothing */
1925 if((state & MF_DISABLED) || (state & MF_GRAYED) || (state == 0xFFFFFFFF))
1926 return;
1927
1928 hdc = GetWindowDC( hwnd );
1929
1930 SetCapture( hwnd );
1931
1932 NC_DrawCloseButton95 (hwnd, hdc, TRUE, FALSE);
1933
1934 while(1)
1935 {
1936 BOOL oldstate = pressed;
1937
1938 if (!GetMessageW( &msg, 0, WM_MOUSEFIRST, WM_MOUSELAST )) break;
1939 if (CallMsgFilterW( &msg, MSGF_MAX )) continue;
1940
1941 if(msg.message == WM_LBUTTONUP)
1942 break;
1943
1944 if(msg.message != WM_MOUSEMOVE)
1945 continue;
1946
1947 pressed = (NC_HandleNCHitTest( hwnd, msg.pt ) == wParam);
1948 if (pressed != oldstate)
1949 NC_DrawCloseButton95 (hwnd, hdc, pressed, FALSE);
1950 }
1951
1952 if(pressed)
1953 NC_DrawCloseButton95 (hwnd, hdc, FALSE, FALSE);
1954
1955 ReleaseCapture();
1956 ReleaseDC( hwnd, hdc );
1957 if (!pressed) return;
1958
1959 SendMessageA( hwnd, WM_SYSCOMMAND, SC_CLOSE, MAKELONG(msg.pt.x,msg.pt.y) );
1960 }
1961
1962
1963 /***********************************************************************
1964 * NC_TrackScrollBar
1965 *
1966 * Track a mouse button press on the horizontal or vertical scroll-bar.
1967 */
1968 static void NC_TrackScrollBar( HWND hwnd, WPARAM wParam, POINT pt )
1969 {
1970 INT scrollbar;
1971
1972 if ((wParam & 0xfff0) == SC_HSCROLL)
1973 {
1974 if ((wParam & 0x0f) != HTHSCROLL) return;
1975 scrollbar = SB_HORZ;
1976 }
1977 else /* SC_VSCROLL */
1978 {
1979 if ((wParam & 0x0f) != HTVSCROLL) return;
1980 scrollbar = SB_VERT;
1981 }
1982 SCROLL_TrackScrollBar( hwnd, scrollbar, pt );
1983 }
1984
1985
1986 /***********************************************************************
1987 * NC_HandleNCLButtonDown
1988 *
1989 * Handle a WM_NCLBUTTONDOWN message. Called from DefWindowProc().
1990 */
1991 LONG NC_HandleNCLButtonDown( HWND hwnd, WPARAM wParam, LPARAM lParam )
1992 {
1993 LONG style = GetWindowLongA( hwnd, GWL_STYLE );
1994
1995 switch(wParam) /* Hit test */
1996 {
1997 case HTCAPTION:
1998 {
1999 HWND top = GetAncestor( hwnd, GA_ROOT );
2000
2001 if (FOCUS_MouseActivate( top ) || (GetActiveWindow() == top))
2002 SendMessageW( hwnd, WM_SYSCOMMAND, SC_MOVE + HTCAPTION, lParam );
2003 break;
2004 }
2005
2006 case HTSYSMENU:
2007 if( style & WS_SYSMENU )
2008 {
2009 if( !(style & WS_MINIMIZE) )
2010 {
2011 HDC hDC = GetWindowDC(hwnd);
2012 if (TWEAK_WineLook == WIN31_LOOK)
2013 NC_DrawSysButton( hwnd, hDC, TRUE );
2014 else
2015 NC_DrawSysButton95( hwnd, hDC, TRUE );
2016 ReleaseDC( hwnd, hDC );
2017 }
2018 SendMessageW( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU + HTSYSMENU, lParam );
2019 }
2020 break;
2021
2022 case HTMENU:
2023 SendMessageW( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU, lParam );
2024 break;
2025
2026 case HTHSCROLL:
2027 SendMessageW( hwnd, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL, lParam );
2028 break;
2029
2030 case HTVSCROLL:
2031 SendMessageW( hwnd, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL, lParam );
2032 break;
2033
2034 case HTMINBUTTON:
2035 case HTMAXBUTTON:
2036 if (TWEAK_WineLook == WIN31_LOOK)
2037 NC_TrackMinMaxBox( hwnd, wParam );
2038 else
2039 NC_TrackMinMaxBox95( hwnd, wParam );
2040 break;
2041
2042 case HTCLOSE:
2043 if (TWEAK_WineLook >= WIN95_LOOK)
2044 NC_TrackCloseButton95 (hwnd, wParam);
2045 break;
2046
2047 case HTLEFT:
2048 case HTRIGHT:
2049 case HTTOP:
2050 case HTTOPLEFT:
2051 case HTTOPRIGHT:
2052 case HTBOTTOM:
2053 case HTBOTTOMLEFT:
2054 case HTBOTTOMRIGHT:
2055 /* make sure hittest fits into 0xf and doesn't overlap with HTSYSMENU */
2056 SendMessageW( hwnd, WM_SYSCOMMAND, SC_SIZE + wParam - 2, lParam);
2057 break;
2058
2059 case HTBORDER:
2060 break;
2061 }
2062 return 0;
2063 }
2064
2065
2066 /***********************************************************************
2067 * NC_HandleNCLButtonDblClk
2068 *
2069 * Handle a WM_NCLBUTTONDBLCLK message. Called from DefWindowProc().
2070 */
2071 LONG NC_HandleNCLButtonDblClk( HWND hwnd, WPARAM wParam, LPARAM lParam )
2072 {
2073 /*
2074 * if this is an icon, send a restore since we are handling
2075 * a double click
2076 */
2077 if (IsIconic(hwnd))
2078 {
2079 SendMessageW( hwnd, WM_SYSCOMMAND, SC_RESTORE, lParam );
2080 return 0;
2081 }
2082
2083 switch(wParam) /* Hit test */
2084 {
2085 case HTCAPTION:
2086 /* stop processing if WS_MAXIMIZEBOX is missing */
2087 if (GetWindowLongA( hwnd, GWL_STYLE ) & WS_MAXIMIZEBOX)
2088 SendMessageW( hwnd, WM_SYSCOMMAND,
2089 IsZoomed(hwnd) ? SC_RESTORE : SC_MAXIMIZE, lParam );
2090 break;
2091
2092 case HTSYSMENU:
2093 if (!(GetClassLongW(hwnd, GCL_STYLE) & CS_NOCLOSE))
2094 SendMessageW( hwnd, WM_SYSCOMMAND, SC_CLOSE, lParam );
2095 break;
2096
2097 case HTHSCROLL:
2098 SendMessageW( hwnd, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL, lParam );
2099 break;
2100
2101 case HTVSCROLL:
2102 SendMessageW( hwnd, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL, lParam );
2103 break;
2104 }
2105 return 0;
2106 }
2107
2108
2109 /***********************************************************************
2110 * NC_HandleSysCommand
2111 *
2112 * Handle a WM_SYSCOMMAND message. Called from DefWindowProc().
2113 */
2114 LONG NC_HandleSysCommand( HWND hwnd, WPARAM wParam, LPARAM lParam )
2115 {
2116 TRACE("Handling WM_SYSCOMMAND %x %lx\n", wParam, lParam );
2117
2118 switch (wParam & 0xfff0)
2119 {
2120 case SC_SIZE:
2121 case SC_MOVE:
2122 if (USER_Driver.pSysCommandSizeMove)
2123 USER_Driver.pSysCommandSizeMove( hwnd, wParam );
2124 break;
2125
2126 case SC_MINIMIZE:
2127 if (hwnd == GetForegroundWindow())
2128 ShowOwnedPopups(hwnd,FALSE);
2129 ShowWindow( hwnd, SW_MINIMIZE );
2130 break;
2131
2132 case SC_MAXIMIZE:
2133 if (IsIconic(hwnd) && hwnd == GetForegroundWindow())
2134 ShowOwnedPopups(hwnd,TRUE);
2135 ShowWindow( hwnd, SW_MAXIMIZE );
2136 break;
2137
2138 case SC_RESTORE:
2139 if (IsIconic(hwnd) && hwnd == GetForegroundWindow())
2140 ShowOwnedPopups(hwnd,TRUE);
2141 ShowWindow( hwnd, SW_RESTORE );
2142 break;
2143
2144 case SC_CLOSE:
2145 return SendMessageA( hwnd, WM_CLOSE, 0, 0 );
2146
2147 case SC_VSCROLL:
2148 case SC_HSCROLL:
2149 {
2150 POINT pt;
2151 pt.x = SLOWORD(lParam);
2152 pt.y = SHIWORD(lParam);
2153 NC_TrackScrollBar( hwnd, wParam, pt );
2154 }
2155 break;
2156
2157 case SC_MOUSEMENU:
2158 {
2159 POINT pt;
2160 pt.x = SLOWORD(lParam);
2161 pt.y = SHIWORD(lParam);
2162 MENU_TrackMouseMenuBar( hwnd, wParam & 0x000F, pt );
2163 }
2164 break;
2165
2166 case SC_KEYMENU:
2167 MENU_TrackKbdMenuBar( hwnd, wParam, LOWORD(lParam) );
2168 break;
2169
2170 case SC_TASKLIST:
2171 WinExec( "taskman.exe", SW_SHOWNORMAL );
2172 break;
2173
2174 case SC_SCREENSAVE:
2175 if (wParam == SC_ABOUTWINE)
2176 {
2177 HMODULE hmodule = LoadLibraryA( "shell32.dll" );
2178 if (hmodule)
2179 {
2180 FARPROC aboutproc = GetProcAddress( hmodule, "ShellAboutA" );
2181 if (aboutproc) aboutproc( hwnd, PACKAGE_NAME, PACKAGE_STRING, 0 );
2182 FreeLibrary( hmodule );
2183 }
2184 }
2185 else
2186 if (wParam == SC_PUTMARK)
2187 TRACE_(shell)("Mark requested by user\n");
2188 break;
2189
2190 case SC_HOTKEY:
2191 case SC_ARRANGE:
2192 case SC_NEXTWINDOW:
2193 case SC_PREVWINDOW:
2194 FIXME("unimplemented!\n");
2195 break;
2196 }
2197 return 0;
2198 }
2199
2200 /*************************************************************
2201 * NC_DrawGrayButton
2202 *
2203 * Stub for the grayed button of the caption
2204 *
2205 *************************************************************/
2206
2207 BOOL NC_DrawGrayButton(HDC hdc, int x, int y)
2208 {
2209 HBITMAP hMaskBmp;
2210 HDC hdcMask = CreateCompatibleDC (0);
2211 HBRUSH hOldBrush;
2212
2213 hMaskBmp = CreateBitmap (12, 10, 1, 1, lpGrayMask);
2214
2215 if(hMaskBmp == 0)
2216 return FALSE;
2217
2218 SelectObject (hdcMask, hMaskBmp);
2219
2220 /* Draw the grayed bitmap using the mask */
2221 hOldBrush = SelectObject (hdc, RGB(128, 128, 128));
2222 BitBlt (hdc, x, y, 12, 10,
2223 hdcMask, 0, 0, 0xB8074A);
2224
2225 /* Clean up */
2226 SelectObject (hdc, hOldBrush);
2227 DeleteObject(hMaskBmp);
2228 DeleteDC (hdcMask);
2229
2230 return TRUE;
2231 }
Maarten's multimedia branch