DIRECTORY EditSpan USING [ChangeLooks, ChangeNesting, CannotDoEdit, Copy, Delete, InsertTextNode, Merge, Move, MoveOnto, Place, Replace, SaveForPaste, SavedForPaste, Split, Transpose], EditSpanSupport USING [Apply], MessageWindow USING [Append, Blink], Rope USING [ROPE, Substr, Concat], RopeEdit USING [AlphaNumericChar], TextEdit USING [DeleteText, FetchChar, FetchLooks, FromRope, Offset, Ref, RefTextNode, Size], TextLooks USING [Look, Looks, allLooks, noLooks], TextLooksSupport USING [ModifyLooks], TextNode USING [Backward, FirstChild, LastLocWithin, Level, Location, MakeNodeLoc, MakeNodeSpan, NarrowToTextNode, NodeItself, nullSpan, Offset, Parent, pZone, Ref, RefTextNode, Root, Span, StepForward, StepBackward], TEditDisplay USING [EstablishLine], TEditDocument USING [BeforeAfter, Selection, SelectionId, SelectionGrain, SelectionPoint, SelectionRec, TEditDocumentData], TEditImpl USING [CaretAtEnd], TEditInput USING [currentEvent], TEditInputOps, TEditLocks USING [Access, Lock, LockBoth, LockRef, Unlock], TEditOps, TEditProfile USING [editTypeScripts], TEditRefresh USING [ScrollToEndOfSel], TEditSelection USING [Alloc, CaretVisible, Copy, Free, Deselect, GetSelectionGrain, InsertionPoint, LockBothSelections, LockSel, MakeSelection, MakePointSelection, nilSel, oldSel, pSel, SelectionRoot, sSel, UnlockBothSelections, UnlockDocAndPSel, UnlockSel], TypeScript USING [ChangeLooks], ViewerClasses USING [Viewer]; TEditInputOpsImpl: CEDAR PROGRAM IMPORTS EditSpan, MessageWindow, EditSpanSupport, Rope, RopeEdit, TextEdit, TextLooksSupport, TextNode, TEditDisplay, TEditImpl, TEditInput, TEditInputOps, TEditLocks, TEditProfile, TEditRefresh, TEditSelection, TypeScript EXPORTS TEditInputOps, TEditOps = BEGIN OPEN TEditDocument, TEditSelection; pdelNode: TextNode.RefTextNode = TextEdit.FromRope["!"]; DoPendingDelete: PUBLIC PROC = { PendingDelete: PROC [root: TextEdit.Ref, tSel: Selection] = { pSel.pendingDelete _ TRUE; tSel^ _ nilSel^; tSel.granularity _ char; tSel.looks _ pSel.looks; tSel.start.pos _ tSel.end.pos _ [pdelNode,0]; tSel.pendingDelete _ FALSE; CopyToDoc[targetSel: pSel, srcSel: tSel, target: primary, lock: FALSE]; Delete[saveForPaste: FALSE] }; CallWithLocks[PendingDelete] }; NodeSel: PROC [sel: Selection] RETURNS [BOOLEAN] = INLINE { RETURN [GetSelectionGrain[sel]=node OR sel.start.pos.node # sel.end.pos.node] }; Delete: PUBLIC PROC [saveForPaste: BOOLEAN _ TRUE] = { DoDelete: PROC [root: TextEdit.Ref, tSel: Selection] = { Deselect[]; tSel.pendingDelete _ FALSE; SELECT GetSelectionGrain[tSel] FROM point => NULL; node => BEGIN -- this is complex because must worry about deleting all of the document newSelNode: TextNode.Ref _ TextNode.StepForward[tSel.end.pos.node]; newSelText: TextNode.RefTextNode _ TextNode.NarrowToTextNode[newSelNode]; newSelInsertion: BeforeAfter; IF newSelNode=NIL THEN { -- deleting the last node of the doc newSelNode _ TextNode.StepBackward[tSel.start.pos.node]; IF newSelNode=NIL OR newSelNode=root THEN { -- deleting all the nodes child: TextEdit.Ref _ TextNode.FirstChild[root]; tSel.start.pos.node _ child; newSelNode _ EditSpan.InsertTextNode[root, child, before, FALSE, TEditInput.currentEvent] }; newSelText _ TextNode.NarrowToTextNode[newSelNode]; newSelInsertion _ IF newSelText#NIL AND TextEdit.Size[newSelText] > 0 THEN after ELSE before } ELSE { newSelInsertion _ before }; EditSpan.Delete[ SelectionRoot[tSel], TextNode.MakeNodeSpan[tSel.start.pos.node,tSel.end.pos.node], TEditInput.currentEvent,saveForPaste ! EditSpan.CannotDoEdit => GOTO Bad]; IF newSelText # NIL THEN { tSel.start.pos.node _ tSel.end.pos.node _ newSelText; tSel.start.pos.where _ tSel.end.pos.where _ IF newSelInsertion=before THEN 0 ELSE TextEdit.Size[newSelText] -- -1? --; tSel.granularity _ point } ELSE { -- the new selection node is not a text node tSel.start.pos _ tSel.end.pos _ TextNode.MakeNodeLoc[newSelNode]; tSel.granularity _ node }; tSel.insertion _ newSelInsertion; END; ENDCASE => BEGIN EditSpan.Delete[ SelectionRoot[tSel], [tSel.start.pos, tSel.end.pos], TEditInput.currentEvent,saveForPaste ! EditSpan.CannotDoEdit => GOTO Bad]; tSel.end.pos _ tSel.start.pos; tSel.granularity _ point; tSel.insertion _ before; END; MakeSelection[selection: primary, new: tSel]; EXITS Bad => { MakeSelection[selection: primary, new: tSel]; EditFailed[] }}; CallWithLocks[DoDelete] }; EditFailed: PUBLIC PROC [msg: Rope.ROPE _ NIL] = { OPEN MessageWindow; Append[IF msg=NIL THEN "Can't do it." ELSE msg, TRUE]; Blink[] }; CaretLoc: PUBLIC PROC [s: Selection _ NIL] RETURNS [TextNode.Location] = { IF s=NIL THEN s _ pSel; IF GetSelectionGrain[s] = node THEN RETURN [ [IF s.insertion = before THEN s.start.pos.node ELSE s.end.pos.node, TextNode.NodeItself]]; IF s.insertion = before THEN RETURN [s.start.pos]; RETURN [[s.end.pos.node, s.end.pos.where+1]] }; CallWithLocks: PUBLIC PROC [proc: PROC [root: TextEdit.Ref, tSel: Selection], access: TEditLocks.Access _ write] = BEGIN root: TextEdit.Ref; tSel: Selection; lockRef: TEditLocks.LockRef; BEGIN ENABLE UNWIND => { UnlockSel[primary]; IF lockRef # NIL THEN TEditLocks.Unlock[root]; IF tSel # NIL THEN Free[tSel] }; LockSel[primary, "CallWithLocks"]; IF (access=write AND ~CheckReadonly[pSel]) OR (root _ SelectionRoot[pSel])=NIL THEN { UnlockSel[primary]; RETURN }; lockRef _ TEditLocks.Lock[root, "CallWithLocks", access]; tSel _ Alloc[]; TEditSelection.Copy[source: pSel, dest: tSel]; proc[root, tSel]; Free[tSel]; tSel _ NIL; UnlockDocAndPSel[root]; END END; BackSpace: PUBLIC PROC [count: INT _ 1] = { DoBackSpace: PROC [root: TextEdit.Ref, tSel: Selection] = { node: TextNode.RefTextNode; flush: TextNode.Location _ InsertionPoint[tSel]; IF flush.where=TextNode.NodeItself THEN GOTO Bad; IF (node _ TextNode.NarrowToTextNode[flush.node])=NIL THEN GOTO Bad; IF flush.where=0 THEN { Join[]; RETURN }; -- already at start of node; do a Join IF (count _ MIN[count,flush.where]) <= 0 THEN GOTO Bad; Deselect[primary]; flush.where _ flush.where-count; TextEdit.DeleteText[root, node, flush.where, count, TEditInput.currentEvent]; MakePointSelection[tSel, flush]; EXITS Bad => EditFailed[] }; IF count > 0 THEN CallWithLocks[DoBackSpace]; }; FindPrevWord: PUBLIC PROC [node: TextNode.RefTextNode, offset: TextNode.Offset] RETURNS [nChars: CARDINAL] = { nChars _ 0; WHILE offset>0 AND ~RopeEdit.AlphaNumericChar[TextEdit.FetchChar[node, offset-1]] DO offset _ offset - 1; nChars _ nChars + 1; ENDLOOP; WHILE offset>0 AND RopeEdit.AlphaNumericChar[TextEdit.FetchChar[node, offset-1]] DO offset _ offset - 1; nChars _ nChars + 1; ENDLOOP; }; BackWord: PUBLIC PROC [count: INT _ 1] = BEGIN DoBackWord: PROC [root: TextEdit.Ref, tSel: Selection] = { node: TextNode.RefTextNode; nChars: CARDINAL _ 0; pos: TextNode.Location _ InsertionPoint[tSel]; IF (node _ TextNode.NarrowToTextNode[pos.node])=NIL THEN GOTO Bad; IF pos.where = TextNode.NodeItself THEN GOTO Bad; Deselect[primary]; FOR garbage:INT IN [0..count) DO wChars: CARDINAL _ FindPrevWord[node,pos.where]; pos.where _ pos.where - wChars; nChars _ nChars + wChars; ENDLOOP; TextEdit.DeleteText[root, node, pos.where, nChars, TEditInput.currentEvent]; MakePointSelection[tSel, pos]; EXITS Bad => EditFailed[] }; IF count > 0 THEN CallWithLocks[DoBackWord]; END; GoToPreviousWord: PUBLIC PROC [count: INT _ 1] = BEGIN DoGoToPreviousWord: PROC [root: TextEdit.Ref, tSel: Selection] = { pos: TextNode.Location; node: TextNode.RefTextNode; nChars: CARDINAL; pos _ InsertionPoint[tSel]; FOR garbage:INT IN [0..count) DO IF (node _ TextNode.NarrowToTextNode[pos.node])=NIL OR pos.where=TextNode.NodeItself OR pos.where=0 THEN { TEditInputOps.GoToPreviousNode; RETURN }; nChars _ FindPrevWord[node,pos.where]; pos.where _ pos.where - nChars; ENDLOOP; MakePointSelection[tSel,pos] }; IF count > 0 THEN CallWithLocks[DoGoToPreviousWord, read]; END; CopyToTypeScript: PROC [targetSel: Selection, source: TextNode.Span] = { TSCopy: PROC [node: TextNode.RefTextNode, start, len: TextNode.Offset] RETURNS [stop: BOOLEAN] = { rope: Rope.ROPE _ Rope.Substr[node.rope, start, len]; IF node # source.end.node THEN rope _ Rope.Concat[rope, "\n"]; -- add CR's between nodes targetSel.viewer.class.notify[targetSel.viewer, TextNode.pZone.LIST[rope]]; RETURN [FALSE] }; EditSpanSupport.Apply[source,TSCopy] }; ConvertNodeSelects: PROC [sel: Selection] RETURNS [BOOLEAN] = { IF GetSelectionGrain[sel] # node THEN RETURN [FALSE]; sel.start.pos.where _ sel.end.pos.where _ TextNode.NodeItself; RETURN [TRUE] }; ExpandToNodeSelection: PROC [sel: Selection] = { sel.start.pos.where _ 0; sel.end.pos.where _ MAX[TextEdit.Size[TextNode.NarrowToTextNode[sel.end.pos.node]],1]-1; sel.granularity _ node; }; UnConvertNodeSelects: PROC [sel: Selection] = { IF GetSelectionGrain[sel] # node THEN RETURN; sel.start.pos.where _ 0; sel.end.pos.where _ MAX[TextEdit.Size[TextNode.NarrowToTextNode[sel.end.pos.node]]-1,0] }; CallWithBothLocked: PUBLIC PROC [ proc: PROC [sourceRoot, destRoot: TextEdit.Ref, tSel, srcSel, targetSel: Selection], targetSel, srcSel: Selection, sourceAccess: TEditLocks.Access] = BEGIN sourceRoot, destRoot: TextEdit.Ref; tSel, tSel1, tSel2: Selection; lockRef: TEditLocks.LockRef; Cleanup: PROC = { IF lockRef # NIL THEN { TEditLocks.Unlock[sourceRoot]; TEditLocks.Unlock[destRoot] }; IF tSel # NIL THEN Free[tSel]; IF tSel1 # NIL THEN Free[tSel1]; IF tSel2 # NIL THEN Free[tSel2]; UnlockBothSelections[] }; BEGIN ENABLE UNWIND => { Cleanup[] }; LockBothSelections["CallWithBothLocked"]; IF srcSel.viewer=NIL OR targetSel.viewer=NIL THEN { UnlockBothSelections[]; RETURN }; IF ~CheckReadonly[targetSel] OR -- don't edit a readonly document (sourceAccess=write AND ~CheckReadonly[srcSel]) THEN { Deselect[selection: secondary]; UnlockBothSelections[]; RETURN }; tSel1 _ Alloc[]; tSel2 _ Alloc[]; tSel _ Alloc[]; TEditSelection.Copy[source: srcSel, dest: tSel1]; TEditSelection.Copy[source: targetSel, dest: tSel2]; TEditSelection.Copy[source: targetSel, dest: tSel]; sourceRoot _ SelectionRoot[srcSel]; destRoot _ SelectionRoot[targetSel]; [lockRef, ----] _ TEditLocks.LockBoth[ sourceRoot, destRoot, "CallWithBothLocked", sourceAccess, write]; Deselect[selection: secondary]; Deselect[selection: primary]; proc[sourceRoot, destRoot, tSel, tSel1, tSel2]; Cleanup[]; END END; CopyToDoc: PROC [targetSel, srcSel: Selection, target: SelectionId, lock: BOOL _ TRUE] = { DoCopyToDoc: PROC [sourceRoot, destRoot: TextEdit.Ref, tSel, srcSel, targetSel: Selection] = { wordMode: BOOLEAN = FALSE; -- (srcSel.granularity = word); nodeCopy: BOOLEAN _ ConvertNodeSelects[srcSel]; pDel: BOOLEAN _ tSel.pendingDelete; IF pDel THEN { -- replace target by source [] _ ConvertNodeSelects[tSel]; [[tSel.start.pos, tSel.end.pos]] _ EditSpan.Replace[destRoot, sourceRoot, [tSel.start.pos, tSel.end.pos], [srcSel.start.pos, srcSel.end.pos], wordMode, TRUE, TEditInput.currentEvent ! EditSpan.CannotDoEdit => GOTO Bad]; tSel.pendingDelete _ FALSE } ELSE { -- source goes to target caret loc: TextNode.Location _ InsertionPoint[tSel]; unnest: INTEGER _ 0; -- amount to unnest by if copying nodes after where: EditSpan.Place _ IF tSel.insertion = before THEN before ELSE after; IF nodeCopy THEN { -- don't copy nodes into target node IF where = before AND loc.where > 0 AND loc.where = TextEdit.Size[TextNode.NarrowToTextNode[loc.node]] THEN where _ after; -- caret at end of node, so copy after loc.where _ TextNode.NodeItself }; IF nodeCopy AND where=after AND tSel.start.pos.node#tSel.end.pos.node THEN unnest _ TextNode.Level[tSel.end.pos.node]-TextNode.Level[tSel.start.pos.node]; [[tSel.start.pos, tSel.end.pos]] _ EditSpan.Copy[destRoot, sourceRoot, loc, [srcSel.start.pos, srcSel.end.pos], wordMode, where, 0, TEditInput.currentEvent ! EditSpan.CannotDoEdit => GOTO Bad]; IF unnest > 0 THEN -- unnest so that copied span starts at same level as start of dest span [[tSel.start.pos, tSel.end.pos]] _ EditSpan.ChangeNesting[root: destRoot, span: [tSel.start.pos, tSel.end.pos], change: -unnest, event: TEditInput.currentEvent ! EditSpan.CannotDoEdit => CONTINUE]; }; tSel.granularity _ srcSel.granularity; UnConvertNodeSelects[tSel]; tSel.insertion _ after; MakeSelection[selection: primary, new: tSel]; TEditSelection.Copy[source: tSel, dest: oldSel]; -- save the copied selection for Repeat's EXITS Bad => { MakeSelection[selection: primary, new: IF target=primary THEN targetSel ELSE srcSel]; EditFailed[] }}; IF lock THEN CallWithBothLocked[DoCopyToDoc, targetSel, srcSel, read] ELSE { -- special hack for DoPendingDelete. tSel: Selection _ Alloc[]; TEditSelection.Copy[source: targetSel, dest: tSel]; DoCopyToDoc[SelectionRoot[srcSel], SelectionRoot[targetSel], tSel, srcSel, targetSel]; Free[tSel] }}; Copy: PUBLIC PROCEDURE [target: SelectionId _ primary] = BEGIN ENABLE UNWIND => UnlockBothSelections[]; targetSel: Selection _ IF target=primary THEN pSel ELSE sSel; srcSel: Selection _ IF target=primary THEN sSel ELSE pSel; LockBothSelections["Copy"]; IF srcSel.viewer#NIL AND targetSel.viewer#NIL THEN DoCopy[target, targetSel, srcSel]; UnlockBothSelections[]; END; CheckReadonly: PUBLIC PROC [targetSel: Selection] RETURNS [BOOL] = { IF targetSel.viewer=NIL OR ~targetSel.data.readOnly THEN RETURN [TRUE]; EditFailed["Cannot modify read only document."]; RETURN [FALSE] }; DoCopy: PROC [target: SelectionId, targetSel, srcSel: Selection] = { IF ~CheckReadonly[targetSel] THEN { Deselect[selection: secondary]; RETURN }; IF targetSel.data.tsInfo#NIL AND (~TEditProfile.editTypeScripts OR TEditImpl.CaretAtEnd[targetSel]) THEN BEGIN tSel: Selection _ Alloc[]; tSel1: Selection _ Alloc[]; span: TextNode.Span _ [srcSel.start.pos, srcSel.end.pos]; TEditSelection.Copy[source: sSel, dest: oldSel]; -- save the secondary selection for Repeat's TEditSelection.Copy[source: targetSel, dest: tSel]; tSel.insertion _ before; tSel.granularity _ point; tSel.start.pos _ tSel.end.pos _ TextNode.LastLocWithin[tSel.data.text]; TEditSelection.Copy[source: srcSel, dest: tSel1]; srcSel _ tSel1; Deselect[selection: primary]; Deselect[selection: secondary]; CopyToTypeScript[tSel, span]; IF target=primary THEN { -- leave primary as caret at end of typescript tSel.start.pos _ tSel.end.pos _ TextNode.LastLocWithin[tSel.data.text]; MakeSelection[selection: primary, new: tSel] } ELSE MakeSelection[selection: primary, new: srcSel]; Free[tSel]; Free[tSel1]; END ELSE IF srcSel.pendingDelete THEN Move[target] ELSE CopyToDoc[targetSel, srcSel, target]; }; Paste: PUBLIC PROC = { DoPaste: PROC [root: TextEdit.Ref, tSel: Selection] = { source: TextNode.Span _ EditSpan.SavedForPaste[]; tdd: TEditDocument.TEditDocumentData _ tSel.data; IF source = TextNode.nullSpan OR tSel.viewer=NIL THEN GOTO Bad; IF tdd.tsInfo=NIL AND tSel.pendingDelete THEN { DoPendingDelete[]; TEditSelection.Copy[source: pSel, dest: tSel] }; Deselect[selection: secondary]; tSel.start.pos _ source.start; tSel.end.pos _ source.end; IF source.start.where=TextNode.NodeItself OR source.end.where=TextNode.NodeItself THEN { tSel.granularity _ node; UnConvertNodeSelects[tSel] } ELSE tSel.granularity _ char; tSel.viewer _ pSel.viewer; -- else Copy will think there isn't a secondary selection tSel.data _ NIL; tSel.pendingDelete _ FALSE; DoCopy[primary, pSel, tSel]; EXITS Bad => EditFailed[] }; CallWithLocks[DoPaste] }; Move: PUBLIC PROCEDURE [target: SelectionId _ primary] = { targetSel: Selection _ IF target=primary THEN pSel ELSE sSel; srcSel: Selection _ IF target=primary THEN sSel ELSE pSel; DoMove: PROC [sourceRoot, destRoot: TextEdit.Ref, tSel, srcSel, targetSel: Selection] = { nodeMove: BOOLEAN; pDel: BOOLEAN; wordMode: BOOLEAN = FALSE; -- (srcSel.granularity = word); IF GetSelectionGrain[srcSel] = node THEN { -- see if moving entire contents newSelNode: TextNode.Ref _ TextNode.StepForward[srcSel.end.pos.node]; IF newSelNode=NIL THEN { -- moving the last node of the doc newSelNode _ TextNode.StepBackward[srcSel.start.pos.node]; IF (newSelNode=NIL OR newSelNode=sourceRoot) AND destRoot # sourceRoot THEN { child: TextEdit.Ref _ TextNode.FirstChild[sourceRoot]; srcSel.start.pos.node _ child; -- make sure doesn't include the root [] _ EditSpan.InsertTextNode[sourceRoot, child, before, FALSE, TEditInput.currentEvent] }}}; nodeMove _ ConvertNodeSelects[srcSel]; IF (pDel _ tSel.pendingDelete) THEN { -- move source onto target [] _ ConvertNodeSelects[tSel]; [[tSel.start.pos, tSel.end.pos]] _ EditSpan.MoveOnto[ destRoot, sourceRoot, [tSel.start.pos, tSel.end.pos], [srcSel.start.pos, srcSel.end.pos], wordMode, TRUE, TEditInput.currentEvent ! EditSpan.CannotDoEdit => GOTO Bad]; tSel.pendingDelete _ FALSE } ELSE { -- move source to target caret loc: TextNode.Location _ InsertionPoint[tSel]; unnest: INTEGER _ 0; -- amount to unnest by if moving nodes after where: EditSpan.Place _ IF tSel.insertion = before THEN before ELSE after; IF nodeMove THEN { -- don't move nodes into target node IF where = before AND loc.where > 0 AND loc.where = TextEdit.Size[TextNode.NarrowToTextNode[loc.node]] THEN where _ after; -- caret at end of node, so move after loc.where _ TextNode.NodeItself }; IF nodeMove AND where=after AND tSel.start.pos.node#tSel.end.pos.node THEN unnest _ TextNode.Level[tSel.end.pos.node]-TextNode.Level[tSel.start.pos.node]; [[tSel.start.pos, tSel.end.pos]] _ EditSpan.Move[ destRoot, sourceRoot, loc, [srcSel.start.pos, srcSel.end.pos], wordMode, where, 0, TEditInput.currentEvent ! EditSpan.CannotDoEdit => GOTO Bad]; IF unnest > 0 THEN -- unnest so that moved span starts at same level as start of dest span [[tSel.start.pos, tSel.end.pos]] _ EditSpan.ChangeNesting[root: destRoot, span: [tSel.start.pos, tSel.end.pos], change: -unnest, event: TEditInput.currentEvent ! EditSpan.CannotDoEdit => CONTINUE]; }; tSel.granularity _ srcSel.granularity; UnConvertNodeSelects[tSel]; tSel.insertion _ after; TEditSelection.Copy[source: tSel, dest: oldSel]; -- save for Repeat's oldSel.pendingDelete _ (target=primary) OR (target=secondary AND pDel); tSel.pendingDelete _ FALSE; MakeSelection[selection: primary, new: tSel]; EXITS Bad => { MakeSelection[selection: primary, new: tSel]; EditFailed[] }}; CallWithBothLocked[DoMove, targetSel, srcSel, write] }; Transpose: PUBLIC PROCEDURE [target: SelectionId _ primary] = { targetSel: Selection _ IF target=primary THEN pSel ELSE sSel; srcSel: Selection _ IF target=primary THEN sSel ELSE pSel; DoTranspose: PROC [sourceRoot, destRoot: TextEdit.Ref, tSel, srcSel, targetSel: Selection] = { wordMode: BOOLEAN = FALSE; -- targetSel.granularity=word AND srcSel.granularity=word; tempT: TextNode.Span; [] _ ConvertNodeSelects[srcSel]; [] _ ConvertNodeSelects[targetSel]; [tempT, ----] _ EditSpan.Transpose[destRoot, sourceRoot, [targetSel.start.pos, targetSel.end.pos], [srcSel.start.pos, srcSel.end.pos], wordMode, TEditInput.currentEvent ! EditSpan.CannotDoEdit => GOTO Bad]; [srcSel.start.pos, srcSel.end.pos] _ tempT; UnConvertNodeSelects[srcSel]; srcSel.pendingDelete _ FALSE; MakeSelection[selection: primary, new: srcSel]; TEditSelection.Copy[source: srcSel, dest: oldSel]; -- save for Repeat's EXITS Bad => { MakeSelection[selection: primary, new: IF target=primary THEN targetSel ELSE srcSel]; EditFailed[] }}; CallWithBothLocked[DoTranspose, targetSel, srcSel, write] }; Break: PUBLIC PROC = { DoBreak: PROC [root: TextEdit.Ref, tSel: Selection] = { null: BOOL _ FALSE; caret: TextNode.Location; newNode: TextNode.RefTextNode; IF tSel.pendingDelete THEN { DoPendingDelete[]; TEditSelection.Copy[source: pSel, dest: tSel] }; caret _ InsertionPoint[pSel]; Deselect[primary]; newNode _ TextNode.NarrowToTextNode[EditSpan.Split[root, caret, TEditInput.currentEvent ! EditSpan.CannotDoEdit => GOTO Bad]]; IF newNode # NIL AND TextEdit.Size[TextNode.NarrowToTextNode[caret.node]]=0 AND TextEdit.Size[newNode] > 0 THEN null _ TRUE -- caret was at front of nonempty node ELSE tSel.start.pos.node _ newNode; -- move caret to start of new node tSel.start.pos.where _ 0; tSel.end.pos _ tSel.start.pos; tSel.granularity _ point; tSel.insertion _ before; tSel.pendingDelete _ FALSE; tSel.looks _ TextLooks.noLooks; MakeSelection[selection: primary, new: tSel]; CheckStartLine[viewer: tSel.viewer, old: caret, new: [newNode,0], null: null]; EXITS Bad => { MakeSelection[selection: primary, new: tSel]; EditFailed[] }}; CallWithLocks[DoBreak] }; Join: PUBLIC PROCEDURE = { DoJoin: PROC [root: TextEdit.Ref, tSel: Selection] = { loc: TextNode.Location; pred: TextNode.Ref; node: TextNode.RefTextNode _ TextNode.NarrowToTextNode[InsertionPoint[].node]; IF node=NIL OR (pred _ TextNode.StepBackward[node])=NIL OR TextNode.Parent[pred]=NIL --i.e., pred is root-- THEN { EditFailed[]; RETURN }; Deselect[primary]; loc _ EditSpan.Merge[root, node, TEditInput.currentEvent ! EditSpan.CannotDoEdit => GOTO Bad]; MakePointSelection[tSel, loc]; CheckStartLine[viewer: tSel.viewer, old: [node,0], new: loc]; EXITS Bad => { MakeSelection[selection: primary, new: tSel]; EditFailed[] }}; CallWithLocks[DoJoin] }; CheckStartLine: PROC [viewer: ViewerClasses.Viewer, old, new: TextNode.Location, null: BOOL _ FALSE] = { first: BOOLEAN _ TRUE; FOR v: ViewerClasses.Viewer _ viewer, v.link UNTIL v=NIL OR (v=viewer AND ~first) DO tdd: TEditDocument.TEditDocumentData _ NARROW[v.data]; IF tdd # NIL THEN { vloc: TextNode.Location _ tdd.lineTable.lines[0].pos; first _ FALSE; IF vloc.node = old.node AND vloc.where >= old.where THEN { vnew: TextNode.Location _ [new.node, new.where+vloc.where-old.where]; IF null AND vnew.where = 0 THEN vnew.node _ old.node; TEditDisplay.EstablishLine[tdd, vnew] }; }; ENDLOOP }; SaveForPaste: PUBLIC PROC = { DoSaveForPaste: PROC [root: TextEdit.Ref, tSel: Selection] = { [] _ ConvertNodeSelects[tSel]; EditSpan.SaveForPaste[[tSel.start.pos, tSel.end.pos], TEditInput.currentEvent] }; CallWithLocks[DoSaveForPaste, read] }; SaveSpanForPaste: PUBLIC PROC [ startLoc, endLoc: TextNode.Location, grain: TEditDocument.SelectionGrain] = { root: TextEdit.Ref = TextNode.Root[startLoc.node]; lockRef: TEditLocks.LockRef; {ENABLE UNWIND => { IF lockRef # NIL THEN TEditLocks.Unlock[root] }; lockRef _ TEditLocks.Lock[root, "SaveSpanForPaste", read]; IF grain=node OR grain=branch THEN { startLoc.where _ TextNode.NodeItself; endLoc.where _ TextNode.NodeItself }; EditSpan.SaveForPaste[[startLoc, endLoc], TEditInput.currentEvent]; TEditLocks.Unlock[root] }}; Nest: PUBLIC PROC = { ChangeNesting[1] }; UnNest: PUBLIC PROC = { ChangeNesting[-1] }; ChangeNesting: PROC [change: INTEGER] = { DoChangeNesting: PROC [root: TextEdit.Ref, tSel: Selection] = { Deselect[primary]; [] _ EditSpan.ChangeNesting[root, TextNode.MakeNodeSpan[tSel.start.pos.node, tSel.end.pos.node], change, TEditInput.currentEvent ! EditSpan.CannotDoEdit => GOTO Bad]; tSel.pendingDelete _ FALSE; MakeSelection[selection: primary, new: tSel]; IF CaretVisible[] THEN TEditRefresh.ScrollToEndOfSel[tSel.viewer, TRUE]; EXITS Bad => { MakeSelection[selection: primary, new: tSel]; EditFailed[] }}; CallWithLocks[DoChangeNesting] }; ModifyLook: PUBLIC PROC [look: TextLooks.Look, op: TEditInputOps.ModifyOp] = { DoModifyLook: PROC [root: TextEdit.Ref, tSel: Selection] = { remLooks, addLooks: TextLooks.Looks _ TextLooks.noLooks; IF tSel.granularity#point THEN { Deselect[primary]; IF op=add THEN addLooks[look] _ TRUE ELSE remLooks[look] _ TRUE; EditSpan.ChangeLooks[root: root, span: [tSel.start.pos, tSel.end.pos], remove: remLooks, add: addLooks, event: TEditInput.currentEvent]; tSel.pendingDelete _ FALSE; MakeSelection[selection: primary, new: tSel] }; ModifyCaretLook[look, op] }; CallWithLocks[DoModifyLook] }; ModifyCaretLook: PUBLIC PROC [look: TextLooks.Look, op: TEditInputOps.ModifyOp] = BEGIN LockSel[primary, "ModifyCaretLook"]; pSel.looks[look] _ (op=add); IF SelAtEndOfTypeScript[pSel] THEN IF (op=add) THEN TypeScript.ChangeLooks[pSel.viewer, look] ELSE TypeScript.ChangeLooks[pSel.viewer, Capital[look]]; UnlockSel[primary]; END; GetSelLooks: PROC [sel: Selection] RETURNS [looks: TextLooks.Looks] = { first: BOOLEAN _ TRUE; GetSelLooks: PROC [node: TextNode.RefTextNode, start, len: TextNode.Offset] RETURNS [stop: BOOLEAN] = { end: TextNode.Offset _ MIN[TextEdit.Size[node],start+len]; FOR i: TextNode.Offset IN [start..end) DO lks: TextLooks.Looks _ TextEdit.FetchLooks[node,i]; IF first THEN { first _ FALSE; looks _ lks } ELSE IF lks#looks THEN { OPEN MessageWindow; Append["Selection does not have uniform looks.",TRUE]; Append[" Using looks from first char."]; Blink[]; RETURN [TRUE] }; ENDLOOP; RETURN [FALSE] }; EditSpanSupport.Apply[[sel.start.pos, sel.end.pos],GetSelLooks]; IF first THEN looks _ sel.looks -- null selection, use caret }; ChangeLooks: PUBLIC PROC [add, remove: TextLooks.Looks] = { DoChangeLooks: PROC [root: TextEdit.Ref, tSel: Selection] = { Deselect[primary]; ChangeSelLooks[add,remove,tSel]; MakeSelection[tSel,primary] }; CallWithLocks[DoChangeLooks] }; CopyLooks: PUBLIC PROCEDURE [target: SelectionId _ primary] = { targetSel: Selection _ IF target=primary THEN pSel ELSE sSel; srcSel: Selection _ IF target=primary THEN sSel ELSE pSel; DoCopyLooks: PROC [sourceRoot, destRoot: TextEdit.Ref, tSel, srcSel, targetSel: Selection] = { TEditSelection.Copy[source: srcSel, dest: oldSel]; -- save the secondary selection for Repeat's ChangeSelLooks[add: GetSelLooks[srcSel], remove: TextLooks.allLooks, targetSel: targetSel]; MakeSelection[IF target=primary THEN targetSel ELSE srcSel, primary] }; CallWithBothLocked[DoCopyLooks, targetSel, srcSel, read] }; TransposeLooks: PUBLIC PROC [target: SelectionId _ primary] = { targetSel: Selection _ IF target=primary THEN pSel ELSE sSel; srcSel: Selection _ IF target=primary THEN sSel ELSE pSel; DoTransLooks: PROC [sourceRoot, destRoot: TextEdit.Ref, tSel, srcSel, targetSel: Selection] = { srcLooks, targetLooks: TextLooks.Looks; srcLooks _ GetSelLooks[srcSel]; targetLooks _ GetSelLooks[targetSel]; TEditSelection.Copy[source: srcSel, dest: oldSel]; -- save for Repeat's Deselect[primary]; Deselect[secondary]; ChangeSelLooks[add: srcLooks, remove: targetLooks, targetSel: targetSel]; ChangeSelLooks[add: targetLooks, remove: srcLooks, targetSel: srcSel]; MakeSelection[IF target=primary THEN targetSel ELSE srcSel, primary] }; CallWithBothLocked[DoTransLooks, targetSel, srcSel, write] }; ChangeSelLooks: PROC [add, remove: TextLooks.Looks, targetSel: Selection] = BEGIN IF targetSel.granularity # point THEN { EditSpan.ChangeLooks[SelectionRoot[targetSel], [targetSel.start.pos, targetSel.end.pos], remove, add, TEditInput.currentEvent]; targetSel.pendingDelete _ FALSE }; targetSel.looks _ TextLooksSupport.ModifyLooks[targetSel.looks, remove, add]; AdjustTypeScriptLooks[targetSel, add, remove]; END; ChangeCaretLooks: PUBLIC PROC [add, remove: TextLooks.Looks] = BEGIN LockSel[primary, "ChangeCaretLooks"]; pSel.looks _ TextLooksSupport.ModifyLooks[pSel.looks, remove, add]; AdjustTypeScriptLooks[pSel, add, remove]; UnlockSel[primary]; END; SelAtEndOfTypeScript: PROC [targetSel: Selection] RETURNS [BOOL] = { tdd: TEditDocumentData; IF targetSel.viewer=NIL THEN RETURN [FALSE]; tdd _ NARROW[targetSel.viewer.data]; IF tdd = NIL OR tdd.tsInfo=NIL THEN RETURN [FALSE]; -- not a typescript IF ~TEditImpl.CaretAtEnd[targetSel] THEN RETURN [FALSE]; RETURN [TRUE] }; Capital: PROC [c: CHAR] RETURNS[CHAR] = INLINE { RETURN[IF c IN ['a..'z] THEN LOOPHOLE[c - 'a + 'A] ELSE c]}; AdjustTypeScriptLooks: PROC [targetSel: Selection, add, remove: TextLooks.Looks] = BEGIN IF ~SelAtEndOfTypeScript[targetSel] THEN RETURN; FOR c: CHAR IN TextLooks.Look DO IF remove[c] THEN TypeScript.ChangeLooks[targetSel.viewer, Capital[c]]; IF add[c] THEN TypeScript.ChangeLooks[targetSel.viewer, c]; ENDLOOP; END; END. 4-- TEditInputOpsImpl.mesa; Edited by Paxton on February 8, 1983 9:34 am -- Edited by McGregor on July 30, 1982 3:15 pm Last Edited by: Maxwell, January 14, 1983 1:58 pm like a replace of pSel by a single character, then delete that character. same as calling Delete for pSel a text selection, but NOT for pSel a node/branch selection. -- shove it in as though typed... special copy to typescript unless we are editing typescripts like regular Tioga documents and the target caret is at the end -- force selection to end of typescript -- now create a phony secondary selection for Copy -- moving all the nodes to different tree -- move the selection to a deeper nesting level in the tree -- move the selection to a shallower nesting level in the tree -- Transpose the looks of the primary and secondary selections ÊY˜JšÏcv™vJ™1JšÏk ˜ ˜šœ žœI˜WJ˜V—Jšœžœ ˜Jšœžœ˜$Jšœžœžœžœ˜"Jšœ žœ˜"Jšœ žœO˜]Jšœ žœ"˜1Jšœžœ˜%Jšœ žœ'Ïbœ˜ÙJšœ žœ˜#Jšœžœh˜{Jšœ žœ˜Jšœ žœ˜ J˜Jšœ žœ+˜;J˜ Jšœ žœ˜%Jšœ žœ˜&Jšœžœî˜‚Jšœ žœ˜Jšœžœ ˜J˜—Jšœž ˜ J˜Jšžœ×˜ÞJšžœžœžœ˜KJ˜J˜8J˜šÏnœžœžœ˜ JšœI™IJšœ[™[š  œžœ*˜=Jšœžœ˜J˜J˜J˜J˜-Jšœžœ˜Jšœ@žœ˜GJšœžœ˜—Jšœ˜J˜—š  œžœžœžœžœ˜;Jšžœžœ*˜PJ˜—š  œžœžœžœžœ˜6š œžœ*˜8J˜ Jšœžœ˜šžœž˜#Jšœ žœ˜šœžœH˜VJ˜CJ˜IJ˜šžœ žœžœ$˜=J˜8š žœ žœžœžœ˜EJ˜0J˜˜1Jšœžœ˜*——J˜3Jš œžœ žœžœžœžœ ˜^—Jšžœ˜"˜J˜J˜=Jšœ@žœ˜J—šžœžœžœ˜J˜5˜,Jšžœžœ˜ Jšžœ œ˜)—J˜—šžœ,˜3J˜AJ˜—J˜!Jšžœ˜—šžœž˜˜J˜J˜J˜&Jšœžœ˜#—J˜J˜J˜Jšžœ˜——Jšœ-˜-JšžœH˜M—Jšœ˜J˜—š   œžœžœ žœžœžœ˜FJš œžœžœžœžœžœ ˜AJ˜—š  œžœžœžœžœ˜JJšžœžœžœ ˜šžœžœžœ˜,Jšœžœžœžœ'˜Z—Jšžœžœžœ˜2Jšžœ)˜/J˜—š  œžœž˜JšœžœMž˜]Jšœ˜Jšœ˜J˜Jšž˜šžœžœ˜Jšœ˜Jšœ žœžœ˜.Jšžœžœžœ˜ —Jšœ"˜"š žœžœžœžœžœ˜UJšœžœ˜—Jšœ9˜9Jšœ˜J˜.J˜Jšœžœ˜Jšœ˜Jšžœ˜J˜—š  œžœžœ žœ ˜+š  œžœ*˜;J˜Jšœ0˜0Jšžœ!žœžœ˜1Jšžœ0žœžœžœ˜DJšžœžœ žœ&˜PJšžœ žœžœžœ˜7J˜J˜ JšœM˜MJšœ ˜ Jšžœ˜—Jšžœ žœ˜-J˜J˜—š  œžœžœ6˜OJšžœ žœ˜J˜ šžœ žœ@ž˜TJšœ*žœ˜2—šžœ žœ?ž˜SJšœ*žœ˜2—J˜J˜—š  œžœžœ žœž˜.š  œžœ*˜:J˜Jšœžœ˜Jšœ.˜.Jšžœ.žœžœžœ˜BJšžœ!žœžœ˜1J˜šžœ žœžœ ž˜ Jšœžœ ˜0J˜J˜Jšžœ˜—J˜LJšœ˜Jšžœ˜—Jšžœ žœ˜,Jšžœ˜J˜—š  œžœžœ žœž˜6š œžœ*˜BJ˜J˜Jšœžœ˜Jšœ˜šžœ žœžœ ž˜ šžœ.žœž˜6šœžœ žœ˜3Jšœ žœ˜)——J˜&J˜Jšžœ˜—Jšœ˜—Jšžœ žœ)˜:Jšžœ˜J˜—š œžœ2˜Hš œžœ:˜FJšžœžœ˜Jšœ žœ&˜5Jšžœžœ!˜XJš!™!Jšœ?žœ˜KJšžœžœ˜—J˜'J˜—š œžœžœžœ˜?Jšžœžœžœžœ˜5J˜>Jšžœžœ˜J˜—š œžœ˜0J˜˜JšžœA˜D—J˜J˜J˜—š œžœ˜/Jšžœžœžœ˜-J˜JšœžœC˜ZJ˜—š œžœžœ˜!JšœžœJ˜TJšœAž˜FJšœ#˜#Jšœ˜Jšœ˜š œžœ˜Jšžœ žœžœ@˜UJšžœžœžœ ˜Jšžœ žœžœ ˜ Jšžœ žœžœ ˜ Jšœ˜—Jšž˜Jšžœžœ˜Jšœ)˜)Jš žœžœžœžœžœžœ˜Ušžœžœ!˜Ašœžœžœ˜6Jšœ8žœ˜A——Jšœ1˜1J˜1J˜4J˜3J˜#J˜$šœ&˜&JšœA˜A—J˜ J˜Jšœ/˜/Jšœ ˜ Jšžœ˜J˜—š  œžœ;žœžœ˜Zš  œžœM˜^Jšœ žœžœ˜:Jšœ žœ˜/Jšœžœ˜#šžœžœ˜*J˜˜"˜&J˜Jšœ.žœ˜3Jšœ3žœ˜=——Jšœžœ˜—šžœ˜%J˜.JšŸÐbk ŸÐbc-˜BJšœžœžœžœ˜Jšžœ žœ$˜7šžœžœž˜'šœ?ž˜CJšœ&˜5——J˜"—š¡Ÿ ¡Ÿ ¡Ÿ'¡˜JJšŸO˜O—˜"˜(J˜7Jšœ3žœ˜=——š¡Ÿ ¡Ÿ¢H˜[JšŸ"˜"šŸL˜LJšŸ1˜1JšŸ¡Ÿ˜#——J˜—J˜&J˜J˜J˜-Jšœ1)˜Zšžœ ˜Jšœ'žœžœ žœ ˜UJ˜——Jšžœžœ9˜Ešžœ$˜+Jšœ˜J˜3JšœV˜VJšœ˜—J˜—š œžœž œ#ž˜>Jšžœžœ˜(Jšœžœžœžœ˜=Jšœžœžœžœ˜:Jšœ˜Jš žœžœžœžœžœ#˜UJšœ˜Jšžœ˜J˜—š   œžœžœžœžœ˜DJš žœžœžœžœžœžœ˜GJ˜0Jšžœžœ˜J˜—š œžœ9˜Ešžœžœ˜#Jšœ žœ˜)—šžœžœž˜ šžœžœ žœž˜MJšœ|™|—Jšœ˜Jšœ˜J˜9Jšœ1,˜]Jš'™'Jšœ3˜3J˜J˜J˜GJšœA˜AJ˜J˜J˜šžœžœ.˜GJ˜GJ˜.—Jšžœ0˜4J˜Jšž˜—Jšžœžœžœ ˜.Jšžœ&˜*J˜J˜—š œžœžœ˜š œžœ*˜7J˜1Jšœ1˜1Jš žœžœ žœžœžœ˜?šžœ žœžœžœ˜/Jšœ˜J˜0—J˜Jš2™2J˜J˜šžœ(žœ%˜QJšžœ8˜Jšœ˜JšœQ˜Q—J˜&J˜—š œžœžœ˜JšœM˜MJšœ2˜2J˜Jš œžœžœžœ žœžœ˜DJšœ:˜:šžœ žœžœ˜$JšœK˜K—JšœC˜CJšœ˜J˜—š œžœžœ˜)Jš;™;J˜—š œžœžœ˜,Jš>™>J˜—š  œžœ žœ˜)š œžœ*˜?J˜˜!J˜>Jšœ;žœ˜E—Jšœžœ˜J˜-Jšžœžœ,žœ˜HJšžœH˜M—Jšœ!˜!J˜—š  œžœžœ7˜Nš  œžœ*˜™>Jšœžœžœžœ˜=Jšœžœžœžœ˜:š  œžœM˜_J˜'J˜J˜%Jšœ4˜HJ˜'J˜IJ˜FJšœžœžœ žœ˜G—Jšœ=˜=J˜—š œžœ8ž˜Qšžœžœ˜'˜.J˜6J˜—Jšœžœ˜"—J˜MJšœ.˜.Jšžœ˜J˜—š œžœžœ"ž˜DJšœ%˜%JšœC˜CJšœ)˜)Jšœ˜Jšžœ˜J˜—š œžœžœžœ˜DJšœ˜Jš žœžœžœžœžœ˜,Jšœžœ˜$Jšžœžœžœ žœžœžœžœ˜GJšžœ"žœžœžœ˜8Jšžœžœ˜J˜—š  œžœžœžœžœžœ˜0Jš žœžœžœ žœžœžœ˜