X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lily%2Fsimple-spacer.cc;h=9200554822b87030d8e0b6c452fd7b3fe5ba859a;hb=7208189546b5932480e268e805e81e468fcd30e5;hp=e027b5e26ad85a387f2e0181ac902d444dbe729c;hpb=98167a22044e00f954a37d4edc323b5620e2bd87;p=lilypond.git diff --git a/lily/simple-spacer.cc b/lily/simple-spacer.cc index e027b5e26a..9200554822 100644 --- a/lily/simple-spacer.cc +++ b/lily/simple-spacer.cc @@ -3,7 +3,7 @@ source file of the GNU LilyPond music typesetter - (c) 1999--2006 Han-Wen Nienhuys + (c) 1999--2007 Han-Wen Nienhuys TODO: - add support for different stretch/shrink constants? @@ -59,18 +59,20 @@ Simple_spacer::Simple_spacer () { - force_ = 0.; + line_len_ = 0.0; + force_ = 0.0; fits_ = true; + ragged_ = true; } Real -Simple_spacer::force () +Simple_spacer::force () const { return force_; } bool -Simple_spacer::fits () +Simple_spacer::fits () const { return fits_; } @@ -129,11 +131,11 @@ Simple_spacer::range_stiffness (int l, int r) const } Real -Simple_spacer::configuration_length () const +Simple_spacer::configuration_length (Real force) const { Real l = 0.; for (vsize i = 0; i < springs_.size (); i++) - l += springs_[i].length (force_); + l += springs_[i].length (force); return l; } @@ -141,29 +143,24 @@ Simple_spacer::configuration_length () const void Simple_spacer::solve (Real line_len, bool ragged) { - Real conf = configuration_length (); + Real conf = configuration_length (force_); ragged_ = ragged; line_len_ = line_len; - if (ragged) - { - force_ = 0; - fits_ = configuration_length () <= line_len_; - /* we need to calculate a force here to prevent a bunch of short lines */ - if (fits_) - force_ = expand_line (); - } - else if (conf < line_len_) + if (conf < line_len_) force_ = expand_line (); else if (conf > line_len_) force_ = compress_line (); + + if (ragged && force_ < 0) + fits_ = false; } Real Simple_spacer::expand_line () { double inv_hooke = 0; - double cur_len = configuration_length (); + double cur_len = configuration_length (force_); fits_ = true; for (vsize i=0; i < springs_.size (); i++) @@ -177,7 +174,7 @@ Real Simple_spacer::compress_line () { double inv_hooke = 0; - double cur_len = configuration_length (); + double cur_len = configuration_length (force_); double cur_force = force_; fits_ = true; @@ -197,8 +194,18 @@ Simple_spacer::compress_line () break; double block_dist = (cur_force - sp.block_force_) * inv_hooke; - if (cur_len - block_dist <= line_len_) - return cur_force + (line_len_ - cur_len) / 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 -= sp.inverse_hooke_; cur_force = sp.block_force_; @@ -236,10 +243,24 @@ Simple_spacer::spring_positions () const ret.push_back (0.); for (vsize i = 0; i < springs_.size (); i++) - ret.push_back (ret.back () + springs_[i].length (ragged_ ? 0.0 : force_)); + ret.push_back (ret.back () + springs_[i].length (ragged_ && force_ > 0 ? 0.0 : force_)); return ret; } +Real +Simple_spacer::force_penalty (bool ragged) const +{ + /* 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*4 : 0); +} + /****************************************************************/ Spring_description::Spring_description () @@ -254,7 +275,9 @@ Spring_description::is_sane () const { return (inverse_hooke_ >= 0) && ideal_ > 0 - && !isinf (ideal_) && !isnan (ideal_); + && !isinf (ideal_) && !isnan (ideal_) + && (inverse_hooke_ == 0.0 || fabs (inverse_hooke_) > 1e-8) + ; } Real @@ -323,8 +346,6 @@ struct Column_description } }; -static int compare_paper_column_rank (Grob *const &a, Grob *const &b); - static bool is_loose (Grob *g) { @@ -349,43 +370,6 @@ next_spaceable_column (vector const &list, vsize starting) return 0; } -/* this only returns non-NULL if the line-ending column is the next - spaceable-or-breakable column */ -static Grob* -next_line_ending_column (vector const &list, vsize starting) -{ - vsize i = starting + 1; - for (; i < list.size () - && is_loose (list[i]) - && !Paper_column::is_breakable (list[i]); - i++) - ; - return dynamic_cast (list[i])->find_prebroken_piece (LEFT); -} - -static void -get_column_spring (Grob *this_col, Grob *next_col, Real *ideal, Real *inv_hooke) -{ - Spring_smob *spring = 0; - - for (SCM s = this_col->get_object ("ideal-distances"); - !spring && scm_is_pair (s); - s = scm_cdr (s)) - { - Spring_smob *sp = unsmob_spring (scm_car (s)); - - if (sp->other_ == next_col) - spring = sp; - } - - if (!spring) - programming_error (_f ("No spring between column %d and next one", - Paper_column::get_rank (this_col))); - - *ideal = (spring) ? spring->distance_ : 5.0; - *inv_hooke = (spring) ? spring->inverse_strength_ : 1.0; -} - static Column_description get_column_description (vector const &cols, vsize col_index, bool line_starter) { @@ -396,16 +380,16 @@ get_column_description (vector const &cols, vsize col_index, bool line_st Column_description description; Grob *next_col = next_spaceable_column (cols, col_index); if (next_col) - get_column_spring (col, next_col, &description.ideal_, &description.inverse_hooke_); - Grob *end_col = next_line_ending_column (cols, col_index); + Spaceable_grob::get_spring (col, next_col, &description.ideal_, &description.inverse_hooke_); + Grob *end_col = dynamic_cast (cols[col_index+1])->find_prebroken_piece (LEFT); if (end_col) - get_column_spring (col, end_col, &description.end_ideal_, &description.end_inverse_hooke_); + Spaceable_grob::get_spring (col, end_col, &description.end_ideal_, &description.end_inverse_hooke_); for (SCM s = Spaceable_grob::get_minimum_distances (col); scm_is_pair (s); s = scm_cdr (s)) { Grob *other = unsmob_grob (scm_caar (s)); - vsize j = binary_search (cols, other, &compare_paper_column_rank, col_index); + vsize j = binary_search (cols, other, Paper_column::less_than, col_index); if (j != VPOS) { if (cols[j] == other) @@ -414,39 +398,44 @@ get_column_description (vector const &cols, vsize col_index, bool line_st description.end_rods_.push_back (Rod_description (j, scm_to_double (scm_cdar (s)))); } } + 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; } vector -get_line_forces (vector const &icols, vector breaks, +get_line_forces (vector const &columns, Real line_len, Real indent, bool ragged) { + vector breaks; vector force; - force.resize (breaks.size () * breaks.size (), infinity_f); - + vector non_loose; vector cols; - vsize b = 1; 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 < icols.size () - 1; i++) + for (vsize i = 1; i + 1 < non_loose.size (); i++) { - if (b < breaks.size () && breaks[b] == i) - { - breaks[b] = cols.size (); - b++; - } - if (!is_loose (icols[i])) - cols.push_back (get_column_description (icols, i, false)); + if (Paper_column::is_breakable (non_loose[i])) + breaks.push_back (cols.size ()); + + cols.push_back (get_column_description (non_loose, i, false)); } - breaks.back () = cols.size () - 1; + breaks.push_back (cols.size ()); + force.resize (breaks.size () * breaks.size (), infinity_f); - for (vsize b = 0; b < breaks.size () - 1; b++) + for (vsize b = 0; b + 1 < breaks.size (); b++) { - cols[breaks[b]] = get_column_description (icols, breaks[b], true); + cols[breaks[b]] = get_column_description (non_loose, breaks[b], true); vsize st = breaks[b]; for (vsize c = b+1; c < breaks.size (); c++) @@ -456,7 +445,7 @@ get_line_forces (vector const &icols, vector breaks, for (vsize i = breaks[b]; i < end - 1; i++) spacer.add_spring (cols[i].ideal_, cols[i].inverse_hooke_); - spacer.add_spring (cols[end-1].end_ideal_, cols[end-1].inverse_hooke_); + spacer.add_spring (cols[end-1].end_ideal_, cols[end-1].end_inverse_hooke_); for (vsize i = breaks[b]; i < end; i++) @@ -470,26 +459,29 @@ get_line_forces (vector const &icols, vector breaks, 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.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 (); + force[b * breaks.size () + c] = spacer.force_penalty (ragged); - if (cols[end].break_permission_ == force_break) - break; if (!spacer.fits ()) { - force[b * breaks.size () + c] = infinity_f; + 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; } } return force; } Column_x_positions -get_line_configuration (vectorconst &columns, +get_line_configuration (vector const &columns, Real line_len, Real indent, bool ragged) @@ -499,7 +491,7 @@ get_line_configuration (vectorconst &columns, Column_x_positions ret; ret.cols_.push_back (dynamic_cast (columns[0])->find_prebroken_piece (RIGHT)); - for (vsize i = 1; i < columns.size () - 1; i++) + for (vsize i = 1; i + 1 < columns.size (); i++) { if (is_loose (columns[i])) ret.loose_cols_.push_back (columns[i]); @@ -508,33 +500,28 @@ get_line_configuration (vectorconst &columns, } ret.cols_.push_back (dynamic_cast (columns.back ())->find_prebroken_piece (LEFT)); - cols.resize (ret.cols_.size () - 1); - /* 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 < cols.size (); i++) + for (vsize i = 0; i + 1 < ret.cols_.size (); i++) { - cols[i] = get_column_description (ret.cols_, i, i == 0); + cols.push_back (get_column_description (ret.cols_, i, i == 0)); spacer.add_spring (cols[i].ideal_, cols[i].inverse_hooke_); } 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]); + spacer.add_rod (0, i, -cols[i].keep_inside_line_[LEFT]); } } spacer.solve (line_len, ragged); - ret.force_ = spacer.force (); + ret.force_ = spacer.force_penalty (ragged); - /* - We used to have a penalty for compression, no matter what, but that - fucked up wtk1-fugue2 (taking 3 full pages.) - */ ret.config_ = spacer.spring_positions (); for (vsize i = 0; i < ret.config_.size (); i++) ret.config_[i] += indent; @@ -544,7 +531,7 @@ get_line_configuration (vectorconst &columns, /* Check if breaking constraints are met. */ - for (vsize i = 1; i < ret.cols_.size () - 1; i++) + 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")) @@ -554,9 +541,3 @@ get_line_configuration (vectorconst &columns, return ret; } -static int -compare_paper_column_rank (Grob *const &a, - Grob *const &b) -{ - return Paper_column::get_rank (a) - Paper_column::get_rank (b); -}