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