lily/p-score.cc

   1 /*
   2   p-score.cc -- implement Paper_score
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 1996,  1997--1999 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   7 */
   8
   9 #include "main.hh"
  10 #include "debug.hh"
  11 #include "lookup.hh"
  12 #include "spanner.hh"
  13 #include "paper-def.hh"
  14 #include "line-of-score.hh"
  15 #include "p-col.hh"
  16 #include "p-score.hh"
  17 #include "p-col.hh"
  18 #include "scope.hh"
  19 #include "word-wrap.hh"
  20 #include "gourlay-breaking.hh"
  21 #include "paper-stream.hh"
  22 #include "paper-outputter.hh"
  23 #include "file-results.hh"
  24 #include "misc.hh"
  25
  26 Paper_score::Paper_score ()
  27 {
  28   outputter_l_ =0;
  29   Line_of_score * line_p = new Line_of_score;
  30   typeset_unbroken_spanner (line_p);
  31
  32   line_l_ = line_p;
  33 }
  34
  35 Paper_score::Paper_score (Paper_score const &s)
  36   : Music_output (s)
  37 {
  38   assert (false);
  39 }
  40
  41 Paper_score::~Paper_score ()
  42 {
  43   for (int i=0; i < span_p_arr_.size (); i++)
  44     delete span_p_arr_[i];
  45   for (int i=0; i < elem_p_arr_.size (); i++)
  46     delete elem_p_arr_[i];
  47 }
  48
  49 void
  50 Paper_score::typeset_element (Score_element * elem_p)
  51 {
  52   elem_p_arr_.push (elem_p);
  53   elem_p->pscore_l_ = this;
  54   elem_p->add_processing ();
  55 }
  56
  57
  58 void
  59 Paper_score::typeset_unbroken_spanner (Spanner*span_p)
  60 {
  61   span_p_arr_.push (span_p);
  62   span_p->pscore_l_=this;
  63   span_p->add_processing ();
  64 }
  65
  66 void
  67 Paper_score::add_column (Paper_column *p)
  68 {
  69   p->set_rank (col_l_arr_.size ());
  70   col_l_arr_.push (p);
  71   typeset_element(p);
  72 }
  73
  74
  75
  76 void
  77 Paper_score::print () const
  78 {
  79 #ifndef NPRINT
  80   if (!check_debug)
  81     return ;
  82   DOUT << "Paper_score { ";
  83   DOUT << "\n elements: ";
  84   for (int i=0; i < span_p_arr_.size (); i++)
  85     span_p_arr_[i]->print ();
  86   for (int i=0; i < elem_p_arr_.size (); i++)
  87     elem_p_arr_[i]->print();
  88
  89   DOUT << "}\n";
  90 #endif
  91 }
  92
  93 int
  94 Paper_score::find_col_idx (Paper_column const *c) const
  95 {
  96   Paper_column const *what = c;
  97
  98   return col_l_arr_.find_i ((Paper_column*)what);
  99 }
 100
 101 Array<Column_x_positions>
 102 Paper_score::calc_breaking ()
 103 {
 104   Break_algorithm *algorithm_p=0;
 105   Array<Column_x_positions> sol;
 106   bool try_wrap = !paper_l_->get_var ("castingalgorithm");
 107
 108   if (!try_wrap)
 109     {
 110       algorithm_p = new Gourlay_breaking ;
 111       algorithm_p->set_pscore (this);
 112       sol = algorithm_p->solve ();
 113       delete algorithm_p;
 114       if (! sol.size ())
 115         {
 116           warning (_ ("Can't solve this casting problem exactly; revert to Word_wrap"));
 117           try_wrap = true;
 118         }
 119     }
 120   if  (try_wrap)
 121     {
 122       algorithm_p = new Word_wrap;
 123       algorithm_p->set_pscore (this);
 124       sol = algorithm_p->solve ();
 125       delete algorithm_p;
 126     }
 127   return sol;
 128 }
 129
 130
 131
 132 void delete_array_contents (Link_array<Score_element> const&to_remove, Dictionary<int> &type_stats)
 133 {
 134   for (int i=0; i < to_remove.size (); i++)
 135     {
 136       Score_element * e = to_remove[i];
 137       String nm = e->name();
 138       if (type_stats.elem_b (nm))
 139            type_stats[nm] ++;
 140          else
 141            type_stats[nm] = 1;
 142
 143          if (dynamic_cast<Item*> (e))
 144            type_stats["Item"] ++;
 145          else if (dynamic_cast<Spanner*>(e))
 146            type_stats["Spanner"] ++;
 147          type_stats["Total"] ++;
 148        }
 149
 150 }
 151 Link_array<Score_element>
 152 Paper_score::remove_break_helpers ()
 153 {
 154   Link_array<Score_element> to_remove;
 155   Link_array<Score_element> keep;
 156   SCM help_sym = break_helper_only_scm_sym;
 157   for (int i=0; i < elem_p_arr_.size (); i++)
 158     {
 159       Score_element*e = elem_p_arr_[i];
 160       SCM p =  e->get_elt_property (help_sym);
 161       if (p != SCM_BOOL_F)
 162         to_remove.push (e);
 163       else
 164         keep.push (e);
 165     }
 166
 167   elem_p_arr_ = keep;
 168   Link_array<Spanner> keeps;
 169   for (int i=0; i<span_p_arr_.size  ();i++)
 170     {
 171       Spanner *s = span_p_arr_[i];
 172       Score_element *e = s;
 173       SCM p =  e->get_elt_property (break_helper_only_scm_sym);
 174       if (p != SCM_BOOL_F)
 175         to_remove.push (e);
 176       else
 177         keeps.push (s);
 178     }
 179
 180
 181   span_p_arr_ =keeps;
 182
 183   return to_remove;
 184 }
 185
 186 void
 187 Paper_score::process ()
 188 {
 189   Dictionary<int> type_stats;
 190   type_stats["Item"] =0;
 191   type_stats["Spanner"] =0;
 192   type_stats["Total"]=0;
 193
 194   print ();
 195   *mlog << _ ("Preprocessing elements...") << " " << flush;
 196   line_l_->breakable_col_processing ();
 197       line_l_->pre_processing ();
 198
 199       *mlog << '\n' << _ ("Calculating column positions...") << " " << flush;
 200       line_l_->space_processing ();
 201
 202   Array<Column_x_positions> breaking = calc_breaking ();
 203
 204   delete_array_contents (remove_break_helpers(), type_stats);
 205
 206   Paper_stream* paper_stream_p = paper_l_->paper_stream_p ();
 207   outputter_l_ = paper_l_->paper_outputter_p (paper_stream_p, header_l_, origin_str_);
 208
 209   Link_array<Line_of_score> lines;
 210   for (int i=0; i < breaking.size (); i++)
 211     {
 212       Line_of_score *line_l = line_l_->set_breaking (breaking, i);
 213       lines.push (line_l);
 214       if (line_l != line_l_)
 215         typeset_element (line_l);
 216     }
 217
 218   if (experimental_features_global_b)
 219     *mlog << elem_p_arr_.size ()  + span_p_arr_.size () << " elements. ";
 220   *mlog << "\nLine ... ";
 221   for (int i=0; i < lines.size (); i++)
 222     {
 223       *mlog << '[' << flush;
 224
 225       Line_of_score *line_l = lines[i];
 226       line_l->break_processing ();
 227       line_l->post_processing ();
 228         *mlog << i << flush;
 229       line_l->output_all ();
 230
 231       if (experimental_features_global_b)
 232         *mlog << '(' << elem_p_arr_.size () + span_p_arr_.size () << ')';
 233
 234       *mlog << ']' << flush;
 235       Link_array<Score_element> to_remove (remove_line (line_l));
 236
 237       delete_array_contents (to_remove,  type_stats);
 238     }
 239
 240   // huh?
 241   delete outputter_l_;
 242   delete paper_stream_p;
 243   outputter_l_ = 0;
 244
 245
 246   /*
 247     todo: sort output
 248    */
 249   if (experimental_features_global_b)
 250     {
 251       for (Dictionary_iter<int> i(type_stats); i.ok(); i++)
 252         {
 253           *mlog << i.key () << ": " << i.val () << " objects\n";
 254         }
 255     }
 256   *mlog << '\n' << flush;
 257
 258 }
 259
 260
 261 Link_array<Score_element>
 262 Paper_score::remove_line (Line_of_score *l)
 263 {
 264   Link_array<Score_element> to_remove;
 265   Link_array<Score_element> keep;
 266   for (int i=0; i < elem_p_arr_.size (); i++)
 267     {
 268       Score_element*e = elem_p_arr_[i];
 269       if (e->line_l () == l)
 270         to_remove.push (e);
 271       else
 272         keep.push (e);
 273     }
 274
 275   elem_p_arr_ = keep;
 276   Link_array<Spanner> keeps;
 277   for (int i=0; i<span_p_arr_.size  ();i++)
 278     {
 279       Spanner *s = span_p_arr_[i];
 280       Score_element *e = s;
 281       if (e->line_l () == l)
 282         to_remove.push (e);
 283       else
 284         keeps.push (s);
 285     }
 286
 287
 288   span_p_arr_ =keeps;
 289   return to_remove;
 290 }
 291
 292 Link_array<Item>
 293 Paper_score::broken_col_range (Item const*l, Item const*r) const
 294 {
 295   Link_array<Item> ret;
 296
 297   l = l->column_l ();
 298   r = r->column_l ();
 299
 300   int  start = l
 301     ? find_col_idx (dynamic_cast<Paper_column*> ((Item*)l))+1
 302     : 0;
 303
 304   int stop = r
 305     ? find_col_idx (dynamic_cast<Paper_column*>((Item*)r))
 306     : col_l_arr_.size ();
 307
 308   while (start < stop)
 309     {
 310       Paper_column *c = col_l_arr_[start];
 311       if (c->breakable_b () && !c->line_l_)
 312         ret.push (c);
 313       start++;
 314     }
 315
 316   return ret;
 317 }