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