3 * Copyright 1994, Bob Amstadt
4 * 1995,1996 Alex Korobka
6 * This file contains routines to support MDI (Multiple Document
7 * Interface) features .
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.
13 * Notes on how the "More Windows..." is implemented:
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:
24 * Name of the child window pWndChild->wIDmenu
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:
40 * Name of the child window pWndChild->wIDmenu
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.
78 #include "wine/unicode.h"
80 #include "nonclient.h"
84 #include "debugtools.h"
87 DEFAULT_DEBUG_CHANNEL(mdi
);
89 #define MDI_MAXLISTLENGTH 0x40
90 #define MDI_MAXTITLELENGTH 0xa1
92 #define MDI_NOFRAMEREPAINT 0
93 #define MDI_REPAINTFRAMENOW 1
94 #define MDI_REPAINTFRAME 2
96 #define WM_MDICALCCHILDSCROLL 0x10ac /* this is exactly what Windows uses */
98 /* "More Windows..." definitions */
99 #define MDI_MOREWINDOWSLIMIT 9 /* after this number of windows, a "More Windows..."
100 option will appear under the Windows menu */
101 #define MDI_IDC_LISTBOX 100
102 #define MDI_IDS_MOREWINDOWS 13
104 #define MDIF_NEEDUPDATE 0x0001
108 UINT nActiveChildren
;
109 HWND hwndChildMaximized
;
110 HWND hwndActiveChild
;
116 UINT sbRecalc
; /* SB_xxx flags for scrollbar fixup */
119 static HBITMAP hBmpClose
= 0;
121 /* ----------------- declarations ----------------- */
122 static void MDI_UpdateFrameText( HWND
, HWND
, BOOL
, LPCWSTR
);
123 static BOOL
MDI_AugmentFrameMenu( HWND
, HWND
);
124 static BOOL
MDI_RestoreFrameMenu( HWND
, HWND
);
125 static LONG
MDI_ChildActivate( HWND
, HWND
);
127 static HWND
MDI_MoreWindowsDialog(HWND
);
128 static void MDI_SwapMenuItems(HWND
, UINT
, UINT
);
129 static LRESULT WINAPI
MDIClientWndProcA( HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
);
130 static LRESULT WINAPI
MDIClientWndProcW( HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
);
132 /* -------- Miscellaneous service functions ----------
136 static HWND
MDI_GetChildByID(HWND hwnd
, UINT id
)
142 if (!(win_array
= WIN_ListChildren( hwnd
))) return 0;
143 for (i
= 0; win_array
[i
]; i
++)
145 if (GetWindowLongA( win_array
[i
], GWL_ID
) == id
) break;
148 HeapFree( GetProcessHeap(), 0, win_array
);
152 static void MDI_PostUpdate(HWND hwnd
, MDICLIENTINFO
* ci
, WORD recalc
)
154 if( !(ci
->mdiFlags
& MDIF_NEEDUPDATE
) )
156 ci
->mdiFlags
|= MDIF_NEEDUPDATE
;
157 PostMessageA( hwnd
, WM_MDICALCCHILDSCROLL
, 0, 0);
159 ci
->sbRecalc
= recalc
;
163 /*********************************************************************
164 * MDIClient class descriptor
166 const struct builtin_class_descr MDICLIENT_builtin_class
=
168 "MDIClient", /* name */
169 CS_GLOBALCLASS
, /* style */
170 MDIClientWndProcA
, /* procA */
171 MDIClientWndProcW
, /* procW */
172 sizeof(MDICLIENTINFO
), /* extra */
173 IDC_ARROWA
, /* cursor */
174 COLOR_APPWORKSPACE
+1 /* brush */
178 static MDICLIENTINFO
*get_client_info( HWND client
)
180 MDICLIENTINFO
*ret
= NULL
;
181 WND
*win
= WIN_GetPtr( client
);
184 if (win
== WND_OTHER_PROCESS
)
186 ERR( "client %x belongs to other process\n", client
);
189 if (win
->cbWndExtra
< sizeof(MDICLIENTINFO
)) WARN( "%x is not an MDI client\n", client
);
190 else ret
= (MDICLIENTINFO
*)win
->wExtra
;
191 WIN_ReleasePtr( win
);
196 /**********************************************************************
199 static void MDI_MenuModifyItem( HWND client
, HWND hWndChild
)
201 MDICLIENTINFO
*clientInfo
= get_client_info( client
);
205 if (!clientInfo
|| !clientInfo
->hWindowMenu
) return;
207 id
= GetWindowLongA( hWndChild
, GWL_ID
);
208 if (id
>= clientInfo
->idFirstChild
+ MDI_MOREWINDOWSLIMIT
) return;
210 buffer
[1] = '1' + id
- clientInfo
->idFirstChild
;
212 GetWindowTextW( hWndChild
, buffer
+ 3, sizeof(buffer
)/sizeof(WCHAR
) - 3 );
214 n
= GetMenuState(clientInfo
->hWindowMenu
, id
, MF_BYCOMMAND
);
215 ModifyMenuW(clientInfo
->hWindowMenu
, id
, MF_BYCOMMAND
| MF_STRING
, id
, buffer
);
216 CheckMenuItem(clientInfo
->hWindowMenu
, id
, n
& MF_CHECKED
);
219 /**********************************************************************
222 static BOOL
MDI_MenuDeleteItem( HWND client
, HWND hWndChild
)
225 static const WCHAR format
[] = {'&','%','d',' ',0};
226 MDICLIENTINFO
*clientInfo
= get_client_info( client
);
229 if( !clientInfo
->nActiveChildren
|| !clientInfo
->hWindowMenu
)
232 id
= GetWindowLongA( hWndChild
, GWL_ID
);
233 DeleteMenu(clientInfo
->hWindowMenu
,id
,MF_BYCOMMAND
);
235 /* walk the rest of MDI children to prevent gaps in the id
236 * sequence and in the menu child list */
238 for( index
= id
+1; index
<= clientInfo
->nActiveChildren
+
239 clientInfo
->idFirstChild
; index
++ )
241 HWND hwnd
= MDI_GetChildByID(client
,index
);
244 TRACE("no window for id=%i\n",index
);
249 SetWindowLongW( hwnd
, GWL_ID
, GetWindowLongW( hwnd
, GWL_ID
) - 1 );
251 n
= wsprintfW(buffer
, format
,index
- clientInfo
->idFirstChild
);
252 GetWindowTextW( hwnd
, buffer
+ n
, sizeof(buffer
)/sizeof(WCHAR
) - n
);
254 /* change menu if the current child is to be shown in the
257 if (index
<= clientInfo
->idFirstChild
+ MDI_MOREWINDOWSLIMIT
)
258 ModifyMenuW(clientInfo
->hWindowMenu
,index
,MF_BYCOMMAND
| MF_STRING
,
259 index
- 1 , buffer
);
262 /* We must restore the "More Windows..." option if there are enough children
264 if (clientInfo
->nActiveChildren
- 1 > MDI_MOREWINDOWSLIMIT
)
267 LoadStringW(GetModuleHandleA("USER32"), MDI_IDS_MOREWINDOWS
, szTmp
, sizeof(szTmp
)/sizeof(szTmp
[0]));
268 AppendMenuW(clientInfo
->hWindowMenu
, MF_STRING
, clientInfo
->idFirstChild
+ MDI_MOREWINDOWSLIMIT
, szTmp
);
273 /**********************************************************************
276 * returns "activateable" child different from the current or zero
278 static HWND
MDI_GetWindow(MDICLIENTINFO
*clientInfo
, HWND hWnd
, BOOL bNext
,
285 dwStyleMask
|= WS_DISABLED
| WS_VISIBLE
;
286 if( !hWnd
) hWnd
= clientInfo
->hwndActiveChild
;
288 if (!(list
= WIN_ListChildren( GetParent(hWnd
) ))) return 0;
290 /* start from next after hWnd */
291 while (list
[i
] && list
[i
] != hWnd
) i
++;
294 for ( ; list
[i
]; i
++)
296 if (GetWindow( list
[i
], GW_OWNER
)) continue;
297 if ((GetWindowLongW( list
[i
], GWL_STYLE
) & dwStyleMask
) != WS_VISIBLE
) continue;
299 if (bNext
) goto found
;
301 /* now restart from the beginning */
302 for (i
= 0; list
[i
] && list
[i
] != hWnd
; i
++)
304 if (GetWindow( list
[i
], GW_OWNER
)) continue;
305 if ((GetWindowLongW( list
[i
], GWL_STYLE
) & dwStyleMask
) != WS_VISIBLE
) continue;
307 if (bNext
) goto found
;
310 HeapFree( GetProcessHeap(), 0, list
);
314 /**********************************************************************
315 * MDI_CalcDefaultChildPos
317 * It seems that the default height is about 2/3 of the client rect
319 static void MDI_CalcDefaultChildPos( HWND hwnd
, WORD n
, LPPOINT lpPos
, INT delta
)
323 INT spacing
= GetSystemMetrics(SM_CYCAPTION
) +
324 GetSystemMetrics(SM_CYFRAME
) - 1;
326 GetClientRect( hwnd
, &rect
);
327 if( rect
.bottom
- rect
.top
- delta
>= spacing
)
328 rect
.bottom
-= delta
;
330 nstagger
= (rect
.bottom
- rect
.top
)/(3 * spacing
);
331 lpPos
[1].x
= (rect
.right
- rect
.left
- nstagger
* spacing
);
332 lpPos
[1].y
= (rect
.bottom
- rect
.top
- nstagger
* spacing
);
333 lpPos
[0].x
= lpPos
[0].y
= spacing
* (n
%(nstagger
+1));
336 /**********************************************************************
339 static LRESULT
MDISetMenu( HWND hwnd
, HMENU hmenuFrame
,
343 HWND hwndFrame
= GetParent(hwnd
);
344 HMENU oldFrameMenu
= GetMenu(hwndFrame
);
346 TRACE("%04x %04x %04x\n",
347 hwnd
, hmenuFrame
, hmenuWindow
);
349 if (hmenuFrame
&& !IsMenu(hmenuFrame
))
351 WARN("hmenuFrame is not a menu handle\n");
355 if (hmenuWindow
&& !IsMenu(hmenuWindow
))
357 WARN("hmenuWindow is not a menu handle\n");
361 if (!(ci
= get_client_info( hwnd
))) return 0;
363 if( ci
->hwndChildMaximized
&& hmenuFrame
&& hmenuFrame
!=oldFrameMenu
)
364 MDI_RestoreFrameMenu( GetParent(hwnd
), ci
->hwndChildMaximized
);
366 if( hmenuWindow
&& ci
->hWindowMenu
&& hmenuWindow
!=ci
->hWindowMenu
)
368 /* delete menu items from ci->hWindowMenu
369 * and add them to hmenuWindow */
371 INT i
= GetMenuItemCount(ci
->hWindowMenu
) - 1;
372 INT pos
= GetMenuItemCount(hmenuWindow
) + 1;
374 AppendMenuA( hmenuWindow
, MF_SEPARATOR
, 0, NULL
);
376 if( ci
->nActiveChildren
)
379 LPWSTR buffer
= NULL
;
381 INT nbWindowsMenuItems
; /* num of documents shown + "More Windows..." if present */
383 if (ci
->nActiveChildren
<= MDI_MOREWINDOWSLIMIT
)
384 nbWindowsMenuItems
= ci
->nActiveChildren
;
386 nbWindowsMenuItems
= MDI_MOREWINDOWSLIMIT
+ 1;
388 j
= i
- nbWindowsMenuItems
+ 1;
390 for( ; i
>= j
; i
-- )
392 memset(&mii
, 0, sizeof(mii
));
393 mii
.cbSize
= sizeof(mii
);
394 mii
.fMask
= MIIM_CHECKMARKS
| MIIM_DATA
| MIIM_ID
| MIIM_STATE
395 | MIIM_SUBMENU
| MIIM_TYPE
| MIIM_BITMAP
;
397 GetMenuItemInfoW(ci
->hWindowMenu
, i
, TRUE
, &mii
);
398 if(mii
.cch
) { /* Menu is MFT_STRING */
399 mii
.cch
++; /* add room for '\0' */
400 buffer
= HeapAlloc(GetProcessHeap(), 0,
401 mii
.cch
* sizeof(WCHAR
));
402 mii
.dwTypeData
= buffer
;
403 GetMenuItemInfoW(ci
->hWindowMenu
, i
, TRUE
, &mii
);
405 DeleteMenu(ci
->hWindowMenu
, i
, MF_BYPOSITION
);
406 InsertMenuItemW(hmenuWindow
, pos
, TRUE
, &mii
);
408 HeapFree(GetProcessHeap(), 0, buffer
);
414 /* remove separator */
415 DeleteMenu(ci
->hWindowMenu
, i
, MF_BYPOSITION
);
417 ci
->hWindowMenu
= hmenuWindow
;
422 SetMenu(hwndFrame
, hmenuFrame
);
423 if( hmenuFrame
!=oldFrameMenu
)
425 if( ci
->hwndChildMaximized
)
426 MDI_AugmentFrameMenu( GetParent(hwnd
), ci
->hwndChildMaximized
);
432 HMENU menu
= GetMenu( GetParent(hwnd
) );
433 INT nItems
= GetMenuItemCount(menu
) - 1;
434 UINT iId
= GetMenuItemID(menu
,nItems
) ;
436 if( !(iId
== SC_RESTORE
|| iId
== SC_CLOSE
) )
438 /* SetMenu() may already have been called, meaning that this window
439 * already has its menu. But they may have done a SetMenu() on
440 * an MDI window, and called MDISetMenu() after the fact, meaning
441 * that the "if" to this "else" wouldn't catch the need to
442 * augment the frame menu.
444 if( ci
->hwndChildMaximized
)
445 MDI_AugmentFrameMenu( GetParent(hwnd
), ci
->hwndChildMaximized
);
451 /**********************************************************************
454 static LRESULT
MDIRefreshMenu( HWND hwnd
, HMENU hmenuFrame
,
457 HWND hwndFrame
= GetParent(hwnd
);
458 HMENU oldFrameMenu
= GetMenu(hwndFrame
);
460 TRACE("%04x %04x %04x\n",
461 hwnd
, hmenuFrame
, hmenuWindow
);
463 FIXME("partially function stub\n");
469 /* ------------------ MDI child window functions ---------------------- */
472 /**********************************************************************
475 static HWND
MDICreateChild( HWND parent
, MDICLIENTINFO
*ci
,
476 LPMDICREATESTRUCTA cs
, BOOL unicode
)
479 DWORD style
= cs
->style
| (WS_CHILD
| WS_CLIPSIBLINGS
);
480 HWND hwnd
, hwndMax
= 0;
481 UINT wIDmenu
= ci
->idFirstChild
+ ci
->nActiveChildren
;
483 static const WCHAR lpstrDef
[] = {'j','u','n','k','!',0};
485 TRACE("origin %i,%i - dim %i,%i, style %08lx\n",
486 cs
->x
, cs
->y
, cs
->cx
, cs
->cy
, cs
->style
);
487 /* calculate placement */
488 MDI_CalcDefaultChildPos(parent
, ci
->nTotalCreated
++, pos
, 0);
490 if (cs
->cx
== CW_USEDEFAULT
|| cs
->cx
== CW_USEDEFAULT16
|| !cs
->cx
) cs
->cx
= pos
[1].x
;
491 if (cs
->cy
== CW_USEDEFAULT
|| cs
->cy
== CW_USEDEFAULT16
|| !cs
->cy
) cs
->cy
= pos
[1].y
;
493 if (cs
->x
== CW_USEDEFAULT
|| cs
->x
== CW_USEDEFAULT16
)
499 /* restore current maximized child */
500 if( (style
& WS_VISIBLE
) && ci
->hwndChildMaximized
)
502 TRACE("Restoring current maximized child %04x\n", ci
->hwndChildMaximized
);
503 if( style
& WS_MAXIMIZE
)
504 SendMessageW(parent
, WM_SETREDRAW
, FALSE
, 0L);
505 hwndMax
= ci
->hwndChildMaximized
;
506 ShowWindow( hwndMax
, SW_SHOWNOACTIVATE
);
507 if( style
& WS_MAXIMIZE
)
508 SendMessageW(parent
, WM_SETREDRAW
, TRUE
, 0L);
511 if (ci
->nActiveChildren
<= MDI_MOREWINDOWSLIMIT
)
512 /* this menu is needed to set a check mark in MDI_ChildActivate */
513 if (ci
->hWindowMenu
!= 0)
514 AppendMenuW(ci
->hWindowMenu
, MF_STRING
, wIDmenu
, lpstrDef
);
516 ci
->nActiveChildren
++;
518 /* fix window style */
519 wndParent
= WIN_FindWndPtr( parent
);
520 if( !(wndParent
->dwStyle
& MDIS_ALLCHILDSTYLES
) )
522 TRACE("MDIS_ALLCHILDSTYLES is missing, fixing window style\n");
523 style
&= (WS_CHILD
| WS_CLIPSIBLINGS
| WS_MINIMIZE
| WS_MAXIMIZE
|
524 WS_CLIPCHILDREN
| WS_DISABLED
| WS_VSCROLL
| WS_HSCROLL
);
525 style
|= (WS_VISIBLE
| WS_OVERLAPPEDWINDOW
);
528 if( wndParent
->flags
& WIN_ISWIN32
)
530 WIN_ReleaseWndPtr( wndParent
);
533 MDICREATESTRUCTW
*csW
= (MDICREATESTRUCTW
*)cs
;
534 hwnd
= CreateWindowW( csW
->szClass
, csW
->szTitle
, style
,
535 csW
->x
, csW
->y
, csW
->cx
, csW
->cy
, parent
,
536 (HMENU
)wIDmenu
, csW
->hOwner
, csW
);
539 hwnd
= CreateWindowA( cs
->szClass
, cs
->szTitle
, style
,
540 cs
->x
, cs
->y
, cs
->cx
, cs
->cy
, parent
,
541 (HMENU
)wIDmenu
, cs
->hOwner
, cs
);
545 MDICREATESTRUCT16 cs16
;
546 SEGPTR title
, cls
, seg_cs16
;
548 WIN_ReleaseWndPtr( wndParent
);
549 STRUCT32_MDICREATESTRUCT32Ato16( cs
, &cs16
);
550 cs16
.szTitle
= title
= MapLS( cs
->szTitle
);
551 cs16
.szClass
= cls
= MapLS( cs
->szClass
);
552 seg_cs16
= MapLS( &cs16
);
553 hwnd
= WIN_Handle32( CreateWindow16( cs
->szClass
, cs
->szTitle
, style
,
554 cs16
.x
, cs16
.y
, cs16
.cx
, cs16
.cy
,
555 WIN_Handle16(parent
), (HMENU
)wIDmenu
,
556 cs16
.hOwner
, (LPVOID
)seg_cs16
));
562 /* MDI windows are WS_CHILD so they won't be activated by CreateWindow */
566 /* All MDI child windows have the WS_EX_MDICHILD style */
567 SetWindowLongW( hwnd
, GWL_EXSTYLE
, GetWindowLongW( hwnd
, GWL_EXSTYLE
) | WS_EX_MDICHILD
);
569 /* If we have more than 9 windows, we must insert the new one at the
570 * 9th position in order to see it in the "Windows" menu
572 if (ci
->nActiveChildren
> MDI_MOREWINDOWSLIMIT
)
573 MDI_SwapMenuItems( parent
, GetWindowLongW( hwnd
, GWL_ID
),
574 ci
->idFirstChild
+ MDI_MOREWINDOWSLIMIT
- 1);
576 MDI_MenuModifyItem(parent
, hwnd
);
578 /* Have we hit the "More Windows..." limit? If so, we must
579 * add a "More Windows..." option
581 if (ci
->nActiveChildren
== MDI_MOREWINDOWSLIMIT
+ 1)
584 LoadStringW(GetModuleHandleA("USER32"), MDI_IDS_MOREWINDOWS
, szTmp
, sizeof(szTmp
)/sizeof(szTmp
[0]));
586 ModifyMenuW(ci
->hWindowMenu
,
587 ci
->idFirstChild
+ MDI_MOREWINDOWSLIMIT
,
588 MF_BYCOMMAND
| MF_STRING
,
589 ci
->idFirstChild
+ MDI_MOREWINDOWSLIMIT
,
593 if( IsIconic(hwnd
) && ci
->hwndActiveChild
)
595 TRACE("Minimizing created MDI child %04x\n", hwnd
);
596 ShowWindow( hwnd
, SW_SHOWMINNOACTIVE
);
600 /* WS_VISIBLE is clear if a) the MDI client has
601 * MDIS_ALLCHILDSTYLES style and 2) the flag is cleared in the
602 * MDICreateStruct. If so the created window is not shown nor
605 if (IsWindowVisible(hwnd
)) ShowWindow(hwnd
, SW_SHOW
);
607 TRACE("created child - %04x\n",hwnd
);
611 ci
->nActiveChildren
--;
612 DeleteMenu(ci
->hWindowMenu
,wIDmenu
,MF_BYCOMMAND
);
613 if( IsWindow(hwndMax
) )
614 ShowWindow(hwndMax
, SW_SHOWMAXIMIZED
);
620 /**********************************************************************
621 * MDI_ChildGetMinMaxInfo
623 * Note: The rule here is that client rect of the maximized MDI child
624 * is equal to the client rect of the MDI client window.
626 static void MDI_ChildGetMinMaxInfo( HWND client
, HWND hwnd
, MINMAXINFO
* lpMinMax
)
630 GetClientRect( client
, &rect
);
631 AdjustWindowRectEx( &rect
, GetWindowLongW( hwnd
, GWL_STYLE
),
632 0, GetWindowLongW( hwnd
, GWL_EXSTYLE
));
634 lpMinMax
->ptMaxSize
.x
= rect
.right
-= rect
.left
;
635 lpMinMax
->ptMaxSize
.y
= rect
.bottom
-= rect
.top
;
637 lpMinMax
->ptMaxPosition
.x
= rect
.left
;
638 lpMinMax
->ptMaxPosition
.y
= rect
.top
;
640 TRACE("max rect (%i,%i - %i, %i)\n",
641 rect
.left
,rect
.top
,rect
.right
,rect
.bottom
);
644 /**********************************************************************
645 * MDI_SwitchActiveChild
647 * Note: SetWindowPos sends WM_CHILDACTIVATE to the child window that is
650 static void MDI_SwitchActiveChild( HWND clientHwnd
, HWND childHwnd
,
655 MDICLIENTINFO
*ci
= get_client_info( clientHwnd
);
657 hwndTo
= MDI_GetWindow(ci
, childHwnd
, bNextWindow
, 0);
659 TRACE("from %04x, to %04x\n",childHwnd
,hwndTo
);
661 if ( !hwndTo
) return; /* no window to switch to */
663 hwndPrev
= ci
->hwndActiveChild
;
665 if ( hwndTo
!= hwndPrev
)
667 SetWindowPos( hwndTo
, HWND_TOP
, 0, 0, 0, 0,
668 SWP_NOMOVE
| SWP_NOSIZE
);
670 if( bNextWindow
&& hwndPrev
)
671 SetWindowPos( hwndPrev
, HWND_BOTTOM
, 0, 0, 0, 0,
672 SWP_NOMOVE
| SWP_NOSIZE
| SWP_NOACTIVATE
);
677 /**********************************************************************
680 static LRESULT
MDIDestroyChild( HWND parent
, MDICLIENTINFO
*ci
,
681 HWND child
, BOOL flagDestroy
)
683 if( child
== ci
->hwndActiveChild
)
685 MDI_SwitchActiveChild(parent
, child
, TRUE
);
687 if( child
== ci
->hwndActiveChild
)
689 ShowWindow( child
, SW_HIDE
);
690 if( child
== ci
->hwndChildMaximized
)
692 HWND frame
= GetParent(parent
);
693 MDI_RestoreFrameMenu( frame
, child
);
694 ci
->hwndChildMaximized
= 0;
695 MDI_UpdateFrameText( frame
, parent
, TRUE
, NULL
);
698 MDI_ChildActivate(parent
, 0);
702 MDI_MenuDeleteItem(parent
, child
);
704 ci
->nActiveChildren
--;
706 TRACE("child destroyed - %04x\n",child
);
710 MDI_PostUpdate(GetParent(child
), ci
, SB_BOTH
+1);
711 DestroyWindow(child
);
717 /**********************************************************************
720 * Note: hWndChild is NULL when last child is being destroyed
722 static LONG
MDI_ChildActivate( HWND client
, HWND child
)
724 MDICLIENTINFO
*clientInfo
= get_client_info( client
);
725 HWND prevActiveWnd
= clientInfo
->hwndActiveChild
;
726 BOOL isActiveFrameWnd
;
728 if (child
&& (!IsWindowEnabled( child
))) return 0;
730 /* Don't activate if it is already active. Might happen
731 since ShowWindow DOES activate MDI children */
732 if (clientInfo
->hwndActiveChild
== child
) return 0;
734 TRACE("%04x\n", child
);
736 isActiveFrameWnd
= (GetActiveWindow() == GetParent(client
));
738 /* deactivate prev. active child */
741 SetWindowLongA( prevActiveWnd
, GWL_STYLE
,
742 GetWindowLongA( prevActiveWnd
, GWL_STYLE
) | WS_SYSMENU
);
743 SendMessageA( prevActiveWnd
, WM_NCACTIVATE
, FALSE
, 0L );
744 SendMessageA( prevActiveWnd
, WM_MDIACTIVATE
, (WPARAM
)prevActiveWnd
, (LPARAM
)child
);
745 /* uncheck menu item */
746 if( clientInfo
->hWindowMenu
)
748 UINT prevID
= GetWindowLongA( prevActiveWnd
, GWL_ID
);
750 if (prevID
- clientInfo
->idFirstChild
< MDI_MOREWINDOWSLIMIT
)
751 CheckMenuItem( clientInfo
->hWindowMenu
, prevID
, 0);
753 CheckMenuItem( clientInfo
->hWindowMenu
,
754 clientInfo
->idFirstChild
+ MDI_MOREWINDOWSLIMIT
- 1, 0);
759 if (clientInfo
->hwndChildMaximized
&& clientInfo
->hwndChildMaximized
!= child
)
763 clientInfo
->hwndActiveChild
= child
;
764 ShowWindow( child
, SW_SHOWMAXIMIZED
);
766 else ShowWindow( clientInfo
->hwndActiveChild
, SW_SHOWNORMAL
);
769 clientInfo
->hwndActiveChild
= child
;
771 /* check if we have any children left */
774 if( isActiveFrameWnd
)
779 /* check menu item */
780 if( clientInfo
->hWindowMenu
)
782 UINT id
= GetWindowLongA( child
, GWL_ID
);
783 /* The window to be activated must be displayed in the "Windows" menu */
784 if (id
>= clientInfo
->idFirstChild
+ MDI_MOREWINDOWSLIMIT
)
786 MDI_SwapMenuItems( GetParent(child
),
787 id
, clientInfo
->idFirstChild
+ MDI_MOREWINDOWSLIMIT
- 1);
788 id
= clientInfo
->idFirstChild
+ MDI_MOREWINDOWSLIMIT
- 1;
789 MDI_MenuModifyItem( GetParent(child
), child
);
792 CheckMenuItem(clientInfo
->hWindowMenu
, id
, MF_CHECKED
);
794 /* bring active child to the top */
795 SetWindowPos( child
, 0,0,0,0,0, SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
);
797 if( isActiveFrameWnd
)
799 SendMessageA( child
, WM_NCACTIVATE
, TRUE
, 0L);
800 if( GetFocus() == client
)
801 SendMessageA( client
, WM_SETFOCUS
, (WPARAM
)client
, 0L );
805 SendMessageA( child
, WM_MDIACTIVATE
, (WPARAM
)prevActiveWnd
, (LPARAM
)child
);
809 /* -------------------- MDI client window functions ------------------- */
811 /**********************************************************************
812 * CreateMDIMenuBitmap
814 static HBITMAP
CreateMDIMenuBitmap(void)
816 HDC hDCSrc
= CreateCompatibleDC(0);
817 HDC hDCDest
= CreateCompatibleDC(hDCSrc
);
818 HBITMAP hbClose
= LoadBitmapW(0, MAKEINTRESOURCEW(OBM_OLD_CLOSE
) );
820 HBITMAP hobjSrc
, hobjDest
;
822 hobjSrc
= SelectObject(hDCSrc
, hbClose
);
823 hbCopy
= CreateCompatibleBitmap(hDCSrc
,GetSystemMetrics(SM_CXSIZE
),GetSystemMetrics(SM_CYSIZE
));
824 hobjDest
= SelectObject(hDCDest
, hbCopy
);
826 BitBlt(hDCDest
, 0, 0, GetSystemMetrics(SM_CXSIZE
), GetSystemMetrics(SM_CYSIZE
),
827 hDCSrc
, GetSystemMetrics(SM_CXSIZE
), 0, SRCCOPY
);
829 SelectObject(hDCSrc
, hobjSrc
);
830 DeleteObject(hbClose
);
833 hobjSrc
= SelectObject( hDCDest
, GetStockObject(BLACK_PEN
) );
835 MoveToEx( hDCDest
, GetSystemMetrics(SM_CXSIZE
) - 1, 0, NULL
);
836 LineTo( hDCDest
, GetSystemMetrics(SM_CXSIZE
) - 1, GetSystemMetrics(SM_CYSIZE
) - 1);
838 SelectObject(hDCDest
, hobjSrc
);
839 SelectObject(hDCDest
, hobjDest
);
845 /**********************************************************************
848 static LONG
MDICascade( HWND client
, MDICLIENTINFO
*ci
)
851 BOOL has_icons
= FALSE
;
854 if (ci
->hwndChildMaximized
)
855 SendMessageA( client
, WM_MDIRESTORE
,
856 (WPARAM
)ci
->hwndChildMaximized
, 0);
858 if (ci
->nActiveChildren
== 0) return 0;
860 if (!(win_array
= WIN_ListChildren( client
))) return 0;
862 /* remove all the windows we don't want */
863 for (i
= total
= 0; win_array
[i
]; i
++)
865 if (!IsWindowVisible( win_array
[i
] )) continue;
866 if (GetWindow( win_array
[i
], GW_OWNER
)) continue; /* skip owned windows */
867 if (IsIconic( win_array
[i
] ))
872 win_array
[total
++] = win_array
[i
];
874 win_array
[total
] = 0;
878 INT delta
= 0, n
= 0, i
;
880 if (has_icons
) delta
= GetSystemMetrics(SM_CYICONSPACING
) + GetSystemMetrics(SM_CYICON
);
882 /* walk the list (backwards) and move windows */
883 for (i
= total
- 1; i
>= 0; i
--)
885 TRACE("move %04x to (%ld,%ld) size [%ld,%ld]\n",
886 win_array
[i
], pos
[0].x
, pos
[0].y
, pos
[1].x
, pos
[1].y
);
888 MDI_CalcDefaultChildPos(client
, n
++, pos
, delta
);
889 SetWindowPos( win_array
[i
], 0, pos
[0].x
, pos
[0].y
, pos
[1].x
, pos
[1].y
,
890 SWP_DRAWFRAME
| SWP_NOACTIVATE
| SWP_NOZORDER
);
893 HeapFree( GetProcessHeap(), 0, win_array
);
895 if (has_icons
) ArrangeIconicWindows( client
);
899 /**********************************************************************
902 static void MDITile( HWND client
, MDICLIENTINFO
*ci
, WPARAM wParam
)
906 BOOL has_icons
= FALSE
;
908 if (ci
->hwndChildMaximized
)
909 SendMessageA( client
, WM_MDIRESTORE
, (WPARAM
)ci
->hwndChildMaximized
, 0);
911 if (ci
->nActiveChildren
== 0) return;
913 if (!(win_array
= WIN_ListChildren( client
))) return;
915 /* remove all the windows we don't want */
916 for (i
= total
= 0; win_array
[i
]; i
++)
918 if (!IsWindowVisible( win_array
[i
] )) continue;
919 if (GetWindow( win_array
[i
], GW_OWNER
)) continue; /* skip owned windows (icon titles) */
920 if (IsIconic( win_array
[i
] ))
925 if ((wParam
& MDITILE_SKIPDISABLED
) && !IsWindowEnabled( win_array
[i
] )) continue;
926 win_array
[total
++] = win_array
[i
];
928 win_array
[total
] = 0;
930 TRACE("%u windows to tile\n", total
);
934 HWND
*pWnd
= win_array
;
936 int x
, y
, xsize
, ysize
;
937 int rows
, columns
, r
, c
, i
;
939 GetClientRect(client
,&rect
);
940 rows
= (int) sqrt((double)total
);
941 columns
= total
/ rows
;
943 if( wParam
& MDITILE_HORIZONTAL
) /* version >= 3.1 */
946 rows
= columns
; /* exchange r and c */
952 y
= rect
.bottom
- 2 * GetSystemMetrics(SM_CYICONSPACING
) - GetSystemMetrics(SM_CYICON
);
953 rect
.bottom
= ( y
- GetSystemMetrics(SM_CYICON
) < rect
.top
)? rect
.bottom
: y
;
956 ysize
= rect
.bottom
/ rows
;
957 xsize
= rect
.right
/ columns
;
959 for (x
= i
= 0, c
= 1; c
<= columns
&& *pWnd
; c
++)
964 ysize
= rect
.bottom
/ rows
;
968 for (r
= 1; r
<= rows
&& *pWnd
; r
++, i
++)
970 SetWindowPos(*pWnd
, 0, x
, y
, xsize
, ysize
,
971 SWP_DRAWFRAME
| SWP_NOACTIVATE
| SWP_NOZORDER
);
978 HeapFree( GetProcessHeap(), 0, win_array
);
979 if (has_icons
) ArrangeIconicWindows( client
);
982 /* ----------------------- Frame window ---------------------------- */
985 /**********************************************************************
986 * MDI_AugmentFrameMenu
988 static BOOL
MDI_AugmentFrameMenu( HWND frame
, HWND hChild
)
990 HMENU menu
= GetMenu( frame
);
991 WND
* child
= WIN_FindWndPtr(hChild
);
993 HBITMAP hSysMenuBitmap
= 0;
995 TRACE("frame %04x,child %04x\n",frame
,hChild
);
997 if( !menu
|| !child
->hSysMenu
)
999 WIN_ReleaseWndPtr(child
);
1002 WIN_ReleaseWndPtr(child
);
1004 /* create a copy of sysmenu popup and insert it into frame menu bar */
1006 if (!(hSysPopup
= LoadMenuA(GetModuleHandleA("USER32"), "SYSMENU")))
1009 AppendMenuA(menu
,MF_HELP
| MF_BITMAP
,
1010 SC_MINIMIZE
, (LPSTR
)(DWORD
)HBMMENU_MBAR_MINIMIZE
) ;
1011 AppendMenuA(menu
,MF_HELP
| MF_BITMAP
,
1012 SC_RESTORE
, (LPSTR
)(DWORD
)HBMMENU_MBAR_RESTORE
);
1014 /* In Win 95 look, the system menu is replaced by the child icon */
1016 if(TWEAK_WineLook
> WIN31_LOOK
)
1018 HICON hIcon
= GetClassLongA(hChild
, GCL_HICONSM
);
1020 hIcon
= GetClassLongA(hChild
, GCL_HICON
);
1024 HBITMAP hBitmap
, hOldBitmap
;
1026 HDC hdc
= GetDC(hChild
);
1031 cx
= GetSystemMetrics(SM_CXSMICON
);
1032 cy
= GetSystemMetrics(SM_CYSMICON
);
1033 hMemDC
= CreateCompatibleDC(hdc
);
1034 hBitmap
= CreateCompatibleBitmap(hdc
, cx
, cy
);
1035 hOldBitmap
= SelectObject(hMemDC
, hBitmap
);
1036 SetMapMode(hMemDC
, MM_TEXT
);
1037 hBrush
= CreateSolidBrush(GetSysColor(COLOR_MENU
));
1038 DrawIconEx(hMemDC
, 0, 0, hIcon
, cx
, cy
, 0, hBrush
, DI_NORMAL
);
1039 SelectObject (hMemDC
, hOldBitmap
);
1040 DeleteObject(hBrush
);
1042 ReleaseDC(hChild
, hdc
);
1043 hSysMenuBitmap
= hBitmap
;
1048 hSysMenuBitmap
= hBmpClose
;
1050 if( !InsertMenuA(menu
,0,MF_BYPOSITION
| MF_BITMAP
| MF_POPUP
,
1051 hSysPopup
, (LPSTR
)(DWORD
)hSysMenuBitmap
))
1053 TRACE("not inserted\n");
1054 DestroyMenu(hSysPopup
);
1058 /* The close button is only present in Win 95 look */
1059 if(TWEAK_WineLook
> WIN31_LOOK
)
1061 AppendMenuA(menu
,MF_HELP
| MF_BITMAP
,
1062 SC_CLOSE
, (LPSTR
)(DWORD
)HBMMENU_MBAR_CLOSE
);
1065 EnableMenuItem(hSysPopup
, SC_SIZE
, MF_BYCOMMAND
| MF_GRAYED
);
1066 EnableMenuItem(hSysPopup
, SC_MOVE
, MF_BYCOMMAND
| MF_GRAYED
);
1067 EnableMenuItem(hSysPopup
, SC_MAXIMIZE
, MF_BYCOMMAND
| MF_GRAYED
);
1068 SetMenuDefaultItem(hSysPopup
, SC_CLOSE
, FALSE
);
1076 /**********************************************************************
1077 * MDI_RestoreFrameMenu
1079 static BOOL
MDI_RestoreFrameMenu( HWND frame
, HWND hChild
)
1081 MENUITEMINFOW menuInfo
;
1082 HMENU menu
= GetMenu( frame
);
1083 INT nItems
= GetMenuItemCount(menu
) - 1;
1084 UINT iId
= GetMenuItemID(menu
,nItems
) ;
1086 TRACE("frame %04x,child %04x,nIt=%d,iId=%d\n",frame
,hChild
,nItems
,iId
);
1088 if(!(iId
== SC_RESTORE
|| iId
== SC_CLOSE
) )
1092 * Remove the system menu, If that menu is the icon of the window
1093 * as it is in win95, we have to delete the bitmap.
1095 memset(&menuInfo
, 0, sizeof(menuInfo
));
1096 menuInfo
.cbSize
= sizeof(menuInfo
);
1097 menuInfo
.fMask
= MIIM_DATA
| MIIM_TYPE
;
1099 GetMenuItemInfoW(menu
,
1104 RemoveMenu(menu
,0,MF_BYPOSITION
);
1106 if ( (menuInfo
.fType
& MFT_BITMAP
) &&
1107 (LOWORD(menuInfo
.dwTypeData
)!=0) &&
1108 (LOWORD(menuInfo
.dwTypeData
)!=hBmpClose
) )
1110 DeleteObject((HBITMAP
)LOWORD(menuInfo
.dwTypeData
));
1113 if(TWEAK_WineLook
> WIN31_LOOK
)
1116 DeleteMenu(menu
,GetMenuItemCount(menu
) - 1,MF_BYPOSITION
);
1119 DeleteMenu(menu
,GetMenuItemCount(menu
) - 1,MF_BYPOSITION
);
1121 DeleteMenu(menu
,GetMenuItemCount(menu
) - 1,MF_BYPOSITION
);
1129 /**********************************************************************
1130 * MDI_UpdateFrameText
1132 * used when child window is maximized/restored
1134 * Note: lpTitle can be NULL
1136 static void MDI_UpdateFrameText( HWND frame
, HWND hClient
,
1137 BOOL repaint
, LPCWSTR lpTitle
)
1139 WCHAR lpBuffer
[MDI_MAXTITLELENGTH
+1];
1140 MDICLIENTINFO
*ci
= get_client_info( hClient
);
1142 TRACE("repaint %i, frameText %s\n", repaint
, debugstr_w(lpTitle
));
1146 if (!lpTitle
&& !ci
->frameTitle
) /* first time around, get title from the frame window */
1148 GetWindowTextW( frame
, lpBuffer
, sizeof(lpBuffer
)/sizeof(WCHAR
) );
1152 /* store new "default" title if lpTitle is not NULL */
1155 if (ci
->frameTitle
) HeapFree( GetProcessHeap(), 0, ci
->frameTitle
);
1156 if ((ci
->frameTitle
= HeapAlloc( GetProcessHeap(), 0, (strlenW(lpTitle
)+1)*sizeof(WCHAR
))))
1157 strcpyW( ci
->frameTitle
, lpTitle
);
1162 if (ci
->hwndChildMaximized
)
1164 /* combine frame title and child title if possible */
1166 static const WCHAR lpBracket
[] = {' ','-',' ','[',0};
1167 static const WCHAR lpBracket2
[] = {']',0};
1168 int i_frame_text_length
= strlenW(ci
->frameTitle
);
1170 lstrcpynW( lpBuffer
, ci
->frameTitle
, MDI_MAXTITLELENGTH
);
1172 if( i_frame_text_length
+ 6 < MDI_MAXTITLELENGTH
)
1174 strcatW( lpBuffer
, lpBracket
);
1175 if (GetWindowTextW( ci
->hwndChildMaximized
, lpBuffer
+ i_frame_text_length
+ 4,
1176 MDI_MAXTITLELENGTH
- i_frame_text_length
- 5 ))
1177 strcatW( lpBuffer
, lpBracket2
);
1179 lpBuffer
[i_frame_text_length
] = 0; /* remove bracket */
1184 lstrcpynW(lpBuffer
, ci
->frameTitle
, MDI_MAXTITLELENGTH
+1 );
1190 DefWindowProcW( frame
, WM_SETTEXT
, 0, (LPARAM
)lpBuffer
);
1191 if( repaint
== MDI_REPAINTFRAME
)
1192 SetWindowPos( frame
, 0,0,0,0,0, SWP_FRAMECHANGED
|
1193 SWP_NOSIZE
| SWP_NOMOVE
| SWP_NOACTIVATE
| SWP_NOZORDER
);
1197 /* ----------------------------- Interface ---------------------------- */
1200 /**********************************************************************
1201 * MDIClientWndProc_common
1203 static LRESULT
MDIClientWndProc_common( HWND hwnd
, UINT message
,
1204 WPARAM wParam
, LPARAM lParam
, BOOL unicode
)
1208 if (!(ci
= get_client_info( hwnd
))) return 0;
1215 /* Since we are using only cs->lpCreateParams, we can safely
1216 * cast to LPCREATESTRUCTA here */
1217 LPCREATESTRUCTA cs
= (LPCREATESTRUCTA
)lParam
;
1218 WND
*wndPtr
= WIN_GetPtr( hwnd
);
1220 /* Translation layer doesn't know what's in the cs->lpCreateParams
1221 * so we have to keep track of what environment we're in. */
1223 if( wndPtr
->flags
& WIN_ISWIN32
)
1225 #define ccs ((LPCLIENTCREATESTRUCT)cs->lpCreateParams)
1226 ci
->hWindowMenu
= ccs
->hWindowMenu
;
1227 ci
->idFirstChild
= ccs
->idFirstChild
;
1232 LPCLIENTCREATESTRUCT16 ccs
= MapSL((SEGPTR
)cs
->lpCreateParams
);
1233 ci
->hWindowMenu
= ccs
->hWindowMenu
;
1234 ci
->idFirstChild
= ccs
->idFirstChild
;
1236 WIN_ReleasePtr( wndPtr
);
1238 ci
->hwndChildMaximized
= 0;
1239 ci
->nActiveChildren
= 0;
1240 ci
->nTotalCreated
= 0;
1241 ci
->frameTitle
= NULL
;
1243 SetWindowLongW( hwnd
, GWL_STYLE
, GetWindowLongW(hwnd
,GWL_STYLE
) | WS_CLIPCHILDREN
);
1245 if (!hBmpClose
) hBmpClose
= CreateMDIMenuBitmap();
1247 if (ci
->hWindowMenu
!= 0)
1248 AppendMenuW( ci
->hWindowMenu
, MF_SEPARATOR
, 0, NULL
);
1250 GetClientRect( GetParent(hwnd
), &rect
);
1251 MoveWindow( hwnd
, 0, 0, rect
.right
, rect
.bottom
, FALSE
);
1253 MDI_UpdateFrameText( GetParent(hwnd
), hwnd
, MDI_NOFRAMEREPAINT
, NULL
);
1255 TRACE("Client created - hwnd = %04x, idFirst = %u\n",
1256 hwnd
, ci
->idFirstChild
);
1263 if( ci
->hwndChildMaximized
)
1264 MDI_RestoreFrameMenu( GetParent(hwnd
), ci
->hwndChildMaximized
);
1265 if((ci
->hWindowMenu
!= 0) &&
1266 (nItems
= GetMenuItemCount(ci
->hWindowMenu
)) > 0)
1268 ci
->idFirstChild
= nItems
- 1;
1269 ci
->nActiveChildren
++; /* to delete a separator */
1270 while( ci
->nActiveChildren
-- )
1271 DeleteMenu(ci
->hWindowMenu
,MF_BYPOSITION
,ci
->idFirstChild
--);
1273 if (ci
->frameTitle
) HeapFree( GetProcessHeap(), 0, ci
->frameTitle
);
1277 case WM_MDIACTIVATE
:
1278 if( ci
->hwndActiveChild
!= (HWND
)wParam
)
1279 SetWindowPos((HWND
)wParam
, 0,0,0,0,0, SWP_NOSIZE
| SWP_NOMOVE
);
1283 return MDICascade(hwnd
, ci
);
1287 return (LRESULT
)MDICreateChild( hwnd
, ci
, (MDICREATESTRUCTA
*)lParam
, unicode
);
1291 return MDIDestroyChild( hwnd
, ci
, WIN_GetFullHandle( (HWND
)wParam
), TRUE
);
1293 case WM_MDIGETACTIVE
:
1294 if (lParam
) *(BOOL
*)lParam
= (ci
->hwndChildMaximized
!= 0);
1295 return (LRESULT
)ci
->hwndActiveChild
;
1297 case WM_MDIICONARRANGE
:
1298 ci
->mdiFlags
|= MDIF_NEEDUPDATE
;
1299 ArrangeIconicWindows( hwnd
);
1300 ci
->sbRecalc
= SB_BOTH
+1;
1301 SendMessageW( hwnd
, WM_MDICALCCHILDSCROLL
, 0, 0 );
1304 case WM_MDIMAXIMIZE
:
1305 ShowWindow( (HWND
)wParam
, SW_MAXIMIZE
);
1308 case WM_MDINEXT
: /* lParam != 0 means previous window */
1309 MDI_SwitchActiveChild( hwnd
, WIN_GetFullHandle( (HWND
)wParam
), !lParam
);
1313 SendMessageW( (HWND
)wParam
, WM_SYSCOMMAND
, SC_RESTORE
, 0);
1317 return MDISetMenu( hwnd
, (HMENU
)wParam
, (HMENU
)lParam
);
1319 case WM_MDIREFRESHMENU
:
1320 return MDIRefreshMenu( hwnd
, (HMENU
)wParam
, (HMENU
)lParam
);
1323 ci
->mdiFlags
|= MDIF_NEEDUPDATE
;
1324 ShowScrollBar( hwnd
, SB_BOTH
, FALSE
);
1325 MDITile( hwnd
, ci
, wParam
);
1326 ci
->mdiFlags
&= ~MDIF_NEEDUPDATE
;
1331 ci
->mdiFlags
|= MDIF_NEEDUPDATE
;
1332 ScrollChildren( hwnd
, message
, wParam
, lParam
);
1333 ci
->mdiFlags
&= ~MDIF_NEEDUPDATE
;
1337 if (ci
->hwndActiveChild
&& !IsIconic( ci
->hwndActiveChild
))
1338 SetFocus( ci
->hwndActiveChild
);
1342 if( ci
->hwndActiveChild
)
1343 SendMessageW(ci
->hwndActiveChild
, message
, wParam
, lParam
);
1346 case WM_PARENTNOTIFY
:
1347 if (LOWORD(wParam
) == WM_LBUTTONDOWN
)
1351 pt
.x
= SLOWORD(lParam
);
1352 pt
.y
= SHIWORD(lParam
);
1353 child
= ChildWindowFromPoint(hwnd
, pt
);
1355 TRACE("notification from %04x (%li,%li)\n",child
,pt
.x
,pt
.y
);
1357 if( child
&& child
!= hwnd
&& child
!= ci
->hwndActiveChild
)
1358 SetWindowPos(child
, 0,0,0,0,0, SWP_NOSIZE
| SWP_NOMOVE
);
1363 if( IsWindow(ci
->hwndChildMaximized
) )
1369 rect
.right
= LOWORD(lParam
);
1370 rect
.bottom
= HIWORD(lParam
);
1372 AdjustWindowRectEx(&rect
, GetWindowLongA(ci
->hwndChildMaximized
,GWL_STYLE
),
1373 0, GetWindowLongA(ci
->hwndChildMaximized
,GWL_EXSTYLE
) );
1374 MoveWindow(ci
->hwndChildMaximized
, rect
.left
, rect
.top
,
1375 rect
.right
- rect
.left
, rect
.bottom
- rect
.top
, 1);
1378 MDI_PostUpdate(hwnd
, ci
, SB_BOTH
+1);
1382 case WM_MDICALCCHILDSCROLL
:
1383 if( (ci
->mdiFlags
& MDIF_NEEDUPDATE
) && ci
->sbRecalc
)
1385 CalcChildScroll(hwnd
, ci
->sbRecalc
-1);
1387 ci
->mdiFlags
&= ~MDIF_NEEDUPDATE
;
1391 return unicode
? DefWindowProcW( hwnd
, message
, wParam
, lParam
) :
1392 DefWindowProcA( hwnd
, message
, wParam
, lParam
);
1395 /***********************************************************************
1398 static LRESULT WINAPI
MDIClientWndProcA( HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
1400 if (!IsWindow(hwnd
)) return 0;
1401 return MDIClientWndProc_common( hwnd
, message
, wParam
, lParam
, FALSE
);
1404 /***********************************************************************
1407 static LRESULT WINAPI
MDIClientWndProcW( HWND hwnd
, UINT message
, WPARAM wParam
, LPARAM lParam
)
1409 if (!IsWindow(hwnd
)) return 0;
1410 return MDIClientWndProc_common( hwnd
, message
, wParam
, lParam
, TRUE
);
1413 /***********************************************************************
1414 * DefFrameProc (USER.445)
1416 LRESULT WINAPI
DefFrameProc16( HWND16 hwnd
, HWND16 hwndMDIClient
,
1417 UINT16 message
, WPARAM16 wParam
, LPARAM lParam
)
1422 lParam
= (LPARAM
)MapSL(lParam
);
1428 return DefFrameProcA( WIN_Handle32(hwnd
), WIN_Handle32(hwndMDIClient
),
1429 message
, wParam
, lParam
);
1433 MDINEXTMENU next_menu
;
1434 DefFrameProcW( WIN_Handle32(hwnd
), WIN_Handle32(hwndMDIClient
),
1435 message
, wParam
, (LPARAM
)&next_menu
);
1436 return MAKELONG( next_menu
.hmenuNext
, WIN_Handle16(next_menu
.hwndNext
) );
1439 return DefWindowProc16(hwnd
, message
, wParam
, lParam
);
1444 /***********************************************************************
1445 * DefFrameProcA (USER32.@)
1447 LRESULT WINAPI
DefFrameProcA( HWND hwnd
, HWND hwndMDIClient
,
1448 UINT message
, WPARAM wParam
, LPARAM lParam
)
1456 DWORD len
= MultiByteToWideChar( CP_ACP
, 0, (LPSTR
)lParam
, -1, NULL
, 0 );
1457 LPWSTR text
= HeapAlloc( GetProcessHeap(), 0, len
* sizeof(WCHAR
) );
1458 MultiByteToWideChar( CP_ACP
, 0, (LPSTR
)lParam
, -1, text
, len
);
1459 MDI_UpdateFrameText(hwnd
, hwndMDIClient
, MDI_REPAINTFRAME
, text
);
1460 HeapFree( GetProcessHeap(), 0, text
);
1462 return 1; /* success. FIXME: check text length */
1469 return DefFrameProcW( hwnd
, hwndMDIClient
, message
, wParam
, lParam
);
1472 return DefWindowProcA(hwnd
, message
, wParam
, lParam
);
1476 /***********************************************************************
1477 * DefFrameProcW (USER32.@)
1479 LRESULT WINAPI
DefFrameProcW( HWND hwnd
, HWND hwndMDIClient
,
1480 UINT message
, WPARAM wParam
, LPARAM lParam
)
1482 MDICLIENTINFO
*ci
= get_client_info( hwndMDIClient
);
1490 WORD id
= LOWORD(wParam
);
1491 /* check for possible syscommands for maximized MDI child */
1492 if (id
< ci
->idFirstChild
|| id
>= ci
->idFirstChild
+ ci
->nActiveChildren
)
1494 if( (id
- 0xf000) & 0xf00f ) break;
1495 if( !ci
->hwndChildMaximized
) break;
1506 return SendMessageW( ci
->hwndChildMaximized
, WM_SYSCOMMAND
,
1513 if (id
- ci
->idFirstChild
== MDI_MOREWINDOWSLIMIT
)
1514 /* User chose "More Windows..." */
1515 childHwnd
= MDI_MoreWindowsDialog(hwndMDIClient
);
1517 /* User chose one of the windows listed in the "Windows" menu */
1518 childHwnd
= MDI_GetChildByID(hwndMDIClient
,id
);
1521 SendMessageW( hwndMDIClient
, WM_MDIACTIVATE
, (WPARAM
)childHwnd
, 0 );
1527 SendMessageW(hwndMDIClient
, message
, wParam
, lParam
);
1531 MDI_UpdateFrameText(hwnd
, hwndMDIClient
, MDI_REPAINTFRAME
, (LPWSTR
)lParam
);
1532 return 1; /* success. FIXME: check text length */
1535 SetFocus(hwndMDIClient
);
1539 MoveWindow(hwndMDIClient
, 0, 0, LOWORD(lParam
), HIWORD(lParam
), TRUE
);
1544 MDINEXTMENU
*next_menu
= (MDINEXTMENU
*)lParam
;
1546 if (!IsIconic(hwnd
) && ci
->hwndActiveChild
&& !ci
->hwndChildMaximized
)
1548 /* control menu is between the frame system menu and
1549 * the first entry of menu bar */
1550 WND
*wndPtr
= WIN_GetPtr(hwnd
);
1552 if( (wParam
== VK_LEFT
&& GetMenu(hwnd
) == next_menu
->hmenuIn
) ||
1553 (wParam
== VK_RIGHT
&& GetSubMenu(wndPtr
->hSysMenu
, 0) == next_menu
->hmenuIn
) )
1555 WIN_ReleasePtr(wndPtr
);
1556 wndPtr
= WIN_GetPtr(ci
->hwndActiveChild
);
1557 next_menu
->hmenuNext
= GetSubMenu(wndPtr
->hSysMenu
, 0);
1558 next_menu
->hwndNext
= ci
->hwndActiveChild
;
1560 WIN_ReleasePtr(wndPtr
);
1567 return DefWindowProcW( hwnd
, message
, wParam
, lParam
);
1571 /***********************************************************************
1572 * DefMDIChildProc (USER.447)
1574 LRESULT WINAPI
DefMDIChildProc16( HWND16 hwnd
, UINT16 message
,
1575 WPARAM16 wParam
, LPARAM lParam
)
1580 return DefMDIChildProcA( WIN_Handle32(hwnd
), message
, wParam
, (LPARAM
)MapSL(lParam
) );
1584 case WM_CHILDACTIVATE
:
1589 return DefMDIChildProcW( WIN_Handle32(hwnd
), message
, wParam
, lParam
);
1590 case WM_GETMINMAXINFO
:
1592 MINMAXINFO16
*mmi16
= (MINMAXINFO16
*)MapSL(lParam
);
1594 STRUCT32_MINMAXINFO16to32( mmi16
, &mmi
);
1595 DefMDIChildProcW( WIN_Handle32(hwnd
), message
, wParam
, (LPARAM
)&mmi
);
1596 STRUCT32_MINMAXINFO32to16( &mmi
, mmi16
);
1601 MDINEXTMENU next_menu
;
1602 DefMDIChildProcW( WIN_Handle32(hwnd
), message
, wParam
, (LPARAM
)&next_menu
);
1603 return MAKELONG( next_menu
.hmenuNext
, WIN_Handle16(next_menu
.hwndNext
) );
1606 return DefWindowProc16(hwnd
, message
, wParam
, lParam
);
1611 /***********************************************************************
1612 * DefMDIChildProcA (USER32.@)
1614 LRESULT WINAPI
DefMDIChildProcA( HWND hwnd
, UINT message
,
1615 WPARAM wParam
, LPARAM lParam
)
1617 HWND client
= GetParent(hwnd
);
1618 MDICLIENTINFO
*ci
= get_client_info( client
);
1620 hwnd
= WIN_GetFullHandle( hwnd
);
1621 if (!ci
) return DefWindowProcA( hwnd
, message
, wParam
, lParam
);
1626 DefWindowProcA(hwnd
, message
, wParam
, lParam
);
1627 MDI_MenuModifyItem( client
, hwnd
);
1628 if( ci
->hwndChildMaximized
== hwnd
)
1629 MDI_UpdateFrameText( GetParent(client
), client
, MDI_REPAINTFRAME
, NULL
);
1630 return 1; /* success. FIXME: check text length */
1632 case WM_GETMINMAXINFO
:
1636 case WM_CHILDACTIVATE
:
1642 return DefMDIChildProcW( hwnd
, message
, wParam
, lParam
);
1644 return DefWindowProcA(hwnd
, message
, wParam
, lParam
);
1648 /***********************************************************************
1649 * DefMDIChildProcW (USER32.@)
1651 LRESULT WINAPI
DefMDIChildProcW( HWND hwnd
, UINT message
,
1652 WPARAM wParam
, LPARAM lParam
)
1654 HWND client
= GetParent(hwnd
);
1655 MDICLIENTINFO
*ci
= get_client_info( client
);
1657 hwnd
= WIN_GetFullHandle( hwnd
);
1658 if (!ci
) return DefWindowProcW( hwnd
, message
, wParam
, lParam
);
1663 DefWindowProcW(hwnd
, message
, wParam
, lParam
);
1664 MDI_MenuModifyItem( client
, hwnd
);
1665 if( ci
->hwndChildMaximized
== hwnd
)
1666 MDI_UpdateFrameText( GetParent(client
), client
, MDI_REPAINTFRAME
, NULL
);
1667 return 1; /* success. FIXME: check text length */
1669 case WM_GETMINMAXINFO
:
1670 MDI_ChildGetMinMaxInfo( client
, hwnd
, (MINMAXINFO
*)lParam
);
1674 return 0x00010000; /* MDI children don't have menu bars */
1677 SendMessageW( client
, WM_MDIDESTROY
, (WPARAM
)hwnd
, 0 );
1681 if (ci
->hwndActiveChild
!= hwnd
) MDI_ChildActivate( client
, hwnd
);
1684 case WM_CHILDACTIVATE
:
1685 MDI_ChildActivate( client
, hwnd
);
1692 if( ci
->hwndChildMaximized
== hwnd
) return 0;
1696 SetWindowLongA( hwnd
, GWL_STYLE
,
1697 GetWindowLongA( hwnd
, GWL_STYLE
) | WS_SYSMENU
);
1700 if (ci
->hwndChildMaximized
== hwnd
)
1701 return SendMessageW( GetParent(client
), message
, wParam
, lParam
);
1702 SetWindowLongW( hwnd
, GWL_STYLE
,
1703 GetWindowLongW( hwnd
, GWL_STYLE
) & ~WS_SYSMENU
);
1706 SendMessageW( client
, WM_MDINEXT
, 0, 0);
1709 SendMessageW( client
, WM_MDINEXT
, 0, 1);
1715 if( ci
->hwndChildMaximized
) ci
->mdiFlags
&= ~MDIF_NEEDUPDATE
;
1716 else MDI_PostUpdate(client
, ci
, SB_BOTH
+1);
1720 if( ci
->hwndActiveChild
== hwnd
&& wParam
!= SIZE_MAXIMIZED
)
1722 ci
->hwndChildMaximized
= 0;
1723 MDI_RestoreFrameMenu( GetParent(client
), hwnd
);
1724 MDI_UpdateFrameText( GetParent(client
), client
, MDI_REPAINTFRAME
, NULL
);
1727 if( wParam
== SIZE_MAXIMIZED
)
1729 HWND hMaxChild
= ci
->hwndChildMaximized
;
1731 if( hMaxChild
== hwnd
) break;
1734 SendMessageW( hMaxChild
, WM_SETREDRAW
, FALSE
, 0 );
1735 MDI_RestoreFrameMenu( GetParent(client
), hMaxChild
);
1736 ShowWindow( hMaxChild
, SW_SHOWNOACTIVATE
);
1737 SendMessageW( hMaxChild
, WM_SETREDRAW
, TRUE
, 0 );
1739 TRACE("maximizing child %04x\n", hwnd
);
1741 /* keep track of the maximized window. */
1742 ci
->hwndChildMaximized
= hwnd
; /* !!! */
1744 /* The maximized window should also be the active window */
1745 MDI_ChildActivate( client
, hwnd
);
1746 MDI_AugmentFrameMenu( GetParent(client
), hwnd
);
1747 MDI_UpdateFrameText( GetParent(client
), client
, MDI_REPAINTFRAME
, NULL
);
1750 if( wParam
== SIZE_MINIMIZED
)
1752 HWND switchTo
= MDI_GetWindow(ci
, hwnd
, TRUE
, WS_MINIMIZE
);
1754 if (switchTo
) SendMessageW( switchTo
, WM_CHILDACTIVATE
, 0, 0);
1756 MDI_PostUpdate(client
, ci
, SB_BOTH
+1);
1761 MDINEXTMENU
*next_menu
= (MDINEXTMENU
*)lParam
;
1762 HWND parent
= GetParent(client
);
1764 if( wParam
== VK_LEFT
) /* switch to frame system menu */
1766 WND
*wndPtr
= WIN_GetPtr( parent
);
1767 next_menu
->hmenuNext
= GetSubMenu( wndPtr
->hSysMenu
, 0 );
1768 WIN_ReleasePtr( wndPtr
);
1770 if( wParam
== VK_RIGHT
) /* to frame menu bar */
1772 next_menu
->hmenuNext
= GetMenu(parent
);
1774 next_menu
->hwndNext
= parent
;
1781 SendMessageW( hwnd
, WM_SYSCOMMAND
, (WPARAM
)SC_KEYMENU
, (DWORD
)VK_SPACE
);
1786 return DefWindowProcW(hwnd
, message
, wParam
, lParam
);
1789 /**********************************************************************
1790 * CreateMDIWindowA (USER32.@) Creates a MDI child
1793 * Success: Handle to created window
1796 HWND WINAPI
CreateMDIWindowA(
1797 LPCSTR lpClassName
, /* [in] Pointer to registered child class name */
1798 LPCSTR lpWindowName
, /* [in] Pointer to window name */
1799 DWORD dwStyle
, /* [in] Window style */
1800 INT X
, /* [in] Horizontal position of window */
1801 INT Y
, /* [in] Vertical position of window */
1802 INT nWidth
, /* [in] Width of window */
1803 INT nHeight
, /* [in] Height of window */
1804 HWND hWndParent
, /* [in] Handle to parent window */
1805 HINSTANCE hInstance
, /* [in] Handle to application instance */
1806 LPARAM lParam
) /* [in] Application-defined value */
1808 MDICLIENTINFO
*pCi
= get_client_info( hWndParent
);
1809 MDICREATESTRUCTA cs
;
1811 TRACE("(%s,%s,%ld,%d,%d,%d,%d,%x,%d,%ld)\n",
1812 debugstr_a(lpClassName
),debugstr_a(lpWindowName
),dwStyle
,X
,Y
,
1813 nWidth
,nHeight
,hWndParent
,hInstance
,lParam
);
1817 ERR("bad hwnd for MDI-client: %04x\n", hWndParent
);
1820 cs
.szClass
=lpClassName
;
1821 cs
.szTitle
=lpWindowName
;
1822 cs
.hOwner
=hInstance
;
1830 return MDICreateChild(hWndParent
, pCi
, &cs
, FALSE
);
1833 /***********************************************************************
1834 * CreateMDIWindowW (USER32.@) Creates a MDI child
1837 * Success: Handle to created window
1840 HWND WINAPI
CreateMDIWindowW(
1841 LPCWSTR lpClassName
, /* [in] Pointer to registered child class name */
1842 LPCWSTR lpWindowName
, /* [in] Pointer to window name */
1843 DWORD dwStyle
, /* [in] Window style */
1844 INT X
, /* [in] Horizontal position of window */
1845 INT Y
, /* [in] Vertical position of window */
1846 INT nWidth
, /* [in] Width of window */
1847 INT nHeight
, /* [in] Height of window */
1848 HWND hWndParent
, /* [in] Handle to parent window */
1849 HINSTANCE hInstance
, /* [in] Handle to application instance */
1850 LPARAM lParam
) /* [in] Application-defined value */
1852 MDICLIENTINFO
*pCi
= get_client_info( hWndParent
);
1853 MDICREATESTRUCTW cs
;
1855 TRACE("(%s,%s,%ld,%d,%d,%d,%d,%x,%d,%ld)\n",
1856 debugstr_w(lpClassName
), debugstr_w(lpWindowName
), dwStyle
, X
, Y
,
1857 nWidth
, nHeight
, hWndParent
, hInstance
, lParam
);
1861 ERR("bad hwnd for MDI-client: %04x\n", hWndParent
);
1864 cs
.szClass
= lpClassName
;
1865 cs
.szTitle
= lpWindowName
;
1866 cs
.hOwner
= hInstance
;
1874 return MDICreateChild(hWndParent
, pCi
, (MDICREATESTRUCTA
*)&cs
, TRUE
);
1877 /**********************************************************************
1878 * TranslateMDISysAccel (USER32.@)
1880 BOOL WINAPI
TranslateMDISysAccel( HWND hwndClient
, LPMSG msg
)
1882 if (msg
->message
== WM_KEYDOWN
|| msg
->message
== WM_SYSKEYDOWN
)
1884 MDICLIENTINFO
*ci
= get_client_info( hwndClient
);
1887 if (!ci
|| !IsWindowEnabled(ci
->hwndActiveChild
)) return 0;
1889 /* translate if the Ctrl key is down and Alt not. */
1891 if( (GetKeyState(VK_CONTROL
) & 0x8000) && !(GetKeyState(VK_MENU
) & 0x8000))
1893 switch( msg
->wParam
)
1897 wParam
= ( GetKeyState(VK_SHIFT
) & 0x8000 ) ? SC_NEXTWINDOW
: SC_PREVWINDOW
;
1906 TRACE("wParam = %04x\n", wParam
);
1907 SendMessageW(ci
->hwndActiveChild
, WM_SYSCOMMAND
, wParam
, (LPARAM
)msg
->wParam
);
1911 return 0; /* failure */
1914 /***********************************************************************
1915 * CalcChildScroll (USER32.@)
1917 void WINAPI
CalcChildScroll( HWND hwnd
, INT scroll
)
1920 RECT childRect
, clientRect
;
1921 INT vmin
, vmax
, hmin
, hmax
, vpos
, hpos
;
1924 GetClientRect( hwnd
, &clientRect
);
1925 SetRectEmpty( &childRect
);
1927 if ((list
= WIN_ListChildren( hwnd
)))
1930 for (i
= 0; list
[i
]; i
++)
1932 DWORD style
= GetWindowLongW( list
[i
], GWL_STYLE
);
1933 if (style
& WS_MAXIMIZE
)
1935 HeapFree( GetProcessHeap(), 0, list
);
1936 ShowScrollBar( hwnd
, SB_BOTH
, FALSE
);
1939 if (style
& WS_VISIBLE
)
1941 WND
*pWnd
= WIN_FindWndPtr( list
[i
] );
1942 UnionRect( &childRect
, &pWnd
->rectWindow
, &childRect
);
1943 WIN_ReleaseWndPtr( pWnd
);
1946 HeapFree( GetProcessHeap(), 0, list
);
1948 UnionRect( &childRect
, &clientRect
, &childRect
);
1950 hmin
= childRect
.left
;
1951 hmax
= childRect
.right
- clientRect
.right
;
1952 hpos
= clientRect
.left
- childRect
.left
;
1953 vmin
= childRect
.top
;
1954 vmax
= childRect
.bottom
- clientRect
.bottom
;
1955 vpos
= clientRect
.top
- childRect
.top
;
1960 vpos
= hpos
; vmin
= hmin
; vmax
= hmax
;
1962 info
.cbSize
= sizeof(info
);
1963 info
.nMax
= vmax
; info
.nMin
= vmin
; info
.nPos
= vpos
;
1964 info
.fMask
= SIF_POS
| SIF_RANGE
;
1965 SetScrollInfo(hwnd
, scroll
, &info
, TRUE
);
1968 SCROLL_SetNCSbState( hwnd
, vmin
, vmax
, vpos
,
1974 /***********************************************************************
1975 * ScrollChildren (USER32.@)
1977 void WINAPI
ScrollChildren(HWND hWnd
, UINT uMsg
, WPARAM wParam
,
1981 INT curPos
, length
, minPos
, maxPos
, shift
;
1984 GetClientRect( hWnd
, &rect
);
1989 GetScrollRange(hWnd
,SB_HORZ
,&minPos
,&maxPos
);
1990 curPos
= GetScrollPos(hWnd
,SB_HORZ
);
1991 length
= (rect
.right
- rect
.left
) / 2;
1992 shift
= GetSystemMetrics(SM_CYHSCROLL
);
1995 GetScrollRange(hWnd
,SB_VERT
,&minPos
,&maxPos
);
1996 curPos
= GetScrollPos(hWnd
,SB_VERT
);
1997 length
= (rect
.bottom
- rect
.top
) / 2;
1998 shift
= GetSystemMetrics(SM_CXVSCROLL
);
2007 newPos
= curPos
- shift
;
2010 newPos
= curPos
+ shift
;
2013 newPos
= curPos
- length
;
2016 newPos
= curPos
+ length
;
2019 case SB_THUMBPOSITION
:
2020 newPos
= LOWORD(lParam
);
2033 CalcChildScroll(hWnd
,(uMsg
== WM_VSCROLL
)?SB_VERT
:SB_HORZ
);
2037 if( newPos
> maxPos
)
2040 if( newPos
< minPos
)
2043 SetScrollPos(hWnd
, (uMsg
== WM_VSCROLL
)?SB_VERT
:SB_HORZ
, newPos
, TRUE
);
2045 if( uMsg
== WM_VSCROLL
)
2046 ScrollWindowEx(hWnd
,0 ,curPos
- newPos
, NULL
, NULL
, 0, NULL
,
2047 SW_INVALIDATE
| SW_ERASE
| SW_SCROLLCHILDREN
);
2049 ScrollWindowEx(hWnd
,curPos
- newPos
, 0, NULL
, NULL
, 0, NULL
,
2050 SW_INVALIDATE
| SW_ERASE
| SW_SCROLLCHILDREN
);
2054 /******************************************************************************
2055 * CascadeWindows (USER32.@) Cascades MDI child windows
2058 * Success: Number of cascaded windows.
2062 CascadeWindows (HWND hwndParent
, UINT wFlags
, const LPRECT lpRect
,
2063 UINT cKids
, const HWND
*lpKids
)
2065 FIXME("(0x%08x,0x%08x,...,%u,...): stub\n",
2066 hwndParent
, wFlags
, cKids
);
2072 /******************************************************************************
2073 * TileWindows (USER32.@) Tiles MDI child windows
2076 * Success: Number of tiled windows.
2080 TileWindows (HWND hwndParent
, UINT wFlags
, const LPRECT lpRect
,
2081 UINT cKids
, const HWND
*lpKids
)
2083 FIXME("(0x%08x,0x%08x,...,%u,...): stub\n",
2084 hwndParent
, wFlags
, cKids
);
2089 /************************************************************************
2090 * "More Windows..." functionality
2093 /* MDI_MoreWindowsDlgProc
2095 * This function will process the messages sent to the "More Windows..."
2097 * Return values: 0 = cancel pressed
2098 * HWND = ok pressed or double-click in the list...
2102 static BOOL WINAPI
MDI_MoreWindowsDlgProc (HWND hDlg
, UINT iMsg
, WPARAM wParam
, LPARAM lParam
)
2111 MDICLIENTINFO
*ci
= get_client_info( (HWND
)lParam
);
2112 HWND hListBox
= GetDlgItem(hDlg
, MDI_IDC_LISTBOX
);
2113 HWND
*list
, *sorted_list
;
2115 if (!(list
= WIN_ListChildren( (HWND
)lParam
))) return TRUE
;
2116 if (!(sorted_list
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
,
2117 sizeof(HWND
) * ci
->nActiveChildren
)))
2119 HeapFree( GetProcessHeap(), 0, list
);
2123 /* Fill the list, sorted by id... */
2124 for (i
= 0; list
[i
]; i
++)
2126 UINT id
= GetWindowLongW( list
[i
], GWL_ID
) - ci
->idFirstChild
;
2127 if (id
< ci
->nActiveChildren
) sorted_list
[id
] = list
[i
];
2129 HeapFree( GetProcessHeap(), 0, list
);
2131 for (i
= 0; i
< ci
->nActiveChildren
; i
++)
2135 if (!GetWindowTextW( sorted_list
[i
], buffer
, sizeof(buffer
)/sizeof(WCHAR
) ))
2137 SendMessageW(hListBox
, LB_ADDSTRING
, 0, (LPARAM
)buffer
);
2138 SendMessageW(hListBox
, LB_SETITEMDATA
, i
, (LPARAM
)sorted_list
[i
] );
2139 length
= strlenW(buffer
); /* FIXME: should use GetTextExtentPoint */
2140 if (length
> widest
)
2143 /* Make sure the horizontal scrollbar scrolls ok */
2144 SendMessageW(hListBox
, LB_SETHORIZONTALEXTENT
, widest
* 6, 0);
2146 /* Set the current selection */
2147 SendMessageW(hListBox
, LB_SETCURSEL
, MDI_MOREWINDOWSLIMIT
, 0);
2152 switch (LOWORD(wParam
))
2155 if (HIWORD(wParam
) != LBN_DBLCLK
) break;
2159 /* windows are sorted by menu ID, so we must return the
2160 * window associated to the given id
2162 HWND hListBox
= GetDlgItem(hDlg
, MDI_IDC_LISTBOX
);
2163 UINT index
= SendMessageW(hListBox
, LB_GETCURSEL
, 0, 0);
2164 LRESULT res
= SendMessageW(hListBox
, LB_GETITEMDATA
, index
, 0);
2165 EndDialog(hDlg
, res
);
2179 * MDI_MoreWindowsDialog
2181 * Prompts the user with a listbox containing the opened
2182 * documents. The user can then choose a windows and click
2183 * on OK to set the current window to the one selected, or
2184 * CANCEL to cancel. The function returns a handle to the
2188 static HWND
MDI_MoreWindowsDialog(HWND hwnd
)
2194 hRes
= FindResourceA(GetModuleHandleA("USER32"), "MDI_MOREWINDOWS", RT_DIALOGA
);
2199 hDlgTmpl
= LoadResource(GetModuleHandleA("USER32"), hRes
);
2204 template = LockResource( hDlgTmpl
);
2209 return (HWND
) DialogBoxIndirectParamA(GetModuleHandleA("USER32"),
2210 (LPDLGTEMPLATEA
) template,
2211 hwnd
, MDI_MoreWindowsDlgProc
, (LPARAM
) hwnd
);
2218 * Will swap the menu IDs for the given 2 positions.
2219 * pos1 and pos2 are menu IDs
2224 static void MDI_SwapMenuItems(HWND parent
, UINT pos1
, UINT pos2
)
2229 if (!(list
= WIN_ListChildren( parent
))) return;
2230 for (i
= 0; list
[i
]; i
++)
2232 UINT id
= GetWindowLongW( list
[i
], GWL_ID
);
2233 if (id
== pos1
) SetWindowLongW( list
[i
], GWL_ID
, pos2
);
2234 else if (id
== pos2
) SetWindowLongW( list
[i
], GWL_ID
, pos1
);
2236 HeapFree( GetProcessHeap(), 0, list
);