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