
    <<XNSPrintRequestWatcher.mesa>>
        <<Copyright © 1985 by Xerox Corporation.  All rights reserved.>>
        <<Bloomenthal, October 29, 1986 10:03:43 pm PST>>
        <<Bill Jackson (bj) February 6, 1987 5:39:11 am PST>>
    <<>>
    DIRECTORY
        Buttons USING [ButtonProc, Create, Destroy],
        CedarProcess USING [Fork, ForkableProc],
        Commander USING [CommandProc, Register],
        Imager USING [black, MaskRectangle, SetColor, white],
        ImagerBackdoor USING [GetBounds],
        IO USING [card, PutFR, PutRope, rope, STREAM],
        PrintingP4V3 USING [RequestID],
        PrintingP4V3Aux USING [ExposeInterpressMasterStatus],
        Rope USING [ROPE],
        TypeScript USING [Create],
        UserProfile USING [Boolean],
        ViewerClasses USING [AdjustProc, DestroyProc, PaintProc, Viewer, ViewerClass, ViewerClassRec],
        ViewerIO USING [CreateViewerStreams],
        ViewerOps USING [CreateViewer, EnumerateViewers, EnumProc, EstablishViewerPosition, OpenIcon, RegisterViewerClass],
        XNSPrintRequestManager USING [GetPrintRequestList, GetPrintRequestStatus, ListChanged, PrintRequest, PrintRequestList, 
        RequestStatus];

    XNSPrintRequestWatcher: CEDAR MONITOR
        IMPORTS Buttons, CedarProcess, Commander, Imager, ImagerBackdoor, IO, PrintingP4V3Aux, TypeScript, UserProfile, ViewerIO, 
        ViewerOps, XNSPrintRequestManager ~ {
        OPEN Printing: PrintingP4V3, PrintingAux: PrintingP4V3Aux, XNSPrintRequestManager;

    <<Commander Constants>>

        XNSPrintRequestWatcher: ROPE ~    "XNSPrintRequestWatcher";
        doc: ROPE ~ "\nCreate viewer to monitor and/or manipulate XNS print requests";
        usage: ROPE ~ "Usage: XNSPrintRequestWatcher";

        NAMESTRIPE: ROPE ~ "Print Request Manipulation";
        TYPESCRIPT: ROPE ~ "///Temp/XNSPrintRequestWatcher.TypeScript";
        <<>>
    <<UserProfile Tags>>

        AUTOOPEN: ROPE ~ "HardcopyWatcher.AutoOpen";
        <<>>
    <<Global State>>
        <<>>
        pendingPrintRequests: PrintRequestList _ NIL;
        printManipViewerClass: ViewerClasses.ViewerClass;
        watcher: Data _ NIL;

    <<Types>>
        <<>>
        ButtonList: TYPE ~ LIST OF Viewer;
        ROPE: TYPE ~ Rope.ROPE;
        Viewer: TYPE ~ ViewerClasses.Viewer;

        Data: TYPE ~ REF DataRec;
        DataRec: TYPE ~ RECORD [
            actualRequest: PrintRequest _ NIL, -- only for the ButtonProc
            autoOpen: BOOL _ FALSE,
            buttons: ButtonList _ NIL,
            requests: PrintRequestList _ NIL,
            typeScript: Viewer _ NIL,
            typeScriptIn: IO.STREAM _ NIL,
            typeScriptOut: IO.STREAM _ NIL,
            viewer: Viewer _ NIL
            ];

    <<Display update Procs>>

        WaitTilListChanged: ENTRY PROC ~ {
            WAIT ListChanged;
            };

        WatchRequestList: CedarProcess.ForkableProc ~ {
            enum: ViewerOps.EnumProc ~ {
                IF (v.class = printManipViewerClass) THEN UpdateViewer[NARROW [v.data]];
                };
            DO 
                WaitTilListChanged[];
                ViewerOps.EnumerateViewers[enum];
                ENDLOOP;
            };
        <<>>
    <<Procs guarding "watcher" state>>

        ClearWatcher: ENTRY PROC ~ {
            watcher _ NIL;
            };

        ConditionallySetWatcher: ENTRY PROC [new: Data] RETURNS [old: Data] ~ {
            old _ watcher;
            IF (watcher = NIL) THEN watcher _ new;
            };

    <<Commander Proc>>
        <<>>
        RequestWatcherCmd: Commander.CommandProc ~ {
            data: Data _ NEW [DataRec];
            otherGuy: Data _ ConditionallySetWatcher[data];

            IF (otherGuy # NIL) THEN {
                UpdateViewer[otherGuy, TRUE];
                RETURN;
                };

            data.autoOpen _ UserProfile.Boolean[AUTOOPEN, FALSE];

            data.viewer _ ViewerOps.CreateViewer[
                flavor: $XNSPrintRequestWatcher,
                info: [name: NAMESTRIPE, data: data]
                ];

            data.typeScript _ TypeScript.Create[[parent: data.viewer, border: TRUE, wh: 60]];
            [data.typeScriptIn, data.typeScriptOut] _ ViewerIO.CreateViewerStreams[NIL, data.typeScript, TYPESCRIPT];

            TypeScriptWrite[data, "Beginning of Typescript...\n"];
            UpdateViewer[data];
            };

    <<Viewer Procs>>
        <<>>
        TypeScriptWrite: PUBLIC PROC [data: Data, rope: ROPE] ~ {
            IF (data.typeScriptOut # NIL) THEN IO.PutRope[data.typeScriptOut, rope];
            };

        AdjustProc: ViewerClasses.AdjustProc ~ {
            data: Data _ NARROW [self.data];
            nButtons: NAT _ 0;
            height: INTEGER _ self.wh-12;
            FOR buttons: ButtonList _ data.buttons, buttons.rest WHILE (buttons # NIL) DO
                button: Viewer _ buttons.first;
                nButtons _ nButtons+1;
                ViewerOps.EstablishViewerPosition[button, 0, (height-(20*nButtons)), button.ww, button.wh];
                ENDLOOP;
            ViewerOps.EstablishViewerPosition[data.typeScript, 0, 0, self.ww, (height-(20*nButtons)-4)];
            RETURN[TRUE];
            };

        DestroyProc: ViewerClasses.DestroyProc ~ {
            data: Data _ NARROW [self.data];
            ClearWatcher[];
            };

        PaintProc: ViewerClasses.PaintProc = {
            data: Data _ NARROW [self.data];

            IF (whatChanged = NIL) THEN {
                Imager.SetColor[context, Imager.white];
                Imager.MaskRectangle[context, ImagerBackdoor.GetBounds[context]];
                Imager.SetColor[context, Imager.black];
                };
            };

        UpdateViewer: PROC [data: Data, forceOpen: BOOL _ FALSE] ~ {
            data.requests _ GetPrintRequestList[];
            MakeButtons[data];
            IF ( (data.autoOpen) OR (forceOpen) ) THEN {
                IF (data.viewer.iconic) THEN ViewerOps.OpenIcon[data.viewer];
                };
            };

    <<Button Procs>>
        <<>>
        ButtonProc: Buttons.ButtonProc ~ {
            data: Data _ NARROW [clientData];
            msg: ROPE _ NIL;
            request: PrintRequest _ data.actualRequest;
            requestStatus: RequestStatus;

            TypeScriptWrite[data, "Checking: "];
            TypeScriptWrite[data, data.actualRequest.fileName];
            TypeScriptWrite[data, "\n"];

            requestStatus _ XNSPrintRequestManager.GetPrintRequestStatus[request];
            msg _ PrintingAux.ExposeInterpressMasterStatus[requestStatus.status, 1];
            TypeScriptWrite[data, "status: ("];
            TypeScriptWrite[data, msg];
            TypeScriptWrite[data, ") statusMessage: "];
            TypeScriptWrite[data, requestStatus.statusMessage];
            TypeScriptWrite[data, "\n"];
            };

        MakeButtons: PROC [data: Data] ~ {
            FOR buttons: ButtonList _ data.buttons, buttons.rest WHILE (buttons # NIL) DO
                Buttons.Destroy[buttons.first];
                ENDLOOP;

            data.buttons _ NIL;

            FOR pr: PrintRequestList _ data.requests, pr.rest WHILE (pr # NIL) DO
                MakeButton[pr.first, data];
                ENDLOOP;

            [] _ AdjustProc[data.viewer];
            };

        MakeButton: PROC [request: PrintRequest, data: Data] ~ {
            buttonName: ROPE _ NIL;
            id: ROPE _ NIL;
            IF (request = NIL) THEN RETURN;
            FOR n: NAT IN [0..5) DO
                id _ IO.PutFR["%g %g", IO.rope[id], IO.card[request.requestID[n]]];
                ENDLOOP;
            buttonName _ IO.PutFR["%g %g %g",
                IO.rope[request.context.printerName], IO.rope[id], IO.rope[request.fileName]];
            data.actualRequest _ request;
            data.buttons _ CONS[
                Buttons.Create[
                    info: [parent: data.viewer, name: buttonName], 
                    proc: ButtonProc,
                    clientData: data
                    ],
                    data.buttons
                ];
            };

    <<Initialization>>

        Init: PROC ~ {
            printManipViewerClass _ NEW[ViewerClasses.ViewerClassRec _ [
                paint: PaintProc,
                adjust: AdjustProc,
                destroy: DestroyProc
                ]];

            ViewerOps.RegisterViewerClass[$XNSPrintRequestWatcher, printManipViewerClass];
            Commander.Register[XNSPrintRequestWatcher, RequestWatcherCmd, doc];
            [] _ CedarProcess.Fork[WatchRequestList];
            };

    Init[];

    }...