Port all code from score_pitch* to pitch*

Tracking the new interface in pitch.h, (and deleting the compatibility
defines from score.h).

diff --git a/scherzo.c b/scherzo.c
index 8152418adfa8bc2bda1f235d48c91bb7c5c70f85..1f2fed753fae1aacefbd706b5cdfb7a5142dd9ad 100644 (file)
--- a/scherzo.c
+++ b/scherzo.c
@@ -64,7 +64,7 @@ typedef struct scherzo
      * keyboard". Any "piano keyboard" key knows its own octave and
      * accidental already. */
     int keyboard_octave;
-    score_pitch_accidental_t keyboard_accidental;
+    pitch_accidental_t keyboard_accidental;
 
     int midi_fd;
     snd_midi_event_t *snd_midi_event;
@@ -80,10 +80,10 @@ typedef struct scherzo
 
 /* Forward declarations. */
 static score_note_t *
-scherzo_press_note (scherzo_t *scherzo, score_pitch_t pitch, int octave);
+scherzo_press_note (scherzo_t *scherzo, pitch_t pitch, int octave);
 
 static void
-scherzo_release_note (scherzo_t *scherzo, score_pitch_t pitch, int octave);
+scherzo_release_note (scherzo_t *scherzo, pitch_t pitch, int octave);
 
 static void
 scherzo_press_pedal (scherzo_t *scherzo);
@@ -148,8 +148,8 @@ on_key_press_event (GtkWidget *widget,
     scherzo_t *scherzo = user_data;
     int octave;
     /* Initialize to keep the compiler quiet. */
-    score_pitch_name_t pitch_name = SCORE_PITCH_C;
-    score_pitch_t pitch;
+    pitch_name_t pitch_name = PITCH_C;
+    pitch_t pitch;
 
     if (scherzo->challenge.note)
        octave = scherzo->challenge.note->octave;
@@ -178,31 +178,31 @@ on_key_press_event (GtkWidget *widget,
        return FALSE;
     case GDK_KEY_c:
     case GDK_KEY_C:
-       pitch_name = SCORE_PITCH_NAME_C;
+       pitch_name = PITCH_NAME_C;
        break;
     case GDK_KEY_d:
     case GDK_KEY_D:
-       pitch_name = SCORE_PITCH_NAME_D;
+       pitch_name = PITCH_NAME_D;
        break;
     case GDK_KEY_e:
     case GDK_KEY_E:
-       pitch_name = SCORE_PITCH_NAME_E;
+       pitch_name = PITCH_NAME_E;
        break;
     case GDK_KEY_f:
     case GDK_KEY_F:
-       pitch_name = SCORE_PITCH_NAME_F;
+       pitch_name = PITCH_NAME_F;
        break;
     case GDK_KEY_g:
     case GDK_KEY_G:
-       pitch_name = SCORE_PITCH_NAME_G;
+       pitch_name = PITCH_NAME_G;
        break;
     case GDK_KEY_a:
     case GDK_KEY_A:
-       pitch_name = SCORE_PITCH_NAME_A;
+       pitch_name = PITCH_NAME_A;
        break;
     case GDK_KEY_b:
     case GDK_KEY_B:
-       pitch_name = SCORE_PITCH_NAME_B;
+       pitch_name = PITCH_NAME_B;
        break;
     case GDK_KEY_0:
     case GDK_KEY_1:
@@ -219,16 +219,16 @@ on_key_press_event (GtkWidget *widget,
        scherzo_press_pedal (scherzo);
        break;
     case GDK_KEY_Up:
-       if (scherzo->keyboard_accidental < SCORE_PITCH_ACCIDENTAL_DOUBLE_SHARP)
+       if (scherzo->keyboard_accidental < PITCH_ACCIDENTAL_DOUBLE_SHARP)
            scherzo->keyboard_accidental++;
        break;
     case GDK_KEY_Down:
-       if (scherzo->keyboard_accidental > SCORE_PITCH_ACCIDENTAL_DOUBLE_FLAT)
+       if (scherzo->keyboard_accidental > PITCH_ACCIDENTAL_DOUBLE_FLAT)
            scherzo->keyboard_accidental--;
        break;
     }
 
-    pitch = SCORE_PITCH (pitch_name, scherzo->keyboard_accidental);
+    pitch = PITCH (pitch_name, scherzo->keyboard_accidental);
 
     if ((key->keyval >= GDK_KEY_A && key->keyval <= GDK_KEY_G) ||
        (key->keyval >= GDK_KEY_a && key->keyval <= GDK_KEY_g))
@@ -255,8 +255,8 @@ on_key_release_event (unused (GtkWidget *widget),
     scherzo_t *scherzo = user_data;
     int octave;
     /* Initialize to keep the compiler quiet. */
-    score_pitch_name_t pitch_name = SCORE_PITCH_NAME_C;
-    score_pitch_t pitch;
+    pitch_name_t pitch_name = PITCH_NAME_C;
+    pitch_t pitch;
 
     if (scherzo->challenge.note)
        octave = scherzo->challenge.note->octave;
@@ -266,38 +266,38 @@ on_key_release_event (unused (GtkWidget *widget),
     switch (key->keyval) {
     case GDK_KEY_c:
     case GDK_KEY_C:
-       pitch_name = SCORE_PITCH_NAME_C;
+       pitch_name = PITCH_NAME_C;
        break;
     case GDK_KEY_d:
     case GDK_KEY_D:
-       pitch_name = SCORE_PITCH_NAME_D;
+       pitch_name = PITCH_NAME_D;
        break;
     case GDK_KEY_e:
     case GDK_KEY_E:
-       pitch_name = SCORE_PITCH_NAME_E;
+       pitch_name = PITCH_NAME_E;
        break;
     case GDK_KEY_f:
     case GDK_KEY_F:
-       pitch_name = SCORE_PITCH_NAME_F;
+       pitch_name = PITCH_NAME_F;
        break;
     case GDK_KEY_g:
     case GDK_KEY_G:
-       pitch_name = SCORE_PITCH_NAME_G;
+       pitch_name = PITCH_NAME_G;
        break;
     case GDK_KEY_a:
     case GDK_KEY_A:
-       pitch_name = SCORE_PITCH_NAME_A;
+       pitch_name = PITCH_NAME_A;
        break;
     case GDK_KEY_b:
     case GDK_KEY_B:
-       pitch_name = SCORE_PITCH_NAME_B;
+       pitch_name = PITCH_NAME_B;
        break;
     case GDK_KEY_space:
        scherzo_release_pedal (scherzo);
        break;
     }
 
-    pitch = SCORE_PITCH (pitch_name, scherzo->keyboard_accidental);
+    pitch = PITCH (pitch_name, scherzo->keyboard_accidental);
 
     if ((key->keyval >= GDK_KEY_A && key->keyval <= GDK_KEY_G) ||
        (key->keyval >= GDK_KEY_a && key->keyval <= GDK_KEY_g))
@@ -315,47 +315,47 @@ on_key_release_event (unused (GtkWidget *widget),
 }
 
 static unsigned char
-_score_pitch_and_octave_to_midi (score_pitch_t pitch,
+_pitch_and_octave_to_midi (pitch_t pitch,
                                 int octave)
 {
     unsigned char midi_note = 12 * (octave + 1);
 
-    switch (SCORE_PITCH_NAME (pitch)) {
-    case SCORE_PITCH_NAME_C:
+    switch (PITCH_NAME (pitch)) {
+    case PITCH_NAME_C:
        break;
-    case SCORE_PITCH_NAME_D:
+    case PITCH_NAME_D:
        midi_note += 2;
        break;
-    case SCORE_PITCH_NAME_E:
+    case PITCH_NAME_E:
        midi_note += 4;
        break;
-    case SCORE_PITCH_NAME_F:
+    case PITCH_NAME_F:
        midi_note += 5;
        break;
-    case SCORE_PITCH_NAME_G:
+    case PITCH_NAME_G:
        midi_note += 7;
        break;
-    case SCORE_PITCH_NAME_A:
+    case PITCH_NAME_A:
        midi_note += 9;
        break;
-    case SCORE_PITCH_NAME_B:
+    case PITCH_NAME_B:
        midi_note += 11;
        break;
     }
 
-    switch (SCORE_PITCH_ACCIDENTAL (pitch)) {
-    case SCORE_PITCH_ACCIDENTAL_DOUBLE_FLAT:
+    switch (PITCH_ACCIDENTAL (pitch)) {
+    case PITCH_ACCIDENTAL_DOUBLE_FLAT:
        midi_note -= 2;
        break;
-    case SCORE_PITCH_ACCIDENTAL_FLAT:
+    case PITCH_ACCIDENTAL_FLAT:
        midi_note -= 1;
        break;
-    case SCORE_PITCH_ACCIDENTAL_NATURAL:
+    case PITCH_ACCIDENTAL_NATURAL:
        break;
-    case SCORE_PITCH_ACCIDENTAL_SHARP:
+    case PITCH_ACCIDENTAL_SHARP:
        midi_note += 1;
        break;
-    case SCORE_PITCH_ACCIDENTAL_DOUBLE_SHARP:
+    case PITCH_ACCIDENTAL_DOUBLE_SHARP:
        midi_note += 2;
        break;
     }
@@ -365,8 +365,8 @@ _score_pitch_and_octave_to_midi (score_pitch_t pitch,
 
 /* octave can optionally by NULL */
 static void
-_midi_to_score_pitch_and_octave (unsigned char midi_note,
-                                score_pitch_t *pitch,
+_midi_to_pitch_and_octave (unsigned char midi_note,
+                                pitch_t *pitch,
                                 int *octave)
 {
     if (octave)
@@ -375,40 +375,40 @@ _midi_to_score_pitch_and_octave (unsigned char midi_note,
     switch (midi_note % 12)
     {
     case 0:
-       *pitch = SCORE_PITCH_C;
+       *pitch = PITCH_C;
        break;
     case 1:
-       *pitch = SCORE_PITCH_Cs;
+       *pitch = PITCH_Cs;
        break;
     case 2:
-       *pitch = SCORE_PITCH_D;
+       *pitch = PITCH_D;
        break;
     case 3:
-       *pitch = SCORE_PITCH_Ds;
+       *pitch = PITCH_Ds;
        break;
     case 4:
-       *pitch = SCORE_PITCH_E;
+       *pitch = PITCH_E;
        break;
     case 5:
-       *pitch = SCORE_PITCH_F;
+       *pitch = PITCH_F;
        break;
     case 6:
-       *pitch = SCORE_PITCH_Fs;
+       *pitch = PITCH_Fs;
        break;
     case 7:
-       *pitch = SCORE_PITCH_G;
+       *pitch = PITCH_G;
        break;
     case 8:
-       *pitch = SCORE_PITCH_Gs;
+       *pitch = PITCH_Gs;
        break;
     case 9:
-       *pitch = SCORE_PITCH_A;
+       *pitch = PITCH_A;
        break;
     case 10:
-       *pitch = SCORE_PITCH_As;
+       *pitch = PITCH_As;
        break;
     case 11:
-       *pitch = SCORE_PITCH_B;
+       *pitch = PITCH_B;
        break;
     }
 }
@@ -494,10 +494,10 @@ _modified_degree_to_half_steps (const modified_degree_t *degree)
 /* Number of half steps from 'root' up to 'pitch' (that is, counting
  * the steps up a chromatic scale). */
 static int
-_pitch_from_root_in_half_steps (score_pitch_t pitch, score_pitch_t root)
+_pitch_from_root_in_half_steps (pitch_t pitch, pitch_t root)
 {
-    int root_midi = _score_pitch_and_octave_to_midi (root, 0);
-    int pitch_midi = _score_pitch_and_octave_to_midi (pitch, 0);
+    int root_midi = _pitch_and_octave_to_midi (root, 0);
+    int pitch_midi = _pitch_and_octave_to_midi (pitch, 0);
 
     if (pitch_midi < root_midi)
        pitch_midi += 12;
@@ -516,7 +516,7 @@ _chord_signature_matches (analyzed_note_t *notes,
                          modified_degree_t *degrees,
                          int num_degrees,
                          int inversion,
-                         score_pitch_t *root)
+                         pitch_t *root)
 {
 #define MAX_DEGREES 6
     int relative_pitches[MAX_DEGREES];
@@ -558,78 +558,78 @@ _chord_signature_matches (analyzed_note_t *notes,
 }
 
 static const char *
-_pitch_str (score_pitch_t pitch)
+_pitch_str (pitch_t pitch)
 {
     switch (pitch) {
-    case SCORE_PITCH_Cff:
+    case PITCH_Cff:
        return "C𝄫";
-    case SCORE_PITCH_Cf:
+    case PITCH_Cf:
        return "C♭";
-    case SCORE_PITCH_C:
+    case PITCH_C:
        return "C";
-    case SCORE_PITCH_Cs:
+    case PITCH_Cs:
        return "C♯";
-    case SCORE_PITCH_Css:
+    case PITCH_Css:
        return "C𝄪";
-    case SCORE_PITCH_Dff:
+    case PITCH_Dff:
        return "D𝄫";
-    case SCORE_PITCH_Df:
+    case PITCH_Df:
        return "D♭";
-    case SCORE_PITCH_D:
+    case PITCH_D:
        return "D";
-    case SCORE_PITCH_Ds:
+    case PITCH_Ds:
        return "D♯";
-    case SCORE_PITCH_Dss:
+    case PITCH_Dss:
        return "D𝄪";
-    case SCORE_PITCH_Eff:
+    case PITCH_Eff:
        return "E𝄫";
-    case SCORE_PITCH_Ef:
+    case PITCH_Ef:
        return "E♭";
-    case SCORE_PITCH_E:
+    case PITCH_E:
        return "E";
-    case SCORE_PITCH_Es:
+    case PITCH_Es:
        return "E♯";
-    case SCORE_PITCH_Ess:
+    case PITCH_Ess:
        return "E𝄪";
-    case SCORE_PITCH_Fff:
+    case PITCH_Fff:
        return "F𝄫";
-    case SCORE_PITCH_Ff:
+    case PITCH_Ff:
        return "F♭";
-    case SCORE_PITCH_F:
+    case PITCH_F:
        return "F";
-    case SCORE_PITCH_Fs:
+    case PITCH_Fs:
        return "F♯";
-    case SCORE_PITCH_Fss:
+    case PITCH_Fss:
        return "F𝄪";
-    case SCORE_PITCH_Gff:
+    case PITCH_Gff:
        return "G𝄫";
-    case SCORE_PITCH_Gf:
+    case PITCH_Gf:
        return "G♭";
-    case SCORE_PITCH_G:
+    case PITCH_G:
        return "G";
-    case SCORE_PITCH_Gs:
+    case PITCH_Gs:
        return "G♯";
-    case SCORE_PITCH_Gss:
+    case PITCH_Gss:
        return "G𝄪";
-    case SCORE_PITCH_Aff:
+    case PITCH_Aff:
        return "A𝄫";
-    case SCORE_PITCH_Af:
+    case PITCH_Af:
        return "A♭";
-    case SCORE_PITCH_A:
+    case PITCH_A:
        return "A";
-    case SCORE_PITCH_As:
+    case PITCH_As:
        return "A♯";
-    case SCORE_PITCH_Ass:
+    case PITCH_Ass:
        return "A𝄪";
-    case SCORE_PITCH_Bff:
+    case PITCH_Bff:
        return "B𝄫";
-    case SCORE_PITCH_Bf:
+    case PITCH_Bf:
        return "B♭";
-    case SCORE_PITCH_B:
+    case PITCH_B:
        return "B";
-    case SCORE_PITCH_Bs:
+    case PITCH_Bs:
        return "B♯";
-    case SCORE_PITCH_Bss:
+    case PITCH_Bss:
        return "B𝄪";
     }
 
@@ -787,15 +787,15 @@ chord_signature_t signatures[] = {
 
 static void
 scherzo_adjust_note_to_match_modified_degree (score_note_t *note,
-                                             score_pitch_t root,
+                                             pitch_t root,
                                              modified_degree_t *degree)
 {
-    score_pitch_name_t name = SCORE_PITCH_NAME (note->pitch);
-    score_pitch_accidental_t accidental = SCORE_PITCH_ACCIDENTAL (note->pitch);
+    pitch_name_t name = PITCH_NAME (note->pitch);
+    pitch_accidental_t accidental = PITCH_ACCIDENTAL (note->pitch);
     int degree_zero_based = (degree->degree - 1) % 7;
     int degree_delta;
 
-    int note_degree_zero_based = name - SCORE_PITCH_NAME (root);
+    int note_degree_zero_based = name - PITCH_NAME (root);
     if (note_degree_zero_based < 0)
        note_degree_zero_based += 7;
 
@@ -814,69 +814,69 @@ scherzo_adjust_note_to_match_modified_degree (score_note_t *note,
     }
 
     if (degree_delta == -1) {
-       if (name == SCORE_PITCH_NAME_B) {
-           name = SCORE_PITCH_NAME_C;
+       if (name == PITCH_NAME_B) {
+           name = PITCH_NAME_C;
            note->octave++;
        } else {
            name++;
        }
        switch (name) {
-       case SCORE_PITCH_NAME_D:
-       case SCORE_PITCH_NAME_E:
-       case SCORE_PITCH_NAME_G:
-       case SCORE_PITCH_NAME_A:
-       case SCORE_PITCH_NAME_B:
+       case PITCH_NAME_D:
+       case PITCH_NAME_E:
+       case PITCH_NAME_G:
+       case PITCH_NAME_A:
+       case PITCH_NAME_B:
            accidental -= 2;
            break;
-       case SCORE_PITCH_NAME_C:
-       case SCORE_PITCH_NAME_F:
+       case PITCH_NAME_C:
+       case PITCH_NAME_F:
            accidental -= 1;
            break;
        }
     }
 
     if (degree_delta == +1) {
-       if (name == SCORE_PITCH_NAME_C) {
-           name = SCORE_PITCH_NAME_B;
+       if (name == PITCH_NAME_C) {
+           name = PITCH_NAME_B;
            note->octave--;
        } else {
            name--;
        }
        switch (name) {
-       case SCORE_PITCH_NAME_C:
-       case SCORE_PITCH_NAME_D:
-       case SCORE_PITCH_NAME_F:
-       case SCORE_PITCH_NAME_G:
-       case SCORE_PITCH_NAME_A:
+       case PITCH_NAME_C:
+       case PITCH_NAME_D:
+       case PITCH_NAME_F:
+       case PITCH_NAME_G:
+       case PITCH_NAME_A:
            accidental += 2;
            break;
-       case SCORE_PITCH_NAME_E:
-       case SCORE_PITCH_NAME_B:
+       case PITCH_NAME_E:
+       case PITCH_NAME_B:
            accidental += 1;
        }
     }
 
-    if (accidental < 0 || accidental > SCORE_PITCH_ACCIDENTAL_DOUBLE_SHARP) {
+    if (accidental < 0 || accidental > PITCH_ACCIDENTAL_DOUBLE_SHARP) {
        fprintf (stderr, "Internal error: Trying to adjust an accidental out of range (degree_delta == %d (%d - %d), new accidental == %d).\n", degree_delta, note_degree_zero_based, degree_zero_based, accidental);
        exit (1);
     }
 
-    note->pitch = SCORE_PITCH (name, accidental);
+    note->pitch = PITCH (name, accidental);
 }
 
 static void
 _spell_chord_by_signature (note_group_t *chord,
                           int num_notes,
                           chord_signature_t *signature,
-                          score_pitch_t root)
+                          pitch_t root)
 {
     int i, degree, note_half_steps, degree_half_steps;
     int root_midi;
 
     /* Sanitize root to eliminate things like double-flats,
      * double-sharps, Cb, E#, etc. */
-    root_midi = _score_pitch_and_octave_to_midi (root, 0);
-    _midi_to_score_pitch_and_octave (root_midi, &root, NULL);
+    root_midi = _pitch_and_octave_to_midi (root, 0);
+    _midi_to_pitch_and_octave (root_midi, &root, NULL);
     
     for (i = 0; i < num_notes; i++) {
        note_half_steps = _pitch_from_root_in_half_steps (chord->notes[i]->pitch,
@@ -905,7 +905,7 @@ scherzo_analyze_chord (scherzo_t *scherzo)
     note_group_t *note_group;
     unsigned i, j, num_notes;
     int bass_pitch, inversion;
-    score_pitch_t root;
+    pitch_t root;
     chord_signature_t *match = NULL;
     char *chord_name;
 
@@ -931,7 +931,7 @@ scherzo_analyze_chord (scherzo_t *scherzo)
     for (i = 0; i < num_notes; i++) {
        score_note_t *note = note_group->notes[i];
        notes[i].note = note;
-       notes[i].midi_pitch = _score_pitch_and_octave_to_midi (note->pitch,
+       notes[i].midi_pitch = _pitch_and_octave_to_midi (note->pitch,
                                                               note->octave);
        /* Relative pitch will be filled in after sorting. */
        notes[i].relative_pitch = 0;
@@ -1072,7 +1072,7 @@ note_group_remove_note_at (note_group_t *group, int i)
 }
 
 static score_note_t *
-scherzo_press_note (scherzo_t *scherzo, score_pitch_t pitch, int octave)
+scherzo_press_note (scherzo_t *scherzo, pitch_t pitch, int octave)
 {
     score_staff_t *staff;
     score_note_t *note;
@@ -1108,17 +1108,17 @@ scherzo_press_note (scherzo_t *scherzo, score_pitch_t pitch, int octave)
 }
 
 static void
-scherzo_release_note (scherzo_t *scherzo, score_pitch_t pitch, int octave)
+scherzo_release_note (scherzo_t *scherzo, pitch_t pitch, int octave)
 {
     score_note_t *note;
     int i;
     int found = 0;
-    int target_midi = _score_pitch_and_octave_to_midi (pitch, octave);
+    int target_midi = _pitch_and_octave_to_midi (pitch, octave);
     int note_midi;
 
     for (i = scherzo->notes_pressed.num_notes - 1; i >=0; i--) {
        note = scherzo->notes_pressed.notes[i];
-       note_midi = _score_pitch_and_octave_to_midi (note->pitch, note->octave);
+       note_midi = _pitch_and_octave_to_midi (note->pitch, note->octave);
        if (note_midi == target_midi) {
            found = 1;
            if (! scherzo->pedal_pressed)
@@ -1137,10 +1137,10 @@ scherzo_release_note (scherzo_t *scherzo, score_pitch_t pitch, int octave)
 static score_note_t *
 scherzo_press_note_midi (scherzo_t *scherzo, unsigned char midi_note)
 {
-    score_pitch_t pitch;
+    pitch_t pitch;
     int octave;
 
-    _midi_to_score_pitch_and_octave (midi_note, &pitch, &octave);
+    _midi_to_pitch_and_octave (midi_note, &pitch, &octave);
 
     return scherzo_press_note (scherzo, pitch, octave);
 }
@@ -1148,10 +1148,10 @@ scherzo_press_note_midi (scherzo_t *scherzo, unsigned char midi_note)
 static void
 scherzo_release_note_midi (scherzo_t *scherzo, unsigned char midi_note)
 {
-    score_pitch_t pitch;
+    pitch_t pitch;
     int octave;
  
-    _midi_to_score_pitch_and_octave (midi_note, &pitch, &octave);
+    _midi_to_pitch_and_octave (midi_note, &pitch, &octave);
 
     scherzo_release_note (scherzo, pitch, octave);
 }
@@ -1202,7 +1202,7 @@ _select_challenge (scherzo_t *scherzo)
     bool_t introduced_unused;
     item_t *item;
     challenge_t *challenge = &scherzo->challenge;
-    score_pitch_t pitch;
+    pitch_t pitch;
     int octave;
     char *s;
 
@@ -1235,25 +1235,25 @@ _select_challenge (scherzo_t *scherzo)
 
     switch (*s) {
     case 'C':
-       pitch = SCORE_PITCH_C;
+       pitch = PITCH_C;
        break;
     case 'D':
-       pitch = SCORE_PITCH_D;
+       pitch = PITCH_D;
        break;
     case 'E':
-       pitch = SCORE_PITCH_E;
+       pitch = PITCH_E;
        break;
     case 'F':
-       pitch = SCORE_PITCH_F;
+       pitch = PITCH_F;
        break;
     case 'G':
-       pitch = SCORE_PITCH_G;
+       pitch = PITCH_G;
        break;
     case 'A':
-       pitch = SCORE_PITCH_A;
+       pitch = PITCH_A;
        break;
     case 'B':
-       pitch = SCORE_PITCH_B;
+       pitch = PITCH_B;
        break;
     default:
        fprintf (stderr, "Malformed pitch name: %s (expected 'A' - 'G')\n", s);
@@ -1413,7 +1413,7 @@ main (int argc, char *argv[])
 
     /* Default to octave 4 and natural for computer keyboard keypresses. */
     scherzo.keyboard_octave = 4;
-    scherzo.keyboard_accidental = SCORE_PITCH_ACCIDENTAL_NATURAL;
+    scherzo.keyboard_accidental = PITCH_ACCIDENTAL_NATURAL;
 
     note_group_init (scherzo.ctx, &scherzo.notes_pressed);
     note_group_init (scherzo.ctx, &scherzo.notes_pedaled);

diff --git a/score.c b/score.c
index b9df23b2577ba3dbacce8d40fe44642ac833fb57..e587c2799ed93a6396456b8d929388d56f482a30 100644 (file)
--- a/score.c
+++ b/score.c
@@ -177,10 +177,10 @@ _score_clef_c_line (score_clef_t clef)
 static double
 _score_note_to_line (score_staff_t *staff, score_note_t *note)
 {
-    score_pitch_name_t name = SCORE_PITCH_NAME (note->pitch);
+    pitch_name_t name = PITCH_NAME (note->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 * (note->octave - 4);
 }
 
 /* chord->width is updated as a side effect */
@@ -265,25 +265,25 @@ _draw_note (score_t *score, cairo_t *cr,
 
     /* 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;
 
@@ -594,7 +594,7 @@ score_remove_chord (score_chord_t *chord)
 
 score_note_t *
 score_add_note (score_staff_t *staff,
-               score_pitch_t pitch,
+               pitch_t pitch,
                int octave,
                score_duration_t duration)
 {
@@ -693,7 +693,7 @@ score_set_note_color_rgb (score_note_t *note,
 
 score_note_t *
 score_staff_find_note (score_staff_t *staff,
-                      score_pitch_t pitch,
+                      pitch_t pitch,
                       int octave,
                       score_duration_t duration)
 {

diff --git a/score.h b/score.h
index 6eef279f9d14b38b0e4ad8a8749e8d4f570cfd52..5dd61887d340da2bbb5ca5420af8dc23bd968bc4 100644 (file)
--- a/score.h
+++ b/score.h
@@ -26,66 +26,6 @@
 
 #include "pitch.h"
 
-/* Some compatibility naming until the code changes to use pitch_t and
- * firedns in place of score_pitch_t and friends. */
-typedef pitch_accidental_t score_pitch_accidental_t;
-typedef pitch_name_t score_pitch_name_t;
-typedef pitch_t score_pitch_t;
-
-#define SCORE_PITCH_ACCIDENTAL(pitch) PITCH_ACCIDENTAL(pitch)
-#define SCORE_PITCH_NAME(pitch) PITCH_NAME(pitch)
-#define SCORE_PITCH(pitch, octave) PITCH(pitch, octave)
-
-#define SCORE_PITCH_ACCIDENTAL_DOUBLE_FLAT     PITCH_ACCIDENTAL_DOUBLE_FLAT
-#define SCORE_PITCH_ACCIDENTAL_FLAT            PITCH_ACCIDENTAL_FLAT
-#define SCORE_PITCH_ACCIDENTAL_NATURAL         PITCH_ACCIDENTAL_NATURAL
-#define SCORE_PITCH_ACCIDENTAL_SHARP           PITCH_ACCIDENTAL_SHARP
-#define SCORE_PITCH_ACCIDENTAL_DOUBLE_SHARP    PITCH_ACCIDENTAL_DOUBLE_SHARP
-
-#define SCORE_PITCH_NAME_C PITCH_NAME_C
-#define SCORE_PITCH_NAME_D PITCH_NAME_D
-#define SCORE_PITCH_NAME_E PITCH_NAME_E
-#define SCORE_PITCH_NAME_F PITCH_NAME_F
-#define SCORE_PITCH_NAME_G PITCH_NAME_G
-#define SCORE_PITCH_NAME_A PITCH_NAME_A
-#define SCORE_PITCH_NAME_B PITCH_NAME_B
-
-#define SCORE_PITCH_Cff PITCH_Cff
-#define SCORE_PITCH_Cf PITCH_Cf
-#define SCORE_PITCH_C PITCH_C
-#define SCORE_PITCH_Cs PITCH_Cs
-#define SCORE_PITCH_Css PITCH_Css
-#define SCORE_PITCH_Dff PITCH_Dff
-#define SCORE_PITCH_Df PITCH_Df
-#define SCORE_PITCH_D PITCH_D
-#define SCORE_PITCH_Ds PITCH_Ds
-#define SCORE_PITCH_Dss PITCH_Dss
-#define SCORE_PITCH_Eff PITCH_Eff
-#define SCORE_PITCH_Ef PITCH_Ef
-#define SCORE_PITCH_E PITCH_E
-#define SCORE_PITCH_Es PITCH_Es
-#define SCORE_PITCH_Ess PITCH_Ess
-#define SCORE_PITCH_Fff PITCH_Fff
-#define SCORE_PITCH_Ff PITCH_Ff
-#define SCORE_PITCH_F PITCH_F
-#define SCORE_PITCH_Fs PITCH_Fs
-#define SCORE_PITCH_Fss PITCH_Fss
-#define SCORE_PITCH_Gff PITCH_Gff
-#define SCORE_PITCH_Gf PITCH_Gf
-#define SCORE_PITCH_G PITCH_G
-#define SCORE_PITCH_Gs PITCH_Gs
-#define SCORE_PITCH_Gss PITCH_Gss
-#define SCORE_PITCH_Aff PITCH_Aff
-#define SCORE_PITCH_Af PITCH_Af
-#define SCORE_PITCH_A PITCH_A
-#define SCORE_PITCH_As PITCH_As
-#define SCORE_PITCH_Ass PITCH_Ass
-#define SCORE_PITCH_Bff PITCH_Bff
-#define SCORE_PITCH_Bf PITCH_Bf
-#define SCORE_PITCH_B PITCH_B
-#define SCORE_PITCH_Bs PITCH_Bs
-#define SCORE_PITCH_Bss PITCH_Bss
-
 typedef enum score_duration
 {
     SCORE_DURATION_WHOLE = 1,
@@ -114,7 +54,7 @@ typedef struct score_staff score_staff_t;
 typedef struct score_note
 {
     score_staff_t *staff;
-    score_pitch_t pitch;
+    pitch_t pitch;
     int octave;
     score_duration_t duration;
 
@@ -180,7 +120,7 @@ score_add_staff (score_t *score, score_clef_t clef);
  */
 score_note_t *
 score_add_note (score_staff_t *staff,
-               score_pitch_t pitch,
+               pitch_t pitch,
                int octave,
                score_duration_t);
 
@@ -213,7 +153,7 @@ score_set_note_color_rgb (score_note_t *note,
  * octave, and durations. Returns NULL if no match is found. */
 score_note_t *
 score_staff_find_note (score_staff_t *staff,
-                      score_pitch_t pitch,
+                      pitch_t pitch,
                       int octave,
                       score_duration_t duration);