windows/mdi.c

   1 /* MDI.C
   2  *
   3  * Copyright 1994, Bob Amstadt
   4  *
   5  * This file contains routines to support MDI features.
   6  */
   7 #include <stdlib.h>
   8 #include <stdio.h>
   9 #include <math.h>
  10 #include "windows.h"
  11 #include "win.h"
  12 #include "mdi.h"
  13 #include "user.h"
  14 #include "menu.h"
  15 #include "sysmetrics.h"
  16 #include "stddebug.h"
  17 /* #define DEBUG_MDI */
  18 #include "debug.h"
  19
  20 /**********************************************************************
  21  *                                      MDIRecreateMenuList
  22  */
  23 void
  24 MDIRecreateMenuList(MDICLIENTINFO *ci)
  25 {
  26     MDICHILDINFO *chi;
  27     char buffer[128];
  28     int id, n, index;
  29
  30     dprintf_mdi(stddeb, "MDIRecreateMenuList: hWindowMenu %0x\n",
  31             ci->hWindowMenu);
  32
  33     id = ci->idFirstChild;
  34     while (DeleteMenu(ci->hWindowMenu, id, MF_BYCOMMAND))
  35         id++;
  36
  37     dprintf_mdi(stddeb, "MDIRecreateMenuList: id %04x, idFirstChild %04x\n",
  38             id, ci->idFirstChild);
  39
  40     if (!ci->flagMenuAltered)
  41     {
  42         ci->flagMenuAltered = TRUE;
  43         AppendMenu(ci->hWindowMenu, MF_SEPARATOR, 0, NULL);
  44     }
  45
  46     id = ci->idFirstChild;
  47     index = 1;
  48     for (chi = ci->infoActiveChildren; chi != NULL; chi = chi->next)
  49     {
  50         n = sprintf(buffer, "%d ", index++);
  51         GetWindowText(chi->hwnd, buffer + n, sizeof(buffer) - n - 1);
  52
  53         dprintf_mdi(stddeb, "MDIRecreateMenuList: id %04x, '%s'\n",
  54                 id, buffer);
  55
  56         AppendMenu(ci->hWindowMenu, MF_STRING, id++, buffer);
  57     }
  58 }
  59
  60 /**********************************************************************
  61  *                                      MDICreateChild
  62  */
  63 HWND
  64 MDICreateChild(WND *w, MDICLIENTINFO *ci, HWND parent, LPMDICREATESTRUCT cs)
  65 {
  66     HWND hwnd;
  67
  68     /*
  69      * Create child window
  70      */
  71     cs->style &= (WS_MINIMIZE | WS_MAXIMIZE | WS_HSCROLL | WS_VSCROLL);
  72
  73     hwnd = CreateWindowEx(0, cs->szClass, cs->szTitle,
  74                           WS_CHILD | WS_BORDER | WS_CAPTION | WS_CLIPSIBLINGS |
  75                           WS_MAXIMIZEBOX | WS_MINIMIZEBOX | WS_SYSMENU |
  76                           WS_THICKFRAME | WS_VISIBLE | cs->style,
  77                           cs->x, cs->y, cs->cx, cs->cy, parent, (HMENU) 0,
  78                           w->hInstance, (LPSTR) cs);
  79
  80     if (hwnd)
  81     {
  82         HANDLE h = USER_HEAP_ALLOC(GMEM_MOVEABLE, sizeof(MDICHILDINFO));
  83         MDICHILDINFO *child_info = USER_HEAP_ADDR(h);
  84         if (!h)
  85         {
  86             DestroyWindow(hwnd);
  87             return 0;
  88         }
  89
  90         ci->nActiveChildren++;
  91
  92         child_info->next = ci->infoActiveChildren;
  93         child_info->prev = NULL;
  94         child_info->hwnd = hwnd;
  95
  96         if (ci->infoActiveChildren)
  97             ci->infoActiveChildren->prev = child_info;
  98
  99         ci->infoActiveChildren = child_info;
 100
 101         SendMessage(parent, WM_CHILDACTIVATE, 0, 0);
 102     }
 103
 104     return hwnd;
 105 }
 106
 107 /**********************************************************************
 108  *                                      MDIDestroyChild
 109  */
 110 HWND
 111 MDIDestroyChild(WND *w_parent, MDICLIENTINFO *ci, HWND parent, HWND child,
 112                  BOOL flagDestroy)
 113 {
 114     MDICHILDINFO  *chi;
 115
 116     chi = ci->infoActiveChildren;
 117     while (chi && chi->hwnd != child)
 118         chi = chi->next;
 119
 120     if (chi)
 121     {
 122         if (chi->prev)
 123             chi->prev->next = chi->next;
 124         if (chi->next)
 125             chi->next->prev = chi->prev;
 126         if (ci->infoActiveChildren == chi)
 127             ci->infoActiveChildren = chi->next;
 128
 129         ci->nActiveChildren--;
 130
 131         if (chi->hwnd == ci->hwndActiveChild)
 132             SendMessage(parent, WM_CHILDACTIVATE, 0, 0);
 133
 134         USER_HEAP_FREE((HANDLE) (LONG) chi);
 135
 136         if (flagDestroy)
 137             DestroyWindow(child);
 138     }
 139
 140     return 0;
 141 }
 142
 143 /**********************************************************************
 144  *                                      MDIBringChildToTop
 145  */
 146 void MDIBringChildToTop(HWND parent, WORD id, WORD by_id, BOOL send_to_bottom)
 147 {
 148     MDICHILDINFO  *chi;
 149     MDICLIENTINFO *ci;
 150     WND           *w;
 151     int            i;
 152
 153     w  = WIN_FindWndPtr(parent);
 154     ci = (MDICLIENTINFO *) w->wExtra;
 155
 156     dprintf_mdi(stddeb, "MDIBringToTop: id %04x, by_id %d\n", id, by_id);
 157
 158     if (by_id)
 159         id -= ci->idFirstChild;
 160     if (!by_id || id < ci->nActiveChildren)
 161     {
 162         chi = ci->infoActiveChildren;
 163
 164         if (by_id)
 165         {
 166             for (i = 0; i < id; i++)
 167                 chi = chi->next;
 168         }
 169         else
 170         {
 171             while (chi && chi->hwnd != id)
 172                 chi = chi->next;
 173         }
 174
 175         if (!chi)
 176             return;
 177
 178         dprintf_mdi(stddeb, "MDIBringToTop: child %04x\n", chi->hwnd);
 179         if (chi != ci->infoActiveChildren)
 180         {
 181             if (ci->flagChildMaximized)
 182             {
 183                 RECT rectOldRestore, rect;
 184
 185                 w = WIN_FindWndPtr(chi->hwnd);
 186
 187                 rectOldRestore = ci->rectRestore;
 188                 GetWindowRect(chi->hwnd, &ci->rectRestore);
 189
 190                 rect.top    = (ci->rectMaximize.top -
 191                                (w->rectClient.top - w->rectWindow.top));
 192                 rect.bottom = (ci->rectMaximize.bottom +
 193                                (w->rectWindow.bottom - w->rectClient.bottom));
 194                 rect.left   = (ci->rectMaximize.left -
 195                                (w->rectClient.left - w->rectWindow.left));
 196                 rect.right  = (ci->rectMaximize.right +
 197                                (w->rectWindow.right - w->rectClient.right));
 198                 w->dwStyle |= WS_MAXIMIZE;
 199                 SetWindowPos(chi->hwnd, HWND_TOP, rect.left, rect.top,
 200                              rect.right - rect.left + 1,
 201                              rect.bottom - rect.top + 1, 0);
 202                 SendMessage(chi->hwnd, WM_SIZE, SIZE_MAXIMIZED,
 203                             MAKELONG(w->rectClient.right-w->rectClient.left,
 204                                      w->rectClient.bottom-w->rectClient.top));
 205
 206                 w = WIN_FindWndPtr(ci->hwndActiveChild);
 207                 w->dwStyle &= ~WS_MAXIMIZE;
 208                 SetWindowPos(ci->hwndActiveChild, HWND_BOTTOM,
 209                              rectOldRestore.left, rectOldRestore.top,
 210                              rectOldRestore.right - rectOldRestore.left + 1,
 211                              rectOldRestore.bottom - rectOldRestore.top + 1,
 212                              SWP_NOACTIVATE |
 213                              (send_to_bottom ? 0 : SWP_NOZORDER));
 214             }
 215             else
 216             {
 217                 SetWindowPos(chi->hwnd, HWND_TOP, 0, 0, 0, 0,
 218                              SWP_NOMOVE | SWP_NOSIZE );
 219                 if (send_to_bottom)
 220                 {
 221                     SetWindowPos(ci->hwndActiveChild, HWND_BOTTOM, 0, 0, 0, 0,
 222                                  SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
 223                 }
 224             }
 225
 226             if (chi->next)
 227                 chi->next->prev    = chi->prev;
 228
 229             if (chi->prev)
 230                 chi->prev->next    = chi->next;
 231
 232             chi->prev              = NULL;
 233             chi->next              = ci->infoActiveChildren;
 234             chi->next->prev        = chi;
 235             ci->infoActiveChildren = chi;
 236
 237             SendMessage(parent, WM_CHILDACTIVATE, 0, 0);
 238         }
 239
 240         dprintf_mdi(stddeb, "MDIBringToTop: pos %04x, hwnd %04x\n",
 241                 id, chi->hwnd);
 242     }
 243 }
 244
 245 /**********************************************************************
 246  *                                      MDIMaximizeChild
 247  */
 248 LONG MDIMaximizeChild(HWND parent, HWND child, MDICLIENTINFO *ci)
 249 {
 250     WND *w = WIN_FindWndPtr(child);
 251     RECT rect;
 252
 253     MDIBringChildToTop(parent, child, FALSE, FALSE);
 254     ci->rectRestore = w->rectWindow;
 255
 256     rect.top    = (ci->rectMaximize.top -
 257                    (w->rectClient.top - w->rectWindow.top));
 258     rect.bottom = (ci->rectMaximize.bottom +
 259                    (w->rectWindow.bottom - w->rectClient.bottom));
 260     rect.left   = (ci->rectMaximize.left -
 261                    (w->rectClient.left - w->rectWindow.left));
 262     rect.right  = (ci->rectMaximize.right +
 263                    (w->rectWindow.right - w->rectClient.right));
 264     w->dwStyle |= WS_MAXIMIZE;
 265     SetWindowPos(child, 0, rect.left, rect.top,
 266                  rect.right - rect.left + 1, rect.bottom - rect.top + 1,
 267                  SWP_NOACTIVATE | SWP_NOZORDER);
 268
 269     ci->flagChildMaximized = TRUE;
 270
 271     SendMessage(child, WM_SIZE, SIZE_MAXIMIZED,
 272                 MAKELONG(w->rectClient.right-w->rectClient.left,
 273                          w->rectClient.bottom-w->rectClient.top));
 274     SendMessage(GetParent(parent), WM_NCPAINT, 1, 0);
 275
 276     return 0;
 277 }
 278
 279 /**********************************************************************
 280  *                                      MDIRestoreChild
 281  */
 282 LONG MDIRestoreChild(HWND parent, MDICLIENTINFO *ci)
 283 {
 284     HWND    child;
 285     WND    *w      = WIN_FindWndPtr(parent);
 286     LPRECT  lprect = &ci->rectRestore;
 287
 288     dprintf_mdi(stddeb,"restoring mdi child\n");
 289
 290     child = ci->hwndActiveChild;
 291
 292     w->dwStyle &= ~WS_MAXIMIZE;
 293     SetWindowPos(child, 0, lprect->left, lprect->top,
 294                  lprect->right - lprect->left + 1,
 295                  lprect->bottom - lprect->top + 1,
 296                  SWP_NOACTIVATE | SWP_NOZORDER);
 297
 298     ci->flagChildMaximized = FALSE;
 299
 300     ShowWindow(child, SW_RESTORE);              /* display the window */
 301     SendMessage(GetParent(parent), WM_NCPAINT, 1, 0);
 302     MDIBringChildToTop(parent, child, FALSE, FALSE);
 303
 304     return 0;
 305 }
 306
 307 /**********************************************************************
 308  *                                      MDIChildActivated
 309  */
 310 LONG MDIChildActivated(WND *w, MDICLIENTINFO *ci, HWND parent)
 311 {
 312     MDICHILDINFO *chi;
 313     HWND          deact_hwnd;
 314     HWND          act_hwnd;
 315     LONG          lParam;
 316
 317     dprintf_mdi(stddeb, "MDIChildActivate: top %04x\n", w->hwndChild);
 318
 319     chi = ci->infoActiveChildren;
 320     if (chi)
 321     {
 322         deact_hwnd = ci->hwndActiveChild;
 323         act_hwnd   = chi->hwnd;
 324         lParam     = ((LONG) deact_hwnd << 16) | act_hwnd;
 325
 326         dprintf_mdi(stddeb, "MDIChildActivate: deact %04x, act %04x\n",
 327                deact_hwnd, act_hwnd);
 328
 329         ci->hwndActiveChild = act_hwnd;
 330
 331         if (deact_hwnd != act_hwnd)
 332         {
 333             MDIRecreateMenuList(ci);
 334             SendMessage(deact_hwnd,  WM_NCACTIVATE, FALSE, 0);
 335             SendMessage(deact_hwnd, WM_MDIACTIVATE, FALSE, lParam);
 336         }
 337
 338         SendMessage(act_hwnd,  WM_NCACTIVATE, TRUE, 0);
 339         SendMessage(act_hwnd, WM_MDIACTIVATE, TRUE, lParam);
 340     }
 341
 342     if (chi || ci->nActiveChildren == 0)
 343     {
 344         MDIRecreateMenuList(ci);
 345         SendMessage(GetParent(parent), WM_NCPAINT, 0, 0);
 346     }
 347
 348     return 0;
 349 }
 350
 351 /**********************************************************************
 352  *                                      MDICascade
 353  */
 354 LONG MDICascade(HWND parent, MDICLIENTINFO *ci)
 355 {
 356     MDICHILDINFO *chi;
 357     RECT          rect;
 358     int           spacing, xsize, ysize;
 359     int           x, y;
 360
 361     if (ci->flagChildMaximized)
 362         MDIRestoreChild(parent, ci);
 363
 364     GetClientRect(parent, &rect);
 365     spacing = GetSystemMetrics(SM_CYCAPTION) + GetSystemMetrics(SM_CYFRAME);
 366     ysize   = rect.bottom - 8 * spacing;
 367     xsize   = rect.right  - 8 * spacing;
 368
 369     dprintf_mdi(stddeb,
 370             "MDICascade: Client wnd at (%d,%d) - (%d,%d), spacing %d\n",
 371             rect.left, rect.top, rect.right, rect.bottom, spacing);
 372     dprintf_mdi(stddeb, "MDICascade: searching for last child\n");
 373     for (chi = ci->infoActiveChildren; chi->next != NULL; chi = chi->next)
 374         ;
 375
 376     dprintf_mdi(stddeb, "MDICascade: last child is %04x\n", chi->hwnd);
 377     x = 0;
 378     y = 0;
 379     for ( ; chi != NULL; chi = chi->prev)
 380     {
 381         dprintf_mdi(stddeb, "MDICascade: move %04x to (%d,%d) size [%d,%d]\n",
 382                 chi->hwnd, x, y, xsize, ysize);
 383         SetWindowPos(chi->hwnd, 0, x, y, xsize, ysize,
 384                      SWP_DRAWFRAME | SWP_NOACTIVATE | SWP_NOZORDER);
 385
 386         x += spacing;
 387         y += spacing;
 388     }
 389
 390     return 0;
 391 }
 392
 393 /**********************************************************************
 394  *                                      MDITile
 395  */
 396 LONG MDITile(HWND parent, MDICLIENTINFO *ci)
 397 {
 398     MDICHILDINFO *chi;
 399     RECT          rect;
 400     int           xsize, ysize;
 401     int           x, y;
 402     int           rows, columns;
 403     int           r, c;
 404     int           i;
 405
 406     if (ci->flagChildMaximized)
 407         MDIRestoreChild(parent, ci);
 408
 409     GetClientRect(parent, &rect);
 410     rows    = (int) sqrt((double) ci->nActiveChildren);
 411     columns = ci->nActiveChildren / rows;
 412     ysize   = rect.bottom / rows;
 413     xsize   = rect.right  / columns;
 414
 415     chi     = ci->infoActiveChildren;
 416     x       = 0;
 417     i       = 0;
 418     for (c = 1; c <= columns; c++)
 419     {
 420         if (c == columns)
 421         {
 422             rows  = ci->nActiveChildren - i;
 423             ysize = rect.bottom / rows;
 424         }
 425
 426         y = 0;
 427         for (r = 1; r <= rows; r++, i++, chi = chi->next)
 428         {
 429             SetWindowPos(chi->hwnd, 0, x, y, xsize, ysize,
 430                          SWP_DRAWFRAME | SWP_NOACTIVATE | SWP_NOZORDER);
 431
 432             y += ysize;
 433         }
 434
 435         x += xsize;
 436     }
 437
 438
 439     return 0;
 440 }
 441
 442 /**********************************************************************
 443  *                                      MDIHandleLButton
 444  */
 445 BOOL MDIHandleLButton(HWND hwndFrame, HWND hwndClient,
 446                       WORD wParam, LONG lParam)
 447 {
 448     MDICLIENTINFO *ci;
 449     WND           *w;
 450     RECT           rect;
 451     WORD           x;
 452
 453     w  = WIN_FindWndPtr(hwndClient);
 454     ci = (MDICLIENTINFO *) w->wExtra;
 455
 456     if (wParam == HTMENU && ci->flagChildMaximized)
 457     {
 458         x = LOWORD(lParam);
 459
 460         NC_GetInsideRect(hwndFrame, &rect);
 461         if (x < rect.left + SYSMETRICS_CXSIZE)
 462         {
 463             SendMessage(ci->hwndActiveChild, WM_SYSCOMMAND,
 464                         SC_CLOSE, lParam);
 465             return TRUE;
 466         }
 467         else if (x >= rect.right - SYSMETRICS_CXSIZE)
 468         {
 469             SendMessage(ci->hwndActiveChild, WM_SYSCOMMAND,
 470                         SC_RESTORE, lParam);
 471             return TRUE;
 472         }
 473     }
 474
 475     return FALSE;
 476 }
 477
 478 /**********************************************************************
 479  *                                      MDIPaintMaximized
 480  */
 481 LONG MDIPaintMaximized(HWND hwndFrame, HWND hwndClient, WORD message,
 482                        WORD wParam, LONG lParam)
 483 {
 484     static HBITMAP hbitmapClose     = 0;
 485     static HBITMAP hbitmapMaximized = 0;
 486
 487     MDICLIENTINFO *ci;
 488     WND           *w;
 489     LONG           rv;
 490     HDC            hdc, hdcMem;
 491     RECT           rect;
 492     WND           *wndPtr = WIN_FindWndPtr(hwndFrame);
 493
 494     w  = WIN_FindWndPtr(hwndClient);
 495     ci = (MDICLIENTINFO *) w->wExtra;
 496
 497     dprintf_mdi(stddeb,
 498                 "MDIPaintMaximized: frame %04x,  client %04x"
 499                 ",  max flag %d,  menu %04x\n",
 500                 hwndFrame, hwndClient,
 501                 ci->flagChildMaximized, wndPtr ? wndPtr->wIDmenu : 0);
 502
 503     if (ci->flagChildMaximized && wndPtr && wndPtr->wIDmenu != 0)
 504     {
 505         rv = NC_DoNCPaint( hwndFrame, (HRGN) 1, wParam, TRUE);
 506
 507         hdc = GetDCEx(hwndFrame, 0, DCX_CACHE | DCX_WINDOW);
 508         if (!hdc)
 509             return rv;
 510
 511         hdcMem = CreateCompatibleDC(hdc);
 512
 513         if (hbitmapClose == 0)
 514         {
 515             hbitmapClose     = LoadBitmap(0, MAKEINTRESOURCE(OBM_OLD_CLOSE));
 516             hbitmapMaximized = LoadBitmap(0, MAKEINTRESOURCE(OBM_RESTORE));
 517         }
 518
 519         dprintf_mdi(stddeb,
 520                 "MDIPaintMaximized: hdcMem %04x, close bitmap %04x, "
 521                 "maximized bitmap %04x\n",
 522                 hdcMem, hbitmapClose, hbitmapMaximized);
 523
 524         NC_GetInsideRect(hwndFrame, &rect);
 525         rect.top   += ((wndPtr->dwStyle & WS_CAPTION) ?
 526                        SYSMETRICS_CYSIZE + 1 :  0);
 527         SelectObject(hdcMem, hbitmapClose);
 528         BitBlt(hdc, rect.left, rect.top + 1,
 529                SYSMETRICS_CXSIZE, SYSMETRICS_CYSIZE,
 530                hdcMem, 1, 1, SRCCOPY);
 531
 532         NC_GetInsideRect(hwndFrame, &rect);
 533         rect.top   += ((wndPtr->dwStyle & WS_CAPTION) ?
 534                        SYSMETRICS_CYSIZE + 1 :  0);
 535         rect.left   = rect.right - SYSMETRICS_CXSIZE;
 536         SelectObject(hdcMem, hbitmapMaximized);
 537         BitBlt(hdc, rect.left, rect.top + 1,
 538                SYSMETRICS_CXSIZE, SYSMETRICS_CYSIZE,
 539                hdcMem, 1, 1, SRCCOPY);
 540
 541         NC_GetInsideRect(hwndFrame, &rect);
 542         rect.top   += ((wndPtr->dwStyle & WS_CAPTION) ?
 543                        SYSMETRICS_CYSIZE + 1 :  0);
 544         rect.left  += SYSMETRICS_CXSIZE;
 545         rect.right -= SYSMETRICS_CXSIZE;
 546         rect.bottom = rect.top + SYSMETRICS_CYMENU;
 547
 548         MENU_DrawMenuBar(hdc, &rect, hwndFrame, FALSE);
 549
 550         DeleteDC(hdcMem);
 551         ReleaseDC(hwndFrame, hdc);
 552     }
 553     else
 554         DefWindowProc(hwndFrame, message, wParam, lParam);
 555
 556     return rv;
 557 }
 558
 559 /**********************************************************************
 560  *                                      MDIClientWndProc
 561  *
 562  * This function is the handler for all MDI requests.
 563  */
 564 LONG
 565 MDIClientWndProc(HWND hwnd, WORD message, WORD wParam, LONG lParam)
 566 {
 567     LPCREATESTRUCT       cs;
 568     LPCLIENTCREATESTRUCT ccs;
 569     MDICLIENTINFO       *ci;
 570     WND                 *w;
 571
 572     w  = WIN_FindWndPtr(hwnd);
 573     ci = (MDICLIENTINFO *) w->wExtra;
 574
 575     switch (message)
 576     {
 577       case WM_CHILDACTIVATE:
 578         return MDIChildActivated(w, ci, hwnd);
 579
 580       case WM_CREATE:
 581         cs                      = (LPCREATESTRUCT) lParam;
 582         ccs                     = (LPCLIENTCREATESTRUCT) cs->lpCreateParams;
 583         ci->hWindowMenu         = ccs->hWindowMenu;
 584         ci->idFirstChild        = ccs->idFirstChild;
 585         ci->infoActiveChildren  = NULL;
 586         ci->flagMenuAltered     = FALSE;
 587         ci->flagChildMaximized  = FALSE;
 588         w->dwStyle             |= WS_CLIPCHILDREN;
 589
 590         GetClientRect(w->hwndParent, &ci->rectMaximize);
 591         MoveWindow(hwnd, 0, 0,
 592                    ci->rectMaximize.right, ci->rectMaximize.bottom, 1);
 593
 594         return 0;
 595
 596       case WM_MDIACTIVATE:
 597         MDIBringChildToTop(hwnd, wParam, FALSE, FALSE);
 598         return 0;
 599
 600       case WM_MDICASCADE:
 601         return MDICascade(hwnd, ci);
 602
 603       case WM_MDICREATE:
 604         return MDICreateChild(w, ci, hwnd, (LPMDICREATESTRUCT) lParam);
 605
 606       case WM_MDIDESTROY:
 607         return MDIDestroyChild(w, ci, hwnd, wParam, TRUE);
 608
 609       case WM_MDIGETACTIVE:
 610         return ((LONG) ci->hwndActiveChild |
 611                 ((LONG) ci->flagChildMaximized << 16));
 612
 613       case WM_MDIICONARRANGE:
 614         /* return MDIIconArrange(...) */
 615         break;
 616
 617       case WM_MDIMAXIMIZE:
 618         return MDIMaximizeChild(hwnd, wParam, ci);
 619
 620       case WM_MDINEXT:
 621         MDIBringChildToTop(hwnd, wParam, FALSE, TRUE);
 622         break;
 623
 624       case WM_MDIRESTORE:
 625         return MDIRestoreChild(hwnd, ci);
 626
 627       case WM_MDISETMENU:
 628         /* return MDISetMenu(...) */
 629         break;
 630
 631       case WM_MDITILE:
 632         return MDITile(hwnd, ci);
 633
 634       case WM_NCACTIVATE:
 635         SendMessage(ci->hwndActiveChild, message, wParam, lParam);
 636         break;
 637
 638       case WM_PARENTNOTIFY:
 639         if (wParam == WM_DESTROY)
 640             return MDIDestroyChild(w, ci, hwnd, LOWORD(lParam), FALSE);
 641         else if (wParam == WM_LBUTTONDOWN)
 642             MDIBringChildToTop(hwnd, ci->hwndHitTest, FALSE, FALSE);
 643         break;
 644
 645       case WM_SIZE:
 646         GetClientRect(w->hwndParent, &ci->rectMaximize);
 647         break;
 648
 649     }
 650
 651     return DefWindowProc(hwnd, message, wParam, lParam);
 652 }
 653
 654 /**********************************************************************
 655  *                                      DefFrameProc (USER.445)
 656  *
 657  */
 658 LONG
 659 DefFrameProc(HWND hwnd, HWND hwndMDIClient, WORD message,
 660              WORD wParam, LONG lParam)
 661 {
 662     if (hwndMDIClient)
 663     {
 664         switch (message)
 665         {
 666           case WM_COMMAND:
 667             MDIBringChildToTop(hwndMDIClient, wParam, TRUE, FALSE);
 668             break;
 669
 670           case WM_NCLBUTTONDOWN:
 671             if (MDIHandleLButton(hwnd, hwndMDIClient, wParam, lParam))
 672                 return 0;
 673             break;
 674
 675           case WM_NCACTIVATE:
 676             SendMessage(hwndMDIClient, message, wParam, lParam);
 677             return MDIPaintMaximized(hwnd, hwndMDIClient,
 678                                      message, wParam, lParam);
 679
 680           case WM_NCPAINT:
 681             return MDIPaintMaximized(hwnd, hwndMDIClient,
 682                                      message, wParam, lParam);
 683
 684           case WM_SETFOCUS:
 685             SendMessage(hwndMDIClient, WM_SETFOCUS, wParam, lParam);
 686             break;
 687
 688           case WM_SIZE:
 689             MoveWindow(hwndMDIClient, 0, 0,
 690                        LOWORD(lParam), HIWORD(lParam), TRUE);
 691             break;
 692         }
 693     }
 694
 695     return DefWindowProc(hwnd, message, wParam, lParam);
 696 }
 697
 698 /**********************************************************************
 699  *                                      DefMDIChildProc (USER.447)
 700  *
 701  */
 702 LONG
 703 DefMDIChildProc(HWND hwnd, WORD message, WORD wParam, LONG lParam)
 704 {
 705     MDICLIENTINFO       *ci;
 706     WND                 *w;
 707
 708     w  = WIN_FindWndPtr(GetParent(hwnd));
 709     ci = (MDICLIENTINFO *) w->wExtra;
 710
 711     switch (message)
 712     {
 713       case WM_NCHITTEST:
 714         ci->hwndHitTest = hwnd;
 715         break;
 716
 717       case WM_NCPAINT:
 718         return NC_DoNCPaint(hwnd, (HRGN)1,
 719                             hwnd == ci->hwndActiveChild);
 720
 721       case WM_SYSCOMMAND:
 722         switch (wParam)
 723         {
 724           case SC_MAXIMIZE:
 725             return SendMessage(GetParent(hwnd), WM_MDIMAXIMIZE, hwnd, 0);
 726
 727           case SC_RESTORE:
 728             return SendMessage(GetParent(hwnd), WM_MDIRESTORE, hwnd, 0);
 729         }
 730         break;
 731
 732     }
 733
 734     return DefWindowProc(hwnd, message, wParam, lParam);
 735 }
 736
 737 /**********************************************************************
 738  *                                      TranslateMDISysAccel (USER.451)
 739  *
 740  */
 741 BOOL TranslateMDISysAccel(HWND hwndClient, LPMSG msg)
 742 {
 743     return 0;
 744 }