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 #include <ctype.h>
  12 #include "bar.hh"
  13 #include "clef-engraver.hh"
  14 #include "clef-item.hh"
  15 #include "debug.hh"
  16 #include "command-request.hh"
  17 #include "time-description.hh"
  18 #include "note-head.hh"
  19 #include "key-item.hh"
  20 #include "local-key-item.hh"
  21
  22 Clef_engraver::Clef_engraver()
  23 {
  24   clef_p_ = 0;
  25   clef_req_l_ = 0;
  26   clef_type_str_ = "";
  27   c0_position_i_ = 0;
  28   clef_position_i_ = 0;
  29   octave_dir_ = CENTER;
  30 }
  31
  32 /*
  33   PUT THIS IN GUILE!
  34  */
  35 struct Clef_settings {
  36   char const *name;
  37   char const *cleftype;
  38   int position;
  39 } clef_settings[] = {
  40   {"treble", "treble", -2},
  41   {"violin", "treble", -2},
  42   {"G", "treble", -2},
  43   {"G2", "treble", -2},
  44   {"french", "treble",-4 },
  45   {"soprano", "alto",-4 },
  46   {"mezzosoprano", "alto",-2 },
  47   {"alto", "alto",0 },
  48   {"tenor", "alto",2 },
  49   {"baritone", "alto",4 },
  50   {"varbaritone", "bass",0 },
  51   {"bass" , "bass",2 },
  52   {"F", "bass", 2},
  53   {"subbass", "bass",4},
  54   {0,0,0}
  55 };
  56
  57 bool
  58 Clef_engraver::set_type (String s)
  59 {
  60   if (s.right_str(2) == "_8") // Down one octave
  61     {
  62       octave_dir_ = DOWN;
  63       s = s.left_str(s.length_i() - 2);
  64     }
  65   else if (s.right_str(2) == "^8") // Up one octave
  66     {
  67       octave_dir_ = UP;
  68       s = s.left_str(s.length_i() - 2);
  69     }
  70   else
  71     octave_dir_ = CENTER;
  72
  73   bool found = 0;
  74   for (Clef_settings *c = clef_settings; !found && c->name; c++)
  75     {
  76       if (c->name == s)
  77         {
  78           clef_type_str_ = c->cleftype;
  79           clef_position_i_ = c->position;
  80           found = 1;
  81         }
  82       }
  83
  84   if (!found)
  85     {
  86       switch(toupper (s[0]))
  87         {
  88         case 'F':
  89           clef_type_str_ = "bass";
  90           break;
  91         case  'G':
  92           clef_type_str_ = "treble";
  93           break;
  94         case 'C':
  95           clef_type_str_ = "alto";
  96           break;
  97         default:
  98           return false;
  99         }
 100       clef_position_i_ = 2 * (s[1] - '0') - 6;
 101     }
 102
 103   if (clef_type_str_ == "treble")
 104     c0_position_i_ = clef_position_i_ - 4;
 105   else if (clef_type_str_ == "alto")
 106     c0_position_i_ = clef_position_i_;
 107   else if (clef_type_str_ == "bass")
 108     c0_position_i_ = clef_position_i_ + 4;
 109   else
 110     assert (false);
 111
 112   c0_position_i_ -= (int) octave_dir_ * 7;
 113
 114   return true;
 115 }
 116
 117
 118 /**
 119   Generate a clef at the start of a measure. (when you see a Bar,
 120   ie. a breakpoint)
 121   */
 122 void
 123 Clef_engraver::acknowledge_element (Score_element_info info)
 124 {
 125   if (dynamic_cast<Bar*>(info.elem_l_)
 126       && clef_type_str_.length_i())
 127     {
 128       bool def = !clef_p_;
 129       create_clef();
 130       if(def)
 131         clef_p_->set_elt_property(visibility_lambda_scm_sym,
 132                                   gh_eval_str ("postbreak_only_visibility"));
 133     }
 134
 135   /* ugh; should make Clef_referenced baseclass */
 136   Item * it_l =dynamic_cast <Item *> (info.elem_l_);
 137   if (it_l)
 138     {
 139       if (Note_head * h = dynamic_cast<Note_head*>(it_l))
 140         {
 141           //      h->position_i_ += c0_position_i_;
 142           h->position_i_ += c0_position_i_;
 143         }
 144       else if (Local_key_item *i = dynamic_cast<Local_key_item*> (it_l))
 145         {
 146           i->c0_position_i_ =c0_position_i_;
 147         }
 148       else if (Key_item *k = dynamic_cast<Key_item*>(it_l))
 149         {
 150           k-> set_c_position (c0_position_i_);
 151         }
 152     }
 153 }
 154
 155 void
 156 Clef_engraver::do_creation_processing()
 157 {
 158   create_default_b_ = true;     // should read property.
 159   Scalar def = get_property ("createInitdefaultClef", 0);
 160   if (def.to_bool ()) // egcs: Scalar to bool is ambiguous
 161     set_type (def);
 162
 163   if (clef_type_str_.length_i ())
 164     {
 165       create_clef();
 166       clef_p_->set_elt_property (non_default_scm_sym, SCM_BOOL_T);
 167     }
 168 }
 169
 170 bool
 171 Clef_engraver::do_try_music (Music * r_l)
 172 {
 173   if (Clef_change_req *cl = dynamic_cast <Clef_change_req *> (r_l))
 174     {
 175       clef_req_l_ = cl;
 176       if (!set_type (cl->clef_str_))
 177         cl->error (_ ("unknown clef type "));
 178
 179       return true;
 180     }
 181   else
 182     return false;
 183
 184 }
 185
 186 void
 187 Clef_engraver::create_clef()
 188 {
 189   if (!clef_p_)
 190     {
 191       Clef_item *c= new Clef_item;
 192       c->set_elt_property (break_priority_scm_sym, gh_int2scm (-2)); // ugh
 193       String clefstyle = get_property ("clefStyle", 0);
 194       if (clefstyle.length_i ())
 195         c->set_elt_property (style_scm_sym,
 196                              gh_str02scm (clefstyle.ch_C()));
 197
 198       announce_element (Score_element_info (c, clef_req_l_));
 199       clef_p_ = c;
 200     }
 201
 202   clef_p_->symbol_ = clef_type_str_;
 203   clef_p_->y_position_i_ = clef_position_i_;
 204   if (octave_dir_)
 205     {
 206       clef_p_->set_elt_property (octave_dir_scm_sym, gh_int2scm (octave_dir_));
 207     }
 208 }
 209
 210
 211 void
 212 Clef_engraver::do_process_requests()
 213 {
 214   if (clef_req_l_)
 215     {
 216       create_clef();
 217     }
 218   else if (create_default_b_)
 219     {
 220       String type = get_property ("defaultClef", 0);
 221       set_type (type.length_i () ? type : "treble");
 222       create_clef ();
 223       create_default_b_ =0;
 224     }
 225 }
 226
 227 void
 228 Clef_engraver::do_pre_move_processing()
 229 {
 230   if (clef_p_)
 231     {
 232       typeset_element (clef_p_);
 233       clef_p_ =0;
 234     }
 235   create_default_b_ = false;
 236 }
 237
 238 void
 239 Clef_engraver::do_post_move_processing()
 240 {
 241   clef_req_l_ = 0;
 242 }
 243
 244 void
 245 Clef_engraver::do_removal_processing()
 246 {
 247   assert (!clef_p_);
 248 }
 249
 250
 251
 252 ADD_THIS_TRANSLATOR(Clef_engraver);