lily/stem-engraver.cc

   1 /*
   2   This file is part of LilyPond, the GNU music typesetter.
   3
   4   Copyright (C) 1997--2011 Han-Wen Nienhuys <hanwen@xs4all.nl>
   5
   6   LilyPond is free software: you can redistribute it and/or modify
   7   it under the terms of the GNU General Public License as published by
   8   the Free Software Foundation, either version 3 of the License, or
   9   (at your option) any later version.
  10
  11   LilyPond is distributed in the hope that it will be useful,
  12   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14   GNU General Public License for more details.
  15
  16   You should have received a copy of the GNU General Public License
  17   along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include "engraver.hh"
  21
  22 #include "context.hh"
  23 #include "directional-element-interface.hh"
  24 #include "duration.hh"
  25 #include "international.hh"
  26 #include "item.hh"
  27 #include "misc.hh"
  28 #include "rhythmic-head.hh"
  29 #include "script-interface.hh"
  30 #include "staff-symbol-referencer.hh"
  31 #include "stem-tremolo.hh"
  32 #include "stem.hh"
  33 #include "stream-event.hh"
  34
  35 #include "translator.icc"
  36
  37 class Stem_engraver : public Engraver
  38 {
  39   Grob *stem_;
  40   Grob *tremolo_;
  41   Stream_event *rhythmic_ev_;
  42   Stream_event *tremolo_ev_;
  43
  44   TRANSLATOR_DECLARATIONS (Stem_engraver);
  45
  46 protected:
  47   void make_stem (Grob_info);
  48
  49   DECLARE_TRANSLATOR_LISTENER (tremolo);
  50   DECLARE_ACKNOWLEDGER (rhythmic_head);
  51   void stop_translation_timestep ();
  52 };
  53
  54 Stem_engraver::Stem_engraver ()
  55 {
  56   tremolo_ev_ = 0;
  57   stem_ = 0;
  58   tremolo_ = 0;
  59   rhythmic_ev_ = 0;
  60 }
  61
  62 void
  63 Stem_engraver::make_stem (Grob_info gi)
  64 {
  65   /* Announce the cause of the head as cause of the stem.  The
  66      stem needs a rhythmic structure to fit it into a beam.  */
  67   stem_ = make_item ("Stem", gi.grob ()->self_scm ());
  68
  69   if (tremolo_ev_)
  70     {
  71       /* Stem tremolo is never applied to a note by default,
  72          it must be requested.  But there is a default for the
  73          tremolo value:
  74
  75          c4:8 c c:
  76
  77          the first and last (quarter) note both get one tremolo flag.  */
  78       int requested_type
  79         = robust_scm2int (tremolo_ev_->get_property ("tremolo-type"), 0);
  80       SCM f = get_property ("tremoloFlags");
  81       if (!requested_type)
  82         {
  83           if (scm_is_number (f))
  84             requested_type = scm_to_int (f);
  85           else
  86             requested_type = 8;
  87         }
  88       else
  89         context ()->set_property ("tremoloFlags", scm_from_int (requested_type));
  90
  91       /*
  92         we take the duration log from the Event, since the duration-log
  93         for a note head is always <= 2.
  94       */
  95       Stream_event *ev = gi.event_cause ();
  96       Duration *dur = unsmob_duration (ev->get_property ("duration"));
  97
  98       int tremolo_flags = intlog2 (requested_type) - 2
  99                           - (dur->duration_log () > 2 ? dur->duration_log () - 2 : 0);
 100       if (tremolo_flags <= 0)
 101         {
 102           tremolo_ev_->origin ()->warning (_ ("tremolo duration is too long"));
 103           tremolo_flags = 0;
 104         }
 105
 106       if (tremolo_flags)
 107         {
 108           tremolo_ = make_item ("StemTremolo", tremolo_ev_->self_scm ());
 109
 110           /* The number of tremolo flags is the number of flags of the
 111              tremolo-type minus the number of flags of the note itself.  */
 112           tremolo_->set_property ("flag-count", scm_from_int (tremolo_flags));
 113           tremolo_->set_parent (stem_, X_AXIS);
 114           stem_->set_object ("tremolo-flag", tremolo_->self_scm ());
 115           tremolo_->set_object ("stem", stem_->self_scm ());
 116         }
 117     }
 118 }
 119
 120 void
 121 Stem_engraver::acknowledge_rhythmic_head (Grob_info gi)
 122 {
 123   if (Rhythmic_head::get_stem (gi.grob ()))
 124     return;
 125
 126   Stream_event *cause = gi.event_cause ();
 127   if (!cause)
 128     return;
 129   Duration *d = unsmob_duration (cause->get_property ("duration"));
 130   if (!d)
 131     return;
 132
 133   if (!stem_)
 134     make_stem (gi);
 135
 136   int ds = Stem::duration_log (stem_);
 137   int dc = d->duration_log ();
 138
 139   // half notes and quarter notes all have compatible stems.
 140   // Longas are done differently (oops?), so we can't unify
 141   // them with the other stemmed notes.
 142   if (ds == 1)
 143     ds = 2;
 144   if (dc == 1)
 145     dc = 2;
 146   // whole notes and brevis both have no stems
 147   if (ds == -1)
 148     ds = 0;
 149   if (dc == -1)
 150     dc = 0;
 151
 152   if (ds != dc)
 153     {
 154       gi.event_cause ()->origin ()->warning (_f ("adding note head to incompatible stem (type = %d/%d)",
 155                                                  ds < 0 ? 1 << -ds : 1,
 156                                                  ds > 0 ? 1 << ds : 1));
 157       gi.event_cause ()->origin ()->warning (_ ("maybe input should specify polyphonic voices"));
 158     }
 159
 160   Stem::add_head (stem_, gi.grob ());
 161 }
 162
 163 void
 164 Stem_engraver::stop_translation_timestep ()
 165 {
 166   tremolo_ = 0;
 167   if (stem_)
 168     {
 169       /* FIXME: junk these properties.  */
 170       SCM prop = get_property ("stemLeftBeamCount");
 171       if (scm_is_number (prop))
 172         {
 173           Stem::set_beaming (stem_, scm_to_int (prop), LEFT);
 174           context ()->unset_property (ly_symbol2scm ("stemLeftBeamCount"));
 175         }
 176       prop = get_property ("stemRightBeamCount");
 177       if (scm_is_number (prop))
 178         {
 179           Stem::set_beaming (stem_, scm_to_int (prop), RIGHT);
 180           context ()->unset_property (ly_symbol2scm ("stemRightBeamCount"));
 181         }
 182       stem_ = 0;
 183     }
 184   tremolo_ev_ = 0;
 185 }
 186
 187 IMPLEMENT_TRANSLATOR_LISTENER (Stem_engraver, tremolo);
 188 void
 189 Stem_engraver::listen_tremolo (Stream_event *ev)
 190 {
 191   ASSIGN_EVENT_ONCE (tremolo_ev_, ev);
 192 }
 193
 194 ADD_ACKNOWLEDGER (Stem_engraver, rhythmic_head);
 195
 196 ADD_TRANSLATOR (Stem_engraver,
 197                 /* doc */
 198                 "Create stems and single-stem tremolos.  It also works"
 199                 " together with the beam engraver for overriding beaming.",
 200
 201                 /* create */
 202                 "Stem "
 203                 "StemTremolo ",
 204
 205                 /* read */
 206                 "tremoloFlags "
 207                 "stemLeftBeamCount "
 208                 "stemRightBeamCount ",
 209
 210                 /* write */
 211                 ""
 212                );