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