mirror of
https://github.com/be5invis/Iosevka.git
synced 2026-10-28 08:28:01 +00:00
1026 lines
50 KiB
Plaintext
1026 lines
50 KiB
Plaintext
###### GEOMETRIC SHAPES
|
|
$$include '../meta/macros.ptl'
|
|
|
|
import '../support/transform' as : Transform && [object [transformPoint tp] [untransform utp] inverse]
|
|
import [mix linreg clamp fallback] from '../support/utils'
|
|
import [designParameters] from '../meta/aesthetics'
|
|
|
|
export : define [apply] : begin
|
|
glyph-module-entry commonShapes overmarks
|
|
|
|
define WidthKinds {{'.hwid' WIDTH}}
|
|
if (para.spacing > 0) : WidthKinds.push {'.fwid' FULLWIDTH0}
|
|
|
|
local exportArrowShape nothing
|
|
|
|
### Arrowheads
|
|
foreach {suffix MosaicWidth} [items-of WidthKinds] : do 'Arrows'
|
|
define [MangleUnicode unicode] : if (MosaicWidth == FULLWIDTH2) unicode nothing
|
|
define [MangleName name] : name + suffix
|
|
|
|
define arrowHeight : para.arrowSize * (WIDTH - SB)
|
|
define arrowWidth : Math.min (MosaicWidth - SB) arrowHeight
|
|
define arrowMidX : MosaicWidth / 2
|
|
define arrowSB : (MosaicWidth - arrowWidth) / 2
|
|
define arrowRSB : MosaicWidth - arrowSB
|
|
define hwArrowRSB : WIDTH - arrowSB
|
|
define hwArrowMidX : WIDTH / 2
|
|
define o : O * 2
|
|
|
|
local arrowSize : (RIGHTSB - arrowSB) * designParameters.arrow_size * [Math.pow (arrowWidth / WIDTH) 0.4]
|
|
local halfstroke : OPERATORSTROKE / 2
|
|
local fine : adviceBlackness 4
|
|
local terminal : adviceBlackness 6
|
|
local arrowTop : [mix operBot operTop (1 / 2)] + arrowHeight / 2
|
|
local arrowBot : [mix operBot operTop (1 / 2)] - arrowHeight / 2
|
|
local doubleArrowStemWidth : arrowSize * 1.1
|
|
|
|
define [ArrowBar x1 y1 x2 y2 halfstroke w] : glyph-construction
|
|
local mag : Math.hypot (y2 - y1) (x2 - x1)
|
|
local p : (mag - o - halfstroke * [fallback w 1.1]) / mag
|
|
include : dispiro
|
|
widths.center (halfstroke * 2)
|
|
flat x1 y1
|
|
curl [mix x1 x2 p] [mix y1 y2 p]
|
|
end : function [set this.contrast 1]
|
|
|
|
define [DashArrowBar x1 y1 x2 y2 halfstroke gap stop w] : glyph-construction
|
|
local mag : Math.hypot (y2 - y1) (x2 - x1)
|
|
local p : (mag - o - halfstroke * [fallback w 1.1]) / mag
|
|
local deltaT : (gap + stop) / mag
|
|
for [local t 0] (t < p) [set t : t + deltaT] : include : dispiro
|
|
widths.center (halfstroke * 2)
|
|
flat [mix x1 x2 t] [mix y1 y2 t]
|
|
curl [mix x1 x2 : Math.min p (t + stop / mag)] [mix y1 y2 : Math.min p (t + stop / mag)]
|
|
end : function [set this.contrast 1]
|
|
|
|
define [HookArrowBar x1 y1 x2 y2 halfstroke s w] : glyph-construction
|
|
local mag : Math.hypot (y2 - y1) (x2 - x1)
|
|
local p : (mag - o - halfstroke * [fallback w 1.1]) / mag
|
|
include : dispiro
|
|
widths.center (halfstroke * 2)
|
|
g4 (mag - [Math.abs s] / 2 - 0.1) s
|
|
g4 (mag - [Math.abs s] / 2) s
|
|
archv
|
|
g4 (mag - O) (s / 2)
|
|
arcvh
|
|
flat (mag - [Math.abs s] / 2) 0
|
|
curl [mix mag 0 p] 0
|
|
end : function [set this.contrast 1]
|
|
|
|
define [PointingTo x1 y1 x2 y2 oo F] : glyph-construction
|
|
local giz this.gizmo
|
|
local g : create-glyph : glyph-construction
|
|
set this.gizmo : Translate 0 0
|
|
include F
|
|
apply-transform : Translate oo 0
|
|
local {.x xo .y yo} : tp giz {.x x1 .y y1}
|
|
local {.x xt .y yt} : tp giz {.x x2 .y y2}
|
|
apply-transform : Rotate : Math.atan2 (yo - yt) (xo - xt)
|
|
apply-transform : Translate xt yt
|
|
include g
|
|
|
|
define [ArrowHead x1 y1 x2 y2 _size] : create-glyph : glyph-construction
|
|
include : LHSHalfArrowHead x1 y1 x2 y2 0 _size
|
|
include : RHSHalfArrowHead x1 y1 x2 y2 0 _size
|
|
|
|
define [RHSHalfArrowHead x1 y1 x2 y2 width _size] : create-glyph : glyph-construction
|
|
local size : fallback _size arrowSize
|
|
include : PointingTo x1 y1 x2 y2 O : dispiro
|
|
function [set this.gizmo [Transform.Id]]
|
|
widths.rhs fine
|
|
flat (o) (-width / 2) [heading UPWARD]
|
|
curl (o + size) size [widths.rhs terminal]
|
|
end : function [set this.contrast 1]
|
|
|
|
define [LHSHalfArrowHead x1 y1 x2 y2 width _size] : create-glyph : glyph-construction
|
|
local size : fallback _size arrowSize
|
|
include : PointingTo x1 y1 x2 y2 O : dispiro
|
|
function [set this.gizmo [Transform.Id]]
|
|
widths.lhs fine
|
|
flat (o) (width / 2) [heading DOWNWARD]
|
|
curl (o + size) (-size) [widths.lhs terminal]
|
|
end : function [set this.contrast 1]
|
|
|
|
define [TriangleArrowHead x1 y1 x2 y2 width length] : create-glyph : glyph-construction
|
|
include : PointingTo x1 y1 x2 y2 O : spiro-outline
|
|
corner o 0
|
|
corner length (width - o)
|
|
corner length (-width + o)
|
|
|
|
define [ArrowShape x1 y1 x2 y2 size] : glyph-construction
|
|
include : ArrowHead x1 y1 x2 y2 size
|
|
include : ArrowBar x1 y1 x2 y2 halfstroke
|
|
define [DashArrowShape x1 y1 x2 y2 size] : glyph-construction
|
|
local gap : adviceBlackness 6
|
|
include : ArrowHead x1 y1 x2 y2 size
|
|
include : DashArrowBar x1 y1 x2 y2 halfstroke gap [Math.max (WIDTH / 5) (gap * 3)]
|
|
|
|
define [HookArrowShape mul] : lambda [x1 y1 x2 y2 size] : glyph-construction
|
|
include : ArrowHead x1 y1 x2 y2 size
|
|
include : PointingTo x1 y1 x2 y2 0 : HookArrowBar x1 y1 x2 y2 halfstroke (arrowSize * mul)
|
|
|
|
define [ThickArrowShape color] : lambda [x1 y1 x2 y2] : glyph-construction
|
|
local headLen : WIDTH * 0.4
|
|
local halfBarWidth : headLen / 3
|
|
local headWidth : halfBarWidth * 2
|
|
|
|
local fine : Math.min [adviceBlackness 5] (halfBarWidth * 0.4)
|
|
local mag : Math.hypot (y2 - y1) (x2 - x1)
|
|
local p : (mag - fine) / mag
|
|
local p2 : (mag - fine * [Math.sqrt 13] / 2) / mag
|
|
local innerHeaderLengthShrink : fine * (1 + [Math.sqrt 13] / 2)
|
|
|
|
local x1a : mix x1 x2 (1 - p)
|
|
local y1a : mix y1 y2 (1 - p)
|
|
local x2a : mix x1 x2 p2
|
|
local y2a : mix y1 y2 p2
|
|
|
|
if (color == "white") : include : difference
|
|
union
|
|
TriangleArrowHead x1 y1 x2 y2 headWidth headLen
|
|
ArrowBar x1 y1 x2 y2 halfBarWidth 2
|
|
union
|
|
TriangleArrowHead x1a y1a x2a y2a (headWidth - innerHeaderLengthShrink * headWidth / headLen) (headLen - innerHeaderLengthShrink)
|
|
ArrowBar x1a y1a x2a y2a (halfBarWidth - fine) 2
|
|
|
|
if (color == "black") : include : union
|
|
TriangleArrowHead x1 y1 x2 y2 headWidth headLen
|
|
ArrowBar x1 y1 x2 y2 halfBarWidth 2
|
|
|
|
define [HalfArrowShape side] : lambda [x1 y1 x2 y2 size] : glyph-construction
|
|
include : side x1 y1 x2 y2 (halfstroke * 2) size
|
|
include : ArrowBar x1 y1 x2 y2 halfstroke 1.5
|
|
|
|
define [DoubleArrowShape w] : lambda [x1 y1 x2 y2 size] : glyph-construction
|
|
include : ArrowHead x1 y1 x2 y2 size
|
|
|
|
local giz this.gizmo
|
|
local {.x xo .y yo} : tp giz {.x x1 .y y1}
|
|
local {.x xt .y yt} : tp giz {.x x2 .y y2}
|
|
|
|
local mag : Math.hypot (yt - yo) (xt - xo)
|
|
local p : (mag - o - w / 2 + O) / mag
|
|
|
|
local fine : Math.min (w / 3) (halfstroke * 2)
|
|
local coFine : w / 2 - fine / 2
|
|
|
|
local G : dispiro
|
|
disable-gizmo
|
|
disable-contrast
|
|
widths.center fine
|
|
# begin
|
|
flat xo yo
|
|
curl [mix xo xt p] [mix yo yt p]
|
|
end
|
|
local g : G.call currentGlyph "don't include"
|
|
# double arrowstick
|
|
g.include : Translate (-xo) (-yo)
|
|
g.include : Rotate (- [Math.atan2 (yt - yo) (xt - xo)])
|
|
include : Translate (-xo) (-yo)
|
|
include : Rotate (- [Math.atan2 (yt - yo) (xt - xo)])
|
|
include : Translate 0 (-coFine)
|
|
include g
|
|
include : Translate 0 (2 * coFine)
|
|
include g
|
|
include : Translate 0 (-coFine)
|
|
include : Rotate [Math.atan2 (yt - yo) (xt - xo)]
|
|
include : Translate xo yo
|
|
|
|
define [dhArrowShape x1 y1 x2 y2 size] : glyph-construction
|
|
local mag : Math.hypot (y2 - y1) (x2 - x1)
|
|
local p : (mag - o - size) / mag
|
|
include : ArrowShape x1 y1 x2 y2 size
|
|
include : ArrowHead x1 y1 [mix x1 x2 p] [mix y1 y2 p] size
|
|
|
|
define [htArrowShape x1 y1 x2 y2 size] : glyph-construction
|
|
local mag : Math.hypot (y2 - y1) (x2 - x1)
|
|
local p1 : (size - o - halfstroke * 1.1) / mag
|
|
local p2 : size / mag
|
|
include : ArrowShape [mix x1 x2 p1] [mix y1 y2 p1] x2 y2 size
|
|
include : ArrowHead x1 y1 [mix x1 x2 p2] [mix y1 y2 p2] size
|
|
|
|
define [arrow shape id unicode x1 y1 x2 y2 width] : sketch
|
|
set-width [fallback width MosaicWidth]
|
|
set-anchor "slash" BASE [mix x1 x2 (2/5)] [mix y1 y2 (2/5)]
|
|
include : shape x1 y1 x2 y2 arrowSize
|
|
save id unicode
|
|
|
|
define [doublearrow shape id unicode x1 y1 x2 y2] : sketch
|
|
set-width MosaicWidth
|
|
set-anchor "slash" BASE [mix x1 x2 (1/2)] [mix y1 y2 (1/2)]
|
|
local xm : mix x1 x2 0.5
|
|
local ym : mix y1 y2 0.5
|
|
include : shape xm ym x1 y1 arrowSize
|
|
include : shape xm ym x2 y2 arrowSize
|
|
save id unicode
|
|
|
|
define [anglearrow shape bar id unicode x1 y1 x2 y2 x3 y3] : sketch
|
|
set-width MosaicWidth
|
|
include : shape x2 y2 x3 y3 arrowSize
|
|
include : bar x1 y1 x2 y2
|
|
save id unicode
|
|
|
|
arrow ArrowShape [MangleName 'arrowleft'] [MangleUnicode 0x2190] arrowRSB symbolMid arrowSB symbolMid
|
|
arrow ArrowShape [MangleName 'arrowup'] [MangleUnicode 0x2191] arrowMidX arrowBot arrowMidX arrowTop
|
|
arrow ArrowShape [MangleName 'arrowright'] [MangleUnicode 0x2192] arrowSB symbolMid arrowRSB symbolMid
|
|
arrow ArrowShape [MangleName 'arrowdown'] [MangleUnicode 0x2193] arrowMidX arrowTop arrowMidX arrowBot
|
|
|
|
arrow DashArrowShape [MangleName 'dasharrowleft'] [MangleUnicode 0x21E0] arrowRSB symbolMid arrowSB symbolMid
|
|
arrow DashArrowShape [MangleName 'dasharrowup'] [MangleUnicode 0x21E1] arrowMidX arrowBot arrowMidX arrowTop
|
|
arrow DashArrowShape [MangleName 'dasharrowright'] [MangleUnicode 0x21E2] arrowSB symbolMid arrowRSB symbolMid
|
|
arrow DashArrowShape [MangleName 'dasharrowdown'] [MangleUnicode 0x21E3] arrowMidX arrowTop arrowMidX arrowBot
|
|
|
|
arrow [HookArrowShape 1] [MangleName 'hookarrowleft'] [MangleUnicode 0x21A9] arrowRSB symbolMid arrowSB symbolMid
|
|
arrow [HookArrowShape (-1)] [MangleName 'hookarrowright'] [MangleUnicode 0x21AA] arrowSB symbolMid arrowRSB symbolMid
|
|
arrow [HookArrowShape (-1)] [MangleName 'hookarrowupleft'] [MangleUnicode 0x2923] arrowRSB arrowBot arrowSB arrowTop
|
|
arrow [HookArrowShape 1] [MangleName 'hookarrowupright'] [MangleUnicode 0x2924] arrowSB arrowBot arrowRSB arrowTop
|
|
arrow [HookArrowShape (-1)] [MangleName 'hookarrowdownright'] [MangleUnicode 0x2925] arrowSB arrowTop arrowRSB arrowBot
|
|
arrow [HookArrowShape 1] [MangleName 'hookarrowdownleft'] [MangleUnicode 0x2926] arrowRSB arrowTop arrowSB arrowBot
|
|
|
|
anglearrow ArrowShape [lambda [x1 y1 x2 y2] : VBarLeft x1 y1 y2] [MangleName 'arrow-up-angle-right'] [MangleUnicode 0x21b1] arrowSB arrowBot arrowSB (arrowTop - arrowSize) arrowRSB (arrowTop - arrowSize)
|
|
anglearrow ArrowShape [lambda [x1 y1 x2 y2] : VBarRight x1 y1 y2] [MangleName 'arrow-up-angle-left'] [MangleUnicode 0x21b0] arrowRSB arrowBot arrowRSB (arrowTop - arrowSize) arrowSB (arrowTop - arrowSize)
|
|
anglearrow ArrowShape [lambda [x1 y1 x2 y2] : VBarLeft x1 y1 y2] [MangleName 'arrow-down-angle-right'] [MangleUnicode 0x21b3] arrowSB arrowTop arrowSB (arrowBot + arrowSize) arrowRSB (arrowBot + arrowSize)
|
|
anglearrow ArrowShape [lambda [x1 y1 x2 y2] : VBarRight x1 y1 y2] [MangleName 'arrow-down-angle-left'] [MangleUnicode 0x21b2] arrowRSB arrowTop arrowRSB (arrowBot + arrowSize) arrowSB (arrowBot + arrowSize)
|
|
|
|
arrow ArrowShape [MangleName 'arrowupleft'] [MangleUnicode 0x2196] arrowRSB arrowBot arrowSB arrowTop
|
|
arrow ArrowShape [MangleName 'arrowupright'] [MangleUnicode 0x2197] arrowSB arrowBot arrowRSB arrowTop
|
|
arrow ArrowShape [MangleName 'arrowdownright'] [MangleUnicode 0x2198] arrowSB arrowTop arrowRSB arrowBot
|
|
arrow ArrowShape [MangleName 'arrowdownleft'] [MangleUnicode 0x2199] arrowRSB arrowTop arrowSB arrowBot
|
|
|
|
arrow [HalfArrowShape RHSHalfArrowHead] [MangleName 'arrowleftHR'] [MangleUnicode 0x21BC] arrowRSB symbolMid arrowSB symbolMid
|
|
arrow [HalfArrowShape LHSHalfArrowHead] [MangleName 'arrowleftHL'] [MangleUnicode 0x21BD] arrowRSB symbolMid arrowSB symbolMid
|
|
arrow [HalfArrowShape RHSHalfArrowHead] [MangleName 'arrowupHR'] [MangleUnicode 0x21BE] arrowMidX arrowBot arrowMidX arrowTop
|
|
arrow [HalfArrowShape LHSHalfArrowHead] [MangleName 'arrowupHL'] [MangleUnicode 0x21BF] arrowMidX arrowBot arrowMidX arrowTop
|
|
arrow [HalfArrowShape LHSHalfArrowHead] [MangleName 'arrowrightHL'] [MangleUnicode 0x21C0] arrowSB symbolMid arrowRSB symbolMid
|
|
arrow [HalfArrowShape RHSHalfArrowHead] [MangleName 'arrowrightHR'] [MangleUnicode 0x21C1] arrowSB symbolMid arrowRSB symbolMid
|
|
arrow [HalfArrowShape LHSHalfArrowHead] [MangleName 'arrowdownHL'] [MangleUnicode 0x21C2] arrowMidX arrowTop arrowMidX arrowBot
|
|
arrow [HalfArrowShape RHSHalfArrowHead] [MangleName 'arrowdownHR'] [MangleUnicode 0x21C3] arrowMidX arrowTop arrowMidX arrowBot
|
|
|
|
arrow [ThickArrowShape 'white'] [MangleName 'uni21E6'] [MangleUnicode 0x21E6] arrowRSB symbolMid arrowSB symbolMid
|
|
arrow [ThickArrowShape 'white'] [MangleName 'uni21E7'] [MangleUnicode 0x21E7] arrowMidX arrowBot arrowMidX arrowTop
|
|
arrow [ThickArrowShape 'white'] [MangleName 'uni21E8'] [MangleUnicode 0x21E8] arrowSB symbolMid arrowRSB symbolMid
|
|
arrow [ThickArrowShape 'white'] [MangleName 'uni21E9'] [MangleUnicode 0x21E9] arrowMidX arrowTop arrowMidX arrowBot
|
|
arrow [ThickArrowShape 'white'] [MangleName 'uni2B00'] [MangleUnicode 0x2B00] arrowSB arrowBot arrowRSB arrowTop
|
|
arrow [ThickArrowShape 'white'] [MangleName 'uni2B01'] [MangleUnicode 0x2B01] arrowRSB arrowBot arrowSB arrowTop
|
|
arrow [ThickArrowShape 'white'] [MangleName 'uni2B02'] [MangleUnicode 0x2B02] arrowSB arrowTop arrowRSB arrowBot
|
|
arrow [ThickArrowShape 'white'] [MangleName 'uni2B03'] [MangleUnicode 0x2B03] arrowRSB arrowTop arrowSB arrowBot
|
|
|
|
arrow [ThickArrowShape 'black'] [MangleName 'uni2B05'] [MangleUnicode 0x2B05] arrowRSB symbolMid arrowSB symbolMid
|
|
arrow [ThickArrowShape 'black'] [MangleName 'uni2B06'] [MangleUnicode 0x2B06] arrowMidX arrowBot arrowMidX arrowTop
|
|
arrow [ThickArrowShape 'black'] [MangleName 'uni27A1'] [MangleUnicode 0x27A1] arrowSB symbolMid arrowRSB symbolMid
|
|
arrow [ThickArrowShape 'black'] [MangleName 'uni2B07'] [MangleUnicode 0x2B07] arrowMidX arrowTop arrowMidX arrowBot
|
|
arrow [ThickArrowShape 'black'] [MangleName 'uni2B08'] [MangleUnicode 0x2B08] arrowSB arrowBot arrowRSB arrowTop
|
|
arrow [ThickArrowShape 'black'] [MangleName 'uni2B09'] [MangleUnicode 0x2B09] arrowRSB arrowBot arrowSB arrowTop
|
|
arrow [ThickArrowShape 'black'] [MangleName 'uni2B0A'] [MangleUnicode 0x2B0A] arrowSB arrowTop arrowRSB arrowBot
|
|
arrow [ThickArrowShape 'black'] [MangleName 'uni2B0B'] [MangleUnicode 0x2B0B] arrowRSB arrowTop arrowSB arrowBot
|
|
|
|
|
|
arrow ArrowShape [MangleName 'arrowleftK'] null arrowRSB symbolMid (arrowSB + fine) symbolMid
|
|
arrow ArrowShape [MangleName 'arrowrightK'] null arrowSB symbolMid (arrowRSB - fine) symbolMid
|
|
arrow ArrowShape [MangleName 'arrowupK'] null arrowMidX arrowBot arrowMidX (arrowTop - fine)
|
|
arrow ArrowShape [MangleName 'arrowdownK'] null arrowMidX arrowTop arrowMidX (arrowBot + fine)
|
|
arrow ArrowShape [MangleName 'arrowleftSK'] null (arrowRSB - fine / 2) symbolMid arrowSB symbolMid
|
|
arrow ArrowShape [MangleName 'arrowrightSK'] null (arrowSB + fine / 2) symbolMid arrowRSB symbolMid
|
|
arrow ArrowShape [MangleName 'arrowupSK'] null arrowMidX (arrowBot + fine / 2) arrowMidX arrowTop
|
|
arrow ArrowShape [MangleName 'arrowdownSK'] null arrowMidX (arrowTop - fine / 2) arrowMidX arrowBot
|
|
arrow ArrowShape [MangleName 'arrowupleftTK'] null arrowRSB arrowBot arrowSB (arrowTop - [Math.max (arrowWidth / 8) (fine * 1.5)])
|
|
|
|
composite [MangleName 'arrowbarleft'] glyphs.[MangleName 'arrowleftK'] [VBar arrowSB (symbolMid - arrowSize) (symbolMid + arrowSize) fine] [into-unicode : MangleUnicode 0x21E4]
|
|
composite [MangleName 'arrowbarright'] glyphs.[MangleName 'arrowrightK'] [VBar arrowRSB (symbolMid - arrowSize) (symbolMid + arrowSize) fine] [into-unicode : MangleUnicode 0x21E5]
|
|
composite [MangleName 'arrowbarup'] glyphs.[MangleName 'arrowupK'] [HBar (arrowMidX - arrowSize) (arrowMidX + arrowSize) arrowTop fine] [into-unicode : MangleUnicode 0x2912]
|
|
composite [MangleName 'arrowbardown'] glyphs.[MangleName 'arrowdownK'] [HBar (arrowMidX - arrowSize) (arrowMidX + arrowSize) arrowBot fine] [into-unicode : MangleUnicode 0x2913]
|
|
composite [MangleName 'bararrowleft'] glyphs.[MangleName 'arrowleftSK'] [VBar arrowRSB (symbolMid - arrowSize) (symbolMid + arrowSize) fine] [into-unicode : MangleUnicode 0x21A4]
|
|
composite [MangleName 'bararrowright'] glyphs.[MangleName 'arrowrightSK'] [VBar arrowSB (symbolMid - arrowSize) (symbolMid + arrowSize) fine] [into-unicode : MangleUnicode 0x21A6]
|
|
composite [MangleName 'bararrowup'] glyphs.[MangleName 'arrowupSK'] [HBar (arrowMidX - arrowSize) (arrowMidX + arrowSize) arrowBot fine] [into-unicode : MangleUnicode 0x21A5]
|
|
composite [MangleName 'bararrowdown'] glyphs.[MangleName 'arrowdownSK'] [HBar (arrowMidX - arrowSize) (arrowMidX + arrowSize) arrowTop fine] [into-unicode : MangleUnicode 0x21A7]
|
|
|
|
composite [MangleName 'uni21B8'] glyphs.[MangleName 'arrowupleftTK'] [HBar (arrowSB - arrowSize / 2) (arrowRSB + arrowSize / 2) arrowTop fine] [into-unicode : MangleUnicode 0x21B8]
|
|
|
|
let [dasw doubleArrowStemWidth] : do
|
|
arrow [DoubleArrowShape dasw] [MangleName 'dblarrowleft'] [MangleUnicode 0x21D0] arrowRSB symbolMid arrowSB symbolMid
|
|
arrow [DoubleArrowShape dasw] [MangleName 'dblarrowright'] [MangleUnicode 0x21D2] arrowSB symbolMid arrowRSB symbolMid
|
|
arrow [DoubleArrowShape dasw] [MangleName 'dblarrowup'] [MangleUnicode 0x21D1] arrowMidX arrowBot arrowMidX arrowTop
|
|
arrow [DoubleArrowShape dasw] [MangleName 'dblarrowdown'] [MangleUnicode 0x21D3] arrowMidX arrowTop arrowMidX arrowBot
|
|
arrow [DoubleArrowShape dasw] [MangleName 'dblarrowupleft'] [MangleUnicode 0x21D6] arrowRSB arrowBot arrowSB arrowTop
|
|
arrow [DoubleArrowShape dasw] [MangleName 'dblarrowupright'] [MangleUnicode 0x21D7] arrowSB arrowBot arrowRSB arrowTop
|
|
arrow [DoubleArrowShape dasw] [MangleName 'dblarrowdownright'] [MangleUnicode 0x21D8] arrowSB arrowTop arrowRSB arrowBot
|
|
arrow [DoubleArrowShape dasw] [MangleName 'dblarrowdownleft'] [MangleUnicode 0x21D9] arrowRSB arrowTop arrowSB arrowBot
|
|
|
|
doublearrow ArrowShape [MangleName 'arrowleftright'] [MangleUnicode 0x2194] arrowSB symbolMid arrowRSB symbolMid
|
|
doublearrow ArrowShape [MangleName 'arrowupdown'] [MangleUnicode 0x2195] arrowMidX arrowTop arrowMidX arrowBot
|
|
doublearrow ArrowShape [MangleName 'arrowupleftdownright'] [MangleUnicode 0x2921] arrowSB arrowTop arrowRSB arrowBot
|
|
doublearrow ArrowShape [MangleName 'arrowuprightdownleft'] [MangleUnicode 0x2922] arrowRSB arrowTop arrowSB arrowBot
|
|
|
|
let [dasw doubleArrowStemWidth] : do
|
|
doublearrow [DoubleArrowShape dasw] [MangleName 'dblarrowleftright'] [MangleUnicode 0x21D4] arrowSB symbolMid arrowRSB symbolMid
|
|
doublearrow [DoubleArrowShape dasw] [MangleName 'dblarrowupdown'] [MangleUnicode 0x21D5] arrowMidX arrowTop arrowMidX arrowBot
|
|
|
|
arrow dhArrowShape [MangleName 'dharrowleft'] [MangleUnicode 0x219E] arrowRSB symbolMid arrowSB symbolMid
|
|
arrow dhArrowShape [MangleName 'dharrowright'] [MangleUnicode 0x21A0] arrowSB symbolMid arrowRSB symbolMid
|
|
arrow dhArrowShape [MangleName 'dharrowup'] [MangleUnicode 0x219F] arrowMidX arrowBot arrowMidX arrowTop
|
|
arrow dhArrowShape [MangleName 'dharrowdown'] [MangleUnicode 0x21A1] arrowMidX arrowTop arrowMidX arrowBot
|
|
|
|
arrow htArrowShape [MangleName 'htarrowleft'] [MangleUnicode 0x21A2] arrowRSB symbolMid arrowSB symbolMid
|
|
arrow htArrowShape [MangleName 'htarrowright'] [MangleUnicode 0x21A3] arrowSB symbolMid arrowRSB symbolMid
|
|
|
|
composite [MangleName 'uni219A'] glyphs.[MangleName 'arrowleft'] glyphs.arrSlashOver [into-unicode : MangleUnicode 0x219A]
|
|
composite [MangleName 'uni219B'] glyphs.[MangleName 'arrowright'] glyphs.arrSlashOver [into-unicode : MangleUnicode 0x219B]
|
|
composite [MangleName 'uni21AE'] glyphs.[MangleName 'arrowleftright'] glyphs.arrSlashOver [into-unicode : MangleUnicode 0x21AE]
|
|
composite [MangleName 'uni21F7'] glyphs.[MangleName 'arrowleft'] glyphs.arrVStrokeOver [into-unicode : MangleUnicode 0x21F7]
|
|
composite [MangleName 'uni21F8'] glyphs.[MangleName 'arrowright'] glyphs.arrVStrokeOver [into-unicode : MangleUnicode 0x21F8]
|
|
composite [MangleName 'uni21F9'] glyphs.[MangleName 'arrowleftright'] glyphs.arrVStrokeOver [into-unicode : MangleUnicode 0x21F9]
|
|
composite [MangleName 'uni21FA'] glyphs.[MangleName 'arrowleft'] glyphs.arrDblVStrokeOver [into-unicode : MangleUnicode 0x21FA]
|
|
composite [MangleName 'uni21FB'] glyphs.[MangleName 'arrowright'] glyphs.arrDblVStrokeOver [into-unicode : MangleUnicode 0x21FB]
|
|
composite [MangleName 'uni21FC'] glyphs.[MangleName 'arrowleftright'] glyphs.arrDblVStrokeOver [into-unicode : MangleUnicode 0x21FC]
|
|
composite [MangleName 'uni21CD'] glyphs.[MangleName 'dblarrowleft'] glyphs.arrSlashOver [into-unicode : MangleUnicode 0x21CD]
|
|
composite [MangleName 'uni21CE'] glyphs.[MangleName 'dblarrowleftright'] glyphs.arrSlashOver [into-unicode : MangleUnicode 0x21CE]
|
|
composite [MangleName 'uni21CF'] glyphs.[MangleName 'dblarrowright'] glyphs.arrSlashOver [into-unicode : MangleUnicode 0x21CF]
|
|
|
|
do
|
|
local hcDist : Math.max (halfstroke * 5) (arrowWidth / 2)
|
|
vcombine [MangleName 'uni21C4'] [MangleUnicode 0x21C4] [MangleName 'arrowright'] [MangleName 'arrowleft'] (arrowSize * 1.75)
|
|
hcombine [MangleName 'uni21C5'] [MangleUnicode 0x21C5] [MangleName 'arrowup'] [MangleName 'arrowdown'] hcDist
|
|
vcombine [MangleName 'uni21C6'] [MangleUnicode 0x21C6] [MangleName 'arrowleft'] [MangleName 'arrowright'] (arrowSize * 1.75)
|
|
vcombine [MangleName 'uni21C7'] [MangleUnicode 0x21C7] [MangleName 'arrowleft'] [MangleName 'arrowleft'] (arrowSize * 1.75)
|
|
hcombine [MangleName 'uni21C8'] [MangleUnicode 0x21C8] [MangleName 'arrowup'] [MangleName 'arrowup'] hcDist
|
|
vcombine [MangleName 'uni21C9'] [MangleUnicode 0x21C9] [MangleName 'arrowright'] [MangleName 'arrowright'] (arrowSize * 1.75)
|
|
hcombine [MangleName 'uni21CA'] [MangleUnicode 0x21CA] [MangleName 'arrowdown'] [MangleName 'arrowdown'] hcDist
|
|
hcombine [MangleName 'uni21F5'] [MangleUnicode 0x21F5] [MangleName 'arrowdown'] [MangleName 'arrowup'] hcDist
|
|
vcombine [MangleName 'uni21CB'] [MangleUnicode 0x21CB] [MangleName 'arrowleftHR'] [MangleName 'arrowrightHR'] (arrowSize)
|
|
vcombine [MangleName 'uni21CC'] [MangleUnicode 0x21CC] [MangleName 'arrowrightHL'] [MangleName 'arrowleftHL'] (arrowSize)
|
|
vcombine [MangleName 'uni21B9'] [MangleUnicode 0x21B9] [MangleName 'arrowbarright'] [MangleName 'arrowbarleft'] (arrowSize * 1.75)
|
|
|
|
if (MosaicWidth == FULLWIDTH2) : set exportArrowShape ArrowShape
|
|
|
|
### Standard geometric shapes
|
|
foreach {suffix MosaicWidth} [items-of WidthKinds] : do 'Geometric'
|
|
define [MangleUnicode unicode] : if (MosaicWidth == FULLWIDTH2) unicode nothing
|
|
define [MangleName name] : name + suffix
|
|
|
|
define shapeWidth MosaicWidth
|
|
define middleFW : shapeWidth / 2
|
|
|
|
define left : mix MIDDLE SB 1.1
|
|
define right : mix MIDDLE RIGHTSB 1.1
|
|
define squareRadius : (right - left) / 2
|
|
|
|
define leftFW : shapeWidth / 2 - (MIDDLE - left) * (shapeWidth / WIDTH)
|
|
define rightFW : shapeWidth / 2 + (MIDDLE - left) * (shapeWidth / WIDTH)
|
|
define squareRadiusFW : (rightFW - leftFW) / 2
|
|
define topFW : symbolMid + squareRadiusFW
|
|
define bottomFW : symbolMid - squareRadiusFW
|
|
|
|
define [hollowScale w d s] : (w - [fallback s GEOMETRYSTROKE] * [fallback d : WIDTH / shapeWidth]) / w
|
|
|
|
define [hollow newid unicode oldid zx zy cx cy] : create-glyph newid : glyph-construction
|
|
depends-on glyphs.(oldid)
|
|
local isWide : glyphs.(oldid).advanceWidth > WIDTH
|
|
local zoom : hollowScale squareRadius (WIDTH / glyphs.(oldid).advanceWidth)
|
|
include : difference
|
|
create-glyph : glyph-construction
|
|
include glyphs.(oldid)
|
|
if isWide : include UnFullWidthify
|
|
create-glyph : glyph-construction
|
|
include glyphs.(oldid)
|
|
if isWide : include UnFullWidthify
|
|
include : FlipAround [fallback cx MIDDLE] [fallback cy symbolMid] [fallback zx zoom] [fallback zy zx zoom]
|
|
if isWide : include FullWidthify
|
|
include : into-unicode unicode
|
|
|
|
define [hollowWithCenter newid unicode oldid zx zy cx cy] : create-glyph newid : glyph-construction
|
|
depends-on glyphs.(oldid)
|
|
local isWide : glyphs.(oldid).advanceWidth > WIDTH
|
|
local zoom : hollowScale squareRadius (WIDTH / glyphs.(oldid).advanceWidth)
|
|
local zx1 : mix [fallback zx zoom] 1 0.25
|
|
local zx2 : mix zx1 0 0.5
|
|
local zy1 : mix [fallback zy zx zoom] 1 0.25
|
|
local zy2 : mix zy1 0 0.5
|
|
include : union
|
|
difference
|
|
create-glyph : glyph-construction
|
|
include glyphs.(oldid)
|
|
if isWide : include UnFullWidthify
|
|
create-glyph : glyph-construction
|
|
include glyphs.(oldid)
|
|
if isWide : include UnFullWidthify
|
|
include : FlipAround [fallback cx MIDDLE] [fallback cy symbolMid] zx1 zy1
|
|
create-glyph : glyph-construction
|
|
include glyphs.(oldid)
|
|
if isWide : include UnFullWidthify
|
|
include : FlipAround [fallback cx MIDDLE] [fallback cy symbolMid] zx2 zy2
|
|
if isWide : include FullWidthify
|
|
include : into-unicode unicode
|
|
|
|
define [doubleHollow newid unicode oldid zx zy cx cy] : create-glyph newid : glyph-construction
|
|
depends-on glyphs.(oldid)
|
|
local isWide : glyphs.(oldid).advanceWidth > WIDTH
|
|
local zoom : hollowScale squareRadius (WIDTH / glyphs.(oldid).advanceWidth)
|
|
local zx1 : mix [fallback zx zoom] 1 0.25
|
|
local zx2 : [mix zx1 0 0.5] + (1 - zx1) / 2
|
|
local zx3 : zx2 - (1 - zx1)
|
|
local zy1 : mix [fallback zy zx zoom] 1 0.25
|
|
local zy2 : [mix zy1 0 0.5] + (1 - zy1) / 2
|
|
local zy3 : zy2 - (1 - zy1)
|
|
include : union
|
|
difference
|
|
create-glyph : glyph-construction
|
|
include glyphs.(oldid)
|
|
if isWide : include UnFullWidthify
|
|
create-glyph : glyph-construction
|
|
include glyphs.(oldid)
|
|
if isWide : include UnFullWidthify
|
|
include : FlipAround [fallback cx MIDDLE] [fallback cy symbolMid] zx1 zy1
|
|
difference
|
|
create-glyph : glyph-construction
|
|
include glyphs.(oldid)
|
|
if isWide : include UnFullWidthify
|
|
include : FlipAround [fallback cx MIDDLE] [fallback cy symbolMid] zx2 zy2
|
|
create-glyph : glyph-construction
|
|
include glyphs.(oldid)
|
|
if isWide : include UnFullWidthify
|
|
include : FlipAround [fallback cx MIDDLE] [fallback cy symbolMid] zx3 zy3
|
|
if isWide : include FullWidthify
|
|
include : into-unicode unicode
|
|
|
|
define [resized newid unicode id x y s sy] : create-glyph newid : glyph-construction
|
|
include glyphs.(id) AS_BASE
|
|
include UnFullWidthify
|
|
include : FlipAround x y s [fallback sy s]
|
|
include FullWidthify
|
|
include : into-unicode unicode
|
|
|
|
define FullWidthify : glyph-construction
|
|
apply-transform [Upright] true
|
|
apply-transform [Translate (-MIDDLE) (-symbolMid)] true
|
|
apply-transform [Scale (shapeWidth / WIDTH)] true
|
|
apply-transform [Translate (shapeWidth / 2) symbolMid] true
|
|
apply-transform [Italify] true
|
|
set-width shapeWidth
|
|
|
|
define UnFullWidthify : glyph-construction
|
|
apply-transform [Upright] true
|
|
apply-transform [Translate (-shapeWidth / 2) (-symbolMid)] true
|
|
apply-transform [Scale (WIDTH / shapeWidth)] true
|
|
apply-transform [Translate MIDDLE symbolMid] true
|
|
apply-transform [Italify] true
|
|
set-width WIDTH
|
|
|
|
sketch # blacksquare
|
|
start-from left (symbolMid + squareRadius)
|
|
line-to right (symbolMid + squareRadius)
|
|
line-to right (symbolMid - squareRadius)
|
|
line-to left (symbolMid - squareRadius)
|
|
include FullWidthify
|
|
save [MangleName 'blacksquare'] [MangleUnicode 0x25A0]
|
|
sketch # smallblacksquare
|
|
local r : squareRadius * designParameters.geometric_small_x
|
|
start-from (MIDDLE - r) (symbolMid + r)
|
|
line-to (MIDDLE + r) (symbolMid + r)
|
|
line-to (MIDDLE + r) (symbolMid - r)
|
|
line-to (MIDDLE - r) (symbolMid - r)
|
|
include FullWidthify
|
|
save [MangleName 'smallblacksquare'] [MangleUnicode 0x25AA]
|
|
sketch # blacktrianglerb
|
|
start-from right (symbolMid + squareRadius)
|
|
line-to right (symbolMid - squareRadius)
|
|
line-to left (symbolMid - squareRadius)
|
|
include FullWidthify
|
|
save [MangleName 'blacktrianglerb'] [MangleUnicode 0x25E2]
|
|
sketch # blacktrianglelb
|
|
start-from left (symbolMid + squareRadius)
|
|
line-to right (symbolMid - squareRadius)
|
|
line-to left (symbolMid - squareRadius)
|
|
include FullWidthify
|
|
save [MangleName 'blacktrianglelb'] [MangleUnicode 0x25E3]
|
|
sketch # blacktrianglelt
|
|
start-from left (symbolMid + squareRadius)
|
|
line-to right (symbolMid + squareRadius)
|
|
line-to left (symbolMid - squareRadius)
|
|
include FullWidthify
|
|
save [MangleName 'blacktrianglelt'] [MangleUnicode 0x25E4]
|
|
sketch # blacktrianglert
|
|
start-from left (symbolMid + squareRadius)
|
|
line-to right (symbolMid + squareRadius)
|
|
line-to right (symbolMid - squareRadius)
|
|
include FullWidthify
|
|
save [MangleName 'blacktrianglert'] [MangleUnicode 0x25E5]
|
|
|
|
sketch # blackrectangle
|
|
start-from left (symbolMid + squareRadius / 1.5)
|
|
line-to right (symbolMid + squareRadius / 1.5)
|
|
line-to right (symbolMid - squareRadius / 1.5)
|
|
line-to left (symbolMid - squareRadius / 1.5)
|
|
include FullWidthify
|
|
save [MangleName 'blackrectangle'] [MangleUnicode 0x25AC]
|
|
|
|
sketch # blackparallelogram
|
|
define skew : squareRadius * 1 / 4
|
|
start-from (left + skew) (symbolMid + squareRadius / 1.5)
|
|
line-to (right + skew) (symbolMid + squareRadius / 1.5)
|
|
line-to (right - skew) (symbolMid - squareRadius / 1.5)
|
|
line-to (left - skew) (symbolMid - squareRadius / 1.5)
|
|
include FullWidthify
|
|
save [MangleName 'blackparallelogram'] [MangleUnicode 0x25B0]
|
|
|
|
sketch # whiteparallelogram
|
|
define skew : squareRadius * 1 / 4
|
|
define w : GEOMETRYSTROKE * (WIDTH / shapeWidth)
|
|
set-width shapeWidth
|
|
include : intersection
|
|
begin glyphs.[MangleName 'blackparallelogram']
|
|
create-glyph : glyph-construction
|
|
include : dispiro
|
|
widths.rhs w
|
|
flat (left + skew) (symbolMid + squareRadius / 1.5)
|
|
curl (right + skew) (symbolMid + squareRadius / 1.5)
|
|
include : dispiro
|
|
widths.rhs w
|
|
flat (right + skew) (symbolMid + squareRadius / 1.5)
|
|
curl (right - skew) (symbolMid - squareRadius / 1.5)
|
|
include : dispiro
|
|
widths.rhs w
|
|
flat (right - skew) (symbolMid - squareRadius / 1.5)
|
|
curl (left - skew) (symbolMid - squareRadius / 1.5)
|
|
include : dispiro
|
|
widths.rhs w
|
|
flat (left - skew) (symbolMid - squareRadius / 1.5)
|
|
curl (left + skew) (symbolMid + squareRadius / 1.5)
|
|
include FullWidthify
|
|
|
|
save [MangleName 'whiteparallelogram'] [MangleUnicode 0x25B1]
|
|
|
|
sketch # blacklongrectangle
|
|
start-from left (symbolMid + squareRadius * 1.5)
|
|
line-to right (symbolMid + squareRadius * 1.5)
|
|
line-to right (symbolMid - squareRadius * 1.5)
|
|
line-to left (symbolMid - squareRadius * 1.5)
|
|
include FullWidthify
|
|
save [MangleName 'blacklongrectangle'] [MangleUnicode 0x25AE]
|
|
local triangleOvershoot : 2 / [Math.sqrt 3]
|
|
|
|
sketch # blacktriangleup
|
|
start-from MIDDLE (symbolMid + squareRadius)
|
|
line-to [mix MIDDLE right triangleOvershoot] (symbolMid - squareRadius)
|
|
line-to [mix MIDDLE left triangleOvershoot] (symbolMid - squareRadius)
|
|
include FullWidthify
|
|
save [MangleName 'blacktriangleup'] [MangleUnicode 0x25B2]
|
|
|
|
sketch # blacktriangledown
|
|
start-from MIDDLE (symbolMid - squareRadius)
|
|
line-to [mix MIDDLE left triangleOvershoot] (symbolMid + squareRadius)
|
|
line-to [mix MIDDLE right triangleOvershoot] (symbolMid + squareRadius)
|
|
include FullWidthify
|
|
save [MangleName 'blacktriangledown'] [MangleUnicode 0x25BC]
|
|
|
|
sketch # blacktriangleleft
|
|
start-from left symbolMid
|
|
line-to right (symbolMid - squareRadius * triangleOvershoot)
|
|
line-to right (symbolMid + squareRadius * triangleOvershoot)
|
|
include FullWidthify
|
|
save [MangleName 'blacktriangleleft'] [MangleUnicode 0x25C0]
|
|
|
|
sketch # blacktriangleright
|
|
start-from right symbolMid
|
|
line-to left (symbolMid + squareRadius * triangleOvershoot)
|
|
line-to left (symbolMid - squareRadius * triangleOvershoot)
|
|
include FullWidthify
|
|
save [MangleName 'blacktriangleright'] [MangleUnicode 0x25B6]
|
|
|
|
sketch # thinblacktriangleleft
|
|
start-from left symbolMid
|
|
line-to right (symbolMid - squareRadius * triangleOvershoot * 0.618)
|
|
line-to right (symbolMid + squareRadius * triangleOvershoot * 0.618)
|
|
include FullWidthify
|
|
save [MangleName 'thinblacktriangleleft'] [MangleUnicode 0x25C4]
|
|
|
|
sketch # thinblacktriangleright
|
|
start-from right symbolMid
|
|
line-to left (symbolMid + squareRadius * triangleOvershoot * 0.618)
|
|
line-to left (symbolMid - squareRadius * triangleOvershoot * 0.618)
|
|
include FullWidthify
|
|
save [MangleName 'thinblacktriangleright'] [MangleUnicode 0x25BA]
|
|
|
|
sketch # blackdiamond
|
|
start-from MIDDLE (symbolMid + squareRadius)
|
|
line-to right symbolMid
|
|
line-to MIDDLE (symbolMid - squareRadius)
|
|
line-to left symbolMid
|
|
include FullWidthify
|
|
save [MangleName 'blackdiamond'] [MangleUnicode 0x25C6]
|
|
|
|
sketch # blackLonzenge
|
|
start-from MIDDLE (symbolMid + squareRadius)
|
|
line-to [mix MIDDLE right (2 / 3)] symbolMid
|
|
line-to MIDDLE (symbolMid - squareRadius)
|
|
line-to [mix MIDDLE left (2 / 3)] symbolMid
|
|
include FullWidthify
|
|
save [MangleName 'blackLonzenge'] [MangleUnicode 0x29EB]
|
|
|
|
sketch # whiteLonzenge
|
|
define w : GEOMETRYSTROKE * (WIDTH / shapeWidth)
|
|
set-width shapeWidth
|
|
include : intersection
|
|
begin glyphs.[MangleName 'blackLonzenge']
|
|
create-glyph : glyph-construction
|
|
include : dispiro
|
|
widths.rhs w
|
|
flat MIDDLE (symbolMid + squareRadius)
|
|
curl [mix MIDDLE right (2 / 3)] symbolMid
|
|
include : dispiro
|
|
widths.rhs w
|
|
flat [mix MIDDLE right (2 / 3)] symbolMid
|
|
curl MIDDLE (symbolMid - squareRadius)
|
|
include : dispiro
|
|
widths.rhs w
|
|
flat MIDDLE (symbolMid - squareRadius)
|
|
curl [mix MIDDLE left (2 / 3)] symbolMid
|
|
include : dispiro
|
|
widths.rhs w
|
|
flat [mix MIDDLE left (2 / 3)] symbolMid
|
|
curl MIDDLE (symbolMid + squareRadius)
|
|
include FullWidthify
|
|
save [MangleName 'whiteLonzenge'] [MangleUnicode 0x25CA]
|
|
|
|
sketch # blackcircle
|
|
include markset.plus
|
|
include : spiro-outline
|
|
g4 MIDDLE (symbolMid + squareRadius + O)
|
|
g4 (left - O) symbolMid
|
|
g4 MIDDLE (symbolMid - squareRadius - O)
|
|
g4 (right + O) symbolMid
|
|
close
|
|
reverse-last
|
|
save [MangleName 'blackcircleO']
|
|
|
|
sketch # blackcircle
|
|
include markset.plus
|
|
include : spiro-outline
|
|
g4 MIDDLE (symbolMid + squareRadius)
|
|
g4 left symbolMid
|
|
g4 MIDDLE (symbolMid - squareRadius)
|
|
g4 right symbolMid
|
|
close
|
|
reverse-last
|
|
include FullWidthify
|
|
save [MangleName 'blackcircle'] [MangleUnicode 0x25CF]
|
|
|
|
sketch # leftblackcircle
|
|
set-width shapeWidth
|
|
include : intersection
|
|
begin glyphs.[MangleName 'blackcircle']
|
|
spiro-outline
|
|
corner (0 - shapeWidth) (symbolMid - squareRadiusFW * 2)
|
|
corner (shapeWidth / 2) (symbolMid - squareRadiusFW * 2)
|
|
corner (shapeWidth / 2) (symbolMid + squareRadiusFW * 2)
|
|
corner (0 - shapeWidth) (symbolMid + squareRadiusFW * 2)
|
|
save [MangleName 'leftblackcircle'] [MangleUnicode 0x25D6]
|
|
|
|
sketch # rightblackcircle
|
|
set-width shapeWidth
|
|
include : intersection
|
|
begin glyphs.[MangleName 'blackcircle']
|
|
spiro-outline
|
|
corner (shapeWidth * 2) (symbolMid - squareRadiusFW * 2)
|
|
corner (shapeWidth / 2) (symbolMid - squareRadiusFW * 2)
|
|
corner (shapeWidth / 2) (symbolMid + squareRadiusFW * 2)
|
|
corner (shapeWidth * 2) (symbolMid + squareRadiusFW * 2)
|
|
save [MangleName 'rightblackcircle'] [MangleUnicode 0x25D7]
|
|
|
|
sketch # smallblackcircle
|
|
include : spiro-outline
|
|
g4 MIDDLE (symbolMid + squareRadius * designParameters.geometric_small_x)
|
|
g4 (MIDDLE - squareRadius * designParameters.geometric_small_x) symbolMid
|
|
g4 MIDDLE (symbolMid - squareRadius * designParameters.geometric_small_x)
|
|
g4 (MIDDLE + squareRadius * designParameters.geometric_small_x) symbolMid
|
|
close
|
|
reverse-last
|
|
include FullWidthify
|
|
save [MangleName 'smallblackcircle']
|
|
|
|
sketch # bigblackcircle
|
|
include : spiro-outline
|
|
g4 MIDDLE (symbolMid + squareRadius * designParameters.geometric_large_x)
|
|
g4 (MIDDLE - squareRadius * designParameters.geometric_large_x) symbolMid
|
|
g4 MIDDLE (symbolMid - squareRadius * designParameters.geometric_large_x)
|
|
g4 (MIDDLE + squareRadius * designParameters.geometric_large_x) symbolMid
|
|
close
|
|
reverse-last
|
|
include FullWidthify
|
|
save [MangleName 'bigblackcircle'] [MangleUnicode 0x2B24]
|
|
|
|
let
|
|
: configurations : list
|
|
* {.sides 5 .skip 2 .name 'blackstar' .unicode 0x2605 .overflow 1.1 .phase 0}
|
|
* {.sides 5 .skip 1 .name 'blackpentagon' .unicode 0x2B1F .overflow 1.05 .phase 0}
|
|
* {.sides 6 .skip 1 .name 'blackhexagon' .unicode 0x2B22 .overflow 1.05 .phase 0}
|
|
* {.sides 5 .skip 1 .name 'rhblackpentagon' .unicode 0x2B53 .overflow 1.05 .phase (-Math.PI / 2)}
|
|
* {.sides 6 .skip 1 .name 'hblackhexagon' .unicode 0x2B23 .overflow 1.05 .phase (Math.PI / 2)}
|
|
: foreach [{.sides sides .skip skip .name name .unicode unicode .overflow overflow .phase phase} : items-of configurations] : sketch
|
|
include markset.plus
|
|
foreach [j : range 0 sides] : begin
|
|
local angle : 2 * Math.PI * j * skip / sides + phase
|
|
currentGlyph.([if j 'line-to' 'start-from'])
|
|
mix left right (0.5 - 0.5 * overflow * [Math.sin angle])
|
|
symbolMid + squareRadius * [Math.cos angle] * overflow
|
|
save [MangleName "hw\(name)"]
|
|
include FullWidthify
|
|
save [MangleName name] [MangleUnicode unicode]
|
|
|
|
sketch # dottedcircle
|
|
local n 12
|
|
local fine : adviceBlackness 10
|
|
foreach j [range 0 n] : begin
|
|
local angle : Math.PI * 2 * j / n
|
|
local cx : MIDDLE + (right - MIDDLE) * [Math.cos angle]
|
|
local cy : (XH / 2) + (right - MIDDLE) * [Math.sin angle]
|
|
include : spiro-outline
|
|
g4 cx (cy + fine)
|
|
g4 (cx + fine) cy
|
|
g4 cx (cy - fine)
|
|
g4 (cx - fine) cy
|
|
close
|
|
#include : Ring (cy + fine) (cy - fine) (cx - fine) (cx + fine) true
|
|
include markset.e
|
|
apply-transform [Upright] true
|
|
apply-transform [Translate 0 (symbolMid - (XH / 2))] true
|
|
apply-transform [Italify] true
|
|
include FullWidthify
|
|
|
|
save [MangleName 'dottedcircle'] [MangleUnicode 0x25CC]
|
|
|
|
hollow [MangleName 'whitesquare'] [MangleUnicode 0x25A1] [MangleName 'blacksquare']
|
|
hollowWithCenter [MangleName 'whitesquareWithCenter'] [MangleUnicode 0x25A3] [MangleName 'blacksquare']
|
|
hollow [MangleName 'whitehexagon'] [MangleUnicode 0x2B21] [MangleName 'blackhexagon']
|
|
hollow [MangleName 'whitepentagon'] [MangleUnicode 0x2B20] [MangleName 'blackpentagon']
|
|
hollow [MangleName 'rhwhitepentagon'] [MangleUnicode 0x2B54] [MangleName 'rhblackpentagon']
|
|
hollow [MangleName 'whiterectangle'] [MangleUnicode 0x25AD] [MangleName 'blackrectangle'] [hollowScale squareRadius] [hollowScale (squareRadius / 1.5)]
|
|
hollow [MangleName 'whitelongrectangle'] [MangleUnicode 0x25AF] [MangleName 'blacklongrectangle'] [hollowScale squareRadius] [hollowScale (squareRadius * 1.5)]
|
|
|
|
hollow [MangleName 'whitecircle'] [MangleUnicode 0x25CB] [MangleName 'blackcircle']
|
|
hollowWithCenter [MangleName 'whitecircleWithCenter'] [MangleUnicode 0x25C9] [MangleName 'blackcircle']
|
|
doubleHollow [MangleName 'doubleWhitecircle'] [MangleUnicode 0x25CE] [MangleName 'blackcircle']
|
|
hollow [MangleName 'bigwhitecircle'] [MangleUnicode 0x25EF] [MangleName 'bigblackcircle'] [hollowScale : squareRadius * designParameters.geometric_large_x]
|
|
hollow [MangleName 'smallwhitecircle'] null [MangleName 'smallblackcircle'] [hollowScale : squareRadius * designParameters.geometric_small_x]
|
|
hollow [MangleName 'smallwhitesquare'] [MangleUnicode 0x25AB] [MangleName 'smallblacksquare'] [hollowScale : squareRadius * designParameters.geometric_small_x]
|
|
let [s : hollowScale squareRadius nothing (GEOMETRYSTROKE * [Math.sqrt 2])] : begin
|
|
hollow [MangleName 'whitediamond'] [MangleUnicode 0x25C7] [MangleName 'blackdiamond'] s
|
|
hollowWithCenter [MangleName 'whitediamondWithCenter'] [MangleUnicode 0x25C8] [MangleName 'blackdiamond'] s
|
|
let [sts 0.75]
|
|
: begin
|
|
resized [MangleName 'smallblacktriangleup'] [MangleUnicode 0x25B4] [MangleName 'blacktriangleup'] MIDDLE symbolMid 0.75
|
|
resized [MangleName 'smallblacktriangleright'] [MangleUnicode 0x25B8] [MangleName 'blacktriangleright'] MIDDLE symbolMid 0.75
|
|
resized [MangleName 'smallblacktriangledown'] [MangleUnicode 0x25BE] [MangleName 'blacktriangledown'] MIDDLE symbolMid 0.75
|
|
resized [MangleName 'smallblacktriangleleft'] [MangleUnicode 0x25C2] [MangleName 'blacktriangleleft'] MIDDLE symbolMid 0.75
|
|
|
|
let
|
|
: sl : hollowScale (squareRadius * 2 / [Math.sqrt 3]) nothing (GEOMETRYSTROKE * [Math.sqrt 3])
|
|
: slt : hollowScale (squareRadius * 2 / [Math.sqrt 3]) nothing (GEOMETRYSTROKE * [Math.sqrt 3])
|
|
: ss : hollowScale (squareRadius * sts * 2 / [Math.sqrt 3]) nothing (GEOMETRYSTROKE * [Math.sqrt 3])
|
|
: begin
|
|
hollow [MangleName 'whitetriangleup'] [MangleUnicode 0x25B3] [MangleName 'blacktriangleup'] sl nothing MIDDLE (symbolMid - squareRadius / 3)
|
|
hollow [MangleName 'whitetriangledown'] [MangleUnicode 0x25BD] [MangleName 'blacktriangledown'] sl nothing MIDDLE (symbolMid + squareRadius / 3)
|
|
hollow [MangleName 'whitetriangleleft'] [MangleUnicode 0x25C1] [MangleName 'blacktriangleleft'] sl nothing [mix MIDDLE right (1 / 3)] symbolMid
|
|
hollow [MangleName 'whitetriangleright'] [MangleUnicode 0x25B7] [MangleName 'blacktriangleright'] sl nothing [mix MIDDLE left (1 / 3)] symbolMid
|
|
hollow [MangleName 'smallwhitetriangleup'] [MangleUnicode 0x25B5] [MangleName 'smallblacktriangleup'] ss nothing MIDDLE (symbolMid - squareRadius / 3 * sts)
|
|
hollow [MangleName 'smallwhitetriangledown'] [MangleUnicode 0x25BF] [MangleName 'smallblacktriangledown'] ss nothing MIDDLE (symbolMid + squareRadius / 3 * sts)
|
|
hollow [MangleName 'smallwhitetriangleleft'] [MangleUnicode 0x25C3] [MangleName 'smallblacktriangleleft'] ss nothing [mix MIDDLE right (sts / 3)] symbolMid
|
|
hollow [MangleName 'smallwhitetriangleright'] [MangleUnicode 0x25B9] [MangleName 'smallblacktriangleright'] ss nothing [mix MIDDLE left (sts / 3)] symbolMid
|
|
hollow [MangleName 'thinwhitetriangleleft'] [MangleUnicode 0x25C5] [MangleName 'thinblacktriangleleft'] sl nothing [mix MIDDLE right (1 / 3)] symbolMid
|
|
hollow [MangleName 'thinwhitetriangleright'] [MangleUnicode 0x25BB] [MangleName 'thinblacktriangleright'] sl nothing [mix MIDDLE left (1 / 3)] symbolMid
|
|
hollow [MangleName 'whitestar'] [MangleUnicode 0x2606] [MangleName 'blackstar'] sl
|
|
|
|
# Mark sampler
|
|
sketch
|
|
include markset.e
|
|
include : spiro-outline
|
|
g4 MIDDLE XH
|
|
g4 (MIDDLE - XH / 2) (XH / 2)
|
|
g4 MIDDLE 0
|
|
close
|
|
|
|
include : spiro-outline
|
|
g4 MIDDLE (XH * 0.9)
|
|
g4 (MIDDLE + XH * 0.4) (XH * 0.5)
|
|
g4 MIDDLE (XH * 0.1)
|
|
close
|
|
save [MangleName 'marksampler'] [MangleUnicode 0xE09E]
|
|
|
|
# Rounded
|
|
sketch # roundwhitesquare, U+25A2
|
|
set-width shapeWidth
|
|
define cr : squareRadiusFW - GEOMETRYSTROKE * 2
|
|
include : dispiro
|
|
widths.lhs GEOMETRYSTROKE
|
|
flat (middleFW + 1) (symbolMid + squareRadiusFW) [heading LEFTWARD]
|
|
curl (middleFW - cr) (symbolMid + squareRadiusFW) [heading LEFTWARD]
|
|
archv
|
|
flat (middleFW - squareRadiusFW) (symbolMid + cr) [heading DOWNWARD]
|
|
curl (middleFW - squareRadiusFW) (symbolMid - cr) [heading DOWNWARD]
|
|
arcvh
|
|
flat (middleFW - cr) (symbolMid - squareRadiusFW) [heading RIGHTWARD]
|
|
curl (middleFW + cr) (symbolMid - squareRadiusFW) [heading RIGHTWARD]
|
|
archv
|
|
flat (middleFW + squareRadiusFW) (symbolMid - cr) [heading UPWARD]
|
|
curl (middleFW + squareRadiusFW) (symbolMid + cr) [heading UPWARD]
|
|
arcvh
|
|
flat (middleFW + cr) (symbolMid + squareRadiusFW) [heading LEFTWARD]
|
|
curl (middleFW - 1) (symbolMid + squareRadiusFW) [heading LEFTWARD]
|
|
save [MangleName 'roundwhitesquare'] [MangleUnicode 0x25A2]
|
|
|
|
# Shaded hollow squares
|
|
sketch # hshadesquare, U+25A4
|
|
define lineWidth : Math.min GEOMETRYSTROKE ((squareRadiusFW * 2 - GEOMETRYSTROKE * 2) * 1 / 11)
|
|
define top : symbolMid + squareRadiusFW - GEOMETRYSTROKE + lineWidth / 2
|
|
define bot : symbolMid - (top - symbolMid)
|
|
set-width shapeWidth
|
|
include : union
|
|
begin glyphs.[MangleName 'whitesquare']
|
|
intersection
|
|
begin glyphs.[MangleName 'blacksquare']
|
|
create-glyph : glyph-construction
|
|
include : dispiro
|
|
widths.center lineWidth
|
|
flat leftFW [mix top bot 0.25] [heading RIGHTWARD]
|
|
curl rightFW [mix top bot 0.25] [heading RIGHTWARD]
|
|
include : dispiro
|
|
widths.center lineWidth
|
|
flat leftFW [mix top bot 0.5] [heading RIGHTWARD]
|
|
curl rightFW [mix top bot 0.5] [heading RIGHTWARD]
|
|
include : dispiro
|
|
widths.center lineWidth
|
|
flat leftFW [mix top bot 0.75] [heading RIGHTWARD]
|
|
curl rightFW [mix top bot 0.75] [heading RIGHTWARD]
|
|
save [MangleName 'hshadesquare'] [MangleUnicode 0x25A4]
|
|
|
|
sketch # vshadesquare, U+25A5
|
|
define lineWidth : Math.min GEOMETRYSTROKE ((squareRadiusFW * 2 - GEOMETRYSTROKE * 2) * 1 / 11)
|
|
define r : shapeWidth / 2 + squareRadiusFW - GEOMETRYSTROKE + lineWidth / 2
|
|
define l : shapeWidth / 2 - (r - shapeWidth / 2)
|
|
set-width shapeWidth
|
|
include : union
|
|
begin glyphs.[MangleName 'whitesquare']
|
|
intersection
|
|
begin glyphs.[MangleName 'blacksquare']
|
|
create-glyph : glyph-construction
|
|
include : dispiro
|
|
widths.center lineWidth
|
|
flat [mix l r 0.25] topFW [heading DOWNWARD]
|
|
curl [mix l r 0.25] bottomFW [heading DOWNWARD]
|
|
include : dispiro
|
|
widths.center lineWidth
|
|
flat [mix l r 0.5] topFW [heading DOWNWARD]
|
|
curl [mix l r 0.5] bottomFW [heading DOWNWARD]
|
|
include : dispiro
|
|
widths.center lineWidth
|
|
flat [mix l r 0.75] topFW [heading DOWNWARD]
|
|
curl [mix l r 0.75] bottomFW [heading DOWNWARD]
|
|
save [MangleName 'vshadesquare'] [MangleUnicode 0x25A5]
|
|
|
|
sketch # hvshadesquare, U+25A6
|
|
set-width shapeWidth
|
|
include : union glyphs.[MangleName 'hshadesquare'] glyphs.[MangleName 'vshadesquare']
|
|
save [MangleName 'hvshadesquare'] [MangleUnicode 0x25A6]
|
|
|
|
sketch # ddiagshadesquare, U+25A7
|
|
define lineWidth : Math.min GEOMETRYSTROKE ((squareRadiusFW * 2 - GEOMETRYSTROKE * 2) * 1 / 11)
|
|
define top : symbolMid + squareRadiusFW
|
|
define bot : symbolMid - (top - symbolMid)
|
|
set-width shapeWidth
|
|
include : union
|
|
begin glyphs.[MangleName 'whitesquare']
|
|
intersection
|
|
begin glyphs.[MangleName 'blacksquare']
|
|
create-glyph : glyph-construction
|
|
foreach [j : range (-10) till 10] : include : dispiro
|
|
widths.center lineWidth
|
|
flat leftFW [mix top bot (j / 4)] [heading RIGHTWARD]
|
|
curl rightFW [mix top bot (j / 4 + 1)] [heading RIGHTWARD]
|
|
save [MangleName 'ddiagshadesquare'] [MangleUnicode 0x25A7]
|
|
|
|
sketch # udiagshadesquare, U+25A8
|
|
define lineWidth : Math.min GEOMETRYSTROKE ((squareRadiusFW * 2 - GEOMETRYSTROKE * 2) * 1 / 11)
|
|
define top : symbolMid + squareRadiusFW
|
|
define bot : symbolMid - (top - symbolMid)
|
|
set-width shapeWidth
|
|
include : union
|
|
begin glyphs.[MangleName 'whitesquare']
|
|
intersection
|
|
begin glyphs.[MangleName 'blacksquare']
|
|
create-glyph : glyph-construction
|
|
foreach [j : range (-10) till 10] : include : dispiro
|
|
widths.center lineWidth
|
|
flat leftFW [mix top bot (j / 4)] [heading RIGHTWARD]
|
|
curl rightFW [mix top bot (j / 4 - 1)] [heading RIGHTWARD]
|
|
save [MangleName 'udiagshadesquare'] [MangleUnicode 0x25A8]
|
|
|
|
sketch # uddiagshadesquare, U+25A9
|
|
set-width shapeWidth
|
|
include : union glyphs.[MangleName 'ddiagshadesquare'] glyphs.[MangleName 'udiagshadesquare']
|
|
save [MangleName 'uddiagshadesquare'] [MangleUnicode 0x25A9]
|
|
|
|
# partial circles
|
|
define quarters : list
|
|
list 0x25D0 1 1 0 0
|
|
list 0x25D1 0 0 1 1
|
|
list 0x25D2 0 1 0 1
|
|
list 0x25D3 1 0 1 0
|
|
list 0x25D4 0 0 1 0
|
|
list 0x25D5 0 1 1 1
|
|
foreach [{u LT LB RT RB} : items-of quarters] : sketch
|
|
define r : squareRadiusFW - GEOMETRYSTROKE / 2
|
|
set-width shapeWidth
|
|
include : union
|
|
begin glyphs.[MangleName 'whitecircle']
|
|
intersection
|
|
spiro-outline
|
|
g4 middleFW (symbolMid + r)
|
|
g4 (middleFW - r) symbolMid
|
|
g4 middleFW (symbolMid - r)
|
|
g4 (middleFW + r) symbolMid
|
|
close
|
|
create-glyph : glyph-construction
|
|
if LT : include : spiro-outline
|
|
corner middleFW symbolMid
|
|
corner middleFW (symbolMid + squareRadiusFW)
|
|
corner (middleFW - squareRadiusFW) (symbolMid + squareRadiusFW)
|
|
corner (middleFW - squareRadiusFW) symbolMid
|
|
if LB : include : spiro-outline
|
|
corner middleFW symbolMid
|
|
corner middleFW (symbolMid - squareRadiusFW)
|
|
corner (middleFW - squareRadiusFW) (symbolMid - squareRadiusFW)
|
|
corner (middleFW - squareRadiusFW) symbolMid
|
|
if RT : include : spiro-outline
|
|
corner middleFW symbolMid
|
|
corner middleFW (symbolMid + squareRadiusFW)
|
|
corner (middleFW + squareRadiusFW) (symbolMid + squareRadiusFW)
|
|
corner (middleFW + squareRadiusFW) symbolMid
|
|
if RB : include : spiro-outline
|
|
corner middleFW symbolMid
|
|
corner middleFW (symbolMid - squareRadiusFW)
|
|
corner (middleFW + squareRadiusFW) (symbolMid - squareRadiusFW)
|
|
corner (middleFW + squareRadiusFW) symbolMid
|
|
save [MangleName ('uni' + u)] [MangleUnicode u]
|
|
|
|
sketch
|
|
set-width shapeWidth
|
|
include : difference
|
|
begin glyphs.[MangleName 'blacklongrectangle']
|
|
begin glyphs.[MangleName 'blackcircle']
|
|
save [MangleName 'uni25D8'] [MangleUnicode 0x25D8]
|
|
|
|
sketch
|
|
set-width shapeWidth
|
|
include : difference
|
|
begin glyphs.[MangleName 'blacklongrectangle']
|
|
begin glyphs.[MangleName 'whitecircle']
|
|
save [MangleName 'uni25D9'] [MangleUnicode 0x25D9]
|
|
|
|
do 'Powerline Symbols'
|
|
sketch # branch
|
|
local fine : adviceBlackness 3.5
|
|
local y1 : mix parenBot parenTop 0.8
|
|
local y2 : mix parenBot parenTop 0.2
|
|
include : VBarLeft SB parenBot parenTop fine
|
|
include : dispiro
|
|
widths.rhs fine
|
|
flat RIGHTSB y1
|
|
curl RIGHTSB [mix y1 y2 0.4]
|
|
g4 (SB + fine * HVCONTRAST) y2 [heading LEFTWARD]
|
|
include : DotAt (RIGHTSB - fine * HVCONTRAST / 2) y1 [Math.max (fine * 1.5) PERIODRADIUS]
|
|
save 'branch' 0xE0A0
|
|
|
|
sketch # pwlLock
|
|
local fine : adviceBlackness 3.5
|
|
local y1 : mix parenBot parenTop 0.95
|
|
local y2 : mix parenBot parenTop 0.05
|
|
local lockTop : mix y2 y1 0.6
|
|
local lockLeft : SB / 2
|
|
local lockRight : WIDTH - SB / 2
|
|
local lockHoleWidth : 1 / 5
|
|
local lockHoleLeft : mix lockLeft lockRight (1 / 2 - lockHoleWidth / 2)
|
|
local lockHoleRight : mix lockLeft lockRight (1 / 2 + lockHoleWidth / 2)
|
|
local lockHoleTop : mix y2 lockTop 0.75
|
|
local lockHoleBottom : mix y2 lockTop 0.25
|
|
include : union
|
|
intersection
|
|
spiro-outline
|
|
corner 0 (2 * y1)
|
|
corner WIDTH (2 * y1)
|
|
corner WIDTH (lockTop - 1)
|
|
corner 0 (lockTop - 1)
|
|
close
|
|
OShape y1 y2 SB RIGHTSB fine (SMALLSMOOTHA) (SMALLSMOOTHB)
|
|
difference
|
|
spiro-outline
|
|
corner lockLeft lockTop
|
|
corner lockRight lockTop
|
|
corner lockRight y2
|
|
corner lockLeft y2
|
|
close
|
|
OShapeOutline lockHoleTop lockHoleBottom lockHoleLeft lockHoleRight fine (SMALLSMOOTHA * lockHoleWidth) (SMALLSMOOTHB * lockHoleWidth)
|
|
|
|
save 'pwlLock' 0xE0A2
|
|
|
|
return [object [ArrowShape exportArrowShape]]
|