lily/key-engraver.cc

   1 /*
   2   key-engraver.cc -- implement Key_engraver
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c)  1997--2001 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   7   */
   8
   9 #include "key-item.hh"
  10 #include "command-request.hh"
  11 #include "musical-request.hh"
  12 #include "item.hh"
  13 #include "bar.hh"
  14 #include "timing-translator.hh"
  15 #include "staff-symbol-referencer.hh"
  16 #include "translator-group.hh"
  17 #include "engraver.hh"
  18 #include "pitch.hh"
  19 #include "protected-scm.hh"
  20 #include "clef.hh"
  21
  22 /**
  23   Make the key signature.
  24  */
  25 class Key_engraver : public Engraver
  26 {
  27   void create_key (bool);
  28   void read_req (Key_change_req const * r);
  29
  30 public:
  31   Key_engraver ();
  32
  33   VIRTUAL_COPY_CONS (Translator);
  34
  35   Key_change_req * keyreq_l_;
  36   Item * item_p_;
  37   Protected_scm old_accs_;      // ugh. -> property
  38
  39 protected:
  40   virtual void initialize ();
  41   virtual void finalize ();
  42   virtual bool try_music (Music *req_l);
  43   virtual void stop_translation_timestep ();
  44   virtual void start_translation_timestep ();
  45   virtual void create_grobs ();
  46   virtual void acknowledge_grob (Grob_info);
  47 };
  48
  49
  50 void
  51 Key_engraver::finalize ()
  52 {
  53   old_accs_ = SCM_EOL;          // unprotect can not  be called from dtor.
  54 }
  55
  56 Key_engraver::Key_engraver ()
  57 {
  58   keyreq_l_ = 0;
  59   item_p_ = 0;
  60 }
  61
  62 void
  63 Key_engraver::create_key (bool def)
  64 {
  65   if (!item_p_)
  66     {
  67       item_p_ = new Item (get_property ("KeySignature"));
  68
  69       item_p_->set_grob_property ("c0-position", gh_int2scm (0));
  70
  71       // todo: put this in basic props.
  72       item_p_->set_grob_property ("old-accidentals", old_accs_);
  73       item_p_->set_grob_property ("new-accidentals", get_property ("keySignature"));
  74
  75       Staff_symbol_referencer::set_interface (item_p_);
  76       Key_item::set_interface (item_p_);
  77
  78
  79       announce_grob (item_p_,keyreq_l_);
  80     }
  81
  82
  83   if (!def)
  84     {
  85       SCM vis = get_property ("explicitKeySignatureVisibility");
  86       if (gh_procedure_p (vis))
  87         item_p_->set_grob_property ("visibility-lambda",vis);
  88     }
  89 }
  90
  91
  92 bool
  93 Key_engraver::try_music (Music * req_l)
  94 {
  95   if (Key_change_req *kc = dynamic_cast <Key_change_req *> (req_l))
  96     {
  97       if (keyreq_l_ && !keyreq_l_->equal_b (kc))
  98         {
  99           kc->origin ()->warning (_ ("Conflicting key signatures found."));
 100           keyreq_l_->origin ()->warning (_ ("This was the other key definition."));
 101           return false;
 102         }
 103       keyreq_l_ = kc;
 104       read_req (keyreq_l_);
 105
 106       return true;
 107     }
 108   return  false;
 109 }
 110
 111 void
 112 Key_engraver::acknowledge_grob (Grob_info info)
 113 {
 114   if (Clef::has_interface (info.elem_l_))
 115     {
 116       SCM c =  get_property ("createKeyOnClefChange");
 117       if (to_boolean (c))
 118         {
 119           create_key (false);
 120         }
 121     }
 122   else if (Bar::has_interface (info.elem_l_)
 123            && gh_pair_p (get_property ("keySignature")))
 124     {
 125       create_key (true);
 126     }
 127
 128 }
 129
 130 void
 131 Key_engraver::create_grobs ()
 132 {
 133   if (keyreq_l_ || old_accs_ != get_property ("keySignature"))
 134     {
 135       create_key (false);
 136     }
 137 }
 138
 139 void
 140 Key_engraver::stop_translation_timestep ()
 141 {
 142   if (item_p_)
 143     {
 144       typeset_grob (item_p_);
 145       item_p_ = 0;
 146     }
 147 }
 148
 149 void
 150 Key_engraver::read_req (Key_change_req const * r)
 151 {
 152   SCM p = r->get_mus_property ("pitch-alist");
 153   if (!gh_pair_p (p))
 154     return;
 155
 156   SCM n = scm_list_copy (p);
 157   SCM accs = SCM_EOL;
 158   for (SCM s = get_property ("keyAccidentalOrder");
 159        gh_pair_p (s); s = gh_cdr (s))
 160     {
 161       if (gh_pair_p (scm_member (gh_car (s), n)))
 162         {
 163           accs = gh_cons (gh_car (s), accs);
 164           n = scm_delete_x (gh_car (s), n);
 165         }
 166     }
 167   for (SCM s = n ; gh_pair_p (s); s = gh_cdr (s))
 168     if (gh_scm2int (gh_cdar (s)))
 169       accs = gh_cons (gh_car (s), accs);
 170
 171   old_accs_ = get_property ("keySignature");
 172   daddy_trans_l_->set_property ("keySignature", accs);
 173 }
 174
 175 void
 176 Key_engraver::start_translation_timestep ()
 177 {
 178   keyreq_l_ = 0;
 179   old_accs_ = get_property ("keySignature");
 180 }
 181
 182 void
 183 Key_engraver::initialize ()
 184 {
 185   daddy_trans_l_->set_property ("keySignature", SCM_EOL);
 186   old_accs_ = SCM_EOL;
 187 }
 188
 189
 190 ADD_THIS_TRANSLATOR (Key_engraver);
 191