lily/hara-kiri-group-spanner.cc

   1 /*
   2   hara-kiri-vertical-group-spanner.cc -- implement Hara_kiri_group_spanner
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 1998--2007 Jan Nieuwenhuizen <janneke@gnu.org>
   7   Han-Wen Nienhuys <hanwen@xs4all.nl>
   8 */
   9
  10 #include "hara-kiri-group-spanner.hh"
  11
  12 #include "paper-column.hh"
  13 #include "pointer-group-interface.hh"
  14 #include "axis-group-interface.hh"
  15 #include "spanner.hh"
  16 #include "warn.hh"
  17
  18 MAKE_SCHEME_CALLBACK (Hara_kiri_group_spanner, y_extent, 1);
  19 SCM
  20 Hara_kiri_group_spanner::y_extent (SCM smob)
  21 {
  22   Grob *me = unsmob_grob (smob);
  23   consider_suicide (me);
  24   return Axis_group_interface::generic_group_extent (me, Y_AXIS);
  25 }
  26
  27 MAKE_SCHEME_CALLBACK (Hara_kiri_group_spanner, calc_skylines, 1);
  28 SCM
  29 Hara_kiri_group_spanner::calc_skylines (SCM smob)
  30 {
  31   Grob *me = unsmob_grob (smob);
  32   consider_suicide (me);
  33   return Axis_group_interface::calc_skylines (smob);
  34 }
  35
  36 MAKE_SCHEME_CALLBACK (Hara_kiri_group_spanner, pure_height, 3);
  37 SCM
  38 Hara_kiri_group_spanner::pure_height (SCM smob, SCM start_scm, SCM end_scm)
  39 {
  40   Grob *me = unsmob_grob (smob);
  41   int start = robust_scm2int (start_scm, 0);
  42   int end = robust_scm2int (end_scm, INT_MAX);
  43
  44   if (request_suicide (me, start, end))
  45     return ly_interval2scm (Interval ());
  46   return Axis_group_interface::pure_group_height (me, start, end);
  47 }
  48
  49 /* there is probably a way that doesn't involve re-implementing a binary
  50    search (I would love some proper closures right now) */
  51 bool find_in_range (SCM vector, int low, int hi, int min, int max)
  52 {
  53   if (low >= hi)
  54     return false;
  55
  56   int mid = low + (hi - low) / 2;
  57   int val = scm_to_int (scm_c_vector_ref (vector, mid));
  58   if (val >= min && val <= max)
  59     return true;
  60   else if (val < min)
  61     return find_in_range (vector, mid+1, hi, min, max);
  62   return find_in_range (vector, low, mid, min, max);
  63 }
  64
  65 bool
  66 Hara_kiri_group_spanner::request_suicide (Grob *me, int start, int end)
  67 {
  68   if (!to_boolean (me->get_property ("remove-empty")))
  69     return false;
  70
  71   bool remove_first = to_boolean (me->get_property ("remove-first"));
  72   if (!remove_first && start <= 0)
  73     return false;
  74
  75   SCM important = me->get_property ("important-column-ranks");
  76   if (scm_is_vector (important))
  77     {
  78       int len = scm_c_vector_length (important);
  79       if (find_in_range (important, 0, len, start, end))
  80         return false;
  81     }
  82   else /* build the important-columns-cache */
  83     {
  84       extract_grob_set (me, "items-worth-living", worth);
  85       vector<int> ranks;
  86
  87       for (vsize i = 0; i < worth.size (); i++)
  88         {
  89           Interval_t<int> iv = worth[i]->spanned_rank_iv ();
  90           for (int j = iv[LEFT]; j <= iv[RIGHT]; j++)
  91             ranks.push_back (j);
  92         }
  93       vector_sort (ranks, less<int> ());
  94       uniq (ranks);
  95
  96       SCM scm_vec = scm_c_make_vector (ranks.size (), SCM_EOL);
  97       for (vsize i = 0; i < ranks.size (); i++)
  98         scm_vector_set_x (scm_vec, scm_from_int (i), scm_from_int (ranks[i]));
  99       me->set_property ("important-column-ranks", scm_vec);
 100
 101       return request_suicide (me, start, end);
 102     }
 103
 104   return true;
 105 }
 106
 107 void
 108 Hara_kiri_group_spanner::consider_suicide (Grob *me)
 109 {
 110   Spanner *sp = dynamic_cast<Spanner*> (me);
 111   int left = sp->get_bound (LEFT)->get_column ()->get_rank ();
 112   int right = sp->get_bound (RIGHT)->get_column ()->get_rank ();
 113   if (!request_suicide (me, left, right))
 114     return;
 115
 116   vector<Grob*> childs;
 117   Axis_group_interface::get_children (me, &childs);
 118   for (vsize i = 0; i < childs.size (); i++)
 119     childs[i]->suicide ();
 120
 121   /*
 122     very appropriate name here :-)
 123   */
 124   me->suicide ();
 125 }
 126
 127 /*
 128   We can't rely on offsets and dimensions of elements in a hara-kiri
 129   group. Use a callback to make sure that hara-kiri has been done
 130   before asking for offsets.  */
 131 MAKE_SCHEME_CALLBACK (Hara_kiri_group_spanner, force_hara_kiri_callback, 1);
 132 SCM
 133 Hara_kiri_group_spanner::force_hara_kiri_callback (SCM smob)
 134 {
 135   Grob *me = unsmob_grob (smob);
 136   consider_suicide (me);
 137   return scm_from_double (0.0);
 138 }
 139
 140 MAKE_SCHEME_CALLBACK (Hara_kiri_group_spanner, force_hara_kiri_in_y_parent_callback, 1);
 141 SCM
 142 Hara_kiri_group_spanner::force_hara_kiri_in_y_parent_callback (SCM smob)
 143 {
 144   Grob *daughter = unsmob_grob (smob);
 145   force_hara_kiri_callback (daughter->get_parent (Y_AXIS)->self_scm ());
 146   return scm_from_double (0.0);
 147 }
 148
 149 void
 150 Hara_kiri_group_spanner::add_interesting_item (Grob *me, Grob *n)
 151 {
 152   Pointer_group_interface::add_unordered_grob (me, ly_symbol2scm ("items-worth-living"), n);
 153 }
 154
 155 ADD_INTERFACE (Hara_kiri_group_spanner,
 156                "A group spanner that  keeps track of interesting items.  If it "
 157                "doesn't contain any after linebreaking, then it "
 158                "will remove itself and all its children.",
 159
 160
 161                /* properties */
 162                "items-worth-living "
 163                "important-column-ranks "
 164                "remove-empty "
 165                "remove-first "
 166                );
 167
 168