-1.3.67.mb1
-===========
+1.3.68
+======
* ly2dvi: changed back to original semantics of latexheaders.
-1.3.66.hwn1
-===========
+* Stem_tremolo, Crescendo, Hara_kiri_group_spanner, Tuplet_spanner,
+Volta_spanner changed into interface.
+
+* Related cleanups for Tie, Tie_column cleanups.
+
+* Made Time_signature, Single_malt_grouping_item, Script_column,
+Chord_name, Dot_column, Breathing_sign, Key_item type into interface.
+
+* Removed const declaration from callback arguments.
+
+* Pagebreak support. See input/test/between-systems.ly
+
+* Fixed a problem with accidentals in combination with
+non-nil key signatures.
+
+1.3.67
+======
* Use callbacks for augmentation dot positioning.
@mudelafile{generic-property-override.ly}
+Paper column supports a special output property that allows you to force
+page breaks (among others).
+
+@mudelafile{between-systems.ly}
+
@section Repeats
LilyPond has three modes for repeats: folded, unfolded and
PACKAGE_NAME=LilyPond
MAJOR_VERSION=1
MINOR_VERSION=3
-PATCH_LEVEL=67
-MY_PATCH_LEVEL=mb1
+PATCH_LEVEL=68
+MY_PATCH_LEVEL=
# use the above to send patches: MY_PATCH_LEVEL is always empty for a
# released version.
--- /dev/null
+% the space after clef/key is stretched too much.
+
+foo = \notes\relative c'' { \key as \major; dis4 dis dis! dis? }
+
+\score {
+
+ < \foo
+ \context NoteNames \foo
+ >
+}
-foo = \notes\relative c'' { cis4 cis cis! cis? }
+foo = \notes\relative c'' { \key as \major; dis4 dis dis! dis? }
+
\score {
- <\foo
- \context NoteNames \foo
->
+ < \foo
+ \context NoteNames \foo
+ >
}
--- /dev/null
+
+\score {
+\notes { c1
+
+ \context Score \outputproperty #(make-type-checker 'paper-column-interface)
+ #'between-system-string = #"(pagebreak)\n\n"
+ \break
+
+c1 }
+
+}
\score{
\notes\relative c''{
- \outputproperty #(make-type-checker 'Note_head)
+ \outputproperty #(make-type-checker 'note-head-interface)
#'extra-offset = #'(2 . 3)
c2
c
\context Score {
- \outputproperty #(make-type-checker 'Mark)
+ \outputproperty #(make-type-checker 'mark-interface)
#'extra-offset = #'(-1 . 4)
}
\mark A;
not compute anything, but a side effect of a->do_side_processing ()
is that the elements are placed correctly. */
Real
-Align_interface::alignment_callback (Score_element const *sc, Axis ax)
+Align_interface::alignment_callback (Score_element *sc, Axis ax)
{
Score_element * par = sc->parent_l (ax);
if (par && par->get_elt_property ("alignment-done") == SCM_UNDEFINED)
Real
-Align_interface::center_on_element (Score_element const *me, Axis a)
+Align_interface::center_on_element (Score_element *me, Axis a)
{
Score_element *cent = unsmob_element (me->get_elt_pointer ("group-center-element"));
#include "grace-align-item.hh"
#include "align-interface.hh"
#include "note-column.hh"
-#include "local-key-item.hh"
#include "warn.hh"
#include "directional-element-interface.hh"
#include "side-position-interface.hh"
{
Grace_align_item * align_item_p_;
Note_column * now_column_l_;
- Local_key_item * accidental_l_;
+ Score_element * accidental_l_;
virtual void process_acknowledged ();
virtual void do_post_move_processing ();
{
now_column_l_ =n;
}
- else if (Local_key_item * it = dynamic_cast<Local_key_item*> (inf.elem_l_))
+ else if (to_boolean (inf.elem_l_->get_elt_property ("accidentals-interface")))
{
- accidental_l_ = it;
+ accidental_l_ = inf.elem_l_;
}
}
void
#include "beaming.hh"
#include "auto-beam-engraver.hh"
#include "musical-request.hh"
-#include "bar.hh"
#include "beam.hh"
-#include "rest.hh"
#include "stem.hh"
#include "debug.hh"
#include "timing-engraver.hh"
{
end_beam ();
}
- else if (Bar *b = dynamic_cast<Bar *> (info.elem_l_))
+ else if (to_boolean (info.elem_l_->get_elt_property ("bar-interface")))
{
end_beam ();
}
}
Interval
-Axis_group_interface::group_extent_callback (Score_element const*me, Axis a)
+Axis_group_interface::group_extent_callback (Score_element *me, Axis a)
{
Score_element * common =(Score_element*) me;
rest -> stem -> beam -> interpolate_y_position ()
*/
Real
-Beam::rest_collision_callback (Score_element const *rest, Axis a )
+Beam::rest_collision_callback (Score_element *rest, Axis a )
{
assert (a == Y_AXIS);
#include "side-position-interface.hh"
#include "warn.hh"
-#include "dimension-cache.hh"
#include "lily-guile.hh"
#include "break-align-item.hh"
#include "dimensions.hh"
-#include "paper-score.hh"
#include "paper-def.hh"
#include "paper-column.hh"
+
#include "group-interface.hh"
#include "align-interface.hh"
private:
Breathing_sign_req * breathing_sign_req_l_;
- Breathing_sign * breathing_sign_p_;
+ Score_element * breathing_sign_p_;
};
Breathing_sign_engraver::Breathing_sign_engraver()
if(breathing_sign_req_l_)
{
SCM b = get_property ("basicBreathingSignProperties");
- breathing_sign_p_ = new Breathing_sign (b);
- Staff_symbol_referencer_interface st (breathing_sign_p_);
- st.set_interface ();
+ breathing_sign_p_ = new Item (b);
+
+ Breathing_sign::set_interface (breathing_sign_p_);
announce_element (Score_element_info (breathing_sign_p_, breathing_sign_req_l_));
}
#include "direction.hh"
-Breathing_sign::Breathing_sign (SCM s)
- : Item (s)
-{
-}
-
-
MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Breathing_sign,brew_molecule);
return sc->lookup_l()->filledbox(b).create_scheme ();
}
-GLUE_SCORE_ELEMENT(Breathing_sign,after_line_breaking);
-SCM
-Breathing_sign::member_after_line_breaking ()
+Real
+Breathing_sign::offset_callback (Score_element * b, Axis a)
{
- Real space = Staff_symbol_referencer_interface (this).staff_space();
- Direction d = Directional_element_interface (this). get ();
+ Score_element * me = (Score_element*)b;
+
+ Real space = Staff_symbol_referencer_interface (b).staff_space();
+ Direction d = Directional_element_interface (b). get ();
if (!d)
{
d = UP;
- Directional_element_interface (this).set (d);
+ Directional_element_interface (me).set (d);
}
- translate_axis(2.0 * space * d, Y_AXIS);
-
- return SCM_UNDEFINED;
+ return 2.0 * space * d;
}
+void
+Breathing_sign::set_interface (Score_element *b)
+{
+ Staff_symbol_referencer_interface::set_interface (b);
+ b->add_offset_callback (Breathing_sign::offset_callback,Y_AXIS);
+}
(c) 1998--2000 Jan Nieuwenhuizen <janneke@gnu.org>
*/
-#include "chord-name-engraver.hh"
+#include "engraver.hh"
#include "chord-name.hh"
+#include "chord.hh"
#include "musical-request.hh"
#include "paper-def.hh"
#include "lookup.hh"
#include "main.hh"
#include "dimensions.hh"
#include "item.hh"
+#include "musical-pitch.hh"
+class Chord_name_engraver : public Engraver
+{
+public:
+ Chord_name_engraver ();
+ VIRTUAL_COPY_CONS (Translator);
+
+protected:
+ virtual void do_pre_move_processing ();
+ virtual void acknowledge_element (Score_element_info i);
+ virtual void do_process_music ();
+ virtual bool do_try_music (Music* m);
+
+private:
+ Array<Musical_pitch> pitch_arr_;
+ Item* chord_name_p_;
+ Tonic_req* tonic_req_;
+ Inversion_req* inversion_req_;
+ Bass_req* bass_req_;
+};
ADD_THIS_TRANSLATOR (Chord_name_engraver);
if (gh_boolean_p (chord_inversion))
find_inversion_b = gh_scm2bool (chord_inversion);
- chord_name_p_ = new Chord_name (get_property ("basicChordNameProperties"));
+ chord_name_p_ = new Item (get_property ("basicChordNameProperties"));
Chord chord = to_chord (pitch_arr_, tonic_req_, inversion_req_, bass_req_,
find_inversion_b);
*/
#include "chord-name.hh"
-#include "musical-request.hh"
-#include "warn.hh"
-#include "debug.hh"
#include "molecule.hh"
#include "paper-def.hh"
#include "lookup.hh"
-#include "staff-symbol-referencer.hh"
-
+#include "score-element.hh"
/*
TODO: move text lookup out of Chord_name
*/
Molecule
-Chord_name::ly_word2molecule (SCM word, Real* x) const
+Chord_name::ly_word2molecule (Score_element * me, SCM word, Real* x)
{
*x = 0;
/*
UGH. Should read from font metric structure.
*/
- Real ex = lookup_l ()->text ("", "x",
- paper_l ()).extent (Y_AXIS).length ();
- Real em = lookup_l ()->text ("", "m",
- paper_l ()).extent (X_AXIS).length ();
+ Real ex = me->lookup_l ()->text ("", "x",
+ me->paper_l ()).extent (Y_AXIS).length ();
+ Real em = me->lookup_l ()->text ("", "m",
+ me->paper_l ()).extent (X_AXIS).length ();
String w = ly_scm2string (word);
Molecule mol;
s = scm_assoc (ly_symbol2scm ("font"), options_alist);
if (s != SCM_BOOL_F && ly_scm2string (gh_cdr (s)) == "feta")
- mol = paper_l ()->lookup_l (size)->afm_find (w);
+ mol = me->paper_l ()->lookup_l (size)->afm_find (w);
else
- mol = paper_l ()->lookup_l (size)->text (style, w, paper_l ());
+ mol = me->paper_l ()->lookup_l (size)->text (style, w, me->paper_l ());
mol.translate (offset);
return mol;
;; property: align, kern, font (?), size
*/
Molecule
-Chord_name::ly_text2molecule (SCM text) const
+Chord_name::ly_text2molecule (Score_element * me, SCM text)
{
Molecule mol;
if (gh_list_p (text))
while (gh_cdr (text) != SCM_EOL)
{
Real x;
- Molecule m = ly_word2molecule (gh_car (text), &x);
+ Molecule m = ly_word2molecule (me, gh_car (text), &x);
if (!m.empty_b ())
mol.add_at_edge (X_AXIS, RIGHT, m, x);
text = gh_cdr (text);
text = gh_car (text);
}
Real x;
- Molecule m = ly_word2molecule (text, &x);
+ Molecule m = ly_word2molecule (me,text, &x);
if (!m.empty_b ())
mol.add_at_edge (X_AXIS, RIGHT, m, x);
return mol;
ly_quote_scm (gh_cons (inversion, bass)),
SCM_UNDEFINED));
- return dynamic_cast<Chord_name*> (sc)->
- ly_text2molecule (text).create_scheme ();
-}
-
-Chord_name::Chord_name (SCM s)
- : Item (s)
-{
+ return ly_text2molecule (sc, text).create_scheme ();
}
#include <ctype.h>
#include "staff-symbol-referencer.hh"
-#include "bar.hh"
-
#include "debug.hh"
#include "command-request.hh"
-#include "timing-translator.hh"
-#include "rhythmic-head.hh"
-#include "key-item.hh"
-#include "local-key-item.hh"
#include "array.hh"
#include "engraver.hh"
#include "direction.hh"
void
Clef_engraver::acknowledge_element (Score_element_info info)
{
- if (dynamic_cast<Bar*>(info.elem_l_)
- && gh_string_p (clef_glyph_))
- create_clef();
-
- Item * it_l =dynamic_cast <Item *> (info.elem_l_);
- if (it_l)
+ Item * item =dynamic_cast <Item *> (info.elem_l_);
+ if (item)
{
- if (to_boolean (it_l->get_elt_property("note-head-interface"))
- || dynamic_cast<Local_key_item*> (it_l))
+ if (to_boolean (info.elem_l_->get_elt_property ("bar-interface"))
+ && gh_string_p (clef_glyph_))
+ create_clef();
+
+
+ if (to_boolean (item->get_elt_property("note-head-interface"))
+ || to_boolean (item->get_elt_property ("accidentals-interface")))
{
- Staff_symbol_referencer_interface si (it_l);
+ Staff_symbol_referencer_interface si (item);
si.set_position (int (si.position_f ()) + c0_position_i_);
}
- else if (Key_item *k = dynamic_cast<Key_item*>(it_l))
+ else if (to_boolean (item->get_elt_property ("key-item-interface")))
{
- k->set_elt_property ("c0-position", gh_int2scm (c0_position_i_));
+ item->set_elt_property ("c0-position", gh_int2scm (c0_position_i_));
}
}
}
Item *c= new Item ( current_settings_);
announce_element (Score_element_info (c, clef_req_l_));
- Staff_symbol_referencer_interface si(c);
- si.set_interface ();
+ Staff_symbol_referencer_interface::set_interface (c);
clef_p_ = c;
}
}
Real
-Collision::force_shift_callback (Score_element const * c, Axis a)
+Collision::force_shift_callback (Score_element * c, Axis a)
{
assert (a == X_AXIS);
#include "molecule.hh"
#include "crescendo.hh"
+#include "spanner.hh"
#include "lookup.hh"
#include "dimensions.hh"
#include "paper-def.hh"
#include "debug.hh"
#include "paper-column.hh"
-
-Crescendo::Crescendo (SCM s)
- : Spanner (s)
+void
+Crescendo::set_interface (Score_element*s)
{
- set_elt_property ("dynamic-drul", gh_cons (SCM_BOOL_F, SCM_BOOL_F));
+ s->set_elt_pointer ("dynamic-drul", gh_cons (SCM_UNDEFINED, SCM_UNDEFINED));
}
-
-GLUE_SCORE_ELEMENT(Crescendo,brew_molecule);
-
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Crescendo,brew_molecule);
SCM
-Crescendo::member_brew_molecule () const
+Crescendo::brew_molecule (SCM smob)
{
- Real absdyn_dim = paper_l ()-> get_var ("crescendo_shorten");
- Real extra_left = get_broken_left_end_align ();
+ Score_element *me= unsmob_element (smob);
+ Spanner * sp = dynamic_cast<Spanner*>(me);
+ Real absdyn_dim = me->paper_l ()-> get_var ("crescendo_shorten");
+ Real extra_left = sp->get_broken_left_end_align ();
- SCM dir = get_elt_property("grow-direction");
- SCM dyns = get_elt_property ("dynamic-drul");
+ SCM dir = me->get_elt_property("grow-direction");
+ SCM dyns = me->get_elt_property ("dynamic-drul");
if (!isdir_b (dir) || !gh_pair_p (dyns))
{
- Crescendo * me = (Crescendo*)this;
me->suicide ();
return SCM_EOL;
}
Direction gd = to_dir (dir);
- bool dynleft= to_boolean (gh_car (dyns));
- bool dynright = to_boolean (gh_cdr (dyns));
+ bool dynleft= unsmob_element (gh_car (dyns));
+ bool dynright = unsmob_element (gh_cdr (dyns));
if (dynleft)
extra_left += absdyn_dim;
-
-
- Real width = spanner_length()- get_broken_left_end_align ();
+ Real width = sp->spanner_length()- sp->get_broken_left_end_align ();
if (dynleft)
{
Direction d = LEFT;
do
{
- Paper_column* s = dynamic_cast<Paper_column*>(get_bound (d)); // UGH
+ Paper_column* s = dynamic_cast<Paper_column*>(sp->get_bound (d)); // UGH
broken[d] = (!s->musical_b ());
}
while (flip (&d) != LEFT);
Molecule m;
Real pad = 0;
- SCM s = get_elt_property ("start-text");
+ SCM s = me->get_elt_property ("start-text");
if (gh_string_p (s))
{
- Molecule start_text (lookup_l ()->text ("italic",
+ Molecule start_text (me->lookup_l ()->text ("italic",
ly_scm2string (s),
- paper_l ()));
+ me->paper_l ()));
m.add_molecule (start_text);
- pad = paper_l ()->get_var ("interline") / 2;
+ pad = me->paper_l ()->get_var ("interline") / 2;
width -= start_text.extent (X_AXIS).length ();
width -= pad;
}
SCM at;
- s = get_elt_property ("spanner");
+ s =me->get_elt_property ("spanner");
Real height;
if (gh_string_p (s) && ly_scm2string (s) == "dashed-line")
{
- Real thick = paper_l ()->get_var ("crescendo_dash_thickness");
- Real dash = paper_l ()->get_var ("crescendo_dash");
+ Real thick = me->paper_l ()->get_var ("crescendo_dash_thickness");
+ Real dash = me->paper_l ()->get_var ("crescendo_dash");
height = thick;
at = gh_list (ly_symbol2scm (ly_scm2string (s).ch_C ()),
gh_double2scm (thick),
else
{
bool continued = broken[Direction (-gd)];
- height = paper_l()->get_var ("crescendo_height");
- Real thick = paper_l ()->get_var ("crescendo_thickness");
+ height = me->paper_l()->get_var ("crescendo_height");
+ Real thick = me->paper_l ()->get_var ("crescendo_thickness");
const char* hairpin = (gd < 0)? "decrescendo" : "crescendo";
*/
-#include "dot-column-engraver.hh"
+
#include "rhythmic-head.hh"
#include "dot-column.hh"
#include "side-position-interface.hh"
+#include "engraver.hh"
+
+class Dot_column_engraver : public Engraver
+{
+ Score_element *dotcol_p_ ;
+ Link_array<Rhythmic_head> head_l_arr_;
+public:
+ VIRTUAL_COPY_CONS(Translator);
+ Dot_column_engraver();
+
+protected:
+ virtual void acknowledge_element (Score_element_info);
+ virtual void do_pre_move_processing ();
+};
+
Dot_column_engraver::Dot_column_engraver ()
{
void
Dot_column_engraver::acknowledge_element (Score_element_info info)
{
- Rhythmic_head * h = dynamic_cast<Rhythmic_head*>(info.elem_l_);
- if (!h)
- return;
+ Score_element *d = unsmob_element (info.elem_l_->get_elt_pointer ("dot"));
+ if (d)
+ {
+ if (!dotcol_p_)
+ {
+ dotcol_p_ = new Item(get_property ("basicDotColumnProperties"));
- if (!h->dots_l ())
- return;
+ Dot_column::set_interface (dotcol_p_);
+ Side_position_interface (dotcol_p_).set_axis (X_AXIS);
+ Side_position_interface (dotcol_p_).set_direction (RIGHT);
+ announce_element (Score_element_info (dotcol_p_, 0));
+ }
- if (!dotcol_p_)
- {
- dotcol_p_ = new Dot_column(get_property ("basicDotColumnProperties"));
- Side_position_interface (dotcol_p_).set_axis (X_AXIS);
- Side_position_interface (dotcol_p_).set_direction (RIGHT);
- announce_element (Score_element_info (dotcol_p_, 0));
+ Dot_column::add_head (dotcol_p_, info.elem_l_);
}
-
- dotcol_p_->add_head (h);
}
void
-Dot_column::add_head (Rhythmic_head *r)
+Dot_column::add_head (Score_element * dc, Score_element *rh)
{
- if (!r->dots_l ())
- return ;
-
- Side_position_interface (this).add_support (r);
- Item * d = r->dots_l ();
+ Score_element * d = unsmob_element (rh->get_elt_pointer ("dot"));
if (d)
{
- Pointer_group_interface gi (this, "dots");
+ Side_position_interface (dc).add_support (rh);
+
+ Pointer_group_interface gi (dc, "dots");
gi.add_element (d);
d->add_offset_callback (force_shift_callback , Y_AXIS);
- Axis_group_interface (this).add_element (d);
+ Axis_group_interface (dc).add_element (d);
}
}
}
-Dot_column::Dot_column (SCM s)
- : Item (s)
+void
+Dot_column::set_interface (Score_element* dc)
{
- this->set_elt_pointer ("dots", SCM_EOL);
- Directional_element_interface (this).set (RIGHT);
+ dc->set_elt_pointer ("dots", SCM_EOL);
+ Directional_element_interface (dc).set (RIGHT);
- Axis_group_interface (this).set_interface ();
- Axis_group_interface (this).set_axes(X_AXIS,X_AXIS);
+ Axis_group_interface (dc).set_interface ();
+ Axis_group_interface (dc).set_axes(X_AXIS,X_AXIS);
}
/*
Real
-Dot_column::force_shift_callback (Score_element const * dot, Axis a)
+Dot_column::force_shift_callback (Score_element * dot, Axis a)
{
assert (a == Y_AXIS);
Score_element * me = dot->parent_l (X_AXIS);
Real
-Dots::quantised_position_callback (Score_element const* me, Axis a)
+Dots::quantised_position_callback (Score_element * me, Axis a)
{
assert (a == Y_AXIS);
*/
#include "debug.hh"
#include "dimensions.hh"
-#include "dimension-cache.hh"
#include "crescendo.hh"
#include "musical-request.hh"
-#include "lookup.hh"
-#include "paper-def.hh"
#include "paper-column.hh"
-#include "staff-symbol.hh"
#include "note-column.hh"
#include "item.hh"
#include "side-position-interface.hh"
#include "engraver.hh"
-#include "stem.hh"
-#include "rhythmic-head.hh"
#include "group-interface.hh"
#include "directional-element-interface.hh"
-#include "staff-symbol-referencer.hh"
#include "translator-group.hh"
#include "axis-group-interface.hh"
class Dynamic_engraver : public Engraver
{
Item * text_p_;
- Crescendo * finished_cresc_p_;
- Crescendo * cresc_p_;
+ Spanner * finished_cresc_p_;
+ Spanner * cresc_p_;
Text_script_req* text_req_l_;
else
{
current_cresc_req_ = accepted_spanreqs_drul_[START];
- cresc_p_ = new Crescendo (get_property ("basicCrescendoProperties"));
+ cresc_p_ = new Spanner (get_property ("basicCrescendoProperties"));
+ Crescendo::set_interface (cresc_p_);
cresc_p_->set_elt_property
("grow-direction",
gh_int2scm ((accepted_spanreqs_drul_[START]->span_type_str_ == "crescendo")
if (text_p_)
{
- index_set_cell (cresc_p_->get_elt_property ("dynamic-drul"),
- LEFT, SCM_BOOL_T);
+ index_set_cell (cresc_p_->get_elt_pointer ("dynamic-drul"),
+ LEFT, text_p_->self_scm_);
if (finished_cresc_p_)
- index_set_cell (finished_cresc_p_->get_elt_property ("dynamic-drul"),
- RIGHT, SCM_BOOL_T);
+ index_set_cell (finished_cresc_p_->get_elt_pointer ("dynamic-drul"),
+ RIGHT, text_p_->self_scm_);
}
Axis_group_interface (line_spanner_).add_element (cresc_p_);
#include "hara-kiri-group-spanner.hh"
#include "hara-kiri-engraver.hh"
#include "rhythmic-head.hh"
+#include "spanner.hh"
Spanner*
Hara_kiri_engraver::get_spanner_p () const
{
- return new Hara_kiri_group_spanner (get_property ("basicHaraKiriVerticalGroupspannerProperties"));
+ Spanner * sp = new Spanner (get_property ("basicHaraKiriVerticalGroupspannerProperties"));
+ Hara_kiri_group_spanner::set_interface (sp);
+ return sp;
}
void
if (Rhythmic_head *h = dynamic_cast<Rhythmic_head *> (i.elem_l_))
{
- dynamic_cast<Hara_kiri_group_spanner*> (staffline_p_)
- ->add_interesting_item (h);
+ Hara_kiri_group_spanner::add_interesting_item (staffline_p_, h);
}
-
}
ADD_THIS_TRANSLATOR(Hara_kiri_engraver);
*/
#include "axis-group-interface.hh"
+#include "spanner.hh"
#include "hara-kiri-group-spanner.hh"
#include "debug.hh"
#include "item.hh"
-/*
- */
-Hara_kiri_group_spanner::Hara_kiri_group_spanner(SCM s)
- : Spanner (s)
+void
+Hara_kiri_group_spanner::set_interface (Score_element*me)
{
- set_elt_pointer ("items-worth-living", SCM_EOL);
+ me->set_elt_pointer ("items-worth-living", SCM_EOL);
}
void
-Hara_kiri_group_spanner::add_interesting_item (Item* n)
+Hara_kiri_group_spanner::add_interesting_item (Score_element* me,Item* n)
{
- add_dependency (n);
- Pointer_group_interface (this, "items-worth-living").add_element (n);
+ me->add_dependency (n);
+ Pointer_group_interface (me, "items-worth-living").add_element (n);
}
-GLUE_SCORE_ELEMENT(Hara_kiri_group_spanner,after_line_breaking);
-SCM
-Hara_kiri_group_spanner::member_after_line_breaking ()
+void
+Hara_kiri_group_spanner::consider_suicide(Score_element*me)
{
- SCM worth = get_elt_pointer ("items-worth-living");
+ SCM worth = me->get_elt_pointer ("items-worth-living");
if (gh_pair_p (worth))
- return SCM_UNDEFINED;
+ return ;
- Link_array<Score_element> childs = Axis_group_interface (this).get_children ();
+ Link_array<Score_element> childs = Axis_group_interface (me).get_children ();
for (int i = 0; i < childs.size (); i++)
- {
- Score_element* s = childs[i];
+ childs[i]->suicide ();
- if ( line_l () != s->line_l ())
- programming_error ("Killing other children too");
- s->suicide ();
- }
/*
very appropriate name here :-)
*/
- suicide ();
- return SCM_UNDEFINED;
+ me->suicide ();
}
group. Use a callback to make sure that hara-kiri has been done
before asking for offsets. */
Real
-Hara_kiri_group_spanner::force_hara_kiri_callback (Score_element const *elt, Axis a)
+Hara_kiri_group_spanner::force_hara_kiri_callback (Score_element *elt, Axis a)
{
- while (elt && !dynamic_cast<Hara_kiri_group_spanner const*> (elt))
+ while (elt
+ && to_boolean (elt->get_elt_property ("hara-kiri-interface")))
elt = elt->parent_l(a);
if (elt)
{
- Hara_kiri_group_spanner const * seppuku = dynamic_cast<Hara_kiri_group_spanner const*> (elt);
-
- ((Hara_kiri_group_spanner*)seppuku)->member_after_line_breaking ();
+ Hara_kiri_group_spanner::consider_suicide (elt);
}
-
return 0.0;
}
Score_element * elt_l_;
Align_interface (Score_element const*);
- static Real alignment_callback (Score_element const*,Axis);
+ static Real alignment_callback (Score_element *,Axis);
void do_side_processing (Axis a);
void set_axis (Axis);
Axis axis () const;
int get_count (Score_element*)const;
void set_interface ();
bool has_interface_b ();
- static Real center_on_element (Score_element const *c, Axis);
+ static Real center_on_element (Score_element *c, Axis);
};
#endif /* ALIGN_INTERFACE_HH */
Score_element *elt_l_;
Axis_group_interface (Score_element*);
- static Interval group_extent_callback (Score_element const*,Axis);
+ static Interval group_extent_callback (Score_element *,Axis);
static Interval relative_group_extent (Axis, Score_element * common, SCM list);
void add_element (Score_element*);
/**
A vertical bar.
*/
-class Bar:public Item {
+class Bar:public Item
+{
public:
VIRTUAL_COPY_CONS(Score_element);
Bar(SCM);
int visible_stem_count () const;
Stem* first_visible_stem () const;
Stem* last_visible_stem () const;
- static Real rest_collision_callback (Score_element const*,Axis);
+ static Real rest_collision_callback (Score_element *,Axis);
Beam (SCM);
void add_stem (Stem*);
void set_grouping (Rhythmic_grouping def, Rhythmic_grouping current);
#ifndef BREATHING_SIGN_HH
#define BREATHING_SIGN_HH
-#include "item.hh"
-#include "parray.hh"
+#include "lily-guile.hh"
/*
breathing sign (apostrophe within staff, not the comma above staff
type)
*/
-class Breathing_sign : public Item
+class Breathing_sign
{
public:
static SCM brew_molecule (SCM);
-
- VIRTUAL_COPY_CONS(Score_element);
- Breathing_sign (SCM s);
-public:
- SCM member_after_line_breaking ();
- static SCM after_line_breaking (SCM);
- SCM member_brew_molecule () const;
+ static Real offset_callback (Score_element *, Axis);
+ static void set_interface (Score_element*);
};
#endif // BREATHING_SIGN_HH
+++ /dev/null
-/*
- chord-name-engraver.hh -- declare Chord_name_engraver
-
- source file of the GNU LilyPond music typesetter
-
- (c) 1998--2000 Jan Nieuwenhuizen <janneke@gnu.org>
-*/
-
-#ifndef CHORD_NAME_ENGRAVER_HH
-#define CHORD_NAME_ENGRAVER_HH
-
-#include "engraver.hh"
-#include "array.hh"
-#include "musical-pitch.hh"
-#include "lily-proto.hh"
-
-class Chord_name_engraver : public Engraver
-{
-public:
- Chord_name_engraver ();
- VIRTUAL_COPY_CONS (Translator);
-
-protected:
- virtual void do_pre_move_processing ();
- virtual void acknowledge_element (Score_element_info i);
- virtual void do_process_music ();
- virtual bool do_try_music (Music* m);
-
-private:
- Array<Musical_pitch> pitch_arr_;
- Chord_name* chord_name_p_;
- Tonic_req* tonic_req_;
- Inversion_req* inversion_req_;
- Bass_req* bass_req_;
-};
-
-#endif // CHORD_NAME_ENGRAVER_HH
#ifndef CHORD_NAME_HH
#define CHORD_NAME_HH
-#include "chord.hh"
-#include "item.hh"
+#include "lily-guile.hh"
#include "molecule.hh"
/**
inversion(optional): musical-pitch
bass(optional): musical-pitch
*/
-class Chord_name : public Item
+class Chord_name
{
public:
static SCM brew_molecule (SCM);
-
- VIRTUAL_COPY_CONS (Score_element);
- Molecule ly_word2molecule (SCM scm, Real* x) const;
- Molecule ly_text2molecule (SCM scm) const;
- Chord_name(SCM s);
-public:
- SCM member_brew_molecule () const;
-
+ static Molecule ly_word2molecule (Score_element*, SCM scm, Real* x) ;
+ static Molecule ly_text2molecule (Score_element*, SCM scm) ;
};
#endif // CHORD_NAME_HH
Score_element* elt_l_;
static SCM automatic_shift (Score_element*);
static SCM forced_shift (Score_element*);
- static Real force_shift_callback (Score_element const*, Axis);
+ static Real force_shift_callback (Score_element *, Axis);
static void do_shifts (Score_element*);
void add_column (Note_column*ncol_l);
#ifndef CRESCENDO_HH
#define CRESCENDO_HH
-#include "spanner.hh"
+#include "lily-guile.hh"
/**
The hairpin symbol. (cresc)
(normal spanner?)
*/
-class Crescendo : public Spanner {
+struct Crescendo
+{
public:
- static SCM brew_molecule (SCM);
-
- Crescendo(SCM);
-
- VIRTUAL_COPY_CONS(Score_element);
- SCM member_brew_molecule() const;
-
-private:
- Molecule get_symbol() const;
+ static SCM brew_molecule (SCM);
+ static void set_interface(Score_element*);
};
#endif // CRESCENDO_HH
#define DIMENSION_CACHE_CALLBACK_HH
-typedef Interval (*Dim_cache_callback)(Score_element const *,Axis);
-typedef Real (*Offset_callback)(Score_element const *,Axis);
+typedef Interval (*Dim_cache_callback)(Score_element *,Axis);
+typedef Real (*Offset_callback)(Score_element *,Axis);
#endif /* DIMENSION_CACHE_CALLBACK_HH */
+++ /dev/null
-/*
- dot-column-engraver.hh -- declare Dot_column_engraver
-
- source file of the GNU LilyPond music typesetter
-
- (c) 1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
-*/
-
-
-#ifndef DOT_COLUMN_GRAV_HH
-#define DOT_COLUMN_GRAV_HH
-
-#include "engraver.hh"
-
-class Dot_column_engraver : public Engraver
-{
- Dot_column *dotcol_p_ ;
- Link_array<Rhythmic_head> head_l_arr_;
-public:
- VIRTUAL_COPY_CONS(Translator);
- Dot_column_engraver();
-
-protected:
- virtual void acknowledge_element (Score_element_info);
- virtual void do_pre_move_processing ();
-};
-
-#endif // DOT_COLUMN_GRAV_HH
#ifndef DOT_COLUMN_HH
#define DOT_COLUMN_HH
-#include "item.hh"
-
+#include "lily-guile.hh"
/**
Group dots. This is needed because, the dots have to be aligned per voice
*/
-class Dot_column : public Item
+class Dot_column // interface
{
- static int compare (Score_element * const&,Score_element * const&);
public:
- VIRTUAL_COPY_CONS (Score_element);
- void add_head (Rhythmic_head*);
- Dot_column (SCM);
-
- static Real force_shift_callback (Score_element const* , Axis);
+ static int compare (Score_element * const&,Score_element * const&);
+ static void add_head (Score_element * dotcol, Score_element* rh );
+ static void set_interface (Score_element*);
+ static Real force_shift_callback (Score_element * , Axis);
static SCM do_shifts (SCM dotlist);
};
#endif // DOT_COLUMN_HH
class Dots // interface
{
public:
- static Real quantised_position_callback(Score_element const*, Axis);
+ static Real quantised_position_callback(Score_element*, Axis);
static SCM brew_molecule (SCM);
};
#ifndef HARA_KIRI_VERTICAL_GROUP_SPANNER_HH
#define HARA_KIRI_VERTICAL_GROUP_SPANNER_HH
-#include "spanner.hh"
+#include "lily-guile.hh"
+#include "lily-proto.hh"
/**
As Vertical_group_spanner, but keep track of interesting items. If
clear this line
*/
-class Hara_kiri_group_spanner : public Spanner
+class Hara_kiri_group_spanner
{
public:
- static Real force_hara_kiri_callback (Score_element const* , Axis);
- Hara_kiri_group_spanner (SCM);
- SCM member_after_line_breaking ();
- static SCM after_line_breaking (SCM);
-
- void add_interesting_item (Item* n);
-
- VIRTUAL_COPY_CONS(Score_element);
+ static Real force_hara_kiri_callback (Score_element * , Axis);
+ static void set_interface (Score_element*me);
+ static void consider_suicide (Score_element*me);
+ static void add_interesting_item (Score_element * me , Item* n);
};
#ifndef KEYITEM_HH
#define KEYITEM_HH
-#include "item.hh"
-#include "array.hh"
-
+#include "lily-guile.hh"
+#include "lily-proto.hh"
/**
A group of accidentals.
new-accidentals -- list of (pitch, accidental) pairs
*/
-class Key_item :public Item
+struct Key_item
{
- int calculate_position(SCM pair) const;
-
-public:
- VIRTUAL_COPY_CONS(Score_element);
- Key_item (SCM);
+ static int calculate_position(Score_element*,SCM pair) ;
+ void set_interface (Score_element*);
static SCM brew_molecule (SCM);
-
-
-
- SCM member_brew_molecule() const;
};
#endif // KEYITEM_HH
#ifndef LOCALKEYITEM_HH
#define LOCALKEYITEM_HH
+
+
#include "item.hh"
#include "array.hh"
#include "musical-pitch.hh"
{
public:
Multi_measure_rest (SCM);
- static SCM brew_molecule (SCM);
-
- void add_column (Item*);
- Molecule compound_rest (int)const;
-
- SCM member_brew_molecule () const;
+ static void set_interface (Score_element*);
+ static SCM brew_molecule (SCM);
+ static void add_column (Score_element*,Item*);
VIRTUAL_COPY_CONS (Score_element);
-
- SCM member_after_line_breaking ();
- static SCM after_line_breaking (SCM);
virtual Array<Rod> get_rods () const;
};
void add_rod (Paper_column * to, Real distance);
void add_spring (Paper_column * to, Real dist, Real strength);
- virtual Paper_column * column_l () const;
+ virtual Paper_column *column_l () const;
virtual Line_of_score *line_l () const;
/// if lines are broken then this column is in #line#
/// which one (left =0)
int rank_i() const;
- Paper_column (Moment when);
+ Paper_column (SCM);
Moment when_mom ()const;
bool musical_b () const;
void output_font_switch (int i);
void output_header ();
void output_comment (String s);
+ void output_string (SCM s);
void output_scheme (SCM scm);
};
+++ /dev/null
-/*
- repeat-engraver.hh -- declare Repeat_engraver
-
- source file of the GNU LilyPond music typesetter
-
- (c) 1998--2000 Jan Nieuwenhuizen <janneke@gnu.org>
-*/
-
-#ifndef REPEAT_ENGRAVER_HH
-#define REPEAT_ENGRAVER_HH
-
-#include "engraver.hh"
-#include "cons.hh"
-
-struct Bar_create_event
-{
- Moment when_;
- bool bar_b_;
- bool last_b_;
- String type_;
- Bar_create_event();
- Bar_create_event (Moment w, String s);
- Bar_create_event (Moment w, int i, int j);
-};
-
-int compare (Bar_create_event const & c1, Bar_create_event const &c2)
-{
- return (c1.when_ - c2.when_).sign();
-}
-
-/**
- Generate repeat-bars |: :| for repeated-music
- */
-class Repeat_engraver : public Engraver
-{
-public:
- VIRTUAL_COPY_CONS(Translator);
- Repeat_engraver ();
-protected:
- virtual void acknowledge_element (Score_element_info i);
- virtual void do_removal_processing ();
- virtual bool do_try_music (Music *req_l);
- virtual void do_process_music();
- virtual void do_pre_move_processing();
- virtual void do_post_move_processing ();
- void queue_events ();
-
-private:
- Repeated_music *repeated_music_l_;
- bool done_this_one_b_;
-
- /*
- Royal_brackla_create_queue is only two Whiskies away. :-)
- */
- Cons<Bar_create_event> *create_barmoments_queue_;
-
- Volta_spanner * volta_span_p_;
- Volta_spanner* end_volta_span_p_;
-};
-
-#endif // REPEAT_ENGRAVER_HH
-
Rest_collision(Score_element*);
void set_interface ();
- static Real force_shift_callback (Score_element const*, Axis);
+ static Real force_shift_callback (Score_element *, Axis);
static SCM do_shift (Score_element*,SCM);
};
#endif // REST_COLLISION_HH
#include "smobs.hh"
#include "dimension-cache.hh"
-typedef Interval (*Extent_callback)(Score_element const *,Axis);
-typedef Real (*Offset_callback)(Score_element const *,Axis);
+typedef Interval (*Extent_callback)(Score_element *,Axis);
+typedef Real (*Offset_callback)(Score_element *,Axis);
#define READONLY_PROPS // FIXME.
Molecule get_molecule () const;
void suicide ();
- static Interval preset_extent (Score_element const*,Axis);
- static Interval point_dimension_callback (Score_element const*,Axis );
- static Interval molecule_extent (Score_element const*,Axis);
+ static Interval preset_extent (Score_element *,Axis);
+ static Interval point_dimension_callback (Score_element *,Axis );
+ static Interval molecule_extent (Score_element *,Axis);
protected:
/**
+++ /dev/null
-/*
- score-align-engraver.hh -- declare Type_align_engraver
-
- source file of the GNU LilyPond music typesetter
-
- (c) 1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
-*/
-
-
-#ifndef SCOREF_ALIGN_GRAV_HH
-#define SCOREF_ALIGN_GRAV_HH
-
-#include "engraver.hh"
-
-/**
- Group a number of items across staffs:
-
- Acknowledge items, put each priority in a separate column. Put all
- columns in a horizontal align engraver. We manufacture two types of
- elements: the alignment element and the columns. This is probably
- more convenient, and I question the use having one without the
- other.
-*/
-class Score_priority_engraver : public Engraver
-{
- Break_align_item * halign_p_;
- Link_array<Item> column_p_arr_;
-
- void add_horizontal_group (Item* , int p);
-public:
- VIRTUAL_COPY_CONS(Translator);
- Score_priority_engraver ();
-
-protected:
- virtual void acknowledge_element (Score_element_info);
- virtual void do_pre_move_processing();
-};
-
-#endif // SCORE_ALIGN_GRAV_HH
#ifndef Script_COLUMN_HH
#define Script_COLUMN_HH
-#include "item.hh"
+#include "lily-guile.hh"
+#include "lily-proto.hh"
-class Script_column : public Item
+class Script_column
{
public:
- Script_column(SCM);
- void add_staff_sided (Item*);
-
- SCM member_before_line_breaking ();
+ static void add_staff_sided (Score_element*, Item*);
static SCM before_line_breaking (SCM);
};
*/
class Script : public Item
{
- Molecule get_molecule (Direction d) const;
public:
+ static Molecule get_molecule (Score_element*,Direction d);
Script (SCM);
- static SCM brew_molecule (SCM);
-
-
-
- SCM member_before_line_breaking ();
- static SCM before_line_breaking (SCM);
+ static SCM brew_molecule (SCM);
SCM member_after_line_breaking ();
static SCM after_line_breaking (SCM);
- SCM member_brew_molecule () const;
};
#endif /* Stem_SCRIPT_HH */
class Separating_group_spanner : public Spanner
{
public:
- void add_spacing_unit (Single_malt_grouping_item*);
+ void add_spacing_unit (Item*);
Separating_group_spanner(SCM);
protected:
VIRTUAL_COPY_CONS(Score_element);
#ifndef SEPARATING_LINE_GROUP_GRAV_HH
#define SEPARATING_LINE_GROUP_GRAV_HH
-
-#include "engraver.hh"
-
-class Separating_line_group_engraver : public Engraver
-{
-protected:
- Single_malt_grouping_item * break_malt_p_;
- Single_malt_grouping_item* nobreak_malt_p_;
- Separating_group_spanner * sep_span_p_;
-
- virtual void acknowledge_element (Score_element_info);
- virtual void do_creation_processing ();
- virtual void do_removal_processing ();
- virtual void do_pre_move_processing ();
-public:
- Separating_line_group_engraver ();
- VIRTUAL_COPY_CONS (Translator);
-
-};
-
-
#endif /* SEPARATING_LINE_GROUP_GRAV_HH */
--- /dev/null
+/*
+ single-malt-grouping-item.hh -- declare Separation_item
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+
+ */
+
+#ifndef SINGLE_MALT_GROUPING_ITEM_HH
+#define SINGLE_MALT_GROUPING_ITEM_HH
+
+#include "lily-proto.hh"
+
+/** Calc dimensions for the Separating_group_spanner; this has to be
+ an item to get dependencies correct. It can't be an element_group
+ since these usually are in a different X_group
+
+ Properties:
+
+
+ elements -- list of items.
+
+ no-spacing-rods -- read from elements: boolean that makes Separation_item ignore
+ this item
+
+*/
+struct Separation_item
+{
+ static void set_interface (Score_element*);
+ static Interval my_width (Score_element*) ;
+ static void add_item (Score_element*,Item*);
+};
+
+#endif /* SINGLE_MALT_GROUPING_ITEM_HH */
+
Score_element * elt_l_;
public:
Side_position_interface (Score_element const*);
- static Real side_position (Score_element const *, Axis);
- static Real aligned_on_self (Score_element const *, Axis);
- static Real aligned_side (Score_element const *, Axis);
- static Real quantised_position (Score_element const*, Axis);
- static Real centered_on_parent (Score_element const*, Axis);
+ static Real side_position (Score_element *, Axis);
+ static Real aligned_on_self (Score_element *, Axis);
+ static Real aligned_side (Score_element *, Axis);
+ static Real quantised_position (Score_element *, Axis);
+ static Real centered_on_parent (Score_element *, Axis);
void set_axis (Axis);
void set_minimum_space (Real);
void set_padding (Real);
+++ /dev/null
-/*
- single-malt-grouping-item.hh -- declare Single_malt_grouping_item
-
- source file of the GNU LilyPond music typesetter
-
- (c) 1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
-
- */
-
-#ifndef SINGLE_MALT_GROUPING_ITEM_HH
-#define SINGLE_MALT_GROUPING_ITEM_HH
-
-#include "item.hh"
-
-/** Calc dimensions for the Separating_group_spanner; this has to be
- an item to get dependencies correct. It can't be an element_group
- since these usually are in a different X_group
-
- It's 1:30 am. Naming suggestions appreciated.
-
- Properties:
-
-
- elements -- list of items.
-
- no-spacing-rods -- read from elements: boolean that makes Single_malt_grouping_item ignore
- this item
-
-*/
-class Single_malt_grouping_item : public Item
-{
- VIRTUAL_COPY_CONS(Score_element);
-public:
- Single_malt_grouping_item (SCM);
- Interval my_width () const;
- void add_item (Item*);
-};
-
-#endif /* SINGLE_MALT_GROUPING_ITEM_HH */
-
void add_bar (Score_element*);
void evaluate_empty ();
- static Interval width_callback(Score_element const*, Axis) ;
+ static Interval width_callback(Score_element *, Axis) ;
virtual Real get_bar_size () const;
SCM member_before_line_breaking ();
public:
Link_array<Spanner> broken_into_l_arr_;
-
+ Real get_broken_left_end_align () const;
// TODO: make virtual and do this for Items as well.
Interval_t<int> spanned_rank_iv ();
void set_bound (Direction d, Score_element*);
protected:
void set_my_columns ();
VIRTUAL_COPY_CONS(Score_element);
- Real get_broken_left_end_align () const;
+
virtual void do_space_processing ();
virtual void do_break_processing ();
class Staff_symbol_referencer_interface
{
public:
- Score_element * elt_l_;
+ Score_element * elt_l_; // junkme.
Staff_symbol_referencer_interface (Score_element const*);
- void set_interface ();
- bool has_interface_b ();
+ static void set_interface (Score_element*);
+ static bool has_interface_b (Score_element*);
void set_position (Real);
- static Real callback (Score_element const*, Axis a);
+ static Real callback (Score_element *, Axis a);
/**
Leading are the lead strips between the sticks (lines) of
#ifndef ABBREV_HH
#define ABBREV_HH
-#include "item.hh"
+#include "lily-proto.hh"
+#include "lily-guile.hh"
-
-class Stem_tremolo : public Item {
+class Stem_tremolo
+{
public:
- Stem * stem_l () const;
- SCM member_brew_molecule () const;
-
+ static void set_interface (Score_element*);
static Interval dim_callback (Score_element*, Axis);
static SCM brew_molecule (SCM);
- Stem_tremolo (SCM);
- void set_stem (Stem *);
+ static void set_stem (Score_element*me, Score_element *st);
};
#endif /* ABBREV_HH */
void position_noteheads();
Real stem_end_position () const;
- static Real off_callback (Score_element const*, Axis);
+ static Real off_callback (Score_element *, Axis);
Molecule flag () const;
SCM member_before_line_breaking ();
static SCM before_line_breaking (SCM);
- static Interval dim_callback (Score_element const*,Axis);
+ static Interval dim_callback (Score_element *,Axis);
SCM member_brew_molecule() const;
void set_spacing_hints () ;
VIRTUAL_COPY_CONS (Score_element);
- virtual SCM member_after_line_breaking ();
static SCM after_line_breaking (SCM);
+ static void try_collapse (Score_element*);
Molecule staff_bracket (Real) const;
Molecule staff_brace (Real) const;
class Tie_column : public Spanner
{
public:
- VIRTUAL_COPY_CONS (Score_element);
- void add_tie (Tie*);
Tie_column (SCM s);
+ VIRTUAL_COPY_CONS (Score_element);
+ static void set_interface (Score_element*me);
+ static void add_tie (Score_element*me,Tie*);
- SCM member_after_line_breaking ();
static SCM after_line_breaking (SCM);
- void set_directions ();
+ static void set_directions (Score_element*me);
};
#endif /* TIE_COLUMN_HH */
{
public:
Tie (SCM);
- void set_head (Direction, Item*head_l);
+ static void set_head (Score_element*,Direction, Item*head_l);
+ static void set_interface (Score_element*);
VIRTUAL_COPY_CONS(Score_element);
-
- Rhythmic_head* head (Direction) const;
- Real position_f () const;
+ static Rhythmic_head* head (Score_element*,Direction) ;
+ static Real position_f (Score_element*) ;
static SCM brew_molecule (SCM);
- Direction get_default_dir() const;
- SCM member_brew_molecule () const;
- Array<Offset> get_encompass_offset_arr () const;
- Bezier get_curve () const;
+ static Direction get_default_dir(Score_element*) ;
+ static SCM after_line_breaking (SCM);
+
/*
JUNKME
*/
+ Array<Offset> get_encompass_offset_arr () const;
+ Bezier get_curve () const;
Drul_array<Real> dy_f_drul_;
Drul_array<Real> dx_f_drul_;
-
- virtual void do_add_processing ();
- SCM member_after_line_breaking ();
- static SCM after_line_breaking (SCM);
-
virtual Array<Rod> get_rods () const;
-
Array<Offset> get_controls () const;
};
+++ /dev/null
-/*
- time_signature-engraver.hh -- declare Time_signature_engraver
-
- source file of the GNU LilyPond music typesetter
-
- (c) 1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
-*/
-
-
-#ifndef TIME_SIG_ENGRAVER_HH
-#define TIME_SIG_ENGRAVER_HH
-
-#include "engraver.hh"
-
-/**
- generate time_signatures.
- */
-class Time_signature_engraver : public Engraver {
-protected:
- virtual void do_process_music();
- virtual void do_pre_move_processing();
-public:
- VIRTUAL_COPY_CONS(Translator);
- Time_signature * time_signature_p_;
-
- Time_signature_engraver();
-};
-#endif // TIME_SIG_ENGRAVER_HH
#define METER_HH
#include "item.hh"
-#include "array.hh"
-#include "real.hh"
/**
Print a time_signature sign.
- TODO:
- C style time_signatures, 2+3+2/8 time_signatures, alla breve.
+ TODO:
+
+ 2+3+2/8 time_signatures
*/
-class Time_signature: public Item
+struct Time_signature
{
- Molecule special_time_signature (String,int,int) const;
- Molecule time_signature (int, int)const;
-
-public:
- SCM member_brew_molecule() const;
-
- Time_signature (SCM);
- static SCM brew_molecule (SCM);
-
-
- /*
- TODO: make this SCM!
- */
- Array<int> args_;
-
- VIRTUAL_COPY_CONS(Score_element);
+ static Molecule special_time_signature (Score_element*,String,int,int) ;
+ static Molecule time_signature (Score_element*,int, int);
+ static SCM brew_molecule (SCM);
};
#endif // METER_HH
#ifndef Tuplet_spanner_HH
#define Tuplet_spanner_HH
-#include "spanner.hh"
+#include "lily-guile.hh"
/** supportable plet: triplets, eentweetjes, ottava, etc.
todo: handle breaking elegantly.
*/
-class Tuplet_spanner : public Spanner
+class Tuplet_spanner
{
public:
- Tuplet_spanner (SCM);
static SCM brew_molecule (SCM);
-
+ static void set_interface (Score_element*);
- void add_column (Note_column*);
- void add_beam (Beam*);
+ static void add_column (Score_element*me,Item*);
+ static void add_beam (Score_element*me,Score_element*);
- void calc_dy (Real *) const;
- void calc_position_and_height (Real*,Real *dy)const;
+ static void calc_dy (Score_element*,Real *) ;
+ static void calc_position_and_height (Score_element*,Real*,Real *dy);
- SCM member_after_line_breaking ();
static SCM after_line_breaking (SCM);
- SCM member_brew_molecule () const;
- VIRTUAL_COPY_CONS(Score_element);
-
- Direction get_default_dir () const;
+ static Direction get_default_dir (Score_element*);
};
#endif // Tuplet_spanner_HH
/** Volta bracket with number */
-class Volta_spanner : public Spanner
+class Volta_spanner
{
public:
- Volta_spanner (SCM);
+ static void set_interface (Score_element*);
static SCM brew_molecule (SCM);
- void add_column (Note_column*);
- void add_bar (Bar*);
-
- SCM member_brew_molecule () const;
- VIRTUAL_COPY_CONS (Score_element);
+ static void add_column (Score_element*, Score_element*col);
+ static void add_bar (Score_element*me, Item*bar);
-
- SCM member_after_line_breaking ();
- static SCM after_line_breaking (SCM);
};
#endif // VOLTA_SPANNER_HH
VIRTUAL_COPY_CONS(Translator);
Key_change_req * keyreq_l_;
- Key_item * item_p_;
- Protected_scm old_accs_;
+ Item * item_p_;
+ Protected_scm old_accs_; // ugh. -> property
protected:
virtual void do_creation_processing();
{
if (!item_p_)
{
- item_p_ = new Key_item ( get_property ("basicKeyProperties"));
-
+ item_p_ = new Item ( get_property ("basicKeyProperties"));
+
item_p_->set_elt_property ("c0-position", gh_int2scm (0));
// todo: put this in basic props.
item_p_->set_elt_property ("old-accidentals", old_accs_);
item_p_->set_elt_property ("new-accidentals", get_property ("keySignature"));
- Staff_symbol_referencer_interface st (item_p_);
- st.set_interface ();
+ Staff_symbol_referencer_interface::set_interface (item_p_);
SCM prop = get_property ("keyOctaviation");
bool multi = to_boolean (prop);
keyplacement by Mats Bengtsson
*/
-#include "group-interface.hh"
+#include "item.hh"
#include "key-item.hh"
#include "molecule.hh"
#include "paper-def.hh"
#include "lookup.hh"
#include "staff-symbol-referencer.hh"
-Key_item::Key_item (SCM s)
- : Item (s)
-{
- set_elt_property ("c0-position", gh_int2scm (0));
-}
-
-
/*
FIXME: too much hardcoding here.
*/
the thinking to other parties.
*/
int
-Key_item::calculate_position(SCM pair) const
+Key_item::calculate_position(Score_element *ki, SCM pair)
{
int p = gh_scm2int (gh_car (pair));
int a = gh_scm2int (gh_cdr (pair));
-
- if (to_boolean (get_elt_property ("multi-octave")))
+ int c0p = gh_scm2int (ki->get_elt_property ("c0-position"));
+ if (to_boolean (ki->get_elt_property ("multi-octave")))
{
- return p + gh_scm2int (get_elt_property ("c0-position"));
+ return p + c0p;
}
else {
// Find the c in the range -4 through 2
- int from_bottom_pos = gh_scm2int (get_elt_property ("c0-position")) + 4;
+ int from_bottom_pos = c0p + 4;
from_bottom_pos = from_bottom_pos%7;
from_bottom_pos = (from_bottom_pos + 7)%7; // Precaution to get positive.
int c0 = from_bottom_pos - 4;
TODO
- space the `natural' signs wider
*/
-GLUE_SCORE_ELEMENT(Key_item,brew_molecule);
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Key_item,brew_molecule);
SCM
-Key_item::member_brew_molecule () const
+Key_item::brew_molecule (SCM smob)
{
- Molecule mol;
+ Score_element*me =unsmob_element (smob);
- Staff_symbol_referencer_interface si (this);
+
+ Staff_symbol_referencer_interface si (me);
Real inter = si.staff_space ()/2.0;
- SCM newas = get_elt_property ("new-accidentals");
-
+ SCM newas = me->get_elt_property ("new-accidentals");
+ Molecule mol;
/*
SCM lists are stacks, so we work from right to left, ending with
the cancellation signature.
for (SCM s = newas; gh_pair_p (s); s = gh_cdr (s))
{
int a = gh_scm2int (gh_cdar (s));
- Molecule m = lookup_l ()->afm_find ("accidentals-" + to_str (a));
- m.translate_axis (calculate_position(gh_car (s)) * inter, Y_AXIS);
+ Molecule m = me->lookup_l ()->afm_find ("accidentals-" + to_str (a));
+ m.translate_axis (calculate_position(me, gh_car (s)) * inter, Y_AXIS);
mol.add_at_edge (X_AXIS, LEFT, m, 0);
}
-
- if (break_status_dir () != RIGHT)
+
+ Item *it = dynamic_cast<Item*> (me) ;
+ if (it->break_status_dir () != RIGHT)
{
- SCM old = get_elt_property ("old-accidentals");
+ SCM old = me->get_elt_property ("old-accidentals");
/*
Add half a space between cancellation and key sig.
Interval x(0, inter);
Interval y(0,0);
- mol.add_at_edge (X_AXIS, LEFT, lookup_l()->blank (Box(x,y)),0);
+ mol.add_at_edge (X_AXIS, LEFT, me->lookup_l()->blank (Box(x,y)),0);
for (; gh_pair_p (old); old = gh_cdr (old))
{
if (found == SCM_EOL || gh_cdr (found) != gh_cdar (old))
{
- Molecule m =lookup_l ()->afm_find ("accidentals-0");
+ Molecule m =me->lookup_l ()->afm_find ("accidentals-0");
- m.translate_axis (calculate_position(gh_car(old)) * inter, Y_AXIS);
+ m.translate_axis (calculate_position (me, gh_car (old)) * inter, Y_AXIS);
mol.add_at_edge (X_AXIS, LEFT, m,0);
}
}
progress_indication (to_str (i));
progress_indication ("]");
}
+
+ if (i < broken_into_l_arr_.size () - 1)
+ {
+ SCM lastcol = gh_car (line_l->get_elt_pointer ("columns"));
+ Score_element* e = unsmob_element (lastcol);
+ SCM inter = e->get_elt_property ("between-system-string");
+ if (gh_string_p (inter))
+ {
+ pscore_l_->outputter_l_->output_string (inter);
+ }
+ }
}
}
set_elt_pointer ("columns", gh_cons (p->self_scm_, cs));
Axis_group_interface (this).add_element (p);
- typeset_element (p);
}
void
Local_key_engraver::process_acknowledged ()
{
- SCM localsig = get_property ("localKeySignature");
-
if (!key_item_p_ && mel_l_arr_.size())
{
+ SCM localsig = get_property ("localKeySignature");
+
SCM f = get_property ("forgetAccidentals");
bool forget = to_boolean (f);
for (int i=0; i < mel_l_arr_.size(); i++)
key_item_p_ = new Local_key_item (get_property ("basicLocalKeyProperties"));
Side_position_interface (key_item_p_).set_axis (X_AXIS);
Side_position_interface (key_item_p_).set_direction (LEFT);
- Staff_symbol_referencer_interface (key_item_p_).set_interface ();
+ Staff_symbol_referencer_interface::set_interface (key_item_p_);
announce_element (Score_element_info (key_item_p_, 0));
}
#endif
}
}
- }
+
daddy_trans_l_->set_property ("localKeySignature", localsig);
+ }
/*
- UGH !
*/
if (key_item_p_ && grace_align_l_)
{
grace_align_l_ = gai;
}
- Note_req * note_l = dynamic_cast <Note_req *> (info.req_l_);
- Rhythmic_head * note_head = dynamic_cast<Rhythmic_head *> (info.elem_l_);
-
if (he_gr != selfgr)
return;
+ Note_req * note_l = dynamic_cast <Note_req *> (info.req_l_);
+ Rhythmic_head * note_head = dynamic_cast<Rhythmic_head *> (info.elem_l_);
+
if (note_l && note_head)
{
mel_l_arr_.push (note_l);
}
else if (Tie * tie_l = dynamic_cast<Tie *> (info.elem_l_))
{
- tied_l_arr_.push (tie_l->head (RIGHT));
+ tied_l_arr_.push (Tie::head (tie_l, RIGHT));
}
}
/*
- ugh. deep_copy uses lots of space.
+ ugh. repeated deep_copy generates lots of garbage.
*/
void
Local_key_engraver::do_process_music()
else if (last_keysig_ != sig)
{
daddy_trans_l_->set_property ("localKeySignature", ly_deep_copy (sig));
+ last_keysig_ = sig;
}
}
}
/**
-TODO: move into Text_item
+TODO: move into Text_item. UGH: paper_l argument shoudl be junked.
*/
Molecule
Lookup::text (String style, String text, Paper_def *paper_l)
if (Bar *c = dynamic_cast<Bar*> (i.elem_l_))
{
if (mmrest_p_)
- mmrest_p_->add_column (c);
+ Multi_measure_rest::add_column (mmrest_p_,c);
if (lastrest_p_)
- lastrest_p_->add_column (c);
+ Multi_measure_rest::add_column (mmrest_p_,c);
}
}
if (busy_span_req_l_ && !mmrest_p_)
{
mmrest_p_ = new Multi_measure_rest (get_property ("basicMultiMeasureRestProperties"));
- Staff_symbol_referencer_interface si (mmrest_p_);
- si.set_interface ();
+ Multi_measure_rest::set_interface (mmrest_p_);
+ Staff_symbol_referencer_interface::set_interface (mmrest_p_);
announce_element (Score_element_info (mmrest_p_, busy_span_req_l_));
start_measure_i_
#include "group-interface.hh"
#include "stem.hh"
#include "staff-symbol-referencer.hh"
-
-Multi_measure_rest::Multi_measure_rest (SCM s)
- : Spanner (s)
+void
+Multi_measure_rest::set_interface (Score_element*me)
{
- set_elt_pointer ("columns", SCM_EOL);
+ me->set_elt_pointer ("columns", SCM_EOL);
}
+Multi_measure_rest::Multi_measure_rest (SCM s)
+ : Spanner(s)
+{}
/*
[TODO] 17
* variable-sized multi-measure rest symbol: |====| ??
*/
-
-GLUE_SCORE_ELEMENT(Multi_measure_rest,brew_molecule);
-
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Multi_measure_rest,brew_molecule);
SCM
-Multi_measure_rest::member_brew_molecule () const
+Multi_measure_rest::brew_molecule (SCM smob)
{
+ Score_element *me = unsmob_element (smob);
+ Spanner * sp = dynamic_cast<Spanner*> (me);
Real staff_space
- = Staff_symbol_referencer_interface (this).staff_space ();
+ = Staff_symbol_referencer_interface (me).staff_space ();
Interval sp_iv;
Direction d = LEFT;
do
{
- Item * col = get_bound (d)->column_l ();
+ Item * col = sp->get_bound (d)->column_l ();
Interval coldim = col->extent (X_AXIS)
+ col->relative_coordinate (0, X_AXIS);
Molecule mol;
Real x_off = 0.0;
- Real rx = get_bound (LEFT)->relative_coordinate (0, X_AXIS);
+ Real rx = sp->get_bound (LEFT)->relative_coordinate (0, X_AXIS);
/*
we gotta stay clear of sp_iv, so move a bit to the right if
needed.
Molecule s;
int measures = 1;
- SCM m (get_elt_property ("measure-count"));
+ SCM m (me->get_elt_property ("measure-count"));
if (gh_number_p (m))
{
measures = gh_scm2int (m);
}
- if (measures <= paper_l() ->get_var ("multi_measure_rest_expand_limit"))
+ if (measures <= me->paper_l() ->get_var ("multi_measure_rest_expand_limit"))
{
/*
Build a rest from smaller parts. Distances inbetween are
}
Real pad = s.empty_b ()
- ? 0.0 : paper_l ()->get_var ("multi_measure_rest_padding");
+ ? 0.0 : me->paper_l ()->get_var ("multi_measure_rest_padding");
- Molecule r (lookup_l ()->afm_find ("rests-" + to_str (k)));
+ Molecule r (me->lookup_l ()->afm_find ("rests-" + to_str (k)));
if (k == 0)
r.translate_axis (staff_space, Y_AXIS);
else
{
String idx = ("rests-") + to_str (-4);
- s = lookup_l ()->afm_find (idx);
+ s = me->lookup_l ()->afm_find (idx);
}
mol.add_molecule (s);
if (measures > 1)
{
- Molecule s (lookup_l ()->text ("number", to_str (measures), paper_l ()));
+ Molecule s (me->lookup_l ()->text ("number", to_str (measures), me->paper_l ()));
s.align_to (X_AXIS, CENTER);
s.translate_axis (3.0 * staff_space, Y_AXIS);
mol.add_molecule (s);
/*
UGH. JUNKME elt prop "columns" isn't really needed.
*/
-
-
-
-
void
-Multi_measure_rest::add_column (Item* c)
+Multi_measure_rest::add_column (Score_element*me,Item* c)
{
- Pointer_group_interface gi (this, "columns");
+ Pointer_group_interface gi (me, "columns");
gi.add_element (c);
- add_bound_item (this, c);
-
- add_dependency (c);
+ add_bound_item (dynamic_cast<Spanner*> (me),c);
}
#include "dimension-cache.hh"
#include "staff-symbol-referencer.hh"
-
-
/*
build a ledger line for small pieces.
*/
{
Rhythmic_head *note_p = new Rhythmic_head (get_property ("basicNoteHeadProperties"));
- Staff_symbol_referencer_interface si (note_p);
- si.set_interface ();
+ Staff_symbol_referencer_interface::set_interface (note_p);
+
Note_req * note_req_l = note_req_l_arr_[i];
{
Item * d = new Item (get_property ("basicDotsProperties"));
- Staff_symbol_referencer_interface sd (d);
- sd.set_interface ();
+ Staff_symbol_referencer_interface::set_interface (d);
note_p->set_dots (d);
announce_element (Score_element_info (d,0));
dot_p_arr_.push (d);
}
- si.set_position(note_req_l->pitch_.steps ());
+
+ note_p->set_elt_property("staff-position", gh_int2scm (note_req_l->pitch_.steps ()));
Score_element_info itinf (note_p,note_req_l);
announce_element (itinf);
return (Paper_column*)(this);
}
-Paper_column::Paper_column (Moment w)
- : Item (SCM_EOL) // guh.?
+Paper_column::Paper_column (SCM l)
+ : Item (l) // guh.?
{
- SCM when = smobify (new Moment (w));
- set_elt_property ("when", when);
-
Axis_group_interface (this).set_interface ();
Axis_group_interface (this).set_axes (X_AXIS, X_AXIS);
set_elt_pointer ("bounded-by-me", SCM_EOL);
-
-
+void
+Paper_outputter::output_string (SCM str)
+{
+ *stream_p_ << ly_scm2string (str);
+}
(c) 1998--2000 Jan Nieuwenhuizen <janneke@gnu.org>
*/
-#include "repeat-engraver.hh"
+#include "engraver.hh"
+#include "cons.hh"
#include "bar.hh"
#include "bar-engraver.hh"
#include "musical-request.hh"
#include "note-column.hh"
#include "paper-def.hh"
#include "music-list.hh"
+#include "side-position-interface.hh"
+
+struct Bar_create_event
+{
+ Moment when_;
+ bool bar_b_;
+ bool last_b_;
+ String type_;
+ Bar_create_event();
+ Bar_create_event (Moment w, String s);
+ Bar_create_event (Moment w, int i, int j);
+};
+
+int compare (Bar_create_event const & c1, Bar_create_event const &c2)
+{
+ return (c1.when_ - c2.when_).sign();
+}
+
+/**
+ Generate repeat-bars |: :| for repeated-music
+ */
+class Repeat_engraver : public Engraver
+{
+public:
+ VIRTUAL_COPY_CONS(Translator);
+ Repeat_engraver ();
+protected:
+ virtual void acknowledge_element (Score_element_info i);
+ virtual void do_removal_processing ();
+ virtual bool do_try_music (Music *req_l);
+ virtual void do_process_music();
+ virtual void do_pre_move_processing();
+ virtual void do_post_move_processing ();
+ void queue_events ();
+
+private:
+ Repeated_music *repeated_music_l_;
+ bool done_this_one_b_;
+
+ /*
+ Royal_brackla_create_queue is only two Whiskies away. :-)
+ */
+ Cons<Bar_create_event> *create_barmoments_queue_;
+
+ Spanner * volta_span_p_;
+ Spanner* end_volta_span_p_;
+};
+
+
+
ADD_THIS_TRANSLATOR (Repeat_engraver);
else
{
assert (!volta_span_p_);
- volta_span_p_ = new Volta_spanner (get_property ("basicVoltaSpannerProperties"));
+ volta_span_p_ = new Spanner (get_property ("basicVoltaSpannerProperties"));
+ Volta_spanner::set_interface (volta_span_p_);
announce_element (Score_element_info (volta_span_p_,0));
volta_span_p_->set_elt_property ("text",
ly_str02scm (t.ch_C()));
if (Note_column *c = dynamic_cast<Note_column *> (i.elem_l_))
{
if (volta_span_p_)
- volta_span_p_->add_column (c);
+ Volta_spanner::add_column (volta_span_p_,c);
if (end_volta_span_p_)
- end_volta_span_p_->add_column (c);
+ Volta_spanner::add_column (end_volta_span_p_,c);
}
if (Bar *c = dynamic_cast<Bar*> (i.elem_l_))
{
if (volta_span_p_)
- volta_span_p_->add_bar (c);
+ Volta_spanner::add_bar (volta_span_p_,c);
if (end_volta_span_p_)
- end_volta_span_p_ ->add_bar(c);
+ Volta_spanner::add_bar(end_volta_span_p_ , c);
}
}
{
if (end_volta_span_p_)
{
+ Side_position_interface (end_volta_span_p_).add_staff_support ();
+
typeset_element (end_volta_span_p_ );
end_volta_span_p_ =0;
}
#include "duration.hh"
Real
-Rest_collision::force_shift_callback (Score_element const*them, Axis a)
+Rest_collision::force_shift_callback (Score_element *them, Axis a)
{
assert (a == Y_AXIS);
if (rest_req_l_ && !rest_p_)
{
rest_p_ = new Rhythmic_head (get_property ("basicRestProperties"));
- Staff_symbol_referencer_interface si (rest_p_);
- si.set_interface ();
+ Staff_symbol_referencer_interface::set_interface (rest_p_);
+
rest_p_->set_elt_property ("duration-log",
gh_int2scm (rest_req_l_->duration_.durlog_i_));
{
dot_p_ = new Item (get_property ("basicDotsProperties"));
- Staff_symbol_referencer_interface si (dot_p_);
- si.set_interface ();
+ Staff_symbol_referencer_interface::set_interface (dot_p_);
+
rest_p_->set_dots (dot_p_);
dot_p_->set_parent (rest_p_, Y_AXIS);
Link_array<Slur> grace_slur_endings_;
Stem * stem_l_;
Note_column *ncol_p_;
- Dot_column *dotcol_l_;
+ Score_element *dotcol_l_;
protected:
VIRTUAL_COPY_CONS(Translator);
if (ncol_p_)
{
if (dotcol_l_
- && !dotcol_l_->parent_l(X_AXIS))
+ && !dotcol_l_->parent_l (X_AXIS))
{
ncol_p_->set_dotcol (dotcol_l_);
}
{
rhead_l_arr_.push (r);
}
- else if (Dot_column*d =dynamic_cast<Dot_column *> (item))
+ else if (item
+ && to_boolean (item->get_elt_property ("dot-column-interface")))
{
- dotcol_l_ = d;
+ dotcol_l_ = item;
}
else if (Slur *s = dynamic_cast<Slur*> (i.elem_l_))
{
#include "paper-column.hh"
#include "debug.hh"
#include "dimensions.hh"
-#include "single-malt-grouping-item.hh"
+#include "separation-item.hh"
Rod::Rod ()
do {
r.push (t);
t = t->daddy_trans_l_;
- } while (t != end->daddy_trans_l_);
+ } while (t && t != end->daddy_trans_l_);
return r;
}
Interval
-Score_element::molecule_extent (Score_element const *s, Axis a )
+Score_element::molecule_extent (Score_element *s, Axis a)
{
Molecule m = s->get_molecule ();
return m.extent(a);
}
Interval
-Score_element::preset_extent (Score_element const *s , Axis a )
+Score_element::preset_extent (Score_element *s , Axis a)
{
SCM ext = s->get_elt_property ((a == X_AXIS)
? "extent-X"
Interval
-Score_element::point_dimension_callback (Score_element const* , Axis)
+Score_element::point_dimension_callback (Score_element* , Axis)
{
return Interval (0,0);
}
}
else if (!d->valid_b_)
{
- d->dim_= (*d->extent_callback_l_ ) (this, a);
+ d->dim_= (*d->extent_callback_l_ ) ((Score_element*)this, a);
d->valid_b_ = true;
}
Score_engraver::prepare (Moment w)
{
Global_translator::prepare (w);
- set_columns (new Paper_column (w), new Paper_column (w));
+ SCM props = get_property (ly_symbol2scm ("basicPaperColumnProperties"));
+ set_columns (new Paper_column (props), new Paper_column (props));
+
+ SCM when = smobify (new Moment (w));
+ command_column_l_->set_elt_property ("when", when);
+ musical_column_l_->set_elt_property ("when", when);
command_column_l_->set_elt_property ("breakable", SCM_BOOL_T);
+
+ Score_element_info i1(command_column_l_, 0), i2 (musical_column_l_,0);
+
+ i1.origin_trans_l_ = this;
+ i2.origin_trans_l_ = this;
+ announce_element (i1);
+ announce_element (i2);
+
post_move_processing();
}
{
if (*current[i])
{
- scoreline_l_->add_column ((*current[i]));
+ scoreline_l_->add_column ((*current[i]));
if (!(*current[i])->used_b())
{
- /*
- We're forgetting about this column. Dump it, and make SCM
- forget it.
-
- FIXME: we should have another way of not putting this
- column into the spacing problem. Maybe we shouldn't
- even prevent this.
-
- */
- (*current[i])->suicide ();
+ (*current[i])->suicide ();
*current[i] =0;
}
}
#include "engraver.hh"
#include "script-column.hh"
+#include "item.hh"
#include "side-position-interface.hh"
-#include "dimension-cache.hh"
/**
Find potentially colliding scripts, and put them in a
Script_column, that will fix the collisions. */
class Script_column_engraver : public Engraver
{
- Script_column *scol_p_;
+ Score_element *scol_p_;
Link_array<Item> script_l_arr_;
public:
{
if (!scol_p_ && script_l_arr_.size () > 1)
{
- scol_p_ = new Script_column (SCM_EOL);
+ scol_p_ = new Item (get_property ("basicScriptColumnProperties"));
+ scol_p_->set_elt_pointer ("scripts", SCM_EOL);
+
announce_element (Score_element_info (scol_p_, 0));
}
if (scol_p_)
{
for (int i=0; i < script_l_arr_.size (); i++)
- scol_p_->add_staff_sided (script_l_arr_[i]);
+ Script_column::add_staff_sided (scol_p_, script_l_arr_[i]);
script_l_arr_.clear ();
}
}
#include "group-interface.hh"
void
-Script_column::add_staff_sided (Item *i)
+Script_column::add_staff_sided (Score_element *me, Item *i)
{
SCM p = i->get_elt_property ("script-priority");
if (!gh_number_p (p))
return;
-
- Pointer_group_interface gi (this, "scripts");
+ Pointer_group_interface gi (me, "scripts");
gi.add_element (i);
- add_dependency (i);
-}
-
-Script_column::Script_column (SCM s)
- : Item (s)
-{
- set_elt_pointer ("scripts", SCM_EOL);
+ me->add_dependency (i);
}
static int
-staff_side_compare (Item * const &i1,
- Item * const &i2)
+staff_side_compare (Score_element * const &i1,
+ Score_element * const &i2)
{
SCM p1 = i1->get_elt_property ("script-priority");
SCM p2 = i2->get_elt_property ("script-priority");
return gh_scm2int (p1) - gh_scm2int (p2);
}
-GLUE_SCORE_ELEMENT(Script_column,before_line_breaking);
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Script_column,before_line_breaking);
+
SCM
-Script_column::member_before_line_breaking ()
+Script_column::before_line_breaking (SCM smob)
{
- Drul_array<Link_array<Item> > arrs;
- Link_array<Item> staff_sided
- = Pointer_group_interface__extract_elements (this, (Item*)0, "scripts");
+ Score_element* me = unsmob_element (smob);
+ Drul_array<Link_array<Score_element> > arrs;
+ Link_array<Score_element> staff_sided
+ = Pointer_group_interface__extract_elements (me, (Score_element*)0, "scripts");
for (int i=0; i < staff_sided.size (); i++)
Direction d = DOWN;
do {
- Link_array<Item> &arr(arrs[d]);
+ Link_array<Score_element> &arr(arrs[d]);
arr.sort (staff_side_compare);
- Item * last = 0;
+ Score_element * last = 0;
for (int i=0; i < arr.size (); i++)
{
Side_position_interface s (arr[i]);
}
// todo -> use result of articulation-to-scriptdef directly as basic prop list.
Script *p =new Script (get_property ("basicScriptProperties"));
+
+ p->add_offset_callback (Side_position_interface::centered_on_parent, X_AXIS);
Side_position_interface stafy (p);
}
Molecule
-Script::get_molecule(Direction d) const
+Script::get_molecule(Score_element * me, Direction d)
{
- SCM s = get_elt_property ("molecule");
+ SCM s = me->get_elt_property ("molecule");
assert (gh_pair_p (s));
SCM key = gh_car (s);
if (key == ly_symbol2scm ("feta"))
{
- return lookup_l ()->afm_find ("scripts-" +
+ return me->lookup_l ()->afm_find ("scripts-" +
ly_scm2string (index_cell (gh_cdr (s), d)));
}
else if (key == ly_symbol2scm ("accordion"))
{
- return lookup_l ()->accordion (gh_cdr (s), paper_l()->get_var("interline"));
+ return me->lookup_l ()->accordion (gh_cdr (s), me->paper_l()->get_var("interline"));
}
-
- else assert (false);
+ else
+ assert (false);
return Molecule ();
}
-GLUE_SCORE_ELEMENT(Script,before_line_breaking);
-SCM
-Script::member_before_line_breaking ()
-{
- /*
- center my self on the note head.
- */
- Score_element * e = parent_l(X_AXIS);
- translate_axis (e->extent (X_AXIS).center (), X_AXIS);
- return SCM_UNDEFINED;
-}
GLUE_SCORE_ELEMENT(Script,after_line_breaking);
SCM
}
-GLUE_SCORE_ELEMENT(Script,brew_molecule);
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Script,brew_molecule);
SCM
-Script::member_brew_molecule () const
+Script::brew_molecule (SCM smob)
{
+ Score_element *me= unsmob_element (smob);
Direction dir = DOWN;
- SCM d = get_elt_property ("direction");
+ SCM d = me->get_elt_property ("direction");
if (isdir_b (d))
dir = to_dir (d);
- return get_molecule (dir).create_scheme();
+ return get_molecule (me, dir).create_scheme();
}
*/
#include "separating-group-spanner.hh"
-#include "single-malt-grouping-item.hh"
+#include "separation-item.hh"
#include "paper-column.hh"
#include "paper-def.hh"
#include "dimensions.hh"
#include "group-interface.hh"
static Rod
-make_rod (Single_malt_grouping_item *l, Single_malt_grouping_item *r)
+make_rod (Item *l, Item *r)
{
Rod rod;
- Interval li (l->my_width ());
- Interval ri (r->my_width ());
+ Interval li (Separation_item::my_width (l));
+ Interval ri (Separation_item::my_width (r));
rod.item_l_drul_[LEFT] =l;
rod.item_l_drul_[RIGHT]=r;
SCM elt = gh_cadr (s);
SCM next_elt = gh_car (s);
- Single_malt_grouping_item *l = dynamic_cast<Single_malt_grouping_item*> (unsmob_element (elt));
- Single_malt_grouping_item *r = dynamic_cast<Single_malt_grouping_item*> (unsmob_element ( next_elt));
+ Item *l = dynamic_cast<Item*> (unsmob_element (elt));
+ Item *r = dynamic_cast<Item*> (unsmob_element ( next_elt));
if (!r || !l)
continue;
- Single_malt_grouping_item *lb
- = dynamic_cast<Single_malt_grouping_item*>(l->find_prebroken_piece (RIGHT));
+ Item *lb
+ = dynamic_cast<Item*>(l->find_prebroken_piece (RIGHT));
- Single_malt_grouping_item *rb
- = dynamic_cast<Single_malt_grouping_item*>(r->find_prebroken_piece (LEFT));
+ Item *rb
+ = dynamic_cast<Item*>(r->find_prebroken_piece (LEFT));
a.push (make_rod(l, r));
if (lb)
}
void
-Separating_group_spanner::add_spacing_unit (Single_malt_grouping_item*i)
+Separating_group_spanner::add_spacing_unit (Item*i)
{
Pointer_group_interface (this, "elements").add_element (i);
add_dependency (i);
*/
-#include "separating-line-group-engraver.hh"
#include "separating-group-spanner.hh"
-#include "single-malt-grouping-item.hh"
+#include "separation-item.hh"
#include "paper-column.hh"
#include "paper-def.hh"
+#include "engraver.hh"
+
+class Separating_line_group_engraver : public Engraver
+{
+protected:
+ Item * break_malt_p_;
+ Item * nobreak_malt_p_;
+ Separating_group_spanner * sep_span_p_;
+
+ virtual void acknowledge_element (Score_element_info);
+ virtual void do_creation_processing ();
+ virtual void do_removal_processing ();
+ virtual void do_pre_move_processing ();
+public:
+ Separating_line_group_engraver ();
+ VIRTUAL_COPY_CONS (Translator);
+};
Separating_line_group_engraver::Separating_line_group_engraver ()
{
if (it && !it->parent_l (X_AXIS))
{
bool ib =it->breakable_b ();
- Single_malt_grouping_item *&p_ref_ (ib ? break_malt_p_
- : nobreak_malt_p_);
+ Item *&p_ref_ (ib ? break_malt_p_
+ : nobreak_malt_p_);
if (!p_ref_)
{
p_ref_
- = new Single_malt_grouping_item
+ = new Item
(get_property ("basicSingleMaltGroupingItemProperties"));
if (ib)
p_ref_->set_elt_property ("breakable", SCM_BOOL_T);
announce_element (Score_element_info (p_ref_, 0));
}
- p_ref_->add_item (it);
+ Separation_item::add_item (p_ref_,it);
}
}
--- /dev/null
+/*
+ single-malt-grouping-item.cc -- implement Separation_item
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1998--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+
+ */
+
+#include "separation-item.hh"
+#include "paper-column.hh"
+#include "debug.hh"
+#include "group-interface.hh"
+
+void
+Separation_item::set_interface (Score_element*s)
+{
+ s->set_elt_pointer ("elements", SCM_EOL);
+ s->set_extent_callback (0, X_AXIS);
+ s->set_extent_callback (0, Y_AXIS);
+}
+
+void
+Separation_item::add_item (Score_element*s,Item* i)
+{
+ assert (i);
+ Pointer_group_interface (s).add_element (i);
+ s->add_dependency (i);
+}
+
+Interval
+Separation_item::my_width (Score_element *me)
+{
+ Item *item = dynamic_cast<Item*> (me);
+ Paper_column * pc = item->column_l ();
+ Interval w;
+
+ for (SCM s = me->get_elt_pointer ("elements"); gh_pair_p (s); s = gh_cdr (s))
+ {
+ SCM elt = gh_car (s);
+ if (!SMOB_IS_TYPE_B(Score_element, elt))
+ continue;
+
+ Item *il = dynamic_cast<Item*> (unsmob_element (elt));
+ if (pc != il->column_l ())
+ {
+ /* this shouldn't happen, but let's continue anyway. */
+ programming_error (_("Separation_item: I've been drinking too much"));
+ continue; /*UGH UGH*/
+ }
+
+ if (to_boolean (il->get_elt_property ("no-spacing-rods")))
+ {
+ continue;
+ }
+
+ Interval iv (il->extent (X_AXIS));
+ if (!iv.empty_b ())
+ {
+ Real off = il->relative_coordinate (pc, X_AXIS);
+ w.unite (iv + off);
+ }
+ }
+
+ return w;
+ // add this->offset_ ? this-> relative_coordinate ()?
+}
+
+
+
*/
Real
-Side_position_interface::side_position (Score_element const *cme, Axis axis)
+Side_position_interface::side_position (Score_element *cme, Axis axis)
{
Score_element* me = (Score_element*)cme;
Score_element *common = me->parent_l (axis);
callback that centers the element on itself
*/
Real
-Side_position_interface::aligned_on_self (Score_element const*elm, Axis ax)
+Side_position_interface::aligned_on_self (Score_element *elm, Axis ax)
{
String s ("self-alignment-");
Callback that quantises in staff-spaces, rounding in the direction
of the elements "direction" elt property. */
Real
-Side_position_interface::quantised_position (Score_element const *me, Axis a)
+Side_position_interface::quantised_position (Score_element *me, Axis a)
{
Side_position_interface s(me);
Direction d = s.get_direction ();
- Staff_symbol_referencer_interface si (me);
- if (si.has_interface_b ())
+ if (Staff_symbol_referencer_interface::has_interface_b (me))
{
+ Staff_symbol_referencer_interface si (me);
Real p = si.position_f ();
Real rp = directed_round (p, d);
Position next to support, taking into account my own dimensions and padding.
*/
Real
-Side_position_interface::aligned_side (Score_element const*me, Axis ax)
+Side_position_interface::aligned_side (Score_element *me, Axis ax)
{
Side_position_interface s(me);
Direction d = s.get_direction ();
Position centered on parent.
*/
Real
-Side_position_interface::centered_on_parent (Score_element const* me, Axis a)
+Side_position_interface::centered_on_parent (Score_element * me, Axis a)
{
Score_element *him = me->parent_l (a);
+++ /dev/null
-/*
- single-malt-grouping-item.cc -- implement Single_malt_grouping_item
-
- source file of the GNU LilyPond music typesetter
-
- (c) 1998--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
-
- */
-
-#include "single-malt-grouping-item.hh"
-#include "paper-column.hh"
-#include "debug.hh"
-#include "group-interface.hh"
-
-Single_malt_grouping_item ::Single_malt_grouping_item(SCM s)
- : Item (s)
-{
- set_elt_pointer ("elements", SCM_EOL);
-
- // this is weird! , but needed!
- set_extent_callback (0, X_AXIS);
- set_extent_callback (0, Y_AXIS);
-
-}
-
-void
-Single_malt_grouping_item::add_item (Item* i)
-{
- assert (i);
- Pointer_group_interface (this).add_element (i);
-
- add_dependency (i);
-}
-
-Interval
-Single_malt_grouping_item::my_width () const
-{
- Paper_column * pc = column_l ();
- Interval w;
-
- for (SCM s = get_elt_pointer ("elements"); gh_pair_p (s); s = gh_cdr (s))
- {
- SCM elt = gh_car (s);
- if (!SMOB_IS_TYPE_B(Score_element, elt))
- continue;
-
- Item *il = dynamic_cast<Item*> (SMOB_TO_TYPE (Score_element, elt));
- if (pc != il->column_l ())
- {
- /* this shouldn't happen, but let's continue anyway. */
- programming_error (_("Single_malt_grouping_item: I've been drinking too much"));
- continue; /*UGH UGH*/
- }
-
- if (to_boolean (il->get_elt_property ("no-spacing-rods")))
- {
- continue;
- }
-
- Interval iv (il->extent (X_AXIS));
- if (!iv.empty_b ())
- {
- Real off = il->relative_coordinate (pc, X_AXIS);
- w.unite (iv + off);
- }
- }
-
- return w;
- // add this->offset_ ? this-> relative_coordinate ()?
-}
-
-
-
Interval
-Span_bar::width_callback (Score_element const *se, Axis )
+Span_bar::width_callback (Score_element *se, Axis )
{
Span_bar* s= dynamic_cast<Span_bar*> ((Score_element*)se);
String gl = ly_scm2string (s->get_elt_property ("glyph"));
Interval
Span_bar::get_spanned_interval () const
{
- return Axis_group_interface::group_extent_callback (this, Y_AXIS);
+ return Axis_group_interface::group_extent_callback ((Span_bar*)this, Y_AXIS);
}
}
void
-Staff_symbol_referencer_interface::set_interface ()
+Staff_symbol_referencer_interface::set_interface (Score_element * e)
{
- if (!gh_number_p (elt_l_->get_elt_property ("staff-position")))
- elt_l_->set_elt_property ("staff-position", gh_double2scm (0.0));
+ if (!gh_number_p (e->get_elt_property ("staff-position")))
+ e->set_elt_property ("staff-position", gh_double2scm (0.0));
- elt_l_->add_offset_callback (callback, Y_AXIS);
+ e->add_offset_callback (callback, Y_AXIS);
}
bool
-Staff_symbol_referencer_interface::has_interface_b ()
+Staff_symbol_referencer_interface::has_interface_b (Score_element*e)
{
- return unsmob_element (elt_l_->get_elt_pointer ("staff-symbol"))
- || gh_number_p (elt_l_->get_elt_property ("staff-position"));
+ return unsmob_element (e->get_elt_pointer ("staff-symbol"))
+ || gh_number_p (e->get_elt_property ("staff-position"));
}
should use offset callback!
*/
Real
-Staff_symbol_referencer_interface::callback (Score_element const* sc,Axis )
+Staff_symbol_referencer_interface::callback (Score_element * sc,Axis )
{
Score_element* me = (Score_element*)sc; // UGH.
private:
int default_tremolo_type_i_;
Stem *stem_p_;
- Stem_tremolo *tremolo_p_;
+ Score_element *tremolo_p_;
Rhythmic_req *rhythmic_req_l_;
Tremolo_req* tremolo_req_l_;
};
if (!stem_p_)
{
stem_p_ = new Stem (get_property ("basicStemProperties"));
- Staff_symbol_referencer_interface st(stem_p_);
- st.set_interface ();
+ Staff_symbol_referencer_interface::set_interface(stem_p_);
+
stem_p_->set_elt_property ("duration-log", gh_int2scm (duration_log));
if (requested_type)
{
- tremolo_p_ = new Stem_tremolo (get_property ("basicStemTremoloProperties"));
+ tremolo_p_ = new Item (get_property ("basicStemTremoloProperties"));
+ Stem_tremolo::set_interface (tremolo_p_);
+
announce_element (Score_element_info (tremolo_p_, tremolo_req_l_));
/*
The number of tremolo flags is the number of flags of
{
if (tremolo_p_)
{
- tremolo_p_->set_stem (stem_p_);
+ Stem_tremolo::set_stem (tremolo_p_, stem_p_);
typeset_element (tremolo_p_);
tremolo_p_ = 0;
}
lengthen stem if necessary
*/
-Stem_tremolo::Stem_tremolo (SCM s)
- : Item (s)
+void
+Stem_tremolo::set_interface (Score_element *me)
{
- set_elt_pointer ("stem", SCM_EOL);
+me->set_elt_pointer ("stem", SCM_EOL);
}
-Stem *
-Stem_tremolo::stem_l ()const
-{
- SCM s = get_elt_pointer ("stem");
-
- return dynamic_cast<Stem*> ( unsmob_element (s));
-}
-
Interval
Stem_tremolo::dim_callback (Score_element * se, Axis )
{
- Stem_tremolo * s = dynamic_cast<Stem_tremolo*> (se);
- Real space = Staff_symbol_referencer_interface (s->stem_l ())
- .staff_space ();
+ Real space = Staff_symbol_referencer_interface (se).staff_space ();
return Interval (-space, space);
}
-GLUE_SCORE_ELEMENT(Stem_tremolo,brew_molecule);
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Stem_tremolo,brew_molecule);
SCM
-Stem_tremolo::member_brew_molecule () const
+Stem_tremolo::brew_molecule (SCM smob)
{
- Stem * stem = stem_l ();
+ Score_element *me= unsmob_element (smob);
+ Stem * stem = dynamic_cast<Stem*> (unsmob_element (me->get_elt_pointer ("stem")));
Beam * beam = stem->beam_l ();
Real dydx;
dydx = 0.25;
Real ss = Staff_symbol_referencer_interface (stem).staff_space ();
- Real thick = gh_scm2double (get_elt_property ("beam-thickness"));
- Real width = gh_scm2double (get_elt_property ("beam-width"));
+ Real thick = gh_scm2double (me->get_elt_property ("beam-thickness"));
+ Real width = gh_scm2double (me->get_elt_property ("beam-width"));
width *= ss;
thick *= ss;
- Molecule a (lookup_l ()->beam (dydx, width, thick));
+ Molecule a (me->lookup_l ()->beam (dydx, width, thick));
a.translate (Offset (-width/2, width / 2 * dydx));
int tremolo_flags;
- SCM s = get_elt_property ("tremolo-flags");
+ SCM s = me->get_elt_property ("tremolo-flags");
if (gh_number_p (s))
tremolo_flags = gh_scm2int (s);
else
tremolo_flags = 1;
int mult = beam ? beam->get_multiplicity () : 0;
- Real interbeam_f = paper_l ()->interbeam_f (mult);
+ Real interbeam_f = me->paper_l ()->interbeam_f (mult);
Molecule mol;
for (int i = 0; i < tremolo_flags; i++)
{
{
// ugh, rather calc from Stem_tremolo_req
int beams_i = stem->beam_count(RIGHT) >? stem->beam_count (LEFT);
- mol.translate (Offset(stem->relative_coordinate (0, X_AXIS) - relative_coordinate (0, X_AXIS),
+ mol.translate (Offset(stem->relative_coordinate (0, X_AXIS) - me->relative_coordinate (0, X_AXIS),
stem->stem_end_position () * ss / 2 -
Directional_element_interface (beam).get () * beams_i * interbeam_f));
}
else
whole_note_correction = 0;
- mol.translate (Offset (stem->relative_coordinate (0, X_AXIS) - relative_coordinate (0, X_AXIS) +
+ mol.translate (Offset (stem->relative_coordinate (0, X_AXIS) - me->relative_coordinate (0, X_AXIS) +
whole_note_correction, dy));
}
void
-Stem_tremolo::set_stem (Stem *s)
+Stem_tremolo::set_stem (Score_element*me,Score_element *s)
{
- set_elt_pointer ("stem", s->self_scm_);
- add_dependency (s);
+ me->set_elt_pointer ("stem", s->self_scm_);
}
}
Interval
-Stem::dim_callback (Score_element const *se, Axis )
+Stem::dim_callback (Score_element *se, Axis )
{
Stem * s = dynamic_cast<Stem*> ((Score_element*)se);
}
Real
-Stem::off_callback (Score_element const* se, Axis)
+Stem::off_callback (Score_element * se, Axis)
{
Stem *st = dynamic_cast<Stem*> ((Score_element*)se);
return lookup_l ()->filledbox (Box (Interval(0,w), Interval(-h/2, h/2)));
}
-GLUE_SCORE_ELEMENT(System_start_delimiter,after_line_breaking);
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(System_start_delimiter,after_line_breaking);
+
SCM
-System_start_delimiter::member_after_line_breaking ()
+System_start_delimiter::after_line_breaking (SCM smob)
+{
+ try_collapse (unsmob_element (smob));
+ return SCM_UNDEFINED;
+}
+
+void
+System_start_delimiter::try_collapse (Score_element*me)
{
- SCM gl = get_elt_property ("glyph");
+ SCM gl = me->get_elt_property ("glyph");
- if (scm_ilength (get_elt_pointer ("elements")) <= 1 && gl == ly_symbol2scm ("bar-line"))
+ if (scm_ilength (me->get_elt_pointer ("elements")) <= 1 && gl == ly_symbol2scm ("bar-line"))
{
- suicide ();
+ me->suicide ();
}
- return SCM_UNDEFINED;
+
}
+
MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(System_start_delimiter,brew_molecule);
SCM
/*
- text-item.cc -- implement Item
+ text-item.cc -- implement Text_item
source file of the GNU LilyPond music typesetter
Tie_column::Tie_column (SCM s)
: Spanner (s)
{
- set_elt_pointer ("ties", SCM_EOL);
- set_extent_callback (0, X_AXIS);
- set_extent_callback (0, Y_AXIS);
+
+}
+void
+Tie_column::set_interface (Score_element*me)
+{
+ me-> set_elt_pointer ("ties", SCM_EOL);
+ me->set_extent_callback (0, X_AXIS);
+ me->set_extent_callback (0, Y_AXIS);
}
void
-Tie_column::add_tie (Tie *s)
+Tie_column::add_tie (Score_element*me,Tie *s)
{
- Pointer_group_interface g (this, "ties");
+ Pointer_group_interface g (me, "ties");
if (!g.count ())
{
- set_bound (LEFT, s->head (LEFT));
- set_bound (RIGHT, s->head (RIGHT));
+ dynamic_cast<Spanner*> (me)->set_bound (LEFT, Tie::head (s,LEFT));
+ dynamic_cast<Spanner*> (me)->set_bound (RIGHT, Tie::head (s,RIGHT));
}
- Pointer_group_interface (this, "ties").add_element (s);
- s->add_dependency (this);
+ Pointer_group_interface (me, "ties").add_element (s);
+ s->add_dependency (me);
}
tie_compare (Tie* const & s1,
Tie* const & s2)
{
- return sign (s1->position_f () - s2->position_f());
+ return sign (Tie::position_f (s1) - Tie::position_f(s2));
}
/*
direction of the rest is determined by their staff position.
Ross forgets about the tie that is *on* the middle staff line. We
- assume it goes UP. (TODO: make this settable) */
+ assume it goes UP. (TODO: make me settable) */
void
-Tie_column::set_directions ()
+Tie_column::set_directions (Score_element*me)
{
Link_array<Tie> ties =
- Pointer_group_interface__extract_elements (this, (Tie*)0, "ties");
+ Pointer_group_interface__extract_elements (me, (Tie*)0, "ties");
- Direction d = Directional_element_interface (this).get ();
+ Direction d = Directional_element_interface (me).get ();
if (d)
{
if (ties.size () == 1)
{
Tie * t = ties[0];
- Directional_element_interface (t).set (t->get_default_dir ());
+ Directional_element_interface (t).set (Tie::get_default_dir (t));
return;
}
for (int i=ties.size(); i--; )
{
Tie * t = ties[i];
- Real p = t->position_f ();
+ Real p = Tie::position_f (t);
Direction d = (Direction) sign (p);
if (!d)
d = UP;
}
-GLUE_SCORE_ELEMENT(Tie_column,after_line_breaking);
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Tie_column,after_line_breaking);
SCM
-Tie_column::member_after_line_breaking ()
+Tie_column::after_line_breaking (SCM smob)
{
- set_directions ();
+ set_directions (unsmob_element (smob));
return SCM_UNDEFINED;
}
virtual bool do_try_music (Music*);
virtual void do_process_music ();
virtual void process_acknowledged ();
-
+ void typeset_tie (Score_element*);
public:
VIRTUAL_COPY_CONS(Translator);
Tie_engraver();
SCM pair = gh_list_ref (head_list, gh_int2scm (i/2));
Tie * p = new Tie (basic);
- p->set_head (LEFT, dynamic_cast<Item*> (unsmob_element (gh_car (pair))));
- p->set_head (RIGHT, dynamic_cast<Item*> (unsmob_element (gh_cdr (pair))));
+ Tie::set_head (p,LEFT, dynamic_cast<Item*> (unsmob_element (gh_car (pair))));
+ Tie::set_head (p,RIGHT, dynamic_cast<Item*> (unsmob_element (gh_cdr (pair))));
tie_p_arr_.push (p);
announce_element (Score_element_info (p, req_l_));
else for (SCM s = head_list; gh_pair_p (s); s = gh_cdr (s))
{
Tie * p = new Tie (basic);
- p->set_head (LEFT, dynamic_cast<Item*> (unsmob_element (gh_caar (s))));
- p->set_head (RIGHT, dynamic_cast<Item*> (unsmob_element (gh_cdar (s))));
+ Tie::set_interface (p);
+
+ Tie::set_head (p, LEFT, dynamic_cast<Item*> (unsmob_element (gh_caar (s))));
+ Tie::set_head (p, RIGHT, dynamic_cast<Item*> (unsmob_element (gh_cdar (s))));
tie_p_arr_.push (p);
announce_element (Score_element_info (p, req_l_));
else if (tie_p_arr_.size () > 1 && !tie_column_p_)
{
tie_column_p_ = new Tie_column (get_property ("basicTieColumnProperties"));
+ Tie_column::set_interface (tie_column_p_);
for (int i = tie_p_arr_.size (); i--; )
- tie_column_p_->add_tie (tie_p_arr_ [i]);
+ Tie_column::add_tie (tie_column_p_,tie_p_arr_ [i]);
announce_element (Score_element_info (tie_column_p_, 0));
}
}
for (int i=0; i< tie_p_arr_.size (); i++)
{
- typeset_element (tie_p_arr_[i]);
+ typeset_tie (tie_p_arr_[i]);
}
tie_p_arr_.clear ();
if (tie_column_p_)
{
- typeset_element (tie_column_p_);
+ typeset_tie (tie_column_p_);
tie_column_p_ =0;
}
}
+void
+Tie_engraver::typeset_tie (Score_element *her)
+{
+ if (!(Tie::head (her,LEFT) && Tie::head (her,RIGHT)))
+ warning (_ ("lonely tie"));
+
+ Direction d = LEFT;
+ Drul_array<Item *> new_head_drul;
+ new_head_drul[LEFT] = Tie::head(her,LEFT);
+ new_head_drul[RIGHT] = Tie::head (her,RIGHT);
+ do {
+ if (!Tie::head (her,d))
+ new_head_drul[d] = Tie::head(her,(Direction)-d);
+ } while (flip(&d) != LEFT);
+
+ index_set_cell (her->get_elt_pointer ("heads"), LEFT, new_head_drul[LEFT]->self_scm_ );
+ index_set_cell (her->get_elt_pointer ("heads"), RIGHT, new_head_drul[RIGHT]->self_scm_ );
+
+ typeset_element (her);
+}
+
void
Tie_engraver::do_post_move_processing ()
{
#include "stem.hh"
void
-Tie::set_head (Direction d, Item * head_l)
+Tie::set_head (Score_element*me,Direction d, Item * head_l)
{
- assert (!head (d));
- index_set_cell (get_elt_pointer ("heads"), d, head_l->self_scm_);
+ assert (!head (me,d));
+ index_set_cell (me->get_elt_pointer ("heads"), d, head_l->self_scm_);
- set_bound (d, head_l);
- add_dependency (head_l);
+ dynamic_cast<Spanner*> (me)->set_bound (d, head_l);
+ me->add_dependency (head_l);
}
Tie::Tie(SCM s)
: Spanner (s)
{
- set_elt_pointer ("heads", gh_cons (SCM_EOL, SCM_EOL));
dy_f_drul_[LEFT] = dy_f_drul_[RIGHT] = 0.0;
dx_f_drul_[LEFT] = dx_f_drul_[RIGHT] = 0.0;
-
+}
+void
+Tie::set_interface (Score_element*me)
+{
+ me->set_elt_pointer ("heads", gh_cons (SCM_EOL, SCM_EOL));
}
Rhythmic_head*
-Tie::head (Direction d) const
+Tie::head (Score_element*me, Direction d)
{
- SCM c = get_elt_pointer ("heads");
+ SCM c = me->get_elt_pointer ("heads");
c = index_cell (c, d);
return dynamic_cast<Rhythmic_head*> (unsmob_element (c));
}
Real
-Tie::position_f () const
+Tie::position_f (Score_element*me)
{
- return head (LEFT)
- ? Staff_symbol_referencer_interface (head (LEFT)).position_f ()
- : Staff_symbol_referencer_interface (head (RIGHT)).position_f () ;
+ return head (me,LEFT)
+ ? Staff_symbol_referencer_interface (head (me,LEFT)).position_f ()
+ : Staff_symbol_referencer_interface (head (me,RIGHT)).position_f () ;
}
ugh: direction of the Tie is more complicated. See [Ross] p136 and further
*/
Direction
-Tie::get_default_dir () const
+Tie::get_default_dir (Score_element*me)
{
- Stem * sl = head(LEFT) ? head (LEFT)->stem_l () :0;
- Stem * sr = head(RIGHT) ? head (RIGHT)->stem_l () :0;
+ Stem * sl = head(me,LEFT) ? head (me,LEFT)->stem_l () :0;
+ Stem * sr = head(me,RIGHT) ? head (me,RIGHT)->stem_l () :0;
if (sl && Directional_element_interface (sl).get () == UP
&& sr && Directional_element_interface (sr).get () == UP)
return UP;
}
-/*
- fixme must use spanned drul from heads elt property
- */
-void
-Tie::do_add_processing()
-{
- if (!(head (LEFT) && head (RIGHT)))
- warning (_ ("lonely tie"));
-
- Direction d = LEFT;
- Drul_array<Rhythmic_head *> new_head_drul;
- new_head_drul[LEFT] = head(LEFT);
- new_head_drul[RIGHT] = head(RIGHT);
- do {
- if (!head (d))
- new_head_drul[d] = head((Direction)-d);
- } while (flip(&d) != LEFT);
-
- index_set_cell (get_elt_pointer ("heads"), LEFT, new_head_drul[LEFT]->self_scm_ );
- index_set_cell (get_elt_pointer ("heads"), RIGHT, new_head_drul[RIGHT]->self_scm_ );
-}
-GLUE_SCORE_ELEMENT(Tie,after_line_breaking);
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Tie,after_line_breaking);
SCM
-Tie::member_after_line_breaking ()
+Tie::after_line_breaking (SCM smob)
{
- if (!head (LEFT) && !head (RIGHT))
+ Tie*me = dynamic_cast<Tie*> (unsmob_element (smob));
+
+ if (!head (me,LEFT) && !head (me,RIGHT))
{
programming_error ("Tie without heads.");
- suicide ();
+ me->suicide ();
return SCM_UNDEFINED;
}
- if (!Directional_element_interface (this).get ())
- Directional_element_interface (this).set (get_default_dir ());
+ if (!Directional_element_interface (me).get ())
+ Directional_element_interface (me).set (Tie::get_default_dir (me));
- Real staff_space = Staff_symbol_referencer_interface (this).staff_space ();
+ Real staff_space = Staff_symbol_referencer_interface (me).staff_space ();
Real half_space = staff_space / 2;
- Real x_gap_f = paper_l ()->get_var ("tie_x_gap");
- Real y_gap_f = paper_l ()->get_var ("tie_y_gap");
+ Real x_gap_f = me->paper_l ()->get_var ("tie_x_gap");
+ Real y_gap_f = me->paper_l ()->get_var ("tie_y_gap");
/*
Slur and tie placement [OSU]
/*
- OSU: not different for outer notes, so why all this code?
- ie, can we drop this, or should it be made switchable.
+ OSU: not different for outer notes, so why all me code?
+ ie, can we drop me, or should it be made switchable.
*/
- if (head (LEFT))
- dx_f_drul_[LEFT] = head (LEFT)->extent (X_AXIS).length ();
+ if (head (me,LEFT))
+ me->dx_f_drul_[LEFT] = Tie::head (me,LEFT)->extent (X_AXIS).length ();
else
- dx_f_drul_[LEFT] = get_broken_left_end_align ();
- dx_f_drul_[LEFT] += x_gap_f;
- dx_f_drul_[RIGHT] -= x_gap_f;
+ me->dx_f_drul_[LEFT] = dynamic_cast<Spanner*>(me)->get_broken_left_end_align ();
+ me->dx_f_drul_[LEFT] += x_gap_f;
+ me->dx_f_drul_[RIGHT] -= x_gap_f;
/*
- Slur and tie placement [OSU] -- check this
+ Slur and tie placement [OSU] -- check me
Ties:
*/
- Real ypos = position_f ();
+ Real ypos = Tie::position_f (me);
Real y_f = half_space * ypos;
int ypos_i = int (ypos);
- Real dx_f = extent (X_AXIS).length () + dx_f_drul_[RIGHT] - dx_f_drul_[LEFT];
- Direction dir = Directional_element_interface (this).get();
- if (dx_f < paper_l ()->get_var ("tie_staffspace_length"))
+ Real dx_f = me->extent (X_AXIS).length () + me->dx_f_drul_[RIGHT] - me->dx_f_drul_[LEFT];
+ Direction dir = Directional_element_interface (me).get();
+ if (dx_f < me->paper_l ()->get_var ("tie_staffspace_length"))
{
if (abs (ypos_i) % 2)
y_f += dir * half_space;
y_f -= dir * y_gap_f;
}
- dy_f_drul_[LEFT] = dy_f_drul_[RIGHT] = y_f;
+ me->dy_f_drul_[LEFT] = me->dy_f_drul_[RIGHT] = y_f;
return SCM_UNDEFINED;
}
return a;
}
-GLUE_SCORE_ELEMENT(Tie,brew_molecule);
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Tie,brew_molecule);
SCM
-Tie::member_brew_molecule () const
+Tie::brew_molecule (SCM smob)
{
- Real thick = paper_l ()->get_var ("tie_thickness");
- Bezier one = get_curve ();
+ Score_element*me = unsmob_element (smob);
+ Real thick = me->paper_l ()->get_var ("tie_thickness");
+ Bezier one = dynamic_cast<Tie*> (me)->get_curve ();
Molecule a;
- SCM d = get_elt_property ("dashed");
+ SCM d = me->get_elt_property ("dashed");
if (gh_number_p (d))
- a = lookup_l ()->dashed_slur (one, thick, gh_scm2int (d));
+ a = me->lookup_l ()->dashed_slur (one, thick, gh_scm2int (d));
else
- a = lookup_l ()->slur (one, Directional_element_interface (this).get () * thick, thick);
+ a = me->lookup_l ()->slur (one, Directional_element_interface (me).get () * thick, thick);
return a.create_scheme();
}
Bezier
Tie::get_curve () const
{
- Direction d (Directional_element_interface (this).get ());
+ Score_element*me = (Score_element*)this;
+ Direction d (Directional_element_interface (me).get ());
Bezier_bow b (get_encompass_offset_arr (), d);
- Real staff_space = Staff_symbol_referencer_interface (this).staff_space ();
+ Real staff_space = Staff_symbol_referencer_interface (me).staff_space ();
Real h_inf = paper_l ()->get_var ("tie_height_limit_factor") * staff_space;
Real r_0 = paper_l ()->get_var ("tie_ratio");
b.set_default_bezier (h_inf, r_0);
Bezier c = b.get_bezier ();
- /* should do this for slurs as well. */
+ /* should do me for slurs as well. */
Array<Real> horizontal (c.solve_derivative (Offset (1,0)));
if (horizontal.size ())
(c) 1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
*/
-#include "time-signature-engraver.hh"
#include "time-signature.hh"
#include "command-request.hh"
+#include "engraver.hh"
+
#include "timing-engraver.hh"
#include "engraver-group-engraver.hh"
+
+/**
+ generate time_signatures.
+ */
+class Time_signature_engraver : public Engraver {
+protected:
+ virtual void do_process_music();
+ virtual void do_pre_move_processing();
+public:
+ VIRTUAL_COPY_CONS(Translator);
+ Item * time_signature_p_;
+
+ Time_signature_engraver();
+};
+
+
Time_signature_engraver::Time_signature_engraver()
{
time_signature_p_ =0;
void
Time_signature_engraver::do_process_music()
{
+ /*
+ UGH.
+ this should use properties.
+ */
Translator * result =
daddy_grav_l()->get_simple_translator ("Timing_engraver"); // ugh
Time_signature_change_req *req = timing_grav_l->time_signature_req_l();
if (req)
{
- time_signature_p_ = new Time_signature (get_property ("basicTimeSignatureProperties"));
-
+ time_signature_p_ = new Item (get_property ("basicTimeSignatureProperties"));
time_signature_p_->set_elt_property ("fraction",
gh_cons (gh_int2scm (req->beats_i_),
gh_int2scm (req->one_beat_i_)));
#include "paper-def.hh"
#include "lookup.hh"
-Time_signature::Time_signature (SCM s)
- : Item (s)
-{
-
-}
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Time_signature,brew_molecule);
-// ugh.!
-
-GLUE_SCORE_ELEMENT(Time_signature,brew_molecule);
SCM
-Time_signature::member_brew_molecule () const
+Time_signature::brew_molecule (SCM smob)
{
- SCM st = get_elt_property ("style");
-
- SCM frac = get_elt_property ("fraction");
+ Score_element * me = unsmob_element (smob);
+ SCM st = me->get_elt_property ("style");
+ SCM frac = me->get_elt_property ("fraction");
int n = 4;
int d = 4;
if (gh_pair_p (frac))
String style (ly_scm2string (st));
if (style[0]=='1')
{
- return time_signature (n, 0).create_scheme();
+ return time_signature (me, n, 0).create_scheme();
}
else
{
- return special_time_signature (style, n, d).create_scheme();
+ return special_time_signature (me, style, n, d).create_scheme();
}
}
else
- return time_signature (n,d).create_scheme();
+ return time_signature (me, n,d).create_scheme();
}
Molecule
-Time_signature::special_time_signature (String s, int n, int d) const
+Time_signature::special_time_signature (Score_element*me, String s, int n, int d)
{
// First guess: s contains only the signature style
String symbolname = "timesig-" + s + to_str (n) + "/" + to_str (d);
- Molecule m = lookup_l ()->afm_find (symbolname, false);
+ Molecule m = me->lookup_l ()->afm_find (symbolname, false);
if (!m.empty_b())
return m;
// Second guess: s contains the full signature name
- m = lookup_l ()->afm_find ("timesig-"+s, false);
+ m = me->lookup_l ()->afm_find ("timesig-"+s, false);
if (!m.empty_b ())
return m;
// Resort to default layout with numbers
- return time_signature (n,d);
+ return time_signature (me, n,d);
}
Molecule
-Time_signature::time_signature (int num, int den) const
+Time_signature::time_signature (Score_element*me,int num, int den)
{
String sty = "timesig";
/*
UGH: need to look at fontsize.
*/
- Molecule n (lookup_l ()->text (sty, to_str (num), paper_l ()));
- Molecule d (lookup_l ()->text (sty, to_str (den), paper_l ()));
+ Molecule n (me->lookup_l ()->text (sty, to_str (num), me->paper_l ()));
+ Molecule d (me->lookup_l ()->text (sty, to_str (den), me->paper_l ()));
n.align_to (X_AXIS, CENTER);
d.align_to (X_AXIS, CENTER);
Molecule m;
Array<Moment> span_stop_moments_;
/// The spanners. Array order is synced with time_scaled_music_arr_
- Link_array<Tuplet_spanner> started_span_p_arr_;
+ Link_array<Spanner> started_span_p_arr_;
virtual void do_removal_processing ();
virtual void acknowledge_element (Score_element_info);
if (i < started_span_p_arr_.size () && started_span_p_arr_[i])
continue;
- Tuplet_spanner* glep = new Tuplet_spanner (get_property ("basicTupletSpannerProperties"));
+ Spanner* glep = new Spanner (get_property ("basicTupletSpannerProperties"));
+ Tuplet_spanner::set_interface (glep);
if (i >= started_span_p_arr_.size ())
started_span_p_arr_.push (glep);
else
{
for (int j =0; j <started_span_p_arr_.size (); j++)
if (started_span_p_arr_[j])
- started_span_p_arr_[j]->add_column (nc);
+ Tuplet_spanner::add_column (started_span_p_arr_[j],nc);
}
else if (Beam *b = dynamic_cast<Beam *> (i.elem_l_))
{
for (int j = 0; j < started_span_p_arr_.size (); j++)
if (started_span_p_arr_[j])
- started_span_p_arr_[j]->add_beam (b);
+ Tuplet_spanner::add_beam (started_span_p_arr_[j],b);
}
}
#include "directional-element-interface.hh"
-Tuplet_spanner::Tuplet_spanner (SCM s)
- : Spanner (s)
-{
- set_elt_pointer ("beams", SCM_EOL);
- set_elt_pointer ("columns", SCM_EOL);
- // ugh.
- set_elt_property ("delta-y", gh_int2scm (0));
+void
+Tuplet_spanner::set_interface (Score_element*me)
+{
+ me-> set_elt_pointer ("beams", SCM_EOL);
+ me->set_elt_pointer ("columns", SCM_EOL);
}
/*
TODO.
*/
-GLUE_SCORE_ELEMENT(Tuplet_spanner,brew_molecule);
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Tuplet_spanner,brew_molecule);
+
SCM
-Tuplet_spanner::member_brew_molecule () const
+Tuplet_spanner::brew_molecule (SCM smob)
{
+ Score_element *me= unsmob_element (smob);
Molecule mol;
// Default behaviour: number always, bracket when no beam!
- bool par_beam = to_boolean (get_elt_property ("parallel-beam"));
+ bool par_beam = to_boolean (me->get_elt_property ("parallel-beam"));
bool bracket_visibility = !par_beam;
bool number_visibility = true;
- SCM bracket = get_elt_property ("tuplet-bracket-visibility");
+ SCM bracket = me->get_elt_property ("tuplet-bracket-visibility");
if (gh_boolean_p (bracket))
{
bracket_visibility = gh_scm2bool (bracket);
else if (bracket == ly_symbol2scm ("if-no-beam"))
bracket_visibility = !par_beam;
- SCM numb = get_elt_property ("tuplet-number-visibility");
+ SCM numb = me->get_elt_property ("tuplet-number-visibility");
if (gh_boolean_p (numb))
{
number_visibility = gh_scm2bool (numb);
else if (bracket == ly_symbol2scm ("if-no-beam"))
number_visibility = !par_beam;
- if (gh_pair_p (get_elt_pointer ("columns")))
+ if (gh_pair_p (me->get_elt_pointer ("columns")))
{
Link_array<Note_column> column_arr=
- Pointer_group_interface__extract_elements (this, (Note_column*)0, "columns");
+ Pointer_group_interface__extract_elements (me, (Note_column*)0, "columns");
Real ncw = column_arr.top ()->extent(X_AXIS).length ();
- Real w = spanner_length () + ncw;
+ Real w = dynamic_cast<Spanner*>(me)->spanner_length () + ncw;
-
- Real staff_space = paper_l ()->get_var ("interline");
- Direction dir = Directional_element_interface (this).get ();
- Real dy = gh_scm2double (get_elt_property ("delta-y"));
- SCM number = get_elt_property ("text");
+ Real staff_space = me->paper_l ()->get_var ("interline");
+ Direction dir = Directional_element_interface (me).get ();
+ Real dy = gh_scm2double (me->get_elt_property ("delta-y"));
+ SCM number = me->get_elt_property ("text");
if (gh_string_p (number) && number_visibility)
{
Molecule
- num (lookup_l ()->text ("italic",
- ly_scm2string (number), paper_l ()));
+ num (me->lookup_l ()->text ("italic",
+ ly_scm2string (number), me->paper_l ()));
num.align_to (X_AXIS, CENTER);
num.translate_axis (w/2, X_AXIS);
num.align_to (Y_AXIS, CENTER);
if (bracket_visibility)
{
- SCM ss = paper_l ()->get_scmvar ("staffspace");
- SCM lt = paper_l ()->get_scmvar ("stafflinethickness");
+ SCM ss = me->paper_l ()->get_scmvar ("staffspace");
+ SCM lt = me->paper_l ()->get_scmvar ("stafflinethickness");
- SCM thick = get_elt_property ("thick");
- SCM gap = get_elt_property ("number-gap");
+ SCM thick = me->get_elt_property ("thick");
+ SCM gap = me->get_elt_property ("number-gap");
SCM at =gh_list(ly_symbol2scm ("tuplet"),
ss,
use first -> last note for slope, and then correct for disturbing
notes in between. */
void
-Tuplet_spanner::calc_position_and_height (Real *offset, Real * dy) const
+Tuplet_spanner::calc_position_and_height (Score_element*me,Real *offset, Real * dy)
{
Link_array<Note_column> column_arr=
- Pointer_group_interface__extract_elements (this, (Note_column*)0, "columns");
+ Pointer_group_interface__extract_elements (me, (Note_column*)0, "columns");
- Score_element * common = common_refpoint (get_elt_pointer ("columns"), Y_AXIS);
+ Score_element * common = me->common_refpoint (me->get_elt_pointer ("columns"), Y_AXIS);
- Direction d = Directional_element_interface (this).get ();
+ Direction d = Directional_element_interface (me).get ();
/*
Use outer non-rest columns to determine slope
use first -> last note for slope,
*/
void
-Tuplet_spanner::calc_dy (Real * dy) const
+Tuplet_spanner::calc_dy (Score_element*me,Real * dy)
{
Link_array<Note_column> column_arr=
- Pointer_group_interface__extract_elements (this, (Note_column*)0, "columns");
+ Pointer_group_interface__extract_elements (me, (Note_column*)0, "columns");
- Direction d = Directional_element_interface (this).get ();
+ Direction d = Directional_element_interface (me).get ();
*dy = column_arr.top ()->extent (Y_AXIS) [d]
- column_arr[0]->extent (Y_AXIS) [d];
}
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Tuplet_spanner,after_line_breaking);
-GLUE_SCORE_ELEMENT(Tuplet_spanner,after_line_breaking);
SCM
-Tuplet_spanner::member_after_line_breaking ()
+Tuplet_spanner::after_line_breaking (SCM smob)
{
+ Score_element * me = unsmob_element (smob);
Link_array<Note_column> column_arr=
- Pointer_group_interface__extract_elements (this, (Note_column*)0, "columns");
+ Pointer_group_interface__extract_elements (me, (Note_column*)0, "columns");
+ Spanner *sp = dynamic_cast<Spanner*> (me);
+
if (!column_arr.size ())
{
- suicide ();
+ me->suicide ();
return SCM_UNDEFINED;
}
- Direction d = Directional_element_interface (this).get ();
+ Direction d = Directional_element_interface (me).get ();
if (!d)
{
- d = get_default_dir ();
- Directional_element_interface (this).set (d);
+ d = Tuplet_spanner::get_default_dir (me);
+ Directional_element_interface (me).set (d);
}
Real dy, offset;
- calc_position_and_height (&offset,&dy);
+ calc_position_and_height (me,&offset,&dy);
- set_elt_property ("delta-y", gh_double2scm (dy));
+ me->set_elt_property ("delta-y", gh_double2scm (dy));
- translate_axis (offset, Y_AXIS);
+ me->translate_axis (offset, Y_AXIS);
- if (scm_ilength (get_elt_pointer ("beams")) == 1)
+ if (scm_ilength (me->get_elt_pointer ("beams")) == 1)
{
- SCM bs = get_elt_pointer ("beams");
+ SCM bs = me->get_elt_pointer ("beams");
Score_element *b = unsmob_element (gh_car (bs));
Beam * beam_l = dynamic_cast<Beam*> (b);
- if (!broken_b ()
- && get_bound (LEFT)->column_l () == beam_l->get_bound (LEFT)->column_l ()
- && get_bound (RIGHT)->column_l () == beam_l->get_bound (RIGHT)->column_l ())
- set_elt_property ("parallel-beam", SCM_BOOL_T);
+ if (!sp->broken_b ()
+ && sp->get_bound (LEFT)->column_l () == beam_l->get_bound (LEFT)->column_l ()
+ && sp->get_bound (RIGHT)->column_l () == beam_l->get_bound (RIGHT)->column_l ())
+ me->set_elt_property ("parallel-beam", SCM_BOOL_T);
}
return SCM_UNDEFINED;
}
Direction
-Tuplet_spanner::get_default_dir () const
+Tuplet_spanner::get_default_dir (Score_element*me)
{
Direction d = UP;
- SCM dir_sym =get_elt_property ("dir-forced");
+ SCM dir_sym =me->get_elt_property ("dir-forced");
if (isdir_b (dir_sym))
{
d= to_dir (dir_sym);
}
d = UP ;
- for (SCM s = get_elt_pointer ("columns"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = me->get_elt_pointer ("columns"); gh_pair_p (s); s = gh_cdr (s))
{
Score_element * sc = unsmob_element (gh_car (s));
Note_column * nc = dynamic_cast<Note_column*> (sc);
}
void
-Tuplet_spanner::add_beam (Beam *b)
+Tuplet_spanner::add_beam (Score_element*me, Score_element *b)
{
- add_dependency (b);
- Pointer_group_interface gi (this, "beams");
+me->add_dependency (b);
+ Pointer_group_interface gi (me, "beams");
gi.add_element (b);
}
void
-Tuplet_spanner::add_column (Note_column*n)
+Tuplet_spanner::add_column (Score_element*me, Item*n)
{
- Pointer_group_interface gi (this, "columns");
+ Pointer_group_interface gi (me, "columns");
gi.add_element (n);
+ me->add_dependency (n);
- add_dependency (n);
-
- add_bound_item (this, n);
+ add_bound_item (dynamic_cast<Spanner*> (me), n);
}
#include "debug.hh"
#include "lookup.hh"
#include "molecule.hh"
-#include "note-column.hh"
#include "paper-column.hh"
#include "bar.hh"
#include "paper-def.hh"
#include "volta-spanner.hh"
-#include "stem.hh"
-#include "dimension-cache.hh"
#include "group-interface.hh"
#include "side-position-interface.hh"
#include "directional-element-interface.hh"
-Volta_spanner::Volta_spanner (SCM s)
- : Spanner (s)
+
+void
+Volta_spanner::set_interface (Score_element*me)
{
- set_elt_pointer ("bars", SCM_EOL);
- Side_position_interface (this).set_axis (Y_AXIS);
- Directional_element_interface (this).set (UP);
+ me->set_elt_pointer ("bars", SCM_EOL);
+ Side_position_interface (me).set_axis (Y_AXIS);
+ Directional_element_interface (me).set (UP);
}
/*
- this is too complicated. Yet another version of side-positioning,
+ me is too complicated. Yet another version of side-positioning,
badly implemented.
--
*/
-GLUE_SCORE_ELEMENT(Volta_spanner,brew_molecule);
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Volta_spanner,brew_molecule);
SCM
-Volta_spanner::member_brew_molecule () const
+Volta_spanner::brew_molecule (SCM smob)
{
-
+ Score_element *me = unsmob_element (smob);
Link_array<Bar> bar_arr
- = Pointer_group_interface__extract_elements (this, (Bar*)0, "bars");
+ = Pointer_group_interface__extract_elements (me, (Bar*)0, "bars");
if (!bar_arr.size ())
return SCM_EOL;
bool no_vertical_start = false;
- bool no_vertical_end = to_boolean (get_elt_property ("last-volta"));
- Spanner *orig_span = dynamic_cast<Spanner*> (original_l_);
- if (orig_span && (orig_span->broken_into_l_arr_[0] != (Spanner*)this))
+ bool no_vertical_end = to_boolean (me->get_elt_property ("last-volta"));
+ Spanner *orig_span = dynamic_cast<Spanner*> (me->original_l_);
+ if (orig_span && (orig_span->broken_into_l_arr_[0] != (Spanner*)me))
no_vertical_start = true;
- if (orig_span && (orig_span->broken_into_l_arr_.top () != (Spanner*)this))
+ if (orig_span && (orig_span->broken_into_l_arr_.top () != (Spanner*)me))
no_vertical_end = true;
#if 0
// FIXME
- if (bar_arr.top ()->get_elt_property (type_str_.length_i () > 1)
+ if (bar_arr.top ()->me->get_elt_property (type_str_.length_i () > 1)
no_vertical_end = false;
#endif
- Real staff_space = paper_l ()->get_var ("interline");
+ Real staff_space = me->paper_l ()->get_var ("interline");
Real half_space = staff_space / 2;
- Real left = get_broken_left_end_align ();
- Real w = spanner_length () - left - half_space;
- Real h = paper_l()->get_var ("volta_spanner_height");
- Real t = paper_l ()->get_var ("volta_thick");
+ Real left = dynamic_cast<Spanner*>(me)->get_broken_left_end_align ();
+ Real w = dynamic_cast<Spanner*>(me)->spanner_length () - left - half_space;
+ Real h = me->paper_l()->get_var ("volta_spanner_height");
+ Real t = me->paper_l ()->get_var ("volta_thick");
SCM at = (gh_list (ly_symbol2scm ("volta"),
gh_double2scm (h),
Box b (Interval (0, w), Interval (0, h));
Molecule mol (b, at);
- Molecule num (lookup_l ()->text ("volta",
- ly_scm2string (get_elt_property("text")),
- paper_l ()));
+ Molecule num (me->lookup_l ()->text ("volta",
+ ly_scm2string (me->get_elt_property("text")),
+ me->paper_l ()));
mol.add_at_edge (X_AXIS, LEFT, num, - num.extent (X_AXIS).length ()
- staff_space);
}
-GLUE_SCORE_ELEMENT(Volta_spanner,after_line_breaking);
-SCM
-Volta_spanner::member_after_line_breaking ()
-{
- Side_position_interface (this).add_staff_support ();
- return SCM_UNDEFINED;
-}
-
void
-Volta_spanner::add_bar (Bar* b)
+Volta_spanner::add_bar (Score_element *me, Item* b)
{
- Pointer_group_interface gi(this, "bars");
+ Pointer_group_interface gi(me, "bars");
gi.add_element (b);
- Side_position_interface (this).add_support (b);
- add_dependency (b);
-
- add_bound_item (this, b);
+ Side_position_interface (me).add_support (b);
+ add_bound_item (dynamic_cast<Spanner*>(me), b);
}
void
-Volta_spanner::add_column (Note_column* c)
+Volta_spanner::add_column (Score_element*me, Score_element* c)
{
- Side_position_interface (this).add_support (c);
- add_dependency (c);
+ Side_position_interface (me).add_support (c);
}
(thin-kern . 3.0)
(hair-thickness . 1.6)
(thick-thickness . 6.0)
+ (bar-interface . #t)
)
basicBarNumberProperties = #`(
basicBreathingSignProperties = #`(
(break-align-symbol . Breathing_sign)
- (after-line-breaking-callback . ,Breathing_sign::after_line_breaking)
(breakable . #t )
(molecule-callback . ,Breathing_sign::brew_molecule)
(visibility-lambda . ,begin-of-line-invisible)
-
)
basicClefItemProperties = #`(
(molecule-callback . ,Score_element::brew_molecule)
(before-line-breaking-callback . ,Grace_align_item::before_line_breaking)
)
basicHaraKiriVerticalGroupspannerProperties = #`(
- (after-line-breaking-callback . ,Hara_kiri_group_spanner::after_line_breaking)
+ (hara-kiri-interface . #t)
+ (axes 1)
)
basicHyphenSpannerProperties = #`(
(thickness . 1.0)
)
basicKeyProperties = #`(
(molecule-callback . ,Key_item::brew_molecule)
+ (key-item-interface . #t)
(break-align-symbol . Key_item)
(visibility-lambda . ,begin-of-line-visible)
(breakable . #t)
(molecule-callback . ,Local_key_item::brew_molecule)
(left-padding . 0.2)
(right-padding . 0.4)
+ (accidentals-interface . #t)
)
basicLyricExtenderProperties = #`(
(molecule-callback . ,Lyric_extender::brew_molecule)
basicMarkProperties = #`(
(molecule-callback . ,Text_item::brew_molecule)
(breakable . #t)
+ (mark-interface . #t)
(visibility-lambda . ,end-of-line-invisible)
)
basicMultiMeasureRestProperties = #`(
(molecule-callback . ,Multi_measure_rest::brew_molecule)
(staff-position . 0)
-
)
basicNoteColumnProperties = #`(
(axes 0 1)
(molecule-callback . ,Text_item::brew_molecule)
(style . "italic")
)
+ basicPaperColumnProperties = #`(
+ (paper-column-interface . #t)
+ (axes 0)
+ )
basicPedalProperties = #`(
(molecule-callback . ,Text_item::brew_molecule)
(style . "italic")
basicScriptProperties = #`(
(molecule-callback . ,Script::brew_molecule)
)
-
+ basicScriptColumnProperties = #`(
+ (before-line-breaking-callback . ,Script_column::before_line_breaking)
+ )
basicSlurProperties = #`(
(molecule-callback . ,Slur::brew_molecule)
(after-line-breaking-callback . ,Slur::after_line_breaking)
(thin-kern . 3.0)
(hair-thickness . 1.6)
(thick-thickness . 6.0)
-
+ (bar-interface . #t)
)
basicSustainPedalProperties = #`(
(no-spacing-rods . #t)
)
basicTupletSpannerProperties = #`(
(number-gap . 2.0)
+ (delta-y . 0)
(thick . 1.0)
(after-line-breaking-callback . ,Tuplet_spanner::after_line_breaking)
(molecule-callback . ,Tuplet_spanner::brew_molecule)
)
basicVoltaSpannerProperties = #`(
(molecule-callback . ,Volta_spanner::brew_molecule)
- (after-line-breaking-callback . ,Volta_spanner::after_line_breaking)
)
\accepts "Staff";
Begin3
Title: LilyPond
-Version: 1.3.67
-Entered-date: 30JUN00
+Version: 1.3.68
+Entered-date: 02JUL00
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.67.tar.gz
+ 1000k lilypond-1.3.68.tar.gz
Original-site: ftp.cs.uu.nl /pub/GNU/LilyPond/development/
- 1000k lilypond-1.3.67.tar.gz
+ 1000k lilypond-1.3.68.tar.gz
Copying-policy: GPL
End
Name: lilypond
-Version: 1.3.67
+Version: 1.3.68
Release: 1
Copyright: GPL
Group: Applications/Publishing
-Source0: ftp.cs.uu.nl:/pub/GNU/LilyPond/development/lilypond-1.3.67.tar.gz
+Source0: ftp.cs.uu.nl:/pub/GNU/LilyPond/development/lilypond-1.3.68.tar.gz
Summary: A program for printing sheet music.
URL: http://www.cs.uu.nl/~hanwen/lilypond
# Icon: lilypond-icon.gif
; Make a function that checks score element for being of a specific type.
-(define (make-type-checker name)
+(define (make-type-checker symbol)
(lambda (elt)
- (not (not (memq name (ly-get-elt-property elt 'interfaces))))))
+ (display symbol)
+ (if (eq? #t (ly-get-elt-property elt symbol))
+ #t
+ #f)
+ ))
+
+
;;;;;;;;;;;;;;;;;;; TeX output
(string-append"\\vbox to " (number->dim ht) "{\\hbox{%\n"))
(define (stop-line)
- "}\\vss}\\interscoreline")
+ "}\\vss}\\interscoreline\n")
(define (stop-last-line)
"}\\vss}")
(define (filledbox breapth width depth height)
projects / lilypond.git / commitdiff