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
  54
  55 Clef_engraver::Clef_engraver()
  56 {
  57   clef_glyph_ = SCM_EOL;
  58   clef_p_ = 0;
  59   clef_req_l_ = 0;
  60   c0_position_i_ = 0;
  61   clef_position_i_ = 0;
  62   octave_dir_ = CENTER;
  63   octavate_p_ = 0;
  64 }
  65
  66 bool
  67 Clef_engraver::set_type (String s)
  68 {
  69   if (s.right_str(2) == "_8") // Down one octave
  70     {
  71       octave_dir_ = DOWN;
  72       s = s.left_str(s.length_i() - 2);
  73     }
  74   else if (s.right_str(2) == "^8") // Up one octave
  75     {
  76       octave_dir_ = UP;
  77       s = s.left_str(s.length_i() - 2);
  78     }
  79   else
  80     octave_dir_ = CENTER;
  81
  82   SCM c = get_property ("supportedClefTypes");
  83   SCM p = get_property ("clefPitches");
  84
  85   if (gh_list_p (c))
  86     {
  87       SCM found = scm_assoc (ly_str02scm (s.ch_C()), c);
  88       if (found == SCM_BOOL_F)
  89         return false;
  90
  91       clef_glyph_  = gh_cadr (found);
  92       SCM pos  = gh_caddr (found);
  93
  94       clef_position_i_ = gh_scm2int (pos);
  95
  96       found = scm_assoc (clef_glyph_, p);
  97       if (found == SCM_BOOL_F)
  98         return false;
  99
 100       c0_position_i_ = clef_position_i_ + gh_scm2int (gh_cdr (found));
 101     }
 102
 103   c0_position_i_ -= (int) octave_dir_ * 7;
 104   return true;
 105 }
 106
 107
 108 /**
 109   Generate a clef at the start of a measure. (when you see a Bar,
 110   ie. a breakpoint)
 111   */
 112 void
 113 Clef_engraver::acknowledge_element (Score_element_info info)
 114 {
 115   if (dynamic_cast<Bar*>(info.elem_l_)
 116       && gh_string_p (clef_glyph_))
 117     create_clef();
 118
 119   /* ugh; should make Clef_referenced baseclass */
 120   Item * it_l =dynamic_cast <Item *> (info.elem_l_);
 121   if (it_l)
 122     {
 123       if (dynamic_cast<Note_head*>(it_l)
 124           || dynamic_cast<Local_key_item*> (it_l)
 125           )
 126
 127         {
 128           Staff_symbol_referencer_interface si (it_l);
 129           si.set_position (int (si.position_f ()) + c0_position_i_);
 130         }
 131       else if (Key_item *k = dynamic_cast<Key_item*>(it_l))
 132         {
 133           k->set_elt_property ("c0-position", gh_int2scm (c0_position_i_));
 134         }
 135     }
 136 }
 137
 138 void
 139 Clef_engraver::do_creation_processing()
 140 {
 141   SCM def = get_property ("defaultClef");
 142   if (gh_string_p (def))
 143     {
 144       set_type (ly_scm2string (def));
 145       create_clef ();
 146       clef_p_->set_elt_property ("non-default", SCM_BOOL_T);
 147     }
 148 }
 149
 150 bool
 151 Clef_engraver::do_try_music (Music * r_l)
 152 {
 153   if (Clef_change_req *cl = dynamic_cast <Clef_change_req *> (r_l))
 154     {
 155       clef_req_l_ = cl;
 156       if (!set_type (cl->clef_str_))
 157         cl->error (_ ("unknown clef type"));
 158
 159       return true;
 160     }
 161   else
 162     return false;
 163
 164 }
 165
 166 void
 167 Clef_engraver::create_clef()
 168 {
 169   if (!clef_p_)
 170     {
 171       Clef_item *c= new Clef_item;
 172       c->set_elt_property ("breakable", SCM_BOOL_T);
 173       c->set_elt_property ("break-align-symbol", ly_symbol2scm ("Clef_item"));
 174       announce_element (Score_element_info (c, clef_req_l_));
 175
 176       Staff_symbol_referencer_interface si(c);
 177       si.set_interface ();
 178
 179       clef_p_ = c;
 180     }
 181   Staff_symbol_referencer_interface si(clef_p_);
 182   clef_p_->set_elt_property ("glyph", clef_glyph_);
 183   si.set_position (clef_position_i_);
 184   if (octave_dir_)
 185     {
 186       Text_item * g = new Text_item;
 187       Side_position_interface spi (g);
 188       spi.set_axis (Y_AXIS);
 189       spi.add_support (clef_p_);
 190       g->set_elt_property ("text", ly_str02scm ( "8"));
 191       g->set_elt_property ("style", gh_str02scm ("italic"));
 192       g->set_parent (clef_p_, Y_AXIS);
 193       g->set_parent (clef_p_, X_AXIS);
 194
 195       g->set_elt_property ("self-alignment-X", gh_int2scm (0));
 196       g->add_offset_callback (Side_position_interface::aligned_on_self, X_AXIS);
 197       g->add_offset_callback (Side_position_interface::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_)
 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       if(to_boolean (clef_p_->remove_elt_property("non-default")))
 221         {
 222           SCM all = scm_eval (ly_symbol2scm ("all-visible"));
 223           clef_p_->set_elt_property("visibility-lambda", all);
 224           if (octavate_p_)
 225             octavate_p_->set_elt_property("visibility-lambda", all);
 226         }
 227       else
 228         {
 229           SCM beg = scm_eval (ly_symbol2scm ("begin-of-line-visible"));
 230
 231           clef_p_->set_elt_property ("visibility-lambda", beg);
 232           if (octavate_p_)
 233             octavate_p_->set_elt_property ("visibility-lambda", beg);
 234         }
 235       typeset_element (clef_p_);
 236       clef_p_ =0;
 237
 238       if (octavate_p_)
 239         typeset_element(octavate_p_);
 240
 241       octavate_p_ = 0;
 242     }
 243 }
 244
 245 void
 246 Clef_engraver::do_post_move_processing()
 247 {
 248   clef_req_l_ = 0;
 249 }
 250
 251 ADD_THIS_TRANSLATOR(Clef_engraver);
 252