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