- {
- /*
- event_dir == LEFT: left edge of a beamsegment.
- */
- Direction event_dir = LEFT;
- do
- {
- bool on_line_bound = (segs[j].dir_ == LEFT) ? segs[j].stem_index_ == 0
- : segs[j].stem_index_ == stems.size() - 1;
- bool on_beam_bound = (event_dir == LEFT) ? j == 0 :
- j == segs.size () - 1;
- bool inside_stem = (event_dir == LEFT)
- ? segs[j].stem_index_ > 0
- : segs[j].stem_index_ + 1 < stems.size () ;
-
- bool event = on_beam_bound
- || abs (segs[j].rank_ - segs[j+event_dir].rank_) > 1
- || (abs (vertical_count) >= segs[j].max_connect_
- || abs (vertical_count) >= segs[j + event_dir].max_connect_);
-
- if (!event)
- continue;
-
- current.vertical_count_ = vertical_count;
- current.horizontal_[event_dir] = segs[j].stem_x_;
- if (segs[j].dir_ == event_dir)
- {
- if (on_line_bound
- && me->get_bound (event_dir)->break_status_dir ())
- {
- current.horizontal_[event_dir]
- = (robust_relative_extent (me->get_bound (event_dir),
- commonx, X_AXIS)[RIGHT]
- + event_dir * break_overshoot[event_dir]);
- }
- else
- {
- Real notehead_width =
- Stem::duration_log (segs[j].stem_) == 1
- ? 1.98
- : 1.32; // URG.
-
-
- if (inside_stem)
- {
- Grob *neighbor_stem = stems[segs[j].stem_index_ + event_dir];
- Real neighbor_stem_x
- = neighbor_stem->relative_coordinate (commonx, X_AXIS);
-
- notehead_width = min (notehead_width,
- fabs (neighbor_stem_x - segs[j].stem_x_)/2.5);
- }
- current.horizontal_[event_dir] += event_dir * notehead_width;
- }
- }
- else
- {
- current.horizontal_[event_dir] += event_dir * segs[j].width_/2;
- if (segs[j].gapped_)
- {
- current.horizontal_[event_dir] -= event_dir * gap_length;
-
- if (Stem::is_invisible (segs[j].stem_))
- {
- /*
- Need to do this in case of whole notes. We don't want the
- heads to collide with the beams.
- */
- extract_grob_set (segs[j].stem_, "note-heads", heads);
-
- for (vsize k = 0; k < heads.size (); k ++)
- current.horizontal_[event_dir]
- = event_dir * min (event_dir * current.horizontal_[event_dir],
- - gap_length/2
- + event_dir
- * heads[k]->extent (commonx,
- X_AXIS)[-event_dir]);
- }
- }
- }
-
- if (event_dir == RIGHT)
- {
- segments.push_back (current);
- current = Beam_segment ();
- }
- }
- while (flip (&event_dir) != LEFT);
- }
-
+ {
+ // Keeping track of the different directions here is a little tricky.
+ // segs[j].dir_ is the direction of the beam segment relative to the stem
+ // (ie. segs[j].dir_ == LEFT if the beam segment sticks out to the left of
+ // its stem) whereas event_dir refers to the edge of the beam segment that
+ // we are currently looking at (ie. if segs[j].dir_ == event_dir then we
+ // are looking at that edge of the beam segment that is furthest from its
+ // stem).
+ Beam_stem_segment const &seg = segs[j];
+ for (LEFT_and_RIGHT (event_dir))
+ {
+ Beam_stem_segment const &neighbor_seg = segs[j + event_dir];
+ // TODO: make names clearer? --jneem
+ // on_line_bound: whether the current segment is on the boundary of the WHOLE beam
+ // on_beam_bound: whether the current segment is on the boundary of just that part
+ // of the beam with the current beam_rank
+ bool on_line_bound = (seg.dir_ == LEFT) ? seg.stem_index_ == 0
+ : seg.stem_index_ == stems.size () - 1;
+ bool on_beam_bound = (event_dir == LEFT) ? j == 0
+ : j == segs.size () - 1;
+ bool inside_stem = (event_dir == LEFT)
+ ? seg.stem_index_ > 0
+ : seg.stem_index_ + 1 < stems.size ();
+
+ bool event = on_beam_bound
+ || abs (seg.rank_ - neighbor_seg.rank_) > 1
+ || (abs (vertical_count) >= seg.max_connect_
+ || abs (vertical_count) >= neighbor_seg.max_connect_);
+
+ if (!event)
+ // Then this edge of the current segment is irrelevant because it will
+ // be connected with the next segment in the event_dir direction.
+ // If we skip the left edge here, the right edge of
+ // the previous segment has already been skipped since
+ // the conditions are symmetric
+ continue;
+
+ current.vertical_count_ = vertical_count;
+ current.horizontal_[event_dir] = seg.stem_x_;
+ if (seg.dir_ == event_dir)
+ // then we are examining the edge of a beam segment that is furthest
+ // from its stem.
+ {
+ if (on_line_bound
+ && me->get_bound (event_dir)->break_status_dir ())
+ {
+ current.horizontal_[event_dir]
+ = (Axis_group_interface::generic_bound_extent (me->get_bound (event_dir),
+ commonx, X_AXIS)[RIGHT]
+ + event_dir * break_overshoot[event_dir]);
+ }
+ else
+ {
+ Grob *stem = stems[seg.stem_index_];
+ Drul_array<Real> beamlet_length
+ = robust_scm2interval (stem->get_property ("beamlet-default-length"), Interval (1.1, 1.1));
+ Drul_array<Real> max_proportion
+ = robust_scm2interval (stem->get_property ("beamlet-max-length-proportion"), Interval (0.75, 0.75));
+ Real length = beamlet_length[seg.dir_];
+
+ if (inside_stem)
+ {
+ Grob *neighbor_stem = stems[seg.stem_index_ + event_dir];
+ Real neighbor_stem_x = neighbor_stem->relative_coordinate (commonx, X_AXIS);
+
+ length = min (length,
+ fabs (neighbor_stem_x - seg.stem_x_) * max_proportion[seg.dir_]);
+ }
+ current.horizontal_[event_dir] += event_dir * length;
+ }
+ }
+ else
+ // we are examining the edge of a beam segment that is closest
+ // (ie. touching, unless there is a gap) its stem.
+ {
+ current.horizontal_[event_dir] += event_dir * seg.width_ / 2;
+ if (seg.gapped_)
+ {
+ current.horizontal_[event_dir] -= event_dir * gap_lengths[event_dir];
+
+ if (Stem::is_invisible (seg.stem_))
+ {
+ /*
+ Need to do this in case of whole notes. We don't want the
+ heads to collide with the beams.
+ */
+ extract_grob_set (seg.stem_, "note-heads", heads);
+
+ for (vsize k = 0; k < heads.size (); k++)
+ current.horizontal_[event_dir]
+ = event_dir * min (event_dir * current.horizontal_[event_dir],
+ - gap_lengths[event_dir] / 2
+ + event_dir
+ * heads[k]->extent (commonx,
+ X_AXIS)[-event_dir]);
+ }
+ }
+ }
+
+ if (event_dir == RIGHT)
+ {
+ segments.push_back (current);
+ current = Beam_segment ();
+ }
+ }
+ }
+
+ }
+
+ SCM segments_scm = SCM_EOL;
+
+ for (vsize i = segments.size (); i--;)
+ {
+ segments_scm = scm_cons (scm_list_2 (scm_cons (ly_symbol2scm ("vertical-count"),
+ scm_from_int (segments[i].vertical_count_)),
+ scm_cons (ly_symbol2scm ("horizontal"),
+ ly_interval2scm (segments[i].horizontal_))),
+ segments_scm);
+ }
+
+ return segments_scm;
+}
+
+MAKE_SCHEME_CALLBACK (Beam, calc_x_positions, 1);
+SCM
+Beam::calc_x_positions (SCM smob)
+{
+ Spanner *me = unsmob_spanner (smob);
+ SCM segments = me->get_property ("beam-segments");
+ Interval x_positions;
+ x_positions.set_empty ();
+ for (SCM s = segments; scm_is_pair (s); s = scm_cdr (s))
+ x_positions.unite (robust_scm2interval (ly_assoc_get (ly_symbol2scm ("horizontal"),
+ scm_car (s),
+ SCM_EOL),
+ Interval (0.0, 0.0)));
+
+ // Case for beams without segments (i.e. uniting two skips with a beam)
+ // TODO: should issue a warning? warning likely issued downstream, but couldn't hurt...
+ if (x_positions.is_empty ())
+ {
+ extract_grob_set (me, "stems", stems);
+ Grob *common_x = common_refpoint_of_array (stems, me, X_AXIS);
+ for (LEFT_and_RIGHT (d))
+ x_positions[d] = me->relative_coordinate (common_x, X_AXIS);
+ }
+ return ly_interval2scm (x_positions);
+}
+
+vector<Beam_segment>
+Beam::get_beam_segments (Grob *me)
+{
+ SCM segments_scm = me->get_property ("beam-segments");
+ vector<Beam_segment> segments;
+ for (SCM s = segments_scm; scm_is_pair (s); s = scm_cdr (s))
+ {
+ segments.push_back (Beam_segment ());
+ segments.back ().vertical_count_ = robust_scm2int (ly_assoc_get (ly_symbol2scm ("vertical-count"), scm_car (s), SCM_EOL), 0);
+ segments.back ().horizontal_ = robust_scm2interval (ly_assoc_get (ly_symbol2scm ("horizontal"), scm_car (s), SCM_EOL), Interval (0.0, 0.0));