LilyPond-Ruby 0.0.2.1 → 0.1.2

data/share/lilypond/2.24.1/fonts/source/feta-macros.mf

@@ -0,0 +1,506 @@
+% Feta (not the Font-En-Tja) music font -- auxiliary macros for both feta and parmesan fonts
+% This file is part of LilyPond, the GNU music typesetter.
+%
+% Copyright (C) 1997--2022 Han-Wen Nienhuys <hanwen@xs4all.nl>
+%
+% The LilyPond font is free software: you can redistribute it and/or modify
+% it under the terms of the GNU General Public License as published by
+% the Free Software Foundation, either version 3 of the License, or
+% (at your option) any later version, or under the SIL Open Font License.
+%
+% LilyPond is distributed in the hope that it will be useful,
+% but WITHOUT ANY WARRANTY; without even the implied warranty of
+% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+% GNU General Public License for more details.
+%
+% You should have received a copy of the GNU General Public License
+% along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
+
+
+%
+% debugging
+%
+
+
+def print_penpos (suffix $) =
+  message
+    "z" & str$ & "l = (" & decimal x.$.l & ", " &decimal y.$.l & ");"
+    & " z" & str$ & "r = (" & decimal x.$.r & ", " & decimal y.$.r & ");";
+enddef;
+
+
+def test_grid =
+  if test > 1:
+    proofrulethickness 1pt#;
+
+    makegrid
+      (0pt, 0pt for i := -5pt step 1pt until 5pt: , i endfor)
+      (0pt, 0pt for i := -5pt step 1pt until 5pt: , i endfor);
+
+    proofrulethickness .1pt#;
+
+    makegrid
+      (0pt, 0pt for i := -4.8pt step .2pt until 4.8pt: , i endfor)
+      (0pt, 0pt for i := -4.8pt step .2pt until 4.8pt: , i endfor);
+  fi;
+enddef;
+
+
+def treq =
+  tracingequations := tracingonline := 1;
+enddef;
+
+
+def draw_staff_if_debugging (expr first, last) =
+  if test <> 0:
+    pickup pencircle scaled stafflinethickness;
+
+    for i := first step 1 until last:
+      draw (-staff_space,
+            (i + stafflines_y_offset) * staff_space_rounded)
+           -- (4 staff_space,
+               (i + stafflines_y_offset) * staff_space_rounded);
+    endfor;
+  fi;
+enddef;
+
+
+%
+% Draw the outline of the stafflines.  For fine tuning.
+%
+
+def draw_staff_outline (expr first, last, offset) =
+  if test <> 0:
+    save p;
+    path p;
+
+    pickup pencircle scaled 2;
+
+    for i := first step 1 until last:
+      p := (-staff_space,
+            (i + offset) * staff_space_rounded)
+           -- (4 staff_space,
+               (i + offset) * staff_space_rounded);
+
+      draw p shifted (0, .5 stafflinethickness);
+      draw p shifted (0, -.5 stafflinethickness);
+    endfor;
+  fi;
+enddef;
+
+
+%
+% Transformations
+%
+
+def scaledabout (expr point, scale) =
+  shifted -point scaled scale shifted point
+enddef;
+
+
+%
+% make a local (restored after endgroup) copy of t_var
+%
+
+def local_copy (text type, t_var) =
+  save copy_temp;
+  type copy_temp;
+  copy_temp := t_var;
+  save t_var;
+  type t_var;
+  t_var := copy_temp;
+enddef;
+
+
+%
+% Urgh! Want to do parametric types
+%
+
+def del_picture_stack =
+  save save_picture_stack, picture_stack_idx;
+enddef;
+
+
+%
+% better versions of Taupin/Egler savepic cmds
+%
+
+def make_picture_stack =
+  % override previous stack
+  del_picture_stack;
+  picture save_picture_stack[];
+  numeric picture_stack_idx;
+  picture_stack_idx := 0;
+
+  def push_picture (expr p) =
+    save_picture_stack[picture_stack_idx] := p;
+    picture_stack_idx := picture_stack_idx + 1;
+  enddef;
+
+  def pop_picture = save_picture_stack[decr picture_stack_idx] enddef;
+  def top_picture = save_picture_stack[picture_stack_idx] enddef;
+enddef;
+
+
+%
+% save/restore pens
+% why can't I delete individual pens?
+%
+
+def make_pen_stack =
+  del_pen_stack;
+  pen save_pen_stack[];
+  numeric pen_stack_idx;
+  pen_stack_idx := 0;
+  def push_pen (expr p) =
+    save_pen_stack[pen_stack_idx] := p;
+    pen_stack_idx := pen_stack_idx + 1;
+  enddef;
+  def pop_pen = save_pen_stack[decr pen_stack_idx] enddef;
+  def top_pen = save_pen_stack[pen_stack_idx] enddef;
+enddef;
+
+
+def del_pen_stack =
+  save save_pen_stack, pen_stack_idx;
+enddef;
+
+
+%
+% drawing
+%
+
+def soft_penstroke text t =
+  forsuffixes e = l, r:
+    path_.e := t;
+  endfor;
+
+  if cycle path_.l:
+    cyclestroke_;
+  else:
+    fill path_.l
+         ..tension1.5.. reverse path_.r
+         ..tension1.5.. cycle;
+  fi;
+enddef;
+
+
+def soft_start_penstroke text t =
+  forsuffixes e = l, r:
+    path_.e := t;
+  endfor;
+
+  if cycle path_.l:
+    cyclestroke_;
+  else:
+    fill path_.l
+         -- reverse path_.r
+         ..tension1.5.. cycle;
+  fi;
+enddef;
+
+
+def soft_end_penstroke text t =
+  forsuffixes e = l, r:
+    path_.e := t;
+  endfor;
+
+  if cycle path_.l:
+    cyclestroke_;
+  else:
+    fill path_.l
+         ..tension1.5.. reverse path_.r
+         -- cycle;
+  fi;
+enddef;
+
+
+%
+% Make a round path segment going from P to Q.  2*A is the angle that the
+% path should take.
+%
+
+def simple_serif (expr p, q, a) =
+  p{dir (angle (q - p) - a)}
+  .. q{-dir (angle (p - q) + a)}
+enddef;
+
+
+%
+% Draw an axis aligned block making sure that edges are on pixels.
+%
+
+def draw_rounded_block (expr bottom_left, top_right, roundness) =
+  begingroup;
+    save size;
+    save x, y;
+
+    % Originally, there was `floor' instead of `round', but this is
+    % not correct because pens use `round' also.
+    size = round min (roundness,
+                      xpart (top_right - bottom_left),
+                      ypart (top_right - bottom_left));
+
+    z2 + (size / 2, size / 2) = top_right;
+    z4 - (size / 2, size / 2) = bottom_left;
+    y3 = y2;
+    y4 = y1;
+    x2 = x1;
+    x4 = x3;
+
+    pickup pencircle scaled size;
+
+    fill bot z1{right}
+         .. rt z1{up}
+         -- rt z2{up}
+         .. top z2{left}
+         -- top z3{left}
+         .. lft z3{down}
+         -- lft z4{down}
+         .. bot z4{right}
+         -- cycle;
+  endgroup;
+enddef;
+
+
+def draw_block (expr bottom_left, top_right) =
+  draw_rounded_block (bottom_left, top_right, blot_diameter);
+enddef;
+
+
+def draw_square_block (expr bottom_left, top_right) =
+  save x, y;
+
+  x1 = xpart bottom_left;
+  y1 = ypart bottom_left;
+  x2 = xpart top_right;
+  y2 = ypart top_right;
+
+  fill (x1, y1)
+       -- (x2, y1)
+       -- (x2, y2)
+       -- (x1, y2)
+       -- cycle;
+enddef;
+
+
+def draw_gridline (expr bottom_left, top_right, thickness) =
+  draw_rounded_block (bottom_left - (thickness / 2, thickness / 2),
+                      top_right + (thickness / 2, thickness / 2),
+                      thickness);
+enddef;
+
+
+def draw_brush (expr a, w, b, v, show_labels) =
+  save x, y;
+
+  z1' = a;
+  z2' = b;
+  z3' = z4' = z1';
+  z5' = z6' = z2';
+
+  penpos3' (w, angle (z2' - z1') + 90);
+  penpos4' (w, angle (z2' - z1'));
+  penpos5' (v, angle (z1' - z2') + 90);
+  penpos6' (v, angle (z1' - z2'));
+
+  if show_labels = 1:
+    labels (1', 2');
+    penlabels (3', 4', 5', 6');
+  fi;
+
+  fill z3'r{z3'r - z5'l}
+       .. z4'l
+       .. {z5'r - z3'l}z3'l
+       .. z5'r{z5'r - z3'l}
+       .. z6'l
+       .. {z3'r - z5'l}z5'l
+       .. cycle;
+enddef;
+
+
+%
+% Make a superellipsoid segment going from FROM to TO, with SUPERNESS.
+% Take superness = sqrt(2)/2 to get a circle segment.
+%
+% See Knuth, p. 267 and p.126.
+
+def super_curvelet (expr from, to, superness, dir) =
+  if dir = 1:
+    (superness [xpart to, xpart from],
+     superness [ypart from, ypart to]){to - from}
+  else:
+    (superness [xpart from, xpart to],
+     superness [ypart to, ypart from]){to - from}
+  fi
+enddef;
+
+
+%
+% Bulb with smooth inside curve.
+%
+% alpha = start direction
+% beta = which side to turn to
+% flare = diameter of the bulb
+% line = diameter of line attachment
+% direction = is ink on left or right side (1 or -1)
+%
+% Note that `currentpen' must be set correctly -- only circular pens
+% are supported properly.
+
+def flare_path (expr pos, alpha, beta, line, flare, direction) =
+  begingroup;
+    save thick;
+
+    thick = pen_top + pen_bot;
+
+    clearxy;
+
+    penpos1' (line - thick, 180 + beta + alpha);
+    top z1'r = pos;
+
+    penpos2' (flare - thick, 180 + beta + alpha);
+    z2' = z3';
+
+    penpos3' (flare - thick, 0 + alpha);
+    rt x3'l = hround (x1'r
+                      + (1/2 + 0.43) * flare * xpart dir (alpha + beta));
+    bot y2'l = vround (y1'r
+                       + (1 + 0.43) * flare * ypart dir (alpha + beta));
+
+    rt x4' = x2'r - line * xpart dir (alpha);
+    y4' = y2'r - line * ypart dir (alpha);
+
+    penlabels (1', 2', 3', 4');
+
+    save t, p;
+    t = 0.833;
+    path p;
+
+    p := z1'r{dir (alpha)}
+         .. z3'r{dir (180 + alpha - beta)}
+         .. z2'l{dir (alpha + 180)}
+         .. z3'l{dir (180 + alpha + beta)}
+         ..tension t.. z4'{dir (180 + alpha + beta)}
+         .. z1'l{dir (alpha + 180)};
+
+    if direction <> 1:
+      p := reverse p;
+    fi;
+
+    p
+  endgroup
+enddef;
+
+
+%
+% Draw a (rest) crook, starting at thickness STEM in point A,
+% ending a ball W to the left, diameter BALLDIAM.
+% ypart of the center of the ball is BALLDIAM/4 lower than ypart A.
+%
+
+def balled_crook (expr a, w, balldiam, stem) =
+  begingroup;
+    save x, y;
+
+    penpos1 (balldiam / 2, -90);
+    penpos2 (balldiam / 2, 0);
+    penpos3 (balldiam / 2, 90);
+    penpos4 (balldiam / 2, 180);
+
+    x4r = xpart a - w;
+    y3r = ypart a + balldiam / 4;
+    x1l = x2l = x3l = x4l;
+    y1l = y2l = y3l = y4l;
+
+    penpos5 (stem, 250);
+    x5 = x4r + 9/8 balldiam;
+    y5r = y1r;
+
+    penpos6 (stem, 260);
+    x6l = xpart a;
+    y6l = ypart a;
+
+    penstroke z1e
+              .. z2e
+              .. z3e
+              .. z4e
+              .. z1e
+              .. z5e{right}
+              .. z6e;
+
+    penlabels (1, 2, 3, 4, 5, 6);
+  endgroup;
+enddef;
+
+
+def y_mirror_char =
+  currentpicture := currentpicture yscaled -1;
+
+  set_char_box (charbp, charwd, charht, chardp);
+enddef;
+
+
+def xy_mirror_char =
+  currentpicture := currentpicture scaled -1;
+
+  set_char_box (charwd, charbp, charht, chardp);
+enddef;
+
+
+%
+% center_factor: typically .5; the larger, the larger the radius of the bulb
+% radius factor: how much the bulb curves inward
+%
+
+def draw_bulb (expr turndir, zl, zr, bulb_rad, radius_factor) =
+  begingroup;
+    save rad, ang, pat;
+    path pat;
+
+    clearxy;
+
+    ang = angle (zr - zl);
+
+    % don't get near infinity
+    % z0 = zr + bulb_rad * (zl - zr) / length (zr - zl);
+    z0' = zr + bulb_rad / length (zr - zl) * (zl - zr);
+
+    rad = bulb_rad;
+
+    z1' = z0' + radius_factor * rad * dir (ang + turndir * 100);
+    z2' = z0' + rad * dir (ang + turndir * 300);
+
+    labels (0', 1', 2');
+
+    pat = zr{dir (ang + turndir * 90)}
+          .. z1'
+          .. z2'
+          .. cycle;
+
+    % avoid grazing outlines
+    fill subpath (0, 2.5) of pat
+         -- cycle;
+  endgroup
+enddef;
+
+
+pi := 3.14159;
+
+
+%
+% To get symmetry at low resolutions we need to shift some points and
+% paths, but not if mf2pt1 is used.
+%
+
+if known miterlimit:
+  vardef hfloor primary x = x enddef;
+  vardef vfloor primary y = y enddef;
+  vardef hceiling primary x = x enddef;
+  vardef vceiling primary y = y enddef;
+else:
+  vardef hfloor primary x = floor x enddef;
+  vardef vfloor primary y = (floor y.o_)_o_ enddef;
+  vardef hceiling primary x = ceiling x enddef;
+  vardef vceiling primary y = (ceiling y.o_)_o_ enddef;
+fi;

data/share/lilypond/2.24.1/fonts/source/feta-naturals.mf

@@ -0,0 +1,223 @@
+% Feta (not the Font-En-Tja) music font --  Accidentals
+% This file is part of LilyPond, the GNU music typesetter.
+%
+% Copyright (C) 1997--2022 Han-Wen Nienhuys <hanwen@xs4all.nl>
+% Copyright (C) 2013--2022 Janek Warchoł <lemniskata.bernoullego@gmail.com>
+%
+% The LilyPond font is free software: you can redistribute it and/or modify
+% it under the terms of the GNU General Public License as published by
+% the Free Software Foundation, either version 3 of the License, or
+% (at your option) any later version, or you can redistribute it under
+% the SIL Open Font License.
+%
+% LilyPond is distributed in the hope that it will be useful,
+% but WITHOUT ANY WARRANTY; without even the implied warranty of
+% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+% GNU General Public License for more details.
+%
+% You should have received a copy of the GNU General Public License
+% along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
+
+%
+% The stems of the natural are brushed (at least, in Barenreiter SCS)
+%
+
+% general parameters:
+save stem_thickness, stem_end_thickness_multiplier;
+save beam_thickness, beam_slant;
+
+stem_thickness# := 0.09 staff_space# + 0.5 stafflinethickness#;
+stem_end_thickness_multiplier := 10/7;
+beam_slant := 1.266 stafflinethickness;
+beam_thickness := 0.485 staff_space -  stafflinethickness;
+
+
+def draw_natural (expr arrowup, arrowdown, figured_bass) =
+  save depth, height, width, breapth;
+  save full_width, full_height;
+  save offset;
+  save hole_highest_point;
+  save upstem_factor, downstem_factor;
+  save upstem_end_thickness, downstem_end_thickness;
+  save half_height, half_box_height;
+  save beam_direction, r_stem_top_path, l_stem_bottom_path;
+  pair beam_direction;
+  path r_stem_top_path, l_stem_bottom_path;
+
+  upstem_factor = downstem_factor = stem_end_thickness_multiplier;
+
+  if figured_bass:
+    full_height# := number_design_size + 2 figbass_y#;
+    full_width# := .7 figbass_width#;
+    offset# := .5 number_design_size;
+    width# := figbass_width#;
+
+    hole_highest_point := 0.2 staff_space + stafflinethickness;
+  else:
+    full_height# := 3 staff_space#;
+    full_width# := 2/3 staff_space#;
+    offset# := 0;
+    width# := full_width#;
+
+    hole_highest_point := 0.5 (staff_space - stafflinethickness);
+  fi;
+  define_pixels (offset);
+
+  half_height# := 0.5 full_height#;
+  define_pixels (half_height);
+  define_whole_pixels (full_width);
+
+  depth# := half_height# - offset#;
+  height# := half_height# + offset#;
+  breapth# := 0;
+
+  if arrowup:
+    % synchronized with point z4 of the arrow
+    height# := half_height#                               % y1
+               + .1 staff_space# + .5 stafflinethickness# % upshift
+               + .85 staff_space# + stafflinethickness#;  % htip
+    breapth# := .3 staff_space# - .5 stem_thickness#;
+    % to look nice, arrowed stems must be less brushed
+    upstem_factor := 0.5 (1 + upstem_factor);
+  fi;
+  if arrowdown:
+    % synchronized with point z4 of the arrow
+    depth# := half_height#                               % y3
+              + .1 staff_space# + .5 stafflinethickness# % upshift
+              + .85 staff_space# + stafflinethickness#;  % htip
+    width# := width# + .3 staff_space# - .5 stem_thickness#;
+    % to look nice, arrowed stems must be less brushed
+    downstem_factor := 0.5 (1 + downstem_factor);
+  fi;
+
+  set_char_box (breapth#, width#, depth#, height#);
+  d := d - feta_space_shift;
+
+  upstem_end_thickness# = upstem_factor * stem_thickness#;
+  downstem_end_thickness# = downstem_factor * stem_thickness#;
+  define_whole_blacker_pixels (upstem_end_thickness, downstem_end_thickness);
+  define_whole_blacker_pixels (stem_thickness);
+
+  if odd (upstem_end_thickness - stem_thickness):
+    upstem_end_thickness := upstem_end_thickness - 1;
+  fi;
+  if odd (downstem_end_thickness - stem_thickness):
+    downstem_end_thickness := downstem_end_thickness - 1;
+  fi;
+
+  half_box_height := hole_highest_point + beam_thickness
+                     %% correction for the fact that x11 != x12.
+                     %% ideally y2 should be calculated from y11
+                     %% and beam_thickness, but the brushed stems
+                     %% would cause a cyclic dependency:
+                     %% y2 -> x11 -> y14 -> y13 -> y12 -> y2
+                     + 0.5 stem_thickness * beam_slant / full_width;
+
+  %% stems:
+
+  pickup pencircle scaled stem_thickness;
+
+  penpos1 (upstem_end_thickness, 0);
+  penpos3 (downstem_end_thickness, 0);
+  penpos2 (stem_thickness, 0);
+  penpos4 (stem_thickness, 0);
+
+  x2r = w - (w - full_width) / 2;
+  x4l = (w - full_width) / 2;
+  x3 = x2;
+  x1 = x4;
+
+  y1 = half_height + offset;
+  y3 = -half_height + offset;
+  top y2 = vround (half_box_height + offset);
+  bot y4 = vround (-half_box_height + offset) + feta_space_shift;
+
+  l_stem_bottom_path := z4r{z4r - z1r}
+                        .. bot z4
+                        .. z4l{z1l - z4l};
+
+  r_stem_top_path := z2r{z2r - z3r}
+                     .. top z2
+                     .. z2l{z3l - z2l};
+
+  fill simple_serif (z1l, z1r, -30)
+       -- l_stem_bottom_path
+       -- cycle;
+
+  fill simple_serif (z3l, z3r, 30)
+       -- r_stem_top_path
+       -- cycle;
+
+  %% beams:
+
+  beam_direction = (full_width, beam_slant);
+
+  z11 = z3l + whatever * (z2l - z3l);
+  y11 = vround (hole_highest_point + offset);
+  z12 = directionpoint -beam_direction of r_stem_top_path;
+  z13 = z12 + whatever * beam_direction;
+  x13 = x1;
+  z14 = z11 + whatever * beam_direction;
+  x14 = x1;
+
+  z21 = z4r + whatever * (z1r - z4r);
+  y21 = vround (-hole_highest_point + offset) + feta_space_shift;
+  z22 = directionpoint -beam_direction of l_stem_bottom_path;
+  z23 = z22 + whatever * beam_direction;
+  x23 = x3;
+  z24 = z21 + whatever * beam_direction;
+  x24 = x3;
+
+  fill z11
+       -- z12
+       -- z13
+       -- z14
+       -- cycle;
+
+  fill z21
+       -- z22
+       -- z23
+       -- z24
+       -- cycle;
+
+  if arrowup:
+    fill draw_arrow (z1, upstem_end_thickness,
+                     z1l - z4l, stafflinethickness / 2, false)
+         -- cycle;
+  fi;
+  if arrowdown:
+    fill draw_arrow (z3, downstem_end_thickness,
+                     z2r - z3r, stafflinethickness / 2, true)
+         -- cycle;
+  fi;
+
+  %% debugging:
+  penlabels (1, 2, 3, 4);
+  labels (11, 12, 13, 14, 21, 22, 23, 24);
+  draw_staff_if_debugging (-2, 2);
+enddef;
+
+
+fet_beginchar ("natural", "natural");
+  draw_natural (false, false, false);
+fet_endchar;
+
+
+fet_beginchar ("figured bass natural", "natural.figbass");
+  draw_natural (false, false, true);
+fet_endchar;
+
+
+fet_beginchar ("arrowed natural (arrow up)", "natural.arrowup");
+  draw_natural (true, false, false);
+fet_endchar;
+
+
+fet_beginchar ("arrowed natural (arrow down)", "natural.arrowdown");
+  draw_natural (false, true, false);
+fet_endchar;
+
+
+fet_beginchar ("arrowed natural (arrows up and down)", "natural.arrowboth");
+  draw_natural (true, true, false);
+fet_endchar;