void
Align_note_column_engraver::do_creation_processing ()
{
- align_item_p_ = new Grace_align_item;
+ align_item_p_ = new Grace_align_item (SCM_EOL);
Side_position_interface (align_item_p_).set_axis (X_AXIS);
- Side_position_interface (align_item_p_).set_direction (LEFT);
+ Side_position_interface (align_item_p_).set_direction (LEFT);
+
// needed for setting font size.
announce_element (Score_element_info (align_item_p_, 0));
}
Beam*
Auto_beam_engraver::create_beam_p ()
{
- Beam* beam_p = new Beam;
+ Beam* beam_p = new Beam (get_property ("basicBeamProperties"));
for (int i = 0; i < stem_l_arr_p_->size (); i++)
{
{
if (!bar_p_)
{
- bar_p_ = new Staff_bar;
- bar_p_->set_elt_property ("break-align-symbol", ly_symbol2scm ("Staff_bar"));
+ bar_p_ = new Staff_bar (get_property ("basicBarlineProperties"));
+
// urg: "" != empty...
/*
TODO: use symbol.
{
protected:
Text_item* text_p_;
- Protected_scm visibility_lambda_;
+
Protected_scm staffs_;
protected:
void
Bar_number_engraver::do_creation_processing ()
{
- String t = "barNumberVisibilityFunction";
- SCM proc = get_property (t);
-
- if (gh_procedure_p (proc))
- visibility_lambda_ = proc;
}
{
if (text_p_)
{
- text_p_->set_elt_property ("side-support", staffs_);
+ text_p_->set_elt_pointer ("side-support-elements", staffs_);
typeset_element (text_p_);
text_p_ =0;
}
{
if (text_p_)
return;
-
- text_p_ = new Text_item;
- text_p_->set_elt_property ("breakable", SCM_BOOL_T); // ugh
+
+ SCM b = get_property ("basicBarNumberProperties");
+ text_p_ = new Text_item (b);
Side_position_interface staffside(text_p_);
staffside.set_axis (Y_AXIS);
gh_double2scm(paper_l ()->get_var ("interline")));
}
- if (gh_procedure_p (visibility_lambda_))
- text_p_->set_elt_property ("visibility-lambda",
- visibility_lambda_);
announce_element (Score_element_info (text_p_, 0));
}
}
prev_start_req_ = reqs_drul_[START];
- beam_p_ = new Beam;
+ beam_p_ = new Beam (get_property ("basicBeamProperties"));
SCM smp = get_property ("measurePosition");
Moment mp = (unsmob_moment (smp)) ? *unsmob_moment (smp) : Moment (0);
Real interline= paper_l ()->get_var ("interline");
Link_array<Score_element> elems;
Link_array<Score_element> all_elems
- = Group_interface__extract_elements (this, (Score_element*)0,
+ = Pointer_group_interface__extract_elements (this, (Score_element*)0,
"elements");
for (int i=0; i < all_elems.size(); i++)
}
-Break_align_item::Break_align_item ()
+Break_align_item::Break_align_item (SCM s)
+ : Item (s)
{
set_elt_property ("stacking-dir" , gh_int2scm (RIGHT));
{
if(breathing_sign_req_l_)
{
- breathing_sign_p_ = new Breathing_sign;
- breathing_sign_p_->set_elt_property ("break-align-symbol",
- ly_symbol2scm ("Breathing_sign"));
+ SCM b = get_property ("basicBreathingSignProperties");
+ breathing_sign_p_ = new Breathing_sign (b);
Staff_symbol_referencer_interface st (breathing_sign_p_);
st.set_interface ();
#include "direction.hh"
-Breathing_sign::Breathing_sign ()
+Breathing_sign::Breathing_sign (SCM s)
+ : Item (s)
{
- set_elt_property ("breakable", SCM_BOOL_T);
}
Molecule
if (gh_boolean_p (chord_inversion))
find_inversion_b = gh_scm2bool (chord_inversion);
- chord_name_p_ = new Chord_name;
+ chord_name_p_ = new Chord_name (SCM_EOL);
Chord chord = to_chord (pitch_arr_, tonic_req_, inversion_req_, bass_req_,
find_inversion_b);
return ly_text2molecule (text);
}
+
+Chord_name::Chord_name (SCM s)
+ : Item (s)
+{
+}
{
if (repeat_ && !beam_p_)
{
- beam_p_ = new Beam;
+ beam_p_ = new Beam (SCM_EOL);
beam_p_->set_elt_property ("chord-tremolo", SCM_BOOL_T);
SCM clef_glyph_; // no need for protection. Always referenced somewhere else.
Clef_engraver();
+
+ SCM basic_properties_;
+ Protected_scm current_settings_;
};
Clef_engraver::Clef_engraver()
{
+ current_settings_ = SCM_EOL;
+ basic_properties_ = SCM_EOL;
+
clef_glyph_ = SCM_EOL;
clef_p_ = 0;
clef_req_l_ = 0;
}
c0_position_i_ -= (int) octave_dir_ * 7;
+
+
+ current_settings_ = gh_cons (gh_cons (ly_symbol2scm ("glyph"), clef_glyph_), basic_properties_);
+ current_settings_ =
+ gh_cons (gh_cons (ly_symbol2scm ("c0-position"),
+ gh_int2scm (c0_position_i_)),
+ current_settings_);
+
return true;
}
void
Clef_engraver::do_creation_processing()
{
+ basic_properties_ = get_property ("basicClefItemProperties");
+
SCM def = get_property ("defaultClef");
if (gh_string_p (def))
{
{
if (!clef_p_)
{
- Clef_item *c= new Clef_item;
- c->set_elt_property ("breakable", SCM_BOOL_T);
- c->set_elt_property ("break-align-symbol", ly_symbol2scm ("Clef_item"));
+ Clef_item *c= new Clef_item ( current_settings_);
announce_element (Score_element_info (c, clef_req_l_));
Staff_symbol_referencer_interface si(c);
si.set_position (clef_position_i_);
if (octave_dir_)
{
- Text_item * g = new Text_item;
+ Text_item * g = new Text_item (get_property ("basicOctavateEightProperties"));
Side_position_interface spi (g);
spi.set_axis (Y_AXIS);
spi.add_support (clef_p_);
- g->set_elt_property ("text", ly_str02scm ( "8"));
- g->set_elt_property ("style", gh_str02scm ("italic"));
g->set_parent (clef_p_, Y_AXIS);
g->set_parent (clef_p_, X_AXIS);
-
- g->set_elt_property ("self-alignment-X", gh_int2scm (0));
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->set_elt_property ("direction", gh_int2scm (octave_dir_));
{
if (clef_p_)
{
- SCM vis;
- if(to_boolean (clef_p_->remove_elt_property("non-default")))
+ SCM vis = 0;
+ if(to_boolean (clef_p_->get_elt_property("non-default")))
{
vis = ly_symbol2scm ("all-visible");
+ vis = scm_eval (vis);
}
- else
- vis = ly_symbol2scm ("begin-of-line-visible");
- vis = scm_eval (vis);
+ if (vis)
+ {
+ clef_p_->set_elt_property("visibility-lambda", vis);
+ if (octavate_p_)
+ octavate_p_->set_elt_property("visibility-lambda", vis);
+ }
- clef_p_->set_elt_property("visibility-lambda", vis);
- if (octavate_p_)
- octavate_p_->set_elt_property("visibility-lambda", vis);
-
typeset_element (clef_p_);
clef_p_ =0;
#include "axis-group-interface.hh"
-Collision::Collision()
+Collision::Collision(SCM s )
+ : Item (s)
{
Axis_group_interface (this).set_interface ();
Axis_group_interface (this).set_axes (X_AXIS, Y_AXIS);
Drul_array<Array<int> > shifts;
SCM tups = SCM_EOL;
- SCM s = get_elt_property ("elements");
+ SCM s = get_elt_pointer ("elements");
for (; gh_pair_p (s); s = gh_cdr (s))
{
SCM car = gh_car (s);
for (int i=0; i < clashes.size (); i++)
{
SCM sh
- = clashes[i]->remove_elt_property ("horizontal-shift");
+ = clashes[i]->get_elt_property ("horizontal-shift");
if (gh_number_p (sh))
shift.push (gh_scm2int (sh));
{
SCM tups = SCM_EOL;
- SCM s = get_elt_property ("elements");
+ SCM s = get_elt_pointer ("elements");
for (; gh_pair_p (s); s = gh_cdr (s))
{
- Score_element * se = unsmob_element ( gh_car (s));
+ Score_element * se = unsmob_element (gh_car (s));
SCM force = se->remove_elt_property ("force-hshift");
if (gh_number_p (force))
#include "paper-column.hh"
-Crescendo::Crescendo ()
+Crescendo::Crescendo (SCM s)
+ : Spanner (s)
{
set_elt_property ("dynamic-drul", gh_cons (SCM_BOOL_F, SCM_BOOL_F));
}
if (!dotcol_p_)
{
- dotcol_p_ = new Dot_column;
+ dotcol_p_ = new Dot_column( SCM_EOL);
Side_position_interface (dotcol_p_).set_axis (X_AXIS);
Side_position_interface (dotcol_p_).set_direction (RIGHT);
announce_element (Score_element_info (dotcol_p_, 0));
void
Dot_column::add_dots (Dots *d)
{
- Group_interface gi (this, "dots");
+ Pointer_group_interface gi (this, "dots");
gi.add_element (d);
add_dependency (d);
}
-Dot_column::Dot_column ()
+Dot_column::Dot_column (SCM s)
+ : Item (s)
{
- Group_interface gi (this, "dots");
+ Pointer_group_interface gi (this, "dots");
gi.set_interface ();
directional_element (this).set (RIGHT);
void
Dot_column::after_line_breaking ()
{
- Link_array<Dots> dots = Group_interface__extract_elements (this, (Dots*)0 , "dots");
+ Link_array<Dots> dots = Pointer_group_interface__extract_elements (this, (Dots*)0 , "dots");
dots.sort (Dot_column::compare);
if (dots.size () < 2)
#include "staff-symbol-referencer.hh"
#include "directional-element-interface.hh"
-Dots::Dots ()
+Dots::Dots (SCM s)
+ : Item (s)
{
set_elt_property ("dot-count", gh_int2scm (0));
}
class Dynamic_line_spanner : public Spanner
{
public:
- Dynamic_line_spanner ();
+ Dynamic_line_spanner (SCM);
VIRTUAL_COPY_CONS(Score_element);
void add_column (Note_column*);
void add_element (Score_element*);
};
-Dynamic_line_spanner::Dynamic_line_spanner ()
+Dynamic_line_spanner::Dynamic_line_spanner (SCM s)
+ : Spanner (s)
{
set_elt_property ("transparent", SCM_BOOL_T);
Side_position_interface (this).set_axis (Y_AXIS);
void
Dynamic_engraver::announce_element (Score_element_info i)
{
- group (i.elem_l_, "interfaces").add_thing (ly_symbol2scm ("dynamic"));
+ Group_interface (i.elem_l_, "interfaces").add_thing (ly_symbol2scm ("dynamic"));
Engraver::announce_element (i);
}
&& !line_spanner_
&& pending_element_arr_.size ())
{
- line_spanner_ = new Dynamic_line_spanner;
+ line_spanner_ = new Dynamic_line_spanner (get_property ("basicDynamicLineSpannerProperties"));
for (int i = 0; i < pending_column_arr_.size (); i++)
line_spanner_->add_column (pending_column_arr_[i]);
pending_column_arr_.clear ();
{
String loud = text_req_l_->text_str_;
- text_p_ = new Text_item;
- text_p_->set_elt_property ("text",
- ly_str02scm (loud.ch_C ()));
- text_p_->set_elt_property ("style", gh_str02scm ("dynamic"));
- text_p_->set_elt_property ("script-priority",
- gh_int2scm (100));
+ text_p_ = new Text_item (get_property ("basicDynamicTextProperties"));
+ text_p_->set_elt_property ("text", ly_str02scm (loud.ch_C ()));
if (Direction d=text_req_l_->get_direction ())
directional_element (text_p_).set (d);
pending_element_arr_.push (text_p_);
- text_p_->set_elt_property ("self-alignment-Y", gh_int2scm (0));
+
text_p_->add_offset_callback (Side_position_interface::aligned_on_self,
Y_AXIS);
announce_element (Score_element_info (text_p_, text_req_l_));
else
{
span_start_req_l_ = span_req_l_drul_[START];
- cresc_p_ = new Crescendo;
+ cresc_p_ = new Crescendo (SCM_EOL);
cresc_p_->set_elt_property
("grow-direction",
gh_int2scm ((span_req_l_drul_[START]->span_type_str_ == "crescendo")
return;
}
- extender_spanner_p_ = new Extender_spanner;
+ extender_spanner_p_ = new Extender_spanner (SCM_EOL);
extender_spanner_p_->set_textitem (LEFT, last_lyric_l_);
announce_element (Score_element_info (extender_spanner_p_, req_l_));
}
#include "paper-def.hh"
#include "extender-spanner.hh"
-Extender_spanner::Extender_spanner ()
- : Spanner ()
+Extender_spanner::Extender_spanner (SCM s)
+ : Spanner (s)
+
{
dx_f_drul_[LEFT] = dx_f_drul_[RIGHT] = 0.0;
set_extent_callback (Score_element::point_dimension_callback, Y_AXIS);
#include "paper-column.hh"
#include "paper-def.hh"
-Grace_align_item::Grace_align_item ()
+Grace_align_item::Grace_align_item (SCM s)
+ : Item (s)
{
set_elt_property ("stacking-dir", gh_int2scm (RIGHT));
Align_interface (this).set_interface();
Spanner*
Hara_kiri_engraver::get_spanner_p () const
{
- return new Hara_kiri_group_spanner;
+ return new Hara_kiri_group_spanner (SCM_EOL);
}
void
#include "debug.hh"
#include "item.hh"
-Hara_kiri_group_spanner::Hara_kiri_group_spanner()
+Hara_kiri_group_spanner::Hara_kiri_group_spanner(SCM s)
+ : Spanner (s)
{
- set_elt_property ("items-worth-living", SCM_EOL);
+ set_elt_pointer ("items-worth-living", SCM_EOL);
}
void
Hara_kiri_group_spanner::add_interesting_item (Item* n)
{
add_dependency (n);
- set_elt_property ("items-worth-living",
- gh_cons (n->self_scm_,
- get_elt_property ("items-worth-living")));
+ Pointer_group_interface (this, "items-worth-living").add_element (n);
}
void
Hara_kiri_group_spanner::after_line_breaking ()
{
- SCM worth = get_elt_property ("items-worth-living");
+ SCM worth = get_elt_pointer ("items-worth-living");
if (gh_pair_p (worth))
return;
return;
}
- hyphen_spanner_p_ = new Hyphen_spanner;
+ hyphen_spanner_p_ = new Hyphen_spanner (SCM_EOL);
hyphen_spanner_p_->set_textitem (LEFT, last_lyric_l_);
announce_element (Score_element_info (hyphen_spanner_p_, req_l_));
}
#include "hyphen-spanner.hh"
#include "dimension-cache.hh"
-Hyphen_spanner::Hyphen_spanner ()
- : Spanner ()
+Hyphen_spanner::Hyphen_spanner (SCM s)
+ : Spanner (s)
{
dx_f_drul_[LEFT] = dx_f_drul_[RIGHT] = 0.0;
class Bar:public Item {
public:
VIRTUAL_COPY_CONS(Score_element);
- Bar();
+ Bar(SCM);
Molecule compound_barline (String, Real height) const;
Molecule simple_barline (Real wid, Real height) const;
Stem* first_visible_stem () const;
Stem* last_visible_stem () const;
- Beam ();
+ Beam (SCM);
void add_stem (Stem*);
void set_grouping (Rhythmic_grouping def, Rhythmic_grouping current);
void set_beaming (Beaming_info_list *);
protected:
virtual void before_line_breaking ();
public:
- Break_align_item ();
+ Break_align_item (SCM s);
VIRTUAL_COPY_CONS(Score_element);
};
#endif // BREAK_ALIGN_ITEM_HH
{
public:
VIRTUAL_COPY_CONS(Score_element);
- Breathing_sign ();
+ Breathing_sign (SCM s);
protected:
virtual void after_line_breaking ();
virtual Molecule do_brew_molecule () const;
VIRTUAL_COPY_CONS (Score_element);
Molecule ly_word2molecule (SCM scm) const;
Molecule ly_text2molecule (SCM scm) const;
-
+ Chord_name(SCM s);
protected:
virtual Molecule do_brew_molecule () const;
+
};
#endif // CHORD_NAME_HH
virtual void before_line_breaking ();
public:
VIRTUAL_COPY_CONS(Score_element);
+ Clef_item (SCM);
};
#endif // CLEFITEM_HH
public:
void add_column (Note_column*ncol_l);
- Collision();
+ Collision(SCM);
};
#endif // COLLISION_HH
*/
class Crescendo : public Spanner {
public:
- Crescendo();
+ Crescendo(SCM);
protected:
VIRTUAL_COPY_CONS(Score_element);
virtual Molecule do_brew_molecule() const;
public:
VIRTUAL_COPY_CONS (Score_element);
void add_head (Rhythmic_head*);
- Dot_column ();
+ Dot_column (SCM);
protected:
virtual void after_line_breaking ();
virtual void after_line_breaking ();
public:
- Dots ();
+ Dots (SCM);
};
#endif // DOTS_HH
class Extender_spanner : public Spanner
{
public:
- Extender_spanner ();
+ Extender_spanner (SCM);
void set_textitem (Direction, Item*);
protected:
{
public:
VIRTUAL_COPY_CONS (Score_element);
- Grace_align_item ();
+ Grace_align_item (SCM);
protected:
virtual void do_add_processing ();
virtual void before_line_breaking ();
class Hara_kiri_group_spanner : public Spanner
{
public:
- Hara_kiri_group_spanner ();
+ Hara_kiri_group_spanner (SCM);
virtual void after_line_breaking ();
void add_interesting_item (Item* n);
protected:
class Hyphen_spanner : public Spanner
{
public:
-Hyphen_spanner ();
+ Hyphen_spanner (SCM);
void set_textitem (Direction, Item*);
protected:
public:
VIRTUAL_COPY_CONS(Score_element);
- Item();
+ Item (SCM);
Item (Item const &);
bool breakable_b () const;
public:
VIRTUAL_COPY_CONS(Score_element);
- Key_item ();
+ Key_item (SCM);
void add (int pitch, int acc);
void add_old (int pitch, int acc);
Molecule accidental (int,bool,bool) const;
public:
-
+ Local_key_item (SCM );
void add_pitch (Musical_pitch, bool cautionary, bool natural);
protected:
virtual void before_line_breaking ();
virtual Molecule do_brew_molecule() const;
+
+
};
#endif // LOCALKEYITEM_HH
class Multi_measure_rest : public Spanner
{
public:
- Multi_measure_rest ();
+ Multi_measure_rest (SCM);
void add_column (Item*);
Molecule compound_rest (int)const;
void translate_rests(int dy);
Note_head * first_head ()const;
Interval rest_dim ()const ;
- Note_column ();
+ Note_column (SCM);
void set_stem (Stem*);
void set_dotcol (Dot_column*);
void add_head (Rhythmic_head*);
static int compare (Note_head * const &a, Note_head *const &b) ;
Molecule ledger_line (Interval) const;
+ Note_head (SCM);
protected:
-
virtual void before_line_breaking ();
virtual Molecule do_brew_molecule() const;
};
void add_column (Note_column*);
Interval rest_dim () const;
- Rest_collision();
+ Rest_collision(SCM);
protected:
virtual void before_line_breaking ();
};
protected:
virtual void after_line_breaking ();
virtual Molecule do_brew_molecule () const;
+public:
+ Rest (SCM s);
};
#endif // REST_HH
class Script_column : public Item
{
public:
- Script_column();
+ Script_column(SCM);
void add_staff_sided (Item*);
protected:
virtual void before_line_breaking ();
{
Molecule get_molecule (Direction d) const;
public:
+ Script (SCM);
protected:
virtual void before_line_breaking ();
{
public:
void add_spacing_unit (Single_malt_grouping_item*);
- Separating_group_spanner();
+ Separating_group_spanner(SCM);
protected:
VIRTUAL_COPY_CONS(Score_element);
virtual Array<Rod> get_rods () const;
{
VIRTUAL_COPY_CONS(Score_element);
public:
- Single_malt_grouping_item ();
+ Single_malt_grouping_item (SCM);
Interval my_width () const;
void add_item (Item*);
};
class Slur : public Spanner
{
public:
- Slur ();
+ Slur (SCM);
VIRTUAL_COPY_CONS(Score_element);
void add_column (Note_column*);
class Spacing_spanner : public Spanner
{
public:
- Spacing_spanner ();
+ Spacing_spanner (SCM);
VIRTUAL_COPY_CONS(Score_element);
Array<Spring> do_measure (Link_array<Paper_column>) const;
{
Interval get_spanned_interval () const;
public:
- Span_bar();
+ Span_bar (SCM);
VIRTUAL_COPY_CONS(Score_element);
void add_bar (Score_element*);
public:
VIRTUAL_COPY_CONS(Score_element);
virtual Real get_bar_size () const;
+ Staff_bar (SCM);
};
#endif /* STAFF_BAR_HH */
Real staff_space () const;
int steps_i() const;
int line_count () const;
+ Staff_symbol (SCM s);
+
protected:
VIRTUAL_COPY_CONS(Score_element);
virtual Molecule do_brew_molecule() const;
+
};
#endif // STAFFSYM_HH
static Interval dim_callback (Score_element*, Axis);
public:
- Stem_tremolo ();
+ Stem_tremolo (SCM);
void set_stem (Stem *);
};
Drul_array<Note_head*> extremal_heads () const;
Score_element * support_head () const;
- Stem ();
+ Stem (SCM);
/// ensure that this Stem also encompasses the Notehead #n#
void add_head (Rhythmic_head*n);
{
public:
VIRTUAL_COPY_CONS (Score_element);
-
+ Sustain_pedal (SCM);
protected:
virtual Molecule do_brew_molecule () const;
virtual void after_line_breaking ();
class System_start_delimiter : public Spanner
{
public:
- System_start_delimiter ();
+ System_start_delimiter (SCM);
VIRTUAL_COPY_CONS (Score_element);
protected:
virtual void after_line_breaking();
{
public:
VIRTUAL_COPY_CONS (Score_element);
+ Text_item (SCM s);
protected:
virtual Molecule do_brew_molecule () const;
};
public:
VIRTUAL_COPY_CONS (Score_element);
void add_tie (Tie*);
- Tie_column ();
+ Tie_column (SCM s);
protected:
virtual void after_line_breaking ();
void set_directions ();
-
};
#endif /* TIE_COLUMN_HH */
class Tie : public Spanner
{
public:
- Tie ();
+ Tie (SCM);
void set_head (Direction, Item*head_l);
VIRTUAL_COPY_CONS(Score_element);
protected:
virtual Molecule do_brew_molecule() const;
public:
- Time_signature () ;
+ Time_signature (SCM);
/*
TODO: make this SCM!
class Tuplet_spanner : public Spanner
{
public:
- Tuplet_spanner ();
+ Tuplet_spanner (SCM);
void add_column (Note_column*);
void add_beam (Beam*);
class Volta_spanner : public Spanner
{
public:
- Volta_spanner ();
+ Volta_spanner (SCM);
void add_column (Note_column*);
void add_bar (Bar*);
{
if(!text_)
{
- text_ = new Text_item;
+ text_ = new Text_item (get_property ("basicInstrumentNameProperties"));
text_->set_elt_property ("text", txt);
- text_->set_elt_property ("breakable", SCM_BOOL_T);
/*
TODO: use more lispish names for break-align-symbols
*/
- text_->set_elt_property ("break-align-symbol", ly_symbol2scm ("Instrument_name"));
- text_->set_elt_property ("visibility-lambda",
- scm_eval (ly_symbol2scm ("begin-of-line-visible")));
-
if (delim_)
text_->set_parent (delim_, Y_AXIS);
const int FLAT_TOP_PITCH=2; /* fes,ges,as and bes typeset in lower octave */
const int SHARP_TOP_PITCH=4; /* ais and bis typeset in lower octave */
-Key_item::Key_item ()
+Key_item::Key_item (SCM s)
+ : Item (s)
{
- set_elt_property ("breakable", SCM_BOOL_T);
set_elt_property ("c0-position", gh_int2scm (0));
-
- set_elt_property ("old-accidentals", SCM_EOL);
- set_elt_property ("new-accidentals", SCM_EOL);
}
void
void
Line_group_engraver_group::create_line_spanner ()
{
- staffline_p_ = new 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);
}
{
if (!text_item_p_ && interesting_.size ())
{
- text_item_p_ = new Text_item;
+ text_item_p_ = new Text_item (SCM_EOL);
Side_position_interface si (text_item_p_);
si.set_axis (Y_AXIS);
text_item_p_->set_parent (interesting_[0].elem_l_, Y_AXIS);
#include "all-font-metrics.hh"
Line_of_score::Line_of_score()
+ : Spanner (SCM_EOL)
{
- set_elt_property ("columns", SCM_EOL);
- set_elt_property ("all-elements", SCM_EOL);
+ set_elt_pointer ("columns", SCM_EOL);
+ set_elt_pointer ("all-elements", SCM_EOL);
Axis_group_interface (this).set_interface ();
Axis_group_interface (this).set_axes (Y_AXIS,X_AXIS);
int
Line_of_score::element_count () const
{
- return scm_ilength ( get_elt_property ("all-elements"));
+ return scm_ilength ( get_elt_pointer ("all-elements"));
}
Line_of_score::typeset_element (Score_element * elem_p)
{
elem_p->pscore_l_ = pscore_l_;
- Group_interface (this, "all-elements").add_element (elem_p);
+ Pointer_group_interface (this, "all-elements").add_element (elem_p);
scm_unprotect_object (elem_p->self_scm_);
}
void
Line_of_score::output_lines ()
{
- for (SCM s = get_elt_property ("all-elements");
+ for (SCM s = get_elt_pointer ("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_property ("all-elements");
+ SCM all = se->get_elt_pointer ("all-elements");
for (SCM s = all; gh_pair_p (s); s = gh_cdr (s))
{
unsmob_element (gh_car (s))->fixup_refpoint ();
/*
needed for doing items.
*/
- for (SCM s = get_elt_property ("all-elements");
+ for (SCM s = get_elt_pointer ("all-elements");
gh_pair_p (s); s = gh_cdr (s))
{
unsmob_element (gh_car (s))->fixup_refpoint ();
}
- for (SCM s = get_elt_property ("all-elements");
+ for (SCM s = get_elt_pointer ("all-elements");
gh_pair_p (s); s = gh_cdr (s))
{
unsmob_element (gh_car (s))->handle_broken_dependencies ();
void
Line_of_score::add_column (Paper_column*p)
{
- SCM cs = get_elt_property ("columns");
+ SCM cs = get_elt_pointer ("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_property ("columns", gh_cons (p->self_scm_, cs));
+ set_elt_pointer ("columns", gh_cons (p->self_scm_, cs));
Axis_group_interface (this).add_element (p);
typeset_element (p);
Line_of_score::column_l_arr ()const
{
Link_array<Paper_column> acs
- = Group_interface__extract_elements (this, (Paper_column*) 0, "columns");
+ = Pointer_group_interface__extract_elements (this, (Paper_column*) 0, "columns");
bool bfound = false;
for (int i= acs.size (); i -- ; )
{
seem empty. We need to retain breakable columns, in case
someone forced a breakpoint.
*/
- if (!bfound
- || (acs[i]->get_elt_property ("elements") == SCM_EOL
- && !brb))
+ if (!bfound || !acs[i]->used_b ())
acs.del (i);
}
return acs;
void
Line_of_score::pre_processing ()
{
- for (SCM s = get_elt_property ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = get_elt_pointer ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
unsmob_element (gh_car (s))->discretionary_processing ();
progress_indication ( _f("Element count %d ", element_count ()));
- for (SCM s = get_elt_property ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = get_elt_pointer ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
unsmob_element (gh_car (s))->handle_prebroken_dependencies ();
- fixup_refpoints (get_elt_property ("all-elements"));
+ fixup_refpoints (get_elt_pointer ("all-elements"));
- for (SCM s = get_elt_property ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = get_elt_pointer ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
{
Score_element* sc = unsmob_element (gh_car (s));
sc->calculate_dependencies (PRECALCED, PRECALCING, &Score_element::before_line_breaking);
}
progress_indication ("\n" + _ ("Calculating column positions...") + " " );
- for (SCM s = get_elt_property ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = get_elt_pointer ("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_property ("all-elements");
+ for (SCM s = get_elt_pointer ("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_property ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = get_elt_pointer ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
unsmob_element (gh_car (s))->get_molecule ();
/*
/*
all elements.
*/
- for (SCM s = get_elt_property ("all-elements"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = get_elt_pointer ("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_property ("columns");
+ SCM s = get_elt_pointer ("columns");
while (gh_car (s) != r->self_scm_)
s = gh_cdr (s);
{
if (!key_item_p_)
{
- key_item_p_ = new Local_key_item;
+ key_item_p_ = new Local_key_item (SCM_EOL);
Side_position_interface (key_item_p_).set_axis (X_AXIS);
Side_position_interface (key_item_p_).set_direction (LEFT);
staff_symbol_referencer(key_item_p_).set_interface ();
return mol;
}
+Local_key_item::Local_key_item (SCM s)
+ : Item (s)
+{
+
+}
{
if (req_l_)
{
- text_p_= new Text_item;
+ text_p_= new Text_item (get_property ("basicLyricTextProperties"));
text_p_->set_elt_property ("text",
ly_str02scm ((req_l_->text_str_ + " ").ch_C ()));
- text_p_->set_elt_property ("non-rhythmic", SCM_BOOL_T);
+
announce_element (Score_element_info (text_p_, req_l_));
}
}
Mark_engraver ();
protected:
Text_item* text_p_;
- Protected_scm visibility_lambda_;
Protected_scm staffs_;
protected:
void
Mark_engraver::do_creation_processing ()
{
- String t = "markVisibilityFunction";
- SCM proc = get_property (t);
-
- if (gh_procedure_p (proc))
- visibility_lambda_ = proc;
}
-
void
Mark_engraver::acknowledge_element (Score_element_info inf)
{
{
if (text_p_)
{
- text_p_->set_elt_property ("side-support" , staffs_);
+ text_p_->set_elt_pointer("side-support-elements" , staffs_);
typeset_element (text_p_);
text_p_ =0;
}
{
if (text_p_)
return;
-
- text_p_ = new Text_item;
- text_p_->set_elt_property ("breakable", SCM_BOOL_T); // ugh
+
+ SCM s = get_property ("basicMarkProperties");
+ text_p_ = new Text_item (s);
+
Group_interface (text_p_, "interfaces").add_thing (ly_symbol2scm ("Mark"));
Side_position_interface staffside(text_p_);
staffside.set_axis (Y_AXIS);
+ /*
+ -> Generic props.
+ */
SCM prop = get_property ("markDirection");
if (!isdir_b (prop))
{
gh_double2scm(paper_l ()->get_var ("interline")));
}
- if (gh_procedure_p (visibility_lambda_))
- text_p_->set_elt_property ("visibility-lambda",
- visibility_lambda_);
announce_element (Score_element_info (text_p_, rq));
}
if (busy_span_req_l_ && !mmrest_p_)
{
- mmrest_p_ = new Multi_measure_rest;
+ mmrest_p_ = new Multi_measure_rest (SCM_EOL);
Staff_symbol_referencer_interface si (mmrest_p_);
si.set_interface ();
if (mmrest_p_ && (now_mom () >= start_moment_)
&& !mp
- && (scm_ilength (mmrest_p_->get_elt_property ("columns")) >= 2))
+ && (scm_ilength (mmrest_p_->get_elt_pointer ("columns")) >= 2))
{
typeset_element (mmrest_p_);
/*
#include "stem.hh"
#include "staff-symbol-referencer.hh"
-Multi_measure_rest::Multi_measure_rest ()
+Multi_measure_rest::Multi_measure_rest (SCM s)
+ : Spanner (s)
{
- set_elt_property ("columns", SCM_EOL);
+ set_elt_pointer ("columns", SCM_EOL);
}
void
Multi_measure_rest::do_add_processing ()
{
- if (gh_pair_p (get_elt_property ("columns")))
+ if (gh_pair_p (get_elt_pointer ("columns")))
{
- Link_array<Item> column_arr (Group_interface__extract_elements (this, (Item*)0, "columns"));
+ Link_array<Item> column_arr (Pointer_group_interface__extract_elements (this, (Item*)0, "columns"));
set_bound (LEFT, column_arr[0 >? column_arr.size () - 2]);
set_bound (RIGHT, column_arr.top ());
void
Multi_measure_rest::after_line_breaking ()
{
- if (!gh_pair_p (get_elt_property ("columns")))
+ if (!gh_pair_p (get_elt_pointer ("columns")))
set_elt_property ("transparent", SCM_BOOL_T);
}
void
Multi_measure_rest::add_column (Item* c)
{
- Group_interface gi (this, "columns");
+ Pointer_group_interface gi (this, "columns");
gi.add_element (c);
bool
Note_column::rest_b () const
{
- SCM r = get_elt_property ("rests");
+ SCM r = get_elt_pointer ("rests");
return gh_pair_p (r);
}
return h1 - h2;
}
-Note_column::Note_column()
+Note_column::Note_column( SCM s)
+ : Item (s)
{
- set_elt_property ("rests", SCM_EOL);
- set_elt_property ("note-heads", SCM_EOL);
+ set_elt_pointer ("rests", SCM_EOL);
+ 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"));
Stem *
Note_column::stem_l () const
{
- SCM s = get_elt_property ("stem");
+ SCM s = get_elt_pointer ("stem");
return dynamic_cast<Stem*> (unsmob_element (s));
}
iv.set_empty ();
- SCM h = get_elt_property ("note-heads");
+ SCM h = get_elt_pointer ("note-heads");
for (; gh_pair_p (h); h = gh_cdr (h))
{
Score_element *se = unsmob_element (gh_car (h));
{
if (stem_l ())
return stem_l ()->get_direction ();
- else if (gh_pair_p (get_elt_property ("note-heads")))
+ else if (gh_pair_p (get_elt_pointer ("note-heads")))
return (Direction)sign (head_positions_interval().center ());
programming_error ("Note column without heads and stem!");
void
Note_column::set_stem (Stem * stem_l)
{
- set_elt_property ("stem", stem_l->self_scm_);
+ set_elt_pointer ("stem", stem_l->self_scm_);
add_dependency (stem_l);
Axis_group_interface (this).add_element (stem_l);
{
if (Rest*r=dynamic_cast<Rest *> (h))
{
- Group_interface gi (this, "rests");
+ Pointer_group_interface gi (this, "rests");
gi.add_element (h);
}
if (Note_head *nh=dynamic_cast<Note_head *> (h))
{
- Group_interface gi (this, "note-heads");
+ Pointer_group_interface gi (this, "note-heads");
gi.add_element (nh);
}
Axis_group_interface (this).add_element (h);
void
Note_column::translate_rests (int dy_i)
{
- SCM s = get_elt_property ("rests");
+ SCM s = get_elt_pointer ("rests");
for (; gh_pair_p (s); s = gh_cdr (s))
{
Score_element * se = unsmob_element (gh_car (s));
Direction d = stem_l ()->get_direction ();
Real beamy = (stem_l ()->relative_coordinate (0, X_AXIS) - x0) * dydx + beam_y;
- s = get_elt_property ("rests");
+ s = get_elt_pointer ("rests");
Score_element * se = unsmob_element (gh_car (s));
Staff_symbol_referencer_interface si (se);
Note_column::rest_dim () const
{
Interval restdim;
- SCM s = get_elt_property ("rests");
+ SCM s = get_elt_pointer ("rests");
for (; gh_pair_p (s); s = gh_cdr (s))
{
Score_element * sc = unsmob_element ( gh_car (s));
return out;
}
+
+Note_head::Note_head (SCM s)
+ : Rhythmic_head (s)
+{
+
+}
for (int i=0; i < note_req_l_arr_.size (); i++)
{
- Note_head *note_p = new Note_head;
+ Note_head *note_p = new Note_head (SCM_EOL);
Staff_symbol_referencer_interface si (note_p);
si.set_interface ();
if (note_req_l->duration_.dots_i_)
{
- Dots * d = new Dots;
+ Dots * d = new Dots (SCM_EOL);
Staff_symbol_referencer_interface sd (d);
sd.set_interface ();
}
if (s.length_i())
{
- Text_item * t = new Text_item;
+ Text_item * t = new Text_item (SCM_EOL);
t->set_elt_property ("text", ly_str02scm ( s.ch_C()));
announce_element (Score_element_info (t, req_l_arr_[0]));
texts_.push (t);
}
Paper_column::Paper_column (Moment w)
+ : Item (SCM_EOL)
{
SCM when = (new Moment (w))->smobify_self ();
scm_unprotect_object (when);
return s != Moment(0);
}
+bool
+Paper_column::used_b ()const
+{
+ return gh_pair_p (get_elt_pointer ("elements")) || breakable_b ();
+}
{
if (p->name_ == String ("Sustain"))
{
- p->item_p_ = new Sustain_pedal;
+ p->item_p_ = new Sustain_pedal (SCM_EOL);
p->item_p_->set_elt_property ("text", s);
}
else
{
- p->item_p_ = new Text_item;
+ p->item_p_ = new Text_item (SCM_EOL);
p->item_p_->set_elt_property ("text", s);
// guh
p->item_p_->set_elt_property ("style", ly_str02scm ("italic"));
Side_position_interface si (p->item_p_);
si.set_axis (Y_AXIS);
+ // todo: init with basic props.
p->item_p_->set_elt_property ("no-spacing-rods" , SCM_BOOL_T);
p->item_p_->set_elt_property ("self-alignment-X", gh_int2scm (0));
p->item_p_->add_offset_callback (Side_position_interface::aligned_on_self, X_AXIS);
else
{
assert (!volta_span_p_);
- volta_span_p_ = new Volta_spanner;
+ volta_span_p_ = new Volta_spanner (SCM_EOL);
announce_element (Score_element_info (volta_span_p_,0));
volta_span_p_->set_elt_property ("text",
ly_str02scm (t.ch_C()));
if (rest_collision_p_ || note_column_l_arr_.size () < 2)
return;
- rest_collision_p_ = new Rest_collision;
+ rest_collision_p_ = new Rest_collision (get_property ("basicRestCollisionProperties"));
announce_element (Score_element_info (rest_collision_p_, 0));
for (int i=0; i< note_column_l_arr_.size (); i++)
Rest_collision::add_column (Note_column *nc_l)
{
add_dependency (nc_l);
- Group_interface gi (this);
+ Pointer_group_interface gi (this);
if (nc_l->rest_b ())
gi.name_ = "rests";
else
static Rhythmic_head*
col2rhythmic_head (Note_column* c)
{
- SCM s = c->get_elt_property ("rests");
+ SCM s = c->get_elt_pointer ("rests");
assert (gh_pair_p (s));
Score_element* e = unsmob_element (gh_car (s));
return dynamic_cast<Rhythmic_head*> (e);
Rest_collision::before_line_breaking ()
{
Link_array<Note_column> rest_l_arr =
- Group_interface__extract_elements (this, (Note_column*) 0, "rests");
+ Pointer_group_interface__extract_elements (this, (Note_column*) 0, "rests");
Link_array<Note_column> ncol_l_arr =
- Group_interface__extract_elements (this, (Note_column*) 0, "notes");
+ Pointer_group_interface__extract_elements (this, (Note_column*) 0, "notes");
/*
}
-Rest_collision::Rest_collision()
+Rest_collision::Rest_collision(SCM s)
+ : Item (s)
{
- set_elt_property ("rests", SCM_EOL);
- set_elt_property ("notes", SCM_EOL);
- set_elt_property ("transparent", SCM_BOOL_T);
+ set_elt_pointer ("rests", SCM_EOL);
+ set_elt_pointer ("notes", SCM_EOL);
set_extent_callback (0, X_AXIS);
set_extent_callback (0, Y_AXIS);
}
{
if (rest_req_l_ && !rest_p_)
{
- rest_p_ = new Rest;
+ rest_p_ = new Rest (SCM_EOL);
Staff_symbol_referencer_interface si (rest_p_);
si.set_interface ();
if (rest_req_l_->duration_.dots_i_)
{
- dot_p_ = new Dots;
+ dot_p_ = new Dots (SCM_EOL);
Staff_symbol_referencer_interface si (dot_p_);
si.set_interface ();
+Rest::Rest (SCM s)
+ : Rhythmic_head (s)
+{
+}
+
{
if (!ncol_p_)
{
- ncol_p_ = new Note_column;
+ ncol_p_ = new Note_column (SCM_EOL);
announce_element (Score_element_info (ncol_p_, 0));
}
Dots*
Rhythmic_head::dots_l () const
{
- SCM s = get_elt_property ("dot");
+ SCM s = get_elt_pointer ("dot");
return dynamic_cast<Dots*> (unsmob_element (s));
}
Stem*
Rhythmic_head::stem_l () const
{
- SCM s = get_elt_property ("stem");
+ SCM s = get_elt_pointer ("stem");
return dynamic_cast<Stem*> (unsmob_element (s));
}
void
Rhythmic_head::add_dots (Dots *dot_l)
{
- set_elt_property ("dot", dot_l->self_scm_);
+ set_elt_pointer ("dot", dot_l->self_scm_);
dot_l->add_dependency (this);
}
+Rhythmic_head::Rhythmic_head (SCM s)
+ : Item (s)
+{
+}
{
if (!scol_p_ && script_l_arr_.size () > 1)
{
- scol_p_ = new Script_column;
+ scol_p_ = new Script_column (SCM_EOL);
announce_element (Score_element_info (scol_p_, 0));
}
return;
- Group_interface gi (this, "scripts");
+ Pointer_group_interface gi (this, "scripts");
gi.add_element (i);
add_dependency (i);
}
-Script_column::Script_column ()
+Script_column::Script_column (SCM s)
+ : Item (s)
{
- set_elt_property ("scripts", SCM_EOL);
+ set_elt_pointer ("scripts", SCM_EOL);
}
static int
{
Drul_array<Link_array<Item> > arrs;
Link_array<Item> staff_sided
- = Group_interface__extract_elements (this, (Item*)0, "scripts");
+ = Pointer_group_interface__extract_elements (this, (Item*)0, "scripts");
for (int i=0; i < staff_sided.size (); i++)
l->articulation_str_.ch_C ()));
continue;
}
- Script *p =new Script;
+ // todo -> use result of articulation-to-scriptdef directly as basic prop list.
+ Script *p =new Script (SCM_EOL);
Side_position_interface stafy (p);
#include "paper-def.hh"
#include "dimension-cache.hh"
+Script ::Script (SCM s)
+ : Item (s)
+{
+}
Molecule
Script::get_molecule(Direction d) const
#include "paper-column.hh"
#include "paper-def.hh"
#include "dimensions.hh"
+#include "group-interface.hh"
static Rod
make_rod (Single_malt_grouping_item *l, Single_malt_grouping_item *r)
{
Array<Rod> a;
- for (SCM s = get_elt_property ("elements"); gh_pair_p (s) && gh_pair_p (gh_cdr (s)); s = gh_cdr (s))
+ for (SCM s = get_elt_pointer ("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_property ("elements"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = get_elt_pointer ("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 (Single_malt_grouping_item*i)
{
- set_elt_property ("elements",
- gh_cons (i->self_scm_,
- get_elt_property ("elements")));
+ Pointer_group_interface (this, "elements").add_element (i);
add_dependency (i);
}
-Separating_group_spanner::Separating_group_spanner ()
+Separating_group_spanner::Separating_group_spanner (SCM s)
+ : Spanner (s)
{
- set_elt_property ("elements", SCM_EOL);
+ set_elt_pointer ("elements", SCM_EOL);
}
#include "debug.hh"
#include "note-column.hh"
#include "translator-group.hh"
+#include "engraver.hh"
+
+class Slur_engraver :public Engraver {
+ Link_array<Span_req> requests_arr_;
+ Link_array<Span_req> new_slur_req_l_arr_;
+ Link_array<Slur> slur_l_stack_;
+ Link_array<Slur> end_slur_l_arr_;
+
+ void set_melisma (bool);
+protected:
+ virtual bool do_try_music (Music*);
+ virtual void do_process_music();
+ virtual void acknowledge_element (Score_element_info);
+ virtual void do_pre_move_processing();
+ virtual void do_post_move_processing();
+ virtual void do_removal_processing ();
+
+public:
+ VIRTUAL_COPY_CONS(Translator);
+
+};
bool
Slur_engraver::do_try_music (Music *req_l)
{
// push a new slur onto stack.
//(use temp. array to wait for all slur STOPs)
- Slur * s_p =new Slur;
+ Slur * s_p =new Slur (SCM_EOL);
requests_arr_.push (slur_req_l);
start_slur_l_arr_.push (s_p);
Slur
*/
-Slur::Slur ()
+Slur::Slur (SCM s)
+ : Spanner (s)
{
// URG
dy_f_drul_[LEFT] = dy_f_drul_[RIGHT] = 0.0;
dx_f_drul_[LEFT] = dx_f_drul_[RIGHT] = 0.0;
- set_elt_property ("note-columns", SCM_EOL);
+ set_elt_pointer ("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_property ("note-heads")))
+ if (!gh_pair_p (n->get_elt_pointer ("note-heads")))
warning (_ ("Putting slur over rest. Ignoring."));
else
{
- Group_interface (this, "note-columns").add_element (n);
+ Pointer_group_interface (this, "note-columns").add_element (n);
add_dependency (n);
}
}
Slur::get_default_dir () const
{
Link_array<Note_column> encompass_arr =
- Group_interface__extract_elements (this, (Note_column*)0, "note-columns");
+ Pointer_group_interface__extract_elements (this, (Note_column*)0, "note-columns");
Direction d = DOWN;
for (int i=0; i < encompass_arr.size (); i ++)
Slur::do_add_processing ()
{
Link_array<Note_column> encompass_arr =
- Group_interface__extract_elements (this, (Note_column*)0, "note-columns");
+ Pointer_group_interface__extract_elements (this, (Note_column*)0, "note-columns");
if (encompass_arr.size ())
{
Slur::set_extremities ()
{
Link_array<Note_column> encompass_arr =
- Group_interface__extract_elements (this, (Note_column*)0, "note-columns");
+ Pointer_group_interface__extract_elements (this, (Note_column*)0, "note-columns");
if (!encompass_arr.size ())
{
Slur::cross_staff_count ()const
{
Link_array<Note_column> encompass_arr =
- Group_interface__extract_elements (this, (Note_column*)0, "note-columns");
+ Pointer_group_interface__extract_elements (this, (Note_column*)0, "note-columns");
int k=0;
Slur::get_encompass_offset_arr () const
{
Link_array<Note_column> encompass_arr =
- Group_interface__extract_elements (this, (Note_column*)0, "note-columns");
+ Pointer_group_interface__extract_elements (this, (Note_column*)0, "note-columns");
Array<Offset> offset_arr;
void
Spacing_engraver::do_creation_processing ()
{
- spacing_p_ =new Spacing_spanner;
+ spacing_p_ =new Spacing_spanner (SCM_EOL);
spacing_p_->set_bound (LEFT, get_staff_info ().command_pcol_l ());
announce_element (Score_element_info (spacing_p_, 0));
}
#include "line-of-score.hh"
#include "misc.hh"
-Spacing_spanner::Spacing_spanner ()
+Spacing_spanner::Spacing_spanner (SCM s)
+ : Spanner (s)
{
set_extent_callback (0, X_AXIS);
set_extent_callback (0, Y_AXIS);
protected:
virtual void acknowledge_element (Score_element_info);
virtual void do_pre_move_processing();
- virtual Span_bar* get_span_bar_p() const;
+ virtual Span_bar* get_span_bar_p(SCM) const;
};
}
Span_bar*
-Span_bar_engraver::get_span_bar_p() const
+Span_bar_engraver::get_span_bar_p(SCM s) const
{
- return new Span_bar;
+ Span_bar * sp= new Span_bar (s);
+ return sp;
}
if (bar_l_arr_.size() >= 2 && !spanbar_p_)
{
- spanbar_p_ = get_span_bar_p();
+ spanbar_p_ = get_span_bar_p( bar_l_arr_[0]->property_alist_);
spanbar_p_->set_parent (bar_l_arr_[0], Y_AXIS);
spanbar_p_->set_parent (bar_l_arr_[0], X_AXIS);
- SCM v = bar_l_arr_[0]->get_elt_property ("visibility-lambda");
- if (gh_procedure_p (v))
- spanbar_p_->set_elt_property ("visibility-lambda",v);
-
- spanbar_p_->set_parent (bar_l_arr_[0], X_AXIS);
announce_element (Score_element_info (spanbar_p_,0));
- if (!gh_string_p (spanbar_p_->get_elt_property ("glyph")))
- spanbar_p_-> set_elt_property ("glyph",
- bar_l_arr_[0]->get_elt_property ("glyph"));
}
}
}
-
void
Span_bar_engraver::do_pre_move_processing()
{
}
}
+
+Staff_bar::Staff_bar (SCM s)
+ : Bar (s)
+{
+
+}
/*
- staff-sym-reg.cc -- implement Staff_symbol_engraver
+ staff-symbol-engraver.cc -- implement Staff_symbol_engraver
source file of the GNU LilyPond music typesetter
void
Staff_symbol_engraver::do_creation_processing()
{
- span_p_ = new Staff_symbol;
+ span_p_ = new Staff_symbol (get_property ("staffSymbolBasicProperties"));
span_p_->set_bound(LEFT,get_staff_info().command_pcol_l ());
+
announce_element (Score_element_info (span_p_, 0));
}
void
Staff_symbol_engraver::acknowledge_element (Score_element_info s)
{
- s.elem_l_->set_elt_property ("staff-symbol", span_p_->self_scm_);
+ s.elem_l_->set_elt_pointer ("staff-symbol", span_p_->self_scm_);
s.elem_l_->add_dependency (span_p_); // UGH. UGH. UGH
}
Real
Staff_symbol::staff_space ()const
{
- return gh_scm2double (get_elt_property ("staff-space"));
+ return gh_scm2double (get_elt_property ("staff-space")) *
+ paper_l ()->get_var ("staffspace");
+}
+
+Staff_symbol::Staff_symbol( SCM s)
+ : Spanner (s)
+{
}
Score_element*
Stem::support_head ()const
{
- SCM h = get_elt_property ("support-head");
+ SCM h = get_elt_pointer ("support-head");
Score_element * nh = unsmob_element (h);
if (nh)
return nh;
UGH.
*/
- return unsmob_element (gh_car (get_elt_property ("heads")));
+ return unsmob_element (gh_car (get_elt_pointer ("heads")));
}
else
return first_head ();
int
Stem::heads_i ()const
{
- Group_interface gi (this, "heads");
+ Pointer_group_interface gi (this, "heads");
return gi.count ();
}
Drul_array<Note_head *> exthead;
exthead[LEFT] = exthead[RIGHT] =0;
- for (SCM s = get_elt_property ("heads"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = get_elt_pointer ("heads"); gh_pair_p (s); s = gh_cdr (s))
{
Note_head * n = dynamic_cast<Note_head*> (unsmob_element (gh_car (s)));
Staff_symbol_referencer_interface si (n);
void
Stem::add_head (Rhythmic_head *n)
{
- n->set_elt_property ("stem", this->self_scm_);
+ n->set_elt_pointer ("stem", this->self_scm_);
n->add_dependency (this);
- Group_interface gi (this);
+ Pointer_group_interface gi (this);
if (Note_head *nh = dynamic_cast<Note_head *> (n))
gi.name_ = "heads";
else
gi.add_element (n);
}
-Stem::Stem ()
+Stem::Stem (SCM s)
+ : Item (s)
{
- set_elt_property ("heads", SCM_EOL);
- set_elt_property ("rests", SCM_EOL);
+ set_elt_pointer ("heads", SCM_EOL);
+ set_elt_pointer ("rests", SCM_EOL);
add_offset_callback ( &Stem::off_callback, X_AXIS);
}
return;
Link_array<Score_element> heads =
- Group_interface__extract_elements (this, (Score_element*)0, "heads");
+ Pointer_group_interface__extract_elements (this, (Score_element*)0, "heads");
heads.sort (compare_position);
Direction dir =get_direction ();
Stem * s = dynamic_cast<Stem*> ((Score_element*)se);
Interval r (0, 0);
- if (unsmob_element (s->get_elt_property ("beam")) || abs (s->flag_i ()) <= 2)
+ if (unsmob_element (s->get_elt_pointer ("beam")) || abs (s->flag_i ()) <= 2)
; // TODO!
else
{
Beam*
Stem::beam_l ()const
{
- SCM b= get_elt_property ("beam");
+ SCM b= get_elt_pointer ("beam");
return dynamic_cast<Beam*> (unsmob_element (b));
}
}
+
+Sustain_pedal ::Sustain_pedal(SCM s )
+ : Item (s)
+{}
don't add as Axis_group_interface (delim_).add_element (),
because that would set the parent as well */
- Group_interface (delim_).add_element (inf.elem_l_);
+ Pointer_group_interface (delim_).add_element (inf.elem_l_);
}
else if (System_start_delimiter * b = dynamic_cast<System_start_delimiter *> (inf.elem_l_))
{
void
System_start_delimiter_engraver::do_creation_processing()
{
- delim_ = new System_start_delimiter;
+ delim_ = new System_start_delimiter (get_property ("basicSystemStartDelimiterProperties"));
delim_->set_bound (LEFT, get_staff_info ().command_pcol_l ());
/*
SCM collapse = get_property ("bracketCollapseHeight");
if (gh_number_p (collapse))
delim_->set_elt_property ("collapse-height", collapse);
- else
- delim_->set_elt_property ("collapse-height", gh_double2scm (1));
delim_->set_bound (RIGHT, get_staff_info ().command_pcol_l ());
typeset_element (delim_);
return mol;
}
-System_start_delimiter::System_start_delimiter ()
+System_start_delimiter::System_start_delimiter (SCM s)
+ : Spanner (s)
{
set_extent_callback (0, Y_AXIS);
- Group_interface (this).set_interface();
+ Pointer_group_interface (this).set_interface();
}
Molecule
{
SCM gl = get_elt_property ("glyph");
- if (scm_ilength (get_elt_property ("elements")) <= 1 && gl == ly_symbol2scm ("bar-line"))
+ if (scm_ilength (get_elt_pointer ("elements")) <= 1 && gl == ly_symbol2scm ("bar-line"))
{
set_elt_property ("transparent", SCM_BOOL_T);
set_extent_callback (0, X_AXIS);
{
Text_script_req * r = reqs_[i];
- Text_item *text = new Text_item;
+ Text_item *text = new Text_item (SCM_EOL);
Side_position_interface stafy (text);
SCM axisprop = get_property ("scriptHorizontal");
#include "lookup.hh"
#include "staff-symbol-referencer.hh"
+Text_item::Text_item (SCM s)
+ : Item (s)
+{
+
+}
+
Molecule
Text_item::do_brew_molecule () const
{
#include "directional-element-interface.hh"
#include "note-head.hh"
-Tie_column::Tie_column ()
+Tie_column::Tie_column (SCM s)
+ : Spanner (s)
{
- set_elt_property ("ties", SCM_EOL);
+ set_elt_pointer ("ties", SCM_EOL);
set_extent_callback (0, X_AXIS);
set_extent_callback (0, Y_AXIS);
set_elt_property ("transparent", SCM_BOOL_T);
void
Tie_column::add_tie (Tie *s)
{
- Group_interface g (this, "ties");
+ Pointer_group_interface g (this, "ties");
if (!g.count ())
{
set_bound (LEFT, s->head (LEFT));
set_bound (RIGHT, s->head (RIGHT));
}
- group (this, "ties").add_element (s);
+ Pointer_group_interface (this, "ties").add_element (s);
s->add_dependency (this);
}
Tie_column::set_directions ()
{
Link_array<Tie> s =
- Group_interface__extract_elements (this, (Tie*)0, "ties");
+ Pointer_group_interface__extract_elements (this, (Tie*)0, "ties");
Direction d = directional_element (this).get ();
SCM pair = gh_list_ref (head_list, gh_int2scm (i/2));
- Tie * p = new Tie;
+ Tie * p = new Tie (SCM_EOL);
p->set_head (LEFT, dynamic_cast<Item*> (unsmob_element (gh_car (pair))));
p->set_head (RIGHT, dynamic_cast<Item*> (unsmob_element (gh_cdr (pair))));
}
else for (SCM s = head_list; gh_pair_p (s); s = gh_cdr (s))
{
- Tie * p = new Tie;
+ Tie * p = new Tie (SCM_EOL);
p->set_head (LEFT, dynamic_cast<Item*> (unsmob_element (gh_caar (s))));
p->set_head (RIGHT, dynamic_cast<Item*> (unsmob_element (gh_cdar (s))));
}
else if (tie_p_arr_.size () > 1 && !tie_column_p_)
{
- tie_column_p_ = new Tie_column;
+ tie_column_p_ = new Tie_column (SCM_EOL);
for (int i = tie_p_arr_.size (); i--; )
tie_column_p_->add_tie (tie_p_arr_ [i]);
announce_element (Score_element_info (tie_column_p_, 0));
Tie::set_head (Direction d, Item * head_l)
{
assert (!head (d));
- index_set_cell (get_elt_property ("heads"), d, head_l->self_scm_);
+ index_set_cell (get_elt_pointer ("heads"), d, head_l->self_scm_);
set_bound (d, head_l);
add_dependency (head_l);
}
-Tie::Tie()
+Tie::Tie(SCM s)
+ : Spanner (s)
{
- set_elt_property ("heads", gh_cons (SCM_EOL, SCM_EOL));
+ set_elt_pointer ("heads", gh_cons (SCM_EOL, SCM_EOL));
dy_f_drul_[LEFT] = dy_f_drul_[RIGHT] = 0.0;
dx_f_drul_[LEFT] = dx_f_drul_[RIGHT] = 0.0;
Note_head*
Tie::head (Direction d) const
{
- SCM c = get_elt_property ("heads");
+ SCM c = get_elt_pointer ("heads");
c = index_cell (c, d);
return dynamic_cast<Note_head*> (unsmob_element (c));
new_head_drul[d] = head((Direction)-d);
} while (flip(&d) != LEFT);
- index_set_cell (get_elt_property ("heads"), LEFT, new_head_drul[LEFT]->self_scm_ );
- index_set_cell (get_elt_property ("heads"), RIGHT, new_head_drul[RIGHT]->self_scm_ );
+ index_set_cell (get_elt_pointer ("heads"), LEFT, new_head_drul[LEFT]->self_scm_ );
+ index_set_cell (get_elt_pointer ("heads"), RIGHT, new_head_drul[RIGHT]->self_scm_ );
}
void
Time_signature_change_req *req = timing_grav_l->time_signature_req_l();
if (req)
{
- time_signature_p_ = new Time_signature;
+ time_signature_p_ = new Time_signature (get_property ("basicTimeSignatureProperties"));
+
time_signature_p_->set_elt_property ("fraction",
gh_cons (gh_int2scm (req->beats_i_),
gh_int2scm (req->one_beat_i_)));
- time_signature_p_->set_elt_property ("break-align-symbol", ly_symbol2scm( "Time_signature"));
}
#include "paper-def.hh"
#include "lookup.hh"
-Time_signature::Time_signature ()
+Time_signature::Time_signature (SCM s)
+ : Item (s)
{
- set_elt_property ("breakable", SCM_BOOL_T);
+
}
// ugh.!
if (i < started_span_p_arr_.size () && started_span_p_arr_[i])
continue;
- Tuplet_spanner* glep = new Tuplet_spanner;
+ Tuplet_spanner* glep = new Tuplet_spanner (SCM_EOL);
if (i >= started_span_p_arr_.size ())
started_span_p_arr_.push (glep);
else
#include "directional-element-interface.hh"
-Tuplet_spanner::Tuplet_spanner ()
+Tuplet_spanner::Tuplet_spanner (SCM s)
+ : Spanner (s)
{
- set_elt_property ("beams", SCM_EOL);
- set_elt_property ("columns", SCM_EOL);
+ set_elt_pointer ("beams", SCM_EOL);
+ set_elt_pointer ("columns", SCM_EOL);
// ugh.
set_elt_property ("delta-y", gh_int2scm (0));
else if (bracket == ly_symbol2scm ("if-no-beam"))
number_visibility = !par_beam;
- if (gh_pair_p (get_elt_property ("columns")))
+ if (gh_pair_p (get_elt_pointer ("columns")))
{
Link_array<Note_column> column_arr=
- Group_interface__extract_elements (this, (Note_column*)0, "columns");
+ Pointer_group_interface__extract_elements (this, (Note_column*)0, "columns");
Real ncw = column_arr.top ()->extent(X_AXIS).length ();
Real w = spanner_length () + ncw;
void
Tuplet_spanner::do_add_processing ()
{
- if (gh_pair_p (get_elt_property ("columns")))
+ if (gh_pair_p (get_elt_pointer ("columns")))
{
Link_array<Note_column> column_arr=
- Group_interface__extract_elements (this, (Note_column*)0, "columns");
+ Pointer_group_interface__extract_elements (this, (Note_column*)0, "columns");
set_bound (LEFT, column_arr[0]);
set_bound (RIGHT, column_arr.top ());
Tuplet_spanner::calc_position_and_height (Real *offset, Real * dy) const
{
Link_array<Note_column> column_arr=
- Group_interface__extract_elements (this, (Note_column*)0, "columns");
+ Pointer_group_interface__extract_elements (this, (Note_column*)0, "columns");
- Score_element * common = common_refpoint (get_elt_property ("columns"), Y_AXIS);
+ Score_element * common = common_refpoint (get_elt_pointer ("columns"), Y_AXIS);
Direction d = directional_element (this).get ();
Tuplet_spanner::calc_dy (Real * dy) const
{
Link_array<Note_column> column_arr=
- Group_interface__extract_elements (this, (Note_column*)0, "columns");
+ Pointer_group_interface__extract_elements (this, (Note_column*)0, "columns");
Direction d = directional_element (this).get ();
Tuplet_spanner::after_line_breaking ()
{
Link_array<Note_column> column_arr=
- Group_interface__extract_elements (this, (Note_column*)0, "columns");
+ Pointer_group_interface__extract_elements (this, (Note_column*)0, "columns");
if (!column_arr.size ())
{
translate_axis (offset, Y_AXIS);
- if (scm_ilength (get_elt_property ("beams")) == 1)
+ if (scm_ilength (get_elt_pointer ("beams")) == 1)
{
- SCM bs = get_elt_property ("beams");
+ SCM bs = get_elt_pointer ("beams");
Score_element *b = unsmob_element (gh_car (bs));
Beam * beam_l = dynamic_cast<Beam*> (b);
if (!broken_b ()
}
d = UP ;
- for (SCM s = get_elt_property ("columns"); gh_pair_p (s); s = gh_cdr (s))
+ for (SCM s = get_elt_pointer ("columns"); gh_pair_p (s); s = gh_cdr (s))
{
Score_element * sc = unsmob_element (gh_car (s));
Note_column * nc = dynamic_cast<Note_column*> (sc);
Tuplet_spanner::add_beam (Beam *b)
{
add_dependency (b);
- Group_interface gi (this, "beams");
+ Pointer_group_interface gi (this, "beams");
gi.add_element (b);
}
void
Tuplet_spanner::add_column (Note_column*n)
{
- Group_interface gi (this, "columns");
+ Pointer_group_interface gi (this, "columns");
gi.add_element (n);
add_dependency (n);
void
Vertical_align_engraver::do_creation_processing()
{
- valign_p_ =new Spanner; //Axis_align_spanner
+ valign_p_ =new Spanner (SCM_EOL); // todo -> basic props
Align_interface (valign_p_).set_interface ();
Align_interface (valign_p_).set_axis (Y_AXIS);
valign_p_->set_elt_property ("stacking-dir",
#include "side-position-interface.hh"
#include "directional-element-interface.hh"
-Volta_spanner::Volta_spanner ()
+Volta_spanner::Volta_spanner (SCM s)
+ : Spanner (s)
{
- set_elt_property ("bars", SCM_EOL);
+ set_elt_pointer ("bars", SCM_EOL);
Side_position_interface (this).set_axis (Y_AXIS);
directional_element (this).set (UP);
}
Molecule mol;
Link_array<Bar> bar_arr
- = Group_interface__extract_elements (this, (Bar*)0, "bars");
+ = Pointer_group_interface__extract_elements (this, (Bar*)0, "bars");
if (!bar_arr.size ())
return mol;
{
Link_array<Bar> bar_arr
- = Group_interface__extract_elements (this, (Bar*)0, "bars");
+ = Pointer_group_interface__extract_elements (this, (Bar*)0, "bars");
if (bar_arr.size ())
{
void
Volta_spanner::add_bar (Bar* b)
{
- Group_interface gi(this, "bars");
+ Pointer_group_interface gi(this, "bars");
gi.add_element (b);
Side_position_interface (this).add_support (b);
projects / lilypond.git / commitdiff