lily/new-fingering-engraver.cc

   1 /*
   2   fingering-engraver.cc -- implement New_fingering_engraver
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 1998--2005 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   7 */
   8
   9 #include "warn.hh"
  10 #include "engraver.hh"
  11 #include "side-position-interface.hh"
  12 #include "stem.hh"
  13 #include "rhythmic-head.hh"
  14 #include "self-alignment-interface.hh"
  15 #include "script-interface.hh"
  16 #include "stem.hh"
  17
  18 struct Finger_tuple
  19 {
  20   Grob *head_;
  21   Grob *script_;
  22   Music *note_event_;
  23   Music *finger_event_;
  24   bool follow_into_staff_;
  25   int position_;
  26
  27   Finger_tuple ()
  28   {
  29     position_ = 0;
  30     head_ = script_ = 0;
  31     note_event_ = finger_event_ = 0;
  32     follow_into_staff_ = false;
  33   }
  34   static int compare (Finger_tuple const &c1, Finger_tuple const &c2)
  35   {
  36     return c1.position_- c2.position_;
  37   }
  38 };
  39
  40 class New_fingering_engraver : public Engraver
  41 {
  42   Array<Finger_tuple> fingerings_;
  43   Array<Finger_tuple> articulations_;
  44   Link_array<Grob> heads_;
  45   Grob *stem_;
  46
  47 public:
  48   TRANSLATOR_DECLARATIONS (New_fingering_engraver);
  49 protected:
  50   virtual void stop_translation_timestep ();
  51   virtual void acknowledge_grob (Grob_info);
  52   void add_fingering (Grob *, Music *, Music *);
  53   void add_script (Grob *, Music *, Music *);
  54   void add_string (Grob *, Music *, Music *);
  55   void position_scripts ();
  56 };
  57
  58 void
  59 New_fingering_engraver::acknowledge_grob (Grob_info inf)
  60 {
  61   if (Rhythmic_head::has_interface (inf.grob_))
  62     {
  63       Music *note_ev = inf.music_cause ();
  64       if (!note_ev)
  65         return;
  66
  67       SCM arts = note_ev->get_property ("articulations");
  68
  69       for (SCM s = arts; scm_is_pair (s); s = scm_cdr (s))
  70         {
  71           Music *m = unsmob_music (scm_car (s));
  72
  73           if (!m)
  74             continue;
  75
  76           if (m->is_mus_type ("fingering-event"))
  77             {
  78               add_fingering (inf.grob_, m, note_ev);
  79             }
  80           else if (m->is_mus_type ("text-script-event"))
  81             {
  82               m->origin ()->warning ("Can not add text scripts to individual note heads");
  83             }
  84           else if (m->is_mus_type ("script-event"))
  85             {
  86               add_script (inf.grob_, m, note_ev);
  87             }
  88           else if (m->is_mus_type ("string-number-event"))
  89             {
  90               add_string (inf.grob_, m, note_ev);
  91             }
  92           else if (m->is_mus_type ("harmonic-event"))
  93             {
  94               inf.grob_->set_property ("style", ly_symbol2scm ("harmonic"));
  95               Grob *d = unsmob_grob (inf.grob_->get_property ("dot"));
  96               if (d)
  97                 d->suicide ();
  98             }
  99         }
 100
 101       heads_.push (inf.grob_);
 102     }
 103   else if (Stem::has_interface (inf.grob_))
 104     {
 105       stem_ = inf.grob_;
 106     }
 107 }
 108
 109 void
 110 New_fingering_engraver::add_script (Grob *head,
 111                                     Music *event,
 112                                     Music *note)
 113 {
 114   (void) note;
 115
 116   Finger_tuple ft;
 117
 118   Grob *g = make_item ("Script", event->self_scm ());
 119   make_script_from_event (g, &ft.follow_into_staff_, context (),
 120                           event->get_property ("articulation-type"), 0);
 121   if (g)
 122     {
 123       ft.script_ = g;
 124
 125       articulations_.push (ft);
 126
 127       ft.script_->set_parent (head, X_AXIS);
 128     }
 129 }
 130
 131 void
 132 New_fingering_engraver::add_fingering (Grob *head,
 133                                        Music *event,
 134                                        Music *hevent)
 135 {
 136   Finger_tuple ft;
 137
 138   ft.script_ = make_item ("Fingering", event->self_scm ());
 139
 140   Side_position_interface::add_support (ft.script_, head);
 141
 142   int d = scm_to_int (event->get_property ("digit"));
 143
 144   /*
 145     TODO:
 146
 147     Should add support for thumb.  It's a little involved, since
 148     the thumb lives in a different font. Maybe it should be moved?
 149
 150   */
 151   if (d > 5)
 152     {
 153       /*
 154         music for the softenon children?
 155       */
 156       event->origin ()->warning (_ ("music for the martians."));
 157     }
 158   SCM sstr = scm_number_to_string (scm_int2num (d), scm_int2num (10));
 159   ft.script_->set_property ("text", sstr);
 160
 161   ft.finger_event_ = event;
 162   ft.note_event_ = hevent;
 163   ft.head_ = head;
 164
 165   fingerings_.push (ft);
 166 }
 167
 168
 169 void
 170 New_fingering_engraver::add_string (Grob *head,
 171                                     Music *event,
 172                                     Music *hevent)
 173 {
 174   Finger_tuple ft;
 175
 176   ft.script_ = make_item ("StringNumber", event->self_scm ());
 177
 178   Side_position_interface::add_support (ft.script_, head);
 179
 180   int d = scm_to_int (event->get_property ("string-number"));
 181
 182   SCM sstr = scm_number_to_string (scm_int2num (d), scm_int2num (10));
 183   ft.script_->set_property ("text", sstr);
 184
 185   ft.finger_event_ = event;
 186   ft.note_event_ = hevent;
 187   ft.head_ = head;
 188
 189   fingerings_.push (ft);
 190 }
 191
 192 void
 193 New_fingering_engraver::position_scripts ()
 194 {
 195
 196   /*
 197     This is not extremely elegant, but we have to do a little
 198     formatting here, because the parent/child relations should be
 199     known before we move on to the next time step.
 200
 201     A more sophisticated approach would be to set both X and Y parents
 202     to the note head, and write a more flexible function for
 203     positioning the fingerings, setting both X and Y coordinates.
 204   */
 205   for (int i = 0; i < fingerings_.size (); i++)
 206     {
 207       fingerings_[i].position_ = scm_to_int (fingerings_[i].head_->get_property ("staff-position"));
 208     }
 209
 210   for (int i = fingerings_.size (); i--;)
 211     for (int j = heads_.size (); j--;)
 212       Side_position_interface::add_support (fingerings_[i].script_, heads_[j]);
 213
 214   Array<Finger_tuple> up, down, horiz;
 215   for (int i = fingerings_.size (); i--;)
 216     {
 217       SCM d = fingerings_[i].finger_event_->get_property ("direction");
 218       if (to_dir (d))
 219         {
 220           ((to_dir (d) == UP) ? up : down).push (fingerings_[i]);
 221           fingerings_.del (i);
 222         }
 223     }
 224
 225   fingerings_.sort (&Finger_tuple::compare);
 226   SCM orientations = get_property ("fingeringOrientations");
 227
 228   bool up_p = scm_c_memq (ly_symbol2scm ("up"), orientations) != SCM_BOOL_F;
 229   bool down_p = scm_c_memq (ly_symbol2scm ("down"), orientations) != SCM_BOOL_F;
 230   bool left_p = scm_c_memq (ly_symbol2scm ("left"), orientations) != SCM_BOOL_F;
 231   bool right_p = scm_c_memq (ly_symbol2scm ("right"), orientations) != SCM_BOOL_F;
 232   Direction hordir = (right_p) ? RIGHT : LEFT;
 233   if (left_p || right_p)
 234     {
 235       if (up_p && !up.size () && fingerings_.size ())
 236         up.push (fingerings_.pop ());
 237
 238       if (down_p && !down.size () && fingerings_.size ())
 239         {
 240           down.push (fingerings_[0]);
 241           fingerings_.del (0);
 242         }
 243
 244       horiz.concat (fingerings_);
 245     }
 246   else if (up_p && down_p)
 247     {
 248       int center = fingerings_.size () / 2;
 249       down.concat (fingerings_.slice (0, center));
 250       up.concat (fingerings_.slice (center, fingerings_.size ()));
 251     }
 252   else if (up_p)
 253     {
 254       up.concat (fingerings_);
 255       fingerings_.clear ();
 256     }
 257   else
 258     {
 259       if (!down_p)
 260         warning (_ ("Fingerings are also not down?! Putting them down anyway."));
 261       down.concat (fingerings_);
 262       fingerings_.clear ();
 263     }
 264
 265   for (int i = 0; i < horiz.size (); i++)
 266     {
 267       Finger_tuple ft = horiz[i];
 268       Grob *f = ft.script_;
 269       f->set_parent (ft.head_, X_AXIS);
 270       f->set_parent (ft.head_, Y_AXIS);
 271       f->add_offset_callback (Self_alignment_interface::centered_on_parent_proc, Y_AXIS);
 272       f->add_offset_callback (Self_alignment_interface::aligned_on_self_proc, Y_AXIS);
 273       f->add_offset_callback (Side_position_interface::aligned_side_proc, X_AXIS);
 274
 275       f->set_property ("direction", scm_int2num (hordir));
 276     }
 277
 278   int finger_prio = 200;
 279   for (int i = 0; i < up.size (); i++)
 280     {
 281       Finger_tuple ft = up[i];
 282       Grob *f = ft.script_;
 283       f->set_parent (ft.head_, X_AXIS);
 284       f->set_property ("script-priority",
 285                        scm_int2num (finger_prio + ft.position_));
 286       f->add_offset_callback (Side_position_interface::aligned_side_proc, Y_AXIS);
 287       f->add_offset_callback (Self_alignment_interface::centered_on_parent_proc, X_AXIS);
 288       f->add_offset_callback (Self_alignment_interface::aligned_on_self_proc, X_AXIS);
 289
 290       f->set_property ("direction", scm_int2num (UP));
 291     }
 292
 293   for (int i = 0; i < down.size (); i++)
 294     {
 295       Finger_tuple ft = down[i];
 296       Grob *f = ft.script_;
 297       f->set_parent (ft.head_, X_AXIS);
 298       f->set_property ("script-priority",
 299                        scm_int2num (finger_prio + down.size () - ft.position_));
 300
 301       f->add_offset_callback (Self_alignment_interface::centered_on_parent_proc, X_AXIS);
 302       f->add_offset_callback (Self_alignment_interface::aligned_on_self_proc, X_AXIS);
 303       f->add_offset_callback (Side_position_interface::aligned_side_proc, Y_AXIS);
 304       f->set_property ("direction", scm_int2num (DOWN));
 305     }
 306 }
 307
 308 void
 309 New_fingering_engraver::stop_translation_timestep ()
 310 {
 311   if (fingerings_.size ())
 312     {
 313       for (int i = 0; i < fingerings_.size (); i++)
 314         if (stem_ && to_boolean (fingerings_[i].script_->get_property ("add-stem-support")))
 315           Side_position_interface::add_support (fingerings_[i].script_, stem_);
 316       position_scripts ();
 317       fingerings_.clear ();
 318     }
 319
 320   for (int i = articulations_.size (); i--;)
 321     {
 322       Grob *script = articulations_[i].script_;
 323
 324       for (int j = heads_.size (); j--;)
 325         Side_position_interface::add_support (script, heads_[j]);
 326
 327       if (stem_ && to_dir (script->get_property ("side-relative-direction")))
 328         script->set_property ("direction-source", stem_->self_scm ());
 329
 330       if (stem_ && to_boolean (script->get_property ("add-stem-support")))
 331         Side_position_interface::add_support (script, stem_);
 332
 333       if (articulations_[i].follow_into_staff_)
 334         {
 335           script->add_offset_callback (Side_position_interface::quantised_position_proc, Y_AXIS);
 336           script->set_property ("staff-padding", SCM_EOL);
 337         }
 338     }
 339
 340   stem_ = 0;
 341   heads_.clear ();
 342   articulations_.clear ();
 343 }
 344
 345 New_fingering_engraver::New_fingering_engraver ()
 346 {
 347   stem_ = 0;
 348 }
 349
 350 ADD_TRANSLATOR (New_fingering_engraver,
 351                 /* descr */ "Create fingering-scripts for notes in a new chord.  "
 352                 "This engraver is ill-named, since it "
 353                 "also takes care of articulations and harmonic note heads",
 354                 /* creats*/ "Fingering",
 355                 /* accepts */ "",
 356                 /* acks  */ "rhythmic-head-interface stem-interface",
 357                 /* reads */ "fingeringOrientations",
 358                 /* write */ "");