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