?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Removed duplicate field in internal structure.
[wine.git] / windows / mdi.c
blob209e9cb84715a2caaa5e4ff2b9f2c72c2124dfc3
1 /* MDI.C
2 *
3 * Copyright 1994, Bob Amstadt
4 * 1995,1996 Alex Korobka
5 *
6 * This file contains routines to support MDI (Multiple Document
7 * Interface) features .
8 *
9 * Notes: Fairly complete implementation.
10 * Also, Excel and WinWord do _not_ use MDI so if you're trying
11 * to fix them look elsewhere.
12 *
13 * Notes on how the "More Windows..." is implemented:
14 *
15 * When we have more than 9 opened windows, a "More Windows..."
16 * option appears in the "Windows" menu. Each child window has
17 * a WND* associated with it, accesible via the children list of
18 * the parent window. This WND* has a wIDmenu member, which reflects
19 * the position of the child in the window list. For example, with
20 * 9 child windows, we could have the following pattern:
21 *
22 *
23 *
24 * Name of the child window pWndChild->wIDmenu
25 * Doc1 5000
26 * Doc2 5001
27 * Doc3 5002
28 * Doc4 5003
29 * Doc5 5004
30 * Doc6 5005
31 * Doc7 5006
32 * Doc8 5007
33 * Doc9 5008
34 *
35 *
36 * The "Windows" menu, as the "More windows..." dialog, are constructed
37 * in this order. If we add a child, we would have the following list:
38 *
39 *
40 * Name of the child window pWndChild->wIDmenu
41 * Doc1 5000
42 * Doc2 5001
43 * Doc3 5002
44 * Doc4 5003
45 * Doc5 5004
46 * Doc6 5005
47 * Doc7 5006
48 * Doc8 5007
49 * Doc9 5008
50 * Doc10 5009
51 *
52 * But only 5000 to 5008 would be displayed in the "Windows" menu. We want
53 * the last created child to be in the menu, so we swap the last child with
54 * the 9th... Doc9 will be accessible via the "More Windows..." option.
55 *
56 * Doc1 5000
57 * Doc2 5001
58 * Doc3 5002
59 * Doc4 5003
60 * Doc5 5004
61 * Doc6 5005
62 * Doc7 5006
63 * Doc8 5007
64 * Doc9 5009
65 * Doc10 5008
66 *
67 */
68
69 #include <stdlib.h>
70 #include <stdio.h>
71 #include <string.h>
72 #include <math.h>
73
74 #include "windef.h"
75 #include "winbase.h"
76 #include "wingdi.h"
77 #include "winuser.h"
78 #include "wine/unicode.h"
79 #include "win.h"
80 #include "heap.h"
81 #include "nonclient.h"
82 #include "controls.h"
83 #include "user.h"
84 #include "struct32.h"
85 #include "tweak.h"
86 #include "debugtools.h"
87 #include "dlgs.h"
88
89 DEFAULT_DEBUG_CHANNEL(mdi);
90
91 #define MDI_MAXLISTLENGTH 0x40
92 #define MDI_MAXTITLELENGTH 0xa1
93
94 #define MDI_NOFRAMEREPAINT 0
95 #define MDI_REPAINTFRAMENOW 1
96 #define MDI_REPAINTFRAME 2
97
98 #define WM_MDICALCCHILDSCROLL 0x10ac /* this is exactly what Windows uses */
99
100 /* "More Windows..." definitions */
101 #define MDI_MOREWINDOWSLIMIT 9 /* after this number of windows, a "More Windows..."
102 option will appear under the Windows menu */
103 #define MDI_IDC_LISTBOX 100
104 #define MDI_IDS_MOREWINDOWS 13
105
106 #define MDIF_NEEDUPDATE 0x0001
107
108 typedef struct
109 {
110 UINT nActiveChildren;
111 HWND hwndChildMaximized;
112 HWND hwndActiveChild;
113 HMENU hWindowMenu;
114 UINT idFirstChild;
115 LPWSTR frameTitle;
116 UINT nTotalCreated;
117 UINT mdiFlags;
118 UINT sbRecalc; /* SB_xxx flags for scrollbar fixup */
119 HWND self;
120 } MDICLIENTINFO;
121
122 static HBITMAP16 hBmpClose = 0;
123 static HBITMAP16 hBmpRestore = 0;
124
125 /* ----------------- declarations ----------------- */
126 static void MDI_UpdateFrameText(WND *, HWND, BOOL, LPCWSTR);
127 static BOOL MDI_AugmentFrameMenu(MDICLIENTINFO*, WND *, HWND);
128 static BOOL MDI_RestoreFrameMenu(WND *, HWND);
129
130 static LONG MDI_ChildActivate( WND*, HWND );
131
132 static HWND MDI_MoreWindowsDialog(WND*);
133 static void MDI_SwapMenuItems(WND *, UINT, UINT);
134 static LRESULT WINAPI MDIClientWndProcA( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam );
135 /* -------- Miscellaneous service functions ----------
136 *
137 * MDI_GetChildByID
138 */
139
140 static HWND MDI_GetChildByID(WND* wndPtr, INT id)
141 {
142 for (wndPtr = wndPtr->child; wndPtr; wndPtr = wndPtr->next)
143 if (wndPtr->wIDmenu == id) return wndPtr->hwndSelf;
144 return 0;
145 }
146
147 static void MDI_PostUpdate(HWND hwnd, MDICLIENTINFO* ci, WORD recalc)
148 {
149 if( !(ci->mdiFlags & MDIF_NEEDUPDATE) )
150 {
151 ci->mdiFlags |= MDIF_NEEDUPDATE;
152 PostMessageA( hwnd, WM_MDICALCCHILDSCROLL, 0, 0);
153 }
154 ci->sbRecalc = recalc;
155 }
156
157
158 /*********************************************************************
159 * MDIClient class descriptor
160 */
161 const struct builtin_class_descr MDICLIENT_builtin_class =
162 {
163 "MDIClient", /* name */
164 CS_GLOBALCLASS, /* style */
165 MDIClientWndProcA, /* procA */
166 NULL, /* procW (FIXME) */
167 sizeof(MDICLIENTINFO), /* extra */
168 IDC_ARROWA, /* cursor */
169 COLOR_APPWORKSPACE+1 /* brush */
170 };
171
172
173 /**********************************************************************
174 * MDI_MenuModifyItem
175 */
176 static BOOL MDI_MenuModifyItem(WND* clientWnd, HWND hWndChild )
177 {
178 WCHAR buffer[128];
179 static const WCHAR format[] = {'%','d',' ',0};
180 MDICLIENTINFO *clientInfo = (MDICLIENTINFO*)clientWnd->wExtra;
181 WND *wndPtr = WIN_FindWndPtr(hWndChild);
182 UINT n = wsprintfW(buffer, format,
183 wndPtr->wIDmenu - clientInfo->idFirstChild + 1);
184 BOOL bRet = 0;
185
186 if( !clientInfo->hWindowMenu )
187 {
188 bRet = FALSE;
189 goto END;
190 }
191
192 if (wndPtr->text) lstrcpynW(buffer + n, wndPtr->text, sizeof(buffer)/sizeof(WCHAR) - n );
193
194 n = GetMenuState(clientInfo->hWindowMenu,wndPtr->wIDmenu ,MF_BYCOMMAND);
195 bRet = ModifyMenuW(clientInfo->hWindowMenu , wndPtr->wIDmenu,
196 MF_BYCOMMAND | MF_STRING, wndPtr->wIDmenu, buffer );
197 CheckMenuItem(clientInfo->hWindowMenu ,wndPtr->wIDmenu , n & MF_CHECKED);
198 END:
199 WIN_ReleaseWndPtr(wndPtr);
200 return bRet;
201 }
202
203 /**********************************************************************
204 * MDI_MenuDeleteItem
205 */
206 static BOOL MDI_MenuDeleteItem(WND* clientWnd, HWND hWndChild )
207 {
208 WCHAR buffer[128];
209 static const WCHAR format[] = {'&','%','d',' ',0};
210 MDICLIENTINFO *clientInfo = (MDICLIENTINFO*)clientWnd->wExtra;
211 WND *wndPtr = WIN_FindWndPtr(hWndChild);
212 UINT index = 0,id,n;
213 BOOL retvalue;
214
215 if( !clientInfo->nActiveChildren ||
216 !clientInfo->hWindowMenu )
217 {
218 retvalue = FALSE;
219 goto END;
220 }
221
222 id = wndPtr->wIDmenu;
223 DeleteMenu(clientInfo->hWindowMenu,id,MF_BYCOMMAND);
224
225 /* walk the rest of MDI children to prevent gaps in the id
226 * sequence and in the menu child list */
227
228 for( index = id+1; index <= clientInfo->nActiveChildren +
229 clientInfo->idFirstChild; index++ )
230 {
231 WND *tmpWnd = WIN_FindWndPtr(MDI_GetChildByID(clientWnd,index));
232 if( !tmpWnd )
233 {
234 TRACE("no window for id=%i\n",index);
235 WIN_ReleaseWndPtr(tmpWnd);
236 continue;
237 }
238
239 /* set correct id */
240 tmpWnd->wIDmenu--;
241
242 n = wsprintfW(buffer, format ,index - clientInfo->idFirstChild);
243 if (tmpWnd->text)
244 lstrcpynW(buffer + n, tmpWnd->text, sizeof(buffer)/sizeof(WCHAR) - n );
245
246 /* change menu if the current child is to be shown in the
247 * "Windows" menu
248 */
249 if (index <= clientInfo->idFirstChild + MDI_MOREWINDOWSLIMIT)
250 ModifyMenuW(clientInfo->hWindowMenu ,index ,MF_BYCOMMAND | MF_STRING,
251 index - 1 , buffer );
252 WIN_ReleaseWndPtr(tmpWnd);
253 }
254
255 /* We must restore the "More Windows..." option if there is enough child
256 */
257 if (clientInfo->nActiveChildren - 1 > MDI_MOREWINDOWSLIMIT)
258 {
259 char szTmp[50];
260 LoadStringA(GetModuleHandleA("USER32"), MDI_IDS_MOREWINDOWS, szTmp, 50);
261
262 AppendMenuA(clientInfo->hWindowMenu ,MF_STRING ,clientInfo->idFirstChild + MDI_MOREWINDOWSLIMIT, szTmp );
263 }
264 retvalue = TRUE;
265 END:
266 WIN_ReleaseWndPtr(wndPtr);
267 return retvalue;
268 }
269
270 /**********************************************************************
271 * MDI_GetWindow
272 *
273 * returns "activateable" child different from the current or zero
274 */
275 static HWND MDI_GetWindow(WND *clientWnd, HWND hWnd, BOOL bNext,
276 DWORD dwStyleMask )
277 {
278 MDICLIENTINFO *clientInfo = (MDICLIENTINFO*)clientWnd->wExtra;
279 WND *wndPtr, *pWnd, *pWndLast = NULL;
280
281 dwStyleMask |= WS_DISABLED | WS_VISIBLE;
282 if( !hWnd ) hWnd = clientInfo->hwndActiveChild;
283
284 if( !(wndPtr = WIN_FindWndPtr(hWnd)) ) return 0;
285
286 for ( pWnd = WIN_LockWndPtr(wndPtr->next); ; WIN_UpdateWndPtr(&pWnd,pWnd->next))
287 {
288 if (!pWnd ) WIN_UpdateWndPtr(&pWnd,wndPtr->parent->child);
289
290 if ( pWnd == wndPtr ) break; /* went full circle */
291
292 if (!pWnd->owner && (pWnd->dwStyle & dwStyleMask) == WS_VISIBLE )
293 {
294 pWndLast = pWnd;
295 if ( bNext ) break;
296 }
297 }
298 WIN_ReleaseWndPtr(wndPtr);
299 WIN_ReleaseWndPtr(pWnd);
300 return pWndLast ? pWndLast->hwndSelf : 0;
301 }
302
303 /**********************************************************************
304 * MDI_CalcDefaultChildPos
305 *
306 * It seems that the default height is about 2/3 of the client rect
307 */
308 static void MDI_CalcDefaultChildPos( WND* w, WORD n, LPPOINT lpPos,
309 INT delta)
310 {
311 INT nstagger;
312 RECT rect = w->rectClient;
313 INT spacing = GetSystemMetrics(SM_CYCAPTION) +
314 GetSystemMetrics(SM_CYFRAME) - 1;
315
316 if( rect.bottom - rect.top - delta >= spacing )
317 rect.bottom -= delta;
318
319 nstagger = (rect.bottom - rect.top)/(3 * spacing);
320 lpPos[1].x = (rect.right - rect.left - nstagger * spacing);
321 lpPos[1].y = (rect.bottom - rect.top - nstagger * spacing);
322 lpPos[0].x = lpPos[0].y = spacing * (n%(nstagger+1));
323 }
324
325 /**********************************************************************
326 * MDISetMenu
327 */
328 static LRESULT MDISetMenu( HWND hwnd, HMENU hmenuFrame,
329 HMENU hmenuWindow)
330 {
331 WND *w;
332 MDICLIENTINFO *ci;
333 HWND hwndFrame = GetParent(hwnd);
334 HMENU oldFrameMenu = GetMenu(hwndFrame);
335
336 TRACE("%04x %04x %04x\n",
337 hwnd, hmenuFrame, hmenuWindow);
338
339 if (hmenuFrame && !IsMenu(hmenuFrame))
340 {
341 WARN("hmenuFrame is not a menu handle\n");
342 return 0L;
343 }
344
345 if (hmenuWindow && !IsMenu(hmenuWindow))
346 {
347 WARN("hmenuWindow is not a menu handle\n");
348 return 0L;
349 }
350
351 w = WIN_FindWndPtr(hwnd);
352 ci = (MDICLIENTINFO *) w->wExtra;
353
354 if( ci->hwndChildMaximized && hmenuFrame && hmenuFrame!=oldFrameMenu )
355 MDI_RestoreFrameMenu(w->parent, ci->hwndChildMaximized );
356
357 if( hmenuWindow && ci->hWindowMenu && hmenuWindow!=ci->hWindowMenu )
358 {
359 /* delete menu items from ci->hWindowMenu
360 * and add them to hmenuWindow */
361
362 INT i = GetMenuItemCount(ci->hWindowMenu) - 1;
363 INT pos = GetMenuItemCount(hmenuWindow) + 1;
364
365 AppendMenuA( hmenuWindow, MF_SEPARATOR, 0, NULL);
366
367 if( ci->nActiveChildren )
368 {
369 INT j;
370 LPWSTR buffer = NULL;
371 MENUITEMINFOW mii;
372 INT nbWindowsMenuItems; /* num of documents shown + "More Windows..." if present */
373
374 if (ci->nActiveChildren <= MDI_MOREWINDOWSLIMIT)
375 nbWindowsMenuItems = ci->nActiveChildren;
376 else
377 nbWindowsMenuItems = MDI_MOREWINDOWSLIMIT + 1;
378
379 j = i - nbWindowsMenuItems + 1;
380
381 for( ; i >= j ; i-- )
382 {
383 memset(&mii, 0, sizeof(mii));
384 mii.cbSize = sizeof(mii);
385 mii.fMask = MIIM_CHECKMARKS | MIIM_DATA | MIIM_ID | MIIM_STATE
386 | MIIM_SUBMENU | MIIM_TYPE | MIIM_BITMAP;
387
388 GetMenuItemInfoW(ci->hWindowMenu, i, TRUE, &mii);
389 if(mii.cch) { /* Menu is MFT_STRING */
390 mii.cch++; /* add room for '\0' */
391 buffer = HeapAlloc(GetProcessHeap(), 0,
392 mii.cch * sizeof(WCHAR));
393 mii.dwTypeData = buffer;
394 GetMenuItemInfoW(ci->hWindowMenu, i, TRUE, &mii);
395 }
396 DeleteMenu(ci->hWindowMenu, i, MF_BYPOSITION);
397 InsertMenuItemW(hmenuWindow, pos, TRUE, &mii);
398 if(buffer) {
399 HeapFree(GetProcessHeap(), 0, buffer);
400 buffer = NULL;
401 }
402 }
403 }
404
405 /* remove separator */
406 DeleteMenu(ci->hWindowMenu, i, MF_BYPOSITION);
407
408 ci->hWindowMenu = hmenuWindow;
409 }
410
411 if (hmenuFrame)
412 {
413 SetMenu(hwndFrame, hmenuFrame);
414 if( hmenuFrame!=oldFrameMenu )
415 {
416 if( ci->hwndChildMaximized )
417 MDI_AugmentFrameMenu(ci, w->parent, ci->hwndChildMaximized );
418 WIN_ReleaseWndPtr(w);
419 return oldFrameMenu;
420 }
421 }
422 else
423 {
424 INT nItems = GetMenuItemCount(w->parent->wIDmenu) - 1;
425 UINT iId = GetMenuItemID(w->parent->wIDmenu,nItems) ;
426
427 if( !(iId == SC_RESTORE || iId == SC_CLOSE) )
428 {
429 /* SetMenu() may already have been called, meaning that this window
430 * already has its menu. But they may have done a SetMenu() on
431 * an MDI window, and called MDISetMenu() after the fact, meaning
432 * that the "if" to this "else" wouldn't catch the need to
433 * augment the frame menu.
434 */
435 if( ci->hwndChildMaximized )
436 MDI_AugmentFrameMenu(ci, w->parent, ci->hwndChildMaximized );
437 }
438 }
439 WIN_ReleaseWndPtr(w);
440 return 0;
441 }
442
443 /**********************************************************************
444 * MDIRefreshMenu
445 */
446 static LRESULT MDIRefreshMenu( HWND hwnd, HMENU hmenuFrame,
447 HMENU hmenuWindow)
448 {
449 HWND hwndFrame = GetParent(hwnd);
450 HMENU oldFrameMenu = GetMenu(hwndFrame);
451
452 TRACE("%04x %04x %04x\n",
453 hwnd, hmenuFrame, hmenuWindow);
454
455 FIXME("partially function stub\n");
456
457 return oldFrameMenu;
458 }
459
460
461 /* ------------------ MDI child window functions ---------------------- */
462
463
464 /**********************************************************************
465 * MDICreateChild
466 */
467 static HWND MDICreateChild( WND *w, MDICLIENTINFO *ci, HWND parent,
468 LPMDICREATESTRUCTA cs )
469 {
470 POINT pos[2];
471 DWORD style = cs->style | (WS_CHILD | WS_CLIPSIBLINGS);
472 HWND hwnd, hwndMax = 0;
473 WORD wIDmenu = ci->idFirstChild + ci->nActiveChildren;
474 char lpstrDef[]="junk!";
475
476 TRACE("origin %i,%i - dim %i,%i, style %08lx\n",
477 cs->x, cs->y, cs->cx, cs->cy, cs->style);
478 /* calculate placement */
479 MDI_CalcDefaultChildPos(w, ci->nTotalCreated++, pos, 0);
480
481 if (cs->cx == CW_USEDEFAULT || !cs->cx) cs->cx = pos[1].x;
482 if (cs->cy == CW_USEDEFAULT || !cs->cy) cs->cy = pos[1].y;
483
484 if( cs->x == CW_USEDEFAULT )
485 {
486 cs->x = pos[0].x;
487 cs->y = pos[0].y;
488 }
489
490 /* restore current maximized child */
491 if( (style & WS_VISIBLE) && ci->hwndChildMaximized )
492 {
493 TRACE("Restoring current maximized child %04x\n", ci->hwndChildMaximized);
494 if( style & WS_MAXIMIZE )
495 SendMessageA(w->hwndSelf, WM_SETREDRAW, FALSE, 0L );
496 hwndMax = ci->hwndChildMaximized;
497 ShowWindow( hwndMax, SW_SHOWNOACTIVATE );
498 if( style & WS_MAXIMIZE )
499 SendMessageA(w->hwndSelf, WM_SETREDRAW, TRUE, 0L );
500 }
501
502 if (ci->nActiveChildren <= MDI_MOREWINDOWSLIMIT)
503 /* this menu is needed to set a check mark in MDI_ChildActivate */
504 if (ci->hWindowMenu != 0)
505 AppendMenuA(ci->hWindowMenu ,MF_STRING ,wIDmenu, lpstrDef );
506
507 ci->nActiveChildren++;
508
509 /* fix window style */
510 if( !(w->dwStyle & MDIS_ALLCHILDSTYLES) )
511 {
512 TRACE("MDIS_ALLCHILDSTYLES is missing, fixing window style\n");
513 style &= (WS_CHILD | WS_CLIPSIBLINGS | WS_MINIMIZE | WS_MAXIMIZE |
514 WS_CLIPCHILDREN | WS_DISABLED | WS_VSCROLL | WS_HSCROLL );
515 style |= (WS_VISIBLE | WS_OVERLAPPEDWINDOW);
516 }
517
518 if( w->flags & WIN_ISWIN32 )
519 {
520 hwnd = CreateWindowA( cs->szClass, cs->szTitle, style,
521 cs->x, cs->y, cs->cx, cs->cy, parent,
522 (HMENU)wIDmenu, cs->hOwner, cs );
523 }
524 else
525 {
526 MDICREATESTRUCT16 *cs16;
527 LPSTR title, cls;
528
529 cs16 = SEGPTR_NEW(MDICREATESTRUCT16);
530 STRUCT32_MDICREATESTRUCT32Ato16( cs, cs16 );
531 title = SEGPTR_STRDUP( cs->szTitle );
532 cls = SEGPTR_STRDUP( cs->szClass );
533 cs16->szTitle = SEGPTR_GET(title);
534 cs16->szClass = SEGPTR_GET(cls);
535
536 hwnd = CreateWindow16( cs->szClass, cs->szTitle, style,
537 cs16->x, cs16->y, cs16->cx, cs16->cy, parent,
538 (HMENU)wIDmenu, cs16->hOwner,
539 (LPVOID)SEGPTR_GET(cs16) );
540 SEGPTR_FREE( title );
541 SEGPTR_FREE( cls );
542 SEGPTR_FREE( cs16 );
543 }
544
545 /* MDI windows are WS_CHILD so they won't be activated by CreateWindow */
546
547 if (hwnd)
548 {
549 WND* wnd = WIN_FindWndPtr( hwnd );
550
551 /* All MDI child windows have the WS_EX_MDICHILD style */
552 wnd->dwExStyle |= WS_EX_MDICHILD;
553
554 /* If we have more than 9 windows, we must insert the new one at the
555 * 9th position in order to see it in the "Windows" menu
556 */
557 if (ci->nActiveChildren > MDI_MOREWINDOWSLIMIT)
558 MDI_SwapMenuItems(wnd->parent, wnd->wIDmenu, ci->idFirstChild + MDI_MOREWINDOWSLIMIT - 1);
559
560 MDI_MenuModifyItem(w ,hwnd);
561
562 /* Have we hit the "More Windows..." limit? If so, we must
563 * add a "More Windows..." option
564 */
565 if (ci->nActiveChildren == MDI_MOREWINDOWSLIMIT + 1)
566 {
567 char szTmp[50];
568 LoadStringA(GetModuleHandleA("USER32"), MDI_IDS_MOREWINDOWS, szTmp, 50);
569
570 ModifyMenuA(ci->hWindowMenu,
571 ci->idFirstChild + MDI_MOREWINDOWSLIMIT,
572 MF_BYCOMMAND | MF_STRING,
573 ci->idFirstChild + MDI_MOREWINDOWSLIMIT,
574 szTmp);
575 }
576
577 if( (wnd->dwStyle & WS_MINIMIZE) && ci->hwndActiveChild )
578 {
579 TRACE("Minimizing created MDI child %04x\n", hwnd);
580 ShowWindow( hwnd, SW_SHOWMINNOACTIVE );
581 }
582 else
583 {
584 /* WS_VISIBLE is clear if a) the MDI client has
585 * MDIS_ALLCHILDSTYLES style and 2) the flag is cleared in the
586 * MDICreateStruct. If so the created window is not shown nor
587 * activated.
588 */
589 if(wnd->dwStyle & WS_VISIBLE)
590 ShowWindow(hwnd, SW_SHOW);
591 }
592 WIN_ReleaseWndPtr(wnd);
593 TRACE("created child - %04x\n",hwnd);
594 }
595 else
596 {
597 ci->nActiveChildren--;
598 DeleteMenu(ci->hWindowMenu,wIDmenu,MF_BYCOMMAND);
599 if( IsWindow(hwndMax) )
600 ShowWindow(hwndMax, SW_SHOWMAXIMIZED);
601 }
602
603 return hwnd;
604 }
605
606 /**********************************************************************
607 * MDI_ChildGetMinMaxInfo
608 *
609 * Note: The rule here is that client rect of the maximized MDI child
610 * is equal to the client rect of the MDI client window.
611 */
612 static void MDI_ChildGetMinMaxInfo( WND* clientWnd, HWND hwnd,
613 MINMAXINFO16* lpMinMax )
614 {
615 WND* childWnd = WIN_FindWndPtr(hwnd);
616 RECT rect = clientWnd->rectClient;
617
618 MapWindowPoints( clientWnd->parent->hwndSelf,
619 ((MDICLIENTINFO*)clientWnd->wExtra)->self, (LPPOINT)&rect, 2);
620 AdjustWindowRectEx( &rect, childWnd->dwStyle, 0, childWnd->dwExStyle );
621
622 lpMinMax->ptMaxSize.x = rect.right -= rect.left;
623 lpMinMax->ptMaxSize.y = rect.bottom -= rect.top;
624
625 lpMinMax->ptMaxPosition.x = rect.left;
626 lpMinMax->ptMaxPosition.y = rect.top;
627
628 WIN_ReleaseWndPtr(childWnd);
629
630 TRACE("max rect (%i,%i - %i, %i)\n",
631 rect.left,rect.top,rect.right,rect.bottom);
632
633 }
634
635 /**********************************************************************
636 * MDI_SwitchActiveChild
637 *
638 * Note: SetWindowPos sends WM_CHILDACTIVATE to the child window that is
639 * being activated
640 */
641 static void MDI_SwitchActiveChild( HWND clientHwnd, HWND childHwnd,
642 BOOL bNextWindow )
643 {
644 WND *w = WIN_FindWndPtr(clientHwnd);
645 HWND hwndTo = 0;
646 HWND hwndPrev = 0;
647 MDICLIENTINFO *ci;
648
649 hwndTo = MDI_GetWindow(w, childHwnd, bNextWindow, 0);
650
651 ci = (MDICLIENTINFO *) w->wExtra;
652
653 TRACE("from %04x, to %04x\n",childHwnd,hwndTo);
654
655 if ( !hwndTo ) goto END; /* no window to switch to */
656
657 hwndPrev = ci->hwndActiveChild;
658
659 if ( hwndTo != hwndPrev )
660 {
661 BOOL bOptimize = 0;
662
663 if( ci->hwndChildMaximized )
664 {
665 bOptimize = 1;
666 w->dwStyle &= ~WS_VISIBLE;
667 }
668
669 SetWindowPos( hwndTo, HWND_TOP, 0, 0, 0, 0,
670 SWP_NOMOVE | SWP_NOSIZE );
671
672 if( bNextWindow && hwndPrev )
673 SetWindowPos( hwndPrev, HWND_BOTTOM, 0, 0, 0, 0,
674 SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE );
675 if( bOptimize )
676 ShowWindow( clientHwnd, SW_SHOW );
677 }
678 END:
679 WIN_ReleaseWndPtr(w);
680 }
681
682
683 /**********************************************************************
684 * MDIDestroyChild
685 */
686 static LRESULT MDIDestroyChild( WND *w_parent, MDICLIENTINFO *ci,
687 HWND parent, HWND child,
688 BOOL flagDestroy )
689 {
690 WND *childPtr = WIN_FindWndPtr(child);
691
692 if( childPtr )
693 {
694 if( child == ci->hwndActiveChild )
695 {
696 MDI_SwitchActiveChild(parent, child, TRUE);
697
698 if( child == ci->hwndActiveChild )
699 {
700 ShowWindow( child, SW_HIDE);
701 if( child == ci->hwndChildMaximized )
702 {
703 MDI_RestoreFrameMenu(w_parent->parent, child);
704 ci->hwndChildMaximized = 0;
705 MDI_UpdateFrameText(w_parent->parent,parent,TRUE,NULL);
706 }
707
708 MDI_ChildActivate(w_parent, 0);
709 }
710 }
711
712 MDI_MenuDeleteItem(w_parent, child);
713
714 WIN_ReleaseWndPtr(childPtr);
715
716 ci->nActiveChildren--;
717
718 TRACE("child destroyed - %04x\n",child);
719
720 if (flagDestroy)
721 {
722 MDI_PostUpdate(GetParent(child), ci, SB_BOTH+1);
723 DestroyWindow(child);
724 }
725 }
726
727 return 0;
728 }
729
730
731 /**********************************************************************
732 * MDI_ChildActivate
733 *
734 * Note: hWndChild is NULL when last child is being destroyed
735 */
736 static LONG MDI_ChildActivate( WND *clientPtr, HWND hWndChild )
737 {
738 MDICLIENTINFO *clientInfo = (MDICLIENTINFO*)clientPtr->wExtra;
739 HWND prevActiveWnd = clientInfo->hwndActiveChild;
740 WND *wndPtr = WIN_FindWndPtr( hWndChild );
741 WND *wndPrev = WIN_FindWndPtr( prevActiveWnd );
742 BOOL isActiveFrameWnd = 0;
743 LONG retvalue;
744
745 if( wndPtr )
746 {
747 if( wndPtr->dwStyle & WS_DISABLED )
748 {
749 retvalue = 0L;
750 goto END;
751 }
752 }
753
754 /* Don't activate if it is already active. Might happen
755 since ShowWindow DOES activate MDI children */
756 if (clientInfo->hwndActiveChild == hWndChild)
757 {
758 retvalue = 0L;
759 goto END;
760 }
761
762 TRACE("%04x\n", hWndChild);
763
764 if( GetActiveWindow() == clientPtr->parent->hwndSelf )
765 isActiveFrameWnd = TRUE;
766
767 /* deactivate prev. active child */
768 if( wndPrev )
769 {
770 wndPrev->dwStyle |= WS_SYSMENU;
771 SendMessageA( prevActiveWnd, WM_NCACTIVATE, FALSE, 0L );
772 SendMessageA( prevActiveWnd, WM_MDIACTIVATE, (WPARAM)prevActiveWnd,
773 (LPARAM)hWndChild);
774 /* uncheck menu item */
775 if( clientInfo->hWindowMenu )
776 {
777 WORD wPrevID = wndPrev->wIDmenu - clientInfo->idFirstChild;
778
779 if (wPrevID < MDI_MOREWINDOWSLIMIT)
780 CheckMenuItem( clientInfo->hWindowMenu,
781 wndPrev->wIDmenu, 0);
782 else
783 CheckMenuItem( clientInfo->hWindowMenu,
784 clientInfo->idFirstChild + MDI_MOREWINDOWSLIMIT - 1, 0);
785 }
786 }
787
788 /* set appearance */
789 if( clientInfo->hwndChildMaximized )
790 {
791 if( clientInfo->hwndChildMaximized != hWndChild ) {
792 if( hWndChild ) {
793 clientInfo->hwndActiveChild = hWndChild;
794 ShowWindow( hWndChild, SW_SHOWMAXIMIZED);
795 } else
796 ShowWindow( clientInfo->hwndActiveChild, SW_SHOWNORMAL );
797 }
798 }
799
800 clientInfo->hwndActiveChild = hWndChild;
801
802 /* check if we have any children left */
803 if( !hWndChild )
804 {
805 if( isActiveFrameWnd )
806 SetFocus( clientInfo->self );
807 retvalue = 0;
808 goto END;
809 }
810
811 /* check menu item */
812 if( clientInfo->hWindowMenu )
813 {
814 /* The window to be activated must be displayed in the "Windows" menu */
815 if (wndPtr->wIDmenu >= clientInfo->idFirstChild + MDI_MOREWINDOWSLIMIT)
816 {
817 MDI_SwapMenuItems(wndPtr->parent, wndPtr->wIDmenu, clientInfo->idFirstChild + MDI_MOREWINDOWSLIMIT - 1);
818 MDI_MenuModifyItem(wndPtr->parent ,wndPtr->hwndSelf);
819 }
820
821 CheckMenuItem(clientInfo->hWindowMenu, wndPtr->wIDmenu, MF_CHECKED);
822 }
823 /* bring active child to the top */
824 SetWindowPos( hWndChild, 0,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
825
826 if( isActiveFrameWnd )
827 {
828 SendMessageA( hWndChild, WM_NCACTIVATE, TRUE, 0L);
829 if( GetFocus() == clientInfo->self )
830 SendMessageA( clientInfo->self, WM_SETFOCUS,
831 (WPARAM)clientInfo->self, 0L );
832 else
833 SetFocus( clientInfo->self );
834 }
835 SendMessageA( hWndChild, WM_MDIACTIVATE, (WPARAM)prevActiveWnd,
836 (LPARAM)hWndChild );
837 retvalue = 1;
838 END:
839 WIN_ReleaseWndPtr(wndPtr);
840 WIN_ReleaseWndPtr(wndPrev);
841 return retvalue;
842 }
843
844 /* -------------------- MDI client window functions ------------------- */
845
846 /**********************************************************************
847 * CreateMDIMenuBitmap
848 */
849 static HBITMAP16 CreateMDIMenuBitmap(void)
850 {
851 HDC hDCSrc = CreateCompatibleDC(0);
852 HDC hDCDest = CreateCompatibleDC(hDCSrc);
853 HBITMAP16 hbClose = LoadBitmapA(0, MAKEINTRESOURCEA(OBM_CLOSE) );
854 HBITMAP16 hbCopy;
855 HANDLE16 hobjSrc, hobjDest;
856
857 hobjSrc = SelectObject(hDCSrc, hbClose);
858 hbCopy = CreateCompatibleBitmap(hDCSrc,GetSystemMetrics(SM_CXSIZE),GetSystemMetrics(SM_CYSIZE));
859 hobjDest = SelectObject(hDCDest, hbCopy);
860
861 BitBlt(hDCDest, 0, 0, GetSystemMetrics(SM_CXSIZE), GetSystemMetrics(SM_CYSIZE),
862 hDCSrc, GetSystemMetrics(SM_CXSIZE), 0, SRCCOPY);
863
864 SelectObject(hDCSrc, hobjSrc);
865 DeleteObject(hbClose);
866 DeleteDC(hDCSrc);
867
868 hobjSrc = SelectObject( hDCDest, GetStockObject(BLACK_PEN) );
869
870 MoveToEx( hDCDest, GetSystemMetrics(SM_CXSIZE) - 1, 0, NULL );
871 LineTo( hDCDest, GetSystemMetrics(SM_CXSIZE) - 1, GetSystemMetrics(SM_CYSIZE) - 1);
872
873 SelectObject(hDCDest, hobjSrc );
874 SelectObject(hDCDest, hobjDest);
875 DeleteDC(hDCDest);
876
877 return hbCopy;
878 }
879
880 /**********************************************************************
881 * MDICascade
882 */
883 static LONG MDICascade(WND* clientWnd, MDICLIENTINFO *ci)
884 {
885 WND** ppWnd;
886 UINT total;
887
888 if (ci->hwndChildMaximized)
889 SendMessageA( clientWnd->hwndSelf, WM_MDIRESTORE,
890 (WPARAM)ci->hwndChildMaximized, 0);
891
892 if (ci->nActiveChildren == 0) return 0;
893
894 if ((ppWnd = WIN_BuildWinArray(clientWnd, BWA_SKIPHIDDEN | BWA_SKIPOWNED |
895 BWA_SKIPICONIC, &total)))
896 {
897 WND** heapPtr = ppWnd;
898 if( total )
899 {
900 INT delta = 0, n = 0;
901 POINT pos[2];
902 if( total < ci->nActiveChildren )
903 delta = GetSystemMetrics(SM_CYICONSPACING) +
904 GetSystemMetrics(SM_CYICON);
905
906 /* walk the list (backwards) and move windows */
907 while (*ppWnd) ppWnd++;
908 while (ppWnd != heapPtr)
909 {
910 ppWnd--;
911 TRACE("move %04x to (%ld,%ld) size [%ld,%ld]\n",
912 (*ppWnd)->hwndSelf, pos[0].x, pos[0].y, pos[1].x, pos[1].y);
913
914 MDI_CalcDefaultChildPos(clientWnd, n++, pos, delta);
915 SetWindowPos( (*ppWnd)->hwndSelf, 0, pos[0].x, pos[0].y,
916 pos[1].x, pos[1].y,
917 SWP_DRAWFRAME | SWP_NOACTIVATE | SWP_NOZORDER);
918 }
919 }
920 WIN_ReleaseWinArray(heapPtr);
921 }
922
923 if( total < ci->nActiveChildren )
924 ArrangeIconicWindows( clientWnd->hwndSelf );
925 return 0;
926 }
927
928 /**********************************************************************
929 * MDITile
930 */
931 static void MDITile( WND* wndClient, MDICLIENTINFO *ci, WPARAM wParam )
932 {
933 WND** ppWnd;
934 UINT total = 0;
935
936 if (ci->hwndChildMaximized)
937 SendMessageA( wndClient->hwndSelf, WM_MDIRESTORE,
938 (WPARAM)ci->hwndChildMaximized, 0);
939
940 if (ci->nActiveChildren == 0) return;
941
942 ppWnd = WIN_BuildWinArray(wndClient, BWA_SKIPHIDDEN | BWA_SKIPOWNED | BWA_SKIPICONIC |
943 ((wParam & MDITILE_SKIPDISABLED)? BWA_SKIPDISABLED : 0), &total );
944
945 TRACE("%u windows to tile\n", total);
946
947 if( ppWnd )
948 {
949 WND** heapPtr = ppWnd;
950
951 if( total )
952 {
953 RECT rect;
954 int x, y, xsize, ysize;
955 int rows, columns, r, c, i;
956
957 GetClientRect(wndClient->hwndSelf,&rect);
958 rows = (int) sqrt((double)total);
959 columns = total / rows;
960
961 if( wParam & MDITILE_HORIZONTAL ) /* version >= 3.1 */
962 {
963 i = rows;
964 rows = columns; /* exchange r and c */
965 columns = i;
966 }
967
968 if( total != ci->nActiveChildren)
969 {
970 y = rect.bottom - 2 * GetSystemMetrics(SM_CYICONSPACING) - GetSystemMetrics(SM_CYICON);
971 rect.bottom = ( y - GetSystemMetrics(SM_CYICON) < rect.top )? rect.bottom: y;
972 }
973
974 ysize = rect.bottom / rows;
975 xsize = rect.right / columns;
976
977 for (x = i = 0, c = 1; c <= columns && *ppWnd; c++)
978 {
979 if (c == columns)
980 {
981 rows = total - i;
982 ysize = rect.bottom / rows;
983 }
984
985 y = 0;
986 for (r = 1; r <= rows && *ppWnd; r++, i++)
987 {
988 SetWindowPos((*ppWnd)->hwndSelf, 0, x, y, xsize, ysize,
989 SWP_DRAWFRAME | SWP_NOACTIVATE | SWP_NOZORDER);
990 y += ysize;
991 ppWnd++;
992 }
993 x += xsize;
994 }
995 }
996 WIN_ReleaseWinArray(heapPtr);
997 }
998
999 if( total < ci->nActiveChildren ) ArrangeIconicWindows( wndClient->hwndSelf );
1000 }
1001
1002 /* ----------------------- Frame window ---------------------------- */
1003
1004
1005 /**********************************************************************
1006 * MDI_AugmentFrameMenu
1007 */
1008 static BOOL MDI_AugmentFrameMenu( MDICLIENTINFO* ci, WND *frame,
1009 HWND hChild )
1010 {
1011 WND* child = WIN_FindWndPtr(hChild);
1012 HMENU hSysPopup = 0;
1013 HBITMAP hSysMenuBitmap = 0;
1014
1015 TRACE("frame %p,child %04x\n",frame,hChild);
1016
1017 if( !frame->wIDmenu || !child->hSysMenu )
1018 {
1019 WIN_ReleaseWndPtr(child);
1020 return 0;
1021 }
1022 WIN_ReleaseWndPtr(child);
1023
1024 /* create a copy of sysmenu popup and insert it into frame menu bar */
1025
1026 if (!(hSysPopup = LoadMenuA(GetModuleHandleA("USER32"), "SYSMENU")))
1027 return 0;
1028
1029 TRACE("\tgot popup %04x in sysmenu %04x\n",
1030 hSysPopup, child->hSysMenu);
1031
1032 AppendMenuA(frame->wIDmenu,MF_HELP | MF_BITMAP,
1033 SC_MINIMIZE, (LPSTR)(DWORD)HBMMENU_MBAR_MINIMIZE ) ;
1034 AppendMenuA(frame->wIDmenu,MF_HELP | MF_BITMAP,
1035 SC_RESTORE, (LPSTR)(DWORD)HBMMENU_MBAR_RESTORE );
1036
1037 /* In Win 95 look, the system menu is replaced by the child icon */
1038
1039 if(TWEAK_WineLook > WIN31_LOOK)
1040 {
1041 HICON hIcon = GetClassLongA(hChild, GCL_HICONSM);
1042 if (!hIcon)
1043 hIcon = GetClassLongA(hChild, GCL_HICON);
1044 if (hIcon)
1045 {
1046 HDC hMemDC;
1047 HBITMAP hBitmap, hOldBitmap;
1048 HBRUSH hBrush;
1049 HDC hdc = GetDC(hChild);
1050
1051 if (hdc)
1052 {
1053 int cx, cy;
1054 cx = GetSystemMetrics(SM_CXSMICON);
1055 cy = GetSystemMetrics(SM_CYSMICON);
1056 hMemDC = CreateCompatibleDC(hdc);
1057 hBitmap = CreateCompatibleBitmap(hdc, cx, cy);
1058 hOldBitmap = SelectObject(hMemDC, hBitmap);
1059 SetMapMode(hMemDC, MM_TEXT);
1060 hBrush = CreateSolidBrush(GetSysColor(COLOR_MENU));
1061 DrawIconEx(hMemDC, 0, 0, hIcon, cx, cy, 0, hBrush, DI_NORMAL);
1062 SelectObject (hMemDC, hOldBitmap);
1063 DeleteObject(hBrush);
1064 DeleteDC(hMemDC);
1065 ReleaseDC(hChild, hdc);
1066 hSysMenuBitmap = hBitmap;
1067 }
1068 }
1069 }
1070 else
1071 hSysMenuBitmap = hBmpClose;
1072
1073 if( !InsertMenuA(frame->wIDmenu,0,MF_BYPOSITION | MF_BITMAP | MF_POPUP,
1074 hSysPopup, (LPSTR)(DWORD)hSysMenuBitmap))
1075 {
1076 TRACE("not inserted\n");
1077 DestroyMenu(hSysPopup);
1078 return 0;
1079 }
1080
1081 /* The close button is only present in Win 95 look */
1082 if(TWEAK_WineLook > WIN31_LOOK)
1083 {
1084 AppendMenuA(frame->wIDmenu,MF_HELP | MF_BITMAP,
1085 SC_CLOSE, (LPSTR)(DWORD)HBMMENU_MBAR_CLOSE );
1086 }
1087
1088 EnableMenuItem(hSysPopup, SC_SIZE, MF_BYCOMMAND | MF_GRAYED);
1089 EnableMenuItem(hSysPopup, SC_MOVE, MF_BYCOMMAND | MF_GRAYED);
1090 EnableMenuItem(hSysPopup, SC_MAXIMIZE, MF_BYCOMMAND | MF_GRAYED);
1091 SetMenuDefaultItem(hSysPopup, SC_CLOSE, FALSE);
1092
1093 /* redraw menu */
1094 DrawMenuBar(frame->hwndSelf);
1095
1096 return 1;
1097 }
1098
1099 /**********************************************************************
1100 * MDI_RestoreFrameMenu
1101 */
1102 static BOOL MDI_RestoreFrameMenu( WND *frameWnd, HWND hChild )
1103 {
1104 MENUITEMINFOA menuInfo;
1105 INT nItems = GetMenuItemCount(frameWnd->wIDmenu) - 1;
1106 UINT iId = GetMenuItemID(frameWnd->wIDmenu,nItems) ;
1107
1108 TRACE("frameWnd %p,(%04x),child %04x,nIt=%d,iId=%d\n",
1109 frameWnd,frameWnd->hwndSelf,hChild,nItems,iId);
1110
1111 if(!(iId == SC_RESTORE || iId == SC_CLOSE) )
1112 return 0;
1113
1114 /*
1115 * Remove the system menu, If that menu is the icon of the window
1116 * as it is in win95, we have to delete the bitmap.
1117 */
1118 menuInfo.cbSize = sizeof(MENUITEMINFOA);
1119 menuInfo.fMask = MIIM_DATA | MIIM_TYPE;
1120
1121 GetMenuItemInfoA(frameWnd->wIDmenu,
1122 0,
1123 TRUE,
1124 &menuInfo);
1125
1126 RemoveMenu(frameWnd->wIDmenu,0,MF_BYPOSITION);
1127
1128 if ( (menuInfo.fType & MFT_BITMAP) &&
1129 (LOWORD(menuInfo.dwTypeData)!=0) &&
1130 (LOWORD(menuInfo.dwTypeData)!=hBmpClose) )
1131 {
1132 DeleteObject((HBITMAP)LOWORD(menuInfo.dwTypeData));
1133 }
1134
1135 if(TWEAK_WineLook > WIN31_LOOK)
1136 {
1137 /* close */
1138 DeleteMenu(frameWnd->wIDmenu,GetMenuItemCount(frameWnd->wIDmenu) - 1,MF_BYPOSITION);
1139 }
1140 /* restore */
1141 DeleteMenu(frameWnd->wIDmenu,GetMenuItemCount(frameWnd->wIDmenu) - 1,MF_BYPOSITION);
1142 /* minimize */
1143 DeleteMenu(frameWnd->wIDmenu,GetMenuItemCount(frameWnd->wIDmenu) - 1,MF_BYPOSITION);
1144
1145 DrawMenuBar(frameWnd->hwndSelf);
1146
1147 return 1;
1148 }
1149
1150
1151 /**********************************************************************
1152 * MDI_UpdateFrameText
1153 *
1154 * used when child window is maximized/restored
1155 *
1156 * Note: lpTitle can be NULL
1157 */
1158 static void MDI_UpdateFrameText( WND *frameWnd, HWND hClient,
1159 BOOL repaint, LPCWSTR lpTitle )
1160 {
1161 WCHAR lpBuffer[MDI_MAXTITLELENGTH+1];
1162 WND* clientWnd = WIN_FindWndPtr(hClient);
1163 MDICLIENTINFO *ci = (MDICLIENTINFO *) clientWnd->wExtra;
1164
1165 TRACE("repaint %i, frameText %s\n", repaint, (lpTitle)?debugstr_w(lpTitle):"NULL");
1166
1167 if (!clientWnd)
1168 return;
1169
1170 if (!ci)
1171 {
1172 WIN_ReleaseWndPtr(clientWnd);
1173 return;
1174 }
1175
1176 /* store new "default" title if lpTitle is not NULL */
1177 if (lpTitle)
1178 {
1179 if (ci->frameTitle) HeapFree( SystemHeap, 0, ci->frameTitle );
1180 ci->frameTitle = HEAP_strdupW( SystemHeap, 0, lpTitle );
1181 }
1182
1183 if (ci->frameTitle)
1184 {
1185 WND* childWnd = WIN_FindWndPtr( ci->hwndChildMaximized );
1186
1187 if( childWnd && childWnd->text )
1188 {
1189 /* combine frame title and child title if possible */
1190
1191 static const WCHAR lpBracket[] = {' ','-',' ','[',0};
1192 static const WCHAR lpBracket2[] = {']',0};
1193 int i_frame_text_length = strlenW(ci->frameTitle);
1194 int i_child_text_length = strlenW(childWnd->text);
1195
1196 lstrcpynW( lpBuffer, ci->frameTitle, MDI_MAXTITLELENGTH);
1197
1198 if( i_frame_text_length + 6 < MDI_MAXTITLELENGTH )
1199 {
1200 strcatW( lpBuffer, lpBracket );
1201
1202 if( i_frame_text_length + i_child_text_length + 6 < MDI_MAXTITLELENGTH )
1203 {
1204 strcatW( lpBuffer, childWnd->text );
1205 strcatW( lpBuffer, lpBracket2 );
1206 }
1207 else
1208 {
1209 lstrcpynW( lpBuffer + i_frame_text_length + 4,
1210 childWnd->text, MDI_MAXTITLELENGTH - i_frame_text_length - 5 );
1211 strcatW( lpBuffer, lpBracket2 );
1212 }
1213 }
1214 }
1215 else
1216 {
1217 lstrcpynW(lpBuffer, ci->frameTitle, MDI_MAXTITLELENGTH+1 );
1218 }
1219 WIN_ReleaseWndPtr(childWnd);
1220
1221 }
1222 else
1223 lpBuffer[0] = '\0';
1224
1225 DEFWND_SetTextW( frameWnd, lpBuffer );
1226 if( repaint == MDI_REPAINTFRAME)
1227 SetWindowPos( frameWnd->hwndSelf, 0,0,0,0,0, SWP_FRAMECHANGED |
1228 SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOZORDER );
1229
1230 WIN_ReleaseWndPtr(clientWnd);
1231
1232 }
1233
1234
1235 /* ----------------------------- Interface ---------------------------- */
1236
1237
1238 /**********************************************************************
1239 * MDIClientWndProcA
1240 *
1241 * This function handles all MDI requests.
1242 */
1243 static LRESULT WINAPI MDIClientWndProcA( HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam )
1244 {
1245 LPCREATESTRUCTA cs;
1246 MDICLIENTINFO *ci;
1247 RECT rect;
1248 WND *w, *frameWnd;
1249 INT nItems;
1250 LRESULT retvalue;
1251
1252 if ( ( w = WIN_FindWndPtr(hwnd) ) == NULL )
1253 return 0;
1254
1255 if ( ( frameWnd = WIN_LockWndPtr(w->parent) ) == NULL ) {
1256 WIN_ReleaseWndPtr(w);
1257 return 0;
1258 }
1259
1260 ci = (MDICLIENTINFO *) w->wExtra;
1261
1262 switch (message)
1263 {
1264 case WM_CREATE:
1265
1266 cs = (LPCREATESTRUCTA)lParam;
1267
1268 /* Translation layer doesn't know what's in the cs->lpCreateParams
1269 * so we have to keep track of what environment we're in. */
1270
1271 if( w->flags & WIN_ISWIN32 )
1272 {
1273 #define ccs ((LPCLIENTCREATESTRUCT)cs->lpCreateParams)
1274 ci->hWindowMenu = ccs->hWindowMenu;
1275 ci->idFirstChild = ccs->idFirstChild;
1276 #undef ccs
1277 }
1278 else
1279 {
1280 LPCLIENTCREATESTRUCT16 ccs = MapSL((SEGPTR)cs->lpCreateParams);
1281 ci->hWindowMenu = ccs->hWindowMenu;
1282 ci->idFirstChild = ccs->idFirstChild;
1283 }
1284
1285 ci->hwndChildMaximized = 0;
1286 ci->nActiveChildren = 0;
1287 ci->nTotalCreated = 0;
1288 ci->frameTitle = NULL;
1289 ci->mdiFlags = 0;
1290 ci->self = hwnd;
1291 w->dwStyle |= WS_CLIPCHILDREN;
1292
1293 if (!hBmpClose)
1294 {
1295 hBmpClose = CreateMDIMenuBitmap();
1296 hBmpRestore = LoadBitmapA( 0, MAKEINTRESOURCEA(OBM_RESTORE) );
1297 }
1298 MDI_UpdateFrameText(frameWnd, hwnd, MDI_NOFRAMEREPAINT,frameWnd->text);
1299
1300 if (ci->hWindowMenu != 0)
1301 AppendMenuA( ci->hWindowMenu, MF_SEPARATOR, 0, NULL );
1302
1303 GetClientRect(frameWnd->hwndSelf, &rect);
1304 NC_HandleNCCalcSize( w, &rect );
1305 w->rectClient = rect;
1306
1307 TRACE("Client created - hwnd = %04x, idFirst = %u\n",
1308 hwnd, ci->idFirstChild );
1309
1310 retvalue = 0;
1311 goto END;
1312
1313 case WM_DESTROY:
1314 if( ci->hwndChildMaximized )
1315 MDI_RestoreFrameMenu(w->parent, ci->hwndChildMaximized);
1316 if((ci->hWindowMenu != 0) &&
1317 (nItems = GetMenuItemCount(ci->hWindowMenu)) > 0)
1318 {
1319 ci->idFirstChild = nItems - 1;
1320 ci->nActiveChildren++; /* to delete a separator */
1321 while( ci->nActiveChildren-- )
1322 DeleteMenu(ci->hWindowMenu,MF_BYPOSITION,ci->idFirstChild--);
1323 }
1324 retvalue = 0;
1325 goto END;
1326
1327 case WM_MDIACTIVATE:
1328 if( ci->hwndActiveChild != (HWND)wParam )
1329 SetWindowPos((HWND)wParam, 0,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE);
1330 retvalue = 0;
1331 goto END;
1332
1333 case WM_MDICASCADE:
1334 retvalue = MDICascade(w, ci);
1335 goto END;
1336
1337 case WM_MDICREATE:
1338 if (lParam) retvalue = MDICreateChild( w, ci, hwnd,
1339 (MDICREATESTRUCTA*)lParam );
1340 else retvalue = 0;
1341 goto END;
1342
1343 case WM_MDIDESTROY:
1344 retvalue = MDIDestroyChild( w, ci, hwnd, (HWND)wParam, TRUE );
1345 goto END;
1346
1347 case WM_MDIGETACTIVE:
1348 if (lParam) *(BOOL *)lParam = (ci->hwndChildMaximized > 0);
1349 retvalue = ci->hwndActiveChild;
1350 goto END;
1351
1352 case WM_MDIICONARRANGE:
1353 ci->mdiFlags |= MDIF_NEEDUPDATE;
1354 ArrangeIconicWindows(hwnd);
1355 ci->sbRecalc = SB_BOTH+1;
1356 SendMessageA(hwnd, WM_MDICALCCHILDSCROLL, 0, 0L);
1357 retvalue = 0;
1358 goto END;
1359
1360 case WM_MDIMAXIMIZE:
1361 ShowWindow( (HWND)wParam, SW_MAXIMIZE );
1362 retvalue = 0;
1363 goto END;
1364
1365 case WM_MDINEXT: /* lParam != 0 means previous window */
1366 MDI_SwitchActiveChild(hwnd, (HWND)wParam, (lParam)? FALSE : TRUE );
1367 break;
1368
1369 case WM_MDIRESTORE:
1370 SendMessageA( (HWND)wParam, WM_SYSCOMMAND, SC_RESTORE, 0);
1371 retvalue = 0;
1372 goto END;
1373
1374 case WM_MDISETMENU:
1375 retvalue = MDISetMenu( hwnd, (HMENU)wParam, (HMENU)lParam );
1376 goto END;
1377 case WM_MDIREFRESHMENU:
1378 retvalue = MDIRefreshMenu( hwnd, (HMENU)wParam, (HMENU)lParam );
1379 goto END;
1380
1381 case WM_MDITILE:
1382 ci->mdiFlags |= MDIF_NEEDUPDATE;
1383 ShowScrollBar(hwnd,SB_BOTH,FALSE);
1384 MDITile(w, ci, wParam);
1385 ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1386 retvalue = 0;
1387 goto END;
1388
1389 case WM_VSCROLL:
1390 case WM_HSCROLL:
1391 ci->mdiFlags |= MDIF_NEEDUPDATE;
1392 ScrollChildren(hwnd, message, wParam, lParam);
1393 ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1394 retvalue = 0;
1395 goto END;
1396
1397 case WM_SETFOCUS:
1398 if( ci->hwndActiveChild )
1399 {
1400 WND* pw = WIN_FindWndPtr( ci->hwndActiveChild );
1401 if( !(pw->dwStyle & WS_MINIMIZE) )
1402 SetFocus( ci->hwndActiveChild );
1403 WIN_ReleaseWndPtr(pw);
1404 }
1405 retvalue = 0;
1406 goto END;
1407
1408 case WM_NCACTIVATE:
1409 if( ci->hwndActiveChild )
1410 SendMessageA(ci->hwndActiveChild, message, wParam, lParam);
1411 break;
1412
1413 case WM_PARENTNOTIFY:
1414 if (LOWORD(wParam) == WM_LBUTTONDOWN)
1415 {
1416 HWND child;
1417 POINT pt;
1418 pt.x = SLOWORD(lParam);
1419 pt.y = SHIWORD(lParam);
1420 child = ChildWindowFromPoint(hwnd, pt);
1421
1422 TRACE("notification from %04x (%li,%li)\n",child,pt.x,pt.y);
1423
1424 if( child && child != hwnd && child != ci->hwndActiveChild )
1425 SetWindowPos(child, 0,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE );
1426 }
1427 retvalue = 0;
1428 goto END;
1429
1430 case WM_SIZE:
1431 if( IsWindow(ci->hwndChildMaximized) )
1432 {
1433 WND* child = WIN_FindWndPtr(ci->hwndChildMaximized);
1434 RECT rect;
1435
1436 rect.left = 0;
1437 rect.top = 0;
1438 rect.right = LOWORD(lParam);
1439 rect.bottom = HIWORD(lParam);
1440
1441 AdjustWindowRectEx(&rect, child->dwStyle, 0, child->dwExStyle);
1442 MoveWindow(ci->hwndChildMaximized, rect.left, rect.top,
1443 rect.right - rect.left, rect.bottom - rect.top, 1);
1444 WIN_ReleaseWndPtr(child);
1445 }
1446 else
1447 MDI_PostUpdate(hwnd, ci, SB_BOTH+1);
1448
1449 break;
1450
1451 case WM_MDICALCCHILDSCROLL:
1452 if( (ci->mdiFlags & MDIF_NEEDUPDATE) && ci->sbRecalc )
1453 {
1454 CalcChildScroll16(hwnd, ci->sbRecalc-1);
1455 ci->sbRecalc = 0;
1456 ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1457 }
1458 retvalue = 0;
1459 goto END;
1460 }
1461
1462 retvalue = DefWindowProcA( hwnd, message, wParam, lParam );
1463 END:
1464 WIN_ReleaseWndPtr(w);
1465 WIN_ReleaseWndPtr(frameWnd);
1466 return retvalue;
1467 }
1468
1469
1470 /***********************************************************************
1471 * DefFrameProc (USER.445)
1472 */
1473 LRESULT WINAPI DefFrameProc16( HWND16 hwnd, HWND16 hwndMDIClient,
1474 UINT16 message, WPARAM16 wParam, LPARAM lParam )
1475 {
1476 HWND16 childHwnd;
1477 MDICLIENTINFO* ci;
1478 WND* wndPtr;
1479
1480 if (hwndMDIClient)
1481 {
1482 switch (message)
1483 {
1484 case WM_COMMAND:
1485 wndPtr = WIN_FindWndPtr(hwndMDIClient);
1486
1487 if (!wndPtr) {
1488 ERR("null wndPtr for mdi window hwndMDIClient=%04x\n",
1489 hwndMDIClient);
1490 return 0;
1491 }
1492
1493 ci = (MDICLIENTINFO*)wndPtr->wExtra;
1494
1495 /* check for possible syscommands for maximized MDI child */
1496 WIN_ReleaseWndPtr(wndPtr);
1497
1498 if( ci && (
1499 wParam < ci->idFirstChild ||
1500 wParam >= ci->idFirstChild + ci->nActiveChildren
1501 )){
1502 if( (wParam - 0xF000) & 0xF00F ) break;
1503 switch( wParam )
1504 {
1505 case SC_SIZE:
1506 case SC_MOVE:
1507 case SC_MINIMIZE:
1508 case SC_MAXIMIZE:
1509 case SC_NEXTWINDOW:
1510 case SC_PREVWINDOW:
1511 case SC_CLOSE:
1512 case SC_RESTORE:
1513 if( ci->hwndChildMaximized )
1514 return SendMessage16( ci->hwndChildMaximized, WM_SYSCOMMAND,
1515 wParam, lParam);
1516 }
1517 }
1518 else
1519 {
1520 wndPtr = WIN_FindWndPtr(hwndMDIClient);
1521 ci = (MDICLIENTINFO*)wndPtr->wExtra;
1522
1523 if (wParam - ci->idFirstChild == MDI_MOREWINDOWSLIMIT)
1524 /* User chose "More Windows..." */
1525 childHwnd = MDI_MoreWindowsDialog(wndPtr);
1526 else
1527 /* User chose one of the windows listed in the "Windows" menu */
1528 childHwnd = MDI_GetChildByID(wndPtr,wParam );
1529
1530 WIN_ReleaseWndPtr(wndPtr);
1531 if( childHwnd )
1532 SendMessage16(hwndMDIClient, WM_MDIACTIVATE,
1533 (WPARAM16)childHwnd , 0L);
1534 }
1535 break;
1536
1537 case WM_NCACTIVATE:
1538 SendMessage16(hwndMDIClient, message, wParam, lParam);
1539 break;
1540
1541 case WM_SETTEXT:
1542 {
1543 LPWSTR text = HEAP_strdupAtoW( GetProcessHeap(), 0, MapSL(lParam) );
1544 wndPtr = WIN_FindWndPtr(hwnd);
1545 MDI_UpdateFrameText(wndPtr, hwndMDIClient,
1546 MDI_REPAINTFRAME, text );
1547 WIN_ReleaseWndPtr(wndPtr);
1548 HeapFree( GetProcessHeap(), 0, text );
1549 }
1550 return 1; /* success. FIXME: check text length */
1551
1552 case WM_SETFOCUS:
1553 SetFocus(hwndMDIClient);
1554 break;
1555
1556 case WM_SIZE:
1557 MoveWindow16(hwndMDIClient, 0, 0,
1558 LOWORD(lParam), HIWORD(lParam), TRUE);
1559 break;
1560
1561 case WM_NEXTMENU:
1562
1563 wndPtr = WIN_FindWndPtr(hwndMDIClient);
1564 ci = (MDICLIENTINFO*)wndPtr->wExtra;
1565
1566 if( !(wndPtr->parent->dwStyle & WS_MINIMIZE)
1567 && ci->hwndActiveChild && !ci->hwndChildMaximized )
1568 {
1569 /* control menu is between the frame system menu and
1570 * the first entry of menu bar */
1571
1572 if( (wParam == VK_LEFT &&
1573 wndPtr->parent->wIDmenu == LOWORD(lParam)) ||
1574 (wParam == VK_RIGHT &&
1575 GetSubMenu16(wndPtr->parent->hSysMenu, 0) == LOWORD(lParam)) )
1576 {
1577 LRESULT retvalue;
1578 WIN_ReleaseWndPtr(wndPtr);
1579 wndPtr = WIN_FindWndPtr(ci->hwndActiveChild);
1580 retvalue = MAKELONG( GetSubMenu16(wndPtr->hSysMenu, 0),
1581 ci->hwndActiveChild);
1582 WIN_ReleaseWndPtr(wndPtr);
1583 return retvalue;
1584 }
1585 }
1586 WIN_ReleaseWndPtr(wndPtr);
1587 break;
1588 }
1589 }
1590
1591 return DefWindowProc16(hwnd, message, wParam, lParam);
1592 }
1593
1594
1595 /***********************************************************************
1596 * DefFrameProcA (USER32.@)
1597 */
1598 LRESULT WINAPI DefFrameProcA( HWND hwnd, HWND hwndMDIClient,
1599 UINT message, WPARAM wParam, LPARAM lParam)
1600 {
1601 if (hwndMDIClient)
1602 {
1603 switch (message)
1604 {
1605 case WM_COMMAND:
1606 return DefFrameProc16( hwnd, hwndMDIClient, message,
1607 (WPARAM16)wParam,
1608 MAKELPARAM( (HWND16)lParam, HIWORD(wParam) ) );
1609
1610 case WM_NCACTIVATE:
1611 SendMessageA(hwndMDIClient, message, wParam, lParam);
1612 break;
1613
1614 case WM_SETTEXT: {
1615 LRESULT ret;
1616 LPSTR segstr = SEGPTR_STRDUP((LPSTR)lParam);
1617
1618 ret = DefFrameProc16(hwnd, hwndMDIClient, message,
1619 wParam, (LPARAM)SEGPTR_GET(segstr) );
1620 SEGPTR_FREE(segstr);
1621 return ret;
1622 }
1623
1624 case WM_NEXTMENU:
1625 case WM_SETFOCUS:
1626 case WM_SIZE:
1627 return DefFrameProc16( hwnd, hwndMDIClient, message,
1628 wParam, lParam );
1629 }
1630 }
1631
1632 return DefWindowProcA(hwnd, message, wParam, lParam);
1633 }
1634
1635
1636 /***********************************************************************
1637 * DefFrameProcW (USER32.@)
1638 */
1639 LRESULT WINAPI DefFrameProcW( HWND hwnd, HWND hwndMDIClient,
1640 UINT message, WPARAM wParam, LPARAM lParam)
1641 {
1642 if (hwndMDIClient)
1643 {
1644 switch (message)
1645 {
1646 case WM_COMMAND:
1647 return DefFrameProc16( hwnd, hwndMDIClient, message,
1648 (WPARAM16)wParam,
1649 MAKELPARAM( (HWND16)lParam, HIWORD(wParam) ) );
1650
1651 case WM_NCACTIVATE:
1652 SendMessageW(hwndMDIClient, message, wParam, lParam);
1653 break;
1654
1655 case WM_SETTEXT:
1656 {
1657 LPSTR txt = HEAP_strdupWtoA(GetProcessHeap(),0,(LPWSTR)lParam);
1658 LRESULT ret = DefFrameProcA( hwnd, hwndMDIClient, message,
1659 wParam, (DWORD)txt );
1660 HeapFree(GetProcessHeap(),0,txt);
1661 return ret;
1662 }
1663 case WM_NEXTMENU:
1664 case WM_SETFOCUS:
1665 case WM_SIZE:
1666 return DefFrameProcA( hwnd, hwndMDIClient, message,
1667 wParam, lParam );
1668 }
1669 }
1670
1671 return DefWindowProcW( hwnd, message, wParam, lParam );
1672 }
1673
1674
1675 /***********************************************************************
1676 * DefMDIChildProc (USER.447)
1677 */
1678 LRESULT WINAPI DefMDIChildProc16( HWND16 hwnd, UINT16 message,
1679 WPARAM16 wParam, LPARAM lParam )
1680 {
1681 MDICLIENTINFO *ci;
1682 WND *clientWnd,*tmpWnd = 0;
1683 LRESULT retvalue;
1684
1685 tmpWnd = WIN_FindWndPtr(hwnd);
1686 if (!tmpWnd) return 0;
1687 clientWnd = WIN_FindWndPtr(tmpWnd->parent->hwndSelf);
1688 ci = (MDICLIENTINFO *) clientWnd->wExtra;
1689 WIN_ReleaseWndPtr(tmpWnd);
1690
1691 /* Sanity check */
1692 if (clientWnd->cbWndExtra < sizeof(MDICLIENTINFO))
1693 {
1694 WARN("called on non-MDI child window %x\n", hwnd);
1695 WIN_ReleaseWndPtr(clientWnd);
1696 return DefWindowProc16(hwnd, message, wParam, lParam);
1697 }
1698
1699 switch (message)
1700 {
1701 case WM_SETTEXT:
1702 DefWindowProc16(hwnd, message, wParam, lParam);
1703 MDI_MenuModifyItem(clientWnd,hwnd);
1704 if( ci->hwndChildMaximized == hwnd )
1705 MDI_UpdateFrameText( clientWnd->parent, ci->self,
1706 MDI_REPAINTFRAME, NULL );
1707 retvalue = 1; /* success. FIXME: check text length */
1708 goto END;
1709
1710 case WM_CLOSE:
1711 SendMessage16(ci->self,WM_MDIDESTROY,(WPARAM16)hwnd,0L);
1712 retvalue = 0;
1713 goto END;
1714
1715 case WM_SETFOCUS:
1716 if( ci->hwndActiveChild != hwnd )
1717 MDI_ChildActivate(clientWnd, hwnd);
1718 break;
1719
1720 case WM_CHILDACTIVATE:
1721 MDI_ChildActivate(clientWnd, hwnd);
1722 retvalue = 0;
1723 goto END;
1724
1725 case WM_NCPAINT:
1726 TRACE("WM_NCPAINT for %04x, active %04x\n",
1727 hwnd, ci->hwndActiveChild );
1728 break;
1729
1730 case WM_SYSCOMMAND:
1731 switch( wParam )
1732 {
1733 case SC_MOVE:
1734 if( ci->hwndChildMaximized == hwnd)
1735 {
1736 retvalue = 0;
1737 goto END;
1738 }
1739 break;
1740 case SC_RESTORE:
1741 case SC_MINIMIZE:
1742 tmpWnd = WIN_FindWndPtr(hwnd);
1743 tmpWnd->dwStyle |= WS_SYSMENU;
1744 WIN_ReleaseWndPtr(tmpWnd);
1745 break;
1746 case SC_MAXIMIZE:
1747 if( ci->hwndChildMaximized == hwnd)
1748 {
1749 retvalue = SendMessage16( clientWnd->parent->hwndSelf,
1750 message, wParam, lParam);
1751 goto END;
1752 }
1753 tmpWnd = WIN_FindWndPtr(hwnd);
1754 tmpWnd->dwStyle &= ~WS_SYSMENU;
1755 WIN_ReleaseWndPtr(tmpWnd);
1756 break;
1757 case SC_NEXTWINDOW:
1758 SendMessage16( ci->self, WM_MDINEXT, 0, 0);
1759 retvalue = 0;
1760 goto END;
1761 case SC_PREVWINDOW:
1762 SendMessage16( ci->self, WM_MDINEXT, 0, 1);
1763 retvalue = 0;
1764 goto END;
1765 }
1766 break;
1767
1768 case WM_GETMINMAXINFO:
1769 MDI_ChildGetMinMaxInfo(clientWnd, hwnd, MapSL(lParam));
1770 retvalue = 0;
1771 goto END;
1772
1773 case WM_SETVISIBLE:
1774 if( ci->hwndChildMaximized) ci->mdiFlags &= ~MDIF_NEEDUPDATE;
1775 else
1776 MDI_PostUpdate(clientWnd->hwndSelf, ci, SB_BOTH+1);
1777 break;
1778
1779 case WM_SIZE:
1780 /* do not change */
1781
1782 if( ci->hwndActiveChild == hwnd && wParam != SIZE_MAXIMIZED )
1783 {
1784 ci->hwndChildMaximized = 0;
1785
1786 MDI_RestoreFrameMenu( clientWnd->parent, hwnd);
1787 MDI_UpdateFrameText( clientWnd->parent, ci->self,
1788 MDI_REPAINTFRAME, NULL );
1789 }
1790
1791 if( wParam == SIZE_MAXIMIZED )
1792 {
1793 HWND16 hMaxChild = ci->hwndChildMaximized;
1794
1795 if( hMaxChild == hwnd ) break;
1796
1797 if( hMaxChild)
1798 {
1799 SendMessage16( hMaxChild, WM_SETREDRAW, FALSE, 0L );
1800
1801 MDI_RestoreFrameMenu( clientWnd->parent, hMaxChild);
1802 ShowWindow16( hMaxChild, SW_SHOWNOACTIVATE);
1803
1804 SendMessage16( hMaxChild, WM_SETREDRAW, TRUE, 0L );
1805 }
1806
1807 TRACE("maximizing child %04x\n", hwnd );
1808
1809 /*
1810 * Keep track of the maximized window.
1811 */
1812 ci->hwndChildMaximized = hwnd; /* !!! */
1813
1814 /*
1815 * The maximized window should also be the active window
1816 */
1817 MDI_ChildActivate(clientWnd, hwnd);
1818
1819 MDI_AugmentFrameMenu( ci, clientWnd->parent, hwnd);
1820 MDI_UpdateFrameText( clientWnd->parent, ci->self,
1821 MDI_REPAINTFRAME, NULL );
1822 }
1823
1824 if( wParam == SIZE_MINIMIZED )
1825 {
1826 HWND16 switchTo = MDI_GetWindow(clientWnd, hwnd, TRUE, WS_MINIMIZE);
1827
1828 if( switchTo )
1829 SendMessage16( switchTo, WM_CHILDACTIVATE, 0, 0L);
1830 }
1831
1832 MDI_PostUpdate(clientWnd->hwndSelf, ci, SB_BOTH+1);
1833 break;
1834
1835 case WM_MENUCHAR:
1836
1837 /* MDI children don't have menu bars */
1838 retvalue = 0x00010000L;
1839 goto END;
1840
1841 case WM_NEXTMENU:
1842
1843 if( wParam == VK_LEFT ) /* switch to frame system menu */
1844 {
1845 retvalue = MAKELONG( GetSubMenu16(clientWnd->parent->hSysMenu, 0),
1846 clientWnd->parent->hwndSelf );
1847 goto END;
1848 }
1849 if( wParam == VK_RIGHT ) /* to frame menu bar */
1850 {
1851 retvalue = MAKELONG( clientWnd->parent->wIDmenu,
1852 clientWnd->parent->hwndSelf );
1853 goto END;
1854 }
1855
1856 break;
1857
1858 case WM_SYSCHAR:
1859 if (wParam == '-')
1860 {
1861 SendMessage16(hwnd,WM_SYSCOMMAND,
1862 (WPARAM16)SC_KEYMENU, (LPARAM)(DWORD)VK_SPACE);
1863 retvalue = 0;
1864 goto END;
1865 }
1866 }
1867
1868 retvalue = DefWindowProc16(hwnd, message, wParam, lParam);
1869 END:
1870 WIN_ReleaseWndPtr(clientWnd);
1871 return retvalue;
1872 }
1873
1874
1875 /***********************************************************************
1876 * DefMDIChildProcA (USER32.@)
1877 */
1878 LRESULT WINAPI DefMDIChildProcA( HWND hwnd, UINT message,
1879 WPARAM wParam, LPARAM lParam )
1880 {
1881 MDICLIENTINFO *ci;
1882 WND *clientWnd,*tmpWnd;
1883 LRESULT retvalue;
1884
1885 tmpWnd = WIN_FindWndPtr(hwnd);
1886 if (!tmpWnd) return 0;
1887 clientWnd = WIN_FindWndPtr(tmpWnd->parent->hwndSelf);
1888 ci = (MDICLIENTINFO *) clientWnd->wExtra;
1889 WIN_ReleaseWndPtr(tmpWnd);
1890
1891 /* Sanity check */
1892 if (clientWnd->cbWndExtra < sizeof(MDICLIENTINFO))
1893 {
1894 WARN("called on non-MDI child window %x\n", hwnd);
1895 WIN_ReleaseWndPtr(clientWnd);
1896 return DefWindowProcA(hwnd, message, wParam, lParam);
1897 }
1898
1899 switch (message)
1900 {
1901 case WM_SETTEXT:
1902 DefWindowProcA(hwnd, message, wParam, lParam);
1903 MDI_MenuModifyItem(clientWnd,hwnd);
1904 if( ci->hwndChildMaximized == hwnd )
1905 MDI_UpdateFrameText( clientWnd->parent, ci->self,
1906 MDI_REPAINTFRAME, NULL );
1907 retvalue = 1; /* success. FIXME: check text length */
1908 goto END;
1909
1910 case WM_GETMINMAXINFO:
1911 {
1912 MINMAXINFO16 mmi;
1913 STRUCT32_MINMAXINFO32to16( (MINMAXINFO *)lParam, &mmi );
1914 MDI_ChildGetMinMaxInfo( clientWnd, hwnd, &mmi );
1915 STRUCT32_MINMAXINFO16to32( &mmi, (MINMAXINFO *)lParam );
1916 }
1917 retvalue = 0;
1918 goto END;
1919
1920 case WM_MENUCHAR:
1921
1922 /* MDI children don't have menu bars */
1923 retvalue = 0x00010000L;
1924 goto END;
1925
1926 case WM_CLOSE:
1927 case WM_SETFOCUS:
1928 case WM_CHILDACTIVATE:
1929 case WM_NCPAINT:
1930 case WM_SYSCOMMAND:
1931 case WM_SETVISIBLE:
1932 case WM_SIZE:
1933 case WM_NEXTMENU:
1934 retvalue = DefMDIChildProc16( hwnd, message, (WPARAM16)wParam, lParam );
1935 goto END;
1936
1937 case WM_SYSCHAR:
1938 if (wParam == '-')
1939 {
1940 SendMessageA(hwnd,WM_SYSCOMMAND,
1941 (WPARAM)SC_KEYMENU, (LPARAM)(DWORD)VK_SPACE);
1942 retvalue = 0;
1943 goto END;
1944 }
1945 }
1946 retvalue = DefWindowProcA(hwnd, message, wParam, lParam);
1947 END:
1948 WIN_ReleaseWndPtr(clientWnd);
1949 return retvalue;
1950 }
1951
1952
1953 /***********************************************************************
1954 * DefMDIChildProcW (USER32.@)
1955 */
1956 LRESULT WINAPI DefMDIChildProcW( HWND hwnd, UINT message,
1957 WPARAM wParam, LPARAM lParam )
1958 {
1959 MDICLIENTINFO *ci;
1960 WND *clientWnd,*tmpWnd;
1961 LRESULT retvalue;
1962
1963 tmpWnd = WIN_FindWndPtr(hwnd);
1964 if (!tmpWnd) return 0;
1965 clientWnd = WIN_FindWndPtr(tmpWnd->parent->hwndSelf);
1966 ci = (MDICLIENTINFO *) clientWnd->wExtra;
1967 WIN_ReleaseWndPtr(tmpWnd);
1968
1969 /* Sanity check */
1970 if (clientWnd->cbWndExtra < sizeof(MDICLIENTINFO))
1971 {
1972 WARN("called on non-MDI child window %x\n", hwnd);
1973 WIN_ReleaseWndPtr(clientWnd);
1974 return DefWindowProcW(hwnd, message, wParam, lParam);
1975 }
1976
1977 switch (message)
1978 {
1979 case WM_SETTEXT:
1980 DefWindowProcW(hwnd, message, wParam, lParam);
1981 MDI_MenuModifyItem(clientWnd,hwnd);
1982 if( ci->hwndChildMaximized == hwnd )
1983 MDI_UpdateFrameText( clientWnd->parent, ci->self,
1984 MDI_REPAINTFRAME, NULL );
1985 retvalue = 1; /* success. FIXME: check text length */
1986 goto END;
1987
1988 case WM_GETMINMAXINFO:
1989 case WM_MENUCHAR:
1990 case WM_CLOSE:
1991 case WM_SETFOCUS:
1992 case WM_CHILDACTIVATE:
1993 case WM_NCPAINT:
1994 case WM_SYSCOMMAND:
1995 case WM_SETVISIBLE:
1996 case WM_SIZE:
1997 case WM_NEXTMENU:
1998 retvalue = DefMDIChildProcA( hwnd, message, (WPARAM16)wParam, lParam );
1999 goto END;
2000
2001 case WM_SYSCHAR:
2002 if (wParam == '-')
2003 {
2004 SendMessageW(hwnd,WM_SYSCOMMAND,
2005 (WPARAM)SC_KEYMENU, (LPARAM)(DWORD)VK_SPACE);
2006 retvalue = 0;
2007 goto END;
2008 }
2009 }
2010 retvalue = DefWindowProcW(hwnd, message, wParam, lParam);
2011 END:
2012 WIN_ReleaseWndPtr(clientWnd);
2013 return retvalue;
2014
2015 }
2016
2017
2018 /**********************************************************************
2019 * CreateMDIWindowA (USER32.@) Creates a MDI child in new thread
2020 * FIXME: its in the same thread now
2021 *
2022 * RETURNS
2023 * Success: Handle to created window
2024 * Failure: NULL
2025 */
2026 HWND WINAPI CreateMDIWindowA(
2027 LPCSTR lpClassName, /* [in] Pointer to registered child class name */
2028 LPCSTR lpWindowName, /* [in] Pointer to window name */
2029 DWORD dwStyle, /* [in] Window style */
2030 INT X, /* [in] Horizontal position of window */
2031 INT Y, /* [in] Vertical position of window */
2032 INT nWidth, /* [in] Width of window */
2033 INT nHeight, /* [in] Height of window */
2034 HWND hWndParent, /* [in] Handle to parent window */
2035 HINSTANCE hInstance, /* [in] Handle to application instance */
2036 LPARAM lParam) /* [in] Application-defined value */
2037 {
2038 WARN("is only single threaded!\n");
2039 return MDI_CreateMDIWindowA(lpClassName, lpWindowName, dwStyle, X, Y,
2040 nWidth, nHeight, hWndParent, hInstance, lParam);
2041 }
2042
2043 /**********************************************************************
2044 * MDI_CreateMDIWindowA
2045 * single threaded version of CreateMDIWindowA
2046 * called by CreateWindowExA
2047 */
2048 HWND MDI_CreateMDIWindowA(
2049 LPCSTR lpClassName,
2050 LPCSTR lpWindowName,
2051 DWORD dwStyle,
2052 INT X,
2053 INT Y,
2054 INT nWidth,
2055 INT nHeight,
2056 HWND hWndParent,
2057 HINSTANCE hInstance,
2058 LPARAM lParam)
2059 {
2060 MDICLIENTINFO* pCi;
2061 MDICREATESTRUCTA cs;
2062 WND *pWnd=WIN_FindWndPtr(hWndParent);
2063 HWND retvalue;
2064
2065 TRACE("(%s,%s,%ld,%d,%d,%d,%d,%x,%d,%ld)\n",
2066 debugstr_a(lpClassName),debugstr_a(lpWindowName),dwStyle,X,Y,
2067 nWidth,nHeight,hWndParent,hInstance,lParam);
2068
2069 if(!pWnd){
2070 ERR(" bad hwnd for MDI-client: %d\n",hWndParent);
2071 return 0;
2072 }
2073 cs.szClass=lpClassName;
2074 cs.szTitle=lpWindowName;
2075 cs.hOwner=hInstance;
2076 cs.x=X;
2077 cs.y=Y;
2078 cs.cx=nWidth;
2079 cs.cy=nHeight;
2080 cs.style=dwStyle;
2081 cs.lParam=lParam;
2082
2083 pCi=(MDICLIENTINFO *)pWnd->wExtra;
2084
2085 retvalue = MDICreateChild(pWnd,pCi,hWndParent,&cs);
2086 WIN_ReleaseWndPtr(pWnd);
2087 return retvalue;
2088 }
2089
2090 /***********************************************************************
2091 * CreateMDIWindowW (USER32.@) Creates a MDI child in new thread
2092 *
2093 * RETURNS
2094 * Success: Handle to created window
2095 * Failure: NULL
2096 */
2097 HWND WINAPI CreateMDIWindowW(
2098 LPCWSTR lpClassName, /* [in] Pointer to registered child class name */
2099 LPCWSTR lpWindowName, /* [in] Pointer to window name */
2100 DWORD dwStyle, /* [in] Window style */
2101 INT X, /* [in] Horizontal position of window */
2102 INT Y, /* [in] Vertical position of window */
2103 INT nWidth, /* [in] Width of window */
2104 INT nHeight, /* [in] Height of window */
2105 HWND hWndParent, /* [in] Handle to parent window */
2106 HINSTANCE hInstance, /* [in] Handle to application instance */
2107 LPARAM lParam) /* [in] Application-defined value */
2108 {
2109 FIXME("(%s,%s,%ld,%d,%d,%d,%d,%x,%d,%ld): stub\n",
2110 debugstr_w(lpClassName),debugstr_w(lpWindowName),dwStyle,X,Y,
2111 nWidth,nHeight,hWndParent,hInstance,lParam);
2112 return (HWND)NULL;
2113 }
2114
2115
2116 /******************************************************************************
2117 * CreateMDIWindowW (USER32.80) Creates a MDI child window
2118 * single threaded version of CreateMDIWindow
2119 * called by CreateWindowExW().
2120 */
2121 HWND MDI_CreateMDIWindowW(
2122 LPCWSTR lpClassName, /* [in] Pointer to registered child class name */
2123 LPCWSTR lpWindowName, /* [in] Pointer to window name */
2124 DWORD dwStyle, /* [in] Window style */
2125 INT X, /* [in] Horizontal position of window */
2126 INT Y, /* [in] Vertical position of window */
2127 INT nWidth, /* [in] Width of window */
2128 INT nHeight, /* [in] Height of window */
2129 HWND hWndParent, /* [in] Handle to parent window */
2130 HINSTANCE hInstance, /* [in] Handle to application instance */
2131 LPARAM lParam) /* [in] Application-defined value */
2132 {
2133 FIXME("(%s,%s,%ld,%d,%d,%d,%d,%x,%d,%ld): stub\n",
2134 debugstr_w(lpClassName),debugstr_w(lpWindowName),dwStyle,X,Y,
2135 nWidth,nHeight,hWndParent,hInstance,lParam);
2136 return (HWND)NULL;
2137 }
2138
2139
2140 /**********************************************************************
2141 * TranslateMDISysAccel (USER32.@)
2142 */
2143 BOOL WINAPI TranslateMDISysAccel( HWND hwndClient, LPMSG msg )
2144 {
2145 MSG16 msg16;
2146
2147 STRUCT32_MSG32to16(msg,&msg16);
2148 /* MDICLIENTINFO is still the same for win32 and win16 ... */
2149 return TranslateMDISysAccel16(hwndClient,&msg16);
2150 }
2151
2152
2153 /**********************************************************************
2154 * TranslateMDISysAccel (USER.451)
2155 */
2156 BOOL16 WINAPI TranslateMDISysAccel16( HWND16 hwndClient, LPMSG16 msg )
2157 {
2158
2159 if( IsWindow(hwndClient) && (msg->message == WM_KEYDOWN || msg->message == WM_SYSKEYDOWN))
2160 {
2161 MDICLIENTINFO *ci = NULL;
2162 HWND wnd;
2163 WND *clientWnd = WIN_FindWndPtr(hwndClient);
2164
2165 ci = (MDICLIENTINFO*) clientWnd->wExtra;
2166 wnd = ci->hwndActiveChild;
2167
2168 WIN_ReleaseWndPtr(clientWnd);
2169
2170 if( IsWindow(wnd) && !(GetWindowLongA(wnd,GWL_STYLE) & WS_DISABLED) )
2171 {
2172 WPARAM16 wParam = 0;
2173
2174 /* translate if the Ctrl key is down and Alt not. */
2175
2176 if( (GetKeyState(VK_CONTROL) & 0x8000) &&
2177 !(GetKeyState(VK_MENU) & 0x8000))
2178 {
2179 switch( msg->wParam )
2180 {
2181 case VK_F6:
2182 case VK_TAB:
2183 wParam = ( GetKeyState(VK_SHIFT) & 0x8000 )
2184 ? SC_NEXTWINDOW : SC_PREVWINDOW;
2185 break;
2186 case VK_F4:
2187 case VK_RBUTTON:
2188 wParam = SC_CLOSE;
2189 break;
2190 default:
2191 return 0;
2192 }
2193 TRACE("wParam = %04x\n", wParam);
2194 SendMessage16( ci->hwndActiveChild, WM_SYSCOMMAND,
2195 wParam, (LPARAM)msg->wParam);
2196 return 1;
2197 }
2198 }
2199 }
2200 return 0; /* failure */
2201 }
2202
2203
2204 /***********************************************************************
2205 * CalcChildScroll (USER.462)
2206 */
2207 void WINAPI CalcChildScroll16( HWND16 hwnd, WORD scroll )
2208 {
2209 SCROLLINFO info;
2210 RECT childRect, clientRect;
2211 INT vmin, vmax, hmin, hmax, vpos, hpos;
2212 WND *pWnd, *Wnd;
2213
2214 if (!(pWnd = WIN_FindWndPtr( hwnd ))) return;
2215 Wnd = WIN_FindWndPtr(hwnd);
2216 GetClientRect( hwnd, &clientRect );
2217 SetRectEmpty( &childRect );
2218
2219 for ( WIN_UpdateWndPtr(&pWnd,pWnd->child); pWnd; WIN_UpdateWndPtr(&pWnd,pWnd->next))
2220 {
2221 if( pWnd->dwStyle & WS_MAXIMIZE )
2222 {
2223 ShowScrollBar(hwnd, SB_BOTH, FALSE);
2224 WIN_ReleaseWndPtr(pWnd);
2225 WIN_ReleaseWndPtr(Wnd);
2226 return;
2227 }
2228 UnionRect( &childRect, &pWnd->rectWindow, &childRect );
2229 }
2230 WIN_ReleaseWndPtr(pWnd);
2231 UnionRect( &childRect, &clientRect, &childRect );
2232
2233 hmin = childRect.left; hmax = childRect.right - clientRect.right;
2234 hpos = clientRect.left - childRect.left;
2235 vmin = childRect.top; vmax = childRect.bottom - clientRect.bottom;
2236 vpos = clientRect.top - childRect.top;
2237
2238 switch( scroll )
2239 {
2240 case SB_HORZ:
2241 vpos = hpos; vmin = hmin; vmax = hmax;
2242 case SB_VERT:
2243 info.cbSize = sizeof(info);
2244 info.nMax = vmax; info.nMin = vmin; info.nPos = vpos;
2245 info.fMask = SIF_POS | SIF_RANGE;
2246 SetScrollInfo(hwnd, scroll, &info, TRUE);
2247 break;
2248 case SB_BOTH:
2249 SCROLL_SetNCSbState( Wnd, vmin, vmax, vpos,
2250 hmin, hmax, hpos);
2251 }
2252 WIN_ReleaseWndPtr(Wnd);
2253 }
2254
2255
2256 /***********************************************************************
2257 * ScrollChildren (USER.463)
2258 */
2259 void WINAPI ScrollChildren16(HWND16 hWnd, UINT16 uMsg, WPARAM16 wParam, LPARAM lParam)
2260 {
2261 ScrollChildren( hWnd, uMsg, wParam, lParam );
2262 }
2263
2264
2265 /***********************************************************************
2266 * ScrollChildren (USER32.@)
2267 */
2268 void WINAPI ScrollChildren(HWND hWnd, UINT uMsg, WPARAM wParam,
2269 LPARAM lParam)
2270 {
2271 WND *wndPtr = WIN_FindWndPtr(hWnd);
2272 INT newPos = -1;
2273 INT curPos, length, minPos, maxPos, shift;
2274
2275 if( !wndPtr ) return;
2276
2277 if( uMsg == WM_HSCROLL )
2278 {
2279 GetScrollRange(hWnd,SB_HORZ,&minPos,&maxPos);
2280 curPos = GetScrollPos(hWnd,SB_HORZ);
2281 length = (wndPtr->rectClient.right - wndPtr->rectClient.left)/2;
2282 shift = GetSystemMetrics(SM_CYHSCROLL);
2283 }
2284 else if( uMsg == WM_VSCROLL )
2285 {
2286 GetScrollRange(hWnd,SB_VERT,&minPos,&maxPos);
2287 curPos = GetScrollPos(hWnd,SB_VERT);
2288 length = (wndPtr->rectClient.bottom - wndPtr->rectClient.top)/2;
2289 shift = GetSystemMetrics(SM_CXVSCROLL);
2290 }
2291 else
2292 {
2293 WIN_ReleaseWndPtr(wndPtr);
2294 return;
2295 }
2296
2297 WIN_ReleaseWndPtr(wndPtr);
2298 switch( wParam )
2299 {
2300 case SB_LINEUP:
2301 newPos = curPos - shift;
2302 break;
2303 case SB_LINEDOWN:
2304 newPos = curPos + shift;
2305 break;
2306 case SB_PAGEUP:
2307 newPos = curPos - length;
2308 break;
2309 case SB_PAGEDOWN:
2310 newPos = curPos + length;
2311 break;
2312
2313 case SB_THUMBPOSITION:
2314 newPos = LOWORD(lParam);
2315 break;
2316
2317 case SB_THUMBTRACK:
2318 return;
2319
2320 case SB_TOP:
2321 newPos = minPos;
2322 break;
2323 case SB_BOTTOM:
2324 newPos = maxPos;
2325 break;
2326 case SB_ENDSCROLL:
2327 CalcChildScroll16(hWnd,(uMsg == WM_VSCROLL)?SB_VERT:SB_HORZ);
2328 return;
2329 }
2330
2331 if( newPos > maxPos )
2332 newPos = maxPos;
2333 else
2334 if( newPos < minPos )
2335 newPos = minPos;
2336
2337 SetScrollPos(hWnd, (uMsg == WM_VSCROLL)?SB_VERT:SB_HORZ , newPos, TRUE);
2338
2339 if( uMsg == WM_VSCROLL )
2340 ScrollWindowEx(hWnd ,0 ,curPos - newPos, NULL, NULL, 0, NULL,
2341 SW_INVALIDATE | SW_ERASE | SW_SCROLLCHILDREN );
2342 else
2343 ScrollWindowEx(hWnd ,curPos - newPos, 0, NULL, NULL, 0, NULL,
2344 SW_INVALIDATE | SW_ERASE | SW_SCROLLCHILDREN );
2345 }
2346
2347
2348 /******************************************************************************
2349 * CascadeWindows (USER32.@) Cascades MDI child windows
2350 *
2351 * RETURNS
2352 * Success: Number of cascaded windows.
2353 * Failure: 0
2354 */
2355 WORD WINAPI
2356 CascadeWindows (HWND hwndParent, UINT wFlags, const LPRECT lpRect,
2357 UINT cKids, const HWND *lpKids)
2358 {
2359 FIXME("(0x%08x,0x%08x,...,%u,...): stub\n",
2360 hwndParent, wFlags, cKids);
2361
2362 return 0;
2363 }
2364
2365
2366 /******************************************************************************
2367 * TileWindows (USER32.@) Tiles MDI child windows
2368 *
2369 * RETURNS
2370 * Success: Number of tiled windows.
2371 * Failure: 0
2372 */
2373 WORD WINAPI
2374 TileWindows (HWND hwndParent, UINT wFlags, const LPRECT lpRect,
2375 UINT cKids, const HWND *lpKids)
2376 {
2377 FIXME("(0x%08x,0x%08x,...,%u,...): stub\n",
2378 hwndParent, wFlags, cKids);
2379
2380 return 0;
2381 }
2382
2383 /************************************************************************
2384 * "More Windows..." functionality
2385 */
2386
2387 /* MDI_MoreWindowsDlgProc
2388 *
2389 * This function will process the messages sent to the "More Windows..."
2390 * dialog.
2391 * Return values: 0 = cancel pressed
2392 * HWND = ok pressed or double-click in the list...
2393 *
2394 */
2395
2396 static BOOL WINAPI MDI_MoreWindowsDlgProc (HWND hDlg, UINT iMsg, WPARAM wParam, LPARAM lParam)
2397 {
2398 switch (iMsg)
2399 {
2400 case WM_INITDIALOG:
2401 {
2402 WND *pWnd;
2403 UINT widest = 0;
2404 UINT length;
2405 UINT i;
2406 WND *pParentWnd = (WND *)lParam;
2407 MDICLIENTINFO *ci = (MDICLIENTINFO*)pParentWnd->wExtra;
2408 HWND hListBox = GetDlgItem(hDlg, MDI_IDC_LISTBOX);
2409
2410 /* Fill the list, sorted by id... */
2411 for (i = 0; i < ci->nActiveChildren; i++)
2412 {
2413
2414 /* Find the window with the current ID */
2415 for (pWnd = WIN_LockWndPtr(pParentWnd->child); pWnd; WIN_UpdateWndPtr(&pWnd, pWnd->next))
2416 if (pWnd->wIDmenu == ci->idFirstChild + i)
2417 break;
2418
2419 SendMessageW(hListBox, LB_ADDSTRING, 0, (LPARAM) pWnd->text);
2420 SendMessageA(hListBox, LB_SETITEMDATA, i, (LPARAM) pWnd);
2421 length = strlenW(pWnd->text);
2422 WIN_ReleaseWndPtr(pWnd);
2423
2424 if (length > widest)
2425 widest = length;
2426 }
2427 /* Make sure the horizontal scrollbar scrolls ok */
2428 SendMessageA(hListBox, LB_SETHORIZONTALEXTENT, widest * 6, 0);
2429
2430 /* Set the current selection */
2431 SendMessageA(hListBox, LB_SETCURSEL, MDI_MOREWINDOWSLIMIT, 0);
2432 return TRUE;
2433 }
2434
2435 case WM_COMMAND:
2436 switch (LOWORD(wParam))
2437 {
2438 case IDOK:
2439 {
2440 /* windows are sorted by menu ID, so we must return the
2441 * window associated to the given id
2442 */
2443 HWND hListBox = GetDlgItem(hDlg, MDI_IDC_LISTBOX);
2444 UINT index = SendMessageA(hListBox, LB_GETCURSEL, 0, 0);
2445 WND* pWnd = (WND*) SendMessageA(hListBox, LB_GETITEMDATA, index, 0);
2446
2447 EndDialog(hDlg, pWnd->hwndSelf);
2448 return TRUE;
2449 }
2450 case IDCANCEL:
2451 EndDialog(hDlg, 0);
2452 return TRUE;
2453
2454 default:
2455 switch (HIWORD(wParam))
2456 {
2457 case LBN_DBLCLK:
2458 {
2459 /* windows are sorted by menu ID, so we must return the
2460 * window associated to the given id
2461 */
2462 HWND hListBox = GetDlgItem(hDlg, MDI_IDC_LISTBOX);
2463 UINT index = SendMessageA(hListBox, LB_GETCURSEL, 0, 0);
2464 WND* pWnd = (WND*) SendMessageA(hListBox, LB_GETITEMDATA, index, 0);
2465
2466 EndDialog(hDlg, pWnd->hwndSelf);
2467 return TRUE;
2468 }
2469 }
2470 break;
2471 }
2472 break;
2473 }
2474 return FALSE;
2475 }
2476
2477 /*
2478 *
2479 * MDI_MoreWindowsDialog
2480 *
2481 * Prompts the user with a listbox containing the opened
2482 * documents. The user can then choose a windows and click
2483 * on OK to set the current window to the one selected, or
2484 * CANCEL to cancel. The function returns a handle to the
2485 * selected window.
2486 */
2487
2488 static HWND MDI_MoreWindowsDialog(WND* wndPtr)
2489 {
2490 LPCVOID template;
2491 HRSRC hRes;
2492 HANDLE hDlgTmpl;
2493
2494 hRes = FindResourceA(GetModuleHandleA("USER32"), "MDI_MOREWINDOWS", RT_DIALOGA);
2495
2496 if (hRes == 0)
2497 return 0;
2498
2499 hDlgTmpl = LoadResource(GetModuleHandleA("USER32"), hRes );
2500
2501 if (hDlgTmpl == 0)
2502 return 0;
2503
2504 template = LockResource( hDlgTmpl );
2505
2506 if (template == 0)
2507 return 0;
2508
2509 return (HWND) DialogBoxIndirectParamA(GetModuleHandleA("USER32"),
2510 (LPDLGTEMPLATEA) template,
2511 wndPtr->hwndSelf,
2512 (DLGPROC) MDI_MoreWindowsDlgProc,
2513 (LPARAM) wndPtr);
2514 }
2515
2516 /*
2517 *
2518 * MDI_SwapMenuItems
2519 *
2520 * Will swap the menu IDs for the given 2 positions.
2521 * pos1 and pos2 are menu IDs
2522 *
2523 *
2524 */
2525
2526 static void MDI_SwapMenuItems(WND *parentWnd, UINT pos1, UINT pos2)
2527 {
2528 WND *pWnd;
2529
2530 for (pWnd = WIN_LockWndPtr(parentWnd->child); pWnd; WIN_UpdateWndPtr(&pWnd,pWnd->next))
2531 {
2532 if (pWnd->wIDmenu == pos1)
2533 pWnd->wIDmenu = pos2;
2534 else
2535 if (pWnd->wIDmenu == pos2)
2536 pWnd->wIDmenu = pos1;
2537 }
2538
2539 WIN_ReleaseWndPtr(pWnd);
2540 }
2541
Windows API implementation