lily/grob.cc

   1 /*
   2   grob.cc -- implement Grob
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 1997--2005 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   7 */
   8
   9 #include "grob.hh"
  10
  11 #include <cstring>
  12 #include <math.h>
  13
  14 #include "main.hh"
  15 #include "input-smob.hh"
  16 #include "warn.hh"
  17 #include "group-interface.hh"
  18 #include "misc.hh"
  19 #include "paper-score.hh"
  20 #include "stencil.hh"
  21 #include "warn.hh"
  22 #include "system.hh"
  23 #include "item.hh"
  24 #include "stencil.hh"
  25 #include "misc.hh"
  26 #include "music.hh"
  27 #include "item.hh"
  28 #include "paper-score.hh"
  29 #include "ly-smobs.icc"
  30 #include "output-def.hh"
  31
  32 Grob *
  33 Grob::clone (int count) const
  34 {
  35   return new Grob (*this, count);
  36 }
  37
  38 /* TODO:
  39
  40 - remove dynamic_cast<Spanner, Item> and put this code into respective
  41 subclass.  */
  42
  43 #define HASH_SIZE 3
  44 #define INFINITY_MSG "Infinity or NaN encountered"
  45
  46 Grob::Grob (SCM basicprops,
  47             Object_key const *key)
  48 {
  49   key_ = key;
  50   /* FIXME: default should be no callback.  */
  51   self_scm_ = SCM_EOL;
  52   pscore_ = 0;
  53   status_ = 0;
  54   original_ = 0;
  55   immutable_property_alist_ = basicprops;
  56   mutable_property_alist_ = SCM_EOL;
  57
  58   /* We do smobify_self () as the first step.  Since the object lives
  59      on the heap, none of its SCM variables are protected from
  60      GC. After smobify_self (), they are.  */
  61   smobify_self ();
  62
  63   /*
  64     We always get a new key object for a new grob.
  65   */
  66   scm_gc_unprotect_object (key_->self_scm ());
  67   SCM meta = get_property ("meta");
  68   if (scm_is_pair (meta))
  69     {
  70       SCM ifs = scm_assoc (ly_symbol2scm ("interfaces"), meta);
  71
  72       /* Switch off interface checks for the moment.  */
  73       bool itc = do_internal_type_checking_global;
  74       do_internal_type_checking_global = false;
  75       internal_set_property (ly_symbol2scm ("interfaces"), scm_cdr (ifs));
  76       do_internal_type_checking_global = itc;
  77     }
  78
  79   /* TODO:
  80
  81   - destill this into a function, so we can re-init the immutable
  82   properties with a new BASICPROPS value after
  83   creation. Convenient eg. when using \override with
  84   StaffSymbol.  */
  85
  86   char const *onames[] = {"X-offset-callbacks", "Y-offset-callbacks"};
  87   char const *xnames[] = {"X-extent", "Y-extent"};
  88   char const *enames[] = {"X-extent-callback", "Y-extent-callback"};
  89
  90   for (int a = X_AXIS; a <= Y_AXIS; a++)
  91     {
  92       SCM l = get_property (onames[a]);
  93
  94       if (scm_ilength (l) >= 0)
  95         {
  96           dim_cache_[a].offset_callbacks_ = l;
  97           dim_cache_[a].offsets_left_ = scm_ilength (l);
  98         }
  99       else
 100         programming_error ("[XY]-offset-callbacks must be a list");
 101
 102       SCM cb = get_property (enames[a]);
 103       if (cb == SCM_BOOL_F)
 104         {
 105           dim_cache_[a].dimension_ = SCM_BOOL_F;
 106         }
 107
 108       SCM xt = get_property (xnames[a]);
 109       if (is_number_pair (xt))
 110         {
 111           dim_cache_[a].dimension_ = xt;
 112         }
 113       else if (ly_c_procedure_p (cb))
 114         {
 115           dim_cache_[a].dimension_callback_ = cb;
 116         }
 117       else if (cb == SCM_EOL
 118                && ly_c_procedure_p (get_property ("print-function")))
 119         dim_cache_[a].dimension_callback_ = stencil_extent_proc;
 120     }
 121 }
 122
 123 Grob::Grob (Grob const &s, int copy_index)
 124   : dim_cache_ (s.dim_cache_)
 125 {
 126   key_ = new Copied_key (s.key_, copy_index);
 127   original_ = (Grob *) & s;
 128   self_scm_ = SCM_EOL;
 129
 130   immutable_property_alist_ = s.immutable_property_alist_;
 131   mutable_property_alist_ = SCM_EOL;
 132
 133   /* No properties are copied.  That is the job of
 134      handle_broken_dependencies.  */
 135   status_ = s.status_;
 136   pscore_ = 0;
 137
 138   smobify_self ();
 139   scm_gc_unprotect_object (key_->self_scm ());
 140 }
 141
 142 Grob::~Grob ()
 143 {
 144 }
 145
 146 MAKE_SCHEME_CALLBACK (Grob, stencil_extent, 2);
 147 SCM
 148 Grob::stencil_extent (SCM element_smob, SCM scm_axis)
 149 {
 150   Grob *s = unsmob_grob (element_smob);
 151   Axis a = (Axis) scm_to_int (scm_axis);
 152
 153   Stencil *m = s->get_stencil ();
 154   Interval e;
 155   if (m)
 156     e = m->extent (a);
 157   return ly_interval2scm (e);
 158 }
 159
 160 Interval
 161 robust_relative_extent (Grob *me, Grob *refp, Axis a)
 162 {
 163   Interval ext = me->extent (refp, a);
 164   if (ext.is_empty ())
 165     {
 166       ext.add_point (me->relative_coordinate (refp, a));
 167     }
 168
 169   return ext;
 170 }
 171
 172 Output_def *
 173 Grob::get_layout () const
 174 {
 175   return pscore_ ? pscore_->layout_ : 0;
 176 }
 177
 178 /* Recursively track all dependencies of this Grob.  The status_ field
 179    is used as a mark-field.  It is marked with BUSY during execution
 180    of this function, and marked with FINAL when finished.
 181
 182    FUNCPTR is the function to call to update this element.  */
 183 void
 184 Grob::calculate_dependencies (int final, int busy, SCM funcname)
 185 {
 186   if (status_ >= final)
 187     return;
 188
 189   if (status_ == busy)
 190     {
 191       programming_error ("Element is busy, come back later");
 192       return;
 193     }
 194
 195   status_ = busy;
 196
 197   for (SCM d = get_property ("dependencies"); scm_is_pair (d);
 198        d = scm_cdr (d))
 199     unsmob_grob (scm_car (d))->calculate_dependencies (final, busy, funcname);
 200
 201   SCM proc = internal_get_property (funcname);
 202   if (ly_c_procedure_p (proc))
 203     scm_call_1 (proc, this->self_scm ());
 204
 205   status_ = final;
 206 }
 207
 208 Stencil *
 209 Grob::get_stencil () const
 210 {
 211   if (!is_live ())
 212     return 0;
 213
 214   SCM stil = get_property ("stencil");
 215   if (unsmob_stencil (stil))
 216     return unsmob_stencil (stil);
 217
 218   stil = get_uncached_stencil ();
 219   if (is_live ())
 220     {
 221       Grob *me = (Grob *) this;
 222       me->set_property ("stencil", stil);
 223     }
 224
 225   return unsmob_stencil (stil);
 226 }
 227
 228 SCM
 229 Grob::get_uncached_stencil () const
 230 {
 231   SCM proc = get_property ("print-function");
 232
 233   SCM stil = SCM_EOL;
 234   if (ly_c_procedure_p (proc))
 235     stil = scm_apply_0 (proc, scm_list_n (this->self_scm (), SCM_UNDEFINED));
 236
 237   if (Stencil *m = unsmob_stencil (stil))
 238     {
 239       if (to_boolean (get_property ("transparent")))
 240         stil = Stencil (m->extent_box (), SCM_EOL).smobbed_copy ();
 241       else
 242         {
 243
 244           SCM expr = m->expr ();
 245           if (point_and_click_global)
 246             expr = scm_list_3 (ly_symbol2scm ("grob-cause"), self_scm (), expr);
 247
 248           stil = Stencil (m->extent_box (), expr).smobbed_copy ();
 249         }
 250
 251       /* color support... see interpret_stencil_expression () for more... */
 252       SCM color = get_property ("color");
 253       if (color != SCM_EOL)
 254         {
 255           m = unsmob_stencil (stil);
 256           SCM expr = scm_list_3 (ly_symbol2scm ("color"),
 257                                  color,
 258                                  m->expr ());
 259
 260           stil = Stencil (m->extent_box (), expr).smobbed_copy ();
 261         }
 262     }
 263
 264   return stil;
 265 }
 266
 267 /*
 268   VIRTUAL STUBS
 269 */
 270 void
 271 Grob::do_break_processing ()
 272 {
 273 }
 274
 275 System *
 276 Grob::get_system () const
 277 {
 278   return 0;
 279 }
 280
 281 void
 282 Grob::add_dependency (Grob *e)
 283 {
 284   if (e)
 285     Pointer_group_interface::add_grob (this, ly_symbol2scm ("dependencies"),
 286                                        e);
 287   else
 288     programming_error ("Null dependency added");
 289 }
 290
 291 void
 292 Grob::handle_broken_dependencies ()
 293 {
 294   Spanner *sp = dynamic_cast<Spanner *> (this);
 295   if (original_ && sp)
 296     return;
 297
 298   if (sp)
 299     /* THIS, SP is the original spanner.  We use a special function
 300        because some Spanners have enormously long lists in their
 301        properties, and a special function fixes FOO  */
 302     for (SCM s = mutable_property_alist_; scm_is_pair (s); s = scm_cdr (s))
 303       sp->substitute_one_mutable_property (scm_caar (s), scm_cdar (s));
 304
 305   System *system = get_system ();
 306
 307   if (is_live ()
 308       && system && common_refpoint (system, X_AXIS)
 309       && common_refpoint (system, Y_AXIS))
 310     substitute_mutable_properties (system
 311                                    ? system->self_scm () : SCM_UNDEFINED,
 312                                    mutable_property_alist_);
 313   else if (dynamic_cast<System *> (this))
 314     substitute_mutable_properties (SCM_UNDEFINED, mutable_property_alist_);
 315   else
 316     /* THIS element is `invalid'; it has been removed from all
 317        dependencies, so let's junk the element itself.
 318
 319        Do not do this for System, since that would remove references
 320        to the originals of score-grobs, which get then GC'd (a bad
 321        thing).  */
 322     suicide ();
 323 }
 324
 325 /* Note that we still want references to this element to be
 326    rearranged, and not silently thrown away, so we keep pointers like
 327    {broken_into_{drul, array}, original}
 328 */
 329 void
 330 Grob::suicide ()
 331 {
 332   if (!is_live ())
 333     return;
 334
 335   mutable_property_alist_ = SCM_EOL;
 336   immutable_property_alist_ = SCM_EOL;
 337
 338   set_extent (SCM_EOL, Y_AXIS);
 339   set_extent (SCM_EOL, X_AXIS);
 340
 341   set_extent_callback (SCM_EOL, Y_AXIS);
 342   set_extent_callback (SCM_EOL, X_AXIS);
 343
 344   for (int a = X_AXIS; a <= Y_AXIS; a++)
 345     {
 346       dim_cache_[a].offset_callbacks_ = SCM_EOL;
 347       dim_cache_[a].offsets_left_ = 0;
 348     }
 349 }
 350
 351 void
 352 Grob::handle_prebroken_dependencies ()
 353 {
 354   /* Don't do this in the derived method, since we want to keep access to
 355      mutable_property_alist_ centralized.  */
 356   if (original_)
 357     {
 358       Item *it = dynamic_cast<Item *> (this);
 359       substitute_mutable_properties (scm_int2num (it->break_status_dir ()),
 360                                      original_->mutable_property_alist_);
 361     }
 362 }
 363
 364 Grob *
 365 Grob::find_broken_piece (System *) const
 366 {
 367   return 0;
 368 }
 369
 370 /* Translate in one direction.  */
 371 void
 372 Grob::translate_axis (Real y, Axis a)
 373 {
 374   if (isinf (y) || isnan (y))
 375     programming_error (_ (INFINITY_MSG));
 376   else
 377     dim_cache_[a].offset_ += y;
 378 }
 379
 380 /* Find the offset relative to D.  If D equals THIS, then it is 0.
 381    Otherwise, it recursively defd as
 382
 383    OFFSET_ + PARENT_L_->relative_coordinate (D) */
 384 Real
 385 Grob::relative_coordinate (Grob const *refp, Axis a) const
 386 {
 387   if (refp == this)
 388     return 0.0;
 389
 390   /* We catch PARENT_L_ == nil case with this, but we crash if we did
 391      not ask for the absolute coordinate (ie. REFP == nil.)  */
 392   if (refp == dim_cache_[a].parent_)
 393     return get_offset (a);
 394
 395   return get_offset (a) + dim_cache_[a].parent_->relative_coordinate (refp, a);
 396 }
 397
 398 /* Invoke callbacks to get offset relative to parent.  */
 399 Real
 400 Grob::get_offset (Axis a) const
 401 {
 402   Grob *me = (Grob *) this;
 403   while (dim_cache_[a].offsets_left_)
 404     {
 405       int l = --me->dim_cache_[a].offsets_left_;
 406       SCM cb = scm_list_ref (dim_cache_[a].offset_callbacks_, scm_int2num (l));
 407       SCM retval = scm_call_2 (cb, self_scm (), scm_int2num (a));
 408
 409       Real r = scm_to_double (retval);
 410       if (isinf (r) || isnan (r))
 411         {
 412           programming_error (INFINITY_MSG);
 413           r = 0.0;
 414         }
 415       me->dim_cache_[a].offset_ += r;
 416     }
 417   return dim_cache_[a].offset_;
 418 }
 419
 420 bool
 421 Grob::is_empty (Axis a) const
 422 {
 423   return !(scm_is_pair (dim_cache_[a].dimension_)
 424            || ly_c_procedure_p (dim_cache_[a].dimension_callback_));
 425 }
 426
 427 void
 428 Grob::flush_extent_cache (Axis axis)
 429 {
 430   Dimension_cache *d = &dim_cache_[axis];
 431   if (ly_c_procedure_p (d->dimension_callback_)
 432       && scm_is_pair (d->dimension_))
 433     {
 434       d->dimension_ = SCM_EOL;
 435
 436       if (get_parent (axis))
 437         get_parent (axis)->flush_extent_cache (axis);
 438     }
 439 }
 440
 441 Interval
 442 Grob::extent (Grob *refp, Axis a) const
 443 {
 444   Real x = relative_coordinate (refp, a);
 445
 446   Dimension_cache *d = (Dimension_cache *) & dim_cache_[a];
 447   Interval ext;
 448
 449   SCM dimpair = d->dimension_;
 450   if (scm_is_pair (dimpair))
 451     ;
 452   else if (ly_c_procedure_p (d->dimension_callback_)
 453            && d->dimension_ == SCM_EOL)
 454     d->dimension_ = scm_call_2 (d->dimension_callback_, self_scm (), scm_int2num (a));
 455   else
 456     return ext;
 457
 458   if (!scm_is_pair (d->dimension_))
 459     return ext;
 460
 461   ext = ly_scm2interval (d->dimension_);
 462
 463   SCM extra = get_property (a == X_AXIS
 464                             ? "extra-X-extent"
 465                             : "extra-Y-extent");
 466
 467   /* Signs ?  */
 468   if (scm_is_pair (extra))
 469     {
 470       ext[BIGGER] += scm_to_double (scm_cdr (extra));
 471       ext[SMALLER] += scm_to_double (scm_car (extra));
 472     }
 473
 474   extra = get_property (a == X_AXIS
 475                         ? "minimum-X-extent"
 476                         : "minimum-Y-extent");
 477   if (scm_is_pair (extra))
 478     ext.unite (Interval (scm_to_double (scm_car (extra)),
 479                          scm_to_double (scm_cdr (extra))));
 480
 481   ext.translate (x);
 482
 483   return ext;
 484 }
 485
 486 /* Find the group-element which has both #this# and #s#  */
 487 Grob *
 488 Grob::common_refpoint (Grob const *s, Axis a) const
 489 {
 490   /* I don't like the quadratic aspect of this code, but I see no
 491      other way.  The largest chain of parents might be 10 high or so,
 492      so it shouldn't be a real issue.  */
 493   for (Grob const *c = this; c; c = c->dim_cache_[a].parent_)
 494     for (Grob const *d = s; d; d = d->dim_cache_[a].parent_)
 495       if (d == c)
 496         return (Grob *) d;
 497
 498   return 0;
 499 }
 500
 501 Grob *
 502 common_refpoint_of_list (SCM elist, Grob *common, Axis a)
 503 {
 504   for (; scm_is_pair (elist); elist = scm_cdr (elist))
 505     if (Grob *s = unsmob_grob (scm_car (elist)))
 506       {
 507         if (common)
 508           common = common->common_refpoint (s, a);
 509         else
 510           common = s;
 511       }
 512
 513   return common;
 514 }
 515
 516 Grob *
 517 common_refpoint_of_array (Link_array<Grob> const &arr, Grob *common, Axis a)
 518 {
 519   for (int i = arr.size (); i--;)
 520     if (Grob *s = arr[i])
 521       {
 522         if (common)
 523           common = common->common_refpoint (s, a);
 524         else
 525           common = s;
 526       }
 527
 528   return common;
 529 }
 530
 531 String
 532 Grob::name () const
 533 {
 534   SCM meta = get_property ("meta");
 535   SCM nm = scm_assoc (ly_symbol2scm ("name"), meta);
 536   nm = (scm_is_pair (nm)) ? scm_cdr (nm) : SCM_EOL;
 537   return scm_is_symbol (nm) ? ly_symbol2string (nm) : classname (this);
 538 }
 539
 540 void
 541 Grob::add_offset_callback (SCM cb, Axis a)
 542 {
 543   if (!has_offset_callback (cb, a))
 544     {
 545       dim_cache_[a].offset_callbacks_
 546         = scm_cons (cb, dim_cache_[a].offset_callbacks_);
 547       dim_cache_[a].offsets_left_++;
 548     }
 549 }
 550
 551 bool
 552 Grob::has_extent_callback (SCM cb, Axis a) const
 553 {
 554   return scm_equal_p (cb, dim_cache_[a].dimension_callback_) == SCM_BOOL_T;
 555 }
 556
 557 bool
 558 Grob::has_offset_callback (SCM cb, Axis a) const
 559 {
 560   return scm_c_memq (cb, dim_cache_[a].offset_callbacks_) != SCM_BOOL_F;
 561 }
 562
 563 void
 564 Grob::set_extent (SCM dc, Axis a)
 565 {
 566   dim_cache_[a].dimension_ = dc;
 567 }
 568
 569 void
 570 Grob::set_extent_callback (SCM dc, Axis a)
 571 {
 572   dim_cache_[a].dimension_callback_ = dc;
 573 }
 574
 575 void
 576 Grob::set_parent (Grob *g, Axis a)
 577 {
 578   dim_cache_[a].parent_ = g;
 579 }
 580
 581 MAKE_SCHEME_CALLBACK (Grob, fixup_refpoint, 1);
 582 SCM
 583 Grob::fixup_refpoint (SCM smob)
 584 {
 585   Grob *me = unsmob_grob (smob);
 586   for (int a = X_AXIS; a < NO_AXES; a++)
 587     {
 588       Axis ax = (Axis)a;
 589       Grob *parent = me->get_parent (ax);
 590
 591       if (!parent)
 592         continue;
 593
 594       if (parent->get_system () != me->get_system () && me->get_system ())
 595         {
 596           Grob *newparent = parent->find_broken_piece (me->get_system ());
 597           me->set_parent (newparent, ax);
 598         }
 599
 600       if (Item *i = dynamic_cast<Item *> (me))
 601         {
 602           Item *parenti = dynamic_cast<Item *> (parent);
 603
 604           if (parenti && i)
 605             {
 606               Direction my_dir = i->break_status_dir ();
 607               if (my_dir != parenti->break_status_dir ())
 608                 {
 609                   Item *newparent = parenti->find_prebroken_piece (my_dir);
 610                   me->set_parent (newparent, ax);
 611                 }
 612             }
 613         }
 614     }
 615   return smob;
 616 }
 617
 618 void
 619 Grob::warning (String s) const
 620 {
 621   SCM cause = self_scm ();
 622   while (Grob *g = unsmob_grob (cause))
 623     cause = g->get_property ("cause");
 624
 625   if (Music *m = unsmob_music (cause))
 626     m->origin ()->warning (s);
 627   else
 628     ::warning (s);
 629 }
 630
 631 void
 632 Grob::programming_error (String s) const
 633 {
 634   s = "Programming error: " + s;
 635   warning (s);
 636 }
 637
 638 /****************************************************
 639   SMOB funcs
 640 ****************************************************/
 641
 642 IMPLEMENT_SMOBS (Grob);
 643 IMPLEMENT_DEFAULT_EQUAL_P (Grob);
 644
 645 SCM
 646 Grob::mark_smob (SCM ses)
 647 {
 648   Grob *s = (Grob *) SCM_CELL_WORD_1 (ses);
 649   scm_gc_mark (s->immutable_property_alist_);
 650   scm_gc_mark (s->key_->self_scm ());
 651   for (int a = 0; a < 2; a++)
 652     {
 653       scm_gc_mark (s->dim_cache_[a].offset_callbacks_);
 654       scm_gc_mark (s->dim_cache_[a].dimension_);
 655       scm_gc_mark (s->dim_cache_[a].dimension_callback_);
 656
 657       /* Do not mark the parents.  The pointers in the mutable
 658          property list form two tree like structures (one for X
 659          relations, one for Y relations).  Marking these can be done
 660          in limited stack space.  If we add the parents, we will jump
 661          between X and Y in an erratic manner, leading to much more
 662          recursion depth (and core dumps if we link to pthreads).  */
 663     }
 664
 665   if (s->original_)
 666     scm_gc_mark (s->original_->self_scm ());
 667
 668   if (s->pscore_)
 669     scm_gc_mark (s->pscore_->layout_->self_scm ());
 670
 671   s->do_derived_mark ();
 672   return s->mutable_property_alist_;
 673 }
 674
 675 int
 676 Grob::print_smob (SCM s, SCM port, scm_print_state *)
 677 {
 678   Grob *sc = (Grob *) SCM_CELL_WORD_1 (s);
 679
 680   scm_puts ("#<Grob ", port);
 681   scm_puts ((char *) sc->name ().to_str0 (), port);
 682
 683   /* Do not print properties, that is too much hassle.  */
 684   scm_puts (" >", port);
 685   return 1;
 686 }
 687
 688 SCM
 689 Grob::do_derived_mark () const
 690 {
 691   return SCM_EOL;
 692 }
 693
 694 void
 695 Grob::discretionary_processing ()
 696 {
 697 }
 698
 699 bool
 700 Grob::internal_has_interface (SCM k)
 701 {
 702   SCM ifs = get_property ("interfaces");
 703
 704   return scm_c_memq (k, ifs) != SCM_BOOL_F;
 705 }
 706
 707 Grob *
 708 Grob::get_parent (Axis a) const
 709 {
 710   return dim_cache_[a].parent_;
 711 }
 712
 713 /** Return Array of Grobs in SCM list LST */
 714 Link_array<Grob>
 715 ly_scm2grobs (SCM lst)
 716 {
 717   Link_array<Grob> arr;
 718
 719   for (SCM s = lst; scm_is_pair (s); s = scm_cdr (s))
 720     {
 721       SCM e = scm_car (s);
 722       arr.push (unsmob_grob (e));
 723     }
 724
 725   arr.reverse ();
 726   return arr;
 727 }
 728
 729 Object_key const *
 730 Grob::get_key () const
 731 {
 732   return key_;
 733 }
 734
 735 /** Return SCM list of Grob array A */
 736 SCM
 737 ly_grobs2scm (Link_array<Grob> a)
 738 {
 739   SCM s = SCM_EOL;
 740   for (int i = a.size (); i; i--)
 741     s = scm_cons (a[i - 1]->self_scm (), s);
 742
 743   return s;
 744 }
 745
 746 IMPLEMENT_TYPE_P (Grob, "ly:grob?");
 747
 748 ADD_INTERFACE (Grob, "grob-interface",
 749                "A grob represents a piece of music notation\n"
 750                "\n"
 751                "All grobs have an X and Y-position on the page.  These X and Y positions\n"
 752                "are stored in a relative format, so they can easily be combined by\n"
 753                "stacking them, hanging one grob to the side of another, and coupling\n"
 754                "them into a grouping objects.\n"
 755                "\n"
 756                "Each grob has a reference point (a.k.a.  parent): the position of a grob\n"
 757                "is stored relative to that reference point. For example the X-reference\n"
 758                "point of a staccato dot usually is the note head that it applies\n"
 759                "to. When the note head is moved, the staccato dot moves along\n"
 760                "automatically.\n"
 761                "\n"
 762                "A grob is often associated with a symbol, but some grobs do not print\n"
 763                "any symbols. They take care of grouping objects. For example, there is a\n"
 764                "separate grob that stacks staves vertically. The @ref{NoteCollision}\n"
 765                "is also an abstract grob: it only moves around chords, but doesn't print\n"
 766                "anything.\n"
 767                "\n"
 768                "Grobs have a properties: Scheme variables, that can be read and set. "
 769                "They have two types. Immutable variables "
 770                "define the default style and behavior.  They are shared between  many objects. "
 771                "They can be changed using @code{\\override} and @code{\\revert}. "
 772                "\n\n"
 773                "Mutable properties are variables that are specific to one grob. Typically, "
 774                "lists of other objects, or results from computations are stored in"
 775                "mutable properties: every call to set-grob-property (or its C++ equivalent) "
 776                "sets a mutable property. ",
 777                "X-offset-callbacks Y-offset-callbacks X-extent-callback stencil cause "
 778                "Y-extent-callback print-function extra-offset spacing-procedure "
 779                "context staff-symbol interfaces dependencies X-extent Y-extent extra-X-extent "
 780                "meta layer before-line-breaking-callback "
 781                "color "
 782                "axis-group-parent-X "
 783                "axis-group-parent-Y "
 784                "after-line-breaking-callback extra-Y-extent minimum-X-extent "
 785                "minimum-Y-extent transparent tweak-count tweak-rank");
 786