?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 20000326.
[wine/gsoc-2012-control.git] / windows / nonclient.c
blob8b0edd810343a4777c4b8ba08a04b7c475309ab9
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 "message.h"
14 #include "user.h"
15 #include "heap.h"
16 #include "dce.h"
17 #include "cursoricon.h"
18 #include "dialog.h"
19 #include "menu.h"
20 #include "winpos.h"
21 #include "hook.h"
22 #include "scroll.h"
23 #include "nonclient.h"
24 #include "queue.h"
25 #include "selectors.h"
26 #include "tweak.h"
27 #include "debugtools.h"
28 #include "options.h"
29 #include "shellapi.h"
30 #include "cache.h"
31 #include "bitmap.h"
32
33 DEFAULT_DEBUG_CHANNEL(nonclient)
34 DECLARE_DEBUG_CHANNEL(shell)
35
36 BOOL NC_DrawGrayButton(HDC hdc, int x, int y);
37
38 static HBITMAP16 hbitmapClose = 0;
39 static HBITMAP16 hbitmapCloseD = 0;
40 static HBITMAP16 hbitmapMinimize = 0;
41 static HBITMAP16 hbitmapMinimizeD = 0;
42 static HBITMAP16 hbitmapMaximize = 0;
43 static HBITMAP16 hbitmapMaximizeD = 0;
44 static HBITMAP16 hbitmapRestore = 0;
45 static HBITMAP16 hbitmapRestoreD = 0;
46
47 BYTE lpGrayMask[] = { 0xAA, 0xA0,
48 0x55, 0x50,
49 0xAA, 0xA0,
50 0x55, 0x50,
51 0xAA, 0xA0,
52 0x55, 0x50,
53 0xAA, 0xA0,
54 0x55, 0x50,
55 0xAA, 0xA0,
56 0x55, 0x50};
57
58 #define SC_ABOUTWINE (SC_SCREENSAVE+1)
59 #define SC_PUTMARK (SC_SCREENSAVE+2)
60
61 /* Some useful macros */
62 #define HAS_DLGFRAME(style,exStyle) \
63 (((exStyle) & WS_EX_DLGMODALFRAME) || \
64 (((style) & WS_DLGFRAME) && !((style) & WS_THICKFRAME)))
65
66 #define HAS_THICKFRAME(style,exStyle) \
67 (((style) & WS_THICKFRAME) && \
68 !(((style) & (WS_DLGFRAME|WS_BORDER)) == WS_DLGFRAME))
69
70 #define HAS_THINFRAME(style) \
71 (((style) & WS_BORDER) || !((style) & (WS_CHILD | WS_POPUP)))
72
73 #define HAS_BIGFRAME(style,exStyle) \
74 (((style) & (WS_THICKFRAME | WS_DLGFRAME)) || \
75 ((exStyle) & WS_EX_DLGMODALFRAME))
76
77 #define HAS_ANYFRAME(style,exStyle) \
78 (((style) & (WS_THICKFRAME | WS_DLGFRAME | WS_BORDER)) || \
79 ((exStyle) & WS_EX_DLGMODALFRAME) || \
80 !((style) & (WS_CHILD | WS_POPUP)))
81
82 #define HAS_MENU(w) (!((w)->dwStyle & WS_CHILD) && ((w)->wIDmenu != 0))
83
84 #define ON_LEFT_BORDER(hit) \
85 (((hit) == HTLEFT) || ((hit) == HTTOPLEFT) || ((hit) == HTBOTTOMLEFT))
86 #define ON_RIGHT_BORDER(hit) \
87 (((hit) == HTRIGHT) || ((hit) == HTTOPRIGHT) || ((hit) == HTBOTTOMRIGHT))
88 #define ON_TOP_BORDER(hit) \
89 (((hit) == HTTOP) || ((hit) == HTTOPLEFT) || ((hit) == HTTOPRIGHT))
90 #define ON_BOTTOM_BORDER(hit) \
91 (((hit) == HTBOTTOM) || ((hit) == HTBOTTOMLEFT) || ((hit) == HTBOTTOMRIGHT))
92
93 /***********************************************************************
94 * WIN_WindowNeedsWMBorder
95 *
96 * This method defines the rules for a window to have a WM border,
97 * caption... It is used for consitency purposes.
98 */
99 BOOL WIN_WindowNeedsWMBorder( DWORD style, DWORD exStyle )
100 {
101 if (!(style & WS_CHILD) &&
102 Options.managed &&
103 !(exStyle & WS_EX_TOOLWINDOW) &&
104 ( ((style & WS_CAPTION) == WS_CAPTION) ||
105 (style & WS_THICKFRAME)))
106 return TRUE;
107 if (exStyle & WS_EX_TRAYWINDOW)
108 return TRUE;
109 return FALSE;
110 }
111
112 /***********************************************************************
113 * NC_AdjustRect
114 *
115 * Compute the size of the window rectangle from the size of the
116 * client rectangle.
117 */
118 static void NC_AdjustRect( LPRECT16 rect, DWORD style, BOOL menu,
119 DWORD exStyle )
120 {
121 if (TWEAK_WineLook > WIN31_LOOK)
122 ERR("Called in Win95 mode. Aiee! Please report this.\n" );
123
124 if(style & WS_ICONIC) return;
125 /* Decide if the window will be managed (see CreateWindowEx) */
126 if (!WIN_WindowNeedsWMBorder(style, exStyle))
127 {
128 if (HAS_THICKFRAME( style, exStyle ))
129 InflateRect16( rect, GetSystemMetrics(SM_CXFRAME), GetSystemMetrics(SM_CYFRAME) );
130 else
131 if (HAS_DLGFRAME( style, exStyle ))
132 InflateRect16( rect, GetSystemMetrics(SM_CXDLGFRAME), GetSystemMetrics(SM_CYDLGFRAME) );
133 else
134 if (HAS_THINFRAME( style ))
135 InflateRect16( rect, GetSystemMetrics(SM_CXBORDER), GetSystemMetrics(SM_CYBORDER));
136
137 if ((style & WS_CAPTION) == WS_CAPTION)
138 rect->top -= GetSystemMetrics(SM_CYCAPTION) - GetSystemMetrics(SM_CYBORDER);
139 }
140 if (menu) rect->top -= GetSystemMetrics(SM_CYMENU) + GetSystemMetrics(SM_CYBORDER);
141
142 if (style & WS_VSCROLL) {
143 rect->right += GetSystemMetrics(SM_CXVSCROLL) - 1;
144 if(!HAS_ANYFRAME( style, exStyle ))
145 rect->right++;
146 }
147
148 if (style & WS_HSCROLL) {
149 rect->bottom += GetSystemMetrics(SM_CYHSCROLL) - 1;
150 if(!HAS_ANYFRAME( style, exStyle ))
151 rect->bottom++;
152 }
153 }
154
155
156 /******************************************************************************
157 * NC_AdjustRectOuter95
158 *
159 * Computes the size of the "outside" parts of the window based on the
160 * parameters of the client area.
161 *
162 + PARAMS
163 * LPRECT16 rect
164 * DWORD style
165 * BOOL32 menu
166 * DWORD exStyle
167 *
168 * NOTES
169 * "Outer" parts of a window means the whole window frame, caption and
170 * menu bar. It does not include "inner" parts of the frame like client
171 * edge, static edge or scroll bars.
172 *
173 * Revision history
174 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
175 * Original (NC_AdjustRect95) cut & paste from NC_AdjustRect
176 *
177 * 20-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
178 * Split NC_AdjustRect95 into NC_AdjustRectOuter95 and
179 * NC_AdjustRectInner95 and added handling of Win95 styles.
180 *
181 * 28-Jul-1999 Ove Kåven (ovek@arcticnet.no)
182 * Streamlined window style checks.
183 *
184 *****************************************************************************/
185
186 static void
187 NC_AdjustRectOuter95 (LPRECT16 rect, DWORD style, BOOL menu, DWORD exStyle)
188 {
189 if(style & WS_ICONIC) return;
190
191 /* Decide if the window will be managed (see CreateWindowEx) */
192 if (!WIN_WindowNeedsWMBorder(style, exStyle))
193 {
194 if (HAS_THICKFRAME( style, exStyle ))
195 InflateRect16( rect, GetSystemMetrics(SM_CXFRAME), GetSystemMetrics(SM_CYFRAME) );
196 else
197 if (HAS_DLGFRAME( style, exStyle ))
198 InflateRect16(rect, GetSystemMetrics(SM_CXDLGFRAME), GetSystemMetrics(SM_CYDLGFRAME) );
199 else
200 if (HAS_THINFRAME( style ))
201 InflateRect16( rect, GetSystemMetrics(SM_CXBORDER), GetSystemMetrics(SM_CYBORDER));
202
203 if ((style & WS_CAPTION) == WS_CAPTION)
204 {
205 if (exStyle & WS_EX_TOOLWINDOW)
206 rect->top -= GetSystemMetrics(SM_CYSMCAPTION);
207 else
208 rect->top -= GetSystemMetrics(SM_CYCAPTION);
209 }
210 }
211
212 if (menu)
213 rect->top -= GetSystemMetrics(SM_CYMENU);
214 }
215
216
217 /******************************************************************************
218 * NC_AdjustRectInner95
219 *
220 * Computes the size of the "inside" part of the window based on the
221 * parameters of the client area.
222 *
223 + PARAMS
224 * LPRECT16 rect
225 * DWORD style
226 * DWORD exStyle
227 *
228 * NOTES
229 * "Inner" part of a window means the window frame inside of the flat
230 * window frame. It includes the client edge, the static edge and the
231 * scroll bars.
232 *
233 * Revision history
234 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
235 * Original (NC_AdjustRect95) cut & paste from NC_AdjustRect
236 *
237 * 20-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
238 * Split NC_AdjustRect95 into NC_AdjustRectOuter95 and
239 * NC_AdjustRectInner95 and added handling of Win95 styles.
240 *
241 *****************************************************************************/
242
243 static void
244 NC_AdjustRectInner95 (LPRECT16 rect, DWORD style, DWORD exStyle)
245 {
246 if(style & WS_ICONIC) return;
247
248 if (exStyle & WS_EX_CLIENTEDGE)
249 InflateRect16 (rect, GetSystemMetrics(SM_CXEDGE), GetSystemMetrics(SM_CYEDGE));
250
251 if (exStyle & WS_EX_STATICEDGE)
252 InflateRect16 (rect, GetSystemMetrics(SM_CXBORDER), GetSystemMetrics(SM_CYBORDER));
253
254 if (style & WS_VSCROLL) rect->right += GetSystemMetrics(SM_CXVSCROLL);
255 if (style & WS_HSCROLL) rect->bottom += GetSystemMetrics(SM_CYHSCROLL);
256 }
257
258
259 /***********************************************************************
260 * DrawCaption16 [USER.660] Draws a caption bar
261 *
262 * PARAMS
263 * hwnd [I]
264 * hdc [I]
265 * lpRect [I]
266 * uFlags [I]
267 *
268 * RETURNS
269 * Success:
270 * Failure:
271 */
272
273 BOOL16 WINAPI
274 DrawCaption16 (HWND16 hwnd, HDC16 hdc, const RECT16 *rect, UINT16 uFlags)
275 {
276 RECT rect32;
277
278 if (rect)
279 CONV_RECT16TO32 (rect, &rect32);
280
281 return (BOOL16)DrawCaptionTempA (hwnd, hdc, rect ? &rect32 : NULL,
282 0, 0, NULL, uFlags & 0x1F);
283 }
284
285
286 /***********************************************************************
287 * DrawCaption32 [USER32.154] Draws a caption bar
288 *
289 * PARAMS
290 * hwnd [I]
291 * hdc [I]
292 * lpRect [I]
293 * uFlags [I]
294 *
295 * RETURNS
296 * Success:
297 * Failure:
298 */
299
300 BOOL WINAPI
301 DrawCaption (HWND hwnd, HDC hdc, const RECT *lpRect, UINT uFlags)
302 {
303 return DrawCaptionTempA (hwnd, hdc, lpRect, 0, 0, NULL, uFlags & 0x1F);
304 }
305
306
307 /***********************************************************************
308 * DrawCaptionTemp16 [USER.657]
309 *
310 * PARAMS
311 *
312 * RETURNS
313 * Success:
314 * Failure:
315 */
316
317 BOOL16 WINAPI
318 DrawCaptionTemp16 (HWND16 hwnd, HDC16 hdc, const RECT16 *rect, HFONT16 hFont,
319 HICON16 hIcon, LPCSTR str, UINT16 uFlags)
320 {
321 RECT rect32;
322
323 if (rect)
324 CONV_RECT16TO32(rect,&rect32);
325
326 return (BOOL16)DrawCaptionTempA (hwnd, hdc, rect?&rect32:NULL, hFont,
327 hIcon, str, uFlags & 0x1F);
328 }
329
330
331 /***********************************************************************
332 * DrawCaptionTemp32A [USER32.599]
333 *
334 * PARAMS
335 *
336 * RETURNS
337 * Success:
338 * Failure:
339 */
340
341 BOOL WINAPI
342 DrawCaptionTempA (HWND hwnd, HDC hdc, const RECT *rect, HFONT hFont,
343 HICON hIcon, LPCSTR str, UINT uFlags)
344 {
345 RECT rc = *rect;
346
347 TRACE("(%08x,%08x,%p,%08x,%08x,\"%s\",%08x)\n",
348 hwnd, hdc, rect, hFont, hIcon, str, uFlags);
349
350 /* drawing background */
351 if (uFlags & DC_INBUTTON) {
352 FillRect (hdc, &rc, GetSysColorBrush (COLOR_3DFACE));
353
354 if (uFlags & DC_ACTIVE) {
355 HBRUSH hbr = SelectObject (hdc, CACHE_GetPattern55AABrush ());
356 PatBlt (hdc, rc.left, rc.top,
357 rc.right-rc.left, rc.bottom-rc.top, 0xFA0089);
358 SelectObject (hdc, hbr);
359 }
360 }
361 else {
362 FillRect (hdc, &rc, GetSysColorBrush ((uFlags & DC_ACTIVE) ?
363 COLOR_ACTIVECAPTION : COLOR_INACTIVECAPTION));
364 }
365
366
367 /* drawing icon */
368 if ((uFlags & DC_ICON) && !(uFlags & DC_SMALLCAP)) {
369 POINT pt;
370
371 pt.x = rc.left + 2;
372 pt.y = (rc.bottom + rc.top - GetSystemMetrics(SM_CYSMICON)) / 2;
373
374 if (hIcon) {
375 DrawIconEx (hdc, pt.x, pt.y, hIcon, GetSystemMetrics(SM_CXSMICON),
376 GetSystemMetrics(SM_CYSMICON), 0, 0, DI_NORMAL);
377 }
378 else {
379 HICON hAppIcon = (HICON) GetClassLongA(hwnd, GCL_HICONSM);
380 if(!hAppIcon) hAppIcon = (HICON) GetClassLongA(hwnd, GCL_HICON);
381
382 DrawIconEx (hdc, pt.x, pt.y, hAppIcon, GetSystemMetrics(SM_CXSMICON),
383 GetSystemMetrics(SM_CYSMICON), 0, 0, DI_NORMAL);
384 }
385
386 rc.left += (rc.bottom - rc.top);
387 }
388
389 /* drawing text */
390 if (uFlags & DC_TEXT) {
391 HFONT hOldFont;
392
393 if (uFlags & DC_INBUTTON)
394 SetTextColor (hdc, GetSysColor (COLOR_BTNTEXT));
395 else if (uFlags & DC_ACTIVE)
396 SetTextColor (hdc, GetSysColor (COLOR_CAPTIONTEXT));
397 else
398 SetTextColor (hdc, GetSysColor (COLOR_INACTIVECAPTIONTEXT));
399
400 SetBkMode (hdc, TRANSPARENT);
401
402 if (hFont)
403 hOldFont = SelectObject (hdc, hFont);
404 else {
405 NONCLIENTMETRICSA nclm;
406 HFONT hNewFont;
407 nclm.cbSize = sizeof(NONCLIENTMETRICSA);
408 SystemParametersInfoA (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0);
409 hNewFont = CreateFontIndirectA ((uFlags & DC_SMALLCAP) ?
410 &nclm.lfSmCaptionFont : &nclm.lfCaptionFont);
411 hOldFont = SelectObject (hdc, hNewFont);
412 }
413
414 if (str)
415 DrawTextA (hdc, str, -1, &rc,
416 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT);
417 else {
418 CHAR szText[128];
419 INT nLen;
420 nLen = GetWindowTextA (hwnd, szText, 128);
421 DrawTextA (hdc, szText, nLen, &rc,
422 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT);
423 }
424
425 if (hFont)
426 SelectObject (hdc, hOldFont);
427 else
428 DeleteObject (SelectObject (hdc, hOldFont));
429 }
430
431 /* drawing focus ??? */
432 if (uFlags & 0x2000)
433 FIXME("undocumented flag (0x2000)!\n");
434
435 return 0;
436 }
437
438
439 /***********************************************************************
440 * DrawCaptionTemp32W [USER32.602]
441 *
442 * PARAMS
443 *
444 * RETURNS
445 * Success:
446 * Failure:
447 */
448
449 BOOL WINAPI
450 DrawCaptionTempW (HWND hwnd, HDC hdc, const RECT *rect, HFONT hFont,
451 HICON hIcon, LPCWSTR str, UINT uFlags)
452 {
453 LPSTR p = HEAP_strdupWtoA (GetProcessHeap (), 0, str);
454 BOOL res = DrawCaptionTempA (hwnd, hdc, rect, hFont, hIcon, p, uFlags);
455 HeapFree (GetProcessHeap (), 0, p);
456 return res;
457 }
458
459
460 /***********************************************************************
461 * AdjustWindowRect16 (USER.102)
462 */
463 BOOL16 WINAPI AdjustWindowRect16( LPRECT16 rect, DWORD style, BOOL16 menu )
464 {
465 return AdjustWindowRectEx16( rect, style, menu, 0 );
466 }
467
468
469 /***********************************************************************
470 * AdjustWindowRect32 (USER32.2)
471 */
472 BOOL WINAPI AdjustWindowRect( LPRECT rect, DWORD style, BOOL menu )
473 {
474 return AdjustWindowRectEx( rect, style, menu, 0 );
475 }
476
477
478 /***********************************************************************
479 * AdjustWindowRectEx16 (USER.454)
480 */
481 BOOL16 WINAPI AdjustWindowRectEx16( LPRECT16 rect, DWORD style,
482 BOOL16 menu, DWORD exStyle )
483 {
484 /* Correct the window style */
485
486 if (!(style & (WS_POPUP | WS_CHILD))) /* Overlapped window */
487 style |= WS_CAPTION;
488 style &= (WS_DLGFRAME | WS_BORDER | WS_THICKFRAME | WS_CHILD);
489 exStyle &= (WS_EX_DLGMODALFRAME | WS_EX_CLIENTEDGE |
490 WS_EX_STATICEDGE | WS_EX_TOOLWINDOW);
491 if (exStyle & WS_EX_DLGMODALFRAME) style &= ~WS_THICKFRAME;
492
493 TRACE("(%d,%d)-(%d,%d) %08lx %d %08lx\n",
494 rect->left, rect->top, rect->right, rect->bottom,
495 style, menu, exStyle );
496
497 if (TWEAK_WineLook == WIN31_LOOK)
498 NC_AdjustRect( rect, style, menu, exStyle );
499 else {
500 NC_AdjustRectOuter95( rect, style, menu, exStyle );
501 NC_AdjustRectInner95( rect, style, exStyle );
502 }
503
504 return TRUE;
505 }
506
507
508 /***********************************************************************
509 * AdjustWindowRectEx32 (USER32.3)
510 */
511 BOOL WINAPI AdjustWindowRectEx( LPRECT rect, DWORD style,
512 BOOL menu, DWORD exStyle )
513 {
514 RECT16 rect16;
515 BOOL ret;
516
517 CONV_RECT32TO16( rect, &rect16 );
518 ret = AdjustWindowRectEx16( &rect16, style, (BOOL16)menu, exStyle );
519 CONV_RECT16TO32( &rect16, rect );
520 return ret;
521 }
522
523
524 /***********************************************************************
525 * NC_HandleNCCalcSize
526 *
527 * Handle a WM_NCCALCSIZE message. Called from DefWindowProc().
528 */
529 LONG NC_HandleNCCalcSize( WND *pWnd, RECT *winRect )
530 {
531 RECT16 tmpRect = { 0, 0, 0, 0 };
532 LONG result = 0;
533 UINT style = (UINT) GetClassLongA(pWnd->hwndSelf, GCL_STYLE);
534
535 if (style & CS_VREDRAW) result |= WVR_VREDRAW;
536 if (style & CS_HREDRAW) result |= WVR_HREDRAW;
537
538 if( !( pWnd->dwStyle & WS_MINIMIZE ) ) {
539 if (TWEAK_WineLook == WIN31_LOOK)
540 NC_AdjustRect( &tmpRect, pWnd->dwStyle, FALSE, pWnd->dwExStyle );
541 else
542 NC_AdjustRectOuter95( &tmpRect, pWnd->dwStyle, FALSE, pWnd->dwExStyle );
543
544 winRect->left -= tmpRect.left;
545 winRect->top -= tmpRect.top;
546 winRect->right -= tmpRect.right;
547 winRect->bottom -= tmpRect.bottom;
548
549 if (HAS_MENU(pWnd)) {
550 TRACE("Calling GetMenuBarHeight with HWND 0x%x, width %d, "
551 "at (%d, %d).\n", pWnd->hwndSelf,
552 winRect->right - winRect->left,
553 -tmpRect.left, -tmpRect.top );
554
555 winRect->top +=
556 MENU_GetMenuBarHeight( pWnd->hwndSelf,
557 winRect->right - winRect->left,
558 -tmpRect.left, -tmpRect.top ) + 1;
559 }
560
561 if (TWEAK_WineLook > WIN31_LOOK) {
562 SetRect16 (&tmpRect, 0, 0, 0, 0);
563 NC_AdjustRectInner95 (&tmpRect, pWnd->dwStyle, pWnd->dwExStyle);
564 winRect->left -= tmpRect.left;
565 winRect->top -= tmpRect.top;
566 winRect->right -= tmpRect.right;
567 winRect->bottom -= tmpRect.bottom;
568 }
569 }
570 return result;
571 }
572
573
574 /***********************************************************************
575 * NC_GetInsideRect
576 *
577 * Get the 'inside' rectangle of a window, i.e. the whole window rectangle
578 * but without the borders (if any).
579 * The rectangle is in window coordinates (for drawing with GetWindowDC()).
580 */
581 static void NC_GetInsideRect( HWND hwnd, RECT *rect )
582 {
583 WND * wndPtr = WIN_FindWndPtr( hwnd );
584
585 rect->top = rect->left = 0;
586 rect->right = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
587 rect->bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
588
589 if ((wndPtr->dwStyle & WS_ICONIC) || (wndPtr->flags & WIN_MANAGED)) goto END;
590
591 /* Remove frame from rectangle */
592 if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
593 InflateRect( rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
594 else
595 if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
596 {
597 InflateRect( rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
598 /* FIXME: this isn't in NC_AdjustRect? why not? */
599 if (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME)
600 InflateRect( rect, -1, 0 );
601 }
602 else
603 if (HAS_THINFRAME( wndPtr->dwStyle ))
604 InflateRect( rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER) );
605 END:
606 WIN_ReleaseWndPtr(wndPtr);
607 return;
608 }
609
610
611 /***********************************************************************
612 * NC_GetInsideRect95
613 *
614 * Get the 'inside' rectangle of a window, i.e. the whole window rectangle
615 * but without the borders (if any).
616 * The rectangle is in window coordinates (for drawing with GetWindowDC()).
617 */
618
619 static void
620 NC_GetInsideRect95 (HWND hwnd, RECT *rect)
621 {
622 WND * wndPtr = WIN_FindWndPtr( hwnd );
623
624 rect->top = rect->left = 0;
625 rect->right = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
626 rect->bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
627
628 if ((wndPtr->dwStyle & WS_ICONIC) || (wndPtr->flags & WIN_MANAGED)) goto END;
629
630 /* Remove frame from rectangle */
631 if (HAS_THICKFRAME (wndPtr->dwStyle, wndPtr->dwExStyle))
632 {
633 InflateRect( rect, -GetSystemMetrics(SM_CXSIZEFRAME), -GetSystemMetrics(SM_CYSIZEFRAME) );
634 }
635 else if (HAS_DLGFRAME (wndPtr->dwStyle, wndPtr->dwExStyle ))
636 {
637 InflateRect( rect, -GetSystemMetrics(SM_CXFIXEDFRAME), -GetSystemMetrics(SM_CYFIXEDFRAME));
638 }
639 else if (HAS_THINFRAME (wndPtr->dwStyle))
640 {
641 InflateRect( rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER) );
642 }
643
644 /* We have additional border information if the window
645 * is a child (but not an MDI child) */
646 if ( (wndPtr->dwStyle & WS_CHILD) &&
647 ( (wndPtr->dwExStyle & WS_EX_MDICHILD) == 0 ) )
648 {
649 if (wndPtr->dwExStyle & WS_EX_CLIENTEDGE)
650 InflateRect (rect, -GetSystemMetrics(SM_CXEDGE), -GetSystemMetrics(SM_CYEDGE));
651
652 if (wndPtr->dwExStyle & WS_EX_STATICEDGE)
653 InflateRect (rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
654 }
655 END:
656 WIN_ReleaseWndPtr(wndPtr);
657 return;
658 }
659
660
661 /***********************************************************************
662 * NC_DoNCHitTest
663 *
664 * Handle a WM_NCHITTEST message. Called from NC_HandleNcHitTest().
665 */
666
667 static LONG NC_DoNCHitTest (WND *wndPtr, POINT16 pt )
668 {
669 RECT16 rect;
670
671 TRACE("hwnd=%04x pt=%d,%d\n", wndPtr->hwndSelf, pt.x, pt.y );
672
673 GetWindowRect16 (wndPtr->hwndSelf, &rect );
674 if (!PtInRect16( &rect, pt )) return HTNOWHERE;
675
676 if (wndPtr->dwStyle & WS_MINIMIZE) return HTCAPTION;
677
678 if (!(wndPtr->flags & WIN_MANAGED))
679 {
680 /* Check borders */
681 if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
682 {
683 InflateRect16( &rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
684 if (!PtInRect16( &rect, pt ))
685 {
686 /* Check top sizing border */
687 if (pt.y < rect.top)
688 {
689 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTTOPLEFT;
690 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTTOPRIGHT;
691 return HTTOP;
692 }
693 /* Check bottom sizing border */
694 if (pt.y >= rect.bottom)
695 {
696 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMLEFT;
697 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMRIGHT;
698 return HTBOTTOM;
699 }
700 /* Check left sizing border */
701 if (pt.x < rect.left)
702 {
703 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPLEFT;
704 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMLEFT;
705 return HTLEFT;
706 }
707 /* Check right sizing border */
708 if (pt.x >= rect.right)
709 {
710 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPRIGHT;
711 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMRIGHT;
712 return HTRIGHT;
713 }
714 }
715 }
716 else /* No thick frame */
717 {
718 if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
719 InflateRect16(&rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
720 else if (HAS_THINFRAME( wndPtr->dwStyle ))
721 InflateRect16(&rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
722 if (!PtInRect16( &rect, pt )) return HTBORDER;
723 }
724
725 /* Check caption */
726
727 if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
728 {
729 rect.top += GetSystemMetrics(SM_CYCAPTION) - GetSystemMetrics(SM_CYBORDER);
730 if (!PtInRect16( &rect, pt ))
731 {
732 /* Check system menu */
733 if (wndPtr->dwStyle & WS_SYSMENU)
734 rect.left += GetSystemMetrics(SM_CXSIZE);
735 if (pt.x <= rect.left) return HTSYSMENU;
736
737 /* Check maximize box */
738 if (wndPtr->dwStyle & WS_MAXIMIZEBOX)
739 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
740
741 if (pt.x >= rect.right) return HTMAXBUTTON;
742 /* Check minimize box */
743 if (wndPtr->dwStyle & WS_MINIMIZEBOX)
744 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
745 if (pt.x >= rect.right) return HTMINBUTTON;
746 return HTCAPTION;
747 }
748 }
749 }
750
751 /* Check client area */
752
753 ScreenToClient16( wndPtr->hwndSelf, &pt );
754 GetClientRect16( wndPtr->hwndSelf, &rect );
755 if (PtInRect16( &rect, pt )) return HTCLIENT;
756
757 /* Check vertical scroll bar */
758
759 if (wndPtr->dwStyle & WS_VSCROLL)
760 {
761 rect.right += GetSystemMetrics(SM_CXVSCROLL);
762 if (PtInRect16( &rect, pt )) return HTVSCROLL;
763 }
764
765 /* Check horizontal scroll bar */
766
767 if (wndPtr->dwStyle & WS_HSCROLL)
768 {
769 rect.bottom += GetSystemMetrics(SM_CYHSCROLL);
770 if (PtInRect16( &rect, pt ))
771 {
772 /* Check size box */
773 if ((wndPtr->dwStyle & WS_VSCROLL) &&
774 (pt.x >= rect.right - GetSystemMetrics(SM_CXVSCROLL)))
775 return HTSIZE;
776 return HTHSCROLL;
777 }
778 }
779
780 /* Check menu bar */
781
782 if (HAS_MENU(wndPtr))
783 {
784 if ((pt.y < 0) && (pt.x >= 0) && (pt.x < rect.right))
785 return HTMENU;
786 }
787
788 /* Should never get here */
789 return HTERROR;
790 }
791
792
793 /***********************************************************************
794 * NC_DoNCHitTest95
795 *
796 * Handle a WM_NCHITTEST message. Called from NC_HandleNCHitTest().
797 *
798 * FIXME: Just a modified copy of the Win 3.1 version.
799 */
800
801 static LONG
802 NC_DoNCHitTest95 (WND *wndPtr, POINT16 pt )
803 {
804 RECT16 rect;
805
806 TRACE("hwnd=%04x pt=%d,%d\n", wndPtr->hwndSelf, pt.x, pt.y );
807
808 GetWindowRect16 (wndPtr->hwndSelf, &rect );
809 if (!PtInRect16( &rect, pt )) return HTNOWHERE;
810
811 if (wndPtr->dwStyle & WS_MINIMIZE) return HTCAPTION;
812
813 if (!(wndPtr->flags & WIN_MANAGED))
814 {
815 /* Check borders */
816 if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
817 {
818 InflateRect16( &rect, -GetSystemMetrics(SM_CXFRAME), -GetSystemMetrics(SM_CYFRAME) );
819 if (!PtInRect16( &rect, pt ))
820 {
821 /* Check top sizing border */
822 if (pt.y < rect.top)
823 {
824 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTTOPLEFT;
825 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTTOPRIGHT;
826 return HTTOP;
827 }
828 /* Check bottom sizing border */
829 if (pt.y >= rect.bottom)
830 {
831 if (pt.x < rect.left+GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMLEFT;
832 if (pt.x >= rect.right-GetSystemMetrics(SM_CXSIZE)) return HTBOTTOMRIGHT;
833 return HTBOTTOM;
834 }
835 /* Check left sizing border */
836 if (pt.x < rect.left)
837 {
838 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPLEFT;
839 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMLEFT;
840 return HTLEFT;
841 }
842 /* Check right sizing border */
843 if (pt.x >= rect.right)
844 {
845 if (pt.y < rect.top+GetSystemMetrics(SM_CYSIZE)) return HTTOPRIGHT;
846 if (pt.y >= rect.bottom-GetSystemMetrics(SM_CYSIZE)) return HTBOTTOMRIGHT;
847 return HTRIGHT;
848 }
849 }
850 }
851 else /* No thick frame */
852 {
853 if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
854 InflateRect16(&rect, -GetSystemMetrics(SM_CXDLGFRAME), -GetSystemMetrics(SM_CYDLGFRAME));
855 else if (HAS_THINFRAME( wndPtr->dwStyle ))
856 InflateRect16(&rect, -GetSystemMetrics(SM_CXBORDER), -GetSystemMetrics(SM_CYBORDER));
857 if (!PtInRect16( &rect, pt )) return HTBORDER;
858 }
859
860 /* Check caption */
861
862 if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
863 {
864 if (wndPtr->dwExStyle & WS_EX_TOOLWINDOW)
865 rect.top += GetSystemMetrics(SM_CYSMCAPTION) - 1;
866 else
867 rect.top += GetSystemMetrics(SM_CYCAPTION) - 1;
868 if (!PtInRect16( &rect, pt ))
869 {
870 /* Check system menu */
871 if(wndPtr->dwStyle & WS_SYSMENU)
872 {
873 /* Check if there is an user icon */
874 HICON hIcon = (HICON) GetClassLongA(wndPtr->hwndSelf, GCL_HICONSM);
875 if(!hIcon) hIcon = (HICON) GetClassLongA(wndPtr->hwndSelf, GCL_HICON);
876
877 /* If there is an icon associated with the window OR */
878 /* If there is no hIcon specified and this is not a modal dialog, */
879 /* there is a system menu icon. */
880 if((hIcon != 0) || (!(wndPtr->dwStyle & DS_MODALFRAME)))
881 rect.left += GetSystemMetrics(SM_CYCAPTION) - 1;
882 }
883 if (pt.x < rect.left) return HTSYSMENU;
884
885 /* Check close button */
886 if (wndPtr->dwStyle & WS_SYSMENU)
887 rect.right -= GetSystemMetrics(SM_CYCAPTION) - 1;
888 if (pt.x > rect.right) return HTCLOSE;
889
890 /* Check maximize box */
891 /* In win95 there is automatically a Maximize button when there is a minimize one*/
892 if ((wndPtr->dwStyle & WS_MAXIMIZEBOX)|| (wndPtr->dwStyle & WS_MINIMIZEBOX))
893 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
894 if (pt.x > rect.right) return HTMAXBUTTON;
895
896 /* Check minimize box */
897 /* In win95 there is automatically a Maximize button when there is a Maximize one*/
898 if ((wndPtr->dwStyle & WS_MINIMIZEBOX)||(wndPtr->dwStyle & WS_MAXIMIZEBOX))
899 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
900
901 if (pt.x > rect.right) return HTMINBUTTON;
902 return HTCAPTION;
903 }
904 }
905 }
906
907 /* Check client area */
908
909 ScreenToClient16( wndPtr->hwndSelf, &pt );
910 GetClientRect16( wndPtr->hwndSelf, &rect );
911 if (PtInRect16( &rect, pt )) return HTCLIENT;
912
913 /* Check vertical scroll bar */
914
915 if (wndPtr->dwStyle & WS_VSCROLL)
916 {
917 rect.right += GetSystemMetrics(SM_CXVSCROLL);
918 if (PtInRect16( &rect, pt )) return HTVSCROLL;
919 }
920
921 /* Check horizontal scroll bar */
922
923 if (wndPtr->dwStyle & WS_HSCROLL)
924 {
925 rect.bottom += GetSystemMetrics(SM_CYHSCROLL);
926 if (PtInRect16( &rect, pt ))
927 {
928 /* Check size box */
929 if ((wndPtr->dwStyle & WS_VSCROLL) &&
930 (pt.x >= rect.right - GetSystemMetrics(SM_CXVSCROLL)))
931 return HTSIZE;
932 return HTHSCROLL;
933 }
934 }
935
936 /* Check menu bar */
937
938 if (HAS_MENU(wndPtr))
939 {
940 if ((pt.y < 0) && (pt.x >= 0) && (pt.x < rect.right))
941 return HTMENU;
942 }
943
944 /* Should never get here */
945 return HTERROR;
946 }
947
948
949 /***********************************************************************
950 * NC_HandleNCHitTest
951 *
952 * Handle a WM_NCHITTEST message. Called from DefWindowProc().
953 */
954 LONG
955 NC_HandleNCHitTest (HWND hwnd , POINT16 pt)
956 {
957 LONG retvalue;
958 WND *wndPtr = WIN_FindWndPtr (hwnd);
959
960 if (!wndPtr)
961 return HTERROR;
962
963 if (TWEAK_WineLook == WIN31_LOOK)
964 retvalue = NC_DoNCHitTest (wndPtr, pt);
965 else
966 retvalue = NC_DoNCHitTest95 (wndPtr, pt);
967 WIN_ReleaseWndPtr(wndPtr);
968 return retvalue;
969 }
970
971
972 /***********************************************************************
973 * NC_DrawSysButton
974 */
975 void NC_DrawSysButton( HWND hwnd, HDC hdc, BOOL down )
976 {
977 RECT rect;
978 HDC hdcMem;
979 HBITMAP hbitmap;
980 WND *wndPtr = WIN_FindWndPtr( hwnd );
981
982 if( !(wndPtr->flags & WIN_MANAGED) )
983 {
984 NC_GetInsideRect( hwnd, &rect );
985 hdcMem = CreateCompatibleDC( hdc );
986 hbitmap = SelectObject( hdcMem, hbitmapClose );
987 BitBlt(hdc, rect.left, rect.top, GetSystemMetrics(SM_CXSIZE), GetSystemMetrics(SM_CYSIZE),
988 hdcMem, (wndPtr->dwStyle & WS_CHILD) ? GetSystemMetrics(SM_CXSIZE) : 0, 0,
989 down ? NOTSRCCOPY : SRCCOPY );
990 SelectObject( hdcMem, hbitmap );
991 DeleteDC( hdcMem );
992 }
993 WIN_ReleaseWndPtr(wndPtr);
994 }
995
996
997 /***********************************************************************
998 * NC_DrawMaxButton
999 */
1000 static void NC_DrawMaxButton( HWND hwnd, HDC16 hdc, BOOL down )
1001 {
1002 RECT rect;
1003 WND *wndPtr = WIN_FindWndPtr( hwnd );
1004 HDC hdcMem;
1005
1006 if( !(wndPtr->flags & WIN_MANAGED) )
1007 {
1008 NC_GetInsideRect( hwnd, &rect );
1009 hdcMem = CreateCompatibleDC( hdc );
1010 SelectObject( hdcMem, (IsZoomed(hwnd)
1011 ? (down ? hbitmapRestoreD : hbitmapRestore)
1012 : (down ? hbitmapMaximizeD : hbitmapMaximize)) );
1013 BitBlt( hdc, rect.right - GetSystemMetrics(SM_CXSIZE) - 1, rect.top,
1014 GetSystemMetrics(SM_CXSIZE) + 1, GetSystemMetrics(SM_CYSIZE), hdcMem, 0, 0,
1015 SRCCOPY );
1016 DeleteDC( hdcMem );
1017 }
1018 WIN_ReleaseWndPtr(wndPtr);
1019
1020 }
1021
1022
1023 /***********************************************************************
1024 * NC_DrawMinButton
1025 */
1026 static void NC_DrawMinButton( HWND hwnd, HDC16 hdc, BOOL down )
1027 {
1028 RECT rect;
1029 WND *wndPtr = WIN_FindWndPtr( hwnd );
1030 HDC hdcMem;
1031
1032 if( !(wndPtr->flags & WIN_MANAGED) )
1033 {
1034 NC_GetInsideRect( hwnd, &rect );
1035 hdcMem = CreateCompatibleDC( hdc );
1036 SelectObject( hdcMem, (down ? hbitmapMinimizeD : hbitmapMinimize) );
1037 if (wndPtr->dwStyle & WS_MAXIMIZEBOX) rect.right -= GetSystemMetrics(SM_CXSIZE)+1;
1038 BitBlt( hdc, rect.right - GetSystemMetrics(SM_CXSIZE) - 1, rect.top,
1039 GetSystemMetrics(SM_CXSIZE) + 1, GetSystemMetrics(SM_CYSIZE), hdcMem, 0, 0,
1040 SRCCOPY );
1041 DeleteDC( hdcMem );
1042 }
1043 WIN_ReleaseWndPtr(wndPtr);
1044 }
1045
1046
1047 /******************************************************************************
1048 *
1049 * void NC_DrawSysButton95(
1050 * HWND32 hwnd,
1051 * HDC32 hdc,
1052 * BOOL32 down )
1053 *
1054 * Draws the Win95 system icon.
1055 *
1056 * Revision history
1057 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1058 * Original implementation from NC_DrawSysButton source.
1059 * 11-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1060 * Fixed most bugs.
1061 *
1062 *****************************************************************************/
1063
1064 BOOL
1065 NC_DrawSysButton95 (HWND hwnd, HDC hdc, BOOL down)
1066 {
1067 WND *wndPtr = WIN_FindWndPtr( hwnd );
1068
1069 if( !(wndPtr->flags & WIN_MANAGED) )
1070 {
1071 HICON hIcon;
1072 RECT rect;
1073
1074 NC_GetInsideRect95( hwnd, &rect );
1075
1076 hIcon = (HICON) GetClassLongA(wndPtr->hwndSelf, GCL_HICONSM);
1077 if(!hIcon) hIcon = (HICON) GetClassLongA(wndPtr->hwndSelf, GCL_HICON);
1078
1079 /* If there is no hIcon specified or this is not a modal dialog, */
1080 /* get the default one. */
1081 if(hIcon == 0)
1082 if (!(wndPtr->dwStyle & DS_MODALFRAME))
1083 hIcon = LoadImageA(0, MAKEINTRESOURCEA(OIC_WINEICON), IMAGE_ICON, 0, 0, LR_DEFAULTCOLOR);
1084
1085 if (hIcon)
1086 DrawIconEx (hdc, rect.left + 2, rect.top + 2, hIcon,
1087 GetSystemMetrics(SM_CXSMICON),
1088 GetSystemMetrics(SM_CYSMICON),
1089 0, 0, DI_NORMAL);
1090
1091 WIN_ReleaseWndPtr(wndPtr);
1092 return (hIcon != 0);
1093 }
1094 WIN_ReleaseWndPtr(wndPtr);
1095 return FALSE;
1096 }
1097
1098
1099 /******************************************************************************
1100 *
1101 * void NC_DrawCloseButton95(
1102 * HWND32 hwnd,
1103 * HDC32 hdc,
1104 * BOOL32 down,
1105 * BOOL bGrayed )
1106 *
1107 * Draws the Win95 close button.
1108 *
1109 * If bGrayed is true, then draw a disabled Close button
1110 *
1111 * Revision history
1112 * 11-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1113 * Original implementation from NC_DrawSysButton95 source.
1114 *
1115 *****************************************************************************/
1116
1117 static void NC_DrawCloseButton95 (HWND hwnd, HDC hdc, BOOL down, BOOL bGrayed)
1118 {
1119 RECT rect;
1120 HDC hdcMem;
1121 WND *wndPtr = WIN_FindWndPtr( hwnd );
1122
1123 if( !(wndPtr->flags & WIN_MANAGED) )
1124 {
1125 BITMAP bmp;
1126 HBITMAP hBmp, hOldBmp;
1127
1128 NC_GetInsideRect95( hwnd, &rect );
1129
1130 hdcMem = CreateCompatibleDC( hdc );
1131 hBmp = down ? hbitmapCloseD : hbitmapClose;
1132 hOldBmp = SelectObject (hdcMem, hBmp);
1133 GetObjectA (hBmp, sizeof(BITMAP), &bmp);
1134
1135 BitBlt (hdc, rect.right - (GetSystemMetrics(SM_CYCAPTION) + 1 + bmp.bmWidth) / 2,
1136 rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2,
1137 bmp.bmWidth, bmp.bmHeight, hdcMem, 0, 0, SRCCOPY);
1138
1139 if(bGrayed)
1140 NC_DrawGrayButton(hdc,rect.right - (GetSystemMetrics(SM_CYCAPTION) + 1 + bmp.bmWidth) / 2 + 2,
1141 rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2 + 2);
1142
1143 SelectObject (hdcMem, hOldBmp);
1144 DeleteDC (hdcMem);
1145 }
1146 WIN_ReleaseWndPtr(wndPtr);
1147 }
1148
1149 /******************************************************************************
1150 *
1151 * NC_DrawMaxButton95(
1152 * HWND32 hwnd,
1153 * HDC16 hdc,
1154 * BOOL32 down
1155 * BOOL bGrayed )
1156 *
1157 * Draws the maximize button for Win95 style windows.
1158 *
1159 * If bGrayed is true, then draw a disabled Maximize button
1160 *
1161 * Bugs
1162 * Many. Spacing might still be incorrect. Need to fit a close
1163 * button between the max button and the edge.
1164 * Should scale the image with the title bar. And more...
1165 *
1166 * Revision history
1167 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1168 * Original implementation.
1169 *
1170 *****************************************************************************/
1171
1172 static void NC_DrawMaxButton95(HWND hwnd,HDC16 hdc,BOOL down, BOOL bGrayed)
1173 {
1174 RECT rect;
1175 HDC hdcMem;
1176 WND *wndPtr = WIN_FindWndPtr( hwnd );
1177
1178 if( !(wndPtr->flags & WIN_MANAGED))
1179 {
1180 BITMAP bmp;
1181 HBITMAP hBmp,hOldBmp;
1182
1183 NC_GetInsideRect95( hwnd, &rect );
1184 hdcMem = CreateCompatibleDC( hdc );
1185 hBmp = IsZoomed(hwnd) ?
1186 (down ? hbitmapRestoreD : hbitmapRestore ) :
1187 (down ? hbitmapMaximizeD: hbitmapMaximize);
1188 hOldBmp=SelectObject( hdcMem, hBmp );
1189 GetObjectA (hBmp, sizeof(BITMAP), &bmp);
1190
1191 if (wndPtr->dwStyle & WS_SYSMENU)
1192 rect.right -= GetSystemMetrics(SM_CYCAPTION) + 1;
1193
1194 BitBlt( hdc, rect.right - (GetSystemMetrics(SM_CXSIZE) + bmp.bmWidth) / 2,
1195 rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2,
1196 bmp.bmWidth, bmp.bmHeight, hdcMem, 0, 0, SRCCOPY );
1197
1198 if(bGrayed)
1199 NC_DrawGrayButton(hdc, rect.right - (GetSystemMetrics(SM_CXSIZE) + bmp.bmWidth) / 2 + 2,
1200 rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2 + 2);
1201
1202
1203 SelectObject (hdcMem, hOldBmp);
1204 DeleteDC( hdcMem );
1205 }
1206 WIN_ReleaseWndPtr(wndPtr);
1207 }
1208
1209 /******************************************************************************
1210 *
1211 * NC_DrawMinButton95(
1212 * HWND32 hwnd,
1213 * HDC16 hdc,
1214 * BOOL32 down,
1215 * BOOL bGrayed )
1216 *
1217 * Draws the minimize button for Win95 style windows.
1218 *
1219 * If bGrayed is true, then draw a disabled Minimize button
1220 *
1221 * Bugs
1222 * Many. Spacing is still incorrect. Should scale the image with the
1223 * title bar. And more...
1224 *
1225 * Revision history
1226 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1227 * Original implementation.
1228 *
1229 *****************************************************************************/
1230
1231 static void NC_DrawMinButton95(HWND hwnd,HDC16 hdc,BOOL down, BOOL bGrayed)
1232 {
1233 RECT rect;
1234 HDC hdcMem;
1235 WND *wndPtr = WIN_FindWndPtr( hwnd );
1236
1237 if( !(wndPtr->flags & WIN_MANAGED))
1238
1239 {
1240 BITMAP bmp;
1241 HBITMAP hBmp,hOldBmp;
1242
1243 NC_GetInsideRect95( hwnd, &rect );
1244
1245 hdcMem = CreateCompatibleDC( hdc );
1246 hBmp = down ? hbitmapMinimizeD : hbitmapMinimize;
1247 hOldBmp= SelectObject( hdcMem, hBmp );
1248 GetObjectA (hBmp, sizeof(BITMAP), &bmp);
1249
1250 if (wndPtr->dwStyle & WS_SYSMENU)
1251 rect.right -= GetSystemMetrics(SM_CYCAPTION) + 1;
1252
1253 /* In win 95 there is always a Maximize box when there is a Minimize one */
1254 if ((wndPtr->dwStyle & WS_MAXIMIZEBOX) || (wndPtr->dwStyle & WS_MINIMIZEBOX))
1255 rect.right += -1 - (GetSystemMetrics(SM_CXSIZE) + bmp.bmWidth) / 2;
1256
1257 BitBlt( hdc, rect.right - (GetSystemMetrics(SM_CXSIZE) + bmp.bmWidth) / 2,
1258 rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2,
1259 bmp.bmWidth, bmp.bmHeight, hdcMem, 0, 0, SRCCOPY );
1260
1261 if(bGrayed)
1262 NC_DrawGrayButton(hdc, rect.right - (GetSystemMetrics(SM_CXSIZE) + bmp.bmWidth) / 2 + 2,
1263 rect.top + (GetSystemMetrics(SM_CYCAPTION) - 1 - bmp.bmHeight) / 2 + 2);
1264
1265
1266 SelectObject (hdcMem, hOldBmp);
1267 DeleteDC( hdcMem );
1268 }
1269 WIN_ReleaseWndPtr(wndPtr);
1270 }
1271
1272 /***********************************************************************
1273 * NC_DrawFrame
1274 *
1275 * Draw a window frame inside the given rectangle, and update the rectangle.
1276 * The correct pen for the frame must be selected in the DC.
1277 */
1278 static void NC_DrawFrame( HDC hdc, RECT *rect, BOOL dlgFrame,
1279 BOOL active )
1280 {
1281 INT width, height;
1282
1283 if (TWEAK_WineLook != WIN31_LOOK)
1284 ERR("Called in Win95 mode. Aiee! Please report this.\n" );
1285
1286 if (dlgFrame)
1287 {
1288 width = GetSystemMetrics(SM_CXDLGFRAME) - 1;
1289 height = GetSystemMetrics(SM_CYDLGFRAME) - 1;
1290 SelectObject( hdc, GetSysColorBrush(active ? COLOR_ACTIVECAPTION :
1291 COLOR_INACTIVECAPTION) );
1292 }
1293 else
1294 {
1295 width = GetSystemMetrics(SM_CXFRAME) - 2;
1296 height = GetSystemMetrics(SM_CYFRAME) - 2;
1297 SelectObject( hdc, GetSysColorBrush(active ? COLOR_ACTIVEBORDER :
1298 COLOR_INACTIVEBORDER) );
1299 }
1300
1301 /* Draw frame */
1302 PatBlt( hdc, rect->left, rect->top,
1303 rect->right - rect->left, height, PATCOPY );
1304 PatBlt( hdc, rect->left, rect->top,
1305 width, rect->bottom - rect->top, PATCOPY );
1306 PatBlt( hdc, rect->left, rect->bottom - 1,
1307 rect->right - rect->left, -height, PATCOPY );
1308 PatBlt( hdc, rect->right - 1, rect->top,
1309 -width, rect->bottom - rect->top, PATCOPY );
1310
1311 if (dlgFrame)
1312 {
1313 InflateRect( rect, -width, -height );
1314 }
1315 else
1316 {
1317 INT decYOff = GetSystemMetrics(SM_CXFRAME) + GetSystemMetrics(SM_CXSIZE) - 1;
1318 INT decXOff = GetSystemMetrics(SM_CYFRAME) + GetSystemMetrics(SM_CYSIZE) - 1;
1319
1320 /* Draw inner rectangle */
1321
1322 SelectObject( hdc, GetStockObject(NULL_BRUSH) );
1323 Rectangle( hdc, rect->left + width, rect->top + height,
1324 rect->right - width , rect->bottom - height );
1325
1326 /* Draw the decorations */
1327
1328 MoveToEx( hdc, rect->left, rect->top + decYOff, NULL );
1329 LineTo( hdc, rect->left + width, rect->top + decYOff );
1330 MoveToEx( hdc, rect->right - 1, rect->top + decYOff, NULL );
1331 LineTo( hdc, rect->right - width - 1, rect->top + decYOff );
1332 MoveToEx( hdc, rect->left, rect->bottom - decYOff, NULL );
1333 LineTo( hdc, rect->left + width, rect->bottom - decYOff );
1334 MoveToEx( hdc, rect->right - 1, rect->bottom - decYOff, NULL );
1335 LineTo( hdc, rect->right - width - 1, rect->bottom - decYOff );
1336
1337 MoveToEx( hdc, rect->left + decXOff, rect->top, NULL );
1338 LineTo( hdc, rect->left + decXOff, rect->top + height);
1339 MoveToEx( hdc, rect->left + decXOff, rect->bottom - 1, NULL );
1340 LineTo( hdc, rect->left + decXOff, rect->bottom - height - 1 );
1341 MoveToEx( hdc, rect->right - decXOff, rect->top, NULL );
1342 LineTo( hdc, rect->right - decXOff, rect->top + height );
1343 MoveToEx( hdc, rect->right - decXOff, rect->bottom - 1, NULL );
1344 LineTo( hdc, rect->right - decXOff, rect->bottom - height - 1 );
1345
1346 InflateRect( rect, -width - 1, -height - 1 );
1347 }
1348 }
1349
1350
1351 /******************************************************************************
1352 *
1353 * void NC_DrawFrame95(
1354 * HDC32 hdc,
1355 * RECT32 *rect,
1356 * BOOL32 dlgFrame,
1357 * BOOL32 active )
1358 *
1359 * Draw a window frame inside the given rectangle, and update the rectangle.
1360 * The correct pen for the frame must be selected in the DC.
1361 *
1362 * Bugs
1363 * Many. First, just what IS a frame in Win95? Note that the 3D look
1364 * on the outer edge is handled by NC_DoNCPaint95. As is the inner
1365 * edge. The inner rectangle just inside the frame is handled by the
1366 * Caption code.
1367 *
1368 * In short, for most people, this function should be a nop (unless
1369 * you LIKE thick borders in Win95/NT4.0 -- I've been working with
1370 * them lately, but just to get this code right). Even so, it doesn't
1371 * appear to be so. It's being worked on...
1372 *
1373 * Revision history
1374 * 06-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1375 * Original implementation (based on NC_DrawFrame)
1376 * 02-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1377 * Some minor fixes.
1378 * 29-Jun-1999 Ove Kåven (ovek@arcticnet.no)
1379 * Fixed a fix or something.
1380 *
1381 *****************************************************************************/
1382
1383 static void NC_DrawFrame95(
1384 HDC hdc,
1385 RECT *rect,
1386 BOOL dlgFrame,
1387 BOOL active )
1388 {
1389 INT width, height;
1390
1391 if (dlgFrame)
1392 {
1393 width = GetSystemMetrics(SM_CXDLGFRAME) - GetSystemMetrics(SM_CXEDGE);
1394 height = GetSystemMetrics(SM_CYDLGFRAME) - GetSystemMetrics(SM_CYEDGE);
1395 }
1396 else
1397 {
1398 width = GetSystemMetrics(SM_CXFRAME) - GetSystemMetrics(SM_CXEDGE);
1399 height = GetSystemMetrics(SM_CYFRAME) - GetSystemMetrics(SM_CYEDGE);
1400 }
1401
1402 SelectObject( hdc, GetSysColorBrush(active ? COLOR_ACTIVEBORDER :
1403 COLOR_INACTIVEBORDER) );
1404
1405 /* Draw frame */
1406 PatBlt( hdc, rect->left, rect->top,
1407 rect->right - rect->left, height, PATCOPY );
1408 PatBlt( hdc, rect->left, rect->top,
1409 width, rect->bottom - rect->top, PATCOPY );
1410 PatBlt( hdc, rect->left, rect->bottom - 1,
1411 rect->right - rect->left, -height, PATCOPY );
1412 PatBlt( hdc, rect->right - 1, rect->top,
1413 -width, rect->bottom - rect->top, PATCOPY );
1414
1415 InflateRect( rect, -width, -height );
1416 }
1417
1418 /***********************************************************************
1419 * NC_DrawMovingFrame
1420 *
1421 * Draw the frame used when moving or resizing window.
1422 *
1423 * FIXME: This causes problems in Win95 mode. (why?)
1424 */
1425 static void NC_DrawMovingFrame( HDC hdc, RECT *rect, BOOL thickframe )
1426 {
1427 if (thickframe)
1428 {
1429 RECT16 r16;
1430 CONV_RECT32TO16( rect, &r16 );
1431 FastWindowFrame16( hdc, &r16, GetSystemMetrics(SM_CXFRAME),
1432 GetSystemMetrics(SM_CYFRAME), PATINVERT );
1433 }
1434 else DrawFocusRect( hdc, rect );
1435 }
1436
1437
1438 /***********************************************************************
1439 * NC_DrawCaption
1440 *
1441 * Draw the window caption.
1442 * The correct pen for the window frame must be selected in the DC.
1443 */
1444 static void NC_DrawCaption( HDC hdc, RECT *rect, HWND hwnd,
1445 DWORD style, BOOL active )
1446 {
1447 RECT r = *rect;
1448 WND * wndPtr = WIN_FindWndPtr( hwnd );
1449 char buffer[256];
1450
1451 if (wndPtr->flags & WIN_MANAGED)
1452 {
1453 WIN_ReleaseWndPtr(wndPtr);
1454 return;
1455 }
1456
1457 if (!hbitmapClose)
1458 {
1459 if (!(hbitmapClose = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_CLOSE) )))
1460 {
1461 WIN_ReleaseWndPtr(wndPtr);
1462 return;
1463 }
1464 hbitmapCloseD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_CLOSED) );
1465 hbitmapMinimize = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_REDUCE) );
1466 hbitmapMinimizeD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_REDUCED) );
1467 hbitmapMaximize = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_ZOOM) );
1468 hbitmapMaximizeD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_ZOOMD) );
1469 hbitmapRestore = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_RESTORE) );
1470 hbitmapRestoreD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_RESTORED) );
1471 }
1472
1473 if (wndPtr->dwExStyle & WS_EX_DLGMODALFRAME)
1474 {
1475 HBRUSH hbrushOld = SelectObject(hdc, GetSysColorBrush(COLOR_WINDOW) );
1476 PatBlt( hdc, r.left, r.top, 1, r.bottom-r.top+1,PATCOPY );
1477 PatBlt( hdc, r.right-1, r.top, 1, r.bottom-r.top+1, PATCOPY );
1478 PatBlt( hdc, r.left, r.top-1, r.right-r.left, 1, PATCOPY );
1479 r.left++;
1480 r.right--;
1481 SelectObject( hdc, hbrushOld );
1482 }
1483 WIN_ReleaseWndPtr(wndPtr);
1484 MoveTo16( hdc, r.left, r.bottom );
1485 LineTo( hdc, r.right, r.bottom );
1486
1487 if (style & WS_SYSMENU)
1488 {
1489 NC_DrawSysButton( hwnd, hdc, FALSE );
1490 r.left += GetSystemMetrics(SM_CXSIZE) + 1;
1491 MoveTo16( hdc, r.left - 1, r.top );
1492 LineTo( hdc, r.left - 1, r.bottom );
1493 }
1494 if (style & WS_MAXIMIZEBOX)
1495 {
1496 NC_DrawMaxButton( hwnd, hdc, FALSE );
1497 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1498 }
1499 if (style & WS_MINIMIZEBOX)
1500 {
1501 NC_DrawMinButton( hwnd, hdc, FALSE );
1502 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1503 }
1504
1505 FillRect( hdc, &r, GetSysColorBrush(active ? COLOR_ACTIVECAPTION :
1506 COLOR_INACTIVECAPTION) );
1507
1508 if (GetWindowTextA( hwnd, buffer, sizeof(buffer) ))
1509 {
1510 if (active) SetTextColor( hdc, GetSysColor( COLOR_CAPTIONTEXT ) );
1511 else SetTextColor( hdc, GetSysColor( COLOR_INACTIVECAPTIONTEXT ) );
1512 SetBkMode( hdc, TRANSPARENT );
1513 DrawTextA( hdc, buffer, -1, &r,
1514 DT_SINGLELINE | DT_CENTER | DT_VCENTER | DT_NOPREFIX );
1515 }
1516 }
1517
1518
1519 /******************************************************************************
1520 *
1521 * NC_DrawCaption95(
1522 * HDC32 hdc,
1523 * RECT32 *rect,
1524 * HWND32 hwnd,
1525 * DWORD style,
1526 * BOOL32 active )
1527 *
1528 * Draw the window caption for Win95 style windows.
1529 * The correct pen for the window frame must be selected in the DC.
1530 *
1531 * Bugs
1532 * Hey, a function that finally works! Well, almost.
1533 * It's being worked on.
1534 *
1535 * Revision history
1536 * 05-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1537 * Original implementation.
1538 * 02-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1539 * Some minor fixes.
1540 *
1541 *****************************************************************************/
1542
1543 static void NC_DrawCaption95(
1544 HDC hdc,
1545 RECT *rect,
1546 HWND hwnd,
1547 DWORD style,
1548 DWORD exStyle,
1549 BOOL active )
1550 {
1551 RECT r = *rect;
1552 WND *wndPtr = WIN_FindWndPtr( hwnd );
1553 char buffer[256];
1554 HPEN hPrevPen;
1555 HMENU hSysMenu;
1556
1557 if (wndPtr->flags & WIN_MANAGED)
1558 {
1559 WIN_ReleaseWndPtr(wndPtr);
1560 return;
1561 }
1562 WIN_ReleaseWndPtr(wndPtr);
1563
1564 hPrevPen = SelectObject( hdc, GetSysColorPen(COLOR_3DFACE) );
1565 MoveToEx( hdc, r.left, r.bottom - 1, NULL );
1566 LineTo( hdc, r.right, r.bottom - 1 );
1567 SelectObject( hdc, hPrevPen );
1568 r.bottom--;
1569
1570 FillRect( hdc, &r, GetSysColorBrush(active ? COLOR_ACTIVECAPTION :
1571 COLOR_INACTIVECAPTION) );
1572
1573 if (!hbitmapClose) {
1574 if (!(hbitmapClose = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_CLOSE) )))
1575 return;
1576 hbitmapCloseD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_CLOSED));
1577 hbitmapMinimize = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_REDUCE) );
1578 hbitmapMinimizeD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_REDUCED) );
1579 hbitmapMaximize = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_ZOOM) );
1580 hbitmapMaximizeD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_ZOOMD) );
1581 hbitmapRestore = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_RESTORE) );
1582 hbitmapRestoreD = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_RESTORED) );
1583 }
1584
1585 if ((style & WS_SYSMENU) && !(exStyle & WS_EX_TOOLWINDOW)) {
1586 if (NC_DrawSysButton95 (hwnd, hdc, FALSE))
1587 r.left += GetSystemMetrics(SM_CYCAPTION) - 1;
1588 }
1589
1590 if (style & WS_SYSMENU)
1591 {
1592 UINT state;
1593
1594 /* Go get the sysmenu */
1595 hSysMenu = GetSystemMenu(hwnd, FALSE);
1596 state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
1597
1598 /* Draw a grayed close button if disabled and a normal one if SC_CLOSE is not there */
1599 NC_DrawCloseButton95 (hwnd, hdc, FALSE,
1600 ((((state & MF_DISABLED) || (state & MF_GRAYED))) && (state != 0xFFFFFFFF)));
1601 r.right -= GetSystemMetrics(SM_CYCAPTION) - 1;
1602
1603 if ((style & WS_MAXIMIZEBOX) || (style & WS_MINIMIZEBOX))
1604 {
1605 /* In win95 the two buttons are always there */
1606 /* But if the menu item is not in the menu they're disabled*/
1607
1608 NC_DrawMaxButton95( hwnd, hdc, FALSE, (!(style & WS_MAXIMIZEBOX)));
1609 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1610
1611 NC_DrawMinButton95( hwnd, hdc, FALSE, (!(style & WS_MINIMIZEBOX)));
1612 r.right -= GetSystemMetrics(SM_CXSIZE) + 1;
1613 }
1614 }
1615
1616 if (GetWindowTextA( hwnd, buffer, sizeof(buffer) )) {
1617 NONCLIENTMETRICSA nclm;
1618 HFONT hFont, hOldFont;
1619 nclm.cbSize = sizeof(NONCLIENTMETRICSA);
1620 SystemParametersInfoA (SPI_GETNONCLIENTMETRICS, 0, &nclm, 0);
1621 if (exStyle & WS_EX_TOOLWINDOW)
1622 hFont = CreateFontIndirectA (&nclm.lfSmCaptionFont);
1623 else
1624 hFont = CreateFontIndirectA (&nclm.lfCaptionFont);
1625 hOldFont = SelectObject (hdc, hFont);
1626 if (active) SetTextColor( hdc, GetSysColor( COLOR_CAPTIONTEXT ) );
1627 else SetTextColor( hdc, GetSysColor( COLOR_INACTIVECAPTIONTEXT ) );
1628 SetBkMode( hdc, TRANSPARENT );
1629 r.left += 2;
1630 DrawTextA( hdc, buffer, -1, &r,
1631 DT_SINGLELINE | DT_VCENTER | DT_NOPREFIX | DT_LEFT );
1632 DeleteObject (SelectObject (hdc, hOldFont));
1633 }
1634 }
1635
1636
1637
1638 /***********************************************************************
1639 * NC_DoNCPaint
1640 *
1641 * Paint the non-client area. clip is currently unused.
1642 */
1643 static void NC_DoNCPaint( WND* wndPtr, HRGN clip, BOOL suppress_menupaint )
1644 {
1645 HDC hdc;
1646 RECT rect;
1647 BOOL active;
1648 HWND hwnd = wndPtr->hwndSelf;
1649
1650 if ( wndPtr->dwStyle & WS_MINIMIZE ||
1651 !WIN_IsWindowDrawable( wndPtr, 0 )) return; /* Nothing to do */
1652
1653 active = wndPtr->flags & WIN_NCACTIVATED;
1654
1655 TRACE("%04x %d\n", hwnd, active );
1656
1657 if (!(hdc = GetDCEx( hwnd, (clip > 1) ? clip : 0, DCX_USESTYLE | DCX_WINDOW |
1658 ((clip > 1) ? (DCX_INTERSECTRGN | DCX_KEEPCLIPRGN): 0) ))) return;
1659
1660 if (ExcludeVisRect16( hdc, wndPtr->rectClient.left-wndPtr->rectWindow.left,
1661 wndPtr->rectClient.top-wndPtr->rectWindow.top,
1662 wndPtr->rectClient.right-wndPtr->rectWindow.left,
1663 wndPtr->rectClient.bottom-wndPtr->rectWindow.top )
1664 == NULLREGION)
1665 {
1666 ReleaseDC( hwnd, hdc );
1667 return;
1668 }
1669
1670 rect.top = rect.left = 0;
1671 rect.right = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
1672 rect.bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
1673
1674 SelectObject( hdc, GetSysColorPen(COLOR_WINDOWFRAME) );
1675
1676 if (!(wndPtr->flags & WIN_MANAGED))
1677 {
1678 if (HAS_ANYFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
1679 {
1680 SelectObject( hdc, GetStockObject(NULL_BRUSH) );
1681 Rectangle( hdc, 0, 0, rect.right, rect.bottom );
1682 InflateRect( &rect, -1, -1 );
1683 }
1684
1685 if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
1686 NC_DrawFrame(hdc, &rect, FALSE, active );
1687 else if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
1688 NC_DrawFrame( hdc, &rect, TRUE, active );
1689
1690 if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
1691 {
1692 RECT r = rect;
1693 r.bottom = rect.top + GetSystemMetrics(SM_CYSIZE);
1694 rect.top += GetSystemMetrics(SM_CYSIZE) + GetSystemMetrics(SM_CYBORDER);
1695 NC_DrawCaption( hdc, &r, hwnd, wndPtr->dwStyle, active );
1696 }
1697 }
1698
1699 if (HAS_MENU(wndPtr))
1700 {
1701 RECT r = rect;
1702 r.bottom = rect.top + GetSystemMetrics(SM_CYMENU); /* default height */
1703 rect.top += MENU_DrawMenuBar( hdc, &r, hwnd, suppress_menupaint );
1704 }
1705
1706 /* Draw the scroll-bars */
1707
1708 if (wndPtr->dwStyle & WS_VSCROLL)
1709 SCROLL_DrawScrollBar( hwnd, hdc, SB_VERT, TRUE, TRUE );
1710 if (wndPtr->dwStyle & WS_HSCROLL)
1711 SCROLL_DrawScrollBar( hwnd, hdc, SB_HORZ, TRUE, TRUE );
1712
1713 /* Draw the "size-box" */
1714
1715 if ((wndPtr->dwStyle & WS_VSCROLL) && (wndPtr->dwStyle & WS_HSCROLL))
1716 {
1717 RECT r = rect;
1718 r.left = r.right - GetSystemMetrics(SM_CXVSCROLL) + 1;
1719 r.top = r.bottom - GetSystemMetrics(SM_CYHSCROLL) + 1;
1720 if(wndPtr->dwStyle & WS_BORDER) {
1721 r.left++;
1722 r.top++;
1723 }
1724 FillRect( hdc, &r, GetSysColorBrush(COLOR_SCROLLBAR) );
1725 }
1726
1727 ReleaseDC( hwnd, hdc );
1728 }
1729
1730
1731 /******************************************************************************
1732 *
1733 * void NC_DoNCPaint95(
1734 * WND *wndPtr,
1735 * HRGN32 clip,
1736 * BOOL32 suppress_menupaint )
1737 *
1738 * Paint the non-client area for Win95 windows. The clip region is
1739 * currently ignored.
1740 *
1741 * Bugs
1742 * grep -E -A10 -B5 \(95\)\|\(Bugs\)\|\(FIXME\) windows/nonclient.c \
1743 * misc/tweak.c controls/menu.c # :-)
1744 *
1745 * Revision history
1746 * 03-Jul-1997 Dave Cuthbert (dacut@ece.cmu.edu)
1747 * Original implementation
1748 * 10-Jun-1998 Eric Kohl (ekohl@abo.rhein-zeitung.de)
1749 * Fixed some bugs.
1750 * 29-Jun-1999 Ove Kåven (ovek@arcticnet.no)
1751 * Streamlined window style checks.
1752 *
1753 *****************************************************************************/
1754
1755 static void NC_DoNCPaint95(
1756 WND *wndPtr,
1757 HRGN clip,
1758 BOOL suppress_menupaint )
1759 {
1760 HDC hdc;
1761 RECT rfuzz, rect, rectClip;
1762 BOOL active;
1763 HWND hwnd = wndPtr->hwndSelf;
1764
1765 if ( wndPtr->dwStyle & WS_MINIMIZE ||
1766 !WIN_IsWindowDrawable( wndPtr, 0 )) return; /* Nothing to do */
1767
1768 active = wndPtr->flags & WIN_NCACTIVATED;
1769
1770 TRACE("%04x %d\n", hwnd, active );
1771
1772 /* MSDN docs are pretty idiotic here, they say app CAN use clipRgn in
1773 the call to GetDCEx implying that it is allowed not to use it either.
1774 However, the suggested GetDCEx( , DCX_WINDOW | DCX_INTERSECTRGN)
1775 will cause clipRgn to be deleted after ReleaseDC().
1776 Now, how is the "system" supposed to tell what happened?
1777 */
1778
1779 if (!(hdc = GetDCEx( hwnd, (clip > 1) ? clip : 0, DCX_USESTYLE | DCX_WINDOW |
1780 ((clip > 1) ?(DCX_INTERSECTRGN | DCX_KEEPCLIPRGN) : 0) ))) return;
1781
1782
1783 if (ExcludeVisRect16( hdc, wndPtr->rectClient.left-wndPtr->rectWindow.left,
1784 wndPtr->rectClient.top-wndPtr->rectWindow.top,
1785 wndPtr->rectClient.right-wndPtr->rectWindow.left,
1786 wndPtr->rectClient.bottom-wndPtr->rectWindow.top )
1787 == NULLREGION)
1788 {
1789 ReleaseDC( hwnd, hdc );
1790 return;
1791 }
1792
1793 rect.top = rect.left = 0;
1794 rect.right = wndPtr->rectWindow.right - wndPtr->rectWindow.left;
1795 rect.bottom = wndPtr->rectWindow.bottom - wndPtr->rectWindow.top;
1796
1797 if( clip > 1 )
1798 GetRgnBox( clip, &rectClip );
1799 else
1800 {
1801 clip = 0;
1802 rectClip = rect;
1803 }
1804
1805 SelectObject( hdc, GetSysColorPen(COLOR_WINDOWFRAME) );
1806
1807 if(!(wndPtr->flags & WIN_MANAGED)) {
1808 if (HAS_BIGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle)) {
1809 DrawEdge (hdc, &rect, EDGE_RAISED, BF_RECT | BF_ADJUST);
1810 }
1811 if (HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
1812 NC_DrawFrame95(hdc, &rect, FALSE, active );
1813 else if (HAS_DLGFRAME( wndPtr->dwStyle, wndPtr->dwExStyle ))
1814 NC_DrawFrame95( hdc, &rect, TRUE, active );
1815 else if (HAS_THINFRAME( wndPtr->dwStyle )) {
1816 SelectObject( hdc, GetStockObject(NULL_BRUSH) );
1817 Rectangle( hdc, 0, 0, rect.right, rect.bottom );
1818 }
1819
1820 if ((wndPtr->dwStyle & WS_CAPTION) == WS_CAPTION)
1821 {
1822 RECT r = rect;
1823 if (wndPtr->dwExStyle & WS_EX_TOOLWINDOW) {
1824 r.bottom = rect.top + GetSystemMetrics(SM_CYSMCAPTION);
1825 rect.top += GetSystemMetrics(SM_CYSMCAPTION);
1826 }
1827 else {
1828 r.bottom = rect.top + GetSystemMetrics(SM_CYCAPTION);
1829 rect.top += GetSystemMetrics(SM_CYCAPTION);
1830 }
1831 if( !clip || IntersectRect( &rfuzz, &r, &rectClip ) )
1832 NC_DrawCaption95 (hdc, &r, hwnd, wndPtr->dwStyle,
1833 wndPtr->dwExStyle, active);
1834 }
1835 }
1836
1837 if (HAS_MENU(wndPtr))
1838 {
1839 RECT r = rect;
1840 r.bottom = rect.top + GetSystemMetrics(SM_CYMENU);
1841
1842 TRACE("Calling DrawMenuBar with rect (%d, %d)-(%d, %d)\n",
1843 r.left, r.top, r.right, r.bottom);
1844
1845 rect.top += MENU_DrawMenuBar( hdc, &r, hwnd, suppress_menupaint ) + 1;
1846 }
1847
1848 TRACE("After MenuBar, rect is (%d, %d)-(%d, %d).\n",
1849 rect.left, rect.top, rect.right, rect.bottom );
1850
1851 if (wndPtr->dwExStyle & WS_EX_CLIENTEDGE)
1852 DrawEdge (hdc, &rect, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
1853
1854 if (wndPtr->dwExStyle & WS_EX_STATICEDGE)
1855 DrawEdge (hdc, &rect, BDR_SUNKENOUTER, BF_RECT | BF_ADJUST);
1856
1857 /* Draw the scroll-bars */
1858
1859 if (wndPtr->dwStyle & WS_VSCROLL)
1860 SCROLL_DrawScrollBar( hwnd, hdc, SB_VERT, TRUE, TRUE );
1861 if (wndPtr->dwStyle & WS_HSCROLL)
1862 SCROLL_DrawScrollBar( hwnd, hdc, SB_HORZ, TRUE, TRUE );
1863
1864 /* Draw the "size-box" */
1865 if ((wndPtr->dwStyle & WS_VSCROLL) && (wndPtr->dwStyle & WS_HSCROLL))
1866 {
1867 RECT r = rect;
1868 r.left = r.right - GetSystemMetrics(SM_CXVSCROLL) + 1;
1869 r.top = r.bottom - GetSystemMetrics(SM_CYHSCROLL) + 1;
1870 FillRect( hdc, &r, GetSysColorBrush(COLOR_SCROLLBAR) );
1871 }
1872
1873 ReleaseDC( hwnd, hdc );
1874 }
1875
1876
1877
1878
1879 /***********************************************************************
1880 * NC_HandleNCPaint
1881 *
1882 * Handle a WM_NCPAINT message. Called from DefWindowProc().
1883 */
1884 LONG NC_HandleNCPaint( HWND hwnd , HRGN clip)
1885 {
1886 WND* wndPtr = WIN_FindWndPtr( hwnd );
1887
1888 if( wndPtr && wndPtr->dwStyle & WS_VISIBLE )
1889 {
1890 if( wndPtr->dwStyle & WS_MINIMIZE )
1891 WINPOS_RedrawIconTitle( hwnd );
1892 else if (TWEAK_WineLook == WIN31_LOOK)
1893 NC_DoNCPaint( wndPtr, clip, FALSE );
1894 else
1895 NC_DoNCPaint95( wndPtr, clip, FALSE );
1896 }
1897 WIN_ReleaseWndPtr(wndPtr);
1898 return 0;
1899 }
1900
1901
1902 /***********************************************************************
1903 * NC_HandleNCActivate
1904 *
1905 * Handle a WM_NCACTIVATE message. Called from DefWindowProc().
1906 */
1907 LONG NC_HandleNCActivate( WND *wndPtr, WPARAM16 wParam )
1908 {
1909 WORD wStateChange;
1910
1911 if( wParam ) wStateChange = !(wndPtr->flags & WIN_NCACTIVATED);
1912 else wStateChange = wndPtr->flags & WIN_NCACTIVATED;
1913
1914 if( wStateChange )
1915 {
1916 if (wParam) wndPtr->flags |= WIN_NCACTIVATED;
1917 else wndPtr->flags &= ~WIN_NCACTIVATED;
1918
1919 if( wndPtr->dwStyle & WS_MINIMIZE )
1920 WINPOS_RedrawIconTitle( wndPtr->hwndSelf );
1921 else if (TWEAK_WineLook == WIN31_LOOK)
1922 NC_DoNCPaint( wndPtr, (HRGN)1, FALSE );
1923 else
1924 NC_DoNCPaint95( wndPtr, (HRGN)1, FALSE );
1925 }
1926 return TRUE;
1927 }
1928
1929
1930 /***********************************************************************
1931 * NC_HandleSetCursor
1932 *
1933 * Handle a WM_SETCURSOR message. Called from DefWindowProc().
1934 */
1935 LONG NC_HandleSetCursor( HWND hwnd, WPARAM16 wParam, LPARAM lParam )
1936 {
1937 if (hwnd != (HWND)wParam) return 0; /* Don't set the cursor for child windows */
1938
1939 switch(LOWORD(lParam))
1940 {
1941 case HTERROR:
1942 {
1943 WORD msg = HIWORD( lParam );
1944 if ((msg == WM_LBUTTONDOWN) || (msg == WM_MBUTTONDOWN) ||
1945 (msg == WM_RBUTTONDOWN))
1946 MessageBeep(0);
1947 }
1948 break;
1949
1950 case HTCLIENT:
1951 {
1952 HICON16 hCursor = (HICON16) GetClassWord(hwnd, GCW_HCURSOR);
1953 if(hCursor) {
1954 SetCursor16(hCursor);
1955 return TRUE;
1956 }
1957 return FALSE;
1958 }
1959
1960 case HTLEFT:
1961 case HTRIGHT:
1962 return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZEWE16 ) );
1963
1964 case HTTOP:
1965 case HTBOTTOM:
1966 return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZENS16 ) );
1967
1968 case HTTOPLEFT:
1969 case HTBOTTOMRIGHT:
1970 return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZENWSE16 ) );
1971
1972 case HTTOPRIGHT:
1973 case HTBOTTOMLEFT:
1974 return (LONG)SetCursor16( LoadCursor16( 0, IDC_SIZENESW16 ) );
1975 }
1976
1977 /* Default cursor: arrow */
1978 return (LONG)SetCursor16( LoadCursor16( 0, IDC_ARROW16 ) );
1979 }
1980
1981 /***********************************************************************
1982 * NC_GetSysPopupPos
1983 */
1984 BOOL NC_GetSysPopupPos( WND* wndPtr, RECT* rect )
1985 {
1986 if( wndPtr->hSysMenu )
1987 {
1988 if( wndPtr->dwStyle & WS_MINIMIZE )
1989 GetWindowRect( wndPtr->hwndSelf, rect );
1990 else
1991 {
1992 if (TWEAK_WineLook == WIN31_LOOK)
1993 NC_GetInsideRect( wndPtr->hwndSelf, rect );
1994 else
1995 NC_GetInsideRect95( wndPtr->hwndSelf, rect );
1996 OffsetRect( rect, wndPtr->rectWindow.left, wndPtr->rectWindow.top);
1997 if (wndPtr->dwStyle & WS_CHILD)
1998 ClientToScreen( wndPtr->parent->hwndSelf, (POINT *)rect );
1999 if (TWEAK_WineLook == WIN31_LOOK) {
2000 rect->right = rect->left + GetSystemMetrics(SM_CXSIZE);
2001 rect->bottom = rect->top + GetSystemMetrics(SM_CYSIZE);
2002 }
2003 else {
2004 rect->right = rect->left + GetSystemMetrics(SM_CYCAPTION) - 1;
2005 rect->bottom = rect->top + GetSystemMetrics(SM_CYCAPTION) - 1;
2006 }
2007 }
2008 return TRUE;
2009 }
2010 return FALSE;
2011 }
2012
2013 /***********************************************************************
2014 * NC_StartSizeMove
2015 *
2016 * Initialisation of a move or resize, when initiatied from a menu choice.
2017 * Return hit test code for caption or sizing border.
2018 */
2019 static LONG NC_StartSizeMove( WND* wndPtr, WPARAM16 wParam,
2020 POINT16 *capturePoint )
2021 {
2022 LONG hittest = 0;
2023 POINT16 pt;
2024 MSG msg;
2025 RECT rectWindow;
2026
2027 GetWindowRect(wndPtr->hwndSelf,&rectWindow);
2028
2029 if ((wParam & 0xfff0) == SC_MOVE)
2030 {
2031 /* Move pointer at the center of the caption */
2032 RECT rect;
2033 if (TWEAK_WineLook == WIN31_LOOK)
2034 NC_GetInsideRect( wndPtr->hwndSelf, &rect );
2035 else
2036 NC_GetInsideRect95( wndPtr->hwndSelf, &rect );
2037 if (wndPtr->dwStyle & WS_SYSMENU)
2038 rect.left += GetSystemMetrics(SM_CXSIZE) + 1;
2039 if (wndPtr->dwStyle & WS_MINIMIZEBOX)
2040 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
2041 if (wndPtr->dwStyle & WS_MAXIMIZEBOX)
2042 rect.right -= GetSystemMetrics(SM_CXSIZE) + 1;
2043 pt.x = rectWindow.left + (rect.right - rect.left) / 2;
2044 pt.y = rectWindow.top + rect.top + GetSystemMetrics(SM_CYSIZE)/2;
2045 hittest = HTCAPTION;
2046 *capturePoint = pt;
2047 }
2048 else /* SC_SIZE */
2049 {
2050 while(!hittest)
2051 {
2052 MSG_InternalGetMessage( QMSG_WIN32A, &msg, 0, 0, MSGF_SIZE, PM_REMOVE, FALSE, NULL );
2053 switch(msg.message)
2054 {
2055 case WM_MOUSEMOVE:
2056 CONV_POINT32TO16(&msg.pt, &pt);
2057 hittest = NC_HandleNCHitTest( wndPtr->hwndSelf, pt );
2058 if ((hittest < HTLEFT) || (hittest > HTBOTTOMRIGHT))
2059 hittest = 0;
2060 break;
2061
2062 case WM_LBUTTONUP:
2063 return 0;
2064
2065 case WM_KEYDOWN:
2066 switch(msg.wParam)
2067 {
2068 case VK_UP:
2069 hittest = HTTOP;
2070 pt.x =(rectWindow.left+rectWindow.right)/2;
2071 pt.y = rectWindow.top + GetSystemMetrics(SM_CYFRAME) / 2;
2072 break;
2073 case VK_DOWN:
2074 hittest = HTBOTTOM;
2075 pt.x =(rectWindow.left+rectWindow.right)/2;
2076 pt.y = rectWindow.bottom - GetSystemMetrics(SM_CYFRAME) / 2;
2077 break;
2078 case VK_LEFT:
2079 hittest = HTLEFT;
2080 pt.x = rectWindow.left + GetSystemMetrics(SM_CXFRAME) / 2;
2081 pt.y =(rectWindow.top+rectWindow.bottom)/2;
2082 break;
2083 case VK_RIGHT:
2084 hittest = HTRIGHT;
2085 pt.x = rectWindow.right - GetSystemMetrics(SM_CXFRAME) / 2;
2086 pt.y =(rectWindow.top+rectWindow.bottom)/2;
2087 break;
2088 case VK_RETURN:
2089 case VK_ESCAPE: return 0;
2090 }
2091 }
2092 }
2093 *capturePoint = pt;
2094 }
2095 SetCursorPos( pt.x, pt.y );
2096 NC_HandleSetCursor( wndPtr->hwndSelf,
2097 wndPtr->hwndSelf, MAKELONG( hittest, WM_MOUSEMOVE ));
2098 return hittest;
2099 }
2100
2101
2102 /***********************************************************************
2103 * NC_DoSizeMove
2104 *
2105 * Perform SC_MOVE and SC_SIZE commands. `
2106 */
2107 static void NC_DoSizeMove( HWND hwnd, WORD wParam )
2108 {
2109 MSG msg;
2110 RECT sizingRect, mouseRect;
2111 HDC hdc;
2112 LONG hittest = (LONG)(wParam & 0x0f);
2113 HCURSOR16 hDragCursor = 0, hOldCursor = 0;
2114 POINT minTrack, maxTrack;
2115 POINT16 capturePoint, pt;
2116 WND * wndPtr = WIN_FindWndPtr( hwnd );
2117 BOOL thickframe = HAS_THICKFRAME( wndPtr->dwStyle, wndPtr->dwExStyle );
2118 BOOL iconic = wndPtr->dwStyle & WS_MINIMIZE;
2119 BOOL moved = FALSE;
2120 DWORD dwPoint = GetMessagePos ();
2121
2122 capturePoint = pt = *(POINT16*)&dwPoint;
2123
2124 if (IsZoomed(hwnd) || !IsWindowVisible(hwnd) ||
2125 (wndPtr->flags & WIN_MANAGED)) goto END;
2126
2127 if ((wParam & 0xfff0) == SC_MOVE)
2128 {
2129 if (!(wndPtr->dwStyle & WS_CAPTION)) goto END;
2130 if (!hittest)
2131 hittest = NC_StartSizeMove( wndPtr, wParam, &capturePoint );
2132 if (!hittest) goto END;
2133 }
2134 else /* SC_SIZE */
2135 {
2136 if (!thickframe) goto END;
2137 if ( hittest && hittest != HTSYSMENU ) hittest += 2;
2138 else
2139 {
2140 SetCapture(hwnd);
2141 hittest = NC_StartSizeMove( wndPtr, wParam, &capturePoint );
2142 if (!hittest)
2143 {
2144 ReleaseCapture();
2145 goto END;
2146 }
2147 }
2148 }
2149
2150 /* Get min/max info */
2151
2152 WINPOS_GetMinMaxInfo( wndPtr, NULL, NULL, &minTrack, &maxTrack );
2153 sizingRect = wndPtr->rectWindow;
2154 if (wndPtr->dwStyle & WS_CHILD)
2155 GetClientRect( wndPtr->parent->hwndSelf, &mouseRect );
2156 else
2157 SetRect(&mouseRect, 0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
2158 if (ON_LEFT_BORDER(hittest))
2159 {
2160 mouseRect.left = max( mouseRect.left, sizingRect.right-maxTrack.x );
2161 mouseRect.right = min( mouseRect.right, sizingRect.right-minTrack.x );
2162 }
2163 else if (ON_RIGHT_BORDER(hittest))
2164 {
2165 mouseRect.left = max( mouseRect.left, sizingRect.left+minTrack.x );
2166 mouseRect.right = min( mouseRect.right, sizingRect.left+maxTrack.x );
2167 }
2168 if (ON_TOP_BORDER(hittest))
2169 {
2170 mouseRect.top = max( mouseRect.top, sizingRect.bottom-maxTrack.y );
2171 mouseRect.bottom = min( mouseRect.bottom,sizingRect.bottom-minTrack.y);
2172 }
2173 else if (ON_BOTTOM_BORDER(hittest))
2174 {
2175 mouseRect.top = max( mouseRect.top, sizingRect.top+minTrack.y );
2176 mouseRect.bottom = min( mouseRect.bottom, sizingRect.top+maxTrack.y );
2177 }
2178 if (wndPtr->dwStyle & WS_CHILD)
2179 {
2180 MapWindowPoints( wndPtr->parent->hwndSelf, 0,
2181 (LPPOINT)&mouseRect, 2 );
2182 }
2183 SendMessage16( hwnd, WM_ENTERSIZEMOVE, 0, 0 );
2184
2185 if (GetCapture() != hwnd) SetCapture( hwnd );
2186
2187 if (wndPtr->dwStyle & WS_CHILD)
2188 {
2189 /* Retrieve a default cache DC (without using the window style) */
2190 hdc = GetDCEx( wndPtr->parent->hwndSelf, 0, DCX_CACHE );
2191 }
2192 else
2193 { /* Grab the server only when moving top-level windows without desktop */
2194 hdc = GetDC( 0 );
2195 }
2196
2197 wndPtr->pDriver->pPreSizeMove(wndPtr);
2198
2199 if( iconic ) /* create a cursor for dragging */
2200 {
2201 HICON16 hIcon = GetClassWord(wndPtr->hwndSelf, GCW_HICON);
2202 if(!hIcon) hIcon = (HICON16) SendMessage16( hwnd, WM_QUERYDRAGICON, 0, 0L);
2203 if( hIcon ) hDragCursor = CURSORICON_IconToCursor( hIcon, TRUE );
2204 if( !hDragCursor ) iconic = FALSE;
2205 }
2206
2207 if( !iconic ) NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
2208
2209 while(1)
2210 {
2211 int dx = 0, dy = 0;
2212
2213 MSG_InternalGetMessage( QMSG_WIN32A, &msg, 0, 0, MSGF_SIZE, PM_REMOVE, FALSE, NULL );
2214
2215 /* Exit on button-up, Return, or Esc */
2216 if ((msg.message == WM_LBUTTONUP) ||
2217 ((msg.message == WM_KEYDOWN) &&
2218 ((msg.wParam == VK_RETURN) || (msg.wParam == VK_ESCAPE)))) break;
2219
2220 if ((msg.message != WM_KEYDOWN) && (msg.message != WM_MOUSEMOVE))
2221 continue; /* We are not interested in other messages */
2222
2223 dwPoint = GetMessagePos ();
2224 pt = *(POINT16*)&dwPoint;
2225
2226 if (msg.message == WM_KEYDOWN) switch(msg.wParam)
2227 {
2228 case VK_UP: pt.y -= 8; break;
2229 case VK_DOWN: pt.y += 8; break;
2230 case VK_LEFT: pt.x -= 8; break;
2231 case VK_RIGHT: pt.x += 8; break;
2232 }
2233
2234 pt.x = max( pt.x, mouseRect.left );
2235 pt.x = min( pt.x, mouseRect.right );
2236 pt.y = max( pt.y, mouseRect.top );
2237 pt.y = min( pt.y, mouseRect.bottom );
2238
2239 dx = pt.x - capturePoint.x;
2240 dy = pt.y - capturePoint.y;
2241
2242 if (dx || dy)
2243 {
2244 if( !moved )
2245 {
2246 moved = TRUE;
2247 if( iconic ) /* ok, no system popup tracking */
2248 {
2249 hOldCursor = SetCursor(hDragCursor);
2250 ShowCursor( TRUE );
2251 WINPOS_ShowIconTitle( wndPtr, FALSE );
2252 }
2253 }
2254
2255 if (msg.message == WM_KEYDOWN) SetCursorPos( pt.x, pt.y );
2256 else
2257 {
2258 RECT newRect = sizingRect;
2259
2260 if (hittest == HTCAPTION) OffsetRect( &newRect, dx, dy );
2261 if (ON_LEFT_BORDER(hittest)) newRect.left += dx;
2262 else if (ON_RIGHT_BORDER(hittest)) newRect.right += dx;
2263 if (ON_TOP_BORDER(hittest)) newRect.top += dy;
2264 else if (ON_BOTTOM_BORDER(hittest)) newRect.bottom += dy;
2265 if( !iconic )
2266 {
2267 NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
2268 NC_DrawMovingFrame( hdc, &newRect, thickframe );
2269 }
2270 capturePoint = pt;
2271 sizingRect = newRect;
2272 }
2273 }
2274 }
2275
2276 ReleaseCapture();
2277 if( iconic )
2278 {
2279 if( moved ) /* restore cursors, show icon title later on */
2280 {
2281 ShowCursor( FALSE );
2282 SetCursor( hOldCursor );
2283 }
2284 DestroyCursor( hDragCursor );
2285 }
2286 else
2287 NC_DrawMovingFrame( hdc, &sizingRect, thickframe );
2288
2289 if (wndPtr->dwStyle & WS_CHILD)
2290 ReleaseDC( wndPtr->parent->hwndSelf, hdc );
2291 else
2292 {
2293 ReleaseDC( 0, hdc );
2294 }
2295
2296 wndPtr->pDriver->pPostSizeMove(wndPtr);
2297
2298 if (HOOK_IsHooked( WH_CBT ))
2299 {
2300 RECT16* pr = SEGPTR_NEW(RECT16);
2301 if( pr )
2302 {
2303 CONV_RECT32TO16( &sizingRect, pr );
2304 if( HOOK_CallHooks16( WH_CBT, HCBT_MOVESIZE, hwnd,
2305 (LPARAM)SEGPTR_GET(pr)) )
2306 sizingRect = wndPtr->rectWindow;
2307 else
2308 CONV_RECT16TO32( pr, &sizingRect );
2309 SEGPTR_FREE(pr);
2310 }
2311 }
2312 SendMessage16( hwnd, WM_EXITSIZEMOVE, 0, 0 );
2313 SendMessage16( hwnd, WM_SETVISIBLE, !IsIconic16(hwnd), 0L);
2314
2315 /* window moved or resized */
2316 if (moved)
2317 {
2318 /* if the moving/resizing isn't canceled call SetWindowPos
2319 * with the new position or the new size of the window
2320 */
2321 if (!((msg.message == WM_KEYDOWN) && (msg.wParam == VK_ESCAPE)) )
2322 {
2323 /* NOTE: SWP_NOACTIVATE prevents document window activation in Word 6 */
2324 SetWindowPos( hwnd, 0, sizingRect.left, sizingRect.top,
2325 sizingRect.right - sizingRect.left,
2326 sizingRect.bottom - sizingRect.top,
2327 ( hittest == HTCAPTION ) ? SWP_NOSIZE : 0 );
2328 }
2329 }
2330
2331 if( IsWindow(hwnd) )
2332 if( wndPtr->dwStyle & WS_MINIMIZE )
2333 {
2334 /* Single click brings up the system menu when iconized */
2335
2336 if( !moved )
2337 {
2338 if( wndPtr->dwStyle & WS_SYSMENU )
2339 SendMessage16( hwnd, WM_SYSCOMMAND,
2340 SC_MOUSEMENU + HTSYSMENU, *((LPARAM*)&pt));
2341 }
2342 else WINPOS_ShowIconTitle( wndPtr, TRUE );
2343 }
2344
2345 END:
2346 WIN_ReleaseWndPtr(wndPtr);
2347 }
2348
2349
2350 /***********************************************************************
2351 * NC_TrackMinMaxBox95
2352 *
2353 * Track a mouse button press on the minimize or maximize box.
2354 *
2355 * The big difference between 3.1 and 95 is the disabled button state.
2356 * In win95 the system button can be disabled, so it can ignore the mouse
2357 * event.
2358 *
2359 */
2360 static void NC_TrackMinMaxBox95( HWND hwnd, WORD wParam )
2361 {
2362 MSG msg;
2363 POINT16 pt16;
2364 HDC hdc = GetWindowDC( hwnd );
2365 BOOL pressed = TRUE;
2366 UINT state;
2367 DWORD wndStyle = GetWindowLongA( hwnd, GWL_STYLE);
2368 HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
2369
2370 void (*paintButton)(HWND, HDC16, BOOL, BOOL);
2371
2372 if (wParam == HTMINBUTTON)
2373 {
2374 /* If the style is not present, do nothing */
2375 if (!(wndStyle & WS_MINIMIZEBOX))
2376 return;
2377
2378 /* Check if the sysmenu item for minimize is there */
2379 state = GetMenuState(hSysMenu, SC_MINIMIZE, MF_BYCOMMAND);
2380
2381 paintButton = &NC_DrawMinButton95;
2382 }
2383 else
2384 {
2385 /* If the style is not present, do nothing */
2386 if (!(wndStyle & WS_MAXIMIZEBOX))
2387 return;
2388
2389 /* Check if the sysmenu item for maximize is there */
2390 state = GetMenuState(hSysMenu, SC_MAXIMIZE, MF_BYCOMMAND);
2391
2392 paintButton = &NC_DrawMaxButton95;
2393 }
2394
2395 SetCapture( hwnd );
2396
2397 (*paintButton)( hwnd, hdc, TRUE, FALSE);
2398
2399 do
2400 {
2401 BOOL oldstate = pressed;
2402 MSG_InternalGetMessage( QMSG_WIN32A, &msg, 0, 0, 0, PM_REMOVE, FALSE, NULL );
2403 CONV_POINT32TO16( &msg.pt, &pt16 );
2404
2405 pressed = (NC_HandleNCHitTest( hwnd, pt16 ) == wParam);
2406 if (pressed != oldstate)
2407 (*paintButton)( hwnd, hdc, pressed, FALSE);
2408 } while (msg.message != WM_LBUTTONUP);
2409
2410 (*paintButton)( hwnd, hdc, FALSE, FALSE);
2411
2412 ReleaseCapture();
2413 ReleaseDC( hwnd, hdc );
2414
2415 /* If the item minimize or maximize of the sysmenu are not there */
2416 /* or if the style is not present, do nothing */
2417 if ((!pressed) || (state == 0xFFFFFFFF))
2418 return;
2419
2420 if (wParam == HTMINBUTTON)
2421 SendMessage16( hwnd, WM_SYSCOMMAND, SC_MINIMIZE, *(LONG*)&pt16 );
2422 else
2423 SendMessage16( hwnd, WM_SYSCOMMAND,
2424 IsZoomed(hwnd) ? SC_RESTORE:SC_MAXIMIZE, *(LONG*)&pt16 );
2425 }
2426
2427 /***********************************************************************
2428 * NC_TrackMinMaxBox
2429 *
2430 * Track a mouse button press on the minimize or maximize box.
2431 */
2432 static void NC_TrackMinMaxBox( HWND hwnd, WORD wParam )
2433 {
2434 MSG msg;
2435 POINT16 pt16;
2436 HDC hdc = GetWindowDC( hwnd );
2437 BOOL pressed = TRUE;
2438 void (*paintButton)(HWND, HDC16, BOOL);
2439
2440 SetCapture( hwnd );
2441
2442 if (wParam == HTMINBUTTON)
2443 paintButton = &NC_DrawMinButton;
2444 else
2445 paintButton = &NC_DrawMaxButton;
2446
2447 (*paintButton)( hwnd, hdc, TRUE);
2448
2449 do
2450 {
2451 BOOL oldstate = pressed;
2452 MSG_InternalGetMessage( QMSG_WIN32A, &msg, 0, 0, 0, PM_REMOVE, FALSE, NULL );
2453 CONV_POINT32TO16( &msg.pt, &pt16 );
2454
2455 pressed = (NC_HandleNCHitTest( hwnd, pt16 ) == wParam);
2456 if (pressed != oldstate)
2457 (*paintButton)( hwnd, hdc, pressed);
2458 } while (msg.message != WM_LBUTTONUP);
2459
2460 (*paintButton)( hwnd, hdc, FALSE);
2461
2462 ReleaseCapture();
2463 ReleaseDC( hwnd, hdc );
2464
2465 if (!pressed) return;
2466
2467 if (wParam == HTMINBUTTON)
2468 SendMessage16( hwnd, WM_SYSCOMMAND, SC_MINIMIZE, *(LONG*)&pt16 );
2469 else
2470 SendMessage16( hwnd, WM_SYSCOMMAND,
2471 IsZoomed(hwnd) ? SC_RESTORE:SC_MAXIMIZE, *(LONG*)&pt16 );
2472 }
2473
2474
2475 /***********************************************************************
2476 * NC_TrackCloseButton95
2477 *
2478 * Track a mouse button press on the Win95 close button.
2479 */
2480 static void
2481 NC_TrackCloseButton95 (HWND hwnd, WORD wParam)
2482 {
2483 MSG msg;
2484 POINT16 pt16;
2485 HDC hdc;
2486 BOOL pressed = TRUE;
2487 HMENU hSysMenu = GetSystemMenu(hwnd, FALSE);
2488 UINT state;
2489
2490 if(hSysMenu == 0)
2491 return;
2492
2493 state = GetMenuState(hSysMenu, SC_CLOSE, MF_BYCOMMAND);
2494
2495 /* If the item close of the sysmenu is disabled or not there do nothing */
2496 if((state & MF_DISABLED) || (state & MF_GRAYED) || (state == 0xFFFFFFFF))
2497 return;
2498
2499 hdc = GetWindowDC( hwnd );
2500
2501 SetCapture( hwnd );
2502
2503 NC_DrawCloseButton95 (hwnd, hdc, TRUE, FALSE);
2504
2505 do
2506 {
2507 BOOL oldstate = pressed;
2508 MSG_InternalGetMessage( QMSG_WIN32A, &msg, 0, 0, 0, PM_REMOVE, FALSE, NULL );
2509 CONV_POINT32TO16( &msg.pt, &pt16 );
2510
2511 pressed = (NC_HandleNCHitTest( hwnd, pt16 ) == wParam);
2512 if (pressed != oldstate)
2513 NC_DrawCloseButton95 (hwnd, hdc, pressed, FALSE);
2514 } while (msg.message != WM_LBUTTONUP);
2515
2516 NC_DrawCloseButton95 (hwnd, hdc, FALSE, FALSE);
2517
2518 ReleaseCapture();
2519 ReleaseDC( hwnd, hdc );
2520 if (!pressed) return;
2521
2522 SendMessage16( hwnd, WM_SYSCOMMAND, SC_CLOSE, *(LONG*)&pt16 );
2523 }
2524
2525
2526 /***********************************************************************
2527 * NC_TrackScrollBar
2528 *
2529 * Track a mouse button press on the horizontal or vertical scroll-bar.
2530 */
2531 static void NC_TrackScrollBar( HWND hwnd, WPARAM wParam, POINT pt )
2532 {
2533 MSG16 *msg;
2534 INT scrollbar;
2535 WND *wndPtr = WIN_FindWndPtr( hwnd );
2536
2537 if ((wParam & 0xfff0) == SC_HSCROLL)
2538 {
2539 if ((wParam & 0x0f) != HTHSCROLL) goto END;
2540 scrollbar = SB_HORZ;
2541 }
2542 else /* SC_VSCROLL */
2543 {
2544 if ((wParam & 0x0f) != HTVSCROLL) goto END;
2545 scrollbar = SB_VERT;
2546 }
2547
2548 if (!(msg = SEGPTR_NEW(MSG16))) goto END;
2549 pt.x -= wndPtr->rectWindow.left;
2550 pt.y -= wndPtr->rectWindow.top;
2551 SetCapture( hwnd );
2552 SCROLL_HandleScrollEvent( hwnd, scrollbar, WM_LBUTTONDOWN, pt );
2553
2554 do
2555 {
2556 GetMessage16( SEGPTR_GET(msg), 0, 0, 0 );
2557 switch(msg->message)
2558 {
2559 case WM_LBUTTONUP:
2560 case WM_MOUSEMOVE:
2561 case WM_SYSTIMER:
2562 pt.x = LOWORD(msg->lParam) + wndPtr->rectClient.left -
2563 wndPtr->rectWindow.left;
2564 pt.y = HIWORD(msg->lParam) + wndPtr->rectClient.top -
2565 wndPtr->rectWindow.top;
2566 SCROLL_HandleScrollEvent( hwnd, scrollbar, msg->message, pt );
2567 break;
2568 default:
2569 TranslateMessage16( msg );
2570 DispatchMessage16( msg );
2571 break;
2572 }
2573 if (!IsWindow( hwnd ))
2574 {
2575 ReleaseCapture();
2576 break;
2577 }
2578 } while (msg->message != WM_LBUTTONUP);
2579 SEGPTR_FREE(msg);
2580 END:
2581 WIN_ReleaseWndPtr(wndPtr);
2582 }
2583
2584 /***********************************************************************
2585 * NC_HandleNCLButtonDown
2586 *
2587 * Handle a WM_NCLBUTTONDOWN message. Called from DefWindowProc().
2588 */
2589 LONG NC_HandleNCLButtonDown( WND* pWnd, WPARAM16 wParam, LPARAM lParam )
2590 {
2591 HWND hwnd = pWnd->hwndSelf;
2592
2593 switch(wParam) /* Hit test */
2594 {
2595 case HTCAPTION:
2596 hwnd = WIN_GetTopParent(hwnd);
2597
2598 if( WINPOS_SetActiveWindow(hwnd, TRUE, TRUE) || (GetActiveWindow() == hwnd) )
2599 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_MOVE + HTCAPTION, lParam );
2600 break;
2601
2602 case HTSYSMENU:
2603 if( pWnd->dwStyle & WS_SYSMENU )
2604 {
2605 if( !(pWnd->dwStyle & WS_MINIMIZE) )
2606 {
2607 HDC hDC = GetWindowDC(hwnd);
2608 if (TWEAK_WineLook == WIN31_LOOK)
2609 NC_DrawSysButton( hwnd, hDC, TRUE );
2610 else
2611 NC_DrawSysButton95( hwnd, hDC, TRUE );
2612 ReleaseDC( hwnd, hDC );
2613 }
2614 SendMessage16( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU + HTSYSMENU, lParam );
2615 }
2616 break;
2617
2618 case HTMENU:
2619 SendMessage16( hwnd, WM_SYSCOMMAND, SC_MOUSEMENU, lParam );
2620 break;
2621
2622 case HTHSCROLL:
2623 SendMessage16( hwnd, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL, lParam );
2624 break;
2625
2626 case HTVSCROLL:
2627 SendMessage16( hwnd, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL, lParam );
2628 break;
2629
2630 case HTMINBUTTON:
2631 case HTMAXBUTTON:
2632 if (TWEAK_WineLook == WIN31_LOOK)
2633 NC_TrackMinMaxBox( hwnd, wParam );
2634 else
2635 NC_TrackMinMaxBox95( hwnd, wParam );
2636 break;
2637
2638 case HTCLOSE:
2639 if (TWEAK_WineLook >= WIN95_LOOK)
2640 NC_TrackCloseButton95 (hwnd, wParam);
2641 break;
2642
2643 case HTLEFT:
2644 case HTRIGHT:
2645 case HTTOP:
2646 case HTTOPLEFT:
2647 case HTTOPRIGHT:
2648 case HTBOTTOM:
2649 case HTBOTTOMLEFT:
2650 case HTBOTTOMRIGHT:
2651 /* make sure hittest fits into 0xf and doesn't overlap with HTSYSMENU */
2652 SendMessage16( hwnd, WM_SYSCOMMAND, SC_SIZE + wParam - 2, lParam);
2653 break;
2654
2655 case HTBORDER:
2656 break;
2657 }
2658 return 0;
2659 }
2660
2661
2662 /***********************************************************************
2663 * NC_HandleNCLButtonDblClk
2664 *
2665 * Handle a WM_NCLBUTTONDBLCLK message. Called from DefWindowProc().
2666 */
2667 LONG NC_HandleNCLButtonDblClk( WND *pWnd, WPARAM16 wParam, LPARAM lParam )
2668 {
2669 /*
2670 * if this is an icon, send a restore since we are handling
2671 * a double click
2672 */
2673 if (pWnd->dwStyle & WS_MINIMIZE)
2674 {
2675 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_RESTORE, lParam );
2676 return 0;
2677 }
2678
2679 switch(wParam) /* Hit test */
2680 {
2681 case HTCAPTION:
2682 /* stop processing if WS_MAXIMIZEBOX is missing */
2683 if (pWnd->dwStyle & WS_MAXIMIZEBOX)
2684 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND,
2685 (pWnd->dwStyle & WS_MAXIMIZE) ? SC_RESTORE : SC_MAXIMIZE,
2686 lParam );
2687 break;
2688
2689 case HTSYSMENU:
2690 if (!(GetClassWord(pWnd->hwndSelf, GCW_STYLE) & CS_NOCLOSE))
2691 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_CLOSE, lParam );
2692 break;
2693
2694 case HTHSCROLL:
2695 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_HSCROLL + HTHSCROLL,
2696 lParam );
2697 break;
2698
2699 case HTVSCROLL:
2700 SendMessage16( pWnd->hwndSelf, WM_SYSCOMMAND, SC_VSCROLL + HTVSCROLL,
2701 lParam );
2702 break;
2703 }
2704 return 0;
2705 }
2706
2707
2708 /***********************************************************************
2709 * NC_HandleSysCommand
2710 *
2711 * Handle a WM_SYSCOMMAND message. Called from DefWindowProc().
2712 */
2713 LONG NC_HandleSysCommand( HWND hwnd, WPARAM16 wParam, POINT16 pt )
2714 {
2715 WND *wndPtr = WIN_FindWndPtr( hwnd );
2716 POINT pt32;
2717 UINT16 uCommand = wParam & 0xFFF0;
2718
2719 TRACE("Handling WM_SYSCOMMAND %x %d,%d\n", wParam, pt.x, pt.y );
2720
2721 if (wndPtr->dwStyle & WS_CHILD && uCommand != SC_KEYMENU )
2722 ScreenToClient16( wndPtr->parent->hwndSelf, &pt );
2723
2724 switch (uCommand)
2725 {
2726 case SC_SIZE:
2727 case SC_MOVE:
2728 NC_DoSizeMove( hwnd, wParam );
2729 break;
2730
2731 case SC_MINIMIZE:
2732 if (hwnd == GetForegroundWindow())
2733 ShowOwnedPopups(hwnd,FALSE);
2734 ShowWindow( hwnd, SW_MINIMIZE );
2735 break;
2736
2737 case SC_MAXIMIZE:
2738 if (IsIconic(hwnd) && hwnd == GetForegroundWindow())
2739 ShowOwnedPopups(hwnd,TRUE);
2740 ShowWindow( hwnd, SW_MAXIMIZE );
2741 break;
2742
2743 case SC_RESTORE:
2744 if (IsIconic(hwnd) && hwnd == GetForegroundWindow())
2745 ShowOwnedPopups(hwnd,TRUE);
2746 ShowWindow( hwnd, SW_RESTORE );
2747 break;
2748
2749 case SC_CLOSE:
2750 WIN_ReleaseWndPtr(wndPtr);
2751 return SendMessage16( hwnd, WM_CLOSE, 0, 0 );
2752
2753 case SC_VSCROLL:
2754 case SC_HSCROLL:
2755 CONV_POINT16TO32( &pt, &pt32 );
2756 NC_TrackScrollBar( hwnd, wParam, pt32 );
2757 break;
2758
2759 case SC_MOUSEMENU:
2760 CONV_POINT16TO32( &pt, &pt32 );
2761 MENU_TrackMouseMenuBar( wndPtr, wParam & 0x000F, pt32 );
2762 break;
2763
2764 case SC_KEYMENU:
2765 MENU_TrackKbdMenuBar( wndPtr , wParam , pt.x );
2766 break;
2767
2768 case SC_TASKLIST:
2769 WinExec( "taskman.exe", SW_SHOWNORMAL );
2770 break;
2771
2772 case SC_SCREENSAVE:
2773 if (wParam == SC_ABOUTWINE)
2774 {
2775 HMODULE hmodule = LoadLibraryA( "shell32.dll" );
2776 if (hmodule)
2777 {
2778 FARPROC aboutproc = GetProcAddress( hmodule, "ShellAboutA" );
2779 if (aboutproc) aboutproc( hwnd, "Wine", WINE_RELEASE_INFO, 0 );
2780 FreeLibrary( hmodule );
2781 }
2782 }
2783 else
2784 if (wParam == SC_PUTMARK)
2785 TRACE_(shell)("Mark requested by user\n");
2786 break;
2787
2788 case SC_HOTKEY:
2789 case SC_ARRANGE:
2790 case SC_NEXTWINDOW:
2791 case SC_PREVWINDOW:
2792 FIXME("unimplemented!\n");
2793 break;
2794 }
2795 WIN_ReleaseWndPtr(wndPtr);
2796 return 0;
2797 }
2798
2799 /*************************************************************
2800 * NC_DrawGrayButton
2801 *
2802 * Stub for the grayed button of the caption
2803 *
2804 *************************************************************/
2805
2806 BOOL NC_DrawGrayButton(HDC hdc, int x, int y)
2807 {
2808 HBITMAP hMaskBmp;
2809 HDC hdcMask = CreateCompatibleDC (0);
2810 HBRUSH hOldBrush;
2811
2812 hMaskBmp = CreateBitmap (12, 10, 1, 1, lpGrayMask);
2813
2814 if(hMaskBmp == 0)
2815 return FALSE;
2816
2817 SelectObject (hdcMask, hMaskBmp);
2818
2819 /* Draw the grayed bitmap using the mask */
2820 hOldBrush = SelectObject (hdc, RGB(128, 128, 128));
2821 BitBlt (hdc, x, y, 12, 10,
2822 hdcMask, 0, 0, 0xB8074A);
2823
2824 /* Clean up */
2825 SelectObject (hdc, hOldBrush);
2826 DeleteObject(hMaskBmp);
2827 DeleteDC (hdcMask);
2828
2829 return TRUE;
2830 }
GSOC 2012 project to enhance the control panel