{
stems_.push (info.elem_l_);
}
- else if (Rhythmic_head::has_interface (info.elem_l_)
+
+ else
+
+ /*
+ We can't catch local key items from Voice context, but let's leave
+ it here in case someone moves this stuff around. */
+ if (Rhythmic_head::has_interface (info.elem_l_)
|| Local_key_item::has_interface (info.elem_l_))
{
supports_.push (info.elem_l_);
{
arpeggio_ = new Item (get_property ("Arpeggio"));
arpeggio_->set_parent (stems_[0], Y_AXIS);
- Side_position::set_axis (arpeggio_, X_AXIS);
- Side_position::set_direction (arpeggio_, LEFT);
- Pointer_group_interface pgi (arpeggio_, "stems");
+
+ // Staff_symbol_referencer::set_interface (arpeggio_);
+
for (int i = 0; i < stems_.size (); i++)
{
- pgi.add_element (stems_[i]);
- Side_position::add_support (arpeggio_, stems_[i]);
+ Pointer_group_interface::add_element (arpeggio_, "stems", stems_[i]);
+ //Side_position::add_support (arpeggio_, stems_[i]);
}
for (int i = 0; i < supports_.size (); i++)
{
- Side_position::add_support (arpeggio_, supports_[i]);
+ ;//Side_position::add_support (arpeggio_, supports_[i]);
}
announce_element (arpeggio_, arpeggio_req_);
}
e->set_parent (me, a);
}
- Pointer_group_interface (me).add_element (e);
+ Pointer_group_interface::add_element (me, "elements", e);
me->add_dependency (e);
}
for (SCM s = elts; gh_pair_p (s); s = gh_cdr (s))
{
Score_element * se = unsmob_element (gh_car (s));
- Interval dims = se->extent (a);
+ Interval dims = se->extent (common, a);
if (!dims.empty_b ())
- r.unite (dims + se->relative_coordinate (common, a));
+ r.unite (dims);
}
return r;
}
void
Beam::add_stem (Score_element*me, Score_element*s)
{
- Pointer_group_interface gi (me, "stems");
- gi.add_element (s);
+ Pointer_group_interface:: add_element(me, "stems", s);
s->add_dependency (me);
Real beamy = (stem->relative_coordinate (0, X_AXIS) - x0) * dydx + beam_y;
Real staff_space = Staff_symbol_referencer::staff_space (rest);
- Real rest_dim = rest->extent (Y_AXIS)[d]*2.0 / staff_space ;
+
+
+ Real rest_dim = rest->extent (rest, Y_AXIS)[d]*2.0 / staff_space ; // refp??
Real minimum_dist
= gh_scm2double (rest->get_elt_property ("minimum-beam-collision-distance"));
{
Side_position::add_support (me,rh);
- Pointer_group_interface gi (me, "dots");
- gi.add_element (d);
-
+ Pointer_group_interface ::add_element (me, "dots",d);
d->add_offset_callback (Dot_column::force_shift_callback_proc , Y_AXIS);
Axis_group_interface::add_element (me, d);
}
#include "group-interface.hh"
#include "score-element.hh"
-/*
- ugh: clean me, junk elt_l_ field
- */
-Group_interface::Group_interface (Score_element * e)
-{
- elt_l_ = (Score_element*)e;
- name_ = "elements";
-}
-
-
-Group_interface::Group_interface (Score_element *e, String s)
-{
- elt_l_ =(Score_element*)e;
- name_ = s;
-}
-bool
-Group_interface::has_interface ()
-{
- 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)
+Group_interface::add_thing (Score_element*me, String name, SCM s)
{
- elt_l_->set_elt_property (name_.ch_C (),
- gh_cons (s, elt_l_->get_elt_property (name_.ch_C())));
+ me->set_elt_property (name.ch_C (),
+ gh_cons (s, me->get_elt_property (name.ch_C())));
}
int
-Group_interface::count ()
+Group_interface::count (Score_element *me, String name)
{
- return scm_ilength (elt_l_->get_elt_property (name_.ch_C()));
+ return scm_ilength (me->get_elt_property (name.ch_C()));
}
-
+void
+Pointer_group_interface::add_element (Score_element*me, String name, Score_element*p)
+{
+ Group_interface::add_thing (me, name, p->self_scm());
+}
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);
+ Pointer_group_interface::add_element (me, "items-worth-living",n);
}
struct Group_interface
{
- Score_element * elt_l_;
- String name_;
public:
- Group_interface (Score_element *);
- Group_interface (Score_element *, String);
- int count ();
- void add_thing (SCM);
- bool has_interface ();
-
+ static int count (Score_element* , String);
+ static void add_thing (Score_element*, String nm, SCM);
};
-struct Pointer_group_interface {
- Score_element * elt_l_;
- String name_;
+struct Pointer_group_interface : public Group_interface {
public:
- Pointer_group_interface (Score_element*);
- Pointer_group_interface (Score_element*, String);
- int count ();
-
- static bool has_interface (Score_element*);
- bool has_interface ();
- void add_element (Score_element*);
+ static void add_element (Score_element*, String nm, Score_element*e);
};
/**
Put all score elements of ELT's property called NAME into an array,
Line_of_score::typeset_element (Score_element * elem_p)
{
elem_p->pscore_l_ = pscore_l_;
- Pointer_group_interface (this, "all-elements").add_element (elem_p);
+ Pointer_group_interface::add_element (this, "all-elements",elem_p);
scm_unprotect_object (elem_p->self_scm ());
}
ly_symbol2scm ("after-line-breaking-callback"));
}
- Interval i(extent(Y_AXIS));
+ Interval i(extent(this, Y_AXIS));
if (i.empty_b())
programming_error ("Huh? Empty Line_of_score?");
else
{
Item * col = sp->get_bound (d)->column_l ();
- Interval coldim = col->extent (X_AXIS)
- + col->relative_coordinate (0, X_AXIS);
+ Interval coldim = col->extent (0, X_AXIS);
sp_iv[d] = coldim[-d] ;
}
void
Multi_measure_rest::add_column (Score_element*me,Item* c)
{
- Pointer_group_interface gi (me, "columns");
- gi.add_element (c);
+ Pointer_group_interface::add_element (me, "columns",c);
add_bound_item (dynamic_cast<Spanner*> (me),c);
}
/*
should do something more advanced.
*/
- rod.distance_f_ = l->extent (X_AXIS)[BIGGER] - r->extent (X_AXIS)[SMALLER]
+ rod.distance_f_ = l->extent (l, X_AXIS)[BIGGER] - r->extent (r, X_AXIS)[SMALLER]
+ gh_scm2double (me->get_elt_property ("minimum-width")) * staff_space;
rod.add_to_cols ();
}
else if (Note_head::has_interface (h))
{
- Pointer_group_interface gi (me, "note-heads");
- gi.add_element (h);
+ Pointer_group_interface::add_element (me, "note-heads",h);
}
Axis_group_interface::add_element (me, h);
}
Note_column::rest_dim (Score_element*me)
{
Score_element * r = unsmob_element (me->get_elt_property ("rest"));
- return r->extent (Y_AXIS);
+ return r->extent (r, Y_AXIS); // ??
}
Score_element*
#include "group-interface.hh"
#include "score-element.hh"
-/*
- UGH clean me .
- */
-Pointer_group_interface::Pointer_group_interface (Score_element * e)
-{
- elt_l_ = e;
- name_ = "elements";
-}
-
-
-Pointer_group_interface::Pointer_group_interface (Score_element *e, String s)
-{
- elt_l_ =(Score_element*)e;
- name_ = s;
-}
-
-/*
- duh.
- */
-bool
-Pointer_group_interface::has_interface ()
-{
- 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_property (name_.ch_C(),
- gh_cons (p->self_scm (),
- elt_l_->get_elt_property (name_.ch_C())));
-}
-int
-Pointer_group_interface::count ()
-{
- return scm_ilength (elt_l_->get_elt_property (name_.ch_C()));
-}
Rest_collision::add_column (Score_element*me,Score_element *p)
{
me->add_dependency (p);
- Pointer_group_interface gi (me);
- gi.add_element (p);
+ Pointer_group_interface::add_element (me, "elements", p);
p->add_offset_callback (Rest_collision::force_shift_callback_proc, Y_AXIS);
p->set_elt_property ("rest-collision", me->self_scm ());
Interval notedim;
for (int i = 0; i < notes.size(); i++)
{
- notedim.unite (notes[i]->extent (Y_AXIS));
+ notedim.unite (notes[i]->extent (notes[i],Y_AXIS)); // refp?
}
Interval inter (notedim);
/*
fixme: default should be no callback.
*/
- set_extent_callback (molecule_extent_proc, X_AXIS);
- set_extent_callback (molecule_extent_proc, Y_AXIS) ;
pscore_l_=0;
lookup_l_ =0;
smobify_self ();
- dim_cache_[X_AXIS].offset_callbacks_
- = get_elt_property ("X-offset-callbacks");
- dim_cache_[Y_AXIS].offset_callbacks_
- = get_elt_property ("Y-offset-callbacks");
-
- dim_cache_[X_AXIS].offsets_left_ = scm_ilength (dim_cache_[X_AXIS].offset_callbacks_);
- dim_cache_[Y_AXIS].offsets_left_ = scm_ilength (dim_cache_[Y_AXIS].offset_callbacks_);
-
- SCM cb = get_elt_property ("X-extent-callback");
- if (cb != SCM_EOL)
- dim_cache_[X_AXIS].dimension_ = cb;
-
- cb = get_elt_property ("Y-extent-callback");
- if (cb != SCM_EOL)
- dim_cache_[Y_AXIS].dimension_ = cb;
+ char const*onames[] = {"X-offset-callbacks", "Y-offset-callbacks"};
+ char const*enames[] = {"X-extent-callback", "Y-extent-callback"};
+
+ for (int a = X_AXIS; a <= Y_AXIS; a++){
+ SCM l = get_elt_property (onames[a]);
+
+ if (scm_ilength (l) >=0)
+ {
+ dim_cache_[a].offset_callbacks_ = l;
+ dim_cache_[a].offsets_left_ = scm_ilength (l);
+ }
+ else
+ {
+ programming_error ("[XY]-offset-callbacks must be a list");
+ }
+
+ SCM cb = get_elt_property (enames[a]);
+
+ /*
+ Should change default to be empty?
+ */
+ if (!gh_procedure_p (cb) && !gh_pair_p (cb))
+ cb = molecule_extent_proc;
+
+ dim_cache_[a].dimension_ = cb;
+ }
}
{
if (e)
{
- Pointer_group_interface gi (this, "dependencies");
- gi.add_element (e);
+ Pointer_group_interface ::add_element (this, "dependencies",e);
+
}
else
programming_error ("Null dependency added");
gh_procedure_p (dim_cache_[a].dimension_ ));
}
+/*
+ TODO: add
+
+ Score_element *refpoint
+
+ to arguments?
+ */
Interval
-Score_element::extent (Axis a) const
+Score_element::extent (Score_element * refp, Axis a) const
{
+ Real x = relative_coordinate (refp, a);
+
+
Dimension_cache * d = (Dimension_cache *)&dim_cache_[a];
Interval ext ;
if (gh_pair_p (d->dimension_))
ext.unite (Interval (s * gh_scm2double (gh_car (extra)),
s * gh_scm2double (gh_cdr (extra))));
}
+
+ ext.translate (x);
return ext;
}
if (!gh_number_p (p))
return;
- Pointer_group_interface gi (me, "scripts");
- gi.add_element (i);
+ Pointer_group_interface::add_element (me, "scripts",i);
me->add_dependency (i);
}
void
Separating_group_spanner::add_spacing_unit (Score_element* me ,Item*i)
{
- Pointer_group_interface (me, "elements").add_element (i);
+ Pointer_group_interface::add_element (me, "elements",i);
me->add_dependency (i);
}
Separation_item::add_item (Score_element*s,Item* i)
{
assert (i);
- Pointer_group_interface (s).add_element (i);
+ Pointer_group_interface::add_element (s,"elements",i);
s->add_dependency (i);
}
continue;
}
- Interval iv (il->extent (X_AXIS));
+ Interval iv (il->extent (pc, X_AXIS));
if (!iv.empty_b ())
{
- Real off = il->relative_coordinate (pc, X_AXIS);
- w.unite (iv + off);
+ w.unite (iv);
}
}
void
Side_position::add_support (Score_element*me, Score_element*e)
{
- Pointer_group_interface (me, "side-support-elements").add_element (e);
+ Pointer_group_interface::add_element (me, "side-support-elements",e);
}
Score_element * e = unsmob_element ( gh_car (s));
if (e)
{
- Real coord = e->relative_coordinate (common, a);
-
- dim.unite (coord + e->extent (a));
+ dim.unite (e->extent (common, a));
}
}
SCM align (me->get_elt_property (s.ch_C()));
if (gh_number_p (align))
{
- Interval ext(me->extent (a));
+ Interval ext(me->extent (me,a));
if (ext.empty_b ())
{
Direction d = Side_position::get_direction (me);
Real o = gh_scm2double (side_position (element_smob,axis));
- Interval iv = me->extent (a);
+ Interval iv = me->extent (me, a);
if (!iv.empty_b ())
{
Axis a = (Axis) gh_scm2int (axis);
Score_element *him = me->parent_l (a);
- return gh_double2scm (him->extent (a).center ());
+ return gh_double2scm (him->extent (him,a).center ());
}
warning (_ ("Putting slur over rest. Ignoring."));
else
{
- Pointer_group_interface (me, "note-columns").add_element (n);
+ Pointer_group_interface::add_element (me, "note-columns",n);
me->add_dependency (n);
}
/*
Default position is centered in X, on outer side of head Y
*/
- o += Offset (0.5 * n->extent (X_AXIS).length (),
+ o += Offset (0.5 * n->extent (n,X_AXIS).length (),
0.5 * ss * Directional_element_interface::get (me));
}
else if (str == "alongside-stem")
/*
Default position is on stem X, on outer side of head Y
*/
- o += Offset (n->extent (X_AXIS).length ()
+ o += Offset (n->extent (n,X_AXIS).length ()
* (1 + Stem::get_direction (stem)),
0.5 * ss * Directional_element_interface::get (me));
}
Default position is on stem X, at stem end Y
*/
o += Offset (0.5 *
- (n->extent (X_AXIS).length ()
- - stem->extent (X_AXIS).length ())
+ (n->extent (n,X_AXIS).length ()
+ - stem->extent (stem,X_AXIS).length ())
* (1 + Stem::get_direction (stem)),
0);
}
Simply set x to middle of notehead
*/
- o[X_AXIS] -= 0.5 * stem_dir * col->extent (X_AXIS).length ();
+ o[X_AXIS] -= 0.5 * stem_dir * col->extent (col,X_AXIS).length ();
if ((stem_dir == dir)
- && !stem_l->extent (Y_AXIS).empty_b ())
+ && !stem_l->extent (stem_l, Y_AXIS).empty_b ())
{
- o[Y_AXIS] = stem_l->relative_coordinate (common[Y_AXIS], Y_AXIS); // iuhg
- o[Y_AXIS] += stem_l->extent (Y_AXIS)[dir];
+ o[Y_AXIS] = stem_l->extent (common[Y_AXIS], Y_AXIS)[dir];
}
else
{
- o[Y_AXIS] = col->relative_coordinate (common[Y_AXIS], Y_AXIS); // ugh
- o[Y_AXIS] += col->extent (Y_AXIS)[dir];
+ o[Y_AXIS] = col->extent (common[Y_AXIS], Y_AXIS)[dir];
}
/*
gh_scm2double (me->get_elt_property ("thickness"));
Bezier one = get_curve (me);
+ // get_curve may suicide
+ if (!scm_ilength (me->get_elt_property ("note-columns")))
+ return SCM_EOL;
+
Molecule a;
SCM d = me->get_elt_property ("dashed");
if (gh_number_p (d))
All these null control-points, where do they all come from?
*/
if (i && b.control_[i][X_AXIS] == 0)
- me->suicide ();
+ {
+ me->suicide ();
+ return;
+ }
}
me->set_elt_property ("control-points", controls);
int i = 0;
if (!Directional_element_interface::get (me)
- || ! gh_symbol_p (index_cell (me->get_elt_property ("attachment"), LEFT)))
+ || ! gh_symbol_p (index_cell (me->get_elt_property ("attachment"), LEFT))
+ || ! gh_symbol_p (index_cell (me->get_elt_property ("attachment"), RIGHT)))
set_extremities (me);
if (!gh_pair_p (me->get_elt_property ("control-points")))
set_control_points (me);
+ // set_control_points may suicide
+ if (!scm_ilength (me->get_elt_property ("note-columns")))
+ return b;
+
for (SCM s= me->get_elt_property ("control-points"); s != SCM_EOL; s = gh_cdr (s))
{
b.control_[i] = ly_scm2offset (gh_car (s));
void
Span_bar::add_bar (Score_element*me, Score_element*b)
{
- Pointer_group_interface gi (me);
- gi.add_element (b);
+ Pointer_group_interface::add_element (me,"elements", b);
me->add_dependency (b);
}
*/
if (dynamic_cast<Paper_column*> (i))
{
- Pointer_group_interface (i, "bounded-by-me").add_element (this);
+ Pointer_group_interface::add_element (i, "bounded-by-me",this);
}
}
But that doesn't make a difference, since the Paper_column
is likely to contain only a Break_align_item.
*/
- return sc->extent (X_AXIS)[RIGHT];
+ return sc->extent (sc, X_AXIS)[RIGHT];
}
return 0.0;
int
Stem::heads_i (Score_element*me)
{
- Pointer_group_interface gi (me, "heads");
- return gi.count ();
+ return Pointer_group_interface::count (me, "heads");
}
/*
if (Note_head::has_interface (n))
{
- Pointer_group_interface (me, "heads").add_element (n);
+ Pointer_group_interface::add_element (me, "heads",n);
}
else
{
heads.reverse ();
- Real w = support_head (me)->extent (X_AXIS)[dir];
+ Score_element *hed = support_head (me);
+ Real w = hed->extent (hed, X_AXIS)[dir];
for (int i=0; i < heads.size (); i++)
{
- heads[i]->translate_axis (w - heads[i]->extent (X_AXIS)[dir], X_AXIS);
+ heads[i]->translate_axis (w - heads[i]->extent (heads[i], X_AXIS)[dir], X_AXIS);
}
bool parity= true; // todo: make me settable.
{
if (parity)
{
- Real l = heads[i]->extent (X_AXIS).length ();
+ Real l = heads[i]->extent (heads[i], X_AXIS).length ();
heads[i]->translate_axis (l * get_direction (me), X_AXIS);
}
parity = !parity;
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)
+ if (scm_sloppy_memq (scmdir, dirlist) == SCM_BOOL_F)
{
dirlist = gh_cons (scmdir, dirlist);
col->set_elt_property ("dir-list", dirlist);
Real dy = Staff_symbol_referencer::staff_space (me)/2.0;
Real head_wid = 0;
- if (support_head (me))
- head_wid = support_head (me)->extent (X_AXIS).length ();
+
+ if (Score_element *hed = support_head (me))
+ head_wid = hed->extent (hed,X_AXIS).length ();
stem_y[Direction(-d)] += d * head_wid * tan(ANGLE)/(2*dy);
if (!invisible_b (me))
MAKE_SCHEME_CALLBACK(Stem,off_callback,2);
SCM
-Stem::off_callback (SCM element_smob, SCM axis)
+Stem::off_callback (SCM element_smob, SCM )
{
Score_element *me = unsmob_element (element_smob);
-
+
Real r=0;
if (Score_element * f = first_head (me))
{
- Interval head_wid(0, f->extent (X_AXIS).length ());
+ Interval head_wid(0, f->extent (f,X_AXIS).length ());
if (to_boolean (me->get_elt_property ("stem-centered")))
return gh_double2scm ( head_wid.center ());
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_);
+ Pointer_group_interface::add_element (delim_, "elements", inf.elem_l_);
}
else if (System_start_delimiter::has_interface (inf.elem_l_))
{
void
Tie_column::add_tie (Score_element*me,Score_element *s)
{
- Pointer_group_interface g (me, "ties");
- if (!g.count ())
+
+ if (! Pointer_group_interface ::count (me, "ties"))
{
dynamic_cast<Spanner*> (me)->set_bound (LEFT, Tie::head (s,LEFT));
dynamic_cast<Spanner*> (me)->set_bound (RIGHT, Tie::head (s,RIGHT));
}
- Pointer_group_interface (me, "ties").add_element (s);
+ Pointer_group_interface::add_element (me, "ties",s);
s->add_dependency (me);
}
Link_array<Score_element> column_arr=
Pointer_group_interface__extract_elements (me, (Score_element*)0, "columns");
- Real ncw = column_arr.top ()->extent(X_AXIS).length ();
+ Real ncw = column_arr.top ()->extent(column_arr.top (), X_AXIS).length ();
Real w = dynamic_cast<Spanner*>(me)->spanner_length () + ncw;
Real staff_space = me->paper_l ()->get_var ("staffspace");
if (l < r)
{
- *dy = column_arr[r]->extent (Y_AXIS) [d] + column_arr[r]->relative_coordinate (commony, Y_AXIS)
- - column_arr[l]->extent (Y_AXIS) [d] - column_arr[l]->relative_coordinate (commony, Y_AXIS);
+ *dy = column_arr[r]->extent (commony, Y_AXIS) [d]
+ - column_arr[l]->extent (commony, Y_AXIS) [d] ;
}
else
* dy = 0;
for (int i = 0; i < column_arr.size (); i++)
{
- Real notey = column_arr[i]->extent (Y_AXIS)[d]
- + column_arr[i]->relative_coordinate (commony, Y_AXIS)
+ Real notey = column_arr[i]->extent (commony, Y_AXIS)[d]
- me->relative_coordinate (commony, Y_AXIS);
Real x = column_arr[i]->relative_coordinate (commonx, X_AXIS) - x0;
{
Link_array<Score_element> column_arr=
Pointer_group_interface__extract_elements (me, (Score_element*)0, "columns");
-
+
+ /*
+ ugh. refps.
+ */
Direction d = Directional_element_interface::get (me);
- *dy = column_arr.top ()->extent (Y_AXIS) [d]
- - column_arr[0]->extent (Y_AXIS) [d];
+ *dy = column_arr.top ()->extent (column_arr.top (), Y_AXIS) [d]
+ - column_arr[0]->extent (column_arr[0], Y_AXIS) [d];
}
MAKE_SCHEME_CALLBACK(Tuplet_spanner,after_line_breaking,1);
Tuplet_spanner::add_beam (Score_element*me, Score_element *b)
{
me->add_dependency (b);
- Pointer_group_interface gi (me, "beams");
- gi.add_element (b);
+ Pointer_group_interface::add_element (me, "beams",b);
}
void
Tuplet_spanner::add_column (Score_element*me, Item*n)
{
- Pointer_group_interface gi (me, "columns");
- gi.add_element (n);
+ Pointer_group_interface::add_element (me, "columns",n);
me->add_dependency (n);
add_bound_item (dynamic_cast<Spanner*> (me), n);
void
Volta_spanner::add_bar (Score_element *me, Item* b)
{
- Pointer_group_interface gi(me, "bars");
- gi.add_element (b);
-
+ Pointer_group_interface::add_element(me, "bars",b);
Side_position::add_support (me,b);
add_bound_item (dynamic_cast<Spanner*>(me), b);
}
projects / lilypond.git / commitdiff