<> <> <> <> <> DIRECTORY Ascii USING [BS], BiScrollers USING [Align, BiScroller, QuaViewer, Scale, ViewportBox], Geom2D USING [id, Rect, Transform, Vec], Imager USING [Context, MaskRectangleI, SetColor, VEC, white], ImagerTransformation USING [PostScale, PostScale2, PostTranslate, Transform, TransformRectangle], MessageWindow USING [Append, Blink], Process USING [Detach], Real USING [RoundI], RefText USING [AppendChar, New], Rope USING [Fetch, FromChar, FromRefText, ToRefText, Cat, Equal], ViewerClasses USING [Viewer], ViewerOps USING [PaintViewer, SaveViewer, UserToScreenCoords], SilDisplay, SilDisplayCursors, SilDisplayInternal, SilDisplayPrivate, SilDisplayUtils, SilFile, SilKernel, SilUserInput ; SilDisplayImpl: CEDAR MONITOR IMPORTS BiScrollers, Geom2D, Imager, ImagerTransformation, MessageWindow, Process, Real, RefText, Rope, SilDisplay, SilDisplayCursors, SilDisplayUtils, SilFile, SilKernel, SilUserInput, ViewerOps EXPORTS SilKernel, SilDisplayPrivate = BEGIN OPEN SilFile; SilData: TYPE = SilKernel.SilData; SilModel: TYPE = SilFile.SilModel; SilUIData: TYPE = SilKernel.SilUIData; SilDisplayData: TYPE = REF SilDisplayDataRec; SilDisplayDataRec: PUBLIC TYPE = SilDisplayInternal.SilDisplayDataRec; UInputRec: TYPE = SilUserInput.UInputRec; SilSelection: TYPE = SilFile.SilSelection; RebuildAreaRec: TYPE = RECORD[ xMin, yMin: INTEGER _ LAST[INTEGER], xMax, yMax: INTEGER _ FIRST[INTEGER] ]; UpdateRebuildArea: PROC [s: SilObjectRec, a: RebuildAreaRec] RETURNS [r: RebuildAreaRec] = { RETURN[[MIN[a.xMin, s.xMin], MIN[a.yMin, s.yMin], MAX[a.xMax, s.xMax], MAX[a.yMax, s.yMax]]]; }; MergeRebuildArea: PROC [data: SilDisplayData, model: SilModel, a: RebuildAreaRec] = { IF a.xMin#LAST[INTEGER] THEN SilDisplayUtils.MergeRebuild[data, model, a.xMin, a.yMin, a.xMax, a.yMax]; }; <> <<>> <<-------File and Control operations-------->> InputFile: PUBLIC PROC [args: UInputRec.InputFile, data: SilData, viewer: ViewerClasses.Viewer, ctx: Imager.Context] = { <<[];>> <> <<>> dData: SilDisplayData _ data.displayData; SilDisplayCursors.DisableRopeInput[data, ctx]; dData.relativeInput _ args.mode=relative; SilDisplayUtils.GuessFileName[data, input]; }; StoreFile: PUBLIC PROC [args: UInputRec.StoreFile, data: SilData, viewer: ViewerClasses.Viewer, ctx: Imager.Context] = { <<[clip: BOOL _ TRUE, large: BOOL _ FALSE];>> <

> <<>> dData: SilDisplayData _ data.displayData; SilDisplayCursors.DisableRopeInput[data, ctx]; dData.clipOutputFile _ args.clip; dData.largeFormat _ args.large; SilDisplayUtils.GuessFileName[data, output]; }; <<>> KillPicture: PUBLIC PROC [args: UInputRec.KillPicture, data: SilData, viewer: ViewerClasses.Viewer, ctx: Imager.Context] = { <<[];>> <> dData: SilDisplayData _ data.displayData; lViewer: ViewerClasses.Viewer _ SilUserInput.GetBiScroller[data.uiData].QuaViewer[].parent; SilDisplayCursors.DisableRopeInput[data, ctx]; IF NOT dData.edited THEN SilDisplayUtils.KillConfirmedFile[data, ctx, lViewer] ELSE { dData.mode _ WaitingForKillConfirmation; SilUserInput.InputingRope[data.uiData]; MessageWindow.Append["File has been edited, ", TRUE]; MessageWindow.Append["confirm with CR, ESC or any click, ", FALSE]; MessageWindow.Append["abort with DEL.", FALSE]; MessageWindow.Blink[]; }; }; <<>> SwapFonts: PUBLIC PROC [args: UInputRec.SwapFonts, data: SilData, viewer: ViewerClasses.Viewer, ctx: Imager.Context] = { <<[];>> SilDisplayUtils.SwapFonts[data: data, ctx: ctx]; --toggles between normal display and "hardcopy" mode }; <<>> HardCopy: PUBLIC PROC [args: UInputRec.HardCopy, data: SilData, viewer: ViewerClasses.Viewer, ctx: Imager.Context] = { <<[char: CHAR];>> <<>> SilDisplayCursors.DisableRopeInput[data, ctx]; SilDisplayUtils.GuessHardFileName[data, args.char]; }; <<>> <<-----Tracking the mouse, and defining the mark, origin and current selection; scrolling to Mark>> TrackMouse: PUBLIC PROC [args: UInputRec.TrackMouse, data: SilData, viewer: ViewerClasses.Viewer, ctx: Imager.Context] = { <<[x: INTEGER _ 0, y: INTEGER _ 0];>> <> <<>> SilDisplayUtils.ChangeCommandLineData[data: data, ctx: ctx, change: Pos, intArg1: args.x, intArg2: args.y]; }; <<>> SetCaret: PUBLIC PROC [args: UInputRec.SetCaret, data: SilData, viewer: ViewerClasses.Viewer, ctx: Imager.Context] = { <<[caret: CaretSet, x: INTEGER _ 0, y: INTEGER _ 0, mode: Relation];>> <, otherwise, change only the y value of the caret, acording to the value of Yinc (ingnore x and y)>> <<>> dData: SilDisplayData _ data.displayData; model: SilModel _ data.model; uiData: SilUIData _ data.uiData; SilDisplayCursors.DisableRopeInput[data, ctx]; SELECT args.caret FROM mark => { SilDisplayCursors.AquireAndDisableTheMark[data, ctx]; SELECT args.mode FROM absolute => { SilDisplayCursors.SetMarkX[args.x]; SilDisplayCursors.SetMarkY[args.y]; }; relative => SilDisplayCursors.SetMarkY[SilDisplayCursors.GetMarkY[] + dData.yInc]; ENDCASE; }; origin => { SilDisplayCursors.AquireAndDisableTheOrigin[data, ctx]; SELECT args.mode FROM absolute => { SilDisplayCursors.SetOriginX[args.x]; SilDisplayCursors.SetOriginY[args.y]; }; relative => SilDisplayCursors.SetOriginY[SilDisplayCursors.GetOriginY[] + dData.yInc]; ENDCASE; }; ENDCASE; SilUserInput.SetCaretChange[uiData]; }; <<>> SetCursor: PUBLIC PROC [args: UInputRec.SetCursor, data: SilData, viewer: ViewerClasses.Viewer, ctx: Imager.Context] = { <<[caret: CaretSet]; Set the cursor bitmap from the screen bitmap near the caret.>> sx, sy: INTEGER; viewerPos: Geom2D.Vec; selection: SilFile.SilSelection; dData: SilDisplayData _ data.displayData; bs: BiScrollers.BiScroller _ SilUserInput.GetBiScroller[data.uiData]; IF (selection _ SilFile.CopySelection[]).numObjects = 0 THEN RETURN; --no selection IF NOT (SilDisplayCursors.MarkAndSelectionInSameWindow[] AND SilDisplayCursors.OriginAndSelectionInSameWindow[]) THEN { MessageWindow.Append["Mark, Origin, and Selection must be in same Window", TRUE]; MessageWindow.Blink[]; RETURN; }; SilDisplayCursors.DisableRopeInput[data, ctx]; SilDisplayCursors.AquireAndDisableTheOrigin[data, ctx]; --get origin out of the bitmap SilDisplayCursors.AquireAndDisableTheMark[data, ctx]; --get mark out of the bitmap SilDisplayUtils.PaintAllSelectedAsDeselected[model: data.model, ctx: ctx]; --rebuild bitmap where origin and selection were <> viewerPos _ bs.style.GetTransforms[bs].clientToViewer.Transform[[ x: (SilDisplayCursors.GetOriginX[] + dData.xOffset) * dData.currentMagnification, y: -(SilDisplayCursors.GetOriginY[] + dData.yOffset) * dData.currentMagnification]]; [sx, sy] _ ViewerOps.UserToScreenCoords[viewer, Real.RoundI[viewerPos.x], Real.RoundI[viewerPos.y]]; SELECT args.caret FROM origin => SilDisplayCursors.BitmapToCursor[x: sx, y: sy, viewer: viewer]; mark => NULL; --not implemented ENDCASE; SilDisplayUtils.MergeRebuild[dData: data.displayData, model: data.model, xMin: selection.xMin, yMin: selection.yMin, xMax: selection.xMax, yMax: selection.yMax, selectedOnly: TRUE]; SilDisplayUtils.SilRebuild[data: data, ctx: ctx]; SilDisplayCursors.SilCursorsBlink[]; --turn origin back on }; SelectWithPos: PUBLIC ENTRY PROC [args: UInputRec.SelectWithPos, data: SilData, viewer: ViewerClasses.Viewer, ctx: Imager.Context] = { <<[x, y: INTEGER, mode: SelectMode _ change];>> <. If there is more than one object at the one we are concerned with is the element at with the smallest perimeter. >> < becomes the only current selection. >> < is added to the previously selected objects. In both cases the origin is moved to the upper left corner of the selected object; if no object exists at the origin is moved to . >> < is deselected; in this case the origin does not change. >> < and the last mark. The origin is moved to the upper left corner of the bounding box containing the selected objects.>> <.>> dData: SilDisplayData _ data.displayData; model: SilModel _ data.model; uiData: SilUIData _ data.uiData; markX: INTEGER _ SilDisplayCursors.GetMarkX[]; markY: INTEGER _ SilDisplayCursors.GetMarkY[]; originX: INTEGER _ SilDisplayCursors.GetOriginX[]; originY: INTEGER _ SilDisplayCursors.GetOriginY[]; SilDisplayCursors.DisableRopeInput[data, ctx]; SilDisplayCursors.CheckSelectionWindow[data]; SELECT args.mode FROM relative => { SilDisplayCursors.AquireAndDisableTheOrigin[data, ctx]; <> SilDisplayUtils.DeselectAndPaintAll[model, ctx]; [originX, originY] _ SilFile.DefineSelectWithBox[model, markX, markY, args.x, args.y]; SilDisplayUtils.MergeRebuild[dData, model, MIN[markX, args.x], MIN[markY, args.y], MAX[markX, args.x], MAX[markY, args.y], TRUE]; SilUserInput.SetCaretChange[uiData]; }; change, add => { sob: SilObject _ ObjectAtPos[model, args.x, args.y]; SilDisplayCursors.AquireAndDisableTheOrigin[data, ctx]; <> IF args.mode = change THEN SilDisplayUtils.DeselectAndPaintAll[model, ctx]; SilFile.DefineSelectWithObject[model, sob]; IF sob # NIL THEN { --Move origin to upper left of selected object SilDisplayUtils.MergeRebuild[dData, model, sob.first.xMin, sob.first.yMin, sob.first.xMax, sob.first.yMax, TRUE]; originX _ sob.first.xMin; originY _ sob.first.yMin; } ELSE { --Move origin to place unsuccessfully selected originX _ args.x; originY _ args.y; }; }; remove => { sob: SilObject _ ObjectAtPos[model, args.x, args.y]; IF sob # NIL THEN { SilFile.Deselect[model, sob]; SilDisplayUtils.MergeRebuild[dData, model, sob.first.xMin, sob.first.yMin, sob.first.xMax, sob.first.yMax, FALSE]; }; }; delete => { sob: SilObject _ ObjectAtPos[model, args.x, args.y]; IF sob # NIL THEN { SilDisplayUtils.PaintObject[model, sob.first, erase, ctx]; SilDisplayCursors.AquireAndDisableTheMark[data, ctx]; markX _ sob.first.xMin; markY _ sob.first.yMin; SilFile.DeleteAndCacheObject[model, sob]; <> SilDisplayUtils.MergeRebuild[dData, model, sob.first.xMin, sob.first.yMin, sob.first.xMax, sob.first.yMax]; SilDisplayUtils.MarkFileAsEdited[data, ctx, viewer]; }; }; ENDCASE; SilDisplayCursors.SetOriginX[originX]; SilDisplayCursors.SetOriginY[originY]; SilDisplayCursors.SetMarkX[markX]; SilDisplayCursors.SetMarkY[markY]; SilUserInput.SetCaretChange[uiData]; SilDisplayUtils.ChangeCommandLineData[data: data, ctx: ctx, change: Selections, intArg1: SilFile.GetSelection[].numObjects]; }; <<>> SelectForAttrib: PUBLIC ENTRY PROC [args: UInputRec.SelectForAttrib, data: SilData, viewer: ViewerClasses.Viewer, ctx: Imager.Context] = { <<[mode: SelectMode, char: CHAR];>> <> <<>> rebuildArea: RebuildAreaRec _ []; dData: SilDisplayData _ data.displayData; model: SilModel _ data.model; uiData: SilUIData _ data.uiData; AR: SilDisplayUtils.AttributeRec _ SilDisplayUtils.AttributeFromChar[args.char]; IF AR.referenced = invalid THEN { MessageWindow.Append["Illegal attribute given.", TRUE]; MessageWindow.Blink; RETURN; } ELSE MessageWindow.Append[Rope.FromChar[args.char], FALSE]; SilDisplayCursors.DisableRopeInput[data, ctx]; SilDisplayCursors.CheckSelectionWindow[data]; IF args.mode = change THEN { --Select the guys that pass inspection SilDisplayUtils.DeselectAndPaintAll[model, ctx]; FOR s: SilObject _ GetObjectList[model, fgnd], s.rest WHILE s # NIL DO IF SilDisplayUtils.AttributeFilter[AR, s.first] THEN { SilFile.DefineSelectWithObject[model, s]; rebuildArea _ UpdateRebuildArea[s.first, rebuildArea]; }; ENDLOOP; } ELSE { --Remove the guys that dont pass inspection s: SilObject _ SilFile.GetSelection[].objects; nextS: SilObject _ s; WHILE s # NIL DO nextS _ s.first.selectObj; IF NOT SilDisplayUtils.AttributeFilter[AR, s.first] THEN { SilFile.Deselect[model, s]; rebuildArea _ UpdateRebuildArea[s.first, rebuildArea]; }; s _ nextS; ENDLOOP; }; MergeRebuildArea[dData, model, rebuildArea]; -- rebuild area ONLY ONCE SilDisplayUtils.ChangeCommandLineData[data: data, ctx: ctx, change: Selections, intArg1: SilFile.GetSelection[].numObjects]; }; CenterOnMark: PUBLIC PROC [args: UInputRec.CenterOnMark, data: SilData, viewer: ViewerClasses.Viewer, ctx: Imager.Context] = { <> <<>> ClientToSilXForm: PROC [] RETURNS [xform: Geom2D.Transform] = { <> <> <> <<>> xform _ Geom2D.id.PostScale2[[1.0, -1.0]].PostScale[IF dData.magnificationOn AND dData.currentMagnification#1 THEN 1.0/dData.currentMagnification ELSE 1.0].PostTranslate[[-dData.xOffset, -dData.yOffset]]; }; SilToClientCoords: PROC [silCoordX, silCoordY: REAL] RETURNS [clientCoordX, clientCoordY: REAL] = { <> <> <> point: Imager.VEC _ [silCoordX, silCoordY]; point.x _ point.x + dData.xOffset; point.y _ point.y + dData.yOffset; IF dData.magnificationOn AND dData.currentMagnification#1 THEN { point.x _ point.x * dData.currentMagnification; point.y _ point.y * dData.currentMagnification; }; RETURN[point.x, -point.y]; --note inversion of y coord }; bxMin, byMin, bxMax, byMax: INTEGER; -- for bounding box of context rMarkX, rMarkY: REAL; area: Geom2D.Rect; dData: SilDisplayData _ data.displayData; -- used by local procs above [rMarkX, rMarkY] _ SilToClientCoords[SilDisplayCursors.GetMarkX[], SilDisplayCursors.GetMarkY[]]; --BiScrollers wants Client coords [bxMin, byMin, bxMax, byMax] _ SilDisplayUtils.BoundingBoxOfContext[ctx]; Imager.SetColor[ctx, Imager.white]; --clear the viewer Imager.MaskRectangleI[ctx, bxMin, byMin, bxMax - bxMin, byMax - byMin]; BiScrollers.Align[bs: SilUserInput.GetBiScroller[data.uiData], client: [coord[x: rMarkX, y: rMarkY]], viewer: [fraction[fx: 0.5, fy: 0.5]], paint: FALSE]; --center the viewer on the Mark BiScrollers.Scale[bs: SilUserInput.GetBiScroller[data.uiData], op: [reset[]], paint: FALSE]; --and reset the Scale to 1:1. Note: paint_FALSE is CRITICAL !! area _ BiScrollers.ViewportBox[bs: SilUserInput.GetBiScroller[data.uiData]]; --find area needing rebuilding area _ ClientToSilXForm[].TransformRectangle[area]; --and convert to Sil coordinates SilDisplayUtils.MergeRebuild[dData, data.model, Real.RoundI[area.x], Real.RoundI[area.y], Real.RoundI[area.x+area.w], Real.RoundI[area.y+area.h], FALSE]; }; <<>> <<-----Manipulation of the current selection-------->> OperateOnSelected: PUBLIC ENTRY PROC [args: UInputRec.OperateOnSelected, data: SilData, viewer: ViewerClasses.Viewer, ctx: Imager.Context] = { <<[op: OperationMode, rel: Relation _ relative, x: INTEGER _ 0, y: INTEGER _ 0];>> < to copy, move, or delete the selected objects.>> < and delete all selected objects.>> <. If rel is relative copy them such that the origin is at the mark and ignore .>> <. If rel is relative move them such that the origin is at the mark and ignore As a feature, if the selected objects are thought of as defining a rectangular window, and if they are moved ONLY in X or in Y, the endpoints of any boxes which cross the window boundary are moved (by shortening or lengthening the box) so that the endpoints have the same relation to the selected objects as in the original view. If the box would be shortened to a non-posotive length, or if it is fully in the window but not selected, it is not modified.>> <> <<>> dData: SilDisplayData _ data.displayData; model: SilModel _ data.model; uiData: SilUIData _ data.uiData; sSel: SilSelection; SilDisplayCursors.DisableRopeInput[data, ctx]; SELECT args.op FROM delete => { sSel _ SilFile.GetSelection[]; SilDisplayCursors.AquireAndDisableTheMark[data, ctx]; SilDisplayCursors.SetMarkX[sSel.xMin]; SilDisplayCursors.SetMarkY[sSel.yMin]; SilDisplayCursors.DeleteAndEraseSelection[data: data, ctx: ctx, cache: TRUE]; SilUserInput.SetCaretChange[uiData]; }; copy, moveStretch, moveNoStretch => { xOffset, yOffset: INTEGER; xMin, yMin, xMax, yMax: INTEGER; IF NOT SilDisplayCursors.OriginAndSelectionInSameWindow[] THEN { MessageWindow.Append["Origin and Selection must be in same window", TRUE]; MessageWindow.Blink; RETURN; }; SELECT args.rel FROM relative => { xOffset _ SilDisplayCursors.GetMarkX[] - SilDisplayCursors.GetOriginX[]; yOffset _ SilDisplayCursors.GetMarkY[] - SilDisplayCursors.GetOriginY[]; }; absolute => { xOffset _ args.x - SilDisplayCursors.GetOriginX[]; yOffset _ args.y - SilDisplayCursors.GetOriginY[]; }; ENDCASE; <<>> sSel _ SilFile.CopySelection[]; xMin _ sSel.xMin; yMin _ sSel.yMin; xMax _ sSel.xMax; yMax _ sSel.yMax; IF NOT CheckSelectionsForMacroDefs[model] THEN { MessageWindow.Append["Selection contains macros undefined in destination window", TRUE]; MessageWindow.Blink; RETURN; }; IF args.op = copy THEN { SilDisplayCursors.DeselectAndRedraw[]; IF args.rel = absolute THEN { SilDisplayCursors.AquireAndDisableTheOrigin[data: data, ctx: ctx]; SilDisplayCursors.SetOriginX[args.x]; SilDisplayCursors.SetOriginY[args.y]; SilUserInput.SetCaretChange[uiData: uiData] } ELSE SilDisplayCursors.MoveOriginToMark[data, ctx]; } ELSE { -- move (not copy) SilDisplayCursors.DeleteAndEraseSelection[data: data, ctx: ctx, cache: FALSE]; SilDisplayCursors.InterchangeMarkAndOrigin[data, ctx]; IF args.rel = absolute THEN { SilDisplayCursors.AquireAndDisableTheOrigin[data: data, ctx: ctx]; SilDisplayCursors.SetOriginX[args.x]; SilDisplayCursors.SetOriginY[args.y]; SilUserInput.SetCaretChange[uiData: uiData] }; }; SilDisplayCursors.InitiateNewSelection[data]; FOR s: SilObject _ sSel.objects, s.rest WHILE s # sSel.lastObject DO sobr: SilObjectRec _ s.first; sobr.xMin _ sobr.xMin + xOffset; sobr.yMin _ sobr.yMin + yOffset; sobr.xMax _ sobr.xMax + xOffset; sobr.yMax _ sobr.yMax + yOffset; SilFile.DefineSelectWithObject[model, SilFile.AddObjectToMainPicture[model, sobr] ]; SilDisplayUtils.PaintObject[model, sobr, select, ctx]; ENDLOOP; IF args.op = moveStretch AND (xOffset # 0 OR yOffset # 0) AND (xOffset = 0 OR yOffset = 0) THEN { offsetDirection: SilDisplayUtils.Orientation _ IF xOffset = 0 THEN vertical ELSE horizontal; offset: INTEGER _ IF xOffset = 0 THEN yOffset ELSE xOffset; FOR s: SilObject _ GetObjectList[model, fgnd], s.rest WHILE s # NIL DO IF NOT ObjectIsSelected[model, s] THEN { bEnd: SilDisplayUtils.BoxEnd; passed: BOOL; [passed, bEnd] _ SilDisplayUtils.OffsetFilter[s.first, offsetDirection, offset, xMin, yMin, xMax, yMax]; IF passed THEN { SilDisplayUtils.PaintObject[model, s.first, erase, ctx]; SilDisplayUtils.StretchBox[s, offsetDirection, bEnd, offset]; SilDisplayUtils.PaintObject[model, s.first, show, ctx]; }; }; ENDLOOP; FOR s: SilObject _ GetObjectList[model, bkgnd], s.rest WHILE s # NIL DO IF NOT ObjectIsSelected[model, s] THEN { bEnd: SilDisplayUtils.BoxEnd; passed: BOOL; [passed, bEnd] _ SilDisplayUtils.OffsetFilter[s.first, offsetDirection, offset, xMin, yMin, xMax, yMax]; IF passed THEN { SilDisplayUtils.PaintObject[model, s.first, erase, ctx]; SilDisplayUtils.StretchBox[s, offsetDirection, bEnd, offset]; SilDisplayUtils.PaintObject[model, s.first, show, ctx]; }; }; ENDLOOP; IF offsetDirection = vertical THEN SilDisplayUtils.MergeRebuild[dData, model, xMin, MIN[yMin, yMin + yOffset], xMax, MIN[yMax, yMax + yOffset], FALSE] ELSE SilDisplayUtils.MergeRebuild[dData, model, MIN[xMin, xMin + xOffset], yMin, MIN[xMax, xMax + xOffset], yMax, FALSE] }; SilDisplayUtils.MarkFileAsEdited[data, ctx, viewer]; }; ENDCASE; SilDisplayUtils.ChangeCommandLineData[data: data, ctx: ctx, change: Selections, intArg1: SilFile.GetSelection[].numObjects]; }; ChangeSelected: PUBLIC ENTRY PROC [args: UInputRec.ChangeSelected, data: SilData, viewer: ViewerClasses.Viewer, ctx: Imager.Context] = { <<[char: CHAR];>> <> <<>> rebuildArea: RebuildAreaRec _ []; dData: SilDisplayData _ data.displayData; model: SilModel _ data.model; uiData: SilUIData _ data.uiData; AR: SilDisplayUtils.AttributeRec _ SilDisplayUtils.AttributeFromChar[args.char]; IF AR.referenced = invalid THEN { MessageWindow.Append["Illegal attribute given.", TRUE]; MessageWindow.Blink; RETURN; } ELSE MessageWindow.Append[Rope.FromChar[args.char], FALSE]; SilDisplayCursors.DisableRopeInput[data, ctx]; FOR s: SilObject _ SilFile.GetSelection[].objects, s.first.selectObj WHILE s # NIL DO SELECT AR.referenced FROM color => { SilDisplayUtils.PaintObject[model, s.first, erase, ctx]; s.first.color _ AR.color; rebuildArea _ UpdateRebuildArea[s.first, rebuildArea]; }; font => IF s.first.font IN SilFile.InternalPresetFonts AND AR.font IN SilFile.PresetFonts THEN { xMin, yMin, xMax, yMax: INTEGER; SilDisplayUtils.PaintObject[model, s.first, erase, ctx]; s.first.font _ IF SilFile.FontIsBold[s.first.font] THEN SilFile.InternalFontFromUserFont[AR.font, TRUE] ELSE SilFile.InternalFontFromUserFont[AR.font, FALSE]; [xMin, yMin, xMax, yMax] _ SilDisplayUtils.BoundingBoxOfObject[model, s.first]; s.first.xMax _ s.first.xMin + xMax; s.first.yMax _ s.first.yMin + yMax; <> <> rebuildArea _ UpdateRebuildArea[s.first, rebuildArea]; }; face => IF s.first.font IN SilFile.InternalPresetFonts THEN { xMin, yMin, xMax, yMax: INTEGER; SilDisplayUtils.PaintObject[model, s.first, erase, ctx]; SELECT AR.face FROM italic => s.first.italic _ TRUE; nonItalic => s.first.italic _ FALSE; bold => s.first.font _ SilFile.InternalFontFromUserFont[SilFile.UserFontFromInternalFont[s.first.font].font, TRUE]; nonBold => s.first.font _ SilFile.InternalFontFromUserFont[SilFile.UserFontFromInternalFont[s.first.font].font, FALSE]; ENDCASE; [xMin, yMin, xMax, yMax] _ SilDisplayUtils.BoundingBoxOfObject[model, s.first]; s.first.xMax _ s.first.xMin + xMax; s.first.yMax _ s.first.yMin + yMax; <> <> rebuildArea _ UpdateRebuildArea[s.first, rebuildArea]; }; ENDCASE; ENDLOOP; MergeRebuildArea[dData, model, rebuildArea]; -- rebuild area ONLY ONCE SilDisplayUtils.MarkFileAsEdited[data, ctx, viewer]; }; <<-----Set Sil parameters-------->> SetDefaultAttribs: PUBLIC PROC [args: UInputRec.SetDefaultAttribs, data: SilData, viewer: ViewerClasses.Viewer, ctx: Imager.Context] = { <<[char: CHAR];>> <> <<>> dData: SilDisplayData _ data.displayData; AR: SilDisplayUtils.AttributeRec _ SilDisplayUtils.AttributeFromChar[args.char]; IF AR.referenced = invalid THEN { MessageWindow.Append["Illegal attribute given.", TRUE]; MessageWindow.Blink; RETURN; } ELSE MessageWindow.Append[Rope.FromChar[args.char], FALSE]; SilDisplayCursors.DisableRopeInput[data, ctx]; SELECT AR.referenced FROM color => SilDisplayUtils.ChangeCommandLineData[data: data, ctx: ctx, change: Color, intArg1: AR.color]; font => SilDisplayUtils.ChangeCommandLineData[data: data, ctx: ctx, change: Font, intArg1: AR.font]; face => SELECT AR.face FROM italic =>SilDisplayUtils.ChangeCommandLineData[data: data, ctx: ctx, change: Italic, boolArg: TRUE]; nonItalic => SilDisplayUtils.ChangeCommandLineData[data: data, ctx: ctx, change: Italic, boolArg: FALSE]; bold => SilDisplayUtils.ChangeCommandLineData[data: data, ctx: ctx, change: Bold, boolArg: TRUE]; nonBold => SilDisplayUtils.ChangeCommandLineData[data: data, ctx: ctx, change: Bold, boolArg: FALSE]; ENDCASE; ENDCASE; IF dData.currentFont IN SilFile.PresetFonts THEN { dData.currentFontRef _ SilDisplayUtils.GetFont[ SilFile.InternalFontFromUserFont[dData.currentFont, dData.currentBoldState], dData.currentItalicState]; }; }; SetDetails: PUBLIC PROC [args: UInputRec.SetDetails, data: SilData, viewer: ViewerClasses.Viewer, ctx: Imager.Context] = { <<[detail: Details, char: CHAR];>> <> <> <> dData: SilDisplayData _ data.displayData; SilDisplayCursors.DisableRopeInput[data, ctx]; SELECT args.detail FROM boxWidth => IF args.char - '0 > 9 OR args.char - '0 < 1 THEN { MessageWindow.Append["Illegal line width given.", TRUE]; MessageWindow.Blink[]; } ELSE { MessageWindow.Append[Rope.FromChar[args.char], FALSE]; SilDisplayUtils.ChangeCommandLineData[data: data, ctx: ctx, change: LineWidth, intArg1: args.char - '0]; }; gridSize => IF args.char - '0 > 9 OR args.char - '0 < 0 THEN { MessageWindow.Append["Illegal grid spacing given.", TRUE]; MessageWindow.Blink[]; } ELSE { grid: NAT _ 1; MessageWindow.Append[Rope.FromChar[args.char], FALSE]; FOR i: NAT IN [1..args.char - '0] DO grid _ grid * 2; ENDLOOP; IF grid > 64 THEN grid _ 64; SilDisplayUtils.ChangeCommandLineData[data: data, ctx: ctx, change: Grid, intArg1: grid]; SilUserInput.ChangeGridInterval[data.uiData, grid]; }; ENDCASE; }; <<-----Manipulate Macros-------->> ManipulateMacro: PUBLIC ENTRY PROC [args: UInputRec.ManipulateMacro, data: SilData, viewer: ViewerClasses.Viewer, ctx: Imager.Context] = { <<[mode: MacroMode, char: CHAR];>> <> <> <> <<>> dData: SilDisplayData _ data.displayData; model: SilModel _ data.model; uiData: SilUIData _ data.uiData; SilDisplayCursors.DisableRopeInput[data, ctx]; SELECT args.mode FROM expand => { markX: INTEGER _ SilDisplayCursors.GetMarkX[]; markY: INTEGER _ SilDisplayCursors.GetMarkY[]; IF NOT SilDisplayCursors.MouseAndMarkInSameWindow[data] THEN { MessageWindow.Append["Input Focus must be in same window as mark", TRUE]; MessageWindow.Blink; RETURN; }; IF NOT args.char IN SilFile.MacroName THEN { MessageWindow.Append["Illegal Macro Name: ", TRUE]; MessageWindow.Append[Rope.FromChar[args.char], FALSE]; MessageWindow.Blink; RETURN; }; MessageWindow.Append[Rope.FromChar[args.char], FALSE]; SilDisplayCursors.CheckSelectionWindow[data]; SilDisplayUtils.DeselectAndPaintAll[model, ctx]; SilDisplayUtils.ExpandMacro[model, args.char, markX, markY, dData.currentOneLevel, ctx]; }; define => IF CheckSelectionsForMacroDefs[model: data.model, disallowName: TRUE, name: args.char] AND args.char IN SilFile.MacroName THEN IF SilFile.GetObjectList[model: model, mode: macro, c: args.char] = NIL THEN { SilDisplayUtils.DefineConfirmedMacro[data, args.char, ctx]; MessageWindow.Append[Rope.FromChar[args.char], FALSE]; } ELSE { dData.mode _ WaitingForMacroDefConfirmation; SilUserInput.InputingRope[data.uiData]; dData.macroDefName _ args.char; MessageWindow.Append["Macro def for ", TRUE]; MessageWindow.Append[Rope.FromChar[args.char], FALSE]; MessageWindow.Append[" already exists. ", FALSE]; MessageWindow.Append["confirm with carriage return for overwrite.", FALSE]; MessageWindow.Blink; } ELSE { MessageWindow.Append["Illegal Macro definition", TRUE]; MessageWindow.Blink; }; clear => { dData.mode _ WaitingForMacroDeleteConfirmation; SilUserInput.InputingRope[data.uiData]; MessageWindow.Append["Confirm deletion of all macros ", TRUE]; MessageWindow.Append["with CR, ESC, or any click ", FALSE]; MessageWindow.Append["abort with DEL.", FALSE]; MessageWindow.Blink[]; }; ENDCASE; SilDisplayUtils.MarkFileAsEdited[data, ctx, viewer]; SilDisplayUtils.ChangeCommandLineData[data: data, ctx: ctx, change: Selections, intArg1: SilFile.GetSelection[].numObjects]; }; <<-----Draw, Delete, and Show procedures-------->> <<>> DrawBox: PUBLIC ENTRY PROC [args: UInputRec.DrawBox, data: SilData, viewer: ViewerClasses.Viewer, ctx: Imager.Context] = { <<[markRel: Relation _ absolute, originRel: Relation _ absolute, x: INTEGER _ 0, y: INTEGER _ 0, background: BOOL _ FALSE];>> <> <> <> < and the mark are the defining points. Move the mark to the end of the box nearest .>> <> <<>> Finite: PROC [sobr: SilObjectRec] RETURNS [BOOL] ~ { RETURN[(sobr.xMin#sobr.xMax) AND (sobr.yMin#sobr.yMax)]; }; dData: SilDisplayData _ data.displayData; model: SilModel _ data.model; uiData: SilUIData _ data.uiData; sobr: SilObjectRec; foregroundBoxFont: INTEGER = SilFile.foregroundBoxFont; backgroundBoxFont: INTEGER = SilFile.backgroundBoxFont; markX: INTEGER _ SilDisplayCursors.GetMarkX[]; markY: INTEGER _ SilDisplayCursors.GetMarkY[]; originX: INTEGER _ SilDisplayCursors.GetOriginX[]; originY: INTEGER _ SilDisplayCursors.GetOriginY[]; SilDisplayCursors.DisableRopeInput[data, ctx]; SilDisplayCursors.CheckSelectionWindow[data]; IF NOT SilDisplayCursors.MouseAndMarkInSameWindow[data] THEN { MessageWindow.Append["Can't draw lines across viewer boundaries", TRUE]; MessageWindow.Blink; RETURN; }; IF args.originRel=absolute AND NOT SilDisplayCursors.MarkAndOriginInSameWindow[] THEN { MessageWindow.Append["Can't draw boxes across viewer boundaries", TRUE]; MessageWindow.Blink; RETURN; }; <> SilDisplayCursors.AquireAndDisableTheMark[data, ctx]; SilDisplayCursors.AquireAndDisableTheOrigin[data, ctx]; SilDisplayUtils.DeselectAndPaintAll[model, ctx]; sobr.color _ dData.currentColor; sobr.font _ IF args.background THEN backgroundBoxFont ELSE foregroundBoxFont; sobr.italic _ FALSE; SELECT args.originRel FROM relative => { --Draw simple box IF ABS[markX - args.x] < ABS[markY - args.y] THEN { <> sobr.xMin _ markX; sobr.yMin _ MIN[markY, args.y]; sobr.xMax _ sobr.xMin + dData.currentBoxWidth; sobr.yMax _ MAX[markY, args.y]; markY _ args.y; sobr _ SilDisplayUtils.FixBoxConnectivity[dData, sobr, vertical]; } ELSE { <> sobr.xMin _ MIN[markX, args.x]; sobr.yMin _ markY; sobr.xMax _ MAX[markX, args.x]; sobr.yMax _ markY + dData.currentBoxWidth; markX _ args.x; sobr _ SilDisplayUtils.FixBoxConnectivity[dData, sobr, horizontal]; }; IF Finite[sobr] THEN SilFile.DefineSelectWithObject[model, SilFile.AddObjectToMainPicture[model, sobr]]; }; absolute => { --The box will use mark AND origin for control xMin, yMin, xMax, yMax: INTEGER; xMin _ sobr.xMin _ MIN[markX, originX]; yMin _ sobr.yMin _ MIN[markY, originY]; xMax _ sobr.xMax _ MAX[markX, originX]; yMax _ sobr.yMax _ MAX[markY, originY]; IF args.background THEN { --The box will be one large one in background IF Finite[sobr] THEN SilFile.DefineSelectWithObject[model, SilFile.AddObjectToMainPicture[model, sobr]]; } ELSE { --There will be 4 boxes: 2 vertical, 2 horizontal sobr.yMax _ yMin + dData.currentBoxWidth; --box 1 IF Finite[sobr] THEN SilFile.DefineSelectWithObject[model, SilFile.AddObjectToMainPicture[model, sobr]]; sobr.xMax _ xMin+ dData.currentBoxWidth; --box 2 sobr.yMax _ yMax; IF Finite[sobr] THEN SilFile.DefineSelectWithObject[model, SilFile.AddObjectToMainPicture[model, sobr]]; sobr.xMin _ xMax; --box 3 sobr.xMax _ xMax + dData.currentBoxWidth; IF Finite[sobr] THEN SilFile.DefineSelectWithObject[model, SilFile.AddObjectToMainPicture[model, sobr]]; sobr.xMin _ xMin; --box 4 sobr.yMin _ yMax; sobr.xMax _ xMax + dData.currentBoxWidth; sobr.yMax _ yMax + dData.currentBoxWidth; IF Finite[sobr] THEN SilFile.DefineSelectWithObject[model, SilFile.AddObjectToMainPicture[model, sobr]]; <> sobr.xMin _ xMin; sobr.yMin _ yMin; sobr.xMax _ xMax; sobr.yMax _ yMax; }; dData.lastBoxLeftToRight _ FALSE; dData.lastBoxTopToBottom _ FALSE; }; ENDCASE; <> FOR s: SilObject _ SilFile.GetSelection[].objects, s.first.selectObj WHILE s # NIL DO SilDisplayUtils.PaintObject[model, s.first, select, ctx]; --shortcut MergeRebuild ENDLOOP; <> SilDisplayCursors.SetOriginX[sobr.xMin]; SilDisplayCursors.SetOriginY[sobr.yMin]; SilDisplayCursors.SetMarkX[markX]; SilDisplayCursors.SetMarkY[markY]; SilUserInput.SetCaretChange[uiData]; IF NOT dData.yLock THEN { n: INTEGER _ (sobr.yMax - sobr.yMin) / dData.currentGridSpacing; m: INTEGER _ (sobr.yMax - sobr.yMin) MOD dData.currentGridSpacing; IF m # 0 THEN n _ n + 1; dData.yInc _ n * dData.currentGridSpacing; }; SilDisplayUtils.ChangeCommandLineData[data: data, ctx: ctx, change: Selections, intArg1: SilFile.GetSelection[].numObjects]; SilDisplayUtils.MarkFileAsEdited[data, ctx, viewer]; }; <<>> HandleInputChars: PUBLIC ENTRY PROC [args: UInputRec.UserChar, data: SilData, viewer: ViewerClasses.Viewer, ctx: Imager.Context] = { <<[c: Char];>> <> <<>> AbortInput: PROC [data: SilData] = { <> <<>> dData: SilDisplayData _ data.displayData; model: SilModel _ data.model; uiData: SilUIData _ data.uiData; SELECT dData.mode FROM InputingRope => SilDisplayCursors.DisableRopeInput[data, ctx]; EditingExistingRope => { SilDisplayUtils.PaintObject[model, dData.collectingObject, erase, ctx]; dData.collectingObject.value _ dData.oldText; SilFile.DefineSelectWithObject[model, SilFile.AddObjectToMainPicture[model, dData.collectingObject]]; SilDisplayUtils.PaintObject[model, dData.collectingObject, select, ctx]; SilDisplayCursors.InitiateNewSelection[data: data]; --notify SilDisplayCursorsImpl of reselection old rope SilUserInput.NotInputingRope[uiData]; SilDisplayUtils.ChangeCommandLineData[data: data, ctx: ctx, change: Selections, intArg1: SilFile.GetSelection[].numObjects]; }; InputingInputFileName, EditingExistingInputFileName, InputingOutputFileName, EditingExistingOutputFileName, InputingHardFileName, EditingExistingHardFileName => { MessageWindow.Append["", TRUE]; dData.collectingFileName.length _ 0; dData.mode _ WaitingToInputRope; SilUserInput.NotInputingRope[uiData]; }; WaitingForKillConfirmation, WaitingForMacroDefConfirmation, WaitingForMacroDeleteConfirmation => { dData.mode _ WaitingToInputRope; SilUserInput.NotInputingRope[uiData]; MessageWindow.Append["", TRUE]; }; ENDCASE; }; FinishInput: PROC [data: SilData] = { <> <<>> dData: SilDisplayData _ data.displayData; model: SilModel _ data.model; uiData: SilUIData _ data.uiData; lViewer: ViewerClasses.Viewer _ SilUserInput.GetBiScroller[uiData].QuaViewer[].parent; <> SELECT dData.mode FROM InputingInputFileName, EditingExistingInputFileName, InputingOutputFileName, EditingExistingOutputFileName, InputingHardFileName, EditingExistingHardFileName => IF dData.collectingFileName.length > 0 THEN { tName: ROPE _ Rope.FromRefText[dData.collectingFileName]; SELECT dData.mode FROM InputingInputFileName, EditingExistingInputFileName => SilDisplayUtils.InputNamedFile[data, tName, ctx]; InputingOutputFileName, EditingExistingOutputFileName => { ViewerOps.SaveViewer[viewer ! SilKernel.SilError => GOTO Done;]; --save inner viewer lViewer.newVersion _ lViewer.newFile _ FALSE; --Abutter lViewer.child.newVersion _ lViewer.child.newFile _ FALSE; --ViewRec viewer lViewer.child.sibling.newVersion _ lViewer.child.sibling.newFile _ FALSE; --BiScroller lViewer.icon _ SilDisplay.GetIcon[dirtyIcon: FALSE]; EXITS Done => NULL; }; InputingHardFileName, EditingExistingHardFileName => TRUSTED { Process.Detach[FORK SilDisplayUtils.HardcopyFile[data, tName]];}; ENDCASE; dData.collectingFileName.length _ 0; dData.mode _ WaitingToInputRope; SilUserInput.NotInputingRope[uiData]; IF NOT Rope.Equal[(tName _ SilFile.GetActiveFileName[data.model]), ""] THEN lViewer.name _ tName; MessageWindow.Append[Rope.Cat["File: ", tName, " completed"], TRUE]; ViewerOps.PaintViewer[lViewer, caption]; } ELSE MessageWindow.Append["", TRUE]; InputingRope, EditingExistingRope => IF dData.collectingText.length > 0 THEN { mxMin, myMin, mxMax, myMax: INTEGER; SilDisplayCursors.CheckSelectionWindow[data]; dData.collectingObject.value _ Rope.FromRefText[dData.collectingText]; [mxMin, myMin, mxMax, myMax] _ SilDisplayUtils.BoundingBoxOfObject[model, dData.collectingObject]; dData.collectingObject.xMax _ dData.collectingObject.xMin + mxMax - mxMin; dData.collectingObject.yMax _ dData.collectingObject.yMin + myMax - myMin; IF mxMax#0 AND myMax#0 THEN { --this is not an "empty" object SilDisplayUtils.DeselectAndPaintAll[model, ctx]; SilFile.DefineSelectWithObject[model, SilFile.AddObjectToMainPicture[model, dData.collectingObject]]; SilDisplayUtils.PaintObject[model, dData.collectingObject, select, ctx]; SilDisplayUtils.ChangeCommandLineData[data: data, ctx: ctx, change: Selections, intArg1: SilFile.GetSelection[].numObjects]; }; IF NOT dData.yLock THEN { n: INTEGER _ (dData.collectingObject.yMax - dData.collectingObject.yMin) / dData.currentGridSpacing; m: INTEGER _ (dData.collectingObject.yMax - dData.collectingObject.yMin) MOD dData.currentGridSpacing; IF m # 0 THEN n _ n + 1; dData.yInc _ n * dData.currentGridSpacing; }; SilDisplayCursors.AquireAndDisableTheMark[data, ctx]; SilDisplayCursors.AquireAndDisableTheOrigin[data, ctx]; SilDisplayCursors.SetMarkY[dData.collectingObject.yMin + dData.yInc]; SilDisplayCursors.SetMarkX[dData.collectingObject.xMin]; SilDisplayCursors.SetOriginX[dData.collectingObject.xMin]; SilDisplayCursors.SetOriginY[dData.collectingObject.yMin]; dData.collectingText.length _ 0; dData.mode _ WaitingToInputRope; SilUserInput.NotInputingRope[uiData]; SilDisplayUtils.MarkFileAsEdited[data, ctx, lViewer]; }; WaitingForKillConfirmation => { SilDisplayUtils.KillConfirmedFile[data, ctx, lViewer]; dData.mode _ WaitingToInputRope; SilUserInput.NotInputingRope[uiData]; MessageWindow.Append["", TRUE]; }; WaitingForMacroDefConfirmation => { -- assert: don't have to scan bkgnd list here FOR s: SilObject _ GetObjectList[model, fgnd], s.rest WHILE s # NIL DO IF s.first.font = InternalFileMacroFont AND Rope.Fetch[s.first.value] = dData.macroDefName THEN SilDisplayUtils.PaintObject[model, s.first, erase, ctx]; ENDLOOP; SilDisplayUtils.DefineConfirmedMacro[data, dData.macroDefName, ctx]; dData.mode _ WaitingToInputRope; SilUserInput.NotInputingRope[uiData]; MessageWindow.Append["", TRUE]; }; WaitingForMacroDeleteConfirmation => { SilDisplayUtils.ClearConfirmedMacroDefs[data, ctx]; dData.mode _ WaitingToInputRope; SilUserInput.NotInputingRope[uiData]; MessageWindow.Append["", TRUE]; }; ENDCASE; }; finished: BOOL; aborted: BOOL; backedUp: BOOL; dData: SilDisplayData _ data.displayData; model: SilModel _ data.model; uiData: SilUIData _ data.uiData; SELECT dData.mode FROM WaitingToInputRope => IF args.c = Ascii.BS THEN { IF NOT SilDisplayCursors.MarkAndSelectionInSameWindow[] THEN { MessageWindow.Append["Mark and Selection must be in same window", TRUE]; MessageWindow.Blink[]; RETURN;} ELSE { sSel: SilSelection _ SilFile.GetSelection[]; <> IF sSel.objects # NIL AND sSel.objects.first.font IN SilFile.InternalRopeFonts AND sSel.objects.first.selectObj = sSel.lastObject THEN { dData.mode _ EditingExistingRope; dData.collectingObject _ sSel.objects.first; dData.oldText _ sSel.objects.first.value; dData.collectingText _ Rope.ToRefText[sSel.objects.first.value]; SilDisplayCursors.DeleteAndEraseSelection[data: data, ctx: ctx, cache: FALSE]; aborted _ finished _ backedUp _ FALSE; SilUserInput.InputingRope[data.uiData]; } ELSE RETURN; }; } ELSE { dData.mode _ InputingRope; SilUserInput.InputingRope[data.uiData]; <> dData.collectingObject.xMin _ SilDisplayCursors.GetMarkX[]; dData.collectingObject.yMin _ SilDisplayCursors.GetMarkY[]; dData.collectingObject.color _ dData.currentColor; dData.collectingObject.font _ SilFile.InternalFontFromUserFont[dData.currentFont, dData.currentBoldState]; dData.collectingObject.italic _ dData.currentItalicState; dData.collectingObject.value _ ""; dData.collectingText.length _ 0; [dData.collectingText, finished, aborted, backedUp] _ SilDisplayUtils.EditText[dData.collectingText, args.c]; }; InputingRope, EditingExistingRope, WaitingForKillConfirmation, WaitingForMacroDefConfirmation, WaitingForMacroDeleteConfirmation => [dData.collectingText, finished, aborted, backedUp] _ SilDisplayUtils.EditText[dData.collectingText, args.c]; InputingInputFileName, EditingExistingInputFileName, InputingOutputFileName, EditingExistingOutputFileName, InputingHardFileName, EditingExistingHardFileName => [dData.collectingFileName, finished, aborted, backedUp] _ SilDisplayUtils.EditText[dData.collectingFileName, args.c]; ENDCASE; SELECT TRUE FROM NOT aborted AND NOT finished => SELECT dData.mode FROM InputingRope, EditingExistingRope => { IF backedUp THEN SilDisplayUtils.PaintObject[model, dData.collectingObject, erase, ctx]; dData.collectingObject.value _ Rope.FromRefText[dData.collectingText]; SilDisplayUtils.PaintObject[model, dData.collectingObject, show, ctx]; }; InputingInputFileName => { MessageWindow.Append["Input file: ", TRUE]; MessageWindow.Append[Rope.FromRefText[dData.collectingFileName], FALSE]; }; EditingExistingInputFileName => { dData.mode _ InputingInputFileName; <> <> <> <<};>> MessageWindow.Append["Input file: ", TRUE]; MessageWindow.Append[Rope.FromRefText[dData.collectingFileName], FALSE]; }; InputingOutputFileName => { MessageWindow.Append["Output", TRUE]; IF dData.largeFormat THEN MessageWindow.Append[" Large Format", FALSE]; MessageWindow.Append[" file: ", FALSE]; MessageWindow.Append[Rope.FromRefText[dData.collectingFileName], FALSE]; }; EditingExistingOutputFileName => { dData.mode _ InputingOutputFileName; <> <> <> <<};>> MessageWindow.Append["Output", TRUE]; IF dData.largeFormat THEN MessageWindow.Append[" Large Format", FALSE]; MessageWindow.Append[" file: ", FALSE]; MessageWindow.Append[Rope.FromRefText[dData.collectingFileName], FALSE]; }; InputingHardFileName => { MessageWindow.Append["Hardcopy file: ", TRUE]; MessageWindow.Append[Rope.FromRefText[dData.collectingFileName], FALSE]; }; EditingExistingHardFileName => { dData.mode _ InputingHardFileName; <> <> <> <<};>> MessageWindow.Append["Hardcopy file: ", TRUE]; MessageWindow.Append[Rope.FromRefText[dData.collectingFileName], FALSE]; }; ENDCASE; aborted => AbortInput[data]; finished => FinishInput[data]; ENDCASE; }; Compliment: PUBLIC PROC [args: UInputRec.Compliment, data: SilData, viewer: ViewerClasses.Viewer, ctx: Imager.Context] = { <<[mode: CompMode];>> <> <> <> <> <> <<>> dData: SilDisplayData _ data.displayData; model: SilModel _ data.model; SilDisplayCursors.DisableRopeInput[data, ctx]; SELECT args.mode FROM tics => { IF dData.ticsOn THEN SilDisplayUtils.DisplayGrid[erase, dData, model, ctx]; dData.ticsOn _ NOT dData.ticsOn; IF dData.ticsOn THEN SilDisplayUtils.DisplayGrid[show, dData, model, ctx]; }; frames => { IF dData.framesOn THEN SilDisplayUtils.DisplayFrames[erase, dData, model, ctx]; dData.framesOn _ NOT dData.framesOn; IF dData.framesOn THEN SilDisplayUtils.DisplayFrames[show, dData, model, ctx]; }; magnification => { xMin, yMin, xMax, yMax: INTEGER; legalBox: BOOL; [legalBox, xMin, yMin, xMax, yMax] _ SilDisplayCursors.GetBoundingBoxOfLast2Marks[data]; IF NOT legalBox THEN RETURN; SilDisplayUtils.MagnifyDrawing[data, ctx, xMin, yMin, xMax, yMax]; }; oneLevel => SilDisplayUtils.ChangeCommandLineData[data: data, ctx: ctx, change: MacExpand, boolArg: NOT dData.currentOneLevel]; yInc => { SilDisplayUtils.ChangeCommandLineData[data: data, ctx: ctx, change: Ylock, boolArg: NOT dData.yLock]; IF dData.yLock THEN { n: INTEGER _ (SilDisplayCursors.GetOriginY[] - SilDisplayCursors.GetMarkY[]) / dData.currentGridSpacing; m: INTEGER _ (SilDisplayCursors.GetOriginY[] - SilDisplayCursors.GetMarkY[]) MOD dData.currentGridSpacing; IF m # 0 THEN n _ n + 1; dData.yInc _ n * dData.currentGridSpacing; }; }; ENDCASE; }; <<>> ShowMacros: PUBLIC PROC [args: UInputRec.ShowMacros, data: SilData, viewer: ViewerClasses.Viewer, ctx: Imager.Context] = { <<[char: CHAR];>> <> model: SilModel _ data.model; font: InternalMacroFonts; fonts: REF TEXT; SilDisplayCursors.DisableRopeInput[data, ctx]; <> SELECT args.char FROM '4, '5, '6, '7, '8, '9 => font _ SilFile.InternalFontFromUserFont[args.char - '0, FALSE]; ENDCASE => {MessageWindow.Append["Illegal Macro Name.", TRUE]; MessageWindow.Blink; RETURN; }; MessageWindow.Append["Font ", TRUE]; MessageWindow.Append[Rope.FromChar[args.char], FALSE]; MessageWindow.Append[": ", FALSE]; fonts _ RefText.New[SilFile.MacroNameSize]; --Maximum number of macro names FOR c: MacroName IN MacroName DO IF SilFile.GetObjectList[model, macro, font, c] # NIL THEN fonts _ RefText.AppendChar[fonts, c]; ENDLOOP; MessageWindow.Append[Rope.FromRefText[fonts], FALSE]; }; <<>> Undelete: PUBLIC ENTRY PROC [args: UInputRec.Undelete, data: SilData, viewer: ViewerClasses.Viewer, ctx: Imager.Context] = { <<[];>> <> <<>> xMin, yMin, xMax, yMax: INTEGER; sob: SilObject; dData: SilDisplayData _ data.displayData; model: SilModel _ data.model; uiData: SilUIData _ data.uiData; SilDisplayCursors.DisableRopeInput[data, ctx]; SilDisplayUtils.PaintAllSelectedAsDeselected[model, ctx]; SilDisplayCursors.CheckSelectionWindow[data]; sob _ SilFile.Undelete[model]; [xMin, yMin, xMax, yMax] _ SilDisplayUtils.BoundingBoxOfContext[ctx]; SilDisplayUtils.MergeRebuild[dData, model, xMin, yMin, xMax, yMax, TRUE]; SilDisplayUtils.MarkFileAsEdited[data, ctx, viewer]; SilDisplayUtils.ChangeCommandLineData[data: data, ctx: ctx, change: Selections, intArg1: SilFile.GetSelection[].numObjects]; }; END. <> <> <> <<>>