DIRECTORY
Angles2d, AtomButtons, AtomButtonsTypes, Basics, Feedback, GraphicsButton, Imager, IO, Real, RealFns, Rope, SV2d, SVInterfaceTypes, SVModelTypes, SVSceneTypes, SVState, SVViewerTools, SVWindow;

SVStateImpl: CEDAR PROGRAM
IMPORTS Angles2d, AtomButtons, Feedback, GraphicsButton, IO, Real, RealFns, Rope, SVViewerTools, SVWindow
EXPORTS SVState
 =
BEGIN

DisplayStyle: TYPE = SVModelTypes.DisplayStyle;
ExtendMode: TYPE = SVSceneTypes.ExtendMode;
FeatureCycler: TYPE = SVInterfaceTypes.FeatureCycler;
GravityType: TYPE = SVInterfaceTypes.GravityType;
SearchDepth: TYPE = SVSceneTypes.SearchDepth;
SelectMode: TYPE = SVSceneTypes.SelectMode;
Skitter: TYPE = SVSceneTypes.Skitter;
SliceDescriptor: TYPE = SVSceneTypes.SliceDescriptor;
SortedButtonHandle: TYPE = AtomButtonsTypes.SortedButtonHandle;
SVData: TYPE = SVInterfaceTypes.SVData;
TwoState: TYPE = AtomButtonsTypes.TwoState;
Vector2d: TYPE = SV2d.Vector2d;

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

DeleteSelected: PROC [state: BOOL, name: Rope.ROPE, value: REF ANY, clientData: REF ANY] RETURNS [found: BOOL, done: BOOL _ FALSE] = {
found _ state;
};
TidyReal: PROC [r: REAL] RETURNS [name: Rope.ROPE] = {
name _ IO.PutFR["%1.2f", [real[r]]];
UNTIL Rope.Fetch[base: name, index: Rope.Length[name]-1]# '0 DO
name _ Rope.Substr[base: name, start: 0, len: Rope.Length[name]-1];
ENDLOOP;
IF Rope.Fetch[base: name, index: Rope.Length[name]-1] = '. THEN name _ Rope.Substr[base: name, start: 0, len: Rope.Length[name]-1];
};


GetAzimuthValue: PUBLIC PROC [svData: SVData] RETURNS [degrees: REAL, success: BOOL _ TRUE] = {
degrees _ SVViewerTools.GetReal[svData.measure.azimuthView, Real.LargestNumber];
IF degrees=Real.LargestNumber THEN {
Feedback.Append[svData.feedback, "Attempt to use illegal azimuth value", oneLiner];
Feedback.Blink[svData.feedback];
degrees _ 0.0;
success _ FALSE;
RETURN;
};
IF RealFns.AlmostEqual[degrees, svData.measure.azimuthViewValue, -10] THEN degrees _ svData.measure.azimuthViewValue ELSE svData.measure.azimuthViewValue _ degrees;
};
GetAzimuthAlignments: PUBLIC PROC [svData: SVData] RETURNS [values: LIST OF REAL, on: LIST OF BOOL] = {
AddAzimuth: PROC [state: BOOL, name: Rope.ROPE, value: REF ANY, clientData: REF ANY] RETURNS [done: BOOL _ FALSE] = {
real: REAL _ NARROW[value, REF REAL]^;
values _ CONS[real, values];
on _ CONS[state, on];
};
AtomButtons.ReadSortedButtons[svData.hitTest.azimuthHandle, AddAzimuth];
};
GetAzimuth: PUBLIC PROC [svData: SVData] RETURNS [degrees: REAL] = {
FindScalar: PROC [state: BOOL, name: Rope.ROPE, value: REF ANY, clientData: REF ANY] RETURNS [done: BOOL _ FALSE] = {
real: REAL _ NARROW[value, REF REAL]^;
IF state THEN {
degrees _ real;
done _ success _ TRUE;
};
};
success: BOOL _ FALSE;
AtomButtons.ReadSortedButtons[svData.hitTest.azimuthHandle, FindScalar];
IF NOT success THEN ERROR;
};
AddAzimuth: PUBLIC PROC [svData: SVData, degrees: REAL, on: BOOL _ TRUE] RETURNS [alreadyThere: BOOL] = {
oldFoundButton: AtomButtons.SortedButtonClient;
AtomButtons.SetAllScalarStates[svData, svData.hitTest.azimuthHandle, FALSE];
oldFoundButton _ AtomButtons.AddScalarSorted[clientData: svData, handle: svData.hitTest.azimuthHandle, button: [NIL, degrees, LIST[LIST[$ToggleAzimuth, NEW[REAL _ degrees]]], on], order: incr];
alreadyThere _ oldFoundButton # NIL;
};
DeleteAzimuth: PUBLIC PROC [svData: SVData] = {
AtomButtons.DeleteSortedButtons[svData, svData.hitTest.azimuthHandle, DeleteSelected];
};

GetSlopeAlignments: PUBLIC PROC [svData: SVData] RETURNS [values: LIST OF REAL, on: LIST OF BOOL] = {
AddSlope: PROC [state: BOOL, name: Rope.ROPE, value: REF ANY, clientData: REF ANY] RETURNS [done: BOOL _ FALSE] = {
real: REAL _ NARROW[value, REF REAL]^;
values _ CONS[real, values];
on _ CONS[state, on];
};
AtomButtons.ReadSortedButtons[svData.hitTest.slopeHandle, AddSlope];
};
GetSlopeValue: PUBLIC PROC [svData: SVData] RETURNS [degrees: REAL, success: BOOL _ TRUE] = {
degrees _ SVViewerTools.GetReal[svData.measure.slopeView, Real.LargestNumber];
IF degrees = Real.LargestNumber THEN {
Feedback.Append[svData.feedback, "Attempt to use illegal slope value", oneLiner];
Feedback.Blink[svData.feedback];
degrees _ 0.0;
success _ FALSE;
RETURN;
};
degrees _ Angles2d.Normalize[degrees];
IF degrees<0.0 THEN degrees _ degrees+180.0;
IF degrees=360.0 THEN degrees _ 0.0;
IF RealFns.AlmostEqual[degrees, svData.measure.slopeViewValue, -10] THEN degrees _ svData.measure.slopeViewValue ELSE svData.measure.slopeViewValue _ degrees;
};
GetSlope: PUBLIC PROC [svData: SVData] RETURNS [degrees: REAL] = {
FindScalar: PROC [state: BOOL, name: Rope.ROPE, value: REF ANY, clientData: REF ANY] RETURNS [done: BOOL _ FALSE] = {
real: REAL _ NARROW[value, REF REAL]^;
IF state THEN {
degrees _ real;
done _ success _ TRUE;
};
};
success: BOOL _ FALSE;
AtomButtons.ReadSortedButtons[svData.hitTest.slopeHandle, FindScalar];
IF NOT success THEN ERROR;
};
AddSlope: PUBLIC PROC [svData: SVData, degrees: REAL, on: BOOL _ TRUE] RETURNS [alreadyThere: BOOL] = {
oldFoundButton: AtomButtons.SortedButtonClient;
AtomButtons.SetAllScalarStates[svData, svData.hitTest.slopeHandle, FALSE];
oldFoundButton _ AtomButtons.AddScalarSorted[svData, svData.hitTest.slopeHandle, [NIL, degrees, LIST[LIST[$ToggleSlope, NEW[REAL _ degrees]]], on], decr];
alreadyThere _ oldFoundButton # NIL;
};
DeleteSlope: PUBLIC PROC [svData: SVData] = {
AtomButtons.DeleteSortedButtons[svData, svData.hitTest.slopeHandle, DeleteSelected];
};

GetRadiusAlignments: PUBLIC PROC [svData: SVData] RETURNS [values: LIST OF REAL, on: LIST OF BOOL] = {
AddRadius: PROC [state: BOOL, name: Rope.ROPE, value: REF ANY, clientData: REF ANY] RETURNS [done: BOOL _ FALSE] = {
radius: REAL _ NARROW[value, REF REAL]^;
values _ CONS[radius, values];
on _ CONS[state, on];
};
AtomButtons.ReadSortedButtons[svData.hitTest.radiusHandle, AddRadius];
};
GetRadiusValue: PUBLIC PROC [svData: SVData] RETURNS [radius: REAL, success: BOOL _ TRUE] = {
radius _ SVViewerTools.GetReal[svData.measure.radiusView, Real.LargestNumber];
IF radius = Real.LargestNumber THEN {
Feedback.Append[svData.feedback, "Attempt to use illegal radius value", oneLiner];
Feedback.Blink[svData.feedback];
radius _ 0.0;
success _ FALSE;
RETURN;
};
IF RealFns.AlmostEqual[radius, svData.measure.radiusViewValue, -10] THEN radius _ svData.measure.radiusViewValue ELSE svData.measure.radiusViewValue _ radius;
};
AddRadius: PUBLIC PROC [svData: SVData, radius: REAL, on: BOOL _ TRUE] RETURNS [alreadyThere: BOOL] = {
oldFoundButton: AtomButtons.SortedButtonClient;
AtomButtons.SetAllScalarStates[svData, svData.hitTest.radiusHandle, FALSE];
oldFoundButton _ AtomButtons.AddScalarSorted[svData, svData.hitTest.radiusHandle, [NIL, radius, LIST[LIST[$ToggleRadius, NEW[REAL _ radius]]], on], incr];
alreadyThere _ oldFoundButton # NIL;
};
DeleteRadii: PUBLIC PROC [svData: SVData] = {
AtomButtons.DeleteSortedButtons[svData, svData.hitTest.radiusHandle, DeleteSelected];
};

GetSlopeLineAlignments: PUBLIC PROC [svData: SVData] RETURNS [azimuths: LIST OF REAL, slopes: LIST OF REAL, on: LIST OF BOOL] = {
AddSlopeLine: PROC [state: BOOL, name: Rope.ROPE, value: REF ANY, clientData: REF ANY] RETURNS [done: BOOL _ FALSE] = {
vector: Vector2d _ NARROW[value, REF Vector2d]^;
azimuths _ CONS[vector[1], azimuths];
slopes _ CONS[vector[2], slopes];
on _ CONS[state, on];
};
AtomButtons.ReadSortedButtons[svData.hitTest.slopeLineHandle, AddSlopeLine];
};

CompareSlopeAzimuth: PROC [aName: Rope.ROPE, aValue: REF ANY, bName: Rope.ROPE, bValue: REF ANY] RETURNS [compare: Basics.Comparison] = {
aVector, bVector: Vector2d;
aVector _ NARROW[aValue, REF Vector2d]^;
bVector _ NARROW[bValue, REF Vector2d]^;
compare _ Real.CompareREAL[aVector[1], bVector[1]];
IF compare # equal THEN RETURN;
compare _ Real.CompareREAL[aVector[2], bVector[2]];
};
AddSlopeLine: PUBLIC PROC [svData: SVData, azimuth: REAL, slope: REAL, on: BOOL _ TRUE] RETURNS [alreadyThere: BOOL] = {
name: Rope.ROPE;
value: REF Vector2d;
oldClient: AtomButtonsTypes.SortedButtonClient;

name _ IO.PutFR["(%g %g)", [rope[TidyReal[azimuth]]], [rope[TidyReal[slope]]]];
value _ NEW[Vector2d_[azimuth,slope]];
oldClient _ AtomButtons.AddSortedButton[svData, svData.hitTest.slopeLineHandle, [name, value, LIST[LIST[$ToggleSlopeLine, value]], TRUE], CompareSlopeAzimuth];
};

DeleteSlopeLines: PUBLIC PROC [svData: SVData] = {
AtomButtons.DeleteSortedButtons[svData, svData.hitTest.slopeLineHandle, DeleteSelected];
};

GetSlopePlaneAlignments: PUBLIC PROC [svData: SVData] RETURNS [azimuths: LIST OF REAL, slopes: LIST OF REAL, on: LIST OF BOOL] = {
AddSlopePlane: PROC [state: BOOL, name: Rope.ROPE, value: REF ANY, clientData: REF ANY] RETURNS [done: BOOL _ FALSE] = {
vector: Vector2d _ NARROW[value, REF Vector2d]^;
azimuths _ CONS[vector[1], azimuths];
slopes _ CONS[vector[2], slopes];
on _ CONS[state, on];
};
AtomButtons.ReadSortedButtons[svData.hitTest.slopePlaneHandle, AddSlopePlane];
};

AddSlopePlane: PUBLIC PROC [svData: SVData, azimuth: REAL, slope: REAL, on: BOOL _ TRUE] RETURNS [alreadyThere: BOOL] = {
name: Rope.ROPE;
value: REF Vector2d;
oldClient: AtomButtonsTypes.SortedButtonClient;
name _ IO.PutFR["(%g %g)", [rope[TidyReal[azimuth]]], [rope[TidyReal[slope]]]];
value _ NEW[Vector2d_[azimuth,slope]];
oldClient _ AtomButtons.AddSortedButton[svData, svData.hitTest.slopePlaneHandle, [name, value, LIST[LIST[$ToggleSlopePlane, value]], TRUE], CompareSlopeAzimuth];
};

DeleteSlopePlanes: PUBLIC PROC [svData: SVData] = {
AtomButtons.DeleteSortedButtons[svData, svData.hitTest.slopePlaneHandle, DeleteSelected];
};


GetDisplayStyle: PUBLIC PROC [svData: SVData] RETURNS [DisplayStyle] = {
RETURN[svData.camera.displayStyle];
};
SetDisplayStyle: PUBLIC PROC [svData: SVData, displayStyle: DisplayStyle] = {
SIGNAL Problem["Not yet implemented."];
};
GetShowAlignments: PUBLIC PROC [svData: SVData] RETURNS [BOOL] = {
RETURN[TRUE];
};
SetShowAlignments: PUBLIC PROC [svData: SVData, showAlignments: BOOL] = {
};
GetShowColors: PUBLIC PROC [svData: SVData] RETURNS [BOOL] = {
RETURN[AtomButtons.GetBinaryState[svData.refresh.showColors]];
};
SetShowColors: PUBLIC PROC [svData: SVData, showColors: BOOL] = {
AtomButtons.SetBinaryState[svData.refresh.showColors, showColors];
};
GetViewport: PUBLIC PROC [svData: SVData] RETURNS [Imager.Rectangle] = {
RETURN[[-1000, -1000, 2000, 2000]];
};
GetSuppressRefresh: PUBLIC PROC [svData: SVData] RETURNS [BOOL] = {
RETURN[svData.refresh.suppressRefresh];
};
SetSuppressRefresh: PUBLIC PROC [svData: SVData, suppressRefresh: BOOL] = {
svData.refresh.suppressRefresh _ suppressRefresh;
};
GetAnchor: PUBLIC PROC [svData: SVData] RETURNS [Skitter] = {
RETURN[svData.scene.anchor];
};
GetGravity: PUBLIC PROC [svData: SVData] RETURNS [gravityOn: BOOL] = {
gravityOn _ AtomButtons.GetBinaryState[svData.hitTest.gravButton];
};
SetGravity: PUBLIC PROC [svData: SVData, gravityOn: BOOL] = {
AtomButtons.SetBinaryState[svData.hitTest.gravButton, gravityOn];
};
ToggleGravity: PUBLIC PROC [svData: SVData] = {
stateInfo: TwoState _ svData.hitTest.gravButton;
AtomButtons.SwitchBinaryState[stateInfo];
UpdateCursorLooks[svData];
};
UpdateCursorLooks: PROC [svData: SVData] = {
SELECT GetGravity[svData] FROM
TRUE => SELECT GetGravityType[svData] FROM
facesPreferred => SVWindow.SetCursorLooks[facesPreferred, svData];
linesPreferred => SVWindow.SetCursorLooks[linesPreferred, svData];
pointsPreferred => SVWindow.SetCursorLooks[pointsPreferred, svData];
ENDCASE => ERROR;
FALSE => SVWindow.SetCursorLooks[type: pointsPreferred, svData: svData, on: FALSE];
ENDCASE => ERROR;
};

GetGravityExtent: PUBLIC PROC [svData: SVData] RETURNS [inches: REAL] = {
screenDots: REAL;
graphicsState: AtomButtonsTypes.GraphicsState _ svData.hitTest.gravityExtentButton;
ged: SVInterfaceTypes.GravityExtentData;
ged _ NARROW[GraphicsButton.GetValue[graphicsState].buttonData];
screenDots _ ged.extent;
inches _ screenDots/72.0;
};
SetGravityExtent: PUBLIC PROC [svData: SVData, inches: REAL] = {
screenDots: REAL;
graphicsState: AtomButtonsTypes.GraphicsState _ svData.hitTest.gravityExtentButton;
ged: SVInterfaceTypes.GravityExtentData;
screenDots _ inches*72.0;
Feedback.PutF[svData.feedback, oneLiner, "Gravity extent is now %g inches.", [real[inches]] ];
ged _ NEW[SVInterfaceTypes.GravityExtentDataObj _ [extent: screenDots]];
GraphicsButton.SetButtonValueAndPaint[graphicsState, svData, ged];
svData.hitTest.t _ screenDots;
};
GetGravityType: PUBLIC PROC [svData: SVData] RETURNS [gravityType: GravityType] = {
gravityType _ svData.hitTest.gravityType;
};
SetGravityType: PUBLIC PROC [svData: SVData, gravityType: GravityType] = {
svData.hitTest.gravityType _ gravityType;
};
CycleGravityType: PUBLIC PROC [svData: SVData, forward: BOOL] = {
info: AtomButtons.EnumTypeRef _ svData.hitTest.gravityTypeMenu;
name: Rope.ROPE;
IF forward THEN AtomButtons.TimeToFlipThru[LIST[$FlipForward, info]]
ELSE AtomButtons.TimeToFlipThru[LIST[$FlipBackward, info]];
name _ info.flipLabel.name;
SELECT TRUE FROM
Rope.Equal[name, "PreferFaces", TRUE] => SetGravityType[svData, facesPreferred];
Rope.Equal[name, "PreferLines", TRUE] => SetGravityType[svData, linesPreferred];
Rope.Equal[name, "PreferPoints", TRUE] => SetGravityType[svData, pointsPreferred];
ENDCASE => ERROR;
UpdateCursorLooks[svData];
};
GetHeuristics: PUBLIC PROC [svData: SVData] RETURNS [BOOL] = {
RETURN[FALSE];
};
SetHeuristics: PUBLIC PROC [svData: SVData, heuristicsOn: BOOL] = {
};
GetMidpoints: PUBLIC PROC [svData: SVData] RETURNS [midpointsOn: BOOL] = {
midpointsOn _ AtomButtons.GetBinaryState[svData.hitTest.midpointButton];
};
SetMidpoints: PUBLIC PROC [svData: SVData, midpointsOn: BOOL] = {
AtomButtons.SetBinaryState[svData.hitTest.midpointButton, midpointsOn];
};
ToggleMidpoints: PUBLIC PROC [svData: SVData] = {
stateInfo: TwoState _ svData.hitTest.midpointButton;
AtomButtons.SwitchBinaryState[stateInfo];
SVWindow.RestoreScreenAndInvariants[paintAction: $None, svData: svData];
};
GetScaleUnit: PUBLIC PROC [svData: SVData] RETURNS [REAL] = {
RETURN[svData.hitTest.scaleUnit];
};
SetScaleUnit: PUBLIC PROC [svData: SVData, unit: REAL]  = {
IF unit <=0.0  THEN {
Feedback.AppendHerald[svData.feedback, "Zero or Illegal unit value.  Set Scale Units ignored.", oneLiner];
Feedback.Blink[svData.feedback];
}
ELSE svData.hitTest.scaleUnit _ unit; -- in screen dots
};
GetSliceToExtend: PUBLIC PROC [svData: SVData] RETURNS [sliceD: SliceDescriptor] = {
RETURN[NIL];
};
SetSliceToExtend: PUBLIC PROC [svData: SVData, sliceD: SliceDescriptor] = {
};

GetSelectionCycler: PUBLIC PROC [svData: SVData] RETURNS [featureCycler: FeatureCycler] = {
featureCycler _ svData.select.cycler;
};
SetSelectionCycler: PUBLIC PROC [svData: SVData, featureCycler: FeatureCycler] = {
svData.select.cycler _ featureCycler;
};

GetSelectMode: PUBLIC PROC [svData: SVData] RETURNS [selectMode: SelectMode] = {
RETURN[svData.drag.selectState];
};
SetSelectMode: PUBLIC PROC [svData: SVData, selectMode: SelectMode] = {
svData.drag.selectState _ selectMode;
};

GetExtendMode: PUBLIC PROC [svData: SVData] RETURNS [extendMode: ExtendMode] = {
RETURN[svData.drag.extendMode];
};
SetExtendMode: PUBLIC PROC [svData: SVData, extendMode: ExtendMode] = {
svData.drag.extendMode _ extendMode;
};


GetQuickClickMode: PUBLIC PROC RETURNS [on: BOOL] = {
RETURN[quickClickMode];
};

SetQuickClickMode: PUBLIC PROC [on: BOOL] = {
quickClickMode _ on;
};
quickClickMode: BOOL _ FALSE;
GetSearchDepth: PUBLIC PROC [svData: SVData] RETURNS [searchDepth: SearchDepth] = {
searchDepth _ first;
};
SetSearchDepth: PUBLIC PROC [svData: SVData, searchDepth: SearchDepth] = {
SIGNAL Problem[msg: "Can't set searchDepth yet"];
};

GetSelectedAzimuth: PUBLIC PROC [svData: SVData] RETURNS [azimuth: REAL] = {
azimuthHandle: SortedButtonHandle;
ReadScalar: PROC [state: BOOL, name: Rope.ROPE, value: REF ANY, clientData: REF ANY] RETURNS [done: BOOL _ FALSE] = {
IF state THEN {
azimuth _ NARROW[value, REF REAL]^;
done _ TRUE;
};
};
azimuthHandle _ svData.hitTest.azimuthHandle;
AtomButtons.ReadSortedButtons[azimuthHandle, ReadScalar, svData];
};
SetSelectedAzimuth: PUBLIC PROC [svData: SVData, azimuth: REAL] = {

};
GetSelectedSlope: PUBLIC PROC [svData: SVData] RETURNS [slope: REAL] = {
slopeHandle: SortedButtonHandle;
ReadScalar: PROC [state: BOOL, name: Rope.ROPE, value: REF ANY, clientData: REF ANY] RETURNS [done: BOOL _ FALSE] = {
IF state THEN {
slope _ NARROW[value, REF REAL]^;
done _ TRUE;
};
};
slopeHandle _ svData.hitTest.slopeHandle;
AtomButtons.ReadSortedButtons[slopeHandle, ReadScalar, svData];
};
SetSelectedSlope: PUBLIC PROC [svData: SVData, slope: REAL] = {

};
GetDefaultHeuristics: PUBLIC PROC [] RETURNS [BOOL] = {
RETURN[TRUE];
};
END.


®SVStateImpl.mesa
Copyright c 1986 by Xerox Corporation.  All rights reserved.
Last edited by Bier on March 30, 1987 12:52:26 pm PST
Contents:  Routines for getting and setting the state or "modes" of the Solidviews interface.

Strip off trailing zeroes
Strip off trailing decimal point
Put the most accurate value we have into variable distance
Only positive slopes, please.
Return the most accurate value we have.
Return the most accurate value we have.

Refresh Parameters

Gravity and Alignments
in units of 1/72 of an inch
in units of 1/72 of an inch

Other
RETURN[svData.drag.sliceToExtend];
svData.drag.sliceToExtend _ sliceD;
Hidden State (yuk)


Peculiar to 3D


Defaults
�ʦ˜J˜Icodeš
œ™Kšœ
Ïm
œ1™<Kšœ2Ïk™5KšÏnœU™]K™š
ž	˜	Jš
œÁ
˜Á
—K˜šŸœžœ
ž˜Jšžœa˜iKšžœ˜Kš
œ˜—Kš
ž˜˜Kšœžœ˜/Kšœžœ˜+Kšœžœ"˜5Kšœ
žœ ˜1Kšœ
žœ˜-Kšœžœ˜+Kšœ	žœ˜%Kšœžœ ˜5Kšœžœ'˜?Kšœžœ˜'Kšœ
žœ˜+Kšœ
žœ˜K˜KšŸœžœ
žœžœ˜;—K˜šŸœžœ	žœ
žœ	žœ
žœžœ
žœžœ	žœžœžœ˜†
Kš
œ˜K˜—š
Ÿœžœžœžœ
žœ˜6Kšœžœ˜$K•StartOfExpansion9[base: 
ROPE, start: 
INT _ 0, len: 
INT _ 2147483647]š
Ïb™šžœ8ž˜?Kš
œC˜CKšžœ
˜—Kš
  ™ Kšžœ9žœD˜ƒ
J˜J˜—K˜šŸœžœ
žœžœžœžœžœ˜_Kš
œP˜Pšžœžœ˜$K–B[gargoyleData: 
REF ANY, msg: 
ROPE, msgType: 
GGError.MsgType]š
œS˜SKš
œ ˜ Kš
œ˜Kšœ
žœ
˜Kšžœ
˜K˜—Kš
 :™:KšžœDžœ+žœ+˜¤
Kš
œ˜—šŸœžœ
žœžœ
žœ
žœ
žœžœ
žœ
žœ˜gšŸ
œžœ	žœ
žœ	žœ
žœžœ
žœžœžœžœ˜uKš	œžœžœžœ
žœ˜&Kšœ	žœ˜Kšœžœ˜K˜—Kš
œH˜HKš
œ˜—šŸ
œžœžœžœ˜DšŸ
œžœ	žœ
žœ	žœ
žœžœ
žœžœžœžœ˜uKš	œžœžœžœ
žœ˜&šžœžœ˜Kš
œ˜Kšœžœ
˜K˜—K˜—Kšœ	žœžœ
˜Kš
œH˜HKšžœ
žœ	žœ
žœ
˜K˜—šŸ
œžœ
žœžœžœžœžœžœ˜iKš
œ/˜/KšœEžœ˜LKšœpžœžœ
žœžœ
žœ!˜Á
Kšœ žœ
˜$K˜—šŸ
œžœ
žœ˜/Kš
œV˜VK˜—K˜šŸœžœ
žœžœ
žœ
žœ
žœžœ
žœ
žœ˜ešŸœžœ	žœ
žœ	žœ
žœžœ
žœžœžœžœ˜sKš	œžœžœžœ
žœ˜&Kšœ	žœ˜Kšœžœ˜K˜—Kš
œD˜DKš
œ˜—šŸ
œžœ
žœžœžœžœžœ˜]Kš
œN˜Nšžœžœ˜&K–B[gargoyleData: 
REF ANY, msg: 
ROPE, msgType: 
GGError.MsgType]š
œQ˜QKš
œ ˜ Kš
œ˜Kšœ
žœ
˜Kšžœ
˜K˜—Kš
œ&˜&Kš
 ™Kšžœ
žœ˜,Kšžœžœ˜$Kš
 '™'KšžœBžœ)žœ)˜ž
Kš
œ˜—š
Ÿœžœ
žœžœžœ˜BšŸ
œžœ	žœ
žœ	žœ
žœžœ
žœžœžœžœ˜uKš	œžœžœžœ
žœ˜&šžœžœ˜Kš
œ˜Kšœžœ
˜K˜—K˜—Kšœ	žœžœ
˜Kš
œF˜FKšžœ
žœ	žœ
žœ
˜K˜—šŸœžœ
žœžœžœžœžœžœ˜gKš
œ/˜/KšœCžœ˜JKšœRžœžœ
žœžœ
žœ˜š
Kšœ žœ
˜$K˜—šŸœžœ
žœ˜-Kš
œT˜TK˜—K˜šŸœžœ
žœžœ
žœ
žœ
žœžœ
žœ
žœ˜fšŸ	œžœ	žœ
žœ	žœ
žœžœ
žœžœžœžœ˜tKš	œžœžœžœ
žœ˜(Kšœ	žœ˜Kšœžœ˜K˜—Kš
œF˜FKš
œ˜—šŸœžœ
žœžœ
žœžœžœ˜]Kš
œN˜Nšžœžœ˜%K–B[gargoyleData: 
REF ANY, msg: 
ROPE, msgType: 
GGError.MsgType]š
œR˜RKš
œ ˜ Kš
œ
˜
Kšœ
žœ
˜Kšžœ
˜K˜—Kš
 '™'KšžœBžœ)žœ)˜ž
Kš
œ˜—šŸ	œžœ
žœžœžœžœžœžœ˜gKš
œ/˜/KšœDžœ˜KKšœSžœ
žœ
žœžœ
žœ˜š
Kšœ žœ
˜$K˜—šŸœžœ
žœ˜-Kš
œU˜UK˜—K˜šŸœžœ
žœžœžœ
žœ
žœ
žœ
žœ
žœžœ
žœ
žœ˜�
šŸœžœ	žœ
žœ	žœ
žœžœ
žœžœžœžœ˜wKšœžœžœ˜0Kšœžœ˜%Kšœ	žœ˜!Kšœžœ˜K˜—Kš
œL˜LK˜K˜—
procšŸœžœžœ
žœ
žœžœ
žœ
žœžœ!˜‰
L˜Lšœ
žœ	žœ˜(Lšœ
žœ	žœ˜(Lš
œ3˜3Lšžœžœ
žœ
˜Lš
œ3˜3L˜—šŸœžœ
žœžœ	žœžœžœžœžœ˜xLšœžœ
˜Lšœžœ
˜Lš
œ/˜/L˜LšœžœF˜OLšœžœ˜&Lšœ^žœ
žœžœ˜Ÿ
K˜K˜—šŸœžœ
žœ˜2Kš
œX˜XK˜K˜—šŸœžœ
žœžœžœ
žœ
žœ
žœ
žœ
žœžœ
žœ
žœ˜‚
šŸ
œžœ	žœ
žœ	žœ
žœžœ
žœžœžœžœ˜xKšœžœžœ˜0Kšœžœ˜%Kšœ	žœ˜!Kšœžœ˜K˜—Kš
œN˜NK˜K˜—šŸ
œžœ
žœžœ	žœžœžœžœžœ˜yLšœžœ
˜Lšœžœ
˜Lš
œ/˜/LšœžœF˜OLšœžœ˜&Lšœ_žœ
žœžœ˜¡
K˜K˜—šŸœžœ
žœ˜3Kš
œY˜YK˜K˜—K™K™K˜šŸœžœ
žœžœ˜HKšžœ˜#K˜—šŸœžœ
žœ1˜MKšžœ!˜'K˜—š
Ÿœžœ
žœžœžœ˜BKšžœ
žœ˜
K˜—šŸœžœ
žœ"žœ˜IK˜—š
Ÿ
œžœ
žœžœžœ˜>Kšžœ8˜>K˜—šŸ
œžœ
žœžœ˜AKš
œB˜BK˜—šŸœžœ
žœžœ˜HKšžœ˜#K˜—š
Ÿœžœ
žœžœžœ˜CKšžœ!˜'K˜—šŸœžœ
žœ#žœ˜KKš
œ1˜1K˜—K™K™šŸ	œžœ
žœžœ˜=Kšžœ˜K˜—š
Ÿ
œžœ
žœžœžœ˜FKš
œB˜BK˜—šŸ
œžœ
žœžœ˜=Kš
œA˜AK˜—šŸ
œžœ
žœ˜/Kš
œ0˜0Kš
œ)˜)Kš
œ˜K˜—šŸœžœ˜,šžœž˜šžœžœž˜*Kš
œB˜BKš
œB˜BKš
œD˜DKšžœžœ
˜—KšžœGžœ˜SKšžœžœ
˜—K˜K˜—š
Ÿœžœ
žœžœ
žœ˜IKšœžœ
˜Kš
œS˜SKš
œ(˜(Kšœžœ4˜@Kš
œ˜Kš
œ˜K˜—šŸœžœ
žœžœ˜@Kšœžœ
˜Kš
œS˜SK˜(Kš
œ˜Kš
œ^˜^Kšœžœ?˜HKš
œB˜BKš
œ˜K˜—šŸœžœ
žœžœ˜SKš
œ)˜)K˜—šŸœžœ
žœ/˜JKš
œ)˜)K˜—šŸœžœ
žœžœ˜AKš
œ?˜?Kšœžœ
˜Kšžœ	žœžœ˜DKšžœžœ˜;Kš
œ˜šžœ
žœ
ž˜Kšœ žœ,˜PKšœ žœ,˜PKšœ!žœ-˜RKšžœžœ
˜—Kš
œ˜K˜—š
Ÿ
œžœ
žœžœžœ˜>Kšžœ
žœ˜K˜—šŸ
œžœ
žœ žœ˜CK˜—š
Ÿœžœ
žœžœ
žœ˜JKš
œH˜HK˜—šŸœžœ
žœžœ˜AKš
œG˜GK˜—šŸœžœ
žœ˜1Kš
œ4˜4Kš
œ)˜)Kš
œH˜HK˜—š
Ÿœžœ
žœžœžœ˜=Kš
œ™Kšžœ˜!K˜—šŸœžœ
žœžœ˜;Kš
œ™šžœ
žœ˜Kš
œj˜jKš
œ ˜ K˜
—Kšžœ"Ïc˜7K˜—K™K™šŸœžœ
žœžœ˜TKšžœ™"Kšžœ
žœ˜K˜—šŸœžœ
žœ.˜KKš
œ#™#K˜K˜—šŸœžœ
žœžœ#˜[Kš
œ%˜%K˜—šŸœžœ
žœ3˜RKš
œ%˜%K˜—K˜K™šŸ
œžœ
žœžœ˜PKšžœ˜ K˜—šŸ
œžœ
žœ-˜GKš
œ%˜%K˜K˜—šŸ
œžœ
žœžœ˜PKšžœ˜K˜—šŸ
œžœ
žœ-˜GKš
œ$˜$K˜K˜—K˜š
Ÿœžœ
žœ
žœžœ˜5Kšžœ˜K˜K˜—šŸœžœ
žœžœ˜-Kš
œ˜K˜—K™Kšœžœžœ
˜K™K™šŸœžœ
žœžœ˜SKš
œ˜K˜—šŸœžœ
žœ/˜JKšžœ+˜1K˜—K˜š
Ÿœžœ
žœžœžœ˜LLš
œ"˜"šŸ
œžœ	žœ
žœ	žœ
žœžœ
žœžœžœžœ˜ušžœžœ˜Lšœ
žœžœ
žœ˜#Lšœžœ
˜L˜—L˜—Lš
œ-˜-Kš
œA˜AK˜—šŸœžœ
žœžœ˜CK˜K˜—š
Ÿœžœ
žœžœ	žœ˜HLš
œ ˜ šŸ
œžœ	žœ
žœ	žœ
žœžœ
žœžœžœžœ˜ušžœžœ˜Lšœžœžœ
žœ˜!Lšœžœ
˜L˜—L˜—Lš
œ)˜)Kš
œ?˜?K˜—šŸœžœ
žœžœ˜?K˜K˜—K™K™K™š
Ÿœžœ
žœžœžœ˜7Kšžœ
žœ˜
K˜—Kšžœ
˜K˜J˜—…—AXh