lily/lookup.cc

   1 /*
   2   lookup.cc -- implement simple Lookup methods.
   3
   4   source file of the GNU LilyPond music typesetter
   5
   6   (c)  1997--1998 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   7
   8   Jan Nieuwenhuizen <janneke@gnu.org>
   9
  10   TODO
  11       Read spacing info from AFMs
  12       Glissando
  13 */
  14
  15 #include <ctype.h>
  16 #include "lookup.hh"
  17 #include "debug.hh"
  18 #include "dimensions.hh"
  19 #include "symtable.hh"
  20 #include "scalar.hh"
  21 #include "paper-def.hh"
  22 #include "string-convert.hh"
  23 #include "file-path.hh"
  24 #include "main.hh"
  25 #include "lily-guile.hh"
  26
  27
  28 Lookup::Lookup ()
  29 {
  30   paper_l_ = 0;
  31   symtables_p_ = new Symtables;
  32   afm_p_ =0;
  33 }
  34
  35 Lookup::Lookup (Lookup const& s)
  36 {
  37   font_ = s.font_;
  38   font_path_ = s.font_path_;
  39   paper_l_ = s.paper_l_;
  40   symtables_p_ = new Symtables (*s.symtables_p_);
  41   afm_p_ = 0;
  42 }
  43
  44 Lookup::Lookup (Symtables const& s)
  45 {
  46   font_ = s.font_;
  47   font_path_ = s.font_path_;
  48   paper_l_ = 0;
  49   symtables_p_ = new Symtables (s);
  50   afm_p_ = 0;
  51 }
  52
  53 Lookup::~Lookup ()
  54 {
  55   delete afm_p_;
  56   delete symtables_p_;
  57 }
  58
  59 Molecule
  60 Lookup::accidental (int j, bool cautionary) const
  61 {
  62   Molecule m(afm_find (String ("accidentals") + String ("-") + to_str (j)));
  63   if (cautionary)
  64     {
  65       m.add_at_edge(X_AXIS, LEFT,
  66                     Molecule(afm_find (String ("accidentals") + String ("-("))))
  67 ;
  68       m.add_at_edge(X_AXIS, RIGHT,
  69                     Molecule(afm_find (String ("accidentals") + String ("-)"))))
  70 ;
  71     }
  72   return m;
  73 }
  74
  75 void
  76 Lookup::add (String s, Symtable*p)
  77 {
  78   symtables_p_->add (s, p);
  79 }
  80
  81 Atom
  82 Lookup::afm_find (String s, bool warn) const
  83 {
  84   if (!afm_p_)
  85     {
  86       *mlog << "[" << font_path_;
  87       ( (Lookup*)this)->afm_p_ = new Adobe_font_metric (read_afm (font_path_));
  88       *mlog << "]" << flush ;
  89       DOUT << this->afm_p_->str ();
  90     }
  91   Adobe_font_char_metric m = afm_p_->find_char (s, warn);
  92
  93   Atom a;
  94   if (m.code () < 0)
  95     return a;
  96
  97   a.dim_ = m.B_;
  98   a.dim_[X_AXIS] *= 1 / 1000.0;
  99   a.dim_[Y_AXIS] *= 1 / 1000.0;
 100   Array<Real> arr;
 101   arr.push (m.code ());
 102   a.lambda_ =  (lambda_scm ("char", arr));
 103   a.str_ = "afm_find: " + s;
 104   a.font_ = font_;
 105   return a;
 106 }
 107
 108 Atom
 109 Lookup::ball (int j) const
 110 {
 111   if (j > 2)
 112     j = 2;
 113
 114   return afm_find (String ("balls") + String ("-") + to_str (j));
 115 }
 116
 117 Atom
 118 Lookup::bar (String str, Real h) const
 119 {
 120   Array<Real> arr;
 121   arr.push (h);
 122   Atom a = (*symtables_p_) ("bars")->lookup (str);
 123   a.lambda_ =  (lambda_scm (a.str_, arr));
 124   a.str_ = "bar";
 125   a.dim_.y () = Interval (-h/2, h/2);
 126   a.font_ = font_;
 127   return a;
 128 }
 129
 130 Atom
 131 Lookup::beam (Real slope, Real width, Real thick) const
 132 {
 133   Real height = slope * width;
 134   Real min_y = (0 <? height) - thick/2;
 135   Real max_y = (0 >? height) + thick/2;
 136
 137   Array<Real> arr;
 138   arr.push (width);
 139   arr.push (slope);
 140   arr.push (thick);
 141
 142   Atom a;
 143   a.lambda_ =  (lambda_scm ("beam", arr));
 144   a.str_ = "beam";
 145   a.dim_[X_AXIS] = Interval (0, width);
 146   a.dim_[Y_AXIS] = Interval (min_y, max_y);
 147   return a;
 148 }
 149
 150 Atom
 151 Lookup::clef (String st) const
 152 {
 153   return afm_find (String ("clefs") + String ("-") + st);
 154 }
 155
 156 SCM
 157 offset2scm (Offset o)
 158 {
 159   return gh_list (gh_double2scm (o[X_AXIS]), gh_double2scm(o[Y_AXIS]), SCM_UNDEFINED);
 160 }
 161
 162 Atom
 163 Lookup::dashed_slur (Array<Offset> controls, Real thick, Real dash) const
 164 {
 165   assert (controls.size () == 8);
 166   Offset d = controls[3] - controls[0];
 167
 168   Real dx = d[X_AXIS];
 169   Real dy = d[Y_AXIS];
 170
 171   Atom a;
 172   a.font_ = font_;
 173   a.dim_[X_AXIS] = Interval (0, dx);
 174   a.dim_[Y_AXIS] = Interval (0 <? dy,  0 >? dy);
 175
 176   SCM sc[4];
 177   for (int i=0; i<  4; i++)
 178     {
 179       sc[i] =  offset2scm (controls[i]);
 180     }
 181
 182   // (lambda (o) (dashed-slur o thick dash '(stuff))
 183   a.lambda_ =
 184     ly_append (ly_lambda_o (),
 185     gh_list (ly_append (ly_func_o ("dashed-slur"),
 186     gh_cons (gh_double2scm (thick),
 187     gh_cons (gh_double2scm (dash),
 188     gh_list (ly_quote_scm (gh_list (sc[1], sc[2], sc[3], sc[0], SCM_UNDEFINED)), SCM_UNDEFINED)))), SCM_UNDEFINED));
 189
 190   a.str_ = "dashed_slur";
 191   return a;
 192 }
 193
 194 Atom
 195 Lookup::dots () const
 196 {
 197   return afm_find (String ("dots") + String ("-") + String ("dot"));
 198 }
 199
 200 Atom
 201 Lookup::dynamic (String st) const
 202 {
 203   return (*symtables_p_) ("dynamics")->lookup (st);
 204 }
 205
 206 Atom
 207 Lookup::fill (Box b) const
 208 {
 209   Atom a;
 210   a.dim_ = b;
 211   return a;
 212 }
 213
 214 Atom
 215 Lookup::flag (int j, Direction d) const
 216 {
 217   char c = (d == UP) ? 'u' : 'd';
 218   Atom a = afm_find (String ("flags") + String ("-") + to_str (c) + to_str (j));
 219   return a;
 220 }
 221
 222 void
 223 Lookup::print () const
 224 {
 225 #ifndef NPRINT
 226   DOUT << "Lookup {\n";
 227   symtables_p_->print ();
 228   DOUT << "}\n";
 229 #endif
 230 }
 231
 232 Atom
 233 Lookup::rest (int j, bool o) const
 234 {
 235    return afm_find (String ("rests")
 236                     + String ("-") + to_str (j) + (o ? "o" : ""));
 237 }
 238
 239 Atom
 240 Lookup::rule_symbol (Real height, Real width) const
 241 {
 242   Atom a = (*symtables_p_) ("param")->lookup ("rule");
 243   Array<Real> arr;
 244   arr.push (height);
 245   arr.push (width);
 246   a.lambda_ = (lambda_scm (a.str_, arr));
 247   a.str_ = "rule_symbol";
 248   a.dim_.x () = Interval (0, width);
 249   a.dim_.y () = Interval (0, height);
 250   return a;
 251 }
 252
 253 Atom
 254 Lookup::script (String str) const
 255 {
 256   return afm_find (String ("scripts") + String ("-") + str);
 257 }
 258
 259 Atom
 260 Lookup::special_time_signature (String s, Array<int> arr) const
 261 {
 262   // First guess: s contains only the signature style
 263   assert (arr.size () >1);
 264   String symbolname = "timesig-" + s + to_str (arr[0]) + "/" + to_str (arr[1]);
 265
 266   Atom a = afm_find (symbolname, false);
 267   if (!a.empty ())
 268     return a;
 269
 270   // Second guess: s contains the full signature name
 271   a = afm_find ("timesig-"+s, false);
 272   if (!a.empty ())
 273     return a;
 274
 275   // Resort to default layout with numbers
 276   return time_signature (arr);
 277 }
 278
 279 Atom
 280 Lookup::stem (Real y1, Real y2) const
 281 {
 282   if (y1 > y2)
 283     {
 284       Real t = y1;
 285       y1 = y2;
 286       y2 = t;
 287     }
 288   Atom a;
 289
 290   a.dim_.x () = Interval (0,0);
 291   a.dim_.y () = Interval (y1,y2);
 292
 293   Array<Real> arr;
 294
 295   Real stem_width = paper_l_->get_var ("stemthickness");
 296   arr.push (-stem_width /2);
 297   arr.push (stem_width);
 298   arr.push (y2);
 299   arr.push (-y1);
 300
 301   a.lambda_ = (lambda_scm ("stem", arr));
 302   a.str_ = "stem";
 303   a.font_ = font_;
 304   return a;
 305 }
 306
 307 Atom
 308 Lookup::streepje (int type) const
 309 {
 310   if (type > 2)
 311     type = 2;
 312
 313   return  afm_find ("balls" + String ("-") +to_str (type) + "l");
 314 }
 315
 316 Dictionary<String> cmr_dict;
 317 Dictionary<Adobe_font_metric*> afm_p_dict;
 318
 319 Atom
 320 Lookup::text (String style, String text) const
 321 {
 322   Array<Scalar> arr;
 323
 324   arr.push (text);
 325   Atom a =  (*symtables_p_) ("style")->lookup (style);
 326   a.lambda_ = lambda_scm (a.str_, arr);
 327   Real font_w = a.dim_.x ().length ();
 328   Real font_h = a.dim_.y ().length ();
 329
 330 // urg
 331 //  if (!cmr_dict.length_i ())
 332   if (!cmr_dict.elem_b ("roman"))
 333     {
 334       //brrrr
 335       cmr_dict.elem ("bold") = "cmbx";
 336       cmr_dict.elem ("dynamic") = "feta-din";
 337       cmr_dict.elem ("finger") = "feta-nummer";
 338       cmr_dict.elem ("italic") = "cmti";
 339       cmr_dict.elem ("roman") = "cmr";
 340     }
 341
 342   if (!afm_p_dict.elem_b (style))
 343     {
 344       Adobe_font_metric* afm_p = 0;
 345       String cmr_str = cmr_dict.elem (style) + to_str ((int) font_h) + ".afm";
 346       String font_path = global_path.find (cmr_str);
 347       if (!font_path.length_i ())
 348         {
 349           warning (_f("can't open file: `%s'", cmr_str.ch_C ()));
 350           warning (_f("guessing dimensions for font style: `%s'", style.ch_C ()));
 351         }
 352       else
 353         {
 354           *mlog << "[" << font_path;
 355           afm_p = new Adobe_font_metric (read_afm (font_path));
 356           DOUT << afm_p->str ();
 357           *mlog << "]" << flush ;
 358         }
 359       afm_p_dict.elem (style) = afm_p;
 360     }
 361   Real w = 0;
 362   Adobe_font_metric* afm_p = afm_p_dict.elem (style);
 363   DOUT << "\nChars: ";
 364   for (int i = 0; i < text.length_i (); i++)
 365     {
 366       if (text[i]=='\\')
 367         for (i++; (i < text.length_i ()) && isalpha(text[i]); i++)
 368           ;
 369       else
 370         {
 371           if (afm_p)
 372             {
 373               Adobe_font_char_metric m = afm_p->char_metrics_[(int)text[i]];
 374               w += m.B_.x ().length ();
 375               DOUT << to_str (m.B_.x ().length ()) << " ";
 376             }
 377           else
 378               w += font_w;
 379         }
 380     }
 381   DOUT << "\n" << to_str (w) << "\n";
 382   a.dim_.x () = Interval (0, w);
 383   a.str_ = "text";
 384   a.font_ = font_;
 385   return a;
 386 }
 387
 388
 389 Atom
 390 Lookup::time_signature (Array<int> a) const
 391 {
 392   Atom s ((*symtables_p_) ("param")->lookup ("time_signature"));
 393   s.lambda_ =  (lambda_scm (s.str_, a));
 394
 395   return s;
 396 }
 397
 398 /*
 399   should be handled via Tex_ code and Lookup::bar ()
 400  */
 401 Atom
 402 Lookup::vbrace (Real &y) const
 403 {
 404   Atom a = (*symtables_p_) ("param")->lookup ( "brace");
 405   Interval ydims = a.dim_[Y_AXIS];
 406   Real min_y = ydims[LEFT];
 407   Real max_y = ydims[RIGHT];
 408   Real step = 1.0 PT;
 409
 410   if (y < min_y)
 411     {
 412       warning (_ ("piano brace")
 413                + " " + _ ("too small") +  " (" + print_dimen (y) + ")");
 414       y = min_y;
 415     }
 416   if (y > max_y)
 417     {
 418       warning (_ ("piano brace")
 419                + " " + _ ("too big") + " (" + print_dimen (y) + ")");
 420       y = max_y;
 421     }
 422
 423
 424   int idx = int (rint ( (y- min_y)/step)) + 1;
 425
 426   Array<Real> arr;
 427   arr.push (idx);
 428   a.lambda_ = (lambda_scm (a.str_, arr));
 429   a.str_ = "brace";
 430   a.dim_[Y_AXIS] = Interval (-y/2,y/2);
 431   a.font_ = font_;
 432   return a;
 433 }
 434
 435 Atom
 436 Lookup::hairpin (Real width, bool decresc, bool continued) const
 437 {
 438   Atom a;
 439   Real height = paper_l_->staffheight_f () / 6;
 440   String ps;
 441   ps += to_str (width) + " "
 442     + to_str (height) + " "
 443     + to_str (continued ? height/2 : 0) +
 444     + " draw_"  + String (decresc ? "de" : "") + "cresc\n";
 445   a.str_ = ps;
 446   a.dim_.x () = Interval (0, width);
 447   a.dim_.y () = Interval (-2*height, 2*height);
 448   a.font_ = font_;
 449   return a;
 450 }
 451
 452 Atom
 453 Lookup::plet (Real dy , Real dx, Direction dir) const
 454 {
 455   String ps;
 456
 457   ps += String_convert::double_str (dx) + " "
 458     + String_convert::double_str (dy) + " "
 459     + String_convert::int_str ( (int)dir) +
 460     " draw_plet ";
 461
 462   Atom a;
 463   a.str_ = ps;
 464   return a;
 465 }
 466
 467 Atom
 468 Lookup::slur (Array<Offset> controls) const
 469 {
 470   assert (controls.size () == 8);
 471
 472   String ps;
 473
 474   Real dx = controls[3].x () - controls[0].x ();
 475   Real dy = controls[3].y () - controls[0].y ();
 476   Atom a;
 477
 478   SCM scontrols [8];
 479   int indices[] = {5,6,7,4,1,2,3,0};
 480
 481   for (int i= 0; i < 8; i++)
 482     scontrols[i] = offset2scm (controls[indices[i]]);
 483
 484
 485   a.lambda_ =
 486     gh_append2 (ly_lambda_o (),
 487                 gh_list (gh_append2 (ly_func_o ("slur"),
 488                                      gh_list (ly_quote_scm (gh_list (scontrols[0],
 489                                                                      scontrols[1],
 490                                                                      scontrols[2],
 491                                                                      scontrols[3],
 492                                                                      scontrols[4],
 493                                                                      scontrols[5],
 494                                                                      scontrols[6],
 495                                                                      scontrols[7],
 496                                                                      SCM_UNDEFINED)),
 497                                               SCM_UNDEFINED)
 498                                      ),
 499                          SCM_UNDEFINED)
 500                 );
 501
 502
 503   a.str_ = "slur";
 504
 505   a.dim_[X_AXIS] = Interval (0, dx);
 506   a.dim_[Y_AXIS] = Interval (0 <? dy,  0 >? dy);
 507   a.font_ = font_;
 508   return a;
 509 }
 510
 511 Atom
 512 Lookup::vbracket (Real &y) const
 513 {
 514   Atom a;
 515   Real min_y = paper_l_->staffheight_f ();
 516   if (y < min_y)
 517     {
 518       warning (_ ("bracket")
 519                + " " + _ ("too small") +  " (" + print_dimen (y) + ")");
 520       //      y = min_y;
 521     }
 522   Array<Real> arr;
 523   arr.push (y);
 524   a.lambda_ =  (lambda_scm ("bracket", arr));
 525   a.str_ = "vbracket";
 526   a.dim_[Y_AXIS] = Interval (-y/2,y/2);
 527   a.dim_[X_AXIS] = Interval (0,4 PT);
 528   return a;
 529 }
 530
 531