DIRECTORY
BasicTime USING [GMT],
Buttons USING [Button, ButtonProc, Create],
Commander USING [CommandProc, Register],
Containers USING [ChildXBound, Container, Create],
FS USING [ComponentPositions, ExpandName],
Icons USING [IconFlavor, NewIconFromFile],
Imager USING [Context, Create, NewPage, SpecialOp],
ImagerBridge USING [SetViewFromGraphicsContext],
ImagerPD USING [Gnat, Hornet, PDFileDescription, PlateMaker, Puffin, Raven, ReticleMaker],
IO USING [Close, int, PutChar, PutF, PutFR, PutRope, rope, STREAM, time],
IP USING [State],
IPExtras USING [DoPage, OpenMaster, PageCount],
IPUtils USING [ToEncoded, ToWritten],
Loader USING [BCDBuildTime],
Menus USING [AppendMenuEntry, CreateEntry, CreateMenu, Menu, MenuProc],
Process USING [Pause, SecondsToTicks],
Rope USING [Concat, Find, ROPE, Substr],
Rules USING [Create, Rule],
ViewerClasses USING [PaintProc, Viewer, ViewerClass, ViewerClassRec],
ViewerIO USING [CreateViewerStreams],
ViewerOps USING [CreateViewer, PaintViewer, RegisterViewerClass],
ViewerTools USING [MakeNewTextViewer, GetContents, SetContents, SetSelection];

IPTool: CEDAR MONITOR
LOCKS data USING data: Data
IMPORTS Buttons, Commander, Containers, FS, Icons, Imager, ImagerBridge, ImagerPD, IO, IPExtras, IPUtils, Loader, Menus, Process, Rope, Rules, ViewerIO, ViewerOps, ViewerTools = {

-- Here is the layout of the tool --
--========================================================================--
--                               Interpress                               --
--========================================================================--
-- Load  Show  Next  Write  Read  LoadSelection                           --
--========================================================================--
-- Master:  Test.Interpress           Written:  Test.IPWritten            --
-- Page: 2                                                                --
--========================================================================--
-- Interpress Tool of March 31, 1983                                      --
--  Test.Interpress -> WTest.Interpress                                   --
--                                                                        --
--                                                                        --
--                                                                        --
--                                                                        --
--========================================================================--

-- Here is the layout of a page viewer --
--========================================================================--
--                       Test.Interpress, page 3                          --
--========================================================================--
--                                                                        --
--                                                                        --
--                                 . . .                                  --
--                                                                        --
--========================================================================--

ROPE: TYPE = Rope.ROPE;
STREAM: TYPE = IO.STREAM;
Viewer: TYPE = ViewerClasses.Viewer;
Button: TYPE = Buttons.Button;

Data: TYPE = REF DataRep;
DataRep: TYPE = MONITORED RECORD [ -- the data for a particular tool instance
outer: Containers.Container _ NIL, -- handle for the enclosing container
busy: BOOL _ FALSE,
height: NAT _ 0, -- height measured from the top of the container
logViewer: Viewer, -- contains error log
log: STREAM, -- output stream for writing to error log
masterButton: Button, -- Master: button
masterField: Viewer, -- contains name of Master file
writtenButton: Button, -- Written: button
writtenField: Viewer, -- contains name of Written file
pageButton: Button, -- Page: button
pageField: Viewer, -- contains page number
page: Viewer, -- viewer for showing a page
masterName: ROPE, -- name of current master
pageNumber: NAT, -- current page number
state: IP.State -- state of the Interpress interpreter
];

Lock: ENTRY PROC[data: Data] RETURNS[BOOL] = INLINE {
IF data.busy THEN RETURN[FALSE]
ELSE RETURN[data.busy _ TRUE];
};
Unlock: ENTRY PROC[data: Data] = INLINE {
data.busy _ FALSE
};

lineHeight: CARDINAL = 15; -- how tall to make each line of items
lineLeading: CARDINAL = 2; -- vertical leading space between lines
totalWidth: CARDINAL = 444; -- width of the entire viewer
margin: CARDINAL = 8; -- left and right margins
entryHSpace: CARDINAL = 10; -- horizontal space between items in a line

MakeIPTool: Commander.CommandProc = { CreateTool[] };

CreateTool: PROC = {
data: Data = NEW[DataRep];
menu: Menus.Menu = MakeMenu[data];
buildTime: BasicTime.GMT ~ Loader.BCDBuildTime[CreateTool];
data.outer _ Containers.Create[[-- construct the outer container'
name: "Interpress Tool", -- name displayed in the caption
menu: menu,
iconic: FALSE,
column: right, -- initially in the right column
scrollable: FALSE
]];
MakeFilePart[data];
MakeRule[data, 1];
MakeLogPart[data, 100];
data.page _ CreatePage[data];
data.log.PutF["Interpress Tool of %g\n", IO.time[buildTime]];
ViewerOps.PaintViewer[data.outer, all]; -- reflect above change
};

PageData: TYPE = REF PageDataRep;
PageDataRep: TYPE = RECORD[w: NAT]; -- instance data for Interpress viewers 

CreatePage: PROC[data: Data] RETURNS[ViewerClasses.Viewer] = {
viewer: ViewerClasses.Viewer = ViewerOps.CreateViewer[
flavor: $Page,
info: [
name: "Interpress Page",
data: data,
iconic: FALSE,
column: left,
scrollable: FALSE
]
];
RETURN[viewer];
};

LongOperation: PROC[log: STREAM, n: NAT] = {
THROUGH [0..n) DO
log.PutChar['.];
Process.Pause[Process.SecondsToTicks[1]];
ENDLOOP;
};

MakeMenu: PROC[data: Data] RETURNS[Menus.Menu] = {
menu: Menus.Menu = Menus.CreateMenu[];
Menus.AppendMenuEntry[menu: menu,
entry: Menus.CreateEntry[name: "Load",
proc: LoadProc, clientData: data]
];
Menus.AppendMenuEntry[menu: menu,
entry: Menus.CreateEntry[name: "Show",
proc: ShowProc, clientData: data]
];
Menus.AppendMenuEntry[menu: menu,
entry: Menus.CreateEntry[name: "Next",
proc: NextProc, clientData: data]
];
Menus.AppendMenuEntry[menu: menu,
entry: Menus.CreateEntry[name: "Print",
proc: PrintProc, clientData: data]
];
Menus.AppendMenuEntry[menu: menu,
entry: Menus.CreateEntry[name: "PrintAll",
proc: PrintAllProc, clientData: data]
];
Menus.AppendMenuEntry[menu: menu,
entry: Menus.CreateEntry[name: "Write",
proc: WriteProc, clientData: data]
];
Menus.AppendMenuEntry[menu: menu,
entry: Menus.CreateEntry[name: "Read",
proc: ReadProc, clientData: data]
];
RETURN[menu];
};

PaintPageViewer: PROC[data: Data] = {
page: Viewer = data.page;
page.name _ IO.PutFR["%g, page %g", IO.rope[data.masterName], IO.int[data.pageNumber]];
ViewerOps.PaintViewer[viewer: page, hint: all];
[] _ IPExtras.DoPage[data.state, data.pageNumber];
};

pdType: ATOM _ $Hornet;

GetPDFileDescription: PROC[fileName: ROPE] RETURNS[ImagerPD.PDFileDescription] ~ {
RETURN[SELECT pdType FROM
$Hornet => ImagerPD.Hornet[fileName],
$Raven => ImagerPD.Raven[fileName],
$Gnat => ImagerPD.Gnat[fileName],
$PlateMaker => ImagerPD.PlateMaker[fileName],
$ReticleMaker => ImagerPD.ReticleMaker[fileName],
$Puffin => ImagerPD.Puffin[fileName],
ENDCASE => ImagerPD.Hornet[fileName]]
};

PrintPage: PROC[data: Data] = {
log: STREAM ~ data.log;
self: IP.State ~ data.state;
screen: Imager.Context ~ self.imager;
masterName: ROPE ~ data.masterName;
pdName: ROPE ~ PDName[masterName];
page: NAT ~ data.pageNumber;
pd: Imager.Context _ NIL;
log.PutF["Writing page %g of %g to %g ...",
IO.int[page], IO.rope[masterName], IO.rope[pdName]];
self.imager _ pd _ Imager.Create[$PD, GetPDFileDescription[pdName]];
[] _ IPExtras.DoPage[self, page];
[] _ Imager.SpecialOp[pd, $Close, NIL];
log.PutRope["done.\n"];
self.imager _ screen;
};

PrintAll: PROC[data: Data] = {
log: STREAM ~ data.log;
self: IP.State ~ data.state;
screen: Imager.Context ~ self.imager;
masterName: ROPE ~ data.masterName;
pdName: ROPE ~ PDName[masterName];
count: NAT ~ IPExtras.PageCount[self];
pd: Imager.Context _ NIL;
log.PutF["Writing %g to %g (%g pages) ...",
IO.rope[masterName], IO.rope[pdName], IO.int[count]];
self.imager _ pd _ Imager.Create[$PD, GetPDFileDescription[pdName]];
FOR page: NAT IN[1..count] DO
log.PutF[" %g", IO.int[page]];
[] _ IPExtras.DoPage[self, page];
IF page<count THEN Imager.NewPage[pd];
ENDLOOP;
[] _ Imager.SpecialOp[pd, $Close, NIL];
log.PutRope[" done.\n"];
self.imager _ screen;
};

PDName: PROC[name: ROPE] RETURNS[ROPE] = {
fname: ROPE; cp: FS.ComponentPositions;
[fullFName: fname, cp: cp] _ FS.ExpandName[name];
RETURN[fname.Substr[len: cp.base.start+cp.base.length].Concat[".pd"]];
};

Extend: PROC[name: ROPE, ext: ROPE] RETURNS[ROPE] = {
RETURN[IF name.Find["."]<0 THEN name.Concat[ext] ELSE name];
};

LoadMaster: PROC[data: Data] = {
name: ROPE = ViewerTools.GetContents[data.masterField];
file: ROPE = Extend[name, ".Interpress"];
log: STREAM = data.log;
log.PutF["Loading %g...", IO.rope[file]];
data.state _ IPExtras.OpenMaster[file, Imager.Create[$LFDisplay]];
log.PutRope["done.\n"];
data.state.log _ log;
data.masterName _ name;
data.pageNumber _ 1;
};

Do: PROC[proc: PROC[Data], data: Data] = {
IF Lock[data] THEN {
proc[data ! UNWIND => Unlock[data]];
Unlock[data];
};
};

LoadProc: Buttons.ButtonProc = {
Do[LoadMaster, NARROW[clientData]];
};

ShowProc: Menus.MenuProc = {
Do[PaintPageViewer, NARROW[clientData]];
};

PrintProc: Menus.MenuProc = {
Do[PrintPage, NARROW[clientData]];
};

PrintAllProc: Menus.MenuProc = {
Do[PrintAll, NARROW[clientData]];
};

NextProc: Menus.MenuProc = {
Next: PROC[data: Data] = {
n: NAT = data.pageNumber;
count: NAT = IPExtras.PageCount[data.state];
SELECT mouseButton FROM
red, yellow => {
IF n<count THEN {
data.pageNumber _ n+1;
PaintPageViewer[data];
};
};
blue => {
IF n>1 THEN {
data.pageNumber _ n-1;
PaintPageViewer[data];
};
};
ENDCASE;
};
Do[Next, NARROW[clientData]];
};

WriteProc: Menus.MenuProc = {
Write: PROC[data: Data] = {
master: ROPE = Extend[ViewerTools.GetContents[data.masterField], ".Interpress"];
written: ROPE = Extend[ViewerTools.GetContents[data.writtenField], ".Interpress"];
log: STREAM = data.log;
Dot: PROC = { log.PutChar['.] };
log.PutRope[IO.PutFR["%g -> %g ", IO.rope[master], IO.rope[written]]];
IPUtils.ToWritten[master, written, Dot];
log.PutRope["done\n"];
};
Do[Write, NARROW[clientData]];
};

ReadProc: Menus.MenuProc = {
Read: PROC[data: Data] = {
master: ROPE = Extend[ViewerTools.GetContents[data.masterField], ".Interpress"];
written: ROPE = Extend[ViewerTools.GetContents[data.writtenField], ".Interpress"];
log: STREAM = data.log;
Dot: PROC = { log.PutChar['.] };
log.PutRope[IO.PutFR["%g -> %g ", IO.rope[written], IO.rope[master]]];
IPUtils.ToEncoded[written, master, Dot];
log.PutRope["done\n"];
};
Do[Read, NARROW[clientData]];
};


MakeRule: PROC[data: Data, height: NAT] = {
rule: Rules.Rule _ Rules.Create[ [ -- create a horizontal rule to separate sections
parent: data.outer,
wy: data.height,
ww: data.outer.cw,
wh: height
]];
Containers.ChildXBound[data.outer, rule];
data.height _ rule.wy + rule.wh + lineLeading; -- spacing after rule
};

TSOpen: PROC[viewer: Viewer] RETURNS[STREAM] = {
in, out: STREAM;
[in: in, out: out] _ ViewerIO.CreateViewerStreams[name: NIL,
viewer: viewer, backingFile: NIL, editedStream: FALSE];
in.Close[];
RETURN[out];
};

MakeLogPart: PROC[data: Data, height: NAT] = {
viewer: Viewer = ViewerOps.CreateViewer[
flavor: $Typescript,
info: [parent: data.outer,
ww: totalWidth, wy: data.height, wh: height,
scrollable: TRUE, border: FALSE]
];
Containers.ChildXBound[data.outer, viewer];
data.logViewer _ viewer;
data.log _ TSOpen[viewer]; -- open an output stream on the typescript
data.height _ viewer.wy + viewer.wh + lineLeading; -- spacing after typescript
};

buttonBorders: BOOL _ TRUE;

MakeFilePart: PROC[data: Data] = {
middle: NAT = totalWidth/2;
rightEdge: NAT = totalWidth;
x: NAT _ margin; -- current x
y: NAT _ data.height; -- current y
container: Viewer = data.outer;
AddButton: PROC[name: ROPE, proc: Buttons.ButtonProc] RETURNS[Button] = {
button: Button = Buttons.Create[
info: [parent: container, name: name, 
wx: x, wy: y, wh: lineHeight,
border: buttonBorders],
proc: proc, clientData: data
];
x _ button.wx+button.ww+entryHSpace;
RETURN[button];
};
AddPrompt: PROC[name: ROPE, proc: Buttons.ButtonProc] RETURNS[Button] = {
button: Button = Buttons.Create[
info: [parent: container, name: name, 
wx: x, wy: y, wh: lineHeight,
border: FALSE],
proc: proc, clientData: data
];
x _ button.wx+button.ww; -- no extra space
RETURN[button];
};
AddField: PROC[nextX: NAT] RETURNS[Viewer] = {
field: Viewer = ViewerTools.MakeNewTextViewer[
info: [parent: container,
wx: x, wy: y+1, ww: nextX-entryHSpace-x, wh: lineHeight,
scrollable: TRUE, border: FALSE]
];
x _ nextX;
RETURN[field];
};
NextLine: PROC = { y _ y+lineHeight+lineLeading; x _ margin; };
data.masterButton _ AddPrompt["Master:", MasterPrompt];
data.masterField _ AddField[rightEdge];
NextLine[];
data.writtenButton _ AddPrompt["Written:", WrittenPrompt];
data.writtenField _ AddField[rightEdge];
NextLine[];
data.height _ y;
};

MasterPrompt: Buttons.ButtonProc = {
data: Data = NARROW[clientData];
IF mouseButton=blue THEN ViewerTools.SetContents[data.masterField, NIL];
ViewerTools.SetSelection[data.masterField]; -- force the selection
};

WrittenPrompt: Buttons.ButtonProc = {
data: Data = NARROW[clientData];
IF mouseButton=blue THEN ViewerTools.SetContents[data.writtenField, NIL];
ViewerTools.SetSelection[data.writtenField]; -- force the selection
};

PagePrompt: Buttons.ButtonProc = {
data: Data = NARROW[clientData];
IF mouseButton=blue THEN ViewerTools.SetContents[data.pageField, NIL];
ViewerTools.SetSelection[data.pageField]; -- force the selection
};

PutLine: PROC[data: Data, rope: ROPE] = {
log: STREAM = data.log;
log.PutRope[rope];
log.PutChar['\n];
};

PaintPage: ViewerClasses.PaintProc = {
data: Data = NARROW[self.data];
state: IP.State = data.state;
IF state#NIL THEN ImagerBridge.SetViewFromGraphicsContext[state.imager, context];
};

pageIcon: Icons.IconFlavor = Icons.NewIconFromFile["Interpress.icons", 2];

pageClass: ViewerClasses.ViewerClass = NEW[ViewerClasses.ViewerClassRec _ [
paint: PaintPage, icon: pageIcon]];
ViewerOps.RegisterViewerClass[$Page, pageClass];
Commander.Register[key: "Interpress", proc: MakeIPTool,
doc: "Create an Interpress tool" ];

}.


IPTool.mesa

Last edited by:
Doug Wyatt, March 9, 1984 4:26:19 pm PST
build each (sub)viewer in turn
Menus.AppendMenuEntry[menu: menu,
entry: Menus.CreateEntry[name: "LoadSelection",
proc: LoadSelectionProc, clientData: data]
];
LoadSelectionProc: Menus.MenuProc = {
LoadSelection: PROC[data: Data] = {
selection: ROPE = ViewerTools.GetSelectionContents[];
log: STREAM = data.log;
ViewerTools.SetContents[data.masterField, "Selection"];
log.PutRope[" Parsing selection ..."];
{ IPUtils.RopeToMaster[selection, "Selection.Interpress" ! ANY => GOTO Fail];
log.PutRope["ok\n"];
LoadMaster[data];
EXITS Fail => log.PutRope["failed\n"];
};
};
Do[LoadSelection, NARROW[clientData]];
};

Register the Interpress class of viewer with the Window Manager

Register a command with the executive.
�Êâ˜Jš
œ™J™š
œ™Jš
œ(™(—J˜š
Ïk	˜	Jšœ
�œ�œ˜Jšœ�œ˜+Jšœ
�œ˜(Jšœ�œ"˜2Jš�œ
�œ"˜*Jšœ�œ˜*Jšœ�œ'˜3Jšœ
�œ˜0Jšœ	�œL˜ZJš�œ
�œ3�œ˜IJš�œ
�œ	˜Jšœ	�œ!˜/Jšœ�œ˜%Jšœ�œ˜Jšœ�œ<˜GJšœ�œ˜&Jšœ�œ�œ
˜(Jšœ�œ˜Jšœ�œ2˜EJšœ	�œ˜%Jšœ
�œ2˜AJšœ�œ=˜NJ˜—Jšœ�œ
�˜Jš�œ�œ˜š�œ!�œ)�œ^˜³
J˜—š
Ïc$˜$Jš
ÏfL˜LJš
ŸL˜LJš
ŸL˜LJš
ŸL˜LJš
ŸL˜LJš
ŸL˜LJš
ŸL˜LJš
ŸL˜LJš
ŸL˜LJš
ŸL˜LJš
ŸL˜LJš
ŸL˜LJš
ŸL˜LJš
ŸL˜LJš
ŸL˜L—J˜š
ž)˜)Jš
ŸL˜LJš
ŸL˜LJš
ŸL˜LJš
ŸL˜LJš
ŸL˜LJš
ŸL˜LJš
ŸL˜LJš
ŸL˜L—J˜Jš�œ�œ�œ
˜Jš�œ�œ�œ
�œ
˜Jšœ�œ˜$Jšœ�œ˜J˜Jšœ�œ�œ	˜šœ	�œ�	œ
�œž*˜MJšœ�œž%˜HJšœ�œ�œ
˜Jšœ�œž0˜AJšœž˜(Jšœ�œž)˜6Jšœžœž˜'Jšœž˜4Jšœžœ	ž˜)Jšœž ˜6Jšœžœž˜#Jšœž˜*Jšœž˜*Jšœ�œž˜+Jšœ�œž˜'Jšœ�œž&˜6Jš
œ˜—J˜šÏnœ�œ
�œ
�œ
�œ�œ˜5Jš�œ�œ
�œ
�œ
˜Jš�œ
�œ
�œ˜J˜—š œ�œ
�œ�œ˜)Jšœ�˜J˜—J˜Jšœ�œž&˜AJšœ
�œž'˜BJšœ�œž˜9Jšœ�œž˜/Jšœ
�œž+˜GJ˜Jš 
œ+˜5J˜š 
œ�œ˜Jšœ
�œ
˜Jš
œ"˜"Jšœ�œ#˜;šœ ž œ
˜AJšœž ˜9Jš
œ˜Jšœ�œ
˜Jšœž ˜/Jšœ�˜Jš
œ˜—Jš
œ™Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœ)�œ˜=Jšœ(ž˜?Jš
œ˜—J˜Jšœ
�œ�œ
˜!Jšœ
�œ�œ�œž(˜LJ˜š 
œ�œ
�œ˜>š
œ6˜6Jš
œ˜š
œ˜J˜Jš
œ˜Jšœ�œ
˜J˜
Jšœ�˜Jš
œ
˜
—Jš
œ˜—Jš�œ	˜Jš
œ˜—J˜š 
œ�œ�œ�œ˜,š�œ�˜Jš
œ˜J˜)Jš�œ
˜—J˜—J˜š œ�œ
�œ˜2J˜&š
œ!˜!š
œ&˜&Jš
œ!˜!—J˜—š
œ!˜!š
œ&˜&Jš
œ!˜!—J˜—š
œ!˜!š
œ&˜&Jš
œ!˜!—J˜—š
œ!˜!š
œ'˜'Jš
œ"˜"—J˜—š
œ!˜!š
œ*˜*Jš
œ%˜%—J˜—š
œ!˜!š
œ'˜'Jš
œ"˜"—J˜—š
œ!˜!š
œ&˜&Jš
œ!˜!—J˜—š
œ!™!š
œ/™/Jš
œ*™*—J™—Jš�œ˜
J˜—J˜š œ�œ˜%J˜Jšœ�œ�œ�œ˜WJš
œ/˜/Jš
œ2˜2J˜J˜—Jšœ�œ˜J˜š œ�œ�œ�œ ˜Rš�œ
�œ�˜J˜%J˜#J˜!J˜-Jš
œ1˜1Jš
œ%˜%Jš�œ˜%—J˜J˜—š 	œ�œ˜Jšœ�œ˜Jšœ�œ˜J˜%Jšœ�œ˜#Jšœ�œ˜"Jšœ�œ˜Jšœ�œ
˜š
œ+˜+Jš�œ�œ�œ˜4—Jš
œD˜DJš
œ!˜!Jšœ"�œ˜'Jš
œ˜J˜J˜J˜—š œ�œ˜Jšœ�œ˜Jšœ�œ˜J˜%Jšœ�œ˜#Jšœ�œ˜"Jšœ�œ˜&Jšœ�œ
˜š
œ+˜+Jš�œ�œ�œ
˜5—Jš
œD˜Dš�œ�œ
�œ�˜Jšœ�œ˜Jš
œ!˜!Jš�œ�œ˜&Jš�œ
˜—Jšœ"�œ˜'Jš
œ˜J˜J˜J˜—š
 œ�œ�œ�œ
�œ˜*Jšœ�œ�œ˜'Jšœ�œ˜1Jš�œ@˜FJ˜J˜—š œ�œ�œ�œ�œ
�œ˜5Jš�œ
�œ�œ�œ˜<J˜—J˜š 
œ�œ˜ Jšœ�œ-˜7Jšœ�œ˜)Jšœ�œ˜Jšœ�œ
˜)Jš
œB˜BJš
œ˜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˜—Jš�œ
˜—J˜—Jšœ	�œ˜Jš
œ˜—J˜š 	œ˜š œ�œ˜Jšœ�œD˜PJšœ	�œE˜RJšœ�œ˜Jš œ�œ˜ Jšœ�œ8˜FJš
œ(˜(Jš
œ˜J˜—Jšœ
�œ˜Jš
œ˜—J˜š œ˜š œ�œ˜Jšœ�œD˜PJšœ	�œE˜RJšœ�œ˜Jš œ�œ˜ Jšœ�œ8˜FJš
œ(˜(Jš
œ˜J˜—Jšœ	�œ˜Jš
œ˜—J˜š œ™%š 
œ�œ™#Jšœ�œ&™5Jšœ�œ™J™7Jš
œ&™&šœ;�œ�œ™MJš
œ™J™Jš�œ!™&J™—J™—Jšœ�œ™&Jš
œ™—J˜š œ�œ�œ˜+šœ#ž0˜SJš
œ˜Jš
œ˜Jš
œ˜Jš
œ
˜
Jš
œ˜—Jš
œ)˜)Jšœ/ž˜DJš
œ˜—J˜š œ�œ�œ
�œ˜0Jšœ	�œ
˜šœ8�œ
˜<Jšœ�œ�œ˜7—J˜Jš�œ˜J˜—J˜š œ�œ�œ˜.˜(J˜˜Jš
œ,˜,Jšœ�œ
�œ
˜ —Jš
œ˜—Jš
œ+˜+J˜Jšœž*˜EJšœ3ž˜NJš
œ˜—J˜Jšœ�œ�œ
˜J˜š œ�œ˜"Jšœ�œ˜Jšœ�œ˜Jšœ�œž˜Jšœ�œž˜"J˜š 	œ�œ�œ�œ˜I˜ š
œ&˜&Jš
œ˜Jš
œ˜—Jš
œ˜Jš
œ˜—Jš
œ$˜$Jš�œ	˜J˜—š 	œ�œ�œ�œ˜I˜ š
œ&˜&Jš
œ˜Jšœ�œ˜—Jš
œ˜Jš
œ˜—Jšœž˜*Jš�œ	˜J˜—š œ�œ�œ�œ˜.š
œ.˜.š
œ˜Jš
œ8˜8Jšœ�œ
�œ
˜ —Jš
œ˜—Jš
œ
˜
Jš�œ˜J˜—Jš œ�œ1˜?Jš
œ7˜7Jš
œ'˜'J˜Jš
œ:˜:Jš
œ(˜(J˜Jš
œ˜Jš
œ˜—J˜š œ˜$Jšœ
�œ
˜ Jš�œ�œ+�œ˜HJšœ,ž˜BJš
œ˜—J˜š 
œ˜%Jšœ
�œ
˜ Jš�œ�œ,�œ˜IJšœ-ž˜CJš
œ˜—J˜š 
œ˜"Jšœ
�œ
˜ Jš�œ�œ)�œ˜FJšœ*ž˜@Jš
œ˜—J˜š œ�œ�œ˜)Jšœ�œ˜Jš
œ˜Jš
œ˜J˜—J˜š 	œ˜&Jšœ
�œ˜Jšœ�œ˜Jš�œ�œ
�œ@˜QJš
œ˜—J˜J˜JJ˜šœ'�œ!˜KJš
œ#˜#—J™Jš
œ?™?Jš
œ0˜0J™Jš
œ&™&˜7J˜#—J˜J˜J˜J˜—…—8`KZ