synfig-osx/launcher/rootless-val-tree.c

   1 /*
   2  * Calculate window clip lists for rootless mode
   3  *
   4  * This file is very closely based on mivaltree.c.
   5  */
   6  /* $XFree86: xc/programs/Xserver/hw/darwin/quartz/rootlessValTree.c,v 1.2 2002/06/18 19:43:04 torrey Exp $ */
   7
   8 /*
   9  * mivaltree.c --
  10  *      Functions for recalculating window clip lists. Main function
  11  *      is miValidateTree.
  12  *
  13
  14 Copyright 1987, 1988, 1989, 1998  The Open Group
  15
  16 All Rights Reserved.
  17
  18 The above copyright notice and this permission notice shall be included in
  19 all copies or substantial portions of the Software.
  20
  21 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  22 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  23 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
  24 OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  25 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  26 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  27
  28 Except as contained in this notice, the name of The Open Group shall not be
  29 used in advertising or otherwise to promote the sale, use or other dealings
  30 in this Software without prior written authorization from The Open Group.
  31
  32  *
  33  * Copyright 1987, 1988, 1989 by
  34  * Digital Equipment Corporation, Maynard, Massachusetts,
  35  *
  36  *                         All Rights Reserved
  37  *
  38  * Permission to use, copy, modify, and distribute this software and its
  39  * documentation for any purpose and without fee is hereby granted,
  40  * provided that the above copyright notice appear in all copies and that
  41  * both that copyright notice and this permission notice appear in
  42  * supporting documentation, and that the name of Digital not be
  43  * used in advertising or publicity pertaining to distribution of the
  44  * software without specific, written prior permission.
  45  *
  46  * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  47  * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  48  * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  49  * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  50  * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  51  * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  52  * SOFTWARE.
  53  *
  54  ******************************************************************/
  55
  56 /* The panoramix components contained the following notice */
  57 /****************************************************************
  58 *                                                               *
  59 *    Copyright (c) Digital Equipment Corporation, 1991, 1997    *
  60 *                                                               *
  61 *   All Rights Reserved.  Unpublished rights  reserved  under   *
  62 *   the copyright laws of the United States.                    *
  63 *                                                               *
  64 *   The software contained on this media  is  proprietary  to   *
  65 *   and  embodies  the  confidential  technology  of  Digital   *
  66 *   Equipment Corporation.  Possession, use,  duplication  or   *
  67 *   dissemination of the software and media is authorized only  *
  68 *   pursuant to a valid written license from Digital Equipment  *
  69 *   Corporation.                                                *
  70 *                                                               *
  71 *   RESTRICTED RIGHTS LEGEND   Use, duplication, or disclosure  *
  72 *   by the U.S. Government is subject to restrictions  as  set  *
  73 *   forth in Subparagraph (c)(1)(ii)  of  DFARS  252.227-7013,  *
  74 *   or  in  FAR 52.227-19, as applicable.                       *
  75 *                                                               *
  76 *****************************************************************/
  77
  78  /*
  79   * Aug '86: Susan Angebranndt -- original code
  80   * July '87: Adam de Boor -- substantially modified and commented
  81   * Summer '89: Joel McCormack -- so fast you wouldn't believe it possible.
  82   *             In particular, much improved code for window mapping and
  83   *             circulating.
  84   *             Bob Scheifler -- avoid miComputeClips for unmapped windows,
  85   *                              valdata changes
  86   */
  87 #include    "X.h"
  88 #include    "scrnintstr.h"
  89 #include    "validate.h"
  90 #include    "windowstr.h"
  91 #include    "mi.h"
  92 #include    "regionstr.h"
  93 #include    "mivalidate.h"
  94
  95 #include    "globals.h"
  96
  97 #ifdef SHAPE
  98 /*
  99  * Compute the visibility of a shaped window
 100  */
 101 int
 102 RootlessShapedWindowIn (pScreen, universe, bounding, rect, x, y)
 103     ScreenPtr   pScreen;
 104     RegionPtr   universe, bounding;
 105     BoxPtr      rect;
 106     register int x, y;
 107 {
 108     BoxRec  box;
 109     register BoxPtr  boundBox;
 110     int     nbox;
 111     Bool    someIn, someOut;
 112     register int t, x1, y1, x2, y2;
 113
 114     nbox = REGION_NUM_RECTS (bounding);
 115     boundBox = REGION_RECTS (bounding);
 116     someIn = someOut = FALSE;
 117     x1 = rect->x1;
 118     y1 = rect->y1;
 119     x2 = rect->x2;
 120     y2 = rect->y2;
 121     while (nbox--)
 122     {
 123         if ((t = boundBox->x1 + x) < x1)
 124             t = x1;
 125         box.x1 = t;
 126         if ((t = boundBox->y1 + y) < y1)
 127             t = y1;
 128         box.y1 = t;
 129         if ((t = boundBox->x2 + x) > x2)
 130             t = x2;
 131         box.x2 = t;
 132         if ((t = boundBox->y2 + y) > y2)
 133             t = y2;
 134         box.y2 = t;
 135         if (box.x1 > box.x2)
 136             box.x2 = box.x1;
 137         if (box.y1 > box.y2)
 138             box.y2 = box.y1;
 139         switch (RECT_IN_REGION(pScreen, universe, &box))
 140         {
 141         case rgnIN:
 142             if (someOut)
 143                 return rgnPART;
 144             someIn = TRUE;
 145             break;
 146         case rgnOUT:
 147             if (someIn)
 148                 return rgnPART;
 149             someOut = TRUE;
 150             break;
 151         default:
 152             return rgnPART;
 153         }
 154         boundBox++;
 155     }
 156     if (someIn)
 157         return rgnIN;
 158     return rgnOUT;
 159 }
 160 #endif
 161
 162 #define HasParentRelativeBorder(w) (!(w)->borderIsPixel && \
 163                                     HasBorder(w) && \
 164                                     (w)->backgroundState == ParentRelative)
 165
 166
 167 /*
 168  *-----------------------------------------------------------------------
 169  * RootlessComputeClips --
 170  *      Recompute the clipList, borderClip, exposed and borderExposed
 171  *      regions for pParent and its children. Only viewable windows are
 172  *      taken into account.
 173  *
 174  * Results:
 175  *      None.
 176  *
 177  * Side Effects:
 178  *      clipList, borderClip, exposed and borderExposed are altered.
 179  *      A VisibilityNotify event may be generated on the parent window.
 180  *
 181  *-----------------------------------------------------------------------
 182  */
 183 static void
 184 RootlessComputeClips (pParent, pScreen, universe, kind, exposed)
 185     register WindowPtr  pParent;
 186     register ScreenPtr  pScreen;
 187     register RegionPtr  universe;
 188     VTKind              kind;
 189     RegionPtr           exposed; /* for intermediate calculations */
 190 {
 191     int                 dx,
 192                         dy;
 193     RegionRec           childUniverse;
 194     register WindowPtr  pChild;
 195     int                 oldVis, newVis;
 196     BoxRec              borderSize;
 197     RegionRec           childUnion;
 198     Bool                overlap;
 199     RegionPtr           borderVisible;
 200     Bool                resized;
 201     /*
 202      * Figure out the new visibility of this window.
 203      * The extent of the universe should be the same as the extent of
 204      * the borderSize region. If the window is unobscured, this rectangle
 205      * will be completely inside the universe (the universe will cover it
 206      * completely). If the window is completely obscured, none of the
 207      * universe will cover the rectangle.
 208      */
 209     borderSize.x1 = pParent->drawable.x - wBorderWidth(pParent);
 210     borderSize.y1 = pParent->drawable.y - wBorderWidth(pParent);
 211     dx = (int) pParent->drawable.x + (int) pParent->drawable.width + wBorderWidth(pParent);
 212     if (dx > 32767)
 213         dx = 32767;
 214     borderSize.x2 = dx;
 215     dy = (int) pParent->drawable.y + (int) pParent->drawable.height + wBorderWidth(pParent);
 216     if (dy > 32767)
 217         dy = 32767;
 218     borderSize.y2 = dy;
 219
 220     oldVis = pParent->visibility;
 221     switch (RECT_IN_REGION( pScreen, universe, &borderSize))
 222     {
 223     case rgnIN:
 224             newVis = VisibilityUnobscured;
 225             break;
 226         case rgnPART:
 227             newVis = VisibilityPartiallyObscured;
 228 #ifdef SHAPE
 229             {
 230                 RegionPtr   pBounding;
 231
 232                 if ((pBounding = wBoundingShape (pParent)))
 233                 {
 234                     switch (RootlessShapedWindowIn (pScreen, universe,
 235                                                     pBounding, &borderSize,
 236                                                     pParent->drawable.x,
 237                                                     pParent->drawable.y))
 238                     {
 239                     case rgnIN:
 240                         newVis = VisibilityUnobscured;
 241                         break;
 242                     case rgnOUT:
 243                         newVis = VisibilityFullyObscured;
 244                         break;
 245                     }
 246                 }
 247             }
 248 #endif
 249             break;
 250         default:
 251             newVis = VisibilityFullyObscured;
 252             break;
 253     }
 254
 255     pParent->visibility = newVis;
 256     if (oldVis != newVis &&
 257         ((pParent->eventMask | wOtherEventMasks(pParent)) & VisibilityChangeMask))
 258         SendVisibilityNotify(pParent);
 259
 260     dx = pParent->drawable.x - pParent->valdata->before.oldAbsCorner.x;
 261     dy = pParent->drawable.y - pParent->valdata->before.oldAbsCorner.y;
 262
 263     /*
 264      * avoid computations when dealing with simple operations
 265      */
 266
 267     switch (kind) {
 268     case VTMap:
 269     case VTStack:
 270     case VTUnmap:
 271         break;
 272     case VTMove:
 273         if ((oldVis == newVis) &&
 274             ((oldVis == VisibilityFullyObscured) ||
 275              (oldVis == VisibilityUnobscured)))
 276         {
 277             pChild = pParent;
 278             while (1)
 279             {
 280                 if (pChild->viewable)
 281                 {
 282                     if (pChild->visibility != VisibilityFullyObscured)
 283                     {
 284                         REGION_TRANSLATE( pScreen, &pChild->borderClip,
 285                                                       dx, dy);
 286                         REGION_TRANSLATE( pScreen, &pChild->clipList,
 287                                                       dx, dy);
 288                         pChild->drawable.serialNumber = NEXT_SERIAL_NUMBER;
 289                         if (pScreen->ClipNotify)
 290                             (* pScreen->ClipNotify) (pChild, dx, dy);
 291
 292                     }
 293                     if (pChild->valdata)
 294                     {
 295                         REGION_INIT(pScreen,
 296                                     &pChild->valdata->after.borderExposed,
 297                                     NullBox, 0);
 298                         if (HasParentRelativeBorder(pChild))
 299                           {
 300                             REGION_SUBTRACT(pScreen,
 301                                          &pChild->valdata->after.borderExposed,
 302                                          &pChild->borderClip,
 303                                          &pChild->winSize);
 304                         }
 305                         REGION_INIT( pScreen, &pChild->valdata->after.exposed,
 306                                                  NullBox, 0);
 307                     }
 308                     if (pChild->firstChild)
 309                     {
 310                         pChild = pChild->firstChild;
 311                         continue;
 312                     }
 313                 }
 314                 while (!pChild->nextSib && (pChild != pParent))
 315                     pChild = pChild->parent;
 316                 if (pChild == pParent)
 317                     break;
 318                 pChild = pChild->nextSib;
 319             }
 320             return;
 321         }
 322         /* fall through */
 323     default:
 324         /*
 325          * To calculate exposures correctly, we have to translate the old
 326          * borderClip and clipList regions to the window's new location so there
 327          * is a correspondence between pieces of the new and old clipping regions.
 328          */
 329         if (dx || dy)
 330         {
 331             /*
 332              * We translate the old clipList because that will be exposed or copied
 333              * if gravity is right.
 334              */
 335             REGION_TRANSLATE( pScreen, &pParent->borderClip, dx, dy);
 336             REGION_TRANSLATE( pScreen, &pParent->clipList, dx, dy);
 337         }
 338         break;
 339     case VTBroken:
 340         REGION_EMPTY (pScreen, &pParent->borderClip);
 341         REGION_EMPTY (pScreen, &pParent->clipList);
 342         break;
 343     }
 344
 345     borderVisible = pParent->valdata->before.borderVisible;
 346     resized = pParent->valdata->before.resized;
 347     REGION_INIT( pScreen, &pParent->valdata->after.borderExposed, NullBox, 0);
 348     REGION_INIT( pScreen, &pParent->valdata->after.exposed, NullBox, 0);
 349
 350     /*
 351      * Since the borderClip must not be clipped by the children, we do
 352      * the border exposure first...
 353      *
 354      * 'universe' is the window's borderClip. To figure the exposures, remove
 355      * the area that used to be exposed from the new.
 356      * This leaves a region of pieces that weren't exposed before.
 357      */
 358
 359     if (HasBorder (pParent))
 360     {
 361         if (borderVisible)
 362         {
 363             /*
 364              * when the border changes shape, the old visible portions
 365              * of the border will be saved by DIX in borderVisible --
 366              * use that region and destroy it
 367              */
 368             REGION_SUBTRACT( pScreen, exposed, universe, borderVisible);
 369             REGION_DESTROY( pScreen, borderVisible);
 370         }
 371         else
 372         {
 373             REGION_SUBTRACT( pScreen, exposed, universe, &pParent->borderClip);
 374         }
 375         if (HasParentRelativeBorder(pParent) && (dx || dy)) {
 376             REGION_SUBTRACT( pScreen, &pParent->valdata->after.borderExposed,
 377                                   universe,
 378                                   &pParent->winSize);
 379         } else {
 380             REGION_SUBTRACT( pScreen, &pParent->valdata->after.borderExposed,
 381                                exposed, &pParent->winSize);
 382         }
 383
 384         REGION_COPY( pScreen, &pParent->borderClip, universe);
 385
 386         /*
 387          * To get the right clipList for the parent, and to make doubly sure
 388          * that no child overlaps the parent's border, we remove the parent's
 389          * border from the universe before proceeding.
 390          */
 391
 392         REGION_INTERSECT( pScreen, universe, universe, &pParent->winSize);
 393     }
 394     else
 395         REGION_COPY( pScreen, &pParent->borderClip, universe);
 396
 397     if ((pChild = pParent->firstChild) && pParent->mapped)
 398     {
 399         REGION_INIT(pScreen, &childUniverse, NullBox, 0);
 400         REGION_INIT(pScreen, &childUnion, NullBox, 0);
 401         if ((pChild->drawable.y < pParent->lastChild->drawable.y) ||
 402             ((pChild->drawable.y == pParent->lastChild->drawable.y) &&
 403              (pChild->drawable.x < pParent->lastChild->drawable.x)))
 404         {
 405             for (; pChild; pChild = pChild->nextSib)
 406             {
 407                 if (pChild->viewable)
 408                     REGION_APPEND( pScreen, &childUnion, &pChild->borderSize);
 409             }
 410         }
 411         else
 412         {
 413             for (pChild = pParent->lastChild; pChild; pChild = pChild->prevSib)
 414             {
 415                 if (pChild->viewable)
 416                     REGION_APPEND( pScreen, &childUnion, &pChild->borderSize);
 417             }
 418         }
 419         REGION_VALIDATE( pScreen, &childUnion, &overlap);
 420
 421         for (pChild = pParent->firstChild;
 422              pChild;
 423              pChild = pChild->nextSib)
 424         {
 425             if (pChild->viewable) {
 426                 /*
 427                  * If the child is viewable, we want to remove its extents
 428                  * from the current universe, but we only re-clip it if
 429                  * it's been marked.
 430                  */
 431                 if (pChild->valdata) {
 432                     /*
 433                      * Figure out the new universe from the child's
 434                      * perspective and recurse.
 435                      */
 436                     REGION_INTERSECT( pScreen, &childUniverse,
 437                                             universe,
 438                                             &pChild->borderSize);
 439                     RootlessComputeClips (pChild, pScreen, &childUniverse,
 440                                           kind, exposed);
 441                 }
 442                 /*
 443                  * Once the child has been processed, we remove its extents
 444                  * from the current universe, thus denying its space to any
 445                  * other sibling.
 446                  */
 447                 if (overlap)
 448                     REGION_SUBTRACT( pScreen, universe, universe,
 449                                           &pChild->borderSize);
 450             }
 451         }
 452         if (!overlap)
 453             REGION_SUBTRACT( pScreen, universe, universe, &childUnion);
 454         REGION_UNINIT( pScreen, &childUnion);
 455         REGION_UNINIT( pScreen, &childUniverse);
 456     } /* if any children */
 457
 458     /*
 459      * 'universe' now contains the new clipList for the parent window.
 460      *
 461      * To figure the exposure of the window we subtract the old clip from the
 462      * new, just as for the border.
 463      */
 464
 465     if (oldVis == VisibilityFullyObscured ||
 466         oldVis == VisibilityNotViewable)
 467     {
 468         REGION_COPY( pScreen, &pParent->valdata->after.exposed, universe);
 469     }
 470     else if (newVis != VisibilityFullyObscured &&
 471              newVis != VisibilityNotViewable)
 472     {
 473         REGION_SUBTRACT( pScreen, &pParent->valdata->after.exposed,
 474                                universe, &pParent->clipList);
 475     }
 476
 477     /*
 478      * One last thing: backing storage. We have to try to save what parts of
 479      * the window are about to be obscured. We can just subtract the universe
 480      * from the old clipList and get the areas that were in the old but aren't
 481      * in the new and, hence, are about to be obscured.
 482      */
 483     if (pParent->backStorage && !resized)
 484     {
 485         REGION_SUBTRACT( pScreen, exposed, &pParent->clipList, universe);
 486         (* pScreen->SaveDoomedAreas)(pParent, exposed, dx, dy);
 487     }
 488
 489     /* HACK ALERT - copying contents of regions, instead of regions */
 490     {
 491         RegionRec   tmp;
 492
 493         tmp = pParent->clipList;
 494         pParent->clipList = *universe;
 495         *universe = tmp;
 496     }
 497
 498 #ifdef NOTDEF
 499     REGION_COPY( pScreen, &pParent->clipList, universe);
 500 #endif
 501
 502     pParent->drawable.serialNumber = NEXT_SERIAL_NUMBER;
 503
 504     if (pScreen->ClipNotify)
 505         (* pScreen->ClipNotify) (pParent, dx, dy);
 506 }
 507
 508 static void
 509 RootlessTreeObscured(pParent)
 510     register WindowPtr pParent;
 511 {
 512     register WindowPtr pChild;
 513     register int    oldVis;
 514
 515     pChild = pParent;
 516     while (1)
 517     {
 518         if (pChild->viewable)
 519         {
 520             oldVis = pChild->visibility;
 521             if (oldVis != (pChild->visibility = VisibilityFullyObscured) &&
 522                 ((pChild->eventMask | wOtherEventMasks(pChild)) & VisibilityChangeMask))
 523                 SendVisibilityNotify(pChild);
 524             if (pChild->firstChild)
 525             {
 526                 pChild = pChild->firstChild;
 527                 continue;
 528             }
 529         }
 530         while (!pChild->nextSib && (pChild != pParent))
 531             pChild = pChild->parent;
 532         if (pChild == pParent)
 533             break;
 534         pChild = pChild->nextSib;
 535     }
 536 }
 537
 538 /*
 539  *-----------------------------------------------------------------------
 540  * RootlessMiValidateTree --
 541  *      Recomputes the clip list for pParent and all its inferiors.
 542  *
 543  * Results:
 544  *      Always returns 1.
 545  *
 546  * Side Effects:
 547  *      The clipList, borderClip, exposed, and borderExposed regions for
 548  *      each marked window are altered.
 549  *
 550  * Notes:
 551  *      This routine assumes that all affected windows have been marked
 552  *      (valdata created) and their winSize and borderSize regions
 553  *      adjusted to correspond to their new positions. The borderClip and
 554  *      clipList regions should not have been touched.
 555  *
 556  *      The top-most level is treated differently from all lower levels
 557  *      because pParent is unchanged. For the top level, we merge the
 558  *      regions taken up by the marked children back into the clipList
 559  *      for pParent, thus forming a region from which the marked children
 560  *      can claim their areas. For lower levels, where the old clipList
 561  *      and borderClip are invalid, we can't do this and have to do the
 562  *      extra operations done in miComputeClips, but this is much faster
 563  *      e.g. when only one child has moved...
 564  *
 565  *-----------------------------------------------------------------------
 566  */
 567 /*
 568    Quartz version: used for validate from root in rootless mode.
 569    We need to make sure top-level windows don't clip each other,
 570    and that top-level windows aren't clipped to the root window.
 571 */
 572 /*ARGSUSED*/
 573 // fixme this is ugly
 574 // Xprint/ValTree.c doesn't work, but maybe that method can?
 575 int
 576 RootlessMiValidateTree (pRoot, pChild, kind)
 577     WindowPtr           pRoot;      /* Parent to validate */
 578     WindowPtr           pChild;     /* First child of pRoot that was
 579                                      * affected */
 580     VTKind              kind;       /* What kind of configuration caused call */
 581 {
 582     RegionRec           childClip;  /* The new borderClip for the current
 583                                      * child */
 584     RegionRec           exposed;    /* For intermediate calculations */
 585     register ScreenPtr  pScreen;
 586     register WindowPtr  pWin;
 587
 588     pScreen = pRoot->drawable.pScreen;
 589     if (pChild == NullWindow)
 590         pChild = pRoot->firstChild;
 591
 592     REGION_INIT(pScreen, &childClip, NullBox, 0);
 593     REGION_INIT(pScreen, &exposed, NullBox, 0);
 594
 595     if (REGION_BROKEN (pScreen, &pRoot->clipList) &&
 596         !REGION_BROKEN (pScreen, &pRoot->borderClip))
 597     {
 598         // fixme this might not work, but hopefully doesn't happen anyway.
 599         kind = VTBroken;
 600         REGION_EMPTY (pScreen, &pRoot->clipList);
 601         ErrorF("ValidateTree: BUSTED!\n");
 602     }
 603
 604     /*
 605      * Recursively compute the clips for all children of the root.
 606      * They don't clip against each other or the root itself, so
 607      * childClip is always reset to that child's size.
 608      */
 609
 610     for (pWin = pChild;
 611          pWin != NullWindow;
 612          pWin = pWin->nextSib)
 613     {
 614         if (pWin->viewable) {
 615             if (pWin->valdata) {
 616                 REGION_COPY( pScreen, &childClip, &pWin->borderSize);
 617                 RootlessComputeClips (pWin, pScreen, &childClip, kind, &exposed);
 618             } else if (pWin->visibility == VisibilityNotViewable) {
 619                 RootlessTreeObscured(pWin);
 620             }
 621         } else {
 622             if (pWin->valdata) {
 623                 REGION_EMPTY( pScreen, &pWin->clipList);
 624                 if (pScreen->ClipNotify)
 625                     (* pScreen->ClipNotify) (pWin, 0, 0);
 626                 REGION_EMPTY( pScreen, &pWin->borderClip);
 627                 pWin->valdata = (ValidatePtr)NULL;
 628             }
 629         }
 630     }
 631
 632     REGION_UNINIT( pScreen, &childClip);
 633
 634     /* The root is never clipped by its children, so nothing on the root
 635        is ever exposed by moving or mapping its children. */
 636     REGION_INIT( pScreen, &pRoot->valdata->after.exposed, NullBox, 0);
 637     REGION_INIT( pScreen, &pRoot->valdata->after.borderExposed, NullBox, 0);
 638
 639     return 1;
 640 }