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