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