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 "key-item.hh"
  14 #include "local-key-item.hh"
  15 #include "bar.hh"
  16 #include "note-head.hh"
  17 #include "staff-symbol-referencer.hh"
  18 #include "debug.hh"
  19 #include "command-request.hh"
  20 #include "array.hh"
  21 #include "engraver.hh"
  22 #include "direction.hh"
  23 #include "side-position-interface.hh"
  24 #include "item.hh"
  25
  26 /// where is c-0 in the staff?
  27 class Clef_engraver : public  Engraver {
  28   Item * clef_p_;
  29   Item * octavate_p_;
  30   Clef_change_req * clef_req_l_;
  31
  32   void create_clef();
  33   bool set_type (String);
  34 protected:
  35   virtual void do_process_music();
  36   virtual void do_pre_move_processing();
  37   virtual void do_creation_processing();
  38   virtual void do_post_move_processing();
  39   virtual bool do_try_music (Music*);
  40   virtual void acknowledge_element (Score_element_info);
  41 public:
  42   VIRTUAL_COPY_CONS(Translator);
  43   int c0_position_i_;
  44   int clef_position_i_;
  45                                 // junkme.
  46   Direction octave_dir_;
  47   SCM clef_glyph_;              // no need for protection. Always referenced somewhere else.
  48
  49   Clef_engraver();
  50
  51   bool  first_b_;
  52
  53   Protected_scm current_settings_;
  54 };
  55
  56
  57 Clef_engraver::Clef_engraver()
  58 {
  59   current_settings_ = SCM_EOL;
  60
  61   first_b_ = true;
  62   clef_glyph_ = SCM_EOL;
  63   clef_p_ = 0;
  64   clef_req_l_ = 0;
  65   c0_position_i_ = 0;
  66   clef_position_i_ = 0;
  67   octave_dir_ = CENTER;
  68   octavate_p_ = 0;
  69 }
  70
  71 bool
  72 Clef_engraver::set_type (String s)
  73 {
  74   if (s.right_str(2) == "_8") // Down one octave
  75     {
  76       octave_dir_ = DOWN;
  77       s = s.left_str(s.length_i() - 2);
  78     }
  79   else if (s.right_str(2) == "^8") // Up one octave
  80     {
  81       octave_dir_ = UP;
  82       s = s.left_str(s.length_i() - 2);
  83     }
  84   else
  85     octave_dir_ = CENTER;
  86
  87   SCM c = get_property ("supportedClefTypes");
  88   SCM p = get_property ("clefPitches");
  89
  90   if (gh_list_p (c))
  91     {
  92       SCM found = scm_assoc (ly_str02scm (s.ch_C()), c);
  93       if (found == SCM_BOOL_F)
  94         return false;
  95
  96       clef_glyph_  = gh_cadr (found);
  97       SCM pos  = gh_caddr (found);
  98
  99       clef_position_i_ = gh_scm2int (pos);
 100
 101       found = scm_assoc (clef_glyph_, p);
 102       if (found == SCM_BOOL_F)
 103         return false;
 104
 105       c0_position_i_ = clef_position_i_ + gh_scm2int (gh_cdr (found));
 106     }
 107
 108   c0_position_i_ -= (int) octave_dir_ * 7;
 109
 110   SCM basic = get_property ("basicClefItemProperties");
 111   current_settings_ = gh_cons (gh_cons (ly_symbol2scm ("glyph"), clef_glyph_), basic);
 112   current_settings_ =
 113     gh_cons (gh_cons (ly_symbol2scm ("c0-position"),
 114                       gh_int2scm (c0_position_i_)),
 115              current_settings_);
 116
 117   return true;
 118 }
 119
 120 /**
 121   Generate a clef at the start of a measure. (when you see a Bar,
 122   ie. a breakpoint)
 123   */
 124 void
 125 Clef_engraver::acknowledge_element (Score_element_info info)
 126 {
 127   Item * item =dynamic_cast <Item *> (info.elem_l_);
 128   if (item)
 129     {
 130       if (Bar::has_interface (info.elem_l_)
 131           && gh_string_p (clef_glyph_))
 132         create_clef();
 133
 134
 135       if (Note_head::has_interface (item)
 136           || Local_key_item::has_interface (item))
 137         {
 138           int p = int (Staff_symbol_referencer::position_f (item)) + c0_position_i_;
 139           Staff_symbol_referencer::set_position (item,p);
 140
 141         }
 142       else if (Key_item::has_interface (item))
 143         {
 144           item->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::set_interface (c);
 184
 185       clef_p_ = c;
 186     }
 187   Staff_symbol_referencer::set_position(clef_p_, clef_position_i_);
 188   if (octave_dir_)
 189     {
 190       Item * g = new Item (get_property ("basicOctavateEightProperties"));
 191       Side_position::set_axis (g,Y_AXIS);
 192       Side_position::add_support (g,clef_p_);
 193
 194       g->set_parent (clef_p_, Y_AXIS);
 195       g->set_parent (clef_p_, X_AXIS);
 196       g->add_offset_callback (Side_position::aligned_on_self, X_AXIS);
 197       g->add_offset_callback (Side_position::centered_on_parent, X_AXIS);
 198       g->set_elt_property ("direction", gh_int2scm (octave_dir_));
 199       octavate_p_ = g;
 200       announce_element (Score_element_info (octavate_p_, clef_req_l_));
 201     }
 202 }
 203
 204
 205 void
 206 Clef_engraver::do_process_music()
 207 {
 208   if (clef_req_l_ || first_b_)
 209     {
 210       create_clef();
 211       clef_p_->set_elt_property ("non-default", SCM_BOOL_T);
 212     }
 213 }
 214
 215 void
 216 Clef_engraver::do_pre_move_processing()
 217 {
 218   if (clef_p_)
 219     {
 220       SCM vis = 0;
 221       if(to_boolean (clef_p_->get_elt_property("non-default")))
 222         {
 223           vis = ly_symbol2scm ("all-visible");
 224           vis = scm_eval (vis);
 225         }
 226
 227       if (vis)
 228         {
 229           clef_p_->set_elt_property("visibility-lambda", vis);
 230           if (octavate_p_)
 231             octavate_p_->set_elt_property("visibility-lambda", vis);
 232         }
 233
 234       typeset_element (clef_p_);
 235       clef_p_ =0;
 236
 237       if (octavate_p_)
 238         typeset_element(octavate_p_);
 239
 240       octavate_p_ = 0;
 241     }
 242
 243   first_b_ = 0;
 244 }
 245
 246 void
 247 Clef_engraver::do_post_move_processing()
 248 {
 249   clef_req_l_ = 0;
 250 }
 251
 252 ADD_THIS_TRANSLATOR(Clef_engraver);
 253