DIRECTORY
Commander USING [CommandProc, Register],
Convert USING [RopeFromInt],
IO USING [PutFR, int, rope],
MBQueue USING [CreateMenuEntry],
Menus USING [Menu, AppendMenuEntry, CreateEntry, MenuProc, CreateMenu],
MessageWindow USING [Append, Blink, Clear],
Rope USING [ROPE, Concat, FromChar, FromRefText, Substr],
TEditDocument USING [SelectionId],
TEditInput USING [CommandProc, Register, UnRegister, editState, RecordRef],
TEditInputImpl USING [editObject, pdelState, pDel, sel, selState, mouseColor, editMessage, InterpInput],
TEditInputOps USING [Delete, Copy, CopyFormat, CopyLooks, Transpose, TransposeLooks, TransposeFormat],
TEditSelection USING [pSel, sSel, MakeSelection],
TextEdit USING [Size],
TiogaButtons USING [TextNodeRef],
TiogaOps USING [CancelSelection, FirstChild, GetRope, GetSelection, Location, RestoreSelA, SaveSelA, SelectDocument, SelectPoint, SetLooks, SetStyle, ViewerDoc],
TiogaOpsDefs USING [Location, Ref, SelectionGrain, WhichSelection],
TiogaVoicePrivate USING [ AddCharMark, AddVoiceProc, AgeAllViewers, BackSpace, BackWord, CancelProc, DebugRope, DeleteCharMarks, DeleteSourceMarker, DictationMachine, DictationOps, DisplayCharMarks, EditAges, EditCharMarks, EditTextMarks, ExtractCharMarks, ExtractSoundList, ExtractTextMarks, oldest, PlayBackMenuProc, ReColorViewer, RedrawTextMarkers, RedrawViewer, RegisterViewer, RemoveViewerReferences, ReplaceSoundList, RopeFromTextList, SaveRopeAtSourceMarker, Selection, SelectionRec, Sound, SoundChars, SoundList, SoundInterval, SoundIntervalRec, SoundListFromIntervalSpecs, soundRopeCharDivisions, soundRopeCharLength, soundRopeResolution, StoreVoiceAtSelection, TextInput, TextListFromRope, thrushHandle, TrackDeletes, voiceButtonQueue, VoiceViewerInfo, VoiceViewerInfoRec, youngest ],
ViewerClasses USING [Viewer, NotifyProc, ViewerClass],
ViewerEvents USING [EventRegistration, RegisterEventProc, UnRegisterEventProc, EventProc],
ViewerLocks USING [CallUnderWriteLock],
ViewerOps USING [AddProp, CreateViewer, DestroyViewer, FetchProp, FetchViewerClass, PaintViewer, SetMenu],
ViewerTools USING [TiogaContents, TiogaContentsRec, SetTiogaContents],
VoiceRope USING [ DescribeRope, IntervalSpecs, Length, Replace, VoiceRopeInterval ],
WindowManager USING [colorDisplayOn]
;
VoiceViewersImpl: CEDAR MONITOR IMPORTS Commander, Convert, IO, MBQueue, Menus, MessageWindow, Rope, TEditInput, TEditInputImpl, TEditInputOps, TEditSelection, TextEdit, TiogaButtons, TiogaOps, TiogaVoicePrivate, ViewerEvents, ViewerLocks, ViewerOps, ViewerTools, VoiceRope, WindowManager EXPORTS TiogaVoicePrivate SHARES TEditInputImpl = {


voiceViewerMenu: PUBLIC Menus.Menu;

CreateVoiceViewerMenu: PROC = {
voiceViewerMenu _ Menus.CreateMenu[];
Menus.AppendMenuEntry[voiceViewerMenu, MBQueue.CreateMenuEntry[TiogaVoicePrivate.voiceButtonQueue, "Add", TiogaVoicePrivate.AddVoiceProc]];
Menus.AppendMenuEntry[voiceViewerMenu, MBQueue.CreateMenuEntry[TiogaVoicePrivate.voiceButtonQueue, "Play", TiogaVoicePrivate.PlayBackMenuProc]];
Menus.AppendMenuEntry[voiceViewerMenu, MBQueue.CreateMenuEntry[TiogaVoicePrivate.voiceButtonQueue, "STOP", TiogaVoicePrivate.CancelProc]];
Menus.AppendMenuEntry[voiceViewerMenu, MBQueue.CreateMenuEntry[TiogaVoicePrivate.voiceButtonQueue, "Save", SaveVoice]];
Menus.AppendMenuEntry[voiceViewerMenu, MBQueue.CreateMenuEntry[TiogaVoicePrivate.voiceButtonQueue, "Store", StoreVoice]];
Menus.AppendMenuEntry[voiceViewerMenu, MBQueue.CreateMenuEntry[TiogaVoicePrivate.voiceButtonQueue, "Redraw", RedrawViewerMenuProc]];
Menus.AppendMenuEntry[voiceViewerMenu, MBQueue.CreateMenuEntry[TiogaVoicePrivate.voiceButtonQueue, "Mark", TiogaVoicePrivate.AddCharMark]];
Menus.AppendMenuEntry[voiceViewerMenu, MBQueue.CreateMenuEntry[TiogaVoicePrivate.voiceButtonQueue, "DeleteMarks", TiogaVoicePrivate.DeleteCharMarks]];
Menus.AppendMenuEntry[voiceViewerMenu, MBQueue.CreateMenuEntry[TiogaVoicePrivate.voiceButtonQueue, "DictationMachine", TiogaVoicePrivate.DictationMachine]];
Menus.AppendMenuEntry[voiceViewerMenu, Menus.CreateEntry["DictationOps", TiogaVoicePrivate.DictationOps]];
};

voiceViewerInfoList: PUBLIC TiogaVoicePrivate.VoiceViewerInfo _ NIL;
BuildVoiceViewer: PUBLIC PROC [
voiceID: Rope.ROPE, textInVoice: Rope.ROPE, youngVoice: BOOLEAN] RETURNS [viewer: ViewerClasses.Viewer, viewerInfo: TiogaVoicePrivate.VoiceViewerInfo, viewerNumber: INT] = {
viewerInfo _ InsertVoiceViewerInfo[];
viewer _ ViewerOps.CreateViewer[
flavor: $Text,
info: [ name: Rope.Concat["Sound Viewer #", Convert.RopeFromInt[viewerInfo.viewerNumber]],
	column: IF WindowManager.colorDisplayOn THEN color ELSE left,
	iconic: FALSE
],
paint: TRUE];
viewer.inhibitDestroy _ FALSE;
viewerNumber _ viewerInfo.viewerNumber;

ViewerOps.AddProp[viewer, $voiceViewerInfo, viewerInfo];
viewerInfo.viewer _ viewer;
viewerInfo.color _ viewer.column = color;

ViewerOps.SetMenu[viewer, voiceViewerMenu];
viewerInfo.destroyEvent _ ViewerEvents.RegisterEventProc[
		  proc: DestroyViewerEvent, event: destroy, filter: viewer, before: TRUE];
viewerInfo.changeColumnEvent _ ViewerEvents.RegisterEventProc[
		  proc: ChangeColumnEvent, event: changeColumn, filter: viewer, before: FALSE];

SetViewerContents[viewer, viewerInfo, voiceID, textInVoice, youngVoice];

MakeNotEdited[viewer]
};

SetViewerContents: PUBLIC PROC [
viewer: ViewerClasses.Viewer, viewerInfo: TiogaVoicePrivate.VoiceViewerInfo, voiceID: Rope.ROPE, textInVoice: Rope.ROPE, youngVoice: BOOLEAN] = {
viewercontents: ViewerTools.TiogaContents _ NEW[ViewerTools.TiogaContentsRec _ []];
intervals: VoiceRope.IntervalSpecs;
viewerInfo.soundList _ NIL;

IF voiceID # NIL THEN 
{  -- **** ought to check here that the rope actually exists
viewerInfo.ropeInterval _ [voiceID, 0, VoiceRope.Length[TiogaVoicePrivate.thrushHandle, NEW [VoiceRope.VoiceRopeInterval _ [voiceID, 0, 0]]]];
intervals _ VoiceRope.DescribeRope[TiogaVoicePrivate.thrushHandle, NEW [VoiceRope.VoiceRopeInterval _ viewerInfo.ropeInterval]];
viewerInfo.soundList _ TiogaVoicePrivate.SoundListFromIntervalSpecs[intervals, viewerInfo.ropeInterval.length];
[soundRope: viewercontents.contents, remnant: viewerInfo.remnant] _ TiogaVoicePrivate.SoundChars[viewerInfo];
viewerInfo.textMarkList _ TiogaVoicePrivate.TextListFromRope[textInVoice];
viewerInfo.ageList _ CONS [[0, IF youngVoice THEN TiogaVoicePrivate.youngest-1 ELSE TiogaVoicePrivate.oldest], NIL]
}
ELSE 
{ viewercontents.contents _ "  ";
viewerInfo.ropeInterval _ [NIL, 0, 0];
};

ViewerTools.SetTiogaContents[viewer, viewercontents];
TiogaOps.SaveSelA[];
TiogaOps.SelectDocument[viewer];
TiogaOps.SetStyle["voiceProfile", root];
TiogaOps.SetLooks["v"];
TiogaOps.RestoreSelA[];

TiogaVoicePrivate.RedrawTextMarkers[viewer, TiogaOps.FirstChild[TiogaOps.ViewerDoc[viewer]]];
IF voiceID # NIL AND viewerInfo.ageList.first.age = TiogaVoicePrivate.youngest-1 THEN TiogaVoicePrivate.AgeAllViewers[viewer] ELSE TiogaVoicePrivate.ReColorViewer[viewer, viewerInfo];
IF viewerInfo.textMarkList # NIL THEN ViewerOps.PaintViewer[viewer: viewer, hint: client, clearClient: TRUE, whatChanged: NIL];


viewerInfo.editInProgress _ (voiceID = NIL) -- can do this because the viewer is created with editInProgress = TRUE, so nobody else can have grabbed the lock 
};

MakeNotEdited: PROC [viewer: ViewerClasses.Viewer] = {
DoIt: PROC = {
viewerInfo: TiogaVoicePrivate.VoiceViewerInfo _ NARROW[ViewerOps.FetchProp[viewer, $voiceViewerInfo], TiogaVoicePrivate.VoiceViewerInfo];
viewerInfo.edited _ viewer.newVersion _ viewer.newFile _ FALSE;
ViewerOps.PaintViewer[viewer, caption, FALSE];
};

ViewerLocks.CallUnderWriteLock[DoIt, viewer]
};

SetVoiceViewerEditStatus: PUBLIC PROC [
viewer: ViewerClasses.Viewer] = {
DoIt: PROC = {
viewerInfo: TiogaVoicePrivate.VoiceViewerInfo _ NARROW[ViewerOps.FetchProp[viewer, $voiceViewerInfo], TiogaVoicePrivate.VoiceViewerInfo];
IF viewerInfo.edited # viewer.newVersion THEN 
{  viewer.newVersion _ viewerInfo.edited;
IF ~viewerInfo.edited THEN viewer.newFile _ FALSE; 
ViewerOps.PaintViewer[viewer, caption, FALSE];
}
};

ViewerLocks.CallUnderWriteLock[DoIt, viewer]
};

SetParentViewer: PUBLIC PROC [
viewerInfo: TiogaVoicePrivate.VoiceViewerInfo, parentViewer: ViewerClasses.Viewer, positionInParent: TiogaOpsDefs.Location] = {
viewerInfo.parentViewer _ parentViewer;
viewerInfo.positionInParent _ positionInParent;
TiogaVoicePrivate.RegisterViewer[parentViewer]
};

RemoveParentViewer: PUBLIC PROC [viewerNumber: INT] = {
FOR info: TiogaVoicePrivate.VoiceViewerInfo _ voiceViewerInfoList, info.nextInfoRec WHILE info # NIL DO
IF info.viewerNumber = viewerNumber THEN {info.parentViewer _ NIL; RETURN}
ENDLOOP
};

InsertVoiceViewerInfo: PROC RETURNS [
newViewerInfo: TiogaVoicePrivate.VoiceViewerInfo] = {
restOfList: TiogaVoicePrivate.VoiceViewerInfo _ voiceViewerInfoList;
newViewerInfo _ NEW[TiogaVoicePrivate.VoiceViewerInfoRec];

IF voiceViewerInfoList = NIL 
THEN 
{  newViewerInfo.viewerNumber _ 1;
voiceViewerInfoList _ newViewerInfo;
RETURN
};

IF voiceViewerInfoList.viewerNumber > 1 THEN
{  newViewerInfo.viewerNumber _ 1;
newViewerInfo.nextInfoRec _ voiceViewerInfoList;
voiceViewerInfoList _ newViewerInfo;
RETURN
};

DO
IF restOfList.nextInfoRec = NIL 
OR restOfList.nextInfoRec.viewerNumber > restOfList.viewerNumber + 1
THEN
{  newViewerInfo.viewerNumber _ restOfList.viewerNumber + 1;
newViewerInfo.nextInfoRec _ restOfList.nextInfoRec;
restOfList.nextInfoRec _ newViewerInfo;
RETURN
};
restOfList _ restOfList.nextInfoRec
ENDLOOP
};

StoreVoice: Menus.MenuProc = {
viewerInfo: TiogaVoicePrivate.VoiceViewerInfo _ NARROW[ViewerOps.FetchProp[NARROW[parent], $voiceViewerInfo], TiogaVoicePrivate.VoiceViewerInfo];
oldParentViewer: ViewerClasses.Viewer _ viewerInfo.parentViewer;
oldPosition: TiogaOpsDefs.Location _ viewerInfo.positionInParent;
IF TiogaVoicePrivate.StoreVoiceAtSelection[viewerInfo]
THEN 
{  MakeNotEdited[NARROW[parent]];
IF oldParentViewer # NIL THEN TiogaVoicePrivate.DeleteSourceMarker[oldParentViewer, oldPosition, viewerInfo.viewerNumber]
}
};

SaveVoice: Menus.MenuProc = {
viewer: ViewerClasses.Viewer _ NARROW[parent];
viewerInfo: TiogaVoicePrivate.VoiceViewerInfo _ NARROW[ViewerOps.FetchProp[viewer, $voiceViewerInfo], TiogaVoicePrivate.VoiceViewerInfo];

IF ~viewerInfo.edited THEN
{  MessageWindow.Append["voice viewer is not edited", TRUE];
RETURN
};

IF viewerInfo.parentViewer = NIL THEN
{  MessageWindow.Append["voice viewer has no parent text viewer", TRUE];
MessageWindow.Blink[];
RETURN
};

IF ~TiogaVoicePrivate.SaveRopeAtSourceMarker[viewerInfo.parentViewer, viewerInfo.positionInParent, viewerInfo.viewerNumber, viewerInfo.ropeInterval.ropeID, TiogaVoicePrivate.RopeFromTextList[viewerInfo.textMarkList]] THEN
{  
MessageWindow.Append["unable to find source marker for voice window: voice not saved", TRUE];
MessageWindow.Blink[];
RETURN
};

MakeNotEdited[viewer]
};

RemoveVoiceViewerInfo: PROC [
viewerInfo: TiogaVoicePrivate.VoiceViewerInfo] = {
IF voiceViewerInfoList = NIL THEN ERROR;
IF voiceViewerInfoList = viewerInfo 
THEN voiceViewerInfoList _ viewerInfo.nextInfoRec
ELSE
{  ptrToCurrInfo: TiogaVoicePrivate.VoiceViewerInfo _ voiceViewerInfoList;
currInfo: TiogaVoicePrivate.VoiceViewerInfo _ voiceViewerInfoList.nextInfoRec;
DO
IF currInfo = NIL THEN ERROR;
IF currInfo = viewerInfo
THEN 
{  ptrToCurrInfo.nextInfoRec _ viewerInfo.nextInfoRec;
RETURN
};
ptrToCurrInfo _ currInfo;
currInfo _ currInfo.nextInfoRec
ENDLOOP
}
};

DestroyViewerEvent: ViewerEvents.EventProc = { RETURN [~DestroyVoiceInfo[viewer]] };

DestroyVoiceInfo: PROC [
viewer: ViewerClasses.Viewer] RETURNS [didIt: BOOLEAN _ TRUE] = {
viewerInfo: TiogaVoicePrivate.VoiceViewerInfo _ NARROW[ViewerOps.FetchProp[viewer, $voiceViewerInfo], TiogaVoicePrivate.VoiceViewerInfo];

IF ~TiogaVoicePrivate.RemoveViewerReferences[viewer] THEN 
{  MessageWindow.Append["Wait until voice cue disappears before destroying viewer", TRUE];
MessageWindow.Blink[];
RETURN [FALSE]
};


IF viewerInfo.parentViewer = NIL 
THEN TiogaVoicePrivate.DebugRope[IO.PutFR["Voice viewer %d had no parent\n", IO.int[viewerInfo.viewerNumber]]] 
ELSE TiogaVoicePrivate.DeleteSourceMarker[viewerInfo.parentViewer, viewerInfo.positionInParent, viewerInfo.viewerNumber];

RemoveVoiceViewerInfo[viewerInfo];
ViewerEvents.UnRegisterEventProc[viewerInfo.destroyEvent, destroy];
ViewerEvents.UnRegisterEventProc[viewerInfo.changeColumnEvent, changeColumn];
};
 
RedrawViewerMenuProc: Menus.MenuProc = {
viewer: ViewerClasses.Viewer _ NARROW[parent];
viewerInfo: TiogaVoicePrivate.VoiceViewerInfo _ NARROW[ViewerOps.FetchProp[viewer, $voiceViewerInfo], TiogaVoicePrivate.VoiceViewerInfo];
IF GetVoiceLock[viewerInfo]  
THEN 
{ trueContents: Rope.ROPE _ TiogaVoicePrivate.SoundChars[viewerInfo].soundRope;
[] _ TiogaVoicePrivate.RedrawViewer[viewer, trueContents, 0, 0, 0, viewerInfo.remnant, FALSE, unAltered];
SetVoiceViewerEditStatus[viewer];
viewerInfo.editInProgress _ FALSE
}
};

ChangeColumnEvent: ViewerEvents.EventProc = {
viewerInfo: TiogaVoicePrivate.VoiceViewerInfo _ NARROW[ViewerOps.FetchProp[viewer, $voiceViewerInfo], TiogaVoicePrivate.VoiceViewerInfo];
IF (viewer.column = color) # viewerInfo.color THEN
{  viewerInfo.color _ viewer.column = color;
IF GetVoiceLock[viewerInfo]  
THEN 
{ trueContents: Rope.ROPE _ TiogaVoicePrivate.SoundChars[viewerInfo].soundRope;
[] _ TiogaVoicePrivate.RedrawViewer[viewer, trueContents, 0, 0, 0, viewerInfo.remnant, FALSE, unAltered];
SetVoiceViewerEditStatus[viewer];
viewerInfo.editInProgress _ FALSE
}
ELSE
{ MessageWindow.Append["Cannot repaint viewer during edit: click REDRAW to change window between color and monchrome if the wrong state persists", TRUE];
MessageWindow.Blink[]
}
}
};

GetVoiceLock: PUBLIC ENTRY PROC [
info: TiogaVoicePrivate.VoiceViewerInfo] RETURNS [gotIt: BOOLEAN] = {
gotIt _ ~ info.editInProgress;
IF info.editInProgress 
THEN MessageWindow.Append["Try again when the viewer's contents are stable", TRUE]
ELSE info.editInProgress _ TRUE;
};


InterceptAllInput: ViewerClasses.NotifyProc = {
IF ViewerOps.FetchProp[self, $voiceViewerInfo] = NIL 
THEN TEditInputImpl.InterpInput[self, input] -- just what the real one does 
ELSE 
{  passOnList, endOfPassOnList: LIST OF REF ANY _ NIL;
FOR currItem: LIST OF REF ANY _ input, currItem.rest WHILE currItem # NIL DO
WITH currItem.first SELECT FROM
z: REF CHAR => 
{  IF passOnList # NIL THEN 
{ TEditInputImpl.InterpInput[self, passOnList];
passOnList _ NIL
};
TiogaVoicePrivate.TextInput[self, Rope.FromChar[z^]]
};
z: Rope.ROPE => 
{  IF passOnList # NIL THEN 
{ TEditInputImpl.InterpInput[self, passOnList];
passOnList _ NIL
};
TiogaVoicePrivate.TextInput[self, z]
};
z: REF TEXT => 
{  IF passOnList # NIL THEN 
{ TEditInputImpl.InterpInput[self, passOnList];
passOnList _ NIL
};
TiogaVoicePrivate.TextInput[self, Rope.FromRefText[z]]
};
ENDCASE => 
IF passOnList = NIL 
THEN 
{  passOnList _ CONS[currItem.first, NIL];
endOfPassOnList _ passOnList
}
ELSE 
{  endOfPassOnList.rest _ CONS[currItem.first, NIL];
endOfPassOnList _ endOfPassOnList.rest
}
ENDLOOP;
IF passOnList # NIL THEN TEditInputImpl.InterpInput[self, passOnList]
}
};

InterceptBackSpace: TEditInput.CommandProc = {
IF TestPrimary[] = normal THEN RETURN;
TiogaVoicePrivate.BackSpace[viewer];
RETURN [quit: TRUE]
};

InterceptBackWord: TEditInput.CommandProc = {
IF TestPrimary[] = normal THEN RETURN;
TiogaVoicePrivate.BackWord[viewer];
RETURN [quit: TRUE]
};

InterceptDelete: TEditInput.CommandProc = {
IF TestPrimary[] = normal 
THEN TiogaVoicePrivate.TrackDeletes[]
ELSE
{  Delete[];
RETURN [quit: TRUE]
};
};

InterceptEdit: TEditInput.CommandProc = { 
quit _ TRUE;
IF TEditSelection.pSel.viewer = NIL THEN {
IF TEditSelection.sSel.viewer # NIL THEN TEditSelection.MakeSelection[NIL,secondary]; -- get rid of secondary
recordAtom _ FALSE }
ELSE IF TEditInput.editState = tolimbo THEN {
recordAtom _ FALSE; TEditInput.RecordRef[$Delete]; CheckDelete[TRUE] }
ELSE IF TEditSelection.sSel.viewer = NIL THEN recordAtom _ FALSE
ELSE {
RecordEditObject: PROC = {
TEditInput.RecordRef[SELECT TEditInputImpl.editObject FROM
text => $EditText,
looks => $EditLooks,
format => $EditFormat,
ENDCASE => ERROR] };
recordAtom _ TRUE;
SELECT TEditInput.editState FROM
reset, abort => recordAtom _ FALSE;
toprimary => {
TEditInput.RecordRef[$GetSecondary];
TEditInput.RecordRef[$ToPrimary];
RecordEditObject[];
SELECT TEditInputImpl.editObject FROM
text => {
IF TEditSelection.pSel.pendingDelete THEN TEditInput.RecordRef[$MakePDel];
CheckCopy[primary] };
looks => CheckCopyLooks[primary];
format => CheckCopyFormat[primary];
ENDCASE => ERROR };
tosecondary => {
TEditInput.RecordRef[$GetSecondary];
TEditInput.RecordRef[$ToSecondary];
RecordEditObject[];
SELECT TEditInputImpl.editObject FROM
text => {
IF TEditSelection.pSel.pendingDelete THEN TEditInput.RecordRef[$MakePDel];
CheckCopy[secondary] };
looks => CheckCopyLooks[secondary];
format => CheckCopyFormat[secondary];
ENDCASE => ERROR };
toboth => {
TEditInput.RecordRef[$GetSecondary];
TEditInput.RecordRef[$ToBoth];
RecordEditObject[];
SELECT TEditInputImpl.editObject FROM
text => CheckTranspose[];
looks => CheckTransposeLooks[];
format => CheckTransposeFormat[];
ENDCASE => ERROR };
ENDCASE => ERROR };
TEditInput.editState _ reset; TEditInputImpl.editObject _ text;
TEditInputImpl.pdelState _ reset; TEditInputImpl.pDel _ FALSE; TEditInputImpl.selState _ reset; TEditInputImpl.sel _ primary;
TEditInputImpl.mouseColor _ red; -- put these back to normal
IF TEditInputImpl.editMessage # NIL THEN MessageWindow.Clear[];
TEditInputImpl.editMessage _ NIL };

selectionTypes: TYPE = {bothNormal, primaryVoice, secondaryVoice, bothVoice};

TestSelections: PROC RETURNS [types: selectionTypes] = {
types _ IF ViewerOps.FetchProp[TiogaOps.GetSelection[primary].viewer, $voiceViewerInfo] = NIL THEN
( IF ViewerOps.FetchProp[TiogaOps.GetSelection[secondary].viewer, $voiceViewerInfo] = NIL THEN bothNormal ELSE secondaryVoice )
ELSE
( IF ViewerOps.FetchProp[TiogaOps.GetSelection[secondary].viewer, $voiceViewerInfo] = NIL THEN primaryVoice ELSE bothVoice )
};

primaryType: TYPE = {normal, voice};

TestPrimary: PROC RETURNS [type: primaryType] = {
 type _ IF ViewerOps.FetchProp[TiogaOps.GetSelection[primary].viewer, $voiceViewerInfo] = NIL THEN normal ELSE voice
};

CheckDelete: PROC [saveForPaste: BOOL _ TRUE] = {
SELECT TestPrimary[] FROM
normal => 
{  TiogaVoicePrivate.TrackDeletes[];
TEditInputOps.Delete[saveForPaste]
};
voice => Delete[]
ENDCASE
}; 

CheckCopy: PROC [target: TEditDocument.SelectionId _ primary] = {
SELECT TestSelections[] FROM
bothNormal => TEditInputOps.Copy[target];
bothVoice => Copy[target];
ENDCASE => Mumble["Copy", "voice and text"]
};

CheckCopyFormat: PROC [target: TEditDocument.SelectionId _ primary] = {
SELECT TestSelections[] FROM
bothNormal => TEditInputOps.CopyFormat[target];
bothVoice => Mumble["Copy format", "two voice"]
ENDCASE => Mumble["Copy format", "voice and text"]
};

CheckCopyLooks: PROC [target: TEditDocument.SelectionId _ primary] = {
SELECT TestSelections[] FROM
bothNormal => TEditInputOps.CopyLooks[target];
bothVoice => Mumble["Copy looks", "two voice"]
ENDCASE => Mumble["Copy looks", "voice and text"]
};

CheckTranspose: PROC [target: TEditDocument.SelectionId _ primary] = {
SELECT TestSelections[] FROM
bothNormal => TEditInputOps.Transpose[target];
bothVoice => Transpose[target];
ENDCASE => Mumble["Transpose", "voice and text"]
};

CheckTransposeFormat: PROC [target: TEditDocument.SelectionId _ primary] = {
SELECT TestSelections[] FROM
bothNormal => TEditInputOps.TransposeFormat[target];
bothVoice => Mumble["Transpose format", "two voice"]
ENDCASE => Mumble["Transpose format", "voice and text"]
};

CheckTransposeLooks: PROC [target: TEditDocument.SelectionId _ primary] = {
SELECT TestSelections[] FROM
bothNormal => TEditInputOps.TransposeLooks[target];
bothVoice => Mumble["Transpose looks", "two voice"]
ENDCASE => Mumble["Transpose looks", "voice and text"]
};

textClassDescriptor: ViewerClasses.ViewerClass _ ViewerOps.FetchViewerClass[$Text];
realNotifyProc: ViewerClasses.NotifyProc _ textClassDescriptor.notify;

HereWeGoAgain: Commander.CommandProc = {
textClassDescriptor: ViewerClasses.ViewerClass _ ViewerOps.FetchViewerClass[$Text];
textClassDescriptor.notify _ realNotifyProc;
TEditInput.UnRegister[$BackSpace, InterceptBackSpace];
TEditInput.UnRegister[$BackWord, InterceptBackWord];  
TEditInput.UnRegister[$Delete, InterceptDelete]; 
TEditInput.UnRegister[$DoEdit, InterceptEdit];
};

BadVoiceViewerDisplay: ERROR [viewer: ViewerClasses.Viewer];

Mumble: PUBLIC PROC [opAttempted: Rope.ROPE, viewerTypes: Rope.ROPE] = {
MessageWindow.Append[IO.PutFR["%g is not a valid operation between %g viewers", IO.rope[opAttempted], IO.rope[viewerTypes]], TRUE];
MessageWindow.Blink[]
};

DescribeSelection: PUBLIC PROC [
which: TiogaOpsDefs.WhichSelection, forceDelete: BOOLEAN, returnSoundInterval: BOOLEAN, viewerAlreadyLocked: ViewerClasses.Viewer _ NIL] RETURNS [failed: BOOLEAN _ FALSE, selection: TiogaVoicePrivate.Selection, soundInterval: TiogaVoicePrivate.SoundInterval _ NIL] = {
selStart, selEnd: TiogaOps.Location;
caretBefore, pendingDelete: BOOL;
level: TiogaOpsDefs.SelectionGrain;
selection _ NEW[TiogaVoicePrivate.SelectionRec];


[viewer: selection.viewer, start: selStart, end: selEnd, level: level, caretBefore: caretBefore, pendingDelete: pendingDelete] _ TiogaOps.GetSelection[which];
selection.voiceViewerInfo _ NARROW[ViewerOps.FetchProp[selection.viewer, $voiceViewerInfo], TiogaVoicePrivate.VoiceViewerInfo];
IF ~( viewerAlreadyLocked = selection.viewer OR GetVoiceLock[selection.voiceViewerInfo] ) THEN {failed _ TRUE; RETURN}; 
IF selStart.node # selEnd.node THEN ERROR BadVoiceViewerDisplay[selection.viewer];
selection.displayNode _ selStart.node;

 
selection.ropeInterval _ [selection.voiceViewerInfo.ropeInterval.ropeID, selStart.where*TiogaVoicePrivate.soundRopeCharLength, (selEnd.where+(IF level=point THEN 0 ELSE 1))*TiogaVoicePrivate.soundRopeCharLength -selStart.where*TiogaVoicePrivate.soundRopeCharLength];

IF selection.ropeInterval.start + selection.ropeInterval.length > selection.voiceViewerInfo.ropeInterval.length THEN ERROR BadVoiceViewerDisplay[selection.viewer];

IF returnSoundInterval THEN 
{  soundInterval _ NEW [TiogaVoicePrivate.SoundIntervalRec _ [ropeInterval: selection.ropeInterval]];
TiogaVoicePrivate.ExtractSoundList[selection.voiceViewerInfo, soundInterval];
TiogaVoicePrivate.ExtractCharMarks[selection.voiceViewerInfo, soundInterval];
TiogaVoicePrivate.ExtractTextMarks[selection.voiceViewerInfo, soundInterval] -- the width/displayChars fields in this will not necessarily be valid at the end of the list
};

IF ~(pendingDelete OR forceDelete) 
THEN 
{  
IF ~caretBefore THEN selection.ropeInterval.start _ selection.ropeInterval.start + selection.ropeInterval.length;
selection.ropeInterval.length _ 0
}
};

ReplaceSelectionWithSavedInterval: PUBLIC PROC [
selection: TiogaVoicePrivate.Selection, soundInterval: TiogaVoicePrivate.SoundInterval, leaveSelected: BOOLEAN] RETURNS [viewerDeleted: BOOLEAN, insertChars, positionAfterInsert: INT] = {
newViewerContents: Rope.ROPE;
displayCutPoint, deleteChars: INT;

IF selection.ropeInterval.length = 0 AND soundInterval = NIL THEN RETURN;

TiogaVoicePrivate.ReplaceSoundList[voiceViewerInfo: selection.voiceViewerInfo, cutStart: selection.ropeInterval.start, cutLength: selection.ropeInterval.length, replacement: IF soundInterval = NIL THEN NIL ELSE soundInterval.soundList];

displayCutPoint _ selection.ropeInterval.start/TiogaVoicePrivate.soundRopeCharLength;
deleteChars _ selection.ropeInterval.length/TiogaVoicePrivate.soundRopeCharLength;
insertChars _ IF soundInterval = NIL THEN 0 ELSE soundInterval.ropeInterval.length/TiogaVoicePrivate.soundRopeCharLength;
positionAfterInsert _ displayCutPoint + insertChars + 1; 

TiogaVoicePrivate.EditCharMarks[selection.voiceViewerInfo, displayCutPoint, deleteChars, insertChars, soundInterval];
TiogaVoicePrivate.EditTextMarks[selection.voiceViewerInfo, displayCutPoint, deleteChars, insertChars, soundInterval];
TiogaVoicePrivate.EditAges[selection.voiceViewerInfo, displayCutPoint, deleteChars, insertChars];

[newViewerContents, selection.voiceViewerInfo.remnant] _ TiogaVoicePrivate.SoundChars[selection.voiceViewerInfo, displayCutPoint];
newViewerContents _ Rope.Concat[(TiogaOps.GetRope[selection.displayNode]).Substr[0, displayCutPoint], newViewerContents];
selection.displayNode _ TiogaVoicePrivate.RedrawViewer[selection.viewer, newViewerContents, displayCutPoint, deleteChars, insertChars, selection.voiceViewerInfo.remnant, TRUE, IF leaveSelected THEN primaryOnInsert ELSE deSelected];
viewerDeleted _ TextEdit.Size[TiogaButtons.TextNodeRef[selection.displayNode]] = 0; 
IF viewerDeleted 
THEN 
{  MessageWindow.Append["voice viewer now completely empty - destroying", TRUE];
ViewerOps.DestroyViewer[selection.viewer]
}
ELSE
{  
selection.voiceViewerInfo.ropeInterval _ VoiceRope.Replace[handle: TiogaVoicePrivate.thrushHandle, vr: NEW [VoiceRope.VoiceRopeInterval _ selection.voiceViewerInfo.ropeInterval], start: selection.ropeInterval.start, len: selection.ropeInterval.length, with: IF soundInterval = NIL THEN NIL ELSE NEW [VoiceRope.VoiceRopeInterval _ soundInterval.ropeInterval]]^
}
};
Delete: PUBLIC PROC = {
charAfterDelete: INT;
viewerDeleted: BOOLEAN;
selectionLocked: BOOLEAN; 
selection: TiogaVoicePrivate.Selection;
[selection: selection, failed: selectionLocked] _ DescribeSelection[which: primary, forceDelete: TRUE, returnSoundInterval: FALSE];
IF selectionLocked THEN RETURN;

selection.voiceViewerInfo.edited _ TRUE;
[positionAfterInsert: charAfterDelete, viewerDeleted: viewerDeleted] _ ReplaceSelectionWithSavedInterval[selection: selection, soundInterval: NIL, leaveSelected: TRUE];
IF ~viewerDeleted THEN 
{  
TiogaOps.SelectPoint[viewer: selection.viewer, caret: [selection.displayNode, MIN [charAfterDelete, TextEdit.Size[TiogaButtons.TextNodeRef[selection.displayNode]]-1]], which: primary];
selection.voiceViewerInfo.editInProgress _ FALSE
} 
};

Copy: PUBLIC PROC [target: TEditDocument.SelectionId _ primary] = {
sourceSelection, destSelection: TiogaVoicePrivate.Selection;
sourceInterval: TiogaVoicePrivate.SoundInterval;
selectionLocked: BOOLEAN;

destMovesForward: INT _ 0;

[selection: sourceSelection, soundInterval: sourceInterval, failed: selectionLocked] _ DescribeSelection[which: (IF target=primary THEN secondary ELSE primary), forceDelete: FALSE, returnSoundInterval: TRUE];
IF ~selectionLocked THEN
{
[selection: destSelection, failed: selectionLocked] _ DescribeSelection[which: (IF target=primary THEN primary ELSE secondary), forceDelete: FALSE, returnSoundInterval: FALSE, viewerAlreadyLocked: sourceSelection.viewer];
IF selectionLocked THEN sourceSelection.voiceViewerInfo.editInProgress _ FALSE
};
TiogaOps.CancelSelection[primary];
TiogaOps.CancelSelection[secondary];
IF selectionLocked THEN RETURN;
destSelection.voiceViewerInfo.edited _ TRUE;

IF sourceSelection.ropeInterval.length # 0
THEN
{  sourceSelection.voiceViewerInfo.edited _ TRUE;
IF sourceSelection.viewer = destSelection.viewer -- special case of same viewer
THEN
{  
IF (sourceSelection.ropeInterval.start< destSelection.ropeInterval.start+destSelection.ropeInterval.length) = (destSelection.ropeInterval.start< sourceSelection.ropeInterval.start+sourceSelection.ropeInterval.length)
THEN
{  firstStart: INT _ destSelection.ropeInterval.start;
firstLength: INT _ MAX [sourceSelection.ropeInterval.start -destSelection.ropeInterval.start, 0];
secondStart: INT _ sourceSelection.ropeInterval.start + sourceSelection.ropeInterval.length; 
secondLength: INT _ MAX [(destSelection.ropeInterval.start+destSelection.ropeInterval.length) - (sourceSelection.ropeInterval.start+sourceSelection.ropeInterval.length), 0];

sourceSelection.ropeInterval.start _ firstStart;
sourceSelection.ropeInterval.length _ firstLength;
destSelection.ropeInterval.start _ secondStart;
destSelection.ropeInterval.length _ secondLength;
sourceInterval _ NIL
};

IF sourceSelection.ropeInterval.start<destSelection.ropeInterval.start THEN destMovesForward _ sourceSelection.ropeInterval.length
};

IF ~ReplaceSelectionWithSavedInterval[sourceSelection, NIL, FALSE].viewerDeleted THEN
{ IF sourceSelection.viewer # destSelection.viewer THEN sourceSelection.voiceViewerInfo.editInProgress _ FALSE }
}
ELSE 
{  IF sourceSelection.viewer # destSelection.viewer THEN sourceSelection.voiceViewerInfo.editInProgress _ FALSE
};

destSelection.ropeInterval.start _ destSelection.ropeInterval.start - destMovesForward;
[] _ ReplaceSelectionWithSavedInterval[destSelection, sourceInterval, TRUE];
destSelection.voiceViewerInfo.editInProgress _ FALSE
};

Transpose: PUBLIC PROC [target: TEditDocument.SelectionId _ primary] = {
IF target = feedback THEN ERROR;
TiogaVoicePrivate.DebugRope["Voice transpose:\n"];
SelectionStates[];
TiogaVoicePrivate.DebugRope["not yet implemented.\n"];
};

SelectionStates: PROC = {
TiogaVoicePrivate.DebugRope[" Primary selection is"];
IF ~TiogaOps.GetSelection[primary].pendingDelete THEN TiogaVoicePrivate.DebugRope[" not"];
TiogaVoicePrivate.DebugRope[" pending delete,\n secondary selection is"]; 
IF ~TiogaOps.GetSelection[secondary].pendingDelete THEN TiogaVoicePrivate.DebugRope[" not"];
TiogaVoicePrivate.DebugRope[" pending delete\n"]
};

SoundListFromIntervalSpecs: PUBLIC PROC [
intervalSpecs: VoiceRope.IntervalSpecs, lengthOfRopeInterval: INT] RETURNS [soundList: TiogaVoicePrivate.SoundList _ NIL] = {
lastSoundEnd: INT _ 0;
FOR l: VoiceRope.IntervalSpecs _ intervalSpecs, l.rest WHILE l # NIL DO
soundList _ AppendSound[soundList, [l.first.start - lastSoundEnd, l.first.length]];
lastSoundEnd _ l.first.start + l.first.length
ENDLOOP;
IF lengthOfRopeInterval > lastSoundEnd THEN soundList _ AppendSound[soundList, [lengthOfRopeInterval-lastSoundEnd, 0]]
};

ExtractSoundList: PUBLIC PROC [
voiceViewerInfo: TiogaVoicePrivate.VoiceViewerInfo, soundInterval: TiogaVoicePrivate.SoundInterval] = {
soughtStart: INT _ soundInterval.ropeInterval.start;
soughtEnd: INT _ soughtStart + soundInterval.ropeInterval.length;
currStart, currEnd: INT _ 0;
thisSilence, thisSound: INT;

FOR l: TiogaVoicePrivate.SoundList _ voiceViewerInfo.soundList, l.rest WHILE l # NIL AND soughtEnd > currEnd DO
currStart _ currEnd;
thisSilence _ l.first.silence;
thisSound _ l.first.sound;
currEnd _ currStart + thisSilence + thisSound;
IF soughtStart < currEnd THEN 
{  IF soughtStart > currStart 
THEN 
{  thisSound _ thisSound - MAX [soughtStart-currStart-thisSilence, 0];
thisSilence _ thisSilence - MIN [soughtStart-currStart, thisSilence]
};
IF soughtEnd < currEnd 
THEN 
{  thisSilence _ thisSilence - MAX [currEnd-soughtEnd-thisSound, 0];
thisSound _ thisSound - MIN [ currEnd-soughtEnd, thisSound]
};
AppendSoundToSoundInterval[soundInterval, [thisSilence, thisSound]]
}
ENDLOOP
};

ReplaceSoundList: PUBLIC PROC [
voiceViewerInfo: TiogaVoicePrivate.VoiceViewerInfo, cutStart: INT, cutLength: INT, replacement: TiogaVoicePrivate.SoundList] = {
tail, workingPtr: TiogaVoicePrivate.SoundList;
endCurrSound, startCurrSound: INT _ 0;
IF cutStart = 0 
THEN {
tail _ voiceViewerInfo.soundList;
voiceViewerInfo.soundList _ NIL
} ELSE {
FOR workingPtr _ voiceViewerInfo.soundList, workingPtr.rest DO
endCurrSound _ endCurrSound + workingPtr.first.silence + workingPtr.first.sound;
IF endCurrSound >= cutStart THEN EXIT
ENDLOOP;
tail _ workingPtr.rest;
workingPtr.rest _ NIL;

IF endCurrSound > cutStart THEN -- Have to 'move sound from workingPtr to tail'
{  silenceToMove: INT _ MAX [endCurrSound-cutStart-workingPtr.first.sound, 0];
soundToMove: INT _ MIN [endCurrSound-cutStart, workingPtr.first.sound];
tail _ CONS[[silenceToMove, soundToMove], tail];
workingPtr.first.silence _ workingPtr.first.silence - silenceToMove;
workingPtr.first.sound _ workingPtr.first.sound - soundToMove
}
};

endCurrSound _ 0; DO
startCurrSound _ endCurrSound;
IF startCurrSound = cutLength THEN EXIT;
endCurrSound _ endCurrSound + tail.first.silence + tail.first.sound;
IF endCurrSound > cutLength THEN EXIT;
tail _ tail.rest;
ENDLOOP;

IF startCurrSound < cutLength THEN -- delete some of the sound in the head of the list 
{ silenceToSave: INT _ MAX [endCurrSound-cutLength-tail.first.sound, 0];
soundToSave: INT _ MIN [endCurrSound-cutLength, tail.first.sound];
tail.first.silence _ silenceToSave;
tail.first.sound _ soundToSave
};

IF replacement = NIL THEN replacement _ tail ELSE AppendSoundListToSoundList[replacement, tail];
IF voiceViewerInfo.soundList = NIL THEN voiceViewerInfo.soundList _ replacement ELSE AppendSoundListToSoundList[voiceViewerInfo.soundList, replacement]
};

SoundChars: PUBLIC PROC [
viewerInfo: TiogaVoicePrivate.VoiceViewerInfo, skipChars: INT _ 0] RETURNS [soundRope: Rope.ROPE _ NIL, remnant: INT] = {
soundList: TiogaVoicePrivate.SoundList _ viewerInfo.soundList;
partiallyFilled: BOOLEAN _ FALSE;
partsFilled: [0..TiogaVoicePrivate.soundRopeCharDivisions] _ 0;
soundMajority: ARRAY [0..TiogaVoicePrivate.soundRopeCharDivisions) OF BOOLEAN;
samplesAccounted, soundComponents: [0..TiogaVoicePrivate.soundRopeResolution] _ 0;
skipping: BOOLEAN _ skipChars>0;
skipSamples: INT _ skipChars*TiogaVoicePrivate.soundRopeCharLength;

AddChars: PROC [length: INT, sound: BOOLEAN] = {

AddToPartChar: PROC [availableSamples: INT, sound: BOOLEAN] RETURNS [usedSamples: [0..TiogaVoicePrivate.soundRopeResolution]] = {
partiallyFilled _ TRUE;
usedSamples _ MIN[availableSamples, TiogaVoicePrivate.soundRopeResolution-samplesAccounted];
samplesAccounted _ samplesAccounted + usedSamples;
IF sound THEN soundComponents _ soundComponents + usedSamples;
IF samplesAccounted = TiogaVoicePrivate.soundRopeResolution
THEN
{  soundMajority[partsFilled] _ soundComponents >= TiogaVoicePrivate.soundRopeResolution/2;
samplesAccounted _ 0;
soundComponents _ 0;
partsFilled _ partsFilled + 1;
IF partsFilled = TiogaVoicePrivate.soundRopeCharDivisions
THEN
{  binaryOfChar: INT _ 0;

partsFilled _ 0;
partiallyFilled _ FALSE;
FOR i: INT IN [0..TiogaVoicePrivate.soundRopeCharDivisions) DO
binaryOfChar _ binaryOfChar*2 + (IF soundMajority[i] THEN 1 ELSE 0)
ENDLOOP;
soundRope _ soundRope.Concat[Rope.FromChar[IF binaryOfChar # 0 THEN ('A + binaryOfChar) ELSE '!]] -- 'A is the base type of the sound font [i.e. all segments clear] but the 'all clear' character is actually ! so as to make 'word selections' work in normal tioga terms
}
}
};

WHILE partiallyFilled AND length>0 DO
taken: INT _ AddToPartChar[length, sound];
length _ length - taken
ENDLOOP;

WHILE length >= TiogaVoicePrivate.soundRopeCharLength DO
soundRope _ soundRope.Concat[Rope.FromChar[IF sound THEN ('A + 15) ELSE '!]];
length _ length - TiogaVoicePrivate.soundRopeCharLength
ENDLOOP;

WHILE length>0 DO
taken: INT _ AddToPartChar[length, sound];
length _ length - taken
ENDLOOP
};

FOR l: TiogaVoicePrivate.SoundList _ soundList, l.rest WHILE l # NIL DO
silence: INT _ l.first.silence;
sound: INT _ l.first.sound;
IF skipping
THEN
{  IF silence >= skipSamples
THEN
{  silence _ silence - skipSamples;
skipping _ FALSE;
AddChars[length: silence, sound: FALSE];
AddChars[length: sound, sound: TRUE]
}
ELSE
{  skipSamples _ skipSamples - silence;
IF sound >= skipSamples
THEN
{  sound _ sound - skipSamples;
skipping _ FALSE;
AddChars[length: sound, sound: TRUE]
}
ELSE skipSamples _ skipSamples - sound;
}
}
ELSE
{  AddChars[length: silence, sound: FALSE];
AddChars[length: sound, sound: TRUE]
}
ENDLOOP;
remnant _ IF partiallyFilled THEN partsFilled*TiogaVoicePrivate.soundRopeResolution+samplesAccounted ELSE 0;
soundRope _ TiogaVoicePrivate.DisplayCharMarks[soundRope, viewerInfo.charMarkList, skipChars]
};
 
LastSilenceInSoundList: PUBLIC PROC [
soundList: TiogaVoicePrivate.SoundList, lengthGreaterThan: INT _ 0] RETURNS [startsAt: INT, lasts: INT _ -1] = {
l: TiogaVoicePrivate.SoundList _ soundList;
currSilenceStart: INT _ 0;
WHILE l # NIL DO
IF l.first.silence > lengthGreaterThan THEN
{  startsAt _ currSilenceStart;
lasts _ l.first.silence
};
currSilenceStart _ currSilenceStart + l.first.silence + l.first.sound;
l _ l.rest
ENDLOOP
};

AppendSound: PROC [
list: TiogaVoicePrivate.SoundList, entry: TiogaVoicePrivate.Sound] RETURNS [TiogaVoicePrivate.SoundList] = {
oneElementList: TiogaVoicePrivate.SoundList _ CONS[entry, NIL];
hangOffPoint: TiogaVoicePrivate.SoundList _ list;
IF list = NIL THEN RETURN [oneElementList];
WHILE hangOffPoint.rest # NIL DO hangOffPoint _ hangOffPoint.rest ENDLOOP;
hangOffPoint.rest _ oneElementList;
RETURN [list]
};

AppendSoundToSoundInterval: PROC [
soundInterval: TiogaVoicePrivate.SoundInterval, entry: TiogaVoicePrivate.Sound] = {
oneElementList: TiogaVoicePrivate.SoundList _ CONS[entry, NIL];
hangOffPoint: TiogaVoicePrivate.SoundList _ soundInterval.soundList;
IF hangOffPoint = NIL THEN {soundInterval.soundList _ oneElementList; RETURN}; 
WHILE hangOffPoint.rest # NIL DO hangOffPoint _ hangOffPoint.rest ENDLOOP;
hangOffPoint.rest _ oneElementList
};

AppendSoundListToSoundList: PROC [
head, tail: TiogaVoicePrivate.SoundList] = {
hangOffPoint: TiogaVoicePrivate.SoundList _ head;
IF tail = NIL THEN RETURN;
WHILE hangOffPoint.rest # NIL DO hangOffPoint _ hangOffPoint.rest ENDLOOP;
IF hangOffPoint.first.sound = 0 OR tail.first.silence = 0 THEN -- these two can be amalgamated
{  hangOffPoint.first.sound _ hangOffPoint.first.sound + tail.first.sound;
hangOffPoint.first.silence _ hangOffPoint.first.silence + tail.first.silence;
tail _ tail.rest
};
hangOffPoint.rest _ tail
};


CreateVoiceViewerMenu[];
Commander.Register[key: "ReadyToRoll", proc: HereWeGoAgain, doc: "ReadyToRoll: do it before running this again!"];

TEditInput.Register[$BackSpace, InterceptBackSpace];
TEditInput.Register[$BackWord, InterceptBackWord];
TEditInput.Register[$Delete, InterceptDelete];
TEditInput.Register[$DoEdit, InterceptEdit];

textClassDescriptor.notify _ InterceptAllInput;

}.

`VoiceViewersImpl.mesa
Copyright Ó 1987 by Xerox Corporation.  All rights reserved.
Ades, May 1, 1986 1:34:00 pm PDT
Swinehart, April 9, 1987 9:39:24 am PDT


Voice Viewers

	icon: create one of these



**** the Plass-bug: shouldn't be necessary and he says he'll have a look at it
this procedure will make a voice viewer think itself unedited, when we wish to assert that there is no voice rope held only in it - use carefully!!
this is similar to the above, except that it ensures that the viewer has the same idea about whether the voice is edited as the VoiceInfo record. For use by functions [such as moving a visual cue along a voice viewer during playback] which need to edit the viewer but not the voice and then want to reflect this fact in the viewer's status
**** locking against edits in this and the next one?
should check also whether viewer is undergoing editing
Voice Edit Intercept

Routines to pick up edit events affecting voice viewers and pass control from normal Tioga ops.
This code stinks for a number of reasons
i) it only picks up a subset of the events which could affect a voice viewer
ii) it SHARES an Impl !!!!!!! - TEditInputImpl to be precise. This occurs only in InterceptEdit, for reasons explained above that procedure
iii) it redefines the 'notify proc' for the $Text class!! - it does exactly what the ousted notify proc would do in the case of non-voice viewers, by calling a TEditInputImpl procedure. At the cost of another procedure call it could be more clean my saving the ousted procedure and calling that, but since I've had to import the Impl anyhow . . . .

The way things should be is that either an equivalent package to tioga is produced specially for voice editing windows or TEditInputOps is rewritten to call TiogaVoice code for viewers managed by TiogaVoice [detectable from the properties that those viewers have]. 

this part of the code is extremely sordid: it really needs to be in TEditInputImpl and for that reason it references private variables from TEditInputImpl 23 times: it gets called in front of the Tioga DoEdit procedure and returns quit=FALSE under all circumstances in order to prevent the real one ever being called
this and the following series of 'Check' procedures test if the proposed edit is applied to normal text: if so they first call the appropriate SourceMarkerTracking routine and then pass control to TEditInputOps [just like TEditInputImpl.DoEdit always would], otherwise they pass control to Voice Edit Ops
This just whilste under development . . .
Voice Edit Ops

Routines to edit voice viewers, plus some routines to intercept operations deemed inapplicable for voice or voice/text viewer combinations.

this routine will characterise the voice corresponding to a selection: if the selection is pendingDelete [or if forceDelete] then the selection.ropeInterval will have non-zero length; if returnSoundInterval then the sound interval corresponding to the whole selection will be characterised - to be saved and inserted somewhere else
selections can only be described if the voiceLock can be taken out on them: this routine returns failed if it cannot get the lock; otherwise it returns with the lock still held. However the caller may pass a viewer in viewerAlreadyLocked to say that he already has that one locked and if this
selection is in the same viewer then we may proceed
work out the VoiceRopeInterval corresponding to the whole selection
it is here that policy about trimming the sound selection e.g. to silence/sound boundaries could be implemented
this routine actually does all the editing work for voice: it is passed a selection specification and a sound specification: if the selection is of non-zero length it is deleted; then if the sound is non-nil it is inserted
this routine (i) works out what the updated voice viewer sound list and contents will be (ii) calls TiogaVoicePrivate to redraw the viewer [done there since the viewer may be somewhere in the queue of sounds to be played back] (iii) interacts with the voice rope data base to update the rope specification corresponding to the viewer
it may turn out that there is nothing left in the viewer at the end of this action, in which case the viewer will simply be deleted. However this is not done until after TiogaVoicePrivate. RedrawViewer has been called since a viewer cannot be destroyed whilst the playback caret is in it: after a call to RedrawViewer the playback caret cannot be in it!!
there is no way to stop this destruction in this implementation: in a Copy/Transpose both selections could be in the same viewer but if so the result of the first call to this procedure cannot be an empty viewer

those three need only be [and are only] approximate
done for efficiency - no need to recalculate the first characters again

redrawing isdone in TiogaVoicePrivate for sync with any playback cues
the last but one parameter governs whether this edit will cause all previous edits to age [only if insertChars # 0]. It is simply set TRUE here: if there were any use for such a facility a parameter could be passed by caller of ReplaceSelectionWithSavedInterval to pass on here

this will cause the event proc which clears down the voiceViewerInfo etc. to be called
  
delete the primary selection
if source selection is pending delete and ahead of the destination selection in the same viewer, then after the first action of deleting source the destination will be nearer the start of the sound 

we drop the selections here because after a ReplaceSelectionWithSavedInterval call a viewer may not exist! If a selection above failed we should also drop the selections here as well - if selections are left around after an aborted tioga editing operation unpleasant thing tend to happen

if true then source is pending delete: this means two edit operations
that is the test for overlapping selections: if source is pending delete the copy operation then reduces to "delete the region(s) lying in the destination but not in the source selection" - done here as a special case
done by substituting first and second regions for source and destination selections
and setting soundInterval to NIL: note that either of these regions may now have zero length
SoundList

Sound lists are descriptions of the silence/sound profiles of a ropeInterval and form part of the data structure behind a voice viewer.

voiceViewerInfo contains the sound list for a complete rope. Use the interval specification from soundInterval.ropeInterval to create a new sound list for that interval, placing it in soundInterval.soundList.
voiceViewerInfo contains the sound list for a complete rope. Cut out the specified portion and at the cutting point insert the replacement soundlist.  
No tests for shooting off the end in this routine.  If we get an error then our caller has gone badly wrong and there is no obvious way to recover.
With the head of the old rope in voiceViewerInfo.soundList, delete the unwanted sound from the tail.
We can now join up our three lists. 
Produce the graphical representation of the SoundList within a VoiceViewerInfo record. The caller already has the first skipChars of the representation in his hand, so omit these from the returned rope. If the sound list does not exactly fill a whole number of characters, return as remnant the number of samples left over. Any marker characters indicated in the VoiceViewerInfo are inserted.
15  represents 'all bits are sound' - i.e. 2**soundRopeCharDivisions-1
All INTs are values in samples, as for the rest of this interface. lasts=-1 indicates that there are no silence intervals in the list of lengthGreaterThan that specified.
Utilities
 
Head is assumed non-nil.
Initialization

stand back - this is the dangerous bit . . .
Swinehart, April 8, 1987 11:59:57 am PDT
Cedar 7.  Merge many files.
changes to: DIRECTORY, VoiceViewersImpl, voiceViewerMenu, CreateVoiceViewerMenu, SetViewerContents, ViewerTools, SetParentViewer, IF, {, SaveVoice, DestroyVoiceInfo, RedrawViewer, ChangeColumnEvent, }, END

�Ê �˜š
œ™Icode™<K™ ™'K™——š
Ïk	˜	Jšœ
�œ˜(Kšœ�œ˜Kš�œ
�œ˜Kšœ�œ˜ Kšœ�œ<˜GKšœ�œ˜+Kšœ�œ�œ)˜9Jšœ�œ˜"Jšœ�œ;˜KJšœ�œT˜hJšœ�œS˜fJšœ�œ˜1Jšœ	�œ˜Jšœ
�œ˜!Kšœ	�œ“
˜¡
Kšœ
�œ1˜CKšœ�œ„˜›Kšœ�œ#˜6Kšœ
�œH˜ZKšœ�œ˜'Kšœ
�œ[˜jKšœ�œ5˜FKšœ
�œE˜TKšœ�œ˜$K˜
—K™KšÏnœ�œ
�œ
�œ�œã
�œ�œ˜ÔK˜š
Ðbl
™
K˜šœ�œ˜#K˜—šžœ�œ˜Kš
œ%˜%Kš
œ‹
˜‹
Kš
œ�
˜�
Kš
œŠ
˜Š
Kš
œw˜wKš
œy˜yKš
œ„
˜„
Kš
œ‹
˜‹
Kš
œ–
˜–
Kš
œœ
˜œ
Kš
œj˜j˜K˜——šœ�œ%�œ
˜DK™—šžœ�œ
�œ˜Kšœ�œ�œ�œ�œ]�œ˜­
K˜%Kš
œ ˜ š
œ˜š
œZ˜ZJš
œ>˜>Jšœ	�˜š
œ™Jš
œ˜——Jšœ�œ˜
—Jšœ�œ
˜J™š
œ'˜'J˜—Jš
œ8˜8J˜J˜)J˜Jš
œ+˜+J™Jšœ€
�œ˜†
Jšœ‰
�œ˜�
J˜Jš
œH˜HJ˜J˜š
œ˜J˜——šžœ�œ
�œ˜ Jšœ[�œ�œ�œ˜‘
Jšœ,�œ$˜SJš
œ#˜#Jšœ�œ
˜J˜Jš�œ�œ
�œ
˜šœÏc9˜<JšœX�œ3˜Ž
JšœC�œ:˜€
Jš
œo˜oJš
œm˜mJš
œJ˜JJšœ�œ�œ�œ�œ�œ
˜s—J˜
Jš�œ
˜š
œ!˜!Jšœ�œ˜&—˜J˜—Jš
œ5˜5J˜Jš
œ ˜ Jš
œ(˜(Jš
œ˜Jš
œ˜J˜Jš
œ]˜]Jš
�œ�œ
�œ=�œ)�œ5˜·
J™J™NJš
�œ�œ
�œB�œ�œ˜J˜J˜Jšœ'�œ r˜ž
˜J˜——šž
œ�œ#˜6J™“
šžœ�œ˜Jšœ0�œS˜‰
Jšœ9�œ
˜?Kšœ'�œ˜.—K˜K˜Kš
œ,˜,˜K˜——šžœ�œ
�œ˜'Kš
œ!˜!K™Óšžœ�œ˜Jšœ0�œS˜‰
Jš�œ'�œ
˜.š
œ)˜)Jš�œ�œ�œ˜3Jšœ'�œ˜.—J˜
—K˜Kš
œ,˜,˜J˜——šžœ�œ
�œ˜Jš
œ˜Jš
œ'˜'Jš
œ/˜/Jš
œ.˜.š
œ˜J˜——šžœ�œ
�œ�œ˜7š�œQ�œ�œ
�˜gJš�œ"�œ�œ�œ
˜J—Jš
�˜˜J˜——šžœ�œ
�œ˜%Jš
œ5˜5Jš
œD˜DJšœ�œ'˜:J˜Jš�œ�œ
˜Jš�œ
˜š
œ"˜"Jš
œ$˜$Jš
�˜—J˜J˜Jš�œ&�˜,š
œ"˜"Jš
œ0˜0Jš
œ$˜$Jš
�˜—J˜J˜š
�˜Jš�œ�œ�œB˜eJš
�˜š
œ<˜<Jš
œ3˜3Jš
œ'˜'Jš
�˜—J˜Jš
œ#˜#—Jš
�˜˜J˜——šž
œ˜J™4Jšœ0�œ�œ@˜‘
Jš
œ@˜@Jš
œA˜AJš�œ4˜6Jš�œ
˜šœ�œ
˜!Jš�œ�œ
�œ\˜y—J˜
˜J˜——šž	œ˜Jšœ�œ	˜.Jšœ0�œS˜‰
J˜Jš�œ�˜šœ6�œ˜<Jš
�˜—J˜J˜Jš�œ�œ
�˜%šœB�œ˜HJ˜Jš
�˜—J˜J˜Jš�œ×
�˜Ý
˜JšœW�œ˜]J˜Jš
�˜—J˜J˜Jš
œ˜J˜J˜—šžœ�œ˜Jš
œ2˜2Jš�œ�œ
�œ
�œ
˜(Jš�œ"˜$Jš�œ-˜1Jš
�˜š
œJ˜JJš
œN˜Nš
�˜Jš�œ�œ
�œ
�œ
˜Jš�œ˜Jš�œ
˜š
œ6˜6Jš
�˜—J˜Jš
œ˜Jš
œ˜—Jš
�˜—J˜
˜J˜——šžœ�œ˜TJ˜—šžœ�œ˜Jšœ�œ	�œ�œ˜AJšœ0�œS˜‰
J˜Jš�œ3�œ
˜:šœT�œ˜ZJš
œ˜Jš�œ�œ
˜—J˜J˜J™6J˜Jš�œ�œ�œ�œ*�œ!�œu˜‹J˜Jš
œ"˜"Jš
œC˜CJš
œM˜MJ˜J˜
—šžœ˜(Jšœ�œ	˜.Jšœ0�œS˜‰
Jš�œ˜Jš�œ
˜šœ�œ6˜OJšœW�œ
˜iJš
œ!˜!Jšœ�˜!—Jš
œ
˜
š
œ˜J˜——šžœ˜-Jšœ0�œS˜‰
Jš�œ,�˜2š
œ,˜,Jš�œ˜Jš�œ
˜šœ�œ6˜OJšœW�œ
˜iJš
œ!˜!Jšœ�˜!—Jš
œ
˜
Jš
�˜šœ“
�œ˜™
J˜—J˜
—J˜
˜J˜——šžœ�œ
�œ
�œ˜!Jšœ)�œ	�œ˜EJš
œ˜Jš�œ˜Jš�œI�œ
˜RJš�œ�œ
˜ ˜J˜—J˜——š
Ÿ™J™J™_™(J™LJš
œ‹
™‹
š
œÜ™ÜJ™——š
œ‰™‰J™—šžœ˜/Jš�œ/�œ
˜5Jš�œ) ˜LJš�œ
˜šœ �œ
�œ
�œ
�œ�œ
˜6š�œ�œ
�œ
�œ
�œ�œ�œ
�˜Lš�œ�œ
�˜Kšœ�œ
�œ˜šœ�œ�œ
�œ
˜š
œ/˜/Kšœ
�˜—K˜Kš
œ4˜4—K˜Kšœ�œ˜šœ�œ�œ
�œ
˜š
œ/˜/Kšœ
�˜—K˜Kš
œ$˜$—K˜Kšœ�œ
�œ˜šœ�œ�œ
�œ
˜š
œ/˜/Kšœ
�˜—K˜Kš
œ6˜6—K˜š�œ˜Kš�œ�œ
˜Kš�œ
˜šœ�œ�œ˜*Kš
œ˜—K˜
Kš�œ
˜šœ�œ�œ˜4Kš
œ&˜&—K˜
———Kš�œ
˜Kš�œ�œ
�œ-˜E—K˜
˜J˜——šžœ˜.Jš�œ�œ
�œ
˜&Jš
œ$˜$Jš�œ�œ
˜˜J˜——šžœ˜-Jš�œ�œ
�œ
˜&Jš
œ#˜#Jš�œ�œ
˜˜J˜——šžœ˜+Jš�œ˜Jš�œ!˜%Jš
�˜š
œ˜Jš�œ�œ
˜—J˜˜J˜——šž
œ˜*Jš
œ¼™¼Jšœ�œ
˜š�œ�œ
�œ˜*Kš	�œ�œ
�œ�œ
 ˜mKšœ
�œ˜—š�œ
�œ �œ˜-Kšœ
�œ-�œ˜F—Kš	�œ
�œ�œ
�œ�˜@š�œ˜šžœ�œ˜šœ�œ�˜:K˜K˜K˜Kš�œ�œ˜——Kšœ
�œ
˜š�œ�˜ Kšœ�œ
˜#˜Kš
œ$˜$Kš
œ!˜!Kš
œ˜Kš�œ�˜%˜	Kš�œ#�œ!˜JK˜—K˜!K˜#Kš�œ�œ˜—˜Kš
œ$˜$Kš
œ#˜#K˜Kš�œ�˜%˜	Kš�œ#�œ!˜JK˜—K˜#K˜%Kš�œ�œ˜—˜Kš
œ$˜$Kš
œ˜K˜Kš�œ�˜%K˜K˜K˜!Kš�œ�œ˜—Kš�œ�œ˜——Kš
œ?˜?Kšœ8�œ@˜}Kšœ! ˜<Kš�œ�œ
�œ˜?Kšœ�œ˜#K˜—šœ�œ9˜MK˜—šžœ�œ
�œ˜8Kšœ�œP�œ
�˜bKš
œ�œR�œ
�œ�œ�˜„
Kš	œ�œR�œ
�œ�œ˜|˜K˜——šœ
�œ˜$K˜—šžœ�œ
�œ˜1Kš	œ�œP�œ
�œ�œ˜t˜K˜——šžœ�œ�œ�œ˜1Kš
œ°™°š�œ�˜Kš
œ
˜
š
œ$˜$Kš
œ"˜"—Kš
œ˜K˜—Kš
�˜˜K˜——šž	œ�œ2˜Aš�œ�˜Kš
œ)˜)Kš
œ˜Kš�œ$˜+—˜K˜——šžœ�œ2˜Gš�œ�˜Kš
œ/˜/Kš
œ/˜/Kš�œ+˜2—˜K˜——šžœ�œ2˜Fš�œ�˜Kš
œ.˜.Kš
œ.˜.Kš�œ*˜1—˜K˜——šžœ�œ2˜Fš�œ�˜Kš
œ.˜.Kš
œ˜Kš�œ)˜0—˜K˜——šžœ�œ2˜Lš�œ�˜Kš
œ4˜4Kš
œ4˜4Kš�œ0˜7—˜K˜——šžœ�œ2˜Kš�œ�˜Kš
œ3˜3Kš
œ3˜3Kš�œ/˜6—˜K˜——Kš
œS˜Sš
œF˜FK˜—šž
œ˜(J™)Jš
œS˜SJš
œ,˜,Jš
œ6˜6Jš
œ6˜6Jš
œ1˜1Jš
œ.˜.J˜—J˜—š
Ÿ™J™™‹
J™—šžœ�œ ˜<J˜—š
žœ�œ
�œ�œ�œ˜HJš	œ�œ9�œ�œ�œ˜ƒ
Jš
œ˜˜J˜——šžœ�œ
�œ˜ Jšœ1�œ�œ3�œ
�œc�œ˜ŒJš
œË™Ë™ØJš
œ$˜$Jšœ�œ
˜!Jš
œ#˜#Jšœ�œ!˜0J˜J˜Jš
œž
˜ž
Jšœ�œ]˜Jš
œx˜xJš�œ�œ
�œ)˜RJš
œ&˜&J˜Jš
œC™CJ™oJ˜
JšœŽ
�œ
�œ�œb˜ŠJ˜Jš�œn�œ
�œ)˜£
J˜Jš�œ�œ
˜šœ�œO˜eJš
œM˜MJš
œM˜MJšœM ]˜ª
—J˜J˜Jš�œ�œ˜#Jš�œ
˜š
œ˜Jš�œ�œ]˜qJš
œ!˜!—J˜
—š
œ˜J˜——šž!œ�œ
�œ˜0Jš	œg�œ�œ�œ$�œ˜»
J™Þ
J™ÍJš
œâ™âJ™Ó
™Jšœ�œ
˜Jšœ�œ
˜"J˜Jš
�œ#�œ�œ
�œ
�œ
˜IJ˜Jšœ®
�œ�œ
�œ
�œ
�œ˜ì
J˜Jš
œU˜UJš
œR˜RJš	œ�œ�œ
�œ�œI˜yJš
œ3™3Jš
œ9˜9J˜Jš
œu˜uJš
œu˜uJš
œa˜aJ˜Jš
œ‚
˜‚
Jš
œy˜yJ™GJ™Jš	œª
�œ�œ�œ�œ
˜ç
Jš
œE™EJšœä
ž!œ™•J™Jš
œT˜TJš�œ˜Jš�œ
˜šœJ�œ˜PJš
œ)˜)J™V—J˜
Jš
�˜š
œ˜Jšœg�œ˜
�œ�œ
�œ
�œ
�œ
�œ=˜ç—J˜
—˜Jš
œ™——šžœ�œ
�œ˜™Jšœ�œ
˜Jšœ�œ
˜Jšœ�œ˜Jš
œ'˜'Jšœa�œ�œ˜ƒ
Jš
œ˜J˜Jšœ#�œ
˜(JšœŽ
�œ�œ˜¨
Jš�œ�œ
˜š
œ˜JšœN�œg˜¸
Jš
œ0˜0—Jš
œ˜—˜J˜——šžœ�œ
�œ2˜CJš
œ<˜<Jš
œ0˜0J˜J˜Jšœ�œ˜J™Æ
J˜Jšœq�œ�œ�œ�œ�œ˜Ð
J˜˜
JšœP�œ�œ	�œ�œ�œ/˜Ý
Jš
œN˜N—J˜J™Jš
œ"˜"Jš
œ$˜$Jš
œŸ™ŸJ™J˜Jšœ'�œ
˜,J˜Jš�œ(˜*J™EJš
�˜šœ,�œ
˜1Jš�œ/ ˜OJš
�˜š
œ˜Jš�œÖ
˜Ø
J™Ù
Jš
ϡ
™°
Jš
�˜šœ�œ$˜6Jšœ
�œ�œK˜aJšœ
�œM˜]Jšœ�œ�œ–
˜­
J˜Jš
œ0˜0Jš
œ2˜2Jš
œ/˜/Jš
œ1˜1Jšœ�˜—J˜J˜Jš�œE�œ7˜‚
—Jš
œ˜J˜Jšœ7�œ�œ…
˜Æ
—J˜
Jš
œ˜Jš
œo˜oJ˜J˜Jš
œW˜WJšœF�œ˜LJš
œ4˜4˜J˜——šž	œ�œ
�œ2˜HJš�œ�œ
�œ
˜ Jš
œ2˜2J˜Jš
œ6˜6˜J˜——šžœ�œ˜Jš
œ5˜5Jš�œ/�œ%˜ZJš
œJ˜JJš�œ1�œ%˜\Jš
œ0˜0J˜—J˜—š
Ÿ	™	J™™‡
J™—šžœ�œ
�œ˜)Jšœ>�œ�œ+�œ˜}Jšœ�œ˜š�œ4�œ�œ
�˜GJš
œS˜SJš
œ-˜-—Jš�œ
˜Jš�œ%�œK˜v˜J˜——šžœ�œ
�œ˜Jš
œg˜gJš
œÐ
™Ð
Jšœ
�œ$˜4Jšœ�œ3˜AJšœ�œ˜Jšœ�œ
˜J˜š	�œD�œ�œ
�œ�˜oJš
œ˜Jš
œ˜Jš
œ˜Jš
œ.˜.Jš�œ�œ
˜šœ�œ˜Jš�œ
˜šœ�œ(˜FJšœ�œ%˜D—J˜Jš�œ˜Jš�œ
˜šœ�œ"˜DJšœ�œ ˜;—J˜Jš
œC˜C—J˜
—Jš
�˜˜J˜——šžœ�œ
�œ˜Jšœ>�œ
�œ/˜€
Jš
œ—
™—
Jš
œ.˜.Jšœ�œ˜&Jš�œ˜š�œ˜Jš
œ!˜!Jšœ�˜—šœ�œ˜Jš�œ9�˜>š
œ“
™“
Jš
œP˜PJš�œ�œ
�˜%—Jš�œ
˜Jš
œ˜Jšœ�œ
˜J˜Jš�œ�œ
 /˜Ošœ�œ�œ3˜NJšœ
�œ�œ1˜GJšœ�œ%˜0Jš
œD˜DJš
œ=˜=—J˜
—˜J˜—Jš
œd™dšœ�˜Jš
œ˜Jš�œ�œ
�œ
˜(Jš
œD˜DJš�œ�œ
�œ
˜&Jš
œ˜—Jš�œ
˜J˜Jš�œ�œ
 4˜Wšœ�œ�œ.˜HJšœ
�œ�œ,˜BJš
œ#˜#Jš
œ˜—J˜J˜J™$Jš�œ�œ
�œ�œ/˜`Jš�œ�œ
�œ)�œC˜—
š
œ˜J˜——šž
œ�œ
�œ˜Jšœ:�œ�œ�œ�œ�œ˜yJš
œˆ™ˆJ˜>Jšœ�œ�œ
˜!Jš
œ?˜?Jšœ�œ/�œ
�œ
˜NJš
œR˜RJšœ
�œ˜ Jšœ
�œ3˜CJ˜šžœ�œ
�œ	�œ˜0J˜š
ž
œ�œ�œ	�œ�œ>˜�
Jšœ�œ
˜Jšœ�œK˜\J˜2Jš�œ�œ1˜>Jš�œ9˜;Jš
�˜š
œ[˜[J˜J˜J˜Jš�œ7˜9Jš
�˜Jšœ�œ˜˜J˜Jšœ�œ
˜š�œ�œ
�œ/�˜>Jšœ!�œ�œ�œ˜C—Jš�œ
˜Jšœ+�œ�œ�œ ©
˜‹—J˜
—J˜
—J˜š�œ�œ
�˜%Jšœ�œ ˜*Jš
œ˜—Jš�œ
˜J˜š�œ1�˜8Jšœ+�œ�œ�œ˜MJš
œF™FJš
œ7˜7—Jš�œ
˜J˜š�œ
�˜Jšœ�œ ˜*Jš
œ˜—Jš
�˜—J˜J˜š�œ4�œ�œ
�˜GJšœ	�œ˜Jšœ�œ˜Jš�œ	˜Jš
�˜šœ�œ˜Jš
�˜š
œ#˜#Jšœ�œ
˜Jšœ!�œ˜(Jšœ�œ
˜$—J˜
Jš
�˜š
œ'˜'š�œ˜Jš
�˜š
œ˜Jšœ�œ
˜Jšœ�œ
˜$—J˜
Jš�œ#˜'——J˜
—J˜
Jš
�˜šœ$�œ˜+Jšœ�œ
˜$—J˜
—Jš�œ
˜Jšœ
�œ�œD�œ˜lJš
œ]˜]˜Jš
œ
˜
——šžœ�œ
�œ˜%Jš	œ;�œ�œ�œ	�œ
˜pKš
ϻ
™ª
Kš
œ+˜+Kšœ�œ˜š�œ�œ
�˜Kš�œ%�˜+š
œ˜Kš
œ˜—K˜Kš
œF˜FK˜
—Kš
�˜˜K˜——™	J™
—šžœ�œ˜JšœC�œ"˜lJšœ.�œ�œ˜?Jš
œ1˜1Jš�œ�œ
�œ
�œ˜+Jš�œ�œ
�œ"�œ
˜JJ˜#Jš�œ˜
˜J˜——šžœ�œ˜"Jš
œS˜SJšœ.�œ�œ˜?Jš
œD˜DJš�œ�œ
�œ,�œ˜OJš�œ�œ
�œ"�œ
˜JJ˜"˜J˜——šžœ�œ˜"Jš
œ,˜,J™Jš
œ1˜1Jš�œ�œ
�œ
�œ
˜Jš�œ�œ
�œ"�œ
˜JJš�œ�œ�œ
 ˜^š
œJ˜JJš
œM˜MJ˜—J˜Jš
œ˜˜J˜——J˜—š
Ÿ™J™J˜Kš
œr˜rJ˜Jš
œ4˜4Jš
œ2˜2Jš
œ.˜.Jš
œ,˜,J˜J™,Jš
œ/˜/J˜—Jš
œ˜J˜™(K™KšœÏrÁ
™Í
—K™—…—“~Ók