mf/feta-noteheads.mf

   1 % Feta (not the Font-En-Tja) music font -- implement noteheads
   2 % This file is part of LilyPond, the GNU music typesetter.
   3 %
   4 % Copyright (C) 1997--2012 Jan Nieuwenhuizen <janneke@gnu.org>
   5 % & Han-Wen Nienhuys <hanwen@xs4all.nl>
   6 % & Juergen Reuter <reuter@ipd.uka.de>
   7 %
   8 % The LilyPond font is free software: you can redistribute it and/or modify
   9 % it under the terms of the GNU General Public License as published by
  10 % the Free Software Foundation, either version 3 of the License, or
  11 % (at your option) any later version, or under the SIL Open Font License.
  12 %
  13 % LilyPond is distributed in the hope that it will be useful,
  14 % but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 % MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 % GNU General Public License for more details.
  17 %
  18 % You should have received a copy of the GNU General Public License
  19 % along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
  20
  21 test_outlines := 0;
  22
  23
  24 save remember_pic;
  25 picture remember_pic;
  26
  27
  28 % Most beautiful noteheads are pronounced, not circular,
  29 % and not even symmetric.
  30 % These examples are inspired by [Wanske]; see literature list.
  31
  32
  33
  34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  35 % NOTE HEAD VARIABLES
  36 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  37
  38 save half_notehead_width, whole_notehead_width;
  39 save solfa_noteheight;
  40
  41 numeric whole_notehead_width;
  42 numeric half_notehead_width;
  43
  44 fet_begingroup ("noteheads");
  45
  46
  47 %
  48 % solfa heads should not overlap on chords.
  49 %
  50 solfa_noteheight# := staff_space# - stafflinethickness#;
  51
  52 def undraw_inside_ellipse (expr ellipticity, tilt, superness, clearance) =
  53 begingroup
  54         save pat;
  55         path pat;
  56
  57         pat := superellipse ((ellipticity, 0), (0, 1.0),
  58                              (-ellipticity, 0), (0, -1.0),
  59                              superness);
  60         pat := pat rotated tilt;
  61
  62         save top_point, right_point;
  63         pair top_point, right_point;
  64
  65         top_point := directionpoint left of pat;
  66         right_point := directionpoint up of pat;
  67
  68         save height, scaling;
  69
  70         height# = staff_space# + stafflinethickness# - clearance;
  71         scaling# = height# / (2 ypart (top_point));
  72         define_pixels (scaling);
  73         pat := pat scaled scaling shifted (w / 2, .5 (h - d));
  74
  75         if test_outlines = 1:
  76                 draw pat;
  77         else:
  78                 unfill pat;
  79         fi
  80 endgroup;
  81 enddef;
  82
  83
  84 def draw_longa (expr up) =
  85         save stemthick, fudge;
  86
  87         stemthick# = 2 stafflinethickness#;
  88         define_whole_blacker_pixels (stemthick);
  89
  90         % Longas of smaller design sizes should have their lines farther
  91         % apart (the overlap with notehead ellipsoid should be smaller).
  92         fudge = hround (blot_diameter
  93                         * min (max (-0.15,
  94                                     (0.9
  95                                      - (20 / (design_size + 4)))),
  96                                0.3));
  97
  98         draw_outside_ellipse (1.80, 0, 0.707, 0);
  99         undraw_inside_ellipse (1.30, 125, 0.68, 2 stafflinethickness#);
 100
 101         set_char_box (stemthick#,
 102                       width# + stemthick#,
 103                       noteheight# / 2,
 104                       noteheight# / 2);
 105
 106         pickup pencircle scaled stemthick;
 107
 108         % Longas of smaller design sizes should have their lines longer.
 109         line_length := min (max (0.7, (64/60 - (design_size / 60))), 0.85);
 110
 111         % Line lengths between 0.72 and 0.77 are not nice
 112         % because they are neither separate nor connected
 113         % when there is an interval of fourth.
 114         if line_length < 0.75:
 115                 quanted_line_length := min (0.72, line_length);
 116         else:
 117                 quanted_line_length := max (0.77, line_length);
 118         fi;
 119
 120         final_line_length := quanted_line_length * staff_space;
 121
 122         if up:
 123                 bot y1 = -final_line_length;
 124                 top y2 = final_line_length;
 125                 rt x1 - fudge = 0;
 126                 x1 = x2;
 127
 128                 fudge + lft x3 = width;
 129                 x4 = x3;
 130                 top y4 = h + 3.0 staff_space;
 131                 y3 = y1;
 132         else:
 133                 bot y1 = -d - 3.0 staff_space;
 134                 top y2 = final_line_length;
 135                 rt x1 - fudge = 0;
 136                 x1 = x2;
 137
 138                 fudge + lft x3 = width;
 139                 x4 = x3;
 140                 y4 = y2;
 141                 bot y3 = -final_line_length;
 142         fi;
 143
 144         draw_gridline (z1, z2, stemthick);
 145         draw_gridline (z3, z4, stemthick);
 146
 147         labels (1, 2, 3, 4);
 148 enddef;
 149
 150
 151 fet_beginchar ("Longa notehead", "uM2");
 152         draw_longa (true);
 153
 154         draw_staff (-2, 2, 0);
 155 fet_endchar;
 156
 157
 158 fet_beginchar ("Longa notehead", "dM2");
 159         draw_longa (false);
 160
 161         draw_staff (-2, 2, 0);
 162 fet_endchar;
 163
 164
 165 if test > 0:
 166         fet_beginchar ("Longa notehead", "uM2");
 167                 draw_longa (true);
 168
 169                 draw_staff (-2, 2, 0.5);
 170         fet_endchar;
 171
 172
 173         fet_beginchar ("Longa notehead", "dM2");
 174                 draw_longa (false);
 175
 176                 draw_staff (-2, 2, 0.5);
 177         fet_endchar;
 178 fi;
 179
 180
 181 def draw_brevis (expr linecount, line_thickness_multiplier) =
 182         save stemthick, fudge, gap;
 183
 184         stemthick# = line_thickness_multiplier * 2 * stafflinethickness#;
 185         define_whole_blacker_pixels (stemthick);
 186
 187         % double-lined breves of smaller design sizes should have
 188         % bigger gap between the lines.
 189         gap# := (0.95 - 0.008 * design_size) * stemthick#;
 190
 191         % Breves of smaller design sizes should have their lines farther
 192         % apart (the overlap with notehead ellipsoid should be smaller).
 193         fudge = hround (blot_diameter
 194                         * min (max (-0.15,
 195                                     (0.8
 196                                      - (20 / (design_size + 4))
 197                                      + .1 linecount)),
 198                                0.3));
 199
 200         draw_outside_ellipse (1.80, 0, 0.707, 0);
 201         undraw_inside_ellipse (1.30, 125, 0.68, 2 stafflinethickness#);
 202
 203         set_char_box (stemthick# * linecount + gap# * (linecount - 1),
 204                       width# + stemthick# * linecount + gap# * (linecount - 1),
 205                       noteheight# / 2,
 206                       noteheight# / 2);
 207
 208         define_pixels (gap);
 209         pickup pencircle scaled stemthick;
 210
 211         % Breves of smaller design sizes should have their lines longer.
 212         line_length := min (max (0.7, (64/60 - (design_size / 60))), 0.85);
 213
 214         % Line lengths between 0.72 and 0.77 are not nice
 215         % because they are neither separate nor connected
 216         % when there is an interval of fourth.
 217         if line_length < 0.75:
 218                 quanted_line_length := min (0.72, line_length);
 219         else:
 220                 quanted_line_length := max (0.77, line_length);
 221         fi;
 222
 223         bot y1 = -quanted_line_length * staff_space;
 224         top y2 = quanted_line_length * staff_space;
 225         rt x1 - fudge = 0;
 226         x1 = x2;
 227
 228         fudge + lft x3 = width;
 229         x4 = x3;
 230         y4 = y2;
 231         y3 = y1;
 232
 233         for i := 0 step 1 until linecount - 1:
 234                 line_distance := i * (gap + stemthick);
 235                 draw_gridline (z1 - (line_distance, 0),
 236                                z2 - (line_distance, 0),
 237                                stemthick);
 238                 draw_gridline (z3 + (line_distance, 0),
 239                                z4 + (line_distance, 0),
 240                                stemthick);
 241         endfor;
 242 enddef;
 243
 244
 245 fet_beginchar ("Brevis notehead", "sM1");
 246         draw_brevis (1, 1);
 247
 248         draw_staff (-2, 2, 0);
 249 fet_endchar;
 250
 251
 252 if test > 0:
 253         fet_beginchar ("Brevis notehead", "sM1");
 254                 draw_brevis(1, 1);
 255
 256                 draw_staff (-2, 2, 0.5);
 257         fet_endchar;
 258 fi;
 259
 260
 261 fet_beginchar ("Double-lined brevis notehead", "sM1double");
 262         draw_brevis (2, 0.8);
 263
 264         draw_staff (-2, 2, 0);
 265 fet_endchar;
 266
 267
 268 if test > 0:
 269         fet_beginchar ("Double-lined brevis notehead", "sM1double");
 270                 draw_brevis (2, 0.8);
 271
 272                 draw_staff (-2, 2, 0.5);
 273         fet_endchar;
 274 fi;
 275
 276
 277 fet_beginchar ("Whole notehead", "s0");
 278         draw_outside_ellipse (1.80 - puff_up_factor / 3.0, 0, 0.707, 0);
 279         undraw_inside_ellipse (1.30, 125 - puff_up_factor * 10,
 280                                0.68, 2 stafflinethickness#);
 281
 282         whole_notehead_width# := charwd;
 283
 284         draw_staff (-2, 2, 0);
 285 fet_endchar;
 286
 287
 288 if test > 0:
 289         fet_beginchar ("Whole notehead", "s0");
 290                 draw_outside_ellipse (1.80 - puff_up_factor / 3.0, 0,
 291                                       0.707, 0);
 292                 undraw_inside_ellipse (1.30, 125 - puff_up_factor * 10,
 293                                        0.68, 2 stafflinethickness#);
 294
 295                 draw_staff (-2, 2, 0.5);
 296         fet_endchar;
 297 fi;
 298
 299
 300 fet_beginchar ("Half notehead", "s1");
 301         draw_outside_ellipse (1.53 - puff_up_factor / 3.0, 34, 0.66, 0.17);
 302         undraw_inside_ellipse (3.25, 33, 0.81, 2.5 stafflinethickness#);
 303
 304         half_notehead_width# := charwd;
 305
 306         draw_staff (-2, 2, 0);
 307 fet_endchar;
 308
 309
 310 if test > 0:
 311         fet_beginchar ("Half notehead", "s1");
 312                 draw_outside_ellipse (1.53 - puff_up_factor / 3.0, 34,
 313                                       0.66, 0.17);
 314                 undraw_inside_ellipse (3.25, 33, 0.81,
 315                                        2.5 stafflinethickness#);
 316
 317                 draw_staff (-2, 2, 0.5);
 318         fet_endchar;
 319 fi;
 320
 321
 322 fet_beginchar ("Quarter notehead", "s2");
 323         draw_quarter_path;
 324         draw_staff (-2, 2, 0);
 325 fet_endchar;
 326
 327
 328 if test > 0:
 329         fet_beginchar ("Quarter notehead", "s2");
 330                 draw_outside_ellipse (1.49 - puff_up_factor / 3.0, 31,
 331                                       0.707, 0);
 332
 333                 draw_staff (-2, 2, 0.5);
 334         fet_endchar;
 335 fi;
 336
 337
 338 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 339
 340
 341 fet_beginchar ("Whole diamondhead", "s0diamond");
 342         draw_outside_ellipse (1.80, 0, 0.495, 0);
 343         undraw_inside_ellipse (1.30, 125, 0.6,
 344                                .4 staff_space# + stafflinethickness#);
 345
 346         draw_staff (-2, 2, 0);
 347 fet_endchar;
 348
 349
 350 if test > 0:
 351         fet_beginchar ("Whole diamondhead", "s0diamond");
 352                 draw_outside_ellipse (1.80, 0, 0.495, 0);
 353                 undraw_inside_ellipse (1.30, 125, 0.6,
 354                                        .4 staff_space# + stafflinethickness#);
 355
 356                 draw_staff (-2, 2, 0.5);
 357         fet_endchar;
 358 fi;
 359
 360
 361 fet_beginchar ("Half diamondhead", "s1diamond");
 362         draw_outside_ellipse (1.50, 34, 0.49, 0.17);
 363         undraw_inside_ellipse (3.5, 33, 0.80,
 364                                .3 staff_space# + 1.5 stafflinethickness#);
 365
 366         draw_staff (-2, 2, 0);
 367 fet_endchar;
 368
 369
 370 if test > 0:
 371         fet_beginchar ("Half diamondhead", "s1diamond");
 372                 draw_outside_ellipse (1.50, 34, 0.49, 0.17);
 373                 undraw_inside_ellipse (3.5, 33, 0.80,
 374                                        .3 staff_space#
 375                                        + 1.5 stafflinethickness#);
 376
 377                 draw_staff (-2, 2, 0.5);
 378         fet_endchar;
 379 fi;
 380
 381
 382 fet_beginchar ("Quarter diamondhead", "s2diamond");
 383         draw_outside_ellipse (1.80, 35, 0.495, -0.25);
 384
 385         draw_staff (-2, 2, 0);
 386 fet_endchar;
 387
 388
 389 if test > 0:
 390         fet_beginchar ("Quarter diamondhead", "s2diamond");
 391                 draw_outside_ellipse (1.80, 35, 0.495, -0.25);
 392
 393                 draw_staff (-2, 2, 0.5);
 394         fet_endchar;
 395 fi;
 396
 397
 398 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 399
 400
 401 vardef penposx@# (expr d) =
 402 begingroup;
 403         save pat;
 404         path pat;
 405
 406         pat = top z@#
 407               .. lft z@#
 408               .. bot z@#
 409               .. rt z@#
 410               .. cycle;
 411         z@#l = pat intersectionpoint (z@# -- infinity * dir (d + 180));
 412         z@#r = pat intersectionpoint (z@# -- infinity * dir (d));
 413 endgroup
 414 enddef;
 415
 416
 417 %
 418 % UGH: xs not declared as argument.
 419 %
 420 def define_triangle_shape (expr stemdir) =
 421         save triangle_a, triangle_b, triangle_c;
 422         save triangle_out_a, triangle_out_b, triangle_out_c;
 423         save triangle_in, triangle_out;
 424         save width, depth, height;
 425         save origin, left_up_dir;
 426         save exact_left_point, exact_right_point, exact_down_point;
 427
 428         path triangle_a, triangle_b, triangle_c;
 429         path triangle_out_a, triangle_out_b, triangle_out_c;
 430         path triangle_in, triangle_out;
 431         pair origin, left_up_dir;
 432         pair exact_down_point, exact_left_point, exact_right_point;
 433
 434         save pen_thick;
 435         pen_thick# = stafflinethickness# + .1 staff_space#;
 436         define_pixels (llap);
 437         define_blacker_pixels (pen_thick);
 438
 439         left_up_dir = llap# * dir (90 + tilt);
 440
 441         xpart (left_up_dir) * xs - (pen_thick# * xs) / 2 + xpart origin = 0;
 442         ypart origin = 0;
 443
 444         exact_left_point := origin + (left_up_dir xscaled xs);
 445         exact_down_point := origin + (left_up_dir rotated 120 xscaled xs);
 446         exact_right_point := origin + (left_up_dir rotated 240 xscaled xs);
 447
 448         height# = ypart (exact_left_point + origin) + pen_thick# / 2;
 449         depth# = -ypart (exact_down_point + origin) + pen_thick# / 2;
 450         width# = xpart (exact_right_point - exact_left_point)
 451                  + pen_thick# * xs;
 452
 453         set_char_box (0, width#, depth#, height#);
 454
 455         % Formerly, the shape has simply been drawn with an elliptical pen
 456         % (`scaled pen_thick xscaled xs'), but the envelope of such a curve
 457         % is of 6th degree.  For the sake of mf2pt1, we approximate it.
 458
 459         pickup pencircle scaled pen_thick xscaled xs;
 460
 461         z0 = (hround_pixels (xpart origin), 0);
 462
 463         z1 = z1' = z0 + llap * dir (90 + tilt) xscaled xs;
 464         z2 = z2' = z0 + llap * dir (90 + tilt + 120) xscaled xs;
 465         z3 = z3' = z0 + llap * dir (90 + tilt + 240) xscaled xs;
 466
 467         z12 = caveness [.5[z1, z2], z3];
 468         z23 = caveness [.5[z2, z3], z1];
 469         z31 = caveness [.5[z3, z1], z2];
 470
 471         triangle_a = z1 .. z12 .. z2;
 472         triangle_b = z2 .. z23 .. z3;
 473         triangle_c = z3 .. z31 .. z1;
 474
 475         penposx1 (angle (direction 0 of triangle_a) - 90);
 476         penposx2 (angle (direction 0 of triangle_b) - 90);
 477         penposx3 (angle (direction 0 of triangle_c) - 90);
 478
 479         penposx1' (angle (direction infinity of triangle_c) + 90);
 480         penposx2' (angle (direction infinity of triangle_a) + 90);
 481         penposx3' (angle (direction infinity of triangle_b) + 90);
 482
 483         penposx12 (angle (z12 - z0));
 484         penposx23 (angle (z23 - z0));
 485         penposx31 (angle (z31 - z0));
 486
 487         z10 = (z0 -- z1) intersectionpoint (z1l .. z12l .. z2'r);
 488         z20 = (z0 -- z2) intersectionpoint (z2l .. z23l .. z3'r);
 489         z30 = (z0 -- z3) intersectionpoint (z3l .. z31l .. z1'r);
 490
 491         triangle_in = z10
 492                       .. z12l
 493                       .. z20
 494                       & z20
 495                       .. z23l
 496                       .. z30
 497                       & z30
 498                       .. z31l
 499                       .. z10
 500                       & cycle;
 501
 502         triangle_out_a = z1r .. z12r .. z2'l;
 503         triangle_out_b = z2r .. z23r .. z3'l;
 504         triangle_out_c = z3r .. z31r .. z1'l;
 505
 506         triangle_out = top z1
 507                        .. lft z1
 508                        .. z1r{direction 0 of triangle_out_a}
 509                        & triangle_out_a
 510                        & {direction infinity of triangle_out_a}z2'l
 511                        .. lft z2
 512                        .. bot z2
 513                        .. z2r{direction 0 of triangle_out_b}
 514                        & triangle_out_b
 515                        & {direction infinity of triangle_out_b}z3'l
 516                        .. rt z3
 517                        .. top z3
 518                        .. z3r{direction 0 of triangle_out_c}
 519                        & triangle_out_c
 520                        & {direction infinity of triangle_out_c}z1'l
 521                        .. cycle;
 522
 523         labels (0, 10, 20, 30);
 524         penlabels (1, 1', 2, 2', 3, 3', 12, 23, 31);
 525
 526         % attachment Y
 527         if stemdir = 1:
 528                 charwy := ypart exact_right_point;
 529                 charwx := xpart exact_right_point + .5 pen_thick# * xs;
 530         else:
 531                 charwy := -ypart exact_down_point;
 532                 charwx := width# - (xpart exact_down_point - .5 pen_thick# * xs);
 533         fi
 534 enddef;
 535
 536
 537 def draw_whole_triangle_head =
 538         save hei, xs;
 539         save llap;
 540         save tilt;
 541
 542         tilt = 40;
 543         llap# = 3/4 noteheight#;
 544
 545         xs = 1.5;
 546         caveness := 0.1;
 547         define_triangle_shape (1);
 548         fill triangle_out;
 549         unfill triangle_in;
 550 enddef;
 551
 552
 553 fet_beginchar ("Whole trianglehead", "s0triangle");
 554         draw_whole_triangle_head;
 555
 556         draw_staff (-2, 2, 0);
 557 fet_endchar;
 558
 559
 560 if test > 0:
 561         fet_beginchar ("Whole trianglehead", "s0triangle");
 562                 draw_whole_triangle_head;
 563
 564                 draw_staff (-2, 2, 0.5);
 565         fet_endchar;
 566 fi;
 567
 568
 569 def draw_small_triangle_head (expr dir) =
 570         save hei, xs;
 571         save llap;
 572         save tilt;
 573
 574         tilt = 40;
 575         llap# = 2/3 noteheight#;
 576         xs = 1.2;
 577         caveness := 0.1;
 578         define_triangle_shape (dir);
 579
 580         pickup feta_fillpen;
 581
 582         filldraw triangle_out;
 583         unfilldraw triangle_in;
 584 enddef;
 585
 586
 587 fet_beginchar ("Half trianglehead (downstem)", "d1triangle");
 588         draw_small_triangle_head (-1);
 589
 590         draw_staff (-2, 2, 0);
 591 fet_endchar;
 592
 593
 594 fet_beginchar ("Half trianglehead (upstem)", "u1triangle");
 595         draw_small_triangle_head (1);
 596
 597         draw_staff (-2, 2, 0.5);
 598 fet_endchar;
 599
 600
 601 def draw_closed_triangle_head (expr dir) =
 602         save hei, xs;
 603         save llap;
 604         save tilt;
 605
 606         tilt = 40;
 607         llap# = 2/3 noteheight#;
 608         xs = 1.0;
 609         caveness := 0.1;
 610         define_triangle_shape (dir);
 611         fill triangle_out;
 612 enddef;
 613
 614
 615 fet_beginchar ("Quarter trianglehead (upstem)", "u2triangle");
 616         draw_closed_triangle_head (1);
 617
 618         draw_staff (-2, 2, 0);
 619 fet_endchar;
 620
 621
 622 fet_beginchar ("Quarter trianglehead (downstem)", "d2triangle");
 623         draw_closed_triangle_head (-1);
 624
 625         draw_staff (-2, 2, 0.5);
 626 fet_endchar;
 627
 628
 629 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 630 %
 631 % Slash heads are for indicating improvisation.  They are
 632 % twice as high as normal heads.
 633 %
 634 def draw_slash (expr hwid_hash) =
 635         save exact_height;
 636         save ne, nw_dist;
 637         pair ne, nw_dist;
 638         exact_height = staff_space# + stafflinethickness# / 2;
 639
 640         set_char_box (0, 2 exact_height / slash_slope + hwid_hash,
 641                       exact_height, exact_height);
 642
 643         charwx := charwd;
 644         charwy := charht;
 645
 646         clearxy;
 647
 648         d := d - feta_shift;
 649
 650         pickup pencircle scaled blot_diameter;
 651
 652         bot y1 = -d;
 653         top y2 = h;
 654         lft x1 = 0;
 655         lft x2 = 2 h / slash_slope;
 656
 657         rt x3 = w;
 658         y3 = y2;
 659         y4 = y1;
 660         x3 - x2 = x4 - x1;
 661
 662         ne = unitvector (z3 - z4);
 663         nw_dist = (ne rotated 90) * 0.5 blot_diameter;
 664
 665         fill bot z1{left}
 666              .. (z1 + nw_dist){ne}
 667              -- (z2 + nw_dist){ne}
 668              .. top z2{right}
 669              -- top z3{right}
 670              .. (z3 - nw_dist){-ne}
 671              -- (z4 - nw_dist){-ne}
 672              .. bot z4{left}
 673              -- cycle;
 674
 675         if hwid_hash > 2 slash_thick#:
 676                 save th;
 677
 678                 th = slash_thick - blot_diameter;
 679                 y6 = y7;
 680                 y5 = y8;
 681                 y3 - y7 = th;
 682                 y5 - y1 = th;
 683                 z6 - z5 = whatever * ne;
 684                 z8 - z7 = whatever * ne;
 685
 686                 z5 = z1 + whatever * ne + th * (ne rotated -90);
 687                 z8 = z4 + whatever * ne + th * (ne rotated 90);
 688
 689                 unfill z5
 690                        -- z6
 691                        -- z7
 692                        -- z8
 693                        -- cycle;
 694         fi
 695         labels (range 1 thru 10);
 696 enddef;
 697
 698
 699 fet_beginchar ("Whole slashhead", "s0slash");
 700         draw_slash (4 slash_thick# + 0.5 staff_space#);
 701
 702         draw_staff (-2, 2, 0);
 703 fet_endchar;
 704
 705
 706 fet_beginchar ("Half slashhead", "s1slash");
 707         draw_slash (3.0 slash_thick# + 0.15 staff_space#);
 708
 709         draw_staff (-2, 2, 0);
 710 fet_endchar;
 711
 712
 713 fet_beginchar ("Quarter slashhead", "s2slash");
 714         draw_slash (1.5 slash_thick#);
 715
 716         draw_staff (-2, 2, 0);
 717 fet_endchar;
 718
 719
 720 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 721 %
 722 % `thick' is the distance between the NE/SW parallel lines in the cross
 723 % (distance between centres of lines) in multiples of stafflinethickness
 724 %
 725 def draw_cross (expr thick) =
 726         save ne, nw;
 727         save ne_dist, nw_dist, rt_dist, up_dist;
 728         save crz_in, crz_out;
 729         save thickness;
 730         pair ne, nw;
 731         pair ne_dist, nw_dist, rt_dist, up_dist;
 732         path crz_in, crz_out;
 733
 734         pen_thick# := 1.2 stafflinethickness#;
 735         thickness# := thick * stafflinethickness#;
 736         define_pixels (thickness);
 737         define_blacker_pixels (pen_thick);
 738
 739         pickup pencircle scaled pen_thick;
 740
 741         h := h - feta_shift;
 742
 743         top y3 = h;
 744         ne = unitvector ((1, (2 h - pen_thick) / (w - pen_thick)));
 745         rt x4 = w / 2;
 746         y5 = 0;
 747         z4 - z5 = whatever * ne;
 748         x6 = 0;
 749         z6 - z3 = whatever * ne;
 750         z3 - z4 = whatever * (ne yscaled -1);
 751
 752         z4 - z3 = whatever * (ne) + (ne rotated -90) * thickness;
 753
 754
 755         x1 = charwd / 2 - .5 pen_thick#;
 756         z1 = whatever * ne
 757              + thick / 2 * stafflinethickness# * (ne rotated -90);
 758
 759         % labels (1, 2, 3, 4, 5, 6);
 760
 761         nw = unitvector (z3 - z4);
 762
 763         up_dist = up * 0.5 pen_thick / cosd (angle (ne));
 764         rt_dist = right * 0.5 pen_thick / sind (angle (ne));
 765         nw_dist = (ne rotated 90) * 0.5 pen_thick;
 766         ne_dist = (nw rotated -90) * 0.5 pen_thick;
 767
 768         x4' := x4;
 769         x5' := x5;
 770         y6' := y6;
 771
 772         x4 := hround (x4' + .5 pen_thick) - .5 pen_thick;
 773         x5 := hfloor (x5' + xpart rt_dist) - xpart rt_dist;
 774         y6 := vfloor (y6' + ypart up_dist) - ypart up_dist;
 775
 776         crz_out = (z6 + up_dist)
 777                   -- (z3 + nw_dist){ne}
 778                   .. (top z3)
 779                   .. (z3 + ne_dist){-nw}
 780                   -- (z4 + ne_dist){-nw}
 781                   .. (rt z4)
 782                   .. (z4 - nw_dist){-ne}
 783                   -- (z5 + rt_dist);
 784         crz_out := crz_out shifted (0, feta_shift)
 785                    -- reverse crz_out yscaled -1 shifted (0, -feta_eps);
 786         fill crz_out
 787              -- reverse crz_out xscaled -1 shifted (-feta_eps, 0)
 788              -- cycle;
 789
 790         if (thick > 1):
 791                 x4 := hround (x4' - xpart rt_dist) + xpart rt_dist;
 792                 x5 := hceiling (x5' - .5 pen_thick) + .5 pen_thick;
 793                 y6 := vfloor (y6' - .5 pen_thick) + .5 pen_thick;
 794
 795                 crz_in = (bot z6){right}
 796                          .. (z6 - nw_dist){ne}
 797                          -- (z3 - up_dist)
 798                          -- (z4 - rt_dist)
 799                          -- (z5 + nw_dist){-ne}
 800                          .. {down}(lft z5);
 801                 crz_in := crz_in shifted (0, feta_shift)
 802                           -- reverse crz_in yscaled -1 shifted (0, -feta_eps);
 803                 unfill crz_in
 804                        -- reverse crz_in xscaled -1 shifted (-feta_eps, 0)
 805                        -- cycle;
 806         fi
 807
 808         % ugh
 809         currentpicture := currentpicture shifted (hround (w / 2), 0);
 810
 811         charwx := charwd;
 812         charwy := y1 + feta_shift;
 813
 814         z12 = (charwx * hppp, y1 * vppp);
 815
 816         labels (12);
 817 enddef;
 818
 819
 820 fet_beginchar ("Whole Crossed notehead", "s0cross");
 821         save wid, hei;
 822
 823         wid# := black_notehead_width# + 4 stafflinethickness#;
 824         hei# := noteheight# + stafflinethickness#;
 825
 826         set_char_box (0, wid#, hei# / 2, hei# / 2);
 827
 828         draw_cross (3.75);
 829
 830         remember_pic := currentpicture;
 831
 832         draw_staff (-2, 2, 0);
 833 fet_endchar;
 834
 835
 836 if test > 0:
 837         fet_beginchar ("Whole Crossed notehead", "s0cross");
 838                 save wid, hei;
 839
 840                 wid# := black_notehead_width# + 4 stafflinethickness#;
 841                 hei# := noteheight# + stafflinethickness#;
 842
 843                 set_char_box (0, wid#, hei# / 2, hei# / 2);
 844
 845                 currentpicture := remember_pic;
 846
 847                 draw_staff (-2, 2, 0.5);
 848         fet_endchar;
 849 fi;
 850
 851
 852 fet_beginchar ("Half Crossed notehead", "s1cross");
 853         save wid, hei;
 854
 855         wid# := black_notehead_width# + 2 stafflinethickness#;
 856         hei# := noteheight# + stafflinethickness# / 2;
 857
 858         set_char_box (0, wid#, hei# / 2, hei# / 2);
 859
 860         draw_cross (3.0);
 861
 862         remember_pic := currentpicture;
 863
 864         draw_staff (-2, 2, 0);
 865 fet_endchar;
 866
 867
 868 if test > 0:
 869         fet_beginchar ("Half Crossed notehead", "s1cross");
 870                 save wid, hei;
 871
 872                 wid# := black_notehead_width# + 2 stafflinethickness#;
 873                 hei# := noteheight# + stafflinethickness# / 2;
 874
 875                 set_char_box (0, wid#, hei# / 2, hei# / 2);
 876
 877                 currentpicture := remember_pic;
 878
 879                 draw_staff (-2, 2, 0.5);
 880         fet_endchar;
 881 fi;
 882
 883
 884 fet_beginchar ("Crossed notehead", "s2cross");
 885         wid# := black_notehead_width#;
 886         hei# := noteheight#;
 887         set_char_box (0, wid#, hei# / 2, hei# / 2);
 888
 889         draw_cross (1.0);
 890
 891         remember_pic := currentpicture;
 892
 893         draw_staff (-2, 2, 0);
 894 fet_endchar;
 895
 896
 897 if test > 0:
 898         fet_beginchar ("Crossed notehead", "s2cross");
 899                 wid# := black_notehead_width#;
 900                 hei# := noteheight#;
 901                 set_char_box (0, wid#, hei# / 2, hei# / 2);
 902
 903                 currentpicture := remember_pic;
 904
 905                 draw_staff (-2, 2, 0.5);
 906         fet_endchar;
 907 fi;
 908
 909
 910 fet_beginchar ("X-Circled notehead", "s2xcircle");
 911         save wid, hei;
 912         save cthick, cxd, cyd, dy;
 913
 914         wid# := black_notehead_width# * sqrt (sqrt2);
 915         hei# := noteheight# * sqrt (sqrt2);
 916
 917         set_char_box (0, wid#, hei# / 2, hei# / 2);
 918
 919         d := d - feta_space_shift;
 920
 921         cthick# := (1.2 + 1/4) * stafflinethickness#;
 922         define_blacker_pixels (cthick);
 923
 924         cxd := w - cthick;
 925         cyd := h + d - cthick / 2;
 926
 927         dy = .5 (h - d);
 928
 929         pickup pencircle scaled cthick;
 930
 931         fill fullcircle xscaled (cxd + cthick)
 932                         yscaled (cyd + cthick)
 933                         shifted (w / 2, dy);
 934         unfill fullcircle xscaled (cxd - cthick)
 935                           yscaled (cyd - cthick)
 936                           shifted (w / 2, dy);
 937
 938         xpos := .5 cxd / sqrt2;
 939         ypos := .5 cyd / sqrt2;
 940
 941         pickup penrazor scaled cthick rotated (angle (xpos, ypos) + 90);
 942         draw (-xpos + w / 2, -ypos + dy)
 943              -- (xpos + w / 2, ypos + dy);
 944
 945         pickup penrazor scaled cthick rotated (angle (xpos, -ypos) + 90);
 946         draw (-xpos + w / 2, ypos + dy)
 947              -- (xpos + w / 2, -ypos + dy);
 948
 949         charwx := charwd;
 950         charwy := 0;
 951
 952         z12 = (charwx * hppp, charwy * vppp);
 953         labels (12);
 954
 955         remember_pic := currentpicture;
 956
 957         draw_staff (-2, 2, 0);
 958 fet_endchar;
 959
 960
 961 if test > 0:
 962         fet_beginchar ("X-Circled notehead", "s2xcircle");
 963                 save wid, hei;
 964                 save cthick, cxr, cyr;
 965
 966                 wid# := black_notehead_width# * sqrt (sqrt2);
 967                 hei# := noteheight# * sqrt (sqrt2);
 968
 969                 set_char_box (0, wid#, hei# / 2, hei# / 2);
 970
 971                 currentpicture := remember_pic;
 972
 973                 draw_staff (-2, 2, 0.5);
 974         fet_endchar;
 975 fi;
 976
 977
 978 %%%%%%%%
 979 %
 980 % SOLFA SHAPED NOTES
 981 %
 982 %
 983 % Note: For whole and half notes, the `fill' curve (p_out) is offset from
 984 %       the points that specify the outer geometry, because we need to add
 985 %       the rounding.  In contrast, the inner curve is not offset, because
 986 %       there is no rounding.
 987 %
 988 %       This means that to get a line of thick_factor * pen_thickness,
 989 %       we need to offset the inner curve by
 990 %
 991 %         (thick_factor - 0.5) * pen_thickness
 992 %
 993 %       or by
 994 %
 995 %         (2 * thick_factor - 1) * half_pen_thickness
 996 %
 997 save solfa_pen_thick;
 998 solfa_pen_thick# = 1.3 stafflinethickness#;
 999 define_blacker_pixels (solfa_pen_thick);
1000
1001 save solfa_pen_radius;
1002 solfa_pen_radius = 0.5 solfa_pen_thick;
1003
1004 save solfa_base_notewidth;
1005 solfa_base_notewidth# := black_notehead_width#;
1006
1007 solfa_whole_width := 1.0;
1008 solfa_half_width := 1.0;
1009 solfa_quarter_width := 1.0;
1010
1011
1012 %%% Do head
1013 %
1014 % Triangle with base parallel to staff lines.
1015 %
1016
1017 def draw_do_head (expr width_factor, dir, thickness_factor) =
1018         save p_in, p_out;
1019         save left_dist, right_dist, bottom_dist;
1020         path p_in, p_out;
1021         pair left_dist, right_dist, bottom_dist;
1022
1023         set_char_box (0, width_factor * solfa_base_notewidth#,
1024                       0.5 solfa_noteheight#, 0.5 solfa_noteheight#);
1025
1026         bottom_thick_factor := 2 * thickness_factor - 1;
1027         % no different thickness for left side if we want uniform thickness
1028         if thickness_factor = 1:
1029                 left_thick_factor := 1;
1030         else:
1031                 left_thick_factor := 0.7 * bottom_thick_factor;
1032         fi
1033
1034         save pen_radius;
1035         pen_radius := min (solfa_pen_radius,
1036                            (h + d) / (3 * (1 + bottom_thick_factor)));
1037
1038         pickup pencircle scaled (2 * pen_radius);
1039
1040         bot y1 = -d;
1041         y1 = y2;
1042         lft x1 = 0;
1043         rt x2 = w;
1044         top y3 = h;
1045         x3 = .5 [x1, x2];
1046
1047         left_dist = (unitvector (z3 - z1) rotated 90) * pen_radius;
1048         right_dist = (unitvector (z2 - z3) rotated 90) * pen_radius;
1049         bottom_dist = (0,1) * pen_radius;
1050
1051         save pa, pb, pc;
1052         path pa, pb, pc;
1053         save point_a, point_b, point_c;
1054         pair point_a, point_b, point_c;
1055
1056         pa := (z1 - left_thick_factor * left_dist)
1057               -- (z3 - left_thick_factor * left_dist);
1058         pb := (z1 + bottom_thick_factor * bottom_dist)
1059               -- (z2 + bottom_thick_factor * bottom_dist);
1060         pc := (z2 - right_dist)
1061               -- (z3 - right_dist);
1062
1063         point_a := pa intersectionpoint pb;
1064         point_b := pb intersectionpoint pc;
1065         point_c := pc intersectionpoint pa;
1066
1067         p_in := point_a
1068                 -- point_b
1069                 -- point_c
1070                 -- cycle;
1071
1072         p_out := bot z1
1073                  -- bot z2{right}
1074                  .. rt z2{up}
1075                  .. (z2 + right_dist){z3 - z2}
1076                  -- (z3 + right_dist){z3 - z2}
1077                  .. top z3{left}
1078                  .. (z3 + left_dist){z1 - z3}
1079                  -- (z1 + left_dist){z1 - z3}
1080                  .. lft z1{down}
1081                  .. {right}cycle;
1082
1083         labels (1, 2, 3);
1084
1085         charwx := charwd;
1086         charwy := -chardp + 0.5 stafflinethickness#;
1087         if dir = -1:
1088                 charwy := -charwy;
1089         fi;
1090 enddef;
1091
1092 save do_weight;
1093 do_weight := 2;
1094
1095
1096 fet_beginchar ("Whole dohead", "s0do");
1097         draw_do_head (solfa_whole_width, 1, do_weight);
1098         fill p_out;
1099         unfill p_in;
1100 fet_endchar;
1101
1102
1103 fet_beginchar ("Half dohead", "d1do");
1104         draw_do_head (solfa_half_width, -1, do_weight);
1105         fill p_out;
1106         unfill p_in;
1107 fet_endchar;
1108
1109
1110 fet_beginchar ("Half dohead", "u1do");
1111         draw_do_head (solfa_half_width, 1, do_weight);
1112         fill p_out;
1113         unfill p_in;
1114 fet_endchar;
1115
1116
1117 fet_beginchar ("Quarter dohead", "d2do");
1118         draw_do_head (solfa_quarter_width, -1, do_weight);
1119         fill p_out;
1120 fet_endchar;
1121
1122
1123 fet_beginchar ("Quarter dohead", "u2do");
1124         draw_do_head (solfa_quarter_width, 1, do_weight);
1125         fill p_out;
1126 fet_endchar;
1127
1128
1129 fet_beginchar ("Whole thin dohead", "s0doThin");
1130         draw_do_head (solfa_whole_width, 1, 1);
1131         fill p_out;
1132         unfill p_in;
1133 fet_endchar;
1134
1135
1136 fet_beginchar ("Half thin dohead", "d1doThin");
1137         draw_do_head (solfa_half_width, -1, 1);
1138         fill p_out;
1139         unfill p_in;
1140 fet_endchar;
1141
1142
1143 fet_beginchar ("Half thin dohead", "u1doThin");
1144         draw_do_head (solfa_half_width, 1, 1);
1145         fill p_out;
1146         unfill p_in;
1147 fet_endchar;
1148
1149
1150 fet_beginchar ("Quarter thin dohead", "d2doThin");
1151         draw_do_head (solfa_quarter_width, -1, 1);
1152         fill p_out;
1153 fet_endchar;
1154
1155
1156 fet_beginchar ("Quarter thin dohead", "u2doThin");
1157         draw_do_head (solfa_quarter_width, 1, 1);
1158         fill p_out;
1159 fet_endchar;
1160
1161
1162 %
1163 % re - flat top, curved bottom:
1164 %
1165 %   (0,h/2) {dir -90}
1166 %   .. (w/2,-h/2)
1167 %   .. {dir 90} (w,h/2)
1168 %   -- cycle;
1169 %
1170 % (broader along the base and with more vertical sides for half and
1171 % whole notes)
1172 %
1173 % Note: According to some shape-note singers, there should be no size
1174 %       differences for half and whole notes, contrary to the comment above.
1175 %       Consequently, we have made them all the same width.
1176 %
1177 % stem attachment: h/2
1178 %
1179 def draw_re_head (expr width_factor, dir, thickness_factor) =
1180         save p_in, p_out;
1181         path p_in, p_out;
1182
1183         set_char_box (0, width_factor * solfa_base_notewidth#,
1184                       0.5 solfa_noteheight#, 0.5 solfa_noteheight#);
1185
1186         save offset;
1187         offset = (2 * thickness_factor - 1);
1188
1189         save curve_start;
1190         curve_start = 0.7;
1191
1192         save pen_radius;
1193
1194         pen_radius := min (solfa_pen_radius,
1195                            (h + d) * (1-curve_start) / (1+ offset));
1196
1197         pickup pencircle scaled (2 * pen_radius);
1198
1199         lft x1 = 0;
1200         top y1 = h;
1201         x2 = x1;
1202         y2 = curve_start [y3, y1];
1203         bot y3 = -d;
1204         x3 = .5 [x2, x4];
1205         rt x4 = w;
1206         y4 = y2;
1207         y5 = y1;
1208         x5 = x4;
1209
1210         labels (range 1 thru 5);
1211
1212         p_in := (z1 + pen_radius * (1, -1 * offset))
1213                 -- rt z2{down}
1214                 .. ((top z3) + (0, offset * pen_radius))
1215                 .. lft z4{up}
1216                 -- (z5 + pen_radius * (-1, -1 * offset))
1217                 -- cycle;
1218
1219         p_out := lft z1
1220                  -- lft z2{down}
1221                  .. bot z3
1222                  .. rt z4{up}
1223                  -- rt z5{up}
1224                  .. top z5{left}
1225                  -- top z1{left}
1226                  .. {down}cycle;
1227
1228         charwx := charwd;
1229         charwy := curve_start [-chardp, charht];
1230
1231         if dir = -1:
1232                 charwy := -charwy;
1233         fi;
1234 enddef;
1235
1236
1237 save re_weight;
1238 re_weight := 2;
1239
1240 fet_beginchar ("Whole rehead", "s0re");
1241         draw_re_head (solfa_whole_width, 1, re_weight);
1242         fill p_out;
1243         unfill p_in;
1244 fet_endchar;
1245
1246
1247 fet_beginchar ("Half up rehead", "u1re");
1248         draw_re_head (solfa_half_width, 1, re_weight);
1249         fill p_out;
1250         unfill p_in;
1251 fet_endchar;
1252
1253
1254 fet_beginchar ("Half down rehead", "d1re");
1255         draw_re_head (solfa_half_width, -1, re_weight);
1256         fill p_out;
1257         unfill p_in;
1258 fet_endchar;
1259
1260
1261 fet_beginchar ("Quarter up rehead", "u2re");
1262         draw_re_head (solfa_quarter_width, 1, re_weight);
1263         fill p_out;
1264 fet_endchar;
1265
1266
1267 fet_beginchar ("Quarter down rehead", "d2re");
1268         draw_re_head (solfa_quarter_width, -1, re_weight);
1269         fill p_out;
1270 fet_endchar;
1271
1272
1273 fet_beginchar ("Whole thin rehead", "s0reThin");
1274         draw_re_head (solfa_whole_width, 1, 1);
1275         fill p_out;
1276         unfill p_in;
1277 fet_endchar;
1278
1279
1280 fet_beginchar ("Half up thin rehead", "u1reThin");
1281         draw_re_head (solfa_half_width, 1, 1);
1282         fill p_out;
1283         unfill p_in;
1284 fet_endchar;
1285
1286
1287 fet_beginchar ("Half down thin rehead", "d1reThin");
1288         draw_re_head (solfa_half_width, -1, 1);
1289         fill p_out;
1290         unfill p_in;
1291 fet_endchar;
1292
1293
1294 fet_beginchar ("Quarter thin rehead", "u2reThin");
1295         draw_re_head (solfa_quarter_width, 1, 1);
1296         fill p_out;
1297 fet_endchar;
1298
1299
1300 fet_beginchar ("Quarter thin rehead", "d2reThin");
1301         draw_re_head (solfa_quarter_width, -1, 1);
1302         fill p_out;
1303 fet_endchar;
1304
1305
1306 %%%% mi head -- diamond shape
1307 %
1308 % two versions, depending on whether the `strong' lines are on the nw & se
1309 % or the ne & sw
1310 %
1311 def draw_mi_head (expr width_factor, thickness_factor, mirror) =
1312         save path_out, path_in;
1313         save ne_dist, se_dist, ne, se;
1314         save path_a, path_b, path_c, path_d;
1315         path path_out, path_in;
1316         pair ne_dist, se_dist, ne, se;
1317         path path_a, path_b, path_c, path_d;
1318         save inner_path;
1319         path inner_path;
1320
1321         set_char_box (0, width_factor * solfa_base_notewidth#,
1322                       0.5 solfa_noteheight#, 0.5 solfa_noteheight#);
1323
1324         save offset;
1325         offset := 2 * thickness_factor - 1;
1326
1327         save note_diagonal;
1328
1329         note_diagonal := w / 2 ++ (h + d) / 2;
1330
1331         save pen_radius;
1332
1333         pen_radius := min (solfa_pen_radius,
1334                            .3 * note_diagonal / (1 + offset));
1335
1336         pickup pencircle scaled (2 * pen_radius);
1337
1338         lft x1 = 0;
1339         y1 = 0;
1340         bot y2 = -d;
1341         x2 = .5 [x1, x3];
1342         rt x3 = w;
1343         x4 = x2;
1344         y3 = y1;
1345         top y4 = h;
1346
1347         % inner sides are parallel to outer sides
1348         z6 - z5 = whatever * (z2 - z1);
1349         z8 - z7 = whatever * (z4 - z3);
1350         z8 - z5 = whatever * (z4 - z1);
1351         z7 - z6 = whatever * (z3 - z2);
1352
1353         ne = unitvector (z4 - z1);
1354         se = unitvector (z2 - z1);
1355
1356         ne_dist = (ne rotated 90) * pen_radius;
1357         se_dist = (se rotated 90) * pen_radius;
1358
1359         path_a := (z1 + se_dist)
1360                   -- (z2 + se_dist);
1361         path_b := (z2 + (ne_dist * offset))
1362                   -- (z3 + (ne_dist * offset));
1363         path_c := (z3 - se_dist)
1364                   -- (z4 - se_dist);
1365         path_d := (z4 - (ne_dist * offset))
1366                   -- (z1 - (ne_dist * offset));
1367
1368         z5 = path_a intersectionpoint path_d;
1369         z7 = path_b intersectionpoint path_c;
1370
1371         labels (range 1 thru 8);
1372
1373         inner_path := z5
1374                       -- z6
1375                       -- z7
1376                       -- z8
1377                       -- cycle;
1378
1379         if mirror:
1380                 path_in := inner_path;
1381         else:
1382                 path_in := inner_path reflectedabout (z2, z4);
1383         fi
1384
1385         path_out := lft z1 {down}
1386                     .. (z1 - se_dist){se}
1387                     -- (z2 - se_dist){se}
1388                     .. bot z2 {right}
1389                     .. (z2 - ne_dist){ne}
1390                     -- (z3 - ne_dist){ne}
1391                     .. rt z3 {up}
1392                     .. (z3 + se_dist){-se}
1393                     -- (z4 + se_dist){-se}
1394                     .. top z4 {left}
1395                     .. (z4 + ne_dist){-ne}
1396                     -- (z1 + ne_dist){-ne}
1397                     .. cycle;
1398 enddef;
1399
1400
1401 save mi_weight, mi_width;
1402 mi_weight := 2;
1403 mi_width := 1.2;
1404
1405 fet_beginchar ("Whole mihead", "s0mi");
1406         draw_mi_head (mi_width * solfa_whole_width, mi_weight, false);
1407         fill path_out;
1408         unfill path_in;
1409 fet_endchar;
1410
1411
1412 fet_beginchar ("Half mihead", "s1mi");
1413         draw_mi_head (mi_width * solfa_quarter_width, mi_weight, false);
1414         fill path_out;
1415         unfill path_in;
1416 fet_endchar;
1417
1418
1419 fet_beginchar ("Quarter mihead", "s2mi");
1420         draw_mi_head (mi_width * solfa_quarter_width, mi_weight, false);
1421         fill path_out;
1422 fet_endchar;
1423
1424
1425 fet_beginchar ("Whole mirror mihead", "s0miMirror");
1426         draw_mi_head (mi_width * solfa_whole_width, mi_weight, true);
1427         fill path_out;
1428         unfill path_in;
1429 fet_endchar;
1430
1431
1432 fet_beginchar ("Half  mirror mihead", "s1miMirror");
1433         draw_mi_head (mi_width * solfa_quarter_width, mi_weight, true);
1434         fill path_out;
1435         unfill path_in;
1436 fet_endchar;
1437
1438
1439 fet_beginchar ("Quarter mirror mihead", "s2miMirror");
1440         draw_mi_head (mi_width * solfa_quarter_width, mi_weight, true);
1441         fill path_out;
1442 fet_endchar;
1443
1444
1445 fet_beginchar ("Whole thin mihead", "s0miThin");
1446         draw_mi_head (mi_width * solfa_whole_width, 1, false);
1447         fill path_out;
1448         unfill path_in;
1449 fet_endchar;
1450
1451
1452 fet_beginchar ("Half thin mihead", "s1miThin");
1453         draw_mi_head (mi_width * solfa_quarter_width, 1, false);
1454         fill path_out;
1455         unfill path_in;
1456 fet_endchar;
1457
1458
1459 fet_beginchar ("Quarter thin mihead", "s2miThin");
1460         draw_mi_head (mi_width * solfa_quarter_width, 1, false);
1461         fill path_out;
1462 fet_endchar;
1463
1464
1465 %%%% fa head
1466 %
1467 % Right triangle, hypotenuse from nw to se corner.  Stem attaches on
1468 % vertical side in direction of horizontal side.
1469 %
1470 def draw_fa_head (expr width_factor, thickness_factor) =
1471         set_char_box (0, width_factor * solfa_base_notewidth#,
1472                       0.5 solfa_noteheight#, 0.5 solfa_noteheight#);
1473
1474         save p_down_in, p_down_out, p_up_in, p_up_out, nw_dist, nw;
1475         path p_down_in, p_down_out, p_up_in, p_up_out;
1476         save path_a, path_b, path_c;
1477         path path_a, path_b, path_c;
1478         pair nw_dist, nw;
1479
1480         save offset;
1481         offset := 2 * thickness_factor - 1;
1482
1483         save pen_radius;
1484         pen_radius := min (solfa_pen_radius,
1485                            .33 * (h + d) / (1 + offset));
1486
1487         pickup pencircle scaled (2 * pen_radius);
1488
1489         lft x1 = 0;
1490         top y1 = h;
1491
1492         rt x2 = w;
1493         y2 = y1;
1494         bot y3 = -d;
1495         x3 = x2;
1496
1497         y4 = y3;
1498         x4 = x1;
1499
1500         labels (1, 2, 3, 4);
1501
1502         nw = unitvector (z1 - z3);
1503         nw_dist = (nw rotated 90) * pen_radius;
1504
1505         path_a := (z1 - (0,1) * offset * pen_radius)
1506                   -- (z2 - (0,1) * offset * pen_radius);
1507         path_b := (z2 - (1,0) * pen_radius)
1508                   -- (z3 - (1,0) * pen_radius);
1509         path_c := (z3 - nw_dist)
1510                   -- (z1 - nw_dist);
1511
1512         p_up_in := (path_a intersectionpoint path_b)
1513                    -- (path_b intersectionpoint path_c)
1514                    -- (path_c intersectionpoint path_a)
1515                    -- cycle;
1516
1517         p_up_out := lft z1{down}
1518                     .. (z1 + nw_dist){-nw}
1519                     -- (z3 + nw_dist){-nw}
1520                     .. bot z3{right}
1521                     .. rt z3{up}
1522                     -- rt z2{up}
1523                     .. top z2{left}
1524                     -- top z1{left}
1525                     .. cycle;
1526
1527         p_down_in := p_up_in rotated 180 shifted (w, 0);
1528         p_down_out := p_up_out rotated 180 shifted (w, 0);
1529
1530         charwy := 0.0;
1531         charwx := charwd;
1532 enddef;
1533
1534 save fa_weight;
1535 fa_weight := 1.75;
1536
1537 fet_beginchar ("Whole fa up head", "u0fa");
1538         draw_fa_head (solfa_whole_width, fa_weight);
1539         fill p_up_out;
1540         unfill p_up_in;
1541 fet_endchar;
1542
1543
1544 fet_beginchar ("Whole fa down head", "d0fa");
1545         draw_fa_head (solfa_whole_width, fa_weight);
1546         fill p_down_out;
1547         unfill p_down_in;
1548 fet_endchar;
1549
1550
1551 fet_beginchar ("half fa up head", "u1fa");
1552         draw_fa_head (solfa_half_width, fa_weight);
1553         fill p_up_out;
1554         unfill p_up_in;
1555 fet_endchar;
1556
1557
1558 fet_beginchar ("Half fa down head", "d1fa");
1559         draw_fa_head (solfa_half_width, fa_weight);
1560         fill p_down_out;
1561         unfill p_down_in;
1562 fet_endchar;
1563
1564
1565 fet_beginchar ("Quarter fa up head", "u2fa");
1566         draw_fa_head (solfa_quarter_width, fa_weight);
1567         fill p_up_out;
1568 fet_endchar;
1569
1570
1571 fet_beginchar ("Quarter fa down head", "d2fa");
1572         draw_fa_head (solfa_quarter_width, fa_weight);
1573         fill p_down_out;
1574 fet_endchar;
1575
1576
1577 fet_beginchar ("Whole thin fa up head", "u0faThin");
1578         draw_fa_head (solfa_whole_width, 1);
1579         fill p_up_out;
1580         unfill p_up_in;
1581 fet_endchar;
1582
1583
1584 fet_beginchar ("Whole thin fa down head", "d0faThin");
1585         draw_fa_head (solfa_whole_width, 1);
1586         fill p_down_out;
1587         unfill p_down_in;
1588 fet_endchar;
1589
1590
1591 fet_beginchar ("half thin fa up head", "u1faThin");
1592         draw_fa_head (solfa_half_width, 1);
1593         fill p_up_out;
1594         unfill p_up_in;
1595 fet_endchar;
1596
1597
1598 fet_beginchar ("Half thin fa down head", "d1faThin");
1599         draw_fa_head (solfa_half_width, 1);
1600         fill p_down_out;
1601         unfill p_down_in;
1602 fet_endchar;
1603
1604
1605 fet_beginchar ("Quarter thin fa up head", "u2faThin");
1606         draw_fa_head (solfa_quarter_width, 1);
1607         fill p_up_out;
1608 fet_endchar;
1609
1610
1611 fet_beginchar ("Quarter thin fa down head", "d2faThin");
1612         draw_fa_head (solfa_quarter_width, 1);
1613         fill p_down_out;
1614 fet_endchar;
1615
1616
1617
1618 %%%% sol head
1619 %
1620 % Note: sol head is the same shape as a standard music head, and doesn't
1621 %       vary from style to style.  However, width is constant with duration,
1622 %       so we can't just use the standard note font.
1623 %
1624 def draw_sol_head (expr filled) =
1625         draw_outside_ellipse (1.53 - puff_up_factor / 3.0, 34, 0.66, 0.17);
1626         if not filled:
1627           undraw_inside_ellipse (3.25, 33, 0.81, 2.5 stafflinethickness#);
1628         fi
1629         draw_staff (-2, 2, 0);
1630 enddef;
1631
1632 fet_beginchar ("Whole solhead", "s0sol");
1633         draw_sol_head ( false);
1634 fet_endchar;
1635
1636
1637 fet_beginchar ("Half solhead", "s1sol");
1638         draw_sol_head ( false);
1639 fet_endchar;
1640
1641
1642 fet_beginchar ("Quarter solhead", "s2sol");
1643         draw_sol_head ( true);
1644 fet_endchar;
1645
1646
1647 %%%% la head
1648 %
1649 %   Rectangle head
1650 %
1651 def draw_la_head (expr width_factor, thickness_factor) =
1652         set_char_box (0, width_factor * solfa_base_notewidth#,
1653                       0.5 solfa_noteheight#, 0.5 solfa_noteheight#);
1654         save p_in, p_out;
1655         path p_in, p_out;
1656
1657         save offset;
1658         offset := 2 * thickness_factor - 1;
1659
1660         save pen_radius;
1661         pen_radius := min (solfa_pen_radius,
1662                            .35 * (h + d) / (1 + offset));
1663
1664         pickup pencircle scaled (2 * pen_radius);
1665
1666         lft x1 = 0;
1667         top y1 = h;
1668
1669         rt x2 = w;
1670         y2 = y1;
1671         bot y3 = -d;
1672         x3 = x2;
1673
1674         y4 = y3;
1675         x4 = x1;
1676
1677         labels (range 1 thru 4);
1678
1679         p_in := (z1 + pen_radius * (1, -offset))
1680                 -- (z2 + pen_radius * (-1, -offset))
1681                 -- (z3 + pen_radius * (-1, offset))
1682                 -- (z4 + pen_radius * (1, offset))
1683                 -- cycle;
1684
1685         p_out := top z1
1686                  -- top z2{right}
1687                  .. rt z2{down}
1688                  -- rt z3{down}
1689                  .. bot z3{left}
1690                  -- bot z4{left}
1691                  .. lft z4{up}
1692                  -- lft z1{up}
1693                  .. cycle;
1694 enddef;
1695
1696
1697 save la_weight;
1698 la_weight := 2;
1699
1700 fet_beginchar ("Whole lahead", "s0la");
1701         draw_la_head (solfa_whole_width, la_weight);
1702         fill p_out;
1703         unfill p_in;
1704 fet_endchar;
1705
1706
1707 fet_beginchar ("Half lahead", "s1la");
1708         draw_la_head (solfa_half_width, la_weight);
1709         fill p_out;
1710         unfill p_in;
1711 fet_endchar;
1712
1713
1714 fet_beginchar ("Quarter lahead", "s2la");
1715         draw_la_head (solfa_quarter_width, la_weight);
1716         fill p_out;
1717 fet_endchar;
1718
1719
1720 fet_beginchar ("Whole thin lahead", "s0laThin");
1721         draw_la_head (solfa_whole_width, 1);
1722         fill p_out;
1723         unfill p_in;
1724 fet_endchar;
1725
1726
1727 fet_beginchar ("Half thin lahead", "s1laThin");
1728         draw_la_head (solfa_half_width, 1);
1729         fill p_out;
1730         unfill p_in;
1731 fet_endchar;
1732
1733
1734 fet_beginchar ("Quarter lahead", "s2laThin");
1735         draw_la_head (solfa_quarter_width, 1);
1736         fill p_out;
1737 fet_endchar;
1738
1739
1740 %%%% ti head
1741 %
1742 %   `Snow-cone', V with rounded top.
1743 %
1744 def draw_ti_head (expr width_factor, dir, thickness_factor) =
1745         set_char_box (0, width_factor * solfa_base_notewidth#,
1746                       0.5 solfa_noteheight#, 0.5 solfa_noteheight#);
1747         save p_in, p_out, p_top, p_top_in;
1748         path p_in, p_out, p_top, p_top_in;
1749         save cone_height;
1750         cone_height = 0.64;
1751
1752         save offset;
1753         offset := 2 * thickness_factor - 1;
1754
1755         save pen_radius;
1756         pen_radius := min (solfa_pen_radius,
1757                            .4 * (h + d) / (1 + offset));
1758
1759         pickup pencircle scaled (2 * pen_radius);
1760
1761         x1 = .5 [x2, x4];
1762         bot y1 = -d;
1763         lft x2 = 0;
1764         y2 = cone_height [y1, y3];
1765         rt x4 = w;
1766         y4 = y2;
1767         x3 = x1;
1768         top y3 = h;
1769         x5 = x1;
1770         y5 = y1 + offset * pen_radius;
1771
1772         labels (range 1 thru 4);
1773
1774         save nw_dist, sw_dist, nw, sw;
1775         pair nw_dist, sw_dist, nw, sw;
1776
1777         nw = unitvector (z2 - z1);
1778         sw = unitvector (z1 - z4);
1779
1780         nw_dist = (nw rotated 90) * pen_radius;
1781         sw_dist = (sw rotated 90) * pen_radius;
1782
1783         p_top := (z2 + nw * pen_radius)
1784                  .. (top z3){right}
1785                  .. (z4 - sw * pen_radius);
1786
1787         p_top_in := (z2 - nw * offset * pen_radius)
1788                     .. (z3 - (0,1) * pen_radius) {right}
1789                     .. (z4 + sw * offset * pen_radius);
1790
1791         save path_a, path_b;
1792         path path_a, path_b;
1793         path_a := z2
1794                   -- z5;
1795         path_b := z5
1796                   -- z4;
1797
1798         z6 = path_a intersectionpoint p_top_in;
1799         z7 = path_b intersectionpoint p_top_in;
1800
1801         p_in := z5
1802                 -- z6
1803                 .. bot z3
1804                 .. z7
1805                 -- cycle;
1806
1807         p_out := bot z1
1808                  .. (z1 + nw_dist)
1809                  -- (z2 + nw_dist)
1810                  .. lft z2
1811                  .. (z2 + nw * pen_radius){direction 0 of p_top}
1812                  & p_top
1813                  & {direction infinity of p_top}(z4 - sw * pen_radius)
1814                  .. rt z4
1815                  .. (z4 + sw_dist)
1816                  -- (z1 + sw_dist)
1817                  .. cycle;
1818
1819         charwx := charwd;
1820         charwy := cone_height [-chardp, charht];
1821         if dir = -1:
1822                 charwy := -charwy;
1823         fi;
1824 enddef;
1825
1826
1827 save ti_weight;
1828 ti_weight := 2;
1829
1830 fet_beginchar ("Whole up tihead", "s0ti");
1831         draw_ti_head (solfa_whole_width, 1, ti_weight);
1832         fill p_out;
1833         unfill p_in;
1834 fet_endchar;
1835
1836
1837 fet_beginchar ("Half up tihead", "u1ti");
1838         draw_ti_head (solfa_half_width, 1, ti_weight);
1839         fill p_out;
1840         unfill p_in;
1841 fet_endchar;
1842
1843
1844 fet_beginchar ("Half down tihead", "d1ti");
1845         draw_ti_head (solfa_half_width, -1, ti_weight);
1846         fill p_out;
1847         unfill p_in;
1848 fet_endchar;
1849
1850
1851 fet_beginchar ("Quarter up tihead", "u2ti");
1852         draw_ti_head (solfa_quarter_width, 1, ti_weight);
1853         fill p_out;
1854 fet_endchar;
1855
1856
1857 fet_beginchar ("Quarter down tihead", "d2ti");
1858         draw_ti_head (solfa_quarter_width, -1, ti_weight);
1859         fill p_out;
1860 fet_endchar;
1861
1862
1863 fet_beginchar ("Whole thin up tihead", "s0tiThin");
1864         draw_ti_head (solfa_whole_width, 1, 1);
1865         fill p_out;
1866         unfill p_in;
1867 fet_endchar;
1868
1869
1870 fet_beginchar ("Half thin up tihead", "u1tiThin");
1871         draw_ti_head (solfa_half_width, 1, 1);
1872         fill p_out;
1873         unfill p_in;
1874 fet_endchar;
1875
1876
1877 fet_beginchar ("Half thin down tihead", "d1tiThin");
1878         draw_ti_head (solfa_half_width, -1, 1);
1879         fill p_out;
1880         unfill p_in;
1881 fet_endchar;
1882
1883
1884 fet_beginchar ("Quarter thin up tihead", "u2tiThin");
1885         draw_ti_head (solfa_quarter_width, 1, 1);
1886         fill p_out;
1887 fet_endchar;
1888
1889
1890 fet_beginchar ("Quarter thin down tihead", "d2tiThin");
1891         draw_ti_head (solfa_quarter_width, -1, 1);
1892         fill p_out;
1893 fet_endchar;
1894
1895
1896 %%%%%%   Funk shape note heads
1897 %
1898 %  Funk heads are narrower than Aiken and Sacred Harp, so we need a new
1899 %  width.
1900 %
1901 funk_notehead_width := 0.75;
1902
1903
1904 %%%%%%   Funk do head
1905 %          Parabolic on one side, vertical line on other
1906 %          Has up and down shapes for *all* notes
1907 %
1908 def draw_Funk_do_head (expr width_factor, thickness_factor) =
1909         set_char_box (0, width_factor * solfa_base_notewidth#,
1910                       0.5 solfa_noteheight#, 0.5 solfa_noteheight#);
1911
1912         save offset;
1913         offset := 2 * thickness_factor - 1;
1914
1915         save pen_radius;
1916         pen_radius := min (solfa_pen_radius,
1917                            .3 * (h + d) / (1 + offset));
1918
1919         pickup pencircle scaled (2 * pen_radius);
1920
1921         rt x1 = w;
1922         bot y1 = -d;
1923
1924         lft x2 = 0;
1925         y2 = 0.5 [y1, y3];
1926
1927         x3 = x1;
1928         top y3 = h;
1929
1930         x4 = x1 - pen_radius;
1931         y4 = y1 + offset * pen_radius;
1932
1933         y5 = y2;
1934         x5 = x2 + pen_radius;
1935
1936         x6 = x4;
1937         y6 = y3 - offset * pen_radius;
1938
1939         save p_up_in, p_up_out, p_down_in, p_down_out;
1940         path p_up_in, p_up_out, p_down_in, p_down_out;
1941
1942         p_down_in := z4{left}
1943                      ... z5{up}
1944                      ... z6{right}
1945                      -- cycle;
1946
1947         p_down_out := bot z1{left}
1948                       .. lft z2{up}
1949                       .. top z3{right}
1950                       .. rt z3{down}
1951                       -- rt z1{down}
1952                       .. cycle;
1953
1954         p_up_in := p_down_in rotated 180 shifted (w,0);
1955         p_up_out := p_down_out rotated 180 shifted (w,0);
1956
1957 enddef;
1958
1959
1960 save funk_do_weight;
1961 funk_do_weight := 1.7;
1962
1963 fet_beginchar ("Whole up Funk dohead", "u0doFunk");
1964         draw_Funk_do_head (funk_notehead_width, funk_do_weight);
1965         fill p_up_out;
1966         unfill p_up_in;
1967 fet_endchar;
1968
1969
1970 fet_beginchar ("Whole down Funk dohead", "d0doFunk");
1971         draw_Funk_do_head (funk_notehead_width, funk_do_weight);
1972         fill p_down_out;
1973         unfill p_down_in;
1974 fet_endchar;
1975
1976
1977 fet_beginchar ("Half up Funk dohead", "u1doFunk");
1978         draw_Funk_do_head (funk_notehead_width, funk_do_weight);
1979         fill p_up_out;
1980         unfill p_up_in;
1981 fet_endchar;
1982
1983
1984 fet_beginchar ("Half down Funk dohead", "d1doFunk");
1985         draw_Funk_do_head (funk_notehead_width, funk_do_weight);
1986         fill p_down_out;
1987         unfill p_down_in;
1988 fet_endchar;
1989
1990
1991 fet_beginchar ("Quarter up Funk dohead", "u2doFunk");
1992         draw_Funk_do_head (funk_notehead_width, funk_do_weight);
1993         fill p_up_out;
1994 fet_endchar;
1995
1996
1997 fet_beginchar ("Quarter down Funk dohead", "d2doFunk");
1998         draw_Funk_do_head (funk_notehead_width, funk_do_weight);
1999         fill p_down_out;
2000 fet_endchar;
2001
2002
2003 %%%%%%  Funk re head
2004 %       Arrowhead shape.
2005 %       Has up and down shapes for *all* notes
2006 %
2007 def draw_Funk_re_head (expr width_factor, thickness_factor) =
2008         set_char_box (0, width_factor * solfa_base_notewidth#,
2009                       0.5 solfa_noteheight#, 0.5 solfa_noteheight#);
2010
2011         save offset;
2012         offset := 2 * thickness_factor - 1;
2013
2014         save pen_radius;
2015         pen_radius := min (solfa_pen_radius,
2016                            .3 * (h + d) / (1 + offset));
2017
2018         pickup pencircle scaled (2 * pen_radius);
2019
2020         save curve_in;
2021         curve_in := 0.9;
2022
2023         lft x1 = 0;
2024         y1 := 0.5 [y2, y4];
2025
2026         rt x2 = w;
2027         top y2 = h;
2028
2029         x3 := curve_in [x1, x2];
2030         y3 := y1;
2031
2032         x4 = x2;
2033         bot y4 = -d;
2034
2035         z6 = lft z3;
2036
2037         save ne, se, ne_perp, se_perp;
2038         pair ne, se, ne_perp, se_perp;
2039
2040         ne := unitvector (z2 - z1);
2041         se := unitvector (z4 - z1);
2042         ne_perp := ne rotated 90;
2043         se_perp := se rotated 90;
2044
2045         save path_a, path_b, path_c, path_d;
2046         path path_a, path_b, path_c, path_d;
2047         save arrow_a_perp, arrow_b_perp;
2048         pair arrow_a_perp, arrow_b_perp;
2049
2050
2051         path_d := z2 .. z3{down} .. z4;
2052         arrow_a_perp = unitvector (direction 0 of path_d rotated 90)
2053                        * pen_radius;
2054         arrow_b_perp = unitvector (direction 2 of path_d rotated 90)
2055                        * pen_radius;
2056
2057         path_b := (z1 + se_perp * pen_radius)
2058                   -- z4 + se_perp * offset * pen_radius;
2059         path_a := (z1 - ne_perp * pen_radius)
2060                   -- z2 - ne_perp * offset * pen_radius;
2061         path_c := z2 - arrow_a_perp
2062                   .. z6{down}
2063                   .. z4 - arrow_b_perp;
2064
2065         z5 = path_a intersectionpoint path_b;
2066         z7 = path_a intersectionpoint path_c;
2067         z8 = path_b intersectionpoint path_c;
2068
2069         save p_up_in, p_down_in, p_up_out, p_down_out;
2070         path p_up_in, p_down_in, p_up_out, p_down_out;
2071
2072         p_down_in := z5
2073                      -- z7
2074                      .. z6{down}
2075                      .. z8
2076                      -- cycle;
2077
2078         p_down_out := lft z1{up}
2079                       .. (z1 + ne_perp * pen_radius){ne}
2080                       -- (z2 + ne_perp * pen_radius){ne}
2081                       .. top z2 {right}
2082                       .. rt z2{down}
2083                       .. (z2 + arrow_a_perp)
2084                       .. rt z3{down}
2085                       .. (z4 + arrow_b_perp)
2086                       .. rt z4{down}
2087                       .. bot z4 {left}
2088                       .. z4 - se_perp * pen_radius
2089                       -- z1 - se_perp * pen_radius
2090                       .. cycle;
2091
2092         p_up_in := p_down_in rotated 180 shifted (w, 0);
2093         p_up_out := p_down_out rotated 180 shifted (w, 0);
2094
2095 enddef;
2096
2097
2098 save funk_re_weight;
2099 funk_re_weight = 1.7;
2100
2101 fet_beginchar ("Whole up Funk rehead", "u0reFunk");
2102         draw_Funk_re_head (funk_notehead_width, funk_re_weight);
2103         fill p_up_out;
2104         unfill p_up_in;
2105 fet_endchar;
2106
2107
2108 fet_beginchar ("Whole down Funk rehead", "d0reFunk");
2109         draw_Funk_re_head (funk_notehead_width, funk_re_weight);
2110         fill p_down_out;
2111         unfill p_down_in;
2112 fet_endchar;
2113
2114
2115 fet_beginchar ("Half up Funk rehead", "u1reFunk");
2116         draw_Funk_re_head (funk_notehead_width, funk_re_weight);
2117         fill p_up_out;
2118         unfill p_up_in;
2119 fet_endchar;
2120
2121
2122 fet_beginchar ("Half down Funk rehead", "d1reFunk");
2123         draw_Funk_re_head (funk_notehead_width, funk_re_weight);
2124         fill p_down_out;
2125         unfill p_down_in;
2126 fet_endchar;
2127
2128
2129 fet_beginchar ("Quarter up Funk rehead", "u2reFunk");
2130         draw_Funk_re_head (funk_notehead_width, funk_re_weight);
2131         fill p_up_out;
2132 fet_endchar;
2133
2134
2135 fet_beginchar ("Quarter down Funk rehead", "d2reFunk");
2136         draw_Funk_re_head (funk_notehead_width, funk_re_weight);
2137         fill p_down_out;
2138 fet_endchar;
2139
2140
2141 %%%%%%  Funk mi head
2142 %       Diamond shape
2143 %       Has up and down shapes for all hollow notes
2144 %
2145 save funk_mi_width, funk_mi_weight;
2146 funk_mi_width := 1.2;
2147 funk_mi_weight := 1.9;
2148
2149 fet_beginchar ("Whole up Funk mihead", "u0miFunk");
2150         draw_mi_head (funk_mi_width * funk_notehead_width,
2151                       funk_mi_weight, false);
2152         fill path_out;
2153         unfill path_in;
2154 fet_endchar;
2155
2156
2157 fet_beginchar ("Whole down Funk mihead", "d0miFunk");
2158         draw_mi_head (funk_mi_width * funk_notehead_width,
2159                       funk_mi_weight, true);
2160         fill path_out;
2161         unfill path_in;
2162 fet_endchar;
2163
2164
2165 fet_beginchar ("Half up Funk mihead", "u1miFunk");
2166         draw_mi_head (funk_mi_width * funk_notehead_width,
2167                       funk_mi_weight, false);
2168         fill path_out;
2169         unfill path_in;
2170 fet_endchar;
2171
2172
2173 fet_beginchar ("Half down Funk mihead", "d1miFunk");
2174         draw_mi_head (funk_mi_width * funk_notehead_width,
2175                       funk_mi_weight, true);
2176         fill path_out;
2177         unfill path_in;
2178 fet_endchar;
2179
2180
2181 fet_beginchar ("Quarter Funk mihead", "s2miFunk");
2182         draw_mi_head (funk_mi_width * funk_notehead_width,
2183                       funk_mi_weight, false);
2184         fill path_out;
2185 fet_endchar;
2186
2187
2188 %%%%%%  Funk fa
2189 %       Triangle shape
2190 %       Does it rotate for whole notes?
2191 %       Same as other shape note systems
2192 %       Need special notes because of special width
2193 %
2194 save funk_fa_weight;
2195 funk_fa_weight := 1.9;
2196
2197 fet_beginchar ("Whole up Funk fahead", "u0faFunk");
2198         draw_fa_head (funk_notehead_width, funk_fa_weight);
2199         fill p_up_out;
2200         unfill p_up_in;
2201 fet_endchar;
2202
2203
2204 fet_beginchar ("Whole down Funk fahead", "d0faFunk");
2205         draw_fa_head (funk_notehead_width, funk_fa_weight);
2206         fill p_down_out;
2207         unfill p_down_in;
2208 fet_endchar;
2209
2210
2211 fet_beginchar ("Half up Funk fahead", "u1faFunk");
2212         draw_fa_head (funk_notehead_width, funk_fa_weight);
2213         fill p_up_out;
2214         unfill p_up_in;
2215 fet_endchar;
2216
2217
2218 fet_beginchar ("Half down Funk fahead", "d1faFunk");
2219         draw_fa_head (funk_notehead_width, funk_fa_weight);
2220         fill p_down_out;
2221         unfill p_down_in;
2222 fet_endchar;
2223
2224
2225 fet_beginchar ("Quarter up Funk fahead", "u2faFunk");
2226         draw_fa_head (funk_notehead_width, funk_fa_weight);
2227         fill p_up_out;
2228 fet_endchar;
2229
2230
2231 fet_beginchar ("Quarter down Funk fahead", "d2faFunk");
2232         draw_fa_head (funk_notehead_width, funk_fa_weight);
2233         fill p_down_out;
2234 fet_endchar;
2235
2236
2237 %%%%%%  Funk sol head is the same as the others
2238 %       Need special character because of skinnier head
2239 %
2240 def draw_Funk_sol_head (expr filled) =
2241 begingroup
2242         save noteheight;
2243         noteheight# := solfa_noteheight#;
2244         draw_outside_ellipse (1.2, 34, 0.71, 0.);
2245         if not filled:
2246           undraw_inside_ellipse (1.9, 33, 0.74, 5.5 stafflinethickness#);
2247         fi
2248         draw_staff (-2, 2, 0);
2249 endgroup
2250 enddef;
2251
2252
2253 fet_beginchar ("Whole Funk solhead", "s0solFunk");
2254         draw_Funk_sol_head ( false);
2255 fet_endchar;
2256
2257
2258 fet_beginchar ("Half Funk solhead", "s1solFunk");
2259         draw_Funk_sol_head ( false);
2260 fet_endchar;
2261
2262
2263 fet_beginchar ("Quarter Funk solhead", "s2solFunk");
2264         draw_Funk_sol_head ( true);
2265 fet_endchar;
2266
2267
2268 %%%%%%  Funk la head
2269 %       Rectangle head
2270 %       Same as for other shape notes
2271 %       Smaller width requires special characters
2272 %
2273 save funk_la_weight;
2274 funk_la_weight := 1.9;
2275
2276 fet_beginchar ("Whole Funk lahead", "s0laFunk");
2277         draw_la_head (funk_notehead_width, funk_notehead_width);
2278         fill p_out;
2279         unfill p_in;
2280 fet_endchar;
2281
2282
2283 fet_beginchar ("Half Funk lahead", "s1laFunk");
2284         draw_la_head (funk_notehead_width, funk_notehead_width);
2285         fill p_out;
2286         unfill p_in;
2287 fet_endchar;
2288
2289
2290 fet_beginchar ("Quarter Funk lahead", "s2laFunk");
2291         draw_la_head (funk_notehead_width, funk_notehead_width);
2292         fill p_out;
2293 fet_endchar;
2294
2295
2296 %%%%%%  Funk ti head
2297 %       `Sideways snow cone'.
2298 %       Rotates for all notes.
2299 %
2300 def draw_Funk_ti_head (expr width_factor, thickness_factor) =
2301         set_char_box (0, width_factor * solfa_base_notewidth#,
2302                       0.5 solfa_noteheight#, 0.5 solfa_noteheight#);
2303         save cone_width;
2304         cone_width = 0.8;
2305
2306         save offset;
2307         offset := 2 * thickness_factor - 1;
2308
2309         save pen_radius;
2310         pen_radius := min (solfa_pen_radius,
2311                            .33 * (h + d) / (1 + offset));
2312
2313         pickup pencircle scaled (2 * pen_radius);
2314
2315         lft x1 = 0;
2316         y1 = .5 [y2, y4];
2317
2318         x2 = cone_width [x1, x3];
2319         top y2 = h;
2320
2321         rt x3 = w;
2322         y3 = y1;
2323
2324         x4 = x2;
2325         bot y4 = -d;
2326
2327         save nw_dist, sw_dist, ne, se;
2328         pair nw_dist, sw_dist, ne, se;
2329
2330         ne = unitvector (z2 - z1);
2331         se = unitvector (z4 - z1);
2332
2333         nw_dist = (ne rotated 90) * pen_radius ;
2334         sw_dist = (se rotated -90) * pen_radius;
2335
2336         save path_a, path_b;
2337         path path_a, path_b;
2338         path_a := z1 - nw_dist
2339                   -- z2 - offset * nw_dist;
2340         path_b := z1 - sw_dist
2341                   -- z4 - offset * sw_dist;
2342
2343         save path_right, path_right_in;
2344         path path_right, path_right_in;
2345         path_right := (z2 + ne * pen_radius)
2346                       .. (rt z3){down}
2347                       .. (z4 + se * pen_radius);
2348
2349         path_right_in := (z2 - ne * pen_radius)
2350                          .. lft z3{down}
2351                          .. (z4 - se * pen_radius);
2352
2353         z5 = path_a intersectionpoint path_b;
2354         z6 = path_a intersectionpoint path_right_in;
2355         z7 = path_b intersectionpoint path_right_in;
2356
2357         save p_up_in, p_down_in, p_up_out, p_down_out;
2358         path p_up_in, p_down_in, p_up_out, p_down_out;
2359
2360         p_down_in := z5
2361                      -- z6
2362                      .. lft z3
2363                      .. z7
2364                      -- cycle;
2365
2366         p_down_out := lft z1
2367                       .. (z1 + nw_dist)
2368                       -- (z2 + nw_dist)
2369                       .. top z2
2370                       .. (z2 + ne * pen_radius){direction 0 of path_right}
2371                       & path_right
2372                       & {direction infinity of path_right}(z4 + se * pen_radius)
2373                       .. bot z4
2374                       .. (z4 + sw_dist)
2375                       -- (z1 + sw_dist)
2376                       .. cycle;
2377
2378         p_up_in := p_down_in rotated 180 shifted (w, 0);
2379         p_up_out := p_down_out rotated 180 shifted (w, 0);
2380 enddef;
2381
2382
2383 save funk_ti_weight;
2384 funk_ti_weight := 1.6;
2385
2386 fet_beginchar ("Whole up Funk tihead", "u0tiFunk");
2387         draw_Funk_ti_head (funk_notehead_width, funk_ti_weight);
2388         fill p_up_out;
2389         unfill p_up_in;
2390 fet_endchar;
2391
2392
2393 fet_beginchar ("Whole down Funk tihead", "d0tiFunk");
2394         draw_Funk_ti_head (funk_notehead_width, funk_ti_weight);
2395         fill p_down_out;
2396         unfill p_down_in;
2397 fet_endchar;
2398
2399
2400 fet_beginchar ("Half up Funk tihead", "u1tiFunk");
2401         draw_Funk_ti_head (funk_notehead_width, funk_ti_weight);
2402         fill p_up_out;
2403         unfill p_up_in;
2404 fet_endchar;
2405
2406
2407 fet_beginchar ("Half down Funk tihead", "d1tiFunk");
2408         draw_Funk_ti_head (funk_notehead_width, funk_ti_weight);
2409         fill p_down_out;
2410         unfill p_down_in;
2411 fet_endchar;
2412
2413
2414 fet_beginchar ("Quarter up Funk tihead", "u2tiFunk");
2415         draw_Funk_ti_head (funk_notehead_width, funk_ti_weight);
2416         fill p_up_out;
2417 fet_endchar;
2418
2419
2420 fet_beginchar ("Quarter down Funk tihead", "d2tiFunk");
2421         draw_Funk_ti_head (funk_notehead_width, funk_ti_weight);
2422         fill p_down_out;
2423 fet_endchar;
2424
2425
2426 %%%%%%   Walker shape note heads
2427 %
2428 % Walker heads are narrow like Funk heads, so use funk_notehead_width.
2429 %
2430
2431 %%%%%%   Walker do head
2432 %
2433 % Trapezoid, with largest side on stem side
2434 %
2435 def draw_Walker_do_head (expr width_factor, dir, thickness_factor) =
2436         set_char_box (0, width_factor * solfa_base_notewidth#,
2437                       0.5 solfa_noteheight#, 0.5 solfa_noteheight#);
2438
2439         pickup pencircle scaled solfa_pen_thick;
2440
2441         save offset;
2442         offset := 2 * thickness_factor - 1;
2443
2444         % adjust width so stem can be centered
2445         if .5w <> good.x .5w: change_width; fi
2446
2447         save scaling;
2448
2449         scaling# = charwd / w;
2450
2451         save inset;
2452         inset := 0.25;
2453
2454         x1 = inset [x4, x3];
2455         top y1 = h;
2456
2457         x2 = inset [x3, x4];
2458         y2 = y1;
2459
2460         bot y3 = -d;
2461         rt x3 = w;
2462
2463         y4 = y3;
2464         lft x4 = 0;
2465
2466         labels (range 1 thru 4);
2467
2468         save left_dir, left_perp, right_dir, right_perp;
2469         pair left_dir, left_perp, right_dir, right_perp;
2470
2471         left_dir = unitvector(z1 - z4);
2472         left_perp = (left_dir rotated 90) * solfa_pen_radius;
2473         right_dir = unitvector(z3 - z2);
2474         right_perp = (right_dir rotated 90) * solfa_pen_radius;
2475
2476         save path_a, path_b, path_c, path_d;
2477         path path_a, path_b, path_c, path_d;
2478
2479         path_a := (z4 - left_perp)
2480                   -- (z1 - left_perp);
2481         path_b := (z1 - (0, offset*solfa_pen_radius))
2482                   -- (z2 - (0, offset*solfa_pen_radius));
2483         path_c := (z2 - right_perp)
2484                   -- (z3 - right_perp);
2485         path_d := (z3 + (0, offset*solfa_pen_radius))
2486                   -- (z4 + (0, offset*solfa_pen_radius));
2487
2488         save p_in, p_out;
2489         path p_in, p_out;
2490
2491         p_in := (path_a intersectionpoint path_b)
2492                 -- (path_b intersectionpoint path_c)
2493                 -- (path_c intersectionpoint path_d)
2494                 -- (path_d intersectionpoint path_a)
2495                 -- cycle;
2496
2497         p_out := top z1{right}
2498                  -- top z2{right}
2499                  .. z2 + right_perp {right_dir}
2500                  -- z3 + right_perp {right_dir}
2501                  .. bot z3{left}
2502                  -- bot z4{left}
2503                  .. z4 + left_perp {left_dir}
2504                  .. z1 + left_perp {left_dir}
2505                  .. cycle;
2506
2507         charwx := scaling# * (w/2 + solfa_pen_radius);
2508         charwy := scaling# * y2 ;
2509
2510         if dir = 1:
2511                 p_in := p_in rotated 180 shifted (w,0);
2512                 p_out := p_out rotated 180 shifted (w,0);
2513         fi;
2514 enddef;
2515
2516
2517 save walker_do_weight;
2518 walker_do_weight := 1.5;
2519
2520 fet_beginchar ("Whole Walker dohead", "s0doWalker");
2521         draw_Walker_do_head (funk_notehead_width, 0, walker_do_weight);
2522         fill p_out;
2523         unfill p_in;
2524 fet_endchar;
2525
2526
2527 fet_beginchar ("Half up Walker dohead", "u1doWalker");
2528         draw_Walker_do_head (funk_notehead_width, 1, walker_do_weight);
2529         fill p_out;
2530         unfill p_in;
2531 fet_endchar;
2532
2533
2534 fet_beginchar ("Half down Walker dohead", "d1doWalker");
2535         draw_Walker_do_head (funk_notehead_width, 0, walker_do_weight);
2536         fill p_out;
2537         unfill p_in;
2538 fet_endchar;
2539
2540
2541 fet_beginchar ("Quarter up Walker dohead", "u2doWalker");
2542         draw_Walker_do_head (funk_notehead_width, 1, walker_do_weight);
2543         fill p_out;
2544 fet_endchar;
2545
2546
2547 fet_beginchar ("Quarter down Walker dohead", "d2doWalker");
2548         draw_Walker_do_head (funk_notehead_width, 0, walker_do_weight);
2549         fill p_out;
2550 fet_endchar;
2551
2552
2553 %%%%%%   Walker re head
2554 %          Parabolic on one side, shallow parabola on other
2555 %          Has up and down shapes for *all* notes
2556 %
2557 def draw_Walker_re_head (expr width_factor, thickness_factor) =
2558         set_char_box (0, width_factor * solfa_base_notewidth#,
2559                       0.5 solfa_noteheight#, 0.5 solfa_noteheight#);
2560
2561         save offset;
2562         offset := 2 * thickness_factor - 1;
2563
2564         save pen_radius;
2565         pen_radius := min (solfa_pen_radius,
2566                            .3 * (h + d) / (1 + offset));
2567
2568         pickup pencircle scaled (2 * pen_radius);
2569
2570         save dish_factor;
2571         dish_factor := 0.20;
2572
2573         rt x1 = w;
2574         bot y1 = -d;
2575
2576         lft x2 = 0;
2577         y2 = 0.5 [y1, y3];
2578
2579         top y3 = h;
2580         x3 = x1;
2581
2582         x4 = dish_factor [x1, x2];
2583         y4 = y2;
2584
2585         x5 = x1;
2586         y5 = y1 + offset * pen_radius;
2587
2588         y6 = y2;
2589         x6 = x2 + pen_radius;
2590
2591         x7 = x3;
2592         y7 = y3 - offset * pen_radius;
2593
2594         y8 = y4;
2595         x8 = x4 - pen_radius;
2596
2597         save path_a, path_d;
2598         path path_a, path_d;
2599
2600         save p_a_start_dir, p_a_end_dir, p_a_start_perp, p_a_end_perp;
2601         pair p_a_start_dir, p_a_end_dir, p_a_start_perp, p_a_end_perp;
2602
2603         path_a := z3 .. z4{down} .. z1;
2604
2605         p_a_start_dir := unitvector(direction 0 of path_a);
2606         p_a_end_dir := unitvector(direction infinity of path_a);
2607         p_a_start_perp := (p_a_start_dir rotated 90) * pen_radius;
2608         p_a_end_perp := (p_a_end_dir rotated 90) * pen_radius;
2609
2610         path_d := (z3 - p_a_start_perp){p_a_start_dir}
2611                   .. z4 {down}
2612                   ..(z1 - p_a_end_perp){p_a_end_dir};
2613
2614         save path_b, path_c;
2615         path path_b, path_c;
2616
2617         path_b := z5 {left} .. z6{up};
2618         path_c := z7 {left} .. z6{down};
2619
2620         z9 = path_d intersectionpoint path_b;
2621         z10 = path_d intersectionpoint path_c;
2622
2623         labels (range 1 thru 4);
2624
2625         save p_up_in, p_up_out, p_down_in, p_down_out;
2626         path p_up_in, p_up_out, p_down_in, p_down_out;
2627
2628         p_down_in := z6{up}
2629                      ... {right} z10 {p_a_start_dir}
2630                      .. z8{down}
2631                      .. {p_a_end_dir} z9 {left}
2632                      ... cycle;
2633
2634         p_down_out := lft z2{up}
2635                       .. top z3{right}
2636                       .. rt z3
2637                       .. (z3 + p_a_start_perp){p_a_start_dir}
2638                       .. rt z4{down}
2639                       .. (z1 + p_a_end_perp) {p_a_end_dir}
2640                       .. rt z1
2641                       .. bot z1 {left}
2642                       .. cycle;
2643
2644         p_up_in := p_down_in rotated 180 shifted (w,0);
2645         p_up_out := p_down_out rotated 180 shifted (w,0);
2646 enddef;
2647
2648
2649 save walker_re_weight;
2650 walker_re_weight := 1.2;
2651
2652 fet_beginchar ("Whole Walker rehead", "s0reWalker");
2653         draw_Walker_re_head (funk_notehead_width, walker_re_weight);
2654         fill p_down_out;
2655         unfill p_down_in;
2656 fet_endchar;
2657
2658
2659 fet_beginchar ("Half up Walker rehead", "u1reWalker");
2660         draw_Walker_re_head (funk_notehead_width, walker_re_weight);
2661         fill p_up_out;
2662         unfill p_up_in;
2663 fet_endchar;
2664
2665
2666 fet_beginchar ("Half down Walker rehead", "d1reWalker");
2667         draw_Walker_re_head (funk_notehead_width, walker_re_weight);
2668         fill p_down_out;
2669         unfill p_down_in;
2670 fet_endchar;
2671
2672
2673 fet_beginchar ("Quarter up Walker rehead", "u2reWalker");
2674         draw_Walker_re_head (funk_notehead_width, walker_re_weight);
2675         fill p_up_out;
2676 fet_endchar;
2677
2678
2679 fet_beginchar ("Quarter down Walker rehead", "d2reWalker");
2680         draw_Walker_re_head (funk_notehead_width, walker_re_weight);
2681         fill p_down_out;
2682 fet_endchar;
2683
2684
2685 %%%%%%  Walker mi head
2686 %       Diamond shape
2687 %       Symmetric for all hollow notes
2688 %
2689 save walker_mi_width, walker_mi_weight;
2690 walker_mi_width := 1.2;
2691 walker_mi_weight := 1.5;
2692
2693 fet_beginchar ("Whole Walker mihead", "s0miWalker");
2694         draw_mi_head (walker_mi_width * funk_notehead_width,
2695                       walker_mi_weight, true);
2696         fill path_out;
2697         unfill path_in;
2698 fet_endchar;
2699
2700
2701 fet_beginchar ("Half Walker mihead", "s1miWalker");
2702         draw_mi_head (walker_mi_width * funk_notehead_width,
2703                       walker_mi_weight, true);
2704         fill path_out;
2705         unfill path_in;
2706 fet_endchar;
2707
2708
2709 fet_beginchar ("Quarter Walker mihead", "s2miWalker");
2710         draw_mi_head (walker_mi_width * funk_notehead_width,
2711                       walker_mi_weight, true);
2712         fill path_out;
2713 fet_endchar;
2714
2715
2716 %%%%%%  Walker fa
2717 %       Triangle shape
2718 %       Does not rotate for whole notes
2719 %       Whole rotation is different from Funk, so special notes
2720
2721 %%%%%%  Funk sol head is the same as the others
2722 %       Need special character because of skinnier head
2723 %
2724 save walker_fa_weight;
2725 walker_fa_weight := 1.5;
2726
2727 fet_beginchar ("Whole Walker fahead", "s0faWalker");
2728         draw_fa_head (funk_notehead_width, walker_fa_weight);
2729         fill p_down_out;
2730         unfill p_down_in;
2731 fet_endchar;
2732
2733
2734 fet_beginchar ("Half up Walker fahead", "u1faWalker");
2735         draw_fa_head (funk_notehead_width, walker_fa_weight);
2736         fill p_up_out;
2737         unfill p_up_in;
2738 fet_endchar;
2739
2740
2741 fet_beginchar ("Half down Walker fahead", "d1faWalker");
2742         draw_fa_head (funk_notehead_width, walker_fa_weight);
2743         fill p_down_out;
2744         unfill p_down_in;
2745 fet_endchar;
2746
2747
2748 fet_beginchar ("Quarter up Walker fahead", "u2faWalker");
2749         draw_fa_head (funk_notehead_width, walker_fa_weight);
2750         fill p_up_out;
2751 fet_endchar;
2752
2753
2754 fet_beginchar ("Quarter down Walker fahead", "d2faWalker");
2755         draw_fa_head (funk_notehead_width, walker_fa_weight);
2756         fill p_down_out;
2757 fet_endchar;
2758
2759
2760 %%%%%%  Walker sol
2761 %       Same as Funk, no special notes
2762 %
2763
2764 %%%%%%  Walker la head
2765 %       Rectcangle head
2766 %       Lighter weight requires separate notes
2767 %
2768 save walker_la_weight;
2769 walker_la_weight := 1.5;
2770
2771 fet_beginchar ("Whole Walker lahead", "s0laWalker");
2772         draw_la_head (funk_notehead_width, walker_la_weight);
2773         fill p_out;
2774         unfill p_in;
2775 fet_endchar;
2776
2777
2778 fet_beginchar ("Half Funk lahead", "s1laWalker");
2779         draw_la_head (funk_notehead_width, walker_la_weight);
2780         fill p_out;
2781         unfill p_in;
2782 fet_endchar;
2783
2784
2785 fet_beginchar ("Quarter Funk lahead", "s2laWalker");
2786         draw_la_head (funk_notehead_width, walker_la_weight);
2787         fill p_out;
2788 fet_endchar;
2789
2790
2791 %%%%%%  Walker ti head
2792 %       Triangular arrowhead
2793 %       Rotates for all but whole notes
2794 %
2795 def draw_Walker_ti_head (expr width_factor, thickness_factor) =
2796         set_char_box (0, width_factor * solfa_base_notewidth#,
2797                       0.5 solfa_noteheight#, 0.5 solfa_noteheight#);
2798
2799         save offset;
2800         offset := 2 * thickness_factor - 1;
2801
2802         save pen_radius;
2803         pen_radius := min (solfa_pen_radius,
2804                            .3 * (h + d) / (1 + offset));
2805
2806         pickup pencircle scaled (2 * pen_radius);
2807
2808         lft x1 = 0;
2809         y1 = .5 [y2, y3];
2810
2811         rt x2 = w;
2812         top y2 = h;
2813
2814         x3 = x2;
2815         bot y3 = -d;
2816
2817
2818         labels (range 1 thru 4);
2819
2820         save nw_dist, sw_dist, ne, se;
2821         pair nw_dist, sw_dist, ne, se;
2822
2823         ne = unitvector (z2 - z1);
2824         se = unitvector (z3 - z1);
2825
2826         nw_dist = (ne rotated 90) * pen_radius ;
2827         sw_dist = (se rotated -90) * pen_radius;
2828
2829
2830         save path_a, path_b, path_c;
2831         path path_a, path_b, path_c;
2832         path_a := z2 - nw_dist * offset
2833                   -- z1 - nw_dist * offset;
2834         path_b := z3 - sw_dist * offset
2835                   -- z1 - sw_dist * offset;
2836         path_c := z2 + left * pen_radius
2837                   -- z3 + left * pen_radius;
2838
2839         z4 = path_a intersectionpoint path_b;
2840         z5 = path_a intersectionpoint path_c;
2841         z6 = path_b intersectionpoint path_c;
2842
2843         save p_up_in, p_down_in, p_up_out, p_down_out;
2844         path p_up_in, p_down_in, p_up_out, p_down_out;
2845
2846         p_down_in := z4
2847                      -- z5
2848                      -- z6
2849                      -- cycle;
2850
2851         p_down_out := lft z1{up}
2852                       .. (z1 + nw_dist){ne}
2853                       -- (z2 + nw_dist){ne}
2854                       .. top z2{right}
2855                       .. rt z2 {down}
2856                       -- rt z3 {down}
2857                       .. bot z3 {left}
2858                       .. (z3 + sw_dist){- se}
2859                       .. (z1 + sw_dist){- se}
2860                       .. cycle;
2861
2862         p_up_in := p_down_in rotated 180 shifted (w, 0);
2863         p_up_out := p_down_out rotated 180 shifted (w, 0);
2864 enddef;
2865
2866
2867 save walker_ti_weight;
2868 walker_ti_weight := 1.4;
2869
2870 fet_beginchar ("Whole Walker tihead", "s0tiWalker");
2871         draw_Walker_ti_head (funk_notehead_width, walker_ti_weight);
2872         fill p_down_out;
2873         unfill p_down_in;
2874 fet_endchar;
2875
2876
2877 fet_beginchar ("Half up Walker tihead", "u1tiWalker");
2878         draw_Walker_ti_head (funk_notehead_width, walker_ti_weight);
2879         fill p_up_out;
2880         unfill p_up_in;
2881 fet_endchar;
2882
2883
2884 fet_beginchar ("Half down Walker tihead", "d1tiWalker");
2885         draw_Walker_ti_head (funk_notehead_width, walker_ti_weight);
2886         fill p_down_out;
2887         unfill p_down_in;
2888 fet_endchar;
2889
2890
2891 fet_beginchar ("Quarter up Walker tihead", "u2tiWalker");
2892         draw_Walker_ti_head (funk_notehead_width, walker_ti_weight);
2893         fill p_up_out;
2894 fet_endchar;
2895
2896
2897 fet_beginchar ("Quarter down Walker tihead", "d2tiWalker");
2898         draw_Walker_ti_head (funk_notehead_width, walker_ti_weight);
2899         fill p_down_out;
2900 fet_endchar;
2901
2902 fet_endgroup ("noteheads");
2903
2904
2905 %
2906 % we derive black_notehead_width# from the quarter head,
2907 % so we have to define black_notehead_width (pixel qty)
2908 % after the black_notehead_width# itself.
2909 %
2910 % Let's keep it outside the group as well.
2911 %
2912
2913 define_pixels (black_notehead_width);