lily/clef-engraver.cc

   1 /*
   2   clef-engraver.cc -- implement Clef_engraver
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c)  1997--2000 Han-Wen Nienhuys <hanwen@cs.uu.nl>,
   7
   8   Mats Bengtsson <matsb@s3.kth.se>
   9 */
  10
  11 #include <ctype.h>
  12
  13 #include "staff-symbol-referencer.hh"
  14 #include "bar.hh"
  15
  16 #include "debug.hh"
  17 #include "command-request.hh"
  18 #include "timing-translator.hh"
  19 #include "rhythmic-head.hh"
  20 #include "key-item.hh"
  21 #include "local-key-item.hh"
  22 #include "array.hh"
  23 #include "engraver.hh"
  24 #include "direction.hh"
  25 #include "side-position-interface.hh"
  26 #include "item.hh"
  27
  28 /// where is c-0 in the staff?
  29 class Clef_engraver : public  Engraver {
  30   Item * clef_p_;
  31   Item * octavate_p_;
  32   Clef_change_req * clef_req_l_;
  33
  34   void create_clef();
  35   bool set_type (String);
  36 protected:
  37   virtual void do_process_music();
  38   virtual void do_pre_move_processing();
  39   virtual void do_creation_processing();
  40   virtual void do_post_move_processing();
  41   virtual bool do_try_music (Music*);
  42   virtual void acknowledge_element (Score_element_info);
  43 public:
  44   VIRTUAL_COPY_CONS(Translator);
  45   int c0_position_i_;
  46   int clef_position_i_;
  47                                 // junkme.
  48   Direction octave_dir_;
  49   SCM clef_glyph_;              // no need for protection. Always referenced somewhere else.
  50
  51   Clef_engraver();
  52
  53   bool  first_b_;
  54
  55   Protected_scm current_settings_;
  56 };
  57
  58
  59 Clef_engraver::Clef_engraver()
  60 {
  61   current_settings_ = SCM_EOL;
  62
  63   first_b_ = true;
  64   clef_glyph_ = SCM_EOL;
  65   clef_p_ = 0;
  66   clef_req_l_ = 0;
  67   c0_position_i_ = 0;
  68   clef_position_i_ = 0;
  69   octave_dir_ = CENTER;
  70   octavate_p_ = 0;
  71 }
  72
  73 bool
  74 Clef_engraver::set_type (String s)
  75 {
  76   if (s.right_str(2) == "_8") // Down one octave
  77     {
  78       octave_dir_ = DOWN;
  79       s = s.left_str(s.length_i() - 2);
  80     }
  81   else if (s.right_str(2) == "^8") // Up one octave
  82     {
  83       octave_dir_ = UP;
  84       s = s.left_str(s.length_i() - 2);
  85     }
  86   else
  87     octave_dir_ = CENTER;
  88
  89   SCM c = get_property ("supportedClefTypes");
  90   SCM p = get_property ("clefPitches");
  91
  92   if (gh_list_p (c))
  93     {
  94       SCM found = scm_assoc (ly_str02scm (s.ch_C()), c);
  95       if (found == SCM_BOOL_F)
  96         return false;
  97
  98       clef_glyph_  = gh_cadr (found);
  99       SCM pos  = gh_caddr (found);
 100
 101       clef_position_i_ = gh_scm2int (pos);
 102
 103       found = scm_assoc (clef_glyph_, p);
 104       if (found == SCM_BOOL_F)
 105         return false;
 106
 107       c0_position_i_ = clef_position_i_ + gh_scm2int (gh_cdr (found));
 108     }
 109
 110   c0_position_i_ -= (int) octave_dir_ * 7;
 111
 112   SCM basic = get_property ("basicClefItemProperties");
 113   current_settings_ = gh_cons (gh_cons (ly_symbol2scm ("glyph"), clef_glyph_), basic);
 114   current_settings_ =
 115     gh_cons (gh_cons (ly_symbol2scm ("c0-position"),
 116                       gh_int2scm (c0_position_i_)),
 117              current_settings_);
 118
 119   return true;
 120 }
 121
 122 /**
 123   Generate a clef at the start of a measure. (when you see a Bar,
 124   ie. a breakpoint)
 125   */
 126 void
 127 Clef_engraver::acknowledge_element (Score_element_info info)
 128 {
 129   if (dynamic_cast<Bar*>(info.elem_l_)
 130       && gh_string_p (clef_glyph_))
 131     create_clef();
 132
 133   Item * it_l =dynamic_cast <Item *> (info.elem_l_);
 134   if (it_l)
 135     {
 136       if (to_boolean (it_l->get_elt_property("note-head-interface"))
 137           || dynamic_cast<Local_key_item*> (it_l))
 138         {
 139           Staff_symbol_referencer_interface si (it_l);
 140           si.set_position (int (si.position_f ()) + c0_position_i_);
 141         }
 142       else if (Key_item *k = dynamic_cast<Key_item*>(it_l))
 143         {
 144           k->set_elt_property ("c0-position", gh_int2scm (c0_position_i_));
 145         }
 146     }
 147 }
 148
 149 void
 150 Clef_engraver::do_creation_processing()
 151 {
 152   SCM def = get_property ("defaultClef");
 153   if (gh_string_p (def))
 154     {
 155       set_type (ly_scm2string (def));
 156     }
 157 }
 158
 159 bool
 160 Clef_engraver::do_try_music (Music * r_l)
 161 {
 162   if (Clef_change_req *cl = dynamic_cast <Clef_change_req *> (r_l))
 163     {
 164       clef_req_l_ = cl;
 165       if (!set_type (cl->clef_str_))
 166         cl->error (_ ("unknown clef type"));
 167
 168       return true;
 169     }
 170   else
 171     return false;
 172
 173 }
 174
 175 void
 176 Clef_engraver::create_clef()
 177 {
 178   if (!clef_p_)
 179     {
 180       Item *c= new Item ( current_settings_);
 181       announce_element (Score_element_info (c, clef_req_l_));
 182
 183       Staff_symbol_referencer_interface si(c);
 184       si.set_interface ();
 185
 186       clef_p_ = c;
 187     }
 188   Staff_symbol_referencer_interface si(clef_p_);
 189
 190   si.set_position (clef_position_i_);
 191   if (octave_dir_)
 192     {
 193       Item * g = new Item (get_property ("basicOctavateEightProperties"));
 194       Side_position_interface spi (g);
 195       spi.set_axis (Y_AXIS);
 196       spi.add_support (clef_p_);
 197       g->set_parent (clef_p_, Y_AXIS);
 198       g->set_parent (clef_p_, X_AXIS);
 199       g->add_offset_callback (Side_position_interface::aligned_on_self, X_AXIS);
 200       g->add_offset_callback (Side_position_interface::centered_on_parent, X_AXIS);
 201       g->set_elt_property ("direction", gh_int2scm (octave_dir_));
 202       octavate_p_ = g;
 203       announce_element (Score_element_info (octavate_p_, clef_req_l_));
 204     }
 205 }
 206
 207
 208 void
 209 Clef_engraver::do_process_music()
 210 {
 211   if (clef_req_l_ || first_b_)
 212     {
 213       create_clef();
 214       clef_p_->set_elt_property ("non-default", SCM_BOOL_T);
 215     }
 216 }
 217
 218 void
 219 Clef_engraver::do_pre_move_processing()
 220 {
 221   if (clef_p_)
 222     {
 223       SCM vis = 0;
 224       if(to_boolean (clef_p_->get_elt_property("non-default")))
 225         {
 226           vis = ly_symbol2scm ("all-visible");
 227           vis = scm_eval (vis);
 228         }
 229
 230       if (vis)
 231         {
 232           clef_p_->set_elt_property("visibility-lambda", vis);
 233           if (octavate_p_)
 234             octavate_p_->set_elt_property("visibility-lambda", vis);
 235         }
 236
 237       typeset_element (clef_p_);
 238       clef_p_ =0;
 239
 240       if (octavate_p_)
 241         typeset_element(octavate_p_);
 242
 243       octavate_p_ = 0;
 244     }
 245
 246   first_b_ = 0;
 247 }
 248
 249 void
 250 Clef_engraver::do_post_move_processing()
 251 {
 252   clef_req_l_ = 0;
 253 }
 254
 255 ADD_THIS_TRANSLATOR(Clef_engraver);
 256