]> git.donarmstrong.com Git - lilypond.git/blob - lily/axis-group-interface.cc
silence some spurious warnings
[lilypond.git] / lily / axis-group-interface.cc
1 /*
2   axis-group-interface.cc -- implement Axis_group_interface
3
4   source file of the GNU LilyPond music typesetter
5
6   (c) 2000--2007 Han-Wen Nienhuys <hanwen@xs4all.nl>
7 */
8
9 #include "axis-group-interface.hh"
10
11 #include "align-interface.hh"
12 #include "directional-element-interface.hh"
13 #include "pointer-group-interface.hh"
14 #include "grob-array.hh"
15 #include "hara-kiri-group-spanner.hh"
16 #include "international.hh"
17 #include "paper-column.hh"
18 #include "paper-score.hh"
19 #include "separation-item.hh"
20 #include "system.hh"
21 #include "warn.hh"
22
23 void
24 Axis_group_interface::add_element (Grob *me, Grob *e)
25 {
26   SCM axes = me->get_property ("axes");
27   if (!scm_is_pair (axes))
28     programming_error ("axes should be nonempty");
29
30   for (SCM ax = axes; scm_is_pair (ax); ax = scm_cdr (ax))
31     {
32       Axis a = (Axis) scm_to_int (scm_car (ax));
33
34       if (!e->get_parent (a))
35         e->set_parent (me, a);
36
37       e->set_object ((a == X_AXIS)
38                      ? ly_symbol2scm ("axis-group-parent-X")
39                      : ly_symbol2scm ("axis-group-parent-Y"),
40                      me->self_scm ());
41     }
42
43   /* must be ordered, because Align_interface also uses
44      Axis_group_interface  */
45   Pointer_group_interface::add_grob (me, ly_symbol2scm ("elements"), e);
46 }
47
48 bool
49 Axis_group_interface::has_axis (Grob *me, Axis a)
50 {
51   SCM axes = me->get_property ("axes");
52
53   return (SCM_BOOL_F != scm_memq (scm_from_int (a), axes));
54 }
55
56 Interval
57 Axis_group_interface::relative_group_extent (vector<Grob*> const &elts,
58                                              Grob *common, Axis a)
59 {
60   Interval r;
61   for (vsize i = 0; i < elts.size (); i++)
62     {
63       Grob *se = elts[i];
64       if (!to_boolean (se->get_property ("cross-staff")))
65         {
66           Interval dims = se->extent (common, a);
67           if (!dims.is_empty ())
68             r.unite (dims);
69         }
70     }
71   return r;
72 }
73
74
75 /*
76   FIXME: pure extent handling has a lot of ad-hoc caching.
77   This should be done with grob property callbacks.
78
79   --hwn
80 */
81
82 Interval
83 Axis_group_interface::cached_pure_height (Grob *me,
84                                           vector<Grob*> const &elts,
85                                           Grob *common,
86                                           int start, int end)
87 {
88   Paper_score *ps = get_root_system (me)->paper_score ();
89   vector<vsize> breaks = ps->get_break_indices ();
90   vector<Grob*> cols = ps->get_columns ();
91   vsize start_index = VPOS;
92   vsize end_index = VPOS;
93
94   for (vsize i = 0; i < breaks.size (); i++)
95     {
96       int r = Paper_column::get_rank (cols[breaks[i]]);
97       if (start == r)
98         start_index = i;
99       if (end == r)
100         end_index = i;
101     }
102   if (end == INT_MAX)
103     end_index = breaks.size () - 1;
104
105   if (start_index == VPOS || end_index == VPOS)
106     {
107       programming_error (_ ("tried to calculate pure-height at a non-breakpoint"));
108       return Interval (0, 0);
109     }
110
111   SCM extents = me->get_property ("cached-pure-extents");
112   if (!scm_is_vector (extents))
113     {
114       extents = scm_c_make_vector (breaks.size () - 1, SCM_EOL);
115       for (vsize i = 0; i + 1 < breaks.size (); i++)
116         {
117           int st = Paper_column::get_rank (cols[breaks[i]]);
118           int ed = Paper_column::get_rank (cols[breaks[i+1]]);
119           Interval iv = relative_pure_height (me, elts, common, st, ed, false);
120           scm_vector_set_x (extents, scm_from_int (i), ly_interval2scm (iv));
121         }
122       me->set_property ("cached-pure-extents", extents);
123     }
124
125   Interval ext (0, 0);
126   for (vsize i = start_index; i < end_index; i++)
127     ext.unite (ly_scm2interval (scm_c_vector_ref (extents, i)));
128   return ext;
129 }
130
131 Interval
132 Axis_group_interface::relative_pure_height (Grob *me,
133                                             vector<Grob*> const &elts,
134                                             Grob *common,
135                                             int start, int end,
136                                             bool use_cache)
137 {
138   /* It saves a _lot_ of time if we assume a VerticalAxisGroup is additive
139      (ie. height (i, k) = height (i, j) + height (j, k) for all i <= j <= k).
140      Unfortunately, it isn't always true, particularly if there is a
141      VerticalAlignment somewhere in the descendants.
142
143      Apart from PianoStaff, which has a fixed VerticalAlignment so it doesn't
144      count, the only VerticalAlignment comes from Score. This makes it
145      reasonably safe to assume that if our parent is a VerticalAlignment,
146      we can assume additivity and cache things nicely. */
147   Grob *p = me->get_parent (Y_AXIS);
148   if (use_cache && p && Align_interface::has_interface (p))
149     return Axis_group_interface::cached_pure_height (me, elts, common, start, end);
150
151   Interval r;
152
153   for (vsize i = 0; i < elts.size (); i++)
154     {
155       Interval_t<int> rank_span = elts[i]->spanned_rank_iv ();
156       Item *it = dynamic_cast<Item*> (elts[i]);
157       if (rank_span[LEFT] <= end && rank_span[RIGHT] >= start && (!it || it->pure_is_visible (start, end)))
158         {
159           Interval dims = elts[i]->pure_height (common, start, end);
160           if (!dims.is_empty ())
161             r.unite (dims);
162         }
163     }
164   return r;
165 }
166
167 MAKE_SCHEME_CALLBACK (Axis_group_interface, width, 1);
168 SCM
169 Axis_group_interface::width (SCM smob)
170 {
171   Grob *me = unsmob_grob (smob);
172   return generic_group_extent (me, X_AXIS);
173 }
174
175 MAKE_SCHEME_CALLBACK (Axis_group_interface, height, 1);
176 SCM
177 Axis_group_interface::height (SCM smob)
178 {
179   Grob *me = unsmob_grob (smob);
180   return generic_group_extent (me, Y_AXIS);
181 }
182
183 MAKE_SCHEME_CALLBACK (Axis_group_interface, pure_height, 3);
184 SCM
185 Axis_group_interface::pure_height (SCM smob, SCM start_scm, SCM end_scm)
186 {
187   int start = robust_scm2int (start_scm, 0);
188   int end = robust_scm2int (end_scm, INT_MAX);
189   Grob *me = unsmob_grob (smob);
190
191   /* Maybe we are in the second pass of a two-pass spacing run. In that
192      case, the Y-extent of a system is already given to us */
193   System *system = dynamic_cast<System*> (me);
194   if (system)
195     {
196       SCM line_break_details = system->column (start)->get_property ("line-break-system-details");
197       SCM system_y_extent = scm_assq (ly_symbol2scm ("system-Y-extent"), line_break_details);
198       if (scm_is_pair (system_y_extent))
199         return scm_cdr (system_y_extent);
200     }
201
202   return pure_group_height (me, start, end);
203 }
204
205 MAKE_SCHEME_CALLBACK (Axis_group_interface, calc_skylines, 1);
206 SCM
207 Axis_group_interface::calc_skylines (SCM smob)
208 {
209   Grob *me = unsmob_grob (smob);
210   extract_grob_set (me, "elements", elts);
211   return skyline_spacing (me, elts).smobbed_copy ();
212 }
213
214 /* whereas calc_skylines calculates skylines for axis-groups with a lot of
215    visible children, combine_skylines is designed for axis-groups whose only
216    children are other axis-groups (ie. VerticalAlignment). Rather than
217    calculating all the skylines from scratch, we just merge the skylines
218    of the children.
219 */
220 MAKE_SCHEME_CALLBACK (Axis_group_interface, combine_skylines, 1);
221 SCM
222 Axis_group_interface::combine_skylines (SCM smob)
223 {
224   Grob *me = unsmob_grob (smob);
225   extract_grob_set (me, "elements", elements);
226   Grob *y_common = common_refpoint_of_array (elements, me, Y_AXIS);
227
228   assert (y_common == me);
229
230   Skyline_pair ret;
231   for (vsize i = 0; i < elements.size (); i++)
232     {
233       SCM skyline_scm = elements[i]->get_property ("skylines");
234       if (Skyline_pair::unsmob (skyline_scm))
235         {
236           Real offset = elements[i]->relative_coordinate (y_common, Y_AXIS);
237           Skyline_pair other = *Skyline_pair::unsmob (skyline_scm);
238           other.raise (offset);
239           ret.merge (other);
240         }
241     }
242   return ret.smobbed_copy ();
243 }
244   
245 SCM
246 Axis_group_interface::generic_group_extent (Grob *me, Axis a)
247 {
248   /* trigger the callback to do skyline-spacing on the children */
249   (void) me->get_property ("skylines");
250
251   extract_grob_set (me, "elements", elts);
252   Grob *common = common_refpoint_of_array (elts, me, a);
253
254   Real my_coord = me->relative_coordinate (common, a);
255   Interval r (relative_group_extent (elts, common, a));
256
257   return ly_interval2scm (r - my_coord);
258 }
259
260
261 Grob *
262 Axis_group_interface::calc_pure_elts_and_common (Grob *me)
263 {
264   if (Grob *c = unsmob_grob (me->get_object ("pure-Y-common")))
265     return c;
266   
267   extract_grob_set (me, "elements", elts);
268
269   vector<Grob*> relevant_elts;
270   SCM pure_relevant_p = ly_lily_module_constant ("pure-relevant?");
271
272   for (vsize i = 0; i < elts.size (); i++)
273     {
274       if (to_boolean (scm_apply_1 (pure_relevant_p, elts[i]->self_scm (), SCM_EOL)))
275         relevant_elts.push_back (elts[i]);
276
277       Item *it = dynamic_cast<Item*> (elts[i]);
278       Direction d = LEFT;
279       if (it)
280         do
281           {
282             Item *piece = it->find_prebroken_piece (d);
283             if (piece && to_boolean (scm_apply_1 (pure_relevant_p, piece->self_scm (), SCM_EOL)))
284               relevant_elts.push_back (piece);
285           }
286         while (flip (&d) != LEFT);
287     }
288
289   Grob *common = common_refpoint_of_array (relevant_elts, me, Y_AXIS);
290   me->set_object ("pure-Y-common", common->self_scm ());
291   
292   SCM ga_scm = Grob_array::make_array ();
293   Grob_array *ga = unsmob_grob_array (ga_scm);
294   ga->set_array (relevant_elts);
295   me->set_object ("pure-relevant-elements", ga_scm);
296
297   return common;
298 }
299
300 MAKE_SCHEME_CALLBACK (Axis_group_interface, calc_x_common, 1);
301 SCM
302 Axis_group_interface::calc_x_common (SCM grob)
303 {
304   Grob *me = unsmob_grob (grob);
305
306   extract_grob_set (me, "elements", elts);
307   Grob *common = common_refpoint_of_array (elts, me, X_AXIS);
308   return common->self_scm ();
309 }
310
311 MAKE_SCHEME_CALLBACK (Axis_group_interface, calc_y_common, 1);
312 SCM
313 Axis_group_interface::calc_y_common (SCM grob)
314 {
315   Grob *me = unsmob_grob (grob);
316
317   extract_grob_set (me, "elements", elts);
318   Grob *common = common_refpoint_of_array (elts, me, Y_AXIS);
319   return common->self_scm ();
320 }
321
322 SCM
323 Axis_group_interface::pure_group_height (Grob *me, int start, int end)
324 {
325   Grob *common = calc_pure_elts_and_common (me);
326         
327   extract_grob_set (me, "pure-relevant-elements", elts);
328   Real my_coord = me->relative_coordinate (common, Y_AXIS);
329   Interval r (relative_pure_height (me, elts, common, start, end, true));
330
331   return ly_interval2scm (r - my_coord);
332 }
333
334 void
335 Axis_group_interface::get_children (Grob *me, vector<Grob*> *found)
336 {
337   found->push_back (me);
338
339   if (!has_interface (me))
340     return;
341
342   extract_grob_set (me, "elements", elements);
343   for (vsize i = 0; i < elements.size (); i++)
344     {
345       Grob *e = elements[i];
346       Axis_group_interface::get_children (e, found);
347     }
348 }
349
350 bool
351 staff_priority_less (Grob * const &g1, Grob * const &g2)
352 {
353   Real priority_1 = robust_scm2double (g1->get_property ("outside-staff-priority"), -infinity_f);
354   Real priority_2 = robust_scm2double (g2->get_property ("outside-staff-priority"), -infinity_f);
355
356   if (priority_1 < priority_2)
357     return true;
358   else if (priority_1 > priority_2)
359     return false;
360
361   /* if neither grob has an outside-staff priority, the ordering will have no
362      effect -- we just need to choose a consistent ordering. We do this to
363      avoid the side-effect of calculating extents. */
364   if (isinf (priority_1))
365     return g1 < g2;
366
367   /* if there is no preference in staff priority, choose the left-most one */
368   Grob *common = g1->common_refpoint (g2, X_AXIS);
369   Real start_1 = g1->extent (common, X_AXIS)[LEFT];
370   Real start_2 = g2->extent (common, X_AXIS)[LEFT];
371   return start_1 < start_2;
372 }
373
374 static void
375 add_boxes (Grob *me, Grob *x_common, Grob *y_common, vector<Box> *const boxes)
376 {
377   /* if we are a parent, consider the children's boxes instead of mine */
378   if (Grob_array *elements = unsmob_grob_array (me->get_object ("elements")))
379     {
380       for (vsize i = 0; i < elements->size (); i++)
381         add_boxes (elements->grob (i), x_common, y_common, boxes);
382     }
383   else if (!scm_is_number (me->get_property ("outside-staff-priority"))
384            && !to_boolean (me->get_property ("cross-staff")))
385     boxes->push_back (Box (me->extent (x_common, X_AXIS),
386                            me->extent (y_common, Y_AXIS)));
387 }
388
389 /* We want to avoid situations like this:
390            still more text
391       more text
392    text
393    -------------------
394    staff
395    -------------------
396
397    The point is that "still more text" should be positioned under
398    "more text".  In order to achieve this, we place the grobs in several
399    passes.  We keep track of the right-most horizontal position that has been
400    affected by the current pass so far (actually we keep track of 2
401    positions, one for above the staff, one for below).
402
403    In each pass, we loop through the unplaced grobs from left to right.
404    If the grob overlaps the right-most affected position, we place it
405    (and then update the right-most affected position to point to the right
406    edge of the just-placed grob).  Otherwise, we skip it until the next pass.
407 */
408 static void
409 add_grobs_of_one_priority (Skyline_pair *const skylines,
410                            vector<Grob*> elements,
411                            Grob *x_common,
412                            Grob *y_common)
413 {
414   vector<Box> boxes;
415   Drul_array<Real> last_affected_position;
416
417   reverse (elements);
418   while (!elements.empty ())
419     {
420       last_affected_position[UP] = -infinity_f;
421       last_affected_position[DOWN] = -infinity_f;
422       /* do one pass */
423       for (vsize i = elements.size (); i--;)
424         {
425           Direction dir = get_grob_direction (elements[i]);
426           if (dir == CENTER)
427             {
428               warning (_ ("an outside-staff object should have a direction, defaulting to up"));
429               dir = UP;
430             }
431
432           Box b (elements[i]->extent (x_common, X_AXIS),
433                  elements[i]->extent (y_common, Y_AXIS));
434           SCM horizon_padding_scm = elements[i]->get_property ("outside-staff-horizontal-padding");
435           Real horizon_padding = robust_scm2double (horizon_padding_scm, 0.0);
436
437           if (b[X_AXIS][LEFT] - 2*horizon_padding < last_affected_position[dir])
438             continue;
439
440           if (!b[X_AXIS].is_empty () && !b[Y_AXIS].is_empty ())
441             {
442               boxes.clear ();
443               boxes.push_back (b);
444               Skyline other = Skyline (boxes, horizon_padding, X_AXIS, -dir);
445               Real padding = robust_scm2double (elements[i]->get_property ("outside-staff-padding"), 0.5);
446               Real dist = (*skylines)[dir].distance (other) + padding;
447
448               if (dist > 0)
449                 {
450                   b.translate (Offset (0, dir*dist));
451                   elements[i]->translate_axis (dir*dist, Y_AXIS);
452                 }
453               (*skylines)[dir].insert (b, 0, X_AXIS);
454               elements[i]->set_property ("outside-staff-priority", SCM_BOOL_F);
455               last_affected_position[dir] = b[X_AXIS][RIGHT];
456             }
457
458           /*
459             Ugh: quadratic. --hwn
460            */
461           elements.erase (elements.begin () + i);
462         }
463     }
464 }
465
466 Skyline_pair
467 Axis_group_interface::skyline_spacing (Grob *me, vector<Grob*> elements)
468 {
469   vector_sort (elements, staff_priority_less);
470   Grob *x_common = common_refpoint_of_array (elements, me, X_AXIS);
471   Grob *y_common = common_refpoint_of_array (elements, me, Y_AXIS);
472
473   assert (y_common == me);
474
475   vsize i = 0;
476   vector<Box> boxes;
477
478   for (i = 0; i < elements.size ()
479          && !scm_is_number (elements[i]->get_property ("outside-staff-priority")); i++)
480     add_boxes (elements[i], x_common, y_common, &boxes);
481
482   Skyline_pair skylines (boxes, 0, X_AXIS);
483   for (; i < elements.size (); i++)
484     {
485       SCM priority = elements[i]->get_property ("outside-staff-priority");
486       vector<Grob*> current_elts;
487       current_elts.push_back (elements[i]);
488       while (i + 1 < elements.size () 
489              && scm_eq_p (elements[i+1]->get_property ("outside-staff-priority"), priority))
490         current_elts.push_back (elements[++i]);
491
492       add_grobs_of_one_priority (&skylines, current_elts, x_common, y_common);
493     }
494   return skylines;
495 }
496
497 MAKE_SCHEME_CALLBACK (Axis_group_interface, calc_max_stretch, 1)
498 SCM
499 Axis_group_interface::calc_max_stretch (SCM smob)
500 {
501   Grob *me = unsmob_grob (smob);
502   Real ret = 0;
503   extract_grob_set (me, "elements", elts);
504
505   for (vsize i = 0; i < elts.size (); i++)
506     if (Axis_group_interface::has_interface (elts[i]))
507       ret += robust_scm2double (elts[i]->get_property ("max-stretch"), 0.0);
508
509   return scm_from_double (ret);
510 }
511
512 ADD_INTERFACE (Axis_group_interface,
513
514                "An object that groups other layout objects.",
515
516                /* properties */
517                "X-common "
518                "Y-common "
519                "axes "
520                "elements "
521                "keep-fixed-while-stretching "
522                "max-stretch "
523                "pure-Y-common "
524                "pure-relevant-elements "
525                "skylines "
526                "cached-pure-extents "
527                );