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