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--2005 Jan Nieuwenhuizen <janneke@gnu.org>
   7
   8   Chris Jackson <chris@fluffhouse.org.uk> - extended to support
   9   bracketed pedals.
  10 */
  11
  12 #include "engraver.hh"
  13 #include "lily-guile.hh"
  14 #include "side-position-interface.hh"
  15 #include "staff-symbol-referencer.hh"
  16 #include "axis-group-interface.hh"
  17 #include "context.hh"
  18 #include "directional-element-interface.hh"
  19 #include "note-column.hh"
  20 #include "warn.hh"
  21
  22 /*
  23   Urgh. This engraver is too complex. rewrite. --hwn
  24 */
  25
  26 struct Pedal_info
  27 {
  28   char const *name_;
  29
  30   /*
  31     Event for currently running pedal.
  32   */
  33   Music *current_bracket_ev_;
  34
  35   /*
  36     Event for currently starting pedal, (necessary?
  37
  38     distinct from current_bracket_ev_, since current_bracket_ev_ only
  39     necessary for brackets, not for text style.
  40   */
  41   Music *start_ev_;
  42
  43   /*
  44     Events that were found in this timestep.
  45   */
  46   Drul_array<Music *> event_drul_;
  47   Item *item_;
  48   Spanner *bracket_; // A single portion of a pedal bracket
  49   Spanner *finished_bracket_;
  50
  51   /*
  52     This grob contains all the pedals of the same type on the same staff
  53   */
  54   Spanner *line_spanner_;
  55   Spanner *finished_line_spanner_;
  56 };
  57
  58 class Piano_pedal_engraver : public Engraver
  59 {
  60 public:
  61   TRANSLATOR_DECLARATIONS (Piano_pedal_engraver);
  62   ~Piano_pedal_engraver ();
  63 protected:
  64   virtual void initialize ();
  65   virtual void finalize ();
  66   virtual bool try_music (Music *);
  67   void stop_translation_timestep ();
  68   DECLARE_ACKNOWLEDGER (note_column);
  69   void process_music ();
  70
  71 private:
  72
  73   Pedal_info *info_list_;
  74
  75   /*
  76     Record a stack of the current pedal spanners, so if more than one pedal
  77     occurs simultaneously then extra space can be added between them.
  78   */
  79
  80   Link_array<Spanner> previous_;
  81   void del_linespanner (Spanner *);
  82
  83   void create_text_grobs (Pedal_info *p, bool);
  84   void create_bracket_grobs (Pedal_info *p, bool);
  85   void typeset_all (Pedal_info *p);
  86 };
  87
  88 Piano_pedal_engraver::Piano_pedal_engraver ()
  89 {
  90   info_list_ = 0;
  91 }
  92
  93 void
  94 Piano_pedal_engraver::initialize ()
  95 {
  96   char *names [] = { "Sostenuto", "Sustain", "UnaCorda", 0 };
  97
  98   info_list_ = new Pedal_info[sizeof (names) / sizeof (char const *)];
  99   Pedal_info *p = info_list_;
 100
 101   char **np = names;
 102   do
 103     {
 104       p->name_ = *np;
 105       p->item_ = 0;
 106       p->bracket_ = 0;
 107       p->finished_bracket_ = 0;
 108       p->line_spanner_ = 0;
 109       p->finished_line_spanner_ = 0;
 110       p->current_bracket_ev_ = 0;
 111       p->event_drul_[START] = 0;
 112       p->event_drul_[STOP] = 0;
 113       p->start_ev_ = 0;
 114
 115       p++;
 116     }
 117   while (* (np++));
 118 }
 119
 120 Piano_pedal_engraver::~Piano_pedal_engraver ()
 121 {
 122   delete[] info_list_;
 123 }
 124
 125 /*
 126   Urg: Code dup
 127   I'm a script
 128 */
 129 void
 130 Piano_pedal_engraver::acknowledge_note_column (Grob_info info)
 131 {
 132   for (Pedal_info *p = info_list_; p && p->name_; p++)
 133     {
 134       if (p->line_spanner_)
 135         {
 136           Side_position_interface::add_support (p->line_spanner_, info.grob ());
 137           add_bound_item (p->line_spanner_, info.grob ());
 138         }
 139       if (p->bracket_)
 140         add_bound_item (p->bracket_, info.grob ());
 141       if (p->finished_bracket_)
 142         add_bound_item (p->finished_bracket_, info.grob ());
 143     }
 144 }
 145
 146 bool
 147 Piano_pedal_engraver::try_music (Music *m)
 148 {
 149   if (m->is_mus_type ("pedal-event"))
 150     {
 151       for (Pedal_info *p = info_list_; p->name_; p++)
 152         {
 153           String nm = p->name_ + String ("Event");
 154           if (ly_is_equal (m->get_property ("name"),
 155                            scm_str2symbol (nm.to_str0 ())))
 156             {
 157               Direction d = to_dir (m->get_property ("span-direction"));
 158               p->event_drul_[d] = m;
 159               return true;
 160             }
 161         }
 162     }
 163   return false;
 164 }
 165
 166 void
 167 Piano_pedal_engraver::process_music ()
 168 {
 169   for (Pedal_info *p = info_list_; p && p->name_; p++)
 170     {
 171       if (p->event_drul_[STOP] || p->event_drul_[START])
 172         {
 173           if (!p->line_spanner_)
 174             {
 175               String name = String (p->name_) + "PedalLineSpanner";
 176               Music *rq = (p->event_drul_[START] ? p->event_drul_[START] : p->event_drul_[STOP]);
 177               p->line_spanner_ = make_spanner (name.to_str0 (), rq->self_scm ());
 178             }
 179
 180           /* Choose the appropriate grobs to add to the line spanner
 181              These can be text items or text-spanners
 182           */
 183
 184           /*
 185             ugh, code dup, should read grob to create from other
 186             property.
 187
 188             bracket: |_________/\____|
 189             text:    Ped.     *Ped.  *
 190             mixed:   Ped. _____/\____|
 191           */
 192
 193           String prop = String ("pedal") + p->name_ + "Style";
 194           SCM style = get_property (prop.to_str0 ());
 195
 196           bool mixed = style == ly_symbol2scm ("mixed");
 197           bool bracket = (mixed
 198                           || style == ly_symbol2scm ("bracket"));
 199           bool text = (style == ly_symbol2scm ("text")
 200                        || mixed);
 201
 202           if (text && !p->item_)
 203             create_text_grobs (p, mixed);
 204           if (bracket)
 205             create_bracket_grobs (p, mixed);
 206         }
 207     }
 208 }
 209
 210 void
 211 Piano_pedal_engraver::create_text_grobs (Pedal_info *p, bool mixed)
 212 {
 213   SCM s = SCM_EOL;
 214   SCM strings = get_property (("pedal" + String (p->name_) + "Strings").to_str0 ());
 215
 216   if (scm_ilength (strings) < 3)
 217     {
 218       Music *m = p->event_drul_[START];
 219       if (!m) m = p->event_drul_ [STOP];
 220
 221       String msg = _f ("expect 3 strings for piano pedals, found: %d",
 222                        scm_ilength (strings));
 223       if (m)
 224         m->origin ()->warning (msg);
 225       else
 226         warning (msg);
 227
 228       return;
 229     }
 230
 231   if (p->event_drul_[STOP] && p->event_drul_[START])
 232     {
 233       if (!mixed)
 234         {
 235           if (!p->start_ev_)
 236             p->event_drul_[STOP]->origin ()->warning (_f ("can't find start of piano pedal: `%s'", p->name_));
 237           else
 238             s = scm_cadr (strings);
 239           p->start_ev_ = p->event_drul_[START];
 240         }
 241     }
 242   else if (p->event_drul_[STOP])
 243     {
 244       if (!mixed)
 245         {
 246           if (!p->start_ev_)
 247             p->event_drul_[STOP]->origin ()->warning (_f ("can't find start of piano pedal: `%s'", p->name_));
 248           else
 249             s = scm_caddr (strings);
 250           p->start_ev_ = 0;
 251         }
 252     }
 253   else if (p->event_drul_[START])
 254     {
 255       p->start_ev_ = p->event_drul_[START];
 256       s = scm_car (strings);
 257       if (!mixed)
 258         {
 259           /*
 260             Code dup?! see below.
 261           */
 262           if (previous_.size ())
 263             // add extra space below the previous already-occuring pedal
 264             Side_position_interface::add_support (p->line_spanner_,
 265                                                   previous_.top ());
 266           previous_.push (p->line_spanner_);
 267         }
 268     }
 269
 270   if (scm_is_string (s))
 271     {
 272       String propname = String (p->name_) + "Pedal";
 273
 274       p->item_ = make_item (propname.to_str0 (), (p->event_drul_[START]
 275                                                   ? p->event_drul_[START]
 276                                                   : p->event_drul_[STOP])->self_scm ());
 277
 278       p->item_->set_property ("text", s);
 279       Axis_group_interface::add_element (p->line_spanner_, p->item_);
 280     }
 281
 282   if (!mixed)
 283     {
 284       p->event_drul_[START] = 0;
 285       p->event_drul_[STOP] = 0;
 286     }
 287 }
 288
 289 void
 290 Piano_pedal_engraver::create_bracket_grobs (Pedal_info *p, bool mixed)
 291 {
 292   if (!p->bracket_ && p->event_drul_[STOP])
 293     {
 294       String msg = _f ("can't find start of piano pedal bracket: `%s'", p->name_);
 295       p->event_drul_[STOP]->origin ()->warning (msg);
 296       p->event_drul_[STOP] = 0;
 297     }
 298
 299   if (p->event_drul_[STOP])
 300     {
 301       assert (!p->finished_bracket_);
 302
 303       Grob *cmc = unsmob_grob (get_property ("currentMusicalColumn"));
 304
 305       if (!p->bracket_->get_bound (RIGHT))
 306         p->bracket_->set_bound (RIGHT, cmc);
 307
 308       /*
 309         Set properties so that the stencil-creating function will
 310         know whether the right edge should be flared ___/
 311       */
 312
 313       if (!p->event_drul_[START])
 314         {
 315           SCM flare = p->bracket_->get_property ("bracket-flare");
 316           p->bracket_->set_property ("bracket-flare", scm_cons (scm_car (flare),
 317                                                                 scm_from_double (0)));
 318         }
 319
 320       p->finished_bracket_ = p->bracket_;
 321       p->bracket_ = 0;
 322       p->current_bracket_ev_ = 0;
 323     }
 324
 325   if (p->event_drul_[START])
 326     {
 327       p->start_ev_ = p->event_drul_[START];
 328       p->current_bracket_ev_ = p->event_drul_[START];
 329
 330       p->bracket_ = make_spanner ("PianoPedalBracket", p->event_drul_[START]->self_scm ());
 331
 332       /*
 333         Set properties so that the stencil-creating function will
 334         know whether the left edge should be flared \___
 335       */
 336
 337       if (!p->finished_bracket_)
 338         {
 339           SCM flare = p->bracket_->get_property ("bracket-flare");
 340           p->bracket_->set_property ("bracket-flare", scm_cons (scm_from_double (0), scm_cdr (flare)));
 341         }
 342
 343       /* Set this property for 'mixed style' pedals,    Ped._______/\ ,
 344          so the stencil function will shorten the ____ line by the length of the Ped. text.
 345       */
 346
 347       if (mixed)
 348         {
 349           /*
 350             Mixed style: Store a pointer to the preceding text for use in
 351             calculating the length of the line
 352
 353
 354             TODO:
 355
 356             WTF is pedal-text not the bound of the object? --hwn
 357           */
 358           if (p->item_)
 359             p->bracket_->set_object ("pedal-text", p->item_->self_scm ());
 360         }
 361
 362       /*
 363         We do not use currentMusicalColumn for the left span-point.
 364         If the column as accidentals (eg on a different stave), the
 365         currentMusicalColumn is too wide, making the bracket too big.
 366
 367         TODO:
 368
 369         Hmm. What do we do when there are no notes when the spanner starts?
 370
 371         TODO:
 372
 373         what about the right span point?
 374
 375       */
 376       Axis_group_interface::add_element (p->line_spanner_, p->bracket_);
 377
 378       if (!p->event_drul_[STOP])
 379         {
 380
 381           /*
 382             code dup. --hwn.
 383
 384             // position new pedal spanner below the current one
 385             */
 386           if (previous_.size ())
 387             Side_position_interface::add_support (p->line_spanner_, previous_.top ());
 388
 389           previous_.push (p->line_spanner_);
 390         }
 391     }
 392
 393   p->event_drul_[START] = 0;
 394   p->event_drul_[STOP] = 0;
 395 }
 396
 397 void
 398 Piano_pedal_engraver::finalize ()
 399 {
 400   for (Pedal_info *p = info_list_; p && p->name_; p++)
 401     {
 402       /*
 403         suicide?
 404       */
 405       if (p->line_spanner_
 406           && !p->line_spanner_->is_live ())
 407         p->line_spanner_ = 0;
 408
 409       if (p->bracket_
 410           && !p->bracket_->is_live ())
 411         p->bracket_ = 0;
 412
 413       if (p->bracket_)
 414         {
 415           SCM cc = get_property ("currentCommandColumn");
 416           Item *c = unsmob_item (cc);
 417           if (p->line_spanner_)
 418             p->line_spanner_->set_bound (RIGHT, c);
 419           p->bracket_->set_bound (RIGHT, c);
 420
 421           p->finished_bracket_ = p->bracket_;
 422           p->bracket_ = 0;
 423           p->finished_line_spanner_ = p->line_spanner_;
 424           p->line_spanner_ = 0;
 425           typeset_all (p);
 426         }
 427
 428       if (p->line_spanner_)
 429         {
 430           p->finished_line_spanner_ = p->line_spanner_;
 431           typeset_all (p);
 432         }
 433     }
 434 }
 435
 436 void
 437 Piano_pedal_engraver::del_linespanner (Spanner *g)
 438 {
 439   int idx = previous_.find_index (g);
 440   if (idx >= 0)
 441     previous_.del (idx);
 442 }
 443
 444 void
 445 Piano_pedal_engraver::stop_translation_timestep ()
 446 {
 447   for (Pedal_info *p = info_list_; p && p->name_; p++)
 448     {
 449       if (!p->bracket_)
 450         {
 451           p->finished_line_spanner_ = p->line_spanner_;
 452           p->line_spanner_ = 0;
 453           del_linespanner (p->finished_line_spanner_);
 454         }
 455
 456       typeset_all (p);
 457     }
 458
 459   for (Pedal_info *p = info_list_; p->name_; p++)
 460     {
 461       p->event_drul_[STOP] = 0;
 462       p->event_drul_[START] = 0;
 463     }
 464 }
 465
 466 void
 467 Piano_pedal_engraver::typeset_all (Pedal_info *p)
 468 {
 469   /*
 470     Handle suicide.
 471   */
 472   if (p->finished_line_spanner_
 473       && !p->finished_line_spanner_->is_live ())
 474     p->finished_line_spanner_ = 0;
 475   if (p->finished_bracket_
 476       && !p->finished_bracket_->is_live ())
 477     p->finished_bracket_ = 0;
 478
 479   if (p->item_)
 480     p->item_ = 0;
 481
 482   if (p->finished_bracket_)
 483     {
 484       Grob *r = p->finished_bracket_->get_bound (RIGHT);
 485       if (!r)
 486         p->finished_bracket_->set_bound (RIGHT, unsmob_grob (get_property ("currentMusicalColumn")));
 487
 488       p->finished_bracket_ = 0;
 489     }
 490
 491   if (p->finished_line_spanner_)
 492     {
 493       Grob *l = p->finished_line_spanner_->get_bound (LEFT);
 494       Grob *r = p->finished_line_spanner_->get_bound (RIGHT);
 495       if (!r && l)
 496         p->finished_line_spanner_->set_bound (RIGHT, l);
 497       else if (!l && r)
 498         p->finished_line_spanner_->set_bound (LEFT, r);
 499       else if (!r && !l)
 500         {
 501           Grob *cc = unsmob_grob (get_property ("currentMusicalColumn"));
 502           Item *ci = dynamic_cast<Item *> (cc);
 503           p->finished_line_spanner_->set_bound (RIGHT, ci);
 504           p->finished_line_spanner_->set_bound (LEFT, ci);
 505         }
 506
 507       p->finished_line_spanner_ = 0;
 508     }
 509 }
 510
 511 #include "translator.icc"
 512 ADD_ACKNOWLEDGER (Piano_pedal_engraver, note_column);
 513 ADD_TRANSLATOR (Piano_pedal_engraver,
 514                 /* doc */ "Engrave piano pedal symbols and brackets.",
 515                 /* create */ "SostenutoPedal SustainPedal UnaCordaPedal SostenutoPedalLineSpanner SustainPedalLineSpanner UnaCordaPedalLineSpanner",
 516                 /* accept */ "pedal-event",
 517                 /* read */ "currentCommandColumn "
 518                 "pedalSostenutoStrings "
 519                 "pedalSustainStrings "
 520                 "pedalUnaCordaStrings "
 521                 "pedalSostenutoStyle "
 522                 "pedalSustainStyle "
 523                 "pedalUnaCordaStyle",
 524                 /* write */ "");