
    <<GGFromImagerImpl.mesa>>
        <<Contents: Routines for building Gargoyle objects from Interpres.>>
        <<Copyright Ó 1985, 1989, 1990, 1991, 1992 by Xerox Corporation.  All rights reserved.>>
        <<Michael Plass, September 18, 1989 11:14:22 am PDT>>
        <<Bier, November 30, 1992 5:38 pm PST>>
        <<Pier, June 16, 1992 1:07 pm PDT>>
        <<Doug Wyatt, April 17, 1992 1:51 pm PDT>>
        <<>>
    DIRECTORY
        Char, Convert, FileNames, GGBasicTypes, GGCoreOps, GGCoreTypes, GGFont, GGFromImager, GGModelTypes, GGOutline, GGParseIn, GGScene, 
        GGSegment, GGSegmentTypes, GGSlice, GGSliceOps, GGTraj, GGUtility, Imager, ImagerBackdoor, ImagerColor, ImagerDeviceVector, 
        ImagerError, ImagerFont, ImagerInterpress, ImagerPath, ImagerPrivate, ImagerState, ImagerTransformation, ImagerTypeface, 
        InterpressInterpreter, IO, Rope, SF, Vectors2d;

    GGFromImagerImpl: CEDAR PROGRAM
        IMPORTS Char, Convert, FileNames, GGCoreOps, GGFont, GGOutline, GGParseIn, GGScene, GGSegment, GGSlice, GGSliceOps, GGTraj, 
        GGUtility, Imager, ImagerBackdoor, ImagerError, ImagerFont, ImagerInterpress, ImagerPath, ImagerState, 
        ImagerTransformation, InterpressInterpreter, IO, Rope, Vectors2d
        EXPORTS GGFromImager, Imager, ImagerFont = BEGIN

        Camera: TYPE ~ GGModelTypes.Camera;
        Class: TYPE ~ REF ClassRep;
        ClassRep: PUBLIC TYPE ~ ImagerPrivate.ClassRep; -- export to Imager.ClassRep
        Clipper: TYPE ~ ImagerBackdoor.Clipper;
        Color: TYPE ~ Imager.Color;
        ColorOperator: TYPE ~ Imager.ColorOperator;
        Context: TYPE ~ Imager.Context;
        CoordSys: TYPE ~ ImagerBackdoor.CoordSys;
        Font: TYPE ~ ImagerFont.Font;
        Object: TYPE ~ Imager.Object;
        PathProc: TYPE ~ ImagerPath.PathProc;
        PixelArray: TYPE ~ Imager.PixelArray;
        PixelMap: TYPE ~ Imager.PixelMap;
        Point: TYPE ~ GGBasicTypes.Point;
        Rectangle: TYPE ~ Imager.Rectangle;
        ROPE: TYPE ~ Rope.ROPE;
        SampleMap: TYPE ~ Imager.SampleMap;
        ScanMode: TYPE ~ ImagerTransformation.ScanMode;
        Scene: TYPE ~ GGModelTypes.Scene;
        SequenceOfReal: TYPE ~ REF SequenceOfRealObj;
        SequenceOfRealObj: TYPE ~ GGCoreTypes.SequenceOfRealObj;
        Slice: TYPE ~ GGModelTypes.Slice;
        SliceParts: TYPE ~ GGModelTypes.SliceParts;
        State: TYPE ~ REF StateRep;
        StateRep: PUBLIC TYPE ~ ImagerState.StateRep;
        StrokeEnd: TYPE ~ Imager.StrokeEnd;
        StrokeJoint: TYPE ~ Imager.StrokeJoint;
        Transformation: TYPE ~ ImagerTransformation.Transformation;
        VEC: TYPE ~ Imager.VEC;
        <<Viewer: TYPE ~ ViewerClasses.Viewer;>>
        Visibility: TYPE ~ ImagerBackdoor.Visibility;
        XChar: TYPE ~ ImagerFont.XChar;
        XStringProc: TYPE ~ ImagerFont.XStringProc;

        Data: TYPE ~ REF DataRep;
        DataRep: TYPE ~ RECORD [
            scene: Scene,
            camera: Camera,
            <<feedback: Viewer,>>
            curOutline: Slice
            ];

        Typeface: TYPE ~ REF TypefaceRep;
        TypefaceRep: PUBLIC TYPE = ImagerTypeface.TypefaceRep; -- export to ImagerFont

    WarningMessage: PUBLIC SIGNAL [context: Context, code: ATOM, message: ROPE] ~ CODE;

    Create: PROC [camera: Camera] RETURNS [Context] ~ {
        data: Data ~ NEW[DataRep Ź [scene: GGScene.CreateScene[], camera: camera]];
        state: State ~ ImagerState.CreateState[];
        state.color Ź Imager.black;
        RETURN[NEW[Imager.ContextRep Ź [class: gargoyleClass, state: state, data: data]]];
        };

    Capture: PUBLIC PROC [action: PROC [Context], camera: Camera] RETURNS [Scene] ~ {
        context: Context ~ Create[camera];
        action[context !
            ImagerError.Warning => {
                r: ROPE ~ IO.PutFR["code: %g, message: %g", [atom[ImagerError.AtomFromErrorCode[error.code]]], [rope[error.explanation]] ];
                SIGNAL WarningMessage[context, $Capture, r];
                RESUME;
                };
            ];
        WITH context.data SELECT FROM data: Data => RETURN [data.scene]; ENDCASE => ERROR;
        };

    ProcessStateChanges: PUBLIC PROC [context: Context] ~ {
        state: State ~ context.state;
        changed: ImagerState.ChangeFlags ~ state.changed;
        state.changed Ź ImagerState.notChanged;
        IF changed.clipper AND state.clipper # NIL THEN SIGNAL WarningMessage[context, $Clipping, "NotImplemented: Clipping"];
        };

    RopeFromXStringProc: PROC [string: XStringProc] RETURNS [rope: ROPE Ź NIL] ~ {
        p: PROC [q: PROC [CHAR]] ~ {
            currentSet: BYTE Ź 0;
            action: PROC [char: XChar] ~ {
                set: BYTE ~ Char.Set[char];
                IF set#currentSet THEN { q[VAL[255]]; q[VAL[currentSet Ź set]] };
                q[VAL[Char.Code[char]]];
                };
            string[action];
            };
        RETURN[Rope.FromChars[p]];
        };

    UnpackComplexFontName: PROC [fontName: Rope.ROPE] RETURNS [prefix, family, face: Rope.ROPE, fontSize: REAL] = {
        <<Takes a complex name like "xerox/pressfonts/Helvetica-MIR" and a font size and returns components.>>
        <<May already have a simple name like xerox/tiogafonts/Helvetica10I.  KAP August 8, 1986>>
        DigitProc: IO.BreakProc = {
        SELECT char FROM
        IO.LF, IO.CR, IO.TAB, IO.SP => RETURN [break];
        '0, '1, '2, '3, '4, '5, '6, '7, '8, '9 => RETURN [break];
        ENDCASE => RETURN [other];
            };
        AlphaProc: IO.BreakProc = {
        SELECT char FROM
        IO.LF, IO.CR, IO.TAB, IO.SP => RETURN [break];
        IN ['a .. 'z], IN ['A .. 'Z] => RETURN [break];
        ENDCASE => RETURN [other];
            };
        new, sizeRope: Rope.ROPE;
        prefix Ź FileNames.Directory[path: fontName]; -- "xerox/*fonts/"
        new Ź FileNames.GetShortName[fontName]; -- get family "name"
        face Ź FileNames.Tail[new, '-]; -- get face component (MIR, BRR, ...)
        IF Rope.Equal[face, new] THEN { -- have a name like Helvetica10I OR TERMINAL
            endOfName: BOOL;
            nameStream: IO.STREAM Ź IO.RIS[new];
            family Ź IO.GetTokenRope[nameStream, DigitProc].token; -- get the leading alpha characters
            sizeRope Ź IO.GetTokenRope[nameStream, AlphaProc ! IO.EndOfStream, IO.Error => {endOfName Ź TRUE; CONTINUE;};].token; -- get any 
            digit characters
            fontSize Ź Convert.RealFromRope[sizeRope];
            IF endOfName THEN face Ź "" -- because face = new 
            ELSE face Ź Rope.Concat["-", GGParseIn.ReadWord[nameStream]];
            }
        ELSE { -- have a name like Helvetica-MIR
            family Ź Rope.Substr[base: new, start: 0, len: Rope.SkipTo[s: new, pos: 0, skip: "-"]]; -- throw away "-XXX"
            face Ź SELECT TRUE FROM
                Rope.Equal[face, "MRR", FALSE] => "",
                Rope.Equal[face, "BRR", FALSE] => "-B",
                Rope.Equal[face, "Bold", FALSE] => "-B",
                Rope.Equal[face, "MIR", FALSE] => "-I",
                Rope.Equal[face, "Italic", FALSE] => "-I",
                Rope.Equal[face, "BIR", FALSE] => "-BI",
            ENDCASE => ERROR;
            fontSize Ź 1.0;
            };
        };

    SetSegProperties: PROC [context: Context, m: Transformation, outlined: BOOL, seg: GGSegmentTypes.Segment] = {
        <<A kludge for the moment to avoid segments with sampled colors>>
        strokeEnd: StrokeEnd;
        strokeEnd Ź VAL[NAT[context.state.np.strokeEnd]];
        IF outlined THEN {
            seg.strokeWidth Ź Vectors2d.Magnitude[ImagerTransformation.TransformVec[m, [context.state.np.strokeWidth, 0.0] ] ];
            seg.color Ź IF ISTYPE[context.state.color, ImagerColor.ConstantColor] THEN context.state.color ELSE Imager.black;
            seg.strokeEnd Ź strokeEnd;
            }
        ELSE {
            seg.strokeWidth Ź 0.0;
            seg.color Ź NIL;
            seg.strokeEnd Ź round;
            };
        };

    OutlineFromPath: PROC[context: Context, path: PathProc, m: Transformation, closed: BOOL, outlined: BOOL Ź TRUE] RETURNS 
    [GGModelTypes.Slice] ~ {
        curOutline: GGModelTypes.Slice;
        curTraj: GGModelTypes.Traj;
        curSeg: GGSegmentTypes.Segment;
        lp: VEC Ź [0,0];
        firstPoint: VEC Ź [0,0];
        Finish: PROC ~ {
            IF curTraj # NIL THEN {
                IF curSeg # NIL THEN {
                    IF closed THEN {
                        IF curSeg.hi = firstPoint THEN {
                            [] Ź GGTraj.AddSegment[curTraj, hi, curSeg, lo];
                            GGTraj.CloseByDistorting[curTraj, hi];
                            }
                        ELSE {
                            [] Ź GGTraj.AddSegment[curTraj, hi, curSeg, lo];
                            curSeg Ź GGSegment.MakeLine[curSeg.hi, firstPoint, NIL];
                            SetSegProperties[context, m, outlined, curSeg];
                            GGTraj.CloseWithSegment[curTraj, curSeg, lo];
                            };
                        }
                    ELSE [] Ź GGTraj.AddSegment[curTraj, hi, curSeg, lo];
                    }
                ELSE { -- unlikely but legal case: Traj with a single point, no segment
                    [] Ź GGTraj.AddSegment[curTraj, lo, GGSegment.MakeLine[[lp.x, lp.y], [lp.x, lp.y], NIL], lo];
                    };
                curSeg Ź NIL;
                IF curOutline = NIL THEN curOutline Ź GGOutline.CreateOutline[curTraj, NIL]
                <<ELSE curOutline _ GGOutline.AddChild[curOutline, curTraj];>>
                <<ASSERT: this code can modify curOutline because it owns it.  This is a big win.>>
                ELSE AppendChild[curOutline, curTraj];
                curTraj Ź NIL;
                };
            };
        AppendChild: PROC [outline: Slice, child: Slice] = {
            holyData: GGOutline.OutlineData Ź NARROW[outline.data];
            holyData.children Ź GGUtility.AppendSliceList[holyData.children, LIST[child]];
            child.parent Ź outline;
            GGTraj.SetTrajRole[child, hole];
            };
        Move: PROC [p: VEC] ~ {
            Finish[];
            curTraj Ź GGTraj.CreateTraj[[p.x, p.y]];
            firstPoint Ź lp Ź p;
            };
        Line: PROC [p1: VEC] ~ {
            IF curSeg # NIL THEN [] Ź GGTraj.AddSegment[curTraj, hi, curSeg, lo];
            curSeg Ź GGSegment.MakeLine[[lp.x, lp.y], [p1.x, p1.y], NIL];
            SetSegProperties[context, m, outlined, curSeg];
            lp Ź p1;
            };
        Curve: PROC [p1, p2, p3: VEC] ~ {
            IF curSeg # NIL THEN [] Ź GGTraj.AddSegment[curTraj, hi, curSeg, lo];
            curSeg Ź GGSegment.MakeBezier[[lp.x, lp.y], [p1.x, p1.y], [p2.x, p2.y], [p3.x, p3.y], NIL];
            SetSegProperties[context, m, outlined, curSeg];
            lp Ź p3;
            };
        Conic: PROC [p1, p2: VEC, r: REAL] ~ {
            IF curSeg # NIL THEN [] Ź GGTraj.AddSegment[curTraj, hi, curSeg, lo];
            curSeg Ź GGSegment.MakeConic[[lp.x, lp.y], [p1.x, p1.y], [p2.x, p2.y], r, NIL];
            SetSegProperties[context, m, outlined, curSeg];
            lp Ź p2;
            };
        Arc: PROC [p1, p2: VEC] ~ {
            IF curSeg # NIL THEN [] Ź GGTraj.AddSegment[curTraj, hi, curSeg, lo];
            curSeg Ź GGSegment.MakeArc[[lp.x, lp.y], [p1.x, p1.y], [p2.x, p2.y], NIL];
            SetSegProperties[context, m, outlined, curSeg];
            lp Ź p2;
            };
        ImagerPath.Transform[path, m, Move, Line, Curve, Conic, Arc];
        Finish[];
        GGSlice.KillBoundBox[curOutline];
        RETURN [curOutline];
        };

    MyShow: PROC[context: Context, string: XStringProc, xrel: BOOL] = {
        MyShowAux[context, RopeFromXStringProc[string], xrel];
        };

    MyShowText: PROC [context: Context, text: REF READONLY TEXT, start, len: NAT, xrel: BOOL] = {
        rope: ROPE ~ IF len=NAT.LAST
            THEN Rope.FromRefText[s: text, start: start] -- let len default
            ELSE Rope.FromRefText[s: text, start: start, len: len];
            <<What a crock... in PCedar the len argument is a NAT15, which is smaller than NAT!>>
        MyShowAux[context, rope, xrel];
        };

    MyShowAux: PROC[context: Context, rope: Rope.ROPE, xrel: BOOL] = {
        OPEN ImagerTransformation;
        font: ImagerFont.Font Ź context.class.GetFont[context];
        escapement: VEC Ź ImagerFont.RopeEscapement[font, rope];
        camera: Camera Ź NARROW[context.data, Data].camera;
        IF context.state.np.noImage=0 THEN {
            textSlice: GGModelTypes.Slice;
            data: Data Ź NARROW[context.data];
            amplifySpace: REAL Ź ImagerBackdoor.GetReal[context, $amplifySpace];
            color: Imager.Color Ź context.class.GetColor[context];
            currentT: Transformation Ź context.class.GetT[context];
            currentPoint: Point Ź context.class.GetCP[context, FALSE];
            fontName: Rope.ROPE Ź ImagerFont.Name[font];
            fontData: GGFont.FontData Ź GGFont.CreateFontData[]; -- ensure non-NIL fontData
            fontData Ź IF fontName # NIL THEN GGFont.ParseFontData[data: fontData, inStream: IO.RIS[fontName], literalP: TRUE ! 
            GGFont.ParseError => CONTINUE;]
            ELSE GGFont.FontDataFromNamelessFont[font];
            fontData.transform Ź Cat[Scale[fontData.storedSize], font.charToClient, Translate[currentPoint], currentT];
            fontData.substituteOK Ź TRUE; -- allow font substitution on file reads
            textSlice Ź GGSlice.MakeTextSlice[rope, color, camera.displayStyle, amplifySpace];
            [] Ź GGSlice.SetTextFontAndTransform[textSlice, fontData, NIL, NIL];
            GGScene.AddSlice[data.scene, textSlice, -1];
            };
        ImagerState.StateSetXYRel[context, escapement];
        };

    MySetSampledColor: PUBLIC PROC [context: Context, pa: PixelArray, m: Transformation, colorOperator: ColorOperator] = {
        ImagerState.StateSetSampledColor[context, pa, m, colorOperator];
        };

    MySetSampledBlack: PUBLIC PROC [context: Context, pa: PixelArray, m: Transformation, clear: BOOL] = {
        ImagerState.StateSetSampledBlack[context, pa, m, clear];
        };

    MyShowBackward: PROC[context: Context, string: XStringProc] = {
        SIGNAL WarningMessage[context, $MyShowBackward, "NotImplemented: ShowBackward"];
        };

    MyMaskFill: PROC[context: Context, path: PathProc, oddWrap: BOOL] = {
        data: Data ~ NARROW[context.data];
        state: State ~ context.state;
        IF state.changed#ImagerState.notChanged THEN ProcessStateChanges[context];
        IF context.state.np.noImage=0 THEN {
            outline: GGModelTypes.Slice;
            IF ImagerTransformation.CloseEnough[state.clientToDevice, identity]
                THEN outline Ź OutlineFromPath[context, path, NIL, TRUE, FALSE]
                ELSE outline Ź OutlineFromPath[context, path, state.clientToDevice, TRUE, FALSE];
            IF outline = NIL THEN RETURN; -- MASKFILL with a null outline can occur in Interpress
            GGOutline.SetWrapRule[outline, oddWrap];
            GGSliceOps.SetFillColor[outline, NIL, GGCoreOps.CopyColor[state.color], $Set, NIL];
            GGScene.AddSlice[data.scene, outline, -1];
            data.curOutline Ź outline;
            };
        };

    ReplaceChild: PROC [outline: Slice, oldChild, newChild: Slice] = {
        outlineData: GGOutline.OutlineData Ź NARROW[outline.data];
        beforeEnt, ent, afterEnt: LIST OF Slice;
        found: BOOL Ź FALSE;
        [beforeEnt, ent, afterEnt, found] Ź GGUtility.FindSliceAndNeighbors[oldChild, outlineData.children];
        IF NOT found THEN ERROR;
        IF beforeEnt = NIL THEN {
            outlineData.children Ź CONS[newChild, afterEnt];
            }
        ELSE {
            beforeEnt.rest Ź CONS[newChild, afterEnt];
            };
        newChild.parent Ź outline;
        GGTraj.SetTrajRole[newChild, GGTraj.GetTrajRole[oldChild]];
        };

    identity: ImagerTransformation.Transformation Ź ImagerTransformation.Scale[1.0];
    MyMaskStroke: PROC[context: Context, path: PathProc, closed: BOOL] ~ {
        outline: GGModelTypes.Slice;
        strokeJoint: StrokeJoint;
        data: Data ~ NARROW[context.data];
        state: State ~ context.state;
        IF state.changed#ImagerState.notChanged THEN ProcessStateChanges[context];
        IF context.state.np.noImage=0 THEN {
            trajs: LIST OF Slice;
            oldTraj: Slice;
            IF ImagerTransformation.CloseEnough[state.clientToDevice, identity]
                THEN outline Ź OutlineFromPath[context, path, NIL, closed]
                ELSE outline Ź OutlineFromPath[context, path, state.clientToDevice, closed];
            trajs Ź GGOutline.TrajectoriesOfOutline[outline];
            IF trajs.rest = NIL AND data.curOutline # NIL THEN {
                oldTrajs: LIST OF Slice Ź GGOutline.FindTrajShapeInOutline[trajs.first, data.curOutline];
                oldTraj Ź IF oldTrajs = NIL THEN NIL ELSE oldTrajs.first;
                };
            strokeJoint Ź VAL[NAT[context.state.np.strokeJoint]];
            IF oldTraj = NIL THEN {
                GGSliceOps.SetFillColor[outline, NIL, NIL, $Set, NIL]; -- no fill color
                GGSliceOps.SetStrokeJoint[outline, GGSliceOps.NewParts[outline, NIL, slice].parts, strokeJoint, NIL];
                GGScene.AddSlice[data.scene, outline, -1];
                }
            ELSE {
                ReplaceChild[data.curOutline, oldTraj, trajs.first];
                GGSliceOps.SetStrokeJoint[trajs.first, GGSliceOps.NewParts[trajs.first, NIL, slice].parts, strokeJoint, NIL];
                };
            };
        };

    MyMaskDashedStroke: PROC[context: Context, path: PathProc, patternLen: NAT, pattern: PROC [NAT] RETURNS [REAL], offset, length: 
    REAL] ~ {
        outline: GGModelTypes.Slice;
        strokeJoint: StrokeJoint;
        data: Data ~ NARROW[context.data];
        state: State ~ context.state;
        patternSeq: SequenceOfReal Ź NEW[SequenceOfRealObj[patternLen]];
        IF state.changed#ImagerState.notChanged THEN ProcessStateChanges[context];
        IF context.state.np.noImage=0 THEN {
            completeParts: SliceParts;
            IF ImagerTransformation.CloseEnough[state.clientToDevice, identity]
                THEN outline Ź OutlineFromPath[context, path, NIL, FALSE] -- to preserve arcs
                ELSE outline Ź OutlineFromPath[context, path, state.clientToDevice, FALSE];
            completeParts Ź GGSliceOps.NewParts[outline, NIL, slice].parts;
            GGSliceOps.SetFillColor[outline, NIL, NIL, $Set, NIL]; -- no fill color
            strokeJoint Ź VAL[NAT[context.state.np.strokeJoint]];
            GGSliceOps.SetStrokeJoint[outline, completeParts, strokeJoint, NIL];
            FOR i: NAT IN [0..patternLen) DO
                patternSeq[i] Ź pattern[i];
                ENDLOOP;
            GGSliceOps.SetDashed[outline, completeParts, TRUE, patternSeq, offset, length, NIL];
            GGScene.AddSlice[data.scene, outline, -1];
            };
        };

    MyShowAndFixedXRel: PROC [context: Context, string: XStringProc, x: REAL] ~ {
        SIGNAL WarningMessage[context, $ShowAndFixedXRel, "Not implemented: ShowAndFixedXRel"];
        };

    MyMaskRectangle: PROC[context: Context, r: Rectangle] ~ {
        path: PathProc ~ {
            moveTo[[r.x, r.y]]; lineTo[[r.x+r.w, r.y]];
            lineTo[[r.x+r.w, r.y+r.h]]; lineTo[[r.x, r.y+r.h]]
            }; 
        MyMaskFill[context, path, FALSE];
        };

    MyMaskRectangleI: PROC[context: Context, x, y, w, h: INTEGER] ~ {
        MyMaskRectangle[context, [x, y, w, h]];
        };

    MyMaskVector: PROC[context: Context, p1, p2: VEC] ~ {
        path: PathProc ~ {moveTo[p1]; lineTo[p2]};
        MyMaskStroke[context, path, FALSE];
        };

    MyMaskPixel: PROC[context: Context, pa: PixelArray] ~ {
        DoMyMaskPixel: PROC [dc: Imager.Context] = {
            Imager.MaskPixel[dc, pa];
            };
        data: Data Ź NARROW[context.data];
        boxSlice: Slice;
        currentColor: Color;
        currentT: ImagerTransformation.Transformation;

        currentColor Ź context.state.color;
        currentT Ź ImagerTransformation.Copy[context.state.clientToDevice];
        boxSlice Ź GGSlice.MakeBoxFromMaskPixel[pa, currentColor, NIL, currentT];
        GGScene.AddSlice[data.scene, boxSlice, -1];
        };

    MyMaskBitmap: PROC[context: Context, bitmap: SampleMap, referencePoint: SF.Vec, scanMode: ScanMode, position: VEC] ~ {
        DoMyMaskBits: PROC [dc: Imager.Context] = {
            Imager.MaskBitmap[dc, bitmap, referencePoint, scanMode, position];
            };
        masterStream, outStream: IO.STREAM;
        masterRope: Rope.ROPE;
        data: Data Ź NARROW[context.data];
        ipRef: ImagerInterpress.Ref;
        ipMaster: InterpressInterpreter.Master;
        ipSlice: Slice;

        <<SIGNAL WarningMessage[context, $MaskBitmap, "NotImplemented: MaskBitmap"];>>
        outStream Ź IO.ROS[];
        ipRef Ź ImagerInterpress.CreateFromStream[outStream, "Interpress/Xerox/3.0 "];
        ImagerInterpress.DoPage[ipRef, DoMyMaskBits];
        ImagerInterpress.Finish[ipRef];
        masterRope Ź IO.RopeFromROS[outStream];
        masterStream Ź IO.RIS[masterRope];
        ipMaster Ź InterpressInterpreter.FromStream[masterStream, NIL];
        <<ipSlice _ GGSlice.MakeIPSliceFromMaster[ipMaster, NIL, NIL, NIL, TRUE];>>
        ipSlice Ź GGSlice.MakeIPSliceFromMaster[ipMaster: ipMaster, router: NIL, includeByValue: TRUE]; -- KAP
        GGScene.AddSlice[data.scene, ipSlice, -1];
        };

    MyDrawBitmap: PROC [context: Context, bitmap: SampleMap, referencePoint: SF.Vec, scanMode: ScanMode, position: VEC] ~ {
        DoMyDrawBits: PROC [dc: Imager.Context] = {
            Imager.MaskBitmap[dc, bitmap, referencePoint, scanMode, position];
            };
        masterStream, outStream: IO.STREAM;
        masterRope: Rope.ROPE;
        data: Data Ź NARROW[context.data];
        ipRef: ImagerInterpress.Ref;
        ipMaster: InterpressInterpreter.Master;
        ipSlice: Slice;

        <<SIGNAL WarningMessage[context, $DrawBits, "NotImplemented: DrawBits"];>>
        outStream Ź IO.ROS[];
        ipRef Ź ImagerInterpress.CreateFromStream[outStream, "Interpress/Xerox/3.0 "];
        ImagerInterpress.DoPage[ipRef, DoMyDrawBits];
        ImagerInterpress.Finish[ipRef];
        masterRope Ź IO.RopeFromROS[outStream];
        masterStream Ź IO.RIS[masterRope];
        ipMaster Ź InterpressInterpreter.FromStream[masterStream, NIL];
        <<ipSlice _ GGSlice.MakeIPSliceFromMaster[ipMaster, NIL, NIL, NIL, TRUE];>>
        ipSlice Ź GGSlice.MakeIPSliceFromMaster[ipMaster: ipMaster, router: NIL, includeByValue: TRUE]; -- KAP
        GGScene.AddSlice[data.scene, ipSlice, -1];
        };

    MyDrawPixels: PROC[context: Context, pixelMap: PixelMap, colorOperator: ColorOperator, referencePoint: SF.Vec, scanMode: ScanMode, 
    position: VEC] ~ {
        SIGNAL WarningMessage[context, $MyDrawPixels, "NotImplemented: DrawPixels"];
        };

    MyDoIfVisible: PROC[context: Context, r: Rectangle, action: PROC] ~ {
        SIGNAL WarningMessage[context, $MyDoIfVisible, "NotImplemented: DoIfVisible"];
        };

    MyDoWithBuffer: PROC[context: Context, action: PROC, x, y, w, h: INTEGER, backgroundColor: Color] ~ {
        SIGNAL WarningMessage[context, $MyDoWithBuffer, "NotImplemented: DoWithBuffer"];
        };

    MyDrawObject: PROC[context: Context, object: Object, position: VEC, interactive: BOOL] ~ {
        SIGNAL WarningMessage[context, $MyDrawObject, "NotImplemented: DrawObject:"];
        };

    MyGetBounds: PROC [context: Context] RETURNS [Rectangle] ~ {
        ERROR ImagerError.Error[[unimplemented, "NotImplemented: GetBounds"]]
        };

    MyViewReset: PROC[context: Context] ~ {
        SIGNAL WarningMessage[context, $MyViewReset, "NotImplemented: ViewReset"];
        };

    MyViewTranslateI: PROC[context: Context, x, y: INTEGER] ~ {
        SIGNAL WarningMessage[context, $MyViewTranslateI, "NotImplemented: ViewTranslateI"];
        };

    MyViewClip: PROC[context: Context, path: PathProc, oddWrap: BOOL, exclude: BOOL] ~ {
        SIGNAL WarningMessage[context, $MyViewClip, "NotImplemented: ViewClip"];
        };

    MyViewClipRectangleI: PROC[context: Context, x, y, w, h: INTEGER, exclude: BOOL] ~ {
        SIGNAL WarningMessage[context, $MyViewClipRectangleI, "NotImplemented: ViewClipRectangleI"];
        };

    MyGetTransformation: PROC[context: Context, from, to: CoordSys] RETURNS [Transformation] ~ {
        state: State Ź context.state;
        m: Transformation Ź NIL;
        SELECT to FROM
            client => m Ź ImagerTransformation.Copy[state.clientToDevice];
            view => m Ź ImagerTransformation.Scale[1.0];
            surface => m Ź ImagerTransformation.Scale[1.0];
            device => m Ź ImagerTransformation.Scale[1.0];
            ENDCASE => ERROR;
        ImagerTransformation.ApplyInvert[m];
        SELECT from FROM
            client => ImagerTransformation.ApplyPreConcat[m: m, p: state.clientToDevice];
            view => NULL;
            surface => NULL;
            device => NULL;
            ENDCASE => ERROR;
        RETURN [m]
        };

    MyTransform: PROC[context: Context, v: VEC, from, to: CoordSys, vec: BOOL] RETURNS [VEC]  ~ {
        SIGNAL WarningMessage[context, $MyTransform, "NotImplemented: Transform"];
        RETURN[[0,0]];
        };

    MyMoveViewRectangle: PROC[context: Context, width, height, fromX, fromY, toX, toY: INTEGER] ~ {
        SIGNAL WarningMessage[context, $MyMoveViewRectangle, "NotImplemented: MoveViewRectangle"];
        };

    MyTestViewRectangle: PROC[context: Context, x, y, w, h: INTEGER] RETURNS [Visibility] ~ {
        SIGNAL WarningMessage[context, $MyTestViewRectangle, "NotImplemented: TestViewRectangle"];
        RETURN[all]
        };

    gargoyleClass: Class ~ NEW[ClassRep Ź [
        type: $Gargoyle,
        Save: ImagerState.StateSave,
        Restore: ImagerState.StateRestore,
        SetInt: ImagerState.StateSetInt,
        SetReal: ImagerState.StateSetReal,
        SetT: ImagerState.StateSetT,
        SetFont: ImagerState.StateSetFont,
        SetColor: ImagerState.StateSetColor,
        SetClipper: ImagerState.StateSetClipper,
        GetInt: ImagerState.StateGetInt,
        GetReal: ImagerState.StateGetReal,
        GetT: ImagerState.StateGetT,
        GetFont: ImagerState.StateGetFont,
        GetColor: ImagerState.StateGetColor,
        GetClipper: ImagerState.StateGetClipper,
        ConcatT: ImagerState.StateConcatT,
        Scale2T: ImagerState.StateScale2T,
        RotateT: ImagerState.StateRotateT,
        TranslateT: ImagerState.StateTranslateT,
        Move: ImagerState.StateMove,
        SetXY: ImagerState.StateSetXY,
        SetXYRel: ImagerState.StateSetXYRel,
        Show: MyShow,
        ShowText: MyShowText,
        StartUnderline: ImagerState.StateStartUnderline,
        MaskUnderline: ImagerState.StateMaskUnderline,
        CorrectMask: ImagerState.StateCorrectMask,
        CorrectSpace: ImagerState.StateCorrectSpace,
        Space: ImagerState.StateSpace,
        SetCorrectMeasure: ImagerState.StateSetCorrectMeasure,
        SetCorrectTolerance: ImagerState.StateSetCorrectTolerance,
        Correct: ImagerState.StateCorrect,
        DontCorrect: ImagerState.StateDontCorrect,
        SetGray: ImagerState.StateSetGray,
        SetSampledColor: ImagerState.StateSetSampledColor,
        SetSampledBlack: ImagerState.StateSetSampledBlack,
        ShowBackward: MyShowBackward,
        MaskFill: MyMaskFill,
        MaskStroke: MyMaskStroke,
        ShowAndFixedXRel: MyShowAndFixedXRel,
        MaskDashedStroke: MyMaskDashedStroke,
        MaskRectangle: MyMaskRectangle,
        MaskRectangleI: MyMaskRectangleI,
        MaskVector: MyMaskVector,
        MaskPixel: MyMaskPixel,
        MaskBitmap: MyMaskBitmap,
        DrawBitmap: MyDrawBitmap,
        DrawPixels: MyDrawPixels,
        DoIfVisible: MyDoIfVisible,
        DoWithBuffer: MyDoWithBuffer,
        DrawObject: MyDrawObject,
        Clip: ImagerState.StateClip,
        ClipRectangle: ImagerState.StateClipRectangle,
        ClipRectangleI: ImagerState.StateClipRectangleI,
        GetCP: ImagerState.StateGetCP,
        GetBounds: MyGetBounds,
        ViewReset: MyViewReset,
        ViewTranslateI: MyViewTranslateI,
        ViewClip: MyViewClip,
        ViewClipRectangleI: MyViewClipRectangleI,
        GetTransformation: MyGetTransformation,
        Transform: MyTransform,
        MoveViewRectangle: MyMoveViewRectangle,
        TestViewRectangle: MyTestViewRectangle,
        propList: NIL
        ]];

    END.