?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 980913
[wine/multimedia.git] / windows / mdi.c
blobf38c164c09549eb49e7ba58fc53eb2a74c3bfa63
1 /* MDI.C
2 *
3 * Copyright 1994, Bob Amstadt
4 * 1995,1996 Alex Korobka
5 *
6 * This file contains routines to support MDI features.
7 *
8 * Notes: Fairly complete implementation. Any volunteers for
9 * "More windows..." stuff?
10 *
11 * Also, Excel and WinWord do _not_ use MDI so if you're trying
12 * to fix them look elsewhere.
13 */
14
15 #include <stdlib.h>
16 #include <string.h>
17 #include <math.h>
18 #include "windows.h"
19 #include "win.h"
20 #include "heap.h"
21 #include "nonclient.h"
22 #include "mdi.h"
23 #include "user.h"
24 #include "menu.h"
25 #include "resource.h"
26 #include "struct32.h"
27 #include "sysmetrics.h"
28 #include "debug.h"
29
30 #define MDIF_NEEDUPDATE 0x0001
31
32 static HBITMAP16 hBmpClose = 0;
33 static HBITMAP16 hBmpRestore = 0;
34
35 DWORD SCROLL_SetNCSbState(WND*,int,int,int,int,int,int);
36
37 /* ----------------- declarations ----------------- */
38 static void MDI_UpdateFrameText(WND *, HWND32, BOOL32, LPCSTR);
39 static BOOL32 MDI_AugmentFrameMenu(MDICLIENTINFO*, WND *, HWND32);
40 static BOOL32 MDI_RestoreFrameMenu(WND *, HWND32);
41
42 static LONG MDI_ChildActivate( WND*, HWND32 );
43
44 /* -------- Miscellaneous service functions ----------
45 *
46 * MDI_GetChildByID
47 */
48
49 static HWND32 MDI_GetChildByID(WND* wndPtr, INT32 id)
50 {
51 for (wndPtr = wndPtr->child; wndPtr; wndPtr = wndPtr->next)
52 if (wndPtr->wIDmenu == id) return wndPtr->hwndSelf;
53 return 0;
54 }
55
56 static void MDI_PostUpdate(HWND32 hwnd, MDICLIENTINFO* ci, WORD recalc)
57 {
58 if( !(ci->mdiFlags & MDIF_NEEDUPDATE) )
59 {
60 ci->mdiFlags |= MDIF_NEEDUPDATE;
61 PostMessage32A( hwnd, WM_MDICALCCHILDSCROLL, 0, 0);
62 }
63 ci->sbRecalc = recalc;
64 }
65
66 /**********************************************************************
67 * MDI_MenuModifyItem
68 */
69 static BOOL32 MDI_MenuModifyItem(WND* clientWnd, HWND32 hWndChild )
70 {
71 char buffer[128];
72 MDICLIENTINFO *clientInfo = (MDICLIENTINFO*)clientWnd->wExtra;
73 WND *wndPtr = WIN_FindWndPtr(hWndChild);
74 UINT32 n = sprintf(buffer, "%d ",
75 wndPtr->wIDmenu - clientInfo->idFirstChild + 1);
76 BOOL32 bRet = 0;
77
78 if( !clientInfo->hWindowMenu ) return 0;
79
80 if (wndPtr->text) lstrcpyn32A(buffer + n, wndPtr->text, sizeof(buffer) - n );
81
82 n = GetMenuState32(clientInfo->hWindowMenu,wndPtr->wIDmenu ,MF_BYCOMMAND);
83 bRet = ModifyMenu32A(clientInfo->hWindowMenu , wndPtr->wIDmenu,
84 MF_BYCOMMAND | MF_STRING, wndPtr->wIDmenu, buffer );
85 CheckMenuItem32(clientInfo->hWindowMenu ,wndPtr->wIDmenu , n & MF_CHECKED);
86 return bRet;
87 }
88
89 /**********************************************************************
90 * MDI_MenuDeleteItem
91 */
92 static BOOL32 MDI_MenuDeleteItem(WND* clientWnd, HWND32 hWndChild )
93 {
94 char buffer[128];
95 MDICLIENTINFO *clientInfo = (MDICLIENTINFO*)clientWnd->wExtra;
96 WND *wndPtr = WIN_FindWndPtr(hWndChild);
97 UINT32 index = 0,id,n;
98
99 if( !clientInfo->nActiveChildren ||
100 !clientInfo->hWindowMenu ) return 0;
101
102 id = wndPtr->wIDmenu;
103 DeleteMenu32(clientInfo->hWindowMenu,id,MF_BYCOMMAND);
104
105 /* walk the rest of MDI children to prevent gaps in the id
106 * sequence and in the menu child list */
107
108 for( index = id+1; index <= clientInfo->nActiveChildren +
109 clientInfo->idFirstChild; index++ )
110 {
111 wndPtr = WIN_FindWndPtr(MDI_GetChildByID(clientWnd,index));
112 if( !wndPtr )
113 {
114 TRACE(mdi,"no window for id=%i\n",index);
115 continue;
116 }
117
118 /* set correct id */
119 wndPtr->wIDmenu--;
120
121 n = sprintf(buffer, "%d ",index - clientInfo->idFirstChild);
122 if (wndPtr->text)
123 lstrcpyn32A(buffer + n, wndPtr->text, sizeof(buffer) - n );
124
125 /* change menu */
126 ModifyMenu32A(clientInfo->hWindowMenu ,index ,MF_BYCOMMAND | MF_STRING,
127 index - 1 , buffer );
128 }
129 return 1;
130 }
131
132 /**********************************************************************
133 * MDI_GetWindow
134 *
135 * returns "activateable" child different from the current or zero
136 */
137 static HWND32 MDI_GetWindow(WND *clientWnd, HWND32 hWnd, BOOL32 bNext,
138 DWORD dwStyleMask )
139 {
140 MDICLIENTINFO *clientInfo = (MDICLIENTINFO*)clientWnd->wExtra;
141 WND *wndPtr, *pWnd, *pWndLast = NULL;
142
143 dwStyleMask |= WS_DISABLED | WS_VISIBLE;
144 if( !hWnd ) hWnd = clientInfo->hwndActiveChild;
145
146 if( !(wndPtr = WIN_FindWndPtr(hWnd)) ) return 0;
147
148 for ( pWnd = wndPtr->next; ; pWnd = pWnd->next )
149 {
150 if (!pWnd ) pWnd = wndPtr->parent->child;
151
152 if ( pWnd == wndPtr ) break; /* went full circle */
153
154 if (!pWnd->owner && (pWnd->dwStyle & dwStyleMask) == WS_VISIBLE )
155 {
156 pWndLast = pWnd;
157 if ( bNext ) break;
158 }
159 }
160 return pWndLast ? pWndLast->hwndSelf : 0;
161 }
162
163 /**********************************************************************
164 * MDI_CalcDefaultChildPos
165 *
166 * It seems that the default height is about 2/3 of the client rect
167 */
168 static void MDI_CalcDefaultChildPos( WND* w, WORD n, LPPOINT32 lpPos,
169 INT32 delta)
170 {
171 INT32 nstagger;
172 RECT32 rect = w->rectClient;
173 INT32 spacing = GetSystemMetrics32(SM_CYCAPTION) +
174 GetSystemMetrics32(SM_CYFRAME) - 1;
175
176 if( rect.bottom - rect.top - delta >= spacing )
177 rect.bottom -= delta;
178
179 nstagger = (rect.bottom - rect.top)/(3 * spacing);
180 lpPos[1].x = (rect.right - rect.left - nstagger * spacing);
181 lpPos[1].y = (rect.bottom - rect.top - nstagger * spacing);
182 lpPos[0].x = lpPos[0].y = spacing * (n%(nstagger+1));
183 }
184
185 /**********************************************************************
186 * MDISetMenu
187 */
188 static LRESULT MDISetMenu( HWND32 hwnd, HMENU32 hmenuFrame,
189 HMENU32 hmenuWindow)
190 {
191 WND *w = WIN_FindWndPtr(hwnd);
192 MDICLIENTINFO *ci;
193 HWND32 hwndFrame = GetParent32(hwnd);
194 HMENU32 oldFrameMenu = GetMenu32(hwndFrame);
195
196 TRACE(mdi, "%04x %04x %04x\n",
197 hwnd, hmenuFrame, hmenuWindow);
198
199 ci = (MDICLIENTINFO *) w->wExtra;
200
201 if( ci->hwndChildMaximized && hmenuFrame && hmenuFrame!=oldFrameMenu )
202 MDI_RestoreFrameMenu(w->parent, ci->hwndChildMaximized );
203
204 if( hmenuWindow && hmenuWindow!=ci->hWindowMenu )
205 {
206 /* delete menu items from ci->hWindowMenu
207 * and add them to hmenuWindow */
208
209 INT32 i = GetMenuItemCount32(ci->hWindowMenu) - 1;
210 INT32 pos = GetMenuItemCount32(hmenuWindow) + 1;
211
212 AppendMenu32A( hmenuWindow, MF_SEPARATOR, 0, NULL);
213
214 if( ci->nActiveChildren )
215 {
216 INT32 j = i - ci->nActiveChildren + 1;
217 char buffer[100];
218 UINT32 id,state;
219
220 for( ; i >= j ; i-- )
221 {
222 id = GetMenuItemID32(ci->hWindowMenu,i );
223 state = GetMenuState32(ci->hWindowMenu,i,MF_BYPOSITION);
224
225 GetMenuString32A(ci->hWindowMenu, i, buffer, 100, MF_BYPOSITION);
226
227 DeleteMenu32(ci->hWindowMenu, i , MF_BYPOSITION);
228 InsertMenu32A(hmenuWindow, pos, MF_BYPOSITION | MF_STRING,
229 id, buffer);
230 CheckMenuItem32(hmenuWindow ,pos , MF_BYPOSITION | (state & MF_CHECKED));
231 }
232 }
233
234 /* remove separator */
235 DeleteMenu32(ci->hWindowMenu, i, MF_BYPOSITION);
236
237 ci->hWindowMenu = hmenuWindow;
238 }
239
240 if( hmenuFrame && hmenuFrame!=oldFrameMenu)
241 {
242 SetMenu32(hwndFrame, hmenuFrame);
243 if( ci->hwndChildMaximized )
244 MDI_AugmentFrameMenu(ci, w->parent, ci->hwndChildMaximized );
245 return oldFrameMenu;
246 }
247 return 0;
248 }
249
250 /**********************************************************************
251 * MDIRefreshMenu
252 */
253 static LRESULT MDIRefreshMenu( HWND32 hwnd, HMENU32 hmenuFrame,
254 HMENU32 hmenuWindow)
255 {
256 HWND32 hwndFrame = GetParent32(hwnd);
257 HMENU32 oldFrameMenu = GetMenu32(hwndFrame);
258
259 TRACE(mdi, "%04x %04x %04x\n",
260 hwnd, hmenuFrame, hmenuWindow);
261
262 FIXME(mdi,"partial function stub\n");
263
264 return oldFrameMenu;
265 }
266
267
268 /* ------------------ MDI child window functions ---------------------- */
269
270
271 /**********************************************************************
272 * MDICreateChild
273 */
274 static HWND32 MDICreateChild( WND *w, MDICLIENTINFO *ci, HWND32 parent,
275 LPMDICREATESTRUCT32A cs )
276 {
277 POINT32 pos[2];
278 DWORD style = cs->style | (WS_CHILD | WS_CLIPSIBLINGS);
279 HWND32 hwnd, hwndMax = 0;
280 WORD wIDmenu = ci->idFirstChild + ci->nActiveChildren;
281 char lpstrDef[]="junk!";
282
283 TRACE(mdi, "origin %i,%i - dim %i,%i, style %08x\n",
284 cs->x, cs->y, cs->cx, cs->cy, (unsigned)cs->style);
285 /* calculate placement */
286 MDI_CalcDefaultChildPos(w, ci->nTotalCreated++, pos, 0);
287
288 if (cs->cx == CW_USEDEFAULT32 || !cs->cx) cs->cx = pos[1].x;
289 if (cs->cy == CW_USEDEFAULT32 || !cs->cy) cs->cy = pos[1].y;
290
291 if( cs->x == CW_USEDEFAULT32 )
292 {
293 cs->x = pos[0].x;
294 cs->y = pos[0].y;
295 }
296
297 /* restore current maximized child */
298 if( style & WS_VISIBLE && ci->hwndChildMaximized )
299 {
300 if( style & WS_MAXIMIZE )
301 SendMessage32A(w->hwndSelf, WM_SETREDRAW, FALSE, 0L );
302 hwndMax = ci->hwndChildMaximized;
303 ShowWindow32( hwndMax, SW_SHOWNOACTIVATE );
304 if( style & WS_MAXIMIZE )
305 SendMessage32A(w->hwndSelf, WM_SETREDRAW, TRUE, 0L );
306 }
307
308 /* this menu is needed to set a check mark in MDI_ChildActivate */
309 AppendMenu32A(ci->hWindowMenu ,MF_STRING ,wIDmenu, lpstrDef );
310
311 ci->nActiveChildren++;
312
313 /* fix window style */
314 if( !(w->dwStyle & MDIS_ALLCHILDSTYLES) )
315 {
316 style &= (WS_CHILD | WS_CLIPSIBLINGS | WS_MINIMIZE | WS_MAXIMIZE |
317 WS_CLIPCHILDREN | WS_DISABLED | WS_VSCROLL | WS_HSCROLL );
318 style |= (WS_VISIBLE | WS_OVERLAPPEDWINDOW);
319 }
320
321 if( w->flags & WIN_ISWIN32 )
322 {
323 hwnd = CreateWindow32A( cs->szClass, cs->szTitle, style,
324 cs->x, cs->y, cs->cx, cs->cy, parent,
325 (HMENU16)wIDmenu, cs->hOwner, cs );
326 }
327 else
328 {
329 MDICREATESTRUCT16 *cs16;
330 LPSTR title, cls;
331
332 cs16 = SEGPTR_NEW(MDICREATESTRUCT16);
333 STRUCT32_MDICREATESTRUCT32Ato16( cs, cs16 );
334 title = SEGPTR_STRDUP( cs->szTitle );
335 cls = SEGPTR_STRDUP( cs->szClass );
336 cs16->szTitle = SEGPTR_GET(title);
337 cs16->szClass = SEGPTR_GET(cls);
338
339 hwnd = CreateWindow16( cs->szClass, cs->szTitle, style,
340 cs16->x, cs16->y, cs16->cx, cs16->cy, parent,
341 (HMENU32)wIDmenu, cs16->hOwner,
342 (LPVOID)SEGPTR_GET(cs16) );
343 SEGPTR_FREE( title );
344 SEGPTR_FREE( cls );
345 SEGPTR_FREE( cs16 );
346 }
347
348 /* MDI windows are WS_CHILD so they won't be activated by CreateWindow */
349
350 if (hwnd)
351 {
352 WND* wnd = WIN_FindWndPtr( hwnd );
353
354 MDI_MenuModifyItem(w ,hwnd);
355 if( wnd->dwStyle & WS_MINIMIZE && ci->hwndActiveChild )
356 ShowWindow32( hwnd, SW_SHOWMINNOACTIVE );
357 else
358 {
359 SetWindowPos32( hwnd, 0, 0, 0, 0, 0, SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOMOVE );
360
361 /* Set maximized state here in case hwnd didn't receive WM_SIZE
362 * during CreateWindow - bad!
363 */
364
365 if((wnd->dwStyle & WS_MAXIMIZE) && !ci->hwndChildMaximized )
366 {
367 ci->hwndChildMaximized = wnd->hwndSelf;
368 MDI_AugmentFrameMenu( ci, w->parent, hwnd );
369 MDI_UpdateFrameText( w->parent, ci->self, MDI_REPAINTFRAME, NULL );
370 }
371 }
372 TRACE(mdi, "created child - %04x\n",hwnd);
373 }
374 else
375 {
376 ci->nActiveChildren--;
377 DeleteMenu32(ci->hWindowMenu,wIDmenu,MF_BYCOMMAND);
378 if( IsWindow32(hwndMax) )
379 ShowWindow32(hwndMax, SW_SHOWMAXIMIZED);
380 }
381
382 return hwnd;
383 }
384
385 /**********************************************************************
386 * MDI_ChildGetMinMaxInfo
387 *
388 * Note: The rule here is that client rect of the maximized MDI child
389 * is equal to the client rect of the MDI client window.
390 */
391 static void MDI_ChildGetMinMaxInfo( WND* clientWnd, HWND32 hwnd,
392 MINMAXINFO16* lpMinMax )
393 {
394 WND* childWnd = WIN_FindWndPtr(hwnd);
395 RECT32 rect = clientWnd->rectClient;
396
397 MapWindowPoints32( clientWnd->parent->hwndSelf,
398 ((MDICLIENTINFO*)clientWnd->wExtra)->self, (LPPOINT32)&rect, 2);
399 AdjustWindowRectEx32( &rect, childWnd->dwStyle, 0, childWnd->dwExStyle );
400
401 lpMinMax->ptMaxSize.x = rect.right -= rect.left;
402 lpMinMax->ptMaxSize.y = rect.bottom -= rect.top;
403
404 lpMinMax->ptMaxPosition.x = rect.left;
405 lpMinMax->ptMaxPosition.y = rect.top;
406
407 TRACE(mdi,"max rect (%i,%i - %i, %i)\n",
408 rect.left,rect.top,rect.right,rect.bottom);
409 }
410
411 /**********************************************************************
412 * MDI_SwitchActiveChild
413 *
414 * Note: SetWindowPos sends WM_CHILDACTIVATE to the child window that is
415 * being activated
416 */
417 static void MDI_SwitchActiveChild( HWND32 clientHwnd, HWND32 childHwnd,
418 BOOL32 bNextWindow )
419 {
420 WND *w = WIN_FindWndPtr(clientHwnd);
421 HWND32 hwndTo = 0;
422 HWND32 hwndPrev = 0;
423 MDICLIENTINFO *ci;
424
425 hwndTo = MDI_GetWindow(w, childHwnd, bNextWindow, 0);
426
427 ci = (MDICLIENTINFO *) w->wExtra;
428
429 TRACE(mdi, "from %04x, to %04x\n",childHwnd,hwndTo);
430
431 if ( !hwndTo ) return; /* no window to switch to */
432
433 hwndPrev = ci->hwndActiveChild;
434
435 if ( hwndTo != hwndPrev )
436 {
437 BOOL32 bOptimize = 0;
438
439 if( ci->hwndChildMaximized )
440 {
441 bOptimize = 1;
442 w->dwStyle &= ~WS_VISIBLE;
443 }
444
445 SetWindowPos32( hwndTo, HWND_TOP, 0, 0, 0, 0,
446 SWP_NOMOVE | SWP_NOSIZE );
447
448 if( bNextWindow && hwndPrev )
449 SetWindowPos32( hwndPrev, HWND_BOTTOM, 0, 0, 0, 0,
450 SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE );
451 if( bOptimize )
452 ShowWindow32( clientHwnd, SW_SHOW );
453 }
454 }
455
456
457 /**********************************************************************
458 * MDIDestroyChild
459 */
460 static LRESULT MDIDestroyChild( WND *w_parent, MDICLIENTINFO *ci,
461 HWND32 parent, HWND32 child,
462 BOOL32 flagDestroy )
463 {
464 WND *childPtr = WIN_FindWndPtr(child);
465
466 if( childPtr )
467 {
468 if( child == ci->hwndActiveChild )
469 {
470 MDI_SwitchActiveChild(parent, child, TRUE);
471
472 if( child == ci->hwndActiveChild )
473 {
474 ShowWindow32( child, SW_HIDE);
475 if( child == ci->hwndChildMaximized )
476 {
477 MDI_RestoreFrameMenu(w_parent->parent, child);
478 ci->hwndChildMaximized = 0;
479 MDI_UpdateFrameText(w_parent->parent,parent,TRUE,NULL);
480 }
481
482 MDI_ChildActivate(w_parent, 0);
483 }
484 MDI_MenuDeleteItem(w_parent, child);
485 }
486
487 ci->nActiveChildren--;
488
489 TRACE(mdi,"child destroyed - %04x\n",child);
490
491 if (flagDestroy)
492 {
493 MDI_PostUpdate(GetParent32(child), ci, SB_BOTH+1);
494 DestroyWindow32(child);
495 }
496 }
497
498 return 0;
499 }
500
501
502 /**********************************************************************
503 * MDI_ChildActivate
504 *
505 * Note: hWndChild is NULL when last child is being destroyed
506 */
507 static LONG MDI_ChildActivate( WND *clientPtr, HWND32 hWndChild )
508 {
509 MDICLIENTINFO *clientInfo = (MDICLIENTINFO*)clientPtr->wExtra;
510 HWND32 prevActiveWnd = clientInfo->hwndActiveChild;
511 WND *wndPtr = WIN_FindWndPtr( hWndChild );
512 WND *wndPrev = WIN_FindWndPtr( prevActiveWnd );
513 BOOL32 isActiveFrameWnd = 0;
514
515 if( hWndChild == prevActiveWnd ) return 0L;
516
517 if( wndPtr )
518 if( wndPtr->dwStyle & WS_DISABLED ) return 0L;
519
520 TRACE(mdi,"%04x\n", hWndChild);
521
522 if( GetActiveWindow32() == clientPtr->parent->hwndSelf )
523 isActiveFrameWnd = TRUE;
524
525 /* deactivate prev. active child */
526 if( wndPrev )
527 {
528 wndPrev->dwStyle |= WS_SYSMENU;
529 SendMessage32A( prevActiveWnd, WM_NCACTIVATE, FALSE, 0L );
530 SendMessage32A( prevActiveWnd, WM_MDIACTIVATE, (WPARAM32)prevActiveWnd,
531 (LPARAM)hWndChild);
532 /* uncheck menu item */
533 if( clientInfo->hWindowMenu )
534 CheckMenuItem32( clientInfo->hWindowMenu,
535 wndPrev->wIDmenu, 0);
536 }
537
538 /* set appearance */
539 if( clientInfo->hwndChildMaximized )
540 if( clientInfo->hwndChildMaximized != hWndChild )
541 if( hWndChild )
542 {
543 clientInfo->hwndActiveChild = hWndChild;
544 ShowWindow32( hWndChild, SW_SHOWMAXIMIZED);
545 }
546 else
547 ShowWindow32( clientInfo->hwndActiveChild, SW_SHOWNORMAL );
548
549 clientInfo->hwndActiveChild = hWndChild;
550
551 /* check if we have any children left */
552 if( !hWndChild )
553 {
554 if( isActiveFrameWnd )
555 SetFocus32( clientInfo->self );
556 return 0;
557 }
558
559 /* check menu item */
560 if( clientInfo->hWindowMenu )
561 CheckMenuItem32( clientInfo->hWindowMenu,
562 wndPtr->wIDmenu, MF_CHECKED);
563
564 /* bring active child to the top */
565 SetWindowPos32( hWndChild, 0,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
566
567 if( isActiveFrameWnd )
568 {
569 SendMessage32A( hWndChild, WM_NCACTIVATE, TRUE, 0L);
570 if( GetFocus32() == clientInfo->self )
571 SendMessage32A( clientInfo->self, WM_SETFOCUS,
572 (WPARAM32)clientInfo->self, 0L );
573 else
574 SetFocus32( clientInfo->self );
575 }
576 SendMessage32A( hWndChild, WM_MDIACTIVATE, (WPARAM32)prevActiveWnd,
577 (LPARAM)hWndChild );
578 return 1;
579 }
580
581 /* -------------------- MDI client window functions ------------------- */
582
583 /**********************************************************************
584 * CreateMDIMenuBitmap
585 */
586 static HBITMAP16 CreateMDIMenuBitmap(void)
587 {
588 HDC32 hDCSrc = CreateCompatibleDC32(0);
589 HDC32 hDCDest = CreateCompatibleDC32(hDCSrc);
590 HBITMAP16 hbClose = LoadBitmap16(0, MAKEINTRESOURCE16(OBM_CLOSE) );
591 HBITMAP16 hbCopy;
592 HANDLE16 hobjSrc, hobjDest;
593
594 hobjSrc = SelectObject32(hDCSrc, hbClose);
595 hbCopy = CreateCompatibleBitmap32(hDCSrc,SYSMETRICS_CXSIZE,SYSMETRICS_CYSIZE);
596 hobjDest = SelectObject32(hDCDest, hbCopy);
597
598 BitBlt32(hDCDest, 0, 0, SYSMETRICS_CXSIZE, SYSMETRICS_CYSIZE,
599 hDCSrc, SYSMETRICS_CXSIZE, 0, SRCCOPY);
600
601 SelectObject32(hDCSrc, hobjSrc);
602 DeleteObject32(hbClose);
603 DeleteDC32(hDCSrc);
604
605 hobjSrc = SelectObject32( hDCDest, GetStockObject32(BLACK_PEN) );
606
607 MoveToEx32( hDCDest, SYSMETRICS_CXSIZE - 1, 0, NULL );
608 LineTo32( hDCDest, SYSMETRICS_CXSIZE - 1, SYSMETRICS_CYSIZE - 1);
609
610 SelectObject32(hDCDest, hobjSrc );
611 SelectObject32(hDCDest, hobjDest);
612 DeleteDC32(hDCDest);
613
614 return hbCopy;
615 }
616
617 /**********************************************************************
618 * MDICascade
619 */
620 static LONG MDICascade(WND* clientWnd, MDICLIENTINFO *ci)
621 {
622 WND** ppWnd;
623 UINT32 total;
624
625 if (ci->hwndChildMaximized)
626 ShowWindow16( ci->hwndChildMaximized, SW_NORMAL);
627
628 if (ci->nActiveChildren == 0) return 0;
629
630 if ((ppWnd = WIN_BuildWinArray(clientWnd, BWA_SKIPHIDDEN | BWA_SKIPOWNED |
631 BWA_SKIPICONIC, &total)))
632 {
633 WND** heapPtr = ppWnd;
634 if( total )
635 {
636 INT32 delta = 0, n = 0;
637 POINT32 pos[2];
638 if( total < ci->nActiveChildren )
639 delta = SYSMETRICS_CYICONSPACING + SYSMETRICS_CYICON;
640
641 /* walk the list (backwards) and move windows */
642 while (*ppWnd) ppWnd++;
643 while (ppWnd != heapPtr)
644 {
645 ppWnd--;
646 TRACE(mdi, "move %04x to (%d,%d) size [%d,%d]\n",
647 (*ppWnd)->hwndSelf, pos[0].x, pos[0].y, pos[1].x, pos[1].y);
648
649 MDI_CalcDefaultChildPos(clientWnd, n++, pos, delta);
650 SetWindowPos32( (*ppWnd)->hwndSelf, 0, pos[0].x, pos[0].y,
651 pos[1].x, pos[1].y,
652 SWP_DRAWFRAME | SWP_NOACTIVATE | SWP_NOZORDER);
653 }
654 }
655 HeapFree( SystemHeap, 0, heapPtr );
656 }
657
658 if( total < ci->nActiveChildren )
659 ArrangeIconicWindows32( clientWnd->hwndSelf );
660 return 0;
661 }
662
663 /**********************************************************************
664 * MDITile
665 */
666 static void MDITile( WND* wndClient, MDICLIENTINFO *ci, WPARAM32 wParam )
667 {
668 WND** ppWnd;
669 UINT32 total = 0;
670
671 if (ci->hwndChildMaximized)
672 ShowWindow32(ci->hwndChildMaximized, SW_NORMAL);
673
674 if (ci->nActiveChildren == 0) return;
675
676 ppWnd = WIN_BuildWinArray(wndClient, BWA_SKIPHIDDEN | BWA_SKIPOWNED | BWA_SKIPICONIC |
677 ((wParam & MDITILE_SKIPDISABLED)? BWA_SKIPDISABLED : 0), &total );
678
679 TRACE(mdi,"%u windows to tile\n", total);
680
681 if( ppWnd )
682 {
683 WND** heapPtr = ppWnd;
684
685 if( total )
686 {
687 RECT32 rect;
688 int x, y, xsize, ysize;
689 int rows, columns, r, c, i;
690
691 rect = wndClient->rectClient;
692 rows = (int) sqrt((double)total);
693 columns = total / rows;
694
695 if( wParam & MDITILE_HORIZONTAL ) /* version >= 3.1 */
696 {
697 i = rows;
698 rows = columns; /* exchange r and c */
699 columns = i;
700 }
701
702 if( total != ci->nActiveChildren)
703 {
704 y = rect.bottom - 2 * SYSMETRICS_CYICONSPACING - SYSMETRICS_CYICON;
705 rect.bottom = ( y - SYSMETRICS_CYICON < rect.top )? rect.bottom: y;
706 }
707
708 ysize = rect.bottom / rows;
709 xsize = rect.right / columns;
710
711 for (x = i = 0, c = 1; c <= columns && *ppWnd; c++)
712 {
713 if (c == columns)
714 {
715 rows = total - i;
716 ysize = rect.bottom / rows;
717 }
718
719 y = 0;
720 for (r = 1; r <= rows && *ppWnd; r++, i++)
721 {
722 SetWindowPos32((*ppWnd)->hwndSelf, 0, x, y, xsize, ysize,
723 SWP_DRAWFRAME | SWP_NOACTIVATE | SWP_NOZORDER);
724 y += ysize;
725 ppWnd++;
726 }
727 x += xsize;
728 }
729 }
730 HeapFree( SystemHeap, 0, heapPtr );
731 }
732
733 if( total < ci->nActiveChildren ) ArrangeIconicWindows32( wndClient->hwndSelf );
734 }
735
736 /* ----------------------- Frame window ---------------------------- */
737
738
739 /**********************************************************************
740 * MDI_AugmentFrameMenu
741 */
742 static BOOL32 MDI_AugmentFrameMenu( MDICLIENTINFO* ci, WND *frame,
743 HWND32 hChild )
744 {
745 WND* child = WIN_FindWndPtr(hChild);
746 HMENU32 hSysPopup = 0;
747
748 TRACE(mdi,"frame %p,child %04x\n",frame,hChild);
749
750 if( !frame->wIDmenu || !child->hSysMenu ) return 0;
751
752 /* create a copy of sysmenu popup and insert it into frame menu bar */
753
754 if (!(hSysPopup = LoadMenuIndirect32A(SYSRES_GetResPtr(SYSRES_MENU_SYSMENU))))
755 return 0;
756
757 TRACE(mdi,"\tgot popup %04x in sysmenu %04x\n",
758 hSysPopup, child->hSysMenu);
759
760 if( !InsertMenu32A(frame->wIDmenu,0,MF_BYPOSITION | MF_BITMAP | MF_POPUP,
761 hSysPopup, (LPSTR)(DWORD)hBmpClose ))
762 {
763 DestroyMenu32(hSysPopup);
764 return 0;
765 }
766
767 if( !AppendMenu32A(frame->wIDmenu,MF_HELP | MF_BITMAP,
768 SC_RESTORE, (LPSTR)(DWORD)hBmpRestore ))
769 {
770 RemoveMenu32(frame->wIDmenu,0,MF_BYPOSITION);
771 return 0;
772 }
773
774 EnableMenuItem32(hSysPopup, SC_SIZE, MF_BYCOMMAND | MF_GRAYED);
775 EnableMenuItem32(hSysPopup, SC_MOVE, MF_BYCOMMAND | MF_GRAYED);
776 EnableMenuItem32(hSysPopup, SC_MAXIMIZE, MF_BYCOMMAND | MF_GRAYED);
777
778 /* redraw menu */
779 DrawMenuBar32(frame->hwndSelf);
780
781 return 1;
782 }
783
784 /**********************************************************************
785 * MDI_RestoreFrameMenu
786 */
787 static BOOL32 MDI_RestoreFrameMenu( WND *frameWnd, HWND32 hChild )
788 {
789 INT32 nItems = GetMenuItemCount32(frameWnd->wIDmenu) - 1;
790
791 TRACE(mdi,"for child %04x\n",hChild);
792
793 if( GetMenuItemID32(frameWnd->wIDmenu,nItems) != SC_RESTORE )
794 return 0;
795
796 RemoveMenu32(frameWnd->wIDmenu,0,MF_BYPOSITION);
797 DeleteMenu32(frameWnd->wIDmenu,nItems-1,MF_BYPOSITION);
798
799 DrawMenuBar32(frameWnd->hwndSelf);
800
801 return 1;
802 }
803
804 /**********************************************************************
805 * MDI_UpdateFrameText
806 *
807 * used when child window is maximized/restored
808 *
809 * Note: lpTitle can be NULL
810 */
811 static void MDI_UpdateFrameText( WND *frameWnd, HWND32 hClient,
812 BOOL32 repaint, LPCSTR lpTitle )
813 {
814 char lpBuffer[MDI_MAXTITLELENGTH+1];
815 WND* clientWnd = WIN_FindWndPtr(hClient);
816 MDICLIENTINFO *ci = (MDICLIENTINFO *) clientWnd->wExtra;
817
818 TRACE(mdi, "repaint %i, frameText %s\n", repaint, (lpTitle)?lpTitle:"NULL");
819
820 if (!clientWnd)
821 return;
822
823 if (!ci)
824 return;
825
826 /* store new "default" title if lpTitle is not NULL */
827 if (lpTitle)
828 {
829 if (ci->frameTitle) HeapFree( SystemHeap, 0, ci->frameTitle );
830 ci->frameTitle = HEAP_strdupA( SystemHeap, 0, lpTitle );
831 }
832
833 if (ci->frameTitle)
834 {
835 WND* childWnd = WIN_FindWndPtr( ci->hwndChildMaximized );
836
837 if( childWnd && childWnd->text )
838 {
839 /* combine frame title and child title if possible */
840
841 LPCSTR lpBracket = " - [";
842 int i_frame_text_length = strlen(ci->frameTitle);
843 int i_child_text_length = strlen(childWnd->text);
844
845 lstrcpyn32A( lpBuffer, ci->frameTitle, MDI_MAXTITLELENGTH);
846
847 if( i_frame_text_length + 6 < MDI_MAXTITLELENGTH )
848 {
849 strcat( lpBuffer, lpBracket );
850
851 if( i_frame_text_length + i_child_text_length + 6 < MDI_MAXTITLELENGTH )
852 {
853 strcat( lpBuffer, childWnd->text );
854 strcat( lpBuffer, "]" );
855 }
856 else
857 {
858 lstrcpyn32A( lpBuffer + i_frame_text_length + 4,
859 childWnd->text, MDI_MAXTITLELENGTH - i_frame_text_length - 5 );
860 strcat( lpBuffer, "]" );
861 }
862 }
863 }
864 else
865 {
866 strncpy(lpBuffer, ci->frameTitle, MDI_MAXTITLELENGTH );
867 lpBuffer[MDI_MAXTITLELENGTH]='\0';
868 }
869 }
870 else
871 lpBuffer[0] = '\0';
872
873 DEFWND_SetText( frameWnd, lpBuffer );
874 if( repaint == MDI_REPAINTFRAME)
875 SetWindowPos32( frameWnd->hwndSelf, 0,0,0,0,0, SWP_FRAMECHANGED |
876 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER );
877 }
878
879
880 /* ----------------------------- Interface ---------------------------- */
881
882
883 /**********************************************************************
884 * MDIClientWndProc
885 *
886 * This function handles all MDI requests.
887 */
888 LRESULT WINAPI MDIClientWndProc( HWND32 hwnd, UINT32 message, WPARAM32 wParam,
889 LPARAM lParam )
890 {
891 LPCREATESTRUCT32A cs;
892 MDICLIENTINFO *ci;
893 RECT32 rect;
894 WND *w = WIN_FindWndPtr(hwnd);
895 WND *frameWnd = w->parent;
896 INT32 nItems;
897
898 ci = (MDICLIENTINFO *) w->wExtra;
899
900 switch (message)
901 {
902 case WM_CREATE:
903
904 cs = (LPCREATESTRUCT32A)lParam;
905
906 /* Translation layer doesn't know what's in the cs->lpCreateParams
907 * so we have to keep track of what environment we're in. */
908
909 if( w->flags & WIN_ISWIN32 )
910 {
911 #define ccs ((LPCLIENTCREATESTRUCT32)cs->lpCreateParams)
912 ci->hWindowMenu = ccs->hWindowMenu;
913 ci->idFirstChild = ccs->idFirstChild;
914 #undef ccs
915 }
916 else
917 {
918 LPCLIENTCREATESTRUCT16 ccs = (LPCLIENTCREATESTRUCT16)
919 PTR_SEG_TO_LIN(cs->lpCreateParams);
920 ci->hWindowMenu = ccs->hWindowMenu;
921 ci->idFirstChild = ccs->idFirstChild;
922 }
923
924 ci->hwndChildMaximized = 0;
925 ci->nActiveChildren = 0;
926 ci->nTotalCreated = 0;
927 ci->frameTitle = NULL;
928 ci->mdiFlags = 0;
929 ci->self = hwnd;
930 w->dwStyle |= WS_CLIPCHILDREN;
931
932 if (!hBmpClose)
933 {
934 hBmpClose = CreateMDIMenuBitmap();
935 hBmpRestore = LoadBitmap16( 0, MAKEINTRESOURCE16(OBM_RESTORE) );
936 }
937 MDI_UpdateFrameText(frameWnd, hwnd, MDI_NOFRAMEREPAINT,frameWnd->text);
938
939 AppendMenu32A( ci->hWindowMenu, MF_SEPARATOR, 0, NULL );
940
941 GetClientRect32(frameWnd->hwndSelf, &rect);
942 NC_HandleNCCalcSize( w, &rect );
943 w->rectClient = rect;
944
945 TRACE(mdi,"Client created - hwnd = %04x, idFirst = %u\n",
946 hwnd, ci->idFirstChild );
947
948 return 0;
949
950 case WM_DESTROY:
951 if( ci->hwndChildMaximized ) MDI_RestoreFrameMenu(w, frameWnd->hwndSelf);
952 if((nItems = GetMenuItemCount32(ci->hWindowMenu)) > 0)
953 {
954 ci->idFirstChild = nItems - 1;
955 ci->nActiveChildren++; /* to delete a separator */
956 while( ci->nActiveChildren-- )
957 DeleteMenu32(ci->hWindowMenu,MF_BYPOSITION,ci->idFirstChild--);
958 }
959 return 0;
960
961 case WM_MDIACTIVATE:
962 if( ci->hwndActiveChild != (HWND32)wParam )
963 SetWindowPos32((HWND32)wParam, 0,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE);
964 return 0;
965
966 case WM_MDICASCADE:
967 return MDICascade(w, ci);
968
969 case WM_MDICREATE:
970 if (lParam) return MDICreateChild( w, ci, hwnd,
971 (MDICREATESTRUCT32A*)lParam );
972 return 0;
973
974 case WM_MDIDESTROY:
975 return MDIDestroyChild( w, ci, hwnd, (HWND32)wParam, TRUE );
976
977 case WM_MDIGETACTIVE:
978 if (lParam) *(BOOL32 *)lParam = (ci->hwndChildMaximized > 0);
979 return ci->hwndActiveChild;
980
981 case WM_MDIICONARRANGE:
982 ci->mdiFlags |= MDIF_NEEDUPDATE;
983 ArrangeIconicWindows32(hwnd);
984 ci->sbRecalc = SB_BOTH+1;
985 SendMessage32A(hwnd, WM_MDICALCCHILDSCROLL, 0, 0L);
986 return 0;
987
988 case WM_MDIMAXIMIZE:
989 ShowWindow32( (HWND32)wParam, SW_MAXIMIZE );
990 return 0;
991
992 case WM_MDINEXT: /* lParam != 0 means previous window */
993 MDI_SwitchActiveChild(hwnd, (HWND32)wParam, (lParam)? FALSE : TRUE );
994 break;
995
996 case WM_MDIRESTORE:
997 ShowWindow32( (HWND32)wParam, SW_NORMAL);
998 return 0;
999
1000 case WM_MDISETMENU:
1001 return MDISetMenu( hwnd, (HMENU32)wParam, (HMENU32)lParam );
1002
1003 case WM_MDIREFRESHMENU:
1004 return MDIRefreshMenu( hwnd, (HMENU32)wParam, (HMENU32)lParam );
1005
1006 case WM_MDITILE:
1007 ci->mdiFlags |= MDIF_NEEDUPDATE;
1008 ShowScrollBar32(hwnd,SB_BOTH,FALSE);
1009 MDITile(w, ci, wParam);
1010 ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1011 return 0;
1012
1013 case WM_VSCROLL:
1014 case WM_HSCROLL:
1015 ci->mdiFlags |= MDIF_NEEDUPDATE;
1016 ScrollChildren32(hwnd, message, wParam, lParam);
1017 ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1018 return 0;
1019
1020 case WM_SETFOCUS:
1021 if( ci->hwndActiveChild )
1022 {
1023 w = WIN_FindWndPtr( ci->hwndActiveChild );
1024 if( !(w->dwStyle & WS_MINIMIZE) )
1025 SetFocus32( ci->hwndActiveChild );
1026 }
1027 return 0;
1028
1029 case WM_NCACTIVATE:
1030 if( ci->hwndActiveChild )
1031 SendMessage32A(ci->hwndActiveChild, message, wParam, lParam);
1032 break;
1033
1034 case WM_PARENTNOTIFY:
1035 if (LOWORD(wParam) == WM_LBUTTONDOWN)
1036 {
1037 POINT16 pt = MAKEPOINT16(lParam);
1038 HWND16 child = ChildWindowFromPoint16(hwnd, pt);
1039
1040 TRACE(mdi,"notification from %04x (%i,%i)\n",child,pt.x,pt.y);
1041
1042 if( child && child != hwnd && child != ci->hwndActiveChild )
1043 SetWindowPos32(child, 0,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE );
1044 }
1045 return 0;
1046
1047 case WM_SIZE:
1048 if( ci->hwndChildMaximized )
1049 {
1050 WND* child = WIN_FindWndPtr(ci->hwndChildMaximized);
1051 RECT32 rect = { 0, 0, LOWORD(lParam), HIWORD(lParam) };
1052
1053 AdjustWindowRectEx32(&rect, child->dwStyle, 0, child->dwExStyle);
1054 MoveWindow32(ci->hwndChildMaximized, rect.left, rect.top,
1055 rect.right - rect.left, rect.bottom - rect.top, 1);
1056 }
1057 else
1058 MDI_PostUpdate(hwnd, ci, SB_BOTH+1);
1059
1060 break;
1061
1062 case WM_MDICALCCHILDSCROLL:
1063 if( (ci->mdiFlags & MDIF_NEEDUPDATE) && ci->sbRecalc )
1064 {
1065 CalcChildScroll(hwnd, ci->sbRecalc-1);
1066 ci->sbRecalc = 0;
1067 ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1068 }
1069 return 0;
1070 }
1071
1072 return DefWindowProc32A( hwnd, message, wParam, lParam );
1073 }
1074
1075
1076 /***********************************************************************
1077 * DefFrameProc16 (USER.445)
1078 */
1079 LRESULT WINAPI DefFrameProc16( HWND16 hwnd, HWND16 hwndMDIClient,
1080 UINT16 message, WPARAM16 wParam, LPARAM lParam )
1081 {
1082 HWND16 childHwnd;
1083 MDICLIENTINFO* ci;
1084 WND* wndPtr;
1085
1086 if (hwndMDIClient)
1087 {
1088 switch (message)
1089 {
1090 case WM_COMMAND:
1091 wndPtr = WIN_FindWndPtr(hwndMDIClient);
1092 ci = (MDICLIENTINFO*)wndPtr->wExtra;
1093
1094 /* check for possible syscommands for maximized MDI child */
1095
1096 if( ci && (
1097 wParam < ci->idFirstChild ||
1098 wParam >= ci->idFirstChild + ci->nActiveChildren
1099 )){
1100 if( (wParam - 0xF000) & 0xF00F ) break;
1101 switch( wParam )
1102 {
1103 case SC_SIZE:
1104 case SC_MOVE:
1105 case SC_MINIMIZE:
1106 case SC_MAXIMIZE:
1107 case SC_NEXTWINDOW:
1108 case SC_PREVWINDOW:
1109 case SC_CLOSE:
1110 case SC_RESTORE:
1111 if( ci->hwndChildMaximized )
1112 return SendMessage16( ci->hwndChildMaximized, WM_SYSCOMMAND,
1113 wParam, lParam);
1114 }
1115 }
1116 else
1117 {
1118 childHwnd = MDI_GetChildByID( WIN_FindWndPtr(hwndMDIClient),
1119 wParam );
1120 if( childHwnd )
1121 SendMessage16(hwndMDIClient, WM_MDIACTIVATE,
1122 (WPARAM16)childHwnd , 0L);
1123 }
1124 break;
1125
1126 case WM_NCACTIVATE:
1127 SendMessage16(hwndMDIClient, message, wParam, lParam);
1128 break;
1129
1130 case WM_SETTEXT:
1131 MDI_UpdateFrameText(WIN_FindWndPtr(hwnd), hwndMDIClient,
1132 MDI_REPAINTFRAME,
1133 (LPCSTR)PTR_SEG_TO_LIN(lParam));
1134 return 0;
1135
1136 case WM_SETFOCUS:
1137 SetFocus32(hwndMDIClient);
1138 break;
1139
1140 case WM_SIZE:
1141 MoveWindow16(hwndMDIClient, 0, 0,
1142 LOWORD(lParam), HIWORD(lParam), TRUE);
1143 break;
1144
1145 case WM_NEXTMENU:
1146
1147 wndPtr = WIN_FindWndPtr(hwndMDIClient);
1148 ci = (MDICLIENTINFO*)wndPtr->wExtra;
1149
1150 if( !(wndPtr->parent->dwStyle & WS_MINIMIZE)
1151 && ci->hwndActiveChild && !ci->hwndChildMaximized )
1152 {
1153 /* control menu is between the frame system menu and
1154 * the first entry of menu bar */
1155
1156 if( (wParam == VK_LEFT &&
1157 wndPtr->parent->wIDmenu == LOWORD(lParam)) ||
1158 (wParam == VK_RIGHT &&
1159 GetSubMenu16(wndPtr->parent->hSysMenu, 0) == LOWORD(lParam)) )
1160 {
1161 wndPtr = WIN_FindWndPtr(ci->hwndActiveChild);
1162 return MAKELONG( GetSubMenu16(wndPtr->hSysMenu, 0),
1163 ci->hwndActiveChild);
1164 }
1165 }
1166 break;
1167 }
1168 }
1169
1170 return DefWindowProc16(hwnd, message, wParam, lParam);
1171 }
1172
1173
1174 /***********************************************************************
1175 * DefFrameProc32A (USER32.122)
1176 */
1177 LRESULT WINAPI DefFrameProc32A( HWND32 hwnd, HWND32 hwndMDIClient,
1178 UINT32 message, WPARAM32 wParam, LPARAM lParam)
1179 {
1180 if (hwndMDIClient)
1181 {
1182 switch (message)
1183 {
1184 case WM_COMMAND:
1185 return DefFrameProc16( hwnd, hwndMDIClient, message,
1186 (WPARAM16)wParam,
1187 MAKELPARAM( (HWND16)lParam, HIWORD(wParam) ) );
1188
1189 case WM_NCACTIVATE:
1190 SendMessage32A(hwndMDIClient, message, wParam, lParam);
1191 break;
1192
1193 case WM_SETTEXT: {
1194 LRESULT ret;
1195 LPSTR segstr = SEGPTR_STRDUP((LPSTR)lParam);
1196
1197 ret = DefFrameProc16(hwnd, hwndMDIClient, message,
1198 wParam, (LPARAM)SEGPTR_GET(segstr) );
1199 SEGPTR_FREE(segstr);
1200 return ret;
1201 }
1202
1203 case WM_SETFOCUS:
1204 case WM_SIZE:
1205 return DefFrameProc16( hwnd, hwndMDIClient, message,
1206 wParam, lParam );
1207 }
1208 }
1209
1210 return DefWindowProc32A(hwnd, message, wParam, lParam);
1211 }
1212
1213
1214 /***********************************************************************
1215 * DefFrameProc32W (USER32.123)
1216 */
1217 LRESULT WINAPI DefFrameProc32W( HWND32 hwnd, HWND32 hwndMDIClient,
1218 UINT32 message, WPARAM32 wParam, LPARAM lParam)
1219 {
1220 if (hwndMDIClient)
1221 {
1222 switch (message)
1223 {
1224 case WM_COMMAND:
1225 return DefFrameProc16( hwnd, hwndMDIClient, message,
1226 (WPARAM16)wParam,
1227 MAKELPARAM( (HWND16)lParam, HIWORD(wParam) ) );
1228
1229 case WM_NCACTIVATE:
1230 SendMessage32W(hwndMDIClient, message, wParam, lParam);
1231 break;
1232
1233 case WM_SETTEXT:
1234 {
1235 LPSTR txt = HEAP_strdupWtoA(GetProcessHeap(),0,(LPWSTR)lParam);
1236 LRESULT ret = DefFrameProc32A( hwnd, hwndMDIClient, message,
1237 wParam, (DWORD)txt );
1238 HeapFree(GetProcessHeap(),0,txt);
1239 return ret;
1240 }
1241 case WM_SETFOCUS:
1242 case WM_SIZE:
1243 return DefFrameProc32A( hwnd, hwndMDIClient, message,
1244 wParam, lParam );
1245 }
1246 }
1247
1248 return DefWindowProc32W( hwnd, message, wParam, lParam );
1249 }
1250
1251
1252 /***********************************************************************
1253 * DefMDIChildProc16 (USER.447)
1254 */
1255 LRESULT WINAPI DefMDIChildProc16( HWND16 hwnd, UINT16 message,
1256 WPARAM16 wParam, LPARAM lParam )
1257 {
1258 MDICLIENTINFO *ci;
1259 WND *clientWnd;
1260
1261 clientWnd = WIN_FindWndPtr(GetParent16(hwnd));
1262 ci = (MDICLIENTINFO *) clientWnd->wExtra;
1263
1264 switch (message)
1265 {
1266 case WM_SETTEXT:
1267 DefWindowProc16(hwnd, message, wParam, lParam);
1268 MDI_MenuModifyItem(clientWnd,hwnd);
1269 if( ci->hwndChildMaximized == hwnd )
1270 MDI_UpdateFrameText( clientWnd->parent, ci->self,
1271 MDI_REPAINTFRAME, NULL );
1272 return 0;
1273
1274 case WM_CLOSE:
1275 SendMessage16(ci->self,WM_MDIDESTROY,(WPARAM16)hwnd,0L);
1276 return 0;
1277
1278 case WM_SETFOCUS:
1279 if( ci->hwndActiveChild != hwnd )
1280 MDI_ChildActivate(clientWnd, hwnd);
1281 break;
1282
1283 case WM_CHILDACTIVATE:
1284 MDI_ChildActivate(clientWnd, hwnd);
1285 return 0;
1286
1287 case WM_NCPAINT:
1288 TRACE(mdi,"WM_NCPAINT for %04x, active %04x\n",
1289 hwnd, ci->hwndActiveChild );
1290 break;
1291
1292 case WM_SYSCOMMAND:
1293 switch( wParam )
1294 {
1295 case SC_MOVE:
1296 if( ci->hwndChildMaximized == hwnd) return 0;
1297 break;
1298 case SC_RESTORE:
1299 case SC_MINIMIZE:
1300 WIN_FindWndPtr(hwnd)->dwStyle |= WS_SYSMENU;
1301 break;
1302 case SC_MAXIMIZE:
1303 if( ci->hwndChildMaximized == hwnd)
1304 return SendMessage16( clientWnd->parent->hwndSelf,
1305 message, wParam, lParam);
1306 WIN_FindWndPtr(hwnd)->dwStyle &= ~WS_SYSMENU;
1307 break;
1308 case SC_NEXTWINDOW:
1309 SendMessage16( ci->self, WM_MDINEXT, 0, 0);
1310 return 0;
1311 case SC_PREVWINDOW:
1312 SendMessage16( ci->self, WM_MDINEXT, 0, 1);
1313 return 0;
1314 }
1315 break;
1316
1317 case WM_GETMINMAXINFO:
1318 MDI_ChildGetMinMaxInfo(clientWnd, hwnd, (MINMAXINFO16*) PTR_SEG_TO_LIN(lParam));
1319 return 0;
1320
1321 case WM_SETVISIBLE:
1322 if( ci->hwndChildMaximized) ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1323 else
1324 MDI_PostUpdate(clientWnd->hwndSelf, ci, SB_BOTH+1);
1325 break;
1326
1327 case WM_SIZE:
1328 /* do not change */
1329
1330 if( ci->hwndActiveChild == hwnd && wParam != SIZE_MAXIMIZED )
1331 {
1332 ci->hwndChildMaximized = 0;
1333
1334 MDI_RestoreFrameMenu( clientWnd->parent, hwnd);
1335 MDI_UpdateFrameText( clientWnd->parent, ci->self,
1336 MDI_REPAINTFRAME, NULL );
1337 }
1338
1339 if( wParam == SIZE_MAXIMIZED )
1340 {
1341 HWND16 hMaxChild = ci->hwndChildMaximized;
1342
1343 if( hMaxChild == hwnd ) break;
1344
1345 if( hMaxChild)
1346 {
1347 SendMessage16( hMaxChild, WM_SETREDRAW, FALSE, 0L );
1348
1349 MDI_RestoreFrameMenu( clientWnd->parent, hMaxChild);
1350 ShowWindow16( hMaxChild, SW_SHOWNOACTIVATE);
1351
1352 SendMessage16( hMaxChild, WM_SETREDRAW, TRUE, 0L );
1353 }
1354
1355 TRACE(mdi,"maximizing child %04x\n", hwnd );
1356
1357 ci->hwndChildMaximized = hwnd; /* !!! */
1358
1359 MDI_AugmentFrameMenu( ci, clientWnd->parent, hwnd);
1360 MDI_UpdateFrameText( clientWnd->parent, ci->self,
1361 MDI_REPAINTFRAME, NULL );
1362 }
1363
1364 if( wParam == SIZE_MINIMIZED )
1365 {
1366 HWND16 switchTo = MDI_GetWindow(clientWnd, hwnd, TRUE, WS_MINIMIZE);
1367
1368 if( switchTo )
1369 SendMessage16( switchTo, WM_CHILDACTIVATE, 0, 0L);
1370 }
1371
1372 MDI_PostUpdate(clientWnd->hwndSelf, ci, SB_BOTH+1);
1373 break;
1374
1375 case WM_MENUCHAR:
1376
1377 /* MDI children don't have menu bars */
1378 PostMessage16( clientWnd->parent->hwndSelf, WM_SYSCOMMAND,
1379 (WPARAM16)SC_KEYMENU, (LPARAM)wParam);
1380 return 0x00010000L;
1381
1382 case WM_NEXTMENU:
1383
1384 if( wParam == VK_LEFT ) /* switch to frame system menu */
1385 return MAKELONG( GetSubMenu16(clientWnd->parent->hSysMenu, 0),
1386 clientWnd->parent->hwndSelf );
1387 if( wParam == VK_RIGHT ) /* to frame menu bar */
1388 return MAKELONG( clientWnd->parent->wIDmenu,
1389 clientWnd->parent->hwndSelf );
1390
1391 break;
1392 }
1393
1394 return DefWindowProc16(hwnd, message, wParam, lParam);
1395 }
1396
1397
1398 /***********************************************************************
1399 * DefMDIChildProc32A (USER32.124)
1400 */
1401 LRESULT WINAPI DefMDIChildProc32A( HWND32 hwnd, UINT32 message,
1402 WPARAM32 wParam, LPARAM lParam )
1403 {
1404 MDICLIENTINFO *ci;
1405 WND *clientWnd;
1406
1407 clientWnd = WIN_FindWndPtr(WIN_FindWndPtr(hwnd)->parent->hwndSelf);
1408 ci = (MDICLIENTINFO *) clientWnd->wExtra;
1409
1410 switch (message)
1411 {
1412 case WM_SETTEXT:
1413 DefWindowProc32A(hwnd, message, wParam, lParam);
1414 MDI_MenuModifyItem(clientWnd,hwnd);
1415 if( ci->hwndChildMaximized == hwnd )
1416 MDI_UpdateFrameText( clientWnd->parent, ci->self,
1417 MDI_REPAINTFRAME, NULL );
1418 return 0;
1419
1420 case WM_GETMINMAXINFO:
1421 {
1422 MINMAXINFO16 mmi;
1423 STRUCT32_MINMAXINFO32to16( (MINMAXINFO32 *)lParam, &mmi );
1424 MDI_ChildGetMinMaxInfo( clientWnd, hwnd, &mmi );
1425 STRUCT32_MINMAXINFO16to32( &mmi, (MINMAXINFO32 *)lParam );
1426 }
1427 return 0;
1428
1429 case WM_MENUCHAR:
1430
1431 /* MDI children don't have menu bars */
1432 PostMessage16( clientWnd->parent->hwndSelf, WM_SYSCOMMAND,
1433 (WPARAM16)SC_KEYMENU, (LPARAM)LOWORD(wParam) );
1434 return 0x00010000L;
1435
1436 case WM_CLOSE:
1437 case WM_SETFOCUS:
1438 case WM_CHILDACTIVATE:
1439 case WM_NCPAINT:
1440 case WM_SYSCOMMAND:
1441 case WM_SETVISIBLE:
1442 case WM_SIZE:
1443 case WM_NEXTMENU:
1444 return DefMDIChildProc16( hwnd, message, (WPARAM16)wParam, lParam );
1445 }
1446 return DefWindowProc32A(hwnd, message, wParam, lParam);
1447 }
1448
1449
1450 /***********************************************************************
1451 * DefMDIChildProc32W (USER32.125)
1452 */
1453 LRESULT WINAPI DefMDIChildProc32W( HWND32 hwnd, UINT32 message,
1454 WPARAM32 wParam, LPARAM lParam )
1455 {
1456 MDICLIENTINFO *ci;
1457 WND *clientWnd;
1458
1459 clientWnd = WIN_FindWndPtr(GetParent16(hwnd));
1460 ci = (MDICLIENTINFO *) clientWnd->wExtra;
1461
1462 switch (message)
1463 {
1464 case WM_SETTEXT:
1465 DefWindowProc32W(hwnd, message, wParam, lParam);
1466 MDI_MenuModifyItem(clientWnd,hwnd);
1467 if( ci->hwndChildMaximized == hwnd )
1468 MDI_UpdateFrameText( clientWnd->parent, ci->self,
1469 MDI_REPAINTFRAME, NULL );
1470 return 0;
1471
1472 case WM_GETMINMAXINFO:
1473 case WM_MENUCHAR:
1474 case WM_CLOSE:
1475 case WM_SETFOCUS:
1476 case WM_CHILDACTIVATE:
1477 case WM_NCPAINT:
1478 case WM_SYSCOMMAND:
1479 case WM_SETVISIBLE:
1480 case WM_SIZE:
1481 case WM_NEXTMENU:
1482 return DefMDIChildProc32A( hwnd, message, (WPARAM16)wParam, lParam );
1483 }
1484 return DefWindowProc32W(hwnd, message, wParam, lParam);
1485 }
1486
1487
1488 /**********************************************************************
1489 * CreateMDIWindowA [USER32.79]
1490 */
1491 HWND32 WINAPI CreateMDIWindowA(
1492 LPCSTR lpClassName,
1493 LPCSTR lpWindowName,
1494 DWORD dwStyle,
1495 INT32 X,
1496 INT32 Y,
1497 INT32 nWidth,
1498 INT32 nHeight,
1499 HWND32 hWndParent,
1500 HINSTANCE32 hInstance,
1501 LPARAM lParam)
1502 {
1503 FIXME(mdi, "(%s,%s,%ld,...): stub\n",debugstr_a(lpClassName),
1504 debugstr_a(lpWindowName),dwStyle);
1505 return (HWND32)NULL;
1506 }
1507
1508
1509 /******************************************************************************
1510 * CreateMDIWindowW [USER32.80] Creates a MDI child window
1511 *
1512 * RETURNS
1513 * Success: Handle to created window
1514 * Failure: NULL
1515 */
1516 HWND32 WINAPI CreateMDIWindowW(
1517 LPCWSTR lpClassName, /* [in] Pointer to registered child class name */
1518 LPCWSTR lpWindowName, /* [in] Pointer to window name */
1519 DWORD dwStyle, /* [in] Window style */
1520 INT32 X, /* [in] Horizontal position of window */
1521 INT32 Y, /* [in] Vertical position of window */
1522 INT32 nWidth, /* [in] Width of window */
1523 INT32 nHeight, /* [in] Height of window */
1524 HWND32 hWndParent, /* [in] Handle to parent window */
1525 HINSTANCE32 hInstance, /* [in] Handle to application instance */
1526 LPARAM lParam) /* [in] Application-defined value */
1527 {
1528 FIXME(mdi, "(%s,%s,%ld,%d,%d,%d,%d,%x,%d,%ld): stub\n",
1529 debugstr_w(lpClassName),debugstr_w(lpWindowName),dwStyle,X,Y,
1530 nWidth,nHeight,hWndParent,hInstance,lParam);
1531 return (HWND32)NULL;
1532 }
1533
1534
1535 /**********************************************************************
1536 * TranslateMDISysAccel32 (USER32.555)
1537 */
1538 BOOL32 WINAPI TranslateMDISysAccel32( HWND32 hwndClient, LPMSG32 msg )
1539 {
1540 MSG16 msg16;
1541
1542 STRUCT32_MSG32to16(msg,&msg16);
1543 /* MDICLIENTINFO is still the same for win32 and win16 ... */
1544 return TranslateMDISysAccel16(hwndClient,&msg16);
1545 }
1546
1547
1548 /**********************************************************************
1549 * TranslateMDISysAccel16 (USER.451)
1550 */
1551 BOOL16 WINAPI TranslateMDISysAccel16( HWND16 hwndClient, LPMSG16 msg )
1552 {
1553 WND* clientWnd = WIN_FindWndPtr( hwndClient);
1554
1555 if( clientWnd && (msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN))
1556 {
1557 MDICLIENTINFO *ci = NULL;
1558 WND* wnd;
1559
1560 ci = (MDICLIENTINFO*) clientWnd->wExtra;
1561 wnd = WIN_FindWndPtr(ci->hwndActiveChild);
1562 if( wnd && !(wnd->dwStyle & WS_DISABLED) )
1563 {
1564 WPARAM16 wParam = 0;
1565
1566 /* translate if the Ctrl key is down and Alt not. */
1567
1568 if( (GetKeyState32(VK_CONTROL) & 0x8000) &&
1569 !(GetKeyState32(VK_MENU) & 0x8000))
1570 {
1571 switch( msg->wParam )
1572 {
1573 case VK_F6:
1574 case VK_TAB:
1575 wParam = ( GetKeyState32(VK_SHIFT) & 0x8000 )
1576 ? SC_NEXTWINDOW : SC_PREVWINDOW;
1577 break;
1578 case VK_F4:
1579 case VK_RBUTTON:
1580 wParam = SC_CLOSE;
1581 break;
1582 default:
1583 return 0;
1584 }
1585 TRACE(mdi,"wParam = %04x\n", wParam);
1586 SendMessage16( ci->hwndActiveChild, WM_SYSCOMMAND,
1587 wParam, (LPARAM)msg->wParam);
1588 return 1;
1589 }
1590 }
1591 }
1592 return 0; /* failure */
1593 }
1594
1595
1596 /***********************************************************************
1597 * CalcChildScroll (USER.462)
1598 */
1599 void WINAPI CalcChildScroll( HWND16 hwnd, WORD scroll )
1600 {
1601 RECT32 childRect, clientRect;
1602 INT32 vmin, vmax, hmin, hmax, vpos, hpos;
1603 WND *pWnd, *Wnd;
1604
1605 if (!(Wnd = pWnd = WIN_FindWndPtr( hwnd ))) return;
1606 GetClientRect32( hwnd, &clientRect );
1607 SetRectEmpty32( &childRect );
1608
1609 for ( pWnd = pWnd->child; pWnd; pWnd = pWnd->next )
1610 {
1611 if( pWnd->dwStyle & WS_MAXIMIZE )
1612 {
1613 ShowScrollBar32(hwnd, SB_BOTH, FALSE);
1614 return;
1615 }
1616 UnionRect32( &childRect, &pWnd->rectWindow, &childRect );
1617 }
1618 UnionRect32( &childRect, &clientRect, &childRect );
1619
1620 /* jump through the hoops to prevent excessive flashing
1621 */
1622
1623 hmin = childRect.left; hmax = childRect.right - clientRect.right;
1624 hpos = clientRect.left - childRect.left;
1625 vmin = childRect.top; vmax = childRect.bottom - clientRect.bottom;
1626 vpos = clientRect.top - childRect.top;
1627
1628 switch( scroll )
1629 {
1630 case SB_HORZ:
1631 vpos = hpos; vmin = hmin; vmax = hmax;
1632 case SB_VERT:
1633 SetScrollPos32(hwnd, scroll, vpos, FALSE);
1634 SetScrollRange32(hwnd, scroll, vmin, vmax, TRUE);
1635 break;
1636 case SB_BOTH:
1637 SCROLL_SetNCSbState( Wnd, vmin, vmax, vpos,
1638 hmin, hmax, hpos);
1639 SetWindowPos32(hwnd, 0, 0, 0, 0, 0, SWP_NOSIZE | SWP_NOMOVE
1640 | SWP_NOACTIVATE | SWP_NOZORDER | SWP_FRAMECHANGED );
1641 }
1642 }
1643
1644
1645 /***********************************************************************
1646 * ScrollChildren16 (USER.463)
1647 */
1648 void WINAPI ScrollChildren16(HWND16 hWnd, UINT16 uMsg, WPARAM16 wParam, LPARAM lParam)
1649 {
1650 return ScrollChildren32( hWnd, uMsg, wParam, lParam );
1651 }
1652
1653
1654 /***********************************************************************
1655 * ScrollChildren32 (USER32.448)
1656 */
1657 void WINAPI ScrollChildren32(HWND32 hWnd, UINT32 uMsg, WPARAM32 wParam,
1658 LPARAM lParam)
1659 {
1660 WND *wndPtr = WIN_FindWndPtr(hWnd);
1661 INT32 newPos = -1;
1662 INT32 curPos, length, minPos, maxPos, shift;
1663
1664 if( !wndPtr ) return;
1665
1666 if( uMsg == WM_HSCROLL )
1667 {
1668 GetScrollRange32(hWnd,SB_HORZ,&minPos,&maxPos);
1669 curPos = GetScrollPos32(hWnd,SB_HORZ);
1670 length = (wndPtr->rectClient.right - wndPtr->rectClient.left)/2;
1671 shift = SYSMETRICS_CYHSCROLL;
1672 }
1673 else if( uMsg == WM_VSCROLL )
1674 {
1675 GetScrollRange32(hWnd,SB_VERT,&minPos,&maxPos);
1676 curPos = GetScrollPos32(hWnd,SB_VERT);
1677 length = (wndPtr->rectClient.bottom - wndPtr->rectClient.top)/2;
1678 shift = SYSMETRICS_CXVSCROLL;
1679 }
1680 else return;
1681
1682 switch( wParam )
1683 {
1684 case SB_LINEUP:
1685 newPos = curPos - shift;
1686 break;
1687 case SB_LINEDOWN:
1688 newPos = curPos + shift;
1689 break;
1690 case SB_PAGEUP:
1691 newPos = curPos - length;
1692 break;
1693 case SB_PAGEDOWN:
1694 newPos = curPos + length;
1695 break;
1696
1697 case SB_THUMBPOSITION:
1698 newPos = LOWORD(lParam);
1699 break;
1700
1701 case SB_THUMBTRACK:
1702 return;
1703
1704 case SB_TOP:
1705 newPos = minPos;
1706 break;
1707 case SB_BOTTOM:
1708 newPos = maxPos;
1709 break;
1710 case SB_ENDSCROLL:
1711 CalcChildScroll(hWnd,(uMsg == WM_VSCROLL)?SB_VERT:SB_HORZ);
1712 return;
1713 }
1714
1715 if( newPos > maxPos )
1716 newPos = maxPos;
1717 else
1718 if( newPos < minPos )
1719 newPos = minPos;
1720
1721 SetScrollPos32(hWnd, (uMsg == WM_VSCROLL)?SB_VERT:SB_HORZ , newPos, TRUE);
1722
1723 if( uMsg == WM_VSCROLL )
1724 ScrollWindowEx32(hWnd ,0 ,curPos - newPos, NULL, NULL, 0, NULL,
1725 SW_INVALIDATE | SW_ERASE | SW_SCROLLCHILDREN );
1726 else
1727 ScrollWindowEx32(hWnd ,curPos - newPos, 0, NULL, NULL, 0, NULL,
1728 SW_INVALIDATE | SW_ERASE | SW_SCROLLCHILDREN );
1729 }
1730
1731
1732 /******************************************************************************
1733 * CascadeWindows [USER32.21] Cascades MDI child windows
1734 *
1735 * RETURNS
1736 * Success: Number of cascaded windows.
1737 * Failure: 0
1738 */
1739 WORD WINAPI
1740 CascadeWindows (HWND32 hwndParent, UINT32 wFlags, const LPRECT32 lpRect,
1741 UINT32 cKids, const HWND32 *lpKids)
1742 {
1743 FIXME (mdi, "(0x%08x,0x%08x,...,%u,...): stub\n",
1744 hwndParent, wFlags, cKids);
1745
1746 return 0;
1747 }
1748
1749
1750 /******************************************************************************
1751 * TileWindows [USER32.545] Tiles MDI child windows
1752 *
1753 * RETURNS
1754 * Success: Number of tiled windows.
1755 * Failure: 0
1756 */
1757 WORD WINAPI
1758 TileWindows (HWND32 hwndParent, UINT32 wFlags, const LPRECT32 lpRect,
1759 UINT32 cKids, const HWND32 *lpKids)
1760 {
1761 FIXME (mdi, "(0x%08x,0x%08x,...,%u,...): stub\n",
1762 hwndParent, wFlags, cKids);
1763
1764 return 0;
1765 }
1766
Maarten's multimedia branch