windows/mdi.c

   1 /* MDI.C
   2  *
   3  * Copyright 1994, Bob Amstadt
   4  *           1995, Alex Korobka
   5  *
   6  * This file contains routines to support MDI features.
   7  *
   8  * Notes: Windows keeps ID of MDI menu item in the wIDenu field
   9  *        of corresponding MDI child.
  10  *
  11  *        Basic child activation routine is MDI_ChildActivate and
  12  *        SetWindowPos(childHwnd,...) implicitly calls it if SWP_NOACTIVATE i
  13  *        is not used.
  14  */
  15
  16 #include <stdlib.h>
  17 #include <string.h>
  18 #include <stdio.h>
  19 #include <math.h>
  20 #include "windows.h"
  21 #include "win.h"
  22 #include "nonclient.h"
  23 #include "mdi.h"
  24 #include "user.h"
  25 #include "menu.h"
  26 #include "sysmetrics.h"
  27 #include "stddebug.h"
  28 #include "debug.h"
  29
  30 void ScrollChildren(HWND , UINT , WPARAM , LPARAM );
  31 void CalcChildScroll(HWND, WORD);
  32
  33 /* ----------------- declarations ----------------- */
  34
  35 static LONG MDI_ChildActivate(WND* ,HWND );
  36
  37 /* -------- Miscellaneous service functions ----------
  38  *
  39  *                      MDI_GetChildByID
  40  */
  41
  42 static HWND MDI_GetChildByID(WND* mdiClient,int id)
  43 {
  44  HWND   hWnd   = mdiClient->hwndChild;
  45  WND*   wndPtr = WIN_FindWndPtr( hWnd );
  46
  47  if( !wndPtr ) return 0;
  48
  49  while( wndPtr )
  50   {
  51         if( wndPtr->wIDmenu == id ) return hWnd;
  52         wndPtr = WIN_FindWndPtr(hWnd = wndPtr->hwndNext);
  53   }
  54
  55  return 0;
  56 }
  57
  58 /**********************************************************************
  59  *                      MDI_MenuAppendItem
  60  */
  61 static BOOL MDI_MenuAppendItem(WND *clientWnd, HWND hWndChild)
  62 {
  63     char buffer[128];
  64  MDICLIENTINFO  *clientInfo = (MDICLIENTINFO*)clientWnd->wExtra;
  65  WND            *wndPtr     = WIN_FindWndPtr(hWndChild);
  66  LPSTR           lpWndText  = (LPSTR) USER_HEAP_LIN_ADDR(wndPtr->hText);
  67  int             n          = sprintf(buffer, "%d ",
  68                                       clientInfo->nActiveChildren);
  69
  70  if( !clientInfo->hWindowMenu ) return 0;
  71
  72  if( lpWndText )
  73      strncpy(buffer + n, lpWndText, sizeof(buffer) - n - 1);
  74  return AppendMenu(clientInfo->hWindowMenu,MF_STRING,
  75                        wndPtr->wIDmenu,(LPSTR)buffer);
  76 }
  77
  78 /**********************************************************************
  79  *                      MDI_MenuModifyItem
  80  */
  81 static BOOL MDI_MenuModifyItem(WND* clientWnd, HWND hWndChild )
  82 {
  83  char            buffer[128];
  84  MDICLIENTINFO  *clientInfo = (MDICLIENTINFO*)clientWnd->wExtra;
  85  WND            *wndPtr     = WIN_FindWndPtr(hWndChild);
  86  LPSTR           lpWndText  = (LPSTR) USER_HEAP_LIN_ADDR(wndPtr->hText);
  87  UINT            n          = sprintf(buffer, "%d ",
  88                               wndPtr->wIDmenu - clientInfo->idFirstChild + 1);
  89  BOOL            bRet       = 0;
  90
  91  if( !clientInfo->hWindowMenu ) return 0;
  92
  93  if( lpWndText )
  94      strncpy(buffer + n, lpWndText, sizeof(buffer) - n - 1);
  95
  96  n    = GetMenuState(clientInfo->hWindowMenu,wndPtr->wIDmenu ,MF_BYCOMMAND);
  97  bRet = ModifyMenu(clientInfo->hWindowMenu , wndPtr->wIDmenu ,
  98                    MF_BYCOMMAND | MF_STRING, wndPtr->wIDmenu ,(LPSTR)buffer );
  99         CheckMenuItem(clientInfo->hWindowMenu ,wndPtr->wIDmenu , n & MF_CHECKED);
 100  return bRet;
 101 }
 102
 103 /**********************************************************************
 104  *                      MDI_MenuDeleteItem
 105  */
 106 static BOOL MDI_MenuDeleteItem(WND* clientWnd, HWND hWndChild )
 107 {
 108  char            buffer[128];
 109  MDICLIENTINFO  *clientInfo = (MDICLIENTINFO*)clientWnd->wExtra;
 110  WND            *wndPtr     = WIN_FindWndPtr(hWndChild);
 111  LPSTR           lpWndText;
 112  INT             index      = 0,id,n;
 113
 114  if( !clientInfo->nActiveChildren ||
 115      !clientInfo->hWindowMenu ) return 0;
 116
 117  id = wndPtr->wIDmenu;
 118  DeleteMenu(clientInfo->hWindowMenu,id,MF_BYCOMMAND);
 119
 120  /* walk the rest of MDI children to prevent gaps in the id
 121   * sequence and in the menu child list
 122   */
 123
 124  for( index = id+1; index <= clientInfo->nActiveChildren +
 125                              clientInfo->idFirstChild; index++ )
 126     {
 127         wndPtr = WIN_FindWndPtr(MDI_GetChildByID(clientWnd,index));
 128         if( !wndPtr )
 129              {
 130               dprintf_mdi(stddeb,"MDIMenuDeleteItem: no window for id=%i\n",index);
 131               continue;
 132     }
 133
 134         /* set correct id */
 135         wndPtr->wIDmenu--;
 136
 137         n          = sprintf(buffer, "%d ",index - clientInfo->idFirstChild);
 138         lpWndText  = (LPSTR) USER_HEAP_LIN_ADDR(wndPtr->hText);
 139
 140         if( lpWndText )
 141             strncpy(buffer + n, lpWndText, sizeof(buffer) - n - 1);
 142
 143         /* change menu */
 144         ModifyMenu(clientInfo->hWindowMenu ,index ,MF_BYCOMMAND | MF_STRING,
 145                    index - 1 ,(LPSTR)buffer );
 146     }
 147  return 1;
 148 }
 149
 150 /**********************************************************************
 151  *                      MDI_GetWindow
 152  *
 153  * returns "activateable" child  or zero
 154  */
 155 HWND MDI_GetWindow(WND  *clientWnd, HWND hWnd, WORD wTo )
 156 {
 157  HWND            hWndNext;
 158  MDICLIENTINFO  *clientInfo = (MDICLIENTINFO*)clientWnd->wExtra;
 159  WND            *wndPtr;
 160
 161  if( !hWnd ) hWnd = clientInfo->hwndActiveChild;
 162
 163  if( !(wndPtr = WIN_FindWndPtr(hWnd)) ) return 0;
 164
 165  hWndNext = hWnd;
 166  wTo      = wTo ? GW_HWNDPREV : GW_HWNDNEXT;
 167
 168  while( hWndNext )
 169     {
 170         if( clientWnd->hwndChild == hWndNext && wTo == GW_HWNDPREV )
 171              hWndNext = GetWindow( hWndNext, GW_HWNDLAST);
 172         else if( wndPtr->hwndNext == 0 && wTo == GW_HWNDNEXT )
 173                  hWndNext = clientWnd->hwndChild;
 174              else
 175                  hWndNext = GetWindow( hWndNext, wTo );
 176
 177         wndPtr = WIN_FindWndPtr( hWndNext );
 178
 179         if( (wndPtr->dwStyle & WS_VISIBLE) &&
 180            !(wndPtr->dwStyle & WS_DISABLED) )
 181              break;
 182
 183         /* check if all windows were iterated through */
 184         if( hWndNext == hWnd ) break;
 185     }
 186
 187  return ( hWnd == hWndNext )? 0 : hWndNext;
 188 }
 189
 190
 191 /**********************************************************************
 192  *                                      MDISetMenu
 193  * FIXME: This is not complete.
 194  */
 195 HMENU MDISetMenu(HWND hwnd, BOOL fRefresh, HMENU hmenuFrame, HMENU hmenuWindow)
 196 {
 197     dprintf_mdi(stddeb, "WM_MDISETMENU: "NPFMT" %04x "NPFMT" "NPFMT"\n", hwnd, fRefresh, hmenuFrame, hmenuWindow);
 198     if (!fRefresh) {
 199         HWND hwndFrame = GetParent(hwnd);
 200         HMENU oldFrameMenu = GetMenu(hwndFrame);
 201         SetMenu(hwndFrame, hmenuFrame);
 202         return oldFrameMenu;
 203     }
 204     return 0;
 205 }
 206
 207 /**********************************************************************
 208  *                                      MDIIconArrange
 209  */
 210 WORD MDIIconArrange(HWND parent)
 211 {
 212   return ArrangeIconicWindows(parent);          /* Any reason why the    */
 213                                                 /* existing icon arrange */
 214                                                 /* can't be used here?   */
 215                                                 /* -DRP                  */
 216 }
 217
 218 /**********************************************************************
 219  *                                      MDICreateChild
 220  */
 221 HWND MDICreateChild(WND *w, MDICLIENTINFO *ci, HWND parent, LPARAM lParam )
 222 {
 223     MDICREATESTRUCT *cs = (MDICREATESTRUCT *)PTR_SEG_TO_LIN(lParam);
 224     HWND hwnd;
 225     WORD             wIDmenu = ci->idFirstChild + ci->nActiveChildren;
 226     int spacing;
 227     char             chDef = '\0';
 228
 229     /*
 230      * Create child window
 231      */
 232     cs->style &= (WS_MINIMIZE | WS_MAXIMIZE | WS_HSCROLL | WS_VSCROLL);
 233
 234                                 /* The child windows should probably  */
 235                                 /* stagger, shouldn't they? -DRP      */
 236     spacing = GetSystemMetrics(SM_CYCAPTION) + GetSystemMetrics(SM_CYFRAME);
 237     cs->x = ci->nActiveChildren * spacing;
 238     cs->y = ci->nActiveChildren * spacing;
 239
 240     /* this menu is needed to set a check mark in MDI_ChildActivate */
 241     AppendMenu(ci->hWindowMenu ,MF_STRING ,wIDmenu, (LPSTR)&chDef);
 242
 243     hwnd = CreateWindow( cs->szClass, cs->szTitle,
 244                           WS_CHILD | WS_BORDER | WS_CAPTION | WS_CLIPSIBLINGS |
 245                           WS_MAXIMIZEBOX | WS_MINIMIZEBOX | WS_SYSMENU |
 246                           WS_THICKFRAME | WS_VISIBLE | cs->style,
 247                           cs->x, cs->y, cs->cx, cs->cy, parent,
 248                          (HMENU) wIDmenu, w->hInstance, (SEGPTR)lParam);
 249
 250     if (hwnd)
 251     {
 252         ci->nActiveChildren++;
 253         MDI_MenuModifyItem(w ,hwnd);
 254
 255         /* FIXME: at this point NC area of hwnd stays inactive */
 256     }
 257     else
 258         DeleteMenu(ci->hWindowMenu,wIDmenu,MF_BYCOMMAND);
 259
 260     return hwnd;
 261 }
 262
 263 /**********************************************************************
 264  *                      MDI_SwitchActiveChild
 265  *
 266  * Notes: SetWindowPos sends WM_CHILDACTIVATE to the child window that is
 267  *        being activated
 268  *
 269  *        Ideally consecutive SetWindowPos should be replaced by
 270  *        BeginDeferWindowPos/EndDeferWindowPos but currently it doesn't
 271  *        matter.
 272  *
 273  *        wTo is basically lParam of WM_MDINEXT message
 274  */
 275 void MDI_SwitchActiveChild(HWND clientHwnd, HWND childHwnd, WORD wTo )
 276 {
 277     WND           *w         = WIN_FindWndPtr(clientHwnd);
 278     HWND           hwndTo    = MDI_GetWindow(w,childHwnd,wTo);
 279     HWND           hwndPrev;
 280     MDICLIENTINFO *ci;
 281
 282
 283     ci = (MDICLIENTINFO *) w->wExtra;
 284
 285     dprintf_mdi(stddeb, "MDI_SwitchActiveChild: "NPFMT", %i\n",childHwnd,wTo);
 286
 287     if ( !childHwnd || !hwndTo ) return;
 288
 289     hwndPrev = ci->hwndActiveChild;
 290
 291     if ( hwndTo != hwndPrev )
 292         {
 293             if (ci->flagChildMaximized)
 294             {
 295                 RECT rectOldRestore, rect;
 296
 297                 w = WIN_FindWndPtr(hwndTo);
 298
 299                 /* save old window dimensions */
 300                 rectOldRestore = ci->rectRestore;
 301                 GetWindowRect(hwndTo, &ci->rectRestore);
 302
 303                 rect.top    = (ci->rectMaximize.top -
 304                                (w->rectClient.top - w->rectWindow.top));
 305                 rect.bottom = (ci->rectMaximize.bottom +
 306                                (w->rectWindow.bottom - w->rectClient.bottom));
 307                 rect.left   = (ci->rectMaximize.left -
 308                                (w->rectClient.left - w->rectWindow.left));
 309                 rect.right  = (ci->rectMaximize.right +
 310                                (w->rectWindow.right - w->rectClient.right));
 311                 w->dwStyle |= WS_MAXIMIZE;
 312
 313                 /* maximize it */
 314                 ci->flagChildMaximized = childHwnd; /* prevent maximization
 315                                                      * in MDI_ChildActivate
 316                                                      */
 317
 318                 SetWindowPos( hwndTo, HWND_TOP, rect.left, rect.top,
 319                              rect.right - rect.left + 1,
 320                              rect.bottom - rect.top + 1, 0);
 321
 322                 SendMessage( hwndTo, WM_SIZE, SIZE_MAXIMIZED,
 323                             MAKELONG(w->rectClient.right-w->rectClient.left,
 324                                      w->rectClient.bottom-w->rectClient.top));
 325
 326                 w = WIN_FindWndPtr(hwndPrev);
 327
 328                 if( w )
 329                   {
 330                 w->dwStyle &= ~WS_MAXIMIZE;
 331
 332                      /* push hwndPrev to the bottom if needed */
 333                      if( !wTo )
 334                          SetWindowPos(hwndPrev, HWND_BOTTOM,
 335                              rectOldRestore.left, rectOldRestore.top,
 336                              rectOldRestore.right - rectOldRestore.left + 1,
 337                              rectOldRestore.bottom - rectOldRestore.top + 1,
 338                                   SWP_NOACTIVATE );
 339                   }
 340             }
 341             else
 342             {
 343                 SetWindowPos( hwndTo, HWND_TOP, 0, 0, 0, 0,
 344                              SWP_NOMOVE | SWP_NOSIZE );
 345                 if( !wTo && hwndPrev )
 346                 {
 347                     SetWindowPos( hwndPrev, HWND_BOTTOM, 0, 0, 0, 0,
 348                                  SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
 349                 }
 350             }
 351     }
 352
 353 }
 354
 355
 356 /**********************************************************************
 357  *                                      MDIDestroyChild
 358  */
 359 HWND MDIDestroyChild(WND *w_parent, MDICLIENTINFO *ci, HWND parent,
 360                      HWND child, BOOL flagDestroy)
 361 {
 362     WND         *childPtr = WIN_FindWndPtr(child);
 363
 364     if( childPtr )
 365     {
 366         if( child == ci->hwndActiveChild )
 367           {
 368             MDI_SwitchActiveChild(parent,child,0);
 369
 370             if( child == ci->hwndActiveChild )
 371                 MDI_ChildActivate(w_parent,0);
 372
 373             MDI_MenuDeleteItem(w_parent, child);
 374         }
 375
 376         ci->nActiveChildren--;
 377
 378         if( ci->flagChildMaximized == child )
 379             ci->flagChildMaximized = 1;
 380
 381         if (flagDestroy)
 382            {
 383             DestroyWindow(child);
 384             PostMessage(parent,WM_MDICALCCHILDSCROLL,0,0L);
 385             ci->sbRecalc |= (SB_BOTH+1);
 386            }
 387     }
 388
 389     return 0;
 390 }
 391
 392
 393 /**********************************************************************
 394  *                                      MDIMaximizeChild
 395  */
 396 LONG MDIMaximizeChild(HWND parent, HWND child, MDICLIENTINFO *ci)
 397 {
 398
 399     WND *w = WIN_FindWndPtr(child);
 400     RECT rect;
 401
 402     if( !SendMessage( child, WM_QUERYOPEN, 0, 0L) )
 403          return 0;
 404
 405     ci->rectRestore = w->rectWindow;
 406
 407     rect.top    = (ci->rectMaximize.top -
 408                    (w->rectClient.top - w->rectWindow.top));
 409     rect.bottom = (ci->rectMaximize.bottom +
 410                    (w->rectWindow.bottom - w->rectClient.bottom));
 411     rect.left   = (ci->rectMaximize.left -
 412                    (w->rectClient.left - w->rectWindow.left));
 413     rect.right  = (ci->rectMaximize.right +
 414                    (w->rectWindow.right - w->rectClient.right));
 415     w->dwStyle |= WS_MAXIMIZE;
 416
 417     SetWindowPos(child, 0, rect.left, rect.top,
 418                  rect.right - rect.left + 1, rect.bottom - rect.top + 1, 0);
 419
 420     ci->flagChildMaximized = child;
 421
 422     SendMessage(child, WM_SIZE, SIZE_MAXIMIZED,
 423                 MAKELONG(w->rectClient.right-w->rectClient.left,
 424                          w->rectClient.bottom-w->rectClient.top));
 425
 426     SendMessage(GetParent(parent), WM_NCPAINT, 0, 0);
 427
 428     return 0;
 429 }
 430
 431 /**********************************************************************
 432  *                                      MDIRestoreChild
 433  */
 434 LONG MDIRestoreChild(HWND parent, MDICLIENTINFO *ci)
 435 {
 436     HWND    hWnd;
 437
 438     hWnd = ci->hwndActiveChild;
 439
 440     dprintf_mdi(stddeb,"MDIRestoreChild: restore "NPFMT"\n", hWnd);
 441
 442     ci->flagChildMaximized = FALSE;
 443
 444     ShowWindow(hWnd, SW_RESTORE);               /* display the window */
 445
 446     hWnd = GetParent(parent);
 447
 448     SendMessage(hWnd,WM_NCPAINT , 0, 0);
 449
 450     return 0;
 451 }
 452
 453 /**********************************************************************
 454  *                                      MDI_ChildActivate
 455  *
 456  * Note: hWndChild is NULL when last child is being destroyed
 457  */
 458 LONG MDI_ChildActivate(WND *clientPtr, HWND hWndChild)
 459 {
 460     MDICLIENTINFO       *clientInfo = (MDICLIENTINFO*)clientPtr->wExtra;
 461     HWND                 prevActiveWnd = clientInfo->hwndActiveChild;
 462     WND                 *wndPtr = WIN_FindWndPtr( hWndChild );
 463     WND                 *wndPrev = WIN_FindWndPtr( prevActiveWnd );
 464     BOOL                 isActiveFrameWnd = 0;
 465
 466     if( hWndChild == prevActiveWnd ) return 0L;
 467
 468     if( wndPtr )
 469         if( wndPtr->dwStyle & WS_DISABLED ) return 0L;
 470
 471     dprintf_mdi(stddeb,"MDI_ChildActivate: "NPFMT"\n", hWndChild);
 472
 473     if( GetActiveWindow() == clientPtr->hwndParent )
 474         isActiveFrameWnd = TRUE;
 475
 476     /* deactivate prev. active child */
 477     if( wndPrev )
 478     {
 479         SendMessage( prevActiveWnd, WM_NCACTIVATE, FALSE, 0L );
 480         SendMessage( prevActiveWnd, WM_MDIACTIVATE, FALSE,
 481                                             MAKELONG(hWndChild,prevActiveWnd));
 482         /* uncheck menu item */
 483         if( clientInfo->hWindowMenu )
 484                 CheckMenuItem( clientInfo->hWindowMenu,
 485                                wndPrev->wIDmenu, 0);
 486       }
 487
 488     /* set appearance */
 489     if( clientInfo->flagChildMaximized )
 490       if( clientInfo->flagChildMaximized != hWndChild )
 491         if( hWndChild )
 492                 {
 493                   clientInfo->hwndActiveChild = hWndChild;
 494                   MDIMaximizeChild(GetParent(hWndChild),hWndChild,clientInfo);
 495                 }
 496
 497     clientInfo->hwndActiveChild = hWndChild;
 498
 499     /* check if we have any children left */
 500     if( !hWndChild )
 501         {
 502             if( isActiveFrameWnd )
 503                 SetFocus( GetParent(hWndChild) );
 504             return 0;
 505         }
 506
 507     /* check menu item */
 508     if( clientInfo->hWindowMenu )
 509               CheckMenuItem( clientInfo->hWindowMenu,
 510                              wndPtr->wIDmenu, MF_CHECKED);
 511
 512     /* bring active child to the top */
 513     SetWindowPos( hWndChild, 0,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
 514
 515     if( isActiveFrameWnd )
 516           {
 517             SendMessage( hWndChild, WM_NCACTIVATE, TRUE, 0L);
 518             if( GetFocus() == GetParent(hWndChild) )
 519                 SendMessage( GetParent(hWndChild), WM_SETFOCUS,
 520                              GetParent(hWndChild), 0L );
 521             else
 522                 SetFocus( GetParent(hWndChild) );
 523     }
 524
 525     SendMessage( hWndChild, WM_MDIACTIVATE, TRUE,
 526                                        MAKELONG(prevActiveWnd,hWndChild) );
 527
 528     return 1;
 529 }
 530
 531 /**********************************************************************
 532  *                      MDI_BuildWCL
 533  *
 534  *  iTotal returns number of children available for tiling or cascading
 535  */
 536 MDIWCL* MDI_BuildWCL(WND* clientWnd, int* iTotal)
 537 {
 538     MDIWCL *listTop,*listNext;
 539     WND    *childWnd;
 540
 541     if (!(listTop = (MDIWCL*)malloc( sizeof(MDIWCL) ))) return NULL;
 542
 543     listTop->hChild = clientWnd->hwndChild;
 544     listTop->prev   = NULL;
 545     *iTotal         = 1;
 546
 547     /* build linked list from top child to bottom */
 548
 549     childWnd  =  WIN_FindWndPtr( listTop->hChild );
 550     while( childWnd && childWnd->hwndNext )
 551     {
 552         listNext = (MDIWCL*)malloc(sizeof(MDIWCL));
 553
 554         if( !listNext )
 555         {
 556             /* quit gracefully */
 557             listNext = listTop->prev;
 558             while( listTop )
 559             {
 560                 listNext = listTop->prev;
 561                 free(listTop);
 562                 listTop  = listNext;
 563             }
 564             fprintf(stdnimp,"MDICascade: allocation failed\n");
 565             return NULL;
 566         }
 567
 568         if( (childWnd->dwStyle & WS_DISABLED) ||
 569             (childWnd->dwStyle & WS_MINIMIZE) ||
 570             !(childWnd->dwStyle & WS_VISIBLE)   )
 571         {
 572             listTop->hChild = 0;
 573             (*iTotal)--;
 574         }
 575
 576         listNext->hChild = childWnd->hwndNext;
 577         listNext->prev   = listTop;
 578         listTop          = listNext;
 579         (*iTotal)++;
 580
 581         childWnd  =  WIN_FindWndPtr( childWnd->hwndNext );
 582     }
 583
 584     if( (childWnd->dwStyle & WS_DISABLED) ||
 585         (childWnd->dwStyle & WS_MINIMIZE) ||
 586         !(childWnd->dwStyle & WS_VISIBLE)   )
 587     {
 588         listTop->hChild = 0;
 589         (*iTotal)--;
 590     }
 591
 592     return listTop;
 593 }
 594
 595 /**********************************************************************
 596  *                                      MDICascade
 597  */
 598 LONG MDICascade(HWND parent, MDICLIENTINFO *ci)
 599 {
 600     WND          *clientWnd;
 601     MDIWCL       *listTop,*listPrev;
 602     RECT          rect;
 603     int           spacing, xsize, ysize;
 604     int           x, y;
 605     int           iToPosition = 0;
 606
 607     if (ci->flagChildMaximized)
 608         MDIRestoreChild(parent, ci);
 609
 610     if (ci->nActiveChildren == 0) return 0;
 611
 612     GetClientRect(parent, &rect);
 613     spacing = GetSystemMetrics(SM_CYCAPTION) + GetSystemMetrics(SM_CYFRAME);
 614     ysize   = rect.bottom - 8 * spacing;
 615     xsize   = rect.right  - 8 * spacing;
 616
 617     dprintf_mdi(stddeb,
 618       "MDICascade: Client wnd at (%ld,%ld) - (%ld,%ld), spacing %d\n",
 619       (LONG)rect.left, (LONG)rect.top, (LONG)rect.right, (LONG)rect.bottom,
 620       spacing);
 621
 622     clientWnd =  WIN_FindWndPtr( parent );
 623
 624     listTop   =  MDI_BuildWCL(clientWnd,&iToPosition);
 625
 626     if( !listTop ) return 0;
 627
 628     x = 0;
 629     y = 0;
 630
 631     /* walk list and move windows */
 632     while ( listTop )
 633     {
 634         dprintf_mdi(stddeb, "MDICascade: move "NPFMT" to (%d,%d) size [%d,%d]\n",
 635                 listTop->hChild, x, y, xsize, ysize);
 636
 637         if( listTop->hChild )
 638           {
 639            SetWindowPos(listTop->hChild, 0, x, y, xsize, ysize,
 640                      SWP_DRAWFRAME | SWP_NOACTIVATE | SWP_NOZORDER);
 641
 642         x += spacing;
 643         y += spacing;
 644           }
 645
 646         listPrev = listTop->prev;
 647         free(listTop);
 648         listTop = listPrev;
 649     }
 650
 651     return 0;
 652 }
 653
 654 /**********************************************************************
 655  *                                      MDITile
 656  *
 657  */
 658 LONG MDITile(HWND parent, MDICLIENTINFO *ci)
 659 {
 660     WND          *wndClient = WIN_FindWndPtr(parent);
 661     MDIWCL       *listTop,*listPrev;
 662     RECT          rect;
 663     int           xsize, ysize;
 664     int           x, y;
 665     int           rows, columns;
 666     int           r, c;
 667     int           i;
 668     int           iToPosition = 0;
 669
 670     if (ci->flagChildMaximized)
 671         MDIRestoreChild(parent, ci);
 672
 673     if (ci->nActiveChildren == 0) return 0;
 674
 675     listTop = MDI_BuildWCL(wndClient, &iToPosition);
 676
 677     dprintf_mdi(stddeb,"MDITile: %i windows to tile\n",iToPosition);
 678
 679     if( !listTop ) return 0;
 680
 681     GetClientRect(parent, &rect);
 682
 683     rows    = (int) sqrt((double) iToPosition);
 684     columns = iToPosition / rows;
 685
 686     /* hack */
 687     if( iToPosition != ci->nActiveChildren)
 688         {
 689            y = rect.bottom - 2 * SYSMETRICS_CYICONSPACING - SYSMETRICS_CYICON;
 690            rect.bottom = ( y - SYSMETRICS_CYICON < rect.top )? rect.bottom: y;
 691         }
 692
 693     ysize   = rect.bottom / rows;
 694     xsize   = rect.right  / columns;
 695
 696     x       = 0;
 697     i       = 0;
 698
 699     for (c = 1; c <= columns; c++)
 700     {
 701         if (c == columns)
 702         {
 703             rows  = iToPosition - i;
 704             ysize = rect.bottom / rows;
 705         }
 706
 707         y = 0;
 708         for (r = 1; r <= rows; r++, i++)
 709         {
 710             /* shouldn't happen but... */
 711             if( !listTop )
 712                  break;
 713
 714             if( listTop->hChild )
 715                 {
 716                     SetWindowPos(listTop->hChild, 0, x, y, xsize, ysize,
 717                          SWP_DRAWFRAME | SWP_NOACTIVATE | SWP_NOZORDER);
 718             y += ysize;
 719                 }
 720
 721             listPrev = listTop->prev;
 722             free(listTop);
 723             listTop = listPrev;
 724         }
 725
 726         x += xsize;
 727     }
 728
 729     /* free the rest if any */
 730     while( listTop ) {
 731          listPrev = listTop->prev;
 732          free(listTop);
 733          listTop = listPrev; }
 734
 735     return 0;
 736 }
 737
 738 /**********************************************************************
 739  *                                      MDIHandleLButton
 740  */
 741 BOOL MDIHandleLButton(HWND hwndFrame, HWND hwndClient,
 742                       WORD wParam, LONG lParam)
 743 {
 744     MDICLIENTINFO *ci;
 745     WND           *w;
 746     RECT           rect;
 747     WORD           x;
 748
 749     w  = WIN_FindWndPtr(hwndClient);
 750     ci = (MDICLIENTINFO *) w->wExtra;
 751
 752     if (wParam == HTMENU && ci->flagChildMaximized)
 753     {
 754         x = LOWORD(lParam);
 755
 756         NC_GetInsideRect(hwndFrame, &rect);
 757         if (x < rect.left + SYSMETRICS_CXSIZE)
 758         {
 759             SendMessage(ci->hwndActiveChild, WM_SYSCOMMAND,
 760                         SC_CLOSE, lParam);
 761             return TRUE;
 762         }
 763         else if (x >= rect.right - SYSMETRICS_CXSIZE)
 764         {
 765             SendMessage(ci->hwndActiveChild, WM_SYSCOMMAND,
 766                         SC_RESTORE, lParam);
 767             return TRUE;
 768         }
 769     }
 770
 771     return FALSE;
 772 }
 773
 774 /**********************************************************************
 775  *                                      MDIPaintMaximized
 776  */
 777 LONG MDIPaintMaximized(HWND hwndFrame, HWND hwndClient, WORD message,
 778                        WORD wParam, LONG lParam)
 779 {
 780     static HBITMAP hbitmapClose     = 0;
 781     static HBITMAP hbitmapMaximized = 0;
 782
 783     MDICLIENTINFO *ci;
 784     WND           *w;
 785     HDC           hdc, hdcMem;
 786     RECT          rect;
 787     WND           *wndPtr = WIN_FindWndPtr(hwndFrame);
 788
 789     w  = WIN_FindWndPtr(hwndClient);
 790     ci = (MDICLIENTINFO *) w->wExtra;
 791
 792     dprintf_mdi(stddeb, "MDIPaintMaximized: frame "NPFMT",  client "NPFMT
 793                 ",  max flag %d,  menu %04x\n", hwndFrame, hwndClient,
 794                 ci->flagChildMaximized, wndPtr ? wndPtr->wIDmenu : 0);
 795
 796     if (ci->flagChildMaximized && wndPtr && wndPtr->wIDmenu != 0)
 797     {
 798         NC_DoNCPaint(hwndFrame, wParam, TRUE);
 799
 800         hdc = GetDCEx(hwndFrame, 0, DCX_CACHE | DCX_WINDOW);
 801         if (!hdc) return 0;
 802
 803         hdcMem = CreateCompatibleDC(hdc);
 804
 805         if (hbitmapClose == 0)
 806         {
 807             hbitmapClose     = LoadBitmap(0, MAKEINTRESOURCE(OBM_OLD_CLOSE));
 808             hbitmapMaximized = LoadBitmap(0, MAKEINTRESOURCE(OBM_RESTORE));
 809         }
 810
 811         dprintf_mdi(stddeb,
 812                     "MDIPaintMaximized: hdcMem "NPFMT", close bitmap "NPFMT", "
 813                     "maximized bitmap "NPFMT"\n",
 814                     hdcMem, hbitmapClose, hbitmapMaximized);
 815
 816         NC_GetInsideRect(hwndFrame, &rect);
 817         rect.top += (wndPtr->dwStyle & WS_CAPTION) ? SYSMETRICS_CYSIZE + 1 : 0;
 818         SelectObject(hdcMem, hbitmapClose);
 819         BitBlt(hdc, rect.left, rect.top + 1,
 820                SYSMETRICS_CXSIZE, SYSMETRICS_CYSIZE,
 821                hdcMem, 1, 1, SRCCOPY);
 822
 823         NC_GetInsideRect(hwndFrame, &rect);
 824         rect.top += (wndPtr->dwStyle & WS_CAPTION) ? SYSMETRICS_CYSIZE + 1 : 0;
 825         rect.left   = rect.right - SYSMETRICS_CXSIZE;
 826         SelectObject(hdcMem, hbitmapMaximized);
 827         BitBlt(hdc, rect.left, rect.top + 1,
 828                SYSMETRICS_CXSIZE, SYSMETRICS_CYSIZE,
 829                hdcMem, 1, 1, SRCCOPY);
 830
 831         NC_GetInsideRect(hwndFrame, &rect);
 832         rect.top += (wndPtr->dwStyle & WS_CAPTION) ? SYSMETRICS_CYSIZE + 1 : 0;
 833         rect.left += SYSMETRICS_CXSIZE;
 834         rect.right -= SYSMETRICS_CXSIZE;
 835         rect.bottom = rect.top + SYSMETRICS_CYMENU;
 836
 837         MENU_DrawMenuBar(hdc, &rect, hwndFrame, FALSE);
 838
 839         DeleteDC(hdcMem);
 840         ReleaseDC(hwndFrame, hdc);
 841     }
 842     else
 843         return DefWindowProc(hwndFrame, message, wParam, lParam);
 844
 845     return 0;
 846 }
 847
 848 /**********************************************************************
 849  *                                      MDIClientWndProc
 850  *
 851  * This function is the handler for all MDI requests.
 852  */
 853 LRESULT MDIClientWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
 854 {
 855     LPCREATESTRUCT       cs;
 856     LPCLIENTCREATESTRUCT ccs;
 857     MDICLIENTINFO       *ci;
 858     WND                 *w;
 859
 860     w  = WIN_FindWndPtr(hwnd);
 861     ci = (MDICLIENTINFO *) w->wExtra;
 862
 863     switch (message)
 864     {
 865       case WM_CREATE:
 866         cs                      = (LPCREATESTRUCT) PTR_SEG_TO_LIN(lParam);
 867         ccs                     = (LPCLIENTCREATESTRUCT) PTR_SEG_TO_LIN(cs->lpCreateParams);
 868         ci->hWindowMenu         = ccs->hWindowMenu;
 869         ci->idFirstChild        = ccs->idFirstChild;
 870         ci->flagChildMaximized  = FALSE;
 871         ci->sbStop              = 0;
 872
 873         w->dwStyle             |= WS_CLIPCHILDREN;
 874
 875         AppendMenu(ccs->hWindowMenu,MF_SEPARATOR,0,NULL);
 876
 877         GetClientRect(w->hwndParent, &ci->rectMaximize);
 878         MoveWindow(hwnd, 0, 0,
 879                    ci->rectMaximize.right, ci->rectMaximize.bottom, 1);
 880
 881         return 0;
 882
 883       case WM_MDIACTIVATE:
 884         SetWindowPos(wParam,0,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE );
 885         return 0;
 886
 887       case WM_MDICASCADE:
 888         return MDICascade(hwnd, ci);
 889
 890       case WM_MDICREATE:
 891         return (LONG)MDICreateChild(w, ci, hwnd, lParam );
 892
 893       case WM_MDIDESTROY:
 894         return MDIDestroyChild(w, ci, hwnd, wParam, TRUE);
 895
 896       case WM_MDIGETACTIVE:
 897         return ((LONG) ci->hwndActiveChild |
 898                 ((LONG) (ci->flagChildMaximized>0) << 16));
 899
 900       case WM_MDIICONARRANGE:
 901                ci->sbStop = TRUE;
 902                MDIIconArrange(hwnd);
 903                ci->sbStop = FALSE;
 904                SendMessage(hwnd,WM_MDICALCCHILDSCROLL,0,0L);
 905                return 0;
 906
 907       case WM_MDIMAXIMIZE:
 908         return MDIMaximizeChild(hwnd, wParam, ci);
 909
 910       case WM_MDINEXT:
 911         MDI_SwitchActiveChild(hwnd, (HWND)wParam, lParam);
 912         break;
 913
 914       case WM_MDIRESTORE:
 915         return MDIRestoreChild(hwnd, ci);
 916
 917       case WM_MDISETMENU:
 918         return MDISetMenu(hwnd, wParam, LOWORD(lParam), HIWORD(lParam));
 919
 920       case WM_MDITILE:
 921         ci->sbStop = TRUE;
 922         ShowScrollBar(hwnd,SB_BOTH,FALSE);
 923         MDITile(hwnd, ci);
 924         ci->sbStop = FALSE;
 925         return 0;
 926
 927       case WM_VSCROLL:
 928       case WM_HSCROLL:
 929         ci->sbStop = TRUE;
 930         ScrollChildren(hwnd,message,wParam,lParam);
 931         ci->sbStop = FALSE;
 932         return 0;
 933
 934       case WM_SETFOCUS:
 935         if( ci->hwndActiveChild )
 936           {
 937            w = WIN_FindWndPtr( ci->hwndActiveChild );
 938            if( !(w->dwStyle & WS_MINIMIZE) )
 939                SetFocus( ci->hwndActiveChild );
 940           }
 941         return 0;
 942
 943       case WM_NCACTIVATE:
 944         if( ci->hwndActiveChild )
 945         SendMessage(ci->hwndActiveChild, message, wParam, lParam);
 946         break;
 947
 948       case WM_PARENTNOTIFY:
 949         if (wParam == WM_LBUTTONDOWN)
 950              SetWindowPos(ci->hwndHitTest, 0,0,0,0,0, SWP_NOSIZE | SWP_NOMOVE );
 951         break;
 952
 953       case WM_SIZE:
 954         GetClientRect(w->hwndParent, &ci->rectMaximize);
 955         if( !ci->hwndActiveChild )
 956           {
 957              PostMessage(hwnd,WM_MDICALCCHILDSCROLL,0,0L);
 958              ci->sbRecalc |= (SB_BOTH+1);
 959           }
 960         break;
 961
 962       case WM_MDICALCCHILDSCROLL:
 963         if( !ci->sbStop )
 964           if( ci->sbRecalc )
 965             {
 966               CalcChildScroll(hwnd, ci->sbRecalc-1);
 967               ci->sbRecalc = 0;
 968             }
 969         return 0;
 970     }
 971
 972     return DefWindowProc(hwnd, message, wParam, lParam);
 973 }
 974
 975 /**********************************************************************
 976  *                                      DefFrameProc (USER.445)
 977  *
 978  */
 979 LRESULT DefFrameProc(HWND hwnd, HWND hwndMDIClient, UINT message,
 980                      WPARAM wParam, LPARAM lParam)
 981 {
 982     HWND        childHwnd;
 983
 984     if (hwndMDIClient)
 985     {
 986         switch (message)
 987         {
 988           case WM_COMMAND:
 989             childHwnd = MDI_GetChildByID( WIN_FindWndPtr(hwndMDIClient),
 990                                           wParam );
 991             if( childHwnd )
 992                 SendMessage(hwndMDIClient, WM_MDIACTIVATE, childHwnd , 0L);
 993             break;
 994
 995           case WM_NCLBUTTONDOWN:
 996             if (MDIHandleLButton(hwnd, hwndMDIClient, wParam, lParam))
 997                 return 0;
 998             break;
 999
1000           case WM_NCACTIVATE:
1001             SendMessage(hwndMDIClient, message, wParam, lParam);
1002             return MDIPaintMaximized(hwnd, hwndMDIClient,
1003                                      message, wParam, lParam);
1004
1005           case WM_NCPAINT:
1006             return MDIPaintMaximized(hwnd, hwndMDIClient,
1007                                      message, wParam, lParam);
1008
1009           case WM_SETFOCUS:
1010             SetFocus(hwndMDIClient);
1011             break;
1012
1013           case WM_SIZE:
1014             MoveWindow(hwndMDIClient, 0, 0,
1015                        LOWORD(lParam), HIWORD(lParam), TRUE);
1016             break;
1017         }
1018     }
1019
1020     return DefWindowProc(hwnd, message, wParam, lParam);
1021 }
1022
1023 /**********************************************************************
1024  *                                      DefMDIChildProc (USER.447)
1025  *
1026  */
1027 #ifdef WINELIB32
1028 LONG DefMDIChildProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
1029 #else
1030 LONG DefMDIChildProc(HWND hwnd, WORD message, WORD wParam, LONG lParam)
1031 #endif
1032 {
1033     MDICLIENTINFO       *ci;
1034     WND                 *clientWnd;
1035
1036     clientWnd  = WIN_FindWndPtr(GetParent(hwnd));
1037     ci         = (MDICLIENTINFO *) clientWnd->wExtra;
1038
1039     switch (message)
1040     {
1041       case WM_NCHITTEST:
1042         ci->hwndHitTest = hwnd;
1043         break;
1044
1045       case WM_SETTEXT:
1046         DefWindowProc(hwnd, message, wParam, lParam);
1047         MDI_MenuModifyItem(clientWnd,hwnd);
1048         return 0;
1049
1050       case WM_CLOSE:
1051         SendMessage(GetParent(hwnd),WM_MDIDESTROY,hwnd,0L);
1052         return 0;
1053
1054       case WM_SIZE:
1055         if( ci->hwndActiveChild != hwnd )
1056             MDI_ChildActivate(clientWnd, hwnd);
1057         break;
1058
1059       case WM_CHILDACTIVATE:
1060         MDI_ChildActivate(clientWnd, hwnd);
1061         return 0;
1062
1063       case WM_NCPAINT:
1064         dprintf_mdi(stddeb,"DefMDIChildProc: WM_NCPAINT for "NPFMT", active "NPFMT"\n",
1065                                              hwnd, ci->hwndActiveChild );
1066         break;
1067
1068       case WM_SYSCOMMAND:
1069         switch (wParam)
1070         {
1071           case SC_MAXIMIZE:
1072             return SendMessage(GetParent(hwnd), WM_MDIMAXIMIZE, (WPARAM)hwnd, 0);
1073
1074           case SC_RESTORE:
1075             return SendMessage(GetParent(hwnd), WM_MDIRESTORE, (WPARAM)hwnd, 0);
1076         }
1077         break;
1078
1079       /* should also handle following messages */
1080       case WM_GETMINMAXINFO:
1081            /* should return rect of MDI client
1082             * so that normal ShowWindow will be able to handle
1083             * actions that are handled by MDIMaximize and MDIRestore */
1084
1085       case WM_SETVISIBLE:
1086          if( !ci->sbStop )
1087           {
1088             PostMessage(GetParent(hwnd),WM_MDICALCCHILDSCROLL,0,0L);
1089             ci->sbRecalc |= (SB_BOTH+1);
1090           }
1091         break;
1092       case WM_SETFOCUS:
1093         if( IsChild( GetActiveWindow(), GetParent(hwnd)) )
1094             SendMessage(clientWnd->hwndChild,WM_CHILDACTIVATE,0,0L);
1095         if( !ci->sbStop )
1096           {
1097             PostMessage(GetParent(hwnd),WM_MDICALCCHILDSCROLL,0,0L);
1098             ci->sbRecalc |= (SB_BOTH+1);
1099           }
1100         break;
1101
1102       case WM_MENUCHAR:
1103       case WM_NEXTMENU:
1104            /* set current menu to child system menu */
1105
1106         break;
1107     }
1108
1109     return DefWindowProc(hwnd, message, wParam, lParam);
1110 }
1111
1112 /**********************************************************************
1113  *                                      TranslateMDISysAccel (USER.451)
1114  *
1115  */
1116 BOOL TranslateMDISysAccel(HWND hwndClient, LPMSG msg)
1117 {
1118     return 0;
1119 }
1120
1121
1122 /***********************************************************************
1123  *           CalcChildScroll   (USER.462)
1124  */
1125 void CalcChildScroll( HWND hwnd, WORD scroll )
1126 {
1127     RECT childRect, clientRect;
1128     HWND hwndChild;
1129
1130     GetClientRect( hwnd, &clientRect );
1131     SetRectEmpty( &childRect );
1132     hwndChild = GetWindow( hwnd, GW_CHILD );
1133     while (hwndChild)
1134     {
1135         WND *wndPtr = WIN_FindWndPtr( hwndChild );
1136         UnionRect( &childRect, &wndPtr->rectWindow, &childRect );
1137         hwndChild = wndPtr->hwndNext;
1138     }
1139     UnionRect( &childRect, &clientRect, &childRect );
1140
1141     if ((scroll == SB_HORZ) || (scroll == SB_BOTH))
1142     {
1143         SetScrollRange( hwnd, SB_HORZ, childRect.left,
1144                         childRect.right - clientRect.right, FALSE );
1145         SetScrollPos( hwnd, SB_HORZ, clientRect.left - childRect.left, TRUE );
1146     }
1147     if ((scroll == SB_VERT) || (scroll == SB_BOTH))
1148     {
1149         SetScrollRange( hwnd, SB_VERT, childRect.top,
1150                         childRect.bottom - clientRect.bottom, FALSE );
1151         SetScrollPos( hwnd, SB_HORZ, clientRect.top - childRect.top, TRUE );
1152     }
1153 }
1154
1155 /***********************************************************************
1156  *           ScrollChildren   (USER.463)
1157  */
1158 void ScrollChildren(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1159 {
1160  WND    *wndPtr = WIN_FindWndPtr(hWnd);
1161  short   newPos;
1162  short   curPos;
1163  short   length;
1164  short   minPos;
1165  short   maxPos;
1166  short   shift;
1167
1168  if( !wndPtr ) return;
1169
1170  if( uMsg == WM_HSCROLL )
1171    {
1172      GetScrollRange(hWnd,SB_HORZ,&minPos,&maxPos);
1173      curPos = GetScrollPos(hWnd,SB_HORZ);
1174      length = (wndPtr->rectClient.right - wndPtr->rectClient.left)/2;
1175      shift = SYSMETRICS_CYHSCROLL;
1176    }
1177  else if( uMsg == WM_VSCROLL )
1178         {
1179           GetScrollRange(hWnd,SB_VERT,&minPos,&maxPos);
1180           curPos = GetScrollPos(hWnd,SB_VERT);
1181           length = (wndPtr->rectClient.bottom - wndPtr->rectClient.top)/2;
1182           shift = SYSMETRICS_CXVSCROLL;
1183         }
1184       else return;
1185
1186  switch( wParam )
1187    {
1188         case SB_LINEUP:
1189                         newPos = curPos - shift;
1190                         break;
1191         case SB_LINEDOWN:
1192                         newPos = curPos + shift;
1193                         break;
1194         case SB_PAGEUP:
1195                         newPos = curPos - length;
1196                         break;
1197         case SB_PAGEDOWN:
1198                         newPos = curPos + length;
1199                         break;
1200
1201         case SB_THUMBPOSITION:
1202                         newPos = LOWORD(lParam);
1203                         break;
1204
1205         case SB_THUMBTRACK:
1206                         return;
1207
1208         case SB_TOP:
1209                         newPos = minPos;
1210                         break;
1211         case SB_BOTTOM:
1212                         newPos = maxPos;
1213                         break;
1214         case SB_ENDSCROLL:
1215                         CalcChildScroll(hWnd,(uMsg == WM_VSCROLL)?SB_VERT:SB_HORZ);
1216                         return;
1217    }
1218
1219  if( newPos > maxPos )
1220      newPos = maxPos;
1221  else if( newPos < minPos )
1222           newPos = minPos;
1223
1224  SetScrollPos(hWnd, (uMsg == WM_VSCROLL)?SB_VERT:SB_HORZ , newPos, TRUE);
1225
1226  if( uMsg == WM_VSCROLL )
1227      ScrollWindow(hWnd ,0 ,curPos - newPos, NULL, NULL);
1228  else
1229      ScrollWindow(hWnd ,curPos - newPos, 0, NULL, NULL);
1230 }
1231