DIRECTORY
Atom, CodeTimer, EBButtonClasses, EBConcreteTypes, EBEditors, EBEditorsExtras, EBEvent, EBLanguage, EBMesaLisp, EBTypes, EmbeddedButtons, IO, KeyMapping, KeyTypes, Process, RefTab, Rope, ScreenCoordsTypes, SimpleFeedback, SpecialKeySyms, TIPPrivate, TIPTypes, UserInput, UserInputDiscrimination, UserInputOps, UserInputOpsExtras2, ViewerClasses, ViewerOps;

EBImpl: CEDAR MONITOR -- for parseInfo --
IMPORTS Atom, CodeTimer, EBLanguage, EBMesaLisp, IO, KeyMapping, RefTab, Rope, SimpleFeedback, TIPPrivate, UserInputDiscrimination, UserInputOps, UserInputOpsExtras2, ViewerOps
EXPORTS EBButtonClasses, EBEditorsExtras, EBEditors, EBTypes, EmbeddedButtons = BEGIN

ActiveButton: TYPE = EBTypes.ActiveButton;
ActiveDoc: TYPE = EBTypes.ActiveDoc;
ButtonClass: TYPE = EBButtonClasses.ButtonClass;
ButtonInfo: TYPE = EBTypes.ButtonInfo;
ButtonInfoRec: TYPE = EBTypes.ButtonInfoRec;
ButtonInfoPrivateRec: PUBLIC TYPE = EBConcreteTypes.ButtonInfoPrivateRec;
EBLanguageProc: TYPE = EBLanguage.EBLanguageProc;
ROPE: TYPE = Rope.ROPE;
Variable: TYPE = REF VariableObj;
VariableObj: TYPE = EBLanguage.VariableObj;
VariableTable: TYPE = EBConcreteTypes.VariableTable;
Viewer: TYPE = ViewerClasses.Viewer;
TargetTableEntry: TYPE = REF TargetTableEntryRep;
TargetTableEntryRep: TYPE = EBConcreteTypes.TargetTableEntryRep;

Error: PUBLIC PROC [screenMessage: ROPE, fileMessage: ROPE ¬ NIL] = {
SimpleFeedback.Append[$EmbeddedButtons, oneLiner, $UserError, screenMessage];
};
ActiveDocObj: TYPE = EBTypes.ActiveDocObj;
ActiveDocClass: TYPE = EBEditors.ActiveDocClass;
ActiveDocPrivateObj: PUBLIC TYPE = EBConcreteTypes.ActiveDocPrivateObj;
Event: TYPE ~ EBEvent.Event;
EventRep: PUBLIC TYPE ~ EBEvent.EventRep; -- for EBTypes
Handle: TYPE = UserInput.Handle;

CreateActiveDoc: PUBLIC PROC [theDoc: REF, docClass: ActiveDocClass] RETURNS [theActiveDoc: ActiveDoc] = {
nameTable: RefTab.Ref ¬ RefTab.Create[];
targetTable: RefTab.Ref ¬ RefTab.Create[];

theActiveDoc ¬ NEW[ActiveDocObj ¬ [
theDoc: theDoc,
private: NEW[ActiveDocPrivateObj ¬ [
class: docClass,
nameTable: nameTable,
targetTable: targetTable]]]];
};


GetHandle: PUBLIC PROC [event: Event] RETURNS [UserInput.Handle] = {
RETURN[event.handle];
};

GetEvent: PUBLIC PROC [input: LIST OF REF] RETURNS [Event ¬ NIL] ~ {
IF input#NIL AND UserInputDiscrimination.IsHandle[input.first] AND input.rest#NIL THEN {
WITH input.rest.first SELECT FROM
action: EBEvent.Action => IF input.rest.rest=NIL THEN {
handle: Handle _ UserInputDiscrimination.NarrowHandle[input.first];
RETURN[NEW[EventRep ¬ [handle, action]]];
};
ENDCASE;
};
};

ValidEvent: PUBLIC PROC [event: Event] RETURNS [BOOL] ~ {
RETURN[event#NIL];
};
Button1: KeyTypes.KeySym ~ SpecialKeySyms.Button1;
Button2: KeyTypes.KeySym ~ SpecialKeySyms.Button2;
Button3: KeyTypes.KeySym ~ SpecialKeySyms.Button3;

MouseMotion: PUBLIC PROC [event: Event] RETURNS [BOOL ¬ FALSE] = {
SELECT event.action.kind FROM
$IntegerPosition, $Position, $FakePosition => RETURN[TRUE];
ENDCASE;
};

MouseAction: PUBLIC PROC [event: Event] RETURNS [BOOL ¬ FALSE] ~ {
SELECT event.action.kind FROM
$Key, $KeyStillDown => {
keySyms: KeyMapping.KeySyms ~ 
KeyMapping.GetKeySyms[UserInputOps.GetMapping[event.handle], event.action.keyCode];
FOR i: BYTE IN[0..keySyms.n) DO
SELECT keySyms[i] FROM
Button1, Button2, Button3 => RETURN[TRUE];
ENDCASE;
ENDLOOP;
};
$IntegerPosition, $Position, $FakePosition => RETURN[TRUE];
ENDCASE;
};
MouseAllUp: PUBLIC PROC [event: Event] RETURNS [BOOL] ~ {
RETURN[
UserInputOps.GetKeySymState[event.handle, Button1]=up AND 
UserInputOps.GetKeySymState[event.handle, Button2]=up AND 
UserInputOps.GetKeySymState[event.handle, Button3]=up
];
};

MouseCoords: PUBLIC PROC [event: Event] RETURNS [EBEditors.MousePosition] ~ {
RETURN[UserInputOpsExtras2.GetPosition[event.handle]];
};

HandleEvent: PUBLIC PROC [event: Event, button: ActiveButton, doc: ActiveDoc] ~ {
buttonInfo: ButtonInfo ~ GetButtonInfo[button, doc];
IF buttonInfo#NIL THEN {
class: ButtonClass ~ buttonInfo.private.class;
IF class#NIL AND class.handleEvent#NIL THEN -- Pass event to button class
class.handleEvent[event, buttonInfo.private.instanceData, buttonInfo];
};
};

parseInfo: TIPPrivate.TIPParseInfo ~ TIPPrivate.CreateParseInfo[name: "EBImpl.ParseEvent"];

MatchEvent: ENTRY PROC [table: TIPTypes.TIPTable, event: Event] RETURNS [LIST OF REF] ~ {
ENABLE UNWIND => NULL;
parseInfo.inCreek ¬ event.handle;
parseInfo.tableHead ¬ table;
RETURN[TIPPrivate.WideMatchEvent[parseInfo, event.action­]];
};

stdCoords: ScreenCoordsTypes.TIPScreenCoords ~ TIPPrivate.stdCoords;
ParseEvent: PUBLIC PROC [table: TIPTypes.TIPTable, event: Event] RETURNS [LIST OF REF] ~ {
result: LIST OF REF ~ MatchEvent[table, event];
FOR list: LIST OF REF ¬ result, list.rest UNTIL list=NIL DO
IF list.first=stdCoords THEN { [] ¬ ViewerOps.MouseInViewer[stdCoords]; EXIT };
ENDLOOP;
RETURN[result];
};

ButtonDataFromRope: PUBLIC PROC [rope: ROPE, instantiateNow: BOOL ¬ FALSE, button: ActiveButton ¬ NIL, doc: ActiveDoc ¬ NIL] RETURNS [val: REF] = {
CodeTimer.StartInt[$ButtonDataFromRope, $EmbeddedButtons];
val ¬ NEW[ButtonInfoRec ¬ [
button: button,
doc: doc,
private: NEW [ButtonInfoPrivateRec ¬ [
rope: rope,
changed: FALSE,
class: NIL,
nameChecked: FALSE,
name: $Unchecked,
fieldValuesOK: FALSE,
language: NIL,
languageVersion: 0,
instanceData: NIL,
hasComplained: FALSE]]]];
CodeTimer.StopInt[$ButtonDataFromRope, $EmbeddedButtons];
};

RopeFromButtonData: PUBLIC PROC [val: REF] RETURNS [rope: Rope.ROPE ¬ ""] = {
CodeTimer.StartInt[$RopeFromButtonData, $EmbeddedButtons];
WITH val SELECT FROM
buttonInfo: ButtonInfo => {
IF buttonInfo.private.class = NIL OR ~buttonInfo.private.changed OR buttonInfo.private.class.unparseInstanceData = NIL THEN rope ¬ buttonInfo.private.rope 
ELSE {
SELECT buttonInfo.private.language FROM
$Poppy => {
[] ¬ buttonInfo.private.class.unparseInstanceData[buttonInfo.private.instanceData, buttonInfo, $Poppy, 1];
rope ¬ Rope.Concat["Poppy1 ", EBLanguage.PoppyUnparse[buttonInfo.private.symbols, buttonInfo.private.order]];
};
$ButtonLisp => rope ¬ Rope.Cat[Atom.GetPName[buttonInfo.private.class.name], " ", buttonInfo.private.class.unparseInstanceData[buttonInfo.private.instanceData, buttonInfo, $ButtonLisp, 1]];
ENDCASE;
};
};
ENDCASE => Error["EmbeddedButtons: Internal error.  ButtonData is wrong type (RopeFromButtonData)"];
CodeTimer.StopInt[$RopeFromButtonData, $EmbeddedButtons];
};

ParseFeedbackField: EBLanguage.FieldParseProc = {
rope: ROPE ¬ stream.GetRope[];
val ¬ ButtonFeedbackFromRope[rope];
};

UnparseFeedbackField: EBLanguage.FieldUnparseProc = {
WITH val SELECT FROM
ft: FeedbackTable => RETURN[ft.rope];
ENDCASE => RETURN[""];
};

ButtonFeedbackFromRope: PUBLIC PROC [rope: ROPE, instantiateNow: BOOL ¬ FALSE] RETURNS[val: REF] = {
val ¬ NEW[FeedbackTableRec ¬ [
rope: rope,
table: NIL]];
};

ButtonFeedbackToRope: PUBLIC PROC [val: REF] RETURNS [rope: Rope.ROPE _ NIL] = {
WITH val SELECT FROM
ft: FeedbackTable => RETURN[ft.rope];
ENDCASE => Error["EmbeddedButtons: Internal error.  ButtonFeedback is wrong type (ButtonFeedbackToRope)"];
};

RegisterButtonClass: PUBLIC PROC [buttonClassName: ATOM, buttonClass: ButtonClass] = {
[] ¬ RefTab.Store[classTable, buttonClassName, buttonClass];
};

RegisterNameValuePair: PUBLIC PROC [name: ATOM, value: REF, buttonInfo: ButtonInfo] = {
[] ¬ RefTab.Store[buttonInfo.doc.private.nameTable, name, value];
};

CheckListOfATOM: PROC [list: LIST OF REF] RETURNS [ok: BOOL ¬ TRUE] = {
FOR l: LIST OF REF ¬ list, l.rest UNTIL l = NIL DO
IF NOT ISTYPE[l.first, ATOM] THEN {
Error["EmbeddedButtons: Message handlers (targets) must be atoms"];
RETURN[FALSE];
};
ENDLOOP;
};

UnknownLanguage: PROC [] = {
Error["PassEventToApplication: Unknown button language"];
};

GetApplications: PUBLIC PROC [buttonInfo: ButtonInfo] RETURNS [applications: LIST OF ATOM] = {
SELECT buttonInfo.private.language FROM
$Poppy => {
targetsRope: ROPE ~ EBLanguage.GetFieldRope[buttonInfo.private.symbols, $MessageHandler];
val: REF ~ EBMesaLisp.Parse[IO.RIS[targetsRope]].val;
tail: LIST OF ATOM;
IF ISTYPE[val, LIST OF REF] THEN {
FOR list: LIST OF REF ¬ NARROW[val], list.rest UNTIL list = NIL DO
IF NOT ISTYPE[list.first, ATOM] THEN RETURN[NIL]; -- one bad apple...
[applications, tail] ¬ AddAtom[NARROW[list.first], applications, tail];
ENDLOOP;
}
ELSE {
IF ISTYPE[val, ATOM] THEN applications ¬ LIST[NARROW[val, ATOM]]
ELSE applications ¬ NIL;
};
};
ENDCASE => {UnknownLanguage[]; RETURN[NIL]};
};

AddAtom: PUBLIC PROC [entity: ATOM, entityList, ptr: LIST OF ATOM] RETURNS [newList, newPtr: LIST OF ATOM] = {
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;
};
};

DefaultBehavior: PROC [class: ButtonClass, instanceData: REF, buttonInfo: ButtonInfo] = INLINE {
IF class # NIL AND class.defaultBehavior # NIL
THEN class.defaultBehavior[instanceData, buttonInfo]; 
};

PassEventToApplication: PUBLIC PROC [event: LIST OF REF, buttonInfo: ButtonInfo, application: ATOM ¬ $MessageHandlers] = {
targets: LIST OF ATOM;

IF application = $MessageHandlers THEN targets ¬ GetApplications[buttonInfo]
ELSE targets ¬ LIST[application];
ForkedEvent[event, buttonInfo, targets];
};

ForkedEvent: PROC [event: LIST OF REF, buttonInfo: ButtonInfo, targets: LIST OF ATOM] = {
anyTargetsFound: BOOL ¬ FALSE;
target: ATOM;
found: BOOL;
class: ButtonClass;
instanceData: REF;
val, results: REF;

class ¬ buttonInfo.private.class;
instanceData ¬ buttonInfo.private.instanceData;
IF event = NIL OR targets = NIL
THEN {DefaultBehavior[class, instanceData, buttonInfo]; RETURN};

FOR l: LIST OF ATOM ¬ targets, l.rest UNTIL l = NIL DO -- for each application...
target ¬ l.first;
IF target = $Default THEN {
DefaultBehavior[class, instanceData, buttonInfo];
anyTargetsFound ¬ TRUE;
LOOP;
};
[found, val] ¬ RefTab.Fetch[buttonInfo.doc.private.targetTable, target];
IF found THEN { -- this document is linked to a particular application window
anyTargetsFound ¬ TRUE;
WITH val SELECT FROM
entry: TargetTableEntry => {
IF entry.notifyProc # NIL THEN  {
results ¬ entry.notifyProc­[buttonInfo, event, entry.viewer, entry.applicationData];
ResultsFeedback[results, buttonInfo];
}
ELSE IF entry.viewer # NIL THEN {
ViewerOps.NotifyViewer[entry.viewer, event];
};
};
ENDCASE => {
Error["EmbeddedButtons: Internal error.  Target table entry is wrong type (PassEventToApplication)"];
RETURN;
};
}
ELSE { -- Let class do default handling and then try globally-registered applications
IF class # NIL AND class.defaultBehavior # NIL
THEN class.defaultBehavior[instanceData, buttonInfo]; 
[found, val] ¬ RefTab.Fetch[registeredNotifyTable, target];
IF found THEN {
anyTargetsFound ¬ TRUE;
WITH val SELECT FROM
proc: REF RegisteredNotifyProc => {
IF proc # NIL
THEN results ¬ proc­[event, buttonInfo]
ELSE results ¬ $Error;
ResultsFeedback[results, buttonInfo];
};
ENDCASE => {
Error["EmbeddedButtons: Internal error.  Registered notify proc is wrong type (PassEventToApplication)"];
RETURN;
};
}
ELSE Error[Rope.Concat["This message handler (target) not found: ", Atom.GetPName[target]]];
};
ENDLOOP;
};

okEvent: LIST OF REF = LIST[$Done, $OK];
errorEvent: LIST OF REF = LIST[$Done, $Error];
warningEvent: LIST OF REF = LIST[$Done, $Warning];
ResultsFeedback: PROC [results: REF, buttonInfo: ButtonInfo] ~ {
feedbackEvent: LIST OF REF;
WITH results SELECT FROM
list: LIST OF REF => feedbackEvent ¬ list;
ENDCASE => {
IF results = NIL THEN feedbackEvent ¬ okEvent
ELSE IF results = $Error THEN feedbackEvent ¬ errorEvent
ELSE IF results = $Warning THEN feedbackEvent ¬ warningEvent
ELSE feedbackEvent ¬ LIST[results];
};
FeedbackNotify[feedbackEvent, buttonInfo];
};

FeedbackTable: TYPE = REF FeedbackTableRec;
FeedbackTableRec: TYPE = RECORD [
rope: ROPE,
table: REF FeedbackTableObj
];
FeedbackTableObj: TYPE = LIST OF FeedbackTableEntry;
FeedbackTableEntry: TYPE = REF FeedbackTableEntryRec;
FeedbackTableEntryRec: TYPE = RECORD [
event: LIST OF REF,
action: LIST OF REF
];

MatchFeedbackTableEntry: PROC [feedbackEvent: LIST OF REF, table: FeedbackTable] RETURNS [bestAction: LIST OF REF ¬ NIL] = {
bestActionMatches: INT ¬ 0;
FOR l: LIST OF FeedbackTableEntry ¬ table.table­, l.rest UNTIL l = NIL DO
m: INT;
m ¬ IF Subset[l.first.event, feedbackEvent] THEN Matches[feedbackEvent, l.first.event] ELSE 0;
IF m > bestActionMatches THEN {
bestAction ¬ l.first.action;
bestActionMatches ¬ m;
};
ENDLOOP;
};

Subset: PROC [a, b: LIST OF REF] RETURNS [BOOL] = {
Included: PROC [a: REF, b: LIST OF REF] RETURNS [BOOL] = {
FOR list: LIST OF REF ¬ b, list.rest UNTIL list = NIL DO
IF Match[a, list.first] THEN RETURN[TRUE];
ENDLOOP;
RETURN[FALSE];
};
FOR alist: LIST OF REF ¬ a, alist.rest UNTIL alist = NIL DO
IF NOT Included[alist.first, b] THEN RETURN[FALSE];
ENDLOOP;
RETURN[TRUE];
};

Match: PROC [a, b: REF] RETURNS [BOOL] = {
IF a = b THEN RETURN[TRUE]
ELSE IF EBLanguage.Equal[a, b] THEN RETURN[TRUE]
ELSE IF a = $Red AND b = $Left THEN RETURN[TRUE]
ELSE IF a = $Yellow AND b = $Middle THEN RETURN[TRUE]
ELSE IF a = $Blue AND b = $Right THEN RETURN[TRUE]
ELSE IF a = $Left AND b = $Red THEN RETURN[TRUE]
ELSE IF a = $Middle AND b = $Yellow THEN RETURN[TRUE]
ELSE IF a = $Right AND b = $Blue THEN RETURN[TRUE]
ELSE RETURN[FALSE];
};

Matches: PROC [a, b: LIST OF REF] RETURNS [result: INT ¬ 0] = {
FOR c: LIST OF REF ¬ a, c.rest UNTIL c = NIL DO
FOR d: LIST OF REF ¬ b, d.rest UNTIL d = NIL DO
IF Match[c.first, d.first] THEN result ¬ result + 1;
ENDLOOP;
ENDLOOP;
};

CheckFeedbackTable: PROC [buttonInfo: ButtonInfo] RETURNS [table: FeedbackTable ¬ NIL] = {
buttonFeedback: REF;
SELECT buttonInfo.private.language FROM 
$Poppy => {
buttonFeedback ¬ EBLanguage.GetFieldRef[buttonInfo.private.symbols, $Feedback];
};
ENDCASE => RETURN;
IF buttonFeedback = NIL THEN RETURN[NIL]; -- this button doesn't specify any feedback
WITH buttonFeedback SELECT FROM
t: FeedbackTable => {
table ¬ t;
IF table.table = NIL THEN {
table.table ¬ ParseFeedbackTable[table.rope];
IF table.table = NIL THEN RETURN[NIL];
};
};
ENDCASE => {
Error["EmbeddedButtons: Internal error.  Button feedback table is wrong type (FeedbackNotify)"];
RETURN[NIL];
};
};

refTRUE: REF BOOL ¬ NEW[BOOL ¬ TRUE];
FeedbackNotify: PUBLIC PROC [feedbackEvent: LIST OF REF, buttonInfo: ButtonInfo] = {
table: FeedbackTable;
bestAction: LIST OF REF;

CodeTimer.StartInt[$FeedbackNotify, $EmbeddedButtons];
table ¬ CheckFeedbackTable[buttonInfo];
IF table = NIL THEN RETURN;

bestAction ¬ MatchFeedbackTableEntry[feedbackEvent, table];
IF bestAction = NIL OR (bestAction.first = NIL AND bestAction.rest = NIL) THEN {
CodeTimer.StopInt[$FeedbackNotify, $EmbeddedButtons];
RETURN;
};
ActionToEditor[bestAction, buttonInfo, feedbackEvent];
CodeTimer.StopInt[$FeedbackNotify, $EmbeddedButtons];
};

Context: TYPE = EBTypes.Context;
feedbackContext: Context ¬ EBLanguage.CreateContext[];

InButton: PUBLIC PROC [x, y: INTEGER, buttonInfo: ButtonInfo] RETURNS[BOOL] = {
IF buttonInfo.doc.private.class.inButton # NIL THEN 
RETURN[buttonInfo.doc.private.class.inButton[buttonInfo.button, buttonInfo.doc, x, y]];

RETURN[TRUE];
};

MapButtons: PUBLIC PROC [doc: ActiveDoc, proc: EachButtonProc] RETURNS [aborted: BOOL ¬ FALSE] = {
IF doc.private.class.mapRef # NIL THEN aborted ¬ doc.private.class.mapRef[doc, proc];
};
EachButtonProc: TYPE = EmbeddedButtons.EachButtonProc;

RegisterPoppyProc: PUBLIC PROC [procedureName: ATOM, proc: EBLanguageProc, interpreted: BOOL ¬ TRUE] = {
EBLanguage.RegisterProc[procedureName, proc, interpreted];
};

FeedbackToEditor: PUBLIC PROC [feedback: REF, buttonInfo: ButtonInfo] RETURNS [REF] = {
RETURN[buttonInfo.doc.private.class.feedback[buttonInfo.button, buttonInfo.doc, feedback]];
};

ActionToEditor: PUBLIC PROC [action: LIST OF REF, buttonInfo: ButtonInfo, feedbackEvent: LIST OF REF] = {
receivers: LIST OF REF ¬ LIST[buttonInfo.doc.private.class.name];
CodeTimer.StartInt[$ActionToEditor, $EmbeddedButtons];
EBLanguage.SetSystemValue[feedbackContext, $MessageReceiver, receivers];
EBLanguage.SetSystemValue[feedbackContext, $Feedback, refTRUE];
IF ISTYPE[action.first, LIST OF REF] THEN {
FOR l: LIST OF REF ¬ action, l.rest UNTIL l = NIL DO
WITH l.first SELECT FROM
lora: LIST OF REF => {
message: REF ¬ EBLanguage.Evaluate[lora, buttonInfo, feedbackEvent, feedbackContext];
IF message # NIL THEN [] ¬ FeedbackToEditor[message, buttonInfo];
};
ENDCASE => Error["EmbeddedButtons: Feedback table actions must be lists!"];
ENDLOOP;
}
ELSE {
message: REF ¬ EBLanguage.Evaluate[action, buttonInfo, feedbackEvent, feedbackContext];
IF message # NIL THEN [] ¬ FeedbackToEditor[message, buttonInfo];
};
CodeTimer.StopInt[$ActionToEditor, $EmbeddedButtons];
};

SetButtonValue: PUBLIC PROC [buttonInfo: ButtonInfo, variable: ATOM ¬ $Value, value: REF] = {
IF variable = $Value THEN {
class: ButtonClass ¬ buttonInfo.private.class;
instanceData: REF ¬ buttonInfo.private.instanceData;
IF class # NIL AND class.setValue # NIL THEN {
changed: BOOL ¬ class.setValue[instanceData, value, buttonInfo];
IF changed THEN MarkButtonAsChanged[buttonInfo];
};
}
ELSE {
variableTable: VariableTable ¬ NARROW[GetFieldRef[$Variables, buttonInfo]];
IF variableTable = NIL THEN RETURN
ELSE {
realVar: Variable ¬ EBLanguage.GetVariable[variableTable, variable];
IF realVar = NIL THEN {
Error[IO.PutFR["Button %g has non-existent or incorrect definition for variable %g.  Can't SetButtonValue", [atom[buttonInfo.private.name]], [atom[variable]] ]];
}
ELSE {
realVar.value ¬ value;
EBLanguage.SetVariable[variableTable, variable, realVar];
};
};
};
};

NotifyProc: TYPE = EmbeddedButtons.NotifyProc;
RegisteredNotifyProc: TYPE = EmbeddedButtons.RegisteredNotifyProc;

LinkDocToApplication: PUBLIC PROC [doc: ActiveDoc, target: ATOM, targetViewer: Viewer ¬ NIL, applicationData: REF ¬ NIL, notifyProc: NotifyProc ¬ NIL] = {
refNotifyProc: REF NotifyProc ¬ IF notifyProc = NIL THEN NIL ELSE NEW[NotifyProc ¬ notifyProc];

tte: TargetTableEntry ¬ NEW[TargetTableEntryRep ¬ [
viewer: targetViewer,
applicationData: applicationData,
notifyProc: refNotifyProc]];

[] ¬ RefTab.Store[doc.private.targetTable, target, tte];
};

RegisterApplication: PUBLIC PROC [target: ATOM, notifyProc: RegisteredNotifyProc] = {
refRegisteredNotifyProc: REF RegisteredNotifyProc ¬ IF notifyProc = NIL THEN NIL ELSE NEW[RegisteredNotifyProc ¬ notifyProc];

[] ¬ RefTab.Store[registeredNotifyTable, target, refRegisteredNotifyProc];
};

GetValue: PUBLIC PROC [name: ATOM, doc: ActiveDoc, variable: ATOM ¬ $Value] RETURNS [val: REF ANY] = {
MapGetKeyValue: EmbeddedButtons.EachButtonProc = {
class: ButtonClass;
instanceData: REF;
thisName: ATOM;
exists: BOOL ¬ FALSE;

[thisName, exists] ¬ GetName[button, doc];
IF exists AND thisName = name THEN {
buttonInfo: ButtonInfo ¬ GetButtonInfo[button, doc]; -- does a full parse, if needed
val ¬ GetButtonValue[buttonInfo, variable]; -- stores value in nameTable, if appropriate
};
};
found: BOOL ¬ FALSE;
IF variable = $Value THEN {
[found, val] ¬ RefTab.Fetch[doc.private.nameTable, name];
};
IF val = NIL THEN [] ¬ doc.private.class.mapRef[doc, MapGetKeyValue];
};

GetButtonName: PUBLIC PROC [buttonInfo: ButtonInfo] RETURNS [name: ATOM] = {
exists: BOOL ¬ FALSE;
[name, exists] ¬ GetNameInternal[buttonInfo];
IF NOT exists THEN name ¬ NIL;
};

GetNameInternal: PROC [buttonInfo: ButtonInfo] RETURNS [name: ATOM, exists: BOOL ¬ FALSE] = {
IF buttonInfo # NIL THEN {
IF buttonInfo.private.nameChecked THEN {
name ¬ buttonInfo.private.name;
exists ¬ TRUE;
}
ELSE {
success: BOOL ¬ ConfirmFields[buttonInfo];
IF success THEN {
nameRope: ROPE ¬ GetFieldRope[$Name, buttonInfo];
nameVal: REF ¬ EBMesaLisp.Parse[IO.RIS[nameRope]].val;
IF nameVal # NIL THEN {
IF ISTYPE[nameVal, ATOM] THEN {
name ¬ NARROW[nameVal];
exists ¬ TRUE;
buttonInfo.private.nameChecked ¬ TRUE;
buttonInfo.private.name ¬ name;
}
ELSE Error["GetName:  Invalid Name field!"];
};
};
};
};
};

GetButtonValue: PUBLIC PROC [buttonInfo: ButtonInfo, variable: ATOM ¬ $Value] RETURNS [value: REF ¬ NIL] = {
IF variable = $Value THEN {
class: ButtonClass ¬ buttonInfo.private.class;
instanceData: REF ¬ buttonInfo.private.instanceData;
IF class # NIL AND class.getValue # NIL THEN 
value ¬ class.getValue[instanceData, buttonInfo];
}
ELSE {
variableTable: VariableTable ¬ NARROW[GetFieldRef[$Variables, buttonInfo]];
IF variableTable = NIL THEN RETURN[NIL]
ELSE {
realVar: Variable ¬ EBLanguage.GetVariable[variableTable, variable];
IF realVar = NIL THEN {
value ¬ NIL;
Error[IO.PutFR["Button %g has non-existent or incorrect definition for variable %g.  Can't GetButtonValue", [atom[buttonInfo.private.name]], [atom[variable]] ]];
}
ELSE value ¬ realVar.value;
};
};
};

SetValue: PUBLIC PROC [name: ATOM, val: REF, doc: ActiveDoc, variable: ATOM ¬ $Value] = {
MapSetKeyValue:  EBEditors.EachButtonProc = {
thisName: ATOM;
exists: BOOL ¬ TRUE;

[thisName, exists] ¬ GetName[button, doc];
IF exists AND thisName = name THEN {
buttonInfo: ButtonInfo ¬ GetButtonInfo[button, doc]; -- fully instantiates if necessary
IF buttonInfo = NIL THEN RETURN;
SetButtonValue[buttonInfo, variable, val];
};
};
[] ¬ doc.private.class.mapRef[doc, MapSetKeyValue];
};
GetRawButtonInfo: PROC [button: ActiveButton, doc: ActiveDoc] RETURNS [buttonInfo: ButtonInfo ¬ NIL] = {
data: REF ¬ doc.private.class.getRef[$ButtonData, button, doc];
IF data = NIL THEN {
Error[IO.PutFR1["Some button in doc %g has a NIL $ButtonData property (Instantiated?)", [rope[doc.private.class.getDocName[doc]]] ]];
buttonInfo ¬ NIL;
}
ELSE {
WITH data SELECT FROM
b: ButtonInfo => buttonInfo ¬ b;
r: ROPE => {
buttonInfo ¬ NARROW[ButtonDataFromRope[r]];
doc.private.class.setRef[$ButtonData, button, doc, buttonInfo, FALSE];
};
ENDCASE => {
Error["Don't know what this ButtonData is!", "A button was pressed whose ButtonData was an unknown type."];
buttonInfo ¬ NIL;
};
};
};

GetButtonInfo: PROC [button: ActiveButton, doc: ActiveDoc] RETURNS [buttonInfo: ButtonInfo] = {
CodeTimer.StartInt[$GetButtonInfo, $EmbeddedButtons];
buttonInfo ¬ GetRawButtonInfo[button, doc];
IF buttonInfo # NIL THEN {
success: BOOL ¬ FALSE;
buttonInfo.button ¬ button;
buttonInfo.doc ¬ doc;
success ¬ ConfirmButtonInfo[buttonInfo];
IF NOT success THEN buttonInfo ¬ NIL;
};
CodeTimer.StopInt[$GetButtonInfo, $EmbeddedButtons];
};

GetName: PROC [button: ActiveButton, doc: ActiveDoc] RETURNS [name: ATOM, exists: BOOL ¬ FALSE] = {
buttonInfo: ButtonInfo ¬ GetRawButtonInfo[button, doc]; -- no parsing, but may already be parsed
IF buttonInfo # NIL THEN {
IF buttonInfo.private.nameChecked THEN {
name ¬ buttonInfo.private.name;
exists ¬ TRUE;
}
ELSE {
success: BOOL ¬ ConfirmFields[buttonInfo];
IF success THEN {
nameRope: ROPE ¬ GetFieldRope[$Name, buttonInfo];
nameVal: REF ¬ EBMesaLisp.Parse[IO.RIS[nameRope]].val;
IF nameVal # NIL THEN {
IF ISTYPE[nameVal, ATOM] THEN {
name ¬ NARROW[nameVal];
exists ¬ TRUE;
buttonInfo.private.nameChecked ¬ TRUE;
buttonInfo.private.name ¬ name;
}
ELSE Error["GetName:  Invalid Name field!"];
};
};
};
};
};

GetButtonClass: PUBLIC PROC [buttonInfo: ButtonInfo] RETURNS [buttonClass: ButtonClass ¬ NIL] = {
buttonClass ¬ buttonInfo.private.class;
};

GetDocClassName: PUBLIC PROC [doc: ActiveDoc] RETURNS[name: ATOM] = {
name ¬ doc.private.class.name;
};

GetFieldRope: PUBLIC PROC [key: ATOM, buttonInfo: ButtonInfo] RETURNS [rope: ROPE] = {
rope ¬ EBLanguage.GetFieldRope[buttonInfo.private.symbols, key];
};
GetFieldAtom: PUBLIC PROC [key: ATOM, buttonInfo: ButtonInfo] RETURNS [atom: ATOM] = {
atom ¬ EBLanguage.GetFieldAtom[buttonInfo.private.symbols, key];
};
GetFieldRef: PUBLIC PROC [key: ATOM, buttonInfo: ButtonInfo] RETURNS [ref: REF] = {
ref ¬EBLanguage.GetFieldRef[buttonInfo.private.symbols, key];
};

SetFieldRope: PUBLIC PROC [key: ATOM, rope: ROPE, buttonInfo: ButtonInfo] = {
EBLanguage.SetFieldRope[buttonInfo.private.symbols, buttonInfo.private.order, key, rope];
};
SetFieldAtom: PUBLIC PROC [key: ATOM, atom: ATOM, buttonInfo: ButtonInfo] = {
EBLanguage.SetFieldAtom[buttonInfo.private.symbols, buttonInfo.private.order, key, atom];
};
SetFieldRef: PUBLIC PROC [key: ATOM, ref: REF, buttonInfo: ButtonInfo] = {
EBLanguage.SetFieldRef[buttonInfo.private.symbols, buttonInfo.private.order, key, ref];
};

GetAtom: PUBLIC PROC [key: ATOM, buttonInfo: ButtonInfo] RETURNS [atom: ATOM ¬ NIL] = {
r: REF ¬ buttonInfo.doc.private.class.getRef[key, buttonInfo.button, buttonInfo.doc];
IF r = NIL THEN RETURN;
WITH r SELECT FROM
a: ATOM => atom ¬ a;
ENDCASE => Error["EmbeddedButtons:  Value returned to GetAtom was not an ATOM."];
};

SetAtom: PUBLIC PROC [key: ATOM, atom: ATOM, buttonInfo: ButtonInfo, edited: BOOL] = {
buttonInfo.doc.private.class.setRef[key, buttonInfo.button, buttonInfo.doc, atom, edited];
};

GetRope: PUBLIC PROC [key: ATOM, buttonInfo: ButtonInfo] RETURNS [rope: ROPE] = {
r: REF ¬ buttonInfo.doc.private.class.getRef[key, buttonInfo.button, buttonInfo.doc];
IF r = NIL THEN RETURN;
WITH r SELECT FROM
a: ROPE => rope ¬ a;
ENDCASE => Error["EmbeddedButtons:  Value returned to GetRope was not a ROPE."];
};

SetRope: PUBLIC PROC [key: ATOM, rope: ROPE, buttonInfo: ButtonInfo, edited: BOOL] = {
buttonInfo.doc.private.class.setRef[key, buttonInfo.button, buttonInfo.doc, rope, edited];
};

GetRef: PUBLIC PROC [key: ATOM, buttonInfo: ButtonInfo] RETURNS [ref: REF] = {
ref ¬ buttonInfo.doc.private.class.getRef[key, buttonInfo.button, buttonInfo.doc];
};

SetRef: PUBLIC PROC [key: ATOM, ref: REF, buttonInfo: ButtonInfo, edited: BOOL] = {
buttonInfo.doc.private.class.setRef[key, buttonInfo.button, buttonInfo.doc, ref, edited];
};

GetText: PUBLIC PROC [buttonInfo: ButtonInfo] RETURNS [text: ROPE] = {
text ¬ buttonInfo.doc.private.class.getText[buttonInfo.button, buttonInfo.doc];
};
GetDocName: PUBLIC PROC [buttonInfo: ButtonInfo] RETURNS [name: ROPE] = {
name ¬ buttonInfo.doc.private.class.getDocName[buttonInfo.doc];
};
ParseFeedbackTable: PROC [r: ROPE] RETURNS [f: REF FeedbackTableObj ¬ NIL] = {
s: IO.STREAM;
CodeTimer.StartInt[$ParseFeedbackTable, $EmbeddedButtons];
s ¬ IO.RIS[r];
f ¬ ParseCurrentFeedbackTable[s];
CodeTimer.StopInt[$ParseFeedbackTable, $EmbeddedButtons];
};

ParseCurrentFeedbackTable: PROC [s: IO.STREAM] RETURNS [f: REF FeedbackTableObj ¬ NIL] = {
object: REF;
head: FeedbackTableObj;
tail: FeedbackTableObj;
char: CHAR;
f ¬ NEW[FeedbackTableObj ¬ NIL];

[] ¬ s.SkipWhitespace[];
char ¬ s.PeekChar[];
IF char # '( AND char # '< THEN {
Error["EmbeddedButtons: The value of Feedback: must be in parens or angle brackets"];
RETURN;
};
object ¬ EBMesaLisp.Parse[s].val;
IF NOT ISTYPE[object, LIST OF REF] THEN {
Error["EmbeddedButtons: The value of Feedback: must be a list"];
RETURN;
};

head ¬ LIST[NIL];
tail ¬ head;

FOR l: LIST OF REF ¬ NARROW[object], l.rest UNTIL l = NIL DO
first: LIST OF REF;
IF NOT ISTYPE[l.first, LIST OF REF] THEN {
Error["EmbeddedButtons: Entries in a feedback table must be event-action pairs"];
RETURN;
};
first ¬ NARROW[l.first];
IF NOT ISTYPE[first.first, ATOM] AND NOT ISTYPE[first.first, LIST OF REF] THEN {
Error["EmbeddedButtons: Invalid event in feedback table"];
RETURN;
};
IF NOT ISTYPE[first.rest.first, LIST OF REF] THEN {
Error["EmbeddedButtons: Invalid action in feedback table"];
RETURN;
};
tail.rest ¬ LIST[NEW[FeedbackTableEntryRec ¬ [
event: IF ISTYPE[first.first, ATOM] THEN LIST[first.first] ELSE NARROW[first.first],
action: NARROW[first.rest.first]]]];
tail ¬ tail.rest;
ENDLOOP;

f­ ¬ head.rest;
};

ConfirmButtonInfo: PROC [buttonInfo: ButtonInfo] RETURNS [success: BOOL ¬ TRUE] = {
IF buttonInfo.private.fieldValuesOK THEN {
CodeTimer.StartInt[$ConfirmButtonInfoQuick, $EmbeddedButtons];
success ¬ TRUE;
IF buttonInfo.private.instanceData = NIL THEN {
buttonInfo.private.instanceData ¬ buttonInfo.private.class.instantiate[
buttonInfo: buttonInfo, 
language: buttonInfo.private.language, 
languageVersion: buttonInfo.private.languageVersion];
};
CodeTimer.StopInt[$ConfirmButtonInfoQuick, $EmbeddedButtons];
}
ELSE {
CodeTimer.StartInt[$ConfirmButtonInfo, $EmbeddedButtons];
success ¬ ConfirmSymbols[buttonInfo];
IF NOT success THEN {CodeTimer.StopInt[$ConfirmButtonInfo, $EmbeddedButtons]; RETURN};
IF buttonInfo.private.instanceData = NIL THEN {
buttonInfo.private.instanceData ¬ buttonInfo.private.class.instantiate[
buttonInfo: buttonInfo, 
language: buttonInfo.private.language, 
languageVersion: buttonInfo.private.languageVersion];
};
CodeTimer.StopInt[$ConfirmButtonInfo, $EmbeddedButtons];
};
};

ConfirmFields: PROC [buttonInfo: ButtonInfo] RETURNS [success: BOOL ¬ TRUE] = {
buttonClassRope: ROPE;
buttonClassName: ATOM;
stream: IO.STREAM;
languageName: ROPE;
IF buttonInfo.private.class # NIL THEN RETURN; -- field names are OK

CodeTimer.StartInt[$ConfirmFields, $EmbeddedButtons];
stream ¬ IO.RIS[buttonInfo.private.rope];
languageName ¬ EBMesaLisp.ReadWWord[stream];
BEGIN
IF NOT Rope.Equal[languageName, "Poppy1"] THEN {
Error[Rope.Concat["Unknown button language: ", languageName]];
CodeTimer.StopInt[$ConfirmFields, $EmbeddedButtons];
RETURN[FALSE];
};
buttonInfo.private.language ¬ $Poppy;
buttonInfo.private.languageVersion ¬ 1;
[buttonInfo.private.symbols, buttonInfo.private.order] ¬ EBLanguage.PoppyParseFieldNames[stream];
buttonClassRope ¬ EBLanguage.GetFieldRope[buttonInfo.private.symbols, $Class];
buttonClassName ¬ Atom.MakeAtom[buttonClassRope];
buttonInfo.private.class ¬ LookupButtonClass[buttonClassName];
IF buttonInfo.private.class = NIL THEN GOTO NoSuchClass;
buttonInfo.private.fieldValuesOK ¬ FALSE;
EXITS
NoSuchClass => {
IF NOT buttonInfo.private.hasComplained THEN {
Error[Rope.Concat["Button class not registered: ", buttonClassRope], Rope.Concat["The button class for this button has not been registered: ", buttonClassRope]];
buttonInfo.private.hasComplained ¬ TRUE;
};
CodeTimer.StopInt[$ConfirmFields, $EmbeddedButtons];
RETURN[FALSE];
};
END;
CodeTimer.StopInt[$ConfirmFields, $EmbeddedButtons];
};

ConfirmSymbols: PROC [buttonInfo: ButtonInfo] RETURNS [success: BOOL ¬ TRUE] = {
IF buttonInfo.private.fieldValuesOK THEN RETURN; -- field names and values are OK

CodeTimer.StartInt[$ConfirmSymbols, $EmbeddedButtons];
IF buttonInfo.private.class = NIL THEN { -- field names and values are both needed
buttonClassRope: ROPE;
buttonClassName: ATOM;
stream: IO.STREAM ¬ IO.RIS[buttonInfo.private.rope];
languageName: ROPE ¬ EBMesaLisp.ReadWWord[stream];
BEGIN
IF NOT Rope.Equal[languageName, "Poppy1"] THEN {
Error[Rope.Concat["Unknown button language: ", languageName]];
CodeTimer.StopInt[$ConfirmSymbols, $EmbeddedButtons];
RETURN[FALSE];
};
buttonInfo.private.language ¬ $Poppy;
buttonInfo.private.languageVersion ¬ 1;
[buttonInfo.private.symbols, buttonInfo.private.order] ¬ EBLanguage.PoppyParse[stream];
buttonClassRope ¬ EBLanguage.GetFieldRope[buttonInfo.private.symbols, $Class];
buttonClassName ¬ Atom.MakeAtom[buttonClassRope];
buttonInfo.private.class ¬ LookupButtonClass[buttonClassName];
IF buttonInfo.private.class = NIL THEN GOTO NoSuchClass;
EXITS
NoSuchClass => {
IF NOT buttonInfo.private.hasComplained THEN {
Error[Rope.Concat["Button class not registered: ", buttonClassRope], Rope.Concat["The button class for this button has not been registered: ", buttonClassRope]];
buttonInfo.private.hasComplained ¬ TRUE;
};
CodeTimer.StopInt[$ConfirmSymbols, $EmbeddedButtons];
RETURN[FALSE];
};
END;
}
ELSE {
EBLanguage.PoppyParseFieldValues[buttonInfo.private.symbols];
};
buttonInfo.private.fieldValuesOK ¬ TRUE;
CodeTimer.StopInt[$ConfirmSymbols, $EmbeddedButtons];
};

LookupButtonClass: PROC [buttonClassName: ATOM] RETURNS [buttonClass: ButtonClass ¬ NIL] = {
found: BOOL;
b: REF ANY;
[found, b] ¬ RefTab.Fetch[classTable, buttonClassName];
IF NOT ISTYPE[b, ButtonClass] THEN {
Error["EmbeddedButtons: Internal error.  Button class is wrong type (LookupButtonClass).", ];
RETURN;
};
buttonClass ¬ NARROW[b];
};

MarkButtonAsChanged: PUBLIC PROC [buttonInfo: ButtonInfo] = {
buttonInfo.private.changed ¬ TRUE;
buttonInfo.doc.private.class.setRef[$ButtonData, buttonInfo.button, buttonInfo.doc, buttonInfo, TRUE];
};
classTable: RefTab.Ref ¬ RefTab.Create[];
registeredNotifyTable: RefTab.Ref ¬ RefTab.Create[];
EBLanguage.RegisterFieldParseProc[$Feedback, ParseFeedbackField];
EBLanguage.RegisterFieldUnparseProc[$Feedback, UnparseFeedbackField];
END.




ψ
EBImpl.mesa
Copyright Σ 1988, 1989, 1990, 1992 by Xerox Corporation.  All rights reserved.
Goodisman, August 15, 1989 5:10:44 pm PDT
Kenneth A. Pier, October 30, 1990 5:15 pm PST
Bier, November 10, 1992 10:48 am PST
Doug Wyatt, April 21, 1992 11:25 am PDT
Contents:  The implementation of EmbeddedButtons, A framework for adding standardized behaviors to any application that is willing to support a set of button objects and implement the behavior access routines.

Error Reporting
The $EmbeddedButtons is set up by ButtonApplicationsImpl's initialization.
IF fileMessage = NIL THEN fileMessage ¬ screenMessage;
SimpleFeedback.Append[$EmbeddedButtons, oneLiner, $InternalError, fileMessage];
Used By Editors
HandleRep: PUBLIC TYPE ~ UserInputPrivate.Rep; -- used only by MouseCoords routine below


RETURN[event.handle.mousePosition];

Have button class unparse fields into the symbol table.
Now unparse the symbol table.
PROC [stream: IO.STREAM] RETURNS [val: REF]
For registration with EBLanguage.RegisterFieldParseProc.
PROC[val: REF] RETURNS [rope: ROPE];
For registration with EBLanguage.RegisterFieldUnparseProc.
"table" will be computed when the button is used.
Used By Button Classes
Should change to include button for traceback.
Usually, when a button is not connected to any application, it will exhibit some default behavior when clicked so that the user knows it is working.  Radio Buttons, for instance, change their state when clicked, as a default behavior.

Process.Detach[FORK ForkedEvent[event, buttonInfo, targets]]; -- unfortunately this causes synchronization problems with Tioga (sigh), Bier February 19, 1990
Search the table for the most specific match to this event.
Returns TRUE iff all REFs of a (or their equivalents, see ExactMatch) are also in b.
Returns the number of elements of the first list that also occur in the second list with the following provisos:  $Red matches $Left, $Yellow matches $Middle, $Blue matches $Right.
Get the feedback table
feedbackEvent may come from several places including
(1)	Translating raw actions through ButtonClassesCommon.tip which produces the atoms Up, Down, Red, Yellow, Blue, MouseMoved and produces mouse coordinates.
(2)	The SetValueProc of a given ButtonClass.  For example, Multi-state buttons send ($Value, <ref>).  Radio buttons send ($State, <REF BOOL>) or ($StateStill, <REF BOOL>).
Used By Feedback Procedures
Otherwise, we have a list like (1 ApplyLook <TextFromValue>) or like <SetCursor bullseye>.  Evaluate as needed and pass to the editor once.
Used By Applications
Tries to find the value in the table of recently queried values.  Otherwise, searches the document.  In the current implementation, only value $Value is cached.  Other values require searching the document.
PROC [button: ActiveButton, doc: ActiveDoc] RETURNS [done: BOOL _ FALSE]
Convenience Routines
Gets the rope corresponding to the key in the specification of the button.

Gets the atom corresponding to the key in the specification of the button.

Gets the ref corresponding to the key in the specification of the button.
Gets the rope corresponding to the key in the specification of the button.

Gets the atom corresponding to the key in the specification of the button.

Gets the ref corresponding to the key in the specification of the button.


Internal Routines
Pick apart the ButtonData into fields, making an entry in "symbols" for each field.  Don't parse the value section of each field.
We expect ButtonData to be in the form:
Poppy1 Class: <classname> <fieldname1>: <field1> <fieldname2>: <field2> etc.

Pick apart the ButtonData into fields, making an entry in "symbols" for each field.  Parse the value section of each field. 
We expect ButtonData to be in the form:
Poppy1 Class: <classname> <fieldname1>: <field1> <fieldname2>: <field2> etc.

Field names are OK.  Just parse the values.
Tell the editor that the document has changed by setting the ButtonData property on the button
Initialization

$ButtonFeedback is an obsolete property.  Where still used, this property is in the following format:

buttonFeedback _ "languageVersion ( feedbackTable )"
languageVersion _ 19890713
feedbackTable _ feedbackTableEntry | feedbackTableEntry feedbackTable
feedbackTableEntry _ ( event entryActions )
event _ userEvent | applicationEvent | ( qualifiersAndEvent ) | ( applicationEvents )
userEvent _ ATOM  [usually $Up or $Down]
applicationEvent _ ATOM 
applicationEvents _ applicationEvent | applicationEvent ApplicationEvents
qualifiersAndEvent _ qualifier 
| qualifier qualifiersAndEvent 
| userEvent
| userEvent qualifiersAndEvent
qualifier _ ATOM [usually $Red, $Control, $Shift, etc.]
entryActions _ entryAction | ( entryActionList )
entryActionList _ entryAction | entryAction entryActionList
entryAction _ action | handlerAction
handlerAction _ ( handler handlerParameters )
handler _ ATOM [the name of the handler]
handlerParameters _ handlerParameter | handlerParameter handlerParameters
handlerParameter _ value
value _ ATOM, BOOL, INT, REAL, or ROPE [a button value]
action _ ROPE [editor specific formatted feedback ROPE]

Κ(K•NewlineDelimiter

–
"cedarcode" style™
codeš
œ™Kšœ	ΟeœB™NKš
œ)™)K™-K™$K™'K˜KšΟnœΙ
™Ρ
K™—š
Οk	˜	Jš
œŠ
Ÿœœœ
œ	œœœœœœœj˜δK˜—šžœŸœ
Ÿœ
Οc˜)JšŸœ*Ÿœ}˜°
KšŸœHŸ˜UK˜KšœŸœ˜*KšœŸœ˜$Kšœ
Ÿœ˜0KšœŸœ˜&KšœŸœ˜,KšœŸœ
Ÿœ(˜IKšœŸœ˜1KšŸœŸœŸœ
˜Kšœ
ŸœŸœ
˜!Kšœ
Ÿœ˜+KšœŸœ!˜4KšœŸœ˜$KšœŸœŸœ˜1KšœŸœŸ
œŸ
˜@—K˜Iheadš
Οx™šžœŸœ
ŸœŸœŸœŸœ˜EK™JKšŸœŸœ
Ÿœ™6K˜MK™OK˜—Lš
‘™KšœŸœ˜*KšœŸœ˜0KšœŸœ'˜GKšœŸœ˜Kšœ
Ÿœ
Ÿœ ˜8KšœŸœ˜ KšœŸœ
Ÿœ )™XK˜šžœŸœ
ŸœŸœ˜jK˜(K˜*K˜šœŸœ˜#K˜šœ	Ÿœ˜$K˜K˜K˜——K˜K˜—K˜š	ž	œŸœ
ŸœŸœœ˜DKšŸœ˜K˜K˜—šžœŸœ
Ÿœ	Ÿœ
Ÿœ
ŸœŸœ
Ÿœ˜DšŸœŸœ
Ÿœ/ŸœŸœ
Ÿœ˜XšŸœŸœ
Ÿ˜!šœŸœŸœ
Ÿœ
Ÿ
˜7K˜CKšŸœ
Ÿœ˜)K˜—KšŸœ
˜—K˜—K˜K˜—š
ž
œŸœ
ŸœŸœŸœ˜9JšŸœŸœ˜Kš
œ˜K™—K˜2K˜2˜2K˜—šžœŸœ
ŸœŸœŸœŸœ˜BšŸœŸ˜Kšœ.Ÿœ
Ÿœ˜;KšŸœ
˜—K˜K˜—šžœŸœ
ŸœŸœŸœŸœ˜BšŸœŸ˜˜K˜ršŸœŸœ
ŸœŸ˜šŸœŸ˜KšœŸœ
Ÿœ˜*KšŸœ
˜—KšŸœ
˜—K˜—Kšœ.Ÿœ
Ÿœ˜;KšŸœ
˜—Kš
œ˜K™—š
ž
œŸœ
ŸœŸœŸœ˜9šŸœ
˜Kšœ6Ÿœ
˜:Kšœ6Ÿœ
˜:K˜5K˜—Kš
œ˜K˜—šžœŸœ
ŸœŸœ˜MKšŸœ™#KšŸœ0˜6Kš
œ˜K˜—šžœŸœ
Ÿœ9˜QK˜4šŸœŸœ
Ÿœ˜K˜.šŸœŸœ
ŸœŸœ
Ÿœ
 ˜IK˜F—K˜—K˜K˜—˜[K˜—šž
œŸœ
Ÿœ*ŸœŸœ
Ÿœ
Ÿœ˜YKšŸœ
ŸœŸœ
˜K˜!K˜KšŸœ6˜<K˜K˜—˜DK™—šž
œŸœ
Ÿœ*ŸœŸœ
Ÿœ
Ÿœ˜ZKšœŸœ
Ÿœ
Ÿœ˜/š
ŸœŸœ
Ÿœ
ŸœŸœŸœ
Ÿ˜;KšŸœŸœ,Ÿœ˜OKšŸœ
˜—KšŸœ	˜K˜K˜—šžœŸœ
ŸœŸœŸœŸœŸœŸœŸœŸœ˜“
Kš
œ:˜:šœŸœ˜K˜K˜	šœ	ŸœΟbœ˜&K˜Kšœ	Ÿœ
˜KšœŸœ
˜Kšœ
Ÿœ
˜K˜KšœŸœ
˜Kšœ
Ÿœ
˜K˜KšœŸœ
˜KšœŸœ˜——Kš
œ9˜9K˜K˜—šžœŸœ
ŸœŸœŸœ
Ÿœ
˜MKš
œ:˜:šŸœŸœ
Ÿ˜š
œ˜KšŸœŸœ
ŸœŸœ0Ÿœ
Ÿœ ˜›
šŸœ˜šŸœŸ˜'˜K™7K˜jK™K˜mK˜—K˜½
KšŸœ
˜—K˜—K˜—KšŸœ]˜d—Kš
œ9˜9K˜—K˜šžœŸ
œ˜1Kš
Ÿœ
Ÿœ
ŸœŸœŸœ
™+Kš
œ8™8KšœŸœ˜K˜#K˜K˜—šžœ!˜5KšŸœŸœŸœŸœ™$Kš
œ:™:šŸœŸœ
Ÿ˜KšœŸœ
˜%KšŸœŸœ˜—K˜—K˜šžœŸœ
ŸœŸœŸœŸœŸœŸœ˜dK™1šœŸœ˜K˜KšœŸœ˜
—K˜K˜—šžœŸœ
ŸœŸœŸœ
ŸœŸœ˜PšŸœŸœ
Ÿ˜KšœŸœ
˜%KšŸœc˜j—K˜—Lš
‘™K˜šžœŸœ
ŸœŸœ˜VK˜<K˜K˜—š
žœŸœ
ŸœŸœ	Ÿœ˜WK˜AK™.K˜K˜—šžœŸœŸœ
Ÿœ
ŸœŸœŸœŸœ˜Gš	ŸœŸœŸœŸœ
Ÿ˜2š
Ÿœ
Ÿœ
Ÿœ
ŸœŸœ˜#K˜CKšŸœ
Ÿœ˜K˜—KšŸœ
˜—K˜K˜—šžœŸœ˜Kš
œ9˜9K˜K˜—šžœŸœ
ŸœŸœŸœ
Ÿœ
Ÿœ˜^šŸœŸ˜'˜Kšœ
ŸœH˜YKšœŸœŸœ
Ÿœ˜5KšœŸœ
Ÿœ
Ÿœ
˜šŸœ
ŸœŸœŸœ˜"
forlistšŸœŸœ
Ÿœ
ŸœŸœŸœŸœ
Ÿ˜BKšŸœ
Ÿœ
Ÿœ
ŸœŸœ
Ÿœ
Ÿœ ˜EKšœŸœ"˜GKšŸœ
˜—K˜
—šŸœ˜šŸœ
ŸœŸœŸœŸœ
ŸœŸœ˜@KšŸœŸœ
˜—K˜—K˜—KšŸœŸœ
Ÿœ˜,—K˜K˜—šžœŸœ
Ÿœ
ŸœŸœ
Ÿœ
ŸœŸœŸœ
Ÿœ
Ÿœ˜nšŸœŸœ
Ÿœ˜Kš
Ÿœ
ŸœŸœ
Ÿœ
Ÿœ
˜#KšœŸœ	Ÿœ˜%KšŸœ
˜K˜
—šŸœ˜K˜KšœŸœ	Ÿœ˜K˜K˜—K˜K˜—šžœŸœ$ŸœŸœ˜`K™κ
šŸœ	Ÿœ
ŸœŸ˜.KšŸœ2˜6—K˜K˜—š
žœŸœ
Ÿœ	Ÿœ'Ÿœ˜zKšœ	Ÿœ
Ÿœ
Ÿœ
˜K˜KšŸœ Ÿœ&˜LKšŸœŸœ˜!K™KšœŸœŠ
™
Kš
œ(˜(Kš
œ˜K˜—šžœŸœ	Ÿœ#Ÿœ
Ÿœ
Ÿœ˜YKšœŸœŸœ
˜KšœŸœ
˜
KšœŸœ
˜K˜KšœŸœ
˜KšœŸœ
˜K˜K˜!K˜/šŸœ	Ÿœ
ŸœŸ˜KšŸœ4Ÿœ˜@K˜—šŸœŸœ
Ÿœ
ŸœŸœŸœ
Ÿœ
 ˜QK˜šŸœŸœ˜Kš
œ1˜1KšœŸœ
˜KšŸœ
˜K˜—K˜HšŸœŸœ =˜MKšœŸœ
˜šŸœŸœ
Ÿ˜˜šŸœŸœ
Ÿœ˜!K˜TKš
œ%˜%K˜
—šŸœ
ŸœŸœ
Ÿœ˜!K˜,K˜—K˜—šŸœ˜Kš
œe˜eKšŸœ
˜K˜——K˜
—šŸœ N˜UšŸœ	Ÿœ
ŸœŸ˜.KšŸœ2˜6—K˜;šŸœŸœ˜KšœŸœ
˜šŸœŸœ
Ÿ˜šœŸœ˜#šŸœŸ˜
KšŸœ#˜'KšŸœ˜—Kš
œ%˜%K˜—šŸœ˜Kš
œi˜iKšŸœ
˜K˜——K˜
—KšŸœX˜\K˜—KšŸœ
˜—K˜K˜—Kš	œ	Ÿœ
Ÿœ
ŸœŸœ
˜(Kš	œŸœ
Ÿœ
ŸœŸœ˜.Kš	œŸœ
Ÿœ
ŸœŸœ˜2šžœŸœŸœ˜@KšœŸœ
Ÿœ
Ÿœ
˜šŸœ	Ÿœ
Ÿ˜KšœŸœ
Ÿœ
Ÿœ˜*šŸœ˜KšŸœŸœ
Ÿœ˜-KšŸœ
ŸœŸœ˜8KšŸœ
ŸœŸœ˜<KšŸœŸœ
˜#K˜——Kš
œ*˜*K˜K˜—KšœŸœŸœ˜+šœŸœŸœ˜!KšœŸœ
˜KšœŸœ˜Kš
œ˜—KšœŸœŸœ
Ÿœ˜4KšœŸœŸœ˜5šœŸœŸœ˜&KšœŸœ
˜KšœŸ˜Kš
œ˜K˜—šžœŸœŸœŸœŸœŸœ˜|KšœŸœ˜K™;šŸœŸœ
Ÿœ+ŸœŸœ
Ÿ˜IKšœŸ˜KšœŸœ&Ÿœ'Ÿœ˜^šŸœŸœ˜K˜K˜K˜—KšŸœ
˜—K˜K˜—šžœŸœŸœ
Ÿœ
ŸœŸœŸœ˜3šžœŸœŸœŸœ
Ÿœ
ŸœŸœŸœ˜:š
ŸœŸœ
Ÿœ
ŸœŸœŸœ
Ÿ˜8KšŸœŸœ
Ÿœ
Ÿœ˜*KšŸœ
˜—KšŸœ
Ÿœ˜K˜—J™Tš
ŸœŸœ
Ÿœ
ŸœŸœ	Ÿœ
Ÿ˜;Kš
Ÿœ
ŸœŸœ
Ÿœ
Ÿœ˜3KšŸœ
˜—KšŸœ
Ÿœ˜
K˜K˜—š
žœŸœŸœŸœŸœ˜*KšŸœŸœ
Ÿœ
Ÿœ
˜KšŸœŸœ
Ÿœ
Ÿœ
˜0KšŸœ
Ÿœ
ŸœŸœ
Ÿœ
Ÿœ
˜0KšŸœ
Ÿœ
Ÿœ
Ÿœ
Ÿœ
Ÿœ
˜5KšŸœ
ŸœŸœŸœ
Ÿœ
Ÿœ
˜2KšŸœ
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ
˜0KšŸœ
Ÿœ
Ÿœ
Ÿœ
Ÿœ
Ÿœ
˜5KšŸœ
ŸœŸœŸœ
Ÿœ
Ÿœ
˜2KšŸœ
Ÿœ
Ÿœ˜K˜K˜—š
žœŸœŸœŸœ	Ÿœ	˜?K™΄
š	ŸœŸœ
ŸœŸœ
Ÿ˜/š	ŸœŸœ
ŸœŸœ
Ÿ˜/KšŸœŸœ˜4KšŸœ
˜—KšŸœ
˜—K˜K˜—šžœŸœŸœŸœ˜ZK™KšœŸœ
˜šŸœŸœ
˜(š
œ˜K˜OK˜—KšŸœŸœ
˜—KšŸœŸœ
Ÿœ
Ÿœ
Ÿœ +˜UšŸœŸœ
Ÿ˜š
œ˜K˜
šŸœŸœ
Ÿœ˜K˜-Kš
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ˜&K˜—K˜—šŸœ˜Kš
œ`˜`KšŸœ
Ÿœ˜K˜——K˜K˜—Kšœ	Ÿœ
ŸœŸœ
Ÿœ
Ÿœ˜%šžœŸœ
ŸœŸœ˜T
blockš
œ4™4Iitemš
œœ
™œ
Oš
œ«
™«
—K˜KšœŸœ
Ÿœ
Ÿœ
˜K˜Kš
œ6˜6K˜'KšŸœ	Ÿœ
Ÿœ
Ÿœ
˜K˜Kšœ
’œ˜;šŸœŸœ
ŸœŸœ
ŸœŸœŸœ
Ÿ
˜PKš
œ5˜5KšŸœ
˜K˜—Kš
œ6˜6Kš
œ5˜5Kš
œ˜K˜—Kšœ	Ÿœ˜ K˜6K˜šžœŸœ
ŸœŸœŸœ
Ÿœ˜OšŸœ)Ÿœ
Ÿœ
˜4KšŸœQ˜W—K˜KšŸœ
Ÿœ˜
Kš
œ˜K˜—šž
œŸœ
Ÿœ(ŸœŸœŸœ˜bKšŸœŸœ
Ÿœ/˜UK˜—KšœŸœ"˜6Lš
‘™K˜šžœŸœ
ŸœŸœ%ŸœŸœ˜hKš
œ:˜:K˜K˜—š
žœŸœŸœŸœ
Ÿœ˜WKšŸœU˜[K˜K˜—šžœŸœ
Ÿœ
Ÿœ
Ÿœ
Ÿœ)Ÿœ
Ÿœ
Ÿœ˜iKš	œŸœ
Ÿœ
ŸœŸœ$˜AKš
œ6˜6Kš
œH˜HKš
œ?˜?šŸœ
ŸœŸœ
Ÿœ
ŸœŸœ˜+š
ŸœŸœ
Ÿœ
ŸœŸœŸœ
Ÿ˜4šŸœ	Ÿœ
Ÿ˜šœŸœ
Ÿœ
Ÿœ˜Kšœ	Ÿœ’œ3˜UKšŸœŸœ
Ÿœ’œ˜AK˜—KšŸœD˜K—KšŸœ
˜—K˜
—šŸœ˜K™‹
Kšœ	Ÿœ’œ5˜WKšŸœŸœ
Ÿœ’œ˜AK˜—Kš
œ5˜5K˜K˜—š
žœŸœ
Ÿœ$ŸœŸœ˜]šŸœŸœ˜K˜.KšœŸœ#˜4š
Ÿœ	Ÿœ
ŸœŸœ
Ÿœ˜.Kšœ	Ÿœ’œ"˜@KšŸœ	Ÿœ!˜0K˜—K˜
—šŸœ˜KšœŸœ&˜KKšŸœŸœ
Ÿœ
Ÿ˜"šŸœ˜K˜DšŸœŸœ
Ÿœ˜KšœŸœ™
˜‘
K˜
—šŸœ˜K˜Kš
œ9˜9K˜—K˜—K˜—K˜—K˜Lš
‘™KšœŸœ˜.KšœŸœ(˜BK˜šžœŸœ
ŸœŸœŸœŸœŸœŸœ˜š
KšœŸœŸœŸœ
Ÿœ
Ÿœ
Ÿœ
Ÿœ˜_K˜šœŸœ˜3Kš
œ˜Kš
œ!˜!Kš
œ˜K˜—K˜8Kš
œ˜K˜—šžœŸœ
Ÿœ'˜UKšœŸœŸœŸœ
Ÿœ
Ÿœ
Ÿœ
Ÿœ$˜}K˜K˜JK˜K˜—šžœŸœ
ŸœŸœŸœŸœŸœ
Ÿœ˜fK™Ξ
šžœ$˜2KšŸœ'ŸœŸœŸœ
™HK˜KšœŸœ
˜Kšœ
Ÿ˜KšœŸœŸœ
˜K˜Kšœ’œ˜*šŸœŸœŸœ˜$Kšœ’
œ ˜TKšœ’œ ,˜XK˜—K˜—KšœŸœŸœ
˜šŸœŸœ˜K˜9K˜—KšŸœŸœ
Ÿœ4˜EK˜K˜—š
ž
œŸœ
ŸœŸœŸœ˜LKšœŸœŸœ
˜K˜-KšŸœ
ŸœŸœŸœ
˜K˜K˜—šžœŸœŸœŸœ
ŸœŸœ˜]šŸœŸœ
Ÿœ˜šŸœ Ÿœ˜(K˜Kšœ	Ÿœ
˜K˜
—šŸœ˜Kšœ	Ÿœ’
œ
˜*šŸœ	Ÿœ˜Kšœ
Ÿœ#˜1Kšœ	ŸœŸœ
Ÿœ˜6šŸœŸœ
Ÿœ˜šŸœ
Ÿœ
ŸœŸœ˜KšœŸœ
˜Kšœ	Ÿœ
˜Kšœ!Ÿœ
˜&K˜K˜
—KšŸœ(˜,K˜—K˜—K˜—K˜—K˜K˜—šžœŸœ
Ÿœ$ŸœŸœ	ŸœŸœ˜lšŸœŸœ˜K˜.KšœŸœ#˜4š
Ÿœ	Ÿœ
ŸœŸœ
Ÿœ
˜-K˜1—K˜
—šŸœ˜KšœŸœ&˜KKš
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ
˜'šŸœ˜K˜DšŸœŸœ
Ÿœ˜KšœŸœ
˜KšœŸœ™
˜‘
K˜
—KšŸœ˜K˜—K˜—K˜K˜—šžœŸœ
ŸœŸœŸœŸœ˜Yšžœ˜-Kšœ
Ÿœ
˜KšœŸœŸœ
˜K˜K˜*šŸœŸœŸœ˜$Kšœ5 "˜WKšŸœŸœ
Ÿœ
Ÿœ
˜ Kš’œ˜*K˜—Kš
œ˜—K˜3K˜—Lš
‘™šžœŸœ(ŸœŸœ˜hKšœŸœ6˜?šŸœŸœ
Ÿœ˜K˜…
Kšœ
Ÿœ
˜K˜
—šŸœ˜šŸœŸœ
Ÿ˜K˜ šœŸœ˜Kšœ
Ÿœ˜+Kšœ?Ÿœ˜FK˜—šŸœ˜Kš
œk˜kKšœ
Ÿœ
˜K˜——K˜—K˜K˜—šž
œŸœ(Ÿœ˜_Kš
œ5˜5K˜+šŸœŸœ
Ÿœ˜Kšœ	ŸœŸœ
˜K˜K˜K˜(KšŸœ
Ÿœ	ŸœŸœ
˜%K˜—Kš
œ4˜4K˜K˜—šžœŸœ(ŸœŸœ
ŸœŸœ˜cKšœ’œ (˜`šŸœŸœ
Ÿœ˜šŸœ Ÿœ˜(K˜Kšœ	Ÿœ
˜K˜
—šŸœ˜Kšœ	Ÿœ’
œ
˜*šŸœ	Ÿœ˜Kšœ
Ÿœ#˜1Kšœ	ŸœŸœ
Ÿœ˜6šŸœŸœ
Ÿœ˜šŸœ
Ÿœ
ŸœŸœ˜KšœŸœ
˜Kšœ	Ÿœ
˜Kšœ!Ÿœ
˜&K˜K˜
—KšŸœ(˜,K˜—K˜—K˜—K˜—K˜K˜—š
žœŸœ
ŸœŸœŸœ˜aK˜'Kš
œ˜K˜—šžœŸœŸœŸœ˜EK˜K˜—K˜š
žœŸœŸœŸœŸœ˜VK™JK˜@K˜K™—š
žœŸœŸœŸœŸœ˜VKš
œJ™JK˜@K˜K™—š
žœŸœŸœŸœŸœ˜SKš
œI™IK˜=K˜—K˜šžœŸœŸœŸœ˜MK™JKš
œY˜YK˜K™—šžœŸœŸœŸœ˜MKš
œJ™JKš
œY˜YK˜K™—šžœŸœŸœŸœ˜JKš
œI™IKš
œW˜WK˜—K˜šžœŸœ
ŸœŸœŸœŸœŸœ˜WKšœŸœO˜UKšŸœŸœ
Ÿœ
Ÿœ
˜šŸœŸœ
Ÿ˜KšœŸœ
˜KšŸœJ˜Q—K˜K˜—šžœŸœ
ŸœŸœŸœ"Ÿœ˜VKš
œZ˜ZK˜K˜—šžœŸœ
ŸœŸœŸœŸœ˜QKšœŸœO˜UKšŸœŸœ
Ÿœ
Ÿœ
˜šŸœŸœ
Ÿ˜KšœŸœ
˜KšŸœI˜P—K˜K˜—šžœŸœ
ŸœŸœŸœ"Ÿœ˜VKš
œZ˜ZK˜K˜—šžœŸœ
ŸœŸœŸœŸœ˜NK˜RK˜K˜—šžœŸœ
ŸœŸœŸœ"Ÿœ˜SKš
œY˜YK˜K˜—š
žœŸœ
ŸœŸœŸœ˜FK˜OK˜K™—š
ž
œŸœ
ŸœŸœŸœ˜IK˜?K˜K™—Lš
‘™šžœŸœŸœŸœŸœŸœ˜NKšœŸœ
Ÿ˜
Kš
œ:˜:KšœŸœ
Ÿœ˜K˜!Kš
œ9˜9K˜K˜—šžœŸœŸœ
ŸœŸœŸœŸœ˜ZKšœŸœ
˜Kš
œ˜Kš
œ˜KšœŸœ
˜KšœŸœŸœ˜ K˜K˜K˜šŸœŸœŸœ˜!K˜UKšŸœ
˜K˜—K˜!š
Ÿœ
Ÿœ
Ÿœ	ŸœŸœ˜)K˜@KšŸœ
˜K˜—K˜KšœŸœ
Ÿœ˜K˜K˜šŸœŸœŸœŸœŸœ
Ÿ˜<KšœŸœ
˜šŸœ
Ÿœ
Ÿœ
Ÿœ
Ÿœ
ŸœŸœ˜*K˜QKšŸœ
˜K˜—KšœŸœ
˜šŸœ
Ÿœ
ŸœŸœŸœ
Ÿœ
ŸœŸœŸœ˜PK˜:KšŸœ
˜K˜—š
Ÿœ
Ÿœ
ŸœŸœŸœ˜3K˜;KšŸœ
˜K˜—šœŸœ
Ÿœ˜.KšœŸœ
ŸœŸœŸœ
ŸœŸœ
Ÿœ˜TKšœŸœ˜$—K˜KšŸœ
˜—K˜K˜K˜K˜—š
žœŸœŸœŸœŸœ˜SšŸœ"Ÿœ˜*Kš
œ>˜>Kšœ
Ÿœ
˜šŸœ#Ÿœ
Ÿœ˜/šœ"’$œ
˜GKš
œ˜Kš
œ'˜'Kš
œ5˜5—K˜—Kš
œ=˜=K˜
—šŸœ˜Kš
œ9˜9Kšœ
’œ
˜%KšŸœ
Ÿœ	Ÿœ;Ÿœ˜VšŸœ#Ÿœ
Ÿœ˜/šœ"’$œ
˜GKš
œ˜Kš
œ'˜'Kš
œ5˜5—K˜—Kš
œ8˜8K˜—K˜K˜—š
ž
œŸœŸœŸœŸœ˜OKš
œ
™
K™'K™LKšœŸœ
˜KšœŸœ
˜KšœŸœ
Ÿ˜KšœŸ˜K™Kš	ŸœŸœ
Ÿœ
Ÿœ ˜DK˜Kš
œ5˜5Kšœ	Ÿœ
Ÿœ˜)K˜,š
Ÿ˜šŸœ
Ÿœ$Ÿœ˜0Kš
œ>˜>Kš
œ4˜4KšŸœ
Ÿœ˜K˜—K˜%K˜'KšœD’œ	˜aK˜NK˜1Kš’œ
’
œ#˜>KšŸœŸœ
Ÿœ
Ÿœ
˜8Kš’!œ
’
Πbk’
˜)š
Ÿ˜˜šŸœ
Ÿœ"Ÿœ˜.Kš
œ‘
˜‘
Kšœ#Ÿœ
˜(K˜—Kš
œ4˜4KšŸœ
Ÿœ˜K˜——KšŸœ
˜—Kš
œ4˜4K˜K˜—š
žœŸœŸœŸœŸœ˜PKš
œ|™|K™'K™LK™KšŸœ"Ÿœ
Ÿœ  ˜QK˜Kš
œ6˜6šŸœŸœ
Ÿœ )˜RKšœŸœ
˜KšœŸœ
˜Kš	œŸœ
ŸœŸœ
Ÿœ˜4KšœŸœ ˜2š
Ÿ˜šŸœ
Ÿœ$Ÿœ˜0Kš
œ>˜>Kš
œ5˜5KšŸœ
Ÿœ˜K˜—K˜%K˜'KšœD’
œ	˜WK˜NK˜1Kš’œ
’
œ#˜>KšŸœŸœ
Ÿœ
Ÿœ
˜8š
Ÿ˜˜šŸœ
Ÿœ"Ÿœ˜.Kš
œ‘
˜‘
Kšœ#Ÿœ
˜(K˜—Kš
œ5˜5KšŸœ
Ÿœ˜K˜——KšŸœ
˜—K˜
—šŸœ˜K™+Kš
œ=˜=K˜—Kš’!œ
’
£’
˜(Kš
œ5˜5K˜K˜—š
žœŸœŸœŸœŸœ˜\KšœŸœ
˜KšœŸœ
Ÿœ
˜K˜7šŸœ
Ÿœ
ŸœŸœ˜$Kš
œ]˜]KšŸœ
˜K˜—KšœŸœ˜K˜K˜—šžœŸœ˜=K™^KšœŸœ
˜"Kšœ`Ÿœ˜fK˜—Lš
‘™K˜)K˜4Kš
œA˜AK˜EJ™KšŸœ
˜K˜™eK™K™4K™K™EK™+K™UK™(K™K™I™K™K™K™—K™7K™0K™;K™$K™-K™(K™IK™K™7K™7K™K˜K˜—K˜—…—}άΊ