Return to Menu.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / X / uwm

Annotation of 43BSD/contrib/X/uwm/Menu.c, revision 1.1

1.1     ! root        1: #ifndef lint
        !             2: static char *rcsid_Menu_c = "$Header: Menu.c,v 10.3 86/02/01 16:23:11 tony Rel $";
        !             3: #endif lint
        !             4: 
        !             5: /************************************************************************
        !             6:  *                                                                     *
        !             7:  *                     Copyright (c) 1986 by                           *
        !             8:  *             Digital Equipment Corporation, Maynard, MA              *
        !             9:  *                      All Rights Reserved.                           *
        !            10:  *                                                                     *
        !            11:  *     Permission to use, copy, modify, and distribute this software   *
        !            12:  *     and its documentation is hereby granted only to licensees of    *
        !            13:  *     The Regents of the University of California pursuant to their   *
        !            14:  *     license agreement for the Berkeley Software Distribution        *
        !            15:  *     provided that the following appears on all copies.              *
        !            16:  *                                                                     *
        !            17:  *            "LICENSED FROM DIGITAL EQUIPMENT CORPORATION             *
        !            18:  *                      COPYRIGHT (C) 1986                             *       
        !            19:  *                 DIGITAL EQUIPMENT CORPORATION                       *
        !            20:  *                         MAYNARD, MA                                 *
        !            21:  *                     ALL RIGHTS RESERVED.                            *
        !            22:  *                                                                     *
        !            23:  *      THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT  * 
        !            24:  *     NOTICE AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL   *
        !            25:  *     EQUIPMENT CORPORATION.  DIGITAL MAKES NO REPRESENTATIONS        *
        !            26:  *     ABOUT SUITABILITY OF THIS SOFTWARE FOR ANY PURPOSE. IT IS       *
        !            27:  *     SUPPLIED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY.           *
        !            28:  *                                                                     *       
        !            29:  *     IF THE UNIVERSITY OF CALIFORNIA OR ITS LICENSEES MODIFY         *       
        !            30:  *     THE SOFTWARE IN A MANNER CREATING DERIVATIVE COPYRIGHT          *       
        !            31:  *     RIGHTS APPROPRIATE COPYRIGHT LEGENDS MAY BE PLACED ON THE       *
        !            32:  *     DERIVATIVE WORK IN ADDITION TO THAT SET FORTH ABOVE."           *       
        !            33:  *                                                                     *
        !            34:  ************************************************************************/
        !            35:  
        !            36: 
        !            37: /*
        !            38:  * MODIFICATION HISTORY
        !            39:  *
        !            40:  * 000 -- M. Gancarz, DEC Ultrix Engineering Group
        !            41:  */
        !            42: 
        !            43: #ifndef lint
        !            44: static char *sccsid = "@(#)Menu.c      3.8     1/24/86";
        !            45: #endif
        !            46: 
        !            47: #include "uwm.h"
        !            48: 
        !            49: #define DisplayLine(w, pane, width, height, str, fg, bg) \
        !            50:          XPixSet(w, 0, pane, width, height, bg); \
        !            51:          XTextMask(w, HMenuPad, pane + VMenuPad, str, strlen(str), MFont, fg);
        !            52: 
        !            53: #define NVERTS 5                       /* Number of vertices for hi-liter. */
        !            54: 
        !            55: static Vertex vlist[NVERTS];           /* Vertex list for hi-liter. */
        !            56: 
        !            57: Bool Menu(window, mask, button, x, y, menu)
        !            58: Window window;                         /* Event window. */
        !            59: int mask;                              /* Button/key mask. */
        !            60: short button;                          /* Button event detail. */
        !            61: int x, y;                              /* Event mouse position. */
        !            62: MenuInfo *menu;
        !            63: {
        !            64:     XButtonEvent button_event;         /* Button event packet. */
        !            65:     Bool func_stat;                    /* Function status return. */
        !            66:     int cur_x, cur_y;                  /* Current mouse position. */
        !            67:     Window sub_window;                 /* Current subwindow. */
        !            68:     int cur_item = 0;                  /* Current menu item. */
        !            69:     int hi_lite = 0;                   /* Current highlighted item. */
        !            70:     int i;                             /* Iteration counter. */
        !            71:     short hlfg, hlbg;                  /* Hi-liter pixels. */
        !            72:     MenuLine *ml;                      /* Menu lines pointer. */
        !            73:     char *hlname;                      /* Pointer to hi-liter name. */
        !            74:     char *strbuf;                      /* String buffer for IsTextNL. */
        !            75:     char *malloc();
        !            76: 
        !            77:     /*
        !            78:      * Change the cursor.
        !            79:      */
        !            80:     status = XGrabButton(RootWindow, MenuCursor, mask, EVENTMASK);
        !            81:     if (status == FAILURE)
        !            82:         Error("Menu -> Unable to grab button and change cursor.");
        !            83: 
        !            84:     /*
        !            85:      * Map the menu.
        !            86:      */
        !            87:     MapMenu(menu, x, y);
        !            88: 
        !            89:     /*
        !            90:      * Main loop.
        !            91:      */
        !            92:     while (TRUE) {
        !            93: 
        !            94:         /*
        !            95:          * If no button event, check the current mouse position.
        !            96:          */
        !            97:         status = XUpdateMouse(menu->w, &cur_x, &cur_y, &sub_window);
        !            98:         if (status == FAILURE) continue;
        !            99: 
        !           100:         /*
        !           101:          * If the mouse has moved out of the menu sideways, abort
        !           102:          * the menu operation. Reset the cursor and unmap the menu.
        !           103:          */
        !           104:         if (cur_x < 0 || cur_x > menu->width) {
        !           105:             UnmapMenu(menu, mask);
        !           106:             return(FALSE);
        !           107:         }
        !           108: 
        !           109:         /*
        !           110:          * If the mouse has moved below or above the menu, but is still
        !           111:          * within the same vertical plane, then simply adjust the values
        !           112:          * so the user doesn't fall off the edge.
        !           113:          */
        !           114:         if (cur_y >= menu->height) cur_y = menu->height - 1;
        !           115:         else if (cur_y < 0) cur_y = 0;
        !           116: 
        !           117:         /*
        !           118:          * If the mouse has moved to another item in the menu,
        !           119:          * highlight the new item.
        !           120:          */
        !           121:         cur_item = cur_y / menu->iheight;
        !           122:         if (cur_item != hi_lite) {
        !           123: 
        !           124:             /*
        !           125:              * Remove highlighting on old item.
        !           126:              */
        !           127:             if (hi_lite) {
        !           128:                 DisplayLine(menu->w, hi_lite * menu->iheight,
        !           129:                             menu->width, menu->iheight, hlname,
        !           130:                             hlfg, hlbg);
        !           131:             }
        !           132: 
        !           133:             /*
        !           134:              * Highlight new item.
        !           135:              */
        !           136:             if (cur_item) {
        !           137:                 for(i = 1, ml = menu->line; ml; i++, ml = ml->next) {
        !           138:                     if (i == cur_item) break;
        !           139:                 }
        !           140:                 DisplayLine(menu->w, cur_item * menu->iheight,
        !           141:                             menu->width, menu->iheight, ml->name,
        !           142:                             menu->hlfg.pixel, menu->hlbg.pixel);
        !           143:                 vlist[0].y = cur_item * menu->iheight + 1;
        !           144:                 XDraw(menu->w, vlist, NVERTS, 1, 1,
        !           145:                       menu->hlfg.pixel, GXcopy, AllPlanes);
        !           146:             }
        !           147:             hi_lite = cur_item;
        !           148:             hlfg = ml->fg.pixel;
        !           149:             hlbg = ml->bg.pixel;
        !           150:             hlname = ml->name;
        !           151:         }
        !           152: 
        !           153:         /*
        !           154:          * Check to see if we have a change in the mouse buttons.
        !           155:          * This means the user has selected an item or aborted the
        !           156:          * operation.
        !           157:          */
        !           158:         if (XPending() && GetButton(&button_event)) {
        !           159: 
        !           160:             /*
        !           161:              * Was button released?
        !           162:              */
        !           163:             if ((button_event.type == ButtonReleased) &&
        !           164:                 ((button_event.detail & ValueMask) == button)) {
        !           165:                 break;
        !           166:             } else {
        !           167: 
        !           168:                 /*
        !           169:                  * Some other button event occurred, so abort the menu
        !           170:                  * operation.
        !           171:                  */
        !           172:                 UnmapMenu(menu, mask);
        !           173:                 return(TRUE);
        !           174:             }
        !           175:         }
        !           176:     }
        !           177: 
        !           178:     /*
        !           179:      * If no item was selected, simply close the menu and return.
        !           180:      */
        !           181:     if (!cur_item) {
        !           182:         UnmapMenu(menu, mask);
        !           183:         return(TRUE);
        !           184:     }
        !           185: 
        !           186:     /*
        !           187:      * Get a pointer to the menu line selected.
        !           188:      */
        !           189:     --cur_item;
        !           190:     for(i = 0, ml = menu->line; ml; i++, ml = ml->next) {
        !           191:         if (i == cur_item) break;
        !           192:     }
        !           193: 
        !           194:     /*
        !           195:      * Perform the selected menu line action.
        !           196:      */
        !           197:     switch (ml->type) {
        !           198: 
        !           199:         case IsShellCommand:
        !           200:             UnmapMenu(menu, mask);
        !           201:             system(ml->text);
        !           202:             break;
        !           203: 
        !           204:         case IsText:
        !           205:             UnmapMenu(menu, mask);
        !           206:             XStoreBytes(ml->text, strlen(ml->text));
        !           207:             break;
        !           208: 
        !           209:         case IsTextNL:
        !           210:             UnmapMenu(menu, mask);
        !           211:             strbuf = (char *)malloc(strlen(ml->text) + 2);
        !           212:             strcpy(strbuf, ml->text);
        !           213:             strcat(strbuf, "\n");
        !           214:             XStoreBytes(strbuf, strlen(strbuf));
        !           215:             free(strbuf);
        !           216:             break;
        !           217: 
        !           218:         case IsUwmFunction:
        !           219:             GetContext(&sub_window, &cur_x, &cur_y);
        !           220:             UnmapMenu(menu, mask);
        !           221:             if (sub_window != menu->w)
        !           222:                 (*ml->func) (sub_window, mask, button, cur_x, cur_y);
        !           223:             break;
        !           224: 
        !           225:         case IsImmFunction:
        !           226:             UnmapMenu(menu, mask);
        !           227:             (*ml->func) (sub_window, mask, button, cur_x, cur_y);
        !           228:             break;
        !           229: 
        !           230:         case IsMenuFunction:
        !           231:             while (TRUE) {
        !           232:                 if (!GetButton(&button_event)) continue;
        !           233:                 if (button_event.type != ButtonPressed) continue;
        !           234:                 if ((KeyMask(button_event.detail) != KeyMask(mask)) ||
        !           235:                     ((button_event.detail & ButtonMods) != button)) {
        !           236:                     UnmapMenu(menu, mask);
        !           237:                     return(TRUE);
        !           238:                 }
        !           239:                 break;
        !           240:             }
        !           241:             UnmapMenu(menu, mask);
        !           242:             func_stat = Menu(menu->w, mask, button, x, y, ml->menu);
        !           243:             return(func_stat);
        !           244:             break;
        !           245: 
        !           246:         default:
        !           247:             Error("Menu -> Internal type error.");
        !           248:     }
        !           249:     return(TRUE);
        !           250: }
        !           251: 
        !           252: /*
        !           253:  * Create the menu windows for later use.
        !           254:  */
        !           255: CreateMenus()
        !           256: {
        !           257:     MenuLink *ptr;
        !           258: 
        !           259:     /*
        !           260:      * If MaxColors isn't set, then jam it to an impossibly high
        !           261:      * number.
        !           262:      */
        !           263:     if (MaxColors == 0)
        !           264:         MaxColors = 25000;
        !           265: 
        !           266:     for(ptr = Menus; ptr; ptr = ptr->next)
        !           267:         InitMenu(ptr->menu);
        !           268: }
        !           269: 
        !           270: /*
        !           271:  * Initialize a menu.
        !           272:  */
        !           273: InitMenu(menu)
        !           274: MenuInfo *menu;
        !           275: {
        !           276:     MenuLine *ml;              /* Menu lines pointer. */
        !           277:     int width;                 /* Width of an item name. */
        !           278:     int maxwidth;              /* Maximum width of item names. */
        !           279:     int len;                   /* Length of an item name. */
        !           280:     int count = 1;             /* Number of items + 1 for name. */
        !           281: 
        !           282:     /*
        !           283:      * Determine the name of the longest menu item.
        !           284:      */
        !           285:     maxwidth = XQueryWidth(menu->name, MFont);
        !           286:     if (maxwidth == 0)
        !           287:         Error("InitMenu -> Couldn't get length of menu name");
        !           288: 
        !           289:     for(ml = menu->line; ml; ml = ml->next) {
        !           290:         if ((len = strlen(ml->name)) == 0)
        !           291:             break;
        !           292:         width = XQueryWidth(ml->name, MFont);
        !           293:         if (width == 0) Error("InitMenu -> Couldn't get length of menu item name");
        !           294:         if (width > maxwidth) maxwidth = width;
        !           295:         count++;
        !           296:     }
        !           297: 
        !           298:     /*
        !           299:      * Get the color cells for the menu items.
        !           300:      */
        !           301:     GetMenuColors(menu);
        !           302: 
        !           303:     /*
        !           304:      * Stash the menu parameters in the menu info structure.
        !           305:      */
        !           306:     menu->iheight = MFontInfo.height + (VMenuPad << 1);
        !           307:     menu->height = menu->iheight * count;
        !           308:     menu->width = maxwidth + (HMenuPad << 1);
        !           309:     menu->image = NULL;
        !           310: 
        !           311:     /*
        !           312:      * Create the menu window.
        !           313:      */
        !           314:     menu->w = XCreateWindow(RootWindow,
        !           315:                             0, 0,
        !           316:                             menu->width,
        !           317:                             menu->height,
        !           318:                             MBorderWidth,
        !           319:                             MBorder, MBackground);
        !           320:     if (menu->w == NULL) Error("InitMenu -> Couldn't create menu window");
        !           321: 
        !           322:     /*
        !           323:      * Store the window name.
        !           324:      */
        !           325:     XStoreName(menu->w, menu->name);
        !           326: 
        !           327:     /*
        !           328:      * Define a cursor for the window.
        !           329:      */
        !           330:     XDefineCursor(menu->w, MenuCursor);
        !           331: }
        !           332: 
        !           333: /*
        !           334:  * Map a menu.
        !           335:  */
        !           336: MapMenu(menu, x, y)
        !           337: MenuInfo *menu;
        !           338: int x, y;
        !           339: {
        !           340:     int item;
        !           341:     Window w;
        !           342:     MenuLine *ml;
        !           343: 
        !           344:     w = menu->w;
        !           345: 
        !           346:     /*
        !           347:      * Move the menu into place, normalizing the coordinates, if necessary;
        !           348:      * then map it.
        !           349:      */
        !           350:     x -= (menu->width >> 1);
        !           351:     if (x < 0) x = 0;
        !           352:     else if (x + menu->width >= ScreenWidth)
        !           353:         x = ScreenWidth - menu->width - (MBorderWidth << 1);
        !           354:     if (y < 0) y = 0;
        !           355:     else if (y + menu->height >= ScreenHeight)
        !           356:         y = ScreenHeight - menu->height - (MBorderWidth << 1);
        !           357:     XMoveWindow(w, x, y);
        !           358: 
        !           359:     /*
        !           360:      * Map the window and draw the text items.
        !           361:      */
        !           362:     XMapWindow(w);
        !           363:     DisplayLine(w, 0, menu->width, menu->iheight, menu->name,
        !           364:                 menu->bg.pixel, menu->fg.pixel);
        !           365: 
        !           366:     SetUpVlist(menu);
        !           367:     vlist[0].x = 1;
        !           368:     vlist[0].y = 1;
        !           369:     XDraw(menu->w, vlist, NVERTS, 1, 1, menu->bg.pixel, GXcopy, AllPlanes);
        !           370:     item = menu->iheight;
        !           371:     for(ml = menu->line; ml; ml = ml->next) {
        !           372:         DisplayLine(w, item, menu->width, menu->iheight, ml->name,
        !           373:                     ml->fg.pixel, ml->bg.pixel);
        !           374:         item += menu->iheight;
        !           375:     }
        !           376: 
        !           377:     /*
        !           378:      * Position the mouse cursor in the menu header (or in the first item
        !           379:      * if "autoselect" is set).
        !           380:      */
        !           381:     if (Autoselect)
        !           382:         XWarpMouse(w, (menu->width >> 2) * 3, (menu->iheight >> 1) * 3);
        !           383:     else XWarpMouse(w, (menu->width >> 2) * 3, menu->iheight >> 1);
        !           384: 
        !           385:     XFlush();
        !           386: }
        !           387: 
        !           388: /*
        !           389:  * Unmap a menu, restoring the contents of the screen underneath
        !           390:  * if necessary. (Restore portion is a future.)
        !           391:  */
        !           392: UnmapMenu(menu, mask)
        !           393: MenuInfo *menu;
        !           394: int mask;
        !           395: {
        !           396:     /*
        !           397:      * Restore the main cursor.
        !           398:      */
        !           399:     Grab((short)mask);
        !           400: 
        !           401:     /*
        !           402:      * Unmap and flush.
        !           403:      */
        !           404:     XUnmapWindow(menu->w);
        !           405:     XFlush();
        !           406: }
        !           407: 
        !           408: /*
        !           409:  * Get the context for invoking a window manager function.
        !           410:  */
        !           411: GetContext(w, x, y)
        !           412: Window *w;
        !           413: int *x, *y;
        !           414: {
        !           415:     XButtonEvent button_event;  /* Button input event. */
        !           416: 
        !           417:     while (TRUE) {
        !           418: 
        !           419:         /*
        !           420:          * Get the next mouse button event.  Spin our wheels until
        !           421:          * a button event is returned (ie. GetButton == TRUE).
        !           422:          * Note that mouse events within an icon window are handled
        !           423:          * in the "GetButton" function or by the icon's owner if
        !           424:          * it is not uwm.
        !           425:          */
        !           426:         if (!GetButton(&button_event)) continue;
        !           427: 
        !           428:         /*
        !           429:          * If the button event received is not a ButtonPressed event
        !           430:          * then continue until we find one.
        !           431:          */
        !           432:         if (button_event.type != ButtonPressed) continue;
        !           433: 
        !           434:         /*
        !           435:          * Okay, determine the event window and mouse coordinates.
        !           436:          */
        !           437:         status = XInterpretLocator(RootWindow,
        !           438:                                     x, y,
        !           439:                                     w,
        !           440:                                     button_event.location);
        !           441: 
        !           442:         if (status == FAILURE) continue;
        !           443: 
        !           444:         if (*w == 0)
        !           445:             *w = RootWindow;
        !           446: 
        !           447:         return;
        !           448:     }
        !           449: }
        !           450: 
        !           451: /*
        !           452:  * Get the color cells for a menu.  This function is slightly brain-damaged
        !           453:  * in that once MaxColors <= 1, then it refuses to even try to allocate any
        !           454:  * more colors, even though the colors may have already been allocated.  It
        !           455:  * probably ought to be done right someday.
        !           456:  */
        !           457: GetMenuColors(menu)
        !           458: MenuInfo *menu;
        !           459: {
        !           460:     register MenuLine *ml;             /* Menu lines pointer. */
        !           461: 
        !           462:     /*
        !           463:      * If we have more than 2 colors available, then attempt to get
        !           464:      * the color map entries requested by the user.
        !           465:      * Otherwise, default to standard black and white.
        !           466:      */
        !           467:     if (DisplayCells() > 2) {
        !           468: 
        !           469:         /*
        !           470:          * Get the menu header colors first.
        !           471:          */
        !           472:         if (!(menu->foreground && menu->background && MaxColors > 1 &&
        !           473:               XParseColor(menu->foreground, &menu->fg) &&
        !           474:               XGetHardwareColor(&menu->fg) &&
        !           475:               XParseColor(menu->background, &menu->bg) &&
        !           476:               XGetHardwareColor(&menu->bg))) {
        !           477:             menu->fg.pixel = MTextForground;
        !           478:             menu->bg.pixel = MTextBackground;
        !           479:         } else {
        !           480:             AdjustMaxColors(menu->fg.pixel);
        !           481:             AdjustMaxColors(menu->bg.pixel);
        !           482:         }
        !           483: 
        !           484:         /*
        !           485:          * Get the menu highlight colors.
        !           486:          */
        !           487:         if (!(menu->fghighlight && menu->bghighlight && MaxColors > 1 &&
        !           488:               XParseColor(menu->fghighlight, &menu->hlfg) &&
        !           489:               XGetHardwareColor(&menu->hlfg) &&
        !           490:               XParseColor(menu->bghighlight, &menu->hlbg) &&
        !           491:               XGetHardwareColor(&menu->hlbg))) {
        !           492:             menu->hlfg.pixel = MTextBackground;
        !           493:             menu->hlbg.pixel = MTextForground;
        !           494:         } else {
        !           495:             AdjustMaxColors(menu->hlfg.pixel);
        !           496:             AdjustMaxColors(menu->hlbg.pixel);
        !           497:         }
        !           498: 
        !           499:         /*
        !           500:          * Get the menu item colors.
        !           501:          */
        !           502:         for(ml = menu->line; ml; ml = ml->next) {
        !           503:             if (!(ml->foreground && ml->background && MaxColors > 1 &&
        !           504:                   XParseColor(ml->foreground, &ml->fg) &&
        !           505:                   XGetHardwareColor(&ml->fg) &&
        !           506:                   XParseColor(ml->background, &ml->bg) &&
        !           507:                   XGetHardwareColor(&ml->bg))) {
        !           508:                 ml->fg.pixel = MTextForground;
        !           509:                 ml->bg.pixel = MTextBackground;
        !           510:             } else {
        !           511:                 AdjustMaxColors(ml->fg.pixel);
        !           512:                 AdjustMaxColors(ml->bg.pixel);
        !           513:             }
        !           514:         }
        !           515: 
        !           516:     } else {
        !           517: 
        !           518:         /*
        !           519:          * Only 2 colors available, so default to standard black and white.
        !           520:          */
        !           521:         menu->fg.pixel = MTextForground;
        !           522:         menu->bg.pixel = MTextBackground;
        !           523:         menu->hlfg.pixel = MTextBackground;
        !           524:         menu->hlbg.pixel = MTextForground;
        !           525:         for(ml = menu->line; ml; ml = ml->next) {
        !           526:             ml->fg.pixel = MTextForground;
        !           527:             ml->bg.pixel = MTextBackground;
        !           528:         }
        !           529:     }
        !           530: }
        !           531: 
        !           532: /*
        !           533:  * Decrement "MaxColors" if this pixel value has never been used in a
        !           534:  * menu before.
        !           535:  */
        !           536: AdjustMaxColors(pixel)
        !           537: int pixel;
        !           538: {
        !           539:     register MenuLink *mptr;
        !           540:     register MenuLine *lptr;
        !           541:     int count = 0;
        !           542: 
        !           543:     for(mptr = Menus; mptr; mptr = mptr->next) {
        !           544:         if (mptr->menu->fg.pixel == pixel) ++count;
        !           545:         if (mptr->menu->bg.pixel == pixel) ++count;
        !           546:         if (mptr->menu->hlfg.pixel == pixel) ++count;
        !           547:         if (mptr->menu->hlbg.pixel == pixel) ++count;
        !           548:         for(lptr = mptr->menu->line; lptr; lptr = lptr->next) {
        !           549:             if (lptr->fg.pixel == pixel) ++count;
        !           550:             if (lptr->bg.pixel == pixel) ++count;
        !           551:         }
        !           552:         if (count > 1) return;
        !           553:     }
        !           554:     --MaxColors;
        !           555: }
        !           556: 
        !           557: /*
        !           558:  * Set up the vertex list for the hi-liter.
        !           559:  */
        !           560: SetUpVlist(menu)
        !           561: MenuInfo *menu;
        !           562: {
        !           563:     vlist[1].x = menu->width - 3;
        !           564:     vlist[1].y = 0;
        !           565:     vlist[2].x = 0;
        !           566:     vlist[2].y = menu->iheight - 3;
        !           567:     vlist[3].x = (short)(0 - menu->width + 3);
        !           568:     vlist[3].y = 0;
        !           569:     vlist[4].x = 0;
        !           570:     vlist[4].y = (short)(0 - menu->iheight + 3);
        !           571:     vlist[1].flags = vlist[2].flags = vlist[3].flags =
        !           572:     vlist[4].flags = VertexRelative;
        !           573: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.