tiny.xkb.state

1pub const Changes = struct {2    depressed_modifiers: bool = false,3    latched_modifiers: bool = false,4    locked_modifiers: bool = false,5    effective_modifiers: bool = false,6    depressed_layout: bool = false,7    latched_layout: bool = false,8    locked_layout: bool = false,9    effective_layout: bool = false,1011    pub fn any(self: Changes) bool {12        return self.depressed_modifiers or self.latched_modifiers or13            self.locked_modifiers or self.effective_modifiers or14            self.depressed_layout or self.latched_layout or15            self.locked_layout or self.effective_layout;16    }17};

1pub const Mask = struct {2    depressed_modifiers: keymap.ModifierMask = 0,3    latched_modifiers: keymap.ModifierMask = 0,4    locked_modifiers: keymap.ModifierMask = 0,5    depressed_layout: u32 = 0,6    latched_layout: u32 = 0,7    locked_layout: u32 = 0,8};

1pub const ModifierComponents = struct {2    depressed: bool = false,3    latched: bool = false,4    locked: bool = false,5    effective: bool = false,6};

1pub const State = struct {2    keymap: *const keymap.Keymap,3    components: Components = .{},45    pub fn init(compiled: *const keymap.Keymap) State {6        return .{ .keymap = compiled };7    }89    pub fn update(self: *State, input: Mask) Changes {10        const previous = self.components;11        self.components.depressed_modifiers = self.keymap.resolveToCanonicalModifiers(input.depressed_modifiers);12        self.components.latched_modifiers = self.keymap.resolveToCanonicalModifiers(input.latched_modifiers);13        self.components.locked_modifiers = self.keymap.resolveToCanonicalModifiers(input.locked_modifiers);14        self.components.effective_modifiers = self.components.depressed_modifiers |15            self.components.latched_modifiers |16            self.components.locked_modifiers;17        self.components.depressed_layout = @bitCast(input.depressed_layout);18        self.components.latched_layout = @bitCast(input.latched_layout);19        self.components.locked_layout = layoutInRange(@bitCast(input.locked_layout), self.keymap.layoutCount());20        const layout_sum = self.components.depressed_layout +%21            self.components.latched_layout +% self.components.locked_layout;22        self.components.effective_layout = layoutInRange(layout_sum, self.keymap.layoutCount());23        return changes(previous, self.components);24    }2526    pub fn effectiveModifiers(self: *const State) keymap.ModifierMask {27        return self.components.effective_modifiers;28    }2930    pub fn effectiveLayout(self: *const State) usize {31        return @intCast(self.components.effective_layout);32    }3334    pub fn modifierActive(self: *const State, name: []const u8) bool {35        const index = self.keymap.modifierIndex(name) orelse return false;36        return self.modifierIndexActive(index, .{ .effective = true });37    }3839    pub fn modifierIndexActive(40        self: *const State,41        index: usize,42        requested: ModifierComponents,43    ) bool {44        const mapping = self.keymap.modifierMapping(index) orelse return false;45        if (mapping == 0) return false;46        const active = self.serializeModifiers(requested);47        return active & mapping == mapping;48    }4950    pub fn keyRepeats(self: *const State, code: keymap.Keycode) bool {51        const key_value = self.keymap.key(code) orelse return false;52        return key_value.repeats;53    }5455    pub fn layout(self: *const State, code: keymap.Keycode) ?usize {56        const key_value = self.keymap.key(code) orelse return null;57        return self.keymap.group(key_value, self.components.effective_layout);58    }5960    pub fn level(self: *const State, code: keymap.Keycode) ?usize {61        const key_value = self.keymap.key(code) orelse return null;62        const group_index = self.keymap.group(key_value, self.components.effective_layout) orelse return null;63        return self.levelForGroup(key_value, group_index);64    }6566    pub fn symbols(self: *const State, code: keymap.Keycode) []const keysym.Keysym {67        const selection_value = self.selection(code) orelse return &.{};68        return selection_value.level.resolvedSymbols(self.capsTransforms(code));69    }7071    pub fn oneSymbol(self: *const State, code: keymap.Keycode) ?keysym.Keysym {72        const selected = self.symbols(code);73        if (selected.len != 1) return null;74        return selected[0];75    }7677    pub fn consumedModifiers(self: *const State, code: keymap.Keycode) keymap.ModifierMask {78        const selection_value = self.selection(code) orelse return 0;79        const key_type = self.keymap.keyType(selection_value.group.type_index).?;80        const active = self.components.effective_modifiers & key_type.modifiers;81        var preserve: keymap.ModifierMask = 0;82        for (key_type.entries) |entry| {83            if (entry.modifiers == active) {84                preserve = entry.preserve;85                break;86            }87        }88        return key_type.modifiers & ~preserve;89    }9091    pub fn modifierConsumed(self: *const State, code: keymap.Keycode, name: []const u8) bool {92        const index = self.keymap.modifierIndex(name) orelse return false;93        const mapping = self.keymap.modifierMapping(index) orelse return false;94        if (mapping == 0) return false;95        return self.consumedModifiers(code) & mapping == mapping;96    }9798    pub fn writeUtf8(99        self: *const State,100        code: keymap.Keycode,101        buffer: []u8,102    ) TextError!?[]const u8 {103        const control = self.controlTransforms(code);104        if (self.oneSymbolForText(code, control)) |symbol| {105            const written = try writeSymbol(symbol, buffer);106            if (written == 0) return null;107            if (written == 1 and control) buffer[0] = toControl(buffer[0]);108            return buffer[0..written];109        }110111        const selected = self.symbols(code);112        if (selected.len == 0) return null;113        var written: usize = 0;114        for (selected) |symbol| {115            const count = try writeSymbol(symbol, buffer[written..]);116            if (count == 0) return null;117            written += count;118        }119        if (written == 1 and control) buffer[0] = toControl(buffer[0]);120        return buffer[0..written];121    }122123    fn serializeModifiers(self: *const State, requested: ModifierComponents) keymap.ModifierMask {124        if (requested.effective) return self.components.effective_modifiers;125        var result: keymap.ModifierMask = 0;126        if (requested.depressed) result |= self.components.depressed_modifiers;127        if (requested.latched) result |= self.components.latched_modifiers;128        if (requested.locked) result |= self.components.locked_modifiers;129        return result;130    }131132    fn selection(self: *const State, code: keymap.Keycode) ?Selection {133        const key_value = self.keymap.key(code) orelse return null;134        const group_index = self.keymap.group(key_value, self.components.effective_layout) orelse return null;135        const group = &key_value.groups[group_index];136        const level_index = self.levelForGroup(key_value, group_index);137        if (level_index >= group.levels.len) return null;138        return .{139            .key = key_value,140            .group = group,141            .level = &group.levels[level_index],142        };143    }144145    fn levelForGroup(self: *const State, key_value: *const keymap.Key, group_index: usize) usize {146        const group = key_value.groups[group_index];147        const key_type = self.keymap.keyType(group.type_index).?;148        const active = self.components.effective_modifiers & key_type.modifiers;149        for (key_type.entries) |entry| {150            if (entry.modifiers == active) return entry.level;151        }152        return 0;153    }154155    fn capsTransforms(self: *const State, code: keymap.Keycode) bool {156        return self.modifierActive("Lock") and !self.modifierConsumed(code, "Lock");157    }158159    fn controlTransforms(self: *const State, code: keymap.Keycode) bool {160        return self.modifierActive("Control") and !self.modifierConsumed(code, "Control");161    }162163    fn oneSymbolForText(164        self: *const State,165        code: keymap.Keycode,166        control: bool,167    ) ?keysym.Keysym {168        const selected = self.selection(code) orelse return null;169        if (selected.level.symbols.len != 1) return null;170        var selected_level = selected.level;171        if (control and @backingInt(selected_level.symbols[0]) > 127) {172            for (selected.key.groups, 0..) |group, group_index| {173                const level_index = self.levelForGroup(selected.key, group_index);174                if (level_index >= group.levels.len) continue;175                const candidates = group.levels[level_index].symbols;176                if (candidates.len == 1 and @backingInt(candidates[0]) <= 127) {177                    selected_level = &group.levels[level_index];178                    break;179                }180            }181        }182        const resolved = selected_level.resolvedSymbols(self.capsTransforms(code));183        return resolved[0];184    }185};

1pub const TextError = error{BufferTooSmall};

1pub const state = @import("state/root.zig");

1const model = @import("model.zig");23pub const Mask = model.Mask;4pub const Changes = model.Changes;5pub const ModifierComponents = model.ModifierComponents;6pub const TextError = model.TextError;7pub const State = model.State;