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