<<>>
    <<IdleImpl.mesa>>
        <<Copyright Ó 1985, 1986, 1988, 1989, 1991, 1992 by Xerox Corporation.  All rights reserved.>>
        <<Russ Atkinson (RRA) April 16, 1987 2:08:09 am PDT>>
        <<Doug Wyatt, December 4, 1986 7:06:23 pm PST>>
        <<Last tweaked by Mike Spreitzer on October 7, 1987 3:00:44 pm PDT>>
        <<Willie-Sue (really bj), November 2, 1988 11:33:51 am PST>>
        <<Bier, March 5, 1991 6:22 pm PST>>
        <<Last edited by: Mik Lamming - January 26, 1989 11:39:00 am PST>>
        <<Michael Plass, September 29, 1989 2:03:30 pm PDT>>
        <<Kenneth A. Pier, March 14, 1991 5:42 pm PST>>
        <<Willie-s, October 14, 1991 1:00 pm PDT>>
        <<Christian Jacobi, March 3, 1992 12:33 pm PST>>

    DIRECTORY
        Basics, BasicTime, Idle, IdleBackdoor, Imager, ImagerBackdoor, ImagerFont, ImagerSample, InputFocus, KeySymsKB, KeyMapping, 
        KeyTypes, MultiCursors, Process, Real, Rope, SpecialKeySyms, TIPPrivate, UserInput, UserInputOps, ViewerClasses, ViewerOps, 
        ViewerPrivate, ViewersWorld, ViewersWorldInstance, ViewersWorldTypes, ViewersWorldRefType;

    IdleImpl: CEDAR MONITOR
        IMPORTS Basics, BasicTime, Imager, ImagerBackdoor, ImagerFont, ImagerSample, InputFocus, KeyMapping, MultiCursors, Process, Real, 
        TIPPrivate, UserInputOps, ViewerOps, ViewerPrivate, ViewersWorld, ViewersWorldInstance
        EXPORTS Idle, IdleBackdoor, ViewersWorldRefType = BEGIN

    <<Basic Stuff>>

        ViewersWorldRef: TYPE = REF ViewersWorldObj;
        ViewersWorldObj: PUBLIC TYPE = ViewersWorldTypes.ViewersWorldObj;
        Activity: TYPE ~ IdleBackdoor.Activity;
        Animator: TYPE ~ IdleBackdoor.Animator;
        AnimatorPrivate: TYPE ~ IdleBackdoor.AnimatorPrivate;
        FullIdleHandler: TYPE ~ IdleBackdoor.FullIdleHandler;
        KeyFilter: TYPE ~ IdleBackdoor.KeyFilter;
        IdleRegistration: TYPE ~ Idle.IdleRegistration;
        IdleHandler: TYPE ~ Idle.IdleHandler;
        ImageProc: TYPE ~ Idle.ImageProc;
        KeyCode: TYPE ~ KeyTypes.KeyCode;
        NotifyProc: TYPE ~ ViewerClasses.NotifyProc;
        ROPE: TYPE ~ Rope.ROPE;

        AnimatorList: TYPE ~ LIST OF Animator;

        Bug: ERROR ~ CODE;

    <<Global Variables (not exported)>>

        idleWorld: ViewersWorldTypes.Ref Ź ViewersWorldInstance.GetWorld[];

        <<Monitored Data>>
            becomeIdle, outOfIdle: CONDITION;
            idleState: Activity Ź unidle;
            newState: Activity Ź unidle; -- just to initialize to something
            changeComing: BOOL Ź FALSE;
            enabled: BOOL Ź TRUE;
            fullRegistry: FullIdleHandlerList Ź NIL;
            animatorStack: AnimatorList Ź NIL;

    <<Exports to IdleBackdoor>>

        FullIdleHandlerList: TYPE ~ LIST OF FullIdleHandlerRecord;
        FullIdleHandlerRecord: TYPE ~ RECORD [proc: FullIdleHandler, data: REF ANY];

        RegisterFullIdleHandler: PUBLIC ENTRY PROC [handler: FullIdleHandler, data: REF Ź NIL] RETURNS [IdleRegistration] ~ {
            fullRegistry Ź CONS[[handler, data], fullRegistry];
            RETURN [fullRegistry];
            };

        UnregisterFullIdleHandler: PUBLIC ENTRY PROC [registration: IdleRegistration] = {
            ENABLE UNWIND => NULL;
            lag: FullIdleHandlerList Ź NIL;
            FOR each: FullIdleHandlerList Ź fullRegistry, each.rest WHILE each # NIL DO
                IF each = registration THEN {
                    IF lag = NIL THEN fullRegistry Ź each.rest ELSE lag.rest Ź each.rest;
                    EXIT;
                    };
                lag Ź each;
                ENDLOOP;
            };

        CopyRegistry: INTERNAL PROC RETURNS [head: FullIdleHandlerList Ź NIL] = {
            ENABLE UNWIND => NULL;
            tail: FullIdleHandlerList Ź NIL;
            FOR each: FullIdleHandlerList Ź fullRegistry, each.rest WHILE each # NIL DO
                new: FullIdleHandlerList = LIST[each.first];
                IF tail = NIL THEN head Ź new ELSE tail.rest Ź new;
                tail Ź new;
                ENDLOOP;
            };

        GetAnimator: PUBLIC ENTRY PROC RETURNS [Animator] ~ {
            ENABLE UNWIND => NULL;
            RETURN [animatorStack.first];
            };

        SetAnimator: PUBLIC ENTRY PROC [a: Animator] ~ {
            ENABLE UNWIND => NULL;
            WHILE idleState#unidle DO WAIT outOfIdle ENDLOOP;
            animatorStack.first Ź a;
            };

        PushAnimator: PUBLIC ENTRY PROC [a: Animator] ~ {
            ENABLE UNWIND => NULL;
            WHILE idleState#unidle DO WAIT outOfIdle ENDLOOP;
            animatorStack Ź CONS[a, animatorStack];
            };

        PopAnimator: PUBLIC ENTRY PROC ~ {
            ENABLE UNWIND => NULL;
            WHILE idleState#unidle DO WAIT outOfIdle ENDLOOP;
            IF animatorStack.rest#NIL THEN animatorStack Ź animatorStack.rest;
            };

        FinishSet: PROC [changed: BOOL, reg: FullIdleHandlerList] ~ {
            FOR each: FullIdleHandlerList Ź reg, each.rest WHILE each # NIL DO
                ENABLE UNWIND => LOOP;
                IF each.first.proc#NIL THEN each.first.proc[each.first.data, idleState, newState];
                ENDLOOP;
            };

        IsKeyDown: PROC [watch: KeyFilter] RETURNS [BOOL] = {
            IF ViewersWorldInstance.GetWorld[]#idleWorld THEN RETURN [FALSE];
            FOR k: KeyCode IN [watch.first .. watch.last] DO
                IF UserInputOps.GetLatestKeyState[ViewersWorld.GetInputHandle[idleWorld], k] = down
                    AND watch.pass[k] THEN RETURN[TRUE];
                ENDLOOP;
            RETURN[FALSE];
            };

        WaitForLogin: PROC ~ {
            SIGNAL NotYetImplemented;
            };

        NotYetImplemented: SIGNAL = CODE;

        DoLogin: PROC RETURNS [wake: BOOL Ź TRUE] = {
            };

        <<defaultKeyFilter: PUBLIC KeyFilter _ [first: 13, last: 111, pass: ALL[TRUE]];>>
        defaultKeyFilter: PUBLIC KeyFilter Ź [first: VAL[1], last: VAL[125], pass: ALL[TRUE]];
        DefaultKeyFilter: PROC RETURNS [KeyFilter] ~ {
            FirstKeyCode: PROC [mapping: KeyMapping.Mapping, keySym: KeyTypes.KeySym] RETURNS [keyCode: KeyTypes.KeyCode Ź keycode0] = {
                keyCodes: KeyMapping.KeyCodes ~ KeyMapping.KeyCodesFromKeySym[mapping, keySym]; 
                IF keyCodes.n>0 THEN RETURN [keyCodes[0].keyCode]
                };
            filter: KeyFilter Ź [first: VAL[1], last: VAL[125], pass: ALL[TRUE]];
            handle: UserInput.Handle Ź ViewersWorld.GetInputHandle[idleWorld];
            mapping: KeyMapping.Mapping ~ UserInputOps.GetMapping[handle];
            lockCode1, lockCode2, controlCode, leftShiftCode, rightShiftCode, leftMouseCode, middleMouseCode, rightMouseCode: KeyCode;
            lockCode1 Ź FirstKeyCode[mapping, KeySymsKB.ShiftLock].keyCode;
            lockCode2 Ź FirstKeyCode[mapping, KeySymsKB.CapsLock].keyCode;
            controlCode Ź FirstKeyCode[mapping, KeySymsKB.LeftControl].keyCode;
            leftShiftCode Ź FirstKeyCode[mapping, KeySymsKB.LeftShift].keyCode;
            rightShiftCode Ź FirstKeyCode[mapping, KeySymsKB.RightShift].keyCode;
            leftMouseCode Ź FirstKeyCode[mapping, SpecialKeySyms.Button1].keyCode;
            middleMouseCode Ź FirstKeyCode[mapping, SpecialKeySyms.Button2].keyCode;
            rightMouseCode Ź FirstKeyCode[mapping, SpecialKeySyms.Button3].keyCode;
            filter.pass[lockCode1] Ź FALSE;
            filter.pass[lockCode2] Ź FALSE;
            filter.pass[controlCode] Ź FALSE;
            filter.pass[leftShiftCode] Ź FALSE;
            filter.pass[rightShiftCode] Ź FALSE;
            filter.pass[leftMouseCode] Ź FALSE;
            filter.pass[middleMouseCode] Ź FALSE;
            filter.pass[rightMouseCode] Ź FALSE;
            RETURN[filter];
            };

    <<Idle Registry (exported to Idle)>>

        SimpleReg: TYPE = REF SimpleRegPrivate;
        SimpleRegPrivate: TYPE = RECORD [
            handler: IdleHandler,
            data: REF ANY
            ];

        IsIdle: PUBLIC PROC RETURNS [BOOL] = {
            RETURN [idleState # unidle];
            };
            <<>>
        RegisterIdleHandler: PUBLIC PROC [handler: IdleHandler, data: REF Ź NIL] RETURNS [IdleRegistration]= {
            sr: SimpleReg Ź NEW [SimpleRegPrivate Ź [handler, data]];
            RETURN [RegisterFullIdleHandler[Simplify, sr]];
            };

        Simplify: PROC [data: REF ANY, old, new: Activity] --FullIdleHandler-- ~ {
            sr: SimpleReg ~ NARROW[data];
            IF old=unidle AND new=idle THEN sr.handler[sr.data, becomingIdle]
            ELSE IF old=loggingIn AND new=unidle THEN sr.handler[sr.data, becomingBusy];
            };

        UnregisterIdleHandler: PUBLIC PROC [registration: IdleRegistration] = {
            UnregisterFullIdleHandler[registration];
            };

    <<Sleep stuff (exported to Idle)>>

        sleepMillis: [10..2000] Ź 150;
        xVel: INTEGER Ź 2;
        yVel: INTEGER Ź 1;
        sleepEraseOld: BOOL Ź TRUE;
        sleepWaitFactor: [5..100] Ź 20;
        ticksPerSecond: Process.Ticks = Process.SecondsToTicks[1];

        WaitForIdle: PUBLIC ENTRY PROC [idle: BOOL] ~ {
            WHILE idleState # idle DO WAIT becomeIdle ENDLOOP;
            };

        DoASleep: PUBLIC PROC ~ {
            an: Animator Ź animatorStack.first;
            BecomeIdle[];
            an.Animate[idleWorld, IsKeyDown, an.data];
            OutOfIdle[];
            ViewerOps.PaintEverything[];
            };

        Sleep: PUBLIC PROC [proc: Idle.ImageProc Ź DefaultImageProc, powerOff: BasicTime.GMT Ź BasicTime.nullGMT] = {
            IF proc=DefaultImageProc THEN DoASleep[] ELSE {
                an: Animator;
                TRUSTED {an Ź NEW [AnimatorPrivate Ź [Bounce, NEW [Idle.ImageProc Ź proc]]]};
                PushAnimator[an];
                DoASleep[];
                PopAnimator[];
                };
            };

        StringEscapement: PROC [font: ImagerFont.Font, string: ImagerFont.XStringProc, amplifySpace: REAL] RETURNS [ImagerFont.VEC] = {
            sum: ImagerFont.VEC Ź [0, 0];
            charAction: ImagerFont.XCharProc ~ {
                width: ImagerFont.VEC;
                width Ź ImagerFont.Escapement[font, char];
                IF ImagerFont.Amplified[font, char] THEN {
                    width.x Ź width.x*amplifySpace;
                    width.y Ź width.y*amplifySpace;
                    };
                sum.x Ź sum.x+width.x; sum.y Ź sum.y+width.y;
                };
            string[charAction];
            RETURN[sum];
            };

        RopeEscapement: PROC [font: ImagerFont.Font, rope: Rope.ROPE, amplifySpace: REAL,
        start: INT Ź 0, len: INT Ź INT.LAST] RETURNS [ImagerFont.VEC] ~ {
            string: ImagerFont.XStringProc ~ { ImagerFont.MapRope[rope, start, len, charAction] };
            RETURN[StringEscapement[font, string, amplifySpace]];
            };

        DoNothing: NotifyProc = {};

        NullContextCreator: PROC
        [screenServerData: REF, screen: ViewerPrivate.Screen] RETURNS [Imager.Context] = {
            sm: ImagerSample.SampleMap = ImagerSample.NewSampleMap[box: [max: [1, 1]]];
            RETURN [ImagerBackdoor.BitmapContext[sm]]
            };

        BecomeIdle: ENTRY PROC = {
            idleState Ź idle;
            idleContext Ź ViewerPrivate.CreateContext[main];
            InputFocus.CaptureButtons[DoNothing, TIPPrivate.DefaultTable[FALSE]];
            oldContextCreatorProc Ź ViewerPrivate.SetCreator[NullContextCreator];
            BROADCAST becomeIdle;
            };

        OutOfIdle: ENTRY PROC = {
            idleState Ź unidle;
            idleContext Ź NIL;
            InputFocus.ReleaseButtons[];
            [] Ź ViewerPrivate.SetCreator[oldContextCreatorProc];
            BROADCAST outOfIdle;
            };

        idleContext: Imager.Context; -- context for Idle to use
        oldContextCreatorProc: ViewerPrivate.ContextCreatorProc;
            <<BecomeIdle will change the Viewers context creator to a Null creator and save the old creator in oldContextCreatorProc.  
            OutOfIdle will restore the Viewers context creator from oldContextCreatorProc.>>

        ColorScreen: PROC [screen: ViewerPrivate.Screen, color: Imager.Color] = {
            <<ignores screen.  Uses idle context.>>
            <<Color the entire screen with the given color.>>
            colorAction: PROC [context: Imager.Context] ~ {
                Imager.SetColor[context, color];
                Imager.MaskRectangleI[context, 0, 0, 9999, 9999];
                };
            PaintScreen[screen, colorAction];
            };

        PaintScreen: PROC [screen: ViewerPrivate.Screen, action: PROC [context: Imager.Context] ] = {
            <<ignores screen.  Uses idle context.>>
            IF idleContext=NIL THEN RETURN;
            action[idleContext ! UNWIND => CONTINUE;];
            };

        Bounce: PROC [world: ViewersWorld.Ref, ShouldReturn: PROC [watch: KeyFilter] RETURNS [BOOL], data: REF ANY Ź NIL] = TRUSTED {
            proc: Idle.ImageProc ~ WITH data SELECT FROM
                x: REF Idle.ImageProc => x­,
                ENDCASE => IF data=NIL THEN DefaultImageProc ELSE ERROR;
            width: NAT Ź ViewersWorld.GetSize[world].width; 
            height: NAT Ź ViewersWorld.GetSize[world].height;
            x: NAT Ź (width / 8)*3;
            y: NAT Ź (height / 8)*3;
            image: Rope.ROPE Ź "Type Key";
            font: Imager.Font Ź Imager.FindFontScaled["Xerox/XC1-2-2/Helvetica", 14.0];
            vec: ImagerFont.VEC Ź RopeEscapement[font, image, 1.0];
            fontExtents: ImagerFont.Extents Ź ImagerFont.RopeBoundingBox[font, image];
            imageWidth: NAT Ź Real.Ceiling[vec.x];
            descent: INTEGER Ź Real.Ceiling[fontExtents.descent];
            imageHeight: NAT Ź descent + Real.Ceiling[fontExtents.ascent];
            termW: NAT = width;
            maxW: NAT = termW - termW/4;
            termH: NAT = height;
            maxH: NAT = termH - termH/4;

            <<ViewerPrivate.>>ColorScreen[main, Imager.black];
            DO
                mark: BasicTime.Pulses Ź BasicTime.GetClockPulses[];
                w: CARDINAL Ź 0;
                h: CARDINAL Ź 0;
                oldX: INTEGER Ź x;
                oldY: INTEGER Ź y;
                IF image # NIL THEN {
                    newX: INTEGER Ź x + xVel;
                    newY: INTEGER Ź y + yVel;
                    xLim: INTEGER Ź newX + (w Ź MIN[imageWidth, maxW]);
                    yLim: INTEGER Ź newY + (h Ź MIN[imageHeight, maxH]);

                    <<Reflect off of the left or right>>
                    SELECT TRUE FROM
                        newX < 0 => {
                            newX Ź 0;
                            xLim Ź newX + w;
                            xVel Ź - xVel;
                            };
                        xLim > termW => {
                            xLim Ź termW;
                            newX Ź xLim - w;
                            xVel Ź - xVel;
                            };
                        ENDCASE;

                    <<Reflect off of the top or bottom>>
                    SELECT TRUE FROM
                        newY < 0 => {
                            newY Ź 0;
                            yLim Ź newY + h;
                            yVel Ź - yVel;
                            };
                        yLim > termH => {
                            yLim Ź termH;
                            newY Ź yLim - h;
                            yVel Ź - yVel;
                            };
                        ENDCASE;

                    x Ź newX;
                    y Ź newY;
                    };
                IF proc # NIL THEN {
                    image Ź proc[w: w, h: h];
                    IF sleepEraseOld THEN {
                        PaintRectangleBlack: SAFE PROC [context: Imager.Context] = CHECKED {
                            Imager.SetColor[context, Imager.black];
                            Imager.MaskRectangleI[context, oldX, oldY-descent, w, h];
                            };
                        <<unpaint old image>>
                        <<ViewerPrivate.>>PaintScreen[main, PaintRectangleBlack];
                        <<ViewerPrivate.ColorScreen[main, Imager.black];>>
                        };
                    IF image # NIL THEN {
                        DrawRope: SAFE PROC [context: Imager.Context] = TRUSTED {
                            Imager.SetXY[context, [x, y]];
                            Imager.SetFont[context, font];
                            Imager.SetColor[context, Imager.white];
                            Imager.ShowRope[context, image];
                            };
                        <<ViewerPrivate.>>PaintScreen[main, DrawRope];
                        };
                    };
                {
                    <<This is an adaptive loop intended to keep the overhead of the idle loop small.  We don't get out until the elapsed time from the 
                    start is sleepWaitFactor times the elapsed time taken to do the screen update.>>
                    limit: BasicTime.Pulses Ź (BasicTime.GetClockPulses[] - mark)*sleepWaitFactor;
                    DO
                        IF ShouldReturn[defaultKeyFilter] THEN GO TO done;
                        Process.Pause[2];
                        <<IF (BasicTime.GetClockPulses[] - mark) > limit THEN EXIT;>>
                        IF BasicTime.Pulses[BasicTime.GetClockPulses[] - mark] > limit THEN EXIT;
                        ENDLOOP;
                    EXITS done => EXIT;
                    };
                ENDLOOP;
            };

        DefaultImageProc: PUBLIC Idle.ImageProc = {RETURN["Type Key"]};
        defaultAnimator: PUBLIC Animator ~ NEW [AnimatorPrivate Ź [Bounce, NIL]];

        nRandoms: CARDINAL = 20;
        RandIndex: TYPE = [0..nRandoms);
        randTable: ARRAY RandIndex OF CARDINAL Ź [
            30200, 27432, 62096, 39855, 17884, 58726, 55595, 20904, 28164, 27447,
            34709, 35231, 33770, 31508, 40689, 1411, 20373, 3422, 62938, 40035];

        startTime: BasicTime.GMT;
        randIndex: RandIndex Ź 0; -- initialized by Start trap

        Random: PROC RETURNS [r: CARDINAL] = {
            <<This algorithm is stolen from DMT.>>
            i: RandIndex;
            randIndex Ź IF randIndex = LAST[RandIndex] THEN FIRST[RandIndex] ELSE SUCC[randIndex];
            i Ź (randIndex + 3) MOD nRandoms;
            r Ź randTable[i] Ź randTable[randIndex] + randTable[i];
            };

        UpdateAndClip: PROC [v: CARDINAL, limit: CARDINAL, scale: CARDINAL Ź 16]
        RETURNS [newV: CARDINAL Ź 0] = INLINE {
            r: CARDINAL = Random[];
            x: INTEGER Ź v;
            x Ź x +
                (SELECT TRUE FROM
                    Basics.BITAND[r, 100000B] ~= 0 => 0,
                    Basics.BITAND[r, 40000B] ~= 0  => scale,
                    ENDCASE => -scale);
            RETURN [
                SELECT x FROM
                    < 0 => limit - scale,
                    >= INTEGER[limit - scale] => 0,
                    ENDCASE => x
                ]  
            };

    <<Initialization>>

    StartIdleProcesses: PUBLIC PROC [] = {
        idleWorld Ź ViewersWorldInstance.GetWorld[];
        defaultKeyFilter Ź DefaultKeyFilter[];
        startTime Ź BasicTime.Now[
        ! BasicTime.TimeNotKnown => { startTime Ź BasicTime.earliestGMT; CONTINUE } ];
        randIndex Ź Basics.LowHalf[BasicTime.ToPupTime[startTime]] MOD nRandoms;
        MultiCursors.SetACursorOffset[-16, -16, TRUE, NIL];
        animatorStack Ź LIST[defaultAnimator];
        };

    END.