git.oblomov.eu Git - wine/blob - windows/mdi.c

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