DIRECTORY 
Atom,
RefTab,
UnsafePropList,
Xl,
XlCursor,
XlUtils,
XTk,
XTkDB,
XTkFastAccessPrivate,
XTkFriends,
XTkOps,
XTkPrivate;

XTkImpl: CEDAR MONITOR 
LOCKS widget USING widget: Widget
IMPORTS RefTab, UnsafePropList, Xl, XlCursor, XlUtils, XTk, XTkDB, XTkFastAccessPrivate
EXPORTS XTk, XTkFriends, XTkOps, XTkPrivate =
BEGIN OPEN Xl, XTk, XTkFriends;

detailsForSynchronous: PUBLIC Xl.Details ¬ NEW[Xl.DetailsRec ¬ [synchronous: TRUE, localErrors: inline]];
detailsForFlushNoErrors: PUBLIC Xl.Details ¬ NEW[Xl.DetailsRec ¬ [flush: now, errorMatch: NEW[Xl.MatchRep ¬ [proc: IgnoreErrors, handles: NIL, tq: Xl.CreateTQ[]]]]];
detailsForFlushSoonNoErrors: PUBLIC Xl.Details ¬ NEW[Xl.DetailsRec ¬ [flush: soon, errorMatch: NEW[Xl.MatchRep ¬ [proc: IgnoreErrors, handles: NIL, tq: Xl.CreateTQ[]]]]];
detailsForNoErrors: PUBLIC Xl.Details ¬ NEW[Xl.DetailsRec ¬ [errorMatch: NEW[Xl.MatchRep ¬ [proc: IgnoreErrors, handles: NIL, tq: Xl.CreateTQ[]]]]];

debugErrCount: CARD ¬ 0;
IgnoreErrors: Xl.EventProcType = {debugErrCount ¬ debugErrCount+1};

classTable: RefTab.Ref ¬ RefTab.Create[];
aliasTable: RefTab.Ref ¬ RefTab.Create[]; --key: "alias" val: "key"
keyTable: RefTab.Ref ¬ RefTab.Create[]; --key: "key" val: not importasnt

XTkBadAlias: SIGNAL = CODE;

AliasNotifierKey: PUBLIC PROC [key: REF, alias: REF ¬ NIL] = {
IF alias=NIL THEN alias ¬ key; 
IF RefTab.Fetch[keyTable, alias].found THEN { 
IF alias#key THEN SIGNAL XTkBadAlias; --this aliases is somebody elses key
};
IF ~RefTab.Insert[aliasTable, alias, key] THEN {
IF RefTab.Fetch[aliasTable, alias].val#key THEN 
SIGNAL XTkBadAlias; --definition has changed
};
[] ¬ RefTab.Store[keyTable, key, key]; --keys can have many aliases
};
AllNotifiers: TYPE = LIST OF NotifierHead;
NotifierHead: TYPE = RECORD [key: REF, list: NotifierList];
NotifierList: TYPE = LIST OF NofierRec;
NofierRec: TYPE = RECORD [proc: WidgetNotifyProc, registerData: REF ¬ NIL];

CallNotifierList: PROC [list: NotifierList, widget: Widget, callData: REF ¬ NIL, event: Event ¬ NIL] = {
FOR l: NotifierList ¬ list, l.rest WHILE l#NIL DO
l.first.proc[widget: widget, registerData: l.first.registerData, callData: callData, event: event];
ENDLOOP
};

CallNotifiers: PUBLIC PROC [widget: Widget, key: REF, callData: REF ¬ NIL, event: Event ¬ NIL] = {
FOR al: AllNotifiers ¬ NARROW[widget.notifiers], al.rest WHILE al#NIL DO
IF al.first.key=key THEN {
CallNotifierList[al.first.list, widget, callData, event];
RETURN;
};
ENDLOOP;
}; 

RemoveNotifiers: PUBLIC PROC [widget: Widget, key: REF] = {
[] ¬ GetNRemoveNotifiers[widget, key];
}; 

GetNRemoveNotifiers: ENTRY PROC [widget: Widget, key: REF] RETURNS [notifiers: NotifierList ¬ NIL] = {
head: AllNotifiers ¬ NARROW[widget.notifiers];
IF head#NIL THEN {
IF head.first.key=key THEN {
notifiers ¬ head.first.list; 
widget.notifiers ¬ head.rest; 
RETURN
};
WHILE head.rest#NIL DO
IF head.rest.first.key=key THEN {
notifiers ¬ head.rest.first.list; 
head.rest ¬ head.rest.rest; 
RETURN
};
head ¬ head.rest
ENDLOOP
};
};

UnregisterFromSingleList: INTERNAL PROC [list: NotifierList, proc: WidgetNotifyProc, registerData: REF ¬ NIL] RETURNS [NotifierList] = {
WHILE list#NIL AND list.first.proc=proc AND list.first.registerData=registerData DO
list _ list.rest
ENDLOOP;
IF list#NIL THEN {
lag: NotifierList _ list;
WHILE lag#NIL AND lag.rest#NIL DO
IF lag.rest.first.proc=proc AND lag.rest.first.registerData=registerData 
THEN {lag.rest _ lag.rest.rest}
ELSE {lag _ lag.rest};
ENDLOOP; 
};
RETURN [list]
};

InternalRegisterNotifier: INTERNAL PROC [widget: Widget, real: REF, proc: WidgetNotifyProc, registerData: REF ¬ NIL] = {
head: AllNotifiers ¬ NARROW[widget.notifiers];
this: AllNotifiers ¬ NIL;
FOR al: AllNotifiers ¬ head, al.rest WHILE al#NIL DO
IF al.first.key=real THEN {this ¬ al; EXIT};
ENDLOOP;
IF this=NIL THEN {
this ¬ CONS[NotifierHead[key: real, list: NIL], head]; 
widget.notifiers ¬ this
};
this.first.list ¬ CONS[[proc, registerData], this.first.list]
};

RegisterNotifier: PUBLIC PROC [widget: Widget, key: REF, procLX: WidgetNotifyProc, registerData: REF ¬ NIL] = {
EntryRegisterNotifier: ENTRY PROC [widget: Widget, real: REF, proc: WidgetNotifyProc, registerData: REF] = {
InternalRegisterNotifier[widget, real, proc, registerData];
};
p: WidgetNotifyProc ¬ procLX; --checks globality
real: REF ¬ RefTab.Fetch[aliasTable, key].val; 
IF real=NIL THEN real ¬ key;
EntryRegisterNotifier[widget, real, p, registerData];
};

UnRegisterNotifier: PUBLIC PROC [widget: Widget, key: REF, procLX: WidgetNotifyProc, registerData: REF ¬ NIL] = {
EntryUnRegisterNotifier: ENTRY PROC [widget: Widget, real: REF, proc: WidgetNotifyProc, registerData: REF] = {
head: AllNotifiers ¬ NARROW[widget.notifiers];
this: AllNotifiers ¬ NIL;
FOR al: AllNotifiers ¬ head, al.rest WHILE al#NIL DO
IF al.first.key=real THEN {this ¬ al; EXIT};
ENDLOOP;
IF this#NIL AND this.first.list#NIL THEN 
this.first.list _ UnregisterFromSingleList[this.first.list, proc, registerData];
};
p: WidgetNotifyProc ¬ procLX; --checks globality
real: REF ¬ RefTab.Fetch[aliasTable, key].val; 
IF real=NIL THEN real ¬ key;
EntryUnRegisterNotifier[widget, real, p, registerData];
};

CallAndRegisterOnPostRealize: PUBLIC <<XTkOps>> PROC [widget: Widget, proc: WidgetNotifyProc, registerData: REF ¬ NIL] = {
p: WidgetNotifyProc ¬ proc; --checks globality
MustCall: ENTRY PROC [widget: Widget, proc: WidgetNotifyProc, registerData: REF] RETURNS [mustCall: BOOL] = {
mustCall ¬ widget.state=realized;
InternalRegisterNotifier[widget, postWindowCreationLRReal, p, registerData]
};
IF widget.state>=dead THEN RETURN;
IF MustCall[widget, proc, registerData] THEN p[widget, registerData];
};

NewNotifyKey: PROC [a: ATOM] RETURNS [key: REF ATOM] = {
key ¬ NEW[ATOM¬a];
AliasNotifierKey[key: key, alias: a];
};

preWindowCreationLRKey: PUBLIC ATOM ¬ $preWindowCreation; 
preWindowCreationKey: PUBLIC ATOM ¬ $preWindowCreation; 

postWindowCreationLRKey: PUBLIC ATOM ¬ $postWindowCreation; 
postWindowCreationKey: PUBLIC ATOM ¬ $postWindowCreation; 

postConfigureLRKey: PUBLIC ATOM ¬ $postConfigure;  
postConfigureKey: PUBLIC ATOM ¬ $postConfigure;  

postWindowDestructionLRKey: PUBLIC ATOM ¬ $postWindowDestruction;
postWindowDestructionKey: PUBLIC ATOM ¬ $postWindowDestruction;
preStopFastAccessKey: PUBLIC ATOM ¬ $preStopFastAccess;  

postStopFastAccessLRKey: PUBLIC ATOM ¬ $postStopFastAccess;  
postStopFastAccessKey: PUBLIC ATOM ¬ $postStopFastAccess;  

bindScreenLRKey: PUBLIC ATOM ¬ $bindScreen;
bindScreenKey: PUBLIC ATOM ¬ $bindScreen;
forgetScreenLRKey: PUBLIC ATOM ¬ $forgetScreen;  
forgetScreenKey: PUBLIC ATOM ¬ $forgetScreen;  
postWidgetDestructionKey: PUBLIC ATOM ¬ $postWidgetDestruction;  

preWindowCreationLRReal: REF ATOM ¬ NewNotifyKey[preWindowCreationLRKey]; 
postWindowCreationLRReal: REF ATOM ¬ NewNotifyKey[postWindowCreationLRKey]; 
postConfigureLRReal: REF ATOM ¬ NewNotifyKey[postConfigureLRKey]; 
postWindowDestructionLRReal: REF ATOM ¬ NewNotifyKey[postWindowDestructionLRKey]; 
preStopFastAccessReal: REF ATOM ¬ NewNotifyKey[preStopFastAccessKey];  
postStopFastAccessLRReal: REF ATOM ¬ NewNotifyKey[postStopFastAccessLRKey];  
forgetScreenLRReal: REF ATOM ¬ NewNotifyKey[forgetScreenLRKey]; 
bindScreenLRReal: REF ATOM ¬ NewNotifyKey[bindScreenLRKey]; 
postWidgetDestructionReal: REF ATOM ¬ NewNotifyKey[postWidgetDestructionKey]; 

AddPermanentMatch: PUBLIC PROC [widget: Widget, matchRep: MatchRep, generate: SetOfEvent] = {
EntryPart: ENTRY PROC [widget: Widget, matchRep: MatchRep, generate: SetOfEvent] RETURNS [realized: BOOL] = {
widget.attributes.eventMask ¬ Xl.ORSetOfEvents[widget.attributes.eventMask, generate];
widget.matchListX ¬ CONS[matchRep, widget.matchListX];
realized ¬ widget.state=realized AND widget.window#Xl.nullWindow AND widget.actualMapping<unconfigured; --Oops, inside a configure proc state may be realized but window not yet generated
};
realized: BOOL ¬ EntryPart[widget, matchRep, generate];
IF realized AND widget.fastAccessAllowed=ok THEN {
match: Xl.Match ¬ NEW[MatchRep ¬ matchRep];
IF match.tq=NIL THEN match.tq ¬ widget.rootTQ;
Xl.AddDispatch[widget.connection, widget.window, match, generate];  
}
};

AddTemporaryMatch: PUBLIC PROC [widget: Widget, matchRep: MatchRep, generate: SetOfEvent] = {
EntryPart: ENTRY PROC [widget: Widget, match: Xl.Match, generate: SetOfEvent] RETURNS [realized: BOOL] = {
widget.attributes.eventMask ¬ Xl.ORSetOfEvents[widget.attributes.eventMask, generate];
widget.matchList1 ¬ CONS[match, widget.matchList1];
realized ¬ widget.state=realized AND widget.window#Xl.nullWindow AND widget.actualMapping<unconfigured; --Oops, inside a configure proc state may be realized but window not yet generated
};
match0: Xl.Match ¬ NEW[MatchRep ¬ matchRep];
realized: BOOL ¬ EntryPart[widget, match0, generate];
IF realized AND widget.fastAccessAllowed=ok THEN {
match: Xl.Match ¬ NEW[MatchRep ¬ matchRep];
IF match.tq=NIL THEN match.tq ¬ widget.rootTQ;
Xl.AddDispatch[widget.connection, widget.window, match, generate];
}
};

PleaseResizeChild: PUBLIC WidgetNChildProc = {
widget.s.class.pleaseResizeChild[widget, child];
};

gAllTrue: GeometryRequest = ALL[TRUE];

PreferredSizeLR: PUBLIC PreferredSizeProc = {
IF maySkip=gAllTrue THEN RETURN [widget.actual];
IF ~IScreenBound[widget] THEN ERROR;
IF widget.state=realized AND GetWidgetFlag[widget, preferredSizeCurrent] THEN {
IF widget.s.geometry.pos.x>=0 THEN {maySkip[x] ¬ TRUE; proposed.pos.x ¬ widget.s.geometry.pos.x};
IF widget.s.geometry.pos.y>=0 THEN {maySkip[y] ¬ TRUE; proposed.pos.y ¬ widget.s.geometry.pos.y};
IF widget.s.geometry.size.width>0 THEN {maySkip[w] ¬ TRUE; proposed.size.width ¬ widget.s.geometry.size.width};
IF widget.s.geometry.size.height>0 THEN {maySkip[h] ¬ TRUE; proposed.size.height ¬ widget.s.geometry.size.height};
IF widget.s.geometry.borderWidth>0 THEN {maySkip[b] ¬ TRUE; proposed.borderWidth ¬ widget.s.geometry.borderWidth};
IF maySkip=gAllTrue THEN RETURN [proposed];
};
IF widget.state>realized AND GetWidgetFlag[widget, preferredSizeFromDB] THEN {
IF maySkip[x] AND maySkip[y] AND maySkip[b] 
THEN preferred.size ¬ XTkDB.GetSizeFromDB[widget]
ELSE preferred ¬ XTkDB.GetGeometryFromDB[widget];
IF preferred.pos.x>=0 THEN {maySkip[x] ¬ TRUE; proposed.pos.x ¬ preferred.pos.x};
IF preferred.pos.y>=0 THEN {maySkip[y] ¬ TRUE; proposed.pos.y ¬ preferred.pos.y};
IF preferred.size.width>0 THEN {maySkip[w] ¬ TRUE; proposed.size.width ¬ preferred.size.width};
IF preferred.size.height>0 THEN {maySkip[h] ¬ TRUE; proposed.size.height ¬ preferred.size.height};
IF preferred.borderWidth>=0 THEN {maySkip[b] ¬ TRUE; proposed.borderWidth ¬ preferred.borderWidth};
IF maySkip=gAllTrue THEN RETURN [proposed];
};
preferred ¬ widget.s.class.preferredSizeLR[widget, mode, proposed, maySkip];
};

PreStopFastAccess: PUBLIC TerminateProc = {
Recurse: EachChild = {PreStopFastAccess[child, reason]};
IF widget.fastAccessAllowed=ok THEN {
parent: Widget ¬ widget.parent;
widget.fastAccessAllowed ¬ warned;
CallNotifiers[widget, preStopFastAccessReal, IF reason=normal THEN $normal ELSE $error]; 
FOR class: Class ¬ widget.s.class, class.super WHILE class#NIL DO
IF class.preStopFastAccess#NIL THEN class.preStopFastAccess[widget, reason];
ENDLOOP;
ShallowInternalEnumerateChildren[widget, Recurse];
};
};

FullStopFastAccessRecurseLR: PROC [w: Widget, protectPaintTQ: PROC [TQ], reason: TerminationReason] = {
Recurse: EachChild = { FullStopFastAccessRecurseLR[child, protectPaintTQ, reason] };
IF w.state>=warned THEN RETURN;
IF w.fastAccessAllowed=ok THEN PreStopFastAccess[w, reason];
w.state ¬ warned;
FOR class: Class ¬ w.s.class, class.super WHILE class#NIL DO
IF class.fullStopFastAccessLR#NIL THEN 
class.fullStopFastAccessLR[w, protectPaintTQ, reason];
ENDLOOP;
ShallowInternalEnumerateChildren[w, Recurse];
FOR list: LIST OF TQ ¬ GetNRemoveSyncsFastAccess[w], list.rest WHILE list#NIL DO
protectPaintTQ[list.first];
ENDLOOP;
}; 

synchFastAccessKey: REF INT ~ NEW[INT];
SynchronizeFastAccess: PUBLIC ENTRY PROC [widget: Widget, protectTQ: TQ] = TRUSTED {
IF protectTQ#NIL THEN {
WITH UnsafePropList.GetProp[@widget.props, synchFastAccessKey] SELECT FROM
lst: LIST OF TQ => {
list: LIST OF TQ ¬ CONS[protectTQ, lst];
[] ¬ UnsafePropList.PutProp[LOOPHOLE[@widget.props], synchFastAccessKey, list];
}
ENDCASE => {
UnsafePropList.TrustedAddNewProp[LOOPHOLE[@widget.props], synchFastAccessKey, LIST[protectTQ]];
};
};
};
 
GetNRemoveSyncsFastAccess: ENTRY PROC [widget: Widget] RETURNS [LIST OF TQ ¬ NIL] = TRUSTED {
old: REF ~ UnsafePropList.RemProp[LOOPHOLE[@widget.props], synchFastAccessKey];
WITH old SELECT FROM
lst: LIST OF TQ => RETURN [lst];
ENDCASE => {}
};

FullStopFastAccessLR: PUBLIC PROC [w: Widget, reason: TerminationReason] = {
tqSet: XTkFastAccessPrivate.TQSet ¬ NIL;
MyQueueTQ: PROC [waitTQ: TQ] = {
IF waitTQ#NIL AND waitTQ#w.rootTQ THEN
tqSet ¬ XTkFastAccessPrivate.Include[tqSet, waitTQ]
};
IF w.state>=warned THEN RETURN;
FullStopFastAccessRecurseLR[w, MyQueueTQ, reason];
IF tqSet#NIL THEN XTkFastAccessPrivate.Synchronize[tqSet];
CallNotifiers[w, postStopFastAccessLRReal, $normal]; 
};

DestroyWidgetLR: PUBLIC PROC [widget: Widget] = {
DestroyChild: XTk.EachChild = {
IF child.state<dead THEN {
OrphanizeLR[child, errorWindow]
};
};
IF widget.state<dead THEN {
parent: Widget ¬ widget.parent;
IF IScreenBound[widget] THEN ForgetScreenLR[widget];
widget.state ¬ dead;
IF parent#NIL AND parent.state<dead THEN [] ¬ RemoveChildLR[parent, widget];
FOR class: Class ¬ widget.s.class, class.super WHILE class#NIL DO
IF class.destroyWidget#NIL THEN class.destroyWidget[widget];
ENDLOOP;
ShallowInternalEnumerateChildren[widget, DestroyChild];
CallNotifiers[widget, postWidgetDestructionReal];
widget.matchList1 ¬ NIL;
widget.matchListX ¬ NIL;
widget.parent ¬ NIL;
widget.notifiers ¬ NIL;
TRUSTED {
IF widget.props#NIL THEN UnsafePropList.NiloutPropList[LOOPHOLE[@widget.props]];
};
};
};

RemoveChildLR: PUBLIC PROC [widget: Widget, child: Widget] RETURNS [done: BOOL ¬ FALSE] = {
IF widget.state<dead AND child#NIL THEN {
FOR class: Class ¬ widget.s.class, class.super WHILE class#NIL DO
IF class.removeChildLR#NIL THEN {
IF class.removeChildLR[widget, child] THEN {
done ¬ TRUE; 
NoteChildChange[widget];
EXIT
}
}
ENDLOOP;
};
};

NoteChildChange: PUBLIC ENTRY PROC [widget: Widget] = {
widget.flags[mustReConsiderChildren] ¬ TRUE
};

SetWidgetFlag: PUBLIC ENTRY PROC [widget: Widget, key: WidgetFlagKey, value: BOOL ¬ TRUE] = {
widget.flags[key] ¬ value
};

dummyWidgetForLock: Widget ~ NEW[WidgetRep];

SetClassFlag: PUBLIC PROC [class: ImplementorClass, key: ClassFlagKey, value: BOOL ¬ TRUE] = {
EntryDo: ENTRY PROC [widget: Widget, class: ImplementorClass, key: ClassFlagKey, value: BOOL ¬ TRUE] = {
class.flags[key] ¬ value
};
IF class#NIL THEN EntryDo[dummyWidgetForLock, class, key, value];
};
 
PutWidgetProp: PUBLIC PROC [widget: Widget, key: REF, value: REF ¬ NIL] = TRUSTED {
[] ¬ UnsafePropList.PutProp[LOOPHOLE[@widget.props], key, value];
};

GetWidgetProp: PUBLIC PROC [widget: Widget, key: REF] RETURNS [REF] = TRUSTED {
RETURN [UnsafePropList.GetProp[LOOPHOLE[@widget.props], key]]
};

HasSubClass: PUBLIC PROC [widget: Widget, class: Class] RETURNS [BOOL ¬ FALSE] = {
FOR super: Class ¬ widget.s.class.super, super.super WHILE super # NIL DO
IF super=class THEN RETURN [TRUE];
ENDLOOP;
};

HasSubClassKey: PUBLIC PROC [widget: Widget, classKey: ATOM] RETURNS [BOOL ¬ FALSE] = {
FOR super: Class ¬ widget.s.class.super, super.super WHILE super # NIL DO
IF super.key = classKey THEN RETURN [TRUE];
ENDLOOP;
};
 
RootWidget: PUBLIC PROC [widget: Widget] RETURNS [Widget] = {
WHILE widget.parent#NIL DO widget ¬ widget.parent ENDLOOP;
RETURN [widget];
};

BorderWidth: PUBLIC PROC [w: Widget] RETURNS [bw: INT] = {
bw ¬ w.s.geometry.borderWidth;
IF bw<0 THEN {
p: Widget ~ w.parent;
IF p=NIL THEN bw ¬ 0 ELSE bw ¬ BorderWidth[p]
};
};

CreateClass: PUBLIC PROC [basicMethods: BasicMethodsRec ¬ []] RETURNS [class: ImplementorClass] = {
CallSubCreateClass: PROC [superClass: Class, newClass: ImplementorClass] = {
IF superClass.super#NIL THEN 
CallSubCreateClass[superClass.super, newClass];
IF superClass.createSubClass#NIL THEN 
superClass.createSubClass[superClass, newClass, newClass=superClass];
};
sup: Class ¬ IF basicMethods.super=NIL 
THEN defaultSuper --used for default procedure values but not for chaining
ELSE basicMethods.super; 
cDataIdx: NAT ¬ sup.cDataIdx+sup.cDataNum;
IF basicMethods.configureLR = NIL THEN 
basicMethods.configureLR ¬ sup.configureLR;
IF basicMethods.actualCreateWindowLR = NIL THEN 
basicMethods.actualCreateWindowLR ¬ sup.actualCreateWindowLR;
IF basicMethods.pleaseResizeChild = NIL THEN 
basicMethods.pleaseResizeChild ¬ sup.pleaseResizeChild;
IF basicMethods.preferredSizeLR = NIL THEN 
basicMethods.preferredSizeLR ¬ sup.preferredSizeLR;
IF basicMethods.classNameHint = NIL THEN 
basicMethods.classNameHint ¬ sup.classNameHint;
IF basicMethods.className = NIL THEN 
basicMethods.className ¬ sup.className;
IF basicMethods.destroyWindowLR=NIL AND basicMethods.super=NIL THEN 
basicMethods.destroyWindowLR ¬ SimpleDestroyWindowLR;
class ¬ NEW[ClassRec[cDataIdx+basicMethods.cDataNum]];
class.flags ¬ basicMethods.addFlags;
class.key ¬ basicMethods.key;
class.classNameHint ¬ basicMethods.classNameHint;
class.super ¬ basicMethods.super; --! no chaining to defaultSuper (sup)
class.wDataIdx ¬ sup.wDataIdx+sup.wDataNum;
class.wDataNum ¬ basicMethods.wDataNum;
class.internalEnumerateChildren ¬ basicMethods.internalEnumerateChildren;
class.superWithIEC ¬ IF sup.internalEnumerateChildren#NIL THEN sup ELSE sup.superWithIEC; 
class.configureLR ¬ basicMethods.configureLR;
class.actualCreateWindowLR ¬ basicMethods.actualCreateWindowLR;
class.destroyWindowLR ¬ basicMethods.destroyWindowLR;
class.removeChildLR ¬ basicMethods.removeChildLR;
class.preferredSizeLR ¬ basicMethods.preferredSizeLR;
class.initInstPart ¬ basicMethods.initInstPart;
class.preStopFastAccess ¬ basicMethods.preStopFastAccess;
class.fullStopFastAccessLR ¬ basicMethods.fullStopFastAccessLR;
class.bindScreenLX ¬ basicMethods.bindScreenLX;
class.forgetScreenLR ¬ basicMethods.forgetScreenLR;
class.destroyWidget ¬ basicMethods.destroyWidget;
class.className ¬ basicMethods.className;
class.pleaseResizeChild ¬ basicMethods.pleaseResizeChild;
class.createSubClass ¬ basicMethods.createSubClass;
class.cDataIdx ¬ cDataIdx;
class.cDataNum ¬ basicMethods.cDataNum;
class.eventMask ¬ Xl.ORSetOfEvents[basicMethods.eventMask, sup.eventMask];
class.cursorKey ¬ IF basicMethods.cursorKey=NIL 
THEN sup.cursorKey
ELSE basicMethods.cursorKey;
class.backgroundKey ¬ IF basicMethods.backgroundKey=NIL 
THEN sup.backgroundKey
ELSE basicMethods.backgroundKey;
class.borderColorKey ¬ IF basicMethods.borderColorKey=NIL 
THEN sup.borderColorKey
ELSE basicMethods.borderColorKey;
FOR i: INT IN [0..cDataIdx) DO
class.cClassData[i] ¬ sup.cClassData[i];
ENDLOOP;
IF class.super#NIL THEN class.flags ¬ OrClassFlags[class.flags, class.super.flags];
CallSubCreateClass[class, class];
[] ¬ RefTab.Store[classTable, class.key, class];
};

OrClassFlags: PROC [cf1, cf2: ClassFlags] RETURNS [ClassFlags] = {
RETURN [LOOPHOLE[Basics.BITOR[LOOPHOLE[cf1], LOOPHOLE[cf2]]]]
};

FindClass: PUBLIC PROC [key: ATOM] RETURNS [Class] = {
RETURN [NARROW[RefTab.Fetch[classTable, key].val]]
};

SpecificsCount: PROC [class: Class] RETURNS [NAT] = INLINE {
RETURN [class.wDataIdx + class.wDataNum]
};

InitClassField: PUBLIC PROC [classField: Class, class: Class] RETURNS [Class] = {
IF classField=NIL 
THEN RETURN [class]
ELSE {
original: Class ¬ classField;
WHILE original # NIL AND original # class DO
original ¬ original.super
ENDLOOP;
IF original # class THEN {
ERROR; --inconsistent class definition (sometimes caused by re-loading a super class) 
};
RETURN [classField]
};
};

InheritedConfigureLRProc: PUBLIC PROC [superClass: Class] RETURNS [ConfigureProc] = {
WHILE superClass.super#NIL AND superClass.configureLR=superClass.super.configureLR DO 
superClass ¬ superClass.super 
ENDLOOP;
RETURN [superClass.configureLR];
};

FindScreen: PROC [widget: Widget] RETURNS [Screen] = {
FOR w: Widget ¬ widget, w.parent WHILE w#NIL DO
IF w.screenDepth#NIL THEN RETURN [w.screenDepth.screen];
ENDLOOP;
IF widget.visual#nullVisual THEN {
FOR i: NAT IN [0..ScreenDepthCount[widget.connection]) DO
sd: ScreenDepth ¬ NthScreenDepth[widget.connection, i];
FOR vl: LIST OF READONLY VisualType ¬ sd.visuals, vl.rest WHILE vl#NIL DO
IF widget.visual=vl.first.visual THEN RETURN [sd.screen];
ENDLOOP;
ENDLOOP;
};
RETURN [DefaultScreen[widget.connection]];
};

InheritDepth: PROC [widget: Widget] = {
IF widget.depth<=0 THEN {
FOR w: Widget ¬ widget.parent, w.parent WHILE w#NIL DO
IF w.depth>0 THEN {
widget.depth ¬ w.depth; 
IF w.screenDepth#NIL AND w.screenDepth.depth=widget.depth THEN 
widget.screenDepth ¬ w.screenDepth;
RETURN
};
ENDLOOP;
}
};

SetupScreenDepth: PUBLIC PROC [widget: Widget] = {
IF widget.depth<=0 AND widget.screenDepth#NIL THEN {
widget.depth ¬ widget.screenDepth.depth; 
};
IF widget.depth<=0 THEN InheritDepth[widget];
IF widget.screenDepth=NIL THEN {
screen: Screen ¬ FindScreen[widget];
IF widget.depth>0 
THEN {
FOR sdl: ScreenDepthL ¬ screen.screenDepthL, sdl.rest WHILE sdl#NIL DO
IF widget.depth=sdl.first.depth THEN {widget.screenDepth ¬ sdl.first; RETURN};
ENDLOOP;
ERROR;
}
ELSE { 
FOR w: Widget ¬ widget.parent, w.parent WHILE w#NIL DO
IF w.screenDepth#NIL THEN {
widget.screenDepth ¬ w.screenDepth; 
widget.depth ¬ widget.screenDepth.depth; 
RETURN
};
ENDLOOP;
FOR sdl: ScreenDepthL ¬ screen.screenDepthL, sdl.rest WHILE sdl#NIL DO
IF sdl.first.depth=1 AND sdl.first.nVisualTypes>0 THEN {
widget.screenDepth ¬ sdl.first; 
widget.depth ¬ widget.screenDepth.depth; 
RETURN
};
ENDLOOP;
FOR sdl: ScreenDepthL ¬ screen.screenDepthL, sdl.rest WHILE sdl#NIL DO
IF sdl.first.depth=screen.rootDepth AND sdl.first.nVisualTypes>0 THEN {
widget.screenDepth ¬ sdl.first; 
widget.depth ¬ widget.screenDepth.depth; 
RETURN
};
ENDLOOP;
FOR sdl: ScreenDepthL ¬ screen.screenDepthL, sdl.rest WHILE sdl#NIL DO
IF sdl.first.nVisualTypes>0 THEN {
widget.screenDepth ¬ sdl.first; 
widget.depth ¬ widget.screenDepth.depth; 
RETURN
};
ENDLOOP;
ERROR;
};
};
};

FindVisual: PROC [widget: Widget] RETURNS [Visual ¬ nullVisual] = {
v: Xl.Visual ¬ widget.visual;
IF v=nullVisual 
THEN {
IF widget.parent#NIL AND widget.screenDepth=widget.parent.screenDepth THEN RETURN [widget.parent.visual]; --most frequent
ERROR; 
}
ELSE {
FOR vtl: LIST OF READONLY VisualType ¬ widget.screenDepth.visuals, vtl.rest WHILE vtl#NIL DO
IF vtl.first.visual=v THEN RETURN [v];
ENDLOOP; 
ERROR; --visual not supported by screen for this depth
};
};

IScreenBound: PROC [widget: Widget] RETURNS [BOOL] = INLINE {
RETURN [widget.state<=screened];
};

ScreenBound: PUBLIC PROC [widget: Widget] RETURNS [BOOL] = {
RETURN [IScreenBound[widget]];
};

BindScreenFromParent: PROC [widget: Widget] = {
IF ~IScreenBound[widget] THEN {
parent: Widget ¬ widget.parent; --crash if parent doesn't exist or isn't IScreenBound is ok
IF ~IScreenBound[parent] THEN ERROR;
BindScreenLR[widget, parent.rootTQ, parent.screenDepth.screen, parent.screenDepth];
};
};

HardScreenFromParentLR: PROC [child: Widget] = {
parent: Widget ¬ child.parent;
IF ~IScreenBound[parent] THEN ERROR;
BindScreenLR[child, parent.rootTQ, parent.screenDepth.screen, parent.screenDepth];
};
AssignParentAndCheckScreenLR: PUBLIC PROC [child, parent: Widget] = {
child.parent ¬ parent;
IF IScreenBound[parent] THEN HardScreenFromParentLR[child]
};
BindScreenLR: PUBLIC PROC [widget: Widget, rootTQ: TQ, screen: Xl.Screen, screenDepth: Xl.ScreenDepth ¬ NIL] = {
Recurse: EachChild = {BindScreenLR[child, rootTQ, screen, screenDepth]};
IF widget.state>=dead THEN ERROR;
IF ~IScreenBound[widget] THEN {
IF screen=NIL THEN screen ¬ screenDepth.screen;
widget.state ¬ screened;
widget.connection ¬ screen.connection;
widget.rootTQ ¬ rootTQ;
FOR class: Class ¬ widget.s.class, class.super WHILE class#NIL DO
IF class.bindScreenLX#NIL THEN class.bindScreenLX[widget, rootTQ, screen, screenDepth];
ENDLOOP;
IF widget.screenDepth=NIL THEN widget.screenDepth ¬ screenDepth;
CallNotifiers[widget, bindScreenLRReal, NIL<<screen is READONLY>>];
ShallowInternalEnumerateChildren[widget, Recurse];
};
};

ForgetScreenLR: PUBLIC PROC [widget: Widget] = {
Recurse: EachChild = {ForgetScreenLR[child]};
IF IScreenBound[widget] THEN {
reason: TerminationReason ¬ errorConnection;
IF widget.fastAccessAllowed<warned THEN reason ¬ normal;
IF widget.actualMapping<unconfigured THEN 
DestroyWindowLR[widget: widget, reason: reason];
widget.state ¬ MAX[widget.state, existing];
ShallowInternalEnumerateChildren[widget, Recurse];
CallNotifiers[widget, forgetScreenLRReal, NIL];
FOR class: Class ¬ widget.s.class, class.super WHILE class#NIL DO
IF class.forgetScreenLR#NIL THEN class.forgetScreenLR[widget, errorWindow];
ENDLOOP;
SuperForgetScreenLR[widget, errorWindow]
};
};
deadConnection: Xl.Connection ¬ XlUtils.DeadConnection[$NoServer];

SuperForgetScreenLR: TerminateProc = INLINE {
a: Xl.Attributes ¬ []; --get an accessible copy with the illegal values
widget.depth ¬ 0;
widget.visual ¬ Xl.nullVisual;
widget.attributes.backgroundPixmap ¬ a.backgroundPixmap;
widget.attributes.backgroundPixel ¬ a.backgroundPixel;
widget.attributes.borderPixmap ¬ a.borderPixmap;
widget.attributes.borderPixel ¬ a.borderPixel;
widget.attributes.backingPlanes ¬ a.backingPlanes;
widget.attributes.backingPixel ¬ a.backingPixel;
widget.attributes.colorMap ¬ a.colorMap;
widget.attributes.cursor ¬ a.cursor;
widget.window ¬ Xl.nullWindow;
widget.connection ¬ deadConnection; --using a non NIL value allows to avoid NIL tests before painting with a widget.connection 
widget.screenDepth ¬ NIL;
widget.rootTQ ¬ NIL;
};

ShallowInternalEnumerateChildren: PUBLIC PROC [widget: Widget, proc: EachChild, data: REF ¬ NIL] = {
FOR class: Class ¬ widget.s.class, class.superWithIEC WHILE class#NIL DO
IF class.internalEnumerateChildren#NIL THEN 
IF class.internalEnumerateChildren[widget, class, proc, data].stop THEN EXIT;
ENDLOOP;
};

DestroyWindowLR: PUBLIC TerminateProc = {
Recurse:  EachChild = {
DestroyWindowLR[child, reason];
};
IF widget.state=dead THEN RETURN;
IF widget.actualMapping=unconfigured THEN RETURN;
IF widget.actualMapping=mapped AND reason=normal AND widget.fastAccessAllowed=ok AND Xl.Alive[widget.connection] THEN {
widget.actualMapping ¬ unmapped;
Xl.UnmapWindow[widget.connection, widget.window, detailsForNoErrors];
}; 
IF widget.fastAccessAllowed=ok THEN
FullStopFastAccessLR[widget, reason];
widget.state ¬ MAX[screened, widget.state];
ShallowInternalEnumerateChildren[widget, Recurse];
FOR class: Class ¬ widget.s.class, class.super WHILE class#NIL DO
IF class.destroyWindowLR#NIL THEN class.destroyWindowLR[widget, reason];
ENDLOOP;
CallNotifiers[widget, postWindowDestructionLRReal, NIL];
};
ConfigureLR: PUBLIC ConfigureProc = {
existW, createW, destroyW: BOOL;

IF widget.state=dead THEN RETURN;
IF widget.actualMapping>=unconfigured THEN {
widget.actualMapping ¬ unconfigured;
IF mapping=dontUse AND widget.parent#NIL AND widget.parent.actualMapping<unconfigured THEN {
mapping ¬ mapped;
};
};
SELECT mapping FROM
unmapIfMapped => {
IF widget.actualMapping=mapped THEN mapping ¬ unmapped ELSE mapping ¬ dontUse
};
mapIfUnmapped => {
IF widget.actualMapping=unmapped THEN mapping ¬ mapped ELSE mapping ¬ dontUse
};
unmapIfUnconfigured => {
IF widget.actualMapping=unconfigured THEN mapping ¬ unmapped ELSE mapping ¬ dontUse
};
mapIfUnconfigured => {
IF widget.actualMapping=unconfigured THEN mapping ¬ mapped ELSE mapping ¬ dontUse
};
ENDCASE => {
IF mapping = widget.actualMapping THEN mapping ¬ dontUse;
};

IF mapping<=unmapped THEN {
IF widget.parent#NIL 
THEN {
IF widget.parent.actualMapping>=unconfigured THEN mapping ¬ dontUse;
}
ELSE {
IF widget.state > screened THEN mapping ¬ dontUse;
};
};

existW ¬ widget.actualMapping<unconfigured;
createW ¬ mapping<unconfigured AND ~existW;
destroyW ¬ mapping=unconfigured AND existW;

IF destroyW THEN {
reason: TerminationReason ¬ IF widget.fastAccessAllowed=ok THEN normal ELSE errorConnection; 
DestroyWindowLR[widget, reason];
RETURN;
};

IF createW THEN {
IF widget.window#Xl.nullWindow THEN ERROR;
IF ~IScreenBound[widget] THEN HardScreenFromParentLR[widget];
widget.state ¬ realized;
widget.fastAccessAllowed ¬ ok;
CallNotifiers[widget, preWindowCreationLRReal, NIL]; 
};

IF geometry.pos.x = widget.actual.pos.x THEN geometry.pos.x ¬ dontUse;
IF geometry.pos.y = widget.actual.pos.y THEN geometry.pos.y ¬ dontUse;
IF geometry.size.width = widget.actual.size.width THEN geometry.size.width ¬ dontUse;
IF geometry.size.height = widget.actual.size.height THEN geometry.size.height ¬ dontUse;
IF geometry.borderWidth = widget.actual.borderWidth THEN geometry.borderWidth ¬ dontUse;

IF createW OR geometry#[[dontUse, dontUse], [dontUse, dontUse], dontUse] OR mapping#dontUse OR (reConsiderChildren AND GetWidgetFlag[widget, mustReConsiderChildren]) THEN {
widget.s.class.configureLR[widget, geometry, mapping, reConsiderChildren];
SELECT TRUE FROM
createW => CallNotifiers[widget, postWindowCreationLRReal, NIL];
existW => CallNotifiers[widget, postConfigureLRReal, NIL];
ENDCASE => {};
};
};


BorderColorDefined: PROC [w: Widget] RETURNS [BOOL] = INLINE {
RETURN [w.attributes.borderPixmap#illegalPixmap OR w.attributes.borderPixel#illegalPixel] 
};

AssignToActual: PROC [widget: Widget, geometry: Xl.Geometry, mapping: Mapping] = INLINE {
IF geometry.pos.x # dontUse THEN widget.actual.pos.x ¬ geometry.pos.x;
IF geometry.pos.y # dontUse THEN widget.actual.pos.y ¬ geometry.pos.y;
IF geometry.size.width # dontUse THEN widget.actual.size.width ¬ geometry.size.width;
IF geometry.size.height # dontUse THEN widget.actual.size.height ¬ geometry.size.height;
IF geometry.borderWidth # dontUse THEN widget.actual.borderWidth ¬ geometry.borderWidth;
IF mapping # dontUse THEN widget.actualMapping ¬ mapping;
};

SimpleConfigureOneLevelLR: PUBLIC ConfigureProc = {
EntryOrEventMask: ENTRY PROC [widget: Widget] = {
widget.attributes.eventMask ¬ Xl.ORSetOfEvents[widget.attributes.eventMask, widget.s.class.eventMask];
};
existW, createW, destroyW: BOOL;

existW ¬ widget.actualMapping<unconfigured;
createW ¬ mapping<unconfigured AND ~existW;
destroyW ¬ mapping=unconfigured AND existW;
IF destroyW THEN ERROR;
IF createW THEN {
IF widget.parent#NIL THEN {
IF widget.depth<0 THEN widget.depth ¬ widget.parent.depth
};
SetupScreenDepth[widget];
IF widget.actual.size.height<=0 THEN widget.actual.size.height ¬ 1;
IF widget.actual.size.width<=0 THEN widget.actual.size.width ¬ 1;
IF widget.actual.borderWidth<0 THEN widget.actual.borderWidth ¬ 0; --neither copy from parent here nor use copy from parent feature of X; this would be to complex for containers.
IF Xl.IllegalCursor[widget.attributes.cursor] THEN {
WITH widget.s.class.cursorKey SELECT FROM
rc: REF XlCursor.StandardFontCursors => 
widget.attributes.cursor ¬ XlCursor.SharedStandardCursor[widget.connection, rc­];
rwp: REF WidgetProc => rwp­[widget]; 
ENDCASE => {};
};
IF widget.attributes.backgroundPixel=illegalPixel AND IllegalPixmap[widget.attributes.backgroundPixmap]  THEN {
WITH widget.s.class.backgroundKey SELECT FROM
a: ATOM => {
widget.attributes.backgroundPixel ¬ SELECT a FROM
$white => widget.screenDepth.screen.whitePixel,
$black => widget.screenDepth.screen.blackPixel,
$none => illegalPixel,
ENDCASE => widget.screenDepth.screen.whitePixel;
};
rwp: REF WidgetProc => rwp­[widget]; 
ENDCASE => {};
};
IF ~BorderColorDefined[widget]  THEN {
WITH widget.s.class.borderColorKey SELECT FROM
a: ATOM => {
widget.attributes.borderPixel ¬ SELECT a FROM
$white => widget.screenDepth.screen.whitePixel,
$black => widget.screenDepth.screen.blackPixel,
$none => illegalPixel,
ENDCASE => widget.screenDepth.screen.blackPixel;
};
rwp: REF WidgetProc => rwp­[widget]; 
ENDCASE => {};
};
};
IF geometry.pos.x = widget.actual.pos.x THEN geometry.pos.x ¬ dontUse;
IF geometry.pos.y = widget.actual.pos.y THEN geometry.pos.y ¬ dontUse;
IF geometry.size.width = widget.actual.size.width THEN geometry.size.width ¬ dontUse;
IF geometry.size.height = widget.actual.size.height THEN geometry.size.height ¬ dontUse;
IF geometry.borderWidth = widget.actual.borderWidth THEN geometry.borderWidth ¬ dontUse;
IF mapping = widget.actualMapping THEN mapping ¬ dontUse;
AssignToActual[widget, geometry, mapping];
SELECT TRUE FROM
createW => {
EntryOrEventMask[widget];
IF mapping=dontUse THEN widget.actualMapping ¬ mapping ¬ mapped;
widget.s.class.actualCreateWindowLR[widget];
};
existW => {
c: Xl.Connection ~ widget.connection;
win: Xl.Window ~ widget.window;
IF Xl.Alive[c] AND win#Xl.nullWindow THEN {
IF mapping=unmapped THEN 
Xl.UnmapWindow[c, win, detailsForNoErrors]; 
Xl.ConfigureWindow[c: c, window: win, geometry: geometry];
IF mapping=mapped THEN 
Xl.MapWindow[c, win, detailsForNoErrors]; 
};
};
ENDCASE => {
};
};

SimpleDestroyWindowLR: PUBLIC TerminateProc = {
c: Xl.Connection ~ widget.connection;
win: Xl.Window ~ widget.window;
widget.actualMapping ¬ MAX[widget.actualMapping, unconfigured];
IF reason=normal AND Xl.Alive[c] AND win#Xl.nullWindow THEN {
Xl.DestroyWindow[c, win, detailsForNoErrors];
};
widget.window ¬ Xl.nullWindow;
};

DontMapCreateWindowLR: PUBLIC WidgetProc = {
visual: Visual ¬ FindVisual[widget];
parentWindow: Xl.Window ¬ widget.parent.window;
widget.window ¬ Xl.CreateWindow[c: widget.connection, matchList: CollectMatchesLR[widget], parent: parentWindow, geometry: widget.actual, visual: visual, depth: widget.depth, attributes: widget.attributes];
};

DefaultActualCreateWindowLR: PUBLIC WidgetProc = {
DontMapCreateWindowLR[widget];
IF widget.actualMapping=mapped THEN 
Xl.MapWindow[widget.connection, widget.window]; 
};

IgnorePleaseResizeChild: PUBLIC WidgetNChildProc = {
};

CollectMatchesLR: PUBLIC PROC [widget: Widget] RETURNS [ml: Xl.MatchList ¬ NIL] = {
FOR lx: LIST OF MatchRep ¬ widget.matchListX, lx.rest WHILE lx # NIL DO
m: Match ¬ NEW[MatchRep ¬ lx.first];
IF m.tq=NIL THEN m.tq ¬ widget.rootTQ;
ml ¬ CONS[m, ml];
ENDLOOP;
IF widget.matchList1 # NIL THEN {
GetMatchList1: ENTRY PROC [widget: Widget] RETURNS [ml: Xl.MatchList] = {
ml ¬ widget.matchList1; widget.matchList1 ¬ NIL;
};
FOR lx: Xl.MatchList ¬ GetMatchList1[widget], lx.rest WHILE lx # NIL DO
m: Match ¬ NEW[MatchRep ¬ lx.first­];
IF m.tq=NIL THEN m.tq ¬ widget.rootTQ;
ml ¬ CONS[m, ml];
ENDLOOP;
};
};

PropagateUpPleaseResizeChild: PUBLIC WidgetNChildProc = {
IF widget.parent#NIL THEN {
PleaseResizeChild[widget.parent, widget];
};
};

SimplePreferredSizeOneLevel: PUBLIC PreferredSizeProc = {
RETURN [widget.s.geometry];
};

SimpleClassName: PUBLIC ClassNameProc = {
RETURN [widget.s.class.classNameHint];
};

NoteChildChangePropagate: PUBLIC PROC [widget: Widget, top: Widget ¬ NIL] = {
WHILE widget#NIL AND widget.state<dead DO
NoteChildChange[widget];
IF widget=top THEN RETURN;
widget ¬ widget.parent
ENDLOOP;
};
NoteGeometryChange: PUBLIC PROC [widget: Widget, geometry: Geometry ¬ []] = {
IF widget.state>=dead THEN ERROR;
IF geometry.size.width>0 THEN widget.s.geometry.size.width ¬ geometry.size.width;
IF geometry.size.height>0 THEN widget.s.geometry.size.height ¬ geometry.size.height;
IF geometry.pos.x#dontUse THEN widget.s.geometry.pos.x ¬ geometry.pos.x;
IF geometry.pos.y#dontUse THEN widget.s.geometry.pos.y ¬ geometry.pos.y;
IF geometry.borderWidth#dontUse THEN widget.s.geometry.borderWidth ¬ geometry.borderWidth;
IF widget.s.geometry#widget.actual OR widget.s.mapping=dontUse THEN { 
IF widget.parent#NIL THEN NoteChildChange[widget.parent];
};
};
NoteMappingChange: PUBLIC PROC [widget: Widget, mapping: Mapping ¬ dontUse] = {
IF widget.state>=dead THEN ERROR;
IF mapping#dontUse THEN widget.s.mapping ¬ mapping;
IF widget.s.mapping#widget.actualMapping OR widget.s.mapping=dontUse THEN { 
IF widget.parent#NIL THEN NoteChildChange[widget.parent];
};
};
NoteAndStartReconfigure: PUBLIC PROC [widget: Widget, geometry: Geometry ¬ [], mapping: Mapping ¬ dontUse] = {
ReconfigureParentNow: PROC [widget: Widget] = {
parent: Widget ¬ widget.parent;
IF parent=NIL THEN ERROR; --shell to be handled differently...
StartReconfigureChildren[parent];
};
IF widget.state>=dead THEN ERROR;
NoteMappingChange[widget, mapping];
NoteGeometryChange[widget, geometry];
ReconfigureParentNow[widget];
};
NoteGeometryChangePropagate: PUBLIC PROC [widget: Widget, geometry: Geometry ¬ [], top: Widget ¬ NIL] = {
NoteGeometryChange[widget, geometry];
IF widget.s.geometry#widget.actual OR widget.s.mapping=dontUse THEN { 
NoteChildChangePropagate[widget.parent, top];
};
};
NoteMappingChangePropagate: PUBLIC PROC [widget: Widget, mapping: Mapping ¬ dontUse, top: Widget ¬ NIL] = {
NoteMappingChange[widget, mapping];
IF widget.s.mapping#widget.actualMapping OR widget.s.mapping=dontUse THEN { 
NoteChildChangePropagate[widget.parent, top];
};
};
ReconfigureChildrenLR: PUBLIC PROC [self: Widget] = {
IF self#NIL AND self.state<dead AND GetWidgetFlag[self, mustReConsiderChildren] THEN {
ConfigureLR[widget: self, geometry: [], mapping: dontUse, reConsiderChildren: TRUE];
};
};

StartReconfigureChildren: PUBLIC PROC [widget: Widget] = {
action: PROC [] = {ReconfigureChildrenLR[widget]};
IF widget.state<dead THEN { 
IF widget.rootTQ=NIL THEN action[] ELSE Xl.CallWithLock[widget.rootTQ, action];
}
};
DestroyWidget: PUBLIC PROC [widget: Widget, startReconfigureParent: BOOL ¬ TRUE] = {
action: PROC = {
parent: Widget ¬ widget.parent;
IF parent#NIL AND widget.state<dead AND parent.state<dead THEN {
NoteChildChange[parent];
};
DestroyWidgetLR[widget];
IF parent#NIL AND GetWidgetFlag[parent, mustReConsiderChildren] AND startReconfigureParent THEN ReconfigureChildrenLR[parent]; 
};
IF widget.state<dead THEN { 
IF widget.rootTQ=NIL THEN action[] ELSE Xl.CallWithLock[widget.rootTQ, action];
}
};

CreateWidget: PUBLIC PROC [widgetSpec: WidgetSpec, class: Class ¬ NIL, arguments: Atom.PropList ¬ NIL] RETURNS [widget: Widget] = {
InitializeChain: PROC [w: Widget, class: Class] = {
IF class.super#NIL THEN InitializeChain[w, class.super];
IF class.initInstPart#NIL THEN class.initInstPart[w, arguments];
};
widgetSpec.class ¬ InitClassField[widgetSpec.class, class];
widget ¬ NEW[WidgetRep[SpecificsCount[widgetSpec.class]]];
widget.s ¬ widgetSpec;
widget.fastAccessAllowed ¬ warned;
InitializeChain[widget, widget.s.class];
}; 

orphanProcKey: REF ¬ NEW[ATOM];
RegisterOrphanProc: PUBLIC PROC [self: Widget, orphanProcLR: OrphanProc ¬ NIL] = {
ref: REF OrphanProc ~ IF orphanProcLR#NIL THEN NEW[OrphanProc¬orphanProcLR] ELSE NIL;
PutWidgetProp[self, orphanProcKey, ref];
};

OrphanizeLR: PUBLIC PROC [orphan: Widget, parentState: TerminationReason] = {
WITH GetWidgetProp[orphan, orphanProcKey] SELECT FROM
op: REF OrphanProc => op[orphan];
ENDCASE => DestroyWidgetLR[orphan];
};
defaultSuper: REF ClassRec ¬ NEW[ClassRec[0]];  --used for defaults in CreateClass; NOT used in runtime chaining for efficiency reasons.
defaultSuper.configureLR ¬ SimpleConfigureOneLevelLR;
defaultSuper.preferredSizeLR ¬ SimplePreferredSizeOneLevel;
defaultSuper.pleaseResizeChild ¬ IgnorePleaseResizeChild;
defaultSuper.className ¬ SimpleClassName;
defaultSuper.actualCreateWindowLR ¬ DefaultActualCreateWindowLR;

END.

’
XTkImpl.mesa
Copyright Σ 1988, 1989, 1990, 1991, 1992, 1993 by Xerox Corporation.  All rights reserved.
Created by Christian Jacobi, August 3, 1990 1:59 pm PDT
Christian Jacobi, May 4, 1993 2:37 pm PDT

--Resumable signal from debugger (while debugging application) 
--Resume means reuse is ok; abort means reuse is not ok
--not monitored because typically called in module initializations
--alias already defined


<<Any thread>>
--sub to super order for no good reason
<<collect threads of slow stoppers (so later a wait can be berformed)>>
<<Root thread because of possible side effects>>
<<Recursing class clients>>
--sub to super order for no good reason
--rarely used, not worth optimizing
--Removes all registered TQ's for SynchronizeFastAccess and returns them. 
--Used on all widgets; optimizing worth while.
<<Root thread because of possible side effects>>
<<Any client; but explicitely not recursion>>
--collect tqs and wait a little for slow stoppers
IF widget=NIL THEN ERROR; 
IF widget=NIL THEN ERROR; 
--recurse ancestor first--
--do the job for this level--
--inherit by copy
--set up
--initializes or restricts classField to superclasses of class
--called before window is set up !
<<DONT RETURN [QueryScreen[of root of widget]] : widget.window is not set up yet>>
--try to find using inheritance
--try to find screen using visual
--dont search for a screen supporting that depth... 
--a reasonable root should have something set up at least
--check existence of required depth on screen 
--well; to bad if we guessed the first screen and it doesnt provide the depth...
--but root widgets should be more clever and provide screenDepth
--try inheriting a screenDepth and use its depth 
--make a screenDepth up 
--try 1 bit per pixel first
--try rootDepth 
--try any bit per pixel
--try inheriting from parent
--if it can not be inherited it should be specified!
--I'm to lazy to make one up, and wouldn't know which
--check whether supplied visual is legal


--sub to super order to give subclass first chance to recognize not yet initialized values
--sub to super order for no good reason


Assigns the defined values into widget, for undefined values leave widget alone.
--
--








Κ+'–
(cedarcode) style•NewlineDelimiter

™
code™Kšœ
Οe
œO™ZK™7K™)K™—šΟk	œ
˜
K˜K˜K˜K˜K˜	K˜K˜K˜Kš
œ˜K˜K˜K˜K˜—šΟnœžœ
žœ
˜Kšžœžœ˜!KšžœP˜WKšžœ&˜-—Kšžœ
žœ˜K˜Kšœžœžœžœ˜iKš	œžœžœ*žœ-žœ˜₯
Kš	œžœžœ+žœ-žœ˜ͺ
š	œžœžœžœ-žœ˜”
K˜Kšœžœ˜KšŸœ7˜C—K˜K˜)Kšœ*Οc˜CKšœ(  ˜HK˜šŸœžœžœ
˜K™?K™7—K˜šŸœžœ
žœžœ	žœžœ˜>K™BKšžœžœ
žœ˜šžœ%žœ˜.Kšžœžœ
žœ $˜JK˜—šžœ(žœ˜0K™šžœ)žœ
˜0Kšžœ
 ˜,—K˜—Kšœ!Πbfœ ˜CK˜K™—Kšœžœžœ
žœ˜*Kšœžœžœžœ˜;Kšœžœžœ
žœ˜'Kš	œžœžœ(žœžœ˜KK˜š
Ÿœžœ0žœžœžœ˜hšžœ žœžœ
ž˜1K˜cKš
ž˜—K˜K˜—šŸ
œžœ
žœžœžœžœžœ˜bš	žœžœžœžœ
ž˜Hšžœžœ˜Kš
œ9˜9Kšžœ
˜K˜—Kšžœ
˜—K˜K˜—šŸœžœ
žœžœ˜;K˜&K˜K˜—šŸœžœ
žœžœžœžœ˜fKšœžœ˜.šžœžœ
žœ˜šžœžœ˜K˜K˜Kš
ž˜K˜—šžœžœ
ž˜šžœžœ˜!K˜"K˜Kš
ž˜K˜—K˜Kš
ž˜—K˜—K˜K˜—šŸœžœ
žœ<žœžœžœ˜ˆ
š	žœžœ
žœžœ&ž˜SKš
œ˜Kšžœ
˜—šžœžœ
žœ˜Kš
œ˜š	žœžœ
žœ
žœ
ž˜!šžœžœ*˜IKšžœ˜Kšžœ˜—Kšžœ˜	—K˜—Kšžœ˜
K˜K˜—šŸœžœ
žœžœ(žœžœ˜xKšœžœ˜.Kšœžœ
˜šžœ"žœžœ
ž˜4Kšžœžœ
žœ˜,Kšžœ
˜—šžœžœ
žœ˜Kšœžœžœ
˜7K˜K˜—Kšœžœ'˜=K˜K˜—šŸœžœ
žœžœ*žœžœ˜oš
Ÿœžœ
žœžœ(žœ˜lKš
œ;˜;K˜—Kšœ ˜0Kšœžœ&˜/Kšžœžœ
žœ˜Kš
œ5˜5K˜K˜—šŸœžœ
žœžœ*žœžœ˜qš
Ÿœžœ
žœžœ(žœ˜nKšœžœ˜.Kšœžœ
˜šžœ"žœžœ
ž˜4Kšžœžœ
žœ˜,Kšžœ
˜—š
žœžœ
žœžœ
žœ
˜)Kš
œP˜P—K˜—Kšœ ˜0Kšœžœ&˜/Kšžœžœ
žœ˜Kš
œ7˜7K˜K˜—š
Ÿœžœžœ8žœžœ˜zKšœ ˜.šŸœžœ
žœ8žœžœžœ˜mK˜!Kš
œK˜KKš
œ˜—Kšžœžœ
žœ
˜"Kšžœ&žœ˜EK˜—˜šŸœžœžœžœžœ
žœ˜8Kšœžœ
žœ˜K˜%K˜K˜—Kšœžœ
žœ˜:Kšœžœ
žœ˜8K˜Kšœžœ
žœ˜<Kšœžœ
žœ˜:K˜Kšœžœ
žœ˜3Kšœžœ
žœ˜1K˜Kšœžœ
žœ˜Ašœžœ
žœ˜?K™—Kšœžœ
žœ˜9K˜Kšœžœ
žœ˜=Kšœžœ
žœ˜;K˜Kšœžœ
žœ˜+Kšœžœ
žœ˜)Kšœžœ
žœ˜1Kšœžœ
žœ˜/Kšœžœ
žœ˜AK˜Kšœžœ
žœ)˜JKšœžœ
žœ*˜LKšœžœ
žœ%˜BKšœžœ
žœ-˜RKšœžœ
žœ(˜GKšœžœ
žœ+˜MKšœžœ
žœ$˜@Kšœžœ
žœ"˜<Kšœžœ
žœ+˜NK˜—šŸœžœ
žœ?˜]š
Ÿ	œžœ
žœ<žœžœ˜mKš
œV˜VKšœžœ˜6Kšœ!žœžœ$ R˜Ί
Kš
œ˜—Kšœ
žœ)˜7šžœ
žœžœ˜2Kšœžœ˜+Kšžœ
žœ
žœ˜.Kš
œD˜DK˜
—K˜K˜—šŸœžœ
žœ?˜]š
Ÿ	œžœ
žœ9žœžœ˜jKš
œV˜VKšœžœ˜3Kšœ!žœžœ$ R˜Ί
Kš
œ˜—Kšœžœ˜,Kšœ
žœ'˜5šžœ
žœžœ˜2Kšœžœ˜+Kšžœ
žœ
žœ˜.Kš
œB˜BK˜
—K˜K˜—šŸœžœ˜.K˜0K˜K˜—Kšœžœ
žœ˜&K˜šŸœžœ˜-Kšžœžœ
žœ˜0Kšžœžœ
žœ
˜$šžœžœ-žœ˜OKšžœžœžœ,˜aKšžœžœžœ,˜aKšžœ žœžœ6˜oKšžœ!žœžœ8˜rKšžœ!žœžœ8˜rKšžœžœ
žœ˜+K˜—šžœžœ,žœ˜Nšžœžœžœ˜,Kšžœ-˜1Kšžœ-˜1—Kšžœžœžœ$˜QKšžœžœžœ$˜QKšžœžœžœ.˜_Kšžœžœžœ0˜bKšžœžœžœ0˜cKšžœžœ
žœ˜+K˜—K˜LK˜K˜—šŸœžœ˜+J™KšŸœ1˜8šžœžœ˜%K˜K˜"Kšœ-žœžœ	žœ
˜YKš
œ'™'šžœ,žœžœ
ž˜AKšžœžœ
žœ)˜LKšžœ
˜—Kš
œ2˜2K˜—Kš
œ˜K˜—šŸœžœžœžœ!˜gJš
œG™GJ™0J™KšŸœM˜TKšžœžœ
žœ
˜Kšžœžœ˜<K˜Kš
œ'™'šžœ'žœžœ
ž˜<šžœžœ
žœ
˜'Kš
œ6˜6—Kšžœ
˜—Kš
œ-˜-š
žœžœ
žœ
žœ+žœžœ
ž˜PKš
œ˜Kšžœ
˜—Kš
œ˜K˜—Kš	œžœ
žœžœ
žœ˜'šŸœžœ
žœ
žœžœžœ˜Tšžœžœ
žœ˜šžœ;žœ
ž˜Jšœžœ
žœ
žœ˜Kš
œ#™#Kš	œžœ
žœ
žœžœ˜(Kšœžœ+˜OK˜
—šžœ˜Kšœ!žœ%žœ
˜_K˜——K˜—Kš
œ˜—Kš
œ
˜
šŸœžœ
žœžœžœ
žœ
žœžœžœ˜]Kš
œJ™JKš
œ.™.Kšœžœžœ%˜Ošžœžœ
ž˜Kš	œžœ
žœ
žœžœ˜ Kšžœ˜
—K˜—K˜šŸœžœ+˜LJ™0J™-Jš
œ1™1Kšœ$žœ
˜(šŸ	œžœ
žœ˜ šžœžœ
žœž˜&K˜3—Kš
œ˜—Kšžœžœ
žœ
˜Kš
œ2˜2Kšžœžœ
žœ)˜:Kš
œ5˜5K˜—K˜šŸœžœ
žœ˜1šŸœ˜šžœžœ˜K˜K˜—K˜—šžœžœ˜K˜Kšžœžœ˜4K˜Kšžœžœ
žœžœ$˜Lšžœ,žœžœ
ž˜AKšžœžœ
žœ˜<Kšžœ
˜—K˜7K˜1Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜šžœ˜	Kšžœžœ
žœžœ˜PK˜—K˜—K˜K˜—šŸ
œžœ
žœ!žœžœžœ˜[šžœžœžœ
žœ˜)šžœ,žœžœ
ž˜Ašžœžœ
žœ˜!šžœ$žœ˜,Kšœžœ˜
Kš
œ˜Kš
ž˜Kš
œ
˜
—K˜
—Kšžœ
˜—K˜—K˜K˜—šŸœžœ
žœ
žœ˜7Kšœ'ž˜+Kš
œ˜K˜—šŸ
œžœ
žœ
žœ-žœžœ˜]K˜Kš
œ˜—K˜šœžœ˜,K˜—š
Ÿœžœ
žœ5žœžœ˜^š
Ÿœžœ
žœEžœžœ˜hKš
œ˜Kš
œ˜—Kšžœžœ
žœ0˜AKš
œ˜—Kš
œ
˜
šŸ
œžœ
žœžœ	žœžœžœ˜SKšžœžœ
žœ
žœ™Kšœžœ˜AK˜—K˜šŸ
œžœ
žœžœžœžœžœ˜OKšžœžœ
žœ
žœ™Kšžœžœ˜=K˜—K˜šŸœžœ
žœ žœžœžœ˜Ršžœ2žœ	žœ
ž˜IKšžœ
žœ
žœžœ˜"Kšžœ
˜—K˜K˜—šŸœžœ
žœžœžœžœžœ˜Wšžœ2žœ	žœ
ž˜IKšžœžœ
žœžœ˜+Kšžœ
˜—K˜—K˜
šŸ
œžœ
žœžœ
˜=Kšžœžœ
žœžœ
˜:Kšžœ
˜K˜K˜—š
Ÿœžœ
žœ
žœžœ˜:K˜šžœžœ˜Kš
œ˜Kšžœžœ
žœžœ˜-K˜—K˜K˜—šŸœžœ
žœ&žœ˜cšŸœžœ4˜LKš
 ™šžœžœ
žœ
˜Kš
œ/˜/—Kš
 ™šžœžœ
žœ
˜&Kš
œE˜E—K˜—šœ
žœžœ
˜'Kšžœ 8˜JKšžœ˜—Kšœ
žœ˜*Kš
 ™šžœžœ
žœ
˜'K˜+—šžœ%žœ
žœ
˜0K˜=—šžœ"žœ
žœ
˜-K˜7—šžœ žœ
žœ
˜+K˜3—šžœžœ
žœ
˜)K˜/—šžœžœ
žœ
˜%K˜'—š
žœžœ
žœžœ
žœ
˜DK˜5—Kš
 ™Kšœžœ+˜6K˜$K˜K˜1Kšœ" %˜GK˜+K˜'K˜IKš	œžœžœ
žœžœ˜ZK˜-K˜?K˜5K˜1K˜5K˜/K˜9K˜?K˜/K˜3K˜1K˜)K˜9K˜3K˜K˜'Kš
œJ˜Jšœžœžœ
˜0Kšžœ˜Kšžœ˜—šœžœžœ
˜8Kšžœ˜Kšžœ˜ —šœžœžœ
˜:Kšžœ˜Kšžœ˜!—šžœžœ
žœž˜K˜(Kšžœ
˜—Kšžœ
žœ
žœ<˜SKš
œ!˜!K˜0K˜—K˜šŸœžœžœ˜BKš
žœžœžœ
žœžœ˜=K˜—K˜š
Ÿ	œžœ
žœžœžœ˜6Kšžœžœ$˜2K˜—K˜š
Ÿœžœžœžœžœ˜<Kšžœ"˜(K˜—K˜šŸœžœ
žœ#žœ˜QKš
 >™>šžœžœ
˜Kšžœ
žœ˜šžœ˜K˜šžœžœ
žœž˜,K˜Kšžœ
˜—šžœžœ˜Kšžœ O˜VK˜—Kšžœ
˜K˜——K˜—K˜šŸœžœ
žœžœ˜Ušžœžœ
žœ5žœ
˜VK˜Kšžœ
˜—Kšžœ˜ K˜K˜—šŸ
œžœžœ
˜6Kš 	Πbc ™"K™RJš
 ™šžœžœžœ
ž˜/Kšžœžœ
žœ
žœ˜8Kšžœ
˜—Jš
 !™!šžœžœ˜"šžœžœ
žœ*ž˜9K˜7š
žœžœ
žœ
žœ"žœžœ
ž˜IKšžœžœ
žœ
˜9Kšžœ
˜—Kšžœ
˜—K˜—Kš
 4™4Kš
 9™9Kšžœ$˜*K˜—K˜šŸœžœ˜'šžœžœ˜šžœ%žœžœ
ž˜6šžœžœ˜K˜šžœžœ
žœ"žœ
˜?K˜#—Kš
ž˜K˜—Kšžœ
˜—K˜
—K˜—K˜šŸœžœ
žœ˜2šžœžœžœ
žœ˜4K˜)K˜—Kšžœžœ˜-šžœžœ
žœ˜ K˜$šžœ˜šžœ˜Kš
 .™.šžœ3žœžœ
ž˜FKšžœžœ"žœ˜NKšžœ
˜—Kš
 P™PKš
 @™@Kšžœ
˜K˜
—šžœ˜Kš
 1™1šžœ%žœžœ
ž˜6šžœžœ
žœ˜K˜$K˜)Kš
ž˜K˜—Kšžœ
˜—Kš
 ™Kš
 ™šžœ3žœžœ
ž˜Fšžœžœžœ˜8K˜ K˜)Kš
ž˜Kš
œ˜—Kšžœ
˜—Kš œ	 
™šžœ3žœžœ
ž˜Fšžœ"žœžœ˜GK˜ K˜)Kš
ž˜Kš
œ˜—Kšžœ
˜—Kš
 ™šžœ3žœžœ
ž˜Fšžœžœ˜"K˜ K˜)Kš
ž˜Kš
œ˜—Kšžœ
˜—Kšžœ
˜K˜——K˜—K˜K˜—šŸ
œžœžœ˜CK˜šžœ˜šžœ˜Kš
 ™Kšžœžœ
žœ.žœ
žœ ˜yKš
 4™4Kš
 5™5Kšžœ˜K˜
—šžœ˜Kš
 (™(š
žœžœ
žœ
žœ3žœžœ
ž˜\Kšžœžœ
žœ˜&Kšžœ˜	—Kšžœ /˜6K˜——K˜K˜—š
Ÿœžœžœžœžœ˜=Kšžœ˜ K˜K˜—š
Ÿœžœ
žœžœžœ˜<Kšžœ˜K˜—K˜šŸœžœ˜/šžœžœ˜Kšœ  ;˜[Kšžœžœ
žœ
˜$Kš
œS˜SKš
œ˜—K˜—K˜šŸœžœ˜0K˜Kšžœžœ
žœ
˜$Kš
œR˜RK˜K™—šŸœžœ˜EK˜Kšžœžœ˜:K˜K™—š
Ÿœžœ
žœžœ3žœ˜pKšŸœA˜HKšžœžœ
žœ
˜!šžœžœ˜Kšžœžœ
žœ˜/K˜K˜&K˜Kš
œZ™Zšžœ,žœžœ
ž˜AKšžœžœ
žœ9˜WKšžœ
˜—Kšžœžœ
žœ"˜@Kšœ(žœ˜CKš
œ2˜2K˜—Kš
œ˜K˜—šŸœžœΟd˜0KšŸœ&˜-šžœžœ˜K˜,Kšžœ!žœ˜8šžœ#žœ
˜*Kš
œ0˜0—Kšœžœ˜+Kš
œ2˜2Kšœ*žœ˜/Kš
œ'™'šžœ,žœžœ
ž˜AKšžœžœ
žœ+˜KKšžœ
˜—Kš
œ(˜(Kš
œ˜—Kš
œ˜—K™K˜BK˜šŸœžœ˜-Kšœ 0˜GK˜K˜K˜8K˜6K˜0K˜.K˜2K˜0K˜(K˜$K˜Kšœ$ 
’ N˜Kšœžœ
˜Kšœžœ
˜K˜—K˜š
Ÿ œžœ
žœ)žœžœ˜dšžœ3žœžœ
ž˜Hšžœ!žœ
žœ
˜,KšžœAžœ
žœ
˜M—Kšžœ
˜—K˜—K˜šŸœžœ˜)šŸœ˜Kš
œ˜Kš
œ˜—Kšžœžœ
žœ
˜!Kšžœ#žœ
žœ
˜1š
žœžœžœžœžœ˜wK˜ Kš
œE˜EKš
œ˜—šžœž˜#Kš
œ%˜%—Kšœžœ˜+Kš
œ2˜2šžœ,žœžœ
ž˜AKšžœžœ
žœ'˜HKšžœ
˜—Kšœ3žœ˜8K˜K™—šŸœžœ˜%Kšœžœ
˜ K˜Kšžœžœ
žœ
˜!šžœ$žœ˜,K˜$š
žœžœžœ
žœ*žœ˜\K˜K˜—K˜—šžœ	ž˜š
œ˜Kšžœžœžœ˜MK˜—š
œ˜Kšžœžœžœ˜MK˜—š
œ˜Kšžœ#žœžœ˜SK˜—š
œ˜Kšžœ#žœžœ˜QK˜—šžœ˜Kšžœ žœ˜9Kš
œ˜——K˜šžœžœ˜šžœžœ
˜šžœ˜Kšžœ+žœ˜DK˜
—šžœ˜Kšžœ‘
œ
žœ˜2K˜——Kš
œ˜—K˜K˜+Kšœžœ	˜+Kšœ žœ˜+K˜šžœ
žœ˜Kšœžœžœžœ˜]Kš
œ ˜ Kšžœ
˜Kš
œ˜—K˜šžœ	žœ˜Kšžœžœ
žœ
˜*Kšžœžœ ˜=K˜K˜Kšœ/žœ˜5K˜—K˜Kšžœ&žœ˜FKšžœ&žœ˜FKšžœ0žœ˜UKšžœ2žœ ˜XKšžœ2žœ ˜XK˜šžœ	žœ<žœžœžœ0žœ˜¬
Kš
œJ˜Jšžœ
žœ
ž˜Kšœ;žœ˜@Kšœ5žœ˜:Kšžœ˜—K˜—K˜K˜—K˜š
Ÿœžœ
žœžœžœ˜>Kšžœ*žœ(˜ZK˜—K˜šŸœžœ=žœ˜YKš
œP™PKšžœžœ&˜FKšžœžœ&˜FKšžœžœ0˜UKšžœ žœ2˜XKšžœ žœ2˜XKšžœžœ ˜9K˜—K˜šŸœžœ˜3šŸœžœ
žœ˜1Kš
œf˜fK˜—Kšœžœ
˜ K˜K˜+Kšœžœ	˜+Kšœ žœ˜+Kšžœ
žœ
žœ
˜šžœ	žœ˜šžœžœ
žœ˜Kšžœžœ#˜9K˜—K˜Kšžœžœ˜CKšžœžœ˜AKšžœžœ  o˜²
šžœ,žœ˜4šžœžœ
ž˜)šœžœ!˜(K˜Q—Kšœžœ˜%Kšžœ˜—K˜—šžœ0žœ4žœ˜ošžœžœ
ž˜-šœžœ˜šœ$žœž˜1K˜/K˜/K˜Kšžœ)˜0—K˜—Kšœžœ˜%Kšžœ˜—K˜—šžœžœ˜&šžœžœ
ž˜.šœžœ˜šœ žœž˜-K˜/K˜/K˜Kšžœ)˜0—K˜—Kšœžœ˜%Kšžœ˜—K˜—K˜—Kšžœ&žœ˜FKšžœ&žœ˜FKšžœ0žœ˜UKšžœ2žœ ˜XKšžœ2žœ ˜XKšžœ žœ˜9Kš
 ™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˜Ξ
K˜—K˜šŸœžœ˜2Kš
œ˜šžœžœ
˜$Kš
œ0˜0—K˜—K˜šŸœžœ˜4K˜—K˜š
Ÿœžœ
žœžœžœ˜Sšžœžœ
žœ'žœžœ
ž˜GKšœžœ˜$Kšžœžœ
žœ˜&Kšœžœ˜Kšžœ
˜—šžœžœ
žœ˜!šŸ
œžœ
žœžœ˜IKšœ,žœ
˜0Kš
œ˜—šžœ3žœžœ
ž˜GKšœžœ˜%Kšžœžœ
žœ˜&Kšœžœ˜Kšžœ
˜—K˜—K˜K˜—šŸœžœ˜9šžœžœ
žœ˜Kš
œ)˜)K˜—K˜—K˜šŸœžœ˜9Kšžœ˜K˜K˜—šŸœžœ˜)Kšžœ ˜&K˜—K˜šŸœžœ
žœ žœ˜Mšžœžœ
žœž˜)Kš
œ˜Kšžœžœ
žœ
˜K˜Kšžœ
˜—K˜K™—šŸœžœ
žœ.˜MKšžœžœ
žœ
˜!Kšžœžœ4˜QKšžœžœ6˜TKšžœžœ*˜HKšžœžœ*˜HKšžœžœ6˜Zšžœ!žœžœ˜FKšžœžœ
žœ ˜9K˜—K˜K™—šŸœžœ
žœ1˜OKšžœžœ
žœ
˜!Kšžœžœ˜3šžœ'žœžœ˜LKšžœžœ
žœ ˜9K˜—K˜K™—šŸœžœ
žœJ˜nšŸœžœ˜/K˜Kš	žœžœ
žœ
žœ $˜>Kš
œ!˜!K˜—Kšžœžœ
žœ
˜!Kš
œ#˜#Kš
œ%˜%Kš
œ˜K˜K™—šŸœžœ
žœ9žœ˜iKš
œ%˜%šžœ!žœžœ˜FKš
œ-˜-K˜—Kš
œ˜K™—šŸœžœ
žœ<žœ˜kKš
œ#˜#šžœ'žœžœ˜LKš
œ-˜-K˜—Kš
œ˜K™—šŸœžœ˜5š
žœžœ
žœžœ-žœ˜VKšœNžœ˜TK˜—K˜K˜—šŸœžœ
žœ˜:Kšœžœ&˜2šžœžœ˜Kšžœžœ
žœ
žœ(˜OK˜
—K˜K™—š
Ÿ
œžœ
žœ*žœžœ˜Tšœžœ˜K˜š
žœžœ
žœžœžœ˜@Kš
œ˜K˜—Kš
œ˜Kš
žœžœ
žœ/žœžœ ˜Kš
œ˜—šžœžœ˜Kšžœžœ
žœ
žœ(˜OK˜
—K˜—K˜šŸœžœ
žœ)žœžœžœ˜ƒ
šŸœžœ˜3Kšžœ
žœ
žœ!˜8Kšžœžœ
žœ"˜@K˜—K˜;Kšœ	žœ.˜:K˜K˜"Kš
œ(˜(K˜K˜—Kšœžœžœ
žœ˜šŸœžœ
žœ+žœ˜RKšœžœžœžœ
žœ
žœžœ
žœ
˜UKš
œ(˜(K˜K˜—šŸœžœ
žœ5˜Mšžœ&žœ
ž˜5Kšœžœ˜!Kšžœ˜#—Kš
œ˜K™—šœžœžœ X˜ˆ
K˜5K˜;K˜9K˜)K˜@—K˜Kšžœ
˜K˜—…—˜ΐΜ‰