DIRECTORY
Atom USING [GetPName],
CD, 
CDDraw,
CDEvents,
CDExtras,
CDBasics,
CDPanel,
CDSequencer USING [Command, CommandRec, ExecuteCommand],
CDTipEtc,
CDDefaults,
CDVFurtherPainters,
CDVPrivate, 
CDViewer,
CDVScale,
Cursors,
InputFocus USING [SetInputFocus],
PrincOps USING [BBTableSpace],
PrincOpsUtils,
Process USING [Detach, Yield],
CedarProcess USING [SetPriority, Priority],
Rope USING [ROPE, Concat],
RuntimeError USING [UNCAUGHT],
SafeStorage USING [ReclaimCollectibleObjects],
TerminalIO,
TIPUser USING [TIPScreenCoords],
UserProfile,
ViewerClasses,
ViewerEvents USING [EventProc, RegisterEventProc],
ViewerOps USING [CreateViewer, RegisterViewerClass, PaintViewer, BlinkIcon, EnumProc, EnumerateViewers],
WindowManager USING [colorDisplayOn];

CDVMain: CEDAR MONITOR 
IMPORTS 
Atom, CedarProcess, CDDraw, CDEvents, CDExtras, CDBasics, CDPanel, CDVFurtherPainters, CDVScale, CDSequencer, CDTipEtc, CDDefaults, CDViewer, CDVPrivate, InputFocus, PrincOpsUtils, Process, Rope, RuntimeError, SafeStorage, TerminalIO, UserProfile, ViewerEvents, ViewerOps, WindowManager 
EXPORTS CDVPrivate 
SHARES CDVFurtherPainters =
BEGIN
  
greeting: Rope.ROPE = "ChipNDale    Version 2.1 for Cedar 6.0 ";
date: Rope.ROPE = "September 16, 1985";
copyRight: Rope.ROPE = "Copyright (C) 1984, 1985 by Xerox Corporation.  All rights reserved.\n";

-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

viewerClassAtom: ATOM = $ChipNDale;
MyGraphicRef: TYPE = CDVPrivate.MyGraphicRef;

-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

terminalLock: BOOLEAN _ FALSE;

TerminalLock: PROC [] = {
terminalLock _ TRUE; 
viewerClassRec.cursor _ cursorWhileInput
};

TerminalFree: PROC [] ={
terminalLock _ FALSE; 
SetCursor[]
};


TrackRef: TYPE = REF TrackRecord; --type to force cursor tracking
TrackRecord: TYPE = RECORD [
pos: CD.Position
];

RepaintRectAreaRef: TYPE = REF RepaintRectArea; --type to force drawing a rectangular aera
RepaintRectArea: TYPE = RECORD[
rect: CD.Rect _ CDBasics.universe,
erase: BOOL _ FALSE
];

tryToPaint: CONDITION; 

viewerClassRec: ViewerClasses.ViewerClass;

cursoredCDViewer: PUBLIC ViewerClasses.Viewer _ NIL;
inputFocussedViewer: ViewerClasses.Viewer _ NIL;
lastInputFocussedViewer: ViewerClasses.Viewer _ NIL;

cursorWithFocus: Cursors.CursorType = textPointer;
cursorNoFocus: Cursors.CursorType = pointDown;
cursorWhileInput: Cursors.CursorType = questionMark;

SetCursor: PROC [] = INLINE {
viewerClassRec.cursor _ (
IF terminalLock THEN cursorWhileInput
ELSE IF cursoredCDViewer=inputFocussedViewer THEN cursorWithFocus
ELSE  cursorNoFocus
);
};

-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

LastViewer: PUBLIC PROC [] RETURNS [ViewerClasses.Viewer] =
BEGIN
RETURN [lastInputFocussedViewer]
END;

Paint: ViewerClasses.PaintProc =
BEGIN
ENABLE {
CDVPrivate.notSupportedColorMode => GOTO errorExit;
RuntimeError.UNCAUGHT => 
IF CDVPrivate.catchAnyWhichDeadlock THEN GOTO errorExit ELSE REJECT;
};
me: MyGraphicRef = NARROW[self.data];

TrackRefTrack: ENTRY PROC [me: MyGraphicRef, tr: TrackRef] =  -- INLINE -- 
BEGIN 
ENABLE UNWIND => NULL;
IF me.cursorInhibitations=0 THEN {
IF me.onVC THEN me.usedCursor[me]
ELSE {
me.startVC _ me.designRec.startLC;
me.firstHorizontalVC _ me.designRec.firstHLC; 
me.designRec.currentLayer _ CDDefaults.CurrentLayer[me.actualDesign];
me.defaultWidthVC _ me.designRec.widthLC _
CDDefaults.LayerWidth[me.actualDesign, me.designRec.currentLayer];
me.onVC _ TRUE;
};
me.usedCursor _ me.designRec.outlineProcLC;
me.stopVC _ tr.pos;
me.usedCursor[me];  
};   
END;

RemoveTrack: ENTRY PROC[me: MyGraphicRef] = 
BEGIN 
ENABLE UNWIND => NULL;
IF me.onVC THEN {
me.usedCursor[me]; 
me.onVC _ FALSE;
};
END;

SetUpAndRedraw: ENTRY PROC[me: MyGraphicRef] = 
BEGIN 
ENABLE UNWIND => NULL;
CDDraw.FlushCommands[me.ct];
me.onVC _ FALSE;  --erasing viewer automaticaly makes cursor invisible
CDVPrivate.CreateDrawInformation[me];
me.saveList _ NIL;
CDDraw.ModifyCommandTable[me.actualDesign, me.ct, me.deviceDrawRef.interestClip];
CDDraw.InsertCommand[me.ct, 
CDDraw.Comm[cmd: all, erase: TRUE, rect: CDBasics.universe, ref: NIL]
];
END;

IF self.destroyed THEN RETURN;
me.viewContext _ context;
WITH whatChanged SELECT FROM
tr: TrackRef => TrackRefTrack[me, tr]; -- called by Notify
atom: ATOM => {
IF atom=$RemoveTrack THEN RemoveTrack[me]
ELSE CDVFurtherPainters.CallFurther[me, atom]; 
};
area: RepaintRectAreaRef => -- protected by ProtectedRepaint
CDVPrivate.RepaintRectAreaInViewer[me, area.rect, area.erase];
ENDCASE =>  {
IF whatChanged=NIL THEN SetUpAndRedraw[me] -- called from anywhere, not protected
ELSE CDVFurtherPainters.CallFurther[me, whatChanged];
}
EXITS errorExit => NULL;
END; 

-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

--local-- EnableCursoring: ENTRY PROC[me: MyGraphicRef] = 
INLINE BEGIN  
ENABLE {
UNWIND => NULL;
RuntimeError.UNCAUGHT => {
BROADCAST tryToPaint; 
IF CDVPrivate.catchAnyWhichDeadlock THEN GOTO errorExit ELSE REJECT
};
};
me.cursorInhibitations _ me.cursorInhibitations-1;
BROADCAST tryToPaint
EXITS errorExit => NULL;
END;

ProtectedRepaint: PROC[me: MyGraphicRef, whatChanged: REF ANY] =
BEGIN
ENABLE RuntimeError.UNCAUGHT => {
EnableCursoring[me];
IF CDVPrivate.catchAnyWhichDeadlock THEN GOTO errorExit ELSE REJECT
};

DisableCursoring: ENTRY PROC[me: MyGraphicRef] RETURNS [mustRemoveCursor: BOOL] = 
INLINE BEGIN 
ENABLE {
UNWIND => NULL;
RuntimeError.UNCAUGHT => {BROADCAST tryToPaint; REJECT};
}; 
me.cursorInhibitations _ me.cursorInhibitations+1;
WHILE me.cursorInhibitations>1 DO 
me.cursorInhibitations _ me.cursorInhibitations-1;
WAIT tryToPaint;
me.cursorInhibitations _ me.cursorInhibitations+1;
ENDLOOP;
mustRemoveCursor _ me.onVC;
END;

IF DisableCursoring[me].mustRemoveCursor THEN RemoveCursor[me];
ViewerOps.PaintViewer[me.viewer, client, FALSE, whatChanged];
EnableCursoring[me];
EXITS errorExit => NULL;
END;   

-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

ViewerProcess: PROC[me: MyGraphicRef] =
BEGIN
comm: REF CDDraw.Comm ~ NEW[CDDraw.Comm];
bBTableSpace1, bBTableSpace2: PrincOps.BBTableSpace; 
IF me.running THEN ERROR;
TRUSTED {
me.pBBptr _ PrincOpsUtils.AlignedBBTable[@bBTableSpace1];
me.xBBptr _ PrincOpsUtils.AlignedBBTable[@bBTableSpace2]
};
me.running _ TRUE;
DO
comm^ _ CDDraw.FetchCommand[me.ct];
SELECT comm.cmd FROM
rect => {
paintArea: RepaintRectAreaRef _ NEW[RepaintRectArea_[comm.rect, comm.erase]];
ProtectedRepaint[me, paintArea];
};
all => {
paintArea: RepaintRectAreaRef _ NEW[RepaintRectArea_[comm.rect, TRUE]];
ProtectedRepaint[me, paintArea];
};
ref => ProtectedRepaint[me, comm];
alldone => { 
ProtectedRepaint[me, $Temporaries];
CedarProcess.SetPriority[CedarProcess.Priority[background]];
SafeStorage.ReclaimCollectibleObjects[suspendMe: FALSE];
};
none => Process.Yield[]; 
disapearforever => EXIT;
ENDCASE => ProtectedRepaint[me, comm];
ENDLOOP;
me.running _ FALSE;
me.ct _ NIL;
me.actualDesign _ NIL;
me.designRec _ NIL;
TerminalIO.WriteRope["Viewer destroyed\n"];
END;

-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

SlowDown: PROC [v: ViewerClasses.Viewer] =
BEGIN
IF v#NIL THEN {
WITH v.data SELECT FROM
me: MyGraphicRef => {
me.hurryUp _ FALSE;
me.slowDown _ TRUE;
me.check _ TRUE;
me.deviceDrawRef.b1 _ TRUE;
};
ENDCASE => NULL;
}
END;

SpeedUp: PROC [v: ViewerClasses.Viewer] =
BEGIN
IF v#NIL THEN {
WITH v.data SELECT FROM
me: MyGraphicRef => {
me.slowDown _ FALSE;
me.hurryUp _ TRUE;
me.check _ TRUE;
me.deviceDrawRef.b1 _ TRUE;
};
ENDCASE => NULL;
}
END;

RemoveCursor: PROC [me: MyGraphicRef] =
INLINE BEGIN
IF me.onVC THEN 
ViewerOps.PaintViewer[me.viewer, client, FALSE, $RemoveTrack];
END;

Modify: ViewerClasses.ModifyProc -- PROC [self: Viewer, change: ModifyAction] -- =
BEGIN
ENABLE UNWIND => NULL;
SELECT change FROM
set, pop => lastInputFocussedViewer _ inputFocussedViewer _ self;
kill, push => inputFocussedViewer _ NIL;
ENDCASE => NULL;
SetCursor[];
END;

Notify: ViewerClasses.NotifyProc 
-- PROC [self: Viewer, input: LIST OF REF ANY] -- = 
BEGIN
ENABLE RuntimeError.UNCAUGHT => 
IF CDVPrivate.catchAnyWhichDeadlock THEN GOTO errorExit ELSE REJECT;

me: MyGraphicRef = NARROW[self.data];
mouse: CD.Position_[0, 0]; --be a little robust and initialize, there are crazy tiptables.

LogicalTrack: PROC [me: MyGraphicRef, pos: CD.Position] = INLINE
BEGIN
IF NOT me.designRec.startLCValid THEN {
me.designRec.startLC _ pos; 
me.designRec.startLCValid _ TRUE;
}
END;

LogicalTrackOff: PROC [me: MyGraphicRef, pos: CD.Position] = INLINE
BEGIN
me.designRec.stopLC _ pos;
me.designRec.startLCValid _ FALSE; 
END;

Track: PROC [me: MyGraphicRef] = 
BEGIN

VisibleTrack: PROC [me: MyGraphicRef, pos: CD.Position] = INLINE
BEGIN
tr: TrackRef ~ NEW[TrackRecord];
tr.pos _ pos;
ViewerOps.PaintViewer[me.viewer, client, FALSE, tr];
END;

pos: CD.Position = CDVScale.ViewerToDesignPosition[me.scale, mouse];
LogicalTrack[me, pos];
IF me.cursorInhibitations#0 THEN RETURN;
VisibleTrack[me, pos]
END;

StopTrack: PROC [me: MyGraphicRef] = 
BEGIN
pos: CD.Position = CDVScale.ViewerToDesignPosition[me.scale, mouse];
me.hurryUp _ TRUE;
LogicalTrackOff[me, pos]; 
RemoveCursor[me];
CDVPrivate.SetCursorMode[me, NIL];
END;

IF self#cursoredCDViewer THEN {
tem: ViewerClasses.Viewer = cursoredCDViewer;
IF me.deviceDrawRef=NIL THEN {
RETURN
};
IF tem#NIL AND tem.data#NIL THEN {
temMe: MyGraphicRef = NARROW[tem.data];
RemoveCursor[temMe];
};
cursoredCDViewer _ self;
SetCursor[];
};
DO -- loop over input list: 
IF input=NIL THEN EXIT;
WITH input.first SELECT FROM
coords: TIPUser.TIPScreenCoords => {
mouse.x _ MIN[MAX[coords.mouseX, 0], me.viewer.cw-1]; 
mouse.y _ MIN[MAX[coords.mouseY, 0], me.viewer.ch-1];
};
atom: ATOM => 
IF atom=$Track THEN Track[me] 
ELSE IF terminalLock THEN {
IF atom#$StopTrack THEN ViewerOps.BlinkIcon[self]; 
RETURN
}
ELSE {
IF self#inputFocussedViewer THEN {
SlowDown[inputFocussedViewer];
InputFocus.SetInputFocus[self];
SpeedUp[self];
IF atom=$CloseReSelectOnlyP THEN RETURN; 
};
SELECT atom FROM
$StopTrack => StopTrack[me];
$UseCursor => { --command involving 2 atoms
RemoveCursor[me];
input _ input.rest;
IF input=NIL THEN RETURN;
CDVPrivate.SetCursorMode[me, input.first]
};
$StopDrawing => CDDraw.FlushCommands[me.ct];
ENDCASE => { -- standard commands
StopTrack[me];
TRUSTED {Process.Detach[FORK CDSequencer.ExecuteCommand[
design: me.actualDesign, 
comm: NEW[CDSequencer.CommandRec_CDSequencer.CommandRec[
design: me.actualDesign,
a: atom,
pos: me.designRec.stopLC,
sPos: me.designRec.startLC,
l: me.designRec.currentLayer,
ref: me,
n: me.defaultWidthVC,
b: me.designRec.firstHLC
]]]]
}; --trusted
}; --endcase
}; --atom
ENDCASE;
input _ input.rest
ENDLOOP;
EXITS errorExit => NULL;
END; 


CaptionText: PROC [design: CD.Design] RETURNS [Rope.ROPE] =
BEGIN
TechnologyName: PROC [t: CD.Technology] RETURNS [Rope.ROPE] = INLINE {
RETURN [IF t.name#NIL THEN t.name ELSE Atom.GetPName[t.key]]
};
name: Rope.ROPE;
IF design=NIL THEN RETURN["nil design"];
name _ Rope.Concat[(IF design.name#NIL THEN design.name ELSE "no name"), "   ("];
name _ Rope.Concat[name, TechnologyName[design.technology]]; 
name _ Rope.Concat[name, ")   cell: "];
name _ Rope.Concat[name, CDExtras.PushedCellName[design]];
RETURN [name]
END;   

RepaintCaptions: CDEvents.EventProc =
BEGIN
name: Rope.ROPE = CaptionText[design];
FOR l: CDViewer.ViewerList _ CDViewer.ViewersOf[design], l.rest WHILE  l#NIL DO
me: MyGraphicRef = NARROW [l.first.data];
l.first.name _ name;
ViewerOps.PaintViewer[l.first, caption];
IF event=$AfterPop OR event=$AfterPush THEN { 
CDDraw.InsertCommand[me.ct, CDDraw.Comm[cmd: all, erase: TRUE, rect: CDBasics.universe, ref: NIL]]
}
ENDLOOP;
END;   

CreateViewer: PUBLIC PROC[design: CD.Design] RETURNS [ViewerClasses.Viewer]= 
BEGIN
b: CD.Rect _ CDExtras.BoundingBox[design]; 
me: MyGraphicRef = CDVPrivate.NewAndLink[design];
me.ct _ CDDraw.CreateCommandTable[me.actualDesign, [1, 1, 0, 0], me.stoprequest];
TRUSTED {Process.Detach[FORK ViewerProcess[me]]};
[] _ CDPanel.CreatePanel[design];
WHILE NOT me.running DO Process.Yield[] ENDLOOP;
me.viewer _ ViewerOps.CreateViewer[
flavor: viewerClassAtom,
info: [
name: CaptionText[design],	
scrollable: FALSE,
icon: CDTipEtc.GetIcon[design],
iconic: FALSE,
column: ColumnForNewViewer[],
tipTable: CDTipEtc.GetTipTable[design], 
data: me
]
];
IF CDBasics.NonEmpty[b] THEN CDViewer.ShowAndScale[me.viewer, b];
RETURN [me.viewer]
END; 

ColumnForNewViewer: PROC [] RETURNS [col: ViewerClasses.Column_left] =
BEGIN
found: BOOL _ FALSE;
CheckTheColorScreen: ViewerOps.EnumProc = {
IF v.column=color AND ~v.iconic AND ~v.offDeskTop THEN {
found _ TRUE; 
RETURN[FALSE]
};
};
IF WindowManager.colorDisplayOn AND 
UserProfile.Boolean["ChipNDale.FirstViewerOnColor", TRUE] THEN { 
ViewerOps.EnumerateViewers[CheckTheColorScreen];
IF ~found THEN col _ color
}
END;

Destroy: ViewerClasses.DestroyProc = 
-- PROC [self: Viewer]  
BEGIN
me: MyGraphicRef ~ NARROW[self.data];
CDVPrivate.UnLink[me];
CDDraw.DestroyCommandTable[me.ct];
self.data _ NIL
END; 

CallOnClose: ViewerEvents.EventProc =
BEGIN
me: MyGraphicRef ~ NARROW[viewer.data];
IF event#close THEN ERROR;
CDDraw.ModifyCommandTable[me.actualDesign, me.ct, CDBasics.empty];
END; 

-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

Init: PROC [] =
BEGIN
TerminalIO.AddLock[TerminalLock, TerminalFree];
viewerClassRec _ NEW[ViewerClasses.ViewerClassRec _ [
paint: Paint,
notify: Notify,
modify: Modify,
destroy: Destroy,
cursor: cursorNoFocus
]];
ViewerOps.RegisterViewerClass[viewerClassAtom, viewerClassRec];
[] _ ViewerEvents.RegisterEventProc[proc: CallOnClose, event: close, filter: viewerClassAtom, before: FALSE];
CDEvents.RegisterEventProc[$ResetDesign, RepaintCaptions];
CDEvents.RegisterEventProc[$RenameDesign, RepaintCaptions];
CDEvents.RegisterEventProc[$AfterPush, RepaintCaptions];
CDEvents.RegisterEventProc[$AfterPop, RepaintCaptions];
TerminalIO.WriteRope[greeting];
TerminalIO.WriteRope[date];
TerminalIO.WriteLn[];
TerminalIO.WriteRope[copyRight];
END;

Init[];
END.


´CDVMain.mesa   (part of ChipNDale)
Copyright c 1983, 1985 by Xerox Corporation.  All rights reserved.
Ch. Jacobi,  June 24, 1983 3:33 pm
last edited by Christian Jacobi,  September 16, 1985 5:38:40 pm PDT
--monitoring rule: aquire the ViewerLock first, the monitor's entry lock only after.
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
--PROC [self: Viewer, context: Imager.Context, whatChanged: REF ANY, clear: BOOL]
--depending on whatChanged, the call must be protected or need not.
--Never call with modules entry monitor lock set.
--now me.onVC is true
--called through anybody anytime;
--reset viewer data and then sets up a buffered request for redrawing
-- erase to allow also backgrounds of arbitrary patterns or colors
--Paint
--logically local to ProtectedRepaint
--is outside to make callable from catch-phrase
--does:
--remove cursor and disables any cursoring process
--let only one client come through
--and enters protected region.
--ProtectedRepaint
--me.xBLT is a short pointer! (hardware) therefore must be local to some
--procedure space.
--do the garbage collection now, when not to much else is to do,
--and also all the allocations of the drawing can be freed
--order important
--order important
--removes visible cursor, if there is
--monitores inside viewerpaintproc 
-- ENTRY ommitted since sequential already by viewer package 
--makes cursor logically available
--makes cursor logically unavailable
--uses intermediate layer variable mouse
--makes cursor visible
--Track
--uses intermediate layer variable mouse
--Notify
--silly Cedar Viewer package allows calls of notify before
--the first call to the paintprocedure happened;
--but in ChipNDale, some initializations happens in paintprocedure only.
--luckyli at that time cursoredCDViewer#self; so here is the only
--place to check. 
--FOR input _ input, input.rest WHILE input # NIL DO 
--is programmed explicitely because internally input is changed also
-- range test, because some crazy tiptables call coords without having had a mouse action first 
-- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
--CaptionText
-- PROC [event: REF, design: CD.Design, x: REF] 
-- repaint captions and sometimes the contents
--redraw everything, because 
--		after pop: cell change may have propagated
--		after push: background features must be redrawn greyish
--must wait until me.xBLT is initialized by ViewerProcess
--normal creation
--selects colordisplay if it is on and free
--PROC [v: Viewer] RETURNS [BOOL _ TRUE] -- 
-- PROC [viewer: ViewerClasses.Viewer, event: ViewerEvent, before: BOOL] RETURNS [abort: BOOL _ FALSE]
--Initialization
�ÊÙ˜š
œ"™"Jšœ
Ïm
œ7™BJš
œ"™"Jš
œC™C—J˜š
Ïk	˜	Jšœžœ˜Jšžœ˜J˜J˜	Jš
œ	˜	J˜	J˜Jšœžœ'˜8J˜	J˜Jš
œ˜Jš
œ˜Jš
œ	˜	J˜	J˜Jšœžœ˜!Jšœ	žœ˜Jš
œ˜Jšœžœ˜Jšœ
žœ˜+Jšœžœžœ
˜Jšœ
žœžœ˜Jšœžœ˜.Jš
œ˜Jšœžœ˜ Jš
œ˜Jš
œ˜Jšœ
žœ ˜2Jšœ
žœY˜hJšœžœ˜%J˜—šÏbœžœ
žœ
˜Jš
œT™Tšžœ
˜Jš
œŸ˜Ÿ—Jšžœ˜Jšžœ˜—Jš
ž˜J˜Jšœžœ-˜@Jšœžœ˜'JšœžœL˜`J˜JšÏcœ
 œ
 œ
 œ
 œ
 œ
 œ
 œ
 ˜5J˜Jšœžœ˜#Jšœžœ˜-J˜Jš œ
 œ
 œ
 œ
 œ
 œ
 œ
 œ
 ˜5J˜Jšœžœžœ
˜J˜šÏnœžœ˜Jšœžœ˜Jš
œ(˜(Jš
œ˜—J˜š¡œžœ˜Jšœž˜Jš
œ˜Jš
œ˜—J˜Jš
œ2™2J˜Jšœ
žœžœ ˜Ašœ
žœžœ˜Jšœžœ	˜J˜J˜—Jšœžœžœ *˜Zšœžœžœ
˜Jšœžœ˜"Jšœžœž˜J˜—J™Jš
œ2™2J˜Jšœž	œ˜J˜J˜*J™Jš
œ2™2J˜Jšœžœžœ
˜4Jšœ,žœ
˜0Jšœ0žœ
˜4˜Jš
œ2˜2Jš
œ.˜.Jš
œ4˜4—J˜š¡	œžœžœ˜š
œ˜Jšžœžœ˜%Jšžœ
žœ&žœ˜AJšžœ˜Jš
œ˜—J˜—J˜Jš
œ5˜5J˜š¡
œžœ
žœžœ˜;Jš
ž˜Jšžœ˜ Jšžœ
˜—J˜šŸœ˜ Jš
œQ™QJš
œC™CJš
œ1™1š
ž˜šžœ˜Jšœ$žœ˜3šœ
žœ˜Jš
žœ"žœ
žœžœ
žœ
˜D—J˜——Jšœžœ˜%J˜š¡
œžœ
žœ% œ
˜Kšžœ
˜Jšžœ
žœžœ
˜—šžœžœ˜"Jšžœ	žœ˜!šžœ˜Jš
œ"˜"Jš
œ.˜.Jš
œE˜Eš
œ*˜*Jš
œB˜B—Jšœ
žœ
˜J˜—Jš
œ™Jš
œ+˜+Jš
œ˜J˜J˜—Jšžœ
˜J˜—š¡œžœ
žœ˜,šžœ
˜Jšžœ
žœžœ
˜—šžœ	žœ˜J˜Jšœ
žœ
˜J˜—Jšžœ
˜—J˜š¡œžœ
žœ˜/Jš
œ!™!J™Ešžœ
˜Jšžœ
žœžœ
˜—Jš
œ˜Jšœ
žœ 4˜FJš
œ%˜%Jšœžœ
˜š
œQ˜QJš
œB™B—š
œ˜Jšœžœ žœ
˜EJš
œ˜—Jšžœ
˜—J˜Jš
œ™Jšžœžœ
žœ
˜J˜šžœ
žœ
ž˜Jšœ' ˜:šœžœ˜Jšžœžœ˜)Jšžœ+˜/J˜—šœ  ˜<Jš
œ>˜>—šžœ˜
Jšžœ
žœ
žœ &˜QJšžœ1˜5J˜
——Jšžœžœ
˜Jšžœ˜—J˜Jš œ
 œ
 œ
 œ
 œ
 œ
 œ
 œ
 ˜5˜šÐbc	œ
¡œžœ
žœ˜:Jš
œ%™%J™/šžœ
žœ˜šžœ˜Jšžœžœ
˜šœ
žœ˜Jšž	œ
˜Jš	žœ"žœ
žœžœ
ž˜CJš
œ˜—J˜——Jš
œ2˜2Jšž	œ˜Jšžœžœ
˜Jšžœ
˜J˜——š¡œžœ žœ
žœ˜@š
œ™Jš
œ2™2Jš
œ"™"—š
ž˜šžœžœ˜!Jš
œ˜Jš	žœ"žœ
žœžœ
ž˜CJš
œ˜——J˜š
¡œžœ
žœžœžœ˜RJš
œ™šžœ
˜
šžœ
ž
˜Jšžœžœ
˜Jšœ
žœž	œ
žœ˜8J˜——J˜2šžœžœ
˜"J˜2Jšžœ˜J˜2Jšžœ
˜—Jš
œ˜Jšžœ
˜J˜—Jš
œ™Jšžœ'žœ˜?Jšœ)žœ˜=J˜Jšžœžœ
˜Jšžœ˜—J˜Jš œ
 œ
 œ
 œ
 œ
 œ
 œ
 œ
 ˜5J˜š¡
œžœ˜'Jš
ž˜Jšœžœžœ˜)š
œ5˜5Jš
œH™HJš
œ™—Jšžœžœ
žœ
˜šžœ˜	Jš
œ9˜9Jš
œ8˜8Jš
œ˜—Jšœ
žœ
˜š
ž˜J˜#šžœ
ž˜˜	Jšœ žœ*˜MJš
œ ˜ Jš
œ˜—˜Jšœ žœžœ˜GJš
œ ˜ Jš
œ˜—Jš
œ"˜"š
œ
˜
Jš
œ#˜#Jš
œ<˜<Jš
œ@™@J™:Jšœ1žœ˜8Jš
œ˜—J˜Jšœžœ
˜Jšžœ˜&—Jšžœ
˜Jšœ
žœ
˜Jšœžœ
˜Jšœžœ
˜Jšœžœ
˜J˜+—Jšžœ
˜J˜—Jš œ
 œ
 œ
 œ
 œ
 œ
 œ
 œ
 ˜5J˜š¡œžœ˜*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˜š¡œ /œ˜RJš
ž˜Jšžœ
žœžœ
˜šžœž˜Jš
œA˜AJšœ#žœ
˜(Jšžœžœ
˜—Jš
œ˜Jšžœ
˜—J˜šŸœ˜!Jš 1œ˜4Jš
œ=™=š
ž˜šžœžœ˜ Jš
žœ"žœ
žœžœ
žœ
˜D——J˜Jšœžœ˜%Jšœžœ @˜ZJ˜š¡œžœžœ
ž˜@Jš
œ"™"Jš
ž˜šžœ
žœžœ˜'Jš
œ˜Jšœžœ
˜!J˜
—Jšžœ
˜J˜—š¡œžœžœ
ž˜CJš
œ$™$Jš
ž˜Jš
œ˜Jšœžœ˜#Jšžœ
˜J˜—š¡œžœ˜!Jš
œ(™(Jš
ž˜J˜š¡œžœžœ
ž˜@Jš
œ™Jš
ž˜Jšœžœ˜ J˜
Jšœ)žœ˜4Jšžœ
˜J˜—Jš
œ™Jšœžœ=˜DJ˜Jšžœž˜(J˜Jšžœ
˜J˜—š¡	œžœ˜%Jš
œ(™(Jš
ž˜Jšœžœ=˜DJšœ
žœ
˜Jš
œ˜Jš
œ˜Jšœžœ˜"Jšžœ
˜J˜—Jš
œ™šžœžœ˜Jš
œ-˜-šžœžœ
žœ˜Jš
œ:™:Jš
œ0™0Jš
œH™HJš
œA™AJš
œ™Jš
ž˜J˜—š
žœžœ
žœ
žœ
žœ˜"Jšœžœ˜'Jš
œ˜J˜—Jš
œ˜Jš
œ˜Jš
œ˜—šžœ
 ˜Jš
œ5™5Jš
œD™DJšžœžœ
žœ
žœ
˜šžœ
žœ
ž˜˜$Jš
œ`™`Jšœ
žœ
žœ%˜6Jšœ
žœ
žœ$˜5J˜—šœžœ˜Jšžœ
žœ˜šžœ
žœžœ˜Jšžœžœ˜3Jš
ž˜J˜
—šžœ˜šžœžœ˜"Jš
œ˜Jš
œ˜Jš
œ˜Jšžœžœ
žœ˜)J˜—šžœž˜J˜šœ ˜+Jš
œ˜Jš
œ˜Jšžœžœ
žœ
žœ
˜Jš
œ)˜)J˜—Jš
œ,˜,šžœ ˜!J˜šžœžœ˜8Jš
œ˜šœžœ/˜8J˜J˜Jš
œ˜Jš
œ˜Jš
œ˜J˜J˜Jš
œ˜Jš
œ˜—Jšœ 	˜—Jšœ 	˜—Jšœ ˜	——Jšžœ
˜——Jš
œ˜Jšžœ
˜—Jšžœžœ
˜Jšžœ˜—J˜Jš
œ8™8J˜š
¡œžœ
žœ	žœžœ˜;Jš
ž˜š¡œžœžœ
žœžœžœ˜FJš
žœžœžœ
žœžœ˜<Jš
œ˜—Jš
œ
™
Jšœžœ
˜Jšžœžœ
žœ
žœ˜(Jš	œžœ
žœ
žœ
žœ˜QJ˜=J˜'J˜:Jšžœ˜
Jšžœ˜J˜—šŸœ˜%Jš
œ0™0Jš
œ.™.Jš
ž˜Jšœžœ˜&šžœ=žœžœ
ž˜OJšœžœ˜)J˜J˜(šžœžœžœ˜.Jš
œ™Jš
œ.™.Jš
œ;™;Jšœ9žœ žœ˜bJ˜
—Jšžœ
˜—Jšžœ˜J˜—š
¡œžœ
žœ	žœ	žœ˜MJš
ž˜Jšœžœ&˜+Jš
œ1˜1J˜QJšžœžœ˜1J˜!Jš
œ9™9Jšžœ
žœžœžœ
˜0Jš
œ™˜#Jš
œ˜˜J˜Jšœžœ
˜Jš
œ˜Jšœžœ
˜Jš
œ˜Jš
œ(˜(J˜J˜
—J˜—Jšžœžœ%˜AJšžœ˜Jšžœ˜—J˜š¡œžœžœ#˜FJš
œ+™+Jš
ž˜Jšœžœžœ
˜šŸœ˜+Jš
œ,™,šžœžœžœžœ˜8Jšœžœ˜Jšžœ
žœ
˜
Jš
œ˜—Jš
œ˜—šžœžœ
˜$Jšœ4žœžœ˜AJš
œ0˜0Jšžœžœ˜J˜
—Jšžœ
˜—J˜šŸœ˜%Jš œ
˜Jš
ž˜Jšœžœ˜%Jš
œ˜J˜"Jšœž˜Jšžœ˜—J˜šŸœ˜%Jšœžœ<žœ
ž	œžœžœ
™fJš
ž˜Jšœžœ˜'Jšžœ
žœ
žœ
˜Jš
œB˜BJšžœ˜—J˜Jš
¡;˜;Jš
œ™J˜š¡œžœ˜Jš
ž˜J˜/šœžœ!˜5Jš
œ
˜
J˜Jš
œ˜J˜Jš
œ˜J˜—Jš
œ?˜?Jšœfžœ˜mJ˜:J˜;J˜8J˜7Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ ˜ Jšžœ
˜—J˜Jš
œ˜Jšžœ
˜J˜—…—6jU÷