--Author: John Maxwell
--last modified: December 15, 1981  4:15 PM

DIRECTORY
   Beam USING [Height,InVoice],
   MusicDefs,
   Note USING [Delete,Delta,FindChord],
   Piece USING [CleanUpSyncs, Length, RemoveSync],
   Real USING [FixI],
   Score USING [GetKey, ShowPitch],
   Sheet USING [FindLine, FindSection, Height, NearestTime, NextLine],
   Sync USING [GetScoreIndex, Octava],
   Utility USING [FreeSync];

PieceImplA: PROGRAM
  IMPORTS Beam, MusicDefs, Note, Piece, Real, Score, Sheet, Sync, Utility
  EXPORTS MusicDefs, Piece =

BEGIN
OPEN MusicDefs;

dataStructureInFlux:PUBLIC BOOLEAN _ FALSE;

--****************************************************************************
--data abstractions for a piece
--CONSTRAINT: piece[i-1].time <= piece[i].time <= piece[i+1].time
--CONSTRAINT: piece[i]#NIL for all i such that 0 <= i < pieceLength
--CONSTRAINT: piece[pieceLength]=NIL
--CONSTRAINT: a sync may be entered at most one time
--****************************************************************************

AddSync:PUBLIC PROCEDURE[p:PiecePTR,s:SyncPTR] =
BEGIN
--any procedure that inserts syncs should process syncs in decreasing order
length:CARDINAL=Piece.Length[p];
IF s=NIL THEN RETURN;
--check for overflow
IF p=score AND length+1=maxScoreLength THEN Overflow[score];
IF p#score AND length+1=maxPieceLength THEN Overflow[piece];
--insert sync
IF p=score THEN dataStructureInFlux_TRUE;
FOR i:CARDINAL DECREASING IN [0..length) DO
	IF p[i]=NIL THEN LOOP;
	IF p[i].time < s.time THEN {p[i+1]_s; s_NIL; EXIT};
	IF p[i].time = s.time AND ~LessThan[s.type,p[i].type] 
		THEN {p[i+1]_s; s_NIL; EXIT};
	p[i+1] _ p[i];
	ENDLOOP;
IF s#NIL THEN p[0] _ s;
IF p=score THEN scoreLength _ scoreLength+1;
IF p=score THEN dataStructureInFlux_FALSE;
END;

LessThan:PROCEDURE[a,b:EventType] RETURNS[BOOLEAN] = INLINE
BEGIN
SELECT TRUE FROM
	a=staves => RETURN[TRUE];
	b=staves => RETURN[FALSE];
	a=keySignature => RETURN[TRUE];
	b=keySignature => RETURN[FALSE];
	Measure[a] => RETURN[TRUE];
	Measure[b] => RETURN[FALSE];
	a=metrenome => RETURN[TRUE];
	b=metrenome => RETURN[FALSE];
	a=timeSignature => RETURN[TRUE];
	b=timeSignature => RETURN[FALSE];
	a IN SheetSwitch => RETURN[TRUE];
	b IN SheetSwitch => RETURN[FALSE];
	ENDCASE => RETURN[TRUE];
END;
	
	
RemoveSync:PUBLIC PROCEDURE[p:PiecePTR,s:SyncPTR] =
BEGIN
--DOES NOT free notes or itself!
--any procedure that removes syncs should process syncs in decreasing order
i,j:CARDINAL_0;
length:CARDINAL_Piece.Length[p];
FOR i IN [0..length) DO
	IF p[i]=s THEN LOOP;
	IF i#j THEN p[j] _ p[i];
	j _ j+1; ENDLOOP;
FOR i IN [0..syncLength) DO 
    IF s.event[i]=NIL THEN EXIT;
    s.event[i].sync _ NIL;
    ENDLOOP;
length _ j;
p[length] _ NIL;
IF p=score THEN scoreLength_length;
END;

DeleteSync:PUBLIC PROCEDURE[s:SyncPTR] =
BEGIN
octava:SyncPTR _ NIL;
index:CARDINAL_Sync.GetScoreIndex[s];
IF s.type IN [octava1..octava2] THEN octava _ Sync.Octava[s];
Piece.RemoveSync[score,s];
IF octava#NIL THEN {
	SetDirty[octava.time,octava.time];
	Piece.RemoveSync[score,octava];
	Utility.FreeSync[@octava]};
Utility.FreeSync[@s];
END;

Sort:PUBLIC PROCEDURE[p:PiecePTR] =
--useful when going from physical to logical files 
BEGIN
i,j:CARDINAL;
temp:SyncPTR;
length:CARDINAL = Piece.Length[p];
FOR i IN [0..length) DO
    FOR j IN (i..length) DO
	IF p[j] = NIL THEN LOOP;
	IF p[i] = NIL THEN {p[i]_p[j]; p[j]_NIL; LOOP};
	IF p[i].time > p[j].time THEN {temp_p[i]; p[i]_p[j]; p[j]_temp};
	IF p[i].time= p[j].time THEN 
	   {IF p[i].event[0]=NIL OR p[j].event[0]=NIL THEN LOOP;
	    IF p[i].event[0].toc<p[j].event[0].toc THEN LOOP;
	    temp_p[i]; p[i]_p[j]; p[j]_temp};
        ENDLOOP;
    ENDLOOP;
END;

CleanUpSyncs:PUBLIC PROCEDURE[p:PiecePTR] =
BEGIN
next:CARDINAL _ 0;
length:CARDINAL _ Piece.Length[p];
FOR i:CARDINAL IN [0..length) DO
	IF p[i].type=notes AND p[i].event[0]=NIL 
		THEN Utility.FreeSync[@p[i]]
		ELSE {p[next] _ p[i]; next _ next+1};
	ENDLOOP;
FOR i:CARDINAL IN [next..length) DO p[i]_NIL; ENDLOOP;
IF p = score THEN scoreLength_next;
END;

CleanUpNotes:PUBLIC PROCEDURE[p:PiecePTR] =
BEGIN
i,j:CARDINAL;
n:NotePTR;
FOR i DECREASING IN [0..Piece.Length[p]) DO
    IF p[i].type#notes THEN LOOP;
    FOR j DECREASING IN [0..syncLength) DO
        IF p[i]=NIL THEN LOOP;
	IF (n_p[i].event[j])=NIL THEN LOOP;
	IF n.value#unknown THEN LOOP;
	IF n.duration#0 THEN LOOP;
	Note.Delete[n,TRUE];
	ENDLOOP;
    ENDLOOP;
Piece.CleanUpSyncs[p];
END;

--****************************************************************************
--what is being pointed at?
--****************************************************************************

NearestSync:PUBLIC PROCEDURE[p:PiecePTR,t:Time,notesOnly:BOOLEAN_FALSE] RETURNS[index:CARDINAL]=
BEGIN
delta:Time _ 10000;
length:CARDINAL = Piece.Length[p];
index _ 0;
FOR binary:CARDINAL_8192, binary/2 UNTIL binary=0 DO
      IF index+binary>=length THEN LOOP;
      IF p[index+binary].time<=t THEN index_index+binary;
      IF p[index].time=t THEN EXIT;
      ENDLOOP;
--the above will fail when the p isn't strictly ordered
FOR i:CARDINAL IN [(IF index<5 THEN 0 ELSE index-5)..MIN[index+5,length]) DO
      IF notesOnly AND p[i].type#notes THEN LOOP;
      IF ABS[p[i].time-t] > delta THEN LOOP;
      index _ i; delta _ ABS[p[i].time-t];
      ENDLOOP;
IF notesOnly AND index#length AND p[index].type#notes THEN index_length;
END;

NearestNote:PUBLIC PROCEDURE[x,y:INTEGER] RETURNS[p:NotePTR] =
BEGIN
n:NotePTR;
key:INTEGER;
time,dt,t:Time_11;
i,j,k,l,next:CARDINAL;
height,dy,show:INTEGER_8; 
[time,height] _ Sheet.NearestTime[x,y];
next _ Sheet.FindLine[time];
time _ time - (staffLength - sheet[next].x);
l _ Sheet.FindLine[time]; 
height _ height + (sheet[next].y - sheet[l].y);
FOR k IN [0..2] DO
	FOR i IN [0..scoreLength) DO
		IF score[i].time< time - 40 THEN LOOP;
		IF score[i].time> time + 40 THEN EXIT;
		IF score[i].time<sheet[l].time THEN LOOP;
		IF score[i].time>=sheet[next].time THEN EXIT;
		FOR j IN [0..syncLength) DO
			IF (n_score[i].event[j]) = NIL THEN EXIT;
			IF voice AND n.voice#selectedVoice THEN LOOP;
			t _ ABS[score[i].time+5+Note.Delta[n]-time];
			key _ Score.GetKey[n.sync.time];
			show _ Score.ShowPitch[n.pitch,n.spelled,key];
			y _ ABS[height-Sheet.Height[n.sync.time,show,n.staff]];
			IF y+t>dy+dt THEN LOOP;
			IF y+t=dy+dt AND t>dt THEN LOOP;
			dt _ t; dy _ y;
			p _ n;
			ENDLOOP;
		ENDLOOP;
	time _ time+ (staffLength - sheet[next].x);
	height _ height- (sheet[next].y - sheet[l].y);
	l _ next;
	next _ Sheet.NextLine[l];
	ENDLOOP;
IF dt>10 OR dy>7 THEN p_NIL;
END;

NearestObject:PUBLIC PROCEDURE[x,y:INTEGER] RETURNS[obj:ObjectType,p:UnspecifiedPTR_NIL] =
BEGIN
n:NotePTR;
l:CARDINAL;
key:INTEGER;
staves:StavesPTR;
i,j,k,s,next:CARDINAL_0;
time,dt,t:Time _ 11;
height,dy,show:INTEGER _ 8; 
[time,height] _ Sheet.NearestTime[x,y];
next _ Sheet.FindLine[time];
time _ time - (staffLength - sheet[next].x);
l _ Sheet.FindLine[time]; 
height _ height + (sheet[next].y - sheet[l].y);
FOR k IN [0..2] DO
--left and right corners of a beam
FOR i IN [0..beamHeapLength) DO
    IF beamHeap[i].beam#NIL AND beamHeap[i].beam.beamed THEN LOOP;
    IF beamHeap[i].sync1.time-5 > time THEN LOOP; 
	 IF beamHeap[i].sync2.time+5 < time THEN LOOP;
    IF voice AND ~Beam.InVoice[beamHeap[i],selectedVoice] THEN LOOP;
    y _ Beam.Height[beamHeap[i],time];
    IF ABS[y-height]+4 > dt+dy THEN LOOP;
    IF ABS[y-height]+4 = dt+dy THEN IF y>height THEN LOOP;
    dt _ 4; dy _ ABS[y-height];
    IF time < (beamHeap[i].sync1.time+beamHeap[i].sync2.time+4)/2 
	THEN obj _leftBeam 
	ELSE obj _rightBeam;
    p _ beamHeap[i];
    ENDLOOP;
--measure sections, signatures and other events
FOR i IN [s..scoreLength) DO
    IF score[i].time< time - 300 THEN LOOP;
    IF score[i].time> time + 300 THEN {s_i; EXIT};
    IF score[i].time<sheet[l].time THEN LOOP;
    FOR j IN [0..syncLength) DO --ties
		IF (n_score[i].event[j]) = NIL THEN EXIT;
		IF voice AND n.voice#selectedVoice THEN LOOP;
		IF n.tie=NIL THEN LOOP;
		IF n.sync.time<time OR n.tie.sync.time>time THEN LOOP;
		t _ ABS[(n.sync.time+n.tie.sync.time)/2-time];
		key _ Score.GetKey[n.sync.time];
		show _ Score.ShowPitch[n.pitch,n.spelled,key];
		y _ ABS[height-(Sheet.Height[n.sync.time,show,n.staff]+n.tieHeight/2)];
		IF y+t>dy+dt THEN LOOP;
		IF y+t=dy+dt THEN IF t>dt THEN LOOP;
		dt _ t; dy _ y;
		obj _ tie; p _ n;
        ENDLOOP;
    IF score[i].time>=sheet[next].time THEN LOOP;
    IF ABS[score[i].time-time]>40 THEN LOOP;
    IF score[i].type IN SheetSwitch AND score[i].type#staves THEN {
		octava:SyncPTR_NIL;
		staff,top,bottom:INTEGER _ score[i].value;
		t _ score[i].time;
		IF score[i].type=clef THEN t_t+6; 
		IF ABS[t-time]+6> dt + dy THEN LOOP; 
		IF ABS[t-time]+6=dt+dy AND t<time THEN LOOP;
		IF score[i].type=octava2 THEN octava _ Sync.Octava[score[i]];
		IF octava#NIL THEN  staves _ LOOPHOLE[@octava.event]
			ELSE staves _ LOOPHOLE[@score[i].event];
		SELECT staves.staff[staff].pitch FROM
			60,15 => {top_staves.height+5; bottom_staves.height-5};
			ENDCASE => {top_32; bottom_0};   
		IF height>Sheet.Height[score[i].time,,staff]+top THEN LOOP;
		IF height<Sheet.Height[score[i].time,,staff]+bottom THEN LOOP; 
		dt _ ABS[t-time]; dy _ 6;
		p _ score[i];
		obj _ measure;
		LOOP}; 
	IF score[i].type#notes THEN {
		IF ABS[score[i].time-time]+6> dt + dy THEN LOOP; 
		IF ABS[score[i].time-time]+6=dt+dy AND score[i].time<time THEN LOOP;
		IF score[i].type=staves AND score[i].time<1 THEN LOOP; -- don't touch the first one
		staves _ sheet[Sheet.FindSection[score[i].time]].staves; 
		IF height>Sheet.Height[score[i].time,,0]+32 THEN LOOP;
		IF height<Sheet.Height[score[i].time,,staves.sl] THEN LOOP; 
		dt _ ABS[score[i].time-time]; dy _ 6;
		p _ score[i];
		obj _ measure;
		LOOP}; 
	FOR j IN [0..syncLength) DO --notes
		IF (n_score[i].event[j]) = NIL THEN EXIT;
		IF voice AND n.voice#selectedVoice THEN LOOP;
		t _ ABS[score[i].time+5+Note.Delta[n]-time];
		y _ ABS[height-Sheet.Height[n.sync.time,n.pitch,n.staff]];
		IF y+t>dy+dt THEN LOOP;
		IF y+t=dy+dt AND t>dt THEN LOOP;
		dt _ t; dy _ y;
		p _ n; obj _ note;
		ENDLOOP;
    ENDLOOP; -- end of this line, go to next
time _ time+ (staffLength - sheet[next].x);
height _ height- (sheet[next].y - sheet[l].y);
l _ next;
next _ Sheet.NextLine[l];
ENDLOOP;
IF dt>10 OR dy>7 THEN p_NIL;
END;

END..

(0,3810)(1,4445)(2,5080)\560b19B131i5I305b7B48i76I1107b10B50i107I313b10B333b4B32i52I481b12B346b12B572b11B726b11B1171b13B423i33I585i46I204i4I1910i5I328i28I