2 This file is part of LilyPond, the GNU music typesetter.
4 Copyright (C) 1997--2011 Han-Wen Nienhuys <hanwen@xs4all.nl>
6 LilyPond is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
11 LilyPond is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with LilyPond. If not, see <http://www.gnu.org/licenses/>.
24 #include "align-interface.hh"
25 #include "axis-group-interface.hh"
27 #include "international.hh"
32 #include "output-def.hh"
33 #include "pointer-group-interface.hh"
34 #include "program-option.hh"
36 #include "stream-event.hh"
40 #include "ly-smobs.icc"
45 return new Grob (*this);
48 Grob::Grob (SCM basicprops)
51 /* FIXME: default should be no callback. */
55 interfaces_ = SCM_EOL;
56 immutable_property_alist_ = basicprops;
57 mutable_property_alist_ = SCM_EOL;
58 object_alist_ = SCM_EOL;
60 /* We do smobify_self () as the first step. Since the object lives
61 on the heap, none of its SCM variables are protected from
62 GC. After smobify_self (), they are. */
65 SCM meta = get_property ("meta");
66 if (scm_is_pair (meta))
68 interfaces_ = scm_cdr (scm_assq (ly_symbol2scm ("interfaces"), meta));
70 SCM object_cbs = scm_assq (ly_symbol2scm ("object-callbacks"), meta);
71 if (scm_is_pair (object_cbs))
73 for (SCM s = scm_cdr (object_cbs); scm_is_pair (s); s = scm_cdr (s))
74 set_object (scm_caar (s), scm_cdar (s));
78 if (get_property_data ("X-extent") == SCM_EOL)
79 set_property ("X-extent", Grob::stencil_width_proc);
80 if (get_property_data ("Y-extent") == SCM_EOL)
81 set_property ("Y-extent", Grob::stencil_height_proc);
84 Grob::Grob (Grob const &s)
85 : dim_cache_ (s.dim_cache_)
87 original_ = (Grob *) & s;
90 immutable_property_alist_ = s.immutable_property_alist_;
91 mutable_property_alist_ = SCM_EOL;
92 interfaces_ = s.interfaces_;
93 object_alist_ = SCM_EOL;
99 mutable_property_alist_ = ly_deep_copy (s.mutable_property_alist_);
106 /****************************************************************
108 ****************************************************************/
111 Grob::get_stencil () const
116 SCM stil = get_property ("stencil");
117 return unsmob_stencil (stil);
121 Grob::get_print_stencil () const
123 SCM stil = get_property ("stencil");
126 if (Stencil *m = unsmob_stencil (stil))
129 bool transparent = to_boolean (get_property ("transparent"));
132 retval = Stencil (m->extent_box (), SCM_EOL);
135 SCM expr = m->expr ();
136 expr = scm_list_3 (ly_symbol2scm ("grob-cause"),
139 retval = Stencil (m->extent_box (), expr);
142 SCM rot = get_property ("rotation");
143 if (scm_is_pair (rot))
145 Real angle = scm_to_double (scm_car (rot));
146 Real x = scm_to_double (scm_cadr (rot));
147 Real y = scm_to_double (scm_caddr (rot));
149 retval.rotate_degrees (angle, Offset (x, y));
152 /* color support... see interpret_stencil_expression () for more... */
153 SCM color = get_property ("color");
154 if (scm_is_pair (color))
156 SCM expr = scm_list_3 (ly_symbol2scm ("color"),
160 retval = Stencil (retval.extent_box (), expr);
163 /* process whiteout */
164 /* a grob has to be visible, otherwise the whiteout property has no effect */
165 if (!transparent && to_boolean (get_property ("whiteout")))
167 /* Call the scheme procedure stencil-whiteout in scm/stencils.scm */
168 /* to add a round-filled-box stencil to the stencil list */
170 = *unsmob_stencil (scm_call_1 (ly_lily_module_constant ("stencil-whiteout"),
171 retval.smobbed_copy ()));
178 /****************************************************************
180 ****************************************************************/
182 Grob::do_break_processing ()
187 Grob::discretionary_processing ()
192 Grob::get_system () const
197 /* This version of get_system is more reliable than this->get_system ()
198 before line-breaking has been done, at which point there is only
199 one system in the whole score and we can find it just by following
202 Grob::get_system (Grob *me)
204 Grob *p = me->get_parent (X_AXIS);
205 return p ? get_system (p) : dynamic_cast<System *>(me);
209 Grob::handle_broken_dependencies ()
211 Spanner *sp = dynamic_cast<Spanner *> (this);
212 if (original () && sp)
216 /* THIS, SP is the original spanner. We use a special function
217 because some Spanners have enormously long lists in their
218 properties, and a special function fixes FOO */
220 for (SCM s = object_alist_; scm_is_pair (s); s = scm_cdr (s))
221 sp->substitute_one_mutable_property (scm_caar (s), scm_cdar (s));
223 System *system = get_system ();
227 && common_refpoint (system, X_AXIS)
228 && common_refpoint (system, Y_AXIS))
229 substitute_object_links (system->self_scm (), object_alist_);
230 else if (dynamic_cast<System *> (this))
231 substitute_object_links (SCM_UNDEFINED, object_alist_);
233 /* THIS element is `invalid'; it has been removed from all
234 dependencies, so let's junk the element itself.
236 Do not do this for System, since that would remove references
237 to the originals of score-grobs, which get then GC'd (a bad
242 /* Note that we still want references to this element to be
243 rearranged, and not silently thrown away, so we keep pointers like
244 {broken_into_{drul, array}, original}
252 for (int a = X_AXIS; a < NO_AXES; a++)
253 dim_cache_[a].clear ();
255 mutable_property_alist_ = SCM_EOL;
256 object_alist_ = SCM_EOL;
257 immutable_property_alist_ = SCM_EOL;
258 interfaces_ = SCM_EOL;
262 Grob::handle_prebroken_dependencies ()
264 /* Don't do this in the derived method, since we want to keep access to
265 object_alist_ centralized. */
268 Item *it = dynamic_cast<Item *> (this);
269 substitute_object_links (scm_from_int (it->break_status_dir ()),
270 original ()->object_alist_);
275 Grob::find_broken_piece (System *) const
280 /****************************************************************
282 ****************************************************************/
285 Grob::translate_axis (Real y, Axis a)
287 if (isinf (y) || isnan (y))
289 programming_error (_ ("Infinity or NaN encountered"));
293 if (!dim_cache_[a].offset_)
294 dim_cache_[a].offset_ = new Real (y);
296 *dim_cache_[a].offset_ += y;
299 /* Find the offset relative to D. If D equals THIS, then it is 0.
300 Otherwise, it recursively defd as
302 OFFSET_ + PARENT_L_->relative_coordinate (D) */
304 Grob::relative_coordinate (Grob const *refp, Axis a) const
306 /* eaa - hmmm, should we do a programming_error() here? */
307 if ((this == NULL) || (refp == this))
310 /* We catch PARENT_L_ == nil case with this, but we crash if we did
311 not ask for the absolute coordinate (ie. REFP == nil.) */
312 Real off = get_offset (a);
313 if (refp == dim_cache_[a].parent_)
316 off += dim_cache_[a].parent_->relative_coordinate (refp, a);
322 Grob::pure_relative_y_coordinate (Grob const *refp, int start, int end)
329 if (dim_cache_[Y_AXIS].offset_)
331 if (to_boolean (get_property ("pure-Y-offset-in-progress")))
332 programming_error ("cyclic chain in pure-Y-offset callbacks");
334 off = *dim_cache_[Y_AXIS].offset_;
338 SCM proc = get_property_data ("Y-offset");
340 dim_cache_[Y_AXIS].offset_ = new Real (0.0);
341 set_property ("pure-Y-offset-in-progress", SCM_BOOL_T);
342 off = robust_scm2double (call_pure_function (proc,
343 scm_list_1 (self_scm ()),
346 del_property ("pure-Y-offset-in-progress");
347 delete dim_cache_[Y_AXIS].offset_;
348 dim_cache_[Y_AXIS].offset_ = 0;
351 /* we simulate positioning-done if we are the child of a VerticalAlignment,
352 but only if we don't have a cached offset. If we do have a cached offset,
353 it probably means that the Alignment was fixed and it has already been
356 if (Grob *p = get_parent (Y_AXIS))
359 if (Align_interface::has_interface (p) && !dim_cache_[Y_AXIS].offset_)
360 trans = Align_interface::get_pure_child_y_translation (p, this, start, end);
362 return off + trans + p->pure_relative_y_coordinate (refp, start, end);
367 /* Invoke callbacks to get offset relative to parent. */
369 Grob::get_offset (Axis a) const
371 if (dim_cache_[a].offset_)
372 return *dim_cache_[a].offset_;
374 Grob *me = (Grob *) this;
376 SCM sym = axis_offset_symbol (a);
377 me->dim_cache_[a].offset_ = new Real (0.0);
380 UGH: can't fold next 2 statements together. Apparently GCC thinks
381 dim_cache_[a].offset_ is unaliased.
383 Real off = robust_scm2double (internal_get_property (sym), 0.0);
384 if (me->dim_cache_[a].offset_)
386 *me->dim_cache_[a].offset_ += off;
387 me->del_property (sym);
388 return *me->dim_cache_[a].offset_;
395 Grob::maybe_pure_coordinate (Grob const *refp, Axis a, bool pure, int start, int end)
397 if (pure && a != Y_AXIS)
398 programming_error ("tried to get pure X-offset");
399 return (pure && a == Y_AXIS) ? pure_relative_y_coordinate (refp, start, end)
400 : relative_coordinate (refp, a);
403 /****************************************************************
405 ****************************************************************/
408 Grob::flush_extent_cache (Axis axis)
410 if (dim_cache_[axis].extent_)
413 Ugh, this is not accurate; will flush property, causing
414 callback to be called if.
416 del_property ((axis == X_AXIS) ? ly_symbol2scm ("X-extent") : ly_symbol2scm ("Y-extent"));
417 delete dim_cache_[axis].extent_;
418 dim_cache_[axis].extent_ = 0;
419 if (get_parent (axis))
420 get_parent (axis)->flush_extent_cache (axis);
425 Grob::extent (Grob *refp, Axis a) const
427 Real offset = relative_coordinate (refp, a);
429 if (dim_cache_[a].extent_)
431 real_ext = *dim_cache_[a].extent_;
436 Order is significant: ?-extent may trigger suicide.
440 ? ly_symbol2scm ("X-extent")
441 : ly_symbol2scm ("Y-extent");
443 SCM ext = internal_get_property (ext_sym);
444 if (is_number_pair (ext))
445 real_ext.unite (ly_scm2interval (ext));
449 ? ly_symbol2scm ("minimum-X-extent")
450 : ly_symbol2scm ("minimum-Y-extent");
451 SCM min_ext = internal_get_property (min_ext_sym);
452 if (is_number_pair (min_ext))
453 real_ext.unite (ly_scm2interval (min_ext));
455 ((Grob *)this)->dim_cache_[a].extent_ = new Interval (real_ext);
458 real_ext.translate (offset);
464 Grob::pure_height (Grob *refp, int start, int end)
466 SCM iv_scm = get_pure_property ("Y-extent", start, end);
467 Interval iv = robust_scm2interval (iv_scm, Interval (0, 0));
468 Real offset = pure_relative_y_coordinate (refp, start, end);
470 SCM min_ext = get_property ("minimum-Y-extent");
472 /* we don't add minimum-Y-extent if the extent is empty. This solves
473 a problem with Hara-kiri spanners. They would request_suicide and
474 return empty extents, but we would force them here to be large. */
475 if (!iv.is_empty () && is_number_pair (min_ext))
476 iv.unite (ly_scm2interval (min_ext));
479 iv.translate (offset);
484 Grob::maybe_pure_extent (Grob *refp, Axis a, bool pure, int start, int end)
486 if (pure && a != Y_AXIS)
487 programming_error ("tried to get pure width");
488 return (pure && a == Y_AXIS) ? pure_height (refp, start, end) : extent (refp, a);
492 Grob::spanned_rank_interval () const
494 return Interval_t<int> (-1, 0);
498 Grob::pure_is_visible (int /* start */, int /* end */) const
503 /* Sort grobs according to their starting column. */
505 Grob::less (Grob *g1, Grob *g2)
507 return g1->spanned_rank_interval ()[LEFT] < g2->spanned_rank_interval ()[LEFT];
510 /****************************************************************
512 ****************************************************************/
514 /* Find the group-element which has both #this# and #s# */
516 Grob::common_refpoint (Grob const *s, Axis a) const
518 /* I don't like the quadratic aspect of this code, but I see no
519 other way. The largest chain of parents might be 10 high or so,
520 so it shouldn't be a real issue. */
521 for (Grob const *c = this; c; c = c->dim_cache_[a].parent_)
522 for (Grob const *d = s; d; d = d->dim_cache_[a].parent_)
530 Grob::set_parent (Grob *g, Axis a)
532 dim_cache_[a].parent_ = g;
536 Grob::get_parent (Axis a) const
538 return dim_cache_[a].parent_;
542 Grob::fixup_refpoint ()
544 for (int a = X_AXIS; a < NO_AXES; a++)
547 Grob *parent = get_parent (ax);
552 if (parent->get_system () != get_system () && get_system ())
554 Grob *newparent = parent->find_broken_piece (get_system ());
555 set_parent (newparent, ax);
558 if (Item *i = dynamic_cast<Item *> (this))
560 Item *parenti = dynamic_cast<Item *> (parent);
564 Direction my_dir = i->break_status_dir ();
565 if (my_dir != parenti->break_status_dir ())
567 Item *newparent = parenti->find_prebroken_piece (my_dir);
568 set_parent (newparent, ax);
575 /****************************************************************
577 ****************************************************************/
579 Grob::programming_error (string s) const
581 SCM cause = self_scm ();
582 while (Grob *g = unsmob_grob (cause))
583 cause = g->get_property ("cause");
585 /* ES TODO: cause can't be Music*/
586 if (Music *m = unsmob_music (cause))
587 m->origin ()->programming_error (s);
588 else if (Stream_event *ev = unsmob_stream_event (cause))
589 ev->origin ()->programming_error (s);
591 ::programming_error (s);
595 Grob::warning (string s) const
597 SCM cause = self_scm ();
598 while (Grob *g = unsmob_grob (cause))
599 cause = g->get_property ("cause");
601 /* ES TODO: cause can't be Music*/
602 if (Music *m = unsmob_music (cause))
603 m->origin ()->warning (s);
604 else if (Stream_event *ev = unsmob_stream_event (cause))
605 ev->origin ()->warning (s);
613 SCM meta = get_property ("meta");
614 SCM nm = scm_assq (ly_symbol2scm ("name"), meta);
615 nm = (scm_is_pair (nm)) ? scm_cdr (nm) : SCM_EOL;
616 return scm_is_symbol (nm) ? ly_symbol2string (nm) : this->class_name ();
620 "A grob represents a piece of music notation.\n"
622 "All grobs have an X and Y@tie{}position on the page. These"
623 " X and Y@tie{}positions are stored in a relative format, thus"
624 " they can easily be combined by stacking them, hanging one"
625 " grob to the side of another, or coupling them into grouping"
628 "Each grob has a reference point (a.k.a.@: parent): The"
629 " position of a grob is stored relative to that reference"
630 " point. For example, the X@tie{}reference point of a staccato"
631 " dot usually is the note head that it applies to. When the"
632 " note head is moved, the staccato dot moves along"
635 "A grob is often associated with a symbol, but some grobs do"
636 " not print any symbols. They take care of grouping objects."
637 " For example, there is a separate grob that stacks staves"
638 " vertically. The @ref{NoteCollision} object is also an"
639 " abstract grob: It only moves around chords, but doesn't print"
642 "Grobs have properties (Scheme variables) that can be read and"
643 " set. Two types of them exist: immutable and mutable."
644 " Immutable variables define the default style and behavior."
645 " They are shared between many objects. They can be changed"
646 " using @code{\\override} and @code{\\revert}. Mutable"
647 " properties are variables that are specific to one grob."
648 " Typically, lists of other objects, or results from"
649 " computations are stored in mutable properties. In"
650 " particular, every call to @code{ly:grob-set-property!}"
651 " (or its C++ equivalent) sets a mutable property.\n"
653 "The properties @code{after-line-breaking} and"
654 " @code{before-line-breaking} are dummies that are not"
655 " user-serviceable.",
662 "after-line-breaking "
664 "axis-group-parent-X "
665 "axis-group-parent-Y "
666 "before-line-breaking "
678 "outside-staff-horizontal-padding "
679 "outside-staff-padding "
680 "outside-staff-priority "
681 "pure-Y-offset-in-progress "
690 /****************************************************************
692 ****************************************************************/
695 grob_stencil_extent (Grob *me, Axis a)
697 Stencil *m = me->get_stencil ();
701 return ly_interval2scm (e);
704 MAKE_SCHEME_CALLBACK (Grob, stencil_height, 1);
706 Grob::stencil_height (SCM smob)
708 Grob *me = unsmob_grob (smob);
709 return grob_stencil_extent (me, Y_AXIS);
712 MAKE_SCHEME_CALLBACK (Grob, y_parent_positioning, 1);
714 Grob::y_parent_positioning (SCM smob)
716 Grob *me = unsmob_grob (smob);
717 Grob *par = me->get_parent (Y_AXIS);
719 (void) par->get_property ("positioning-done");
721 return scm_from_double (0.0);
724 MAKE_SCHEME_CALLBACK (Grob, x_parent_positioning, 1);
726 Grob::x_parent_positioning (SCM smob)
728 Grob *me = unsmob_grob (smob);
730 Grob *par = me->get_parent (X_AXIS);
732 (void) par->get_property ("positioning-done");
734 return scm_from_double (0.0);
737 MAKE_SCHEME_CALLBACK (Grob, stencil_width, 1);
739 Grob::stencil_width (SCM smob)
741 Grob *me = unsmob_grob (smob);
742 return grob_stencil_extent (me, X_AXIS);
746 common_refpoint_of_list (SCM elist, Grob *common, Axis a)
748 for (; scm_is_pair (elist); elist = scm_cdr (elist))
749 if (Grob *s = unsmob_grob (scm_car (elist)))
752 common = common->common_refpoint (s, a);
761 common_refpoint_of_array (vector<Grob *> const &arr, Grob *common, Axis a)
763 for (vsize i = 0; i < arr.size (); i++)
765 common = common->common_refpoint (arr[i], a);
773 robust_relative_extent (Grob *me, Grob *refpoint, Axis a)
775 Interval ext = me->extent (refpoint, a);
777 ext.add_point (me->relative_coordinate (refpoint, a));
782 // Checks whether there is a vertical alignment in the chain of
783 // parents between this and commony.
785 Grob::check_cross_staff (Grob *commony)
787 if (Align_interface::has_interface (commony))
790 for (Grob *g = this; g && g != commony; g = g->get_parent (Y_AXIS))
791 if (Align_interface::has_interface (g))