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