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