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

DIRECTORY
	Beam USING [SetStems],
	Graphics USING [DisplayContext, DrawRectangle, GetTexture, MakeFont, MoveTo, Scale, SetLineWidth, SetPaint, SetTexture, Texture, Vec],
	InlineDefs USING [LowHalf],
	MusicDefs,
	Piece USING [AddSync, RemoveSync],
	Score USING [BuildCache, cache, cacheLength, DrawKey, Look],
	Selection USING [AddLine],
	Sheet USING [default, FindLine, FindSection, Map, NextLine, NormalPitch, OctavaHeight, PriorLine, Reset, SetBegin],
	StringDefs USING [AppendDecimal],
	Sync USING [GetScoreIndex, Hidden, SetStave],
	Utility USING [DrawChar, DrawLine, DrawString, NewSync, SetFont];
 
SheetImplA:PROGRAM
  IMPORTS Beam, Graphics, InlineDefs, MusicDefs, Piece, Score, Selection, Sheet, StringDefs, Sync, Utility 
  EXPORTS MusicDefs, Sheet =
BEGIN
OPEN MusicDefs, Score, Sheet;

begin:PUBLIC Time;
endTime:PUBLIC Time;
scale,staffLength:PUBLIC INTEGER;

--****************************************************************************
--the sheet consists of an array of Sections
--****************************************************************************

sheet:PUBLIC ARRAY [0..sheetLength) OF Section;

Initialize:PUBLIC PROCEDURE[dc:Graphics.DisplayContext] =
BEGIN
context _ dc;
music _ Graphics.MakeFont["music"];
text _ Graphics.MakeFont["TimesRoman"];
Utility.SetFont[context,music,8];
style _ ALL[[NIL,0,0,0,[[0,0],[0,0],[0,0],[0,0]]]];
-- pianoroll
style[0] _ [NIL,0,60,3,,]; 
style[0].staff _[[72,-32],[48,-88],[27,-136],[3,-196]];
-- one staff  
style[1] _ [NIL,0,80,3,,];
style[1].staff _[[48,-32],[48,-32],[48,-32],[48,-32]];  
-- two staffs  
style[2] _ [NIL,0,85,3,,];
style[2].staff _[[48,-32],[48,-32],[27,-125],[27,-125]];  
style[12] _ [NIL,0,85,3,,];
style[12].staff _[[48,-32],[48,-32],[27,-150],[27,-150]];
-- three staffs  
style[3] _ [NIL,0,75,3,,];
style[3].staff _[[48,-32],[48,-32],[27,-110],[27,-185]];  
style[13] _ [NIL,0,75,3,,];
style[13].staff _[[48,-32],[48,-32],[27,-130],[27,-220]];  
-- four staffs  
style[4] _ [NIL,0,75,3,,];
style[4].staff _[[48,-32],[48,-110],[27,-185],[27,-260]];  
show _ [,TRUE,TRUE,FALSE,FALSE,TRUE,graphical];
selection _ ALL[NIL];
selectionLength _ 0;
begin _ 0;
scale _ 1;
staffLength _ 550;
TF _ 256;
Score.Look[sheet,,2];
Selection.AddLine[0,0];
END;

Reset:PUBLIC PROCEDURE=
BEGIN
sync:SyncPTR_NIL;
staves:StavesPTR_NIL;
page,pitch:INTEGER_2;
v,j,last,next:CARDINAL_0;
time,break,lastBreak,cacheTime:Time _ 0;
top,height,x,sc,lastHeight:INTEGER _ 0;
Score.BuildCache[];
IF scale=2 THEN sc_3 ELSE sc_2*scale;
[staves,last,next] _ NextStyle[NIL,0,0,100];
IF staves=NIL THEN RETURN;
FOR i:CARDINAL IN [0..cacheLength] DO
	IF i#cacheLength AND cache[i].type NOT IN SheetSwitch THEN LOOP;
	IF i=cacheLength 
		THEN cacheTime_LONG[staffLength]*sheetLength 
		ELSE  cacheTime_cache[i].time;
	WHILE time<cacheTime OR cacheTime=break DO -- fill in all of the sections between
		IF j=sheetLength THEN EXIT;
		sheet[j].page _ 0;
		sheet[j].time _ time;
		IF j#0 AND sheet[j].time=sheet[j-1].time 
			THEN sheet[j].key _ sheet[j-1].key 
			ELSE sheet[j].key _ Key[time,break];
		IF time<break THEN x_x+InlineDefs.LowHalf[time-sheet[j-1].time];
		IF time>=break THEN { -- new line
			height _ height-lastHeight;
			x_ MAX[8,ABS[8*(sheet[j].key)]];
			lastBreak _ break;
			break _ lastBreak+staffLength-x; 
			[staves,last,next] _ NextStyle[staves,last,next,break-20];
			lastHeight _ -staves.staff[staves.sl].y+staves.offset;
			IF top-height>(650*sc)/2 THEN { -- new page
				top _ height; sheet[j].page_page; page_page+1}};
		sheet[j].x _ x;
		sheet[j].y _ height;
		sheet[j].staves _ staves;
		time _ MIN[break,cacheTime];
		j _ j + 1;
		ENDLOOP;
	IF i=cacheLength THEN EXIT;
	IF cache[i].type=staves THEN LOOP;
	Sync.SetStave[staves,cache[i]];
	staves_LOOPHOLE[@cache[i].event];
	IF cache[i].type#clef THEN LOOP;
	IF Sync.Hidden[0,Sync.GetScoreIndex[cache[i]],lastBreak] THEN time_lastBreak;
	ENDLOOP;
IF scale=2 THEN Paginate[];
Sheet.SetBegin[begin];
FOR i:CARDINAL IN [0..beamHeapLength) DO
	IF beamHeap[i].sync2.time<min THEN LOOP;
	IF beamHeap[i].sync1.time>max THEN LOOP; 
	Beam.SetStems[beamHeap[i]]; 
	ENDLOOP; 
END;

NextStyle:PROCEDURE[old:StavesPTR,last,next:CARDINAL, break:Time] RETURNS[StavesPTR,CARDINAL,CARDINAL] = 
BEGIN
temp,new:StavesPTR;
newLast,newNext:CARDINAL_0;
new _ old;
newLast _ last;
newNext _ next;
FOR i:CARDINAL IN [next..cacheLength) DO
	IF cache[i].time>=break+40 THEN EXIT;
	IF cache[i].type#staves THEN LOOP;
	newNext _ i;
	IF cache[i].time>=break THEN EXIT;
	temp _ LOOPHOLE[@cache[i].event];
	IF temp=old THEN LOOP;
	IF new#NIL AND i#next AND new.staff[new.sl].y<temp.staff[temp.sl].y THEN LOOP;
	new _ temp;
	newLast _ i;
	ENDLOOP;
IF newLast=last AND old#NIL THEN RETURN[old,newLast,newNext];
Sync.SetStave[old,cache[newLast]];
RETURN[new,newLast,newNext];
END;

Key:PROCEDURE[time,break:Time] RETURNS[key:INTEGER_0] =
INLINE BEGIN
sync:SyncPTR_NIL;
FOR i:CARDINAL IN [0..cacheLength) DO
	IF cache[i].time>=time+staffLength THEN EXIT;
	IF cache[i].type#keySignature THEN LOOP;
	IF cache[i].time<time THEN {key_cache[i].value; LOOP};
	IF time=break THEN {sync_cache[i]; EXIT};
	ENDLOOP;
IF sync=NIL THEN RETURN;
IF ~Sync.Hidden[0,Sync.GetScoreIndex[sync],break] THEN RETURN;
RETURN[sync.value];
END;

limit:INTEGER_1050;

Paginate:PROCEDURE =
BEGIN
min:INTEGER=75;
start:INTEGER=40;
page:CARDINAL_2;
height:INTEGER_-start;
line,last:CARDINAL_1;
count,first:CARDINAL_0;
FOR line_0,Sheet.NextLine[line] WHILE line#last DO
	height _ height-sheet[line].staves.staff[3].y+min;
	count _ count+1;
	IF height<limit THEN {last_line; LOOP};
	IF count#1 THEN {-- subtract out the last line
		count_count-1;
		height _ height+sheet[line].staves.staff[3].y-min};
	-- layout the page
	LayoutPage[count,first,line,limit+count*min-start-height];
	sheet[line].page _ page;
	page_page+1;
	-- set up for next page
	first_line; line_last;
	count _ 0;
	height _ -start;
	ENDLOOP;
END;

LayoutPage:PROCEDURE[lines,first,last,space:CARDINAL] =
BEGIN
oldHeight,height:INTEGER_sheet[first].y;
-- layout this page
FOR i:CARDINAL IN (first..sheetLength) DO
	IF sheet[i].y#oldHeight THEN {--new line
		IF i>last THEN EXIT;
		oldHeight_sheet[i].y;
		height_sheet[i-1].y+sheet[i-1].staves.staff[3].y;
		height_height-space/lines};
	sheet[i].y_height;
	sheet[i].page_0;
	ENDLOOP;
END;
      
FindLine:PUBLIC PROCEDURE[t:Time] RETURNS[l:INTEGER] = 
BEGIN
start:CARDINAL_0;
FOR i:CARDINAL IN [0..sheetLength-1) DO
	IF sheet[i].time#sheet[i+1].time THEN {start_i; EXIT};
	ENDLOOP;
l _ start;
FOR i:CARDINAL _start, NextLine[i] DO
	IF sheet[i].time<=t THEN l_i ELSE RETURN;
	IF i=sheetLength-1 THEN RETURN;
	ENDLOOP;
END;
      
FindSection:PUBLIC PROCEDURE[t:Time] RETURNS[INTEGER] =
BEGIN
IF t>=sheet[current].time
   THEN BEGIN
  	IF current=sheetLength-1 THEN RETURN[current];
	WHILE t>=sheet[current+1].time DO
	      current _ current+1;
	      IF current=sheetLength-1 THEN RETURN[current];
	      ENDLOOP;
	RETURN[current];
	END
   ELSE BEGIN
	WHILE current#0 AND t<sheet[current].time DO
	      current _ current -1;
	      ENDLOOP;
	RETURN[current];
	END;
END;

current:CARDINAL _ 0;

--****************************************************************************
--procedures that change the staves attributes
--****************************************************************************

SetStyle:PUBLIC PROCEDURE[index:INTEGER,t1,t2:Time] =
BEGIN
old:INTEGER_-1;
temp,sync:SyncPTR_NIL;
endOfScore:Time=EndOfScore[];
IF index NOT IN [0..20] THEN {flash_TRUE; RETURN};
IF style[index].sl=0 THEN {flash_TRUE; RETURN};
SetDirty[begin,endTime];
sync_ NearestMeasure[t1,10];
temp_ NearestMeasure[t2,10];
IF sync#NIL THEN t1 _ sync.time+1;
IF temp#NIL THEN t2 _ temp.time-1;
--get the old style
FOR i:CARDINAL IN [0..cacheLength) DO
	IF cache[i].type#staves THEN LOOP;
	IF cache[i].time>=t1-1 THEN EXIT;
	old _ cache[i].value;
	ENDLOOP;
--change all of the current staves to the new style
FOR i:CARDINAL DECREASING IN [0..cacheLength) DO
	IF cache[i].time>t2 THEN LOOP;
	IF cache[i].time<t1-5 THEN EXIT;
	IF cache[i].type#staves THEN LOOP;
	cache[i].value_index;
	ENDLOOP;
--insert new staves 
IF old#index THEN {
	IF sync#NIL THEN Piece.RemoveSync[score,sync];
	IF sync=NIL THEN {sync_Utility.NewSync[]; sync.time_t1};
	sync.type _ staves;
	sync.value _ index;
	sync.event _ LOOPHOLE[style[index]];
	Piece.AddSync[score,sync]};
IF old#index AND old#-1 AND t2#endOfScore THEN {
	IF temp#NIL THEN Piece.RemoveSync[score,temp];
	IF temp=NIL THEN {temp_Utility.NewSync[]; temp.time_t2};
	temp.type _ staves;
	temp.value _ old;
	temp.event _ LOOPHOLE[style[old]];
	Piece.AddSync[score,temp]};
--reset world
Sheet.Reset[]; 
Sheet.SetBegin[begin];
FOR i:CARDINAL IN [0..beamHeapLength) DO 
	Beam.SetStems[beamHeap[i]]; 
	ENDLOOP;
Selection.AddLine[t1,t2]; 
END;

NearestMeasure:PROCEDURE[time,delta:Time] RETURNS[SyncPTR] =
BEGIN
s:SyncPTR _ NIL;
FOR i:CARDINAL IN [0..scoreLength) DO
	IF score[i].type#measure AND score[i].type#staves THEN LOOP;
	IF ABS[score[i].time-time]>delta THEN LOOP;
	delta _ ABS[score[i].time-time];
	s _ score[i];
	ENDLOOP;
RETURN[s];
END;

style:PUBLIC ARRAY [0..20] OF Staves;

GetStyle:PUBLIC PROCEDURE[time:Time] RETURNS[INTEGER] =
BEGIN
equal:BOOLEAN;
staves:StavesPTR = sheet[Sheet.FindLine[time]].staves;
IF staves=NIL THEN RETURN[-1];
FOR i:CARDINAL IN [0..20] DO
	IF style[i].sl#staves.sl THEN LOOP;
	equal_TRUE;
	FOR j:CARDINAL IN [0..style[i].sl] DO
		IF style[i].staff[j].y#staves.staff[j].y THEN {equal_FALSE; EXIT};
		ENDLOOP;
	IF equal THEN RETURN[i];
	ENDLOOP;
RETURN[-1];
END;

--****************************************************************************
--clefs switches
--****************************************************************************

SetClef:PUBLIC PROCEDURE[pitch,staff:INTEGER,time:Time] =
BEGIN
s:SyncPTR_NIL;
staves:StavesPTR;
--make up a sync
s _ Utility.NewSync[];
staves _ LOOPHOLE[@s.event];
staves^ _ sheet[Sheet.FindSection[time]].staves^;
staves.staff[staff].pitch _ pitch;
s.type _ clef;
s.time _ time;
s.value _ staff;
Piece.AddSync[score,s];
Sheet.Reset[];
END;

DrawClef:PUBLIC PROCEDURE[pitch,staff:INTEGER,time:Time] =
BEGIN
x,y:INTEGER;
l:CARDINAL_Sheet.FindLine[time];
IF time IN (sheet[l].time..sheet[l].time+15] THEN time_sheet[l].time;
[x,y] _ Sheet.Map[time,,staff];
IF sheet[l].time=time THEN x_-21;
Graphics.MoveTo[context,[x,y+16]];
IF voice THEN Graphics.SetTexture[context,light];
SELECT TRUE FROM
	x=-21 AND pitch=27 => Utility.DrawChar[context,121C];
	x=-21 AND pitch=48 => Utility.DrawChar[context,120C];
	pitch=27 => Utility.DrawChar[context,131C];
	pitch=48 => Utility.DrawChar[context,130C];
	ENDCASE;
END;

--****************************************************************************
--octava
--****************************************************************************

SetOctava:PUBLIC PROCEDURE[pitch,staff,height:INTEGER,t1,t2:Time] =
BEGIN
s:SyncPTR_NIL;
current:INTEGER;
section:CARDINAL;
staves:StavesPTR;
normal:INTEGER = Sheet.NormalPitch[staff];
IF t1>=t2 THEN RETURN;
--check to make sure that the staff is clear
FOR i:CARDINAL IN [0..cacheLength) DO
	IF cache[i].time<t1 THEN LOOP;
	IF cache[i].time>t2 THEN EXIT;
	IF cache[i].type NOT IN SheetSwitch THEN LOOP;
	staves _ LOOPHOLE[@cache[i].event];
	current _ staves.staff[staff].pitch;
	IF current=normal THEN LOOP;
	flash _ TRUE; RETURN;
	ENDLOOP;
section _ Sheet.FindSection[t1];
IF sheet[section].staves.staff[staff].pitch#normal THEN {flash_TRUE; RETURN};
--add the first sync
s _ Utility.NewSync[];
staves _ LOOPHOLE[@s.event];
staves^ _ sheet[section].staves^;
staves.staff[staff].pitch _ pitch;
staves.height _ Sheet.OctavaHeight[pitch,height];
s.type _ octava1;
s.time _ t1;
s.value _ staff;
Piece.AddSync[score,s];
--add the second sync
s _ Utility.NewSync[];
staves _ LOOPHOLE[@s.event];
staves^ _ sheet[Sheet.FindSection[t2]].staves^;
staves.staff[staff].pitch _ normal;
s.type _ octava2;
s.time _ t2;
s.value _ staff;
Piece.AddSync[score,s];
Sheet.Reset[];
END;

DrawOctava:PUBLIC PROCEDURE[pitch,staff,height:INTEGER,t1,t2:Time] =
BEGIN
x1,x2,y:INTEGER_0;
section1,section2:CARDINAL;
IF t1>t2 THEN RETURN;
IF pitch#60 AND pitch#15 THEN RETURN;
height _ Sheet.OctavaHeight[pitch,height];
Utility.SetFont[context,text,12];
section1 _ Sheet.FindSection[t1];
section2 _ Sheet.FindSection[t2];
IF voice THEN Graphics.SetTexture[context,light];
FOR i:CARDINAL IN [section1..section2] DO
	IF i+1=sheetLength THEN EXIT;
	IF sheet[i].time<begin THEN LOOP;
	IF sheet[i].time>=endTime THEN EXIT;
	IF sheet[i].time=sheet[i+1].time THEN LOOP;
	[x1,] _ Sheet.Map[MAX[t1,sheet[i].time],,staff];
	[x2,y] _ Sheet.Map[MIN[t2,sheet[i+1].time-1],,staff];
	IF x1>staffLength-15 AND i=section1 THEN LOOP;
	x2_x2+1;  y _ y+height;
	IF x1<10 OR i=section1 THEN BEGIN
		Graphics.MoveTo[context,[x1,y-8]];
		Utility.DrawChar[context,'8];
		x1 _ x1+7; END;
	IF x1<x2 THEN DrawDottedLine[x1,y,x2,y];
	IF i=section2 THEN Utility.DrawLine[x2,y,x2,y-(IF height>0 THEN 7 ELSE -7)];
	ENDLOOP;
Utility.SetFont[context,music,8];
END;

DrawDottedLine:PROCEDURE[x1,y,x2,y2:INTEGER] =
INLINE BEGIN
x:INTEGER;
IF NOT print THEN BEGIN
	Graphics.SetTexture[context,146314B];
	Utility.DrawLine[x1,y,x2,y];
	Graphics.SetTexture[context,black];
	RETURN; END;
x_x1;
WHILE x<x2 DO
	Utility.DrawLine[x,y,MIN[x+3,x2],y];
	x _ x+5;
	ENDLOOP;
END;
--****************************************************************************
--drawing the sheet
--****************************************************************************

HiLite:PUBLIC PROCEDURE[tex:Graphics.Texture,t1,t2:Time] =
BEGIN
OPEN Graphics;
x1,y1,x2,y2,lastY:INTEGER;
v1,v2:Graphics.Vec;
offset:INTEGER _ IF tex=white THEN 58 ELSE 40;
section1,section2,i,j:CARDINAL;
IF t1 >= t2 THEN RETURN;
--EnableClipping[context];
Graphics.SetPaint[context,IF tex=white THEN replace ELSE invert];
Graphics.SetTexture[context,tex];
i _ Sheet.FindLine[t1];
j _ Sheet.PriorLine[i];
IF i=j THEN lastY_100 ELSE lastY_sheet[j].y;
j _ section1 _ FindSection[t1];
section2 _ FindSection[t2];
FOR i IN [section1..section2] DO
	IF sheet[i].time>endTime THEN EXIT;
	IF i#section2 AND sheet[i].time=sheet[i+1].time THEN LOOP;
	IF tex#white AND i#section2 AND sheet[i].y=sheet[i+1].y THEN LOOP;
	offset _ sheet[i].staves.offset;
	IF tex=white THEN offset_offset/2 ELSE offset_offset/4; 
	[x1,y1] _ Sheet.Map[MAX[t1,sheet[j].time],,0];
	[x2,y2] _ Sheet.Map[MIN[t2,sheet[i+1].time-1],,sheet[i].staves.sl];
	y1 _ y1+offset+34;  y2 _ y2-offset;
	IF x2<staffLength-1 OR tex=white THEN x2_x2+1 ELSE x2_x2+16;
	IF tex=white AND sheet[i].y#lastY AND x1=sheet[i].x THEN x1_-25;
	lastY _ sheet[i].y;
	v1 _ [x1,y1]; v2 _ [x2,y2];
	IF tex=white THEN SetBrush[white,replace];
	Graphics.DrawRectangle[context,v1,v2];
	IF tex=white THEN DrawStaves[sheet[i],x1,x2];
	j _ i+1; 
	ENDLOOP;
--EnableClipping[context];
Graphics.SetPaint[context,paint];
END;

Draw:PUBLIC PROCEDURE =
BEGIN
x:INTEGER;
j:CARDINAL;
staves:StavesPTR = sheet[0].staves;
sheetHeight:INTEGER = staves.staff[staves.sl].y;
IF begin=0 THEN Utility.DrawLine[-23,0,-23,sheetHeight];
endTime _ begin;
IF scale=2 THEN x_3 ELSE x_2*scale;
FOR j _ Sheet.FindLine[begin], Sheet.NextLine[j] DO
     IF sheet[j].y-top<(-650*x)/2 THEN {endTime_sheet[j].time; EXIT};
     DrawStaves[sheet[j],-25,staffLength];
     ENDLOOP;
END;

DrawStaves:PROCEDURE[l:Section,start,length:INTEGER] =
BEGIN
sheetHeight:INTEGER _ l.staves.staff[l.staves.sl].y;
i:CARDINAL;
y:INTEGER _ l.y-top;
oldStaff _ [0,0];
Graphics.SetTexture[context,black];
IF start=-25 THEN Utility.DrawLine[start,y,start,y+sheetHeight];
IF start=-25 AND show.accidental THEN Score.DrawKey[l.key,l.time];
IF l.page>1 THEN BEGIN
   s:STRING _ [5];
   StringDefs.AppendDecimal[s,l.page];
   Graphics.MoveTo[context,[staffLength+10,y+30]];
   Utility.SetFont[context,text,12];
   Utility.DrawString[context,s];
   Utility.SetFont[context,music,8];
   END;
IF scale>3 THEN 
   BEGIN
   Graphics.SetLineWidth[context,8];
   IF length=staffLength THEN Utility.DrawLine[length,y,length,y+sheetHeight];
   IF NOT show.notehead THEN Graphics.SetTexture[context,grey];	
   Utility.DrawLine[start,y,length,y];
   Utility.DrawLine[start,y+sheetHeight,length,y+sheetHeight];
   Graphics.SetTexture[context,black];
   Graphics.SetLineWidth[context,4];
   END
ELSE FOR i IN [0..l.staves.sl] DO
   DrawStaff[l.staves.staff[i],y,start,length]
   ENDLOOP;
END;

DrawStaff: PROCEDURE[s:Staff,y,start,length:INTEGER] =
BEGIN
w:REAL_1;
ll,ur:Graphics.Vec;
i:CARDINAL;
tex:Graphics.Texture _ Graphics.GetTexture[context];
IF s=oldStaff THEN RETURN;
oldStaff _ s;
y _ y + s.y;
Graphics.SetTexture[context,IF show.notehead THEN black ELSE grey];
IF print THEN w_w/2;
ll _ [start,y-w];
ur _[length,y+w];
FOR i IN [0..5) DO
    Graphics.DrawRectangle[context,ll,ur];
    ll.y _ ll.y+8;
    ur.y _ ur.y+8;
    ENDLOOP;
Graphics.SetTexture[context,black];
IF start<0 THEN Graphics.SetPaint[context,paint];
IF (s.pitch=27 OR s.pitch=15) AND start<0 THEN { 
	Graphics.MoveTo[context,[-21,y+16]]; 
	Utility.DrawChar[context,121C]};
IF (s.pitch=48 OR s.pitch=60) AND start<0 THEN {
	Graphics.MoveTo[context,[-21,y+16]]; 
	Utility.DrawChar[context,120C]};
Graphics.SetTexture[context,tex];
END;

oldStaff:Staff;
d:CARDINAL = 8;

--****************************************************************************
--changing the view on the sheet
--****************************************************************************

top:PUBLIC INTEGER _ 0;

SetBegin:PUBLIC PROCEDURE[now:Time] =
BEGIN
l:Section _ sheet[Sheet.FindLine[now]];
begin _ l.time;
top _ l.y;
END;

Scroll:PUBLIC PROCEDURE[lines:INTEGER] = 
BEGIN
section:CARDINAL_Sheet.FindLine[begin];
IF lines<0 
	THEN FOR i:CARDINAL IN [0..ABS[lines]) DO
		IF section=0 THEN EXIT;
		section _ Sheet.PriorLine[section];
		ENDLOOP
	ELSE FOR i:CARDINAL IN [0..ABS[lines]) DO
		section _ Sheet.NextLine[section];
		IF section=sheetLength THEN RETURN;
		ENDLOOP;
Sheet.SetBegin[sheet[section].time];
min _ 0; max _ EndOfScore[];
END;

Scale:PUBLIC PROCEDURE[newScale:INTEGER] = 
BEGIN
one:REAL = 1;
two:REAL = 2;
IF scale=newScale THEN RETURN;
--reset to 1
SELECT scale FROM
	2 => Graphics.Scale[context,[3/two,3/two]];
	4 => Graphics.Scale[context,[4,4]];
	ENDCASE; 
staffLength _ 550;
--now move to the desired scale
SELECT newScale FROM
  1 => {scale _ 1;
		staffLength _ staffLength;
		Graphics.SetLineWidth[context,1]};
  2 => {scale _ 2; --actually 3/2
		staffLength _ (3*staffLength)/2;
		Graphics.Scale[context,[two/3,two/3]];
		Graphics.SetLineWidth[context,2]};
  4 => {scale _ 4;
		staffLength _ 4*staffLength;
		Graphics.Scale[context,[one/4,one/4]];
		Graphics.SetLineWidth[context,4]};
  ENDCASE;
Sheet.Reset[];
Sheet.SetBegin[begin];
min _ 0; max _ EndOfScore[];
END;

END..

(635)\865b6B14b7B14b5B1b11B99i42I80b6B44b10B1104b5B323i1I3712b8B325b11B536i27I6i11I81b8B1760b5B34b8B488i14I80b8B336b8B638i6I80b10B1157b11B1407i17I81b6B1345b5B243i1I2190i30I81b3B22b8B109b6B412b5B406i12I