+pl 8.hwn2
+ - staff-support for Crescendi.
+ - padding for accidentals.
+ - cascading offset callbacks
+
+pl 8.hwn1
+ - note-head-side
+ - naming Staff_sidify -> Side_position_interface
+
+
+
+***********
pl7.mb1
- bf: timeSignatureStyle works again
has the development pages.
@end itemize
-@ignore
-@unnumberedsec NEWS
-
-
-This is what the latest version brings:
-@example
-
-top_of_NEWS
-
-@end example
-@end ignore
@unnumberedsec Download
@item Debian binary @uref{ftp://ftp.debian.org/pub/debian/dists/unstable/main/binary-i386/tex}
@item Windows NT: @uref{http://home.austin.rr.com/jbr/jeff/lilypond/}
@item i386 RPM: @uref{http://linux.umbc.edu/software/lilypond/rpms/}
-@item i386 RPM: @uref{ftp://ftp.freshmeat.net/pub/rpms/lilypond/}
@item Windows NT: @uref{http://home.austin.rr.com/jbr/jeff/lilypond/}
@end itemize
Grep -i for TODO, FIXME and ugh/ugr/urg.
.* TODO
-. * agressive type-checking for SCM stuff.
+. * use hash tabs iso. alist_ for elt property?
+. * agressive type-checking for SCM stuff.
+
. * TODO^2:
-. *make a TODO.texi, like http://www.gnu.org/software/guile/ideas.html
+. * make a TODO.texi, like http://www.gnu.org/software/guile/ideas.html
. * make this file understandable for 3rd parties.
. * \accepts -> \acceptedby
. * context in embedded SCM errors.
John
. * fix #'margin-shape; setting indent to 0 with \shape fails
. * Fixed size staff/system heights;
-. *
. * ly2dvi : don't repeat opus if same.
. * hara kiri _8 clef.
. * junk -M ?
. * account for rhythmic position in measure
. * etc.
-. * Output class, handles : (smallish)
-. * help text /(c) notice?
-. * version line
-. * warning /errors/progress
-. * abort on error/warning; exit status
-. * quiet/ignore-version options
-. * logfile output
+
+. * logfile output?
. * PS
. * speed up PS code.
basic_offset_ = d.basic_offset_;
extra_offset_ = d.extra_offset_;
off_valid_b_ = d.off_valid_b_;
- off_callback_l_ = d.off_callback_l_;
+ off_callbacks_ = d.off_callbacks_;
}
Dimension_cache::Dimension_cache ()
valid_b_ = false;
empty_b_ = false;
off_valid_b_ = false;
- off_callback_l_ =0;
}
*/
- basic_offset_ = x;
+ extra_offset_ = x;
}
void
Dimension_cache::translate (Real x)
{
- basic_offset_ += x;
+ extra_offset_ += x;
}
Real
Real
Dimension_cache::get_offset () const
{
- if (!off_valid_b_ && off_callback_l_ )
+ if (!off_valid_b_)
{
Dimension_cache *d = (Dimension_cache*) this;
+
+ d->basic_offset_ =0.0;
d->off_valid_b_ = true;
- d->basic_offset_ = (*off_callback_l_) (d);
+ for (int i=0; i < off_callbacks_.size (); i++)
+ d->basic_offset_ += (*off_callbacks_[i]) (d);
}
return basic_offset_ + extra_offset_;
callback_l_ =c;
}
-void
-Dimension_cache::set_offset_callback (Offset_cache_callback c)
-{
- off_callback_l_ =c;
-}
+
text_p_->set_elt_property ("style", gh_str02scm ("dynamic"));
text_p_->set_elt_property ("script-priority",
gh_int2scm (100));
- Staff_sidify (text_p_).set_axis (Y_AXIS);
+ text_p_->set_elt_property ("staff-support", SCM_BOOL_T);
+
+ Side_position_interface (text_p_).set_axis (Y_AXIS);
if (absd->get_direction ())
if (isdir_b (prop) && to_dir (prop))
text_p_->set_elt_property ("direction", prop);
-
prop = get_property ("dynamicPadding", 0);
if (gh_number_p(prop))
{
assert (!new_cresc_p);
new_cresc_p = new Crescendo;
new_cresc_p->grow_dir_ = (span_l->span_type_str_ == "crescendo") ? BIGGER : SMALLER;
+ new_cresc_p->set_elt_property ("staff-support", SCM_BOOL_T);
+
- Staff_sidify (new_cresc_p).set_axis (Y_AXIS);
+ Side_position_interface (new_cresc_p).set_axis (Y_AXIS);
announce_element (Score_element_info (new_cresc_p, span_l));
}
}
if (cresc_p_)
{
::warning (_ ("Too many crescendi here"));
+
+
typeset_element (cresc_p_);
cresc_p_ = 0;
if (to_end_cresc_p_)
{
to_end_cresc_p_->set_bounds(RIGHT,get_staff_info().musical_pcol_l ());
-
typeset_element (to_end_cresc_p_);
to_end_cresc_p_ =0;
)
{
if (text_p_)
- Staff_sidify (text_p_).add_support (i.elem_l_);
+ Side_position_interface (text_p_).add_support (i.elem_l_);
if (to_end_cresc_p_)
- Staff_sidify (to_end_cresc_p_).add_support (i.elem_l_);
+ Side_position_interface (to_end_cresc_p_).add_support (i.elem_l_);
if (cresc_p_)
- Staff_sidify(cresc_p_).add_support (i.elem_l_);
+ Side_position_interface(cresc_p_).add_support (i.elem_l_);
}
}
translate_axis (-0.5* nhw, X_AXIS); // ugh.
}
-void
-Grace_align_item::do_substitute_element_pointer (Score_element*o, Score_element*n)
-{
- Axis_align_item::do_substitute_element_pointer (o,n);
- Note_head_side::do_substitute_element_pointer( o,n);
-}
+
void
Grace_align_item::do_add_processing ()
{
void init ();
public:
- Offset_cache_callback off_callback_l_;
+ Array<Offset_cache_callback> off_callbacks_;
Axis axis () const;
Real get_offset () const;
Grace_align_item ();
protected:
virtual void do_add_processing ();
- virtual void do_substitute_element_pointer (Score_element*,Score_element*);
virtual void do_pre_processing ();
};
#endif /* GRACE_ALIGN_ITEM_HH */
class Local_key_item : public Note_head_side, public Staff_symbol_referencer {
Array<Local_key_cautionary_tuple> accidental_arr_;
- Molecule accidental (int,bool) const;
+ Molecule accidental (int,bool,bool) const;
public:
int c0_position_i_;
Local_key_item ();
void add_pitch (Musical_pitch, bool cautionary, bool natural);
protected:
virtual void do_pre_processing();
- virtual void do_substitute_element_pointer (Score_element*,Score_element*);
virtual Molecule* do_brew_molecule_p() const;
};
#endif // LOCALKEYITEM_HH
#funcptr# is the function to call to update this element.
*/
void calculate_dependencies (int final, int busy, Score_element_method_pointer funcptr);
- static SCM handle_broken_smobs (SCM, Line_of_score*);
+
+ static SCM handle_broken_smobs (SCM, SCM criterion);
virtual Score_element *find_broken_piece (Line_of_score*) const;
protected:
*/
-#ifndef STAFF_SYM_GRAV_HH
-#define STAFF_SYM_GRAV_HH
+#ifndef STAFF_SYMBOL_GRAV_HH
+#define STAFF_SYMBOL_GRAV_HH
#include "engraver.hh"
#include "moment.hh"
virtual void do_creation_processing();
};
-#endif // STAFF_SYM_GRAV_HH
+#endif // STAFF_SYMBOL_GRAV_HH
/*
- staff-sym-referencer.hh -- declare Staff_sym_referencer
+ staff-sym-referencer.hh -- declare staff_symbol_referencer
source file of the GNU LilyPond music typesetter
*/
-#ifndef STAFF_SYM_REFERENCER_HH
-#define STAFF_SYM_REFERENCER_HH
+#ifndef STAFF_SYMBOL_REFERENCER_HH
+#define STAFF_SYMBOL_REFERENCER_HH
#include "score-element.hh"
*/
class Staff_symbol_referencer : public virtual Score_element
{
- int position_i_;
+ Real position_f_;
+
protected:
- Staff_symbol * staff_sym_l_;
+ Staff_symbol * staff_symbol_l_;
public:
Staff_symbol_referencer ();
- void set_position (int);
+ void set_position (Real);
void set_staff_symbol (Staff_symbol*);
/**
virtual void do_substitute_element_pointer (Score_element*,Score_element*);
virtual void do_pre_processing ();
virtual Real position_f () const;
+
};
-#endif /* STAFF_SYM_REFERENCER_HH */
+#endif /* STAFF_SYMBOL_REFERENCER_HH */
}
Molecule
-Local_key_item::accidental (int j, bool cautionary) const
+Local_key_item::accidental (int j, bool cautionary, bool natural) const
{
Molecule m (lookup_l ()->afm_find (String ("accidentals-") + to_str (j)));
+ if (natural)
+ {
+ Molecule prefix = lookup_l ()->afm_find (String ("accidentals-0"));
+ m.add_at_edge(X_AXIS, LEFT, Molecule(prefix), 0);
+ }
if (cautionary)
{
Molecule open = lookup_l ()->afm_find (String ("accidentals-("));
(c0_position_i_ + p.notename_i_)
* note_distance;
- Molecule m (accidental (p.accidental_i_, accidental_arr_[i].cautionary_b_));
+ Molecule m (accidental (p.accidental_i_,
+ accidental_arr_[i].cautionary_b_,
+ accidental_arr_[i].natural_b_));
m.translate_axis (dy, Y_AXIS);
octave_mol_p->add_at_edge (X_AXIS, RIGHT, m, 0);
if (accidental_arr_.size())
{
- Box b(Interval (0, 0.6 * note_distance), Interval (0,0));
- Molecule m (lookup_l ()->fill (b));
- output->add_at_edge (X_AXIS, RIGHT, m, 0);
+ Drul_array<SCM> pads;
+
+ /*
+ Use a cons?
+ */
+ pads[RIGHT] = get_elt_property ("right-padding");
+ pads[LEFT] = get_elt_property ("left-padding");
+
+ Direction d = LEFT;
+ do {
+ if (!gh_number_p (pads[d]))
+ continue;
+
+ Box b(Interval (0, gh_scm2double (pads[d]) * note_distance),
+ Interval (0,0));
+ Molecule m (lookup_l ()->fill (b));
+ output->add_at_edge (X_AXIS, d, m, 0);
+ } while ( flip (&d)!= LEFT);
}
return output;
}
-void
-Local_key_item::do_substitute_element_pointer (Score_element *o, Score_element*n)
-{
- Note_head_side::do_substitute_element_pointer (o,n);
- Staff_symbol_referencer::do_substitute_element_pointer (o,n);
-
-}
Lookup::staff_brace (Real y, int staff_size) const
{
Molecule m;
- /*
- (define (pianobrace y staffht)
- (let* ((step 1.0)
- (minht (* 2 staffht))
- (maxht (* 7 minht))
- )
- (string-append
- (select-font (string-append "feta-braces" (number->string (inexact->exact staffht))) 0)
- (char (max 0 (/ (- (min y (- maxht step)) minht) step))))
- )
- )
- */
Real step = 1.0;
int minht = 2 * staff_size;
*/
+#include "staff-side.hh"
#include "note-head-side.hh"
-
void
Note_head_side::add_support (Item*head_l)
{
- if (support_l_arr_.find_l(head_l))
- return ;
- support_l_arr_.push (head_l);
- add_dependency (head_l);
+ Side_position_interface s (this);
+ s.add_support (head_l);
}
-void
-Note_head_side::do_pre_processing ()
-{
- Interval x_int;
- for (int i=0; i < support_l_arr_.size(); i++)
- {
- Graphical_element *common =
- common_refpoint (support_l_arr_[i], X_AXIS);
- Real x = support_l_arr_[i]->relative_coordinate (common, X_AXIS)
- - relative_coordinate (common, X_AXIS);
-
- x_int.unite (x + support_l_arr_[i]->extent (X_AXIS));
- }
-
- if (x_int.empty_b ())
- x_int = Interval(0,0);
-
- translate_axis (-extent(X_AXIS)[-notehead_align_dir_] + x_int[notehead_align_dir_], X_AXIS);
-}
-void
-Note_head_side::do_substitute_element_pointer (Score_element*o,Score_element*n)
+Note_head_side::Note_head_side()
{
- if (Item* o_l = dynamic_cast <Item *> (o))
- support_l_arr_.substitute (o_l,dynamic_cast <Item *> (n));
+ Side_position_interface s(this);
+ s.set_axis (X_AXIS);
+ s.set_direction (LEFT);
}
-Note_head_side:: Note_head_side()
-{
- notehead_align_dir_ = LEFT;
-}
bool
Note_head_side::supported_b ()const
{
- return support_l_arr_.size ();
+ Side_position_interface s(this);
+ return s.supported_b ();
}
#include "misc.hh"
#include "paper-outputter.hh"
#include "dimension-cache.hh"
-
+#include "staff-side.hh"
Interval
Score_element::dim_cache_callback (Dimension_cache const*c)
}
-
-Real
-set_alignment_callback (Dimension_cache const *c)
-{
- String s ("self-alignment-");
- Axis ax = c->axis ();
- s += (ax == X_AXIS) ? "X" : "Y";
- Score_element *elm = dynamic_cast<Score_element*> (c->element_l ());
- SCM align (elm->get_elt_property (s));
- if (isdir_b (align))
- {
- Direction d = to_dir (align);
- Interval ext(elm->extent (ax));
- if (d)
- {
- return - ext[d];
- }
- return - ext.center ();
- }
- else
- return 0.0;
-}
-
-
Score_element::Score_element()
{
output_p_ =0;
self_scm_ = SCM_EOL;
used_b_ = true;
original_l_ =(Score_element*) &s;
+
+ /*
+ should protect because smobify_self () might trigger GC.
+ */
element_property_alist_ = scm_protect_object (scm_list_copy (s.element_property_alist_));
dependency_arr_ = s.dependency_arr_;
output_p_ =0;
return;
status_i_ ++;
- if (get_elt_property ("self-alignment-X") != SCM_UNDEFINED)
+#if 0
+ /*
+ UGH. UGH. UGH.
+ */
+ if (get_elt_property ("self-alignment-X") != SCM_UNDEFINED
+ && !dim_cache_[X_AXIS]->off_callback_l_)
{
- dim_cache_[X_AXIS]->set_offset_callback (set_alignment_callback);
+ dim_cache_[X_AXIS]->off_callbacks_.push (Side_position_interface::self_alignment);
}
- if (get_elt_property ("self-alignment-Y") != SCM_UNDEFINED)
+ if (get_elt_property ("self-alignment-Y") != SCM_UNDEFINED
+ && !dim_cache_[X_AXIS]->off_callback_l_)
+
{
- dim_cache_[Y_AXIS]->set_offset_callback (set_alignment_callback);
+ dim_cache_[Y_AXIS]->set_offset_callback (Side_position_interface::self_alignment);
}
+#endif
do_add_processing();
}
for (int i=0; i < extra.size(); i++)
extra[i]->calculate_dependencies (final, busy, funcptr);
- invalidate_cache (X_AXIS);
- invalidate_cache (Y_AXIS);
(this->*funcptr)();
status_i_= final;
}
/**
- Do break substitution, and return new value.
- */
-SCM
-Score_element::handle_broken_smobs (SCM s, Line_of_score * line)
+ Do break substitution in S, using CRITERION. Return new value.
+ CRITERION is either a SMOB pointer to the desired line, or a number
+ representing the break direction. */
+SCM
+Score_element::handle_broken_smobs (SCM s, SCM criterion)
{
if (SMOB_IS_TYPE_B (Score_element, s))
{
Score_element *sc = SMOB_TO_TYPE (Score_element, s);
- Score_element * br =0;
- if (sc->line_l () != line)
+
+ if (gh_number_p (criterion))
{
- br = sc->find_broken_piece (line);
+ Item * i = dynamic_cast<Item*> (sc);
+ Direction d = to_dir (criterion);
+ if (i && i->break_status_dir () != d)
+ {
+ Item *br = i->find_broken_piece (d);
+ return (br) ? br->self_scm_ : SCM_UNDEFINED;
+ }
}
+ else
+ {
+ Score_element * ln = SMOB_TO_TYPE (Score_element, criterion);
+ Line_of_score * line = dynamic_cast<Line_of_score*> (ln);
+ Score_element * br =0;
+ if (sc->line_l () != line)
+ {
+ br = sc->find_broken_piece (line);
+ return (br) ? br->self_scm_ : SCM_UNDEFINED;
+ }
- if (br)
- return br->self_scm_;
+ }
}
else if (gh_pair_p (s))
{
/*
UGH! breaks on circular lists.
- */
- gh_set_car_x (s, handle_broken_smobs (gh_car (s), line));
- gh_set_cdr_x (s, handle_broken_smobs (gh_cdr (s), line));
+ */
+ gh_set_car_x (s, handle_broken_smobs (gh_car (s), criterion));
+ gh_set_cdr_x (s, handle_broken_smobs (gh_cdr (s), criterion));
}
return s;
}
if (!line)
return;
- element_property_alist_ = handle_broken_smobs (element_property_alist_, line);
+ element_property_alist_ = handle_broken_smobs (element_property_alist_,
+ line->self_scm_);
Link_array<Score_element> new_deps;
void
Score_element::handle_prebroken_dependencies()
{
- element_property_alist_
- = handle_broken_smobs (element_property_alist_, line_l ());
+ if (Item*i =dynamic_cast<Item*> (this))
+ {
+ element_property_alist_
+ = handle_broken_smobs (element_property_alist_,
+ gh_int2scm (i->break_status_dir ()));
+ }
Link_array<Score_element> old_arr, new_arr;
continue;
}
Script *p =new Script;
- Staff_sidify stafy (p);
+ Side_position_interface stafy (p);
list = gh_cdr (list);
p->set_elt_property ("molecule",
stafy.set_direction (l->get_direction ());
SCM axisprop = get_property ("scriptHorizontal",0);
- if (gh_boolean_p (axisprop) && gh_scm2bool (axisprop))
+ bool xaxis = gh_boolean_p (axisprop) && gh_scm2bool (axisprop);
+ if (xaxis)
stafy.set_axis (X_AXIS);
else
stafy.set_axis (Y_AXIS);
- if (follow_staff && !gh_boolean_p (axisprop) && gh_scm2bool (axisprop))
- p->set_elt_property ("no-staff-support", SCM_BOOL_T);
+ if (!follow_staff && ! xaxis)
+ p->set_elt_property ("staff-support", SCM_BOOL_T);
p->set_elt_property ("script-priority", priority);
{
for (int i=0; i < script_p_arr_.size(); i++)
{
- Staff_sidify stafy (script_p_arr_[i]);
+ Side_position_interface stafy (script_p_arr_[i]);
stafy.elt_l_->set_elt_property ("direction-source", s->self_scm_);
stafy.add_support (s);
}
{
for (int i=0; i < script_p_arr_.size(); i++)
{
- Staff_sidify stafy(script_p_arr_[i]);
+ Side_position_interface stafy(script_p_arr_[i]);
if (!stafy.elt_l_->parent_l (X_AXIS))
{
*/
-/*
-
- TODO: Quantisation support (staccato dots between stafflines)
-
-*/
#include "debug.hh"
#include "script.hh"
#include "lookup.hh"
void
Script::do_post_processing ()
{
- Direction d = Staff_sidify (this).get_direction ();
+ Direction d = Side_position_interface (this).get_direction ();
Molecule m (get_molecule(d));
-
- /*
- UGH UGH UGH
- */
-#if 0
- if (staff_side_l_->get_elt_property ("no-staff-support") == SCM_UNDEFINED)
- translate_axis (- m.dim_[Y_AXIS][Direction (-d)], Y_AXIS);
-#endif
}
-
Molecule*
Script::do_brew_molecule_p () const
{
#include "dimensions.hh"
#include "dimension-cache.hh"
-Staff_sidify::Staff_sidify (Score_element *e)
+Side_position_interface::Side_position_interface (Score_element *e)
{
elt_l_ = e;
}
void
-Staff_sidify::add_support (Score_element*e)
+Side_position_interface::add_support (Score_element*e)
{
SCM sup = elt_l_->get_elt_property ("side-support");
elt_l_->set_elt_property ("side-support",
gh_cons (e->self_scm_,sup));
}
-Real
-Staff_sidify::aligned_position (Dimension_cache const *c)
-{
- return position_self (c);
-}
Direction
-Staff_sidify::get_direction () const
+Side_position_interface::get_direction () const
{
SCM d = elt_l_->get_elt_property ("direction");
if (isdir_b (d))
{
Score_element * e = SMOB_TO_TYPE(Score_element,other_elt);
- return relative_dir * Staff_sidify (e).get_direction ();
+ return relative_dir * Side_position_interface (e).get_direction ();
}
return DOWN;
Callback that does the aligning.
*/
Real
-Staff_sidify::position_self (Dimension_cache const * c)
+Side_position_interface::side_position (Dimension_cache const * c)
{
Score_element * me = dynamic_cast<Score_element*> (c->element_l ());
SCM support = me->get_elt_property ("side-support");
for (SCM s = support; s != SCM_EOL; s = gh_cdr (s))
{
- assert (SMOB_IS_TYPE_B (Score_element, gh_car (s)));
+ if (!SMOB_IS_TYPE_B (Score_element, gh_car (s)))
+ continue;
+
Score_element * e = SMOB_TO_TYPE(Score_element, gh_car (s));
common = common->common_refpoint (e, axis);
}
for (SCM s = support; s != SCM_EOL; s = gh_cdr (s))
{
+ if (!SMOB_IS_TYPE_B (Score_element, gh_car (s)))
+ continue;
+
Score_element * e = SMOB_TO_TYPE(Score_element, gh_car (s));
Real coord = e->relative_coordinate (common, axis);
Real off = me->parent_l (axis)->relative_coordinate (common, axis);
- Direction dir = Staff_sidify (me).get_direction ();
+ Direction dir = Side_position_interface (me).get_direction ();
SCM pad = me->remove_elt_property ("padding");
if (pad != SCM_UNDEFINED)
return total_off;
}
+Real
+Side_position_interface::self_alignment (Dimension_cache const *c)
+{
+ String s ("self-alignment-");
+ Axis ax = c->axis ();
+ s += (ax == X_AXIS) ? "X" : "Y";
+ Score_element *elm = dynamic_cast<Score_element*> (c->element_l ());
+ SCM align (elm->get_elt_property (s));
+ if (isdir_b (align))
+ {
+ Direction d = to_dir (align);
+ Interval ext(elm->extent (ax));
+ if (d)
+ {
+ return - ext[d];
+ }
+ return - ext.center ();
+ }
+ else
+ return 0.0;
+}
+
+
+Real
+Side_position_interface::aligned_side (Dimension_cache const *c)
+{
+ Score_element * me = dynamic_cast<Score_element*> (c->element_l ());
+ Side_position_interface s(me);
+ Direction d = s.get_direction ();
+ Axis ax = c->axis ();
+ Real o = side_position (c);
+
+ Interval iv = me->extent (ax);
+
+ if (!iv.empty_b ())
+ {
+ o += - iv[-d];
+
+ SCM pad = me->get_elt_property ("padding");
+ if (gh_number_p (pad))
+ o += d *gh_scm2double (pad) ;
+ }
+ return o;
+}
+
+#if 0
+
+/*
+ need cascading off callbacks for this.
+ */
+Side_position_interface::quantised_side (Dimension_cache const *c)
+{
+ Score_element * me = dynamic_cast<Score_element*> (c->element_l ());
+ Side_position_interface s(me);
+ Direction d = s.get_direction ();
+ Axis ax = c->axis ();
+ Real o = side_position (c);
+ Staff_symbol_referencer * st = dynamic_cast (me);
+
+ if (st && ax == Y_AXIS)
+ {
+ st->translate_axis (o, Y_AXIS);
+ st->set_position ();
+
+ st->lines_i ();
+ st->quantise_to_next_line (d);
+ st->translate_axis (o, -Y_AXIS);
+ }
+
+ return o;
+}
+#endif
+
+
+
void
-Staff_sidify::set_axis (Axis a)
+Side_position_interface::set_axis (Axis a)
{
- if (elt_l_->get_elt_property ("transparent") == SCM_UNDEFINED)
+ // prop transparent ?
+ if (elt_l_->get_elt_property ("side-support") == SCM_UNDEFINED)
elt_l_->set_elt_property ("side-support" ,SCM_EOL);
Axis other = Axis ((a +1)%2);
- elt_l_->dim_cache_[a]->set_offset_callback (position_self);
- elt_l_->dim_cache_[other]->set_offset_callback (0);
+ elt_l_->dim_cache_[a]->off_callbacks_.push (aligned_side);
}
+
Axis
-Staff_sidify::get_axis () const
+Side_position_interface::get_axis () const
{
- if (elt_l_->dim_cache_[X_AXIS]->off_callback_l_ == position_self) // UGH.
- return X_AXIS;
- else
- return Y_AXIS;
+ Dimension_cache * c = elt_l_->dim_cache_[X_AXIS];
+ for (int i=0 ; i < c->off_callbacks_.size();i ++)
+ if (c->off_callbacks_[i] == side_position
+ ||c->off_callbacks_[i] == aligned_side)
+ return X_AXIS;
+
+
+ return Y_AXIS;
}
void
-Staff_sidify::set_direction (Direction d)
+Side_position_interface::set_direction (Direction d)
{
elt_l_->set_elt_property ("direction", gh_int2scm (d));
}
bool
-Staff_sidify::is_staff_side_b ()
+Side_position_interface::is_staff_side_b () const
{
return elt_l_->get_elt_property ("side-support") != SCM_UNDEFINED;
}
+
+bool
+Side_position_interface::supported_b () const
+{
+ SCM s =elt_l_->get_elt_property ("side-support");
+ return s != SCM_UNDEFINED && s != SCM_EOL;
+}
#include "paper-column.hh"
#include "staff-symbol-referencer.hh"
#include "paper-def.hh"
+#include "staff-side.hh"
Staff_symbol_engraver::~Staff_symbol_engraver()
{
{
st->set_staff_symbol (span_p_);
}
+
+ SCM ss =s.elem_l_->remove_elt_property ("staff-support");
+ if (gh_boolean_p (ss) && gh_scm2bool (ss))
+ {
+ Side_position_interface si (s.elem_l_);
+ if (si.is_staff_side_b ())
+ si.add_support (span_p_);
+ }
}
Staff_symbol_referencer::Staff_symbol_referencer ()
{
- staff_sym_l_ =0;
- position_i_ =0;
+ staff_symbol_l_ =0;
+ position_f_ =0;
}
void
-Staff_symbol_referencer::do_substitute_element_pointer (Score_element *o, Score_element*n)
+Staff_symbol_referencer::do_substitute_element_pointer (Score_element *o,
+ Score_element*n)
{
- if (staff_sym_l_ == o)
+ if (staff_symbol_l_ == o)
{
- staff_sym_l_ = dynamic_cast<Staff_symbol*> (n);
+ staff_symbol_l_ = dynamic_cast<Staff_symbol*> (n);
}
}
int
Staff_symbol_referencer::lines_i () const
{
- return (staff_sym_l_) ? staff_sym_l_->no_lines_i_ : 5;
+ return (staff_symbol_l_) ? staff_symbol_l_->no_lines_i_ : 5;
}
void
Staff_symbol_referencer::set_staff_symbol (Staff_symbol*s)
{
- staff_sym_l_ =s;
+ staff_symbol_l_ =s;
add_dependency (s);
}
Staff_symbol*
Staff_symbol_referencer::staff_symbol_l () const
{
- return staff_sym_l_;
+ return staff_symbol_l_;
}
Real
Staff_symbol_referencer::staff_line_leading_f () const
{
- if (staff_sym_l_)
- return staff_sym_l_->staff_line_leading_f_;
+ if (staff_symbol_l_)
+ return staff_symbol_l_->staff_line_leading_f_;
else if (pscore_l_ && paper_l ())
paper_l ()->get_var ("interline");
Real
Staff_symbol_referencer::position_f () const
{
- Real p = position_i_;
- if (staff_sym_l_ )
+ Real p = position_f_;
+ if (staff_symbol_l_ )
{
- Graphical_element * c = common_refpoint (staff_sym_l_, Y_AXIS);
- Real y = relative_coordinate (c, Y_AXIS) - staff_sym_l_->relative_coordinate (c, Y_AXIS);
+ Graphical_element * c = common_refpoint (staff_symbol_l_, Y_AXIS);
+ Real y = relative_coordinate (c, Y_AXIS) - staff_symbol_l_->relative_coordinate (c, Y_AXIS);
p += 2.0 * y / staff_line_leading_f ();
}
+/*
+ should use offset callback!
+ */
void
Staff_symbol_referencer::do_pre_processing ()
{
- translate_axis (position_i_ * staff_line_leading_f () /2.0, Y_AXIS);
- position_i_ =0;
+ translate_axis (position_f_ * staff_line_leading_f () /2.0, Y_AXIS);
+ position_f_ =0;
}
void
-Staff_symbol_referencer::set_position (int p)
+Staff_symbol_referencer::set_position (Real p)
{
Real halfspace = staff_line_leading_f ()* 0.5;
translate_axis (- halfspace * position_f (), Y_AXIS);
- if (staff_sym_l_)
+ if (staff_symbol_l_)
translate_axis (halfspace * p, Y_AXIS);
else
- position_i_ = p;
+ position_f_ = p;
}
+
#'margin-shape = #'()
+
+%
+#'Local_key_item::left-padding = #'0.2
+#'Local_key_item::right-padding = #'0.4
projects / lilypond.git / commitdiff