X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=score.c;h=0a6016bcb706785db4460460a37ebdde235a8563;hb=54d2b1cb13bf52df22c93e58377a00b757644b94;hp=598c298752d13d42634b487176dd90267419169c;hpb=0261a9e510c766d7c8c69a8d66783bf050683c9f;p=scherzo diff --git a/score.c b/score.c index 598c298..0a6016b 100644 --- a/score.c +++ b/score.c @@ -18,18 +18,75 @@ * along with this program. If not, see http://www.gnu.org/licenses/ . */ +#include + +#include +#include + #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; + + score_chord_t **chords; + int num_chords; + + score_note_t **notes; + int num_notes; + + /* How many ledger lines are needed for current notes */ + int upper_ledger_lines; + int lower_ledger_lines; + + /* Y position of top full line of staff */ + int y_pos; +}; + +typedef struct score_brace +{ + int first_staff; + int num_staves; +} score_brace_t; + struct score { - /* Height of a single staff */ + /* Nominal height of a single staff (ledger lines may make it larger) */ int staff_height; /* Height of one space within a staff */ int space_height; + /* Minimal line width for staff lines */ + int line_width; + /* Full width of staff */ int width; + + /* the pitch class of the current (diatonic) key */ + pitch_t key; + + score_brace_t **braces; + int num_braces; + int brace_width; + + score_staff_t **staves; + int num_staves; }; score_t * @@ -38,7 +95,23 @@ score_create (void *ctx) score_t *score; score = talloc (ctx, score_t); - score_set_staff_height (score, 24); + if (score == NULL) + return NULL; + + /* Also sets space_height and line_width */ + score_set_staff_height (score, 76); + + /* Just to have some nominal width. */ + score->width = 1000; + + /* Default to C, of course */ + score->key = PITCH_CLASS_LITERAL (C, NATURAL); + + score->braces = NULL; + score->num_braces = 0; + + score->staves = NULL; + score->num_staves = 0; return score; } @@ -48,6 +121,11 @@ score_set_staff_height (score_t *score, int height) { score->space_height = (int) height / 4; score->staff_height = score->space_height * 4; + + score->line_width = score->space_height / 10; + if (score->line_width == 0) + score->line_width = 1; + return score->staff_height; } @@ -57,116 +135,755 @@ score_set_width (score_t *score, int width) score->width = width; } -typedef enum score_clef +void +score_set_key (score_t *score, pitch_t key) +{ + score->key = key; +} + +/* Returns in brace_width the width of the brace */ +static void +_draw_brace (score_t *score, cairo_t *cr, + score_brace_t *brace, int *brace_width) +{ + cairo_glyph_t brace_glyph; + cairo_text_extents_t brace_extents; + double top, bottom; + + if (brace->num_staves == 0) + return; + + cairo_save (cr); + + top = score->staves[brace->first_staff]->y_pos; + bottom = score->staves[brace->first_staff + brace->num_staves - 1]->y_pos + score->staff_height; + + cairo_select_font_face (cr, "Gonville-Brace", 0, 0); + + /* XXX: This hard-coded glyph index is pretty ugly. We should + * figure out how to lookup the glyph we want, (though, as it + * turns out, this brace font pretty much just has numbered glyph + * names for different sizes, so it wouldn't be all that different + * than just the bare index here). */ + brace_glyph.index = 300; + brace_glyph.x = 0; + brace_glyph.y = top + (bottom - top) / 2.0 + score->line_width / 2.0; + + /* XXX: This font size (in conjunction with the glyph selection) + * is a rough guess at best. We should figure out how the brace + * font is intended to be used and actually measure to find the + * correctly-sized glyph. */ + cairo_set_font_size (cr, (bottom - top) / 3.85); + + cairo_glyph_extents (cr, &brace_glyph, 1, &brace_extents); + + /* Subtract space for brace itself */ + cairo_translate (cr, -brace_extents.x_bearing, 0); + + cairo_set_source_rgb (cr, 0.0, 0.0, 0.0); /* black */ + cairo_show_glyphs (cr, &brace_glyph, 1); + + cairo_restore (cr); + + *brace_width = (int) -brace_extents.x_bearing; +} + +/* Line containing middle C for the given clef. */ +static int +_score_clef_c_line (score_clef_t clef) +{ + switch (clef) + { + default: + case SCORE_CLEF_G: + return 5; + case SCORE_CLEF_F: + return -1; + } +} + +/* On which line would 'pitch' appear on 'staff'. + * + * Lines are numbered with line 0 as the top full line of the staff + * and increasing downward. So line values less than 0 will appear as + * ledger lines above the staff while line values greater than 4 will + * appear on ledger lines below the staff. + * + * A line value of 2 will be centered verticall on the staff. + * + * For notes appearing on a space, the line value will be half-way + * between two integers. */ +static double +_score_staff_pitch_to_line (score_staff_t *staff, pitch_t pitch) +{ + pitch_name_t name = PITCH_NAME (pitch); + int octave = PITCH_OCTAVE (pitch); + int c_line = _score_clef_c_line (staff->clef); + + return c_line - (name - PITCH_NAME_C) / 2.0 - 3.5 * (octave - 4); +} + +/* chord->width is updated as a side effect */ +static void +_draw_chord (score_t *score, cairo_t *cr, + score_staff_t *staff, score_chord_t *chord) +{ + PangoRectangle ink_extents; + PangoRectangle logical_extents; + double total_staff_height; + PangoLayout *layout; + PangoFontDescription *font_description; + + /* XXX: The staff should manage this height itself. */ + total_staff_height = (staff->upper_ledger_lines * score->space_height + + score->staff_height + + staff->lower_ledger_lines * score->space_height); + + cairo_save (cr); + + font_description = pango_font_description_new (); + pango_font_description_set_family (font_description, "serif"); + pango_font_description_set_absolute_size (font_description, + score->space_height * 3 * PANGO_SCALE); + + layout = pango_cairo_create_layout (cr); + pango_layout_set_font_description (layout, font_description); + pango_layout_set_markup (layout, chord->name, -1); + + pango_layout_line_get_pixel_extents (pango_layout_get_line (layout, 0), + &ink_extents, &logical_extents); + + if (staff->clef == SCORE_CLEF_G) + cairo_move_to (cr, 0, - score->space_height * 0.5); + else + cairo_move_to (cr, 0, score->space_height * 0.5 + total_staff_height + + logical_extents.height); + + pango_cairo_show_layout_line (cr, pango_layout_get_line (layout, 0)); + + g_object_unref (layout); + pango_font_description_free (font_description); + + chord->width = logical_extents.width; + + cairo_restore (cr); +} + +/* Draw 'note' with accidental (if not NATURAL) at its correct + * position on 'staff'. + * + * 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) +{ + double line; + cairo_glyph_t note_glyph[2]; + static double extend_factor = 0.25; + cairo_text_extents_t extents; + int num_glyphs = 0; + + void _draw_ledger_line (double line, double offset, double width) { + cairo_move_to (cr, offset - extend_factor * width / 2.0, + score->space_height * line + score->line_width / 2.0); + cairo_rel_line_to (cr, (1 + extend_factor) * width, 0); + cairo_stroke (cr); + } + + cairo_save (cr); + + /* Move right so that X==0 is natural position for non-displaced + * noteheads. + */ + cairo_translate (cr, score->space_height, 0); + + /* Which line should the note appear on? Line 0 is the top line of + * the staff and increasing downwards. (Negative values indicate a + * note on a ledger line above the staff). Values half way between + * integers indicate notes appearing on a space between two staff + * lines (or ledger lines). */ + line = _score_staff_pitch_to_line (staff, note->pitch); + + cairo_select_font_face (cr, "Gonville-26", 0, 0); + cairo_set_font_size (cr, score->staff_height); + + /* XXX: The hard-coded glyph indices here are very ugly. We should + * figure out how to lookup glyphs by name from this font. */ + switch (PITCH_ACCIDENTAL (note->pitch)) { + case PITCH_ACCIDENTAL_DOUBLE_FLAT: + note_glyph[num_glyphs].index = 77; + break; + case PITCH_ACCIDENTAL_FLAT: + note_glyph[num_glyphs].index = 68; + break; + case PITCH_ACCIDENTAL_NATURAL: + note_glyph[num_glyphs].index = 101; + break; + case PITCH_ACCIDENTAL_SHARP: + note_glyph[num_glyphs].index = 134; + break; + case PITCH_ACCIDENTAL_DOUBLE_SHARP: + note_glyph[num_glyphs].index = 142; + break; + } + + if (PITCH_ACCIDENTAL (note->pitch) != PITCH_ACCIDENTAL_NATURAL) + { + note_glyph[num_glyphs].x = 0; + + note_glyph[num_glyphs].y = score->space_height * line; + + num_glyphs++; + + cairo_glyph_extents (cr, note_glyph, num_glyphs, &extents); + +#define ACCIDENTAL_NOTE_SPACING (score->space_height * .15) + + note_glyph[0].x = - (extents.width + ACCIDENTAL_NOTE_SPACING); + } + + /* 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; + + num_glyphs++; + } + + cairo_glyph_extents (cr, note_glyph, num_glyphs, &extents); + + if (line < 0 || line > 4) { + double offset, width; + int i; + + offset = note_glyph[0].x + extents.x_bearing; + width = extents.width; + + if (line < 0) { + for (i = -1; i >= line; i--) + _draw_ledger_line (i, offset, width); + } else { + for (i = 5; i <= line; i++) + _draw_ledger_line (i, offset, width); + } + } + + cairo_set_source_rgb (cr, + note->color.r, + note->color.g, + note->color.b); + 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, ¬e); +} + +static void +_draw_sharps_key_signature (score_t *score, cairo_t *cr, + score_staff_t *staff, int num_sharps) +{ + 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) + }; + + for (i = 0; i < 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); + } +} + +static void +_draw_flats_key_signature (score_t *score, cairo_t *cr, + score_staff_t *staff, int num_flats) { - SCORE_CLEF_G, - SCORE_CLEF_F -} score_clef_t; + pitch_t pitch; + double width; + int i; + + /* These octave numbers are correct for treble clef. For bass + * clef, subtract two. + */ + pitch_name_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 < 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 -_draw_staff (score_t *score, cairo_t *cr, score_clef_t clef) +_draw_key_signature (score_t *score, cairo_t *cr, + score_staff_t *staff, pitch_t key) { int i; - cairo_glyph_t glyph; + + pitch_t sharp_keys[] = { + PITCH_CLASS_LITERAL (C, NATURAL), + PITCH_CLASS_LITERAL (G, NATURAL), + PITCH_CLASS_LITERAL (D, NATURAL), + PITCH_CLASS_LITERAL (A, NATURAL), + PITCH_CLASS_LITERAL (E, NATURAL), + PITCH_CLASS_LITERAL (B, NATURAL), + PITCH_CLASS_LITERAL (F, SHARP), + PITCH_CLASS_LITERAL (C, SHARP), + }; + + pitch_t flat_keys[] = { + PITCH_CLASS_LITERAL (C, NATURAL), + PITCH_CLASS_LITERAL (F, NATURAL), + PITCH_CLASS_LITERAL (B, FLAT), + PITCH_CLASS_LITERAL (E, FLAT), + PITCH_CLASS_LITERAL (A, FLAT), + PITCH_CLASS_LITERAL (D, FLAT), + PITCH_CLASS_LITERAL (G, FLAT), + PITCH_CLASS_LITERAL (C, FLAT) + }; + + for (i = 0; i < ARRAY_SIZE (sharp_keys); i++) { + if (sharp_keys[i] == key) { + _draw_sharps_key_signature (score, cr, staff, i); + return; + } + } + + for (i = 0; i < ARRAY_SIZE (flat_keys); i++) { + if (flat_keys[i] == key) { + _draw_flats_key_signature (score, cr, staff, i); + return; + } + } + + fprintf (stderr, "Internal error: Not a key: %s\n", pitch_string (key)); + exit (1); +} + +static void +_draw_staff (score_t *score, cairo_t *cr, + score_staff_t *staff, int staff_width) +{ + int i; + cairo_glyph_t clef_glyph; + cairo_text_extents_t clef_extents; cairo_save (cr); + cairo_translate (cr, 0, staff->y_pos); + cairo_select_font_face (cr, "Gonville-26", 0, 0); - /* XXX: This font size is a rough guess at best. We should figure - * out to correctly measure, size, and place clefs. */ - cairo_set_font_size (cr, 24); + 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 (clef) { + switch (staff->clef) { case SCORE_CLEF_G: default: - glyph.index = 46; - glyph.y = 3 * score->space_height; + clef_glyph.index = 46; + clef_glyph.y = 3 * score->space_height; break; case SCORE_CLEF_F: - glyph.index = 45; - glyph.y = 1 * score->space_height; + clef_glyph.index = 45; + clef_glyph.y = 1 * score->space_height; break; } - glyph.x = 2; + clef_glyph.x = 3 * score->line_width; + clef_glyph.y += score->line_width / 2.0; cairo_set_source_rgb (cr, 0.0, 0.0, 0.0); /* black */ - cairo_show_glyphs (cr, &glyph, 1); + cairo_show_glyphs (cr, &clef_glyph, 1); - cairo_rectangle (cr, - 0.5, 0.5, - score->width - 1.0, score->space_height * 4); - - for (i = 1; i < 4; i++) { - cairo_move_to (cr, 0, i * score->space_height + 0.5); - cairo_rel_line_to (cr, score->width, 0); - } + /* Make space for clef */ + cairo_glyph_extents (cr, &clef_glyph, 1, &clef_extents); - cairo_set_line_width (cr, 1.0); +#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, score->key); + + /* Draw chord symbols */ + cairo_save (cr); + { + for (i = 0; i < staff->num_chords; i++) { + _draw_chord (score, cr, staff, staff->chords[i]); + cairo_translate (cr, staff->chords[i]->width, 0.0); + } + } + cairo_restore (cr); + + /* Draw notes */ + for (i = 0; i < staff->num_notes; i++) { + _draw_note (score, cr, staff, staff->notes[i]); + /* Draw all notes concurrent for now (as a chord) + cairo_translate (cr, score->space_height * 2.0, 0); + */ + } cairo_restore (cr); } -static void -_draw_grand_staff (score_t *score, cairo_t *cr) +void +score_draw (score_t *score, cairo_t *cr) { -#define BRACE_GLYPHS 1 - cairo_glyph_t brace; - cairo_save (cr); + int i; + int staff_width = score->width; + int staff_y_pos; - /* Brace test */ - cairo_select_font_face (cr, "Gonville-Brace", 0, 0); + if (score->num_staves == 0) + return; - /* XXX: This font size (in conjunction with the glyph selection) - * is a rough guess at best. We should figure out how the brace - * font is intended to be used and actually measure to find the - * correctly sized glyph. */ - cairo_set_font_size (cr, 40); + cairo_save (cr); - cairo_translate (cr, 5, 0); - score->width -= 5; + /* Before drawing anything, position each staff based on the size + * of each (including ledger lines) */ + staff_y_pos = 0; + for (i = 0; i < score->num_staves; i++) { + score_staff_t *staff = score->staves[i]; + staff_y_pos += staff->upper_ledger_lines * score->space_height; + staff->y_pos = staff_y_pos; + staff_y_pos += (score->staff_height + + staff->lower_ledger_lines * score->space_height + + score->staff_height); + } - /* XXX: This hard-coded glyph index is pretty ugly. We should - * figure out how to lookup the glyph we want, (though, as it - * turns out, this brace font pretty much just has numbered glyph - * names for different sizes, so it wouldn't be all that different - * than just the bare index here). */ - brace.index = 185; - brace.x = 0; - brace.y = score->staff_height * 1.5; + if (score->num_braces) + { + /* Initialize to keep the compiler quiet. */ + int brace_width = 0; - cairo_set_source_rgb (cr, 0.0, 0.0, 0.0); /* black */ - cairo_show_glyphs (cr, &brace, 1); + for (i = 0; i < score->num_braces; i++) + _draw_brace (score, cr, score->braces[i], &brace_width); - cairo_translate (cr, 2, 0); - score->width -= 2; + /* Subtract space for brace itself */ + cairo_translate (cr, brace_width, 0); + staff_width -= brace_width; + + /* As well as some padding */ + cairo_translate (cr, 2, 0); + staff_width -= 2; + } /* Vertical lines at each end */ cairo_rectangle (cr, - 0.5, 0.5, - score->width - 1.0, - score->staff_height * 3); + score->line_width / 2.0, + score->staves[0]->y_pos + score->line_width / 2.0, + staff_width - score->line_width, + score->staves[score->num_staves-1]->y_pos + score->staff_height - score->staves[0]->y_pos); cairo_set_source_rgb (cr, 0.0, 0.0, 0.0); /* black */ - cairo_set_line_width (cr, 1.0); + cairo_set_line_width (cr, score->line_width); cairo_stroke (cr); - /* Top staff */ - _draw_staff (score, cr, SCORE_CLEF_G); - - /* Bottom staff */ - cairo_translate (cr, 0, score->staff_height * 2); - _draw_staff (score, cr, SCORE_CLEF_F); + for (i = 0; i < score->num_staves; i++) { + score_staff_t *staff = score->staves[i]; + _draw_staff (score, cr, staff, staff_width); + } cairo_restore (cr); } void -score_draw (score_t *score, cairo_t *cr) +score_add_brace (score_t *score, int staves) { - _draw_grand_staff (score, cr); + score_brace_t *brace; + + brace = talloc (score, score_brace_t); + if (brace == NULL) + return; + + brace->first_staff = score->num_staves; + brace->num_staves = staves; + + score->num_braces++; + score->braces = talloc_realloc (score, + score->braces, + score_brace_t*, + score->num_braces); + if (score->braces == NULL) { + score->num_braces = 0; + return; + } + + score->braces[score->num_braces - 1] = brace; + +} + +score_staff_t * +score_add_staff (score_t *score, score_clef_t clef) +{ + score_staff_t *staff; + + staff = talloc (score, score_staff_t); + if (staff == NULL) + return NULL; + + staff->clef = clef; + + staff->notes = NULL; + staff->num_notes = 0; + + staff->chords = NULL; + staff->num_chords = 0; + + staff->upper_ledger_lines = 0; + staff->lower_ledger_lines = 0; + + score->num_staves++; + score->staves = talloc_realloc (score, + score->staves, + score_staff_t*, + score->num_staves); + if (score->staves == NULL) { + score->num_staves = 0; + return NULL; + } + + score->staves[score->num_staves - 1] = staff; + + return staff; +} + +score_chord_t * +score_add_chord (score_staff_t *staff, + const char *name) +{ + score_chord_t *chord; + + chord = talloc (staff, score_chord_t); + if (chord == NULL) + return NULL; + + talloc_steal (chord, name); + + chord->staff = staff; + chord->name = talloc_strdup (chord, name); + + /* The width will get set correctly the first time _draw_chord is + * called. */ + chord->width = 0.0; + + staff->num_chords++; + staff->chords = talloc_realloc (staff, + staff->chords, + score_chord_t*, + staff->num_chords); + if (staff->chords == NULL) { + staff->num_chords = 0; + return NULL; + } + + staff->chords[staff->num_chords - 1] = chord; + + return chord; +} + +void +score_staff_remove_chords (score_staff_t *staff) +{ + talloc_free (staff->chords); + staff->chords = NULL; + + staff->num_chords = 0; +} + +void +score_remove_chords (score_t *score) +{ + int i; + + for (i = 0; i < score->num_staves; i++) + score_staff_remove_chords (score->staves[i]); +} + +void +score_staff_add_note (score_staff_t *staff, + pitch_t pitch, + score_duration_t duration) +{ + score_note_t *note; + double line; + int i; + + /* Return existing note if already present. */ + for (i = 0; i < staff->num_notes; i++) { + note = staff->notes[i]; + if (note->pitch == pitch && + note->duration == duration) + { + return; + } + } + + note = talloc (staff, score_note_t); + if (note == NULL) + return; + + note->staff = staff; + note->pitch = pitch; + note->duration = duration; + + note->color.r = 0.0; + note->color.g = 0.0; + note->color.b = 0.0; + + line = _score_staff_pitch_to_line (staff, note->pitch); + if (line < 0) { + int lines = (int) (- line); + if (lines > staff->upper_ledger_lines) + staff->upper_ledger_lines = lines; + } else { + int lines = (int) (line - 4); + if (lines > staff->lower_ledger_lines) + staff->lower_ledger_lines = lines; + } + + staff->num_notes++; + staff->notes = talloc_realloc (staff, + staff->notes, + score_note_t*, + staff->num_notes); + if (staff->notes == NULL) { + staff->num_notes = 0; + return; + } + + staff->notes[staff->num_notes - 1] = note; +} + +void +score_add_note (score_t *score, pitch_t pitch, score_duration_t duration) +{ + score_staff_t *staff, *nearest_staff = NULL; + double distance, nearest_distance = 0.0; + int i; + + /* Nothing to do if we have no staff, (there's no place to add a note) . */ + if (score->num_staves == 0) + return; + + /* Find the staff where the note will be closest to the center of + * the staff. */ + for (i = 0; i < score->num_staves; i++) { + staff = score->staves[i]; + distance = fabs (_score_staff_pitch_to_line (staff, pitch) - 2.0); + if (nearest_staff == NULL || distance < nearest_distance) { + nearest_staff = staff; + nearest_distance = distance; + } + } + + score_staff_add_note (nearest_staff, pitch, duration); +} + +void +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 +score_remove_notes (score_t *score) +{ + int i; + + for (i = 0; i < score->num_staves; i++) + score_staff_remove_notes (score->staves[i]); }