
<<GGFileImpl.mesa>>
    <<Copyright Ó 1987, 1989, 1991, 1992 by Xerox Corporation.  All rights reserved.>>
    <<Pier, December 1, 1992 2:26 pm PST>>
    <<Kurlander, September 1, 1987 1:47:01 pm PDT>>
    <<Bier, December 3, 1992 5:27 pm PST>>
    <<Doug Wyatt, April 16, 1992 4:32 pm PDT>>
    <<>>
    <<Contents: Created October 12, 1987 by merging GGFileInImpl and GGFileOutImpl>>
    <<>>
DIRECTORY
Atom, CardTab, CodeTimer, Convert, Feedback, FeedbackTypes, GGBasicTypes, GGCoreOps, GGEvent, GGFileIn, GGFileOut, GGFont, 
GGInterfaceTypes, GGModelTypes, GGParseIn, GGParseOut, GGScene, GGSegmentTypes, GGSelect, GGSlice, GGSliceOps, GGState, 
GGUIUtility, GGUtility, Imager, ImagerColor, ImagerColorPrivate, ImagerTransformation, IO, Real, RefTab, Rope, SimpleFeedback, 
SymTab, ViewerClasses;

GGFileImpl: CEDAR PROGRAM
IMPORTS Atom, CardTab, CodeTimer, Convert, Feedback, GGCoreOps, GGEvent, GGFont, GGParseIn, GGParseOut, GGScene, GGSelect, GGSlice, 
GGSliceOps, GGState, GGUIUtility, GGUtility, Imager, ImagerColor, ImagerColorPrivate, IO, Real, RefTab, Rope, SimpleFeedback, SymTab
EXPORTS GGFileIn, GGFileOut = BEGIN

Camera: TYPE = GGModelTypes.Camera;
Caret: TYPE = GGInterfaceTypes.Caret;
Color: TYPE = Imager.Color;
DefaultData: TYPE = GGModelTypes.DefaultData;
    MsgRouter: TYPE = FeedbackTypes.MsgRouter;
FontData: TYPE = GGModelTypes.FontData;
GGData: TYPE = GGInterfaceTypes.GGData;
Point: TYPE = GGBasicTypes.Point;
ROPE: TYPE = Rope.ROPE;
Scene: TYPE = GGModelTypes.Scene;
Segment: TYPE = GGSegmentTypes.Segment;
SegmentClass: TYPE = GGSegmentTypes.SegmentClass;
Slice: TYPE = GGModelTypes.Slice;
SliceClass: TYPE = GGModelTypes.SliceClass;
SliceGenerator: TYPE = GGModelTypes.SliceGenerator;
StrokeEnd: TYPE = Imager.StrokeEnd;
StrokeJoint: TYPE = Imager.StrokeJoint;
Traj: TYPE = GGModelTypes.Traj;
Transformation: TYPE = ImagerTransformation.Transformation;
Viewer: TYPE = ViewerClasses.Viewer;

OutputPixelArrayTable: TYPE = REF OutputPixelArrayTableObj;
    OutputPixelArrayTableObj: TYPE = RECORD [
        nextIndex: NAT Ź 0,
        table: RefTab.Ref Ź NIL -- a mapping from pixel arrays to small integers
        ];

OutputColorTable: TYPE = REF OutputColorTableObj;
    OutputColorTableObj: TYPE = RECORD [
        pixelArrayTable: OutputPixelArrayTable,
        nextColorIndex: NAT Ź 0,
        constantOp: CardTab.Ref, -- keys off the intensity
        constantSpecial: RefTab.Ref, -- keys off the REF
        sampled: RefTab.Ref -- keys off the REF, used for sampled colors and sampled blacks
        ];

InputPixelArrayTable: TYPE = REF InputPixelArrayTableObj;
    InputPixelArrayTableObj: TYPE = RECORD [
        table: CardTab.Ref Ź NIL -- a mapping from small integers to pixel arrays
        ];

InputColorTable: TYPE = REF InputColorTableObj;
    InputColorTableObj: TYPE = RECORD [
        pixelArrayTable: InputPixelArrayTable,
        colors: CardTab.Ref Ź NIL -- a mapping from small integers to colors
        ];


CreateOutputColorTable: PROC [] RETURNS [ct: OutputColorTable] = {
ct Ź NEW[OutputColorTableObj];
ct.pixelArrayTable Ź NEW[OutputPixelArrayTableObj];
ct.pixelArrayTable.table Ź RefTab.Create[mod: 17];
ct.constantOp Ź CardTab.Create[mod: 17];
ct.constantSpecial Ź RefTab.Create[mod: 11];
ct.sampled Ź RefTab.Create[mod: 5];
};

NatRef: TYPE = REF NAT;
PickANumber: PROC [ct: OutputColorTable] RETURNS [natRef: NatRef] = {
natRef Ź NEW[NAT Ź ct.nextColorIndex];
ct.nextColorIndex Ź ct.nextColorIndex + 1;
};

FindColorInIntensityTable: PROC [op: ImagerColor.OpConstantColor, table: CardTab.Ref] RETURNS [found: BOOL Ź FALSE, nat: NAT Ź 0] = 
{
intensity: REAL Ź ImagerColorPrivate.IntensityFromColor[op];
key: CARD Ź Real.Floor[intensity*32767];
};

AddColorToOutputTable: PROC [color: Imager.Color, ct: OutputColorTable] = {
    gray: ImagerColor.OpConstantColor Ź ImagerColor.ColorFromGray[1];
    IF color=NIL THEN {
        <<Treat as a special color.>>
        }
    ELSE {
    WITH color SELECT FROM
    op: ImagerColor.OpConstantColor => {
    IF gray.colorOperator=op.colorOperator THEN {    -- "MakeGray"
    }
    ELSE {    --put out an RGB
    r, g, b: REAL;
    [r,g,b] Ź GGCoreOps.ExtractRGB[op];
    };
    };
    special: ImagerColor.SpecialColor =>  {
    <<f.PutF[" %g]", [rope[special.name]]];>>
    };
    sampledBlack: ImagerColor.SampledBlack => {
    };
    sampledColor: ImagerColor.SampledColor => {
    };
    ENDCASE => ERROR; -- Gargoyle doesn't know about this type of color
    };
};

<<Filing in>>
FileinSceneAndOptions: PUBLIC PROC [f: IO.STREAM, ggData: GGData, alignmentsOnly: BOOL, selectSlices: BOOL, closeStreamWhenDone: 
BOOL _ TRUE] RETURNS [success: BOOL Ź FALSE, sceneName: ROPE] = {
<<Loads any objects in f into ggData scene.  Merges any alignment line types in f into the viewer represented by ggData.  Changes 
other control panel state variables to options found in f if NOT alignmentsOnly.>>
ENABLE GGParseIn.SyntaxError => {
Feedback.PutFL[ggData.router, oneLiner, $Error, "position: %g, wasThere: %g, notThere: %g", LIST[[integer[position]], 
[rope[wasThere]], [rope[notThere]]] ];
GOTO Abort;
};
scene: Scene Ź ggData.scene;
version: REAL;
count: NAT;
entity: Slice;
finger, newEntities: LIST OF Slice;
[sceneName, version] Ź ReadHeaderAndOptions[f, ggData, IF alignmentsOnly THEN alignments ELSE all];
<<Read in the scene entities>>
GGParseIn.ReadRope[f, "Entities:"];
GGParseIn.ReadChar[f, '[];
count Ź GGParseIn.ReadNAT[f];
GGParseIn.ReadRope[f, "]:"]; GGParseIn.ReadWhiteSpace[f];
[newEntities, finger] Ź GGUtility.StartSliceList[];
FOR i: NAT IN[1..count] DO
entity Ź FileinEntity[f, version, ggData.router, ggData.camera];
    IF entity#NIL THEN [newEntities, finger] Ź GGUtility.AddSlice[entity, newEntities, finger];
    IF ggData.aborted[filein] THEN {
        ggData.aborted[filein] Ź FALSE;
    GGUIUtility.SafeClose[f, ggData.router];
        RETURN[FALSE, NIL];  -- signals a failed read
        };
ENDLOOP;
IF closeStreamWhenDone THEN GGUIUtility.SafeClose[f, ggData.router];
GGSelect.DeselectAll[scene, normal];
GGScene.AddSlices[scene, newEntities];
    IF selectSlices THEN FOR sliceList: LIST OF Slice Ź newEntities, sliceList.rest UNTIL sliceList=NIL DO
    GGSelect.SelectEntireSlice[sliceList.first, scene, normal];
    ENDLOOP;
RETURN[TRUE, sceneName];
EXITS
Abort => {}; -- RETURN[FALSE, NIL];
};

FileinSceneOnly: PUBLIC PROC [f: IO.STREAM, scene: Scene, selectSlices: BOOL, camera: Camera, closeStreamWhenDone: BOOL _ TRUE] 
RETURNS [success: BOOL Ź FALSE, sceneName: Rope.ROPE] = {
<<Ignores the control panel state variables options in f.  Merges any objects in f into scene.>>
ENABLE GGParseIn.SyntaxError => {
SimpleFeedback.PutFL[$Gargoyle, oneLiner, $Error, "position: %g, wasThere: %g, notThere: %g", LIST[[integer[position]], 
[rope[wasThere]], [rope[notThere]]] ];
GOTO Abort;
};
version: REAL;
count: NAT;
entity: Slice;
finger, newEntities: LIST OF Slice;
<<Read in the Header>>
GGParseIn.ReadRope[f, "Gargoyle file for scene: "];
sceneName Ź GGParseIn.ReadLine[f];
GGParseIn.ReadRope[f, "Produced by version"];
version Ź GGParseIn.ReadReal[f];
version Ź Real.Round[version*100.0]/100.0; -- compensate for fuzzy ReadReal of version
<<Read in the alignment objects, etc.>>
<<IF version >= 8607.17 THEN SkipOptions[f];>>
<<IF version >= 9207.29 THEN ReadSceneFields[f, version, scene];>>
IF version >= 8607.17 THEN ReadSceneFields[f, version, scene];
<<Read the scene entities>>
GGParseIn.ReadRope[f, "Entities:"];
GGParseIn.ReadChar[f, '[];
count Ź GGParseIn.ReadNAT[f];
GGParseIn.ReadRope[f, "]:"]; GGParseIn.ReadWhiteSpace[f];
[newEntities, finger] Ź GGUtility.StartSliceList[];
FOR i: NAT IN[1..count] DO
entity Ź FileinEntity[f, version, NIL, camera];
    IF entity#NIL THEN [newEntities, finger] Ź GGUtility.AddSlice[entity, newEntities, finger];
ENDLOOP;
    IF closeStreamWhenDone THEN GGUIUtility.SafeClose[f];
GGSelect.DeselectAll[scene, normal];
GGScene.AddSlices[scene, newEntities];
IF selectSlices THEN FOR sliceList: LIST OF Slice Ź newEntities, sliceList.rest UNTIL sliceList=NIL DO
GGSelect.SelectEntireSlice[sliceList.first, scene, normal];
ENDLOOP;
RETURN[TRUE, sceneName];
EXITS
Abort => {}; -- RETURN[FALSE, NIL];
};

FileinOptionsOnly: PUBLIC PROC [f: IO.STREAM, ggData: GGData, alignmentsOnly: BOOL, closeStreamWhenDone: BOOL _ TRUE] RETURNS 
[success: BOOL Ź FALSE, sceneName: Rope.ROPE] = {
<<Merges any alignment line types in f into the viewer represented by ggData.  Changes other control panel state variables to 
options found in f if NOT alignmentsOnly.>>
ENABLE GGParseIn.SyntaxError => {
Feedback.PutFL[ggData.router, oneLiner, $Error, "position: %g, wasThere: %g, notThere: %g", LIST[[integer[position]], 
[rope[wasThere]], [rope[notThere]]] ];
GOTO Abort;
};
version: REAL;
[sceneName, version] Ź ReadHeaderAndOptions[f, ggData, IF alignmentsOnly THEN alignments ELSE all];
    IF closeStreamWhenDone THEN GGUIUtility.SafeClose[f, ggData.router];
RETURN[TRUE, sceneName];
EXITS
Abort => {}; -- RETURN[FALSE, NIL];
};

ReadHeaderAndOptions: PROC [f: IO.STREAM, ggData: GGData, type: OptionType] RETURNS [sceneName: Rope.ROPE, version: REAL] = {
<<Read in the Header>>
GGParseIn.ReadRope[f, "Gargoyle file for scene: "];
sceneName Ź GGParseIn.ReadLine[f];
GGParseIn.ReadRope[f, "Produced by version"];
version Ź GGParseIn.ReadReal[f];
version Ź Real.Round[version*100.0]/100.0; -- compensate for fuzzy ReadReal of version
<<Read in the options.>>
    CodeTimer.StartInt[$ReadOptions, $Gargoyle];
IF version >= 8607.17 THEN ReadOptions[f, version, ggData, type]
ELSE GGEvent.StandardAlignments[ggData, LIST[NIL]];
    CodeTimer.StopInt[$ReadOptions, $Gargoyle];
};

ReadSceneFields: PROC [f: IO.STREAM, version: REAL, scene: Scene] = {
    keyWord, option: Rope.ROPE;
    good: BOOL;
    nextChar: CHAR;
    twoCRsFound: BOOL Ź FALSE;
<<Read in the Scene Fields that are Mentioned>>
    UNTIL twoCRsFound DO
        [keyWord, good] Ź GGParseIn.ReadKeyWord[f];
        IF NOT good THEN {
            nextChar Ź IO.PeekChar[f];
            IF IsEndLine[nextChar] THEN {
                [] Ź IO.GetChar[f];
                twoCRsFound Ź TRUE;
                };
            LOOP};
        good Ź GGParseIn.ReadHorizontalBlank[f];
        IF NOT good THEN {
            nextChar Ź IO.PeekChar[f];
            IF IsEndLine[nextChar] THEN {
                [] Ź IO.GetChar[f];
                twoCRsFound Ź TRUE;
                };
            LOOP};
        option Ź GGParseIn.ReadLine[f];
        ProcessSceneField[keyWord, option, version, scene];
        nextChar Ź IO.PeekChar[f];
        IF IsEndLine[nextChar] THEN {
            [] Ź IO.GetChar[f];
            twoCRsFound Ź TRUE;
            };
    ENDLOOP;
    };

ReadOptions: PROC [f: IO.STREAM, version: REAL, ggData: GGData, type: OptionType] = {
    keyWord, option: Rope.ROPE;
    good: BOOL;
    nextChar: CHAR;
    twoCRsFound: BOOL Ź FALSE;
<<Initialize Some Options>>
    GGState.SetPalette[ggData, FALSE];
<<Read in the Options that are Mentioned>>
    UNTIL twoCRsFound DO
        [keyWord, good] Ź GGParseIn.ReadKeyWord[f];
        IF NOT good THEN {
            nextChar Ź IO.PeekChar[f];
            IF IsEndLine[nextChar] THEN {
                [] Ź IO.GetChar[f];
                twoCRsFound Ź TRUE;
                };
            LOOP};
        good Ź GGParseIn.ReadHorizontalBlank[f];
        IF NOT good THEN {
            nextChar Ź IO.PeekChar[f];
            IF IsEndLine[nextChar] THEN {
                [] Ź IO.GetChar[f];
                twoCRsFound Ź TRUE;
                };
            LOOP};
        option Ź GGParseIn.ReadLine[f];
        ProcessOption[keyWord, option, version, ggData, type];
        nextChar Ź IO.PeekChar[f];
        IF IsEndLine[nextChar] THEN {
            [] Ź IO.GetChar[f];
            twoCRsFound Ź TRUE;
            };
    ENDLOOP;
    };

ReadListOfAtom: PUBLIC PROC [f: IO.STREAM] RETURNS [atomList: LIST OF ATOM] = {
cr: Rope.ROPE = Rope.FromChar[IO.CR];
lf: Rope.ROPE = Rope.FromChar[IO.LF];
rightParen: Rope.ROPE = Rope.FromChar[')];
rightBracket: Rope.ROPE = Rope.FromChar[']];
AtomsOnOneLineOrParenProc: SAFE PROC [char: CHAR] RETURNS [IO.CharClass] = {
SELECT char FROM
IO.LF, IO.CR, '), '] =>RETURN [break];
IO.SP, IO.TAB, ', , '; => RETURN [sepr];
ENDCASE => RETURN [other];
};

rope: Rope.ROPE;
end: BOOL Ź FALSE;
[] Ź IO.SkipWhitespace[f, TRUE];
atomList Ź NIL;
WHILE TRUE DO
[rope, ----] Ź IO.GetTokenRope[f, AtomsOnOneLineOrParenProc
!IO.EndOfStream => {end Ź TRUE; CONTINUE}];
IF end OR rope = NIL THEN RETURN;
IF Rope.Equal[rope, cr] OR Rope.Equal[rope, lf] THEN RETURN;
IF Rope.Equal[rope, rightParen] THEN {
f.Backup[')];
RETURN;
};
IF Rope.Equal[rope, rightBracket] THEN {
f.Backup[']];
RETURN;
};
atomList Ź AppendAtomToAtomList[Atom.MakeAtom[rope], atomList];
ENDLOOP;
};

AppendAtomToAtomList: PROC [atom: ATOM, list: LIST OF ATOM] RETURNS [LIST OF ATOM] = {
<<A copy of List.Nconc1 for LIST OF Rope.ROPE instead of LIST OF REF ANY>>
    z: LIST OF ATOM Ź list;
    IF z = NIL THEN RETURN[CONS[atom,NIL]];
    UNTIL z.rest = NIL DO z Ź z.rest; ENDLOOP;
    z.rest Ź CONS[atom,NIL];
    RETURN[list];
    };

    OptionType: TYPE = {alignments, normal, sceneField, all, none};
    optionTable: SymTab.Ref;
    OptionData: TYPE = REF OptionDataObj;
    OptionDataObj: TYPE = RECORD [
        process: ProcessOptionProc _ NIL,
        processScene: ProcessSceneFieldProc _ NIL,
        type: OptionType
        ];

    FindOption: PROC [name: ROPE] RETURNS [optionData: OptionData _ NIL] = {
        found: BOOL;
        val: REF;
        [found, val] _ SymTab.Fetch[optionTable, name];
        IF found THEN optionData _ NARROW[val];
        };

    RegisterAllOptions: PROC [] = {
        RegisterOption: PROC [name: ROPE, process: ProcessOptionProc, type: OptionType] = {
            optionData: OptionData;
            optionData _ NEW[OptionDataObj _ [process: process, processScene: NIL, type: type]];
            [] _ SymTab.Store[optionTable, name, optionData];
            };
        RegisterSceneField: PROC [name: ROPE, process: ProcessSceneFieldProc] = {
            optionData: OptionData;
            optionData _ NEW[OptionDataObj _ [process: NIL, processScene: process, type: sceneField]];
            [] _ SymTab.Store[optionTable, name, optionData];
            };
        optionTable _ SymTab.Create[29];
        RegisterOption["ViewTransform", ProcessViewTransform, normal];
        RegisterOption["PaletteForFillColor", ProcessPaletteForFillColor, normal];
        RegisterOption["PaletteForStrokeColor", ProcessPaletteForStrokeColor, normal];
        RegisterOption["Palette", ProcessPalette, normal];
        RegisterOption["Scripts", ProcessScripts, normal];
        RegisterOption["Slope", ProcessSlope, alignments];
        RegisterOption["Angle", ProcessAngle, alignments];
        RegisterOption["Radius", ProcessRadius, alignments];
        RegisterOption["LineDistance", ProcessLineDistance, alignments];
        RegisterOption["Anchor", ProcessAnchor, alignments];
        RegisterOption["Midpoints", ProcessMidpoints, normal];
        RegisterOption["Heuristics", ProcessHeuristics, normal];
        RegisterOption["ShowAlignments", ProcessShowAlignments, normal];
        RegisterOption["ShowColors", ProcessShowColors, normal];
        RegisterOption["Gravity", ProcessGravity, normal];
        RegisterOption["ScaleUnit", ProcessScaleUnit, normal];
        RegisterOption["DisplayStyle", ProcessDisplayStyle, normal];
        RegisterOption["GravityExtent", ProcessGravityExtent, normal];
        RegisterOption["GravityType", ProcessGravityType, normal];
        RegisterOption["DefaultFont", ProcessDefaultFont, normal];
        RegisterOption["Defaults", ProcessDefaults, normal];
        RegisterOption["Dashed", ProcessDashed, normal];
        RegisterOption["Shadows", ProcessShadows, normal];
        RegisterOption["Active", ProcessActive, normal];
        RegisterSceneField["BackgroundColor", ProcessBackgroundColor];
        };

    ProcessSceneField: PROC [keyWord, option: Rope.ROPE, version: REAL, scene: Scene] = {
        optionStream: IO.STREAM;
        optionData: OptionData;

        optionStream Ź IO.RIS[option];
        optionData _ FindOption[keyWord];
        IF optionData = NIL THEN {
            <<SIGNAL Problem[msg: Rope.Concat["Unknown keyword in gargoyle file: ", keyWord]];>>
            SimpleFeedback.PutF[$Gargoyle, oneLiner, $Error, "Unknown keyword in gargoyle file: %g", [rope[keyWord]]];
            }
        ELSE {
            IF optionData.type # sceneField THEN RETURN;
            optionData.processScene[keyWord, scene, optionStream, version];
            };
        };

    ProcessOption: PROC [keyWord, option: Rope.ROPE, version: REAL, ggData: GGData, types: OptionType] = {
        optionStream: IO.STREAM;
        optionData: OptionData;

        IF types = none THEN RETURN;
        optionStream Ź IO.RIS[option];
        optionData _ FindOption[keyWord];
        IF optionData = NIL THEN {
            <<SIGNAL Problem[msg: Rope.Concat["Unknown keyword in gargoyle file: ", keyWord]];>>
            SimpleFeedback.PutF[$Gargoyle, oneLiner, $Error, "Unknown keyword in gargoyle file: %g", [rope[keyWord]]];
            }
        ELSE {
            IF types = sceneField AND NOT optionData.type = sceneField THEN RETURN;
            IF types = alignments AND NOT optionData.type = alignments THEN RETURN;
            IF types = normal AND NOT optionData.type = normal THEN RETURN;
            IF optionData.type = sceneField
                THEN optionData.processScene[keyWord, ggData.scene, optionStream, version]
                ELSE optionData.process[keyWord, ggData, optionStream, version];
            };
        };

    ProcessOptionProc: TYPE = PROC [keyWord: ROPE, ggData: GGData, optionStream: IO.STREAM, version: REAL];
    ProcessSceneFieldProc: TYPE = PROC [keyWord: ROPE, scene: Scene, optionStream: IO.STREAM, version: REAL];
    ProcessViewTransform: ProcessOptionProc = {
        clientToViewer: Transformation _ GGParseIn.ReadTransformation[optionStream];
        GGState.SetBiScrollersTransform[ggData, clientToViewer];
        };
    ProcessPaletteForFillColor: ProcessOptionProc = {
        active: BOOL Ź GGParseIn.ReadBool[optionStream];
        IF active THEN GGState.SetPalette[ggData, TRUE];
        };
    ProcessPaletteForStrokeColor: ProcessOptionProc = {
        active: BOOL Ź GGParseIn.ReadBool[optionStream];
        IF active THEN GGState.SetPalette[ggData, TRUE];
        };
    ProcessPalette: ProcessOptionProc = {
        active: BOOL Ź GGParseIn.ReadBool[optionStream];
        IF active THEN GGState.SetPalette[ggData, TRUE];
        };
    ProcessScripts: ProcessOptionProc = {
        names: LIST OF Rope.ROPE Ź GGParseIn.ReadListOfRope[optionStream];
        ggData.debug.autoScriptNames Ź GGCoreOps.NewRopeListt[];
        FOR list: LIST OF Rope.ROPE Ź names, list.rest UNTIL list = NIL DO
            GGCoreOps.AppendRope[list.first, ggData.debug.autoScriptNames];
            ENDLOOP;
        };
    ProcessSlope: ProcessOptionProc = {
        IF version>=8706.16 THEN { -- slope values and ON states
            values: LIST OF REAL;
            on: LIST OF BOOL;
            [----, values, on] Ź GGParseIn.ReadScalarButtonValues[optionStream, version];
            GGState.AddSlopeList[ggData, values, on];
            }
        ELSE { -- slope values only
            values, ptr: LIST OF REAL;
            optionList: LIST OF ROPE;
            value: REAL;
            optionList Ź GGParseIn.ReadListOfRope[optionStream];
            [values, ptr] Ź GGCoreOps.StartRealList[];
            FOR list: LIST OF Rope.ROPE Ź optionList, list.rest UNTIL list = NIL DO
                value Ź Convert.RealFromRope[list.first];
                [values, ptr] Ź GGCoreOps.AddReal[value, values, ptr];
                ENDLOOP;
            GGState.AddSlopeList[ggData, values, NIL];
            };
        };
    ProcessAngle: ProcessOptionProc = {
        IF version>=8706.16 THEN { -- angle values and ON states
            values: LIST OF REAL;
            on: LIST OF BOOL;
            [----, values, on] Ź GGParseIn.ReadScalarButtonValues[optionStream, version];
            GGState.AddAngleList[ggData, values, on];
            }
        ELSE { -- angle values only
            values, ptr: LIST OF REAL;
            value: REAL;
            optionList: LIST OF ROPE;
            optionList Ź GGParseIn.ReadListOfRope[optionStream];
            [values, ptr] Ź GGCoreOps.StartRealList[];
            FOR list: LIST OF Rope.ROPE Ź optionList, list.rest UNTIL list = NIL DO
                value Ź Convert.RealFromRope[list.first];
                [values, ptr] Ź GGCoreOps.AddReal[value, values, ptr];
                ENDLOOP;
            GGState.AddAngleList[ggData, values, NIL];
            };
        };
    ProcessRadius: ProcessOptionProc = {
        IF version>=8706.16 THEN { -- radius values and ON states
            values: LIST OF REAL;
            on: LIST OF BOOL;
            names: LIST OF Rope.ROPE;
            [names, values, on] Ź GGParseIn.ReadScalarButtonValues[optionStream, version];
            GGState.AddRadiusList[ggData, names, values, on];
            }
        ELSE { -- radius values only
            values, ptr: LIST OF REAL;
            value: REAL;
            optionList: LIST OF ROPE;
            optionList Ź GGParseIn.ReadListOfRope[optionStream];
            [values, ptr] Ź GGCoreOps.StartRealList[];
            FOR list: LIST OF Rope.ROPE Ź optionList, list.rest UNTIL list = NIL DO
                value Ź Convert.RealFromRope[list.first];
                [values, ptr] Ź GGCoreOps.AddReal[value, values, ptr];
                ENDLOOP;
            GGState.AddRadiusList[ggData, NIL, values, NIL];
            };
        };
    ProcessLineDistance: ProcessOptionProc = {
        IF version>=8706.16 THEN { -- LineDistance values and ON states
            values: LIST OF REAL;
            on: LIST OF BOOL;
            names: LIST OF Rope.ROPE;
            [names, values, on] Ź GGParseIn.ReadScalarButtonValues[optionStream, version];
            GGState.AddLineDistanceList[ggData, names, values, on];
            }
        ELSE { -- LineDistance values only
            values, ptr: LIST OF REAL;
            value: REAL;
            optionList: LIST OF ROPE;
            optionList Ź GGParseIn.ReadListOfRope[optionStream];
            [values, ptr] Ź GGCoreOps.StartRealList[];
            FOR list: LIST OF Rope.ROPE Ź optionList, list.rest UNTIL list = NIL DO
                value Ź Convert.RealFromRope[list.first];
                [values, ptr] Ź GGCoreOps.AddReal[value, values, ptr];
                ENDLOOP;
            GGState.AddLineDistanceList[ggData, NIL, values, NIL];
            };
        };
    ProcessAnchor: ProcessOptionProc = {
        anchored: BOOL;
        anchored Ź GGParseIn.ReadBool[optionStream];
        IF anchored THEN {
            point: Point Ź GGParseIn.ReadPoint[optionStream];
            ggData.anchor­ Ź [exists: TRUE, point: point, chair: NIL, attractor: NIL];
            }
        ELSE ggData.anchor.exists Ź FALSE;
        };
    ProcessMidpoints: ProcessOptionProc = {
        on: BOOL;
        on Ź GGParseIn.ReadBool[optionStream];
        GGState.SetMidpoints[ggData, on];
        };
    ProcessHeuristics: ProcessOptionProc = {
        on: BOOL;
        on Ź GGParseIn.ReadBool[optionStream];
        GGState.SetHeuristics[ggData, on];
        };
    ProcessShowAlignments: ProcessOptionProc = {
        on: BOOL;
        on Ź GGParseIn.ReadBool[optionStream];
        GGState.SetShowAlignments[ggData, on];
        };
    ProcessShowColors: ProcessOptionProc = {
        on: BOOL;
        on Ź GGParseIn.ReadBool[optionStream];
    <<GGState.SetShowColors[ggData, on];>>
        };
    ProcessGravity: ProcessOptionProc = {
        on: BOOL;
        on Ź GGParseIn.ReadBool[optionStream];
        GGState.SetGravity[ggData, on];
        };
    ProcessScaleUnit: ProcessOptionProc = {
        real: REAL Ź GGParseIn.ReadReal[optionStream];
        IF real>0.0 THEN GGState.SetScaleUnit[ggData, real, NIL];
        };
    ProcessDisplayStyle: ProcessOptionProc = {
        rope: Rope.ROPE Ź GGParseIn.ReadWord[optionStream];
        GGState.SetDisplayStyle[ggData, GGUIUtility.DisplayStyleFromRope[rope]];
        };
    ProcessGravityExtent: ProcessOptionProc = {
        real: REAL Ź GGParseIn.ReadReal[optionStream];
        GGState.SetGravityExtent[ggData, real];
        };
    ProcessGravityType: ProcessOptionProc = {
        rope: Rope.ROPE Ź GGParseIn.ReadWord[optionStream];
        GGState.SetGravityType[ggData, GGUIUtility.GravityTypeFromRope[rope]];
        };
    ProcessDefaultFont: ProcessOptionProc = {
        fontData: FontData Ź GGFont.CreateFontData[]; -- assure non-NIL font data
        fontData Ź GGFont.ParseFontData[data: fontData, inStream: optionStream, literalP: TRUE, transformP: TRUE, storedSizeP: TRUE, 
        designSizeP: TRUE ! GGFont.ParseError => CONTINUE;];
        fontData.substituteOK Ź TRUE; -- bad hack here. Avoids a bogus default font
        GGState.SetDefaultFont[ggData, fontData];
        };
    ProcessDefaults: ProcessOptionProc = {
        strokeJoint, strokeEnd: Rope.ROPE;
        ggData.defaults.fillColor Ź GGParseIn.ReadColor[optionStream, version];
        ggData.defaults.strokeColor Ź GGParseIn.ReadColor[optionStream, version];
        ggData.defaults.strokeWidth Ź GGParseIn.ReadReal[optionStream];
        strokeJoint Ź GGParseIn.ReadWord[optionStream];
        ggData.defaults.strokeJoint Ź SELECT TRUE FROM
            Rope.Equal[strokeJoint, "miter", FALSE] => miter,
            Rope.Equal[strokeJoint, "bevel", FALSE] => bevel,
            ENDCASE => round;
        strokeEnd Ź GGParseIn.ReadWord[optionStream];
        ggData.defaults.strokeEnd Ź SELECT TRUE FROM
            Rope.Equal[strokeEnd, "square", FALSE] => square,
            Rope.Equal[strokeEnd, "butt", FALSE] => butt,
            ENDCASE => round;
        };
    ProcessDashed: ProcessOptionProc = {
        dashed: BOOL;
        dashed Ź GGParseIn.ReadBool[optionStream];
        ggData.defaults.dashed Ź dashed;
        IF ggData.defaults.dashed THEN {
            ggData.defaults.pattern Ź GGParseIn.ReadArrayOfReal[optionStream];
            ggData.defaults.offset Ź GGParseIn.ReadReal[optionStream];
            ggData.defaults.length Ź GGParseIn.ReadReal[optionStream];
            };
        };
    ProcessShadows: ProcessOptionProc = {
        shadowed: BOOL;
        ggData.defaults.textColor Ź GGParseIn.ReadColor[optionStream, version];
        IF ggData.defaults.textColor=NIL THEN ggData.defaults.textColor Ź Imager.black;
            <<fixes NIL text color defaults in many older files.  Added by Pier, July 17, 1991>>
        shadowed Ź GGParseIn.ReadBool[optionStream];
        ggData.defaults.dropShadowOn Ź shadowed;
        IF ggData.defaults.dropShadowOn THEN {
            ggData.defaults.dropShadowOffset Ź GGParseIn.ReadPoint[optionStream];
            ggData.defaults.dropShadowColor Ź GGParseIn.ReadColor[optionStream, version];
            };
        };
    ProcessActive: ProcessOptionProc = {
        active: BOOL;
        active Ź GGParseIn.ReadBool[optionStream];
        GGState.SetActive[ggData, active];
            };
    ProcessBackgroundColor: ProcessSceneFieldProc = {
        color: Imager.Color Ź GGParseIn.ReadColor[optionStream, version];
        GGScene.SetBackgroundColor[scene, color];
        };

SkipOptions: PROC [f: IO.STREAM] = {
    keyWord, option: Rope.ROPE;
    good: BOOL;
    nextChar: CHAR;
    twoCRsFound: BOOL Ź FALSE;
    UNTIL twoCRsFound DO
        [keyWord, good] Ź GGParseIn.ReadKeyWord[f];
        IF NOT good THEN {
            nextChar Ź IO.PeekChar[f];
            IF IsEndLine[nextChar] THEN {
                [] Ź IO.GetChar[f];
                twoCRsFound Ź TRUE;
                };
            LOOP};
        good Ź GGParseIn.ReadHorizontalBlank[f];
        IF NOT good THEN {
            nextChar Ź IO.PeekChar[f];
            IF IsEndLine[nextChar] THEN {
                [] Ź IO.GetChar[f];
                twoCRsFound Ź TRUE;
                };
            LOOP};
        option Ź GGParseIn.ReadLine[f];
    <<ProcessOption[keyWord, option, ggData];>>
        nextChar Ź IO.PeekChar[f];
        IF IsEndLine[nextChar] THEN {
            [] Ź IO.GetChar[f];
            twoCRsFound Ź TRUE;
            };
    ENDLOOP;
    };

FileinEntity: PROC [f: IO.STREAM, version: REAL, router: MsgRouter, camera: Camera] RETURNS [entity: Slice] = {
nextWord: Rope.ROPE;
IF version > 8605.22 THEN {
IF version >= 8705.14 THEN {
    entity Ź GGSliceOps.FileinSlice[f, version, router, camera];
}
ELSE {
nextWord Ź GGParseIn.ReadWord[f];
SELECT TRUE FROM
Rope.Equal[nextWord, "Outline:"] => {
    class: SliceClass Ź GGSlice.FetchSliceClass[$Outline];
    entity Ź class.filein[f, version, router, camera];
};
Rope.Equal[nextWord, "Slice"] => {
    entity Ź GGSliceOps.FileinSlice[f, version, router, camera];
};
ENDCASE => ERROR
}
}
    ELSE {
    nextWord Ź GGParseIn.ReadWord[f];
    SELECT TRUE FROM
    Rope.Equal[nextWord, "Outline:"] => {
        class: SliceClass Ź GGSlice.FetchSliceClass[$Outline];
        entity Ź class.filein[f, version, router, camera];
    };
    Rope.Equal[nextWord, "Cluster"] => {
        entity Ź GGSliceOps.FileinSlice[f, version, router, camera];
    };
    ENDCASE => ERROR;
    };
};

<<Filing out>>
FileoutSceneAndOptions: PUBLIC PROC [f: IO.STREAM, ggData: GGData, fileName: Rope.ROPE, scene: Scene Ź NIL] = {
sceneOut: Scene Ź IF scene#NIL THEN scene ELSE ggData.scene;
sliceCount: NAT Ź GGScene.CountSlices[sceneOut, first];
DoFileOut: PROC [slice: Slice] RETURNS [done: BOOL Ź FALSE] = {
    f.PutChar[IO.LF]; -- CR before each top-Level slice
    GGSliceOps.FileoutSlice[f, slice];
    };
f.PutF1["Gargoyle file for scene: %g\n", [rope[fileName]]];
f.PutF1["Produced by version %g\n\n", [rope[GGUtility.versionRope]]];
FileoutOptions[f, ggData];
    FileoutSceneFields[f, ggData.scene];
    f.PutChar[IO.LF];
f.PutF1["Entities: [%g]:\n\n", [integer[sliceCount]]];
[] Ź GGScene.WalkSlices[sceneOut, first, DoFileOut];
};

FileoutSceneOnly: PUBLIC PROC [f: IO.STREAM, scene: Scene, fileName: Rope.ROPE] = {
sliceCount: NAT Ź GGScene.CountSlices[scene, first];
DoFileOut: PROC [slice: Slice] RETURNS [done: BOOL Ź FALSE] = {
    f.PutChar[IO.LF];
    GGSliceOps.FileoutSlice[f, slice];
    };
f.PutF1["Gargoyle file for scene: %g\n", [rope[fileName]]];
f.PutF1["Produced by version %g\n\n", [rope[GGUtility.versionRope]]];
    FileoutSceneFields[f, scene];
    f.PutChar[IO.LF];
f.PutF1["Entities: [%g]:\n\n", [integer[sliceCount]]];
    [] Ź GGScene.WalkSlices[scene, first, DoFileOut];
};

FileoutSceneFields: PROC [f: IO.STREAM, scene: Scene] = {
f.PutRope["BackgroundColor: "];
GGParseOut.WriteColor[f, GGScene.GetBackgroundColor[scene]];
    f.PutChar[IO.LF];
};

FileoutOptions: PROC [f: IO.STREAM, ggData: GGData] = {
    values: LIST OF REAL;
    on: LIST OF BOOL;
    names: LIST OF Rope.ROPE;
    defaults: DefaultData;
    anchor: Caret;
f.PutRope["ViewTransform: "];
GGParseOut.WriteTransformation[f, GGState.GetBiScrollersTransform[ggData]];
    f.PutChar[IO.LF];
f.PutRope["Scripts: "];
GGParseOut.WriteListOfRope[f, ggData.debug.autoScriptNames.list];
    f.PutChar[IO.LF];
f.PutRope["Slope: "];
    [values, on] Ź GGState.GetSlopeAlignments[ggData];
    GGParseOut.WriteScalarButtonValues[f, NIL, values, on];
    f.PutChar[IO.LF];
f.PutRope["Angle: "];
    [values, on] Ź GGState.GetAngleAlignments[ggData];
    GGParseOut.WriteScalarButtonValues[f, NIL, values, on];
    f.PutChar[IO.LF];
f.PutRope["Radius: "];
    [names, values, on] Ź GGState.GetRadiusAlignments[ggData];
    GGParseOut.WriteScalarButtonValues[f, names, values, on];
    f.PutChar[IO.LF];
f.PutRope["LineDistance: "];
    [names, values, on] Ź GGState.GetLineDistanceAlignments[ggData];
    GGParseOut.WriteScalarButtonValues[f, names, values, on];
f.PutRope["\nMidpoints: "];
    GGParseOut.WriteBool[f, GGState.GetMidpoints[ggData]];
f.PutRope["\nHeuristics: "];
    GGParseOut.WriteBool[f, GGState.GetHeuristics[ggData]];
f.PutRope["\nShowAlignments: "];
    GGParseOut.WriteBool[f, GGState.GetShowAlignments[ggData]];
f.PutF1["\nScaleUnit: %g", [real[GGState.GetScaleUnit[ggData]]] ];
    f.PutF1["\nDisplayStyle: %g", [rope[GGUIUtility.DisplayStyleToRope[GGState.GetDisplayStyle[ggData]] ]] ];
f.PutRope["\nGravity: "];
    GGParseOut.WriteBool[f, GGState.GetGravity[ggData]];
    f.PutF1["\nGravityExtent: %g", [real[GGState.GetGravityExtent[ggData]]] ];
    f.PutF1["\nGravityType: %g", [rope[GGUIUtility.GravityTypeToRope[GGState.GetGravityType[ggData]] ]] ];
    defaults Ź GGState.GetDefaults[ggData];
    f.PutF1["\nDefaultFont: %g ", [rope[defaults.font.literal]] ];
    GGParseOut.WriteFactoredTransformationVEC[f, defaults.font.transform];
    f.PutF[" %g %g", [real[defaults.font.storedSize]], [real[defaults.font.designSize]] ];
    f.PutRope["\nDefaults: "];
    GGParseOut.WriteColor[f, defaults.fillColor];
    f.PutChar[' ]; -- put a SPACE
    GGParseOut.WriteColor[f, defaults.strokeColor];
    f.PutF1[" %g", [real[defaults.strokeWidth]] ];
    f.PutF1[" %g", [rope[SELECT defaults.strokeJoint FROM
        bevel => "bevel",
        miter => "miter",
        ENDCASE => "round"
        ]] ];
    f.PutF1[" %g", [rope[SELECT defaults.strokeEnd FROM
        square => "square",
        butt => "butt",
        ENDCASE => "round"
        ]] ];
f.PutRope["\nDashed: "];
    GGParseOut.WriteBool[f, defaults.dashed];
    IF defaults.dashed THEN {
        f.PutChar[' ]; -- put a SPACE
        GGParseOut.WriteArrayOfReal[f, defaults.pattern];
        f.PutF[" %g %g", [real[defaults.offset]], [real[defaults.length]] ];
        };
    f.PutChar[' ]; -- put a SPACE
f.PutRope["\nShadows: "];
    GGParseOut.WriteColor[f, defaults.textColor];
    GGParseOut.WriteBool[f, defaults.dropShadowOn];
    IF defaults.dropShadowOn THEN {
        f.PutChar[' ]; -- put a SPACE
        GGParseOut.WritePoint[f, defaults.dropShadowOffset];
        GGParseOut.WriteColor[f, defaults.dropShadowColor];
        };
    anchor Ź GGState.GetAnchor[ggData];
    f.PutRope["\nAnchor: "];
    GGParseOut.WriteBool[f, IF anchor=NIL THEN FALSE ELSE anchor.exists];
    IF anchor.exists THEN {
        f.PutChar[' ]; -- put a SPACE
        GGParseOut.WritePoint[f, anchor.point];
        };
    f.PutRope["\nPalette: "];
    GGParseOut.WriteBool[f, GGState.GetPalette[ggData]];
    f.PutRope["\nActive: "];
    GGParseOut.WriteBool[f, GGState.GetActive[ggData]];
    f.PutChar[IO.LF];
};

    IsEndLine: PROC [c: CHAR] RETURNS [BOOL] = {
        RETURN[c=IO.CR OR c=IO.LF];
        };

    RegisterAllOptions[];

END.