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 #include "clef-item.hh"
  16 #include "debug.hh"
  17 #include "command-request.hh"
  18 #include "timing-translator.hh"
  19 #include "note-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 "text-item.hh"
  27
  28 /// where is c-0 in the staff?
  29 class Clef_engraver : public  Engraver {
  30   Clef_item * clef_p_;
  31   Text_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   SCM basic_properties_;
  54   Protected_scm current_settings_;
  55 };
  56
  57
  58 Clef_engraver::Clef_engraver()
  59 {
  60   current_settings_ = SCM_EOL;
  61   basic_properties_ = SCM_EOL;
  62
  63   clef_glyph_ = SCM_EOL;
  64   clef_p_ = 0;
  65   clef_req_l_ = 0;
  66   c0_position_i_ = 0;
  67   clef_position_i_ = 0;
  68   octave_dir_ = CENTER;
  69   octavate_p_ = 0;
  70 }
  71
  72 bool
  73 Clef_engraver::set_type (String s)
  74 {
  75   if (s.right_str(2) == "_8") // Down one octave
  76     {
  77       octave_dir_ = DOWN;
  78       s = s.left_str(s.length_i() - 2);
  79     }
  80   else if (s.right_str(2) == "^8") // Up one octave
  81     {
  82       octave_dir_ = UP;
  83       s = s.left_str(s.length_i() - 2);
  84     }
  85   else
  86     octave_dir_ = CENTER;
  87
  88   SCM c = get_property ("supportedClefTypes");
  89   SCM p = get_property ("clefPitches");
  90
  91   if (gh_list_p (c))
  92     {
  93       SCM found = scm_assoc (ly_str02scm (s.ch_C()), c);
  94       if (found == SCM_BOOL_F)
  95         return false;
  96
  97       clef_glyph_  = gh_cadr (found);
  98       SCM pos  = gh_caddr (found);
  99
 100       clef_position_i_ = gh_scm2int (pos);
 101
 102       found = scm_assoc (clef_glyph_, p);
 103       if (found == SCM_BOOL_F)
 104         return false;
 105
 106       c0_position_i_ = clef_position_i_ + gh_scm2int (gh_cdr (found));
 107     }
 108
 109   c0_position_i_ -= (int) octave_dir_ * 7;
 110
 111   current_settings_ = gh_cons (gh_cons (ly_symbol2scm ("glyph"), clef_glyph_), basic_properties_);
 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 /**
 122   Generate a clef at the start of a measure. (when you see a Bar,
 123   ie. a breakpoint)
 124   */
 125 void
 126 Clef_engraver::acknowledge_element (Score_element_info info)
 127 {
 128   if (dynamic_cast<Bar*>(info.elem_l_)
 129       && gh_string_p (clef_glyph_))
 130     create_clef();
 131
 132   /* ugh; should make Clef_referenced baseclass */
 133   Item * it_l =dynamic_cast <Item *> (info.elem_l_);
 134   if (it_l)
 135     {
 136       if (dynamic_cast<Note_head*>(it_l)
 137           || dynamic_cast<Local_key_item*> (it_l)
 138           )
 139
 140         {
 141           Staff_symbol_referencer_interface si (it_l);
 142           si.set_position (int (si.position_f ()) + c0_position_i_);
 143         }
 144       else if (Key_item *k = dynamic_cast<Key_item*>(it_l))
 145         {
 146           k->set_elt_property ("c0-position", gh_int2scm (c0_position_i_));
 147         }
 148     }
 149 }
 150
 151 void
 152 Clef_engraver::do_creation_processing()
 153 {
 154   basic_properties_ = get_property ("basicClefItemProperties");
 155
 156   SCM def = get_property ("defaultClef");
 157   if (gh_string_p (def))
 158     {
 159       set_type (ly_scm2string (def));
 160       create_clef ();
 161       clef_p_->set_elt_property ("non-default", SCM_BOOL_T);
 162     }
 163 }
 164
 165 bool
 166 Clef_engraver::do_try_music (Music * r_l)
 167 {
 168   if (Clef_change_req *cl = dynamic_cast <Clef_change_req *> (r_l))
 169     {
 170       clef_req_l_ = cl;
 171       if (!set_type (cl->clef_str_))
 172         cl->error (_ ("unknown clef type"));
 173
 174       return true;
 175     }
 176   else
 177     return false;
 178
 179 }
 180
 181 void
 182 Clef_engraver::create_clef()
 183 {
 184   if (!clef_p_)
 185     {
 186       Clef_item *c= new Clef_item ( current_settings_);
 187       announce_element (Score_element_info (c, clef_req_l_));
 188
 189       Staff_symbol_referencer_interface si(c);
 190       si.set_interface ();
 191
 192       clef_p_ = c;
 193     }
 194   Staff_symbol_referencer_interface si(clef_p_);
 195
 196   si.set_position (clef_position_i_);
 197   if (octave_dir_)
 198     {
 199       Text_item * g = new Text_item (get_property ("basicOctavateEightProperties"));
 200       Side_position_interface spi (g);
 201       spi.set_axis (Y_AXIS);
 202       spi.add_support (clef_p_);
 203       g->set_parent (clef_p_, Y_AXIS);
 204       g->set_parent (clef_p_, X_AXIS);
 205       g->add_offset_callback (Side_position_interface::aligned_on_self, X_AXIS);
 206       g->add_offset_callback (Side_position_interface::centered_on_parent, X_AXIS);
 207       g->set_elt_property ("direction", gh_int2scm (octave_dir_));
 208       octavate_p_ = g;
 209       announce_element (Score_element_info (octavate_p_, clef_req_l_));
 210     }
 211 }
 212
 213
 214 void
 215 Clef_engraver::do_process_music()
 216 {
 217   if (clef_req_l_)
 218     {
 219       create_clef();
 220       clef_p_->set_elt_property ("non-default", SCM_BOOL_T);
 221     }
 222 }
 223
 224 void
 225 Clef_engraver::do_pre_move_processing()
 226 {
 227   if (clef_p_)
 228     {
 229       SCM vis = 0;
 230       if(to_boolean (clef_p_->get_elt_property("non-default")))
 231         {
 232           vis = ly_symbol2scm ("all-visible");
 233           vis = scm_eval (vis);
 234         }
 235
 236       if (vis)
 237         {
 238           clef_p_->set_elt_property("visibility-lambda", vis);
 239           if (octavate_p_)
 240             octavate_p_->set_elt_property("visibility-lambda", vis);
 241         }
 242
 243       typeset_element (clef_p_);
 244       clef_p_ =0;
 245
 246       if (octavate_p_)
 247         typeset_element(octavate_p_);
 248
 249       octavate_p_ = 0;
 250     }
 251 }
 252
 253 void
 254 Clef_engraver::do_post_move_processing()
 255 {
 256   clef_req_l_ = 0;
 257 }
 258
 259 ADD_THIS_TRANSLATOR(Clef_engraver);
 260