DIRECTORY
AccessCH USING [NSNameFromRope],
AdobeCommon USING [AddSystemToKnownSystems, Box, EnumeratedTypes, FindSystem, FindThisQL, FormatType, Handle, InitialSetStatus, LocateSystemInKnownSystems, PostMessage, PostNumber, RemoveSystemFromKnownSystems, RowBufferRec, SetFSWOrderAndDefaultFromUserFile, StringArray],
AdobeCommonInternal USING [EntryBytesType, InstanceData, InstanceDataHandle, SystemNotFound],
AdobeIO USING [ReadProc, UnlockProc, WriteProc],
AdobeOps USING [ARNumber, ARSystemHandle, FieldList, QLHandle, QueryList, StrFIO, ToolType],
AdobeP75V2 USING [FieldItemObjectRec, FieldItemValue, FieldItemValueRec],
AdobeTool USING [ClearWindow, CurrentButtonProcData, DisableUserEdits, EmptyContents, EnableUserEdits, GetPossibilities, GetValidRelations, SetEnumValue, SetUpDefaults, SetUpWindow],
AdobeUI USING [Handle],
BasicTime USING [nullGMT],
Convert USING [CardFromRope, Error, RopeFromCard, TimeFromRope],
CrRPC USING [Error],
PFS USING [Error, PathFromRope, StreamOpen],
Rope USING [Concat, Equal, IsEmpty, Length, ROPE, Substr],
ViewerClasses USING [MouseButton],
ViewerTools USING [SelPos, SelPosRec],
XNSAdobeClientOps USING [AboutToStore, GetNextSubmitNumber, SubmitFailed, UpdateAcceleratorField];

AdobeUIImpl: CEDAR MONITOR 
IMPORTS AccessCH, AdobeCommon, AdobeCommonInternal, AdobeIO, AdobeTool, Convert, CrRPC, PFS, Rope, XNSAdobeClientOps
EXPORTS AdobeUI ~ {


HandleField: PUBLIC PROCEDURE [h: AdobeUI.Handle, field: INTEGER, mouseButton: ViewerClasses.MouseButton, title: Rope.ROPE ¬ NIL, selections: LIST OF Rope.ROPE ¬ NIL] RETURNS [which: INT ¬ 0] = {

SELECT mouseButton FROM
red => {
h.setSelection[h.editors[field]];
};
yellow => SELECT title FROM
NIL => {
h.setContents[h.editors[field], ""];
h.setSelection[h.editors[field]];
};
ENDCASE => which ¬ h.popUpRequest[title, selections];
blue => {
h.setSelection[h.editors[field]];
};
ENDCASE => ERROR;
};

BusyTest: PROCEDURE [h: AdobeUI.Handle] RETURNS [isBusy: BOOLEAN ¬ FALSE] ~ {
IF h.isBusy THEN {
h.report[h, "Adobe tool is busy, try again later.\n"];
RETURN[TRUE];
};
};

CheckSystem: PROC [h: AdobeUI.Handle] RETURNS [continue: BOOL ¬ TRUE] ~ {
IF h.system = LAST[CARD]  OR h.systemName = NIL THEN {
h.report[h, "Must specify system.\n"];
RETURN[FALSE];
};
};

AnotherTool: PUBLIC PROCEDURE [h: AdobeUI.Handle ¬ NIL] ~ {
h.makeAnotherTool[h];
};

ExamineRope: Rope.ROPE ~ "Examining AR #%g ... ";

DoExamine: PROC[h: AdobeUI.Handle, r: Rope.ROPE ¬ ExamineRope, lock: BOOL ¬ FALSE] ~ {
IF ~CheckSystem[h] THEN RETURN;
IF BusyTest[h] THEN RETURN;
SELECT h.currentARState FROM
CheckedOut => h.report[h, "Check in current AR first!\n"];
Normal => {
h.currentAR ¬ GetNumber[h];
SELECT h.currentAR FROM
0 => {
AdobeTool.EmptyContents[h];
};
LAST[CARDINAL] => {
h.currentAR ¬ h.oldCurrentAR
};
ENDCASE => {
h.isBusy ¬ TRUE;
h.report[h, r, [integer[h.currentAR]]];
AdobeIO.ReadProc[h.currentAR, h, NIL, lock];
h.oldCurrentAR ¬ h.currentAR;
AdobeTool.DisableUserEdits[h];
h.isBusy ¬ FALSE;
h.report[h, "done.\n"];
};
};
ENDCASE => {};
};

DoCheckIn: PROCEDURE [h: AdobeUI.Handle] ~ {
done: BOOL ¬ FALSE;
fIV: AdobeP75V2.FieldItemValue;
r: Rope.ROPE ¬ NIL;
IF ~CheckSystem[h] THEN RETURN;
IF BusyTest[h] THEN RETURN;
SELECT h.currentARState FROM
Normal => h.report[h, "No AR checked out.\n"];
CheckedOut => {
h.report[h, "Checking in AR#%g...", [integer[h.currentAR]]];
h.isBusy ¬ TRUE;
AdobeTool.DisableUserEdits[h];
IF AdobeIO.WriteProc[h] THEN {
AdobeIO.UnlockProc[h.currentAR, h];
h.setIcon[h, $normal];
h.currentARState ¬ Normal;
h.report[h, "Updating Accelerators . . . "];
FOR i: CARD IN [0..h.fieldViewer.buttons.length) DO
done ¬ FALSE;
r ¬ h.getContents[h.fieldViewer.buttons[i].controllerOf];
fIV ¬ NIL;
SELECT h.fieldViewer.buttons[i].type FROM
arId => 
fIV ¬ NEW [AdobeP75V2.FieldItemValueRec.arId ¬ [arId[Convert.CardFromRope[r]]]];
dateTime => 
IF r = NIL OR r.Length = 0 OR r.IsEmpty[] THEN
fIV ¬ NEW [AdobeP75V2.FieldItemValueRec.dateTime ¬ [dateTime[BasicTime.nullGMT]]]
ELSE
fIV ¬ NEW [AdobeP75V2.FieldItemValueRec.dateTime ¬ [dateTime[Convert.TimeFromRope[r]]]];
numeric => 
IF r = NIL OR r.Length = 0 OR r.IsEmpty[] THEN
fIV ¬ NEW [AdobeP75V2.FieldItemValueRec.numeric ¬ [numeric[0]]]
ELSE
fIV ¬ NEW [AdobeP75V2.FieldItemValueRec.numeric ¬ [numeric[Convert.CardFromRope[r]]]];
fixedLengthString => 
IF r = NIL OR r.Length = 0 OR r.IsEmpty[] THEN
fIV ¬ NEW [AdobeP75V2.FieldItemValueRec.fixedLengthString ¬ [fixedLengthString[NIL, h.fieldViewer.buttons[i].maxLength]]]
ELSE
fIV ¬ NEW [AdobeP75V2.FieldItemValueRec.fixedLengthString ¬ [fixedLengthString[r, h.fieldViewer.buttons[i].maxLength]]];
enumerated => {
evalNum: CARD ¬ 0;
r: Rope.ROPE ¬ Rope.Substr[h.getBoxName[h.fieldViewer.buttons[i].button], 0, h.getBoxName[h.fieldViewer.buttons[i].button].Length - 2];
cO: Rope.ROPE ¬ h.getContents[h.fieldViewer.buttons[i].controllerOf];
cO ¬ Rope.Substr[cO, 1, cO.Length - 2];
FOR j: CARD IN [0..h.systemHandle.fieldList.length) DO
IF Rope.Equal[h.systemHandle.fieldList[j].name, r] THEN {
WITH h.systemHandle.fieldList[j] SELECT FROM
it: REF AdobeP75V2.FieldItemObjectRec.enumerated => {
FOR k: CARD IN [0..it.possibilities.length) DO
FOR l: CARD IN [0..it.possibilities[k].enumRecs.length) DO
IF Rope.Equal[it.possibilities[k].enumRecs[l].tag, cO] THEN {
fIV ¬ NEW[AdobeP75V2.FieldItemValueRec.enumerated ¬ [enumerated[it.possibilities[k].enumRecs[l].item]]];
done ¬ TRUE;
};
IF done THEN EXIT;
ENDLOOP;
IF done THEN EXIT;
ENDLOOP;
};
ENDCASE => ERROR;
EXIT;
};
ENDLOOP;
IF ~done THEN
fIV ¬ NEW[AdobeP75V2.FieldItemValueRec.enumerated ¬ [enumerated[LAST[CARD16]]]];
};
string => {};
ENDCASE => ERROR;
IF fIV  # NIL THEN
XNSAdobeClientOps.UpdateAcceleratorField[h.systemHandle.service, AccessCH.NSNameFromRope[h.systemName].local, h.systemHandle.version, h.currentAR, fIV, Rope.Substr[h.getBoxName[h.fieldViewer.buttons[i].button], 0, h.getBoxName[h.fieldViewer.buttons[i].button].Length-2]];
ENDLOOP;
h.report[h, "done.\n"];
} ELSE
AdobeTool.EnableUserEdits[h];
h.isBusy ¬ FALSE;
};
ENDCASE => {};
};

CheckOutRope: Rope.ROPE ~ "Checking out AR #%g  ...";

CheckIn: PUBLIC PROC[h: AdobeUI.Handle] ~ {
ENABLE UNWIND => NULL;
DoCheckIn[h];
};

CheckInAndOut: PUBLIC PROC[h: AdobeUI.Handle] ~ {
ENABLE UNWIND => NULL;
DoCheckIn[h];
DoCheckOut[h];
};

CheckInAndExamine: PUBLIC PROC[h: AdobeUI.Handle] ~ {
ENABLE UNWIND => NULL;
DoCheckIn[h];
DoExamine[h];
};

Examine: PUBLIC PROC[h: AdobeUI.Handle] ~ {
ENABLE UNWIND => NULL;
DoExamine[h];
};

CheckOut: PUBLIC PROC[h: AdobeUI.Handle] ~ {
ENABLE UNWIND => NULL;
DoCheckOut[h];
};

DoCheckOut: PROC[h: AdobeUI.Handle] ~ {
IF ~CheckSystem[h] THEN RETURN;
IF BusyTest[h] THEN RETURN;
DoExamine[h, CheckOutRope, TRUE];
AdobeTool.EnableUserEdits[h];
h.currentARState ¬ CheckedOut;
h.setIcon[h, $editted];
h.paintBox[h.outer, $all];
};

AbortCheckOut: PUBLIC PROCEDURE [h: AdobeUI.Handle] = {
ENABLE UNWIND => NULL;

IF ~CheckSystem[h] THEN RETURN;
IF BusyTest[h] THEN RETURN;

SELECT h.currentARState FROM
Normal => h.report[h, "No AR checked out.\n"];
CheckedOut => {
h.isBusy  ¬ TRUE;
h.report[h, "Aborting check out of AR#%g ... ", [integer[h.currentAR]]];
h.currentARState ¬ Normal;
AdobeTool.DisableUserEdits[h];
AdobeIO.UnlockProc[h.currentAR, h];
h.setIcon[h, $normal];
h.paintBox[h.outer, $all];
h.isBusy  ¬ FALSE;
h.report[h, "done.\n"];
};
ENDCASE => {};
};

Next: PUBLIC PROCEDURE [h: AdobeUI.Handle] = {
ENABLE UNWIND => NULL;
instanceData: AdobeCommonInternal.InstanceDataHandle ¬ NARROW[h.instanceData];
number: CARDINAL ¬ 0;

WITH instanceData SELECT FROM
id: REF AdobeCommonInternal.InstanceData.edit => 
IF id.useQL THEN {
IF id.qlSetStatus = AdobeCommon.InitialSetStatus THEN id.qlSetStatus ¬ [0,0]
ELSE {
id.qlSetStatus.runOffset ¬ id.qlSetStatus.runOffset + 1;
IF id.qlSetStatus.runOffset = id.qlHandle.list.body[id.qlSetStatus.setIndex].runLength THEN {
id.qlSetStatus.runOffset ¬ 0;
id.qlSetStatus.setIndex ¬ id.qlSetStatus.setIndex + 1;
IF id.qlSetStatus.setIndex = id.qlHandle.list.len THEN {
id.qlSetStatus ¬ AdobeCommon.InitialSetStatus;
AdobeCommon.PostMessage[h, TRUE, "Query List Exhausted"];
h.setDisplayStyle[h.useQLButton, $BlackOnWhite];
id.useQL ¬ FALSE;
RETURN;
}
}
};
number ¬ id.qlHandle.list.body[id.qlSetStatus.setIndex].startValue + id.qlSetStatus.runOffset;
}
ELSE {
number ¬ GetNumber[h];
IF number # LAST[CARDINAL] THEN number ¬ number + 1;
};
ENDCASE;
IF number # LAST[CARDINAL] THEN
h.setContents[h.editors[1], Convert.RopeFromCard[number, 10, FALSE]];
};

Previous: PUBLIC PROCEDURE [h: AdobeUI.Handle] = {
ENABLE UNWIND => NULL;
instanceData: AdobeCommonInternal.InstanceDataHandle ¬ NARROW[h.instanceData];
number: CARDINAL ¬ 0;

WITH instanceData SELECT FROM
id: REF AdobeCommonInternal.InstanceData.edit => 
IF id.useQL THEN {
IF id.qlSetStatus = AdobeCommon.InitialSetStatus THEN id.qlSetStatus ¬ [id.qlHandle.list.body[id.qlHandle.list.len-1].runLength-1, id.qlHandle.list.len-1]
ELSE 
IF id.qlSetStatus.runOffset # 0 THEN 
id.qlSetStatus.runOffset ¬ id.qlSetStatus.runOffset - 1
ELSE 
IF id.qlSetStatus.setIndex # 0 THEN {
id.qlSetStatus.setIndex ¬ id.qlSetStatus.setIndex - 1;
id.qlSetStatus.runOffset ¬ id.qlHandle.list.body[id.qlSetStatus.setIndex].runLength-1;
}
ELSE {
AdobeCommon.PostMessage[h, TRUE, "Query List Exhausted"];
h.setDisplayStyle[h.useQLButton, $BlackOnWhite];
id.useQL ¬ FALSE;
id.qlSetStatus ¬ AdobeCommon.InitialSetStatus;
RETURN;
};
number ¬ id.qlHandle.list.body[id.qlSetStatus.setIndex].startValue + id.qlSetStatus.runOffset;
}
ELSE {
number ¬ GetNumber[h];
IF number # LAST[CARDINAL] THEN number ¬ number - 1;
};
ENDCASE;

IF number # LAST[CARDINAL]THEN
h.setContents[h.editors[1], Convert.RopeFromCard[number, 10, FALSE]];
};

UseQL: PUBLIC PROCEDURE [h: AdobeUI.Handle] = {
ENABLE UNWIND => NULL;
instanceData: AdobeCommonInternal.InstanceDataHandle ¬ NARROW[h.instanceData];
ql: AdobeOps.QueryList ¬ NIL;

WITH instanceData SELECT FROM
id: REF AdobeCommonInternal.InstanceData.edit => {
IF id.useQL THEN {
id.useQL ¬ FALSE;
h.setDisplayStyle[h.useQLButton , $BlackOnWhite];
RETURN;
};
ql ¬ AdobeCommon.FindThisQL[h.getContents[h.editors[3]], h];
IF ql = NIL OR ql.list = NIL THEN
AdobeCommon.PostMessage[h, TRUE, "Empty QueryList!"]
ELSE {
h.setDisplayStyle[h.useQLButton , $WhiteOnBlack];
id.qlSetStatus ¬ AdobeCommon.InitialSetStatus;
id.useQL ¬ TRUE;
id.qlName ¬ ql.name;
id.qlHandle ¬ ql;
};
};
ENDCASE;
};

WhichQL: PUBLIC PROCEDURE [h: AdobeUI.Handle, mouseButton: ViewerClasses.MouseButton] = {
ENABLE UNWIND => NULL;
instanceData: AdobeCommonInternal.InstanceDataHandle ¬ NARROW[h.instanceData];
sel: ViewerTools.SelPos ¬ NIL;

WITH instanceData SELECT FROM
id: REF AdobeCommonInternal.InstanceData.edit => 
IF id.useQL THEN {
AdobeCommon.PostMessage[h, TRUE, "Currently using that QueryList."];
RETURN
};
ENDCASE;
SELECT mouseButton FROM
red => h.setSelection[h.editors[3]];
blue => {
h.setContents[h.editors[3], ""];
h.setSelection[h.editors[3]];
};
ENDCASE => {
l: LIST OF Rope.ROPE ¬ NIL;
which: INT ¬ 0;

FOR q: AdobeOps.QLHandle ¬ h.systemHandle.otherQLs, q.next UNTIL q = NIL DO
l ¬ CONS[q.qL.name, l];
ENDLOOP;
l ¬ CONS["SysQL", l];
which ¬ h.popUpRequest["Query List Name", l];
SELECT which FROM
<= 0 => RETURN;
1 => h.setContents[h.editors[3], "SysQL"];
ENDCASE =>
FOR lr: LIST OF Rope.ROPE  ¬ l, lr.rest UNTIL lr = NIL DO
which ¬ which - 1;
IF which = 0 THEN
h.setContents[h.editors[3], lr.first];
ENDLOOP;
sel ¬ NEW[ViewerTools.SelPosRec ¬ [h.getContents[h.editors[3]].Length + 1, 0, FALSE, after]];
h.setSelection[h.editors[3], sel];
};

};

Clear: PUBLIC PROCEDURE [h: AdobeUI.Handle] = {
ENABLE UNWIND => NULL;
AdobeTool.EmptyContents[h];
AdobeTool.SetUpDefaults[h];
};

WhichQL2: PUBLIC PROCEDURE [h: AdobeUI.Handle, mouseButton: ViewerClasses.MouseButton] = {
ENABLE UNWIND => NULL;
sel: ViewerTools.SelPos ¬ NIL;

SELECT mouseButton FROM
red => h.setSelection[h.editors[1]];
blue => {
h.setContents[h.editors[1], ""];
h.setSelection[h.editors[1]];
};
ENDCASE => {
l: LIST OF Rope.ROPE ¬ NIL;
which: INT ¬ 0;

FOR q: AdobeOps.QLHandle ¬ h.systemHandle.otherQLs, q.next UNTIL q = NIL DO
l ¬ CONS[q.qL.name, l];
ENDLOOP;
l ¬ CONS["SysQL", l];
which ¬ h.popUpRequest["Query List Name", l];
SELECT which FROM
<= 0 => RETURN;
1 => h.setContents[h.editors[1], "SysQL"];
ENDCASE =>
FOR lr: LIST OF Rope.ROPE  ¬ l, lr.rest UNTIL lr = NIL DO
which ¬ which - 1;
IF which = 0 THEN
h.setContents[h.editors[1], lr.first];
ENDLOOP;
sel ¬ NEW[ViewerTools.SelPosRec ¬ [h.getContents[h.editors[1]].Length + 1, 0, FALSE, after]];
h.setSelection[h.editors[1], sel];
};
};

GetSubmitFileName: PROCEDURE [h: AdobeUI.Handle] RETURNS [fName: Rope.ROPE ¬ NIL] ~ {
fName ¬ h.getContents[h.editors[1]];
IF fName = NIL OR fName.Length = 0 OR fName.IsEmpty[] THEN {
fName ¬ NIL;
h.report[h, "Invalid file name!\n"];
};
};

Put: PUBLIC PROCEDURE [h: AdobeUI.Handle] = {
ENABLE UNWIND => NULL;
fName: Rope.ROPE ¬ GetSubmitFileName[h];

IF fName # NIL THEN 
[] ¬ AdobeIO.WriteProc[h, PFS.StreamOpen[PFS.PathFromRope[fName], write]];
};

Get: PUBLIC PROCEDURE [h: AdobeUI.Handle] = {
ENABLE UNWIND => NULL;
fName: Rope.ROPE ¬ GetSubmitFileName[h];
{
ENABLE PFS.Error => {
h.report[h, "Invalid file name!\n"];
GOTO badFile;
};
IF fName # NIL THEN
AdobeIO.ReadProc[0, h, PFS.StreamOpen[PFS.PathFromRope[fName], read], FALSE];
EXITS
badFile => {};
};
};

Submit: PUBLIC PROCEDURE [h: AdobeUI.Handle] = {
num: CARD ¬ 0;
arField: CARD ¬ 0;
fIV: AdobeP75V2.FieldItemValue;
r: Rope.ROPE ¬ NIL;
done: BOOL ¬ FALSE;
{
ENABLE UNWIND => {
h.report[h, "submit failed.\n"];
XNSAdobeClientOps.SubmitFailed[h.systemHandle.service, AccessCH.NSNameFromRope[h.systemName].local, h.systemHandle.version, num];
AdobeTool.EnableUserEdits[h];

};

IF BusyTest[h] THEN RETURN;

h.report[h, "Submitting . . . "];
AdobeTool.DisableUserEdits[h];
{
DoProc: PROC [h:AdobeUI.Handle] ~ {
num ¬ XNSAdobeClientOps.GetNextSubmitNumber[h.systemHandle.service, AccessCH.NSNameFromRope[h.systemName].local];
FOR i: CARD IN [0..h.fieldViewer.buttons.length) DO
IF h.fieldViewer.buttons[i].type = arId THEN {
arField ¬ i;
EXIT;
};
ENDLOOP;
h.setContents[h.fieldViewer.buttons[arField].controllerOf, Convert.RopeFromCard[num, 10, FALSE]];
h.currentAR ¬ num;
};
XNSAdobeClientOps.AboutToStore[h.systemHandle.service, AccessCH.NSNameFromRope[h.systemName].local, h.systemHandle.version, num];
IF ~AdobeIO.WriteProc[h, NIL, DoProc] THEN {
h.report[h, "submit failed.\n"];
XNSAdobeClientOps.SubmitFailed[h.systemHandle.service, AccessCH.NSNameFromRope[h.systemName].local, h.systemHandle.version, num];
}
ELSE {
h.report[h, "Updating Accelerators . . . "];
FOR i: CARD IN [0..h.fieldViewer.buttons.length) DO
done ¬ FALSE;
r ¬ h.getContents[h.fieldViewer.buttons[i].controllerOf];
fIV ¬ NIL;
SELECT h.fieldViewer.buttons[i].type FROM
arId => 
fIV ¬ NEW [AdobeP75V2.FieldItemValueRec.arId ¬ [arId[Convert.CardFromRope[r]]]];
dateTime => 
IF r = NIL OR r.Length = 0 OR r.IsEmpty[] THEN
fIV ¬ NEW [AdobeP75V2.FieldItemValueRec.dateTime ¬ [dateTime[BasicTime.nullGMT]]]
ELSE
fIV ¬ NEW [AdobeP75V2.FieldItemValueRec.dateTime ¬ [dateTime[Convert.TimeFromRope[r]]]];
numeric => 
IF r = NIL OR r.Length = 0 OR r.IsEmpty[] THEN
fIV ¬ NEW [AdobeP75V2.FieldItemValueRec.numeric ¬ [numeric[0]]]
ELSE
fIV ¬ NEW [AdobeP75V2.FieldItemValueRec.numeric ¬ [numeric[Convert.CardFromRope[r]]]];
fixedLengthString => 
IF r = NIL OR r.Length = 0 OR r.IsEmpty[] THEN
fIV ¬ NEW [AdobeP75V2.FieldItemValueRec.fixedLengthString ¬ [fixedLengthString[NIL, h.fieldViewer.buttons[i].maxLength]]]
ELSE
fIV ¬ NEW [AdobeP75V2.FieldItemValueRec.fixedLengthString ¬ [fixedLengthString[r, h.fieldViewer.buttons[i].maxLength]]];
enumerated => {
evalNum: CARD ¬ 0;
r: Rope.ROPE ¬ Rope.Substr[h.getBoxName[h.fieldViewer.buttons[i].button], 0, h.getBoxName[h.fieldViewer.buttons[i].button].Length - 2];
cO: Rope.ROPE ¬ h.getContents[h.fieldViewer.buttons[i].controllerOf];
cO ¬ Rope.Substr[cO, 1, cO.Length - 2];
FOR j: CARD IN [0..h.systemHandle.fieldList.length) DO
IF Rope.Equal[h.systemHandle.fieldList[j].name, r] THEN {
WITH h.systemHandle.fieldList[j] SELECT FROM
it: REF AdobeP75V2.FieldItemObjectRec.enumerated => {
FOR k: CARD IN [0..it.possibilities.length) DO
FOR l: CARD IN [0..it.possibilities[k].enumRecs.length) DO
IF Rope.Equal[it.possibilities[k].enumRecs[l].tag, cO] THEN {
fIV ¬ NEW[AdobeP75V2.FieldItemValueRec.enumerated ¬ [enumerated[it.possibilities[k].enumRecs[l].item]]];
done ¬ TRUE;
};
IF done THEN EXIT;
ENDLOOP;
IF done THEN EXIT;
ENDLOOP;
};
ENDCASE => ERROR;
EXIT;
};
ENDLOOP;
IF ~done THEN
fIV ¬ NEW[AdobeP75V2.FieldItemValueRec.enumerated ¬ [enumerated[LAST[CARD16]]]];
};
string => {};
ENDCASE => ERROR;
IF fIV  # NIL THEN
XNSAdobeClientOps.UpdateAcceleratorField[h.systemHandle.service, AccessCH.NSNameFromRope[h.systemName].local, h.systemHandle.version, num, fIV, Rope.Substr[h.getBoxName[h.fieldViewer.buttons[i].button], 0, h.getBoxName[h.fieldViewer.buttons[i].button].Length-2]];
ENDLOOP;
};
AdobeTool.EnableUserEdits[h];
h.report[h, "Done.\n"]
};
};
};

GetUserFile: PROCEDURE [h: AdobeUI.Handle] ~ {
currentToolRope, currentFieldRope, currentFieldData: Rope.ROPE ¬ NIL;
AdobeCommon.SetFSWOrderAndDefaultFromUserFile[
systemName: h.systemName,
arSH: h.systemHandle,
server: h.systemHandle.host];
};

ChangeSystem: PUBLIC PROCEDURE [h: AdobeUI.Handle] = {
h2: AdobeUI.Handle ¬ h;
systemField: Rope.ROPE ¬ NIL;
tmpSys: AdobeOps.ARSystemHandle ¬ h.systemHandle;

IF h.isBusy THEN {
h.report[h, "Adobe is busy, cannot switch systems! \n"];
RETURN;
};
h.isBusy ¬ TRUE;
h.report[h, "Changing System ... "];
systemField ¬ h.systemName;

h.system ¬ AdobeCommon.LocateSystemInKnownSystems[systemField, h.knownSystems ! AdobeCommonInternal.SystemNotFound => {AdobeCommon.AddSystemToKnownSystems[systemField, h.knownSystems];
RETRY}];
IF h.system = LAST[CARD] THEN {h.oldsystem ¬ h.system; h.isBusy ¬ FALSE; RETURN};

h.systemHandle ¬ AdobeCommon.FindSystem[NIL, h, h.knownSystems.system[h.system], FALSE ! 
CrRPC.Error => { h2.systemHandle ¬ NIL; h2.report[h2, "Adobe Server is down.\n"]; CONTINUE};
AdobeCommonInternal.SystemNotFound => { 
AdobeCommon.RemoveSystemFromKnownSystems[system, h.knownSystems];
h.systemHandle ¬ tmpSys;
h.system ¬ h.oldsystem;
h.isBusy ¬ FALSE;
GOTO badsys;
};
];
IF h.systemHandle = NIL THEN {
h.systemHandle ¬ tmpSys;
h.isBusy ¬ FALSE;
h.system¬ h.oldsystem;
RETURN
};
IF h.systemHandle = tmpSys THEN {
h.report[h, "System selected is same as current system, no change made.\n"];
h.isBusy ¬ FALSE;
RETURN
}
ELSE {
AdobeTool.ClearWindow[h];
AdobeTool.SetUpWindow[h];
GetUserFile[h];
h.report[h, "Done.\n"];
h.oldsystem ¬ h.system;
};
h.isBusy ¬ FALSE;
EXITS 
badsys => RETURN;
};

formatFormsList: LIST OF Rope.ROPE ¬ LIST["plain", "columns", "template"];

RopeFromFormat: PROCEDURE [format: AdobeCommon.FormatType] RETURNS [rope: Rope.ROPE ¬ NIL] = {
SELECT format FROM
plain =>       {RETURN ["{plain}"] };
columns =>    {RETURN ["{columns}"] };
template =>     {RETURN ["{template}"] };
ENDCASE;
};

OutputFormat: PUBLIC PROCEDURE [h: AdobeUI.Handle] = {
ENABLE UNWIND => NULL;
instanceData: AdobeCommonInternal.InstanceDataHandle ¬ NARROW[h.instanceData];
WITH instanceData SELECT FROM
id: REF AdobeCommonInternal.InstanceData.report => {
ft: AdobeCommon.FormatType ¬ plain;
which:INT;
which ¬ h.popUpRequest["Output Format", formatFormsList];
SELECT which FROM
<= 0 => RETURN; --nothing selected
1 => ft ¬ plain;
2 => ft ¬ columns;
3 => ft ¬ template;
ENDCASE => {
h.report[h, "Don't really know what you did.\n"];
RETURN;
};

IF ft # id.format THEN {

IF h.formatButton # NIL THEN {
h.reLabelBox[h.formatButton, RopeFromFormat[ft]];
id.format ¬ ft;
}
ELSE RETURN
};
}
ENDCASE;
};

SystemMenu: PUBLIC PROC [h: AdobeUI.Handle] = {
newSystemName, oldSys, newSys: Rope.ROPE ¬ NIL;
sysNum, oldSysNum: CARD;
{
ENABLE UNWIND => NULL;

which: INT ¬ 0;
oldSystemMenuEntry: REF ANY ¬ h.systemMenuItem;
sysList: LIST OF Rope.ROPE ¬ LIST["Current Selection"];
FOR i: CARD IN [0..h.knownSystems.next) DO
sysList ¬ CONS[h.knownSystems.system[h.knownSystems.next - i - 1], sysList];
ENDLOOP;
which ¬ h.popUpRequest["System", sysList];
oldSysNum ¬ h.oldsystem;
sysNum ¬ h.system;

SELECT which FROM
<= 0 => RETURN; --nothing selected
ENDCASE => 
sysNum ¬ which - 1;

IF sysNum = h.knownSystems.next THEN {
newSystemName: Rope.ROPE ¬ h.getSelectionContents[h.outer];
sysNum ¬ LAST[CARD];

sysNum ¬ AdobeCommon.LocateSystemInKnownSystems[newSystemName, h.knownSystems ! AdobeCommonInternal.SystemNotFound => {
AdobeCommon.AddSystemToKnownSystems[newSystemName, h.knownSystems];
RETRY}];
};


IF oldSysNum # LAST[CARDINAL] THEN
oldSys ¬ h.knownSystems.system[oldSysNum];
IF sysNum # LAST[CARDINAL] THEN
newSys ¬ h.knownSystems.system[sysNum];
IF oldSystemMenuEntry # NIL THEN  {
newMenuEntry: AdobeCommon.Box ¬ h.newMenuEntry[newSys];
h.systemName ¬ newSys;
h.replaceMenuEntry[h, h.menu, oldSystemMenuEntry, newMenuEntry];
oldSysNum ¬ sysNum;
h.paintBox[h.outer, $menu];
}
ELSE {
h.report[h, "Didn't find old Menu Entry!\n"];
sysNum ¬ oldSysNum;
}
};
};

toolFormsList: LIST OF Rope.ROPE ¬ LIST["Edit", "Submit", "Report", "Query", "Sort", "QueryList"];

ListAction: PUBLIC PROCEDURE [h: AdobeUI.Handle, mouseButton: ViewerClasses.MouseButton] ~ {[] ¬ HandleField[h, 4, mouseButton]};

ToolMenu: PUBLIC PROCEDURE [h: AdobeUI.Handle] = {
ENABLE UNWIND => NULL;

which:INT;
IF BusyTest[h] THEN RETURN;
IF h.currentARState = CheckedOut THEN {
h.report[h, "Do a CheckIn first.\n"];
RETURN;
};
IF h.systemHandle = NIL THEN {
h.report[h, "Select a system first.\n"];
RETURN;
};
which ¬ h.popUpRequest["Tools", toolFormsList];
SELECT which FROM
<= 0 => RETURN; --nothing selected
1 => {
h.tool ¬ edit;
};
2 => {
h.tool ¬ submit;
};
3 => {
h.tool ¬ report;
};
4 => {
h.tool ¬ query;
};
5 => {
h.tool ¬ sort;
};
6 => {
h.tool ¬ queryList;
};
ENDCASE => {
h.report[h, "Don't really know what you did.\n"];
RETURN;
};

IF (h.tool # h.oldtool) THEN {
oldToolMenuEntry: REF ANY ¬ h.findMenuEntry[h: h, entryName: Rope.Concat["{", Rope.Concat[RopeFromTool[h.oldtool], "}"]]];
IF oldToolMenuEntry # NIL THEN  {
newToolMenuEntry: REF ANY ¬ h.newMenuEntry[
entryName: Rope.Concat["{", Rope.Concat[RopeFromTool[h.tool], "}"]]];
h.replaceMenuEntry[
h: h,
menu: h.menu,
oldEntry: oldToolMenuEntry,
newEntry: newToolMenuEntry];
AdobeTool.ClearWindow[h];
h.oldtool ¬ h.tool;
h.addButtons[h];
SELECT h.tool FROM
query => h.instanceData ¬ NEW[AdobeCommonInternal.InstanceData.query];
edit => h.instanceData ¬ NEW[AdobeCommonInternal.InstanceData.edit];
submit => h.instanceData ¬ NEW[AdobeCommonInternal.InstanceData.submit];
report => {
idh: AdobeCommonInternal.InstanceDataHandle;
h.instanceData ¬ NEW[AdobeCommonInternal.InstanceData.report];
idh ¬ NARROW[h.instanceData];
WITH idh SELECT FROM
id: REF AdobeCommonInternal.InstanceData.report => {
id.entryBytes ¬ NEW[AdobeCommonInternal.EntryBytesType ¬ [0]];
id.rowBuffer ¬ NEW[AdobeCommon.RowBufferRec ¬ [NIL, NIL]];
};
ENDCASE;
};
sort => h.instanceData ¬ NEW[AdobeCommonInternal.InstanceData.sort];
queryList => h.instanceData ¬ NEW[AdobeCommonInternal.InstanceData.queryList];
ENDCASE;
AdobeTool.SetUpWindow[h];
h.paintBox[h.outer, $menu];
h.setIcon[h, $normal];
h.paintBox[h.outer, $all];
}
ELSE h.tool ¬ h.oldtool;
};

};

QLOperandProc: PUBLIC PROCEDURE [h: AdobeUI.Handle, mouseButton: ViewerClasses.MouseButton, which: CARD, title: Rope.ROPE] = {
ENABLE UNWIND => NULL;
selections: LIST OF Rope.ROPE ¬ NIL;
choice: INT;
sel: ViewerTools.SelPos ¬ NIL;

FOR q: AdobeOps.QLHandle ¬ h.systemHandle.otherQLs, q.next UNTIL q = NIL DO
selections ¬ CONS[q.qL.name, selections];
ENDLOOP;
selections ¬ CONS["filename", selections];
selections ¬ CONS["List", selections];
selections ¬ CONS["SysQL", selections];
choice ¬ HandleField[h, which, mouseButton, title, selections];
IF choice > 0 THEN {
choice ¬ choice - 1;
WHILE choice > 0 DO
selections ¬ selections.rest;
choice ¬ choice - 1;
ENDLOOP;
h.setContents[h.editors[which], selections.first];
sel ¬ NEW[ViewerTools.SelPosRec ¬ [selections.first.Length + 1, 0, FALSE, after]];
h.setSelection[h.editors[which], sel];
};
};

CurrentButton: PUBLIC PROC [data: AdobeTool.CurrentButtonProcData, parent: AdobeCommon.Box] = {
ENABLE UNWIND => NULL;
which: INT ¬ 0;
handle: AdobeCommon.EnumeratedTypes ¬ data.e;
index: CARDINAL ¬ 0;

IF handle.dependentOn # NIL THEN {
handle.currentMenu ¬ handle.dependentOn.currentSelection;
};

IF handle.currentMenu >= handle.allSelections.length THEN {
sels: LIST OF Rope.ROPE ¬ CONS["Nil", NIL];
which ¬ data.h.popUpRequest[data.h.getBoxName[parent], sels];
}
ELSE {
which ¬ data.h.popUpRequest[data.h.getBoxName[parent], handle.allSelections[handle.currentMenu].ropes];
IF handle.boolVal = TRUE THEN RETURN;
SELECT which FROM
<= 0 => RETURN;
ENDCASE => AdobeTool.SetEnumValue[data.h, handle, which-1];
};
};

CheckField: PUBLIC PROC [enumData: AdobeCommon.EnumeratedTypes] = {
windowData: AdobeUI.Handle ¬ enumData.mainViewer;
instanceData: AdobeCommonInternal.InstanceDataHandle ¬ NARROW[windowData.instanceData];
WITH instanceData SELECT FROM
toolData: REF AdobeCommonInternal.InstanceData.report => {
IF toolData.fieldsInReport[enumData.fieldNum] THEN {
windowData.setDisplayStyle[enumData.button, $BlackOnWhite];
toolData.fieldsInReport[enumData.fieldNum] ¬ FALSE;
RETURN;
}
ELSE {
toolData.fieldsInReport[enumData.fieldNum] ¬ TRUE;
windowData.setDisplayStyle[enumData.button, $WhiteOnBlack];
WITH windowData.systemHandle.fieldList[enumData.fieldNum] SELECT FROM
fli: AdobeOps.StrFIO => {
AdobeCommon.PostMessage[windowData, FALSE, "A report with "];
AdobeCommon.PostMessage[windowData, FALSE, fli.name];
AdobeCommon.PostMessage[windowData, TRUE, " wouldn't use accelerator files!"]};
ENDCASE};
};
ENDCASE};

GetValueFromEnum: PROC [bh: AdobeCommon.EnumeratedTypes] RETURNS [v: CARD ¬ LAST[CARD]]~ {
index: CARD ¬ 0;
valInField: Rope.ROPE ¬ bh.mainViewer.getContents[bh.controllerOf];
FOR sels: LIST OF Rope.ROPE ¬ bh.allSelections[bh.currentMenu].ropes, sels.rest UNTIL sels = NIL DO
IF Rope.Equal[valInField, sels.first, FALSE] THEN
RETURN[index]
ELSE index ¬ index + 1;
ENDLOOP;
RETURN[LAST[CARD]];
};

HintMenu: PUBLIC PROCEDURE [buttonData: AdobeCommon.EnumeratedTypes, mouseButton: ViewerClasses.MouseButton] =
{
ropeToPutIn: Rope.ROPE ¬ NIL;
count: INT ¬ 0;
data: AdobeCommon.Handle ¬ buttonData.mainViewer;
arSH: AdobeOps.ARSystemHandle ¬ data.systemHandle;
fL: AdobeOps.FieldList ¬ data.systemHandle.fieldList;
--flIndex: CARDINAL ¬ arSH.formSWOrderArray[data.tool][index];
enumValue, i: CARDINAL;
enumStrings, relStrings, hintSeqList: LIST OF Rope.ROPE ¬ NIL;
hintSeq: REF AdobeCommon.StringArray;
which: INT ¬ 0;
SELECT mouseButton FROM
red => {
data.setSelection[buttonData.controllerOf];
RETURN
};
blue => {
data.setContents[buttonData.controllerOf, ""];
data.setSelection[buttonData.controllerOf];
RETURN
};
ENDCASE;
SELECT buttonData.type FROM
arId => hintSeq ¬ AdobeTool.GetValidRelations[arId];
dateTime => hintSeq ¬ AdobeTool.GetValidRelations[dateTime];
numeric => hintSeq ¬ AdobeTool.GetValidRelations[numeric];
fixedLengthString => hintSeq ¬ AdobeTool.GetValidRelations[fixedLengthString];
enumerated => {
IF buttonData.dependentOn # NIL THEN {   
enumValue ¬ GetValueFromEnum[buttonData.dependentOn];
buttonData.currentMenu ¬ enumValue;
};
enumStrings ¬ AdobeTool.GetPossibilities[buttonData];
hintSeq ¬ AdobeTool.GetValidRelations[enumerated];
};
ENDCASE;
FOR i IN [0..hintSeq.length) DO
relStrings ¬ CONS[hintSeq[hintSeq.length-i-1], relStrings];
ENDLOOP;
FOR i: LIST OF Rope.ROPE ¬ enumStrings, i.rest UNTIL i = NIL DO
count ¬ count + 1;
ENDLOOP;
hintSeq ¬ NEW[AdobeCommon.StringArray[count]];
FOR i: LIST OF Rope.ROPE ¬ enumStrings, i.rest UNTIL i = NIL DO
count ¬ count - 1;
hintSeq[count] ¬ i.first;
ENDLOOP;
FOR i: CARD IN [0..hintSeq.length) DO
relStrings ¬ CONS[hintSeq[i], relStrings];
ENDLOOP;
which ¬ data.popUpRequest[data.getBoxName[buttonData.button], relStrings];
IF which > 0 THEN {
sel: ViewerTools.SelPos ¬ NIL;
count ¬ 1;
ropeToPutIn ¬ "Total confusion.";
FOR i: LIST OF Rope.ROPE ¬ relStrings, i.rest UNTIL i = NIL DO
IF count = which THEN 
ropeToPutIn ¬ i.first;
count ¬ count + 1;
ENDLOOP;
data.setContents[
buttonData.controllerOf, 
Rope.Concat[data.getContents[buttonData.controllerOf], ropeToPutIn]];
sel ¬ NEW[ViewerTools.SelPosRec ¬ [data.getContents[buttonData.controllerOf].Length + 1, 0, FALSE, after]];
data.setSelection[buttonData.controllerOf, sel];
};
};

SubmitFieldButton: PUBLIC PROCEDURE [data: AdobeTool.CurrentButtonProcData, mouseButton: ViewerClasses.MouseButton] ~ {
buttonH: AdobeCommon.EnumeratedTypes ¬ data.e;

IF ~buttonH.boolVal THEN {
SELECT mouseButton FROM
red, yellow => data.h.setSelection[buttonH.controllerOf];
blue =>  {
data.h.setContents[buttonH.controllerOf, ""];
data.h.setSelection[buttonH.controllerOf];
};
ENDCASE;
};

};

ResetQL: PUBLIC PROCEDURE [h: AdobeUI.Handle] = {
ENABLE UNWIND => NULL;
ql: AdobeOps.QueryList ¬ NIL;

ql ¬ AdobeCommon.FindThisQL[h.getContents[h.editors[1]], h];

IF ql # NIL THEN ql.list ¬ NIL;
};

NumberEquals: PUBLIC PROC [h: AdobeUI.Handle, mouseButton: ViewerClasses.MouseButton] = {
ENABLE UNWIND => NULL;
[] ¬ HandleField[h, 1, mouseButton];
};

EditFilename: PUBLIC PROC [h: AdobeUI.Handle, mouseButton: ViewerClasses.MouseButton] = {
ENABLE UNWIND => NULL;
[] ¬ HandleField[h, 2, mouseButton];
};

ReportOutputFile: PUBLIC PROC [h: AdobeUI.Handle, mouseButton: ViewerClasses.MouseButton] = {
ENABLE UNWIND => NULL;
[] ¬ HandleField[h, 1, mouseButton];
};

ReportTemplateFile: PUBLIC PROC [h: AdobeUI.Handle, mouseButton: ViewerClasses.MouseButton] = {
ENABLE UNWIND => NULL;
[] ¬ HandleField[h, 2, mouseButton];
};

ShowElements: PUBLIC PROCEDURE [h: AdobeUI.Handle] = {
ENABLE UNWIND => NULL;
ql: AdobeOps.QueryList ¬ NIL;
pastFirst: BOOL ¬ FALSE;

ql ¬ AdobeCommon.FindThisQL[h.getContents[h.editors[1]], h];

IF ql = NIL OR ql.list = NIL THEN {
AdobeCommon.PostMessage[h, TRUE, "Empty QueryList!"];
RETURN;
};
AdobeCommon.PostMessage[h, FALSE, "Query Elements for "];
AdobeCommon.PostMessage[h, FALSE, ql.name];
AdobeCommon.PostMessage[h, FALSE, ": "];
FOR i: CARD IN [0..ql.list.len) DO
FOR j: AdobeOps.ARNumber IN [ql.list.body[i].startValue..ql.list.body[i].startValue + ql.list.body[i].runLength) DO
IF pastFirst THEN 
AdobeCommon.PostMessage[h, FALSE, ", "]
ELSE
pastFirst ¬ TRUE;
AdobeCommon.PostNumber[h, FALSE, j];
ENDLOOP;
ENDLOOP;
AdobeCommon.PostMessage[h, TRUE, "."];
};

Overwrite: PUBLIC PROCEDURE [h: AdobeUI.Handle] = {
ENABLE UNWIND => NULL;
instanceData: AdobeCommonInternal.InstanceDataHandle ¬ NARROW[h.instanceData];

WITH instanceData SELECT FROM
id: REF AdobeCommonInternal.InstanceData.report => 
SELECT id.overwrite FROM
TRUE => {
id.overwrite ¬ FALSE;
h.setDisplayStyle[h.overwriteButton, $BlackOnWhite];
};
FALSE => {
id.overwrite ¬ TRUE;
h.setDisplayStyle[h.overwriteButton, $WhiteOnBlack];
};
ENDCASE => ERROR;
ENDCASE;
};

RopeFromTool: PUBLIC PROCEDURE [tool: AdobeOps.ToolType] RETURNS [rope: Rope.ROPE ¬ NIL] = {
SELECT tool FROM
edit =>       {RETURN ["Edit"] };
submit =>    {RETURN ["Submit"] };
report =>     {RETURN ["Report"] };
query =>     {RETURN ["Query"] };
sort =>        {RETURN ["Sort"] };
queryList => {RETURN ["QueryList"] };
ENDCASE;
};

GetNumber: PUBLIC PROCEDURE [h: AdobeUI.Handle] RETURNS [CARDINAL ¬ LAST[CARDINAL]] = {
ENABLE UNWIND => NULL;
RETURN[
Convert.CardFromRope[
h.getContents[h.editors[1]] ! Convert.Error => GOTO IOError]
];
EXITS
IOError => {
h.report[h, "Please enter a positive number in the Number= field.\n"];
h.setSelection[h.editors[1]]
};
};

}.
Ž
AdobeUIImpl.mesa
Copyright Σ 1992 by Xerox Corporation.  All rights reserved.
Philip James, March 10, 1992 3:30 pm PST
Check in AR
Cancel CheckOut
currentTool: AdobeOps.ToolType;
currentField: CARD;
c1, c2: CHAR;
theButton: Buttons.Button _ ViewerOps.FindViewer[RopeFromFormat[handle.oldOutputFormat]];
theButton: Buttons.Button _ handle.lastButton;
WHILE (theButton # NIL) AND (theButton.name # RopeFromFormat[id.format]) DO
theButton _ theButton.sibling;
ENDLOOP;
Buttons.ReLabel[h.formatButton, RopeFromFormat[ft]];
oldSystemMenuEntry _ Menus.FindEntry[
menu: handle.menu,
entryName: oldSys];
oldToolMenuEntry: Menus.MenuEntry _ Menus.FindEntry[
menu: MenuFromAny[handle.menu],
entryName: Rope.Concat["{", Rope.Concat[RopeFromTool[handle.oldtool], "}"]]
];
newToolMenuEntry: Menus.MenuEntry _ Menus.CreateEntry[
name: Rope.Concat["{", Rope.Concat[RopeFromTool[handle.tool], "}"]],
proc: DeadProc
];
Menus.ReplaceMenuEntry[
menu: MenuFromAny[handle.menu],
oldEntry: oldToolMenuEntry,
newEntry: newToolMenuEntry];
the field is already on
the field is now turned on
IF fItem.field # AdobeOps.nullDependsOnIndex THEN
hintSeq _ NEW[AdobeCommon.StringArray[enumStrings.length + relStrings.length]];
FOR i IN [0..enumStrings.length) DO
hintSeq[i] _ enumStrings[i].string;
ENDLOOP;
FOR i IN [0..relStrings.length) DO
hintSeq[i + enumStrings.length] _ relStrings[i]; ENDLOOP
hints _ DESCRIPTOR[hintSeq];
replace _ FALSE;
Κ%Έ–
(cedarcode) style•NewlineDelimiter

™š
œ™Jšœ
Οe
œ1™<J™(—Icode˜š
Οk	˜	Kšœ	žœ˜ Kšœžœ€˜‘KšœžœD˜]Kšœžœ#˜0Kšœ	žœN˜\Kšœžœ9˜IKšœ
žœ§
˜Ά
Kšœžœ
˜Kšœ
žœ˜Kšœžœ3˜@Kšœžœ	˜Kšžœ
žœ#˜,Kšœžœ"žœ
˜:Kšœžœ˜"Kšœžœ˜&KšœžœK˜b—K˜šΠlnœžœ
žœ
˜KšžœQžœ˜tKšžœ˜K˜K˜šΟnœžœžœ6žœžœžœ
žœžœžœžœ	žœ	˜Γ
K˜šžœ
ž˜˜K˜!K˜—šœ
žœž˜šžœ˜K˜$K˜!K˜—Kšžœ.˜5—š
œ	˜	K˜!K˜—Kšžœžœ
˜—K˜K˜—š
 œž	œžœ
žœžœ˜Mšžœ
žœ˜K˜6Kšžœ
žœ˜
K˜—K˜K˜—š
 œžœžœžœžœ˜Išžœžœ
žœžœžœ
žœ˜6Kš
œ&˜&Kšžœ˜K˜—K˜K˜—š œžœ
ž	œžœ˜;K˜K˜K˜—Kš œžœ˜1K˜š
 	œžœžœžœžœ˜VKšžœžœ
ž˜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šœžœ
˜Jš
œ™K˜šžœžœ˜K˜#K˜K˜K˜,šžœžœ
žœ#ž˜3Kšœžœ
˜
K˜9Kšœžœ
˜
šžœž˜)˜KšœžœG˜P—š
œ˜š	žœžœ
žœžœ
ž˜.KšœžœH˜Q—š
ž˜KšœžœO˜X——š
œ˜š	žœžœ
žœžœ
ž˜.Kšœžœ6˜?—š
ž˜KšœžœM˜V——š
œ˜š	žœžœ
žœžœ
ž˜.KšœžœFžœ'˜y—š
ž˜Kšœžœo˜x——š
œ˜Kšœ	žœ˜Kšœžœ{˜‡
Kšœ	žœ8˜EK˜'šžœžœ
žœ&ž˜6šžœ1žœ˜9šžœžœ
ž˜,šœžœ.˜5šžœžœ
žœž˜.šžœžœ
žœ*ž˜:šžœ5žœ˜=K˜hKšœžœ
˜K˜—Kšžœžœ
žœ
˜Kšžœ
˜—Kšžœžœ
žœ
˜Kšžœ
˜—K˜—Kšžœžœ
˜—Kšžœ
˜K˜—Kšžœ
˜—šžœž˜
Kšœžœ7žœ
žœ˜P—K˜—Kš
œ
˜
Kšžœžœ
˜—šžœžœ
ž˜K˜—Kšžœ
˜—Kš
œ˜—šœž˜K˜—Kšœžœ
˜K˜—Kšžœ˜—K˜K˜—Kš œžœ˜5K˜š œžœ
žœ˜+Kšžœ
žœžœ
˜K˜
K˜K˜—š 
œžœ
žœ˜1Kšžœ
žœžœ
˜K˜
K˜K˜K˜—š œžœ
žœ˜5Kšžœ
žœžœ
˜K˜
K˜
K˜K˜—š œžœ
žœ˜+Kšžœ
žœžœ
˜Kš
œ
˜
K˜K˜—š œžœ
žœ˜,Kšžœ
žœžœ
˜K˜K˜K˜—š 
œžœ˜'Kšžœžœ
ž˜Kšžœ
žœ
žœ
˜Kšœžœ˜!K˜K˜Kš
œ˜Kš
œ˜Kš
œ˜K˜—š 
œžœ
ž	œ˜7Kšžœ
žœžœ
˜K˜Kšžœžœ
ž˜Kšžœ
žœ
žœ
˜K˜šžœž˜K˜.˜Jš
œ™Kšœžœ
˜K˜HK˜K˜K˜#K˜Kš
œ˜Kšœžœ
˜K˜Kš
œ˜—Kšžœ˜—Kš
œ˜K˜—š œžœ
ž	œ˜.Kšžœ
žœžœ
˜Kšœ7žœ˜NKšœžœ˜K˜šžœžœ
ž˜šœžœ*˜1šžœ
žœ˜Kšžœ/žœ˜Lšžœ˜K˜8šžœUžœ˜]K˜K˜6šžœ0žœ˜8K˜.Kšœžœ˜9K˜0Kšœž˜Kšžœ
˜K˜
—K˜
—K˜—K˜^K˜
—šžœ˜K˜Kšžœ
žœ
žœžœ˜4K˜——Kšžœ
˜—šžœ
žœ
žœž˜Kšœ=žœ˜E—Kš
œ˜K˜—š œžœ
ž	œ˜2Kšžœ
žœžœ
˜Kšœ7žœ˜NKšœžœ˜K˜šžœžœ
ž˜šœžœ*˜1šžœ
žœ˜Kšžœ/žœe˜š
šžœ
˜šžœžœ
˜%K˜7—šžœ
˜šžœžœ˜%K˜6K˜VK˜
—šžœ˜Kšœžœ˜9K˜0Kšœž˜K˜.Kšžœ
˜K˜———K˜^K˜
—šžœ˜K˜Kšžœ
žœ
žœžœ˜4K˜——Kšžœ
˜—K˜šžœ
žœ
žœ
ž˜Kšœ=žœ˜E—Kš
œ˜K˜—š œžœ
ž	œ˜/Kšžœ
žœžœ
˜Kšœ7žœ˜NKšœžœ
˜K˜šžœ
žœ
ž˜šœžœ+˜2šžœ
žœ˜Kšœž˜Kšœ"Οt˜1Kšžœ
˜K˜—K˜<šžœžœ
žœž˜!Kšœžœ˜4—šžœ˜Kšœ"‘˜1K˜.Kšœžœ
˜K˜K˜K˜—K˜—Kšžœ
˜—Kš
œ˜—K˜š œžœ
ž	œ@˜YKšžœ
žœžœ
˜Kšœ7žœ˜NKšœžœ
˜K˜šžœ
žœ
ž˜šœžœ*˜1šžœ
žœ˜Kšœžœ%˜DKš
ž˜K˜——Kšžœ
˜—šžœ
ž˜K˜$š
œ	˜	K˜ K˜K˜—šžœ˜Kš	œžœ
žœžœžœ
˜Kšœžœ˜K˜šœ;žœžœ
ž˜KKšœžœ˜Kšžœ
˜—Kšœžœ
˜K˜-šžœž˜Kšœžœ
˜K˜*šžœ˜
š
žœžœ
žœžœžœžœ
ž˜9K˜šžœž˜K˜&—Kšžœ
˜——KšœžœEžœ
˜]Kš
œ"˜"—K˜——K˜Kš
œ˜K˜—š œžœ
ž	œ˜/Kšžœ
žœžœ
˜Kš
œ˜K˜Kš
œ˜—K˜š œžœ
ž	œ@˜ZKšžœ
žœžœ
˜Kšœž˜K˜šžœ
ž˜K˜$š
œ	˜	K˜ K˜K˜—šžœ˜Kš	œžœ
žœžœžœ
˜Kšœžœ˜K˜šœ;žœžœ
ž˜KKšœžœ˜Kšžœ
˜—Kšœžœ
˜K˜-šžœž˜Kšœžœ
˜K˜*šžœ˜
š
žœžœ
žœžœžœžœ
ž˜9K˜šžœž˜K˜&—Kšžœ
˜——KšœžœEžœ
˜]Kš
œ"˜"—K˜——Kš
œ˜K˜—š
 œž	œžœžœžœ˜UK˜$š
žœ	žœ
žœžœžœ˜<Kšœžœ
˜K˜$K˜—K˜K˜—š œžœ
ž	œ˜-Kšžœ
žœžœ
˜Kšœžœ˜(K˜šžœ	žœ
žœ
˜Kšœžœžœ˜J—Kš
œ˜K˜—š œžœ
ž	œ˜-Kšžœ
žœžœ
˜Kšœžœ˜(˜
šžœ
žœ˜K˜$Kšžœ	˜
K˜—šžœ	žœ
ž˜Kšœžœžœžœ˜M—š
ž˜K˜—K˜—Kš
œ˜—K˜š œžœ
ž	œ˜0Kšœžœ˜Kšœ	žœ˜Kš
œ˜Kšœžœžœ
˜Kšœžœžœ
˜š
ž
˜
šžœ
žœ˜K˜ K˜
K˜K˜Kš
œ˜——K˜Kšžœ
žœ
žœ
˜K˜K˜!K˜Kš
œ
˜
š œžœ˜#K˜qšžœžœ
žœ#ž˜3šžœ&žœ˜.K˜Kš
ž˜K˜—Kšžœ
˜—KšœYžœ˜aK˜K˜—K˜
šžœžœ
žœ˜,K˜ K˜
K˜
—šžœ˜K˜,šžœžœ
žœ#ž˜3Kšœžœ
˜
K˜9Kšœžœ
˜
šžœž˜)˜KšœžœG˜P—š
œ˜š	žœžœ
žœžœ
ž˜.KšœžœH˜Q—š
ž˜KšœžœO˜X——š
œ˜š	žœžœ
žœžœ
ž˜.Kšœžœ6˜?—š
ž˜KšœžœM˜V——š
œ˜š	žœžœ
žœžœ
ž˜.KšœžœFžœ'˜y—š
ž˜Kšœžœo˜x——š
œ˜Kšœ	žœ˜Kšœžœ{˜‡
Kšœ	žœ8˜EK˜'šžœžœ
žœ&ž˜6šžœ1žœ˜9šžœžœ
ž˜,šœžœ.˜5šžœžœ
žœž˜.šžœžœ
žœ*ž˜:šžœ5žœ˜=K˜hKšœžœ
˜K˜—Kšžœžœ
žœ
˜Kšžœ
˜—Kšžœžœ
žœ
˜Kšžœ
˜—K˜—Kšžœžœ
˜—Kšžœ
˜K˜—Kšžœ
˜—šžœž˜
Kšœžœ7žœ
žœ˜P—K˜—Kš
œ
˜
Kšžœžœ
˜—šžœžœ
ž˜K˜‡—Kšžœ
˜—K˜—K˜K˜K˜K˜K˜K˜—š œž	œ˜.Kšœ:žœžœ
˜EJ™Jšœžœ
™Jšœžœ
™
š
œ.˜.K˜K˜K˜—K˜K˜—š œžœ
ž	œ˜6K˜Kšœžœžœ
˜K˜1K˜šžœ
žœ˜Kš
œ8˜8Kšžœ
˜K˜—Kšœžœ
˜Kš
œ$˜$K˜K˜KšœΉ
žœ˜Α
Kšžœžœ
žœžœ%žœžœ˜QK˜šœ(žœ&žœ˜YKšœ#žœ,žœ˜\š
œ(˜(Kš
œA˜AK˜K˜Kšœžœ
˜Kšžœ˜K˜—Kš
œ˜—šžœžœ
žœ˜K˜Kšœžœ
˜K˜Kš
ž˜K˜—šžœžœ˜!Kš
œL˜LKšœžœ
˜Kš
ž˜K˜
—šžœ˜Kš
œ˜Kš
œ˜K˜Kš
œ˜K˜K˜—Kšœžœ
˜˜Kš‘
Πkt‘
˜—K˜K˜—Kš	œžœ
žœžœžœ!˜JK˜š
 œž	œ"žœ
žœžœ˜^šžœž˜Kšœžœ˜%Kšœžœ˜&Kšœžœ˜)Kšžœ
˜—K˜K˜—š œžœ
ž	œ˜6Kšžœ
žœžœ
˜Kšœ7žœ˜Nšžœžœ
ž˜šœžœ-˜4K˜#Kšœžœ
˜
K˜9šžœž˜KšœžœΟc˜"K˜K˜K˜šžœ˜K˜1Kšžœ
˜K˜——K˜šžœžœ˜Jš
œY™YJš
œ.™.šžœžœžœ.ž™KJš
œ™Jšžœ
™—K˜šžœžœ
žœ˜Kš
œ1˜1Jš
œ4™4K˜K˜
—Kšžœ
ž˜K˜—K˜
—Kšžœ
˜—Kš
œ˜K˜—š 
œžœ
žœ˜/Kšœ$žœžœ
˜/Kšœžœ
˜K˜
Kšžœ
žœžœ
˜K˜Kšœžœ˜Kšœžœ
žœ˜/Kš	œ	žœ
žœžœžœ˜7šžœžœ
žœž˜*Kšœ
žœ>˜LKšžœ
˜—K˜*K˜K˜K˜šžœž˜Kšœžœ£˜"šžœ˜K˜——K˜šžœžœ˜&Kšœžœ#˜;Kšœ	žœ
žœ˜K˜˜wKš
œC˜CKšžœ˜—K˜K˜—K˜šžœ
žœ
žœž˜"K˜*—šžœ
žœ
žœž˜K˜'—™%J™Jš
œ™—šžœžœ
žœ˜#K˜7K˜Kš
œ@˜@K˜Kš
œ˜K˜
—šžœ˜Kš
œ-˜-K˜K˜
—K˜K˜K˜—Kš	œžœ
žœžœžœ;˜bK˜š 
œžœ
ž	œe˜
K˜—š œžœ
ž	œ˜2Kšžœ
žœžœ
˜K˜Kšœžœ
˜
Kšžœ
žœ
žœ
˜šžœž˜'K˜%Kšžœ
˜K˜—šžœžœ
žœ˜K˜(Kšžœ
˜K˜—K˜/šžœž˜Kšœžœ£˜"˜K˜K˜—˜K˜K˜—˜K˜K˜—˜K˜K˜—˜K˜K˜—˜K˜K˜—šžœ˜K˜1Kšžœ
˜K˜——K˜šžœžœ˜Kšœžœ
žœa˜z™4J™Jš
œK™KJ™—šžœžœ
žœ˜!šœžœ
žœ˜+Kš
œE˜E—š
œ6™6Jš
œD™DJ™J™—š
‘˜Kš
‘˜Kš
‘
˜
Kš
œ˜Kš
œ˜—š
‘™Jš‘œ‘™Jš
œ™Jš
œ™—K˜K˜K˜šžœž˜Kšœžœ)˜FKšœžœ(˜DKšœžœ*˜Hš
œ˜Kš
œ,˜,Kšœžœ*˜>Kšœžœ˜šžœžœ
ž˜šœžœ-˜4Kšœžœž
œ˜>Kšœžœžœžœ˜:K˜—Kšžœ
˜—K˜—Kšœžœ(˜DKšœžœ-˜NKšžœ
˜—K˜Kš
œ˜K˜Kš
œ˜K˜
—Kšžœ˜K˜—K˜K˜K˜—š
 
œžœ
ž	œDžœžœ˜~Kšžœ
žœžœ
˜Kš	œžœ
žœžœžœ
˜$Kšœžœ
˜Kšœž˜K˜šžœ8žœžœ
ž˜KKšœ
žœ˜)Kš
ž˜—Kšœ
žœ˜*Kšœ
žœ˜&Kšœ
žœ˜'K˜?šžœžœ˜K˜šžœž˜K˜K˜Kšžœ
˜—K˜2Kšœžœ:žœ
˜RK˜&K˜—K˜—K˜š 
œžœ
žœE˜_Kšžœ
žœžœ
˜Kšœžœ˜K˜-Kšœžœ˜K˜šžœžœ
žœ˜"K˜9K˜K˜—šžœ3žœ˜;Kšœžœ
žœžœžœžœ˜+K˜=K˜
—šžœ˜K˜gKšžœžœ
žœ
žœ
˜%šžœž˜Kšœžœ
˜Kšžœ4˜;—K˜—K˜K˜—š 
œžœ
žœ,˜CK˜1Kšœ7žœ˜Wšžœžœ
ž˜šœ
žœ-˜:šžœ,žœ˜4Jš
œ™Kš
œ;˜;Kšœ-ž˜3Kš
ž˜K˜
—šžœ˜Jš
œ™Kšœ-žœ
˜2Kš
œ;˜;šžœ6žœ
ž˜Eš
œ˜Kšœ$žœ˜=Kšœ$žœ˜5Kšœ$žœ'˜O—Kšžœ˜	—K˜——Kšžœ˜	K˜——š œžœ#žœžœžœ
žœ˜ZKšœžœ˜Kšœžœ.˜Cš
žœžœ
žœžœ5žœžœ
ž˜cšžœ$žœž˜1Kšžœ˜
—Kšžœ˜Kšžœ
˜—Kšžœ
žœ
žœ˜K˜K˜—š œžœ
ž	œT˜nKš
œ
˜
Kšœžœžœ
˜Kšœžœ˜K˜1K˜2K˜5Kšœžœ+˜>Kšœžœ
˜Kš	œ&žœ
žœžœžœ
˜>Kšœ	žœ˜%Kšœžœ˜šžœ
ž˜˜K˜+Kš
ž˜K˜—˜	K˜.K˜+Kš
ž˜K˜—Kšžœ
˜—šžœž˜K˜4K˜<K˜:K˜Nš
œ˜Jšžœ+ž™1šžœžœ
žœ£˜)K˜5K˜#Kš
œ˜—K˜5K˜2Jšœ
žœB™Ošžœžœž™#J™#Jšžœ
™—šžœžœž™"Jšœ1ž™8—Kš
œ˜—Kšžœ
˜—šžœžœž˜Kšœ
žœ*˜;Kšžœ
˜—š
žœžœ
žœžœžœžœ
ž˜?K˜Kšžœ
˜—Kšœ
žœ!˜.š
žœžœ
žœžœžœžœ
ž˜?K˜K˜Kšžœ
˜—šžœžœ
žœž˜%Kšœ
žœ˜*Kšžœ
˜—K˜Jšžœžœ˜Kšœž˜K˜
K˜!š
žœžœ
žœžœžœžœ
ž˜>šžœž˜K˜—K˜Kšžœ
˜—š
œ˜Kš
œ˜Kš
œE˜E—KšœžœSžœ
˜kKš
œ0˜0K˜—Jšœž
œ
™Jšœ
žœ
™Kš
œ˜K˜—š œžœ
ž	œT˜wK˜.K˜šžœžœ˜šžœ
ž˜Kš
œ9˜9˜
Kš
œ-˜-Kš
œ*˜*K˜—Kšžœ
˜—K˜—K˜Kš
œ˜K˜—š œžœ
ž
œ˜1Kšžœ
žœžœ
˜Kšœžœ
˜K˜K˜<K˜Kšžœžœ
žœž˜Kš
œ˜K˜—š œžœ
žœ@˜YKšžœ
žœžœ
˜K˜$Kš
œ˜K˜—š œžœ
žœ@˜YKšžœ
žœžœ
˜K˜$Kš
œ˜K˜—š œžœ
žœ@˜]Kšžœ
žœžœ
˜K˜$Kš
œ˜K˜—š œžœ
žœ@˜_Kšžœ
žœžœ
˜K˜$Kš
œ˜K˜—š œžœ
ž
œ˜6Kšžœ
žœžœ
˜Kšœžœ
˜Kšœžœž˜K˜K˜<K˜š
žœžœ
žœžœ
žœ˜#Kšœžœ˜5Kšžœ
˜K˜—Kšœžœ˜9Kšœžœ˜+Kšœžœ˜(šžœžœ
žœž˜"šžœžœVž˜sšžœžœ
˜Kšœžœ˜'—š
ž˜Kšœžœ
˜—Kšœžœ˜$Kšžœ
˜—Kšžœ
˜—Kšœžœ˜&Kš
œ˜K˜—š 	œžœ
ž
œ˜3Kšžœ
žœžœ
˜Kšœ7žœ˜NK˜šžœ
žœ
ž˜šœžœ,˜3šžœž˜šžœ˜	Kšœž˜K˜4K˜—šžœ˜
Kšœž˜K˜4K˜—Kšžœ
žœ
˜——Kšžœ
˜—Kš
œ˜—K˜š œžœ
ž	œžœ
žœžœ˜\šžœž˜Kšœžœ˜!Kšœžœ˜"Kšœžœ˜#Kšœžœ
˜!Kšœžœ˜"Kšœžœ˜%Kšžœ
˜—K˜K˜—š 	œžœ
ž	œžœžœžœ
žœ˜WKšžœ
žœžœ
˜šžœ
˜š
œ˜Kšœ/žœ	˜<—Kš
œ˜—š
ž˜˜K˜FKš
œ˜K˜——K˜—K˜Kš
œ˜——…—zδ¦*