X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fsimple-spacer.cc;h=9200554822b87030d8e0b6c452fd7b3fe5ba859a;hb=47db9a3883d726ca53e2133a3b2298f78dd6a32e;hp=d9413d5b8ea2ad6065912af99084363be9ed4310;hpb=f79e161e5f81421337a4f459eb8f8a6978abf9fb;p=lilypond.git diff --git a/lily/simple-spacer.cc b/lily/simple-spacer.cc index d9413d5b8e..d17fa1ed73 100644 --- a/lily/simple-spacer.cc +++ b/lily/simple-spacer.cc @@ -1,77 +1,103 @@ -/* - simple-spacer.cc -- implement Simple_spacer - - source file of the GNU LilyPond music typesetter - - (c) 1999--2004 Han-Wen Nienhuys +/* + This file is part of LilyPond, the GNU music typesetter. + + Copyright (C) 1999--2015 Han-Wen Nienhuys TODO: - add support for different stretch/shrink constants? - + + LilyPond is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + LilyPond is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with LilyPond. If not, see . */ -#include -#include -#include // isinf -#include "simple-spacer.hh" +#include + +#include "column-x-positions.hh" +#include "dimensions.hh" +#include "international.hh" +#include "libc-extension.hh" // isinf #include "paper-column.hh" +#include "simple-spacer.hh" +#include "spaceable-grob.hh" #include "spring.hh" -#include "rod.hh" #include "warn.hh" -#include "column-x-positions.hh" -#include "spaceable-grob.hh" -#include "dimensions.hh" - /* - A simple spacing constraint solver. The approach: + A simple spacing constraint solver. The approach: - Stretch the line uniformly until none of the constraints (rods) - block. It then is very wide. + Stretch the line uniformly until none of the constraints (rods) + block. It then is very wide. - Compress until the next constraint blocks, + Compress until the next constraint blocks, - Mark the springs over the constrained part to be non-active. - - Repeat with the smaller set of non-active constraints, until all - constraints blocked, or until the line is as short as desired. + Mark the springs over the constrained part to be non-active. - This is much simpler, and much much faster than full scale - Constrained QP. On the other hand, a situation like this will not - be typeset as dense as possible, because + Repeat with the smaller set of non-active constraints, until all + constraints blocked, or until the line is as short as desired. - c4 c4 c4 c4 - veryveryverylongsyllable2 veryveryverylongsyllable2 - " "4 veryveryverylongsyllable2 syllable4 + This is much simpler, and much much faster than full scale + Constrained QP. On the other hand, a situation like this will not + be typeset as dense as possible, because + c4 c4 c4 c4 + veryveryverylongsyllable2 veryveryverylongsyllable2 + " "4 veryveryverylongsyllable2 syllable4 - can be further compressed to + can be further compressed to - c4 c4 c4 c4 - veryveryverylongsyllable2 veryveryverylongsyllable2 - " "4 veryveryverylongsyllable2 syllable4 + c4 c4 c4 c4 + veryveryverylongsyllable2 veryveryverylongsyllable2 + " "4 veryveryverylongsyllable2 syllable4 - Perhaps this is not a bad thing, because the 1st looks better anyway. */ + Perhaps this is not a bad thing, because the 1st looks better anyway. */ /* - positive force = expanding, negative force = compressing. - */ Simple_spacer::Simple_spacer () { - /* - Give an extra penalty for compression. Needed to avoid compressing - tightly spaced lines. - */ - active_count_ = 0; - force_ = 0.; - indent_ =0.0; - default_space_ = 20 PT; + line_len_ = 0.0; + force_ = 0.0; + fits_ = true; + ragged_ = true; +} + +Real +Simple_spacer::force () const +{ + return force_; +} + +bool +Simple_spacer::fits () const +{ + return fits_; +} + +Real +Simple_spacer::rod_force (int l, int r, Real dist) +{ + Real d = range_ideal_len (l, r); + Real c = range_stiffness (l, r, dist > d); + Real block_stretch = dist - d; + + if (isinf (c) && block_stretch == 0) /* take care of the 0*infinity_f case */ + return 0; + return c * block_stretch; } void @@ -79,459 +105,432 @@ Simple_spacer::add_rod (int l, int r, Real dist) { if (isinf (dist) || isnan (dist)) { - programming_error ("Weird minimum distance. Ignoring"); + programming_error ("ignoring weird minimum distance"); return; } - Real c = range_stiffness (l,r); - if (isinf (c)) + Real block_force = rod_force (l, r, dist); + + if (isinf (block_force)) { - /* - If a spring is fixed, we have to do something here: - we let the rod override the spring. - */ - Real total_dist = 0.; - for (int i = l ; i < r; i++) - total_dist += springs_[i].ideal_; - - if (total_dist < dist) - for (int i = l ; i < r; i++) - springs_[i].ideal_ *= dist/total_dist; + Real spring_dist = range_ideal_len (l, r); + if (spring_dist < dist) + for (int i = l; i < r; i++) + { + if (spring_dist) + springs_[i].set_distance (springs_[i].distance () * dist / spring_dist); + else + springs_[i].set_distance (dist / (r - l)); + } return; } - - Real d = range_ideal_len (l,r); - Real block_stretch = dist - d; - - Real block_force = c * block_stretch; - force_ = force_ >? block_force; - - for (int i=l; i < r; i++) - springs_[i].block_force_ = block_force >? - springs_[i].block_force_ ; + force_ = max (force_, block_force); + for (int i = l; i < r; i++) + springs_[i].set_blocking_force (max (block_force, springs_[i].blocking_force ())); } Real -Simple_spacer::range_ideal_len (int l, int r) const +Simple_spacer::range_ideal_len (int l, int r) const { - Real d =0.; - for (int i=l; i < r; i++) - d += springs_[i].ideal_; + Real d = 0.; + for (int i = l; i < r; i++) + d += springs_[i].distance (); return d; } Real -Simple_spacer::range_stiffness (int l, int r) const +Simple_spacer::range_stiffness (int l, int r, bool stretch) const { - Real den =0.0; - for (int i=l; i < r; i++) - { - if (springs_[i].is_active_) - den += 1 / springs_[i].hooke_; - } + Real den = 0.0; + for (int i = l; i < r; i++) + den += stretch ? springs_[i].inverse_stretch_strength () + : springs_[i].inverse_compress_strength (); return 1 / den; } Real -Simple_spacer::active_blocking_force () const -{ - Real bf = - infinity_f; - for (int i=0; i < springs_.size (); i++) - if (springs_[i].is_active_) - { - bf = bf >? springs_[i].block_force_; - } - return bf; -} - -Real -Simple_spacer::active_springs_stiffness () const -{ - Real stiff = range_stiffness (0, springs_.size ()); - if (isinf (stiff)) - { - /* - all springs are inactive. Take the stiffness of the - latest spring to block. - */ - - Real max_block_force = -infinity_f; - int max_i = -1; - for (int i=0; i < springs_.size (); i++) - { - if (springs_[i].block_force_ > max_block_force) - { - max_i = i; - max_block_force = springs_[i].block_force_; - } - } - - stiff = springs_[max_i].hooke_; - } - return stiff; -} - -void -Simple_spacer::set_active_states () -{ - /* float comparison is safe, since force is only copied. */ - for (int i=0 ; i = force_) - { - springs_[i].is_active_ = false; - active_count_ --; - } -} - -Real -Simple_spacer::configuration_length () const +Simple_spacer::configuration_length (Real force) const { - Real l =0.; - for (int i=0; i < springs_.size (); i++) - l += springs_[i].length (force_); + Real l = 0.; + for (vsize i = 0; i < springs_.size (); i++) + l += springs_[i].length (force); return l; } -bool -Simple_spacer::is_active () const -{ - return active_count_; -} - void -Simple_spacer::my_solve_linelen () +Simple_spacer::set_force (Real force) { - while (is_active ()) - { - force_ = active_blocking_force (); - Real conf = configuration_length (); - - if (conf < line_len_) - { - force_ += (line_len_ - conf) * active_springs_stiffness (); - break; - } - else - set_active_states (); - } + force_ = force; } - void -Simple_spacer::my_solve_natural_len () +Simple_spacer::solve (Real line_len, bool ragged) { - Real line_len_force = 0.0; - - while (is_active ()) - { - force_ = active_blocking_force () >? 0.0; - Real conf = configuration_length (); - - if (conf < line_len_) - { - line_len_force = force_ - + (line_len_ - conf) - * active_springs_stiffness(); - } - - if (force_ < 1e-8) // ugh., - break; - - set_active_states (); - } + Real conf = configuration_length (force_); - force_ = line_len_force; + ragged_ = ragged; + line_len_ = line_len; + if (conf < line_len_) + force_ = expand_line (); + else if (conf > line_len_) + force_ = compress_line (); + + if (ragged && force_ < 0) + fits_ = false; } -LY_DEFINE(ly_solve_spring_rod_problem, "ly:solve-spring-rod-problem", - 4, 1, 0, (SCM springs, SCM rods, SCM length, SCM ragged), - "Solve a spring and rod problem for @var{count} objects, that " - "are connected by @var{count-1} springs, and an arbitrary number of rods " - "Springs have the format (ideal, hooke) and rods (idx1, idx2, distance) " - "@var{length} is a number, @var{ragged} a boolean " - "Return: a list containing the force (positive for stretching, " - "negative for compressing and #f for non-satisfied constraints) " - "followed by the @var{spring-count}+1 positions of the objects. " - ) +Real +Simple_spacer::expand_line () { - int len = scm_ilength (springs); - if (len == 0) - return scm_list_2 (scm_from_double (0.0), scm_from_double (0.0)); - - SCM_ASSERT_TYPE (len >= 0, springs, SCM_ARG1, __FUNCTION__, "list of springs"); - SCM_ASSERT_TYPE (scm_ilength (rods) >= 0, rods, SCM_ARG2, __FUNCTION__, "list of rods"); - SCM_ASSERT_TYPE (scm_is_number (length) || length == SCM_BOOL_F, - length, SCM_ARG3, __FUNCTION__, "number or #f"); - - - bool is_ragged = ragged == SCM_BOOL_T; - Simple_spacer spacer; - for (SCM s = springs; scm_is_pair (s); s = scm_cdr (s)) - { - Real ideal = scm_to_double (scm_caar (s)); - Real hooke = scm_to_double (scm_cadar (s)); + double inv_hooke = 0; + double cur_len = configuration_length (force_); - spacer.add_spring (ideal, hooke); - } + fits_ = true; + for (vsize i = 0; i < springs_.size (); i++) + inv_hooke += springs_[i].inverse_stretch_strength (); - for (SCM s = rods; scm_is_pair (s); s = scm_cdr (s)) - { - SCM entry = scm_car (s); - int l = scm_to_int (scm_car (entry)); - int r = scm_to_int (scm_cadr (entry)); - entry = scm_cddr (entry); - - Real distance = scm_to_double (scm_car (entry)); - spacer.add_rod (l, r, distance); - } + if (inv_hooke == 0.0) /* avoid division by zero. If springs are infinitely stiff */ + inv_hooke = 1e-6; /* then report a very large stretching force */ - spacer.line_len_ = scm_to_double (length); - - if (is_ragged) - spacer.my_solve_natural_len (); - else - spacer.my_solve_linelen (); + assert (cur_len <= line_len_); + return (line_len_ - cur_len) / inv_hooke + force_; +} - Array posns; - posns.push (0.0); - for (int i = 0; i < spacer.springs_.size(); i++) +Real +Simple_spacer::compress_line () +{ + double cur_len = configuration_length (force_); + double cur_force = force_; + bool compressed = false; + + /* just because we are in compress_line () doesn't mean that the line + will actually be compressed (as in, a negative force) because + we start out with a stretched line. Here, we check whether we + will be compressed or stretched (so we know which spring constant to use) */ + if (configuration_length (0.0) > line_len_) { - Real l = spacer.springs_[i].length ((is_ragged) ? 0.0 : spacer.force_); - posns.push (posns.top() + l); + cur_force = 0.0; + cur_len = configuration_length (0.0); + compressed = true; } + fits_ = true; - - SCM force_return = SCM_BOOL_F; - if (!isinf (spacer.force_) - && (spacer.is_active () || is_ragged)) - { - force_return = scm_from_double (spacer.force_); - } + assert (line_len_ <= cur_len); - if (is_ragged - && posns.top () > spacer.line_len_) - { - force_return = SCM_BOOL_F; - } + vector sorted_springs = springs_; + sort (sorted_springs.begin (), sorted_springs.end (), greater ()); - SCM retval= SCM_EOL; - for (int i = posns.size(); i--;) + /* inv_hooke is the total flexibility of currently-active springs */ + double inv_hooke = 0; + vsize i = sorted_springs.size (); + for (; i && sorted_springs[i - 1].blocking_force () < cur_force; i--) + inv_hooke += compressed + ? sorted_springs[i - 1].inverse_compress_strength () + : sorted_springs[i - 1].inverse_stretch_strength (); + /* i now indexes the first active spring, so */ + for (; i < sorted_springs.size (); i++) { - retval = scm_cons (scm_from_double (posns[i]), retval); + Spring sp = sorted_springs[i]; + + if (isinf (sp.blocking_force ())) + break; + + double block_dist = (cur_force - sp.blocking_force ()) * inv_hooke; + if (cur_len - block_dist < line_len_) + { + cur_force += (line_len_ - cur_len) / inv_hooke; + cur_len = line_len_; + + /* + Paranoia check. + */ + assert (fabs (configuration_length (cur_force) - cur_len) < 1e-6); + return cur_force; + } + + cur_len -= block_dist; + inv_hooke -= compressed ? sp.inverse_compress_strength () : sp.inverse_stretch_strength (); + cur_force = sp.blocking_force (); } - retval = scm_cons (force_return, retval); - return retval; + fits_ = false; + return cur_force; } - - -/****************************************************************/ -Spring_description::Spring_description () +void +Simple_spacer::add_spring (Spring const &sp) { - ideal_ =0.0; - hooke_ =0.0; - is_active_ = true; - block_force_ = 0.0; + force_ = max (force_, sp.blocking_force ()); + springs_.push_back (sp); } - -bool -Spring_description::is_sane () const +vector +Simple_spacer::spring_positions () const { - return (hooke_ > 0) - && ideal_ > 0 - && !isinf (ideal_) && !isnan (ideal_); + vector ret; + ret.push_back (0.); + + for (vsize i = 0; i < springs_.size (); i++) + ret.push_back (ret.back () + springs_[i].length (ragged_ && force_ > 0 ? 0.0 : force_)); + return ret; } Real -Spring_description::length (Real f) const +Simple_spacer::force_penalty (bool ragged) const { - if (!is_active_) - f = block_force_; - return ideal_ + f / hooke_ ; -} -/****************************************************************/ + /* If we are ragged-right, we don't want to penalise according to the force, + but according to the amount of whitespace that is present after the end + of the line. */ + if (ragged) + return max (0.0, line_len_ - configuration_length (0.0)); + /* Use a convex compression penalty. */ + Real f = force_; + return f - (f < 0 ? f * f * f * f * 2 : 0); +} -/* - - TODO: should a add penalty for widely varying spring forces (caused - by constraints, eg. +/****************************************************************/ +struct Rod_description +{ + vsize r_; + Real dist_; + + bool operator < (const Rod_description r) + { + return r_ < r.r_; + } + + Rod_description () + { + r_ = 0; + dist_ = 0; + } + + Rod_description (vsize r, Real d) + { + r_ = r; + dist_ = d; + } +}; + +struct Column_description +{ + vector rods_; + vector end_rods_; /* use these if they end at the last column of the line */ + Spring spring_; + Spring end_spring_; + + SCM break_permission_; + Interval keep_inside_line_; + + Column_description () + { + break_permission_ = SCM_EOL; + } +}; + +static bool +is_loose (Grob *g) +{ + return (scm_is_pair (g->get_object ("between-cols"))); +} - ===== - | | - o|o| x ##x +static Grob * +maybe_find_prebroken_piece (Grob *g, Direction d) +{ + Grob *ret = dynamic_cast (g)->find_prebroken_piece (d); + if (ret) + return ret; + return g; +} +static Grob * +next_spaceable_column (vector const &list, vsize starting) +{ + for (vsize i = starting + 1; i < list.size (); i++) + if (!is_loose (list[i])) + return list[i]; + return 0; +} - The ## forces the notes apart; we shouldn't allow the O's to touch - this closely. - - */ -void -Simple_spacer_wrapper::solve (Column_x_positions *positions, bool ragged) +static Column_description +get_column_description (vector const &cols, vsize col_index, bool line_starter) { - if (ragged) - spacer_->my_solve_natural_len (); - else - spacer_->my_solve_linelen (); + Grob *col = cols[col_index]; + if (line_starter) + col = maybe_find_prebroken_piece (col, RIGHT); - positions->force_ = spacer_->force_; - - /* - We used to have a penalty for compression, no matter what, but that - fucked up wtk1-fugue2 (taking 3 full pages.) - */ - positions->config_.push (spacer_->indent_); - for (int i=0; i < spacer_->springs_.size (); i++) - { - Real l = spacer_->springs_[i].length ((ragged) ? 0.0 : spacer_->force_); - positions->config_.push (positions->config_.top () + l); - /* - we have l>= 0 here, up to rounding errors - */ - } + Column_description description; + Grob *next_col = next_spaceable_column (cols, col_index); + if (next_col) + description.spring_ = Spaceable_grob::get_spring (col, next_col); - /* - For raggedright, we must have a measure of music density: this is - to prevent lots of short lines (which all have force = 0). - */ - if (ragged) + if (col_index + 1 < cols.size ()) { - positions->satisfies_constraints_ = - positions->config_.top () < spacer_->line_len_ ; + Grob *end_col = dynamic_cast (cols[col_index + 1])->find_prebroken_piece (LEFT); + if (end_col) + description.end_spring_ = Spaceable_grob::get_spring (col, end_col); } - - positions->cols_ = spaced_cols_; - positions->loose_cols_ = loose_cols_; - positions->satisfies_constraints_ = - positions->satisfies_constraints_ && spacer_->is_active (); - - /* - Check if breaking constraints are met. - */ - bool break_satisfy = true; - int sz = positions->cols_.size (); - for (int i = sz; i--; ) + for (SCM s = Spaceable_grob::get_minimum_distances (col); + scm_is_pair (s); s = scm_cdr (s)) { - SCM p = positions->cols_[i]->get_property ( "penalty"); - if (scm_is_number (p)) - { - if (scm_to_double (p) < -9999) - break_satisfy = break_satisfy && (i == 0 || i == sz -1); - if (scm_to_double (p) > 9999) - break_satisfy = break_satisfy && !(i == 0 || i == sz -1); - } - + Grob *other = Grob::unsmob (scm_caar (s)); + vsize j = binary_search (cols, other, Paper_column::less_than, col_index); + if (j != VPOS) + { + if (cols[j] == other) + description.rods_.push_back (Rod_description (j, scm_to_double (scm_cdar (s)))); + else /* it must end at the LEFT prebroken_piece */ + /* see Spanner::set_spacing_rods for more comments on how + to deal with situations where we don't know if we're + ending yet on the left prebroken piece */ + description.end_rods_.push_back (Rod_description (j, scm_to_double (scm_cdar (s)))); + } } - positions->satisfies_constraints_ = - positions->satisfies_constraints_ && break_satisfy; + if (!line_starter && to_boolean (col->get_property ("keep-inside-line"))) + description.keep_inside_line_ = col->extent (col, X_AXIS); + + description.break_permission_ = col->get_property ("line-break-permission"); + return description; } -void -Simple_spacer::add_spring (Real ideal, Real hooke) +vector +get_line_forces (vector const &columns, + Real line_len, Real indent, bool ragged) { - Spring_description desc; - - desc.ideal_ = ideal; - desc.hooke_ = hooke; - if (!desc.is_sane ()) + vector breaks; + vector force; + vector non_loose; + vector cols; + SCM force_break = ly_symbol2scm ("force"); + + for (vsize i = 0; i < columns.size (); i++) + if (!is_loose (columns[i]) || Paper_column::is_breakable (columns[i])) + non_loose.push_back (columns[i]); + + breaks.clear (); + breaks.push_back (0); + cols.push_back (Column_description ()); + for (vsize i = 1; i + 1 < non_loose.size (); i++) { - programming_error ("Insane spring found. Setting to unit spring."); + if (Paper_column::is_breakable (non_loose[i])) + breaks.push_back (cols.size ()); - desc.hooke_ = 1.0; - desc.ideal_ = 1.0; - } - - if (isinf (hooke)) - { - desc.is_active_ = false; + cols.push_back (get_column_description (non_loose, i, false)); } - else + breaks.push_back (cols.size ()); + force.resize (breaks.size () * breaks.size (), infinity_f); + + for (vsize b = 0; b + 1 < breaks.size (); b++) { - /* - desc.is_active_ ? - */ - desc.block_force_ = - desc.hooke_ * desc.ideal_; // block at distance 0 - - active_count_ ++; + cols[breaks[b]] = get_column_description (non_loose, breaks[b], true); + vsize st = breaks[b]; + + for (vsize c = b + 1; c < breaks.size (); c++) + { + vsize end = breaks[c]; + Simple_spacer spacer; + + for (vsize i = breaks[b]; i < end - 1; i++) + spacer.add_spring (cols[i].spring_); + spacer.add_spring (cols[end - 1].end_spring_); + + for (vsize i = breaks[b]; i < end; i++) + { + for (vsize r = 0; r < cols[i].rods_.size (); r++) + if (cols[i].rods_[r].r_ < end) + spacer.add_rod (i - st, cols[i].rods_[r].r_ - st, cols[i].rods_[r].dist_); + for (vsize r = 0; r < cols[i].end_rods_.size (); r++) + if (cols[i].end_rods_[r].r_ == end) + spacer.add_rod (i - st, end - st, cols[i].end_rods_[r].dist_); + if (!cols[i].keep_inside_line_.is_empty ()) + { + spacer.add_rod (i - st, end - st, cols[i].keep_inside_line_[RIGHT]); + spacer.add_rod (0, i - st, -cols[i].keep_inside_line_[LEFT]); + } + } + spacer.solve ((b == 0) ? line_len - indent : line_len, ragged); + force[b * breaks.size () + c] = spacer.force_penalty (ragged); + + if (!spacer.fits ()) + { + if (c == b + 1) + force[b * breaks.size () + c] = -200000; + else + force[b * breaks.size () + c] = infinity_f; + break; + } + if (end < cols.size () && cols[end].break_permission_ == force_break) + break; + } } - springs_.push (desc); + return force; } -void -Simple_spacer_wrapper::add_columns (Link_array const &icols) +Column_x_positions +get_line_configuration (vector const &columns, + Real line_len, + Real indent, + bool ragged) { - Link_array cols (icols); - - for (int i = cols.size (); i--;) - if (scm_is_pair (cols[i]->get_property ("between-cols"))) - { - loose_cols_.push (cols[i]); - cols.del (i); - } - - spaced_cols_ = cols; - for (int i=0; i < cols.size () - 1; i++) + vector cols; + Simple_spacer spacer; + Column_x_positions ret; + + ret.cols_.push_back (dynamic_cast (columns[0])->find_prebroken_piece (RIGHT)); + for (vsize i = 1; i + 1 < columns.size (); i++) { - Spring_smob *spring = 0; - - for (SCM s = cols[i]->get_property ("ideal-distances"); - !spring && scm_is_pair (s); - s = scm_cdr (s)) - { - Spring_smob *sp = unsmob_spring (scm_car (s)); - - - if (sp->other_ == cols[i+1]) - spring = sp; - } - - if (!spring) - programming_error (_f ("No spring between column %d and next one", - Paper_column::get_rank (cols[i]) - )); - - Real ideal = (spring) ? spring->distance_ : spacer_->default_space_; - Real hooke = (spring) ? spring->strength_ : 1.0; - - spacer_->add_spring (ideal, hooke); + if (is_loose (columns[i])) + ret.loose_cols_.push_back (columns[i]); + else + ret.cols_.push_back (columns[i]); } - - for (int i=0; i < cols.size () - 1; i++) + ret.cols_.push_back (dynamic_cast (columns.back ())->find_prebroken_piece (LEFT)); + + /* since we've already put our line-ending column in the column list, we can ignore + the end_XXX_ fields of our column_description */ + for (vsize i = 0; i + 1 < ret.cols_.size (); i++) { - for (SCM s = Spaceable_grob::get_minimum_distances (cols[i]); - scm_is_pair (s); s = scm_cdr (s)) - { - Grob * other = unsmob_grob (scm_caar (s)); - int oi = cols.find_index (other); - if (oi >= 0) - { - spacer_->add_rod (i, oi, scm_to_double (scm_cdar (s))); - } - } + cols.push_back (get_column_description (ret.cols_, i, i == 0)); + spacer.add_spring (cols[i].spring_); + } + for (vsize i = 0; i < cols.size (); i++) + { + for (vsize r = 0; r < cols[i].rods_.size (); r++) + spacer.add_rod (i, cols[i].rods_[r].r_, cols[i].rods_[r].dist_); + + if (!cols[i].keep_inside_line_.is_empty ()) + { + spacer.add_rod (i, cols.size (), cols[i].keep_inside_line_[RIGHT]); + spacer.add_rod (0, i, -cols[i].keep_inside_line_[LEFT]); + } } -} -Simple_spacer_wrapper::Simple_spacer_wrapper () -{ - spacer_ = new Simple_spacer (); -} + spacer.solve (line_len, ragged); + ret.force_ = spacer.force_penalty (ragged); -Simple_spacer_wrapper::~Simple_spacer_wrapper () -{ - delete spacer_; -} + ret.config_ = spacer.spring_positions (); + for (vsize i = 0; i < ret.config_.size (); i++) + ret.config_[i] += indent; + ret.satisfies_constraints_ = spacer.fits (); -Simple_spacer_wrapper::Simple_spacer_wrapper (Simple_spacer_wrapper const&) -{ + /* + Check if breaking constraints are met. + */ + for (vsize i = 1; i + 1 < ret.cols_.size (); i++) + { + SCM p = ret.cols_[i]->get_property ("line-break-permission"); + if (p == ly_symbol2scm ("force")) + ret.satisfies_constraints_ = false; + } + + return ret; }