lily/grob.cc

   1 /*
   2   grob.cc -- implement Grob
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 1997--2006 Han-Wen Nienhuys <hanwen@xs4all.nl>
   7 */
   8
   9 #include "grob.hh"
  10
  11 #include <cstring>
  12
  13 #include "align-interface.hh"
  14 #include "input.hh"
  15 #include "international.hh"
  16 #include "item.hh"
  17 #include "main.hh"
  18 #include "misc.hh"
  19 #include "music.hh"
  20 #include "output-def.hh"
  21 #include "pointer-group-interface.hh"
  22 #include "stencil.hh"
  23 #include "stream-event.hh"
  24 #include "system.hh"
  25 #include "warn.hh"
  26
  27 #include "ly-smobs.icc"
  28
  29 Grob *
  30 Grob::clone (int count) const
  31 {
  32   return new Grob (*this, count);
  33 }
  34
  35 Grob::Grob (SCM basicprops,
  36             Object_key const *key)
  37 {
  38   key_ = key;
  39
  40   /* FIXME: default should be no callback.  */
  41   self_scm_ = SCM_EOL;
  42   layout_ = 0;
  43   original_ = 0;
  44   interfaces_ = SCM_EOL;
  45   immutable_property_alist_ = basicprops;
  46   mutable_property_alist_ = SCM_EOL;
  47   object_alist_ = SCM_EOL;
  48
  49   /* We do smobify_self () as the first step.  Since the object lives
  50      on the heap, none of its SCM variables are protected from
  51      GC. After smobify_self (), they are.  */
  52   smobify_self ();
  53
  54   /*
  55     We always get a new key object for a new grob.
  56   */
  57   if (key_)
  58     ((Object_key *)key_)->unprotect ();
  59
  60   SCM meta = get_property ("meta");
  61   if (scm_is_pair (meta))
  62     interfaces_ = scm_cdr (scm_assq (ly_symbol2scm ("interfaces"), meta));
  63
  64   if (get_property_data ("X-extent") == SCM_EOL)
  65     set_property ("X-extent", Grob::stencil_width_proc);
  66   if (get_property_data ("Y-extent") == SCM_EOL)
  67     set_property ("Y-extent", Grob::stencil_height_proc);
  68 }
  69
  70 Grob::Grob (Grob const &s, int copy_index)
  71   : dim_cache_ (s.dim_cache_)
  72 {
  73   key_ = (use_object_keys) ? new Copied_key (s.key_, copy_index) : 0;
  74   original_ = (Grob *) & s;
  75   self_scm_ = SCM_EOL;
  76
  77   immutable_property_alist_ = s.immutable_property_alist_;
  78   mutable_property_alist_ = ly_deep_copy (s.mutable_property_alist_);
  79   interfaces_ = s.interfaces_;
  80   object_alist_ = SCM_EOL;
  81
  82   layout_ = 0;
  83
  84   smobify_self ();
  85   if (key_)
  86     ((Object_key *)key_)->unprotect ();
  87 }
  88
  89 Grob::~Grob ()
  90 {
  91 }
  92 /****************************************************************
  93   STENCILS
  94 ****************************************************************/
  95
  96 Stencil *
  97 Grob::get_stencil () const
  98 {
  99   if (!is_live ())
 100     return 0;
 101
 102   SCM stil = get_property ("stencil");
 103   return unsmob_stencil (stil);
 104 }
 105
 106 Stencil
 107 Grob::get_print_stencil () const
 108 {
 109   SCM stil = get_property ("stencil");
 110
 111   Stencil retval;
 112   if (Stencil *m = unsmob_stencil (stil))
 113     {
 114       retval = *m;
 115       if (to_boolean (get_property ("transparent")))
 116         retval = Stencil (m->extent_box (), SCM_EOL);
 117       else
 118         {
 119           SCM expr = m->expr ();
 120           expr = scm_list_3 (ly_symbol2scm ("grob-cause"),
 121                              self_scm (), expr);
 122
 123           retval = Stencil (m->extent_box (), expr);
 124         }
 125
 126       SCM rot = get_property ("rotation");
 127       if (scm_is_pair (rot))
 128         {
 129           Real angle = scm_to_double (scm_car (rot));
 130           Real x = scm_to_double (scm_cadr (rot));
 131           Real y = scm_to_double (scm_caddr (rot));
 132
 133           retval.rotate (angle, Offset (x, y));
 134         }
 135
 136       /* color support... see interpret_stencil_expression () for more... */
 137       SCM color = get_property ("color");
 138       if (scm_is_pair (color))
 139         {
 140           SCM expr = scm_list_3 (ly_symbol2scm ("color"),
 141                                  color,
 142                                  retval.expr ());
 143
 144           retval = Stencil (retval.extent_box (), expr);
 145         }
 146
 147     }
 148
 149   return retval;
 150 }
 151
 152 /****************************************************************
 153   VIRTUAL STUBS
 154 ****************************************************************/
 155 void
 156 Grob::do_break_processing ()
 157 {
 158 }
 159
 160 void
 161 Grob::discretionary_processing ()
 162 {
 163 }
 164
 165 System *
 166 Grob::get_system () const
 167 {
 168   return 0;
 169 }
 170
 171
 172 void
 173 Grob::handle_broken_dependencies ()
 174 {
 175   Spanner *sp = dynamic_cast<Spanner *> (this);
 176   if (original () && sp)
 177     return;
 178
 179   if (sp)
 180     /* THIS, SP is the original spanner.  We use a special function
 181        because some Spanners have enormously long lists in their
 182        properties, and a special function fixes FOO  */
 183     {
 184       for (SCM s = object_alist_; scm_is_pair (s); s = scm_cdr (s))
 185         sp->substitute_one_mutable_property (scm_caar (s), scm_cdar (s));
 186     }
 187   System *system = get_system ();
 188
 189   if (is_live ()
 190       && system
 191       && common_refpoint (system, X_AXIS)
 192       && common_refpoint (system, Y_AXIS))
 193     substitute_object_links (system->self_scm (), object_alist_);
 194   else if (dynamic_cast<System *> (this))
 195     substitute_object_links (SCM_UNDEFINED, object_alist_);
 196   else
 197     /* THIS element is `invalid'; it has been removed from all
 198        dependencies, so let's junk the element itself.
 199
 200        Do not do this for System, since that would remove references
 201        to the originals of score-grobs, which get then GC'd (a bad
 202        thing).  */
 203     suicide ();
 204 }
 205
 206 /* Note that we still want references to this element to be
 207    rearranged, and not silently thrown away, so we keep pointers like
 208    {broken_into_{drul, array}, original}
 209 */
 210 void
 211 Grob::suicide ()
 212 {
 213   if (!is_live ())
 214     return;
 215
 216   for (int a = X_AXIS; a < NO_AXES; a++)
 217     dim_cache_[a].clear ();
 218
 219   mutable_property_alist_ = SCM_EOL;
 220   object_alist_ = SCM_EOL;
 221   immutable_property_alist_ = SCM_EOL;
 222   interfaces_ = SCM_EOL;
 223 }
 224
 225 void
 226 Grob::handle_prebroken_dependencies ()
 227 {
 228   /* Don't do this in the derived method, since we want to keep access to
 229      object_alist_ centralized.  */
 230   if (original ())
 231     {
 232       Item *it = dynamic_cast<Item *> (this);
 233       substitute_object_links (scm_from_int (it->break_status_dir ()),
 234                                original ()->object_alist_);
 235     }
 236 }
 237
 238 Grob *
 239 Grob::find_broken_piece (System *) const
 240 {
 241   return 0;
 242 }
 243
 244 /****************************************************************
 245    OFFSETS
 246 ****************************************************************/
 247
 248 void
 249 Grob::translate_axis (Real y, Axis a)
 250 {
 251   if (isinf (y) || isnan (y))
 252     {
 253       programming_error (_ ("Infinity or NaN encountered"));
 254       return ;
 255     }
 256
 257   if (!dim_cache_[a].offset_)
 258     dim_cache_[a].offset_ = new Real (y);
 259   else
 260     *dim_cache_[a].offset_ += y;
 261 }
 262
 263 /* Find the offset relative to D.  If D equals THIS, then it is 0.
 264    Otherwise, it recursively defd as
 265
 266    OFFSET_ + PARENT_L_->relative_coordinate (D) */
 267 Real
 268 Grob::relative_coordinate (Grob const *refp, Axis a) const
 269 {
 270   if (refp == this)
 271     return 0.0;
 272
 273   /* We catch PARENT_L_ == nil case with this, but we crash if we did
 274      not ask for the absolute coordinate (ie. REFP == nil.)  */
 275   Real off = get_offset (a);
 276   if (refp == dim_cache_[a].parent_)
 277     return off;
 278
 279   off += dim_cache_[a].parent_->relative_coordinate (refp, a);
 280
 281   return off;
 282 }
 283
 284 Real
 285 Grob::pure_relative_y_coordinate (Grob const *refp, int start, int end)
 286 {
 287   if (refp == this)
 288     return 0.0;
 289
 290   Real off = 0;
 291
 292   if (dim_cache_[Y_AXIS].offset_)
 293     off = *dim_cache_[Y_AXIS].offset_;
 294   else
 295     {
 296       SCM proc = get_property_data ("Y-offset");
 297
 298       dim_cache_[Y_AXIS].offset_ = new Real (0.0);
 299       off = robust_scm2double (call_pure_function (proc,
 300                                                    scm_list_1 (self_scm ()),
 301                                                    start, end),
 302                                0.0);
 303       delete dim_cache_[Y_AXIS].offset_;
 304       dim_cache_[Y_AXIS].offset_ = 0;
 305     }
 306
 307   /* we simulate positioning-done if we are the child of a VerticalAlignment,
 308      but only if we don't have a cached offset. If we do have a cached offset,
 309      it probably means that the Alignment was fixed and it has already been
 310      calculated.
 311   */
 312   if (Grob *p = get_parent (Y_AXIS))
 313     {
 314       Real trans = 0;
 315       if (Align_interface::has_interface (p) && !dim_cache_[Y_AXIS].offset_)
 316         trans = Align_interface::get_pure_child_y_translation (p, this, start, end);
 317
 318       return off + trans + p->pure_relative_y_coordinate (refp, start, end);
 319     }
 320   return off;
 321 }
 322
 323 /* Invoke callbacks to get offset relative to parent.  */
 324 Real
 325 Grob::get_offset (Axis a) const
 326 {
 327   if (dim_cache_[a].offset_)
 328     return *dim_cache_[a].offset_;
 329
 330   Grob *me = (Grob *) this;
 331
 332   SCM sym = axis_offset_symbol (a);
 333   me->dim_cache_[a].offset_ = new Real (0.0);
 334
 335   /*
 336     UGH: can't fold next 2 statements together. Apparently GCC thinks
 337     dim_cache_[a].offset_ is unaliased.
 338   */
 339   Real off = robust_scm2double (internal_get_property (sym), 0.0);
 340   if (me->dim_cache_[a].offset_)
 341     {
 342       *me->dim_cache_[a].offset_ += off;
 343       me->del_property (sym);
 344       return *me->dim_cache_[a].offset_;
 345     }
 346   else
 347     return 0.0;
 348 }
 349
 350 Real
 351 Grob::maybe_pure_coordinate (Grob const *refp, Axis a, bool pure, int start, int end)
 352 {
 353   if (pure && a != Y_AXIS)
 354     programming_error ("tried to get pure X-offset");
 355   return (pure && a == Y_AXIS) ? pure_relative_y_coordinate (refp, start, end)
 356     : relative_coordinate (refp, a);
 357 }
 358
 359 /****************************************************************
 360   extents
 361 ****************************************************************/
 362
 363 void
 364 Grob::flush_extent_cache (Axis axis)
 365 {
 366   if (dim_cache_[axis].extent_)
 367     {
 368       /*
 369         Ugh, this is not accurate; will flush property, causing
 370         callback to be called if.
 371        */
 372       del_property ((axis == X_AXIS) ? ly_symbol2scm ("X-extent") : ly_symbol2scm ("Y-extent"));
 373       delete dim_cache_[axis].extent_;
 374       dim_cache_[axis].extent_ = 0;
 375       if (get_parent (axis))
 376         get_parent (axis)->flush_extent_cache (axis);
 377     }
 378 }
 379
 380
 381 Interval
 382 Grob::extent (Grob *refp, Axis a) const
 383 {
 384   Real offset = relative_coordinate (refp, a);
 385   Interval real_ext;
 386   if (dim_cache_[a].extent_)
 387     {
 388       real_ext = *dim_cache_[a].extent_;
 389     }
 390   else
 391     {
 392       /*
 393         Order is significant: ?-extent may trigger suicide.
 394        */
 395       SCM ext_sym =
 396         (a == X_AXIS)
 397         ? ly_symbol2scm ("X-extent")
 398         : ly_symbol2scm ("Y-extent");
 399
 400       SCM ext = internal_get_property (ext_sym);
 401       if (is_number_pair (ext))
 402         real_ext.unite (ly_scm2interval (ext));
 403
 404       SCM min_ext_sym =
 405         (a == X_AXIS)
 406         ? ly_symbol2scm ("minimum-X-extent")
 407         : ly_symbol2scm ("minimum-Y-extent");
 408       SCM min_ext = internal_get_property (min_ext_sym);
 409       if (is_number_pair (min_ext))
 410         real_ext.unite (ly_scm2interval (min_ext));
 411
 412       ((Grob*)this)->dim_cache_[a].extent_ = new Interval (real_ext);
 413     }
 414
 415   real_ext.translate (offset);
 416
 417   return real_ext;
 418 }
 419
 420 Interval
 421 Grob::pure_height (Grob *refp, int start, int end)
 422 {
 423   SCM proc = get_property_data ( ly_symbol2scm ("Y-extent"));
 424   Interval iv = robust_scm2interval (call_pure_function (proc,
 425                                                          scm_list_1 (self_scm ()),
 426                                                          start, end),
 427                                      Interval (0, 0));
 428   Real offset = pure_relative_y_coordinate (refp, start, end);
 429
 430   SCM min_ext = get_property ("minimum-Y-extent");
 431
 432   /* we don't add minimum-Y-extent if the extent is empty. This solves
 433      a problem with Hara-kiri spanners. They would request_suicide and
 434      return empty extents, but we would force them here to be large. */
 435   if (!iv.is_empty () && is_number_pair (min_ext))
 436     iv.unite (ly_scm2interval (min_ext));
 437
 438   iv.translate (offset);
 439   return iv;
 440 }
 441
 442 Interval
 443 Grob::maybe_pure_extent (Grob *refp, Axis a, bool pure, int start, int end)
 444 {
 445   if (pure && a != Y_AXIS)
 446     programming_error ("tried to get pure width");
 447   return (pure && a == Y_AXIS) ? pure_height (refp, start, end) : extent (refp, a);
 448 }
 449
 450 Interval_t<int>
 451 Grob::spanned_rank_iv ()
 452 {
 453   return Interval_t<int> (-1, 0);
 454 }
 455
 456 /****************************************************************
 457   REFPOINTS
 458 ****************************************************************/
 459
 460 /* Find the group-element which has both #this# and #s#  */
 461 Grob *
 462 Grob::common_refpoint (Grob const *s, Axis a) const
 463 {
 464   /* I don't like the quadratic aspect of this code, but I see no
 465      other way.  The largest chain of parents might be 10 high or so,
 466      so it shouldn't be a real issue.  */
 467   for (Grob const *c = this; c; c = c->dim_cache_[a].parent_)
 468     for (Grob const *d = s; d; d = d->dim_cache_[a].parent_)
 469       if (d == c)
 470         return (Grob *) d;
 471
 472   return 0;
 473 }
 474
 475 void
 476 Grob::set_parent (Grob *g, Axis a)
 477 {
 478   dim_cache_[a].parent_ = g;
 479 }
 480
 481 Grob *
 482 Grob::get_parent (Axis a) const
 483 {
 484   return dim_cache_[a].parent_;
 485 }
 486
 487
 488 void
 489 Grob::fixup_refpoint ()
 490 {
 491   for (int a = X_AXIS; a < NO_AXES; a++)
 492     {
 493       Axis ax = (Axis)a;
 494       Grob *parent = get_parent (ax);
 495
 496       if (!parent)
 497         continue;
 498
 499       if (parent->get_system () != get_system () && get_system ())
 500         {
 501           Grob *newparent = parent->find_broken_piece (get_system ());
 502           set_parent (newparent, ax);
 503         }
 504
 505       if (Item *i = dynamic_cast<Item *> (this))
 506         {
 507           Item *parenti = dynamic_cast<Item *> (parent);
 508
 509           if (parenti && i)
 510             {
 511               Direction my_dir = i->break_status_dir ();
 512               if (my_dir != parenti->break_status_dir ())
 513                 {
 514                   Item *newparent = parenti->find_prebroken_piece (my_dir);
 515                   set_parent (newparent, ax);
 516                 }
 517             }
 518         }
 519     }
 520 }
 521
 522
 523 /****************************************************************
 524   MESSAGES
 525 ****************************************************************/
 526 void
 527 Grob::warning (string s) const
 528 {
 529   SCM cause = self_scm ();
 530   while (Grob *g = unsmob_grob (cause))
 531     cause = g->get_property ("cause");
 532
 533   /* ES TODO: cause can't be Music*/
 534   if (Music *m = unsmob_music (cause))
 535     m->origin ()->warning (s);
 536   else if (Stream_event *ev = unsmob_stream_event (cause))
 537     ev->origin ()->warning (s);
 538   else
 539     ::warning (s);
 540 }
 541
 542
 543 string
 544 Grob::name () const
 545 {
 546   SCM meta = get_property ("meta");
 547   SCM nm = scm_assq (ly_symbol2scm ("name"), meta);
 548   nm = (scm_is_pair (nm)) ? scm_cdr (nm) : SCM_EOL;
 549   return scm_is_symbol (nm) ? ly_symbol2string (nm) : this->class_name ();
 550 }
 551
 552 void
 553 Grob::programming_error (string s) const
 554 {
 555   SCM cause = self_scm ();
 556   while (Grob *g = unsmob_grob (cause))
 557     cause = g->get_property ("cause");
 558
 559   s = _f ("programming error: %s", s);
 560
 561   /* ES TODO: cause can't be Music*/
 562   if (Music *m = unsmob_music (cause))
 563     m->origin ()->message (s);
 564   else if (Stream_event *ev = unsmob_stream_event (cause))
 565     ev->origin ()->warning (s);
 566   else
 567     ::message (s);
 568 }
 569
 570
 571 ADD_INTERFACE (Grob,
 572                "A grob represents a piece of music notation\n"
 573                "\n"
 574                "All grobs have an X and Y-position on the page.  These X and Y positions\n"
 575                "are stored in a relative format, so they can easily be combined by\n"
 576                "stacking them, hanging one grob to the side of another, and coupling\n"
 577                "them into a grouping objects.\n"
 578                "\n"
 579                "Each grob has a reference point (a.k.a.  parent): the position of a grob\n"
 580                "is stored relative to that reference point. For example the X-reference\n"
 581                "point of a staccato dot usually is the note head that it applies\n"
 582                "to. When the note head is moved, the staccato dot moves along\n"
 583                "automatically.\n"
 584                "\n"
 585                "A grob is often associated with a symbol, but some grobs do not print\n"
 586                "any symbols. They take care of grouping objects. For example, there is a\n"
 587                "separate grob that stacks staves vertically. The @ref{NoteCollision}\n"
 588                "is also an abstract grob: it only moves around chords, but doesn't print\n"
 589                "anything.\n"
 590                "\n"
 591                "Grobs have a properties: Scheme variables, that can be read and set. "
 592                "They have two types. Immutable variables "
 593                "define the default style and behavior.  They are shared between  many objects. "
 594                "They can be changed using @code{\\override} and @code{\\revert}. "
 595                "\n\n"
 596                "Mutable properties are variables that are specific to one grob. Typically, "
 597                "lists of other objects, or results from computations are stored in"
 598                "mutable properties: every call to set-grob-property (or its C++ equivalent) "
 599                "sets a mutable property. "
 600                "\n\n"
 601                "The properties @code{after-line-breaking} and @code{before-line-breaking} "
 602                "are dummies that are not user-serviceable. "
 603
 604                ,
 605
 606                /* properties */
 607                "X-extent "
 608                "X-offset "
 609                "Y-extent "
 610                "Y-offset "
 611                "after-line-breaking "
 612                "avoid-slur "
 613                "axis-group-parent-X "
 614                "axis-group-parent-Y "
 615                "before-line-breaking "
 616                "cause "
 617                "color "
 618                "extra-X-extent "
 619                "extra-Y-extent "
 620                "extra-offset "
 621                "interfaces "
 622                "layer "
 623                "meta "
 624                "minimum-X-extent "
 625                "minimum-Y-extent "
 626                "outside-staff-horizontal-padding "
 627                "outside-staff-padding "
 628                "outside-staff-priority "
 629                "rotation "
 630                "springs-and-rods "
 631                "staff-symbol "
 632                "stencil "
 633                "transparent "
 634                );
 635
 636
 637
 638
 639
 640 /****************************************************************
 641   CALLBACKS
 642 ****************************************************************/
 643
 644
 645 static SCM
 646 grob_stencil_extent (Grob *me, Axis a)
 647 {
 648   Stencil *m = me->get_stencil ();
 649   Interval e;
 650   if (m)
 651     e = m->extent (a);
 652   return ly_interval2scm (e);
 653 }
 654
 655
 656 MAKE_SCHEME_CALLBACK (Grob, stencil_height, 1);
 657 SCM
 658 Grob::stencil_height (SCM smob)
 659 {
 660   Grob *me = unsmob_grob (smob);
 661   return grob_stencil_extent (me, Y_AXIS);
 662 }
 663
 664 MAKE_SCHEME_CALLBACK(Grob, y_parent_positioning, 1);
 665 SCM
 666 Grob::y_parent_positioning (SCM smob)
 667 {
 668   Grob *me = unsmob_grob (smob);
 669   Grob *par = me->get_parent (Y_AXIS);
 670   if (par)
 671     (void) par->get_property ("positioning-done");
 672
 673   return scm_from_double (0.0);
 674 }
 675
 676
 677 MAKE_SCHEME_CALLBACK(Grob, x_parent_positioning, 1);
 678 SCM
 679 Grob::x_parent_positioning (SCM smob)
 680 {
 681   Grob *me = unsmob_grob (smob);
 682
 683   Grob *par = me->get_parent (X_AXIS);
 684   if (par)
 685     (void) par->get_property ("positioning-done");
 686
 687   return scm_from_double (0.0);
 688 }
 689
 690 MAKE_SCHEME_CALLBACK (Grob, stencil_width, 1);
 691 SCM
 692 Grob::stencil_width (SCM smob)
 693 {
 694   Grob *me = unsmob_grob (smob);
 695   return grob_stencil_extent (me, X_AXIS);
 696 }
 697
 698
 699
 700 Grob *
 701 common_refpoint_of_list (SCM elist, Grob *common, Axis a)
 702 {
 703   for (; scm_is_pair (elist); elist = scm_cdr (elist))
 704     if (Grob *s = unsmob_grob (scm_car (elist)))
 705       {
 706         if (common)
 707           common = common->common_refpoint (s, a);
 708         else
 709           common = s;
 710       }
 711
 712   return common;
 713 }
 714
 715 Grob *
 716 common_refpoint_of_array (vector<Grob*> const &arr, Grob *common, Axis a)
 717 {
 718   for (vsize i = arr.size (); i--;)
 719     if (Grob *s = arr[i])
 720       {
 721         if (common)
 722           common = common->common_refpoint (s, a);
 723         else
 724           common = s;
 725       }
 726
 727   return common;
 728 }
 729
 730 Interval
 731 robust_relative_extent (Grob *me, Grob *refpoint, Axis a)
 732 {
 733   Interval ext = me->extent (refpoint, a);
 734   if (ext.is_empty ())
 735     ext.add_point (me->relative_coordinate (refpoint, a));
 736
 737   return ext;
 738 }
 739