<<>>
    <<CursorsImpl.mesa >>
        <<Copyright Ó 1985, 1986, 1987, 1988, 1990, 1991, 1992 by Xerox Corporation.  All rights reserved.>>
        <<Russ Atkinson (RRA) May 6, 1986 10:51:40 pm PDT>>
        <<Doug Wyatt, January 4, 1990 2:37:27 pm PST>>
        <<Pier, August 20, 1992 12:02 pm PDT>>
        <<Bier, August 5, 1992 12:30 pm PDT>>
        <<Willie-s, August 29, 1991 6:07 pm PDT>>
        <<Michael Plass, February 25, 1992 1:45 pm PST>>
        <<Christian Jacobi, March 3, 1992 2:41 pm PST>>

    DIRECTORY
    Atom, Basics, Basics16, Commander, CommanderOps, Cursors, CursorTypes, Imager, ImagerColor, ImagerSample, IO, MultiCursors, 
    MultiCursorsExtras, Process, PseudoCursors, RefTab, Rope, ViewerClasses, ViewerOps, ViewerPrivate, ViewersWorld, 
    ViewersWorldClasses, ViewersWorldInstance, ViewersWorldRefType, ViewersWorldTypes;

    CursorsImpl: CEDAR MONITOR
        IMPORTS Atom, Commander, CommanderOps, Imager, ImagerColor, ImagerSample, IO, Basics, Basics16, Process, RefTab, Rope, ViewerOps, 
        ViewersWorldInstance
        EXPORTS Cursors, MultiCursors, MultiCursorsExtras, PseudoCursors, ViewerPrivate, ViewersWorldRefType
        = BEGIN 

    <<Global Variables And Types>>

        CursorType: TYPE ~ MultiCursors.CursorType;
        ClientCursor: TYPE ~ MultiCursors.ClientCursor;
        CornerSide: TYPE ~ MultiCursors.CornerSide;
        CursorInfo: TYPE ~ MultiCursors.CursorInfo;
        CursorArray: TYPE = CursorTypes.CursorArray;
        CursorArrayRef: TYPE = CursorTypes.CursorArrayRef;
        Cursor32Array: TYPE = CursorTypes.Cursor32Array;
        Cursor32ArrayRef: TYPE = CursorTypes.Cursor32ArrayRef;
        ClientCursorArray: TYPE = ARRAY ClientCursor OF CursorHandle;
        CursorTypeArray: TYPE = ARRAY CursorType OF CursorHandle;
        CursorHandle: TYPE ~ REF CursorRec; -- use these for user-defined cursors

        CursorRec: TYPE ~ RECORD [
            info: CursorInfo,
            bits: CursorArray
            ];

        BigClientCursorArray: TYPE = ARRAY ClientCursor OF BigCursorHandle;
        BigCursorTypeArray: TYPE = ARRAY CursorType OF BigCursorHandle;
        BigCursorHandle: TYPE = REF BigCursorRec;
        BigCursorRec: TYPE = RECORD [
            info: CursorInfo,
            bits: Cursor32ArrayRef
            ];
        VWorld: TYPE = ViewersWorld.Ref;
        ViewersWorldObj: PUBLIC TYPE = ViewersWorldTypes.ViewersWorldObj;
        X: BOOL = TRUE;
        O: BOOL = FALSE;

        PackedCursor: TYPE = PACKED ARRAY [0..16*16) OF BOOL;
        <<KAP for PCedar November 18, 1988>>
        Halfword: TYPE = CARD16;
        NotYetImplemented: SIGNAL = CODE;

        global: Global; -- initialization moved to InitSmallCursors.  KAP. August 20, 1992.
        Global: TYPE = REF GlobalData;
        GlobalData: TYPE = RECORD [
            info: CursorInfo Ź [last, 0, 0, FALSE],
            bits: CursorArray Ź ALL[CARD16.LAST],
            clientCursors: REF CursorTypeArray Ź NEW[CursorTypeArray Ź ALL[NIL]],
            bigClientCursors: REF BigCursorTypeArray Ź NEW[BigCursorTypeArray Ź ALL[NIL]],
            isABigCursor: ARRAY CursorType OF BOOL Ź ALL[FALSE],
            lastUsedCursor: CursorType Ź $none,
                <<DKW: formerly LAST[PredefinedCursor], but PredefinedCursor is now wrong since $none was added after $textPointer >>
            initialHourglass: PackedCursor Ź [
                X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X,
                X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X,
                O, X, X, X, X, X, X, X, X, X, X, X, X, X, X, O,
                O, O, X, X, X, X, X, X, X, X, X, X, X, X, O, O,
                O, O, O, X, X, X, X, X, X, X, X, X, X, O, O, O,
                O, O, O, O, X, X, X, X, X, X, X, X, O, O, O, O,
                O, O, O, O, O, X, X, X, X, X, X, O, O, O, O, O,
                O, O, O, O, O, O, X, X, X, X, O, O, O, O, O, O,
                O, O, O, O, O, O, X, O, O, X, O, O, O, O, O, O,
                O, O, O, O, O, X, O, O, O, O, X, O, O, O, O, O,
                O, O, O, O, X, O, O, O, O, O, O, X, O, O, O, O,
                O, O, O, X, O, O, O, O, O, O, O, O, X, O, O, O,
                O, O, X, O, O, O, O, O, O, O, O, O, O, X, O, O,
                O, X, O, O, O, O, O, O, O, O, O, O, O, O, X, O,
                X, O, O, O, O, O, O, O, O, O, O, O, O, O, O, X,
                X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X
                ],
            invertSand: BOOL Ź TRUE,
            sand: BOOL Ź TRUE,
            sandArray: ARRAY [1..15) OF CARDINAL Ź ALL[0],
            sandUsed, tick, totalTicks, savedTicks: CARDINAL Ź 0,
            theHG: PackedCursor Ź ALL[FALSE],
            waitTime: Process.Ticks Ź Process.MsecToTicks[100]
            ];
        patternToAtom: ARRAY CursorType OF ATOM;

    <<High-Level Cursor Routines (for old single-cursor and new multi-cursor worlds)>>

    SetACursorColor: PUBLIC PROC [color: Imager.Color, cursor: ATOM, vWorld: VWorld Ź NIL] = {
        <<red, green, and blue should be between 0 and 255.  "cursor" describes which cursor to recolor.  The values of red, green, and 
        blue should not be gamma-corrected.>>
        IF vWorld = NIL THEN vWorld Ź ViewersWorldInstance.GetWorld[];
        vWorld.class.setCursorColor[vWorld.screenServerData, color, cursor];
        };

    GetACursorColor: PUBLIC PROC [cursor: ATOM, vWorld: VWorld Ź NIL] RETURNS [color: Imager.Color] = {
        IF vWorld = NIL THEN vWorld Ź ViewersWorldInstance.GetWorld[];
        color Ź vWorld.class.getCursorColor[vWorld.screenServerData, cursor];
        };

    <<InvertCursor: PUBLIC ENTRY PROC = {>>
        <<vWorld: ViewersWorld.Ref _ ViewersWorldInstance.GetWorld[];>>
        <<global.bits _ GetCursorPatternOnly[];>>
        <<FOR n: CARDINAL IN [0..16) DO>>
            <<global.bits[n] _ Basics16.BITNOT[global.bits[n]];>>
            <<ENDLOOP;>>
        <<SetCursorPatternOnly[global.bits];>>
        <<global.info.inverted _ ~ global.info.inverted; -- only makes sense in a one-cursor system>>
        <<};>>
        <<>>
    InvertCursor: PUBLIC ENTRY PROC = {
        InvertACursor[NIL];
        };

    InvertACursor: PUBLIC PROC [cursor: ATOM, vWorld: VWorld Ź NIL] = {
        pattern: CursorArray;
        bigPattern: Cursor32ArrayRef;
        isBig: BOOL Ź FALSE;
        IF vWorld = NIL THEN vWorld Ź ViewersWorldInstance.GetWorld[];
        IF HasBigPattern[cursor, vWorld] THEN {
            bigPattern Ź GetABigCursorPatternOnly[cursor, vWorld];
            FOR n: CARDINAL IN [0..32) DO
                bigPattern[n] Ź Basics.BITNOT[bigPattern[n]];
                ENDLOOP;
            SetABigCursorPatternOnly[bigPattern, cursor, vWorld];
            }
        ELSE {
            pattern Ź GetACursorPatternOnly[cursor, vWorld];
            FOR n: CARDINAL IN [0..16) DO
                pattern[n] Ź Basics16.BITNOT[pattern[n]];
                ENDLOOP;
            SetACursorPatternOnly[pattern, cursor, vWorld];
            };
        };

    SetCursor: PUBLIC PROC [type: CursorType] = {
        SetACursor[type, NIL];
        };

    <<SetACursor: PUBLIC ENTRY PROC [type: CursorType, cursor: ATOM, vWorld: VWorld Ź NIL] = TRUSTED {
        IF global.isABigCursor[type] THEN {
            global.info Ź global.bigClientCursors[type].info;
            <<global.bits _ global.bigClientCursors[type].bits;>>
            IF vWorld = NIL THEN vWorld Ź ViewersWorldInstance.GetWorld[];
            vWorld.class.setBigCursorPattern[vWorld.screenServerData, global.info.hotX, global.info.hotY, global.bigClientCursors[type].bits, 
            patternToAtom[type], cursor];
            }
        ELSE {
            SELECT type FROM
                <<global.info.type => RETURN;>>
                bullseye => {
                    global.info Ź [bullseye, -7,-7, FALSE];
                    global.bits Ź [
                        003700B, 007740B, 014060B, 030030B,
                        060014B, 140006B, 141606B, 141606B,
                        141606B, 140006B, 060014B, 030030B,
                        014060B, 007740B, 003700B, 000000B]; 
                    };
                hourGlass => {
                    global.info Ź [hourGlass, -7,-7, FALSE];
                    global.bits Ź [
                        177777B, 100001B, 040002B, 034034B,
                        017170B, 007560B, 003740B, 001700B,
                        001100B, 002440B, 004220B, 010610B,
                        021704B, 047762B, 177777B, 177777B];
                    };
                menu => {
                    global.info Ź [menu, 0,-7, FALSE];
                    global.bits Ź [
                        000000B, 000000B, 000000B, 001000B,
                        003001B, 007003B, 036007B, 177776B,
                        177776B, 036007B, 007003B, 003001B,
                        001000B, 000000B, 000000B, 000000B];
                    };
                scrollUpDown => {
                    global.info Ź [scrollUpDown, -7,-7, FALSE];
                    global.bits Ź [
                        000400B, 001600B, 003700B, 007740B,
                        017760B, 001600B, 001600B, 001600B,
                        001600B, 001600B, 001600B, 017760B,
                        007740B, 003700B, 001600B, 000400B];
                    };
                textPointer => {
                    global.info Ź [textPointer, 0,0, FALSE];
                    global.bits Ź [
                        100000B, 140000B, 160000B, 170000B,
                        174000B, 176000B, 177000B, 170000B,
                        154000B, 114000B, 006000B, 006000B,
                        003000B, 003000B, 001400B, 001400B];
                    };
                activate => {
                    global.info Ź [activate, -7,-7, FALSE];
                    global.bits Ź [
                        177777B, 177777B, 140003B, 140003B,
                        140003B, 140003B, 140003B, 140003B,
                        140003B, 140003B, 140003B, 140003B,
                        140003B, 140003B, 177777B, 177777B];
                    };
                blank => {
                    global.info Ź [blank, 0,0, FALSE];
                    global.bits Ź [
                        000000B, 000000B, 000000B, 000000B,
                        000000B, 000000B, 000000B, 000000B,
                        000000B, 000000B, 000000B, 000000B,
                        000000B, 000000B, 000000B, 000000B];
                    };
                confirm => {
                    global.info Ź [confirm, 0,0, FALSE];
                    global.bits Ź [
                        000000B, 000000B, 167227B, 105324B,
                        105326B, 105264B, 167224B, 000000B,
                        000000B, 073642B, 022266B, 023652B,
                        022442B, 072242B, 000000B, 000000B];
                    };
                crossHairsCircle => {
                    global.info Ź [crossHairsCircle, -7,-7, FALSE];
                    global.bits Ź [
                        001700B, 007760B, 014630B, 030614B,
                        060606B, 040602B, 140603B, 177177B,
                        177177B, 140603B, 040602B, 060606B,
                        030614B, 014630B, 007760B, 001700B];
                    };
                ftp => {
                    global.info Ź [ftp, -7,-7, FALSE];
                    global.bits Ź [
                        000177B, 076077B, 040037B, 040017B,
                        070007B, 043703B, 040401B, 040400B,
                        000400B, 100436B, 140421B, 160421B,
                        170036B, 174020B, 176020B, 177020B];
                    };
                typeKey => {
                    global.info Ź [typeKey, -7,-7, FALSE];
                    global.bits Ź [
                        002000B, 074000B, 140000B, 012767B,
                        012525B, 053566B, 111113B, 163100B,
                        000000B, 000000B, 154000B, 053520B,
                        062520B, 053360B, 155440B, 000140B];
                    };
                move => {
                    global.info Ź [move, -7,-7, FALSE];
                    global.bits Ź [
                        000000B, 000000B, 000000B, 014030B,
                        016070B, 017170B, 017770B, 015730B,
                        014630B, 014030B, 014030B, 014030B,
                        014030B, 000000B, 000000B, 000000B];
                    };
                mouseBlue => {
                    global.info Ź [mouseBlue, -2,0, FALSE];
                    global.bits Ź [
                        037770B, 020010B, 025350B, 025350B,
                        025350B, 025350B, 025350B, 020010B,
                        020010B, 020010B, 020010B, 020010B,
                        020010B, 020010B, 020010B, 037770B];
                    };
                mouseRed => {
                    global.info Ź [mouseRed, -2,0, FALSE];
                    global.bits Ź [
                        037770B, 020010B, 027250B, 027250B,
                        027250B, 027250B, 027250B, 020010B,
                        020010B, 020010B, 020010B, 020010B,
                        020010B, 020010B, 020010B, 037770B];
                    };
                mouseYellow => {
                    global.info Ź [mouseYellow, -2,0, FALSE];
                    global.bits Ź [
                        037770B, 020010B, 025650B, 025650B,
                        025650B, 025650B, 025650B, 020010B,
                        020010B, 020010B, 020010B, 020010B,
                        020010B, 020010B, 020010B, 037770B];
                    };
                grow => {
                    global.info Ź [grow, 0,0, FALSE];
                    global.bits Ź [
                        000000B, 000000B, 000000B, 003740B,
                        007760B, 006060B, 014000B, 014370B,
                        014370B, 014030B, 006060B, 007760B,
                        003740B, 000000B, 000000B, 000000B];
                    };
                pointDown => {
                    global.info Ź [pointDown, -7,-15, FALSE];
                    global.bits Ź [
                        001700B, 001700B, 001700B, 001700B,
                        001700B, 001700B, 001700B, 001700B,
                        001700B, 001700B, 037774B, 017770B,
                        007760B, 003740B, 001700B, 000600B];
                    };
                pointLeft => {
                    global.info Ź [pointLeft, 0,-7, FALSE];
                    global.bits Ź [
                        000000B, 000000B, 002000B, 006000B,
                        016000B, 036000B, 077777B, 177777B,
                        177777B, 077777B, 036000B, 016000B,
                        006000B, 002000B, 000000B, 000000B];
                    };
                pointRight => {
                    global.info Ź [pointRight, -15,-7, FALSE];
                    global.bits Ź [
                        000000B, 000000B, 000040B, 000060B,
                        000070B, 000074B, 177776B, 177777B,
                        177777B, 177776B, 000074B, 000070B,
                        000060B, 000040B, 000000B, 000000B];
                    };
                pointUp => {
                    global.info Ź [pointUp, -7,0, FALSE];
                    global.bits Ź [
                        000600B, 001700B, 003740B, 007760B,
                        017770B, 037774B, 001700B, 001700B,
                        001700B, 001700B, 001700B, 001700B,
                        001700B, 001700B, 001700B, 001700B];
                    };
                questionMark => {
                    global.info Ź [questionMark, -7,-7, FALSE];
                    global.bits Ź [
                        017000B, 037600B, 060600B, 140300B,
                        140300B, 060300B, 000600B, 001400B,
                        003000B, 006000B, 006000B, 006000B,
                        000000B, 000000B, 006000B, 006000B];
                    };
                retry => {
                    global.info Ź [retry, -7,-7, FALSE];
                    global.bits Ź [
                        036370B, 021200B, 021200B, 036347B,
                        024200B, 022200B, 021370B, 000000B,
                        000000B, 175721B, 021052B, 021044B,
                        021704B, 021204B, 021104B, 021044B];
                    };
                scrollDown => {
                    global.info Ź [scrollDown, -7,-7, FALSE];
                    global.bits Ź [
                        007760B, 007760B, 007760B, 007760B,
                        007760B, 007760B, 007760B, 007760B,
                        007760B, 077776B, 037774B, 017770B,
                        007760B, 003740B, 001700B, 000600B];
                    };
                scrollLeft => {
                    global.info Ź [scrollLeft, -7,-7, FALSE];
                    global.bits Ź [
                        000000B, 001000B, 003000B, 007000B,
                        017777B, 037777B, 077777B, 177777B,
                        177777B, 077777B, 037777B, 017777B,
                        007000B, 003000B, 001000B, 000000B];
                    };
                scrollLeftRight => {
                    global.info Ź [scrollLeftRight, -7,-7, FALSE];
                    global.bits Ź [
                        000000B, 000000B, 000000B, 004020B,
                        014030B, 034034B, 077776B, 177777B,
                        177777B, 077776B, 034034B, 014030B,
                        004020B, 000000B, 000000B, 000000B];
                    };
                scrollUp => {
                    global.info Ź [scrollUp, -7,-7, FALSE];
                    global.bits Ź [
                        000600B, 001700B, 003740B, 007760B,
                        017770B, 037774B, 077776B, 007760B,
                        007760B, 007760B, 007760B, 007760B,
                        007760B, 007760B, 007760B, 007760B];
                    };
                scrollRight => {
                    global.info Ź [scrollRight, -7,-7, FALSE];
                    global.bits Ź [
                        000000B, 000100B, 000140B, 000160B,
                        177770B, 177774B, 177776B, 177777B,
                        177777B, 177776B, 177774B, 177770B,
                        000160B, 000140B, 000100B, 000000B];
                    };
                ENDCASE => {
                    global.info Ź global.clientCursors[type].info;
                    global.bits Ź global.clientCursors[type].bits;
                    };
                IF vWorld = NIL THEN vWorld Ź ViewersWorldInstance.GetWorld[];
                vWorld.class.setCursorPattern[vWorld.screenServerData, global.info.hotX, global.info.hotY, global.bits, patternToAtom[type], 
                cursor];
                };
        };
        >>

    SetACursor: PUBLIC ENTRY PROC [type: CursorType, cursor: ATOM, vWorld: VWorld Ź NIL] = TRUSTED {
        IF global.isABigCursor[type] THEN {
            global.info Ź global.bigClientCursors[type].info;
            <<global.bits _ global.bigClientCursors[type].bits;>>
            IF vWorld = NIL THEN vWorld Ź ViewersWorldInstance.GetWorld[];
            vWorld.class.setBigCursorPattern[vWorld.screenServerData, global.info.hotX, global.info.hotY, global.bigClientCursors[type].bits, 
            patternToAtom[type], cursor];
            }
        ELSE {
            global.info Ź global.clientCursors[type].info;
            <<global.bits Ź global.clientCursors[type].bits;>>
            IF vWorld = NIL THEN vWorld Ź ViewersWorldInstance.GetWorld[];
            vWorld.class.setCursorPattern[vWorld.screenServerData, global.info.hotX, global.info.hotY, global.clientCursors[type].bits, 
            patternToAtom[type], cursor];
            };
        };

    GetCursor: PUBLIC PROC RETURNS [CursorType] ~ {
        <<RETURN [global.info.type];>>
        RETURN[GetACursor[NIL]];
        };

    GetACursor: PUBLIC PROC [cursor: ATOM, vWorld: VWorld Ź NIL] RETURNS [CursorType] = {
        atom: ATOM;
        IF vWorld = NIL THEN vWorld Ź ViewersWorldInstance.GetWorld[];
        atom Ź vWorld.class.getCursorPattern[vWorld.screenServerData, cursor].patternName;
        RETURN[PatternFromAtom[atom]];
        };

    GetCursorInfo: PUBLIC ENTRY PROC RETURNS [CursorInfo] ~ {
        RETURN [global.info]; -- only makes sense in a one-cursor world
        };

    CursorPatternResult: TYPE = MultiCursorsExtras.CursorPatternResult;
    GetPatternFromName: PUBLIC PROC [type: CursorType] RETURNS [result: CursorPatternResult, smallPattern: CursorArrayRef, bigPattern: 
    Cursor32ArrayRef, hotX, hotY: INTEGER Ź 0] = {
        info: CursorInfo;
        IF type > global.lastUsedCursor THEN RETURN[none, NIL, NIL];
        IF global.isABigCursor[type] THEN {
            result _ big;
            bigPattern _ global.bigClientCursors[type].bits;
            info _ global.bigClientCursors[type].info;
            }
        ELSE {
            result _ small;
            smallPattern _ NEW[CursorArray];
            smallPattern^ Ź global.clientCursors[type].bits;
            info _ global.clientCursors[type].info;
            };
        hotX Ź info.hotX;
        hotY Ź info.hotY;
        };
        <<>>
    InitGlobalCursor: PROC [type: CursorType, info: CursorInfo, bits: CursorArray] = {
        IF type>global.lastUsedCursor THEN ERROR; -- safety check.  global.lastUsedCursor should be at none when this routine is called
        global.clientCursors[type] Ź NEW[CursorRec Ź [
            info,
            bits
            ]];
        global.isABigCursor[type] Ź FALSE;
        };

    NewCursor: PUBLIC ENTRY PROC [bits: CursorArray, hotX, hotY: INTEGER Ź 0]
    RETURNS [CursorType] = {
        global.lastUsedCursor Ź SUCC[global.lastUsedCursor];
        global.clientCursors[global.lastUsedCursor] Ź NEW[CursorRec Ź [
            [global.lastUsedCursor, hotX, hotY, FALSE],
            bits
            ]];
        global.isABigCursor[global.lastUsedCursor] Ź FALSE;
        RETURN[global.lastUsedCursor];
        };

    NewBigCursor: PUBLIC ENTRY PROC [bits: Cursor32ArrayRef, hotX, hotY: INTEGER Ź 0] RETURNS [CursorType] = {
        global.lastUsedCursor Ź SUCC[global.lastUsedCursor];
        global.bigClientCursors[global.lastUsedCursor] Ź NEW[BigCursorRec Ź [
            [global.lastUsedCursor, hotX, hotY, FALSE],
            bits
            ]];
        global.isABigCursor[global.lastUsedCursor] Ź TRUE;
        RETURN[global.lastUsedCursor];
        };

    AddCursorCorner: PUBLIC PROC [cornerSide: CornerSide] = {
        AddACursorCorner[cornerSide, NIL];
        };

    AddACursorCorner: PUBLIC ENTRY PROC [cornerSide: CornerSide, cursor: ATOM, vWorld: VWorld Ź NIL] = {
        <<Adds lines on top, sides, or both to currently displayed cursor>>
        i: CARDINAL[0..15];
        patternName: ATOM;
        IF vWorld = NIL THEN vWorld Ź ViewersWorldInstance.GetWorld[];
        IF HasBigPattern[cursor, vWorld] THEN RETURN -- for now
        ELSE {
            [global.info.hotX, global.info.hotY, global.bits, patternName] Ź vWorld.class.getCursorPattern[vWorld.screenServerData, cursor];
            SELECT cornerSide FROM
                upperLeft => {
                    global.info.hotX Ź global.info.hotY Ź 0;
                    global.bits[0] Ź 177777B;
                    global.bits[1] Ź 177777B;
                    FOR i IN [2..16) DO
                        global.bits[i] Ź Basics16.BITOR[global.bits[i], 140000B];
                        ENDLOOP;
                    };
                upperRight => {
                    global.info.hotX Ź -15;
                    global.info.hotY Ź 0;
                    global.bits[0] Ź 177777B;
                    global.bits[1] Ź 177777B;
                    FOR i IN [2..16) DO
                        global.bits[i] Ź Basics16.BITOR[global.bits[i], 000003B];
                        ENDLOOP;
                    };
                lowerLeft => {
                    global.info.hotX Ź 0;
                    global.info.hotY Ź -15;
                    global.bits[14] Ź 177777B;
                    global.bits[15] Ź 177777B;
                    FOR i IN [0..14) DO
                        global.bits[i] Ź Basics16.BITOR[global.bits[i], 140000B];
                        ENDLOOP;
                    };
                lowerRight => {
                    global.info.hotX Ź global.info.hotY Ź -15;
                    global.bits[14] Ź 177777B;
                    global.bits[15] Ź 177777B;
                    FOR i IN [0..14) DO
                        global.bits[i] Ź Basics16.BITOR[global.bits[i], 000003B];
                        ENDLOOP;
                    };
                upperSide => {
                    global.bits[0] Ź 177777B;
                    global.bits[1] Ź 177777B;
                    };
                lowerSide => {
                    global.bits[14] Ź 177777B;
                    global.bits[15] Ź 177777B;
                    };
                leftSide => {
                    FOR i IN [0..16) DO
                        global.bits[i] Ź Basics16.BITOR[global.bits[i], 140000B];
                        ENDLOOP;
                    };
                rightSide => {
                    FOR i IN [0..16) DO
                        global.bits[i] Ź Basics16.BITOR[global.bits[i], 000003B];
                        ENDLOOP;
                    };
                ENDCASE;
            vWorld.class.setCursorPattern[vWorld.screenServerData, global.info.hotX, global.info.hotY, global.bits, $Unnamed, cursor];
            };
        };
    <<>>
    <<ViewerPrivate procedures>>

        <<See HourGlass.mesa for instructions on how to use these procedures.>>

        <<Here's how to modify the cursor:  change the global.initialHourglass array below to anything>>
        <<you like for an initial cursor.  Count the number of bits (of global.sand) contained in the top>>
        <<and change the constant grains to this number.  global.sandArray will also need to be changed>>
        <<in InitializeHourglass.  The first seven numbers tell how many grains there are to start in>>
        <<the top rows of the hourglass (not counting the sides).  The last seven numbers tell how>>
        <<many empty places (slots for global.sand grains) there are in the bottom rows of the hourglass. >>
        <<The algorithm that moves the grains will carefully skip over any grains you initially put>>
        <<in the bottom.  Other fun things to play with are the constants that control how steep>>
        <<(slope) the global.sand piles up in the bottom, or drains from the top.  Happy hacking,  /Scott.>>

        grains: CARDINAL = 56;
        initGrains: CARDINAL = 3;

    InitializeHourglass: PUBLIC PROC [ticks: CARDINAL] = TRUSTED {
        global.savedTicks Ź ticks;
        global.sandUsed Ź global.tick Ź 0;
        global.totalTicks Ź ticks;
        global.theHG Ź global.initialHourglass;
        global.sandArray Ź [14, 12, 10, 8, 6, 4, 2, 2, 3, 6, 7, 10, 11, 14];
        global.sand Ź TRUE;
        };

    TickHourglass: PUBLIC PROC = TRUSTED {
        incr: INTEGER;
        n, m: CARDINAL;
        topSlope: CARDINAL = 3;
        bottomSlope: CARDINAL = 2;

        IF (global.tickŹglobal.tick+1) > global.totalTicks
            THEN {
                <<wrap around>>
                IF global.invertSand
                THEN global.sand Ź ~global.sand
                ELSE global.theHG Ź global.initialHourglass;
                global.sandUsed Ź global.tick Ź 0;
                global.totalTicks Ź global.savedTicks;
                global.sandArray Ź [14, 12, 10, 8, 6, 4, 2, 2, 3, 6, 7, 10, 11, 14];
                RETURN;
                }
            ELSE
                THROUGH [global.sandUsed..MIN[global.tick*grains/global.totalTicks, grains]) DO

                    <<Take a grain out of the top non-empty row of global.sand, favoring the middle.>>
                    FOR n DECREASING IN [2..8) DO
                        IF global.sandArray[n] >= global.sandArray[n-1]+topSlope THEN EXIT;
                        REPEAT FINISHED => FOR n IN [1..8) DO
                            IF global.sandArray[n]#0 THEN EXIT;
                            ENDLOOP;
                        ENDLOOP;
                    global.sandArray[n] Ź global.sandArray[n]-1;
                    m Ź (n*16)+7;
                    incr Ź 1;
                    UNTIL global.theHG[m]=global.sand DO
                        m Ź m+incr;
                        incr Ź -incr + (IF incr<0 THEN 1 ELSE -1);
                        ENDLOOP;
                    global.theHG[m] Ź ~global.sand;

                    <<Put a grain in one of the top non-empty rows of global.sand, favoring the middle,>>
                    <<and using the slope as a determinant of the global.sand stacking angle.>>
                    IF global.sandUsed < initGrains
                        THEN global.theHG[SELECT global.sandUsed FROM
                            0 => (9*16)+7,
                            1 => (11*16)+7,
                            ENDCASE => (13*16)+7] Ź global.sand
                        ELSE {
                            FOR n IN [8..14) DO
                                IF global.sandArray[n] >= global.sandArray[n+1]+bottomSlope THEN EXIT;
                                REPEAT FINISHED => FOR n DECREASING IN [8..15) DO
                                    IF global.sandArray[n]#0 THEN EXIT;
                                    ENDLOOP;
                                ENDLOOP;
                            global.sandArray[n] Ź global.sandArray[n]-1;
                            m Ź (n*16)+7;
                            incr Ź 1;
                            WHILE global.theHG[m]=global.sand DO
                                m Ź m+incr;
                                incr Ź -incr + (IF incr<0 THEN 1 ELSE -1);
                                ENDLOOP;
                            global.theHG[m] Ź global.sand;
                            };

                    global.sandUsed Ź global.sandUsed+1;

                    ENDLOOP;

        SetCursorPatternOnly[CursorFromPackedCursor[global.theHG]]; -- update displayed cursor
        };

    CursorFromPackedCursor: PROC [packed: PackedCursor] RETURNS [cursor: CursorArray] = {
        word16: CARD16;
        FOR i: NAT IN [0..15] DO
            word16 Ź IF packed[i*16] THEN 1 ELSE 0;
            FOR j: NAT IN [1..15] DO
                word16 Ź Basics16.BITLSHIFT[word16, 1];
                IF packed[i*16+j] THEN word16 Ź word16 + 1;
                ENDLOOP;
            cursor[i] Ź word16;
            ENDLOOP;
        };

    <<Pseudo Cursors>>

        PseudoCursor: TYPE = PseudoCursors.PseudoCursor;

        DataRec: TYPE = RECORD [
            bits: REF CursorArray,
            newData: BOOL Ź FALSE,
            paint: PROCESS Ź NIL,
            timeout: CONDITION
            ];

    Create: PUBLIC PROC [parent: ViewerClasses.Viewer, x, y: INTEGER Ź 0] 
    RETURNS [PseudoCursor] = {
        data: REF DataRec Ź NEW[DataRec];
        data.bits Ź NEW[CursorArray];
        TRUSTED { Process.InitializeCondition[@data.timeout, global.waitTime] };
        RETURN[ViewerOps.CreateViewer[flavor: $PsuedoCursor, info: [parent: parent, wx: x, wy: y, ww: 16, wh: 16, data: data, border: 
        FALSE], paint: FALSE]];
        };

    Set: PUBLIC ENTRY PROC [pseudoCursor: PseudoCursor, bits: REF CursorArray] = {
        ENABLE UNWIND => {};
        IF pseudoCursor # NIL THEN WITH pseudoCursor.data SELECT FROM
            d: REF DataRec => {
                IF bits=NIL THEN d.bits­ Ź ALL[0] ELSE d.bits­ Ź bits­;
                d.newData  Ź TRUE;
                IF d.paint=NIL THEN TRUSTED {
                    Process.Detach[d.paint Ź FORK PaintProcess[pseudoCursor]];
                    };
                };
            ENDCASE;
        };

    PaintProcess: ENTRY PROC [pseudoCursor: PseudoCursor] = {
        ENABLE UNWIND => {};
        WITH pseudoCursor.data SELECT FROM
            d: REF DataRec => {
                WHILE d.newData DO
                    d.newData Ź FALSE;
                    ViewerOps.PaintViewer[pseudoCursor, client, FALSE, $Update];
                    WAIT d.timeout;
                    ENDLOOP;
                d.paint Ź NIL;
                };
            ENDCASE;
        };

    PseudoCursorPaint: ViewerClasses.PaintProc = {
        IF self # NIL THEN WITH self.data SELECT FROM
            d: REF DataRec => TRUSTED {
                sm: ImagerSample.RasterSampleMap ~ ImagerSample.ObtainUnsafeDescriptor[size: [16, 16], bitsPerSample: 1, bitsPerLine: 16, base: 
                [word: LOOPHOLE[d.bits], bit: 0], ref: d.bits, words: WORDS[CursorArray]];
                Imager.DrawBitmap[context: context, bitmap: sm, position: [0, 16]];
                ImagerSample.ReleaseDescriptor[sm];
                };
            ENDCASE;
        };

    <<Lower-Level Routines.  Use with Care>>
    <<>>
    SetACursorOffset: PUBLIC PROC [deltaX, deltaY: INTEGER, enableTracking: BOOL Ź TRUE, cursor: ATOM, vWorld: VWorld Ź NIL] = {
        <<Offsets origin of cursor bitmap by the specified number of screen points>>
        <<enableTracking _ FALSE to disable automatic cursor tracking.>>
        pattern: CursorArray;
        IF vWorld = NIL THEN vWorld Ź ViewersWorldInstance.GetWorld[];
        pattern Ź vWorld.class.getCursorPattern[vWorld.screenServerData, cursor].cursorPattern;
        vWorld.class.setCursorPattern[vWorld.screenServerData, deltaX, deltaY, pattern, cursor];
        };
        <<>>
    SetCursorOffset: PUBLIC PROC [deltaX, deltaY: INTEGER, enableTracking: BOOL Ź TRUE] = {
        <<Offsets origin of [the default mouse] cursor bitmap by the specified number of screen points>>
        <<enableTracking _ FALSE to disable automatic cursor tracking.>>
        vWorld: ViewersWorld.Ref Ź ViewersWorldInstance.GetWorld[];
        pattern: CursorArray Ź vWorld.class.getCursorPattern[vWorld.screenServerData, NIL].cursorPattern;
        vWorld.class.setCursorPattern[vWorld.screenServerData, deltaX, deltaY, pattern, NIL];
        };

    GetACursorOffset: PUBLIC PROC [cursor: ATOM, vWorld: VWorld Ź NIL] RETURNS [deltaX, deltaY: INTEGER Ź 0, trackingEnabled: BOOL Ź 
    TRUE] = {
        IF vWorld = NIL THEN vWorld Ź ViewersWorldInstance.GetWorld[];
        [deltaX, deltaY, ----] Ź vWorld.class.getCursorPattern[vWorld.screenServerData, cursor];
        };

    GetCursorOffset: PUBLIC PROC RETURNS[deltaX, deltaY: INTEGER, trackingEnabled: BOOL Ź TRUE] = {
        <<Get the origin offset of the [default mouse] cursor.>>
        vWorld: ViewersWorld.Ref Ź ViewersWorldInstance.GetWorld[];
        [deltaX, deltaY, ----] Ź vWorld.class.getCursorPattern[vWorld.screenServerData, NIL];
        };

    SetACursorPosition: PUBLIC PROC [posX, posY: INTEGER, enableTracking: BOOL Ź TRUE, cursor: ATOM, vWorld: VWorld Ź NIL] = {
        IF vWorld = NIL THEN vWorld Ź ViewersWorldInstance.GetWorld[];
        SIGNAL NotYetImplemented;
        };

    SetCursorPosition: PUBLIC PROC[posX, posY: INTEGER, enableTracking: BOOL Ź TRUE] = {
        <<Sets the cursor position directly to the desired value (useful for cursor gridding)>>
        <<enableTracking _ FALSE to disable automatic cursor tracking.>>
        <<Position may not be in synch with Inscript fetches.>>
        vWorld: ViewersWorld.Ref Ź ViewersWorldInstance.GetWorld[];
        SIGNAL NotYetImplemented;
        };

    GetACursorPosition: PUBLIC PROC [cursor: ATOM, vWorld: VWorld Ź NIL] RETURNS [deltaX, deltaY: INTEGER Ź 0, trackingEnabled: BOOL Ź 
    TRUE] = {
        IF vWorld = NIL THEN vWorld Ź ViewersWorldInstance.GetWorld[];
        SIGNAL NotYetImplemented;
        };

    GetCursorPosition: PUBLIC PROC RETURNS [deltaX, deltaY: INTEGER Ź 0, trackingEnabled: BOOL Ź TRUE] = {
        <<Returns the current cursor position.>>
        <<Position may not be in synch with Inscript fetches.>>
        SIGNAL NotYetImplemented;
        };

    SetAMousePosition: PUBLIC PROC [x, y: INTEGER, display: REF Ź NIL, cursor: ATOM, vWorld: VWorld Ź NIL] = {
        IF vWorld = NIL THEN vWorld Ź ViewersWorldInstance.GetWorld[];
        vWorld.class.setMousePosition[vWorld.screenServerData, x, y, display, cursor];
        };

    GetAMousePosition: PUBLIC PROC [cursor: ATOM, vWorld: VWorld Ź NIL] RETURNS [x, y: INTEGER, display: REF Ź NIL] = {
        IF vWorld = NIL THEN vWorld Ź ViewersWorldInstance.GetWorld[];
        RETURN vWorld.class.getMousePosition[vWorld.screenServerData, cursor];
        };

    DefaultMouseGrain: PUBLIC PROC RETURNS [ticks: CARD16 Ź 173, dots: INTEGER Ź 173] = {
        SIGNAL NotYetImplemented;
        };
        <<Recording grain hints.  These are provided by higher levels at the time those levels are created.  Subsequent recorded events 
        will be entered at the specified grain.  Unless the higher levels are running in more or less real time, these hints will 
        not be too valuable.>>

    SetAMouseGrain: PUBLIC PROC [ticks: CARD16, dots: INTEGER, cursor: ATOM, vWorld: VWorld Ź NIL] = {
        SIGNAL NotYetImplemented;
        };

    SetMouseGrain: PUBLIC PROC [ticks: CARD16, dots: INTEGER] = {
        SIGNAL NotYetImplemented;
        };

    SetACursorPattern: PUBLIC PROC [cursorPattern: CursorArray, deltaX, deltaY: INTEGER, cursor: ATOM, vWorld: VWorld Ź NIL] = {
        IF vWorld = NIL THEN vWorld Ź ViewersWorldInstance.GetWorld[];
        vWorld.class.setCursorPattern[vWorld.screenServerData, deltaX, deltaY, cursorPattern, $Unnamed, cursor];
        };

    SetCursorPattern: PUBLIC PROC [cursorPattern: CursorArray, deltaX, deltaY: INTEGER] = {
        <<Changes the cursor bit array and the offset of the hot spot.>>
        vWorld: ViewersWorld.Ref Ź ViewersWorldInstance.GetWorld[];
        vWorld.class.setCursorPattern[vWorld.screenServerData, deltaX, deltaY, cursorPattern, $Unnamed, NIL];
        };

    SetABigCursorPattern: PUBLIC PROC [cursorPattern: Cursor32ArrayRef, deltaX, deltaY: INTEGER, cursor: ATOM, vWorld: VWorld Ź NIL] = {
        IF vWorld = NIL THEN vWorld Ź ViewersWorldInstance.GetWorld[];
        vWorld.class.setBigCursorPattern[vWorld.screenServerData, deltaX, deltaY, cursorPattern, $Unnamed, cursor];
        };
        <<>>
    HasBigPattern: PUBLIC PROC [cursor: ATOM, vWorld: VWorld Ź NIL] RETURNS [BOOL] = {
        IF vWorld = NIL THEN vWorld Ź ViewersWorldInstance.GetWorld[];
        RETURN[vWorld.class.isBigCursorPattern[vWorld.screenServerData, cursor]];
        };

    GetACursorPattern: PUBLIC PROC [cursor: ATOM, vWorld: VWorld Ź NIL] RETURNS [cursorPattern: CursorArray, deltaX, deltaY: INTEGER] = 
    {
        IF vWorld = NIL THEN vWorld Ź ViewersWorldInstance.GetWorld[];
        [deltaX, deltaY, cursorPattern] Ź vWorld.class.getCursorPattern[vWorld.screenServerData, cursor];
        };

    GetCursorPattern: PUBLIC PROC RETURNS [cursorPattern: CursorArray, deltaX, deltaY: INTEGER] = {
        <<Fetches the cursor bit array, and the offset of the hot spot.>>
        vWorld: ViewersWorld.Ref Ź ViewersWorldInstance.GetWorld[];
        [deltaX, deltaY, cursorPattern] Ź vWorld.class.getCursorPattern[vWorld.screenServerData, NIL];
        };

    GetABigCursorPattern: PUBLIC PROC [cursor: ATOM, vWorld: VWorld Ź NIL] RETURNS [cursorPattern: Cursor32ArrayRef, deltaX, deltaY: 
    INTEGER Ź 0] = {
        IF vWorld = NIL THEN vWorld Ź ViewersWorldInstance.GetWorld[];
        [deltaX, deltaY, cursorPattern] Ź vWorld.class.getBigCursorPattern[vWorld.screenServerData, cursor];
        };

    SetACursorPatternOnly: PUBLIC PROC [cursorPattern: CursorArray, cursor: ATOM, vWorld: VWorld Ź NIL] = {
        deltaX, deltaY: INTEGER;
        IF vWorld = NIL THEN vWorld Ź ViewersWorldInstance.GetWorld[];
        [deltaX, deltaY, ----] Ź vWorld.class.getCursorPattern[vWorld.screenServerData, cursor];
        vWorld.class.setCursorPattern[vWorld.screenServerData, deltaX, deltaY, cursorPattern, cursor];
        };

    SetCursorPatternOnly: PUBLIC PROC [cursorPattern: CursorArray] = {
        <<changes the cursor bit array>>
        vWorld: ViewersWorld.Ref Ź ViewersWorldInstance.GetWorld[];
        deltaX, deltaY: INTEGER;
        [deltaX, deltaY, ----] Ź vWorld.class.getCursorPattern[vWorld.screenServerData, NIL];
        vWorld.class.setCursorPattern[vWorld.screenServerData, deltaX, deltaY, cursorPattern, NIL];
        };

    SetABigCursorPatternOnly: PUBLIC PROC [cursorPattern: Cursor32ArrayRef, cursor: ATOM, vWorld: VWorld Ź NIL] = {
        deltaX, deltaY: INTEGER;
        IF vWorld = NIL THEN vWorld Ź ViewersWorldInstance.GetWorld[];
        [deltaX, deltaY, ----] Ź vWorld.class.getCursorPattern[vWorld.screenServerData, NIL];
        vWorld.class.setBigCursorPattern[vWorld.screenServerData, deltaX, deltaY, cursorPattern, cursor];
        };
        <<>>
    GetACursorPatternOnly: PUBLIC PROC [cursor: ATOM, vWorld: VWorld Ź NIL] RETURNS [cursorPattern: CursorArray] = {
        IF vWorld = NIL THEN vWorld Ź ViewersWorldInstance.GetWorld[];
        cursorPattern Ź vWorld.class.getCursorPattern[vWorld.screenServerData, cursor].cursorPattern;
        };

    GetCursorPatternOnly: PUBLIC PROC RETURNS [cursorPattern: CursorArray] = {
        <<fetches the cursor bit array>>
        vWorld: ViewersWorld.Ref Ź ViewersWorldInstance.GetWorld[];
        cursorPattern Ź vWorld.class.getCursorPattern[vWorld.screenServerData, NIL].cursorPattern;
        };

    GetABigCursorPatternOnly: PUBLIC PROC [cursor: ATOM, vWorld: VWorld Ź NIL] RETURNS [cursorPattern: Cursor32ArrayRef] = {
        IF vWorld = NIL THEN vWorld Ź ViewersWorldInstance.GetWorld[];
        cursorPattern Ź vWorld.class.getBigCursorPattern[vWorld.screenServerData, cursor].cursorPattern;
        };
    <<>>
    CursorColorCommand: Commander.CommandProc = {
        colorName: Rope.ROPE Ź CommanderOps.NextArgument[cmd];
        cursorName: Rope.ROPE Ź CommanderOps.NextArgument[cmd];
        cursorAtom: ATOM Ź Atom.MakeAtom[cursorName];
        rgb: ImagerColor.RGB;
        vWorld: ViewersWorld.Ref Ź ViewersWorldInstance.GetWorld[];
        color: Imager.Color;
        rgb Ź SELECT TRUE FROM
            Rope.Equal[colorName, "red", FALSE] => [1,0,0],
            Rope.Equal[colorName, "orange", FALSE] => [R: 0.976, G: 0.452, B: 0.0],
            Rope.Equal[colorName, "yellow", FALSE] => [1,1,0],
            Rope.Equal[colorName, "green", FALSE] => [0,1,0],
            Rope.Equal[colorName, "blue", FALSE] => [0,0,1],
            Rope.Equal[colorName, "purple", FALSE] => [R: 0.81, G: 0.011, B: 0.941],
            Rope.Equal[colorName, "black", FALSE] => [0,0,0],
            ENDCASE => [0,0,0];
        color Ź ImagerColor.ColorFromRGB[rgb];
        SetACursorColor[color, cursorAtom, vWorld];
        };

    CursorPatternCommand: Commander.CommandProc = {
        patternName: Rope.ROPE Ź CommanderOps.NextArgument[cmd];
        cursorRope: Rope.ROPE;
        pattern: ViewerClasses.CursorType;
        cursorAtom: ATOM;

        pattern Ź SELECT TRUE FROM
            Rope.Equal[patternName, "activate"] => activate,
            Rope.Equal[patternName, "blank"] => blank,
            Rope.Equal[patternName, "bullseye"] => bullseye,
            Rope.Equal[patternName, "confirm"] => confirm,
            Rope.Equal[patternName, "crossHairsCircle"] => crossHairsCircle,
            Rope.Equal[patternName, "ftp"] => ftp,
            Rope.Equal[patternName, "typeKey"] => typeKey,
            Rope.Equal[patternName, "hourGlass"] => hourGlass,
            Rope.Equal[patternName, "move"] => move,
            Rope.Equal[patternName, "menu"] => menu,
            Rope.Equal[patternName, "mouseRed"] => mouseRed,
            Rope.Equal[patternName, "mouseYellow"] => mouseYellow,
            Rope.Equal[patternName, "mouseBlue"] => mouseBlue,
            Rope.Equal[patternName, "grow"] => grow,
            Rope.Equal[patternName, "pointDown"] => pointDown,
            Rope.Equal[patternName, "pointLeft"] => pointLeft,
            Rope.Equal[patternName, "pointRight"] => pointRight,
            Rope.Equal[patternName, "pointUp"] => pointUp,
            Rope.Equal[patternName, "questionMark"] => questionMark,
            Rope.Equal[patternName, "retry"] => retry,
            Rope.Equal[patternName, "scrollDown"] => scrollDown,
            Rope.Equal[patternName, "scrollLeft"] => scrollLeft,
            Rope.Equal[patternName, "scrollLeftRight"] => scrollLeftRight,
            Rope.Equal[patternName, "scrollRight"] => scrollRight,
            Rope.Equal[patternName, "scrollUp"] => scrollUp,
            Rope.Equal[patternName, "scrollUpDown"] => scrollUpDown,
            Rope.Equal[patternName, "textPointer"] => textPointer,
            Rope.Equal[patternName, "none"] => none,
            Rope.Equal[patternName, "last"] => last,
            ENDCASE => textPointer;

        cursorRope Ź CommanderOps.NextArgument[cmd];
        cursorAtom Ź IF cursorRope = NIL THEN NIL ELSE Atom.MakeAtom[cursorRope];
        SetACursor[pattern, cursorAtom, NIL];
        cmd.out.PutF[" Setting cursor %g to pattern %g\n", [atom[cursorAtom]], [rope[IF pattern = textPointer THEN "textPointer" ELSE 
        patternName]] ];
        };

    PatternFromAtom: PROC [atom: ATOM] RETURNS [pattern: CursorType] = {
        val: REF;
        success: BOOL Ź FALSE;
        [success, val] Ź RefTab.Fetch[atomToPattern, atom];
        pattern Ź IF NOT success THEN none
            ELSE NARROW[val, REF CursorType]­;
        };

    atomToPattern: RefTab.Ref Ź RefTab.Create[271];
    BuildCursorNameTables: PROC [] = {
        AssociatePatternAndAtom: PROC [pattern: CursorType, atom: ATOM] = {
            patternToAtom[pattern] Ź atom;
            [] Ź RefTab.Store[atomToPattern, atom, NEW[CursorType Ź pattern]];
            };
        AssociatePatternAndAtom[activate, $activate];
        AssociatePatternAndAtom[blank, $blank];
        AssociatePatternAndAtom[bullseye, $bullseye];
        AssociatePatternAndAtom[confirm, $confirm];
        AssociatePatternAndAtom[crossHairsCircle, $crossHairsCircle];
        AssociatePatternAndAtom[ftp, $ftp];
        AssociatePatternAndAtom[typeKey, $typeKey];
        AssociatePatternAndAtom[hourGlass, $hourGlass];
        AssociatePatternAndAtom[move, $move];
        AssociatePatternAndAtom[menu, $menu];
        AssociatePatternAndAtom[mouseRed, $mouseRed];
        AssociatePatternAndAtom[mouseYellow, $mouseYellow];
        AssociatePatternAndAtom[mouseBlue, $mouseBlue];
        AssociatePatternAndAtom[grow, $grow];
        AssociatePatternAndAtom[pointDown, $pointDown];
        AssociatePatternAndAtom[pointLeft, $pointLeft];
        AssociatePatternAndAtom[pointRight, $pointRight];
        AssociatePatternAndAtom[pointUp, $pointUp];
        AssociatePatternAndAtom[questionMark, $questionMark];
        AssociatePatternAndAtom[retry, $retry];
        AssociatePatternAndAtom[scrollDown, $scrollDown];
        AssociatePatternAndAtom[scrollLeft, $scrollLeft];
        AssociatePatternAndAtom[scrollLeftRight, $scrollLeftRight];
        AssociatePatternAndAtom[scrollRight, $scrollRight];
        AssociatePatternAndAtom[scrollUp, $scrollUp];
        AssociatePatternAndAtom[scrollUpDown, $scrollUpDown];
        AssociatePatternAndAtom[textPointer, $textPointer];
        AssociatePatternAndAtom[none, $none];
        FOR i: CursorType IN (textPointer..last) DO
            AssociatePatternAndAtom[i, Atom.MakeAtom[IO.PutFR1["Custom%g", [integer[ORD[i]-27]] ]] ];
            ENDLOOP;
        AssociatePatternAndAtom[last, $last];
        };

    InitSmallCursors: PROC [] = TRUSTED {
        global Ź NEW[GlobalData Ź []]; -- used to set up the calls to SetCursorPattern, etc.  See SetACursor for an example of use.
        FOR type: CursorType IN [activate..textPointer] DO
            SELECT type FROM
                activate => {
                    InitGlobalCursor[type, [activate, -7,-7, FALSE],
                     [
                        177777B, 177777B, 140003B, 140003B,
                        140003B, 140003B, 140003B, 140003B,
                        140003B, 140003B, 140003B, 140003B,
                        140003B, 140003B, 177777B, 177777B]];
                    };
                blank => {
                    InitGlobalCursor[type, [blank, 0,0, FALSE],
                     [
                        000000B, 000000B, 000000B, 000000B,
                        000000B, 000000B, 000000B, 000000B,
                        000000B, 000000B, 000000B, 000000B,
                        000000B, 000000B, 000000B, 000000B]];
                    };
                bullseye => {
                    InitGlobalCursor[type, [bullseye, -7,-7, FALSE],
                     [
                        003700B, 007740B, 014060B, 030030B,
                        060014B, 140006B, 141606B, 141606B,
                        141606B, 140006B, 060014B, 030030B,
                        014060B, 007740B, 003700B, 000000B]]; 
                    };
                confirm => {
                    InitGlobalCursor[type, [confirm, 0,0, FALSE],
                     [
                        000000B, 000000B, 167227B, 105324B,
                        105326B, 105264B, 167224B, 000000B,
                        000000B, 073642B, 022266B, 023652B,
                        022442B, 072242B, 000000B, 000000B]];
                    };
                crossHairsCircle => {
                    InitGlobalCursor[type, [crossHairsCircle, -7,-7, FALSE],
                     [
                        001700B, 007760B, 014630B, 030614B,
                        060606B, 040602B, 140603B, 177177B,
                        177177B, 140603B, 040602B, 060606B,
                        030614B, 014630B, 007760B, 001700B]];
                    };
                ftp => {
                    InitGlobalCursor[type, [ftp, -7,-7, FALSE],
                     [
                        000177B, 076077B, 040037B, 040017B,
                        070007B, 043703B, 040401B, 040400B,
                        000400B, 100436B, 140421B, 160421B,
                        170036B, 174020B, 176020B, 177020B]];
                    };
                typeKey => {
                    InitGlobalCursor[type, [typeKey, -7,-7, FALSE],
                     [
                        002000B, 074000B, 140000B, 012767B,
                        012525B, 053566B, 111113B, 163100B,
                        000000B, 000000B, 154000B, 053520B,
                        062520B, 053360B, 155440B, 000140B]];
                    };
                hourGlass => {
                    InitGlobalCursor[type, [hourGlass, -7,-7, FALSE],
                     [
                        177777B, 100001B, 040002B, 034034B,
                        017170B, 007560B, 003740B, 001700B,
                        001100B, 002440B, 004220B, 010610B,
                        021704B, 047762B, 177777B, 177777B]];
                    };
                move => {
                    InitGlobalCursor[type, [move, -7,-7, FALSE],
                     [
                        000000B, 000000B, 000000B, 014030B,
                        016070B, 017170B, 017770B, 015730B,
                        014630B, 014030B, 014030B, 014030B,
                        014030B, 000000B, 000000B, 000000B]];
                    };
                menu => {
                    InitGlobalCursor[type, [menu, 0,-7, FALSE],
                     [
                        000000B, 000000B, 000000B, 001000B,
                        003001B, 007003B, 036007B, 177776B,
                        177776B, 036007B, 007003B, 003001B,
                        001000B, 000000B, 000000B, 000000B]];
                    };
                mouseRed => {
                    InitGlobalCursor[type, [mouseRed, -2,0, FALSE],
                     [
                        037770B, 020010B, 027250B, 027250B,
                        027250B, 027250B, 027250B, 020010B,
                        020010B, 020010B, 020010B, 020010B,
                        020010B, 020010B, 020010B, 037770B]];
                    };
                mouseYellow => {
                    InitGlobalCursor[type, [mouseYellow, -2,0, FALSE],
                     [
                        037770B, 020010B, 025650B, 025650B,
                        025650B, 025650B, 025650B, 020010B,
                        020010B, 020010B, 020010B, 020010B,
                        020010B, 020010B, 020010B, 037770B]];
                    };
                mouseBlue => {
                    InitGlobalCursor[type, [mouseBlue, -2,0, FALSE],
                     [
                        037770B, 020010B, 025350B, 025350B,
                        025350B, 025350B, 025350B, 020010B,
                        020010B, 020010B, 020010B, 020010B,
                        020010B, 020010B, 020010B, 037770B]];
                    };
                grow => {
                    InitGlobalCursor[type, [grow, 0,0, FALSE],
                     [
                        000000B, 000000B, 000000B, 003740B,
                        007760B, 006060B, 014000B, 014370B,
                        014370B, 014030B, 006060B, 007760B,
                        003740B, 000000B, 000000B, 000000B]];
                    };
                pointDown => {
                    InitGlobalCursor[type, [pointDown, -7,-15, FALSE],
                     [
                        001700B, 001700B, 001700B, 001700B,
                        001700B, 001700B, 001700B, 001700B,
                        001700B, 001700B, 037774B, 017770B,
                        007760B, 003740B, 001700B, 000600B]];
                    };
                pointLeft => {
                    InitGlobalCursor[type, [pointLeft, 0,-7, FALSE],
                     [
                        000000B, 000000B, 002000B, 006000B,
                        016000B, 036000B, 077777B, 177777B,
                        177777B, 077777B, 036000B, 016000B,
                        006000B, 002000B, 000000B, 000000B]];
                    };
                pointRight => {
                    InitGlobalCursor[type, [pointRight, -15,-7, FALSE],
                     [
                        000000B, 000000B, 000040B, 000060B,
                        000070B, 000074B, 177776B, 177777B,
                        177777B, 177776B, 000074B, 000070B,
                        000060B, 000040B, 000000B, 000000B]];
                    };
                pointUp => {
                    InitGlobalCursor[type, [pointUp, -7,0, FALSE],
                     [
                        000600B, 001700B, 003740B, 007760B,
                        017770B, 037774B, 001700B, 001700B,
                        001700B, 001700B, 001700B, 001700B,
                        001700B, 001700B, 001700B, 001700B]];
                    };
                questionMark => {
                    InitGlobalCursor[type, [questionMark, -7,-7, FALSE],
                     [
                        017000B, 037600B, 060600B, 140300B,
                        140300B, 060300B, 000600B, 001400B,
                        003000B, 006000B, 006000B, 006000B,
                        000000B, 000000B, 006000B, 006000B]];
                    };
                retry => {
                    InitGlobalCursor[type, [retry, -7,-7, FALSE],
                     [
                        036370B, 021200B, 021200B, 036347B,
                        024200B, 022200B, 021370B, 000000B,
                        000000B, 175721B, 021052B, 021044B,
                        021704B, 021204B, 021104B, 021044B]];
                    };
                scrollDown => {
                    InitGlobalCursor[type, [scrollDown, -7,-7, FALSE],
                     [
                        007760B, 007760B, 007760B, 007760B,
                        007760B, 007760B, 007760B, 007760B,
                        007760B, 077776B, 037774B, 017770B,
                        007760B, 003740B, 001700B, 000600B]];
                    };
                scrollLeft => {
                    InitGlobalCursor[type, [scrollLeft, -7,-7, FALSE],
                     [
                        000000B, 001000B, 003000B, 007000B,
                        017777B, 037777B, 077777B, 177777B,
                        177777B, 077777B, 037777B, 017777B,
                        007000B, 003000B, 001000B, 000000B]];
                    };
                scrollLeftRight => {
                    InitGlobalCursor[type, [scrollLeftRight, -7,-7, FALSE],
                     [
                        000000B, 000000B, 000000B, 004020B,
                        014030B, 034034B, 077776B, 177777B,
                        177777B, 077776B, 034034B, 014030B,
                        004020B, 000000B, 000000B, 000000B]];
                    };
                scrollRight => {
                    InitGlobalCursor[type, [scrollRight, -7,-7, FALSE],
                     [
                        000000B, 000100B, 000140B, 000160B,
                        177770B, 177774B, 177776B, 177777B,
                        177777B, 177776B, 177774B, 177770B,
                        000160B, 000140B, 000100B, 000000B]];
                    };
                scrollUp => {
                    InitGlobalCursor[type, [scrollUp, -7,-7, FALSE],
                     [
                        000600B, 001700B, 003740B, 007760B,
                        017770B, 037774B, 077776B, 007760B,
                        007760B, 007760B, 007760B, 007760B,
                        007760B, 007760B, 007760B, 007760B]];
                    };
                scrollUpDown => {
                    InitGlobalCursor[type, [scrollUpDown, -7,-7, FALSE],
                     [
                        000400B, 001600B, 003700B, 007740B,
                        017760B, 001600B, 001600B, 001600B,
                        001600B, 001600B, 001600B, 017760B,
                        007740B, 003700B, 001600B, 000400B]];
                    };
                textPointer => {
                    InitGlobalCursor[type, [textPointer, 0,0, FALSE],
                     [
                        100000B, 140000B, 160000B, 170000B,
                        174000B, 176000B, 177000B, 170000B,
                        154000B, 114000B, 006000B, 006000B,
                        003000B, 003000B, 001400B, 001400B]];
                    };
                ENDCASE => NULL;
            ENDLOOP;
        };

    InitSmallCursors[];
    BuildCursorNameTables[];

    ViewerOps.RegisterViewerClass[
        $PsuedoCursor,
        NEW[ViewerClasses.ViewerClassRec Ź [
            paint: PseudoCursorPaint,
            tipTable: NIL
            ]]
        ];

    Commander.Register["CursorColor", CursorColorCommand, "CursorColor <red, orange, yellow, green, blue, purple, or black> <cursor 
    name>\n    e.g., CursorColor blue Mouse\n    Gives the named cursor the named color"];
    Commander.Register["CursorPattern", CursorPatternCommand, "CursorPattern <activate, blank, bullseye, confirm, crossHairsCircle, 
    ftp, typeKey, hourGlass, move, menu, mouseRed, mouseYellow, mouseBlue, grow, pointDown, pointLeft, pointRight, pointUp, 
    questionMark, retry, scrollDown, scrollLeft, scrollLeftRight, scrollRight, scrollUp, scrollUpDown, textPointer, none, or last> 
    <cursor name>\n    e.g., CursorPattern scrollLeft /dev/mouse1\n    Gives the named cursor the named pattern"];


    END.