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