+1.3.107.jcn3
+============
+
+* Dropped ly_lists_equal for gh_equal_
+
+* Removed Array from chord.
+
+* Small bugfix to lilypond-mode.
+
+* lily/part-combine-music-iterator.cc: fixed (switch `combineParts'
+property on), and removed Array.
+
+1.3.107.uu1
+===========
+
+* Bugfix: don't call Crescendo::brew_molecule () too early if there is
+an absolute dynamic.
+
+* Rename class Crescendo to Hairpin.
+
+* Search/replace: Musical_pitch -> Pitch
+
+* More links in the backend documentation.
+
1.3.106.jcn2
============
$(SHELL) $(buildscript-dir)/install-info-html.sh --dir=$(outdir) lilypond lilypond-internals
$(MAKE) footify
-mkdir $(outdir)/lilypond
- ln -f $(outdir)/*.png $(outdir)/lilypond
+ cp -f $(outdir)/*.png $(outdir)/lilypond
$(MAKE) deep-footify
# $(PYTHON) $(step-bindir)/ls-latex.py --title 'User documentation' \
PACKAGE_NAME=LilyPond
MAJOR_VERSION=1
MINOR_VERSION=3
-PATCH_LEVEL=107
-MY_PATCH_LEVEL=mb1
+PATCH_LEVEL=108
+MY_PATCH_LEVEL=
# use the above to send patches: MY_PATCH_LEVEL is always empty for a
# released version.
at-dir = $(outdir)/
at-ext =
-EXTRA_DIST_FILES = README.Debian TODO $(CONF_FILES) \
- control.foka
CONF_FILES = changelog control copyright doc-base emacsen-startup \
preinst postinst postrm prerm rules watch
+EXTRA_DIST_FILES = README.Debian TODO $(CONF_FILES) \
+ control.foka
#OUTCONF_FILES = $(addprefix $(outdir)/, $(basename $(CONF_FILES))) $(OUTIN_FILES)
OUTCONF_FILES = $(OUTIN_FILES)
OUT_DIST_FILES = $(OUTIN_FILES)
+lilypond1.3 (1.3.107) unstable; urgency=low
+
+ * Fixed watch location.
+ * Hmm, what about ``add-log-mailing-address: "foka@debian.org"''?
+
+ -- Jan Nieuwenhuizen <foka@debian.org> Mon, 13 Nov 2000 13:33:53 +0100
+
lilypond1.3 (1.3.103) unstable; urgency=low
* Re-enabled info doc rules.
Source: lilypond1.3
-Build-Depends: debhelper (>= 2.0.71), python-base (>= 1.5.2-4), libguile6-dev, tetex-bin, tetex-devel, tetex-extra, flex (>= 2.5.4a-1), bison (>= 1:1.28-1), texinfo (>= 4.0-1), groff, gs, netpbm, pnmtopng, m4, gettext (>= 0.10.35-13)
+Build-Depends: debhelper (>= 2.0.71), python-base (>= 1.5.2-4), libguile9-dev, tetex-bin, tetex-devel, tetex-extra, flex (>= 2.5.4a-1), bison (>= 1:1.28-1), texinfo (>= 4.0-1), groff, gs, netpbm, pnmtopng, m4, gettext (>= 0.10.35-13)
Section: tex
Priority: optional
Maintainer: Anthony Fok <foka@debian.org>
# Rename this file to "watch" and then you can run the "uscan" command
# to check for upstream updates and more.
# Site Directory Pattern Version Script
-ftp.cs.uu.nl /pub/GNU/LilyPond/v1.1 lilypond-*.tar.gz debian uupdate
+ftp.cs.uu.nl /pub/GNU/LilyPond/v1.3 lilypond-*.tar.gz debian uupdate
if (Stem::has_interface (i.elem_l_)
|| Slur::has_interface (i.elem_l_)
// || Text_item::has_interface (i.elem_l_)
- //|| Crescendo::has_interface (i.elem_l_)
+ //|| Hairpin::has_interface (i.elem_l_)
)
{
/*
audio_column_l_ = 0;
}
-Audio_note::Audio_note (Musical_pitch p, Moment m, int transposing_i)
+Audio_note::Audio_note (Pitch p, Moment m, int transposing_i)
{
pitch_ = p;
length_mom_ = m;
PRECONDITION: this->ok() holds.
*/
-Array<Musical_pitch>
+Array<Pitch>
Auto_change_iterator::pending_pitch (Moment m) const
{
Music_iterator * iter = child_iter_p_ ->clone ();
- Array<Musical_pitch> ps;
+ Array<Pitch> ps;
while (1)
{
SCM muses = iter->get_music (m);
first we get the pitches, then we do the real work.
Music_wrapper_iterator::process() might process (and throw away)
pitches we need. */
- Array<Musical_pitch> ps = pending_pitch (m);
+ Array<Pitch> ps = pending_pitch (m);
Music_wrapper_iterator::process (m);
if (ps.size ())
{
- Musical_pitch p = ps[0];
+ Pitch p = ps[0];
Direction s = Direction (sign(p.steps ()));
if (s != where_dir_)
{
#include "main.hh"
#include "dimensions.hh"
#include "item.hh"
-#include "musical-pitch.hh"
+#include "pitch.hh"
+#include "protected-scm.hh"
class Chord_name_engraver : public Engraver
{
private:
void create_chord_name ();
-
- Array<Musical_pitch> pitch_arr_;
+
Item* chord_name_p_;
- Chord* chord_p_;
- Chord* last_chord_p_;
- Tonic_req* tonic_req_;
- Inversion_req* inversion_req_;
- Bass_req* bass_req_;
+ Protected_scm pitches_;
+
+ Protected_scm chord_;
+ Protected_scm last_chord_;
+
+ Protected_scm tonic_req_;
+ Protected_scm inversion_req_;
+ Protected_scm bass_req_;
};
ADD_THIS_TRANSLATOR (Chord_name_engraver);
Chord_name_engraver::Chord_name_engraver ()
{
chord_name_p_ = 0;
- tonic_req_ = 0;
- inversion_req_ = 0;
- bass_req_ = 0;
- chord_p_ = 0;
- last_chord_p_ = 0;
+ pitches_ = SCM_EOL;
+ tonic_req_ = SCM_EOL;
+ inversion_req_ = SCM_EOL;
+ bass_req_ = SCM_EOL;
+ chord_ = SCM_EOL;
+ last_chord_ = SCM_EOL;
}
void
Chord_name_engraver::acknowledge_element (Score_element_info i)
{
if (Note_req* n = dynamic_cast<Note_req*> (i.req_l_))
- pitch_arr_.push (* unsmob_pitch (n->get_mus_property ("pitch")));
+ pitches_ = gh_cons (n->get_mus_property ("pitch"), pitches_);
}
bool
{
if (Note_req* n = dynamic_cast<Note_req*> (m))
{
- pitch_arr_.push (* unsmob_pitch (n->get_mus_property ("pitch")));
+ pitches_ = gh_cons (n->get_mus_property ("pitch"), pitches_);
return true;
}
if (Tonic_req* t = dynamic_cast<Tonic_req*> (m))
{
- tonic_req_ = t;
+ tonic_req_ = t->get_mus_property ("pitch");
return true;
}
if (Inversion_req* i = dynamic_cast<Inversion_req*> (m))
{
- inversion_req_ = i;
+ inversion_req_ = i->get_mus_property ("pitch");
return true;
}
if (Bass_req* b = dynamic_cast<Bass_req*> (m))
{
- bass_req_ = b;
+ bass_req_ = b->get_mus_property ("pitch");
return true;
}
return false;
void
Chord_name_engraver::do_process_music ()
{
- if (chord_name_p_)
- return;
-
- if (!pitch_arr_.size ())
- return;
-
- bool find_inversion_b = false;
- SCM chord_inversion = get_property ("chordInversion");
- if (gh_boolean_p (chord_inversion))
- find_inversion_b = gh_scm2bool (chord_inversion);
-
- chord_p_ = new Chord (to_chord (pitch_arr_,
- tonic_req_, inversion_req_, bass_req_,
- find_inversion_b));
-
- create_chord_name ();
- announce_element (chord_name_p_, 0);
- SCM s = get_property ("drarnChords"); //FIXME!
- if (to_boolean (s) && last_chord_p_ && !compare (chord_p_, last_chord_p_))
- chord_name_p_->set_elt_property ("begin-of-line-visible", SCM_BOOL_T);
+ if (!chord_name_p_ && pitches_ != SCM_EOL)
+ {
+ bool find_inversion_b = false;
+ SCM chord_inversion = get_property ("chordInversion");
+ if (gh_boolean_p (chord_inversion))
+ find_inversion_b = gh_scm2bool (chord_inversion);
+
+ chord_ = Chord::pitches_and_requests_to_chord (pitches_,
+ tonic_req_,
+ inversion_req_,
+ bass_req_,
+ find_inversion_b);
+
+ create_chord_name ();
+ announce_element (chord_name_p_, 0);
+ SCM s = get_property ("drarnChords"); //FIXME!
+ if (to_boolean (s) && last_chord_ != SCM_EOL &&
+ gh_equal_p (chord_, last_chord_))
+ chord_name_p_->set_elt_property ("begin-of-line-visible", SCM_BOOL_T);
+ }
}
void
Chord_name_engraver::create_chord_name ()
{
- assert (chord_p_);
chord_name_p_ = new Item (get_property ("ChordName"));
- /*
- Hmm, why not represent complete chord as list?
- ((tonic third fifth) (inversion bass))
- */
- SCM plist = SCM_EOL;
- for (int i= chord_p_->pitch_arr_.size (); i--; )
- plist = gh_cons (chord_p_->pitch_arr_[i].smobbed_copy (), plist);
-
- chord_name_p_->set_elt_property ("pitches", plist);
- if (chord_p_->inversion_b_)
- chord_name_p_->set_elt_property ("inversion",
- chord_p_->inversion_pitch_.smobbed_copy ());
- if (chord_p_->bass_b_)
- chord_name_p_->set_elt_property ("bass", chord_p_->bass_pitch_.smobbed_copy ());
+
+ SCM pitches = gh_car (chord_);
+ SCM modifiers = gh_cdr (chord_);
+ SCM inversion = gh_car (modifiers);
+ SCM bass = gh_cdr (modifiers);
+ /* Hmm, maybe chord-name should use (pitches (inversion . base)) too? */
+ chord_name_p_->set_elt_property ("pitches", pitches);
+ chord_name_p_->set_elt_property ("inversion", inversion);
+ chord_name_p_->set_elt_property ("inversion", bass);
}
void
{
typeset_element (chord_name_p_);
}
- pitch_arr_.clear ();
chord_name_p_ = 0;
- tonic_req_ = 0;
- inversion_req_ = 0;
- bass_req_ = 0;
- delete last_chord_p_;
- last_chord_p_ = chord_p_;
- chord_p_ = 0;
+
+ pitches_ = SCM_EOL;
+ tonic_req_ = SCM_EOL;
+ inversion_req_ = SCM_EOL;
+ bass_req_ = SCM_EOL;
+ last_chord_ = chord_;
+ chord_ = SCM_EOL;
}
#include "music-list.hh"
#include "musical-request.hh"
-/*
- UGH
-
- should compare SCM lists.
- */
-int
-compare (Chord* left, Chord* right)
-{
- assert (left);
- assert (right);
-
- return !(left->inversion_b_ == right->inversion_b_
- && left->bass_b_ == right->bass_b_
- && !compare (&left->pitch_arr_, &right->pitch_arr_));
-}
-
-/*
- FIXME: should use SCM iso. arrays and have-to-delete pointers.
-
- FIXME: a real function looks like
-
+/* some SCM abbrevs
- Return_value func (Input_value),
+ zijn deze nou handig?
+ zijn ze er al in scheme, maar heten ze anders? */
- not
- void func (Input_value *);
-
- FIXME:
-
- pitch is really a tuple, hence an immutable object. We
- should remove all mutating operations.
-
- */
-
-/*
- construct from parser output
-*/
-Chord
-to_chord (Musical_pitch tonic, Array<Musical_pitch>* add_arr_p, Array<Musical_pitch>* sub_arr_p, Musical_pitch* inversion_p, Musical_pitch* bass_p)
+/* Remove doubles from (sorted) list */
+SCM
+ly_unique (SCM list)
{
- // urg: catch dim modifier: 3rd, 5th, 7th, .. should be lowered
- bool dim_b = false;
- for (int i=0; i < add_arr_p->size (); i++)
+ SCM unique = SCM_EOL;
+ for (SCM i = list; gh_pair_p (i); i = gh_cdr (i))
{
- Musical_pitch* p = &(*add_arr_p)[i];
- if (p->octave_i () == -100)
- {
- p->octave_i_ = 0;
- dim_b = true;
- }
+ if (!gh_pair_p (gh_cdr (i))
+ || !gh_equal_p (gh_car (i), gh_cadr (i)))
+ unique = gh_cons (gh_car (i), unique);
}
- Chord::rebuild_transpose (add_arr_p, tonic, true);
- Chord::rebuild_transpose (sub_arr_p, tonic, true);
-
- Musical_pitch fifth = Chord::base_arr (tonic).top ();
+ return gh_reverse (unique);
+}
- /*
- remove double adds (urg: sus4)
- */
- for (int i = add_arr_p->size () - 1; i >= 0 ; i--)
+/* Hmm, rewrite this using ly_split_list? */
+SCM
+ly_remove_member (SCM s, SCM list)
+{
+ SCM removed = SCM_EOL;
+ for (SCM i = list; gh_pair_p (i); i = gh_cdr (i))
{
- int j = Chord::find_pitch_i (add_arr_p, (*add_arr_p)[i]);
- if ((j != -1) && (i != j))
- {
- add_arr_p->get (i);
- }
+ if (!gh_equal_p (gh_car (i), s))
+ removed = gh_cons (gh_car (i), removed);
}
+ return gh_reverse (removed);
+}
- /*
- default chord includes upto 5: <1, 3, 5>
- */
- add_arr_p->insert (tonic, 0);
- Array<Musical_pitch> tmp = *add_arr_p;
- int highest_step = Chord::step_i (tonic, tmp.top ());
- if (highest_step < 5)
- tmp.push (fifth);
- else if (dim_b)
- {
- Musical_pitch* p = &add_arr_p->top ();
- p->alteration_i_--;
- }
+SCM
+ly_last (SCM list)
+{
+ return gh_car (scm_last_pair (list));
+}
- /*
- find missing thirds
- */
- Array<Musical_pitch> missing_arr = Chord::missing_thirds_pitch_arr (&tmp);
- if (highest_step < 5)
- missing_arr.push (fifth);
+/* tail add */
+SCM
+ly_snoc (SCM s, SCM list)
+{
+ return gh_append2 (list, gh_list (s, SCM_UNDEFINED));
+}
- /*
- if dim modifier is given: lower all missing
- */
- if (dim_b)
- {
- for (int i=0; i < missing_arr.size (); i++)
- {
- missing_arr[i].alteration_i_--;
- }
- }
- /*
- if additions include some 3, don't add third
- */
- Musical_pitch third = Chord::base_arr (tonic)[1];
- if (Chord::find_notename_i (add_arr_p, third) != -1)
- {
- int i = Chord::find_pitch_i (&missing_arr, third);
- if (i != -1)
- missing_arr.get (i);
- }
-
- /*
- if additions include 4, assume sus4 and don't add third implicitely
- C-sus (4) = c f g (1 4 5)
- */
- Musical_pitch sus = tonic;
- sus.transpose (Musical_pitch (0,3,0));
- if (Chord::find_pitch_i (add_arr_p, sus) != -1)
+/* Split list at member s, removing s.
+ Return (BEFORE . AFTER) */
+SCM
+ly_split_list (SCM s, SCM list)
+{
+ SCM before = SCM_EOL;
+ SCM after = list;
+ for (; gh_pair_p (after);)
{
- int i = Chord::find_pitch_i (&missing_arr, third);
- if (i != -1)
- missing_arr.get (i);
+ SCM i = gh_car (after);
+ after = gh_cdr (after);
+ if (gh_equal_p (i, s))
+ break;
+ before = gh_cons (i, before);
}
+ return gh_cons (gh_reverse (before), after);
+}
- /*
- if additions include some 5, don't add fifth
- */
- if (Chord::find_notename_i (add_arr_p, fifth) != -1)
- {
- int i = Chord::find_pitch_i (&missing_arr, fifth);
- if (i != -1)
- missing_arr.get (i);
- }
-
-
- /*
- complete the list of thirds to be added
- */
- add_arr_p->concat (missing_arr);
- add_arr_p->sort (Musical_pitch::compare);
-
- Array<Musical_pitch> pitch_arr;
- /*
- add all that aren't subtracted
- */
- for (int i = 0; i < add_arr_p->size (); i++)
- {
- Musical_pitch p = (*add_arr_p)[i];
- int j = 0;
- for (; j < sub_arr_p->size (); j++)
- if (p == (*sub_arr_p)[j])
- {
- sub_arr_p->del (j);
- j = -1;
- break;
- }
- if (j == sub_arr_p->size ())
- pitch_arr.push (p);
- }
- pitch_arr.sort (Musical_pitch::compare);
+/* Construct from list of pitches and requests:
- for (int i = 0; i < sub_arr_p->size (); i++)
- warning (_f ("invalid subtraction: not part of chord: %s",
- (*sub_arr_p)[i].str ()));
-
- return Chord (pitch_arr, inversion_p, bass_p);
-}
+ (PITCHES . (INVERSION . BASS))
-/*
- Construct from list of pitches and requests
- */
-Chord
-to_chord (Array<Musical_pitch> pitch_arr, Tonic_req* tonic_req, Inversion_req* inversion_req, Bass_req* bass_req, bool find_inversion_b)
+
+ Note, the pitches here, are all inclusive.
+ We must identify tonic, filter-out (and maybe detect) inversion and bass. */
+
+SCM
+Chord::pitches_and_requests_to_chord (SCM pitches,
+ SCM tonic_req,
+ SCM inversion_req,
+ SCM bass_req,
+ bool find_inversion_b)
{
- Musical_pitch* inversion_p = 0;
- Musical_pitch* bass_p = 0;
+ pitches = scm_sort_list (pitches,
+ scm_eval2 (ly_symbol2scm ("Pitch::less_p"),
+ SCM_EOL));
- if (bass_req)
+
+ if (bass_req != SCM_EOL)
{
- assert (pitch_arr[0].notename_i_ == unsmob_pitch (bass_req->get_mus_property ("pitch"))->notename_i_);
- bass_p = new Musical_pitch (pitch_arr.get (0));
+ assert (unsmob_pitch (gh_car (pitches))->notename_i_
+ == unsmob_pitch (bass_req)->notename_i_);
+ pitches = gh_cdr (pitches);
}
- if (inversion_req)
+ if (inversion_req != SCM_EOL)
{
- assert (pitch_arr[0].notename_i_ == unsmob_pitch (inversion_req->get_mus_property ("pitch"))->notename_i_);
- inversion_p = new Musical_pitch (* unsmob_pitch (inversion_req->get_mus_property ("pitch")));
- assert (tonic_req);
- int tonic_i = Chord::find_notename_i (&pitch_arr,
- *unsmob_pitch (tonic_req->get_mus_property ("pitch")));
- if (tonic_i)
- Chord::rebuild_insert_inversion (&pitch_arr, tonic_i);
+ assert (unsmob_pitch (gh_car (pitches))->notename_i_
+ == unsmob_pitch (inversion_req)->notename_i_);
+ /* huh ? */
+ assert (tonic_req != SCM_EOL);
+
+ SCM tonic = member_notename (tonic_req, pitches);
+ if (tonic != SCM_EOL)
+ pitches = rebuild_insert_inversion (pitches); //, tonic);
}
-
- if (find_inversion_b && !inversion_p)
+ else if (find_inversion_b)
{
- int tonic_i = tonic_req
- ? Chord::find_notename_i (&pitch_arr, *unsmob_pitch (tonic_req->get_mus_property ("pitch")))
- : Chord::find_tonic_i (&pitch_arr);
+ SCM tonic = (tonic_req != SCM_EOL)
+ ? member_notename (pitches, tonic_req)
+ : guess_tonic (pitches);
- if (tonic_i)
+ if (tonic != SCM_EOL)
{
- inversion_p = &pitch_arr[0];
- Chord::rebuild_insert_inversion (&pitch_arr, tonic_i);
+ inversion_req = gh_car (pitches);
+ pitches = rebuild_insert_inversion (pitches); //, tonic);
}
}
- if (tonic_req)
- {
- assert (pitch_arr[0].notename_i_ == unsmob_pitch (tonic_req->get_mus_property ("pitch"))->notename_i_);
- }
-
- return Chord (pitch_arr, inversion_p, bass_p);
-}
+ if (tonic_req != SCM_EOL)
+ assert (unsmob_pitch (gh_car (pitches))->notename_i_
+ == unsmob_pitch (tonic_req)->notename_i_);
-Chord::Chord ()
-{
- inversion_b_ = false;
- bass_b_ = false;
+ return gh_cons (pitches, gh_cons (inversion_req, bass_req));
}
-Chord::Chord (Array<Musical_pitch> pitch_arr, Musical_pitch* inversion_p, Musical_pitch* bass_p)
-{
- pitch_arr_ = pitch_arr;
- inversion_b_ = false;
- bass_b_ = false;
- if (inversion_p)
- {
- inversion_pitch_ = *inversion_p;
- inversion_b_ = true;
- }
- if (bass_p)
- {
- bass_pitch_ = *bass_p;
- bass_b_ = true;
- }
-}
-
-Chord::Chord (Chord const& chord)
-{
- pitch_arr_ = chord.pitch_arr_;
- inversion_b_ = chord.inversion_b_;
- inversion_pitch_ = chord.inversion_pitch_;
- bass_b_ = chord.bass_b_;
- bass_pitch_ = chord.bass_pitch_;
-}
-
-
/*
JUNKME.
do something smarter.
+ zoals?
*/
-Array<Musical_pitch>
-Chord::base_arr (Musical_pitch p)
+SCM
+Chord::base_pitches (SCM tonic)
{
- Array<Musical_pitch> base;
- base.push (p);
- p.transpose (Musical_pitch (0,2,0));
- base.push (p);
- p.transpose (Musical_pitch (0, 2, -1));
- base.push (p);
- return base;
+ SCM base = SCM_EOL;
+
+ SCM major = Pitch (0, 2, 0).smobbed_copy ();
+ SCM minor = Pitch (0, 2, -1).smobbed_copy ();
+
+ base = gh_cons (tonic, base);
+ base = gh_cons (Pitch::transpose (gh_car (base), major), base);
+ base = gh_cons (Pitch::transpose (gh_car (base), minor), base);
+
+ return gh_reverse (base);
}
-void
-Chord::rebuild_transpose (Array<Musical_pitch>* pitch_arr_p, Musical_pitch tonic, bool fix7_b)
+SCM
+Chord::transpose_pitches (SCM tonic, SCM pitches)
{
- for (int i = 0; i < pitch_arr_p->size (); i++)
+ /* map?
+ hoe doe je lambda in C?
+ */
+ SCM transposed = SCM_EOL;
+ for (SCM i = pitches; gh_pair_p (i); i = gh_cdr (i))
{
- Musical_pitch p = tonic;
- Musical_pitch q = (*pitch_arr_p)[i];
- p.transpose (q);
- // duh, c7 should mean <c bes>
- if (fix7_b && (step_i (tonic, p) == 7))
- p.alteration_i_--;
- (*pitch_arr_p)[i] = p;
+ transposed = gh_cons (Pitch::transpose (tonic, gh_car (i)),
+ transposed);
}
- pitch_arr_p->sort (Musical_pitch::compare);
+ return gh_reverse (transposed);
}
-int
-Chord::find_pitch_i (Array<Musical_pitch> const* pitch_arr_p, Musical_pitch p)
+/*
+ burp, in SCM duw je gewoon een (if (= (step x) 7) (...)) door pitches
+
+ Lower step STEP.
+ If step == 0, lower all.
+ */
+SCM
+Chord::lower_step (SCM tonic, SCM pitches, SCM step)
{
- for (int i = 0; i < pitch_arr_p->size (); i++)
- if (p == (*pitch_arr_p)[i])
- return i;
- return -1;
+ SCM lowered = SCM_EOL;
+ for (SCM i = pitches; gh_pair_p (i); i = gh_cdr (i))
+ {
+ SCM p = gh_car (i);
+ if (gh_equal_p (step_scm (tonic, gh_car (i)), step)
+ || gh_scm2int (step) == 0)
+ {
+#if 0
+ Pitch x = *unsmob_pitch (p);
+ x.alteration_i_--;
+ p = x.smobbed_copy ();
+#else
+ p = Pitch::transpose (p, Pitch (0, 0, -1).smobbed_copy ());
+#endif
+ }
+ lowered = gh_cons (p, lowered);
+ }
+ return gh_reverse (lowered);
}
-int
-Chord::find_notename_i (Array<Musical_pitch> const* pitch_arr_p, Musical_pitch p)
+/* Return member that has same notename, disregarding octave or accidentals */
+SCM
+Chord::member_notename (SCM p, SCM pitches)
{
- int i = find_pitch_i (pitch_arr_p, p);
- if (i == -1)
+ /* If there's an exact match, make sure to return that */
+ SCM member = gh_member (p, pitches);
+ if (member == SCM_BOOL_F)
{
- for (int i = 0; i < pitch_arr_p->size (); i++)
+ for (SCM i = pitches; gh_pair_p (i); i = gh_cdr (i))
{
- p.octave_i_ = (*pitch_arr_p)[i].octave_i () ;
- if (p == (*pitch_arr_p)[i])
- return i;
+ /*
+ Urg, eindelijk gevonden: () != #f, kan maar niet aan wennen.
+ Anders kon iets korter...
+ */
+ if (unsmob_pitch (p)->notename_i_
+ == unsmob_pitch (gh_car (i))->notename_i_)
+ {
+ member = gh_car (i);
+ break;
+ }
}
}
- return i;
+ return member;
}
int
-Chord::step_i (Musical_pitch tonic, Musical_pitch p)
+Chord::step_i (Pitch tonic, Pitch p)
{
int i = p.notename_i_ - tonic.notename_i_
+ (p.octave_i () - tonic.octave_i () ) * 7;
return i;
}
+SCM
+Chord::step_scm (SCM tonic, SCM p)
+{
+ return gh_int2scm (step_i (*unsmob_pitch (tonic), *unsmob_pitch (p)));
+}
+
/*
- JUNKME.
- do something smarter.
+ docme
*/
-Array<Musical_pitch>
-Chord::missing_thirds_pitch_arr (Array<Musical_pitch> const* pitch_arr_p)
+SCM
+Chord::missing_thirds (SCM pitches)
{
- Array<Musical_pitch> thirds;
-
+ SCM thirds = SCM_EOL;
+
/* is the third c-e, d-f, etc. small or large? */
- int minormajor_a[] = {0, -1, -1, 0,0,-1,-1};
+ int minormajor_a[] = {0, -1, -1, 0, 0, -1, -1};
for (int i=0; i < 7; i++)
- thirds.push (Musical_pitch( 0, 2, minormajor_a[i]));
-
- Musical_pitch tonic = (*pitch_arr_p)[0];
- Musical_pitch last = tonic;
- Array<Musical_pitch> missing_arr;
+ thirds = gh_cons (Pitch (0, 2, minormajor_a[i]).smobbed_copy (),
+ thirds);
+ thirds = scm_vector (gh_reverse (thirds));
+
+ SCM tonic = gh_car (pitches);
+ SCM last = tonic;
+ SCM missing = SCM_EOL;
- for (int i = 0; i < pitch_arr_p->size ();)
+ for (SCM i = pitches; gh_pair_p (i);)
{
- Musical_pitch p = (*pitch_arr_p)[i];
- int step = step_i (tonic, p);
- if (last.notename_i_ == p.notename_i_)
- last.transpose (thirds[(last.notename_i_ - tonic.notename_i_ + 7) % 7]);
- if (step > step_i (tonic, last))
+ SCM p = gh_car (i);
+ int step = gh_scm2int (step_scm (tonic, p));
+
+ if (unsmob_pitch (last)->notename_i_ == unsmob_pitch (p)->notename_i_)
+ {
+ int third = (unsmob_pitch (last)->notename_i_
+ - unsmob_pitch (tonic)-> notename_i_ + 7) % 7;
+ last = Pitch::transpose (last, scm_vector_ref (thirds, gh_int2scm (third)));
+ }
+
+ if (step > gh_scm2int (step_scm (tonic, last)))
{
- while (step > step_i (tonic, last))
+ while (step > gh_scm2int (step_scm (tonic, last)))
{
- if ((last.notename_i_ - tonic.notename_i_ + 7) % 7 == 6)
- {
- Musical_pitch special_seven = last;
- Musical_pitch lower (0, 0, -1);
- special_seven.transpose (lower);
- missing_arr.push (special_seven);
- }
- else
- {
- missing_arr.push (last);
- }
- last.transpose (thirds[(last.notename_i_ - tonic.notename_i_ + 7) % 7]);
+ missing = gh_cons (last, missing);
+ int third = (unsmob_pitch (last)->notename_i_
+ - unsmob_pitch (tonic)->notename_i_ + 7) % 7;
+ last = Pitch::transpose (last, scm_vector_ref (thirds,
+ gh_int2scm (third)));
}
}
else
{
- i++;
+ i = gh_cdr (i);
}
}
- return missing_arr;
+
+ return lower_step (tonic, missing, gh_int2scm (7));
}
/*
- Mangle into list of pitches.
+ Mangle
+
+ (PITCHES . (INVERSION . BASS))
+
+ into list of pitches.
+
For normal chord entry, inversion and bass pitches are retained in
- specific *_requests
- */
-Array<Musical_pitch>
-Chord::to_pitch_arr () const
+ specific *_requests */
+
+SCM
+Chord::to_pitches (SCM chord)
{
- Array<Musical_pitch> pitch_arr = pitch_arr_;
- if (inversion_b_)
+ SCM pitches = gh_car (chord);
+ SCM modifiers = gh_cdr (chord);
+ SCM inversion = gh_car (modifiers);
+ SCM bass = gh_cdr (modifiers);
+ if (inversion != SCM_EOL)
{
- int i = 0;
- for (; i < pitch_arr.size (); i++)
+ Pitch inversion_pitch = *unsmob_pitch (inversion);
+ SCM i = pitches;
+ for (; gh_pair_p (i); i = gh_cdr (i))
{
- if ((pitch_arr[i].notename_i_ == inversion_pitch_.notename_i_)
- && (pitch_arr[i].alteration_i_ == inversion_pitch_.alteration_i_))
+ Pitch p = *unsmob_pitch (gh_car (i));
+ if ((p.notename_i_ == inversion_pitch.notename_i_)
+ && (p.alteration_i_ == inversion_pitch.alteration_i_))
break;
}
- if (i == pitch_arr.size ())
- {
- warning (_f ("invalid inversion pitch: not part of chord: %s",
- inversion_pitch_.str ()));
- }
+ if (gh_pair_p (i))
+ pitches = rebuild_with_bass (pitches, gh_car (i));
else
- rebuild_with_bass (&pitch_arr, i);
+ warning (_f ("invalid inversion pitch: not part of chord: %s",
+ unsmob_pitch (inversion)->str ()));
}
- if (bass_b_)
+ if (bass != SCM_EOL)
{
- pitch_arr.insert (bass_pitch_, 0);
- rebuild_with_bass (&pitch_arr, 0);
+ pitches = gh_cons (bass, pitches);
+ pitches = rebuild_with_bass (pitches, bass);
}
- return pitch_arr;
+ return pitches;
}
/*
This is only used for chords that are entered as simultaneous notes,
chords entered in \chord mode are fully defined.
*/
-int
-Chord::find_tonic_i (Array<Musical_pitch> const* pitch_arr_p)
-{
- /*
- find tonic
-
- first try: base of longest line of thirds
- */
- int tonic_i = 0;
- int longest_i = 0;
- for (int i = 0; i < pitch_arr_p->size (); i++)
- {
- int no_third_i = 0;
- int last_i = (*pitch_arr_p)[i % pitch_arr_p->size ()].notename_i_;
- int j = 0;
- for (; j < pitch_arr_p->size (); j++)
- {
- int cur_i = (*pitch_arr_p)[(i + j + 1) % pitch_arr_p->size ()].notename_i_;
- int gap = cur_i - last_i;
- while (gap < 0)
- gap += 7;
- gap %= 7;
- if (gap == 2)
- last_i = cur_i;
- else
- no_third_i++;
- }
- if (j - no_third_i > longest_i)
- {
- longest_i = j - no_third_i;
- tonic_i = i;
- }
- }
- /*
- second try: note after biggest gap
- */
- int biggest_i = 0;
- // if (longest_i)
- if (longest_i <= 1)
- for (int i = 0; i < pitch_arr_p->size (); i++)
- {
- int gap = (*pitch_arr_p)[i].notename_i_
- - (*pitch_arr_p)[(i - 1 + pitch_arr_p->size ())
- % pitch_arr_p->size ()].notename_i_;
- while (gap < 0)
- gap += 7;
- gap %= 7;
- if (gap > biggest_i)
- {
- biggest_i = gap;
- tonic_i = i;
- }
- }
- return tonic_i;
-}
+SCM
+Chord::guess_tonic (SCM pitches)
+{
+ return gh_car (scm_sort_list (pitches, Pitch::less_p_proc));
+}
-void
-Chord::rebuild_from_base (Array<Musical_pitch>* pitch_arr_p, int base_i)
+SCM
+Chord::rebuild_from_base (SCM pitches, SCM base)
{
- assert (base_i >= 0);
- Musical_pitch last (0, 0, -5);
- Array<Musical_pitch> new_arr;
- for (int i = 0; i < pitch_arr_p->size (); i++)
+ SCM split = ly_split_list (base, pitches);
+ SCM before = gh_car (split);
+ SCM after = gh_cdr (split);
+
+ SCM last = Pitch (0, 0, -5).smobbed_copy ();
+ SCM rebuilt = SCM_EOL;
+ rebuilt = gh_cons (base, rebuilt);
+ for (SCM i = gh_append2 (after, before); gh_pair_p (i); i = gh_cdr (i))
{
- Musical_pitch p = (*pitch_arr_p)[(base_i + i) % pitch_arr_p->size ()];
- if (p < last)
+ SCM p = gh_car (i);
+ if (Pitch::less_p (p, last) == SCM_BOOL_T)
{
- p.octave_i_ = last.octave_i () ;
- if (p < last)
- p.octave_i_++;
+ // UHUHUrg
+ p = Pitch (unsmob_pitch (last)->octave_i_,
+ unsmob_pitch (p)->notename_i_,
+ unsmob_pitch (p)->alteration_i_).smobbed_copy ();
+ if (Pitch::less_p (p, last))
+ p = Pitch::transpose (p, Pitch (1, 0, 0).smobbed_copy ());
}
- new_arr.push (p);
+ rebuilt = gh_cons (p, rebuilt);
last = p;
}
- *pitch_arr_p = new_arr;
+
+ return gh_reverse (rebuilt);
}
-void
-Chord::rebuild_insert_inversion (Array<Musical_pitch>* pitch_arr_p, int tonic_i)
+SCM
+Chord::rebuild_insert_inversion (SCM pitches) //, SCM tonic)
{
- assert (tonic_i > 0);
- Musical_pitch inversion = pitch_arr_p->get (0);
- rebuild_from_base (pitch_arr_p, tonic_i - 1);
- if (pitch_arr_p->size ())
+ SCM inversion = gh_car (pitches);
+ pitches = gh_cdr (pitches);
+ SCM tonic = gh_car (pitches);
+ pitches = rebuild_from_base (pitches, tonic);
+ if (pitches != SCM_EOL)
{
- inversion.octave_i_ = (*pitch_arr_p)[0].octave_i () - 1;
- while (inversion < (*pitch_arr_p)[0])
- inversion.octave_i_++;
+ // UHUHUrg
+ inversion = Pitch (unsmob_pitch (gh_car (pitches))->octave_i_-1,
+ unsmob_pitch (inversion)->notename_i_,
+ unsmob_pitch (inversion)->alteration_i_).smobbed_copy ();
+ while (Pitch::less_p (inversion, gh_car (pitches)) == SCM_BOOL_T)
+ inversion = Pitch::transpose (inversion, Pitch (1, 0, 0).smobbed_copy ());
}
- for (int i = 0; i < pitch_arr_p->size (); i++)
- if ((*pitch_arr_p)[i] > inversion)
- {
- pitch_arr_p->insert (inversion, i);
- break;
- }
+ pitches = gh_cons (inversion, pitches);
+ return scm_sort_list (pitches,
+ scm_eval2 (ly_symbol2scm ("Pitch::less_p"),
+ SCM_EOL));
}
-void
-Chord::rebuild_with_bass (Array<Musical_pitch>* pitch_arr_p, int bass_i)
+SCM
+Chord::rebuild_with_bass (SCM pitches, SCM bass)
{
- assert (bass_i >= 0);
- Musical_pitch bass = pitch_arr_p->get (bass_i);
+ pitches = ly_remove_member (bass, pitches);
// is lowering fine, or should others be raised?
- if (pitch_arr_p->size ())
- while (bass > (*pitch_arr_p)[0])
- bass.octave_i_--;
- pitch_arr_p->insert (bass, 0);
+ if (pitches != SCM_EOL)
+ while (Pitch::less_p (gh_car (pitches), bass) == SCM_BOOL_T)
+ bass = Pitch::transpose (bass, Pitch (-1, 0, 0).smobbed_copy ());
+ return gh_cons (bass, pitches);
}
-// junk me
-Simultaneous_music *
-get_chord (SCM stonic,
- SCM sadd_arr_p,
- SCM ssub_arr_p,
- SCM sinversion_p,
- SCM sbass_p,
- SCM dur)
+
+/*********************************/
+/* Parser stuff */
+
+/* Construct from parser output:
+
+ (PITCHES . (INVERSION . BASS)) */
+SCM
+Chord::tonic_add_sub_inversion_bass_to_scm (SCM tonic, SCM add, SCM sub,
+ SCM inversion, SCM bass)
{
- Musical_pitch tonic = *unsmob_pitch (stonic);
+ SCM less = scm_eval2 (ly_symbol2scm ("Pitch::less_p"), SCM_EOL);
+
+ /* urg: catch dim modifier: 3rd, 5th, 7th, .. should be lowered */
+ bool dim_b = false;
+ for (SCM i = add; gh_pair_p (i); i = gh_cdr (i))
+ {
+ Pitch* p = unsmob_pitch (gh_car (i));
+ if (p->octave_i () == -100)
+ {
+ p->octave_i_ = 0;
+ dim_b = true;
+ }
+ }
+ add = transpose_pitches (tonic, add);
+ add = lower_step (tonic, add, gh_int2scm (7));
+ add = scm_sort_list (add, less);
+ add = ly_unique (add);
- Musical_pitch *inversion_p = unsmob_pitch( sinversion_p);
- Musical_pitch *bass_p = unsmob_pitch (sbass_p);
-
- Array<Musical_pitch> add_arr_p;
- Array<Musical_pitch> sub_arr_p;
+ sub = transpose_pitches (tonic, sub);
+ sub = lower_step (tonic, sub, gh_int2scm (7));
+ sub = scm_sort_list (sub, less);
+
+ /* default chord includes upto 5: <1, 3, 5> */
+ add = gh_cons (tonic, add);
+ SCM tmp = add;
+
+ SCM fifth = ly_last (base_pitches (tonic));
+ int highest_step = gh_scm2int (step_scm (tonic, ly_last (tmp)));
+ if (highest_step < 5)
+ tmp = ly_snoc (fifth, tmp);
+ else if (dim_b)
+ add = lower_step (tonic, add, gh_int2scm (5));
+
+ /* find missing thirds */
+ SCM missing = missing_thirds (tmp);
+ if (highest_step < 5)
+ missing = ly_snoc (fifth, missing);
- for (SCM s = sadd_arr_p ; gh_pair_p (s); s = gh_cdr (s))
- add_arr_p.push (*unsmob_pitch (gh_car (s)));
- for (SCM s = ssub_arr_p ; gh_pair_p (s); s = gh_cdr (s))
- sub_arr_p.push (*unsmob_pitch (gh_car (s)));
+ /* if dim modifier is given: lower all missing */
+ if (dim_b)
+ missing = lower_step (tonic, missing, gh_int2scm (0));
+
+ /* if additions include any 3, don't add third */
+ SCM third = gh_cadr (base_pitches (tonic));
+ if (member_notename (third, add) != SCM_BOOL_F)
+ missing = ly_remove_member (third, missing);
+
+ /* if additions include any 4, assume sus4 and don't add third implicitely
+ C-sus (4) = c f g (1 4 5) */
+ SCM sus = Pitch::transpose (tonic, Pitch (0, 3, 0).smobbed_copy ());
+ if (member_notename (sus, add) != SCM_BOOL_F)
+ missing = ly_remove_member (third, missing);
+
+ /* if additions include some 5, don't add fifth */
+ if (member_notename (fifth, add) != SCM_BOOL_F)
+ missing = ly_remove_member (fifth, missing);
+
+ /* complete the list of thirds to be added */
+ add = gh_append2 (missing, add);
+ add = scm_sort_list (add, less);
- sub_arr_p.reverse ();
- add_arr_p.reverse ();
+ SCM pitches = SCM_EOL;
+ /* Add all that aren't subtracted */
+ for (SCM i = add; gh_pair_p (i); i = gh_cdr (i))
+ {
+ SCM p = gh_car (i);
+ SCM s = member_notename (p, sub);
+ if (s != SCM_BOOL_F)
+ sub = ly_remove_member (s, sub);
+ else
+ pitches = gh_cons (p, pitches);
+ }
+ pitches = scm_sort_list (pitches, less);
+
+ for (SCM i = sub; gh_pair_p (i); i = gh_cdr (i))
+ warning (_f ("invalid subtraction: not part of chord: %s",
+ unsmob_pitch (gh_car (i))->str ()));
- /*
- UARGAUGRAGRUAUGRUINAGRAUGIRNA
+ return gh_cons (pitches, gh_cons (inversion, bass));
+}
- ugh
- */
- Chord chord = to_chord (tonic, &add_arr_p, &sub_arr_p, inversion_p, bass_p);
- inversion_p = 0;
- bass_p = 0;
+/*
+ junk me
+
+ snapnie
+
+ Een chord invoer bestaat uit een naam. Maar, we willen een aantal
+ pitch-requests doen, zodat na het parsen van een chord geen verschil
+ meer is met een gewoon accoord. Die vertaalslag is behoorlijk
+ harig, hoe wil je dit junken? Nouja, cleanup lijkt me aardige
+ eerste stap enniewee.
+
+
+ --Het lijkt me dat dit in het paarse gedeelte moet.
+
+ Zo-en-zo, lijktme dat je ipv. Inversion_req een (inversion . #t) aan
+ de betreffende Noot_req kan hangen
+*/
+
+Simultaneous_music *
+Chord::get_chord (SCM tonic, SCM add, SCM sub, SCM inversion, SCM bass, SCM dur)
+{
+ SCM chord = tonic_add_sub_inversion_bass_to_scm (tonic, add, sub,
+ inversion, bass);
+
Tonic_req* t = new Tonic_req;
- t->set_mus_property ("pitch", tonic.smobbed_copy ());
+ t->set_mus_property ("pitch", tonic);
SCM l = gh_cons (t->self_scm (), SCM_EOL);
+ SCM modifiers = gh_cdr (chord);
+ inversion = gh_car (modifiers);
+ bass = gh_cdr (modifiers);
+
//urg
- if (chord.inversion_b_
- && Chord::find_notename_i (&chord.pitch_arr_, chord.inversion_pitch_) > 0)
+ if (inversion != SCM_EOL)
{
Inversion_req* i = new Inversion_req;
- i->set_mus_property ("pitch", chord.inversion_pitch_.smobbed_copy ());
+ i->set_mus_property ("pitch", inversion);
l = gh_cons (i->self_scm (), l);
scm_unprotect_object (i->self_scm ());
}
- if (chord.bass_b_)
+ if (bass != SCM_EOL)
{
Bass_req* b = new Bass_req;
- b->set_mus_property ("pitch", chord.bass_pitch_.smobbed_copy ());
+ b->set_mus_property ("pitch", bass);
l = gh_cons (b->self_scm (), l);
scm_unprotect_object (b->self_scm ());
}
- Array<Musical_pitch> pitch_arr = chord.to_pitch_arr ();
- for (int i = pitch_arr.size (); --i >= 0;)
+ SCM pitches = Chord::to_pitches (chord);
+ for (SCM i = pitches; gh_pair_p (i); i = gh_cdr (i))
{
Note_req* n = new Note_req;
- n->set_mus_property ("pitch", pitch_arr[i].smobbed_copy ());
+ n->set_mus_property ("pitch", gh_car (i));
n->set_mus_property ("duration", dur);
l = gh_cons (n->self_scm (), l);
void
-Key_change_req::transpose (Musical_pitch p)
+Key_change_req::transpose (Pitch p)
{
SCM newlist = SCM_EOL;
SCM pa = get_mus_property ("pitch-alist");
SCM alter = gh_cdar (s);
if (gh_pair_p (key))
{
- Musical_pitch orig (gh_scm2int (gh_car (key)),
+ Pitch orig (gh_scm2int (gh_car (key)),
gh_scm2int (gh_cdr (key)),
gh_scm2int (alter));
}
else if (gh_number_p (key))
{
- Musical_pitch orig (0, gh_scm2int (key), gh_scm2int (alter));
+ Pitch orig (0, gh_scm2int (key), gh_scm2int (alter));
orig.transpose (p);
key =gh_int2scm (orig.notename_i_);
/*
- crescendo.cc -- implement Crescendo
+ crescendo.cc -- implement Hairpin
source file of the GNU LilyPond music typesetter
#include "debug.hh"
#include "paper-column.hh"
-MAKE_SCHEME_CALLBACK (Crescendo, brew_molecule, 1);
+MAKE_SCHEME_CALLBACK (Hairpin, brew_molecule, 1);
SCM
-Crescendo::brew_molecule (SCM smob)
+Hairpin::brew_molecule (SCM smob)
{
Score_element *me= unsmob_element (smob);
Spanner *span = dynamic_cast<Spanner*>(me);
}
Direction grow_dir = to_dir (s);
-
+ Real padding = gh_scm2double (me->get_elt_property ("padding"));
Real width = span->spanner_length ();
width -= span->get_broken_left_end_align ();
}
Drul_array<bool> broken;
+ Drul_array<Real> extra_off;
Direction d = LEFT;
do
{
- Paper_column* s = dynamic_cast<Paper_column*> (span->get_bound (d)); // UGH
- broken[d] = (!s->musical_b ());
+ Item *b = span->get_bound (d);
+ broken[d] = b->break_status_dir () != CENTER;
+
+ if (!broken [d])
+ {
+ Real r = b->extent (b, X_AXIS)[-d] + padding;
+ width += d * r;
+ extra_off[d] = r;
+ }
}
while (flip (&d) != LEFT);
Box b (Interval (0, width), Interval (-2*height, 2*height));
Molecule mol (b, hairpin);
- mol.translate_axis (broken_left, X_AXIS);
+ mol.translate_axis (broken_left + extra_off[LEFT], X_AXIS);
return mol.smobbed_copy ();
}
Item * create_custos();
bool custos_permitted;
Link_array<Score_element> custos_arr_;
- Array<Musical_pitch> pitches_;
+ Array<Pitch> pitches_;
};
Custos_engraver::Custos_engraver ()
SCM_UNDEFINED);
}
}
-
- Score_element *cc = unsmob_element (get_property ("currentMusicalColumn"));
- cresc_p_->set_bound (LEFT, cc);
-
- if (script_p_)
- {
- Side_position::set_direction (script_p_, LEFT);
- Side_position::set_axis (script_p_, X_AXIS);
- Side_position::add_support (script_p_, cresc_p_);
- }
-
+ cresc_p_->set_bound (LEFT, script_p_
+ ? script_p_
+ : unsmob_element (get_property ("currentMusicalColumn")));
+
Axis_group_interface::add_element (line_spanner_, cresc_p_);
announce_element (cresc_p_, accepted_spanreqs_drul_[START]);
}
{
if (finished_cresc_p_)
{
+ finished_cresc_p_->set_bound (RIGHT, script_p_
+ ? script_p_
+ : unsmob_element (get_property ("currentMusicalColumn")));
+
typeset_element (finished_cresc_p_);
finished_cresc_p_ =0;
}
#include "string.hh"
#include "audio-element.hh"
-#include "musical-pitch.hh"
+#include "pitch.hh"
#include "moment.hh"
#include "drul-array.hh"
class Audio_note : public Audio_item
{
public:
- Audio_note (Musical_pitch p, Moment m, int transposing_i = 0);
+ Audio_note (Pitch p, Moment m, int transposing_i = 0);
void tie_to (Audio_note*);
- Musical_pitch pitch_;
+ Pitch pitch_;
Moment length_mom_;
Moment delayed_mom_;
Moment delayed_until_mom_;
virtual void process (Moment);
- Array<Musical_pitch> pending_pitch (Moment)const;
+ Array<Pitch> pending_pitch (Moment)const;
private:
#ifndef CHORD_HH
#define CHORD_HH
-#include "array.hh"
-#include "musical-pitch.hh"
-#include "lily-proto.hh"
-
-
+#include "pitch.hh"
/*
- Slightly on the hairy side? In any case COMMENTME.
+ ``chord'' is encoded:
+ (PITCHES . (INVERSION . BASS))
+
+ Chord:: namespace...
*/
class Chord
{
public:
- static Array<Musical_pitch> base_arr (Musical_pitch p);
- static int find_tonic_i (Array<Musical_pitch> const*);
- static int find_pitch_i (Array<Musical_pitch> const*, Musical_pitch p);
- static int find_notename_i (Array<Musical_pitch> const*, Musical_pitch p);
- static Array<Musical_pitch> missing_thirds_pitch_arr (Array<Musical_pitch> const* pitch_arr_p);
- static void rebuild_from_base (Array<Musical_pitch>*, int base_i);
- static void rebuild_insert_inversion (Array<Musical_pitch>*, int tonic_i);
- static void rebuild_transpose (Array<Musical_pitch>*, Musical_pitch tonic, bool fix7_b);
- static void rebuild_with_bass (Array<Musical_pitch>*, int bass_i);
- static int step_i (Musical_pitch tonic, Musical_pitch p);
-
-
- Chord ();
- Chord (Array<Musical_pitch> pitch_arr, Musical_pitch* inversion_p, Musical_pitch* bass_p);
- Chord (Chord const&);
-
- Array<Musical_pitch> to_pitch_arr () const;
-
- Array<Musical_pitch> pitch_arr_;
- bool inversion_b_;
- Musical_pitch inversion_pitch_;
- bool bass_b_;
- Musical_pitch bass_pitch_;
+ static SCM pitches_and_requests_to_chord (SCM pitches,
+ SCM tonic_req,
+ SCM inversion_req,
+ SCM bass_req,
+ bool find_inversion_b);
+ static SCM base_pitches (SCM tonic);
+ static SCM transpose_pitches (SCM tonic, SCM pitches);
+ static SCM lower_step (SCM tonic, SCM pitches, SCM step);
+ static SCM member_notename (SCM p, SCM pitches);
+ static int step_i (Pitch tonic, Pitch p);
+ static SCM step_scm (SCM tonic, SCM p);
+ static SCM missing_thirds (SCM pitches);
+ static SCM to_pitches (SCM chord);
+ static SCM guess_tonic (SCM pitches);
+ static SCM rebuild_from_base (SCM pitches, SCM base);
+ static SCM rebuild_insert_inversion (SCM pitches); //, SCM tonic);
+ static SCM rebuild_with_bass (SCM pitches, SCM bass);
+ static SCM tonic_add_sub_inversion_bass_to_scm (SCM tonic, SCM add, SCM sub,
+ SCM inversion, SCM bass);
+ static Simultaneous_music *get_chord (SCM tonic, SCM add, SCM sub, SCM inversion, SCM bass, SCM dur);
};
-Chord to_chord (Musical_pitch tonic, Array<Musical_pitch>* add_arr_p, Array<Musical_pitch>* sub_arr_p, Musical_pitch* inversion_p, Musical_pitch* bass_p);
-
-Chord to_chord (Array<Musical_pitch> pitch_arr, Tonic_req* tonic_req, Inversion_req* inversion_req, Bass_req* bass_req, bool find_inversion_b);
-
-int compare (Chord*, Chord*);
-
-Simultaneous_music *get_chord (SCM tonic,
- SCM add_arr_p,
- SCM sub_arr_p,
- SCM inversion_p,
- SCM bass_p,
- SCM d);
-
-
-
-#endif // CHORD_HH
+#endif /* CHORD_HH */
#include "request.hh"
#include "array.hh"
#include "duration.hh"
-#include "musical-pitch.hh"
+#include "pitch.hh"
#include "protected-scm.hh"
class Break_req : public Request {
protected:
VIRTUAL_COPY_CONS(Music);
- void transpose (Musical_pitch d);
+ void transpose (Pitch d);
bool do_equal_b (Request const * )const;
};
/*
- crescendo.hh -- declare Crescendo
+ crescendo.hh -- declare Hairpin
source file of the GNU LilyPond music typesetter
/**
The hairpin symbol.
*/
-struct Crescendo
+struct Hairpin
{
public:
DECLARE_SCHEME_CALLBACK (brew_molecule, (SCM));
class Music_sequence;
class Music_wrapper;
class Music_wrapper_iterator;
-class Musical_pitch;
+class Pitch;
class Musical_req;
class My_lily_lexer;
class Note_performer;
#include "array.hh"
-#include "musical-pitch.hh"
+#include "pitch.hh"
class Local_key_item
{
static Molecule parenthesize (Score_element*me, Molecule) ;
public:
DECLARE_SCHEME_CALLBACK(brew_molecule, (SCM ));
- static void add_pitch (Score_element*me, Musical_pitch, bool cautionary, bool natural);
+ static void add_pitch (Score_element*me, Pitch, bool cautionary, bool natural);
static bool has_interface (Score_element*);
static void set_interface (Score_element*);
};
Music * lyrics_l () const;
Lyric_combine_music (Music*, Music*);
- virtual void transpose (Musical_pitch);
+ virtual void transpose (Pitch);
VIRTUAL_COPY_CONS(Music);
virtual Moment length_mom () const;
- virtual Musical_pitch to_relative_octave (Musical_pitch);
+ virtual Pitch to_relative_octave (Pitch);
virtual void compress (Moment);
};
#endif /* LYRIC_COMBINE_MUSIC_HH */
public:
VIRTUAL_COPY_CONS(Music);
Simultaneous_music(SCM);
- virtual Musical_pitch to_relative_octave (Musical_pitch);
+ virtual Pitch to_relative_octave (Pitch);
virtual Moment length_mom () const;
};
{
public:
VIRTUAL_COPY_CONS(Music);
- virtual Musical_pitch to_relative_octave (Musical_pitch);
+ virtual Pitch to_relative_octave (Pitch);
Request_chord(SCM list);
};
void append_music (Music *);
VIRTUAL_COPY_CONS(Music);
- Musical_pitch do_relative_octave (Musical_pitch p, bool b);
- virtual void transpose (Musical_pitch );
+ Pitch do_relative_octave (Pitch p, bool b);
+ virtual void transpose (Pitch );
void truncate (int k);
virtual void compress (Moment);
int length_i () const;
Moment maximum_length () const;
protected:
- virtual Musical_pitch to_relative_octave (Musical_pitch);
+ virtual Pitch to_relative_octave (Pitch);
};
#define MUSIC_WRAPPER_HH
#include "music.hh"
-#include "musical-pitch.hh"
+#include "pitch.hh"
/** A Music that modifies an existing Music. This data structure
corresponds to a production that takes a single Music argument,
public:
Music_wrapper (Music*);
Music * element () const;
- virtual void transpose (Musical_pitch);
+ virtual void transpose (Pitch);
VIRTUAL_COPY_CONS(Music);
virtual Moment length_mom () const;
- virtual Musical_pitch to_relative_octave (Musical_pitch);
+ virtual Pitch to_relative_octave (Pitch);
virtual void compress (Moment);
};
void set_mus_pointer (const char*, SCM val);
SCM remove_mus_property (const char* nm);
- virtual Musical_pitch to_relative_octave (Musical_pitch);
+ virtual Pitch to_relative_octave (Pitch);
/// The duration of this piece of music
virtual Moment length_mom () const;
void print() const;
/// Transpose, with the interval central C to #p#
- virtual void transpose (Musical_pitch p);
+ virtual void transpose (Pitch p);
/// Scale the music in time by #factor#.
virtual void compress (Moment factor);
-/*
- musical-pitch.hh -- declare Musical_pitch
-
- source file of the GNU LilyPond music typesetter
-
- (c) 1998--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
-
- */
-
-#ifndef MUSICAL_PITCH_HH
-#define MUSICAL_PITCH_HH
-
-#include "lily-proto.hh"
-#include "smobs.hh"
-
-/** A "tonal" pitch. This is a pitch as it figures in diatonal western
- music (12 semitones in an octave), as opposed to a frequence in Hz
- or a integer number of semitones.
-
-
-
-
-*/
-class Musical_pitch
-{
-public: // fixme
-
- /// 0 is c, 6 is b
- int notename_i_;
-
- /// 0 natural, 1 sharp, etc
- int alteration_i_;
-
- /// 0 is central c
- int octave_i_;
-public:
-
- int octave_i () const;
- int notename_i () const;
- int alteration_i () const;
-
- /*
- Musical_pitch is lexicographically ordered by (octave, notename,
- alteration).
- */
- Musical_pitch (int octave, int notename,int accidental);
- Musical_pitch ();
-
- Musical_pitch to_relative_octave (Musical_pitch);
- void transpose (Musical_pitch);
- static int compare (Musical_pitch const&,Musical_pitch const&);
- /// return large part of interval from central c
- int steps() const;
- /// return pitch from central c (in halfnotes)
- int semitone_pitch() const;
- void up_to (int);
- void down_to (int);
- String str () const;
-
- SCM smobbed_copy () const;
- DECLARE_SCHEME_CALLBACK(less_p, (SCM a, SCM b));
- DECLARE_SIMPLE_SMOBS(Musical_pitch,);
-};
-
-Musical_pitch* unsmob_pitch (SCM);
-
-#include "compare.hh"
-INSTANTIATE_COMPARE(Musical_pitch, Musical_pitch::compare);
-
-int compare (Array<Musical_pitch>*, Array<Musical_pitch>*);
-
-#endif /* MUSICAL_PITCH_HH */
-
#include "lily-proto.hh"
#include "request.hh"
#include "duration.hh"
-#include "musical-pitch.hh"
+#include "pitch.hh"
#include "array.hh"
/** a request with a duration.
{
protected:
/// transpose. #delta# is relative to central c.
- virtual void transpose (Musical_pitch delta);
+ virtual void transpose (Pitch delta);
virtual bool do_equal_b (Request const*) const;
VIRTUAL_COPY_CONS(Music);
#include "string.hh"
#include "includable-lexer.hh"
#include "duration.hh"
-#include "musical-pitch.hh"
+#include "pitch.hh"
#include "protected-scm.hh"
bool busy_parsing();
#include "lily-proto.hh"
#include "lily-proto.hh"
#include "duration.hh"
-#include "musical-pitch.hh"
+#include "pitch.hh"
#include "string.hh"
#include "array.hh"
#include "input.hh"
char const* here_ch_C() const;
- Simultaneous_music * get_chord (Musical_pitch tonic, Array<Musical_pitch>* add_arr_p,
- Array<Musical_pitch>* sub_arr_p, Musical_pitch* inversion_p,
- Musical_pitch* bass_p, Duration d);
+ Simultaneous_music * get_chord (Pitch tonic, Array<Pitch>* add_arr_p,
+ Array<Pitch>* sub_arr_p, Pitch* inversion_p,
+ Pitch* bass_p, Duration d);
void set_chord_tremolo (int type_i);
void set_last_duration (Duration const *);
- void set_last_pitch (Musical_pitch const *);
+ void set_last_pitch (Pitch const *);
friend int yyparse (void*);
};
Music * first_l () const;
Music * second_l () const;
- virtual void transpose (Musical_pitch);
+ virtual void transpose (Pitch);
virtual Moment length_mom () const;
- virtual Musical_pitch to_relative_octave (Musical_pitch);
+ virtual Pitch to_relative_octave (Pitch);
virtual void compress (Moment);
};
--- /dev/null
+/*
+ pitch.hh -- declare Pitch
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1998--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+
+ */
+
+#ifndef MUSICAL_PITCH_HH
+#define MUSICAL_PITCH_HH
+
+#include "lily-proto.hh"
+#include "smobs.hh"
+
+/** A "tonal" pitch. This is a pitch as it figures in diatonal western
+ music (12 semitones in an octave), as opposed to a frequence in Hz
+ or a integer number of semitones.
+
+*/
+class Pitch
+{
+public: // fixme
+ /*
+ TODO: use SCM -- (make private?)
+ */
+
+ /// 0 is c, 6 is b
+ int notename_i_;
+
+ /// 0 natural, 1 sharp, etc
+ int alteration_i_;
+
+ /// 0 is central c
+ int octave_i_;
+ /*
+ mutators, so JUNKME.
+ */
+ void transpose (Pitch);
+ void up_to (int);
+ void down_to (int);
+
+public:
+
+ int octave_i () const;
+ int notename_i () const;
+ int alteration_i () const;
+
+ /*
+ Pitch is lexicographically ordered by (octave, notename,
+ alteration).
+ */
+ Pitch (int octave, int notename,int accidental);
+ Pitch ();
+
+ Pitch to_relative_octave (Pitch);
+
+ static int compare (Pitch const&,Pitch const&);
+ /// return large part of interval from central c
+ int steps() const;
+ /// return pitch from central c (in halfnotes)
+ int semitone_pitch() const;
+ String str () const;
+
+ static SCM transpose (SCM p, SCM delta);
+
+ SCM smobbed_copy () const;
+ DECLARE_SCHEME_CALLBACK(less_p, (SCM a, SCM b));
+ DECLARE_SIMPLE_SMOBS(Pitch,);
+
+
+};
+
+Pitch* unsmob_pitch (SCM);
+
+#include "compare.hh"
+INSTANTIATE_COMPARE(Pitch, Pitch::compare);
+
+int compare (Array<Pitch>*, Array<Pitch>*);
+
+#endif /* MUSICAL_PITCH_HH */
+
+
class Relative_octave_music : public Music_wrapper
{
public:
- Musical_pitch last_pitch_;
+ Pitch last_pitch_;
- Relative_octave_music (Music*, Musical_pitch);
+ Relative_octave_music (Music*, Pitch);
VIRTUAL_COPY_CONS(Music);
- virtual Musical_pitch to_relative_octave (Musical_pitch);
+ virtual Pitch to_relative_octave (Pitch);
};
/// how often do we repeat?
int repeat_count( ) const;
- virtual Musical_pitch to_relative_octave (Musical_pitch);
+ virtual Pitch to_relative_octave (Pitch);
Moment body_length_mom () const;
Moment alternatives_length_mom (bool fold) const;
DECLARE_SCHEME_CALLBACK(folded_music_length, (SCM));
/// Transpose, with the interval central C to #p#
- virtual void transpose (Musical_pitch p);
+ virtual void transpose (Pitch p);
/// Scale the music in time by #factor#.
virtual void compress (Moment factor);
class Transposed_music : public Music_wrapper
{
public:
- Musical_pitch transpose_to_pitch_;
+ Pitch transpose_to_pitch_;
- Transposed_music (Music*, Musical_pitch);
+ Transposed_music (Music*, Pitch);
VIRTUAL_COPY_CONS(Music);
- virtual Musical_pitch to_relative_octave (Musical_pitch);
+ virtual Pitch to_relative_octave (Pitch);
};
#endif /* TRANSPOSED_MUSIC_HH */
#include "staff-symbol-referencer.hh"
#include "translator-group.hh"
#include "engraver.hh"
-#include "musical-pitch.hh"
+#include "pitch.hh"
#include "protected-scm.hh"
#include "clef.hh"
return gh_str02scm ((char*)c);
}
-
-
/*
Pass string to scm parser, evaluate one expression.
Return result value and #chars read.
/*
- local-key-item.cc -- implement Local_key_item, Musical_pitch
+ local-key-item.cc -- implement Local_key_item, Pitch
source file of the GNU LilyPond music typesetter
static SCM
pitch_less (SCM p1, SCM p2)
{
- return Musical_pitch::less_p (gh_car (p1), gh_car (p2));
+ return Pitch::less_p (gh_car (p1), gh_car (p2));
}
static SCM pitch_less_proc;
void
-Local_key_item::add_pitch (Score_element*me, Musical_pitch p, bool cautionary, bool natural)
+Local_key_item::add_pitch (Score_element*me, Pitch p, bool cautionary, bool natural)
{
SCM acs = me->get_elt_property ("accidentals");
SCM pitch = p.smobbed_copy ();
for (SCM s = accs;
gh_pair_p (s); s = gh_cdr (s))
{
- Musical_pitch p (*unsmob_pitch (gh_caar (s)));
+ Pitch p (*unsmob_pitch (gh_caar (s)));
SCM opts = gh_cdar (s);
// do one octave
#include "lyric-combine-music.hh"
#include "lyric-combine-music-iterator.hh"
-#include "musical-pitch.hh"
+#include "pitch.hh"
Lyric_combine_music::Lyric_combine_music (Music * m, Music * l)
{
void
-Lyric_combine_music::transpose (Musical_pitch p)
+Lyric_combine_music::transpose (Pitch p)
{
music_l ()->transpose (p);
lyrics_l () ->transpose (p);
return music_l ()->length_mom ();
}
-Musical_pitch
-Lyric_combine_music::to_relative_octave ( Musical_pitch p )
+Pitch
+Lyric_combine_music::to_relative_octave ( Pitch p )
{
p = music_l ()->to_relative_octave (p);
return lyrics_l () ->to_relative_octave (p);
#include "music-list.hh"
#include "music-wrapper.hh"
-#include "musical-pitch.hh"
+#include "pitch.hh"
#include "request.hh"
#include "musical-request.hh"
#include "music-iterator.hh"
return cumulative_length ();
}
-Musical_pitch
-Simultaneous_music::to_relative_octave (Musical_pitch p)
+Pitch
+Simultaneous_music::to_relative_octave (Pitch p)
{
return do_relative_octave (p, true);
}
Request_chord_iterator::constructor_cxx_function);
}
-Musical_pitch
-Request_chord::to_relative_octave (Musical_pitch last)
+Pitch
+Request_chord::to_relative_octave (Pitch last)
{
for (SCM s = music_list (); gh_pair_p (s); s = gh_cdr (s))
{
Music * mus = unsmob_music (gh_car (s));
if (Melodic_req *m= dynamic_cast <Melodic_req *> (mus))
{
- Musical_pitch pit = *unsmob_pitch (m->get_mus_property ("pitch"));
+ Pitch pit = *unsmob_pitch (m->get_mus_property ("pitch"));
pit.to_relative_octave (last);
m->set_mus_property ("pitch", pit.smobbed_copy());
*/
#include "music-list.hh"
#include "debug.hh"
-#include "musical-pitch.hh"
+#include "pitch.hh"
void
}
void
-Music_sequence::transpose (Musical_pitch rq)
+Music_sequence::transpose (Pitch rq)
{
for (SCM s = music_list (); gh_pair_p (s); s = gh_cdr (s))
unsmob_music (gh_car (s))->transpose (rq);
return last;
}
-Musical_pitch
-Music_sequence::to_relative_octave (Musical_pitch p)
+Pitch
+Music_sequence::to_relative_octave (Pitch p)
{
return do_relative_octave (p, false);
}
return scm_ilength (music_list ());
}
-Musical_pitch
-Music_sequence::do_relative_octave (Musical_pitch p, bool ret_first)
+Pitch
+Music_sequence::do_relative_octave (Pitch p, bool ret_first)
{
- Musical_pitch retval;
+ Pitch retval;
int count=0;
- Musical_pitch last = p;
+ Pitch last = p;
for (SCM s = music_list (); gh_pair_p (s); s = gh_cdr (s))
{
last = unsmob_music (gh_car (s))->to_relative_octave (last);
void
-Music_wrapper::transpose (Musical_pitch p)
+Music_wrapper::transpose (Pitch p)
{
if (element ())
element ()-> transpose (p);
return element ()->length_mom ();
}
-Musical_pitch
-Music_wrapper::to_relative_octave (Musical_pitch p)
+Pitch
+Music_wrapper::to_relative_octave (Pitch p)
{
return element ()->to_relative_octave (p);
}
#include "music.hh"
#include "music-list.hh"
#include "debug.hh"
-#include "musical-pitch.hh"
+#include "pitch.hh"
#include "ly-smobs.icc"
SCM
return 1;
}
-Musical_pitch
-Music::to_relative_octave (Musical_pitch m)
+Pitch
+Music::to_relative_octave (Pitch m)
{
return m;
}
void
-Music::transpose (Musical_pitch )
+Music::transpose (Pitch )
{
}
+++ /dev/null
-/*
- musical-pitch.cc -- implement Musical_pitch
-
- source file of the GNU LilyPond music typesetter
-
- (c) 1998--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
-
- */
-#include "musical-pitch.hh"
-#include "debug.hh"
-#include "main.hh"
-#include "ly-smobs.icc"
-
-int
-compare (Array<Musical_pitch>* left, Array<Musical_pitch>* right)
-{
- assert (left);
- assert (right);
-
- if (left->size () == right->size ())
- {
- for (int i = 0; i < left->size (); i++)
- {
- int r = Musical_pitch::compare ((*left)[i], (*right)[i]);
- if (r)
- return r;
- }
- }
- else
- return 1;
-
- return 0;
-}
-
-Musical_pitch::Musical_pitch (int o, int n, int a)
-{
- notename_i_ = n;
- alteration_i_ = a;
- octave_i_ = o;
-
- if (n < 0 || n >= 7 ||
- a < -2 || a > 2)
- {
- String s = _("Pitch arguments out of range");
- s += ": alteration = " + to_str (a);
- s += ", notename = " + to_str (n);
- warning (s);
- }
-}
-
-Musical_pitch::Musical_pitch ()
-{
- notename_i_ = 0;
- alteration_i_ = 0;
- octave_i_ = 0;
-}
-
-int
-Musical_pitch::compare (Musical_pitch const &m1, Musical_pitch const &m2)
-{
- int o= m1.octave_i_ - m2.octave_i_;
- int n = m1.notename_i_ - m2.notename_i_;
- int a = m1.alteration_i_ - m2.alteration_i_;
-
- if (o)
- return o;
- if (n)
- return n;
- if (a)
- return a;
- return 0;
-}
-
-int
-Musical_pitch::steps () const
-{
- return notename_i_ + octave_i_*7;
-}
-
-/*
- should be settable from input?
- */
-static Byte pitch_byte_a[ ] = { 0, 2, 4, 5, 7, 9, 11 };
-
-int
-Musical_pitch::semitone_pitch () const
-{
- return pitch_byte_a[ notename_i_ % 7 ] + alteration_i_ + octave_i_ * 12;
-}
-
-void
-Musical_pitch::transpose (Musical_pitch delta)
-{
- int old_pitch = semitone_pitch ();
- int delta_pitch = delta.semitone_pitch ();
- octave_i_ += delta.octave_i_;
- notename_i_ += delta.notename_i_;
-
-
- while (notename_i_ >= 7)
- {
- notename_i_ -= 7;
- octave_i_ ++;
- }
-
- int new_pitch = semitone_pitch ();
- int delta_acc = new_pitch - old_pitch - delta_pitch;
- alteration_i_ -= delta_acc;
-}
-
-
-#if 0
-// nice test for internationalisation strings
-char const *accname[] = {"double flat", "flat", "natural",
- "sharp" , "double sharp"};
-#else
-char const *accname[] = {"eses", "es", "", "is" , "isis"};
-#endif
-
-String
-Musical_pitch::str () const
-{
- int n = (notename_i_ + 2) % 7;
- String s = to_str (char(n + 'a'));
- if (alteration_i_)
- s += String (accname[alteration_i_ + 2]);
-
- if (octave_i_ > 0)
- {
- int o = octave_i_ + 1;
- while (o--)
- s += "'";
- }
- else if (octave_i_ <0)
- {
- int o = (-octave_i_) - 1;
- while (o--)
- s += to_str (',');
- }
-
-
- return s;
-}
-
-/*
- change me to relative, counting from last pitch p
- return copy of resulting pitch
- */
-Musical_pitch
-Musical_pitch::to_relative_octave (Musical_pitch p)
-{
- int oct_mod = octave_i_ + 1; // account for c' = octave 1 iso. 0 4
- Musical_pitch up_pitch (p);
- Musical_pitch down_pitch (p);
-
- up_pitch.alteration_i_ = alteration_i_;
- down_pitch.alteration_i_ = alteration_i_;
-
- Musical_pitch n = *this;
- up_pitch.up_to (notename_i_);
- down_pitch.down_to (notename_i_);
-
- int h = p.steps ();
- if (abs (up_pitch.steps () - h) < abs (down_pitch.steps () - h))
- n = up_pitch;
- else
- n = down_pitch;
-
- n.octave_i_ += oct_mod;
-
- *this = n;
- return *this;
-}
-
-void
-Musical_pitch::up_to (int notename)
-{
- if (notename_i_ > notename)
- {
- octave_i_ ++;
- }
- notename_i_ = notename;
-}
-
-void
-Musical_pitch::down_to (int notename)
-{
- if (notename_i_ < notename)
- {
- octave_i_ --;
- }
- notename_i_ = notename;
-}
-
-/****************************************************************/
-
-
-IMPLEMENT_TYPE_P(Musical_pitch, "pitch?");
-IMPLEMENT_UNSMOB(Musical_pitch, pitch);
-SCM
-Musical_pitch::mark_smob (SCM )
-{
- return SCM_EOL;
-}
-
-IMPLEMENT_SIMPLE_SMOBS(Musical_pitch);
-
-
-int
-Musical_pitch::print_smob (SCM s, SCM port, scm_print_state *)
-{
- Musical_pitch *r = (Musical_pitch *) gh_cdr (s);
-
- scm_puts ("#<Musical_pitch ", port);
- scm_display (gh_str02scm ((char*)r->str().ch_C()), port);
- scm_puts (" >", port);
-
- return 1;
-}
-
-SCM
-Musical_pitch::equal_p (SCM a , SCM b)
-{
- Musical_pitch *p = (Musical_pitch *) gh_cdr (a);
- Musical_pitch *q = (Musical_pitch *) gh_cdr (b);
-
- bool eq = p->notename_i_ == q->notename_i_
- && p->octave_i_ == q->octave_i_
- && p->alteration_i_ == q->alteration_i_;
-
- return eq ? SCM_BOOL_T : SCM_BOOL_F;
-}
-
-MAKE_SCHEME_CALLBACK(Musical_pitch, less_p, 2);
-SCM
-Musical_pitch::less_p (SCM p1, SCM p2)
-{
- Musical_pitch *a = unsmob_pitch (p1);
- Musical_pitch *b = unsmob_pitch (p2);
-
- if (compare(*a, *b) < 0 )
- return SCM_BOOL_T;
- else
- return SCM_BOOL_F;
-}
-
-/*
- should add optional args
- */
-
-static SCM
-make_pitch (SCM o, SCM n, SCM a)
-{
- Musical_pitch p;
- p.octave_i_ = gh_scm2int (o);
- p.notename_i_ = gh_scm2int (n);
- p.alteration_i_ = gh_scm2int (a);
- return p.smobbed_copy ();
-}
-
-static SCM
-pitch_octave (SCM pp)
-{
- Musical_pitch *p = unsmob_pitch (pp);
- int q = 0;
- if (!p)
- warning ("Not a pitch");
- else
- q = p->octave_i();
-
- return gh_int2scm (q);
-}
-
-static SCM
-pitch_alteration (SCM pp)
-{
- Musical_pitch *p = unsmob_pitch (pp);
- int q = 0;
- if (!p)
- warning ("Not a pitch");
- else
- q = p->alteration_i();
-
- return gh_int2scm (q);
-}
-
-static SCM
-pitch_notename (SCM pp)
-{
- Musical_pitch *p = unsmob_pitch (pp);
- int q = 0;
- if (!p)
- warning ("Not a pitch");
- else
- q = p->notename_i();
-
- return gh_int2scm (q);
-}
-
-static SCM
-pitch_semitones (SCM pp)
-{
- Musical_pitch *p = unsmob_pitch (pp);
- int q = 0;
- if (!p)
- warning ("Not a pitch");
- else
- q = p->steps();
-
- return gh_int2scm (q);
-}
-
-static void
-add_funcs()
-{
- scm_make_gsubr ("make-pitch", 3, 0, 0, (Scheme_function_unknown)make_pitch);
- scm_make_gsubr ("pitch-octave", 1, 0, 0, (Scheme_function_unknown)pitch_octave);
- scm_make_gsubr ("pitch-notename", 1, 0, 0, (Scheme_function_unknown)pitch_notename);
- scm_make_gsubr ("pitch-alteration", 1, 0, 0, (Scheme_function_unknown)pitch_alteration);
- scm_make_gsubr ("pitch-semitones", 1, 0, 0, (Scheme_function_unknown)pitch_semitones);
-}
-
-ADD_SCM_INIT_FUNC(pitch, add_funcs);
-
-SCM
-Musical_pitch::smobbed_copy ()const
-{
- Musical_pitch * p = new Musical_pitch (*this);
- return p->smobbed_self ();
-}
-
-int
-Musical_pitch::octave_i ()const
-{
- return octave_i_;
-}
-
-int
-Musical_pitch::notename_i () const
-{
- return notename_i_;
-}
-
-int
-Musical_pitch::alteration_i () const
-{
- return alteration_i_;
-}
void
-Melodic_req::transpose (Musical_pitch delta)
+Melodic_req::transpose (Pitch delta)
{
- Musical_pitch p = *unsmob_pitch (get_mus_property ("pitch"));
+ Pitch p = *unsmob_pitch (get_mus_property ("pitch"));
p.transpose (delta);
while (note_req_l_arr_.size ())
{
Note_req* n = note_req_l_arr_.pop ();
- Musical_pitch pit = * unsmob_pitch (n->get_mus_property ("pitch"));
+ Pitch pit = * unsmob_pitch (n->get_mus_property ("pitch"));
Audio_note* p = new Audio_note (pit, n->length_mom (), transposing_i);
Audio_element_info info (p, n);
announce_element (info);
$$ = $1;
}
| NOTENAME_PITCH sup_quotes {
- Musical_pitch p = *unsmob_pitch ($1);
+ Pitch p = *unsmob_pitch ($1);
p.octave_i_ += $2;
$$ = p.smobbed_copy ();
}
| NOTENAME_PITCH sub_quotes {
- Musical_pitch p =* unsmob_pitch ($1);
+ Pitch p =* unsmob_pitch ($1);
p.octave_i_ += -$2;
$$ = p.smobbed_copy ();
$$ = $1;
}
| TONICNAME_PITCH sup_quotes {
- Musical_pitch p = *unsmob_pitch ($1);
+ Pitch p = *unsmob_pitch ($1);
p.octave_i_ += $2;
$$ = p.smobbed_copy ();
}
| TONICNAME_PITCH sub_quotes {
- Musical_pitch p =* unsmob_pitch ($1);
+ Pitch p =* unsmob_pitch ($1);
p.octave_i_ += -$2;
$$ = p.smobbed_copy ();
| MUSICAL_PITCH embedded_scm {
if (!unsmob_pitch ($2))
THIS->parser_error (_f ("Expecting musical-pitch value", 3));
- Musical_pitch m;
+ Pitch m;
$$ = m.smobbed_copy ();
}
;
chord:
steno_tonic_pitch optional_notemode_duration chord_additions chord_subtractions chord_inversion chord_bass {
- $$ = get_chord ($1, $3, $4, $5, $6, $2);
+ $$ = Chord::get_chord ($1, $3, $4, $5, $6, $2);
$$->set_spot (THIS->here_input ());
};
chord_note:
bare_unsigned {
- Musical_pitch m;
+ Pitch m;
m.notename_i_ = ($1 - 1) % 7;
m.octave_i_ = $1 > 7 ? 1 : 0;
m.alteration_i_ = 0;
$$ = m.smobbed_copy ();
}
| bare_unsigned '+' {
- Musical_pitch m;
+ Pitch m;
m.notename_i_ = ($1 - 1) % 7;
m.octave_i_ = $1 > 7 ? 1 : 0;
m.alteration_i_ = 1;
$$ = m.smobbed_copy ();
}
| bare_unsigned CHORD_MINUS {
- Musical_pitch m;
+ Pitch m;
m.notename_i_ = ($1 - 1) % 7;
m.octave_i_ = $1 > 7 ? 1 : 0;
m.alteration_i_ = -1;
#include "translator-group.hh"
#include "musical-request.hh"
#include "music-sequence.hh"
+#include "lily-guile.hh"
#include "warn.hh"
-
-/*
- DOCUMENTME
- */
-int
-compare (Array<Duration> const * left, Array<Duration> const * right)
-{
- assert (left);
- assert (right);
-
- if (left->size () == right->size ())
- {
- for (int i = 0; i < left->size (); i++)
- {
- int r = Duration::compare ((*left)[i], (*right)[i]);
- if (r)
- return r;
- }
- }
- else
- return 1;
- return 0;
-}
-
Part_combine_music_iterator::Part_combine_music_iterator ()
{
first_iter_p_ = 0;
}
+// SCM*, moet / kan dat niet met set_x ofzo?
static void
-get_music_info (Moment m, Music_iterator* iter, Array<Musical_pitch> *pitches, Array<Duration> *durations)
+get_music_info (Moment m, Music_iterator* iter, SCM *pitches, SCM *durations)
{
if (iter->ok ())
{
{
Music *m = unsmob_music (gh_car (i));
if (Melodic_req *r = dynamic_cast<Melodic_req *> (m))
- pitches->push (*unsmob_pitch (r->get_mus_property("pitch")));
+ *pitches = gh_cons (r->get_mus_property("pitch"), *pitches);
if (Rhythmic_req *r = dynamic_cast<Rhythmic_req *> (m))
- durations->push (*unsmob_duration (r->get_mus_property("duration")));
+ *durations = gh_cons (r->get_mus_property("duration"), *durations);
}
}
}
pending = first_iter->pending_moment () <? second_iter->pending_moment ();
last_pending = pending;
- Array<Musical_pitch> first_pitches;
- Array<Duration> first_durations;
- get_music_info (pending, first_iter, &first_pitches, &first_durations);
+ SCM first_pitches = SCM_EOL;
+ SCM first_durations = SCM_EOL;
+ get_music_info (pending, first_iter,
+ &first_pitches, &first_durations);
- Array<Musical_pitch> second_pitches;
- Array<Duration> second_durations;
- get_music_info (pending, second_iter, &second_pitches, &second_durations);
+ SCM second_pitches = SCM_EOL;
+ SCM second_durations = SCM_EOL;
+ get_music_info (pending, second_iter,
+ &second_pitches, &second_durations);
- if (first_pitches.size () && second_pitches.size ())
+ if (first_pitches != SCM_EOL && second_pitches != SCM_EOL)
{
- first_pitches.sort (Musical_pitch::compare);
- second_pitches.sort (Musical_pitch::compare);
- interval = gh_int2scm (first_pitches.top ().steps ()
- - second_pitches[0].steps ());
+ scm_sort_list_x (first_pitches,
+ scm_eval2 (ly_str02scm ("Pitch::less_p"),
+ SCM_EOL));
+ scm_sort_list_x (second_pitches,
+ scm_eval2 (ly_str02scm ("Pitch::less_p"),
+ SCM_EOL));
+ interval = gh_int2scm (unsmob_pitch (gh_car (first_pitches))->steps ()
+ - unsmob_pitch (gh_car (scm_last_pair (second_pitches)))->steps ());
}
- if (first_durations.size ())
+
+ if (first_durations != SCM_EOL)
{
- first_durations.sort (Duration::compare);
- first_mom += first_durations.top ().length_mom ();
+ scm_sort_list_x (first_durations,
+ scm_eval2 (ly_str02scm ("Duration::less_p"),
+ SCM_EOL));
+ first_mom += unsmob_duration (gh_car (first_durations))->length_mom ();
}
-
- if (second_durations.size ())
+
+ if (second_durations != SCM_EOL)
{
- second_durations.sort (Duration::compare);
- second_mom += second_durations.top ().length_mom ();
+ scm_sort_list_x (second_durations,
+ scm_eval2 (ly_str02scm ("Duration::less_p"),
+ SCM_EOL));
+ second_mom += unsmob_duration (gh_car (second_durations))->length_mom ();
}
-
- if (!first_pitches.empty () && second_pitches.empty ()
- && !(second_until_ > now))
+
+ if (first_pitches != SCM_EOL && second_pitches == SCM_EOL
+ && !(second_until_ > now))
{
state |= UNRELATED;
state &= ~UNISILENCE;
else
state &= ~SOLO1;
- if (first_pitches.empty () && !second_pitches.empty ()
+ if (first_pitches == SCM_EOL && second_pitches != SCM_EOL
&& !(first_until_ > now))
{
state |= UNRELATED;
else
state &= ~SOLO2;
- if (!compare (&first_durations, &second_durations))
+ if (gh_equal_p (first_durations, second_durations))
{
state &= ~UNISILENCE;
if (!(state & ~(UNIRHYTHM | UNISON)))
else
state &= ~(UNIRHYTHM | UNISILENCE);
- if (!first_pitches.empty ()
- &&!compare (&first_pitches, &second_pitches))
+ if (first_pitches != SCM_EOL
+ && gh_equal_p (first_pitches, second_pitches))
{
state &= ~UNISILENCE;
if (!(state & ~(UNIRHYTHM | UNISON)))
else
state &= ~(UNISON);
- if (first_pitches.empty () && second_pitches.empty ())
+ if (first_pitches == SCM_EOL && second_pitches == SCM_EOL)
{
if (!(state & ~(UNIRHYTHM | UNISILENCE)))
state |= UNISILENCE;
state &= ~(SPLIT_INTERVAL);
}
- if (first && !first_pitches.empty ())
+ if (first && first_pitches != SCM_EOL)
first_until_ = first_mom;
- if (first && !second_pitches.empty ())
+ if (first && second_pitches != SCM_EOL)
second_until_ = second_mom;
first = false;
if (combine_b != previously_combined_b)
change_to (second_iter_p_, w, (combine_b ? "one" : "two")
+ suffix_);
-
+
Translator_group *first_translator = first_iter_p_->report_to_l ()->find_create_translator_l (w, "one" + suffix_);
Translator_group *second_translator = second_iter_p_->report_to_l ()->find_create_translator_l (w, "two" + suffix_);
+
- /*
- hmm
- */
+ /* Hmm */
+ first_translator->set_property ("combineParts", SCM_BOOL_T);
+ second_translator ->set_property ("combineParts", SCM_BOOL_T);
+
+
+ /* hmm */
SCM b = (state & UNIRHYTHM) ? SCM_BOOL_T : SCM_BOOL_F;
first_translator->set_property ("unirhythm", b);
second_translator->set_property ("unirhythm", b);
#include "part-combine-music.hh"
#include "part-combine-music-iterator.hh"
-#include "musical-pitch.hh"
+#include "pitch.hh"
Part_combine_music::Part_combine_music (SCM what, Music * f, Music * s)
{
}
void
-Part_combine_music::transpose (Musical_pitch p)
+Part_combine_music::transpose (Pitch p)
{
first_l ()->transpose (p);
second_l () ->transpose (p);
return first_l ()->length_mom ();
}
-Musical_pitch
-Part_combine_music::to_relative_octave (Musical_pitch p)
+Pitch
+Part_combine_music::to_relative_octave (Pitch p)
{
p = first_l ()->to_relative_octave (p);
return second_l ()->to_relative_octave (p);
--- /dev/null
+/*
+ musical-pitch.cc -- implement Pitch
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1998--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+
+ */
+#include "pitch.hh"
+#include "debug.hh"
+#include "main.hh"
+#include "ly-smobs.icc"
+
+
+
+Pitch::Pitch (int o, int n, int a)
+{
+ notename_i_ = n;
+ alteration_i_ = a;
+ octave_i_ = o;
+
+ if (n < 0 || n >= 7 ||
+ a < -2 || a > 2)
+ {
+ String s = _("Pitch arguments out of range");
+ s += ": alteration = " + to_str (a);
+ s += ", notename = " + to_str (n);
+ warning (s);
+ }
+}
+
+Pitch::Pitch ()
+{
+ notename_i_ = 0;
+ alteration_i_ = 0;
+ octave_i_ = 0;
+}
+
+int
+Pitch::compare (Pitch const &m1, Pitch const &m2)
+{
+ int o= m1.octave_i_ - m2.octave_i_;
+ int n = m1.notename_i_ - m2.notename_i_;
+ int a = m1.alteration_i_ - m2.alteration_i_;
+
+ if (o)
+ return o;
+ if (n)
+ return n;
+ if (a)
+ return a;
+ return 0;
+}
+
+int
+Pitch::steps () const
+{
+ return notename_i_ + octave_i_*7;
+}
+
+/*
+ should be settable from input?
+ */
+static Byte pitch_byte_a[ ] = { 0, 2, 4, 5, 7, 9, 11 };
+
+int
+Pitch::semitone_pitch () const
+{
+ return pitch_byte_a[ notename_i_ % 7 ] + alteration_i_ + octave_i_ * 12;
+}
+
+/* WHugh, wat een intervaas */
+void
+Pitch::transpose (Pitch delta)
+{
+ int old_pitch = semitone_pitch ();
+ int delta_pitch = delta.semitone_pitch ();
+ octave_i_ += delta.octave_i_;
+ notename_i_ += delta.notename_i_;
+
+
+ while (notename_i_ >= 7)
+ {
+ notename_i_ -= 7;
+ octave_i_ ++;
+ }
+
+ int new_pitch = semitone_pitch ();
+ int delta_acc = new_pitch - old_pitch - delta_pitch;
+ alteration_i_ -= delta_acc;
+}
+
+
+
+
+/* FIXME */
+#if 0
+// nice test for internationalisation strings
+char const *accname[] = {"double flat", "flat", "natural",
+ "sharp" , "double sharp"};
+#else
+char const *accname[] = {"eses", "es", "", "is" , "isis"};
+#endif
+
+String
+Pitch::str () const
+{
+ int n = (notename_i_ + 2) % 7;
+ String s = to_str (char(n + 'a'));
+ if (alteration_i_)
+ s += String (accname[alteration_i_ + 2]);
+
+ if (octave_i_ > 0)
+ {
+ int o = octave_i_ + 1;
+ while (o--)
+ s += "'";
+ }
+ else if (octave_i_ <0)
+ {
+ int o = (-octave_i_) - 1;
+ while (o--)
+ s += to_str (',');
+ }
+
+
+ return s;
+}
+
+/*
+ change me to relative, counting from last pitch p
+ return copy of resulting pitch
+ */
+Pitch
+Pitch::to_relative_octave (Pitch p)
+{
+ int oct_mod = octave_i_ + 1; // account for c' = octave 1 iso. 0 4
+ Pitch up_pitch (p);
+ Pitch down_pitch (p);
+
+ up_pitch.alteration_i_ = alteration_i_;
+ down_pitch.alteration_i_ = alteration_i_;
+
+ Pitch n = *this;
+ up_pitch.up_to (notename_i_);
+ down_pitch.down_to (notename_i_);
+
+ int h = p.steps ();
+ if (abs (up_pitch.steps () - h) < abs (down_pitch.steps () - h))
+ n = up_pitch;
+ else
+ n = down_pitch;
+
+ n.octave_i_ += oct_mod;
+
+ *this = n;
+ return *this;
+}
+
+void
+Pitch::up_to (int notename)
+{
+ if (notename_i_ > notename)
+ {
+ octave_i_ ++;
+ }
+ notename_i_ = notename;
+}
+
+void
+Pitch::down_to (int notename)
+{
+ if (notename_i_ < notename)
+ {
+ octave_i_ --;
+ }
+ notename_i_ = notename;
+}
+
+///MAKE_SCHEME_CALLBACK (Pitch, transpose, 2);
+///transpose_proc?
+SCM
+Pitch::transpose (SCM p, SCM delta)
+{
+ Pitch t = *unsmob_pitch (p);
+ t.transpose (*unsmob_pitch (delta));
+ return t.smobbed_copy ();
+}
+
+static SCM
+pitch_transpose (SCM p, SCM delta)
+{
+ return Pitch::transpose (p, delta);
+}
+
+/****************************************************************/
+
+
+IMPLEMENT_TYPE_P(Pitch, "pitch?");
+IMPLEMENT_UNSMOB(Pitch, pitch);
+SCM
+Pitch::mark_smob (SCM )
+{
+ return SCM_EOL;
+}
+
+IMPLEMENT_SIMPLE_SMOBS(Pitch);
+
+
+int
+Pitch::print_smob (SCM s, SCM port, scm_print_state *)
+{
+ Pitch *r = (Pitch *) gh_cdr (s);
+
+ scm_puts ("#<Pitch ", port);
+ scm_display (gh_str02scm ((char*)r->str().ch_C()), port);
+ scm_puts (" >", port);
+
+ return 1;
+}
+
+SCM
+Pitch::equal_p (SCM a , SCM b)
+{
+ Pitch *p = (Pitch *) gh_cdr (a);
+ Pitch *q = (Pitch *) gh_cdr (b);
+
+ bool eq = p->notename_i_ == q->notename_i_
+ && p->octave_i_ == q->octave_i_
+ && p->alteration_i_ == q->alteration_i_;
+
+ return eq ? SCM_BOOL_T : SCM_BOOL_F;
+}
+
+MAKE_SCHEME_CALLBACK(Pitch, less_p, 2);
+SCM
+Pitch::less_p (SCM p1, SCM p2)
+{
+ Pitch *a = unsmob_pitch (p1);
+ Pitch *b = unsmob_pitch (p2);
+
+ if (compare(*a, *b) < 0 )
+ return SCM_BOOL_T;
+ else
+ return SCM_BOOL_F;
+}
+
+/*
+ should add optional args
+ */
+
+static SCM
+make_pitch (SCM o, SCM n, SCM a)
+{
+ Pitch p;
+ p.octave_i_ = gh_scm2int (o);
+ p.notename_i_ = gh_scm2int (n);
+ p.alteration_i_ = gh_scm2int (a);
+ return p.smobbed_copy ();
+}
+
+static SCM
+pitch_octave (SCM pp)
+{
+ Pitch *p = unsmob_pitch (pp);
+ int q = 0;
+ if (!p)
+ warning ("Not a pitch");
+ else
+ q = p->octave_i();
+
+ return gh_int2scm (q);
+}
+
+static SCM
+pitch_alteration (SCM pp)
+{
+ Pitch *p = unsmob_pitch (pp);
+ int q = 0;
+ if (!p)
+ warning ("Not a pitch");
+ else
+ q = p->alteration_i();
+
+ return gh_int2scm (q);
+}
+
+static SCM
+pitch_notename (SCM pp)
+{
+ Pitch *p = unsmob_pitch (pp);
+ int q = 0;
+ if (!p)
+ warning ("Not a pitch");
+ else
+ q = p->notename_i();
+
+ return gh_int2scm (q);
+}
+
+static SCM
+pitch_semitones (SCM pp)
+{
+ Pitch *p = unsmob_pitch (pp);
+ int q = 0;
+ if (!p)
+ warning ("Not a pitch");
+ else
+ q = p->steps();
+
+ return gh_int2scm (q);
+}
+
+static void
+add_funcs()
+{
+ // should take list?: (make-pitch '(octave name accidental))
+ scm_make_gsubr ("make-pitch", 3, 0, 0, (Scheme_function_unknown)make_pitch);
+
+ scm_make_gsubr ("pitch-octave", 1, 0, 0, (Scheme_function_unknown)pitch_octave);
+ scm_make_gsubr ("pitch-notename", 1, 0, 0, (Scheme_function_unknown)pitch_notename);
+ scm_make_gsubr ("pitch-alteration", 1, 0, 0, (Scheme_function_unknown)pitch_alteration);
+ scm_make_gsubr ("pitch-semitones", 1, 0, 0, (Scheme_function_unknown)pitch_semitones);
+ scm_make_gsubr ("Pitch::transpose", 2, 0, 0, (Scheme_function_unknown) pitch_transpose);
+}
+
+ADD_SCM_INIT_FUNC(pitch, add_funcs);
+
+SCM
+Pitch::smobbed_copy ()const
+{
+ Pitch * p = new Pitch (*this);
+ return p->smobbed_self ();
+}
+
+int
+Pitch::octave_i ()const
+{
+ return octave_i_;
+}
+
+int
+Pitch::notename_i () const
+{
+ return notename_i_;
+}
+
+int
+Pitch::alteration_i () const
+{
+ return alteration_i_;
+}
#include "relative-music.hh"
#include "debug.hh"
-Musical_pitch
-Relative_octave_music::to_relative_octave (Musical_pitch)
+Pitch
+Relative_octave_music::to_relative_octave (Pitch)
{
return last_pitch_;
}
-Relative_octave_music::Relative_octave_music(Music*p,Musical_pitch def)
+Relative_octave_music::Relative_octave_music(Music*p,Pitch def)
: Music_wrapper (p)
{
last_pitch_ = element ()->to_relative_octave (def);
#include "repeated-music.hh"
#include "music-list.hh"
-#include "musical-pitch.hh"
+#include "pitch.hh"
#include "debug.hh"
Music *
}
-Musical_pitch
-Repeated_music::to_relative_octave (Musical_pitch p)
+Pitch
+Repeated_music::to_relative_octave (Pitch p)
{
if (body ())
p = body ()->to_relative_octave (p);
- Musical_pitch last = p ;
+ Pitch last = p ;
if (alternatives ())
for (SCM s = alternatives ()->music_list (); gh_pair_p (s); s = gh_cdr (s))
unsmob_music (gh_car (s))->to_relative_octave (p);
}
void
-Repeated_music::transpose (Musical_pitch p)
+Repeated_music::transpose (Pitch p)
{
if (body ())
body ()->transpose (p);
while (i >= 0 && j >=0)
{
int comp
- = Musical_pitch::compare (*unsmob_pitch (now_heads_[i].req_l_->get_mus_property ("pitch") ),
+ = Pitch::compare (*unsmob_pitch (now_heads_[i].req_l_->get_mus_property ("pitch") ),
*unsmob_pitch (stopped_heads_[j].req_l_->get_mus_property ("pitch")));
if (comp)
SCM p1 = h1.req_l_->get_mus_property ("pitch");
SCM p2 = h2.req_l_->get_mus_property ("pitch");
- return Musical_pitch::equal_p (p1,p2) == SCM_BOOL_T;
+ return Pitch::equal_p (p1,p2) == SCM_BOOL_T;
}
int
while ( i < now_notes_.size () && j < stopped_notes_.size ())
{
int comp
- = Musical_pitch::compare (*unsmob_pitch (now_notes_[i].req_l_->get_mus_property ("pitch") ),
+ = Pitch::compare (*unsmob_pitch (now_notes_[i].req_l_->get_mus_property ("pitch") ),
*unsmob_pitch (stopped_notes_[j].req_l_->get_mus_property ("pitch")));
if (comp)
{
SCM p1 = h1.req_l_->get_mus_property ("pitch");
SCM p2 = h2.req_l_->get_mus_property ("pitch");
- return Musical_pitch::compare (*unsmob_pitch (p1),
+ return Pitch::compare (*unsmob_pitch (p1),
*unsmob_pitch (p2));
}
#include "transposed-music.hh"
#include "debug.hh"
-Transposed_music::Transposed_music (Music *p, Musical_pitch pit)
+Transposed_music::Transposed_music (Music *p, Pitch pit)
: Music_wrapper (p)
{
transpose_to_pitch_ = pit;
}
-Musical_pitch
-Transposed_music::to_relative_octave (Musical_pitch p)
+Pitch
+Transposed_music::to_relative_octave (Pitch p)
{
return p;
}
;; This is the major configuration variable.
(defcustom LilyPond-command-alist
- '(
+ `(
("LilyPond" . ("lilypond %s" . "TeX"))
("TeX" . ("tex '\\nonstopmode\\input %t'" . "View"))
("SmartView" . ("xdvi %d" . "LilyPond"))
;; refreshes when kicked USR1
- ("View" . ((concat LilyPond-xdvi-command " %d") . "LilyPond"))
+ ("View" . (,(concat LilyPond-xdvi-command " %d") . "LilyPond"))
)
"AList of commands to execute on the current document.
% For using "sostingut" notation, which is also correct
-\notenames #'(
+\notenames #`(
(dobb . ,(make-pitch -1 0 -2 ))
(dob . ,(make-pitch -1 0 -1 ))
(do . ,(make-pitch -1 0 0 ))
Begin3
Title: LilyPond
-Version: 1.3.107
-Entered-date: 13NOV00
+Version: 1.3.108
+Entered-date: 15NOV00
Description:
Keywords: music notation typesetting midi fonts engraving
Author: hanwen@cs.uu.nl (Han-Wen Nienhuys)
janneke@gnu.org (Jan Nieuwenhuizen)
Maintained-by: hanwen@stack.nl (Han-Wen Nienhuys)
Primary-site: sunsite.unc.edu /pub/Linux/apps/sound/convert
- 1000k lilypond-1.3.107.tar.gz
+ 1000k lilypond-1.3.108.tar.gz
Original-site: ftp.cs.uu.nl /pub/GNU/LilyPond/development/
- 1000k lilypond-1.3.107.tar.gz
+ 1000k lilypond-1.3.108.tar.gz
Copying-policy: GPL
End
%define info yes
Name: lilypond
-Version: 1.3.107
+Version: 1.3.108
Release: 1
License: GPL
Group: Applications/Publishing
-Source0: ftp.cs.uu.nl:/pub/GNU/LilyPond/development/lilypond-1.3.107.tar.gz
+Source0: ftp.cs.uu.nl:/pub/GNU/LilyPond/development/lilypond-1.3.108.tar.gz
Summary: A program for printing sheet music.
URL: http://www.cs.uu.nl/~hanwen/lilypond
# Icon: lilypond-icon.gif
-
;;; backend-documentation-lib.scm -- Functions for backend documentation
;;;
;;; source file of the GNU LilyPond music typesetter
;;; This file generates documentation for the backend of lilypond.
;; alist of property descriptions
-;; when called by First level Interface description, desc == '()
-;; CDR "not set" is only used for Second level Element description
-(define (document-element-property prop desc)
- (let ((handle (assoc (car prop) desc)))
- (cons
- (string-append "@code{" (symbol->string (car prop)) "} "
- "(" (type-name (cadr prop)) ")"
- (if (equal? desc '()) "" ":"))
- (string-append (if (equal? desc '())
- (caddr prop)
- (if (pair? handle)
- (string-append (caddr prop)
- "\ndefault value: @code{"
- (scm->string (cdr handle))
- "}")
- "not set"))))))
-;; First level Interface description
-;; Second level, part of element description
-(define (document-interface level interface element-description)
- (let* ((name (car interface))
+
+(define (document-element-property property-def element-description only-doc-if-set)
+ "
+"
+ (let* (
+ (handle (assoc (car property-def) element-description))
+ (def-val-str (if (eq? handle #f)
+ "not set"
+ (scm->texi (cdr handle))))
+
+ (name (symbol->string (car property-def)))
+ (type (type-name (cadr property-def)))
+ (desc (caddr property-def))
+ )
+
+ (if (and (eq? handle #f) only-doc-if-set)
+ '("" . "")
+ (cons (string-append "@code{" name "} "
+ "(" type ")"
+ ":" )
+ (string-append desc
+ "\nDefault value: "
+ def-val-str))
+ ))
+ )
+
+(define (document-interface where interface element-description)
+ "
+
+"
+ (let* ((level (if (eq? where 'element) 3 2))
+ (name (car interface))
(desc (cadr interface))
(props (caddr interface))
- (docs (map (lambda (x)
- (document-element-property x element-description))
- props)))
+ (docfun (lambda (x)
+ (document-element-property
+ x element-description (eq? where 'element))))
+ (docs (map docfun props))
+ )
(string-append
- (section level (string-append (interface-name (symbol->string name))))
+ (texi-section level (string-append (interface-name (symbol->string name))) (eq? where 'element)) ;gur.
desc
- (description-list
- ;; filter-out entries with CDR "not set"
- (apply append
- (map (lambda (x)
- (if (string-match "not set" (cdr x)) '() (list x)))
- docs))))))
+ (description-list->texi docs)
+ )))
;; First level Interface description
(define (document-separate-interface interface)
(processing name)
(string-append
(node (interface-name name))
- (document-interface 2 interface '()))))
+ (document-interface 'self interface '()))))
;; First level element description
(define (document-element iname description)
(name (cdr (assoc 'name meta)))
(ifaces (cdr (assoc 'interface-descriptions meta)))
- (ifacedoc (map (lambda (x) (document-interface 3 x description))
+ (ifacedoc (map (lambda (x) (document-interface 'element x description))
(reverse ifaces))))
(string-append
(node (element-name name))
- (section 2 (element-name name))
+ (texi-section 2 (element-name name) #f)
"\n"
(let* ((element (string->symbol name))
(load "lily.scm")))
(use-modules (ice-9 string-fun))
+
+(define interface-file-str (string-append (ly-gulp-file "interface.scm") "\n(define "))
(define (list-interface-names)
- (let* ((text (string-append (ly-gulp-file "interface.scm") "\n(define "))
+ (let* ((text interface-file-str)
(r (make-regexp
"\n[(](define *([a-z-]*-interface)*)*[^\n]*"))
(t (regexp-substitute/global #f r text 2 " " 'post))
-;;;
+;;
;;; documentation-lib.scm -- Assorted Functions for generated documentation
;;;
;;; source file of the GNU LilyPond music typesetter
;; )
;; x2))
+
+
+(define (scm->texi x)
+ (string-append "@code{" (texify (scm->string x)) "}")
+ )
+
(define (scm->string val)
(string-append
(if (self-evaluating? val) "" "'")
- (texify
- (call-with-output-string (lambda (port) (display val port))))
+ (call-with-output-string (lambda (port) (display val port)))
))
(define (node name)
"\n@end html"
"\n@node " name ",,,"))
-(define section-alist
+(define texi-section-alist
'(
;; Hmm, texinfo doesn't have ``part''
(0 . "@top")
(5 . "@unnumberedsubsubsec")
))
-(define (section level name)
- (string-append "\n" (cdr (assoc level section-alist)) " " name "\n"))
-
-(define (description-list items-alist)
+(define (texi-section level name ref)
+ "texi sectioning command (lower LEVEL means more significant).
+Add a ref if REF is set
+"
+
+ (string-append
+ "\n" (cdr (assoc level texi-section-alist)) " "
+ (if ref
+ (string-append "@ref{" name "}")
+ name)
+ "\n"))
+
+
+(define (one-item->texi label-desc-pair)
+ "Document one (LABEL . DESC); return empty string if LABEL is empty string.
+"
+ (if (eq? (car label-desc-pair) "")
+ ""
+ (string-append "\n@item " (car label-desc-pair) "\n" (cdr label-desc-pair))
+ ))
+
+
+(define (description-list->texi items-alist)
+ "Document ITEMS-ALIST in a table. entries contain (item-label . string-to-use)
+"
(string-append
"\n@table @samp\n"
- (apply string-append
- (map (lambda (x) (string-append "\n@item " (car x) "\n" (cdr x)))
- items-alist))
+ (apply string-append (map one-item->texi items-alist))
"\n@end table\n"))
(define (texi-menu items-alist)
;; Menus don't appear in html, so we make a list ourselves
"\n@ignore\n"
"\n@ifhtml\n"
- (description-list (map (lambda (x) (cons (reffy (car x)) (cdr x)))
+ (description-list->texi (map (lambda (x) (cons (reffy (car x)) (cdr x)))
items-alist))
"\n@end ifhtml\n"
"\n@end ignore\n"))
(define (texi-node-menu name items-alist)
(string-append
(node name)
- (section 1 name)
+ (texi-section 1 name #f)
(texi-menu items-alist)))
(define (texi-file-head name file-name top items-alist)
"\n@settitle " name
(node "Top") top
"\n@top"
- (section 1 name)
+ (texi-section 1 name #f)
(texi-menu items-alist)
"\n@contents"
))
))
(Crescendo . (
- (molecule-callback . ,Crescendo::brew_molecule)
+ (molecule-callback . ,Hairpin::brew_molecule)
(thickness . 1.0)
- (shorten-for-letter . 4.0)
+ (padding . 1.0)
(height . 0.6666)
(dash-thickness . 1.2)
(dash-length . 4.0)
(font-family . roman)
(meta . ,(element-description "NoteName"
note-name-interface font-interface
- general-element-interface))
+ ))
))
(OctavateEight . (
;; First level Engraver description and
;; second level Context description
-(define (document-engraver level engraver-descr)
+(define (document-engraver where engraver-descr)
(let* (
+ (level (if (eq? where 'context) 3 2))
(props (car (cdddr engraver-descr)))
(name (car engraver-descr))
(desc (cadr engraver-descr))
)
(string-append
- (section level (engraver-name name))
+ (texi-section level (engraver-name name) (eq? where 'context))
desc
"\n\n"
(if (null? props)
""
(string-append
- (section (+ level 1) "Properties")
- (description-list
+ (texi-section (+ level 1) "Properties" #f)
+ (description-list->texi
(map (lambda (x) (document-translator-property x)) props))))
(if (null? objs)
""
(processing name)
(string-append
(node (engraver-name name))
- (document-engraver 2 description))))
+ (document-engraver 'self description))))
;; Second level, part of Context description
(define (document-engraver-by-name name)
(if (eq? eg #f)
(string-append "Engraver " name ", not documented.\n")
- (document-engraver 3 (cdr eg))
+ (document-engraver 'context (cdr eg))
)
))
(processing name)
(string-append
(node (context-name name))
- (section 2 (context-name name))
+ (texi-section 2 (context-name name) #f)
doc)))
(define (document-paper name)
(document-paper "LilyPond interpretation contexts")
(document-all-engravers "LilyPond engravers")
(document-all-elements "LilyPond backend")
- (document-all-interfaces "LilyPond interfaces"))
+ (document-all-interfaces "LilyPond interfaces")
+ )
)
(name "lilypond-internals")
(outname (string-append name ".texi"))
'note-column-interface
"Stem and noteheads combined"
(list
- (elt-property-description 'horizontal-shift integer? "integer that identifies ranking of note-column for horizontal shifting.")
- (elt-property-description 'force-hshift number? "amount of collision_note_width that overides automatic collision settings.")
- (elt-property-description 'merge-differently-dotted boolean? "merge black noteheads with differing dot count in collisions.
-
-Merge noteheads in collisions, even if they have a different number of
-dots. This normal notation for polyphonic guitar music.
-
-")
+ (elt-property-description 'horizontal-shift integer? "integer that identifies ranking of note-column for horizontal shifting. This is used by @ref{note-collision-interface}")
+ (elt-property-description 'force-hshift number? "amount of collision_note_width that overides automatic collision settings. This is used by @ref{note-collision-interface}")
))
)
(elt-property-description 'grow-direction dir? "crescendo or decrescendo?")
(elt-property-description 'thickness number? "thickness, measured in stafflinethickness")
(elt-property-description 'height number? "height, measured in staffspace.")
+ (elt-property-description 'padding number? "horizontal padding. This is useful if a crescendo is set next to a text like `mf'")
)))
(define arpeggio-interface
(lily-interface
'arpeggio-interface
- "arpeggio"
+ "Functions and settings for drawing an arpeggio symbol (a wavy line left to noteheads."
(list
(elt-property-description 'stems list? "list of stem objects, corresponding to the notes that the arpeggio has to be before.")
)
(define note-collision-interface
(lily-interface
'note-collision-interface
- "note collision"
+ "An object that handles collisions between notes with different
+stem directions and horizontal shifts. Most of the interesting
+properties are to be set in @ref{note-column-interface}"
(list
+ (elt-property-description 'merge-differently-dotted boolean? "
+Merge noteheads in collisions, even if they have a different number of
+dots. This normal notation for some types of polyphonic music. The
+value of this setting is used by @ref{note-collision-interface}
+
+")
(elt-property-description 'note-width 'number? "unit for horizontal translation, measured in staff-space.")
) ) )
(translator-property-description 'barAlways boolean? " If set to true a bar line is drawn after each note.
")
- (translator-property-description 'defaultBarType string? "Sets the default type of bar line. See Section XREF-barlines [FIXME]
- for a list of available bar types.
+ (translator-property-description 'defaultBarType string? "Sets the default type of bar line. Available bar types: [FIXME]
")
(translator-property-description 'skipBars boolean? " Set to true to skip the empty bars that are produced by
multimeasure notes and rests. These bars will not appear on the
projects / lilypond.git / commitdiff