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