
<<TiogaExtraOpsImpl.Mesa>>
<<written by Bill Paxton. June 1982>>
<<last written by Paxton. December 30, 1982 11:19 am>>
<<Last Edited by: Paxton, January 10, 1983 4:23 pm>>
<<Last Edited by: Plass, April 15, 1983 2:04 pm>>
DIRECTORY
TiogaOpsDefs,
TiogaExtraOps,
TextNode,
NodeProps,
EditSpan,
PutGet,
Rope,
TEditDocument,
TEditInput,
TiogaOps;

TiogaExtraOpsImpl: CEDAR PROGRAM
IMPORTS
NodeProps,
EditSpan,
PutGet,
TEditInput,
TEditDocument,
TextNode,
TiogaOps
EXPORTS TiogaOps, TiogaOpsDefs, TiogaExtraOps =
BEGIN OPEN TiogaOps, TiogaExtraOps, TiogaOpsDefs;

Ref: TYPE = REF NodeBody; -- points to a Tioga node
NodeBody: PUBLIC TYPE = TextNode.Body;

<<Miscellaneous operations on nodes>>

GetRope: PUBLIC PROC [node: Ref] RETURNS [ROPE]  = {
txt: TextNode.RefTextNode = TextNode.NarrowToTextNode[node];
RETURN [IF txt=NIL THEN NIL ELSE txt.rope] };

Parent: PUBLIC PROC [node: Ref] RETURNS [Ref] = { RETURN [TextNode.Parent[node]] };

Root: PUBLIC PROC [node: Ref] RETURNS [Ref] = { RETURN [TextNode.Root[node]] };

Next: PUBLIC PROC [node: Ref] RETURNS [Ref] = { RETURN [TextNode.Next[node]] };

Previous: PUBLIC PROC [node: Ref, parent: Ref _ NIL] RETURNS [nx: Ref] = {
RETURN [TextNode.Previous[node]] };

StepForward: PUBLIC PROC [node: Ref] RETURNS [nx: Ref] = {
RETURN [TextNode.StepForward[node]] };

StepBackward: PUBLIC PROC [node: Ref, parent: Ref _ NIL] RETURNS [back: Ref] = {
RETURN [TextNode.StepBackward[node, parent]] };

FirstSibling: PUBLIC PROC [node: Ref] RETURNS [Ref] = {
RETURN [TextNode.FirstSibling[node]] };

LastSibling: PUBLIC PROC [node: Ref] RETURNS [Ref] = {
RETURN [TextNode.LastSibling[node]] };

LastWithin: PUBLIC PROC [node: Ref] RETURNS [Ref] = { RETURN [TextNode.LastWithin[node]] };

DocLoc: PROC [loc: Location] RETURNS [TextNode.Location] = INLINE {
RETURN [[loc.node, loc.where]] };

MyLoc: PROC [loc: TextNode.Location] RETURNS [Location] = INLINE {
RETURN [[loc.node, loc.where]] };

LastLocWithin: PUBLIC PROC [node: Ref] RETURNS [Location] = {
RETURN [MyLoc[TextNode.LastLocWithin[node]]] }; 

FirstChild: PUBLIC PROC [node: Ref] RETURNS [Ref] = { RETURN [TextNode.FirstChild[node]] };

LastChild: PUBLIC PROC [node: Ref] RETURNS [Ref] = { RETURN [TextNode.LastChild[node]] };

IsDirty: PUBLIC PROC [node: Ref] RETURNS [BOOL] = { RETURN [node.dirty] };

IsNew: PUBLIC PROC [node: Ref] RETURNS [BOOL] = { RETURN [node.new] };

ClearDirty: PUBLIC PROC [node: Ref] = { node.dirty _ FALSE };

ClearNew: PUBLIC PROC [node: Ref] = { node.new _ FALSE };

ViewerDoc: PUBLIC PROC [viewer: Viewer] RETURNS [root: Ref] = {
tdd: TEditDocument.TEditDocumentData = NARROW[viewer.data];
IF tdd = NIL THEN RETURN [NIL];
[] _ TEditDocument.SpinAndLock[tdd, "ViewerDoc"]; -- make sure nothing else going on
root _ tdd.text;
TEditDocument.Unlock[tdd] };

<<Node Property Lists>>
<<>>
PutProp: PUBLIC PROCEDURE [n: Ref, name: ATOM, value: REF] = {
NodeProps.PutProp[n, name, value] };
<<>>
GetProp: PUBLIC PROCEDURE [n: Ref, name: ATOM] RETURNS [REF] = {
RETURN [NodeProps.GetProp[n, name]] };

RemProp: PUBLIC PROCEDURE [n: Ref, name: ATOM] = {
NodeProps.RemProp[n, name] };

MapProps: PUBLIC PROC [
n: Ref, action: MapPropsAction, typeFlag, commentFlag: BOOLEAN _ TRUE]
RETURNS [BOOLEAN] = {
RETURN [NodeProps.MapProps[n, action, typeFlag, commentFlag]] };

<<read, write, copy props>>

Register: PUBLIC PROC [name: ATOM,
reader: ReadSpecsProc,
writer: WriteSpecsProc,
copier: CopyInfoProc] = { NodeProps.Register[name, reader, writer, copier] };

NullRead: PUBLIC ReadSpecsProc = { [] _ NodeProps.NullRead[name, specs] };
NullWrite: PUBLIC WriteSpecsProc = { [] _ NodeProps.NullWrite[name, value] };
NullCopy: PUBLIC CopyInfoProc = { [] _ NodeProps.NullCopy[name, value] };

<<Comparing order of nodes or locations in document>>
<<>>
NodeOrder: PROC [order: EditSpan.NodeOrder] RETURNS [Order] = {
RETURN [SELECT order FROM before => before, same => same, after => after, disjoint => disjoint, ENDCASE => ERROR] };

CompareLocOrder: PUBLIC PROCEDURE [loc1, loc2: Location] RETURNS [order: Order] = TRUSTED {
order _ NodeOrder[EditSpan.CompareNodeOrder[LOOPHOLE[loc1.node], LOOPHOLE[loc2.node]]];
IF order=same THEN order _ SELECT loc1.where FROM
< loc2.where => before,
= loc2.where => same,
ENDCASE => after };

CompareNodeOrder: PUBLIC PROCEDURE [node1, node2: Ref] RETURNS [order: Order] = {
RETURN [NodeOrder[EditSpan.CompareNodeOrder[node1, node2]]] };

<<File I/O>>
<<>>
GetFile: PUBLIC PROCEDURE [name: ROPE] RETURNS [root: Ref] = {
RETURN [PutGet.FromFile[name]] };

PutFile: PUBLIC PROCEDURE [name: ROPE, root: Ref] = { [] _ PutGet.ToFile[name, root] };

FreeTree: PUBLIC PROCEDURE [root: Ref] = { TEditInput.FreeTree[root] };


<<Make point selection>>
<<>>
SelectPoint: PUBLIC PROC [
viewer: Viewer, caret: Location, which: WhichSelection _ primary] = TRUSTED {
TiogaOps.SetSelection[viewer: viewer, start: LOOPHOLE[caret], end: LOOPHOLE[caret], level: point, which: which] };

<<Command registration>>
<<>>
RegisterCommand: PUBLIC PROC [name: ATOM, proc: CommandProc, before: BOOL _ TRUE] = {
TEditInput.Register[name, proc, before] };

UnRegisterCommand: PUBLIC PROC [name: ATOM, proc: CommandProc] = {
TEditInput.UnRegister[name, proc] };

END.