alphabet.dir - OpenGrok cross reference for /dports/x11/xstroke/xstroke-0.5.12/etc/alphabet.dir

# alphabet -- xstroke alphabet configuration file
#
# xstroke is available from ftp://ftp.handhelds.org/pub/projects/xstroke
#
# Rather than hacking this file directly, you probably want to start
# with a file ~/.xstroke/alphabet that consists of a single line:
#
# 	include "/etc/xstroke/alphabet"
#
# Then, you may add your custom strokes to that file, (you'll want to
# add them before the include line so that your custom strokes take
# precedence over the strokes defined in /etc/xstroke/alphabet).

# Here is a summary of the syntax of this file:

# Blank lines are ignored.
# Lines beginning with a '#' character are comments and are ignored.

# INCLUDE STATEMENTS:
#
# An include statement looks like this: include "/path/to/some/file" It
# will open and read the file, which should have the same syntax as
# this file. File may be included to arbitrarily deep levels, but no
# checks are made to avoid infinite include loops, so Don't Do That.

# MODE DEFINITIONS:
#
# The alphabet file consists of a series of mode definitions which
# will have the following form:
#
#	Mode <MODE_NAME> [: <PARENT_MODE_NAME>, ... ]{
#		<stroke_definition>
#		...
#	}
#
# Where all mode names are quoted strings.
#
# xstroke always has one active mode, (whose name will be displayed in
# the control window). The user may change the active mode by using
# ModeShift and ModeLock strokes defined within the active mode, (or
# one of its parents).
#
# There are two mode names that have special meaning: __GLOBAL__ and
# __FALLBACK__. Strokes defined within the __GLOBAL__ mode take
# precedence over any strokes defined within the active mode. Strokes
# defined within __FALLBACK__ are available in all modes, but at a
# precedence lower than any other stroke within the mode.
#
# The logic used to search for recognized strokes is as follows: When
# the user enters a stroke, a probability is computed for each
# candidate stroke definition. The stroke definition with the highest
# probability is then returned. For the purpose of resolving stroke
# definitions with equal probabilities, the first definition
# encountered will be returned. Strokes within each mode are searched
# in the same order they are processed within the alphabet file. Modes
# are searched in the following order: the __GLOBAL__ mode, the active
# mode, the parents of the active mode (and recursively, all of their
# parents in depth-first order), and finally the __FALLBACK__ mode.

# STROKE DEFINITIONS:
#
# The meat of the alphabet file is stroke definitions of the form:
#
#	<action> = <stroke_regex>
#
# where <action> can be any of the following:
#
#	Key <keysym>
#	Button <button number>
#	ModeShift <mode_name>
#	ModeLock <mode_name>
#	Exec <program args...>
#
# The Key action emits a key press, (and release), event for the given
# keysym. You can find keysyms in /usr/include/X11/keysymdef.h, just
# drop the "XK_" prefix. Modifier keysyms may also be listed and they
# will do the Right Thing, (ie. they won't immediately cause a key
# press but will rather modify the next Key stroke).
#
# The Button action emits a button press, (and release), event at
# the location of the pointer at the end of the stroke.
#
# The ModeShift action performs a temporary change of the active mode
# to the given mode. After the next stroke, (whether successful or
# not), the active mode will revert to the current mode. (Modifier Key
# actions do not cause the mode to revert).
#
# The ModeLock action performs a persistent change of the active mode
# to the given mode. It will remain in effect until the next ModeLock
# action.
#
# The Exec action will cause the given command to be invoked. The
# command will be executed using /bin/sh so shell tricks are
# available.
#
# <stroke_regex> is a modern regular expression (see regex(7))
# consisting primarily of the the characters `, ^, ', >, l, v, /, <.
# These expression is the sequence of slopes that appear in the stroke
# with each character representing one of the 8 major directions as
# shown in the following diagram:
#
#	` ^ '
#	<   >
#	/ v l
#
# Hopefully the shape of each character will server as an easy
# mnemonic for the direction it represents.(I know that 'l' is a weak
# mnemonic but '\' wouldn't work as it would have to be represented as
# "\\" which is even worse than 'l').
#
# For example, an intuitive stroke for the letter L might be:
#
#	Key L = dir ( "v>" )
#
# Notice that the characters 'v' and '>' describe the path of an 'L'
# shape, ie. down, then right. This simple stroke is sufficient for
# defining an basic L, but unless you make an exceptionally sharp turn
# whenever you make an 'L', you will dint that the recognized stroke
# will often be "vl>", (ie. there is a smoother transition from down
# to right). The regular expression syntax makes it easy to define
# robust strokes that encompass both variations. For example, you
# could make the 'l' optional like so:
#
#	Key L = dir ( "vl?>" )
#
# Other regular expression features such as character classes (`[' and
# `]'), and repetition, ('*', '+'), may also be used as needed to define
# more reliable strokes.
#
# Feel free to let me know any comments/suggestions you might have.
# Have fun!
#
# -Carl Worth <cworth@handhelds.org>

Engine dir_length { }
#Engine grid { }

Engine anchor {
	Option "BorderWidthPercent" "5"
}

# First, the strokes for the global mode
Mode "__GLOBAL__" {
  Key BackSpace, OrientationCorrection 180 = {
	dir("<")
	doc("654")
  }
  Key Return = {
	dir("/")
	doc("357")
  }
  Key Control_L = {
	dir("/<`^'>l")
	grid("[^5]*")
	dir("/?<`^'>l?")
	doc("9823")
  }

  Key Meta_L = {
	dir("'?^`</v^`</vl?")
	doc("96[23]5[58]8[58]5[12]47")
  }

  # Full-screen bottom-to-top gives help
  Exec "xstroke-help" = {
	dir("`l")
	anchor("852")
  }

  # Bit of a kludge to be including keybindings for ion here, but I like 'em.
  Key Super_L, Key s = {
	dir(">")
	anchor("456")
  }
  Key Super_L, Key k, Key s = {
	dir("v")
	anchor("258")
  }
  Key Super_L, Key k, Key x = {
	dir("'")
	anchor("7[48]?5[26]?3")
  }
}

# And some convenient fallbacks, (like __GLOBAL__ except they can be overridden)
Mode "__FALLBACK__" {
  Key space, OrientationCorrection 0 =  { dir(">") doc("456") }

  # Pass short taps through as a button press
  Button 1 = { dir("") doc("5") }
}

# Next, the letters. By default, letter mode gets backwards numbers,
# but none of the backtracking capitals.

Mode "abc" : "numbers_in_letter_mode",
	     "punctuation_in_letter_mode",
	     "no_capitals_in_lowercase_mode"
{
Exec "xstroke-help" = {
	dir("`l")
	doc("95[15]1[15]59")
}

ModeShift "Abc", Key Shift_L, OrientationCorrection -90 = {
	dir("^")
	doc("852")
}
ModeShift "123" = {
	dir("`")
	doc("951")
}
ModeShift "!@#" = {
	dir("l")
	doc("159")
}

### NEWLINE

# stylized A
Key a = {
	dir("[^']+>?[lv]+")
	doc("729:straight")
}
# lowercase a
Key a = {
	dir("`?</vl>'^vl?")
	grid("[^5]*[321].*")
	doc("3286[36]3[36]69")
}

# B with optional bar
Key b = {
#	dir("v?^?.>.v.<>.v.<")
	dir("v?(/?<?`?|l?>?'?)^?'?(>?lv?|>l?v)/<?(`?^?'?|/?v?l?)>?lv?/<?[`^]*'?")
	doc("125[45]4[45]587")
	doc("74125[45]4[45]587")
	doc("14[47]7[47]4125[45]4[45]587")
}

# lowercase b
Key b = {
	dir("v^'>l?v/?<`?")
	grid("[^789]*[789][^123]*")
	doc("14[47]7[47]587")
}

# the letter c
Key c = {
	dir("`?</vl>'?")
	doc("3289")
}

# D shape with optional bar
Key d = {
	dir("v?`?^?'?>lv?/<`?^?")
	grid("[^5]*[87]4?")
	doc("1287")
	doc("741287")
	doc("14[47]7[47]41287")
}

# lowercase d starting with bar
Key d = {
	dir("vl?>?'?^`</vl>'?")
	doc("36[69]9[69][58]9")
}

# lowercase d starting with circle
Key d = {
	dir("`?</?vl>'^v?")
	grid("[^321]*5.*")
	doc("[69][58]963")
	doc("[69][58]96[36]3[36]69")
}

# stylized E shape like a mirror-image of a 3
# This is simply the the mirror-image of the B stroke
Key e = {
	dir("`?</vl>'?^?`?</vl>'?")
	doc("325[56]6[56]589")
}

# lowercase e shape
Key e = {
	dir(">'?^`</vl>?'?")
	doc("45524[78][89]")
}

# stylized F shape with optional initial curl
Key f = {
	dir("^?`?</?v")
	doc("[23]2[12][14]47")
	doc("[25][12][14]47")
}

Key f = {
	dir("^'?>")
	doc("7412[23]")
}

# G shape (in or in-and-out at end)
Key g = {
	dir("`?</vl>'^`?</?v?l?>?'?")
	grid("[^789]*[789][^123]*")
	doc("[23]24865")
}

# lowercase g shape with tail to left
Key g = {
	dir("`?</vl>'^v/?<?`?")
	doc("32[25][36]3[36][69][58]")
}

# typical lowercase h
Key h = {
	dir("vl?>?'?(^'?|^?')>lv")
	grid("[^789]*[789][^123]*")
	doc("14[47]7[47][58]8")
}

# i as vertical line down
Key i, OrientationCorrection 90 = {
	dir("v")
	doc("258")
}

# stylized J shape as backwards L
Key j = {
	dir("v/?<")
	doc("3698[78]")
}

# loopy sort of k-like shape
Key k = {
	dir("v?/<`^?'>lv?")
	grid(".*5.*")
	doc("3[56][58][45][25][56]9")
}

# L shape
Key l = {
	dir("vl?>")
	doc("1478[89]")
}

# M shape or lowercase m with optional initial down-stroke
Key m = {
	dir("v?`?^?'>?v?lv?^?'>?lv?")
	doc("7[12]8[23]9:straight")
	doc("74[12]5[58]8[58]5[23]69")
	doc("14[47]7[47]4[12]5[58]8[58]5[23]69")
}

# N shape starting at lower-left
Key n = {
	dir("^l>?'?^")
	doc("7193:straight")
}

# lowercase n
Key n = {
	dir("v^'>lv")
	grid("[^789]*[789].*[123].*")
	doc("14[47]7[47]4269")
}

# O as counter-clockwise circle starting at top
Key o = {
	dir("<?/vl>'^?`<?/?")
	doc("248622")
}

# custom P with just the curved part, drawn backwards, (like backwards D)
Key p = {
	dir("l?>'^`</?")
	grid("[^5]*")
	doc("7821")
}

# lowercase P with up-stroke or down-up stroke vertical bar
Key p = {
	dir("v?`?^'?>lv/<`?")
	grid(".*[123][^789]*")
	doc("741254")
	doc("14[47]7[47]41254")
}

# Q as counter-clockwise circle starting at bottom
Key q = {
	dir("l?>?'^`</vl>?")
	doc("862488")
}

# lowercase q with tail to the right
Key q = dir("`?</vl>'^vl?>")

# Also, it's not defined until no_capitals_in_lowercase_mode, but I'll
# display it here:
Key q = { doc("24862123") }

# lowercase r
Key r = {
	dir("v/?<?`?^'?>l?")
	doc("14[47]7[47]423")
}

# R shape
Key r = {
	dir("v?/?<?`?^'?>lv/<`?^?'?>lv?")
	doc("74125[45]4[45]5[89]")
	doc("14[47]7[47]4125[45]4[45]5[89]")
}

# your basic S shape
Key s = {
	dir("`?</vl>?l?v/<`?")
	doc("325698")
}

# stylized T as right->down
Key t = {
	dir(">l?v")
	doc("[12]2369")
}

# u shape
Key u = {
	dir("vl>'^v?")
	doc("148633")
	doc("1486[36]3[36]69")
}

# V shape
Key v = {
	dir("lv?l?^?'")
	doc("183:straight")
}

# V as backwards U
Key v = {
	dir("v?/<?(`^?|`?^)")
	doc("381:straight")
	doc("368411")
}

# w or W shape
Key w = {
	dir("(v?l|vl?)>?'^?(v?l|vl?)>?'^?")
	doc("14[78]5[25]2[25]5[89]63")
}

# loopy sort of x-like shape
Key x = {
	dir("v?l>'^?`</v?")
	grid(".*5.*")
	doc("1[45][58][56][25][45]7")
}

# y shape
Key y = {
	dir("vl>?'^v/?<?`?^?'?>?")
	doc("2[25][36]3[36]69")
	doc("2[25][36]3[36]69[89][56]6")
}

# basic z shape
Key z = {
	dir(">l?v?/v?l?>")
	doc("1379:straight")
}

### NEWPAGE
}

Mode "Abc":"abc"
{
    ModeLock "ABC", Key Caps_Lock, OrientationCorrection -90 = dir("^")
}

Mode "ABC":"abc"
{
    ModeLock "abc", OrientationCorrection -90 = dir("^")
}

#
#Mode "123":"!@#"
#{
#### Number mode [123]
#
## Need to override Return so it has precedence over ',' from [!@#]
#Key Return = grid("3[26]?5[48]?7?")
#
#ModeShift "!@#" = {
#	grid("1[24]?5[68]?9")
#	doc("159")
#}
#ModeLock "*123*" = grid("9[68]?5[24]?1?")
#
## In number mode we get to use the standard number shapes.
## standard 0
#Key 0 = {
#	grid("3?2?1?[54][45]?7?89?6[32]+1?4?")
#	doc("248622")
#}
#Key 0 = {
#	grid("1?2?3?[56][56]?9?87?41?2?3?6?")
#	doc("268422")
#}
## standard 1
#Key 1= {
#	grid("258")
#	doc("258")
#}
## 7 needs precedence over 2 for 123658
## standard 7 as T
#Key 7 = grid("1?23?([26]?5[48]?7?|65?[98]8?9?)")
## standard 2
#Key 2 = {
#	grid("1?23?[26]?5[48]?([47]*?[58]+|47?[58]*)[69]*")
#	doc("12578[89]")
#}
#Key 2 = grid("1?23?6[59]8[47]*[58]+[69]*")
## standard 3
#Key 3 = {
#	grid("4?(1?[2][369]+|1[25][369]*)([369]+[25]+[147]?[258]*[369]+|[25]*[147]+[258]+[369]*)([369]*[58][74]+|[369]+[58][74]*)")
#	doc("125[45]4[45]587")
#}
## standard 4 (as L)
#Key 4 = {
#	grid("1?47?89?6?")
#	doc("14789")
#}
## standard 4 (like the y stroke)
#Key 4 = {
#	grid("12?[45]+1?6?[23]*[56]*[89]+")
#	doc("2[25][36]3[36]69")
#}
## standard 5
#Key 5 = {
#	grid("6?3?[25]?5?[14]*[25]*[69]*+[58]*87?4?")
#	doc("325698")
#	doc("255698")
#}
## standard 6
#Key 6 = {
#	grid("3?[26]?[15]?[45][57]?8[59]?6?9?[58]+[47]*1?")
#	doc("24854")
#}
## 7 is defined above (before 2)
#Key 7 = {
#	doc("12357:straight")
#	doc("[12]2369")
#}
## a figure-eight
#Key 8= {
#	grid("3?2[14]?4?[25]+[69]?9?87?[4598]+[12356]*")
#	doc("325698563")
#}
## basic 9-shape
#Key 9 = {
#	grid("3?21?2?[45]*[789]*1?[256]+[32]+[56]+[89]*7?")
#	doc("32[25][36]3[36]69")
#}
#
#### NEWPAGE
#}
#
#Mode "*123*":"123"
#{
#    ModeLock "abc" = grid("9[68]?5[24]?1?")
#}
#
#Mode "!@#":"punctuation_in_letter_mode"
#{
#### Punctuation mode [!@\#]
#
#ModeLock "abc" = {
#	grid("1[24]?5[68]?9")
#	doc("159")
#}
#
#Key period = {
#	grid("5")
#	doc("5")
#}
#
#Key comma  = {
#	grid("3[26]?5[48]?7?")
#	doc("357")
#}
#
#Key quoteright,	OrientationCorrection 90 = {
#	grid("258")
#	doc("258")
#}
#
#Key quotedbl = {
#	grid("([87]*[45]5?[12]+|[87]+[45]5?[12]*)([456]*[789]+|[12][45]5?[789]*)[56]6?3?2?")
#	doc("7415963:straight")
#}
#
#Key less = {
#	grid("9?8[75]?4[15]?23?")
#	doc("842:straight")
#}
#
#Key greater = {
#	grid("7?8[59]?6[35]?21?4?")
#	doc("862:straight")
#}
#
#Key bracketleft = {
#	grid("(9?[8][147]+|9[58][147]*)([147]+[58]+[69]?[258]*[147]+|[58]*[69]+[258]+[147]*)([147]*[25][36]+|[147]+[25][36]*)")
#	doc("985[56]6[56]523")
#	doc("[89]8741")
#}
#
#Key bracketright= {
#	grid("(7?[8][369]+|7[58][369]*)([369]+[58]+[47]?[258]*[369]+|[58]*[47]+[258]+[369]*)([369]*[25][14]+|[369]+[25][14]*)")
#	doc("[78]8963")
#	doc("785[45]4[45]521")
#}
#
#Key minus, OrientationCorrection 0 = {
#	grid("456")
#	doc("456")
#}
#
#Key slash = {
#	grid("7[48]?5[26]?3")
#	doc("753")
#}
#
## XXX: this stroke doesn't work very well yet
#Key question = {
#	grid("4?1?23?[26]?54?7?")
#	doc("12547")
#}
#
#Key exclam, OrientationCorrection -90 = {
#	grid("852")
#	doc("852")
#}
#
#Key braceleft = {
#	grid("6?([36]?[25][147]+|[36][215][147]*)([147]+[258]+([36]?[258]*|9[658]+)[147]+|[258]*([36]+[25]+|9[658]+)[147]*)([147]*[58]9?6?|[147]+[58][96]*)")
#	doc("325[56]6[56]589")
#	doc("9874[14]1[14]47")
#}
#
#Key braceright = {
#	grid("4?([14]?[25][369]+|[14][235][369]*)([369]+[258]+([14]?[258]*|7[458]+)[369]+|[259]*([14]+[25]+|7[458]+)[369]*)([369]*[58]7?4?|[369]+[58][74]*)")
#	doc("7896[36]3[36]69")
#	doc("125[45]4[45]587")
#}
#Key braceright = grid("1?23?[26]?5[48]?7?89?[58]+[47]*8?")
#
#Key numbersign = {
#	grid("147[48]?5[26]?369")
#	doc("1475369:straight")
#}
#
#Key parenleft = {
#	grid("6?3?2[15]?47?[58]8?9?6?")
#	doc("248")
#}
#
#Key parenright = {
#	grid("1?2[35]?6[59]?87?4?")
#	doc("268")
#}
#
#Key dollar = {
#	grid("6?3?25?([369]+(58)?8?7?4?|[14]+[25]*(5[25]*[369]*5?87?4?|[369]*874?))")
#	doc("325698")
#}
#
#Key dollar = grid("6?3?25?15?4(7?[58]8?9?6?|[78]+9?6?9?)87?")
#
#Key backslash = {
#	grid("9[68]?5[24]?1?")
#	doc("951")
#}
#
#Key plus = {
#	grid("(3[26]?|3?[26])([58]8?)([48][57])?[47](1[24])?[57]?[68]?9")
#	doc("3[56][58][45][25][56]9")
#}
#
#Key equal = {
#	grid("1?2(3[26]?5[48]?7?|3?[26]?5[48]?7)89?")
#	doc("1235789:straight")
#}
#
#Key equal = grid("(123?|23)((56?5?)?8[47]|5?6?9[58]8?)7?4?[58]+[69]*")
#
#Key underscore = {
#	grid("4?5654?")
#	doc("45[56]6[56]54")
#}
#
#Key asterisk = {
#	grid("1?([24]?5|[24]7)([68][59])?6(3[256]1?)?[59]?[48]?7")
#	doc("1[45][58][56][25][45]7")
#}
#
#Key bar = {
#	grid("8?5258?")
#	doc("85[25]2[25]58")
#}
#
#Key semicolon = {
#	grid("3?[26]?5[48]?7?[48]?5[26]?3")
#	doc("35[57]7[57]53")
#}
#
#Key colon = {
#	grid("2?5852?")
#	doc("25[58]8[58]52")
#}
#
#Key Tab	 = {
#	grid("741?23")
#	doc("7412[23]")
#}
#
#Key Escape = {
#	grid("369?[68]?[58][24]?1")
#	doc("36951:straight")
#}
#Key Escape = grid("3?6?[56](8|987)[745]*41?")
#
## These five come last to avoid some precedence problems
#Key asciitilde = {
#	grid("3?69?[68]?[35]?[24]?147?")
#	doc("3695147:straight")
#}
#Key asciitilde = grid("3?6?[56](8|98)[7845]*41?2?[456]+[789]*")
#
#Key at	 = {
#	grid("3?(21?[54][45]?7?89?63?2?|2?1?[54]4?7?89?63?2)1?4?")
#	doc("248622")
#}
#
#Key at	 = {
#	grid("1?(23?[56][56]?9?87?41?2?|2?3?[56]6?9?87?41?2)3?6?")
#	doc("268422")
#}
#
#Key percent = {
#	grid("([12]*[45]+[789]+|[12][745]+[789]*)([78]*[45]*[123]*[456]*[789]+|[45]*[12]+[456]+[789]*)([789]*[56]+[32]+|[789]+[56]+[32]*)")
#	doc("1[45][78][47]5[69][89][56]3")
#	doc("183:straight")
#}
#
#Key ampersand = {
#	grid("3?2[14]?4?[25]+[69]?9?87?[4598]+[12356]*")
#	doc("325698563")
#}
#
#Key asciicircum = {
#	grid("[78]?[45]5?1?(23?[56]6?|4?5)8?9?8?")
#	doc("729:straight")
#}
#
#Key quoteleft = {
#	grid("9?[68]?5[24]?1?[24]?5[68]?9?")
#	doc("95[15]1[15]59")
#}
#
#}
#### NEWPAGE
#
Mode "no_capitals_in_lowercase_mode"
{
## n instead of A
#Key n = grid("[78]?[45]5?1?(23?(56?[89]+[856]*[124]*|6[89]+[856]*[1234]*)|4?58?9?[856]*4?[12]+)")
## s instead of C
#Key s = grid("6?3?25?15?4(7?[58]8?9?6?|[78]+9?6?9?)87?")
## z instead of D
#Key z = grid("(123?|23)((56?5?)?8[47]|5?6?9[58]8?)7?4?[58]+[69]*")
## r instead of D
#Key r = grid("[12]?([45][78]*4|[459]*[78]+[45]*)(123?|23)5?6?5?(8[47]|9[58]8?)7?4?[58]+[69]*")
## g instead of G
#Key g = grid("3?21?2?[45]?1?[256]*[32]*[56]+(98?7?|87)4?[58]*2?[369]*")
## w instead of H
#Key w = grid("[12]1?47[47]*8?[56]6?[89][56]*[23]*")
## d instead of J
#Key d = grid("2?(3?69?8[74]4?|(3?6|2)59?8[74]4?)7?8[69]*")
## b instead of L
#Key b = grid("1?47?89[58]*[47]*")
## m instead of N
#Key m = grid("([87]*[45]5?[12]+|[87]+[45]5?[12]*)([456]*[789]+|[45]5?6?[789]*)[56]6?3?2?[56]+[89]*")
## w instead of N
#Key w = grid("[12]*[45]+(7[45]+)(1?23?6|1[24][35]?6?|1[45]+8)9?[56]+[23]+")
## q instead of O
Key q = {
	dir("`?</vl>'^`?</?v?l?>'?")
	doc("24862123")
}
## p instead of R
#Key p = grid("([12]*[45]|[12][45]*)?[78]*4?5?1?23?[25]+[14]*")
## e instead of S
#Key e = grid("6?3?25?([369]+(58)?8?7?4?|[14]+[25]*(5[25]*[369]*5?87?4?|[369]*874?))[58]+[69]*")
## w instead of U
#Key w = grid("1?47?8[59]?[26]3?2?6(9[56]+)?[23]*")
## y instead of X
#Key y = grid("1?([24]?5|[24]7)([68][59])?6(3[256]1?)?3?5?[48]?78?9?[456]+[1236]*")
## b instead of Z
#Key b = grid("1?2(3[26]?5[48]?7?|3?[26]?5[48]?7)89?[58]+[47]*8?")
}
#
#Mode "capitals_in_lowercase_mode"
#{
## stylized A shape
#Key A = grid("[78]?[45]5?1?(23?(56?[89]+[856]*[124]*|6[89]+[856]*[1234]*)|4?58?9?[856]*4?[12]+)")
## a shape
#Key A = grid("6?(3?25?|32?5?)1?4([748]+56?|7?4?8[96]6?)[23]*(3[56][89]?8?|3?(6[89]|598?))[56]*[23]*")
#
## B with optional bar
#Key B = grid("([12]*[45]+[78]|[12][45]+[78])?[78]*[45]*(1?[2][369]+|1[25][369]*)([369]+[25]+[147]?[258]*[369]+|[25]*[147]+[258]+[369]*)([369]*[58][74]+|[369]+[58][74]*)[58]+[69]*8?")
## lowercase b shape
#Key B = grid("[21][21]?[54]4?[78]+4?8?58?[69]9?87?4?[58]*[69]*")
#
## the letter c
#Key C = grid("6?3?25?15?4(7?[58]8?9?6?|[78]+9?6?9?)87?")
#
## D shape with optional bar
#Key D = grid("(123?|23)((56?5?)?8[47]|5?6?9[58]8?)7?4?[58]+[69]*")
#Key D = grid("[12]?([45][78]*4|[459]*[78]+[45]*)(123?|23)5?6?5?(8[47]|9[58]8?)7?4?[58]+[69]*")
## lowercase d starting with bar
#Key D = grid("(3?6(56)?|26?5(6[89]+)?|23?6?9)[89]*[658]*[32]*[15]?([47]+|[58]+)89?[69]+[58]+[47]+")
## lowercase d starting with circle
#Key D = grid("9?6?[258]+[47]7?[258]+9?[256]?[23]+[56]*9?[89]*[56]+[23]*")
#
## stylized E shape like a mirror-image of a 3
## This is simply the the mirror-image of the B stroke
#Key E = grid("([36]?[25][147]+|[36][215][147]*)([147]+[258]+([36]?[25]*|9[658]+)[147]+|[258]*([36]+[25]+|9[658]+)[147]*)([147]*8[96]6?|[147]+8[96]*)[58]+[47]*8?")
## e shape
#Key E = grid("1?[47]?2?[58]?2?6?3?[25]+1?4[57]?89?6?[58]+[47]*")
#
## stylized F shape with optional initial curl
#Key F = grid("6?3?21?478?7?[45]*[12]*")
#
## i and I need precedence over g and G
## I as vertical downward stroke
#Key I = grid("2?58?52")
#
## G shape (in-and-out-and-in at end)
#Key G = grid("3?21?5?45?7?89?((6?5|68)|85)([47]+[258]+([369]+[258]+)?|[47]*[258]+([369]+[258]+))[147]*")
## lowercase g shape with tail to left
#Key G = grid("3?21?2?[45]1?[256]+[32]+[56]+(98?7?|87)4?[58]*[69]*")
#
## typical lowercase h
#Key H = grid("[12]1?47[47]*8?[56]6?[89][56]*[23]*")
#
## i is defined above (before G)
#
## stylized J shape as backwards L
#Key J = grid("2?(3?69?8[74]4?|(3?6|2)59?8[74]4?)7?8[69]*")
#
## loopy sort of k-like shape
#Key K = grid("(3[26]?|3?[26])([58]8?)([48][57])?[47]+(1[24]3?)?1?[57]?[68]?9[568]+([12347]|5)[1245]*")
#
## L shape
#Key L = grid("1?47?89[58]*[47]*")
#
## M shape or lowercase m with optional initial down-stroke
#Key M = grid("([12]*[45]|[12][45]*)?([78]*[45]+[123]+|[78][145]+[123]*)(([123]+[456]+[789]*|[456]+[789]+)[456]*[123]+|[456]*[789]+[456]+[123]*)([123]*[56]+[98]+|[123]+[56]+[98]*)[56]+[23]*")
#
## N shape starting at lower-left
#Key N = grid("([87]*[45]5?[12]+|[87]+[45]5?[12]*)([456]*[789]+|[45]5?6?[789]*)[56]6?3?2?[56]+[89]*")
## n shape
#Key N = grid("[12]*[45]+(7[45]+)(1?23?6|1[24][35]?6?|1[45]+8)9?[56]+[23]+")
#
## O as counter-clockwise circle starting at top
#Key O = grid("3?([26][15]?[54]4?7?8[59]?[65]5?3?2?|[26]?[15]?[54]4?7?8[59]?[65]5?3?2)1?4?[25]+[36]*")
#
## custom P with just the curved part, drawn backwards, (like backwards D)
#Key P = grid("7?8[59]?63?[52]2?([14]4?[25]+3?|[25]+3)")
## P with up-stroke or down-up stroke vertical bar
#Key P = grid("([12]*[456]+|[12][456]*)?([789]*4|[789]+[45]+)1?2[36]?(6|(6?(2?5|25?)2?8?[147]*|[25]*8?1?41?7?))[25]+[36]*")
#
## Q as counter-clockwise circle starting at bottom
#Key Q = grid("4?[57]?([48][59]?63?2[15]?[45][57]?|[48]?[59]?63?2[15]?[45][57]?)(87|8?9?6?9[58]+[47]*[58]*)")
#
## lowercase r
#Key R = grid("([12]*[45]|[12][45]*)[78]*4?5?1?23?[25]+[14]*")
## R shape
#Key R = grid("([12]*4)?[78]*[45]+[12]2?([369]*[25]+[14]|[369]+[258]+)([147]*[258]*[68]?9|[147]+[258]+[68]?9?)[68]?[57][24]?1?4?")
#
## your basic S shape
#Key S = grid("6?3?25?([369]+(58)?8?7?4?|[14]+[25]*(5[25]*[369]*5?87?4?|[369]*874?))[58]+[69]*")
#
## stylized T as right->down
#Key T = grid("1?23?65?([23]+|[98]8?9?)[56]+[23]*")
#
## u shape (down-up tail)
#Key U = grid("1?47?8[59]?[26]3?2?6(9[56]+)?[23]*")
#
## V shape
#Key V = grid("1?[245]5?[78]8?[49]?[256]+3[56]*9?8")
#Key V = grid("1?[245]5?8[49]?[256]+3[56]*9?8?")
#Key V = grid("1?[245]5?78?[49]?[56]*[23]+[56]*9?87?")
## V as backwards U
#Key V = grid("3?6?[56](8|987)[7845]*41?2?[456]+[789]*")
#Key V = grid("3?6?[56](8|98)[745]*41?2?[456]+[89]*")
#
## w or W shape
#Key W = grid("([12]*[45][789]+|[12][745][789]*)(([78]+[456]+[123]*|[45]+[12]+)4?5?6?[789]+|[45]*[12]+[456]+[789]*)([789]*[569]+[32]+|[789]+[569]+[32]*)[56]*[89]*")
#
## loopy sort of x-like shape
#Key X = grid("1?([24]?5|[24]7)([68][59])?6(3[256]1?)?3?5?[48]?78?9?[456]+[1236]*")
#
## y shape (down-up-down tail)
#Key Y = grid("1?2?[45]+1?([789]+[45]*)?6?[23]+[56]*[89]+7?8?[456]+([23]+[56]+)?[89]*9[89]*")
#
## basic z shape
#Key Z = grid("1?2(3[26]?5[48]?7?|3?[26]?5[48]?7)89?[58]+[47]*8?")
#}
#
#Mode "numbers_in_letter_mode"
#{
#### Numbers in letter mode [abc]
## 0 as clockwise circle
#Key 0 = {
#	grid("1?2?3?69?87?41?2?3?")
#	doc("268422")
#}
#
## 1 is defined way up above A
#Key 1 = {
#	dir ("^v")
#	doc("85[25]2[25]58")
#}
#
## 2 drawn backwards (starting at bottom)
#Key 2 = {
#	grid("9?8([74][48]?[58]9?[26]?3?|7?[48]?[58]9?[26]?[63]3?)21?4?")
#	doc("[89]87521")
#}
#
## 3 drawn backwards (starting at bottom)
#Key 3 = {
#	grid("(7?[8][369]+|7[58][369]*)([369]+[58]+[47]?[258]*[369]+|[58]*[47]+[258]+[369]*)([369]*[25][14]+|[369]+[25][14]*)")
#	doc("785[45]4[45]521")
#}
#
## 4 as y drawn backwards, (starting at bottom)
#Key 4 = {
#	grid("[89]9?5?65?36?9?(87?4|54?)1?2?")
#	doc("96[36]3[36][25]2")
#}
#
## 6 needs precedence over 5
## 6 drawn backwards (starting at circle)
#Key 6 = grid("7?4?[58][69]*87?4[15]?2?3?")
#
## 5 drawn backwards (starting at bottom)
#Key 5 = {
#	grid("([47]*[58]5?[69]+|[47]+[58]5?[69]*)([58]*[147]+(25)?|[58]+[147]*5?2)23?6?")
#	doc("896523")
#}
#
#Key 6 = doc("[47][58]842")
#
## 7 drawn backwards (starting at bottom)
#Key 7 = {
#	grid("963?21")
#	doc("9632[12]")
#}
#
## standard 8
#Key 8 = {
#	grid("3?2[14]?4?[25]+[69]9?87?[4598]+[12356]*")
#	doc("325698563")
#}
## 8 drawn backwards
#Key 8 = {
#	grid("1?2[36]?6?[25]+[47]7?89?[5678]+[12345]*")
#	doc("236589652")
#}
#
## 9 drawn backwards (starting with circle)
#Key 9 = {
#	grid("3?6?(5[41]*|2[41]*4[41]*)23?69?8?9?")
#	doc("[36][25]2369")
#}
#
## 9 drawn backwards (starting with tail)
#Key 9 = {
#	grid("[789]*[56]+3?2[14]4?(2?52?[36]*|[25]*63?)")
#	doc("9632[25][36]")
#}
#
#}
#
#Mode "punctuation_in_letter_mode"
#{
#### Punctuation in letter mode [abc]
#
#Key Escape = {
#	grid("369?[68]?[58][24]?1")
#	doc("36951:straight")
#}
#
#
#Key Tab	 = {
#	grid("741?2(32)?1?")
#	doc("7412[23]21")
#}
#
#Key period = {
#	grid("65456")
#	doc("65[45]4[45]6")
#}
#
#Key comma = {
#	grid("3?2123?[26]?5[48]?7?")
#	doc("32[12]1[12]357")
#}
#
#Key colon = {
#	grid("3?2(12)?3?6[89]+")
#	doc("32[12]1[12]369")
#}
#
#Key exclam = {
#	grid("2?5(85?)?2?58?5?")
#	doc("25[58]8[58]5258")
#}
#
#Key minus = {
#	grid("45654")
#	doc("45[56]6[56]54")
#}
#
## XXX: I replaced this with 'e'. Need a new stroke here...
#Key equal = {
#	grid("1?2(32)?1?47?89?")
#	doc("12[23]3[23]289")
#}
#
#Key question = {
#	grid("1?23?21?[45][78]+")
#	doc("12[23]3[23]2147")
#}
#
#Key underscore = {
#	grid("4?5(65)?456?")
#	doc("45[56]6[56]5456")
#}
#
## XXX: need to combine
#Key plus = grid("2587456")
#Key plus = grid("1458?[74]4?56")
#Key plus = grid("1?258?[74]4?56")
#Key plus = grid("2?3[56]9?87?456?")
#
## bar is defined way up above A for precedence
#Key bar = {
#	dir("^v^")
#	doc("85[25]2[25]5852")
#}
#Key bar	 = grid("7?4147?89")
#Key bar	 = grid("9?6369?87")
#
#Key bracketleft = {
#	grid("987?41")
#	doc("98741")
#}
#
#Key bracketright = {
#	grid("789?63")
#	doc("78963")
#}
#
#Key braceleft = {
#	grid("(654?|987?4)14[78]?")
#	doc("9874[14]1[14]47")
#}
#
#Key braceright = {
#	grid("(456?|789?6)36[89]?")
#	doc("7896[36]3[36]69")
#}
#
#Key less = {
#	grid("987[48]?5[26]?3?")
#	doc("-98753")
#}
#
#Key greater = {
#	grid("789[68]?5[24]?1?")
#	doc("-78951")
#}
#
#Key parenleft = {
#	grid("9?[68]?5([24]?1|[24]1?)2[36]*")
#	doc("95123:straight")
#}
#
#Key parenright = {
#	grid("7?[48]?5([26]?3|[36]3?)2[14]*")
#	doc("75321:straight")
#}
#
#Key quoteright = {
#	grid("7[48]?5[26]?3?[26]?5[48]?7?")
#	doc("75[35]3[35]57")
#}
#Key quoteright = grid("7?[48]?5[26]?3?[26]?5[48]?7")
#
#Key quoteleft = {
#	grid("1[24]?5[68]?9?([68]?5[24]?|84)1?")
#	doc("15[59]9[59]51")
#}
#Key quoteleft = grid("1?[24]?5[68]?9?([68]?5[24]?|84)1")
#
#Key quotedbl = {
#	grid("147[48]?54?5?[26]?32?3?69")
#	doc("1475369:straight")
#}
#
#Key semicolon = {
#	grid("3?[26]?5[48]?7?[48]?5[26]?3")
#	doc("35[57]7[57]53")
#}
#
#Key slash = {
#	grid("7[48]?5[26]?3")
#	doc("753")
#}
#
## XXX: need something else for backslash if this will be puncshift
##Key backslash = grid("1[24]?5[68]?9")
#
#Key percent = {
#	grid("([32]*[56]+[789]+|[32][569]+[789]*)([89]*[56]*[123]*[456]*[789]+|[56]*[23]+[456]+[789]*)([789]*[45]+[12]+|[789]+[45]+[12]*)")
#	doc("3[56][89][69]5[47][78][45]1")
#}
#
#Key asciicircum = {
#	grid("8?9[68]?5?[34]?(2?1?[54]4?|6?5)[78]*")
#	doc("927:straight")
#}
#
#Key numbersign = {
#	grid("9?63?[26]?56?5?[48]?741?")
#	doc("9635741:straight")
#}
#
#Key asciitilde = {
#	grid("3?69?[68]?5?[24]?147?")
#	doc("3695147")
#}
#
## XXX: what stroke do we want for asterisk?
#Key asterisk    = grid("7[48]?[15]([26][53])?6(9[568]7?)?[53]?[24]?1")
#
#Key ampersand = {
#	grid("9[68]?5?[24]?1?47?89?")
#	doc("9514789")
#}
#
#Key at	 = {
#	grid("2?589?63?21?47?8?9?[89]?")
#	doc("55862488")
#}
#
## XXX: right now, dollar conflicts with 8
#Key dollar = grid("3?2[14]?4?[58]+[69]?9?874[12][12]?")
#
#### NEWPAGE
#}
#