{
end_beam ();
}
- else if (Rest* rest_l = dynamic_cast<Rest *> (info.elem_l_))
+ else if (to_boolean (info.elem_l_->get_elt_property ("rest-interface")))
{
end_beam ();
}
{
if (beam_p_)
{
- if (Rest* r = dynamic_cast<Rest* > (info.elem_l_))
+ if (to_boolean (info.elem_l_->get_elt_property("rest-interface")))
{
- r->add_offset_callback (Beam::rest_collision_callback, Y_AXIS);
+ info.elem_l_->add_offset_callback (Beam::rest_collision_callback, Y_AXIS);
}
- else if (Stem* stem_l = dynamic_cast<Stem *> (info.elem_l_))
+ else if (to_boolean (info.elem_l_->get_elt_property ("stem-interface")))
{
+ Stem *stem_l = dynamic_cast<Stem*> (info.elem_l_);
if (stem_l->beam_l ())
return;
-
bool stem_grace = stem_l->get_elt_property ("grace") == SCM_BOOL_T;
SCM wg =get_property ("weAreGraceContext");
*/
#include "staff-symbol-referencer.hh"
-#include "breathing-sign-engraver.hh"
#include "breathing-sign.hh"
#include "musical-request.hh"
#include "command-request.hh"
#include "engraver-group-engraver.hh"
-#include "note-head.hh"
#include "local-key-item.hh"
+#include "engraver.hh"
+#include "command-request.hh"
+
+class Breathing_sign_engraver : public Engraver {
+public:
+ Breathing_sign_engraver();
+ VIRTUAL_COPY_CONS(Translator);
+
+protected:
+ 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();
+private:
+ Breathing_sign_req * breathing_sign_req_l_;
+ Breathing_sign * breathing_sign_p_;
+};
Breathing_sign_engraver::Breathing_sign_engraver()
{
SCM
Breathing_sign::member_after_line_breaking ()
{
- Real space = staff_symbol_referencer (this).staff_space();
+ Real space = Staff_symbol_referencer_interface (this).staff_space();
Direction d = Directional_element_interface (this). get ();
if (!d)
{
#include "beam.hh"
#include "repeated-music.hh"
#include "stem.hh"
-#include "note-head.hh"
+#include "rhythmic-head.hh"
#include "engraver-group-engraver.hh"
#include "musical-request.hh"
#include "warn.hh"
::warning (s);
}
}
- if (Note_head *nh = dynamic_cast<Note_head*> (info.elem_l_))
+ if (to_boolean (info.elem_l_->get_elt_property ("note-head-interface")))
{
- nh->set_elt_property ("duration-log", gh_int2scm (intlog2 (note_head_i_)));
+ info.elem_l_->set_elt_property ("duration-log", gh_int2scm (intlog2 (note_head_i_)));
}
}
}
#include "debug.hh"
#include "command-request.hh"
#include "timing-translator.hh"
-#include "note-head.hh"
+#include "rhythmic-head.hh"
#include "key-item.hh"
#include "local-key-item.hh"
#include "array.hh"
Item * it_l =dynamic_cast <Item *> (info.elem_l_);
if (it_l)
{
- if (dynamic_cast<Note_head*>(it_l)
+ if (to_boolean (it_l->get_elt_property("note-head-interface"))
|| dynamic_cast<Local_key_item*> (it_l))
{
Staff_symbol_referencer_interface si (it_l);
#include "debug.hh"
#include "collision.hh"
#include "note-column.hh"
-#include "note-head.hh"
+#include "rhythmic-head.hh"
#include "paper-def.hh"
#include "axis-group-interface.hh"
#include "item.hh"
/*
TODO.
*/
- Note_head * nu_l= cu_l->first_head();
- Note_head * nd_l = cd_l->first_head();
+ Rhythmic_head * nu_l= cu_l->first_head();
+ Rhythmic_head * nd_l = cd_l->first_head();
int downpos = Note_column::head_positions_interval (cd_l)[BIGGER];
int uppos = Note_column::head_positions_interval (cu_l)[SMALLER];
#include "axis-group-interface.hh"
-// todo: dots and elements duplicate each other.
-void
-Dot_column::add_dots (Item *d)
-{
- Pointer_group_interface gi (this, "dots");
- gi.add_element (d);
-
- add_dependency (d);
- Axis_group_interface (this).add_element (d);
-}
void
Dot_column::add_head (Rhythmic_head *r)
return ;
Side_position_interface (this).add_support (r);
- add_dots (r->dots_l ());
+ Item * d = r->dots_l ();
+ if (d)
+ {
+ Pointer_group_interface gi (this, "dots");
+ gi.add_element (d);
+
+ d->add_offset_callback (force_shift_callback , Y_AXIS);
+ Axis_group_interface (this).add_element (d);
+ }
}
int
-Dot_column::compare (Item * const &d1, Item * const &d2)
+Dot_column::compare (Score_element * const &d1, Score_element * const &d2)
{
Staff_symbol_referencer_interface s1(d1);
Staff_symbol_referencer_interface s2(d2);
Dot_column::Dot_column (SCM s)
: Item (s)
{
- Pointer_group_interface gi (this, "dots");
- gi.set_interface ();
+ this->set_elt_pointer ("dots", SCM_EOL);
Directional_element_interface (this).set (RIGHT);
Axis_group_interface (this).set_interface ();
Should be smarter.
*/
-GLUE_SCORE_ELEMENT(Dot_column,after_line_breaking);
+
+Real
+Dot_column::force_shift_callback (Score_element const * dot, Axis a)
+{
+ assert (a == Y_AXIS);
+ Score_element * me = dot->parent_l (X_AXIS);
+ SCM dots = me->get_elt_pointer ("dots");
+ do_shifts (dots);
+ return 0.0;
+}
+
SCM
-Dot_column::member_after_line_breaking ()
+Dot_column::do_shifts (SCM l)
{
- Link_array<Item> dots = Pointer_group_interface__extract_elements (this, (Item*)0 , "dots");
+ Link_array<Score_element> dots;
+ while (gh_pair_p (l))
+ {
+ dots.push (unsmob_element (gh_car (l)));
+ l = gh_cdr (l);
+ }
+
dots.sort (Dot_column::compare);
if (dots.size () < 2)
}
if (!conflicts)
- return SCM_UNDEFINED;
-
+ return SCM_UNDEFINED;
int middle = s.center ();
/*
for (int i=0; i < dots.size (); pos += 2, i++)
{
- staff_symbol_referencer (dots[i]).set_position(pos);
+ Score_element * d = dots[i];
+ Staff_symbol_referencer_interface (d).set_position(pos);
}
return SCM_UNDEFINED;
#include "staff-symbol-referencer.hh"
#include "directional-element-interface.hh"
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Dots,after_line_breaking);
-SCM
-Dots::after_line_breaking (SCM smob)
+Real
+Dots::quantised_position_callback (Score_element const* me, Axis a)
{
- Item * p = dynamic_cast<Item*> (unsmob_element (smob));
-
- SCM d= p->get_elt_property ("dot-count");
+ assert (a == Y_AXIS);
+
+ SCM d= me->get_elt_property ("dot-count");
if (gh_number_p (d) && gh_scm2int (d))
{
- if (!Directional_element_interface (p).get ())
- Directional_element_interface (p).set (UP);
+ if (!Directional_element_interface (me).get ())
+ Directional_element_interface (me).set (UP);
- Staff_symbol_referencer_interface si (p);
+ Staff_symbol_referencer_interface si (me);
int pos = int (si.position_f ());
if (!(pos % 2))
- si.set_position (pos + Directional_element_interface (p).get ());
+ return si.staff_space () / 2.0 * Directional_element_interface (me).get ();
}
- return SCM_UNDEFINED;
+ return 0.0;
}
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Dots,brew_molecule);
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Dots,brew_molecule);
SCM
Dots::brew_molecule (SCM d)
{
#include "side-position-interface.hh"
#include "engraver.hh"
#include "stem.hh"
-#include "note-head.hh"
+#include "rhythmic-head.hh"
#include "group-interface.hh"
#include "directional-element-interface.hh"
#include "staff-symbol-referencer.hh"
#include "engraver.hh"
#include "grace-align-item.hh"
-#include "note-head.hh"
+#include "rhythmic-head.hh"
#include "local-key-item.hh"
#include "paper-column.hh"
#include "dimension-cache.hh"
{
align_l_ = g;
}
- else if (Note_head * n = dynamic_cast <Note_head*> (i.elem_l_))
+ else if (to_boolean (i.elem_l_->get_elt_property ("note-head-interface")))
{
- if (!to_boolean (n->get_elt_property ("grace")))
- support_.push (n);
+ if (!to_boolean (i.elem_l_->get_elt_property ("grace")))
+ support_.push (dynamic_cast<Item*> (i.elem_l_));
}
else if (Local_key_item*it = dynamic_cast<Local_key_item*>(i.elem_l_))
{
*/
class Dot_column : public Item
{
- static int compare (Item * const&,Item * const&);
- void add_dots (Item*);
+ static int compare (Score_element * const&,Score_element * const&);
public:
VIRTUAL_COPY_CONS (Score_element);
void add_head (Rhythmic_head*);
Dot_column (SCM);
-
-
- SCM member_after_line_breaking ();
- static SCM after_line_breaking (SCM);
+
+ static Real force_shift_callback (Score_element const* , Axis);
+ static SCM do_shifts (SCM dotlist);
};
#endif // DOT_COLUMN_HH
class Dots // interface
{
public:
- static SCM after_line_breaking (SCM);
+ static Real quantised_position_callback(Score_element const*, Axis);
static SCM brew_molecule (SCM);
};
SCM member_brew_molecule () const;
VIRTUAL_COPY_CONS (Score_element);
- virtual void do_add_processing ();
SCM member_after_line_breaking ();
static SCM after_line_breaking (SCM);
virtual Array<Rod> get_rods () const;
static Slice head_positions_interval(Score_element* me) ;
static Direction static_dir (Score_element*);
void translate_rests(int dy);
- Note_head * first_head ()const;
+ Rhythmic_head * first_head ()const;
Interval rest_dim ()const ;
Note_column (SCM);
void set_stem (Score_element*);
#ifndef NOTEHEAD_HH
#define NOTEHEAD_HH
-#include "rhythmic-head.hh"
+#include "lily-guile.hh"
+#include "molecule.hh"
/** ball at the end of the stem. Takes care of:
*/
-class Note_head : public Rhythmic_head
+class Note_head
{
public:
- static int compare (Note_head * const &a, Note_head *const &b) ;
- static SCM brew_molecule (SCM);
-
-
- Molecule ledger_line (Interval) const;
- Note_head (SCM);
-
- SCM member_before_line_breaking ();
- static SCM before_line_breaking (SCM);
- SCM member_brew_molecule() const;
+ static SCM brew_molecule (SCM);
+ static Molecule ledger_line (Interval, Score_element*) ;
};
#endif // NOTEHEAD_HH
#ifndef REST_HH
#define REST_HH
-#include "rhythmic-head.hh"
+#include "lily-guile.hh"
/**
A pause.
style -- string specifying glyph style
*/
-class Rest : public Rhythmic_head
+class Rest
{
public:
- SCM member_after_line_breaking ();
static SCM after_line_breaking (SCM);
- SCM member_brew_molecule () const;
-
- static SCM brew_molecule (SCM);
-
-Rest (SCM s);
+ static SCM brew_molecule (SCM);
};
#endif // REST_HH
VIRTUAL_COPY_CONS(Rhythmic_head);
int balltype_i () const;
- void add_dots (Item *);
+ void set_dots (Item *);
Stem * stem_l () const;
Item * dots_l () const;
int dot_count () const;
};
int compare_position (Score_element *const&,Score_element *const&);
-
-
-Staff_symbol_referencer_interface staff_symbol_referencer (Score_element const*);
-
#endif /* STAFF_SYMBOL_REFERENCER_HH */
our beam, for aligning abbrev flags
*/
Beam* beam_l () const;
- Note_head * first_head () const;
- Drul_array<Note_head*> extremal_heads () const;
+ Rhythmic_head * first_head () const;
+ Drul_array<Rhythmic_head*> extremal_heads () const;
Score_element * support_head () const;
Stem (SCM);
SCM member_brew_molecule () const;
VIRTUAL_COPY_CONS (Score_element);
- virtual void do_add_processing ();
+
SCM member_after_line_breaking ();
static SCM after_line_breaking (SCM);
};
#include "engraver.hh"
#include "item.hh"
#include "side-position-interface.hh"
-#include "note-head.hh"
+#include "rhythmic-head.hh"
#include "stem.hh"
/**
void
Line_number_engraver::acknowledge_element (Score_element_info inf)
{
- if (dynamic_cast<Note_head*> (inf.elem_l_))
+ if (to_boolean (inf.elem_l_->get_elt_property ("note-head-interface")))
{
interesting_.push (inf);
support_.push (inf.elem_l_);
}
- if (dynamic_cast<Stem*> (inf.elem_l_))
+ else if (to_boolean (inf.elem_l_->get_elt_property ("stem-interface")))
{
support_.push (inf.elem_l_);
}
#include "local-key-item.hh"
#include "key-item.hh"
#include "tie.hh"
-#include "note-head.hh"
+#include "rhythmic-head.hh"
#include "timing-translator.hh"
#include "engraver-group-engraver.hh"
#include "grace-align-item.hh"
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(key_item_p_).set_interface ();
+ Staff_symbol_referencer_interface (key_item_p_).set_interface ();
announce_element (Score_element_info (key_item_p_, 0));
}
grace_align_l_ = gai;
}
Note_req * note_l = dynamic_cast <Note_req *> (info.req_l_);
- Note_head * note_head = dynamic_cast<Note_head *> (info.elem_l_);
+ Rhythmic_head * note_head = dynamic_cast<Rhythmic_head *> (info.elem_l_);
if (he_gr != selfgr)
return;
#include "lookup.hh"
#include "paper-def.hh"
#include "musical-request.hh"
-#include "note-head.hh"
+#include "rhythmic-head.hh"
#include "misc.hh"
void
Multi_measure_rest::member_brew_molecule () const
{
Real staff_space
- = staff_symbol_referencer (this).staff_space ();
+ = Staff_symbol_referencer_interface (this).staff_space ();
Interval sp_iv;
Direction d = LEFT;
UGH. JUNKME elt prop "columns" isn't really needed.
*/
-void
-Multi_measure_rest::do_add_processing ()
-{
-#if 0
- if (gh_pair_p (get_elt_pointer ("columns")))
- {
- Link_array<Item> column_arr (Pointer_group_interface__extract_elements (this, (Item*)0, "columns"));
-
- set_bound (LEFT, column_arr[0 >? column_arr.size () - 2]);
- set_bound (RIGHT, column_arr.top ());
- }
-#endif
- // set columns to SCM_EOL?
-}
-
-GLUE_SCORE_ELEMENT(Multi_measure_rest,after_line_breaking);
-SCM
-Multi_measure_rest::member_after_line_breaking ()
-{
- if (!gh_pair_p (get_elt_pointer ("columns")))
- {
- suicide ();
- }
-
- return SCM_UNDEFINED;
-}
return r->extent (Y_AXIS);
}
-Note_head*
+Rhythmic_head*
Note_column::first_head () const
{
Stem * st = stem_l ();
build a ledger line for small pieces.
*/
Molecule
-Note_head::ledger_line (Interval xwid) const
+Note_head::ledger_line (Interval xwid, Score_element *me)
{
Drul_array<Molecule> endings;
- endings[LEFT] = lookup_l()->afm_find ("noteheads-ledgerending");
+ endings[LEFT] = me->lookup_l()->afm_find ("noteheads-ledgerending");
Molecule *e = &endings[LEFT];
endings[RIGHT] = *e;
}
-GLUE_SCORE_ELEMENT(Note_head,before_line_breaking);
-SCM
-Note_head::member_before_line_breaking ()
-{
- // 8 ball looks the same as 4 ball:
-
- if (balltype_i () > 2)
- set_elt_property ("duration-log", gh_int2scm (2));
-
- if (Item *d = dots_l ())
- { // move into Rhythmic_head?
- Staff_symbol_referencer_interface si (d);
- Staff_symbol_referencer_interface me (this);
-
- si.set_position(int (me.position_f ()));
- }
-
- return SCM_UNDEFINED;
-}
-
-GLUE_SCORE_ELEMENT(Note_head,brew_molecule);
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Note_head,brew_molecule);
SCM
-Note_head::member_brew_molecule () const
+Note_head::brew_molecule (SCM smob)
{
- Staff_symbol_referencer_interface si (this);
+ Score_element *me = unsmob_element (smob);
+ Staff_symbol_referencer_interface si (me);
Real inter_f = si.staff_space ()/2;
int sz = si.line_count ()-1;
? 0
: (abs((int)p) - sz) /2;
- SCM style = get_elt_property ("style");
+ SCM style = me->get_elt_property ("style");
if (style == SCM_UNDEFINED)
{
style = ly_symbol2scm("default");
}
- Molecule out = lookup_l()->afm_find (String ("noteheads-") +
+ Molecule out = me->lookup_l()->afm_find (String ("noteheads-") +
ly_scm2string (scm_eval (gh_list (ly_symbol2scm("find-notehead-symbol"),
- gh_int2scm(balltype_i ()),
+ me->get_elt_property ("duration-log"),
ly_quote_scm(style),
SCM_UNDEFINED))));
Interval hd = out.extent (X_AXIS);
Real hw = hd.length ()/4;
Molecule ledger (ledger_line (Interval (hd[LEFT] - hw,
- hd[RIGHT] + hw)));
+ hd[RIGHT] + hw), me));
ledger.set_empty (true);
}
return out.create_scheme();
}
-
-
-Note_head::Note_head (SCM s)
- : Rhythmic_head (s)
-{
-
-}
(c) 1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
*/
-#include "note-head.hh"
-#include "note-heads-engraver.hh"
+#include "rhythmic-head.hh"
+#include "engraver.hh"
#include "paper-def.hh"
#include "musical-request.hh"
#include "dots.hh"
#include "dot-column.hh"
#include "staff-symbol-referencer.hh"
+#include "engraver.hh"
+#include "pqueue.hh"
+
+/**
+ make balls and rests
+ */
+class Note_heads_engraver : public Engraver
+{
+ Link_array<Rhythmic_head> note_p_arr_;
+ Link_array<Item> dot_p_arr_;
+ Link_array<Note_req> note_req_l_arr_;
+ Moment note_end_mom_;
+public:
+ VIRTUAL_COPY_CONS(Translator);
+ Note_heads_engraver();
+
+protected:
+ virtual bool do_try_music (Music *req_l) ;
+ virtual void do_process_music();
+ virtual void do_pre_move_processing();
+};
+
+
+
+
Note_heads_engraver::Note_heads_engraver()
{
for (int i=0; i < note_req_l_arr_.size (); i++)
{
- Note_head *note_p = new Note_head (get_property ("basicNoteHeadProperties"));
+ Rhythmic_head *note_p = new Rhythmic_head (get_property ("basicNoteHeadProperties"));
Staff_symbol_referencer_interface si (note_p);
si.set_interface ();
if (note_req_l->duration_.dots_i_)
{
- Item * d = new Item (get_property ("basicDotsProperties"));
+ Item * d = new Item (get_property ("basicDotsProperties"));
Staff_symbol_referencer_interface sd (d);
sd.set_interface ();
- note_p->add_dots (d);
+ note_p->set_dots (d);
if (note_req_l->duration_.dots_i_
!= gh_scm2int (d->get_elt_property ("dot-count")))
d->set_elt_property ("dot-count", gh_int2scm (note_req_l->duration_.dots_i_));
-
+
+ d->set_parent (note_p, Y_AXIS);
+ d->add_offset_callback (Dots::quantised_position_callback, Y_AXIS);
announce_element (Score_element_info (d,0));
dot_p_arr_.push (d);
}
#include "item.hh"
#include "lookup.hh"
#include "lily-guile.hh"
-#include "note-head.hh"
+#include "rhythmic-head.hh"
#include "stem.hh"
#include "side-position-interface.hh"
#include "staff-symbol-referencer.hh"
{
if (p->item_p_)
{
- if (Note_head* n = dynamic_cast<Note_head*> (info.elem_l_))
+ if (Rhythmic_head* n = dynamic_cast<Rhythmic_head*> (info.elem_l_))
{
Side_position_interface st (p->item_p_);
st.add_support (n);
#include "staff-symbol-referencer.hh"
#include "pitch-squash-engraver.hh"
-#include "note-head.hh"
+#include "rhythmic-head.hh"
void
Pitch_squash_engraver::acknowledge_element (Score_element_info i)
{
- if (Note_head *nh = dynamic_cast<Note_head *> (i.elem_l_))
+ if (to_boolean (i.elem_l_->get_elt_property ("note-head-interface")))
{
- Staff_symbol_referencer_interface (nh).set_position(0);
+ Staff_symbol_referencer_interface (i.elem_l_).set_position(0);
}
}
(c) 1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
*/
+
#include <math.h> // ceil.
#include "debug.hh"
#include "rest-collision.hh"
#include "note-column.hh"
#include "stem.hh"
-#include "note-head.hh"
+#include "rhythmic-head.hh"
#include "paper-def.hh"
#include "rest.hh"
#include "group-interface.hh"
(c) 1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
*/
#include "staff-symbol-referencer.hh"
-#include "rest-engraver.hh"
#include "musical-request.hh"
#include "dots.hh"
-#include "rest.hh"
+#include "rhythmic-head.hh"
+#include "engraver.hh"
+
+class Rest_engraver : public Engraver
+{
+ Rest_req *rest_req_l_;
+ Item * dot_p_;
+ Rhythmic_head * rest_p_;
+protected:
+ virtual bool do_try_music (Music *);
+ virtual void do_pre_move_processing ();
+ virtual void do_post_move_processing ();
+ virtual void do_process_music ();
+public:
+
+ VIRTUAL_COPY_CONS(Translator);
+ Rest_engraver ();
+};
+
/*
Should merge with Note_head_engraver
{
if (rest_req_l_ && !rest_p_)
{
- rest_p_ = new Rest (get_property ("basicRestProperties"));
+ rest_p_ = new Rhythmic_head (get_property ("basicRestProperties"));
Staff_symbol_referencer_interface si (rest_p_);
si.set_interface ();
Staff_symbol_referencer_interface si (dot_p_);
si.set_interface ();
- rest_p_->add_dots (dot_p_);
+ rest_p_->set_dots (dot_p_);
+ dot_p_->set_parent (rest_p_, Y_AXIS);
+ dot_p_->add_offset_callback (Dots::quantised_position_callback, Y_AXIS);
dot_p_->set_elt_property ("dot-count",
gh_int2scm (rest_req_l_->duration_.dots_i_));
announce_element (Score_element_info (dot_p_,0));
#include "dimension-cache.hh"
#include "slur.hh"
#include "engraver.hh"
-#include "note-head.hh"
+#include "rhythmic-head.hh"
#include "stem.hh"
#include "note-column.hh"
#include "dot-column.hh"
return dots_l ()
? gh_scm2int (dots_l ()->get_elt_property ("dot-count")) : 0;
}
-
-GLUE_SCORE_ELEMENT(Rhythmic_head,after_line_breaking);
-SCM
-Rhythmic_head::member_after_line_breaking ()
-{
- if (Item *d = dots_l ())
- {
- Staff_symbol_referencer_interface si (d);
- Staff_symbol_referencer_interface me (d);
- si.set_position(int (me.position_f ()));
- }
-
- return SCM_UNDEFINED;
-}
-
void
-Rhythmic_head::add_dots (Item *dot_l)
+Rhythmic_head::set_dots (Item *dot_l)
{
set_elt_pointer ("dot", dot_l->self_scm_);
- dot_l->add_dependency (this);
}
Real off =0.0;
if (gh_number_p (pos))
{
- Real space = staff_symbol_referencer (sc).staff_space ();
+ Real space = Staff_symbol_referencer_interface (sc).staff_space ();
off = gh_scm2double (pos) * space/2.0;
}
elt_l_->add_offset_callback (callback, Y_AXIS);
}
-Staff_symbol_referencer_interface
-staff_symbol_referencer (Score_element const*e)
-{
- return e; // gee, I'm so smart!
-}
int
compare_position (Score_element *const &a, Score_element * const &b)
*/
#include "staff-symbol-referencer.hh"
-#include "note-head.hh"
+#include "rhythmic-head.hh"
#include "stem.hh"
#include "musical-request.hh"
#include "misc.hh"
#include "side-position-interface.hh"
#include "item.hh"
#include "musical-request.hh"
-#include "note-head.hh"
+
#include "stem.hh"
#include "staff-symbol.hh"
Link_array<Text_script_req> reqs_;
Link_array<Item> texts_;
public:
-
VIRTUAL_COPY_CONS(Translator);
protected:
virtual bool do_try_music (Music* m);
void
-Text_engraver::acknowledge_element (Score_element_info i)
+Text_engraver::acknowledge_element (Score_element_info inf)
{
- if (Note_head *n = dynamic_cast<Note_head*> (i.elem_l_))
+ if (to_boolean (inf.elem_l_->get_elt_property ("note-head-interface")))
{
for (int i=0; i < texts_.size (); i++)
{
Side_position_interface st (texts_[i]);
- st.add_support (n);
+ st.add_support (inf.elem_l_);
if (st.get_axis( ) == X_AXIS
&& !texts_[i]->parent_l (Y_AXIS))
- texts_[i]->set_parent (n, Y_AXIS);
+ texts_[i]->set_parent (inf.elem_l_, Y_AXIS);
}
}
- if (Stem *n = dynamic_cast<Stem*> (i.elem_l_))
+ if (Stem *n = dynamic_cast<Stem*> (inf.elem_l_))
{
for (int i=0; i < texts_.size (); i++)
{
Molecule m;
m.set_empty (false);
mol.add_at_edge (X_AXIS, RIGHT, m, gh_scm2double (space)*
- staff_symbol_referencer (s).staff_space ());
+ Staff_symbol_referencer_interface (s).staff_space ());
}
return mol.create_scheme ();
}
#include "group-interface.hh"
#include "tie.hh"
#include "directional-element-interface.hh"
-#include "note-head.hh"
+#include "rhythmic-head.hh"
Tie_column::Tie_column (SCM s)
: Spanner (s)
#include "tie-engraver.hh"
#include "command-request.hh"
-#include "note-head.hh"
+#include "rhythmic-head.hh"
#include "musical-request.hh"
#include "tie.hh"
#include "translator-group.hh"
struct CHead_melodic_tuple {
Melodic_req *req_l_ ;
- Note_head *head_l_;
+ Rhythmic_head *head_l_;
Moment end_;
CHead_melodic_tuple ();
- CHead_melodic_tuple (Note_head*, Melodic_req*, Moment);
+ CHead_melodic_tuple (Rhythmic_head*, Melodic_req*, Moment);
static int pitch_compare (CHead_melodic_tuple const &, CHead_melodic_tuple const &);
static int time_compare (CHead_melodic_tuple const &, CHead_melodic_tuple const &);
};
void
Tie_engraver::acknowledge_element (Score_element_info i)
{
- if (Note_head *nh = dynamic_cast<Note_head *> (i.elem_l_))
+ if (Rhythmic_head *nh = dynamic_cast<Rhythmic_head *> (i.elem_l_))
{
Note_req * m = dynamic_cast<Note_req* > (i.req_l_);
if (!m)
end_ = 0;
}
-CHead_melodic_tuple::CHead_melodic_tuple (Note_head *h, Melodic_req*m, Moment mom)
+CHead_melodic_tuple::CHead_melodic_tuple (Rhythmic_head *h, Melodic_req*m, Moment mom)
{
head_l_ = h;
req_l_ = m;
#include "lookup.hh"
#include "paper-def.hh"
#include "tie.hh"
-#include "note-head.hh"
+#include "rhythmic-head.hh"
#include "bezier.hh"
#include "paper-column.hh"
#include "debug.hh"
}
-Note_head*
+Rhythmic_head*
Tie::head (Direction d) const
{
SCM c = get_elt_pointer ("heads");
c = index_cell (c, d);
- return dynamic_cast<Note_head*> (unsmob_element (c));
+ return dynamic_cast<Rhythmic_head*> (unsmob_element (c));
}
Real
Tie::position_f () const
{
return head (LEFT)
- ? staff_symbol_referencer (head (LEFT)).position_f ()
- : staff_symbol_referencer (head (RIGHT)).position_f () ;
+ ? Staff_symbol_referencer_interface (head (LEFT)).position_f ()
+ : Staff_symbol_referencer_interface (head (RIGHT)).position_f () ;
}
warning (_ ("lonely tie"));
Direction d = LEFT;
- Drul_array<Note_head *> new_head_drul;
+ Drul_array<Rhythmic_head *> new_head_drul;
new_head_drul[LEFT] = head(LEFT);
new_head_drul[RIGHT] = head(RIGHT);
do {
if (!Directional_element_interface (this).get ())
Directional_element_interface (this).set (get_default_dir ());
- Real staff_space = staff_symbol_referencer (this).staff_space ();
+ Real staff_space = Staff_symbol_referencer_interface (this).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");
Direction d (Directional_element_interface (this).get ());
Bezier_bow b (get_encompass_offset_arr (), d);
- Real staff_space = staff_symbol_referencer (this).staff_space ();
+ Real staff_space = Staff_symbol_referencer_interface (this).staff_space ();
Real h_inf = paper_l ()->get_var ("tie_height_limit_factor") * staff_space;
Real r_0 = paper_l ()->get_var ("tie_ratio");
}
return mol.create_scheme();
}
-
-void
-Tuplet_spanner::do_add_processing ()
-{
-#if 0
- if (gh_pair_p (get_elt_pointer ("columns")))
- {
- Link_array<Note_column> column_arr=
- Pointer_group_interface__extract_elements (this, (Note_column*)0, "columns");
-
- set_bound (LEFT, column_arr[0]);
- set_bound (RIGHT, column_arr.top ());
- }
-#endif
-}
+
mol.translate_axis (left, X_AXIS);
return mol.create_scheme();
}
-
-void
-Volta_spanner::do_add_processing ()
-{
-#if 0
- Link_array<Bar> bar_arr
- = Pointer_group_interface__extract_elements (this, (Bar*)0, "bars");
- if (bar_arr.size ())
- {
- set_bound (LEFT, bar_arr[0]);
- set_bound (RIGHT, bar_arr.top ());
- }
-#endif
-}
GLUE_SCORE_ELEMENT(Volta_spanner,after_line_breaking);
SCM
projects / lilypond.git / commitdiff