X-Git-Url: https://git.cworth.org/git?a=blobdiff_plain;f=score.c;h=0a6016bcb706785db4460460a37ebdde235a8563;hb=54d2b1cb13bf52df22c93e58377a00b757644b94;hp=fe7622d85e4acd5c4fc45cd707df961017995380;hpb=73ba6a9e9a9308747fd0fa301e1a349746eaf47c;p=scherzo diff --git a/score.c b/score.c index fe7622d..0a6016b 100644 --- a/score.c +++ b/score.c @@ -18,10 +18,28 @@ * 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; @@ -60,6 +78,9 @@ struct score /* 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; @@ -83,6 +104,9 @@ score_create (void *ctx) /* 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; @@ -111,6 +135,12 @@ score_set_width (score_t *score, int width) score->width = width; } +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, @@ -172,13 +202,25 @@ _score_clef_c_line (score_clef_t clef) } } +/* 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_note_to_line (score_staff_t *staff, score_note_t *note) +_score_staff_pitch_to_line (score_staff_t *staff, pitch_t pitch) { - score_pitch_name_t name = SCORE_PITCH_NAME (note->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 - SCORE_PITCH_NAME_C) / 2.0 - 3.5 * (note->octave - 4); + return c_line - (name - PITCH_NAME_C) / 2.0 - 3.5 * (octave - 4); } /* chord->width is updated as a side effect */ @@ -186,8 +228,11 @@ static void _draw_chord (score_t *score, cairo_t *cr, score_staff_t *staff, score_chord_t *chord) { - cairo_text_extents_t chord_extents; + 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 + @@ -196,24 +241,40 @@ _draw_chord (score_t *score, cairo_t *cr, cairo_save (cr); - cairo_text_extents (cr, chord->name, &chord_extents); + 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); - cairo_select_font_face (cr, "serif", 0, 0); - cairo_set_font_size (cr, score->space_height * 3); + 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 + chord_extents.y_bearing); + cairo_move_to (cr, 0, score->space_height * 0.5 + total_staff_height + + logical_extents.height); - cairo_show_text (cr, chord->name); + pango_cairo_show_layout_line (cr, pango_layout_get_line (layout, 0)); - chord->width = chord_extents.x_advance; + g_object_unref (layout); + pango_font_description_free (font_description); + + chord->width = logical_extents.width; cairo_restore (cr); } -static void +/* 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) { @@ -242,32 +303,32 @@ _draw_note (score_t *score, cairo_t *cr, * 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_note_to_line (staff, note); + 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 (SCORE_PITCH_ACCIDENTAL (note->pitch)) { - case SCORE_PITCH_ACCIDENTAL_DOUBLE_FLAT: + switch (PITCH_ACCIDENTAL (note->pitch)) { + case PITCH_ACCIDENTAL_DOUBLE_FLAT: note_glyph[num_glyphs].index = 77; break; - case SCORE_PITCH_ACCIDENTAL_FLAT: + case PITCH_ACCIDENTAL_FLAT: note_glyph[num_glyphs].index = 68; break; - case SCORE_PITCH_ACCIDENTAL_NATURAL: + case PITCH_ACCIDENTAL_NATURAL: note_glyph[num_glyphs].index = 101; break; - case SCORE_PITCH_ACCIDENTAL_SHARP: + case PITCH_ACCIDENTAL_SHARP: note_glyph[num_glyphs].index = 134; break; - case SCORE_PITCH_ACCIDENTAL_DOUBLE_SHARP: + case PITCH_ACCIDENTAL_DOUBLE_SHARP: note_glyph[num_glyphs].index = 142; break; } - if (SCORE_PITCH_ACCIDENTAL (note->pitch) != SCORE_PITCH_ACCIDENTAL_NATURAL) + if (PITCH_ACCIDENTAL (note->pitch) != PITCH_ACCIDENTAL_NATURAL) { note_glyph[num_glyphs].x = 0; @@ -282,33 +343,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; @@ -328,6 +394,147 @@ _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, ¬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) +{ + 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_key_signature (score_t *score, cairo_t *cr, + score_staff_t *staff, pitch_t key) +{ + int i; + + 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 @@ -336,6 +543,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); @@ -345,6 +553,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) { @@ -364,19 +585,15 @@ _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); - - cairo_set_source_rgb (cr, 0.0, 0.0, 0.0); /* black */ - cairo_stroke (cr); +#define CLEF_KEY_SIGNATURE_SPACING (score->space_height * .75) + cairo_translate (cr, ceil (clef_extents.width + + CLEF_KEY_SIGNATURE_SPACING), 0); - /* Make space for clef before drawing notes */ - cairo_translate (cr, (int) (4 * score->space_height), 0); + /* Draw the key signature */ + _draw_key_signature (score, cr, staff, score->key); /* Draw chord symbols */ cairo_save (cr); @@ -425,7 +642,8 @@ score_draw (score_t *score, cairo_t *cr) if (score->num_braces) { - int brace_width; + /* Initialize to keep the compiler quiet. */ + int brace_width = 0; for (i = 0; i < score->num_braces; i++) _draw_brace (score, cr, score->braces[i], &brace_width); @@ -553,33 +771,27 @@ 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 * -score_add_note (score_staff_t *staff, - score_pitch_t pitch, - int octave, - score_duration_t duration) +void +score_staff_add_note (score_staff_t *staff, + pitch_t pitch, + score_duration_t duration) { score_note_t *note; double line; @@ -589,27 +801,25 @@ score_add_note (score_staff_t *staff, for (i = 0; i < staff->num_notes; i++) { note = staff->notes[i]; if (note->pitch == pitch && - note->octave == octave && note->duration == duration) { - return note; + return; } } note = talloc (staff, score_note_t); if (note == NULL) - return NULL; + return; note->staff = staff; note->pitch = pitch; - note->octave = octave; note->duration = duration; note->color.r = 0.0; note->color.g = 0.0; note->color.b = 0.0; - line = _score_note_to_line (staff, note); + line = _score_staff_pitch_to_line (staff, note->pitch); if (line < 0) { int lines = (int) (- line); if (lines > staff->upper_ledger_lines) @@ -627,72 +837,53 @@ score_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; } void -score_remove_note (score_note_t *note) +score_add_note (score_t *score, pitch_t pitch, score_duration_t duration) { - score_staff_t *staff = note->staff; + score_staff_t *staff, *nearest_staff = NULL; + double distance, nearest_distance = 0.0; int i; - for (i = 0; i < staff->num_notes; i++) - if (staff->notes[i] == note) - break; - - if (i == staff->num_notes) + /* Nothing to do if we have no staff, (there's no place to add a note) . */ + if (score->num_staves == 0) return; - if (i < staff->num_notes - 1) - { - memmove (staff->notes + i, - staff->notes + i + 1, - (staff->num_notes - 1 - i) * sizeof (score_note_t *)); + /* 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; + } } - 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 -score_set_note_color_rgb (score_note_t *note, - double r, - double g, - double b) +score_staff_remove_notes (score_staff_t *staff) { - note->color.r = r; - note->color.g = g; - note->color.b = b; + talloc_free (staff->notes); + staff->notes = NULL; + staff->num_notes = 0; + + staff->upper_ledger_lines = 0; + staff->lower_ledger_lines = 0; } -score_note_t * -score_staff_find_note (score_staff_t *staff, - score_pitch_t pitch, - int octave, - score_duration_t duration) +void +score_remove_notes (score_t *score) { int i; - score_note_t *note; - for (i = 0; i < staff->num_notes; i++) { - note = staff->notes[i]; - if (note->pitch == pitch && - note->octave == octave && - note->duration == duration) - { - return note; - } - } - - return NULL; + for (i = 0; i < score->num_staves; i++) + score_staff_remove_notes (score->staves[i]); } -