<<>>
    <<EditPropertiesImpl.mesa>>
        <<Copyright Ó 1986, 1989, 1991, 1992 by Xerox Corporation.  All rights reserved.>>
        <<Hal Murray, December 22, 1986 4:02:22 pm PST>>
        <<Michael Plass, August 11, 1988 4:19:41 pm PDT>>
        <<Doug Wyatt, February 25, 1992 4:37 pm PST>>

    DIRECTORY Atom, CharOps, NodeProps, Prop, RefText, Rope, RuntimeError, TEditDocument, TEditInput, TEditSelection, 
    TEditSelectionOps, TextNode, Tioga, TiogaAccess, TiogaAccessViewers, TiogaOps, ViewerClasses, ViewerOps;

    EditPropertiesImpl: CEDAR PROGRAM
    IMPORTS Atom, CharOps, NodeProps, Prop, RefText, Rope, RuntimeError, TEditInput, TEditSelection, TEditSelectionOps, TextNode, 
    TiogaAccess, TiogaAccessViewers, TiogaOps, ViewerOps
    ~ BEGIN

        ROPE: TYPE ~ Rope.ROPE;
        Viewer: TYPE ~ ViewerClasses.Viewer;


        TranslateToOpenProperties: PROC [reader: TiogaAccess.Reader, writer: TiogaAccess.Writer, rootOnly: BOOL Ź FALSE] ~ {
            t: TiogaAccess.TiogaChar Ź [charSet: 0, char: 0C, looks: ALL[FALSE], format: NIL, comment: FALSE, endOfNode: FALSE, deltaLevel: 0, 
            propList: NIL];
            node: TiogaAccess.TiogaChar Ź [charSet: 0, char: 15C, looks: ALL[FALSE], format: $code, comment: FALSE, endOfNode: TRUE, 
            deltaLevel: 0, propList: NIL];
            nest: TiogaAccess.TiogaChar Ź [charSet: 0, char: 15C, looks: ALL[FALSE], format: $code, comment: FALSE, endOfNode: TRUE, 
            deltaLevel: 1, propList: NIL];
            outc: TiogaAccess.TiogaChar Ź [charSet: 0, char: 0C, looks: ALL[FALSE], format: NIL, comment: FALSE, endOfNode: FALSE, deltaLevel: 
            0, propList: NIL];
            PutRope: PROC [rope: ROPE] ~ {
                FOR i: INT IN [0..Rope.Size[rope]) DO
                    outc.char Ź Rope.Fetch[rope, i];
                    TiogaAccess.Put[writer, outc];
                    ENDLOOP;
                };
            PutOctal: PROC [b: [0..256)] ~ {
                outc.char Ź '0+b/64;
                TiogaAccess.Put[writer, outc];
                outc.char Ź '0+(b/8) MOD 8;
                TiogaAccess.Put[writer, outc];
                outc.char Ź '0+b MOD 8;
                TiogaAccess.Put[writer, outc];
                };
            PutPropName: PROC [atom: ATOM] ~ {
                save: Tioga.Looks Ź outc.looks;
                outc.looks['n] Ź TRUE;
                PutRope[Atom.GetPName[atom]];
                outc.looks Ź save;
                PutRope[": "];
                };
            PutKey: PROC [rope: ROPE] ~ {
                save: Tioga.Looks Ź outc.looks;
                outc.looks['k] Ź TRUE;
                outc.looks['b] Ź TRUE;
                PutRope[rope];
                outc.looks Ź save;
                };
            PutProperties: PROC [propList: Prop.PropList] ~ {
                action: Prop.MapAction ~ { PutProperty[NARROW[key], val] };
                [] Ź Prop.Map[propList, action];
                };
            PutProperty: PROC [key: ATOM, value: REF] ~ {
                IF value # NIL THEN {
                    rope: ROPE ~ TiogaAccess.GetExternalProp[key, value];
                    PutPropName[key];
                    IF rope = NIL OR NodeProps.Is[key, $ClientOnly]
                        THEN {
                            save: Tioga.Looks Ź outc.looks;
                            savedPropList: Prop.PropList ~ node.propList;
                            outc.looks['c] Ź TRUE;
                            PutRope["(opaque)"];
                            outc.looks Ź save;
                            node.propList Ź Prop.Put[node.propList, $OpaqueValue, value];
                            TiogaAccess.Put[writer, node];
                            node.propList Ź savedPropList;
                            }
                        ELSE {
                            PutRope[rope];
                            TiogaAccess.Put[writer, node];
                            };
                    };
                };
            TranslateNodeContents: PROC ~ {
                UNTIL t.endOfNode DO
                    looks: Tioga.Looks ~ t.looks;
                    propList: Prop.PropList ~ t.propList;
                    IF t.charSet = 0 AND t.char IN [' ..'~]
                        THEN {
                            <<Emit a run of printable ascii characters, all with the same looks and properties>>
                            PutPropName[$Text];
                            WHILE NOT t.endOfNode AND t.charSet = 0 AND t.char IN [' ..'~] AND t.looks=looks AND t.propList = propList DO
                                save: Tioga.Looks Ź outc.looks;
                                outc.char Ź t.char;
                                outc.looks['o] Ź TRUE;
                                TiogaAccess.Put[writer, outc];
                                outc.looks Ź save;
                                t Ź TiogaAccess.Get[reader];
                                ENDLOOP;
                            }
                        ELSE {
                            <<Emit a single XC character>>
                            PutPropName[$Char];
                            PutRope["("];
                            PutOctal[t.charSet];
                            PutRope["|"];
                            PutOctal[ORD[t.char]];
                            PutRope[")"];
                            t Ź TiogaAccess.Get[reader];
                            };
                    TiogaAccess.Put[writer, node];
                    IF looks # ALL[FALSE] THEN {
                        <<Emit the looks that apply to the previous text or character>>
                        TiogaAccess.Nest[writer, 1];
                        PutKey["LOOKS"];
                        PutRope["("];
                        FOR c: Tioga.Look IN Tioga.Look DO
                            IF looks[c] THEN {outc.char Ź c; TiogaAccess.Put[writer, outc]};
                            ENDLOOP;
                        PutRope[")"];
                        TiogaAccess.Put[writer, node];
                        TiogaAccess.Nest[writer, -1];
                        };
                    IF propList # NIL THEN {
                        <<Emit the properties that apply to the previous text or character>>
                        TiogaAccess.Nest[writer, 1];
                        PutProperties[propList];
                        TiogaAccess.Nest[writer, -1];
                        };
                    ENDLOOP;
                };
            UNTIL TiogaAccess.EndOf[reader] DO
                t Ź TiogaAccess.Get[reader];
                PutKey[IF rootOnly THEN "BEGIN ROOT NODE" ELSE "BEGIN NODE"]; TiogaAccess.Put[writer, nest];
                    IF NOT t.endOfNode  THEN {
                        PutKey["CONTENTS"]; TiogaAccess.Put[writer, nest];
                            TranslateNodeContents[];
                        TiogaAccess.Nest[writer, -1];
                        };
                    PutKey["PROPERTIES"]; TiogaAccess.Put[writer, nest];
                        PutProperty[$Comment, NodeProps.ValueFromBool[t.comment]];
                        PutProperty[$Format, NodeProps.ValueFromAtom[t.format]];
                        PutProperties[t.propList];
                        TiogaAccess.Nest[writer, -1];
                    PutKey["END NODE"];
                    TiogaAccess.Put[writer, node];
                    TiogaAccess.Nest[writer, t.deltaLevel-1];
                IF rootOnly THEN EXIT;
                ENDLOOP;
            UNTIL TiogaAccess.EndOf[reader] DO
                [] Ź TiogaAccess.CopyNode[writer: writer, reader: reader];
                ENDLOOP;
            };

        Cant: ERROR ~ CODE;
        TranslateFromOpenProperties: PROC [reader: TiogaAccess.Reader, writer: TiogaAccess.Writer, doRoot: BOOL] ~ {
            Must: PROC [assertion: BOOL] ~ {IF NOT assertion THEN Cant[]};
            break: TiogaAccess.TiogaChar Ź [charSet: 0, char: 0C, looks: ALL[FALSE], format: NIL, comment: FALSE, endOfNode: FALSE, deltaLevel: 
            0, propList: NIL];
            Match: PROC [rope: ROPE] RETURNS [BOOL] ~ {
                targetLen: INT ~ Rope.Size[rope];
                input: ROPE ~ TiogaAccess.PeekRope[reader];
                matchLen: INT ~ Rope.Run[s1: rope, s2: input, case: TRUE];
                IF matchLen=targetLen THEN {
                    FOR i: INT IN [0..targetLen) DO [] Ź TiogaAccess.Get[reader] ENDLOOP;
                    RETURN [TRUE];
                    };
                RETURN [FALSE];
                };
            level: INT Ź 0;
            MatchBreak: PROC RETURNS [BOOL] ~ {
                IF TiogaAccess.Peek[reader].endOfNode THEN {
                    break Ź TiogaAccess.Get[reader];
                    level Ź level + break.deltaLevel;
                    RETURN [TRUE];
                    };
                RETURN [FALSE];
                };
            MustNest: PROC ~ {Must[MatchBreak[] AND break.deltaLevel = 1]};
            GetOctal3: PROC RETURNS [[0..256)] ~ {
                v: CARDINAL Ź 0;
                FOR i: NAT IN [0..3) DO
                    t: TiogaAccess.TiogaChar Ź TiogaAccess.Get[reader];
                    Must[t.char IN ['0..'8) AND t.charSet = 0];
                    v Ź v*8 + (t.char-'0);
                    ENDLOOP;
                Must[v IN [0..256)];
                RETURN [v];
                };
            RopeToEnd: PROC RETURNS [ROPE] ~ {
                rope: ROPE Ź TiogaAccess.PeekRope[reader];
                FOR i: INT IN [0..Rope.Size[rope]) DO [] Ź TiogaAccess.Get[reader] ENDLOOP;
                RETURN [rope];
                };
            ParseProp: PROC RETURNS [Prop.Pair] ~ {
                keyText: REF TEXT ~ RefText.ObtainScratch[100];
                t: TiogaAccess.TiogaChar Ź TiogaAccess.Get[reader];
                key: ATOM Ź NIL;
                rope: ROPE Ź NIL;
                value: REF;
                WHILE t.charSet = 0 AND CharOps.AlphaNumeric[t.char] DO
                    Must[keyText.length < keyText.maxLength];
                    keyText[keyText.length] Ź t.char;
                    keyText.length Ź keyText.length + 1;
                    t Ź TiogaAccess.Get[reader];
                    ENDLOOP;
                Must[keyText.length > 0];
                Must[t.charSet = 0 AND t.char = ':];
                Must[Match[" "]];
                rope Ź RopeToEnd[];
                Must[MatchBreak[]];
                key Ź Atom.MakeAtomFromRefText[keyText];
                value Ź Prop.Get[break.propList, $OpaqueValue];
                IF value = NIL THEN value Ź TiogaAccess.GetInternalProp[key, rope];
                RefText.ReleaseScratch[keyText];
                RETURN [[key: key, val: value]];
                };
            first: BOOL Ź TRUE;
            IF doRoot THEN {
                node: TextNode.Ref ~ TiogaAccess.GetLocation[reader].node;
                parent: TextNode.Ref ~ TextNode.Parent[node];
                Must[TextNode.Parent[parent]=NIL AND TextNode.Next[node]=NIL]; -- no siblings allowed!
                };
            UNTIL TiogaAccess.EndOf[reader] DO
                IF (NOT doRoot AND Match["BEGIN NODE"]) OR (doRoot AND Match["BEGIN ROOT NODE"])
                    THEN {
                        node: TiogaAccess.TiogaChar Ź [charSet: 0, char: 15C, looks: ALL[FALSE], format: NIL, comment: FALSE, endOfNode: TRUE, deltaLevel: 
                        0, propList: NIL];
                        nodeTail: Prop.PropList Ź NIL;
                        level Ź 0;
                        MustNest[];
                        IF Match["CONTENTS"] THEN {
                            MustNest[];
                            WHILE level >= 2 DO
                                outc: TiogaAccess.TiogaChar Ź [charSet: 0, char: 0C, looks: ALL[FALSE], format: NIL, comment: FALSE, endOfNode: FALSE, deltaLevel: 
                                0, propList: NIL];
                                outcTail: Prop.PropList Ź NIL;
                                rope: ROPE Ź NIL;
                                Must[level = 2];
                                IF Match["Text: "]
                                    THEN rope Ź RopeToEnd[]
                                    ELSE {
                                        Must[Match["Char: ("]];
                                        outc.charSet Ź GetOctal3[];
                                        Must[Match["|"]];
                                        rope Ź Rope.FromChar[VAL[GetOctal3[]]];
                                        Must[Match[")"]];
                                        };
                                Must[MatchBreak[]];
                                WHILE level >= 3 DO
                                    Must[level = 3];
                                    IF Match["LOOKS("] THEN {
                                        t: TiogaAccess.TiogaChar Ź TiogaAccess.Peek[reader];
                                        WHILE t.charSet = 0 AND t.char IN Tioga.Look DO
                                            t Ź TiogaAccess.Get[reader];
                                            outc.looks[t.char] Ź TRUE;
                                            t Ź TiogaAccess.Peek[reader];
                                            ENDLOOP;
                                        Must[Match[")"]];
                                        Must[MatchBreak[]];
                                        }
                                    ELSE {
                                        pair: Prop.Pair ~ ParseProp[];
                                        last: Prop.PropList ~ LIST[pair];
                                        IF outcTail=NIL THEN outc.propList Ź last ELSE outcTail.rest Ź last;
                                        outcTail Ź last;
                                        };
                                    ENDLOOP;
                                IF rope # NIL THEN {
                                    action: Rope.ActionType = { outc.char Ź c; TiogaAccess.Put[writer, outc] };
                                    [] Ź Rope.Map[base: rope, action: action];
                                    };
                                ENDLOOP;
                            };
                        IF Match["PROPERTIES"] THEN {
                            MustNest[];
                            WHILE level >= 2 DO
                                pair: Prop.Pair;
                                Must[level = 2];
                                pair Ź ParseProp[];
                                SELECT pair.key FROM
                                    $Comment => node.comment Ź NodeProps.BoolFromValue[pair.val];
                                    $Format => node.format Ź NodeProps.AtomFromValue[pair.val];
                                    ENDCASE => {
                                        last: Prop.PropList ~ LIST[pair];
                                        IF nodeTail=NIL THEN node.propList Ź last ELSE nodeTail.rest Ź last;
                                        nodeTail Ź last;
                                        };
                                ENDLOOP;
                            };
                        Must[level = 1];
                        Must[Match["END NODE"]];
                        Must[MatchBreak[]];
                        node.deltaLevel Ź level;
                        TiogaAccess.Put[writer, node];
                        }
                    ELSE {
                        Must[NOT first];
                        Must[TiogaAccess.CopyNode[writer, reader].nodeEnd];
                        };
                first Ź FALSE;
                ENDLOOP;
            };

        MakeNodeSelection: PROC RETURNS [useRootViewer: Viewer Ź NIL] ~ {
            tSel: TEditDocument.Selection;
            IF TEditSelection.pSel=NIL OR TEditSelection.pSel.viewer=NIL THEN RETURN;
            tSel Ź TEditSelection.Alloc[];
            TEditSelection.Copy[source: TEditSelection.pSel, dest: tSel];
            IF tSel.start.pos.node = tSel.data.text.child AND tSel.start.pos.where = 0 AND tSel.insertion = before THEN {
                useRootViewer Ź tSel.viewer;
                TEditSelection.Free[tSel];
                RETURN;
                };
            SELECT tSel.granularity FROM
                point, char, word => {
                    tSel.start.pos.where Ź 0;
                    tSel.end.pos.where Ź TextNode.EndPos[tSel.end.pos.node];
                    tSel.granularity Ź node;
                    };
                ENDCASE => NULL;
            TEditSelection.MakeSelection[new: tSel];
            TEditSelection.Free[tSel]
            };

        OpenPropertiesOp: TEditInput.CommandProc ~ {
            OpenProperties: PROC [root: TiogaOps.Ref] ~ {
                reader: TiogaAccess.Reader Ź NIL;
                writer: TiogaAccess.Writer Ź NIL;
                useRootViewer: Viewer ~ MakeNodeSelection[];
                reader Ź IF useRootViewer#NIL THEN TiogaAccessViewers.FromViewer[useRootViewer] ELSE TiogaAccessViewers.FromSelection[];
                writer Ź TiogaAccess.Create[];
                TranslateToOpenProperties[reader, writer, useRootViewer#NIL];
                IF useRootViewer#NIL
                    THEN {
                        TiogaAccessViewers.WriteViewer[writer: writer, viewer: useRootViewer];
                        ViewerOps.SetNewVersion[viewer];
                        }
                    ELSE TiogaAccessViewers.WriteSelection[writer];
                };
            TiogaOps.CallWithLocks[OpenProperties];
            quit Ź TRUE;
            };

        SomethingBadHappenedProceedToDebug: SIGNAL ~ CODE;
        ClosePropertiesOp: TEditInput.CommandProc ~ {
            <<PROC [viewer: ViewerClasses.Viewer _ NIL] RETURNS [recordAtom: BOOL _ TRUE, quit: BOOL _ FALSE];>>
            errorPosition: INT Ź -1;
            CloseProperties: PROC [root: TiogaOps.Ref] ~ {
                reader: TiogaAccess.Reader Ź NIL;
                writer: TiogaAccess.Writer Ź NIL;
                useRootViewer: Viewer ~ MakeNodeSelection[];
                IF useRootViewer#NIL
                    THEN {
                        reader Ź TiogaAccessViewers.FromViewer[useRootViewer];
                        [] Ź TiogaAccess.Get[reader]; -- discard actual root
                        }
                    ELSE { reader Ź TiogaAccessViewers.FromSelection[] };
                writer Ź TiogaAccess.Create[];
                TranslateFromOpenProperties[reader, writer, useRootViewer#NIL !
                    Cant => {errorPosition Ź TiogaAccess.GetPosition[reader]}
                    ];
                IF useRootViewer#NIL
                    THEN {
                        TiogaAccessViewers.WriteViewer[writer: writer, viewer: useRootViewer];
                        ViewerOps.SetNewVersion[viewer];
                        }
                    ELSE TiogaAccessViewers.WriteSelection[writer];
                };
            error: {none, cant, uncaught} Ź none;
            TiogaOps.CallWithLocks[CloseProperties !
                Cant => {error Ź cant; CONTINUE};
                RuntimeError.UNCAUGHT => {error Ź uncaught; CONTINUE};
                ];
            SELECT error FROM
                none => IF errorPosition # -1 THEN ERROR;
                cant => {
                    TEditSelectionOps.ShowGivenPosition[viewer: viewer, pos: errorPosition, skipCommentNodes: TRUE];
                    ViewerOps.BlinkViewer[viewer, 200];
                    };
                uncaught => {
                    SIGNAL SomethingBadHappenedProceedToDebug;
                    CloseProperties[NIL]; -- do it again without lock for easy debug
                    };
                ENDCASE => ERROR;
            quit Ź TRUE;
            };

        TEditInput.Register[name: $OpenProperties, proc: OpenPropertiesOp, before: TRUE];
        TEditInput.Register[name: $CloseProperties, proc: ClosePropertiesOp, before: TRUE];

    END.