DIRECTORY
Atom, AtomButtons, AtomButtonsTypes, Buttons, FileNames, Imager, IO, Labels, Menus, PopUpButtons, Rope, TiogaButtons, VFonts, ViewerClasses, ViewerOps, ViewerTools;

AtomButtonsImpl: CEDAR PROGRAM
IMPORTS Atom, Buttons, FileNames, IO, Labels, PopUpButtons, Rope, TiogaButtons, VFonts, ViewerOps, ViewerTools
EXPORTS AtomButtons =
BEGIN

Action: TYPE = AtomButtons.Action;
ButtonLineEntry: TYPE = AtomButtons.ButtonLineEntry;
UnQueuedButtonLineEntry: TYPE = AtomButtons.UnQueuedButtonLineEntry;
ButtonList: TYPE = AtomButtons.ButtonList;
ButtonType: TYPE = AtomButtons.ButtonType;
DisplayStyle: TYPE = AtomButtons.DisplayStyle;
ConfirmProc: TYPE = AtomButtonsTypes.ConfirmProc;
Order: TYPE = AtomButtons.Order;
HandleButtonProc: TYPE = AtomButtons.HandleButtonProc;
InitButtonProc: TYPE = AtomButtonsTypes.InitButtonProc;
PopUpChoice: TYPE = AtomButtons.PopUpChoice;
ScalarButton: TYPE = AtomButtons.ScalarButton;
ScalarButtonClient: TYPE = REF ScalarButtonClientObj;
ScalarButtonClientObj: TYPE = AtomButtons.ScalarButtonClientObj;
ScalarButtonHandle: TYPE = REF ScalarButtonHandleObj;
ScalarButtonHandleObj: TYPE = AtomButtons.ScalarButtonHandleObj;
StateType: TYPE = AtomButtons.StateType;
StyleChoice: TYPE = AtomButtons.StyleChoice;
TwoState: TYPE = REF TwoStateObj;
TwoStateObj: TYPE = AtomButtons.TwoStateObj;
UpdateProc: TYPE = AtomButtons.UpdateProc;
Viewer: TYPE = ViewerClasses.Viewer;
EnumTypeRef: TYPE = REF EnumTypeRec;
EnumTypeRec: TYPE = AtomButtons.EnumTypeRec;
NotYetImplemented: PUBLIC SIGNAL = CODE;

GGButtonData: TYPE = REF GGButtonDataObj;
GGButtonDataObj: TYPE = RECORD [
clientData: REF ANY,
actions: LIST OF Action,
handleProc: HandleButtonProc,
confirmProc: ConfirmProc
];
BuildButtonLine: PUBLIC PROC [container: Viewer, x, y: NAT, clientData: REF ANY, handleProc: HandleButtonProc, entries: LIST OF ButtonLineEntry, horizontalSpace: INTEGER _ 2, lineHeight: INTEGER _ 15] RETURNS [nextX: INTEGER] = {
thisButton, prevButton, firstButton: Buttons.Button;
wxRelative: INTEGER _ -1;

firstButton _ prevButton _ BuildButton[container, x, y, clientData, handleProc, entries.first, horizontalSpace, lineHeight];
FOR entryList: LIST OF ButtonLineEntry _ entries.rest, entryList.rest UNTIL entryList = NIL DO
WITH entryList.first SELECT FROM
a: ButtonLineEntry.button => wxRelative _ a.wxRelative;
b: ButtonLineEntry.popUpButton => wxRelative _ b.wxRelative;
c: ButtonLineEntry.label => wxRelative _ c.wxRelative;
d: ButtonLineEntry.text => wxRelative _ d.wxRelative;
ENDCASE => ERROR;
nextX _ IF wxRelative < 0
THEN prevButton.wx + prevButton.ww + horizontalSpace
ELSE wxRelative; 
thisButton _ BuildButton[container, nextX, y, clientData, handleProc, entryList.first, horizontalSpace, lineHeight];
prevButton _ thisButton;
ENDLOOP;
nextX _ prevButton.wx + prevButton.ww;
};

BuildButton: PROC [container: Viewer, x, y: NAT, clientData: REF ANY, handleProc: HandleButtonProc, entry: ButtonLineEntry, horizontalSpace: INTEGER, lineHeight: INTEGER] RETURNS [button: Buttons.Button] = {
WITH entry SELECT FROM
a: ButtonLineEntry.button => button _ BuildOldButton[container, x, y, clientData, handleProc, a.name, a.actions, a.wxRelative, a.border, a.font, a.confirmProc, a.initProc, a.ww, lineHeight];
b: ButtonLineEntry.popUpButton => button _ BuildPopUpButton[container, x, y, clientData, handleProc, b.name, b.choices, b.wxRelative, b.border, b.font, b.confirmProc, b.initProc, b.ww, lineHeight];
c: ButtonLineEntry.label => button _ BuildLabel[container, x, y, clientData, handleProc, c.name, c.initProc, c.ww, c.wxRelative, c.border, c.font, lineHeight];
d: ButtonLineEntry.text => button _ BuildTextViewer[container, x, y, clientData, handleProc, d.name, d.initProc, d.ww, d.wxRelative, d.border, d.font, lineHeight];
ENDCASE => ERROR;
};

BuildLabel: PROC [container: Viewer, x, y: NAT, clientData: REF ANY, handleProc: HandleButtonProc, name: Rope.ROPE, initProc: InitButtonProc, ww: NAT, wxRelative: INTEGER, border: BOOL, font: Imager.Font, lineHeight: INTEGER] RETURNS [button: Buttons.Button] = {
button _ Labels.Create[
info: [
parent: container, 
wx: x, wy: y, ww: ww, wh: lineHeight,
name: name,
border: border]];
IF initProc # NIL THEN initProc[name, clientData, button];
};

BuildOldButton: PROC [container: Viewer, x, y: NAT, clientData: REF ANY, handleProc: HandleButtonProc, name: Rope.ROPE, actions: LIST OF Action, wxRelative: INTEGER, border: BOOL, font: Imager.Font, confirmProc: ConfirmProc, initProc: InitButtonProc, ww: NAT, lineHeight: INTEGER] RETURNS [button: Buttons.Button] = {
buttonData: GGButtonData;
buttonData _ NEW[GGButtonDataObj _ [clientData, actions, handleProc, confirmProc]];
button _ Buttons.Create[
info: [name: name, wx: x, wy: y, wh: lineHeight,
parent: container, border: border],
proc: HandleButton,
clientData: buttonData,
documentation: handleConfirm,
fork: FALSE,
guarded: confirmProc # NIL,
font: font
];
IF initProc # NIL THEN initProc[name, clientData, button];
};

HandlePopUpButton: PROC [viewer: Viewer, instanceData, classData, key: REF ANY] = {
action: LIST OF REF ANY _ NARROW[key];
popUpData: PopUpButtonData _ NARROW[instanceData];
popUpData.handleProc[classData, action];
};

PopUpButtonData: TYPE = REF PopUpButtonDataObj;
PopUpButtonDataObj: TYPE = RECORD [
handleProc: HandleButtonProc
];

BuildPopUpButton: PROC [container: Viewer, x, y: NAT, clientData: REF ANY, handleProc: HandleButtonProc, name: Rope.ROPE, choices: LIST OF PopUpChoice, wxRelative: INTEGER, border: BOOL, font: Imager.Font, confirmProc: ConfirmProc, initProc: InitButtonProc, ww: NAT, lineHeight: INTEGER] RETURNS [button: Buttons.Button] = {
popUpClassSpec: PopUpButtons.ClassSpec;
popUpClass: PopUpButtons.Class;
choiceList, ptr: LIST OF PopUpButtons.Choice;
image: PopUpButtons.Image;
instanceData: PopUpButtonData;
[choiceList, ptr] _ StartChoiceList[];
FOR list: LIST OF PopUpChoice _ choices, list.rest UNTIL list = NIL DO
IF list.first.actionImage = NIL THEN image _ PopUpButtons.ImageForRope[Atom.GetPName[NARROW[list.first.action.first]], NIL, list.first.font]
ELSE image _ PopUpButtons.ImageForRope[list.first.actionImage, NIL, list.first.font];
[choiceList, ptr] _ AddChoice[[key: list.first.action, doc: list.first.doc, image: image], choiceList, ptr];
ENDLOOP;
popUpClassSpec _ [
classData: clientData,
proc: HandlePopUpButton,
choices: choiceList,
fork: FALSE
];
popUpClass _ PopUpButtons.MakeClass[popUpClassSpec];
instanceData _ NEW[PopUpButtonDataObj _ [handleProc]];
button _ PopUpButtons.Instantiate[
class: popUpClass,
viewerInfo: [name: name, wx: x, wy: y, ww: ww, wh: lineHeight,
parent: container, border: border],
instanceData: instanceData,
image: PopUpButtons.ImageForRope[name, NIL, font]
];
IF initProc # NIL THEN initProc[name, clientData, button];
};

BuildTextViewer: PROC [container: Viewer, x, y: NAT, clientData: REF ANY, handleProc: HandleButtonProc, name: Rope.ROPE, initProc: InitButtonProc, ww: NAT, wxRelative: INTEGER, border: BOOL, font: Imager.Font, lineHeight: INTEGER] RETURNS [button: Buttons.Button] = {
button _ ViewerTools.MakeNewTextViewer[[
parent: container,
wx: x, wy: y, ww: ww, wh: lineHeight,
data: name,
scrollable: FALSE, border: border]];
IF initProc # NIL THEN initProc[name, clientData, button];
};

StartChoiceList: PUBLIC PROC [] RETURNS [entityList, ptr: LIST OF PopUpButtons.Choice] = {
ptr _ entityList _ NIL;
};
AddChoice: PUBLIC PROC [entity: PopUpButtons.Choice, entityList, ptr: LIST OF PopUpButtons.Choice] RETURNS [newList, newPtr: LIST OF PopUpButtons.Choice] = {
IF ptr = NIL THEN {
IF NOT entityList = NIL THEN ERROR;
newPtr _ newList _ CONS[entity, NIL];
RETURN;
}
ELSE {
newList _ entityList;
ptr.rest _ CONS[entity, NIL];
newPtr _ ptr.rest;
};
};
HandleButton: Menus.ClickProc = {
buttonData: GGButtonData _ NARROW[clientData];
IF mouseButton = red THEN buttonData.handleProc[buttonData.clientData, buttonData.actions.first]
ELSE IF mouseButton = yellow THEN {
IF buttonData.actions.rest # NIL AND buttonData.actions.rest.first # NIL
THEN buttonData.handleProc[buttonData.clientData, buttonData.actions.rest.first]
ELSE buttonData.handleProc[buttonData.clientData, buttonData.actions.first];
}
ELSE {
IF buttonData.actions.rest # NIL AND buttonData.actions.rest.rest # NIL AND buttonData.actions.rest.rest.first # NIL
THEN buttonData.handleProc[buttonData.clientData, buttonData.actions.rest.rest.first]
ELSE buttonData.handleProc[buttonData.clientData, buttonData.actions.first];
};
};

handleConfirm: REF Menus.ClickProc _ NEW[Menus.ClickProc _ HandleConfirm];

HandleConfirm: Menus.ClickProc = {
buttonData: GGButtonData _ NARROW[clientData];
buttonData.confirmProc[buttonData.clientData];
};


GGUnQueuedButtonData: TYPE = REF GGUnQueuedButtonDataObj;
GGUnQueuedButtonDataObj: TYPE = RECORD [
clientData: REF ANY,
clickProc: Menus.ClickProc,
confirmProc: ConfirmProc
];

BuildUnQueuedButtonLine: PUBLIC PROC [container: Viewer, x, y: NAT, clientData: REF ANY, entries: LIST OF UnQueuedButtonLineEntry, horizontalSpace: INTEGER _ 2, lineHeight: INTEGER _ 15] RETURNS [nextX: INTEGER] = {
thisButton, prevButton: Buttons.Button;
entry: UnQueuedButtonLineEntry;

entry _ entries.first;
prevButton _ BuildUnQueuedButton[container, x, y, clientData, entry.type, entry.clickProc, entry.name, entry.border, entry.ww, entry.updateProc, entry.confirmProc, entry.font, horizontalSpace, lineHeight];
nextX _ prevButton.wx + prevButton.ww;
FOR entryList: LIST OF UnQueuedButtonLineEntry _ entries.rest, entryList.rest UNTIL entryList = NIL DO
entry _ entryList.first;
thisButton _ BuildUnQueuedButton[container, nextX + horizontalSpace, y, clientData, entry.type, entry.clickProc, entry.name, entry.border, entry.ww, entry.updateProc, entry.confirmProc, entry.font, horizontalSpace, lineHeight];
prevButton _ thisButton;
nextX _ prevButton.wx + prevButton.ww;
ENDLOOP;
};


BuildUnQueuedButton: PROC [container: Viewer, x, y: NAT, clientData: REF ANY, type: ButtonType, clickProc: Menus.ClickProc, name: Rope.ROPE, border: BOOL, ww: NAT, updateProc: UpdateProc, confirmProc: ConfirmProc, font: Imager.Font, horizontalSpace: INTEGER, lineHeight: INTEGER] RETURNS [button: Buttons.Button] = {
SELECT type FROM
button => {
buttonData: GGUnQueuedButtonData;
buttonData _ NEW[GGUnQueuedButtonDataObj _ [clientData, clickProc, confirmProc]];
button _ Buttons.Create[
info: [name: name, wx: x, wy: y, wh: lineHeight,
parent: container, border: border],
proc: HandleUnQueuedButton,
clientData: buttonData,
documentation: handleUnQueuedConfirm,
fork: TRUE,
guarded: confirmProc # NIL,
font: font
];
};
label => {
button _ Labels.Create[
info: [
parent: container,
name: name,
wx: x, wy: y, ww: ww, wh: lineHeight,
border: border]];
};
text => {
button _ ViewerTools.MakeNewTextViewer[[
parent: container,
wx: x, wy: y, ww: ww, wh: lineHeight,
data: name,
scrollable: FALSE, border: border]];
};
popUpButton => SIGNAL NotYetImplemented; -- not yet implemented
ENDCASE => ERROR;
IF updateProc # NIL THEN updateProc[name, clientData, button];
};

HandleUnQueuedButton: Menus.ClickProc = {
buttonData: GGUnQueuedButtonData _ NARROW[clientData];
buttonData.clickProc[NIL, buttonData.clientData, mouseButton, shift, control];
};

handleUnQueuedConfirm: REF Menus.ClickProc _ NEW[Menus.ClickProc _ HandleUnQueuedConfirm];
HandleUnQueuedConfirm: Menus.ClickProc = {
buttonData: GGUnQueuedButtonData _ NARROW[clientData];
buttonData.confirmProc[buttonData.clientData];
};



BuildTwoStateButton: PUBLIC PROC [viewer: ViewerClasses.Viewer, x, y: NAT, clientData: REF ANY, handleProc: HandleButtonProc, name: Rope.ROPE, border: BOOL _ TRUE, init: StateType _ off, action: LIST OF REF ANY, lineHeight: INTEGER _ 15] RETURNS [stateInfo: TwoState, nextX: INTEGER] = {
tempButton: Buttons.Button;
stateInfo _ NEW[TwoStateObj];
tempButton _ Buttons.Create[
info: [name: name, wx: x, wy: y, wh: lineHeight,
parent: viewer, border: border],
proc: TwoSwitchProc,
clientData: stateInfo -- this will be passed to our button proc
];
stateInfo.button _ tempButton;
stateInfo.action _ action;
stateInfo.clientData _ clientData;
stateInfo.handleProc _ handleProc;
SetButtonState[stateInfo, init];
nextX _ tempButton.wx + tempButton.ww + 4;
};

SetButtonState: PUBLIC PROC [twoState: TwoState, state: StateType] = {
twoState.state _ state;
SELECT state FROM 
on => Buttons.SetDisplayStyle[button: twoState.button, style: $WhiteOnBlack];
off => Buttons.SetDisplayStyle[button: twoState.button, style: $BlackOnWhite];
ENDCASE => ERROR;
};

GetButtonState: PUBLIC PROC [twoState: TwoState] RETURNS [state: StateType] = {
state _ twoState.state;
};


NextState: PROC [state: StateType] RETURNS [StateType] = {
IF state = LAST[StateType] THEN RETURN[FIRST[StateType]]
ELSE RETURN[SUCC[state]];
};

TwoSwitchProc: Buttons.ButtonProc = {
handle: TwoState _ NARROW[clientData];
handle.handleProc[handle.clientData, handle.action];
};

SwitchState: PUBLIC PROC [handle: TwoState] = {
nextState: StateType;
nextState _ NextState[handle.state];
SetButtonState[handle, nextState];
};


CreateScalarButtonViewer: PUBLIC PROC [container: Viewer, x, y: NAT, lineHeight: INTEGER _ 15] RETURNS [AtomButtons.ScalarButtonHandle] = {
sbHandle: AtomButtons.ScalarButtonHandle _ NEW[AtomButtons.ScalarButtonHandleObj];
sbHandle.viewer _  MakeViewer[container, x, y, lineHeight];
sbHandle.headerButton _ NewHeaderButton[sbHandle.viewer, NIL];
RETURN[sbHandle];
};

BuildScalarButtons: PUBLIC PROC [handle: ScalarButtonHandle, clientData: REF ANY, handleProc: HandleButtonProc, header: Rope.ROPE, scalarButtonList: LIST OF ScalarButton] = {
buttons: ScalarButtonClient;
prevButton: TiogaButtons.TiogaButton;
oldScalarButtons: ScalarButtonClient _ handle.scalarButtons;
FOR thisButton: ScalarButtonClient _ oldScalarButtons, thisButton.next UNTIL thisButton=NIL DO
TiogaButtons.DeleteButton[thisButton.button];
ENDLOOP;
prevButton _ handle.headerButton;
FOR list: LIST OF ScalarButton _ scalarButtonList, list.rest UNTIL list = NIL DO
prevButton _ AppendScalarButton[prevButton, clientData, handleProc, list.first.name, list.first.value, list.first.init = on, list.first.action];
IF list = scalarButtonList THEN buttons _ NARROW[prevButton.clientData];
ENDLOOP;
handle.scalarButtons _ buttons;
handle.handleProc _ handleProc;
};

StartScalarButtonList: PROC [] RETURNS [entityList, ptr: LIST OF ScalarButton] = {
ptr _ entityList _ NIL;
};

AddScalarButton: PROC [entity: ScalarButton, entityList, ptr: LIST OF ScalarButton] RETURNS [newList, newPtr: LIST OF ScalarButton] = {
IF ptr = NIL THEN {
IF NOT entityList = NIL THEN ERROR;
newPtr _ newList _ CONS[entity, NIL];
RETURN;
}
ELSE {
newList _ entityList;
ptr.rest _ CONS[entity, NIL];
newPtr _ ptr.rest;
};
};

AddValueSorted: PUBLIC PROC [clientData: REF ANY, scalarButtonHandle: ScalarButtonHandle, value: ScalarButton, order: Order _ incr] RETURNS [oldFoundButton: ScalarButtonClient _ NIL] = {
epsilon: REAL = 0.001;
list, finger: LIST OF AtomButtons.ScalarButton;
inserted: BOOL _ FALSE;
oldScalarButtons: ScalarButtonClient _ scalarButtonHandle.scalarButtons;
[list, finger] _ StartScalarButtonList[];
FOR thisButton: ScalarButtonClient _ oldScalarButtons, thisButton.next UNTIL thisButton=NIL DO
IF ABS[thisButton.value-value.value] < epsilon THEN {
thisButton.on _ value.init = on;
IF thisButton.on THEN TiogaButtons.ChangeButtonLooks[thisButton.button, "b", ""]
ELSE TiogaButtons.ChangeButtonLooks[thisButton.button, "", "b"];
RETURN[thisButton];
};
IF NOT inserted AND order=decr AND thisButton.value<value.value THEN { -- insert new value behind thisButton
[list, finger] _ AddScalarButton[value, list, finger];
inserted _ TRUE;
}
ELSE IF NOT inserted AND order=incr AND thisButton.value>value.value THEN { -- insert new value behind thisButton
[list, finger] _ AddScalarButton[value, list, finger];
inserted _ TRUE;
};
[list, finger] _ AddScalarButton[[thisButton.name, thisButton.value, thisButton.action, IF thisButton.on THEN on ELSE off], list, finger];
ENDLOOP;
IF NOT inserted THEN { -- tack new slope onto proper end of the list
[list, finger] _ AddScalarButton[value, list, finger];
};
FOR thisButton: ScalarButtonClient _ oldScalarButtons, thisButton.next UNTIL thisButton=NIL DO
TiogaButtons.DeleteButton[thisButton.button];
ENDLOOP;
scalarButtonHandle.scalarButtons _ RebuildScalarButtons[viewer: scalarButtonHandle.viewer, headerButton: scalarButtonHandle.headerButton, clientData: clientData, handleProc: scalarButtonHandle.handleProc, scalarButtonList: list];
FOR thisButton: ScalarButtonClient _ scalarButtonHandle.scalarButtons, thisButton.next UNTIL thisButton=NIL DO
IF thisButton.on THEN TiogaButtons.ChangeButtonLooks[thisButton.button, "b", ""]
ELSE TiogaButtons.ChangeButtonLooks[thisButton.button, "", "b"];
ENDLOOP;
};

RebuildScalarButtons: PUBLIC PROC [viewer: Viewer, headerButton: TiogaButtons.TiogaButton, clientData: REF ANY, handleProc: HandleButtonProc, scalarButtonList: LIST OF ScalarButton] RETURNS [buttons: ScalarButtonClient _ NIL] = {
prevButton: TiogaButtons.TiogaButton _ headerButton;
FOR list: LIST OF ScalarButton _ scalarButtonList, list.rest UNTIL list = NIL DO
prevButton _ AppendScalarButton[prevButton, clientData, handleProc, list.first.name, list.first.value, list.first.init = on, list.first.action];
IF list = scalarButtonList THEN buttons _ NARROW[prevButton.clientData];
ENDLOOP;
};

AppendScalarButton: PROC [prevButton: TiogaButtons.TiogaButton, clientData: REF ANY, handleProc: HandleButtonProc, name: Rope.ROPE _ NIL, value: REAL, on: BOOL, action: LIST OF REF ANY] RETURNS [button: TiogaButtons.TiogaButton] = {
buttonData, prevButtonData: ScalarButtonClient;
IF name = NIL THEN {
space: CHAR = ' ;
name _ IO.PutFR["%1.2f", [real[value]]];
name _ FileNames.Tail[name, space]; -- strip off leading spaces
UNTIL Rope.Fetch[base: name, index: Rope.Length[name]-1]# '0 DO name _ Rope.Substr[base: name, start: 0, len: Rope.Length[name]-1]; ENDLOOP;
};
buttonData _ NEW[ScalarButtonClientObj _ [NIL, name, value, action, on, NIL, clientData, handleProc]];
button _ TiogaButtons.AppendToButton[
button: prevButton,
rope: Rope.Concat[name, " "],
looks: "",
proc: ToggleScalar,
clientData: buttonData,
fork: FALSE];
prevButtonData _ NARROW[prevButton.clientData];
IF prevButtonData # NIL THEN prevButtonData.next _ buttonData;
buttonData.button _ button;
};

ToggleScalar: TiogaButtons.TiogaButtonProc ~ {
buttonData: ScalarButtonClient _ NARROW[clientData];
buttonData.handleProc[buttonData.clientData, buttonData.action];
};

MakeViewer: PROC [container: Viewer, x, y: NAT, lineHeight: INTEGER] RETURNS [viewer: Viewer] = {
viewer _ TiogaButtons.CreateViewer[
info: [
wx: x, wy: y, ww: container.ww, wh: lineHeight,
parent: container,
border: FALSE]
];
container.class.set[self: container, data: viewer, op: $XBound];
};

NewHeaderButton: PROC [v: Viewer, name: Rope.ROPE] RETURNS [button: TiogaButtons.TiogaButton] = {
button _ TiogaButtons.CreateButton[
viewer: v,
rope: name,
format: "",
looks: "",
proc: NIL,
clientData: NIL];
};



BuildEnumTypeSelection: PUBLIC PROC [viewer: ViewerClasses.Viewer, x, y: NAT, maxWidth: NAT, clientData: REF ANY, handleProc: HandleButtonProc, title: Rope.ROPE, default: Rope.ROPE, borderOnButtons: BOOL, style: StyleChoice, allInOneRow: BOOL, buttonNames: ButtonList, atom: ATOM, horizontalSpace: INTEGER _ 2, lineHeight: INTEGER _ 15] RETURNS [EnumTypeRef] = {
foundDefault: BOOL _ FALSE;
stateInfo: EnumTypeRef _ NEW[EnumTypeRec];
DefaultFound: PROC[currentName, defaultName: Rope.ROPE] RETURNS [BOOL] = {
IF Rope.Equal[currentName, defaultName, FALSE]  THEN RETURN [foundDefault _ TRUE]
ELSE RETURN [FALSE];
};
BuildMenuSelection: PROC = {
border: INTEGER _ 10;
startButtons: NAT;
startX: NAT _ 0; -- keeps a running tally of where the next x position is
tempButton:  Buttons.Button;
eachButton: ButtonList;
stateInfo.type _ menuStyle;
stateInfo.handleProc _ handleProc;
IF title # NIL THEN {
titleLabel:  Labels.Label_ Labels.Create[[
name: title, 
parent: viewer,
wx: x, wy: y, wh: lineHeight,
border: FALSE
]];
startButtons _ titleLabel.wx + titleLabel.ww + horizontalSpace;
}
ELSE startButtons _ x;
startX _ startButtons;

FOR eachButton _ buttonNames, eachButton.rest UNTIL eachButton = NIL DO
IF ~allInOneRow THEN {
IF startX + VFonts.StringWidth[eachButton.first, VFonts.defaultFont] +
border >= maxWidth THEN {
startX _ startButtons;
stateInfo.nexty _ stateInfo.nexty + lineHeight;
};
};
tempButton _ Buttons.Create[info: [
name: eachButton.first,
wx: startX,
wy: stateInfo.nexty,
wh: lineHeight, -- specify rather than defaulting so line is uniform
parent: viewer, 
border: borderOnButtons
],
proc: MenuSelectionProc,
clientData: stateInfo
];
ViewerOps.AddProp[tempButton, $ChoiceButtons, stateInfo];
IF DefaultFound[eachButton.first, default] THEN {
stateInfo.buttonOn _ tempButton;
Buttons.SetDisplayStyle[button: tempButton, style: on];
};
startX _ tempButton.wx + tempButton.ww;
ENDLOOP;
stateInfo.nextx _ startX;
};
BuildFlipThru: PROC = {
eachButton: ButtonList;
titleButton: Buttons.Button;
nextx: INTEGER _ x;
IF title # NIL THEN { -- create a title button
stateInfo.type _ flipThruWithTitle;
stateInfo.handleProc _ handleProc;
titleButton _ Buttons.Create[
info: [name: title, 
parent: viewer,
wx: nextx,
wy: y,
wh: lineHeight,
border: TRUE
],
proc: FlipThruButtonProc,
clientData: stateInfo
];
nextx _ titleButton.wx + titleButton.ww + 3;
}
ELSE stateInfo.type _ flipThruNoTitle;
FOR eachButton _ buttonNames, eachButton.rest UNTIL (eachButton = NIL) OR
DefaultFound[eachButton.first, default] DO -- do nothing
ENDLOOP;
IF title # NIL THEN stateInfo.flipLabel _ Labels.Create[[
name: eachButton.first,
wx: nextx,
wy: y,
ww: MaxNameWidth[buttonNames], -- first find the longest name so we can set up the
wh: lineHeight, 
parent: viewer, 
border: FALSE
]]
ELSE stateInfo.flipLabel _ Buttons.Create[
info:  [name: eachButton.first,
wx: nextx,
wy: y,
ww: MaxNameWidth[buttonNames],
wh: lineHeight,
parent: viewer, 
border: borderOnButtons
],
proc: FlipThruButtonProc,
clientData: stateInfo
];
stateInfo.nextx _ stateInfo.flipLabel.wx + stateInfo.flipLabel.ww;
};
stateInfo.nextx _ x;
stateInfo.nexty _ y;
stateInfo.atom _ atom;
stateInfo.namesOfButtons _ buttonNames;
stateInfo.clientData _ clientData;
IF default = NIL THEN -- set it to be the first name of the list of button names
default _ buttonNames.first;

SELECT style FROM
menuSelection => BuildMenuSelection;
flipThru => BuildFlipThru;
ENDCASE => ERROR;

IF ~foundDefault THEN SIGNAL DefaultDoesntExist;

stateInfo.nexty _ stateInfo.nexty + lineHeight; 
RETURN[stateInfo];
}; -- end of BuildEnumTypeSelection

FlipThruButtonProc: Buttons.ButtonProc = {
info: EnumTypeRef _ NARROW[clientData];
IF mouseButton=red THEN
info.handleProc[info.clientData, LIST[info.atom, $FlipForward--, info--]] 
ELSE info.handleProc[info.clientData, LIST[info.atom, $FlipBackward--, info--]];
};

TimeToFlipThru: PUBLIC PROC [event: LIST OF REF ANY] = {
info: EnumTypeRef _ NARROW[event.rest.first];
IF event.first = $FlipForward THEN
ViewerTools.SetContents[viewer: info.flipLabel, contents:
GetNextName[info.namesOfButtons, info.flipLabel.name]]
ELSE IF event.first = $FlipBackward THEN
ViewerTools.SetContents[viewer: info.flipLabel, contents:
GetPrevName[info.namesOfButtons, info.flipLabel.name]];
};

UpdateChoiceButtons: PUBLIC PROC [viewer: ViewerClasses.Viewer, enumTypeInfo: EnumTypeRef, newName: Rope.ROPE] = {
newButton: Buttons.Button _ NIL;
GetDesiredButton: ViewerOps.EnumProc = {
IF (Rope.Equal[v.name, newName, FALSE]) AND 
(ViewerOps.FetchProp[v, $ChoiceButtons] = enumTypeInfo) THEN {
newButton _ v;
RETURN [FALSE];
};
};
IF enumTypeInfo = NIL THEN SIGNAL ButtonsCannotBeUpdated;
SELECT enumTypeInfo.type FROM
menuStyle  => {ViewerOps.EnumerateChildren[viewer, GetDesiredButton];
IF newButton # NIL THEN {
SwitchButtons[enumTypeInfo.buttonOn, newButton];
enumTypeInfo.buttonOn _ newButton;
}
ELSE SIGNAL ChoiceDoesntExist;
};
flipThruWithTitle =>  Labels.Set[label: enumTypeInfo.flipLabel, value: newName];
flipThruNoTitle  => Buttons.ReLabel[button: enumTypeInfo.flipLabel, newName: newName];
ENDCASE => ERROR;
};


DefaultDoesntExist: PUBLIC SIGNAL = CODE;
ChoiceDoesntExist: PUBLIC SIGNAL = CODE;
ButtonsCannotBeUpdated: PUBLIC SIGNAL = CODE;

MaxNameWidth: PROC[listOfNames: ButtonList] RETURNS [CARDINAL] = {
eachButton: ButtonList _ listOfNames;
maxWidth: CARDINAL;
IF eachButton # NIL THEN {
maxWidth _ VFonts.StringWidth[string: eachButton.first, font: VFonts.defaultFont];
eachButton _ eachButton.rest }
ELSE RETURN [0];
WHILE (eachButton # NIL) DO
IF VFonts.StringWidth[string: eachButton.first, font: VFonts.defaultFont] > maxWidth THEN
maxWidth _ VFonts.StringWidth[string: eachButton.first, font: VFonts.defaultFont]; 
eachButton _ eachButton.rest;
ENDLOOP;
maxWidth _ maxWidth + VFonts.CharWidth['M]; -- add on a little extra just to be sure
RETURN[maxWidth];
};

MenuSelectionProc: Buttons.ButtonProc = {
info: EnumTypeRef _ NARROW[clientData];
viewer: ViewerClasses.Viewer _ NARROW[parent];
SwitchButtons[info.buttonOn, viewer]; -- viewer is the button which was just selected
info.buttonOn _ viewer;
};

GetNextName: PROC[listOfNames: ButtonList,  currentName: Rope.ROPE] RETURNS
[Rope.ROPE] = {
eachButton: ButtonList _ listOfNames;
WHILE (eachButton # NIL) AND (eachButton.first # currentName) DO 
eachButton _ eachButton.rest;
ENDLOOP;
IF eachButton = NIL THEN ERROR; -- This shouldn't happen; we should always be able to
IF eachButton.rest = NIL THEN 
RETURN [listOfNames.first]
ELSE RETURN [(eachButton.rest).first];
};

GetPrevName: PROC[listOfNames: ButtonList,  currentName: Rope.ROPE] RETURNS
[Rope.ROPE] = {
prev: Rope.ROPE _ listOfNames.first;
eachName:  ButtonList _ listOfNames.rest;
WHILE (eachName # NIL) AND ~Rope.Equal[eachName.first, currentName, FALSE] DO
prev _ eachName.first;
eachName _ eachName.rest;
ENDLOOP;
RETURN[prev];
};

on: ATOM = $WhiteOnBlack;
off: ATOM = $BlackOnWhite;
SwitchButtons: PROC[oldButton, newButton: Buttons.Button] = {
Buttons.SetDisplayStyle[button: oldButton, style: off];
Buttons.SetDisplayStyle[button: newButton, style: on];
};

END.




AtomButtonsImpl.mesa
Last edited by Bier on April 30, 1987 7:38:35 pm PDT.
Contents:  General Purpose routines for use by Gargoyle.
Pier, December 12, 1986 2:36:03 pm PST
Button Lines

[parent: REF ANY, clientData: REF ANY _ NIL, mouseButton: Menus.MouseButton _ red, shift: BOOL _ FALSE, control: BOOL _ FALSE]
buttonData.handleProc might put the action on the slack queue.
UnQueued Buttons Lines

An unqueued button calls the clickProc indicated by the client.  It forks a process.
Like BuildButton except that action: LIST OF REF ANY is replaced with clickProc: Menus.ClickProc.  This only affects buttons (not labels or text viewers).
Two State Buttons
Scalar Buttons

A line of Tioga Buttons, but built for the new User Interface Architecture (see comment below).
Makes a TiogaButtons viewer and fills it with buttons.  Each button names the action atoms to give to the slack process when the button is pressed.  The rest is somewhat convoluted.  The client must figure out which button has been pressed, update his data structures and call an appropriate procedure to change the appearance of the button, if desired.  Hence, the client must have a data structure which points to the appropriate button.  This procedure builds such a data structure.

clear out the existing buttons, which TiogaOps doesn't seem able to do !!
add the new buttons
Adds a new scalar button to the list, sort in increasing order or decreasing order as requested. If it is already there, it is not added.  Turns on the new button.
search the current list for duplicate OR for proper insertion point, build new list along the way
Now clear out the existing buttons, which TiogaOps doesn't seem able to do !!
this routine builds a new set of Tioga buttons into the given viewer
the client must have cleaned out old buttons before calling herein.
creates a new button and appends it to the viewer in which prevButton exists. DOES NOT APPEND TO prevButton, as one might hope !!
IF Rope.Equal[Rope.Substr[name, Rope.Length[name]-5, 5], ".0000"] THEN
name _ Rope.Substr[name, 0, Rope.Length[name]-5];
strip off trailing zeroes
prevButtonData will be NIL after the Header button.
Enumerated Types Buttons

(like Choice Buttons, but built for the new User Interface Architecture (queues atoms onto the slack process queue and waits for them to return before acting.  Thus, the buttons can be "pushed" from the TIP Table as well as with the mouse.
default the width so that it will be computed for us
now set up the initial button
width properly (unfortunately when re-labeling a button, the width remains the same)
signal that the default didn't exist if necessary
Display the next name in succession
Notify client that change has taken place if the client provided a proc for doing this
IF info.proc # NIL THEN info.proc[viewer.name, info.clientdata];
find the current button name in list of button names
we are at the end of our list, cycle around to the beginning
merely changes the physical appearance of the buttons
Switch off the previously selected button
switch "on" the newly selected button
�ÊÔ˜Icode™K™5™8K™&—š
Ïk	˜	JšœA�œa˜¤
—K˜šœ�œ
�˜Kš�œ�œJ˜nKš�œ˜—Kš
�˜˜Kšœ�œ˜"Kšœ�œ˜4Kšœ�œ'˜DKšœ�œ˜*Kšœ�œ˜*Kšœ�œ˜.Kšœ
�œ ˜1Kšœ�œ˜ Kšœ�œ ˜6Kšœ�œ#˜7Kšœ
�œ˜,Kšœ�œ˜.Kšœ�œ�œ˜5Kšœ�œ%˜@Kšœ�œ�œ˜5Kšœ�œ%˜@Kšœ�œ˜(Kšœ
�œ˜,Kšœ
�œ�œ
˜!Kšœ
�œ˜,Kšœ�œ˜*Kšœ�œ˜$Kšœ
�œ�œ
˜$Kšœ
�œ˜,KšÏnœ�œ
�œ�œ
˜(—K˜K™K™Kšœ�œ�œ˜)šœ�œ�œ˜ Kšœ�œ
�œ
˜Kšœ	�œ
�œ�
˜Kš
œ˜Kš
œ˜K˜—šžœ�œ
�œ�œ�œ
�œ)�œ
�œ#�œ�œ�œ	�œ˜å
Kš
œ4˜4Kšœ�œ˜K˜Kš
œ|˜|š�œ�œ
�œ0�œ
�œ
�˜^š�œ�œ
�˜ Kš
œ7˜7Kš
œ<˜<Kš
œ6˜6Kš
œ5˜5Kš�œ�œ
˜—šœ�œ˜Kš�œ0˜4Kš�œ
˜—Kš
œt˜tKš
œ˜Kš�œ
˜—Kš
œ&˜&Kš
œ˜K˜—šžœ�œ�œ�œ
�œI�œ�œ�œ˜Ï
š�œ�œ
�˜Kš
œ¾
˜¾
Kš
ρ
˜Å
Kš
œŸ
˜Ÿ
Kš
ϣ
˜£
Kš�œ�œ
˜—K˜—K˜šž
œ�œ�œ�œ
�œ+�œ �œ�œ
�œ!�œ�œ˜†š
œ˜š
œ˜Kš
œ˜Kš
œ%˜%Kš
œ˜Kš
œ˜——Kš�œ�œ
�œ$˜:K˜K˜—šžœ�œ�œ�œ
�œ+�œ�œ
�œ�œ
�œM�œ�œ�œ˜½K˜Kšœ
�œC˜Sš
œ˜š
œ0˜0Kš
œ#˜#—Kš
œ˜Kš
œ˜Kš
œ˜Kšœ�œ
˜Kšœ�œ
˜Kš
œ
˜
Kš
œ˜—Kš�œ�œ
�œ$˜:˜K˜——šžœ�œ0�œ
�œ˜SKšœ�œ
�œ
�œ
�œ�œ˜&Kšœ�œ˜2Kš
œ(˜(K˜K˜—Kšœ�œ�œ˜/šœ�œ�œ˜#Kš
œ˜K˜K˜—šžœ�œ�œ�œ
�œ+�œ�œ
�œ�œ
�œM�œ�œ�œ˜ÄKš
œ'˜'Kš
œ˜Kšœ�œ
�œ˜-Kš
œ˜Kš
œ˜Kš
œ&˜&š�œ�œ
�œ"�œ�œ
�˜FKš
�œ�œ
�œ1�œ�œ˜Œ
Kš�œ;�œ˜UKš
œl˜lKš�œ
˜—š
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšœ�˜K˜—Kš
œ4˜4Kšœ�œ$˜6š
œ"˜"Kš
œ˜š
œ>˜>Kš
œ#˜#—Kš
œ˜Kšœ'�œ˜1K˜—Kš�œ�œ
�œ$˜:K˜K˜—šžœ�œ�œ�œ
�œ+�œ �œ�œ
�œ!�œ�œ˜‹š
œ(˜(Kš
œ˜Kš
œ%˜%Kš
œ˜Kšœ�œ˜$—Kš�œ�œ
�œ$˜:K˜K˜—šžœ�œ
�œ�œ�œ
�œ˜ZKšœ�œ
˜K˜—šž	œ�œ
�œ0�œ
�œ�œ�œ
�œ˜�
š�œ�œ
�œ˜Kš
�œ
�œ�œ
�œ
�œ
˜#Kšœ�œ	�œ˜%Kš�œ
˜K˜
—š�œ˜Kš
œ˜Kšœ�œ	�œ˜Kš
œ˜K˜—K˜—šžœ˜!Kšœ	�œ
�œ�œ
�œ�œ/�œ�œ�œ�œ
™~Kšœ�œ
˜.Kš�œ�œG˜`š�œ
�œ�œ˜#Kš�œ�œ
�œ!�˜HKš�œL˜PKš�œH˜LK˜
—š�œ˜Kš�œ�œ
�œ �œ
�œ&�˜tKš�œQ˜UKš�œH˜LK˜—Kš
Ïb>™>K˜K˜—šŸ
œ�œ�œ"˜JK˜—šž
œ˜"Kšœ�œ
˜.Kš
œ.˜.K˜K˜—K˜K™K™Kšœ�œ�œ˜9šœ�œ�œ˜(Kšœ�œ
�œ
˜Kš
œ˜Kš
œ˜K˜K˜—šžœ�œ
�œ�œ�œ
�œ�œ
�œ+�œ�œ�œ	�œ˜×
Kš
œ'˜'Kš
œ˜K˜Kš
œ˜Kš
œÍ
˜Í
Kš
œ&˜&š�œ�œ
�œ8�œ
�œ
�˜fKš
œ˜Kš
ϋ
˜ã
Kš
œ˜Kš
œ&˜&—Kš�œ
˜Kš
œ˜K˜—K˜šžœ�œ�œ�œ
�œ;�œ
�œ�œX�œ�œ�œ˜¼K™TKš	œ%�œ
�œ
�œ
�œf™š
Kš�œ�˜˜K˜!Kšœ
�œA˜Qš
œ˜š
œ0˜0Kš
œ#˜#—KšœŸœ
˜Kš
œ˜KšœŸœ
˜%Kšœ�œ
˜Kšœ�œ
˜Kš
œ
˜
Kš
œ˜—K˜—˜
š
œ˜š
œ˜Kš
œ˜Kš
œ˜Kš
œ%˜%Kš
œ˜——K˜—˜	š
œ(˜(Kš
œ˜Kš
œ%˜%Kš
œ˜Kšœ�œ˜$—K˜—Kšœ�œÏc˜?Kš�œ�œ
˜Kš�œ�œ
�œ&˜>K˜K˜—šžœ˜)Kšœ#�œ
˜6Kšœ�œ6˜NK˜K˜—KšŸœ�œ�œ*˜Zšžœ˜*Kšœ#�œ
˜6Kš
œ.˜.K˜K˜—K˜K™K˜š žœ�œ
�œ&�œ�œ
�œ+�œ
�œ�œ!�œ
�œ
�œ
�œ�œ�œ�œ˜ŸK˜Kšœ�œ˜K˜š
œ0˜0Kš
œ ˜ K˜Kšœ )˜?K˜—K˜Kš
œ˜Kš
œ"˜"Kš
œ"˜"Kš
œ ˜ K˜*K˜K˜—šžœ�œ
�œ+˜FKš
œ˜š�œ�œ
˜Kš
œM˜MKš
œN˜NKš�œ�œ
˜—Kš
œ˜K˜—šžœ�œ
�œ4˜OKš
œ˜Kš
œ˜K˜K˜—šž	œ�œ�œ˜:Kš
�œ	�œ�œ
�œ
�œ˜8Kš�œ
�œ
�œ	˜Kš
œ˜K˜—šž
œ˜%Kšœ�œ
˜&Kš
œ4˜4Kš
œ˜K˜—šžœ�œ
�œ˜/Kš
œ˜Kš
œ$˜$Kš
œ"˜"K˜K˜—K˜K™K™K™_K™åK™šžœ�œ
�œ�œ�œ�œ%˜‹
Kšœ+�œ$˜RKš
œ;˜;Kšœ9�œ˜>Kš�œ˜K˜K˜—šžœ�œ
�œ*�œ
�œ-�œ�œ
�œ˜®
Kš
œ˜Kš
œ%˜%š
œ<˜<Kš
ŸI™I—š�œD�œ�œ
�˜^Kš
œ-˜-Kš�œ
˜Kš
Ÿ™—Kš
œ!˜!š�œ�œ
�œ,�œ�œ
�˜PKš
œ�
˜�
Kš�œ�œ�œ˜HKš�œ
˜—KšŸœ˜KšŸœ˜K˜K˜—š
žœ�œ�œ�œ
�œ˜RKšœ�œ
˜K˜K˜—šžœ�œ)�œ
�œ�œ�œ
�œ˜‡
š�œ�œ
�œ˜Kš
�œ
�œ�œ
�œ
�œ
˜#Kšœ�œ	�œ˜%Kš�œ
˜K˜
—š�œ˜Kš
œ˜Kšœ�œ	�œ˜Kš
œ˜K˜—K˜K˜—šžœ�œ
�œ�œ
�œT�œ'�œ˜º
Kš
ϣ
™£
Kšœ	�œ	˜Kšœ�œ
�œ˜/Kšœ
�œ�œ
˜Kš
œH˜HKš
œ)˜)š�œD�œ�œ
�˜^Kš
Ÿa™aš�œ
�œ)�œ
�
˜5Kš
œ ˜ Kš�œ�œ;˜PKš�œ<˜@Kš�œ
˜K˜—š�œ
�œ
�œ�œ�œ %˜lKš
œ6˜6Kšœ
�œ
˜K˜
—š
�œ
�œ
�œ
�œ�œ�œ %˜qKš
œ6˜6Kšœ
�œ
˜K˜—KšœX�œ�œ�œ˜Š
Kš�œ
˜—š�œ
�œ
�œ -˜DKš
œ6˜6Kš
œ˜Kš
ŸM™M—š�œD�œ�œ
�˜^Kš
œ-˜-Kš�œ
˜—Kš
ό
˜å
š�œT�œ�œ
�˜nKš�œ�œ;˜PKš�œ<˜@Kš�œ
˜—K˜K˜—šžœ�œ
�œF�œ
�œ2�œ
�œ�œ �œ˜å
K™DK™CKš
œ4˜4š�œ�œ
�œ,�œ�œ
�˜PKš
œ�
˜�
Kš�œ�œ�œ˜H—Kš�œ
˜K˜—K˜šžœ�œ4�œ
�œ+�œ�œ	�œ�œ
�œ
�œ
�œ
�œ�œ'˜è
Kš
œ�
™�
Kš
œ/˜/š�œ�œ
�œ˜Kšœ�œ˜Kšœ�œ˜(š�œ@�™FKš
œ1™1—Kšœ$ ˜?K•StartOfExpansion9[base: 
ROPE, start: 
INT _ 0, len: 
INT _ 2147483647]š
 ™Kš�œ8�œE�œ
˜Œ
K˜—Kšœ
�œ�œ�œ˜fš
œ%˜%Kš
œ˜Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ˜Kšœ�œ˜
—Kšœ�œ˜/š�œ�œ
�œ"˜>Kš
œ3™3—Kš
œ˜K˜K˜—šŸœ"˜.Kšœ!�œ
˜4Kš
œ@˜@K˜—K˜š
ž
œ�œ�œ�œ�œ˜aš
œ#˜#š
œ˜Kš
œ/˜/Kš
œ˜Kšœ�œ
˜—Kš
œ˜—Kš
œ@˜@K˜K˜—šžœ�œ�œ�œ'˜aKš
œ#˜#Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ
˜
Kšœ�œ
˜
Kšœ�œ˜K˜K˜—K˜K™K™K™ï
K˜šžœ�œ
�œ&�œ�œ�œ
�œ,�œ�œ�œ#�œ!�œ�œ�œ�œ˜êKšœ�œ�œ
˜Kšœ�œ˜*š
žœ�œ �œ�œ�œ˜Jš
�œ&�œ�œ
�œ�œ
˜QKš�œ
�œ�œ˜—Kš
œ˜—šžœ�œ˜Kšœ�œ˜Kšœ�œ
˜Kšœ�œ 8˜IK˜K˜K˜K˜"š�œ	�œ
�œ˜˜*K˜
K˜K˜Kšœ�˜
K˜—Kš
œ?˜?K˜
—Kš�œ˜K˜˜š�œ+�œ�œ
�˜Gš�œ�œ˜Kš�œD˜Fšœ�œ˜K˜K˜/K˜—K˜—˜#K˜K˜K˜Kš
œ4™4Kšœ 4˜DK˜K˜K˜KšœÐbvœ
˜K˜K˜—K˜9š�œ)�œ˜1K˜ K˜7K˜—K˜'Kš�œ
˜—K˜Kš
œ˜——šž
œ�œ˜K˜K˜Kšœ�œ˜š�œ	�œ
�œ ˜.K˜#K˜"˜˜K˜K˜
K˜K˜Kšœ�˜K˜—KšœŸœ
˜K˜K˜—K˜,K˜
—Kš�œ"˜&š�œ+�œ�œ�˜IKšœ(�œ
 
˜8Kš�œ
˜—Kš
œ™š�œ	�œ
�œ&˜9K˜K˜
K˜Kšœ 3˜RKš
œT™TK˜K˜Kšœ�˜
K˜—š�œ&˜*˜K˜
K˜K˜K˜K˜K˜K˜—KšœŸœ
˜K˜K˜—K˜BKš
œ˜—K˜K˜K˜K˜'K˜"š�œ�œ
�œ
 :˜PK˜—K˜š�œ�˜KšœŸœ
˜$KšœŸ
œ
˜Kš�œ�œ
˜—K˜Kš
œ1™1Kš�œ�œ
�œ˜0K˜K˜0Kš�œ˜Kšœ  ˜#K˜—šžœ˜*Kšœ�œ
˜'š�œ�˜Kšœ�œ%˜J—Kš�œ �œ&˜PKš
œ˜K˜—šžœ�œ
�œ	�œ
�œ
�œ
�œ˜8Kšœ�œ˜-š�œ�˜"Kš
œ#™#˜9K˜6——š�œ
�œ�˜(˜9K˜7——K˜K˜—šžœ�œ
�œI�œ˜rKšœ�œ
˜ š
œ(˜(š�œ�œ�œ
˜,Kšœ8�œ˜>K˜Kš�œ�œ˜K˜—Kš
œ˜—Kš�œ�œ
�œ
�œ˜9š�œ�˜˜Eš�œ
�œ
�œ˜K˜0K˜"K˜
—Kš�œ
�œ˜K˜—K˜PK˜VKš�œ�œ
˜—Kš
œ˜K˜—K˜Kšœ�œ
�œ�œ
˜)Kšœ�œ
�œ�œ
˜(Kšœ�œ
�œ�œ
˜-K˜šžœ�œ�œ�œ˜BK˜%Kšœ
�œ
˜š�œ�œ
�œ˜K˜RK˜—Kš�œ
�œ˜š�œ�œ�˜š�œS�˜YK˜S—K˜Kš�œ
˜—Kšœ, (˜TKš�œ˜Kš
œ˜K˜—šžœ˜)Kšœ�œ
˜'Kšœ�œ	˜.Kšœ& /˜UK˜Kš
œV™VKš�œ
�œ
�œ)™@Kš
œ˜K˜—šžœ�œ-�œ�˜KKšœ�œ˜K˜%š�œ�œ�œ"�œ
˜AK˜Kš�œ
˜—š	�œ�œ
�œ
�œ 5˜UKš
œ4™4—š�œ�œ
�œ
˜Kš
œ<™<Kš�œ˜—Kš�œ
�œ˜&Kš
œ˜K˜—šžœ�œ-�œ�˜KKšœ�œ˜Kšœ�œ˜$K˜)š	�œ
�œ�œ*�œ�˜MK˜K˜Kš�œ
˜—Kš�œ˜
Kš
œ˜K˜—Kšœ�œ˜Kšœ�œ˜šž
œ�œ*˜=Kš
œ5™5Kš
œ)™)K˜7Kš
œ%™%K˜6Kš
œ˜K˜—Kš�œ
˜K˜K˜K˜—…—e¤Œ‚