lily/score-element.cc

   1 /*
   2   score-elem.cc -- implement Score_element
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c)  1997--1999 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   7 */
   8
   9
  10 #include <string.h>
  11
  12 #include "p-score.hh"
  13 #include "paper-def.hh"
  14 #include "lookup.hh"
  15 #include "molecule.hh"
  16 #include "score-element.hh"
  17 #include "debug.hh"
  18 #include "spanner.hh"
  19 #include "line-of-score.hh"
  20 #include "item.hh"
  21 #include "p-col.hh"
  22 #include "molecule.hh"
  23 #include "misc.hh"
  24 #include "paper-outputter.hh"
  25
  26 Score_element::Score_element()
  27 {
  28   output_p_ =0;
  29   break_helper_only_b_ = false;
  30   transparent_b_ = false;
  31   size_i_ = 0;
  32   pscore_l_=0;
  33   status_i_ = 0;
  34 }
  35
  36 Score_element::Score_element (Score_element const&s)
  37   :  Directed_graph_node (s), Graphical_element (s)
  38 {
  39   /* called from derived ctor, so most info points to the same deps
  40      as (Directed_graph_node&)s. Nobody points to us, so don't copy
  41      dependents.
  42    */
  43   copy_edges_out (s);
  44   output_p_ =0;
  45   break_helper_only_b_ = s.break_helper_only_b_;
  46   transparent_b_ = s.transparent_b_;
  47   status_i_ = s.status_i_;
  48   pscore_l_ = s.pscore_l_;
  49   size_i_ = s.size_i_;
  50 }
  51
  52
  53
  54
  55 Score_element::~Score_element()
  56 {
  57   delete output_p_;
  58   assert (status_i_ >=0);
  59   status_i_  = -1;
  60 }
  61
  62 Score_element*
  63 Score_element::dependency (int i) const
  64 {
  65   return (Score_element*) (get_out_edge_arr ()[i]);
  66 }
  67
  68 int
  69 Score_element::dependency_size () const
  70 {
  71   return get_out_edge_arr ().size ();
  72 }
  73
  74 Score_element*
  75 Score_element::dependent (int i) const
  76 {
  77   return (Score_element *)( get_in_edge_arr()[i]);
  78 }
  79
  80 int
  81 Score_element::dependent_size() const
  82 {
  83   return get_in_edge_arr().size ();
  84 }
  85
  86
  87
  88 Interval
  89 Score_element::do_width() const
  90 {
  91   Interval r;
  92
  93   Molecule*m = output_p_ ?  output_p_ : do_brew_molecule_p();
  94   r = m->extent().x ();
  95
  96   if (!output_p_)
  97     delete m;
  98
  99   return r;
 100 }
 101
 102 Interval
 103 Score_element::do_height() const
 104 {
 105   Interval r;
 106   Molecule*m = output_p_ ?  output_p_ : do_brew_molecule_p();
 107   r = m->extent().y ();
 108   if (!output_p_)
 109     delete m;
 110
 111   return r;
 112 }
 113
 114
 115 /*
 116   STANDARD METHS
 117  */
 118 void
 119 Score_element::print() const
 120 {
 121 #ifndef NPRINT
 122   DOUT << classname(this) << "{\n";
 123   DOUT << "dets: " << dependent_size() << "dependencies: " <<
 124     dependency_size();
 125
 126   Graphical_element::do_print ();
 127   do_print();
 128
 129   DOUT <<  "}\n";
 130 #endif
 131 }
 132
 133
 134 Paper_def*
 135 Score_element::paper()  const
 136 {
 137   return pscore_l_->paper_l_;
 138 }
 139
 140
 141 Lookup const *
 142 Score_element::lookup_l () const
 143 {
 144   return pscore_l_->paper_l_->lookup_l (size_i_);
 145 }
 146
 147 void
 148 Score_element::add_processing()
 149 {
 150   assert (status_i_ >=0);
 151   if (status_i_)
 152     return;
 153   status_i_ ++;
 154   do_add_processing();
 155 }
 156
 157
 158 void
 159 Score_element::calculate_dependencies (int final, int busy,
 160                                     Score_element_method_pointer funcptr)
 161 {
 162   assert (status_i_ >=0);
 163
 164   if (status_i_ >= final)
 165     return;
 166
 167   assert (status_i_!= busy);
 168   status_i_= busy;
 169
 170   for (int i=0; i < dependency_size(); i++)
 171     dependency (i)->calculate_dependencies (final, busy, funcptr);
 172
 173   Link_array<Score_element> extra (get_extra_dependencies());
 174   for (int i=0; i < extra.size(); i++)
 175     extra[i]->calculate_dependencies (final, busy, funcptr);
 176
 177   invalidate_cache (X_AXIS);
 178   invalidate_cache (Y_AXIS);
 179   (this->*funcptr)();
 180   status_i_= final;
 181 }
 182
 183 void
 184 Score_element::output_processing ()
 185 {
 186   if (transparent_b_)
 187     return;
 188   if (output_p_)
 189     delete output_p_;
 190
 191   output_p_ = do_brew_molecule_p ();
 192   pscore_l_->outputter_l_->output_molecule (output_p_,
 193                                             absolute_offset (),
 194                                             classname(this));
 195 }
 196
 197 /*
 198
 199   VIRTUAL STUBS
 200
 201  */
 202
 203 void
 204 Score_element::do_break_processing()
 205 {
 206   handle_broken_dependencies();
 207 }
 208
 209 void
 210 Score_element::do_post_processing()
 211 {
 212 }
 213
 214 void
 215 Score_element::do_breakable_col_processing()
 216 {
 217   handle_prebroken_dependencies();
 218 }
 219
 220 void
 221 Score_element::do_pre_processing()
 222 {
 223 }
 224
 225 void
 226 Score_element::do_space_processing ()
 227 {
 228 }
 229
 230 void
 231 Score_element::do_add_processing()
 232 {
 233 }
 234
 235 void
 236 Score_element::do_substitute_element_pointer (Score_element*,Score_element*)
 237 {
 238 }
 239
 240 void
 241 Score_element::do_unlink()
 242 {
 243 }
 244
 245 void
 246 Score_element::do_junk_links()
 247 {
 248 }
 249
 250
 251
 252 Molecule*
 253 Score_element::do_brew_molecule_p() const
 254 {
 255   Molecule a (lookup_l ()->fill (Box (Interval (0,0), Interval (0,0))));
 256   return new Molecule (a);
 257 }
 258
 259
 260 Line_of_score *
 261 Score_element::line_l() const
 262 {
 263   return 0;
 264 }
 265
 266 /*
 267
 268   DEPENDENCIES
 269
 270   */
 271
 272 void
 273 Score_element::remove_dependency (Score_element*e)
 274 {
 275   remove_edge_out (e);
 276   substitute_dependency (e, 0);
 277 }
 278
 279 void
 280 Score_element::add_dependency (Score_element*e)
 281 {
 282   Directed_graph_node::add_edge (e);
 283 }
 284 void
 285 Score_element::substitute_dependency (Score_element* old, Score_element* new_l)
 286 {
 287   do_substitute_element_pointer (old,new_l);
 288   old->do_substitute_element_pointer (this, 0);
 289 }
 290
 291 void
 292 Score_element::handle_broken_dependencies()
 293 {
 294   Line_of_score *line  = line_l();
 295   if (!line)
 296     return;
 297
 298   Link_array<Score_element> remove_us_arr;
 299   for (int i=0; i < dependency_size(); i++)
 300     {
 301       Score_element * elt = dependency (i);
 302       if (elt->line_l() != line)
 303         {
 304           if (Spanner *sp = dynamic_cast<Spanner *> (elt))
 305             {
 306               Spanner * broken = sp->find_broken_piece (line);
 307               substitute_dependency (sp, broken);
 308
 309               add_dependency (broken);
 310             }
 311           else if (Item *original = dynamic_cast <Item *> (elt))
 312             {
 313               Item * my_item = original->find_prebroken_piece (line);
 314
 315               substitute_dependency (elt, my_item);
 316               if (my_item)
 317                 add_dependency (my_item);
 318             }
 319           remove_us_arr.push (elt);
 320         }
 321     }
 322
 323   remove_us_arr.default_sort();
 324   remove_us_arr.uniq();
 325   for (int i=0;  i <remove_us_arr.size(); i++)
 326     remove_dependency (remove_us_arr[i]);
 327 }
 328
 329 /*
 330   This sux.
 331
 332   unlike with spanners, the number of items can increase
 333
 334   span: item1
 335
 336   becomes
 337
 338   span: item1 item2 item3
 339
 340   How to let span (a derived class) know that this happened?
 341  */
 342 void
 343 Score_element::handle_prebroken_dependencies()
 344 {
 345   Link_array<Score_element> old_arr, new_arr;
 346
 347   for (int i=0; i < dependency_size(); i++)
 348     {
 349       Score_element * elt = dependency (i);
 350       Item *it_l = dynamic_cast <Item *> (elt);
 351       if (it_l && it_l->breakable_b_)
 352         if (Item *me = dynamic_cast<Item*> (this) )
 353           {
 354             Score_element *new_l = it_l->find_prebroken_piece (me->break_status_dir_);
 355             if (new_l != elt)
 356               {
 357                 new_arr.push (new_l);
 358                 old_arr.push (elt);
 359               }
 360           }
 361         else
 362           {
 363             new_arr.push (it_l->broken_to_drul_[LEFT]);
 364             old_arr.push (0);
 365             old_arr.push (0);
 366             new_arr.push (it_l->broken_to_drul_[RIGHT]);
 367           }
 368     }
 369
 370   for (int i=0;  i < old_arr.size(); i++)
 371     if (old_arr[i])
 372       substitute_dependency (old_arr[i], new_arr[i]);
 373 }
 374
 375 void
 376 Score_element::handle_prebroken_dependents()
 377 {
 378 }
 379
 380
 381 void
 382 Score_element::junk_links ()
 383 {
 384   Directed_graph_node::junk_links();
 385   Graphical_element::junk_links ();
 386   do_junk_links();
 387 }
 388
 389 void
 390 Score_element::unlink()
 391 {
 392   do_unlink();
 393   while (dependency_size())
 394     {
 395       do_substitute_element_pointer (dependency (0),0);
 396       remove_edge_out_idx (0);
 397     }
 398   while  (dependent_size())
 399     {
 400       dependent (0)->remove_dependency (this);
 401     }
 402   Graphical_element::unlink ();
 403 }
 404
 405
 406 Link_array<Score_element>
 407 Score_element::get_extra_dependencies() const
 408 {
 409   Link_array<Score_element> empty;
 410   return empty;
 411 }
 412
 413 bool
 414 Score_element::linked_b() const
 415 {
 416   return get_extra_dependencies().size() ||
 417     dependency_size();
 418 }