DIRECTORY Atom, Buttons, CedarProcess, Commander, Containers, Controls, ControlsPrivate, Convert, FileNames, G2dBasic, Imager, IO, Labels, PopUpSelection, ProcessProps, Real, Rope, TiogaExtraOps, TiogaOps, TIPUser, TypeScript, VFonts, ViewerClasses, ViewerIO, ViewerOps, ViewerSpecs, ViewerTools;

ControlsOuterImpl: CEDAR MONITOR
IMPORTS Atom, Buttons, CedarProcess, Containers, Controls, ControlsPrivate, Convert, FileNames, Imager, IO, Labels, PopUpSelection, ProcessProps, Real, Rope, TiogaExtraOps, TiogaOps, TIPUser, TypeScript, VFonts, ViewerIO, ViewerOps, ViewerSpecs, ViewerTools
EXPORTS Controls

~ BEGIN
Button:				TYPE ~ Controls.Button;
ButtonList:			TYPE ~ Controls.ButtonList;
ButtonRep:			TYPE ~ Controls.ButtonRep;
Choice:				TYPE ~ Controls.Choice;
ClickProc:			TYPE ~ Controls.ClickProc;
Column:				TYPE ~ Controls.Column;
Control:				TYPE ~ Controls.Control;
ControlList:			TYPE ~ Controls.ControlList;
ControlSizes:			TYPE ~ Controls.ControlSizes;
DestroyProc:			TYPE ~ Controls.DestroyProc;
DrawProc:			TYPE ~ Controls.DrawProc;
GraphicsData:		TYPE ~ Controls.GraphicsData;
GraphicsDataRep:	TYPE ~ Controls.GraphicsDataRep;
IntegerPair:			TYPE ~ Controls.IntegerPair;
MouseButton:		TYPE ~ Controls.MouseButton;
MouseProc:			TYPE ~ Controls.MouseProc;
OuterData:			TYPE ~ Controls.OuterData;
OuterDataRep:		TYPE ~ Controls.OuterDataRep;
RealSequence:		TYPE ~ Controls.RealSequence;
RealSequenceRep:	TYPE ~ Controls.RealSequenceRep;
RopeSequence:		TYPE ~ Controls.RopeSequence;
RopeSequenceRep:	TYPE ~ Controls.RopeSequenceRep;
Request:				TYPE ~ Controls.Request;
Triple:				TYPE ~ Controls.Triple;
TSValue:				TYPE ~ Controls.TSValue;
Typescript:			TYPE ~ Controls.Typescript;
TypescriptRep:		TYPE ~ Controls.TypescriptRep;
Font:					TYPE ~ Imager.Font;
STREAM:				TYPE ~ IO.STREAM;
ROPE:					TYPE ~ Rope.ROPE;
IconFlavor:			TYPE ~ ViewerClasses.IconFlavor;
Viewer:				TYPE ~ ViewerClasses.Viewer;
maxNRows:			INTEGER ~ 10;
capHeight:			INTEGER ~ 14;
ControlError: PUBLIC ERROR [reason: ROPE] = CODE;
AvailableHeight: PROC [column: ViewerClasses.Column] RETURNS [ht: INTEGER] ~ {
nViewers: INTEGER ¬ 1;							-- count oneself too
EnumProc: ViewerOps.EnumProc ~ {
IF v.column = column AND NOT v.iconic THEN nViewers ¬ nViewers+1;
};
ViewerOps.EnumerateViewers[EnumProc];
ht ¬ ViewerSpecs.openTopY-ViewerSpecs.openBottomY-nViewers*ViewerSpecs.captionHeight;
};

PaintOuter: ViewerClasses.PaintProc ~ {
Action: PROC ~ { 
o: OuterData ¬ NARROW[self.data];
Imager.MaskRectangleI[context, 0, self.wh-capHeight, self.ww, 1];
IF o.buttons # NIL THEN Imager.MaskRectangleI[context, 0, o.buttonsY, self.ww, 1];
IF o.typescript # NIL AND o.typescript.viewer # NIL
THEN Imager.MaskRectangleI[context, 0, o.tsY, self.ww, 1];
IF o.graphics # NIL THEN Imager.MaskRectangleI[context, 0, o.graphicsY-1, self.ww, 1];
};
IF whatChanged = NIL THEN Imager.DoWithBuffer[context, Action, 0, 0, self.ww, self.wh];
};

AdjustProc: ViewerClasses.AdjustProc ~ {AdjustOuter[NARROW[self.data], self.ww, self.wh]};

AdjustOuter: PROC [o: OuterData, w, h: INTEGER] ~ {
SetV: PROC[v: Viewer, x, y, w, h: INT] ~ {ViewerOps.EstablishViewerPosition[v,x,y,w,h]};
EstablishOuterChild: ViewerOps.EnumProc ~ {
newY: INTEGER ¬ v.wy+h-o.outerH;
IF ViewerOps.FetchProp[v, $CreatedInOuterViewer] = NIL
THEN SetV[v, v.wx, v.wy ¬ newY, v.ww, v.wh];
};
oldGraphicsH: INT ¬ o.graphicsH;
o.graphicsH ¬ h-capHeight-o.controlsH-o.buttonsH-o.tsH;
SetYs[o];
IF o.typescript # NIL AND o.typescript.viewer # NIL
THEN SetV[o.typescript.viewer, 0, o.tsY+1, w, o.tsH-2];
IF o.buttons # NIL THEN FOR b: ButtonList ¬ o.buttons, b.rest WHILE b # NIL DO
SetV[b.first.viewer, b.first.x, o.buttonsY+b.first.y, b.first.w, b.first.h];
ENDLOOP;
IF o.parent # NIL THEN ViewerOps.EnumerateChildren[o.parent, EstablishOuterChild];
IF o.graphics # NIL AND NOT o.parent.iconic THEN {
refWidth: REF ANY ¬ ViewerOps.FetchProp[o.graphics, $Width];
refHeight: REF ANY ¬ ViewerOps.FetchProp[o.graphics, $Height];
SetV[o.graphics, 0, o.graphicsY, w, o.graphicsH];
IF refWidth # NIL AND refHeight # NIL THEN {
EstablishGraphicsChild: ViewerOps.EnumProc ~ {
I: PROC [r: REAL] RETURNS [i: INT] ~ {i ¬ Real.Round[r]};
SetV[v, I[sx*v.wx], I[sy*v.wy], I[sx*v.ww], I[sy*v.wh]];
};
sx: REAL ¬ REAL[w]/REAL[NARROW[refWidth, REF INTEGER]­];
sy: REAL ¬ REAL[o.graphicsH]/REAL[NARROW[refHeight, REF INTEGER]­];
ViewerOps.EnumerateChildren[o.graphics, EstablishGraphicsChild];
};
ViewerOps.AddProp[o.graphics, $Width, NEW[INTEGER ¬ w]];
ViewerOps.AddProp[o.graphics, $Height, NEW[INTEGER ¬ o.graphicsH]];
};
o.outerH ¬ h;
};

CopyControlList: PROC [controls: ControlList] RETURNS [ControlList] ~ {
new: ControlList ¬ NIL;
FOR c: ControlList ¬ controls, c.rest WHILE c # NIL DO
new ¬ Controls.Append[c.first, new];
ENDLOOP;
RETURN[new];
};

ChangeOuterViewer: PUBLIC PROC [outerData: OuterData, controls: ControlList] ~ {
NotInList: PROC [controls: ControlList, control: Control] RETURNS [BOOL] ~ {
FOR c: ControlList ¬ controls, c.rest WHILE c # NIL DO
IF c.first = control THEN RETURN[FALSE];
ENDLOOP;
RETURN[TRUE];
};
destroy: BOOL ¬ FALSE;
parent: Viewer ¬ outerData.parent;
oldControlHeight: INTEGER ¬ outerData.controlsH;
FOR c: ControlList ¬ outerData.controls, c.rest WHILE c # NIL DO			-- do this everytime
IF NotInList[controls, c.first] THEN {destroy ¬ TRUE; EXIT};
ENDLOOP;
FOR c: ControlList ¬ outerData.controls, c.rest WHILE c # NIL DO
ViewerOps.DestroyViewer[c.first.viewer, FALSE];
ViewerOps.DestroyViewer[c.first.title, FALSE];
ViewerOps.DestroyViewer[c.first.status, FALSE];
ENDLOOP;
outerData.controlsH ¬
Controls.ControlPositions[controls, outerData.controlSizes, ColumnWidth[outerData.column]];
IF outerData.controlsH # oldControlHeight THEN {
SetOuterHeight[outerData];
AdjustOuter[outerData, outerData.parent.ww, outerData.outerH];
ViewerOps.SetOpenHeight[parent, outerData.outerH-capHeight+1];
ViewerOps.ComputeColumn[outerData.column, TRUE];
};
outerData.controls ¬ CopyControlList[controls];
FOR c: ControlList ¬ controls, c.rest WHILE c # NIL DO
Controls.ControlViewer[parent, c.first, outerData.graphics, outerData];
ENDLOOP;
IF outerData.controlsH = oldControlHeight AND destroy
THEN ViewerOps.PaintViewer[parent, client, TRUE, NIL];
};

OuterViewer: PUBLIC PROC [
name: ROPE ¬ NIL,
column: Column ¬ left,
buttons: ButtonList ¬ NIL,
controls: ControlList ¬ NIL,
controlSizes: ControlSizes ¬ [25, 200, 60, 25, 60, 150, 150],
graphicsHeight: INTEGER ¬ 0,
mouseProc: MouseProc ¬ NIL,
drawProc: DrawProc ¬ NIL,
destroyProc: DestroyProc ¬ NIL,
typescriptHeight: INTEGER ¬ 0,
biScrollable: BOOL ¬ FALSE,
clientData: REF ANY ¬ NIL,
noOpen: BOOL ¬ FALSE,
icon: IconFlavor ¬ document]
RETURNS [outerData: OuterData]
~ {
viewer: Viewer;
outerData ¬ OuterDataInit[
NIL, column, buttons, controls, controlSizes,
graphicsHeight, mouseProc, drawProc,
destroyProc, typescriptHeight, clientData];
viewer ¬ outerData.parent ¬ ViewerOps.CreateViewer[
flavor: $Outer,
paint: FALSE,
info: [
name: name,
data: outerData,
openHeight: MIN[AvailableHeight[column], outerData.outerH],
scrollable: FALSE,
column: column,
iconic: TRUE]
];
IF icon # document THEN viewer.icon ¬ icon;
ViewerOps.AddProp[viewer, $WorkingDirectory, ProcessProps.GetProp[$WorkingDirectory]];
SetYs[outerData];
IF outerData.tsH # 0 THEN {
ts: Typescript ¬ outerData.typescript ¬ NEW[TypescriptRep];
v: Viewer ¬ ts.viewer ¬ TypescriptViewer[viewer, outerData.tsH];
[ts.in, ts.out] ¬ ViewerIO.CreateViewerStreams[NIL, v];
};
IF graphicsHeight # 0 THEN {
outerData.graphics ¬ GraphicsViewer[viewer, outerData.controlsH, graphicsHeight, mouseProc, drawProc, biScrollable, outerData.clientData];
ViewerOps.AddProp[outerData.graphics, $Width, NEW[INTEGER ¬ viewer.ww]];
ViewerOps.AddProp[outerData.graphics, $Height, NEW[INTEGER ¬ graphicsHeight]];
outerData.graphicsData ¬ GetGraphicsData[outerData.graphics];
};
FOR b: ButtonList ¬ outerData.buttons, b.rest WHILE b # NIL DO
v: Viewer ¬ b.first.viewer ¬ ButtonViewer[viewer, b.first];
IF b.first.type = click AND b.first.style # $BlackOnWhite
THEN Buttons.SetDisplayStyle[b.first.viewer, b.first.style];
ENDLOOP;
FOR c: ControlList ¬ outerData.controls, c.rest WHILE c # NIL DO
Controls.ControlViewer[viewer, c.first, outerData.graphics, outerData];
ENDLOOP;
IF NOT noOpen THEN ViewerOps.OpenIcon[viewer];
};

OuterDataInit: PROC [
outerData: OuterData ¬ NIL,							-- use if non-nil
column: Column ¬ left,
buttons: ButtonList ¬ NIL,
controls: ControlList ¬ NIL,
controlSizes: ControlSizes ¬ [25, 200, 60, 25, 60, 150, 150],
graphicsHeight: INTEGER ¬ 0,
mouseProc: MouseProc ¬ NIL,
drawProc: DrawProc ¬ NIL,
destroyProc: DestroyProc ¬ NIL,
typescriptHeight: INTEGER ¬ 0,
data: REF ANY ¬ NIL]
RETURNS [OuterData] ~ {
widthLim: NAT ¬ SELECT column FROM
left => ViewerSpecs.openLeftWidth,
right => ViewerSpecs.openRightWidth,
ENDCASE => ViewerSpecs.colorScreenWidth;
IF outerData = NIL THEN outerData ¬ NEW[OuterDataRep];
outerData.controls ¬ CopyControlList[controls];
outerData.buttons ¬ buttons;
outerData.clientData ¬ data;
outerData.destroyProc ¬ destroyProc;
outerData.controlSizes ¬ controlSizes;
outerData.directory ¬ FileNames.CurrentWorkingDirectory[];
outerData.cmdOut ¬ WITH ProcessProps.GetProp[$CommanderHandle] SELECT FROM
cmd: Commander.Handle => cmd.err,
ENDCASE => NIL;
outerData.controlsH ¬ Controls.ControlPositions[controls, controlSizes, ColumnWidth[column]];
outerData.graphicsH ¬ graphicsHeight;
outerData.tsH ¬ typescriptHeight;
outerData.buttonsH ¬ ButtonsPreparation[buttons, widthLim];
SetOuterHeight[outerData];
RETURN[outerData];
};

ColumnWidth: PROC [column: Column] RETURNS [INTEGER] ~ {
RETURN[SELECT column FROM
color => ViewerSpecs.colorScreenWidth,
left => ViewerSpecs.openLeftWidth,
right => ViewerSpecs.openRightWidth,
ENDCASE => 600];
};

SetYs: PROC [outerData: OuterData] ~ {
outerData.controlsY ¬ 0;
outerData.graphicsY ¬ outerData.controlsY+outerData.controlsH;
outerData.tsY ¬ outerData.graphicsY+outerData.graphicsH;
outerData.buttonsY ¬ outerData.tsY+outerData.tsH;
};

SetOuterHeight: PROC [outerData: OuterData] ~ {
outerData.outerH ¬ outerData.controlsH+outerData.graphicsH+outerData.tsH+outerData.buttonsH+capHeight;
};
gGraphicsData: REF ANY;
gGraphicsInput: LIST OF REF ANY;
newGraphicsInputBoolean: BOOL;
newGraphicsInputCondition: CONDITION;

NotifyGraphics: ViewerClasses.NotifyProc ~ {
NewGraphicsInput[GetGraphicsData[self], input];
};

NewGraphicsInput: ENTRY PROC [data: REF ANY, input: LIST OF REF ANY] ~ {
gGraphicsData ¬ data;
gGraphicsInput ¬ input;
newGraphicsInputBoolean ¬ TRUE;
NOTIFY newGraphicsInputCondition;
};

GetGraphicsInput: ENTRY PROC RETURNS [graphics: GraphicsData] ~ {
IF NOT newGraphicsInputBoolean THEN WAIT newGraphicsInputCondition;
newGraphicsInputBoolean ¬ FALSE;
graphics ¬ NARROW[gGraphicsData];
IF gGraphicsInput # NIL
THEN graphics.mouse ¬ Controls.SetMouse[
atom: NARROW[gGraphicsInput.rest.first],
position: WITH gGraphicsInput.first SELECT FROM
p: TIPUser.TIPScreenCoords => [p.mouseX, p.mouseY],
ENDCASE => ERROR];
};

WatchGraphics: CedarProcess.ForkableProc ~ {
DO 
g: GraphicsData ¬ GetGraphicsInput[];
IF g.mouseProc # NIL THEN g.mouseProc[g.mouse, g.viewer, g.clientData];
ENDLOOP;
};

GetGraphicsData: PROC [viewer: Viewer] RETURNS [GraphicsData] ~ {
RETURN[NARROW[viewer.data]];
};

PaintGraphics: ViewerClasses.PaintProc ~ {
v: Viewer;
d: GraphicsData;
d ¬ NARROW[self.data];
v ¬ self;
IF d # NIL AND d.drawProc # NIL THEN d.drawProc[context, d.clientData, whatChanged, v];
};

GraphicsViewer: PUBLIC PROC [
parent: Viewer,
y, h: INTEGER ¬ 0,
mouseProc: MouseProc,
drawProc: DrawProc,
biScrollable: BOOL ¬ FALSE,
clientData: REF ANY]
RETURNS [viewer: Viewer]
~ {
graphicsData: GraphicsData ¬ NEW[GraphicsDataRep ¬ [
mouseProc: mouseProc, drawProc: drawProc, clientData: clientData, parent: parent]];
-- ELSE -- viewer ¬ ViewerOps.CreateViewer[
flavor: $Graphics,
paint: FALSE,
info: [
data: graphicsData,
scrollable: FALSE,
ww: parent.ww,
wy: y,
wh: h,
border: FALSE,
parent: parent]];
graphicsData.viewer ¬ viewer;
ViewerOps.AddProp[viewer, $CreatedInOuterViewer, $True];
};
ClickButton: PUBLIC PROC [
name: ROPE ¬ NIL,
proc: ClickProc ¬ NIL,
clientData: REF ANY ¬ NIL,
row, x, y, w, h: INTEGER ¬ 0,
fork: BOOL ¬ TRUE,
guarded: BOOL ¬ FALSE,
documentation: ROPE ¬ NIL,
font: Font ¬ NIL,
style: ATOM ¬ $BlackOnWhite]
RETURNS [Button] ~ {
RETURN[NEW[ButtonRep ¬ [click, name, row, x, y, w, h, fork, guarded, documentation, font, NIL, clientData, proc, style]]];
};
TextButton: PUBLIC PROC [
name: ROPE ¬ NIL,
text: ROPE ¬ NIL,
proc: ClickProc ¬ NIL,
clientData: REF ANY ¬ NIL,
row, x, y, w, h: INTEGER ¬ 0,
fork: BOOL ¬ TRUE,
documentation: ROPE ¬ NIL,
font: Font ¬ NIL]
RETURNS [b: Button]
~ {
b ¬ NEW[ButtonRep ¬ [text, name, row, x, y, w, h, fork,, documentation, font, NIL, clientData,,, text, proc]];
};
popUpButton: MouseButton ¬ none;

PopUpRequest: PUBLIC PROC [header: Request, requests: LIST OF Request] RETURNS [i: INT] ~ {
Reverse: PROC [in: LIST OF ROPE] RETURNS [out: LIST OF ROPE] ~ {
FOR r: LIST OF ROPE ¬ in, r.rest WHILE r # NIL DO out ¬ CONS[r.first, out]; ENDLOOP;
};
choices, docs: LIST OF ROPE ¬ NIL;
pos: REF ViewerClasses.MouseButton ¬ NEW[ViewerClasses.MouseButton];
FOR r: LIST OF Request ¬ requests, r.rest WHILE r # NIL DO
choices ¬ CONS[r.first.choice, choices];
docs ¬ CONS[r.first.doc, docs];
ENDLOOP;
i ¬ PopUpSelection.Request[header.choice, Reverse[choices], header.doc, Reverse[docs],,, pos];
popUpButton ¬ IF i > 0
THEN SELECT pos­ FROM
red		=> left,
yellow	=> middle,
blue		=> right,
ENDCASE	=> none
ELSE none;
};

BoolRequest: PUBLIC PROC [value: BOOL, title: ROPE] RETURNS [req: Request] ~ {
req.choice ¬ IO.PutFR["%g is %g", IO.rope[title], IO.rope[IF value THEN "On" ELSE "Off"]];
req.doc ¬ IO.PutFR["Turn %g %g", IO.rope[IF value THEN "Off" ELSE "On"], IO.rope[title]];
};

IntRequest: PUBLIC PROC [title, doc: ROPE, value: NAT] RETURNS [Request] ~ {
RETURN[[IO.PutFR["%g (now %g)", IO.rope[title], IO.int[value]], doc]];
};

RealRequest: PUBLIC PROC [title, doc: ROPE, value: REAL] RETURNS [Request] ~ {
RETURN[[IO.PutFR["%g (now %6.3f)", IO.rope[title], IO.real[value]], doc]];
};

RopeRequest: PUBLIC PROC [title, doc, value: ROPE] RETURNS [req: Request] ~ {
req ¬ IF value = NIL
THEN [IO.PutFR1["%g", IO.rope[title]], doc]
ELSE [IO.PutFR["%g (now %g)", IO.rope[title], IO.rope[value]], doc];
};

MultiRequest: PUBLIC PROC [header: ROPE, choices: LIST OF Choice] RETURNS [INT] ~ {
Reverse: PROC [in: LIST OF Request] RETURNS [out: LIST OF Request] ~ {
FOR r: LIST OF Request ¬ in, r.rest WHILE r # NIL DO out ¬ CONS[r.first, out]; ENDLOOP;
};
id, choice, count: NAT ¬ 0;
status: ROPE ¬ NIL;
requests: LIST OF Request ¬ NIL;
FOR l: LIST OF Choice ¬ choices, l.rest WHILE l # NIL DO
IF l.first.true
THEN status ¬ (IF status = NIL
THEN Rope.Concat[header, l.first.state]
ELSE Rope.Cat[status, ", ", l.first.state])
ELSE {
requests ¬ CONS[[Rope.Concat["Change to ", l.first.state]], requests];
l.first.privateId ¬ (id ¬ id+1);
};
ENDLOOP;
choice ¬ Controls.PopUpRequest[[status], Reverse[requests]];
FOR l: LIST OF Choice ¬ choices, l.rest WHILE l # NIL DO
count ¬ count+1;
IF l.first.privateId = choice THEN RETURN[count];
ENDLOOP;
RETURN[-1];
};

GetPopUpButton: PUBLIC PROC RETURNS [MouseButton] ~ {RETURN[popUpButton]};

GetTextButtonText: PUBLIC PROC [outerData: OuterData, name: ROPE] RETURNS [t: ROPE] ~ {
button: Button ¬ ButtonFind[outerData, name];
IF button = NIL
THEN ControlError["Can't find named button"]
ELSE t ¬ ViewerTools.GetContents[button.textViewer];
};

GetTextButtonValue: PUBLIC PROC [outerData: OuterData, name: ROPE] RETURNS [r: REAL] ~ {
r ¬ Convert.RealFromRope[GetTextButtonText[outerData, name]];
};

GetTextButtonsTexts: PUBLIC PROC [outerData: OuterData, name: ROPE]
RETURNS [ropes: RopeSequence]
~ {
IF outerData # NIL AND outerData.buttons # NIL THEN {
i: INT ¬ 0; FOR l: ButtonList ¬ outerData.buttons, l.rest WHILE l # NIL DO i¬i+1; ENDLOOP;
ropes ¬ NEW[RopeSequenceRep[i]];
i ¬ 0;
FOR l: ButtonList ¬ outerData.buttons, l.rest WHILE l # NIL DO
ropes[i] ¬ ViewerTools.GetContents[l.first.textViewer];
i ¬ i+1;
ENDLOOP;
};
};

GetTextButtonsValues: PUBLIC PROC [outerData: OuterData, name: ROPE]
RETURNS [reals: RealSequence]
~ {
IF outerData # NIL AND outerData.buttons # NIL THEN {
i: INT ¬ 0; FOR l: ButtonList ¬ outerData.buttons, l.rest WHILE l # NIL DO i¬i+1; ENDLOOP;
reals ¬ NEW[RealSequenceRep[i]];
i ¬ 0;
FOR l: ButtonList ¬ outerData.buttons, l.rest WHILE l # NIL DO
reals[i] ¬Convert.RealFromRope[ViewerTools.GetContents[l.first.textViewer]];
i ¬ i+1;
ENDLOOP;
};
};

ButtonRelabel: PUBLIC PROC [outerData: OuterData, oldName, newName: ROPE] ~ {
IF outerData # NIL THEN FOR b: ButtonList ¬ outerData.buttons, b.rest WHILE b # NIL DO
IF b.first.type = click AND Rope.Equal[b.first.viewer.name, oldName]
THEN Buttons.ReLabel[b.first.viewer, newName];
ENDLOOP;
};

ButtonToggle: PUBLIC PROC [outerData: OuterData, state: BOOL, trueName, falseName: ROPE]
~ {
IF state
THEN ButtonRelabel[outerData, falseName, trueName]
ELSE  ButtonRelabel[outerData, trueName, falseName];
};

ButtonStyle: PUBLIC PROC [outerData: OuterData, name: ROPE, style: ATOM] ~ {
FOR b: ButtonList ¬ outerData.buttons, b.rest WHILE b # NIL DO
IF b.first.type = click AND Rope.Equal[b.first.viewer.name, name]
THEN Buttons.SetDisplayStyle[b.first.viewer, style];
ENDLOOP;
};

ButtonFind: PUBLIC PROC [outerData: OuterData, name: ROPE] RETURNS [Button] ~ {
FOR b: ButtonList ¬ outerData.buttons, b.rest WHILE b # NIL DO
IF Rope.Equal[b.first.name, name] THEN RETURN[b.first];
ENDLOOP;
RETURN[NIL];
};

ButtonTextProc: ClickProc ~ {
outerData: OuterData ¬ NARROW[clientData];
button: Button ¬ ButtonFind[outerData, parent.name];
IF button.type # text THEN RETURN;
ViewerTools.SetSelection[button.textViewer];
};

ButtonDummyProc: ClickProc ~ {};	-- otherwise Buttons.ButtonPusher dies 

ButtonViewer: PUBLIC PROC [parent: Viewer, button: Button] RETURNS [viewer: Viewer] ~ {
SELECT button.type FROM
click =>
viewer ¬ IF button.clickProc # NIL
THEN
Buttons.Create[
info: [parent: parent, name: button.name, wx: button.x, wy: button.y],
proc: button.clickProc,
clientData: button.clientData,
fork: button.fork,
font: button.font,
documentation: button.documentation,
guarded: button.guarded
]
ELSE
Labels.Create[
info: [parent: parent, border: FALSE, wx: button.x, wy: button.y,
ww: VFonts.StringWidth[button.name, button.font]+8, wh: button.h,
scrollable: FALSE, name: button.name],
font: button.font
];
text => {
labelW: INTEGER ¬ VFonts.StringWidth[button.name, button.font]+8;
v: Viewer ¬ viewer ¬ Containers.Create[info: [parent: parent, name: button.name, wx: button.x, wy: button.y+1, ww: button.w, wh: button.h, scrollable: FALSE]];
v ¬ Buttons.Create[
info: [parent: viewer, name: button.name, border: FALSE, wx: 0, wy: -1, ww: labelW],
proc: ButtonTextProc,
clientData: parent.data,			-- should be outerData!!
fork: button.fork,
font: button.font,
documentation: IF button.guarded THEN button.text ELSE NIL,
guarded: button.guarded
];
button.textViewer ¬ ViewerTools.MakeNewTextViewer[
info: [parent: viewer, border: FALSE, wx: labelW, wy: 0, ww: button.w-labelW, wh: button.h, scrollable: FALSE, data: button.clientData]];
ViewerOps.AddProp[v, $CreatedInOuterViewer, $True];
ViewerOps.AddProp[button.textViewer, $CreatedInOuterViewer, $True];
ViewerOps.AddProp[button.textViewer, $ButtonText, button];
ViewerTools.SetContents[button.textViewer, button.text];
ControlsPrivate.ActivateViewer[button.textViewer];
};
ENDCASE;
ViewerOps.AddProp[viewer, $CreatedInOuterViewer, $True];
};

ButtonsPreparation: PROC [buttons: ButtonList, widthLimit: NAT]
RETURNS [buttonHeight: INTEGER]
~ {
margin: INTEGER ~ 4;
buttonRows: ARRAY [0..maxNRows) OF RECORD [x: INTEGER ¬ margin, y, h: INTEGER ¬ 0];
FOR b: ButtonList ¬ buttons, b.rest WHILE b # NIL DO
font: Font ¬ b.first.font ¬ VFonts.DefaultFont[b.first.font];
IF b.first.h = 0 THEN b.first.h ¬ VFonts.FontHeight[font]+3;
IF b.first.w = 0 THEN b.first.w ¬ VFonts.StringWidth[b.first.name, font]+8;
IF b.first.type = text THEN {
b.first.text ¬ Rope.Concat[b.first.text, " "];  -- MakeNewTextViewer needs padding
b.first.w ¬ b.first.w+VFonts.StringWidth[b.first.text, font]+8;
};
ENDLOOP;
FOR b: ButtonList ¬ buttons, b.rest WHILE b # NIL DO
b.first.row ¬ MAX[0, MIN[maxNRows-1, b.first.row]];
DO
IF MAX[b.first.x, buttonRows[b.first.row].x]+b.first.w < widthLimit THEN EXIT;
IF b.first.row >= maxNRows-2 THEN EXIT;
b.first.row ¬ b.first.row+1;
ENDLOOP;
IF b.first.x = 0
THEN b.first.x ¬ buttonRows[b.first.row].x
ELSE buttonRows[b.first.row].x ¬ b.first.x;
buttonRows[b.first.row].x ¬ b.first.x+b.first.w+margin-1;
buttonRows[b.first.row].h ¬ MAX[buttonRows[b.first.row].h, b.first.h];
ENDLOOP;
buttonRows[0].y ¬ margin+1;
buttonHeight ¬ buttonRows[0].y+buttonRows[0].h+margin;
FOR n: NAT IN [1..maxNRows) DO
IF buttonRows[n].h # 0 THEN buttonHeight ¬ buttonHeight+buttonRows[n].h+margin;
buttonRows[n].y ¬ buttonRows[n-1].y+buttonRows[n].h+margin;
ENDLOOP;
FOR b: ButtonList ¬ buttons, b.rest WHILE b # NIL DO
IF b.first.y = 0 THEN b.first.y ¬ buttonRows[b.first.row].y;
ENDLOOP;
IF buttons = NIL THEN buttonHeight ¬ 0;
};
TypescriptViewer: PROC [parent: Viewer, tsHeight: INTEGER] RETURNS [ts: Viewer] ~ {
arg: ROPE ~ "0 pt restIndent";
ts ¬ TypeScript.Create[[parent: parent, wh: tsHeight, border: FALSE]];
ViewerOps.AddProp[ts, $CreatedInOuterViewer, $True];
TiogaExtraOps.PutProp[TiogaOps.LastWithin[TiogaOps.ViewerDoc[ts]], $Postfix, arg];
};

TypescriptClear: PUBLIC PROC [ts: Typescript] ~ {
IF ts.out # NIL AND NOT ts.clear THEN IO.PutRope[ts.out, "\n"];
ts.clear ¬ TRUE;
};

TypescriptWrite: PUBLIC PROC [ts: Typescript, rope: ROPE] ~ {
IF ts.out = NIL THEN RETURN;
IO.PutRope[ts.out, rope ! IO.Error => CONTINUE];
IO.Flush[ts.out ! IO.Error => CONTINUE];
ts.clear ¬ Rope.FindBackward[rope, "\n"] = Rope.Length[rope]-1;
};

TypescriptRead: PUBLIC PROC [ts: Typescript, prompt: ROPE ¬ NIL] RETURNS [reply: ROPE]
~ {
IF ts.in = NIL THEN RETURN[NIL];
IF ts.out # NIL AND prompt # NIL THEN {
IF NOT ts.clear THEN prompt ¬ Rope.Concat["\n", prompt];
TypescriptWrite[ts, prompt];
};
ViewerTools.SetSelection[ts.viewer];
reply ¬ IO.GetLineRope[ts.in ! IO.Rubout, IO.Error => CONTINUE];
IF reply = NIL THEN TypescriptWrite[ts, ". . . aborted.\n"];
ts.clear ¬ TRUE;
};

TypescriptReadFileName: PUBLIC PROC [ts: Typescript] RETURNS [reply: ROPE] ~ {
Inner: PROC ~ {reply ¬ FileNames.ResolveRelativePath[reply]};
workingDir: ROPE ~ NARROW[ViewerOps.FetchProp[ts.viewer.parent, $WorkingDirectory]];
reply ¬ TypescriptRead[ts, IO.PutFR1["Filename: (dir = %g)  ", IO.rope[workingDir]]];
ProcessProps.AddPropList[Atom.PutPropOnList[NIL, $WorkingDirectory, workingDir], Inner];
IF Rope.IsEmpty[reply] THEN RETURN[NIL];
IF Rope.Fetch[reply, 0] # '/ THEN reply ¬ Rope.Concat[workingDir, reply];
};

TypescriptReadValue: PUBLIC PROC [ts: Typescript, name: ROPE, currentValue: REAL]
RETURNS [newValue: REAL]
~ {
reply: ROPE ¬
TypescriptRead[ts, IO.PutFR["%g (now %g): ", IO.rope[name], IO.real[currentValue]]];
newValue ¬ currentValue;
IF reply # NIL THEN newValue ¬ Convert.RealFromRope[reply !
Convert.Error => {TypescriptWrite[ts, "Bad format.\n"]; CONTINUE}];
};

TypescriptReadValues:  PUBLIC PROC [
ts: Typescript,
prompt: ROPE ¬ NIL,
tsValues: LIST OF TSValue]
RETURNS [reals: RealSequence]
~ {
ENABLE Convert.Error => GOTO BadFormat;
Test: PROC [tsv: TSValue] ~ {
commaV: IO.Value ¬ IO.rope[IF prompt # NIL THEN ", " ELSE NIL];
prompt ¬ SELECT TRUE FROM
named AND NOT once => IO.PutFLR["%g%g%g (now %g)",
LIST[IO.rope[prompt], commaV, IO.rope[tsv.name], IO.real[tsv.value]]],
named AND once => IO.PutFLR["%g%g%g (%g)",
LIST[IO.rope[prompt], commaV, IO.rope[tsv.name], IO.real[tsv.value]]],
ENDCASE => IO.PutFR["%g%g%g", IO.rope[prompt], commaV, IO.real[tsv.value]];
IF named AND NOT once THEN once ¬ TRUE;
};
NextRope: PROC RETURNS [ROPE] ~ {
IF (n0 ¬ Rope.SkipOver[reply, n1, ", \t"]) = Rope.Length[reply] THEN RETURN[NIL];
n1 ¬ Rope.SkipTo[reply, n0, ", \t"];
RETURN[Rope.Substr[reply, n0, n1-n0]];
};
once: BOOL ¬ FALSE;
n0, n1, count: NAT ¬ 0;
reply: ROPE ¬ NIL;
named: BOOL ¬ FALSE;
FOR l: LIST OF TSValue ¬ tsValues, l.rest WHILE l # NIL DO
count ¬ count+1;
IF l.first.name # NIL THEN named ¬ TRUE;
ENDLOOP;
IF NOT named THEN prompt ¬ Rope.Concat[prompt, "(now "];
FOR l: LIST OF TSValue ¬ tsValues, l.rest WHILE l # NIL DO Test[l.first]; ENDLOOP;
prompt ¬ Rope.Concat[prompt, IF named THEN "): " ELSE ": "];
IF (reply ¬ TypescriptRead[ts, prompt]) = NIL THEN RETURN;
reals ¬ NEW[RealSequenceRep[count]];
reals.length ¬ count;
count ¬ 0;
FOR l: LIST OF TSValue ¬ tsValues, l.rest WHILE l # NIL DO
rope: ROPE ¬ NextRope[];
real: REAL ¬ IF rope # NIL THEN Convert.RealFromRope[rope] ELSE l.first.value;
reals[count] ¬ real;
count ¬ count+1;
ENDLOOP;
EXITS BadFormat => TypescriptWrite[ts, "Bad Format"];
};

GetReal: PUBLIC PROC [ts: Typescript, prompt: ROPE, in: REAL] RETURNS [out: REAL] ~ {
reply: ROPE ¬ TypescriptRead[ts, IO.PutFR["%g (now %g): ", IO.rope[prompt], IO.real[in]]];
out ¬ in;
IF reply # NIL THEN out ¬ Convert.RealFromRope[reply !
Convert.Error => {TypescriptWrite[ts, ". . . bad format.\n"]; CONTINUE}];
};

GetNat: PUBLIC PROC [ts: Typescript, prompt: ROPE, in: NAT] RETURNS [out: NAT] ~ {
reply: ROPE ¬ TypescriptRead[ts, IO.PutFR["%g (now %g): ", IO.rope[prompt], IO.card[in]]];
out ¬ in;
IF reply # NIL THEN out ¬ Convert.CardFromRope[reply !
Convert.Error => {TypescriptWrite[ts, ". . . bad format.\n"]; CONTINUE}];
};

GetIntegerPair: PUBLIC PROC [ts: Typescript, prompt: ROPE, in: IntegerPair]
RETURNS [out: IntegerPair]
~ {
ENABLE IO.EndOfStream, IO.Error => GOTO Bad;
reply: ROPE ¬ TypescriptRead[ts, IO.PutFR["%g: (now %g, %g) ",
IO.rope[prompt], IO.int[in.x], IO.int[in.y]]];
out ¬ in;
IF reply # NIL THEN {
s: STREAM ¬ IO.RIS[reply];
out.x ¬ IO.GetInt[s];
out.y ¬ IO.GetInt[s];
};
EXITS Bad => TypescriptWrite[ts, ". . . bad format.\n"];
};

GetTriple: PUBLIC PROC [ts: Typescript, prompt: ROPE, in: Triple] RETURNS [out: Triple] ~ {
ENABLE IO.EndOfStream, IO.Error => GOTO Bad;
reply: ROPE ¬ TypescriptRead[ts, IO.PutFLR["%g: (now %g, %g, %g) ",
LIST[IO.rope[prompt], IO.real[in.x], IO.real[in.y], IO.real[in.z]]]];
out ¬ in;
IF reply # NIL THEN {
s: STREAM ¬ IO.RIS[reply];
out.x ¬ IO.GetReal[s];
out.y ¬ IO.GetReal[s];
out.z ¬ IO.GetReal[s];
};
EXITS Bad => TypescriptWrite[ts, ". . . bad format.\n"];
};
Quit: PUBLIC ClickProc ~ {ViewerOps.DestroyViewer[NARROW[parent, Viewer].parent]};

DestroyOuter: ViewerClasses.DestroyProc ~ {
o: OuterData ¬ NARROW[self.data];
o.destroyed ¬ TRUE;
IF o.destroyProc # NIL THEN o.destroyProc[o.parent, $Unknown, o.clientData];
};

Restore: PUBLIC ClickProc ~ {
outerData: OuterData ¬ NARROW[clientData];
FOR c: ControlList ¬ outerData.controls, c.rest WHILE c # NIL DO
c.first.value ¬ c.first.init;
ViewerOps.PaintViewer[c.first.viewer, client, FALSE, c.first];
ENDLOOP;
};
tipTable: TIPUser.TIPTable ¬ TIPUser.InstantiateNewTIPTable["Controls.tip"];
					
[] ¬ CedarProcess.Fork[WatchGraphics];

ViewerOps.RegisterViewerClass[$Outer, NEW[ViewerClasses.ViewerClassRec ¬ [
paint: PaintOuter,
adjust: AdjustProc,
destroy: DestroyOuter]]];

ViewerOps.RegisterViewerClass[$Graphics, NEW[ViewerClasses.ViewerClassRec ¬ [
notify: NotifyGraphics,
paint: PaintGraphics,
tipTable: tipTable]]];

END.
..

ButtonNewChoice: PUBLIC PROC [
viewer: Viewer, oldAtom, newAtom: REF ANY, newDoc: ROPE]
~ {
instanceSpec: PopUpButtons.InstanceSpec ¬ PopUpButtons.GetInstanceSpec[viewer];
spec: PopUpButtons.ClassSpec ¬ PopUpButtons.GetSpec[instanceSpec.class];
FOR c: PopUpButtons.ChoiceList ¬ spec.choices, c.rest WHILE c # NIL DO
IF c.first.key = oldAtom THEN {c.first.key ¬ newAtom; c.first.doc ¬ newDoc; EXIT};
ENDLOOP;
PopUpButtons.AmbushClass[instanceSpec.class, spec];
};

Extrema: BiScrollers.ExtremaProc ~ {
g: GraphicsData ¬ NARROW[clientData];
[min,max] ¬ Geom2D.ExtremaOfRect[[0, 0, g.viewer.cw, g.viewer.ch], direction];
};

graphicsBiScrollerClass: BiScrollers.BiScrollerClass ¬ BiScrollers.GetStyle[].NewBiScrollerClass[[
flavor: $GraphicsBiScroller,
extrema: Extrema,
notify: NotifyGraphics,
paint: PaintGraphics,
tipTable: tipTable,
mayStretch: FALSE,
offsetsMustBeIntegers: TRUE,
preferIntegerCoefficients: FALSE,
preserve: [X: 0.0, Y: 0.0]
]];


^
ControlsOuterImpl.mesa
Copyright Σ 1985, 1992 by Xerox Corporation.  All rights reserved.
Bloomenthal, July 2, 1992 6:25 pm PDT
Types
Constants
Errors
Outer Procedures
Justify child with respect to top of parent viewer:
IF column = color AND ColorDisplayManager.NextState[].type = NIL THEN column _ left;
Graphics Procedures
p: BiScrollers.ClientCoords => [Real.InlineRoundI[p.x], Real.InlineRoundI[p.y]],
RETURN[IF BiScrollers.ViewerIsABiScroller[viewer]
THEN NARROW[BiScrollers.ClientDataOfViewer[viewer]]
ELSE NARROW[viewer.data]];
IF BiScrollers.ViewerIsABiScroller[self]
THEN {
d _ NARROW[BiScrollers.ClientDataOfViewer[self]];
v _ BiScrollers.QuaViewer[BiScrollers.QuaBiScroller[self], TRUE];
}
ELSE {
};
IF biScrollable
THEN {
bs: BiScrollers.BiScroller _ BiScrollers.GetStyle[].CreateBiScroller[
class: graphicsBiScrollerClass,
info: [
parent: parent,
wx: 0, wy: y,
ww: parent.ww,
wh: h,
data: graphicsData,
border: FALSE,
scrollable: FALSE],
paint: FALSE
];
viewer _ bs.QuaViewer[inner: FALSE];
}
Button Procedures


PopUpButton: PUBLIC PROC [
name: ROPE _ NIL,
proc: PopUpButtonProc _ NIL,
choices: ChoiceList _ NIL,
doc: ROPE _ NIL,
help: Help _ NIL,
clientData: REF ANY _ NIL,
row, x, y, w, h: INTEGER _ 0,
fork: BOOL _ TRUE,
guarded: BOOL _ FALSE,
documentation: ROPE _ NIL,
font: Font _ NIL]
RETURNS [Button] ~ {
RETURN[NEW[ButtonRep _ [popUp, name, row, x, y, w, h, fork, guarded, documentation, font,, clientData,,,,,, proc, choices, doc, help]]];
};

When mouse focus moved from textViewer, button.textProc called by Controls.KillInputFocus
If button.proc is NIL, treat button as a non-bordered label.
popUp => {
class: PopUpButtons.Class _ PopUpButtons.MakeClass[[
classData: button.clientData,
proc: button.popUpProc,
choices: button.choices,
fork: button.fork,
guarded: button.guarded,
image: PopUpButtons.ImageForRope[button.name],
doc: button.doc,
help: button.help]];
viewer _ PopUpButtons.Instantiate[
class,
[parent: parent, name: button.name, border: button.popUpProc # NIL, wx: button.x, wy: button.y],
button.help];
};
Typescript Procedures
The above doesn't always seem to work, so:
ClickProcs
Start Code
Κ#―–
"cedarcode" style•NewlineDelimiter

™š
œ™Jšœ	Οeœ6™BJ™%J˜JšΟk	œvžœ§
˜¨J˜—šΠblœžœ
ž˜ Jšžœažœ—
˜šžœ	˜J˜——Jšœž˜
headš
Οl™Jšœ
žœ˜"Jšœžœ˜)Jšœ
žœ˜'Jšœ
žœ˜"Jšœ
žœ˜'Jšœžœ˜"Jšœžœ˜$Jšœžœ˜+Jšœžœ˜-Jšœžœ˜+Jšœžœ˜%Jšœžœ˜,Jšœžœ˜1Jšœžœ˜+Jšœžœ˜*Jšœ
žœ˜'Jšœ
žœ˜'Jšœžœ˜,Jšœžœ˜,Jšœžœ˜1Jšœžœ˜,Jšœžœ˜1Jšœ	žœ˜$Jšœžœ˜"Jšœ	žœ˜$Jšœžœ˜)Jšœžœ˜.Jšœ
žœ˜Jšžœžœžœ
žœ
˜Jšžœžœžœ
˜Jšœžœ˜.Jšœžœ˜'—š
 	™	Jšœ
ž	œ˜Jšœž	œ˜—š
 ™Jš
Οnœžœ
žœ
žœžœ
˜1—š
 ™š‘œžœ žœžœ˜NJšœ
žœΟc˜1šΟbœ˜ Jšžœžœ
žœ
žœ˜AJ˜—J˜%J˜UJ˜J˜—š‘
œ˜'š‘œžœ˜Jšœžœ˜!Jš
œA˜AJšžœ
žœ
žœ;˜Ršžœžœ
žœž˜3Jšžœ6˜:—Jšžœžœ
žœ>˜VJ˜—Jšžœžœ
žœ>˜WJ˜J˜—š£
œ*žœ ˜ZJ˜—šΠbnœžœžœ˜3Jš‘œ
Οs
žœ₯
œ₯
œ₯
œ₯
œ₯
œ₯
žœ
₯
œ1˜Xš‘œ˜+J™3Jšœžœ˜ šžœ1ž˜6Jšžœ(˜,—J˜—Jšœžœ˜ J˜7J˜	šžœžœ
žœž˜3Jšžœ3˜7—šžœ
žœ
žœ#žœžœ
ž˜NJš
œL˜LJšžœ
˜—Jšžœžœ<˜Rš
žœžœ
žœ
žœžœ˜2Jšœ
žœ
žœ+˜<Jšœžœ
žœ,˜>Jš
œ1˜1š
žœžœ
žœ
žœ
žœ˜,š‘œ˜.Jš
‘
œžœžœžœžœ˜9Jš
œ8˜8J˜—Jšœžœžœžœ
žœžœ˜8Jšœ₯
ž₯
œ
₯
žœžœ
žœžœ˜CJš
œ@˜@J˜—Jšœ&žœ
žœ˜8Jšœ'žœ
žœ˜CJ˜—J˜
J˜J˜—š‘œžœžœ˜GJšœžœ
˜šžœ#žœžœ
ž˜6J˜$Jšžœ
˜—Jšžœ˜J˜J˜—š‘œžœ
žœ2˜Pš‘	œžœ+žœžœ˜Lšžœ#žœžœ
ž˜6Jšžœžœ
žœ
žœ˜(Jšžœ
˜—Jšžœ
žœ˜
J˜—Jšœ	žœžœ
˜J˜"Jšœžœ˜0š	žœ-žœžœ
žœ’˜WJšžœžœžœžœ˜<Jšžœ
˜—šžœ-žœžœ
ž˜@Jšœ(žœ˜/Jšœ'žœ˜.Jšœ(žœ˜/Jšžœ
˜—˜Jš
œ[˜[—šžœ(žœ˜0J˜Jš
œ>˜>J˜>Jšœ*žœ˜0J˜—J˜/šžœ#žœžœ
ž˜6Jš
œG˜GJšžœ
˜—šžœ(žœ˜5Jšžœ'žœžœ˜6—J˜J˜—š‘œžœ
žœ˜Jšœžœžœ
˜J˜Jšœžœ
˜Jšœžœ
˜J˜=Jšœžœ˜Jšœžœ
˜Jšœžœ
˜Jšœžœ
˜Jšœžœ˜Jšœžœžœ
˜Jšœžœ
žœž˜Jšœžœžœ
˜J˜Jšžœ˜Jš
œ˜J˜Jšžœžœ(žœ
žœ™T˜Jšžœ*˜-J˜$Jš
œ+˜+—˜3Jš
œ˜Jšœžœ
˜
š
œ˜Jš
œ˜Jš
œ˜Jšœžœ,˜;Jšœžœ
˜Jš
œ˜Jšœžœ
˜
—J˜—Jšžœžœ˜+Jš
œV˜VJ˜šžœžœ˜Jšœ(žœ˜;J˜@Jšœ/žœ˜7J˜—šžœžœ˜J˜Š
Jšœ.žœ
žœ˜HJšœ/žœ
žœ˜NJ˜=J˜—šžœ+žœžœ
ž˜>J˜;šžœžœ˜9Jšžœ8˜<—Jšžœ
˜—šžœ-žœžœ
ž˜@Jš
œG˜GJšžœ
˜—Jšžœ
žœžœ˜.J˜J˜—š‘
œžœ˜Jšœžœ’˜3J˜Jšœžœ
˜Jšœžœ
˜J˜=Jšœžœ˜Jšœžœ
˜Jšœžœ
˜Jšœžœ
˜Jšœžœ˜Jšœžœ
žœžœ
˜Jšžœ˜šœ
žœžœž˜"Jš
œ"˜"Jš
œ$˜$Jšžœ!˜(—Jšžœ
žœ
žœ˜6J˜/J˜J˜J˜$J˜&J˜:šœžœ(žœ
ž˜JJš
œ!˜!Jšžœžœ
˜—J˜]J˜%J˜!J˜;Jš
œ˜Jšžœ˜J˜J˜—š‘œžœžœžœ˜8šžœ
žœž˜Jš
œ&˜&Jš
œ"˜"Jš
œ$˜$Jšžœ	˜J˜J˜——š‘œžœ˜&J˜J˜>J˜8J˜1J˜J˜—š‘œžœ˜/J˜fJ˜——š
 ™Jšœžœ
žœ
˜Jš	œžœ
žœ
žœ
žœ
˜ Jšœžœ
˜šœž	œ
˜%J˜—š£œ˜,Jš
œ/˜/Jš
œ˜J˜—š£œžœ
žœžœ
žœ	žœ
žœ
žœ
žœ˜HJ˜J˜Jšœžœ
˜Jšžœ˜!Jš
œ˜J˜—š‘œžœ
žœ
žœ˜AJšžœž
œ˜CJšœžœ
˜ Jšœžœ˜!šžœž˜šžœ$˜(Jšœžœ˜(šœ
žœžœ
ž˜/Jš
œ3˜3Jš
œP™PJšžœžœ˜———Jš
œ˜J˜—š‘
œ
ž
œ˜,šžœ
˜J˜%Jšžœžœ
žœ.˜GJšžœ
˜—Jš
œ˜J˜—š‘œžœžœ˜Ašžœ
žœ(™1Jšžœ
žœ(™3Jšžœ
žœ™—Jšžœ
žœ˜Jš
œ˜J˜—š‘
œ˜*J˜
Jš
œ˜šžœ&™(šžœ™Jšœžœ'™1Jšœ;žœ™AJ™
—šžœ™Jšœžœ˜J˜	J™——Jšžœžœ
žœžœ3˜WJ˜J˜—š‘œžœ
žœ˜Jš
œ˜Jšœžœ˜Jš
œ˜Jš
œ˜Jšœžœžœ
˜Jšœžœ
žœ
˜Jšžœ˜Jš
œ˜šœžœ˜4Jš
œS˜S—šžœ
™šžœ™š
œE™EJš
œ™š
œ™Jš
œ™Jš
œ
™
Jš
œ™Jš
œ™Jš
œ™Jšœžœ
™Jšœžœ™—Jšœž™Jš
œ™—Jšœžœ™$J™
—š’Πcs’œ!˜+Jš
œ˜Jšœžœ
˜
š
œ˜Jš
œ˜Jšœžœ
˜J˜J˜J˜Jšœž˜Jš
œ˜———J˜Jš
œ8˜8J˜——š
 ™š‘œžœ˜Jšœžœžœ
˜Jšœžœ
˜Jšœžœ
žœžœ
˜Jšœžœ˜Jšœžœžœ
˜Jšœ	žœžœ
˜Jšœžœžœ
˜Jšœ
žœ
˜Jšœžœ˜Jšžœ
˜Jšžœ
žœPžœ˜zJ˜J™—š‘
œžœ˜Jšœžœžœ
˜Jšœžœžœ
˜Jšœžœ
˜Jšœžœ
žœžœ
˜Jšœžœ˜Jšœžœžœ
˜Jšœžœžœ
˜Jšœ
žœ
˜Jšžœ˜J˜JšœžœGžœ˜nJ˜J™—š‘œžœ™Jšœžœžœ
™Jšœžœ
™Jšœžœ
™Jšœžœžœ
™Jšœ
žœ
™Jšœžœ
žœžœ
™Jšœžœ™Jšœžœžœ
™Jšœ	žœžœ
™Jšœžœžœ
™Jšœ
žœ
™Jšžœ
™Jšžœ
žœ~™ˆ
J™J™—˜ J˜—š‘œžœ
žœžœ
žœ
žœžœ˜[š‘œžœžœ
žœ
žœžœžœ
žœ
žœ˜@Jšžœžœ
žœ
žœžœžœ
žœžœžœ
˜TJ˜—Jš	œžœ
žœ
žœžœ
˜"Jšœžœžœ˜Dšžœžœ
žœžœžœ
ž˜:Jšœ
žœ˜(Jšœžœ˜Jšžœ
˜—J˜^šœžœ˜šžœ
žœž˜J˜
J˜J˜Jšžœ˜—Jšžœ˜
—J˜J˜—š
‘œžœ	žœ	žœžœ˜NJš
œ
žœžœžœžœžœžœ	˜ZJš
œ
žœžœžœžœžœžœ˜YJ˜J˜—š
‘
œžœžœ	žœžœ˜LJšžœžœžœžœ˜FJ˜J˜—š
‘œžœžœ	žœžœ˜NJšžœžœžœžœ˜JJ˜J˜—š‘œžœžœžœ˜Mšœžœ	ž˜Jšžœžœžœ˜+Jšžœžœžœžœ˜D—J˜J˜—š‘œžœ
žœžœ
žœ	žœžœ˜Sš‘œžœžœ
žœ
žœžœ
žœ
˜FJšžœžœ
žœžœžœ
žœžœžœ
˜WJ˜—Jšœžœ˜Jšœžœžœ
˜Jšœ
žœ
žœžœ
˜ šžœžœ
žœžœžœ
ž˜8šžœ
˜šžœžœ
ž˜Jšžœ#˜'Jšžœ'˜+—šžœ˜Jšœžœ7˜FJ˜ J˜——Jšžœ
˜—J˜<šžœžœ
žœžœžœ
ž˜8J˜Jšžœžœ
žœ˜1Jšžœ
˜—Jšžœ˜J˜J˜—š
‘œžœ
žœ
žœžœ˜JJ˜—š‘œžœ
žœžœ
žœžœ˜WJ˜-šžœ
ž˜Jšžœ(˜,Jšžœ0˜4—J˜J˜—š‘œžœ
žœžœ
Πks
ž₯
œ₯
žœ
₯
œ˜XJ˜=J˜J˜—š‘œžœ
žœžœ
˜CJšžœ˜Jš
œ˜š
žœ
žœ
žœžœ
žœ˜5Jšœžœ₯
œžœ+žœžœ
žœžœ
˜ZJšœžœ˜ J˜šžœ+žœžœ
ž˜>J˜7J˜Jšžœ
˜—J˜—J˜J˜—š‘œžœ
žœžœ
˜DJšž₯
œ˜Jš
œ˜š
žœ
žœ
žœžœ
žœ˜5Jšœžœ₯
œžœ+žœžœ
žœžœ
˜ZJšœžœ˜ J˜šžœ+žœžœ
ž˜>Jšœ₯
œC˜LJ˜Jšžœ
˜—J˜—J˜J˜—š‘
œžœ
žœ*žœ˜Mš
žœ
žœ
žœ
žœ+žœžœ
ž˜Všžœžœ)˜DJšžœ*˜.—Jšžœ
˜—J˜J˜—š‘œžœžœžœ
˜XJš
œ˜šžœ˜Jšžœ.˜2Jšžœ0˜4—J˜J˜—š
‘œžœ
žœžœ	žœ˜Lšžœ+žœžœ
ž˜>šžœžœ&˜AJšžœ0˜4—Jšžœ
˜—J˜J˜—š
‘
œžœ
žœžœžœ
˜Ošžœ+žœžœ
ž˜>Jšžœ žœ
žœ
˜7Jšžœ
˜—Jšžœ
žœ˜J˜J˜—š‘œ˜Jšœžœ
˜*J˜4Jšžœžœ
žœ
˜"J˜,Jš
œY™YJ˜J˜—š‘œ’'˜HJ˜—š‘œžœ
žœ"žœ˜WJšœ₯œ'™<šžœ
ž˜˜šœ	žœž˜"š
ž˜š
œ˜Jš
œF˜FJš
œ˜Jš
œ˜J˜J˜Jš
œ$˜$J˜Jš
œ
˜
—š
ž˜š
œ˜šœžœ˜AJš
œA˜AJšœžœ˜&—J˜—Jš
œ˜————˜	Jšœžœ2˜AJšœ—
žœ˜Ÿ
˜Jšœ2žœ˜TJš
œ˜Jšœ’˜3J˜J˜Jš	œžœžœ
žœ
žœ
˜;J˜Jš
œ˜—˜2JšœžœDžœ˜‰
—Jš
œ3˜3Jš
œC˜CJš
œ:˜:J˜8Jš
œ2˜2J˜—™
™4J™J™J™J™J™J™.J™J™—š
œ"™"Jš
œ™Jšœ>žœ™`Jš
œ
™
—J™—Jšžœ
˜—J˜8J˜J˜—š‘œžœ#žœ
˜?Jšžœžœ
˜Jš
œ˜Jšœžœ˜Jšœžœžœ
žœžœžœ˜Sšžœ!žœžœ
ž˜4J˜=Jšžœžœ'˜<Jšžœžœ6˜Kšžœžœ˜Jšœ0’"˜RJ˜?J˜—Jšžœ
˜—šžœ!žœžœ
ž˜4Jšœžœžœ˜3š
ž˜Jšžœ
žœ>žœ
žœ
˜NJšžœžœ
žœ
˜'J˜Jšžœ
˜—šžœ˜Jšžœ&˜*Jšžœ'˜+—J˜9Jšœžœ'˜FJšžœ
˜—J˜J˜6šžœžœ
žœž˜Jšžœžœ4˜OJ˜;Jšžœ
˜—šžœ!žœžœ
ž˜4Jšžœžœ'˜<Jšžœ
˜—Jšžœžœ
žœ˜'J˜——š
 ™š‘œžœžœ
žœ˜SJšœžœ˜Jšœ>žœ˜FJ˜4Jš
œR˜RJ˜J˜—š‘œžœ˜1Jšžœ
žœ
žœ
žœ˜?Jšœžœ
˜J˜J˜—š‘œžœžœ˜=Jšžœ
žœ
žœ
žœ
˜Jšžœžœ
žœ˜0Jšžœžœ
žœ˜(Jšœ"₯
œ₯
œ
₯
œ˜?J˜J˜—š‘œžœ
žœžœžœžœ	žœ
˜VJš
œ˜Jš
žœ	žœ
žœ
žœ
žœ˜ š
žœ
žœ
žœ
žœ
žœ˜'Jšžœ
žœ
žœ$˜8Jš
œ˜J˜—Jš
œ$˜$Jš	œžœžœ	žœ
žœ˜@Jšžœ	žœ)˜<Jšœžœ
˜J˜J˜—š
‘œžœ
žœžœ	žœ˜NJš‘œžœ2˜=Jšœžœžœ;˜TJšœž
œžœ!žœ˜UJšœ,žœ)˜XJ™*Jšžœžœ
žœ
žœ˜(Jšžœžœ(˜IJ˜J˜—š
‘œžœ
žœžœžœ
˜QJšžœžœ
˜Jš
œ˜šœžœ˜
Jšœžœžœ
žœ˜T—J˜šžœ	žœ
žœ(˜;Jšœ8žœ˜C—J˜J˜—š‘œžœ˜$Jš
œ˜Jšœžœžœ
˜Jšœ
žœ
žœ	˜Jšžœ˜Jš
œ˜Jšžœžœ˜'š‘œžœ˜Jšœžœ	žœžœ
žœ
žœžœ
žœ˜?šœ	žœ
žœ
ž˜šœžœ
žœžœ˜2Jšžœ
žœžœžœ˜F—šœžœ	žœ˜*Jšžœ
žœžœžœ˜F—Jšžœžœžœžœ˜K—Jš
žœžœ
žœžœžœ
˜'Jš
œ˜—š‘œžœ
žœ
žœ˜!Jšžœ>žœ
žœ
žœ˜QJ˜$Jšžœ ˜&J˜—Jšœžœžœ
˜Jšœžœ˜Jšœžœžœ
˜Jšœžœžœ
˜šžœžœ
žœžœžœ
ž˜:J˜Jšžœžœ
žœ	žœ
˜(Jšžœ
˜—Jšžœ
žœžœ'˜8Jšžœžœ
žœžœžœ
žœžœ
˜RJšœžœžœžœ˜<Jšžœ(žœ
žœ
˜:Jšœžœ˜$J˜J˜
šžœžœ
žœžœžœ
ž˜:Jšœžœ˜Jšœžœžœžœ
žœžœ˜NJ˜J˜Jšžœ
˜—Jšžœ0˜5J˜J˜—š‘œžœžœžœžœžœ˜UJš	œžœžœžœžœ˜ZJ˜	šžœ	žœ
žœ#˜6Jšœ>žœ˜I—J˜J˜—š‘œžœžœžœ
žœžœ˜RJš	œžœžœžœžœ˜ZJ˜	šžœ	žœ
žœ#˜6Jšœ>žœ˜I—J˜J˜—š‘œžœžœ˜KJšžœ˜Jš
œ˜Jšžœ
žœžœ
žœ˜,šœžœžœ˜>Jšžœžœžœ
˜.—J˜	šžœ	žœ
žœ˜Jšœžœžœ
žœ˜Jšœžœ˜Jšœžœ˜J˜—Jšžœ3˜8J˜J˜—š‘	œžœžœžœ˜[Jšžœ
žœžœ
žœ˜,šœžœžœ ˜CJš
žœ
žœžœ
žœ
žœ˜E—J˜	šžœ	žœ
žœ˜Jšœžœžœ
žœ˜Jšœžœ˜Jšœžœ˜Jšœžœ˜J˜—Jšžœ3˜8J˜——š
 
™
š£œžœ&žœ˜RJ˜—š£œ˜+Jšœžœ˜!Jšœžœ
˜Jšžœžœ
žœ1˜LJš
œ˜J˜—š£œžœ˜Jšœžœ
˜*šžœ-žœžœ
ž˜@J˜Jšœ.žœ˜>Jšžœ
˜—Jš
œ˜——š
 
™
˜LJš
’˜—˜&J˜—šœ&žœ!˜JJš
œ˜Jš
œ˜š
œ˜J˜——šœ)žœ!˜MJš
œ˜Jš
œ˜Jš
œ˜—J˜—Jšžœ
˜J˜J˜š‘œžœ˜Jšœ"žœ
žœ
žœ
˜8Jš
œ˜J˜OJ˜Hšžœ3žœžœ
ž˜FJšžœžœ/žœ˜RJšžœ
˜—Jš
œ3˜3J˜J˜—š‘œ˜$Jšœžœ
˜%Jšœ	ž
œ
ž
œB˜NJš
œ˜J˜—˜bJš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœžœ
˜Jšœžœ
˜Jšœžœ
˜!Jš
œ˜š
œ˜J˜——J˜—…—nš!