lily/piano-pedal-engraver.cc

   1 /*
   2   piano-pedal-engraver.cc -- implement Piano_pedal_engraver
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c) 2000--2007 Jan Nieuwenhuizen <janneke@gnu.org>,
   7                  Erik Sandberg <mandolaerik@gmail.com>
   8
   9   Chris Jackson <chris@fluffhouse.org.uk> - extended to support
  10   bracketed pedals.
  11 */
  12
  13 #include "engraver.hh"
  14
  15 #include "axis-group-interface.hh"
  16 #include "context.hh"
  17 #include "directional-element-interface.hh"
  18 #include "international.hh"
  19 #include "lily-guile.hh"
  20 #include "note-column.hh"
  21 #include "side-position-interface.hh"
  22 #include "staff-symbol-referencer.hh"
  23 #include "stream-event.hh"
  24 #include "string-convert.hh"
  25 #include "warn.hh"
  26 #include "spanner.hh"
  27 #include "item.hh"
  28
  29 #include "translator.icc"
  30
  31
  32 /*
  33   TODO:
  34
  35   * Junk hardcoded sustain/sostenuto/una_corda distinction;
  36     Softcode using (list (sustain-event SustainPedal PianoPedalBracket) ... )
  37
  38   * Try to use same engraver for dynamics.
  39
  40 */
  41
  42 /* Ugh: This declaration is duplicated in piano-pedal-performer */
  43 typedef enum Pedal_type {
  44   SOSTENUTO,
  45   SUSTAIN,
  46   UNA_CORDA,
  47   NUM_PEDAL_TYPES
  48 };
  49
  50 /*
  51   Static precalculated data (symbols and strings) for the different
  52   pedal types
  53 */
  54 struct Pedal_type_info
  55 {
  56   string base_name_;
  57   SCM event_class_sym_;
  58   SCM style_sym_;
  59   SCM strings_sym_;
  60
  61   const char *pedal_c_str_;
  62
  63   Pedal_type_info ()
  64   {
  65     event_class_sym_ = SCM_EOL;
  66     style_sym_ = SCM_EOL;
  67     strings_sym_ = SCM_EOL;
  68     pedal_c_str_ = 0;
  69   }
  70   void protect ()
  71   {
  72     scm_gc_protect_object (event_class_sym_);
  73     scm_gc_protect_object (style_sym_);
  74     scm_gc_protect_object (strings_sym_);
  75   }
  76 };
  77
  78 struct Pedal_info
  79 {
  80   const Pedal_type_info *type_;
  81
  82   /*
  83     Event for currently running pedal.
  84   */
  85   Stream_event *current_bracket_ev_;
  86
  87   /*
  88     Event for currently starting pedal, (necessary?
  89
  90     distinct from current_bracket_ev_, since current_bracket_ev_ only
  91     necessary for brackets, not for text style.
  92   */
  93   Stream_event *start_ev_;
  94
  95   /*
  96     Events that were found in this timestep.
  97   */
  98   Drul_array<Stream_event *> event_drul_;
  99   Item *item_;
 100   Spanner *bracket_; // A single portion of a pedal bracket
 101   Spanner *finished_bracket_;
 102 };
 103
 104 static Pedal_type_info pedal_types_[NUM_PEDAL_TYPES];
 105
 106 class Piano_pedal_engraver : public Engraver
 107 {
 108 public:
 109   TRANSLATOR_DECLARATIONS (Piano_pedal_engraver);
 110
 111 protected:
 112   virtual void initialize ();
 113   virtual void finalize ();
 114   DECLARE_TRANSLATOR_LISTENER (sustain);
 115   DECLARE_TRANSLATOR_LISTENER (una_corda);
 116   DECLARE_TRANSLATOR_LISTENER (sostenuto);
 117   DECLARE_ACKNOWLEDGER (note_column);
 118   void stop_translation_timestep ();
 119   void process_music ();
 120
 121 private:
 122   Pedal_info info_list_[NUM_PEDAL_TYPES + 1];
 123
 124   void create_text_grobs (Pedal_info *p, bool);
 125   void create_bracket_grobs (Pedal_info *p, bool);
 126   void typeset_all (Pedal_info *p);
 127 };
 128
 129
 130 static void
 131 init_pedal_types ()
 132 {
 133   const char *names [NUM_PEDAL_TYPES];
 134   names[SOSTENUTO] = "Sostenuto";
 135   names[SUSTAIN] = "Sustain";
 136   names[UNA_CORDA] = "UnaCorda";
 137
 138   for (int i = 0; i < NUM_PEDAL_TYPES; i++)
 139     {
 140       const char *name = names[i];
 141       /* FooBar */
 142       string base_name = name;
 143       /* foo-bar */
 144       string base_ident = "";
 145       int prev_pos=0;
 146       int cur_pos;
 147       for (cur_pos = 1; name[cur_pos]; cur_pos++)
 148         if (isupper (name[cur_pos]))
 149           {
 150             base_ident = base_ident + String_convert::to_lower (string (name, prev_pos, cur_pos - prev_pos)) + "-";
 151             prev_pos = cur_pos;
 152           }
 153       base_ident += String_convert::to_lower (string (name, prev_pos, cur_pos - prev_pos));
 154
 155       /*
 156         be careful, as we don't want to loose references to the _sym_ members.
 157        */
 158       Pedal_type_info info;
 159       info.event_class_sym_ = scm_str2symbol ((base_ident + "-event").c_str ());
 160       info.style_sym_ = scm_str2symbol (("pedal" + base_name + "Style").c_str ());
 161       info.strings_sym_ = scm_str2symbol (("pedal" + base_name + "Strings").c_str ());
 162
 163       info.base_name_ = name;
 164       info.pedal_c_str_ = strdup ((base_name + "Pedal").c_str ());
 165
 166       info.protect ();
 167
 168       pedal_types_[i] = info;
 169     }
 170 }
 171
 172 ADD_SCM_INIT_FUNC (Piano_pedal_engraver_init_pedal_types_, init_pedal_types);
 173
 174 Piano_pedal_engraver::Piano_pedal_engraver ()
 175 {
 176 }
 177
 178 void
 179 Piano_pedal_engraver::initialize ()
 180 {
 181   for (int i = 0; i < NUM_PEDAL_TYPES; i++)
 182     {
 183       Pedal_type_info *s = &pedal_types_[i];
 184       Pedal_info *info = &info_list_[i];
 185
 186       info->type_ = s;
 187       info->item_ = 0;
 188       info->bracket_ = 0;
 189       info->finished_bracket_ = 0;
 190       info->current_bracket_ev_ = 0;
 191       info->event_drul_[START] = 0;
 192       info->event_drul_[STOP] = 0;
 193       info->start_ev_ = 0;
 194     }
 195   info_list_[NUM_PEDAL_TYPES].type_ = 0;
 196 }
 197
 198
 199 /*
 200   Urg: Code dup
 201   I'm a script
 202 */
 203 void
 204 Piano_pedal_engraver::acknowledge_note_column (Grob_info info)
 205 {
 206   for (Pedal_info *p = info_list_; p->type_; p++)
 207     {
 208       if (p->bracket_)
 209         add_bound_item (p->bracket_, info.grob ());
 210       if (p->finished_bracket_)
 211         add_bound_item (p->finished_bracket_, info.grob ());
 212     }
 213 }
 214
 215 IMPLEMENT_TRANSLATOR_LISTENER (Piano_pedal_engraver, sostenuto);
 216 void
 217 Piano_pedal_engraver::listen_sostenuto (Stream_event *ev)
 218 {
 219   Direction d = to_dir (ev->get_property ("span-direction"));
 220   ASSIGN_EVENT_ONCE (info_list_[SOSTENUTO].event_drul_[d], ev);
 221 }
 222
 223 IMPLEMENT_TRANSLATOR_LISTENER (Piano_pedal_engraver, sustain);
 224 void
 225 Piano_pedal_engraver::listen_sustain (Stream_event *ev)
 226 {
 227   Direction d = to_dir (ev->get_property ("span-direction"));
 228   ASSIGN_EVENT_ONCE (info_list_[SUSTAIN].event_drul_[d], ev);
 229 }
 230
 231 IMPLEMENT_TRANSLATOR_LISTENER (Piano_pedal_engraver, una_corda);
 232 void
 233 Piano_pedal_engraver::listen_una_corda (Stream_event *ev)
 234 {
 235   Direction d = to_dir (ev->get_property ("span-direction"));
 236   ASSIGN_EVENT_ONCE (info_list_[UNA_CORDA].event_drul_[d], ev);
 237 }
 238
 239 void
 240 Piano_pedal_engraver::process_music ()
 241 {
 242   for (Pedal_info *p = info_list_; p->type_; p++)
 243     {
 244       if (p->event_drul_[STOP] || p->event_drul_[START])
 245         {
 246           /* Choose the appropriate grobs to add to the line spanner
 247              These can be text items or text-spanners
 248           */
 249
 250           /*
 251             ugh, code dup, should read grob to create from other
 252             property.
 253
 254             bracket: |_________/\____|
 255             text:    Ped.     *Ped.  *
 256             mixed:   Ped. _____/\____|
 257           */
 258
 259           SCM style = internal_get_property (p->type_->style_sym_);
 260
 261           bool mixed = style == ly_symbol2scm ("mixed");
 262           bool bracket = (mixed
 263                           || style == ly_symbol2scm ("bracket"));
 264           bool text = (style == ly_symbol2scm ("text")
 265                        || mixed);
 266
 267           if (text && !p->item_)
 268             create_text_grobs (p, mixed);
 269           if (bracket)
 270             create_bracket_grobs (p, mixed);
 271         }
 272     }
 273 }
 274
 275 void
 276 Piano_pedal_engraver::create_text_grobs (Pedal_info *p, bool mixed)
 277 {
 278   SCM s = SCM_EOL;
 279   SCM strings = internal_get_property (p->type_->strings_sym_);
 280
 281   if (scm_ilength (strings) < 3)
 282     {
 283       Stream_event *m = p->event_drul_[START];
 284       if (!m) m = p->event_drul_ [STOP];
 285
 286       string msg = _f ("expect 3 strings for piano pedals, found: %ld",
 287                        scm_ilength (strings));
 288       if (m)
 289         m->origin ()->warning (msg);
 290       else
 291         warning (msg);
 292
 293       return;
 294     }
 295
 296   if (p->event_drul_[STOP] && p->event_drul_[START])
 297     {
 298       if (!mixed)
 299         {
 300           if (!p->start_ev_)
 301             p->event_drul_[STOP]->origin ()->warning (_f ("cannot find start of piano pedal: `%s'", p->type_->base_name_.c_str ()));
 302           else
 303             s = scm_cadr (strings);
 304           p->start_ev_ = p->event_drul_[START];
 305         }
 306     }
 307   else if (p->event_drul_[STOP])
 308     {
 309       if (!mixed)
 310         {
 311           if (!p->start_ev_)
 312             p->event_drul_[STOP]->origin ()->warning (_f ("cannot find start of piano pedal: `%s'", p->type_->base_name_.c_str ()));
 313           else
 314             s = scm_caddr (strings);
 315           p->start_ev_ = 0;
 316         }
 317     }
 318   else if (p->event_drul_[START])
 319     {
 320       p->start_ev_ = p->event_drul_[START];
 321       s = scm_car (strings);
 322       }
 323
 324   if (scm_is_string (s))
 325     {
 326       const char *propname = p->type_->pedal_c_str_;
 327
 328       p->item_ = make_item (propname, (p->event_drul_[START]
 329                                        ? p->event_drul_[START]
 330                                        : p->event_drul_[STOP])->self_scm ());
 331
 332       p->item_->set_property ("text", s);
 333     }
 334
 335   if (!mixed)
 336     {
 337       p->event_drul_[START] = 0;
 338       p->event_drul_[STOP] = 0;
 339     }
 340 }
 341
 342 void
 343 Piano_pedal_engraver::create_bracket_grobs (Pedal_info *p, bool mixed)
 344 {
 345   if (!p->bracket_ && p->event_drul_[STOP])
 346     {
 347       string msg = _f ("cannot find start of piano pedal bracket: `%s'", p->type_->base_name_.c_str ());
 348       p->event_drul_[STOP]->origin ()->warning (msg);
 349       p->event_drul_[STOP] = 0;
 350     }
 351
 352   if (p->event_drul_[STOP])
 353     {
 354       assert (!p->finished_bracket_);
 355
 356       Grob *cmc = unsmob_grob (get_property ("currentMusicalColumn"));
 357
 358       if (!p->bracket_->get_bound (RIGHT))
 359         p->bracket_->set_bound (RIGHT, cmc);
 360
 361       /*
 362         Set properties so that the stencil-creating function will
 363         know whether the right edge should be flared ___/
 364       */
 365
 366       if (!p->event_drul_[START])
 367         {
 368           SCM flare = p->bracket_->get_property ("bracket-flare");
 369           if (scm_is_pair (flare))
 370             p->bracket_->set_property ("bracket-flare", scm_cons (scm_car (flare),
 371                                                                   scm_from_double (0)));
 372         }
 373
 374       p->finished_bracket_ = p->bracket_;
 375       p->bracket_ = 0;
 376
 377       announce_end_grob (p->finished_bracket_, p->event_drul_[STOP]->self_scm ());
 378
 379       p->current_bracket_ev_ = 0;
 380     }
 381
 382   if (p->event_drul_[START])
 383     {
 384       p->start_ev_ = p->event_drul_[START];
 385       p->current_bracket_ev_ = p->event_drul_[START];
 386
 387       p->bracket_ = make_spanner ("PianoPedalBracket", p->event_drul_[START]->self_scm ());
 388
 389       /*
 390         Set properties so that the stencil-creating function will
 391         know whether the left edge should be flared \___
 392       */
 393
 394       if (!p->finished_bracket_)
 395         {
 396           SCM flare = p->bracket_->get_property ("bracket-flare");
 397           p->bracket_->set_property ("bracket-flare", scm_cons (scm_from_double (0), scm_cdr (flare)));
 398         }
 399
 400       /* Set this property for 'mixed style' pedals,    Ped._______/\ ,
 401          so the stencil function will shorten the ____ line by the length of the Ped. text.
 402       */
 403
 404       if (mixed)
 405         {
 406           /*
 407             Mixed style: Store a pointer to the preceding text for use in
 408             calculating the length of the line
 409
 410
 411             TODO:
 412
 413             WTF is pedal-text not the bound of the object? --hwn
 414           */
 415           if (p->item_)
 416             p->bracket_->set_object ("pedal-text", p->item_->self_scm ());
 417         }
 418     }
 419
 420   p->event_drul_[START] = 0;
 421   p->event_drul_[STOP] = 0;
 422 }
 423
 424 void
 425 Piano_pedal_engraver::finalize ()
 426 {
 427   for (Pedal_info *p = info_list_; p->type_; p++)
 428     {
 429       if (p->bracket_
 430           && !p->bracket_->is_live ())
 431         p->bracket_ = 0;
 432
 433       if (p->bracket_)
 434         {
 435           SCM cc = get_property ("currentCommandColumn");
 436           Item *c = unsmob_item (cc);
 437           p->bracket_->set_bound (RIGHT, c);
 438
 439           p->finished_bracket_ = p->bracket_;
 440           p->bracket_ = 0;
 441           typeset_all (p);
 442         }
 443
 444     }
 445 }
 446
 447 void
 448 Piano_pedal_engraver::stop_translation_timestep ()
 449 {
 450   for (Pedal_info *p = info_list_; p->type_; p++)
 451     {
 452
 453       typeset_all (p);
 454       if (p->bracket_ && !p->bracket_->get_bound (LEFT))
 455         {
 456           Grob *cmc = unsmob_grob (get_property ("currentMusicalColumn"));
 457
 458           if (!p->bracket_->get_bound (LEFT))
 459             p->bracket_->set_bound (LEFT, cmc);
 460         }
 461     }
 462
 463   for (Pedal_info *p = info_list_; p->type_; p++)
 464     {
 465       p->event_drul_[STOP] = 0;
 466       p->event_drul_[START] = 0;
 467     }
 468 }
 469
 470 void
 471 Piano_pedal_engraver::typeset_all (Pedal_info *p)
 472 {
 473   /*
 474     Handle suicide.
 475   */
 476   if (p->finished_bracket_
 477       && !p->finished_bracket_->is_live ())
 478     p->finished_bracket_ = 0;
 479
 480   if (p->item_)
 481     p->item_ = 0;
 482
 483   if (p->finished_bracket_)
 484     {
 485       Grob *r = p->finished_bracket_->get_bound (RIGHT);
 486       if (!r)
 487         p->finished_bracket_->set_bound (RIGHT, unsmob_grob (get_property ("currentMusicalColumn")));
 488
 489       p->finished_bracket_ = 0;
 490     }
 491 }
 492
 493 ADD_ACKNOWLEDGER (Piano_pedal_engraver, note_column);
 494
 495 ADD_TRANSLATOR (Piano_pedal_engraver,
 496
 497                 /* doc */
 498                 "Engrave piano pedal symbols and brackets.",
 499
 500                 /* create */
 501                 "PianoPedalBracket "
 502                 "SostenutoPedal "
 503                 "SustainPedal "
 504                 "UnaCordaPedal ",
 505
 506                 /* read */
 507                 "currentCommandColumn "
 508                 "pedalSostenutoStrings "
 509                 "pedalSostenutoStyle "
 510                 "pedalSustainStrings "
 511                 "pedalSustainStyle "
 512                 "pedalUnaCordaStrings "
 513                 "pedalUnaCordaStyle",
 514
 515                 /* write */ "");