lily/paper-column.cc

   1 /*
   2   paper-column.cc -- implement Paper_column
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 1997--2007 Han-Wen Nienhuys <hanwen@xs4all.nl>
   7 */
   8
   9 #include "paper-column.hh"
  10
  11 #include "moment.hh"
  12 #include "paper-score.hh"
  13 #include "warn.hh"
  14 #include "axis-group-interface.hh"
  15 #include "spaceable-grob.hh"
  16 #include "text-interface.hh"
  17 #include "lookup.hh"
  18 #include "font-interface.hh"
  19 #include "output-def.hh"
  20 #include "pointer-group-interface.hh"
  21 #include "grob-array.hh"
  22 #include "system.hh"
  23 #include "spring.hh"
  24 #include "lookup.hh"
  25 #include "separation-item.hh"
  26 #include "string-convert.hh"
  27
  28 Grob *
  29 Paper_column::clone () const
  30 {
  31   return new Paper_column (*this);
  32 }
  33
  34 void
  35 Paper_column::do_break_processing ()
  36 {
  37   Item::do_break_processing ();
  38 }
  39
  40 int
  41 Paper_column::get_rank (Grob const *me)
  42 {
  43   return dynamic_cast<Paper_column const *> (me)->rank_;
  44 }
  45
  46 System *
  47 Paper_column::get_system () const
  48 {
  49   return system_;
  50 }
  51
  52 void
  53 Paper_column::set_system (System *s)
  54 {
  55   system_ = s;
  56 }
  57
  58 Paper_column *
  59 Paper_column::get_column () const
  60 {
  61   return (Paper_column *) (this);
  62 }
  63
  64 Paper_column::Paper_column (SCM l)
  65   : Item (l)
  66 {
  67   system_ = 0;
  68   rank_ = -1;
  69 }
  70
  71 Paper_column::Paper_column (Paper_column const &src)
  72   : Item (src)
  73 {
  74   system_ = 0;
  75   rank_ = src.rank_;
  76 }
  77
  78 int
  79 Paper_column::compare (Grob * const &a,
  80                        Grob * const &b)
  81 {
  82   return sign (dynamic_cast<Paper_column*> (a)->rank_
  83                - dynamic_cast<Paper_column*> (b)->rank_);
  84 }
  85
  86 bool
  87 Paper_column::less_than (Grob *const &a,
  88                          Grob *const &b)
  89 {
  90   Paper_column *pa = dynamic_cast<Paper_column*> (a);
  91   Paper_column *pb = dynamic_cast<Paper_column*> (b);
  92
  93   return pa->rank_ < pb->rank_;
  94 }
  95
  96 Moment
  97 Paper_column::when_mom (Grob *me)
  98 {
  99   SCM m = me->get_property ("when");
 100   if (Moment *when = unsmob_moment (m))
 101     return *when;
 102   return Moment (0);
 103 }
 104
 105 bool
 106 Paper_column::is_musical (Grob *me)
 107 {
 108   SCM m = me->get_property ("shortest-starter-duration");
 109   Moment s (0);
 110   if (unsmob_moment (m))
 111     s = *unsmob_moment (m);
 112   return s != Moment (0);
 113 }
 114
 115 bool
 116 Paper_column::is_used (Grob *me)
 117 {
 118   extract_grob_set (me, "elements", elts);
 119   if (elts.size ())
 120     return true;
 121
 122   extract_grob_set (me, "bounded-by-me", bbm);
 123   if (bbm.size ())
 124     return true;
 125
 126   if (Paper_column::is_breakable (me))
 127     return true;
 128
 129   if (to_boolean (me->get_property ("used")))
 130     return true;
 131   return false;
 132 }
 133
 134 bool
 135 Paper_column::is_breakable (Grob *me)
 136 {
 137   return scm_is_symbol (me->get_property ("line-break-permission"));
 138 }
 139
 140 Real
 141 Paper_column::minimum_distance (Grob *left, Grob *right)
 142 {
 143   Drul_array<Grob*> cols (left, right);
 144   Drul_array<Skyline> skys = Drul_array<Skyline> (Skyline (RIGHT), Skyline (LEFT));
 145
 146   Direction d = LEFT;
 147   do
 148     {
 149       extract_grob_set (cols[d], "elements", elts);
 150
 151       for (vsize i = 0; i < elts.size (); i++)
 152         if (Separation_item::has_interface (elts[i]))
 153           {
 154             Skyline_pair *sp = Skyline_pair::unsmob (elts[i]->get_property ("horizontal-skylines"));
 155             if (sp)
 156               skys[d].merge ((*sp)[-d]);
 157           }
 158     }
 159   while (flip (&d) != LEFT);
 160
 161   return min (0.0, skys[LEFT].distance (skys[RIGHT]));
 162 }
 163
 164 /*
 165   Print a vertical line and  the rank number, to aid debugging.
 166 */
 167 MAKE_SCHEME_CALLBACK (Paper_column, print, 1);
 168 SCM
 169 Paper_column::print (SCM p)
 170 {
 171   Paper_column *me = dynamic_cast<Paper_column*> (unsmob_grob (p));
 172
 173   string r = to_string (Paper_column::get_rank (me));
 174
 175   Moment *mom = unsmob_moment (me->get_property ("when"));
 176   string when = mom ? mom->to_string () : "?/?";
 177
 178   Font_metric *musfont = Font_interface::get_default_font (me);
 179   SCM properties = Font_interface::text_font_alist_chain (me);
 180
 181   SCM scm_mol = Text_interface::interpret_markup (me->layout ()->self_scm (),
 182                                                   properties,
 183                                                   ly_string2scm (r));
 184   SCM when_mol = Text_interface::interpret_markup (me->layout ()->self_scm (),
 185                                                    properties,
 186                                                    ly_string2scm (when));
 187   Stencil t = *unsmob_stencil (scm_mol);
 188   t.add_at_edge (Y_AXIS, DOWN, *unsmob_stencil (when_mol), 0.1);
 189   t.align_to (X_AXIS, CENTER);
 190   t.align_to (Y_AXIS, DOWN);
 191
 192   Stencil l = Lookup::filled_box (Box (Interval (-0.01, 0.01),
 193                                        Interval (-2, -1)));
 194
 195   SCM small_letters = scm_cons (scm_acons (ly_symbol2scm ("font-size"),
 196                                            scm_from_int (-6), SCM_EOL),
 197                                 properties);
 198
 199   int j = 0;
 200   for (SCM s = me->get_object ("ideal-distances");
 201        scm_is_pair (s); s = scm_cdr (s))
 202     {
 203       Spring *sp = unsmob_spring (scm_car (s));
 204       if (!sp->other_->get_system ())
 205         continue;
 206
 207       j++;
 208       Real y = -j * 1 -3;
 209       vector<Offset> pts;
 210       pts.push_back (Offset (0, y));
 211
 212       Offset p2 (sp->distance (), y);
 213       pts.push_back (p2);
 214
 215       Stencil id_stencil = Lookup::points_to_line_stencil (0.1, pts);
 216       Stencil head (musfont->find_by_name ("arrowheads.open.01"));
 217
 218       SCM distance_stc = Text_interface::interpret_markup (me->layout ()->self_scm (),
 219                                                            small_letters,
 220                                                            ly_string2scm (String_convert::form_string ("%5.2lf", sp->distance ())));
 221
 222       id_stencil.add_stencil (unsmob_stencil (distance_stc)->translated (Offset (sp->distance ()/3, y+1)));
 223       id_stencil.add_stencil (head.translated (p2));
 224       id_stencil = id_stencil.in_color (0,0,1);
 225       l.add_stencil (id_stencil);
 226     }
 227
 228   for (SCM s = me->get_object ("minimum-distances");
 229        scm_is_pair (s); s = scm_cdr (s))
 230     {
 231       Real dist = scm_to_double (scm_cdar (s));
 232       Grob *other =  unsmob_grob (scm_caar (s));
 233       if (!other || other->get_system () != me->get_system ())
 234         continue;
 235
 236       j++;
 237
 238       Real y = -j * 1.0 -3.5;
 239       vector<Offset> pts;
 240       pts.push_back (Offset (0, y));
 241
 242       Offset p2 (dist, y);
 243       pts.push_back (p2);
 244
 245       Stencil id_stencil = Lookup::points_to_line_stencil (0.1, pts);
 246       Stencil head (musfont->find_by_name ("arrowheads.open.0M1"));
 247       head.translate_axis (y, Y_AXIS);
 248       id_stencil.add_stencil (head);
 249
 250       SCM distance_stc = Text_interface::interpret_markup (me->layout ()->self_scm (),
 251                                                            small_letters,
 252                                                            ly_string2scm (String_convert::form_string ("%5.2lf",
 253                                                                                                        dist)));
 254
 255       id_stencil.add_stencil (unsmob_stencil (distance_stc)->translated (Offset (dist/3, y-1)));
 256
 257
 258       id_stencil = id_stencil.in_color (1,0,0);
 259       l.add_stencil (id_stencil);
 260     }
 261   t.add_stencil (l);
 262   return t.smobbed_copy ();
 263 }
 264
 265 /*
 266   This is all too hairy. We use bounded-by-me to make sure that some
 267   columns are kept "alive". Unfortunately, when spanners are suicided,
 268   this falls apart again, because suicided spanners are still in
 269   bounded-by-me
 270
 271   THIS IS BROKEN KLUDGE. WE SHOULD INVENT SOMETHING BETTER.
 272 */
 273 MAKE_SCHEME_CALLBACK (Paper_column, before_line_breaking, 1);
 274 SCM
 275 Paper_column::before_line_breaking (SCM grob)
 276 {
 277   Grob *me = unsmob_grob (grob);
 278
 279   SCM bbm = me->get_object ("bounded-by-me");
 280   Grob_array *ga = unsmob_grob_array (bbm);
 281   if (!ga)
 282     return SCM_UNSPECIFIED;
 283
 284   vector<Grob*> &array (ga->array_reference ());
 285
 286   for (vsize i = array.size (); i--;)
 287     {
 288       Grob *g = array[i];
 289
 290       if (!g || !g->is_live ())
 291         /* UGH . potentially quadratic. */
 292         array.erase (array.begin () + i);
 293     }
 294
 295   return SCM_UNSPECIFIED;
 296 }
 297
 298
 299 ADD_INTERFACE (Paper_column,
 300                "@code{Paper_column} objects form the top-most X-parents for items."
 301                "  The are two types of columns: musical columns, where are attached to, and "
 302                "  non-musical columns, where bar-lines, clefs etc. are attached to. "
 303                "  The spacing engine determines the X-positions of these objects."
 304
 305                "\n\n"
 306                "They are\n"
 307                "  numbered, the first (leftmost) is column 0. Numbering happens before\n"
 308                "  line-breaking, and columns are not renumbered after line breaking.\n"
 309                "  Since many columns go unused, you should only use the rank field to\n"
 310                "  get ordering information.  Two adjacent columns may have\n"
 311                "  non-adjacent numbers.\n",
 312
 313
 314                /* properties */
 315                "between-cols "
 316                "bounded-by-me "
 317                "grace-spacing "
 318                "labels "
 319                "line-break-system-details "
 320                "line-break-penalty "
 321                "line-break-permission "
 322                "page-break-penalty "
 323                "page-break-permission "
 324                "page-turn-penalty "
 325                "page-turn-permission "
 326                "rhythmic-location "
 327                "shortest-playing-duration "
 328                "shortest-starter-duration "
 329                "spacing "
 330                "used "
 331                "when ");
 332