lily/score-elem.cc

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