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   ugh.  Should be configurable.
  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       create_clef();
 129       if (!clef_req_l_)
 130         clef_p_->default_b_ = true;
 131     }
 132
 133   /* ugh; should make Clef_referenced baseclass */
 134   Item * it_l =dynamic_cast <Item *> (info.elem_l_);
 135   if (it_l)
 136     {
 137       if (Note_head * h = dynamic_cast<Note_head*>(it_l))
 138         {
 139           //      h->position_i_ += c0_position_i_;
 140           h->position_i_ = h->steps_i_ + c0_position_i_;
 141         }
 142       else if (Local_key_item *i = dynamic_cast<Local_key_item*> (it_l))
 143         {
 144           i->c0_position_i_ =c0_position_i_;
 145         }
 146       else if (Key_item *k = dynamic_cast<Key_item*>(it_l))
 147         {
 148           k-> set_c_position (c0_position_i_);
 149         }
 150     }
 151 }
 152
 153 void
 154 Clef_engraver::do_creation_processing()
 155 {
 156   create_default_b_ = true;     // should read property.
 157   Scalar def = get_property ("createInitdefaultClef", 0);
 158   if (def.to_bool ()) // egcs: Scalar to bool is ambiguous
 159     set_type (def);
 160
 161   if (clef_type_str_.length_i ())
 162     {
 163       create_clef();
 164       clef_p_->default_b_ = false;
 165     }
 166 }
 167
 168 bool
 169 Clef_engraver::do_try_music (Music * r_l)
 170 {
 171   if (Clef_change_req *cl = dynamic_cast <Clef_change_req *> (r_l))
 172     {
 173       clef_req_l_ = cl;
 174       if (!set_type (cl->clef_str_))
 175         cl->error (_ ("unknown clef type "));
 176
 177       return true;
 178     }
 179   else
 180     return false;
 181
 182 }
 183
 184 void
 185 Clef_engraver::create_clef()
 186 {
 187   if (!clef_p_)
 188     {
 189       Clef_item *c= new Clef_item;
 190       c->break_priority_i_ = -2; // ugh
 191       announce_element (Score_element_info (c, clef_req_l_));
 192       clef_p_ = c;
 193     }
 194
 195
 196   clef_p_->symbol_ = clef_type_str_;
 197   clef_p_->y_position_i_ = clef_position_i_;
 198   clef_p_->octave_dir_ = octave_dir_;
 199 }
 200
 201
 202 void
 203 Clef_engraver::do_process_requests()
 204 {
 205   if (clef_req_l_)
 206     {
 207       create_clef();
 208       clef_p_->default_b_ = false;
 209     }
 210   else if (create_default_b_)
 211     {
 212       String type = get_property ("defaultClef", 0);
 213       set_type (type.length_i () ? type : "treble");
 214       create_clef ();
 215       clef_p_->default_b_ = false;
 216       create_default_b_ =0;
 217     }
 218 }
 219
 220 void
 221 Clef_engraver::do_pre_move_processing()
 222 {
 223   if (clef_p_)
 224     {
 225       typeset_element (clef_p_);
 226       clef_p_ =0;
 227     }
 228   create_default_b_ = false;
 229 }
 230
 231 void
 232 Clef_engraver::do_post_move_processing()
 233 {
 234   clef_req_l_ = 0;
 235 }
 236
 237 void
 238 Clef_engraver::do_removal_processing()
 239 {
 240   assert (!clef_p_);
 241 }
 242
 243
 244
 245 ADD_THIS_TRANSLATOR(Clef_engraver);