DIRECTORY
Buttons, 
CD,
CDCellsBackdoor,
CDEnvironment,
CDEvents,
CDLayers,
CDOps, 
CDPanel,
CDPrivate,
CDProperties,
CDSequencer,
CDValue,
CDViewer,
Containers,
Labels,
Menus, 
PopUpSelection,
Rope,
TerminalIO,
UserProfile, 
ViewerEvents,
ViewerClasses,
ViewerOps,
ViewerTools;

CDPanelImpl: CEDAR MONITOR 
IMPORTS Buttons, CD, CDCellsBackdoor, CDEnvironment, CDEvents, CDLayers, CDOps, CDPrivate, CDProperties, CDSequencer, CDValue, CDViewer, Containers, Labels, PopUpSelection, Rope, TerminalIO, UserProfile, ViewerEvents, ViewerOps, ViewerTools
EXPORTS CDPanel
SHARES CDLayers, CDPrivate = 
BEGIN


ROPE: TYPE = Rope.ROPE;
Viewer: TYPE = ViewerClasses.Viewer;
Info: TYPE = CDPanel.Info;

LayerPanelRec: TYPE = RECORD [
container: Viewer _ NIL,
nextX: CARDINAL _ 0
];
layerOptionsCount: NAT = 3;

Panel: TYPE = REF PanelRec; -- defines the control panel; one per design
PanelRec: TYPE = RECORD [   
container: Viewer _ NIL,
layerOption: NAT _ 0,
layers: ARRAY [0..layerOptionsCount) OF LayerPanelRec,
design: CD.Design,
class: Class _ NIL,
nextX: CARDINAL _ 0,
nextY: CARDINAL _ 0,
nexTopX: CARDINAL _ 0,
layerLabel: Labels.Label _ NIL,
layerWidths: LIST OF Actual _ NIL,
actuals: LIST OF Actual _ NIL
];
PanelList: TYPE = LIST OF Panel; 

EntryClass: TYPE = REF EntryClassRec; --class of entry in viewer
EntryClassRec: TYPE = RECORD [
build: BuildProc,
toDisplay: ToDisplayProc _ NIL,
fromdisplay: FromDisplayProc _ NIL, --if defaulted uses cdvalue
classData: REF _ NIL
];

BuildProc: TYPE = PROC [panel: Panel, entry: EntryDef]; --builds an entry into a viewer
ToDisplayProc: TYPE = PROC [actual: Actual, value: REF]; 
FromDisplayProc: TYPE = PROC [actual: Actual] RETURNS [value: REF_NIL]; 

EntryDef: TYPE = REF EntryDefRec; --defines an entry 
EntryDefRec: TYPE = RECORD [
entryClass: EntryClass,
button, val: Info,  	--only val's cdValueKey is looked at ever
min, max, default, lambda: INT _ 1,
layer: CD.Layer _ CD.undefLayer, option: NAT _ 0,
topLine, editable: BOOL _ FALSE,
proc: CDSequencer.CommandProc _ NIL, 
command: ATOM _ NIL,
queue: CDSequencer.QueueMethod _ useDefault,
data: REF _ NIL
];

EntryList: TYPE = LIST OF EntryDef;  
Class: TYPE = REF EntryList; -- one per Technology

Actual: TYPE = REF ActualRec;  --type used for clientData field of viewer stuff
ActualRec: TYPE = RECORD [
panel: Panel, 
define: EntryDef, 
feedback: Viewer _ NIL --might be a different viewer doing feedback for the caller
];

panelKey: REF ATOM ~ NEW[ATOM_$Panel];  -- used instead of atoms, to be really unique
classKey: REF ATOM ~ NEW[ATOM_$PanelClass];
globalClass: Class ~ NEW[EntryList_NIL];
panelList: PanelList _ NIL;

newLineClass: EntryClass _ RegisterEntryClass[[
build: BuildNewLine
]];
buttonClass: EntryClass _ RegisterEntryClass[[
build: BuildButton,
toDisplay: ToDisplayButton
]];
labelClass: EntryClass _ RegisterEntryClass[[
build: BuildLabel,
toDisplay: ToDisplayLabel
]];
textClass: EntryClass _ RegisterEntryClass[[
build: BuildText,
toDisplay: ToDisplayText,
fromdisplay: FromDisplayText
]];
layerClass: EntryClass _ RegisterEntryClass[[
build: BuildLayer
]];
intClass: EntryClass _ RegisterEntryClass[[
build: BuildInt,
toDisplay: ToDisplayNumber
]];

butYCompensation: INTEGER _ 0;
labelYCompensation: INTEGER _ 1;
textYCompensation: INTEGER _ -2;
textHCompensation: INTEGER _ 2;

topY: CARDINAL = 1;
entryHSpace: CARDINAL = 3;
entryHeight: CARDINAL = 12;
shorterEntryVSpace: CARDINAL = 1;


RegisterEntryClass: PROC [c: EntryClassRec] RETURNS [entryClass: EntryClass] = {
entryClass _NEW[EntryClassRec_c]
};

GetPanel: PROC [design: CD.Design] RETURNS [Panel] = {
x: REF _ CDValue.Fetch[boundTo: design, key: panelKey, propagation: global];
IF x=NIL THEN {
panel: Panel = NEW[PanelRec_[
design: design,
class: GetClass[design.technology]
]];
[] _ CDValue.StoreConditional[design, panelKey, panel];
RETURN [GetPanel[design]]
}; 
RETURN [NARROW[x, Panel]];
};

GetClass: PROC [tech: CD.Technology] RETURNS [Class] = {
IF tech=NIL THEN RETURN [globalClass] 
ELSE {
x: REF _ CDValue.Fetch[boundTo: tech, key: classKey, propagation: technology];
IF x=NIL THEN {
class: Class = NEW[EntryList_NIL];
IF CDValue.StoreConditional[tech, classKey, class] THEN
CDLayers.SetCurrentLayer[tech, CD.commentLayer];
RETURN [GetClass[tech]];
};
RETURN [NARROW[x, Class]];
}
};

Create: PUBLIC ENTRY PROC [design: CD.Design] RETURNS [Viewer] = {
ENABLE UNWIND => NULL;
panel: Panel _ GetPanel[design];
class: Class _ GetClass[design.technology];
IF panel.container#NIL AND NOT panel.container.destroyed THEN RETURN [panel.container];
panel.container _ NIL; panel.actuals _ NIL;
IF class#NIL THEN CreatePanelViewer[panel];
CheckPanelList[panel];
IF panel.container#NIL THEN {
ViewerOps.PaintViewer[panel.container, all]; 
IF ~UserProfile.Boolean["ChipNDale.ControlViewerOpenIconic", FALSE] THEN
ViewerOps.OpenIcon[panel.container];
};
RETURN [panel.container]
};

CheckPanelList: INTERNAL PROC [p: Panel] = {
copiedList: PanelList _ NIL;
FOR list: PanelList _ panelList, list.rest WHILE list#NIL DO
IF list.first.container#NIL AND ~list.first.container.destroyed AND list.first#p THEN 
copiedList _ CONS[list.first, copiedList]
ENDLOOP;
IF p#NIL THEN copiedList _ CONS[p, copiedList];
panelList _ copiedList
};

BuildEntry: INTERNAL PROC[panel: Panel, entry: EntryDef] = {
IF panel.container.destroyed THEN RETURN;
entry.entryClass.build[panel, entry];
};

DefineEntry: INTERNAL PROC [tech: CD.Technology, entryRec: EntryDefRec] RETURNS [entry: EntryDef] = {
IncludeEntryInClass: INTERNAL PROC [class: Class, entry: EntryDef] = {
IF class^=NIL THEN class^ _ LIST[entry]
ELSE
FOR list: EntryList _ class^, list.rest DO
IF list.rest = NIL THEN {list.rest _ LIST[entry]; EXIT} 
ENDLOOP;
};
CreateEntryInViewers: INTERNAL PROC [class: Class, entry: EntryDef] = {
FOR list: PanelList _ panelList, list.rest WHILE list#NIL DO
IF list.first.container#NIL AND ~list.first.container.destroyed THEN {
IF list.first.class=class OR class=globalClass THEN BuildEntry[list.first, entry];
}
ENDLOOP
};
class: Class = GetClass[tech];
entry _ NEW[EntryDefRec_entryRec];
entry.button.xpos _ MIN[2000, entry.button.xpos];
entry.button.width _ MIN[2000, entry.button.width];
entry.button.space _ MIN[2000, entry.button.space];
entry.val.xpos _ MIN[2000, entry.val.xpos];
entry.val.width _ MIN[2000, entry.val.width];
entry.val.space _ MIN[2000, entry.val.space];
IncludeEntryInClass[class, entry];
CreateEntryInViewers[class, entry];
};


Line: PUBLIC ENTRY PROC [tech: CD.Technology] = {
ENABLE UNWIND => NULL;
[] _ DefineEntry[tech, [entryClass: newLineClass]];
};

Button: PUBLIC ENTRY PROC [button: Info, proc: CDSequencer.CommandProc _ NIL, command: ATOM _ NIL, data: REF _ NIL, queue: CDSequencer.QueueMethod _ useDefault, topLine: BOOL _ FALSE, tech: CD.Technology _ NIL] = {
ENABLE UNWIND => NULL;
IF command=NIL AND queue=useDefault THEN queue _ doQueue;
[] _ DefineEntry[tech, [
entryClass: buttonClass,
button: button, val: button,
proc: proc, command: command, 
queue: queue, 
data: data, 
topLine: topLine
]];
};

Label: PUBLIC ENTRY PROC [label: Info, tech: CD.Technology _ NIL] = {
ENABLE UNWIND => NULL;
[] _ DefineEntry[tech, [entryClass: labelClass, button: label, val: label]];
};

Layer: PUBLIC ENTRY PROC [layer: CD.Layer, text: Rope.ROPE, min, default: CD.Number _ 1, option: NAT _ 0, tech: CD.Technology _ NIL] = {
ENABLE UNWIND => NULL;
def: EntryDef _ DefineEntry[tech, [
entryClass: layerClass, 
layer: layer, button: [text: text], min: min, default: default, 
option: option MOD layerOptionsCount
]];
CDProperties.PutProp[CDPrivate.layers[layer].properties, GetClass[tech], def]; 
CDLayers.SetLayerWidth[design: NIL --!!! it sets default--, layer: layer, width: default];
};

Number: PUBLIC ENTRY PROC [button: Info, number: Info, min: INT _ FIRST[INT], max: INT _ LAST[INT], default: INT _ 0, lambda: INT _ 1, tech: CD.Technology _ NIL] = {
ENABLE UNWIND => NULL;
CDValue.StoreInt[boundTo: tech, key: number.cdValueKey, value: default];
button.cdValueKey _ NIL;
number.text _ NIL;
IF number.width<=0 THEN number.width _ 72;
[] _ DefineEntry[tech, [
entryClass: intClass, button: button, val: number,
min: min, max: max, default: default, lambda: lambda
]];
};

Text: PUBLIC ENTRY PROC [button: Info, text: Info, editable: BOOL _ TRUE, tech: CD.Technology _ NIL] = {
ENABLE UNWIND => NULL;
button.cdValueKey _ NIL;
[] _ DefineEntry[tech, [entryClass: textClass, button: button, val: text, editable: editable]];
};

LayerName: PROC [panel: Panel, layer: CD.Layer] RETURNS [r: ROPE] = {
WITH CDProperties.GetListProp[CDPrivate.layers[layer].properties^, panel.class] SELECT FROM
entry: EntryDef => r _ entry.button.text;
ENDCASE => NULL;
IF Rope.IsEmpty[r] THEN {
r _ CDOps.LayerRope[layer];
IF Rope.IsEmpty[r] THEN r _ "not defined"
}
};

NotifyCurrentLayer: CDLayers.DesignNotifyProc = {
panel: Panel = GetPanel[design];
IF panel.layerLabel#NIL THEN {
l: CD.Layer _ CDLayers.CurrentLayer[design];
Labels.Set[panel.layerLabel, LayerName[panel, l]];
}
};

NotifyLayerWidth: CDLayers.LayerNotifyProc = {
panel: Panel = GetPanel[design];
IF panel.layerLabel#NIL THEN {
FOR list: LIST OF Actual _ panel.layerWidths, list.rest WHILE list#NIL DO
IF list.first.define.layer=layer THEN {
Labels.Set[list.first.feedback, 
CDOps.LambdaRope[
n: CDLayers.LayerWidth[design, layer], 
lambda: design.technology.lambda
]
];
};
ENDLOOP;
}
};




Caption: PROC [panel: Panel] RETURNS [ROPE] = {
RETURN [Rope.Cat[
CD.DesignName[panel.design],
"   ", 
panel.design.technology.name, 
"   ", 
CDCellsBackdoor.PushedCellName[panel.design]
]];
};

CreatePanelViewer: INTERNAL PROC [panel: Panel] = {

MakeClassEntries: INTERNAL PROC [class: Class] = {
FOR l: EntryList _ class^, l.rest WHILE l#NIL DO
BuildEntry[panel, l.first];
ENDLOOP;
};

IF panel=NIL OR panel.design=NIL OR panel.design.technology=NIL THEN ERROR;
TerminalIO.PutRopes["create control panel for ", CD.DesignName[panel.design], "\n"];
panel.actuals _ NIL;
panel.layerWidths _ NIL;
panel.nextX _ 0;
panel.nextY _ topY;
panel.container _ Containers.Create[
info: [
name: Caption[panel], 
openHeight: CDValue.FetchInt[panel.design, $PanelHeight, global, 120], 
scrollable: TRUE,
iconic: TRUE, column: right, icon: CDEnvironment.GetPanelIcon[panel.design]
],
paint: FALSE
];   
FOR i: NAT IN [0..layerOptionsCount) DO
panel.layers[i].nextX _ 0;
panel.layers[i].container _ Containers.Create[
info: [
wx: IF i=0 THEN 0 ELSE 1999,
wy: topY+entryHeight+entryHSpace+Containers.ScrollOffset[panel.container],
wh: entryHeight+shorterEntryVSpace+entryHeight+labelYCompensation,
parent: panel.container,
border: FALSE, 
scrollable: FALSE
],
paint: FALSE
];
Containers.ChildXBound[container: panel.container, child: panel.layers[i].container];
ENDLOOP;
ViewerOps.AddProp[panel.container, $ChipNDaleDesign, panel.design];
ViewerOps.AddProp[panel.container, $CDPanelsPrivate, panel];
[] _ NextButton[panel: panel, label: "layer: ", proc: NotifyChangeLayerOption, clientData: panel];
panel.layerLabel _ NextLabel[panel: panel, name: LayerName[panel, CDLayers.CurrentLayer[panel.design]], width: 120];
panel.nextX _ 180;
[] _ NextLabel[panel, "| "];
panel.nexTopX _ panel.nextX;
panel.nextY _ 3*(entryHeight+entryHSpace);
panel.nextX _ 0;
MakeClassEntries[panel.class];
MakeClassEntries[globalClass];
};

NotifyChangeLayerOption: ENTRY Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
panel: Panel _ NARROW[clientData];
this: NAT _ panel.layerOption;
next: NAT _ (this+1) MOD layerOptionsCount;
IF control AND shift THEN 
next _ CDValue.FetchInt[panel.design, $PanelLayerMode, global] MOD layerOptionsCount;
DO
IF next=this THEN RETURN;
IF panel.layers[next].nextX#0 THEN EXIT;
next _ (next+1) MOD layerOptionsCount;
ENDLOOP;
ViewerOps.MoveViewer[
viewer: panel.layers[this].container,
x: 1990, y: panel.layers[this].container.wy,
w: 0, h: panel.layers[this].container.wh,
paint: FALSE
];
panel.layerOption _ next;
ViewerOps.MoveViewer[
viewer: panel.layers[next].container,
x: 0, y: panel.layers[next].container.wy,
w: panel.container.ww, h: panel.layers[next].container.wh,
paint: TRUE
];
};

RepaintCaptions: CDEvents.EventProc = {
panel: Panel _ GetPanel[design];
IF panel.container#NIL THEN {
panel.container.name _ Caption[panel];
ViewerOps.PaintViewer[panel.container, caption];
};
};   

NextIntButton: PROC [panel: Panel, label: ROPE, proc: Buttons.ButtonProc, border: BOOL _ FALSE, clientData: REF ANY _ NIL, width: INT _ -1, space: INT _ -1] = {
button: Buttons.Button = Buttons.Create[
info: [ name: label,
wx: panel.nextX,
ww: SmallDefault[width],
wy: panel.nextY+Containers.ScrollOffset[panel.container]+butYCompensation,
wh: entryHeight,
parent: panel.container,
border: border
],
clientData: clientData,
proc: proc
];
panel.nextX _ button.wx+button.ww+SpaceDefault[space];
};

NextButton: INTERNAL PROC [panel: Panel, label: ROPE, proc: Buttons.ButtonProc, clientData: REF ANY _ NIL, topLine: BOOL _ FALSE, border: BOOL _ FALSE, width: INT _ 0, space: INT_0] RETURNS [button: Buttons.Button] = {
yoff: INT = Containers.ScrollOffset[panel.container];
x: INT _ panel.nextX;
y: INT _ panel.nextY;
IF topLine THEN {x _ panel.nexTopX; y _ 0};
button _ Buttons.Create[
info: [ name: label,
wx: x,
ww: SmallDefault[width],
wy: y+yoff+butYCompensation,
wh: entryHeight,
parent: panel.container,
border: border
],
clientData: clientData,
proc: proc
];
IF topLine THEN panel.nexTopX _ button.wx+button.ww+SpaceDefault[space]
ELSE panel.nextX _ button.wx+button.ww+SpaceDefault[space]
};

NextLabel: PROC [panel: Panel, name: ROPE, border: BOOL _ FALSE, width: INT _ 0, space: INT _ 0] RETURNS [Labels.Label] = {
yoff: INT = Containers.ScrollOffset[panel.container];
label: Labels.Label;
IF name=NIL THEN name _ "       ";
label _ Labels.Create[
info: [ name: name,
wx: panel.nextX,
ww: SmallDefault[width],
wy: panel.nextY+yoff+labelYCompensation,
wh: entryHeight,
parent: panel.container,
border: border
]
];
panel.nextX _ label.wx+label.ww+SpaceDefault[space];
RETURN [label]
};

BuildInt: BuildProc = {
initialValue: ROPE; width: INT;
actual: Actual _ NEW[ActualRec _ [panel: panel, define: entry]];
panel.nextX _ MAX[entry.button.xpos, panel.nextX];
width _ entry.button.width;
IF entry.button.maxx>0 THEN width _ entry.button.maxx-panel.nextX;
[] _ NextIntButton[panel: panel, label: entry.button.text, proc: IntCalled, clientData: actual, space: entry.button.space, width: width];
initialValue _ CDOps.LambdaRope[
n: CDValue.FetchInt[panel.design, entry.val.cdValueKey, technology, entry.default],
lambda: ActualLambda[actual]
];
panel.nextX _ MAX[entry.val.xpos, panel.nextX+8];
width _ entry.val.width;
IF entry.val.maxx>0 THEN width _ entry.val.maxx-panel.nextX;
actual.feedback _ NextLabel[panel: panel, name: initialValue, width: entry.val.width];
panel.actuals _ CONS[actual, panel.actuals];
};

ActualLambda: PROC [actual: Actual] RETURNS [lambda: INT] = {
lambda _ actual.define.lambda;
IF lambda<=0 THEN lambda _ actual.panel.design.technology.lambda
};

ToDisplayNumber: ToDisplayProc = {
n: INT;
lambda: INT _ ActualLambda[actual];
WITH value SELECT FROM
ri: REF INT => n _ ri^
ENDCASE => n _ actual.define.default;
Buttons.ReLabel[actual.feedback, CDOps.LambdaRope[n, lambda]];
};

BuildLabel: BuildProc = {
actual: Actual_NIL;
lab: Labels.Label;
width: INT _ entry.button.width;
panel.nextX _ MAX[entry.button.xpos, panel.nextX];
IF entry.button.maxx>0 THEN width _ entry.button.maxx-panel.nextX;
lab _ NextLabel[
panel: panel, 
name: entry.button.text, 
width: width,
space: entry.button.space,
border: entry.button.border
];
IF entry.val.cdValueKey#NIL THEN {
actual _ NEW[ActualRec _ [panel: panel, 
define: entry, 
feedback: lab 
]];
panel.actuals _ CONS[actual, panel.actuals];
RedisplayVal[actual];
}
};

ToDisplayLabel: ToDisplayProc = {
Labels.Set[actual.feedback, CDOps.ToRope[value, "-?-"]];
};


FetchRopeWithList: PROC [from: REF, key: REF, start: ROPE_NIL] RETURNS [ROPE] = {
NextName: PROC [list: LIST OF ROPE, last: ROPE_NIL] RETURNS [next: ROPE _ NIL] = {
IF list=NIL THEN RETURN;
FOR l: LIST OF ROPE _ list, l.rest WHILE l#NIL DO
IF Rope.Equal[last, l.first, FALSE] THEN 
RETURN [IF l.rest=NIL THEN list.first ELSE l.rest.first]
ENDLOOP;
RETURN [list.first]
};
WITH CDValue.Fetch[from, key, global] SELECT FROM
r: ROPE => RETURN [r];
rt: REF TEXT => RETURN [Rope.FromRefText[rt]];
lr: LIST OF ROPE => RETURN [NextName[lr, start]];
ENDCASE => RETURN [NIL];
};

TextButProc: Menus.ClickProc = {
actual: Actual _ NARROW[clientData];
selection: REF ViewerTools.SelPosRec _ NIL;
v: Viewer _ actual.feedback; --not the button; the text
SELECT TRUE FROM
mouseButton=blue => ViewerTools.SetContents[v, NIL];
ViewerTools.GetSelectedViewer[]=v => {--viewer previously selected; iterate through.
contents: ROPE _ FetchRopeWithList[actual.panel.design.technology, actual.define.val.cdValueKey, ViewerTools.GetContents[v]];
ViewerTools.SetContents[v, contents];
selection _ NEW[ViewerTools.SelPosRec _ [start: contents.Length[], length: 0]];
};
ENDCASE => NULL;
ViewerTools.SetSelection[v, selection];
};

TextLabButProc: Menus.ClickProc = {
FetchSimpleRope: PROC [from: REF, key: REF] RETURNS [ROPE] = INLINE {
WITH CDValue.Fetch[from, key, global] SELECT FROM
r: ROPE => RETURN [r];
rt: REF TEXT => RETURN [Rope.FromRefText[rt]];
ENDCASE => RETURN [NIL];
};
contents, start: ROPE;
actual: Actual _ NARROW[clientData];
cdValueKey: REF _ actual.define.val.cdValueKey;
start _ FetchSimpleRope[actual.panel.design, cdValueKey];
contents _ FetchRopeWithList[actual.panel.design.technology, cdValueKey, start];
CDValue.Store[actual.panel.design, cdValueKey, contents];
Labels.Set[actual.feedback, contents];
};

SmallDefault: PROC [w: INT] RETURNS [INT] = {
RETURN [IF w<=0 THEN 0 ELSE MIN[2000, w]]
};

SpaceDefault: PROC [s: INT] RETURNS [INT] = {
RETURN [IF s<=0 THEN entryHSpace ELSE MIN[200, s]]
};

BuildText: BuildProc = {
v: Viewer; x, y: INT;
actual: Actual _ NEW[ActualRec _ [panel: panel, define: entry, feedback: NIL]];
width: INT;
height: INT _ entryHeight;
panel.nextX _ MAX[entry.button.xpos, panel.nextX];
y _ panel.nextY+Containers.ScrollOffset[panel.container];
x _ panel.nextX;
width _ SmallDefault[entry.button.width];
IF entry.button.maxx>0 THEN width _ entry.button.maxx-panel.nextX;
IF ~Rope.IsEmpty[entry.button.text] THEN {
button: Buttons.Button _ Buttons.Create[
info: [ name: entry.button.text,
wx: x, ww: width,
wy: y+butYCompensation, wh: height,
border: FALSE,
parent: panel.container
],
clientData: actual,
proc: IF entry.editable THEN TextButProc ELSE TextLabButProc
];
x _ button.wx+button.ww+SpaceDefault[entry.button.space];
};
x _ MAX[x, entry.val.xpos];
width _ IF entry.val.width<=0 THEN 2000 ELSE MIN[entry.val.width, 2000];
IF entry.val.maxx>0 THEN width _ entry.val.maxx-panel.nextX;
IF entry.editable THEN
v _ actual.feedback _ ViewerTools.MakeNewTextViewer[info: [
wx: x, wy: y+textYCompensation, ww: width, wh: height+textHCompensation,
parent: panel.container,
border: FALSE,
data: FetchRopeWithList[panel.design, entry.val.cdValueKey] 
]]
ELSE
v _ actual.feedback _ Labels.Create[info: [
name: FetchRopeWithList[panel.design, entry.val.cdValueKey],
wx: x, ww: width, 
wy: y+labelYCompensation, wh: height,
parent: panel.container,
border: FALSE
]];
panel.nextX _ v.wx+v.ww+SpaceDefault[entry.val.space];
IF entry.val.width<=0 AND entry.val.maxx<=0 THEN Containers.ChildXBound[panel.container, v];
panel.actuals _ CONS[actual, panel.actuals];
};

ToDisplayText: ToDisplayProc = {
entry: EntryDef _ actual.define;
design: CD.Design _ actual.panel.design;
rope: ROPE _ CDOps.ToRope[value, " "];
v: Viewer _ actual.feedback;
IF v.class.flavor=$Label THEN Labels.Set[v, rope]
ELSE ViewerTools.SetContents[v, rope];
};

FromDisplayText: FromDisplayProc = {
RETURN [ViewerTools.GetContents[NARROW[actual.feedback]]];
};

RedisplayVal: PROC [actual: Actual] = {
IF actual.define.val.cdValueKey#NIL THEN 
ToDisplay[actual, CDValue.Fetch[actual.panel.design, actual.define.val.cdValueKey, global]]
};

ToDisplay: PROC [actual: Actual, x: REF] = {
IF actual.define.entryClass.toDisplay#NIL THEN actual.define.entryClass.toDisplay[actual, x];
};

PutUpAll: PUBLIC PROC [design: CD.Design] = {
panel: Panel = GetPanel[design];
IF panel.container=NIL OR panel.container.destroyed THEN RETURN;
FOR list: LIST OF Actual _ panel.actuals, list.rest WHILE list#NIL DO
IF list.first.define.val.redisplay THEN RedisplayVal[list.first];
ENDLOOP;
};

BuildButton: INTERNAL PROC [panel: Panel, entry: EntryDef] = {
but: Buttons.Button;
width: INT _ SmallDefault[entry.button.width];
panel.nextX _ MAX[entry.button.xpos, panel.nextX];
IF entry.button.maxx>0 THEN width _ entry.button.maxx-panel.nextX;
but _ NextButton[
panel: panel, 
label: entry.button.text, 
proc: ButtonCalled, 
border: entry.button.border,
topLine: entry.topLine,
width: width,
clientData: entry
];
IF entry.val.cdValueKey#NIL THEN {
actual: Actual _ NEW[ActualRec _ [panel: panel, define: entry, feedback: but]];
panel.actuals _ CONS[actual, panel.actuals];
RedisplayVal[actual];
}
};

ToDisplayButton: ToDisplayProc = {
Buttons.ReLabel[actual.feedback, CDOps.ToRope[value, "-?-"]];
};

ButtonCalled: Buttons.ButtonProc = {
butDef: EntryDef = NARROW[clientData];
comm: CDSequencer.Command = NEW[CDSequencer.CommandRec_[
data: butDef.data,
design: CDViewer.DesignOf[NARROW[parent]],
n: ORD[mouseButton],
b: shift OR control,
ref: $Panel
]];
IF butDef.proc#NIL THEN
CDSequencer.ExecuteProc[comm: comm, proc: butDef.proc, queue: butDef.queue]
ELSE IF butDef.command#NIL THEN
CDSequencer.ExecuteCommand[comm: comm, key: butDef.command, queue: butDef.queue];
};


GetAnInt: PROC [old, default: INT, label: ROPE, lambda: INT_1] RETURNS [new: INT] = {
ENABLE TerminalIO.UserAbort => GOTO aborted;
choice: LIST OF ROPE;
new _ old;
IF lambda=1 THEN 
choice _ LIST["+1", "-1", "*2", "/2", "default", "type"] 
ELSE 
choice _ LIST["+1", "-1", "*2", "/2", "default", "type", Rope.Concat["type * ", CDOps.LambdaRope[1, lambda]], "trunc"];
SELECT PopUpSelection.Request[header: label, choice: choice] FROM
1 => new _ Inc[old, lambda];
2 => new _ Dec[old, lambda]; 
3 => new _ Double[old];
4 => new _ old/2;
5 => new _ default;
6 => new _ TerminalIO.RequestInt["type value > "]*lambda;
7 => new _ TerminalIO.RequestInt[Rope.Cat["type value ", CDOps.LambdaRope[1, lambda], " > "]];
8 => new _ old/lambda*lambda;
ENDCASE => TerminalIO.PutRope["Skipped\n"];
EXITS aborted => NULL;
};

IntCalled: Buttons.ButtonProc = {
design: CD.Design _ CDViewer.DesignOf[NARROW[parent]];
IF design=NIL THEN RETURN;
CDSequencer.ExecuteProc[
proc: SerializedIntCalled, 
design: design, 
queue: doQueue, 
comm: NEW[CDSequencer.CommandRec _ [
data: clientData, 
key: SELECT mouseButton FROM 
red => $left, yellow => $middle, blue => $right, 
ENDCASE => NIL,
n: IF control THEN 1 ELSE 0,
b: shift
]]
];
};

SerializedIntCalled: PROC [comm: CDSequencer.Command] = {
ENABLE UNWIND => NULL;
design: CD.Design ~ comm.design; 
actual: Actual ~ NARROW[comm.data];
intDef: EntryDef ~ actual.define;
lambda: INT _ ActualLambda[actual];
i: INT _ CDValue.FetchInt[design, intDef.val.cdValueKey, global, intDef.default];
SELECT TRUE FROM
comm.b => { 
IF comm.n=1 THEN i _ i/lambda*lambda 
ELSE i _ GetAnInt[i, intDef.default, intDef.button.text, lambda]
};
comm.key=$right => {
IF comm.n=1 THEN i_i/2 ELSE i _ Dec[i, lambda]
};
comm.key=$left => {
IF comm.n=1 THEN i _ Double[i] ELSE i _ Inc[i, lambda]
};
ENDCASE => NULL;
i _ MAX[MIN[i, intDef.max], intDef.min];
CDValue.StoreInt[design, intDef.val.cdValueKey, i];
Labels.Set[actual.feedback, CDOps.LambdaRope[n: i, lambda: lambda]];
};

BuildNewLine: BuildProc = {
panel.nextY _ panel.nextY+entryHSpace+entryHeight;
panel.nextX _ 0;
};

BuildLayer: BuildProc = {
p: Actual _ NEW[ActualRec _ [define: entry, panel: panel]];
option: NAT _ entry.option;
button: Buttons.Button = Buttons.Create[
info: [ name: entry.button.text,
wx: panel.layers[option].nextX,
wy: butYCompensation,
wh: entryHeight,
parent: panel.layers[option].container,
border: FALSE
],
clientData: p,
proc: WireWidthCalled
];
p.feedback _ Labels.Create[
info: [
wx: panel.layers[option].nextX,
wy: shorterEntryVSpace+entryHeight+labelYCompensation,
wh: entryHeight,
ww: button.ww+4*entryHSpace, --2 spaces for real; 2 covering leading blank of next #
parent: panel.layers[option].container,
border: FALSE,
name: CDOps.LambdaRope[
n: CDLayers.LayerWidth[panel.design, entry.layer],
lambda: panel.design.technology.lambda
]
]
];
panel.layers[option].nextX _ button.wx+button.ww+2*entryHSpace; 
panel.layerWidths _ CONS[p, panel.layerWidths];
};

WireWidthCalled: Buttons.ButtonProc = {
wireRef: Actual = NARROW[clientData];
CDSequencer.ExecuteProc[
proc: SerializedWireWidthCalled, 
design: wireRef.panel.design, 
queue: doQueue, 
comm: NEW[CDSequencer.CommandRec _ [
data: clientData, 
key: SELECT mouseButton FROM 
red => $left, 
yellow => $middle, 
blue => $right, 
ENDCASE => NIL,
n: IF control THEN 1 ELSE 0,
b: shift
]]
];
};

SerializedWireWidthCalled: PROC[comm: CDSequencer.Command] = {
wireRef: Actual = NARROW[comm.data];
layer: CD.Layer = wireRef.define.layer;
design: CD.Design _ wireRef.panel.design;
width: CD.Number _ CDLayers.LayerWidth[design, layer];
lambda: INT _ design.technology.lambda;
IF comm.b THEN { 
IF comm.n=1 THEN width _ width/lambda*lambda 
ELSE width _ GetAnInt[width, wireRef.define.default, wireRef.define.button.text, lambda]
}
ELSE IF comm.key=$right THEN {
IF comm.n=1 THEN width _ width/2 ELSE width _ Dec[width, lambda]
}
ELSE IF comm.key=$left THEN { 
IF comm.n=1 THEN width _ Double[width] ELSE width _ Inc[width, lambda]
}
ELSE IF comm.key=$middle THEN {
CDLayers.SetCurrentLayer[design, layer];
RETURN
};
CDLayers.SetLayerWidth[design, layer, MAX[width, 0]];
};

DoFromDisplayVal: PROC [actual: Actual] RETURNS [x: REF] = {
RETURN [
IF actual.define.entryClass.fromdisplay=NIL 
THEN CDValue.Fetch[actual.panel.design, actual.define.val.cdValueKey, global]
ELSE actual.define.entryClass.fromdisplay[actual]
]  
};

FromDisplayNoStoreVal: PROC [design: CD.Design, cdValueKey: REF] RETURNS [REF_NIL] = {
panel: Panel = GetPanel[design];
FOR list: LIST OF Actual _ panel.actuals, list.rest WHILE list#NIL DO
IF list.first.define.val.cdValueKey=cdValueKey THEN
RETURN [DoFromDisplayVal[list.first]]
ENDLOOP;
};

TakeDown: PUBLIC PROC [design: CD.Design, cdValueKey: REF] RETURNS [x: REF] = {
x _ FromDisplayNoStoreVal[design, cdValueKey];
WITH x SELECT FROM
rt: REF TEXT => x _ Rope.FromRefText[rt];
ENDCASE => NULL;
CDValue.Store[design, cdValueKey, x];
};

TakeDownText: PUBLIC PROC [design: CD.Design, cdValueKey: REF] RETURNS [Rope.ROPE] = {
WITH TakeDown[design, cdValueKey] SELECT FROM
r: Rope.ROPE => RETURN [r];
ENDCASE => RETURN [NIL];
};

ToDisplayNoFetchVal: PROC [design: CD.Design, cdValueKey: REF, value: REF] = {
panel: Panel = GetPanel[design];
IF panel.container=NIL OR panel.container.destroyed THEN RETURN;
FOR list: LIST OF Actual _ panel.actuals, list.rest WHILE list#NIL DO
IF list.first.define.val.cdValueKey=cdValueKey THEN {
ToDisplay[list.first, value];
}
ENDLOOP;
};

PutUpText: PUBLIC PROC [design: CD.Design, cdValueKey: REF, rope: Rope.ROPE] = {
CDValue.Store[design, cdValueKey, rope];
ToDisplayNoFetchVal[design, cdValueKey, rope];
};

PutUp: PUBLIC PROC [design: CD.Design, cdValueKey: REF] RETURNS [REF_NIL] = {
value: REF;
IF cdValueKey=$PanelLayerMode THEN {
panel: Panel _ GetPanel[design];
NotifyChangeLayerOption[panel.container, panel, red, TRUE, TRUE];
RETURN
};
value _ CDValue.Fetch[design, cdValueKey, global];
ToDisplayNoFetchVal[design, cdValueKey, value];
RETURN [value]
};

ContainerDeleted: ViewerEvents.EventProc = {
WITH ViewerOps.FetchProp[viewer, $CDPanelsPrivate] SELECT FROM
panel: Panel => {
ViewerOps.AddProp[viewer, $ChipNDaleDesign, NIL];
ViewerOps.AddProp[viewer, $CDPanelsPrivate, NIL];
IF panel.container=viewer AND panel.design#NIL THEN {
CDValue.Store[panel.design, panelKey, NIL];
panel.container _ NIL;
panel.design _ NIL;
panel.class _ NIL;
panel.layerLabel _ NIL;
panel.layerWidths _ NIL;
panel.actuals _ NIL;
};
};
ENDCASE => NULL;
};
EnumDesigns: PROC[p: CDPrivate.DesignEnumerator] RETURNS [quit: BOOL_FALSE] = {
FOR list: PanelList _ panelList, list.rest WHILE list#NIL AND ~quit DO
IF list.first.container#NIL AND ~list.first.container.destroyed THEN {
d: CD.Design _ list.first.design;
IF d#NIL THEN quit _ p[d];
} 
ENDLOOP;
};

Double: PROC[i: INT] RETURNS [INT] = INLINE {
IF i<LAST[INT]/2 AND i>(FIRST[INT]/2) THEN i _ i+i;
RETURN [i]
};

Inc: PROC[i: INT, x: INT_1] RETURNS [INT] = INLINE {
IF i<=LAST[INT]-x THEN i _ i+x;
RETURN [i]
};

Dec: PROC[i: INT, x: INT_1] RETURNS [INT] = INLINE {
IF i>=FIRST[INT]+x THEN i _ i-x;
RETURN [i]
};
[] _ CDValue.RegisterKey[panelKey, NIL];
[] _ CDValue.RegisterKey[classKey, NIL];
CDValue.RegisterKey[key: $PanelHeight];
CDEvents.RegisterEventProc[$RenameDesign, RepaintCaptions];
CDEvents.RegisterEventProc[$AfterPush, RepaintCaptions];
CDEvents.RegisterEventProc[$AfterPop, RepaintCaptions];
CDLayers.RegisterNotifiers[layer: NotifyCurrentLayer, width: NotifyLayerWidth];
[] _ ViewerEvents.RegisterEventProc[ContainerDeleted, destroy, $Container];
CDPrivate.InstallDesignEnumerator[EnumDesigns];
END. 


0CDPanelImpl.mesa    (part of ChipNDale)
Copyright c 1983, 1987 by Xerox Corporation.  All rights reserved.
Created by Christian Jacobi, August 8, 1983 5:20 pm 
Last Edited by: Christian Jacobi, March 18, 1987 12:37:04 pm PST

Terminology in procedure names
Build: build entry [instance] into a viewer
Define: define [register] behaviour for class
PutUp: reset picture on screen from CDValue
Called: proc is called by interactive action
--Compensations
--the viewer package uses funny y positions; use this to compensate
--the height sometimes are not enogh to reasonably display contents...
-- Viewer
--supress creation of viewer if empty
--Get rid of panels which are not used anymore 
--No user visible action 
-- Define's ===========================================================
--we need to find names

--  special treatment for layers ===========================================================
EXIT; don't exit in case of multiple buttons...

-- Viewer Stuff -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
--uses intermediate layer variables!
--special hack to make this outside accessible
--called from special buttons which have a Text as actual.feedback
--new contents is not stored to CDValue yet!! (It wont if edited either)
--called from special buttons which have a Label as actual.feedback
--default width for buttons
--default spacing

-- ================================================
--special hack to change layer mode
--break circularities


--vanilla utilities ================================

--module initialization ================================
�Ê&˜
codeš
œ'™'Kšœ
Ïm
œ7™BKš
œ4™4K™@K™—š
Ïk	˜	K˜	Kšžœ
˜K˜K˜K˜	Kš
œ	˜	Kš
œ˜Kš
œ˜K˜
Kš
œ
˜
K˜K˜Kš
œ	˜	Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜K˜K˜
Kš
œ
˜
Kš
œ˜K˜
K˜—K˜šÏnœžœ
žœ
˜Kšžœ
žœÝ
˜ð
Kšžœ˜Kšžœ˜—Kš
ž˜K˜š
Ïb™Kš œ&™+Kš œ'™-Kš œ&™+Kš œ&™,—K˜Kšžœžœžœ
˜Kšœžœ˜$Kšœžœ˜K˜šœžœžœ˜Kšœžœ
˜Kšœžœ˜K˜—Kšœžœ˜K˜KšœžœžœÏc,˜Hšœ
žœžœ˜Kšœžœ
˜Kšœ
žœ˜Kšœžœžœ˜6Kšœžœ˜Kšœžœ
˜Kšœžœ˜Kšœžœ˜Kšœ	žœ˜Kšœžœ
˜Kšœ
žœ
žœ
žœ
˜"Kšœ	žœ
žœ
ž˜Kš
œ˜—Kšœžœžœ
žœ˜!K˜Kšœžœžœ¡˜@šœžœžœ˜Kš
œ˜Kšœžœ
˜Kšœžœ¡˜?Kšœžœž˜Kš
œ˜—K˜Kšœžœžœ"¡˜WKšœžœžœžœ˜9Kšœžœžœžœ	žœ
žœ˜HK˜Kšœ
žœžœ¡˜5šœ
žœžœ˜Kš
œ˜Kšœ¡)˜>Kšœžœ˜#Kšœžœ	žœžœ˜1Kšœžœžœ
˜ Kšœ žœ˜%Kšœ	žœžœ
˜Kš
œ,˜,Kšœžœž˜K˜—K˜Kšœžœžœ
žœ˜%Kšœžœžœ¡˜2K˜Kšœžœžœ
¡0˜Ošœžœžœ˜Kš
œ˜Kš
œ˜Kšœžœ
¡;˜RKš
œ˜—K˜Kš
œ
žœ
žœžœ
žœ¡-˜UKš	œ
žœ
žœžœ
žœ˜+Kšœžœžœ˜(Kšœžœ
˜K˜š
œ/˜/Kš
œ˜Kš
œ˜—š
œ.˜.Kš
œ˜Kš
œ˜Kš
œ˜—š
œ-˜-Kš
œ˜Kš
œ˜Kš
œ˜—š
œ,˜,Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—š
œ-˜-Kš
œ˜Kš
œ˜—š
œ+˜+Kš
œ˜Kš
œ˜Kš
œ˜—K˜š
œ™K™CKšœžœ˜Kšœžœ˜ Kšœžœ˜ K™FKšœžœ˜—K˜š
œ	™	Kšœžœ˜Kšœ
žœ˜Kšœ
žœ˜Kšœžœ˜!K˜—K˜šŸœžœžœ˜PKšœžœ˜ K˜—K˜šŸœžœ
žœ	žœ˜6KšœžœF˜Lšžœžœ
žœ˜šœžœ˜Kš
œ˜Kš
œ"˜"Kš
œ˜—Kš
œ7˜7Kšžœ˜Kš
œ˜—Kšžœžœ˜Kš
œ˜K˜—šŸœžœžœ
žœ˜8Kšžœžœ
žœ
žœ˜&šžœ˜KšœžœH˜Nšžœžœ
žœ˜Kšœžœžœ˜"šžœ1ž˜7Kšœžœ˜0—Kšžœ˜Kš
œ˜—Kšžœžœ˜K˜
—Kš
œ˜K˜—šŸœžœ
žœ
žœ
žœ	žœ
˜BKšžœ
žœžœ
˜K˜ Kš
œ+˜+Kšžœžœ
žœ
žœžœ
žœ˜WKšœžœžœ
˜+Kš
œ%™%Kšžœžœ
žœ˜+Kš
œ˜šžœžœ
žœ˜Kš
œ-˜-šžœ;žœž˜HKš
œ$˜$—K˜—Kšžœ˜Kš
œ˜K˜—šŸœžœ
žœ˜,K™/K™Kšœžœ
˜šžœ(žœžœ
ž˜<š
žœžœ
žœ!žœžœ
˜VKšœ
žœ˜)—Kšžœ
˜—Kšžœžœ
žœžœ˜/Kš
œ˜Kš
œ˜—K˜šŸ
œžœ
žœ#˜<Kšžœžœ
žœ
˜)Kš
œ%˜%Kš
œ˜—K˜š
Ÿœžœ
žœžœ$žœ˜ešŸœž
œ$˜FKšžœžœ
žœ
žœ˜'š
ž˜šžœ%ž˜*Kš
žœ
žœ
žœžœ	žœ˜8Kšžœ
˜——Kš
œ˜—šŸœž
œ$˜Gšžœ(žœžœ
ž˜<šžœžœ
žœ!žœ˜FKšžœžœžœ˜RK˜
—Kš
ž˜—Kš
œ˜—Kš
œ˜Kšœžœ˜"Kšœžœ˜1Kšœžœ˜3Kšœžœ˜3Kšœžœ˜+Kšœžœ˜-Kšœžœ˜-Kš
œ"˜"Kš
œ#˜#Kš
œ˜—K˜Kš
œG™GK˜š
Ÿœžœ
žœ
žœžœ˜1Kšžœ
žœžœ
˜Kš
œ3˜3Kš
œ˜—K˜šŸœžœ
žœ
žœ0žœžœžœžœžœ8žœžœžœžœ˜Ö
Kšžœ
žœžœ
˜Kšžœ	žœ
žœžœ˜9š
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ˜K˜—šŸœžœ
žœ
žœ
žœžœ
žœ˜EKšžœ
žœžœ
˜Kš
œL˜LKš
œ˜—K˜šŸœžœ
žœ
žœ	žœžœžœžœžœžœ˜ˆ
Kšžœ
žœžœ
˜š
œ#˜#Kš
œ˜Kš
œ@˜@Kšœžœ˜$Kš
œ˜—š
œO˜OKš
œ™—Kšœžœ
¡œ ˜ZKš
œ˜—K˜šŸœžœ
žœ
žœ#žœžœ
žœžœžœ
žœžœžœžœžœ˜¥
Kšžœ
žœžœ
˜Kš
œH˜HKšœžœ
˜Kšœžœ
˜Kšžœžœ˜*š
œ˜Kš
œ2˜2Kš
œ4˜4Kš
œ˜—Kš
œ˜—K˜šŸœžœ
žœ
žœ&žœ
žœžœžœ˜hKšžœ
žœžœ
˜Kšœžœ
˜Kš
œ_˜_Kš
œ˜—K™Kš
œ\™\K˜š
Ÿ	œžœžœžœžœ˜EšžœLžœ
ž˜[Kš
œ)˜)Kšžœžœ
˜—šžœžœ˜Kš
œ˜Kšžœžœ˜)K˜
—K˜—K˜šÐbnœ˜1K˜ šžœžœ
žœ˜Kšœžœ'˜,Kš
œ2˜2K˜
—Kš
œ˜—K˜š¢œ˜.K˜ šžœžœ
žœ˜šžœžœ
žœ'žœžœ
ž˜Išžœžœ˜'š
œ ˜ š
œ˜Kš
œ'˜'Kš
œ ˜ Kš
œ
˜
—Kš
œ˜—Kšžœ+™/K˜—Kšžœ
˜—K˜
—Kš
œ˜—K˜K™Kš
œ?™?K˜K˜K˜šŸœžœžœžœ˜/šžœ˜Kš
œ˜K˜Kš
œ˜K˜K˜,K˜—Kš
œ˜K˜—šŸœžœ
žœ˜3K˜šŸœžœ
žœ˜2Kš
œ$™$šžœžœžœ
ž˜0Kš
œ˜Kšžœ
˜—Kš
œ˜—K˜Kšžœžœ
žœžœ
žœžœ
žœ
žœ
˜KKš
œT˜TKšœžœ
˜Kšœžœ
˜Kš
œ˜Kš
œ˜š
œ$˜$š
œ˜K˜Kš
œG˜GKšœžœ
˜Kšœžœ?˜KK˜—Kšœž˜K˜—šžœžœ
žœž˜'Kš
œ˜š
œ.˜.š
œ˜Kšœžœžœžœ˜Kš
œJ˜JKš
œB˜BKš
œ˜Kšœžœ˜Kšœž˜K˜—Kšœž˜K˜—Kš
œU˜UKšžœ
˜—Kš
œC˜CKš
œ<˜<Kš
œb˜bKš
œt˜tKš
œ˜K˜Kš
œ˜Kš
œ*˜*K˜Kš
œ˜Kš
œ˜Kš
œ˜K˜—šŸœžœ˜5Kšžœ
žœžœ
˜Kšœžœ
˜"Kšœžœ˜Kšœžœžœ˜+Kš
œ.™.šžœ	žœžœ
˜Kšœ?žœ˜U—š
ž˜Kšžœžœ
žœ
˜Kšžœžœ
žœ
˜(Kšœžœ˜&Kšžœ
˜—š
œ˜Kš
œ%˜%Kš
œ,˜,Kš
œ)˜)Kšœž˜K˜—Kš
œ˜š
œ˜Kš
œ%˜%Kš
œ)˜)Kš
œ:˜:Kšœž˜K˜—K˜—K˜šŸœ˜'K˜ šžœžœ
žœ˜K˜&K˜0K˜—š
œ˜K˜——šŸ
œžœžœ$žœžœžœ
žœžœ	žœžœ
˜ 
š
œ(˜(˜Kš
œ˜Kš
œ˜Kš
œJ˜JKš
œ˜K˜K˜K˜—K˜K˜
K˜—Kš
œ6˜6Kš
œ˜K˜—šŸ
œžœ
žœžœ(žœ
žœžœžœžœ
žœžœ	žœ
žœžœ˜Ú
Kšœžœ,˜5Kšœžœ˜Kšœžœ˜Kšžœ	žœ˜+š
œ˜˜K˜Kš
œ˜Kš
œ˜K˜K˜Kš
œ˜K˜—K˜K˜
K˜—Kšžœ	žœ8˜GKšžœ6˜:Kš
œ˜K˜—šŸ	œžœžœ
žœžœ	žœ
žœžœ˜{Kšœžœ,˜5K˜Kšžœžœ
žœ˜"˜˜Kš
œ˜Kš
œ˜Kš
œ(˜(K˜K˜K˜K˜
—K˜—Kš
œ4˜4Kšžœ˜Kš
œ˜K˜—šŸœ˜Kšœžœ	žœ
˜Kšœžœ,˜@Kšœžœ!˜2Kš
œ˜Kšžœžœ'˜BKš
œ‰
˜‰
š
œ ˜ Kš
œS˜SKš
œ˜Kš
œ˜—Kšœžœ ˜1Kš
œ˜Kšžœžœ$˜<Kš
œV˜VKšœžœ˜,Kš
œ˜—K˜šŸœžœžœ
žœ˜=Kšœžœž
˜Kšžœžœžœ%˜@K˜—K˜šŸœ˜"Jšœžœ
˜Kšœžœ˜#šžœžœ
ž˜Jšœžœ
žœ˜Jšžœ˜%—Kš
œ>˜>K˜—K˜šŸ
œ˜Kšœžœ
˜Kš
œ˜Kšœžœ˜ Kšœžœ!˜2Kšžœžœ'˜Bš
œ˜Kš
œ˜Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜—šžœžœ
žœ˜"šœ	žœ˜(Kš
œ˜Kš
œ˜Kš
œ˜—Kšœžœ˜,Kš
œ˜K˜
—Kš
œ˜—K˜šŸœ˜!Kš
œ8˜8K˜—K˜K˜šŸœžœžœžœ	žœ
žœžœžœ˜QšŸœžœžœ
žœ
žœžœ
žœžœžœžœ˜RKšžœžœ
žœ
žœ
˜š
žœžœ
žœ
žœžœžœ
ž˜1šžœžœžœ
˜)Kš
žœžœžœ
žœžœ˜8—Kšžœ
˜—Kšžœ
˜K˜—šžœ"žœ
ž˜1Kšœžœžœ˜Kšœžœ
žœžœ˜.Kš	œžœ
žœ
žœžœ˜1Kšžœžœžœ˜—K˜—K˜šŸœ˜ Kš
œB™BKšœžœ
˜$Kšœžœžœ
˜+Kšœ¡˜7šžœ
žœ
ž˜Kšœ/žœ˜4šœ&¡.˜TKšœ
žœo˜}Kš
œ%˜%Kšœžœ@˜OK˜—Kšžœžœ
˜—Kš
œ'˜'Kš
œH™HK˜—K˜šŸœ˜#Kš
œC™CšŸœžœžœžœžœžœžœ˜Ešžœ"žœ
ž˜1Kšœžœžœ˜Kšœžœ
žœžœ˜.Kšžœžœžœ˜—Kš
œ˜—Kšœžœ
˜Kšœžœ
˜$Kšœžœ ˜/Kš
œ9˜9Kš
œP˜PKš
œ9˜9Kš
œ&˜&K˜—K˜š
Ÿœžœžœžœžœ˜-Kš
¡™Kš
žœžœžœžœ
žœ
˜)K˜—K˜š
Ÿœžœžœžœžœ˜-Kš
¡™Kš
žœžœžœ
žœ
žœ	˜2K˜—K˜šŸ	œ˜Kšœžœ
˜Kšœžœ5žœ˜OKšœžœ
˜Kšœžœ˜Kšœžœ!˜2Kš
œ9˜9Kš
œ˜Kš
œ)˜)Kšžœžœ'˜Bšžœ"žœ˜*š
œ(˜(š
œ ˜ Kš
œ˜Kš
œ#˜#Kšœžœ
˜K˜K˜—Kš
œ˜Kšœžœžœ
žœ˜<K˜—Kš
œ9˜9Kš
œ˜—Kšœžœ˜Kš	œžœžœžœ
žœ˜HKšžœžœ$˜<šžœž˜š
œ;˜;Kš
œH˜HKš
œ˜Kšœžœ
˜Kš
œ<˜<Kš
œ˜——š
ž˜š
œ+˜+Kš
œ<˜<Kš
œ˜Kš
œ%˜%K˜Kšœž˜
K˜——Kš
œ6˜6Kšžœžœžœ,˜\Kšœžœ˜,Kš
œ˜—K˜šŸ
œ˜ Kš
œ ˜ Kšœžœ˜(Jšœžœ˜&Kš
œ˜Kšžœžœ˜1Kšžœ"˜&K˜—K˜šŸœ˜$Kšžœžœ˜:K˜—K™K™3K˜šŸœžœ˜'šžœžœ
žœ
˜)Kš
œ[˜[—Kš
œ˜—K˜šŸ	œžœžœ˜,Kšžœ$žœ
žœ/˜]Kš
œ˜—K˜šŸœžœ
žœ
žœ˜-K˜ Kš
žœžœ
žœžœ
žœ
˜@šžœžœ
žœ#žœžœ
ž˜EKšžœ!žœ˜AKšžœ
˜—Kš
œ˜—K˜šŸœžœ
žœ$˜>Kš
œ˜Kšœžœ$˜.Kšœžœ!˜2Kšžœžœ'˜Bš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ˜—šžœžœ
žœ˜"Kšœžœ;˜OKšœžœ˜,Kš
œ˜K˜
—Kš
œ˜—K˜šŸœ˜"Kš
œ=˜=K˜—K˜š¢œ˜$Kšœžœ
˜&šœžœ˜8Kš
œ˜Kšœžœ
˜*Kšœžœ˜Kšœ	žœ	˜Kš
œ˜Kš
œ˜—šžœ
žœ
ž˜Kš
œK˜K—šžœ
žœžœ
ž˜Kš
œQ˜Q—Kš
œ˜K˜—K˜šŸœžœžœ	žœ
žœžœžœ˜UKšžœžœ	˜,Kšœžœ
žœ
žœ
˜Kš
œ
˜
šžœ
žœ
˜Kšœ	žœ,˜9—šžœ
˜Kšœ	žœj˜w—šžœ7ž˜AKš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ9˜9Kš
œ^˜^Kš
œ˜Kšžœ$˜+—Kšžœžœ
˜Kš
œ˜—š¢	œ˜!Kšœžœžœ
˜6Kšžœžœ
žœ
žœ
˜š
œ˜Kš
œ˜Kš
œ˜Kš
œ˜šœžœ˜$Kš
œ˜šœžœ
žœ
˜Kš
œ1˜1Kšžœžœ
˜—Kšœžœ	žœžœ˜Kš
œ˜Kš
œ˜—Kš
œ˜—Kš
œ˜—K˜š¢œžœ ˜9Kšžœ
žœžœ
˜Kšœžœ˜!Kšœžœ˜#Kš
œ!˜!Kšœžœ˜#KšœžœK˜Qšžœ
žœ
ž˜š
œ˜Kšžœ
žœ˜%Kšžœ<˜@K˜—š
œ˜Kšžœ
žœžœ˜.K˜—š
œ˜Kšžœ
žœžœ˜6Kš
œ˜—Kšžœžœ
˜—Kšœžœ
žœ˜(Kš
œ3˜3Kš
œD˜DKš
œ˜K˜—šŸœ˜K˜2K˜Kš
œ˜K˜—šŸ
œ˜Kšœžœ,˜;Kšœžœ˜š
œ(˜(˜ Kš
œ˜Kš
œ˜K˜Kš
œ'˜'Kšœž˜
K˜—K˜Kš
œ˜K˜—š
œ˜˜Kš
œ˜Kš
œ6˜6K˜Kšœ¡7˜TKš
œ'˜'Kšœžœ
˜š
œ˜Kš
œ2˜2Kš
œ&˜&Kš
œ
˜
—Kš
œ
˜
—K˜—Kš
œ@˜@Kšœžœ˜/Kš
œ˜K˜—š¢œ˜'Kšœžœ
˜%š
œ˜Kš
œ!˜!Kš
œ˜Kš
œ˜šœžœ˜$Kš
œ˜šœžœ
žœ
˜Kš
œ˜Kš
œ˜Kš
œ˜Kšžœžœ
˜—Kšœžœ	žœžœ˜Kš
œ˜Kš
œ˜—Kš
œ˜—Kš
œ˜—K˜šŸ¢œžœ˜>Kšœžœ˜$Kšœžœ˜'Kšœžœ˜)Kšœžœ-˜6Kšœžœ˜'šžœžœ˜Kšžœ
žœ˜-KšžœT˜XK˜
—šžœ
žœžœ˜Kšžœ
žœžœ˜@Kš
œ
˜
—šžœ
žœžœ˜Kšžœ
žœžœ˜FKš
œ
˜
—šžœ
žœžœ˜Kš
œ(˜(Kš
ž˜Kš
œ˜—Kšœ&žœ˜5Kš
œ˜—K˜šŸœžœžœžœ˜<šžœ˜šžœ&žœ
˜,KšžœI˜MKšžœ-˜1—Kš
œ˜—K˜—K˜šŸœžœ
žœžœžœžœ
žœ˜VK˜ šžœžœ
žœ#žœžœ
ž˜Ešžœ-ž˜3Kšžœ˜%—Kšžœ
˜—Kš
œ˜—K˜šŸœžœ
žœžœžœžœ˜OKš
œ.˜.šžœžœ
ž˜Kšœžœ
žœ˜)Kšžœžœ
˜—Kš
œ%˜%K˜—K˜šŸœžœ
žœ
žœžœžœžœ˜Všžœžœ
ž˜-Kšœžœžœ˜Kšžœžœžœ˜—Kš
œ˜—K˜š
Ÿœžœ
žœžœ	žœ˜NK˜ Kš
žœžœ
žœžœ
žœ
˜@šžœžœ
žœ#žœžœ
ž˜Ešžœ-žœ˜5Kš
œ˜K˜
—Kšžœ
˜—K˜—K˜šŸ	œžœ
žœ
žœžœ
žœ˜PKš
œ(˜(Kš
œ.˜.Kš
œ˜—K˜šŸœžœ
žœ
žœžœžœžœ
žœ˜MKšœž˜Kš
œ#™#šžœžœ˜$Kš
œ ˜ Kšœ5žœžœ˜AKš
ž˜K˜—Kš
œ2˜2Kš
œ/˜/Kšžœ˜Kš
œ˜K˜—š¢œ˜,Kš
œ™šžœ/žœ
ž˜>š
œ˜Kšœ,žœ˜1Kšœ,žœ˜1šžœžœžœ
žœ˜5Kšœ&žœ˜+Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜K˜—K˜—Kšžœžœ
˜—K˜—K™š
Ÿœžœ žœžœ
žœ˜Oš	žœ(žœžœ
žœž˜Fšžœžœ
žœ!žœ˜FKšœžœ˜!Kšžœžœ
žœ
˜Kš
œ˜—Kšžœ
˜—Kš
œ˜—K™Kš
¡4™4K˜šŸœžœžœžœžœžœ˜-Kšžœžœ
žœžœžœ
žœžœ	˜3Kšžœ˜
K˜K˜—šŸœžœžœžœžœžœžœ˜4Kšžœžœ
žœžœ	˜Kšžœ˜
K˜K˜—šŸœžœžœžœžœžœžœ˜4Kšžœžœ
žœžœ	˜ Kšžœ˜
K˜—K™Kšœ¡!™8Kšœ#žœ˜(Kšœ#žœ˜(Kš
œ'˜'K˜;K˜8K˜7Kš
œO˜OKš
œK˜KKš
œ/˜/Kšžœ˜K˜K˜—…—q �Ò