The nkeymaps Reference Manual

Next: , Previous: , Up: (dir)   [Contents][Index]

The nkeymaps Reference Manual

This is the nkeymaps Reference Manual, version 1.0.0, generated automatically by Declt version 4.0 beta 2 "William Riker" on Tue Nov 15 06:45:31 2022 GMT+0.

Table of Contents


1 Introduction

#+TITLE: NKeymaps
#+SUBTITLE: General-purpose keymap management

This keymap library is inspired by [[https://savannah.nongnu.org/projects/emacsy][Emacsy]] (=keymap.scm=), which in turn is
inspired by Emacs.

The main types are:

- A =key= structure has a hardware =code=, a symbolic =value=, an ordered set of
  modifiers (the order is to avoid inequality on permutation) and possibly more
  in the future.

  Whitespaces are the only reserved characters.  Anything else can be stored in
  the =key= value.

- A =keyspec= is a string representation of a =key=.  A =keyspec= is a
  space-separated string representation of a sequence of =key=s.

- A =keymap= contains a hash-table where the keys are a =keyspec= and the values
  are either a keymap or anything else.  As a special case, a =nil= value
  unbinds the key.

** Goals

- Support prefix keys to other keymaps.  For instance, prefixing my-mode-map
  with =C-c= makes all bindings for my-mode accessible after pressing =C-c=.
- List all bindings matching a given prefix.  (Also known as =which-key= in
  Emacs.)
- List the bindings associated to a command.
- Support multiple inheritance.
- Support keycode.
- Validate keyspec at compile time.
- ~define-key~ can set multiple bindings in a single call.
- Support multiple keyschemes to make it easy to switch between, say, Emacs-style
  and VI-style bindings.  This orthogonality to keymaps composes better than
  having multiple keymaps: changing keyscheme applies to the entire program, which
  is easier than looping through all keymaps to change them.
- Translate keyspecs as a fallback.  For instance if =shift-a= is unbound, check
  =A=.
- Customizable behaviour with global parameters such as ~*print-shortcut*~.
- The ~compose~ function can merge multiple keymaps together.
- Support multiple arguments when that makes sense (e.g. multiple keymaps for
  ~lookup-key~).
- Key remapping à-la Emacs.
- Typed keymaps, i.e. keymaps where bound values can only be of a given type.
  This is convenient to catch typos, for instance when binding ='FOO= instead of
  =#'FOO=.

** Non-goals

- Customizable modifiers: the input system must decide how to map =meta=,
  =control=, etc.
- Dead key support: the input system must handle it.
- Fallback function when binding is not found: the caller of =lookup-key= gets
  =nil= when unbound, thus it can decide of a default behaviour.
- Provide a self-insert function: the caller must handle it.
- Global or local bindings: it's up to the calling application to manage the
  locality of their keymaps.

** Example

#+begin_src lisp
  (let* ((parent-keymap (nkeymaps:make-keymap "parent-keymap"))
         (my-keymap (nkeymaps:make-keymap "my-keymap" parent-keymap)))
    (nkeymaps:define-key parent-keymap
      "C-c" 'copy
      "C-v" 'paste)
    (nkeymaps:define-key my-keymap
      "C-x" 'cut)
    (values
     (nkeymaps:lookup-key "C-x" parent-keymap)
     (nkeymaps:lookup-key "C-x" my-keymap)
     (nkeymaps:lookup-key "C-c" my-keymap)))

  ;; => NIL, CUT, COPY
#+end_src

See the [[file:package.lisp][package]] documentation for a usage guide and more examples.

** History

NKeymaps was originally developed for keymap management in [[https://nyxt.atlas.engineer][Nyxt]], so the "N"
may stand for it, or "New", or whatever poetic meaning you may find behind it!

** Road-map

- [ ] Lookup order (for instance parent-first or next-keymap-first) should be customizable.

- [ ] For now =*translator*= is a global, but ideally it would be part of the
  keyscheme and keymap.  But this would impact the lookup order, since
  translations come after all the keymaps and their parents have been searched for.

** Change log

*** 1.0.0

- Renamed =scheme-name= to =keyscheme= and =scheme= to =keyscheme-map=.
  It's more consistent and intuitive.  The previous naming was really confusing.
- All warnings have now their own conditions, see the =nkeymaps/conditions= package.
- =define-keyscheme-map= has a different syntax, it's now
  #+begin_src lisp
    (define-keyscheme-map "NAME-PREFIX" (:import OPTIONAL-KEYSCHEME-MAP-TO-IMPORT)
      KEYSCHEME BINDINGS...)
  #+end_src
- The predefined =keyscheme=s are now accessible from the =nkeymaps= package.
- New =default= =keyscheme= which is the new parent of other keyschemes
  (including =cua=), instead of =cua=.
- =*modifier-list*= is no longer exported.  Instead, both =keyscheme= and
  =keymap= have a =modifiers= slot for the modifiers they accept.
- Switched testing framework from =Prove= to =Lisp-Unit2=.
- Removed the =cl-str= dependency.


2 Systems

The main system appears first, followed by any subsystem dependency.


Previous: , Up: Systems   [Contents][Index]

2.1 nkeymaps

General-purpose keymap management à-la Emacs.

Author

Atlas Engineer LLC

Home Page

https://github.com/atlas-engineer/nkeymaps

License

BSD 3-Clause

Version

1.0.0

Dependencies
  • alexandria (system).
  • fset (system).
  • trivial-package-local-nicknames (system).
  • uiop (system).
Source

nkeymaps.asd.

Child Components

3 Files

Files are sorted by type and then listed depth-first from the systems components trees.


Previous: , Up: Files   [Contents][Index]

3.1 Lisp


Next: , Previous: , Up: Lisp   [Contents][Index]

3.1.1 nkeymaps/nkeymaps.asd

Source

nkeymaps.asd.

Parent Component

nkeymaps (system).

ASDF Systems

nkeymaps.


3.1.2 nkeymaps/types.lisp

Source

nkeymaps.asd.

Parent Component

nkeymaps (system).

Packages

nkeymaps/types.

Public Interface

list-of (type).

Internals

3.1.3 nkeymaps/conditions.lisp

Dependency

types.lisp (file).

Source

nkeymaps.asd.

Parent Component

nkeymaps (system).

Packages

nkeymaps/conditions.

Public Interface
Internals

3.1.4 nkeymaps/package.lisp

Dependency

conditions.lisp (file).

Source

nkeymaps.asd.

Parent Component

nkeymaps (system).

Packages

3.1.5 nkeymaps/keymap.lisp

Dependency

package.lisp (file).

Source

nkeymaps.asd.

Parent Component

nkeymaps (system).

Public Interface
Internals

3.1.6 nkeymaps/modifiers.lisp

Dependency

keymap.lisp (file).

Source

nkeymaps.asd.

Parent Component

nkeymaps (system).

Public Interface

3.1.7 nkeymaps/translators.lisp

Dependency

modifiers.lisp (file).

Source

nkeymaps.asd.

Parent Component

nkeymaps (system).

Public Interface
Internals

toggle-case (function).


3.1.8 nkeymaps/keyscheme-map.lisp

Dependency

translators.lisp (file).

Source

nkeymaps.asd.

Parent Component

nkeymaps (system).

Public Interface
Internals

3.1.9 nkeymaps/keyschemes.lisp

Dependency

keyscheme-map.lisp (file).

Source

nkeymaps.asd.

Parent Component

nkeymaps (system).

Public Interface

4 Packages

Packages are listed by definition order.


Next: , Previous: , Up: Packages   [Contents][Index]

4.1 nkeymaps/conditions

Package listing conditions.

Source

conditions.lisp.

Use List

common-lisp.

Used By List
Public Interface
Internals

4.2 nkeymaps/keyscheme

Package holding the list of well-known keyschemes.
We use a dedicated package so that keyschemes can easily be listed and completed.

Source

package.lisp.

Use List

common-lisp.

Used By List

nkeymaps.

Public Interface

4.3 nkeymaps/modifier

Package holding the list of predefined modifiers.
We use a dedicated package so that modifiers can easily be listed and completed. See ‘nkeymaps:define-modifier’.

Source

package.lisp.

Use List

common-lisp.

Used By List
Public Interface

Next: , Previous: , Up: Packages   [Contents][Index]

4.4 nkeymaps/translator

Package holding the list of predefined translators.
We use a dedicated package so that modifiers can easily be listed and completed. See ‘nkeymaps:*translator*’.

Source

package.lisp.

Use List
Used By List

nkeymaps.

Public Interface
Internals

toggle-case (function).


4.5 nkeymaps

The workflow goes as follows:
- Make a keymap with ‘nkeymaps:make-keymap’.
- Define a binding on it with ‘nkeymaps:define-key’.
- Lookup this binding with ‘nkeymaps:lookup-key’.

Example:

(let* ((parent-keymap (nkeymaps:make-keymap "parent-keymap"))
(my-keymap (nkeymaps:make-keymap "my-keymap" parent-keymap))) (nkeymaps:define-key parent-keymap
"C-c" ’copy
"C-v" ’paste)
(nkeymaps:define-key my-keymap
"C-x" ’cut)
(values
(nkeymaps:lookup-key "C-x" parent-keymap)
(nkeymaps:lookup-key "C-x" my-keymap)
(nkeymaps:lookup-key "C-c" my-keymap)))
;; => NIL, CUT, COPY

Another workflow is to use ‘nkeymaps:keyscheme’s which allow to compose different binding styles.

Example:

(nkeymaps:define-keyscheme-map "test" ()
nkeymaps:cua ’("C-c" copy
"C-v" paste)
nkeymaps:emacs ’("C-x" cut))

The default keyschemes can be listed from the ‘nkeymaps/keyscheme:’ package exported symbols.

New keyschemes can be created with ‘nkeymaps:make-keyscheme’.

Keys can be created with ‘nkeymaps:make-key’, which gives you more fine-tuning compared to the "keyspecs" above:

(nkeymaps:make-key :code 38 :value "a" :modifiers ’("C"))

You can also specify key codes from the keyspec directly. For instance,
"C-#10" corresponds to keycode 10 with the ‘nkeymaps:+control+’.

The reverse-action of ‘nkeymaps:lookup-key’ is ‘nkeymaps:binding-keys’.

Keymaps can be composed with ‘nkeymaps:compose’.

New modifiers can be defined with ‘nkeymaps:define-modifier’.

(nkeymaps:define-modifier :string "duper" :shortcut "D")

Some globals can be tweaked to customize the library to your needs:

- ‘nkeymaps:*translator*’: The function to infer the right binding when
the exact binding hits nothing.
- ‘nkeymaps:*print-shortcut*’: Print modifiers using their short form instead of the full name, e.g. "C" instead of "control".

Source

package.lisp.

Use List

Next: , Previous: , Up: Packages   [Contents][Index]

4.6 nkeymaps/types

Package for types.
It’s useful to have a separate package because some types may need to generate functions for the ‘satisfies’ type condition.

Source

types.lisp.

Use List

common-lisp.

Used By List
Public Interface

list-of (type).

Internals

Previous: , Up: Packages   [Contents][Index]

4.7 nkeymaps/core

See the ‘nkeymaps’ package documentation.

Source

package.lisp.

Use List
Used By List
Public Interface
Internals

5 Definitions

Definitions are sorted by export status, category, package, and then by lexicographic order.


Next: , Previous: , Up: Definitions   [Contents][Index]

5.1 Public Interface


5.1.1 Special variables

Special Variable: *print-shortcut*

Whether to print the short form of the modifiers.

Package

nkeymaps/core.

Source

keymap.lisp.

Special Variable: *translator*

Key translator to use in ‘keymap’ objects.
When no binding is found, call this function to
generate new bindings to lookup. The function takes a list of ‘key’ objects and returns a list of list of keys.

Ths parameter can be let-bound around ‘lookup-key’ calls.

Package

nkeymaps/core.

Source

keymap.lisp.

Special Variable: +control+
Package

nkeymaps/modifier.

Source

modifiers.lisp.

Special Variable: +hyper+
Package

nkeymaps/modifier.

Source

modifiers.lisp.

Special Variable: +meta+
Package

nkeymaps/modifier.

Source

modifiers.lisp.

Special Variable: +shift+
Package

nkeymaps/modifier.

Source

modifiers.lisp.

Special Variable: +super+
Package

nkeymaps/modifier.

Source

modifiers.lisp.

Special Variable: cua
Package

nkeymaps/keyscheme.

Source

keyschemes.lisp.

Special Variable: default
Package

nkeymaps/keyscheme.

Source

keyschemes.lisp.

Special Variable: emacs
Package

nkeymaps/keyscheme.

Source

keyschemes.lisp.

Special Variable: vi-insert
Package

nkeymaps/keyscheme.

Source

keyschemes.lisp.

Special Variable: vi-normal
Package

nkeymaps/keyscheme.

Source

keyschemes.lisp.


5.1.2 Compiler macros

Compiler Macro: define-key (keymap keyspecs bound-value &rest more-keyspecs-value-pairs)

We need a compiler macro to check that bindings are valid at compile time. This is because most Common Lisp implementations are not capable of checking types that use ‘satisfies’ for non-top-level symbols.
We can verify this with:

(compile nil (lambda () (nkeymaps::define-key keymap "C-x C-f" ’open-file)))

Package

nkeymaps/core.

Source

keymap.lisp.

Compiler Macro: define-keyscheme-map (name-prefix options keyscheme bindings &rest more-keyscheme+bindings-pairs)

See the ‘define-key’ compiler-macro for why we need one here too.

Package

nkeymaps/core.

Source

keyscheme-map.lisp.


5.1.3 Ordinary functions

Function: binding-keys (bound-value keymap-or-keymaps &key test)

Return the list of ‘keyspec’s bound to BINDING in KEYMAP-OR-KEYMAPS.

The order of the result is dictated by the order of KEYMAP-OR-KEYMAPS.

As a second value, return an alist of (keyspec keymap) for all the ‘keyspec’s bound to BINDING in KEYMAP.

Comparison against BINDING is done with TEST.

Duplicates and shadowed bindings are removed.

For instance, to list all keymaps that have a binding, call:

(mapcar #’second (nth-value 1 (binding-keys ...)))

Package

nkeymaps/core.

Source

keymap.lisp.

Function: compose (keymap &rest more-keymaps)

Return a new keymap that’s the composition of all given KEYMAPS.
KEYMAPS are composed by order of precedence, first keymap being the one with highest precedence.

Package

nkeymaps/core.

Source

keymap.lisp.

Function: copy-key (key &key code value modifiers status)
Package

nkeymaps/core.

Source

keymap.lisp.

Function: define-key (keymap keyspecs bound-value &rest more-keyspecs-value-pairs)

Bind KEYS to BOUND-VALUE in KEYMAP.
Return KEYMAP.

KEYSPECS is either a ‘keyspecs-type’, or a list of arguments passed to invocations of ‘make-key’s, or (:REMAP OTHER-VALUE &OPTIONAL OTHER-KEYMAP).

BOUND-VALUE can be anything. If NIL, the binding is removed.

With (:REMAP OTHER-VALUE &OPTIONAL OTHER-KEYMAP), define-key maps the binding of OTHER-VALUE in OTHER-KEYMAP (default to KEYMAP) to BOUND-VALUE.
In other words, it remaps OTHER-VALUE to VALUE.

Examples:

(define-key foo-map "C-x C-f" ’open-file)

(define-key foo-map
"C-x C-f" ’open-file
"C-h k" ’describe-key)

"C-M-1 x" on a QWERTY:

(define-key foo-map ’((:code 10 :modifiers ("C" "M") (:value "x"))) ’open-file)

or the shorter:

(define-key foo-map "C-M-#1" ’open-file)

Remapping keys:

(define-key foo-map ’(:remap foo-a) ’foo-value)
(define-key foo-map ‘(:remap foo-a ,bar-map) ’new-value)

Package

nkeymaps/core.

Source

keymap.lisp.

Function: define-keyscheme-map (name-prefix options keyscheme bindings &rest more-keyschemes+bindings-pairs)

Return a keyscheme-map, a hash table with ‘keyscheme’s as key and ‘keymap’s holding BINDINGS as value.

The keymap names are prefixed with NAME-PREFIX and suffixed with "-map".

OPTIONS is list of keyword arguments.
For now the only supported option is IMPORT.

When given a ‘keyscheme-map’ to IMPORT, it is used as initial values for the new keyscheme-map. The content is copied. Further alteration to the imported keyscheme-map won’t reflect on this newly define keyscheme-map.

This is a macro like ‘define-key’ so that it can type-check the BINDINGS keyspecs at compile-time.

Example:

(define-keyscheme-map "my-mode" ’()
nkeymaps/keyscheme:cua (list
"C-c" ’copy
"C-v" ’paste)

nkeymaps/keyscheme:emacs ’("M-w" copy
"M-y" paste))

‘nkeymaps/keyscheme:cua’ and ‘nkeymaps/keyscheme:emacs’ are pre-defined keyschemes. To define a new keyscheme, see ‘make-keyscheme’.

‘nkeymaps/keyscheme:cua’ is a parent of ‘nkeymaps/keyscheme:emacs’; thus, in the above example, the Emacs keymap will have the CUA keymap as parent.
The keyscheme-map keymaps are named "my-mode-cua-map" and
"my-mode-emacs-map".

Package

nkeymaps/core.

Source

keyscheme-map.lisp.

Function: define-modifier (&rest args &key string shortcut)

Return a new modifier.
It is registered globally and can be used from any new keymap, unless the keymap filters out the modifier in its ‘modifiers’ slot.

Package

nkeymaps/core.

Source

keymap.lisp.

Function: get-keymap (keyscheme keyscheme-map)

Return keymap corresponding to KEYSCHEME in KEYSCHEME-MAP.
If no keymap is found, try with KEYSCHEME’s ‘parents’.
For instance, if KEYSCHEME has a ‘nkeymaps/keyscheme:cua’ keymap and no ‘nkeymaps/keyscheme:emacs’ keymap, this function returns the ‘nkeymaps/keyscheme:cua’ keymap when NAME is ‘nkeymaps/keyscheme:emacs’. Return nil if nothing is found.

Package

nkeymaps/core.

Source

keyscheme-map.lisp.

Reader: key-code (instance)
Writer: (setf key-code) (instance)
Package

nkeymaps/core.

Source

keymap.lisp.

Target Slot

code.

Reader: key-modifiers (instance)
Writer: (setf key-modifiers) (instance)
Package

nkeymaps/core.

Source

keymap.lisp.

Target Slot

modifiers.

Reader: key-status (instance)
Writer: (setf key-status) (instance)
Package

nkeymaps/core.

Source

keymap.lisp.

Target Slot

status.

Reader: key-value (instance)
Writer: (setf key-value) (instance)
Package

nkeymaps/core.

Source

keymap.lisp.

Target Slot

value.

Function: key= (key1 key2)

Two keys are equal if the have the same modifiers, status and key code.
If codes don’t match, the values are compared instead. This way, code-matching keys match before the value which is usually what the users want when they specify a key-code binding.

Package

nkeymaps/core.

Source

keymap.lisp.

Function: keymap->map (keymap &rest more-keymaps)

Return a hash-table of (KEYSPEC BOUND-VALUE) from KEYMAP.
Parent bindings are not listed; see ‘keymap-with-parents->map’ instead.
This is convenient if the caller wants to list all the bindings.
When multiple keymaps are provided, return the union of the ‘fset:map’ of each arguments. Keymaps are ordered by precedence, highest precedence comes first.

Package

nkeymaps/core.

Source

keymap.lisp.

Function: keymap-p (object)
Package

nkeymaps/core.

Source

keymap.lisp.

Function: keymap-with-parents->map (keymap)

List bindings in KEYMAP and all its parents. See ‘keymap->map’.

Package

nkeymaps/core.

Source

keymap.lisp.

Function: keys->keyspecs (keys)

Return the keyspecs (a list of ‘keyspec’) for KEYS. See ‘key->keyspec’ for the details.

Package

nkeymaps/core.

Source

keymap.lisp.

Function: keyscheme-map-p (keyscheme-map)
Package

nkeymaps/core.

Source

keyscheme-map.lisp.

Function: keyscheme-p (name)
Package

nkeymaps/core.

Source

keyscheme-map.lisp.

Function: lookup-key (keys-or-keyspecs keymap-or-keymaps)

Return the value bound to KEYS-OR-KEYSPECS in KEYMAP-OR-KEYMAPS.
As a second value, return the matching keymap.
As a third value, return the possibly translated KEYS.

Return NIL if no value is found.

The successive keymaps from KEYMAP-OR-KEYMAPS (if a list) are looked up one after the other.
If no binding is found, the direct parents are looked up in the same order. And so on if the binding is still not found.

Package

nkeymaps/core.

Source

keymap.lisp.

Function: make-key (&key code value modifiers status)

Return new ‘key’.
Modifiers can be either a ‘modifier’ type or a string that will be looked up in ‘*modifier-list*’.

Package

nkeymaps/core.

Source

keymap.lisp.

Function: make-keymap (name &rest parents)
Package

nkeymaps/core.

Source

keymap.lisp.

Function: make-keyscheme (name &rest parents)

Return a new ‘keyscheme’ object.
The scheme name inherits from the optional PARENTS, ordered by priority.

Example:

(defvar emacs (make-keyscheme "emacs" cua))

In the above, we define a new scheme name called ‘emacs‘ which inherits from the existing keyscheme ‘cua‘.

Package

nkeymaps/core.

Source

keyscheme-map.lisp.

Function: make-keyscheme-map (keyscheme keymap &rest more-keyscheme+keymap-pairs)

Return a new scheme associating KEYSCHEME to KEYMAP.
With MORE-KEYSCHEME+KEYMAP-PAIRS, include those names and keymaps as well. This is useful in complement to ‘define-keyscheme-map’ to make a scheme with pre-existing keymaps.

Package

nkeymaps/core.

Source

keyscheme-map.lisp.

Function: modifier= (string-or-modifier1 string-or-modifier2)
Package

nkeymaps/core.

Source

keymap.lisp.

Function: translate-remove-but-first-control (keys)

With control, keys without control except for the first key: ’C-x C-c’ -> ’C-x c’.

Package

nkeymaps/translator.

Source

translators.lisp.

Function: translate-remove-shift (keys)

With shift, keys without shift: ’shift-a’ -> ’a’.

Package

nkeymaps/translator.

Source

translators.lisp.

Function: translate-remove-shift-but-first-control (keys)

With control and shift, keys without control except for the first key and without shift everywhere: ’C-shift-C C-shift-f’ -> ’C-C f.

Package

nkeymaps/translator.

Source

translators.lisp.

Function: translate-remove-shift-but-first-control-toggle-case (keys)

With control and shift, keys without control except for the first key and without shift everywhere: ’C-shift-C C-shift-f’ -> ’C-c F.

Package

nkeymaps/translator.

Source

translators.lisp.

Function: translate-remove-shift-toggle-case (keys)

With shift, keys without shift and with their key value case reversed: ’shift-a shift-B’ -> ’A b’.

Package

nkeymaps/translator.

Source

translators.lisp.

Function: translate-shift-control-combinations (keys)

Return the successive translations of
- ‘translate-remove-shift’,
- ‘translate-remove-shift-toggle-case’,
- ‘translate-remove-but-first-control’,
- ‘translate-remove-shift-but-first-control’,
- ‘translate-remove-shift-but-first-control-toggle-case’.

We first remove shift before toggle the case because we want ’s-A’ to match an ’A’ binding before matching ’a’.

Package

nkeymaps/translator.

Source

translators.lisp.


5.1.4 Generic functions

Generic Reader: bound-type (object)
Generic Writer: (setf bound-type) (object)
Package

nkeymaps/core.

Methods
Reader Method: bound-type ((keyscheme keyscheme))
Writer Method: (setf bound-type) ((keyscheme keyscheme))

Type of the bound-value.
The type is enforced in ‘define-keyscheme-map’ at macro-expansion time. Type should allow ‘keymap’s, so it should probably be in the form (or keymap NON-KEYMAP-BOUND-TYPE).

Source

keyscheme-map.lisp.

Target Slot

bound-type.

Reader Method: bound-type ((keymap keymap))
Writer Method: (setf bound-type) ((keymap keymap))

Type of the bound-value.
The type is enforced in ‘define-key’ at macro-expansion time. Type should allow ‘keymap’s, so it should probably be in the form (or keymap NON-KEYMAP-BOUND-TYPE).

Source

keymap.lisp.

Target Slot

bound-type.

Generic Reader: modifiers (object)
Generic Writer: (setf modifiers) (object)
Package

nkeymaps/core.

Methods
Reader Method: modifiers ((keyscheme keyscheme))
Writer Method: (setf modifiers) ((keyscheme keyscheme))

Accepted modifiers for this ‘keyscheme’.

Source

keyscheme-map.lisp.

Target Slot

modifiers.

Reader Method: modifiers ((keymap keymap))
Writer Method: (setf modifiers) ((keymap keymap))

Accepted modifiers for this ‘keymap’.

Source

keymap.lisp.

Target Slot

modifiers.

Generic Reader: name (object)
Generic Writer: (setf name) (object)
Package

nkeymaps/core.

Methods
Reader Method: name ((keyscheme keyscheme))
Writer Method: (setf name) ((keyscheme keyscheme))

A scheme name.

Source

keyscheme-map.lisp.

Target Slot

name.

Reader Method: name ((keymap keymap))
Writer Method: (setf name) ((keymap keymap))

Name of the keymap.
Used for documentation purposes, e.g. referring to a keymap by a well known name.

Source

keymap.lisp.

Target Slot

name.

Generic Reader: parents (object)
Generic Writer: (setf parents) (object)
Package

nkeymaps/core.

Methods
Reader Method: parents ((keyscheme keyscheme))
Writer Method: (setf parents) ((keyscheme keyscheme))

The list of parents. When a scheme is defined, the
keymap parents are automatically set to the keymaps corresponding to the given keyschemes. See ‘define-keyscheme-map’.

Source

keyscheme-map.lisp.

Target Slot

parents.

Reader Method: parents ((keymap keymap))
Writer Method: (setf parents) ((keymap keymap))

List of parent keymaps.
Parents are ordered by priority, the first parent has highest priority.

Source

keymap.lisp.

Target Slot

parents.


5.1.5 Standalone methods

Method: compare ((x key) (y key))

Needed to use the KEY structure as keys in Fset maps.
Would we use the default comparison function, case-sensitivity would be lost on key values because ‘fset:equal?‘ folds case.

Package

fset.

Source

keymap.lisp.

Method: compare ((x modifier) (y modifier))

Modifier sets need this comparison function to be ordered, so that ("C" "M") is the same as ("M" "C").

Package

fset.

Source

keymap.lisp.

Method: print-object ((object keyscheme) stream)
Source

keyscheme-map.lisp.

Method: print-object ((keymap keymap) stream)
Source

keymap.lisp.


5.1.6 Conditions

Condition: bad-keyspec

Warning raised when trying to derive a key from an illegal keyspec.

Package

nkeymaps/conditions.

Source

conditions.lisp.

Direct superclasses

warning.

Direct methods
Direct slots
Slot: message
Initform

(quote "illegal keyspec")

Initargs

:message

Readers

message.

Writers

(setf message).

Slot: error-condition
Initform

(quote (alexandria:required-argument (quote nkeymaps/conditions::error-condition)))

Initargs

:error-condition

Readers

error-condition.

Writers

(setf error-condition).

Condition: bad-modifier

Condition raised when we didn’t get a modifier as expected.

Package

nkeymaps/conditions.

Source

conditions.lisp.

Direct superclasses

error.

Direct methods
Direct slots
Slot: message
Initform

(quote "")

Initargs

:message

Readers

message.

Writers

(setf message).

Condition: cycle

Warning raised when keymap has cycles.
This is possible if a bound value is a keymap that occured before.

Package

nkeymaps/conditions.

Source

conditions.lisp.

Direct superclasses

warning.

Direct methods
Direct slots
Slot: message
Initform

(quote "cycle detect in keymap")

Initargs

:message

Readers

message.

Writers

(setf message).

Slot: keymap
Initform

(quote (alexandria:required-argument (quote nkeymaps/conditions::keymap)))

Initargs

:keymap

Readers

keymap.

Writers

(setf keymap).

Condition: duplicate-modifiers

Warning raised when a keyspec contains multiple occurences of the same modifiers.

Package

nkeymaps/conditions.

Source

conditions.lisp.

Direct superclasses

warning.

Direct methods
Direct slots
Slot: message
Initform

(quote "duplicate modifiers")

Initargs

:message

Readers

message.

Writers

(setf message).

Slot: modifiers
Initform

(quote (alexandria:required-argument (quote nkeymaps/conditions::modifiers)))

Initargs

:modifiers

Readers

modifiers.

Writers

(setf modifiers).

Condition: empty-keyspec
Package

nkeymaps/conditions.

Source

conditions.lisp.

Direct superclasses

error.

Condition: empty-modifiers
Package

nkeymaps/conditions.

Source

conditions.lisp.

Direct superclasses

error.

Direct methods
Direct slots
Slot: keyspec
Initform

(quote (alexandria:required-argument (quote nkeymaps/conditions::keyspec)))

Initargs

:keyspec

Readers

keyspec.

Writers

(setf keyspec).

Condition: empty-value
Package

nkeymaps/conditions.

Source

conditions.lisp.

Direct superclasses

error.

Direct methods
Direct slots
Slot: keyspec
Initform

(quote (alexandria:required-argument (quote nkeymaps/conditions::keyspec)))

Initargs

:keyspec

Readers

keyspec.

Writers

(setf keyspec).

Condition: make-key-required-arg
Package

nkeymaps/conditions.

Source

conditions.lisp.

Direct superclasses

error.

Condition: override-existing-binding

Warning raised overriding an existing binding.

Package

nkeymaps/conditions.

Source

conditions.lisp.

Direct superclasses

warning.

Direct methods
Direct slots
Slot: message
Initform

(quote "key was bound to")

Initargs

:message

Readers

message.

Writers

(setf message).

Slot: existing-binding-value
Initform

(quote (alexandria:required-argument (quote nkeymaps/conditions::existing-binding-value)))

Initargs

:existing-binding-value

Readers

existing-binding-value.

Writers

(setf existing-binding-value).


Next: , Previous: , Up: Public Interface   [Contents][Index]

5.1.7 Structures

Structure: key
Package

nkeymaps/core.

Source

keymap.lisp.

Direct superclasses

structure-object.

Direct methods

compare.

Direct slots
Slot: code
Type

integer

Initform

0

Readers

key-code.

Writers

(setf key-code).

Slot: value
Type

string

Initform

""

Readers

key-value.

Writers

(setf key-value).

Slot: modifiers
Type

fset:wb-set

Initform

(fset:set)

Readers

key-modifiers.

Writers

(setf key-modifiers).

Slot: status
Type

nkeymaps/core::key-status-type

Initform

:pressed

Readers

key-status.

Writers

(setf key-status).


Next: , Previous: , Up: Public Interface   [Contents][Index]

5.1.8 Classes

Class: keymap
Package

nkeymaps/core.

Source

keymap.lisp.

Direct methods
Direct slots
Slot: name

Name of the keymap.
Used for documentation purposes, e.g. referring to a keymap by a well known name.

Type

string

Initform

"anonymous"

Initargs

:name

Readers

name.

Writers

(setf name).

Slot: entries

Hash table of which the keys are key-chords and the values are a symbol or a keymap.

Type

fset:wb-map

Initform

(fset:empty-map)

Initargs

:entries

Readers

entries.

Writers

(setf entries).

Slot: bound-type

Type of the bound-value.
The type is enforced in ‘define-key’ at macro-expansion time. Type should allow ‘keymap’s, so it should probably be in the form (or keymap NON-KEYMAP-BOUND-TYPE).

Initform

nkeymaps/core::*default-bound-type*

Initargs

:bound-type

Readers

bound-type.

Writers

(setf bound-type).

Slot: parents

List of parent keymaps.
Parents are ordered by priority, the first parent has highest priority.

Type

(nkeymaps/types:list-of nkeymaps/core:keymap)

Initargs

:parents

Readers

parents.

Writers

(setf parents).

Slot: modifiers

Accepted modifiers for this ‘keymap’.

Type

fset:wb-set

Initform

(fset:convert (quote fset:set) nkeymaps/core::*modifier-list*)

Initargs

:modifiers

Readers

modifiers.

Writers

(setf modifiers).

Class: keyscheme
Package

nkeymaps/core.

Source

keyscheme-map.lisp.

Direct methods
Direct slots
Slot: name

A scheme name.

Type

string

Initargs

:name

Readers

name.

Writers

(setf name).

Slot: parents

The list of parents. When a scheme is defined, the
keymap parents are automatically set to the keymaps corresponding to the given keyschemes. See ‘define-keyscheme-map’.

Type

(nkeymaps/types:list-of nkeymaps/core:keyscheme)

Initform

(quote nil)

Initargs

:parents

Readers

parents.

Writers

(setf parents).

Slot: bound-type

Type of the bound-value.
The type is enforced in ‘define-keyscheme-map’ at macro-expansion time. Type should allow ‘keymap’s, so it should probably be in the form (or keymap NON-KEYMAP-BOUND-TYPE).

Initform

nkeymaps/core::*default-bound-type*

Initargs

:bound-type

Readers

bound-type.

Writers

(setf bound-type).

Slot: modifiers

Accepted modifiers for this ‘keyscheme’.

Type

fset:wb-set

Initform

(fset:convert (quote fset:set) nkeymaps/core::*modifier-list*)

Initargs

:modifiers

Readers

modifiers.

Writers

(setf modifiers).


Previous: , Up: Public Interface   [Contents][Index]

5.1.9 Types

Type: keyscheme-map ()

A ‘hash-table’ mapping ‘keyscheme’s to ‘keymap’s.

Package

nkeymaps/core.

Source

keyscheme-map.lisp.

Type: list-of (type)

The empty list or a proper list of TYPE elements. Unlike ‘(cons TYPE *)’, it checks all the elements. ‘(cons TYPE *)’ does not accept the empty list.

Package

nkeymaps/types.

Source

types.lisp.


5.2 Internals


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.1 Special variables

Special Variable: *default-bound-type*

Default value for the ‘bound-type’ slot of ‘keymap’.
Do not change this, instead create new ‘scheme-name’s or subclass ‘keymap’.

Package

nkeymaps/core.

Source

keymap.lisp.

Special Variable: *modifier-list*

List of known modifiers.
‘make-key’ and ‘define-key’ raise an error when setting a modifier that is not in this list.

Package

nkeymaps/core.

Source

keymap.lisp.


5.2.2 Ordinary functions

Function: %copy-key (instance)
Package

nkeymaps/core.

Source

keymap.lisp.

Function: %make-key (code value modifiers status)
Package

nkeymaps/core.

Source

keymap.lisp.

Function: bind-key (keymap keys bound-value)

Recursively bind the KEYS to keymaps starting from KEYMAP. The last key is bound to BOUND-VALUE.
If BOUND-VALUE is nil, the key is unbound.
If KEYS has modifiers that are not allowed in KEYMAP, do nothing.

Return KEYMAP.

Package

nkeymaps/core.

Source

keymap.lisp.

Function: binding-keys* (binding keymap &key test)

Return a the list of ‘keyspec’s bound to BINDING in KEYMAP. The list is sorted alphabetically to ensure reproducible results. Comparison against BINDING is done with TEST.

Package

nkeymaps/core.

Source

keymap.lisp.

Function: copy-keymap (keymap)
Package

nkeymaps/core.

Source

keymap.lisp.

Function: copy-keyscheme-map (keyscheme-map)
Package

nkeymaps/core.

Source

keyscheme-map.lisp.

Function: copy-modifier (instance)
Package

nkeymaps/core.

Source

keymap.lisp.

Function: key->keyspec (key)

Return the keyspec of KEY.
If the key has a code, return it prefixed with ’#’.
For now the status is not encoded in the keyspec, this may change in the future.

Package

nkeymaps/core.

Source

keymap.lisp.

Function: key-p (object)
Package

nkeymaps/core.

Source

keymap.lisp.

Function: keymap->map* (keymap &optional visited)

Return a map of (KEYSPEC SYM) from KEYMAP.

Package

nkeymaps/core.

Source

keymap.lisp.

Function: keymap-tree->list (keymaps visited)

Flatten the KEYMAPS into a list.
It traverses KEYMAPS first, then traverses the each keymap ‘parent’ layer after layer.

Example:
- keymap1 has parents (k1a k1b)
- k1a has parents (k1ap)
- keymap2 has parents (k2a)

Return (keymap1 keymap2 k1a k1b k2a k1ap).

Package

nkeymaps/core.

Source

keymap.lisp.

Function: keymap-with-parents (keymap)

Return the list of keymap and all its parents.

Package

nkeymaps/core.

Source

keymap.lisp.

Function: keyspec->key (string &optional error-p)

Parse STRING and return a new ‘key’.
The specifier is expected to be in the form

MOFIFIERS-CODE/VALUE

MODIFIERS are hyphen-separated modifiers as per ‘*modifier-list*’. CODE/VALUE is either a code that starts with ’#’ or a key symbol.

Note that ’-’ or ’#’ as a last character is supported, e.g. ’control–’ and ’control-#’ are valid.

Package

nkeymaps/core.

Source

keymap.lisp.

Function: keyspecs->keys (spec &optional error-p)

Parse SPEC and return corresponding list of keys.

Package

nkeymaps/core.

Source

keymap.lisp.

Whether KEY’s modifiers are allowed in KEYMAP.

Package

nkeymaps/core.

Source

keymap.lisp.

Function: list-of-key-p (object)
Package

nkeymaps/types.

Source

types.lisp.

Function: list-of-keymap-p (object)
Package

nkeymaps/types.

Source

types.lisp.

Function: list-of-keyscheme-p (object)
Package

nkeymaps/types.

Source

types.lisp.

Function: list-of-p (list type)

Return non-nil if LIST contains only elements of the given TYPE.

Package

nkeymaps/types.

Source

types.lisp.

Function: list-of-string-p (object)
Package

nkeymaps/types.

Source

types.lisp.

Function: lookup-key* (keymap-or-keymaps keys visited)

Internal function, see ‘lookup-key’ for the user-facing function. VISITED is used to detect cycles.
As a second value, return the matching keymap.

Package

nkeymaps/core.

Source

keymap.lisp.

Function: lookup-keys-in-keymap (keymap keys visited)

Return bound value or keymap for KEYS. Return nil when KEYS is not found in KEYMAP. VISITED is used to detect cycles.

Package

nkeymaps/core.

Source

keymap.lisp.

Function: make-modifier (&key string shortcut)
Package

nkeymaps/core.

Source

keymap.lisp.

Function: modifier-p (object)
Package

nkeymaps/core.

Source

keymap.lisp.

Reader: modifier-shortcut (instance)
Writer: (setf modifier-shortcut) (instance)
Package

nkeymaps/core.

Source

keymap.lisp.

Target Slot

shortcut.

Reader: modifier-string (instance)
Writer: (setf modifier-string) (instance)
Package

nkeymaps/core.

Source

keymap.lisp.

Target Slot

string.

Function: modspec->modifier (string-or-modifier)

Return the ‘modifier’ corresponding to STRING-OR-MODIFIER.

Package

nkeymaps/core.

Source

keymap.lisp.

Function: modspecs->modifiers (strings-or-modifiers)

Return the list of ‘modifier’s corresponding to STRINGS-OR-MODIFIERS.

Package

nkeymaps/core.

Source

keymap.lisp.

Function: quoted-symbol-p (arg)
Package

nkeymaps/core.

Source

keyscheme-map.lisp.

Function: string-join (strings separator &key end)

Adapted from ‘serapeum:string-join’.

Package

nkeymaps/core.

Source

keymap.lisp.

Function: toggle-case (string)

Return the input with reversed case if it has only one character.

Package

nkeymaps/translator.

Source

translators.lisp.


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.3 Generic functions

Generic Reader: entries (object)
Generic Writer: (setf entries) (object)
Package

nkeymaps/core.

Methods
Reader Method: entries ((keymap keymap))
Writer Method: (setf entries) ((keymap keymap))

Hash table of which the keys are key-chords and the values are a symbol or a keymap.

Source

keymap.lisp.

Target Slot

entries.

Generic Reader: error-condition (condition)
Generic Writer: (setf error-condition) (condition)
Package

nkeymaps/conditions.

Methods
Reader Method: error-condition ((condition bad-keyspec))
Writer Method: (setf error-condition) ((condition bad-keyspec))
Source

conditions.lisp.

Target Slot

error-condition.

Generic Reader: existing-binding-value (condition)
Generic Writer: (setf existing-binding-value) (condition)
Package

nkeymaps/conditions.

Methods
Reader Method: existing-binding-value ((condition override-existing-binding))
Writer Method: (setf existing-binding-value) ((condition override-existing-binding))
Source

conditions.lisp.

Target Slot

existing-binding-value.

Generic Reader: keymap (condition)
Generic Writer: (setf keymap) (condition)
Package

nkeymaps/conditions.

Methods
Reader Method: keymap ((condition cycle))
Writer Method: (setf keymap) ((condition cycle))
Source

conditions.lisp.

Target Slot

keymap.

Generic Reader: keyspec (condition)
Generic Writer: (setf keyspec) (condition)
Package

nkeymaps/conditions.

Methods
Reader Method: keyspec ((condition empty-modifiers))
Writer Method: (setf keyspec) ((condition empty-modifiers))
Source

conditions.lisp.

Target Slot

keyspec.

Reader Method: keyspec ((condition empty-value))
Writer Method: (setf keyspec) ((condition empty-value))
Source

conditions.lisp.

Target Slot

keyspec.

Generic Reader: message (condition)
Generic Writer: (setf message) (condition)
Package

nkeymaps/conditions.

Methods
Reader Method: message ((condition bad-keyspec))
Writer Method: (setf message) ((condition bad-keyspec))
Source

conditions.lisp.

Target Slot

message.

Reader Method: message ((condition bad-modifier))
Writer Method: (setf message) ((condition bad-modifier))
Source

conditions.lisp.

Target Slot

message.

Reader Method: message ((condition override-existing-binding))
Writer Method: (setf message) ((condition override-existing-binding))
Source

conditions.lisp.

Target Slot

message.

Reader Method: message ((condition duplicate-modifiers))
Writer Method: (setf message) ((condition duplicate-modifiers))
Source

conditions.lisp.

Target Slot

message.

Reader Method: message ((condition cycle))
Writer Method: (setf message) ((condition cycle))
Source

conditions.lisp.

Target Slot

message.

Generic Reader: modifiers (condition)
Generic Writer: (setf modifiers) (condition)
Package

nkeymaps/conditions.

Methods
Reader Method: modifiers ((condition duplicate-modifiers))
Writer Method: (setf modifiers) ((condition duplicate-modifiers))
Source

conditions.lisp.

Target Slot

modifiers.


Next: , Previous: , Up: Internals   [Contents][Index]

5.2.4 Structures

Structure: modifier
Package

nkeymaps/core.

Source

keymap.lisp.

Direct superclasses

structure-object.

Direct methods

compare.

Direct slots
Slot: string
Package

common-lisp.

Type

string

Initform

""

Readers

modifier-string.

Writers

(setf modifier-string).

Slot: shortcut
Type

string

Initform

""

Readers

modifier-shortcut.

Writers

(setf modifier-shortcut).


Previous: , Up: Internals   [Contents][Index]

5.2.5 Types

Type: key-status-type ()
Package

nkeymaps/core.

Source

keymap.lisp.

Type: keyspecs-type ()
Package

nkeymaps/core.

Source

keymap.lisp.


Appendix A Indexes


Next: , Previous: , Up: Indexes   [Contents][Index]

A.1 Concepts


Next: , Previous: , Up: Indexes   [Contents][Index]

A.2 Functions

Jump to:   %   (  
B   C   D   E   F   G   K   L   M   N   P   Q   S   T  
Index Entry  Section

%
%copy-key: Private ordinary functions
%make-key: Private ordinary functions

(
(setf bound-type): Public generic functions
(setf bound-type): Public generic functions
(setf bound-type): Public generic functions
(setf entries): Private generic functions
(setf entries): Private generic functions
(setf error-condition): Private generic functions
(setf error-condition): Private generic functions
(setf existing-binding-value): Private generic functions
(setf existing-binding-value): Private generic functions
(setf key-code): Public ordinary functions
(setf key-modifiers): Public ordinary functions
(setf key-status): Public ordinary functions
(setf key-value): Public ordinary functions
(setf keymap): Private generic functions
(setf keymap): Private generic functions
(setf keyspec): Private generic functions
(setf keyspec): Private generic functions
(setf keyspec): Private generic functions
(setf message): Private generic functions
(setf message): Private generic functions
(setf message): Private generic functions
(setf message): Private generic functions
(setf message): Private generic functions
(setf message): Private generic functions
(setf modifier-shortcut): Private ordinary functions
(setf modifier-string): Private ordinary functions
(setf modifiers): Public generic functions
(setf modifiers): Public generic functions
(setf modifiers): Public generic functions
(setf modifiers): Private generic functions
(setf modifiers): Private generic functions
(setf name): Public generic functions
(setf name): Public generic functions
(setf name): Public generic functions
(setf parents): Public generic functions
(setf parents): Public generic functions
(setf parents): Public generic functions

B
bind-key: Private ordinary functions
binding-keys: Public ordinary functions
binding-keys*: Private ordinary functions
bound-type: Public generic functions
bound-type: Public generic functions
bound-type: Public generic functions

C
compare: Public standalone methods
compare: Public standalone methods
Compiler Macro, define-key: Public compiler macros
Compiler Macro, define-keyscheme-map: Public compiler macros
compose: Public ordinary functions
copy-key: Public ordinary functions
copy-keymap: Private ordinary functions
copy-keyscheme-map: Private ordinary functions
copy-modifier: Private ordinary functions

D
define-key: Public compiler macros
define-key: Public ordinary functions
define-keyscheme-map: Public compiler macros
define-keyscheme-map: Public ordinary functions
define-modifier: Public ordinary functions

E
entries: Private generic functions
entries: Private generic functions
error-condition: Private generic functions
error-condition: Private generic functions
existing-binding-value: Private generic functions
existing-binding-value: Private generic functions

F
Function, %copy-key: Private ordinary functions
Function, %make-key: Private ordinary functions
Function, (setf key-code): Public ordinary functions
Function, (setf key-modifiers): Public ordinary functions
Function, (setf key-status): Public ordinary functions
Function, (setf key-value): Public ordinary functions
Function, (setf modifier-shortcut): Private ordinary functions
Function, (setf modifier-string): Private ordinary functions
Function, bind-key: Private ordinary functions
Function, binding-keys: Public ordinary functions
Function, binding-keys*: Private ordinary functions
Function, compose: Public ordinary functions
Function, copy-key: Public ordinary functions
Function, copy-keymap: Private ordinary functions
Function, copy-keyscheme-map: Private ordinary functions
Function, copy-modifier: Private ordinary functions
Function, define-key: Public ordinary functions
Function, define-keyscheme-map: Public ordinary functions
Function, define-modifier: Public ordinary functions
Function, get-keymap: Public ordinary functions
Function, key->keyspec: Private ordinary functions
Function, key-code: Public ordinary functions
Function, key-modifiers: Public ordinary functions
Function, key-p: Private ordinary functions
Function, key-status: Public ordinary functions
Function, key-value: Public ordinary functions
Function, key=: Public ordinary functions
Function, keymap->map: Public ordinary functions
Function, keymap->map*: Private ordinary functions
Function, keymap-p: Public ordinary functions
Function, keymap-tree->list: Private ordinary functions
Function, keymap-with-parents: Private ordinary functions
Function, keymap-with-parents->map: Public ordinary functions
Function, keys->keyspecs: Public ordinary functions
Function, keyscheme-map-p: Public ordinary functions
Function, keyscheme-p: Public ordinary functions
Function, keyspec->key: Private ordinary functions
Function, keyspecs->keys: Private ordinary functions
Function, legal-modifiers-p: Private ordinary functions
Function, list-of-key-p: Private ordinary functions
Function, list-of-keymap-p: Private ordinary functions
Function, list-of-keyscheme-p: Private ordinary functions
Function, list-of-p: Private ordinary functions
Function, list-of-string-p: Private ordinary functions
Function, lookup-key: Public ordinary functions
Function, lookup-key*: Private ordinary functions
Function, lookup-keys-in-keymap: Private ordinary functions
Function, make-key: Public ordinary functions
Function, make-keymap: Public ordinary functions
Function, make-keyscheme: Public ordinary functions
Function, make-keyscheme-map: Public ordinary functions
Function, make-modifier: Private ordinary functions
Function, modifier-p: Private ordinary functions
Function, modifier-shortcut: Private ordinary functions
Function, modifier-string: Private ordinary functions
Function, modifier=: Public ordinary functions
Function, modspec->modifier: Private ordinary functions
Function, modspecs->modifiers: Private ordinary functions
Function, quoted-symbol-p: Private ordinary functions
Function, string-join: Private ordinary functions
Function, toggle-case: Private ordinary functions
Function, translate-remove-but-first-control: Public ordinary functions
Function, translate-remove-shift: Public ordinary functions
Function, translate-remove-shift-but-first-control: Public ordinary functions
Function, translate-remove-shift-but-first-control-toggle-case: Public ordinary functions
Function, translate-remove-shift-toggle-case: Public ordinary functions
Function, translate-shift-control-combinations: Public ordinary functions

G
Generic Function, (setf bound-type): Public generic functions
Generic Function, (setf entries): Private generic functions
Generic Function, (setf error-condition): Private generic functions
Generic Function, (setf existing-binding-value): Private generic functions
Generic Function, (setf keymap): Private generic functions
Generic Function, (setf keyspec): Private generic functions
Generic Function, (setf message): Private generic functions
Generic Function, (setf modifiers): Public generic functions
Generic Function, (setf modifiers): Private generic functions
Generic Function, (setf name): Public generic functions
Generic Function, (setf parents): Public generic functions
Generic Function, bound-type: Public generic functions
Generic Function, entries: Private generic functions
Generic Function, error-condition: Private generic functions
Generic Function, existing-binding-value: Private generic functions
Generic Function, keymap: Private generic functions
Generic Function, keyspec: Private generic functions
Generic Function, message: Private generic functions
Generic Function, modifiers: Public generic functions
Generic Function, modifiers: Private generic functions
Generic Function, name: Public generic functions
Generic Function, parents: Public generic functions
get-keymap: Public ordinary functions

K
key->keyspec: Private ordinary functions
key-code: Public ordinary functions
key-modifiers: Public ordinary functions
key-p: Private ordinary functions
key-status: Public ordinary functions
key-value: Public ordinary functions
key=: Public ordinary functions
keymap: Private generic functions
keymap: Private generic functions
keymap->map: Public ordinary functions
keymap->map*: Private ordinary functions
keymap-p: Public ordinary functions
keymap-tree->list: Private ordinary functions
keymap-with-parents: Private ordinary functions
keymap-with-parents->map: Public ordinary functions
keys->keyspecs: Public ordinary functions
keyscheme-map-p: Public ordinary functions
keyscheme-p: Public ordinary functions
keyspec: Private generic functions
keyspec: Private generic functions
keyspec: Private generic functions
keyspec->key: Private ordinary functions
keyspecs->keys: Private ordinary functions

L
legal-modifiers-p: Private ordinary functions
list-of-key-p: Private ordinary functions
list-of-keymap-p: Private ordinary functions
list-of-keyscheme-p: Private ordinary functions
list-of-p: Private ordinary functions
list-of-string-p: Private ordinary functions
lookup-key: Public ordinary functions
lookup-key*: Private ordinary functions
lookup-keys-in-keymap: Private ordinary functions

M
make-key: Public ordinary functions
make-keymap: Public ordinary functions
make-keyscheme: Public ordinary functions
make-keyscheme-map: Public ordinary functions
make-modifier: Private ordinary functions
message: Private generic functions
message: Private generic functions
message: Private generic functions
message: Private generic functions
message: Private generic functions
message: Private generic functions
Method, (setf bound-type): Public generic functions
Method, (setf bound-type): Public generic functions
Method, (setf entries): Private generic functions
Method, (setf error-condition): Private generic functions
Method, (setf existing-binding-value): Private generic functions
Method, (setf keymap): Private generic functions
Method, (setf keyspec): Private generic functions
Method, (setf keyspec): Private generic functions
Method, (setf message): Private generic functions
Method, (setf message): Private generic functions
Method, (setf message): Private generic functions
Method, (setf message): Private generic functions
Method, (setf message): Private generic functions
Method, (setf modifiers): Public generic functions
Method, (setf modifiers): Public generic functions
Method, (setf modifiers): Private generic functions
Method, (setf name): Public generic functions
Method, (setf name): Public generic functions
Method, (setf parents): Public generic functions
Method, (setf parents): Public generic functions
Method, bound-type: Public generic functions
Method, bound-type: Public generic functions
Method, compare: Public standalone methods
Method, compare: Public standalone methods
Method, entries: Private generic functions
Method, error-condition: Private generic functions
Method, existing-binding-value: Private generic functions
Method, keymap: Private generic functions
Method, keyspec: Private generic functions
Method, keyspec: Private generic functions
Method, message: Private generic functions
Method, message: Private generic functions
Method, message: Private generic functions
Method, message: Private generic functions
Method, message: Private generic functions
Method, modifiers: Public generic functions
Method, modifiers: Public generic functions
Method, modifiers: Private generic functions
Method, name: Public generic functions
Method, name: Public generic functions
Method, parents: Public generic functions
Method, parents: Public generic functions
Method, print-object: Public standalone methods
Method, print-object: Public standalone methods
modifier-p: Private ordinary functions
modifier-shortcut: Private ordinary functions
modifier-string: Private ordinary functions
modifier=: Public ordinary functions
modifiers: Public generic functions
modifiers: Public generic functions
modifiers: Public generic functions
modifiers: Private generic functions
modifiers: Private generic functions
modspec->modifier: Private ordinary functions
modspecs->modifiers: Private ordinary functions

N
name: Public generic functions
name: Public generic functions
name: Public generic functions

P
parents: Public generic functions
parents: Public generic functions
parents: Public generic functions
print-object: Public standalone methods
print-object: Public standalone methods

Q
quoted-symbol-p: Private ordinary functions

S
string-join: Private ordinary functions

T
toggle-case: Private ordinary functions
translate-remove-but-first-control: Public ordinary functions
translate-remove-shift: Public ordinary functions
translate-remove-shift-but-first-control: Public ordinary functions
translate-remove-shift-but-first-control-toggle-case: Public ordinary functions
translate-remove-shift-toggle-case: Public ordinary functions
translate-shift-control-combinations: Public ordinary functions

Jump to:   %   (  
B   C   D   E   F   G   K   L   M   N   P   Q   S   T  

Next: , Previous: , Up: Indexes   [Contents][Index]

A.3 Variables

Jump to:   *   +  
B   C   D   E   K   M   N   P   S   V  
Index Entry  Section

*
*default-bound-type*: Private special variables
*modifier-list*: Private special variables
*print-shortcut*: Public special variables
*translator*: Public special variables

+
+control+: Public special variables
+hyper+: Public special variables
+meta+: Public special variables
+shift+: Public special variables
+super+: Public special variables

B
bound-type: Public classes
bound-type: Public classes

C
code: Public structures
cua: Public special variables

D
default: Public special variables

E
emacs: Public special variables
entries: Public classes
error-condition: Public conditions
existing-binding-value: Public conditions

K
keymap: Public conditions
keyspec: Public conditions
keyspec: Public conditions

M
message: Public conditions
message: Public conditions
message: Public conditions
message: Public conditions
message: Public conditions
modifiers: Public conditions
modifiers: Public structures
modifiers: Public classes
modifiers: Public classes

N
name: Public classes
name: Public classes

P
parents: Public classes
parents: Public classes

S
shortcut: Private structures
Slot, bound-type: Public classes
Slot, bound-type: Public classes
Slot, code: Public structures
Slot, entries: Public classes
Slot, error-condition: Public conditions
Slot, existing-binding-value: Public conditions
Slot, keymap: Public conditions
Slot, keyspec: Public conditions
Slot, keyspec: Public conditions
Slot, message: Public conditions
Slot, message: Public conditions
Slot, message: Public conditions
Slot, message: Public conditions
Slot, message: Public conditions
Slot, modifiers: Public conditions
Slot, modifiers: Public structures
Slot, modifiers: Public classes
Slot, modifiers: Public classes
Slot, name: Public classes
Slot, name: Public classes
Slot, parents: Public classes
Slot, parents: Public classes
Slot, shortcut: Private structures
Slot, status: Public structures
Slot, string: Private structures
Slot, value: Public structures
Special Variable, *default-bound-type*: Private special variables
Special Variable, *modifier-list*: Private special variables
Special Variable, *print-shortcut*: Public special variables
Special Variable, *translator*: Public special variables
Special Variable, +control+: Public special variables
Special Variable, +hyper+: Public special variables
Special Variable, +meta+: Public special variables
Special Variable, +shift+: Public special variables
Special Variable, +super+: Public special variables
Special Variable, cua: Public special variables
Special Variable, default: Public special variables
Special Variable, emacs: Public special variables
Special Variable, vi-insert: Public special variables
Special Variable, vi-normal: Public special variables
status: Public structures
string: Private structures

V
value: Public structures
vi-insert: Public special variables
vi-normal: Public special variables

Jump to:   *   +  
B   C   D   E   K   M   N   P   S   V  

Previous: , Up: Indexes   [Contents][Index]

A.4 Data types

Jump to:   B   C   D   E   F   K   L   M   N   O   P   S   T  
Index Entry  Section

B
bad-keyspec: Public conditions
bad-modifier: Public conditions

C
Class, keymap: Public classes
Class, keyscheme: Public classes
Condition, bad-keyspec: Public conditions
Condition, bad-modifier: Public conditions
Condition, cycle: Public conditions
Condition, duplicate-modifiers: Public conditions
Condition, empty-keyspec: Public conditions
Condition, empty-modifiers: Public conditions
Condition, empty-value: Public conditions
Condition, make-key-required-arg: Public conditions
Condition, override-existing-binding: Public conditions
conditions.lisp: The nkeymaps/conditions․lisp file
cycle: Public conditions

D
duplicate-modifiers: Public conditions

E
empty-keyspec: Public conditions
empty-modifiers: Public conditions
empty-value: Public conditions

F
File, conditions.lisp: The nkeymaps/conditions․lisp file
File, keymap.lisp: The nkeymaps/keymap․lisp file
File, keyscheme-map.lisp: The nkeymaps/keyscheme-map․lisp file
File, keyschemes.lisp: The nkeymaps/keyschemes․lisp file
File, modifiers.lisp: The nkeymaps/modifiers․lisp file
File, nkeymaps.asd: The nkeymaps/nkeymaps․asd file
File, package.lisp: The nkeymaps/package․lisp file
File, translators.lisp: The nkeymaps/translators․lisp file
File, types.lisp: The nkeymaps/types․lisp file

K
key: Public structures
key-status-type: Private types
keymap: Public classes
keymap.lisp: The nkeymaps/keymap․lisp file
keyscheme: Public classes
keyscheme-map: Public types
keyscheme-map.lisp: The nkeymaps/keyscheme-map․lisp file
keyschemes.lisp: The nkeymaps/keyschemes․lisp file
keyspecs-type: Private types

L
list-of: Public types

M
make-key-required-arg: Public conditions
modifier: Private structures
modifiers.lisp: The nkeymaps/modifiers․lisp file

N
nkeymaps: The nkeymaps system
nkeymaps: The nkeymaps package
nkeymaps.asd: The nkeymaps/nkeymaps․asd file
nkeymaps/conditions: The nkeymaps/conditions package
nkeymaps/core: The nkeymaps/core package
nkeymaps/keyscheme: The nkeymaps/keyscheme package
nkeymaps/modifier: The nkeymaps/modifier package
nkeymaps/translator: The nkeymaps/translator package
nkeymaps/types: The nkeymaps/types package

O
override-existing-binding: Public conditions

P
Package, nkeymaps: The nkeymaps package
Package, nkeymaps/conditions: The nkeymaps/conditions package
Package, nkeymaps/core: The nkeymaps/core package
Package, nkeymaps/keyscheme: The nkeymaps/keyscheme package
Package, nkeymaps/modifier: The nkeymaps/modifier package
Package, nkeymaps/translator: The nkeymaps/translator package
Package, nkeymaps/types: The nkeymaps/types package
package.lisp: The nkeymaps/package․lisp file

S
Structure, key: Public structures
Structure, modifier: Private structures
System, nkeymaps: The nkeymaps system

T
translators.lisp: The nkeymaps/translators․lisp file
Type, key-status-type: Private types
Type, keyscheme-map: Public types
Type, keyspecs-type: Private types
Type, list-of: Public types
types.lisp: The nkeymaps/types․lisp file

Jump to:   B   C   D   E   F   K   L   M   N   O   P   S   T