layout

Documentation

Index

• Constants
• Variables
• type Finger
  • func (f Finger) String() string
• type FingerUsage
  • func (fu FingerUsage) String() string
• type Hand
  • func (h *Hand) Move(finger Finger, pos Vec2) Vec2
• type Key
  • func ActivationGroup(activation []string, keys ...Key) []Key
  • func AddUppercase(activation []string, keys []Key) []Key
  • func Cluster(side Side, finger Finger, keyss ...[]Key) []Key
  • func Column(keys ...Key) []Key
  • func Flatten(keyss ...[]Key) []Key
  • func (k Key) String() string
• type Layout
  • func New(keys []Key, state *State) *Layout
  • func Permutations(keys []Key, state *State, text string) []*Layout
  • func (l *Layout) Analyze(text string) (Stats, error)
• type Side
• type State
  • func (s *State) Clone() *State
  • func (s *State) Move(k Key) Vec2
• type Stats
  • func (s Stats) String() string
• type Vec2
  • func (v Vec2) Len() float64
  • func (v Vec2) Point() image.Point
  • func (v Vec2) Sub(rhs Vec2) Vec2

Constants

const U1 = 20 * distance.MM

Variables

var ColemakDH34Keys = Flatten(
	Cluster(LeftSide, PinkyFinger,
		AddUppercase([]string{"rshift"}, Column(
			Key{Char: 'q'},
			Key{
				Char:   'a',
				IsHome: true,
			},
			Key{Char: 'x'},
		)),
		ActivationGroup([]string{"layer 1"},
			Key{Char: '1'},
		),
	),
	Cluster(LeftSide, RingFinger,
		AddUppercase([]string{"rshift"}, Column(
			Key{Char: 'w'},
			Key{
				ID:     "lshift",
				Char:   'r',
				IsHome: true,
			},
			Key{Char: 'c'},
		)),
		ActivationGroup([]string{"layer 1"},
			Key{
				ID:   "2",
				Char: '2',
			},
		),
	),
	Cluster(LeftSide, MiddleFinger,
		AddUppercase([]string{"rshift"}, Column(
			Key{Char: 'f'},
			Key{
				Char:   's',
				IsHome: true,
			},
			Key{Char: 'd'},
		)),
		ActivationGroup([]string{"layer 1"},
			Key{Char: '3'},
		),
	),
	Cluster(LeftSide, IndexFinger,
		AddUppercase([]string{"rshift"}, Column(
			Key{Char: 'p'},
			Key{
				Char:   't',
				IsHome: true,
			},
			Key{Char: 'v'},
		)),
		AddUppercase([]string{"rshift"}, Column(
			Key{
				Char: 'b',
				Pos:  Vec2{X: int(U1)},
			},
			Key{
				Char: 'g',
				Pos:  Vec2{X: int(U1)},
			},
			Key{
				Char: 'z',
				Pos:  Vec2{X: int(U1)},
			},
		)),
		ActivationGroup([]string{"layer 1"},
			Key{Char: '4'},
			Key{
				Char: '5',
				Pos:  Vec2{X: int(U1)},
			},
		),
	),

	Cluster(RightSide, PinkyFinger,
		Column(
			Key{Char: ';'},
			Key{
				Char:   'o',
				IsHome: true,
			},
			Key{Char: '/'},
		),
		ActivationGroup([]string{"lshift"},
			Column(
				Key{Char: ':'},
				Key{Char: 'O'},
				Key{Char: '?'},
			)...,
		),
		ActivationGroup([]string{"layer 1"},
			Key{Char: '0'},
			Key{
				Char: '\'',
				Pos: Vec2{
					X: 0,
					Y: int(U1),
				},
			},
		),
	),
	Cluster(RightSide, RingFinger,
		Column(
			Key{Char: 'y'},
			Key{
				ID:     "rshift",
				Char:   'i',
				IsHome: true,
			},
			Key{Char: '.'},
		),
		ActivationGroup([]string{"lshift"},
			Column(
				Key{Char: 'Y'},
				Key{Char: 'I'},
				Key{Char: '>'},
			)...,
		),
		ActivationGroup([]string{"layer 1"},
			Key{Char: '9'},
		),
	),
	Cluster(RightSide, MiddleFinger,
		Column(
			Key{Char: 'u'},
			Key{
				Char:   'e',
				IsHome: true,
			},
			Key{Char: ','},
		),
		ActivationGroup([]string{"lshift"},
			Column(
				Key{Char: 'U'},
				Key{Char: 'E'},
				Key{Char: '<'},
			)...,
		),
		ActivationGroup([]string{"layer 1"},
			Key{Char: '8'},
		),
	),
	Cluster(RightSide, IndexFinger,
		AddUppercase([]string{"lshift"}, Column(
			Key{
				Char: 'l',
				Pos: Vec2{
					X: int(U1),
				},
			},
			Key{
				Char:   'n',
				IsHome: true,
				Pos: Vec2{
					X: int(U1),
				},
			},
			Key{
				Char: 'h',
				Pos: Vec2{
					X: int(U1),
				},
			},
		)),
		AddUppercase([]string{"lshift"}, Column(
			Key{Char: 'j'},
			Key{Char: 'm'},
			Key{Char: 'k'},
		)),
		ActivationGroup([]string{"layer 1"},
			Key{
				Char: '7',
				Pos: Vec2{
					X: int(U1),
				},
			},
			Key{Char: '6'},
		),
	),

	Cluster(LeftSide, ThumbFinger,
		[]Key{
			{
				ID:     "left space",
				Char:   ' ',
				Finger: ThumbFinger,
				IsHome: true,
			},
			{
				ID: "layer 1",
				Pos: Vec2{
					X: int(U1),
					Y: int(U1) / 2,
				},
			},
		},
	),
	Cluster(RightSide, ThumbFinger,
		[]Key{
			{
				ID:     "right esc",
				IsHome: true,
			},
			{
				ID: "right tab",
				Pos: Vec2{
					X: int(U1),
					Y: int(U1) / 2,
				},
			},
		},
	),
)

var Ukrainian34 = Flatten(
	Cluster(LeftSide, PinkyFinger,
		AddUppercase([]string{"rshift"}, Column(
			Key{Char: 'й'},
			Key{
				Char:   'ф',
				IsHome: true,
			},
			Key{Char: 'я'},
		)),
		ActivationGroup([]string{"ukr"},
			Column(
				Key{},
				Key{},
				Key{},
			)...,
		),
		ActivationGroup([]string{"l1"},
			Key{Char: '1'},
		),
		ActivationGroup([]string{"l1", "rb"},
			Key{Char: '!'},
		),
	),
	Cluster(LeftSide, RingFinger,
		AddUppercase([]string{"rshift"}, Column(
			Key{Char: 'ц'},
			Key{
				ID:     "lshift",
				Char:   'і',
				IsHome: true,
			},
			Key{Char: 'ч'},
		)),
		ActivationGroup([]string{"ukr"},
			Column(
				Key{},
				Key{Char: 'ї'},
				Key{Char: 'Ї'},
			)...,
		),
		ActivationGroup([]string{"l1"},
			Key{Char: '2'},
		),
		ActivationGroup([]string{"l1", "rb"},
			Key{Char: '"'},
		),
	),
	Cluster(LeftSide, MiddleFinger,
		AddUppercase([]string{"rshift"}, Column(
			Key{Char: 'у'},
			Key{
				Char:   'в',
				IsHome: true,
			},
			Key{Char: 'с'},
		)),
		ActivationGroup([]string{"ukr"},
			Column(
				Key{},
				Key{},
				Key{},
			)...,
		),
		ActivationGroup([]string{"l1"},
			Key{Char: '3'},
		),
		ActivationGroup([]string{"l1", "rb"},
			Key{Char: '№'},
		),
	),
	Cluster(LeftSide, IndexFinger,
		AddUppercase([]string{"rshift"}, Column(
			Key{Char: 'к'},
			Key{
				Char:   'а',
				IsHome: true,
			},
			Key{Char: 'м'},
		)),
		AddUppercase([]string{"rshift"}, Column(
			Key{
				Char: 'е',
				Pos:  Vec2{X: int(U1)},
			},
			Key{
				Char: 'п',
				Pos:  Vec2{X: int(U1)},
			},
			Key{
				Char: 'и',
				Pos:  Vec2{X: int(U1)},
			},
		)),
		ActivationGroup([]string{"ukr"},
			Column(
				Key{Char: 'х'},
				Key{Char: 'Х'},
				Key{},
			)...,
		),
		ActivationGroup([]string{"ukr"},
			Column(
				Key{
					Char: 'є',
					Pos:  Vec2{X: int(U1)},
				},
				Key{
					Char: 'Є',
					Pos:  Vec2{X: int(U1)},
				},
				Key{
					Pos: Vec2{X: int(U1)},
				},
			)...,
		),
		ActivationGroup([]string{"l1"},
			Key{Char: '4'},
			Key{
				Char: '5',
				Pos:  Vec2{X: int(U1)},
			},
		),
		ActivationGroup([]string{"l1", "rb"},
			Key{Char: ';'},
			Key{
				Char: '%',
				Pos:  Vec2{X: int(U1)},
			},
		),
	),

	Cluster(RightSide, PinkyFinger,
		AddUppercase([]string{"lshift"}, Column(
			Key{Char: 'з'},
			Key{
				Char:   'ж',
				IsHome: true,
			},
			Key{Char: '.'},
		)),
		ActivationGroup([]string{"lshift"},
			Key{
				Char: ',',
				Pos: Vec2{
					Y: 3 * int(U1),
				},
			},
		),
		ActivationGroup([]string{"ukr"},
			Column(
				Key{},
				Key{Char: '\''},
				Key{},
			)...,
		),
		ActivationGroup([]string{"l1"},
			Key{Char: '0'},
			Key{
				Char: '\'',
				Pos: Vec2{
					X: 0,
					Y: int(U1),
				},
			},
		),
		ActivationGroup([]string{"l1", "rb"},
			Key{Char: ')'},
		),
	),
	Cluster(RightSide, RingFinger,
		AddUppercase([]string{"lshift"}, Column(
			Key{Char: 'щ'},
			Key{
				ID:     "rshift",
				Char:   'д',
				IsHome: true,
			},
			Key{Char: 'ю'},
		)),
		ActivationGroup([]string{"ukr"},
			Column(
				Key{},
				Key{},
				Key{},
			)...,
		),
		ActivationGroup([]string{"l1"},
			Key{Char: '9'},
		),
		ActivationGroup([]string{"l1", "rb"},
			Key{Char: '('},
		),
	),
	Cluster(RightSide, MiddleFinger,
		AddUppercase([]string{"lshift"}, Column(
			Key{Char: 'ш'},
			Key{
				Char:   'л',
				IsHome: true,
			},
			Key{Char: 'б'},
		)),
		ActivationGroup([]string{"ukr"},
			Column(
				Key{},
				Key{},
				Key{},
			)...,
		),
		ActivationGroup([]string{"l1"},
			Key{Char: '8'},
		),
		ActivationGroup([]string{"l1", "rb"},
			Key{Char: '*'},
		),
	),
	Cluster(RightSide, IndexFinger,
		AddUppercase([]string{"lshift"}, Column(
			Key{
				Char: 'г',
				Pos: Vec2{
					X: int(U1),
				},
			},
			Key{
				Char:   'о',
				IsHome: true,
				Pos: Vec2{
					X: int(U1),
				},
			},
			Key{
				Char: 'ь',
				Pos: Vec2{
					X: int(U1),
				},
			},
		)),
		AddUppercase([]string{"lshift"}, Column(
			Key{Char: 'н'},
			Key{Char: 'р'},
			Key{Char: 'т'},
		)),
		ActivationGroup([]string{"rb"},
			Key{
				Char: '-',
				Pos: Vec2{
					Y: int(U1),
				},
			},
		),
		ActivationGroup([]string{"ukr"},
			Column(
				Key{},
				Key{},
				Key{},
			)...,
		),
		ActivationGroup([]string{"ukr"},
			Column(
				Key{
					Char: 'ґ',
					Pos:  Vec2{X: int(U1)},
				},
				Key{
					Char: 'Ґ',
					Pos:  Vec2{X: int(U1)},
				},
				Key{
					Pos: Vec2{X: int(U1)},
				},
			)...,
		),
		ActivationGroup([]string{"l1"},
			Key{
				Char: '7',
				Pos: Vec2{
					X: int(U1),
				},
			},
			Key{Char: '6'},
		),
		ActivationGroup([]string{"l1", "rb"},
			Key{
				Char: '?',
				Pos: Vec2{
					X: int(U1),
				},
			},
			Key{Char: ':'},
		),
	),

	Cluster(LeftSide, ThumbFinger,
		[]Key{
			{
				ID:     "lb",
				Char:   ' ',
				Finger: ThumbFinger,
				IsHome: true,
			},
			{
				ID: "l1",
				Pos: Vec2{
					X: int(U1),
					Y: int(U1) / 2,
				},
			},
		},
	),
	Cluster(RightSide, ThumbFinger,
		[]Key{
			{
				ID:     "rb",
				IsHome: true,
			},
			{
				ID: "ukr",
			},
			{
				ID: "rs",
				Pos: Vec2{
					X: int(U1),
					Y: int(U1) / 2,
				},
			},
		},
	),
)

Types

type Finger

type Finger byte

const (
	ThumbFinger Finger
	IndexFinger
	MiddleFinger
	RingFinger
	PinkyFinger
)

func (Finger) String

func (f Finger) String() string

type FingerUsage

type FingerUsage struct {
	Thumb  uint
	Index  uint
	Middle uint
	Ring   uint
	Pinky  uint
}

func (FingerUsage) String

func (fu FingerUsage) String() string

type Hand

type Hand struct {
	Thumb  Vec2
	Index  Vec2
	Middle Vec2
	Ring   Vec2
	Pinky  Vec2
}

func (*Hand) Move

func (h *Hand) Move(finger Finger, pos Vec2) Vec2

type Key

type Key struct {
	ID     string
	Char   rune
	Pos    Vec2
	Finger Finger
	Side   Side
	IsHome bool
	// Activation is a list of key ids required to press this key
	Activation []string
}

func ActivationGroup

func ActivationGroup(activation []string, keys ...Key) []Key

func AddUppercase

func AddUppercase(activation []string, keys []Key) []Key

func Cluster

func Cluster(side Side, finger Finger, keyss ...[]Key) []Key

func Column

func Column(keys ...Key) []Key

func Flatten

func Flatten(keyss ...[]Key) []Key

func (Key) String

func (k Key) String() string

type Layout

type Layout struct {
	Keys  []Key
	State *State
	// contains filtered or unexported fields
}

func New

func New(keys []Key, state *State) *Layout

func Permutations

func Permutations(keys []Key, state *State, text string) []*Layout

func (*Layout) Analyze

func (l *Layout) Analyze(text string) (Stats, error)

type Side

type Side bool

const (
	LeftSide  Side = false
	RightSide Side = true
)

type State

type State struct {
	Left  *Hand
	Right *Hand
}

func (*State) Clone

func (s *State) Clone() *State

func (*State) Move

func (s *State) Move(k Key) Vec2

type Stats

type Stats struct {
	TotalDistance float64
	FingerUsage   struct {
		Left  FingerUsage
		Right FingerUsage
	}
}

func (Stats) String

func (s Stats) String() string

type Vec2

type Vec2 struct {
	X int
	Y int
}

func (Vec2) Len

func (v Vec2) Len() float64

func (Vec2) Point

func (v Vec2) Point() image.Point

func (Vec2) Sub

func (v Vec2) Sub(rhs Vec2) Vec2