DIRECTORY
Beam USING [Drawn], 
Event USING [Adjust, Draw, GetScoreIndex], 
Graphics USING [Context, DrawBox, DrawChar, GetBounds, SetCP, SetStipple], 
MusicDefs, 
Note USING [DrawTie, InVoice], 
Piece USING [NearestEvent], 
Score USING [Draw, GetKey, Justify, LogicalToPhysical, ScalePhysical, SetStyle, ShowPitch], 
Selection USING [Draw, selection], 
Sheet USING [default, Draw, FindSection, FindStaves, Height, HiLite, MapNote, Scale, SetBegin];

ScoreImplB: CEDAR PROGRAM
IMPORTS Beam, Graphics, MusicDefs, Note, Piece, Score, Selection, Sheet, Event 
EXPORTS Score
= BEGIN OPEN MusicDefs;


Draw: PUBLIC PROC[score: ScorePTR, erase: BOOLEAN] = {
sheet: SheetPTR _ score.sheet;
Selection.Draw[]; -- remove selection from screen
IF erase THEN {
SetBrush[score, white, opaque];
Graphics.DrawBox[sheet.context, Graphics.GetBounds[sheet.context]];
SetBrush[score, black, transparent]; 
Sheet.Draw[sheet]};
DrawInterval[score, sheet.begin, sheet.endTime];
Selection.Draw[];
};

Redraw: PUBLIC PROC[score: ScorePTR, t1, t2: Time] = {
x, y: INTEGER;
select: BOOLEAN;
selection: SelectionPTR _ Selection.selection;
SetBrush[score, black, transparent];
SELECT score.sheet.scale FROM
1 => IF t2-t1 > 700 THEN {Score.Draw[score]; RETURN};
2 => IF t2-t1 > 2000 THEN {Score.Draw[score]; RETURN};
4 => IF t2-t1 > 8000 THEN {Score.Draw[score]; RETURN};
ENDCASE;
select _ selection.lineSelect AND selection.select2 > t1-40 AND selection.select1 < t2+50;
IF select THEN Selection.Draw[]; -- remove selection from screen
Sheet.HiLite[score.sheet, white, t1-20, t2+30];
DrawInterval[score, t1-30, t2+40];
IF select THEN Selection.Draw[];
IF selection.lineSelect THEN RETURN;
SetBrush[score, black, invert];
FOR i: CARDINAL IN [0..selection.length) DO
IF selection.note[i] = NIL THEN LOOP;
IF selection[i].sync.time > t2+40 OR selection[i].sync.time < t1-30 THEN LOOP;
IF ~Note.InVoice[selection[i], score.sheet.voice] THEN LOOP;
[x, y] _ Sheet.MapNote[score.sheet, selection[i]];
Graphics.SetCP[score.sheet.context, x, y];
Graphics.DrawChar[score.sheet.context, 170C];
ENDLOOP;
};

DrawInterval: PROC[score: ScorePTR, t1, t2: Time] = {
n: NotePTR;
staves: StavesPTR;
j: CARDINAL _ 0;
sheet: SheetPTR _ score.sheet;
[] _ Beam.Drawn[score, NIL]; -- clears the beam cache
SetBrush[score, black, transparent];
staves _ Sheet.FindStaves[sheet, t1];
FOR i: CARDINAL IN [0..staves.length) DO
IF staves.staff[i].pitch # 15 AND staves.staff[i].pitch # 60 THEN LOOP;
FOR j: CARDINAL DECREASING IN [0..score.length) DO
IF score.event[j].time >= t1 THEN LOOP;
IF score.event[j].type # staves THEN LOOP;
WITH score.event[j] SELECT FROM
ev: StavesPTR => {
IF ev.staves NOT IN [octava1..octava2] THEN LOOP;
IF ev.value # i THEN LOOP;
IF ev.staves = octava2 THEN EXIT};
ENDCASE => ERROR;
Event.Draw[score, score.event[j]]; 
EXIT; ENDLOOP;
ENDLOOP;
j _ 0;
IF score.sheet.display = graphical THEN 
FOR i: CARDINAL IN [0..score.length) DO
IF score.event[i].time < t1 THEN LOOP;
IF score.event[i].time > t2 THEN EXIT;
IF score.event[i].type = sync THEN {
IF j = 10 THEN EXIT ELSE j _ j+1;
Event.Adjust[score, NARROW[score.event[i]]]};
ENDLOOP;
j _ 0;
FOR i: CARDINAL IN [0..score.length) DO
IF score.event[i].time < t1 THEN LOOP;
IF score.event[i].time > t2 THEN {j _ i; EXIT};
IF score.sheet.display = graphical THEN {
plus10: CARDINAL _ MIN[i+10, score.length-1];
IF score.event[plus10].type = sync 
THEN Event.Adjust[score, NARROW[score.event[plus10]]]};
Event.Draw[score, score.event[i]];
ENDLOOP;
IF j # 0 THEN FOR i: CARDINAL IN [j..score.length) DO
IF score.event[i].time > t2+200 THEN EXIT;
WITH score.event[i] SELECT FROM
sync: SyncPTR => {
FOR j: CARDINAL IN [0..sync.length) DO
IF (n _ sync.note[j]) = NIL THEN EXIT;
IF n.tie = NIL THEN LOOP;
IF n.tie.sync.time > t2 THEN LOOP;
IF ~Note.InVoice[n, score.sheet.voice]
THEN Graphics.SetStipple[score.sheet.context, light]
ELSE Graphics.SetStipple[score.sheet.context, black];
Note.DrawTie[score, n];
ENDLOOP;
};
ENDCASE;
ENDLOOP;
[] _ Beam.Drawn[score, NIL];
};


Print: PUBLIC PROC[score: ScorePTR, splines: BOOLEAN] = {};


Look: PUBLIC PROC[score: ScorePTR, look: LookCommand, switch: BOOLEAN, n: INTEGER] = {
draw: BOOLEAN _ TRUE;
SELECT look FROM
accidental => score.sheet.accidental _ switch;
hardcopy   => {
Sheet.Scale[score, IF switch THEN 2 ELSE 1]; 
score.sheet.hardcopy _ switch};
justified  => {
score.sheet.density _ n; 
Score.Justify[score, Selection.selection.select1, Selection.selection.select2]};
logical    => Score.LogicalToPhysical[score, Selection.selection.select1, Selection.selection.select2];
noCarry    => score.sheet.noCarry _ switch;
notehead   => score.sheet.notehead _ switch;
overview   => Overview[score, switch];
physical   => Score.ScalePhysical[score, 512/n];
style      => Score.SetStyle[score, n, 0, EndOfScore[score]];
sync  => score.sheet.sync _ switch;
voice      => {score.sheet.voice _ IF ~switch THEN noVoice ELSE n};
ENDCASE;
};

Overview: PROC[score: ScorePTR, switch: BOOLEAN] = {
SELECT TRUE FROM
score.sheet.scale < 4 AND ~switch => {score.flash _ TRUE; RETURN};
score.sheet.scale > 2 AND switch => {score.flash _ TRUE; RETURN};
switch => {Sheet.Scale[score, 4]; Sheet.SetBegin[score.sheet, 0]};
ENDCASE => {
Sheet.Scale[score, IF score.sheet.hardcopy THEN 2 ELSE 1]; 
Sheet.SetBegin[score.sheet, 0]};
};


phi: ARRAY [0..12) OF INTEGER = [6, 1, -4, 3, -2, 5, 0, 7, 2, -3, 4, -1];
flatHeight: ARRAY[0..12) OF INTEGER =  [0, 4, 8, 8, 12, 12, 16, 16, 20, 24, 24, 28];
sharpHeight: ARRAY[0..12) OF INTEGER = [0, 4, 4, 8, 8, 12, 12, 16, 20, 20, 24, 24];

GetAccidental: PUBLIC PROC[score: ScorePTR, n: NotePTR] RETURNS[Accidental] = {
n.shown _ GetAccInternal[score, n];
RETURN[n.shown];
};

GetAccInternal: PROC[score: ScorePTR, n: NotePTR] RETURNS[Accidental] = {
a: Accidental;
prior: NotePTR;
index: CARDINAL;
pitch, key: INTEGER;
normal: Accidental;
noteHeight: INTEGER;
IF NOT score.sheet.accidental THEN RETURN[inKey];
IF n.tie # NIL AND n.tie.pitch = n.pitch THEN RETURN[inKey];
IF n.show AND n.spelled = inKey THEN Error["show inKey?"];
IF n.show THEN RETURN[n.spelled];
IF score.sheet.noCarry THEN {
IF n.spelled # inKey THEN RETURN[n.spelled];
a _ DefaultAcc[0, n.pitch];
IF a = natural THEN a _ inKey;
RETURN[a]};
key _ Score.GetKey[score, n.sync.time];
pitch _ Score.ShowPitch[score.sheet, n.pitch, n.spelled, key];
noteHeight _ Sheet.Height[score.sheet, n.sync.time, pitch, n.staff];
index _ Event.GetScoreIndex[score, n.sync];
IF index = score.length THEN index _ EventIndex[score, n.sync.time];
prior _ PriorNote[score, pitch, noteHeight, index];
normal _ NormalAcc[key, pitch];
IF prior = NIL THEN SELECT TRUE FROM
normal = inKey => RETURN[n.spelled];
n.spelled = inKey => RETURN[normal];
ENDCASE => RETURN[n.spelled];
IF prior.pitch = n.pitch THEN RETURN[inKey];
IF n.spelled # inKey THEN RETURN[n.spelled];
IF normal # inKey THEN RETURN[normal];
IF Mod[n.pitch, 12] = 7 AND key < -5 THEN RETURN[flat];
IF Mod[n.pitch, 12] = 0 AND key < -6 THEN RETURN[flat];
IF Mod[n.pitch, 12] = 1 AND key > 5 THEN RETURN[sharp];
IF Mod[n.pitch, 12] = 8 AND key > 6 THEN RETURN[sharp];
normal _ NormalAcc[0, n.pitch];
IF normal = inKey THEN normal _ natural;
IF key < 0 AND normal = sharp THEN normal _ flat;
RETURN[normal];
};

EventIndex: PROC[score: ScorePTR, time: Time] RETURNS[s: CARDINAL] = {
s _ Piece.NearestEvent[score, time];
IF score.event[s] # NIL AND score.event[s].time >= time THEN RETURN[s];
FOR i: CARDINAL DECREASING IN [0..s+10) DO
IF score.event[i] = NIL THEN LOOP;
IF score.event[i].time > time THEN LOOP;
RETURN[i+1];
ENDLOOP;
};

PriorNote: PUBLIC PROC[score: ScorePTR, pitch, height: INTEGER, index: CARDINAL] RETURNS[NotePTR] = {
n: NotePTR;
sync: SyncPTR;
newPitch, key: INTEGER;
FOR i: CARDINAL DECREASING IN [0..index) DO
IF Measure[score.event[i]] THEN RETURN[NIL];
IF score.event[i].type # sync THEN LOOP;
key _ Score.GetKey[score, score.event[i].time];
sync _ NARROW[score.event[i]];
FOR j: CARDINAL IN [0..sync.length) DO
IF (n _ sync.note[j]) = NIL THEN EXIT;
IF n.rest THEN LOOP;
newPitch _ Score.ShowPitch[score.sheet, n.pitch, n.spelled, key];
IF NOT newPitch IN [pitch-2..pitch+2] THEN LOOP;
IF Sheet.Height[score.sheet, score.event[i].time, newPitch, n.staff] # height THEN LOOP;
RETURN[n];
ENDLOOP;
ENDLOOP;
RETURN[NIL];
};

assert: Accidental = LOOPHOLE[LOOPHOLE[LAST[Accidental], CARDINAL]+1]; 

NormalAcc: PUBLIC PROC[key, pitch: INTEGER] RETURNS[Accidental] = {
strangeness: INTEGER _ phi[Mod[pitch, 12]];
SELECT TRUE FROM
Mod[(key-strangeness), 12] > 4 => RETURN[inKey];
strangeness > 0 => RETURN[natural];
key < 0 => RETURN[flat];
ENDCASE => RETURN[sharp];
};

DefaultAcc: PROC[key, pitch: INTEGER] RETURNS[Accidental] = {
SELECT NormalAcc[0, pitch] FROM
inKey => RETURN[natural];
sharp => RETURN[IF key < 0 THEN flat ELSE sharp];
ENDCASE => ERROR;
};

AddToPitch: PUBLIC PROC[key, pitch, delta: INTEGER] RETURNS[INTEGER] = {
i: INTEGER;
IF delta > 0 THEN FOR i IN (pitch..90] DO
IF NormalAcc[key, i] = inKey THEN delta _ delta-1;
IF delta = 0 THEN RETURN[i];
ENDLOOP
ELSE FOR i DECREASING IN [0..pitch) DO
IF NormalAcc[key, i] = inKey THEN delta _ delta+1;
IF delta = 0 THEN RETURN[i];
ENDLOOP;
ERROR;
};

KeyHeight: PUBLIC PROC[key, pitch: INTEGER] RETURNS[INTEGER] = {
i: CARDINAL _ Mod[pitch, 12];
SELECT TRUE FROM
i = 7 AND key < -5 => RETURN[flatHeight[8]];
i = 0 AND key < -6 => RETURN[flatHeight[1]];
key < 0  => RETURN[flatHeight[i]];
i = 1 AND key > 5 => RETURN[sharpHeight[0]];
i = 8 AND key > 6 => RETURN[sharpHeight[7]];
ENDCASE => RETURN[sharpHeight[i]];
};

END.

Print: PUBLIC PROC[splines: BOOLEAN] = {
printAll: BOOLEAN;
oldBegin: Time _ begin;
ph: POINTER TO PressDefs.PressFileDescriptor;
device: Device.Handle _ Utility.OpenPressDevice[splines];
ph _ LOOPHOLE[device.data, PressDeviceImpl.DataRef].pressHandle;
printAll _ ~splines AND scale = 2;
IF printAll THEN Sheet.SetBegin[0];
FOR i: CARDINAL IN [0..scoreLength) DO
Event.Adjust[score.event[i]];
ENDLOOP;
WHILE TRUE DO
Sheet.Draw[];
DrawInterval[begin, endTime];
IF endTime > EndOfScore[]-40 THEN EXIT;
IF printAll THEN {Sheet.SetBegin[endTime]; PressDefs.WritePage[ph]} ELSE EXIT;
ENDLOOP;
Utility.ClosePressDevice[@device];
Sheet.SetBegin[oldBegin];
};

LScoreImplB.mesa
Copyright (C) 1983, 1984 Xerox Corporation. All rights reserved.
Author: John Maxwell
Last Edited by: Maxwell, November 22, 1983 12:29 pm
Last Edited by: Doug Wyatt, June 12, 1984 11:55:05 am PDT
****************************************************************************
drawing the score 
****************************************************************************
draw octava markings first
pre-Adjust the first 10 syncs (beams may draw notes in syncs downstream)
draw the syncs
IF NOT sheet.printing AND AnyBug[] THEN EXIT;
draw ties that go off the end of the section
****************************************************************************
printing the score 
****************************************************************************
****************************************************************************
changing the view
****************************************************************************
ENABLE Piece.Overflow => IF score = old THEN score _ new;
time: Time;
x, y: INTEGER;
YellowBug[] => {
[x, y] _ Sheet.ScreenPoint[score.sheet];
time _ Sheet.NearestTime[score.sheet, x, y].time;
Sheet.Scale[score, IF score.sheet.hardcopy THEN 2 ELSE 1]; 
Sheet.SetBegin[score.sheet, time]};
****************************************************************************
getting accidentals
****************************************************************************
hack to set n.shown
no prior note
n.spelled = normal => RETURN[inKey];
n.spelled # normal => RETURN[n.spelled];
ENDCASE;
prior note
an accidental MUST be asserted
I bet you don't really believe this works.
�Ê]˜™Jš
œ@™@Jš
œ™Jš
œ3™3Jš
œ9™9—J˜š
Ïk	˜	Jšœ�œ
˜Jšœ�œ ˜+Jšœ	�œ=˜KJ˜Jšœ�œ˜Jšœ�œ˜Jšœ�œQ˜\Jšœ
�œ˜#Jšœ�œT˜_J˜—Jšœ�œ
�˜Jš�œH˜OJš�œ˜
Jšœ�œ
�œ˜J˜Jš
œL™LJš
œ™Jš
œL™LJ˜šÏnœ�œ
�œ�œ˜6J˜JšœÏc˜1š�œ�œ˜J˜J˜CJ˜%J˜—J˜0J˜Jš
œ˜J˜—šžœ�œ
�œ#˜6Jšœ�œ
˜Jšœ�œ
˜J˜.J˜$š�œ�˜Jšœ�œ
�œ�œ˜5Jšœ�œ�œ�œ˜6Jšœ�œ�œ�œ˜6Jš�œ
˜—Jšœ�œ�œ˜ZJš�œ�œŸ˜@J˜/J˜"Jš�œ�œ˜ Jš�œ�œ
�œ
˜$J˜š�œ�œ
�œ�˜+Jš�œ�œ
�œ
�œ
˜%Jš�œ �œ �œ
�œ
˜NJš�œ0�œ
�œ
˜<J˜2J˜*J˜-Jš�œ
˜—Jš
œ˜J˜—šžœ�œ#˜5J˜J˜Jšœ�œ˜J˜Jšœ�œŸ˜5J˜$Jš
œ™J˜%š�œ�œ
�œ�˜(Jš�œ�œ�œ
�œ
˜Gš	�œ�œ
�
œ
�œ�˜2Jš�œ�œ
�œ
˜'Jš�œ�œ
�œ
˜*š�œ�œ
�˜š
œ˜Jš
�œ�œ
�œ�œ
�œ
˜1Jš�œ�œ
�œ
˜Jš�œ�œ
�œ˜"—Jš�œ�œ
˜—J˜#Jš�œ�œ
˜—Jš�œ
˜—Jš
œH™HJ˜š�œ!�œ
˜(š�œ�œ
�œ�˜'Jš�œ�œ
�œ
˜&Jš�œ�œ
�œ
˜&š�œ�œ˜$š�œ�œ
�œ
�œ	˜!Jšœ�œ˜-Jš�œ
˜————Jš
œ™J˜š�œ�œ
�œ�˜'Jš�œ�œ
�œ
˜&Jš�œ�œ	�œ˜/š�œ!�œ˜)Jšœ�œ�œ˜-š�œ!˜#Jš�œ�œ˜7——J˜"Jš
�œ
�œ�œ
�œ
�œ
™-Jš�œ
˜—Jš
œ,™,š�œ�œ
�œ�œ
�œ�˜5Jš�œ�œ
�œ
˜*š�œ�œ
�˜š
œ˜š�œ�œ
�œ�˜&Jš�œ�œ
�œ
�œ
˜&Jš�œ	�œ
�œ
�œ
˜Jš�œ�œ
�œ
˜"š�œ$˜&Jš�œ0˜4Jš�œ1˜5—J˜Jš�œ
˜—J˜—Jš�œ
˜—Jš�œ
˜—Jšœ�œ˜Jš
œ˜J˜—Jš
œL™LJš
œ™Jš
œL™LJ˜Jšžœ�œ
�œ�œ˜;J˜Jš
œL™LJš
œ™Jš
œL™LJ˜š
žœ�œ
�œ-�œ�œ˜VJš�œ�œ
�œ
™9Jšœ�œ�œ
˜š�œ�˜J˜.˜Jšœ�œ�œ�œ˜-J˜—˜J˜J˜P—J˜gJ˜+J˜,J˜&J˜0J˜=J˜#Jšœ#�œ	�œ	�œ˜CJš�œ
˜—Jš
œ˜J˜—šžœ�œ�œ˜4J™Jšœ�œ
™š�œ
�œ
�˜Jšœ�œ�œ�œ˜BJšœ�œ�œ�œ˜AJ˜B™J™(J™1Jšœ�œ�œ�œ™;J™#—š�œ˜Jšœ�œ�œ�œ˜;J˜ ——Jš
œ˜J˜—Jš
œL™LJš
œ™Jš
œL™LJ˜Jšœ�œ	�œ
�œ,˜IJšœ�œ�œ
�œ1˜TJšœ
�œ�œ
�œ/˜SJ˜šž
œ�œ
�œ�œ˜OJš
œ™J˜#Jš�œ
˜Jš
œ˜J˜—šžœ�œ�œ˜IJ˜J˜Jšœ�œ
˜Jšœ�œ
˜J˜Jšœ�œ
˜Jš�œ
�œ�œ
�œ˜1Jš
�œ	�œ
�œ�œ
�œ˜<Jš�œ�œ�œ˜:Jš�œ�œ
�œ˜!š�œ�œ˜Jš�œ�œ
�œ˜,J˜Jš�œ
�œ˜Jš�œ˜—J˜'J˜>J˜DJ˜+Jš�œ�œ(˜DJ˜3J˜Jš
œ
™
š�œ	�œ
�œ
�œ
�œ
�˜$Jšœ�œ˜$Jšœ�œ	˜$Jš�œ�œ˜—Jš
œ$™$Jš
œ(™(Jš
œ™Jš
œ
™
Jš�œ�œ
�œ˜,Jš
œ™Jš�œ�œ
�œ˜,Jš�œ�œ
�œ	˜&Jš�œ�œ
�œ
�œ˜7Jš�œ�œ
�œ
�œ˜7Jš�œ�œ	�œ
�œ˜7Jš�œ�œ	�œ
�œ˜7J˜Jš�œ�œ˜(Jš�œ	�œ�œ˜1Jš�œ	˜Jš
œ˜J˜—šž
œ�œ�œ�œ˜FJ˜$Jš
�œ�œ
�œ�œ
�œ˜Gš	�œ�œ
�
œ
�œ�˜*Jš�œ�œ
�œ
�œ
˜"Jš�œ�œ
�œ
˜(Jš�œ˜Jš�œ
˜—Jš
œ˜J˜—šž	œ�œ
�œ!�œ	�œ�œ
˜eJ˜J˜Jšœ�œ
˜š	�œ�œ
�
œ
�œ�˜+Jš�œ�œ
�œ
�œ˜,Jš�œ�œ
�œ
˜(J˜/Jšœ�œ˜š�œ�œ
�œ�˜&Jš�œ�œ
�œ
�œ
˜&Jš�œ�œ
�œ
˜J˜AJš
�œ
�œ
�œ�œ
�œ
˜0Jš�œL�œ
�œ
˜XJš�œ˜
Jš�œ
˜—Jš�œ
˜—Jš�œ
�œ˜Jš
œ˜J˜—Jš	œ�œ
�œ
�œ�œ˜GJ˜š
ž	œ�œ
�œ
�œ�œ˜CJšœ
�œ˜+Jš
œ*™*š�œ
�œ
�˜Jšœ"�œ˜0Jšœ�œ
˜#Jšœ�œ˜Jš�œ�œ˜—Jš
œ˜J˜—šž
œ�œ
�œ�œ˜=š�œ�˜Jšœ	�œ
˜Jš	œ	�œ
�œ	�œ�œ˜1Jš�œ�œ
˜—Jš
œ˜J˜—šž
œ�œ
�œ�œ�œ
�œ˜HJšœ�œ
˜š	�œ�œ
�œ�œ
�˜)Jš�œ�œ˜2Jš�œ�œ
�œ˜Jš
�˜š	�œ
�œ�
œ
�œ�˜&Jš�œ�œ˜2Jš�œ�œ
�œ˜Jš�œ
˜——Jš�œ
˜Jš
œ˜J˜—šž	œ�œ
�œ
�œ�œ
�œ˜@Jšœ�œ˜š�œ
�œ
�˜Jšœ�œ
�œ˜,Jšœ�œ
�œ˜,Jšœ�œ˜"Jšœ�œ�œ˜,Jšœ�œ�œ˜,Jš�œ�œ˜"—Jš
œ˜J˜—Jš�œ
˜J˜šžœ�œ
�œ
�œ˜(Jšœ
�œ
˜J˜Jšœ�œ
�œ˜-J˜9Jšœ�œ3˜@Jšœ�œ˜"Jš�œ
�œ˜#š�œ�œ
�œ�˜&J˜Jš�œ
˜—š�œ
�œ
�˜
J˜
J˜Jš�œ�œ
�œ
˜'Jš�œ
�œ4�œ
�œ
˜NJš�œ
˜—J˜"J˜Jš
œ˜J˜——…—'ª<S