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