X-Git-Url: https://git.cworth.org/git?p=scherzo;a=blobdiff_plain;f=score.c;h=f8373ab1ad1c949d7635d66693aa4c5f8494e0a4;hp=ba27844fb02e9fc6835188f1409cd36e0442b5d2;hb=HEAD;hpb=367e517451123c7c79ead28eca6d2489bfed6467

diff --git a/score.c b/score.c
index ba27844..f8373ab 100644
--- a/score.c
+++ b/score.c
@@ -25,6 +25,21 @@
 
 #include "score.h"
 
+#define ARRAY_SIZE(arr) ((int) (sizeof(arr) / sizeof(arr[0])))
+
+typedef struct score_note
+{
+    score_staff_t *staff;
+    pitch_t pitch;
+    score_duration_t duration;
+
+    struct {
+	double r;
+	double g;
+	double b;
+    } color;
+} score_note_t;
+
 struct score_staff
 {
     score_clef_t clef;
@@ -63,6 +78,9 @@ struct score
     /* Full width of staff */
     int width;
 
+    /* Current (diatonic) key */
+    scherzo_key_t key;
+
     score_brace_t **braces;
     int num_braces;
     int brace_width;
@@ -86,6 +104,11 @@ score_create (void *ctx)
     /* Just to have some nominal width. */
     score->width = 1000;
 
+    /* Default to C, of course */
+    score->key.pitch = PITCH_CLASS_LITERAL (C, NATURAL);
+    score->key.num_sharps = 0;
+    score->key.num_flats = 0;
+
     score->braces = NULL;
     score->num_braces = 0;
 
@@ -114,6 +137,13 @@ score_set_width (score_t *score, int width)
     score->width = width;
 }
 
+void
+score_set_key (score_t *score, pitch_t key)
+{
+    scherzo_key_init (&score->key, key);
+}
+
+
 /* Returns in brace_width the width of the brace */
 static void
 _draw_brace (score_t *score, cairo_t *cr,
@@ -242,7 +272,17 @@ _draw_chord (score_t *score, cairo_t *cr,
     cairo_restore (cr);
 }
 
-static void
+/* Draw 'note' at its correct position on 'staff'.
+ * If the accidental of 'note' is not contained within the current
+ * key, then draw the accidental as well.
+ *
+ * As a special case, if the note's duration is 0, draw the accidental
+ * alone, regardless of the key. This is useful for drawing the
+ * accidentals of the key signature.
+ *
+ * Returns the width of the drawn glyphs.
+ */
+static double
 _draw_note (score_t *score, cairo_t *cr,
 	    score_staff_t *staff, score_note_t *note)
 {
@@ -296,7 +336,8 @@ _draw_note (score_t *score, cairo_t *cr,
 	    break;
     }
 
-    if (PITCH_ACCIDENTAL (note->pitch) != PITCH_ACCIDENTAL_NATURAL)
+    if (note->duration == 0 ||
+	! scherzo_key_contains_pitch (&score->key, note->pitch))
     {
 	    note_glyph[num_glyphs].x = 0;
 
@@ -311,33 +352,38 @@ _draw_note (score_t *score, cairo_t *cr,
 	    note_glyph[0].x = - (extents.width + ACCIDENTAL_NOTE_SPACING);
     }
 
-    switch (note->duration) {
-    case SCORE_DURATION_1:
-	note_glyph[num_glyphs].index = 127;
-	break;
-    case SCORE_DURATION_2:
-	note_glyph[num_glyphs].index = 85;
-	break;
-    case SCORE_DURATION_4:
-    case SCORE_DURATION_8:
-    case SCORE_DURATION_16:
-    case SCORE_DURATION_32:
-    case SCORE_DURATION_64:
-    case SCORE_DURATION_128:
-    default:
-	note_glyph[num_glyphs].index = 84;
-    }
+    /* Support duration == 0 to draw accidental only */
+    if (note->duration)
+    {
+	switch (note->duration) {
+	case SCORE_DURATION_1:
+	    note_glyph[num_glyphs].index = 127;
+	    break;
+	case SCORE_DURATION_2:
+	    note_glyph[num_glyphs].index = 85;
+	    break;
+	case SCORE_DURATION_4:
+	case SCORE_DURATION_8:
+	case SCORE_DURATION_16:
+	case SCORE_DURATION_32:
+	case SCORE_DURATION_64:
+	case SCORE_DURATION_128:
+	default:
+	    note_glyph[num_glyphs].index = 84;
+	}
+
+	note_glyph[num_glyphs].x = 0;
+	note_glyph[num_glyphs].y = score->space_height * line;
 
-    note_glyph[num_glyphs].x = 0;
-    note_glyph[num_glyphs].y = score->space_height * line;
+	num_glyphs++;
+    }
 
-    num_glyphs++;
+    cairo_glyph_extents (cr, note_glyph, num_glyphs, &extents);
 
     if (line < 0 || line > 4) {
 	double offset, width;
 	int i;
 
-	cairo_glyph_extents (cr, note_glyph, num_glyphs, &extents);
 	offset = note_glyph[0].x + extents.x_bearing;
 	width = extents.width;
 
@@ -357,6 +403,89 @@ _draw_note (score_t *score, cairo_t *cr,
     cairo_show_glyphs (cr, note_glyph, num_glyphs);
 
     cairo_restore (cr);
+
+    return extents.width;
+}
+
+/* Draw the accidental from 'pitch' only (no notehead) at the correct
+ * position as if drawing a note at 'pitch'.
+ *
+ * Returns the width of the drawn glyph.
+ */
+static double
+_draw_accidental (score_t *score,
+		  cairo_t *cr,
+		  score_staff_t *staff,
+		  pitch_t pitch)
+{
+    score_note_t note;
+
+    note.staff = staff;
+    note.pitch = pitch;
+
+    /* A duration of 0 indicates to draw only the accidental. */
+    note.duration = 0;
+
+    note.color.r = 0.0;
+    note.color.g = 0.0;
+    note.color.b = 0.0;
+
+    return _draw_note (score, cr, staff, &note);
+}
+
+static void
+_draw_key_signature (score_t *score, cairo_t *cr,
+		     score_staff_t *staff)
+{
+    pitch_t pitch;
+    double width;
+    int i;
+
+    /* These octave numbers are correct for treble clef. For bass
+     * clef, subtract two.
+     */
+    pitch_t sharps_order[] = {
+	PITCH_LITERAL (F, SHARP, 5),
+	PITCH_LITERAL (C, SHARP, 5),
+	PITCH_LITERAL (G, SHARP, 5),
+	PITCH_LITERAL (D, SHARP, 5),
+	PITCH_LITERAL (A, SHARP, 4),
+	PITCH_LITERAL (E, SHARP, 5),
+	PITCH_LITERAL (B, SHARP, 4)
+    };
+
+    pitch_t flats_order[] = {
+	PITCH_LITERAL (B, FLAT, 4),
+	PITCH_LITERAL (E, FLAT, 5),
+	PITCH_LITERAL (A, FLAT, 4),
+	PITCH_LITERAL (D, FLAT, 5),
+	PITCH_LITERAL (G, FLAT, 4),
+	PITCH_LITERAL (C, FLAT, 5),
+	PITCH_LITERAL (F, FLAT, 4),
+    };
+
+    for (i = 0; i < score->key.num_sharps; i++) {
+	pitch = sharps_order[i];
+
+	if (staff->clef == SCORE_CLEF_BASS)
+	    pitch = pitch_lower_by_octaves (pitch, 2);
+
+	width = _draw_accidental (score, cr, staff, pitch);
+
+#define KEY_SIGNATURE_ACCIDENTAL_SPACING (score->space_height * .15)
+	cairo_translate (cr, ceil (width + KEY_SIGNATURE_ACCIDENTAL_SPACING), 0);
+    }
+
+    for (i = 0; i < score->key.num_flats; i++) {
+	pitch = flats_order[i];
+
+	if (staff->clef == SCORE_CLEF_BASS)
+	    pitch = pitch_lower_by_octaves (pitch, 2);
+
+	width = _draw_accidental (score, cr, staff, pitch);
+
+	cairo_translate (cr, ceil (width + KEY_SIGNATURE_ACCIDENTAL_SPACING), 0);
+    }
 }
 
 static void
@@ -365,6 +494,7 @@ _draw_staff (score_t *score, cairo_t *cr,
 {
     int i;
     cairo_glyph_t clef_glyph;
+    cairo_text_extents_t clef_extents;
 
     cairo_save (cr);
 
@@ -374,6 +504,19 @@ _draw_staff (score_t *score, cairo_t *cr,
 
     cairo_set_font_size (cr, score->staff_height);
 
+    /* Draw staff lines */
+    for (i = 0; i < 5; i++) {
+	cairo_move_to (cr, 0, i * score->space_height + score->line_width / 2.0);
+	cairo_rel_line_to (cr, staff_width, 0);
+    }
+
+    cairo_set_line_width (cr, score->line_width);
+
+    cairo_set_source_rgb (cr, 0.0, 0.0, 0.0); /* black */
+    cairo_stroke (cr);
+
+    /* Draw the clef */
+
     /* XXX: The hard-coded glyph indices here are very ugly. We should
      * figure out how to lookup glyphs by name from this font. */
     switch (staff->clef) {
@@ -393,19 +536,18 @@ _draw_staff (score_t *score, cairo_t *cr,
     cairo_set_source_rgb (cr, 0.0, 0.0, 0.0); /* black */
     cairo_show_glyphs (cr, &clef_glyph, 1);
 
-    /* Draw staff lines */
-    for (i = 0; i < 5; i++) {
-	cairo_move_to (cr, 0, i * score->space_height + score->line_width / 2.0);
-	cairo_rel_line_to (cr, staff_width, 0);
-    }
+    /* Make space for clef */
+    cairo_glyph_extents (cr, &clef_glyph, 1, &clef_extents);
 
-    cairo_set_line_width (cr, score->line_width);
+#define CLEF_KEY_SIGNATURE_SPACING (score->space_height * .75) 
+    cairo_translate (cr, ceil (clef_extents.width +
+			       CLEF_KEY_SIGNATURE_SPACING), 0);
 
-    cairo_set_source_rgb (cr, 0.0, 0.0, 0.0); /* black */
-    cairo_stroke (cr);
+    /* Draw the key signature */
+    _draw_key_signature (score, cr, staff);
 
-    /* Make space for clef before drawing notes */
-    cairo_translate (cr, (int) (4 * score->space_height), 0);
+#define KEY_SIGNATURE_NOTE_SPACING (score->space_height)
+    cairo_translate (cr, ceil (KEY_SIGNATURE_NOTE_SPACING), 0);
 
     /* Draw chord symbols */
     cairo_save (cr);
@@ -583,29 +725,24 @@ score_add_chord (score_staff_t *staff,
 }
 
 void
-score_remove_chord (score_chord_t *chord)
+score_staff_remove_chords (score_staff_t *staff)
 {
-    score_staff_t *staff = chord->staff;
-    int i;
-
-    for (i = 0; i < staff->num_chords; i++)
-	if (staff->chords[i] == chord)
-	    break;
+    talloc_free (staff->chords);
+    staff->chords = NULL;
 
-    if (i == staff->num_chords)
-	return;
+    staff->num_chords = 0;
+}
 
-    if (i < staff->num_chords - 1)
-    {
-	memmove (staff->chords + i,
-		 staff->chords + i + 1, 
-		 (staff->num_chords - 1 - i) * sizeof (score_chord_t *));
-    }
+void
+score_remove_chords (score_t *score)
+{
+    int i;
 
-    staff->num_chords -= 1;
+    for (i = 0; i < score->num_staves; i++)
+	score_staff_remove_chords (score->staves[i]);
 }
 
-score_note_t *
+void
 score_staff_add_note (score_staff_t *staff,
 		      pitch_t pitch,
 		      score_duration_t duration)
@@ -620,13 +757,13 @@ score_staff_add_note (score_staff_t *staff,
 	if (note->pitch == pitch &&
 	    note->duration == duration)
 	{
-	    return note;
+	    return;
 	}
     }
 
     note = talloc (staff, score_note_t);
     if (note == NULL)
-	return NULL;
+	return;
 
     note->staff = staff;
     note->pitch = pitch;
@@ -654,15 +791,13 @@ score_staff_add_note (score_staff_t *staff,
 				   staff->num_notes);
     if (staff->notes == NULL) {
 	staff->num_notes = 0;
-	return NULL;
+	return;
     }
 
     staff->notes[staff->num_notes - 1] = note;
-
-    return note;
 }
 
-score_note_t *
+void
 score_add_note (score_t *score, pitch_t pitch, score_duration_t duration)
 {
     score_staff_t *staff, *nearest_staff = NULL;
@@ -671,7 +806,7 @@ score_add_note (score_t *score, pitch_t pitch, score_duration_t duration)
 
     /* Nothing to do if we have no staff, (there's no place to add a note) . */
     if (score->num_staves == 0)
-	return NULL;
+	return;
 
     /* Find the staff where the note will be closest to the center of
      * the staff. */
@@ -684,35 +819,7 @@ score_add_note (score_t *score, pitch_t pitch, score_duration_t duration)
 	}
     }
 
-    return score_staff_add_note (nearest_staff, pitch, duration);
-}
-
-void
-score_remove_note (score_note_t *note)
-{
-    score_staff_t *staff = note->staff;
-    int i;
-
-    for (i = 0; i < staff->num_notes; i++)
-	if (staff->notes[i] == note)
-	    break;
-
-    if (i == staff->num_notes)
-	return;
-
-    if (i < staff->num_notes - 1)
-    {
-	memmove (staff->notes + i,
-		 staff->notes + i + 1, 
-		 (staff->num_notes - 1 - i) * sizeof (score_note_t *));
-    }
-
-    staff->num_notes -= 1;
-
-    if (staff->num_notes == 0) {
-	staff->upper_ledger_lines = 0;
-	staff->lower_ledger_lines = 0;
-    }
+    score_staff_add_note (nearest_staff, pitch, duration);
 }
 
 void
@@ -721,6 +828,9 @@ score_staff_remove_notes (score_staff_t *staff)
     talloc_free (staff->notes);
     staff->notes = NULL;
     staff->num_notes = 0;
+
+    staff->upper_ledger_lines = 0;
+    staff->lower_ledger_lines = 0;
 }
 
 void
@@ -731,31 +841,3 @@ score_remove_notes (score_t *score)
     for (i = 0; i < score->num_staves; i++)
 	score_staff_remove_notes (score->staves[i]);
 }
-
-void
-score_set_note_color_rgb (score_note_t *note,
-			  double r,
-			  double g,
-			  double b)
-{
-    note->color.r = r;
-    note->color.g = g;
-    note->color.b = b;
-}
-
-score_note_t *
-score_staff_find_note (score_staff_t *staff,
-		       pitch_t pitch,
-		       score_duration_t duration)
-{
-    int i;
-    score_note_t *note;
-
-    for (i = 0; i < staff->num_notes; i++) {
-	note = staff->notes[i];
-	if (note->pitch == pitch && note->duration == duration)
-	    return note;
-    }
-
-    return NULL;
-}