
<<-- TiogaInput2Impl.mesa; Edited by Paxton on June 14, 1983 9:18 am>>
<<Last Edited by: Maxwell, January 6, 1983 11:24 am>>
<<Last Edited by: Plass, April 15, 1983 2:08 pm>>
DIRECTORY

InputFocus USING [SetInputFocus],
MessageWindow USING [Append, Blink],
Process USING [Detach],
TiogaDisplay USING [EstablishLine],
TiogaDocument USING [maxClip, Selection, SpinAndLock, TiogaDocumentData, Unlock],
TiogaImpl USING [ReloadTipTable, ReloadReadonlyTipTable, ReloadTypeScriptTipTable],
TiogaInput,
TiogaInputOps, -- USING Lots
TiogaProfile USING [ReadProfile],
TiogaSelection USING [CancelPrimary, CancelSecondary, CaretAfterSelection, CaretBeforeSelection, GrowSelection, 
GrowSelectionToBlanks, LockSel, MakePointSelection, MakePrimary, MakeSecondary, pSel, PendingDeleteSelection, 
NotPendingDeleteSelection, SelectEverything, UnlockSel],
TiogaTouchup USING [LockAfterRefresh, UnlockAfterRefresh],
TiogaNode USING [Location, Ref, RefTextNode],
TiogaNodeOps USING [ForwardClipped, Level, Parent, Root],
TreeCheck USING [Verify],
UserProfile USING [CallWhenProfileChanges, ProfileChangedProc],
ViewerOps USING [PaintViewer],
ViewerClasses USING [Viewer, ViewerRec],
WindowManager USING [UnWaitCursor, WaitCursor];

TiogaInput2Impl: CEDAR PROGRAM

IMPORTS InputFocus, TiogaImpl, TiogaDisplay, MessageWindow, Process, TiogaDocument, TiogaInput, TiogaInputOps, TiogaProfile, 
TiogaSelection, TiogaTouchup, TiogaNodeOps, TreeCheck, UserProfile, ViewerOps, WindowManager
EXPORTS TiogaInput =

BEGIN OPEN TiogaInput, TiogaSelection;

Break: CommandProc = {
TiogaInputOps.Break[] };

Join: CommandProc = {
TiogaInputOps.Join[] };

Nest: CommandProc = {
TiogaInputOps.Nest[] };

Paste: CommandProc = {
TiogaInputOps.Paste[] };

SaveForPaste: CommandProc = {
TiogaInputOps.SaveForPaste[] };

SetFormat: CommandProc = {
TiogaInputOps.SetFormat[] };

GetFormat: CommandProc = {
TiogaInputOps.GetFormat[] };

UnNest: CommandProc = {
TiogaInputOps.UnNest[] };

AllCaps: CommandProc = {
TiogaInputOps.Capitalise[allCaps] };

AllLower: CommandProc = {
TiogaInputOps.Capitalise[allLower] };

FirstCap: CommandProc = {
TiogaInputOps.Capitalise[firstCap] };

InitialCaps: CommandProc = {
TiogaInputOps.Capitalise[initCaps] };

ForkPaint: PROC [viewer: ViewerClasses.Viewer] = TRUSTED {
Process.Detach[FORK ViewerOps.PaintViewer[viewer, client ! ABORTED => CONTINUE]] };

AllLevels: PUBLIC CommandProc = {
tdd: TiogaDocument.TiogaDocumentData _ NARROW[viewer.data];
IF tdd = NIL THEN RETURN;
tdd.clipLevel _ TiogaDocument.maxClip;
ForkPaint[viewer];
RETURN [FALSE] };

FirstLevelOnly: PUBLIC CommandProc = {
tdd: TiogaDocument.TiogaDocumentData _ NARROW[viewer.data];
IF tdd = NIL THEN RETURN;
tdd.clipLevel _ 1;
CheckFirstLevel[tdd];
ForkPaint[viewer];
RETURN [FALSE] };

CheckFirstLevel: PROC [tdd: TiogaDocument.TiogaDocumentData] = {
node: TiogaNode.Ref;
delta: INTEGER;
pos: TiogaNode.Location;
[] _ TiogaDocument.SpinAndLock[tdd, "CheckFirstLevel", TRUE]; -- ok to interrupt repaint
pos _ tdd.lineTable.lines[0].pos; -- the start of the first line
delta _ TiogaNodeOps.Level[pos.node]-tdd.clipLevel; -- how much too deep it is, if any
IF delta > 0 THEN {
FOR i:INTEGER IN [0..delta) DO -- only do this if pos is too deep
pos _ [TiogaNodeOps.Parent[pos.node],0];
ENDLOOP;
IF (node _ TiogaNodeOps.ForwardClipped[pos.node,].nx) # NIL THEN pos _ [node,0];
TiogaDisplay.EstablishLine[tdd, pos] };
TiogaDocument.Unlock[tdd] };

MaxLevelShown: PUBLIC PROC [tdd: TiogaDocument.TiogaDocumentData]
RETURNS [level: INTEGER] = {
node, n: TiogaNode.Ref;
max: INTEGER _ 0;
IF tdd = NIL THEN RETURN [0];
FOR l: INTEGER IN [0..tdd.lineTable.lastLine] DO
IF (n _ tdd.lineTable.lines[l].pos.node) # node THEN {
node _ n;
max _ MAX[TiogaNodeOps.Level[node],max] };
ENDLOOP;
level _ max };

MoreLevels: PUBLIC CommandProc = {
tdd: TiogaDocument.TiogaDocumentData _ NARROW[viewer.data];
IF tdd = NIL THEN RETURN;
[] _ TiogaDocument.SpinAndLock[tdd, "MoreLevels", TRUE]; -- ok to interrupt repaint
IF tdd.clipLevel < TiogaDocument.maxClip THEN tdd.clipLevel _ MaxLevelShown[tdd]+1;
ForkPaint[viewer];
TiogaDocument.Unlock[tdd];
RETURN [FALSE] };

FewerLevels: PUBLIC CommandProc = {
tdd: TiogaDocument.TiogaDocumentData _ NARROW[viewer.data];
level: INTEGER;
IF tdd = NIL THEN RETURN;
IF ~TiogaTouchup.LockAfterRefresh[tdd, "FewerLevels"] THEN RETURN [FALSE];
{ ENABLE UNWIND => TiogaTouchup.UnlockAfterRefresh[tdd];
level _ tdd.clipLevel;
IF level = TiogaDocument.maxClip THEN level _ MaxLevelShown[tdd];
IF level # 1 THEN {
tdd.clipLevel _ level-1;
CheckFirstLevel[tdd];
ForkPaint[viewer] };
TiogaTouchup.UnlockAfterRefresh[tdd];
RETURN [FALSE] }};

CaretAfter: CommandProc = {
CaretAfterSelection[] };

CaretBefore: CommandProc = {
CaretBeforeSelection[] };

Everything: CommandProc = {
SelectEverything[] };

GrowSel: CommandProc = {
GrowSelection[] };

GrowSelToBlanks: CommandProc = {
GrowSelectionToBlanks[] };

InsertLineBreak: CommandProc = {
TiogaInputOps.InsertLineBreak[] };

MakeNotPendingDelete: CommandProc = {
NotPendingDeleteSelection[] };

MakePendingDelete: CommandProc = {
PendingDeleteSelection[] };

MakePointSelection: PUBLIC CommandProc = {
TiogaSelection.LockSel[primary, "MakePointSelection"];
IF pSel.viewer#NIL THEN
TiogaSelection.MakePointSelection[pSel,
IF pSel.insertion=before THEN pSel.start.pos
ELSE [pSel.end.pos.node,pSel.end.pos.where+1]];
TiogaSelection.UnlockSel[primary] };

MakeControlCharacter: CommandProc = {
TiogaInputOps.MakeControlCharacter[] };

MakeOctalCharacter: CommandProc = {
TiogaInputOps.MakeOctalCharacter[] };

UnMakeControlCharacter: CommandProc = {
TiogaInputOps.UnMakeControlCharacter[] };

UnMakeOctalCharacter: CommandProc = {
TiogaInputOps.UnMakeOctalCharacter[] };

MakePrimaryOp: CommandProc = { MakePrimary[] };

MakeSecondaryOp: CommandProc = { MakeSecondary[] };

CancelPrimaryOp: CommandProc = { CancelPrimary[] };

CancelSecondaryOp: CommandProc = { CancelSecondary[] };

Paint: CommandProc = { ViewerOps.PaintViewer[viewer, client] };

PlaceholderBrackets: CommandProc = {
TiogaInputOps.InsertBrackets[1C,2C]  };

justRegistered: BOOL _ TRUE;

ProfileChanged: UserProfile.ProfileChangedProc = {
IF justRegistered THEN { justRegistered _ FALSE; RETURN };
TiogaProfile.ReadProfile[] };

ReadTip: CommandProc = { ReadTipTables[] };

ReadTipTables: PUBLIC PROC = {
WindowManager.WaitCursor[];
TiogaImpl.ReloadTipTable[];
TiogaImpl.ReloadReadonlyTipTable[];
TiogaImpl.ReloadTypeScriptTipTable[];
InputFocus.SetInputFocus[];    -- kill selection; force ChangeTIPContext
WindowManager.UnWaitCursor[] };

ReloadStyle: CommandProc = {
TiogaInputOps.ReloadStyle[] };

SelectMatchingPlaceholderBrackets: CommandProc = {
TiogaInputOps.SelectMatchingBrackets[1C,2C] };

SelectMatchingSingleQuotes: CommandProc = { -- look for 140C as left single quote
TiogaInputOps.SelectMatchingBrackets['\140,''] };

SelectMatchingDoubleQuotes: CommandProc = {
TiogaInputOps.SelectMatchingBrackets['",'"] };

SelectMatchingDashBrackets: CommandProc = {
TiogaInputOps.SelectMatchingBrackets['-,'-] };

PreviousPlaceholder: CommandProc = {
TiogaInputOps.FindPlaceholders[FALSE] };

PreviousViewer: CommandProc = {
TiogaInputOps.NextViewer[FALSE] };

NextPlaceholder: CommandProc = {
TiogaInputOps.FindPlaceholders[TRUE] };

NextViewer: CommandProc = {
TiogaInputOps.NextViewer[TRUE] };

ReadAbbreviations: CommandProc = {
TiogaInputOps.LoadAbbreviations["Default"] };

VerifyTree: CommandProc = {
IF pSel.viewer=NIL THEN RETURN;
TreeCheck.Verify[TiogaNodeOps.Root[pSel.start.pos.node]];
MessageWindow.Append["Verified", TRUE]; MessageWindow.Blink[] };

SelectMatchingParens: CommandProc = {
TiogaInputOps.SelectMatchingBrackets['(,')] };

SelectMatchingAngleBrackets: CommandProc = {
TiogaInputOps.SelectMatchingBrackets['<,'>] };

SelectMatchingCurlyBrackets: CommandProc = {
TiogaInputOps.SelectMatchingBrackets['{,'}] };

SelectMatchingSquareBrackets: CommandProc = {
TiogaInputOps.SelectMatchingBrackets['[,']] };

ParenBrackets: CommandProc = {
TiogaInputOps.InsertBrackets['(,')] };

DashBrackets: CommandProc = {
TiogaInputOps.InsertBrackets['-,'-] };

DoubleQuoteBrackets: CommandProc = {
TiogaInputOps.InsertBrackets['",'"] };

AngleBrackets: CommandProc = {
TiogaInputOps.InsertBrackets['<,'>] };

SingleQuoteBrackets: CommandProc = { -- use 140C for left single quote
TiogaInputOps.InsertBrackets['\140,''] };

CurlyBrackets: CommandProc = {
TiogaInputOps.InsertBrackets['{,'}] };

SquareBrackets: CommandProc = {
TiogaInputOps.InsertBrackets['[,']] };

ComArray: TYPE = ARRAY ComIndex OF LIST OF REF ANY;
coms: REF ComArray = NEW [ComArray];

SetCommand: PUBLIC PROC [num: ComIndex, params: LIST OF REF ANY] = {
coms[num] _ params };

GetCommand: PUBLIC PROC [num: ComIndex] RETURNS [params: LIST OF REF ANY] = {
RETURN [coms[num]] };

DoCommand: PROC [viewer: ViewerClasses.Viewer, num: ComIndex] = {
Interpret[viewer,coms[num]] };

Command0: CommandProc = {
DoCommand[viewer,0] };

Command1: CommandProc = {
DoCommand[viewer,1] };

Command2: CommandProc = {
DoCommand[viewer,2] };

Command3: CommandProc = {
DoCommand[viewer,3] };

Command4: CommandProc = {
DoCommand[viewer,4] };

Command5: CommandProc = {
DoCommand[viewer,5] };

Command6: CommandProc = {
DoCommand[viewer,6] };

Command7: CommandProc = {
DoCommand[viewer,7] };

Command8: CommandProc = {
DoCommand[viewer,8] };

Command9: CommandProc = {
DoCommand[viewer,9] };

SetComment: CommandProc = {
TiogaInputOps.SetCommentProp[TRUE] };

SetNotComment: CommandProc = {
TiogaInputOps.SetCommentProp[FALSE] };

RegisterCommandAtoms: PROC = {
Register[$Break, Break];
Register[$Join, Join];
Register[$Nest, Nest];
Register[$Paste, Paste];
Register[$SaveForPaste, SaveForPaste];
Register[$SetFormat, SetFormat];
Register[$SetType, SetFormat]; -- get rid of this someday when change Tioga.tip
Register[$GetFormat, GetFormat];
Register[$GetType, GetFormat]; -- get rid of this someday when change Tioga.tip
Register[$UnNest, UnNest];
Register[$AllCaps, AllCaps];
Register[$AllLower, AllLower];
Register[$FirstCap, FirstCap];
Register[$InitialCaps, InitialCaps];
Register[$AllLevels, AllLevels];
Register[$FewerLevels, FewerLevels];
Register[$MoreLevels, MoreLevels];
Register[$FirstLevelOnly, FirstLevelOnly];
Register[$CaretAfter, CaretAfter];
Register[$CaretBefore, CaretBefore];
Register[$Everything, Everything];
Register[$GrowSelection, GrowSel];
Register[$GrowSelectionToBlanks, GrowSelToBlanks];
Register[$InsertLineBreak, InsertLineBreak];
Register[$MakeNotPendingDelete, MakeNotPendingDelete];
Register[$MakePendingDelete, MakePendingDelete];
Register[$MakePointSelection, MakePointSelection];
Register[$MakeControlCharacter, MakeControlCharacter];
Register[$MakeOctalCharacter, MakeOctalCharacter];
Register[$UnMakeControlCharacter, UnMakeControlCharacter];
Register[$UnMakeOctalCharacter, UnMakeOctalCharacter];
Register[$MakePrimary, MakePrimaryOp];
Register[$MakeSecondary, MakeSecondaryOp];
Register[$CancelPrimary, CancelPrimaryOp];
Register[$CancelSecondary, CancelSecondaryOp];
Register[$Paint, Paint];
Register[$PlaceholderBrackets, PlaceholderBrackets];
Register[$PreviousPlaceholder, PreviousPlaceholder];
Register[$PreviousViewer, PreviousViewer];
Register[$ReadProfile, ReadTip];
Register[$ReloadStyle, ReloadStyle];
Register[$SelectMatchingPlaceholderBrackets, SelectMatchingPlaceholderBrackets];
Register[$NextPlaceholder, NextPlaceholder];
Register[$NextViewer, NextViewer];
Register[$ReadAbbreviations, ReadAbbreviations];
Register[$VerifyTree, VerifyTree];
Register[$SelectMatchingParens, SelectMatchingParens];
Register[$SelectMatchingAngleBrackets, SelectMatchingAngleBrackets];
Register[$SelectMatchingCurlyBrackets, SelectMatchingCurlyBrackets];
Register[$SelectMatchingSquareBrackets, SelectMatchingSquareBrackets];
Register[$SelectMatchingSingleQuotes, SelectMatchingSingleQuotes];
Register[$SelectMatchingDoubleQuotes, SelectMatchingDoubleQuotes];
Register[$SelectMatchingDashBrackets, SelectMatchingDashBrackets];
Register[$ParenBrackets, ParenBrackets];
Register[$DashBrackets, DashBrackets];
Register[$AngleBrackets, AngleBrackets];
Register[$DoubleQuoteBrackets, DoubleQuoteBrackets];
Register[$SingleQuoteBrackets, SingleQuoteBrackets];
Register[$CurlyBrackets, CurlyBrackets];
Register[$SquareBrackets, SquareBrackets];
Register[$Command0, Command0];
Register[$Command1, Command1];
Register[$Command2, Command2];
Register[$Command3, Command3];
Register[$Command4, Command4];
Register[$Command5, Command5];
Register[$Command6, Command6];
Register[$Command7, Command7];
Register[$Command8, Command8];
Register[$Command9, Command9];
Register[$SetComment, SetComment];
Register[$SetNotComment, SetNotComment];
};

RegisterCommandAtoms;

UserProfile.CallWhenProfileChanges[ProfileChanged];

END.