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--1999 Han-Wen Nienhuys <hanwen@cs.uu.nl>
   7
   8   Jan Nieuwenhuizen <janneke@gnu.org>
   9
  10   TODO
  11       Glissando
  12 */
  13
  14 #include <ctype.h>
  15 #include "lookup.hh"
  16 #include "debug.hh"
  17 #include "dimensions.hh"
  18 #include "scalar.hh"
  19 #include "paper-def.hh"
  20 #include "string-convert.hh"
  21 #include "file-path.hh"
  22 #include "main.hh"
  23 #include "lily-guile.hh"
  24 #include "all-fonts.hh"
  25 #include "afm.hh"
  26 #include "scope.hh"
  27 #include "molecule.hh"
  28 #include "atom.hh"
  29 #include "lily-guile.hh"
  30
  31 SCM
  32 array_to_list (SCM *a , int l)
  33 {
  34   SCM list = SCM_EOL;
  35   for (int i= l; i--;  )
  36     {
  37       list =  gh_cons (a[i], list);
  38     }
  39   return list;
  40 }
  41
  42
  43 Lookup::Lookup ()
  44 {
  45   paper_l_ = 0;
  46   afm_l_ = 0;
  47 }
  48
  49 Lookup::Lookup (Lookup const& s)
  50 {
  51   font_name_ = s.font_name_;
  52   paper_l_ = 0;
  53   afm_l_ = 0;
  54 }
  55
  56
  57 Molecule
  58 Lookup::ledger_line (Interval xwid) const
  59 {
  60   Molecule end (afm_find ("noteheads-ledgerending"));
  61   Interval ed = end.dim_[X_AXIS];
  62   xwid = Interval (xwid[LEFT] - ed[LEFT],
  63                    xwid[RIGHT] - ed[RIGHT]);
  64   Molecule mid = filledbox (Box (xwid, end.dim_[Y_AXIS]));
  65   Molecule l (mid);
  66
  67   Molecule e2 = end;
  68   Molecule e1 = end;
  69   e1.translate_axis (xwid[RIGHT], X_AXIS);
  70   e2.translate_axis (xwid[LEFT], X_AXIS);
  71
  72   l.add_molecule (e1);
  73   l.add_molecule (e2);
  74   return l;
  75 }
  76
  77
  78 Molecule
  79 Lookup::accidental (int j, bool cautionary) const
  80 {
  81   Molecule m(afm_find (String ("accidentals-") + to_str (j)));
  82   if (cautionary)
  83     {
  84       Molecule open = afm_find (String ("accidentals-("));
  85       Molecule close = afm_find (String ("accidentals-)"));
  86       m.add_at_edge(X_AXIS, LEFT, Molecule(open), 0);
  87       m.add_at_edge(X_AXIS, RIGHT, Molecule(close), 0);
  88     }
  89   return m;
  90 }
  91
  92
  93
  94 Molecule
  95 Lookup::afm_find (String s, bool warn) const
  96 {
  97   if (!afm_l_)
  98     {
  99       Lookup * me =     (Lookup*)(this);
 100       me->afm_l_ = all_fonts_global_p->find_afm (font_name_);
 101       if (!me->afm_l_)
 102         {
 103           warning (_f("Can't open `%s'\n", font_name_));
 104           warning (_f("Search path %s\n", global_path.str ().ch_C()));
 105           error (_f("Aborting"));
 106         }
 107     }
 108   Adobe_font_char_metric cm = afm_l_->find_char (s, warn);
 109   Molecule m;
 110   if (cm.code () < 0)
 111     return m;
 112
 113   Atom at (gh_list (char_scm_sym,
 114                     gh_int2scm (cm.code ()),
 115                     SCM_UNDEFINED));
 116   at.font_ = ly_symbol (font_name_.ch_C());
 117   m.dim_ = cm.dimensions();
 118   m.add_atom (&at);
 119   return m;
 120 }
 121
 122 Molecule
 123 Lookup::notehead (int j, String type) const
 124 {
 125   if (j > 2)
 126     j = 2;
 127
 128   return afm_find (String ("noteheads-") + to_str (j) + type);
 129 }
 130
 131 Molecule
 132 Lookup::simple_bar (String type, Real h) const
 133 {
 134   SCM thick = ly_symbol ("barthick_" + type);
 135   Real w = 0.1 PT;
 136   if (paper_l_->scope_p_->elem_b (thick))
 137     {
 138       w = paper_l_->get_realvar (thick);
 139     }
 140
 141   return filledbox (Box (Interval(0,w), Interval(-h/2, h/2)));
 142 }
 143
 144
 145 Molecule
 146 Lookup::bar (String str, Real h) const
 147 {
 148   if (str == "[")
 149     return staff_bracket (h);
 150   else if (str == "{")
 151     return staff_brace (h);
 152
 153   Real kern = paper_l_->get_var ("bar_kern");
 154   Real thinkern = paper_l_->get_var ("bar_thinkern");
 155   Molecule thin = simple_bar ("thin", h);
 156   Molecule thick = simple_bar ("thick", h);
 157   Molecule colon = afm_find ("dots-repeatcolon");
 158
 159   Molecule m;
 160
 161   if (str == "")
 162     {
 163       return fill (Box (Interval(0, 0), Interval (-h/2, h/2)));
 164     }
 165   if (str == "scorepostbreak")
 166     {
 167       return simple_bar ("score", h);
 168     }
 169   else if (str == "|")
 170     {
 171       return thin;
 172     }
 173   else if (str == "|.")
 174     {
 175       m.add_at_edge (X_AXIS, LEFT, thick, 0);
 176       m.add_at_edge (X_AXIS, LEFT, thin, kern);
 177     }
 178   else if (str == ".|")
 179     {
 180       m.add_at_edge (X_AXIS, RIGHT, thick, 0);
 181       m.add_at_edge (X_AXIS, RIGHT, thin, kern);
 182     }
 183   else if (str == ":|")
 184     {
 185       m.add_at_edge (X_AXIS, LEFT, thick, 0);
 186       m.add_at_edge (X_AXIS, LEFT, thin, kern);
 187       m.add_at_edge (X_AXIS, LEFT, colon, kern);
 188     }
 189   else if (str == "|:")
 190     {
 191       m.add_at_edge (X_AXIS, RIGHT, thick, 0);
 192       m.add_at_edge (X_AXIS, RIGHT, thin, kern);
 193       m.add_at_edge (X_AXIS, RIGHT, colon, kern);
 194     }
 195   else if (str == ":|:")
 196     {
 197       m.add_at_edge (X_AXIS, LEFT, thick, thinkern);
 198       m.add_at_edge (X_AXIS, LEFT, colon, kern);
 199       m.add_at_edge (X_AXIS, RIGHT, thick, kern);
 200       m.add_at_edge (X_AXIS, RIGHT, colon, kern);
 201     }
 202   else if (str == ".|.")
 203     {
 204       m.add_at_edge (X_AXIS, LEFT, thick, thinkern);
 205       m.add_at_edge (X_AXIS, RIGHT, thick, kern);
 206     }
 207   else if (str == "||")
 208     {
 209       m.add_at_edge (X_AXIS, RIGHT, thin, 0);
 210       m.add_at_edge (X_AXIS, RIGHT, thin, thinkern);
 211     }
 212
 213   return m;
 214 }
 215
 216 Molecule
 217 Lookup::beam (Real slope, Real width, Real thick) const
 218 {
 219   Real height = slope * width;
 220   Real min_y = (0 <? height) - thick/2;
 221   Real max_y = (0 >? height) + thick/2;
 222
 223
 224   Molecule m;
 225   Atom at
 226      (gh_list (beam_scm_sym,
 227                                 gh_double2scm (width),
 228                                 gh_double2scm (slope),
 229                                 gh_double2scm (thick),
 230                                 SCM_UNDEFINED));
 231
 232   m.dim_[X_AXIS] = Interval (0, width);
 233   m.dim_[Y_AXIS] = Interval (min_y, max_y);
 234   m.add_atom (&at);
 235   return m;
 236 }
 237
 238 Molecule
 239 Lookup::clef (String st) const
 240 {
 241   return afm_find (String ("clefs-" + st));
 242 }
 243
 244 SCM
 245 offset2scm (Offset o)
 246 {
 247   return gh_list (gh_double2scm (o[X_AXIS]), gh_double2scm(o[Y_AXIS]),
 248                   SCM_UNDEFINED);
 249 }
 250
 251 Molecule
 252 Lookup::dashed_slur (Array<Offset> controls, Real thick, Real dash) const
 253 {
 254   assert (controls.size () == 8);
 255   Offset d = controls[3] - controls[0];
 256
 257   Real dx = d[X_AXIS];
 258   Real dy = d[Y_AXIS];
 259
 260   Molecule m;
 261
 262
 263   m.dim_[X_AXIS] = Interval (0, dx);
 264   m.dim_[Y_AXIS] = Interval (0 <? dy, 0 >? dy);
 265
 266   SCM sc[4];
 267   for (int i=0; i<  4; i++)
 268     {
 269       sc[i] =  offset2scm (controls[i]);
 270     }
 271
 272   Atom at
 273      (gh_list (ly_symbol ("dashed-slur"),
 274                                 gh_double2scm (thick),
 275                                 gh_double2scm (dash),
 276                                 ly_quote_scm (array_to_list (sc, 4)),
 277                                 SCM_UNDEFINED));
 278
 279
 280   m.add_atom (&at);
 281   return m;
 282 }
 283
 284 Molecule
 285 Lookup::dots () const
 286 {
 287   return afm_find (String ("dots-dot"));
 288 }
 289
 290
 291
 292 Molecule
 293 Lookup::fill (Box b) const
 294 {
 295   Molecule m;
 296   m.dim_ = b;
 297   return m;
 298 }
 299
 300 Molecule
 301 Lookup::flag (int j, Direction d) const
 302 {
 303   char c = (d == UP) ? 'u' : 'd';
 304   return  afm_find (String ("flags-") + to_str (c) + to_str (j));
 305 }
 306
 307 Molecule
 308 Lookup::rest (int j, bool o) const
 309 {
 310   return afm_find (String ("rests-") + to_str (j) + (o ? "o" : ""));
 311 }
 312
 313 Molecule
 314 Lookup::rule_symbol (Real height, Real width) const
 315 {
 316   Atom at  (gh_list (rulesym_scm_sym,
 317                                          gh_double2scm (height),
 318                                          gh_double2scm (width),
 319                                          SCM_UNDEFINED));
 320
 321   Molecule m;
 322   m.dim_.x () = Interval (0, width);
 323   m.dim_.y () = Interval (0, height);
 324
 325   m.add_atom (&at);
 326
 327   return m;
 328 }
 329
 330 Molecule
 331 Lookup::script (String str) const
 332 {
 333   return afm_find (String ("scripts-") + str);
 334 }
 335
 336 Molecule
 337 Lookup::special_time_signature (String s, int n, int d) const
 338 {
 339   // First guess: s contains only the signature style
 340   String symbolname = "timesig-" + s + to_str (n) + "/" + to_str (d);
 341
 342   Molecule m = afm_find (symbolname, false);
 343   if (!m.empty_b())
 344     return m;
 345
 346   // Second guess: s contains the full signature name
 347   m = afm_find ("timesig-"+s, false);
 348   if (!m.empty_b ())
 349     return m;
 350
 351   // Resort to default layout with numbers
 352   return time_signature (n,d);
 353 }
 354
 355 Molecule
 356 Lookup::filledbox (Box b ) const
 357 {
 358   Molecule m;
 359
 360   Atom at  (gh_list (filledbox_scm_sym,
 361                                          gh_double2scm (-b[X_AXIS][LEFT]),
 362                                          gh_double2scm (b[X_AXIS][RIGHT]),
 363                                          gh_double2scm (-b[Y_AXIS][DOWN]),
 364                                          gh_double2scm (b[Y_AXIS][UP]),
 365                                          SCM_UNDEFINED));
 366
 367   m.dim_ = b;
 368   m.add_atom (&at);
 369   return m;
 370 }
 371
 372 Molecule
 373 Lookup::stem (Real y1, Real y2) const
 374 {
 375   if (y1 > y2)
 376     {
 377       Real t = y1;
 378       y1 = y2;
 379       y2 = t;
 380     }
 381   Real stem_width = paper_l_->get_var ("stemthickness");
 382   return filledbox (Box (Interval (-stem_width/2,stem_width/2),
 383                          Interval (y1, y2)));
 384 }
 385
 386
 387
 388 /**
 389    Magnification steps.  These are powers of 1.2. The numbers are
 390  taken from Knuth's plain.tex: */
 391 static Real mag_steps[] = {1, 1, 1.200, 1.440, 1.7280,  2.074, 2.488};
 392
 393
 394
 395 Molecule
 396 Lookup::text (String style, String text) const
 397 {
 398   Molecule m;
 399
 400   int font_mag = 1;
 401   Real font_h = paper_l_->get_var ("font_normal");
 402   if (paper_l_->scope_p_->elem_b ("font_" + style))
 403     {
 404       font_h = paper_l_->get_var ("font_" + style);
 405     }
 406
 407   if (paper_l_->scope_p_->elem_b ("magnification_" + style))
 408     {
 409       font_mag = (int)paper_l_->get_var ("magnification_" + style);
 410     }
 411
 412   SCM l = gh_eval_str (("(style-to-cmr \"" + style + "\")").ch_C());
 413   if (l != SCM_BOOL_F)
 414     {
 415       style = ly_scm2string (SCM_CDR(l)) +to_str  ((int)font_h);
 416     }
 417
 418   Real w = 0;
 419   Interval ydims (0,0);
 420
 421   Font_metric* afm_l = all_fonts_global_p->find_font (style);
 422   DOUT << "\nChars: ";
 423
 424   for (int i = 0; i < text.length_i (); i++)
 425     {
 426       if (text[i]=='\\')
 427         for (i++; (i < text.length_i ()) && isalpha(text[i]); i++)
 428           ;
 429       else
 430         {
 431           Character_metric *c = afm_l->get_char ((unsigned char)text[i],false);
 432
 433           w += c->dimensions()[X_AXIS].length ();
 434           ydims.unite (c->dimensions()[Y_AXIS]);
 435         }
 436     }
 437
 438   if (font_mag > 1 && font_mag < 7 )
 439     {
 440       /* UGH  */
 441       style = style + String(" scaled \\magstep ") + to_str (font_mag);
 442       w *= mag_steps[font_mag];
 443       ydims *= mag_steps[font_mag];
 444     }
 445
 446   DOUT << "\n" << to_str (w) << "\n";
 447   m.dim_.x () = Interval (0, w);
 448   m.dim_.y () = ydims;
 449
 450
 451   Atom at  (gh_list (text_scm_sym,
 452                      gh_str02scm (text.ch_C()),
 453                      SCM_UNDEFINED));
 454   at.font_ = ly_symbol (style);
 455
 456   m.add_atom (&at);
 457   return m;
 458 }
 459
 460
 461 /*
 462  */
 463 Molecule
 464 Lookup::time_signature (int num, int den) const
 465 {
 466   String sty = "number";
 467   Molecule n (text (sty, to_str (num)));
 468   Molecule d (text (sty, to_str (den)));
 469   n.do_center (X_AXIS);
 470   d.do_center (X_AXIS);
 471   Molecule m;
 472   if (den)
 473     {
 474       m.add_at_edge (Y_AXIS, UP, n, 0.0);
 475       m.add_at_edge (Y_AXIS, DOWN, d, 0.0);
 476     }
 477   else
 478     {
 479       m = n;
 480       m.do_center (Y_AXIS);
 481     }
 482   return m;
 483 }
 484
 485 Molecule
 486 Lookup::staff_brace (Real y) const
 487 {
 488   Molecule m;
 489
 490   Atom at  (gh_list (pianobrace_scm_sym,
 491                        gh_double2scm (y),
 492                        SCM_UNDEFINED
 493                        ));
 494
 495   m.dim_[Y_AXIS] = Interval (-y/2,y/2);
 496   m.dim_[X_AXIS] = Interval (0,0);
 497   m.add_atom (&at);
 498   return m;
 499 }
 500
 501 Molecule
 502 Lookup::hairpin (Real width, bool decresc, bool continued) const
 503 {
 504   Molecule m;
 505   Real height = paper_l_->staffheight_f () / 6;
 506
 507   String hairpin = String (decresc ? "de" : "") + "crescendo";
 508   Atom at  (gh_list (ly_symbol (hairpin),
 509                        gh_double2scm (width),
 510                        gh_double2scm (height),
 511                        gh_double2scm (continued ? height/2 : 0.0),
 512                        SCM_UNDEFINED));
 513   m.dim_.x () = Interval (0, width);
 514   m.dim_.y () = Interval (-2*height, 2*height);
 515
 516   m.add_atom (&at);
 517   return m;
 518 }
 519
 520 Molecule
 521 Lookup::plet (Real dy , Real dx, Direction dir) const
 522 {
 523   Molecule m;
 524   SCM thick = tuplet_thick_scm_sym;
 525   Real t = 0.1 PT;
 526   if (paper_l_->scope_p_->elem_b (thick))
 527     {
 528       t = paper_l_->get_realvar (thick);
 529     }
 530
 531   Atom at  (gh_list(tuplet_scm_sym,
 532                       gh_double2scm (dx),
 533                       gh_double2scm (dy),
 534                       gh_double2scm (t),
 535                       gh_int2scm (dir),
 536                       SCM_UNDEFINED));
 537 m.add_atom (&at);
 538
 539   return m;
 540 }
 541
 542 /*
 543   Make a smooth curve along the points
 544  */
 545 Molecule
 546 Lookup::slur (Array<Offset> controls) const
 547 {
 548   Offset  delta_off = controls[3]- controls[0];
 549   Molecule m;
 550
 551   SCM scontrols [8];
 552   int indices[] = {5,6,7,4,1,2,3,0};
 553
 554   for (int i= 0; i < 8; i++)
 555     scontrols[i] = offset2scm (controls[indices[i]]);
 556
 557
 558   Atom at  (gh_list (ly_symbol ("bezier-sandwich"),
 559                       ly_quote_scm (array_to_list (scontrols, 8)),
 560                       SCM_UNDEFINED));
 561
 562   m.dim_[X_AXIS] = Interval (0, delta_off[X_AXIS]);
 563   m.dim_[Y_AXIS] = Interval (0 <? delta_off[Y_AXIS], 0 >? delta_off[Y_AXIS]);
 564   m.add_atom (&at);
 565   return m;
 566 }
 567
 568 Molecule
 569 Lookup::staff_bracket (Real y) const
 570 {
 571   Molecule m;
 572   Atom at  ( gh_list (bracket_scm_sym,
 573                         gh_double2scm (y),
 574                         SCM_UNDEFINED));
 575   m.add_atom (&at);
 576   m.dim_[Y_AXIS] = Interval (-y/2,y/2);
 577   m.dim_[X_AXIS] = Interval (0,4 PT);
 578
 579   m.translate_axis (- 4. / 3. * m.dim_[X_AXIS].length (), X_AXIS);
 580   return m;
 581 }
 582
 583 Molecule
 584 Lookup::volta (Real w, bool last_b) const
 585 {
 586   Molecule m;
 587   SCM thick = volta_thick_scm_sym;
 588   Real t = 0.1 PT;
 589   if (paper_l_->scope_p_->elem_b (thick))
 590     {
 591       t = paper_l_->get_realvar (thick);
 592     }
 593   Atom at  (gh_list (volta_scm_sym,
 594                        gh_double2scm (w),
 595                        gh_double2scm (t),
 596                        gh_int2scm (last_b),
 597                        SCM_UNDEFINED));
 598
 599   Real interline_f = paper_l_->get_realvar (interline_scm_sym);
 600
 601   m.dim_[Y_AXIS] = Interval (-interline_f, interline_f);
 602   m.dim_[X_AXIS] = Interval (0, w);
 603
 604   m.add_atom (&at);
 605   return m;
 606 }
 607
 608