- {
- /*
- The case that the right part is broken as well is rather
- rare, but it is possible, eg. with a single empty measure,
- or if one staff finishes a tad earlier than the rest.
- */
- Item *lb = l->find_prebroken_piece (RIGHT);
- Item *rb = r->find_prebroken_piece (LEFT);
-
- if (i == 0 && Paper_column::get_rank (l) == 0)
- l = 0;
-
- if (l && r)
- breakable_column_spacing (me, l, r, options);
-
- if (lb && r)
- breakable_column_spacing (me, lb, r, options);
-
- if (l && rb)
- breakable_column_spacing (me, l, rb, options);
-
- if (lb && rb)
- breakable_column_spacing (me, lb, rb, options);
- }
+ musical_column_spacing (me, left_col, right_col, options);
+
+ if (Item *rb = right_col->find_prebroken_piece (LEFT))
+ musical_column_spacing (me, left_col, rb, options);
+ }
+ else
+ {
+ /*
+ The case that the right part is broken as well is rather
+ rare, but it is possible, eg. with a single empty measure,
+ or if one staff finishes a tad earlier than the rest.
+ */
+ Item *lb = left_col->find_prebroken_piece (RIGHT);
+ Item *rb = right_col->find_prebroken_piece (LEFT);
+
+ if (left_col && right_col)
+ breakable_column_spacing (me, left_col, right_col, options);
+
+ if (lb && right_col)
+ breakable_column_spacing (me, lb, right_col, options);
+
+ if (left_col && rb)
+ breakable_column_spacing (me, left_col, rb, options);
+
+ if (lb && rb)
+ breakable_column_spacing (me, lb, rb, options);
+ }
+}
+
+static void
+set_column_rods (vector<Grob *> const &cols, Real padding)
+{
+ /* distances[i] will be the distance betwen cols[i-1] and cols[i], and
+ overhangs[j] the amount by which cols[0 thru j] extend beyond cols[j]
+ when each column is placed as far to the left as possible. */
+ vector<Real> distances (cols.size ());
+ vector<Real> overhangs (cols.size ());
+
+ for (vsize i = 0; i < cols.size (); i++)
+ {
+ Item *r = dynamic_cast<Item *> (cols[i]);
+ Item *rb = r->find_prebroken_piece (LEFT);
+
+ if (Separation_item::is_empty (r) && (!rb || Separation_item::is_empty (rb)))
+ continue;
+
+ Skyline_pair *skys = unsmob<Skyline_pair> (r->get_property ("horizontal-skylines"));
+ overhangs[i] = skys ? (*skys)[RIGHT].max_height () : 0.0;
+
+ if (0 == i) continue;
+
+ /* min rather than max because stickout will be negative if the right-hand column
+ sticks out a lot to the left */
+ Real stickout = min (skys ? (*skys)[LEFT].max_height () : 0.0,
+ Separation_item::conditional_skyline (r, cols[i - 1]).max_height ());
+
+ Real prev_distances = 0.0;
+
+ /* This is an inner loop and hence it is potentially quadratic. However, we only continue
+ as long as there is a rod to insert. Therefore, this loop will usually only execute
+ a constant number of times per iteration of the outer loop. */
+ for (vsize j = i; j--;)
+ {
+ if (overhangs[j] + padding <= prev_distances + distances[i] + stickout)
+ break; // cols[0 thru j] cannot reach cols[i]
+
+ Item *l = dynamic_cast<Item *> (cols[j]);
+ Item *lb = l->find_prebroken_piece (RIGHT);
+
+ Real dist = Separation_item::set_distance (l, r, padding);
+ distances[i] = max (distances[i], dist - prev_distances);
+
+ if (lb)
+ {
+ dist = Separation_item::set_distance (lb, r, padding);
+ // The left-broken version might reach more columns to the
+ // right than the unbroken version, by extending farther and/or
+ // nesting more closely;
+ if (j == i - 1) // check this, the first time we see each lb.
+ overhangs[j] = max (overhangs[j],
+ lb->extent (lb, X_AXIS)[RIGHT]
+ + distances[i] - dist);
+ }
+ if (rb)
+ Separation_item::set_distance (l, rb, padding);
+ if (lb && rb)
+ Separation_item::set_distance (lb, rb, padding);
+
+ prev_distances += distances[j];
+ }
+ overhangs[i] = max (overhangs[i],
+ overhangs[i - 1] - distances[i]);