DIRECTORY
BasicTime USING [GetClockPulses, PulsesToMicroseconds, MicrosecondsToPulses, Pulses],
Jukebox USING [bytesPerMS],
Process USING [Pause, MsecToTicks, Priority, priorityRealTime, SetPriority, Detach],
Rope USING [ROPE, Length],
Menus USING [MenuProc],
MessageWindow USING [Append, Blink],
TiogaOps USING [GetRope, SaveSelA, RestoreSelA, SetSelection, AddLooks, SubtractLooks, ViewerDoc, FirstChild, SelectDocument, SetStyle, SetLooks, GetSelection, SelectPoint, ClearLooks, CancelSelection],
TiogaOpsDefs USING [Ref, Location, SelectionGrain],
VoiceAging USING [AgeAllViewers, ReColorViewer],
VoiceViewers USING [VoiceViewerInfo, SetVoiceViewerEditStatus, soundRopeCharLength, soundRopeCharsPerSecond],
VoiceInText USING [thrushHandle, PlaySelection],
ViewerClasses USING [Viewer],
ViewerOps USING [FetchProp],
ViewerTools USING [TiogaContents, TiogaContentsRec, SetTiogaContents],
VoiceMarkers USING [RedrawTextMarkers],
VoiceRecord USING [RecordingInProgress],
VoiceRope USING [VoiceRope, VoiceRopeInterval, Play, Length],
VoicePlayBack;
VoicePlayBackImpl: CEDAR MONITOR IMPORTS BasicTime, MessageWindow, Process, Rope, TiogaOps, VoiceAging, VoiceViewers, VoiceInText, ViewerOps, ViewerTools, VoiceMarkers, VoiceRecord, VoiceRope EXPORTS VoicePlayBack = BEGIN


playBackState: RECORD
[  running: BOOLEAN _ FALSE, -- is there currently a forked instance of PlayBackProcess ?
queue: LIST OF PlayBackRequest _ NIL,
nextTime: BasicTime.Pulses,  -- time to wake up playBackProcess next
abort: BOOLEAN _ FALSE -- set when a 'stop voice playback' button is hit - playBackProcess will destroy itself next time it wakes up
];

abortCleared: CONDITION; -- signalled by PlayBackProcess when it has acted on an abort 

PlayBackRequest: TYPE = REF PlayBackRequestRec;
PlayBackRequestRec: TYPE = RECORD
[  display: BOOLEAN, -- if not set then there is no displaying to be done 
viewer: ViewerClasses.Viewer,
node: TiogaOpsDefs.Ref, -- the text node is assumed to contain of rope of characters in the
start: INT, -- range [start..end]: this is not checked by PlayBackProcess
end: INT, -- except that if display=FALSE then viewer, node are unused and these
currentPos: INT, -- integers are used only for counting
timeRemnant: INT -- (end-start+1) represents the duration of the rope section in 'whole characters' rounded down: this is the rounding error in voice samples
];

 
cuePriority: Process.Priority = Process.priorityRealTime;
aVeryLongTime: BasicTime.Pulses = BasicTime.MicrosecondsToPulses[300000000];

PlayBackProcess: PROC = {
moreToDo: BOOLEAN;
nextWakeUp: BasicTime.Pulses;

Process.SetPriority[cuePriority]; 
[moreToDo, nextWakeUp] _ PlayBackNext[];

WHILE moreToDo DO
now: BasicTime.Pulses _ BasicTime.GetClockPulses[];
IF nextWakeUp - now < aVeryLongTime -- so as to cope properly with wrap-around

THEN Process.Pause[Process.MsecToTicks[BasicTime.PulsesToMicroseconds[ nextWakeUp-now]/1000]];
[moreToDo, nextWakeUp] _ PlayBackNext[]
ENDLOOP
};

PlayBackNext: ENTRY PROC RETURNS [moreToDo: BOOLEAN _ TRUE, nextWakeUp: BasicTime.Pulses] = {
currRequest: PlayBackRequest _ playBackState.queue.first;

IF playBackState.abort THEN 
{  IF currRequest.display AND currRequest.currentPos>=currRequest.start THEN
{  TiogaOps.SaveSelA[];
TiogaOps.SetSelection[currRequest.viewer, [currRequest.node, MAX[currRequest.start, currRequest.currentPos-1]], [currRequest.node, MIN[currRequest.end, currRequest.currentPos]]];
TiogaOps.AddLooks["v"];
TiogaOps.SubtractLooks["w"];
TiogaOps.RestoreSelA[]
};  -- all that restored any W looks to V looks
playBackState.queue _ NIL;
playBackState.running _ FALSE;
playBackState.abort _ FALSE;
VoiceViewers.SetVoiceViewerEditStatus[currRequest.viewer];
BROADCAST abortCleared;
RETURN [moreToDo: FALSE, nextWakeUp: 0] -- the latter only to satisfy the compiler
};

currRequest.currentPos _ currRequest.currentPos + 1;

IF currRequest.display THEN
{  TiogaOps.SaveSelA[];
IF currRequest.currentPos-2 >= currRequest.start THEN
{  TiogaOps.SetSelection[currRequest.viewer, [currRequest.node, currRequest.currentPos-2], [currRequest.node, currRequest.currentPos-2]];
TiogaOps.AddLooks["v"];
TiogaOps.SubtractLooks["w"]
};
IF currRequest.currentPos <= currRequest.end THEN
{  TiogaOps.SetSelection[currRequest.viewer, [currRequest.node, currRequest.currentPos], [currRequest.node, currRequest.currentPos]];
TiogaOps.AddLooks["w"];
TiogaOps.SubtractLooks["v"]
};
TiogaOps.RestoreSelA[]
}; 

IF currRequest.currentPos < currRequest.end + 2
THEN 
{  playBackState.nextTime _ playBackState.nextTime + BasicTime.MicrosecondsToPulses[(IF currRequest.currentPos = currRequest.end + 1 THEN currRequest.timeRemnant*(1000/Jukebox.bytesPerMS) ELSE 1000000/VoiceViewers.soundRopeCharsPerSecond)];
RETURN[nextWakeUp: playBackState.nextTime]
};

VoiceViewers.SetVoiceViewerEditStatus[currRequest.viewer];
playBackState.queue _ playBackState.queue.rest;
IF playBackState.queue = NIL THEN
{  playBackState.running _ FALSE;
RETURN[moreToDo: FALSE, nextWakeUp: 0]
}
ELSE RETURN [nextWakeUp: playBackState.nextTime] -- will cause PlayBackNext to be called again immediately to colour the first cell of the next sound section
}; 



QueuePlayBackCue: ENTRY PROC [request: PlayBackRequest] = {
WHILE playBackState.running AND playBackState.abort DO WAIT abortCleared ENDLOOP;
IF playBackState.running 
THEN AppendRequest[request]
ELSE
{  p: PROCESS;
playBackState.queue _ CONS[request, NIL];
playBackState.nextTime _ BasicTime.GetClockPulses[];
playBackState.running _ TRUE;
p _ FORK PlayBackProcess[];
TRUSTED {Process.Detach[p]};
}
};

AppendRequest: INTERNAL PROC [request: PlayBackRequest] = {
hangOffPoint: LIST OF PlayBackRequest _ playBackState.queue;
oneElementList: LIST OF PlayBackRequest _ CONS[request, NIL];
WHILE hangOffPoint.rest # NIL DO hangOffPoint _ hangOffPoint.rest ENDLOOP;
hangOffPoint.rest _ oneElementList
};

AbortCues: ENTRY PROC = { IF playBackState.running THEN playBackState.abort _ TRUE };




PlayBackMenuProc: PUBLIC Menus.MenuProc = {
IF VoiceRecord.RecordingInProgress[] THEN
{  MessageWindow.Append["Stop recording before trying to play back", TRUE];
MessageWindow.Blink[];
RETURN
}; 

IF mouseButton = blue -- i.e. right
THEN PlayWholeSlab[NARROW[parent, ViewerClasses.Viewer]]
ELSE
{  viewer: ViewerClasses.Viewer;
start, end: TiogaOpsDefs.Location;
[viewer: viewer, start: start, end: end] _ TiogaOps.GetSelection[];

IF viewer = NIL -- no selection
THEN PlayWholeSlab[NARROW[parent, ViewerClasses.Viewer]]
ELSE
{  IF ViewerOps.FetchProp[viewer, $voiceViewerInfo] # NIL 
THEN
{  IF start.node # end.node THEN ERROR; -- voice viewers only have one display node !!!!
TiogaOps.SelectPoint[viewer, start]; -- leave caret at left of playback selection
PlaySlabSection[viewer, start.node, start.where, end.where] 
}
ELSE VoiceInText.PlaySelection[]
}
}
};
  

PlaySlabSection: PUBLIC PROC [viewer: ViewerClasses.Viewer, node: TiogaOpsDefs.Ref, from, to: INT] = {
viewerInfo: VoiceViewers.VoiceViewerInfo _ NARROW[ViewerOps.FetchProp[viewer, $voiceViewerInfo], VoiceViewers.VoiceViewerInfo];
newRequest: PlayBackRequest;
IF viewerInfo = NIL THEN RETURN; -- somebody's buggering around with the selection
IF node # TiogaOps.FirstChild[TiogaOps.ViewerDoc[viewer]] THEN ERROR;
newRequest _ NEW[PlayBackRequestRec _ [display: TRUE, viewer: viewer, node: node, start: from, end: to, currentPos: from-1, timeRemnant: 0]];

VoiceRope.Play[handle: VoiceInText.thrushHandle, voiceRope: NEW [VoiceRope.VoiceRopeInterval _ [viewerInfo.ropeInterval.ropeID, from*VoiceViewers.soundRopeCharLength, (to-from)*VoiceViewers.soundRopeCharLength]]];
QueuePlayBackCue[newRequest]
};

PlayWholeSlab: PUBLIC PROC [viewer: ViewerClasses.Viewer] = {
viewerInfo: VoiceViewers.VoiceViewerInfo _ NARROW[ViewerOps.FetchProp[viewer, $voiceViewerInfo], VoiceViewers.VoiceViewerInfo];
IF viewerInfo = NIL THEN MessageWindow.Append["Not a voice window or no selection", TRUE]
ELSE
{  node: TiogaOpsDefs.Ref _ TiogaOps.FirstChild[TiogaOps.ViewerDoc[viewer]];
nodeLength: INT _ TiogaOps.GetRope[node].Length;
newRequest: PlayBackRequest _ NEW[PlayBackRequestRec _ [display: TRUE, viewer: viewer, node: node, start: 0, end: nodeLength-1, currentPos: -1, timeRemnant: viewerInfo.remnant]]; 


VoiceRope.Play[handle: VoiceInText.thrushHandle, voiceRope: NEW [VoiceRope.VoiceRopeInterval _ viewerInfo.ropeInterval]];
QueuePlayBackCue[newRequest]
}
};

PlayRopeWithoutCue: PUBLIC PROC [voiceID: Rope.ROPE] = {
fullRope: VoiceRope.VoiceRope _ NEW [VoiceRope.VoiceRopeInterval  _ [voiceID, 0, 0]];
newRequest: PlayBackRequest;
fullRope.length _ VoiceRope.Length[handle: VoiceInText.thrushHandle, vr: fullRope];
IF fullRope.length = 0 THEN RETURN;
IF fullRope.length = -1 THEN
{  MessageWindow.Append["non-existant voice utterance(s) found in selection", TRUE];
RETURN
};

newRequest _ NEW [PlayBackRequestRec _ [display: FALSE, start: 0, end: fullRope.length/VoiceViewers.soundRopeCharLength, currentPos: -1, timeRemnant: fullRope.length MOD VoiceViewers.soundRopeCharLength]];
VoiceRope.Play[handle: VoiceInText.thrushHandle, voiceRope: fullRope];
QueuePlayBackCue[newRequest]
};

PlayBackInProgress: PUBLIC PROC RETURNS [BOOLEAN] = { RETURN [playBackState.running AND ~playBackState.abort] }; -- only a hint: a new playback request may be queued up and wating for the abort to clear before becoming the new playBackState.queue 

CancelPlayBack: PUBLIC PROC = { AbortCues[] };

RemoveViewerReferences: PUBLIC ENTRY PROC [viewer: ViewerClasses.Viewer] RETURNS [okay: BOOLEAN _ TRUE] = {
IF playBackState.queue = NIL THEN RETURN;
IF playBackState.queue.first.display AND playBackState.queue.first.viewer = viewer THEN RETURN [FALSE];
FOR l: LIST OF PlayBackRequest _ playBackState.queue.rest, l.rest WHILE l # NIL DO
IF l.first.viewer = viewer THEN l.first.display _ FALSE
ENDLOOP
};

RedrawViewer: PUBLIC ENTRY PROC [viewer: ViewerClasses.Viewer, newContents: Rope.ROPE, unchangedHead, deleteChars, insertChars: INT, timeRemnant: INT, age: BOOLEAN, selectionsAfterRedraw: VoicePlayBack.SelectionsAfterRedraw] RETURNS [newNode: TiogaOpsDefs.Ref] = {

pViewer, sViewer: ViewerClasses.Viewer;
pStart, pEnd, sStart, sEnd: TiogaOpsDefs.Location;
pLevel, sLevel: TiogaOpsDefs.SelectionGrain;
pCaretBefore, sCaretBefore, pPendingDelete, sPendingDelete: BOOLEAN;

viewercontents: ViewerTools.TiogaContents _ NEW[ViewerTools.TiogaContentsRec _ []]; 
[viewer: pViewer, start: pStart, end: pEnd, level: pLevel, caretBefore: pCaretBefore, pendingDelete: pPendingDelete] _ TiogaOps.GetSelection[primary];
[viewer: sViewer, start: sStart, end: sEnd, level: sLevel, caretBefore: sCaretBefore, pendingDelete: sPendingDelete] _ TiogaOps.GetSelection[secondary];

viewercontents.contents _ newContents;
ViewerTools.SetTiogaContents[viewer, viewercontents];
TiogaOps.SaveSelA[];
TiogaOps.SelectDocument[viewer];
TiogaOps.SetStyle["voiceProfile", root];
TiogaOps.ClearLooks[];
TiogaOps.SetLooks["v"];
TiogaOps.RestoreSelA[];
newNode _ TiogaOps.FirstChild[TiogaOps.ViewerDoc[viewer]];
VoiceMarkers.RedrawTextMarkers[viewer, newNode];
SELECT selectionsAfterRedraw FROM
unAltered =>  -- if the selected character have been edited then we'll try to keep the selection on the same bits of voice
{  lastCharInNode: INT _ (TiogaOps.GetRope[newNode]).Length - 1;
IF pViewer = viewer THEN
{  IF pStart.node # pEnd.node THEN TiogaOps.CancelSelection[primary]
ELSE
{  pStart.node _ pEnd.node _ newNode;
IF pStart.where >= unchangedHead THEN pStart.where _ pStart.where - deleteChars + insertChars;
IF pEnd.where >= unchangedHead THEN pEnd.where _ pEnd.where - deleteChars + insertChars;
IF pStart.where > lastCharInNode THEN pStart.where _ lastCharInNode;
IF pEnd.where > lastCharInNode THEN pEnd.where _ lastCharInNode;
TiogaOps.SetSelection[viewer: pViewer, start: pStart, end: pEnd, level: pLevel, caretBefore: pCaretBefore, pendingDelete: pPendingDelete, which: primary]
}
};
IF sViewer = viewer THEN
{  IF sStart.node # sEnd.node THEN TiogaOps.CancelSelection[secondary]
ELSE
{  sStart.node _ sEnd.node _ newNode;
IF sStart.where >= unchangedHead THEN sStart.where _ sStart.where - deleteChars + insertChars;
IF sEnd.where >= unchangedHead THEN sEnd.where _ sEnd.where - deleteChars + insertChars;
IF sStart.where > lastCharInNode THEN sStart.where _ lastCharInNode;
IF sEnd.where > lastCharInNode THEN sEnd.where _ lastCharInNode;
TiogaOps.SetSelection[viewer: sViewer, start: sStart, end: sEnd, level: sLevel, caretBefore: sCaretBefore, pendingDelete: sPendingDelete, which: secondary]
}
}
};
deSelected =>
{  IF pViewer = viewer THEN TiogaOps.CancelSelection[primary];
IF sViewer = viewer THEN TiogaOps.CancelSelection[secondary]
};
primaryOnInsert =>
{  nodeLength: INT _ (TiogaOps.GetRope[newNode]).Length;
IF sViewer = viewer THEN TiogaOps.CancelSelection[secondary];
IF nodeLength = 0 THEN TiogaOps.CancelSelection[primary] -- in case the viewer is empty 
ELSE
{  pViewer _ viewer;
pStart.node _ pEnd.node _ newNode;
IF insertChars = 0 
THEN -- leave a point selection
{  pStart.where _ pEnd.where _ (IF unchangedHead > nodeLength THEN nodeLength ELSE unchangedHead);
pLevel _ point
}
ELSE
{  pStart.where _ unchangedHead;
pEnd.where _ unchangedHead + insertChars -1;
pLevel _ char
};
pCaretBefore _ pPendingDelete _ FALSE;
TiogaOps.SetSelection[viewer: pViewer, start: pStart, end: pEnd, level: pLevel, caretBefore: pCaretBefore, pendingDelete: pPendingDelete, which: primary]
}
}; 
ENDCASE => ERROR;
IF age AND insertChars # 0 THEN VoiceAging.AgeAllViewers[viewer] ELSE VoiceAging.ReColorViewer[viewer];
IF playBackState.queue # NIL THEN FOR p: LIST OF PlayBackRequest _ playBackState.queue, p.rest WHILE p.rest # NIL DO
currRequest: PlayBackRequest _ p.rest.first;
IF currRequest.display AND currRequest.viewer = viewer THEN
{  currRequest.node _ newNode; -- I've just changed it under your feet!! [okay - monitored]
IF currRequest.end >= unchangedHead -- if not, unaffected by the edit
THEN 
{  newRequests: LIST OF PlayBackRequest _ p.rest.rest;

IF currRequest.end >= unchangedHead + deleteChars THEN -- non-empty third part
{  start: INT _ MAX[ unchangedHead + deleteChars, currRequest.start ] 
+ (insertChars - deleteChars);
end: INT _ currRequest.end + (insertChars - deleteChars);
newRequests _ CONS[ NEW[ PlayBackRequestRec _ [display: TRUE, viewer: viewer, node: newNode, start: start, end: end, currentPos: start-1, timeRemnant: timeRemnant]], newRequests]
};

IF currRequest.start < unchangedHead + deleteChars THEN -- non-empty second part [since request cannot lie entirely in first part - see two IFs back]
{  start: INT _ MAX[unchangedHead, currRequest.start]; 
end: INT _ MIN [unchangedHead + deleteChars - 1, currRequest.end];
newRequests _ CONS[ NEW[ PlayBackRequestRec _ [display: FALSE, start: start, end: end, currentPos: start-1, timeRemnant: 0]], newRequests]
};

IF currRequest.start < unchangedHead THEN -- non-empty first part
{  start: INT _ currRequest.start;
end: INT _ MIN [unchangedHead - 1, currRequest.end];
newRequests _ CONS[ NEW[ PlayBackRequestRec _ [display: TRUE, viewer: viewer, node: newNode, start: start, end: end, currentPos: start-1, timeRemnant: 0]], newRequests]
};

p.rest _ newRequests
}
}
ENDLOOP;


IF playBackState.queue # NIL THEN 
{  currRequest: PlayBackRequest _ playBackState.queue.first;
currentPosFound: BOOLEAN _ FALSE;
IF currRequest.display AND currRequest.viewer = viewer THEN
{  oldCurrentPos: INT _ currRequest.currentPos;
newRequests: LIST OF PlayBackRequest _ playBackState.queue.rest;
currRequest.node _ newNode;
IF currRequest.end >= unchangedHead -- if not, unaffected by the edit [but still will need to put back the playback looks]
THEN 
{  -- one advantage of going backwards through these is that it's easy to stop when we find the one currently being played back
IF currRequest.end >= unchangedHead + deleteChars THEN
{  start: INT _ MAX[ unchangedHead + deleteChars, currRequest.start ] 
+ (insertChars - deleteChars);
end: INT _ currRequest.end + (insertChars - deleteChars);
currentPos: INT _ MAX [ start-1, currRequest.currentPos + (insertChars - deleteChars) ]; 
newRequests _ CONS[ NEW[ PlayBackRequestRec _ [display: TRUE, viewer: viewer, node: newNode, start: start, end: end, currentPos: currentPos, timeRemnant: timeRemnant]], newRequests];
IF currentPos # start-1 THEN currentPosFound _ TRUE
};

IF (~currentPosFound) AND currRequest.start < unchangedHead + deleteChars THEN
{  start: INT _ MAX[unchangedHead, currRequest.start]; 
end: INT _ MIN [unchangedHead + deleteChars - 1, currRequest.end];
currentPos: INT _ MAX [ start-1, currRequest.currentPos]; -- no need to put in a MIN clause since otherwise currentPosFound=TRUE and we'd never have got here
newRequests _ CONS[ NEW[ PlayBackRequestRec _ [display: FALSE, viewer: viewer, node: newNode, start: start, end: end, currentPos: currentPos, timeRemnant: 0]], newRequests];
IF currentPos # start-1 THEN currentPosFound _ TRUE
};

IF (~currentPosFound) AND currRequest.start < unchangedHead THEN
{  start: INT _ currRequest.start;
end: INT _ MIN [unchangedHead - 1, currRequest.end];
currentPos: INT _ currRequest.currentPos;
newRequests _ CONS[ NEW[ PlayBackRequestRec _ [display: TRUE, viewer: viewer, node: newNode, start: start, end: end, currentPos: currentPos, timeRemnant: 0]], newRequests]
};
playBackState.queue _ newRequests
};

IF newRequests.first.display AND newRequests.first.currentPos>=currRequest.start THEN
{  TiogaOps.SaveSelA[];
TiogaOps.SetSelection[newRequests.first.viewer, [newRequests.first.node, MAX[newRequests.first.start, newRequests.first.currentPos-1]], [newRequests.first.node, MIN[newRequests.first.end, newRequests.first.currentPos]]];
TiogaOps.AddLooks["w"];
TiogaOps.SubtractLooks["v"];
TiogaOps.RestoreSelA[]
}
}
}
};  



   

END.
œVoicePlayBackImpl.mesa
routines replay sounds, plus all the guff to move a cue along a slab display
Ades, September 24, 1986 10:21:05 am PDT


see the head of VoicePlayBack.mesa for the raison d'etre of this module
when placed in the playback queue, a request should have currentPos=start-1
requests with end<start should not be queued!!!
 
when a PlayBackRequest is on the head of playBackState.queue and display=TRUE then the characters currentPos and currentPos-1 in the node currentlyhave looks w instead of v, provided in each case that  start<=characterPosition<=end 
the BasicTime ClockPulses wrap around every hour [roughly]. Since we use the clock to time intervals of 250ms, five minutes is indeed aVeryLongTime for the purposes of spotting wrap-around
try to keep this process up to time: however there is compensation for delay in each wake-up by looking at a real time clock; see below

getting down here means the current display is finished: if there is another we will start it, if not kill the process. first make sure the 'edited' status of the viewer is set correctly
-------------------------
the public interface


general playback proc for all viewers: on a right click or if there is no primary selection, if the viewer is a voice viewer then play the whole of it otherwise do nothing; in other cases play all the voice represented in/by [for text/voice viewers] the current selection


called in order to redraw an edited voice viewer, which may or may not be in the queue of viewers in which cues are appearing or are about to appear: newContents is the result of the edit as is timeRemnant, and the three INT arguments refer to the display prior to the edit
all voice viewers will be 'aged' by this call [see VoiceAging for details] unless age=FALSE OR insertChars = 0
because the contents of the viewer are to be completely reset, any selections therein will be upset: how selections are to be affected must always be specified explicitly
these preserve the selection info for reasoning after the redraw
for all I know newNode may actually be the same as the old one, but I don't have any evidence that it is defined to be so. Also possibly the SetStyle and/or SetLooks may be redundant - ditto

now attend to resetting selections:


process any instances of this viewer on the queue [not including the one at the head]
if this PlayBackRequest is part of something that has been edited, we need to split it into up to three sections: the first section is the unedited head of the slab, to be displayed. The second is the spliced out section, which is not to be displayed [but appears to keep the timing correct]. The third is the tail of the slab which is to be displayed: its position in the slab has in general moved. We will assemble these components in reverse order, simply because that's what CONS allows. newRequests was initialised to point to the list of entries beyond the element we are about to replace

**** this and the following section need changing so that the remnant goes in the last of the split parts, as opposed to the third part if it exists
link the new structure into the queue in place of the old one
now we have to go through all that guff again for the head of the queue, except that there is an additional complication: the head of the queue, if being played back, must have the playback looks put back into it. Also the head of the queue must be whichever of the three sections discussed above is currently being played back. Alas we must also remove any character looks corresponding to the cue before this redraw occured
link the new structure into the queue in place of the old head
now redraw the playback cue: beware - the head of the queue might now be a ~display entry
�ÊJ˜š
œ™™LIcode™(K™——š
Ïk	˜	Kšœ
�œF˜UKšœ�œ˜Kšœ�œG˜TKšœ�œ�œ
˜Kšœ�œ˜Kšœ�œ˜$Kšœ	�œ¼
˜Ê
Kšœ
�œ!˜3Kšœ�œ ˜0Kšœ
�œ[˜mKšœ�œ˜0Kšœ�œ
˜Kšœ
�œ
˜Kšœ�œ5˜FKšœ
�œ˜'Kšœ�œ˜(Kšœ
�œ.˜=Kš
œ˜—K™KšÏnœ�œ
�œ
�œ˜
�œ�˜Ý
K˜Kš
œG™GK˜šœ�˜šœ�œ�œÏc<˜YKšœ�œ
�œ�œ
˜%KšœŸ'˜DKšœ�œ�œ
Ÿm˜„
—Kš
œ˜K˜—Kšœ�	œŸ>˜WK˜Kšœ�œ�œ˜/šœ�œ�˜!šœ�œŸ5˜JKš
œ˜KšœŸC˜[Kšœ�œŸ=˜IKšœ�œŸF˜PKšœ�œŸ&˜7Kšœ
�œ
ŸŒ
˜�
—K˜K˜—Kš
œK™KKš
œ/™/Kš
œ
™
š
Ϗ
™è
Kš
œ
˜
—Kš
œ9˜9Kš
œL˜LKš
œ¼
™¼
K˜Kšžœ�œ˜Kšœ
�œ
˜Kš
œ˜˜Kš
œ"˜"Kš
œˆ
™ˆ
Kš
œ(˜(K˜š�œ
�˜Kš
œ3˜3Kš�œ"Ÿ*˜NK˜Kš�œZ˜^Kš
œ'˜'—Kš
�˜—K˜K˜šžœ�œ
�œ
�œ�œ�œ#˜]Kš
œ9˜9—˜Kš�œ�œ
˜šœ�œ�œ+�˜Lš
œ˜Kšœ=�œC�œ,˜²
Kš
œ˜Kš
œ˜Kš
œ˜—KšœŸ+˜/Kšœ�œ
˜Kšœ�œ
˜Kšœ�œ
˜Kš
œ:˜:Kš�	œ˜Kš�œ�œŸ*˜R—K˜K˜Kš
œ4˜4K˜Kš�œ�˜˜Kš�œ/�˜5š
œ‰
˜‰
Kš
œ˜Kš
œ˜—K˜Kš�œ+�˜1š
œ…
˜…
Kš
œ˜Kš
œ˜—K˜Kš
œ˜—Kš
œ˜K˜Kš�œ-˜/Kš�œ
˜šœU�œ.�œ3�œ0˜ð
Kš�œ$˜*—K˜K˜K™º
Kš
œ:˜:Kš
œ/˜/Kš�œ�œ
�˜!šœ�œ
˜!Kš�œ�œ˜&—Kš
œ
˜
Kš�œ
�œ&Ÿl˜�
—Kš
œ˜K˜Kš
œ
˜
šžœ�œ
�œ˜;Kš
�œ�œ�œ
�œ�œ
˜QKš�œ˜Kš�œ˜Kš
�˜šœ�œ
˜Kšœ�œ
�œ˜)Kš
œ4˜4Kšœ�œ
˜Kšœ�œ˜Jš�œ˜—K˜
—K˜K˜šž
œ�œ
�œ˜;Jšœ�œ
�œ'˜<Jš	œ�œ
�œ�œ
�œ˜=Jš�œ�œ
�œ"�œ
˜JJ˜"—J˜K˜Kšž	œ�œ
�œ�œ�œ�œ˜UK˜Kš
œ™K™K™Kšžœ�œ˜+™�Kš�œ#�˜)šœE�œ˜KJ˜Jš
�˜—Jš
œ˜J˜Kš�œŸ
˜#Kš�œ�œ˜8Kš
�˜š
œ ˜ Kš
œ"˜"Kš
œC˜C—˜Kš�œ
�œ
Ÿ˜Kš�œ�œ˜8Kš
�˜šœ�œ1�œ
˜:Kš
�˜šœ�œ�œ
�œŸ0˜XKšœ%Ÿ,˜QKš
œ<˜<—Kš
œ
˜
Kš�œ˜ —K˜
—K˜
—˜Kš
œ˜—K˜šžœ�œ
�œB�œ˜fKšœ+�œN˜Kš
œ˜Kš	�œ�œ
�œ
�œŸ1˜RKš�œ8�œ
�œ
˜EK™Kšœ
�œ �œY˜�
K˜Kšœ<�œ–
˜Õ
Kš
œ˜—K˜K˜šž
œ�œ
�œ#˜=Kšœ+�œN˜Kš�œ�œ
�œ<�œ
˜YKš
�˜š
œL˜LJšœ�œ!˜0Jšœ�œ �œn˜³
J˜J˜Kšœ<�œ:˜yKš
œ˜—K˜
—K˜K˜šžœ�œ
�œ�œ˜8Kšœ �œ2˜UKš
œ˜K™Kš
œS˜SKš�œ�œ
�œ
˜#Kš�œ�˜šœN�œ˜TJš
�˜—Jš
œ˜J˜Kšœ
�œ!�œp�œ$˜Í
Kš
œF˜FKš
œ˜—K˜K˜Kšžœ�œ
�œ
�œ�œ�œ�œŸ†
˜÷
K˜Kšžœ�œ
�œ˜.K˜šžœ�œ
�œ
�œ �œ�œ�œ˜kKš�œ�œ
�œ
�œ
˜)Kš
�œ#�œ+�œ
�œ�œ˜gš�œ�œ
�œ4�œ�œ
�˜RKš�œ�œ�˜7—Kš
�˜—Kš
œ˜K˜Kšžœ�œ
�œ
�œ2�œ+�œ�œ�œ>�œ ˜ˆKšœÂ
�œD™‘K™n™ª
K˜K™@Kš
œ'˜'K˜2Kš
œ,˜,Kšœ<�œ
˜DK˜Kšœ,�œ%˜TKš
œ–
˜–
Kš
œ˜
˜˜
K˜Kš
œ&˜&Kš
œ5˜5K˜Jš
œ ˜ Jš
œ(˜(Jš
œ˜Jš
œ˜Jš
œ˜Kš
œ:˜:Kš
œ0˜0Kš
œ¾
™¾
K™K™#Kš�œ�˜!šœŸl˜zšœ�œ*˜@Kš�œ�˜šœ�œ�œ"˜DKš
�˜š
œ%˜%Kš�œ�œ9˜^Kš�œ�œ5˜XKš�œ�œ˜DKš�œ�œ˜@Kš
Ϫ
˜™
—K˜
—K˜Kš�œ�˜šœ�œ�œ$˜FKš
�˜š
œ%˜%Kš�œ�œ9˜^Kš�œ�œ5˜XKš�œ�œ˜DKš�œ�œ˜@Kš
œ›
˜›
—K˜
—K˜
—K˜—˜
šœ�œ�œ#˜>Kš�œ�œ$˜<—K˜—˜šœ�œ&˜8Kš�œ�œ%˜=Kš�œ�œ#Ÿ˜XKš
�˜š
œ˜Kš
œ"˜"Kš�œ˜Kš�œ
Ÿ˜šœ �œ�œ�œ˜bKš
œ˜—Kš
œ
˜
Kš
�˜š
œ ˜ Kš
œ,˜,Kš
œ
˜
—K˜Kšœ �œ
˜&Kš
Ϫ
˜™
—K˜
—Kš
œ˜—Kš�œ�œ
˜K™Kš�œ�œ�œ"�œ"˜gK™K™Uš�œ�œ
�œ
�œ�œ
�œ/�œ
�œ
�˜tKš
œ,˜,Kš�œ�œ�˜;šœŸ<˜[Kš�œ"Ÿ!˜EKš�œ
˜šœ�œ
�œ˜6Kš
œÒ™ÒK™K™”
K˜Kš�œ0�œ
Ÿ˜Nšœ
�œ�œR˜eKšœ�œ1˜9Kšœ�œ�œ!�œv˜²
—K˜K˜Kš�œ1�œ
Ÿ]˜•
šœ
�œ�œ$˜7Kšœ�œ�œ4˜BKšœ�œ�œ!�œM˜Š
—K˜K˜Kš�œ#�œ
Ÿ˜Ašœ
�œ˜"Kšœ�œ�œ&˜4Kšœ�œ�œ!�œl˜¨
—K˜K˜K™=Kš
œ˜—K˜
—K˜
—Kš�œ
˜K˜K™©K˜Kš�œ�œ
�œ
˜"š
œ<˜<Kšœ�œ�œ
˜!Kš�œ�œ�˜;šœ�œ˜/Kšœ
�œ
�œ,˜@Kš
œ˜Kš�œ"ŸV˜zKš�œ
˜šœŸ|˜Kš�œ0�˜6šœ
�œ�œR˜eKšœ�œ1˜9Kšœ�œ�œD˜YKšœ�œ�œ!�œz˜¶
Kš�œ�œ�˜3—K˜K˜Kš�œ�œ1�˜Nšœ
�œ�œ$˜7Kšœ�œ�œ4˜BKšœ�œ�œ%Ÿc˜�
Kšœ�œ�œ!�œp˜­
Kš�œ�œ�˜3—K˜K˜Kš�œ�œ#�˜@šœ
�œ˜"Kšœ�œ�œ&˜4Kšœ�œ˜)Kšœ�œ�œ!�œo˜«
—K˜K™>Kš
œ!˜!—K˜K˜K™YKš�œ�œ1�˜Uš
œ˜KšœI�œU�œ8˜Ü
Kš
œ˜Kš
œ˜Kš
œ˜—K˜
—K˜
—K˜
—˜˜K˜—K˜—š
œ˜J˜—Jš�œ
˜—…—E c