<<>>
<<SlateIOImpl.mesa>>
<<Copyright Ó 1992, 1993 by Xerox Corporation.  All rights reserved.>>
<<Weiser, August 8, 1992 5:07 pm PDT >>
<<Christian Jacobi, June 14, 1993 2:52 pm PDT>>

    DIRECTORY
        CommanderOps,
        Imager,
        ImagerColor,
        ImagerBitmapContext,
        ImagerColorMap,
        ImagerDitherContext,
        ImagerInterpress,
        ImagerPixel,
        ImagerSample,
        InterpressInterpreter,
        IPMaster,
        IPInterpreter,
        IO,
        PFS,
        Rope,
        SF,
        SlateIO,
        SlatePrivateTypes,
        Slate,
        ThisMachine,
        X11PopUpSelection,
        XlBitmap,
        XlBitmapExtras;
    <<>>
SlateIOImpl: CEDAR MONITOR
    IMPORTS CommanderOps, Imager, ImagerBitmapContext, ImagerDitherContext, ImagerInterpress, ImagerPixel, ImagerSample, 
    InterpressInterpreter, IPMaster, IPInterpreter, IO, PFS, Rope, SlatePrivateTypes, Slate, ThisMachine, X11PopUpSelection, 
    XlBitmap, XlBitmapExtras
EXPORTS SlateIO = 
    BEGIN OPEN Slate, SlateIO;

    metersPerPixel: REAL = 0.0254/72.0;

    WritePSFile: PUBLIC PROC [pages: LIST OF Page, fileName: Rope.ROPE, trans: Imager.Transformation, log: IO.STREAM, server: REF, 
    overwrite: OverWriteMode] = { 
        out: Rope.ROPE;
        tmpName: Rope.ROPE = Rope.Concat[fileName, ".temp.ip"];
        WriteIPFile[pages, tmpName, trans, log, NIL, overwrite];
        [out, ] Ź CommanderOps.DoCommandRope[
            commandLine: IO.PutFR["IPToPS %g _ %g; Delete %g\n", IO.rope[fileName], IO.rope[tmpName], IO.rope[tmpName]],
            parent: NIL];
        IO.PutRope[log, out];
        };


    WriteIPFile: PUBLIC PROC [pages: LIST OF Page Ź NIL, fileName: Rope.ROPE, trans: Imager.Transformation, log: IO.STREAM, server: REF 
    Ź NIL, overwrite: OverWriteMode] = {
        <<<<no usage of d.context>>>>
        path: PFS.PATH; bytes: INT Ź 0;
        uniqueID: PFS.UniqueID Ź PFS.nullUniqueID;
        stream: IO.STREAM;
        path Ź PFS.PathFromRope[fileName ! 
            PFS.Error => {
                IO.PutF1[log, "write failed: %g\n", IO.rope[error.explanation]]; GOTO Oops
                }
            ];
        [uniqueID: uniqueID, bytes: bytes] Ź PFS.FileInfo[name: path ! 
            PFS.Error => {
                uniqueID Ź PFS.nullUniqueID;
                CONTINUE;
                }
            ];
        IF (uniqueID#PFS.nullUniqueID OR bytes>0) THEN {
            SELECT overwrite FROM
                always => {};
                never => {
                    IO.PutRope[log, "existing file not overwritten\n"]; GOTO Oops
                    };
                interactive => {
                    x: INT;
                    x Ź X11PopUpSelection.Request[header: "file exists", choice: LIST["overwrite", "abort"], connection: server];
                    IF x#1 THEN {
                        IO.PutRope[log, "existing file not overwritten\n"]; GOTO Oops
                        };
                    };
                ENDCASE => ERROR;
            };
        stream Ź PFS.StreamOpen[fileName: path, accessOptions: create, wantedUniqueID: uniqueID ! 
            PFS.Error => {
                IO.PutF1[log, "write failed: %g\n", IO.rope[error.explanation]]; GOTO Oops
                }
            ];
        IPPutPages[stream, pages, trans ! Imager.Error => {
            IO.PutF1[log, "write failed: %g\n", IO.rope[error.explanation]]; IO.Close[stream, TRUE];
            GOTO Oops;
            }];
        IO.Close[stream];
        IO.PutF1[log, "written to: %g\n", IO.rope[fileName]];
        EXITS Oops => {};
        };

    WriteSlateFile: PUBLIC PROC [pages: LIST OF Page Ź NIL, fileName: Rope.ROPE, log: IO.STREAM, server: REF Ź NIL, overwrite: 
    OverWriteMode] = {
        <<<<no usage of d.context>>>>
        path: PFS.PATH; bytes: INT Ź 0;
        uniqueID: PFS.UniqueID Ź PFS.nullUniqueID;
        stream: IO.STREAM;
        path Ź PFS.PathFromRope[fileName ! 
            PFS.Error => {
                IO.PutF1[log, "write failed: %g\n", IO.rope[error.explanation]];
                GOTO Oops
                }
            ];
        [uniqueID: uniqueID, bytes: bytes] Ź PFS.FileInfo[name: path ! 
            PFS.Error => {
                uniqueID Ź PFS.nullUniqueID;
                CONTINUE;
                }
            ];
        IF (uniqueID#PFS.nullUniqueID OR bytes>0) THEN {
            SELECT overwrite FROM
                always => {};
                never => {
                    IO.PutRope[log, "existing file not overwritten\n"]; GOTO Oops
                    };
                interactive => {
                    x: INT;
                    x Ź X11PopUpSelection.Request[header: "file exists", choice: LIST["overwrite", "abort"], connection: server];
                    IF x#1 THEN {
                        IO.PutRope[log, "existing file not overwritten\n"]; GOTO Oops
                        };
                    };
                ENDCASE => ERROR;
            };
        stream Ź PFS.StreamOpen[fileName: path, accessOptions: create, wantedUniqueID: uniqueID ! 
            PFS.Error => {
                IO.PutF1[log, "write failed: %g\n", IO.rope[error.explanation]]; GOTO Oops
                }
            ];
        IO.PutRope[stream, "Slate 1\n"];
        FOR l: LIST OF Page Ź pages, l.rest WHILE l#NIL DO
            page: Page Ź l.first;
            IF page#NIL THEN {
                rosStream: IO.STREAM Ź IO.ROS[];
                rosRope: Rope.ROPE;
                sm: ImagerSample.RasterSampleMap Ź XlBitmap.GetSM[page.activeArea];
                sz: SF.Vec Ź ImagerSample.GetSize[sm];
                bpp: INT Ź ImagerSample.GetBitsPerSample[sm];
                IO.PutF[stream, "Page %g %g %g\n", IO.int[sz.f], IO.int[sz.s], IO.int[bpp]];
                IPPutPages[rosStream, LIST[page], NIL ! Imager.Error => {
                    IO.PutF1[log, "write failed: %g\n", IO.rope[error.explanation]]; IO.Close[stream, TRUE];
                    GOTO Oops;
                    }];
                rosRope Ź IO.RopeFromROS[rosStream, TRUE];
                IO.PutF1[stream, " %g\n", IO.int[Rope.Length[rosRope]]];
                IO.PutRope[stream, "unnamed\n"];
                IO.PutRope[stream, rosRope];
                };
            ENDLOOP;
        IO.PutRope[stream, "End\n"];
        IO.Close[stream];
        IO.PutF[log, "written to: (%g) %g\n", IO.rope[ThisMachine.Name[]], IO.rope[fileName]];
        EXITS Oops => {};
        };

    IPPutPages: PROC [stream: IO.STREAM, pages: LIST OF Page, trans: Imager.Transformation Ź NIL] = {
        <<--May raise Imager.Error>>
        fileRef: ImagerInterpress.Ref;
        fileRef Ź ImagerInterpress.CreateFromStream[stream: stream, header: "Interpress/Xerox/3.0 "];
        FOR l: LIST OF Page Ź pages, l.rest WHILE l#NIL DO
            page: Page ~ l.first;
            EachPage: PROC [ctx: Imager.Context] = {
                sm: ImagerSample.RasterSampleMap Ź XlBitmap.GetSM[page.activeArea];
                bpp: INT Ź ImagerSample.GetBitsPerSample[sm];
                IF trans#NIL THEN Imager.ConcatT[ctx, trans];
                Imager.ScaleT[ctx, metersPerPixel];
                Imager.SetColor[ctx, Imager.black];
                Imager.TranslateT[ctx, [0, ImagerSample.GetSize[sm].s]];
                IF bpp>1
                    THEN {
                        mapEntries: ImagerColorMap.MapEntries Ź NARROW[XlBitmapExtras.GetColormap[page.activeArea]];
                        colorOperator: ImagerColor.ColorOperator Ź ImagerDitherContext.NewColorOperatorDither[bpp: bpp, mapEntries: mapEntries];
                        pixelMap: ImagerPixel.PixelMap Ź ImagerPixel.MakePixelMap[sm];
                        Imager.DrawPixels[context: ctx, pixelMap: pixelMap, colorOperator: colorOperator]
                        }
                    ELSE {
                        Imager.MaskBitmap[context: ctx, bitmap: sm];
                        };
                };
            IF page#NIL THEN ImagerInterpress.DoPage[self: fileRef, action: EachPage];
            ENDLOOP;
        ImagerInterpress.Finish[fileRef];
        }; 

    ReadSlateFile: PUBLIC PROC [session: Session, fileName: Rope.ROPE, log: IO.STREAM, mapEntries: REF ANY Ź NIL] = {
        firstPage: Page Ź NIL;
        Inner: PROC [] = {
            Log: InterpressInterpreter.LogProc = {
                IF class<10 THEN IO.PutF1[log, "%g\n", IO.rope[explanation]];
                };
            line, ipRope: Rope.ROPE; stream: IO.STREAM;
            somePage: Page Ź NIL;
            m: InterpressInterpreter.Master;
            IO.PutF1[log, "read from: %g\n", IO.rope[fileName]];
            stream Ź PFS.StreamOpen[PFS.PathFromRope[fileName], read !
                PFS.Error => ERROR ReadFailed[Rope.Concat[error.explanation, "\n"]]
                ];
            line Ź IO.GetLineRope[stream];
            IF ~Rope.Match["Slate *", line] THEN {
                IO.Close[stream]; ERROR ReadFailed["Not a slate file\n"];
                };
            line Ź IO.GetLineRope[stream];
            DO
                lineStream: IO.STREAM; ipLength: INT; bpp: INT; pageSize: SF.Vec;
                pageName, lengthLine: Rope.ROPE;
                IF Rope.Match["End*", line] THEN EXIT;
                IF ~Rope.Match["Page*", line] THEN {
                    IO.Close[stream]; ERROR ReadFailed["Not a slate file\n"];
                    };
                lineStream Ź IO.RIS[Rope.Substr[line, 5]];
                    pageSize.f Ź IO.GetInt[lineStream];
                    pageSize.s Ź IO.GetInt[lineStream];
                    bpp Ź IO.GetInt[lineStream];
                lengthLine Ź IO.GetLineRope[stream];
                    lineStream Ź IO.RIS[lengthLine];
                    ipLength Ź IO.GetInt[lineStream];
                pageName Ź IO.GetLineRope[stream];
                ipRope Ź IO.GetRope[stream, ipLength];
                m Ź InterpressInterpreter.FromRope[ipRope, Log];
                somePage Ź FromMaster[m, pageSize, bpp, mapEntries, Log, session];
                IF firstPage=NIL THEN firstPage Ź somePage;
                line Ź IO.GetLineRope[stream];
                ENDLOOP;
            IO.Close[stream];
            };
        WithBackStop[Inner, log];
        IF firstPage#NIL THEN Slate.ActivatePage[firstPage];
        };

    ReadIPFile: PUBLIC PROC [session: Session, fileName: Rope.ROPE, log: IO.STREAM, pageSize: SF.Vec, bpp: INT, mapEntries: REF ANY Ź 
    NIL] = {
        firstPage: Page Ź NIL;
        Inner: PROC [] = {
            Log: InterpressInterpreter.LogProc = {
                IF class<10 THEN IO.PutF1[log, "%g\n", IO.rope[explanation]];
                };
            m: InterpressInterpreter.Master;
            IF pageSize.s<=0 OR pageSize.f<=0 THEN pageSize Ź SlatePrivateTypes.defaultPageSize;
            IF bpp<=0 THEN bpp Ź 1;
            IO.PutF1[log, "read from: %g\n", IO.rope[fileName]];
            m Ź InterpressInterpreter.Open[fileName, Log];
            firstPage Ź FromMaster[m, pageSize, bpp, mapEntries, Log, session];
            };
        WithBackStop[Inner, log];
        IF firstPage#NIL THEN Slate.ActivatePage[firstPage];
        };

    ReadFailed: ERROR [msg: Rope.ROPE] = CODE; 

    WithBackStop: PROC [proc: PROC, log: IO.STREAM] = {
        <<Urtility providing a backstop for read operations>>
        ENABLE {
            PFS.Error => {
                IO.PutF1[log, "read failed: %g\n", IO.rope[error.explanation]]; GOTO Oops
                };
            Imager.Error => {
                IO.PutF1[log, "read failed: %g\n", IO.rope[error.explanation]]; GOTO Oops
                };
            IPMaster.Error => {
                IO.PutF1[log, "read failed (IPMaster.Error): %g\n", IO.rope[error.explanation]]; GOTO Oops
                };
            IPInterpreter.Error => {
                IO.PutF1[log, "read failed (IPInterpreter.Error): %g\n", IO.rope[explanation]]; GOTO Oops
                };
            IO.Error => {
                IO.PutF1[log, "read failed (IO.Error): %g\n", IO.rope[msg]]; GOTO Oops
                };
            ReadFailed => {
                IO.PutF1[log, "read failed : %g\n", IO.rope[msg]]; GOTO Oops
                };
            };
        proc[];
        EXITS Oops => {};
        };

    FromMaster: PROC [m: InterpressInterpreter.Master, pageSize: SF.Vec, bpp: INT, mapEntries: REF ANY Ź NIL, logProc: 
    InterpressInterpreter.LogProc, session: Slate.Session] RETURNS [firstPage: Slate.Page Ź NIL] = {
        IF m#NIL THEN {
            FOR i: INT IN [1..m.pages] DO
                thisPage: Slate.Page Ź NIL; context: Imager.Context; sm: ImagerSample.RasterSampleMap;
                sm Ź ImagerSample.NewSampleMap[[min: [0, 0], max: pageSize], bpp];
                IF bpp>1 AND mapEntries#NIL 
                    THEN { 
                        context Ź ImagerDitherContext.Create[deviceSpaceSize: pageSize, scanMode: [slow: down, fast: right], surfaceUnitsPerInch: [72, 72], 
                        pixelUnits: TRUE];
                        ImagerDitherContext.SetSampleMap[context: context, sampleMap: sm];
                        IF mapEntries#NIL THEN
                            ImagerDitherContext.SetDitherMap[context: context, mapEntries: NARROW[mapEntries]];
                        }
                    ELSE {
                        context Ź ImagerBitmapContext.Create[deviceSpaceSize: pageSize, scanMode: [slow: down, fast: right], surfaceUnitsPerInch: [72, 72], 
                        pixelUnits: TRUE, fontCacheName: $Bitmap];
                        ImagerBitmapContext.SetBitmap[context: context, bitmap: sm];
                        };
                Imager.SetColor[context, Imager.black];
                Imager.ScaleT[context, 1.0/metersPerPixel];
                InterpressInterpreter.DoPage[m, i, context, logProc];
                thisPage Ź NewPage[session, pageSize, sm, NIL, bpp];
                IF firstPage=NIL THEN firstPage Ź thisPage;
                ENDLOOP;
            InterpressInterpreter.Close[m];
            };
        };

    IPPrint: PUBLIC PROC [pages: LIST OF Page, printerName: Rope.ROPE, trans: Imager.Transformation, log: IO.STREAM, server: REF Ź NIL] 
    = {
        out: Rope.ROPE; result: REF ANY;
        fileName: Rope.ROPE Ź IO.PutFR1["/tmp/SlatePrintFile.%0g.ip", IO.card[Counter[]]];
        WriteIPFile[pages, fileName, trans, log, server, always];
        [out, result] Ź CommanderOps.DoCommandRope[
            commandLine: IO.PutFR["SendIPMaster %g -h %g; delete %g\n", IO.rope[fileName], IO.rope[printerName], IO.rope[fileName]],
            parent: NIL
            ];
        IO.PutRope[log, out];
        };

    PSPrint: PUBLIC PROC [pages: LIST OF Page, printerName: Rope.ROPE, trans: Imager.Transformation, log: IO.STREAM, server: REF Ź NIL] 
    = {
        result: REF Ź NIL; out: Rope.ROPE Ź NIL;
        fileName: Rope.ROPE Ź IO.PutFR1["/tmp/SlatePrintFile.%0g.ps", IO.card[Counter[]]];
        WritePSFile[pages, fileName, trans, log, server, OverWriteMode.always];
        [out, result] Ź CommanderOps.DoCommandRope[
            commandLine: IO.PutFR["sh1 lpr -P%g %g ; delete %g\n", IO.rope[printerName], IO.rope[fileName], IO.rope[fileName]],
            parent: NIL
            ];
        IO.PutRope[log, out];
        };

    cnt: CARD Ź 1;
    Counter: ENTRY PROC [] RETURNS [i: CARD] = {
        i Ź cnt Ź cnt + 1;
        };


    END.