Grob *head = acc->get_parent (Y_AXIS);
Grob *col = head->get_parent (X_AXIS);
- if (Note_column::has_interface (col))
+ if (has_interface<Note_column> (col))
note_cols.push_back (col);
else
ret.push_back (head);
for (vsize i = note_cols.size (); i--;)
{
Grob *c = note_cols[i]->get_parent (X_AXIS);
- if (Note_collision_interface::has_interface (c))
+ if (has_interface<Note_collision_interface> (c))
{
extract_grob_set (c, "elements", columns);
concat (note_cols, columns);
// of the system. This way, the tall treble clefs are only compared with the treble
// clefs of the other staff and they will be ignored if the staff above is, for example,
// lyrics.
- if (Axis_group_interface::has_interface (g))
+ if (has_interface<Axis_group_interface> (g))
{
extent = Axis_group_interface::rest_of_line_pure_height (g, start, end);
Interval begin_of_line_extent = Axis_group_interface::begin_of_line_pure_height (g, start);
Grob *se = elts[i];
if (!to_boolean (se->get_property ("cross-staff")))
{
- Interval dims = (bound && Axis_group_interface::has_interface (se)
+ Interval dims = (bound && has_interface<Axis_group_interface> (se)
? generic_bound_extent (se, common, a)
: se->extent (common, a));
if (!dims.is_empty ())
reasonably safe to assume that if our parent is a VerticalAlignment,
we can assume additivity and cache things nicely. */
Grob *p = me->get_parent (Y_AXIS);
- if (p && Align_interface::has_interface (p))
+ if (has_interface<Align_interface> (p))
return Axis_group_interface::sum_partial_pure_heights (me, start, end);
Grob *common = unsmob<Grob> (me->get_object ("pure-Y-common"));
if (rank_span[LEFT] <= end && rank_span[RIGHT] >= start
&& g->pure_is_visible (start, end)
&& !(to_boolean (g->get_property ("cross-staff"))
- && Stem::has_interface (g)))
+ && has_interface<Stem> (g)))
{
Interval dims = g->pure_y_extent (common, start, end);
if (!dims.is_empty ())
/* trigger the callback to do skyline-spacing on the children */
if (a == Y_AXIS)
for (vsize i = 0; i < elts.size (); i++)
- if (!(Stem::has_interface (elts[i])
+ if (!(has_interface<Stem> (elts[i])
&& to_boolean (elts[i]->get_property ("cross-staff"))))
(void) elts[i]->get_property ("vertical-skylines");
extract_grob_set (me, "pure-relevant-grobs", elts);
Grob *common = common_refpoint_of_array (elts, me, Y_AXIS);
- if (common != me && Align_interface::has_interface (common))
+ if (common != me && has_interface<Align_interface> (common))
{
me->programming_error("My pure_y_common is a VerticalAlignment,"
" which might contain several staves.");
{
found->push_back (me);
- if (!Axis_group_interface::has_interface (me))
+ if (!has_interface<Axis_group_interface> (me))
return;
extract_grob_set (me, "elements", elements);
public:
DECLARE_SCHEME_CALLBACK (print, (SCM));
DECLARE_SCHEME_CALLBACK (print_spanner, (SCM));
- DECLARE_GROB_INTERFACE ();
static SCM internal_balloon_print (Grob *me, Grob *p, Offset off);
};
if ((covered_grob_spanned_rank[RIGHT] >= beam_spanned_rank_[LEFT])
&& !(to_boolean (beam_grob->get_property ("collision-voice-only"))
&& (covered_grob_context != beam_context))
- && !(Beam::has_interface (covered_grob)
+ && !(has_interface<Beam> (covered_grob)
&& (covered_grob_spanned_rank[LEFT] <= beam_spanned_rank_[LEFT]))
&& covered_grob_has_interface (covered_grob, beam_grob))
{
// Do not consider note heads attached to the beam.
- if (Stem::has_interface (covered_grob))
+ if (has_interface<Stem> (covered_grob))
if (unsmob<Grob> (covered_grob->get_object ("beam")))
continue;
edge_dirs_ = Drul_array<Direction> (stem_infos_[0].dir_,
stem_infos_.back ().dir_);
- is_xstaff_ = Align_interface::has_interface (common[Y_AXIS]);
+ is_xstaff_ = has_interface<Align_interface> (common[Y_AXIS]);
is_knee_ |= dirs_found[DOWN] && dirs_found[UP];
staff_radius_ = Staff_symbol_referencer::staff_radius (beams[i]);
if (!collisions[j]->is_live ())
continue;
- if (Beam::has_interface (collisions[j]) && Beam::is_cross_staff (collisions[j]))
+ if (has_interface<Beam> (collisions[j]) && Beam::is_cross_staff (collisions[j]))
continue;
Box b;
add_collision (b[X_AXIS][d], b[Y_AXIS], width_factor);
Grob *stem = unsmob<Grob> (collisions[j]->get_object ("stem"));
- if (stem && Stem::has_interface (stem) && Stem::is_normal_stem (stem))
+ if (has_interface<Stem> (stem) && Stem::is_normal_stem (stem))
{
colliding_stems.insert (stem);
}
return scm_from_double (0.0);
Grob *beam = unsmob<Grob> (stem->get_object ("beam"));
if (!beam
- || !Beam::has_interface (beam)
+ || !has_interface<Beam> (beam)
|| !Beam::normal_stem_count (beam))
return scm_from_double (0.0);
{
Grob *me = unsmob<Grob> (grob);
Item *alignment = dynamic_cast<Item *> (me->get_parent (X_AXIS));
- if (!Break_alignment_interface::has_interface (alignment))
+ if (!has_interface<Break_alignment_interface> (alignment))
return scm_from_int (0);
SCM symbol_list = me->get_property ("break-align-symbols");
struct Clef_modifier
{
DECLARE_SCHEME_CALLBACK (calc_parent_alignment, (SCM));
- DECLARE_GROB_INTERFACE ();
};
MAKE_SCHEME_CALLBACK (Clef_modifier, calc_parent_alignment, 1)
void
Cluster_spanner_engraver::acknowledge_note_column (Grob_info info)
{
- if (!beacon_ && Note_column::has_interface (info.grob ()))
+ if (!beacon_ && has_interface<Note_column> (info.grob ()))
{
finished_spanner_ = spanner_;
spanner_ = 0;
{
public:
DECLARE_SCHEME_CALLBACK (height, (SCM));
- DECLARE_GROB_INTERFACE ();
};
MAKE_SCHEME_CALLBACK (Cluster_beacon, height, 1);
void
Collision_engraver::acknowledge_note_column (Grob_info i)
{
- if (Note_column::has_interface (i.grob ()))
+ if (has_interface<Note_column> (i.grob ()))
{
/*should check Y axis? */
if (Note_column::has_rests (i.grob ()) || i.grob ()->get_parent (X_AXIS))
Rest collisions should wait after line breaking.
*/
Interval y;
- if (Rest::has_interface (s))
+ if (has_interface<Rest> (s))
{
base_x.unite (s->extent (commonx, X_AXIS));
continue;
}
- else if (Stem::has_interface (s))
+ else if (has_interface<Stem> (s))
{
Real y1 = Stem::head_positions (s)[-get_grob_direction (s)];
Real y2 = y1 + get_grob_direction (s) * 7;
stems.insert (s);
}
- else if (Note_head::has_interface (s))
+ else if (has_interface<Note_head> (s))
y = Interval (-1.1, 1.1);
else
{
Grob *note = dots[i]->get_parent (Y_AXIS);
if (note)
{
- if (Note_head::has_interface (note))
+ if (has_interface<Note_head> (note))
dp.dir_ = to_dir (dp.dot_->get_property ("direction"));
dp.x_extent_ = note->extent (commonx, X_AXIS);
// correct X-offset of the dots for horizontal collision avoidance.
// The translation here is undone in calc_positioning_done, where we
// do the X-offset properly.
- if (Rest::has_interface (head))
+ if (has_interface<Rest> (head))
d->translate_axis (head->extent (head, X_AXIS).length (), X_AXIS);
else
d->set_property ("X-offset", Grob::x_parent_positioning_proc);
void
Dynamic_align_engraver::acknowledge_end_dynamic (Grob_info info)
{
- if (Spanner::has_interface (info.grob ()))
+ if (has_interface<Spanner> (info.grob ()))
ended_.push_back (info.spanner ());
/* If the break flag is set, store the current spanner and let new dynamics
}
create_line_spanner (info.grob ());
- if (Spanner::has_interface (info.grob ()))
+ if (has_interface<Spanner> (info.grob ()))
{
started_.push_back (info.spanner ());
current_dynamic_spanner_ = info.spanner ();
}
if (finished_spanner_)
{
- if (Hairpin::has_interface (finished_spanner_))
+ if (has_interface<Hairpin> (finished_spanner_))
Pointer_group_interface::add_grob (finished_spanner_,
ly_symbol2scm ("adjacent-spanners"),
current_spanner_);
- if (Hairpin::has_interface (current_spanner_))
+ if (has_interface<Hairpin> (current_spanner_))
Pointer_group_interface::add_grob (current_spanner_,
ly_symbol2scm ("adjacent-spanners"),
finished_spanner_);
struct Enclosing_bracket
{
- DECLARE_GROB_INTERFACE ();
public:
DECLARE_SCHEME_CALLBACK (print, (SCM));
struct Figured_bass_continuation
{
- DECLARE_GROB_INTERFACE ();
public:
DECLARE_SCHEME_CALLBACK (print, (SCM));
DECLARE_SCHEME_CALLBACK (calc_y_offset, (SCM));
DECLARE_SCHEME_CALLBACK (pure_calc_y_offset, (SCM, SCM, SCM));
DECLARE_SCHEME_CALLBACK (calc_x_offset, (SCM));
- DECLARE_GROB_INTERFACE ();
static SCM internal_calc_y_offset (SCM smob, bool pure);
};
if (Grob *p = get_parent (Y_AXIS))
{
Real trans = 0;
- if (Align_interface::has_interface (p) && !dim_cache_[Y_AXIS].offset_)
+ if (has_interface<Align_interface> (p) && !dim_cache_[Y_AXIS].offset_)
trans = Align_interface::get_pure_child_y_translation (p, this, start, end);
return off + trans + p->pure_relative_y_coordinate (refp, start, end);
{
if (!g)
return maybe;
- if (Align_interface::has_interface (g))
+ if (has_interface<Align_interface> (g))
return get_maybe_root_vertical_alignment (g->get_parent (Y_AXIS), g);
return get_maybe_root_vertical_alignment (g->get_parent (Y_AXIS), maybe);
return 0;
if (!g->get_parent (Y_AXIS))
return 0;
- if (Axis_group_interface::has_interface (g)
- && Align_interface::has_interface (g->get_parent (Y_AXIS)))
+ if (has_interface<Axis_group_interface> (g)
+ && has_interface<Align_interface> (g->get_parent (Y_AXIS)))
return g;
return get_vertical_axis_group (g->get_parent (Y_AXIS));
bool
Grob::check_cross_staff (Grob *commony)
{
- if (Align_interface::has_interface (commony))
+ if (has_interface<Align_interface> (commony))
return true;
for (Grob *g = this; g && g != commony; g = g->get_parent (Y_AXIS))
- if (Align_interface::has_interface (g))
+ if (has_interface<Align_interface> (g))
return true;
return false;
}
else
{
- if (Text_interface::has_interface (b))
+ if (has_interface<Text_interface> (b))
{
if (!e.is_empty ())
x_points[d] = e[-d] - d * padding;
if (neighbor_found)
{
- if (Hairpin::has_interface (adjacent))
+ if (has_interface<Hairpin> (adjacent))
{
/*
Handle back-to-back hairpins with a circle in the middle
else
{
if (d == RIGHT // end at the left edge of a rest
- && Note_column::has_interface (b)
+ && has_interface<Note_column> (b)
&& Note_column::has_rests (b))
x_points[d] = e[-d];
else
DECLARE_SCHEME_CALLBACK (height, (SCM));
DECLARE_SCHEME_CALLBACK (remove_tied, (SCM));
- DECLARE_GROB_INTERFACE ();
static SCM get_stencil (Grob *me);
};
vector<Grob *> *real_acc);
DECLARE_SCHEME_CALLBACK (calc_positioning_done, (SCM));
- DECLARE_GROB_INTERFACE ();
};
#endif /* ACCIDENTAL_PLACEMENT_HH */
static void add_element (Grob *, Grob *);
static int get_count (Grob *, Grob *);
- DECLARE_GROB_INTERFACE ();
static Real get_pure_child_y_translation (Grob *, Grob *child, int start, int end);
DECLARE_SCHEME_CALLBACK (brew_chord_slur, (SCM));
DECLARE_SCHEME_CALLBACK (width, (SCM));
DECLARE_SCHEME_CALLBACK (pure_height, (SCM, SCM, SCM));
- DECLARE_GROB_INTERFACE ();
};
#endif /* ARPEGGIO_HH */
static SCM calc_common (Grob *, Axis);
static Real minimum_distance (Grob *, Grob *, Axis);
static SCM calc_maybe_pure_staff_staff_spacing (Grob *, bool, int, int);
- DECLARE_GROB_INTERFACE ();
};
#endif /* AXIS_GROUP_INTERFACE_HH */
class Bar_line
{
public:
- DECLARE_GROB_INTERFACE ();
static bool non_empty_barline (Grob *me);
};
static int normal_stem_count (Grob *);
static Grob *first_normal_stem (Grob *);
static Grob *last_normal_stem (Grob *);
- DECLARE_GROB_INTERFACE ();
static void add_stem (Grob *, Grob *);
static bool is_cross_staff (Grob *);
static bool is_knee (Grob *);
{
public:
static vector<Grob *> ordered_elements (Grob *me);
- DECLARE_GROB_INTERFACE ();
static void add_element (Grob *me, Grob *add);
static SCM break_align_order (Item *me);
DECLARE_SCHEME_CALLBACK (calc_positioning_done, (SCM element));
DECLARE_SCHEME_CALLBACK (calc_average_anchor, (SCM));
DECLARE_SCHEME_CALLBACK (calc_extent_aligned_anchor, (SCM));
DECLARE_SCHEME_CALLBACK (calc_break_visibility, (SCM));
- DECLARE_GROB_INTERFACE ();
};
struct Break_alignable_interface
{
DECLARE_SCHEME_CALLBACK (self_align_callback, (SCM element));
- DECLARE_GROB_INTERFACE ();
};
#endif // BREAK_ALIGN_INTERFACE_HH
DECLARE_SCHEME_CALLBACK (finalis, (SCM));
DECLARE_SCHEME_CALLBACK (offset_callback, (SCM element));
- DECLARE_GROB_INTERFACE ();
};
#endif // BREATHING_SIGN_HH
{
public:
DECLARE_SCHEME_CALLBACK (after_line_breaking, (SCM));
- DECLARE_GROB_INTERFACE ();
};
#endif // CHORD_NAME_HH
{
DECLARE_SCHEME_CALLBACK (calc_glyph_name, (SCM));
DECLARE_SCHEME_CALLBACK (print, (SCM));
- DECLARE_GROB_INTERFACE ();
};
#endif /* CLEF_HH */
public:
DECLARE_SCHEME_CALLBACK (print, (SCM));
DECLARE_SCHEME_CALLBACK (calc_cross_staff, (SCM));
- DECLARE_GROB_INTERFACE ();
};
#endif // CLUSTER_HH
struct Custos
{
DECLARE_SCHEME_CALLBACK (print, (SCM));
- DECLARE_GROB_INTERFACE ();
private:
static void add_streepjes (Grob *me, int pos, int interspaces, Stencil *custos_);
static int compare (Grob *const &, Grob *const &);
static void add_head (Grob *dotcol, Grob *rh);
- DECLARE_GROB_INTERFACE ();
DECLARE_SCHEME_CALLBACK (side_position, (SCM));
DECLARE_SCHEME_CALLBACK (calc_positioning_done, (SCM));
};
{
public:
DECLARE_SCHEME_CALLBACK (print, (SCM));
- DECLARE_GROB_INTERFACE ();
};
#endif // DOTS_HH
{
static void add_fingering (Grob *, Grob *);
DECLARE_SCHEME_CALLBACK (calc_positioning_done, (SCM));
- DECLARE_GROB_INTERFACE ();
static void do_x_positioning (Grob *me);
static void do_y_positioning (Grob *me);
};
static SCM text_font_alist_chain (Grob *);
static SCM music_font_alist_chain (Grob *);
static Font_metric *get_default_font (Grob *);
- DECLARE_GROB_INTERFACE ();
};
#endif /* FONT_INTERFACE_HH */
class Gregorian_ligature
{
public:
- DECLARE_GROB_INTERFACE ();
static string prefixes_to_str (Grob *);
};
static void add_grid_point (Grob *me, Grob *b);
DECLARE_SCHEME_CALLBACK (print, (SCM));
DECLARE_SCHEME_CALLBACK (width, (SCM));
- DECLARE_GROB_INTERFACE ();
};
class Grid_point_interface
{
public:
- DECLARE_GROB_INTERFACE ();
};
#endif /* GRID_LINE_INTERFACE_HH */
class Grob;
-// TODO: remove DECLARE_GROB_INTERFACE
-#define DECLARE_GROB_INTERFACE() \
- static bool has_interface (Grob *g)
-
-// TODO: remove cl::has_interface and use ::has_interface directly
#define ADD_INTERFACE(cl, b, c) \
Grob_interface<cl> cl ## _interface_initializer; \
template <> char const *Grob_interface<cl>::cxx_name_ (#cl); \
template <> char const *Grob_interface<cl>::description_ (b); \
- template <> char const *Grob_interface<cl>::variables_ (c); \
- bool cl::has_interface (Grob *me) \
- { \
- return ::has_interface<cl> (me); \
- }
+ template <> char const *Grob_interface<cl>::variables_ (c);
SCM add_interface (char const *cxx_name,
char const *descr,
/* interfaces */
bool internal_has_interface (SCM intf);
- DECLARE_GROB_INTERFACE ();
/* offsets */
void translate_axis (Real, Axis);
DECLARE_SCHEME_CALLBACK (print, (SCM));
DECLARE_SCHEME_CALLBACK (broken_bound_padding, (SCM));
DECLARE_SCHEME_CALLBACK (pure_height, (SCM, SCM, SCM));
- DECLARE_GROB_INTERFACE ();
};
#endif // HAIRPIN_HH
DECLARE_SCHEME_CALLBACK (calc_skylines, (SCM smob));
DECLARE_SCHEME_CALLBACK (pure_height, (SCM smob, SCM start, SCM end));
DECLARE_SCHEME_CALLBACK (force_hara_kiri_in_y_parent_callback, (SCM));
- DECLARE_GROB_INTERFACE ();
static bool request_suicide (Grob *me, int start, int end);
static bool request_suicide_alone (Grob *me, int start, int end);
static void consider_suicide (Grob *me);
static Stencil make_enclosing_bracket (Grob *me, Grob *refpoint,
vector<Grob *> grobs,
Axis a, Direction dir);
- DECLARE_GROB_INTERFACE ();
};
#endif /* HORIZONTAL_BRACKET_HH */
virtual Interval_t<int> spanned_rank_interval () const;
virtual Interval pure_y_extent (Grob *ref, int start, int end);
virtual void cache_pure_height (Interval height);
- DECLARE_GROB_INTERFACE ();
protected:
virtual void discretionary_processing ();
void copy_breakable_items ();
struct Kievan_ligature
{
DECLARE_SCHEME_CALLBACK (print, (SCM));
- DECLARE_GROB_INTERFACE ();
};
#endif /* KIEVAN_LIGATURE_HH */
struct Line_interface
{
static Stencil line (Grob *me, Offset from, Offset to);
- DECLARE_GROB_INTERFACE ();
static Stencil make_zigzag_line (Grob *me,
Offset from,
Offset to);
class Lyric_extender
{
public:
- DECLARE_GROB_INTERFACE ();
DECLARE_SCHEME_CALLBACK (print, (SCM));
};
{
public:
DECLARE_SCHEME_CALLBACK (set_spacing_rods, (SCM));
- DECLARE_GROB_INTERFACE ();
DECLARE_SCHEME_CALLBACK (print, (SCM));
};
public:
DECLARE_SCHEME_CALLBACK (print, (SCM));
- DECLARE_GROB_INTERFACE ();
};
#endif /* MEASURE_GROUPING_SPANNER_HH */
class Melody_spanner
{
public:
- DECLARE_GROB_INTERFACE ();
static void add_stem (Grob *, Grob *);
DECLARE_SCHEME_CALLBACK (calc_neutral_stem_direction, (SCM));
};
{
DECLARE_SCHEME_CALLBACK (brew_ligature_primitive, (SCM));
DECLARE_SCHEME_CALLBACK (print, (SCM));
- DECLARE_GROB_INTERFACE ();
};
#endif /* MENSURAL_LIGATURE_HH */
class Multi_measure_rest
{
public:
- DECLARE_GROB_INTERFACE ();
DECLARE_SCHEME_CALLBACK (print, (SCM));
DECLARE_SCHEME_CALLBACK (height, (SCM));
DECLARE_SCHEME_CALLBACK (percent, (SCM));
static Drul_array<vector<Grob *> > get_clash_groups (Grob *me);
DECLARE_SCHEME_CALLBACK (calc_positioning_done, (SCM smob));
static void add_column (Grob *me, Grob *ncol);
- DECLARE_GROB_INTERFACE ();
};
#endif // COLLISION_HH
static bool has_rests (Grob *me);
static Grob *dot_column (Grob *me);
static Interval cross_staff_extent (Grob *me, Grob *refp);
- DECLARE_GROB_INTERFACE ();
static Item *get_stem (Grob *);
static Item *get_flag (Grob *);
DECLARE_SCHEME_CALLBACK (stem_x_shift, (SCM));
DECLARE_SCHEME_CALLBACK (calc_stem_attachment, (SCM));
DECLARE_SCHEME_CALLBACK (include_ledger_line_height, (SCM));
- DECLARE_GROB_INTERFACE ();
static Real stem_attachment_coordinate (Grob *, Axis a);
static int get_balltype (Grob *);
class Note_spacing
{
public:
- DECLARE_GROB_INTERFACE ();
static Spring get_spacing (Grob *me, Item *, Spring, Real);
static void stem_dir_correction (Grob *me, Item *next_col, Real incr,
DECLARE_SCHEME_CALLBACK (print, (SCM));
DECLARE_SCHEME_CALLBACK (before_line_breaking, (SCM));
- DECLARE_GROB_INTERFACE ();
static int get_rank (Grob const *);
static bool is_musical (Grob *);
static Moment when_mom (Grob *);
class Percent_repeat_item_interface
{
public:
- DECLARE_GROB_INTERFACE ();
DECLARE_SCHEME_CALLBACK (beat_slash, (SCM));
DECLARE_SCHEME_CALLBACK (double_percent, (SCM));
static Stencil x_percent (Grob *, int);
{
public:
DECLARE_SCHEME_CALLBACK (calc_pure_relevant_grobs, (SCM));
- DECLARE_GROB_INTERFACE ();
};
public:
static void add_column (Grob *me, Grob *);
- DECLARE_GROB_INTERFACE ();
DECLARE_SCHEME_CALLBACK (calc_positioning_done, (SCM element));
DECLARE_SCHEME_CALLBACK (force_shift_callback_rest, (SCM element, SCM off));
static SCM do_shift (Grob *);
public:
DECLARE_SCHEME_CALLBACK (y_offset_callback, (SCM));
DECLARE_SCHEME_CALLBACK (calc_cross_staff, (SCM));
- DECLARE_GROB_INTERFACE ();
static string glyph_name (Grob *, int durlog, const string &style, bool, Real);
static Real staff_position_internal (Grob *, int /* duration_log */,
int /* dir */);
static Item *get_dots (Grob *);
static int dot_count (Grob *);
DECLARE_SCHEME_CALLBACK (after_line_breaking, (SCM));
- DECLARE_GROB_INTERFACE ();
};
#endif // RHYTHMIC_HEAD_HH
static void add_side_positioned (Grob *, Grob *);
DECLARE_SCHEME_CALLBACK (before_line_breaking, (SCM));
DECLARE_SCHEME_CALLBACK (row_before_line_breaking, (SCM));
- DECLARE_GROB_INTERFACE ();
static void order_grobs (vector<Grob *> grobs);
};
static Stencil get_stencil (Grob *, Direction d);
static Direction get_direction (Grob *);
- DECLARE_GROB_INTERFACE ();
DECLARE_SCHEME_CALLBACK (print, (SCM));
DECLARE_SCHEME_CALLBACK (calc_direction, (SCM));
DECLARE_SCHEME_CALLBACK (calc_positioning_done, (SCM));
struct Self_alignment_interface
{
- DECLARE_GROB_INTERFACE ();
static SCM aligned_on_self (Grob *me, Axis a, bool pure, int start, int end);
static SCM centered_on_object (Grob *me, Axis a);
struct Semi_tie_column
{
- DECLARE_GROB_INTERFACE ();
DECLARE_SCHEME_CALLBACK (calc_positioning_done, (SCM));
DECLARE_SCHEME_CALLBACK (calc_head_direction, (SCM));
struct Semi_tie
{
- DECLARE_GROB_INTERFACE ();
DECLARE_SCHEME_CALLBACK (calc_control_points, (SCM));
static bool less (Grob *s1, Grob *s2);
struct Separation_item
{
- DECLARE_GROB_INTERFACE ();
DECLARE_SCHEME_CALLBACK (calc_skylines, (SCM));
DECLARE_SCHEME_CALLBACK (print, (SCM));
static Axis get_axis (Grob *);
static void set_axis (Grob *, Axis);
- DECLARE_GROB_INTERFACE ();
static void add_support (Grob *, Grob *);
static void recursive_add_support (Grob *, Grob *);
static void add_staff_support (Grob *);
DECLARE_SCHEME_CALLBACK (pure_outside_slur_callback, (SCM, SCM, SCM, SCM));
DECLARE_SCHEME_CALLBACK (outside_slur_cross_staff, (SCM, SCM));
DECLARE_SCHEME_CALLBACK (calc_cross_staff, (SCM));
- DECLARE_GROB_INTERFACE ();
static Bezier get_curve (Grob *me);
};
static void add_spring (Grob *me, Grob *to, Spring sp);
static Spring get_spring (Grob *me, Grob *other);
- DECLARE_GROB_INTERFACE ();
static SCM get_minimum_distances (Grob *);
static SCM get_ideal_distances (Grob *);
};
static Drul_array<Skyline> skylines (Grob *me, Grob *right_col);
static Grob *extremal_break_aligned_grob (Grob *me, Direction, Direction, Interval *);
- DECLARE_GROB_INTERFACE ();
};
#endif /* SPACING_INTERFACE_HH */
DECLARE_SCHEME_CALLBACK (set_springs, (SCM));
DECLARE_SCHEME_CALLBACK (calc_common_shortest_duration, (SCM));
- DECLARE_GROB_INTERFACE ();
};
#endif /* SPACING_SPANNER_HH */
static bool less (Spanner *const &, Spanner *const &);
virtual Grob *find_broken_piece (System *) const;
virtual void derived_mark () const;
- DECLARE_GROB_INTERFACE ();
virtual System *get_system () const;
SCM get_cached_pure_property (SCM sym, int start, int end);
class Staff_grouper_interface
{
public:
- DECLARE_GROB_INTERFACE ();
static bool maybe_pure_within_group (Grob *, Grob *child, bool, int, int);
};
static Real next_notes_correction (Grob *, Grob *);
public:
- DECLARE_GROB_INTERFACE ();
static Spring get_spacing (Grob *, Grob *, Real);
static Interval bar_y_positions (Grob *);
};
class Staff_symbol_referencer
{
public:
- DECLARE_GROB_INTERFACE ();
static bool ugly_hack (Grob *);
static void set_position (Grob *, Real);
static void pure_set_position (Grob *, Real);
static Interval line_span (Grob *);
DECLARE_SCHEME_CALLBACK (print, (SCM));
DECLARE_SCHEME_CALLBACK (height, (SCM));
- DECLARE_GROB_INTERFACE ();
};
#endif // STAFF_SYMBOL_HH
{
public:
- DECLARE_GROB_INTERFACE ();
DECLARE_SCHEME_CALLBACK (calc_slope, (SCM));
DECLARE_SCHEME_CALLBACK (calc_width, (SCM));
DECLARE_SCHEME_CALLBACK (calc_y_offset, (SCM));
static Real internal_calc_stem_end_position (Grob *, bool);
static Real internal_calc_stem_begin_position (Grob *, bool);
- DECLARE_GROB_INTERFACE ();
static void set_spacing_hints (Grob *);
static Grob *flag (Grob *);
public:
DECLARE_SCHEME_CALLBACK (print, (SCM));
- DECLARE_GROB_INTERFACE ();
static void try_collapse (Grob *);
static Stencil staff_bracket (Grob *, Real);
static Stencil old_staff_bracket (Grob *, Real);
int spanner_count () const;
void break_into_pieces (vector<Column_x_positions> const &);
- DECLARE_GROB_INTERFACE ();
vector<Item *> broken_col_range (Item const *, Item const *) const;
vector<Grob *> used_columns () const;
DECLARE_SCHEME_CALLBACK (print, (SCM));
DECLARE_SCHEME_CALLBACK (interpret_markup, (SCM, SCM, SCM));
DECLARE_SCHEME_CALLBACK (interpret_string, (SCM, SCM, SCM));
- DECLARE_GROB_INTERFACE ();
static bool is_markup (SCM);
static bool is_markup_list (SCM);
};
class Tie_column
{
public:
- DECLARE_GROB_INTERFACE ();
static void add_tie (Grob *me, Spanner *);
DECLARE_SCHEME_CALLBACK (calc_positioning_done, (SCM));
DECLARE_SCHEME_CALLBACK (before_line_breaking, (SCM));
{
public:
static void set_head (Spanner *, Direction, Grob *head);
- DECLARE_GROB_INTERFACE ();
static Item *head (Spanner *, Direction);
static int get_column_rank (Spanner *, Direction);
static int get_position (Spanner *);
DECLARE_SCHEME_CALLBACK (calc_connect_to_neighbors, (SCM smob));
DECLARE_SCHEME_CALLBACK (calc_cross_staff, (SCM));
- DECLARE_GROB_INTERFACE ();
static Grob *get_common_x (Spanner *);
static void add_tuplet_bracket (Grob *me, Grob *smaller_bracket);
static void get_bounds (Grob *, Grob **, Grob **);
DECLARE_SCHEME_CALLBACK (calc_x_offset, (SCM));
DECLARE_SCHEME_CALLBACK (calc_y_offset, (SCM));
DECLARE_SCHEME_CALLBACK (calc_cross_staff, (SCM));
- DECLARE_GROB_INTERFACE ();
static Real calc_offset (Spanner *me, Axis a); // not used
{
DECLARE_SCHEME_CALLBACK (brew_ligature_primitive, (SCM));
DECLARE_SCHEME_CALLBACK (print, (SCM));
- DECLARE_GROB_INTERFACE ();
};
/*
class Volta_bracket_interface
{
public:
- DECLARE_GROB_INTERFACE ();
DECLARE_SCHEME_CALLBACK (print, (SCM));
static void modify_edge_height (Spanner *);
static void add_bar (Grob *me, Item *bar);
&& !info.grob ()->internal_has_interface (ly_symbol2scm ("dynamic-interface"))
&& !info.grob ()->internal_has_interface (ly_symbol2scm ("piano-pedal-interface"))
&& !info.grob ()->internal_has_interface (ly_symbol2scm ("volta-interface"))
- && (!Align_interface::has_interface (info.grob ())))
+ && (!has_interface<Align_interface> (info.grob ())))
{
if (Page_layout_problem::is_spaceable (info.grob ()))
axis_groups_.push_back (info.grob ());
struct Key_signature_interface
{
DECLARE_SCHEME_CALLBACK (print, (SCM));
- DECLARE_GROB_INTERFACE ();
};
/*
{
DECLARE_SCHEME_CALLBACK (print, (SCM));
DECLARE_SCHEME_CALLBACK (set_spacing_rods, (SCM));
- DECLARE_GROB_INTERFACE ();
};
static void
struct Ledgered_interface
{
- DECLARE_GROB_INTERFACE ();
};
ADD_INTERFACE (Ledgered_interface,
DECLARE_SCHEME_CALLBACK (calc_left_bound_info_and_text, (SCM));
DECLARE_SCHEME_CALLBACK (calc_right_bound_info, (SCM));
DECLARE_SCHEME_CALLBACK (calc_bound_info, (SCM, Direction));
- DECLARE_GROB_INTERFACE ();
};
Spanner *parent_spanner (Grob *g)
{
- if (Spanner::has_interface (g))
+ if (has_interface<Spanner> (g))
return dynamic_cast<Spanner *> (g);
return parent_spanner (g->get_parent (Y_AXIS));
}
? columns[0] : columns.back ();
}
- Real x_coord = (Paper_column::has_interface (bound_grob)
+ Real x_coord = (has_interface<Paper_column> (bound_grob)
? Axis_group_interface::generic_bound_extent (bound_grob, commonx, X_AXIS)
: robust_relative_extent (bound_grob, commonx, X_AXIS)).linear_combination (attach);
// here. Not with this mechanism.
if ((*end_mom == end_from_now)
&& dynamic_cast<Item *> (g)
- && Note_head::has_interface (g))
+ && has_interface<Note_head> (g))
{
return g;
}
{
Grob *d = unsmob<Grob> (head_up->get_object ("dot"));
Grob *parent = d->get_parent (X_AXIS);
- if (Dot_column::has_interface (parent))
+ if (has_interface<Dot_column> (parent))
Side_position_interface::add_support (parent, head_down);
}
else if (Rhythmic_head::dot_count (head_down))
{
Grob *d = unsmob<Grob> (head_down->get_object ("dot"));
Grob *parent = d->get_parent (X_AXIS);
- if (Dot_column::has_interface (parent))
+ if (has_interface<Dot_column> (parent))
{
Grob *stem = unsmob<Grob> (head_up->get_object ("stem"));
// Loop over all heads on an up-pointing-stem to see if dots
for (vsize i = 0; i < elements.size (); i++)
{
Grob *se = elements[i];
- if (Note_column::has_interface (se))
+ if (has_interface<Note_column> (se))
{
if (!Note_column::dir (se))
se->programming_error ("note-column has no direction");
Note_column::dir (Grob *me)
{
Grob *stem = unsmob<Grob> (me->get_object ("stem"));
- if (stem && Stem::has_interface (stem))
+ if (has_interface<Stem> (stem))
return get_grob_direction (stem);
else
{
return (Direction)sign (head_positions_interval (me).center ());
}
- if (Note_column::has_interface (me))
+ if (has_interface<Note_column> (me))
programming_error ("Note_column without heads and stem");
else
programming_error ("dir() given grob without Note_column interface");
Note_column::add_head (Grob *me, Grob *h)
{
bool both = false;
- if (Rest::has_interface (h))
+ if (has_interface<Rest> (h))
{
extract_grob_set (me, "note-heads", heads);
if (heads.size ())
else
me->set_object ("rest", h->self_scm ());
}
- else if (Note_head::has_interface (h))
+ else if (has_interface<Note_head> (h))
{
if (unsmob<Grob> (me->get_object ("rest")))
both = true;
if (!acc)
return 0;
- if (Accidental_placement::has_interface (acc->get_parent (X_AXIS)))
+ if (has_interface<Accidental_placement> (acc->get_parent (X_AXIS)))
return acc->get_parent (X_AXIS);
/* compatibility. */
for (vsize i = 0; i < items.size (); i++)
{
Item *it = dynamic_cast<Item *> (items[i]);
- if (!Note_column::has_interface (it))
+ if (!has_interface<Note_column> (it))
continue;
if (d == RIGHT && it->get_column () != rcolumn)
continue;
struct Ottava_bracket
{
DECLARE_SCHEME_CALLBACK (print, (SCM));
- DECLARE_GROB_INTERFACE ();
};
/*
Item *b = me->get_bound (d);
broken[d] = (b->break_status_dir () != CENTER);
- if (Note_column::has_interface (b))
+ if (has_interface<Note_column> (b))
{
extract_grob_set (b, "note-heads", heads);
common = common_refpoint_of_array (heads, common, X_AXIS);
Item *b = me->get_bound (d);
Interval ext;
- if (Note_column::has_interface (b))
+ if (has_interface<Note_column> (b))
{
extract_grob_set (b, "note-heads", heads);
for (vsize i = 0; i < heads.size (); i++)
vector<Grob *> output;
for (vsize i = 0; i < input.size (); ++i)
{
- if (Hara_kiri_group_spanner::has_interface (input[i]))
+ if (has_interface<Hara_kiri_group_spanner> (input[i]))
Hara_kiri_group_spanner::consider_suicide (input[i]);
if (input[i]->is_live ())
if (!unsmob<Grob> (elem->get_object ("axis-group-parent-X")))
elem->set_object ("axis-group-parent-X", col->self_scm ());
- if (Accidental_placement::has_interface (elem)
- || Arpeggio::has_interface (elem))
+ if (has_interface<Accidental_placement> (elem)
+ || has_interface<Arpeggio> (elem))
Separation_item::add_conditional_item (col, elem);
- else if (!Accidental_interface::has_interface (elem))
+ else if (!has_interface<Accidental_interface> (elem))
Separation_item::add_item (col, elem);
}
items_.clear ();
(me, ly_symbol2scm ("elements"),
(scm_is_eq (align_sym, ly_symbol2scm ("staff-bar"))
? Bar_line::non_empty_barline
- : Break_alignment_interface::has_interface));
+ : has_interface<Break_alignment_interface>));
else
{
extract_grob_set (me, "elements", elts);
bool has_notehead = false;
for (vsize i = 0; i < elts.size (); i++)
{
- if (Rhythmic_head::has_interface (elts[i]))
+ if (has_interface<Rhythmic_head> (elts[i]))
{
has_notehead = true;
if (dynamic_cast<Item *> (elts[i])->get_column () == me)
struct Piano_pedal_bracket
{
DECLARE_SCHEME_CALLBACK (print, (SCM));
- DECLARE_GROB_INTERFACE ();
};
MAKE_SCHEME_CALLBACK (Piano_pedal_bracket, print, 1);
void
Pure_from_neighbor_engraver::acknowledge_item (Grob_info i)
{
- if (!Pure_from_neighbor_interface::has_interface (i.item ()))
+ if (!has_interface<Pure_from_neighbor_interface> (i.item ()))
pure_relevants_.push_back (i.item ());
}
if (!g || !m)
continue;
- if (Rhythmic_head::has_interface (g) && (*m) > now)
+ if (has_interface<Rhythmic_head> (g) && (*m) > now)
{
Grob *column = g->get_parent (X_AXIS);
if (!column)
// Only include rests that start now. Include notes that started any time.
Paper_column *paper_column = dynamic_cast<Item *> (column)->get_column ();
- if (!Rest::has_interface (g) || !paper_column || Paper_column::when_mom (paper_column) == now)
+ if (!has_interface<Rest> (g) || !paper_column || Paper_column::when_mom (paper_column) == now)
{
columns.insert (column);
rest_count += Note_column::has_rests (column);
if (scm_is_number (offset))
rest_grob->translate_axis (scm_to_double (offset), Y_AXIS);
- if (Note_column::has_interface (parent) && Note_column::has_rests (parent))
+ if (has_interface<Note_column> (parent) && Note_column::has_rests (parent))
{
Grob *collision = unsmob<Grob> (parent->get_object ("rest-collision"));
for (vsize i = 0; i < elts.size (); i++)
{
Grob *e = elts[i];
- if (Note_column::has_interface (e))
+ if (has_interface<Note_column> (e))
{
if (unsmob<Grob> (e->get_object ("rest")))
rests.push_back (e);
/*
Don't want to consider scripts horizontally next to notes.
*/
- if (Accidental_placement::has_interface (sc)
- || Arpeggio::has_interface (sc))
+ if (has_interface<Accidental_placement> (sc)
+ || has_interface<Arpeggio> (sc))
{
affect_all_grobs.push_back (sc);
}
struct Text_script
{
- DECLARE_GROB_INTERFACE ();
};
ADD_INTERFACE (Text_script,
if (script_row_)
{
for (vsize i = 0; i < scripts_.size (); i++)
- if (Accidental_placement::has_interface (scripts_[i])
+ if (has_interface<Accidental_placement> (scripts_[i])
|| Side_position_interface::get_axis (scripts_[i]) == X_AXIS)
Script_column::add_side_positioned (script_row_, scripts_[i]);
}
{
Grob *him = me->get_parent (a);
Interval he;
- if (Paper_column::has_interface (him))
+ if (has_interface<Paper_column> (him))
/*
PaperColumn extents aren't reliable (they depend on size and alignment
of PaperColumn's children), so we align on NoteColumn instead.
else
{
if (to_boolean (me->get_property ("X-align-on-main-noteheads"))
- && Note_column::has_interface (him))
+ && has_interface<Note_column> (him))
he = Note_column::calc_main_extent(him);
else
he = him->extent (him, a);
(void) me->get_property ("direction");
Grob *yparent = me->get_parent (Y_AXIS);
- if (Semi_tie_column::has_interface (yparent))
+ if (has_interface<Semi_tie_column> (yparent))
{
/* trigger positioning. */
yparent->get_property ("positioning-done");
{
Item *it = i.item ();
- if (Note_spacing::has_interface (it))
+ if (has_interface<Note_spacing> (it))
{
current_spacings_.note_spacings_.push_back (it);
return;
vector<Grob *> other_elts; // for now only arpeggios
for (vsize i = 0; i < read_only_elts.size (); i++)
{
- if (Accidental_placement::has_interface (read_only_elts[i]))
+ if (has_interface<Accidental_placement> (read_only_elts[i]))
accidental_elts.push_back (read_only_elts[i]);
else
other_elts.push_back (read_only_elts[i]);
bounds all of them). However, we can't exclude an axis-group that
adds to its childrens' stencil. Currently, this is just TrillPitchGroup;
hence the check for note-head-interface. */
- if (Axis_group_interface::has_interface (il)
- && !Note_head::has_interface (il))
+ if (has_interface<Axis_group_interface> (il)
+ && !has_interface<Note_head> (il))
continue;
Interval y (il->pure_y_extent (ycommon, 0, very_large));
for (vsize i = 0; i < proto_support.size (); i++)
{
- if (Accidental_placement::has_interface (proto_support[i]))
+ if (has_interface<Accidental_placement> (proto_support[i]))
{
Grob *accs = proto_support[i];
for (SCM acs = accs->get_object ("accidental-grobs"); scm_is_pair (acs);
continue; // so 'me' may not move in response to 'e'
if (a == Y_AXIS
- && Stem::has_interface (e))
+ && has_interface<Stem> (e))
{
// If called as 'pure' we may not force a stem to set its direction,
if (pure && !is_direction (e->get_property_data ("direction")))
: e->maybe_pure_coordinate (common[Y_AXIS], Y_AXIS, pure, start, end);
Skyline_pair copy = *unsmob<Skyline_pair> (sp);
if (a == Y_AXIS
- && Stem::has_interface (e)
+ && has_interface<Stem> (e)
&& to_boolean (me->get_maybe_pure_property ("add-stem-support", pure, start, end)))
copy[dir].set_minimum_height (copy[dir].max_height ());
copy.shift (a == X_AXIS ? yc : xc);
staff_span.widen (1);
if (staff_span.contains (position)
/* If we are between notehead and staff, quantize for ledger lines. */
- || (Note_head::has_interface (head)
+ || (has_interface<Note_head> (head)
&& dir * position < 0))
{
total_off += (rounded - position) * 0.5 * ss;
// we find forbidden attachments
vector<Offset> forbidden_attachments;
for (vsize i = 0; i < state.extra_encompass_infos_.size (); i++)
- if (Tie::has_interface (state.extra_encompass_infos_[i].grob_))
+ if (has_interface<Tie> (state.extra_encompass_infos_[i].grob_))
{
Grob *t = state.extra_encompass_infos_[i].grob_;
Grob *common_x = Grob::get_vertical_axis_group (t);
for (LEFT_and_RIGHT (d))
{
extremes[d].bound_ = slur_->get_bound (d);
- if (Note_column::has_interface (extremes[d].bound_))
+ if (has_interface<Note_column> (extremes[d].bound_))
{
extremes[d].note_column_ = extremes[d].bound_;
extremes[d].stem_ = Note_column::get_stem (extremes[d].note_column_);
ly_symbol2scm ("inside"))
&& minmax (dir_, encompass_place, y_place) == encompass_place
&& (!extra_encompass_infos_[i].grob_->internal_has_interface (ly_symbol2scm ("key-signature-interface"))
- && !Clef::has_interface (extra_encompass_infos_[i].grob_)
+ && !has_interface<Clef> (extra_encompass_infos_[i].grob_)
&& !extra_encompass_infos_[i].grob_->internal_has_interface (ly_symbol2scm ("time-signature-interface"))))
{
for (LEFT_and_RIGHT (d))
extract_grob_set (slur_, "encompass-objects", extra_encompasses);
for (vsize i = 0; i < extra_encompasses.size (); i++)
{
- if (Slur::has_interface (extra_encompasses[i]))
+ if (has_interface<Slur> (extra_encompasses[i]))
{
Grob *small_slur = extra_encompasses[i];
Bezier b = Slur::get_curve (small_slur);
vector<Extra_collision_info> collision_infos;
for (vsize i = encompasses.size (); i--;)
{
- if (Slur::has_interface (encompasses[i]))
+ if (has_interface<Slur> (encompasses[i]))
{
Spanner *small_slur = dynamic_cast<Spanner *> (encompasses[i]);
Bezier b = Slur::get_curve (small_slur);
Grob *g = encompasses [i];
Interval xe = g->extent (common_[X_AXIS], X_AXIS);
Interval ye = g->extent (common_[Y_AXIS], Y_AXIS);
- if (Dots::has_interface (g))
+ if (has_interface<Dots> (g))
ye.widen (0.2);
Real xp = 0.0;
Real penalty = parameters_.extra_object_collision_penalty_;
- if (Accidental_interface::has_interface (g))
+ if (has_interface<Accidental_interface> (g))
{
penalty = parameters_.accidental_collision_;
{
Grob *g = extra_objects[i];
- if (Separation_item::has_interface (g))
+ if (has_interface<Separation_item> (g))
{
extract_grob_set (g, "elements", breakables);
for (vsize j = 0; j < breakables.size (); j++)
else
slur = slurs[0];
- if (Tie::has_interface (e)
+ if (has_interface<Tie> (e)
|| scm_is_eq (avoid, ly_symbol2scm ("inside")))
{
for (vsize i = slurs.size (); i--;)
so we can ignore them here */
vector<Grob *> non_sep_extras;
for (vsize i = 0; i < extras.size (); i++)
- if (!Separation_item::has_interface (extras[i]))
+ if (!has_interface<Separation_item> (extras[i]))
non_sep_extras.push_back (extras[i]);
Grob *common = common_refpoint_of_array (cols, me, Y_AXIS);
for (vsize i = elts.size (); i--;)
{
Grob *g = elts[i];
- if (g && Break_alignment_interface::has_interface (g))
+ if (has_interface<Break_alignment_interface> (g))
{
extract_grob_set (g, "elements", gelts);
for (vsize j = gelts.size (); j--;)
|| Spacing_interface::right_column (sp) != rc)
continue;
- if (Note_spacing::has_interface (sp))
+ if (has_interface<Note_spacing> (sp))
{
/*
The note spacing should be taken from the musical
dists[d] = max (dists[d], spring.min_distance ());
}
- else if (Staff_spacing::has_interface (sp))
+ else if (has_interface<Staff_spacing> (sp))
{
Spring spring = Staff_spacing::get_spacing (sp, rc, 0.0);
if (Item *piece = g->find_prebroken_piece (break_dirs[d]))
g = piece;
- if (g && Separation_item::has_interface (g) && g->get_column () == columns[d])
+ if (has_interface<Separation_item> (g) && g->get_column () == columns[d])
{
SCM sky_scm = g->get_property ("horizontal-skylines");
Skyline_pair *sky = unsmob<Skyline_pair> (sky_scm);
for (vsize i = 0; i < elts.size (); i++)
{
- if (Note_column::has_interface (elts[i]))
+ if (has_interface<Note_column> (elts[i]))
ret.push_back (dynamic_cast<Item *> (elts[i]));
- else if (Separation_item::has_interface (elts[i]))
+ else if (has_interface<Separation_item> (elts[i]))
{
extract_grob_set (elts[i], "elements", more_elts);
vector<Item *> ncs = get_note_columns (more_elts);
{
Spring spring = Spacing_spanner::note_spacing (spacing, loose_col,
next_col, &options);
- if (Note_spacing::has_interface (spacing))
+ if (has_interface<Note_spacing> (spacing))
spring = Note_spacing::get_spacing (spacing, next_col,
spring, options.increment_);
/*
This is probably a waste of time in the case of polyphonic
music. */
- if (found_matching_column && Note_spacing::has_interface (wish))
+ if (found_matching_column && has_interface<Note_spacing> (wish))
{
Real inc = options->increment_;
Grob *gsp = unsmob<Grob> (left_col->get_object ("grace-spacing"));
{
Item *spacing_grob = dynamic_cast<Item *> (wishes[i]);
- if (!spacing_grob || !Staff_spacing::has_interface (spacing_grob))
+ if (!spacing_grob || !has_interface<Staff_spacing> (spacing_grob))
continue;
/*
Real
Staff_spacing::optical_correction (Grob *me, Grob *g, Interval bar_height)
{
- if (!g || !Note_column::has_interface (g))
+ if (!g || !has_interface<Note_column> (g))
return 0;
Grob *stem = Note_column::get_stem (g);
Grob *
Staff_symbol_referencer::get_staff_symbol (Grob *me)
{
- if (Staff_symbol::has_interface (me))
+ if (has_interface<Staff_symbol> (me))
return me;
SCM st = me->get_object ("staff-symbol");
*/
Grob *maybe_nc = stem->get_parent (X_AXIS)->get_parent (X_AXIS);
bool whole_note = Stem::duration_log (stem) <= 0;
- if (whole_note && Note_collision_interface::has_interface (maybe_nc))
+ if (whole_note && has_interface<Note_collision_interface> (maybe_nc))
{
Drul_array<bool> avoid_me (false, false);
vector<int> all_nhps = Note_collision_interface::note_head_positions (maybe_nc);
{
n->set_object ("stem", me->self_scm ());
- if (Note_head::has_interface (n))
+ if (has_interface<Note_head> (n))
Pointer_group_interface::add_grob (me, ly_symbol2scm ("note-heads"), n);
- else if (Rest::has_interface (n))
+ else if (has_interface<Rest> (n))
Pointer_group_interface::add_grob (me, ly_symbol2scm ("rests"), n);
}
vector<Grob *> vertical_skyline_grobs;
extract_grob_set (me_grob, "elements", my_elts);
for (vsize i = 0; i < my_elts.size (); i++)
- if (System_start_delimiter::has_interface (my_elts[i]))
+ if (has_interface<System_start_delimiter> (my_elts[i]))
vertical_skyline_grobs.push_back (my_elts[i]);
System *me = dynamic_cast<System *> (me_grob);
extract_grob_set (align, "elements", elts);
for (vsize i = 0; i < elts.size (); i++)
- if (Hara_kiri_group_spanner::has_interface (elts[i]))
+ if (has_interface<Hara_kiri_group_spanner> (elts[i]))
vertical_skyline_grobs.push_back (elts[i]);
SCM grobs_scm = Grob_array::make_array ();
extract_grob_set (me, "elements", elts);
Grob *ret = 0;
for (vsize i = 0; i < elts.size (); i++)
- if (Align_interface::has_interface (elts[i]))
+ if (has_interface<Align_interface> (elts[i]))
{
if (ret)
me->programming_error ("found multiple vertical alignments in this system");
vsize end = (dir == UP) ? elts.size () : VPOS;
for (vsize i = start; i != end; i += dir)
{
- if (Hara_kiri_group_spanner::has_interface (elts[i]))
+ if (has_interface<Hara_kiri_group_spanner> (elts[i]))
Hara_kiri_group_spanner::consider_suicide (elts[i]);
Interval intersection = elts[i]->extent (this, X_AXIS);
if (elts[i] == vertical_axis_group)
return out;
- if (Hara_kiri_group_spanner::has_interface (elts[i]))
+ if (has_interface<Hara_kiri_group_spanner> (elts[i]))
Hara_kiri_group_spanner::consider_suicide (elts[i]);
bounds.intersect (elts[i]->spanned_rank_interval ());
for (vsize i = 0; i < elts.size (); ++i)
{
- if (!Axis_group_interface::has_interface (elts[i]))
+ if (!has_interface<Axis_group_interface> (elts[i]))
{
relevant_grobs.push_back (elts[i]);
Spanner *me = dynamic_cast<Spanner *> (tc);
if (tie->get_parent (Y_AXIS)
- && Tie_column::has_interface (tie->get_parent (Y_AXIS)))
+ && has_interface<Tie_column> (tie->get_parent (Y_AXIS)))
return;
if (!me->get_bound (LEFT)
for (vsize i = 0; i < bounds.size (); i++)
{
Grob *head = bounds[i];
- if (!Note_head::has_interface (head))
+ if (!has_interface<Note_head> (head))
continue;
if (!stem)
Tie::head (Spanner *me, Direction d)
{
Item *it = me->get_bound (d);
- return Note_head::has_interface (it) ? it : 0;
+ return has_interface<Note_head> (it) ? it : 0;
}
int
// types. It might be clearer to use a template.
Grob *me = unsmob<Grob> (smob);
Grob *yparent = me->get_parent (Y_AXIS);
- if ((Tie_column::has_interface (yparent)
- || Semi_tie_column::has_interface (yparent))
+ if ((has_interface<Tie_column> (yparent)
+ || has_interface<Semi_tie_column> (yparent))
&& unsmob<Grob_array> (yparent->get_object ("ties"))
// && unsmob<Grob_array> (yparent->get_object ("ties"))->size () > 1
)
Spanner *me = LY_ASSERT_SMOB(Spanner, smob, 1);
Grob *yparent = me->get_parent (Y_AXIS);
- if ((Tie_column::has_interface (yparent)
- || Semi_tie_column::has_interface (yparent))
+ if ((has_interface<Tie_column> (yparent)
+ || has_interface<Semi_tie_column> (yparent))
&& unsmob<Grob_array> (yparent->get_object ("ties")))
{
extract_grob_set (yparent, "ties", ties);
{
Spanner *me = dynamic_cast<Spanner *> (me_grob);
Item *g = me->get_bound (hdir);
- if (Note_column::has_interface (g)
+ if (has_interface<Note_column> (g)
&& Note_column::get_stem (g)
&& Note_column::dir (g) == my_dir)
g = Note_column::get_stem (g);
for (LEFT_and_RIGHT (d))
{
- if (Note_column::has_interface (bounds[d])
+ if (has_interface<Note_column> (bounds[d])
&& Note_column::get_stem (bounds[d]))
bounds[d] = Note_column::get_stem (bounds[d]);
bound_poss[d] = Axis_group_interface::generic_bound_extent (bounds[d], commonx, X_AXIS)[-d];
{
int sz = i.origin_contexts ((Translator *)this).size ();
- return sz > 0 && Axis_group_interface::has_interface (i.grob ())
+ return sz > 0 && has_interface<Axis_group_interface> (i.grob ())
&& !i.grob ()->get_parent (Y_AXIS)
&& !to_boolean (i.grob ()->get_property ("no-alignment"))
&& Axis_group_interface::has_axis (i.grob (), Y_AXIS);
projects / lilypond.git / commitdiff