DIRECTORY
Buttons,
Carets,
ChoiceButtons,
CGAIS,
Commander,
Containers,
Convert,
Graphics,
GraphicsOps,
IO,
Labels,
LFUtil,
Menus,
MessageWindow,
PieViewers,
PressScreen,
Process,
Real,
Rope,
Rules,
SirPress,
ViewerClasses,
ViewerOps,
ViewerSpecs,
ViewerTools;

PressScreenToolImpl: CEDAR MONITOR
IMPORTS Buttons, ChoiceButtons, Commander, Containers, Convert, Graphics, IO, Labels, LFUtil, Menus, MessageWindow, PieViewers, PressScreen, Process, Real, Rope, Rules, ViewerSpecs, ViewerOps, ViewerTools
EXPORTS PressScreen = {
OPEN PressScreen;

ROPE: TYPE = Rope.ROPE;

PressScreenTool: PUBLIC TYPE = REF PressScreenToolRec;
PressScreenToolRec: PUBLIC TYPE = RECORD[
stateSaved: BOOLEAN _ FALSE,
destroyed: BOOLEAN _ FALSE,
screenAreaChoice: ChoiceButtons.EnumTypeRef,
screenAreaRope: ROPE,
magnificationChoice: ChoiceButtons.EnumTypeRef,
magnificationRope: ROPE,
magnificationViewer: ViewerClasses.Viewer,  -- magnification factor
magnificationFactor: REAL,
ulx, uly, lrx, lry: ViewerClasses.Viewer,  -- upper left, lower right coordinates
ulX, ulY, lrX, lrY: REAL,
formatViewer: ChoiceButtons.EnumTypeRef,
formatRope: ROPE,
borderViewer: ViewerClasses.Viewer,  -- border width
borderWidth: REAL,
pageMarginViewer: ViewerClasses.Viewer,
pageMargin: REAL,
countDownTimerViewer: ViewerClasses.Viewer,
countDownTime: Process.Ticks,
countDownPieViewer: PieViewers.PieViewer,
lockViewersTriState: ChoiceButtons.ThreeStateRef,
lockViewers: BOOLEAN,
displayCursorTriState: ChoiceButtons.ThreeStateRef,
displayCursor: BOOLEAN,
displayCaretsTriState: ChoiceButtons.ThreeStateRef,
displayCarets: BOOLEAN,
logViewer: ViewerClasses.Viewer,
logMessage: ROPE
];

ScreenArea: TYPE = {leftColumn, rightColumn, wholeScreen, desiredArea};
indent: INTEGER ~ 4;
baseline: INTEGER ~ 16;

NewPressScreenTool: PUBLIC PROCEDURE [serverName: ROPE] RETURNS[psTool: PressScreenTool] = {
ENABLE UNWIND => NULL;
viewer: ViewerClasses.Viewer _
ViewerOps.CreateViewer[
flavor: $PressScreen,
info: [
name: IF serverName.Length = 0 THEN "PressScreen" ELSE Rope.Concat["PressScreen to ", serverName],
column: right,
scrollable: FALSE
],
paint: TRUE
];
psTool _ NARROW[ViewerOps.FetchProp[viewer, $PressScreenData]];
};

InitPressScreenViewer: ViewerClasses.InitProc = {
psTool: PressScreenTool _ NEW[PressScreenToolRec];
nextX: INTEGER;
curY: INTEGER _ indent/2;
NextY: PROCEDURE RETURNS [y:NAT] = {y _ curY _ curY+baseline};
button: ViewerClasses.Viewer;
menu: Menus.Menu _ Menus.CreateMenu[];
InsertMenu: PROCEDURE [name: ROPE, proc: Menus.ClickProc, doc: ROPE] = {
Menus.InsertMenuEntry[menu, Menus.CreateEntry[
name: name,
proc: proc,
clientData: psTool,
documentation: doc
]];
};
LabelledTextViewer: PROCEDURE [name: ROPE] RETURNS [v: ViewerClasses.Viewer] = {
v _ ViewerTools.MakeNewTextViewer[
info:[wx: button.wx+button.ww, wy: curY, ww: 50, wh: button.wh,
parent: self, scrollable: FALSE, border: TRUE],
paint: TRUE
];
button _ Labels.Create[
info: [name: name, wx: v.wx + v.ww, wy: curY+1, wh: button.wh, parent: self, scrollable: FALSE, border: FALSE],
paint: TRUE
];
};
MyButton: PROCEDURE [name: ROPE, proc: Buttons.ButtonProc, doc: ROPE] RETURNS [Buttons.Button] = {
RETURN [Buttons.Create[
info: [name: name, wx: indent, wy: NextY[], parent: self, border: FALSE],
clientData: psTool,
proc: proc,
fork: TRUE,
paint: TRUE,
documentation: doc
]]};

triggerName: ROPE _ Rope.Concat["PS", GenSym[]];

ViewerOps.AddProp[self, $PressScreenData, psTool];

containerInitProc[self];  -- since I know its really a $Container, I need to init it for him

[] _ Buttons.Create[info: [name: triggerName], proc: DoItButton, clientData: psTool, documentation: "Convert the identified area of the screen image into an AIS/Press file"];
InsertMenu["SaveState", SaveStateButton,
"Saves the state of the PressScreen tool."];
InsertMenu["GetSelectedViewer", GetSelectedViewerButton,
"Gets the corners of the selected viewer for PressScreening."];
InsertMenu["FlashImage", FlashImageButton,
"Flashes the identified area of the screen image."];
InsertMenu["SetCorners", SetCornersButton,
"Permits designation of a rectangular screen area"];
InsertMenu["DoIt", DoItButton,
"Convert the identified area of the screen image into an AIS/Press file"];
ViewerOps.SetMenu[self, menu];
psTool.screenAreaChoice _ ChoiceButtons.BuildEnumTypeSelection[
viewer: self,
x: indent,
y: curY,
title: "Screen Area:",
buttonNames: CONS["DesiredArea", CONS["WholeScreen", CONS["LeftColumn", CONS["RightColumn", NIL]]]],
default: "WholeScreen",
style: menuSelection];
button _ MyButton["Area Corners: ", AreaCornersButton, "Set the corners of the identified area of the screen"];
psTool.ulx _ LabelledTextViewer["x "]; 
psTool.uly _ LabelledTextViewer["y  "];
psTool.lrx _ LabelledTextViewer["x "];
psTool.lry _ LabelledTextViewer["y"];
psTool.magnificationChoice _ ChoiceButtons.BuildEnumTypeSelection[
viewer: self,
x: indent,
y: NextY[],
title: "Magnification:",
buttonNames: CONS["FullPage", CONS["HalfPage", CONS["UseFactorBelow", NIL]]],
default: "FullPage",
style: menuSelection];
button _ MyButton["MagnificationFactor: ", MagnificationFactorButton, "Set the magnification factor"];
psTool.magnificationViewer _ LabelledTextViewer["%"]; 
psTool.formatViewer _ ChoiceButtons.BuildEnumTypeSelection[
viewer: self,
x: indent,
y: NextY[],
title: "Page Format:",
buttonNames: CONS["Portrait", CONS["Landscape", NIL]],
default: "Portrait",
style: menuSelection];
button _ MyButton["BlackBorder: ", BlackBorderButton, "Set the black border width surrounding the identified image area."];
psTool.borderViewer _ LabelledTextViewer["pixels"];
button _ MyButton["PageMargin: ", PageMarginButton, "Set the white space provided around the page"];
psTool.pageMarginViewer _ LabelledTextViewer["inches"];
button _ MyButton["CountDownTimer: ", CountDownTimerButton, "Set the time before the screen is copied"];
psTool.countDownTimerViewer _ LabelledTextViewer["seconds  "];
psTool.countDownPieViewer _ PieViewers.Create[parent: self, x: button.wx+button.ww, y: curY]; 
button _ Labels.Create[
info: [name: "Viewer Controls: ", wx: indent, wy: NextY[]+1, wh: button.wh, parent: self, scrollable: FALSE, border: FALSE],
paint: TRUE
];
[psTool.lockViewersTriState, nextX] _ ChoiceButtons.BuildTriStateButton[
viewer: self,
x: button.wx+button.ww,
y: curY,
name: "LockViewers"];
[psTool.displayCursorTriState, nextX] _ ChoiceButtons.BuildTriStateButton[
viewer: self,
x: nextX,
y: curY,
name: "DisplayCursor"];
[psTool.displayCaretsTriState, nextX] _ ChoiceButtons.BuildTriStateButton[
viewer: self,
x: nextX,
y: curY,
name: "DisplayCarets"];
Containers.ChildXBound[self, Rules.Create[info: [wx: 0, wy: NextY[], wh: 1, parent: self]]];
psTool.logViewer _ ViewerTools.MakeNewTextViewer[
info: [wx: 0, wy: curY+2, parent: self, scrollable: TRUE, border: FALSE]
];
Containers.ChildXBound[self, psTool.logViewer];
Containers.ChildYBound[self, psTool.logViewer];

AppendLogMessage[psTool, "To set the area corners: left-click SetCorners and cursor changes to cross-hair; left-click-and-hold to set first corner; drag mouse to second corner and release the mouse button."];
AppendLogMessage[psTool, "To use GetSelectedViewer: make a point selection within a viewer or make the selection the name of a viewer and left-click GetSelectedViewer."];
[] _ psTool.logViewer.class.scroll[psTool.logViewer, thumb, 0];

ChoiceButtons.UpdateChoiceButtons[self, psTool.screenAreaChoice, "WholeScreen"];
ChoiceButtons.UpdateChoiceButtons[self, psTool.magnificationChoice, "FullPage"];
ViewerTools.SetContents[psTool.magnificationViewer, IO.PutFR["%g", IO.real[100.0]]];
ViewerTools.SetContents[psTool.ulx, IO.PutFR["%g", IO.int[0]]];
ViewerTools.SetContents[psTool.uly, IO.PutFR["%g", IO.int[807]]];
ViewerTools.SetContents[psTool.lrx, IO.PutFR["%g", IO.int[1023]]];
ViewerTools.SetContents[psTool.lry, IO.PutFR["%g", IO.int[0]]];
ChoiceButtons.UpdateChoiceButtons[self, psTool.formatViewer, "Portrait"];
ViewerTools.SetContents[psTool.borderViewer, IO.PutFR["%g", IO.int[2]]];
ViewerTools.SetContents[psTool.pageMarginViewer, IO.PutFR["%g", IO.real[0.75]]];
ViewerTools.SetContents[psTool.countDownTimerViewer, IO.PutFR["%g", IO.int[0]]];
PieViewers.Set[psTool.countDownPieViewer, 100.0];

ViewerOps.PaintViewer[self, all];
};

DestroyPressScreenViewer: ViewerClasses.DestroyProc = {
psTool: PressScreenTool _ NARROW[ViewerOps.FetchProp[self, $PressScreenData]];
SaveState[psTool];
psTool.destroyed _ TRUE;
IF containerDestroyProc # NIL THEN containerDestroyProc[self];
};
GetSelectedViewerButton: Buttons.ButtonProc = {
psTool: PressScreenTool _ NARROW[clientData];
selectedViewer: ViewerClasses.Viewer _ ViewerTools.GetSelectedViewer[];
sourceName: ROPE _
IF selectedViewer = NIL OR selectedViewer.class.get = NIL THEN NIL
ELSE NARROW[selectedViewer.class.get[selectedViewer, $SelChars]];
IF sourceName.Length <= 1 THEN {
IF (selectedViewer = NIL) THEN {
AppendLogMessage[psTool, "Selection not in text viewer"];
RETURN;
}
ELSE {
WHILE sourceName.Length <= 1 AND selectedViewer # NIL DO
sourceName _ selectedViewer.name;
selectedViewer _ selectedViewer.parent;
ENDLOOP;
};
};
IF sourceName.Length > 1 THEN {
selectedViewer _ ViewerOps.FindViewer[sourceName];
IF selectedViewer = NIL THEN
AppendLogMessage[psTool, Rope.Cat["Viewer \"", sourceName, "\" wasn't found."]]
ELSE {
ViewerTools.SetContents[psTool.ulx, IO.PutFR["%g", IO.int[selectedViewer.wx]]];
ViewerTools.SetContents[psTool.uly, IO.PutFR["%g", IO.int[selectedViewer.wy+selectedViewer.wh]]];
ViewerTools.SetContents[psTool.lrx, IO.PutFR["%g", IO.int[selectedViewer.wx+selectedViewer.ww]]];
ViewerTools.SetContents[psTool.lry, IO.PutFR["%g", IO.int[selectedViewer.wy]]];
ChoiceButtons.UpdateChoiceButtons[NARROW[parent], psTool.screenAreaChoice, "DesiredArea"];
FlashScreenArea[psTool];
};
};
};

FlashImageButton: Buttons.ButtonProc = {
psTool: PressScreenTool _ NARROW[clientData];
FlashScreenArea[psTool];
};

flashTime: Process.Milliseconds ~ 600;
FlashScreenArea: PROCEDURE [psTool: PressScreenTool] = {
ulx, uly, lrx, lry: REAL;
context: Graphics.Context _ Graphics.NewContext[];
[] _ context.SetPaintMode[invert];
[ulx, uly, lrx, lry] _ ReadScreenCorners[psTool];
context.DrawBox[[lrx, lry, ulx, uly]];
Process.Pause[Process.MsecToTicks[flashTime]];
context.DrawBox[[lrx, lry, ulx, uly]];
};

SetCornersButton: Buttons.ButtonProc = {
psTool: PressScreenTool _ NARROW[clientData];
sMin, fMin: INTEGER;
sSize, fSize: NAT;
[sMin, fMin, sSize, fSize] _ LFUtil.GetArea[ ! LFUtil.AbortAdjust => GOTO DoNothing];
ViewerTools.SetContents[psTool.ulx, IO.PutFR["%g", IO.int[fMin]]];
ViewerTools.SetContents[psTool.uly, IO.PutFR["%g", IO.int[sMin+sSize-1]]];
ViewerTools.SetContents[psTool.lrx, IO.PutFR["%g", IO.int[fMin+fSize-1]]];
ViewerTools.SetContents[psTool.lry, IO.PutFR["%g", IO.int[sMin]]];
ChoiceButtons.UpdateChoiceButtons[NARROW[parent], psTool.screenAreaChoice, "DesiredArea"];
FlashScreenArea[psTool];
EXITS
DoNothing => NULL;
};

SaveStateButton: Buttons.ButtonProc = {
psTool: PressScreenTool _ NARROW[clientData];
SaveState[psTool];
};
SaveState: PROCEDURE [psTool: PressScreenTool] = {
IF psTool.destroyed THEN RETURN;
psTool.screenAreaRope _ ChoiceButtons.GetSelectedButton[psTool.screenAreaChoice];
psTool.magnificationRope _ ChoiceButtons.GetSelectedButton[psTool.magnificationChoice];
psTool.pageMargin _ ConvertRopeToReal[ViewerTools.GetContents[psTool.pageMarginViewer]];
psTool.magnificationFactor _ ConvertRopeToReal[ViewerTools.GetContents[psTool.magnificationViewer]]/100.0;
[psTool.ulX, psTool.ulY, psTool.lrX, psTool.lrY] _ ReadScreenCorners[psTool]; 
psTool.formatRope _ ChoiceButtons.GetSelectedButton[psTool.formatViewer];
psTool.borderWidth _ ConvertRopeToReal[ViewerTools.GetContents[psTool.borderViewer]];
psTool.pageMargin _ ConvertRopeToReal[ViewerTools.GetContents[psTool.pageMarginViewer]];
psTool.countDownTime _ Process.SecondsToTicks[MIN[100000, MAX[0, Real.FixC[ConvertRopeToReal[ViewerTools.GetContents[psTool.countDownTimerViewer]]]]]];
psTool.lockViewers _ psTool.lockViewersTriState.state = on;
psTool.displayCursor _ psTool.displayCursorTriState.state = on;
psTool.displayCarets _ psTool.displayCaretsTriState.state = on;
psTool.stateSaved _ TRUE;
};
DoItButton: Buttons.ButtonProc = {
psTool: PressScreenTool _ NARROW[clientData];
SaveState[psTool];
DoIt[psTool];
};
DoIt: PROCEDURE [psTool: PressScreenTool] = {
IF psTool.stateSaved THEN {
sourceHeight, sourceWidth, sourceBottom, sourceLeft: NAT _ 0;
fileName: ROPE;
SELECT TRUE FROM
psTool.screenAreaRope.Equal["LeftColumn"] => {
sourceHeight _ ViewerSpecs.screenH;
sourceWidth _ ViewerSpecs.openLeftWidth;
sourceBottom _ 0;
sourceLeft _ ViewerSpecs.openLeftLeftX;
};
psTool.screenAreaRope.Equal["RightColumn"] => {
sourceHeight _ ViewerSpecs.screenH;
sourceWidth _ ViewerSpecs.openRightWidth;
sourceBottom _ 0;
sourceLeft _ ViewerSpecs.openRightLeftX;
};
psTool.screenAreaRope.Equal["WholeScreen"] => {
sourceHeight _ ViewerSpecs.screenH;
sourceWidth _ ViewerSpecs.screenW;
sourceBottom _ 0;
sourceLeft _ 0;
};
psTool.screenAreaRope.Equal["DesiredArea"] => {
ulx, uly, lrx, lry: REAL;
[ulx, uly, lrx, lry] _ ReadScreenCorners[psTool];
sourceHeight _ Real.Fix[uly - lry + 1];
sourceWidth _ Real.Fix[lrx - ulx + 1];
sourceBottom _ Real.Fix[lry];
sourceLeft _ Real.Fix[ulx];
};
ENDCASE => {
sourceHeight _ ViewerSpecs.screenH;
sourceWidth _ ViewerSpecs.screenW;
sourceBottom _ 0;
sourceLeft _ 0;
};
IF psTool.countDownTime > 0 THEN {
FOR i: CARDINAL IN [1..25] DO
Process.Pause[psTool.countDownTime/25];
IF NOT psTool.countDownPieViewer.destroyed THEN
PieViewers.Set[psTool.countDownPieViewer, 100.0-4*i];
ENDLOOP;
};
fileName _ AISPressScreen[
pressFileName: NewAISPressName[],
sourceHeight: sourceHeight,
sourceWidth: sourceWidth,
sourceBottom: sourceBottom,
sourceLeft: sourceLeft,
magnification: psTool.magnificationFactor,
scaleToFit: SELECT TRUE FROM
psTool.magnificationRope.Equal["UseFactor"] => useMagnification,
psTool.magnificationRope.Equal["HalfPage"] => halfPage,
psTool.magnificationRope.Equal["FullPage"] => fullPage,
ENDCASE => halfPage,
leftMarginInches: psTool.pageMargin,
rightMarginInches: psTool.pageMargin,
landscape: SELECT psTool.formatRope FROM
"Landscape" => TRUE,
ENDCASE => FALSE,
borderWidth: psTool.borderWidth,
lockViewers: psTool.lockViewers,
displayCursor: psTool.displayCursor,
displayCarets: psTool.displayCarets
! MagnificationFactorTooLarge => GOTO ReportError];
AppendLogMessage[psTool, Rope.Concat[fileName, " written."]];
IF NOT psTool.countDownPieViewer.destroyed THEN
PieViewers.Set[psTool.countDownPieViewer, 100.0];
EXITS
ReportError =>
AppendLogMessage[psTool, "Magnification factor too large for identified area"];
};
};

MagnificationFactorButton: Buttons.ButtonProc = {
psTool: PressScreenTool _ NARROW[clientData];
IF mouseButton = blue THEN ViewerTools.SetContents[psTool.magnificationViewer, ""];
ViewerTools.SetSelection[psTool.magnificationViewer];
};

AreaCornersButton: Buttons.ButtonProc = {
psTool: PressScreenTool _ NARROW[clientData];
sourceHeight, sourceWidth, sourceBottom, sourceLeft: NAT _ 0;
screenAreaChoice: ROPE _ ChoiceButtons.GetSelectedButton[psTool.screenAreaChoice];
SELECT TRUE FROM
screenAreaChoice.Equal["LeftColumn"] => {
sourceHeight _ ViewerSpecs.screenH;
sourceWidth _ ViewerSpecs.openLeftWidth;
sourceBottom _ 0;
sourceLeft _ ViewerSpecs.openLeftLeftX;
};
screenAreaChoice.Equal["RightColumn"] => {
sourceHeight _ ViewerSpecs.screenH;
sourceWidth _ ViewerSpecs.openRightWidth;
sourceBottom _ 0;
sourceLeft _ ViewerSpecs.openRightLeftX;
};
screenAreaChoice.Equal["WholeScreen"] => {
sourceHeight _ ViewerSpecs.screenH;
sourceWidth _ ViewerSpecs.screenW;
sourceBottom _ 0;
sourceLeft _ 0;
};
screenAreaChoice.Equal["DesiredArea"] => {
sourceHeight _ sourceWidth _ sourceBottom _ sourceLeft _ 0;
};
ENDCASE => {
sourceHeight _ ViewerSpecs.screenH;
sourceWidth _ ViewerSpecs.screenW;
sourceBottom _ 0;
sourceLeft _ 0;
};
ViewerTools.SetContents[psTool.ulx, IO.PutFR["%g", IO.int[sourceLeft]]];
ViewerTools.SetContents[psTool.uly, IO.PutFR["%g", IO.int[sourceBottom+sourceHeight-1]]];
ViewerTools.SetContents[psTool.lrx, IO.PutFR["%g", IO.int[sourceLeft+sourceWidth-1]]];
ViewerTools.SetContents[psTool.lry, IO.PutFR["%g", IO.int[sourceBottom]]];
ViewerTools.SetSelection[psTool.ulx];
};

BlackBorderButton: Buttons.ButtonProc = {
psTool: PressScreenTool _ NARROW[clientData];
IF mouseButton = blue THEN ViewerTools.SetContents[psTool.borderViewer, ""];
ViewerTools.SetSelection[psTool.borderViewer];
};

PageMarginButton: Buttons.ButtonProc = {
psTool: PressScreenTool _ NARROW[clientData];
IF mouseButton = blue THEN ViewerTools.SetContents[psTool.pageMarginViewer, ""];
ViewerTools.SetSelection[psTool.pageMarginViewer];
};

CountDownTimerButton: Buttons.ButtonProc = {
psTool: PressScreenTool _ NARROW[clientData];
IF mouseButton = blue THEN ViewerTools.SetContents[psTool.countDownTimerViewer, "0"];
ViewerTools.SetSelection[psTool.countDownTimerViewer];
};

AppendLogMessage: PROCEDURE [psTool: PressScreenTool, msg: ROPE] = {
psTool.logMessage _ psTool.logMessage.Cat[msg, "\n"];
IF NOT psTool.logViewer.destroyed THEN {
ViewerTools.SetContents[psTool.logViewer, psTool.logMessage];
[] _ psTool.logViewer.class.scroll[psTool.logViewer, thumb, 100];
}
ELSE MessageWindow.Append[msg, TRUE];
};

ReadScreenCorners: PROCEDURE [psTool: PressScreenTool] RETURNS [ulx, uly, lrx, lry: REAL] = {
ulx _ ConvertRopeToReal[ViewerTools.GetContents[psTool.ulx]];
uly _ ConvertRopeToReal[ViewerTools.GetContents[psTool.uly]];
lrx _ ConvertRopeToReal[ViewerTools.GetContents[psTool.lrx]];
lry _ ConvertRopeToReal[ViewerTools.GetContents[psTool.lry]];
};

ConvertRopeToReal: PROCEDURE [rope: ROPE] RETURNS [value: REAL] = {
success: BOOLEAN _ TRUE;
value _ 0.0;
value _ Convert.RealFromRope[rope ! Convert.Error => {success _ FALSE; CONTINUE}];
IF NOT success THEN value _ Convert.IntFromRope[rope ! Convert.Error => CONTINUE];
};

GetName: PROC [stream: IO.STREAM] RETURNS [name: ROPE] ~ {
name _ NIL;
name _ IO.GetTokenRope[stream, IO.IDProc ! IO.EndOfStream => CONTINUE].token;
};

PressScreenExecCommand: Commander.CommandProc = TRUSTED {
stream: IO.STREAM _ IO.RIS[cmd.commandLine];
serverName: ROPE _ GetName[stream];
[] _ NewPressScreenTool[serverName];
};

sym: INT _ 0;
GenSym: ENTRY PROC RETURNS [ROPE] ~ {s: INT _ sym; sym _ sym + 1; RETURN [IF s = 0 THEN "" ELSE Convert.RopeFromInt[s]]};
pressScreenViewerClass: ViewerClasses.ViewerClass ~
NEW[ViewerClasses.ViewerClassRec _ ViewerOps.FetchViewerClass[$Container]^];
containerInitProc: ViewerClasses.InitProc _ pressScreenViewerClass.init;
containerDestroyProc: ViewerClasses.InitProc _ pressScreenViewerClass.destroy;

pressScreenViewerClass.init _ InitPressScreenViewer;
pressScreenViewerClass.destroy _ DestroyPressScreenViewer;

ViewerOps.RegisterViewerClass[$PressScreen, pressScreenViewerClass];

Commander.Register[
key: "PressScreen",
proc: PressScreenExecCommand,
doc: "Create a tool to make AIS/Press files of portions of the bitmap display screen"
];

}.
6-Apr-82 12:01:31 Teitelman fixed PressScreenButton to clear message window first.
May 4, 1982 4:39 pm Cattell: print msg saying whether half or full screen. Also, no longer need config 'cause SirPressPackage is external.

June 18, 1982 1:58 pm Cattell: convert to 3.2; leave a little left margin to avoid printer truncation.  
November 15, 1982 12:30 pm Plass: Made client-callable interface.
November 15, 1982 2:30 pm Plass: Made rightSide work, removed button interface, made half-screen resolution match what Spruce can sometimes handle.
November 16, 1982 10:57 am Plass: Tracked SirPress changes.

PressScreenToolImpl.mesa
Tool to make AIS/press file of display
Last Edited by: Beach, October 31, 1983 1:29 pm
Plass, December 9, 1983 2:49 pm
Creates a PressScreen tool viewer.
The only way this proc is called is to init a new $PressScreen viewer.
There is no reset menu entry posted.

Create the PressScreen menu


Screen Area: DesiredArea WholeScreen LeftColumn RightColumn

Area Corners: #### x #### y  #### x #### y

Magnification: FullPage HalfPage UseFactorBelow

MagnificationFactor: xxxx %

Page Format: Landscape Portrait

BlackBorder: xxxx pixels

PageMargin: xxxx inches

CountDownTimer: xxxx seconds

Viewer Controls: LockViewers DisplayCursor DisplayCarets

Rule between buttons and log viewer

Create log viewer for file completion messages
Display default settings
ส๛˜Jš
ฯc™Jš
&™&š
/™/J™—J˜š
ฯk	˜	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šžœžœžœ
˜J˜Iunitšœžœžœ˜6šœžœ
žœžœ
˜)Jšœžœžœ
˜Jšœžœžœ
˜Jš
œ,˜,Jšœžœ
˜Jš
œ/˜/Jšœžœ
˜Jšœ,˜CJšœžœ
˜Jšœ+&˜QJšœžœ
˜Jš
œ(˜(Jšœžœ
˜Jšœ%˜4Jšœ
žœ
˜Jš
œ'˜'Jšœžœ
˜Jš
œ+˜+Jš
œ˜Jš
œ)˜)J˜1Jšœ
žœ
˜J˜3Jšœžœ
˜J˜3Jšœžœ
˜J˜ Jšœž˜J˜J˜—Kšœžœ7˜GJšœžœ˜šœ
žœ˜J˜—šฯnœžœžœžœ˜\J™"Jšžœ
žœžœ
˜˜˜J˜š
œ˜Jšœžœžœžœ,˜bJš
œ˜Jšœž˜J˜—Jšœž˜J˜——Jšœ	žœ0˜?J˜J˜—šŸœ˜1J™FJ™$Jšœžœ˜2Jšœžœ
˜Jšœžœ˜JšŸœž	œ
žœžœ˜>J˜J˜&šŸ
œž	œžœžœ˜H˜.Jš
œ˜J˜J˜Jš
œ˜J˜—J˜—šŸœž	œžœžœ˜Pš
œ"˜"š
œ?˜?Jšœžœ
žœ˜/—Jšœž˜J˜—˜JšœYžœ
žœ˜oJšœž˜J˜—J˜—š
Ÿœž	œžœ!žœžœ˜bšžœ˜JšœBžœ˜IJ˜Jš
œ˜Jšœžœ
˜Jšœžœ
˜Jš
œ˜Jš
œ˜—J˜—Jšœ
žœ˜0J˜Jš
œ2˜2J˜JšœB˜\J˜J˜ฎ
J™J™J™J˜UJ˜xJ˜_J˜_J˜iJ˜J™Jš
œ;™;š
œ?˜?Jš
œ
˜
Jš
œ
˜
Jš
œ˜Jš
œ˜Jšœ
žœžœžœžœžœ˜dJš
œ˜Jš
œ˜—J™Jš	œฯeœ œ œ œ™*Jš
œo˜oJš
œ'˜'Jš
œ'˜'Jš
œ&˜&Jš
œ%˜%J™Jš
œ/™/š
œB˜BJš
œ
˜
Jš
œ
˜
Jš
œ˜Jš
œ˜Jš	œ
žœ
žœ
žœžœ˜MJ˜Jš
œ˜—J™J™Jš
œf˜fJš
œ6˜6J™J™š
œ;˜;Jš
œ
˜
Jš
œ
˜
Jš
œ˜Jš
œ˜Jšœ
žœ
žœžœ˜6Jš
œ˜Jš
œ˜—J™Jš
œ™Jš
œ{˜{Jš
œ3˜3J™J™Jš
œd˜dJš
œ7˜7J™Jš
œ™Jš
œh˜hJš
œ>˜>Jš
œ^˜^J™J™8˜Jšœfžœ
žœ˜|Jšœž˜J˜—š
œH˜HJš
œ
˜
Jš
œ˜Jš
œ˜Jš
œ˜—š
œJ˜JJš
œ
˜
Jš
œ	˜	Jš
œ˜Jš
œ˜—š
œJ˜JJš
œ
˜
Jš
œ	˜	Jš
œ˜Jš
œ˜—J™J™#J˜\J™J™.˜1Jšœ4žœ
žœ
˜HJ˜—J˜/J˜/J˜J˜ะ
J˜ช
Jš
œ?˜?J˜J™Jš
œP˜PJš
œP˜PJšœ4žœ
žœ˜TJšœ$žœ
žœ
˜?Jšœ$žœ
žœ˜AJšœ$žœ
žœ
˜BJšœ$žœ
žœ
˜?Jš
œI˜IJšœ-žœ
žœ
˜HJšœ1žœ
žœ˜PJšœ5žœ
žœ
˜PJ˜1J˜J˜!J˜J˜—šŸœ˜7Jšœžœ.˜NJ˜Jšœžœ
˜Jšžœžœ
žœ˜>J˜—šŸœ˜/Jšœžœ
˜-J˜Gšœžœ˜Jšžœžœ
žœžœ
žœ
ž˜BJšžœ
žœ6˜A—šžœžœ˜ šžœžœžœ˜ Jš
œ9˜9Jšžœ
˜Jš
œ
˜
—šžœ˜šžœžœžœ
ž˜8Jš
œ!˜!J˜'Jš
ž˜—Jš
œ˜—J˜—šžœžœ˜J˜2šžœž˜Jš
œO˜O—šžœ˜Jšœ$žœ
žœ˜OJšœ$žœ
žœ,˜aJšœ$žœ
žœ,˜aJšœ$žœ
žœ˜OJšœ"žœ2˜ZJš
œ˜J˜—Jš
œ˜—J˜J˜—šŸœ˜(Jšœžœ
˜-Jš
œ˜J˜J˜—J˜&šŸœž	œ˜8Jšœžœ
˜J˜2J˜"Jš
œ1˜1Jš
œ&˜&J˜.Jš
œ&˜&J˜J˜—šฯaœ˜(Jšœžœ
˜-Jšœžœ
˜Jšœž˜JšœEžœ˜UJšœ$žœ
žœ
˜BJšœ$žœ
žœ˜JJšœ$žœ
žœ˜JJšœ$žœ
žœ
˜BJšœ"žœ2˜ZJš
œ˜š
ž˜Jšœ
žœ
˜—J˜J˜—šŸœ˜'Jšœžœ
˜-J˜J˜—šŸ	œž	œ˜2Jšžœžœ
žœ
˜ Jš
œQ˜QJš
œW˜WJš
œX˜XJš
œj˜jJš
œN˜NJš
œI˜IJš
œU˜UJš
œX˜XJšœ.žœ	žœZ˜—
Jš
œ;˜;Jš
œ?˜?Jš
œ?˜?Jšœžœ
˜J˜—šŸ
œ˜"Jšœžœ
˜-J˜Jš
œ
˜
Jš
œ˜—šŸœž	œ˜-šžœžœ˜Jšœ5žœ˜=Jšœ
ž˜šžœ
žœ
ž˜š
œ.˜.Jš
œ#˜#Jš
œ(˜(Jš
œ˜Jš
œ'˜'Jš
œ˜—š
œ/˜/Jš
œ#˜#Jš
œ)˜)Jš
œ˜Jš
œ(˜(Jš
œ˜—š
œ/˜/Jš
œ#˜#Jš
œ"˜"Jš
œ˜Jš
œ˜Jš
œ˜—š
œ/˜/Jšœžœ
˜Jš
œ1˜1Jš
œ'˜'Jš
œ&˜&Jš
œ˜Jš
œ˜Jš
œ˜—šžœ˜Jš
œ#˜#Jš
œ"˜"Jš
œ˜Jš
œ˜Jš
œ˜——šžœžœ˜"šžœžœ
žœ	ž˜Jš
œ'˜'šžœ
žœ%ž˜/Jš
œ5˜5—Jš
ž˜—Jš
œ˜—š
œ˜Jš
œ!˜!Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ*˜*šœžœ
žœ
ž˜Jš
œ@˜@Jš
œ7˜7Jš
œ7˜7Jšžœ
˜—Jš
œ$˜$Jš
œ%˜%šœžœž˜(Jšœžœ
˜Jšžœžœ
˜—Jš
œ ˜ Jš
œ ˜ Jš
œ$˜$Jš
œ#˜#Jšœ!žœ˜3—Jš
œ=˜=šžœ
žœ%ž˜/Jš
œ1˜1—š
ž˜š
œ˜Jš
œO˜O——Jš
œ˜—J˜J˜—šŸœ˜1Jšœžœ
˜-Jšžœžœ9˜SJš
œ5˜5J˜J˜—šŸœ˜)Jšœžœ
˜-Jšœ5žœ˜=Jšœžœ<˜Ršžœ
žœ
ž˜š
œ)˜)Jš
œ#˜#Jš
œ(˜(Jš
œ˜Jš
œ'˜'Jš
œ˜—š
œ*˜*Jš
œ#˜#Jš
œ)˜)Jš
œ˜Jš
œ(˜(Jš
œ˜—š
œ*˜*Jš
œ#˜#Jš
œ"˜"Jš
œ˜Jš
œ˜Jš
œ˜—š
œ*˜*Jš
œ;˜;Jš
œ˜—šžœ˜Jš
œ#˜#Jš
œ"˜"Jš
œ˜Jš
œ˜Jš
œ˜——Jšœ$žœ
žœ˜HJšœ$žœ
žœ$˜YJšœ$žœ
žœ!˜VJšœ$žœ
žœ˜JJš
œ%˜%J˜J˜—šŸœ˜)Jšœžœ
˜-Jšžœžœ2˜LJš
œ.˜.J˜J˜—šŸœ˜(Jšœžœ
˜-Jšžœžœ6˜PJš
œ2˜2J˜J˜—šŸœ˜,Jšœžœ
˜-Jšžœžœ;˜UJš
œ6˜6J˜J˜—šŸœž	œ žœ˜D˜5šžœ
žœžœ˜(Jš
œ=˜=Jš
œA˜AJš
œ
˜
—Jšžœžœ˜%—J˜J˜—šŸœž	œžœžœ˜]J˜=J˜=J˜=J˜=J˜J˜—š
Ÿœž	œžœžœ	žœ˜CJšœ	žœžœ
˜Jš
œ˜Jšœ@žœžœ˜RJšžœ
žœ	žœ5žœ˜RJ˜J˜—šŸœžœ
žœ
žœžœžœ˜:Jšœžœ
˜Jš	œžœžœ
žœžœ˜MJ˜J˜—šŸœžœ˜9Jš	œžœ
žœžœ
žœ˜,Jšœžœ˜#Jš
œ$˜$J˜J˜—Kšœžœ˜
KšŸœžœ
žœ
žœžœžœžœžœžœžœ˜y˜3JšžœI˜L—Jš
œH˜HJš
œN˜NJ˜Jš
œ4˜4Jš
œ:˜:J˜J˜DJ˜š
œ˜Jš
œ˜Jš
œ˜Jš
œU˜UJ˜—J˜š
œ˜J˜RJ˜Š
J˜J˜hJ˜AJ˜“
J˜;—J˜—…—Ln`}