DIRECTORY

Atom USING [GetPName],
NodeAddrs USING [AddNotifyProc],
EditSpan USING [CompareNodeOrder],
MessageWindow USING [Append, Blink, Clear],
RefTab USING [Create, Fetch, Ref, Store, Delete],
Rope USING [Concat, FromRefText, ROPE],
SafeStorage USING [NewZone],
TEditDocument USING [TEditDocumentData, Selection, SelectionId, SelectionRec],
TEditHistory,
TEditImpl,
TEditInput,
TEditInputOps, -- USING Lots
TEditOps USING [RememberCurrentPosition],
TEditProfile USING [CategoryOfUser, userCategory],
TEditScrolling USING [ScrollToPosition],
TEditSelection USING [CallWithSelAndDocAndTddLocks, Copy, Create, Extend, FakeSecondary, Find, InsertionPoint, LevelChange, LockSel, MakePointSelection, MakeSelection, oldSel, Position, fSel, pSel, SelectBranch, SelectChar, SelectNode, SelectWord, sSel, UnlockSel, Update],
TEditSplit USING [Split],
TextEdit USING [Size],
TextLooks USING [Look, allLooks, noLooks],
TextNode USING [FirstChild, Location, NarrowToTextNode, NodeItself, Offset, pZone, Ref,
RefTextNode, Root],
TiogaOps,
TIPUser USING [TIPScreenCoords],
ViewerClasses USING [NotifyProc, Viewer, ViewerRec],
ViewerOps USING [AddProp];

TEditInputImpl: CEDAR MONITOR

IMPORTS Atom, NodeAddrs, RefTab, EditSpan, MessageWindow, Rope, SafeStorage, TEditInput, TEditInputOps, TEditOps, TEditProfile, TEditScrolling, TEditSelection, TEditSplit, TextEdit, TextNode, ViewerOps

EXPORTS TEditInput, TEditImpl, TiogaOps =

BEGIN OPEN TEditInput, TEditSelection;

mx, my: INTEGER;	-- global Coord param for ops below
n: LONG INTEGER;	-- global Numeric param for ops below

sel: TEditDocument.SelectionId _ primary;		-- global sel ID; can be set to "secondary" by $SelSecondary
changeLevel: TEditSelection.LevelChange;	-- change granularity when extend
pDel: BOOL _ FALSE;

EditObject: TYPE = {
text, -- operate on the text of the selection
looks, -- operate on the looks only
type -- operate on the type only
};

editState: PUBLIC EditState _ reset;
editObject: EditObject _ text;

SelState: TYPE = {
reset, 	-- not specified yet
primary, 	-- making a primary selection
secondary };

selState: SelState _ reset;

PDelState: TYPE = {
reset, 	-- not specified yet
pending,	-- making a pending delete selection
not };

pdelState: PDelState _ reset;

commandTable: RefTab.Ref _ RefTab.Create[mod: 100, zone: TextNode.pZone];

editMessage: Rope.ROPE _ NIL;
MessageArray: TYPE = ARRAY BOOLEAN OF ARRAY BOOLEAN OF Rope.ROPE;
toPrimaryMessages: REF MessageArray _ NEW [MessageArray];
toSecondaryMessages: REF MessageArray _ NEW [MessageArray];

EditMessage: PROC = {
msg: Rope.ROPE _ SELECT editState FROM
tolimbo => "Select for delete",
toprimary => SELECT editObject FROM
text => toPrimaryMessages[pSel.pendingDelete][sSel.pendingDelete],
looks => "Select looks to copy",
type => "Select format to copy",
ENDCASE => NIL,
tosecondary => SELECT editObject FROM
text => toSecondaryMessages[pSel.pendingDelete][sSel.pendingDelete],
looks => "Select destination for copy looks",
type => "Select destination for copy format",
ENDCASE => NIL,
toboth => SELECT editObject FROM
text => "Select for transpose",
looks => "Select for transpose looks",
type => "Select for transpose format",
ENDCASE => NIL,
ENDCASE => NIL;
IF msg = NIL OR msg = editMessage THEN RETURN;
MessageWindow.Append[msg,TRUE];
editMessage _ msg };

prevPSel: TEditDocument.Selection _ TextNode.pZone.NEW[TEditDocument.SelectionRec];

qZone: ZONE _ SafeStorage.NewZone[quantized];

Interpret: PUBLIC PROC [viewer: ViewerClasses.Viewer, params: LIST OF REF ANY] = {
InterpInput[viewer,params] };

InterpretAtom: PUBLIC PROC [viewer: ViewerClasses.Viewer, atom: ATOM] = {
InterpAtom[viewer,atom] };

TEditNotifyProc: PUBLIC ViewerClasses.NotifyProc = BEGIN
InterpInput[self,input];
END;

InterpAtom: PROCEDURE [viewer: ViewerClasses.Viewer, atom: ATOM] = {
p: REF ANY = RefTab.Fetch[commandTable,atom].val;
IF p=NIL THEN MessageWindow.Append[
Rope.Concat["Unknown atom given to Tioga: ", Atom.GetPName[atom]], TRUE]
ELSE {
procList: LIST OF CommandProc = NARROW[p];
recordAtom: BOOL _ FALSE;
TEditInputOps.WaitForInsertToFinish[]; -- make sure previous characters have gone in
FOR list: LIST OF CommandProc _ procList, list.rest UNTIL list=NIL DO
record, quit: BOOL;
[record, quit] _ list.first[viewer];
IF record THEN recordAtom _ TRUE;
IF quit THEN EXIT;
ENDLOOP;
IF recordAtom THEN RecordRef[atom] }};

ResetInputStuff: PUBLIC PROC = { changeLevel _ same };

SaveCoords: PUBLIC PROC [x,y: INTEGER] = { mx _ x; my _ y };

InterpInput: PUBLIC PROCEDURE [viewer: ViewerClasses.Viewer, params: LIST OF REF ANY,
increaseNestingCount: BOOL _ TRUE] =
BEGIN OPEN TEditInputOps;

NormaliseSelection: PROC = BEGIN
IF ~pSel.pendingDelete THEN RETURN;
LockSel[primary, "InterpInput"];
{ ENABLE UNWIND => UnlockSel[primary];
IF pSel.pendingDelete THEN DoPendingDelete[];
IF ~InsSel[] THEN MakePointSelection[pSel, InsertionPoint[]];
}; UnlockSel[primary];
END;

InsSel: PROC RETURNS [BOOLEAN] =
INLINE {RETURN[pSel.granularity=point AND pSel.insertion=before
AND sSel.viewer=NIL]};

BumpNesting: ENTRY PROC = INLINE {
IF (interpreterNesting _ interpreterNesting+1) <= 1 THEN {
interpreterNesting _ 1;
closeEvent _ FALSE }};

DecrementNesting: ENTRY PROC RETURNS [BOOL] = INLINE {
RETURN [(interpreterNesting _ interpreterNesting-1) <= 0] };

AllText: PROC [LIST OF REF ANY] RETURNS [BOOLEAN] = INLINE {
FOR input: LIST OF REF ANY _ params, input.rest UNTIL input=NIL DO
WITH input.first SELECT FROM
z: REF CHARACTER => NULL;
z: Rope.ROPE => NULL;
z: REF TEXT => NULL;
ENDCASE => RETURN [FALSE];
ENDLOOP;
RETURN [TRUE] };

ResetInputStuff;

IF interpreterNesting=0 AND ~pSel.pendingDelete AND AllText[params] THEN { 
FOR input: LIST OF REF ANY _ params, input.rest UNTIL input=NIL DO
WITH input.first SELECT FROM
z: REF CHARACTER => {
NormaliseSelection[]; BufferedInsertChar[z^]; RecordChar[z^]};
z: Rope.ROPE => {
NormaliseSelection[]; BufferedInsertText[z]; RecordRef[z]};
z: REF TEXT => {
NormaliseSelection[]; BufferedInsertText[Rope.FromRefText[z]]; RecordRef[z]};
ENDCASE => ERROR;
ENDLOOP }
ELSE {
IF increaseNestingCount THEN BumpNesting[];
FOR input: LIST OF REF ANY _ params, input.rest UNTIL input=NIL DO
WITH input.first SELECT FROM
z: ATOM => InterpAtom[viewer,z ! BadMouse, DontDoIt => EXIT];
z: TIPUser.TIPScreenCoords => SaveCoords[z.mouseX, viewer.ch-z.mouseY];
z: REF CHARACTER => { InsertChar[z^]; RecordChar[z^] };
z: REF LONG INTEGER => { n _ z^; RecordInt[n] };
z: Rope.ROPE => { InsertRope[z]; RecordRef[z] };
z: REF TEXT => { InsertRope[Rope.FromRefText[z]]; RecordRef[z] };
ENDCASE => MessageWindow.Append["Unknown input given to Tioga.", TRUE];
ENDLOOP;
IF increaseNestingCount AND DecrementNesting[] AND closeEvent THEN CloseEventNow[];
};
END;

interpreterNesting: PUBLIC INTEGER _ 0;

NumberToLook: PROC RETURNS [l: CHARACTER] = INLINE BEGIN
RETURN['a+n];
END;


ApplyCaretLook: CommandProc = {
TEditInputOps.ModifyCaretLook[NumberToLook[], add] };

ApplyLook: CommandProc = {
TEditInputOps.ModifyLook[NumberToLook[], add] };

ClearCaretLooks: CommandProc = {
TEditInputOps.ChangeCaretLooks[add: TextLooks.noLooks, remove: TextLooks.allLooks] };

ClearLooks: CommandProc = {
TEditInputOps.ChangeLooks[add: TextLooks.noLooks, remove: TextLooks.allLooks] };

BackSpace: CommandProc = {
TEditInputOps.BackSpace[n] };

BackWord: CommandProc = {
TEditInputOps.BackWord[n] };

DeleteNextChar: CommandProc = {
TEditInputOps.DeleteNextChar[n] };

DeleteNextWord: CommandProc = {
TEditInputOps.DeleteNextWord[n] };

GoToPreviousWord: CommandProc = {
TEditInputOps.GoToPreviousWord[n] };

GoToNextWord: CommandProc = {
TEditInputOps.GoToNextWord[n] };

GoToPreviousChar: CommandProc = {
TEditInputOps.GoToPreviousChar[n] };

GoToNextChar: CommandProc = {
TEditInputOps.GoToNextChar[n] };

GoToPreviousNode: CommandProc = {
TEditInputOps.GoToPreviousNode[n] };

GoToNextNode: CommandProc = {
TEditInputOps.GoToNextNode[n] };

Copy: CommandProc = { IF sSel.viewer#NIL THEN {
TEditInputOps.Copy[sel];
RecordRef[$GetSecondary] }};

Delete: CommandProc = {
TEditInputOps.Delete[TRUE] };

ExpandAbbrev: CommandProc = {
TEditInputOps.ExpandAbbreviation[] };

Move: CommandProc = { IF sSel.viewer#NIL THEN {
TEditInputOps.Move[sel];
RecordRef[$GetSecondary] }};

RemoveCaretLook: CommandProc = {
TEditInputOps.ModifyCaretLook[NumberToLook[], remove] };

RemoveLook: CommandProc = {
TEditInputOps.ModifyLook[NumberToLook[], remove] };

SetStyle: CommandProc = {
TEditInputOps.SetStyle[] };

Time: CommandProc = { TEditInputOps.InsertTime[] };

Split: CommandProc = { TEditSplit.Split[viewer]; RETURN[FALSE] };

Transpose: CommandProc = { IF sSel.viewer#NIL THEN {
TEditInputOps.Transpose[sel];
RecordRef[$GetSecondary] }};

ToBoth: CommandProc = {
IF editState=reset OR editState=tolimbo THEN { editState _ toboth; EditMessage[] };
RETURN [FALSE] };

ToLimbo: CommandProc = { IF editState=reset THEN editState _ tolimbo; RETURN [FALSE] };

ToPrimary: CommandProc = {
IF editState=reset OR editState=tolimbo THEN editState _ toprimary;
RETURN [FALSE] };

ToSecondary: CommandProc = {
IF editState=reset OR editState=tolimbo THEN { editState _ tosecondary; EditMessage[] };
RETURN [FALSE] };

EditText: CommandProc = {
editObject _ text; RETURN [FALSE] };

EditLooks: CommandProc = {
editObject _ looks; EditMessage[]; RETURN [FALSE] };

EditType: CommandProc = {
editObject _ type; EditMessage[]; RETURN [FALSE] };

EditReset: CommandProc = {
editState _ reset; editObject  _ text; selState _ reset; pdelState _ reset; RETURN [FALSE] };

EditAbort: CommandProc = {
IF viewer#NIL AND pSel.viewer=viewer AND pSel.granularity=point
AND sSel.viewer=NIL THEN
ViewerOps.AddProp[viewer, $Abort, TextNode.pZone.NEW[BOOL _ FALSE]];
MessageWindow.Append["Cancelled",TRUE];
MakeSelection[NIL,secondary];
MakeSelection[IF CheckSelection[prevPSel] THEN prevPSel ELSE NIL, primary]; 
editState _ abort; editObject _ text;
mouseColor _ dead; -- stop tracking the mouse
RETURN [FALSE] };

GetSecondary: CommandProc = {
IF sSel.viewer=NIL AND CheckSelection[oldSel] THEN FakeSecondary[oldSel];
RETURN [FALSE] };

UpdateSavedSelections: PROC [
node: TextNode.RefTextNode,
new: PROC [old: TextNode.Offset] RETURNS [TextNode.Offset]] = {
Check: PROC [loc: TextNode.Location] RETURNS [TextNode.Location] = {
IF loc.node # node THEN RETURN [loc];
RETURN [[loc.node, new[loc.where]]] };
oldSel.start.pos _ Check[oldSel.start.pos];
oldSel.end.pos _ Check[oldSel.end.pos];
savedSelA.start.pos _ Check[savedSelA.start.pos];
savedSelA.end.pos _ Check[savedSelA.end.pos];
savedSelB.start.pos _ Check[savedSelB.start.pos];
savedSelB.end.pos _ Check[savedSelB.end.pos];
fSel.start.pos _ Check[fSel.start.pos];
fSel.end.pos _ Check[fSel.end.pos];
};

CheckSelection: PUBLIC PROC [sel: TEditDocument.Selection] RETURNS [BOOLEAN] = {
root, first, last: TextNode.Ref;
t1, t2: TextNode.RefTextNode;
tdd: TEditDocument.TEditDocumentData;
IF sel=NIL THEN RETURN [FALSE];
IF sel.viewer=NIL OR sel.viewer.destroyed THEN GOTO Failed;
IF (first _ sel.start.pos.node)=NIL OR (last _ sel.end.pos.node)=NIL THEN GOTO Failed;
IF (tdd _ NARROW[sel.viewer.data])=NIL THEN GOTO Failed;
IF (root _ tdd.text)=NIL THEN GOTO Failed;
IF TextNode.Root[first] # root THEN GOTO Failed; -- make sure still in the tree
IF first # last THEN -- make sure nodes in same tree and right order
IF EditSpan.CompareNodeOrder[first,last] # before THEN GOTO Failed;
IF sel.start.pos.where # TextNode.NodeItself THEN -- make sure start index is ok
IF (t1 _ TextNode.NarrowToTextNode[first])=NIL OR
sel.start.pos.where NOT IN [0..TextEdit.Size[t1]] THEN GOTO Failed;
IF sel.end.pos.where # TextNode.NodeItself THEN -- make sure end index is ok
IF (t2 _ TextNode.NarrowToTextNode[last])=NIL OR
sel.end.pos.where NOT IN [0..TextEdit.Size[t2]] THEN GOTO Failed;
IF t1 # NIL AND t1 = t2 THEN -- make sure start is not after end
IF sel.start.pos.where > sel.end.pos.where THEN GOTO Failed;
RETURN [TRUE];
EXITS Failed => { sel.viewer _ NIL; RETURN [FALSE] };
};

MakePDel: CommandProc = {
pSel.pendingDelete _ TRUE; RETURN [FALSE] };

DoEdit: CommandProc = {
IF pSel.viewer = NIL THEN {
IF sSel.viewer # NIL THEN MakeSelection[NIL,secondary]; -- get rid of secondary
recordAtom _ FALSE }
ELSE IF editState = tolimbo THEN {
recordAtom _ FALSE; RecordRef[$Delete]; TEditInputOps.Delete[TRUE] }
ELSE IF sSel.viewer = NIL THEN recordAtom _ FALSE
ELSE {
RecordEditObject: PROC = {
RecordRef[SELECT editObject FROM
text => $EditText,
looks => $EditLooks,
type => $EditType,
ENDCASE => ERROR] };
recordAtom _ TRUE;
SELECT editState FROM
reset, abort => recordAtom _ FALSE;
toprimary => {
RecordRef[$GetSecondary];
RecordRef[$ToPrimary];
RecordEditObject[];
SELECT editObject FROM
text => {
IF pSel.pendingDelete THEN RecordRef[$MakePDel];
TEditInputOps.Copy[primary] };
looks => TEditInputOps.CopyLooks[primary];
type => TEditInputOps.CopyType[primary];
ENDCASE => ERROR };
tosecondary => {
RecordRef[$GetSecondary];
RecordRef[$ToSecondary];
RecordEditObject[];
SELECT editObject FROM
text => {
IF pSel.pendingDelete THEN RecordRef[$MakePDel];
TEditInputOps.Copy[secondary] };
looks => TEditInputOps.CopyLooks[secondary];
type => TEditInputOps.CopyType[secondary];
ENDCASE => ERROR };
toboth => {
RecordRef[$GetSecondary];
RecordRef[$ToBoth];
RecordEditObject[];
SELECT editObject FROM
text => TEditInputOps.Transpose[];
looks => TEditInputOps.TransposeLooks[];
type => TEditInputOps.TransposeType[];
ENDCASE => ERROR };
ENDCASE => ERROR };
editState _ reset; editObject _ text;
pdelState _ reset; pDel _ FALSE; selState _ reset; sel _ primary;
mouseColor _ red; -- put these back to normal
IF editMessage # NIL THEN MessageWindow.Clear[];
editMessage _ NIL };

NormalizeViewer: PROC [
viewer: ViewerClasses.Viewer, loc: TextNode.Location,
tdd: TEditDocument.TEditDocumentData, tSel: TEditDocument.Selection] = {
IF loc.node = NIL OR tdd.text # TextNode.Root[loc.node] THEN -- scroll to start of document
loc _ [TextNode.FirstChild[tdd.text],0];
TEditOps.RememberCurrentPosition[viewer];
TEditScrolling.ScrollToPosition[viewer, loc] };

NormalizeToStart: PUBLIC CommandProc = {
DoIt: PROC [tdd: TEditDocument.TEditDocumentData, tSel: TEditDocument.Selection] = {
NormalizeViewer[viewer, IF tSel.viewer=NIL THEN [NIL,0] ELSE tSel.start.pos, tdd, tSel] };
TEditSelection.CallWithSelAndDocAndTddLocks[viewer, primary, DoIt] };

NormalizeToCaret, Normalize: PUBLIC CommandProc = {
DoIt: PROC [tdd: TEditDocument.TEditDocumentData, tSel: TEditDocument.Selection] = {
NormalizeViewer[viewer,
IF tSel.viewer=NIL THEN [NIL,0] ELSE InsertionPoint[tSel], tdd, tSel] };
TEditSelection.CallWithSelAndDocAndTddLocks[viewer, primary, DoIt] };

NormalizeToEnd: PUBLIC CommandProc = {
DoIt: PROC [tdd: TEditDocument.TEditDocumentData, tSel: TEditDocument.Selection] = {
NormalizeViewer[viewer, IF tSel.viewer=NIL THEN [NIL,0] ELSE tSel.end.pos, tdd, tSel] };
TEditSelection.CallWithSelAndDocAndTddLocks[viewer, primary, DoIt] };

FindNext: CommandProc = {
Find[viewer,forwards]; CloseEvent[]; RETURN [FALSE] };

FindAny: CommandProc = {
Find[viewer,anywhere]; CloseEvent[]; RETURN [FALSE] };

FindPrev: CommandProc = {
Find[viewer,backwards]; CloseEvent[]; RETURN [FALSE] };

FindNextWord: CommandProc = {
Find[viewer,forwards,FALSE,TRUE]; CloseEvent[]; RETURN [FALSE] };

FindAnyWord: CommandProc = {
Find[viewer,anywhere,FALSE,TRUE]; CloseEvent[]; RETURN [FALSE] };

FindPrevWord: CommandProc = {
Find[viewer,backwards,FALSE,TRUE]; CloseEvent[]; RETURN [FALSE] };

FindNextDef: CommandProc = {
Find[viewer,forwards,TRUE,TRUE]; CloseEvent[]; RETURN [FALSE] };

FindAnyDef: CommandProc = {
Find[viewer,anywhere,TRUE,TRUE]; CloseEvent[]; RETURN [FALSE] };

FindPrevDef: CommandProc = {
Find[viewer,backwards,TRUE,TRUE]; CloseEvent[]; RETURN [FALSE] };

savedSelA: TEditDocument.Selection _ TEditSelection.Create[];
savedSelB: TEditDocument.Selection _ TEditSelection.Create[];

RestoreSelectionA: PUBLIC CommandProc = {
IF CheckSelection[savedSelA] THEN  MakeSelection[selection: primary, new: savedSelA] };

SaveSelectionA: PUBLIC CommandProc = {
IF pSel # NIL THEN TEditSelection.Copy[source: pSel, dest: savedSelA] };

RestoreSelectionB: PUBLIC CommandProc = {
IF CheckSelection[savedSelB] THEN  MakeSelection[selection: primary, new: savedSelB] };

SaveSelectionB: PUBLIC CommandProc = {
IF pSel # NIL THEN TEditSelection.Copy[source: pSel, dest: savedSelB] };

PositionCommand: CommandProc = { CloseEvent[]; Position[viewer]; RETURN [FALSE] };

MouseColor: TYPE = { red, yellow, blue, dead };
mouseColor: MouseColor _ red;
BadMouse: PUBLIC SIGNAL = CODE;

RedMouse: CommandProc = {
IF mouseColor = dead THEN SIGNAL BadMouse;
mouseColor _ red;
TEditSelection.Copy[source: pSel, dest: prevPSel];
RETURN [FALSE] };

YellowMouse: CommandProc = {
IF mouseColor = dead THEN SIGNAL BadMouse;
mouseColor _ yellow;
TEditSelection.Copy[source: pSel, dest: prevPSel];
RETURN [FALSE] };

BlueMouse: CommandProc = {
IF mouseColor = dead THEN SIGNAL BadMouse;
mouseColor _ blue;
TEditSelection.Copy[source: pSel, dest: prevPSel];
RETURN [FALSE] };

RedDown: CommandProc = {
IF mouseColor # red THEN SIGNAL BadMouse; RETURN [FALSE] };

YellowDown: CommandProc = {
IF mouseColor # yellow THEN SIGNAL BadMouse; RETURN [FALSE] };

BlueDown: CommandProc = {
IF mouseColor # blue THEN SIGNAL BadMouse; RETURN [FALSE] };

AbortSecondary: PROC = {
MessageWindow.Append["Make a primary selection first.",TRUE];
MessageWindow.Blink[];
editState _ abort; mouseColor _ dead };

SelBranch: CommandProc = {
tdd: TEditDocument.TEditDocumentData ~ NARROW[viewer.data];
IF tdd = NIL THEN RETURN;
interpreterNesting _ 0;
IF editState=abort THEN RETURN;
IF sel=secondary AND pSel.viewer = NIL THEN { AbortSecondary[]; RETURN };
TEditSelection.SelectBranch[viewer, tdd, mx, my, sel, pDel];
IF editState=tolimbo OR sel=secondary THEN EditMessage[];
IF sel=primary THEN CloseEvent[];
RETURN [FALSE] };

SelChar: CommandProc = {
tdd: TEditDocument.TEditDocumentData ~ NARROW[viewer.data];
IF tdd = NIL THEN RETURN;
interpreterNesting _ 0;
IF editState=abort THEN RETURN;
IF sel=secondary AND pSel.viewer = NIL THEN { AbortSecondary[]; RETURN };
TEditSelection.SelectChar[viewer, tdd, mx, my, sel, pDel];
IF editState=tolimbo OR sel=secondary THEN EditMessage[];
IF sel=primary THEN CloseEvent[];
RETURN [FALSE] };

SelExpand: CommandProc = {
changeLevel _ expand; IF sel=primary THEN CloseEvent[]; RETURN [FALSE] };

SelExtend: CommandProc = { Extend[viewer, FALSE]; RETURN [FALSE] };
SelStartExtend: CommandProc = { Extend[viewer, TRUE]; RETURN [FALSE] };

Extend: PROC [viewer: ViewerClasses.Viewer, saveEnds: BOOL] = {
tdd: TEditDocument.TEditDocumentData ~ NARROW[viewer.data];
IF tdd = NIL THEN RETURN;
interpreterNesting _ 0;
IF editState=abort THEN RETURN;
IF mouseColor # blue THEN { [] _ BlueMouse[]; saveEnds _ TRUE };
TEditSelection.Extend[viewer,tdd,mx,my,sel,pDel,changeLevel,saveEnds];
IF sel=secondary THEN EditMessage[]
ELSE IF sel=primary THEN CloseEvent[] };

SelNode: CommandProc = {
tdd: TEditDocument.TEditDocumentData ~ NARROW[viewer.data];
IF tdd = NIL THEN RETURN;
interpreterNesting _ 0;
IF editState=abort THEN RETURN;
IF sel=secondary AND pSel.viewer = NIL THEN { AbortSecondary[]; RETURN };
SelectNode[viewer, tdd, mx, my, sel, pDel];
IF editState=tolimbo OR sel=secondary THEN EditMessage[];
IF sel=primary THEN CloseEvent[];
RETURN [FALSE] };

SelNotPendDel: CommandProc = {
IF pdelState=reset THEN {
pdelState _ not; pDel _ FALSE;
IF sel=primary THEN CloseEvent[] };
RETURN [FALSE] };

SelPendDel: CommandProc = {
IF pdelState=reset THEN {
pdelState _ pending; pDel _ TRUE;
IF sel=primary THEN CloseEvent[] };
RETURN [FALSE] };

ForceSelPendDel: CommandProc = { -- force pending delete
pdelState _ reset; [] _ SelPendDel[]; RETURN [FALSE] };

ForceSelNotPendDel: CommandProc = { -- force not pending delete
pdelState _ reset; [] _ SelNotPendDel[]; RETURN [FALSE] };

SelSamePendDel: CommandProc = {
IF sel=primary THEN CloseEvent[]; RETURN [FALSE] };

SelPrimary: CommandProc = {
IF selState=reset THEN { selState _ primary; sel _ primary; CloseEvent[] };
RETURN [FALSE] };

SelReduce: CommandProc = {
changeLevel _ reduce; IF sel=primary THEN CloseEvent[]; RETURN [FALSE] };

SelSame: CommandProc = { -- this is no longer needed.  delete it after release new TIP tables
};

SelSameEnd: CommandProc = { -- get rid of this when change Tioga.Tip
RETURN [FALSE] };

SelSecondary: CommandProc = {
IF selState=reset THEN { selState _ secondary; sel _ secondary };
RETURN [FALSE] };

SelUpdate: CommandProc = {
tdd: TEditDocument.TEditDocumentData ~ NARROW[viewer.data];
IF tdd = NIL THEN RETURN;
IF editState=abort THEN RETURN;
IF sel=secondary AND pSel.viewer = NIL THEN { AbortSecondary[]; RETURN };
Update[viewer, tdd, mx, my, sel, pDel];
IF sel=secondary THEN EditMessage[];
IF sel=primary THEN CloseEvent[];
RETURN [FALSE] };

SelWord: CommandProc = {
tdd: TEditDocument.TEditDocumentData ~ NARROW[viewer.data];
IF tdd = NIL THEN RETURN;
interpreterNesting _ 0;
IF editState=abort THEN RETURN;
IF sel=secondary AND pSel.viewer = NIL THEN { AbortSecondary[]; RETURN };
SelectWord[viewer, tdd, mx, my, sel, pDel];
IF editState=tolimbo OR sel=secondary THEN EditMessage[];
IF sel=primary THEN CloseEvent[];
RETURN [FALSE] };

IntermediateUser: CommandProc = {
CheckUser[intermediate]; RETURN [FALSE] };

AdvancedUser: CommandProc = {
CheckUser[advanced]; RETURN [FALSE] };

ExpertUser: CommandProc = {
CheckUser[expert]; RETURN [FALSE] };

DontDoIt: PUBLIC SIGNAL = CODE; -- raised if user category is too low

CheckUser: PROC [category: TEditProfile.CategoryOfUser] = {
IF TEditProfile.userCategory < category THEN SIGNAL DontDoIt };

Register: PUBLIC ENTRY PROC [name: ATOM, proc: CommandProc, before: BOOL _ TRUE] = {
ENABLE UNWIND => NULL;
p: REF ANY = RefTab.Fetch[commandTable,name].val;
list: LIST OF CommandProc _ NARROW[p];
IF before OR list=NIL THEN list _ TextNode.pZone.CONS[proc,list]
ELSE FOR l: LIST OF CommandProc _ list, l.rest DO
IF l.rest=NIL THEN { l.rest _ TextNode.pZone.LIST[proc]; EXIT };
ENDLOOP;
[] _  RefTab.Store[commandTable,name,list] };

UnRegister: PUBLIC ENTRY PROC [name: ATOM, proc: CommandProc] = {
ENABLE UNWIND => NULL;
p: REF ANY = RefTab.Fetch[commandTable,name].val;
procList: LIST OF CommandProc _ NARROW[p];
IF procList=NIL THEN NULL
ELSE IF procList.first = proc THEN procList _ procList.rest
ELSE {
prev: LIST OF CommandProc _ procList;
FOR list: LIST OF CommandProc _ procList.rest, list.rest UNTIL list=NIL DO
IF list.first=proc THEN { prev.rest _ list.rest; RETURN };
prev _ list;
ENDLOOP };
IF procList=NIL THEN [] _ RefTab.Delete[commandTable,name]
ELSE IF procList # p THEN [] _  RefTab.Store[commandTable,name,procList] };

IsRegistered: PUBLIC ENTRY PROC [name: ATOM, proc: CommandProc] RETURNS [BOOLEAN] = {
ENABLE UNWIND => NULL;
p: REF ANY = RefTab.Fetch[commandTable,name].val;
procList: LIST OF CommandProc _ NARROW[p];
FOR l: LIST OF CommandProc _ procList, l.rest UNTIL l=NIL DO
IF l.first=proc THEN RETURN[TRUE]; ENDLOOP;
RETURN [FALSE] };

RegisterCommandAtoms: PROC = {
Register[$ApplyCaretLook, ApplyCaretLook];
Register[$ApplyLook, ApplyLook];
Register[$ClearCaretLooks, ClearCaretLooks];
Register[$ClearLooks, ClearLooks];
Register[$BackSpace, BackSpace];
Register[$BackWord, BackWord];
Register[$DeleteNextChar, DeleteNextChar];
Register[$DeleteNextWord, DeleteNextWord];
Register[$GoToPreviousWord, GoToPreviousWord];
Register[$GoToNextWord, GoToNextWord];
Register[$GoToPreviousChar, GoToPreviousChar];
Register[$GoToNextChar, GoToNextChar];
Register[$GoToPreviousNode, GoToPreviousNode];
Register[$GoToNextNode, GoToNextNode];
Register[$Copy, Copy];
Register[$Delete, Delete];
Register[$DoEdit, DoEdit];
Register[$ExpandAbbrev, ExpandAbbrev];
Register[$Move, Move];
Register[$NormalizeToStart, NormalizeToStart];
Register[$NormalizeToCaret, NormalizeToCaret];
Register[$NormalizeToEnd, NormalizeToEnd];
Register[$RemoveCaretLook, RemoveCaretLook];
Register[$RemoveLook, RemoveLook];
Register[$SetStyle, SetStyle];
Register[$Time, Time];
Register[$RedSplit, Split]; Register[$YellowSplit, Split]; Register[$BlueSplit, Split];
Register[$Transpose, Transpose];
Register[$ToBoth, ToBoth];
Register[$ToLimbo, ToLimbo];
Register[$ToPrimary, ToPrimary];
Register[$ToSecondary, ToSecondary];
Register[$EditReset, EditReset];
Register[$EditAbort, EditAbort];
Register[$EditText, EditText];
Register[$EditType, EditType];
Register[$EditLooks, EditLooks];
Register[$GetSecondary, GetSecondary];
Register[$MakePDel, MakePDel];
Register[$FindNext, FindNext];
Register[$FindAny, FindAny];
Register[$FindPrev, FindPrev];
Register[$FindNextDef, FindNextDef];
Register[$FindAnyDef, FindAnyDef];
Register[$FindPrevDef, FindPrevDef];
Register[$FindNextWord, FindNextWord];
Register[$FindAnyWord, FindAnyWord];
Register[$FindPrevWord, FindPrevWord];
Register[$PushSelection, SaveSelectionA];
Register[$PopSelection, RestoreSelectionA];
Register[$SaveSelection, SaveSelectionA];
Register[$RestoreSelection, RestoreSelectionA];
Register[$SaveSelectionA, SaveSelectionA];
Register[$RestoreSelectionA, RestoreSelectionA];
Register[$SaveSelectionB, SaveSelectionB];
Register[$RestoreSelectionB, RestoreSelectionB];
Register[$Position, PositionCommand];
Register[$RedMouse, RedMouse];
Register[$YellowMouse, YellowMouse];
Register[$BlueMouse, BlueMouse];
Register[$RedDown, RedDown];
Register[$YellowDown, YellowDown];
Register[$BlueDown, BlueDown];
Register[$SelBranch, SelBranch];
Register[$SelChar, SelChar];
Register[$SelExpand, SelExpand];
Register[$SelExtend, SelExtend];
Register[$SelStartExtend, SelStartExtend];
Register[$SelNode, SelNode];
Register[$SelNotPendDel, SelNotPendDel];
Register[$SelPendDel, SelPendDel];
Register[$ForceSelPendDel, ForceSelPendDel];
Register[$ForceSelNotPendDel, ForceSelNotPendDel];
Register[$SelSamePendDel, SelSamePendDel];
Register[$SelPrimary, SelPrimary];
Register[$SelReduce, SelReduce];
Register[$SelSame, SelSame];
Register[$SelSameEnd, SelSameEnd];
Register[$SelSecondary, SelSecondary];
Register[$SelUpdate, SelUpdate];
Register[$SelWord, SelWord];
Register[$IntermediateUser, IntermediateUser];
Register[$AdvancedUser, AdvancedUser];
Register[$ExpertUser, ExpertUser];
};

toPrimaryMessages[FALSE][FALSE] _ "Select for copy to caret";
toPrimaryMessages[FALSE][TRUE] _ "Select for move to caret";
toPrimaryMessages[TRUE][FALSE] _ "Select replacement";
toPrimaryMessages[TRUE][TRUE] _ "Select for move onto";

toSecondaryMessages[FALSE][FALSE] _ "Select destination for copy";
toSecondaryMessages[FALSE][TRUE] _ "Select for replacement";
toSecondaryMessages[TRUE][FALSE] _ "Select destination for move";
toSecondaryMessages[TRUE][TRUE] _ "Select destination for move onto";

RegisterCommandAtoms;
NodeAddrs.AddNotifyProc[UpdateSavedSelections];

END.


h-- TEditInputImpl.mesa; Edited by Paxton on December 28, 1982 2:21 pm
Last Edited by: Maxwell, January 4, 1983 3:53 pm
Last Edited by: Plass, April 15, 1983 2:03 pm
-- global sel ID; can be set to TRUE by $SelPendDel, FALSE by $SelNotPendDel
-- for EditAbort
-- hand it off to buffered input routines
-- maps global value in n to => ['a..'z];
-- ***** Command Procs *****
-- oldSel is saved version of sSel for use in Repeat
-- savedSelA is saved by SaveSelectionA and restored by RestoreSelectionA
-- savedSelB is saved by SaveSelectionB and restored by RestoreSelectionB
-- fSel is saved feedback selection
�Ê)˜JšÏc,œ™EJ™0J™-Jš
Ïk	˜	˜Jšœžœ˜Jšœ
žœ˜ Jšœ	žœ˜"Jšœžœ˜+Jšœžœ%˜1Jšœžœžœ˜'Jšœžœ˜Jšœžœ;˜NJ˜
J˜
J˜Jšœ�
˜Jšœ	žœ˜)Jšœ
žœ ˜2Jšœžœ˜(Jšœžœý
˜‘Jšœžœ	˜Jšœ	žœ˜Jšœ
žœ˜*šœ	žœI˜WJ˜—Jš
œ	˜	Jšœžœ˜ Jšœžœ!˜4Jšœ
žœ˜J˜—Jšœž
˜J˜JšžœÂ
˜É
J˜Jšžœ"˜)J˜Jšžœ
žœ˜&J˜Jšœžœ�#˜4Jšœžœ
žœ�%˜6J˜Jšœ+�<˜gJšœ)�!˜Jšœžœžœ
˜Jš
�L™LJ˜—šœžœ˜Jšœ�'˜-Jšœ�˜#Jšœ�˜ J˜J˜—Jšœžœ˜$J˜J˜šœ
žœ˜Jšœ�˜Jšœ
�˜'J˜J˜—J˜J˜šœžœ˜Jšœ�˜Jšœ	�$˜-J˜J˜—J˜J˜J˜IJ˜Jšœžœžœ
˜Jšœžœžœ
žœ
žœ
žœ
žœ
žœžœ
˜AJšœžœžœ˜9Jšœžœžœ˜;J˜šÏnœžœ˜šœ
žœžœž˜&J˜šœ
žœž˜#J˜BJ˜ J˜ Jšžœžœ
˜—šœžœž˜%J˜DJ˜-J˜-Jšžœžœ
˜—šœ
žœž˜ J˜J˜&J˜&Jšžœžœ
˜—Jšžœžœ
˜—Jš
žœžœ
žœžœ
žœ
˜.Jšœžœ˜J˜J˜—šœ3žœ˜SJš
�™J˜—Jšœžœ"˜-J˜šŸ	œžœ
žœ(žœ
žœ
žœ
žœ˜RJ˜J˜—šŸ
œžœ
žœ&žœ˜IJ˜J˜—šœžœž˜8J˜Jšžœ
˜J˜—šŸ
œž	œ&žœ˜DJšœžœ
žœ'˜1šžœžœ
žœ˜#JšœCžœ
˜H—šžœ˜Jšœ
žœ
žœžœ˜*Jšœžœžœ
˜Jšœ'�-˜Tšžœžœ
žœ#žœžœ
ž˜EJšœžœ
˜Jš
œ$˜$Jšžœžœžœ
˜!Jšžœžœ
žœ
˜Jšžœ
˜—Jšžœžœ˜&J˜——šŸœžœ
žœ˜6J˜—JšŸ
œžœ
žœžœ˜<J˜šŸœžœ
ž	œ(žœ
žœ
žœ
žœ
˜UJšœžœžœ˜$Jšžœ
žœ˜J˜šŸœžœž˜ Jšžœžœ
žœ
˜#Jš
œ ˜ Jšœžœ
žœ˜&Jšžœžœ˜-Jšžœžœ,˜=J˜Jšžœ
˜J˜—šŸœžœ
žœžœ˜ šžœžœžœ˜?Jšžœ
žœ˜J˜——šŸœžœ
žœžœ˜"šžœ2žœ˜:J˜Jšœ
žœ˜J˜——šŸœžœ
žœ
žœžœžœ˜6šžœ6˜<J˜——šŸœžœžœ
žœ
žœ
žœžœžœžœ˜<šžœžœ
žœ
žœ
žœžœžœ
ž˜Bšžœ
žœ
ž˜Jšœžœ
ž	œžœ
˜Jšœžœžœ
˜Jšœžœ
žœžœ
˜Jšžœžœžœ˜Jšžœ
˜——Jšžœžœ˜J˜—J˜J˜šžœžœžœžœ˜KJš
�)™)šžœžœ
žœ
žœ
žœžœžœ
ž˜Bšžœ
žœ
ž˜šœžœ
ž	œ˜J˜>—šœžœ˜J˜;—šœžœ
žœ˜J˜M—Jšžœžœ
˜Jšžœ˜	———šžœ˜Jšžœžœ˜+šžœžœ
žœ
žœ
žœžœžœ
ž˜Bšžœ
žœ
ž˜Jšœžœ0žœ˜=J˜GJšœžœ
ž	œ'˜7Jšœžœ
žœ
žœ˜0Jšœžœ$˜0Jšœžœ
žœ6˜AJšžœ:žœ˜GJšžœ
˜—Jšžœžœžœžœ˜SJ˜——Jšžœ
˜J˜—Jšœžœ˜'J˜šŸœžœ
žœž	œžœ
ž˜8Jš
�)™)Jšžœ˜
Jšžœ
˜J˜—Jš
�™J˜˜J˜5J˜—˜J˜0J˜—˜ J˜UJ˜—˜J˜PJ˜—˜J˜J˜—˜J˜J˜—˜J˜"J˜—˜J˜"J˜—˜!J˜$J˜—˜J˜ J˜—˜!J˜$J˜—˜J˜ J˜—˜!J˜$J˜—˜J˜ J˜—šœžœ
žœ
žœ˜/J˜J˜J˜—˜Jšœžœ˜J˜—˜J˜%J˜—šœžœ
žœ
žœ˜/J˜J˜J˜—˜ J˜8J˜—˜J˜3J˜—˜J˜J˜—˜3J˜—šœž
œžœ
žœ˜AJ˜—šœžœ
žœ
žœ˜4J˜J˜J˜—˜Jšžœžœžœ'˜SJšžœžœ˜J˜—Jš	œžœžœžœžœ˜WJ˜˜Jšžœžœžœ˜CJšžœžœ˜J˜—˜Jšžœžœžœ,˜XJšžœžœ˜J˜—˜Jšœžœžœ˜$J˜—˜Jšœ#žœžœ˜4J˜—˜Jšœ"žœžœ˜3J˜—˜JšœLžœžœ˜]J˜—˜šžœžœ
žœžœ˜?Jšžœ
žœ
ž˜Jšœ1žœ
žœžœ˜D—Jšœ!žœ˜'Jšœžœ˜Jš	œžœžœ
žœ
žœ˜LJ˜%Jšœ�˜-Jšžœžœ˜J˜—˜Jšžœ
žœ
žœžœ˜IJšžœžœ˜J˜—šŸœžœ˜J˜Jšœžœžœ˜?šŸœžœžœ˜DJšžœžœ
žœ˜%Jšžœ ˜&—Jš
�4™4J˜+J˜'Jš
�I™IJ˜1J˜-Jš
�I™IJ˜1J˜-Jš
�#™#Jš
œ'˜'Jš
œ#˜#J˜J˜—š
Ÿœžœ
žœ žœžœ˜PJ˜ J˜Jš
œ%˜%Jš
žœžœ
žœ
žœžœ˜Jš
žœžœ
žœžœ
žœ˜;Jšžœžœ
žœžœ
žœ
žœ˜VJš
žœžœžœ
žœ
žœ˜8Jšžœžœ
žœ
žœ˜*Jšžœžœ
žœ	�˜Ošžœžœ
�/˜DJšžœ0žœ
žœ˜C—šžœ+žœ
�˜Pšžœ)žœ
ž˜1Jš	œžœ
žœžœ
žœ˜C——šžœ)žœ
�˜Lšžœ(žœ
ž˜0Jš	œžœ
žœžœ
žœ˜A——š	žœžœ
žœ	žœ
�#˜@Jšžœ)žœ
žœ˜<—Jšžœžœ˜Jšžœžœžœžœ˜5J˜J˜—˜Jšœžœžœžœ˜,J˜—˜šžœžœ
žœ˜Jš	žœžœ
žœžœ
�˜OJšœ
žœ˜—šžœ
žœžœ˜"Jšœ
žœ+žœ˜D—Jš	žœ
žœžœ
žœž˜1šžœ˜šŸœžœ˜šœ
žœž˜ J˜J˜J˜Jšžœžœ˜——Jšœ
žœ
˜šžœž˜Jšœžœ
˜#˜J˜J˜J˜Jšžœž˜˜	Jšžœžœ˜0J˜—J˜*J˜(Jšžœžœ˜—˜J˜J˜J˜Jšžœž˜˜	Jšžœžœ˜0J˜ —J˜,J˜*Jšžœžœ˜—˜J˜J˜J˜Jšžœž˜J˜"J˜(J˜&Jšžœžœ˜—Jšžœžœ˜——J˜%Jšœžœ"˜AJšœ�˜-Jšžœžœ
žœ˜0Jšœžœ˜J˜—šŸœžœ˜Jš
œ5˜5Jš
œH˜Hš	žœžœ
žœ$žœ
�˜[J˜(—J˜)J˜/J˜—šœžœ˜(šŸœžœJ˜TJšœžœ
žœ
žœžœžœ˜Z—Jš
œE˜E—J˜šœžœ˜3šŸœžœJ˜Tš
œ˜Jš
žœ
žœ
žœžœžœ$˜H——Jš
œE˜E—J˜šœžœ˜&šŸœžœJ˜TJšœžœ
žœ
žœžœžœ˜X—Jš
œE˜EJ˜—˜Jšœ%žœžœ˜6J˜—˜Jšœ%žœžœ˜6J˜—˜Jšœ&žœžœ˜7J˜—˜Jš	œžœ
žœžœžœ˜AJ˜—˜Jš	œžœ
žœžœžœ˜AJ˜—˜Jš	œžœ
žœžœžœ˜BJ˜—˜Jš	œžœ
žœžœžœ˜@J˜—˜Jš	œžœ
žœžœžœ˜@J˜—˜Jš	œžœ
žœžœžœ˜AJ˜—Jš
œ=˜=Jš
œ=˜=J˜šœžœ˜)Jšžœžœ6˜WJ˜—šœžœ˜&Jšžœžœ
žœ6˜H—J˜šœžœ˜)Jšžœžœ6˜WJ˜—šœžœ˜&Jšžœžœ
žœ6˜H—J˜JšœAžœžœ˜RJ˜Jšœžœ˜/J˜Jšœ
žœ
žœžœ
˜J˜˜Jšžœžœ
žœ
˜*J˜J˜2Jšžœžœ˜J˜—˜Jšžœžœ
žœ
˜*J˜J˜2Jšžœžœ˜J˜—˜Jšžœžœ
žœ
˜*J˜J˜2Jšžœžœ˜J˜—˜Jš
žœžœ
žœžœžœ˜;J˜—˜Jš
žœžœ
žœžœžœ˜>J˜—˜Jš
žœžœ
žœžœžœ˜<J˜—šŸœžœ˜Jšœ7žœ˜=J˜J˜'J˜—˜Jšœ'žœ˜;Jšžœžœ
žœ
žœ
˜J˜Jšžœžœ
žœ
˜Jš
žœžœžœ
žœžœ˜IJš
œ<˜<Jšžœžœžœ˜9Jšžœ
žœ˜!Jšžœžœ˜J˜—˜Jšœ'žœ˜;Jšžœžœ
žœ
žœ
˜J˜Jšžœžœ
žœ
˜Jš
žœžœžœ
žœžœ˜IJš
œ:˜:Jšžœžœžœ˜9Jšžœ
žœ˜!Jšžœžœ˜J˜—˜Jš	œžœ
žœžœžœ˜IJ˜—Jšœ*žœžœžœ˜CJšœ/žœžœžœ˜GJ˜šŸœžœ*žœ˜?Jšœ'žœ˜;Jšžœžœ
žœ
žœ
˜J˜Jšžœžœ
žœ
˜Jšžœžœ žœ˜@Jš
œF˜FJšžœžœ˜#Jšžœ
žœ
žœ˜(J˜—˜Jšœ'žœ˜;Jšžœžœ
žœ
žœ
˜J˜Jšžœžœ
žœ
˜Jš
žœžœžœ
žœžœ˜IJš
œ+˜+Jšžœžœžœ˜9Jšžœ
žœ˜!Jšžœžœ˜J˜—˜šžœžœ˜Jšœžœ
˜Jšžœ
žœ˜#—Jšžœžœ˜J˜—˜šžœžœ˜Jšœžœ
˜!Jšžœ
žœ˜#—Jšžœžœ˜J˜—šœ!�˜8Jšœ$žœžœ˜7J˜—šœ$�˜?Jšœ'žœžœ˜:J˜—˜Jšžœ
žœžœžœ˜3J˜—˜Jšžœžœ5˜KJšžœžœ˜J˜—˜Jš	œžœ
žœžœžœ˜IJ˜—šœ�D˜]J˜J˜—šœ�(˜DJšžœžœ˜J˜—˜Jšžœžœ+˜AJšžœžœ˜J˜—˜Jšœ'žœ˜;Jšžœžœ
žœ
žœ
˜Jšžœžœ
žœ
˜Jš
žœžœžœ
žœžœ˜IJš
œ'˜'Jšžœžœ˜$Jšžœ
žœ˜!Jšžœžœ˜J˜—˜Jšœ'žœ˜;Jšžœžœ
žœ
žœ
˜J˜Jšžœžœ
žœ
˜Jš
žœžœžœ
žœžœ˜IJš
œ+˜+Jšžœžœžœ˜9Jšžœ
žœ˜!Jšžœžœ˜J˜—˜!Jšœžœžœ˜*J˜—˜Jšœžœžœ˜&J˜—˜Jšœžœžœ˜$J˜—Jšœ
žœ
žœžœ�%˜EJ˜šŸ	œžœ,˜;Jšžœ&žœ
žœ˜?J˜—šŸœžœ
ž
œžœžœžœ˜TJšžœ
žœžœ
˜Jšœžœ
žœ'˜1Jšœžœ
žœžœ˜&Jš
žœžœžœ
žœžœ˜@š	žœ
žœžœ
žœž˜1Jš
žœžœ
žœžœžœ˜@Jšžœ
˜—š
œ-˜-J˜——šŸ
œžœ
ž
œžœ˜AJšžœ
žœžœ
˜Jšœžœ
žœ'˜1Jšœ
žœ
žœžœ˜*Jšžœ
žœ
žœ
ž˜Jšžœ
žœžœ˜;šžœ˜Jšœžœ
žœ˜%šžœžœ
žœ(žœžœ
ž˜JJšžœžœžœ˜:J˜Jšžœ˜
——Jšžœ
žœ
žœ&˜:Jšžœ
žœžœ2˜KJ˜—šŸœžœ
ž
œžœžœžœ˜UJšžœ
žœžœ
˜Jšœžœ
žœ'˜1Jšœ
žœ
žœžœ˜*šžœžœ
žœ žœžœ
ž˜<Jš
žœžœ
žœ
žœžœ
˜+—Jšžœžœ˜J˜—šŸœžœ˜J˜*J˜ J˜,J˜"J˜ J˜J˜*J˜*J˜.J˜&J˜.J˜&J˜.J˜&J˜J˜J˜J˜&J˜J˜.J˜.J˜*J˜,J˜"J˜J˜J˜WJ˜ J˜J˜J˜ J˜$J˜ J˜ J˜J˜J˜ J˜&J˜J˜J˜J˜J˜$J˜"J˜$J˜&J˜$J˜&J˜)J˜+J˜)J˜/J˜*J˜0J˜*J˜0J˜%J˜J˜$J˜ J˜J˜"J˜J˜ J˜J˜ J˜ J˜*J˜J˜(J˜"J˜,J˜2J˜*J˜"J˜ J˜J˜"J˜&J˜ J˜J˜.J˜&J˜"J˜J˜—Jšœžœžœ˜=Jšœžœžœ˜<Jšœžœžœ˜6Jšœžœžœ˜7J˜Jšœžœžœ"˜BJšœžœžœ˜<Jšœžœžœ"˜AJšœžœžœ'˜EJ˜J˜J˜/J˜Jšžœ
˜J˜J˜—…—hD†Õ