DIRECTORY
Atom, BasicTime, BiScrollers, CodeTimer, Convert, Feedback, GGActive, GGBasicTypes, GGControlPanelTypes, GGCoreOps, GGCoreTypes, GGEmbedTypes, GGEvent, GGFont, GGInterfaceTypes, GGModelTypes, GGScrollMonitor, GGSlice, GGState, GGTransform, GGUserInput, GGUserProfile, GGViewerOps, GGWindow, GGWorld, Imager, ImagerTransformation, InputFocus, IO, List, Menus, Process, Real, RealFns, RefTab, Rope, ScreenCoordsTypes, SlackProcess, TIPUser, UserProfile, Vector2, ViewerClasses;

GGUserImpl: CEDAR MONITOR
IMPORTS Atom, BasicTime, BiScrollers, CodeTimer, Convert, Feedback, GGActive, GGCoreOps, GGEvent, GGFont, GGScrollMonitor, GGSlice, GGState, GGTransform, GGUserInput, GGViewerOps, GGWindow, ImagerTransformation, InputFocus, IO, List, Process, RealFns, RefTab, Rope, SlackProcess, UserProfile
EXPORTS GGInterfaceTypes, GGUserInput, GGUserProfile = BEGIN

Camera: TYPE = GGModelTypes.Camera;
ControlsObj: PUBLIC TYPE = GGControlPanelTypes.ControlsObj; -- exported to GGInterfaceTypes
EmbedDataObj: PUBLIC TYPE = GGEmbedTypes.EmbedDataObj; -- exported to GGInterfaceTypes
Event: TYPE = GGCoreTypes.Event;
EventListt: TYPE = GGCoreTypes.EventListt;
External: TYPE = GGUserInput.External;
ExternalRec: TYPE = GGUserInput.ExternalRec;
FeatureData: TYPE = GGModelTypes.FeatureData;
FontData: TYPE = GGModelTypes.FontData;
GGData: TYPE = GGInterfaceTypes.GGData;
Point: TYPE = GGBasicTypes.Point;
RawInputHandlerProc: TYPE = GGUserInput.RawInputHandlerProc;
Scene: TYPE = GGModelTypes.Scene;
SlackHandle: TYPE = SlackProcess.SlackHandle;
Slice: TYPE = GGModelTypes.Slice;
SliceDescriptor: TYPE = GGModelTypes.SliceDescriptor;
Transformation: TYPE = ImagerTransformation.Transformation;
UserInputProc: TYPE = GGUserInput.UserInputProc;
VEC: TYPE = Imager.VEC;
XVEC: TYPE = RECORD [x, y: REAL];
Viewer: TYPE = ViewerClasses.Viewer;

Problem: PUBLIC SIGNAL [msg: Rope.ROPE] = Feedback.Problem;

externalCV: CONDITION;

WaitExternal: PUBLIC ENTRY PROC [External] = {
WAIT externalCV;
};

BroadcastExternal: PUBLIC ENTRY PROC [External] = {
BROADCAST externalCV;
};

NotifyExternal: PUBLIC ENTRY PROC [External] = {
NOTIFY externalCV;
};


EventNotify: PUBLIC PROC [clientData: REF ANY, event: LIST OF REF ANY] = {
ggData: GGData ¬ NARROW[clientData];
ProcessAndQueueEvent[event, ggData];
};

UnQueuedEventNotify: PUBLIC PROC [clientData: REF ANY, event: LIST OF REF ANY] = {
ggData: GGData ~ NARROW[clientData];
atom: ATOM ~ NARROW[event.first];
regEvent: RegisteredEvent ~ FetchAction[atom];
IF regEvent=NIL THEN {
NotYetImplementedMessage[atom, ggData];
}
ELSE {
event ¬ GetAnyArguments[event, regEvent, ggData];
TRUSTED {Process.Detach[FORK regEvent.eventProc[ggData, event] ]; };
};
};

PlayAction: PUBLIC PROC [clientData: REF ANY, event: LIST OF REF ANY] = {
ggData: GGData ¬ NARROW[clientData];
IF
event.first = $Version OR
event.first = $Store OR
event.first = $Save OR
event.first = $ToIP OR
event.first = $ToIPScreen OR
event.first = $ToIPLit OR
event.first = $IPToTioga OR
event.first = $IPToTiogaBordered OR
event.first = $IPToTiogaFit OR
event.first = $IPToTiogaBorderedAndFit OR
event.first = $IPToTiogaAlt OR
event.first = $StuffToTioga OR
event.first = $StuffToFile OR
event.first = $MergeFromTioga OR
event.first = $StuffToTiogaBordered OR
event.first = $StuffToFileAlt OR
event.first = $GrabFromTioga OR
event.first = $StuffToTiogaFit OR
event.first = $GetFromTioga OR
event.first = $StuffToTiogaBorderedAndFit OR
event.first = $MergeFromGargoyle OR
event.first = $StuffToTiogaAlt
THEN RETURN;
ProcessAndQueueEvent[event, ggData];
};

gRawInputHandler: GGUserInput.RawInputHandlerProc ¬ GGActive.ActiveInputHandler;

InputNotify: PUBLIC ViewerClasses.NotifyProc = {
ggData: GGData ~ NARROW[BiScrollers.ClientDataOfViewer[self]];
notify: PROC [input: LIST OF REF] ~ {
InputFocus.SetInputFocus[ggData.controls.actionArea];
ProcessAndQueueEvent[input, ggData];
};
gRawInputHandler[self, ggData, input, notify];
};

BiScrollerInputNotify: PUBLIC PROC [ggData: GGData, event: LIST OF REF] = {
BiScrollerQueue: PROC [event: LIST OF REF ANY, ggData: GGData] = {
first: ATOM ¬ NARROW[event.first];
IF first=$Shift THEN {
vec: REF VEC _ NARROW[event.rest.first]; -- Shift VECTOR
xVec: REF XVEC ¬ NEW[XVEC ¬ [vec.x, vec.y] ]; -- put it in a record different from type VEC
event ¬ LIST[$Shift, xVec];
};
ProcessAndQueueEvent[event, ggData];
};
IF ISTYPE[event.first, LIST OF REF] THEN {
FOR list: LIST OF REF _ event, list.rest UNTIL list = NIL DO
sublist: REF ¬ list.first;
IF ISTYPE[sublist, LIST OF REF] THEN BiScrollerQueue[NARROW[sublist], ggData];
ENDLOOP;
}
ELSE BiScrollerQueue[event, ggData];
};

finishText: LIST OF REF ANY ~ LIST[$SawTextFinish];
finishMouse: LIST OF REF ANY ~ LIST[$SawMouseFinish];

ProcessAndQueueEvent: PROC [event: LIST OF REF ANY, ggData: GGData] = {
IF ggData.embed.beingBorn THEN RETURN; -- don't handle events while the window is being created
WITH event.first SELECT FROM
refChar: REF CHAR => {
myRefChar: REF CHAR ~ NEW[CHAR ¬ refChar­];
event ¬ LIST[$AddChar, myRefChar];
};
atom: ATOM => {
regEvent: RegisteredEvent ~ FetchAction[atom];
IF regEvent=NIL THEN NotYetImplementedMessage[atom, ggData]
ELSE {
atomName: Rope.ROPE ~ Atom.GetPName[atom];
startAction: BOOL ~ Rope.Equal[Rope.Substr[atomName, 0, 5], "Start", TRUE];
IF startAction THEN
QueueInput[ggData, finishText]; -- need this before selection changes
IF regEvent.causeMouseEventsToComplete THEN
QueueInput[ggData, finishMouse];
event ¬ GetAnyArguments[event, regEvent, ggData];
IF atom = $OneScroll THEN {
IF event.rest # NIL THEN
BEGIN
x, y: INTEGER ¬ 0;
WITH event.rest.first SELECT FROM
change: REF Imager.VEC => {
GGScrollMonitor.ConcatToDue[ggData, ImagerTransformation.Translate[[change.x, change.y]] ];
GOTO EasyCase;
};
i: REF INTEGER => x ¬ i­;
ENDCASE;
IF event.rest.rest # NIL THEN {
WITH event.rest.rest.first SELECT FROM
i: REF INTEGER => y ¬ i­;
ENDCASE;
};
GGScrollMonitor.ConcatToDue[ggData, ImagerTransformation.Translate[[x, y]] ];
EXITS
EasyCase => NULL;
END;
}
ELSE IF atom = $OneZoom THEN {
originViewer: Point;
x: INTEGER ¬ 0;
fx, scalar: REAL;
viewport: Imager.Rectangle ¬ GGState.GetViewport[ggData];
originViewer ¬ [viewport.x+(viewport.w/2.0), viewport.y+(viewport.h/2.0)];

IF event.rest # NIL THEN {
WITH event.rest.first SELECT FROM
i: REF INTEGER => x ¬ i­;
ENDCASE;
};
fx ¬ x; -- convert to float
scalar ¬ RealFns.Power[base: 2.0, exponent: fx/50.0]; -- fifty clicks of the track ball gives a factor of two
GGScrollMonitor.ConcatToDue[ggData, GGTransform.ScaleAboutPoint[originViewer, scalar] ];
};
};
};
ENDCASE => ERROR;
QueueInput[ggData, event, NIL];
};

Timestamp: TYPE = REF TimestampObj;
TimestampObj: TYPE = RECORD [
startTime: CARD32
];

timeQueue: BOOL ¬ FALSE;
QueueInput: PROC [ggData: GGData, event: LIST OF REF ANY, optimizeHint: REF ANY ¬ NIL] ~ {
handle: SlackHandle ~ ggData.slackHandle;

GGEvent.PrintAllInput[ggData, event]; -- KAP
IF timeQueue THEN event ¬ List.Nconc1[event, NEW[TimestampObj ¬ [NowInMilliseconds[]]] ]; -- for timing how much time is spent on the queue
SlackProcess.QueueAction[handle, Dispatch, event, ggData, optimizeHint];
};

GetAnyArguments: PROC [event: LIST OF REF ANY, regEvent: RegisteredEvent, ggData: GGData] RETURNS [newEvent: LIST OF REF ANY] = {
atom: ATOM ¬ NARROW[event.first];
SELECT regEvent.argType FROM
none => newEvent ¬ event;
rope => newEvent ¬ CheckForSelectedRope[atom, event];
rope2 => newEvent ¬ CheckForSelectedRope2[atom, event];
refReal => newEvent ¬ CheckForSelectedReal[atom, event];
refInt => newEvent ¬ CheckForSelectedInt[atom, event];
refCard => newEvent ¬ CheckForSelectedCard[atom, event];
refExt => newEvent ¬ CheckForActualExt[atom, event];
ENDCASE => ERROR;
};

RegisterRawInputHandler: PUBLIC PROC [rawInputHandler: RawInputHandlerProc] = {
gRawInputHandler ¬ rawInputHandler;
};

NowInMilliseconds: PROC RETURNS [CARD32] = {
RETURN[(BasicTime.PulsesToMicroseconds[BasicTime.GetClockPulses[]]+500)/1000];
};

PrintUserTrace: PROC [ggData: GGInterfaceTypes.GGData, eventProc: GGUserInput.UserInputProc, event: LIST OF REF ANY] ~ {
procName: Rope.ROPE ¬ "?";
moduleName: Rope.ROPE ¬ "?";
thisArgName: Rope.ROPE;
allArgs: Rope.ROPE;
FOR list: LIST OF REF ANY ¬ event, list.rest UNTIL list = NIL DO
thisArgName ¬ IO.PutFR1["%g", [refAny[list.first]] ];
IF allArgs = NIL THEN allArgs ¬ thisArgName
ELSE allArgs ¬ Rope.Cat[allArgs, ", ", thisArgName];
ENDLOOP;
Feedback.PutFL[ggData.router, oneLiner, $Typescript, "%g.%g[%g]", LIST[[rope[moduleName]], [rope[procName]], [rope[allArgs]]] ];
};

Dispatch: PROC [clientData: REF ANY, inputAction: REF] = {
ggData: GGData ~ NARROW[clientData];
atom: ATOM;
startTime, endTime: CARD32;
startTimeRef: REF;
regEvent: RegisteredEvent;
event: LIST OF REF ¬ NARROW[inputAction];

UpdateCoords: PROC [input: LIST OF REF] RETURNS [o: LIST OF REF] = {
i, l: LIST OF REF;
viewerToClient: Transformation _ GGState.GetBiScrollersTransforms[ggData].viewerToClient;
IF input.first = $AlignFracs OR (input.rest # NIL AND input.rest.first = $AlignFracs) THEN RETURN[input]; -- because BiScrollers uses REF Vector2.VEC for the shift amount
FOR i ¬ input, i.rest WHILE i # NIL DO
l ¬ IF l = NIL THEN o ¬ CONS[i.first, NIL] ELSE l.rest ¬ CONS[i.first, NIL];
WITH l.first SELECT FROM
z: TIPUser.TIPScreenCoords => {
l.first ¬ NEW [Vector2.VEC ¬ viewerToClient.Transform[[z.mouseX, z.mouseY]]];
};
v: REF Vector2.VEC => {
l.first _ NEW [Vector2.VEC _ viewerToClient.Transform[v^]];
};
z: REF XVEC => {
l.first _ NEW [Vector2.VEC _ [z.x, z.y] ];
};
ENDCASE;
ENDLOOP;
};

event ¬ UpdateCoords[event]; -- perform the BiScrollers transform
IF timeQueue THEN {
startTimeRef ¬ List.NthElement[event, -1];
WITH startTimeRef SELECT FROM
timeStamp: Timestamp => {
startTime ¬ timeStamp.startTime;
event ¬ List.DRemove[startTimeRef, event];
endTime ¬ NowInMilliseconds[];
CodeTimer.SetIntMilliseconds[$TimeOnQueue, startTime, endTime, $Gargoyle];
};
ENDCASE;
};

atom ¬ NARROW[event.first];
regEvent ¬ FetchAction[atom];
IF regEvent=NIL THEN NotYetImplementedMessage[atom, ggData]
ELSE {
IF event.first=$Again THEN {
IF NOT GGCoreOps.NoEvents[ggData.lastEvents] THEN {
FOR list: LIST OF Event ¬ ggData.lastEvents.list, list.rest UNTIL list = NIL DO
thisEvent: LIST OF REF ANY ~ list.first;
thisAtom: ATOM ~ NARROW[thisEvent.first];
thisRegEvent: RegisteredEvent ~ FetchAction[thisAtom];
IF thisRegEvent=NIL
THEN NotYetImplementedMessage[thisAtom, ggData]
ELSE thisRegEvent.eventProc[ggData, thisEvent];
ENDLOOP;
}
ELSE {}; -- there is nothing to do again
}
ELSE {
SELECT GetEventClass[atom] FROM
select => ggData.justSawSelect ¬ TRUE;
action => {
IF ggData.justSawSelect THEN {
GGCoreOps.FlushEventListt[ggData.lastEvents];
ggData.justSawSelect ¬ FALSE;
};
GGCoreOps.AppendEvent[event, ggData.lastEvents];
};
suppress => {}; -- $During.  Ignore it.
neutral => {
IF ggData.justSawSelect THEN {} -- this is the during or end of a select operation
ELSE GGCoreOps.AppendEvent[event, ggData.lastEvents];
};
ENDCASE => ERROR;
IF GGUserInput.GetUserTraceOn[] THEN
PrintUserTrace[ggData, regEvent.eventProc, event];
regEvent.eventProc[ggData, event];
};
};
};

EventClass: TYPE = {select, neutral, action, suppress};
GetEventClass: PROC [atom: ATOM] RETURNS [eventClass: EventClass] = {
IF (
atom = $During OR
atom = $GuardUp OR
atom = $MouseUp OR
atom = $AllUp OR
atom = $SawTextFinish OR
atom = $SawMouseFinish
) THEN RETURN [neutral];
IF (
atom = $StartSelectWithBox OR
atom = $StartSelectJoint OR
atom = $StartExtSelectJoint OR
atom = $StartSelectSegment OR
atom = $StartExtSelectSegment OR
atom = $StartSelectTrajectory OR
atom = $StartExtSelectTrajectory OR
atom = $StartSelectTopLevel OR
atom = $StartExtSelectTopLevel OR
atom = $StartExtendSelection OR
atom = $StartDeselectJoint OR
atom = $StartDeselectSegment OR
atom = $StartDeselectTrajectory OR
atom = $StartDeselectTopLevel OR
atom = $CycleSelection OR
atom = $AreaSelectNew OR
atom = $AreaSelectNewAndDelete OR
atom = $SelectAll OR
atom = $AreaSelectDegenerate OR
atom = $SelectCoincident OR
atom = $SelectUnseeableSegs OR
atom = $SelectUnseeableObjs
) THEN RETURN [select];
IF (
atom = $StartCaretPos OR
atom = $StartAdd OR
atom = $StartBox OR
atom = $StartDrag OR
atom = $StartCopyAndDrag OR
atom = $StartAddAndDrag OR
atom = $StartRotate OR
atom = $StartScale OR
atom = $StartSixPoint
) THEN RETURN [action];
IF (
atom = $OneZoom OR
atom = $OneScroll
) THEN RETURN [suppress]; -- added November 4, 1992.  KAP.
RETURN [action];
};

NotYetImplementedMessage: PROC [atom: ATOM, ggData: GGData] = {
Feedback.Append[ggData.router, begin, $Warning, "User event "];
Feedback.Append[ggData.router, middle, $Warning, Atom.GetPName[atom]];
Feedback.Append[ggData.router, end, $Warning, " is not yet implemented"];
};

CheckForSelectedRope: PROC [atom: ATOM, event: LIST OF REF ANY] RETURNS [newAction: LIST OF REF ANY] = {
IF event.rest = NIL THEN { -- interactive call
r: Rope.ROPE ¬ GGViewerOps.GetSelectionContents[];
newAction ¬ LIST[atom, r];
}
ELSE IF ISTYPE[event.rest.first, REF TEXT] THEN { -- TIP table call
newAction ¬ CONS[atom, CONS[Rope.FromRefText[NARROW[event.rest.first]], event.rest.rest]];
}
ELSE newAction ¬ event; -- SessionLog call
};

CheckForSelectedRope2: PROC [atom: ATOM, event: LIST OF REF ANY] RETURNS [newAction: LIST OF REF ANY] = {
IF event.rest = NIL THEN ERROR;
IF event.rest.rest = NIL THEN { -- interactive call
r: Rope.ROPE ¬ GGViewerOps.GetSelectionContents[];
newAction ¬ LIST[atom, event.rest.first, r];
}
ELSE IF ISTYPE[event.rest.rest.first, REF TEXT] THEN { -- TIP table call
newAction ¬ LIST[atom, event.rest.first, Rope.FromRefText[NARROW[event.rest.rest.first]], event.rest.rest.rest];
}
ELSE newAction ¬ event; -- SessionLog call
};


CheckForSelectedReal: PROC [atom: ATOM, event: LIST OF REF ANY] RETURNS [newAction: LIST OF REF ANY] = {
rope: Rope.ROPE;
real: REAL;
IF event.rest = NIL THEN { -- interactive call
rope ¬ GGViewerOps.GetSelectionContents[];
real ¬ Convert.RealFromRope[rope ! Convert.Error => {real ¬ Real.LargestNumber; CONTINUE}];
newAction ¬ LIST[atom, NEW[REAL ¬ real]];
}
ELSE IF ISTYPE[event.rest.first, REF TEXT] THEN { -- TIP table call
rope ¬ Rope.FromRefText[NARROW[event.rest.first]];
real ¬ Convert.RealFromRope[rope ! Convert.Error => {real ¬ Real.LargestNumber; CONTINUE}];
newAction ¬ LIST[atom, NEW[REAL ¬ real]];
}
ELSE newAction ¬ event; -- SessionLog call
};

CheckForSelectedCard: PROC [atom: ATOM, event: LIST OF REF ANY] RETURNS [newAction: LIST OF REF ANY] = {
rope: Rope.ROPE;
card: CARD;
IF event.rest = NIL THEN { -- interactive call
rope ¬ GGViewerOps.GetSelectionContents[];
card ¬ IO.GetCard[IO.RIS[rope] ! IO.EndOfStream, IO.Error => {card ¬ LAST[CARD]; CONTINUE}];
newAction ¬ LIST[atom, NEW[CARD ¬ card]];
}
ELSE IF ISTYPE[event.rest.first, REF CARD] THEN { -- TIP table call or SessionLog call
newAction ¬ event;
}
ELSE ERROR;
};

CheckForSelectedInt: PROC [atom: ATOM, event: LIST OF REF ANY] RETURNS [newAction: LIST OF REF ANY] = {
rope: Rope.ROPE;
int: INT;
IF event.rest = NIL THEN { -- interactive call
rope ¬ GGViewerOps.GetSelectionContents[];
int ¬ IO.GetInt[IO.RIS[rope] ! IO.EndOfStream, IO.Error => {int ¬ LAST[INT]; CONTINUE}];
newAction ¬ LIST[atom, NEW[INT ¬ int]];
}
ELSE {
 WITH event.rest.first SELECT FROM
int: REF INT => newAction ¬ event; -- TIP table call or SessionLog call
card: REF CARD => newAction ¬ List.Append[LIST[atom, NEW[INT ¬ card­]], event.rest.rest]; -- type coersion
ENDCASE => ERROR;
};
};

CheckForActualExt: PROC [atom: ATOM, event: LIST OF REF ANY] RETURNS [newAction: LIST OF REF ANY] = {
IF event.rest=NIL OR NOT ISTYPE[event.rest.first, REF GGUserInput.ExternalRec] THEN ERROR;
newAction ¬ event;
};

RegisteredEvent: TYPE = REF RegisteredEventObj;
RegisteredEventObj: TYPE = RECORD [
eventProc: UserInputProc,
argType: GGUserInput.ArgumentType,
causeMouseEventsToComplete: BOOL
];

RegisterAction: PUBLIC PROC [atom: ATOM, eventProc: UserInputProc, argType: GGUserInput.ArgumentType, causeMouseEventsToComplete: BOOL ¬ TRUE, ensureUnique: BOOL ¬ TRUE] = {
regEvent: RegisteredEvent ¬ NEW[RegisteredEventObj ¬ [eventProc, argType, causeMouseEventsToComplete]];
justInserted: BOOL ¬ RefTab.Insert[eventTable, atom, regEvent];
IF NOT justInserted THEN
[] ¬ RefTab.Replace[eventTable, atom, regEvent];
};

FetchAction: PROC [atom: ATOM] RETURNS [RegisteredEvent] ~ {
WITH RefTab.Fetch[eventTable, atom].val SELECT FROM
regEvent: RegisteredEvent => RETURN[regEvent];
ENDCASE => RETURN[NIL];
};

LookAtProfile: PUBLIC UserProfile.ProfileChangedProc = {
gravExtent: REAL; -- in inches
defaultHistorySize: INT;
heuristics: BOOL ¬ UserProfile.Boolean[key: "Gargoyle.Heuristics", default: FALSE];
quickClickMode: BOOL  ¬ UserProfile.Boolean[key: "Gargoyle.QuickClickEnable", default: FALSE];
useLatestIPVersion: BOOL ¬ UserProfile.Boolean[key: "Gargoyle.UseLatestIPVersion", default: FALSE];
autoOpenTypescript: BOOL ¬ UserProfile.Boolean[key: "Gargoyle.AutoOpenTypescript", default: TRUE];
autoOpenHistory: BOOL ¬ UserProfile.Boolean[key: "Gargoyle.AutoOpenHistory", default: TRUE];
autoScriptingOn: BOOL ¬ UserProfile.Boolean[key: "Gargoyle.AutoScriptingOn", default: FALSE];
separateControlPanel: BOOL ¬ UserProfile.Boolean[key: "Gargoyle.SeparateControlPanel", default: FALSE];
defaultIncludeIPBy: Rope.ROPE ¬ UserProfile.Token[key: "Gargoyle.DefaultIncludeIPBy", default: "Reference"];
holdThatTiger: BOOL ¬ UserProfile.Boolean[key: "Gargoyle.HoldThatTiger", default: FALSE];
newBoxesUnfilled: BOOL ¬ UserProfile.Boolean[key: "Gargoyle.NewBoxesUnfilled", default: FALSE];
defaultHistorySize ¬ Convert.IntFromRope[UserProfile.Token[key: "Gargoyle.DefaultHistorySize", default: "40"]
! Convert.Error => IF reason = syntax THEN {defaultHistorySize ¬ -1; CONTINUE;} ELSE REJECT];
gravExtent ¬ Convert.RealFromRope[UserProfile.Token[key: "Gargoyle.GravityExtent", default: "-1.0"]
! Convert.Error => IF reason = syntax THEN {gravExtent ¬ -1.0; CONTINUE;} ELSE REJECT];
IF gravExtent=-1.0 THEN gravExtent ¬ 25.0/72.0;
IF defaultHistorySize<1 THEN defaultHistorySize ¬ IF defaultHistorySize=0 THEN 1 ELSE 40;
SetDefaultHeuristics[on: heuristics];
SetDefaultGravityExtent[inches: gravExtent];
GGState.SetQuickClickMode[quickClickMode];
SetDefaultUseLatestIPVersion[useLatestIPVersion];
SetAutoOpenTypescript[autoOpenTypescript];
SetAutoOpenHistory[autoOpenHistory];
SetDefaultHistorySize[defaultHistorySize];
SetAutoScriptingOn[autoScriptingOn];
SetSeparateControlPanel[separateControlPanel];
SetHoldThatTiger[holdThatTiger];
SetNewBoxesUnfilled[newBoxesUnfilled];
SetDefaultIncludeIPByValue[Rope.Equal[defaultIncludeIPBy, "Value", FALSE]];
BEGIN -- set the default default font
description: Rope.ROPE ¬ UserProfile.Token[key: "Gargoyle.DefaultDefaultFont", default: NIL];
descriptionStream: IO.STREAM;
defaultFont: FontData;
IF description = NIL THEN
description ¬ "xerox/xc1-2-2/helvetica [r1: 0.0 s: [10.0 10.0] r2: 0.0] 1.0 1.0";
descriptionStream ¬ IO.RIS[description];
defaultFont ¬ GGFont.ParseFontData[inStream: descriptionStream, literalP: TRUE, transformP: TRUE, storedSizeP: TRUE, designSizeP: TRUE];
SetDefaultDefaultFont[defaultFont];
END;
IF reason#firstTime THEN GGWindow.InitIcons[]; -- don't do this on first registering this proc
}; 


MasterData: TYPE = REF MasterDataObj;
MasterDataObj: TYPE = RECORD [
defaultGravityExtent: REAL ¬ 25.0, -- in screen dots
defaultHeuristics: BOOL ¬ TRUE,
objectsBeingCopied: LIST OF REF ANY, -- for copying objects from viewer to viewer,
defaultDefaultFont: FontData,
autoOpenTypescript: BOOL ¬ TRUE,
autoOpenHistory: BOOL ¬ TRUE,
defaultHistorySize: INT ¬ 40,
autoScriptingOn: BOOL ¬ TRUE,
separateControlPanel: BOOL ¬ FALSE,
defaultIncludeIPByValue: BOOL ¬ FALSE,
holdThatTiger: BOOL ¬ FALSE,
newBoxesUnfilled: BOOL ¬ FALSE,
turboOn: BOOL ¬ FALSE,
userTraceOn: BOOL ¬ FALSE
];

SetUserTraceOn: PUBLIC PROC [on: BOOL] = {
masterData.userTraceOn ¬ on;
};

GetUserTraceOn: PUBLIC PROC RETURNS [on: BOOL] = {
on ¬ masterData.userTraceOn;
};

SetDefaultHeuristics: PUBLIC PROC [on: BOOL] = {
masterData.defaultHeuristics ¬ on;
};

GetDefaultHeuristics: PUBLIC PROC RETURNS [on: BOOL] = {
on ¬ masterData.defaultHeuristics;
};
SetDefaultGravityExtent: PUBLIC PROC [inches: REAL] = {
masterData.defaultGravityExtent ¬ inches*72.0;
};

GetDefaultGravityExtent: PUBLIC PROC RETURNS [screenDots: REAL] = {
screenDots ¬ masterData.defaultGravityExtent;
};

SetDefaultUseLatestIPVersion: PUBLIC PROC [useLatestIPVersion: BOOL] = {
GGSlice.SetDefaultUseLatestIPVersion[useLatestIPVersion];
};

GetDefaultUseLatestIPVersion: PUBLIC PROC [] RETURNS [useLatestIPVersion: BOOL] = {
RETURN[GGSlice.GetDefaultUseLatestIPVersion[]];
};
SetDefaultDefaultFont: PUBLIC PROC [font: FontData] = {
masterData.defaultDefaultFont ¬ font;
};

GetDefaultDefaultFont: PUBLIC PROC RETURNS [font: FontData] = {
font ¬ masterData.defaultDefaultFont;
};

SetAutoOpenTypescript: PUBLIC PROC [autoOpenTypescript: BOOL] = {
masterData.autoOpenTypescript ¬ autoOpenTypescript;
};

GetAutoOpenTypescript: PUBLIC PROC [] RETURNS [autoOpenTypescript: BOOL] = {
autoOpenTypescript ¬ masterData.autoOpenTypescript;
};

SetAutoOpenHistory: PUBLIC PROC [autoOpenHistory: BOOL] = {
masterData.autoOpenHistory ¬ autoOpenHistory;
};

GetAutoOpenHistory: PUBLIC PROC [] RETURNS [autoOpenHistory: BOOL] = {
autoOpenHistory ¬ masterData.autoOpenHistory;
};

SetDefaultHistorySize: PUBLIC PROC [defaultHistorySize: INT] = {
masterData.defaultHistorySize ¬ defaultHistorySize;
};

GetDefaultHistorySize: PUBLIC PROC RETURNS [defaultHistorySize: INT] = {
defaultHistorySize ¬ masterData.defaultHistorySize;
};

SetAutoScriptingOn: PUBLIC PROC [autoScriptingOn: BOOL] = {
masterData.autoScriptingOn ¬ autoScriptingOn;
};

GetAutoScriptingOn: PUBLIC PROC [] RETURNS [autoScriptingOn: BOOL] = {
autoScriptingOn ¬ masterData.autoScriptingOn;
};

SetSeparateControlPanel: PUBLIC PROC [separateControlPanel: BOOL] = {
masterData.separateControlPanel ¬ separateControlPanel;
};

GetSeparateControlPanel: PUBLIC PROC [] RETURNS [separateControlPanel: BOOL] = {
separateControlPanel ¬ masterData.separateControlPanel;
};

SetDefaultIncludeIPByValue: PUBLIC PROC [defaultIncludeIPByValue: BOOL] = {
masterData.defaultIncludeIPByValue ¬ defaultIncludeIPByValue;
};

GetDefaultIncludeIPByValue: PUBLIC PROC [] RETURNS [defaultIncludeIPByValue: BOOL] = {
defaultIncludeIPByValue ¬ masterData.defaultIncludeIPByValue;
};

SetHoldThatTiger: PUBLIC PROC [holdThatTiger: BOOL] = {
masterData.holdThatTiger ¬ holdThatTiger;
};

GetHoldThatTiger: PUBLIC PROC [] RETURNS [holdThatTiger: BOOL] = {
holdThatTiger ¬ masterData.holdThatTiger;
};

SetNewBoxesUnfilled: PUBLIC PROC [newBoxesUnfilled: BOOL] = {
masterData.newBoxesUnfilled ¬ newBoxesUnfilled;
};

GetNewBoxesUnfilled: PUBLIC PROC [] RETURNS [newBoxesUnfilled: BOOL] = {
newBoxesUnfilled ¬ masterData.newBoxesUnfilled;
};

masterData: MasterData;
eventTable: RefTab.Ref;

masterData ¬ NEW[MasterDataObj];
UserProfile.CallWhenProfileChanges[LookAtProfile];
eventTable ¬ RefTab.Create[255];


END.
δGGUserImpl.mesa
Copyright Σ 1986, 1989, 1991, 1992 by Xerox Corporation.  All rights reserved.
Contents:  Routines for reading the Gargoyle entries in the user profile and setting Gargoyle options.  Also, procedures which handle user actions (menu buttons and mouse events).
Kurlander August 24, 1986 1:00:26 pm PDT
Goodisman, August 11, 1989 4:59:38 pm PDT
Pier, November 4, 1992 3:36 pm PST
Bier,  August 20, 1993 7:12 pm PDT
Doug Wyatt, April 20, 1992 12:24 pm PDT

ExternalRec is used by applications external to Gargoyle to return results to those applications.  Clients should call EventNotify with a registered external proc name and a REF to an ExternalRec on a two-element event list.  Client should then call WaitExternal in a loop checking their particular "valid" bit. Gargoyle completes the desired action, puts results in "results", and sets "valid" to TRUE.  Gargoyle external procs will call BroadcastExternal when actions complete.
Before the Queue (done by InputNotifier, Menu Process or Playback Process)
From Buttons and Menus
Used by several menu classes as the procedure to call when a menu click occurs.
Used by several menu classes as the procedure to call when a menu click occurs.
From Playback Scripts
Regular Input Notification

Called by the TIP table machinery when an action is received from mouse or keyboard.  Self is an ActionArea.
Problem: If a gargoyle scene changes from active to inactive due to a queued action, the length of the queue will determine when Gargoyle gets the input focus.
An action has been received from BiScroller (e.g. from the ScrollBar).
The event will be in one of two forms:
1) LIST[REF CHAR].
2) LIST[ATOM, ... ].
Need our own copy of the ref and char, because the system reuses the storage.
DKW: Yecch! Maybe the RegisteredEvent could contain this information.
Feedback.PutFL[ggData.router, oneLiner, $Typescript, "[%g %g: %g] ", LIST[ [real[originViewer.x]], [real[originViewer.y]], [real[scalar]] ]];
DKW: REF VEC values come from Biscrollers, which treats them as immutable, so the following is unnecessary.  Maybe this code is left over from pre-Biscrollers days; TIPScreenCoords values straight from TIP are mutable, and would have to be copied.
none => {
tail: LIST OF REF ANY;
Copy all of the VECs since the TIP table reuses the storage.
tail _ newEvent _ CONS[event.first, NIL];
FOR list: LIST OF REF ANY _ event.rest, list.rest UNTIL list = NIL DO
IF ISTYPE[list.first, REF VEC] THEN {
mousePlace: REF VEC _ NARROW[list.first];
tail.rest _ CONS[NEW[VEC _ [mousePlace.x, mousePlace.y]], NIL];
}
ELSE tail.rest _ CONS[list.first, NIL];
tail _ tail.rest;
ENDLOOP;
};
After the Queue (Done by SlackProcess)

procTV: AMTypes.TV _ AMBridge.TVForProc[eventProc];
moduleTV: AMTypes.TV _ AMTypes.GlobalParent[procTV];
procName: Rope.ROPE _ AMTypes.TVToName[procTV];
moduleName: Rope.ROPE _ AMTypes.TVToName[moduleTV];
IF ( -- oops.  You can't suppress all of the Durings.  You must not suppress the last one for a given operation.  Yuk.
atom = $During
) THEN RETURN [suppress];
Utility Routines

Expect a rope as the second argument.
If the event has already been registered and ensureUnique is true, an error will be signalled.  If the event has been registered and ensureUnique is FALSE, the action will be reregistered.
IF ensureUnique THEN SIGNAL Problem[msg: IO.PutFR1["Event %g was already registered in Gargoyle's event table.", [rope[Atom.GetPName[atom]]]]]
ELSE [] ¬ RefTab.Replace[eventTable, atom, regEvent]; -- register again
GGUserProfile
[reason: UserProfile.ProfileChangeReason]
formerly "xerox/pressfonts/helvetica-mrr [r1: 0.0 s: [10.0 10.0] r2: 0.0] 1.0 1.0"
No matter how many Gargoyle viewers are present, there is only one MasterData.
When a new viewer is created, should heuristics be turned on?
When a new viewer is created, should heuristics be turned on?

When a new viewer is created, how strong should its gravity be?
When a new viewer is created, how strong should its gravity be?

interval _ CodeTimer.CreateInterval[$UserInput];
CodeTimer.AddInt[interval, $Gargoyle];
Κ–
(cedarcode) style•NewlineDelimiter

˜
codeš
œ™Kšœ
Οe
œC™NKšΟnœ«
™³
Kšœ%Οk™(K™)K™"K™"K™'K™—š
Ÿ	˜	JšœΦŸœƒ
˜ΫK˜—šž
œŸœ
Ÿ˜JšŸœΩ
ŸœA˜£KšŸœ0Ÿ˜<K˜KšœŸœ˜#Kšœ
Ÿœ
Ÿœ$Οc˜[KšœŸœ
Ÿœ ˜VKšœŸœ˜ KšœŸœ˜*K•StartOfExpansion- -- [reason: UserProfile.ProfileChangeReason]šœ
Ÿœ˜&Kšœ
Ÿœ˜,Kšœ
Ÿœ˜-K–- -- [reason: UserProfile.ProfileChangeReason]šœ
Ÿœ˜'KšœŸœ˜'KšœŸœ˜!KšœŸœ#˜<KšœŸœ˜!Kšœ
Ÿœ˜-KšœŸœ˜!KšœŸœ ˜5KšœŸœ'˜;KšœŸœ˜0KšŸœŸœ
Ÿœ
˜KšŸœŸœŸœŸœ˜!KšœŸœ˜$—K˜šžœŸœ
ŸœŸœ˜;K˜—šœŸ	œ
˜Kšœϊ
žœ±
žœ™ίK˜—šžœŸœ˜.KšŸœ˜K˜K˜—šžœŸœ˜3KšŸ	œ˜K˜K˜—šžœŸœ˜0KšŸœ˜K˜—K˜Kš
œJ™JK˜K™šžœŸœŸœ
Ÿœ	Ÿœ
Ÿœ
Ÿœ
Ÿœ˜JKšœŸœ
˜$K™OKš
œ$˜$Kš
œ˜K˜—šžœŸœŸœ
Ÿœ	Ÿœ
Ÿœ
Ÿœ
Ÿœ˜RK™OKšœŸœ
˜$KšœŸœŸœ˜!Kš
œ.˜.šŸœ
Ÿœ
Ÿœ˜Kš
œ'˜'K˜
—šŸœ˜K˜1KšŸœΠbkœ(˜DK˜—Kš
œ˜—K˜K™šž
œŸœŸœ
Ÿœ	Ÿœ
Ÿœ
Ÿœ
Ÿœ˜IKšœŸœ
˜$š
Ÿ˜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™˜PK˜—šžœŸœ˜0KšœŸœ[™lKšœŸœ'˜>š	œŸœ	Ÿœ
Ÿœ
Ÿœ˜%šœΟb
œ˜5Kšžœ˜
™Ÿ
—Kš
œ$˜$K˜—K˜.K˜K˜—šžœŸœ
ŸœŸœ
Ÿœ
Ÿœ˜KKš
œF™FšžœŸœ	Ÿœ
Ÿœ
Ÿœ
Ÿœ˜BKšœŸœŸœ˜"šŸœŸœ˜KšœŸœ
ŸœŸœ ˜8Kš
œŸœ
ŸœŸœ
Ÿœ -˜[KšœŸœ˜K˜—J˜$K˜—šŸœ
ŸœŸœ
Ÿœ
ŸœŸœ˜*š
ŸœŸœ
Ÿœ
ŸœŸœŸœ
Ÿ˜<Jšœ	Ÿœ˜JšŸœ
Ÿœ
Ÿœ
Ÿœ
ŸœŸœŸœ˜NJšŸœ
˜—K˜
—KšŸœ ˜$K˜K˜—KšœŸœ
Ÿœ
Ÿœ
ŸœŸœ˜3šœ
Ÿœ
Ÿœ
Ÿœ
ŸœŸœ˜5K˜—šžœŸœ	Ÿœ
Ÿœ
Ÿœ
Ÿœ˜G™&JšœŸœ
Ÿœ
Ÿœ™JšœŸœ
Ÿœ™—KšŸœŸœ
Ÿœ 8˜_šŸœ
Ÿœ
Ÿ˜šœ	Ÿœ
Ÿœ˜Kš
œM™MKš	œŸœ
ŸœŸœ
Ÿœ
˜+KšœŸœ˜"K˜—šœŸœ˜Kš
œ.˜.KšŸœ
Ÿœ
Ÿœ'˜;šŸœ˜KšœŸœ˜*šœ
Ÿœ4Ÿœ˜KKš
œE™E—šŸœ
Ÿ˜Kšœ  %˜E—šŸœ%Ÿ˜+Kš
œ ˜ —K˜1šŸœŸœ˜KšŸœŸœ
Ÿ˜š
Ÿ˜KšœŸœ˜šŸœŸœ
Ÿ˜!šœŸœŸœ˜Kšœžœ@˜[KšŸœ
˜K˜—KšœŸœ
Ÿœ˜KšŸœ
˜—šŸœŸœ
Ÿœ˜šŸœŸœ
Ÿ˜&KšœŸœ
Ÿœ˜KšŸœ
˜—K˜—Kšœžœ2˜Mš
Ÿ˜KšœŸœ
˜—KšŸœ
˜—K˜
—šŸœ
ŸœŸœ˜KšœΟuœ˜KšœŸœ˜KšœŸœ
˜K˜9Kšœ£œ>˜JK˜šŸœŸœ
Ÿœ˜šŸœŸœ
Ÿ˜!KšœŸœ
Ÿœ˜KšŸœ
˜—K˜—Kšœ ˜Kšœ6 7˜mKšœEŸœ£œ£œ™
Kšœžœ+£œ˜XK˜—K˜—K˜—KšŸœŸœ
˜—KšœŸœ˜K˜K˜—KšœŸœŸœ˜#šœŸœŸœ˜KšœŸ˜K˜K˜—KšœŸœŸœ
˜šž
œŸœŸœ
Ÿœ
Ÿœ
ŸœŸœ
ŸœŸœ˜ZKš
œ)˜)K˜Kšœ& ˜,KšŸœŸœŸœ* 1˜‹
Kš
œH˜HK˜K˜—šžœŸœ	Ÿœ
Ÿœ
Ÿœ
Ÿœ-ŸœŸœ
Ÿœ
Ÿœ
Ÿœ˜
KšœŸœŸœ˜!šŸœŸ˜˜KšœŸœΒ
œ&™χ
—™	Kš	œŸœ
Ÿœ
Ÿœ
Ÿœ
™K™<KšœŸœŸœ™)šŸœŸœ
Ÿœ
Ÿœ
ŸœŸœŸœ
Ÿ™Eš	Ÿœ
Ÿœ
Ÿœ
Ÿœ
Ÿ™%KšœŸœ
ŸœŸœ
™)Kš	œŸœ
Ÿœ
Ÿœ"Ÿœ™?K™
—KšŸœ
Ÿœ
Ÿœ™'Kš
œ™KšŸœ
™—K™—K˜5K˜7K˜8K˜6K˜8K˜4KšŸœŸœ
˜—K˜—K˜šžœŸœ
Ÿœ+˜OK˜#K˜K˜—Kš
œ&™&K™šžœŸœ
ŸœŸœ˜,KšŸœH˜NK˜K˜—šžœŸœPŸœ
Ÿœ
Ÿœ
Ÿœ˜xKšœŸœ!™3KšœŸœ ™4KšœŸœ™/KšœŸœ™3KšœŸœ˜KšœŸœ˜KšœŸœ
˜KšœŸœ
˜šŸœŸœ
Ÿœ
Ÿœ
ŸœŸœŸœ
Ÿ˜@KšœŸœ%˜5KšŸœŸœ
Ÿœ˜+KšŸœ0˜4KšŸœ
˜—KšœBŸœ:˜€
K˜K˜—•	CharProps$
Postfix0.83333 1 0.7 textColor2š
ΠlnœŸœŸœ
ŸœŸœ˜:KšœŸœ
˜$KšœŸœ
˜KšœŸœ
˜KšœŸœ
˜Kš
œ˜Kš	œŸœ
Ÿœ
ŸœŸœ˜)K˜šžœŸœ	Ÿœ
Ÿœ
ŸœŸœŸœ
Ÿœ
Ÿœ˜DKšœŸœ
Ÿœ
Ÿœ
˜Kš
œY˜YKš
ŸœŸœŸœ
Ÿœ!Ÿœ
Ÿœ	 @˜ͺ
šŸœŸœŸœ
Ÿ˜&KšœŸœŸœ
ŸœŸœ
ŸœŸœ
Ÿœ
Ÿœ˜LšŸœ	Ÿœ
Ÿ˜˜Kšœ
Ÿœ
Ÿœ3˜MKš
œ˜—šœŸœ	Ÿœ˜Kšœ
Ÿœ
Ÿœ!˜;K˜—šœŸœ
Ÿœ˜Kšœ
Ÿœ
Ÿœ˜*K˜—KšŸœ
˜—KšŸœ
˜—K˜K˜—Kšœ $˜AšŸœŸœ˜K˜*šŸœŸœ
Ÿ˜š
œ˜K˜ K˜*K˜K˜JK˜—KšŸœ
˜—K˜—K˜KšœŸœ˜K˜KšŸœ
Ÿœ
Ÿœ'˜;šŸœ˜šŸœŸ˜šŸœ
Ÿœ'Ÿœ˜3šŸœŸœ
Ÿœ+ŸœŸœ
Ÿ˜OKš	œŸœ
Ÿœ
Ÿœ
Ÿœ˜(Kšœ
ŸœŸœ˜)Kš
œ6˜6šŸœŸ˜KšŸœ+˜/KšŸœ+˜/—KšŸœ
˜—Kš
œ
˜
—KšŸœ ˜(K˜
—šŸœ˜šŸœŸ˜Kšœ!Ÿœ
˜&˜šŸœŸœ˜Kš
œ-˜-KšœŸœ
˜K˜—Kš
œ0˜0K˜—Kšœ ˜'˜KšŸœŸœ 2˜RKšŸœ1˜5K˜—KšŸœŸœ
˜—šŸœŸ˜$Kš
œ2˜2—Kš’œ˜"K˜—K˜—K˜K˜—KšœŸœ'˜7šž
œŸœŸœŸœ˜EšŸœt™vJš
œ™JšœŸœ
Ÿœ™—šŸœ˜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š
œ˜KšœŸœ
Ÿœ
˜—šŸœ˜KšœŸ˜KšœŸ˜KšœŸ˜KšœŸ˜KšœŸ˜KšœŸ˜KšœŸ˜KšœŸ˜Kš
œ˜KšœŸœ
Ÿœ
˜—šŸœ˜KšœŸ˜K˜KšœŸœ
Ÿœ
  ˜:—KšŸœ
˜K˜—K˜K™K™šžœŸœŸœ˜?Kš
œ?˜?Kš
œF˜FKš
œI˜IK˜K˜—šžœŸœŸœ	Ÿœ
Ÿœ
Ÿœ
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ
Ÿœ˜hšŸœŸœ
Ÿœ ˜.KšœŸœ%˜2KšœŸœ
˜Kš
œ
˜
—š
Ÿœ
Ÿœ
ŸœŸœ
ŸœŸœ ˜CKšœŸœŸœŸœ'˜ZKš
œ
˜
—KšŸœ ˜*K˜K˜—šžœŸœŸœ	Ÿœ
Ÿœ
Ÿœ
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ
Ÿœ˜iK™%KšŸœŸœ
Ÿœ
Ÿœ
˜šŸœŸœ
Ÿœ ˜3KšœŸœ%˜2KšœŸœ˜,Kš
œ
˜
—š
Ÿœ
Ÿœ
ŸœŸœ
ŸœŸœ ˜HKšœŸœ*Ÿœ0˜pKš
œ
˜
—KšŸœ ˜*K˜K˜K˜—šžœŸœŸœ	Ÿœ
Ÿœ
Ÿœ
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ
Ÿœ˜hKšœŸœ
˜KšœŸœ
˜šŸœŸœ
Ÿœ ˜.K˜*KšœPŸœ˜[KšœŸœŸœ
Ÿœ
˜)Kš
œ
˜
—š
Ÿœ
Ÿœ
ŸœŸœ
ŸœŸœ ˜CKšœŸœ˜2KšœPŸœ˜[KšœŸœŸœ
Ÿœ
˜)Kš
œ
˜
—KšŸœ ˜*K˜K˜—šžœŸœŸœ	Ÿœ
Ÿœ
Ÿœ
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ
Ÿœ˜hKšœŸœ
˜KšœŸœ
˜šŸœŸœ
Ÿœ ˜.K˜*KšœŸœ	Ÿœ
Ÿœ	ŸœŸœŸœ
ŸœŸœ˜\KšœŸœŸœ
Ÿœ
˜)Kš
œ
˜
—š
Ÿœ
Ÿœ
ŸœŸœ
ŸœŸœ $˜VK˜Kš
œ
˜
—KšŸœ
Ÿœ
˜K˜K˜—šžœŸœŸœ	Ÿœ
Ÿœ
Ÿœ
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ
Ÿœ˜gKšœŸœ
˜KšœŸœ
˜	šŸœŸœ
Ÿœ ˜.K˜*KšœŸœŸœ
Ÿœ	ŸœŸœŸœ
ŸœŸœ˜XKšœŸœŸœ
Ÿœ	˜'Kš
œ
˜
—šŸœ˜šœ
ŸœŸœ
Ÿ˜"KšœŸœ
Ÿœ $˜GKšœŸœ
ŸœŸœŸœ
Ÿœ ˜jKšŸœŸœ
˜—K˜—K˜K˜—šžœŸœŸœ	Ÿœ
Ÿœ
Ÿœ
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ
Ÿœ˜eKšŸœŸœ
Ÿœ
Ÿœ
ŸœŸœŸœ
Ÿœ
˜ZK˜K˜—K˜KšœŸœŸœ˜/šœŸœŸœ˜#Kš
œ˜Kš
œ"˜"KšœŸ˜ K˜—K˜šžœŸœ
ŸœŸœ[ŸœŸœŸœŸœ˜­
Kšœ•
Ÿœ"™Ό
KšœŸœH˜gKšœŸœ-˜?šŸœ
ŸœŸ˜KšŸœŸœ
ŸœŸœc™Ž
KšŸœ2 ™GK˜0—K˜—K–- -- [reason: UserProfile.ProfileChangeReason]˜šžœŸœŸœŸœ˜<šŸœ$Ÿœ
Ÿ˜3KšœŸœ˜.KšŸœŸœ
Ÿœ˜—K˜—K˜Kš
œ
™
šž
œŸœ#˜8Kš
œ)™)KšœŸœ ˜KšœŸœ
˜KšœŸœ<Ÿœ˜SK–$[key: 
ROPE, default: 
ROPE _ NIL]šœŸœCŸœ˜^KšœŸœDŸœ˜cKšœŸœDŸœ˜bKšœŸœAŸœ˜\KšœŸœAŸœ˜]KšœŸœFŸœ˜gKšœŸœO˜lKšœŸœ?Ÿœ˜YKšœŸœBŸœ˜_˜mKšœŸœŸœŸœŸœ
Ÿœ˜]—˜cKšœŸœŸœŸœŸœ
Ÿœ˜W—KšŸœŸœ˜/Kš
ŸœŸœŸœŸœŸœ˜YKšœ’
œ˜%Kšœ ’
œ˜,Kšœ’œ˜*Kš
œ1˜1Kš
œ*˜*Kš
œ$˜$Kš
œ*˜*Kš
œ$˜$Kš
œ.˜.Kš
œ ˜ Kš
œ&˜&KšœCŸœ˜KšŸœ
 ˜%KšœŸœBŸœ˜]KšœŸœ
Ÿœ
˜K˜šŸœŸœ
Ÿ˜K˜QKš
œR™R—KšœŸœ
Ÿœ˜(Kš	œJŸœŸœŸœŸœ˜ˆ
Kš
œ#˜#KšŸœ
˜—KšŸœŸœ /˜^Kš
œ˜—K˜Kš
œN™NK˜Kš’
œŸœŸœ˜%š’
œŸœŸœ˜KšœŸœ	 ˜4KšœŸœŸœ
˜Kš
œŸœ
Ÿœ
Ÿœ
Ÿœ -˜RK˜KšœŸœŸœ
˜ KšœŸœŸœ
˜KšœŸœ˜KšœŸœŸœ
˜KšœŸœ
Ÿ˜#KšœŸœŸœ
˜&KšœŸœŸœ
˜KšœŸœŸ˜Kšœ	ŸœŸœ
˜Kšœ
ŸœŸ˜K˜—K˜šžœŸœ
ŸœŸœ˜*K˜K˜K˜—š
žœŸœ
Ÿœ
ŸœŸœ˜2K˜K˜K˜—šžœŸœ
ŸœŸœ˜0K™=K˜"K˜K˜—š
žœŸœ
Ÿœ
ŸœŸœ˜8K™=K˜"K˜K™—šžœŸœ
Ÿœ
Ÿœ˜7K™?K˜.K˜K˜—šžœŸœ
Ÿœ
Ÿœ’
œŸœ˜CK™?K˜-K˜K˜—šžœŸœ
ŸœŸœ˜HKš
œ9˜9K˜K˜—š
žœŸœ
ŸœŸœŸœ˜SKšŸœ)˜/K˜K™—šžœŸœ
Ÿœ˜7K˜%K˜K˜—šžœŸœ
Ÿœ
Ÿœ˜?K˜%K˜K˜—šžœŸœ
ŸœŸœ˜AK˜3K˜K˜—š
žœŸœ
ŸœŸœŸœ˜LK˜3K˜K˜—šžœŸœ
ŸœŸœ˜;K˜-K˜K˜—š
žœŸœ
ŸœŸœŸœ˜FK˜-K˜K˜—šžœŸœŸœ˜@K˜3K˜K˜—šžœŸœ
ŸœŸœ˜HK˜3K˜—K˜šžœŸœ
ŸœŸœ˜;K˜-K˜K˜—š
žœŸœ
ŸœŸœŸœ˜FK˜-K˜K˜—šžœŸœ
ŸœŸœ˜EK˜7K˜K˜—š
žœŸœ
ŸœŸœŸœ˜PK˜7K˜K˜—šžœŸœ
ŸœŸœ˜KK˜=K˜K˜—š
žœŸœ
ŸœŸœŸœ˜VK˜=K˜—K˜šžœŸœ
ŸœŸœ˜7K˜)K˜K˜—š
žœŸœ
ŸœŸœŸœ˜BK˜)K˜—K˜šžœŸœ
ŸœŸœ˜=K˜/K˜K˜—š
žœŸœ
ŸœŸœŸœ˜HK˜/K˜—K˜Kš
œ˜K˜K˜Kšœ
Ÿœ˜ Kš
œ2˜2K˜ K˜K™0K™&K˜KšŸœ
˜—…—Y’ˆŽ