-1.3.66.hwn1
-===========
+1.3.68
+======
+
+* ly2dvi: changed back to original semantics of latexheaders.
+
+* 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.
c1 | c2 c | c c | c c | \break c c | c c | c c | c c |
}
+M = \notes \relative c''{
+
+c1 | c2 c | c c | R1*5
+}
+
\score{ <
\context StaffGroup = wood <
\context Staff = flauto <
\context Staff = cor <
\property Staff.instrument = "2 Corni in F"
\property Staff.instr = "Cor."
- \context Voice = corI { \stemup \m }
- \context Voice = corII { \stemdown \m }
+ \context Voice = corI { \stemup \M }
+ \context Voice = corII { \stemdown \M }
>
\context Staff = trp <
\property Staff.instrument = "2 Trp. in B\\textflat "
\property Staff.instr = "Trp."
- \context Voice = trpI { \stemup \m }
- \context Voice = trpII { \stemdown \m }
+ \context Voice = trpI { \stemup \M }
+ \context Voice = trpII { \stemdown \M }
>
>
\context StaffGroup = percussion <\context Staff = timpani <
\translator {
\OrchestralScoreContext
barNumberScriptPadding = 10;
- minVerticalAlign = 2.2*\staffheight;
-
}
\translator { \HaraKiriStaffContext
- \consists "Instrument_name_engraver";
marginScriptPadding = 15.0;
+% StaffMinimumVerticalExtent = #(cons -0.0 0.0)
}
}
}
#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 "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;
}
/**
A vertical bar.
*/
-class Bar:public Item {
+class Bar:public Item
+{
public:
VIRTUAL_COPY_CONS(Score_element);
Bar(SCM);
#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
#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);
};
{
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;
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 ();
#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 */
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;
};
#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
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;
}
}
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);
}
(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;
}
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_);
}
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
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 ())
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";
conversions.append ((1,3,59), conv,
'\key X ; -> \key X major; ')
+if 1:
+ def conv (str):
+# if re.search ('latexheaders *= *"\\\\input ',str):
+# sys.stderr.write ('\nHello???')
+ str = re.sub (r'latexheaders *= *"\\\\input ',
+ 'latexheaders = "',
+ str)
+ return str
+ conversions.append ((1,3,68), conv, 'latexheaders = "\\input global" -> latexheaders = "global"')
+
+
############################
%%\headsep0pt
%% Maybe this is too drastic, but let us give it a try.
\geometry{width=%spt, height=%spt,headheight=2mm,headsep=0pt,footskip=2mm}
-\input lilyponddefs
-\input titledefs
+\input{lilyponddefs}
+\input{titledefs}
%s
\makeatletter
\renewcommand{\@oddhead}{\parbox{\textwidth}%%
# Set latex header name
#
def setHeader(this,head, requester):
- this.__set('header',head,requester)
+ this.__set('header','\\input{' + head + '}',requester)
#
# Set or Clear Dependencies flag to generate makefile dependencies
projects / lilypond.git / commitdiff