SCM
-Bar::scheme_molecule (SCM smob)
+Bar::brew_molecule (SCM smob)
{
Score_element * self = unsmob_element (smob);
Bar * fly = dynamic_cast<Bar*> (self);
return SCM_EOL;
}
-MAKE_SCHEME_SCORE_ELEMENT_NON_DEFAULT_CALLBACKS(Bar);
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Bar,brew_molecule);
Molecule
Bar::compound_barline (String str, Real h) const
}
-void
-Bar::before_line_breaking ()
+GLUE_SCORE_ELEMENT(Bar,before_line_breaking );
+SCM
+Bar::member_before_line_breaking ()
{
SCM g = get_elt_property ("glyph");
SCM orig = g;
}
else if (! gh_equal_p (g, orig))
set_elt_property ("glyph", g);
+
+
+ return SCM_UNDEFINED;
}
[Alternatively, stems could set its own directions, according to
their beam, during 'final-pre-processing'.]
*/
-void
-Beam::before_line_breaking ()
+GLUE_SCORE_ELEMENT(Beam,before_line_breaking);
+SCM
+Beam::member_before_line_breaking ()
{
// Why?
if (visible_stem_count () < 2)
auto_knees ();
set_stem_directions ();
- set_stem_shorten ();
+ set_stem_shorten ();
+
+ return SCM_EOL;
}
/*
Set elt properties height and y-position if not set.
Adjust stem lengths to reach beam.
*/
-void
-Beam::after_line_breaking ()
+GLUE_SCORE_ELEMENT(Beam,after_line_breaking);
+SCM
+Beam::member_after_line_breaking ()
{
/* first, calculate y, dy */
Real y, dy;
// 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));
+ set_elt_property ("y-position", gh_double2scm (y));
+
+
+ return SCM_UNDEFINED;
}
/*
return leftbeams;
}
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACKS (Beam);
-
-Molecule
-Beam::do_brew_molecule () const
+GLUE_SCORE_ELEMENT(Beam,brew_molecule);
+SCM
+Beam::member_brew_molecule () const
{
Molecule mol;
if (!stem_count ())
- return mol;
+ return SCM_EOL;
Real x0,dx;
if (visible_stem_count ())
{
mol.translate_axis (x0
- get_bound (LEFT)->relative_coordinate (0, X_AXIS), X_AXIS);
- return mol;
+ return mol.create_scheme ();
}
int
-MAKE_SCHEME_SCORE_ELEMENT_NON_DEFAULT_CALLBACKS(Breathing_sign);
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Breathing_sign,brew_molecule);
SCM
-Breathing_sign::scheme_molecule (SCM smob)
+Breathing_sign::brew_molecule (SCM smob)
{
Score_element * sc = unsmob_element (smob);
Staff_symbol_referencer_interface si (sc);
return sc->lookup_l()->filledbox(b).create_scheme ();
}
-void
-Breathing_sign::after_line_breaking ()
+GLUE_SCORE_ELEMENT(Breathing_sign,after_line_breaking);
+SCM
+Breathing_sign::member_after_line_breaking ()
{
Real space = staff_symbol_referencer (this).staff_space();
Direction d = directional_element (this). get ();
}
translate_axis(2.0 * space * d, Y_AXIS);
+
+ return SCM_UNDEFINED;
}
return mol;
}
-MAKE_SCHEME_SCORE_ELEMENT_NON_DEFAULT_CALLBACKS(Chord_name);
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Chord_name,brew_molecule);
SCM
-Chord_name::scheme_molecule (SCM smob)
+Chord_name::brew_molecule (SCM smob)
{
Score_element *sc = unsmob_element (smob);
SCM style = sc->get_elt_property ("style");
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACKS(Crescendo)
-Molecule
-Crescendo::do_brew_molecule () const
+GLUE_SCORE_ELEMENT(Crescendo,brew_molecule);
+
+SCM
+Crescendo::member_brew_molecule () const
{
Real absdyn_dim = paper_l ()-> get_var ("crescendo_shorten");
Real extra_left = get_broken_left_end_align ();
{
Crescendo * me = (Crescendo*)this;
me->suicide ();
- Molecule m;
-
- return m;
+ return SCM_EOL;
}
Direction gd = to_dir (dir);
m.add_at_edge (X_AXIS, RIGHT, span, pad);
m.translate_axis (extra_left, X_AXIS);
- return m;
+ return m.create_scheme ();
}
{
}
-void
-Dots::after_line_breaking ()
+GLUE_SCORE_ELEMENT(Dots,after_line_breaking);
+SCM
+Dots::member_after_line_breaking ()
{
SCM d= get_elt_property ("dot-count");
if (gh_number_p (d) && gh_scm2int (d))
if (!(p % 2))
si.set_position (p + directional_element (this).get ());
}
+
+ return SCM_UNDEFINED;
+
}
-MAKE_SCHEME_SCORE_ELEMENT_NON_DEFAULT_CALLBACKS(Dots);
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Dots,brew_molecule);
SCM
-Dots::scheme_molecule (SCM d)
+Dots::brew_molecule (SCM d)
{
Score_element *sc = unsmob_element (d);
Molecule mol (sc->lookup_l ()->blank (Box (Interval (0,0),
#include "spanner.hh"
#include "item.hh"
-MAKE_SCHEME_SCORE_ELEMENT_NON_DEFAULT_CALLBACKS(Hyphen_spanner)
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Hyphen_spanner,brew_molecule)
SCM
-Hyphen_spanner::scheme_molecule (SCM smob)
+Hyphen_spanner::brew_molecule (SCM smob)
{
Spanner * sp =dynamic_cast<Spanner*> (unsmob_element (smob));
Molecule mol;
Molecule compound_barline (String, Real height) const;
Molecule simple_barline (Real wid, Real height) const;
- static SCM scheme_molecule (SCM);
+ static SCM brew_molecule (SCM);
-protected:
- virtual void before_line_breaking ();
+public:
+ SCM member_before_line_breaking ();
+ static SCM before_line_breaking (SCM);
virtual Real get_bar_size () const;
};
class Beam : public Spanner
{
public:
- static SCM scheme_molecule (SCM);
+ static SCM brew_molecule (SCM);
int stem_count () const;
int get_multiplicity () const;
-protected:
+public:
- virtual void before_line_breaking ();
- virtual void after_line_breaking ();
- Molecule do_brew_molecule () const;
+ SCM member_before_line_breaking ();
+ 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;
private:
class Breathing_sign : public Item
{
public:
- static SCM scheme_molecule (SCM);
+ static SCM brew_molecule (SCM);
VIRTUAL_COPY_CONS(Score_element);
Breathing_sign (SCM s);
-protected:
- virtual void after_line_breaking ();
- Molecule do_brew_molecule () const;
+public:
+ SCM member_after_line_breaking ();
+ static SCM after_line_breaking (SCM);
+ SCM member_brew_molecule () const;
};
#endif // BREATHING_SIGN_HH
class Chord_name : public Item
{
public:
- static SCM scheme_molecule (SCM);
+ static SCM brew_molecule (SCM);
-VIRTUAL_COPY_CONS (Score_element);
+ VIRTUAL_COPY_CONS (Score_element);
Molecule ly_word2molecule (SCM scm, Real* x) const;
Molecule ly_text2molecule (SCM scm) const;
Chord_name(SCM s);
-protected:
- Molecule do_brew_molecule () const;
+public:
+ SCM member_brew_molecule () const;
};
*/
class Crescendo : public Spanner {
public:
- static SCM scheme_molecule (SCM);
+ static SCM brew_molecule (SCM);
-Crescendo(SCM);
-protected:
+ Crescendo(SCM);
+
VIRTUAL_COPY_CONS(Score_element);
- Molecule do_brew_molecule() const;
+ SCM member_brew_molecule() const;
private:
Molecule get_symbol() const;
*/
class Dots : public Item
{
-protected:
- Molecule do_brew_molecule () const;
- virtual void after_line_breaking ();
public:
- static SCM scheme_molecule (SCM);
-
+ SCM member_brew_molecule () const;
+ SCM member_after_line_breaking ();
+ static SCM after_line_breaking (SCM);
+ static SCM brew_molecule (SCM);
Dots (SCM);
};
Spanner*elt_l_;
Lyric_extender (Spanner*);
void set_textitem (Direction, Item*);
- static SCM scheme_molecule (SCM);
+ static SCM brew_molecule (SCM);
};
#endif // EXTENDER_SPANNER_HH
}
}
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACKS(Key_item)
-
/*
TODO
- space the `natural' signs wider
*/
-Molecule
-Key_item::do_brew_molecule () const
+GLUE_SCORE_ELEMENT(Key_item,brew_molecule);
+SCM
+Key_item::member_brew_molecule () const
{
Molecule mol;
mol.add_at_edge (X_AXIS, LEFT, m,0);
}
}
-
-
}
-
- return mol;
+ return mol.create_scheme();
}
#include "note-head.hh"
#include "misc.hh"
-
void
Local_key_item::add_pitch (Musical_pitch p, bool cautionary, bool natural)
{
accidental_arr_.push (t);
}
+GLUE_SCORE_ELEMENT(Local_key_item,before_line_breaking);
-
-void
-Local_key_item::before_line_breaking ()
+SCM
+Local_key_item::member_before_line_breaking ()
{
accidental_arr_.sort (Local_key_cautionary_tuple::compare);
+ return SCM_UNDEFINED;
}
Molecule
/*
UGH. clean me up
*/
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACKS(Local_key_item)
-Molecule
-Local_key_item::do_brew_molecule () const
+
+GLUE_SCORE_ELEMENT(Local_key_item,brew_molecule);
+SCM
+Local_key_item::member_brew_molecule () const
{
Molecule mol;
Staff_symbol_referencer_interface si (this);
} while ( flip (&d)!= LEFT);
}
- return mol;
+ return mol.create_scheme();
}
Local_key_item::Local_key_item (SCM s)
#include "extender-spanner.hh"
-MAKE_SCHEME_SCORE_ELEMENT_NON_DEFAULT_CALLBACKS(Lyric_extender)
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Lyric_extender,brew_molecule)
SCM
-Lyric_extender::scheme_molecule (SCM smob)
+Lyric_extender::brew_molecule (SCM smob)
{
Spanner *sp = dynamic_cast<Spanner*> (unsmob_element (smob));
[TODO] 17
* variable-sized multi-measure rest symbol: |====| ??
*/
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACKS(Multi_measure_rest)
-Molecule
-Multi_measure_rest::do_brew_molecule () const
+
+GLUE_SCORE_ELEMENT(Multi_measure_rest,brew_molecule);
+
+SCM
+Multi_measure_rest::member_brew_molecule () const
{
Real staff_space
= staff_symbol_referencer (this).staff_space ();
mol.add_molecule (s);
}
mol.translate_axis (x_off, X_AXIS);
- return mol;
+ return mol.create_scheme();
}
/*
// set columns to SCM_EOL?
}
-void
-Multi_measure_rest::after_line_breaking ()
+GLUE_SCORE_ELEMENT(Multi_measure_rest,after_line_breaking);
+SCM
+Multi_measure_rest::member_after_line_breaking ()
{
if (!gh_pair_p (get_elt_pointer ("columns")))
{
suicide ();
}
-
+
+ return SCM_UNDEFINED;
}
}
-void
-Note_head::before_line_breaking ()
+GLUE_SCORE_ELEMENT(Note_head,before_line_breaking);
+SCM
+Note_head::member_before_line_breaking ()
{
// 8 ball looks the same as 4 ball:
si.set_position(int (me.position_f ()));
}
+
+ return SCM_UNDEFINED;
}
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACKS(Note_head);
+GLUE_SCORE_ELEMENT(Note_head,brew_molecule);
-Molecule
-Note_head::do_brew_molecule() const
+SCM
+Note_head::member_brew_molecule () const
{
Staff_symbol_referencer_interface si (this);
out.add_molecule (s);
}
}
- return out;
+ return out.create_scheme();
}
#include "staff-symbol-referencer.hh"
// -> offset callback
-void
-Rest::after_line_breaking ()
+GLUE_SCORE_ELEMENT(Rest,after_line_breaking);
+SCM
+Rest::member_after_line_breaking ()
{
if (balltype_i () == 0)
{
staff_symbol_referencer (d)
.set_position ((balltype_i () == 7) ? 4 : 3);
}
+
+ return SCM_UNDEFINED;
}
-MAKE_SCHEME_SCORE_ELEMENT_NON_DEFAULT_CALLBACKS(Rest)
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Rest,brew_molecule)
SCM
-Rest::scheme_molecule (SCM smob)
+Rest::brew_molecule (SCM smob)
{
Score_element* sc = unsmob_element (smob);
}
void
-Score_element::calculate_dependencies (int final, int busy,
- Score_element_method_pointer funcptr)
+Score_element::calculate_dependencies (int final, int busy, SCM funcname)
{
assert (status_i_ >=0);
for (SCM d= get_elt_pointer ("dependencies"); gh_pair_p (d); d = gh_cdr (d))
{
unsmob_element (gh_car (d))
- ->calculate_dependencies (final, busy, funcptr);
+ ->calculate_dependencies (final, busy, funcname);
}
- (this->*funcptr)();
+ // ughugh.
+ String s = ly_symbol2string (funcname);
+ SCM proc = get_elt_property (s.ch_C());
+ if (gh_procedure_p (proc))
+ gh_call1 (proc, this->self_scm_);
+
status_i_= final;
+
}
Molecule
{
}
-void
-Score_element::after_line_breaking ()
-{
-}
-
-
-void
-Score_element::before_line_breaking ()
-{
-}
-
void
Score_element::do_space_processing ()
{
}
-MAKE_SCHEME_SCORE_ELEMENT_NON_DEFAULT_CALLBACKS(Score_element)
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Score_element,brew_molecule)
/*
ugh.
*/
SCM
-Score_element::scheme_molecule (SCM smob)
+Score_element::brew_molecule (SCM smob)
{
Score_element * sc = unsmob_element (smob);
SCM glyph = sc->get_elt_property ("glyph");
}
-void
-Script::before_line_breaking ()
+GLUE_SCORE_ELEMENT(Script,before_line_breaking);
+SCM
+Script::member_before_line_breaking ()
{
/*
center my self on the note head.
*/
Score_element * e = parent_l(X_AXIS);
translate_axis (e->extent (X_AXIS).center (), X_AXIS);
+
+ return SCM_UNDEFINED;
}
-void
-Script::after_line_breaking ()
+GLUE_SCORE_ELEMENT(Script,after_line_breaking);
+SCM
+Script::member_after_line_breaking ()
{
Side_position_interface i (this);
Direction d = i.get_direction ();
i.set_direction (d);
+
+ return SCM_UNDEFINED;
}
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACKS(Script)
-Molecule
-Script::do_brew_molecule () const
+
+GLUE_SCORE_ELEMENT(Script,brew_molecule);
+
+SCM
+Script::member_brew_molecule () const
{
Direction dir = DOWN;
SCM d = get_elt_property ("direction");
if (isdir_b (d))
dir = to_dir (d);
- return get_molecule (dir);
+ return get_molecule (dir).create_scheme();
}
return o;
}
-void
-Slur::after_line_breaking ()
+GLUE_SCORE_ELEMENT(Slur,after_line_breaking);
+
+SCM
+Slur::member_after_line_breaking ()
{
set_extremities ();
set_control_points ();
+ return SCM_UNDEFINED;
}
/*
}
-
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACKS(Slur);
-
/*
Ugh should have dash-length + dash-period
*/
-Molecule
-Slur::do_brew_molecule () const
+GLUE_SCORE_ELEMENT(Slur,brew_molecule);
+SCM
+Slur::member_brew_molecule () const
{
Real thick = paper_l ()->get_var ("slur_thickness");
Bezier one = get_curve ();
else
a = lookup_l ()->slur (one, directional_element (this).get () * thick, thick);
- return a;
+ return a.create_scheme();
}
void
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACKS(Staff_symbol)
-Molecule
-Staff_symbol::do_brew_molecule () const
+
+GLUE_SCORE_ELEMENT(Staff_symbol,brew_molecule);
+
+SCM
+Staff_symbol::member_brew_molecule () const
{
Score_element * common
= get_bound (LEFT)->common_refpoint (get_bound (RIGHT), X_AXIS);
m.add_molecule (a);
}
- return m;
+ return m.create_scheme();
}
int
}
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACKS(Stem_tremolo)
-Molecule
-Stem_tremolo::do_brew_molecule () const
+
+GLUE_SCORE_ELEMENT(Stem_tremolo,brew_molecule);
+SCM
+Stem_tremolo::member_brew_molecule () const
{
Stem * stem = stem_l ();
Beam * beam = stem->beam_l ();
whole_note_correction, dy));
}
- return mol;
+ return mol.create_scheme();
}
}
}
-void
-Stem::before_line_breaking ()
+GLUE_SCORE_ELEMENT(Stem,before_line_breaking);
+SCM
+Stem::member_before_line_breaking ()
{
stem_end_position (); // ugh. Trigger direction calc.
position_noteheads ();
}
set_spacing_hints ();
+ return SCM_UNDEFINED;
}
const Real ANGLE = 20* (2.0*M_PI/360.0); // ugh! Should be settable.
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACKS(Stem)
-Molecule
-Stem::do_brew_molecule () const
+
+GLUE_SCORE_ELEMENT(Stem,brew_molecule);
+
+SCM
+Stem::member_brew_molecule () const
{
Molecule mol;
mol.add_molecule (fl);
}
- return mol;
+ return mol.create_scheme();
}
Real
Properties:
- glyph -- text string (TODO: make one large glyph of the Ped symbol, removes need for do_brew_molecule ())
+ glyph -- text string (TODO: make one large glyph of the Ped symbol, removes need for member_brew_molecule ())
*/
struct Sustain_pedal
{
public:
- static SCM scheme_molecule (SCM);
+ static SCM brew_molecule (SCM);
};
-MAKE_SCHEME_SCORE_ELEMENT_NON_DEFAULT_CALLBACKS(Sustain_pedal);
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Sustain_pedal,brew_molecule);
SCM
-Sustain_pedal::scheme_molecule (SCM smob)
+Sustain_pedal::brew_molecule (SCM smob)
{
Score_element * e = unsmob_element (smob);
return lookup_l ()->filledbox (Box (Interval(0,w), Interval(-h/2, h/2)));
}
-void
-System_start_delimiter::after_line_breaking ()
+GLUE_SCORE_ELEMENT(System_start_delimiter,after_line_breaking);
+SCM
+System_start_delimiter::member_after_line_breaking ()
{
SCM gl = get_elt_property ("glyph");
{
suicide ();
}
+ return SCM_UNDEFINED;
}
-MAKE_SCHEME_SCORE_ELEMENT_NON_DEFAULT_CALLBACKS(System_start_delimiter);
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(System_start_delimiter,brew_molecule);
SCM
-System_start_delimiter::scheme_molecule (SCM smob)
+System_start_delimiter::brew_molecule (SCM smob)
{
Score_element * sc = unsmob_element (smob);
struct Text_item
{
- static SCM scheme_molecule (SCM);
+ static SCM brew_molecule (SCM);
};
-MAKE_SCHEME_SCORE_ELEMENT_NON_DEFAULT_CALLBACKS(Text_item)
+MAKE_SCHEME_SCORE_ELEMENT_CALLBACK(Text_item,brew_molecule)
SCM
-Text_item::scheme_molecule (SCM sm)
+Text_item::brew_molecule (SCM sm)
{
Score_element * s = unsmob_element (sm);
index_set_cell (get_elt_pointer ("heads"), RIGHT, new_head_drul[RIGHT]->self_scm_ );
}
-void
-Tie::after_line_breaking ()
+GLUE_SCORE_ELEMENT(Tie,after_line_breaking);
+SCM
+Tie::member_after_line_breaking ()
{
if (!head (LEFT) && !head (RIGHT))
{
programming_error ("Tie without heads.");
suicide ();
- return;
+ return SCM_UNDEFINED;
}
if (!directional_element (this).get ())
}
dy_f_drul_[LEFT] = dy_f_drul_[RIGHT] = y_f;
+
+ return SCM_UNDEFINED;
}
return a;
}
+GLUE_SCORE_ELEMENT(Tie,brew_molecule);
-
-
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACKS(Tie)
-Molecule
-Tie::do_brew_molecule () const
+SCM
+Tie::member_brew_molecule () const
{
Real thick = paper_l ()->get_var ("tie_thickness");
Bezier one = get_curve ();
else
a = lookup_l ()->slur (one, directional_element (this).get () * thick, thick);
- return a;
+ return a.create_scheme();
}
}
// ugh.!
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACKS(Time_signature)
-Molecule
-Time_signature::do_brew_molecule () const
+
+GLUE_SCORE_ELEMENT(Time_signature,brew_molecule);
+SCM
+Time_signature::member_brew_molecule () const
{
SCM st = get_elt_property ("style");
String style (ly_scm2string (st));
if (style[0]=='1')
{
- return time_signature (n, 0);
+ return time_signature (n, 0).create_scheme();
}
else
{
- return special_time_signature (style, n, d);
+ return special_time_signature (style, n, d).create_scheme();
}
}
else
- return time_signature (n,d);
+ return time_signature (n,d).create_scheme();
}
Molecule
/*
TODO.
*/
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACKS(Tuplet_spanner)
-Molecule
-Tuplet_spanner::do_brew_molecule () const
+
+GLUE_SCORE_ELEMENT(Tuplet_spanner,brew_molecule);
+SCM
+Tuplet_spanner::member_brew_molecule () const
{
Molecule mol;
mol.add_molecule (Molecule (b, at));
}
}
- return mol;
+ return mol.create_scheme();
}
void
- column_arr[0]->extent (Y_AXIS) [d];
}
-void
-Tuplet_spanner::after_line_breaking ()
+GLUE_SCORE_ELEMENT(Tuplet_spanner,after_line_breaking);
+SCM
+Tuplet_spanner::member_after_line_breaking ()
{
Link_array<Note_column> column_arr=
Pointer_group_interface__extract_elements (this, (Note_column*)0, "columns");
if (!column_arr.size ())
{
suicide ();
+ return SCM_UNDEFINED;
}
Direction d = directional_element (this).get ();
&& get_bound (RIGHT)->column_l () == beam_l->get_bound (RIGHT)->column_l ())
set_elt_property ("parallel-beam", SCM_BOOL_T);
}
+ return SCM_UNDEFINED;
}
*/
-MAKE_SCHEME_SCORE_ELEMENT_CALLBACKS(Volta_spanner)
-Molecule
-Volta_spanner::do_brew_molecule () const
+
+GLUE_SCORE_ELEMENT(Volta_spanner,brew_molecule);
+SCM
+Volta_spanner::member_brew_molecule () const
{
Molecule mol;
= Pointer_group_interface__extract_elements (this, (Bar*)0, "bars");
if (!bar_arr.size ())
- return mol;
+ return mol.create_scheme();
bool no_vertical_start = false;
bool no_vertical_end = to_boolean (get_elt_property ("last-volta"));
mol.add_at_edge (X_AXIS, LEFT, num, - num.extent (X_AXIS).length ()
- staff_space);
- return mol;
+ return mol.create_scheme();
}
void
Volta_spanner::do_add_processing ()
{
-
Link_array<Bar> bar_arr
= Pointer_group_interface__extract_elements (this, (Bar*)0, "bars");
}
}
-void
-Volta_spanner::after_line_breaking ()
+GLUE_SCORE_ELEMENT(Volta_spanner,after_line_breaking);
+SCM
+Volta_spanner::member_after_line_breaking ()
{
Side_position_interface (this).add_staff_support ();
+ return SCM_UNDEFINED;
}
void