
    <<CDColorPDPlot.mesa  >>
        <<Jacobi, March 25, 1986 5:17:14 pm PST>>
        <<gbb April 4, 1986 7:44:07 pm PST>>
        <<>>
        <<Copyright © 1983, 1986 by Xerox Corporation.  All rights reserved.>>
        <<written by E. McCreight,  August 1, 1983  2:00 PM>>
        <<Last Edited by: McCreight,  November 23, 1983 4:58 pm>>
        <<Last Edited by: Jacobi,  October 27, 1983 12:36 pm>>
        <<Last Edited by: Jacobi,  April 11, 1985 3:21:48 pm PST>>
        <<Last Edited by: Kimr,  October 29, 1984 9:49:48 am PST>>

    DIRECTORY
        CD,
        CDBasics,
        CDCommandOps,
        CDDefaultProcs,
        CDIO,
        CDVArrow,
        CDPolygons,
        CDMenus,
        CDOps,
        CDOrient,
        CDProperties,
        CDSequencer,
        CDValue,
            GraphicsBasic,
            CGArea,
            CGClipper,
            CGReducer,
        Commander,
        CStitching,
        IO,
        PDFileFormat,
        PDFileWriter,
        Process,
        Real,
        Rope,
        TerminalIO,
        ViewerClasses,
        ViewerSpecs;

    CDColorPDPlot: CEDAR PROGRAM
        IMPORTS CD, CDBasics, CDCommandOps, CDDefaultProcs, CDIO, CDMenus, CDValue, CDVArrow, CDOps, CDOrient, CDPolygons, CDProperties, 
        CDSequencer, CGArea, CGClipper, CGReducer, Commander, CStitching, IO, PDFileWriter, Process, Real, TerminalIO =
    BEGIN

    plottingInProgress: BOOL _ FALSE;

    <<--handling colors>>

    Toner: TYPE = PDFileFormat.Toner;  -- {black, cyan, magenta, yellow, .. 15};
    TonerKeys: TYPE = ARRAY Toner OF REF;
    LoadArray: TYPE = ARRAY Toner OF PDFileWriter.LoadReference;
    ColorDescription: TYPE = ARRAY CD.Layer OF REF LoadArray _ ALL[NIL];

    whiteLoadRef: PDFileWriter.LoadReference = LAST[PDFileWriter.LoadReference]; 
        <<-- used to identify tiles without toner so that you can avoid recording them>>

    tonerToKeyKeys: REF TonerKeys = NEW[TonerKeys _ ALL[NIL]];
        <<--gives a key to get the keys to get the color stipple as property of the layers >>
    <<>>
    <<--device description>>

    deviceCode: PDFileFormat.DeviceCode _ last;  
    sRes: CARDINAL _ 200;  -- resolution (slow directition), pixels / inch
    fRes: CARDINAL _ 200;  -- resolution (fast direction), pixels / inch
    scanLineWidth: CARDINAL _ 8000; --for the wide-bed Versatec, length in the "fast" direction;
    toners: PDFileWriter.TonerSet _ ALL[FALSE];
    leftOverMode: BOOL _ FALSE;

    bandSSize: CARDINAL _ 64;  -- number chosen because of buffer-size of versatec
    overLap: CARDINAL _ 300;  -- number of pixels by which to overlap strips
    maxPixPerLambda: NAT _ 20; -- maximum # of pixels to make lambda

    paged: BOOL _ FALSE;
    slowLimited: BOOL _ FALSE; --only interesting if ~paged
        pageSlowSize: CARDINAL _ 0; --only interesting if paged or slowLimited

    stippleKey: ATOM _ $CDxVersatec;
    tonerToKey: REF TonerKeys _ NIL;
        <<--gives a key to get the color stipple as property of the layers >>


    ColorVersatec: PROC [] =
        BEGIN
        deviceCode _ last;   --does not yet has an assigned value, use "last"
        sRes _ 200;  -- resolution (slow directition), pixels / inch
        fRes _ 200;  -- resolution (fast direction), pixels / inch
        scanLineWidth _ 8000; --for the wide-bed Versatec, length in the "fast" direction;
        toners _ ALL[FALSE];
        toners[black] _ TRUE;
        toners[cyan] _ TRUE;
        toners[magenta] _ TRUE;
        toners[yellow] _ TRUE;
        bandSSize _ 64;  -- number chosen because of buffer-size of versatec
        overLap _ 300;  -- number of pixels by which to overlap strips
        maxPixPerLambda _ 20; -- maximum # of pixels to make lambda
        paged _ slowLimited _ FALSE;
        leftOverMode _ FALSE;
        stippleKey _ $CDxVersatec;
        TerminalIO.WriteRope["color versatec"];
        END;

    InkJetC150: PROC [] =
        BEGIN
        deviceCode _ VAL[10];  
        sRes _ 120;  -- resolution (slow directition), pixels / inch
        fRes _ 120;  -- resolution (fast direction), pixels / inch
        scanLineWidth _ 1020; 
        toners _ ALL[FALSE];
        toners[black] _ TRUE;
        toners[cyan] _ TRUE;
        toners[magenta] _ TRUE;
        toners[yellow] _ TRUE;
        bandSSize _ 48;  -- 
        overLap _ 30;  -- number of pixels by which to overlap strips
        maxPixPerLambda _ 20; -- maximum # of pixels to make lambda
        paged _ FALSE;
        slowLimited _ TRUE;
        pageSlowSize _ 1020;
        leftOverMode _ FALSE;
        stippleKey _ $CDxVersatec;
        TerminalIO.WriteRope["ink jet"];
        END;

    Color400: PROC [] =
        BEGIN
        deviceCode _ VAL[9];  
        sRes _ 400;  -- resolution (slow directition), pixels / inch
        fRes _ 400;  -- resolution (fast direction), pixels / inch
        scanLineWidth _ 4096; 
        toners _ ALL[FALSE];
        toners[black] _ TRUE;
        toners[cyan] _ TRUE;
        toners[magenta] _ TRUE;
        toners[yellow] _ TRUE;
        bandSSize _ 50;  -- 
        overLap _ 30;  -- number of pixels by which to overlap strips
        maxPixPerLambda _ 240; -- maximum # of pixels to make lambda
        paged _ TRUE;
        pageSlowSize _ 5500;
        leftOverMode _ FALSE;
        stippleKey _ $CDxC400;
        TerminalIO.WriteRope["Color400"];
        END;

    Puffin: PROC [] =
        BEGIN
        deviceCode _ PDFileFormat.DeviceCode[puffin];  
        sRes _ 384;  -- resolution (slow directition), pixels / inch
        fRes _ 384;  -- resolution (fast direction), pixels / inch
        scanLineWidth _ fRes * 17 / 2; 
        toners _ ALL[FALSE];
        toners[black] _ FALSE;
        toners[cyan] _ TRUE;
        toners[magenta] _ TRUE;
        toners[yellow] _ TRUE;
        bandSSize _ 16;  -- 
        overLap _ 30;  -- number of pixels by which to overlap strips
        maxPixPerLambda _ 20; -- maximum # of pixels to make lambda
        paged _ TRUE;
        pageSlowSize _ sRes*11;
        leftOverMode _ TRUE;
        stippleKey _ $CDxPuffin;
        TerminalIO.WriteRope["Puffin"];
        END;

    PlateMaker: PROC [] =
        BEGIN
        deviceCode _ PDFileFormat.DeviceCode[last];  
        sRes _ 1200;  -- resolution (slow directition), pixels / inch
        fRes _ 1200;  -- resolution (fast direction), pixels / inch
        scanLineWidth _ fRes * 17 / 2; 
        toners _ ALL[FALSE];
        toners[black] _ TRUE;
        toners[cyan] _ FALSE;
        toners[magenta] _ FALSE;
        toners[yellow] _ FALSE;
        bandSSize _ 16;  -- 
        overLap _ 30;  -- number of pixels by which to overlap strips
        maxPixPerLambda _ 20; -- maximum # of pixels to make lambda
        paged _ TRUE;
        pageSlowSize _ sRes*11;
        leftOverMode _ TRUE;
        stippleKey _ $CDxRaven;
        TerminalIO.WriteRope["Raven or platemaker"];
        END;

    <<--state of the plot>>

    technologyPropertyKey: REF _ $CDxLastTechnology; --a property of the stippleKey

    abortPlot: REF BOOL _ NEW[BOOL _ FALSE];

    PlotStateRef: TYPE = REF PlotState;
    PlotState: TYPE = RECORD [
        tes: ARRAY CD.Layer OF CStitching.Tesselation _ ALL[NIL], 
        scale: REAL _ 1.0, -- pixels per CD.Number
        totalPlotClip, bandClip: CD.Rect _ [0, 0, 0, 0],
            <<--rectangles in design space touching all geometry in the plot, or this band>>
        pdState: PDFileWriter.PDState,
        colorLoads: REF ColorDescription,
        anouncedLayer: INT _ -1
        ];

    pdy: CARDINAL _ 0;     -- top of band in pixel coords
        <<xoffset: INT _ -stripClip.x1*scale; >>
        <<yoffset: INT _ stripClip.y2*scale; >>
    stripClip: CD.Rect;        -- clip for a page; not reduced to real design clip
    plotScale: REAL;  
    imageSSize: CARDINAL;
    imageFSize: CARDINAL;

    ps: PlotStateRef;

    PrepareContextFilter: PROC [] =
        BEGIN
        contextFilter^ _ ALL[FALSE];
        FOR l: CD.Layer IN CD.Layer DO
            FOR toner: Toner IN Toner DO
                IF tonerToKey[toner]#NIL AND CDProperties.GetLayerProp[from: l, prop: tonerToKey[toner]]#NIL THEN {
                    contextFilter^[l] _ TRUE;
                    EXIT
                    };
                ENDLOOP;
            ENDLOOP;
        END;

    CheckStipples: PROC [technology: CD.Technology] =
        BEGIN
        x: REF _ CDValue.Fetch[technology, stippleKey];
        WITH x SELECT FROM
            r: Rope.ROPE => TerminalIO.WriteRopes["color stipples used: [", r, "]\n"];
            ENDCASE => {
                TerminalIO.WriteRope["**color stipples are not defined\n"];
                ERROR ABORTED
                };
        IF technology.key#CDProperties.GetAtomProp[stippleKey, technologyPropertyKey] THEN
            TerminalIO.WriteRope["**Warning: another technology registered in the meantime; the technology independent stipples are 
            redefined\n"];
        tonerToKey _ NEW[TonerKeys _ ALL[NIL]];
        FOR t: PDFileWriter.Toner IN PDFileWriter.Toner DO
            tonerToKey^[t] _ CDProperties.GetAtomProp[stippleKey, tonerToKeyKeys[t]];
            IF ~toners[t] OR tonerToKey^[t]=NIL THEN {
                toners[t] _ FALSE;
                tonerToKey^[t] _ NEW[INT];
                } 
            ENDLOOP;
        PrepareContextFilter[];
        END;

    ClipArea: PROC [comm: CDSequencer.Command] RETURNS [plotClip: CD.Rect] =
        BEGIN
        SELECT TerminalIO.RequestSelection["Plot", LIST["complete design", "rectangle"]] FROM
            2 => {
                plotClip _ CDBasics.ToRect[comm.pos, comm.sPos];
                TerminalIO.WriteRope["plot rectangle\n"];
                };
            ENDCASE => {
                plotClip _ CDCommandOps.BoundingBox[comm.design];
                TerminalIO.WriteRope["plot all\n"];
                };
        IF plotClip.x1>=plotClip.x2 OR plotClip.y1>=plotClip.y2 THEN {
            TerminalIO.WriteRope["**cannot plot empty area\n"];
        ERROR ABORTED
            };
        END;

    ProtectedPlotDesign: PROC [comm: CDSequencer.Command] =
        BEGIN
            <<--ENABLE UNWIND => plottingInProgress _ FALSE; >>
            <<--dont, we better wait longer...>>
        design: CD.Design = comm.design;
        plotClip: CD.Rect;
        plotSize: CD.Position;
        s: IO.STREAM _ NIL;
        strips: INT;
        plottingInProgress _ TRUE;
        TerminalIO.WriteRope["Starting Color plot for "];
        SELECT comm.key FROM
            $VersatecColorPlot => ColorVersatec[];
            $C150ColorPlot => InkJetC150[];
            $PuffinColorPlot => Puffin[];
            $PlatemakerColorPlot => PlateMaker[];
            $Color400Plot => Color400[];
            ENDCASE => ERROR;
        TerminalIO.WriteLn[];
        CheckStipples[design.technology];
        plotClip _ ClipArea[comm];
        plotSize _ CDBasics.SizeOfRect[plotClip];
        TRUSTED {Process.SetPriority[Process.priorityBackground]};
        strips _ 1;
        IF ~paged AND ~slowLimited THEN {
            IF TerminalIO.Confirm[label: "plot multiple vertical strips", choice: "yes"] THEN
                strips _ TerminalIO.RequestInt["How many vertical strips? [1..10] "];
            };
        strips _ MAX[1, MIN[10, strips]];
        BEGIN 
            ENABLE { -- for ERRORs
                UNWIND => {
                    s _ AbortFile[s];  
                    CDVArrow.RemoveArrow[design]; 
                    TerminalIO.WriteRope[" ** plot aborted ** "]
                    };
                };
            dr: CD.DrawRef = CD.CreateDrawRef[[
                design: design,
                stopFlag: abortPlot,
                drawRect: NoteRectangle,
                drawContext: DrawContext,
                contextFilter: contextFilter
                ]]; 
            scale: REAL _ MIN[
                REAL[maxPixPerLambda] / design.technology.lambda,
                REAL[(scanLineWidth-overLap)*strips+overLap] / plotSize.x
                ];
                <<--Center the x range of the selected area of the design on the plotter bed, with at most maxPixPerLambda pixels per lambda. If 
                multiple strips are called for, overlap adjacent ones by "overLap" pixels.>>
                <<-- total number of pixels across plot = REAL[scanLineWidth]+REAL[scanLineWidth-overLap]*(strips-1))>>
            pageStep: CD.Position;
            pageWidth: CD.Position;

            imageFSize _ scanLineWidth;
            imageSSize _ Real.FixC[plotSize.y*scale]+1;
            IF paged THEN {
                imageSSize _ MIN[imageSSize, pageSlowSize];
                scale _ MIN[scale, REAL[pageSlowSize]/(plotSize.y+1)];
                };

            ps _ NEW[PlotState _ [
                scale: scale,
                totalPlotClip: plotClip,
                colorLoads: NEW[ColorDescription _ ALL[NIL]]
                ]];
            pageStep _ [plotSize.x/strips, plotSize.y];
            pageWidth _ [Real.Round[scanLineWidth/scale], plotSize.y];
            plotScale _ scale;
            dr.devicePrivate _ ps;
            FOR strip: INT IN [0..strips) DO
                localFileName: Rope.ROPE = CDIO.MakeName[wDir: "///temp/", base: "plot", modifier: IO.PutFR["%d", IO.int[strip+1]], ext: "pd"];
                TerminalIO.WriteRopes["Recording strip on file ", localFileName, "\n"];
                stripClip _ [ --but not yet intersected with complete design clip
                    x1:  plotClip.x1+strip*pageStep.x,
                    y1:  plotClip.y1,
                    x2:  plotClip.x1+strip*pageStep.x+pageWidth.x,
                    y2:  plotClip.y2
                    ];
                ps.pdState _ PDFileWriter.Create[
                    fileName: localFileName, 
                    deviceCode: deviceCode, 
                    sResolution: sRes, 
                    fResolution: fRes, 
                    imageSSize: imageSSize, 
                    imageFSize: imageFSize, 
                    bandSSize: bandSSize, 
                    leftOverMode: leftOverMode
                    ];
                ps.colorLoads^ _ ALL[NIL];
                PDFileWriter.StartImage[pdState: ps.pdState, toners: toners];
                <<-- For each band in the strip>>
                FOR bandYtop: INT _ 0, bandYtop+bandSSize WHILE bandYtop<imageSSize DO
                    dc: CD.Rect; --clip for band in design coordinates; little larger than band
                    IF abortPlot^ THEN GOTO AbortPlot;
                    <<-- Determine coordinate transformations>>
                    pdy _ bandYtop;
                    dc _ CDBasics.NormalizeRect[[
                        x1: stripClip.x1-1, 
                        y1: stripClip.y2-Real.Fix[(bandYtop+bandSSize)/scale]-1, 
                        x2: stripClip.x1+Real.Fix[scanLineWidth/scale]+1, 
                        y2: stripClip.y2-Real.Fix[bandYtop/scale]+1
                        ]] ;
                    dr.interestClip _ ps.bandClip _ CDBasics.Intersection[plotClip, dc];
                    <<--Display current band under consideration to pacify user>>
                    CDVArrow.ShowArrow[design: design, pos: [
                        x: (dr.interestClip.x1+dr.interestClip.x2)/2, 
                        y: (dr.interestClip.y1+dr.interestClip.y2)/2]
                        ];
                    <<-- clear previous tessalations >>
                    ps.anouncedLayer _ -1;
                    FOR l: CD.Layer IN CD.Layer DO
                        IF ps.tes[l]#NIL THEN
                            CStitching.ChangeRect[plane: ps.tes[l], rect: CDBasics.universe, new: NIL];
                        ENDLOOP;
                    CDOps.DrawDesign[design, dr]; -- build tesselations of the relevant design rectangle
                    AnalyzeTesselations[ps]; --will actually draw
                    TerminalIO.WriteRope["."];
                    ENDLOOP;  -- for each band in the strip
                PDFileWriter.EndPage[ps.pdState];
                PDFileWriter.Close[ps.pdState];
                TerminalIO.WriteRope["*\n"];
                ENDLOOP;  -- for each strip
            TerminalIO.WriteRope[" finished plot(s)\n"];
            CDVArrow.RemoveArrow[design: design];
            plottingInProgress _ FALSE;
            EXITS
                AbortPlot => {
                    s _ AbortFile[s]; 
                    CDVArrow.RemoveArrow[design]; 
                    TerminalIO.WriteRope[" ** plot aborted ** "]; 
                    };
            END;  -- enable
        END;  -- PlotDesign

    NoteRectangle: PROC [r: CD.Rect, l: CD.Layer, pr: CD.DrawRef] =
        BEGIN
        ps: PlotStateRef = NARROW[pr.devicePrivate];
        IF CDBasics.NonEmpty[r] THEN {
            IF ps.tes[l]=NIL THEN ps.tes[l] _ CStitching.NewTesselation[];
            ps.tes[l].ChangeRect[rect: r, new: $covered];
            };
        END;

    SetColor: PROC [ps: PlotStateRef, lev: CD.Layer] =
        BEGIN
        Stipple16: TYPE = ARRAY[0..16) OF CARDINAL;
        Stipple8: TYPE = ARRAY[0..8) OF [0..256);
        Stipple4: TYPE = ARRAY[0..4) OF [0..16);

        ToTexture: PROC [pattern: REF ANY] RETURNS [texture: Stipple16] =
            <<--tries to convert pattern to a texture stipple>>
            BEGIN
            IF pattern=NIL THEN RETURN[Stipple16[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]; -- should not occur
            WITH pattern SELECT FROM
                s16: REF Stipple16 => texture _ s16^;
                s8: REF Stipple8 => 
                    FOR  i: [0..8) IN [0..8) DO
                        texture[i] _ texture[i+8] _ (256+1)*s8[i];
                        ENDLOOP;
                s4: REF Stipple4 =>
                    FOR  i: [0..4) IN [0..4) DO
                        texture[i] _ texture[i+4] _ texture[i+8] _ texture[i+12] _ s4[i]*1111H;
                        ENDLOOP;
                ENDCASE => RETURN[Stipple16[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0FFFFH]];  -- error texture
            RETURN [texture]
            END; -- ToTexture

        MakeLoadref: PROC [pattern: REF ANY] RETURNS [loadRef: PDFileWriter.LoadReference] =
            TRUSTED BEGIN
            texture: Stipple16 _ ToTexture[pattern];
            loadRef _ PDFileWriter.LoadContiguousColorTile[pdState: ps.pdState, phase: 0, sMin: 0, fMin: 0, sSize: 16, fSize: 16, bitsPtr: 
            @texture];
            END;  -- MakeLoadref

        MakeLoad: PROC [ps: PlotStateRef, lev: CD.Layer] =
            <<--makes the load if it does not already exist>>
            BEGIN
            IF ps.colorLoads^[lev]=NIL THEN {
                ps.colorLoads^[lev] _ NEW[LoadArray];
                FOR toner: Toner IN Toner DO
                    tex: REF _ CDProperties.GetLayerProp[from: lev, prop: tonerToKey[toner]];
                    IF tex=NIL THEN ps.colorLoads^[lev][toner] _ whiteLoadRef
                    ELSE ps.colorLoads^[lev][toner] _ MakeLoadref[tex]
                    ENDLOOP;
                };
            END; --MakeLoad

        <<--SetColor>>
        IF ps.anouncedLayer=lev THEN RETURN;
        IF ps.colorLoads^[lev]=NIL THEN MakeLoad[ps, lev];
        FOR toner: Toner IN Toner DO
            IF ps.colorLoads^[lev][toner] = whiteLoadRef THEN 
                PDFileWriter.SetColorOff[ps.pdState, toner]
            ELSE
                PDFileWriter.SetColorTile[ps.pdState, toner, ps.colorLoads^[lev][toner], transparent];
            ENDLOOP;
        ps.anouncedLayer _ lev
        END;

    contextFilter: REF CD.ContextFilter = NEW[CD.ContextFilter_ALL[TRUE]];

    PlotPolygon: PROC [ob: CD.Object, pos: CD.Position, orient: CD.Orientation] =
        BEGIN

        OutputTrapezoid: PROC [xbotL: REAL, xbotR: REAL, ybot: REAL, xtopL: REAL, xtopR: REAL, ytop: REAL] =
            <<--lower left x, lower right x, lower y, upper left x, upper right x, upper y>>
            BEGIN
            <<--global variables ps, stripClip, plotScale, imageFSize, imageSSize, pdy>>
            <<--x-Fast>>
            <<--y-Slow>>
            PDFileWriter.MaskTrapezoid[
                pdState: ps.pdState, 
                sMin: Real.RoundC[ybot], 
                sSize: Real.RoundC[ytop-ybot], 
                fMin: Real.RoundC[xbotL], 
                fSize: Real.RoundC[xbotR-xbotL], 
                fMinLast: Real.RoundC[xtopL], 
                fSizeLast: Real.RoundC[xtopR-xtopL]
                ];
            END; --OutputTrapezoid

        <<--PlotPolygon>>
        pp: CDPolygons.PolygonPtr = NARROW[ob.specificRef];
        polygon: CGReducer.Ref = CGReducer.New[size: 8];
        tiling: CGArea.Ref = CGArea.New[size: 4];
        clipRef: CGClipper.Ref = CGClipper.New[size: 4];
        clip: GraphicsBasic.Box _ [
            xmin: 0, 
            ymin: pdy, 
            xmax: MIN[(ps.bandClip.x2-stripClip.x1)*plotScale, imageFSize], 
            ymax: MIN[pdy+bandSSize, imageSSize]
            ];
        CGClipper.SetBox[self: clipRef, box: clip];
        CGClipper.Load[self: clipRef, reducer: polygon];
        FOR p: LIST OF CD.Position _ pp.points, p.rest WHILE p#NIL DO
            at: CD.Position = CDOrient.MapPoint[
                pointInCell: p.first,
                cellSize: ob.size,
                cellInstOrient: orient,
                cellInstPos: pos
                ];
            CGReducer.Vertex[self: polygon, v: [
                x: (at.x-stripClip.x1)*plotScale, 
                y: (stripClip.y2-at.y)*plotScale
                ]]
            ENDLOOP;
        CGReducer.Close[polygon];
        CGReducer.Generate[self: polygon, area: tiling];
        UNTIL CGArea.Empty[tiling] DO
            t: GraphicsBasic.Trap = CGArea.Remove[tiling];
            OutputTrapezoid[t.xbotL, t.xbotR, t.ybot, t.xtopL, t.xtopR, t.ytop];
            ENDLOOP;
        END; --PlotPolygon

    DrawContext: PROC [pr: CD.DrawRef, proc: CD.DrawContextLayerProc, ob: CD.Object, pos: CD.Position, orient: CD.Orientation, layer: 
    CD.Layer] =
        BEGIN
        IF CDPolygons.IsPolygon[ob] THEN {
            SetColor[ps, layer];
            PlotPolygon[ob, pos, orient];
            }
        ELSE CDDefaultProcs.DrawContext[pr, proc, ob, pos, orient, layer]
        END;

    AnalyzeTesselations: PROC [ps: PlotStateRef] =
        BEGIN
        FOR lev: CD.Layer IN CD.Layer DO
            IF ps.tes[lev]#NIL THEN {
                SetColor[ps, lev];
                CStitching.EnumerateArea[plane: ps.tes[lev], rect: ps.bandClip, eachTile: ProcessTile, data: ps];
                };
            ENDLOOP;
        END;

    ProcessTile: PROC [tile: CStitching.Tile, data: REF ANY] =
        BEGIN 
        IF tile.value = $covered THEN {
            rightBound, xStart, xStop, yStart, yStop: INT;
            cxStart, cxStop, cyStop, cyStart: CARDINAL;
            sSize, fSize: CARDINAL;
            ps: PlotStateRef = NARROW[data];
            r: CD.Rect = tile.Area;
            <<-- calculate device coords of rectangle>>
            xStart _ Real.Round[(r.x1-stripClip.x1)*plotScale];
            yStop _ Real.Round[(stripClip.y2-r.y1)*plotScale]; 
            xStop _ Real.Round[(r.x2-stripClip.x1)*plotScale];
            yStart _ Real.Round[(stripClip.y2-r.y2)*plotScale];  
            <<-- clip device rectangle>>
            rightBound _ Real.Round[(ps.bandClip.x2-stripClip.x1)*plotScale];
            IF xStart>rightBound OR xStop<0 THEN RETURN;
            IF yStop<pdy OR yStart>MIN[imageSSize, pdy+bandSSize] THEN RETURN;
            <<-- print device rectangle>>
            cxStart _ MAX[xStart, 0];
            cxStop _ MIN[xStop, rightBound, imageFSize];
            cyStart _ MAX[yStart, pdy];
            cyStop _ MIN[yStop, pdy+bandSSize, imageSSize];
            fSize _ cxStop - cxStart;
            sSize _ cyStop - cyStart;
            IF sSize>0 AND fSize>0 THEN PDFileWriter.MaskRectangle[pdState: ps.pdState, sMin: cyStart, fMin: cxStart, sSize: sSize, fSize: 
            fSize];
            };
        END;

    AbortFile: PROC [s: IO.STREAM] RETURNS [IO.STREAM] = {
        IF s#NIL THEN s.Close[abort: TRUE];     
        RETURN[NIL]
        };
    <<>>
    PDColorPlotComm: PROC [comm: CDSequencer.Command] =
        BEGIN 
        TerminalIO.WriteRope["Color plot\n"]; 
        [] _ CDCommandOps.CallWithResource[ProtectedPlotDesign, comm, $ColorPlot, abortPlot];
        END;

    WaitPlotFinishedCommand: Commander.CommandProc = 
        BEGIN
        prio: Process.Priority = Process.GetPriority[];
        IF ~plottingInProgress THEN { 
            IO.PutRope[cmd.out, "  waiting for plot to start"];
            WHILE ~plottingInProgress DO
                Process.Pause[Process.SecondsToTicks[1]];
                ENDLOOP;
            IO.PutRope[cmd.out, ". plot started...\n"]
            };
        Process.SetPriority[Process.priorityBackground];
        WHILE plottingInProgress DO
            Process.Pause[Process.SecondsToTicks[2]];
            ENDLOOP;
        Process.SetPriority[prio];
        IO.PutRope[cmd.out, "  finished\n"]
        END;

    Init: PROC [] = 
        BEGIN
        tonerToKeyKeys[black] _ $CDxColorPDPlotBlack;
        tonerToKeyKeys[cyan] _ $CDxColorPDPlotCyan;
        tonerToKeyKeys[magenta] _ $CDxColorPDPlotMagenta;
        tonerToKeyKeys[yellow] _ $CDxColorPDPlotYellow;
        CDSequencer.ImplementCommand[key: $VersatecColorPlot, proc: PDColorPlotComm, queue: doQueue];
        CDSequencer.ImplementCommand[key: $C150ColorPlot, proc: PDColorPlotComm, queue: doQueue];
        CDSequencer.ImplementCommand[key: $Color400Plot, proc: PDColorPlotComm, queue: doQueue];
        CDSequencer.ImplementCommand[key: $PuffinColorPlot, proc: PDColorPlotComm, queue: doQueue];
        CDSequencer.ImplementCommand[key: $PlatemakerColorPlot, proc: PDColorPlotComm, queue: doQueue];
        CDMenus.CreateEntry[$HardCopyMenu, "PD Color Versatec", $VersatecColorPlot];
        CDMenus.CreateEntry[$HardCopyMenu, "PD C150", $C150ColorPlot];
        CDMenus.CreateEntry[$HardCopyMenu, "PD Puffin, (1 page)", $PuffinColorPlot];
        CDMenus.CreateEntry[$HardCopyMenu, "PD Platemaker", $PlatemakerColorPlot];
        CDMenus.CreateEntry[$HardCopyMenu, "PD Color400", $Color400Plot];
        Commander.Register[
            key: "///Commands/CDWaitPlotFinished", 
            proc: WaitPlotFinishedCommand,
            doc: "waits until ChipNDale pd plotting is finished"
            ];
        TerminalIO.WriteRope["ChipNDale color plot program loaded\n"];
        END;

    Init[];
    END.