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          e->unlink ();
 150          assert (!e->linked_b ());
 151          delete e;
 152        }
 153
 154 }
 155 Link_array<Score_element>
 156 Paper_score::remove_break_helpers ()
 157 {
 158   Link_array<Score_element> to_remove;
 159   Link_array<Score_element> keep;
 160   for (int i=0; i < elem_p_arr_.size (); i++)
 161     {
 162       Score_element*e = elem_p_arr_[i];
 163       if (e->break_helper_only_b_)
 164         to_remove.push (e);
 165       else
 166         keep.push (e);
 167     }
 168
 169   elem_p_arr_ = keep;
 170   Link_array<Spanner> keeps;
 171   for (int i=0; i<span_p_arr_.size  ();i++)
 172     {
 173       Spanner *s = span_p_arr_[i];
 174       Score_element *e = s;
 175       if (e->break_helper_only_b_)
 176         to_remove.push (e);
 177       else
 178         keeps.push (s);
 179     }
 180
 181
 182   span_p_arr_ =keeps;
 183
 184   return to_remove;
 185 }
 186
 187 void
 188 Paper_score::process ()
 189 {
 190   Dictionary<int> type_stats;
 191   type_stats["Item"] =0;
 192   type_stats["Spanner"] =0;
 193   type_stats["Total"]=0;
 194
 195   print ();
 196   *mlog << _ ("Preprocessing elements...") << " " << flush;
 197   line_l_->breakable_col_processing ();
 198       line_l_->pre_processing ();
 199
 200       *mlog << '\n' << _ ("Calculating column positions...") << " " << flush;
 201       line_l_->space_processing ();
 202
 203   Array<Column_x_positions> breaking = calc_breaking ();
 204
 205   delete_array_contents (remove_break_helpers(), type_stats);
 206
 207   Paper_stream* paper_stream_p = paper_l_->paper_stream_p ();
 208   outputter_l_ = paper_l_->paper_outputter_p (paper_stream_p, header_l_, origin_str_);
 209
 210   Link_array<Line_of_score> lines;
 211   for (int i=0; i < breaking.size (); i++)
 212     {
 213       Line_of_score *line_l = line_l_->set_breaking (breaking, i);
 214       lines.push (line_l);
 215       if (line_l != line_l_)
 216         typeset_element (line_l);
 217     }
 218
 219   if (experimental_features_global_b)
 220     *mlog << elem_p_arr_.size ()  + span_p_arr_.size () << " elements. ";
 221   *mlog << "\nLine ... ";
 222   for (int i=0; i < lines.size (); i++)
 223     {
 224       *mlog << '[' << flush;
 225
 226       Line_of_score *line_l = lines[i];
 227       line_l->break_processing ();
 228       line_l->post_processing ();
 229         *mlog << i << flush;
 230       line_l->output_all ();
 231
 232       if (experimental_features_global_b)
 233         *mlog << '(' << elem_p_arr_.size () + span_p_arr_.size () << ')';
 234
 235       *mlog << ']' << flush;
 236       Link_array<Score_element> to_remove (remove_line (line_l));
 237
 238       delete_array_contents (to_remove,  type_stats);
 239     }
 240
 241   // huh?
 242   delete outputter_l_;
 243   delete paper_stream_p;
 244   outputter_l_ = 0;
 245
 246
 247   /*
 248     todo: sort output
 249    */
 250   if (experimental_features_global_b)
 251     {
 252       for (Dictionary_iter<int> i(type_stats); i.ok(); i++)
 253         {
 254           *mlog << i.key () << ": " << i.val () << " objects\n";
 255         }
 256     }
 257   *mlog << '\n' << flush;
 258
 259 }
 260
 261
 262 Link_array<Score_element>
 263 Paper_score::remove_line (Line_of_score *l)
 264 {
 265   Link_array<Score_element> to_remove;
 266   Link_array<Score_element> keep;
 267   for (int i=0; i < elem_p_arr_.size (); i++)
 268     {
 269       Score_element*e = elem_p_arr_[i];
 270       if (e->line_l () == l)
 271         to_remove.push (e);
 272       else
 273         keep.push (e);
 274     }
 275
 276   elem_p_arr_ = keep;
 277   Link_array<Spanner> keeps;
 278   for (int i=0; i<span_p_arr_.size  ();i++)
 279     {
 280       Spanner *s = span_p_arr_[i];
 281       Score_element *e = s;
 282       if (e->line_l () == l)
 283         to_remove.push (e);
 284       else
 285         keeps.push (s);
 286     }
 287
 288
 289   span_p_arr_ =keeps;
 290   return to_remove;
 291 }
 292
 293 Link_array<Item>
 294 Paper_score::broken_col_range (Item const*l, Item const*r) const
 295 {
 296   Link_array<Item> ret;
 297
 298   l = l->column_l ();
 299   r = r->column_l ();
 300
 301   int  start = l
 302     ? find_col_idx (dynamic_cast<Paper_column*> ((Item*)l))+1
 303     : 0;
 304
 305   int stop = r
 306     ? find_col_idx (dynamic_cast<Paper_column*>((Item*)r))
 307     : col_l_arr_.size ();
 308
 309   while (start < stop)
 310     {
 311       Paper_column *c = col_l_arr_[start];
 312       if (c->breakable_b_ && !c->line_l_)
 313         ret.push (c);
 314       start++;
 315     }
 316
 317   return ret;
 318 }