DIRECTORY
CD, 
CDCacheBase,
CDCells,
CDCellsBackdoor,
CDDefaultProcs,
CDDirectory,
CDEvents,
CDBasics,
CDOps,
CDProperties,
CDRects,
CDValue,
IO,
Properties,
Random,
RefTab,
Rope,
SymTab,
TerminalIO;

CDDirectoryImpl: CEDAR MONITOR 
IMPORTS CD, CDDirectory, CDCells, CDCellsBackdoor, CDDefaultProcs, CDEvents, CDBasics, CDOps, CDProperties, CDRects, CDValue, IO, Properties, Random, RefTab, Rope, SymTab, TerminalIO
EXPORTS CDDirectory, CDCacheBase
SHARES CD, CDRects = 
BEGIN


SetOwner: PUBLIC PROC [design: CD.Design, object: CD.Object, check: BOOL_TRUE] = {
x: REF _ (IF design=NIL THEN NIL ELSE design.cdDirectoryPriv2);
IF check THEN 
SELECT CDProperties.GetObjectProp[object, ownerKey] FROM
x => RETURN; 
NIL => {}; 
ENDCASE => ERROR CD.Error[directoryInvariant, "object in different design"]; 
IF object.immutable AND design#NIL THEN ERROR CD.Error[calling, "don't set ownership of immutable object"];
CDProperties.PutObjectProp[object, ownerKey, x];
};

IsOwner: PUBLIC PROC [design: CD.Design, object: CD.Object] RETURNS [BOOL] = {
x: REF ~ (IF design=NIL THEN NIL ELSE design.cdDirectoryPriv2);
SELECT CDProperties.GetObjectProp[object, ownerKey] FROM
x => RETURN [TRUE]; 
ENDCASE => RETURN [FALSE]; 
};

CompatibleOwner: PUBLIC PROC [design: CD.Design, object: CD.Object] RETURNS [BOOL] = {
x: REF ~ (IF design=NIL THEN NIL ELSE design.cdDirectoryPriv2);
SELECT CDProperties.GetObjectProp[object, ownerKey] FROM
x => RETURN [TRUE]; 
NIL => RETURN [TRUE]; 
ENDCASE => RETURN [FALSE]; 
};

EachEntryAction: TYPE = PROC [name: Rope.ROPE, ob: CD.Object] RETURNS [quit: BOOL_FALSE];

Fetch: PUBLIC PROC [design: CD.Design, name: Rope.ROPE] RETURNS [object: CD.Object_NIL] = {
WITH SymTab.Fetch[design.cdDirectory1, name].val SELECT FROM
ob: CD.Object => RETURN [ob]
ENDCASE => RETURN [NIL];
};
Remove: PUBLIC PROC [design: CD.Design, name: Rope.ROPE, expectObject: CD.Object_NIL] RETURNS [ob: CD.Object] = {
ob _ MyRemove[design, name, expectObject].removed;
IF ob#NIL THEN {
[] _ DirectoryOp[ob, design, name, remove];
};
};

Fiddle: PUBLIC PROC [design: CD.Design, name: Rope.ROPE] RETURNS [ob: CD.Object] = {
ob _ MyRemove[design, name].removed;
IF ob#NIL THEN {
newName: Rope.ROPE _ IncludeFiddled[design, ob, name];
[] _ DirectoryOp[ob, design, newName, rename];
};
};

IncludeFiddled: PROC [design: CD.Design, ob: CD.Object, name: Rope.ROPE] RETURNS [newName: Rope.ROPE] = {
try: INT _ 0;
DO
IF (try _ try+1) < 3 
THEN {name _ FiddleName[name, design]}
ELSE {try _ 0; name _ FiddleGlobal[name]};
IF SymTab.Insert[design.cdDirectory1, name, ob] THEN {
[] _ RefTab.Store[design.cdDirectory2, ob, name];
RETURN [name];
}
ENDLOOP;
};

Status: TYPE = {done, ok, failed};

MyRemove: PROC [design: CD.Design, name: Rope.ROPE, expectObject: CD.Object_NIL] RETURNS [status: Status_failed, removed: CD.Object_NIL] = {
object: CD.Object _ Fetch[design, name].object;
IF object=NIL THEN RETURN [ok, NIL];  
IF (object=expectObject OR expectObject=NIL) THEN {
IF ~CompatibleOwner[design, object] THEN 
ERROR CD.Error[directoryInvariant, "Removed object in different design"];
IF RefTab.Delete[design.cdDirectory2, object] THEN removed _ object;
IF SymTab.Delete[design.cdDirectory1, name] THEN removed _ object;
IF removed#NIL THEN status _ done
};
};

DirectoryOp: PROC[me: CD.Object, design: CD.Design, name: Rope.ROPE, function: CDDirectory.DirectoryFunction] = {
IF me.class.composed THEN {
dop: CDDirectory.DirectoryProc = CDDirectory.ObToDirectoryProcs[me].directoryOp;
IF dop#NIL THEN dop[me, design, name, function];
}
};

IsIncluded: PUBLIC PROC [design: CD.Design, object: CD.Object] RETURNS [BOOL] = {
name: Rope.ROPE _ CDDirectory.Name[object, design];
RETURN [name#NIL]
};

Include: PUBLIC PROC [design: CD.Design, object: CD.Object, name: Rope.ROPE, fiddle: BOOL_TRUE] RETURNS [done: BOOL_FALSE] = {
oldName: Rope.ROPE _ NIL;
try: INT _ 0;
IF Rope.IsEmpty[name] THEN name _ "-noname-";
IF ~object.immutable AND object.class.composed THEN SetOwner[design, object, TRUE];
IF (oldName _ CDDirectory.Name[object, design])#NIL THEN {
IF Rope.Equal[oldName, name] THEN RETURN [TRUE];
RETURN [FALSE];
};
IF SymTab.Insert[design.cdDirectory1, name, object] THEN {
[] _ RefTab.Store[design.cdDirectory2, object, name];
DirectoryOp[object, design, name, include];
RETURN [TRUE]
};
IF fiddle THEN {
name  _ IncludeFiddled[design, object, name];
DirectoryOp[object, design, name, include];
RETURN [TRUE]
};
RETURN [FALSE]
};
FiddleGlobal: PROC [name: Rope.ROPE] RETURNS [Rope.ROPE] = {
RETURN [IO.PutFR["%g@%g@0", IO.rope[name], IO.int[Random.ChooseInt[max: LAST[NAT]]]]];
};

NextFiddleKey: PROC [design: CD.Design] RETURNS [key: INT] = {
WITH CDProperties.GetDesignProp[design, $FiddleKey] SELECT FROM
i: REF INT => {key _ i^; i^ _ i^ MOD 1000000B + 1};
ENDCASE => {key _ 0; CDProperties.PutDesignProp[design, $FiddleKey, NEW[INT_1]]};
};

FiddleName: PROC [name: Rope.ROPE, design: CD.Design] RETURNS [Rope.ROPE] = {
modifier: INT _ NextFiddleKey[design];
leng: INT _ name.Length[];
WHILE leng>0 DO
leng _ leng-1;
IF name.Fetch[leng]='@ THEN {
name _ name.Substr[0, leng]; EXIT
}
ENDLOOP;
name _ IO.PutFR["%g@%g", IO.rope[name], IO.int[modifier]];
RETURN [name];
};

Rename: PUBLIC PROC [design: CD.Design, object: CD.Object, newName: Rope.ROPE _ NIL, fiddle: BOOL _ TRUE, fiddleFirst: BOOL _ FALSE, removeFirst: BOOL _ FALSE] RETURNS [done: BOOL, conflict: CD.Object] = {
oldName: Rope.ROPE = CDDirectory.Name[object, design];
status: Status;
IF ~CompatibleOwner[design, object] THEN ERROR CD.Error[directoryInvariant];
status _ MyRemove[design, oldName, object].status;
IF status=failed THEN RETURN [FALSE, CDDirectory.Fetch[design, newName]];
IF SymTab.Insert[design.cdDirectory1, newName, object] THEN {
[] _ RefTab.Store[design.cdDirectory2, object, newName];
DirectoryOp[object, design, newName, (IF status = done THEN rename ELSE include)];
RETURN [TRUE, NIL]
};
conflict _ CDDirectory.Fetch[design, newName];
IF fiddle THEN {
newName  _ IncludeFiddled[design, object, newName];
DirectoryOp[object, design, newName, (IF status = done THEN rename ELSE include)];
RETURN [TRUE, conflict]
}
ELSE { --NOT fiddle
IF conflict#NIL THEN {
IF conflict=object THEN RETURN [TRUE, NIL];
IF fiddleFirst THEN conflict _ Fiddle[design, newName]
ELSE IF removeFirst THEN conflict _ Remove[design, newName]
};
IF SymTab.Insert[design.cdDirectory1, newName, object] THEN {
[] _ RefTab.Store[design.cdDirectory2, object, newName];
DirectoryOp[object, design, newName, (IF status = done THEN rename ELSE include)];
RETURN [TRUE, conflict]
};
IF status=done THEN {
[]  _ IncludeFiddled[design, object, oldName];
RETURN [done: FALSE, conflict: conflict]
};
ERROR CD.Error[programming, "rename removed an object"]
}
};

Enumerate: PUBLIC PROC [design: CD.Design, action: EachEntryAction] RETURNS [quit: BOOL] = {
EachPairAction: SymTab.EachPairAction ~ {
quit _ action[name: NARROW[key], ob: NARROW[val, CD.Object]]
};
quit _ SymTab.Pairs[design.cdDirectory1, EachPairAction]
};

DirSize: PUBLIC PROC [design: CD.Design] RETURNS [INT] = {
RETURN [SymTab.GetSize[design.cdDirectory1]]
};

InstallDirectoryProcs: PUBLIC PROC [type: CD.ObjectClass, dp: CDDirectory.DirectoryProcs] RETURNS [REF CDDirectory.DirectoryProcs] = {
dpr: REF CDDirectory.DirectoryProcs ~ NEW[CDDirectory.DirectoryProcs_dp];
IF type.directoryProcs#NIL OR type.composed THEN 
ERROR CD.Error[ec: doubleRegistration, explanation: "type already composed"];
type.directoryProcs _ dpr;
type.composed _ TRUE;
IF dpr.enumerateChildObjects=NIL THEN 
dpr.enumerateChildObjects _ DefaultEnumerateChildObjects;
IF dpr.replaceDirectChilds=NIL THEN dpr.replaceDirectChilds _ DefaultReplaceDirectChilds;
IF dpr.another=NIL THEN dpr.another _ DefaultAnother;
IF dpr.expand=NIL THEN dpr.expand _ DefaultExpand;
IF dpr.directoryOp=NIL THEN dpr.directoryOp _ DefaultDirectoryOp;
RETURN [dpr]
};

DefaultAnother: CDDirectory.AnotherProc = {
new _ NEW[CD.ObjectRep_me^]; --this would not be ok for most object classes
new.properties _ CDProperties.DCopyProps[me.properties];
childAccessible _ (IF into#NIL AND into=fromOrNil THEN ~me.class.xDesign ELSE FALSE);
};

DefaultExpand: CDDirectory.ExpandProc = { 
new _ Expand1ByDraw[me, LeaveNextLevel];
topAccessible _ TRUE;
childAccessible _ (into=fromOrNil OR into#NIL);
};

DefaultReplaceDirectChilds: CDDirectory.ReplaceDChildsProc = {
ERROR CD.Error[missingRegistration, "Don't default this procedure"];
};

DefaultEnumerateChildObjects: CDDirectory.EnumerateChildObjectsProc = {
--
IF me.class.composed AND ~me.class.xDesign THEN {
exp: CD.Object;
exp _ Expand1ByDraw[me, LeaveNextLevel, NIL];
quit _ CDDirectory.EnumerateChildObjects[exp, proc, data];
RETURN
};
--
--
IF me.class.composed AND ~me.class.xDesign THEN {
xPr: CD.DrawRef = CD.CreateDrawRef[[
drawRect: CDDefaultProcs.IgnoreRect,
drawChild: EnumerateByDrawing,
drawOutLine: CDDefaultProcs.IgnoreRect,
selections: FALSE,
symbolics: FALSE,
devicePrivate: NEW[EnumRec_[data, proc]]
]];
CD.DrawOb[xPr, me ! QuitEnumerating => GOTO quit];
}; 
RETURN [FALSE];
EXITS quit => RETURN [TRUE]
};

EnumRec: TYPE = RECORD [data: REF, proc: CDDirectory.EachObjectProc];

QuitEnumerating: ERROR = CODE;

EnumerateByDrawing: CD.DrawProc = {
IF ob.class.composed THEN {
er: REF EnumRec _ NARROW[pr.devicePrivate];
IF er.proc[ob, er.data].quit THEN ERROR QuitEnumerating;
}
};


DefaultDirectoryOp: PROC [me: CD.Object, design: CD.Design, name: Rope.ROPE, function: CDDirectory.DirectoryFunction] = {
};


Name: PUBLIC PROC [object: CD.Object, design: CD.Design] RETURNS [Rope.ROPE] = {
WITH RefTab.Fetch[design.cdDirectory2, object].val SELECT FROM
r: Rope.ROPE => RETURN [r]
ENDCASE => RETURN [NIL];
};
EnumerateDesign: PUBLIC PROC [design: CD.Design, proc: CDDirectory.EachObjectProc, data: REF_NIL, dir: BOOL_TRUE, top: BOOL_TRUE, recurse: BOOL_TRUE, dummy: BOOL_FALSE, visited: RefTab.Ref_NIL] RETURNS [quit: BOOL_FALSE] = {
Handle: PROC [ob: CD.Object] RETURNS [quit: BOOL_FALSE] = INLINE {
IF RefTab.Insert[visited, ob, $x] THEN {
IF recurse THEN quit _ CDDirectory.EnumerateChildObjects[ob, CheckNRecurse];
IF ~quit THEN quit _ proc[ob, data];
}
};
CheckNRecurse: CDDirectory.EachObjectProc = {
IF me.class.composed THEN RETURN [Handle[me]];
};
EachDirEntry: SymTab.EachPairAction = {
ob: CD.Object _ NARROW[val, CD.Object];
IF ob.class.composed THEN RETURN [Handle[ob]];
};
IF visited=NIL THEN visited _ RefTab.Create[MAX[CDDirectory.DirSize[design], 28]+17];
IF dir THEN 
quit _ SymTab.Pairs[design.cdDirectory1, EachDirEntry];
IF top THEN
FOR l: LIST OF CD.PushRec _ design.actual, l.rest WHILE (l#NIL AND ~quit) DO
IF l.first.mightReplace#NIL THEN quit _ CheckNRecurse[l.first.mightReplace.ob];
IF ~quit THEN
quit _ IF dummy 
THEN CheckNRecurse[l.first.dummyCell.ob]
ELSE CDDirectory.EnumerateChildObjects[l.first.dummyCell.ob, CheckNRecurse]
ENDLOOP;
};

EnumerateObject: PUBLIC PROC [ob: CD.Object, proc: CDDirectory.EachObjectProc, data: REF_NIL, recurse: BOOL_TRUE, visited: RefTab.Ref_NIL] RETURNS [quit: BOOL_FALSE] = {
Handle: PROC [ob: CD.Object] RETURNS [quit: BOOL_FALSE] = INLINE {
IF RefTab.Insert[visited, ob, $x] THEN {
IF recurse THEN quit _ CDDirectory.EnumerateChildObjects[ob, CheckNRecurse];
IF ~quit THEN quit _ proc[ob, data];
}
};
CheckNRecurse: CDDirectory.EachObjectProc = {
IF me.class.composed THEN RETURN [Handle[me]];
};
IF visited=NIL THEN visited _ RefTab.Create[];
IF ob.class.composed THEN RETURN [Handle[ob]];
};

Another1: PUBLIC PROC [me: CD.Object, fromOrNil: CD.Design_NIL, into: CD.Design_NIL, friendly: BOOL_FALSE] RETURNS [new: CD.Object, childAccessible: BOOL] = {
IF ~me.class.composed THEN RETURN [me, TRUE]
ELSE { 
another: CDDirectory.AnotherProc _ CDDirectory.ObToDirectoryProcs[me].another;
IF another=NIL THEN ERROR CD.Error[missingRegistration];
[new, childAccessible] _ another[me, fromOrNil, into, friendly];
IF childAccessible THEN SetOwner[into, new];
};
};

Expand1: PUBLIC PROC [me: CD.Object, fromOrNil: CD.Design_NIL, into: CD.Design_NIL, friendly: BOOL_FALSE] RETURNS [new: CD.Object, topAccessible: BOOL, childAccessible: BOOL] = {
IF ~me.class.composed THEN RETURN [NIL, FALSE, FALSE] 
ELSE { 
expand: CDDirectory.ExpandProc = CDDirectory.ObToDirectoryProcs[me].expand;
IF expand=NIL THEN ERROR CD.Error[missingRegistration]; 
[new, topAccessible, childAccessible] _ expand[me, fromOrNil, into, friendly];
IF topAccessible AND childAccessible THEN SetOwner[into, new];
};
};

AnotherRecursed: PUBLIC PROC [me: CD.Object, into: CD.Design_NIL, fromOrNil: CD.Design_NIL, cx: RefTab.Ref_NIL, getFromCache: CDDirectory.GetFromCacheProc_NIL, putInCache: CDDirectory.PutInCacheProc_NIL, data: REF_NIL] RETURNS [new: CD.Object_NIL] = {
ca: BOOL _ TRUE;
IF cx=NIL THEN cx _ RefTab.Create[]
ELSE
WITH RefTab.Fetch[cx, me].val SELECT FROM
ob: CD.Object => RETURN [ob]; 
ENDCASE => NULL;
IF getFromCache#NIL THEN {
new _ getFromCache[me, data]; 
IF new#NIL THEN {[] _ RefTab.Store[cx, me, new]; RETURN};
};
[new, ca] _ Another1[me, fromOrNil, into, TRUE];
IF new#NIL AND ~ca THEN {
IF ~FixChildren[new, into, fromOrNil, cx, getFromCache, putInCache, data].ok THEN RETURN [NIL] 
};
IF new#NIL THEN {
[] _ RefTab.Store[cx, me, new];
IF putInCache#NIL THEN putInCache[me, new, data];
}
};

ExpandRecursed: PUBLIC PROC [me: CD.Object, into: CD.Design_NIL, fromOrNil: CD.Design_NIL, cx: RefTab.Ref_NIL, getFromCache: CDDirectory.GetFromCacheProc_NIL, putInCache: CDDirectory.PutInCacheProc_NIL, data: REF_NIL] RETURNS [new: CD.Object] = {
ta, ca: BOOL;
[new, ta, ca] _ Expand1[me, fromOrNil, into, TRUE];
IF new#NIL THEN { 
IF cx=NIL THEN cx _ RefTab.Create[];
IF ~ta THEN { 
[new, ca] _ Another1[new, fromOrNil, into];
IF new=NIL THEN RETURN;
};
IF ~ca THEN {
IF ~FixChildren[new, into, fromOrNil, cx, getFromCache, putInCache, data].ok THEN RETURN [NIL] 
};
};
}; 

FixChildren: PUBLIC PROC [me: CD.Object, into: CD.Design, fromOrNil: CD.Design_NIL, cx: RefTab.Ref_NIL, getFromCache: CDDirectory.GetFromCacheProc_NIL, putInCache: CDDirectory.PutInCacheProc_NIL, data: REF_NIL] RETURNS [ok: BOOL_TRUE] = {
replaceList: CDDirectory.ReplaceList _ NIL;
localTab: RefTab.Ref _ RefTab.Create[]; 

PerChild: CDDirectory.EachObjectProc = {
IF ~me.immutable AND me.class.composed THEN { 
newChild: CD.Object _ NIL; 
IF ~RefTab.Insert[localTab, me, $handled] THEN RETURN; -- eliminate duplicates 
WITH RefTab.Fetch[cx, me].val SELECT FROM
cob: CD.Object => newChild _ cob;
ENDCASE => {
localOk, ca: BOOL _ TRUE;
IF IsOwner[into, me] THEN newChild _ me
ELSE IF getFromCache#NIL THEN newChild _ getFromCache[me, data];
IF newChild=NIL THEN {
[newChild, ca] _ Another1[me: me, fromOrNil: fromOrNil, into: into, friendly: TRUE];
IF newChild=NIL THEN {ok _ localOk _ FALSE; newChild _ me; ca _ FALSE}
ELSE IF ~ca AND newChild#me THEN {
IF newChild.immutable THEN ERROR CD.Error[classBehaviour];
IF ~FixChildren[me: newChild, into: into, fromOrNil: fromOrNil, cx: cx, getFromCache: getFromCache, putInCache: putInCache, data: data].ok THEN ok _ localOk _ FALSE 
};
IF localOk AND putInCache#NIL THEN putInCache[me, newChild, data]
};
IF localOk THEN [] _ RefTab.Insert[cx, me, newChild];
};
IF me#newChild AND newChild#NIL THEN
replaceList _ CONS[NEW[CDDirectory.ReplaceRec_[old: me, new: newChild]], replaceList];
}
};

IF cx=NIL THEN cx _ RefTab.Create[];
[] _ CDDirectory.EnumerateChildObjects[me: me, proc: PerChild, data: data];
IF replaceList#NIL THEN { 
IF me.immutable THEN ERROR CD.Error[classBehaviour, "immutable objects must not have inaccessible children"]; 
[] _ CDDirectory.ReplaceDirectChild[me: me, design: into, replace: replaceList, propagate: FALSE]; 
};
IF ok THEN {
SetOwner[into, me];
[] _ RefTab.Insert[cx, me, me];
}
};


ExpandRec: TYPE = RECORD [
cell: CD.Object,
cellPtr: CD.CellSpecific,
ep: CDDirectory.ExpandDecisionProc,
data: REF
];

drawAll: REF CD.ContextFilter = NEW[CD.ContextFilter_ALL[TRUE]];

Expand1ByDraw: PUBLIC PROC [ob: CD.Object, ep: CDDirectory.ExpandDecisionProc_NIL, data: REF_NIL] RETURNS [CD.Object] = {
cell: CD.Object = CDCells.CreateEmptyCell[];
expandRef: REF ExpandRec = NEW[ExpandRec_[
cell: cell, cellPtr: NARROW[cell.specific],
ep: ep, data: data
]];
expandPr: CD.DrawRef = CD.CreateDrawRef[[
design: NIL,
drawRect: ExpandByDrawBareRect,
drawChild: ExpandByDrawChild,
drawOutLine: CDDefaultProcs.IgnoreRect,
selections: FALSE,
devicePrivate: expandRef,
contextFilter: drawAll
]];
ob.class.drawMe[pr: expandPr, ob: ob];
CDCells.SetInterestRect[NIL, cell, CD.InterestRect[ob], doit];
RETURN [cell]
};

LeaveRectangles: PUBLIC CDDirectory.ExpandDecisionProc = {
IF ob.class.composed THEN RETURN [recurse];
IF ob.class.symbolic THEN RETURN [suppress];
IF ob.class=CDRects.bareRectClass THEN RETURN [leave];
RETURN [recurse];
};

LeaveNextLevel: PUBLIC CDDirectory.ExpandDecisionProc = {
RETURN [leave];
};

LeaveDontFlatten: PUBLIC CDDirectory.ExpandDecisionProc = {
IF ~ob.class.composed THEN RETURN [leave];
IF CDProperties.GetObjectProp[ob, $DontFlatten]#NIL THEN RETURN [leave];
IF CDProperties.GetListProp[readOnlyInstProps, $DontFlatten]#NIL THEN RETURN [leave];
RETURN [recurse];
};

ExpandByDrawBareRect: PROC [pr: CD.DrawRef, r: CD.Rect, l: CD.Layer] = {
expandRef: REF ExpandRec = NARROW[pr.devicePrivate];
inst: CD.Instance _ NEW[CD.InstanceRep_[
ob: CDRects.CreateBareRect[size: CDBasics.SizeOfRect[r], l: l], 
trans: [CDBasics.BaseOfRect[r], original]
]];
expandRef.cellPtr.contents _ CONS[inst, expandRef.cellPtr.contents];
}; 

ExpandByDrawChild: CD.DrawProc = {
expandRef: REF ExpandRec = NARROW[pr.devicePrivate];
SELECT expandRef.ep[ob, trans, readOnlyInstProps, expandRef.data] FROM
suppress => NULL;
leave => expandRef.cellPtr.contents _ CONS[
NEW[CD.InstanceRep_[ob: ob, trans: trans, properties: CDProperties.DCopyProps[readOnlyInstProps]]], 
expandRef.cellPtr.contents
];
recurse => ob.class.drawMe[pr, ob, trans, readOnlyInstProps];
ENDCASE => ERROR CD.Error[programming];
};



RepositionList: TYPE = LIST OF CD.Object;

changeEvent: CDEvents.EventRegistration ~ CDEvents.RegisterEventType[$AfterChange];

ReplaceObject: PUBLIC PROC [design: CD.Design, old: CD.Object, new: CD.Object, trans: CD.Transformation] = {
repRef: REF CDDirectory.ReplaceRec _ NEW[CDDirectory.ReplaceRec_[old: old, new: new, trans: trans]];
IF design=NIL THEN ERROR CD.Error[calling];
FOR plist: LIST OF CD.PushRec _ design.actual, plist.rest WHILE plist#NIL DO
IF plist.first.mightReplace#NIL AND plist.first.mightReplace.ob=old THEN
TerminalIO.PutRope["** Tries to replace pushed in cell; does not work\n"];
ENDLOOP;
ReplaceAllChilds[design, repRef]
};

PropagateResize: PUBLIC PROC [design: CD.Design, ob: CD.Object] = {
repRef: REF CDDirectory.ReplaceRec _ NEW[CDDirectory.ReplaceRec_[old: ob, new: ob]];
IF ob.immutable THEN ERROR CD.Error[objectMutability]; 
[] _ CDEvents.ProcessEvent[
eventRegistration: resizeEvent, 
design: design, 
x: NEW[CDDirectory.ReplaceRec _ repRef^], --copy for safety
listenToDont: FALSE
];
IF design#NIL THEN ReplaceAllChilds[design, repRef]
};
ReplaceAllChilds: PROC [design: CD.Design, repRef: REF CDDirectory.ReplaceRec] = {
ENABLE UNWIND => {
CDValue.Store[design, repositioningListKey, NIL];
TerminalIO.PutRope["****repositioning or replace failed [maybe, partly]\n"];
};
ref: REF CDDirectory.ReplaceList _ NARROW[
CDValue.Fetch[boundTo: design, key: repositioningListKey, propagation: design]
];
IF ref#NIL THEN {  -- we are inside replace process, remember object
IF ref^=NIL THEN ref^ _ LIST[repRef]
ELSE {
FOR l: CDDirectory.ReplaceList _ ref^, l.rest DO
IF l.first.old=repRef.old THEN ERROR CD.Error[programming, "impossible! call Christian"];
IF l.rest=NIL THEN {l.rest _ LIST[repRef]; EXIT}
ENDLOOP;
};
RETURN
};
ref _ NEW[CDDirectory.ReplaceList_LIST[repRef]];
CDValue.Store[boundTo: design, key: repositioningListKey, value: ref];
WHILE ref^#NIL DO
repList: CDDirectory.ReplaceList _ ref^;
ref^ _ NIL;
DoReplaceAllChilds[design, repList];
ENDLOOP;
CDValue.Store[design, repositioningListKey, NIL];
CDOps.Redraw[design];
};

ReplaceDirectChild: PUBLIC PROC [me: CD.Object, design: CD.Design, replace: CDDirectory.ReplaceList, propagate: BOOL_TRUE] RETURNS [changed: BOOL_FALSE] = {
IF me.class.composed AND replace#NIL THEN { 
IF me.immutable THEN ERROR CD.Error[objectMutability]; 
changed _ CDDirectory.ObToDirectoryProcs[me].replaceDirectChilds[me, design, replace];
IF changed AND propagate THEN PropagateChange[me, design];
}
};

DoReplaceAllChilds: PROC [design: CD.Design, repList: CDDirectory.ReplaceList] = {

ReplaceForOne: CDDirectory.EachObjectProc = {
IF ~me.immutable THEN [] _ ReplaceDirectChild[me: me, design: design, replace: repList];
};

[] _ CDDirectory.EnumerateDesign[design, ReplaceForOne];
FOR plist: LIST OF CD.PushRec _ design.actual, plist.rest WHILE plist#NIL DO
inst: CD.Instance _ plist.first.mightReplace;
SetOwner[design, plist.first.dummyCell.ob, TRUE]; --HACK XXX XXX
FOR rlist: CDDirectory.ReplaceList _ repList, rlist.rest WHILE rlist#NIL DO
rep: REF CDDirectory.ReplaceRec = rlist.first;
IF inst#NIL AND inst.ob=rep.old THEN {
inst.trans _ CDBasics.ComposeTransform[itemInCell: inst.trans, cellInWorld: rep.trans];
}
ENDLOOP;
[] _ CDCellsBackdoor.ReplaceDirectChildForCell[plist.first.dummyCell.ob, design, repList];
ENDLOOP;
};

RemovePropsEvent: CDEvents.EventProc = {
ob: CD.Object = NARROW[x];
Rem: Properties.EachProp  = {
p: CDProperties.PropertyProcs ~ CDProperties.FetchProcs[key];
IF p#NIL AND p.autoRem THEN CDProperties.PutObjectProp[ob, key, NIL];
}; 
IF ob#NIL THEN [] _ Properties.Enumerate[ob.properties, Rem]
};

PropagateChange: PUBLIC PROC [ob: CD.Object, design: CD.Design] = {
IF ob.immutable THEN ERROR CD.Error[objectMutability];
[] _ CDEvents.ProcessEvent[changeEvent, design, ob];
};


CurrentKey: PUBLIC PROC [ob: CD.Object] RETURNS [key: REF] = {
RETURN [CDProperties.GetObjectProp[ob, modificationKeyProp]]
};

Match: PUBLIC PROC [ok: CDCacheBase.ObjectAndKey] RETURNS [BOOL] = {
RETURN [CDProperties.GetObjectProp[ok.ob, modificationKeyProp]=ok.key]
};

modificationKeyProp: PUBLIC REF = NEW[ATOM_$ModificationKey];
nextModification: CARD _ 0;

ObjectHasChanged: CDEvents.EventProc = {
WITH x SELECT FROM
ob: CD.Object => IF ob.class.composed THEN
CDProperties.PutObjectProp[ob, modificationKeyProp, NEW[CARD_(nextModification_nextModification+1)]];
ENDCASE => NULL;
};

resizeEventKey: ATOM = $resize;
resizeEvent: CDEvents.EventRegistration = CDEvents.RegisterEventType[resizeEventKey];
repositioningListKey: REF ATOM = NEW[ATOM_$RepositioningList];
ownerKey: ATOM = $OwnerDesign; --HACK XXX: property is also used by cdcellsimpl
[] _ CDProperties.RegisterProperty[ownerKey];
[] _ CDProperties.RegisterProperty[modificationKeyProp];
CDProperties.InstallProcs[prop: ownerKey, procs: CDProperties.PropertyProcsRec[exclusive: TRUE]];
CDProperties.InstallProcs[prop: modificationKeyProp, procs: CDProperties.PropertyProcsRec[exclusive: TRUE, internalWrite: CDProperties.DontPWrite, makeCopy: CDProperties.CopyVal]];
CDValue.RegisterKey[repositioningListKey];
CDEvents.RegisterEventProc[event: changeEvent, proc: RemovePropsEvent];
CDEvents.RegisterEventProc[event: changeEvent, proc: ObjectHasChanged];
END.

���‚��CDDirectoryImpl.mesa   (part of ChipNDale)
Copyright c 1983, 1984, 1985, 1986, 1987 by Xerox Corporation.  All rights reserved.
Created by Christian Jacobi, June 24, 1983 5:00 pm 
Last edited by: Christian Jacobi, April 10, 1987 6:38:49 pm PDT
Directory updates:
Always include name in SymTab first then include object in RefTab.
Remove in opposite order.

We dont SetOwner[NIL, object]; This makes interactive operations safer, 
at cost of inter-design copy; But inter-design copy is already difficult anyway. 
--ob must not be already included with any name
--always ! succeeds including object
--done: done on this call 
--ok: its not really done, but that name is at least not occupying a slot in the 
--     name-space anymore
--failed: place in name space is still occupied
--we tolerate include of an object twice in the same design

--crazy another proc which makes a copy of the object-definition
--Use drawproc to find children.
--Sorry this is not too fast; But not providing a default proc would bare the risk of some 
--people making classes with EnumerateChildObjectsProc's not returning any objects.
--The real implementation crashes when a nested procedure is passed in and assigned
--used by DefaultEnumerateChildObjects
--used by DefaultEnumerateChildObjects
--used by DefaultEnumerateChildObjects
-- -- -- -- -- -- -- -- -- -- --

--enumerates only the mutable children
--enumerates only the mutable children

-- -- -- -- -- -- -- -- -- -- --
--contains all elements of replaceList; one level only!
-- -- -- -- -- -- -- -- -- -- --
--all over in the design replace old by new
--may be delayed
--all over in the design tries to reposition ob;
--may be delayed

--catches recursive calls and transformes them into sequential calls...
--the list of what to do is found using CDValue on the design
-- we are not inside reposition process, start one
-- processes an CDEvent $AfterChange

--CDCacheBase
Ê ��˜�
codeš
œ*™*Kšœ
Ïm
œI™TKš
œ3™3K™?K˜�—š
Ïk	˜	Kšžœ˜Kš
œ˜Kš
œ˜K˜Kš
œ˜Kš
œ˜K˜	K˜	K˜K˜
K˜K˜Kšžœ
˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—K˜�šÏnœžœ
žœ
˜Kšžœ
žœtžœ6˜¶
Kšžœ˜ Kšžœ
žœ˜—Kš
ž˜K˜�™K™BK™—K˜�šŸœžœ
žœ
žœžœžœ
žœ˜RKš
œžœžœžœ
žœ
žœ
žœ˜?šžœžœ
˜šžœ.ž˜8Kšœžœ˜
Kšžœ˜Kšžœžœ
žœ:˜M——Kšžœžœžœ
žœ
žœ
žœ;˜kKš
œ0˜0K˜—K˜�šŸœžœ
žœžœ	žœžœ˜NKš
œžœžœžœ
žœ
žœ
žœ˜?šžœ.ž˜8Kšœžœžœ˜Kšžœžœžœ˜—K˜—K˜�šŸœžœ
žœžœ	žœžœ˜VKš
œžœžœžœ
žœ
žœ
žœ˜?šžœ.ž˜8Kšœžœžœ˜Kšžœžœžœ˜Kšžœžœžœ˜—K˜—K˜�Kšœžœžœ
žœžœ	žœžœ
žœ˜ZšŸœžœ
žœ
žœžœžœ
žœžœ˜[šžœ-žœ
ž˜<Kšœžœžœ˜Kšžœžœžœ˜—Kš
œ˜—K™�šŸœžœ
žœ
žœžœžœžœžœžœ˜qKš
œ2˜2šžœžœ
žœ˜Kš
œ+˜+Kšœžœ4™HKš
œQ™QK˜—Kš
œ˜—šŸœžœ
žœ
žœžœžœžœ˜TKš
œ$˜$šžœžœ
žœ˜Kšœžœ$˜6Kš
œ.˜.K˜—Kš
œ˜—šŸœžœ
žœ
žœžœžœžœ˜iKš
Ïc/™/Kš
 $™$Kšœžœ˜
š
ž˜šžœ˜Kšžœ"˜&Kšžœ&˜*—šžœ.žœ˜6Kš
œ1˜1Kšžœ˜K˜
—Kšžœ
˜—K˜—K˜�šœžœ˜"Kš
œ™K™QK™K™/—K˜�šŸœžœ
žœžœžœžœžœ"žœžœ˜Œ
Kšœžœ%˜/Kš
žœžœ
žœ
žœžœ˜&šžœžœžœžœ˜3šžœ"žœ
˜)Kšžœ
žœA˜I—Kšžœ,žœ˜DKšžœ*žœ˜BKšžœ	žœ
žœ˜!K˜—Kš
œ˜—š
Ÿœžœžœžœžœ.˜qšžœžœ˜Kš
œP˜PKšžœžœ
žœ!˜0Kš
œ
˜
—Kš
œ˜—K˜�šŸ
œžœ
žœ
žœžœ	žœžœ˜QKšœžœ$˜3Kšžœžœ
˜K˜—K˜�šŸœžœ
žœ
žœžœžœ
žœ
žœžœžœ
žœ˜~Kš
 ;™;Kšœžœžœ
˜Kšœžœ˜
Kšžœžœ˜-Kšžœžœžœžœ˜Sšžœ.žœ
žœ˜:Kšžœžœ
žœžœ˜0Kšžœžœ˜K˜—šžœ2žœ˜:Kš
œ5˜5Kš
œ+˜+Kšžœžœ
˜
Kš
œ˜—šžœžœ˜Kš
œ-˜-Kš
œ+˜+Kšžœžœ
˜
K˜—Kšžœžœ
˜Kš
œ˜—K™�š
Ÿœžœ
žœžœžœ˜<Kšžœžœžœ
žœžœ
žœ˜VKš
œ˜—K˜�š
Ÿ
œžœ
žœ	žœžœ˜>šžœ0žœ
ž˜?Kšœžœ
žœžœ˜3Kšžœ=žœ
žœ˜Q—K˜—K˜�šŸ
œžœ
žœ
žœ	žœžœ˜MKšœ
žœ˜&Kšœžœ˜šžœž˜Kš
œ˜šžœžœ˜Kšœž˜!K˜
—Kšžœ
˜—Kšœžœžœ
žœ˜:Kšžœ˜Kš
œ˜—K˜�š Ÿœžœ
žœ
žœžœžœžœ
žœžœžœžœžœžœžœžœžœ˜Í
Kšœžœ$˜6Kš
œ˜Kšžœ"žœ
žœ
žœ˜LKš
œ2˜2Kšžœžœ
žœžœ&˜Išžœ5žœ˜=Kš
œ8˜8Kšœ&žœžœžœ˜RKšžœžœžœ
˜Kš
œ˜—Kš
œ.˜.šžœžœ˜Kš
œ3˜3Kšœ&žœžœžœ˜RKšžœžœ˜K˜
—šžœ ˜šžœ
žœ
žœ˜Kš
žœžœ
žœžœžœ˜+Kšžœ
žœ#˜6Kšžœ
žœ
žœ#˜;K˜—šžœ5žœ˜=Kš
œ8˜8Kšœ&žœžœžœ˜RKšžœžœ˜Kš
œ˜—šžœ
žœ˜Kš
œ.˜.Kšžœžœ˜(K˜—Kšžœ
žœ/˜7K˜
—Kš
œ˜—šŸ	œžœ
žœ
žœ"žœžœ˜\šÐbnœ˜)Kšœžœžœžœ	˜<Kš
œ˜—Kš
œ8˜8Kš
œ˜K˜�—šŸœžœ
žœ
žœ	žœžœ˜:Kšžœ&˜,Kš
œ˜—K˜�šŸœžœ
žœžœ.žœžœ ˜†
Kšœžœžœ ˜Išžœžœ
žœžœ
˜1Kšžœ
žœE˜M—Kš
œ˜Kšœžœ
˜šžœžœ
žœ
˜&Kš
œ9˜9—Kšžœžœ
žœ6˜YKšžœ
žœ
žœ˜5Kšžœžœ
žœ˜2Kšžœžœ
žœ&˜AKšžœ˜Kš
œ˜—K˜�š¡œ˜+Kš
œ@™@Kšœžœ
žœ .˜KKš
œ8˜8Kš
œžœžœ
žœžœžœ
žœ˜UKš
œ˜—K˜�š¡
œ˜*Kš
œ(˜(Kšœžœ
˜Kšœ"žœžœ˜/Kš
œ˜—K˜�š¡œ$˜>Kšžœ
žœ<˜DKš
œ˜—K˜�šŸœ+˜GJš
  ™ Jš Sœ™[Jš œQ™SJš
œ˜šžœžœžœ˜1Jšœžœ˜Jšœ(žœ˜-Jš
œ:˜:Jš
ž˜J˜—J˜Jš
œS™SJ˜šžœžœžœ˜1šœžœžœ˜$Kš
œ$˜$Kš
œ˜Kš
œ'˜'Kšœžœ
˜Kšœžœ
˜Kšœžœ˜(Kš
œ˜—Jšžœ%žœ˜2Jš
œ˜—Jšžœžœ˜Jšžœ	žœžœ
˜J˜—˜�šœ	žœžœžœ$˜EJš
 &™&—J˜�šŸœžœžœ
˜Jš
 &™&—J˜�šŸœžœ
˜#Jš
 &™&šžœžœ˜Jšœžœžœ˜+Jšžœžœ
žœ˜8J˜
—Jš
œ˜——K˜�K˜�š
Ÿœžœžœžœžœ.˜yKš
œ˜—K˜�Kš
œ ™ K˜�šŸœžœ
žœ
žœžœ	žœžœ˜Pšžœ/žœ
ž˜>Kšœžœžœ˜Kšžœžœžœ˜—K˜—K™�š"Ÿœžœ
žœ1žœ
žœžœ
žœžœ
žœžœ
žœ	žœ
žœžœžœžœ
žœ˜à
Kš
œ&™&šŸœžœžœ	žœžœ
žœžœ˜Bšžœ žœ˜(Kšžœ	žœ=˜LKšžœžœ˜$K˜
—K˜—šŸ
œ ˜-Kšžœžœ
žœ˜.K˜—šŸœ˜'Kšœžœ
žœžœ	˜'Kšžœžœ
žœ˜.Kš
œ˜—Kšžœ	žœ
žœžœ&˜Ušžœžœ
˜Kš
œ7˜7—šžœž˜šžœžœ
žœ
žœ!žœžœ
žœž˜LKšžœžœ
žœ/˜Ošžœž˜
šœžœ˜Kšžœ$˜(KšžœG˜K——Kšžœ
˜——K˜—K˜�šŸœžœžœ1žœ
žœžœ
žœžœžœžœ
žœ˜©
Kš
œ&™&šŸœžœžœ	žœžœ
žœžœ˜Bšžœ žœ˜(Kšžœ	žœ=˜LKšžœžœ˜$K˜
—K˜—šŸ
œ ˜-Kšžœžœ
žœ˜.K˜—Kšžœ	žœ
žœ˜.Kšžœžœ
žœ˜.K˜—K™�Kš
œ ™ K˜�šŸœžœ
žœžœžœžœžœžœžœ
žœžœžœžœ˜ž
Kšžœžœ
žœžœ
˜,šžœ˜Kš
œN˜NKš
žœ	žœ
žœ
žœ
žœ˜8Kš
œ@˜@Kšžœžœ˜,K˜—Kš
œ˜—K˜�šŸœžœ
žœžœžœžœžœžœžœ
žœžœžœžœžœ˜²
Kšžœžœ
žœžœžœžœ˜6šžœ˜Kš
œK˜KKš
žœžœ
žœ
žœ
žœ˜8Kš
œN˜NKšžœžœžœ˜>K˜—Kš
œ˜—K˜�š Ÿœžœ
žœžœžœžœ
žœžœžœ-žœ)žœžœ
žœžœžœžœ˜û
Kšœžœžœ
˜Kšžœžœ
žœ˜#š
ž˜šžœžœ
ž˜)Kšœžœžœ˜Kšžœžœ
˜——šžœžœ
žœ˜Kš
œ˜Kšžœžœ
žœ"žœ˜9Kš
œ˜—Kšœ*žœ˜0šžœžœ
žœžœ˜KšžœKžœ
žœžœ˜_K˜—šžœžœ
žœ˜Kš
œ˜Kšžœžœ
žœ˜1K˜
—Kš
œ˜—K˜�šŸœžœ
žœžœžœžœ
žœžœžœ-žœ)žœžœ
žœžœžœ˜ö
Kšœžœ
˜
Kšœ-žœ˜3šžœžœ
žœ˜Kšžœžœ
žœ˜$šžœžœ˜Kš
œ+˜+Kšžœžœ
žœ
žœ
˜K˜—šžœžœ˜
KšžœKžœ
žœžœ˜_K˜—K˜—Kš
œ˜—K˜�šŸœžœ
žœžœžœžœžœžœ-žœ)žœžœ
žœžœžœ
žœ˜î
Kšœ'žœ
˜+š
œ(˜(Kš
 7™7—K˜�šŸœ ˜(šžœžœžœ˜.Kšœ
žœ
žœ˜Kšžœ(žœ
žœ ˜Ošžœžœ
ž˜)Kšœžœ˜!šžœ˜Kšœ
žœžœ
˜Kšžœžœ˜'Kšžœ
žœžœ
žœ#˜@šžœ
žœ
žœ˜KšœNžœ˜TKš
žœ
žœ
žœžœžœ
˜Fšžœ
žœžœ
žœ˜"Kšžœžœ
žœ
žœ˜:Kšžœ‰
žœžœ
˜¥
K˜—Kšžœ	žœžœ
žœ˜AK˜—Kšžœ	žœ&˜5K˜——šžœ
žœ
žœ
ž˜$Kšœžœ
žœ@˜V—K˜
—Kš
œ˜—K˜�Kšžœžœ
žœ˜$Kš
œK˜Kšžœ
žœ
žœ˜Kšžœžœ
žœ
žœQ˜nKšœ[žœ˜cK˜—šžœžœ˜Kš
œ˜Kš
œ˜K˜
—Kš
œ˜—K˜�K˜�šœžœžœ˜Kšœžœ˜Kšœ	žœ˜Kš
œ#˜#Kšœž˜	Kš
œ˜—K˜�Kš
œ	žœ
žœžœ
žœžœ
žœ˜@K˜�šŸ
œžœ
žœžœ,žœžœ
žœžœžœ˜yKšœžœ$˜,šœžœ
žœ˜*Kšœžœ˜+Kš
œ˜Kš
œ˜—šœ
žœžœ˜)Kšœžœ
˜Kš
œ˜Kš
œ˜Kš
œ'˜'Kšœžœ
˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ&˜&Kšœžœžœ˜>Kšžœ˜
Kš
œ˜—K˜�šŸœžœ#˜:Kšžœžœ
žœ˜+Kšžœžœ
žœ˜,Kšžœ žœ
žœ	˜6Kšžœ˜Kš
œ˜—K˜�šŸœžœ#˜9Kšžœ	˜Kš
œ˜—K˜�šŸœžœ#˜;Kšžœžœ
žœ	˜*Kšžœ.žœ
žœ
žœ	˜HKšžœ;žœ
žœ
žœ	˜UKšžœ˜Kš
œ˜—K˜�š
Ÿœžœžœ
žœ
žœ˜HKšœžœ
žœ˜4šœžœžœ
žœ˜(Kš
œ@˜@Kš
œ)˜)Kš
œ˜—Kšœžœ#˜DKš
œ˜—K˜�šŸœ˜"Kšœžœ
žœ˜4šžœ<ž˜FKšœž˜šœ&žœ
˜+Kšžœ
žœ^˜dKš
œ˜Kš
œ˜—Kš
œ=˜=Kšžœžœ
žœ˜'—Kš
œ˜—K˜�K˜�Kš
œ ™ K˜�Kš	œžœžœ
žœ
žœ	˜*Kš
œS˜SK˜�šŸ
œžœ
žœ
žœžœžœžœ˜lKš
œ+™+K™Kšœžœžœ<˜dKš
žœžœ
žœ
žœ
žœ˜+š
žœžœ
žœ
žœ%žœžœ
ž˜Lšžœžœ
žœ!ž˜HKš
œJ˜J—Kšžœ
˜—Kš
œ ˜ Kš
œ˜—K˜�š
Ÿœžœ
žœ
žœ
žœ˜CKš
œ0™0K™Kšœžœžœ,˜TKšžœžœ
žœ
žœ˜7š
œ˜Kš
œ ˜ Kš
œ˜Kšœžœ$ ˜;Kšœž˜K˜—Kšžœžœ
žœ!˜3Kš
œ˜K™�—šŸœžœ
žœžœ˜RKš
 G™GKš
 =™=šžœ
žœ˜Kšœ,žœ˜1Kš
œL˜LK˜—šœžœžœ
˜*Kš
œN˜NKš
œ˜—šžœžœ
žœ 1˜DKšžœžœ
žœžœ˜$šžœ˜šžœ+ž˜0Kšžœžœ
žœ
žœ2˜YKš
žœžœ
žœžœ
žœ
˜0Kšžœ
˜—K˜—Kš
ž˜K˜—Kš
œ2™2Kšœžœžœ
˜0Kš
œF˜Fšžœžœ
ž˜Kš
œ(˜(Kšœžœ
˜Kš
œ$˜$Kšžœ
˜—Kšœ,žœ˜1Kš
œ˜Kš
œ˜—K˜�š¡œžœ
žœžœžœ6žœ
žœžœžœ
žœ˜œ
šžœžœ	žœ
žœ˜,Kšžœžœ
žœ
žœ˜7Kš
œV˜VKšžœ	žœžœ˜:K˜
—Kš
œ˜—K˜�š¡œžœ
žœ.˜RK˜�šŸ
œ ˜-KšžœžœC˜XKš
œ˜—K˜�Kš
œ8˜8š
žœžœ
žœ
žœ%žœžœ
ž˜LKšœžœ%˜-Kšœ+žœ ˜@šžœ6žœžœ
ž˜KKšœžœ&˜.šžœžœ
žœžœ˜&Kš
œW˜WK˜
—Kšžœ
˜—Kš
œZ˜ZKšžœ
˜—Kš
œ˜—K˜�š¡œ˜(Kšœžœ
žœ˜š¡œ˜Kš
œ=˜=Kš
žœžœ
žœžœ%žœ˜EKš
œ˜—Kšžœžœ
žœ.˜<Kš
œ˜—K˜�š
Ÿœžœ
žœžœžœ˜CKš
œ$™$Kšžœžœ
žœ
žœ˜6Kš
œ4˜4Kš
œ˜—K˜�K™�Kš
Ðbl
™
K˜�šŸ
œžœ
žœžœ	žœžœ˜>Kšžœ6˜<K˜—K˜�š
Ÿœžœ
žœ žœžœ˜DKšžœ@˜FK˜—K˜�Kš	œžœ
žœžœ
žœ˜=Kšœžœ˜K˜�š¡œ˜(šžœžœ
ž˜šœžœžœž˜*Kšœ4žœ
žœ)˜e—Kšžœžœ
˜—Kš
œ˜—K˜�Kšœžœ˜Kš
œU˜UKš	œžœ
žœžœ
žœ˜>Kšœ
žœ 0˜OKš
œ-˜-Kš
œ8˜8KšœZžœ˜aKšœežœK˜´
Kš
œ*˜*Kš
œG˜GKš
œG˜GKšžœ
˜K˜�—�…—����Z��€´��