lily/piano-pedal-engraver.cc

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