tiny.xkb.keymap

1pub const Definition = struct {2    modifiers: []const Modifier,3    types: []const KeyType,4    keys: []const Key,5};

1pub const Group = struct {2    type_index: usize,3    levels: []const Level,4};

1pub const Key = struct {2    code: Keycode,3    groups: []const Group,4    out_of_range: OutOfRange = .wrap,5    repeats: bool = false,6};

1pub const KeyType = struct {2    modifiers: ModifierMask,3    level_count: usize,4    entries: []const TypeEntry,5};

1pub const Keymap = opaque {2    pub const Storage = struct {3        bytes: [@sizeOf(Backing)]u8 align(@alignOf(Backing)),4    };56    pub fn init(storage_value: *Storage, definition: Definition) ValidationError!*const Keymap {7        const layout_count = try validate(definition);8        const backing: *Backing = @ptrCast(storage_value);9        backing.* = .{10            .definition = definition,11            .layout_count = layout_count,12        };13        return @ptrCast(storage_value);14    }1516    pub fn modifierIndex(self: *const Keymap, name: []const u8) ?usize {17        for (self.storage().definition.modifiers, 0..) |modifier, index| {18            if (std.mem.eql(u8, modifier.name, name)) return index;19        }20        return null;21    }2223    pub fn modifierMapping(self: *const Keymap, index: usize) ?ModifierMask {24        const modifiers = self.storage().definition.modifiers;25        if (index >= modifiers.len) return null;26        return modifiers[index].mapping;27    }2829    pub fn canonicalModifierMask(self: *const Keymap) ModifierMask {30        _ = self;31        return core_modifier_mask;32    }3334    pub fn effectiveModifiers(self: *const Keymap, input: ModifierMask) ModifierMask {35        const modifiers = self.storage().definition.modifiers;36        var result = input & core_modifier_mask;37        for (modifiers[core_modifier_count..], core_modifier_count..) |modifier, index| {38            if (input & modifierBit(index) != 0) result |= modifier.mapping;39        }40        return result;41    }4243    pub fn resolveToCanonicalModifiers(self: *const Keymap, input: ModifierMask) ModifierMask {44        return (input & core_modifier_mask) |45            self.effectiveModifiers(input & ~core_modifier_mask);46    }4748    pub fn layoutCount(self: *const Keymap) usize {49        return self.storage().layout_count;50    }5152    pub fn keyType(self: *const Keymap, index: usize) ?*const KeyType {53        const types = self.storage().definition.types;54        if (index >= types.len) return null;55        return &types[index];56    }5758    pub fn key(self: *const Keymap, code: Keycode) ?*const Key {59        const keys = self.storage().definition.keys;60        var low: usize = 0;61        var high = keys.len;62        while (low < high) {63            const middle = low + (high - low) / 2;64            const candidate = &keys[middle];65            if (code < candidate.code) {66                high = middle;67            } else if (code > candidate.code) {68                low = middle + 1;69            } else {70                return candidate;71            }72        }73        return null;74    }7576    pub fn group(self: *const Keymap, key_value: *const Key, effective_layout: i32) ?usize {77        _ = self;78        if (key_value.groups.len == 0) return null;79        return groupInRange(effective_layout, key_value.groups.len, key_value.out_of_range);80    }8182    fn storage(self: *const Keymap) *const Backing {83        return @ptrCast(@alignCast(self));84    }85};

1pub const Level = struct {2    symbols: []const xkb.keysym.Keysym,3    uppercase_symbols: ?[]const xkb.keysym.Keysym = null,45    pub fn resolvedSymbols(self: *const Level, uppercase: bool) []const xkb.keysym.Keysym {6        if (uppercase) return self.uppercase_symbols orelse self.symbols;7        return self.symbols;8    }9};

1pub const Modifier = struct {2    name: []const u8,3    mapping: ModifierMask,4    kind: Kind,56    pub const Kind = enum {7        real,8        virtual,9    };10};

1pub const OutOfRange = union(enum) {2    wrap,3    saturate,4    redirect: usize,5};

1pub const TypeEntry = struct {2    modifiers: ModifierMask,3    preserve: ModifierMask = 0,4    level: usize,5};

1pub const ValidationError = error{2    TooManyModifiers,3    InvalidCoreModifiers,4    DuplicateModifierName,5    InvalidModifierMapping,6    EmptyKeyType,7    InvalidTypeEntry,8    DuplicateTypeEntry,9    InvalidGroupType,10    InvalidGroupLevels,11    InvalidGroupRedirect,12    InvalidKeyOrder,13    InvalidLayoutCount,14    InvalidKeysym,15    InvalidUppercaseSymbols,16};

1pub const Keycode = u32;

1pub const ModifierMask = u32;

1pub const core_modifier_count = 8;

1pub const core_modifier_mask: ModifierMask = (1 << core_modifier_count) - 1;

1pub const core_modifiers = [_]Modifier{2    .{ .name = "Shift", .mapping = 1 << 0, .kind = .real },3    .{ .name = "Lock", .mapping = 1 << 1, .kind = .real },4    .{ .name = "Control", .mapping = 1 << 2, .kind = .real },5    .{ .name = "Mod1", .mapping = 1 << 3, .kind = .real },6    .{ .name = "Mod2", .mapping = 1 << 4, .kind = .real },7    .{ .name = "Mod3", .mapping = 1 << 5, .kind = .real },8    .{ .name = "Mod4", .mapping = 1 << 6, .kind = .real },9    .{ .name = "Mod5", .mapping = 1 << 7, .kind = .real },10};

1pub fn groupInRange(group: i32, count: usize, out_of_range: OutOfRange) usize {2    std.debug.assert(count != 0);3    if (group >= 0 and @as(usize, @intCast(group)) < count) return @intCast(group);4    return switch (out_of_range) {5        .redirect => |redirect| if (redirect < count) redirect else 0,6        .saturate => if (group < 0) 0 else count - 1,7        .wrap => @intCast(@mod(@as(i64, group), @as(i64, @intCast(count)))),8    };9}

1pub const max_layouts = 32;

1pub fn modifierBit(index: usize) ModifierMask {2    std.debug.assert(index < @bitSizeOf(ModifierMask));3    return @as(ModifierMask, 1) << @intCast(index);4}

1const model = @import("model.zig");23pub const text = @import("text/root.zig");45pub const ModifierMask = model.ModifierMask;6pub const Keycode = model.Keycode;7pub const max_layouts = model.max_layouts;8pub const core_modifier_count = model.core_modifier_count;9pub const core_modifier_mask = model.core_modifier_mask;10pub const Modifier = model.Modifier;11pub const core_modifiers = model.core_modifiers;12pub const TypeEntry = model.TypeEntry;13pub const KeyType = model.KeyType;14pub const Level = model.Level;15pub const Group = model.Group;16pub const OutOfRange = model.OutOfRange;17pub const Key = model.Key;18pub const Definition = model.Definition;19pub const ValidationError = model.ValidationError;20pub const Keymap = model.Keymap;21pub const modifierBit = model.modifierBit;22pub const groupInRange = model.groupInRange;

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