+1.3.68.hwn1
+===========
+
+* Cleanup auto-beam-engraver: use properties for retrieving timing
+information.
+
+* Fixed: Multi measure rests don't cause crashes.
+
+* Fixed: don't invoke Hara_kiri::consider_suicide too early.
+
+* Fixed: property engraver.
+
+* Fixed: don't crash on multiple ties.
+
+* Cleanups of Beam, should also be a little faster.
+
+* Reunite properties and pointers. In implementation we make a
+distinction between mutable and immutable properties
+
+* Add {has|set}_interface () static methods to interface classes.
+
+* Made Side_position_interface and Staff_symbol_interface an all
+statics class, and stripped _interface suffix.
+
+* Make Align_interface and Axis_group_interface an all-statics class
+
+* Rhythmic_head, Staff_symbol, Grace_align_item, Break_align_item,
+Bar, Span_bar are now interfaces, Staff_bar was removed. Use a
+callback for determining barsize.
+
+* Removed all GLUE_SCORE_ELEMENT callbacks.
+
+* Added test for repeats to trip.ly
+
+*
+
1.3.68
======
- removed old notename2scm conversion
- beam-dir-algorithm through scm
- bfs paper-scm
- - bf: knee-stemlengths
+gv - bf: knee-stemlengths
pl 15.jcn3
- moved poor man's stem arrays to scm
@end example
-@subsubsection Some of your neat scripts fail, what directories do you use:
-
-[This only applies if you don't do @code{make install}, and run out
-of the source directory]
-
-I have a directory which contains all our development projects
-@example
-
- ~/usr/
-
-@end example
-
-which looks like @file{/usr/}
-@example
-
- bin/
- share
- lib/
- share/
- src/
-
- etc....
-
-@end example
-
-@file{~/usr/bin/} is in the variable PATH, and contains symbolic links
-to the compiled executables. Unpacked sources, releases and patches are
-in subdirectories under @file{~/usr/src/}.
-
@subsubsection Is there an emacs mode?
Yes. It is included with the source archive as @file{lilypond-mode.el}.
@mudelafile{generic-output-property.ly}
+The same mechanism can be used to force pagebreaks.
+
+@mudelafile{between-systems.ly}
+
@bye
PACKAGE_NAME=LilyPond
MAJOR_VERSION=1
MINOR_VERSION=3
-PATCH_LEVEL=68
+PATCH_LEVEL=69
MY_PATCH_LEVEL=
# use the above to send patches: MY_PATCH_LEVEL is always empty for a
--- /dev/null
+% f.ly:4:20: warning: Must stop before this music ends:
+
+
+\score { \notes {
+ \addlyrics { c4 } { f4}
+}}
\clef bass;
%15
- dis4.-\ltoe e8-\rtoe cis4 |
+ %
+ % TODO: the volta typesetting should spread over the complete score.
+ %
+ \repeat "volta" 2 { dis4.-\ltoe } \alternative { e8-\rtoe cis4 } |
b4.-\lheel [cis8-\ltoe dis8-\rtoe e8-\rheel] |
fis4.-\rtoe [e8-\rheel dis8-\rtoe cis8-\ltoe] |
dis4-\rtoe e4-\rheel e,4-\ltoe |
*/
#include "align-interface.hh"
-#include "dimension-cache.hh"
+
#include "score-element.hh"
#include "group-interface.hh"
#include "axis-group-interface.hh"
Score_element * par = sc->parent_l (ax);
if (par && par->get_elt_property ("alignment-done") == SCM_UNDEFINED)
{
- Align_interface (par).do_side_processing (ax);
+ Align_interface::do_side_processing (par, ax);
}
return 0.0;
}
Real
Align_interface::center_on_element (Score_element *me, Axis a)
{
- Score_element *cent = unsmob_element (me->get_elt_pointer ("group-center-element"));
+ Score_element *cent = unsmob_element (me->get_elt_property ("group-center-element"));
if (cent)
{
from the outside by setting minimum-space and extra-space in its
children */
void
-Align_interface::do_side_processing (Axis a)
+Align_interface::do_side_processing (Score_element * me, Axis a)
{
- elt_l_->set_elt_property ("alignment-done", SCM_BOOL_T);
+ me->set_elt_property ("alignment-done", SCM_BOOL_T);
- SCM d = elt_l_->get_elt_property ("stacking-dir");
+ SCM d = me->get_elt_property ("stacking-dir");
Direction stacking_dir = gh_number_p(d) ? to_dir (d) : CENTER;
if (!stacking_dir)
stacking_dir = DOWN;
Link_array<Score_element> elems;
Link_array<Score_element> all_elts
- = Pointer_group_interface__extract_elements ( elt_l_, (Score_element*) 0, "elements");
+ = Pointer_group_interface__extract_elements ( me, (Score_element*) 0, "elements");
for (int i=0; i < all_elts.size(); i++)
{
- Interval y = all_elts[i]->extent(a) + all_elts[i]->relative_coordinate (elt_l_, a);
+ Interval y = all_elts[i]->extent(a) + all_elts[i]->relative_coordinate (me, a);
if (!y.empty_b())
{
Score_element *e =dynamic_cast<Score_element*>(all_elts[i]);
Interval threshold = Interval (0, Interval::infinity ());
- SCM thr = elt_l_->get_elt_property ("threshold");
+ SCM thr = me->get_elt_property ("threshold");
if (gh_pair_p (thr))
{
threshold[SMALLER] = gh_scm2double (gh_car (thr));
Axis
-Align_interface::axis ()const
+Align_interface::axis (Score_element*me)
{
- return Axis (gh_scm2int (gh_car (elt_l_->get_elt_property ("axes"))));
+ return Axis (gh_scm2int (gh_car (me->get_elt_property ("axes"))));
}
should use generic Scm funcs.
*/
int
-Align_interface::get_count (Score_element*s)const
+Align_interface::get_count (Score_element*me,Score_element*s)
{
- SCM e = elt_l_->get_elt_pointer ("elements");
+ SCM e = me->get_elt_property ("elements");
int c =0;
while (gh_pair_p (e))
{
}
void
-Align_interface::add_element (Score_element* s)
+Align_interface::add_element (Score_element*me,Score_element* s)
{
- s->add_offset_callback (alignment_callback, axis ());
- Axis_group_interface (elt_l_).add_element (s);
+ s->add_offset_callback (alignment_callback, Align_interface::axis (me));
+ Axis_group_interface::add_element (me, s);
}
-Align_interface::Align_interface (Score_element const*s)
-{
- elt_l_ = (Score_element*)s;
-}
void
-Align_interface::set_interface ()
+Align_interface::set_interface (Score_element*me)
{
- Axis_group_interface (elt_l_).set_interface ();
+ me->set_interface (ly_symbol2scm ("align-interface"));
- Group_interface (elt_l_, "interfaces").add_thing (ly_symbol2scm ("Alignment"));
+ Axis_group_interface::set_interface (me);
}
void
-Align_interface::set_axis (Axis a)
+Align_interface::set_axis (Score_element*me,Axis a)
{
- Axis_group_interface (elt_l_).set_axes (a,a );
+ Axis_group_interface::set_axes (me, a,a );
}
bool
-Align_interface::has_interface_b ()
+Align_interface::has_interface (Score_element*me)
{
- SCM ifs = elt_l_->get_elt_property ("interfaces");
- if (!gh_pair_p (ifs))
- return false;
-
- return scm_memq (ly_symbol2scm ("Alignment"), ifs) != SCM_BOOL_F;
+ return me && me->has_interface (ly_symbol2scm ("align-interface"));
}
#include "warn.hh"
#include "directional-element-interface.hh"
#include "side-position-interface.hh"
+#include "local-key-item.hh"
/**
Catch notes, and put them in a row. Used for aligning grace notes.
*/
class Align_note_column_engraver: public Engraver
{
- Grace_align_item * align_item_p_;
+ Item * align_item_p_;
Note_column * now_column_l_;
Score_element * accidental_l_;
void
Align_note_column_engraver::do_creation_processing ()
{
- align_item_p_ = new Grace_align_item (get_property ("basicGraceAlignItemProperties"));
- Side_position_interface (align_item_p_).set_axis (X_AXIS);
- Side_position_interface (align_item_p_).set_direction (LEFT);
+ align_item_p_ = new Item (get_property ("basicGraceAlignItemProperties"));
+ Grace_align_item::set_interface (align_item_p_);
+ Side_position::set_axis (align_item_p_, X_AXIS);
+ Side_position::set_direction (align_item_p_, LEFT);
// needed for setting font size.
announce_element (Score_element_info (align_item_p_, 0));
{
now_column_l_ =n;
}
- else if (to_boolean (inf.elem_l_->get_elt_property ("accidentals-interface")))
+ else if (Local_key_item::has_interface (inf.elem_l_))
{
accidental_l_ = inf.elem_l_;
}
if (now_column_l_)
{
- Align_interface (align_item_p_).add_element (now_column_l_);
+ Align_interface::add_element (align_item_p_,now_column_l_);
now_column_l_ =0;
}
}
+
/*
auto-beam-engraver.cc -- implement Auto_beam_engraver
*/
#include "beaming.hh"
-#include "auto-beam-engraver.hh"
#include "musical-request.hh"
#include "beam.hh"
#include "stem.hh"
#include "debug.hh"
-#include "timing-engraver.hh"
#include "engraver-group-engraver.hh"
+#include "bar.hh"
+#include "rest.hh"
+#include "engraver.hh"
+
+class Auto_beam_engraver : public Engraver
+{
+public:
+ Auto_beam_engraver ();
+ VIRTUAL_COPY_CONS (Translator);
+
+protected:
+ virtual bool do_try_music (Music*);
+ virtual void do_pre_move_processing ();
+ virtual void do_post_move_processing ();
+ virtual void do_removal_processing ();
+ virtual void acknowledge_element (Score_element_info);
+ virtual void do_process_music ();
+ virtual void process_acknowledged ();
+private:
+ void begin_beam ();
+ void consider_end_and_begin (Moment test_mom);
+ Beam* create_beam_p ();
+ void end_beam ();
+ void junk_beam ();
+ bool same_grace_state_b (Score_element* e);
+ void typeset_beam ();
+
+ Moment shortest_mom_;
+ Beam *finished_beam_p_;
+ Link_array<Item>* stem_l_arr_p_;
+
+ Moment last_add_mom_;
+ Moment extend_mom_;
+ Moment beam_start_moment_;
+ Moment beam_start_location_;
+
+ // We act as if beam were created, and start a grouping anyway.
+ Beaming_info_list*grouping_p_;
+ Beaming_info_list*finished_grouping_p_;
+};
+
+
+
ADD_THIS_TRANSLATOR (Auto_beam_engraver);
finished_beam_p_ = 0;
finished_grouping_p_ = 0;
grouping_p_ = 0;
- timer_l_ =0;
}
-void
-Auto_beam_engraver::do_creation_processing ()
-{
- Translator * t = daddy_grav_l ()->get_simple_translator ("Timing_engraver");
- timer_l_ = dynamic_cast<Timing_engraver*> (t);
-}
bool
Auto_beam_engraver::do_try_music (Music*)
void
Auto_beam_engraver::consider_end_and_begin (Moment test_mom)
{
- if (!timer_l_)
- return;
-
- int num;
- int den;
- timer_l_->get_time_signature (&num, &den);
+ Moment one_beat = *unsmob_moment( get_property ("beatLength"));
+
+ int num = *unsmob_moment (get_property("measureLength")) / one_beat;
+ int den = one_beat.den_i ();
+
String time_str = String ("time") + to_str (num) + "_" + to_str (den);
Rational r;
if (end_mom)
- r = timer_l_->measure_position ().mod_rat (end_mom);
+ r = unsmob_moment (get_property ("measurePosition"))->mod_rat (end_mom);
else
r = Moment (1);
return;
if (begin_mom)
- r = timer_l_->measure_position ().mod_rat (begin_mom);
+ r = unsmob_moment (get_property ("measurePosition"))->mod_rat (begin_mom);
if (!stem_l_arr_p_ && (!begin_mom || !r))
begin_beam ();
}
Auto_beam_engraver::begin_beam ()
{
assert (!stem_l_arr_p_);
- stem_l_arr_p_ = new Array<Stem*>;
+ stem_l_arr_p_ = new Link_array<Item>;
assert (!grouping_p_);
grouping_p_ = new Beaming_info_list;
beam_start_moment_ = now_mom ();
- beam_start_location_ = timer_l_->measure_position ();
+ beam_start_location_ = *unsmob_moment (get_property ("measurePosition"));
}
Beam*
/*
watch out for stem tremolos and abbreviation beams
*/
- if ((*stem_l_arr_p_)[i]->beam_l ())
+ if (Stem::beam_l ((*stem_l_arr_p_)[i]))
{
return 0;
}
void
Auto_beam_engraver::acknowledge_element (Score_element_info info)
{
- if (!same_grace_state_b (info.elem_l_) || !timer_l_)
+ if (!same_grace_state_b (info.elem_l_))
return;
if (stem_l_arr_p_)
{
end_beam ();
}
- else if (to_boolean (info.elem_l_->get_elt_property ("bar-interface")))
+ else if (Bar::has_interface (info.elem_l_))
{
end_beam ();
}
- else if (to_boolean (info.elem_l_->get_elt_property ("rest-interface")))
+ else if (Rest::has_interface (info.elem_l_))
{
end_beam ();
}
}
- if (Stem* stem_l = dynamic_cast<Stem *> (info.elem_l_))
+ if (Stem::has_interface (info.elem_l_))
{
+ Item* stem_l = dynamic_cast<Item *> (info.elem_l_);
+
Rhythmic_req *rhythmic_req = dynamic_cast <Rhythmic_req *> (info.req_l_);
if (!rhythmic_req)
{
/*
Don't (start) auto-beam over empty stems; skips or rests
*/
- if (!stem_l->heads_i ())
+ if (!Stem::heads_i (stem_l))
{
if (stem_l_arr_p_)
end_beam ();
return;
}
- if (stem_l->beam_l ())
+ if (!Stem::beam_l (stem_l))
{
if (stem_l_arr_p_)
junk_beam ();
#include "spanner.hh"
#include "paper-column.hh"
#include "axis-group-interface.hh"
-#include "dimension-cache.hh"
+
#include "engraver-group-engraver.hh"
Axis_group_engraver::Axis_group_engraver ()
Axis_group_engraver::do_creation_processing ()
{
staffline_p_ = get_spanner_p ();
- Axis_group_interface (staffline_p_).set_interface ();
- Axis_group_interface (staffline_p_).set_axes (Y_AXIS, Y_AXIS);
+ Axis_group_interface::set_interface (staffline_p_);
+ Axis_group_interface::set_axes (staffline_p_, Y_AXIS, Y_AXIS);
Score_element * it = unsmob_element (get_property ("currentCommandColumn"));
Pointer_group_interface (it, "bounded-by-me").add_element (staffline_p_);
{
Score_element *par = elts_[i]->parent_l (Y_AXIS);
- if ((!par || !Axis_group_interface (par).has_interface_b ())
+ if ((!par || !Axis_group_interface::has_interface (par))
&& ! elts_[i]->empty_b (Y_AXIS))
- Axis_group_interface (staffline_p_).add_element (elts_[i]);
+ Axis_group_interface::add_element (staffline_p_, elts_[i]);
}
elts_.clear ();
}
#include "axis-group-interface.hh"
#include "score-element.hh"
-#include "dimension-cache.hh"
-
-Axis_group_interface::Axis_group_interface (Score_element*s)
-{
- elt_l_ = s;
-}
-
-Axis_group_interface
-Axis_group_interface (Score_element*s)
-{
- return Axis_group_interface (s);
-}
void
-Axis_group_interface::add_element (Score_element *e)
+Axis_group_interface::add_element (Score_element*me,Score_element *e)
{
- for (SCM ax = elt_l_->get_elt_property ("axes"); ax != SCM_EOL ; ax = gh_cdr (ax))
+ for (SCM ax = me->get_elt_property ("axes"); ax != SCM_EOL ; ax = gh_cdr (ax))
{
Axis a = (Axis) gh_scm2int (gh_car (ax));
if (!e->parent_l (a))
- e->set_parent (elt_l_, a);
+ e->set_parent (me, a);
}
- Pointer_group_interface (elt_l_).add_element (e);
- elt_l_->add_dependency (e);
+ Pointer_group_interface (me).add_element (e);
+ me->add_dependency (e);
}
-
bool
-Axis_group_interface::axis_b (Axis a )const
+Axis_group_interface::axis_b (Score_element*me,Axis a )
{
- return elt_l_->has_extent_callback_b (group_extent_callback, a);
+ return me->has_extent_callback_b (group_extent_callback, a);
}
Interval
{
Score_element * common =(Score_element*) me;
- for (SCM s = me->get_elt_pointer ("elements"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = me->get_elt_property ("elements"); gh_pair_p (s); s = gh_cdr (s))
{
Score_element * se = unsmob_element (gh_car (s));
common = se->common_refpoint (common, a);
}
Real my_coord = me->relative_coordinate (common, a);
- Interval r (relative_group_extent (a, common, me->get_elt_pointer ("elements")));
+ Interval r (relative_group_extent (a, common, me->get_elt_property ("elements")));
return r - my_coord;
}
-void
-Axis_group_interface::set_interface ()
-{
- if (!has_interface_b ())
- {
- elt_l_->set_elt_pointer ("elements", SCM_EOL);
-
- Group_interface (elt_l_, "interfaces").add_thing (ly_symbol2scm ("Axis_group"));
- }
-}
void
-Axis_group_interface::set_axes (Axis a1, Axis a2)
+Axis_group_interface::set_axes (Score_element*me,Axis a1, Axis a2)
{
// set_interface () ?
SCM sa1= gh_int2scm (a1);
SCM sa2 = gh_int2scm (a2);
- SCM prop = elt_l_->get_elt_property ("axes");
+ SCM prop = me->get_elt_property ("axes");
if (prop == SCM_UNDEFINED
|| scm_memq (sa1, prop) == SCM_BOOL_F
SCM ax = gh_cons (sa1, SCM_EOL);
if (a1 != a2)
ax= gh_cons (sa2, ax);
- elt_l_->set_elt_property ("axes", ax);
+ me->set_elt_property ("axes", ax);
}
if (a1 != X_AXIS && a2 != X_AXIS)
- elt_l_->set_extent_callback (0, X_AXIS);
+ me->set_extent_callback (0, X_AXIS);
if (a1 != Y_AXIS && a2 != Y_AXIS)
- elt_l_->set_extent_callback (0, Y_AXIS);
+ me->set_extent_callback (0, Y_AXIS);
- elt_l_->set_extent_callback (Axis_group_interface::group_extent_callback,a1);
- elt_l_->set_extent_callback (Axis_group_interface::group_extent_callback,a2);
+ me->set_extent_callback (Axis_group_interface::group_extent_callback,a1);
+ me->set_extent_callback (Axis_group_interface::group_extent_callback,a2);
}
Link_array<Score_element>
-Axis_group_interface::get_children ()
+Axis_group_interface::get_children (Score_element*me)
{
Link_array<Score_element> childs;
- childs.push (elt_l_) ;
+ childs.push (me) ;
- if (!has_interface_b ())
+ if (!has_interface (me))
return childs;
- for (SCM ep = elt_l_->get_elt_pointer ("elements"); gh_pair_p (ep); ep = gh_cdr (ep))
+ for (SCM ep = me->get_elt_property ("elements"); gh_pair_p (ep); ep = gh_cdr (ep))
{
Score_element* e = unsmob_element (gh_car (ep));
if (e)
- childs.concat (Axis_group_interface (e).get_children ());
+ childs.concat (Axis_group_interface::get_children (e));
}
return childs;
}
bool
-Axis_group_interface::has_interface_b ()
+Axis_group_interface::has_interface (Score_element*me)
{
- SCM ifs = elt_l_->get_elt_property ("interfaces");
-
- if (!gh_pair_p (ifs ))
- return false;
- return scm_memq (ly_symbol2scm ("Axis_group"),ifs) != SCM_BOOL_F;
+ return me && me->has_interface (ly_symbol2scm ("axis-group-interface"));
}
+
+void
+Axis_group_interface::set_interface (Score_element*me)
+{
+ if (!has_interface (me))
+ {
+ me->set_interface (ly_symbol2scm ("axis-group-interface"));
+ me->set_elt_property ("elements", SCM_EOL);
+ }
+}
Jan Nieuwenhuizen <janneke@gnu.org>
*/
+#include "bar.hh"
#include "score-engraver.hh"
#include "bar-engraver.hh"
-#include "staff-bar.hh"
#include "musical-request.hh"
#include "multi-measure-rest.hh"
#include "command-request.hh"
#include "timing-engraver.hh"
#include "engraver-group-engraver.hh"
#include "warn.hh"
+#include "item.hh"
Bar_engraver::Bar_engraver()
{
{
if (!bar_p_)
{
- bar_p_ = new Staff_bar (get_property ("basicBarProperties"));
-
+ bar_p_ = new Item (get_property ("basicBarProperties"));
- // urg: "" != empty...
- /*
- TODO: use symbol.
- */
SCM default_type = get_property ("defaultBarType");
if (gh_string_p (default_type))
{
/**
Make a barline. If there are both |: and :| requested, merge them
to :|:.
-
*/
void
Bar_engraver::request_bar (String requested_type)
Bar_number_engraver::acknowledge_element (Score_element_info inf)
{
Score_element * s = inf.elem_l_;
- if (dynamic_cast<Staff_symbol*> (s))
+ if (Staff_symbol::has_interface (s))
{
staffs_ = gh_cons (inf.elem_l_->self_scm_, staffs_);
}
{
if (text_p_)
{
- text_p_->set_elt_pointer ("side-support-elements", staffs_);
+ text_p_->set_elt_property ("side-support-elements", staffs_);
typeset_element (text_p_);
text_p_ =0;
}
SCM b = get_property ("basicBarNumberProperties");
text_p_ = new Item (b);
- Side_position_interface staffside(text_p_);
- staffside.set_axis (Y_AXIS);
+ Side_position::set_axis(text_p_,Y_AXIS);
SCM prop = get_property ("barNumberDirection");
if (!isdir_b (prop))
#include "main.hh"
#include "dimensions.hh"
-#include "dimension-cache.hh"
+#include "score-element.hh"
#include "bar.hh"
#include "string.hh"
#include "molecule.hh"
#include "lookup.hh"
#include "debug.hh"
#include "all-font-metrics.hh"
+#include "item.hh"
+#include "staff-symbol-referencer.hh"
-Bar::Bar (SCM s)
- : Item (s)
-{
-}
-
-
-Real
-Bar::get_bar_size () const
-{
- // Never called!
- return 0;
-}
-
+MAKE_SCHEME_CALLBACK(Bar,brew_molecule);
SCM
Bar::brew_molecule (SCM smob)
{
- Score_element * self = unsmob_element (smob);
- Bar * fly = dynamic_cast<Bar*> (self);
- SCM s = self->get_elt_property ("glyph");
- if (gh_string_p (s))
+ Score_element * me = unsmob_element (smob);
+
+ SCM s = me->get_elt_property ("glyph");
+ SCM barsiz_proc = me->get_elt_property ("barsize-procedure");
+ if (gh_string_p (s) && gh_procedure_p (barsiz_proc))
{
String str =ly_scm2string (s);
- return fly->compound_barline (str, fly->get_bar_size ()).create_scheme ();
+ SCM siz = gh_call1 (barsiz_proc, me->self_scm_);
+ return compound_barline (me, str, gh_scm2double (siz)).create_scheme ();
}
return SCM_EOL;
}
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Bar,brew_molecule);
Molecule
-Bar::compound_barline (String str, Real h) const
+Bar::compound_barline (Score_element*me, String str, Real h)
{
- Real kern = gh_scm2double (get_elt_property ("kern"));
- Real thinkern = gh_scm2double (get_elt_property ("thin-kern"));
- Real hair = gh_scm2double (get_elt_property ("hair-thickness"));
- Real fatline = gh_scm2double (get_elt_property ("thick-thickness"));
+ Real kern = gh_scm2double (me->get_elt_property ("kern"));
+ Real thinkern = gh_scm2double (me->get_elt_property ("thin-kern"));
+ Real hair = gh_scm2double (me->get_elt_property ("hair-thickness"));
+ Real fatline = gh_scm2double (me->get_elt_property ("thick-thickness"));
- Real staffline = paper_l ()->get_var ("stafflinethickness");
+ Real staffline = me->paper_l ()->get_var ("stafflinethickness");
kern *= staffline;
thinkern *= staffline;
hair *= staffline;
fatline *= staffline;
- Molecule thin = simple_barline (hair, h);
- Molecule thick = simple_barline (fatline, h);
- Molecule colon = lookup_l ()->afm_find ("dots-repeatcolon");
+ Molecule thin = simple_barline (me, hair, h);
+ Molecule thick = simple_barline (me, fatline, h);
+ Molecule colon = me->lookup_l ()->afm_find ("dots-repeatcolon");
Molecule m;
if (str == "")
{
- return lookup_l ()->blank (Box (Interval(0, 0), Interval (-h/2, h/2)));
+ return me->lookup_l ()->blank (Box (Interval(0, 0), Interval (-h/2, h/2)));
}
if (str == "scorepostbreak")
{
- return simple_barline (paper_l ()->get_var ("barthick_score"), h);
+ return simple_barline (me, me->paper_l ()->get_var ("barthick_score"), h);
}
else if (str == "|")
{
Molecule
-Bar::simple_barline (Real w, Real h) const
+Bar::simple_barline (Score_element*me,Real w, Real h)
{
- return lookup_l ()->filledbox (Box (Interval(0,w), Interval(-h/2, h/2)));
+ return me->lookup_l ()->filledbox (Box (Interval(0,w), Interval(-h/2, h/2)));
}
+MAKE_SCHEME_CALLBACK(Bar,before_line_breaking );
-GLUE_SCORE_ELEMENT(Bar,before_line_breaking );
SCM
-Bar::member_before_line_breaking ()
+Bar::before_line_breaking (SCM smob)
{
- SCM g = get_elt_property ("glyph");
+ Score_element*me=unsmob_element (smob);
+ Item * item = dynamic_cast<Item*> (me);
+
+ SCM g = me->get_elt_property ("glyph");
SCM orig = g;
- Direction bsd = break_status_dir ();
+ Direction bsd = item->break_status_dir ();
if (gh_string_p (g))
{
if (bsd)
if (!gh_string_p (g))
{
- set_elt_property ("molecule-callback", SCM_BOOL_T);
- set_extent_callback (0, X_AXIS);
+ me->set_elt_property ("molecule-callback", SCM_BOOL_T);
+ me->set_extent_callback (0, X_AXIS);
// leave y_extent for spanbar?
}
else if (! gh_equal_p (g, orig))
- set_elt_property ("glyph", g);
+ me->set_elt_property ("glyph", g);
return SCM_UNDEFINED;
}
+void
+Bar::set_interface (Score_element*me)
+{
+ me->set_elt_property ("interfaces",
+ gh_cons (ly_symbol2scm ("bar-interface"), me->get_elt_property ("interfaces")));
+}
+bool
+Bar::has_interface (Score_element*m)
+{
+ return m && m->has_interface (ly_symbol2scm ("bar-interface"));
+}
+
+
+MAKE_SCHEME_CALLBACK(Bar,get_staff_bar_size);
+SCM
+Bar::get_staff_bar_size (SCM smob)
+{
+ Score_element*me = unsmob_element (smob);
+ Real ss = Staff_symbol_referencer::staff_space (me);
+ SCM size = me->get_elt_property ("bar-size");
+ if (gh_number_p (size))
+ return gh_double2scm (gh_scm2double(size)*ss);
+ else
+ {
+ return gh_double2scm ((Staff_symbol_referencer::line_count (me) -1) * ss);
+ }
+}
{
if (beam_p_)
{
- if (to_boolean (info.elem_l_->get_elt_property("rest-interface")))
+ if (Rest::has_interface (info.elem_l_))
{
info.elem_l_->add_offset_callback (Beam::rest_collision_callback, Y_AXIS);
}
- else if (to_boolean (info.elem_l_->get_elt_property ("stem-interface")))
+ else if (Stem::has_interface (info.elem_l_))
{
- Stem *stem_l = dynamic_cast<Stem*> (info.elem_l_);
- if (stem_l->beam_l ())
+ Item *stem_l = dynamic_cast<Item*> (info.elem_l_);
+ if (Stem::beam_l (stem_l))
return;
bool stem_grace = stem_l->get_elt_property ("grace") == SCM_BOOL_T;
Beam::Beam (SCM s)
: Spanner (s)
{
- Pointer_group_interface g (this, "stems");
+ Score_element*me =this;
+
+ Pointer_group_interface g (me, "stems");
g.set_interface ();
set_elt_property ("height", gh_int2scm (0)); // ugh.
}
void
-Beam::add_stem (Stem*s)
+Beam::add_stem (Score_element*s)
{
- Pointer_group_interface gi (this, "stems");
+ Score_element*me =this;
+ Pointer_group_interface gi (me, "stems");
gi.add_element (s);
- s->add_dependency (this);
+ s->add_dependency (me);
- assert (!s->beam_l ());
- s->set_elt_pointer ("beam", self_scm_);
+ assert (!Stem::beam_l (s));
+ s->set_elt_property ("beam", self_scm_);
- add_bound_item (this, s);
+ add_bound_item (dynamic_cast<Spanner*> (me), dynamic_cast<Item*> (s));
}
int
Beam::get_multiplicity () const
{
+ Score_element*me =(Score_element*)this;
int m = 0;
- for (SCM s = get_elt_pointer ("stems"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = me->get_elt_property ("stems"); gh_pair_p (s); s = gh_cdr (s))
{
Score_element * sc = unsmob_element (gh_car (s));
- if (Stem * st = dynamic_cast<Stem*> (sc))
- m = m >? st->beam_count (LEFT) >? st->beam_count (RIGHT);
+ if (Stem::has_interface (sc))
+ m = m >? Stem::beam_count (sc,LEFT) >? Stem::beam_count (sc,RIGHT);
}
return m;
}
[Alternatively, stems could set its own directions, according to
their beam, during 'final-pre-processing'.]
*/
-GLUE_SCORE_ELEMENT(Beam,before_line_breaking);
+MAKE_SCHEME_CALLBACK(Beam,before_line_breaking);
SCM
-Beam::member_before_line_breaking ()
+Beam::before_line_breaking (SCM smob)
{
+
+ Score_element * beam = unsmob_element (smob);
+ Beam * me =dynamic_cast<Beam*> (beam);
+
// Why?
- if (visible_stem_count () < 2)
+ if (me->visible_stem_count () < 2)
{
warning (_ ("beam has less than two stems"));
}
- 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 (me->get_default_dir ());
- auto_knees ();
- set_stem_directions ();
- set_stem_shorten ();
+ me->auto_knees ();
+ me->set_stem_directions ();
+ me->set_stem_shorten ();
return SCM_EOL;
}
Drul_array<int> count;
count[UP] = count[DOWN] = 0;
Direction d = DOWN;
+ Spanner*me = (Spanner*)this;
+ Link_array<Item> stems=
+ Pointer_group_interface__extract_elements (me, (Item*)0, "stems");
- for (int i=0; i <stem_count (); i++)
+ for (int i=0; i <stems.size (); i++)
do { // HUH -- waar slaat dit op?
- Stem *s = stem (i);
+ Score_element *s = stems[i];
Direction sd = Directional_element_interface (s).get ();
int current = sd ? (1 + d * sd)/2
- : s->get_center_distance ((Direction)-d);
+ : Stem::get_center_distance (s, (Direction)-d);
if (current)
{
return to_dir (s);
/*
- If dir is not determined: get from paper
+ If dir is not determined: get default
*/
- return (Direction)(int)
- paper_l ()->get_var ("stem_default_neutral_direction");
+ return to_dir (get_elt_property ("default-neutral-direction"));
}
void
Beam::set_stem_directions ()
{
+ Link_array<Item> stems
+ =Pointer_group_interface__extract_elements (this, (Item*) 0, "stems");
Direction d = Directional_element_interface (this).get ();
- for (int i=0; i <stem_count (); i++)
+
+ for (int i=0; i <stems.size (); i++)
{
- Stem *s = stem (i);
+ Score_element *s = stems[i];
SCM force = s->remove_elt_property ("dir-forced");
if (!gh_boolean_p (force) || !gh_scm2bool (force))
Directional_element_interface (s).set (d);
{
bool knee_b = false;
int knee_y = 0;
- SCM gap = get_elt_property (gap_str);
- Direction d = Directional_element_interface (this).get ();
+ SCM gap = get_elt_property (gap_str.ch_C());
+ Spanner* me = this;
+
+ Direction d = Directional_element_interface (me).get ();
+ Link_array<Item> stems=
+ Pointer_group_interface__extract_elements (me, (Item*)0, "stems");
if (gh_number_p (gap))
{
int auto_gap_i = gh_scm2int (gap);
- for (int i=1; i < stem_count (); i++)
+ for (int i=1; i < stems.size (); i++)
{
- bool is_b = (bool)(calc_interstaff_dist (stem (i), this)
- - calc_interstaff_dist (stem (i-1), this));
- int l_y = (int)(stem (i-1)->head_positions()[d])
- + (int)calc_interstaff_dist (stem (i-1), this);
- int r_y = (int)(stem (i)->head_positions()[d])
- + (int)calc_interstaff_dist (stem (i), this);
+ bool is_b = (bool)(calc_interstaff_dist (stems[i], me)
+ - calc_interstaff_dist (stems[i-1], me));
+ int l_y = (int)(Stem::head_positions(stems[i-1])[d])
+ + (int)calc_interstaff_dist (stems[i-1], me);
+ int r_y = (int)(Stem::head_positions(stems[i])[d])
+ + (int)calc_interstaff_dist (stems[i], me);
int gap_i = r_y - l_y;
if ((abs (gap_i) >= auto_gap_i) && (!interstaff_b || is_b))
}
if (knee_b)
{
- for (int i=0; i < stem_count (); i++)
+ for (int i=0; i < stems.size (); i++)
{
- Item *s = stem(i);
- int y = (int)(stem (i)->head_positions()[d])
- + (int)calc_interstaff_dist (s, this);
-
+ Item *s = stems[i];
+ int y = (int)(Stem::head_positions(s)[d])
+ + (int)calc_interstaff_dist (s, me);
Directional_element_interface (s).set (y < knee_y ? UP : DOWN);
s->set_elt_property ("dir-forced", SCM_BOOL_T);
void
Beam::set_stem_shorten ()
{
+ Spanner*me = this;
if (!visible_stem_count ())
return;
int sz = scm_ilength (shorten);
- Staff_symbol_referencer_interface st (this);
- Real staff_space = st.staff_space ();
+ Real staff_space = Staff_symbol_referencer::staff_space (me);
SCM shorten_elt = scm_list_ref (shorten, gh_int2scm (multiplicity <? (sz - 1)));
Real shorten_f = gh_scm2double (shorten_elt) * staff_space;
if (forced_fraction < 1)
shorten_f /= 2;
- for (int i=0; i < stem_count (); i++)
+ Link_array<Item> stems=
+ Pointer_group_interface__extract_elements (me, (Item*)0, "stems");
+
+ for (int i=0; i < stems.size (); i++)
{
- Stem* s = stem (i);
- if (s->invisible_b ())
+ Item* s = stems[i];
+ if (Stem::invisible_b (s))
continue;
if (gh_number_p (s->get_elt_property ("shorten")))
s->set_elt_property ("shorten", gh_double2scm (shorten_f));
Set elt properties height and y-position if not set.
Adjust stem lengths to reach beam.
*/
-GLUE_SCORE_ELEMENT(Beam,after_line_breaking);
+MAKE_SCHEME_CALLBACK(Beam,after_line_breaking);
SCM
-Beam::member_after_line_breaking ()
+Beam::after_line_breaking (SCM smob)
{
+ Score_element * beam = unsmob_element (smob);
+ Beam * me =dynamic_cast<Beam*> (beam);
+
/* first, calculate y, dy */
Real y, dy;
- calc_default_position_and_height (&y, &dy);
- if (visible_stem_count ())
+ me->calc_default_position_and_height (&y, &dy);
+ if (me->visible_stem_count ())
{
- if (suspect_slope_b (y, dy))
+ if (me->suspect_slope_b (y, dy))
dy = 0;
- Real damped_dy = calc_slope_damping_f (dy);
- Real quantised_dy = quantise_dy_f (damped_dy);
+ Real damped_dy = me->calc_slope_damping_f (dy);
+ Real quantised_dy = me->quantise_dy_f (damped_dy);
y += (dy - quantised_dy) / 2;
dy = quantised_dy;
/*
until here, we used only stem_info, which acts as if dir=up
*/
- y *= Directional_element_interface (this).get ();
- dy *= Directional_element_interface (this).get ();
+ y *= Directional_element_interface (me).get ();
+ dy *= Directional_element_interface (me).get ();
+
- Staff_symbol_referencer_interface st (this);
- Real half_space = st.staff_space () / 2;
+ Real half_space = Staff_symbol_referencer::staff_space (me) / 2;
/* check for user-override of dy */
- SCM s = remove_elt_property ("height-hs");
+ SCM s = me->remove_elt_property ("height-hs");
if (gh_number_p (s))
{
dy = gh_scm2double (s) * half_space;
}
- set_elt_property ("height", gh_double2scm (dy));
+ me->set_elt_property ("height", gh_double2scm (dy));
/* check for user-override of y */
- s = remove_elt_property ("y-position-hs");
+ s = me->remove_elt_property ("y-position-hs");
if (gh_number_p (s))
{
y = gh_scm2double (s) * half_space;
else
{
/* we can modify y, so we should quantise y */
- Real y_shift = check_stem_length_f (y, dy);
+ Real y_shift = me->check_stem_length_f (y, dy);
y += y_shift;
- y = quantise_y_f (y, dy, 0);
- set_stem_length (y, dy);
- y_shift = check_stem_length_f (y, dy);
+ y = me->quantise_y_f (y, dy, 0);
+ me->set_stem_length (y, dy);
+ y_shift = me->check_stem_length_f (y, dy);
if (y_shift > half_space / 4)
{
*/
int quant_dir = 0;
if (abs (y_shift) > half_space / 2)
- quant_dir = sign (y_shift) * Directional_element_interface (this).get ();
- y = quantise_y_f (y, dy, quant_dir);
+ quant_dir = sign (y_shift) * Directional_element_interface (me).get ();
+ y = me->quantise_y_f (y, dy, quant_dir);
}
}
// UGH. Y is not in staff position unit?
// Ik dacht datwe daar juist van weg wilden?
- set_stem_length (y, dy);
- set_elt_property ("y-position", gh_double2scm (y));
-
+ me->set_stem_length (y, dy);
+ me->set_elt_property ("y-position", gh_double2scm (y));
return SCM_UNDEFINED;
}
void
Beam::calc_default_position_and_height (Real* y, Real* dy) const
{
+ Spanner*me = (Spanner*)this;
*y = 0;
*dy = 0;
if (visible_stem_count () <= 1)
return;
- Real first_ideal = first_visible_stem ()->calc_stem_info ().idealy_f_;
- if (first_ideal == last_visible_stem ()->calc_stem_info ().idealy_f_)
+ Real first_ideal = Stem::calc_stem_info (first_visible_stem ()).idealy_f_;
+ if (first_ideal == Stem::calc_stem_info (last_visible_stem ()).idealy_f_)
{
*dy = 0;
*y = first_ideal;
Array<Offset> ideals;
Real x0 = first_visible_stem ()->relative_coordinate (0, X_AXIS);
- for (int i=0; i < stem_count (); i++)
+ Link_array<Item> stems=
+ Pointer_group_interface__extract_elements (me, (Item*)0, "stems");
+
+ for (int i=0; i < stems.size (); i++)
{
- Stem* s = stem (i);
- if (s->invisible_b ())
+ Item* s = stems[i];
+ if (Stem::invisible_b (s))
continue;
ideals.push (Offset (s->relative_coordinate (0, X_AXIS) - x0,
- s->calc_stem_info ().idealy_f_));
+ Stem::calc_stem_info (s).idealy_f_));
}
Real dydx;
minimise_least_squares (&dydx, y, ideals); // duh, takes references
/*
steep slope running against lengthened stem is suspect
*/
- Real first_ideal = first_visible_stem ()->calc_stem_info ().idealy_f_;
- Real last_ideal = last_visible_stem ()->calc_stem_info ().idealy_f_;
+ Real first_ideal = Stem::calc_stem_info (first_visible_stem ()).idealy_f_;
+ Real last_ideal = Stem::calc_stem_info (last_visible_stem ()).idealy_f_;
Real lengthened = paper_l ()->get_var ("beam_lengthened");
Real steep = paper_l ()->get_var ("beam_steep_slope");
Real
Beam::calc_slope_damping_f (Real dy) const
{
- SCM damp = get_elt_property ("damping"); // remove?
- int damping = 1; // ugh.
- if (gh_number_p (damp))
- damping = gh_scm2int (damp);
+ SCM damp = get_elt_property ("damping");
+ int damping = gh_scm2int (damp);
if (damping)
{
}
Real
-Beam::calc_stem_y_f (Stem* s, Real y, Real dy) const
+Beam::calc_stem_y_f (Item* s, Real y, Real dy) const
{
+ Score_element*me = (Score_element*)this;
Real thick = gh_scm2double (get_elt_property ("beam-thickness"));
thick *= paper_l ()->get_var ("staffspace");
int beam_multiplicity = get_multiplicity ();
- int stem_multiplicity = (s->flag_i () - 2) >? 0;
+ int stem_multiplicity = (Stem::flag_i (s) - 2) >? 0;
Real interbeam_f = paper_l ()->interbeam_f (beam_multiplicity);
Real x0 = first_visible_stem ()->relative_coordinate (0, X_AXIS);
Real stem_y = (dy && dx ? (s->relative_coordinate (0, X_AXIS) - x0) / dx * dy : 0) + y;
/* knee */
- Direction dir = Directional_element_interface(this).get ();
+ Direction dir = Directional_element_interface(me).get ();
Direction sdir = Directional_element_interface (s).get ();
/* knee */
stem_y -= dir
* (thick / 2 + (beam_multiplicity - 1) * interbeam_f);
- Staff_symbol_referencer_interface me (s);
- Staff_symbol_referencer_interface last (last_visible_stem ());
+
// huh, why not for first visible?
- if (//(s != first_visible_stem ()) &&
- me.staff_symbol_l () != last.staff_symbol_l ())
- stem_y += Directional_element_interface (this).get ()
- * (beam_multiplicity - stem_multiplicity) * interbeam_f;
- }
+ if (Staff_symbol_referencer::staff_symbol_l (s)
+ != Staff_symbol_referencer::staff_symbol_l (last_visible_stem ()))
+ stem_y += Directional_element_interface (me).get ()
+ * (beam_multiplicity - stem_multiplicity) * interbeam_f;
+ }
+
return stem_y;
}
Real
Beam::check_stem_length_f (Real y, Real dy) const
{
+ Score_element * me = (Score_element*)this;
Real shorten = 0;
Real lengthen = 0;
- Direction dir = Directional_element_interface (this).get ();
-
- for (int i=0; i < stem_count (); i++)
+ Direction dir = Directional_element_interface (me).get ();
+
+ Link_array<Item> stems=
+ Pointer_group_interface__extract_elements (me, (Item*)0, "stems");
+
+ for (int i=0; i < stems.size(); i++)
{
- Stem* s = stem (i);
- if (s->invisible_b ())
+ Item* s = stems[i];
+ if (Stem::invisible_b (s))
continue;
Real stem_y = calc_stem_y_f (s, y, dy);
stem_y *= dir;
- Stem_info info = s->calc_stem_info ();
+ Stem_info info = Stem::calc_stem_info (s);
// if (0 > info.maxy_f_ - stem_y)
shorten = shorten <? info.maxy_f_ - stem_y;
void
Beam::set_stem_length (Real y, Real dy)
{
- Staff_symbol_referencer_interface st (this);
- Real half_space = st.staff_space ()/2;
- for (int i=0; i < stem_count (); i++)
+ Beam*me = this;
+
+ Real half_space = Staff_symbol_referencer::staff_space (me)/2;
+ Link_array<Item> stems=
+ Pointer_group_interface__extract_elements (me, (Item*)0, "stems");
+
+
+ for (int i=0; i < stems.size (); i++)
{
- Stem* s = stem (i);
- if (s->invisible_b ())
+ Item* s = stems[i];
+ if (Stem::invisible_b (s))
continue;
Real stem_y = calc_stem_y_f (s, y, dy);
/* caution: stem measures in staff-positions */
- s->set_stemend ((stem_y + calc_interstaff_dist (s, this)) / half_space);
+ Stem::set_stemend (s,(stem_y + calc_interstaff_dist (s, me)) / half_space);
}
}
Real
Beam::quantise_dy_f (Real dy) const
{
+ Score_element*me = (Score_element*)this;
Array<Real> a;
for (SCM s = scm_eval (ly_symbol2scm ("beam-height-quants")); s !=SCM_EOL; s = gh_cdr (s))
a.push (gh_scm2double (gh_car (s)));
if (a.size () <= 1)
return dy;
- Staff_symbol_referencer_interface st (this);
- Real staff_space = st.staff_space ();
+ Real staff_space = Staff_symbol_referencer::staff_space (me);
Interval iv = quantise_iv (a, abs (dy)/staff_space) * staff_space;
Real q = (abs (dy) - iv[SMALLER] <= iv[BIGGER] - abs (dy))
Beam::quantise_y_f (Real y, Real dy, int quant_dir)
{
int multiplicity = get_multiplicity ();
- Staff_symbol_referencer_interface st (this);
- Real staff_space = st.staff_space ();
+ Score_element*me = (Score_element*)this;
+
+ Real staff_space = Staff_symbol_referencer::staff_space (me);
SCM quants = scm_eval (gh_list (ly_symbol2scm ("beam-vertical-position-quants"),
gh_int2scm (multiplicity),
gh_double2scm (dy/staff_space),
if (a.size () <= 1)
return y;
- Real up_y = Directional_element_interface (this).get () * y;
+ Real up_y = Directional_element_interface (me).get () * y;
Interval iv = quantise_iv (a, up_y/staff_space) * staff_space;
Real q = up_y - iv[SMALLER] <= iv[BIGGER] - up_y
if (quant_dir)
q = iv[(Direction)quant_dir];
- return q * Directional_element_interface (this).get ();
+ return q * Directional_element_interface (me).get ();
}
void
Beam::set_beaming (Beaming_info_list *beaming)
{
+ Score_element*me = this;
+ Link_array<Score_element> stems=
+ Pointer_group_interface__extract_elements (me, (Score_element*)0, "stems");
+
Direction d = LEFT;
- for (int i=0; i < stem_count (); i++)
+ for (int i=0; i < stems.size(); i++)
{
do
{
- if (stem (i)->beam_count (d) == 0)
- stem (i)->set_beaming ( beaming->infos_.elem (i).beams_i_drul_[d],d);
+ if (Stem::beam_count (stems[i], d) == 0)
+ Stem::set_beaming ( stems[i], beaming->infos_.elem (i).beams_i_drul_[d],d);
}
while (flip (&d) != LEFT);
}
clean me up.
*/
Molecule
-Beam::stem_beams (Stem *here, Stem *next, Stem *prev) const
+Beam::stem_beams (Item *here, Item *next, Item *prev) const
{
+ Score_element*me = (Score_element*)this;
if ((next && !(next->relative_coordinate (0, X_AXIS) > here->relative_coordinate (0, X_AXIS))) ||
(prev && !(prev->relative_coordinate (0, X_AXIS) < here->relative_coordinate (0, X_AXIS))))
programming_error ("Beams are not left-to-right");
// UGH
Real nw_f;
- if (!here->first_head ())
+ if (!Stem::first_head (here))
nw_f = 0;
- else if (here->type_i ()== 1)
+ else if (Stem::type_i (here)== 1)
nw_f = paper_l ()->get_var ("wholewidth");
- else if (here->type_i () == 2)
+ else if (Stem::type_i (here) == 2)
nw_f = paper_l ()->get_var ("notewidth") * 0.8;
else
nw_f = paper_l ()->get_var ("quartwidth");
- Direction dir = Directional_element_interface (this).get ();
+ Direction dir = Directional_element_interface (me).get ();
/* half beams extending to the left. */
if (prev)
{
- int lhalfs= lhalfs = here->beam_count (LEFT) - prev->beam_count (RIGHT);
- int lwholebeams= here->beam_count (LEFT) <? prev->beam_count (RIGHT) ;
+ int lhalfs= lhalfs = Stem::beam_count (here,LEFT) - Stem::beam_count (prev,RIGHT);
+ int lwholebeams= Stem::beam_count (here,LEFT) <? Stem::beam_count (prev,RIGHT) ;
/*
Half beam should be one note-width,
but let's make sure two half-beams never touch
if (next)
{
- int rhalfs = here->beam_count (RIGHT) - next->beam_count (LEFT);
- int rwholebeams= here->beam_count (RIGHT) <? next->beam_count (LEFT) ;
+ int rhalfs = Stem::beam_count (here,RIGHT) - Stem::beam_count (next,LEFT);
+ int rwholebeams= Stem::beam_count (here,RIGHT) <? Stem::beam_count (next,LEFT) ;
Real w = next->relative_coordinate (0, X_AXIS) - here->relative_coordinate (0, X_AXIS);
Molecule a = lookup_l ()->beam (dydx, w + stemdx, thick);
for (; j < rwholebeams; j++)
{
Molecule b (a);
- b.translate (Offset (here->invisible_b () ? 0 : gap_f, -dir * bdy * j));
+ b.translate (Offset (Stem::invisible_b (here) ? 0 : gap_f, -dir * bdy * j));
rightbeams.add_molecule (b);
}
return leftbeams;
}
-GLUE_SCORE_ELEMENT(Beam,brew_molecule);
+MAKE_SCHEME_CALLBACK(Beam,brew_molecule);
SCM
-Beam::member_brew_molecule () const
+Beam::brew_molecule (SCM smob)
{
+ Score_element * beam = unsmob_element (smob);
+ Beam * me =dynamic_cast<Beam*> (beam);
+
Molecule mol;
- if (!stem_count ())
+ if (!gh_pair_p (me->get_elt_property ("stems")))
return SCM_EOL;
Real x0,dx;
- if (visible_stem_count ())
+ Link_array<Item>stems =
+ Pointer_group_interface__extract_elements ((Beam*) me, (Item*) 0, "stems");
+ if (me->visible_stem_count ())
{
- x0 = first_visible_stem ()->relative_coordinate (0, X_AXIS);
- dx = last_visible_stem ()->relative_coordinate (0, X_AXIS) - x0;
+ x0 = me->first_visible_stem ()->relative_coordinate (0, X_AXIS);
+ dx = me->last_visible_stem ()->relative_coordinate (0, X_AXIS) - x0;
}
else
{
- x0 = stem (0)->relative_coordinate (0, X_AXIS);
- dx = stem_top ()->relative_coordinate (0, X_AXIS) - x0;
+ x0 = stems[0]->relative_coordinate (0, X_AXIS);
+ dx = stems.top()->relative_coordinate (0, X_AXIS) - x0;
}
- Real dy = gh_scm2double (get_elt_property ("height"));
+ Real dy = gh_scm2double (me->get_elt_property ("height"));
Real dydx = dy && dx ? dy/dx : 0;
- Real y = gh_scm2double (get_elt_property ("y-position"));
- for (int j=0; j <stem_count (); j++)
+ Real y = gh_scm2double (me->get_elt_property ("y-position"));
+
+
+ for (int j=0; j <stems.size (); j++)
{
- Stem *i = stem (j);
- Stem * prev = (j > 0)? stem (j-1) : 0;
- Stem * next = (j < stem_count ()-1) ? stem (j+1) :0;
+ Item *i = stems[j];
+ Item * prev = (j > 0)? stems[j-1] : 0;
+ Item * next = (j < stems.size()-1) ? stems[j+1] :0;
- Molecule sb = stem_beams (i, next, prev);
+ Molecule sb = me->stem_beams (i, next, prev);
Real x = i->relative_coordinate (0, X_AXIS)-x0;
sb.translate (Offset (x, x * dydx + y));
mol.add_molecule (sb);
}
mol.translate_axis (x0
- - get_bound (LEFT)->relative_coordinate (0, X_AXIS), X_AXIS);
+ - me->get_bound (LEFT)->relative_coordinate (0, X_AXIS), X_AXIS);
return mol.create_scheme ();
}
int
Beam::forced_stem_count () const
{
+ Score_element* me = (Score_element*)this;
+ Link_array<Item>stems =
+ Pointer_group_interface__extract_elements ((Beam*) me, (Item*) 0, "stems");
int f = 0;
- for (int i=0; i < stem_count (); i++)
+ for (int i=0; i < stems.size (); i++)
{
- Stem *s = stem (i);
+ Item *s = stems[i];
- if (s->invisible_b ())
+ if (Stem::invisible_b (s))
continue;
- if (((int)s->chord_start_f ())
- && (s->get_direction () != s->get_default_dir ()))
+ if (((int)Stem::chord_start_f (s))
+ && (Stem::get_direction (s ) != Stem::get_default_dir (s )))
f++;
}
return f;
}
-/*
- TODO: Fix this class. This is wildly inefficient.
- And it sux. Yet another array/list 'interface'.
- */
-Stem *
-Beam::stem (int i) const
-{
- return Pointer_group_interface__extract_elements ((Beam*) this, (Stem*) 0, "stems")[i];
-}
-int
-Beam::stem_count () const
-{
- Pointer_group_interface gi (this, "stems");
- return gi.count ();
-}
-Stem*
-Beam::stem_top () const
-{
- SCM s = get_elt_pointer ("stems");
-
- return gh_pair_p (s) ? dynamic_cast<Stem*> (unsmob_element (gh_car (s))) : 0;
-}
-/* burp */
+/* TODO:
+ use filter and standard list functions.
+ */
int
Beam::visible_stem_count () const
{
+ Score_element * me = (Score_element*)this;
+ Link_array<Item>stems =
+ Pointer_group_interface__extract_elements (me, (Item*) 0, "stems");
int c = 0;
- for (int i = 0; i < stem_count (); i++)
+ for (int i = stems.size (); i--;)
{
- if (!stem (i)->invisible_b ())
+ if (!Stem::invisible_b (stems[i]))
c++;
}
return c;
}
-Stem*
-Beam::first_visible_stem () const
+Item*
+Beam::first_visible_stem() const
{
- for (int i = 0; i < stem_count (); i++)
+ Score_element * me = (Score_element*)this;
+ Link_array<Item>stems =
+ Pointer_group_interface__extract_elements ((Beam*) me, (Item*) 0, "stems");
+
+ for (int i = 0; i < stems.size (); i++)
{
- Stem* s = stem (i);
- if (!s->invisible_b ())
- return s;
+ if (!Stem::invisible_b (stems[i]))
+ return stems[i];
}
return 0;
}
-Stem*
-Beam::last_visible_stem () const
+Item*
+Beam::last_visible_stem() const
{
- for (int i = stem_count (); i > 0; i--)
+ Score_element * me = (Score_element*)this;
+ Link_array<Item>stems =
+ Pointer_group_interface__extract_elements ((Beam*) me, (Item*) 0, "stems");
+ for (int i = stems.size (); i--;)
{
- Stem* s = stem (i - 1);
- if (!s->invisible_b ())
- return s;
+ if (!Stem::invisible_b (stems[i]))
+ return stems[i];
}
return 0;
}
{
assert (a == Y_AXIS);
- Score_element * st = unsmob_element (rest->get_elt_pointer ("stem"));
- Stem * stem = dynamic_cast<Stem*> (st);
+ Score_element * st = unsmob_element (rest->get_elt_property ("stem"));
+ Score_element * stem = st;
if (!stem)
return 0.0;
- Beam * beam = dynamic_cast<Beam*> (unsmob_element (stem->get_elt_pointer ("beam")));
+ Beam * beam = dynamic_cast<Beam*> (unsmob_element (stem->get_elt_property ("beam")));
if (!beam || !beam->visible_stem_count ())
return 0.0;
if (gh_number_p (s))
beam_y = gh_scm2double (s);
- Real x0 = beam->first_visible_stem ()->relative_coordinate (0, X_AXIS);
- Real dx = beam->last_visible_stem ()->relative_coordinate (0, X_AXIS) - x0;
+ Real x0 = beam->first_visible_stem()->relative_coordinate (0, X_AXIS);
+ Real dx = beam->last_visible_stem()->relative_coordinate (0, X_AXIS) - x0;
Real dydx = beam_dy && dx ? beam_dy/dx : 0;
- Direction d = stem->get_direction ();
+ Direction d = Stem::get_direction (stem);
Real beamy = (stem->relative_coordinate (0, X_AXIS) - x0) * dydx + beam_y;
- Staff_symbol_referencer_interface si (rest);
-
- Real staff_space = si.staff_space ();
+ Real staff_space = Staff_symbol_referencer::staff_space (rest);
Real rest_dim = rest->extent (Y_AXIS)[d]*2.0 / staff_space ;
Real minimum_dist
Real dist =
minimum_dist + -d * (beamy - rest_dim) >? 0;
- int stafflines = si.line_count ();
+ int stafflines = Staff_symbol_referencer::line_count (rest);
// move discretely by half spaces.
int discrete_dist = int (ceil (dist));
#include "engraver.hh"
#include "protected-scm.hh"
#include "break-align-item.hh"
+#include "item.hh"
#include "align-interface.hh"
#include "axis-group-interface.hh"
-#include "dimension-cache.hh"
+
class Break_align_engraver : public Engraver
{
- Break_align_item *align_l_;
+ Item *align_l_;
Protected_scm column_alist_;
protected:
virtual void acknowledge_element(Score_element_info i);
Break_align_engraver::add_column (SCM smob)
{
Score_element * e = unsmob_element (smob);
- Align_interface (align_l_).add_element (e);
+ Break_align_item::add_element (align_l_,e);
typeset_element (e);
}
if (!align_l_)
{
- align_l_ = new Break_align_item (get_property ("basicBreakAlignProperties"));
+ align_l_ = new Item (get_property ("basicBreakAlignProperties"));
+ Break_align_item::set_interface (align_l_);
announce_element (Score_element_info (align_l_,0));
SCM edge_sym = ly_symbol2scm ("Left_edge_item");
*/
edge->set_extent_callback (Score_element::point_dimension_callback,X_AXIS);
- align_l_->set_elt_pointer ("group-center-element", edge->self_scm_);
+ align_l_->set_elt_property ("group-center-element", edge->self_scm_);
announce_element (Score_element_info(edge, 0));
column_alist_ = scm_assoc_set_x (column_alist_, edge_sym, edge->self_scm_);
}
else
{
- group = new Item (SCM_EOL);
+ group = new Item (get_property ("basicBreakAlignGroupProperties"));
- Axis_group_interface (group).set_interface ();
- Axis_group_interface (group).set_axes (X_AXIS,X_AXIS);
+ Axis_group_interface::set_interface (group);
+ Axis_group_interface::set_axes (group, X_AXIS,X_AXIS);
group->set_elt_property ("break-align-symbol", align_name);
group->set_parent (align_l_, Y_AXIS);
announce_element (Score_element_info (group, 0));
column_alist_ = scm_assoc_set_x (column_alist_, align_name, group->self_scm_);
}
- Axis_group_interface (group).add_element (item_l);
+ Axis_group_interface::add_element (group, item_l);
}
}
(c) 1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
*/
+
+
#include <math.h>
#include <libc-extension.hh>
#include "side-position-interface.hh"
+#include "axis-group-interface.hh"
#include "warn.hh"
#include "lily-guile.hh"
#include "break-align-item.hh"
#include "dimensions.hh"
#include "paper-def.hh"
#include "paper-column.hh"
-
#include "group-interface.hh"
#include "align-interface.hh"
-GLUE_SCORE_ELEMENT(Break_align_item,before_line_breaking);
+MAKE_SCHEME_CALLBACK(Break_align_item,before_line_breaking);
+
SCM
-Break_align_item::member_before_line_breaking ()
+Break_align_item::before_line_breaking (SCM smob)
+{
+ Score_element* me = unsmob_element (smob);
+ do_alignment (me);
+ return SCM_UNDEFINED;
+}
+
+Real
+Break_align_item::alignment_callback (Score_element*c, Axis a)
{
- if (break_status_dir() == LEFT)
+ assert (a == X_AXIS);
+ Score_element *par = c->parent_l (a);
+ if (par && !to_boolean (par->get_elt_property ("break-alignment-done")))\
{
- set_elt_property ("self-alignment-X", gh_int2scm (RIGHT));
+ par->set_elt_property ("break-alignment-done", SCM_BOOL_T);
+ Break_align_item::do_alignment (par);
+ }
+
+ return 0.0;
+}
+
+void
+Break_align_item::add_element (Score_element*me, Score_element *toadd)
+{
+ toadd->add_offset_callback (alignment_callback, X_AXIS);
+ Axis_group_interface::add_element (me, toadd);
+}
+
+void
+Break_align_item::do_alignment (Score_element *me)
+{
+ Item * item = dynamic_cast<Item*> (me);
+ Item *column = item->column_l ();
+ if (item->break_status_dir() == LEFT)
+ {
+ me->set_elt_property ("self-alignment-X", gh_int2scm (RIGHT));
}
else
{
- add_offset_callback (Align_interface::center_on_element, X_AXIS);
+ me->add_offset_callback (Align_interface::center_on_element, X_AXIS);
}
-
-
- Real interline= paper_l ()->get_var ("interline");
+ Real interline= me->paper_l ()->get_var ("interline");
Link_array<Score_element> elems;
Link_array<Score_element> all_elems
- = Pointer_group_interface__extract_elements (this, (Score_element*)0,
- "elements");
+ = Pointer_group_interface__extract_elements (me, (Score_element*)0,
+ "elements");
for (int i=0; i < all_elems.size(); i++)
{
}
if (!elems.size ())
- return SCM_UNDEFINED;
+ return;
SCM symbol_list = SCM_EOL;
Array<Real> dists;
symbol_list = gh_cdr (scm_reverse (symbol_list));
for (int i=0; i <elems.size()-1; i++)
{
- String sym_str = ly_symbol2string (gh_car (symbol_list));
- elems[i]->set_elt_property (sym_str,
+ elems[i]->set_elt_property (gh_car (symbol_list),
scm_cons (gh_double2scm (0),
gh_double2scm (dists[i+1])));
/*
Force callbacks for alignment to be called
- */
- Real unused = elems[0]->relative_coordinate (this, X_AXIS);
- Real pre_space = elems[0]->relative_coordinate (column_l (), X_AXIS);
+ */
+ Align_interface::do_side_processing (me, X_AXIS);
+
+ Real pre_space = elems[0]->relative_coordinate (column, X_AXIS);
Real xl = elems[0]->extent (X_AXIS)[LEFT];
if (!isinf (xl))
programming_error ("Infinity reached. ");
Real xr = elems.top ()->extent (X_AXIS)[RIGHT];
- Real spring_len = elems.top ()->relative_coordinate (column_l (), X_AXIS);
+ Real spring_len = elems.top ()->relative_coordinate (column, X_AXIS);
if (!isinf (xr))
spring_len += xr;
else
The pairs are in the format of an interval (ie. CAR < CDR).
*/
- column_l ()->set_elt_property ("extra-space",
- scm_cons (gh_double2scm (pre_space),
- gh_double2scm (spring_len)));
+ column->set_elt_property ("extra-space",
+ scm_cons (gh_double2scm (pre_space),
+ gh_double2scm (spring_len)));
- column_l ()->set_elt_property ("stretch-distance",
- gh_cons (gh_double2scm (-dists[0]),
- gh_double2scm (stretch_distance)));
+ column->set_elt_property ("stretch-distance",
+ gh_cons (gh_double2scm (-dists[0]),
+ gh_double2scm (stretch_distance)));
- return SCM_UNDEFINED;
}
-Break_align_item::Break_align_item (SCM s)
- : Item (s)
-{
- set_elt_property ("stacking-dir" , gh_int2scm (RIGHT));
- Align_interface (this).set_interface ();
- Align_interface (this).set_axis (X_AXIS);
+void
+Break_align_item::set_interface (Score_element*me)
+{
+ Align_interface::set_interface (me);
+ Align_interface::set_axis (me,X_AXIS);
- add_offset_callback (Side_position_interface::aligned_on_self, X_AXIS);
+ me->add_offset_callback (Side_position::aligned_on_self, X_AXIS);
}
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Breathing_sign,brew_molecule);
+MAKE_SCHEME_CALLBACK(Breathing_sign,brew_molecule);
SCM
Breathing_sign::brew_molecule (SCM smob)
{
- Score_element * sc = unsmob_element (smob);
- Staff_symbol_referencer_interface si (sc);
-
- Real space = si.staff_space();
+ Score_element * me = unsmob_element (smob);
+ Real space = Staff_symbol_referencer::staff_space (me);
// todo: cfg'able.
Interval i1(0, space / 6), i2(-space / 2, space / 2);
Box b(i1, i2);
- return sc->lookup_l()->filledbox(b).create_scheme ();
+ return me->lookup_l()->filledbox(b).create_scheme ();
}
Real
{
Score_element * me = (Score_element*)b;
- Real space = Staff_symbol_referencer_interface (b).staff_space();
+ Real space = Staff_symbol_referencer::staff_space (b);
Direction d = Directional_element_interface (b). get ();
if (!d)
{
void
Breathing_sign::set_interface (Score_element *b)
{
- Staff_symbol_referencer_interface::set_interface (b);
+ Staff_symbol_referencer::set_interface (b);
b->add_offset_callback (Breathing_sign::offset_callback,Y_AXIS);
}
return mol;
}
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Chord_name,brew_molecule);
+MAKE_SCHEME_CALLBACK(Chord_name,brew_molecule);
SCM
Chord_name::brew_molecule (SCM smob)
#include "musical-request.hh"
#include "warn.hh"
#include "misc.hh"
+#include "note-head.hh"
/**
This acknowledges repeated music with "tremolo" style. It typesets
{
if (beam_p_)
{
- if (Stem* s = dynamic_cast<Stem *> (info.elem_l_))
+ if (Stem::has_interface (info.elem_l_))
{
- int f = s->flag_i ();
+ Score_element * s = info.elem_l_;
+ int f = Stem::flag_i (s);
f = (f > 2) ? f - 2 : 1;
- s->set_beaming (f, LEFT);
- s->set_beaming (f, RIGHT);
+ Stem::set_beaming (s, f, LEFT);
+ Stem::set_beaming (s, f, RIGHT);
/*
URG: this sets the direction of the Stem s.
--hwn.
*/
SCM d = s->get_elt_property ("direction");
- if (s->type_i () != 1)
+ if (Stem::type_i (s ) != 1)
{
- int gap_i =s->flag_i () - ((s->type_i () >? 2) - 2);
+ int gap_i =Stem::flag_i (s ) - ((Stem::type_i (s ) >? 2) - 2);
beam_p_->set_elt_property ("beam-gap", gh_int2scm(gap_i));
}
s->set_elt_property ("direction", d);
::warning (s);
}
}
- if (to_boolean (info.elem_l_->get_elt_property ("note-head-interface")))
+ if (Note_head::has_interface (info.elem_l_))
{
info.elem_l_->set_elt_property ("duration-log", gh_int2scm (intlog2 (note_head_i_)));
}
/*
FIXME: should use SCM iso. arrays and have-to-delete pointers.
+
+ FIXME: this contains memleaks.
*/
-
/*
construct from parser output
*/
#include <ctype.h>
+#include "key-item.hh"
+#include "local-key-item.hh"
+#include "bar.hh"
+#include "note-head.hh"
#include "staff-symbol-referencer.hh"
#include "debug.hh"
#include "command-request.hh"
Item * item =dynamic_cast <Item *> (info.elem_l_);
if (item)
{
- if (to_boolean (info.elem_l_->get_elt_property ("bar-interface"))
+ if (Bar::has_interface (info.elem_l_)
&& 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")))
+ if (Note_head::has_interface (item)
+ || Local_key_item::has_interface (item))
{
- Staff_symbol_referencer_interface si (item);
- si.set_position (int (si.position_f ()) + c0_position_i_);
+ int p = int (Staff_symbol_referencer::position_f (item)) + c0_position_i_;
+ Staff_symbol_referencer::set_position (item,p);
+
}
- else if (to_boolean (item->get_elt_property ("key-item-interface")))
+ else if (Key_item::has_interface (item))
{
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::set_interface (c);
+ Staff_symbol_referencer::set_interface (c);
clef_p_ = c;
}
- Staff_symbol_referencer_interface si(clef_p_);
-
- si.set_position (clef_position_i_);
+ Staff_symbol_referencer::set_position(clef_p_, clef_position_i_);
if (octave_dir_)
{
Item * g = new Item (get_property ("basicOctavateEightProperties"));
- Side_position_interface spi (g);
- spi.set_axis (Y_AXIS);
- spi.add_support (clef_p_);
+ Side_position::set_axis (g,Y_AXIS);
+ Side_position::add_support (g,clef_p_);
+
g->set_parent (clef_p_, Y_AXIS);
g->set_parent (clef_p_, X_AXIS);
- g->add_offset_callback (Side_position_interface::aligned_on_self, X_AXIS);
- g->add_offset_callback (Side_position_interface::centered_on_parent, X_AXIS);
+ g->add_offset_callback (Side_position::aligned_on_self, X_AXIS);
+ g->add_offset_callback (Side_position::centered_on_parent, X_AXIS);
g->set_elt_property ("direction", gh_int2scm (octave_dir_));
octavate_p_ = g;
announce_element (Score_element_info (octavate_p_, clef_req_l_));
*/
-#include "clef-item.hh"
+#include "clef.hh"
#include "string.hh"
#include "molecule.hh"
#include "item.hh"
-
-/**
- Set a clef in a staff.
-
- properties:
-
- non-default -- not set because of existence of a bar?
-
- change -- is this a change clef (smaller size)?
-
- glyph -- a string determining what glyph is typeset
-
- */
-struct Clef
-{
- static SCM before_line_breaking (SCM);
-};
-
-
/*
FIXME: should use symbol.
*/
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Clef,before_line_breaking);
+MAKE_SCHEME_CALLBACK(Clef,before_line_breaking);
SCM
Clef::before_line_breaking (SCM smob)
{
return SCM_UNDEFINED;
}
+bool
+Clef::has_interface (Score_element* me)
+{
+ return me->has_interface (ly_symbol2scm ("clef-interface"));
+}
+
+
+void
+Clef::set_interface (Score_element* me)
+{
+ me->set_interface (ly_symbol2scm ("clef-interface"));
+}
#include "note-column.hh"
#include "collision.hh"
-#include "dimension-cache.hh"
+
#include "engraver.hh"
#include "axis-group-interface.hh"
if (!col_p_)
{
col_p_ = new Item (get_property ("basicCollisionProperties"));
- Axis_group_interface (col_p_).set_interface ();
- Axis_group_interface (col_p_).set_axes (X_AXIS, Y_AXIS);
+ Axis_group_interface::set_interface (col_p_);
+ Axis_group_interface::set_axes (col_p_, X_AXIS, Y_AXIS);
announce_element (Score_element_info (col_p_,0));
}
for (int i=0; i< note_column_l_arr_.size (); i++)
- Collision (col_p_).add_column (note_column_l_arr_[i]);
+ Collision::add_column (col_p_,note_column_l_arr_[i]);
}
void
#include "item.hh"
void
-Collision::add_column (Note_column* ncol_l)
+Collision::add_column (Score_element*me,Note_column* ncol_l)
{
ncol_l->add_offset_callback (force_shift_callback, X_AXIS);
- Axis_group_interface (elt_l_).add_element (ncol_l);
- elt_l_->add_dependency (ncol_l);
+ Axis_group_interface::add_element (me, ncol_l);
+ me->add_dependency (ncol_l);
}
Real
/*
ugh. the way DONE is done is not clean
*/
- if (!unsmob_element (me->get_elt_pointer ("done")))
+ if (!unsmob_element (me->get_elt_property ("done")))
{
- me->set_elt_pointer ("done", me->self_scm_);
+ me->set_elt_property ("done", me->self_scm_);
do_shifts (me);
}
Drul_array<Array<int> > shifts;
SCM tups = SCM_EOL;
- SCM s = me->get_elt_pointer ("elements");
+ SCM s = me->get_elt_property ("elements");
for (; gh_pair_p (s); s = gh_cdr (s))
{
SCM car = gh_car (s);
/*
TODO.
*/
- Rhythmic_head * nu_l= cu_l->first_head();
- Rhythmic_head * nd_l = cd_l->first_head();
+ Score_element * nu_l= cu_l->first_head();
+ Score_element * 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];
bool merge =
downpos == uppos
- && nu_l->balltype_i () == nd_l->balltype_i ();
+ && Rhythmic_head::balltype_i (nu_l) == Rhythmic_head::balltype_i (nd_l);
if (!to_boolean (me->get_elt_property ("merge-differently-dotted")))
- merge = merge && nu_l->dot_count () == nd_l->dot_count ();
+ merge = merge && Rhythmic_head::dot_count (nu_l) == Rhythmic_head::dot_count (nd_l);
/*
notes are close, but can not be merged. Shift
{
SCM tups = SCM_EOL;
- SCM s = me->get_elt_pointer ("elements");
+ SCM s = me->get_elt_property ("elements");
for (; gh_pair_p (s); s = gh_cdr (s))
{
Score_element * se = unsmob_element (gh_car (s));
-Collision::Collision (Score_element* c)
-{
- elt_l_ = c;
-}
void
Crescendo::set_interface (Score_element*s)
{
- s->set_elt_pointer ("dynamic-drul", gh_cons (SCM_UNDEFINED, SCM_UNDEFINED));
+ s->set_elt_property ("dynamic-drul", gh_cons (SCM_UNDEFINED, SCM_UNDEFINED));
}
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Crescendo,brew_molecule);
+MAKE_SCHEME_CALLBACK(Crescendo,brew_molecule);
SCM
Crescendo::brew_molecule (SCM smob)
{
{
Real interstaff = 0.0;
Score_element *common = item->common_refpoint (span, Y_AXIS);
- Align_interface align(common);
- if (align.has_interface_b () && align.axis() == Y_AXIS)
+
+ if (Align_interface::has_interface (common) && Align_interface::axis(common) == Y_AXIS)
{
SCM threshold = common->get_elt_property ("threshold");
if (!gh_pair_p (threshold)
note_refpoint = note_refpoint->parent_l (Y_AXIS);
int span_prio =
- align.get_count ((Score_element*) dynamic_cast<Score_element const*> (span_refpoint));
+ Align_interface::get_count (common,(Score_element*) dynamic_cast<Score_element const*> (span_refpoint));
int item_prio =
- align.get_count ((Score_element*) dynamic_cast<Score_element const *> (note_refpoint));
+ Align_interface::get_count (common,(Score_element*) dynamic_cast<Score_element const *> (note_refpoint));
/*
our staff is lower -> interstaff *= -1
}
bool
-Directional_element_interface::has_interface_b () const
+Directional_element_interface::has_interface () const
{
return isdir_b (elt_l_->get_elt_property ("direction"));
}
class Dot_column_engraver : public Engraver
{
Score_element *dotcol_p_ ;
- Link_array<Rhythmic_head> head_l_arr_;
+ Link_array<Item> head_l_arr_;
public:
VIRTUAL_COPY_CONS(Translator);
Dot_column_engraver();
void
Dot_column_engraver::acknowledge_element (Score_element_info info)
{
- Score_element *d = unsmob_element (info.elem_l_->get_elt_pointer ("dot"));
+ Score_element *d = unsmob_element (info.elem_l_->get_elt_property ("dot"));
if (d)
{
if (!dotcol_p_)
dotcol_p_ = new Item(get_property ("basicDotColumnProperties"));
Dot_column::set_interface (dotcol_p_);
- Side_position_interface (dotcol_p_).set_axis (X_AXIS);
- Side_position_interface (dotcol_p_).set_direction (RIGHT);
+ Side_position::set_axis (dotcol_p_, X_AXIS);
+ Side_position::set_direction (dotcol_p_, RIGHT);
announce_element (Score_element_info (dotcol_p_, 0));
}
void
-Dot_column::add_head (Score_element * dc, Score_element *rh)
+Dot_column::add_head (Score_element * me, Score_element *rh)
{
- Score_element * d = unsmob_element (rh->get_elt_pointer ("dot"));
+ Score_element * d = unsmob_element (rh->get_elt_property ("dot"));
if (d)
{
- Side_position_interface (dc).add_support (rh);
+ Side_position::add_support (me,rh);
- Pointer_group_interface gi (dc, "dots");
+ Pointer_group_interface gi (me, "dots");
gi.add_element (d);
d->add_offset_callback (force_shift_callback , Y_AXIS);
- Axis_group_interface (dc).add_element (d);
+ Axis_group_interface::add_element (me, d);
}
}
-int
-Dot_column::compare (Score_element * const &d1, Score_element * const &d2)
-{
- Staff_symbol_referencer_interface s1(d1);
- Staff_symbol_referencer_interface s2(d2);
-
- return int (s1.position_f () - s2.position_f ());
-}
void
-Dot_column::set_interface (Score_element* dc)
+Dot_column::set_interface (Score_element* me)
{
- dc->set_elt_pointer ("dots", SCM_EOL);
- Directional_element_interface (dc).set (RIGHT);
+ me->set_elt_property ("dots", SCM_EOL);
+ Directional_element_interface (me).set (RIGHT);
- Axis_group_interface (dc).set_interface ();
- Axis_group_interface (dc).set_axes(X_AXIS,X_AXIS);
+ Axis_group_interface::set_interface (me);
+ Axis_group_interface::set_axes (me, X_AXIS,X_AXIS);
}
/*
{
assert (a == Y_AXIS);
Score_element * me = dot->parent_l (X_AXIS);
- SCM dots = me->get_elt_pointer ("dots");
+ SCM dots = me->get_elt_property ("dots");
do_shifts (dots);
return 0.0;
}
l = gh_cdr (l);
}
- dots.sort (Dot_column::compare);
+ dots.sort (compare_position);
if (dots.size () < 2)
return SCM_UNDEFINED;
int conflicts = 0;
for (int i=0; i < dots.size (); i++)
{
- Real p = Staff_symbol_referencer_interface (dots[i]).position_f ();
+ Real p = Staff_symbol_referencer::position_f (dots[i]);
for (int j=0; j < taken_posns.size (); j++)
{
if (taken_posns[j] == (int) p)
for (int i=0; i < dots.size (); pos += 2, i++)
{
Score_element * d = dots[i];
- Staff_symbol_referencer_interface (d).set_position(pos);
+ Staff_symbol_referencer::set_position (d,pos);
}
return SCM_UNDEFINED;
}
+
+bool
+Dot_column::has_interface (Score_element*m)
+{
+ return m && m->has_interface (ly_symbol2scm ("dot-column-interface"));
+}
if (!Directional_element_interface (me).get ())
Directional_element_interface (me).set (UP);
- Staff_symbol_referencer_interface si (me);
- int pos = int (si.position_f ());
+
+ int pos = int (Staff_symbol_referencer::position_f (me));
if (!(pos % 2))
- return si.staff_space () / 2.0 * Directional_element_interface (me).get ();
+ return Staff_symbol_referencer::staff_space (me) / 2.0 * Directional_element_interface (me).get ();
}
return 0.0;
}
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Dots,brew_molecule);
+MAKE_SCHEME_CALLBACK(Dots,brew_molecule);
SCM
Dots::brew_molecule (SCM d)
{
{
line_spanner_ = new Spanner (get_property ("basicDynamicLineSpannerProperties"));
- Side_position_interface (line_spanner_).set_axis (Y_AXIS);
- Axis_group_interface (line_spanner_).set_interface ();
- Axis_group_interface (line_spanner_).set_axes (Y_AXIS, Y_AXIS);
+ Side_position::set_axis (line_spanner_, Y_AXIS);
+ Axis_group_interface::set_interface (line_spanner_);
+ Axis_group_interface::set_axes (line_spanner_, Y_AXIS, Y_AXIS);
announce_element (Score_element_info
(line_spanner_,
text_req_l_ ? text_req_l_ : accepted_spanreqs_drul_[START]));
if (Direction d=text_req_l_->get_direction ())
Directional_element_interface (line_spanner_).set (d);
- Axis_group_interface (line_spanner_).add_element (text_p_);
+ Axis_group_interface::add_element (line_spanner_, text_p_);
- text_p_->add_offset_callback (Side_position_interface::aligned_on_self,
+ text_p_->add_offset_callback (Side_position::aligned_on_self,
Y_AXIS);
announce_element (Score_element_info (text_p_, text_req_l_));
}
if (text_p_)
{
- index_set_cell (cresc_p_->get_elt_pointer ("dynamic-drul"),
+ index_set_cell (cresc_p_->get_elt_property ("dynamic-drul"),
LEFT, text_p_->self_scm_);
if (finished_cresc_p_)
- index_set_cell (finished_cresc_p_->get_elt_pointer ("dynamic-drul"),
+ index_set_cell (finished_cresc_p_->get_elt_property ("dynamic-drul"),
RIGHT, text_p_->self_scm_);
}
- Axis_group_interface (line_spanner_).add_element (cresc_p_);
+ Axis_group_interface::add_element (line_spanner_, cresc_p_);
cresc_p_->set_elt_property ("self-alignment-Y", gh_int2scm (0));
cresc_p_->add_offset_callback
- (Side_position_interface::aligned_on_self, Y_AXIS);
+ (Side_position::aligned_on_self, Y_AXIS);
announce_element (Score_element_info (cresc_p_, accepted_spanreqs_drul_[START]));
}
}
}
if (finished_line_spanner_)
{
- Side_position_interface (finished_line_spanner_).add_staff_support ();
+ Side_position::add_staff_support (finished_line_spanner_);
if (!finished_line_spanner_->get_bound (LEFT))
{
{
if (line_spanner_)
{
- Side_position_interface (line_spanner_).add_support (n);
+ Side_position::add_support (line_spanner_,n);
add_bound_item (line_spanner_,n);
}
}
Extender_engraver::acknowledge_element (Score_element_info i)
{
// -> text_item
- if (dynamic_cast<Item*> (i.elem_l_)
- && to_boolean (i.elem_l_->get_elt_property ("text-item-interface")))
+ if (i.elem_l_->has_interface (ly_symbol2scm("text-item-interface")))
+
{
current_lyric_l_ = i.elem_l_;
if (extender_p_
#include "paper-column.hh"
#include "paper-def.hh"
-Grace_align_item::Grace_align_item (SCM s)
- : Item (s)
+void
+Grace_align_item::set_interface (Score_element*me)
{
- set_elt_property ("stacking-dir", gh_int2scm (RIGHT));
- Align_interface (this).set_interface();
- Align_interface (this).set_axis (X_AXIS);
+ me->set_interface (ly_symbol2scm ("grace-align-interface"));
+ me->set_elt_property ("stacking-dir", gh_int2scm (RIGHT));
+ Align_interface::set_interface(me);
+ Align_interface::set_axis (me,X_AXIS);
}
/*
TODO: cfg-able
*/
-GLUE_SCORE_ELEMENT(Grace_align_item,before_line_breaking);
+MAKE_SCHEME_CALLBACK(Grace_align_item,before_line_breaking);
SCM
-Grace_align_item::member_before_line_breaking ()
+Grace_align_item::before_line_breaking (SCM smob)
{
+ Score_element*me = unsmob_element (smob);
Real nhw = // lookup_l ()->notehead (2, "")..extent (X_AXIS).length();
- paper_l ()->get_var ("quartwidth");
+ me->paper_l ()->get_var ("quartwidth");
- set_elt_property ("threshold",
+ me->set_elt_property ("threshold",
gh_cons (gh_double2scm (nhw* 1.5),
gh_double2scm (infinity_f)));
- column_l ()->set_elt_property ("contains-grace", SCM_BOOL_T);
+ dynamic_cast<Item*>(me)->column_l ()->set_elt_property ("contains-grace", SCM_BOOL_T);
return SCM_UNDEFINED;
-
}
-
-
+bool
+Grace_align_item::has_interface (Score_element*m)
+{
+ return m&& m->has_interface (ly_symbol2scm ("grace-align-interface"));
+}
#include "rhythmic-head.hh"
#include "local-key-item.hh"
#include "paper-column.hh"
-#include "dimension-cache.hh"
+#include "note-head.hh"
#include "side-position-interface.hh"
#include "axis-group-interface.hh"
virtual void process_acknowledged ();
virtual void do_post_move_processing ();
virtual void do_pre_move_processing ();
- Grace_align_item*align_l_;
+ Item*align_l_;
Link_array<Item> support_;
public:
Grace_position_engraver();
void
Grace_position_engraver::acknowledge_element (Score_element_info i)
{
- if (Grace_align_item*g =dynamic_cast<Grace_align_item*>(i.elem_l_))
+ Item *item = dynamic_cast<Item*> (i.elem_l_);
+ if (item && Grace_align_item::has_interface (i.elem_l_))
{
- align_l_ = g;
+ align_l_ = item;
}
- else if (to_boolean (i.elem_l_->get_elt_property ("note-head-interface")))
+ else if (item && Note_head::has_interface (i.elem_l_))
{
- if (!to_boolean (i.elem_l_->get_elt_property ("grace")))
- support_.push (dynamic_cast<Item*> (i.elem_l_));
+ if (!to_boolean (item->get_elt_property ("grace")))
+ support_.push (item);
}
- else if (Local_key_item*it = dynamic_cast<Local_key_item*>(i.elem_l_))
+ else if (item && Local_key_item::has_interface (i.elem_l_))
{
- if (!to_boolean (it->get_elt_property ("grace")))
- support_.push (it);
+ if (!to_boolean (item->get_elt_property ("grace")))
+ support_.push (item);
else if (align_l_)
- it->add_dependency (align_l_);
+ item->add_dependency (align_l_);
}
}
if (align_l_)
{
for (int i=0; i < support_.size (); i++)
- Side_position_interface (align_l_).add_support (support_[i]);
+ Side_position::add_support (align_l_,support_[i]);
support_.clear ();
}
}
void
Grace_position_engraver::do_pre_move_processing ()
{
- if (align_l_ && !Side_position_interface (align_l_).supported_b ())
+ if (align_l_ && !Side_position::supported_b (align_l_))
{
/*
We don't have support. Either some moron tried attaching us to a rest,
warning (_("Unattached grace notes. Attaching to last musical column."));
align_l_->set_parent (0, X_AXIS);
- Axis_group_interface (last_musical_col_l_).add_element (align_l_);
+ Axis_group_interface::add_element (last_musical_col_l_, align_l_);
}
last_musical_col_l_ = dynamic_cast<Paper_column*>( unsmob_element (get_property ("currentMusicalColumn")));
name_ = s;
}
bool
-Group_interface::has_interface_b ()
+Group_interface::has_interface ()
{
- SCM el = elt_l_->get_elt_property (name_);
+ SCM el = elt_l_->get_elt_property (name_.ch_C());
return el == SCM_EOL || gh_pair_p (el);
}
void
Group_interface::add_thing (SCM s)
{
- elt_l_->set_elt_property (name_,
- gh_cons (s, elt_l_->get_elt_property (name_)));
-
+ elt_l_->set_elt_property (name_.ch_C (),
+ gh_cons (s, elt_l_->get_elt_property (name_.ch_C())));
}
int
Group_interface::count ()
{
- return scm_ilength (elt_l_->get_elt_property (name_));
+ return scm_ilength (elt_l_->get_elt_property (name_.ch_C()));
}
void
Group_interface::set_interface ()
{
- if (!has_interface_b ())
+ if (!has_interface ())
{
- elt_l_->set_elt_property (name_, SCM_EOL);
+ elt_l_->set_elt_property (name_.ch_C (), SCM_EOL);
}
}
Hara_kiri_engraver::acknowledge_element (Score_element_info i)
{
Axis_group_engraver::acknowledge_element (i);
-
- i.elem_l_->add_offset_callback (Hara_kiri_group_spanner::force_hara_kiri_callback, Y_AXIS);
-
- if (Rhythmic_head *h = dynamic_cast<Rhythmic_head *> (i.elem_l_))
+ if (Rhythmic_head::has_interface (i.elem_l_))
{
- Hara_kiri_group_spanner::add_interesting_item (staffline_p_, h);
+ Hara_kiri_group_spanner::add_interesting_item (staffline_p_, i.elem_l_);
}
}
ADD_THIS_TRANSLATOR(Hara_kiri_engraver);
void
Hara_kiri_group_spanner::set_interface (Score_element*me)
{
- me->set_elt_pointer ("items-worth-living", SCM_EOL);
+ me->set_elt_property ("items-worth-living", SCM_EOL);
+ me->add_offset_callback (force_hara_kiri_callback, Y_AXIS);
+ me->set_interface (ly_symbol2scm ("hara-kiri-spanner-interface"));
+}
+
+bool
+Hara_kiri_group_spanner::has_interface (Score_element*me)
+{
+ return me->has_interface (ly_symbol2scm ("hara-kiri-spanner-interface"));
}
void
-Hara_kiri_group_spanner::add_interesting_item (Score_element* me,Item* n)
+Hara_kiri_group_spanner::add_interesting_item (Score_element* me,Score_element* n)
{
me->add_dependency (n);
Pointer_group_interface (me, "items-worth-living").add_element (n);
-
}
void
Hara_kiri_group_spanner::consider_suicide(Score_element*me)
{
- SCM worth = me->get_elt_pointer ("items-worth-living");
+ SCM worth = me->get_elt_property ("items-worth-living");
if (gh_pair_p (worth))
return ;
- Link_array<Score_element> childs = Axis_group_interface (me).get_children ();
+ Link_array<Score_element> childs = Axis_group_interface::get_children (me);
for (int i = 0; i < childs.size (); i++)
childs[i]->suicide ();
Real
Hara_kiri_group_spanner::force_hara_kiri_callback (Score_element *elt, Axis a)
{
- while (elt
- && to_boolean (elt->get_elt_property ("hara-kiri-interface")))
- elt = elt->parent_l(a);
-
- if (elt)
- {
- Hara_kiri_group_spanner::consider_suicide (elt);
- }
-
+ assert (a == Y_AXIS);
+ consider_suicide (elt);
return 0.0;
}
+
Hyphen_engraver::acknowledge_element (Score_element_info i)
{
// -> text-item
- if (dynamic_cast<Item*> (i.elem_l_)
- && to_boolean (i.elem_l_->get_elt_property ("text-item-interface")))
+ if (i.elem_l_->has_interface (ly_symbol2scm ("text-item-interface")))
{
current_lyric_l_ = i.elem_l_;
if (hyphen_p_
#include "spanner.hh"
#include "item.hh"
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Hyphen_spanner,brew_molecule)
+MAKE_SCHEME_CALLBACK(Hyphen_spanner,brew_molecule)
SCM
Hyphen_spanner::brew_molecule (SCM smob)
element properties
stacking-dir
-
- Which side to align? -1: left side, 0: centered (around
- center_l_ if not nil, or around center of width), 1: right side
- */
-struct Align_interface {
- Score_element * elt_l_;
-
- Align_interface (Score_element const*);
+
+ Which side to align? -1: left side, 0: centered (around
+ center_l_ if not nil, or around center of width), 1: right side
+*/
+struct Align_interface {
static Real alignment_callback (Score_element *,Axis);
- void do_side_processing (Axis a);
- void set_axis (Axis);
- Axis axis () const;
- void add_element (Score_element*);
- int get_count (Score_element*)const;
- void set_interface ();
- bool has_interface_b ();
+ static void do_side_processing (Score_element*,Axis a);
+ static void set_axis (Score_element*,Axis);
+ static Axis axis (Score_element*) ;
+ static void add_element (Score_element*,Score_element*);
+ static int get_count (Score_element*,Score_element*);
+ static void set_interface (Score_element*);
+ static bool has_interface (Score_element*);
static Real center_on_element (Score_element *c, Axis);
};
+++ /dev/null
-/*
- auto-beam-engraver.hh -- declare Auto_beam_engraver
-
- source file of the GNU LilyPond music typesetter
-
- (c) 1999--2000 Jan Nieuwenhuizen <janneke@gnu.org>
-
- */
-
-#ifndef AUTO_BEAM_ENGRAVER_HH
-#define AUTO_BEAM_ENGRAVER_HH
-
-#include "engraver.hh"
-
-class Auto_beam_engraver : public Engraver
-{
-public:
- Auto_beam_engraver ();
- VIRTUAL_COPY_CONS (Translator);
-
-protected:
- virtual bool do_try_music (Music*);
- virtual void do_pre_move_processing ();
- virtual void do_post_move_processing ();
- virtual void do_removal_processing ();
- virtual void acknowledge_element (Score_element_info);
- virtual void do_process_music ();
- virtual void process_acknowledged ();
- virtual void do_creation_processing ();
-private:
- void begin_beam ();
- void consider_end_and_begin (Moment test_mom);
- Beam* create_beam_p ();
- void end_beam ();
- void junk_beam ();
- bool same_grace_state_b (Score_element* e);
- void typeset_beam ();
-
- Moment shortest_mom_;
- Beam *finished_beam_p_;
- Array<Stem*>* stem_l_arr_p_;
-
- Moment last_add_mom_;
- Moment extend_mom_;
-
-
- Moment beam_start_moment_;
- Moment beam_start_location_;
-
- Timing_translator * timer_l_;
- // We act as if beam were created, and start a grouping anyway.
- Beaming_info_list*grouping_p_;
- Beaming_info_list*finished_grouping_p_;
-};
-
-#endif /* AUTO_BEAM_ENGRAVER_HH */
-
*/
struct Axis_group_interface
{
- Score_element *elt_l_;
- Axis_group_interface (Score_element*);
-
static Interval group_extent_callback (Score_element *,Axis);
static Interval relative_group_extent (Axis, Score_element * common, SCM list);
- void add_element (Score_element*);
- void set_axes (Axis,Axis);
- bool axis_b (Axis)const;
- Link_array<Score_element> get_children ();
- bool has_interface_b ();
- void set_interface ();
+ static void add_element (Score_element* me, Score_element*);
+ static void set_axes (Score_element*,Axis,Axis);
+ static bool axis_b (Score_element*,Axis);
+ static Link_array<Score_element> get_children (Score_element*);
+ static bool has_interface (Score_element*);
+ static void set_interface (Score_element*);
};
private:
void create_bar ();
- Bar * bar_p_;
+ Item * bar_p_;
};
#endif // BAR_ENGRAVER_HH
#ifndef BAR_HH
#define BAR_HH
-#include "item.hh"
+
+#include "lily-guile.hh"
+#include "lily-proto.hh"
/**
A vertical bar.
*/
-class Bar:public Item
+class Bar
{
public:
- VIRTUAL_COPY_CONS(Score_element);
- Bar(SCM);
-
- Molecule compound_barline (String, Real height) const;
- Molecule simple_barline (Real wid, Real height) const;
+ static bool has_interface (Score_element*);
+ static void set_interface (Score_element*);
+ static Molecule compound_barline (Score_element*, String, Real height) ;
+ static Molecule simple_barline (Score_element*, Real wid, Real height) ;
+ static SCM get_staff_bar_size (SCM);
static SCM brew_molecule (SCM);
-
-
-public:
- SCM member_before_line_breaking ();
static SCM before_line_breaking (SCM);
-
- virtual Real get_bar_size () const;
};
#endif // BAR_HH
beam and that point in the correct direction (urg?)
elt_properties:
- y-position: real (position of left edge)
- height: real (dy)
+
+ y-position -- real (position of left edge)
- damping: amount of beam slope damping. (int)
+ height -- real (dy)
+
+ damping -- amount of beam slope damping. (int)
should beam slope be damped? 0: no, 1: yes, 100000: horizontal beams
*/
class Beam : public Spanner
{
public:
- static SCM brew_molecule (SCM);
-
- int stem_count () const;
- Stem* stem (int) const;
- Stem* stem_top () const;
+
int visible_stem_count () const;
- Stem* first_visible_stem () const;
- Stem* last_visible_stem () const;
+ Item* first_visible_stem () const;
+ Item* last_visible_stem () const;
static Real rest_collision_callback (Score_element *,Axis);
Beam (SCM);
- void add_stem (Stem*);
+ void add_stem (Score_element*);
void set_grouping (Rhythmic_grouping def, Rhythmic_grouping current);
void set_beaming (Beaming_info_list *);
void set_stemlens ();
int get_multiplicity () const;
-public:
-
- SCM member_before_line_breaking ();
+ static SCM brew_molecule (SCM);
static SCM before_line_breaking (SCM);
- SCM member_after_line_breaking ();
static SCM after_line_breaking (SCM);
- SCM member_brew_molecule () const;
- Molecule stem_beams (Stem *here, Stem *next, Stem *prev) const;
+ Molecule stem_beams (Item *here, Item *next, Item *prev) const;
private:
Direction get_default_dir () const;
void set_stem_directions ();
void calc_default_position_and_height (Real* y, Real* dy) const;
bool suspect_slope_b (Real y, Real dy) const;
Real calc_slope_damping_f (Real dy) const;
- Real calc_stem_y_f (Stem* s, Real y, Real dy) const;
+ Real calc_stem_y_f (Item* s, Real y, Real dy) const;
Real check_stem_length_f (Real y, Real dy) const;
void set_stem_length (Real y, Real dy);
Real quantise_dy_f (Real dy) const;
/** Class representation of an algorithm which decides where to put
the column, and where to break lines.
+
+ JUNKME.
*/
class Break_algorithm {
TODO: remove this as a class, and make interface.
*/
-class Break_align_item : public Item
+class Break_align_item
{
public:
- SCM member_before_line_breaking ();
static SCM before_line_breaking (SCM);
-
- Break_align_item (SCM s);
- VIRTUAL_COPY_CONS(Score_element);
+ static void do_alignment (Score_element*);
+ static void set_interface (Score_element*);
+ static bool has_interface (Score_element*);
+ static void add_element (Score_element*me, Score_element*add);
+ static Real alignment_callback (Score_element*, Axis);
};
#endif // BREAK_ALIGN_ITEM_HH
static SCM brew_molecule (SCM);
static Real offset_callback (Score_element *, Axis);
static void set_interface (Score_element*);
+ static bool has_interface (Score_element*);
};
#endif // BREATHING_SIGN_HH
+++ /dev/null
-/*
- clef-item.hh -- declare Clef_item
-
- (c) 1996--2000 Han-Wen Nienhuys
-*/
-
-#ifndef CLEFITEM_HH
-#define CLEFITEM_HH
-#include "item.hh"
-
-#include "direction.hh"
-
-
-
-#endif // CLEFITEM_HH
-
-
--- /dev/null
+/*
+ clef.hh -- declare
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+
+ */
+
+#ifndef CLEF_HH
+#define CLEF_HH
+#include "lily-guile.hh"
+#include "lily-proto.hh"
+
+/**
+ Set a clef in a staff.
+
+ properties:
+
+ non-default -- not set because of existence of a bar?
+
+ change -- is this a change clef (smaller size)?
+
+ glyph -- a string determining what glyph is typeset
+
+ */
+struct Clef
+{
+ static SCM before_line_breaking (SCM);
+ static bool has_interface (Score_element*);
+ static void set_interface (Score_element*);
+};
+
+
+#endif /* CLEF_HH */
+
class Collision // interface
{
public:
- Score_element* elt_l_;
static SCM automatic_shift (Score_element*);
static SCM forced_shift (Score_element*);
static Real force_shift_callback (Score_element *, Axis);
static void do_shifts (Score_element*);
-
- void add_column (Note_column*ncol_l);
- Collision(Score_element*);
+ static void add_column (Score_element*me,Note_column*ncol_l);
};
#endif // COLLISION_HH
public:
static SCM brew_molecule (SCM);
static void set_interface(Score_element*);
+ static bool has_interface (Score_element*);
};
#endif // CRESCENDO_HH
Directional_element_interface (Score_element const *);
void set (Direction d);
Direction get () const;
- bool has_interface_b () const;
+ bool has_interface () const;
// bool set_interface ();
};
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 bool has_interface (Score_element*);
static Real force_shift_callback (Score_element * , Axis);
static SCM do_shifts (SCM dotlist);
};
#define GRACE_ALIGN_ITEM_HH
-#include "item.hh"
+#include "lily-guile.hh"
+#include "lily-proto.hh"
-class Grace_align_item : public Item
+class Grace_align_item
{
public:
- VIRTUAL_COPY_CONS (Score_element);
- Grace_align_item (SCM);
-
-
- SCM member_before_line_breaking ();
+ static void set_interface (Score_element*);
+ static bool has_interface (Score_element*);
static SCM before_line_breaking (SCM);
};
#endif /* GRACE_ALIGN_ITEM_HH */
Group_interface (Score_element const*, String);
int count ();
void add_thing (SCM);
- bool has_interface_b ();
+ bool has_interface ();
void set_interface ();
};
Pointer_group_interface (Score_element const*, String);
int count ();
void set_interface ();
- bool has_interface_b ();
+ static bool has_interface (Score_element*);
+ bool has_interface ();
void add_element (Score_element*);
};
/**
{
Link_array<T> arr;
- for (SCM s = elt->get_elt_pointer (name); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = elt->get_elt_property (name); gh_pair_p (s); s = gh_cdr (s))
{
SCM e = gh_car (s);
arr.push (dynamic_cast<T*> (unsmob_element (e)));
public:
static Real force_hara_kiri_callback (Score_element * , Axis);
static void set_interface (Score_element*me);
+ static bool has_interface (Score_element*);
static void consider_suicide (Score_element*me);
- static void add_interesting_item (Score_element * me , Item* n);
+ static void add_interesting_item (Score_element * me , Score_element* n);
};
struct Key_item
{
static int calculate_position(Score_element*,SCM pair) ;
- void set_interface (Score_element*);
+ static void set_interface (Score_element*);
+ static bool has_interface (Score_element*);
static SCM brew_molecule (SCM);
};
*/
void add_scm_init_func (void (*)());
+
+
+#define MAKE_SCHEME_CALLBACK(TYPE, FUNC) \
+static SCM TYPE ## _ ## FUNC ## _scm;\
+void \
+TYPE ## _ ## FUNC ## _init_functions () \
+{ \
+ TYPE ## _ ## FUNC ## _scm = gh_new_procedure1_0 (#TYPE "::" #FUNC, \
+ (SCM(*)(...))TYPE :: FUNC); \
+} \
+ \
+ADD_SCM_INIT_FUNC(TYPE ## _ ## FUNC ## _callback, TYPE ## _ ## FUNC ## _init_functions); \
+
+
#define ADD_SCM_INIT_FUNC(name, func)\
class name ## _scm_initter { \
public:\
class Line_of_score : public Spanner
{
public:
-
-
- void post_processing();
-
- /// -> SCM
int rank_i_;
+ void post_processing();
Protected_scm output_;
- Line_of_score();
+ Line_of_score(SCM);
/// is #c# contained in #*this#?
bool contains_b (Paper_column const *c) const;
{
Array<Local_key_cautionary_tuple> accidental_arr_;
- Molecule accidental (int,bool,bool) const;
+ static Molecule accidental (Score_element*me, int,bool,bool) ;
public:
Local_key_item (SCM );
static SCM brew_molecule (SCM);
void add_pitch (Musical_pitch, bool cautionary, bool natural);
- SCM member_before_line_breaking ();
static SCM before_line_breaking (SCM);
- SCM member_brew_molecule() const;
+ static bool has_interface (Score_element*);
};
+
#endif // LOCALKEYITEM_HH
+++ /dev/null
-/*
- multi_measure_rest-engraver.hh -- declare Multi_measure_rest_engraver
-
- source file of the GNU LilyPond music typesetter
-
- (c) 1998--2000 Jan Nieuwenhuizen <janneke@gnu.org>
-*/
-
Multi_measure_rest (SCM);
static void set_interface (Score_element*);
+ static bool has_interface (Score_element*);
static SCM brew_molecule (SCM);
static void add_column (Score_element*,Item*);
VIRTUAL_COPY_CONS (Score_element);
static Slice head_positions_interval(Score_element* me) ;
static Direction static_dir (Score_element*);
void translate_rests(int dy);
- Rhythmic_head * first_head ()const;
+ Score_element * first_head ()const;
Interval rest_dim ()const ;
Note_column (SCM);
void set_stem (Score_element*);
void add_head (Score_element*);
bool rest_b () const;
- Stem *stem_l()const;
+ static bool has_interface (Score_element*);
+
+ Item *stem_l()const;
};
#endif // NOTE_COLUMN_HH
public:
static SCM brew_molecule (SCM);
static Molecule ledger_line (Interval, Score_element*) ;
+ static bool has_interface (Score_element*);
};
#endif // NOTEHEAD_HH
* Put these in Scheme.
*/
-
+
+
Array<Column_rod> minimal_dists_;
Array<Column_spring > springs_;
+
+ /*
+ Not (yet) in scm, because of messy effects when a column commits suicide.
+ */
+ int rank_i_;
/// set a minimum distance
void add_rod (Paper_column * to, Real distance);
void add_spring (Paper_column * to, Real dist, Real strength);
Line_of_score *line_l_;
/// which one (left =0)
- int rank_i() const;
+ static int rank_i(Score_element*);
Paper_column (SCM);
Moment when_mom ()const;
bool musical_b () const;
bool used_b () const;
void set_rank (int);
-private:
-
- /**
- The ranking: left is smaller than right
- -1 is uninitialised.
- */
- int rank_i_;
-
};
#endif // P_COL_HH
#Paper_score# contains the items, the columns.
*/
-
class Paper_score : public Music_output
{
- SCM element_smob_list_;
+ SCM main_smob_;
public:
Paper_def *paper_l_;
class Rest_collision // interface
{
public:
- Score_element *elt_l_;
-
- void add_column (Note_column*);
- Rest_collision(Score_element*);
- void set_interface ();
-
+ static void add_column (Score_element*me,Note_column*);
+ static void set_interface (Score_element*me);
+ static bool has_interface (Score_element*);
static Real force_shift_callback (Score_element *, Axis);
static SCM do_shift (Score_element*,SCM);
};
{
public:
static SCM after_line_breaking (SCM);
+ static bool has_interface (Score_element*);
static SCM brew_molecule (SCM);
};
#endif // REST_HH
#ifndef RHYTHMIC_HEAD_HH
#define RHYTHMIC_HEAD_HH
-#include "item.hh"
+#include "lily-guile.hh"
+#include "lily-proto.hh"
/*
Properties
dot -- reference to Dots object.
*/
-class Rhythmic_head : public Item
+class Rhythmic_head
{
public:
-
- /*
- Typically not used, since Rhythmic_head is not breakable.
- */
- VIRTUAL_COPY_CONS(Rhythmic_head);
- int balltype_i () const;
-
- void set_dots (Item *);
- Stem * stem_l () const;
- Item * dots_l () const;
- int dot_count () const;
-
- SCM member_after_line_breaking ();
+ static int balltype_i (Score_element*) ;
+ static void set_dots (Score_element*,Item *);
+ static Item * stem_l (Score_element*) ;
+ static Item * dots_l (Score_element*) ;
+ static int dot_count (Score_element*) ;
static SCM after_line_breaking (SCM);
- Rhythmic_head (SCM s);
+ static bool has_interface (Score_element*);
+ static void set_interface (Score_element*);
};
#endif // RHYTHMIC_HEAD_HH
Real distance_f_;
Column_rod ();
- static int compare (const Column_rod &r1, const Column_rod &r2);
};
typedef Interval (*Extent_callback)(Score_element *,Axis);
typedef Real (*Offset_callback)(Score_element *,Axis);
-#define READONLY_PROPS // FIXME.
/**
*/
public: // ugh.
- SCM property_alist_;
- SCM pointer_alist_;
-#ifndef READONLY_PROPS
- SCM basic_property_list_;
-#endif
+ SCM immutable_property_alist_;
+ SCM mutable_property_alist_;
+
public:
Score_element *original_l_;
/*
properties
*/
- SCM get_elt_property (String nm) const;
- void set_elt_property (String, SCM val);
-
- /**
- Pointers are like properties, but they are subject to a substitution
- after line breaking.
- */
- SCM get_elt_pointer (const char*) const;
+ SCM get_elt_property (const char*) const;
+ SCM get_elt_property (SCM) const;
+ void set_elt_property (const char * , SCM val);
+ void set_immutable_elt_property (const char * , SCM val);
+ void set_immutable_elt_property (SCM key, SCM val);
+ void set_elt_property (SCM , SCM val);
void set_elt_pointer (const char*, SCM val);
friend class Property_engraver; // UGHUGHUGH.
- /**
- UGH! JUNKME ?
-
- This gets messy because it changes state
-
- calling
-
- Bar::proc ()
- {
- s->remove_elt_property ("foo")
- }
-
- twice may do weird things if Bar::foo has a default set.
-
- */
SCM remove_elt_property (const char* nm);
/*
static Interval dim_cache_callback (Dimension_cache const*);
public:
- SCM member_brew_molecule ()const;
-
static SCM ly_set_elt_property (SCM, SCM,SCM);
static SCM ly_get_elt_property (SCM, SCM);
+
+ bool has_interface (SCM intf);
+ void set_interface (SCM intf);
+
+
static SCM brew_molecule (SCM);
virtual void handle_broken_dependencies ();
virtual void handle_prebroken_dependencies ();
void set_parent (Score_element* e, Axis);
Score_element *parent_l (Axis a) const;
- void fixup_refpoint ();
+ static SCM fixup_refpoint (SCM);
};
Score_element * unsmob_element (SCM);
-#define MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(TYPE, FUNC) \
-void \
-TYPE ## _ ## FUNC ## _init_functions () \
-{ \
- scm_make_gsubr (#TYPE "::" #FUNC, 1, 0, 0, \
- (SCM(*)(...))TYPE :: FUNC); \
-} \
- \
-ADD_SCM_INIT_FUNC(TYPE ## _ ## FUNC ## _scelt, TYPE ## _ ## FUNC ## _init_functions); \
-
-#define GLUE_SCORE_ELEMENT(TYPE, FUNC) \
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(TYPE,FUNC);\
-SCM \
-TYPE::FUNC (SCM smob) \
-{ \
- TYPE * b = dynamic_cast<TYPE*> (unsmob_element (smob)); \
- return b ? b->member_ ## FUNC () : SCM_UNDEFINED; \
-} \
-
-
#endif // STAFFELEM_HH
static Molecule get_molecule (Score_element*,Direction d);
Script (SCM);
static SCM brew_molecule (SCM);
- SCM member_after_line_breaking ();
static SCM after_line_breaking (SCM);
};
class Separating_group_spanner : public Spanner
{
public:
- void add_spacing_unit (Item*);
+ static void add_spacing_unit (Score_element*me, Item*);
Separating_group_spanner(SCM);
protected:
VIRTUAL_COPY_CONS(Score_element);
struct Separation_item
{
static void set_interface (Score_element*);
+ static bool has_interface (Score_element*);
static Interval my_width (Score_element*) ;
static void add_item (Score_element*,Item*);
};
padding -- add this much extra space between victim and support
+
TODO: move out unrelated callbacks.
-
+
+ TODO: reduce number of methods.
*/
-struct Side_position_interface
+struct Side_position
{
- Score_element * elt_l_;
public:
- Side_position_interface (Score_element const*);
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);
- void set_quantised (Axis);
- Axis get_axis () const;
-
- bool supported_b () const;
- bool has_interface_b () const;
- void add_support (Score_element*);
-
- void add_staff_support ();
- Direction get_direction () const;
- void set_direction (Direction);
+ static void set_axis (Score_element*,Axis);
+ static void set_minimum_space (Score_element*,Real);
+ static void set_padding (Score_element*,Real);
+ static Axis get_axis (Score_element*) ;
+ static bool supported_b (Score_element*) ;
+ static bool has_interface (Score_element*) ;
+ static void add_support (Score_element*,Score_element*);
+ static void add_staff_support (Score_element*);
+ static Direction get_direction (Score_element*);
+ static void set_direction (Score_element*,Direction);
};
void add_column (Note_column*);
static SCM brew_molecule (SCM);
- SCM member_brew_molecule () const;
Array<Offset> get_encompass_offset_arr () const;
Bezier get_curve () const;
Direction get_default_dir () const;
- SCM member_after_line_breaking ();
static SCM after_line_breaking (SCM);
Array<Rod> get_rods () const;
Offset get_attachment (Direction dir, Score_element**common) const;
#ifndef SPAN_BAR_HH
#define SPAN_BAR_HH
-#include "bar.hh"
+#include "lily-guile.hh"
+#include "lily-proto.hh"
/**
This is a barline that is spanned across other bar lines. This is
to span a Score_element. Perhaps this can be used for large time
sigs?
*/
-class Span_bar : public Bar
+class Span_bar
{
- Interval get_spanned_interval () const;
public:
- Span_bar (SCM);
-
- VIRTUAL_COPY_CONS(Score_element);
- void add_bar (Score_element*);
- void evaluate_empty ();
-
+ static void set_interface (Score_element*);
+ static bool has_interface (Score_element*);
+ static Interval get_spanned_interval (Score_element*);
+ static void add_bar (Score_element*,Score_element*);
+ static void evaluate_empty (Score_element*);
static Interval width_callback(Score_element *, Axis) ;
-
- virtual Real get_bar_size () const;
- SCM member_before_line_breaking ();
+ static SCM get_bar_size (SCM);
static SCM before_line_breaking (SCM);
- SCM member_after_line_breaking ();
- static SCM after_line_breaking (SCM);
+ static Real center_on_spanned_callback (Score_element*,Axis);
};
#endif // SPAN_BAR_HH
Real strength_f_;
Column_spring ();
- static int compare (const Column_spring &r1, const Column_spring &r2);
};
struct Spring{
+++ /dev/null
-/*
- staff-bar.hh -- declare Staff_bar
-
- source file of the GNU LilyPond music typesetter
-
- (c) 1999--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
-
- */
-
-#ifndef STAFF_BAR_HH
-#define STAFF_BAR_HH
-
-#include "bar.hh"
-
-
-/**
- A bar that is on a staff.
- Ugh. Entita non multiplicandum ...
- */
-class Staff_bar : public Bar
-{
-public:
- VIRTUAL_COPY_CONS(Score_element);
- virtual Real get_bar_size () const;
- Staff_bar (SCM);
-};
-
-#endif /* STAFF_BAR_HH */
-
-/*
- staff-sym-referencer.hh -- declare staff_symbol_referencer
-
- source file of the GNU LilyPond music typesetter
-
- (c) 1999--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
-
+/*
+ staff-sym-referencer.hh -- declare staff_symbol_referencer
+
+ source file of the GNU LilyPond music typesetter
+
+ (c) 1999--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+
*/
#ifndef STAFF_SYMBOL_REFERENCER_HH
/**
- A notation object that needs access to variables of the staff (no
- lines, leading).
-
+ A notation object that needs access to variables of the staff (no
+ lines, leading).
+
*/
-class Staff_symbol_referencer_interface
+class Staff_symbol_referencer
{
public:
- Score_element * elt_l_; // junkme.
- Staff_symbol_referencer_interface (Score_element const*);
static void set_interface (Score_element*);
- static bool has_interface_b (Score_element*);
- void set_position (Real);
+ static bool has_interface (Score_element*);
+ static void set_position (Score_element*,Real);
static Real callback (Score_element *, Axis a);
/**
Leading are the lead strips between the sticks (lines) of
typeface. ie. leading is vertical space.
- */
-
- Real staff_space () const;
- Staff_symbol * staff_symbol_l () const;
- int line_count () const;
- Real position_f () const;
+ */
+
+ static Real staff_space (Score_element*);
+ static Score_element * staff_symbol_l (Score_element*);
+ static int line_count (Score_element*);
+ static Real position_f (Score_element*);
};
int compare_position (Score_element *const&,Score_element *const&);
#ifndef STAFFSYM_HH
#define STAFFSYM_HH
-#include "spanner.hh"
+
+#include "lily-guile.hh"
/**
This spanner draws the lines of a pstaff.
The bottom line is position 0.
*/
-class Staff_symbol : public Spanner
+class Staff_symbol
{
public:
- Real staff_space () const;
- int steps_i() const;
- int line_count () const;
- Staff_symbol (SCM s);
- static SCM brew_molecule (SCM);
- VIRTUAL_COPY_CONS(Score_element);
- SCM member_brew_molecule() const;
-
+ static Real staff_space (Score_element*) ;
+ static int steps_i(Score_element*) ;
+ static int line_count (Score_element*);
+ static SCM brew_molecule (SCM);
+ static bool has_interface (Score_element*);
+ static void set_interface (Score_element*);
};
#endif // STAFFSYM_HH
{
public:
static void set_interface (Score_element*);
+ static bool has_interface (Score_element*);
static Interval dim_callback (Score_element*, Axis);
static SCM brew_molecule (SCM);
static void set_stem (Score_element*me, Score_element *st);
class Stem : public Item
{
public:
- static SCM brew_molecule (SCM);
-
-
+ static SCM brew_molecule (SCM);
/// log of the duration. Eg. 4 -> 16th note -> 2 flags
- int flag_i () const;
+ static int flag_i (Score_element*) ;
- int beam_count (Direction) const;
- void set_beaming (int, Direction d);
+ static int beam_count (Score_element*,Direction) ;
+ static void set_beaming (Score_element*,int, Direction d);
/**
- don't print flag when in beam.
- our beam, for aligning abbrev flags
- */
- Beam* beam_l () const;
- Rhythmic_head * first_head () const;
- Drul_array<Rhythmic_head*> extremal_heads () const;
-
- Score_element * support_head () const;
+ don't print flag when in beam.
+ our beam, for aligning abbrev flags
+ */
+ static Beam * beam_l (Score_element*);
+ static Score_element * first_head (Score_element*) ;
+ static Drul_array<Score_element*> extremal_heads (Score_element*);
+
+ static Score_element * support_head (Score_element*) ;
Stem (SCM);
/// ensure that this Stem also encompasses the Notehead #n#
- void add_head (Rhythmic_head*n);
+ static void add_head (Score_element*me, Score_element*n);
- Stem_info calc_stem_info () const;
+ static Stem_info calc_stem_info (Score_element *) ;
- Real chord_start_f () const;
- Direction get_direction () const;
- int type_i () const;
- void set_stemend (Real);
- Direction get_default_dir() const;
+ static Real chord_start_f (Score_element *) ;
+ static Direction get_direction (Score_element*) ;
+ static int type_i (Score_element *) ;
+ static void set_stemend (Score_element *,Real);
+ static Direction get_default_dir(Score_element *) ;
+ static int get_center_distance(Score_element *,Direction) ;
+ static int heads_i (Score_element *) ;
- int get_center_distance(Direction) const;
- int heads_i () const;
-
- bool invisible_b() const;
-
+ static bool invisible_b(Score_element *) ;
+
/// heads that the stem encompasses (positions)
- Interval head_positions() const;
+ static Interval head_positions(Score_element *) ;
-public:
- friend class Stem_tremolo; // ugh.
- Real get_default_stem_end_position () const;
- void position_noteheads();
- Real stem_end_position () const;
+ static Real get_default_stem_end_position (Score_element*me) ;
+ static void position_noteheads(Score_element*);
+ static Real stem_end_position (Score_element*) ;
static Real off_callback (Score_element *, Axis);
- Molecule flag () const;
-
- SCM member_before_line_breaking ();
+ static Molecule flag (Score_element*);
static SCM before_line_breaking (SCM);
static Interval dim_callback (Score_element *,Axis);
- SCM member_brew_molecule() const;
+ static bool has_interface (Score_element*);
+ static void set_interface (Score_element*);
- void set_spacing_hints () ;
+ static void set_spacing_hints (Score_element*me) ;
};
#endif
Tie_column (SCM s);
VIRTUAL_COPY_CONS (Score_element);
static void set_interface (Score_element*me);
+ static bool has_interface (Score_element*);
static void add_tie (Score_element*me,Tie*);
static SCM after_line_breaking (SCM);
Tie (SCM);
static void set_head (Score_element*,Direction, Item*head_l);
static void set_interface (Score_element*);
+ static bool has_interface (Score_element*);
VIRTUAL_COPY_CONS(Score_element);
- static Rhythmic_head* head (Score_element*,Direction) ;
+ static Score_element * head (Score_element*,Direction) ;
static Real position_f (Score_element*) ;
static SCM brew_molecule (SCM);
static Direction get_default_dir(Score_element*) ;
Moment measure_position () const;
Moment measure_length () const;
void set_time_signature (int, int);
- void get_time_signature (int *, int*) const;
};
#endif // TIMING_TRANSLATOR_HH
public:
static SCM brew_molecule (SCM);
static void set_interface (Score_element*);
+ static bool has_interface (Score_element*);
static void add_column (Score_element*me,Item*);
static void add_beam (Score_element*me,Score_element*);
{
public:
static void set_interface (Score_element*);
+ static bool has_interface (Score_element*);
static SCM brew_molecule (SCM);
static void add_column (Score_element*, Score_element*col);
static void add_bar (Score_element*me, Item*bar);
-
};
#endif // VOLTA_SPANNER_HH
{
if (text_)
{
- text_->add_offset_callback (Side_position_interface::centered_on_parent,
+ text_->add_offset_callback (Side_position::centered_on_parent,
Y_AXIS);
typeset_element (text_);
if (gh_string_p (s))
{
- if (Bar* b= dynamic_cast<Bar*> (i.elem_l_))
+ if (Bar::has_interface (i.elem_l_))
{
create_text (s);
}
(c) 1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
*/
-#include "dimension-cache.hh"
+
#include "paper-score.hh"
#include "debug.hh"
#include "item.hh"
{
if (original_l_)
{
- pointer_alist_
- = handle_broken_smobs (original_l_->pointer_alist_,
+ mutable_property_alist_
+ = handle_broken_smobs (original_l_->mutable_property_alist_,
gh_int2scm (break_status_dir ()));
}
#include "engraver.hh"
#include "musical-pitch.hh"
#include "protected-scm.hh"
-
+#include "clef.hh"
/**
Make the key signature.
item_p_->set_elt_property ("old-accidentals", old_accs_);
item_p_->set_elt_property ("new-accidentals", get_property ("keySignature"));
- Staff_symbol_referencer_interface::set_interface (item_p_);
+ Staff_symbol_referencer::set_interface (item_p_);
SCM prop = get_property ("keyOctaviation");
bool multi = to_boolean (prop);
void
Key_engraver::acknowledge_element (Score_element_info info)
{
- if (to_boolean (info.elem_l_->get_elt_property ("clef-interface")))
+ if (Clef::has_interface (info.elem_l_))
{
SCM c = get_property ("createKeyOnClefChange");
if (to_boolean (c))
create_key (false);
}
}
- else if (dynamic_cast<Bar *> (info.elem_l_)
+ else if (Bar::has_interface (info.elem_l_)
&& gh_pair_p (get_property ("keySignature")))
{
create_key (true);
TODO
- space the `natural' signs wider
*/
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Key_item,brew_molecule);
+MAKE_SCHEME_CALLBACK(Key_item,brew_molecule);
SCM
Key_item::brew_molecule (SCM smob)
{
Score_element*me =unsmob_element (smob);
- Staff_symbol_referencer_interface si (me);
- Real inter = si.staff_space ()/2.0;
+ Real inter = Staff_symbol_referencer::staff_space (me)/2.0;
SCM newas = me->get_elt_property ("new-accidentals");
Molecule mol;
+
+bool
+Key_item::has_interface (Score_element*m)
+{
+ return m && m->has_interface (ly_symbol2scm ("key-signature-interface"));
+}
+
+void
+Key_item::set_interface (Score_element*m)
+{
+ m->set_interface (ly_symbol2scm ("key-signature-interface"));
+}
/*
- staff-gravs.cc -- implement Line_group_engraver
+ line-group-engraver-group.cc -- implement Line_group_engraver
source file of the GNU LilyPond music typesetter
(c) 1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
*/
-#include "staff-symbol.hh"
#include "command-request.hh"
#include "bar.hh"
#include "debug.hh"
#include "line-group-group-engraver.hh"
#include "paper-column.hh"
#include "axis-group-interface.hh"
+#include "spanner.hh"
Line_group_engraver_group::Line_group_engraver_group()
Line_group_engraver_group::typeset_element (Score_element *elem)
{
if (!elem->parent_l (Y_AXIS))
- Axis_group_interface (staffline_p_).add_element (elem);
+ Axis_group_interface::add_element (staffline_p_, elem);
Engraver_group_engraver::typeset_element (elem);
}
Line_group_engraver_group::create_line_spanner ()
{
staffline_p_ = new Spanner (SCM_EOL);
- Axis_group_interface (staffline_p_).set_interface ();
- Axis_group_interface (staffline_p_).set_axes (Y_AXIS,Y_AXIS);
+ Axis_group_interface::set_interface (staffline_p_);
+ Axis_group_interface::set_axes (staffline_p_, Y_AXIS,Y_AXIS);
}
#include "side-position-interface.hh"
#include "rhythmic-head.hh"
#include "stem.hh"
+#include "note-head.hh"
/**
Annotate output with line numbers. Creates text-items when it
if (!text_item_p_ && interesting_.size ())
{
text_item_p_ = new Item (get_property ("basicTextProperties") );
- Side_position_interface si (text_item_p_);
- si.set_axis (Y_AXIS);
+ Side_position::set_axis (text_item_p_,Y_AXIS);
+ Side_position::set_direction (text_item_p_, UP);
text_item_p_->set_parent (interesting_[0].elem_l_, Y_AXIS);
- si.set_direction (UP);
+
announce_element (Score_element_info (text_item_p_, 0));
}
}
void
Line_number_engraver::acknowledge_element (Score_element_info inf)
{
- if (to_boolean (inf.elem_l_->get_elt_property ("note-head-interface")))
+ if (Note_head::has_interface (inf.elem_l_))
{
interesting_.push (inf);
support_.push (inf.elem_l_);
}
- else if (to_boolean (inf.elem_l_->get_elt_property ("stem-interface")))
+ else if (Stem::has_interface (inf.elem_l_))
{
support_.push (inf.elem_l_);
}
if (text_item_p_)
{
String s;
- Side_position_interface si (text_item_p_);
+
for (int i=0; i < interesting_.size (); i++)
{
if (i)
for (int j= support_.size (); j--; )
{
- si.add_support (support_[j]);
+ Side_position::add_support (text_item_p_,support_[j]);
}
if (s != last_text_)
{
#include "molecule.hh"
#include "all-font-metrics.hh"
-Line_of_score::Line_of_score()
- : Spanner (SCM_EOL)
+// todo: use map.
+void
+fixup_refpoints (SCM s)
+{
+ for (; gh_pair_p (s); s = gh_cdr (s))
+ {
+ Score_element::fixup_refpoint (gh_car (s));
+ }
+}
+
+
+Line_of_score::Line_of_score(SCM s)
+ : Spanner (s)
{
- set_elt_pointer ("columns", SCM_EOL);
- set_elt_pointer ("all-elements", SCM_EOL);
+ rank_i_ = 0;
+ set_elt_property ("columns", SCM_EOL);
+ set_elt_property ("all-elements", SCM_EOL);
- Axis_group_interface (this).set_interface ();
- Axis_group_interface (this).set_axes (Y_AXIS,X_AXIS);
+ Axis_group_interface::set_interface (this);
+ Axis_group_interface::set_axes (this, Y_AXIS,X_AXIS);
}
int
Line_of_score::element_count () const
{
- return scm_ilength ( get_elt_pointer ("all-elements"));
+ return scm_ilength ( get_elt_property ("all-elements"));
}
void
void
Line_of_score::output_lines ()
{
- for (SCM s = get_elt_pointer ("all-elements");
+ for (SCM s = get_elt_property ("all-elements");
gh_pair_p (s); s = gh_cdr (s))
{
unsmob_element (gh_car (s))->do_break_processing ();
for (int i=0; i < broken_into_l_arr_.size (); i++)
{
Score_element *se = broken_into_l_arr_[i];
- SCM all = se->get_elt_pointer ("all-elements");
+ SCM all = se->get_elt_property ("all-elements");
for (SCM s = all; gh_pair_p (s); s = gh_cdr (s))
{
- unsmob_element (gh_car (s))->fixup_refpoint ();
+ fixup_refpoint (gh_car (s));
}
count += scm_ilength (all);
}
/*
needed for doing items.
*/
- for (SCM s = get_elt_pointer ("all-elements");
- gh_pair_p (s); s = gh_cdr (s))
- {
- unsmob_element (gh_car (s))->fixup_refpoint ();
- }
+ fixup_refpoints (get_elt_property ("all-elements"));
+
- for (SCM s = get_elt_pointer ("all-elements");
+ for (SCM s = get_elt_property ("all-elements");
gh_pair_p (s); s = gh_cdr (s))
{
unsmob_element (gh_car (s))->handle_broken_dependencies ();
if (i < broken_into_l_arr_.size () - 1)
{
- SCM lastcol = gh_car (line_l->get_elt_pointer ("columns"));
+ SCM lastcol = gh_car (line_l->get_elt_property ("columns"));
Score_element* e = unsmob_element (lastcol);
SCM inter = e->get_elt_property ("between-system-string");
if (gh_string_p (inter))
{
Line_of_score *line_l = dynamic_cast <Line_of_score*> (clone());
line_l->rank_i_ = i;
+ // line_l->set_immutable_elt_property ("rank", gh_int2scm( i));
Link_array<Paper_column> c (breaking[i].cols_);
pscore_l_->typeset_line (line_l);
void
Line_of_score::add_column (Paper_column*p)
{
- SCM cs = get_elt_pointer ("columns");
+ Score_element *me = this;
+ SCM cs = me->get_elt_property ("columns");
Score_element * prev = gh_pair_p (cs) ? unsmob_element (gh_car (cs)) : 0;
- int rank = prev ? dynamic_cast<Paper_column*> (prev)->rank_i () + 1 : 0;
- p->set_rank (rank);
- set_elt_pointer ("columns", gh_cons (p->self_scm_, cs));
+ p->rank_i_ = prev ? Paper_column::rank_i (prev) + 1 : 0;
- Axis_group_interface (this).add_element (p);
-}
-void
-fixup_refpoints (SCM s)
-{
- for (; gh_pair_p (s); s = gh_cdr (s))
- {
- Score_element * se = unsmob_element (gh_car (s));
- if (se)
- {
- se->fixup_refpoint ();
- if (!dynamic_cast<Line_of_score*> (se) && !se->parent_l (Y_AXIS))
- {
- programming_error ("No parent!");
- }
- }
- }
+ me->set_elt_property ("columns", gh_cons (p->self_scm_, cs));
+
+ Axis_group_interface::add_element (me, p);
}
+
+/*
+ TODO: use scm_map iso. for loops.
+ */
void
Line_of_score::pre_processing ()
{
- for (SCM s = get_elt_pointer ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = get_elt_property ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
unsmob_element (gh_car (s))->discretionary_processing ();
if(verbose_global_b)
progress_indication ( _f("Element count %d ", element_count ()));
- for (SCM s = get_elt_pointer ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = get_elt_property ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
unsmob_element (gh_car (s))->handle_prebroken_dependencies ();
- fixup_refpoints (get_elt_pointer ("all-elements"));
+ fixup_refpoints (get_elt_property ("all-elements"));
- for (SCM s = get_elt_pointer ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = get_elt_property ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
{
Score_element* sc = unsmob_element (gh_car (s));
sc->calculate_dependencies (PRECALCED, PRECALCING, ly_symbol2scm ("before-line-breaking-callback"));
}
progress_indication ("\n" + _ ("Calculating column positions...") + " " );
- for (SCM s = get_elt_pointer ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = get_elt_property ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
unsmob_element (gh_car (s))->do_space_processing ();
}
void
Line_of_score::post_processing ()
{
- for (SCM s = get_elt_pointer ("all-elements");
+ for (SCM s = get_elt_property ("all-elements");
gh_pair_p (s); s = gh_cdr (s))
{
Score_element* sc = unsmob_element (gh_car (s));
generate all molecules to trigger all font loads.
(ugh. This is not very memory efficient.) */
- for (SCM s = get_elt_pointer ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = get_elt_property ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
unsmob_element (gh_car (s))->get_molecule ();
/*
/*
all elements.
*/
- for (SCM s = get_elt_pointer ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = get_elt_property ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
{
Score_element * sc = unsmob_element (gh_car (s));
Molecule m = sc->get_molecule ();
l = l->column_l ();
r = r->column_l ();
- SCM s = get_elt_pointer ("columns");
+ SCM s = get_elt_property ("columns");
while (gh_pair_p (s) && gh_car (s) != r->self_scm_)
s = gh_cdr (s);
SCM last_keysig_;
Link_array<Note_req> mel_l_arr_;
- Link_array<Item> support_l_arr_;
+ Link_array<Score_element> support_l_arr_;
Link_array<Item> forced_l_arr_;
- Link_array<Item> tied_l_arr_;
+ Link_array<Score_element> tied_l_arr_;
Local_key_engraver();
- Grace_align_item * grace_align_l_;
+ Item * grace_align_l_;
};
Local_key_engraver::Local_key_engraver()
bool forget = to_boolean (f);
for (int i=0; i < mel_l_arr_.size(); i++)
{
- Item * support_l = support_l_arr_[i];
+ Score_element * support_l = support_l_arr_[i];
Note_req * note_l = mel_l_arr_[i];
int n = note_l->pitch_.notename_i_;
if (!key_item_p_)
{
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::set_interface (key_item_p_);
+ Side_position::set_axis (key_item_p_, X_AXIS);
+ Side_position::set_direction (key_item_p_, LEFT);
+ Staff_symbol_referencer::set_interface (key_item_p_);
announce_element (Score_element_info (key_item_p_, 0));
}
key_item_p_->add_pitch (note_l->pitch_,
note_l->cautionary_b_,
extra_natural);
- Side_position_interface (key_item_p_).add_support (support_l);
+ Side_position::add_support (key_item_p_,support_l);
}
if (!forget)
if (key_item_p_ && grace_align_l_)
{
- Side_position_interface (grace_align_l_).add_support (key_item_p_);
+ Side_position::add_support (grace_align_l_,key_item_p_);
grace_align_l_ =0;
}
if (key_item_p_)
{
for (int i=0; i < support_l_arr_.size(); i++)
- Side_position_interface (key_item_p_).add_support (support_l_arr_[i]);
+ Side_position::add_support (key_item_p_,support_l_arr_[i]);
typeset_element (key_item_p_);
key_item_p_ =0;
bool selfgr = gh_boolean_p (wg) &&gh_scm2bool (wg);
bool he_gr = to_boolean (info.elem_l_->get_elt_property ("grace"));
- Grace_align_item * gai = dynamic_cast<Grace_align_item*> (info.elem_l_);
- if (he_gr && !selfgr && gai)
+ Item * item = dynamic_cast<Item*> (info.elem_l_);
+ if (he_gr && !selfgr && item && Grace_align_item::has_interface (item))
{
- grace_align_l_ = gai;
+ grace_align_l_ = item;
}
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)
+ if (note_l && Rhythmic_head::has_interface (info.elem_l_))
{
mel_l_arr_.push (note_l);
- support_l_arr_.push (note_head);
+ support_l_arr_.push (info.elem_l_);
}
- else if (Tie * tie_l = dynamic_cast<Tie *> (info.elem_l_))
+ else if (Tie::has_interface (info.elem_l_))
{
- tied_l_arr_.push (Tie::head (tie_l, RIGHT));
+ tied_l_arr_.push (Tie::head (info.elem_l_, RIGHT));
}
}
accidental_arr_.push (t);
}
-GLUE_SCORE_ELEMENT(Local_key_item,before_line_breaking);
+MAKE_SCHEME_CALLBACK(Local_key_item,before_line_breaking);
SCM
-Local_key_item::member_before_line_breaking ()
+Local_key_item::before_line_breaking (SCM smob)
{
- accidental_arr_.sort (Local_key_cautionary_tuple::compare);
+ Local_key_item* me = dynamic_cast<Local_key_item*>(unsmob_element (smob));
+
+
+ me->accidental_arr_.sort (Local_key_cautionary_tuple::compare);
return SCM_UNDEFINED;
}
Molecule
-Local_key_item::accidental (int j, bool cautionary, bool natural) const
+Local_key_item::accidental (Score_element*me, int j, bool cautionary, bool natural)
{
- Molecule m (lookup_l ()->afm_find (String ("accidentals-") + to_str (j)));
+ Molecule m (me->lookup_l ()->afm_find (String ("accidentals-") + to_str (j)));
if (natural)
{
- Molecule prefix = lookup_l ()->afm_find (String ("accidentals-0"));
+ Molecule prefix = me->lookup_l ()->afm_find (String ("accidentals-0"));
m.add_at_edge(X_AXIS, LEFT, Molecule(prefix), 0);
}
if (cautionary)
{
- Molecule open = lookup_l ()->afm_find (String ("accidentals-("));
- Molecule close = lookup_l ()->afm_find (String ("accidentals-)"));
+ Molecule open = me->lookup_l ()->afm_find (String ("accidentals-("));
+ Molecule close = me->lookup_l ()->afm_find (String ("accidentals-)"));
m.add_at_edge(X_AXIS, LEFT, Molecule(open), 0);
m.add_at_edge(X_AXIS, RIGHT, Molecule(close), 0);
}
UGH. clean me up
*/
-GLUE_SCORE_ELEMENT(Local_key_item,brew_molecule);
+MAKE_SCHEME_CALLBACK(Local_key_item,brew_molecule);
SCM
-Local_key_item::member_brew_molecule () const
+Local_key_item::brew_molecule (SCM smob)
{
+ Local_key_item* lki = dynamic_cast<Local_key_item*>(unsmob_element (smob));
+ Score_element* me = lki;
+
Molecule mol;
- Staff_symbol_referencer_interface si (this);
- Real note_distance = si.staff_space ()/2;
+
+ Real note_distance = Staff_symbol_referencer::staff_space (me)/2;
Molecule octave_mol;
bool oct_b = false;
int lastoct = -100;
- for (int i = 0; i < accidental_arr_.size(); i++)
+ for (int i = 0; i < lki->accidental_arr_.size(); i++)
{
- Musical_pitch p (accidental_arr_[i].pitch_);
+ Musical_pitch p (lki->accidental_arr_[i].pitch_);
// do one octave
if (p.octave_i_ != lastoct)
{
lastoct = p.octave_i_;
- SCM c0 = get_elt_property ("c0-position");
+ SCM c0 = me->get_elt_property ("c0-position");
Real dy = (gh_number_p (c0) ? gh_scm2int (c0) : 0 + p.notename_i_)
* note_distance;
- Molecule m (accidental (p.accidental_i_,
- accidental_arr_[i].cautionary_b_,
- accidental_arr_[i].natural_b_));
+ Molecule m (accidental (me,p.accidental_i_,
+ lki->accidental_arr_[i].cautionary_b_,
+ lki->accidental_arr_[i].natural_b_));
m.translate_axis (dy, Y_AXIS);
octave_mol.add_at_edge (X_AXIS, RIGHT, m, 0);
octave_mol = Molecule ();
}
- if (accidental_arr_.size())
+ if (lki->accidental_arr_.size())
{
Drul_array<SCM> pads;
/*
Use a cons?
*/
- pads[RIGHT] = get_elt_property ("right-padding");
- pads[LEFT] = get_elt_property ("left-padding");
+ pads[RIGHT] = me->get_elt_property ("right-padding");
+ pads[LEFT] = me->get_elt_property ("left-padding");
// unused ?
Box b(Interval (0, gh_scm2double (pads[d]) * note_distance),
Interval (0,0));
- Molecule m (lookup_l ()->blank (b));
+ Molecule m (me->lookup_l ()->blank (b));
mol.add_at_edge (X_AXIS, d, m, 0);
} while ( flip (&d)!= LEFT);
}
{
}
+bool
+Local_key_item::has_interface (Score_element*m)
+{
+ return m && m->has_interface (ly_symbol2scm ("accidentals-interface"));
+}
text_p_->set_elt_property ("text",
ly_str02scm ((req_l_->text_str_ + " ").ch_C ()));
- text_p_->add_offset_callback (&Side_position_interface::aligned_on_self,X_AXIS);
+ text_p_->add_offset_callback (&Side_position::aligned_on_self,X_AXIS);
/*
We can't reach the notehead where we're centered from here. So
we kludge.
Han-Wen Nienhuys
*/
-#include "dimension-cache.hh"
+
#include "box.hh"
#include "debug.hh"
#include "lookup.hh"
#include "lyric-extender.hh"
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Lyric_extender,brew_molecule)
+MAKE_SCHEME_CALLBACK(Lyric_extender,brew_molecule)
SCM
Lyric_extender::brew_molecule (SCM smob)
{
#include <ctype.h>
#include "bar.hh"
#include "command-request.hh"
-#include "dimension-cache.hh"
+#include "staff-symbol.hh"
#include "engraver-group-engraver.hh"
#include "engraver.hh"
#include "lily-guile.hh"
#include "protected-scm.hh"
#include "side-position-interface.hh"
#include "staff-symbol-referencer.hh"
-#include "staff-symbol.hh"
#include "item.hh"
#include "group-interface.hh"
Protected_scm staffs_;
protected:
- virtual void do_creation_processing ();
virtual void do_pre_move_processing ();
virtual void acknowledge_element (Score_element_info);
void create_items(Request*);
staffs_ = SCM_EOL;
}
-void
-Mark_engraver::do_creation_processing ()
-{
-}
void
Mark_engraver::acknowledge_element (Score_element_info inf)
{
Score_element * s = inf.elem_l_;
- if (dynamic_cast<Staff_symbol*> (s))
+ if (Staff_symbol::has_interface (s))
{
staffs_ = gh_cons (inf.elem_l_->self_scm_, staffs_);
}
- else if (text_p_ && dynamic_cast<Bar*> (s))
+ else if (text_p_ && Bar::has_interface (s))
{
/*
Ugh. Figure out how to do this right at beginning of line, (without
{
if (text_p_)
{
- text_p_->set_elt_pointer("side-support-elements" , staffs_);
+ text_p_->set_elt_property("side-support-elements" , staffs_);
typeset_element (text_p_);
text_p_ =0;
}
SCM s = get_property ("basicMarkProperties");
text_p_ = new Item (s);
- Group_interface (text_p_, "interfaces").add_thing (ly_symbol2scm ("Mark"));
- Side_position_interface staffside(text_p_);
- staffside.set_axis (Y_AXIS);
+
+ Side_position::set_axis (text_p_, Y_AXIS);
/*
-> Generic props.
#include "staff-symbol-referencer.hh"
#include "engraver.hh"
#include "moment.hh"
+#include "spanner.hh"
/**
The name says it all: make multi measure rests
int start_measure_i_;
Moment start_moment_;
- Multi_measure_rest *mmrest_p_;
- Multi_measure_rest *lastrest_p_;
+ Spanner *mmrest_p_;
+ Spanner *lastrest_p_;
};
ADD_THIS_TRANSLATOR (Multi_measure_rest_engraver);
void
Multi_measure_rest_engraver::acknowledge_element (Score_element_info i)
{
- if (Bar *c = dynamic_cast<Bar*> (i.elem_l_))
+ Item * item = dynamic_cast<Item*> (i.elem_l_);
+ if (item && Bar::has_interface (item))
{
if (mmrest_p_)
- Multi_measure_rest::add_column (mmrest_p_,c);
+ Multi_measure_rest::add_column (mmrest_p_,item);
if (lastrest_p_)
- Multi_measure_rest::add_column (mmrest_p_,c);
+ Multi_measure_rest::add_column (lastrest_p_,item);
}
}
{
mmrest_p_ = new Multi_measure_rest (get_property ("basicMultiMeasureRestProperties"));
Multi_measure_rest::set_interface (mmrest_p_);
- Staff_symbol_referencer_interface::set_interface (mmrest_p_);
+ Staff_symbol_referencer::set_interface (mmrest_p_);
announce_element (Score_element_info (mmrest_p_, busy_span_req_l_));
start_measure_i_
if (mmrest_p_ && (now_mom () >= start_moment_)
&& !mp
- && (scm_ilength (mmrest_p_->get_elt_pointer ("columns")) >= 2))
+ && (scm_ilength (mmrest_p_->get_elt_property ("columns")) >= 2))
{
typeset_element (mmrest_p_);
/*
void
Multi_measure_rest::set_interface (Score_element*me)
{
- me->set_elt_pointer ("columns", SCM_EOL);
+ me->set_elt_property ("columns", SCM_EOL);
}
Multi_measure_rest::Multi_measure_rest (SCM s)
[TODO] 17
* variable-sized multi-measure rest symbol: |====| ??
*/
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Multi_measure_rest,brew_molecule);
+MAKE_SCHEME_CALLBACK(Multi_measure_rest,brew_molecule);
SCM
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 (me).staff_space ();
+ = Staff_symbol_referencer::staff_space (me);
Interval sp_iv;
Direction d = LEFT;
#include "paper-def.hh"
#include "group-interface.hh"
#include "staff-symbol-referencer.hh"
+#include "rest.hh"
+#include "note-head.hh"
bool
Note_column::rest_b () const
{
- return unsmob_element (get_elt_pointer ("rest"));
+ return unsmob_element (get_elt_property ("rest"));
}
int
Note_column::Note_column( SCM s)
: Item (s)
{
- set_elt_pointer ("note-heads", SCM_EOL);
- Axis_group_interface (this).set_interface ();
- Axis_group_interface (this).set_axes (X_AXIS, Y_AXIS);
- Group_interface (this, "interfaces").add_thing (ly_symbol2scm ("Note_column"));
+ Score_element* me = this;
+ me->set_elt_property ("note-heads", SCM_EOL);
+ me->set_interface (ly_symbol2scm ("note-column-interface"));
+
+ Axis_group_interface::set_interface (me);
+ Axis_group_interface::set_axes (me, X_AXIS, Y_AXIS);
}
-Stem *
+Item *
Note_column::stem_l () const
{
- SCM s = get_elt_pointer ("stem");
- return dynamic_cast<Stem*> (unsmob_element (s));
+ SCM s = get_elt_property ("stem");
+ return dynamic_cast<Item*>(unsmob_element (s));
}
iv.set_empty ();
- SCM h = me->get_elt_pointer ("note-heads");
+ SCM h = me->get_elt_property ("note-heads");
for (; gh_pair_p (h); h = gh_cdr (h))
{
Score_element *se = unsmob_element (gh_car (h));
- Staff_symbol_referencer_interface si (se);
- int j = int (si.position_f ());
+ int j = int (Staff_symbol_referencer::position_f (se));
iv.unite (Slice (j,j));
}
return iv;
Direction
Note_column::static_dir (Score_element* me)
{
- Score_element *stem = unsmob_element (me->get_elt_pointer ("stem"));
- if (dynamic_cast<Stem*> (stem))
- return dynamic_cast<Stem*> (stem)->get_direction ();
- else if (gh_pair_p (me->get_elt_pointer ("note-heads")))
+ Score_element *stem = unsmob_element (me->get_elt_property ("stem"));
+ if (stem && Stem::has_interface (stem))
+ return Stem::get_direction (stem);
+ else if (gh_pair_p (me->get_elt_property ("note-heads")))
return (Direction)sign (head_positions_interval (me).center ());
programming_error ("Note column without heads and stem!");
void
Note_column::set_stem (Score_element * stem_l)
{
- set_elt_pointer ("stem", stem_l->self_scm_);
+ set_elt_property ("stem", stem_l->self_scm_);
add_dependency (stem_l);
- Axis_group_interface (this).add_element (stem_l);
+ Axis_group_interface::add_element (this, stem_l);
}
void
Note_column::add_head (Score_element *h)
{
- if (to_boolean (h->get_elt_property ("rest-interface")))
+ if (Rest::has_interface (h))
{
- this->set_elt_pointer ("rest", h->self_scm_);
+ this->set_elt_property ("rest", h->self_scm_);
}
- else if (to_boolean (h->get_elt_property ("note-head-interface")))
+ else if (Note_head::has_interface (h))
{
Pointer_group_interface gi (this, "note-heads");
gi.add_element (h);
}
- Axis_group_interface (this).add_element (h);
+ Axis_group_interface::add_element (this, h);
}
/**
void
Note_column::translate_rests (int dy_i)
{
- Score_element * r = unsmob_element (get_elt_pointer ("rest"));
+ Score_element * r = unsmob_element (get_elt_property ("rest"));
if (r)
{
- Staff_symbol_referencer_interface si (r);
- r->translate_axis (dy_i * si.staff_space ()/2.0, Y_AXIS);
+ r->translate_axis (dy_i * Staff_symbol_referencer::staff_space (r)/2.0, Y_AXIS);
}
}
void
Note_column::set_dotcol (Score_element *d)
{
- Axis_group_interface (this).add_element (d);
+ Axis_group_interface::add_element (this, d);
}
Interval
Note_column::rest_dim () const
{
- Score_element * r = unsmob_element (get_elt_pointer ("rest"));
+ Score_element * r = unsmob_element (get_elt_property ("rest"));
return r->extent (Y_AXIS);
}
-Rhythmic_head*
+Score_element*
Note_column::first_head () const
{
- Stem * st = stem_l ();
- return st? st->first_head (): 0;
+ Score_element * st = stem_l ();
+ return st? Stem::first_head (st): 0;
+}
+
+bool
+Note_column::has_interface (Score_element*me)
+{
+ return me && me->has_interface (ly_symbol2scm ("note-column-interface"));
}
#include "lookup.hh"
#include "molecule.hh"
#include "musical-request.hh"
-#include "dimension-cache.hh"
+
#include "staff-symbol-referencer.hh"
/*
}
-
-
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Note_head,brew_molecule);
+MAKE_SCHEME_CALLBACK(Note_head,brew_molecule);
SCM
Note_head::brew_molecule (SCM smob)
{
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;
- Real p = si.position_f ();
+ Real inter_f = Staff_symbol_referencer::staff_space (me)/2;
+ int sz = Staff_symbol_referencer::line_count (me)-1;
+ Real p = Staff_symbol_referencer::position_f (me);
int streepjes_i = abs (p) < sz
? 0
: (abs((int)p) - sz) /2;
}
return out.create_scheme();
}
+
+bool
+Note_head::has_interface (Score_element*m)
+{
+ return m&& m->has_interface (ly_symbol2scm ("note-head-interface"));
+}
#include "staff-symbol-referencer.hh"
#include "engraver.hh"
#include "pqueue.hh"
+#include "item.hh"
/**
make balls and rests
*/
class Note_heads_engraver : public Engraver
{
- Link_array<Rhythmic_head> note_p_arr_;
+ Link_array<Item> note_p_arr_;
Link_array<Item> dot_p_arr_;
Link_array<Note_req> note_req_l_arr_;
Moment note_end_mom_;
for (int i=0; i < note_req_l_arr_.size (); i++)
{
- Rhythmic_head *note_p = new Rhythmic_head (get_property ("basicNoteHeadProperties"));
+ Item *note_p = new Item (get_property ("basicNoteHeadProperties"));
- Staff_symbol_referencer_interface::set_interface (note_p);
+ Staff_symbol_referencer::set_interface (note_p);
{
Item * d = new Item (get_property ("basicDotsProperties"));
- Staff_symbol_referencer_interface::set_interface (d);
+ Staff_symbol_referencer::set_interface (d);
- note_p->set_dots (d);
+ Rhythmic_head::set_dots (note_p, d);
if (note_req_l->duration_.dots_i_
!= gh_scm2int (d->get_elt_property ("dot-count")))
gh_list (inf.elem_l_->self_scm_, SCM_UNDEFINED));
if (to_boolean (result))
{
- Score_element::ly_set_elt_property (inf.elem_l_->self_scm_,
- gh_cadr (o->pred_sym_val_list_),
- gh_caddr (o->pred_sym_val_list_));
+ inf.elem_l_->set_elt_property (gh_cadr (o->pred_sym_val_list_),
+ gh_caddr (o->pred_sym_val_list_));
}
}
}
void
Paper_column::add_rod (Paper_column * p, Real d)
{
- Direction dir = Direction (sign (p->rank_i () - rank_i ()));
+ Direction dir = Direction (sign (rank_i(p) -rank_i (this)));
if (dir != RIGHT)
{
void
Paper_column::add_spring (Paper_column * p, Real d, Real s)
{
- Direction dir = Direction (sign (p->rank_i () - rank_i ()));
+ Direction dir = Direction (sign (rank_i(p) -rank_i (this)));
if (dir != RIGHT)
{
}
int
-Paper_column::rank_i() const
+Paper_column::rank_i(Score_element*me)
{
- return rank_i_;
+ return dynamic_cast<Paper_column*> (me)->rank_i_;
}
-void
-Paper_column::set_rank (int i)
-{
- rank_i_ = i;
-}
-
-
-
Line_of_score*
Paper_column::line_l() const
{
Paper_column::Paper_column (SCM l)
: Item (l) // guh.?
{
- Axis_group_interface (this).set_interface ();
- Axis_group_interface (this).set_axes (X_AXIS, X_AXIS);
- set_elt_pointer ("bounded-by-me", SCM_EOL);
+ Axis_group_interface::set_interface (this);
+ Axis_group_interface::set_axes (this, X_AXIS, X_AXIS);
+ set_elt_property ("bounded-by-me", SCM_EOL);
line_l_=0;
rank_i_ = -1;
}
bool
Paper_column::used_b ()const
{
- return gh_pair_p (get_elt_pointer ("elements")) || breakable_b ()
- || gh_pair_p (get_elt_pointer ("bounded-by-me"))
+ return gh_pair_p (get_elt_property ("elements")) || breakable_b ()
+ || gh_pair_p (get_elt_property ("bounded-by-me"))
;
}
{
paper_l_ =0;
outputter_l_ =0;
- line_l_ = new Line_of_score;
- element_smob_list_ = SCM_EOL;
- typeset_line (line_l_);
+ line_l_ = 0;
+ main_smob_ = SCM_EOL;
}
void
Paper_score::typeset_line (Line_of_score *l)
{
- line_l_->pscore_l_ = this;
- element_smob_list_ = gh_cons (l->self_scm_, element_smob_list_);
+ if (!line_l_)
+ {
+ line_l_ = l; // ugh.
+ }
+ main_smob_ = gh_cons (l->self_scm_, main_smob_);
+ l->pscore_l_ = this;
}
Paper_score::Paper_score (Paper_score const &s)
{
if (p->item_p_)
{
- if (Rhythmic_head* n = dynamic_cast<Rhythmic_head*> (info.elem_l_))
+ if (Rhythmic_head::has_interface (info.elem_l_))
{
- Side_position_interface st (p->item_p_);
- st.add_support (n);
- if (st.get_axis( ) == X_AXIS
+ Side_position::add_support (p->item_p_, info.elem_l_);
+
+ if (Side_position::get_axis(p->item_p_) == X_AXIS
&& !p->item_p_->parent_l (Y_AXIS))
- p->item_p_->set_parent (n, Y_AXIS);
+ p->item_p_->set_parent (info.elem_l_, Y_AXIS);
}
- if (Stem* s = dynamic_cast<Stem*> (info.elem_l_))
+ if (Stem::has_interface (info.elem_l_))
{
- Side_position_interface st (p->item_p_);
- st.add_support (s);
+ Side_position::add_support (p->item_p_,info.elem_l_);
}
}
}
p->item_p_->set_elt_property ("text", s);
// guh
- Side_position_interface si (p->item_p_);
- si.set_axis (Y_AXIS);
+ Side_position::set_axis (p->item_p_,Y_AXIS);
// todo: init with basic props.
- p->item_p_->add_offset_callback (Side_position_interface::aligned_on_self, X_AXIS);
- p->item_p_->add_offset_callback (Side_position_interface::centered_on_parent, X_AXIS);
+ p->item_p_->add_offset_callback (Side_position::aligned_on_self, X_AXIS);
+ p->item_p_->add_offset_callback (Side_position::centered_on_parent, X_AXIS);
announce_element (Score_element_info (p->item_p_,
p->req_l_drul_[START]
? p->req_l_drul_[START]
{
if (p->item_p_)
{
- Side_position_interface (p->item_p_).add_staff_support ();
+ Side_position::add_staff_support (p->item_p_);
/*
Hmm.
*/
{
if (sustain)
{
- Side_position_interface st (p->item_p_);
- st.add_support (sustain);
+ Side_position::add_support (p->item_p_,sustain);
}
}
typeset_element (p->item_p_);
*/
#include "staff-symbol-referencer.hh"
-
+#include "note-head.hh"
#include "pitch-squash-engraver.hh"
#include "rhythmic-head.hh"
void
Pitch_squash_engraver::acknowledge_element (Score_element_info i)
{
- if (to_boolean (i.elem_l_->get_elt_property ("note-head-interface")))
+ if (Note_head::has_interface (i.elem_l_))
{
- Staff_symbol_referencer_interface (i.elem_l_).set_position(0);
+ Staff_symbol_referencer::set_position (i.elem_l_,0);
}
}
name_ = s;
}
bool
-Pointer_group_interface::has_interface_b ()
+Pointer_group_interface::has_interface ()
{
- SCM el = elt_l_->get_elt_pointer (name_.ch_C());
+ SCM el = elt_l_->get_elt_property (name_.ch_C());
return el == SCM_EOL || gh_pair_p (el);
}
void
Pointer_group_interface::add_element (Score_element*p)
{
- elt_l_->set_elt_pointer (name_.ch_C(),
+ elt_l_->set_elt_property (name_.ch_C(),
gh_cons (p->self_scm_,
- elt_l_->get_elt_pointer (name_.ch_C())));
+ elt_l_->get_elt_property (name_.ch_C())));
}
int
Pointer_group_interface::count ()
{
- return scm_ilength (elt_l_->get_elt_pointer (name_.ch_C()));
+ return scm_ilength (elt_l_->get_elt_property (name_.ch_C()));
}
void
Pointer_group_interface::set_interface ()
{
- if (!has_interface_b ())
+ if (!has_interface ())
{
- elt_l_->set_elt_pointer (name_.ch_C(), SCM_EOL);
+ elt_l_->set_elt_property (name_.ch_C(), SCM_EOL);
}
}
SCM type_p = gh_cadr (entry);
SCM elt_prop_sym = gh_caddr (entry);
- SCM preset = scm_assq(elt_prop_sym, e->property_alist_);
- if (preset != SCM_BOOL_F)
+ SCM preset = e->get_elt_property (elt_prop_sym); // scm_assq(elt_prop_sym, e->property_alist_);
+ if (preset != SCM_UNDEFINED)
continue;
SCM val = get_property (prop_sym);
-
if (val == SCM_UNDEFINED)
; // Not defined in context.
else if (gh_apply (type_p, scm_listify (val, SCM_UNDEFINED))
== SCM_BOOL_T) // defined and right type: do it
- e->set_elt_property (ly_symbol2string (elt_prop_sym), val);
+ e->set_elt_property (elt_prop_sym, val);
else
/*
#include "paper-def.hh"
#include "music-list.hh"
#include "side-position-interface.hh"
+#include "spanner.hh"
+#include "note-column.hh"
struct Bar_create_event
{
void
Repeat_engraver::acknowledge_element (Score_element_info i)
{
- if (Note_column *c = dynamic_cast<Note_column *> (i.elem_l_))
- {
- if (volta_span_p_)
- Volta_spanner::add_column (volta_span_p_,c);
- if (end_volta_span_p_)
- Volta_spanner::add_column (end_volta_span_p_,c);
- }
- if (Bar *c = dynamic_cast<Bar*> (i.elem_l_))
+ if (Item* item = dynamic_cast<Item*> (i.elem_l_))
{
- if (volta_span_p_)
- Volta_spanner::add_bar (volta_span_p_,c);
- if (end_volta_span_p_)
- Volta_spanner::add_bar(end_volta_span_p_ , c);
+ if (Note_column::has_interface (item))
+ {
+ if (volta_span_p_)
+ Volta_spanner::add_column (volta_span_p_,item);
+ if (end_volta_span_p_)
+ Volta_spanner::add_column (end_volta_span_p_,item);
+ }
+ if (Bar::has_interface (item))
+ {
+ if (volta_span_p_)
+ Volta_spanner::add_bar (volta_span_p_, item);
+ if (end_volta_span_p_)
+ Volta_spanner::add_bar(end_volta_span_p_ , item);
+ }
}
}
-
void
Repeat_engraver::do_removal_processing ()
{
{
if (end_volta_span_p_)
{
- Side_position_interface (end_volta_span_p_).add_staff_support ();
+ Side_position::add_staff_support (end_volta_span_p_);
typeset_element (end_volta_span_p_ );
end_volta_span_p_ =0;
#include "collision.hh"
#include "note-column.hh"
-
class Rest_collision_engraver : public Engraver
{
Item* rest_collision_p_;
return;
rest_collision_p_ = new Item (get_property ("basicRestCollisionProperties"));
- Rest_collision (rest_collision_p_).set_interface();
+ Rest_collision::set_interface (rest_collision_p_);
announce_element (Score_element_info (rest_collision_p_, 0));
for (int i=0; i< note_column_l_arr_.size (); i++)
- Rest_collision (rest_collision_p_).add_column (note_column_l_arr_[i]);
+ Rest_collision::add_column ( rest_collision_p_,note_column_l_arr_[i]);
}
void
{
assert (a == Y_AXIS);
- Score_element * rc = unsmob_element (them->get_elt_pointer ("rest-collision"));
+ Score_element * rc = unsmob_element (them->get_elt_property ("rest-collision"));
if (rc)
{
/*
Done: destruct pointers, so we do the shift only once.
*/
- SCM elts = rc->get_elt_pointer ("elements");
- rc->set_elt_pointer ("elements", SCM_EOL);
+ SCM elts = rc->get_elt_property ("elements");
+ rc->set_elt_property ("elements", SCM_EOL);
do_shift (rc, elts);
}
}
void
-Rest_collision::add_column (Note_column *p)
+Rest_collision::add_column (Score_element*me,Note_column *p)
{
- elt_l_->add_dependency (p);
- Pointer_group_interface gi (elt_l_);
+ me->add_dependency (p);
+ Pointer_group_interface gi (me);
gi.add_element (p);
p->add_offset_callback (&Rest_collision::force_shift_callback, Y_AXIS);
- p->set_elt_pointer ("rest-collision", elt_l_->self_scm_);
+ p->set_elt_property ("rest-collision", me->self_scm_);
}
-/*
- these 3 have to go, because they're unnecessary complications.
- */
-static Duration
-to_duration (int type, int dots)
+static SCM
+head_characteristic (Score_element * col)
{
- Duration d;
- d.durlog_i_ = type;
- d.dots_i_ = dots;
- return d;
-}
-
-/*
- UGH
-
- elt_l_ should be "duration" independent
- */
-static Moment
-rhythmic_head2mom (Rhythmic_head* r)
-{
- return to_duration (r->balltype_i (), r->dot_count ()).length_mom ();
-}
+ Score_element * s = unsmob_element (col->get_elt_property ("rest"));
-/*
- ugh
- */
-static Rhythmic_head*
-col2rhythmic_head (Score_element* c)
-{
- return dynamic_cast<Rhythmic_head*> (unsmob_element (c->get_elt_pointer ("rest")));
+ if (!s)
+ return SCM_BOOL_F;
+ else
+ return gh_cons (s->get_elt_property ("duration-log"),
+ gh_int2scm (Rhythmic_head::dot_count (s)));
}
-
/*
TODO: fixme, fucks up if called twice on the same set of rests.
*/
for (SCM s = elts; gh_pair_p (s); s = gh_cdr (s))
{
Score_element * e = unsmob_element (gh_car (s));
- if (e && unsmob_element (e->get_elt_pointer ("rest")))
+ if (e && unsmob_element (e->get_elt_property ("rest")))
rests.push (dynamic_cast<Note_column*> (e));
else
notes.push (dynamic_cast<Note_column*> (e));
// meisjes met meisjes
if (!notes.size())
{
- Moment m = rhythmic_head2mom (col2rhythmic_head (rests[0]));
+
+ /*
+ FIXME: col2rhythmic_head and rhythmic_head2mom sucks bigtime.
+
+ */
+ SCM characteristic = head_characteristic (rests[0]);
int i = 1;
for (; i < rests.size (); i++)
{
- Moment me = rhythmic_head2mom (col2rhythmic_head (rests[i]));
- if (me != m)
+ if (!gh_equal_p (head_characteristic (rests[i]), characteristic))
break;
}
{
display_count = gh_scm2int (s);
for (; i > display_count; i--)
- col2rhythmic_head (rests[i-1])
- ->set_elt_property ("molecule-callback", SCM_BOOL_T);
+ {
+ Score_element* r = unsmob_element (rests[i-1]->get_elt_property ("rest"));
+ if (r)
+ r->suicide ();
+ rests[i-1]->suicide ();
+ }
}
else
display_count = rests.size ();
// FIXME
//int stafflines = 5; // rcol->rests[0]->line_count;
- int stafflines = Staff_symbol_referencer_interface (me).line_count ();
+ int stafflines = Staff_symbol_referencer::line_count (me);
// hurg?
stafflines = stafflines != 0 ? stafflines : 5;
}
void
-Rest_collision::set_interface ()
+Rest_collision::set_interface (Score_element*me)
{
- elt_l_->set_extent_callback (0, X_AXIS);
- elt_l_->set_extent_callback (0, Y_AXIS);
- elt_l_->set_elt_pointer ("elements", SCM_EOL);
+ me->set_extent_callback (0, X_AXIS);
+ me->set_extent_callback (0, Y_AXIS);
+ me->set_elt_property ("elements", SCM_EOL);
}
-Rest_collision::Rest_collision (Score_element* c)
-{
- elt_l_ = c;
-}
(c) 1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
*/
+#include "item.hh"
#include "staff-symbol-referencer.hh"
#include "musical-request.hh"
#include "dots.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_;
+ Score_element* rest_p_;
protected:
virtual bool do_try_music (Music *);
virtual void do_pre_move_processing ();
{
if (rest_req_l_ && !rest_p_)
{
- rest_p_ = new Rhythmic_head (get_property ("basicRestProperties"));
- Staff_symbol_referencer_interface::set_interface (rest_p_);
+ rest_p_ = new Item (get_property ("basicRestProperties"));
+ Rhythmic_head::set_interface (rest_p_);
+ Staff_symbol_referencer::set_interface (rest_p_);
rest_p_->set_elt_property ("duration-log",
{
dot_p_ = new Item (get_property ("basicDotsProperties"));
- Staff_symbol_referencer_interface::set_interface (dot_p_);
-
-
- rest_p_->set_dots (dot_p_);
+ Staff_symbol_referencer::set_interface (dot_p_);
+ Rhythmic_head::set_dots (rest_p_, 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",
#include "staff-symbol-referencer.hh"
// -> offset callback
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Rest,after_line_breaking);
+MAKE_SCHEME_CALLBACK(Rest,after_line_breaking);
SCM
Rest::after_line_breaking (SCM smob)
{
int bt = gh_scm2int (me->get_elt_property ("duration-log"));
if (bt == 0)
{
- Staff_symbol_referencer_interface si (me);
- me->translate_axis (si.staff_space() , Y_AXIS);
+
+ me->translate_axis (Staff_symbol_referencer::staff_space (me) , Y_AXIS);
}
- Score_element * d = unsmob_element (me->get_elt_pointer ("dot"));
+ Score_element * d = unsmob_element (me->get_elt_property ("dot"));
if (d && bt > 4) // UGH.
{
d->set_elt_property ("staff-position",
}
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Rest,brew_molecule)
+MAKE_SCHEME_CALLBACK(Rest,brew_molecule)
SCM
Rest::brew_molecule (SCM smob)
{
- Score_element* sc = unsmob_element (smob);
+ Score_element* me = unsmob_element (smob);
bool ledger_b =false;
- SCM balltype = sc->get_elt_property ("duration-log");
+ SCM balltype = me->get_elt_property ("duration-log");
if (balltype == gh_int2scm (0) || balltype == gh_int2scm (1))
{
- Staff_symbol_referencer_interface si(sc);
- ledger_b = abs(si.position_f () - (2* gh_scm2int (balltype) - 1))
- > si.line_count ();
+ int sz = Staff_symbol_referencer::line_count (me);
+ Real dif = abs(Staff_symbol_referencer::position_f (me) - (2* gh_scm2int (balltype) - 1));
+ ledger_b = dif > sz;
}
String style;
- SCM style_sym =sc->get_elt_property ("style");
+ SCM style_sym =me->get_elt_property ("style");
if (gh_scm2int (balltype) >= 2 && gh_string_p (style_sym))
{
style = ly_scm2string (style_sym);
String idx = ("rests-") + to_str (gh_scm2int (balltype))
+ (ledger_b ? "o" : "") + style;
- return sc-> lookup_l ()->afm_find (idx).create_scheme();
+ return me-> lookup_l ()->afm_find (idx).create_scheme();
}
+
+bool
+Rest::has_interface (Score_element*m)
+{
+ return m && m->has_interface (ly_symbol2scm ("rest-interface"));
+}
(c) 1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
*/
-#include "dimension-cache.hh"
+
#include "slur.hh"
#include "engraver.hh"
#include "rhythmic-head.hh"
#include "note-column.hh"
#include "dot-column.hh"
#include "musical-request.hh"
+#include "item.hh"
class Rhythmic_column_engraver :public Engraver
{
- Link_array<Rhythmic_head> rhead_l_arr_;
+ Link_array<Score_element> rhead_l_arr_;
Link_array<Slur> grace_slur_endings_;
- Stem * stem_l_;
+ Score_element * stem_l_;
Note_column *ncol_p_;
Score_element *dotcol_l_;
{
if (!ncol_p_)
{
- ncol_p_ = new Note_column (SCM_EOL);
+ ncol_p_ = new Note_column (get_property("basicNoteColumnProperties"));
announce_element (Score_element_info (ncol_p_, 0));
}
{
SCM wg = get_property ("weAreGraceContext");
bool wegrace = to_boolean (wg);
- if ((wegrace !=
- (i.elem_l_->get_elt_property ("grace") != SCM_UNDEFINED))
+ if (wegrace != to_boolean (i.elem_l_->get_elt_property ("grace"))
&& !dynamic_cast<Slur*> (i.elem_l_))
return ;
Item * item = dynamic_cast <Item *> (i.elem_l_);
- if (Stem*s=dynamic_cast<Stem *> (item))
+ if (item && Stem::has_interface (item))
{
- stem_l_ = s;
+ stem_l_ = item;
}
- else if (Rhythmic_head*r=dynamic_cast<Rhythmic_head *> (item))
+ else if (item && Rhythmic_head::has_interface (item))
{
- rhead_l_arr_.push (r);
+ rhead_l_arr_.push (item);
}
- else if (item
- && to_boolean (item->get_elt_property ("dot-column-interface")))
+ else if (item && Dot_column::has_interface (item))
{
dotcol_l_ = item;
}
Item*
-Rhythmic_head::dots_l () const
+Rhythmic_head::dots_l (Score_element*me)
{
- SCM s = get_elt_pointer ("dot");
+ SCM s = me->get_elt_property ("dot");
return dynamic_cast<Item*> (unsmob_element (s));
}
int
-Rhythmic_head::balltype_i () const
+Rhythmic_head::balltype_i (Score_element*me)
{
- SCM s = get_elt_property ("duration-log");
+ SCM s = me->get_elt_property ("duration-log");
return gh_number_p (s) ? gh_scm2int (s) : 0;
}
-Stem*
-Rhythmic_head::stem_l () const
+Item*
+Rhythmic_head::stem_l (Score_element*me)
{
- SCM s = get_elt_pointer ("stem");
- return dynamic_cast<Stem*> (unsmob_element (s));
+ SCM s = me->get_elt_property ("stem");
+ return dynamic_cast<Item*> (unsmob_element (s));
}
int
-Rhythmic_head::dot_count () const
+Rhythmic_head::dot_count (Score_element*me)
{
- return dots_l ()
- ? gh_scm2int (dots_l ()->get_elt_property ("dot-count")) : 0;
+ return dots_l (me)
+ ? gh_scm2int (dots_l (me)->get_elt_property ("dot-count")) : 0;
}
void
-Rhythmic_head::set_dots (Item *dot_l)
+Rhythmic_head::set_dots (Score_element*me,Item *dot_l)
{
- set_elt_pointer ("dot", dot_l->self_scm_);
+ me->set_elt_property ("dot", dot_l->self_scm_);
}
-Rhythmic_head::Rhythmic_head (SCM s)
- : Item (s)
+void
+Rhythmic_head::set_interface (Score_element*me)
+{
+ me->set_interface (ly_symbol2scm ("rhythmic-head-interface"));
+}
+
+bool
+Rhythmic_head::has_interface (Score_element*me)
{
+ return me && me->has_interface (ly_symbol2scm ("rhythmic-head-interface"));
}
distance_f_ = 0;
other_l_ = 0;
}
-
-int
-Column_rod::compare (const Column_rod &r1, const Column_rod &r2)
-{
- return r1.other_l_->rank_i() - r2.other_l_->rank_i();
-}
-
void
Rod::columnize ()
+#if 0
/*
score-element-callback.cc -- implement Callback smob.
}
ADD_SCM_INIT_FUNC(callback, start_callback_smobs);
+#endif
status_i_ = 0;
self_scm_ = SCM_EOL;
original_l_ = 0;
- property_alist_ = basicprops;
- pointer_alist_ = SCM_EOL;
-
+ immutable_property_alist_ = basicprops;
+ mutable_property_alist_ = SCM_EOL;
+
smobify_self ();
- set_elt_pointer ("dependencies", SCM_EOL);
- set_elt_property ("interfaces", SCM_EOL);
+ set_elt_property ("dependencies", SCM_EOL);
+
+ if (get_elt_property ("interfaces") == SCM_UNDEFINED)
+ set_elt_property ("interfaces", SCM_EOL);
}
{
self_scm_ = SCM_EOL;
original_l_ =(Score_element*) &s;
- property_alist_ = s.property_alist_;
-
- pointer_alist_ = SCM_EOL;
+ immutable_property_alist_ = s.immutable_property_alist_;
+ mutable_property_alist_ = SCM_EOL;
status_i_ = s.status_i_;
lookup_l_ = s.lookup_l_;
SCM
-Score_element::get_elt_pointer (const char *nm) const
+Score_element::get_elt_property (const char *nm) const
{
- SCM sym = ly_symbol2scm (nm);
- SCM s = scm_assq(sym, pointer_alist_);
-
- return (s == SCM_BOOL_F) ? SCM_UNDEFINED : gh_cdr (s);
+ SCM sym = ly_symbol2scm (nm);
+ return get_elt_property (sym);
}
-// should also have one that takes SCM arg.
SCM
-Score_element::get_elt_property (String nm) const
+Score_element::get_elt_property (SCM sym) const
{
- SCM sym = ly_symbol2scm (nm.ch_C());
- SCM s = scm_assq(sym, property_alist_);
-
+ SCM s = scm_assq(sym, mutable_property_alist_);
if (s != SCM_BOOL_F)
- return gh_cdr (s);
+ return gh_cdr (s);
- return SCM_UNDEFINED;
+ s = scm_assq (sym, immutable_property_alist_);
+ return (s == SCM_BOOL_F) ? SCM_UNDEFINED : gh_cdr (s);
}
/*
}
void
-Score_element::set_elt_property (String k, SCM val)
+Score_element::set_elt_property (const char* k, SCM v)
{
- SCM sym = ly_symbol2scm (k.ch_C ());
- property_alist_ = gh_cons (gh_cons (sym, val), property_alist_);
+ SCM s = ly_symbol2scm (k);
+ set_elt_property (s, v);
}
+/*
+ Puts the k, v in the immutable_property_alist_, which is convenient for
+ storing variables that are needed during the breaking process. (eg.
+ Line_of_score::rank : int )
+ */
void
-Score_element::set_elt_pointer (const char* k, SCM v)
+Score_element::set_immutable_elt_property (const char*k, SCM v)
{
SCM s = ly_symbol2scm (k);
- pointer_alist_ = scm_assq_set_x (pointer_alist_, s, v);
+ set_immutable_elt_property (s, v);
+}
+
+void
+Score_element::set_immutable_elt_property (SCM s, SCM v)
+{
+ immutable_property_alist_ = gh_cons (gh_cons (s,v), mutable_property_alist_);
+ mutable_property_alist_ = scm_assq_remove_x (mutable_property_alist_, s);
+}
+void
+Score_element::set_elt_property (SCM s, SCM v)
+{
+ mutable_property_alist_ = scm_assq_set_x (mutable_property_alist_, s, v);
}
status_i_= busy;
- for (SCM d= get_elt_pointer ("dependencies"); gh_pair_p (d); d = gh_cdr (d))
+ for (SCM d= get_elt_property ("dependencies"); gh_pair_p (d); d = gh_cdr (d))
{
unsmob_element (gh_car (d))
->calculate_dependencies (final, busy, funcname);
}
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Score_element,brew_molecule)
+MAKE_SCHEME_CALLBACK(Score_element,brew_molecule)
/*
ugh.
{
Score_element * sc = s->broken_into_l_arr_[i];
Line_of_score * l = sc->line_l ();
- sc->pointer_alist_ =
- handle_broken_smobs (pointer_alist_,
+ sc->mutable_property_alist_ =
+ handle_broken_smobs (mutable_property_alist_,
l ? l->self_scm_ : SCM_UNDEFINED);
}
}
if (line && common_refpoint (line, X_AXIS) && common_refpoint (line, Y_AXIS))
{
- pointer_alist_
- = handle_broken_smobs (pointer_alist_,
+ mutable_property_alist_
+ = handle_broken_smobs (mutable_property_alist_,
line ? line->self_scm_ : SCM_UNDEFINED);
}
else if (dynamic_cast <Line_of_score*> (this))
{
- pointer_alist_ = handle_broken_smobs (pointer_alist_,
+ mutable_property_alist_ = handle_broken_smobs (mutable_property_alist_,
SCM_UNDEFINED);
}
else
void
Score_element::suicide ()
{
- property_alist_ = SCM_EOL;
- pointer_alist_ = SCM_EOL;
+ mutable_property_alist_ = SCM_EOL;
+ immutable_property_alist_ = SCM_EOL;
set_extent_callback (0, Y_AXIS);
set_extent_callback (0, X_AXIS);
dim_cache_[a].parent_l_ = g;
}
-void
-Score_element::fixup_refpoint ()
+MAKE_SCHEME_CALLBACK(Score_element,fixup_refpoint);
+SCM
+Score_element::fixup_refpoint (SCM smob)
{
+ Score_element *me = unsmob_element (smob);
for (int a = X_AXIS; a < NO_AXES; a ++)
{
Axis ax = (Axis)a;
- Score_element * parent = parent_l (ax);
+ Score_element * parent = me->parent_l (ax);
if (!parent)
continue;
- if (parent->line_l () != line_l () && line_l ())
+ if (parent->line_l () != me->line_l () && me->line_l ())
{
- Score_element * newparent = parent->find_broken_piece (line_l ());
- set_parent (newparent, ax);
+ Score_element * newparent = parent->find_broken_piece (me->line_l ());
+ me->set_parent (newparent, ax);
}
- if (Item * i = dynamic_cast<Item*> (this))
+ if (Item * i = dynamic_cast<Item*> (me))
{
Item *parenti = dynamic_cast<Item*> (parent);
if (my_dir!= parenti->break_status_dir())
{
Item *newparent = parenti->find_prebroken_piece (my_dir);
- set_parent (newparent, ax);
+ me->set_parent (newparent, ax);
}
}
}
}
+ return smob;
}
programming_error ("SMOB marking gone awry");
return SCM_EOL;
}
- scm_gc_mark (s->pointer_alist_);
+ scm_gc_mark ( s->immutable_property_alist_);
s->do_derived_mark ();
if (s->parent_l (Y_AXIS))
if (s->parent_l (X_AXIS))
scm_gc_mark (s->parent_l (X_AXIS)->self_scm_);
- return s->property_alist_;
+ return s->mutable_property_alist_;
}
int
SCM
-Score_element::ly_set_elt_property (SCM elt, SCM sym, SCM val)
+ly_set_elt_property (SCM elt, SCM sym, SCM val)
{
Score_element * sc = unsmob_element (elt);
if (sc)
{
- sc->property_alist_ = scm_assq_set_x (sc->property_alist_, sym, val);
+ sc->set_elt_property (sym, val);
}
else
{
SCM
-Score_element::ly_get_elt_property (SCM elt, SCM sym)
+ly_get_elt_property (SCM elt, SCM sym)
{
Score_element * sc = unsmob_element (elt);
if (sc)
{
- SCM s = scm_assq(sym, sc->property_alist_);
-
- if (s != SCM_BOOL_F)
- return gh_cdr (s);
- else
- return SCM_UNDEFINED;
+ return sc->get_elt_property (sym);
}
else
{
}
+
SCM
spanner_get_bound (SCM slur, SCM dir)
{
return dynamic_cast<Spanner*> (unsmob_element (slur))->get_bound (to_dir (dir))->self_scm_;
}
-SCM
-score_element_get_pointer (SCM se, SCM name)
+
+
+static SCM interfaces_sym;
+
+static void
+init_functions ()
{
- SCM s = scm_assq (name, unsmob_element (se)->pointer_alist_);
- return (s == SCM_BOOL_F) ? SCM_UNDEFINED : gh_cdr (s);
+ interfaces_sym = scm_permanent_object (ly_symbol2scm ("interfaces"));
+
+ scm_make_gsubr ("ly-get-elt-property", 2, 0, 0, (SCM(*)(...))ly_get_elt_property);
+ scm_make_gsubr ("ly-set-elt-property", 3, 0, 0, (SCM(*)(...))ly_set_elt_property);
+ scm_make_gsubr ("ly-get-spanner-bound", 2 , 0, 0, (SCM(*)(...)) spanner_get_bound);
}
-SCM
-score_element_get_property (SCM se, SCM name)
+bool
+Score_element::has_interface (SCM k)
{
- SCM s = scm_assq (name, unsmob_element (se)->property_alist_);
- return (s == SCM_BOOL_F) ? SCM_UNDEFINED : gh_cdr (s);
-}
+ if (mutable_property_alist_ == SCM_EOL)
+ return false;
+
+ SCM ifs = get_elt_property (interfaces_sym);
+ return scm_memq (k, ifs) != SCM_BOOL_F;
+}
-static void
-init_functions ()
+void
+Score_element::set_interface (SCM k)
{
- scm_make_gsubr ("ly-get-elt-property", 2, 0, 0, (SCM(*)(...))Score_element::ly_get_elt_property);
- scm_make_gsubr ("ly-set-elt-property", 3, 0, 0, (SCM(*)(...))Score_element::ly_set_elt_property);
- scm_make_gsubr ("ly-get-elt-pointer", 2 , 0, 0,
- (SCM(*)(...)) score_element_get_pointer);
- scm_make_gsubr ("ly-get-spanner-bound", 2 , 0, 0,
- (SCM(*)(...)) spanner_get_bound);
+ if (has_interface (k))
+ return ;
+ else
+ {
+ set_elt_property (interfaces_sym,
+ gh_cons (k, get_elt_property (interfaces_sym)));
+ }
}
+
+
ADD_SCM_INIT_FUNC(scoreelt, init_functions);
*/
#include "debug.hh"
-#include "dimension-cache.hh"
+
#include "line-of-score.hh"
#include "item.hh"
#include "score-engraver.hh"
if (!elem_p->parent_l (X_AXIS))
{
bool br = to_boolean (elem_p->get_elt_property ("breakable"));
- Axis_group_interface gi ((br) ? command_column_l_ : musical_column_l_) ;
- gi.add_element(elem_p);
+ Axis_group_interface::add_element (br ? command_column_l_ : musical_column_l_, elem_p);
+
}
}
if (!elem_p->parent_l(Y_AXIS))
- Axis_group_interface (scoreline_l_).add_element (elem_p);
+ Axis_group_interface::add_element (scoreline_l_, elem_p);
}
elem_p_arr_.clear();
}
assert (!daddy_trans_l_);
pscore_p_ = new Paper_score;
pscore_p_->paper_l_ = dynamic_cast<Paper_def*>(output_def_l_);
+
+ pscore_p_->typeset_line (new Line_of_score (get_property(ly_symbol2scm ("basicLineOfScoreProperties"))));
}
void
Script_column_engraver::acknowledge_element( Score_element_info inf)
{
- if (Side_position_interface (inf.elem_l_).has_interface_b ())
+ if (Side_position::has_interface (inf.elem_l_))
{
Item *thing = dynamic_cast<Item*> (inf.elem_l_);
if (thing
&& !thing->breakable_b ()
- && Side_position_interface (inf.elem_l_).get_axis () == Y_AXIS)
+ && Side_position::get_axis (inf.elem_l_) == Y_AXIS)
{
script_l_arr_.push (thing);
}
if (!scol_p_ && script_l_arr_.size () > 1)
{
scol_p_ = new Item (get_property ("basicScriptColumnProperties"));
- scol_p_->set_elt_pointer ("scripts", SCM_EOL);
+ scol_p_->set_elt_property ("scripts", SCM_EOL);
announce_element (Score_element_info (scol_p_, 0));
}
*/
#include "script-column.hh"
#include "side-position-interface.hh"
-#include "dimension-cache.hh"
+
#include "group-interface.hh"
void
return gh_scm2int (p1) - gh_scm2int (p2);
}
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Script_column,before_line_breaking);
+MAKE_SCHEME_CALLBACK(Script_column,before_line_breaking);
SCM
Script_column::before_line_breaking (SCM smob)
for (int i=0; i < staff_sided.size (); i++)
{
- Side_position_interface st (staff_sided[i]);
- arrs[st.get_direction ()].push (staff_sided[i]);
+ arrs[Side_position::get_direction (staff_sided[i])]
+ .push (staff_sided[i]);
}
Direction d = DOWN;
Score_element * last = 0;
for (int i=0; i < arr.size (); i++)
{
- Side_position_interface s (arr[i]);
+
if (last)
- {
- s.add_support (last);
- }
+ Side_position::add_support( arr[i],last);
arr[i]->remove_elt_property ("script-priority");
last = arr[i];
#include "side-position-interface.hh"
#include "musical-request.hh"
#include "stem.hh"
-#include "staff-symbol.hh"
#include "rhythmic-head.hh"
-#include "dimension-cache.hh"
+
#include "engraver.hh"
// 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);
-
+ p->add_offset_callback (Side_position::centered_on_parent, X_AXIS);
list = gh_cdr (list);
p->set_elt_property ("molecule",
if (relative_stem_dir)
p->set_elt_property ("side-relative-direction", gh_int2scm (relative_stem_dir));
else
- stafy.set_direction ((Direction)force_dir);
+ Side_position::set_direction (p,(Direction)force_dir);
if (l->get_direction ())
- stafy.set_direction (l->get_direction ());
+ Side_position::set_direction (p, l->get_direction ());
SCM axisprop = get_property ("scriptHorizontal");
bool xaxis = to_boolean (axisprop);
- if (xaxis)
- stafy.set_axis (X_AXIS);
- else
- stafy.set_axis (Y_AXIS);
+ Side_position::set_axis (p, xaxis ? X_AXIS : Y_AXIS);
if (!follow_staff && ! xaxis)
p->set_elt_property ("staff-support", SCM_BOOL_T);
if (!xaxis && follow_staff)
- stafy.set_quantised (Y_AXIS);
+ p->add_offset_callback (Side_position::quantised_position, Y_AXIS);
+
p->set_elt_property ("script-priority", priority);
if (us_grace != them_grace)
return;
- if (Stem *s = dynamic_cast<Stem*>(inf.elem_l_))
+ if (Stem::has_interface (inf.elem_l_))
{
for (int i=0; i < script_p_arr_.size(); i++)
{
- Side_position_interface stafy (script_p_arr_[i]);
- stafy.elt_l_->set_elt_property ("direction-source", s->self_scm_);
- stafy.add_support (s);
+ Score_element*e = script_p_arr_[i];
+
+ e->set_elt_property ("direction-source", inf.elem_l_->self_scm_);
+ Side_position::add_support (e, inf.elem_l_);
}
}
- else if (Rhythmic_head * rh = dynamic_cast<Rhythmic_head*>(inf.elem_l_))
+ else if (Rhythmic_head::has_interface (inf.elem_l_))
{
for (int i=0; i < script_p_arr_.size(); i++)
{
- Side_position_interface stafy(script_p_arr_[i]);
+ Score_element *e = script_p_arr_[i];
- if (!stafy.elt_l_->parent_l (X_AXIS))
+ if (!e->parent_l (X_AXIS))
{
- stafy.elt_l_->set_parent (inf.elem_l_, X_AXIS);
+ e->set_parent (inf.elem_l_, X_AXIS);
}
- if (stafy.get_axis () == X_AXIS
- && !stafy.elt_l_->parent_l (Y_AXIS))
- stafy.elt_l_->set_parent (rh, Y_AXIS);
+ if (Side_position::get_axis (e) == X_AXIS
+ && !e->parent_l (Y_AXIS))
+ e->set_parent (inf.elem_l_, Y_AXIS);
- stafy.add_support (rh);
+ Side_position::add_support (e,inf.elem_l_);
}
}
}
Script * sc = script_p_arr_[i];
if (to_boolean (sc->remove_elt_property ("staff-support")))
{
- Side_position_interface (sc).add_staff_support ();
+ Side_position::add_staff_support (sc);
}
typeset_element (sc);
}
#include "lookup.hh"
#include "side-position-interface.hh"
#include "paper-def.hh"
-#include "dimension-cache.hh"
+
Script ::Script (SCM s)
: Item (s)
-
-GLUE_SCORE_ELEMENT(Script,after_line_breaking);
+MAKE_SCHEME_CALLBACK(Script,after_line_breaking);
SCM
-Script::member_after_line_breaking ()
+Script::after_line_breaking (SCM smob)
{
- Side_position_interface i (this);
- Direction d = i.get_direction ();
- i.set_direction (d);
+ Score_element * me = unsmob_element (smob);
+
+ Direction d = Side_position::get_direction (me);
+ Side_position::set_direction (me,d);
return SCM_UNDEFINED;
}
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Script,brew_molecule);
+MAKE_SCHEME_CALLBACK(Script,brew_molecule);
SCM
Script::brew_molecule (SCM smob)
{
Array<Rod> a;
- for (SCM s = get_elt_pointer ("elements"); gh_pair_p (s) && gh_pair_p (gh_cdr (s)); s = gh_cdr (s))
+ for (SCM s = get_elt_property ("elements"); gh_pair_p (s) && gh_pair_p (gh_cdr (s)); s = gh_cdr (s))
{
/*
Order of elements is reversed!
/*
We've done our job, so we get lost.
*/
- for (SCM s = get_elt_pointer ("elements"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = get_elt_property ("elements"); gh_pair_p (s); s = gh_cdr (s))
{
Item * it =dynamic_cast<Item*>(unsmob_element (gh_car (s)));
if (it && it->broken_b ())
}
void
-Separating_group_spanner::add_spacing_unit (Item*i)
+Separating_group_spanner::add_spacing_unit (Score_element* me ,Item*i)
{
- Pointer_group_interface (this, "elements").add_element (i);
- add_dependency (i);
+ Pointer_group_interface (me, "elements").add_element (i);
+ me->add_dependency (i);
}
Separating_group_spanner::Separating_group_spanner (SCM s)
: Spanner (s)
{
- set_elt_pointer ("elements", SCM_EOL);
+ set_elt_property ("elements", SCM_EOL);
}
/*
- separating-line-group-grav.cc -- implement Separating_line_group_engraver
+ separating-line-group-engraver.cc -- implement Separating_line_group_engraver
source file of the GNU LilyPond music typesetter
void
Separating_line_group_engraver::do_creation_processing ()
{
- sep_span_p_ = new Separating_group_spanner (SCM_EOL);
+ sep_span_p_ = new Separating_group_spanner (get_property ("basicSeparatingGroupSpannerProperties"));
announce_element (Score_element_info (sep_span_p_, 0));
sep_span_p_->set_bound (LEFT, unsmob_element (get_property ("currentCommandColumn")));
}
if (!p_ref_)
{
- p_ref_
- = new Item
- (get_property ("basicSingleMaltGroupingItemProperties"));
+ p_ref_ = new Item
+ (get_property ("basicSeparationItemProperties"));
if (ib)
p_ref_->set_elt_property ("breakable", SCM_BOOL_T);
{
if (break_malt_p_)
{
- sep_span_p_->add_spacing_unit (break_malt_p_);
+ Separating_group_spanner::add_spacing_unit (sep_span_p_, break_malt_p_);
typeset_element (break_malt_p_);
break_malt_p_ =0;
}
if (nobreak_malt_p_)
{
- sep_span_p_->add_spacing_unit (nobreak_malt_p_);
+ Separating_group_spanner::add_spacing_unit (sep_span_p_, nobreak_malt_p_);
typeset_element (nobreak_malt_p_);
nobreak_malt_p_ =0;
}
-ADD_THIS_TRANSLATOR( Separating_line_group_engraver);
+ADD_THIS_TRANSLATOR(Separating_line_group_engraver);
void
Separation_item::set_interface (Score_element*s)
{
- s->set_elt_pointer ("elements", SCM_EOL);
+ s->set_elt_property ("elements", SCM_EOL);
s->set_extent_callback (0, X_AXIS);
s->set_extent_callback (0, Y_AXIS);
}
Paper_column * pc = item->column_l ();
Interval w;
- for (SCM s = me->get_elt_pointer ("elements"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = me->get_elt_property ("elements"); gh_pair_p (s); s = gh_cdr (s))
{
SCM elt = gh_car (s);
if (!SMOB_IS_TYPE_B(Score_element, elt))
#include <math.h> // ceil.
#include "side-position-interface.hh"
-#include "staff-symbol.hh"
#include "debug.hh"
#include "warn.hh"
#include "dimensions.hh"
-#include "dimension-cache.hh"
+
#include "staff-symbol-referencer.hh"
#include "group-interface.hh"
-Side_position_interface::Side_position_interface (Score_element const *e)
-{
- elt_l_ = (Score_element*)e;
-}
-
void
-Side_position_interface::add_support (Score_element*e)
+Side_position::add_support (Score_element*me, Score_element*e)
{
- Pointer_group_interface (elt_l_, "side-support-elements").add_element (e);
+ Pointer_group_interface (me, "side-support-elements").add_element (e);
}
Direction
-Side_position_interface::get_direction () const
+Side_position::get_direction (Score_element*me)
{
- SCM d = elt_l_->get_elt_property ("direction");
+ SCM d = me->get_elt_property ("direction");
if (isdir_b (d))
return to_dir (d) ? to_dir (d) : DOWN;
Direction relative_dir = UP;
- SCM reldir = elt_l_->get_elt_property ("side-relative-direction"); // should use a lambda.
+ SCM reldir = me->get_elt_property ("side-relative-direction"); // should use a lambda.
if (isdir_b (reldir))
{
relative_dir = to_dir (reldir);
}
- SCM other_elt = elt_l_->get_elt_pointer ("direction-source");
+ SCM other_elt = me->get_elt_property ("direction-source");
Score_element * e = unsmob_element(other_elt);
if (e)
{
- return (Direction)(relative_dir * Side_position_interface (e).get_direction ());
+ return (Direction)(relative_dir * Side_position::get_direction (e));
}
return DOWN;
*/
Real
-Side_position_interface::side_position (Score_element *cme, Axis axis)
+Side_position::side_position (Score_element *cme, Axis axis)
{
Score_element* me = (Score_element*)cme;
Score_element *common = me->parent_l (axis);
- SCM support = me->get_elt_pointer ("side-support-elements");
+ SCM support = me->get_elt_property ("side-support-elements");
for (SCM s = support; s != SCM_EOL; s = gh_cdr (s))
{
Score_element * e = unsmob_element (gh_car (s));
dim = Interval(0,0);
}
- Direction dir = Side_position_interface (me).get_direction ();
+ Direction dir = Side_position::get_direction (me);
Real off = me->parent_l (axis)->relative_coordinate (common, axis);
SCM minimum = me->remove_elt_property ("minimum-space");
callback that centers the element on itself
*/
Real
-Side_position_interface::aligned_on_self (Score_element *elm, Axis ax)
+Side_position::aligned_on_self (Score_element *elm, Axis ax)
{
String s ("self-alignment-");
s += (ax == X_AXIS) ? "X" : "Y";
- SCM align (elm->get_elt_property (s));
+ SCM align (elm->get_elt_property (s.ch_C()));
if (isdir_b (align))
{
Direction d = to_dir (align);
Callback that quantises in staff-spaces, rounding in the direction
of the elements "direction" elt property. */
Real
-Side_position_interface::quantised_position (Score_element *me, Axis a)
+Side_position::quantised_position (Score_element *me, Axis )
{
- Side_position_interface s(me);
- Direction d = s.get_direction ();
+ Direction d = Side_position::get_direction (me);
- if (Staff_symbol_referencer_interface::has_interface_b (me))
+ if (Staff_symbol_referencer::has_interface (me))
{
- Staff_symbol_referencer_interface si (me);
- Real p = si.position_f ();
+ Real p = Staff_symbol_referencer::position_f (me);
Real rp = directed_round (p, d);
int ip = int (rp);
rp += d;
}
- return (rp - p) * si.staff_space () / 2.0;
+ return (rp - p) * Staff_symbol_referencer::staff_space (me) / 2.0;
}
return 0.0;
}
Position next to support, taking into account my own dimensions and padding.
*/
Real
-Side_position_interface::aligned_side (Score_element *me, Axis ax)
+Side_position::aligned_side (Score_element *me, Axis ax)
{
- Side_position_interface s(me);
- Direction d = s.get_direction ();
+
+ Direction d = Side_position ::get_direction (me);
Real o = side_position (me,ax);
Interval iv = me->extent (ax);
Position centered on parent.
*/
Real
-Side_position_interface::centered_on_parent (Score_element * me, Axis a)
+Side_position::centered_on_parent (Score_element * me, Axis a)
{
Score_element *him = me->parent_l (a);
void
-Side_position_interface::add_staff_support ()
+Side_position::add_staff_support (Score_element*me)
{
- Staff_symbol_referencer_interface si (elt_l_);
- if (si.staff_symbol_l ())
+ Score_element* st = Staff_symbol_referencer::staff_symbol_l (me);
+ if (st)
{
- add_support (si.staff_symbol_l ());
+ add_support (me,st);
}
}
void
-Side_position_interface::set_axis (Axis a)
+Side_position::set_axis (Score_element*me, Axis a)
{
// prop transparent ?
- if (elt_l_->get_elt_pointer ("side-support-elements") == SCM_UNDEFINED)
- elt_l_->set_elt_pointer ("side-support-elements" ,SCM_EOL);
+ if (me->get_elt_property ("side-support-elements") == SCM_UNDEFINED)
+ me->set_elt_property ("side-support-elements" ,SCM_EOL);
- if (!elt_l_->has_offset_callback_b (aligned_side, a))
- elt_l_->add_offset_callback (aligned_side, a);
+ if (!me->has_offset_callback_b (aligned_side, a))
+ me->add_offset_callback (aligned_side, a);
}
-void
-Side_position_interface::set_quantised (Axis a)
-{
- elt_l_->add_offset_callback (quantised_position, a);
-}
+
Axis
-Side_position_interface::get_axis () const
+Side_position::get_axis (Score_element*me)
{
- if (elt_l_->has_offset_callback_b (&side_position, X_AXIS)
- || elt_l_->has_offset_callback_b (&aligned_side , X_AXIS))
+ if (me->has_offset_callback_b (&side_position, X_AXIS)
+ || me->has_offset_callback_b (&aligned_side , X_AXIS))
return X_AXIS;
}
void
-Side_position_interface::set_direction (Direction d)
+Side_position::set_direction (Score_element*me, Direction d)
{
- elt_l_->set_elt_property ("direction", gh_int2scm (d));
+ me->set_elt_property ("direction", gh_int2scm (d));
}
void
-Side_position_interface::set_minimum_space (Real m)
+Side_position::set_minimum_space (Score_element*me, Real m)
{
- elt_l_->set_elt_property ("minimum-space", gh_double2scm (m));
+ me->set_elt_property ("minimum-space", gh_double2scm (m));
}
void
-Side_position_interface::set_padding (Real p)
+Side_position::set_padding (Score_element*me, Real p)
{
- elt_l_->set_elt_property ("padding", gh_double2scm (p));
+ me->set_elt_property ("padding", gh_double2scm (p));
}
bool
-Side_position_interface::has_interface_b () const
+Side_position::has_interface (Score_element*me)
{
- return elt_l_->get_elt_pointer ("side-support-elements") != SCM_UNDEFINED;
+ return me->get_elt_property ("side-support-elements") != SCM_UNDEFINED;
}
bool
-Side_position_interface::supported_b () const
+Side_position::supported_b (Score_element*me)
{
- SCM s =elt_l_->get_elt_pointer ("side-support-elements");
+ SCM s =me->get_elt_property ("side-support-elements");
return s != SCM_UNDEFINED && s != SCM_EOL;
}
: Spanner (s)
{
set_elt_property ("attachment", gh_cons (SCM_BOOL_F, SCM_BOOL_F));
- set_elt_pointer ("note-columns", SCM_EOL);
+ set_elt_property ("note-columns", SCM_EOL);
set_elt_property ("control-points", SCM_EOL);
}
void
Slur::add_column (Note_column*n)
{
- if (!gh_pair_p (n->get_elt_pointer ("note-heads")))
+ if (!gh_pair_p (n->get_elt_property ("note-heads")))
warning (_ ("Putting slur over rest. Ignoring."));
else
{
Score_element **common) const
{
Offset o;
- Score_element* stem_l = unsmob_element (col->get_elt_pointer ("stem"));
+ Score_element* stem_l = unsmob_element (col->get_elt_property ("stem"));
Direction dir = Directional_element_interface (this).get ();
return o;
}
-GLUE_SCORE_ELEMENT(Slur,after_line_breaking);
+MAKE_SCHEME_CALLBACK(Slur,after_line_breaking);
SCM
-Slur::member_after_line_breaking ()
+Slur::after_line_breaking (SCM smob)
{
- set_extremities ();
- set_control_points ();
+ Score_element *me = unsmob_element (smob);
+ Slur * sl = dynamic_cast<Slur*>(me);
+ sl->set_extremities ();
+ sl->set_control_points ();
return SCM_UNDEFINED;
}
SCM s = get_elt_property ("attachment");
SCM a = dir == LEFT ? gh_car (s) : gh_cdr (s);
String str = ly_symbol2string (a);
- Real ss = Staff_symbol_referencer_interface (this).staff_space ();
+ Real ss = Staff_symbol_referencer::staff_space ((Score_element*)this);
Real hs = ss / 2.0;
Offset o;
if (Note_column* n = dynamic_cast<Note_column*> (get_bound (dir)))
{
- if (Stem* st = dynamic_cast<Stem*> (n->stem_l ()))
+ if (n->stem_l ())
{
+ Score_element*st = n->stem_l();
if (str == "head")
{
- o = Offset (0, st->chord_start_f ());
+ o = Offset (0, Stem::chord_start_f (st ));
/*
Default position is centered in X, on outer side of head Y
*/
}
else if (str == "alongside-stem")
{
- o = Offset (0, st->chord_start_f ());
+ o = Offset (0, Stem::chord_start_f (st ));
/*
Default position is on stem X, on outer side of head Y
*/
o += Offset (n->extent (X_AXIS).length ()
- * (1 + st->get_direction ()),
+ * (1 + Stem::get_direction (st )),
0.5 * ss * Directional_element_interface (this).get ());
}
else if (str == "stem")
{
- o = Offset (0, st->stem_end_position () * hs);
+ o = Offset (0, Stem::stem_end_position (st ) * hs);
/*
Default position is on stem X, at stem end Y
*/
o += Offset (0.5 *
(n->extent (X_AXIS).length ()
- st->extent (X_AXIS).length ())
- * (1 + st->get_direction ()),
+ * (1 + Stem::get_direction (st )),
0);
}
else if (str == "loose-end")
SCM l = scm_assoc
(scm_listify (a,
- gh_int2scm (st->get_direction () * dir),
+ gh_int2scm (Stem::get_direction (st ) * dir),
gh_int2scm (Directional_element_interface (this).get () * dir),
SCM_UNDEFINED),
scm_eval (ly_symbol2scm ("slur-extremity-offset-alist")));
Array<Offset>
Slur::get_encompass_offset_arr () const
{
- SCM eltlist = get_elt_pointer ("note-columns");
+ SCM eltlist = get_elt_property ("note-columns");
Score_element *common[] = {common_refpoint (eltlist,X_AXIS),
common_refpoint (eltlist,Y_AXIS)};
/*
Ugh should have dash-length + dash-period
*/
-GLUE_SCORE_ELEMENT(Slur,brew_molecule);
+MAKE_SCHEME_CALLBACK(Slur,brew_molecule);
SCM
-Slur::member_brew_molecule () const
+Slur::brew_molecule (SCM smob)
{
- Real thick = paper_l ()->get_var ("slur_thickness");
- Bezier one = get_curve ();
+ Slur * me = dynamic_cast<Slur*> (unsmob_element (smob));
+
+
+ Real thick = me->paper_l ()->get_var ("slur_thickness");
+ Bezier one = 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, thick * gh_scm2double (d));
+ a = me->lookup_l ()->dashed_slur (one, thick, thick * gh_scm2double (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();
}
Slur_bezier_bow bb (get_encompass_offset_arr (),
Directional_element_interface (this).get ());
- Real staff_space = Staff_symbol_referencer_interface (this).staff_space ();
+ Real staff_space = Staff_symbol_referencer::staff_space (this);
Real h_inf = paper_l ()->get_var ("slur_height_limit_factor") * staff_space;
Real r_0 = paper_l ()->get_var ("slur_ratio");
(c) 1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
*/
-#include "dimension-cache.hh"
+
#include "lily-guile.hh"
+#include "bar.hh"
+#include "item.hh"
#include "span-bar.hh"
#include "engraver.hh"
+
/**
Make bars that span multiple "staffs". Catch bars, and span a
*/
class Span_bar_engraver : public Engraver
{
- Span_bar * spanbar_p_;
- Link_array<Bar> bar_l_arr_;
+ Item * spanbar_p_;
+ Link_array<Item> bar_l_arr_;
public:
VIRTUAL_COPY_CONS(Translator);
protected:
virtual void acknowledge_element (Score_element_info);
virtual void do_pre_move_processing();
- virtual Span_bar* get_span_bar_p(SCM) const;
+
};
spanbar_p_ =0;
}
-Span_bar*
-Span_bar_engraver::get_span_bar_p(SCM s) const
-{
- Span_bar * sp= new Span_bar (s);
- return sp;
-}
void
{
int depth = i.origin_trans_l_arr (this).size();
if (depth > 1
- && dynamic_cast<Bar *> (i.elem_l_))
+ && Bar::has_interface (i.elem_l_))
{
- bar_l_arr_.push (dynamic_cast<Bar *> (i.elem_l_));
+ Item * it = dynamic_cast<Item*>(i.elem_l_);
+ bar_l_arr_.push (it);
if (bar_l_arr_.size() >= 2 && !spanbar_p_)
{
- spanbar_p_ = get_span_bar_p (get_property ("basicSpanBarProperties"));
+ spanbar_p_ = new Item (get_property ("basicSpanBarProperties"));
+ Span_bar::set_interface (spanbar_p_);
spanbar_p_->set_elt_property ("glyph", bar_l_arr_[0]->get_elt_property ("glyph"));
spanbar_p_->set_elt_property ("visibility-lambda",
bar_l_arr_[0]->get_elt_property ("visibility-lambda"));
if (spanbar_p_)
{
for (int i=0; i < bar_l_arr_.size() ; i++)
- spanbar_p_->add_bar (bar_l_arr_[i]);
+ Span_bar::add_bar( spanbar_p_,bar_l_arr_[i]);
typeset_element (spanbar_p_);
spanbar_p_ =0;
}
(c) 1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
*/
-#include "dimension-cache.hh"
+
#include "span-bar.hh"
#include "lookup.hh"
#include "dimensions.hh"
#include "warn.hh"
#include "axis-group-interface.hh"
#include "group-interface.hh"
+#include "score-element.hh"
+#include "bar.hh"
void
-Span_bar::add_bar (Score_element*b)
+Span_bar::add_bar (Score_element*me, Score_element*b)
{
- Pointer_group_interface gi (this);
+ Pointer_group_interface gi (me);
gi.add_element (b);
- add_dependency (b);
+ me->add_dependency (b);
}
-
Interval
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"));
+ String gl = ly_scm2string (se->get_elt_property ("glyph"));
/*
urg.
*/
- Molecule m = s->compound_barline (gl, 40 PT);
+ Molecule m = Bar::compound_barline (se, gl, 40 PT);
return m.extent (X_AXIS);
}
-GLUE_SCORE_ELEMENT(Span_bar,before_line_breaking);
+MAKE_SCHEME_CALLBACK(Span_bar,before_line_breaking);
SCM
-Span_bar::member_before_line_breaking ()
+Span_bar::before_line_breaking (SCM smob)
{
- Bar::member_before_line_breaking ();
+ Bar::before_line_breaking (smob);
- evaluate_empty ();
+ evaluate_empty (unsmob_element (smob));
return SCM_UNDEFINED;
}
-GLUE_SCORE_ELEMENT(Span_bar,after_line_breaking);
-SCM
-Span_bar::member_after_line_breaking ()
+Real
+Span_bar::center_on_spanned_callback (Score_element * me, Axis a)
{
- Interval i (get_spanned_interval ());
+ assert (a == Y_AXIS);
+ Interval i (get_spanned_interval (me));
/*
Bar::brew_molecule delivers a barline of y-extent (-h/2,h/2), so
we have to translate ourselves to be in the center of the
interval that we span. */
- translate_axis (i.center (), Y_AXIS);
- return SCM_UNDEFINED;
+
+ return i.center ();
}
void
-Span_bar::evaluate_empty ()
+Span_bar::evaluate_empty (Score_element*me)
{
- if (!gh_pair_p (get_elt_pointer ("elements")))
+ if (!gh_pair_p (me->get_elt_property ("elements")))
{
- suicide ();
+ me->suicide ();
}
- SCM gl = get_elt_property ("glyph");
+ SCM gl = me->get_elt_property ("glyph");
if (!gh_string_p (gl))
{
- suicide ();
+ me->suicide ();
return ;
}
else {
type_str= ".|.";
}
if (orig != type_str)
- set_elt_property ("glyph", ly_str02scm (type_str.ch_C()));
+ me->set_elt_property ("glyph", ly_str02scm (type_str.ch_C()));
}
}
Interval
-Span_bar::get_spanned_interval () const
+Span_bar::get_spanned_interval (Score_element*me)
{
- return Axis_group_interface::group_extent_callback ((Span_bar*)this, Y_AXIS);
+ return Axis_group_interface::group_extent_callback (me, Y_AXIS);
}
-Real
-Span_bar::get_bar_size () const
+MAKE_SCHEME_CALLBACK(Span_bar,get_bar_size);
+SCM
+Span_bar::get_bar_size (SCM smob)
{
- Interval iv (get_spanned_interval ());
+ Score_element* me = unsmob_element (smob);
+ Interval iv (get_spanned_interval (me));
if (iv.empty_b ())
{
programming_error("Huh? My children deflated (FIXME)");
iv = Interval (0,0);
}
- return iv.length ();
+ return gh_double2scm (iv.length ());
}
-
-Span_bar::Span_bar (SCM s)
- : Bar (s)
+void
+Span_bar::set_interface (Score_element *me)
{
- Pointer_group_interface(this).set_interface ();
- set_extent_callback (width_callback, X_AXIS);
+ Bar::set_interface (me);
- // dim_cache_[Y_AXIS]->set_extent_callback (Axis_group_interface::group_extent_callback);
-
- set_extent_callback (0, Y_AXIS);
+ Pointer_group_interface(me).set_interface ();
+ me->set_extent_callback (width_callback, X_AXIS);
+ me->add_offset_callback (center_on_spanned_callback, Y_AXIS);
+ me->set_interface (ly_symbol2scm ("span-bar-interface"));
+ me->set_extent_callback (0, Y_AXIS);
}
+bool
+Span_bar::has_interface (Score_element*m)
+{
+ return m && m->has_interface (ly_symbol2scm ("span-bar-interface"));
+}
#include <math.h>
#include <libc-extension.hh>
-#include "dimension-cache.hh"
+
#include "debug.hh"
#include "spanner.hh"
#include "paper-column.hh"
if (spanned_drul_[LEFT])
{
- iv[LEFT] = spanned_drul_[LEFT]->column_l ()->rank_i ();
+ iv[LEFT] = Paper_column::rank_i (spanned_drul_[LEFT]->column_l ());
}
if (spanned_drul_[RIGHT])
{
- iv[RIGHT] = spanned_drul_[RIGHT]->column_l ()->rank_i ();
+ iv[RIGHT] = Paper_column::rank_i (spanned_drul_[RIGHT]->column_l ());
}
return iv;
}
int
Spanner::compare (Spanner * const &p1, Spanner * const &p2)
{
- return p1->line_l ()->rank_i_ - p2->line_l ()->rank_i_;
+ return p1->line_l ()->rank_i_ - p2->line_l ()->rank_i_;
}
bool
if (spanned_drul_[d])
scm_gc_mark (spanned_drul_[d]->self_scm_);
while (flip (&d) != LEFT);
+
+ for (int i= broken_into_l_arr_.size () ; i--;)
+ scm_gc_mark (broken_into_l_arr_[i]->self_scm_);
}
void
}
-int
-Column_spring::compare (Column_spring const & r1, Column_spring const &r2)
-{
- return r1.other_l_->rank_i() - r2.other_l_->rank_i();
-}
-/*
- staff-bar.cc -- implement Staff_bar
-
- source file of the GNU LilyPond music typesetter
-
- (c) 1999--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
-
- */
-#include "staff-bar.hh"
-#include "staff-symbol-referencer.hh"
-
-Real
-Staff_bar::get_bar_size () const
-{
- SCM size = get_elt_property ("bar-size");
- if (gh_number_p (size))
- return gh_scm2double (size);
- else
- {
- Staff_symbol_referencer_interface si (this);
- return (si.line_count () -1) * si.staff_space ();
- }
-}
-
-
-Staff_bar::Staff_bar (SCM s)
- : Bar (s)
-{
-
-}
(c) 1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
*/
-#include "staff-symbol.hh"
+
#include "score.hh"
#include "paper-column.hh"
#include "paper-def.hh"
Manage the staff symbol.
*/
class Staff_symbol_engraver : public Engraver {
- Staff_symbol *span_p_;
+ Spanner *span_p_;
public:
VIRTUAL_COPY_CONS(Translator);
Staff_symbol_engraver();
protected:
virtual ~Staff_symbol_engraver();
-
virtual void acknowledge_element (Score_element_info);
virtual void do_removal_processing();
virtual void do_creation_processing();
-
};
void
Staff_symbol_engraver::do_creation_processing()
{
- span_p_ = new Staff_symbol (get_property ("staffSymbolBasicProperties"));
- span_p_->set_bound(LEFT,unsmob_element (get_property ("currentCommandColumn")));
+ span_p_ = new Spanner (get_property ("staffSymbolBasicProperties"));
+
+ span_p_->set_bound(LEFT, unsmob_element (get_property ("currentCommandColumn")));
announce_element (Score_element_info (span_p_, 0));
}
void
Staff_symbol_engraver::acknowledge_element (Score_element_info s)
{
- s.elem_l_->set_elt_pointer ("staff-symbol", span_p_->self_scm_);
+ s.elem_l_->set_elt_property ("staff-symbol", span_p_->self_scm_);
s.elem_l_->add_dependency (span_p_); // UGH. UGH. UGH
}
#include "staff-symbol-referencer.hh"
#include "staff-symbol.hh"
#include "paper-def.hh"
-#include "dimension-cache.hh"
-Staff_symbol_referencer_interface::Staff_symbol_referencer_interface (Score_element const *sc)
-{
- elt_l_ = (Score_element*)sc;
-}
+
+
void
-Staff_symbol_referencer_interface::set_interface (Score_element * e)
+Staff_symbol_referencer::set_interface (Score_element * e)
{
if (!gh_number_p (e->get_elt_property ("staff-position")))
e->set_elt_property ("staff-position", gh_double2scm (0.0));
}
bool
-Staff_symbol_referencer_interface::has_interface_b (Score_element*e)
+Staff_symbol_referencer::has_interface (Score_element*e)
{
- return unsmob_element (e->get_elt_pointer ("staff-symbol"))
+ return unsmob_element (e->get_elt_property ("staff-symbol"))
|| gh_number_p (e->get_elt_property ("staff-position"));
}
int
-Staff_symbol_referencer_interface::line_count () const
+Staff_symbol_referencer::line_count (Score_element*me)
{
- Staff_symbol *st = staff_symbol_l ();
- return st ? st->line_count () : 0;
+ Score_element *st = staff_symbol_l (me);
+ return st ? Staff_symbol::line_count (st) : 0;
}
-Staff_symbol*
-Staff_symbol_referencer_interface::staff_symbol_l () const
+Score_element*
+Staff_symbol_referencer::staff_symbol_l (Score_element*me)
{
- SCM st = elt_l_->get_elt_pointer ("staff-symbol");
- return dynamic_cast<Staff_symbol* > (unsmob_element(st));
+ SCM st = me->get_elt_property ("staff-symbol");
+ return unsmob_element(st);
}
Real
-Staff_symbol_referencer_interface::staff_space () const
+Staff_symbol_referencer::staff_space (Score_element*me)
{
- Staff_symbol * st = staff_symbol_l ();
+ Score_element * st = staff_symbol_l (me);
if (st)
- return st->staff_space ();
- else if (elt_l_->pscore_l_ && elt_l_->paper_l ())
- return elt_l_->paper_l ()->get_var ("interline");
+ return Staff_symbol::staff_space (st);
+ else if (me->pscore_l_ && me->paper_l ())
+ return me->paper_l ()->get_var ("interline");
return 0.0;
}
Real
-Staff_symbol_referencer_interface::position_f () const
+Staff_symbol_referencer::position_f (Score_element*me)
{
Real p =0.0;
- Staff_symbol * st = staff_symbol_l ();
- Score_element * c = st ? elt_l_->common_refpoint (st, Y_AXIS) : 0;
+ Score_element * st = staff_symbol_l (me);
+ Score_element * c = st ? me->common_refpoint (st, Y_AXIS) : 0;
if (st && c)
{
- Real y = elt_l_->relative_coordinate (c, Y_AXIS)
+ Real y = me->relative_coordinate (c, Y_AXIS)
- st->relative_coordinate (c, Y_AXIS);
- p += 2.0 * y / st->staff_space ();
+ p += 2.0 * y / Staff_symbol::staff_space (st);
}
else
{
- SCM pos = elt_l_->get_elt_property ("staff-position");
+ SCM pos = me->get_elt_property ("staff-position");
if (gh_number_p (pos))
return gh_scm2double (pos);
}
should use offset callback!
*/
Real
-Staff_symbol_referencer_interface::callback (Score_element * sc,Axis )
+Staff_symbol_referencer::callback (Score_element * sc,Axis )
{
Score_element* me = (Score_element*)sc; // UGH.
Real off =0.0;
if (gh_number_p (pos))
{
- Real space = Staff_symbol_referencer_interface (sc).staff_space ();
+ Real space = Staff_symbol_referencer::staff_space (sc);
off = gh_scm2double (pos) * space/2.0;
}
*/
void
-Staff_symbol_referencer_interface::set_position (Real p)
+Staff_symbol_referencer::set_position (Score_element*me,Real p)
{
- Staff_symbol * st = staff_symbol_l ();
- if (st && elt_l_->common_refpoint(st, Y_AXIS))
+ Score_element * st = staff_symbol_l (me);
+ if (st && me->common_refpoint(st, Y_AXIS))
{
- Real oldpos = position_f ();
- elt_l_->set_elt_property ("staff-position", gh_double2scm (p - oldpos));
+ Real oldpos = position_f (me);
+ me->set_elt_property ("staff-position", gh_double2scm (p - oldpos));
}
else
{
- elt_l_->set_elt_property ("staff-position",
+ me->set_elt_property ("staff-position",
gh_double2scm (p));
}
- if (elt_l_->has_offset_callback_b (callback, Y_AXIS))
+ if (me->has_offset_callback_b (callback, Y_AXIS))
return ;
- elt_l_->add_offset_callback (callback, Y_AXIS);
+ me->add_offset_callback (callback, Y_AXIS);
}
int
compare_position (Score_element *const &a, Score_element * const &b)
{
- Staff_symbol_referencer_interface s1(a);
- Staff_symbol_referencer_interface s2(b);
-
- return sign(s1.position_f () - s2.position_f ());
+ return sign (Staff_symbol_referencer::position_f((Score_element*)a) -
+ Staff_symbol_referencer::position_f((Score_element*)b));
}
/*
- staffsym.cc -- implement Staff_symbol
+ staff-symbol.cc -- implement Staff_symbol
source file of the GNU LilyPond music typesetter
(c) 1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>
*/
-#include "staff-symbol.hh"
+
#include "lookup.hh"
#include "dimensions.hh"
#include "paper-def.hh"
#include "molecule.hh"
#include "debug.hh"
#include "item.hh"
+#include "staff-symbol.hh"
+#include "spanner.hh"
-
-
-GLUE_SCORE_ELEMENT(Staff_symbol,brew_molecule);
+MAKE_SCHEME_CALLBACK(Staff_symbol,brew_molecule);
SCM
-Staff_symbol::member_brew_molecule () const
+Staff_symbol::brew_molecule (SCM smob)
{
+ Score_element *me = unsmob_element (smob);
+ Spanner* sp = dynamic_cast<Spanner*> (me);
Score_element * common
- = get_bound (LEFT)->common_refpoint (get_bound (RIGHT), X_AXIS);
+ = sp->get_bound (LEFT)->common_refpoint (sp->get_bound (RIGHT), X_AXIS);
Real width =
// right_shift - left_shift
- + get_bound (RIGHT)->relative_coordinate (common , X_AXIS)
- - get_bound (LEFT)->relative_coordinate (common, X_AXIS)
+ + sp->get_bound (RIGHT)->relative_coordinate (common , X_AXIS)
+ - sp->get_bound (LEFT)->relative_coordinate (common, X_AXIS)
;
- Real t = paper_l ()->get_var ("stafflinethickness");
- int l = line_count ();
+ Real t = me->paper_l ()->get_var ("stafflinethickness");
+ int l = Staff_symbol::line_count (me);
- Real height = (l-1) * staff_space () /2;
- Molecule m;
+ Real height = (l-1) * staff_space (me) /2;
+ Molecule m;
for (int i=0; i < l; i++)
{
Molecule a =
- lookup_l ()->filledbox (Box (Interval (0,width),
- Interval (-t/2, t/2)));
+ me->lookup_l ()->filledbox (Box (Interval (0,width),
+ Interval (-t/2, t/2)));
- a.translate_axis (height - i * staff_space (), Y_AXIS);
+ a.translate_axis (height - i * staff_space (me), Y_AXIS);
m.add_molecule (a);
}
}
int
-Staff_symbol::steps_i() const
+Staff_symbol::steps_i(Score_element*me)
{
- return line_count () * 2;
+ return line_count (me) * 2;
}
int
-Staff_symbol::line_count () const
+Staff_symbol::line_count (Score_element*me)
{
- return gh_scm2int (get_elt_property ("line-count"));
+ SCM c = me->get_elt_property ("line-count");
+ if (gh_number_p (c))
+ return gh_scm2int (c);
+ else
+ return 0;
}
Real
-Staff_symbol::staff_space ()const
+Staff_symbol::staff_space (Score_element*me )
{
- return gh_scm2double (get_elt_property ("staff-space")) *
- paper_l ()->get_var ("staffspace");
+ Real ss = me->paper_l ()->get_var ("staffspace");
+
+ SCM s = me->get_elt_property ("staff-space");
+ if (gh_number_p (s))
+ ss *= gh_scm2double (s);
+ return ss;
}
-Staff_symbol::Staff_symbol( SCM s)
- : Spanner (s)
+bool
+Staff_symbol::has_interface (Score_element*m)
{
+ return m && m->has_interface (ly_symbol2scm ("staff-symbol-interface"));
}
void
Stem_engraver::acknowledge_element(Score_element_info i)
{
- if (Rhythmic_head * h = dynamic_cast<Rhythmic_head *> (i.elem_l_))
+ Score_element* h = i.elem_l_;
+ if (Rhythmic_head::has_interface (h))
{
- if (h->stem_l ())
+ if (Rhythmic_head::stem_l (h))
return;
Rhythmic_req * r = dynamic_cast <Rhythmic_req *> (i.req_l_);
if (!stem_p_)
{
stem_p_ = new Stem (get_property ("basicStemProperties"));
- Staff_symbol_referencer_interface::set_interface(stem_p_);
+ Staff_symbol_referencer::set_interface(stem_p_);
stem_p_->set_elt_property ("duration-log", gh_int2scm (duration_log));
announce_element (Score_element_info (stem_p_, r));
}
- if (stem_p_->flag_i () != duration_log)
+ if (Stem::flag_i (stem_p_) != duration_log)
{
- r->warning (_f ("Adding note head to incompatible stem (type = %d)", 1 << stem_p_->flag_i ()));
+ r->warning (_f ("Adding note head to incompatible stem (type = %d)", 1 << Stem::flag_i (stem_p_)));
}
- stem_p_->add_head (h);
+ Stem::add_head (stem_p_,h);
}
}
SCM prop = get_property ("stemLeftBeamCount");
if (gh_number_p(prop))
{
- stem_p_->set_beaming (gh_scm2int (prop),LEFT);
+ Stem::set_beaming (stem_p_,gh_scm2int (prop),LEFT);
daddy_trans_l_->set_property ("stemLeftBeamCount", SCM_UNDEFINED);
}
prop = get_property ("stemRightBeamCount");
if (gh_number_p(prop))
{
- stem_p_->set_beaming (gh_scm2int (prop), RIGHT);
+ Stem::set_beaming (stem_p_,gh_scm2int (prop), RIGHT);
daddy_trans_l_->set_property ("stemRightBeamCount", SCM_UNDEFINED);
}
#include "lookup.hh"
#include "stem.hh"
#include "offset.hh"
-#include "dimension-cache.hh"
+
#include "staff-symbol-referencer.hh"
#include "directional-element-interface.hh"
void
Stem_tremolo::set_interface (Score_element *me)
{
-me->set_elt_pointer ("stem", SCM_EOL);
+me->set_elt_property ("stem", SCM_EOL);
}
Interval
Stem_tremolo::dim_callback (Score_element * se, Axis )
{
- Real space = Staff_symbol_referencer_interface (se).staff_space ();
+ Real space = Staff_symbol_referencer::staff_space (se);
return Interval (-space, space);
}
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Stem_tremolo,brew_molecule);
+MAKE_SCHEME_CALLBACK(Stem_tremolo,brew_molecule);
SCM
Stem_tremolo::brew_molecule (SCM smob)
{
Score_element *me= unsmob_element (smob);
- Stem * stem = dynamic_cast<Stem*> (unsmob_element (me->get_elt_pointer ("stem")));
- Beam * beam = stem->beam_l ();
+ Score_element * stem = unsmob_element (me->get_elt_property ("stem"));
+ Beam * beam = Stem::beam_l (stem);
Real dydx;
if (beam)
// urg
dydx = 0.25;
- Real ss = Staff_symbol_referencer_interface (stem).staff_space ();
+ Real ss = Staff_symbol_referencer::staff_space (stem);
Real thick = gh_scm2double (me->get_elt_property ("beam-thickness"));
Real width = gh_scm2double (me->get_elt_property ("beam-width"));
width *= ss;
if (beam)
{
// ugh, rather calc from Stem_tremolo_req
- int beams_i = stem->beam_count(RIGHT) >? stem->beam_count (LEFT);
+ int beams_i = Stem::beam_count(stem, RIGHT) >? Stem::beam_count (stem, LEFT);
mol.translate (Offset(stem->relative_coordinate (0, X_AXIS) - me->relative_coordinate (0, X_AXIS),
- stem->stem_end_position () * ss / 2 -
+ Stem::stem_end_position (stem ) * ss / 2 -
Directional_element_interface (beam).get () * beams_i * interbeam_f));
}
else
/*
Beams should intersect one beamthickness below stem end
*/
- Real dy = stem->stem_end_position () * ss / 2;
- dy -= mol.extent (Y_AXIS).length () / 2 * stem->get_direction ();
+ Real dy = Stem::stem_end_position (stem ) * ss / 2;
+ dy -= mol.extent (Y_AXIS).length () / 2 * Stem::get_direction (stem );
/*
uhg. Should use relative coords and placement
*/
Real whole_note_correction;
- if (stem->invisible_b ())
- whole_note_correction = -stem->get_direction ()
- * stem->support_head ()->extent (X_AXIS).length () / 2;
+ if (Stem::invisible_b (stem ))
+ whole_note_correction = -Stem::get_direction (stem )
+ * Stem::support_head (stem )->extent (X_AXIS).length () / 2;
else
whole_note_correction = 0;
void
Stem_tremolo::set_stem (Score_element*me,Score_element *s)
{
- me->set_elt_pointer ("stem", s->self_scm_);
+ me->set_elt_property ("stem", s->self_scm_);
}
#include <math.h> // m_pi
#include "directional-element-interface.hh"
-#include "dimension-cache.hh"
+#include "note-head.hh"
#include "stem.hh"
#include "debug.hh"
#include "paper-def.hh"
void
-Stem::set_beaming (int i, Direction d )
+Stem::set_beaming (Score_element*me ,int i, Direction d )
{
- SCM pair = get_elt_property ("beaming");
+ SCM pair = me->get_elt_property ("beaming");
if (!gh_pair_p (pair))
{
pair = gh_cons (gh_int2scm (0),gh_int2scm (0));
- set_elt_property ("beaming", pair);
+ me-> set_elt_property ("beaming", pair);
}
index_set_cell (pair, d, gh_int2scm (i));
}
int
-Stem::beam_count (Direction d) const
+Stem::beam_count (Score_element*me,Direction d)
{
- SCM p=get_elt_property ("beaming");
+ SCM p=me->get_elt_property ("beaming");
if (gh_pair_p (p))
return gh_scm2int (index_cell (p,d));
else
}
Interval
-Stem::head_positions () const
+Stem::head_positions (Score_element*me)
{
- if (!heads_i ())
+ if (!heads_i (me))
{
Interval iv;
return iv;
}
-
- Drul_array<Rhythmic_head*> e (extremal_heads ());
+ Drul_array<Score_element*> e (extremal_heads (me));
- return Interval (Staff_symbol_referencer_interface (e[DOWN]).position_f (),
- Staff_symbol_referencer_interface ( e[UP]).position_f ());
+ return Interval (Staff_symbol_referencer::position_f (e[DOWN]),
+ Staff_symbol_referencer::position_f ( e[UP]));
}
Real
-Stem::chord_start_f () const
+Stem::chord_start_f (Score_element*me)
{
- return head_positions()[get_direction ()]
- * Staff_symbol_referencer_interface (this).staff_space ()/2.0;
+ return head_positions(me)[get_direction (me)]
+ * Staff_symbol_referencer::staff_space (me)/2.0;
}
Real
-Stem::stem_end_position () const
+Stem::stem_end_position (Score_element*me)
{
- SCM p =get_elt_property ("stem-end-position");
+ SCM p =me->get_elt_property ("stem-end-position");
Real pos;
if (!gh_number_p (p))
{
- Stem * me = (Stem*) this;
- pos = get_default_stem_end_position ();
+
+ pos = get_default_stem_end_position (me);
me->set_elt_property ("stem-end-position", gh_double2scm (pos));
}
else
}
Direction
-Stem::get_direction () const
+Stem::get_direction (Score_element*me)
{
- Direction d = Directional_element_interface (this).get ();
+ Direction d = Directional_element_interface (me).get ();
if (!d)
{
- Stem * me = (Stem*) this;
- d = get_default_dir ();
+ d = get_default_dir (me);
// urg, AAARGH!
Directional_element_interface (me).set (d);
}
void
-Stem::set_stemend (Real se)
+Stem::set_stemend (Score_element*me, Real se)
{
// todo: margins
- Direction d= get_direction ();
+ Direction d= get_direction (me);
- if (d && d * head_positions()[get_direction ()] >= se*d)
+ if (d && d * head_positions(me)[get_direction (me)] >= se*d)
warning (_ ("Weird stem size; check for narrow beams"));
- set_elt_property ("stem-end-position", gh_double2scm (se));
+ me->set_elt_property ("stem-end-position", gh_double2scm (se));
}
int
-Stem::type_i () const
+Stem::type_i (Score_element*me)
{
- return first_head () ? first_head ()->balltype_i () : 2;
+ return first_head (me) ? Rhythmic_head::balltype_i (first_head (me)) : 2;
}
/*
Note head that determines hshift for upstems
*/
Score_element*
-Stem::support_head ()const
+Stem::support_head (Score_element*me)
{
- SCM h = get_elt_pointer ("support-head");
+ SCM h = me->get_elt_property ("support-head");
Score_element * nh = unsmob_element (h);
if (nh)
return nh;
- else if (heads_i () == 1)
+ else if (heads_i (me) == 1)
{
/*
UGH.
*/
- return unsmob_element (gh_car (get_elt_pointer ("heads")));
+ return unsmob_element (gh_car (me->get_elt_property ("heads")));
}
else
- return first_head ();
+ return first_head (me);
}
int
-Stem::heads_i ()const
+Stem::heads_i (Score_element*me)
{
- Pointer_group_interface gi (this, "heads");
+ Pointer_group_interface gi (me, "heads");
return gi.count ();
}
/*
The note head which forms one end of the stem.
*/
-Rhythmic_head*
-Stem::first_head () const
+Score_element*
+Stem::first_head (Score_element*me)
{
- return extremal_heads ()[-get_direction ()];
+ return extremal_heads (me)[-get_direction (me)];
}
/*
START is part where stem reaches `last' head.
*/
-Drul_array<Rhythmic_head*>
-Stem::extremal_heads () const
+Drul_array<Score_element*>
+Stem::extremal_heads (Score_element*me)
{
const int inf = 1000000;
Drul_array<int> extpos;
extpos[DOWN] = inf;
extpos[UP] = -inf;
- Drul_array<Rhythmic_head *> exthead;
+ Drul_array<Score_element *> exthead;
exthead[LEFT] = exthead[RIGHT] =0;
- for (SCM s = get_elt_pointer ("heads"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = me->get_elt_property ("heads"); gh_pair_p (s); s = gh_cdr (s))
{
- Rhythmic_head * n = dynamic_cast<Rhythmic_head*> (unsmob_element (gh_car (s)));
- Staff_symbol_referencer_interface si (n);
+ Score_element * n = unsmob_element (gh_car (s));
+
- int p = int(si.position_f ());
+ int p = int(Staff_symbol_referencer::position_f (n));
Direction d = LEFT;
do {
}
void
-Stem::add_head (Rhythmic_head *n)
+Stem::add_head (Score_element*me, Score_element *n)
{
- n->set_elt_pointer ("stem", this->self_scm_);
- n->add_dependency (this);
+ n->set_elt_property ("stem", me->self_scm_);
+ n->add_dependency (me);
- if (to_boolean (n->get_elt_property ("note-head-interface")))
+ if (Note_head::has_interface (n))
{
- Pointer_group_interface (this, "heads").add_element (n);
+ Pointer_group_interface (me, "heads").add_element (n);
}
else
{
- n->set_elt_pointer ("rest", n->self_scm_);
+ n->set_elt_property ("rest", n->self_scm_);
}
}
Stem::Stem (SCM s)
: Item (s)
{
- set_elt_pointer ("heads", SCM_EOL);
-
- add_offset_callback ( &Stem::off_callback, X_AXIS);
+ Score_element * me = this;
+
+ me->set_elt_property ("heads", SCM_EOL);
+ Stem::set_interface (me);
+ me->add_offset_callback ( &Stem::off_callback, X_AXIS);
}
bool
-Stem::invisible_b () const
+Stem::invisible_b (Score_element*me)
{
- /*
- UGH. Who determines balltype for stem?
- */
- Rhythmic_head * nh = dynamic_cast<Rhythmic_head*> (support_head ());
- return !(heads_i () && nh->balltype_i () >= 1);
+ return !(heads_i (me) && Rhythmic_head::balltype_i (support_head (me)) >= 1);
}
int
-Stem::get_center_distance (Direction d) const
+Stem::get_center_distance (Score_element*me, Direction d)
{
int staff_center = 0;
- int distance = (int) (d*(head_positions()[d] - staff_center));
+ int distance = (int) (d*(head_positions(me)[d] - staff_center));
return distance >? 0;
}
Direction
-Stem::get_default_dir () const
+Stem::get_default_dir (Score_element*me)
{
- int du = get_center_distance (UP);
- int dd = get_center_distance (DOWN);
+ int du = get_center_distance (me,UP);
+ int dd = get_center_distance (me,DOWN);
if (sign (dd - du))
return Direction (sign (dd -du));
- return Direction (int(paper_l ()->get_var ("stem_default_neutral_direction")));
+ return to_dir (me->get_elt_property ("default-neutral-direction"));
}
/*
conversions. (but lets wait till we have namespaces in SCM)
*/
Real
-Stem::get_default_stem_end_position () const
+Stem::get_default_stem_end_position (Score_element*me)
{
- bool grace_b = to_boolean (get_elt_property ("grace"));
+ bool grace_b = to_boolean (me->get_elt_property ("grace"));
String type_str = grace_b ? "grace-" : "";
SCM s;
Array<Real> a;
Real length_f = 0.;
- SCM scm_len = get_elt_property("length");
+ SCM scm_len = me->get_elt_property("length");
if (gh_number_p (scm_len))
{
length_f = gh_scm2double (scm_len);
a.push (gh_scm2double (gh_car (q)));
// stem uses half-spaces
- length_f = a[((flag_i () - 2) >? 0) <? (a.size () - 1)] * 2;
+ length_f = a[((flag_i (me) - 2) >? 0) <? (a.size () - 1)] * 2;
}
// stem uses half-spaces
// fixme: use gh_list_ref () iso. array[]
- Real shorten_f = a[((flag_i () - 2) >? 0) <? (a.size () - 1)] * 2;
+ Real shorten_f = a[((flag_i (me) - 2) >? 0) <? (a.size () - 1)] * 2;
/* URGURGURG
'set-default-stemlen' sets direction too
*/
- Direction dir = get_direction ();
+ Direction dir = get_direction (me);
if (!dir)
{
- dir = get_default_dir ();
- Directional_element_interface (this).set (dir);
+ dir = get_default_dir (me);
+ Directional_element_interface (me).set (dir);
}
/*
stems in unnatural (forced) direction should be shortened,
according to [Roush & Gourlay]
*/
- if (((int)chord_start_f ())
- && (get_direction () != get_default_dir ()))
+ if (((int)chord_start_f (me))
+ && (get_direction (me) != get_default_dir (me)))
length_f -= shorten_f;
- Real st = head_positions()[dir] + dir * length_f;
+ Real st = head_positions(me)[dir] + dir * length_f;
- bool no_extend_b = to_boolean (get_elt_property ("no-stem-extend"));
+ bool no_extend_b = to_boolean (me->get_elt_property ("no-stem-extend"));
if (!grace_b && !no_extend_b && dir * st < 0)
st = 0.0;
FIXME: wrong name
*/
int
-Stem::flag_i () const
+Stem::flag_i (Score_element*me)
{
- SCM s = get_elt_property ("duration-log");
+ SCM s = me->get_elt_property ("duration-log");
return (gh_number_p (s)) ? gh_scm2int (s) : 2;
}
void
-Stem::position_noteheads ()
+Stem::position_noteheads (Score_element*me)
{
- if (!heads_i ())
+ if (!heads_i (me))
return;
Link_array<Score_element> heads =
- Pointer_group_interface__extract_elements (this, (Score_element*)0, "heads");
+ Pointer_group_interface__extract_elements (me, (Score_element*)0, "heads");
heads.sort (compare_position);
- Direction dir =get_direction ();
+ Direction dir =get_direction (me);
if (dir < 0)
heads.reverse ();
- Real w = support_head ()->extent (X_AXIS)[dir];
+ Real w = support_head (me)->extent (X_AXIS)[dir];
for (int i=0; i < heads.size (); i++)
{
heads[i]->translate_axis (w - heads[i]->extent (X_AXIS)[dir], X_AXIS);
}
- bool parity= true; // todo: make this settable.
- int lastpos = int (Staff_symbol_referencer_interface (heads[0]).position_f ());
+ bool parity= true; // todo: make me settable.
+ int lastpos = int (Staff_symbol_referencer::position_f (heads[0]));
for (int i=1; i < heads.size (); i ++)
{
- Real p = Staff_symbol_referencer_interface (heads[i]).position_f ();
+ Real p = Staff_symbol_referencer::position_f (heads[i]);
int dy =abs (lastpos- (int)p);
if (dy <= 1)
if (parity)
{
Real l = heads[i]->extent (X_AXIS).length ();
- heads[i]->translate_axis (l * get_direction (), X_AXIS);
+ heads[i]->translate_axis (l * get_direction (me), X_AXIS);
}
parity = !parity;
}
}
}
-GLUE_SCORE_ELEMENT(Stem,before_line_breaking);
+MAKE_SCHEME_CALLBACK(Stem,before_line_breaking);
SCM
-Stem::member_before_line_breaking ()
+Stem::before_line_breaking (SCM smob)
{
- stem_end_position (); // ugh. Trigger direction calc.
- position_noteheads ();
+ Score_element*me = unsmob_element (smob);
+ stem_end_position (me); // ugh. Trigger direction calc.
+ position_noteheads (me);
- if (invisible_b ())
+ if (invisible_b (me))
{
- remove_elt_property ("molecule-callback");
+ me->remove_elt_property ("molecule-callback");
// suicide();
}
- set_spacing_hints ();
+ set_spacing_hints (me);
return SCM_UNDEFINED;
}
TODO: more advanced: supply height of noteheads as well, for more advanced spacing possibilities
*/
void
-Stem::set_spacing_hints ()
+Stem::set_spacing_hints (Score_element*me)
{
- if (!invisible_b ())
+ if (!invisible_b (me))
{
- SCM scmdir = gh_int2scm (get_direction ());
- SCM dirlist = column_l ()->get_elt_property ("dir-list");
+ SCM scmdir = gh_int2scm (get_direction (me));
+
+ Item* item = dynamic_cast<Item*> (me);
+ Item * col = item->column_l ();
+ SCM dirlist =col->get_elt_property ("dir-list");
if (dirlist == SCM_UNDEFINED)
dirlist = SCM_EOL;
if (scm_sloppy_memq (scmdir, dirlist) == SCM_EOL)
{
dirlist = gh_cons (scmdir, dirlist);
- column_l ()->set_elt_property ("dir-list", dirlist);
+ col->set_elt_property ("dir-list", dirlist);
}
}
}
Molecule
-Stem::flag () const
+Stem::flag (Score_element*me)
{
String style;
- SCM st = get_elt_property ("flag-style");
+ SCM st = me->get_elt_property ("flag-style");
if ( gh_string_p (st))
{
style = ly_scm2string (st);
}
- char c = (get_direction () == UP) ? 'u' : 'd';
- Molecule m = lookup_l ()->afm_find (String ("flags-") + to_str (c) +
- to_str (flag_i ()));
+ char c = (get_direction (me) == UP) ? 'u' : 'd';
+ Molecule m = me->lookup_l ()->afm_find (String ("flags-") + to_str (c) +
+ to_str (flag_i (me)));
if (!style.empty_b ())
- m.add_molecule(lookup_l ()->afm_find (String ("flags-") + to_str (c) + style));
+ m.add_molecule(me->lookup_l ()->afm_find (String ("flags-") + to_str (c) + style));
return m;
}
Interval
Stem::dim_callback (Score_element *se, Axis )
{
- Stem * s = dynamic_cast<Stem*> ((Score_element*)se);
-
Interval r (0, 0);
- if (unsmob_element (s->get_elt_pointer ("beam")) || abs (s->flag_i ()) <= 2)
+ if (unsmob_element (se->get_elt_property ("beam")) || abs (flag_i (se)) <= 2)
; // TODO!
else
{
- r = s->flag ().extent (X_AXIS);
+ r = flag (se).extent (X_AXIS);
}
return r;
}
const Real ANGLE = 20* (2.0*M_PI/360.0); // ugh! Should be settable.
-GLUE_SCORE_ELEMENT(Stem,brew_molecule);
+MAKE_SCHEME_CALLBACK(Stem,brew_molecule);
SCM
-Stem::member_brew_molecule () const
+Stem::brew_molecule (SCM smob)
{
+ Score_element*me = unsmob_element (smob);
Molecule mol;
-
- Staff_symbol_referencer_interface si (first_head ());
+ Direction d = get_direction (me);
- Real y1 = si.position_f();
- Real y2 = stem_end_position ();
+
+ Real y1 = Staff_symbol_referencer::position_f (first_head (me));
+ Real y2 = stem_end_position (me);
Interval stem_y(y1,y2);
stem_y.unite (Interval (y2,y1));
- Real dy = Staff_symbol_referencer_interface (this).staff_space ()/2.0;
+ Real dy = Staff_symbol_referencer::staff_space (me)/2.0;
Real head_wid = 0;
- if (support_head ())
- head_wid = support_head ()->extent (X_AXIS).length ();
- stem_y[Direction(-get_direction ())] += get_direction () * head_wid * tan(ANGLE)/(2*dy);
+ if (support_head (me))
+ head_wid = support_head (me)->extent (X_AXIS).length ();
+ stem_y[Direction(-d)] += d * head_wid * tan(ANGLE)/(2*dy);
- if (!invisible_b ())
+ if (!invisible_b (me))
{
- Real stem_width = paper_l ()->get_var ("stemthickness");
- Molecule ss =lookup_l ()->filledbox (Box (Interval (-stem_width/2, stem_width/2),
+ Real stem_width = me->paper_l ()->get_var ("stemthickness");
+ Molecule ss =me->lookup_l ()->filledbox (Box (Interval (-stem_width/2, stem_width/2),
Interval (stem_y[DOWN]*dy, stem_y[UP]*dy)));
mol.add_molecule (ss);
}
- if (!beam_l () && abs (flag_i ()) > 2)
+ if (!beam_l (me) && abs (flag_i (me)) > 2)
{
- Molecule fl = flag ();
- fl.translate_axis(stem_y[get_direction ()]*dy, Y_AXIS);
+ Molecule fl = flag (me);
+ fl.translate_axis(stem_y[d]*dy, Y_AXIS);
mol.add_molecule (fl);
}
}
Real
-Stem::off_callback (Score_element * se, Axis)
+Stem::off_callback (Score_element * me, Axis)
{
- Stem *st = dynamic_cast<Stem*> ((Score_element*)se);
-
Real r=0;
- if (Rhythmic_head * f = st->first_head ())
+ if (Score_element * f = first_head (me))
{
Interval head_wid(0, f->extent (X_AXIS).length ());
- if (to_boolean (st->get_elt_property ("stem-centered")))
+ if (to_boolean (me->get_elt_property ("stem-centered")))
return head_wid.center ();
- Real rule_thick = st->paper_l ()->get_var ("stemthickness");
- Direction d = st->get_direction ();
+ Real rule_thick = me->paper_l ()->get_var ("stemthickness");
+ Direction d = get_direction (me);
r = head_wid[d] - d * rule_thick ;
}
return r;
Beam*
-Stem::beam_l ()const
+Stem::beam_l (Score_element*me)
{
- SCM b= get_elt_pointer ("beam");
+ SCM b= me->get_elt_property ("beam");
return dynamic_cast<Beam*> (unsmob_element (b));
}
// ugh still very long.
Stem_info
-Stem::calc_stem_info () const
+Stem::calc_stem_info (Score_element*me)
{
- assert (beam_l ());
+ Beam * beam = beam_l (me);
- Direction beam_dir = Directional_element_interface (beam_l ()).get ();
+ Direction beam_dir = Directional_element_interface (beam).get ();
if (!beam_dir)
{
programming_error ("Beam dir not set.");
beam_dir = UP;
}
- Staff_symbol_referencer_interface st (this);
- Real staff_space = st.staff_space ();
+
+ Real staff_space = Staff_symbol_referencer::staff_space (me);
Real half_space = staff_space / 2;
- Real interbeam_f = paper_l ()->interbeam_f (beam_l ()->get_multiplicity ());
- Real thick = gh_scm2double (beam_l ()->get_elt_property ("beam-thickness"));
- int multiplicity = beam_l ()->get_multiplicity ();
+ Real interbeam_f = me->paper_l ()->interbeam_f (beam->get_multiplicity ());
+ Real thick = gh_scm2double (beam->get_elt_property ("beam-thickness"));
+ int multiplicity = beam->get_multiplicity ();
Stem_info info;
- info.idealy_f_ = chord_start_f ();
+ info.idealy_f_ = chord_start_f (me);
// for simplicity, we calculate as if dir == UP
info.idealy_f_ *= beam_dir;
- SCM grace_prop = get_elt_property ("grace");
+ SCM grace_prop = me->get_elt_property ("grace");
bool grace_b = to_boolean (grace_prop);
Real stem_length = a[multiplicity <? (a.size () - 1)] * staff_space;
- if (!beam_dir || (beam_dir == Directional_element_interface (this).get ()))
+ if (!beam_dir || (beam_dir == Directional_element_interface (me).get ()))
/* normal beamed stem */
{
if (multiplicity)
than middle staffline, just as normal stems.
*/
- bool no_extend_b = to_boolean (get_elt_property ("no-stem-extend"));
+ bool no_extend_b = to_boolean (me->get_elt_property ("no-stem-extend"));
if (!grace_b && !no_extend_b)
{
/* highest beam of (UP) beam must never be lower than middle
info.idealy_f_ = (info.maxy_f_ <? info.idealy_f_) >? info.miny_f_;
- s = beam_l ()->get_elt_property ("shorten");
+ s = beam->get_elt_property ("shorten");
if (gh_number_p (s))
info.idealy_f_ -= gh_scm2double (s);
- Real interstaff_f = -beam_dir* calc_interstaff_dist (this, beam_l ());
+ Real interstaff_f = -beam_dir* calc_interstaff_dist (dynamic_cast<Item*> (me), beam);
info.idealy_f_ += interstaff_f;
info.miny_f_ += interstaff_f;
return info;
}
+bool
+Stem::has_interface (Score_element*m)
+{
+ return m && m->has_interface (ly_symbol2scm ("stem-interface"));
+}
+
+void
+Stem::set_interface (Score_element*m)
+{
+ return m->set_interface (ly_symbol2scm ("stem-interface"));
+}
};
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Sustain_pedal,brew_molecule);
+MAKE_SCHEME_CALLBACK(Sustain_pedal,brew_molecule);
SCM
Sustain_pedal::brew_molecule (SCM smob)
void
System_start_delimiter_engraver::acknowledge_element (Score_element_info inf)
{
- if (dynamic_cast<Staff_symbol*> (inf.elem_l_))
+ if (Staff_symbol::has_interface (inf.elem_l_))
{
/*
- don't add as Axis_group_interface (delim_).add_element (),
+ don't add as Axis_group_interface::add_element (delim_, ),
because that would set the parent as well */
Pointer_group_interface (delim_).add_element (inf.elem_l_);
return lookup_l ()->filledbox (Box (Interval(0,w), Interval(-h/2, h/2)));
}
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(System_start_delimiter,after_line_breaking);
+MAKE_SCHEME_CALLBACK(System_start_delimiter,after_line_breaking);
SCM
System_start_delimiter::after_line_breaking (SCM smob)
{
SCM gl = me->get_elt_property ("glyph");
- if (scm_ilength (me->get_elt_pointer ("elements")) <= 1 && gl == ly_symbol2scm ("bar-line"))
+ if (scm_ilength (me->get_elt_property ("elements")) <= 1 && gl == ly_symbol2scm ("bar-line"))
{
me->suicide ();
}
}
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(System_start_delimiter,brew_molecule);
+MAKE_SCHEME_CALLBACK(System_start_delimiter,brew_molecule);
SCM
System_start_delimiter::brew_molecule (SCM smob)
*/
-#include "dimension-cache.hh"
+
#include "engraver.hh"
#include "side-position-interface.hh"
#include "item.hh"
#include "musical-request.hh"
-
#include "stem.hh"
-#include "staff-symbol.hh"
+#include "note-head.hh"
/**
typeset directions that are plain text.
void
Text_engraver::acknowledge_element (Score_element_info inf)
{
- if (to_boolean (inf.elem_l_->get_elt_property ("note-head-interface")))
+ if (Note_head::has_interface (inf.elem_l_))
{
for (int i=0; i < texts_.size (); i++)
{
- Side_position_interface st (texts_[i]);
- st.add_support (inf.elem_l_);
- if (st.get_axis( ) == X_AXIS
- && !texts_[i]->parent_l (Y_AXIS))
- texts_[i]->set_parent (inf.elem_l_, Y_AXIS);
+ Score_element*t = texts_[i];
+ Side_position::add_support (t,inf.elem_l_);
+ if (Side_position::get_axis( t) == X_AXIS
+ && !t->parent_l (Y_AXIS))
+ t->set_parent (inf.elem_l_, Y_AXIS);
}
}
- if (Stem *n = dynamic_cast<Stem*> (inf.elem_l_))
+ if (Stem::has_interface (inf.elem_l_))
{
for (int i=0; i < texts_.size (); i++)
{
- Side_position_interface st(texts_[i]);
- st.add_support (n);
+ Side_position::add_support(texts_[i],inf.elem_l_);
}
}
}
Text_script_req * r = reqs_[i];
Item *text = new Item (get_property ("basicTextScriptProperties"));
- Side_position_interface stafy (text);
+
SCM axisprop = get_property ("scriptHorizontal");
- if (to_boolean (axisprop))
- {
- stafy.set_axis (X_AXIS);
- // text->set_parent (ss, Y_AXIS);
- }
- else
- stafy.set_axis (Y_AXIS);
+
+ Side_position::set_axis (text, to_boolean (axisprop) ? X_AXIS : Y_AXIS);
/*
make sure they're in order by adding i to the priority field.
gh_int2scm (200 + i));
if (r->get_direction ())
- stafy.set_direction (r->get_direction ());
+ Side_position::set_direction (text, r->get_direction ());
text->set_elt_property ("text",
ly_str02scm ( r->text_str_.ch_C ()));
for (int i=0; i < texts_.size (); i++)
{
Item *ti = texts_[i];
- Side_position_interface (ti).add_staff_support ();
+ Side_position::add_staff_support (ti);
typeset_element (ti);
}
texts_.clear ();
};
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Text_item,brew_molecule)
+MAKE_SCHEME_CALLBACK(Text_item,brew_molecule)
SCM
Text_item::brew_molecule (SCM sm)
Molecule m;
m.set_empty (false);
mol.add_at_edge (X_AXIS, RIGHT, m, gh_scm2double (space)*
- Staff_symbol_referencer_interface (s).staff_space ());
+ Staff_symbol_referencer::staff_space (s));
}
return mol.create_scheme ();
}
void
Tie_column::set_interface (Score_element*me)
{
- me-> set_elt_pointer ("ties", SCM_EOL);
+ me-> set_elt_property ("ties", SCM_EOL);
me->set_extent_callback (0, X_AXIS);
me->set_extent_callback (0, Y_AXIS);
}
}
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Tie_column,after_line_breaking);
+MAKE_SCHEME_CALLBACK(Tie_column,after_line_breaking);
SCM
Tie_column::after_line_breaking (SCM smob)
{
#include "tie-column.hh"
#include "pqueue.hh"
#include "engraver.hh"
+#include "item.hh"
struct CHead_melodic_tuple {
Melodic_req *req_l_ ;
- Rhythmic_head *head_l_;
+ Score_element *head_l_;
Moment end_;
CHead_melodic_tuple ();
- CHead_melodic_tuple (Rhythmic_head*, Melodic_req*, Moment);
+ CHead_melodic_tuple (Score_element*, 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 &);
};
priority queue. If we have a Tie_req, connect the notes that finish
just at this time, and note that start at this time.
- TODO: should share code with Beam_engraver, Extender_engraver?
+ TODO: junk the pq.
*/
class Tie_engraver : public Engraver
{
void
Tie_engraver::acknowledge_element (Score_element_info i)
{
- if (Rhythmic_head *nh = dynamic_cast<Rhythmic_head *> (i.elem_l_))
+ if (Rhythmic_head::has_interface (i.elem_l_))
{
Note_req * m = dynamic_cast<Note_req* > (i.req_l_);
if (!m)
return;
- now_heads_.push (CHead_melodic_tuple (nh, m, now_mom()+ m->length_mom ()));
+ now_heads_.push (CHead_melodic_tuple (i.elem_l_, m, now_mom()+ m->length_mom ()));
}
}
tie_p_arr_.clear ();
if (tie_column_p_)
{
- typeset_tie (tie_column_p_);
+ typeset_element (tie_column_p_);
tie_column_p_ =0;
}
}
void
Tie_engraver::typeset_tie (Score_element *her)
{
- if (!(Tie::head (her,LEFT) && Tie::head (her,RIGHT)))
+ if (!(Tie::head (her,LEFT) && Tie::head (her,RIGHT)))
warning (_ ("lonely tie"));
Direction d = LEFT;
- Drul_array<Item *> new_head_drul;
+ Drul_array<Score_element *> new_head_drul;
new_head_drul[LEFT] = Tie::head(her,LEFT);
new_head_drul[RIGHT] = Tie::head (her,RIGHT);
do {
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_ );
+ index_set_cell (her->get_elt_property ("heads"), LEFT, new_head_drul[LEFT]->self_scm_ );
+ index_set_cell (her->get_elt_property ("heads"), RIGHT, new_head_drul[RIGHT]->self_scm_ );
typeset_element (her);
}
end_ = 0;
}
-CHead_melodic_tuple::CHead_melodic_tuple (Rhythmic_head *h, Melodic_req*m, Moment mom)
+CHead_melodic_tuple::CHead_melodic_tuple (Score_element *h, Melodic_req*m, Moment mom)
{
head_l_ = h;
req_l_ = m;
Tie::set_head (Score_element*me,Direction d, Item * head_l)
{
assert (!head (me,d));
- index_set_cell (me->get_elt_pointer ("heads"), d, head_l->self_scm_);
+ index_set_cell (me->get_elt_property ("heads"), d, head_l->self_scm_);
dynamic_cast<Spanner*> (me)->set_bound (d, head_l);
me->add_dependency (head_l);
void
Tie::set_interface (Score_element*me)
{
- me->set_elt_pointer ("heads", gh_cons (SCM_EOL, SCM_EOL));
+ me->set_elt_property ("heads", gh_cons (SCM_EOL, SCM_EOL));
+ me->set_interface (ly_symbol2scm ("tie-interface"));
+}
+bool
+Tie::has_interface (Score_element*me)
+{
+ return me->has_interface (ly_symbol2scm ("tie-interface"));
}
-Rhythmic_head*
+Score_element*
Tie::head (Score_element*me, Direction d)
{
- SCM c = me->get_elt_pointer ("heads");
+ SCM c = me->get_elt_property ("heads");
c = index_cell (c, d);
- return dynamic_cast<Rhythmic_head*> (unsmob_element (c));
+ return unsmob_element (c);
}
Real
Tie::position_f (Score_element*me)
{
- return head (me,LEFT)
- ? Staff_symbol_referencer_interface (head (me,LEFT)).position_f ()
- : Staff_symbol_referencer_interface (head (me,RIGHT)).position_f () ;
+ Direction d = head (me,LEFT) ? LEFT:RIGHT;
+ return Staff_symbol_referencer::position_f (head (me,d));
}
Direction
Tie::get_default_dir (Score_element*me)
{
- Stem * sl = head(me,LEFT) ? head (me,LEFT)->stem_l () :0;
- Stem * sr = head(me,RIGHT) ? head (me,RIGHT)->stem_l () :0;
+ Item * sl = head(me,LEFT) ? Rhythmic_head::stem_l (head (me,LEFT)) :0;
+ Item * sr = head(me,RIGHT) ? Rhythmic_head::stem_l (head (me,RIGHT)) :0;
if (sl && Directional_element_interface (sl).get () == UP
&& sr && Directional_element_interface (sr).get () == UP)
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Tie,after_line_breaking);
+MAKE_SCHEME_CALLBACK(Tie,after_line_breaking);
SCM
Tie::after_line_breaking (SCM smob)
{
if (!Directional_element_interface (me).get ())
Directional_element_interface (me).set (Tie::get_default_dir (me));
- Real staff_space = Staff_symbol_referencer_interface (me).staff_space ();
+ Real staff_space = Staff_symbol_referencer::staff_space (me);
Real half_space = staff_space / 2;
Real x_gap_f = me->paper_l ()->get_var ("tie_x_gap");
Real y_gap_f = me->paper_l ()->get_var ("tie_y_gap");
return a;
}
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Tie,brew_molecule);
+MAKE_SCHEME_CALLBACK(Tie,brew_molecule);
SCM
Tie::brew_molecule (SCM smob)
Direction d (Directional_element_interface (me).get ());
Bezier_bow b (get_encompass_offset_arr (), d);
- Real staff_space = Staff_symbol_referencer_interface (me).staff_space ();
+ Real staff_space = Staff_symbol_referencer::staff_space (me);
Real h_inf = paper_l ()->get_var ("tie_height_limit_factor") * staff_space;
Real r_0 = paper_l ()->get_var ("tie_ratio");
#include "paper-def.hh"
#include "lookup.hh"
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Time_signature,brew_molecule);
+MAKE_SCHEME_CALLBACK(Time_signature,brew_molecule);
SCM
Time_signature::brew_molecule (SCM smob)
daddy_trans_l_->set_property ("timing" , SCM_BOOL_T);
daddy_trans_l_->set_property ("currentBarNumber" , gh_int2scm (1));
daddy_trans_l_->set_property ("measurePosition", smobify (new Moment));
- daddy_trans_l_->set_property ("oneBeat", smobify (new Moment (1,4)));
+ daddy_trans_l_->set_property ("beatLength", smobify (new Moment (1,4)));
daddy_trans_l_->set_property ("measureLength", smobify (new Moment (1)));
}
Timing_translator::measure_length () const
{
SCM l = get_property("measureLength");
- if (SMOB_IS_TYPE_B(Moment, l))
- return *SMOB_TO_TYPE (Moment, l);
+ if (unsmob_moment(l))
+ return *unsmob_moment (l);
else
return Moment (1);
}
-void
-Timing_translator::get_time_signature (int *n, int *d) const
-{
- Moment one_beat (1,4);
- SCM one = get_property ("beatLength");
- if (SMOB_IS_TYPE_B (Moment, one))
- one_beat = *SMOB_TO_TYPE (Moment, one);
- *n = measure_length () / one_beat;
- *d = one_beat.den_i ();
-}
-
-
void
Timing_translator::set_time_signature (int l, int o)
{
void
Tuplet_spanner::set_interface (Score_element*me)
{
- me-> set_elt_pointer ("beams", SCM_EOL);
- me->set_elt_pointer ("columns", SCM_EOL);
+ me-> set_elt_property ("beams", SCM_EOL);
+ me->set_elt_property ("columns", SCM_EOL);
}
/*
TODO.
*/
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Tuplet_spanner,brew_molecule);
+MAKE_SCHEME_CALLBACK(Tuplet_spanner,brew_molecule);
SCM
Tuplet_spanner::brew_molecule (SCM smob)
else if (bracket == ly_symbol2scm ("if-no-beam"))
number_visibility = !par_beam;
- if (gh_pair_p (me->get_elt_pointer ("columns")))
+ if (gh_pair_p (me->get_elt_property ("columns")))
{
Link_array<Note_column> column_arr=
Pointer_group_interface__extract_elements (me, (Note_column*)0, "columns");
Pointer_group_interface__extract_elements (me, (Note_column*)0, "columns");
- Score_element * common = me->common_refpoint (me->get_elt_pointer ("columns"), Y_AXIS);
+ Score_element * common = me->common_refpoint (me->get_elt_property ("columns"), Y_AXIS);
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);
+MAKE_SCHEME_CALLBACK(Tuplet_spanner,after_line_breaking);
SCM
Tuplet_spanner::after_line_breaking (SCM smob)
me->translate_axis (offset, Y_AXIS);
- if (scm_ilength (me->get_elt_pointer ("beams")) == 1)
+ if (scm_ilength (me->get_elt_property ("beams")) == 1)
{
- SCM bs = me->get_elt_pointer ("beams");
+ SCM bs = me->get_elt_property ("beams");
Score_element *b = unsmob_element (gh_car (bs));
Beam * beam_l = dynamic_cast<Beam*> (b);
if (!sp->broken_b ()
}
d = UP ;
- for (SCM s = me->get_elt_pointer ("columns"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = me->get_elt_property ("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);
#include "engraver.hh"
#include "spanner.hh"
-class Vertical_align_engraver : public Engraver {
+class Vertical_align_engraver : public Engraver
+{
Spanner * valign_p_;
bool qualifies_b (Score_element_info) const;
public:
virtual void do_removal_processing();
};
-
Vertical_align_engraver::Vertical_align_engraver()
{
valign_p_ =0;
Vertical_align_engraver::do_creation_processing()
{
valign_p_ =new Spanner (SCM_EOL); // todo -> basic props
- Align_interface (valign_p_).set_interface ();
- Align_interface (valign_p_).set_axis (Y_AXIS);
+ Align_interface::set_interface (valign_p_);
+ Align_interface::set_axis (valign_p_,Y_AXIS);
valign_p_->set_elt_property ("stacking-dir",
gh_int2scm (DOWN));
SCM max = get_property ("minVerticalAlign");
if (gh_number_p (min) || gh_number_p (max))
- {
- min = gh_number_p (min) ? min : gh_double2scm (0.0);
- max = gh_number_p (max) ? max : gh_double2scm (infinity_f);
+ {
+ min = gh_number_p (min) ? min : gh_double2scm (0.0);
+ max = gh_number_p (max) ? max : gh_double2scm (infinity_f);
- valign_p_->set_elt_property ("threshold",
- gh_cons (min,max));
- }
+ valign_p_->set_elt_property ("threshold",
+ gh_cons (min,max));
+ }
valign_p_->set_bound(RIGHT,unsmob_element (get_property ("currentCommandColumn")));
typeset_element (valign_p_);
valign_p_ =0;
{
int sz = i.origin_trans_l_arr ((Translator*)this).size() ;
-
- Axis_group_interface agi(i.elem_l_);
-
- return sz > 1 && agi.has_interface_b ()
- && !i.elem_l_->parent_l (Y_AXIS) && agi.axis_b (Y_AXIS);
+ return sz > 1 && Axis_group_interface::has_interface (i.elem_l_)
+ && !i.elem_l_->parent_l (Y_AXIS) && Axis_group_interface::axis_b (i.elem_l_, Y_AXIS);
}
void
{
if (qualifies_b (i))
{
- Align_interface(valign_p_).add_element (i.elem_l_);
+ Align_interface::add_element (valign_p_,i.elem_l_);
}
}
-
-
ADD_THIS_TRANSLATOR(Vertical_align_engraver);
#include "lookup.hh"
#include "molecule.hh"
#include "paper-column.hh"
-#include "bar.hh"
#include "paper-def.hh"
#include "volta-spanner.hh"
#include "group-interface.hh"
void
Volta_spanner::set_interface (Score_element*me)
{
- me->set_elt_pointer ("bars", SCM_EOL);
- Side_position_interface (me).set_axis (Y_AXIS);
+ me->set_elt_property ("bars", SCM_EOL);
+ Side_position::set_axis (me, Y_AXIS);
Directional_element_interface (me).set (UP);
}
*/
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Volta_spanner,brew_molecule);
+MAKE_SCHEME_CALLBACK(Volta_spanner,brew_molecule);
SCM
Volta_spanner::brew_molecule (SCM smob)
{
Score_element *me = unsmob_element (smob);
- Link_array<Bar> bar_arr
- = Pointer_group_interface__extract_elements (me, (Bar*)0, "bars");
+ Link_array<Item> bar_arr
+ = Pointer_group_interface__extract_elements (me, (Item*)0, "bars");
if (!bar_arr.size ())
return SCM_EOL;
Pointer_group_interface gi(me, "bars");
gi.add_element (b);
- Side_position_interface (me).add_support (b);
+ Side_position::add_support (me,b);
add_bound_item (dynamic_cast<Spanner*>(me), b);
}
void
Volta_spanner::add_column (Score_element*me, Score_element* c)
{
- Side_position_interface (me).add_support (c);
+ Side_position::add_support (me,c);
}
basicBarProperties = #`(
(break-align-symbol . Staff_bar)
+ (barsize-procedure . ,Bar::get_staff_bar_size)
(molecule-callback . ,Bar::brew_molecule)
(visibility-lambda . ,begin-of-line-invisible)
(breakable . #t)
(thin-kern . 3.0)
(hair-thickness . 1.6)
(thick-thickness . 6.0)
- (bar-interface . #t)
+
+ (interfaces . (bar-interface staff-bar-interface))
)
basicBarNumberProperties = #`(
(molecule-callback . ,Beam::brew_molecule)
(beam-thickness . 0.42) ; interline
(before-line-breaking-callback . ,Beam::before_line_breaking)
- (after-line-breaking-callback . ,Beam::after_line_breaking)
+ (after-line-breaking-callback . ,Beam::after_line_breaking)
+ (default-neutral-direction . 1)
+ (interfaces . (beam-interface))
+ (damping . 1)
)
basicBreakAlignProperties = #`(
(breakable . #t)
- (before-line-breaking-callback . ,Break_align_item::before_line_breaking)
-)
-
-
+ (interfaces . (break-align-interface))
+ (stacking-dir . 1)
+ (axes 0)
+ )
+ basicBreakAlignGroupProperties = #`(
+ (interfaces . (axis-group-interface))
+ (axes . (0))
+ )
basicBreathingSignProperties = #`(
(break-align-symbol . Breathing_sign)
(breakable . #t )
(molecule-callback . ,Breathing_sign::brew_molecule)
(visibility-lambda . ,begin-of-line-invisible)
+ (interfaces . (breathing-sign-interface))
)
basicClefItemProperties = #`(
(molecule-callback . ,Score_element::brew_molecule)
(breakable . #t)
(break-align-symbol . Clef_item)
(visibility-lambda . ,begin-of-line-visible)
- (clef-interface . #t)
+ (interfaces . (clef-interface))
)
basicChordNameProperties = #`(
(molecule-callback . ,Chord_name::brew_molecule)
+ (interfaces . (chord-name-interface))
)
basicCollisionProperties = #`(
(axes 0 1)
+ (interfaces . (collision-interface))
)
basicCrescendoProperties = #`(
(molecule-callback . ,Crescendo::brew_molecule)
+ (interfaces . (crescendo-interface dynamic-interface))
)
basicDotColumnProperties = #`(
- (dot-column-interface . #t)
+ (interfaces . (dot-column-interface axis-group-interface ))
+ (axes 0 )
)
basicDotsProperties = #`(
(molecule-callback . ,Dots::brew_molecule)
(dot-count . 1)
- (dots-interface . #t)
+ (interfaces . (dot-interface))
)
basicDynamicLineSpannerProperties = #`(
- (dynamic-interface . #t)
+ (interfaces (dynamic-interface))
(axes . ( 1))
)
basicDynamicTextProperties = # `(
(style . "dynamic")
- (dynamic-interface . #t)
+ (interface (dynamic-interface))
(molecule-callback . ,Text_item::brew_molecule)
(script-priority . 100)
(self-alignment-Y . 0)
(before-line-breaking-callback . ,Grace_align_item::before_line_breaking)
)
basicHaraKiriVerticalGroupspannerProperties = #`(
- (hara-kiri-interface . #t)
+ (interfaces . (hara-kiri-interface))
(axes 1)
)
basicHyphenSpannerProperties = #`(
)
basicKeyProperties = #`(
(molecule-callback . ,Key_item::brew_molecule)
- (key-item-interface . #t)
+ (interfaces . (key-item-interface))
(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)
+ (interfaces . (accidentals-interface ))
)
+ basicLineOfScoreProperties = #`( )
+%{; (axes . (0 1))
+; (interfaces . (axis-group))
+ ; (rank . -1)
+ ; )%}
basicLyricExtenderProperties = #`(
(molecule-callback . ,Lyric_extender::brew_molecule)
)
(molecule-callback . ,Text_item::brew_molecule)
(self-alignment-X . 0)
(non-rhythmic . #t)
- (text-item-interface . #t)
+ (interfaces . (text-item-interface))
)
basicMarkProperties = #`(
(molecule-callback . ,Text_item::brew_molecule)
(breakable . #t)
- (mark-interface . #t)
+ (interfaces . (mark-interface))
(visibility-lambda . ,end-of-line-invisible)
)
basicMultiMeasureRestProperties = #`(
)
basicNoteColumnProperties = #`(
(axes 0 1)
+ (interfaces . (note-column-interface))
)
basicNoteHeadProperties = #`(
- (note-head-interface . #t)
+ (interfaces . (note-head-interface rhythmic-head-interface))
(molecule-callback . ,Note_head::brew_molecule)
)
basicNoteNameProperties = #`(
(style . "italic")
)
basicPaperColumnProperties = #`(
- (paper-column-interface . #t)
+ (interfaces . (paper-column-interface))
(axes 0)
+ (rank . -1)
)
basicPedalProperties = #`(
(molecule-callback . ,Text_item::brew_molecule)
)
basicTextProperties = #`( )
basicRestProperties = #`(
- (rest-interface . #t)
+ (interfaces . (rest-interface rhythmic-head-interface))
(molecule-callback . ,Rest::brew_molecule)
(minimum-beam-collision-distance . 1.5)
)
basicRestCollisionProperties = #`(
(minimum-distance . 0.75)
+ (interfaces . (rest-collision-interface))
)
basicScriptProperties = #`(
(molecule-callback . ,Script::brew_molecule)
+ (interface . (script-interface))
)
basicScriptColumnProperties = #`(
(before-line-breaking-callback . ,Script_column::before_line_breaking)
)
basicSpanBarProperties = #`(
(break-align-symbol . Staff_bar)
+ (barsize-procedure . ,Span_bar::get_bar_size)
(molecule-callback . ,Bar::brew_molecule)
(visibility-lambda . ,begin-of-line-invisible)
(breakable . #t)
(before-line-breaking-callback . ,Span_bar::before_line_breaking)
- (after-line-breaking-callback . ,Span_bar::after_line_breaking)
;; ugh duplication!
(thin-kern . 3.0)
(hair-thickness . 1.6)
(thick-thickness . 6.0)
- (bar-interface . #t)
+ (interfaces . (bar-interface span-bar-interface))
)
basicSustainPedalProperties = #`(
(no-spacing-rods . #t)
(molecule-callback . ,Sustain_pedal::brew_molecule)
(self-alignment-X . 0)
+ (interface . (sustain-pedal-interface))
)
basicSystemStartDelimiterProperties = #`(
(molecule-callback . ,System_start_delimiter::brew_molecule)
- (after-line-breaking-callback . ,System_start_delimiter::after_line_breaking)
+ (after-line-breaking-callback . ,System_start_delimiter::after_line_breaking)
(collapse-height . 1.0)
(thickness . 1.6)
(arch-height . 1.5)
basicStemProperties = #`(
(before-line-breaking-callback . ,Stem::before_line_breaking)
(molecule-callback . ,Stem::brew_molecule)
- (stem-interface . #t)
+
+ ; if stem is on middle line, choose this direction.
+ (default-neutral-direction . 1)
+ (interfaces . (stem-interface))
)
staffSymbolBasicProperties = #`(
(molecule-callback . ,Staff_symbol::brew_molecule)
- (staff-space . 1.0 )
+ (staff-space . 1.0)
(line-count . 5 )
+ (interfaces . (staff-symbol-interface ))
)
basicTextScriptProperties = #`(
(molecule-callback . ,Text_item::brew_molecule)
(no-spacing-rods . #t)
- )
- basicTimeSignatureProperties = #`(
- (molecule-callback . ,Time_signature::brew_molecule)
- (break-align-symbol . Time_signature)
- (visibility-lambda . ,all-visible)
- (breakable . #t)
+ (interfaces . (text-script-interface text-item-interface))
)
basicTieProperties = #`(
(molecule-callback . ,Tie::brew_molecule)
- (after-line-breaking-callback . ,Tie::after_line_breaking)
+ (after-line-breaking-callback . ,Tie::after_line_breaking)
+ (interfaces . (tie-interface))
)
basicTieColumnProperties = #`(
(after-line-breaking-callback . ,Tie_column::after_line_breaking)
+ (interfaces . (tie-column-interface))
+ )
+ basicTimeSignatureProperties = #`(
+ (molecule-callback . ,Time_signature::brew_molecule)
+ (break-align-symbol . Time_signature)
+ (visibility-lambda . ,all-visible)
+ (breakable . #t)
+ (interfaces . (time-signature-interface))
)
basicTupletSpannerProperties = #`(
(number-gap . 2.0)
(thick . 1.0)
(after-line-breaking-callback . ,Tuplet_spanner::after_line_breaking)
(molecule-callback . ,Tuplet_spanner::brew_molecule)
+ (interfaces . (tuplet-spanner-interface))
)
basicStemTremoloProperties = #`(
(molecule-callback . ,Stem_tremolo::brew_molecule)
(beam-thickness . 0.42) ; interline!
)
- basicSingleMaltGroupingItemProperties = #`(
-
+ basicSeparationItemProperties = #`(
+ (interfaces . (separation-item-interface))
+ )
+ basicSeparatingGroupSpannerProperties = #`(
+ (interfaces . (separation-spanner-interface))
)
basicInstrumentNameProperties = #`(
(breakable . #t)
)
basicVoltaSpannerProperties = #`(
(molecule-callback . ,Volta_spanner::brew_molecule)
+ (interfaces . (volta-spanner-interface))
)
\accepts "Staff";
compression_energy_factor = 0.6;
-% if stem is on middle line, choose this direction.
-stem_default_neutral_direction = 1.0;
-
% in staffspace
articulation_script_padding_default = 1.0;
Begin3
Title: LilyPond
-Version: 1.3.68
-Entered-date: 02JUL00
+Version: 1.3.69
+Entered-date: 04JUL00
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.68.tar.gz
+ 1000k lilypond-1.3.69.tar.gz
Original-site: ftp.cs.uu.nl /pub/GNU/LilyPond/development/
- 1000k lilypond-1.3.68.tar.gz
+ 1000k lilypond-1.3.69.tar.gz
Copying-policy: GPL
End
Name: lilypond
-Version: 1.3.68
+Version: 1.3.69
Release: 1
Copyright: GPL
Group: Applications/Publishing
-Source0: ftp.cs.uu.nl:/pub/GNU/LilyPond/development/lilypond-1.3.68.tar.gz
+Source0: ftp.cs.uu.nl:/pub/GNU/LilyPond/development/lilypond-1.3.69.tar.gz
Summary: A program for printing sheet music.
URL: http://www.cs.uu.nl/~hanwen/lilypond
# Icon: lilypond-icon.gif
(define generic-beam-properties
- (cons 'Beam
+ (cons 'beam-interface
(list
(list 'beamSlopeDamping number? 'damping)
(list 'autoKneeGap number? 'auto-knee-gap)
(define generic-stem-properties
- (cons 'Stem
+ (cons 'stem-interface
(list
(list 'stemVerticalDirection dir? 'direction)
(list 'verticalDirection dir? 'direction)
)
(define generic-dot-properties
- (cons 'Dots
+ (cons 'dot-interface
(list
(list 'dotDirection dir? 'direction)
(list 'verticalDirection dir? 'direction)
))
(define generic-script-properties
- (cons 'Script (list
+ (cons 'script-interface
+ (list
(list 'articulationScriptVerticalDirection dir? 'direction)
(list 'articulationScriptPadding number? 'padding)
(define generic-text-properties
- (cons 'Text_item (list
+ (cons 'text-item-interface
+ (list
(list 'textStyle string? 'style)
(list 'lyricAlignment dir? 'self-alignment-X)
(list 'textScriptPadding number? 'padding)
))
(define generic-sustain-pedal-properties
- (cons 'Sustain_pedal (list
- (list 'textScriptPadding number? 'padding)
- (list 'sustainPedalPadding number? 'padding))))
+ (cons 'sustain-pedal-interface
+ (list
+ (list 'textScriptPadding number? 'padding)
+ (list 'sustainPedalPadding number? 'padding))))
(define generic-chord-name-properties
- (cons 'Chord_name (list
- (list 'textScriptWordSpace number? 'word-space)
- (list 'chordNameWordSpace number? 'word-space)
- (list 'chordNameStyle string? 'style))))
+ (cons 'chord-name-interface
+ (list
+ (list 'textScriptWordSpace number? 'word-space)
+ (list 'chordNameWordSpace number? 'word-space)
+ (list 'chordNameStyle string? 'style))))
(define generic-crescendo-properties
- (cons 'Crescendo (list
- (list 'dynamicDirection dir? 'direction)
- (list 'verticalDirection dir? 'direction)
- (list 'dynamicPadding number? 'padding)
- (list 'dynamicMinimumSpace number? 'minimum-space)
- )))
-
+ (cons 'crescendo-interface
+ (list
+ (list 'dynamicDirection dir? 'direction)
+ (list 'verticalDirection dir? 'direction)
+ (list 'dynamicPadding number? 'padding)
+ (list 'dynamicMinimumSpace number? 'minimum-space)
+ )))
+
(define generic-dynamic-line-spanner-properties
- (cons 'Dynamic_line_spanner (list
+ (cons 'dynamic-interface
+ (list
(list 'dynamicDirection dir? 'direction)
(list 'verticalDirection dir? 'direction)
(list 'dynamicPadding number? 'padding)
)))
(define generic-volta-spanner-properties
- (cons 'Volta_spanner (list
+ (cons 'volta-spanner-interface (list
(list 'voltaVerticalDirection dir? 'direction)
(list 'voltaPadding number? 'padding)
(list 'voltaMinimumSpace number? 'minimum-space)
)))
(define generic-bar-properties
- (cons 'Staff_bar (list
- (list 'barSize number? 'bar-size))
+ (cons 'staff-bar-interface
+ (list
+ (list 'barSize number? 'bar-size))
)
)
; don't do this yet. Depends on whennn the staff is really announced
(define generic-staff-symbol-properties
- (cons 'Staff_symbol (list
- )
+ (cons 'staff-symbol-interface
+ (list
+ )
)
)
(define generic-breathing-sign-properties
- (cons 'Breathing_sign
+ (cons 'breathing-sign-interface
(list
(list 'breathingSignVerticalDirection dir? 'direction)
(list 'verticalDirection dir? 'direction)
)))
(define generic-clef-properties
- (cons 'Clef_item
+ (cons 'clef-interface
(list
(list 'clefStyle string? 'style))
)
)
(define generic-All-properties
- (cons 'all (list (list 'fontSize number? 'fontsize))))
+ (cons 'all
+ (list (list 'fontSize number? 'fontsize))))
(define generic-notehead-properties
- (cons 'Note_head
+ (cons 'note-head-interface
(list (list 'noteHeadStyle symbol? 'style))))
(define generic-rest-properties
- (cons 'Rest
+ (cons 'rest-interface
(list (list 'restStyle string? 'reststyle))))
(define generic-rest-collision-properties
- (cons 'Rest_collision
+ (cons 'rest-collision-interface
(list (list 'maximumRestCount number? 'maximum-rest-count))))
(define generic-tie-properties
- (cons 'Tie (list
+ (cons 'tie-interface
+ (list
(list 'tieVerticalDirection dir? 'direction)
(list 'verticalDirection dir? 'direction)
(list 'tieDash number? 'dashed)
)))
(define generic-tie-column-properties
- (cons 'Tie_column (list
+ (cons 'tie-column-interface (list
(list 'tieVerticalDirection dir? 'direction)
(list 'verticalDirection dir? 'direction)
)))
(define generic-note-column-properties
- (cons 'Note_column
+ (cons 'note-column-interface
(list
(list 'horizontalNoteShift number? 'horizontal-shift)
(list 'forceHorizontalShift number? 'force-hshift)
)))
(define generic-collision-properties
- (cons 'Collision
+ (cons 'collision-interface
(list
(list 'collisionMergeDotted boolean? 'merge-differently-dotted)
)
)
(define generic-slur-properties
- (cons 'Slur
+ (cons 'slur-interface
(list
(list 'slurVerticalDirection dir? 'direction)
(list 'verticalDirection dir? 'direction)
(list 'slurDash number? 'dashed))))
(define generic-timesig-properties
- (cons 'Time_signature
+ (cons 'time-signature-interface
(list
(list 'timeSignatureStyle string? 'style))))
(or (boolean? s) (symbol? s)))
(define generic-tuplet-spanner-properties
- (cons 'Tuplet_spanner
+ (cons 'tuplet-spanner-interface
(list
(list 'tupletDirection dir? 'direction)
(list 'tupletNumberVisibility symbol-or-boolean? 'tuplet-number-visibility)
; Make a function that checks score element for being of a specific type.
(define (make-type-checker symbol)
(lambda (elt)
- (display symbol)
- (if (eq? #t (ly-get-elt-property elt symbol))
- #t
- #f)
+; (display symbol)
+; (eq? #t (ly-get-elt-property elt symbol))
+ (not (eq? #f (memq symbol (ly-get-elt-property elt 'interfaces))))
+
))
-
-
-
;;;;;;;;;;;;;;;;;;; TeX output
(define (tex-scm action-name)
(define (attached-to-stem slur dir)
- (let* ((note-columns (ly-get-elt-pointer slur 'note-columns))
+ (let* ((note-columns (ly-get-elt-property slur 'note-columns))
(col (if (= dir 1) (car note-columns) (car (reverse note-columns))))
- (stem (ly-get-elt-pointer col 'stem)))
+ (stem (ly-get-elt-property col 'stem)))
(and
(eq? col (ly-get-spanner-bound slur dir))
stem
- (ly-get-elt-pointer stem 'heads))))
+ (ly-get-elt-property stem 'heads))))
;; Slur-extremity-rules is a list of rules. Each rule is a pair
(list
(cons (lambda (slur dir)
;; urg, code dup
- (let* ((note-columns (ly-get-elt-pointer slur 'note-columns))
+ (let* ((note-columns (ly-get-elt-property slur 'note-columns))
(col (if (= dir 1) (car note-columns) (car (reverse note-columns))))
- (stem (ly-get-elt-pointer col 'stem)))
+ (stem (ly-get-elt-property col 'stem)))
(and stem
(not (= (ly-get-elt-property slur 'direction)
(ly-get-elt-property stem 'direction)))))) 'head)
(and (attached-to-stem slur dir)
;; and got beam
;; urg, code dup
- (let* ((note-columns (ly-get-elt-pointer slur 'note-columns))
+ (let* ((note-columns (ly-get-elt-property slur 'note-columns))
(col (if (= dir 1) (car note-columns) (car (reverse note-columns))))
- (stem (ly-get-elt-pointer col 'stem)))
+ (stem (ly-get-elt-property col 'stem)))
(and stem
- (ly-get-elt-pointer stem 'beam)
+ (ly-get-elt-property stem 'beam)
;; and beam on same side as slur
(let ((beaming (ly-get-elt-property stem 'beaming)))
(if (pair? beaming)
+++ /dev/null
-#!@PYTHON@
-
-#
-# flower.py -- python flower lib
-#
-# source file of the GNU LilyPond music typesetter
-#
-# (c) 1997 Han-Wen Nienhuys <hanwen@stack.nl>
-#
-
-import sys
-from string import *
-
-class File:
- """silly wrapper for Python file object."""
- def __init__ (self,nm, mode='r'):
- if nm:
- self.file_ = open (nm, mode);
- elif mode == 'w':
- self.file_ = sys.stdout
- else:
- self.file_ = sys.stdin
-
- self.eof_ = 0;
- def readline (self):
- l= self.file_.readline ();
- if not l:
- self.eof_ = 1;
- return l;
- def write (self, str):
- self.file_.write (str)
- def eof (self):
- return self.eof_
- def close (self):
- self.file_.close ()
- def __del__ (self):
- self.close ();
-
-
-
-import fnmatch
-import os
-
-_debug = 0
-
-_prune = ['(*)']
-
-
-def my_find(patterns, dir = os.curdir):
- list = []
- names = os.listdir(dir)
- names.sort()
- for name in names:
- if name in (os.curdir, os.pardir):
- continue
- fullname = os.path.join(dir, name)
- for pat in patterns:
- if fnmatch.fnmatch(name, pat):
- list.append(fullname)
- if os.path.isdir(fullname) and not os.path.islink(fullname):
- for p in _prune:
- if fnmatch.fnmatch(name, p):
- if _debug: print "skip", `fullname`
- break
- else:
- if _debug: print "descend into", `fullname`
- found = my_find(patterns, fullname)
- if found:
- list = list + found
- return list
-
-
-def multiple_find(pats, dirnames):
- from find import find
- l = []
- for d in dirnames:
- l = l + my_find(pats, d)
- return l
-
-def file_exist_b(name):
- try:
- f = open(name)
- except IOError:
- return 0
- f.close ()
- return 1
-
#!@PYTHON@
#
-# TODO: CLEAN THIS UP.
+# TODO: CLEAN THIS UP, merge packagepython.py and release.py
#
#!/usr/bin/python
+
+#ugh. junkme.
+
# packagepython.py -- implement general StepMake-wide python stuff
#
# source file of the GNU LilyPond music typesetter
+++ /dev/null
-#!/bin/sh
-# show-latest.sh --- show latest lily
-
-# @PERL@ @step-bindir@/out/show-latest.pl --package=@package@ $*
-# urg
-#@step-bindir@/out/show-latest --the-package=@package@ $*
-if [ $# -lt 1 ]; then
- print="-p"
-fi
-@abs-step-bindir@/out/package-latest --the-package=@package@ $* $print
-
+++ /dev/null
-#!@PYTHON@
-
-# table-to-html.py -- convert char-separated table to html table
-#
-# source file of the GNU LilyPond music typesetter
-#
-# (c) 1998 Jan Nieuwenhuizen <janneke@gnu.org>
-
-version = '0.1'
-name = 'table-to-html'
-
-import os
-import sys
-import getopt
-import string
-import time
-import re
-
-format = 'html'
-
-def program_id ():
- return name + ' version ' + version;
-
-def identify ():
- sys.stdout.write (program_id () + '\n')
-
-def help ():
- sys.stdout.write (
-r"""Usage: table-to-html [OPTION]... TABLE-FILE HTML-FILENAME
-Generate pretty table from char separated table
-Options:
- -h, --help print this help
- -p, --package=DIR specify package
- -s, --separator=SEP specify separator [:]
- -t, --latex do latex output instead
-""")
- sys.exit (0)
-
-
-def header (html):
- html.write ('<body bgcolor=white><table cellspacing=10>')
-
-def footer (html):
- html.write ('</table></body>')
-
-def convert_html (lines, outname, cols, separator, linesep):
- # ugh
- html = open (outname, 'w')
-
- header (html)
- i = 0
- for line in lines:
- i = i + 1
- if not len(line):
- continue
- columns = string.split (line, separator)
- html_line = '<tr><td>' + string.join (columns, '</td><td>') + '</td></tr>'
- html_line= re.sub (linesep, ' ', html_line)
- html.write (html_line)
-
- if len (columns) <> cols:
- print i
- raise 'not enough cols'
-
- footer (html)
- html.close ()
-
-
-def convert_tex (lines, outname, cols, separator, linesep):
- html = open(outname, 'w')
- header = r"""\documentclass{article}
-\begin{document}
-{\parindent -1pc
- \parskip 0pc\parsep 0pc
- % COMMENT( from the texbook)
- \def\length#1{\count0=0 \getlength#1\end}
- \def\getlength#1{\ifx#1\end \let\next=\relax
- \else\advance\count0 by1 \let\next=\getlength\fi \next}
- \def\inlanguage#1#2{{\length{#2}%
- \ifnum\count0=0
- \else
- \emph{#1}: #2.
- \fi}}
- \small
-
- \def\tableentry#1#2#3#4#5#6#7{\par{\bf #1}: #7
- \inlanguage{Fran\c cais}{#2}
- \inlanguage{British}{#4} \inlanguage{Deutsch}{#3}
- \inlanguage{Nederlands}{#5}\inlanguage{Italiano}{#6}}
-"""
-
- html.write (header)
- i = 0
- for line in lines:
- i = i + 1
- if not len(line):
- continue
- columns = string.split (line, separator)
- if len (columns) <> cols:
- print i
- raise 'not enough cols'
-
- tex_line = '\\tableentry{' + string.join (columns, '}{') + '}\n'
- tex_line = re.sub (linesep, ' ', tex_line)
- html.write (tex_line)
-
- html.write(r"""}\end{document}""")
- html.close ()
-
-def convert_texinfo (lines, outname, cols, separator, linesep):
- pass
-
-
-
-identify ()
-(options, files) = getopt.getopt (
- sys.argv[1:], 'f:tl:o:h:c:s:', ['columns=', 'help', 'format=', 'output=', 'separator=', 'linesep='])
-latex = 0
-separator = '@'
-output = ''
-linesep = '\r'
-for opt in options:
- o = opt[0]
- a = opt[1]
- if o == '--separator' or o == '-s':
- separator = a
- elif o== '--help' or o == '-h':
- help ()
- elif o=='--format' or o == '-f':
- format = a
- elif o == '--output' or o == '-o':
- output = a
- elif o == '--linesep' or o == '-l':
- linesep = a
- elif o == '--columns' or o == '-c':
- cols = string.atoi(a)
- else:
- print o
- raise getopt.error
-
-lines = open (files[0]).readlines ()
-
-if format == 'latex':
- convert_tex (lines, output, cols, separator, linesep)
-elif format == 'html':
- convert_html (lines, output, cols, separator, linesep)
-elif format == 'texi':
- convert_texinfo (lines, output, cols, separator, linesep)
-
+++ /dev/null
-#!/bin/sh
-
-cwd=`pwd`
-
-if [ "$1" = "" ]; then
- echo usage tar-docxx TARBALL
- exit 2
-else
- TARBALL=$1
-fi
-
-
-# mail-address
-if [ "$MAILADDRESS" != "" ]; then
- echo mail address is $MAILADDRESS
-else
- echo "mail-address:6: warning: \$MAILADDRESS undefined" > /dev/stderr
- echo $USER@`hostname`
-fi
-
-
-if [ ! -e $TARBALL ]; then
- echo $TARBALL does not exist
- exit 2
-fi
-
-TARBALLBASE=`basename $TARBALL`
-
-TAROUTDIR=/tmp/tar-docxx
-rm -rf $TAROUTDIR
-mkdir -p $TAROUTDIR
-echo untarring ...
-tar -C $TAROUTDIR -zxf $TARBALL '*.hh' '*.h'
-
-cd $TAROUTDIR
-DATE=`date`
-
-cat << EOF > banner.html
- This program documentation comes from $TARBALLBASE. It was generated by
- $USERNAME <<a href="mail:$MAILADDRESS">$MAILADDRESS</a>> on $DATE
-EOF
-
-mkdir docxx;
-echo doc++ ...
-doc++ -pSf -B banner.html -d docxx `find -type f`
-echo tarring ...
-tar -czf $cwd/progdocs.tar.gz docxx/
-
-rm -rf $TAROUTDIR
+++ /dev/null
-#!/bin/sh
-# zet-step.sh --- configure StepMake sourcetree
-# nice in first character unique name
-#
-export PACKAGE_NAME=StepMake
-prefix=$HOME/usr
-#
-#
-. ./stepmake/bin/package-zet.sh
-#
-# The package root dir looks like this:
-#
-# <SEE INSTALL.txt>
-#
-# ln -sf $STEPMAKEL_SOURCEDIR/src/stepmake/out/step $prefix/bin/step
-
-./configure --prefix=$prefix
-
projects / lilypond.git / commitdiff