lily/hairpin.cc

   1 /*
   2   hairpin.cc -- implement Hairpin
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 1997--2009 Han-Wen Nienhuys <hanwen@xs4all.nl>
   7 */
   8
   9 #include "hairpin.hh"
  10
  11 #include "dimensions.hh"
  12 #include "international.hh"
  13 #include "line-interface.hh"
  14 #include "output-def.hh"
  15 #include "paper-column.hh"
  16 #include "pointer-group-interface.hh"
  17 #include "spanner.hh"
  18 #include "staff-symbol-referencer.hh"
  19 #include "text-interface.hh"
  20 #include "note-column.hh"
  21 #include "warn.hh"
  22
  23 MAKE_SCHEME_CALLBACK (Hairpin, height, 1);
  24 SCM
  25 Hairpin::height (SCM smob)
  26 {
  27   return Grob::stencil_height (smob);
  28 }
  29
  30 MAKE_SCHEME_CALLBACK (Hairpin, pure_height, 3);
  31 SCM
  32 Hairpin::pure_height (SCM smob, SCM, SCM)
  33 {
  34   Grob *me = unsmob_grob (smob);
  35   Real height = robust_scm2double (me->get_property ("height"), 0.0)
  36     * Staff_symbol_referencer::staff_space (me);
  37
  38   Real thickness = robust_scm2double (me->get_property ("thickness"), 1)
  39     * Staff_symbol_referencer::line_thickness (me);
  40
  41   height += thickness / 2;
  42   return ly_interval2scm (Interval (-height, height));
  43 }
  44
  45 MAKE_SCHEME_CALLBACK (Hairpin, print, 1);
  46 SCM
  47 Hairpin::print (SCM smob)
  48 {
  49   Spanner *me = unsmob_spanner (smob);
  50
  51   SCM s = me->get_property ("grow-direction");
  52   if (!is_direction (s))
  53     {
  54       me->suicide ();
  55       return SCM_EOL;
  56     }
  57
  58   Direction grow_dir = to_dir (s);
  59   Real padding = robust_scm2double (me->get_property ("bound-padding"), 0.5);
  60
  61   Drul_array<bool> broken;
  62   Drul_array<Item *> bounds;
  63   Direction d = LEFT;
  64   do
  65     {
  66       bounds[d] = me->get_bound (d);
  67       broken[d] = bounds[d]->break_status_dir () != CENTER;
  68     }
  69   while (flip (&d) != LEFT);
  70
  71   broken[RIGHT] = broken[RIGHT] && me->broken_neighbor (RIGHT);
  72   broken[RIGHT] = broken[RIGHT] && me->broken_neighbor (RIGHT)->is_live ();
  73
  74   if (broken[RIGHT])
  75     {
  76       Spanner *next = me->broken_neighbor (RIGHT);
  77       Stencil *s = next->get_stencil ();
  78       if (!s || s->is_empty ())
  79         broken[RIGHT] = false;
  80     }
  81
  82   Grob *common = bounds[LEFT]->common_refpoint (bounds[RIGHT], X_AXIS);
  83   Drul_array<Real> x_points;
  84
  85   /*
  86     Use the height and thickness of the hairpin when making a circled tip
  87   */
  88   bool circled_tip = ly_scm2bool (me->get_property ("circled-tip"));
  89   Real height = robust_scm2double (me->get_property ("height"), 0.2) *
  90                 Staff_symbol_referencer::staff_space (me);
  91   /*
  92     FIXME: 0.525 is still just a guess...
  93   */
  94   Real rad = height * 0.525;
  95   Real thick = 1.0;
  96   if (circled_tip)
  97     thick = robust_scm2double (me->get_property ("thickness"), 1.0)
  98             * Staff_symbol_referencer::line_thickness (me);
  99
 100   do
 101     {
 102       Item *b = bounds[d];
 103       x_points[d] = b->relative_coordinate (common, X_AXIS);
 104       if (broken [d])
 105         {
 106           if (d == LEFT)
 107             x_points[d] = b->extent (common, X_AXIS)[RIGHT];
 108         }
 109       else
 110         {
 111           if (Text_interface::has_interface (b))
 112             {
 113               Interval e = b->extent (common, X_AXIS);
 114               if (!e.is_empty ())
 115                 x_points[d] = e[-d] - d * padding;
 116             }
 117           else
 118             {
 119               bool neighbor_found = false;
 120               extract_grob_set (me, "adjacent-hairpins", pins);
 121               for (vsize i = 0; i < pins.size (); i++)
 122                 {
 123                   /*
 124                     FIXME: this will fuck up in case of polyphonic
 125                     notes in other voices. Need to look at note-columns
 126                     in the current staff/voice.
 127                   */
 128
 129                   Spanner *pin = dynamic_cast<Spanner *> (pins[i]);
 130                   if (pin
 131                       && (pin->get_bound (LEFT)->get_column () == b->get_column ()
 132                           || pin->get_bound (RIGHT)->get_column () == b->get_column ()))
 133                     neighbor_found = true;
 134                 }
 135
 136               Interval e = robust_relative_extent (b, common, X_AXIS);
 137               if (neighbor_found)
 138                 {
 139                   /*
 140                     Handle back-to-back hairpins with a circle in the middle
 141                   */
 142                   if (circled_tip && (grow_dir != d))
 143                     x_points[d] = e.center () + d * (rad - thick / 2.0);
 144                   /*
 145                     If we're hung on a paper column, that means we're not
 146                     adjacent to a text-dynamic, and we may move closer. We
 147                     make the padding a little smaller, here.
 148                   */
 149                   else
 150                     x_points[d] = e.center () - d * padding / 3;
 151                 }
 152               else
 153                 {
 154                   if (Note_column::has_interface (b)
 155                       && Note_column::has_rests (b))
 156                     x_points[d] = e[-d];
 157                   else
 158                     x_points[d] = e[d];
 159
 160                   Item *bound = me->get_bound (d);
 161                   if (bound->is_non_musical (bound))
 162                     x_points[d] -=  d * padding;
 163                 }
 164             }
 165         }
 166     }
 167   while (flip (&d) != LEFT);
 168
 169   Real width = x_points[RIGHT] - x_points[LEFT];
 170   if (width < 0)
 171     {
 172       me->warning (_ ((grow_dir < 0) ? "decrescendo too small"
 173                       : "crescendo too small"));
 174       width = 0;
 175     }
 176
 177   bool continued = broken[Direction (-grow_dir)];
 178
 179   Real starth = 0;
 180   Real endh = 0;
 181   if (grow_dir < 0)
 182     {
 183       starth = height;
 184       endh = continued ? height / 2 : 0.0;
 185     }
 186   else
 187     {
 188       starth = continued ? height / 2 : 0.0;
 189       endh = height;
 190     }
 191
 192   /*
 193     should do relative to staff-symbol staff-space?
 194   */
 195   Stencil mol;
 196   Real x = 0.0;
 197
 198   /*
 199     Compensate for size of circle
 200   */
 201   Direction tip_dir = -grow_dir;
 202   if (circled_tip && !broken[tip_dir])
 203     {
 204       if (grow_dir > 0)
 205         x = rad * 2.0;
 206       else if (grow_dir < 0)
 207         width -= rad *2.0;
 208     }
 209   mol = Line_interface::line (me, Offset (x, starth), Offset (width, endh));
 210   mol.add_stencil (Line_interface::line (me,
 211                                          Offset (x, -starth),
 212                                          Offset (width, -endh)));
 213
 214   /*
 215     Support al/del niente notation by putting a circle at the
 216     tip of the (de)crescendo.
 217   */
 218   if (circled_tip)
 219     {
 220       Box extent (Interval (-rad, rad), Interval (-rad, rad));
 221
 222       /* Hmmm, perhaps we should have a Lookup::circle () method? */
 223       Stencil circle (extent,
 224                      scm_list_4 (ly_symbol2scm ("circle"),
 225                                  scm_from_double (rad),
 226                                  scm_from_double (thick),
 227                                  SCM_BOOL_F));
 228
 229       /*
 230         don't add another circle the hairpin is broken
 231       */
 232       if (!broken[tip_dir])
 233         mol.add_at_edge (X_AXIS, tip_dir, Stencil (circle), 0);
 234     }
 235
 236   mol.translate_axis (x_points[LEFT]
 237                       - bounds[LEFT]->relative_coordinate (common, X_AXIS),
 238                       X_AXIS);
 239   return mol.smobbed_copy ();
 240 }
 241
 242 ADD_INTERFACE (Hairpin,
 243                "A hairpin crescendo or decrescendo.",
 244
 245                /* properties */
 246                "adjacent-hairpins "
 247                "circled-tip "
 248                "bound-padding "
 249                "grow-direction "
 250                "height "
 251                );