Struct KeymapPolicy 

pub struct KeymapPolicy {
    base_text: String,
    base_map: HashMap<u32, (u32, u32)>,
    slots: Vec<Option<u32>>,
    by_sym: HashMap<u32, usize>,
    lru: VecDeque<usize>,
    overlay_codes: Vec<u32>,
    preferred: usize,
    base_bound: HashSet<u32>,
    manual_overlay: BTreeMap<u32, u32>,
}

Seat keymap state: the base text, its reverse keysym map, and the overlay slots.

Fields

base_text: String

base_map: HashMap<u32, (u32, u32)>

keysym -> (xkb keycode, level) in the base keymap; lowest level wins.

slots: Vec<Option<u32>>

slot index -> bound keysym.

by_sym: HashMap<u32, usize>

keysym -> slot index.

lru: VecDeque<usize>

Slot recycle order, oldest bind first.

overlay_codes: Vec<u32>

Overlay keycodes (xkb numbering) in the order free slots take them; slot i lives at overlay_codes[i].

preferred: usize

How many of the leading overlay codes a bind prefers, recycling the oldest of them before taking a free code past them: the seat’s text spares, which Chromium types on.

base_bound: HashSet<u32>

The text spares the base binds to a keysym other than a vendor one, which an overlay slot must not shadow. (The virtual-keyboard client’s own codes are base character keys it shadows on purpose, unshadow taking them back.)

manual_overlay: BTreeMap<u32, u32>

Externally-owned overlay binds (keycode -> keysym): selkies resolves its own keysyms and hands the compositor explicit assignments. Held here so every keymap the policy emits carries them, and a policy rebuild (computer-use bind, base-layout swap) keeps them live instead of dropping them until selkies re-sends.

Implementations

impl KeymapPolicy

pub fn empty() -> Self

Placeholder policy before the seat keymap is known; rebuild_base fills it in.

pub fn seat() -> Self

The compositor seat’s policy: the text spares (TEXT_SPARE_KEYCODES) first, then the above-255 range.

pub fn with_overlay_codes(overlay_codes: Vec<u32>) -> Self

Policy with its own overlay keycodes (xkb numbering), taken in order. The seat uses empty()’s above-255 range; the virtual-keyboard client typing into a nested compositor uses the main block’s character keys, which a base character the batch types takes back (unshadow).

pub fn rebuild_base(&mut self, base_text: String) -> bool

Replace the base keymap text and rebuild the reverse map. Overlay assignments are retained (same keycodes), so keycodes already handed out stay valid across the swap. Returns whether base_text compiled. A string that does not is rejected without touching any state, so the caller needs no separate validation pass — compiling a keymap is the expensive part of installing one and doing it twice is pure cost.

pub fn has_base(&self) -> bool

True once a base keymap has been installed.

pub fn resolve(&self, keysym: u32) -> Option<(u32, u32)>

Resolve keysym without binding: base first, then an existing overlay slot.

fn slot_at(&self, keycode: u32) -> Option<usize>

The occupied overlay slot on keycode, whose keysym shadows the base’s there.

fn unshadow( &mut self, keysyms: &[u32], pressed: &HashSet<u32>, plain_only: bool, changed: &mut bool, ) -> HashSet<u32>

Unbind every overlay slot shadowing a base keycode the batch presses, unless it is held, and return those keycodes so the batch’s own binds skip them.

pub fn resolves_plain(&self, keysym: u32) -> bool

True when keysym resolves at level 0 (base or overlay) — i.e. typable without synthetic modifiers.

pub fn bind_many( &mut self, keysyms: &[u32], pressed: &HashSet<u32>, ) -> (Vec<(u32, u32)>, bool)

Resolve every keysym, overlay-binding the unresolvable ones. Returns one (keycode, level) per input keysym ((0, 0) when it cannot be bound) plus whether the keymap changed and must be re-applied — at most ONE swap per call, however many new keysyms were bound. Slots whose keycode is in pressed are never recycled.

pub fn bind_many_plain( &mut self, keysyms: &[u32], pressed: &HashSet<u32>, ) -> (Vec<u32>, bool)

Like bind_many but only accepts level-0 resolutions: a keysym reachable in the base solely behind a modifier (e.g. A behind Shift) is overlay-bound instead, so the caller can inject it without synthesizing modifiers. Returns keycodes (0 = unbindable).

fn bind_one( &mut self, sym: u32, pressed: &HashSet<u32>, reserved: &HashSet<u32>, plain_only: bool, changed: &mut bool, ) -> (u32, u32)

fn recycle_slot( &mut self, pressed: &HashSet<u32>, reserved: &HashSet<u32>, below: usize, ) -> Option<usize>

Oldest slot below below whose keycode is neither held down nor pressed for its base keysym by this batch; a held keycode must keep its meaning until its release has been delivered.

fn takes(&self, keycode: u32, reserved: &HashSet<u32>) -> bool

Whether a slot may hold keycode: not one this batch presses for its base keysym, not a text spare the base binds to a real keysym, and not one selkies’ overlay holds.

pub fn set_manual_overlay(&mut self, binds: &[(u32, u32)])

Replace the externally-owned overlay binds (keycode -> keysym). selkies resolves its own keysyms and re-sends the whole set on every change, so a full replace is the contract. They then ride along in every keymap_text, so a base-layout swap or a computer-use policy bind re-applies them instead of dropping them. A slot on a keycode selkies now binds gives it up, so its keysym is bound afresh elsewhere when next typed.

pub fn keymap_text(&self) -> String

The full seat keymap: the base text with every occupied policy overlay slot and every externally-owned bind spliced into the xkb_keycodes and xkb_symbols sections (and maximum raised to cover them). With neither, the base text verbatim. A manual bind sharing a keycode with a policy slot is emitted last, so its symbol wins.

fn section_close(text: &str, from: usize) -> Option<usize>

Byte offset of the } closing the brace-block that starts at/after from.