DIRECTORY
AdobeCommon,
AdobeCommonInternal USING [EntryBytesType, InstanceData, ProcessUserDotCM, SetTypedInitialSystem, SystemNotFound], 
AdobeOps USING [ARNumber, ARSystemHandle, ToolType, QueryList],
AdobeTip USING [AdjustStringField, defaultHeight],
AdobeTool USING [ChooseQLCmd, CurrentButtonProcData, EmptyContents, ReportCommandProc, ResetProc, SetProc, SetUpWindow, ShowSortKeys, SortCommandProc, QueryCommandProc],
AdobeUI USING [AbortCheckOut, AnotherTool, ChangeSystem, CheckField, CheckInAndExamine, CheckInAndOut, Clear, CheckIn, CheckOut, CurrentButton, EditFilename, Examine, Get, Handle, HandleField, HintMenu, ListAction, Next, NumberEquals, OutputFormat, Overwrite, Previous, Put, QLOperandProc, ReportOutputFile, ReportTemplateFile, RopeFromTool, ResetQL, ShowElements, Submit, SubmitFieldButton, SystemMenu, ToolMenu, UseQL, WhichQL, WhichQL2],
Buttons USING [Button, ButtonProc, Create, ReLabel, SetDisplayStyle], 
Commander USING [CommandProc, Register], 
CommanderOps USING [NextArgument, NumArgs], 
Containers USING [ChildXBound, ChildYBound, Create], 
CrRPC USING [Error],
Icons USING [IconFlavor, NewIconFromFile],
IO USING [PutF], 
Labels USING [Create],
Menus USING [AppendMenuEntry, CreateEntry, CreateMenu, FindEntry, Menu, MenuEntry, MenuProc, ReplaceMenuEntry], 
MessageWindow USING [], 
PFS USING [GetWDir, RopeFromPath],
PopUpSelection USING [Request], 
Rope USING [Cat, Concat, Equal, ROPE],  
Rules USING [Create],
TypeScript USING [Create], 
ViewerClasses USING [Viewer], 
ViewerIO USING [CreateViewerStreams], 
ViewerOps USING [DestroyViewer, MoveViewer, OpenIcon, PaintViewer], 
ViewerTools USING [EnableUserEdits, GetContents, GetSelectionContents, InhibitUserEdits, MakeNewTextViewer, SelPos, SetContents, SetSelection];

AdobeViewersImpl: CEDAR MONITOR
IMPORTS AdobeCommon, AdobeCommonInternal, AdobeTip, AdobeTool, AdobeUI, Buttons, Commander, CommanderOps, Containers, CrRPC, Icons, IO, Labels, Menus, PFS, PopUpSelection, Rope, Rules, TypeScript, ViewerIO, ViewerOps, ViewerTools = {

Box: TYPE ~ AdobeCommon.Box;

ButtonData: TYPE = RECORD [
title: Rope.ROPE,
proc: Buttons.ButtonProc,
line: INT,
width: INT
];

ButtonsList: TYPE = LIST OF ButtonData;
nullButton: ButtonData _ ["NULL", NIL, -1, 0];

MakeViewerAdobeTool: AdobeCommon.AnotherToolProc =  {
my: AdobeCommon.Handle _ NEW[AdobeCommon.AdobeViewerDataRec];

{
ENABLE {
AdobeCommonInternal.SystemNotFound => {
AdobeCommon.PostMessage[my, TRUE, "Initial system specified is invalid!"];
AdobeCommon.RemoveSystemFromKnownSystems[my.knownSystems.system[my.system], my.knownSystems];
GOTO errors;
};
};
  
my.isBusy _ TRUE;
IF iconList[sort] = unInit THEN {
check: Icons.IconFlavor ¬ Icons.NewIconFromFile[adobeIconPath, 0];
IF check # unInit THEN {
iconList[edit] _ check;
iconList[submit] _ Icons.NewIconFromFile[adobeIconPath, 1];
iconList[report] _ Icons.NewIconFromFile[adobeIconPath, 2];
iconList[sort] _ Icons.NewIconFromFile[adobeIconPath, 3];
iconList[query] _ Icons.NewIconFromFile[adobeIconPath, 4];
iconList[queryList] _ Icons.NewIconFromFile[adobeIconPath, 5];
submittingIcon _ Icons.NewIconFromFile[adobeIconPath, 6];
edittedIcon _ Icons.NewIconFromFile[adobeIconPath, 7];
};
};
my.systemHandle _ NIL;
my.report _ Report;
my.getContents _ ViewerGetContentsProc;
my.getSelectionContents _ ViewerGetSelectionContentsProc;
my.setContents _ ViewerSetContentsProc;
my.setSelection _ ViewerSetSelectionProc;
my.setDisplayStyle _ ViewerSetDisplayStyleProc;
my.setIcon _ ViewerSetIconProc;
my.addButtons _ AddButtons;
my.paintBox _ ViewerPaintBoxProc;
my.popUpRequest _ ViewerPopUpRequestProc;
my.reLabelBox _ ViewerReLabelBoxProc;
my.newMenuEntry _ ViewerNewMenuEntryProc;
my.findMenuEntry _ ViewerFindMenuEntryProc;
my.replaceMenuEntry _ ViewerReplaceMenuEntryProc;
my.makeAnotherTool _ MakeViewerAdobeTool;
my.inhibitEdits _ ViewerInhibitEditsProc;
my.enableEdits _ ViewerEnableEditsProc;
my.getBoxGeometry _ ViewerGetBoxGeometryProc;
my.setBoxGeometry _ ViewerSetBoxGeometryProc;
my.getBoxName _ ViewerGetBoxNameProc;
my.destroyBox _ ViewerDestroyBoxProc;
my.setBoxScrollable _ ViewerSetBoxScrollableProc;
my.xBoundBox _ ViewerXBoundBoxProc;
my.newFieldBox _ ViewerNewFieldBoxProc;
my.newLabelBox _ ViewerNewLabelBoxProc;
my.setContainerName _ ViewerSetContainerNameProc;
my.setMainName _ ViewerSetMainNameProc;
my.getMainName _ ViewerGetMainNameProc;
my.makeButton _ ViewerMakeButtonProc;
my.assistLogin _ ViewerAssistLoginProc;
IF parent = NIL THEN 
AdobeCommonInternal.ProcessUserDotCM[my]
ELSE {
my.oldtool _ my.tool _ parent.tool;
my.knownSystems _ parent.knownSystems;
my.system _ my.oldsystem _ parent.system;
my.systemName _ parent.systemName;
my.systemHandle _ parent.systemHandle;
};

AddMenus[my];
AddSubContainers[my];
AddButtons[my];

SELECT my.tool FROM 
edit => my.instanceData _ NEW[AdobeCommonInternal.InstanceData.edit];
submit => my.instanceData _ NEW[AdobeCommonInternal.InstanceData.submit];
report => my.instanceData _ NEW[AdobeCommonInternal.InstanceData.report];
query => my.instanceData _ NEW[AdobeCommonInternal.InstanceData.query];
sort => my.instanceData _ NEW[AdobeCommonInternal.InstanceData.sort];
queryList => my.instanceData _ NEW[AdobeCommonInternal.InstanceData.queryList];
ENDCASE;

IF my.systemHandle = NIL THEN
IF my.system # LAST[CARDINAL] THEN {
my.systemHandle _ AdobeCommon.FindSystem[NIL, my, my.knownSystems.system[my.system], FALSE ! 
CrRPC.Error => { my.systemHandle _ NIL; my.report[my, "Adobe server is down.\n"]; CONTINUE}
];
};
IF my.systemHandle # NIL THEN
AdobeTool.SetUpWindow[my];

my.isBusy  _FALSE;

EXITS 
errors => {
my.isBusy  _FALSE;
my.system _ my.oldsystem _ LAST[CARDINAL];
};
}
};

AddSubContainers: PROCEDURE [handle: AdobeUI.Handle] = {
outerW, outerH: CARD;
handle.outer _ Containers.Create[
info: [
name: Rope.Concat["Adobe ", AdobeUI.RopeFromTool[handle.tool]],
iconic: TRUE,
column: left,
menu: MenuFromAny[handle.menu],
scrollable: FALSE,
icon: iconList[handle.tool]
]
];
[, , outerW, outerH] _ handle.getBoxGeometry[handle.outer];
handle.buttonViewer.outer _ Containers.Create[
info: [
parent: ViewerFromBox[handle.outer],
wx: 0,
wy: 0,
wh: 55,
ww: outerW,
border: FALSE,
scrollable: FALSE
]
];
[] _ Rules.Create[
info: [
parent: ViewerFromBox[handle.outer], 
wx: 0, wy: 55, 
ww: 2000, wh: 1], 
paint: TRUE];
handle.messageViewer.outer _ TypeScript.Create[
info: [
parent: ViewerFromBox[handle.outer],
wx: 0,
wy: 56,
wh: 50,
ww: outerW,
border: FALSE,
scrollable: TRUE
]
];
[] _ Rules.Create[
info: [
parent: ViewerFromBox[handle.outer], 
wx: 0, wy: 106, 
ww: 2000, wh: 1], 
paint: TRUE];
handle.fieldViewer.outer _ Containers.Create[
info: [
parent: ViewerFromBox[handle.outer],
wx: 0,
wy: 107,
wh: outerH,
ww: outerW,
border: FALSE,
scrollable: TRUE
]
];
handle.messageViewer.reportStream _ ViewerIO.CreateViewerStreams[
name: "Adobe Messages",
viewer: ViewerFromBox[handle.messageViewer.outer], 
editedStream: FALSE
].out;

handle.xBoundBox[handle.outer, handle.buttonViewer.outer];
handle.xBoundBox[handle.outer, handle.fieldViewer.outer];
handle.xBoundBox[handle.outer, handle.messageViewer.outer];
Containers.ChildYBound[ViewerFromBox[handle.outer], ViewerFromBox[handle.fieldViewer.outer]];
ViewerOps.OpenIcon[ViewerFromBox[handle.outer]];
};

AddMenus: PROCEDURE [handle: AdobeUI.Handle] = {
systemName: Rope.ROPE _ NIL;
handle.menu _ Menus.CreateMenu[lines: 1]; 

Menus.AppendMenuEntry[
menu: MenuFromAny[handle.menu],
entry: Menus.CreateEntry[
name: "Tool:",
proc: ToolMenuProc,
clientData: handle
]
];
Menus.AppendMenuEntry[
menu: MenuFromAny[handle.menu],
entry: Menus.CreateEntry[
name: Rope.Concat["{", Rope.Concat[AdobeUI.RopeFromTool[handle.tool], "}"]],
proc: DeadProc,
clientData: handle
]
];
Menus.AppendMenuEntry[
menu: MenuFromAny[handle.menu],
entry: Menus.CreateEntry[
name: "Another",
proc: AnotherProc,
clientData: handle
]
];
Menus.AppendMenuEntry[
menu: MenuFromAny[handle.menu],
entry: Menus.CreateEntry[
name: "ChangeSystem",
proc: ChangeSystemProc,
clientData: handle
]
];
Menus.AppendMenuEntry[
menu: MenuFromAny[handle.menu],
entry: Menus.CreateEntry[
name: "System:",
proc: SystemMenuProc,
clientData: handle
]
];
IF handle.system # LAST[CARDINAL] THEN 
systemName _ handle.knownSystems.system[handle.system];
handle.systemMenuItem _ Menus.CreateEntry[
name: systemName,
proc: DeadProc,
clientData: handle
];
Menus.AppendMenuEntry[
menu: MenuFromAny[handle.menu],
entry: MenuEntryFromAny[handle.systemMenuItem]
];
};

AddButtons: AdobeCommon.AddButtonsProc = {

currButton, lastButton: Buttons.Button _ NIL;
lastLine, currLine: INTEGER _ 1;
buttonHeight: INTEGER _ 15;
buttonSpaceHeight: INTEGER _ buttonHeight + 2;
currX: INTEGER _ -1;
whichButtons: ButtonsList _ NIL;
tempButton: Buttons.Button _ NIL;
buttonCount, buttonIndex: CARD _ 0;
editorIndex: NAT _ 1;

FOR i: CARD IN [1..4] DO
h.destroyBox[h, h.editors[i], FALSE];
ENDLOOP;

IF h.controlButtons # NIL THEN
FOR i: CARD IN [0..h.controlButtons.len) DO
h.destroyBox[h, h.controlButtons[i], FALSE];
ENDLOOP;


SELECT h.tool FROM 
edit => { whichButtons _ EditButtons };
submit => { whichButtons _ SubmitButtons };
report => { whichButtons _ ReportButtons };
query => { whichButtons _ QueryButtons };
sort => { whichButtons _ SortButtons };
queryList => { whichButtons _ QueryListButtons };
ENDCASE => { whichButtons _ EditButtons };

buttonCount _ 0;
FOR buttonLoop: ButtonsList _ whichButtons, buttonLoop.rest WHILE buttonLoop # NIL DO
buttonCount _ buttonCount + 1;
ENDLOOP;

h.controlButtons _ NEW[AdobeCommon.ControlSeqRec[buttonCount]];

buttonIndex _ 0;
FOR whichButtons _ whichButtons, whichButtons.rest WHILE whichButtons # NIL DO
thisButton: ButtonData _ whichButtons.first;
SELECT thisButton.title FROM
"NULL" => {};
"SKIP" => {
lastLine _ currLine;
currLine _ thisButton.line;
IF currLine # lastLine THEN
currX _ -1;
currButton _ h.editors[editorIndex] _ ViewerTools.MakeNewTextViewer[
info: [
parent: ViewerFromBox[h.buttonViewer.outer],
wx: currX + 5,
wy: ((currLine -1) * buttonSpaceHeight) - currLine + 1,
ww: thisButton.width,
wh: buttonHeight,
scrollable: FALSE,
sibling: lastButton,
border: FALSE
]
];
editorIndex _ editorIndex + 1;
currX _ currX + thisButton.width - 1
};
ENDCASE => {
lastLine _ currLine;
currLine _ thisButton.line;
IF currLine # lastLine THEN
currX _ -1;
h.controlButtons[buttonIndex] _ Buttons.Create[
info: [
wx: currX + 5, 
wy: ((currLine -1) * buttonSpaceHeight) - currLine,
ww: thisButton.width - 5,
wh: buttonHeight,
name: thisButton.title,
scrollable: FALSE,
parent: ViewerFromBox[h.buttonViewer.outer],
border: FALSE
],
proc: thisButton.proc,
clientData: h,
paint:FALSE
];
IF Rope.Equal[thisButton.title, "{plain}", FALSE] THEN
h.formatButton _ h.controlButtons[buttonIndex];
IF Rope.Equal[thisButton.title, "  Overwrite", FALSE] THEN
h.overwriteButton _ h.controlButtons[buttonIndex];
IF Rope.Equal[thisButton.title, " UseQL", FALSE] THEN
h.useQLButton _ h.controlButtons[buttonIndex];
buttonIndex _ buttonIndex + 1;
currX _ currX + thisButton.width - 1;
};
ENDLOOP;

h.paintBox[h.outer, $all];

};


MenuFromAny: PROCEDURE [any: REF ANY] RETURNS [m: Menus.Menu] ~ {
m _ NARROW[any];
};

MenuEntryFromAny: PROCEDURE [any: REF ANY] RETURNS [mE: Menus.MenuEntry] ~ {
mE _ NARROW[any];
};

ViewerFromBox: PROCEDURE [b: Box] RETURNS [v: ViewerClasses.Viewer] ~ {
v _ NARROW[b];
};

ViewerGetBoxNameProc: AdobeCommon.GetBoxNameProc ~ {
RETURN[ViewerFromBox[box].name];
};

ViewerGetMainNameProc: AdobeCommon.GetMainNameProc ~ {
RETURN[ViewerFromBox[box].name];
};

ViewerSetMainNameProc: AdobeCommon.SetMainNameProc ~ {
ViewerFromBox[box].name _ name;
};

ViewerSetContainerNameProc: AdobeCommon.SetContainerNameProc ~ {
ViewerFromBox[box].label _ name;
};

ViewerGetContentsProc: AdobeCommon.GetContentsProc ~ {
RETURN[ViewerTools.GetContents[ViewerFromBox[box]]];
};

ViewerXBoundBoxProc: AdobeCommon.XBoundBoxProc ~ {
Containers.ChildXBound[ViewerFromBox[parent], ViewerFromBox[box]];
};

ViewerDestroyBoxProc: AdobeCommon.DestroyBoxProc ~ {
ViewerOps.DestroyViewer[ViewerFromBox[box], FALSE];
};

ViewerSetBoxScrollableProc: AdobeCommon.SetBoxScrollableProc ~ {
ViewerFromBox[box].scrollable _ TRUE;
};

ViewerNewFieldBoxProc: AdobeCommon.NewFieldBoxProc ~ {
RETURN[
ViewerTools.MakeNewTextViewer[
info:[
parent: ViewerFromBox[parent],
wx: x,
wy: y,
ww: w,
wh: h,
border: FALSE,
scrollable: TRUE
]]];
};

ViewerNewLabelBoxProc: AdobeCommon.NewLabelBoxProc ~ {
RETURN[
Labels.Create[
info:[
parent: ViewerFromBox[parent],
wx: x,
wy: y,
border: FALSE,
scrollable: FALSE
]]];
};

ViewerGetBoxGeometryProc: AdobeCommon.GetBoxGeometryProc ~ {
v: ViewerClasses.Viewer _ ViewerFromBox[box];
RETURN[v.wx, v.wy, v.ww, v.wh];
};

ViewerSetBoxGeometryProc: AdobeCommon.SetBoxGeometryProc ~ {
ViewerOps.MoveViewer[ViewerFromBox[box], x, y, w, h, draw];
};

CurrentButtonProc: Buttons.ButtonProc = {
data: AdobeTool.CurrentButtonProcData _ NARROW[clientData];
AdobeUI.CurrentButton[data, parent];
};

SubmitFieldButtonProc: Buttons.ButtonProc = {
data: AdobeTool.CurrentButtonProcData _ NARROW[clientData];
AdobeUI.SubmitFieldButton[data, mouseButton];
};

AdjustStringHeight: Buttons.ButtonProc ~ {
buttonData: AdobeCommon.EnumeratedTypes _ NARROW[clientData, AdobeTool.CurrentButtonProcData].e;
handle: AdobeCommon.Handle _ buttonData.mainViewer;
buttons: AdobeCommon.ButtonsSeq _ handle.fieldViewer.buttons;
x, y, w, h: CARD;
offset: INT _ 0;
currentFieldNum: CARD _ LAST[CARD];

lines: INT _ AdobeTip.AdjustStringField[buttonData];
offset _ lines * AdobeTip.defaultHeight;

IF lines = 0 THEN RETURN;

FOR i: CARD IN [0..buttons.length) DO
IF buttons[i] = buttonData THEN 
currentFieldNum _ i;
ENDLOOP;

IF currentFieldNum = LAST[CARD] THEN { 
Report[handle, "Couldn't find field.\n"];
RETURN
};

[x, y, w, h] _ handle.getBoxGeometry[buttons[currentFieldNum].controllerOf];
handle.setBoxGeometry[buttons[currentFieldNum].controllerOf, x, y, w, h + offset, FALSE];
buttons[currentFieldNum].currentHeight _ buttons[currentFieldNum].currentHeight + lines;
FOR i: CARD IN (currentFieldNum..buttons.length) DO
IF buttons[i].adjButton # NIL THEN {
[x, y, w, h] _ handle.getBoxGeometry[buttons[i].adjButton];
handle.setBoxGeometry[buttons[i].adjButton, x, y + offset, w, h, FALSE];
};
[x, y, w, h] _ handle.getBoxGeometry[buttons[i].controllerOf];
handle.setBoxGeometry[buttons[i].controllerOf, x, y + offset, w, h, FALSE];
[x, y, w, h] _ handle.getBoxGeometry[buttons[i].button];
handle.setBoxGeometry[buttons[i].button, x, y + offset, w, h, FALSE];
ENDLOOP;
handle.paintBox[handle.fieldViewer.outer, $all];
};

HintMenuProc: PUBLIC Buttons.ButtonProc = {
buttonData: AdobeCommon.EnumeratedTypes _ NARROW[clientData];
AdobeUI.HintMenu[buttonData, mouseButton];
};

ListActionProc: PUBLIC Buttons.ButtonProc = {
handle: AdobeCommon.Handle _ NARROW[clientData];
AdobeUI.ListAction[handle, mouseButton];
};

ViewerAssistLoginProc: AdobeCommon.AssistLoginProc ~ {};

ViewerMakeButtonProc: AdobeCommon.MakeButtonProc ~ {
Proc: Buttons.ButtonProc;
SELECT proc FROM
$AdjustStringHeight => Proc _ AdjustStringHeight;
$CheckField => Proc _ CheckField;
$CurrentButtonProc => Proc _ CurrentButtonProc;
$HintMenuProc => Proc _ HintMenuProc;
$ListAction => Proc _ ListActionProc;
$SubmitFieldButtonProc => Proc _ SubmitFieldButtonProc;
ENDCASE => ERROR;
RETURN[Buttons.Create[
info: [
parent: ViewerFromBox[parent],
wx: x,
wy: y,
name: name,
border: FALSE,
data: data,
scrollable: scrollable
],
paint: paint,
proc: Proc,
clientData: cData]];
};

ViewerGetSelectionContentsProc: AdobeCommon.GetSelectionContentsProc ~ {
RETURN[ViewerTools.GetSelectionContents[]];
};

ViewerSetContentsProc: AdobeCommon.SetContentsProc ~ {
ViewerTools.SetContents[ViewerFromBox[box], r];
};

ViewerSetSelectionProc: AdobeCommon.SetSelectionProc ~ {
ViewerTools.SetSelection[ViewerFromBox[box], selection];
};

ViewerSetDisplayStyleProc: AdobeCommon.SetDisplayStyleProc ~ {
Buttons.SetDisplayStyle[ViewerFromBox[box], style];
};

ViewerPaintBoxProc: AdobeCommon.PaintBoxProc ~ {
SELECT which FROM
$all => ViewerOps.PaintViewer[ViewerFromBox[box], all, TRUE];
$caption => ViewerOps.PaintViewer[ViewerFromBox[box], caption, TRUE];
$client => ViewerOps.PaintViewer[ViewerFromBox[box], client, TRUE];
$menu => ViewerOps.PaintViewer[ViewerFromBox[box], menu, TRUE];
ENDCASE => ERROR;
};

ViewerReLabelBoxProc: AdobeCommon.ReLabelBoxProc ~ {
Buttons.ReLabel[ViewerFromBox[box], newLabel];
};

ViewerPopUpRequestProc: AdobeCommon.PopUpRequestProc ~ {
RETURN[PopUpSelection.Request[title, selections]];
};

ViewerFindMenuEntryProc: AdobeCommon.FindMenuEntryProc ~ {
RETURN[Menus.FindEntry[menu: MenuFromAny[h.menu], entryName: entryName]];
};

ViewerNewMenuEntryProc: AdobeCommon.NewMenuEntryProc ~ {
RETURN[Menus.CreateEntry[name: entryName, proc: DeadProc]];
};

ViewerReplaceMenuEntryProc: AdobeCommon.ReplaceMenuEntryProc ~ {
Menus.ReplaceMenuEntry[menu: MenuFromAny[menu], oldEntry: MenuEntryFromAny[oldEntry], newEntry: MenuEntryFromAny[newEntry]];
h.systemMenuItem _ newEntry;
};

ViewerInhibitEditsProc: AdobeCommon.InhibitEditsProc ~ {
ViewerTools.InhibitUserEdits[ViewerFromBox[box]];
};

ViewerEnableEditsProc: AdobeCommon.InhibitEditsProc ~ {
ViewerTools.EnableUserEdits[ViewerFromBox[box]];
};

ViewerSetIconProc: AdobeCommon.SetIconProc ~ {
SELECT function FROM
$normal => ViewerFromBox[h.outer].icon _ iconList[h.tool];
$editted => ViewerFromBox[h.outer].icon _ edittedIcon
ENDCASE => ERROR;
};

Report: AdobeCommon.ReportProc ~ {
h.messageViewer.reportStream.PutF[format, v1, v2, v3];
};

ChangeTool: PROCEDURE RETURNS [change: BOOLEAN _ TRUE] = {
};

DeadBProc: Buttons.ButtonProc = {};

DeadProc: Menus.MenuProc = {};

AnotherProc: Menus.MenuProc = {
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.AnotherTool[handle];
};

ChangeSystemProc: Menus.MenuProc ~ {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.ChangeSystem[handle];
};

SubmitProc: Buttons.ButtonProc ~ {
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.Submit[handle];
};

SystemMenuProc: Menus.MenuProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.SystemMenu[handle];
};

ToolMenuProc: ENTRY Menus.MenuProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];

AdobeUI.ToolMenu[handle];
};

ExamineProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.Examine[handle];
};

CheckInProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.CheckIn[handle];
};

CheckInAndOutProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.CheckInAndOut[handle];
};

CheckInAndExamineProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.CheckInAndExamine[handle];
};

CheckOutProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.CheckOut[handle];
};

AbortCheckOutProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.AbortCheckOut[handle];
};

NumberEqualsProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.NumberEquals[handle, mouseButton];
};

NextProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.Next[handle];
};

PreviousProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.Previous[handle];
};

EditFilenameProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.EditFilename[handle, mouseButton];
};

UseQLProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.UseQL[handle];
};

WhichQLProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.WhichQL[handle, mouseButton];
};

WhichQLProc2: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.WhichQL2[handle, mouseButton];
};

ClearProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.Clear[handle];
};

PutProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.Put[handle];
};

GetProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.Get[handle];
};

SubmitFileProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
[] _ AdobeUI.HandleField[handle, 1, mouseButton];
};

ReportProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeTool.ReportCommandProc[handle];
};

QueryProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeTool.QueryCommandProc[handle];
};

ShowSortKeys: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeTool.ShowSortKeys[handle];
};

OutputFormatProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.OutputFormat[handle];
};

WhichFormatProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
};

OverwriteProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.Overwrite[handle];
};

SetFieldsProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];

AdobeTool.SetProc[handle];
};

ResetProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];

AdobeTool.ResetProc[handle, TRUE];
};

ReportOutputFileProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.ReportOutputFile[handle, mouseButton];
};

ReportTemplateFileProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.ReportTemplateFile[handle, mouseButton];
};


ClearFormProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];

AdobeTool.EmptyContents[handle];
};

ShowElementsProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.ShowElements[handle];
};

ResetQLProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.ResetQL[handle];
};

UnionProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];

AdobeTool.ChooseQLCmd[handle, 0];
};

IntersectionProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];

AdobeTool.ChooseQLCmd[handle, 1];
};

ComplementProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];

AdobeTool.ChooseQLCmd[handle, 2];
};

DifferenceProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];

AdobeTool.ChooseQLCmd[handle, 3];
};

XORProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];

AdobeTool.ChooseQLCmd[handle, 4];
};

CopyToQueryListProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];

AdobeTool.ChooseQLCmd[handle, 5];
};

CopyToFileProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
foo: Rope.ROPE _ NIL;

AdobeTool.ChooseQLCmd[handle, 6];
};

QLOperandOneProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.QLOperandProc[handle, mouseButton, 1, "Operand1"];
};

QLOperandTwoProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.QLOperandProc[handle, mouseButton, 2, "Operand2"];
};

QLResultProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeUI.QLOperandProc[handle, mouseButton, 3, "Result"];
};

SortProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
AdobeTool.SortCommandProc[handle];
};

SortMaxOutputProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
[] _ AdobeUI.HandleField[handle, 1, mouseButton];
};

SortInputProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
[] _ AdobeUI.HandleField[handle, 2, mouseButton];
};

SortOutputProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
[] _ AdobeUI.HandleField[handle, 3, mouseButton];
};

SortKeySpecsProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
[] _ AdobeUI.HandleField[handle, 4, mouseButton];
};

ShowSortKeysProc: Buttons.ButtonProc = {
ENABLE UNWIND => NULL;
handle: AdobeUI.Handle _ NARROW[clientData];
};
 
CheckField: Buttons.ButtonProc = {
enumData: AdobeCommon.EnumeratedTypes _ NARROW[clientData];
AdobeUI.CheckField[enumData];
};

EditButtons: ButtonsList = LIST [
["Examine", ExamineProc, 1, 60],
[" CheckIn", CheckInProc, 1, 70],
["CheckIn&Out", CheckInAndOutProc, 1, 90],
["CheckIn&Exam", CheckInAndExamineProc, 1, 100],
["CheckOut", CheckOutProc, 1, 65],
["AbortCheckOut", AbortCheckOutProc, 1, 100],
["  Next", NextProc, 2, 60],
[" Number=", NumberEqualsProc, 2, 70],
["SKIP", DeadBProc, 2, 90],
["    Previous", PreviousProc, 2, 100],
["Filename:", EditFilenameProc, 2, 65],
["SKIP", DeadBProc, 2, 160],
[" UseQL", UseQLProc, 3, 60],
["QL to use:", WhichQLProc, 3, 70],
["SKIP", DeadBProc, 3, 190],
nullButton];

SubmitButtons: ButtonsList = LIST [
["Submit", SubmitProc, 1, 50],
["Clear", ClearProc, 1, 40],
["Put", PutProc, 1, 30],
["Get", GetProc, 1, 30],
["File:", SubmitFileProc, 1, 40],
["SKIP", DeadBProc, 1, 190],
nullButton];

ReportButtons: ButtonsList = LIST  [
["   Report", ReportProc, 1, 80],
["OutputFormat:", OutputFormatProc, 1, 90],
["{plain}", WhichFormatProc, 1, 75],
["  Overwrite", OverwriteProc, 1, 90],
["Reset", ResetProc, 1, 45],
["SetFields", SetFieldsProc, 1, 60],
["Output file:", ReportOutputFileProc, 2, 80],
["SKIP", DeadBProc, 2, 164],
["Template file:", ReportTemplateFileProc, 2, 90],
["SKIP", DeadBProc, 2, 190],
[" QL to use:", WhichQLProc, 3, 80],
["SKIP", DeadBProc, 3, 190],
nullButton];

QueryButtons: ButtonsList = LIST  [
["Query", QueryProc, 1, 70],
["ClearForm", ClearFormProc, 1, 70],
["ShowElements", ShowElementsProc, 1, 90],
["ResetQL", ResetQLProc, 1, 60],
["Query List Name:", WhichQLProc2, 2, 110],
["SKIP", DeadBProc, 2, 190],
nullButton];

QueryListButtons: ButtonsList = LIST  [
["  Union", UnionProc, 1, 70],
[" Intersection", IntersectionProc, 1, 80],
["Complement", ComplementProc, 1, 80],
["Difference", DifferenceProc, 1, 70],
["XOR", XORProc, 1, 40],
["CopyToQueryList", CopyToQueryListProc, 1, 110],
[" CopyToFile", CopyToFileProc, 1, 80],
["Operand1:", QLOperandOneProc, 2, 70],
["SKIP", DeadBProc, 2, 159],
["Operand2:", QLOperandTwoProc, 2, 70],
["SKIP", DeadBProc, 2, 160],
["  Result:", QLResultProc, 3, 70],
["SKIP", DeadBProc, 3, 190],
nullButton];

SortButtons: ButtonsList = LIST  [
["   Sort", SortProc, 1, 70],
["ShowSortKeys", ShowSortKeys, 1, 90],
["Max output file length:", SortMaxOutputProc, 1, 150],
["SKIP", DeadBProc, 1, 80],
["Input File:", SortInputProc, 2, 70],
["SKIP", DeadBProc, 2, 160],
["Output File:", SortOutputProc, 2, 80],
["SKIP", DeadBProc, 2, 160],
["Key specs:", SortKeySpecsProc, 3, 70],
["SKIP", DeadBProc, 3, 170],
nullButton];

iconList: ARRAY AdobeOps.ToolType OF Icons.IconFlavor _ ALL[unInit];
edittedIcon: Icons.IconFlavor _ unInit;
submittingIcon: Icons.IconFlavor _ unInit;

AdobeCommand: Commander.CommandProc = {
initTypedSystem: Rope.ROPE _ NIL;
numArgs:CARD _ CommanderOps.NumArgs[cmd];
IF numArgs > 1 THEN {
initTypedSystem _ CommanderOps.NextArgument[cmd];
numArgs _ numArgs - 1;
WHILE numArgs > 1 DO 
initTypedSystem _ initTypedSystem.Cat[" ",CommanderOps.NextArgument[cmd]];
numArgs _ numArgs - 1;
ENDLOOP;
AdobeCommonInternal.SetTypedInitialSystem[initTypedSystem];
};
MakeViewerAdobeTool[NIL];
};

adobeIconPath: Rope.ROPE ~ Rope.Concat[PFS.RopeFromPath[PFS.GetWDir[]], "Adobe.icons"];

Commander.Register[key: "Adobe", proc: AdobeCommand, doc: "Create an instance of the Viewer Adobe Tool."];
}.



JAdobeViewersImpl.mesa
Copyright Ó 1990, 1991, 1992, 1993 by Xerox Corporation.  All rights reserved.
Philip James, March 10, 1992 3:28 pm PST
Foote, July 14, 1993 10:13 am PDT
Willie-s, August 2, 1993 6:24 pm PDT
Swen Johnson, August 24, 1993 5:32 pm PDT

WHILE handle.lastButton # NIL DO 
tempButton _ handle.lastButton.sibling;
ViewerOps.DestroyViewer[handle.lastButton, TRUE];
handle.lastButton _ tempButton;
ENDLOOP;
handle.lastButton _ currButton;
lastButton _ currButton;
sibling: lastButton,
handle.lastButton _ currButton;
lastButton _ currButton;

[] _ AdobeUI.HandleField[handle, 2, mouseButton];
};

ql: AdobeOps.QueryList _ NIL;

ql _ AdobeCommon.FindThisQL[ViewerTools.GetContents[handle.editors[1]], handle];

IF ql # NIL THEN ql.list _ NIL;
};
IF stateInfo = NIL THEN stateInfo _ NEW[
ToolStateType _ []];
Swen Johnson, August 24, 1993
Bug fix: AdjustStringHeight was getting a NARROW fault when assigning buttonData.
changes to: AdjustStringHeight: NARROW clientData to AdobeTool.CurrentButtonProcData (instead of AdobeCommon.EnumeratedTypes), assign field e to buttonData.

�Êû˜
code™Kšœ
Ïe
œC™NK™(K™!K™$K™)—K™š
Ïk	˜	Kš
œ˜KšœžœZ˜sKšœ	žœ1˜?Kšœ	žœ$˜2Kšœ
žœš
˜©
Kšœžœ«˜¸Kšœžœ9˜FKšœ
žœ˜)Kšœ
žœ˜,Kšœžœ%˜5Kšœžœ	˜Kšœžœ˜*Kšžœ
žœ	˜Kšœžœ
˜Kšœžœe˜pKšœžœ˜Kšžœ
žœ˜"Kšœžœ˜ Kšœžœžœ˜(Kšœžœ
˜Kšœžœ˜Kšœžœ˜Kšœ	žœ˜&Kšœ
žœ5˜DKšœžœ~˜�
K˜—šÐlnœžœ
ž˜Kšžœ}žœžœO˜é
K˜Kšœžœ˜K˜šœžœžœ˜Kšœžœ
˜K˜Kšœžœ
˜
Kšœž˜
K˜—K˜Kšœ
žœžœ
žœ˜'Kšœ"žœ	˜.K˜šÏnœ"˜5Kšœžœ!˜=K˜š
œ
˜
šžœ˜˜'Kšœžœ*˜JKš
œ]˜]Kšžœ˜K˜—K˜—K˜Kšœžœ
˜šžœžœ˜!K˜Bšžœžœ˜K˜K˜;K˜;K˜9K˜:K˜>K˜9K˜6K˜—K˜—Kšœžœ
˜K˜K˜'K˜9K˜'K˜)Kš
œ/˜/Kš
œ˜Kš
œ˜Kš
œ!˜!Kš
œ)˜)Kš
œ%˜%Kš
œ)˜)Kš
œ+˜+Kš
œ1˜1Kš
œ)˜)Kš
œ)˜)Kš
œ'˜'Kš
œ-˜-Kš
œ-˜-Kš
œ%˜%Kš
œ%˜%Kš
œ1˜1Kš
œ#˜#Kš
œ'˜'Kš
œ'˜'Kš
œ1˜1Kš
œ'˜'Kš
œ'˜'Kš
œ%˜%Kš
œ'˜'šžœ
žœ
žœ
˜Kš
œ(˜(—šžœ˜Kš
œ#˜#KšœÏrœ
¡œ
˜&Kš
œ)˜)Kš
œ"˜"K˜&K˜K˜—K˜
K˜K˜K˜šžœ	žœ
˜Kšœžœ(˜EKšœžœ*˜IKšœžœ*˜IKšœžœ)˜GKšœžœ(˜EKšœžœ-˜OKšžœ
˜K˜—Kšžœžœ
ž˜šžœ
žœ
žœžœ˜$šœ)žœ	¡œ
žœ˜]Kšœ#žœ,žœ
˜[Kš
œ˜—K˜—šžœžœ
ž˜K˜—K˜Kšœžœ
˜K˜šžœ
˜˜Kšœžœ
˜Kšœžœ
žœ˜*K˜——K˜
—K˜—K˜š œž	œ˜8Kšœžœ
˜š
œ!˜!˜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˜—š
œA˜AK˜Kš
œ3˜3Kšœž˜K˜—K˜Kš
œ:˜:Kš
œ9˜9Kš
œ;˜;Kš
œ]˜]Kš
œ0˜0K˜K˜—š œž	œ˜0Kšœžœž˜Kš
œ*˜*K˜š
œ˜Kš
œ˜˜K˜K˜Kš
œ˜K˜
—K˜—˜Kš
œ˜˜Kš
œL˜LK˜Kš
œ˜K˜
—K˜—˜Kš
œ˜˜K˜Kš
œ˜Kš
œ˜Kš
œ
˜
—K˜—˜Kš
œ˜˜K˜K˜Kš
œ˜K˜
—K˜—˜Kš
œ˜˜K˜K˜Kš
œ˜K˜
—K˜—šžœžœ
žœžœ
˜'Kš
œ7˜7—˜*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šœ+žœ™1K™Kšžœ
™—K˜šžœžœ
˜Kš
œ'˜'Kš
œ+˜+Kš
œ+˜+Kš
œ)˜)Kš
œ'˜'Kš
œ1˜1Kšžœ#˜*—K˜Kš
œ˜šžœ9žœžœ
ž˜UKš
œ˜Kšžœ
˜—K˜Kšœžœ)˜?K˜Kš
œ˜šžœ0žœžœ
ž˜NKš
œ,˜,šžœž˜Kš
œ
˜
š
œ˜K˜K˜šžœž˜K˜—˜D˜K˜,K˜K˜7K˜K˜Kšœžœ
˜K˜Kšœž˜
K˜
—K˜—K™K™Kš
œ˜Kš
œ$˜$Kš
œ˜—šžœ˜K˜K˜šžœž˜K˜—˜/˜K˜K˜3Kš
œ˜K˜K˜Kšœžœ
˜K™K˜,Kšœž˜
K˜—K˜K˜Kšœž˜K˜—šžœ)žœž˜6K˜/—šžœ-žœž˜:K˜2—šžœ(žœž˜5K˜.—K˜K™K™K˜%K˜——Kšžœ
˜K˜—Kš
¡˜K˜K˜—K˜K˜š
 œž	œžœ
žœžœ˜AKšœžœ˜K˜K˜—š
 œž	œžœ
žœžœ˜LKšœžœ˜K˜K˜—š 
œž	œ
žœ˜GKšœžœ˜K˜K˜—š œ ˜4Kšžœ˜ K˜K˜—š œ!˜6Kšžœ˜ K˜K˜—š œ!˜6Kš
œ˜K˜K˜—š œ&˜@Kš
œ ˜ K˜K˜—š œ!˜6Kšžœ.˜4K˜K˜—š œ˜2Kš
œB˜BK˜K˜—š œ ˜4Kšœ,žœ˜3K˜K˜—š œ&˜@Kšœ žœ
˜%K˜K˜—š œ!˜6šžœ
˜š
œ˜˜K˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšœžœ
˜Kšœž˜Kš
œ˜———K˜K˜—š œ!˜6šžœ
˜š
œ˜˜K˜Kš
œ˜Kš
œ˜Kšœžœ
˜Kšœž˜Kš
œ˜———K˜K˜—š œ$˜<Kš
œ-˜-Kšžœ˜K˜K˜—š œ$˜<Kš
œ;˜;K˜K˜—š œ˜)Kšœ(žœ
˜;Kš
œ$˜$K˜K˜—š œ˜-Kšœ(žœ
˜;K˜-K˜K˜—š œ˜*Kšœ*žœ0˜`Kš
œ3˜3Kš
œ=˜=Kšœžœ
˜Kšœžœ˜Kšœžœžœ
žœ˜#K˜Kšœžœ*˜4Kš
œ(˜(K˜Kšžœžœ
žœ
˜K˜šžœžœ
žœž˜%šžœžœ
˜ K˜—Kšžœ
˜—K˜šžœžœ
žœžœ˜'Kš
œ)˜)Kš
ž˜K˜K˜—Kš
œL˜LKšœRž˜YKš
œX˜Xšžœžœ
žœ#ž˜3šžœžœ
žœ˜$Kš
œ;˜;KšœAžœ˜HK˜—Kš
œ>˜>KšœDž˜KKš
œ8˜8Kšœ>ž˜EKšžœ
˜—K˜0K˜K˜—š œžœ˜+Kšœ*žœ
˜=Kš
œ*˜*K˜K˜—š œžœ˜-Kšœžœ
˜0Kš
œ(˜(K˜—K˜š œ#˜8K˜—š œ ˜4K˜šžœž˜Kš
œ1˜1Kšœ
Ït
Ϣ
œ
˜!Kš
œ/˜/Kš
œ%˜%Kš
œ%˜%Kš
œ7˜7Kšžœžœ
˜—šžœ˜˜K˜K˜K˜K˜Kšœž˜K˜K˜K˜—K˜
K˜Kš
œ˜—K˜K˜—š œ*˜HKšžœ%˜+K˜K˜—š œ!˜6K˜/K˜K˜—š œ"˜8Kš
œ8˜8K˜K˜—š œ%˜>Kš
œ3˜3K˜K˜—š œ˜0šžœž˜Kšœ7žœ˜=Kšœ?žœ˜EKšœ=žœ˜CKšœ9žœ˜?Kšžœžœ
˜—K˜K˜—š œ ˜4Kš
œ.˜.K˜K˜—š œ"˜8Kšžœ,˜2K˜K˜—š œ#˜:KšžœC˜IK˜K˜—š œ"˜8Kšžœ5˜;K˜K˜—š œ&˜@Kšœ¢œf˜|Kš
œ˜K˜K˜—š œ"˜8Kš
œ1˜1K˜K˜—š œ"˜7Kš
œ0˜0K˜K˜—š œ˜.šžœ
ž˜Kš
œ:˜:Kš
œ5˜5Kšžœžœ
˜—K˜K˜—š œ˜"Kš
œ6˜6K˜—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˜—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˜—K˜š œ˜Kšžœ
žœžœ
˜Kšœžœ
˜,K˜K˜—K˜š œ˜Kšžœ
žœžœ
˜Kšœžœ
˜,K˜K˜—K˜š œ˜&Kšžœ
žœžœ
˜Kšœžœ
˜,K˜1K˜—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š
œ0˜0K˜—™K™1Kš
œ™—K˜K˜š 
œ˜%Kšžœ
žœžœ
˜Kšœžœ
˜,K˜K˜ Kš
œ˜—K˜š œ˜(Kšžœ
žœžœ
˜Kšœžœ
˜,Kš
œ˜K˜—K˜š œ˜#Kšžœ
žœžœ
˜Kšœžœ
˜,K˜K˜—™Kšœžœ
™K™Kš
œP™PK™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˜—K˜š œ˜(Kšžœ
žœžœ
˜Kšœžœ
˜,Kš
œ:˜:K˜—K˜š œ˜$Kšžœ
žœžœ
˜Kšœžœ
˜,K˜8K˜K˜—š œ˜ Kšžœ
žœžœ
˜Kšœžœ
˜,Kš
œ"˜"Kš
œ˜K˜—š œ˜)Kšžœ
žœžœ
˜Kšœžœ
˜,K˜1K˜K˜—š 
œ˜%Kšžœ
žœžœ
˜Kšœžœ
˜,K˜1K˜K˜—š œ˜&Kšžœ
žœžœ
˜Kšœžœ
˜,K˜1K˜K˜—š œ˜(Kšžœ
žœžœ
˜Kšœžœ
˜,K˜1K˜K˜—š œ˜(Kšžœ
žœžœ
˜Kšœžœ
˜,Kš
œ˜K˜
—š 
œ˜"Kšœ(žœ
˜;Kš
œ˜K˜K˜—Kš œžœ«˜ÊK˜Kš 
œžœ¼
˜Ý
K˜Kš 
œžœÊ˜ëK˜Kš œžœç
˜‡K˜Kš œžœç˜‹K˜Kš œžœù˜˜K˜Kšœ
žœžœžœ	˜DKš
œ'˜'Kš
œ*˜*K˜š œ˜'Kšœžœžœ
˜!Kšœžœ˜)šžœ
žœ
žœ
žœ
™(Kš
œ™—šžœ
žœ˜Kš
œ1˜1K˜šžœ
žœ
˜Kš
œJ˜JK˜Kšžœ
˜—Kš
œ;˜;K˜—Kšœžœ˜K˜K˜—šœžœžœžœ˜WK˜—Kš
œj˜jKš
œ˜—K˜K˜™K™QK™œ
K™—K˜—…—n®�ó