lily/clef-engraver.cc

   1 /*
   2   clef.cc -- implement Clef_engraver
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c)  1997--1999 Han-Wen Nienhuys <hanwen@cs.uu.nl>,
   7
   8   Mats Bengtsson <matsb@s3.kth.se>
   9 */
  10
  11 /*
  12   CLEAN ME UP.
  13  */
  14 #include <ctype.h>
  15 #include "bar.hh"
  16 #include "clef-engraver.hh"
  17 #include "clef-item.hh"
  18 #include "debug.hh"
  19 #include "command-request.hh"
  20 #include "timing-translator.hh"
  21 #include "note-head.hh"
  22 #include "key-item.hh"
  23 #include "local-key-item.hh"
  24
  25 Clef_engraver::Clef_engraver()
  26 {
  27   clef_p_ = 0;
  28   clef_req_l_ = 0;
  29   clef_type_str_ = "";
  30   c0_position_i_ = 0;
  31   clef_position_i_ = 0;
  32   octave_dir_ = CENTER;
  33   create_default_b_ = true;
  34 }
  35
  36 bool
  37 Clef_engraver::set_type (String s)
  38 {
  39   if (s.right_str(2) == "_8") // Down one octave
  40     {
  41       octave_dir_ = DOWN;
  42       s = s.left_str(s.length_i() - 2);
  43     }
  44   else if (s.right_str(2) == "^8") // Up one octave
  45     {
  46       octave_dir_ = UP;
  47       s = s.left_str(s.length_i() - 2);
  48     }
  49   else
  50     octave_dir_ = CENTER;
  51
  52   bool found = false;
  53   SCM c = get_property ("supportedClefTypes",0);
  54   for (; gh_pair_p(c); c = gh_cdr (c))
  55     {
  56       SCM entry = gh_car (c);
  57       SCM name  = gh_car (entry);
  58
  59       if (ly_scm2string (name) != s)
  60         continue;
  61
  62       SCM glyph  = gh_cadr (entry);
  63       SCM pos  = gh_caddr (entry);
  64
  65       clef_type_str_ = ly_scm2string (glyph);
  66       clef_position_i_ = gh_scm2int (pos);
  67       found = true;
  68       break;
  69     }
  70
  71   if (!found)
  72     {
  73       switch(toupper (s[0]))
  74         {
  75         case 'F':
  76           clef_type_str_ = "bass";
  77           break;
  78         case  'G':
  79           clef_type_str_ = "treble";
  80           break;
  81         case 'C':
  82           clef_type_str_ = "alto";
  83           break;
  84         default:
  85           return false;
  86         }
  87       clef_position_i_ = 2 * (s[1] - '0') - 6;
  88     }
  89
  90   if (clef_type_str_ == "treble")
  91     c0_position_i_ = clef_position_i_ - 4;
  92   else if (clef_type_str_ == "alto")
  93     c0_position_i_ = clef_position_i_;
  94   else if (clef_type_str_ == "bass")
  95     c0_position_i_ = clef_position_i_ + 4;
  96   else
  97     assert (false);
  98
  99   c0_position_i_ -= (int) octave_dir_ * 7;
 100
 101   return true;
 102 }
 103
 104
 105 /**
 106   Generate a clef at the start of a measure. (when you see a Bar,
 107   ie. a breakpoint)
 108   */
 109 void
 110 Clef_engraver::acknowledge_element (Score_element_info info)
 111 {
 112   if (dynamic_cast<Bar*>(info.elem_l_)
 113       && clef_type_str_.length_i())
 114     {
 115       bool default_clef = !clef_p_;
 116       create_clef();
 117       if(!default_clef)
 118         clef_p_->set_elt_property("visibility-lambda",
 119                                   ly_eval_str ("all-visibility"));
 120     }
 121
 122   /* ugh; should make Clef_referenced baseclass */
 123   Item * it_l =dynamic_cast <Item *> (info.elem_l_);
 124   if (it_l)
 125     {
 126       if (Note_head * h = dynamic_cast<Note_head*>(it_l))
 127         {
 128           h->set_position (int (h->position_f ()) + c0_position_i_);
 129         }
 130       else if (Local_key_item *i = dynamic_cast<Local_key_item*> (it_l))
 131         {
 132           i->c0_position_i_ =c0_position_i_;
 133         }
 134       else if (Key_item *k = dynamic_cast<Key_item*>(it_l))
 135         {
 136           k-> set_c_position (c0_position_i_);
 137         }
 138     }
 139 }
 140
 141 void
 142 Clef_engraver::do_creation_processing()
 143 {
 144   create_default_b_ = true;     // should read property.
 145   SCM def = get_property ("createInitdefaultClef", 0);
 146   if (gh_string_p (def))
 147     set_type (ly_scm2string (def));
 148
 149   if (clef_type_str_.length_i ())
 150     {
 151       create_clef();
 152       clef_p_->set_elt_property ("non-default", SCM_BOOL_T);
 153     }
 154 }
 155
 156 bool
 157 Clef_engraver::do_try_music (Music * r_l)
 158 {
 159   if (Clef_change_req *cl = dynamic_cast <Clef_change_req *> (r_l))
 160     {
 161       clef_req_l_ = cl;
 162       if (!set_type (cl->clef_str_))
 163         cl->error (_ ("unknown clef type"));
 164
 165       return true;
 166     }
 167   else
 168     return false;
 169
 170 }
 171
 172 void
 173 Clef_engraver::create_clef()
 174 {
 175   if (!clef_p_)
 176     {
 177       Clef_item *c= new Clef_item;
 178       c->set_elt_property ("break-aligned", SCM_BOOL_T);
 179       announce_element (Score_element_info (c, clef_req_l_));
 180       clef_p_ = c;
 181     }
 182
 183   clef_p_->symbol_ = clef_type_str_;
 184   clef_p_->set_position(clef_position_i_);
 185   if (octave_dir_)
 186     {
 187       clef_p_->set_elt_property ("octave-dir", gh_int2scm (octave_dir_));
 188     }
 189 }
 190
 191
 192 void
 193 Clef_engraver::do_process_requests()
 194 {
 195   if (clef_req_l_)
 196     {
 197       create_clef();
 198     }
 199   else if (create_default_b_)
 200     {
 201       SCM type = get_property ("defaultClef", 0);
 202       if (gh_string_p (type))
 203         set_type (ly_scm2string (type));
 204       else
 205         set_type ( "treble");
 206       create_clef ();
 207       create_default_b_ = false;
 208     }
 209 }
 210
 211 void
 212 Clef_engraver::do_pre_move_processing()
 213 {
 214   if (clef_p_)
 215     {
 216       typeset_element (clef_p_);
 217       clef_p_ =0;
 218     }
 219   create_default_b_ = false;
 220 }
 221
 222 void
 223 Clef_engraver::do_post_move_processing()
 224 {
 225   clef_req_l_ = 0;
 226 }
 227
 228 void
 229 Clef_engraver::do_removal_processing()
 230 {
 231   assert (!clef_p_);
 232 }
 233
 234
 235
 236 ADD_THIS_TRANSLATOR(Clef_engraver);
 237