/*
This file is part of LilyPond, the GNU music typesetter.
- Copyright (C) 1998--2011 Han-Wen Nienhuys <hanwen@xs4all.nl>
+ Copyright (C) 1998--2012 Han-Wen Nienhuys <hanwen@xs4all.nl>
LilyPond is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include <cmath> // ceil.
#include <algorithm>
+#include <set>
+#include <map>
using namespace std;
+#include "accidental-interface.hh"
+#include "accidental-placement.hh"
#include "axis-group-interface.hh"
#include "directional-element-interface.hh"
#include "grob.hh"
#include "main.hh"
#include "misc.hh"
#include "note-head.hh"
+#include "note-column.hh"
#include "pointer-group-interface.hh"
+#include "skyline-pair.hh"
#include "staff-symbol-referencer.hh"
#include "staff-symbol.hh"
#include "stem.hh"
Pointer_group_interface::add_unordered_grob (me, ly_symbol2scm ("side-support-elements"), e);
}
+SCM
+finish_offset (Grob *me, Direction dir, Real total_off, Real *current_offset)
+{
+ Real ss = Staff_symbol_referencer::staff_space (me);
+ Real minimum_space = ss * robust_scm2double (me->get_property ("minimum-space"), -1);
+ total_off += dir * ss * robust_scm2double (me->get_property ("padding"), 0);
+
+ if (minimum_space >= 0
+ && dir
+ && total_off * dir < minimum_space)
+ total_off = minimum_space * dir;
+
+ if (current_offset)
+ total_off = dir * max (dir * total_off,
+ dir * (*current_offset));
+
+ /* FIXME: 1000 should relate to paper size. */
+ if (fabs (total_off) > 1000)
+ {
+ string msg
+ = String_convert::form_string ("Improbable offset for grob %s: %f",
+ me->name ().c_str (), total_off);
+
+ programming_error (msg);
+ if (strict_infinity_checking)
+ scm_misc_error (__FUNCTION__, "Improbable offset.", SCM_EOL);
+ }
+
+ return scm_from_double (total_off);
+}
+
+set<Grob *>
+get_support_set (Grob *me)
+{
+ // Only slightly kludgy heuristic...
+ // We want to make sure that all AccidentalPlacements'
+ // accidentals make it into the side support
+ extract_grob_set (me, "side-support-elements", proto_support);
+ set<Grob *> support;
+
+ for (vsize i = 0; i < proto_support.size (); i++)
+ {
+ if (Accidental_placement::has_interface (proto_support[i]))
+ {
+ Grob *accs = proto_support[i];
+ for (SCM acs = accs->get_object ("accidental-grobs"); scm_is_pair (acs);
+ acs = scm_cdr (acs))
+ for (SCM s = scm_cdar (acs); scm_is_pair (s); s = scm_cdr (s))
+ {
+ Grob *a = unsmob_grob (scm_car (s));
+ support.insert (a);
+ }
+ }
+ else
+ support.insert (proto_support[i]);
+ }
+ return support;
+}
+
/* Put the element next to the support, optionally taking in
account the extent of the support.
bool pure, int start, int end,
Real *current_offset)
{
- Real ss = Staff_symbol_referencer::staff_space (me);
-
- extract_grob_set (me, "side-support-elements", support);
+ set<Grob *> support = get_support_set (me);
Grob *common = common_refpoint_of_array (support, me->get_parent (a), a);
Grob *staff_symbol = Staff_symbol_referencer::get_staff_symbol (me);
Direction dir = get_grob_direction (me);
- for (vsize i = 0; i < support.size (); i++)
+ set<Grob *>::iterator it;
+
+ for (it = support.begin (); it != support.end (); it++)
{
- Grob *e = support[i];
+ Grob *e = *it;
// In the case of a stem, we will find a note head as well
// ignoring the stem solves cyclic dependencies if the stem is
dim = Interval (0, 0);
Real off = me->get_parent (a)->maybe_pure_coordinate (common, a, pure, start, end);
- Real minimum_space = ss * robust_scm2double (me->get_property ("minimum-space"), -1);
Real total_off = dim.linear_combination (dir) - off;
- total_off += dir * ss * robust_scm2double (me->get_property ("padding"), 0);
-
- if (minimum_space >= 0
- && dir
- && total_off * dir < minimum_space)
- total_off = minimum_space * dir;
-
if (include_my_extent)
{
Interval iv = me->maybe_pure_extent (me, a, pure, start, end);
}
}
- if (current_offset)
- total_off = dir * max (dir * total_off,
- dir * (*current_offset));
+ return finish_offset (me, dir, total_off, current_offset);
+}
- /* FIXME: 1000 should relate to paper size. */
- if (fabs (total_off) > 1000)
+SCM
+Side_position_interface::skyline_side_position (Grob *me, Axis a,
+ bool pure, int start, int end,
+ Real *current_offset)
+{
+ set<Grob *> support = get_support_set (me);
+
+ Grob *common[2];
+ for (Axis ax = X_AXIS; ax < NO_AXES; incr (ax))
+ common[ax] = common_refpoint_of_array (support, ax == a ? me->get_parent (ax) : me, ax);
+
+ Grob *staff_symbol = Staff_symbol_referencer::get_staff_symbol (me);
+ Direction dir = get_grob_direction (me);
+
+ Skyline my_dim;
+ Skyline_pair *sp = Skyline_pair::unsmob (me->get_property ("vertical-skylines"));
+ if (sp && a == Y_AXIS && !pure)
{
- string msg
- = String_convert::form_string ("Improbable offset for grob %s: %f",
- me->name ().c_str (), total_off);
+ Skyline_pair copy = Skyline_pair (*sp);
+ copy.shift (me->relative_coordinate (common[X_AXIS], X_AXIS));
+ copy.raise (me->get_parent (Y_AXIS)->relative_coordinate (common[Y_AXIS], Y_AXIS));
+ my_dim = copy[-dir];
+ }
+ else
+ {
+ Box off;
+ for (Axis ax = X_AXIS; ax < NO_AXES; incr (ax))
+ {
+ if (ax == a)
+ off[ax] = me->get_parent (ax)->maybe_pure_coordinate (common[ax], ax, pure, start, end)
+ + me->maybe_pure_extent (me, ax, pure, start, end);
+ else
+ off[ax] = me->maybe_pure_extent (common[ax], ax, pure, start, end);
+ }
- programming_error (msg);
- if (strict_infinity_checking)
- scm_misc_error (__FUNCTION__, "Improbable offset.", SCM_EOL);
+ if (off[X_AXIS].is_empty () || off[Y_AXIS].is_empty ())
+ return scm_from_double (0.0);
+
+ my_dim = Skyline (off, other_axis (a), -dir);
}
+ bool include_staff
+ = staff_symbol
+ && a == Y_AXIS
+ && scm_is_number (me->get_property ("staff-padding"))
+ && !to_boolean (me->get_property ("quantize-position"));
- return scm_from_double (total_off);
+ vector<Box> boxes;
+ vector<Skyline_pair> skyps;
+ Real min_h = dir == LEFT ? infinity_f : -infinity_f;
+ set<Grob *>::iterator it;
+
+ map<Grob *, vector<Grob *> > note_column_map; // for parts of a note column
+ for (it = support.begin (); it != support.end (); it++)
+ {
+ Grob *e = *it;
+
+ // In the case of a stem, we will find a note head as well
+ // ignoring the stem solves cyclic dependencies if the stem is
+ // attached to a cross-staff beam.
+ if (a == Y_AXIS
+ && Stem::has_interface (e)
+ && dir == - get_grob_direction (e))
+ continue;
+
+ if (e)
+ {
+ if (Note_column::has_interface (e->get_parent (X_AXIS))
+ && to_boolean (me->get_property ("add-stem-support")))
+ {
+ note_column_map[e->get_parent (X_AXIS)].push_back (e);
+ continue;
+ }
+
+ Skyline_pair *sp = Skyline_pair::unsmob (e->get_property ("vertical-skylines"));
+ if (sp && a == Y_AXIS && !pure)
+ {
+ Skyline_pair copy = Skyline_pair (*sp);
+ copy.shift (e->relative_coordinate (common[X_AXIS], X_AXIS));
+ copy.raise (e->relative_coordinate (common[Y_AXIS], Y_AXIS));
+ skyps.push_back (copy);
+ continue;
+ }
+ Box b;
+ for (Axis ax = X_AXIS; ax < NO_AXES; incr (ax))
+ b[ax] = e->maybe_pure_extent (common[ax], ax, pure, start, end);
+
+ if (b[X_AXIS].is_empty () || b[Y_AXIS].is_empty ())
+ continue;
+
+ boxes.push_back (b);
+ min_h = minmax (dir, b[a][-dir], min_h);
+ }
+ }
+
+ // this loop ensures that parts of a note column will be in the same box
+ // pushes scripts and such over stems instead of just over heads
+ for (map<Grob *, vector<Grob *> >::iterator i = note_column_map.begin (); i != note_column_map.end (); i++)
+ {
+ Box big;
+ for (vsize j = 0; j < (*i).second.size (); j++)
+ {
+ Grob *e = (*i).second[j];
+ Box b;
+ for (Axis ax = X_AXIS; ax < NO_AXES; incr (ax))
+ b[ax] = e->maybe_pure_extent (common[ax], ax, pure, start, end);
+
+ if (b[X_AXIS].is_empty () || b[Y_AXIS].is_empty ())
+ continue;
+
+ big.unite (b);
+ }
+ if (!big[X_AXIS].is_empty () && !big[Y_AXIS].is_empty ())
+ boxes.push_back (big);
+ }
+
+ Skyline dim (boxes, other_axis (a), dir);
+ if (skyps.size ())
+ {
+ Skyline_pair merged (skyps);
+ dim.merge (merged[dir]);
+ }
+ if (!boxes.size ())
+ dim.set_minimum_height (0.0);
+ else
+ dim.set_minimum_height (min_h);
+
+ if (include_staff)
+ {
+ Interval staff_extents;
+ common[Y_AXIS] = staff_symbol->common_refpoint (common[Y_AXIS], Y_AXIS);
+ staff_extents = staff_symbol->maybe_pure_extent (common[Y_AXIS], Y_AXIS, pure, start, end);
+ dim.set_minimum_height (minmax (dir, min_h, staff_extents[dir]));
+ }
+
+ Real dist = dim.distance (my_dim, 0.1); // 0.1 m4g1c value...fix...
+ Real total_off = !isinf (dist) ? dir * dist : 0.0;
+
+ return finish_offset (me, dir, total_off, current_offset);
}
MAKE_SCHEME_CALLBACK (Side_position_interface, y_aligned_on_support_refpoints, 1);
Real *current_off)
{
Direction dir = get_grob_direction (me);
+ bool skyline = to_boolean (me->get_property ("use-skylines"));
- Real o = scm_to_double (general_side_position (me, a, true, true, pure, start, end, current_off));
+ Real o = scm_to_double (skyline && !pure
+ ? skyline_side_position (me, a, pure, start, end, current_off)
+ : general_side_position (me, a, true, true, pure, start, end, current_off));
/*
Maintain a minimum distance to the staff. This is similar to side
Real rounded = directed_round (position, dir);
Grob *head = me->get_parent (X_AXIS);
- if (fabs (position) <= 2 * Staff_symbol_referencer::staff_radius (me) + 1
+ Interval staff_span = Staff_symbol::line_span (staff);
+ staff_span.widen (1);
+ if (staff_span.contains (position)
/* In case of a ledger lines, quantize even if we're outside the staff. */
|| (Note_head::has_interface (head)
" is ignored.",
/* properties */
+ "add-stem-support "
"direction "
"minimum-space "
"padding "
"side-support-elements "
"slur-padding "
"staff-padding "
+ "use-skylines "
);
projects / lilypond.git / blobdiff