diff --git a/build.zig b/build.zig index 55a5f4d..4656fc6 100644 --- a/build.zig +++ b/build.zig @@ -178,6 +178,13 @@ pub fn build(b: *std.Build) void { .root_source_file = b.path("system/services/vfs/protocol.zig"), }); + // The input wire protocol: the input service's public interface, exposed as its own + // module the same way vfs-protocol is. Shared by the input service, the runtime's + // `input` helper (subscribe/publish), and every source and subscriber. + const input_protocol_module = b.addModule("input-protocol", .{ + .root_source_file = b.path("system/services/input/protocol.zig"), + }); + // The danos-native user-space runtime: system_call wrappers, the C-convention // heap, IPC helpers, the process start shim, device access. This is the stable // application ABI; POSIX compatibility is a separate library on top (see below). @@ -193,6 +200,7 @@ pub fn build(b: *std.Build) void { .{ .name = "abi", .module = abi_module }, .{ .name = "device-abi", .module = device_abi_module }, .{ .name = "vfs-protocol", .module = vfs_protocol_module }, + .{ .name = "input-protocol", .module = input_protocol_module }, }, }); @@ -203,6 +211,21 @@ pub fn build(b: *std.Build) void { .root_source_file = b.path("library/mmio/mmio.zig"), }); + // Keyboard layouts compiled from the X11 xkeyboard-config database into native Zig + // (keycode + modifiers -> keysym/character). The `layouts` tables are generated by + // tools/make-xkeyboard-config.py; `xkeyboard-config` is the hand-written API over them. + // No target set, so each inherits its importer's. See library/xkeyboard-config/. + const xkb_layouts_module = b.addModule("layouts", .{ + .root_source_file = b.path("library/xkeyboard-config/generated/layouts.zig"), + }); + const xkeyboard_config_module = b.addModule("xkeyboard-config", .{ + .root_source_file = b.path("library/xkeyboard-config/xkeyboard-config.zig"), + .imports = &.{ + .{ .name = "layouts", .module = xkb_layouts_module }, + }, + }); + _ = xkeyboard_config_module; + // The POSIX / C compatibility layer, a separate library layered strictly over the // runtime (it calls the runtime's IPC/heap, never system calls directly). This is // the one place POSIX/C spellings are allowed verbatim — see docs/coding-standards.md @@ -298,7 +321,15 @@ pub fn build(b: *std.Build) void { const vfstest_exe = addUserBinary(b, kernel_target, runtime_module, posix_module, mmio_module, "vfs-test", "system/services/vfs/vfs-test.zig"); const hpet_exe = addUserBinary(b, kernel_target, runtime_module, posix_module, mmio_module, "hpet", "system/drivers/hpet/hpet.zig"); const bus_exe = addUserBinary(b, kernel_target, runtime_module, posix_module, mmio_module, "bus", "system/drivers/bus/bus.zig"); + const ps2_bus_exe = addUserBinary(b, kernel_target, runtime_module, posix_module, mmio_module, "bus", "system/drivers/ps2-bus/ps2-bus.zig"); + const ps2_keyboard_exe = addUserBinary(b, kernel_target, runtime_module, posix_module, mmio_module, "ps2-keyboard", "system/drivers/ps2-bus/keyboard.zig"); + const ps2_mouse_exe = addUserBinary(b, kernel_target, runtime_module, posix_module, mmio_module, "ps2-mouse", "system/drivers/ps2-bus/mouse.zig"); const device_manager_exe = addUserBinary(b, kernel_target, runtime_module, posix_module, mmio_module, "device-manager", "system/services/device-manager/device-manager.zig"); + // The input service and its exercisers: the fan-out server, a hardware-free synthetic + // source, and a subscriber that doubles as the `input` test's oracle. See docs/input.md. + const input_exe = addUserBinary(b, kernel_target, runtime_module, posix_module, mmio_module, "input", "system/services/input/input.zig"); + const input_source_exe = addUserBinary(b, kernel_target, runtime_module, posix_module, mmio_module, "input-source", "system/services/input-source/input-source.zig"); + const input_test_exe = addUserBinary(b, kernel_target, runtime_module, posix_module, mmio_module, "input-test", "system/services/input-test/input-test.zig"); const args_echo_exe = addUserBinary(b, kernel_target, runtime_module, posix_module, mmio_module, "args-echo", "system/services/args-echo/args-echo.zig"); const process_test_exe = addUserBinary(b, kernel_target, runtime_module, posix_module, mmio_module, "process-test", "system/services/process-test/process-test.zig"); @@ -316,8 +347,20 @@ pub fn build(b: *std.Build) void { mk_run.addFileArg(hpet_exe.getEmittedBin()); mk_run.addArg("bus"); mk_run.addFileArg(bus_exe.getEmittedBin()); + mk_run.addArg("ps2-bus"); + mk_run.addFileArg(ps2_bus_exe.getEmittedBin()); + mk_run.addArg("ps2-keyboard"); + mk_run.addFileArg(ps2_keyboard_exe.getEmittedBin()); + mk_run.addArg("ps2-mouse"); + mk_run.addFileArg(ps2_mouse_exe.getEmittedBin()); mk_run.addArg("device-manager"); mk_run.addFileArg(device_manager_exe.getEmittedBin()); + mk_run.addArg("input"); + mk_run.addFileArg(input_exe.getEmittedBin()); + mk_run.addArg("input-source"); + mk_run.addFileArg(input_source_exe.getEmittedBin()); + mk_run.addArg("input-test"); + mk_run.addFileArg(input_test_exe.getEmittedBin()); mk_run.addArg("args-echo"); mk_run.addFileArg(args_echo_exe.getEmittedBin()); mk_run.addArg("process-test"); @@ -328,8 +371,12 @@ pub fn build(b: *std.Build) void { for ([_]struct { *std.Build.Step.Compile, []const u8 }{ .{ vfs_exe, "system/services" }, .{ device_manager_exe, "system/services" }, + .{ input_exe, "system/services" }, .{ hpet_exe, "system/drivers" }, .{ bus_exe, "system/drivers" }, + .{ ps2_bus_exe, "system/drivers" }, + .{ ps2_keyboard_exe, "system/drivers" }, + .{ ps2_mouse_exe, "system/drivers" }, }) |entry| { const step = b.addInstallArtifact(entry[0], .{ .dest_dir = .{ .override = .{ .custom = entry[1] } } }); b.getInstallStep().dependOn(&step.step); @@ -470,4 +517,25 @@ pub fn build(b: *std.Build) void { }); test_step.dependOn(&b.addRunArtifact(mod_tests).step); } + + // The xkeyboard-config keymap tests need its generated `layouts` import wired, so they + // don't fit the plain loop above. Its keycode->character assertions are the end-to-end + // proof that the xkb-data -> generator -> Zig-lookup pipeline is correct. + const xkb_tests = b.addTest(.{ + .root_module = b.createModule(.{ + .root_source_file = b.path("library/xkeyboard-config/xkeyboard-config.zig"), + .target = target, + .optimize = optimize, + .imports = &.{ + .{ .name = "layouts", .module = xkb_layouts_module }, + }, + }), + }); + test_step.dependOn(&b.addRunArtifact(xkb_tests).step); + + // Convenience: `zig build gen-xkeyboard-config` regenerates the layout tables from the + // vendored data (offline). `fetch` (the network step) stays a manual script run. + const gen_xkb = b.addSystemCommand(&.{ "python3", "tools/make-xkeyboard-config.py", "generate" }); + const gen_xkb_step = b.step("gen-xkeyboard-config", "Regenerate library/xkeyboard-config/generated from the vendored data"); + gen_xkb_step.dependOn(&gen_xkb.step); } diff --git a/docs/README.md b/docs/README.md index b02e240..bd69c58 100644 --- a/docs/README.md +++ b/docs/README.md @@ -52,7 +52,11 @@ rather than restate it. Roughly in the order things happen at runtime: microkernel's `ps`/`kill`/SIGCHLD: enumerate as a table snapshot, the supervision link as the kill authority, and child-exit notifications over the same endpoints IRQs arrive on. -16. **[halting.md](halting.md) — halting.** Why a kernel can't just "exit", and +16. **[input.md](input.md) — the input module.** Broadcasting input events (keyboard, + mouse, joystick): why a synchronous rendezvous can't fan out to many listeners, the + asynchronous `ipc_send` primitive built to fix it, and the per-device subscribe/publish + service layered on top. +17. **[halting.md](halting.md) — halting.** Why a kernel can't just "exit", and how `while (true) hlt` parks the CPU safely once there's nothing left to do. Start with the north star: diff --git a/docs/input.md b/docs/input.md new file mode 100644 index 0000000..bde90be --- /dev/null +++ b/docs/input.md @@ -0,0 +1,147 @@ +# The input module: broadcasting input events + +A keyboard driver has one keystroke and *many* programs that might want it — a shell, a +window server, a logger. None of them owns the hardware, and the driver should not know +who is listening. So between the drivers and the listeners sits the **input service** +(`system/services/input/`): drivers **publish** events to it, programs **subscribe**, and +it fans each event out to every interested subscriber. It is an ordinary ring-3 process +reached over IPC, like the [VFS server](../system/services/vfs/vfs.zig) — no kernel knows +what a key is. + +## One service, several device classes + +The service carries three device classes today — **keyboard**, **mouse**, and +**joystick/gamepad** — and is built to take more +([protocol.zig](../system/services/input/protocol.zig)). Each class has its own typed +event: + +- `KeyEvent` — `key_down`/`key_up` (physical make/break) and `key_press` (a character was + produced, carrying the Unicode scalar); plus a layout-independent `keycode` and a + `modifiers` bitmask. +- `MouseEvent` — relative `motion` (`dx`/`dy`), `button_down`/`button_up`, and `scroll`. +- `JoystickEvent` — `axis` moves (a signed value on a `control` index) and + `button_down`/`button_up`. + +All three travel in one **`InputEvent` envelope** tagged with a `DeviceKind`, so the +fan-out is a single code path and a subscriber can take a mix of classes on one stream. +Decode an envelope with `asKeyboard()` / `asMouse()` / `asJoystick()` (each returns null +unless the tag matches). A subscriber names the classes it wants with a **`device_mask`**, +and the service routes each event only to subscribers whose mask includes its class — so a +mouse-only listener never wakes for keystrokes. + +## Why this needed a new kernel primitive + +The interesting part is delivery, and it runs straight into the shape of danos IPC. +[ipc.md](ipc.md) describes a **synchronous rendezvous**: a server holds exactly one +pending reply (`Task.ipc_client`) and *must* answer it on its next `replyWait`. Two +consequences decide the whole design: + +1. **You cannot block N subscribers waiting for "the next event".** A server can hold only + one caller at a time, so the natural "subscriber calls `next_event()` and blocks" API + is impossible for more than one subscriber. Delivery therefore has to be **push** — the + service reaching out to subscribers — not pull. + +2. **A synchronous push can hang the whole service.** If the service delivered with + `ipc_call`, it would block until each subscriber replied. `ipc_call` has no timeout, and + the kernel does **not** wake a caller parked on a *dead* peer's endpoint (it only fails a + peer that was mid-reply — see [process.zig](../system/kernel/process.zig) + `releaseTaskResourcesLocked`). One subscriber that exits mid-delivery would wedge input + for everyone. That is the opposite of the resilience the microkernel is for. + +The fix is the asynchronous send that [ipc.md](ipc.md) had already earmarked as future +work ("asynchronous / buffered send … for notifications between servers"): + +``` +ipc_send(handle, message_ptr, message_len) -> 0 / -errno +``` + +`ipc_send` copies a small payload into the endpoint's **bounded queue** and wakes a +receiver, then returns immediately — it never blocks and so can never hang on a dead or +slow subscriber. The receiver picks it up through the same `replyWait` it already runs: +the wake arrives as a **buffered message** — `notify_badge_bit | notify_message_bit` set in +the badge (distinguishing it from a bare IRQ/child-exit notification), the sender's task id +in the low bits, and the payload in the receive buffer, with no reply owed. The queue holds +16 messages per endpoint; a full queue **drops the oldest**, because a buffered message is +discrete data, not a coalescing "level" like an interrupt. See +[ipc-synchronous.zig](../system/kernel/ipc-synchronous.zig) (`sendLocked`, `popPost`, and +the `replyWait` receive loop). + +This is the async counterpart of `ipc_call`, and the input service is its first consumer. + +## How the pieces fit + +``` + keyboard/mouse driver, input-source input service subscriber(s) + ----------------------------------- ------------- ------------- + connectSource(); loop: replyWait: subscribeKeyboard()/…All: + publishKeyboardEvent(k) ─ ipc_call ─▶ publish → broadcast: createIpcEndpoint() + publishMouseEvent(m) for each sub whose callCap(subscribe, + publishJoystickEvent(j) mask matches event.device: send_cap = ep, + ipc_send(sub_ep) ──────▶ device_mask) + reply ok loop: next() + subscribe → store {ep cap, └─ replyWait(ep) + task id, device_mask} → InputEvent +``` + +- A **subscriber** calls `input.subscribe(mask)` — or a typed helper: `subscribeKeyboard()`, + `subscribeMouse()`, `subscribeJoystick()` (one class, `next()` returns the decoded event), + or `subscribeAll()` (every class, `next()` returns a tagged `InputEvent`) + ([library/runtime/input.zig](../library/runtime/input.zig)). It creates its own endpoint + and hands it to the service as a **capability** (M13 capability passing — the input + service is that feature's first real user), along with its `device_mask`. Then it loops on + `next()`, a `replyWait` on that endpoint returning each pushed event. +- A **source** (a keyboard, mouse, or joystick driver) calls `input.connectSource()` and the + method for its class: `publishKeyboardEvent`, `publishMouseEvent`, or + `publishJoystickEvent`. Publishing is a short synchronous `ipc_call` the service answers at + once; the service's own fan-out is asynchronous, so publishing never blocks on a slow + subscriber. +- The **service** ([input.zig](../system/services/input/input.zig)) keeps a small subscriber + table (endpoint handle + owning task id + `device_mask`). On `publish` it `ipc_send`s the + event to every subscriber whose mask includes the event's device class. On `subscribe` it + stores the passed capability and mask and, as housekeeping, prunes any slot whose owning + process has exited (checked against `process_enumerate`) — not for correctness (an async + send to an orphaned endpoint is harmless) but to reclaim the slot. + +Publisher and subscriber must be **separate processes**: a single thread that both +published and serviced its own subscription would deadlock (its `publish` call blocks until +the service delivers to its endpoint, which only the same thread could receive). + +## Status and follow-ups + +- **Synthetic sources, for now.** The `ps2-bus` driver owns PNP0303, which carries *both* + the 0x60/0x64 ports and IRQ1, so reading real scancodes/packets has to live in the bus, + not in [keyboard.zig](../system/drivers/ps2-bus/keyboard.zig) / + [mouse.zig](../system/drivers/ps2-bus/mouse.zig). Until that lands, the keyboard driver + publishes a synthetic key stream, the mouse driver a synthetic motion/click stream, and + the hardware-free `input-source` rotates through all three classes (including a synthetic + joystick, which has no driver yet) — all via the `input.synthetic*Event` helpers. The + fan-out and per-device routing are real; only the bytes are placeholder. **Follow-up:** the + bus binds IRQ1/IRQ12, reads port 0x60, and `ps2-library` decodes scan-set-1 → + keycodes and mouse packets; the drivers publish decoded events. +- **Keycode → character** is a keymap, and danos has one: + [`library/xkeyboard-config`](../library/xkeyboard-config/README.md) compiles the X11 + xkeyboard-config layouts (us, gb, de, fr, …) to native Zig — + `xkb.map(layout, keycode, mods)` → keysym + Unicode character. Wiring it in to fill a + `key_press` event's `character` (in the keyboard driver, or a small keymap service) is the + natural next step. +- **Drop-oldest under overflow** is a defined loss; the 16-slot ring absorbs normal bursts. + Real backpressure/flow-control is future work. +- **`publish` is unauthenticated** — any process may publish, consistent with the current + bring-up trust model (see [driver-model.md](driver-model.md)). A source capability is + future work. + +## Verifying it + +The `input` case (`python3 test/qemu_test.py input`, in +[tests.zig](../system/kernel/tests.zig) `inputTest`) boots the real kernel and spawns the +service, the synthetic source (which cycles keyboard, mouse, and joystick events), and a +subscriber that took all three classes. It passes only when the subscriber heartbeats +`input-test: ok` — proof that an event travelled source → service → subscriber over IPC, +exercising `ipc_send`, capability-passing subscription, and per-device routing. Each +serial line names the class received, so the log shows all three arriving on one stream. + +## See also + +- [ipc.md](ipc.md) — the synchronous rendezvous and the notification path `ipc_send` extends. +- [syscall.md](syscall.md) — the system-call surface, including `ipc_send`. +- [driver-model.md](driver-model.md) — class drivers, capability passing (M13), the trust model. diff --git a/docs/ipc.md b/docs/ipc.md index 868de10..a503a87 100644 --- a/docs/ipc.md +++ b/docs/ipc.md @@ -95,6 +95,11 @@ This is what makes a user-space driver possible at all, and it's the subject of every capability is either well-known (the registry) or inherited — there's no way to delegate one. - **Asynchronous / buffered send** for the cases where a rendezvous is the wrong - shape (logging, notifications between servers). + shape (logging, notifications between servers). *Landed as `ipc_send`* — a + non-blocking post to an endpoint's bounded payload queue, delivered through + `reply_wait` as a buffered message (badge bit `notify_message_bit`). Built for, and + first used by, the [input service](input.md)'s keyboard-event broadcast, where a + synchronous push would let one dead subscriber hang the fan-out. A full queue drops + the oldest (discrete messages, not a coalescing level like the notification ring). - **A bounded reply.** `MSG_MAX` is 256 bytes and the copy runs under the big kernel lock; a bulk transfer wants shared pages, not a copy. diff --git a/docs/syscall.md b/docs/syscall.md index bbb10a9..6447b41 100644 --- a/docs/syscall.md +++ b/docs/syscall.md @@ -47,6 +47,8 @@ Everything else---including`read()`,`write()`,`malloc()`, and`fork()`---will run - **What it does:**Used strictly by your background user-space servers (like your disk driver or filesystem). It sends a reply to the last client that called it, and immediately puts the server to sleep until the next request arrives.[[1](https://news.ycombinator.com/item?id=33078441)] 3. **`Yield()`/`Thread_Ctrl()`** - **What it does:**Allows a thread to voluntarily give up its CPU time slice, or allows a root task to spawn/kill threads. +4. **`ipc_send(endpoint, message_buffer)`(Asynchronous Send)** + - **What it does:**Posts a small payload to an endpoint's bounded queue and returns *without* blocking — no rendezvous, no reply. The receiver picks it up through the same `IPC_ReplyWait`, as a buffered message. It is the async counterpart of `IPC_Call`, for one-to-many broadcasts where a synchronous rendezvous would let one dead or slow receiver hang the sender. The [input service](input.md) — keyboard-event fan-out — is its first user. A full queue drops the oldest message (a buffered message is discrete data, unlike a coalescing interrupt notification). * * * * * diff --git a/library/runtime/device.zig b/library/runtime/device.zig index 6502314..0bc1525 100644 --- a/library/runtime/device.zig +++ b/library/runtime/device.zig @@ -3,6 +3,7 @@ //! ownership of its hardware; the claim is the capability the kernel checks before //! mapping registers or routing an IRQ. +const std = @import("std"); const abi = @import("abi"); const device_abi = @import("device-abi"); const sc = @import("system-call.zig"); @@ -108,3 +109,19 @@ pub fn ioRead(device_id: u64, resource_index: u64, offset: u64, width: u8) ?u32 pub fn ioWrite(device_id: u64, resource_index: u64, offset: u64, width: u8, value: u32) bool { return !failed(sc.systemCall5(.io_write, device_id, resource_index, offset, width, value)); } + +/// Find DeviceDescription by hid +/// +/// Utility function for driver development +pub fn findDeviceDescriptorByHid(buffer: []DeviceDescriptor, hid_needle: []const u8) ?DeviceDescriptor { + const total = enumerate(buffer); + const n = @min(total, buffer.len); + for (@as([]DeviceDescriptor, buffer[0..n])) |d| { + const hid_haystack = d.hid[0..@intCast(d.hid_len)]; + if (std.mem.eql(u8, hid_haystack, hid_needle)) { + return d; + } + } + + return null; +} \ No newline at end of file diff --git a/library/runtime/input.zig b/library/runtime/input.zig new file mode 100644 index 0000000..bac3f4d --- /dev/null +++ b/library/runtime/input.zig @@ -0,0 +1,219 @@ +//! User-space input helpers: the client and publisher sides of the input service, so a +//! program listening for input events — or a driver broadcasting them — doesn't hand-roll +//! the IPC. Layered over `ipc` (endpoints, capability passing, `send`) and the shared +//! `input-protocol` wire format, the way `device.zig` layers over the raw `device_*` calls. +//! See system/services/input/input.zig. +//! +//! The service carries several device classes (keyboard, mouse, joystick/gamepad). A +//! **source** publishes its class with the matching method: +//! var source = input.connectSource() orelse return; +//! _ = source.publishKeyboardEvent(.{ .kind = ..., .keycode = ..., ... }); +//! _ = source.publishMouseEvent(.{ ... }); +//! _ = source.publishJoystickEvent(.{ ... }); +//! +//! A **subscriber** either takes one class with a typed helper — +//! var keys = input.subscribeKeyboard() orelse return; +//! while (true) { const key = keys.next() orelse continue; ... } +//! — or takes several at once and inspects the tagged envelope: +//! var listener = input.subscribeAll() orelse return; +//! while (true) { +//! const event = listener.next() orelse continue; +//! if (event.asKeyboard()) |k| { ... } else if (event.asMouse()) |m| { ... } +//! } + +const std = @import("std"); +const abi = @import("abi"); +const ipc = @import("ipc.zig"); +const system = @import("system.zig"); +const protocol = @import("input-protocol"); + +pub const DeviceKind = protocol.DeviceKind; +pub const InputEvent = protocol.InputEvent; +pub const KeyEvent = protocol.KeyEvent; +pub const MouseEvent = protocol.MouseEvent; +pub const JoystickEvent = protocol.JoystickEvent; +pub const EventKind = protocol.EventKind; +pub const MouseEventKind = protocol.MouseEventKind; +pub const JoystickEventKind = protocol.JoystickEventKind; +pub const Keycode = protocol.Keycode; + +/// Interest masks re-exported so a caller can `subscribe(input.device_keyboard | input.device_mouse)`. +pub const device_keyboard = protocol.device_keyboard; +pub const device_mouse = protocol.device_mouse; +pub const device_joystick = protocol.device_joystick; +pub const device_all = protocol.device_all; + +/// Look up the input service, retrying while it is still coming up. Both a subscriber and +/// a source race the service's registration at boot, so both wait for it here rather than +/// failing. Returns the service endpoint handle, or null if it never appears. +fn lookupService() ?ipc.Handle { + var attempts: usize = 0; + while (attempts < 100) : (attempts += 1) { + if (ipc.lookup(.input)) |handle| return handle; + system.sleep(50); + } + return null; +} + +// --- subscribing ------------------------------------------------------------ + +/// A subscription to the input service: our own endpoint, which the service pushes events +/// to. `next` returns each event as a tagged `InputEvent`; use `asKeyboard`/`asMouse`/ +/// `asJoystick` to decode. Created with `subscribe`/`subscribeAll`; for a single device +/// class prefer the typed helpers (`subscribeKeyboard`, ...), which return decoded events. +pub const Subscriber = struct { + /// The endpoint the service delivers events to (created and owned by us; its handle + /// was handed to the service as a capability at subscribe time). + endpoint: ipc.Handle, + receive: [protocol.event_size]u8 = undefined, + + /// Block until the next event is pushed, and return it. Events arrive as asynchronous + /// buffered messages (`ipc_send` from the service), so nothing is owed in reply — the + /// empty reply this issues is a harmless no-op. Returns null for any non-event wake-up + /// (there should be none), so callers can loop. + pub fn next(self: *Subscriber) ?InputEvent { + const got = ipc.replyWait(self.endpoint, &.{}, &self.receive, null); + if (!got.isMessage() or got.len < protocol.event_size) return null; + return std.mem.bytesToValue(InputEvent, self.receive[0..protocol.event_size]); + } +}; + +/// Subscribe to the input classes named in `device_mask` (an OR of `device_*`, or +/// `device_all`). Creates an endpoint for the service to push to and hands it over as a +/// capability. Returns a `Subscriber` to loop `next` on, or null on failure. +pub fn subscribe(device_mask: u32) ?Subscriber { + const service = lookupService() orelse return null; + const endpoint = ipc.createIpcEndpoint() orelse return null; + + var request = protocol.Request{ .operation = @intFromEnum(protocol.Operation.subscribe), .device_mask = device_mask }; + var reply: [protocol.reply_size]u8 = undefined; + const result = ipc.callCap(service, std.mem.asBytes(&request), &reply, endpoint) catch return null; + if (result.len < protocol.reply_size) return null; + if (std.mem.bytesToValue(protocol.Reply, reply[0..protocol.reply_size]).status != 0) return null; + return .{ .endpoint = endpoint }; +} + +/// Subscribe to every input class (keyboard, mouse, joystick) on one stream. +pub fn subscribeAll() ?Subscriber { + return subscribe(device_all); +} + +/// A subscriber filtered to keyboard events, whose `next` returns a decoded `KeyEvent`. +pub const KeyboardSubscriber = struct { + inner: Subscriber, + pub fn next(self: *KeyboardSubscriber) ?KeyEvent { + return (self.inner.next() orelse return null).asKeyboard(); + } +}; + +/// A subscriber filtered to mouse events, whose `next` returns a decoded `MouseEvent`. +pub const MouseSubscriber = struct { + inner: Subscriber, + pub fn next(self: *MouseSubscriber) ?MouseEvent { + return (self.inner.next() orelse return null).asMouse(); + } +}; + +/// A subscriber filtered to joystick/gamepad events, whose `next` returns a decoded +/// `JoystickEvent`. +pub const JoystickSubscriber = struct { + inner: Subscriber, + pub fn next(self: *JoystickSubscriber) ?JoystickEvent { + return (self.inner.next() orelse return null).asJoystick(); + } +}; + +/// Subscribe to keyboard events only; `next` returns decoded `KeyEvent`s. +pub fn subscribeKeyboard() ?KeyboardSubscriber { + return .{ .inner = subscribe(device_keyboard) orelse return null }; +} + +/// Subscribe to mouse events only; `next` returns decoded `MouseEvent`s. +pub fn subscribeMouse() ?MouseSubscriber { + return .{ .inner = subscribe(device_mouse) orelse return null }; +} + +/// Subscribe to joystick/gamepad events only; `next` returns decoded `JoystickEvent`s. +pub fn subscribeJoystick() ?JoystickSubscriber { + return .{ .inner = subscribe(device_joystick) orelse return null }; +} + +// --- publishing ------------------------------------------------------------- + +/// A connection to the input service for a source (a keyboard/mouse/joystick driver) that +/// publishes events. Each `publish*Event` is a short synchronous call the service answers +/// at once; its own fan-out to subscribers is asynchronous, so publishing never blocks on +/// a slow subscriber. +pub const Publisher = struct { + service: ipc.Handle, + + fn publish(self: Publisher, event: InputEvent) bool { + var request = protocol.Request{ .operation = @intFromEnum(protocol.Operation.publish), .event = event }; + var reply: [protocol.reply_size]u8 = undefined; + const len = ipc.call(self.service, std.mem.asBytes(&request), &reply) catch return false; + if (len < protocol.reply_size) return false; + return std.mem.bytesToValue(protocol.Reply, reply[0..protocol.reply_size]).status == 0; + } + + /// Broadcast a keyboard event to every subscriber that took keyboard events. + pub fn publishKeyboardEvent(self: Publisher, event: KeyEvent) bool { + return self.publish(InputEvent.fromKeyboard(event)); + } + /// Broadcast a mouse event to every subscriber that took mouse events. + pub fn publishMouseEvent(self: Publisher, event: MouseEvent) bool { + return self.publish(InputEvent.fromMouse(event)); + } + /// Broadcast a joystick/gamepad event to every subscriber that took joystick events. + pub fn publishJoystickEvent(self: Publisher, event: JoystickEvent) bool { + return self.publish(InputEvent.fromJoystick(event)); + } +}; + +/// Connect to the input service as an event source, waiting for it to come up. Returns a +/// `Publisher`, or null if the service never registered. +pub fn connectSource() ?Publisher { + return .{ .service = lookupService() orelse return null }; +} + +// --- synthetic scaffolding -------------------------------------------------- + +/// Synthetic key events, shared by the demo source and the keyboard driver's placeholder +/// stream while real scancode decoding is still a follow-up. `step` rolls through A..E, +/// emitting for each key a `key_down`, then a `key_press` carrying the character, then a +/// `key_up`. Scaffolding, not wire protocol — hence it lives with the helpers. +pub fn syntheticKeyEvent(step: usize) KeyEvent { + const Key = struct { code: Keycode, character: u32 }; + const keys = [_]Key{ + .{ .code = .a, .character = 'A' }, + .{ .code = .b, .character = 'B' }, + .{ .code = .c, .character = 'C' }, + .{ .code = .d, .character = 'D' }, + .{ .code = .e, .character = 'E' }, + }; + const key = keys[(step / 3) % keys.len]; + return switch (step % 3) { + 0 => .{ .kind = @intFromEnum(EventKind.key_down), .keycode = @intFromEnum(key.code), .character = 0, .modifiers = 0 }, + 1 => .{ .kind = @intFromEnum(EventKind.key_press), .keycode = @intFromEnum(key.code), .character = key.character, .modifiers = 0 }, + else => .{ .kind = @intFromEnum(EventKind.key_up), .keycode = @intFromEnum(key.code), .character = 0, .modifiers = 0 }, + }; +} + +/// Synthetic mouse events (placeholder until real PS/2 packet decoding). `step` alternates +/// a small diagonal motion with a left-button click. +pub fn syntheticMouseEvent(step: usize) MouseEvent { + return switch (step % 3) { + 0 => .{ .kind = @intFromEnum(MouseEventKind.motion), .button = 0, .dx = 1, .dy = 1, .scroll_x = 0, .scroll_y = 0, .buttons = 0 }, + 1 => .{ .kind = @intFromEnum(MouseEventKind.button_down), .button = protocol.mouse_button_left, .dx = 0, .dy = 0, .scroll_x = 0, .scroll_y = 0, .buttons = protocol.mouse_button_left }, + else => .{ .kind = @intFromEnum(MouseEventKind.button_up), .button = protocol.mouse_button_left, .dx = 0, .dy = 0, .scroll_x = 0, .scroll_y = 0, .buttons = 0 }, + }; +} + +/// Synthetic joystick/gamepad events (placeholder until a real controller driver). `step` +/// sweeps axis 0 and toggles button 0. +pub fn syntheticJoystickEvent(step: usize) JoystickEvent { + return switch (step % 3) { + 0 => .{ .kind = @intFromEnum(JoystickEventKind.axis), .control = 0, .value = 16384, .buttons = 0 }, + 1 => .{ .kind = @intFromEnum(JoystickEventKind.button_down), .control = 0, .value = 0, .buttons = 1 }, + else => .{ .kind = @intFromEnum(JoystickEventKind.button_up), .control = 0, .value = 0, .buttons = 0 }, + }; +} diff --git a/library/runtime/ipc.zig b/library/runtime/ipc.zig index b17f9ba..462fca7 100644 --- a/library/runtime/ipc.zig +++ b/library/runtime/ipc.zig @@ -79,6 +79,16 @@ pub fn call(h: Handle, message: []const u8, reply: []u8) CallError!usize { return (try callCap(h, message, reply, null)).len; } +/// Post `message` to endpoint `h`'s asynchronous queue and return immediately — no +/// rendezvous, no reply, no blocking. The receiver picks it up through `replyWait` as a +/// buffered message (`Received.isMessage`). Unlike `call`, this **cannot hang on a dead +/// or slow peer**, which is why a broadcaster (the input service) delivers events this +/// way. The payload must fit an endpoint slot (64 bytes); a full queue drops the oldest +/// message. Returns false on failure (bad handle, oversized payload, bad buffer). +pub fn send(h: Handle, message: []const u8) bool { + return !failed(sc.systemCall3(.ipc_send, h, @intFromPtr(message.ptr), message.len)); +} + /// Set in `Received.badge` when what arrived is an asynchronous notification — a /// bound device interrupt — rather than a client's message. The low bits carry the /// GSI. See `isNotification`. @@ -89,6 +99,12 @@ pub const notify_badge_bit: u64 = abi.notify_badge_bit; /// rather than a device interrupt. The low bits carry the child's process id. pub const notify_exit_bit: u64 = abi.notify_exit_bit; +/// Set alongside `notify_badge_bit` when the wake-up is a **buffered message** — a payload +/// posted with `send` (`ipc_send`) — rather than a bare device interrupt or child-exit +/// notice. The payload is in the `replyWait` receive buffer (`Received.len` bytes); the +/// low bits of the badge carry the sender's task id. See `Received.isMessage`. +pub const notify_message_bit: u64 = abi.notify_message_bit; + /// The result of a `replyWait`: the request length, the sender's badge (a task id, or /// an IRQ notification if the high bit is set), and any capability the request carried. pub const Received = struct { @@ -109,6 +125,19 @@ pub const Received = struct { return self.isNotification() and self.badge & notify_exit_bit != 0; } + /// True if this wake-up is a **buffered message** posted with `send` (`ipc_send`): + /// there is a payload in the receive buffer (`self.len` bytes) and no reply is owed. + /// The subscriber side of a broadcast branches on this. + pub fn isMessage(self: Received) bool { + return self.isNotification() and self.badge & notify_message_bit != 0; + } + + /// The task id of whoever posted a buffered message, meaningful only when + /// `isMessage`. (The badge's low bits, with the three high marker bits masked off.) + pub fn senderTaskId(self: Received) u32 { + return @intCast(self.badge & ~(notify_badge_bit | notify_exit_bit | notify_message_bit)); + } + /// The interrupt source (a GSI), meaningful only when `isNotification` and /// not `isChildExit`. pub fn source(self: Received) u64 { diff --git a/library/runtime/runtime.zig b/library/runtime/runtime.zig index bd36c91..b5e660a 100644 --- a/library/runtime/runtime.zig +++ b/library/runtime/runtime.zig @@ -17,6 +17,11 @@ pub const ipc = @import("ipc.zig"); pub const start = @import("start.zig"); /// The VFS wire protocol (shared with the VFS server). pub const vfs_protocol = @import("vfs-protocol"); +/// Keyboard-event listening (subscribe/next) and broadcasting (publish), over the input +/// service. See library/runtime/input.zig and system/services/input/. +pub const input = @import("input.zig"); +/// The input wire protocol (shared with the input service and its clients). +pub const input_protocol = @import("input-protocol"); /// POSIX-style file API: open/read/write/lseek/stat/close. /// C stdio: fopen/fread/fwrite/fseek/ftell/fclose over unistd. /// Device access for drivers: enumerate/claim/mmioMap. diff --git a/library/runtime/system.zig b/library/runtime/system.zig index 8561e9c..3b32a8e 100644 --- a/library/runtime/system.zig +++ b/library/runtime/system.zig @@ -2,6 +2,7 @@ //! stubs, one per kernel call. Numbers come from `abi.SystemCall`, the single //! source of truth shared with the kernel dispatcher. +const std = @import("std"); const abi = @import("abi"); const sc = @import("system-call.zig"); @@ -98,6 +99,16 @@ pub fn processes(out: []abi.ProcessDescriptor) usize { return sc.systemCall2(.process_enumerate, @intFromPtr(out.ptr), out.len); } +/// Whether a process spawned under `name` (its argv[0]) is currently alive. +pub fn isProcessRunning(name: []const u8) bool { + var table: [32]ProcessDescriptor = undefined; + const total = processes(&table); + for (table[0..@min(total, table.len)]) |descriptor| { + if (std.mem.eql(u8, descriptor.name[0..descriptor.name_length], name)) return true; + } + return false; +} + /// End process `id`. Only its supervisor — the process that spawned it — may; /// anyone else gets false, as does a stale or unknown id (ids are never reused). /// Delivery is prompt but asynchronous, like a signal: a target caught running on diff --git a/library/xkeyboard-config/README.md b/library/xkeyboard-config/README.md new file mode 100644 index 0000000..afc087b --- /dev/null +++ b/library/xkeyboard-config/README.md @@ -0,0 +1,65 @@ +# xkeyboard-config — X11 keyboard layouts, compiled to Zig + +This module turns a physical key (a **USB HID usage**, as the [input module](../../docs/input.md) +delivers in `KeyEvent.keycode`) plus a modifier state into a **keysym** and, when the key +produces one, a **character** (a Unicode scalar). It is what lets a `keycode` become a +`character` — a keymap — without danos shipping an X11 runtime. + +The layout data comes from the X11 [xkeyboard-config](https://gitlab.freedesktop.org/xkeyboard-config/xkeyboard-config) +database, but it is **compiled to native Zig at build time** rather than parsed at runtime. +`tools/make-xkeyboard-config.py` reads the vendored xkb data and emits pure-data tables into +`generated/layouts.zig`; `xkeyboard-config.zig` is the hand-written API over them. This is +the same build-time-codegen pattern as `tools/make-initial-ramdisk.py`. + +## Using it + +```zig +const xkb = @import("xkeyboard-config"); + +const m = xkb.map(xkb.us, key_event.keycode, .{ .shift = shift_held, .caps_lock = caps }); +if (m.character) |ch| { /* a printable Unicode scalar */ } +// m.keysym is always set (e.g. an X11 keysym for Return / F1 / a dead key). + +const layout = xkb.byName("gb") orelse xkb.us; // choose a layout by name +for (xkb.all) |l| { /* enumerate available layouts */ } +``` + +`Modifiers` carries `shift`, `caps_lock`, `level3` (AltGr), and `control`. `map` selects the +level from the key's XKB *type* (the generated data) and those modifiers (the policy, in +`xkeyboard-config.zig`), so data and semantics stay separable. + +Layouts: **us, gb, de, fr, es, dvorak**. + +## Regenerating + +```sh +python3 tools/make-xkeyboard-config.py fetch # network: download + vendor the data subset +python3 tools/make-xkeyboard-config.py generate # offline: emit generated/layouts.zig +# or, from the build: +zig build gen-xkeyboard-config +``` + +- **`fetch`** downloads the pinned xkeyboard-config release (version + sha256 in the script), + resolves the `include` graph for the configured layouts, and vendors *only* the symbols + files actually reached (plus `keysymdef.h`, `COPYING`, and `PROVENANCE.md`) into `vendor/`. + Run it when bumping the version or adding a layout. +- **`generate`** is deterministic and offline — same vendored input produces byte-identical + output. To add a layout, extend `TARGETS` (and `HID_TO_NAME` if a new physical key is + involved), then re-run `fetch` (to vendor any new includes) and `generate`. + +## Scope + +A pragmatic subset, enough for real Latin-script typing: + +- **Group 1 only** — no multi-layout group switching. +- **No dead-key / compose composition** — a dead key returns its keysym with no `character` + (composing `´` + `e` → `é` is a higher layer's job). +- **Curated key types** — the common XKB types (one/two-level, alphabetic, four-level, …); + unmapped keys and unknown types fall back to level-by-shift. +- **6 layouts** — extend via `TARGETS` as above. + +## Licensing + +xkeyboard-config and `keysymdef.h` (xorgproto) are MIT/X11 licensed. The vendored data +subset carries the upstream `vendor/COPYING`, and `vendor/PROVENANCE.md` records the exact +version, source URL, and sha256. The generated tables are a derived work under the same terms. diff --git a/library/xkeyboard-config/generated/layouts.zig b/library/xkeyboard-config/generated/layouts.zig new file mode 100644 index 0000000..ac44069 --- /dev/null +++ b/library/xkeyboard-config/generated/layouts.zig @@ -0,0 +1,1594 @@ +// GENERATED by tools/make-xkeyboard-config.py from xkeyboard-config 2.44. Do not edit. +// Keyboard layout tables compiled from the X11 xkeyboard-config database +// (MIT/X11 licensed; see ../vendor/COPYING and ../vendor/PROVENANCE.md). + +pub const Level = struct { keysym: u32 = 0, unicode: u21 = 0 }; + +pub const KeyType = enum { + one_level, + two_level, + alphabetic, + four_level, + four_level_alphabetic, + four_level_semialphabetic, + keypad, + other, +}; + +pub const Key = struct { kind: KeyType = .one_level, levels: [4]Level = [_]Level{.{}} ** 4 }; + +pub const Layout = struct { name: []const u8, keys: [256]Key }; + +pub const us: Layout = .{ + .name = "us", + .keys = .{ + .{}, + .{}, + .{}, + .{}, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 97, .unicode = 97 }, .{ .keysym = 65, .unicode = 65 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 98, .unicode = 98 }, .{ .keysym = 66, .unicode = 66 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 99, .unicode = 99 }, .{ .keysym = 67, .unicode = 67 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 100, .unicode = 100 }, .{ .keysym = 68, .unicode = 68 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 101, .unicode = 101 }, .{ .keysym = 69, .unicode = 69 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 102, .unicode = 102 }, .{ .keysym = 70, .unicode = 70 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 103, .unicode = 103 }, .{ .keysym = 71, .unicode = 71 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 104, .unicode = 104 }, .{ .keysym = 72, .unicode = 72 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 105, .unicode = 105 }, .{ .keysym = 73, .unicode = 73 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 106, .unicode = 106 }, .{ .keysym = 74, .unicode = 74 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 107, .unicode = 107 }, .{ .keysym = 75, .unicode = 75 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 108, .unicode = 108 }, .{ .keysym = 76, .unicode = 76 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 109, .unicode = 109 }, .{ .keysym = 77, .unicode = 77 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 110, .unicode = 110 }, .{ .keysym = 78, .unicode = 78 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 111, .unicode = 111 }, .{ .keysym = 79, .unicode = 79 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 112, .unicode = 112 }, .{ .keysym = 80, .unicode = 80 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 113, .unicode = 113 }, .{ .keysym = 81, .unicode = 81 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 114, .unicode = 114 }, .{ .keysym = 82, .unicode = 82 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 115, .unicode = 115 }, .{ .keysym = 83, .unicode = 83 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 116, .unicode = 116 }, .{ .keysym = 84, .unicode = 84 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 117, .unicode = 117 }, .{ .keysym = 85, .unicode = 85 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 118, .unicode = 118 }, .{ .keysym = 86, .unicode = 86 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 119, .unicode = 119 }, .{ .keysym = 87, .unicode = 87 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 120, .unicode = 120 }, .{ .keysym = 88, .unicode = 88 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 121, .unicode = 121 }, .{ .keysym = 89, .unicode = 89 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 122, .unicode = 122 }, .{ .keysym = 90, .unicode = 90 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 49, .unicode = 49 }, .{ .keysym = 33, .unicode = 33 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 50, .unicode = 50 }, .{ .keysym = 64, .unicode = 64 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 51, .unicode = 51 }, .{ .keysym = 35, .unicode = 35 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 52, .unicode = 52 }, .{ .keysym = 36, .unicode = 36 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 53, .unicode = 53 }, .{ .keysym = 37, .unicode = 37 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 54, .unicode = 54 }, .{ .keysym = 94, .unicode = 94 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 55, .unicode = 55 }, .{ .keysym = 38, .unicode = 38 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 56, .unicode = 56 }, .{ .keysym = 42, .unicode = 42 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 57, .unicode = 57 }, .{ .keysym = 40, .unicode = 40 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 48, .unicode = 48 }, .{ .keysym = 41, .unicode = 41 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{}, + .{}, + .{}, + .{}, + .{}, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 45, .unicode = 45 }, .{ .keysym = 95, .unicode = 95 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 61, .unicode = 61 }, .{ .keysym = 43, .unicode = 43 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 91, .unicode = 91 }, .{ .keysym = 123, .unicode = 123 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 93, .unicode = 93 }, .{ .keysym = 125, .unicode = 125 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 92, .unicode = 92 }, .{ .keysym = 124, .unicode = 124 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{}, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 59, .unicode = 59 }, .{ .keysym = 58, .unicode = 58 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 39, .unicode = 39 }, .{ .keysym = 34, .unicode = 34 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 96, .unicode = 96 }, .{ .keysym = 126, .unicode = 126 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 44, .unicode = 44 }, .{ .keysym = 60, .unicode = 60 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 46, .unicode = 46 }, .{ .keysym = 62, .unicode = 62 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 47, .unicode = 47 }, .{ .keysym = 63, .unicode = 63 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + }, +}; + +pub const gb: Layout = .{ + .name = "gb", + .keys = .{ + .{}, + .{}, + .{}, + .{}, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 97, .unicode = 97 }, .{ .keysym = 65, .unicode = 65 }, .{ .keysym = 230, .unicode = 230 }, .{ .keysym = 198, .unicode = 198 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 98, .unicode = 98 }, .{ .keysym = 66, .unicode = 66 }, .{ .keysym = 2770, .unicode = 8220 }, .{ .keysym = 2768, .unicode = 8216 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 99, .unicode = 99 }, .{ .keysym = 67, .unicode = 67 }, .{ .keysym = 162, .unicode = 162 }, .{ .keysym = 169, .unicode = 169 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 100, .unicode = 100 }, .{ .keysym = 68, .unicode = 68 }, .{ .keysym = 240, .unicode = 240 }, .{ .keysym = 208, .unicode = 208 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 101, .unicode = 101 }, .{ .keysym = 69, .unicode = 69 }, .{ .keysym = 101, .unicode = 101 }, .{ .keysym = 69, .unicode = 69 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 102, .unicode = 102 }, .{ .keysym = 70, .unicode = 70 }, .{ .keysym = 496, .unicode = 273 }, .{ .keysym = 170, .unicode = 170 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 103, .unicode = 103 }, .{ .keysym = 71, .unicode = 71 }, .{ .keysym = 959, .unicode = 331 }, .{ .keysym = 957, .unicode = 330 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 104, .unicode = 104 }, .{ .keysym = 72, .unicode = 72 }, .{ .keysym = 689, .unicode = 295 }, .{ .keysym = 673, .unicode = 294 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 105, .unicode = 105 }, .{ .keysym = 73, .unicode = 73 }, .{ .keysym = 2301, .unicode = 8594 }, .{ .keysym = 697, .unicode = 305 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 106, .unicode = 106 }, .{ .keysym = 74, .unicode = 74 }, .{ .keysym = 65121, .unicode = 0 }, .{ .keysym = 65122, .unicode = 0 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 107, .unicode = 107 }, .{ .keysym = 75, .unicode = 75 }, .{ .keysym = 930, .unicode = 312 }, .{ .keysym = 38, .unicode = 38 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 108, .unicode = 108 }, .{ .keysym = 76, .unicode = 76 }, .{ .keysym = 435, .unicode = 322 }, .{ .keysym = 419, .unicode = 321 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 109, .unicode = 109 }, .{ .keysym = 77, .unicode = 77 }, .{ .keysym = 181, .unicode = 181 }, .{ .keysym = 186, .unicode = 0 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 110, .unicode = 110 }, .{ .keysym = 78, .unicode = 78 }, .{ .keysym = 2771, .unicode = 8221 }, .{ .keysym = 2769, .unicode = 8217 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 111, .unicode = 111 }, .{ .keysym = 79, .unicode = 79 }, .{ .keysym = 248, .unicode = 248 }, .{ .keysym = 216, .unicode = 216 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 112, .unicode = 112 }, .{ .keysym = 80, .unicode = 80 }, .{ .keysym = 254, .unicode = 254 }, .{ .keysym = 222, .unicode = 222 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 113, .unicode = 113 }, .{ .keysym = 81, .unicode = 81 }, .{ .keysym = 64, .unicode = 64 }, .{ .keysym = 2009, .unicode = 937 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 114, .unicode = 114 }, .{ .keysym = 82, .unicode = 82 }, .{ .keysym = 182, .unicode = 182 }, .{ .keysym = 174, .unicode = 174 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 115, .unicode = 115 }, .{ .keysym = 83, .unicode = 83 }, .{ .keysym = 223, .unicode = 223 }, .{ .keysym = 16785054, .unicode = 7838 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 116, .unicode = 116 }, .{ .keysym = 84, .unicode = 84 }, .{ .keysym = 956, .unicode = 359 }, .{ .keysym = 940, .unicode = 358 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 117, .unicode = 117 }, .{ .keysym = 85, .unicode = 85 }, .{ .keysym = 2302, .unicode = 8595 }, .{ .keysym = 2300, .unicode = 8593 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 118, .unicode = 118 }, .{ .keysym = 86, .unicode = 86 }, .{ .keysym = 2814, .unicode = 8222 }, .{ .keysym = 2813, .unicode = 8218 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 119, .unicode = 119 }, .{ .keysym = 87, .unicode = 87 }, .{ .keysym = 16777599, .unicode = 383 }, .{ .keysym = 167, .unicode = 167 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 120, .unicode = 120 }, .{ .keysym = 88, .unicode = 88 }, .{ .keysym = 187, .unicode = 0 }, .{ .keysym = 62, .unicode = 62 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 121, .unicode = 121 }, .{ .keysym = 89, .unicode = 89 }, .{ .keysym = 2299, .unicode = 8592 }, .{ .keysym = 165, .unicode = 165 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 122, .unicode = 122 }, .{ .keysym = 90, .unicode = 90 }, .{ .keysym = 171, .unicode = 0 }, .{ .keysym = 60, .unicode = 60 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 49, .unicode = 49 }, .{ .keysym = 33, .unicode = 33 }, .{ .keysym = 185, .unicode = 185 }, .{ .keysym = 161, .unicode = 161 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 50, .unicode = 50 }, .{ .keysym = 34, .unicode = 34 }, .{ .keysym = 178, .unicode = 178 }, .{ .keysym = 2755, .unicode = 8539 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 51, .unicode = 51 }, .{ .keysym = 163, .unicode = 163 }, .{ .keysym = 179, .unicode = 179 }, .{ .keysym = 163, .unicode = 163 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 52, .unicode = 52 }, .{ .keysym = 36, .unicode = 36 }, .{ .keysym = 8364, .unicode = 8364 }, .{ .keysym = 188, .unicode = 188 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 53, .unicode = 53 }, .{ .keysym = 37, .unicode = 37 }, .{ .keysym = 189, .unicode = 189 }, .{ .keysym = 2756, .unicode = 8540 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 54, .unicode = 54 }, .{ .keysym = 94, .unicode = 94 }, .{ .keysym = 190, .unicode = 190 }, .{ .keysym = 2757, .unicode = 8541 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 55, .unicode = 55 }, .{ .keysym = 38, .unicode = 38 }, .{ .keysym = 123, .unicode = 123 }, .{ .keysym = 2758, .unicode = 8542 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 56, .unicode = 56 }, .{ .keysym = 42, .unicode = 42 }, .{ .keysym = 91, .unicode = 91 }, .{ .keysym = 2761, .unicode = 8482 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 57, .unicode = 57 }, .{ .keysym = 40, .unicode = 40 }, .{ .keysym = 93, .unicode = 93 }, .{ .keysym = 177, .unicode = 177 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 48, .unicode = 48 }, .{ .keysym = 41, .unicode = 41 }, .{ .keysym = 125, .unicode = 125 }, .{ .keysym = 176, .unicode = 176 } } }, + .{}, + .{}, + .{}, + .{}, + .{}, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 45, .unicode = 45 }, .{ .keysym = 95, .unicode = 95 }, .{ .keysym = 92, .unicode = 92 }, .{ .keysym = 191, .unicode = 191 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 61, .unicode = 61 }, .{ .keysym = 43, .unicode = 43 }, .{ .keysym = 65115, .unicode = 0 }, .{ .keysym = 65116, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 91, .unicode = 91 }, .{ .keysym = 123, .unicode = 123 }, .{ .keysym = 65111, .unicode = 0 }, .{ .keysym = 65112, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 93, .unicode = 93 }, .{ .keysym = 125, .unicode = 125 }, .{ .keysym = 65107, .unicode = 0 }, .{ .keysym = 65108, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 35, .unicode = 35 }, .{ .keysym = 126, .unicode = 126 }, .{ .keysym = 65104, .unicode = 0 }, .{ .keysym = 65109, .unicode = 0 } } }, + .{}, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 59, .unicode = 59 }, .{ .keysym = 58, .unicode = 58 }, .{ .keysym = 65105, .unicode = 0 }, .{ .keysym = 65113, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 39, .unicode = 39 }, .{ .keysym = 64, .unicode = 64 }, .{ .keysym = 65106, .unicode = 0 }, .{ .keysym = 65114, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 96, .unicode = 96 }, .{ .keysym = 172, .unicode = 172 }, .{ .keysym = 124, .unicode = 124 }, .{ .keysym = 124, .unicode = 124 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 44, .unicode = 44 }, .{ .keysym = 60, .unicode = 60 }, .{ .keysym = 16785442, .unicode = 8226 }, .{ .keysym = 215, .unicode = 215 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 46, .unicode = 46 }, .{ .keysym = 62, .unicode = 62 }, .{ .keysym = 183, .unicode = 183 }, .{ .keysym = 247, .unicode = 247 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 47, .unicode = 47 }, .{ .keysym = 63, .unicode = 63 }, .{ .keysym = 65120, .unicode = 0 }, .{ .keysym = 65110, .unicode = 0 } } }, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 92, .unicode = 92 }, .{ .keysym = 124, .unicode = 124 }, .{ .keysym = 124, .unicode = 124 }, .{ .keysym = 166, .unicode = 166 } } }, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + }, +}; + +pub const de: Layout = .{ + .name = "de", + .keys = .{ + .{}, + .{}, + .{}, + .{}, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 97, .unicode = 97 }, .{ .keysym = 65, .unicode = 65 }, .{ .keysym = 230, .unicode = 230 }, .{ .keysym = 198, .unicode = 198 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 98, .unicode = 98 }, .{ .keysym = 66, .unicode = 66 }, .{ .keysym = 2770, .unicode = 8220 }, .{ .keysym = 2768, .unicode = 8216 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 99, .unicode = 99 }, .{ .keysym = 67, .unicode = 67 }, .{ .keysym = 162, .unicode = 162 }, .{ .keysym = 169, .unicode = 169 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 100, .unicode = 100 }, .{ .keysym = 68, .unicode = 68 }, .{ .keysym = 240, .unicode = 240 }, .{ .keysym = 208, .unicode = 208 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 101, .unicode = 101 }, .{ .keysym = 69, .unicode = 69 }, .{ .keysym = 8364, .unicode = 8364 }, .{ .keysym = 8364, .unicode = 8364 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 102, .unicode = 102 }, .{ .keysym = 70, .unicode = 70 }, .{ .keysym = 496, .unicode = 273 }, .{ .keysym = 170, .unicode = 170 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 103, .unicode = 103 }, .{ .keysym = 71, .unicode = 71 }, .{ .keysym = 959, .unicode = 331 }, .{ .keysym = 957, .unicode = 330 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 104, .unicode = 104 }, .{ .keysym = 72, .unicode = 72 }, .{ .keysym = 689, .unicode = 295 }, .{ .keysym = 673, .unicode = 294 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 105, .unicode = 105 }, .{ .keysym = 73, .unicode = 73 }, .{ .keysym = 2301, .unicode = 8594 }, .{ .keysym = 697, .unicode = 305 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 106, .unicode = 106 }, .{ .keysym = 74, .unicode = 74 }, .{ .keysym = 65120, .unicode = 0 }, .{ .keysym = 65110, .unicode = 0 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 107, .unicode = 107 }, .{ .keysym = 75, .unicode = 75 }, .{ .keysym = 930, .unicode = 312 }, .{ .keysym = 38, .unicode = 38 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 108, .unicode = 108 }, .{ .keysym = 76, .unicode = 76 }, .{ .keysym = 435, .unicode = 322 }, .{ .keysym = 419, .unicode = 321 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 109, .unicode = 109 }, .{ .keysym = 77, .unicode = 77 }, .{ .keysym = 181, .unicode = 181 }, .{ .keysym = 186, .unicode = 0 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 110, .unicode = 110 }, .{ .keysym = 78, .unicode = 78 }, .{ .keysym = 2771, .unicode = 8221 }, .{ .keysym = 2769, .unicode = 8217 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 111, .unicode = 111 }, .{ .keysym = 79, .unicode = 79 }, .{ .keysym = 248, .unicode = 248 }, .{ .keysym = 216, .unicode = 216 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 112, .unicode = 112 }, .{ .keysym = 80, .unicode = 80 }, .{ .keysym = 254, .unicode = 254 }, .{ .keysym = 222, .unicode = 222 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 113, .unicode = 113 }, .{ .keysym = 81, .unicode = 81 }, .{ .keysym = 64, .unicode = 64 }, .{ .keysym = 2009, .unicode = 937 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 114, .unicode = 114 }, .{ .keysym = 82, .unicode = 82 }, .{ .keysym = 182, .unicode = 182 }, .{ .keysym = 174, .unicode = 174 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 115, .unicode = 115 }, .{ .keysym = 83, .unicode = 83 }, .{ .keysym = 16777599, .unicode = 383 }, .{ .keysym = 16785054, .unicode = 7838 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 116, .unicode = 116 }, .{ .keysym = 84, .unicode = 84 }, .{ .keysym = 956, .unicode = 359 }, .{ .keysym = 940, .unicode = 358 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 117, .unicode = 117 }, .{ .keysym = 85, .unicode = 85 }, .{ .keysym = 2302, .unicode = 8595 }, .{ .keysym = 2300, .unicode = 8593 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 118, .unicode = 118 }, .{ .keysym = 86, .unicode = 86 }, .{ .keysym = 2814, .unicode = 8222 }, .{ .keysym = 2813, .unicode = 8218 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 119, .unicode = 119 }, .{ .keysym = 87, .unicode = 87 }, .{ .keysym = 16777599, .unicode = 383 }, .{ .keysym = 167, .unicode = 167 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 120, .unicode = 120 }, .{ .keysym = 88, .unicode = 88 }, .{ .keysym = 171, .unicode = 0 }, .{ .keysym = 16785465, .unicode = 8249 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 122, .unicode = 122 }, .{ .keysym = 90, .unicode = 90 }, .{ .keysym = 2299, .unicode = 8592 }, .{ .keysym = 165, .unicode = 165 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 121, .unicode = 121 }, .{ .keysym = 89, .unicode = 89 }, .{ .keysym = 187, .unicode = 0 }, .{ .keysym = 16785466, .unicode = 8250 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 49, .unicode = 49 }, .{ .keysym = 33, .unicode = 33 }, .{ .keysym = 185, .unicode = 185 }, .{ .keysym = 161, .unicode = 161 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 50, .unicode = 50 }, .{ .keysym = 34, .unicode = 34 }, .{ .keysym = 178, .unicode = 178 }, .{ .keysym = 2755, .unicode = 8539 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 51, .unicode = 51 }, .{ .keysym = 167, .unicode = 167 }, .{ .keysym = 179, .unicode = 179 }, .{ .keysym = 163, .unicode = 163 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 52, .unicode = 52 }, .{ .keysym = 36, .unicode = 36 }, .{ .keysym = 188, .unicode = 188 }, .{ .keysym = 164, .unicode = 164 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 53, .unicode = 53 }, .{ .keysym = 37, .unicode = 37 }, .{ .keysym = 189, .unicode = 189 }, .{ .keysym = 2756, .unicode = 8540 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 54, .unicode = 54 }, .{ .keysym = 38, .unicode = 38 }, .{ .keysym = 172, .unicode = 172 }, .{ .keysym = 2757, .unicode = 8541 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 55, .unicode = 55 }, .{ .keysym = 47, .unicode = 47 }, .{ .keysym = 123, .unicode = 123 }, .{ .keysym = 2758, .unicode = 8542 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 56, .unicode = 56 }, .{ .keysym = 40, .unicode = 40 }, .{ .keysym = 91, .unicode = 91 }, .{ .keysym = 2761, .unicode = 8482 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 57, .unicode = 57 }, .{ .keysym = 41, .unicode = 41 }, .{ .keysym = 93, .unicode = 93 }, .{ .keysym = 177, .unicode = 177 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 48, .unicode = 48 }, .{ .keysym = 61, .unicode = 61 }, .{ .keysym = 125, .unicode = 125 }, .{ .keysym = 176, .unicode = 176 } } }, + .{}, + .{}, + .{}, + .{}, + .{}, + .{ .kind = .other, .levels = .{ .{ .keysym = 223, .unicode = 223 }, .{ .keysym = 63, .unicode = 63 }, .{ .keysym = 92, .unicode = 92 }, .{ .keysym = 191, .unicode = 191 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 65105, .unicode = 0 }, .{ .keysym = 65104, .unicode = 0 }, .{ .keysym = 65115, .unicode = 0 }, .{ .keysym = 65116, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 252, .unicode = 252 }, .{ .keysym = 220, .unicode = 220 }, .{ .keysym = 65111, .unicode = 0 }, .{ .keysym = 65112, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 43, .unicode = 43 }, .{ .keysym = 42, .unicode = 42 }, .{ .keysym = 126, .unicode = 126 }, .{ .keysym = 175, .unicode = 175 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 35, .unicode = 35 }, .{ .keysym = 39, .unicode = 39 }, .{ .keysym = 2769, .unicode = 8217 }, .{ .keysym = 65109, .unicode = 0 } } }, + .{}, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 246, .unicode = 246 }, .{ .keysym = 214, .unicode = 214 }, .{ .keysym = 65113, .unicode = 0 }, .{ .keysym = 65120, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 228, .unicode = 228 }, .{ .keysym = 196, .unicode = 196 }, .{ .keysym = 65106, .unicode = 0 }, .{ .keysym = 65114, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 65106, .unicode = 0 }, .{ .keysym = 176, .unicode = 176 }, .{ .keysym = 16785458, .unicode = 8242 }, .{ .keysym = 16785459, .unicode = 8243 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 44, .unicode = 44 }, .{ .keysym = 59, .unicode = 59 }, .{ .keysym = 183, .unicode = 183 }, .{ .keysym = 215, .unicode = 215 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 46, .unicode = 46 }, .{ .keysym = 58, .unicode = 58 }, .{ .keysym = 16785446, .unicode = 8230 }, .{ .keysym = 247, .unicode = 247 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 45, .unicode = 45 }, .{ .keysym = 95, .unicode = 95 }, .{ .keysym = 2730, .unicode = 8211 }, .{ .keysym = 2729, .unicode = 8212 } } }, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 60, .unicode = 60 }, .{ .keysym = 62, .unicode = 62 }, .{ .keysym = 124, .unicode = 124 }, .{ .keysym = 65128, .unicode = 0 } } }, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + }, +}; + +pub const fr: Layout = .{ + .name = "fr", + .keys = .{ + .{}, + .{}, + .{}, + .{}, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 113, .unicode = 113 }, .{ .keysym = 81, .unicode = 81 }, .{ .keysym = 64, .unicode = 64 }, .{ .keysym = 2009, .unicode = 937 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 98, .unicode = 98 }, .{ .keysym = 66, .unicode = 66 }, .{ .keysym = 2770, .unicode = 8220 }, .{ .keysym = 2768, .unicode = 8216 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 99, .unicode = 99 }, .{ .keysym = 67, .unicode = 67 }, .{ .keysym = 162, .unicode = 162 }, .{ .keysym = 169, .unicode = 169 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 100, .unicode = 100 }, .{ .keysym = 68, .unicode = 68 }, .{ .keysym = 240, .unicode = 240 }, .{ .keysym = 208, .unicode = 208 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 101, .unicode = 101 }, .{ .keysym = 69, .unicode = 69 }, .{ .keysym = 8364, .unicode = 8364 }, .{ .keysym = 162, .unicode = 162 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 102, .unicode = 102 }, .{ .keysym = 70, .unicode = 70 }, .{ .keysym = 496, .unicode = 273 }, .{ .keysym = 170, .unicode = 170 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 103, .unicode = 103 }, .{ .keysym = 71, .unicode = 71 }, .{ .keysym = 959, .unicode = 331 }, .{ .keysym = 957, .unicode = 330 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 104, .unicode = 104 }, .{ .keysym = 72, .unicode = 72 }, .{ .keysym = 689, .unicode = 295 }, .{ .keysym = 673, .unicode = 294 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 105, .unicode = 105 }, .{ .keysym = 73, .unicode = 73 }, .{ .keysym = 2301, .unicode = 8594 }, .{ .keysym = 697, .unicode = 305 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 106, .unicode = 106 }, .{ .keysym = 74, .unicode = 74 }, .{ .keysym = 65121, .unicode = 0 }, .{ .keysym = 65122, .unicode = 0 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 107, .unicode = 107 }, .{ .keysym = 75, .unicode = 75 }, .{ .keysym = 930, .unicode = 312 }, .{ .keysym = 38, .unicode = 38 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 108, .unicode = 108 }, .{ .keysym = 76, .unicode = 76 }, .{ .keysym = 435, .unicode = 322 }, .{ .keysym = 419, .unicode = 321 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 44, .unicode = 44 }, .{ .keysym = 63, .unicode = 63 }, .{ .keysym = 65105, .unicode = 0 }, .{ .keysym = 65113, .unicode = 0 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 110, .unicode = 110 }, .{ .keysym = 78, .unicode = 78 }, .{ .keysym = 2771, .unicode = 8221 }, .{ .keysym = 2769, .unicode = 8217 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 111, .unicode = 111 }, .{ .keysym = 79, .unicode = 79 }, .{ .keysym = 248, .unicode = 248 }, .{ .keysym = 216, .unicode = 216 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 112, .unicode = 112 }, .{ .keysym = 80, .unicode = 80 }, .{ .keysym = 254, .unicode = 254 }, .{ .keysym = 222, .unicode = 222 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 97, .unicode = 97 }, .{ .keysym = 65, .unicode = 65 }, .{ .keysym = 230, .unicode = 230 }, .{ .keysym = 198, .unicode = 198 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 114, .unicode = 114 }, .{ .keysym = 82, .unicode = 82 }, .{ .keysym = 182, .unicode = 182 }, .{ .keysym = 174, .unicode = 174 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 115, .unicode = 115 }, .{ .keysym = 83, .unicode = 83 }, .{ .keysym = 223, .unicode = 223 }, .{ .keysym = 16785054, .unicode = 7838 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 116, .unicode = 116 }, .{ .keysym = 84, .unicode = 84 }, .{ .keysym = 956, .unicode = 359 }, .{ .keysym = 940, .unicode = 358 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 117, .unicode = 117 }, .{ .keysym = 85, .unicode = 85 }, .{ .keysym = 2302, .unicode = 8595 }, .{ .keysym = 2300, .unicode = 8593 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 118, .unicode = 118 }, .{ .keysym = 86, .unicode = 86 }, .{ .keysym = 2814, .unicode = 8222 }, .{ .keysym = 2813, .unicode = 8218 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 122, .unicode = 122 }, .{ .keysym = 90, .unicode = 90 }, .{ .keysym = 171, .unicode = 0 }, .{ .keysym = 60, .unicode = 60 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 120, .unicode = 120 }, .{ .keysym = 88, .unicode = 88 }, .{ .keysym = 187, .unicode = 0 }, .{ .keysym = 62, .unicode = 62 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 121, .unicode = 121 }, .{ .keysym = 89, .unicode = 89 }, .{ .keysym = 2299, .unicode = 8592 }, .{ .keysym = 165, .unicode = 165 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 119, .unicode = 119 }, .{ .keysym = 87, .unicode = 87 }, .{ .keysym = 435, .unicode = 322 }, .{ .keysym = 419, .unicode = 321 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 38, .unicode = 38 }, .{ .keysym = 49, .unicode = 49 }, .{ .keysym = 185, .unicode = 185 }, .{ .keysym = 161, .unicode = 161 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 233, .unicode = 233 }, .{ .keysym = 50, .unicode = 50 }, .{ .keysym = 126, .unicode = 126 }, .{ .keysym = 2755, .unicode = 8539 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 34, .unicode = 34 }, .{ .keysym = 51, .unicode = 51 }, .{ .keysym = 35, .unicode = 35 }, .{ .keysym = 163, .unicode = 163 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 39, .unicode = 39 }, .{ .keysym = 52, .unicode = 52 }, .{ .keysym = 123, .unicode = 123 }, .{ .keysym = 36, .unicode = 36 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 40, .unicode = 40 }, .{ .keysym = 53, .unicode = 53 }, .{ .keysym = 91, .unicode = 91 }, .{ .keysym = 2756, .unicode = 8540 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 45, .unicode = 45 }, .{ .keysym = 54, .unicode = 54 }, .{ .keysym = 124, .unicode = 124 }, .{ .keysym = 2757, .unicode = 8541 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 232, .unicode = 232 }, .{ .keysym = 55, .unicode = 55 }, .{ .keysym = 96, .unicode = 96 }, .{ .keysym = 2758, .unicode = 8542 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 95, .unicode = 95 }, .{ .keysym = 56, .unicode = 56 }, .{ .keysym = 92, .unicode = 92 }, .{ .keysym = 2761, .unicode = 8482 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 231, .unicode = 231 }, .{ .keysym = 57, .unicode = 57 }, .{ .keysym = 94, .unicode = 94 }, .{ .keysym = 177, .unicode = 177 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 224, .unicode = 224 }, .{ .keysym = 48, .unicode = 48 }, .{ .keysym = 64, .unicode = 64 }, .{ .keysym = 176, .unicode = 176 } } }, + .{}, + .{}, + .{}, + .{}, + .{}, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 41, .unicode = 41 }, .{ .keysym = 176, .unicode = 176 }, .{ .keysym = 93, .unicode = 93 }, .{ .keysym = 191, .unicode = 191 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 61, .unicode = 61 }, .{ .keysym = 43, .unicode = 43 }, .{ .keysym = 125, .unicode = 125 }, .{ .keysym = 65116, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 65106, .unicode = 0 }, .{ .keysym = 65111, .unicode = 0 }, .{ .keysym = 65111, .unicode = 0 }, .{ .keysym = 65112, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 36, .unicode = 36 }, .{ .keysym = 163, .unicode = 163 }, .{ .keysym = 164, .unicode = 164 }, .{ .keysym = 65108, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 42, .unicode = 42 }, .{ .keysym = 181, .unicode = 181 }, .{ .keysym = 65104, .unicode = 0 }, .{ .keysym = 65109, .unicode = 0 } } }, + .{}, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 109, .unicode = 109 }, .{ .keysym = 77, .unicode = 77 }, .{ .keysym = 181, .unicode = 181 }, .{ .keysym = 186, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 249, .unicode = 249 }, .{ .keysym = 37, .unicode = 37 }, .{ .keysym = 65106, .unicode = 0 }, .{ .keysym = 65114, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 178, .unicode = 178 }, .{ .keysym = 126, .unicode = 126 }, .{ .keysym = 172, .unicode = 172 }, .{ .keysym = 172, .unicode = 172 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 59, .unicode = 59 }, .{ .keysym = 46, .unicode = 46 }, .{ .keysym = 16785442, .unicode = 8226 }, .{ .keysym = 215, .unicode = 215 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 58, .unicode = 58 }, .{ .keysym = 47, .unicode = 47 }, .{ .keysym = 183, .unicode = 183 }, .{ .keysym = 247, .unicode = 247 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 33, .unicode = 33 }, .{ .keysym = 167, .unicode = 167 }, .{ .keysym = 65120, .unicode = 0 }, .{ .keysym = 65110, .unicode = 0 } } }, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + }, +}; + +pub const es: Layout = .{ + .name = "es", + .keys = .{ + .{}, + .{}, + .{}, + .{}, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 97, .unicode = 97 }, .{ .keysym = 65, .unicode = 65 }, .{ .keysym = 230, .unicode = 230 }, .{ .keysym = 198, .unicode = 198 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 98, .unicode = 98 }, .{ .keysym = 66, .unicode = 66 }, .{ .keysym = 2770, .unicode = 8220 }, .{ .keysym = 2768, .unicode = 8216 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 99, .unicode = 99 }, .{ .keysym = 67, .unicode = 67 }, .{ .keysym = 162, .unicode = 162 }, .{ .keysym = 169, .unicode = 169 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 100, .unicode = 100 }, .{ .keysym = 68, .unicode = 68 }, .{ .keysym = 240, .unicode = 240 }, .{ .keysym = 208, .unicode = 208 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 101, .unicode = 101 }, .{ .keysym = 69, .unicode = 69 }, .{ .keysym = 8364, .unicode = 8364 }, .{ .keysym = 162, .unicode = 162 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 102, .unicode = 102 }, .{ .keysym = 70, .unicode = 70 }, .{ .keysym = 496, .unicode = 273 }, .{ .keysym = 170, .unicode = 170 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 103, .unicode = 103 }, .{ .keysym = 71, .unicode = 71 }, .{ .keysym = 959, .unicode = 331 }, .{ .keysym = 957, .unicode = 330 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 104, .unicode = 104 }, .{ .keysym = 72, .unicode = 72 }, .{ .keysym = 689, .unicode = 295 }, .{ .keysym = 673, .unicode = 294 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 105, .unicode = 105 }, .{ .keysym = 73, .unicode = 73 }, .{ .keysym = 2301, .unicode = 8594 }, .{ .keysym = 697, .unicode = 305 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 106, .unicode = 106 }, .{ .keysym = 74, .unicode = 74 }, .{ .keysym = 65121, .unicode = 0 }, .{ .keysym = 65122, .unicode = 0 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 107, .unicode = 107 }, .{ .keysym = 75, .unicode = 75 }, .{ .keysym = 930, .unicode = 312 }, .{ .keysym = 38, .unicode = 38 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 108, .unicode = 108 }, .{ .keysym = 76, .unicode = 76 }, .{ .keysym = 435, .unicode = 322 }, .{ .keysym = 419, .unicode = 321 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 109, .unicode = 109 }, .{ .keysym = 77, .unicode = 77 }, .{ .keysym = 181, .unicode = 181 }, .{ .keysym = 186, .unicode = 0 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 110, .unicode = 110 }, .{ .keysym = 78, .unicode = 78 }, .{ .keysym = 2771, .unicode = 8221 }, .{ .keysym = 2769, .unicode = 8217 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 111, .unicode = 111 }, .{ .keysym = 79, .unicode = 79 }, .{ .keysym = 248, .unicode = 248 }, .{ .keysym = 216, .unicode = 216 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 112, .unicode = 112 }, .{ .keysym = 80, .unicode = 80 }, .{ .keysym = 254, .unicode = 254 }, .{ .keysym = 222, .unicode = 222 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 113, .unicode = 113 }, .{ .keysym = 81, .unicode = 81 }, .{ .keysym = 64, .unicode = 64 }, .{ .keysym = 2009, .unicode = 937 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 114, .unicode = 114 }, .{ .keysym = 82, .unicode = 82 }, .{ .keysym = 182, .unicode = 182 }, .{ .keysym = 174, .unicode = 174 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 115, .unicode = 115 }, .{ .keysym = 83, .unicode = 83 }, .{ .keysym = 223, .unicode = 223 }, .{ .keysym = 16785054, .unicode = 7838 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 116, .unicode = 116 }, .{ .keysym = 84, .unicode = 84 }, .{ .keysym = 956, .unicode = 359 }, .{ .keysym = 940, .unicode = 358 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 117, .unicode = 117 }, .{ .keysym = 85, .unicode = 85 }, .{ .keysym = 2302, .unicode = 8595 }, .{ .keysym = 2300, .unicode = 8593 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 118, .unicode = 118 }, .{ .keysym = 86, .unicode = 86 }, .{ .keysym = 2814, .unicode = 8222 }, .{ .keysym = 2813, .unicode = 8218 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 119, .unicode = 119 }, .{ .keysym = 87, .unicode = 87 }, .{ .keysym = 16777599, .unicode = 383 }, .{ .keysym = 167, .unicode = 167 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 120, .unicode = 120 }, .{ .keysym = 88, .unicode = 88 }, .{ .keysym = 187, .unicode = 0 }, .{ .keysym = 62, .unicode = 62 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 121, .unicode = 121 }, .{ .keysym = 89, .unicode = 89 }, .{ .keysym = 2299, .unicode = 8592 }, .{ .keysym = 165, .unicode = 165 } } }, + .{ .kind = .four_level_alphabetic, .levels = .{ .{ .keysym = 122, .unicode = 122 }, .{ .keysym = 90, .unicode = 90 }, .{ .keysym = 171, .unicode = 0 }, .{ .keysym = 60, .unicode = 60 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 49, .unicode = 49 }, .{ .keysym = 33, .unicode = 33 }, .{ .keysym = 124, .unicode = 124 }, .{ .keysym = 161, .unicode = 161 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 50, .unicode = 50 }, .{ .keysym = 34, .unicode = 34 }, .{ .keysym = 64, .unicode = 64 }, .{ .keysym = 2755, .unicode = 8539 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 51, .unicode = 51 }, .{ .keysym = 183, .unicode = 183 }, .{ .keysym = 35, .unicode = 35 }, .{ .keysym = 163, .unicode = 163 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 52, .unicode = 52 }, .{ .keysym = 36, .unicode = 36 }, .{ .keysym = 126, .unicode = 126 }, .{ .keysym = 36, .unicode = 36 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 53, .unicode = 53 }, .{ .keysym = 37, .unicode = 37 }, .{ .keysym = 189, .unicode = 189 }, .{ .keysym = 2756, .unicode = 8540 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 54, .unicode = 54 }, .{ .keysym = 38, .unicode = 38 }, .{ .keysym = 172, .unicode = 172 }, .{ .keysym = 2757, .unicode = 8541 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 55, .unicode = 55 }, .{ .keysym = 47, .unicode = 47 }, .{ .keysym = 123, .unicode = 123 }, .{ .keysym = 2758, .unicode = 8542 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 56, .unicode = 56 }, .{ .keysym = 40, .unicode = 40 }, .{ .keysym = 91, .unicode = 91 }, .{ .keysym = 2761, .unicode = 8482 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 57, .unicode = 57 }, .{ .keysym = 41, .unicode = 41 }, .{ .keysym = 93, .unicode = 93 }, .{ .keysym = 177, .unicode = 177 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 48, .unicode = 48 }, .{ .keysym = 61, .unicode = 61 }, .{ .keysym = 125, .unicode = 125 }, .{ .keysym = 176, .unicode = 176 } } }, + .{}, + .{}, + .{}, + .{}, + .{}, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 39, .unicode = 39 }, .{ .keysym = 63, .unicode = 63 }, .{ .keysym = 92, .unicode = 92 }, .{ .keysym = 191, .unicode = 191 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 161, .unicode = 161 }, .{ .keysym = 191, .unicode = 191 }, .{ .keysym = 65115, .unicode = 0 }, .{ .keysym = 65116, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 65104, .unicode = 0 }, .{ .keysym = 65106, .unicode = 0 }, .{ .keysym = 91, .unicode = 91 }, .{ .keysym = 65112, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 43, .unicode = 43 }, .{ .keysym = 42, .unicode = 42 }, .{ .keysym = 93, .unicode = 93 }, .{ .keysym = 65108, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 231, .unicode = 231 }, .{ .keysym = 199, .unicode = 199 }, .{ .keysym = 125, .unicode = 125 }, .{ .keysym = 65109, .unicode = 0 } } }, + .{}, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 241, .unicode = 241 }, .{ .keysym = 209, .unicode = 209 }, .{ .keysym = 65107, .unicode = 0 }, .{ .keysym = 65113, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 65105, .unicode = 0 }, .{ .keysym = 65111, .unicode = 0 }, .{ .keysym = 123, .unicode = 123 }, .{ .keysym = 65114, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 186, .unicode = 0 }, .{ .keysym = 170, .unicode = 170 }, .{ .keysym = 92, .unicode = 92 }, .{ .keysym = 92, .unicode = 92 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 44, .unicode = 44 }, .{ .keysym = 59, .unicode = 59 }, .{ .keysym = 16785442, .unicode = 8226 }, .{ .keysym = 215, .unicode = 215 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 46, .unicode = 46 }, .{ .keysym = 58, .unicode = 58 }, .{ .keysym = 183, .unicode = 183 }, .{ .keysym = 247, .unicode = 247 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 45, .unicode = 45 }, .{ .keysym = 95, .unicode = 95 }, .{ .keysym = 65120, .unicode = 0 }, .{ .keysym = 65110, .unicode = 0 } } }, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + }, +}; + +pub const dvorak: Layout = .{ + .name = "dvorak", + .keys = .{ + .{}, + .{}, + .{}, + .{}, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 97, .unicode = 97 }, .{ .keysym = 65, .unicode = 65 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 120, .unicode = 120 }, .{ .keysym = 88, .unicode = 88 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 106, .unicode = 106 }, .{ .keysym = 74, .unicode = 74 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 101, .unicode = 101 }, .{ .keysym = 69, .unicode = 69 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 46, .unicode = 46 }, .{ .keysym = 62, .unicode = 62 }, .{ .keysym = 65110, .unicode = 0 }, .{ .keysym = 183, .unicode = 183 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 117, .unicode = 117 }, .{ .keysym = 85, .unicode = 85 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 105, .unicode = 105 }, .{ .keysym = 73, .unicode = 73 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 100, .unicode = 100 }, .{ .keysym = 68, .unicode = 68 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 99, .unicode = 99 }, .{ .keysym = 67, .unicode = 67 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 104, .unicode = 104 }, .{ .keysym = 72, .unicode = 72 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 116, .unicode = 116 }, .{ .keysym = 84, .unicode = 84 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 110, .unicode = 110 }, .{ .keysym = 78, .unicode = 78 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 109, .unicode = 109 }, .{ .keysym = 77, .unicode = 77 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 98, .unicode = 98 }, .{ .keysym = 66, .unicode = 66 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 114, .unicode = 114 }, .{ .keysym = 82, .unicode = 82 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 108, .unicode = 108 }, .{ .keysym = 76, .unicode = 76 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 39, .unicode = 39 }, .{ .keysym = 34, .unicode = 34 }, .{ .keysym = 65105, .unicode = 0 }, .{ .keysym = 65111, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 112, .unicode = 112 }, .{ .keysym = 80, .unicode = 80 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 111, .unicode = 111 }, .{ .keysym = 79, .unicode = 79 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 121, .unicode = 121 }, .{ .keysym = 89, .unicode = 89 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 103, .unicode = 103 }, .{ .keysym = 71, .unicode = 71 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 107, .unicode = 107 }, .{ .keysym = 75, .unicode = 75 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 44, .unicode = 44 }, .{ .keysym = 60, .unicode = 60 }, .{ .keysym = 65115, .unicode = 0 }, .{ .keysym = 65114, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 113, .unicode = 113 }, .{ .keysym = 81, .unicode = 81 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 102, .unicode = 102 }, .{ .keysym = 70, .unicode = 70 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 59, .unicode = 59 }, .{ .keysym = 58, .unicode = 58 }, .{ .keysym = 65116, .unicode = 0 }, .{ .keysym = 65113, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 49, .unicode = 49 }, .{ .keysym = 33, .unicode = 33 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 50, .unicode = 50 }, .{ .keysym = 64, .unicode = 64 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 51, .unicode = 51 }, .{ .keysym = 35, .unicode = 35 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 52, .unicode = 52 }, .{ .keysym = 36, .unicode = 36 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 53, .unicode = 53 }, .{ .keysym = 37, .unicode = 37 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 54, .unicode = 54 }, .{ .keysym = 94, .unicode = 94 }, .{ .keysym = 65106, .unicode = 0 }, .{ .keysym = 65106, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 55, .unicode = 55 }, .{ .keysym = 38, .unicode = 38 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 56, .unicode = 56 }, .{ .keysym = 42, .unicode = 42 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 57, .unicode = 57 }, .{ .keysym = 40, .unicode = 40 }, .{ .keysym = 65104, .unicode = 0 }, .{ .keysym = 65109, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 48, .unicode = 48 }, .{ .keysym = 41, .unicode = 41 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{}, + .{}, + .{}, + .{}, + .{}, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 91, .unicode = 91 }, .{ .keysym = 123, .unicode = 123 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 93, .unicode = 93 }, .{ .keysym = 125, .unicode = 125 }, .{ .keysym = 65107, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 47, .unicode = 47 }, .{ .keysym = 63, .unicode = 63 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 61, .unicode = 61 }, .{ .keysym = 43, .unicode = 43 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 92, .unicode = 92 }, .{ .keysym = 124, .unicode = 124 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{}, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 115, .unicode = 115 }, .{ .keysym = 83, .unicode = 83 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .two_level, .levels = .{ .{ .keysym = 45, .unicode = 45 }, .{ .keysym = 95, .unicode = 95 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .four_level, .levels = .{ .{ .keysym = 96, .unicode = 96 }, .{ .keysym = 126, .unicode = 126 }, .{ .keysym = 65104, .unicode = 0 }, .{ .keysym = 65107, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 119, .unicode = 119 }, .{ .keysym = 87, .unicode = 87 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 118, .unicode = 118 }, .{ .keysym = 86, .unicode = 86 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{ .kind = .alphabetic, .levels = .{ .{ .keysym = 122, .unicode = 122 }, .{ .keysym = 90, .unicode = 90 }, .{ .keysym = 0, .unicode = 0 }, .{ .keysym = 0, .unicode = 0 } } }, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + .{}, + }, +}; + +pub const all = [_]*const Layout{ &us, &gb, &de, &fr, &es, &dvorak }; diff --git a/library/xkeyboard-config/vendor/COPYING b/library/xkeyboard-config/vendor/COPYING new file mode 100644 index 0000000..3c82f9f --- /dev/null +++ b/library/xkeyboard-config/vendor/COPYING @@ -0,0 +1,190 @@ +Copyright 1996 by Joseph Moss +Copyright (C) 2002-2007 Free Software Foundation, Inc. +Copyright (C) Dmitry Golubev , 2003-2004 +Copyright (C) 2004, Gregory Mokhin +Copyright (C) 2006 Erdal Ronahî + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation, and that the name of the copyright holder(s) not be used in +advertising or publicity pertaining to distribution of the software without +specific, written prior permission. The copyright holder(s) makes no +representations about the suitability of this software for any purpose. It +is provided "as is" without express or implied warranty. + +THE COPYRIGHT HOLDER(S) DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO +EVENT SHALL THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY SPECIAL, INDIRECT OR +CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER +TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. + + +Copyright (c) 1996 Digital Equipment Corporation + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL DIGITAL EQUIPMENT CORPORATION BE LIABLE FOR ANY CLAIM, +DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR +OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR +THE USE OR OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of the Digital Equipment +Corporation shall not be used in advertising or otherwise to promote +the sale, use or other dealings in this Software without prior written +authorization from Digital Equipment Corporation. + + +Copyright 1996, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + + +Copyright 2004-2005 Sun Microsystems, Inc. All rights reserved. + +Permission is hereby granted, free of charge, to any person obtaining a +copy of this software and associated documentation files (the "Software"), +to deal in the Software without restriction, including without limitation +the rights to use, copy, modify, merge, publish, distribute, sublicense, +and/or sell copies of the Software, and to permit persons to whom the +Software is furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice (including the next +paragraph) shall be included in all copies or substantial portions of the +Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL +THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING +FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. + + +Copyright (c) 1996 by Silicon Graphics Computer Systems, Inc. + +Permission to use, copy, modify, and distribute this +software and its documentation for any purpose and without +fee is hereby granted, provided that the above copyright +notice appear in all copies and that both that copyright +notice and this permission notice appear in supporting +documentation, and that the name of Silicon Graphics not be +used in advertising or publicity pertaining to distribution +of the software without specific prior written permission. +Silicon Graphics makes no representation about the suitability +of this software for any purpose. It is provided "as is" +without any express or implied warranty. + +SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS +SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON +GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL +DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE +OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH +THE USE OR PERFORMANCE OF THIS SOFTWARE. + + +Copyright (c) 1996 X Consortium + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +"Software"), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of the X Consortium shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from the X Consortium. + + +Copyright (C) 2004, 2006 Ævar Arnfjörð Bjarmason + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of a copyright holder shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization of +the copyright holder. + + +Copyright (C) 1999, 2000 by Anton Zinoviev + +This software may be used, modified, copied, distributed, and sold, +in both source and binary form provided that the above copyright +and these terms are retained. Under no circumstances is the author +responsible for the proper functioning of this software, nor does +the author assume any responsibility for damages incurred with its +use. + +Permission is granted to anyone to use, distribute and modify +this file in any way, provided that the above copyright notice +is left intact and the author of the modification summarizes +the changes in this header. + +This file is distributed without any expressed or implied warranty. diff --git a/library/xkeyboard-config/vendor/PROVENANCE.md b/library/xkeyboard-config/vendor/PROVENANCE.md new file mode 100644 index 0000000..94d270b --- /dev/null +++ b/library/xkeyboard-config/vendor/PROVENANCE.md @@ -0,0 +1,21 @@ +# Vendored xkeyboard-config subset + +- **Package**: xkeyboard-config 2.44 +- **Source**: https://gitlab.freedesktop.org/xkeyboard-config/xkeyboard-config/-/archive/xkeyboard-config-2.44/xkeyboard-config-2.44.tar.gz +- **sha256**: `35e34edeaf4e8da8d0696ff6b241ee11ddb1b8c6730bac7252d4d0a88ea5f05b` +- **keysymdef.h**: xorgproto, copied from `/opt/homebrew/include/X11/keysymdef.h` +- **License**: MIT/X11 (see COPYING) + +Only the symbols files reachable from the generated layouts (tools/make-xkeyboard-config.py `TARGETS`) are vendored; regenerate with +`python3 tools/make-xkeyboard-config.py fetch` then `... generate`. + +Vendored symbols files: + +- `symbols/de` +- `symbols/es` +- `symbols/fr` +- `symbols/gb` +- `symbols/kpdl` +- `symbols/latin` +- `symbols/level3` +- `symbols/us` diff --git a/library/xkeyboard-config/vendor/keysymdef.h b/library/xkeyboard-config/vendor/keysymdef.h new file mode 100644 index 0000000..e75c402 --- /dev/null +++ b/library/xkeyboard-config/vendor/keysymdef.h @@ -0,0 +1,2584 @@ +/*********************************************************** +Copyright 1987, 1994, 1998 The Open Group + +Permission to use, copy, modify, distribute, and sell this software and its +documentation for any purpose is hereby granted without fee, provided that +the above copyright notice appear in all copies and that both that +copyright notice and this permission notice appear in supporting +documentation. + +The above copyright notice and this permission notice shall be included +in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS +OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR +OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, +ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR +OTHER DEALINGS IN THE SOFTWARE. + +Except as contained in this notice, the name of The Open Group shall +not be used in advertising or otherwise to promote the sale, use or +other dealings in this Software without prior written authorization +from The Open Group. + + +Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts + + All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that copyright notice and this permission notice appear in +supporting documentation, and that the name of Digital not be +used in advertising or publicity pertaining to distribution of the +software without specific, written prior permission. + +DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING +ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL +DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR +ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, +ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS +SOFTWARE. + +******************************************************************/ + +/* + * The "X11 Window System Protocol" standard defines in Appendix A the + * keysym codes. These 29-bit integer values identify characters or + * functions associated with each key (e.g., via the visible + * engraving) of a keyboard layout. This file assigns mnemonic macro + * names for these keysyms. + * + * This file is also compiled (by src/util/makekeys.c in libX11) into + * hash tables that can be accessed with X11 library functions such as + * XStringToKeysym() and XKeysymToString(). + * + * Where a keysym corresponds one-to-one to an ISO 10646 / Unicode + * character, this is noted in a comment that provides both the U+xxxx + * Unicode position, as well as the official Unicode name of the + * character. + * + * Some keysyms map to a character already mapped by another keysym, + * with compatible but more precise semantics, such as the keypad- + * related keysyms. In this case, none of the keysym are deprecated. + * The most generic keysym is annotated as previously and more specific + * keysyms have the same annotation between angle brackets: + * + * #define XK_space 0x0020 // U+0020 SPACE + * #define XK_KP_Space 0xff80 // + * + * Where the correspondence is either not one-to-one or semantically + * unclear, the Unicode position and name are enclosed in + * parentheses. Such legacy keysyms should be considered deprecated + * and are not recommended for use in future keyboard mappings. + * + * For any future extension of the keysyms with characters already + * found in ISO 10646 / Unicode, the following algorithm shall be + * used. The new keysym code position will simply be the character's + * Unicode number plus 0x01000000. The keysym values in the range + * 0x01000100 to 0x0110ffff are reserved to represent Unicode + * characters in the range U+0100 to U+10FFFF. + * + * While most newer Unicode-based X11 clients do already accept + * Unicode-mapped keysyms in the range 0x01000100 to 0x0110ffff, it + * will remain necessary for clients -- in the interest of + * compatibility with existing servers -- to also understand the + * existing legacy keysym values in the range 0x0100 to 0x20ff. + * + * Where several mnemonic names are defined for the same keysym in this + * file, the first one listed is considered the "canonical" name. This + * is the name that should be used when retrieving a keysym name from + * its code. The next names are considered "aliases" to the canonical + * name. + * + * Aliases are made explicit by writing in their comment "alias for", + * followed by the corresponding canonical name. Example: + * + * #define XK_dead_tilde 0xfe53 + * #define XK_dead_perispomeni 0xfe53 // alias for dead_tilde + * + * The rules to consider a keysym mnemonic name deprecated are: + * + * 1. A legacy keysym with its Unicode mapping in parentheses is + * deprecated (see above). + * + * 2. A keysym name is *explicitly* deprecated by starting its comment + * with "deprecated". Examples: + * + * #define XK_L1 0xffc8 // deprecated alias for F11 + * #define XK_quoteleft 0x0060 // deprecated + * + * 3. A keysym name is *explicitly* *not* deprecated by starting its + * comment with "non-deprecated alias". Examples: + * + * #define XK_dead_tilde 0xfe53 + * #define XK_dead_perispomeni 0xfe53 // non-deprecated alias for dead_tilde + * + * 4. If none of the previous rules apply, an alias is *implicitly* + * deprecated if there is at least one previous name for the + * corresponding keysym that is *not* explicitly deprecated. + * + * Examples: + * + * // SingleCandidate is the canonical name + * #define XK_SingleCandidate 0xff3c + * // Hangul_SingleCandidate is deprecated because it is an alias + * // and it does not start with "non-deprecated alias" + * #define XK_Hangul_SingleCandidate 0xff3c // Single candidate + * + * // guillemotleft is the canonical name, but it is deprecated + * #define XK_guillemotleft 0x00ab // deprecated alias for guillemetleft (misspelling) + * // guillemetleft is not deprecated, because the keysym has no endorsed name before it. + * #define XK_guillemetleft 0x00ab // U+00AB LEFT-POINTING DOUBLE ANGLE QUOTATION MARK + * // The following hypothetical name is deprecated because guillemetleft come before. + * #define XK_guillemetleft2 0x00ab + * + * Mnemonic names for keysyms are defined in this file with lines + * that match one of these Perl regular expressions: + * + * /^\#define XK_([a-zA-Z_0-9]+)\s+0x([0-9a-f]+)\s*\/\* U\+([0-9A-F]{4,6}) (.*) \*\/\s*$/ + * /^\#define XK_([a-zA-Z_0-9]+)\s+0x([0-9a-f]+)\s*\/\*\*\/\s*$/ + * /^\#define XK_([a-zA-Z_0-9]+)\s+0x([0-9a-f]+)\s*\/\*\(U\+([0-9A-F]{4,6}) (.*)\)\*\/\s*$/ + * /^\#define XK_([a-zA-Z_0-9]+)\s+0x([0-9a-f]+)\s*(\/\*\s*(.*)\s*\*\/)?\s*$/ + * + * Before adding new keysyms, please do consider the following: In + * addition to the keysym names defined in this file, the + * XStringToKeysym() and XKeysymToString() functions will also handle + * any keysym string of the form "U0020" to "U007E" and "U00A0" to + * "U10FFFF" for all possible Unicode characters. In other words, + * every possible Unicode character has already a keysym string + * defined algorithmically, even if it is not listed here. Therefore, + * defining an additional keysym macro is only necessary where a + * non-hexadecimal mnemonic name is needed, or where the new keysym + * does not represent any existing Unicode character. + * + * When adding new keysyms to this file, do not forget to also update the + * following as needed: + * + * - the mappings in src/KeyBind.c in the libX11 repo + * https://gitlab.freedesktop.org/xorg/lib/libx11 + * + * - the protocol specification in specs/keysyms.xml in this repo + * https://gitlab.freedesktop.org/xorg/proto/xorgproto + * + * Before removing or changing the order of the keysyms, please consider + * the following: it is very difficult to know what keysyms are used and + * how. + * + * - A sandboxed application may have incompatibilities with the host + * system. For example, if new keysym name is introduced and is made + * the canonical name, then an application with an older keysym parser + * will not be able to parse the new name. + * - Customization of keyboard layout and Compose files are two popular + * use cases. Checking the standard keyboard layout database xkeyboard-config + * https://gitlab.freedesktop.org/xkeyboard-config/xkeyboard-config + * and the standard Compose files in libx11 + * https://gitlab.freedesktop.org/xorg/lib/libx11 is a mandatory + * step, but may *not* be enough for a proper impact assessment for + * e.g. keysyms removals. + * + * Therefore, it is advised to proceed to no removal and to make a new + * name canonical only 10 years after its introduction. This means that + * some keysyms may have their first listed name deprecated during the + * period of transition. Once this period is over, the deprecated name + * should be moved after the new canonical name. + */ + +#define XK_VoidSymbol 0xffffff /* Void symbol */ + +#ifdef XK_MISCELLANY +/* + * TTY function keys, cleverly chosen to map to ASCII, for convenience of + * programming, but could have been arbitrary (at the cost of lookup + * tables in client code). + */ + +#define XK_BackSpace 0xff08 /* U+0008 BACKSPACE */ +#define XK_Tab 0xff09 /* U+0009 CHARACTER TABULATION */ +#define XK_Linefeed 0xff0a /* U+000A LINE FEED */ +#define XK_Clear 0xff0b /* U+000B LINE TABULATION */ +#define XK_Return 0xff0d /* U+000D CARRIAGE RETURN */ +#define XK_Pause 0xff13 /* Pause, hold */ +#define XK_Scroll_Lock 0xff14 +#define XK_Sys_Req 0xff15 +#define XK_Escape 0xff1b /* U+001B ESCAPE */ +#define XK_Delete 0xffff /* U+007F DELETE */ + + + +/* International & multi-key character composition */ + +#define XK_Multi_key 0xff20 /* Multi-key character compose */ +#define XK_Codeinput 0xff37 +#define XK_SingleCandidate 0xff3c +#define XK_MultipleCandidate 0xff3d +#define XK_PreviousCandidate 0xff3e + +/* Japanese keyboard support */ + +#define XK_Kanji 0xff21 /* Kanji, Kanji convert */ +#define XK_Muhenkan 0xff22 /* Cancel Conversion */ +#define XK_Henkan_Mode 0xff23 /* Start/Stop Conversion */ +#define XK_Henkan 0xff23 /* non-deprecated alias for Henkan_Mode */ +#define XK_Romaji 0xff24 /* to Romaji */ +#define XK_Hiragana 0xff25 /* to Hiragana */ +#define XK_Katakana 0xff26 /* to Katakana */ +#define XK_Hiragana_Katakana 0xff27 /* Hiragana/Katakana toggle */ +#define XK_Zenkaku 0xff28 /* to Zenkaku */ +#define XK_Hankaku 0xff29 /* to Hankaku */ +#define XK_Zenkaku_Hankaku 0xff2a /* Zenkaku/Hankaku toggle */ +#define XK_Touroku 0xff2b /* Add to Dictionary */ +#define XK_Massyo 0xff2c /* Delete from Dictionary */ +#define XK_Kana_Lock 0xff2d /* Kana Lock */ +#define XK_Kana_Shift 0xff2e /* Kana Shift */ +#define XK_Eisu_Shift 0xff2f /* Alphanumeric Shift */ +#define XK_Eisu_toggle 0xff30 /* Alphanumeric toggle */ +#define XK_Kanji_Bangou 0xff37 /* Codeinput */ +#define XK_Zen_Koho 0xff3d /* Multiple/All Candidate(s) */ +#define XK_Mae_Koho 0xff3e /* Previous Candidate */ + +/* 0xff31 thru 0xff3f are under XK_KOREAN */ + +/* Cursor control & motion */ + +#define XK_Home 0xff50 +#define XK_Left 0xff51 /* Move left, left arrow */ +#define XK_Up 0xff52 /* Move up, up arrow */ +#define XK_Right 0xff53 /* Move right, right arrow */ +#define XK_Down 0xff54 /* Move down, down arrow */ +#define XK_Prior 0xff55 /* Prior, previous */ +#define XK_Page_Up 0xff55 /* deprecated alias for Prior */ +#define XK_Next 0xff56 /* Next */ +#define XK_Page_Down 0xff56 /* deprecated alias for Next */ +#define XK_End 0xff57 /* EOL */ +#define XK_Begin 0xff58 /* BOL */ + + +/* Misc functions */ + +#define XK_Select 0xff60 /* Select, mark */ +#define XK_Print 0xff61 +#define XK_Execute 0xff62 /* Execute, run, do */ +#define XK_Insert 0xff63 /* Insert, insert here */ +#define XK_Undo 0xff65 +#define XK_Redo 0xff66 /* Redo, again */ +#define XK_Menu 0xff67 +#define XK_Find 0xff68 /* Find, search */ +#define XK_Cancel 0xff69 /* Cancel, stop, abort, exit */ +#define XK_Help 0xff6a /* Help */ +#define XK_Break 0xff6b +#define XK_Mode_switch 0xff7e /* Character set switch */ +#define XK_script_switch 0xff7e /* non-deprecated alias for Mode_switch */ +#define XK_Num_Lock 0xff7f + +/* Keypad functions, keypad numbers cleverly chosen to map to ASCII */ + +#define XK_KP_Space 0xff80 /**/ +#define XK_KP_Tab 0xff89 /**/ +#define XK_KP_Enter 0xff8d /**/ +#define XK_KP_F1 0xff91 /* PF1, KP_A, ... */ +#define XK_KP_F2 0xff92 +#define XK_KP_F3 0xff93 +#define XK_KP_F4 0xff94 +#define XK_KP_Home 0xff95 +#define XK_KP_Left 0xff96 +#define XK_KP_Up 0xff97 +#define XK_KP_Right 0xff98 +#define XK_KP_Down 0xff99 +#define XK_KP_Prior 0xff9a +#define XK_KP_Page_Up 0xff9a /* deprecated alias for KP_Prior */ +#define XK_KP_Next 0xff9b +#define XK_KP_Page_Down 0xff9b /* deprecated alias for KP_Next */ +#define XK_KP_End 0xff9c +#define XK_KP_Begin 0xff9d +#define XK_KP_Insert 0xff9e +#define XK_KP_Delete 0xff9f +#define XK_KP_Equal 0xffbd /**/ +#define XK_KP_Multiply 0xffaa /**/ +#define XK_KP_Add 0xffab /**/ +#define XK_KP_Separator 0xffac /**/ +#define XK_KP_Subtract 0xffad /**/ +#define XK_KP_Decimal 0xffae /**/ +#define XK_KP_Divide 0xffaf /**/ + +#define XK_KP_0 0xffb0 /**/ +#define XK_KP_1 0xffb1 /**/ +#define XK_KP_2 0xffb2 /**/ +#define XK_KP_3 0xffb3 /**/ +#define XK_KP_4 0xffb4 /**/ +#define XK_KP_5 0xffb5 /**/ +#define XK_KP_6 0xffb6 /**/ +#define XK_KP_7 0xffb7 /**/ +#define XK_KP_8 0xffb8 /**/ +#define XK_KP_9 0xffb9 /**/ + + + +/* + * Auxiliary functions; note the duplicate definitions for left and right + * function keys; Sun keyboards and a few other manufacturers have such + * function key groups on the left and/or right sides of the keyboard. + * We've not found a keyboard with more than 35 function keys total. + */ + +#define XK_F1 0xffbe +#define XK_F2 0xffbf +#define XK_F3 0xffc0 +#define XK_F4 0xffc1 +#define XK_F5 0xffc2 +#define XK_F6 0xffc3 +#define XK_F7 0xffc4 +#define XK_F8 0xffc5 +#define XK_F9 0xffc6 +#define XK_F10 0xffc7 +#define XK_F11 0xffc8 +#define XK_L1 0xffc8 /* deprecated alias for F11 */ +#define XK_F12 0xffc9 +#define XK_L2 0xffc9 /* deprecated alias for F12 */ +#define XK_F13 0xffca +#define XK_L3 0xffca /* deprecated alias for F13 */ +#define XK_F14 0xffcb +#define XK_L4 0xffcb /* deprecated alias for F14 */ +#define XK_F15 0xffcc +#define XK_L5 0xffcc /* deprecated alias for F15 */ +#define XK_F16 0xffcd +#define XK_L6 0xffcd /* deprecated alias for F16 */ +#define XK_F17 0xffce +#define XK_L7 0xffce /* deprecated alias for F17 */ +#define XK_F18 0xffcf +#define XK_L8 0xffcf /* deprecated alias for F18 */ +#define XK_F19 0xffd0 +#define XK_L9 0xffd0 /* deprecated alias for F19 */ +#define XK_F20 0xffd1 +#define XK_L10 0xffd1 /* deprecated alias for F20 */ +#define XK_F21 0xffd2 +#define XK_R1 0xffd2 /* deprecated alias for F21 */ +#define XK_F22 0xffd3 +#define XK_R2 0xffd3 /* deprecated alias for F22 */ +#define XK_F23 0xffd4 +#define XK_R3 0xffd4 /* deprecated alias for F23 */ +#define XK_F24 0xffd5 +#define XK_R4 0xffd5 /* deprecated alias for F24 */ +#define XK_F25 0xffd6 +#define XK_R5 0xffd6 /* deprecated alias for F25 */ +#define XK_F26 0xffd7 +#define XK_R6 0xffd7 /* deprecated alias for F26 */ +#define XK_F27 0xffd8 +#define XK_R7 0xffd8 /* deprecated alias for F27 */ +#define XK_F28 0xffd9 +#define XK_R8 0xffd9 /* deprecated alias for F28 */ +#define XK_F29 0xffda +#define XK_R9 0xffda /* deprecated alias for F29 */ +#define XK_F30 0xffdb +#define XK_R10 0xffdb /* deprecated alias for F30 */ +#define XK_F31 0xffdc +#define XK_R11 0xffdc /* deprecated alias for F31 */ +#define XK_F32 0xffdd +#define XK_R12 0xffdd /* deprecated alias for F32 */ +#define XK_F33 0xffde +#define XK_R13 0xffde /* deprecated alias for F33 */ +#define XK_F34 0xffdf +#define XK_R14 0xffdf /* deprecated alias for F34 */ +#define XK_F35 0xffe0 +#define XK_R15 0xffe0 /* deprecated alias for F35 */ + +/* Modifiers */ + +#define XK_Shift_L 0xffe1 /* Left shift */ +#define XK_Shift_R 0xffe2 /* Right shift */ +#define XK_Control_L 0xffe3 /* Left control */ +#define XK_Control_R 0xffe4 /* Right control */ +#define XK_Caps_Lock 0xffe5 /* Caps lock */ +#define XK_Shift_Lock 0xffe6 /* Shift lock */ + +#define XK_Meta_L 0xffe7 /* Left meta */ +#define XK_Meta_R 0xffe8 /* Right meta */ +#define XK_Alt_L 0xffe9 /* Left alt */ +#define XK_Alt_R 0xffea /* Right alt */ +#define XK_Super_L 0xffeb /* Left super */ +#define XK_Super_R 0xffec /* Right super */ +#define XK_Hyper_L 0xffed /* Left hyper */ +#define XK_Hyper_R 0xffee /* Right hyper */ +#endif /* XK_MISCELLANY */ + +/* + * Keyboard (XKB) Extension function and modifier keys + * (from Appendix C of "The X Keyboard Extension: Protocol Specification") + * Byte 3 = 0xfe + */ + +#ifdef XK_XKB_KEYS +#define XK_ISO_Lock 0xfe01 +#define XK_ISO_Level2_Latch 0xfe02 +#define XK_ISO_Level3_Shift 0xfe03 +#define XK_ISO_Level3_Latch 0xfe04 +#define XK_ISO_Level3_Lock 0xfe05 +#define XK_ISO_Level5_Shift 0xfe11 +#define XK_ISO_Level5_Latch 0xfe12 +#define XK_ISO_Level5_Lock 0xfe13 +#define XK_ISO_Group_Shift 0xff7e /* non-deprecated alias for Mode_switch */ +#define XK_ISO_Group_Latch 0xfe06 +#define XK_ISO_Group_Lock 0xfe07 +#define XK_ISO_Next_Group 0xfe08 +#define XK_ISO_Next_Group_Lock 0xfe09 +#define XK_ISO_Prev_Group 0xfe0a +#define XK_ISO_Prev_Group_Lock 0xfe0b +#define XK_ISO_First_Group 0xfe0c +#define XK_ISO_First_Group_Lock 0xfe0d +#define XK_ISO_Last_Group 0xfe0e +#define XK_ISO_Last_Group_Lock 0xfe0f + +#define XK_ISO_Left_Tab 0xfe20 +#define XK_ISO_Move_Line_Up 0xfe21 +#define XK_ISO_Move_Line_Down 0xfe22 +#define XK_ISO_Partial_Line_Up 0xfe23 +#define XK_ISO_Partial_Line_Down 0xfe24 +#define XK_ISO_Partial_Space_Left 0xfe25 +#define XK_ISO_Partial_Space_Right 0xfe26 +#define XK_ISO_Set_Margin_Left 0xfe27 +#define XK_ISO_Set_Margin_Right 0xfe28 +#define XK_ISO_Release_Margin_Left 0xfe29 +#define XK_ISO_Release_Margin_Right 0xfe2a +#define XK_ISO_Release_Both_Margins 0xfe2b +#define XK_ISO_Fast_Cursor_Left 0xfe2c +#define XK_ISO_Fast_Cursor_Right 0xfe2d +#define XK_ISO_Fast_Cursor_Up 0xfe2e +#define XK_ISO_Fast_Cursor_Down 0xfe2f +#define XK_ISO_Continuous_Underline 0xfe30 +#define XK_ISO_Discontinuous_Underline 0xfe31 +#define XK_ISO_Emphasize 0xfe32 +#define XK_ISO_Center_Object 0xfe33 +#define XK_ISO_Enter 0xfe34 + +#define XK_dead_grave 0xfe50 +#define XK_dead_acute 0xfe51 +#define XK_dead_circumflex 0xfe52 +#define XK_dead_tilde 0xfe53 +#define XK_dead_perispomeni 0xfe53 /* non-deprecated alias for dead_tilde */ +#define XK_dead_macron 0xfe54 +#define XK_dead_breve 0xfe55 +#define XK_dead_abovedot 0xfe56 +#define XK_dead_diaeresis 0xfe57 +#define XK_dead_abovering 0xfe58 +#define XK_dead_doubleacute 0xfe59 +#define XK_dead_caron 0xfe5a +#define XK_dead_cedilla 0xfe5b +#define XK_dead_ogonek 0xfe5c +#define XK_dead_iota 0xfe5d +#define XK_dead_voiced_sound 0xfe5e +#define XK_dead_semivoiced_sound 0xfe5f +#define XK_dead_belowdot 0xfe60 +#define XK_dead_hook 0xfe61 +#define XK_dead_horn 0xfe62 +#define XK_dead_stroke 0xfe63 +#define XK_dead_abovecomma 0xfe64 +#define XK_dead_psili 0xfe64 /* non-deprecated alias for dead_abovecomma */ +#define XK_dead_abovereversedcomma 0xfe65 +#define XK_dead_dasia 0xfe65 /* non-deprecated alias for dead_abovereversedcomma */ +#define XK_dead_doublegrave 0xfe66 +#define XK_dead_belowring 0xfe67 +#define XK_dead_belowmacron 0xfe68 +#define XK_dead_belowcircumflex 0xfe69 +#define XK_dead_belowtilde 0xfe6a +#define XK_dead_belowbreve 0xfe6b +#define XK_dead_belowdiaeresis 0xfe6c +#define XK_dead_invertedbreve 0xfe6d +#define XK_dead_belowcomma 0xfe6e +#define XK_dead_currency 0xfe6f + +/* extra dead elements for German T3 layout */ +#define XK_dead_lowline 0xfe90 +#define XK_dead_aboveverticalline 0xfe91 +#define XK_dead_belowverticalline 0xfe92 +#define XK_dead_longsolidusoverlay 0xfe93 + +/* dead vowels for universal syllable entry */ +#define XK_dead_a 0xfe80 +#define XK_dead_A 0xfe81 +#define XK_dead_e 0xfe82 +#define XK_dead_E 0xfe83 +#define XK_dead_i 0xfe84 +#define XK_dead_I 0xfe85 +#define XK_dead_o 0xfe86 +#define XK_dead_O 0xfe87 +#define XK_dead_u 0xfe88 +#define XK_dead_U 0xfe89 +#define XK_dead_small_schwa 0xfe8a /* deprecated alias for dead_schwa */ +#define XK_dead_schwa 0xfe8a +#define XK_dead_capital_schwa 0xfe8b /* deprecated alias for dead_SCHWA */ +#define XK_dead_SCHWA 0xfe8b + +#define XK_dead_greek 0xfe8c +#define XK_dead_hamza 0xfe8d + +#define XK_First_Virtual_Screen 0xfed0 +#define XK_Prev_Virtual_Screen 0xfed1 +#define XK_Next_Virtual_Screen 0xfed2 +#define XK_Last_Virtual_Screen 0xfed4 +#define XK_Terminate_Server 0xfed5 + +#define XK_AccessX_Enable 0xfe70 +#define XK_AccessX_Feedback_Enable 0xfe71 +#define XK_RepeatKeys_Enable 0xfe72 +#define XK_SlowKeys_Enable 0xfe73 +#define XK_BounceKeys_Enable 0xfe74 +#define XK_StickyKeys_Enable 0xfe75 +#define XK_MouseKeys_Enable 0xfe76 +#define XK_MouseKeys_Accel_Enable 0xfe77 +#define XK_Overlay1_Enable 0xfe78 +#define XK_Overlay2_Enable 0xfe79 +#define XK_AudibleBell_Enable 0xfe7a + +#define XK_Pointer_Left 0xfee0 +#define XK_Pointer_Right 0xfee1 +#define XK_Pointer_Up 0xfee2 +#define XK_Pointer_Down 0xfee3 +#define XK_Pointer_UpLeft 0xfee4 +#define XK_Pointer_UpRight 0xfee5 +#define XK_Pointer_DownLeft 0xfee6 +#define XK_Pointer_DownRight 0xfee7 +#define XK_Pointer_Button_Dflt 0xfee8 +#define XK_Pointer_Button1 0xfee9 +#define XK_Pointer_Button2 0xfeea +#define XK_Pointer_Button3 0xfeeb +#define XK_Pointer_Button4 0xfeec +#define XK_Pointer_Button5 0xfeed +#define XK_Pointer_DblClick_Dflt 0xfeee +#define XK_Pointer_DblClick1 0xfeef +#define XK_Pointer_DblClick2 0xfef0 +#define XK_Pointer_DblClick3 0xfef1 +#define XK_Pointer_DblClick4 0xfef2 +#define XK_Pointer_DblClick5 0xfef3 +#define XK_Pointer_Drag_Dflt 0xfef4 +#define XK_Pointer_Drag1 0xfef5 +#define XK_Pointer_Drag2 0xfef6 +#define XK_Pointer_Drag3 0xfef7 +#define XK_Pointer_Drag4 0xfef8 +#define XK_Pointer_Drag5 0xfefd + +#define XK_Pointer_EnableKeys 0xfef9 +#define XK_Pointer_Accelerate 0xfefa +#define XK_Pointer_DfltBtnNext 0xfefb +#define XK_Pointer_DfltBtnPrev 0xfefc + +/* Single-Stroke Multiple-Character N-Graph Keysyms For The X Input Method */ + +#define XK_ch 0xfea0 +#define XK_Ch 0xfea1 +#define XK_CH 0xfea2 +#define XK_c_h 0xfea3 +#define XK_C_h 0xfea4 +#define XK_C_H 0xfea5 + +#endif /* XK_XKB_KEYS */ + +/* + * 3270 Terminal Keys + * Byte 3 = 0xfd + */ + +#ifdef XK_3270 +#define XK_3270_Duplicate 0xfd01 +#define XK_3270_FieldMark 0xfd02 +#define XK_3270_Right2 0xfd03 +#define XK_3270_Left2 0xfd04 +#define XK_3270_BackTab 0xfd05 +#define XK_3270_EraseEOF 0xfd06 +#define XK_3270_EraseInput 0xfd07 +#define XK_3270_Reset 0xfd08 +#define XK_3270_Quit 0xfd09 +#define XK_3270_PA1 0xfd0a +#define XK_3270_PA2 0xfd0b +#define XK_3270_PA3 0xfd0c +#define XK_3270_Test 0xfd0d +#define XK_3270_Attn 0xfd0e +#define XK_3270_CursorBlink 0xfd0f +#define XK_3270_AltCursor 0xfd10 +#define XK_3270_KeyClick 0xfd11 +#define XK_3270_Jump 0xfd12 +#define XK_3270_Ident 0xfd13 +#define XK_3270_Rule 0xfd14 +#define XK_3270_Copy 0xfd15 +#define XK_3270_Play 0xfd16 +#define XK_3270_Setup 0xfd17 +#define XK_3270_Record 0xfd18 +#define XK_3270_ChangeScreen 0xfd19 +#define XK_3270_DeleteWord 0xfd1a +#define XK_3270_ExSelect 0xfd1b +#define XK_3270_CursorSelect 0xfd1c +#define XK_3270_PrintScreen 0xfd1d +#define XK_3270_Enter 0xfd1e +#endif /* XK_3270 */ + +/* + * Latin 1 + * (ISO/IEC 8859-1 = Unicode U+0020..U+00FF) + * Byte 3 = 0 + */ +#ifdef XK_LATIN1 +#define XK_space 0x0020 /* U+0020 SPACE */ +#define XK_exclam 0x0021 /* U+0021 EXCLAMATION MARK */ +#define XK_quotedbl 0x0022 /* U+0022 QUOTATION MARK */ +#define XK_numbersign 0x0023 /* U+0023 NUMBER SIGN */ +#define XK_dollar 0x0024 /* U+0024 DOLLAR SIGN */ +#define XK_percent 0x0025 /* U+0025 PERCENT SIGN */ +#define XK_ampersand 0x0026 /* U+0026 AMPERSAND */ +#define XK_apostrophe 0x0027 /* U+0027 APOSTROPHE */ +#define XK_quoteright 0x0027 /* deprecated */ +#define XK_parenleft 0x0028 /* U+0028 LEFT PARENTHESIS */ +#define XK_parenright 0x0029 /* U+0029 RIGHT PARENTHESIS */ +#define XK_asterisk 0x002a /* U+002A ASTERISK */ +#define XK_plus 0x002b /* U+002B PLUS SIGN */ +#define XK_comma 0x002c /* U+002C COMMA */ +#define XK_minus 0x002d /* U+002D HYPHEN-MINUS */ +#define XK_period 0x002e /* U+002E FULL STOP */ +#define XK_slash 0x002f /* U+002F SOLIDUS */ +#define XK_0 0x0030 /* U+0030 DIGIT ZERO */ +#define XK_1 0x0031 /* U+0031 DIGIT ONE */ +#define XK_2 0x0032 /* U+0032 DIGIT TWO */ +#define XK_3 0x0033 /* U+0033 DIGIT THREE */ +#define XK_4 0x0034 /* U+0034 DIGIT FOUR */ +#define XK_5 0x0035 /* U+0035 DIGIT FIVE */ +#define XK_6 0x0036 /* U+0036 DIGIT SIX */ +#define XK_7 0x0037 /* U+0037 DIGIT SEVEN */ +#define XK_8 0x0038 /* U+0038 DIGIT EIGHT */ +#define XK_9 0x0039 /* U+0039 DIGIT NINE */ +#define XK_colon 0x003a /* U+003A COLON */ +#define XK_semicolon 0x003b /* U+003B SEMICOLON */ +#define XK_less 0x003c /* U+003C LESS-THAN SIGN */ +#define XK_equal 0x003d /* U+003D EQUALS SIGN */ +#define XK_greater 0x003e /* U+003E GREATER-THAN SIGN */ +#define XK_question 0x003f /* U+003F QUESTION MARK */ +#define XK_at 0x0040 /* U+0040 COMMERCIAL AT */ +#define XK_A 0x0041 /* U+0041 LATIN CAPITAL LETTER A */ +#define XK_B 0x0042 /* U+0042 LATIN CAPITAL LETTER B */ +#define XK_C 0x0043 /* U+0043 LATIN CAPITAL LETTER C */ +#define XK_D 0x0044 /* U+0044 LATIN CAPITAL LETTER D */ +#define XK_E 0x0045 /* U+0045 LATIN CAPITAL LETTER E */ +#define XK_F 0x0046 /* U+0046 LATIN CAPITAL LETTER F */ +#define XK_G 0x0047 /* U+0047 LATIN CAPITAL LETTER G */ +#define XK_H 0x0048 /* U+0048 LATIN CAPITAL LETTER H */ +#define XK_I 0x0049 /* U+0049 LATIN CAPITAL LETTER I */ +#define XK_J 0x004a /* U+004A LATIN CAPITAL LETTER J */ +#define XK_K 0x004b /* U+004B LATIN CAPITAL LETTER K */ +#define XK_L 0x004c /* U+004C LATIN CAPITAL LETTER L */ +#define XK_M 0x004d /* U+004D LATIN CAPITAL LETTER M */ +#define XK_N 0x004e /* U+004E LATIN CAPITAL LETTER N */ +#define XK_O 0x004f /* U+004F LATIN CAPITAL LETTER O */ +#define XK_P 0x0050 /* U+0050 LATIN CAPITAL LETTER P */ +#define XK_Q 0x0051 /* U+0051 LATIN CAPITAL LETTER Q */ +#define XK_R 0x0052 /* U+0052 LATIN CAPITAL LETTER R */ +#define XK_S 0x0053 /* U+0053 LATIN CAPITAL LETTER S */ +#define XK_T 0x0054 /* U+0054 LATIN CAPITAL LETTER T */ +#define XK_U 0x0055 /* U+0055 LATIN CAPITAL LETTER U */ +#define XK_V 0x0056 /* U+0056 LATIN CAPITAL LETTER V */ +#define XK_W 0x0057 /* U+0057 LATIN CAPITAL LETTER W */ +#define XK_X 0x0058 /* U+0058 LATIN CAPITAL LETTER X */ +#define XK_Y 0x0059 /* U+0059 LATIN CAPITAL LETTER Y */ +#define XK_Z 0x005a /* U+005A LATIN CAPITAL LETTER Z */ +#define XK_bracketleft 0x005b /* U+005B LEFT SQUARE BRACKET */ +#define XK_backslash 0x005c /* U+005C REVERSE SOLIDUS */ +#define XK_bracketright 0x005d /* U+005D RIGHT SQUARE BRACKET */ +#define XK_asciicircum 0x005e /* U+005E CIRCUMFLEX ACCENT */ +#define XK_underscore 0x005f /* U+005F LOW LINE */ +#define XK_grave 0x0060 /* U+0060 GRAVE ACCENT */ +#define XK_quoteleft 0x0060 /* deprecated */ +#define XK_a 0x0061 /* U+0061 LATIN SMALL LETTER A */ +#define XK_b 0x0062 /* U+0062 LATIN SMALL LETTER B */ +#define XK_c 0x0063 /* U+0063 LATIN SMALL LETTER C */ +#define XK_d 0x0064 /* U+0064 LATIN SMALL LETTER D */ +#define XK_e 0x0065 /* U+0065 LATIN SMALL LETTER E */ +#define XK_f 0x0066 /* U+0066 LATIN SMALL LETTER F */ +#define XK_g 0x0067 /* U+0067 LATIN SMALL LETTER G */ +#define XK_h 0x0068 /* U+0068 LATIN SMALL LETTER H */ +#define XK_i 0x0069 /* U+0069 LATIN SMALL LETTER I */ +#define XK_j 0x006a /* U+006A LATIN SMALL LETTER J */ +#define XK_k 0x006b /* U+006B LATIN SMALL LETTER K */ +#define XK_l 0x006c /* U+006C LATIN SMALL LETTER L */ +#define XK_m 0x006d /* U+006D LATIN SMALL LETTER M */ +#define XK_n 0x006e /* U+006E LATIN SMALL LETTER N */ +#define XK_o 0x006f /* U+006F LATIN SMALL LETTER O */ +#define XK_p 0x0070 /* U+0070 LATIN SMALL LETTER P */ +#define XK_q 0x0071 /* U+0071 LATIN SMALL LETTER Q */ +#define XK_r 0x0072 /* U+0072 LATIN SMALL LETTER R */ +#define XK_s 0x0073 /* U+0073 LATIN SMALL LETTER S */ +#define XK_t 0x0074 /* U+0074 LATIN SMALL LETTER T */ +#define XK_u 0x0075 /* U+0075 LATIN SMALL LETTER U */ +#define XK_v 0x0076 /* U+0076 LATIN SMALL LETTER V */ +#define XK_w 0x0077 /* U+0077 LATIN SMALL LETTER W */ +#define XK_x 0x0078 /* U+0078 LATIN SMALL LETTER X */ +#define XK_y 0x0079 /* U+0079 LATIN SMALL LETTER Y */ +#define XK_z 0x007a /* U+007A LATIN SMALL LETTER Z */ +#define XK_braceleft 0x007b /* U+007B LEFT CURLY BRACKET */ +#define XK_bar 0x007c /* U+007C VERTICAL LINE */ +#define XK_braceright 0x007d /* U+007D RIGHT CURLY BRACKET */ +#define XK_asciitilde 0x007e /* U+007E TILDE */ + +#define XK_nobreakspace 0x00a0 /* U+00A0 NO-BREAK SPACE */ +#define XK_exclamdown 0x00a1 /* U+00A1 INVERTED EXCLAMATION MARK */ +#define XK_cent 0x00a2 /* U+00A2 CENT SIGN */ +#define XK_sterling 0x00a3 /* U+00A3 POUND SIGN */ +#define XK_currency 0x00a4 /* U+00A4 CURRENCY SIGN */ +#define XK_yen 0x00a5 /* U+00A5 YEN SIGN */ +#define XK_brokenbar 0x00a6 /* U+00A6 BROKEN BAR */ +#define XK_section 0x00a7 /* U+00A7 SECTION SIGN */ +#define XK_diaeresis 0x00a8 /* U+00A8 DIAERESIS */ +#define XK_copyright 0x00a9 /* U+00A9 COPYRIGHT SIGN */ +#define XK_ordfeminine 0x00aa /* U+00AA FEMININE ORDINAL INDICATOR */ +#define XK_guillemotleft 0x00ab /* deprecated alias for guillemetleft (misspelling) */ +#define XK_guillemetleft 0x00ab /* U+00AB LEFT-POINTING DOUBLE ANGLE QUOTATION MARK */ +#define XK_notsign 0x00ac /* U+00AC NOT SIGN */ +#define XK_hyphen 0x00ad /* U+00AD SOFT HYPHEN */ +#define XK_registered 0x00ae /* U+00AE REGISTERED SIGN */ +#define XK_macron 0x00af /* U+00AF MACRON */ +#define XK_degree 0x00b0 /* U+00B0 DEGREE SIGN */ +#define XK_plusminus 0x00b1 /* U+00B1 PLUS-MINUS SIGN */ +#define XK_twosuperior 0x00b2 /* U+00B2 SUPERSCRIPT TWO */ +#define XK_threesuperior 0x00b3 /* U+00B3 SUPERSCRIPT THREE */ +#define XK_acute 0x00b4 /* U+00B4 ACUTE ACCENT */ +#define XK_mu 0x00b5 /* U+00B5 MICRO SIGN */ +#define XK_paragraph 0x00b6 /* U+00B6 PILCROW SIGN */ +#define XK_periodcentered 0x00b7 /* U+00B7 MIDDLE DOT */ +#define XK_cedilla 0x00b8 /* U+00B8 CEDILLA */ +#define XK_onesuperior 0x00b9 /* U+00B9 SUPERSCRIPT ONE */ +#define XK_masculine 0x00ba /* deprecated alias for ordmasculine (inconsistent name) */ +#define XK_ordmasculine 0x00ba /* U+00BA MASCULINE ORDINAL INDICATOR */ +#define XK_guillemotright 0x00bb /* deprecated alias for guillemetright (misspelling) */ +#define XK_guillemetright 0x00bb /* U+00BB RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK */ +#define XK_onequarter 0x00bc /* U+00BC VULGAR FRACTION ONE QUARTER */ +#define XK_onehalf 0x00bd /* U+00BD VULGAR FRACTION ONE HALF */ +#define XK_threequarters 0x00be /* U+00BE VULGAR FRACTION THREE QUARTERS */ +#define XK_questiondown 0x00bf /* U+00BF INVERTED QUESTION MARK */ +#define XK_Agrave 0x00c0 /* U+00C0 LATIN CAPITAL LETTER A WITH GRAVE */ +#define XK_Aacute 0x00c1 /* U+00C1 LATIN CAPITAL LETTER A WITH ACUTE */ +#define XK_Acircumflex 0x00c2 /* U+00C2 LATIN CAPITAL LETTER A WITH CIRCUMFLEX */ +#define XK_Atilde 0x00c3 /* U+00C3 LATIN CAPITAL LETTER A WITH TILDE */ +#define XK_Adiaeresis 0x00c4 /* U+00C4 LATIN CAPITAL LETTER A WITH DIAERESIS */ +#define XK_Aring 0x00c5 /* U+00C5 LATIN CAPITAL LETTER A WITH RING ABOVE */ +#define XK_AE 0x00c6 /* U+00C6 LATIN CAPITAL LETTER AE */ +#define XK_Ccedilla 0x00c7 /* U+00C7 LATIN CAPITAL LETTER C WITH CEDILLA */ +#define XK_Egrave 0x00c8 /* U+00C8 LATIN CAPITAL LETTER E WITH GRAVE */ +#define XK_Eacute 0x00c9 /* U+00C9 LATIN CAPITAL LETTER E WITH ACUTE */ +#define XK_Ecircumflex 0x00ca /* U+00CA LATIN CAPITAL LETTER E WITH CIRCUMFLEX */ +#define XK_Ediaeresis 0x00cb /* U+00CB LATIN CAPITAL LETTER E WITH DIAERESIS */ +#define XK_Igrave 0x00cc /* U+00CC LATIN CAPITAL LETTER I WITH GRAVE */ +#define XK_Iacute 0x00cd /* U+00CD LATIN CAPITAL LETTER I WITH ACUTE */ +#define XK_Icircumflex 0x00ce /* U+00CE LATIN CAPITAL LETTER I WITH CIRCUMFLEX */ +#define XK_Idiaeresis 0x00cf /* U+00CF LATIN CAPITAL LETTER I WITH DIAERESIS */ +#define XK_ETH 0x00d0 /* U+00D0 LATIN CAPITAL LETTER ETH */ +#define XK_Eth 0x00d0 /* deprecated */ +#define XK_Ntilde 0x00d1 /* U+00D1 LATIN CAPITAL LETTER N WITH TILDE */ +#define XK_Ograve 0x00d2 /* U+00D2 LATIN CAPITAL LETTER O WITH GRAVE */ +#define XK_Oacute 0x00d3 /* U+00D3 LATIN CAPITAL LETTER O WITH ACUTE */ +#define XK_Ocircumflex 0x00d4 /* U+00D4 LATIN CAPITAL LETTER O WITH CIRCUMFLEX */ +#define XK_Otilde 0x00d5 /* U+00D5 LATIN CAPITAL LETTER O WITH TILDE */ +#define XK_Odiaeresis 0x00d6 /* U+00D6 LATIN CAPITAL LETTER O WITH DIAERESIS */ +#define XK_multiply 0x00d7 /* U+00D7 MULTIPLICATION SIGN */ +#define XK_Oslash 0x00d8 /* U+00D8 LATIN CAPITAL LETTER O WITH STROKE */ +#define XK_Ooblique 0x00d8 /* deprecated alias for Oslash */ +#define XK_Ugrave 0x00d9 /* U+00D9 LATIN CAPITAL LETTER U WITH GRAVE */ +#define XK_Uacute 0x00da /* U+00DA LATIN CAPITAL LETTER U WITH ACUTE */ +#define XK_Ucircumflex 0x00db /* U+00DB LATIN CAPITAL LETTER U WITH CIRCUMFLEX */ +#define XK_Udiaeresis 0x00dc /* U+00DC LATIN CAPITAL LETTER U WITH DIAERESIS */ +#define XK_Yacute 0x00dd /* U+00DD LATIN CAPITAL LETTER Y WITH ACUTE */ +#define XK_THORN 0x00de /* U+00DE LATIN CAPITAL LETTER THORN */ +#define XK_Thorn 0x00de /* deprecated */ +#define XK_ssharp 0x00df /* U+00DF LATIN SMALL LETTER SHARP S */ +#define XK_agrave 0x00e0 /* U+00E0 LATIN SMALL LETTER A WITH GRAVE */ +#define XK_aacute 0x00e1 /* U+00E1 LATIN SMALL LETTER A WITH ACUTE */ +#define XK_acircumflex 0x00e2 /* U+00E2 LATIN SMALL LETTER A WITH CIRCUMFLEX */ +#define XK_atilde 0x00e3 /* U+00E3 LATIN SMALL LETTER A WITH TILDE */ +#define XK_adiaeresis 0x00e4 /* U+00E4 LATIN SMALL LETTER A WITH DIAERESIS */ +#define XK_aring 0x00e5 /* U+00E5 LATIN SMALL LETTER A WITH RING ABOVE */ +#define XK_ae 0x00e6 /* U+00E6 LATIN SMALL LETTER AE */ +#define XK_ccedilla 0x00e7 /* U+00E7 LATIN SMALL LETTER C WITH CEDILLA */ +#define XK_egrave 0x00e8 /* U+00E8 LATIN SMALL LETTER E WITH GRAVE */ +#define XK_eacute 0x00e9 /* U+00E9 LATIN SMALL LETTER E WITH ACUTE */ +#define XK_ecircumflex 0x00ea /* U+00EA LATIN SMALL LETTER E WITH CIRCUMFLEX */ +#define XK_ediaeresis 0x00eb /* U+00EB LATIN SMALL LETTER E WITH DIAERESIS */ +#define XK_igrave 0x00ec /* U+00EC LATIN SMALL LETTER I WITH GRAVE */ +#define XK_iacute 0x00ed /* U+00ED LATIN SMALL LETTER I WITH ACUTE */ +#define XK_icircumflex 0x00ee /* U+00EE LATIN SMALL LETTER I WITH CIRCUMFLEX */ +#define XK_idiaeresis 0x00ef /* U+00EF LATIN SMALL LETTER I WITH DIAERESIS */ +#define XK_eth 0x00f0 /* U+00F0 LATIN SMALL LETTER ETH */ +#define XK_ntilde 0x00f1 /* U+00F1 LATIN SMALL LETTER N WITH TILDE */ +#define XK_ograve 0x00f2 /* U+00F2 LATIN SMALL LETTER O WITH GRAVE */ +#define XK_oacute 0x00f3 /* U+00F3 LATIN SMALL LETTER O WITH ACUTE */ +#define XK_ocircumflex 0x00f4 /* U+00F4 LATIN SMALL LETTER O WITH CIRCUMFLEX */ +#define XK_otilde 0x00f5 /* U+00F5 LATIN SMALL LETTER O WITH TILDE */ +#define XK_odiaeresis 0x00f6 /* U+00F6 LATIN SMALL LETTER O WITH DIAERESIS */ +#define XK_division 0x00f7 /* U+00F7 DIVISION SIGN */ +#define XK_oslash 0x00f8 /* U+00F8 LATIN SMALL LETTER O WITH STROKE */ +#define XK_ooblique 0x00f8 /* deprecated alias for oslash */ +#define XK_ugrave 0x00f9 /* U+00F9 LATIN SMALL LETTER U WITH GRAVE */ +#define XK_uacute 0x00fa /* U+00FA LATIN SMALL LETTER U WITH ACUTE */ +#define XK_ucircumflex 0x00fb /* U+00FB LATIN SMALL LETTER U WITH CIRCUMFLEX */ +#define XK_udiaeresis 0x00fc /* U+00FC LATIN SMALL LETTER U WITH DIAERESIS */ +#define XK_yacute 0x00fd /* U+00FD LATIN SMALL LETTER Y WITH ACUTE */ +#define XK_thorn 0x00fe /* U+00FE LATIN SMALL LETTER THORN */ +#define XK_ydiaeresis 0x00ff /* U+00FF LATIN SMALL LETTER Y WITH DIAERESIS */ +#endif /* XK_LATIN1 */ + +/* + * Latin 2 + * Byte 3 = 1 + */ + +#ifdef XK_LATIN2 +#define XK_Aogonek 0x01a1 /* U+0104 LATIN CAPITAL LETTER A WITH OGONEK */ +#define XK_breve 0x01a2 /* U+02D8 BREVE */ +#define XK_Lstroke 0x01a3 /* U+0141 LATIN CAPITAL LETTER L WITH STROKE */ +#define XK_Lcaron 0x01a5 /* U+013D LATIN CAPITAL LETTER L WITH CARON */ +#define XK_Sacute 0x01a6 /* U+015A LATIN CAPITAL LETTER S WITH ACUTE */ +#define XK_Scaron 0x01a9 /* U+0160 LATIN CAPITAL LETTER S WITH CARON */ +#define XK_Scedilla 0x01aa /* U+015E LATIN CAPITAL LETTER S WITH CEDILLA */ +#define XK_Tcaron 0x01ab /* U+0164 LATIN CAPITAL LETTER T WITH CARON */ +#define XK_Zacute 0x01ac /* U+0179 LATIN CAPITAL LETTER Z WITH ACUTE */ +#define XK_Zcaron 0x01ae /* U+017D LATIN CAPITAL LETTER Z WITH CARON */ +#define XK_Zabovedot 0x01af /* U+017B LATIN CAPITAL LETTER Z WITH DOT ABOVE */ +#define XK_aogonek 0x01b1 /* U+0105 LATIN SMALL LETTER A WITH OGONEK */ +#define XK_ogonek 0x01b2 /* U+02DB OGONEK */ +#define XK_lstroke 0x01b3 /* U+0142 LATIN SMALL LETTER L WITH STROKE */ +#define XK_lcaron 0x01b5 /* U+013E LATIN SMALL LETTER L WITH CARON */ +#define XK_sacute 0x01b6 /* U+015B LATIN SMALL LETTER S WITH ACUTE */ +#define XK_caron 0x01b7 /* U+02C7 CARON */ +#define XK_scaron 0x01b9 /* U+0161 LATIN SMALL LETTER S WITH CARON */ +#define XK_scedilla 0x01ba /* U+015F LATIN SMALL LETTER S WITH CEDILLA */ +#define XK_tcaron 0x01bb /* U+0165 LATIN SMALL LETTER T WITH CARON */ +#define XK_zacute 0x01bc /* U+017A LATIN SMALL LETTER Z WITH ACUTE */ +#define XK_doubleacute 0x01bd /* U+02DD DOUBLE ACUTE ACCENT */ +#define XK_zcaron 0x01be /* U+017E LATIN SMALL LETTER Z WITH CARON */ +#define XK_zabovedot 0x01bf /* U+017C LATIN SMALL LETTER Z WITH DOT ABOVE */ +#define XK_Racute 0x01c0 /* U+0154 LATIN CAPITAL LETTER R WITH ACUTE */ +#define XK_Abreve 0x01c3 /* U+0102 LATIN CAPITAL LETTER A WITH BREVE */ +#define XK_Lacute 0x01c5 /* U+0139 LATIN CAPITAL LETTER L WITH ACUTE */ +#define XK_Cacute 0x01c6 /* U+0106 LATIN CAPITAL LETTER C WITH ACUTE */ +#define XK_Ccaron 0x01c8 /* U+010C LATIN CAPITAL LETTER C WITH CARON */ +#define XK_Eogonek 0x01ca /* U+0118 LATIN CAPITAL LETTER E WITH OGONEK */ +#define XK_Ecaron 0x01cc /* U+011A LATIN CAPITAL LETTER E WITH CARON */ +#define XK_Dcaron 0x01cf /* U+010E LATIN CAPITAL LETTER D WITH CARON */ +#define XK_Dstroke 0x01d0 /* U+0110 LATIN CAPITAL LETTER D WITH STROKE */ +#define XK_Nacute 0x01d1 /* U+0143 LATIN CAPITAL LETTER N WITH ACUTE */ +#define XK_Ncaron 0x01d2 /* U+0147 LATIN CAPITAL LETTER N WITH CARON */ +#define XK_Odoubleacute 0x01d5 /* U+0150 LATIN CAPITAL LETTER O WITH DOUBLE ACUTE */ +#define XK_Rcaron 0x01d8 /* U+0158 LATIN CAPITAL LETTER R WITH CARON */ +#define XK_Uring 0x01d9 /* U+016E LATIN CAPITAL LETTER U WITH RING ABOVE */ +#define XK_Udoubleacute 0x01db /* U+0170 LATIN CAPITAL LETTER U WITH DOUBLE ACUTE */ +#define XK_Tcedilla 0x01de /* U+0162 LATIN CAPITAL LETTER T WITH CEDILLA */ +#define XK_racute 0x01e0 /* U+0155 LATIN SMALL LETTER R WITH ACUTE */ +#define XK_abreve 0x01e3 /* U+0103 LATIN SMALL LETTER A WITH BREVE */ +#define XK_lacute 0x01e5 /* U+013A LATIN SMALL LETTER L WITH ACUTE */ +#define XK_cacute 0x01e6 /* U+0107 LATIN SMALL LETTER C WITH ACUTE */ +#define XK_ccaron 0x01e8 /* U+010D LATIN SMALL LETTER C WITH CARON */ +#define XK_eogonek 0x01ea /* U+0119 LATIN SMALL LETTER E WITH OGONEK */ +#define XK_ecaron 0x01ec /* U+011B LATIN SMALL LETTER E WITH CARON */ +#define XK_dcaron 0x01ef /* U+010F LATIN SMALL LETTER D WITH CARON */ +#define XK_dstroke 0x01f0 /* U+0111 LATIN SMALL LETTER D WITH STROKE */ +#define XK_nacute 0x01f1 /* U+0144 LATIN SMALL LETTER N WITH ACUTE */ +#define XK_ncaron 0x01f2 /* U+0148 LATIN SMALL LETTER N WITH CARON */ +#define XK_odoubleacute 0x01f5 /* U+0151 LATIN SMALL LETTER O WITH DOUBLE ACUTE */ +#define XK_rcaron 0x01f8 /* U+0159 LATIN SMALL LETTER R WITH CARON */ +#define XK_uring 0x01f9 /* U+016F LATIN SMALL LETTER U WITH RING ABOVE */ +#define XK_udoubleacute 0x01fb /* U+0171 LATIN SMALL LETTER U WITH DOUBLE ACUTE */ +#define XK_tcedilla 0x01fe /* U+0163 LATIN SMALL LETTER T WITH CEDILLA */ +#define XK_abovedot 0x01ff /* U+02D9 DOT ABOVE */ +#endif /* XK_LATIN2 */ + +/* + * Latin 3 + * Byte 3 = 2 + */ + +#ifdef XK_LATIN3 +#define XK_Hstroke 0x02a1 /* U+0126 LATIN CAPITAL LETTER H WITH STROKE */ +#define XK_Hcircumflex 0x02a6 /* U+0124 LATIN CAPITAL LETTER H WITH CIRCUMFLEX */ +#define XK_Iabovedot 0x02a9 /* U+0130 LATIN CAPITAL LETTER I WITH DOT ABOVE */ +#define XK_Gbreve 0x02ab /* U+011E LATIN CAPITAL LETTER G WITH BREVE */ +#define XK_Jcircumflex 0x02ac /* U+0134 LATIN CAPITAL LETTER J WITH CIRCUMFLEX */ +#define XK_hstroke 0x02b1 /* U+0127 LATIN SMALL LETTER H WITH STROKE */ +#define XK_hcircumflex 0x02b6 /* U+0125 LATIN SMALL LETTER H WITH CIRCUMFLEX */ +#define XK_idotless 0x02b9 /* U+0131 LATIN SMALL LETTER DOTLESS I */ +#define XK_gbreve 0x02bb /* U+011F LATIN SMALL LETTER G WITH BREVE */ +#define XK_jcircumflex 0x02bc /* U+0135 LATIN SMALL LETTER J WITH CIRCUMFLEX */ +#define XK_Cabovedot 0x02c5 /* U+010A LATIN CAPITAL LETTER C WITH DOT ABOVE */ +#define XK_Ccircumflex 0x02c6 /* U+0108 LATIN CAPITAL LETTER C WITH CIRCUMFLEX */ +#define XK_Gabovedot 0x02d5 /* U+0120 LATIN CAPITAL LETTER G WITH DOT ABOVE */ +#define XK_Gcircumflex 0x02d8 /* U+011C LATIN CAPITAL LETTER G WITH CIRCUMFLEX */ +#define XK_Ubreve 0x02dd /* U+016C LATIN CAPITAL LETTER U WITH BREVE */ +#define XK_Scircumflex 0x02de /* U+015C LATIN CAPITAL LETTER S WITH CIRCUMFLEX */ +#define XK_cabovedot 0x02e5 /* U+010B LATIN SMALL LETTER C WITH DOT ABOVE */ +#define XK_ccircumflex 0x02e6 /* U+0109 LATIN SMALL LETTER C WITH CIRCUMFLEX */ +#define XK_gabovedot 0x02f5 /* U+0121 LATIN SMALL LETTER G WITH DOT ABOVE */ +#define XK_gcircumflex 0x02f8 /* U+011D LATIN SMALL LETTER G WITH CIRCUMFLEX */ +#define XK_ubreve 0x02fd /* U+016D LATIN SMALL LETTER U WITH BREVE */ +#define XK_scircumflex 0x02fe /* U+015D LATIN SMALL LETTER S WITH CIRCUMFLEX */ +#endif /* XK_LATIN3 */ + + +/* + * Latin 4 + * Byte 3 = 3 + */ + +#ifdef XK_LATIN4 +#define XK_kra 0x03a2 /* U+0138 LATIN SMALL LETTER KRA */ +#define XK_kappa 0x03a2 /* deprecated */ +#define XK_Rcedilla 0x03a3 /* U+0156 LATIN CAPITAL LETTER R WITH CEDILLA */ +#define XK_Itilde 0x03a5 /* U+0128 LATIN CAPITAL LETTER I WITH TILDE */ +#define XK_Lcedilla 0x03a6 /* U+013B LATIN CAPITAL LETTER L WITH CEDILLA */ +#define XK_Emacron 0x03aa /* U+0112 LATIN CAPITAL LETTER E WITH MACRON */ +#define XK_Gcedilla 0x03ab /* U+0122 LATIN CAPITAL LETTER G WITH CEDILLA */ +#define XK_Tslash 0x03ac /* U+0166 LATIN CAPITAL LETTER T WITH STROKE */ +#define XK_rcedilla 0x03b3 /* U+0157 LATIN SMALL LETTER R WITH CEDILLA */ +#define XK_itilde 0x03b5 /* U+0129 LATIN SMALL LETTER I WITH TILDE */ +#define XK_lcedilla 0x03b6 /* U+013C LATIN SMALL LETTER L WITH CEDILLA */ +#define XK_emacron 0x03ba /* U+0113 LATIN SMALL LETTER E WITH MACRON */ +#define XK_gcedilla 0x03bb /* U+0123 LATIN SMALL LETTER G WITH CEDILLA */ +#define XK_tslash 0x03bc /* U+0167 LATIN SMALL LETTER T WITH STROKE */ +#define XK_ENG 0x03bd /* U+014A LATIN CAPITAL LETTER ENG */ +#define XK_eng 0x03bf /* U+014B LATIN SMALL LETTER ENG */ +#define XK_Amacron 0x03c0 /* U+0100 LATIN CAPITAL LETTER A WITH MACRON */ +#define XK_Iogonek 0x03c7 /* U+012E LATIN CAPITAL LETTER I WITH OGONEK */ +#define XK_Eabovedot 0x03cc /* U+0116 LATIN CAPITAL LETTER E WITH DOT ABOVE */ +#define XK_Imacron 0x03cf /* U+012A LATIN CAPITAL LETTER I WITH MACRON */ +#define XK_Ncedilla 0x03d1 /* U+0145 LATIN CAPITAL LETTER N WITH CEDILLA */ +#define XK_Omacron 0x03d2 /* U+014C LATIN CAPITAL LETTER O WITH MACRON */ +#define XK_Kcedilla 0x03d3 /* U+0136 LATIN CAPITAL LETTER K WITH CEDILLA */ +#define XK_Uogonek 0x03d9 /* U+0172 LATIN CAPITAL LETTER U WITH OGONEK */ +#define XK_Utilde 0x03dd /* U+0168 LATIN CAPITAL LETTER U WITH TILDE */ +#define XK_Umacron 0x03de /* U+016A LATIN CAPITAL LETTER U WITH MACRON */ +#define XK_amacron 0x03e0 /* U+0101 LATIN SMALL LETTER A WITH MACRON */ +#define XK_iogonek 0x03e7 /* U+012F LATIN SMALL LETTER I WITH OGONEK */ +#define XK_eabovedot 0x03ec /* U+0117 LATIN SMALL LETTER E WITH DOT ABOVE */ +#define XK_imacron 0x03ef /* U+012B LATIN SMALL LETTER I WITH MACRON */ +#define XK_ncedilla 0x03f1 /* U+0146 LATIN SMALL LETTER N WITH CEDILLA */ +#define XK_omacron 0x03f2 /* U+014D LATIN SMALL LETTER O WITH MACRON */ +#define XK_kcedilla 0x03f3 /* U+0137 LATIN SMALL LETTER K WITH CEDILLA */ +#define XK_uogonek 0x03f9 /* U+0173 LATIN SMALL LETTER U WITH OGONEK */ +#define XK_utilde 0x03fd /* U+0169 LATIN SMALL LETTER U WITH TILDE */ +#define XK_umacron 0x03fe /* U+016B LATIN SMALL LETTER U WITH MACRON */ +#endif /* XK_LATIN4 */ + +/* + * Latin 8 + */ +#ifdef XK_LATIN8 +#define XK_Wcircumflex 0x1000174 /* U+0174 LATIN CAPITAL LETTER W WITH CIRCUMFLEX */ +#define XK_wcircumflex 0x1000175 /* U+0175 LATIN SMALL LETTER W WITH CIRCUMFLEX */ +#define XK_Ycircumflex 0x1000176 /* U+0176 LATIN CAPITAL LETTER Y WITH CIRCUMFLEX */ +#define XK_ycircumflex 0x1000177 /* U+0177 LATIN SMALL LETTER Y WITH CIRCUMFLEX */ +#define XK_Babovedot 0x1001e02 /* U+1E02 LATIN CAPITAL LETTER B WITH DOT ABOVE */ +#define XK_babovedot 0x1001e03 /* U+1E03 LATIN SMALL LETTER B WITH DOT ABOVE */ +#define XK_Dabovedot 0x1001e0a /* U+1E0A LATIN CAPITAL LETTER D WITH DOT ABOVE */ +#define XK_dabovedot 0x1001e0b /* U+1E0B LATIN SMALL LETTER D WITH DOT ABOVE */ +#define XK_Fabovedot 0x1001e1e /* U+1E1E LATIN CAPITAL LETTER F WITH DOT ABOVE */ +#define XK_fabovedot 0x1001e1f /* U+1E1F LATIN SMALL LETTER F WITH DOT ABOVE */ +#define XK_Mabovedot 0x1001e40 /* U+1E40 LATIN CAPITAL LETTER M WITH DOT ABOVE */ +#define XK_mabovedot 0x1001e41 /* U+1E41 LATIN SMALL LETTER M WITH DOT ABOVE */ +#define XK_Pabovedot 0x1001e56 /* U+1E56 LATIN CAPITAL LETTER P WITH DOT ABOVE */ +#define XK_pabovedot 0x1001e57 /* U+1E57 LATIN SMALL LETTER P WITH DOT ABOVE */ +#define XK_Sabovedot 0x1001e60 /* U+1E60 LATIN CAPITAL LETTER S WITH DOT ABOVE */ +#define XK_sabovedot 0x1001e61 /* U+1E61 LATIN SMALL LETTER S WITH DOT ABOVE */ +#define XK_Tabovedot 0x1001e6a /* U+1E6A LATIN CAPITAL LETTER T WITH DOT ABOVE */ +#define XK_tabovedot 0x1001e6b /* U+1E6B LATIN SMALL LETTER T WITH DOT ABOVE */ +#define XK_Wgrave 0x1001e80 /* U+1E80 LATIN CAPITAL LETTER W WITH GRAVE */ +#define XK_wgrave 0x1001e81 /* U+1E81 LATIN SMALL LETTER W WITH GRAVE */ +#define XK_Wacute 0x1001e82 /* U+1E82 LATIN CAPITAL LETTER W WITH ACUTE */ +#define XK_wacute 0x1001e83 /* U+1E83 LATIN SMALL LETTER W WITH ACUTE */ +#define XK_Wdiaeresis 0x1001e84 /* U+1E84 LATIN CAPITAL LETTER W WITH DIAERESIS */ +#define XK_wdiaeresis 0x1001e85 /* U+1E85 LATIN SMALL LETTER W WITH DIAERESIS */ +#define XK_Ygrave 0x1001ef2 /* U+1EF2 LATIN CAPITAL LETTER Y WITH GRAVE */ +#define XK_ygrave 0x1001ef3 /* U+1EF3 LATIN SMALL LETTER Y WITH GRAVE */ +#endif /* XK_LATIN8 */ + +/* + * Latin 9 + * Byte 3 = 0x13 + */ + +#ifdef XK_LATIN9 +#define XK_OE 0x13bc /* U+0152 LATIN CAPITAL LIGATURE OE */ +#define XK_oe 0x13bd /* U+0153 LATIN SMALL LIGATURE OE */ +#define XK_Ydiaeresis 0x13be /* U+0178 LATIN CAPITAL LETTER Y WITH DIAERESIS */ +#endif /* XK_LATIN9 */ + +/* + * Katakana + * Byte 3 = 4 + */ + +#ifdef XK_KATAKANA +#define XK_overline 0x047e /* U+203E OVERLINE */ +#define XK_kana_fullstop 0x04a1 /* U+3002 IDEOGRAPHIC FULL STOP */ +#define XK_kana_openingbracket 0x04a2 /* U+300C LEFT CORNER BRACKET */ +#define XK_kana_closingbracket 0x04a3 /* U+300D RIGHT CORNER BRACKET */ +#define XK_kana_comma 0x04a4 /* U+3001 IDEOGRAPHIC COMMA */ +#define XK_kana_conjunctive 0x04a5 /* U+30FB KATAKANA MIDDLE DOT */ +#define XK_kana_middledot 0x04a5 /* deprecated */ +#define XK_kana_WO 0x04a6 /* U+30F2 KATAKANA LETTER WO */ +#define XK_kana_a 0x04a7 /* U+30A1 KATAKANA LETTER SMALL A */ +#define XK_kana_i 0x04a8 /* U+30A3 KATAKANA LETTER SMALL I */ +#define XK_kana_u 0x04a9 /* U+30A5 KATAKANA LETTER SMALL U */ +#define XK_kana_e 0x04aa /* U+30A7 KATAKANA LETTER SMALL E */ +#define XK_kana_o 0x04ab /* U+30A9 KATAKANA LETTER SMALL O */ +#define XK_kana_ya 0x04ac /* U+30E3 KATAKANA LETTER SMALL YA */ +#define XK_kana_yu 0x04ad /* U+30E5 KATAKANA LETTER SMALL YU */ +#define XK_kana_yo 0x04ae /* U+30E7 KATAKANA LETTER SMALL YO */ +#define XK_kana_tsu 0x04af /* U+30C3 KATAKANA LETTER SMALL TU */ +#define XK_kana_tu 0x04af /* deprecated */ +#define XK_prolongedsound 0x04b0 /* U+30FC KATAKANA-HIRAGANA PROLONGED SOUND MARK */ +#define XK_kana_A 0x04b1 /* U+30A2 KATAKANA LETTER A */ +#define XK_kana_I 0x04b2 /* U+30A4 KATAKANA LETTER I */ +#define XK_kana_U 0x04b3 /* U+30A6 KATAKANA LETTER U */ +#define XK_kana_E 0x04b4 /* U+30A8 KATAKANA LETTER E */ +#define XK_kana_O 0x04b5 /* U+30AA KATAKANA LETTER O */ +#define XK_kana_KA 0x04b6 /* U+30AB KATAKANA LETTER KA */ +#define XK_kana_KI 0x04b7 /* U+30AD KATAKANA LETTER KI */ +#define XK_kana_KU 0x04b8 /* U+30AF KATAKANA LETTER KU */ +#define XK_kana_KE 0x04b9 /* U+30B1 KATAKANA LETTER KE */ +#define XK_kana_KO 0x04ba /* U+30B3 KATAKANA LETTER KO */ +#define XK_kana_SA 0x04bb /* U+30B5 KATAKANA LETTER SA */ +#define XK_kana_SHI 0x04bc /* U+30B7 KATAKANA LETTER SI */ +#define XK_kana_SU 0x04bd /* U+30B9 KATAKANA LETTER SU */ +#define XK_kana_SE 0x04be /* U+30BB KATAKANA LETTER SE */ +#define XK_kana_SO 0x04bf /* U+30BD KATAKANA LETTER SO */ +#define XK_kana_TA 0x04c0 /* U+30BF KATAKANA LETTER TA */ +#define XK_kana_CHI 0x04c1 /* U+30C1 KATAKANA LETTER TI */ +#define XK_kana_TI 0x04c1 /* deprecated */ +#define XK_kana_TSU 0x04c2 /* U+30C4 KATAKANA LETTER TU */ +#define XK_kana_TU 0x04c2 /* deprecated */ +#define XK_kana_TE 0x04c3 /* U+30C6 KATAKANA LETTER TE */ +#define XK_kana_TO 0x04c4 /* U+30C8 KATAKANA LETTER TO */ +#define XK_kana_NA 0x04c5 /* U+30CA KATAKANA LETTER NA */ +#define XK_kana_NI 0x04c6 /* U+30CB KATAKANA LETTER NI */ +#define XK_kana_NU 0x04c7 /* U+30CC KATAKANA LETTER NU */ +#define XK_kana_NE 0x04c8 /* U+30CD KATAKANA LETTER NE */ +#define XK_kana_NO 0x04c9 /* U+30CE KATAKANA LETTER NO */ +#define XK_kana_HA 0x04ca /* U+30CF KATAKANA LETTER HA */ +#define XK_kana_HI 0x04cb /* U+30D2 KATAKANA LETTER HI */ +#define XK_kana_FU 0x04cc /* U+30D5 KATAKANA LETTER HU */ +#define XK_kana_HU 0x04cc /* deprecated */ +#define XK_kana_HE 0x04cd /* U+30D8 KATAKANA LETTER HE */ +#define XK_kana_HO 0x04ce /* U+30DB KATAKANA LETTER HO */ +#define XK_kana_MA 0x04cf /* U+30DE KATAKANA LETTER MA */ +#define XK_kana_MI 0x04d0 /* U+30DF KATAKANA LETTER MI */ +#define XK_kana_MU 0x04d1 /* U+30E0 KATAKANA LETTER MU */ +#define XK_kana_ME 0x04d2 /* U+30E1 KATAKANA LETTER ME */ +#define XK_kana_MO 0x04d3 /* U+30E2 KATAKANA LETTER MO */ +#define XK_kana_YA 0x04d4 /* U+30E4 KATAKANA LETTER YA */ +#define XK_kana_YU 0x04d5 /* U+30E6 KATAKANA LETTER YU */ +#define XK_kana_YO 0x04d6 /* U+30E8 KATAKANA LETTER YO */ +#define XK_kana_RA 0x04d7 /* U+30E9 KATAKANA LETTER RA */ +#define XK_kana_RI 0x04d8 /* U+30EA KATAKANA LETTER RI */ +#define XK_kana_RU 0x04d9 /* U+30EB KATAKANA LETTER RU */ +#define XK_kana_RE 0x04da /* U+30EC KATAKANA LETTER RE */ +#define XK_kana_RO 0x04db /* U+30ED KATAKANA LETTER RO */ +#define XK_kana_WA 0x04dc /* U+30EF KATAKANA LETTER WA */ +#define XK_kana_N 0x04dd /* U+30F3 KATAKANA LETTER N */ +#define XK_voicedsound 0x04de /* U+309B KATAKANA-HIRAGANA VOICED SOUND MARK */ +#define XK_semivoicedsound 0x04df /* U+309C KATAKANA-HIRAGANA SEMI-VOICED SOUND MARK */ +#define XK_kana_switch 0xff7e /* non-deprecated alias for Mode_switch */ +#endif /* XK_KATAKANA */ + +/* + * Arabic + * Byte 3 = 5 + */ + +#ifdef XK_ARABIC +#define XK_Farsi_0 0x10006f0 /* U+06F0 EXTENDED ARABIC-INDIC DIGIT ZERO */ +#define XK_Farsi_1 0x10006f1 /* U+06F1 EXTENDED ARABIC-INDIC DIGIT ONE */ +#define XK_Farsi_2 0x10006f2 /* U+06F2 EXTENDED ARABIC-INDIC DIGIT TWO */ +#define XK_Farsi_3 0x10006f3 /* U+06F3 EXTENDED ARABIC-INDIC DIGIT THREE */ +#define XK_Farsi_4 0x10006f4 /* U+06F4 EXTENDED ARABIC-INDIC DIGIT FOUR */ +#define XK_Farsi_5 0x10006f5 /* U+06F5 EXTENDED ARABIC-INDIC DIGIT FIVE */ +#define XK_Farsi_6 0x10006f6 /* U+06F6 EXTENDED ARABIC-INDIC DIGIT SIX */ +#define XK_Farsi_7 0x10006f7 /* U+06F7 EXTENDED ARABIC-INDIC DIGIT SEVEN */ +#define XK_Farsi_8 0x10006f8 /* U+06F8 EXTENDED ARABIC-INDIC DIGIT EIGHT */ +#define XK_Farsi_9 0x10006f9 /* U+06F9 EXTENDED ARABIC-INDIC DIGIT NINE */ +#define XK_Arabic_percent 0x100066a /* U+066A ARABIC PERCENT SIGN */ +#define XK_Arabic_superscript_alef 0x1000670 /* U+0670 ARABIC LETTER SUPERSCRIPT ALEF */ +#define XK_Arabic_tteh 0x1000679 /* U+0679 ARABIC LETTER TTEH */ +#define XK_Arabic_peh 0x100067e /* U+067E ARABIC LETTER PEH */ +#define XK_Arabic_tcheh 0x1000686 /* U+0686 ARABIC LETTER TCHEH */ +#define XK_Arabic_ddal 0x1000688 /* U+0688 ARABIC LETTER DDAL */ +#define XK_Arabic_rreh 0x1000691 /* U+0691 ARABIC LETTER RREH */ +#define XK_Arabic_comma 0x05ac /* U+060C ARABIC COMMA */ +#define XK_Arabic_fullstop 0x10006d4 /* U+06D4 ARABIC FULL STOP */ +#define XK_Arabic_0 0x1000660 /* U+0660 ARABIC-INDIC DIGIT ZERO */ +#define XK_Arabic_1 0x1000661 /* U+0661 ARABIC-INDIC DIGIT ONE */ +#define XK_Arabic_2 0x1000662 /* U+0662 ARABIC-INDIC DIGIT TWO */ +#define XK_Arabic_3 0x1000663 /* U+0663 ARABIC-INDIC DIGIT THREE */ +#define XK_Arabic_4 0x1000664 /* U+0664 ARABIC-INDIC DIGIT FOUR */ +#define XK_Arabic_5 0x1000665 /* U+0665 ARABIC-INDIC DIGIT FIVE */ +#define XK_Arabic_6 0x1000666 /* U+0666 ARABIC-INDIC DIGIT SIX */ +#define XK_Arabic_7 0x1000667 /* U+0667 ARABIC-INDIC DIGIT SEVEN */ +#define XK_Arabic_8 0x1000668 /* U+0668 ARABIC-INDIC DIGIT EIGHT */ +#define XK_Arabic_9 0x1000669 /* U+0669 ARABIC-INDIC DIGIT NINE */ +#define XK_Arabic_semicolon 0x05bb /* U+061B ARABIC SEMICOLON */ +#define XK_Arabic_question_mark 0x05bf /* U+061F ARABIC QUESTION MARK */ +#define XK_Arabic_hamza 0x05c1 /* U+0621 ARABIC LETTER HAMZA */ +#define XK_Arabic_maddaonalef 0x05c2 /* U+0622 ARABIC LETTER ALEF WITH MADDA ABOVE */ +#define XK_Arabic_hamzaonalef 0x05c3 /* U+0623 ARABIC LETTER ALEF WITH HAMZA ABOVE */ +#define XK_Arabic_hamzaonwaw 0x05c4 /* U+0624 ARABIC LETTER WAW WITH HAMZA ABOVE */ +#define XK_Arabic_hamzaunderalef 0x05c5 /* U+0625 ARABIC LETTER ALEF WITH HAMZA BELOW */ +#define XK_Arabic_hamzaonyeh 0x05c6 /* U+0626 ARABIC LETTER YEH WITH HAMZA ABOVE */ +#define XK_Arabic_alef 0x05c7 /* U+0627 ARABIC LETTER ALEF */ +#define XK_Arabic_beh 0x05c8 /* U+0628 ARABIC LETTER BEH */ +#define XK_Arabic_tehmarbuta 0x05c9 /* U+0629 ARABIC LETTER TEH MARBUTA */ +#define XK_Arabic_teh 0x05ca /* U+062A ARABIC LETTER TEH */ +#define XK_Arabic_theh 0x05cb /* U+062B ARABIC LETTER THEH */ +#define XK_Arabic_jeem 0x05cc /* U+062C ARABIC LETTER JEEM */ +#define XK_Arabic_hah 0x05cd /* U+062D ARABIC LETTER HAH */ +#define XK_Arabic_khah 0x05ce /* U+062E ARABIC LETTER KHAH */ +#define XK_Arabic_dal 0x05cf /* U+062F ARABIC LETTER DAL */ +#define XK_Arabic_thal 0x05d0 /* U+0630 ARABIC LETTER THAL */ +#define XK_Arabic_ra 0x05d1 /* U+0631 ARABIC LETTER REH */ +#define XK_Arabic_zain 0x05d2 /* U+0632 ARABIC LETTER ZAIN */ +#define XK_Arabic_seen 0x05d3 /* U+0633 ARABIC LETTER SEEN */ +#define XK_Arabic_sheen 0x05d4 /* U+0634 ARABIC LETTER SHEEN */ +#define XK_Arabic_sad 0x05d5 /* U+0635 ARABIC LETTER SAD */ +#define XK_Arabic_dad 0x05d6 /* U+0636 ARABIC LETTER DAD */ +#define XK_Arabic_tah 0x05d7 /* U+0637 ARABIC LETTER TAH */ +#define XK_Arabic_zah 0x05d8 /* U+0638 ARABIC LETTER ZAH */ +#define XK_Arabic_ain 0x05d9 /* U+0639 ARABIC LETTER AIN */ +#define XK_Arabic_ghain 0x05da /* U+063A ARABIC LETTER GHAIN */ +#define XK_Arabic_tatweel 0x05e0 /* U+0640 ARABIC TATWEEL */ +#define XK_Arabic_feh 0x05e1 /* U+0641 ARABIC LETTER FEH */ +#define XK_Arabic_qaf 0x05e2 /* U+0642 ARABIC LETTER QAF */ +#define XK_Arabic_kaf 0x05e3 /* U+0643 ARABIC LETTER KAF */ +#define XK_Arabic_lam 0x05e4 /* U+0644 ARABIC LETTER LAM */ +#define XK_Arabic_meem 0x05e5 /* U+0645 ARABIC LETTER MEEM */ +#define XK_Arabic_noon 0x05e6 /* U+0646 ARABIC LETTER NOON */ +#define XK_Arabic_ha 0x05e7 /* U+0647 ARABIC LETTER HEH */ +#define XK_Arabic_heh 0x05e7 /* deprecated */ +#define XK_Arabic_waw 0x05e8 /* U+0648 ARABIC LETTER WAW */ +#define XK_Arabic_alefmaksura 0x05e9 /* U+0649 ARABIC LETTER ALEF MAKSURA */ +#define XK_Arabic_yeh 0x05ea /* U+064A ARABIC LETTER YEH */ +#define XK_Arabic_fathatan 0x05eb /* U+064B ARABIC FATHATAN */ +#define XK_Arabic_dammatan 0x05ec /* U+064C ARABIC DAMMATAN */ +#define XK_Arabic_kasratan 0x05ed /* U+064D ARABIC KASRATAN */ +#define XK_Arabic_fatha 0x05ee /* U+064E ARABIC FATHA */ +#define XK_Arabic_damma 0x05ef /* U+064F ARABIC DAMMA */ +#define XK_Arabic_kasra 0x05f0 /* U+0650 ARABIC KASRA */ +#define XK_Arabic_shadda 0x05f1 /* U+0651 ARABIC SHADDA */ +#define XK_Arabic_sukun 0x05f2 /* U+0652 ARABIC SUKUN */ +#define XK_Arabic_madda_above 0x1000653 /* U+0653 ARABIC MADDAH ABOVE */ +#define XK_Arabic_hamza_above 0x1000654 /* U+0654 ARABIC HAMZA ABOVE */ +#define XK_Arabic_hamza_below 0x1000655 /* U+0655 ARABIC HAMZA BELOW */ +#define XK_Arabic_jeh 0x1000698 /* U+0698 ARABIC LETTER JEH */ +#define XK_Arabic_veh 0x10006a4 /* U+06A4 ARABIC LETTER VEH */ +#define XK_Arabic_keheh 0x10006a9 /* U+06A9 ARABIC LETTER KEHEH */ +#define XK_Arabic_gaf 0x10006af /* U+06AF ARABIC LETTER GAF */ +#define XK_Arabic_noon_ghunna 0x10006ba /* U+06BA ARABIC LETTER NOON GHUNNA */ +#define XK_Arabic_heh_doachashmee 0x10006be /* U+06BE ARABIC LETTER HEH DOACHASHMEE */ +#define XK_Farsi_yeh 0x10006cc /* U+06CC ARABIC LETTER FARSI YEH */ +#define XK_Arabic_farsi_yeh 0x10006cc /* deprecated alias for Farsi_yeh */ +#define XK_Arabic_yeh_baree 0x10006d2 /* U+06D2 ARABIC LETTER YEH BARREE */ +#define XK_Arabic_heh_goal 0x10006c1 /* U+06C1 ARABIC LETTER HEH GOAL */ +#define XK_Arabic_switch 0xff7e /* non-deprecated alias for Mode_switch */ +#endif /* XK_ARABIC */ + +/* + * Cyrillic + * Byte 3 = 6 + */ +#ifdef XK_CYRILLIC +#define XK_Cyrillic_GHE_bar 0x1000492 /* U+0492 CYRILLIC CAPITAL LETTER GHE WITH STROKE */ +#define XK_Cyrillic_ghe_bar 0x1000493 /* U+0493 CYRILLIC SMALL LETTER GHE WITH STROKE */ +#define XK_Cyrillic_ZHE_descender 0x1000496 /* U+0496 CYRILLIC CAPITAL LETTER ZHE WITH DESCENDER */ +#define XK_Cyrillic_zhe_descender 0x1000497 /* U+0497 CYRILLIC SMALL LETTER ZHE WITH DESCENDER */ +#define XK_Cyrillic_KA_descender 0x100049a /* U+049A CYRILLIC CAPITAL LETTER KA WITH DESCENDER */ +#define XK_Cyrillic_ka_descender 0x100049b /* U+049B CYRILLIC SMALL LETTER KA WITH DESCENDER */ +#define XK_Cyrillic_KA_vertstroke 0x100049c /* U+049C CYRILLIC CAPITAL LETTER KA WITH VERTICAL STROKE */ +#define XK_Cyrillic_ka_vertstroke 0x100049d /* U+049D CYRILLIC SMALL LETTER KA WITH VERTICAL STROKE */ +#define XK_Cyrillic_EN_descender 0x10004a2 /* U+04A2 CYRILLIC CAPITAL LETTER EN WITH DESCENDER */ +#define XK_Cyrillic_en_descender 0x10004a3 /* U+04A3 CYRILLIC SMALL LETTER EN WITH DESCENDER */ +#define XK_Cyrillic_U_straight 0x10004ae /* U+04AE CYRILLIC CAPITAL LETTER STRAIGHT U */ +#define XK_Cyrillic_u_straight 0x10004af /* U+04AF CYRILLIC SMALL LETTER STRAIGHT U */ +#define XK_Cyrillic_U_straight_bar 0x10004b0 /* U+04B0 CYRILLIC CAPITAL LETTER STRAIGHT U WITH STROKE */ +#define XK_Cyrillic_u_straight_bar 0x10004b1 /* U+04B1 CYRILLIC SMALL LETTER STRAIGHT U WITH STROKE */ +#define XK_Cyrillic_HA_descender 0x10004b2 /* U+04B2 CYRILLIC CAPITAL LETTER HA WITH DESCENDER */ +#define XK_Cyrillic_ha_descender 0x10004b3 /* U+04B3 CYRILLIC SMALL LETTER HA WITH DESCENDER */ +#define XK_Cyrillic_CHE_descender 0x10004b6 /* U+04B6 CYRILLIC CAPITAL LETTER CHE WITH DESCENDER */ +#define XK_Cyrillic_che_descender 0x10004b7 /* U+04B7 CYRILLIC SMALL LETTER CHE WITH DESCENDER */ +#define XK_Cyrillic_CHE_vertstroke 0x10004b8 /* U+04B8 CYRILLIC CAPITAL LETTER CHE WITH VERTICAL STROKE */ +#define XK_Cyrillic_che_vertstroke 0x10004b9 /* U+04B9 CYRILLIC SMALL LETTER CHE WITH VERTICAL STROKE */ +#define XK_Cyrillic_SHHA 0x10004ba /* U+04BA CYRILLIC CAPITAL LETTER SHHA */ +#define XK_Cyrillic_shha 0x10004bb /* U+04BB CYRILLIC SMALL LETTER SHHA */ + +#define XK_Cyrillic_SCHWA 0x10004d8 /* U+04D8 CYRILLIC CAPITAL LETTER SCHWA */ +#define XK_Cyrillic_schwa 0x10004d9 /* U+04D9 CYRILLIC SMALL LETTER SCHWA */ +#define XK_Cyrillic_I_macron 0x10004e2 /* U+04E2 CYRILLIC CAPITAL LETTER I WITH MACRON */ +#define XK_Cyrillic_i_macron 0x10004e3 /* U+04E3 CYRILLIC SMALL LETTER I WITH MACRON */ +#define XK_Cyrillic_O_bar 0x10004e8 /* U+04E8 CYRILLIC CAPITAL LETTER BARRED O */ +#define XK_Cyrillic_o_bar 0x10004e9 /* U+04E9 CYRILLIC SMALL LETTER BARRED O */ +#define XK_Cyrillic_U_macron 0x10004ee /* U+04EE CYRILLIC CAPITAL LETTER U WITH MACRON */ +#define XK_Cyrillic_u_macron 0x10004ef /* U+04EF CYRILLIC SMALL LETTER U WITH MACRON */ + +#define XK_Serbian_dje 0x06a1 /* U+0452 CYRILLIC SMALL LETTER DJE */ +#define XK_Macedonia_gje 0x06a2 /* U+0453 CYRILLIC SMALL LETTER GJE */ +#define XK_Cyrillic_io 0x06a3 /* U+0451 CYRILLIC SMALL LETTER IO */ +#define XK_Ukrainian_ie 0x06a4 /* U+0454 CYRILLIC SMALL LETTER UKRAINIAN IE */ +#define XK_Ukranian_je 0x06a4 /* deprecated */ +#define XK_Macedonia_dse 0x06a5 /* U+0455 CYRILLIC SMALL LETTER DZE */ +#define XK_Ukrainian_i 0x06a6 /* U+0456 CYRILLIC SMALL LETTER BYELORUSSIAN-UKRAINIAN I */ +#define XK_Ukranian_i 0x06a6 /* deprecated */ +#define XK_Ukrainian_yi 0x06a7 /* U+0457 CYRILLIC SMALL LETTER YI */ +#define XK_Ukranian_yi 0x06a7 /* deprecated */ +#define XK_Cyrillic_je 0x06a8 /* U+0458 CYRILLIC SMALL LETTER JE */ +#define XK_Serbian_je 0x06a8 /* deprecated */ +#define XK_Cyrillic_lje 0x06a9 /* U+0459 CYRILLIC SMALL LETTER LJE */ +#define XK_Serbian_lje 0x06a9 /* deprecated */ +#define XK_Cyrillic_nje 0x06aa /* U+045A CYRILLIC SMALL LETTER NJE */ +#define XK_Serbian_nje 0x06aa /* deprecated */ +#define XK_Serbian_tshe 0x06ab /* U+045B CYRILLIC SMALL LETTER TSHE */ +#define XK_Macedonia_kje 0x06ac /* U+045C CYRILLIC SMALL LETTER KJE */ +#define XK_Ukrainian_ghe_with_upturn 0x06ad /* U+0491 CYRILLIC SMALL LETTER GHE WITH UPTURN */ +#define XK_Byelorussian_shortu 0x06ae /* U+045E CYRILLIC SMALL LETTER SHORT U */ +#define XK_Cyrillic_dzhe 0x06af /* U+045F CYRILLIC SMALL LETTER DZHE */ +#define XK_Serbian_dze 0x06af /* deprecated */ +#define XK_numerosign 0x06b0 /* U+2116 NUMERO SIGN */ +#define XK_Serbian_DJE 0x06b1 /* U+0402 CYRILLIC CAPITAL LETTER DJE */ +#define XK_Macedonia_GJE 0x06b2 /* U+0403 CYRILLIC CAPITAL LETTER GJE */ +#define XK_Cyrillic_IO 0x06b3 /* U+0401 CYRILLIC CAPITAL LETTER IO */ +#define XK_Ukrainian_IE 0x06b4 /* U+0404 CYRILLIC CAPITAL LETTER UKRAINIAN IE */ +#define XK_Ukranian_JE 0x06b4 /* deprecated */ +#define XK_Macedonia_DSE 0x06b5 /* U+0405 CYRILLIC CAPITAL LETTER DZE */ +#define XK_Ukrainian_I 0x06b6 /* U+0406 CYRILLIC CAPITAL LETTER BYELORUSSIAN-UKRAINIAN I */ +#define XK_Ukranian_I 0x06b6 /* deprecated */ +#define XK_Ukrainian_YI 0x06b7 /* U+0407 CYRILLIC CAPITAL LETTER YI */ +#define XK_Ukranian_YI 0x06b7 /* deprecated */ +#define XK_Cyrillic_JE 0x06b8 /* U+0408 CYRILLIC CAPITAL LETTER JE */ +#define XK_Serbian_JE 0x06b8 /* deprecated */ +#define XK_Cyrillic_LJE 0x06b9 /* U+0409 CYRILLIC CAPITAL LETTER LJE */ +#define XK_Serbian_LJE 0x06b9 /* deprecated */ +#define XK_Cyrillic_NJE 0x06ba /* U+040A CYRILLIC CAPITAL LETTER NJE */ +#define XK_Serbian_NJE 0x06ba /* deprecated */ +#define XK_Serbian_TSHE 0x06bb /* U+040B CYRILLIC CAPITAL LETTER TSHE */ +#define XK_Macedonia_KJE 0x06bc /* U+040C CYRILLIC CAPITAL LETTER KJE */ +#define XK_Ukrainian_GHE_WITH_UPTURN 0x06bd /* U+0490 CYRILLIC CAPITAL LETTER GHE WITH UPTURN */ +#define XK_Byelorussian_SHORTU 0x06be /* U+040E CYRILLIC CAPITAL LETTER SHORT U */ +#define XK_Cyrillic_DZHE 0x06bf /* U+040F CYRILLIC CAPITAL LETTER DZHE */ +#define XK_Serbian_DZE 0x06bf /* deprecated */ +#define XK_Cyrillic_yu 0x06c0 /* U+044E CYRILLIC SMALL LETTER YU */ +#define XK_Cyrillic_a 0x06c1 /* U+0430 CYRILLIC SMALL LETTER A */ +#define XK_Cyrillic_be 0x06c2 /* U+0431 CYRILLIC SMALL LETTER BE */ +#define XK_Cyrillic_tse 0x06c3 /* U+0446 CYRILLIC SMALL LETTER TSE */ +#define XK_Cyrillic_de 0x06c4 /* U+0434 CYRILLIC SMALL LETTER DE */ +#define XK_Cyrillic_ie 0x06c5 /* U+0435 CYRILLIC SMALL LETTER IE */ +#define XK_Cyrillic_ef 0x06c6 /* U+0444 CYRILLIC SMALL LETTER EF */ +#define XK_Cyrillic_ghe 0x06c7 /* U+0433 CYRILLIC SMALL LETTER GHE */ +#define XK_Cyrillic_ha 0x06c8 /* U+0445 CYRILLIC SMALL LETTER HA */ +#define XK_Cyrillic_i 0x06c9 /* U+0438 CYRILLIC SMALL LETTER I */ +#define XK_Cyrillic_shorti 0x06ca /* U+0439 CYRILLIC SMALL LETTER SHORT I */ +#define XK_Cyrillic_ka 0x06cb /* U+043A CYRILLIC SMALL LETTER KA */ +#define XK_Cyrillic_el 0x06cc /* U+043B CYRILLIC SMALL LETTER EL */ +#define XK_Cyrillic_em 0x06cd /* U+043C CYRILLIC SMALL LETTER EM */ +#define XK_Cyrillic_en 0x06ce /* U+043D CYRILLIC SMALL LETTER EN */ +#define XK_Cyrillic_o 0x06cf /* U+043E CYRILLIC SMALL LETTER O */ +#define XK_Cyrillic_pe 0x06d0 /* U+043F CYRILLIC SMALL LETTER PE */ +#define XK_Cyrillic_ya 0x06d1 /* U+044F CYRILLIC SMALL LETTER YA */ +#define XK_Cyrillic_er 0x06d2 /* U+0440 CYRILLIC SMALL LETTER ER */ +#define XK_Cyrillic_es 0x06d3 /* U+0441 CYRILLIC SMALL LETTER ES */ +#define XK_Cyrillic_te 0x06d4 /* U+0442 CYRILLIC SMALL LETTER TE */ +#define XK_Cyrillic_u 0x06d5 /* U+0443 CYRILLIC SMALL LETTER U */ +#define XK_Cyrillic_zhe 0x06d6 /* U+0436 CYRILLIC SMALL LETTER ZHE */ +#define XK_Cyrillic_ve 0x06d7 /* U+0432 CYRILLIC SMALL LETTER VE */ +#define XK_Cyrillic_softsign 0x06d8 /* U+044C CYRILLIC SMALL LETTER SOFT SIGN */ +#define XK_Cyrillic_yeru 0x06d9 /* U+044B CYRILLIC SMALL LETTER YERU */ +#define XK_Cyrillic_ze 0x06da /* U+0437 CYRILLIC SMALL LETTER ZE */ +#define XK_Cyrillic_sha 0x06db /* U+0448 CYRILLIC SMALL LETTER SHA */ +#define XK_Cyrillic_e 0x06dc /* U+044D CYRILLIC SMALL LETTER E */ +#define XK_Cyrillic_shcha 0x06dd /* U+0449 CYRILLIC SMALL LETTER SHCHA */ +#define XK_Cyrillic_che 0x06de /* U+0447 CYRILLIC SMALL LETTER CHE */ +#define XK_Cyrillic_hardsign 0x06df /* U+044A CYRILLIC SMALL LETTER HARD SIGN */ +#define XK_Cyrillic_YU 0x06e0 /* U+042E CYRILLIC CAPITAL LETTER YU */ +#define XK_Cyrillic_A 0x06e1 /* U+0410 CYRILLIC CAPITAL LETTER A */ +#define XK_Cyrillic_BE 0x06e2 /* U+0411 CYRILLIC CAPITAL LETTER BE */ +#define XK_Cyrillic_TSE 0x06e3 /* U+0426 CYRILLIC CAPITAL LETTER TSE */ +#define XK_Cyrillic_DE 0x06e4 /* U+0414 CYRILLIC CAPITAL LETTER DE */ +#define XK_Cyrillic_IE 0x06e5 /* U+0415 CYRILLIC CAPITAL LETTER IE */ +#define XK_Cyrillic_EF 0x06e6 /* U+0424 CYRILLIC CAPITAL LETTER EF */ +#define XK_Cyrillic_GHE 0x06e7 /* U+0413 CYRILLIC CAPITAL LETTER GHE */ +#define XK_Cyrillic_HA 0x06e8 /* U+0425 CYRILLIC CAPITAL LETTER HA */ +#define XK_Cyrillic_I 0x06e9 /* U+0418 CYRILLIC CAPITAL LETTER I */ +#define XK_Cyrillic_SHORTI 0x06ea /* U+0419 CYRILLIC CAPITAL LETTER SHORT I */ +#define XK_Cyrillic_KA 0x06eb /* U+041A CYRILLIC CAPITAL LETTER KA */ +#define XK_Cyrillic_EL 0x06ec /* U+041B CYRILLIC CAPITAL LETTER EL */ +#define XK_Cyrillic_EM 0x06ed /* U+041C CYRILLIC CAPITAL LETTER EM */ +#define XK_Cyrillic_EN 0x06ee /* U+041D CYRILLIC CAPITAL LETTER EN */ +#define XK_Cyrillic_O 0x06ef /* U+041E CYRILLIC CAPITAL LETTER O */ +#define XK_Cyrillic_PE 0x06f0 /* U+041F CYRILLIC CAPITAL LETTER PE */ +#define XK_Cyrillic_YA 0x06f1 /* U+042F CYRILLIC CAPITAL LETTER YA */ +#define XK_Cyrillic_ER 0x06f2 /* U+0420 CYRILLIC CAPITAL LETTER ER */ +#define XK_Cyrillic_ES 0x06f3 /* U+0421 CYRILLIC CAPITAL LETTER ES */ +#define XK_Cyrillic_TE 0x06f4 /* U+0422 CYRILLIC CAPITAL LETTER TE */ +#define XK_Cyrillic_U 0x06f5 /* U+0423 CYRILLIC CAPITAL LETTER U */ +#define XK_Cyrillic_ZHE 0x06f6 /* U+0416 CYRILLIC CAPITAL LETTER ZHE */ +#define XK_Cyrillic_VE 0x06f7 /* U+0412 CYRILLIC CAPITAL LETTER VE */ +#define XK_Cyrillic_SOFTSIGN 0x06f8 /* U+042C CYRILLIC CAPITAL LETTER SOFT SIGN */ +#define XK_Cyrillic_YERU 0x06f9 /* U+042B CYRILLIC CAPITAL LETTER YERU */ +#define XK_Cyrillic_ZE 0x06fa /* U+0417 CYRILLIC CAPITAL LETTER ZE */ +#define XK_Cyrillic_SHA 0x06fb /* U+0428 CYRILLIC CAPITAL LETTER SHA */ +#define XK_Cyrillic_E 0x06fc /* U+042D CYRILLIC CAPITAL LETTER E */ +#define XK_Cyrillic_SHCHA 0x06fd /* U+0429 CYRILLIC CAPITAL LETTER SHCHA */ +#define XK_Cyrillic_CHE 0x06fe /* U+0427 CYRILLIC CAPITAL LETTER CHE */ +#define XK_Cyrillic_HARDSIGN 0x06ff /* U+042A CYRILLIC CAPITAL LETTER HARD SIGN */ +#endif /* XK_CYRILLIC */ + +/* + * Greek + * (based on an early draft of, and not quite identical to, ISO/IEC 8859-7) + * Byte 3 = 7 + */ + +#ifdef XK_GREEK +#define XK_Greek_ALPHAaccent 0x07a1 /* U+0386 GREEK CAPITAL LETTER ALPHA WITH TONOS */ +#define XK_Greek_EPSILONaccent 0x07a2 /* U+0388 GREEK CAPITAL LETTER EPSILON WITH TONOS */ +#define XK_Greek_ETAaccent 0x07a3 /* U+0389 GREEK CAPITAL LETTER ETA WITH TONOS */ +#define XK_Greek_IOTAaccent 0x07a4 /* U+038A GREEK CAPITAL LETTER IOTA WITH TONOS */ +#define XK_Greek_IOTAdieresis 0x07a5 /* U+03AA GREEK CAPITAL LETTER IOTA WITH DIALYTIKA */ +#define XK_Greek_IOTAdiaeresis 0x07a5 /* deprecated (old typo) */ +#define XK_Greek_OMICRONaccent 0x07a7 /* U+038C GREEK CAPITAL LETTER OMICRON WITH TONOS */ +#define XK_Greek_UPSILONaccent 0x07a8 /* U+038E GREEK CAPITAL LETTER UPSILON WITH TONOS */ +#define XK_Greek_UPSILONdieresis 0x07a9 /* U+03AB GREEK CAPITAL LETTER UPSILON WITH DIALYTIKA */ +#define XK_Greek_OMEGAaccent 0x07ab /* U+038F GREEK CAPITAL LETTER OMEGA WITH TONOS */ +#define XK_Greek_accentdieresis 0x07ae /* U+0385 GREEK DIALYTIKA TONOS */ +#define XK_Greek_horizbar 0x07af /* U+2015 HORIZONTAL BAR */ +#define XK_Greek_alphaaccent 0x07b1 /* U+03AC GREEK SMALL LETTER ALPHA WITH TONOS */ +#define XK_Greek_epsilonaccent 0x07b2 /* U+03AD GREEK SMALL LETTER EPSILON WITH TONOS */ +#define XK_Greek_etaaccent 0x07b3 /* U+03AE GREEK SMALL LETTER ETA WITH TONOS */ +#define XK_Greek_iotaaccent 0x07b4 /* U+03AF GREEK SMALL LETTER IOTA WITH TONOS */ +#define XK_Greek_iotadieresis 0x07b5 /* U+03CA GREEK SMALL LETTER IOTA WITH DIALYTIKA */ +#define XK_Greek_iotaaccentdieresis 0x07b6 /* U+0390 GREEK SMALL LETTER IOTA WITH DIALYTIKA AND TONOS */ +#define XK_Greek_omicronaccent 0x07b7 /* U+03CC GREEK SMALL LETTER OMICRON WITH TONOS */ +#define XK_Greek_upsilonaccent 0x07b8 /* U+03CD GREEK SMALL LETTER UPSILON WITH TONOS */ +#define XK_Greek_upsilondieresis 0x07b9 /* U+03CB GREEK SMALL LETTER UPSILON WITH DIALYTIKA */ +#define XK_Greek_upsilonaccentdieresis 0x07ba /* U+03B0 GREEK SMALL LETTER UPSILON WITH DIALYTIKA AND TONOS */ +#define XK_Greek_omegaaccent 0x07bb /* U+03CE GREEK SMALL LETTER OMEGA WITH TONOS */ +#define XK_Greek_ALPHA 0x07c1 /* U+0391 GREEK CAPITAL LETTER ALPHA */ +#define XK_Greek_BETA 0x07c2 /* U+0392 GREEK CAPITAL LETTER BETA */ +#define XK_Greek_GAMMA 0x07c3 /* U+0393 GREEK CAPITAL LETTER GAMMA */ +#define XK_Greek_DELTA 0x07c4 /* U+0394 GREEK CAPITAL LETTER DELTA */ +#define XK_Greek_EPSILON 0x07c5 /* U+0395 GREEK CAPITAL LETTER EPSILON */ +#define XK_Greek_ZETA 0x07c6 /* U+0396 GREEK CAPITAL LETTER ZETA */ +#define XK_Greek_ETA 0x07c7 /* U+0397 GREEK CAPITAL LETTER ETA */ +#define XK_Greek_THETA 0x07c8 /* U+0398 GREEK CAPITAL LETTER THETA */ +#define XK_Greek_IOTA 0x07c9 /* U+0399 GREEK CAPITAL LETTER IOTA */ +#define XK_Greek_KAPPA 0x07ca /* U+039A GREEK CAPITAL LETTER KAPPA */ +#define XK_Greek_LAMDA 0x07cb /* U+039B GREEK CAPITAL LETTER LAMDA */ +#define XK_Greek_LAMBDA 0x07cb /* non-deprecated alias for Greek_LAMDA */ +#define XK_Greek_MU 0x07cc /* U+039C GREEK CAPITAL LETTER MU */ +#define XK_Greek_NU 0x07cd /* U+039D GREEK CAPITAL LETTER NU */ +#define XK_Greek_XI 0x07ce /* U+039E GREEK CAPITAL LETTER XI */ +#define XK_Greek_OMICRON 0x07cf /* U+039F GREEK CAPITAL LETTER OMICRON */ +#define XK_Greek_PI 0x07d0 /* U+03A0 GREEK CAPITAL LETTER PI */ +#define XK_Greek_RHO 0x07d1 /* U+03A1 GREEK CAPITAL LETTER RHO */ +#define XK_Greek_SIGMA 0x07d2 /* U+03A3 GREEK CAPITAL LETTER SIGMA */ +#define XK_Greek_TAU 0x07d4 /* U+03A4 GREEK CAPITAL LETTER TAU */ +#define XK_Greek_UPSILON 0x07d5 /* U+03A5 GREEK CAPITAL LETTER UPSILON */ +#define XK_Greek_PHI 0x07d6 /* U+03A6 GREEK CAPITAL LETTER PHI */ +#define XK_Greek_CHI 0x07d7 /* U+03A7 GREEK CAPITAL LETTER CHI */ +#define XK_Greek_PSI 0x07d8 /* U+03A8 GREEK CAPITAL LETTER PSI */ +#define XK_Greek_OMEGA 0x07d9 /* U+03A9 GREEK CAPITAL LETTER OMEGA */ +#define XK_Greek_alpha 0x07e1 /* U+03B1 GREEK SMALL LETTER ALPHA */ +#define XK_Greek_beta 0x07e2 /* U+03B2 GREEK SMALL LETTER BETA */ +#define XK_Greek_gamma 0x07e3 /* U+03B3 GREEK SMALL LETTER GAMMA */ +#define XK_Greek_delta 0x07e4 /* U+03B4 GREEK SMALL LETTER DELTA */ +#define XK_Greek_epsilon 0x07e5 /* U+03B5 GREEK SMALL LETTER EPSILON */ +#define XK_Greek_zeta 0x07e6 /* U+03B6 GREEK SMALL LETTER ZETA */ +#define XK_Greek_eta 0x07e7 /* U+03B7 GREEK SMALL LETTER ETA */ +#define XK_Greek_theta 0x07e8 /* U+03B8 GREEK SMALL LETTER THETA */ +#define XK_Greek_iota 0x07e9 /* U+03B9 GREEK SMALL LETTER IOTA */ +#define XK_Greek_kappa 0x07ea /* U+03BA GREEK SMALL LETTER KAPPA */ +#define XK_Greek_lamda 0x07eb /* U+03BB GREEK SMALL LETTER LAMDA */ +#define XK_Greek_lambda 0x07eb /* non-deprecated alias for Greek_lamda */ +#define XK_Greek_mu 0x07ec /* U+03BC GREEK SMALL LETTER MU */ +#define XK_Greek_nu 0x07ed /* U+03BD GREEK SMALL LETTER NU */ +#define XK_Greek_xi 0x07ee /* U+03BE GREEK SMALL LETTER XI */ +#define XK_Greek_omicron 0x07ef /* U+03BF GREEK SMALL LETTER OMICRON */ +#define XK_Greek_pi 0x07f0 /* U+03C0 GREEK SMALL LETTER PI */ +#define XK_Greek_rho 0x07f1 /* U+03C1 GREEK SMALL LETTER RHO */ +#define XK_Greek_sigma 0x07f2 /* U+03C3 GREEK SMALL LETTER SIGMA */ +#define XK_Greek_finalsmallsigma 0x07f3 /* U+03C2 GREEK SMALL LETTER FINAL SIGMA */ +#define XK_Greek_tau 0x07f4 /* U+03C4 GREEK SMALL LETTER TAU */ +#define XK_Greek_upsilon 0x07f5 /* U+03C5 GREEK SMALL LETTER UPSILON */ +#define XK_Greek_phi 0x07f6 /* U+03C6 GREEK SMALL LETTER PHI */ +#define XK_Greek_chi 0x07f7 /* U+03C7 GREEK SMALL LETTER CHI */ +#define XK_Greek_psi 0x07f8 /* U+03C8 GREEK SMALL LETTER PSI */ +#define XK_Greek_omega 0x07f9 /* U+03C9 GREEK SMALL LETTER OMEGA */ +#define XK_Greek_switch 0xff7e /* non-deprecated alias for Mode_switch */ +#endif /* XK_GREEK */ + +/* + * Technical + * (from the DEC VT330/VT420 Technical Character Set, http://vt100.net/charsets/technical.html) + * Byte 3 = 8 + */ + +#ifdef XK_TECHNICAL +#define XK_leftradical 0x08a1 /* U+23B7 RADICAL SYMBOL BOTTOM */ +#define XK_topleftradical 0x08a2 /*(U+250C BOX DRAWINGS LIGHT DOWN AND RIGHT)*/ +#define XK_horizconnector 0x08a3 /*(U+2500 BOX DRAWINGS LIGHT HORIZONTAL)*/ +#define XK_topintegral 0x08a4 /* U+2320 TOP HALF INTEGRAL */ +#define XK_botintegral 0x08a5 /* U+2321 BOTTOM HALF INTEGRAL */ +#define XK_vertconnector 0x08a6 /*(U+2502 BOX DRAWINGS LIGHT VERTICAL)*/ +#define XK_topleftsqbracket 0x08a7 /* U+23A1 LEFT SQUARE BRACKET UPPER CORNER */ +#define XK_botleftsqbracket 0x08a8 /* U+23A3 LEFT SQUARE BRACKET LOWER CORNER */ +#define XK_toprightsqbracket 0x08a9 /* U+23A4 RIGHT SQUARE BRACKET UPPER CORNER */ +#define XK_botrightsqbracket 0x08aa /* U+23A6 RIGHT SQUARE BRACKET LOWER CORNER */ +#define XK_topleftparens 0x08ab /* U+239B LEFT PARENTHESIS UPPER HOOK */ +#define XK_botleftparens 0x08ac /* U+239D LEFT PARENTHESIS LOWER HOOK */ +#define XK_toprightparens 0x08ad /* U+239E RIGHT PARENTHESIS UPPER HOOK */ +#define XK_botrightparens 0x08ae /* U+23A0 RIGHT PARENTHESIS LOWER HOOK */ +#define XK_leftmiddlecurlybrace 0x08af /* U+23A8 LEFT CURLY BRACKET MIDDLE PIECE */ +#define XK_rightmiddlecurlybrace 0x08b0 /* U+23AC RIGHT CURLY BRACKET MIDDLE PIECE */ +#define XK_topleftsummation 0x08b1 +#define XK_botleftsummation 0x08b2 +#define XK_topvertsummationconnector 0x08b3 +#define XK_botvertsummationconnector 0x08b4 +#define XK_toprightsummation 0x08b5 +#define XK_botrightsummation 0x08b6 +#define XK_rightmiddlesummation 0x08b7 +#define XK_lessthanequal 0x08bc /* U+2264 LESS-THAN OR EQUAL TO */ +#define XK_notequal 0x08bd /* U+2260 NOT EQUAL TO */ +#define XK_greaterthanequal 0x08be /* U+2265 GREATER-THAN OR EQUAL TO */ +#define XK_integral 0x08bf /* U+222B INTEGRAL */ +#define XK_therefore 0x08c0 /* U+2234 THEREFORE */ +#define XK_variation 0x08c1 /* U+221D PROPORTIONAL TO */ +#define XK_infinity 0x08c2 /* U+221E INFINITY */ +#define XK_nabla 0x08c5 /* U+2207 NABLA */ +#define XK_approximate 0x08c8 /* U+223C TILDE OPERATOR */ +#define XK_similarequal 0x08c9 /* U+2243 ASYMPTOTICALLY EQUAL TO */ +#define XK_ifonlyif 0x08cd /* U+21D4 LEFT RIGHT DOUBLE ARROW */ +#define XK_implies 0x08ce /* U+21D2 RIGHTWARDS DOUBLE ARROW */ +#define XK_identical 0x08cf /* U+2261 IDENTICAL TO */ +#define XK_radical 0x08d6 /* U+221A SQUARE ROOT */ +#define XK_includedin 0x08da /* U+2282 SUBSET OF */ +#define XK_includes 0x08db /* U+2283 SUPERSET OF */ +#define XK_intersection 0x08dc /* U+2229 INTERSECTION */ +#define XK_union 0x08dd /* U+222A UNION */ +#define XK_logicaland 0x08de /* U+2227 LOGICAL AND */ +#define XK_logicalor 0x08df /* U+2228 LOGICAL OR */ +#define XK_partialderivative 0x08ef /* U+2202 PARTIAL DIFFERENTIAL */ +#define XK_function 0x08f6 /* U+0192 LATIN SMALL LETTER F WITH HOOK */ +#define XK_leftarrow 0x08fb /* U+2190 LEFTWARDS ARROW */ +#define XK_uparrow 0x08fc /* U+2191 UPWARDS ARROW */ +#define XK_rightarrow 0x08fd /* U+2192 RIGHTWARDS ARROW */ +#define XK_downarrow 0x08fe /* U+2193 DOWNWARDS ARROW */ +#endif /* XK_TECHNICAL */ + +/* + * Special + * (from the DEC VT100 Special Graphics Character Set) + * Byte 3 = 9 + */ + +#ifdef XK_SPECIAL +#define XK_blank 0x09df +#define XK_soliddiamond 0x09e0 /* U+25C6 BLACK DIAMOND */ +#define XK_checkerboard 0x09e1 /* U+2592 MEDIUM SHADE */ +#define XK_ht 0x09e2 /* U+2409 SYMBOL FOR HORIZONTAL TABULATION */ +#define XK_ff 0x09e3 /* U+240C SYMBOL FOR FORM FEED */ +#define XK_cr 0x09e4 /* U+240D SYMBOL FOR CARRIAGE RETURN */ +#define XK_lf 0x09e5 /* U+240A SYMBOL FOR LINE FEED */ +#define XK_nl 0x09e8 /* U+2424 SYMBOL FOR NEWLINE */ +#define XK_vt 0x09e9 /* U+240B SYMBOL FOR VERTICAL TABULATION */ +#define XK_lowrightcorner 0x09ea /* U+2518 BOX DRAWINGS LIGHT UP AND LEFT */ +#define XK_uprightcorner 0x09eb /* U+2510 BOX DRAWINGS LIGHT DOWN AND LEFT */ +#define XK_upleftcorner 0x09ec /* U+250C BOX DRAWINGS LIGHT DOWN AND RIGHT */ +#define XK_lowleftcorner 0x09ed /* U+2514 BOX DRAWINGS LIGHT UP AND RIGHT */ +#define XK_crossinglines 0x09ee /* U+253C BOX DRAWINGS LIGHT VERTICAL AND HORIZONTAL */ +#define XK_horizlinescan1 0x09ef /* U+23BA HORIZONTAL SCAN LINE-1 */ +#define XK_horizlinescan3 0x09f0 /* U+23BB HORIZONTAL SCAN LINE-3 */ +#define XK_horizlinescan5 0x09f1 /* U+2500 BOX DRAWINGS LIGHT HORIZONTAL */ +#define XK_horizlinescan7 0x09f2 /* U+23BC HORIZONTAL SCAN LINE-7 */ +#define XK_horizlinescan9 0x09f3 /* U+23BD HORIZONTAL SCAN LINE-9 */ +#define XK_leftt 0x09f4 /* U+251C BOX DRAWINGS LIGHT VERTICAL AND RIGHT */ +#define XK_rightt 0x09f5 /* U+2524 BOX DRAWINGS LIGHT VERTICAL AND LEFT */ +#define XK_bott 0x09f6 /* U+2534 BOX DRAWINGS LIGHT UP AND HORIZONTAL */ +#define XK_topt 0x09f7 /* U+252C BOX DRAWINGS LIGHT DOWN AND HORIZONTAL */ +#define XK_vertbar 0x09f8 /* U+2502 BOX DRAWINGS LIGHT VERTICAL */ +#endif /* XK_SPECIAL */ + +/* + * Publishing + * (these are probably from a long forgotten DEC Publishing + * font that once shipped with DECwrite) + * Byte 3 = 0x0a + */ + +#ifdef XK_PUBLISHING +#define XK_emspace 0x0aa1 /* U+2003 EM SPACE */ +#define XK_enspace 0x0aa2 /* U+2002 EN SPACE */ +#define XK_em3space 0x0aa3 /* U+2004 THREE-PER-EM SPACE */ +#define XK_em4space 0x0aa4 /* U+2005 FOUR-PER-EM SPACE */ +#define XK_digitspace 0x0aa5 /* U+2007 FIGURE SPACE */ +#define XK_punctspace 0x0aa6 /* U+2008 PUNCTUATION SPACE */ +#define XK_thinspace 0x0aa7 /* U+2009 THIN SPACE */ +#define XK_hairspace 0x0aa8 /* U+200A HAIR SPACE */ +#define XK_emdash 0x0aa9 /* U+2014 EM DASH */ +#define XK_endash 0x0aaa /* U+2013 EN DASH */ +#define XK_signifblank 0x0aac /*(U+2423 OPEN BOX)*/ +#define XK_ellipsis 0x0aae /* U+2026 HORIZONTAL ELLIPSIS */ +#define XK_doubbaselinedot 0x0aaf /* U+2025 TWO DOT LEADER */ +#define XK_onethird 0x0ab0 /* U+2153 VULGAR FRACTION ONE THIRD */ +#define XK_twothirds 0x0ab1 /* U+2154 VULGAR FRACTION TWO THIRDS */ +#define XK_onefifth 0x0ab2 /* U+2155 VULGAR FRACTION ONE FIFTH */ +#define XK_twofifths 0x0ab3 /* U+2156 VULGAR FRACTION TWO FIFTHS */ +#define XK_threefifths 0x0ab4 /* U+2157 VULGAR FRACTION THREE FIFTHS */ +#define XK_fourfifths 0x0ab5 /* U+2158 VULGAR FRACTION FOUR FIFTHS */ +#define XK_onesixth 0x0ab6 /* U+2159 VULGAR FRACTION ONE SIXTH */ +#define XK_fivesixths 0x0ab7 /* U+215A VULGAR FRACTION FIVE SIXTHS */ +#define XK_careof 0x0ab8 /* U+2105 CARE OF */ +#define XK_figdash 0x0abb /* U+2012 FIGURE DASH */ +#define XK_leftanglebracket 0x0abc /*(U+2329 LEFT-POINTING ANGLE BRACKET)*/ +#define XK_decimalpoint 0x0abd /*(U+002E FULL STOP)*/ +#define XK_rightanglebracket 0x0abe /*(U+232A RIGHT-POINTING ANGLE BRACKET)*/ +#define XK_marker 0x0abf +#define XK_oneeighth 0x0ac3 /* U+215B VULGAR FRACTION ONE EIGHTH */ +#define XK_threeeighths 0x0ac4 /* U+215C VULGAR FRACTION THREE EIGHTHS */ +#define XK_fiveeighths 0x0ac5 /* U+215D VULGAR FRACTION FIVE EIGHTHS */ +#define XK_seveneighths 0x0ac6 /* U+215E VULGAR FRACTION SEVEN EIGHTHS */ +#define XK_trademark 0x0ac9 /* U+2122 TRADE MARK SIGN */ +#define XK_signaturemark 0x0aca /*(U+2613 SALTIRE)*/ +#define XK_trademarkincircle 0x0acb +#define XK_leftopentriangle 0x0acc /*(U+25C1 WHITE LEFT-POINTING TRIANGLE)*/ +#define XK_rightopentriangle 0x0acd /*(U+25B7 WHITE RIGHT-POINTING TRIANGLE)*/ +#define XK_emopencircle 0x0ace /*(U+25CB WHITE CIRCLE)*/ +#define XK_emopenrectangle 0x0acf /*(U+25AF WHITE VERTICAL RECTANGLE)*/ +#define XK_leftsinglequotemark 0x0ad0 /* U+2018 LEFT SINGLE QUOTATION MARK */ +#define XK_rightsinglequotemark 0x0ad1 /* U+2019 RIGHT SINGLE QUOTATION MARK */ +#define XK_leftdoublequotemark 0x0ad2 /* U+201C LEFT DOUBLE QUOTATION MARK */ +#define XK_rightdoublequotemark 0x0ad3 /* U+201D RIGHT DOUBLE QUOTATION MARK */ +#define XK_prescription 0x0ad4 /* U+211E PRESCRIPTION TAKE */ +#define XK_permille 0x0ad5 /* U+2030 PER MILLE SIGN */ +#define XK_minutes 0x0ad6 /* U+2032 PRIME */ +#define XK_seconds 0x0ad7 /* U+2033 DOUBLE PRIME */ +#define XK_latincross 0x0ad9 /* U+271D LATIN CROSS */ +#define XK_hexagram 0x0ada +#define XK_filledrectbullet 0x0adb /*(U+25AC BLACK RECTANGLE)*/ +#define XK_filledlefttribullet 0x0adc /*(U+25C0 BLACK LEFT-POINTING TRIANGLE)*/ +#define XK_filledrighttribullet 0x0add /*(U+25B6 BLACK RIGHT-POINTING TRIANGLE)*/ +#define XK_emfilledcircle 0x0ade /*(U+25CF BLACK CIRCLE)*/ +#define XK_emfilledrect 0x0adf /*(U+25AE BLACK VERTICAL RECTANGLE)*/ +#define XK_enopencircbullet 0x0ae0 /*(U+25E6 WHITE BULLET)*/ +#define XK_enopensquarebullet 0x0ae1 /*(U+25AB WHITE SMALL SQUARE)*/ +#define XK_openrectbullet 0x0ae2 /*(U+25AD WHITE RECTANGLE)*/ +#define XK_opentribulletup 0x0ae3 /*(U+25B3 WHITE UP-POINTING TRIANGLE)*/ +#define XK_opentribulletdown 0x0ae4 /*(U+25BD WHITE DOWN-POINTING TRIANGLE)*/ +#define XK_openstar 0x0ae5 /*(U+2606 WHITE STAR)*/ +#define XK_enfilledcircbullet 0x0ae6 /*(U+2022 BULLET)*/ +#define XK_enfilledsqbullet 0x0ae7 /*(U+25AA BLACK SMALL SQUARE)*/ +#define XK_filledtribulletup 0x0ae8 /*(U+25B2 BLACK UP-POINTING TRIANGLE)*/ +#define XK_filledtribulletdown 0x0ae9 /*(U+25BC BLACK DOWN-POINTING TRIANGLE)*/ +#define XK_leftpointer 0x0aea /*(U+261C WHITE LEFT POINTING INDEX)*/ +#define XK_rightpointer 0x0aeb /*(U+261E WHITE RIGHT POINTING INDEX)*/ +#define XK_club 0x0aec /* U+2663 BLACK CLUB SUIT */ +#define XK_diamond 0x0aed /* U+2666 BLACK DIAMOND SUIT */ +#define XK_heart 0x0aee /* U+2665 BLACK HEART SUIT */ +#define XK_maltesecross 0x0af0 /* U+2720 MALTESE CROSS */ +#define XK_dagger 0x0af1 /* U+2020 DAGGER */ +#define XK_doubledagger 0x0af2 /* U+2021 DOUBLE DAGGER */ +#define XK_checkmark 0x0af3 /* U+2713 CHECK MARK */ +#define XK_ballotcross 0x0af4 /* U+2717 BALLOT X */ +#define XK_musicalsharp 0x0af5 /* U+266F MUSIC SHARP SIGN */ +#define XK_musicalflat 0x0af6 /* U+266D MUSIC FLAT SIGN */ +#define XK_malesymbol 0x0af7 /* U+2642 MALE SIGN */ +#define XK_femalesymbol 0x0af8 /* U+2640 FEMALE SIGN */ +#define XK_telephone 0x0af9 /* U+260E BLACK TELEPHONE */ +#define XK_telephonerecorder 0x0afa /* U+2315 TELEPHONE RECORDER */ +#define XK_phonographcopyright 0x0afb /* U+2117 SOUND RECORDING COPYRIGHT */ +#define XK_caret 0x0afc /* U+2038 CARET */ +#define XK_singlelowquotemark 0x0afd /* U+201A SINGLE LOW-9 QUOTATION MARK */ +#define XK_doublelowquotemark 0x0afe /* U+201E DOUBLE LOW-9 QUOTATION MARK */ +#define XK_cursor 0x0aff +#endif /* XK_PUBLISHING */ + +/* + * APL + * Byte 3 = 0x0b + */ + +#ifdef XK_APL +#define XK_leftcaret 0x0ba3 /*(U+003C LESS-THAN SIGN)*/ +#define XK_rightcaret 0x0ba6 /*(U+003E GREATER-THAN SIGN)*/ +#define XK_downcaret 0x0ba8 /*(U+2228 LOGICAL OR)*/ +#define XK_upcaret 0x0ba9 /*(U+2227 LOGICAL AND)*/ +#define XK_overbar 0x0bc0 /*(U+00AF MACRON)*/ +#define XK_downtack 0x0bc2 /* U+22A4 DOWN TACK */ +#define XK_upshoe 0x0bc3 /*(U+2229 INTERSECTION)*/ +#define XK_downstile 0x0bc4 /* U+230A LEFT FLOOR */ +#define XK_underbar 0x0bc6 /*(U+005F LOW LINE)*/ +#define XK_jot 0x0bca /* U+2218 RING OPERATOR */ +#define XK_quad 0x0bcc /* U+2395 APL FUNCTIONAL SYMBOL QUAD */ +#define XK_uptack 0x0bce /* U+22A5 UP TACK */ +#define XK_circle 0x0bcf /* U+25CB WHITE CIRCLE */ +#define XK_upstile 0x0bd3 /* U+2308 LEFT CEILING */ +#define XK_downshoe 0x0bd6 /*(U+222A UNION)*/ +#define XK_rightshoe 0x0bd8 /*(U+2283 SUPERSET OF)*/ +#define XK_leftshoe 0x0bda /*(U+2282 SUBSET OF)*/ +#define XK_lefttack 0x0bdc /* U+22A3 LEFT TACK */ +#define XK_righttack 0x0bfc /* U+22A2 RIGHT TACK */ +#endif /* XK_APL */ + +/* + * Hebrew + * Byte 3 = 0x0c + */ + +#ifdef XK_HEBREW +#define XK_hebrew_doublelowline 0x0cdf /* U+2017 DOUBLE LOW LINE */ +#define XK_hebrew_aleph 0x0ce0 /* U+05D0 HEBREW LETTER ALEF */ +#define XK_hebrew_bet 0x0ce1 /* U+05D1 HEBREW LETTER BET */ +#define XK_hebrew_beth 0x0ce1 /* deprecated */ +#define XK_hebrew_gimel 0x0ce2 /* U+05D2 HEBREW LETTER GIMEL */ +#define XK_hebrew_gimmel 0x0ce2 /* deprecated */ +#define XK_hebrew_dalet 0x0ce3 /* U+05D3 HEBREW LETTER DALET */ +#define XK_hebrew_daleth 0x0ce3 /* deprecated */ +#define XK_hebrew_he 0x0ce4 /* U+05D4 HEBREW LETTER HE */ +#define XK_hebrew_waw 0x0ce5 /* U+05D5 HEBREW LETTER VAV */ +#define XK_hebrew_zain 0x0ce6 /* U+05D6 HEBREW LETTER ZAYIN */ +#define XK_hebrew_zayin 0x0ce6 /* deprecated */ +#define XK_hebrew_chet 0x0ce7 /* U+05D7 HEBREW LETTER HET */ +#define XK_hebrew_het 0x0ce7 /* deprecated */ +#define XK_hebrew_tet 0x0ce8 /* U+05D8 HEBREW LETTER TET */ +#define XK_hebrew_teth 0x0ce8 /* deprecated */ +#define XK_hebrew_yod 0x0ce9 /* U+05D9 HEBREW LETTER YOD */ +#define XK_hebrew_finalkaph 0x0cea /* U+05DA HEBREW LETTER FINAL KAF */ +#define XK_hebrew_kaph 0x0ceb /* U+05DB HEBREW LETTER KAF */ +#define XK_hebrew_lamed 0x0cec /* U+05DC HEBREW LETTER LAMED */ +#define XK_hebrew_finalmem 0x0ced /* U+05DD HEBREW LETTER FINAL MEM */ +#define XK_hebrew_mem 0x0cee /* U+05DE HEBREW LETTER MEM */ +#define XK_hebrew_finalnun 0x0cef /* U+05DF HEBREW LETTER FINAL NUN */ +#define XK_hebrew_nun 0x0cf0 /* U+05E0 HEBREW LETTER NUN */ +#define XK_hebrew_samech 0x0cf1 /* U+05E1 HEBREW LETTER SAMEKH */ +#define XK_hebrew_samekh 0x0cf1 /* deprecated */ +#define XK_hebrew_ayin 0x0cf2 /* U+05E2 HEBREW LETTER AYIN */ +#define XK_hebrew_finalpe 0x0cf3 /* U+05E3 HEBREW LETTER FINAL PE */ +#define XK_hebrew_pe 0x0cf4 /* U+05E4 HEBREW LETTER PE */ +#define XK_hebrew_finalzade 0x0cf5 /* U+05E5 HEBREW LETTER FINAL TSADI */ +#define XK_hebrew_finalzadi 0x0cf5 /* deprecated */ +#define XK_hebrew_zade 0x0cf6 /* U+05E6 HEBREW LETTER TSADI */ +#define XK_hebrew_zadi 0x0cf6 /* deprecated */ +#define XK_hebrew_qoph 0x0cf7 /* U+05E7 HEBREW LETTER QOF */ +#define XK_hebrew_kuf 0x0cf7 /* deprecated */ +#define XK_hebrew_resh 0x0cf8 /* U+05E8 HEBREW LETTER RESH */ +#define XK_hebrew_shin 0x0cf9 /* U+05E9 HEBREW LETTER SHIN */ +#define XK_hebrew_taw 0x0cfa /* U+05EA HEBREW LETTER TAV */ +#define XK_hebrew_taf 0x0cfa /* deprecated */ +#define XK_Hebrew_switch 0xff7e /* non-deprecated alias for Mode_switch */ +#endif /* XK_HEBREW */ + +/* + * Thai + * Byte 3 = 0x0d + */ + +#ifdef XK_THAI +#define XK_Thai_kokai 0x0da1 /* U+0E01 THAI CHARACTER KO KAI */ +#define XK_Thai_khokhai 0x0da2 /* U+0E02 THAI CHARACTER KHO KHAI */ +#define XK_Thai_khokhuat 0x0da3 /* U+0E03 THAI CHARACTER KHO KHUAT */ +#define XK_Thai_khokhwai 0x0da4 /* U+0E04 THAI CHARACTER KHO KHWAI */ +#define XK_Thai_khokhon 0x0da5 /* U+0E05 THAI CHARACTER KHO KHON */ +#define XK_Thai_khorakhang 0x0da6 /* U+0E06 THAI CHARACTER KHO RAKHANG */ +#define XK_Thai_ngongu 0x0da7 /* U+0E07 THAI CHARACTER NGO NGU */ +#define XK_Thai_chochan 0x0da8 /* U+0E08 THAI CHARACTER CHO CHAN */ +#define XK_Thai_choching 0x0da9 /* U+0E09 THAI CHARACTER CHO CHING */ +#define XK_Thai_chochang 0x0daa /* U+0E0A THAI CHARACTER CHO CHANG */ +#define XK_Thai_soso 0x0dab /* U+0E0B THAI CHARACTER SO SO */ +#define XK_Thai_chochoe 0x0dac /* U+0E0C THAI CHARACTER CHO CHOE */ +#define XK_Thai_yoying 0x0dad /* U+0E0D THAI CHARACTER YO YING */ +#define XK_Thai_dochada 0x0dae /* U+0E0E THAI CHARACTER DO CHADA */ +#define XK_Thai_topatak 0x0daf /* U+0E0F THAI CHARACTER TO PATAK */ +#define XK_Thai_thothan 0x0db0 /* U+0E10 THAI CHARACTER THO THAN */ +#define XK_Thai_thonangmontho 0x0db1 /* U+0E11 THAI CHARACTER THO NANGMONTHO */ +#define XK_Thai_thophuthao 0x0db2 /* U+0E12 THAI CHARACTER THO PHUTHAO */ +#define XK_Thai_nonen 0x0db3 /* U+0E13 THAI CHARACTER NO NEN */ +#define XK_Thai_dodek 0x0db4 /* U+0E14 THAI CHARACTER DO DEK */ +#define XK_Thai_totao 0x0db5 /* U+0E15 THAI CHARACTER TO TAO */ +#define XK_Thai_thothung 0x0db6 /* U+0E16 THAI CHARACTER THO THUNG */ +#define XK_Thai_thothahan 0x0db7 /* U+0E17 THAI CHARACTER THO THAHAN */ +#define XK_Thai_thothong 0x0db8 /* U+0E18 THAI CHARACTER THO THONG */ +#define XK_Thai_nonu 0x0db9 /* U+0E19 THAI CHARACTER NO NU */ +#define XK_Thai_bobaimai 0x0dba /* U+0E1A THAI CHARACTER BO BAIMAI */ +#define XK_Thai_popla 0x0dbb /* U+0E1B THAI CHARACTER PO PLA */ +#define XK_Thai_phophung 0x0dbc /* U+0E1C THAI CHARACTER PHO PHUNG */ +#define XK_Thai_fofa 0x0dbd /* U+0E1D THAI CHARACTER FO FA */ +#define XK_Thai_phophan 0x0dbe /* U+0E1E THAI CHARACTER PHO PHAN */ +#define XK_Thai_fofan 0x0dbf /* U+0E1F THAI CHARACTER FO FAN */ +#define XK_Thai_phosamphao 0x0dc0 /* U+0E20 THAI CHARACTER PHO SAMPHAO */ +#define XK_Thai_moma 0x0dc1 /* U+0E21 THAI CHARACTER MO MA */ +#define XK_Thai_yoyak 0x0dc2 /* U+0E22 THAI CHARACTER YO YAK */ +#define XK_Thai_rorua 0x0dc3 /* U+0E23 THAI CHARACTER RO RUA */ +#define XK_Thai_ru 0x0dc4 /* U+0E24 THAI CHARACTER RU */ +#define XK_Thai_loling 0x0dc5 /* U+0E25 THAI CHARACTER LO LING */ +#define XK_Thai_lu 0x0dc6 /* U+0E26 THAI CHARACTER LU */ +#define XK_Thai_wowaen 0x0dc7 /* U+0E27 THAI CHARACTER WO WAEN */ +#define XK_Thai_sosala 0x0dc8 /* U+0E28 THAI CHARACTER SO SALA */ +#define XK_Thai_sorusi 0x0dc9 /* U+0E29 THAI CHARACTER SO RUSI */ +#define XK_Thai_sosua 0x0dca /* U+0E2A THAI CHARACTER SO SUA */ +#define XK_Thai_hohip 0x0dcb /* U+0E2B THAI CHARACTER HO HIP */ +#define XK_Thai_lochula 0x0dcc /* U+0E2C THAI CHARACTER LO CHULA */ +#define XK_Thai_oang 0x0dcd /* U+0E2D THAI CHARACTER O ANG */ +#define XK_Thai_honokhuk 0x0dce /* U+0E2E THAI CHARACTER HO NOKHUK */ +#define XK_Thai_paiyannoi 0x0dcf /* U+0E2F THAI CHARACTER PAIYANNOI */ +#define XK_Thai_saraa 0x0dd0 /* U+0E30 THAI CHARACTER SARA A */ +#define XK_Thai_maihanakat 0x0dd1 /* U+0E31 THAI CHARACTER MAI HAN-AKAT */ +#define XK_Thai_saraaa 0x0dd2 /* U+0E32 THAI CHARACTER SARA AA */ +#define XK_Thai_saraam 0x0dd3 /* U+0E33 THAI CHARACTER SARA AM */ +#define XK_Thai_sarai 0x0dd4 /* U+0E34 THAI CHARACTER SARA I */ +#define XK_Thai_saraii 0x0dd5 /* U+0E35 THAI CHARACTER SARA II */ +#define XK_Thai_saraue 0x0dd6 /* U+0E36 THAI CHARACTER SARA UE */ +#define XK_Thai_sarauee 0x0dd7 /* U+0E37 THAI CHARACTER SARA UEE */ +#define XK_Thai_sarau 0x0dd8 /* U+0E38 THAI CHARACTER SARA U */ +#define XK_Thai_sarauu 0x0dd9 /* U+0E39 THAI CHARACTER SARA UU */ +#define XK_Thai_phinthu 0x0dda /* U+0E3A THAI CHARACTER PHINTHU */ +#define XK_Thai_maihanakat_maitho 0x0dde /*(U+0E3E Unassigned code point)*/ +#define XK_Thai_baht 0x0ddf /* U+0E3F THAI CURRENCY SYMBOL BAHT */ +#define XK_Thai_sarae 0x0de0 /* U+0E40 THAI CHARACTER SARA E */ +#define XK_Thai_saraae 0x0de1 /* U+0E41 THAI CHARACTER SARA AE */ +#define XK_Thai_sarao 0x0de2 /* U+0E42 THAI CHARACTER SARA O */ +#define XK_Thai_saraaimaimuan 0x0de3 /* U+0E43 THAI CHARACTER SARA AI MAIMUAN */ +#define XK_Thai_saraaimaimalai 0x0de4 /* U+0E44 THAI CHARACTER SARA AI MAIMALAI */ +#define XK_Thai_lakkhangyao 0x0de5 /* U+0E45 THAI CHARACTER LAKKHANGYAO */ +#define XK_Thai_maiyamok 0x0de6 /* U+0E46 THAI CHARACTER MAIYAMOK */ +#define XK_Thai_maitaikhu 0x0de7 /* U+0E47 THAI CHARACTER MAITAIKHU */ +#define XK_Thai_maiek 0x0de8 /* U+0E48 THAI CHARACTER MAI EK */ +#define XK_Thai_maitho 0x0de9 /* U+0E49 THAI CHARACTER MAI THO */ +#define XK_Thai_maitri 0x0dea /* U+0E4A THAI CHARACTER MAI TRI */ +#define XK_Thai_maichattawa 0x0deb /* U+0E4B THAI CHARACTER MAI CHATTAWA */ +#define XK_Thai_thanthakhat 0x0dec /* U+0E4C THAI CHARACTER THANTHAKHAT */ +#define XK_Thai_nikhahit 0x0ded /* U+0E4D THAI CHARACTER NIKHAHIT */ +#define XK_Thai_leksun 0x0df0 /* U+0E50 THAI DIGIT ZERO */ +#define XK_Thai_leknung 0x0df1 /* U+0E51 THAI DIGIT ONE */ +#define XK_Thai_leksong 0x0df2 /* U+0E52 THAI DIGIT TWO */ +#define XK_Thai_leksam 0x0df3 /* U+0E53 THAI DIGIT THREE */ +#define XK_Thai_leksi 0x0df4 /* U+0E54 THAI DIGIT FOUR */ +#define XK_Thai_lekha 0x0df5 /* U+0E55 THAI DIGIT FIVE */ +#define XK_Thai_lekhok 0x0df6 /* U+0E56 THAI DIGIT SIX */ +#define XK_Thai_lekchet 0x0df7 /* U+0E57 THAI DIGIT SEVEN */ +#define XK_Thai_lekpaet 0x0df8 /* U+0E58 THAI DIGIT EIGHT */ +#define XK_Thai_lekkao 0x0df9 /* U+0E59 THAI DIGIT NINE */ +#endif /* XK_THAI */ + +/* + * Korean + * Byte 3 = 0x0e + */ + +#ifdef XK_KOREAN + +#define XK_Hangul 0xff31 /* Hangul start/stop(toggle) */ +#define XK_Hangul_Start 0xff32 /* Hangul start */ +#define XK_Hangul_End 0xff33 /* Hangul end, English start */ +#define XK_Hangul_Hanja 0xff34 /* Start Hangul->Hanja Conversion */ +#define XK_Hangul_Jamo 0xff35 /* Hangul Jamo mode */ +#define XK_Hangul_Romaja 0xff36 /* Hangul Romaja mode */ +#define XK_Hangul_Codeinput 0xff37 /* Hangul code input mode */ +#define XK_Hangul_Jeonja 0xff38 /* Jeonja mode */ +#define XK_Hangul_Banja 0xff39 /* Banja mode */ +#define XK_Hangul_PreHanja 0xff3a /* Pre Hanja conversion */ +#define XK_Hangul_PostHanja 0xff3b /* Post Hanja conversion */ +#define XK_Hangul_SingleCandidate 0xff3c /* Single candidate */ +#define XK_Hangul_MultipleCandidate 0xff3d /* Multiple candidate */ +#define XK_Hangul_PreviousCandidate 0xff3e /* Previous candidate */ +#define XK_Hangul_Special 0xff3f /* Special symbols */ +#define XK_Hangul_switch 0xff7e /* non-deprecated alias for Mode_switch */ + +/* Hangul Consonant Characters */ +#define XK_Hangul_Kiyeog 0x0ea1 /* U+3131 HANGUL LETTER KIYEOK */ +#define XK_Hangul_SsangKiyeog 0x0ea2 /* U+3132 HANGUL LETTER SSANGKIYEOK */ +#define XK_Hangul_KiyeogSios 0x0ea3 /* U+3133 HANGUL LETTER KIYEOK-SIOS */ +#define XK_Hangul_Nieun 0x0ea4 /* U+3134 HANGUL LETTER NIEUN */ +#define XK_Hangul_NieunJieuj 0x0ea5 /* U+3135 HANGUL LETTER NIEUN-CIEUC */ +#define XK_Hangul_NieunHieuh 0x0ea6 /* U+3136 HANGUL LETTER NIEUN-HIEUH */ +#define XK_Hangul_Dikeud 0x0ea7 /* U+3137 HANGUL LETTER TIKEUT */ +#define XK_Hangul_SsangDikeud 0x0ea8 /* U+3138 HANGUL LETTER SSANGTIKEUT */ +#define XK_Hangul_Rieul 0x0ea9 /* U+3139 HANGUL LETTER RIEUL */ +#define XK_Hangul_RieulKiyeog 0x0eaa /* U+313A HANGUL LETTER RIEUL-KIYEOK */ +#define XK_Hangul_RieulMieum 0x0eab /* U+313B HANGUL LETTER RIEUL-MIEUM */ +#define XK_Hangul_RieulPieub 0x0eac /* U+313C HANGUL LETTER RIEUL-PIEUP */ +#define XK_Hangul_RieulSios 0x0ead /* U+313D HANGUL LETTER RIEUL-SIOS */ +#define XK_Hangul_RieulTieut 0x0eae /* U+313E HANGUL LETTER RIEUL-THIEUTH */ +#define XK_Hangul_RieulPhieuf 0x0eaf /* U+313F HANGUL LETTER RIEUL-PHIEUPH */ +#define XK_Hangul_RieulHieuh 0x0eb0 /* U+3140 HANGUL LETTER RIEUL-HIEUH */ +#define XK_Hangul_Mieum 0x0eb1 /* U+3141 HANGUL LETTER MIEUM */ +#define XK_Hangul_Pieub 0x0eb2 /* U+3142 HANGUL LETTER PIEUP */ +#define XK_Hangul_SsangPieub 0x0eb3 /* U+3143 HANGUL LETTER SSANGPIEUP */ +#define XK_Hangul_PieubSios 0x0eb4 /* U+3144 HANGUL LETTER PIEUP-SIOS */ +#define XK_Hangul_Sios 0x0eb5 /* U+3145 HANGUL LETTER SIOS */ +#define XK_Hangul_SsangSios 0x0eb6 /* U+3146 HANGUL LETTER SSANGSIOS */ +#define XK_Hangul_Ieung 0x0eb7 /* U+3147 HANGUL LETTER IEUNG */ +#define XK_Hangul_Jieuj 0x0eb8 /* U+3148 HANGUL LETTER CIEUC */ +#define XK_Hangul_SsangJieuj 0x0eb9 /* U+3149 HANGUL LETTER SSANGCIEUC */ +#define XK_Hangul_Cieuc 0x0eba /* U+314A HANGUL LETTER CHIEUCH */ +#define XK_Hangul_Khieuq 0x0ebb /* U+314B HANGUL LETTER KHIEUKH */ +#define XK_Hangul_Tieut 0x0ebc /* U+314C HANGUL LETTER THIEUTH */ +#define XK_Hangul_Phieuf 0x0ebd /* U+314D HANGUL LETTER PHIEUPH */ +#define XK_Hangul_Hieuh 0x0ebe /* U+314E HANGUL LETTER HIEUH */ + +/* Hangul Vowel Characters */ +#define XK_Hangul_A 0x0ebf /* U+314F HANGUL LETTER A */ +#define XK_Hangul_AE 0x0ec0 /* U+3150 HANGUL LETTER AE */ +#define XK_Hangul_YA 0x0ec1 /* U+3151 HANGUL LETTER YA */ +#define XK_Hangul_YAE 0x0ec2 /* U+3152 HANGUL LETTER YAE */ +#define XK_Hangul_EO 0x0ec3 /* U+3153 HANGUL LETTER EO */ +#define XK_Hangul_E 0x0ec4 /* U+3154 HANGUL LETTER E */ +#define XK_Hangul_YEO 0x0ec5 /* U+3155 HANGUL LETTER YEO */ +#define XK_Hangul_YE 0x0ec6 /* U+3156 HANGUL LETTER YE */ +#define XK_Hangul_O 0x0ec7 /* U+3157 HANGUL LETTER O */ +#define XK_Hangul_WA 0x0ec8 /* U+3158 HANGUL LETTER WA */ +#define XK_Hangul_WAE 0x0ec9 /* U+3159 HANGUL LETTER WAE */ +#define XK_Hangul_OE 0x0eca /* U+315A HANGUL LETTER OE */ +#define XK_Hangul_YO 0x0ecb /* U+315B HANGUL LETTER YO */ +#define XK_Hangul_U 0x0ecc /* U+315C HANGUL LETTER U */ +#define XK_Hangul_WEO 0x0ecd /* U+315D HANGUL LETTER WEO */ +#define XK_Hangul_WE 0x0ece /* U+315E HANGUL LETTER WE */ +#define XK_Hangul_WI 0x0ecf /* U+315F HANGUL LETTER WI */ +#define XK_Hangul_YU 0x0ed0 /* U+3160 HANGUL LETTER YU */ +#define XK_Hangul_EU 0x0ed1 /* U+3161 HANGUL LETTER EU */ +#define XK_Hangul_YI 0x0ed2 /* U+3162 HANGUL LETTER YI */ +#define XK_Hangul_I 0x0ed3 /* U+3163 HANGUL LETTER I */ + +/* Hangul syllable-final (JongSeong) Characters */ +#define XK_Hangul_J_Kiyeog 0x0ed4 /* U+11A8 HANGUL JONGSEONG KIYEOK */ +#define XK_Hangul_J_SsangKiyeog 0x0ed5 /* U+11A9 HANGUL JONGSEONG SSANGKIYEOK */ +#define XK_Hangul_J_KiyeogSios 0x0ed6 /* U+11AA HANGUL JONGSEONG KIYEOK-SIOS */ +#define XK_Hangul_J_Nieun 0x0ed7 /* U+11AB HANGUL JONGSEONG NIEUN */ +#define XK_Hangul_J_NieunJieuj 0x0ed8 /* U+11AC HANGUL JONGSEONG NIEUN-CIEUC */ +#define XK_Hangul_J_NieunHieuh 0x0ed9 /* U+11AD HANGUL JONGSEONG NIEUN-HIEUH */ +#define XK_Hangul_J_Dikeud 0x0eda /* U+11AE HANGUL JONGSEONG TIKEUT */ +#define XK_Hangul_J_Rieul 0x0edb /* U+11AF HANGUL JONGSEONG RIEUL */ +#define XK_Hangul_J_RieulKiyeog 0x0edc /* U+11B0 HANGUL JONGSEONG RIEUL-KIYEOK */ +#define XK_Hangul_J_RieulMieum 0x0edd /* U+11B1 HANGUL JONGSEONG RIEUL-MIEUM */ +#define XK_Hangul_J_RieulPieub 0x0ede /* U+11B2 HANGUL JONGSEONG RIEUL-PIEUP */ +#define XK_Hangul_J_RieulSios 0x0edf /* U+11B3 HANGUL JONGSEONG RIEUL-SIOS */ +#define XK_Hangul_J_RieulTieut 0x0ee0 /* U+11B4 HANGUL JONGSEONG RIEUL-THIEUTH */ +#define XK_Hangul_J_RieulPhieuf 0x0ee1 /* U+11B5 HANGUL JONGSEONG RIEUL-PHIEUPH */ +#define XK_Hangul_J_RieulHieuh 0x0ee2 /* U+11B6 HANGUL JONGSEONG RIEUL-HIEUH */ +#define XK_Hangul_J_Mieum 0x0ee3 /* U+11B7 HANGUL JONGSEONG MIEUM */ +#define XK_Hangul_J_Pieub 0x0ee4 /* U+11B8 HANGUL JONGSEONG PIEUP */ +#define XK_Hangul_J_PieubSios 0x0ee5 /* U+11B9 HANGUL JONGSEONG PIEUP-SIOS */ +#define XK_Hangul_J_Sios 0x0ee6 /* U+11BA HANGUL JONGSEONG SIOS */ +#define XK_Hangul_J_SsangSios 0x0ee7 /* U+11BB HANGUL JONGSEONG SSANGSIOS */ +#define XK_Hangul_J_Ieung 0x0ee8 /* U+11BC HANGUL JONGSEONG IEUNG */ +#define XK_Hangul_J_Jieuj 0x0ee9 /* U+11BD HANGUL JONGSEONG CIEUC */ +#define XK_Hangul_J_Cieuc 0x0eea /* U+11BE HANGUL JONGSEONG CHIEUCH */ +#define XK_Hangul_J_Khieuq 0x0eeb /* U+11BF HANGUL JONGSEONG KHIEUKH */ +#define XK_Hangul_J_Tieut 0x0eec /* U+11C0 HANGUL JONGSEONG THIEUTH */ +#define XK_Hangul_J_Phieuf 0x0eed /* U+11C1 HANGUL JONGSEONG PHIEUPH */ +#define XK_Hangul_J_Hieuh 0x0eee /* U+11C2 HANGUL JONGSEONG HIEUH */ + +/* Ancient Hangul Consonant Characters */ +#define XK_Hangul_RieulYeorinHieuh 0x0eef /* U+316D HANGUL LETTER RIEUL-YEORINHIEUH */ +#define XK_Hangul_SunkyeongeumMieum 0x0ef0 /* U+3171 HANGUL LETTER KAPYEOUNMIEUM */ +#define XK_Hangul_SunkyeongeumPieub 0x0ef1 /* U+3178 HANGUL LETTER KAPYEOUNPIEUP */ +#define XK_Hangul_PanSios 0x0ef2 /* U+317F HANGUL LETTER PANSIOS */ +#define XK_Hangul_KkogjiDalrinIeung 0x0ef3 /* U+3181 HANGUL LETTER YESIEUNG */ +#define XK_Hangul_SunkyeongeumPhieuf 0x0ef4 /* U+3184 HANGUL LETTER KAPYEOUNPHIEUPH */ +#define XK_Hangul_YeorinHieuh 0x0ef5 /* U+3186 HANGUL LETTER YEORINHIEUH */ + +/* Ancient Hangul Vowel Characters */ +#define XK_Hangul_AraeA 0x0ef6 /* U+318D HANGUL LETTER ARAEA */ +#define XK_Hangul_AraeAE 0x0ef7 /* U+318E HANGUL LETTER ARAEAE */ + +/* Ancient Hangul syllable-final (JongSeong) Characters */ +#define XK_Hangul_J_PanSios 0x0ef8 /* U+11EB HANGUL JONGSEONG PANSIOS */ +#define XK_Hangul_J_KkogjiDalrinIeung 0x0ef9 /* U+11F0 HANGUL JONGSEONG YESIEUNG */ +#define XK_Hangul_J_YeorinHieuh 0x0efa /* U+11F9 HANGUL JONGSEONG YEORINHIEUH */ + +/* Korean currency symbol */ +#define XK_Korean_Won 0x0eff /*(U+20A9 WON SIGN)*/ + +#endif /* XK_KOREAN */ + +/* + * Armenian + */ + +#ifdef XK_ARMENIAN +#define XK_Armenian_ligature_ew 0x1000587 /* U+0587 ARMENIAN SMALL LIGATURE ECH YIWN */ +#define XK_Armenian_full_stop 0x1000589 /* U+0589 ARMENIAN FULL STOP */ +#define XK_Armenian_verjaket 0x1000589 /* deprecated alias for Armenian_full_stop */ +#define XK_Armenian_separation_mark 0x100055d /* U+055D ARMENIAN COMMA */ +#define XK_Armenian_but 0x100055d /* deprecated alias for Armenian_separation_mark */ +#define XK_Armenian_hyphen 0x100058a /* U+058A ARMENIAN HYPHEN */ +#define XK_Armenian_yentamna 0x100058a /* deprecated alias for Armenian_hyphen */ +#define XK_Armenian_exclam 0x100055c /* U+055C ARMENIAN EXCLAMATION MARK */ +#define XK_Armenian_amanak 0x100055c /* deprecated alias for Armenian_exclam */ +#define XK_Armenian_accent 0x100055b /* U+055B ARMENIAN EMPHASIS MARK */ +#define XK_Armenian_shesht 0x100055b /* deprecated alias for Armenian_accent */ +#define XK_Armenian_question 0x100055e /* U+055E ARMENIAN QUESTION MARK */ +#define XK_Armenian_paruyk 0x100055e /* deprecated alias for Armenian_question */ +#define XK_Armenian_AYB 0x1000531 /* U+0531 ARMENIAN CAPITAL LETTER AYB */ +#define XK_Armenian_ayb 0x1000561 /* U+0561 ARMENIAN SMALL LETTER AYB */ +#define XK_Armenian_BEN 0x1000532 /* U+0532 ARMENIAN CAPITAL LETTER BEN */ +#define XK_Armenian_ben 0x1000562 /* U+0562 ARMENIAN SMALL LETTER BEN */ +#define XK_Armenian_GIM 0x1000533 /* U+0533 ARMENIAN CAPITAL LETTER GIM */ +#define XK_Armenian_gim 0x1000563 /* U+0563 ARMENIAN SMALL LETTER GIM */ +#define XK_Armenian_DA 0x1000534 /* U+0534 ARMENIAN CAPITAL LETTER DA */ +#define XK_Armenian_da 0x1000564 /* U+0564 ARMENIAN SMALL LETTER DA */ +#define XK_Armenian_YECH 0x1000535 /* U+0535 ARMENIAN CAPITAL LETTER ECH */ +#define XK_Armenian_yech 0x1000565 /* U+0565 ARMENIAN SMALL LETTER ECH */ +#define XK_Armenian_ZA 0x1000536 /* U+0536 ARMENIAN CAPITAL LETTER ZA */ +#define XK_Armenian_za 0x1000566 /* U+0566 ARMENIAN SMALL LETTER ZA */ +#define XK_Armenian_E 0x1000537 /* U+0537 ARMENIAN CAPITAL LETTER EH */ +#define XK_Armenian_e 0x1000567 /* U+0567 ARMENIAN SMALL LETTER EH */ +#define XK_Armenian_AT 0x1000538 /* U+0538 ARMENIAN CAPITAL LETTER ET */ +#define XK_Armenian_at 0x1000568 /* U+0568 ARMENIAN SMALL LETTER ET */ +#define XK_Armenian_TO 0x1000539 /* U+0539 ARMENIAN CAPITAL LETTER TO */ +#define XK_Armenian_to 0x1000569 /* U+0569 ARMENIAN SMALL LETTER TO */ +#define XK_Armenian_ZHE 0x100053a /* U+053A ARMENIAN CAPITAL LETTER ZHE */ +#define XK_Armenian_zhe 0x100056a /* U+056A ARMENIAN SMALL LETTER ZHE */ +#define XK_Armenian_INI 0x100053b /* U+053B ARMENIAN CAPITAL LETTER INI */ +#define XK_Armenian_ini 0x100056b /* U+056B ARMENIAN SMALL LETTER INI */ +#define XK_Armenian_LYUN 0x100053c /* U+053C ARMENIAN CAPITAL LETTER LIWN */ +#define XK_Armenian_lyun 0x100056c /* U+056C ARMENIAN SMALL LETTER LIWN */ +#define XK_Armenian_KHE 0x100053d /* U+053D ARMENIAN CAPITAL LETTER XEH */ +#define XK_Armenian_khe 0x100056d /* U+056D ARMENIAN SMALL LETTER XEH */ +#define XK_Armenian_TSA 0x100053e /* U+053E ARMENIAN CAPITAL LETTER CA */ +#define XK_Armenian_tsa 0x100056e /* U+056E ARMENIAN SMALL LETTER CA */ +#define XK_Armenian_KEN 0x100053f /* U+053F ARMENIAN CAPITAL LETTER KEN */ +#define XK_Armenian_ken 0x100056f /* U+056F ARMENIAN SMALL LETTER KEN */ +#define XK_Armenian_HO 0x1000540 /* U+0540 ARMENIAN CAPITAL LETTER HO */ +#define XK_Armenian_ho 0x1000570 /* U+0570 ARMENIAN SMALL LETTER HO */ +#define XK_Armenian_DZA 0x1000541 /* U+0541 ARMENIAN CAPITAL LETTER JA */ +#define XK_Armenian_dza 0x1000571 /* U+0571 ARMENIAN SMALL LETTER JA */ +#define XK_Armenian_GHAT 0x1000542 /* U+0542 ARMENIAN CAPITAL LETTER GHAD */ +#define XK_Armenian_ghat 0x1000572 /* U+0572 ARMENIAN SMALL LETTER GHAD */ +#define XK_Armenian_TCHE 0x1000543 /* U+0543 ARMENIAN CAPITAL LETTER CHEH */ +#define XK_Armenian_tche 0x1000573 /* U+0573 ARMENIAN SMALL LETTER CHEH */ +#define XK_Armenian_MEN 0x1000544 /* U+0544 ARMENIAN CAPITAL LETTER MEN */ +#define XK_Armenian_men 0x1000574 /* U+0574 ARMENIAN SMALL LETTER MEN */ +#define XK_Armenian_HI 0x1000545 /* U+0545 ARMENIAN CAPITAL LETTER YI */ +#define XK_Armenian_hi 0x1000575 /* U+0575 ARMENIAN SMALL LETTER YI */ +#define XK_Armenian_NU 0x1000546 /* U+0546 ARMENIAN CAPITAL LETTER NOW */ +#define XK_Armenian_nu 0x1000576 /* U+0576 ARMENIAN SMALL LETTER NOW */ +#define XK_Armenian_SHA 0x1000547 /* U+0547 ARMENIAN CAPITAL LETTER SHA */ +#define XK_Armenian_sha 0x1000577 /* U+0577 ARMENIAN SMALL LETTER SHA */ +#define XK_Armenian_VO 0x1000548 /* U+0548 ARMENIAN CAPITAL LETTER VO */ +#define XK_Armenian_vo 0x1000578 /* U+0578 ARMENIAN SMALL LETTER VO */ +#define XK_Armenian_CHA 0x1000549 /* U+0549 ARMENIAN CAPITAL LETTER CHA */ +#define XK_Armenian_cha 0x1000579 /* U+0579 ARMENIAN SMALL LETTER CHA */ +#define XK_Armenian_PE 0x100054a /* U+054A ARMENIAN CAPITAL LETTER PEH */ +#define XK_Armenian_pe 0x100057a /* U+057A ARMENIAN SMALL LETTER PEH */ +#define XK_Armenian_JE 0x100054b /* U+054B ARMENIAN CAPITAL LETTER JHEH */ +#define XK_Armenian_je 0x100057b /* U+057B ARMENIAN SMALL LETTER JHEH */ +#define XK_Armenian_RA 0x100054c /* U+054C ARMENIAN CAPITAL LETTER RA */ +#define XK_Armenian_ra 0x100057c /* U+057C ARMENIAN SMALL LETTER RA */ +#define XK_Armenian_SE 0x100054d /* U+054D ARMENIAN CAPITAL LETTER SEH */ +#define XK_Armenian_se 0x100057d /* U+057D ARMENIAN SMALL LETTER SEH */ +#define XK_Armenian_VEV 0x100054e /* U+054E ARMENIAN CAPITAL LETTER VEW */ +#define XK_Armenian_vev 0x100057e /* U+057E ARMENIAN SMALL LETTER VEW */ +#define XK_Armenian_TYUN 0x100054f /* U+054F ARMENIAN CAPITAL LETTER TIWN */ +#define XK_Armenian_tyun 0x100057f /* U+057F ARMENIAN SMALL LETTER TIWN */ +#define XK_Armenian_RE 0x1000550 /* U+0550 ARMENIAN CAPITAL LETTER REH */ +#define XK_Armenian_re 0x1000580 /* U+0580 ARMENIAN SMALL LETTER REH */ +#define XK_Armenian_TSO 0x1000551 /* U+0551 ARMENIAN CAPITAL LETTER CO */ +#define XK_Armenian_tso 0x1000581 /* U+0581 ARMENIAN SMALL LETTER CO */ +#define XK_Armenian_VYUN 0x1000552 /* U+0552 ARMENIAN CAPITAL LETTER YIWN */ +#define XK_Armenian_vyun 0x1000582 /* U+0582 ARMENIAN SMALL LETTER YIWN */ +#define XK_Armenian_PYUR 0x1000553 /* U+0553 ARMENIAN CAPITAL LETTER PIWR */ +#define XK_Armenian_pyur 0x1000583 /* U+0583 ARMENIAN SMALL LETTER PIWR */ +#define XK_Armenian_KE 0x1000554 /* U+0554 ARMENIAN CAPITAL LETTER KEH */ +#define XK_Armenian_ke 0x1000584 /* U+0584 ARMENIAN SMALL LETTER KEH */ +#define XK_Armenian_O 0x1000555 /* U+0555 ARMENIAN CAPITAL LETTER OH */ +#define XK_Armenian_o 0x1000585 /* U+0585 ARMENIAN SMALL LETTER OH */ +#define XK_Armenian_FE 0x1000556 /* U+0556 ARMENIAN CAPITAL LETTER FEH */ +#define XK_Armenian_fe 0x1000586 /* U+0586 ARMENIAN SMALL LETTER FEH */ +#define XK_Armenian_apostrophe 0x100055a /* U+055A ARMENIAN APOSTROPHE */ +#endif /* XK_ARMENIAN */ + +/* + * Georgian + */ + +#ifdef XK_GEORGIAN +#define XK_Georgian_an 0x10010d0 /* U+10D0 GEORGIAN LETTER AN */ +#define XK_Georgian_ban 0x10010d1 /* U+10D1 GEORGIAN LETTER BAN */ +#define XK_Georgian_gan 0x10010d2 /* U+10D2 GEORGIAN LETTER GAN */ +#define XK_Georgian_don 0x10010d3 /* U+10D3 GEORGIAN LETTER DON */ +#define XK_Georgian_en 0x10010d4 /* U+10D4 GEORGIAN LETTER EN */ +#define XK_Georgian_vin 0x10010d5 /* U+10D5 GEORGIAN LETTER VIN */ +#define XK_Georgian_zen 0x10010d6 /* U+10D6 GEORGIAN LETTER ZEN */ +#define XK_Georgian_tan 0x10010d7 /* U+10D7 GEORGIAN LETTER TAN */ +#define XK_Georgian_in 0x10010d8 /* U+10D8 GEORGIAN LETTER IN */ +#define XK_Georgian_kan 0x10010d9 /* U+10D9 GEORGIAN LETTER KAN */ +#define XK_Georgian_las 0x10010da /* U+10DA GEORGIAN LETTER LAS */ +#define XK_Georgian_man 0x10010db /* U+10DB GEORGIAN LETTER MAN */ +#define XK_Georgian_nar 0x10010dc /* U+10DC GEORGIAN LETTER NAR */ +#define XK_Georgian_on 0x10010dd /* U+10DD GEORGIAN LETTER ON */ +#define XK_Georgian_par 0x10010de /* U+10DE GEORGIAN LETTER PAR */ +#define XK_Georgian_zhar 0x10010df /* U+10DF GEORGIAN LETTER ZHAR */ +#define XK_Georgian_rae 0x10010e0 /* U+10E0 GEORGIAN LETTER RAE */ +#define XK_Georgian_san 0x10010e1 /* U+10E1 GEORGIAN LETTER SAN */ +#define XK_Georgian_tar 0x10010e2 /* U+10E2 GEORGIAN LETTER TAR */ +#define XK_Georgian_un 0x10010e3 /* U+10E3 GEORGIAN LETTER UN */ +#define XK_Georgian_phar 0x10010e4 /* U+10E4 GEORGIAN LETTER PHAR */ +#define XK_Georgian_khar 0x10010e5 /* U+10E5 GEORGIAN LETTER KHAR */ +#define XK_Georgian_ghan 0x10010e6 /* U+10E6 GEORGIAN LETTER GHAN */ +#define XK_Georgian_qar 0x10010e7 /* U+10E7 GEORGIAN LETTER QAR */ +#define XK_Georgian_shin 0x10010e8 /* U+10E8 GEORGIAN LETTER SHIN */ +#define XK_Georgian_chin 0x10010e9 /* U+10E9 GEORGIAN LETTER CHIN */ +#define XK_Georgian_can 0x10010ea /* U+10EA GEORGIAN LETTER CAN */ +#define XK_Georgian_jil 0x10010eb /* U+10EB GEORGIAN LETTER JIL */ +#define XK_Georgian_cil 0x10010ec /* U+10EC GEORGIAN LETTER CIL */ +#define XK_Georgian_char 0x10010ed /* U+10ED GEORGIAN LETTER CHAR */ +#define XK_Georgian_xan 0x10010ee /* U+10EE GEORGIAN LETTER XAN */ +#define XK_Georgian_jhan 0x10010ef /* U+10EF GEORGIAN LETTER JHAN */ +#define XK_Georgian_hae 0x10010f0 /* U+10F0 GEORGIAN LETTER HAE */ +#define XK_Georgian_he 0x10010f1 /* U+10F1 GEORGIAN LETTER HE */ +#define XK_Georgian_hie 0x10010f2 /* U+10F2 GEORGIAN LETTER HIE */ +#define XK_Georgian_we 0x10010f3 /* U+10F3 GEORGIAN LETTER WE */ +#define XK_Georgian_har 0x10010f4 /* U+10F4 GEORGIAN LETTER HAR */ +#define XK_Georgian_hoe 0x10010f5 /* U+10F5 GEORGIAN LETTER HOE */ +#define XK_Georgian_fi 0x10010f6 /* U+10F6 GEORGIAN LETTER FI */ +#endif /* XK_GEORGIAN */ + +/* + * Azeri (and other Turkic or Caucasian languages) + */ + +#ifdef XK_CAUCASUS +/* latin */ +#define XK_Xabovedot 0x1001e8a /* U+1E8A LATIN CAPITAL LETTER X WITH DOT ABOVE */ +#define XK_Ibreve 0x100012c /* U+012C LATIN CAPITAL LETTER I WITH BREVE */ +#define XK_Zstroke 0x10001b5 /* U+01B5 LATIN CAPITAL LETTER Z WITH STROKE */ +#define XK_Gcaron 0x10001e6 /* U+01E6 LATIN CAPITAL LETTER G WITH CARON */ +#define XK_Ocaron 0x10001d1 /* U+01D1 LATIN CAPITAL LETTER O WITH CARON */ +#define XK_Obarred 0x100019f /* U+019F LATIN CAPITAL LETTER O WITH MIDDLE TILDE */ +#define XK_xabovedot 0x1001e8b /* U+1E8B LATIN SMALL LETTER X WITH DOT ABOVE */ +#define XK_ibreve 0x100012d /* U+012D LATIN SMALL LETTER I WITH BREVE */ +#define XK_zstroke 0x10001b6 /* U+01B6 LATIN SMALL LETTER Z WITH STROKE */ +#define XK_gcaron 0x10001e7 /* U+01E7 LATIN SMALL LETTER G WITH CARON */ +#define XK_ocaron 0x10001d2 /* U+01D2 LATIN SMALL LETTER O WITH CARON */ +#define XK_obarred 0x1000275 /* U+0275 LATIN SMALL LETTER BARRED O */ +#define XK_SCHWA 0x100018f /* U+018F LATIN CAPITAL LETTER SCHWA */ +#define XK_schwa 0x1000259 /* U+0259 LATIN SMALL LETTER SCHWA */ +#define XK_EZH 0x10001b7 /* U+01B7 LATIN CAPITAL LETTER EZH */ +#define XK_ezh 0x1000292 /* U+0292 LATIN SMALL LETTER EZH */ +/* those are not really Caucasus */ +/* For Inupiak */ +#define XK_Lbelowdot 0x1001e36 /* U+1E36 LATIN CAPITAL LETTER L WITH DOT BELOW */ +#define XK_lbelowdot 0x1001e37 /* U+1E37 LATIN SMALL LETTER L WITH DOT BELOW */ +#endif /* XK_CAUCASUS */ + +/* + * Vietnamese + */ + +#ifdef XK_VIETNAMESE +#define XK_Abelowdot 0x1001ea0 /* U+1EA0 LATIN CAPITAL LETTER A WITH DOT BELOW */ +#define XK_abelowdot 0x1001ea1 /* U+1EA1 LATIN SMALL LETTER A WITH DOT BELOW */ +#define XK_Ahook 0x1001ea2 /* U+1EA2 LATIN CAPITAL LETTER A WITH HOOK ABOVE */ +#define XK_ahook 0x1001ea3 /* U+1EA3 LATIN SMALL LETTER A WITH HOOK ABOVE */ +#define XK_Acircumflexacute 0x1001ea4 /* U+1EA4 LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND ACUTE */ +#define XK_acircumflexacute 0x1001ea5 /* U+1EA5 LATIN SMALL LETTER A WITH CIRCUMFLEX AND ACUTE */ +#define XK_Acircumflexgrave 0x1001ea6 /* U+1EA6 LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND GRAVE */ +#define XK_acircumflexgrave 0x1001ea7 /* U+1EA7 LATIN SMALL LETTER A WITH CIRCUMFLEX AND GRAVE */ +#define XK_Acircumflexhook 0x1001ea8 /* U+1EA8 LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE */ +#define XK_acircumflexhook 0x1001ea9 /* U+1EA9 LATIN SMALL LETTER A WITH CIRCUMFLEX AND HOOK ABOVE */ +#define XK_Acircumflextilde 0x1001eaa /* U+1EAA LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND TILDE */ +#define XK_acircumflextilde 0x1001eab /* U+1EAB LATIN SMALL LETTER A WITH CIRCUMFLEX AND TILDE */ +#define XK_Acircumflexbelowdot 0x1001eac /* U+1EAC LATIN CAPITAL LETTER A WITH CIRCUMFLEX AND DOT BELOW */ +#define XK_acircumflexbelowdot 0x1001ead /* U+1EAD LATIN SMALL LETTER A WITH CIRCUMFLEX AND DOT BELOW */ +#define XK_Abreveacute 0x1001eae /* U+1EAE LATIN CAPITAL LETTER A WITH BREVE AND ACUTE */ +#define XK_abreveacute 0x1001eaf /* U+1EAF LATIN SMALL LETTER A WITH BREVE AND ACUTE */ +#define XK_Abrevegrave 0x1001eb0 /* U+1EB0 LATIN CAPITAL LETTER A WITH BREVE AND GRAVE */ +#define XK_abrevegrave 0x1001eb1 /* U+1EB1 LATIN SMALL LETTER A WITH BREVE AND GRAVE */ +#define XK_Abrevehook 0x1001eb2 /* U+1EB2 LATIN CAPITAL LETTER A WITH BREVE AND HOOK ABOVE */ +#define XK_abrevehook 0x1001eb3 /* U+1EB3 LATIN SMALL LETTER A WITH BREVE AND HOOK ABOVE */ +#define XK_Abrevetilde 0x1001eb4 /* U+1EB4 LATIN CAPITAL LETTER A WITH BREVE AND TILDE */ +#define XK_abrevetilde 0x1001eb5 /* U+1EB5 LATIN SMALL LETTER A WITH BREVE AND TILDE */ +#define XK_Abrevebelowdot 0x1001eb6 /* U+1EB6 LATIN CAPITAL LETTER A WITH BREVE AND DOT BELOW */ +#define XK_abrevebelowdot 0x1001eb7 /* U+1EB7 LATIN SMALL LETTER A WITH BREVE AND DOT BELOW */ +#define XK_Ebelowdot 0x1001eb8 /* U+1EB8 LATIN CAPITAL LETTER E WITH DOT BELOW */ +#define XK_ebelowdot 0x1001eb9 /* U+1EB9 LATIN SMALL LETTER E WITH DOT BELOW */ +#define XK_Ehook 0x1001eba /* U+1EBA LATIN CAPITAL LETTER E WITH HOOK ABOVE */ +#define XK_ehook 0x1001ebb /* U+1EBB LATIN SMALL LETTER E WITH HOOK ABOVE */ +#define XK_Etilde 0x1001ebc /* U+1EBC LATIN CAPITAL LETTER E WITH TILDE */ +#define XK_etilde 0x1001ebd /* U+1EBD LATIN SMALL LETTER E WITH TILDE */ +#define XK_Ecircumflexacute 0x1001ebe /* U+1EBE LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND ACUTE */ +#define XK_ecircumflexacute 0x1001ebf /* U+1EBF LATIN SMALL LETTER E WITH CIRCUMFLEX AND ACUTE */ +#define XK_Ecircumflexgrave 0x1001ec0 /* U+1EC0 LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND GRAVE */ +#define XK_ecircumflexgrave 0x1001ec1 /* U+1EC1 LATIN SMALL LETTER E WITH CIRCUMFLEX AND GRAVE */ +#define XK_Ecircumflexhook 0x1001ec2 /* U+1EC2 LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE */ +#define XK_ecircumflexhook 0x1001ec3 /* U+1EC3 LATIN SMALL LETTER E WITH CIRCUMFLEX AND HOOK ABOVE */ +#define XK_Ecircumflextilde 0x1001ec4 /* U+1EC4 LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND TILDE */ +#define XK_ecircumflextilde 0x1001ec5 /* U+1EC5 LATIN SMALL LETTER E WITH CIRCUMFLEX AND TILDE */ +#define XK_Ecircumflexbelowdot 0x1001ec6 /* U+1EC6 LATIN CAPITAL LETTER E WITH CIRCUMFLEX AND DOT BELOW */ +#define XK_ecircumflexbelowdot 0x1001ec7 /* U+1EC7 LATIN SMALL LETTER E WITH CIRCUMFLEX AND DOT BELOW */ +#define XK_Ihook 0x1001ec8 /* U+1EC8 LATIN CAPITAL LETTER I WITH HOOK ABOVE */ +#define XK_ihook 0x1001ec9 /* U+1EC9 LATIN SMALL LETTER I WITH HOOK ABOVE */ +#define XK_Ibelowdot 0x1001eca /* U+1ECA LATIN CAPITAL LETTER I WITH DOT BELOW */ +#define XK_ibelowdot 0x1001ecb /* U+1ECB LATIN SMALL LETTER I WITH DOT BELOW */ +#define XK_Obelowdot 0x1001ecc /* U+1ECC LATIN CAPITAL LETTER O WITH DOT BELOW */ +#define XK_obelowdot 0x1001ecd /* U+1ECD LATIN SMALL LETTER O WITH DOT BELOW */ +#define XK_Ohook 0x1001ece /* U+1ECE LATIN CAPITAL LETTER O WITH HOOK ABOVE */ +#define XK_ohook 0x1001ecf /* U+1ECF LATIN SMALL LETTER O WITH HOOK ABOVE */ +#define XK_Ocircumflexacute 0x1001ed0 /* U+1ED0 LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND ACUTE */ +#define XK_ocircumflexacute 0x1001ed1 /* U+1ED1 LATIN SMALL LETTER O WITH CIRCUMFLEX AND ACUTE */ +#define XK_Ocircumflexgrave 0x1001ed2 /* U+1ED2 LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND GRAVE */ +#define XK_ocircumflexgrave 0x1001ed3 /* U+1ED3 LATIN SMALL LETTER O WITH CIRCUMFLEX AND GRAVE */ +#define XK_Ocircumflexhook 0x1001ed4 /* U+1ED4 LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE */ +#define XK_ocircumflexhook 0x1001ed5 /* U+1ED5 LATIN SMALL LETTER O WITH CIRCUMFLEX AND HOOK ABOVE */ +#define XK_Ocircumflextilde 0x1001ed6 /* U+1ED6 LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND TILDE */ +#define XK_ocircumflextilde 0x1001ed7 /* U+1ED7 LATIN SMALL LETTER O WITH CIRCUMFLEX AND TILDE */ +#define XK_Ocircumflexbelowdot 0x1001ed8 /* U+1ED8 LATIN CAPITAL LETTER O WITH CIRCUMFLEX AND DOT BELOW */ +#define XK_ocircumflexbelowdot 0x1001ed9 /* U+1ED9 LATIN SMALL LETTER O WITH CIRCUMFLEX AND DOT BELOW */ +#define XK_Ohornacute 0x1001eda /* U+1EDA LATIN CAPITAL LETTER O WITH HORN AND ACUTE */ +#define XK_ohornacute 0x1001edb /* U+1EDB LATIN SMALL LETTER O WITH HORN AND ACUTE */ +#define XK_Ohorngrave 0x1001edc /* U+1EDC LATIN CAPITAL LETTER O WITH HORN AND GRAVE */ +#define XK_ohorngrave 0x1001edd /* U+1EDD LATIN SMALL LETTER O WITH HORN AND GRAVE */ +#define XK_Ohornhook 0x1001ede /* U+1EDE LATIN CAPITAL LETTER O WITH HORN AND HOOK ABOVE */ +#define XK_ohornhook 0x1001edf /* U+1EDF LATIN SMALL LETTER O WITH HORN AND HOOK ABOVE */ +#define XK_Ohorntilde 0x1001ee0 /* U+1EE0 LATIN CAPITAL LETTER O WITH HORN AND TILDE */ +#define XK_ohorntilde 0x1001ee1 /* U+1EE1 LATIN SMALL LETTER O WITH HORN AND TILDE */ +#define XK_Ohornbelowdot 0x1001ee2 /* U+1EE2 LATIN CAPITAL LETTER O WITH HORN AND DOT BELOW */ +#define XK_ohornbelowdot 0x1001ee3 /* U+1EE3 LATIN SMALL LETTER O WITH HORN AND DOT BELOW */ +#define XK_Ubelowdot 0x1001ee4 /* U+1EE4 LATIN CAPITAL LETTER U WITH DOT BELOW */ +#define XK_ubelowdot 0x1001ee5 /* U+1EE5 LATIN SMALL LETTER U WITH DOT BELOW */ +#define XK_Uhook 0x1001ee6 /* U+1EE6 LATIN CAPITAL LETTER U WITH HOOK ABOVE */ +#define XK_uhook 0x1001ee7 /* U+1EE7 LATIN SMALL LETTER U WITH HOOK ABOVE */ +#define XK_Uhornacute 0x1001ee8 /* U+1EE8 LATIN CAPITAL LETTER U WITH HORN AND ACUTE */ +#define XK_uhornacute 0x1001ee9 /* U+1EE9 LATIN SMALL LETTER U WITH HORN AND ACUTE */ +#define XK_Uhorngrave 0x1001eea /* U+1EEA LATIN CAPITAL LETTER U WITH HORN AND GRAVE */ +#define XK_uhorngrave 0x1001eeb /* U+1EEB LATIN SMALL LETTER U WITH HORN AND GRAVE */ +#define XK_Uhornhook 0x1001eec /* U+1EEC LATIN CAPITAL LETTER U WITH HORN AND HOOK ABOVE */ +#define XK_uhornhook 0x1001eed /* U+1EED LATIN SMALL LETTER U WITH HORN AND HOOK ABOVE */ +#define XK_Uhorntilde 0x1001eee /* U+1EEE LATIN CAPITAL LETTER U WITH HORN AND TILDE */ +#define XK_uhorntilde 0x1001eef /* U+1EEF LATIN SMALL LETTER U WITH HORN AND TILDE */ +#define XK_Uhornbelowdot 0x1001ef0 /* U+1EF0 LATIN CAPITAL LETTER U WITH HORN AND DOT BELOW */ +#define XK_uhornbelowdot 0x1001ef1 /* U+1EF1 LATIN SMALL LETTER U WITH HORN AND DOT BELOW */ +#define XK_Ybelowdot 0x1001ef4 /* U+1EF4 LATIN CAPITAL LETTER Y WITH DOT BELOW */ +#define XK_ybelowdot 0x1001ef5 /* U+1EF5 LATIN SMALL LETTER Y WITH DOT BELOW */ +#define XK_Yhook 0x1001ef6 /* U+1EF6 LATIN CAPITAL LETTER Y WITH HOOK ABOVE */ +#define XK_yhook 0x1001ef7 /* U+1EF7 LATIN SMALL LETTER Y WITH HOOK ABOVE */ +#define XK_Ytilde 0x1001ef8 /* U+1EF8 LATIN CAPITAL LETTER Y WITH TILDE */ +#define XK_ytilde 0x1001ef9 /* U+1EF9 LATIN SMALL LETTER Y WITH TILDE */ +#define XK_Ohorn 0x10001a0 /* U+01A0 LATIN CAPITAL LETTER O WITH HORN */ +#define XK_ohorn 0x10001a1 /* U+01A1 LATIN SMALL LETTER O WITH HORN */ +#define XK_Uhorn 0x10001af /* U+01AF LATIN CAPITAL LETTER U WITH HORN */ +#define XK_uhorn 0x10001b0 /* U+01B0 LATIN SMALL LETTER U WITH HORN */ +#define XK_combining_tilde 0x1000303 /* U+0303 COMBINING TILDE */ +#define XK_combining_grave 0x1000300 /* U+0300 COMBINING GRAVE ACCENT */ +#define XK_combining_acute 0x1000301 /* U+0301 COMBINING ACUTE ACCENT */ +#define XK_combining_hook 0x1000309 /* U+0309 COMBINING HOOK ABOVE */ +#define XK_combining_belowdot 0x1000323 /* U+0323 COMBINING DOT BELOW */ + +#endif /* XK_VIETNAMESE */ + +#ifdef XK_CURRENCY +#define XK_EcuSign 0x10020a0 /* U+20A0 EURO-CURRENCY SIGN */ +#define XK_ColonSign 0x10020a1 /* U+20A1 COLON SIGN */ +#define XK_CruzeiroSign 0x10020a2 /* U+20A2 CRUZEIRO SIGN */ +#define XK_FFrancSign 0x10020a3 /* U+20A3 FRENCH FRANC SIGN */ +#define XK_LiraSign 0x10020a4 /* U+20A4 LIRA SIGN */ +#define XK_MillSign 0x10020a5 /* U+20A5 MILL SIGN */ +#define XK_NairaSign 0x10020a6 /* U+20A6 NAIRA SIGN */ +#define XK_PesetaSign 0x10020a7 /* U+20A7 PESETA SIGN */ +#define XK_RupeeSign 0x10020a8 /* U+20A8 RUPEE SIGN */ +#define XK_WonSign 0x10020a9 /* U+20A9 WON SIGN */ +#define XK_NewSheqelSign 0x10020aa /* U+20AA NEW SHEQEL SIGN */ +#define XK_DongSign 0x10020ab /* U+20AB DONG SIGN */ +#define XK_EuroSign 0x20ac /* U+20AC EURO SIGN */ +#endif /* XK_CURRENCY */ + +#ifdef XK_MATHEMATICAL +/* one, two and three are defined above. */ +#define XK_zerosuperior 0x1002070 /* U+2070 SUPERSCRIPT ZERO */ +#define XK_foursuperior 0x1002074 /* U+2074 SUPERSCRIPT FOUR */ +#define XK_fivesuperior 0x1002075 /* U+2075 SUPERSCRIPT FIVE */ +#define XK_sixsuperior 0x1002076 /* U+2076 SUPERSCRIPT SIX */ +#define XK_sevensuperior 0x1002077 /* U+2077 SUPERSCRIPT SEVEN */ +#define XK_eightsuperior 0x1002078 /* U+2078 SUPERSCRIPT EIGHT */ +#define XK_ninesuperior 0x1002079 /* U+2079 SUPERSCRIPT NINE */ +#define XK_zerosubscript 0x1002080 /* U+2080 SUBSCRIPT ZERO */ +#define XK_onesubscript 0x1002081 /* U+2081 SUBSCRIPT ONE */ +#define XK_twosubscript 0x1002082 /* U+2082 SUBSCRIPT TWO */ +#define XK_threesubscript 0x1002083 /* U+2083 SUBSCRIPT THREE */ +#define XK_foursubscript 0x1002084 /* U+2084 SUBSCRIPT FOUR */ +#define XK_fivesubscript 0x1002085 /* U+2085 SUBSCRIPT FIVE */ +#define XK_sixsubscript 0x1002086 /* U+2086 SUBSCRIPT SIX */ +#define XK_sevensubscript 0x1002087 /* U+2087 SUBSCRIPT SEVEN */ +#define XK_eightsubscript 0x1002088 /* U+2088 SUBSCRIPT EIGHT */ +#define XK_ninesubscript 0x1002089 /* U+2089 SUBSCRIPT NINE */ +#define XK_partdifferential 0x1002202 /* U+2202 PARTIAL DIFFERENTIAL */ +#define XK_emptyset 0x1002205 /* U+2205 EMPTY SET */ +#define XK_elementof 0x1002208 /* U+2208 ELEMENT OF */ +#define XK_notelementof 0x1002209 /* U+2209 NOT AN ELEMENT OF */ +#define XK_containsas 0x100220b /* U+220B CONTAINS AS MEMBER */ +#define XK_squareroot 0x100221a /* U+221A SQUARE ROOT */ +#define XK_cuberoot 0x100221b /* U+221B CUBE ROOT */ +#define XK_fourthroot 0x100221c /* U+221C FOURTH ROOT */ +#define XK_dintegral 0x100222c /* U+222C DOUBLE INTEGRAL */ +#define XK_tintegral 0x100222d /* U+222D TRIPLE INTEGRAL */ +#define XK_because 0x1002235 /* U+2235 BECAUSE */ +#define XK_approxeq 0x1002248 /*(U+2248 ALMOST EQUAL TO)*/ +#define XK_notapproxeq 0x1002247 /*(U+2247 NEITHER APPROXIMATELY NOR ACTUALLY EQUAL TO)*/ +#define XK_notidentical 0x1002262 /* U+2262 NOT IDENTICAL TO */ +#define XK_stricteq 0x1002263 /* U+2263 STRICTLY EQUIVALENT TO */ +#endif /* XK_MATHEMATICAL */ + +#ifdef XK_BRAILLE +#define XK_braille_dot_1 0xfff1 +#define XK_braille_dot_2 0xfff2 +#define XK_braille_dot_3 0xfff3 +#define XK_braille_dot_4 0xfff4 +#define XK_braille_dot_5 0xfff5 +#define XK_braille_dot_6 0xfff6 +#define XK_braille_dot_7 0xfff7 +#define XK_braille_dot_8 0xfff8 +#define XK_braille_dot_9 0xfff9 +#define XK_braille_dot_10 0xfffa +#define XK_braille_blank 0x1002800 /* U+2800 BRAILLE PATTERN BLANK */ +#define XK_braille_dots_1 0x1002801 /* U+2801 BRAILLE PATTERN DOTS-1 */ +#define XK_braille_dots_2 0x1002802 /* U+2802 BRAILLE PATTERN DOTS-2 */ +#define XK_braille_dots_12 0x1002803 /* U+2803 BRAILLE PATTERN DOTS-12 */ +#define XK_braille_dots_3 0x1002804 /* U+2804 BRAILLE PATTERN DOTS-3 */ +#define XK_braille_dots_13 0x1002805 /* U+2805 BRAILLE PATTERN DOTS-13 */ +#define XK_braille_dots_23 0x1002806 /* U+2806 BRAILLE PATTERN DOTS-23 */ +#define XK_braille_dots_123 0x1002807 /* U+2807 BRAILLE PATTERN DOTS-123 */ +#define XK_braille_dots_4 0x1002808 /* U+2808 BRAILLE PATTERN DOTS-4 */ +#define XK_braille_dots_14 0x1002809 /* U+2809 BRAILLE PATTERN DOTS-14 */ +#define XK_braille_dots_24 0x100280a /* U+280A BRAILLE PATTERN DOTS-24 */ +#define XK_braille_dots_124 0x100280b /* U+280B BRAILLE PATTERN DOTS-124 */ +#define XK_braille_dots_34 0x100280c /* U+280C BRAILLE PATTERN DOTS-34 */ +#define XK_braille_dots_134 0x100280d /* U+280D BRAILLE PATTERN DOTS-134 */ +#define XK_braille_dots_234 0x100280e /* U+280E BRAILLE PATTERN DOTS-234 */ +#define XK_braille_dots_1234 0x100280f /* U+280F BRAILLE PATTERN DOTS-1234 */ +#define XK_braille_dots_5 0x1002810 /* U+2810 BRAILLE PATTERN DOTS-5 */ +#define XK_braille_dots_15 0x1002811 /* U+2811 BRAILLE PATTERN DOTS-15 */ +#define XK_braille_dots_25 0x1002812 /* U+2812 BRAILLE PATTERN DOTS-25 */ +#define XK_braille_dots_125 0x1002813 /* U+2813 BRAILLE PATTERN DOTS-125 */ +#define XK_braille_dots_35 0x1002814 /* U+2814 BRAILLE PATTERN DOTS-35 */ +#define XK_braille_dots_135 0x1002815 /* U+2815 BRAILLE PATTERN DOTS-135 */ +#define XK_braille_dots_235 0x1002816 /* U+2816 BRAILLE PATTERN DOTS-235 */ +#define XK_braille_dots_1235 0x1002817 /* U+2817 BRAILLE PATTERN DOTS-1235 */ +#define XK_braille_dots_45 0x1002818 /* U+2818 BRAILLE PATTERN DOTS-45 */ +#define XK_braille_dots_145 0x1002819 /* U+2819 BRAILLE PATTERN DOTS-145 */ +#define XK_braille_dots_245 0x100281a /* U+281A BRAILLE PATTERN DOTS-245 */ +#define XK_braille_dots_1245 0x100281b /* U+281B BRAILLE PATTERN DOTS-1245 */ +#define XK_braille_dots_345 0x100281c /* U+281C BRAILLE PATTERN DOTS-345 */ +#define XK_braille_dots_1345 0x100281d /* U+281D BRAILLE PATTERN DOTS-1345 */ +#define XK_braille_dots_2345 0x100281e /* U+281E BRAILLE PATTERN DOTS-2345 */ +#define XK_braille_dots_12345 0x100281f /* U+281F BRAILLE PATTERN DOTS-12345 */ +#define XK_braille_dots_6 0x1002820 /* U+2820 BRAILLE PATTERN DOTS-6 */ +#define XK_braille_dots_16 0x1002821 /* U+2821 BRAILLE PATTERN DOTS-16 */ +#define XK_braille_dots_26 0x1002822 /* U+2822 BRAILLE PATTERN DOTS-26 */ +#define XK_braille_dots_126 0x1002823 /* U+2823 BRAILLE PATTERN DOTS-126 */ +#define XK_braille_dots_36 0x1002824 /* U+2824 BRAILLE PATTERN DOTS-36 */ +#define XK_braille_dots_136 0x1002825 /* U+2825 BRAILLE PATTERN DOTS-136 */ +#define XK_braille_dots_236 0x1002826 /* U+2826 BRAILLE PATTERN DOTS-236 */ +#define XK_braille_dots_1236 0x1002827 /* U+2827 BRAILLE PATTERN DOTS-1236 */ +#define XK_braille_dots_46 0x1002828 /* U+2828 BRAILLE PATTERN DOTS-46 */ +#define XK_braille_dots_146 0x1002829 /* U+2829 BRAILLE PATTERN DOTS-146 */ +#define XK_braille_dots_246 0x100282a /* U+282A BRAILLE PATTERN DOTS-246 */ +#define XK_braille_dots_1246 0x100282b /* U+282B BRAILLE PATTERN DOTS-1246 */ +#define XK_braille_dots_346 0x100282c /* U+282C BRAILLE PATTERN DOTS-346 */ +#define XK_braille_dots_1346 0x100282d /* U+282D BRAILLE PATTERN DOTS-1346 */ +#define XK_braille_dots_2346 0x100282e /* U+282E BRAILLE PATTERN DOTS-2346 */ +#define XK_braille_dots_12346 0x100282f /* U+282F BRAILLE PATTERN DOTS-12346 */ +#define XK_braille_dots_56 0x1002830 /* U+2830 BRAILLE PATTERN DOTS-56 */ +#define XK_braille_dots_156 0x1002831 /* U+2831 BRAILLE PATTERN DOTS-156 */ +#define XK_braille_dots_256 0x1002832 /* U+2832 BRAILLE PATTERN DOTS-256 */ +#define XK_braille_dots_1256 0x1002833 /* U+2833 BRAILLE PATTERN DOTS-1256 */ +#define XK_braille_dots_356 0x1002834 /* U+2834 BRAILLE PATTERN DOTS-356 */ +#define XK_braille_dots_1356 0x1002835 /* U+2835 BRAILLE PATTERN DOTS-1356 */ +#define XK_braille_dots_2356 0x1002836 /* U+2836 BRAILLE PATTERN DOTS-2356 */ +#define XK_braille_dots_12356 0x1002837 /* U+2837 BRAILLE PATTERN DOTS-12356 */ +#define XK_braille_dots_456 0x1002838 /* U+2838 BRAILLE PATTERN DOTS-456 */ +#define XK_braille_dots_1456 0x1002839 /* U+2839 BRAILLE PATTERN DOTS-1456 */ +#define XK_braille_dots_2456 0x100283a /* U+283A BRAILLE PATTERN DOTS-2456 */ +#define XK_braille_dots_12456 0x100283b /* U+283B BRAILLE PATTERN DOTS-12456 */ +#define XK_braille_dots_3456 0x100283c /* U+283C BRAILLE PATTERN DOTS-3456 */ +#define XK_braille_dots_13456 0x100283d /* U+283D BRAILLE PATTERN DOTS-13456 */ +#define XK_braille_dots_23456 0x100283e /* U+283E BRAILLE PATTERN DOTS-23456 */ +#define XK_braille_dots_123456 0x100283f /* U+283F BRAILLE PATTERN DOTS-123456 */ +#define XK_braille_dots_7 0x1002840 /* U+2840 BRAILLE PATTERN DOTS-7 */ +#define XK_braille_dots_17 0x1002841 /* U+2841 BRAILLE PATTERN DOTS-17 */ +#define XK_braille_dots_27 0x1002842 /* U+2842 BRAILLE PATTERN DOTS-27 */ +#define XK_braille_dots_127 0x1002843 /* U+2843 BRAILLE PATTERN DOTS-127 */ +#define XK_braille_dots_37 0x1002844 /* U+2844 BRAILLE PATTERN DOTS-37 */ +#define XK_braille_dots_137 0x1002845 /* U+2845 BRAILLE PATTERN DOTS-137 */ +#define XK_braille_dots_237 0x1002846 /* U+2846 BRAILLE PATTERN DOTS-237 */ +#define XK_braille_dots_1237 0x1002847 /* U+2847 BRAILLE PATTERN DOTS-1237 */ +#define XK_braille_dots_47 0x1002848 /* U+2848 BRAILLE PATTERN DOTS-47 */ +#define XK_braille_dots_147 0x1002849 /* U+2849 BRAILLE PATTERN DOTS-147 */ +#define XK_braille_dots_247 0x100284a /* U+284A BRAILLE PATTERN DOTS-247 */ +#define XK_braille_dots_1247 0x100284b /* U+284B BRAILLE PATTERN DOTS-1247 */ +#define XK_braille_dots_347 0x100284c /* U+284C BRAILLE PATTERN DOTS-347 */ +#define XK_braille_dots_1347 0x100284d /* U+284D BRAILLE PATTERN DOTS-1347 */ +#define XK_braille_dots_2347 0x100284e /* U+284E BRAILLE PATTERN DOTS-2347 */ +#define XK_braille_dots_12347 0x100284f /* U+284F BRAILLE PATTERN DOTS-12347 */ +#define XK_braille_dots_57 0x1002850 /* U+2850 BRAILLE PATTERN DOTS-57 */ +#define XK_braille_dots_157 0x1002851 /* U+2851 BRAILLE PATTERN DOTS-157 */ +#define XK_braille_dots_257 0x1002852 /* U+2852 BRAILLE PATTERN DOTS-257 */ +#define XK_braille_dots_1257 0x1002853 /* U+2853 BRAILLE PATTERN DOTS-1257 */ +#define XK_braille_dots_357 0x1002854 /* U+2854 BRAILLE PATTERN DOTS-357 */ +#define XK_braille_dots_1357 0x1002855 /* U+2855 BRAILLE PATTERN DOTS-1357 */ +#define XK_braille_dots_2357 0x1002856 /* U+2856 BRAILLE PATTERN DOTS-2357 */ +#define XK_braille_dots_12357 0x1002857 /* U+2857 BRAILLE PATTERN DOTS-12357 */ +#define XK_braille_dots_457 0x1002858 /* U+2858 BRAILLE PATTERN DOTS-457 */ +#define XK_braille_dots_1457 0x1002859 /* U+2859 BRAILLE PATTERN DOTS-1457 */ +#define XK_braille_dots_2457 0x100285a /* U+285A BRAILLE PATTERN DOTS-2457 */ +#define XK_braille_dots_12457 0x100285b /* U+285B BRAILLE PATTERN DOTS-12457 */ +#define XK_braille_dots_3457 0x100285c /* U+285C BRAILLE PATTERN DOTS-3457 */ +#define XK_braille_dots_13457 0x100285d /* U+285D BRAILLE PATTERN DOTS-13457 */ +#define XK_braille_dots_23457 0x100285e /* U+285E BRAILLE PATTERN DOTS-23457 */ +#define XK_braille_dots_123457 0x100285f /* U+285F BRAILLE PATTERN DOTS-123457 */ +#define XK_braille_dots_67 0x1002860 /* U+2860 BRAILLE PATTERN DOTS-67 */ +#define XK_braille_dots_167 0x1002861 /* U+2861 BRAILLE PATTERN DOTS-167 */ +#define XK_braille_dots_267 0x1002862 /* U+2862 BRAILLE PATTERN DOTS-267 */ +#define XK_braille_dots_1267 0x1002863 /* U+2863 BRAILLE PATTERN DOTS-1267 */ +#define XK_braille_dots_367 0x1002864 /* U+2864 BRAILLE PATTERN DOTS-367 */ +#define XK_braille_dots_1367 0x1002865 /* U+2865 BRAILLE PATTERN DOTS-1367 */ +#define XK_braille_dots_2367 0x1002866 /* U+2866 BRAILLE PATTERN DOTS-2367 */ +#define XK_braille_dots_12367 0x1002867 /* U+2867 BRAILLE PATTERN DOTS-12367 */ +#define XK_braille_dots_467 0x1002868 /* U+2868 BRAILLE PATTERN DOTS-467 */ +#define XK_braille_dots_1467 0x1002869 /* U+2869 BRAILLE PATTERN DOTS-1467 */ +#define XK_braille_dots_2467 0x100286a /* U+286A BRAILLE PATTERN DOTS-2467 */ +#define XK_braille_dots_12467 0x100286b /* U+286B BRAILLE PATTERN DOTS-12467 */ +#define XK_braille_dots_3467 0x100286c /* U+286C BRAILLE PATTERN DOTS-3467 */ +#define XK_braille_dots_13467 0x100286d /* U+286D BRAILLE PATTERN DOTS-13467 */ +#define XK_braille_dots_23467 0x100286e /* U+286E BRAILLE PATTERN DOTS-23467 */ +#define XK_braille_dots_123467 0x100286f /* U+286F BRAILLE PATTERN DOTS-123467 */ +#define XK_braille_dots_567 0x1002870 /* U+2870 BRAILLE PATTERN DOTS-567 */ +#define XK_braille_dots_1567 0x1002871 /* U+2871 BRAILLE PATTERN DOTS-1567 */ +#define XK_braille_dots_2567 0x1002872 /* U+2872 BRAILLE PATTERN DOTS-2567 */ +#define XK_braille_dots_12567 0x1002873 /* U+2873 BRAILLE PATTERN DOTS-12567 */ +#define XK_braille_dots_3567 0x1002874 /* U+2874 BRAILLE PATTERN DOTS-3567 */ +#define XK_braille_dots_13567 0x1002875 /* U+2875 BRAILLE PATTERN DOTS-13567 */ +#define XK_braille_dots_23567 0x1002876 /* U+2876 BRAILLE PATTERN DOTS-23567 */ +#define XK_braille_dots_123567 0x1002877 /* U+2877 BRAILLE PATTERN DOTS-123567 */ +#define XK_braille_dots_4567 0x1002878 /* U+2878 BRAILLE PATTERN DOTS-4567 */ +#define XK_braille_dots_14567 0x1002879 /* U+2879 BRAILLE PATTERN DOTS-14567 */ +#define XK_braille_dots_24567 0x100287a /* U+287A BRAILLE PATTERN DOTS-24567 */ +#define XK_braille_dots_124567 0x100287b /* U+287B BRAILLE PATTERN DOTS-124567 */ +#define XK_braille_dots_34567 0x100287c /* U+287C BRAILLE PATTERN DOTS-34567 */ +#define XK_braille_dots_134567 0x100287d /* U+287D BRAILLE PATTERN DOTS-134567 */ +#define XK_braille_dots_234567 0x100287e /* U+287E BRAILLE PATTERN DOTS-234567 */ +#define XK_braille_dots_1234567 0x100287f /* U+287F BRAILLE PATTERN DOTS-1234567 */ +#define XK_braille_dots_8 0x1002880 /* U+2880 BRAILLE PATTERN DOTS-8 */ +#define XK_braille_dots_18 0x1002881 /* U+2881 BRAILLE PATTERN DOTS-18 */ +#define XK_braille_dots_28 0x1002882 /* U+2882 BRAILLE PATTERN DOTS-28 */ +#define XK_braille_dots_128 0x1002883 /* U+2883 BRAILLE PATTERN DOTS-128 */ +#define XK_braille_dots_38 0x1002884 /* U+2884 BRAILLE PATTERN DOTS-38 */ +#define XK_braille_dots_138 0x1002885 /* U+2885 BRAILLE PATTERN DOTS-138 */ +#define XK_braille_dots_238 0x1002886 /* U+2886 BRAILLE PATTERN DOTS-238 */ +#define XK_braille_dots_1238 0x1002887 /* U+2887 BRAILLE PATTERN DOTS-1238 */ +#define XK_braille_dots_48 0x1002888 /* U+2888 BRAILLE PATTERN DOTS-48 */ +#define XK_braille_dots_148 0x1002889 /* U+2889 BRAILLE PATTERN DOTS-148 */ +#define XK_braille_dots_248 0x100288a /* U+288A BRAILLE PATTERN DOTS-248 */ +#define XK_braille_dots_1248 0x100288b /* U+288B BRAILLE PATTERN DOTS-1248 */ +#define XK_braille_dots_348 0x100288c /* U+288C BRAILLE PATTERN DOTS-348 */ +#define XK_braille_dots_1348 0x100288d /* U+288D BRAILLE PATTERN DOTS-1348 */ +#define XK_braille_dots_2348 0x100288e /* U+288E BRAILLE PATTERN DOTS-2348 */ +#define XK_braille_dots_12348 0x100288f /* U+288F BRAILLE PATTERN DOTS-12348 */ +#define XK_braille_dots_58 0x1002890 /* U+2890 BRAILLE PATTERN DOTS-58 */ +#define XK_braille_dots_158 0x1002891 /* U+2891 BRAILLE PATTERN DOTS-158 */ +#define XK_braille_dots_258 0x1002892 /* U+2892 BRAILLE PATTERN DOTS-258 */ +#define XK_braille_dots_1258 0x1002893 /* U+2893 BRAILLE PATTERN DOTS-1258 */ +#define XK_braille_dots_358 0x1002894 /* U+2894 BRAILLE PATTERN DOTS-358 */ +#define XK_braille_dots_1358 0x1002895 /* U+2895 BRAILLE PATTERN DOTS-1358 */ +#define XK_braille_dots_2358 0x1002896 /* U+2896 BRAILLE PATTERN DOTS-2358 */ +#define XK_braille_dots_12358 0x1002897 /* U+2897 BRAILLE PATTERN DOTS-12358 */ +#define XK_braille_dots_458 0x1002898 /* U+2898 BRAILLE PATTERN DOTS-458 */ +#define XK_braille_dots_1458 0x1002899 /* U+2899 BRAILLE PATTERN DOTS-1458 */ +#define XK_braille_dots_2458 0x100289a /* U+289A BRAILLE PATTERN DOTS-2458 */ +#define XK_braille_dots_12458 0x100289b /* U+289B BRAILLE PATTERN DOTS-12458 */ +#define XK_braille_dots_3458 0x100289c /* U+289C BRAILLE PATTERN DOTS-3458 */ +#define XK_braille_dots_13458 0x100289d /* U+289D BRAILLE PATTERN DOTS-13458 */ +#define XK_braille_dots_23458 0x100289e /* U+289E BRAILLE PATTERN DOTS-23458 */ +#define XK_braille_dots_123458 0x100289f /* U+289F BRAILLE PATTERN DOTS-123458 */ +#define XK_braille_dots_68 0x10028a0 /* U+28A0 BRAILLE PATTERN DOTS-68 */ +#define XK_braille_dots_168 0x10028a1 /* U+28A1 BRAILLE PATTERN DOTS-168 */ +#define XK_braille_dots_268 0x10028a2 /* U+28A2 BRAILLE PATTERN DOTS-268 */ +#define XK_braille_dots_1268 0x10028a3 /* U+28A3 BRAILLE PATTERN DOTS-1268 */ +#define XK_braille_dots_368 0x10028a4 /* U+28A4 BRAILLE PATTERN DOTS-368 */ +#define XK_braille_dots_1368 0x10028a5 /* U+28A5 BRAILLE PATTERN DOTS-1368 */ +#define XK_braille_dots_2368 0x10028a6 /* U+28A6 BRAILLE PATTERN DOTS-2368 */ +#define XK_braille_dots_12368 0x10028a7 /* U+28A7 BRAILLE PATTERN DOTS-12368 */ +#define XK_braille_dots_468 0x10028a8 /* U+28A8 BRAILLE PATTERN DOTS-468 */ +#define XK_braille_dots_1468 0x10028a9 /* U+28A9 BRAILLE PATTERN DOTS-1468 */ +#define XK_braille_dots_2468 0x10028aa /* U+28AA BRAILLE PATTERN DOTS-2468 */ +#define XK_braille_dots_12468 0x10028ab /* U+28AB BRAILLE PATTERN DOTS-12468 */ +#define XK_braille_dots_3468 0x10028ac /* U+28AC BRAILLE PATTERN DOTS-3468 */ +#define XK_braille_dots_13468 0x10028ad /* U+28AD BRAILLE PATTERN DOTS-13468 */ +#define XK_braille_dots_23468 0x10028ae /* U+28AE BRAILLE PATTERN DOTS-23468 */ +#define XK_braille_dots_123468 0x10028af /* U+28AF BRAILLE PATTERN DOTS-123468 */ +#define XK_braille_dots_568 0x10028b0 /* U+28B0 BRAILLE PATTERN DOTS-568 */ +#define XK_braille_dots_1568 0x10028b1 /* U+28B1 BRAILLE PATTERN DOTS-1568 */ +#define XK_braille_dots_2568 0x10028b2 /* U+28B2 BRAILLE PATTERN DOTS-2568 */ +#define XK_braille_dots_12568 0x10028b3 /* U+28B3 BRAILLE PATTERN DOTS-12568 */ +#define XK_braille_dots_3568 0x10028b4 /* U+28B4 BRAILLE PATTERN DOTS-3568 */ +#define XK_braille_dots_13568 0x10028b5 /* U+28B5 BRAILLE PATTERN DOTS-13568 */ +#define XK_braille_dots_23568 0x10028b6 /* U+28B6 BRAILLE PATTERN DOTS-23568 */ +#define XK_braille_dots_123568 0x10028b7 /* U+28B7 BRAILLE PATTERN DOTS-123568 */ +#define XK_braille_dots_4568 0x10028b8 /* U+28B8 BRAILLE PATTERN DOTS-4568 */ +#define XK_braille_dots_14568 0x10028b9 /* U+28B9 BRAILLE PATTERN DOTS-14568 */ +#define XK_braille_dots_24568 0x10028ba /* U+28BA BRAILLE PATTERN DOTS-24568 */ +#define XK_braille_dots_124568 0x10028bb /* U+28BB BRAILLE PATTERN DOTS-124568 */ +#define XK_braille_dots_34568 0x10028bc /* U+28BC BRAILLE PATTERN DOTS-34568 */ +#define XK_braille_dots_134568 0x10028bd /* U+28BD BRAILLE PATTERN DOTS-134568 */ +#define XK_braille_dots_234568 0x10028be /* U+28BE BRAILLE PATTERN DOTS-234568 */ +#define XK_braille_dots_1234568 0x10028bf /* U+28BF BRAILLE PATTERN DOTS-1234568 */ +#define XK_braille_dots_78 0x10028c0 /* U+28C0 BRAILLE PATTERN DOTS-78 */ +#define XK_braille_dots_178 0x10028c1 /* U+28C1 BRAILLE PATTERN DOTS-178 */ +#define XK_braille_dots_278 0x10028c2 /* U+28C2 BRAILLE PATTERN DOTS-278 */ +#define XK_braille_dots_1278 0x10028c3 /* U+28C3 BRAILLE PATTERN DOTS-1278 */ +#define XK_braille_dots_378 0x10028c4 /* U+28C4 BRAILLE PATTERN DOTS-378 */ +#define XK_braille_dots_1378 0x10028c5 /* U+28C5 BRAILLE PATTERN DOTS-1378 */ +#define XK_braille_dots_2378 0x10028c6 /* U+28C6 BRAILLE PATTERN DOTS-2378 */ +#define XK_braille_dots_12378 0x10028c7 /* U+28C7 BRAILLE PATTERN DOTS-12378 */ +#define XK_braille_dots_478 0x10028c8 /* U+28C8 BRAILLE PATTERN DOTS-478 */ +#define XK_braille_dots_1478 0x10028c9 /* U+28C9 BRAILLE PATTERN DOTS-1478 */ +#define XK_braille_dots_2478 0x10028ca /* U+28CA BRAILLE PATTERN DOTS-2478 */ +#define XK_braille_dots_12478 0x10028cb /* U+28CB BRAILLE PATTERN DOTS-12478 */ +#define XK_braille_dots_3478 0x10028cc /* U+28CC BRAILLE PATTERN DOTS-3478 */ +#define XK_braille_dots_13478 0x10028cd /* U+28CD BRAILLE PATTERN DOTS-13478 */ +#define XK_braille_dots_23478 0x10028ce /* U+28CE BRAILLE PATTERN DOTS-23478 */ +#define XK_braille_dots_123478 0x10028cf /* U+28CF BRAILLE PATTERN DOTS-123478 */ +#define XK_braille_dots_578 0x10028d0 /* U+28D0 BRAILLE PATTERN DOTS-578 */ +#define XK_braille_dots_1578 0x10028d1 /* U+28D1 BRAILLE PATTERN DOTS-1578 */ +#define XK_braille_dots_2578 0x10028d2 /* U+28D2 BRAILLE PATTERN DOTS-2578 */ +#define XK_braille_dots_12578 0x10028d3 /* U+28D3 BRAILLE PATTERN DOTS-12578 */ +#define XK_braille_dots_3578 0x10028d4 /* U+28D4 BRAILLE PATTERN DOTS-3578 */ +#define XK_braille_dots_13578 0x10028d5 /* U+28D5 BRAILLE PATTERN DOTS-13578 */ +#define XK_braille_dots_23578 0x10028d6 /* U+28D6 BRAILLE PATTERN DOTS-23578 */ +#define XK_braille_dots_123578 0x10028d7 /* U+28D7 BRAILLE PATTERN DOTS-123578 */ +#define XK_braille_dots_4578 0x10028d8 /* U+28D8 BRAILLE PATTERN DOTS-4578 */ +#define XK_braille_dots_14578 0x10028d9 /* U+28D9 BRAILLE PATTERN DOTS-14578 */ +#define XK_braille_dots_24578 0x10028da /* U+28DA BRAILLE PATTERN DOTS-24578 */ +#define XK_braille_dots_124578 0x10028db /* U+28DB BRAILLE PATTERN DOTS-124578 */ +#define XK_braille_dots_34578 0x10028dc /* U+28DC BRAILLE PATTERN DOTS-34578 */ +#define XK_braille_dots_134578 0x10028dd /* U+28DD BRAILLE PATTERN DOTS-134578 */ +#define XK_braille_dots_234578 0x10028de /* U+28DE BRAILLE PATTERN DOTS-234578 */ +#define XK_braille_dots_1234578 0x10028df /* U+28DF BRAILLE PATTERN DOTS-1234578 */ +#define XK_braille_dots_678 0x10028e0 /* U+28E0 BRAILLE PATTERN DOTS-678 */ +#define XK_braille_dots_1678 0x10028e1 /* U+28E1 BRAILLE PATTERN DOTS-1678 */ +#define XK_braille_dots_2678 0x10028e2 /* U+28E2 BRAILLE PATTERN DOTS-2678 */ +#define XK_braille_dots_12678 0x10028e3 /* U+28E3 BRAILLE PATTERN DOTS-12678 */ +#define XK_braille_dots_3678 0x10028e4 /* U+28E4 BRAILLE PATTERN DOTS-3678 */ +#define XK_braille_dots_13678 0x10028e5 /* U+28E5 BRAILLE PATTERN DOTS-13678 */ +#define XK_braille_dots_23678 0x10028e6 /* U+28E6 BRAILLE PATTERN DOTS-23678 */ +#define XK_braille_dots_123678 0x10028e7 /* U+28E7 BRAILLE PATTERN DOTS-123678 */ +#define XK_braille_dots_4678 0x10028e8 /* U+28E8 BRAILLE PATTERN DOTS-4678 */ +#define XK_braille_dots_14678 0x10028e9 /* U+28E9 BRAILLE PATTERN DOTS-14678 */ +#define XK_braille_dots_24678 0x10028ea /* U+28EA BRAILLE PATTERN DOTS-24678 */ +#define XK_braille_dots_124678 0x10028eb /* U+28EB BRAILLE PATTERN DOTS-124678 */ +#define XK_braille_dots_34678 0x10028ec /* U+28EC BRAILLE PATTERN DOTS-34678 */ +#define XK_braille_dots_134678 0x10028ed /* U+28ED BRAILLE PATTERN DOTS-134678 */ +#define XK_braille_dots_234678 0x10028ee /* U+28EE BRAILLE PATTERN DOTS-234678 */ +#define XK_braille_dots_1234678 0x10028ef /* U+28EF BRAILLE PATTERN DOTS-1234678 */ +#define XK_braille_dots_5678 0x10028f0 /* U+28F0 BRAILLE PATTERN DOTS-5678 */ +#define XK_braille_dots_15678 0x10028f1 /* U+28F1 BRAILLE PATTERN DOTS-15678 */ +#define XK_braille_dots_25678 0x10028f2 /* U+28F2 BRAILLE PATTERN DOTS-25678 */ +#define XK_braille_dots_125678 0x10028f3 /* U+28F3 BRAILLE PATTERN DOTS-125678 */ +#define XK_braille_dots_35678 0x10028f4 /* U+28F4 BRAILLE PATTERN DOTS-35678 */ +#define XK_braille_dots_135678 0x10028f5 /* U+28F5 BRAILLE PATTERN DOTS-135678 */ +#define XK_braille_dots_235678 0x10028f6 /* U+28F6 BRAILLE PATTERN DOTS-235678 */ +#define XK_braille_dots_1235678 0x10028f7 /* U+28F7 BRAILLE PATTERN DOTS-1235678 */ +#define XK_braille_dots_45678 0x10028f8 /* U+28F8 BRAILLE PATTERN DOTS-45678 */ +#define XK_braille_dots_145678 0x10028f9 /* U+28F9 BRAILLE PATTERN DOTS-145678 */ +#define XK_braille_dots_245678 0x10028fa /* U+28FA BRAILLE PATTERN DOTS-245678 */ +#define XK_braille_dots_1245678 0x10028fb /* U+28FB BRAILLE PATTERN DOTS-1245678 */ +#define XK_braille_dots_345678 0x10028fc /* U+28FC BRAILLE PATTERN DOTS-345678 */ +#define XK_braille_dots_1345678 0x10028fd /* U+28FD BRAILLE PATTERN DOTS-1345678 */ +#define XK_braille_dots_2345678 0x10028fe /* U+28FE BRAILLE PATTERN DOTS-2345678 */ +#define XK_braille_dots_12345678 0x10028ff /* U+28FF BRAILLE PATTERN DOTS-12345678 */ +#endif /* XK_BRAILLE */ + +/* + * Sinhala (http://unicode.org/charts/PDF/U0D80.pdf) + * http://www.nongnu.org/sinhala/doc/transliteration/sinhala-transliteration_6.html + */ + +#ifdef XK_SINHALA +#define XK_Sinh_ng 0x1000d82 /* U+0D82 SINHALA SIGN ANUSVARAYA */ +#define XK_Sinh_h2 0x1000d83 /* U+0D83 SINHALA SIGN VISARGAYA */ +#define XK_Sinh_a 0x1000d85 /* U+0D85 SINHALA LETTER AYANNA */ +#define XK_Sinh_aa 0x1000d86 /* U+0D86 SINHALA LETTER AAYANNA */ +#define XK_Sinh_ae 0x1000d87 /* U+0D87 SINHALA LETTER AEYANNA */ +#define XK_Sinh_aee 0x1000d88 /* U+0D88 SINHALA LETTER AEEYANNA */ +#define XK_Sinh_i 0x1000d89 /* U+0D89 SINHALA LETTER IYANNA */ +#define XK_Sinh_ii 0x1000d8a /* U+0D8A SINHALA LETTER IIYANNA */ +#define XK_Sinh_u 0x1000d8b /* U+0D8B SINHALA LETTER UYANNA */ +#define XK_Sinh_uu 0x1000d8c /* U+0D8C SINHALA LETTER UUYANNA */ +#define XK_Sinh_ri 0x1000d8d /* U+0D8D SINHALA LETTER IRUYANNA */ +#define XK_Sinh_rii 0x1000d8e /* U+0D8E SINHALA LETTER IRUUYANNA */ +#define XK_Sinh_lu 0x1000d8f /* U+0D8F SINHALA LETTER ILUYANNA */ +#define XK_Sinh_luu 0x1000d90 /* U+0D90 SINHALA LETTER ILUUYANNA */ +#define XK_Sinh_e 0x1000d91 /* U+0D91 SINHALA LETTER EYANNA */ +#define XK_Sinh_ee 0x1000d92 /* U+0D92 SINHALA LETTER EEYANNA */ +#define XK_Sinh_ai 0x1000d93 /* U+0D93 SINHALA LETTER AIYANNA */ +#define XK_Sinh_o 0x1000d94 /* U+0D94 SINHALA LETTER OYANNA */ +#define XK_Sinh_oo 0x1000d95 /* U+0D95 SINHALA LETTER OOYANNA */ +#define XK_Sinh_au 0x1000d96 /* U+0D96 SINHALA LETTER AUYANNA */ +#define XK_Sinh_ka 0x1000d9a /* U+0D9A SINHALA LETTER ALPAPRAANA KAYANNA */ +#define XK_Sinh_kha 0x1000d9b /* U+0D9B SINHALA LETTER MAHAAPRAANA KAYANNA */ +#define XK_Sinh_ga 0x1000d9c /* U+0D9C SINHALA LETTER ALPAPRAANA GAYANNA */ +#define XK_Sinh_gha 0x1000d9d /* U+0D9D SINHALA LETTER MAHAAPRAANA GAYANNA */ +#define XK_Sinh_ng2 0x1000d9e /* U+0D9E SINHALA LETTER KANTAJA NAASIKYAYA */ +#define XK_Sinh_nga 0x1000d9f /* U+0D9F SINHALA LETTER SANYAKA GAYANNA */ +#define XK_Sinh_ca 0x1000da0 /* U+0DA0 SINHALA LETTER ALPAPRAANA CAYANNA */ +#define XK_Sinh_cha 0x1000da1 /* U+0DA1 SINHALA LETTER MAHAAPRAANA CAYANNA */ +#define XK_Sinh_ja 0x1000da2 /* U+0DA2 SINHALA LETTER ALPAPRAANA JAYANNA */ +#define XK_Sinh_jha 0x1000da3 /* U+0DA3 SINHALA LETTER MAHAAPRAANA JAYANNA */ +#define XK_Sinh_nya 0x1000da4 /* U+0DA4 SINHALA LETTER TAALUJA NAASIKYAYA */ +#define XK_Sinh_jnya 0x1000da5 /* U+0DA5 SINHALA LETTER TAALUJA SANYOOGA NAAKSIKYAYA */ +#define XK_Sinh_nja 0x1000da6 /* U+0DA6 SINHALA LETTER SANYAKA JAYANNA */ +#define XK_Sinh_tta 0x1000da7 /* U+0DA7 SINHALA LETTER ALPAPRAANA TTAYANNA */ +#define XK_Sinh_ttha 0x1000da8 /* U+0DA8 SINHALA LETTER MAHAAPRAANA TTAYANNA */ +#define XK_Sinh_dda 0x1000da9 /* U+0DA9 SINHALA LETTER ALPAPRAANA DDAYANNA */ +#define XK_Sinh_ddha 0x1000daa /* U+0DAA SINHALA LETTER MAHAAPRAANA DDAYANNA */ +#define XK_Sinh_nna 0x1000dab /* U+0DAB SINHALA LETTER MUURDHAJA NAYANNA */ +#define XK_Sinh_ndda 0x1000dac /* U+0DAC SINHALA LETTER SANYAKA DDAYANNA */ +#define XK_Sinh_tha 0x1000dad /* U+0DAD SINHALA LETTER ALPAPRAANA TAYANNA */ +#define XK_Sinh_thha 0x1000dae /* U+0DAE SINHALA LETTER MAHAAPRAANA TAYANNA */ +#define XK_Sinh_dha 0x1000daf /* U+0DAF SINHALA LETTER ALPAPRAANA DAYANNA */ +#define XK_Sinh_dhha 0x1000db0 /* U+0DB0 SINHALA LETTER MAHAAPRAANA DAYANNA */ +#define XK_Sinh_na 0x1000db1 /* U+0DB1 SINHALA LETTER DANTAJA NAYANNA */ +#define XK_Sinh_ndha 0x1000db3 /* U+0DB3 SINHALA LETTER SANYAKA DAYANNA */ +#define XK_Sinh_pa 0x1000db4 /* U+0DB4 SINHALA LETTER ALPAPRAANA PAYANNA */ +#define XK_Sinh_pha 0x1000db5 /* U+0DB5 SINHALA LETTER MAHAAPRAANA PAYANNA */ +#define XK_Sinh_ba 0x1000db6 /* U+0DB6 SINHALA LETTER ALPAPRAANA BAYANNA */ +#define XK_Sinh_bha 0x1000db7 /* U+0DB7 SINHALA LETTER MAHAAPRAANA BAYANNA */ +#define XK_Sinh_ma 0x1000db8 /* U+0DB8 SINHALA LETTER MAYANNA */ +#define XK_Sinh_mba 0x1000db9 /* U+0DB9 SINHALA LETTER AMBA BAYANNA */ +#define XK_Sinh_ya 0x1000dba /* U+0DBA SINHALA LETTER YAYANNA */ +#define XK_Sinh_ra 0x1000dbb /* U+0DBB SINHALA LETTER RAYANNA */ +#define XK_Sinh_la 0x1000dbd /* U+0DBD SINHALA LETTER DANTAJA LAYANNA */ +#define XK_Sinh_va 0x1000dc0 /* U+0DC0 SINHALA LETTER VAYANNA */ +#define XK_Sinh_sha 0x1000dc1 /* U+0DC1 SINHALA LETTER TAALUJA SAYANNA */ +#define XK_Sinh_ssha 0x1000dc2 /* U+0DC2 SINHALA LETTER MUURDHAJA SAYANNA */ +#define XK_Sinh_sa 0x1000dc3 /* U+0DC3 SINHALA LETTER DANTAJA SAYANNA */ +#define XK_Sinh_ha 0x1000dc4 /* U+0DC4 SINHALA LETTER HAYANNA */ +#define XK_Sinh_lla 0x1000dc5 /* U+0DC5 SINHALA LETTER MUURDHAJA LAYANNA */ +#define XK_Sinh_fa 0x1000dc6 /* U+0DC6 SINHALA LETTER FAYANNA */ +#define XK_Sinh_al 0x1000dca /* U+0DCA SINHALA SIGN AL-LAKUNA */ +#define XK_Sinh_aa2 0x1000dcf /* U+0DCF SINHALA VOWEL SIGN AELA-PILLA */ +#define XK_Sinh_ae2 0x1000dd0 /* U+0DD0 SINHALA VOWEL SIGN KETTI AEDA-PILLA */ +#define XK_Sinh_aee2 0x1000dd1 /* U+0DD1 SINHALA VOWEL SIGN DIGA AEDA-PILLA */ +#define XK_Sinh_i2 0x1000dd2 /* U+0DD2 SINHALA VOWEL SIGN KETTI IS-PILLA */ +#define XK_Sinh_ii2 0x1000dd3 /* U+0DD3 SINHALA VOWEL SIGN DIGA IS-PILLA */ +#define XK_Sinh_u2 0x1000dd4 /* U+0DD4 SINHALA VOWEL SIGN KETTI PAA-PILLA */ +#define XK_Sinh_uu2 0x1000dd6 /* U+0DD6 SINHALA VOWEL SIGN DIGA PAA-PILLA */ +#define XK_Sinh_ru2 0x1000dd8 /* U+0DD8 SINHALA VOWEL SIGN GAETTA-PILLA */ +#define XK_Sinh_e2 0x1000dd9 /* U+0DD9 SINHALA VOWEL SIGN KOMBUVA */ +#define XK_Sinh_ee2 0x1000dda /* U+0DDA SINHALA VOWEL SIGN DIGA KOMBUVA */ +#define XK_Sinh_ai2 0x1000ddb /* U+0DDB SINHALA VOWEL SIGN KOMBU DEKA */ +#define XK_Sinh_o2 0x1000ddc /* U+0DDC SINHALA VOWEL SIGN KOMBUVA HAA AELA-PILLA */ +#define XK_Sinh_oo2 0x1000ddd /* U+0DDD SINHALA VOWEL SIGN KOMBUVA HAA DIGA AELA-PILLA */ +#define XK_Sinh_au2 0x1000dde /* U+0DDE SINHALA VOWEL SIGN KOMBUVA HAA GAYANUKITTA */ +#define XK_Sinh_lu2 0x1000ddf /* U+0DDF SINHALA VOWEL SIGN GAYANUKITTA */ +#define XK_Sinh_ruu2 0x1000df2 /* U+0DF2 SINHALA VOWEL SIGN DIGA GAETTA-PILLA */ +#define XK_Sinh_luu2 0x1000df3 /* U+0DF3 SINHALA VOWEL SIGN DIGA GAYANUKITTA */ +#define XK_Sinh_kunddaliya 0x1000df4 /* U+0DF4 SINHALA PUNCTUATION KUNDDALIYA */ +#endif /* XK_SINHALA */ diff --git a/library/xkeyboard-config/vendor/symbols/de b/library/xkeyboard-config/vendor/symbols/de new file mode 100644 index 0000000..7eab164 --- /dev/null +++ b/library/xkeyboard-config/vendor/symbols/de @@ -0,0 +1,1232 @@ +// Keyboard layouts for Germany. + +default +xkb_symbols "basic" { + + include "latin(type4)" + + name[Group1]="German"; + + key {[dead_circumflex, degree, U2032, U2033 ]}; // ′ ″ + key {[ 2, quotedbl, twosuperior, oneeighth ]}; + key {[ 3, section, threesuperior, sterling ]}; + key {[ 4, dollar, onequarter, currency ]}; + key {[ ssharp, question, backslash, questiondown, U1E9E ], type[group1]="FOUR_LEVEL_PLUS_LOCK" }; + key {[ dead_acute, dead_grave, dead_cedilla, dead_ogonek ]}; + + key {[ e, E, EuroSign, EuroSign ]}; + key {[ z, Z, leftarrow, yen ]}; + key {[ udiaeresis, Udiaeresis, dead_diaeresis, dead_abovering ]}; + key {[ plus, asterisk, asciitilde, macron ]}; + + key {[ s, S, U017F, U1E9E ]}; // ſ ẞ + key {[ j, J, dead_belowdot, dead_abovedot ]}; + key {[ odiaeresis, Odiaeresis, dead_doubleacute, dead_belowdot ]}; + key {[ adiaeresis, Adiaeresis, dead_circumflex, dead_caron ]}; + key {[ numbersign, apostrophe, rightsinglequotemark, dead_breve ]}; + + key {[ less, greater, bar, dead_belowmacron ]}; + key {[ y, Y, guillemotright, U203A ]}; // » › + key {[ x, X, guillemotleft, U2039 ]}; // « ‹ + key {[ comma, semicolon, periodcentered, multiply ]}; + key {[ period, colon, U2026, division ]}; // … ÷ + key {[ minus, underscore, endash, emdash ]}; + + include "kpdl(comma)" + + include "level3(ralt_switch)" +}; + +partial alphanumeric_keys +xkb_symbols "deadtilde" { + // The previous standard German layout with tilde as dead key. + + include "de(basic)" + name[Group1]="German (dead tilde)"; + + key { [ plus, asterisk, dead_tilde, dead_macron ] }; +}; + +partial alphanumeric_keys +xkb_symbols "nodeadkeys" { + // Modify the basic German layout to not have any dead keys. + + include "de(basic)" + name[Group1]="German (no dead keys)"; + + key { [asciicircum, degree, notsign, notsign ] }; + key { [ acute, grave, cedilla, cedilla ] }; + key { [ udiaeresis, Udiaeresis, diaeresis, diaeresis ] }; + key { [ plus, asterisk, asciitilde, macron ] }; + key { [ j, J, ezh, EZH ] }; + key { [ odiaeresis, Odiaeresis, doubleacute, doubleacute ] }; + key { [ adiaeresis, Adiaeresis, asciicircum, asciicircum ] }; + key { [ numbersign, apostrophe, rightsinglequotemark, grave ] }; + key { [ less, greater, bar, dagger ] }; +}; + +partial alphanumeric_keys +xkb_symbols "deadgraveacute" { + // Modify the basic German layout to have only acute and grave as dead keys + // (~ and ^ are needed as spacing characters in many programming languages). + + include "de(basic)" + name[Group1]="German (dead grave acute)"; + + key { [asciicircum, degree, notsign, notsign ] }; + key { [ plus, asterisk, asciitilde, dead_macron ] }; + key { [ numbersign, apostrophe, rightsinglequotemark, grave ] }; +}; + +partial alphanumeric_keys +xkb_symbols "deadacute" { + // Modify the basic German layout to have only acute as a dead key. + + include "de(deadgraveacute)" + + name[Group1]="German (dead acute)"; + + key { [dead_acute, grave, dead_cedilla, dead_ogonek ] }; + key { [numbersign, apostrophe, rightsinglequotemark, dead_grave ] }; +}; + +partial alphanumeric_keys +xkb_symbols "e1" { + // German extended layout E1, based on DIN 2137-1:2023-08, for a 105-key keyboard. + // See https://de.wikipedia.org/wiki/E1_(Tastaturbelegung). + + name[Group1]="German (E1)"; + + key.type[Group1] = "EIGHT_LEVEL"; + key {[ dead_circumflex, degree, multiply, any, any, any ]}; + key {[ 1, exclam, rightsinglequotemark, any, onequarter, U25CA ]}; + key {[ 2, quotedbl, twosuperior, any, onehalf, brokenbar ]}; + key {[ 3, section, threesuperior, any, threequarters, paragraph ]}; + key {[ 4, dollar, emdash, any, currency, U2133 ]}; + key {[ 5, percent, exclamdown, any, permille, U20B0 ]}; + key {[ 6, ampersand, questiondown, any, U2044, U204A ]}; + key {[ 7, slash, braceleft, any, U2300, U2116 ]}; + key {[ 8, parenleft, bracketleft, any, U27E8, U27EA ]}; + key {[ 9, parenright, bracketright, any, U27E9, U27EB ]}; + key {[ 0, equal, braceright, any, division, U2205 ]}; + key {[ ssharp, question, backslash, any, notequal, notsign ]}; + key {[ dead_acute, dead_grave, dead_abovedot, any, sterling, U00A5 ]}; + + key.type[Group1] = "EIGHT_LEVEL_SEMIALPHABETIC"; + key {[ q, Q, at, any, masculine, U2642 ]}; + key {[ w, W, dead_macron, any, ordfeminine, U2640 ]}; + key {[ e, E, EuroSign, any, schwa, SCHWA ]}; + key {[ r, R, dead_doubleacute, any, trademark, registered ]}; + key {[ t, T, dead_caron, any, thorn, THORN ]}; + key {[ z, Z, dead_diaeresis, any, ezh, EZH ]}; + key {[ u, U, dead_breve, any, downarrow, uparrow ]}; + key {[ i, I, dead_tilde, any, idotless, U26A5 ]}; + key {[ o, O, dead_abovering, any, oslash, Oslash ]}; + key {[ p, P, dead_hook, any, rightarrow, leftarrow ]}; + key {[ udiaeresis, Udiaeresis, dead_horn, any, U2198, U2197 ]}; + key.type[Group1] = "EIGHT_LEVEL"; + key {[ plus, asterisk, asciitilde, any, plusminus, U2052 ]}; + + key.type[Group1] = "EIGHT_LEVEL_SEMIALPHABETIC"; + // Per DIN 2137-1:2018-12, p. 11-12, AltGr+a can either invoke a selection possibility + // for emojis and/or special characters, or output the U+263A smiley. The same holds for + // DIN 2137-1:2023-08. + key {[ a, A, Multi_key, any, any, any ]}; + key {[ s, S, seconds, any, U017F, U2211 ]}; + key {[ d, D, minutes, any, eth, ETH ]}; + key {[ f, F, ISO_Level5_Latch, any, any, any ]}; + key {[ g, G, U1E9E, any, U02BF, U261B ]}; + key {[ h, H, dead_belowmacron, any, U02BE, U261A ]}; + key {[ j, J, dead_cedilla, any, U02B9, U02BA ]}; + key {[ k, K, dead_belowcomma, any, any, any ]}; + key {[ l, L, dead_ogonek, any, lstroke, Lstroke ]}; + key {[ odiaeresis, Odiaeresis, dead_belowdot, any, oe, OE ]}; + key {[ adiaeresis, Adiaeresis, dead_stroke, any, ae, AE ]}; + key.type[Group1] = "EIGHT_LEVEL"; + key {[ numbersign, apostrophe, U2212, any, U2020, U2021 ]}; + + key {[ less, greater, bar, any, lessthanequal, greaterthanequal ]}; + key.type[Group1] = "EIGHT_LEVEL_SEMIALPHABETIC"; + key {[ y, Y, U203A, any, U2423, U23D1 ]}; + key {[ x, X, guillemotright, any, doublelowquotemark, singlelowquotemark ]}; + key {[ c, C, U202F, any, cent, copyright ]}; + key {[ v, V, guillemotleft, any, leftdoublequotemark, leftsinglequotemark ]}; + key {[ b, B, U2039, any, rightdoublequotemark, rightsinglequotemark ]}; + key {[ n, N, endash, any, eng, ENG ]}; + // Per DIN 2137-1:2018-12, p. 12, U+2217 should be replaced by the 'middle asterisk' character + // as soon as it has been added to Unicode (see Unicode proposal L2/17-152). Same holds for + // DIN 2137-1:2023-08. + key {[ m, M, mu, any, U200C, U2217 ]}; + key.type[Group1] = "EIGHT_LEVEL"; + key {[ comma, semicolon, U2011, any, U02BB, U2665 ]}; + key {[ period, colon, periodcentered, any, ellipsis, U2713 ]}; + key {[ minus, underscore, hyphen, any, U2022, U25E6 ]}; + + key.type[Group1] = "EIGHT_LEVEL"; + key {[ space, space, nobreakspace, any, U200A, U200A ]}; + + key.type[Group1] = "ONE_LEVEL"; + key {[ Shift_L ]}; + key {[ Shift_R ]}; + key {[ ISO_Level3_Shift ]}; + + include "kpdl(comma)" + }; + +partial alphanumeric_keys +xkb_symbols "e2" { + // German extended layout E2, based on DIN 2137-1:2023-08, for a 104-key keyboard. + // See https://de.wikipedia.org/wiki/E1_(Tastaturbelegung). + + include "de(e1)" + name[Group1]="German (E2)"; + + // One key less than E1: assign bar, less and greater to other keys. + key.type[Group1] = "EIGHT_LEVEL"; + key {[ dead_circumflex, degree, bar, any, any, any ]}; + key {[ 2, quotedbl, less, any, onehalf, brokenbar ]}; + key {[ 3, section, greater, any, threequarters, paragraph ]}; + key {[ plus, asterisk, asciitilde, any, multiply, U2052 ]}; + + // For when E2 is used on a 105-key keyboard. + key {[ ISO_Level3_Shift ], type[group1] = "ONE_LEVEL" }; +}; + +partial alphanumeric_keys +xkb_symbols "T3" { + // German extended layout T3 based on DIN 2137-1:2012-06 + // Now obsolete, use de(e1) or de(e2) + + name[Group1]="German (T3)"; + + key.type[Group1] = "EIGHT_LEVEL"; + key {[ dead_circumflex, degree, multiply, NoSymbol, U204A, hyphen, bar ]}; + key {[ 1, exclam, rightsinglequotemark, NoSymbol, onesuperior, exclamdown, U02B9 ]}; + key {[ 2, quotedbl, twosuperior, NoSymbol, twosuperior, currency, U02BA ]}; + key {[ 3, section, threesuperior, NoSymbol, threesuperior, sterling, U02BF ]}; + key {[ 4, dollar, emdash, NoSymbol, onequarter, EuroSign, U02BE ]}; + key {[ 5, percent, exclamdown, NoSymbol, onehalf, uparrow, U02C1 ]}; + key {[ 6, ampersand, questiondown, NoSymbol, threequarters, downarrow, U02C0 ]}; + key {[ 7, slash, braceleft, NoSymbol, oneeighth, leftarrow, braceleft ]}; + key {[ 8, parenleft, bracketleft, NoSymbol, threeeighths, rightarrow, braceright ]}; + key {[ 9, parenright, bracketright, NoSymbol, fiveeighths, plusminus, bracketleft ]}; + key {[ 0, equal, braceright, NoSymbol, seveneighths, trademark, bracketright ]}; + key {[ ssharp, question, backslash, NoSymbol, backslash, questiondown, U02BB ]}; + key {[ dead_acute, dead_grave, dead_abovedot, NoSymbol, dead_cedilla, dead_ogonek, notsign ]}; + + key.type[Group1] = "EIGHT_LEVEL_ALPHABETIC"; + key {[ q, Q, at, NoSymbol, U0242, U0241, U030D ]}; + key {[ w, W, dead_caron, NoSymbol, U02B7, U2126, dead_abovedot ]}; + key {[ e, E, EuroSign, NoSymbol, oe, OE, dead_breve ]}; + key {[ r, R, dead_diaeresis, NoSymbol, paragraph, registered, dead_circumflex ]}; + key {[ t, T, dead_macron, NoSymbol, UA78C, UA78B, dead_diaeresis ]}; + key {[ z, Z, dead_doubleacute, NoSymbol, U027C, yen, dead_invertedbreve ]}; + key {[ u, U, dead_breve, NoSymbol, U0223, U0222, dead_caron ]}; + key {[ i, I, dead_tilde, NoSymbol, idotless, U214D, dead_abovecomma ]}; + key {[ o, O, dead_abovering, NoSymbol, oslash, Oslash, dead_horn ]}; + key {[ p, P, dead_hook, NoSymbol, thorn, THORN, dead_hook ]}; + key {[ udiaeresis, Udiaeresis, dead_horn, NoSymbol, U017F, dead_abovering, dead_grave ]}; + key.type[Group1] = "EIGHT_LEVEL"; + key {[ plus, asterisk, asciitilde, NoSymbol, dead_tilde, dead_macron, at ]}; + + key.type[Group1] = "ONE_LEVEL"; + key {[ Caps_Lock ]}; + key.type[Group1] = "EIGHT_LEVEL_ALPHABETIC"; + key {[ a, A, lessthanequal, NoSymbol, ae, AE, U0329 ]}; + key {[ s, S, greaterthanequal, NoSymbol, ssharp, section, dead_belowdot ]}; + key {[ d, D, U2300, NoSymbol, eth, ETH, dead_belowbreve ]}; + key {[ f, F, minutes, NoSymbol, U0294, ordfeminine, dead_belowcircumflex ]}; + key {[ g, G, seconds, NoSymbol, eng, ENG, dead_belowmacron ]}; + key {[ h, H, U1E9E, NoSymbol, U0272, U019D, U0332 ]}; + key {[ j, J, dead_cedilla, NoSymbol, U0133, U0132, dead_belowring ]}; + key {[ k, K, dead_belowcomma, NoSymbol, kra, dead_belowcomma, dead_stroke ]}; + key {[ l, L, dead_ogonek, NoSymbol, lstroke, Lstroke, U0338 ]}; + key {[ odiaeresis, Odiaeresis, dead_belowdot, NoSymbol, dead_acute, dead_doubleacute, degree ]}; + key {[ adiaeresis, Adiaeresis, dead_stroke, NoSymbol, U019B, U1E9E, minutes ]}; + key.type[Group1] = "EIGHT_LEVEL"; + key {[ numbersign, apostrophe, registered, NoSymbol, schwa, SCHWA, seconds ]}; + + key {[ less, greater, bar, NoSymbol, U0149, brokenbar, U266A ]}; + key.type[Group1] = "EIGHT_LEVEL_ALPHABETIC"; + key {[ y, Y, U203A, NoSymbol, ezh, EZH, guillemotleft ]}; + key {[ x, X, guillemotright, NoSymbol, doublelowquotemark, singlelowquotemark, guillemotright ]}; + key {[ c, C, copyright, NoSymbol, cent, copyright, Greek_horizbar ]}; + key {[ v, V, guillemotleft, NoSymbol, leftdoublequotemark, leftsinglequotemark, U2039 ]}; + key {[ b, B, U2039, NoSymbol, rightdoublequotemark, rightsinglequotemark, U203A ]}; + key {[ n, N, endash, NoSymbol, U019E, U0220, endash ]}; + key {[ m, M, mu, NoSymbol, mu, masculine, emdash ]}; + key.type[Group1] = "EIGHT_LEVEL"; + key {[ comma, semicolon, U02BB, NoSymbol, ellipsis, multiply, dollar ]}; + key {[ period, colon, U200C, NoSymbol, periodcentered, division, numbersign ]}; + key {[ minus, underscore, hyphen, NoSymbol, U0140, U013F, U2011 ]}; + + key {[ space, space, nobreakspace, NoSymbol, U202F, U200C, nobreakspace ]}; + + include "kpdl(comma)" + + key.type[Group1] = "THREE_LEVEL"; + key {[ Shift_L, Shift_L, ISO_Level5_Latch ]}; + key {[ Shift_R, Shift_R, ISO_Level5_Latch ]}; + key {[ ISO_Level3_Shift, ISO_Level5_Latch, ISO_Level5_Latch ]}; + }; + +partial alphanumeric_keys +xkb_symbols "ro" { + // Adds Romanian-specific letters to the German basic layout. + // Romanian symbols are accessible by combining and + // 'a', 's', 't', 'i', 'ä (ä)' (+ for capital letters). + + include "de(basic)" + + name[Group1]="Romanian (Germany)"; + + key { [ t, T, U021b, U021a ] }; + key { [ i, I, icircumflex, Icircumflex ] }; + key { [ a, A, acircumflex, Acircumflex ] }; + key { [ s, S, U0219, U0218 ] }; + key { [ adiaeresis, Adiaeresis, abreve, Abreve ] }; +}; + +partial alphanumeric_keys +xkb_symbols "ro_nodeadkeys" { + // Adds Romanian-specific letters to the German nodeadkeys layout. + // Read the comment for de_ro ! + + include "de(nodeadkeys)" + name[Group1]="Romanian (Germany, no dead keys)"; + + key { [ t, T, U021b, U021a ] }; + key { [ i, I, icircumflex, Icircumflex ] }; + key { [ a, A, acircumflex, Acircumflex ] }; + key { [ s, S, U0219, U0218 ] }; + key { [ adiaeresis, Adiaeresis, abreve, Abreve ] }; +}; + +// German Dvorak keymap by Thorsten Staerk (www.staerk.de/thorsten) +// Have acute and grave as dead keys, tilde and circumflex alive as they are needed +// in many programming languages. +// to use this keymap, use a 105-key-keyboard and the command setxkbmap -model pc105 -layout dvorak -variant de +// source: http://www-lehre.informatik.uni-osnabrueck.de/~rfreund/dvorak.php +partial alphanumeric_keys +xkb_symbols "dvorak" { + include "us(dvorak)" + + name[Group1]="German (Dvorak)"; + + key { [ asciicircum, degree ] }; + + key { [ 1, exclam, onesuperior ] }; + key { [ 2, quotedbl, twosuperior ] }; + key { [ 3, section, threesuperior ] }; + key { [ 4, dollar, bar ] }; + key { [ 5, percent, bar ] }; + key { [ 6, ampersand, brokenbar ] }; + key { [ 7, slash, braceleft ] }; + key { [ 8, parenleft, bracketleft ] }; + key { [ 9, parenright, bracketright ] }; + key { [ 0, equal, braceright ] }; + key { [ plus, asterisk, asciitilde ] }; + key { [ less, greater, dead_grave ] }; + + key { [ udiaeresis, Udiaeresis, at ] }; + key { [ comma, semicolon, dead_diaeresis ] }; + key { [ period, colon ] }; + key { [ c, C, copyright, Cacute ] }; + key { [ t, T, trademark ] }; + key { [ z, Z, zabovedot, Zabovedot ] }; + key { [ question, ssharp ] }; + key { [ slash, backslash, dead_acute ] }; + + key { [ a, A, at, aogonek ] }; + key { [ o, O, oacute, Oacute ] }; + key { [ e, E, EuroSign, eogonek ] }; + key { [ i, I ] }; + key { [ u, U ] }; + key { [ h, H ] }; + key { [ d, D ] }; + key { [ r, R, registered ] }; + key { [ n, N, nacute, Nacute ] }; + key { [ s, S, sacute, Sacute] }; + key { [ l, L, lstroke, Lstroke ] }; + key { [ minus, underscore, hyphen, diaeresis] }; + + key { [ adiaeresis, Adiaeresis, bar ] }; + key { [ odiaeresis, Odiaeresis ] }; + key { [ q, Q, at ] }; + key { [ m, M, mu ] }; + key { [ numbersign, apostrophe ] }; + + include "level3(ralt_switch)" +}; + + +// German Neo-Layout Version 2 +// adopted 2004 by Hanno Behrens +// inspired by Dvorak/de-ergo http://www.goebel-consult.de/de-ergo/ +// +// Authors: Stephan Hilb +// +// Benjamin Kellermann +// Erik Streb +// and many other contributors +// +// https://www.neo-layout.org + +partial alphanumeric_keys modifier_keys keypad_keys +xkb_symbols "neo_base" { + + // The different layers and how to reach them + // -------------------------------------------------------------- + // Ebene 1: normal + // Ebene 2: Shift + // Ebene 3: Caps or Bksl ("Mod three") + // Ebene 4: Lsgt or RAlt ("Mod four") (for selecting, use also Shift) + // Ebene 5: Shift + Caps/Bksl + // Ebene 6: Caps/Bksl + Lsgt/RAlt + // Locking uppercase: left Shift + right Shift + // Locking Ebene 4: Shift + Caps + Tab, or Lsgt + RAlt + + + // Captions for the large table below + // -------------------------------------------------------------- + // Xorg: Level1 Level2 Level3 Level4 Level5 Level6 Level7 Level8 + // Neo: Ebene1 Ebene2 Ebene3 Ebene5 Ebene4 Pseudo-Ebene Ebene6 + // Access key: none Shift Caps/Bksl Shift + Caps/Bksl Lsgt/RAlt Shift + Lsgt/RAlt Caps/Bksl + Lsgt/RAlt + + + // Alphanumeric-keys + // ================= + key.type[Group1] = "EIGHT_LEVEL_WITH_LEVEL5_LOCK"; + + // The Tab key has Compose on the third layer (Caps + Tab) + // -------------------------------------------------------------- + key { [ Tab, ISO_Left_Tab, Multi_key, ISO_Level5_Lock, NoSymbol, NoSymbol, NoSymbol, ISO_Level5_Lock ] }; + + // Number row + // -------------------------------------------------------------- + key { [ dead_circumflex, dead_caron, U21BB, U02DE, dead_abovedot, Pointer_EnableKeys, dead_belowdot, NoSymbol ] }; + + key { [ 1, degree, onesuperior, onesubscript, ordfeminine, NoSymbol, notsign, NoSymbol ] }; + key { [ 2, section, twosuperior, twosubscript, masculine, NoSymbol, logicalor, NoSymbol ] }; + key { [ 3, U2113, threesuperior, threesubscript, numerosign, NoSymbol, logicaland, NoSymbol ] }; + key { [ 4, guillemotright, U203A, femalesymbol, NoSymbol, NoSymbol, U22A5, NoSymbol ] }; + key { [ 5, guillemotleft, U2039, malesymbol, periodcentered, NoSymbol, U2221, NoSymbol ] }; + key { [ 6, dollar, cent, U26A5, sterling, NoSymbol, U2225, NoSymbol ] }; + + key { [ 7, EuroSign, yen, U03F0, currency, NoSymbol, rightarrow, NoSymbol ] }; + key { [ 8, doublelowquotemark, singlelowquotemark, U27E8, Tab, ISO_Left_Tab, U221E, NoSymbol ] }; + key { [ 9, leftdoublequotemark, leftsinglequotemark, U27E9, KP_Divide, KP_Divide, variation, NoSymbol ] }; + key { [ 0, rightdoublequotemark, rightsinglequotemark, zerosubscript, KP_Multiply, KP_Multiply, emptyset, NoSymbol ] }; + + key { [ minus, emdash, NoSymbol, U2011, KP_Subtract, KP_Subtract, hyphen, NoSymbol ] }; + key { [ dead_grave, dead_cedilla, dead_abovering, dead_dasia, dead_diaeresis, NoSymbol, dead_macron, NoSymbol ] }; + + // Top row + // -------------------------------------------------------------- + key.type[Group1] = "EIGHT_LEVEL_ALPHABETIC_WITH_LEVEL5_LOCK"; + key { [ x, X, ellipsis, Greek_xi, Prior, Prior, Greek_XI, NoSymbol ] }; + key { [ v, V, underscore, NoSymbol, BackSpace, BackSpace, radical, NoSymbol ] }; + key { [ l, L, bracketleft, Greek_lambda, Up, Up, Greek_LAMBDA, NoSymbol ] }; + key { [ c, C, bracketright, Greek_chi, Delete, Delete, U2102, NoSymbol ] }; + key { [ w, W, asciicircum, Greek_omega, Next, Next, Greek_OMEGA, NoSymbol ] }; + + key { [ k, K, exclam, Greek_kappa, exclamdown, NoSymbol, multiply, NoSymbol ] }; + key { [ h, H, less, Greek_psi, KP_7, KP_7, Greek_PSI, NoSymbol ] }; + key { [ g, G, greater, Greek_gamma, KP_8, KP_8, Greek_GAMMA, NoSymbol ] }; + key { [ f, F, equal, Greek_phi, KP_9, KP_9, Greek_PHI, NoSymbol ] }; + key { [ q, Q, ampersand, U03D5, KP_Add, KP_Add, U211A, NoSymbol ] }; + + key { [ ssharp, U1E9E, U017F, Greek_finalsmallsigma, U2212, NoSymbol, jot, NoSymbol ] }; + + key.type[Group1] = "EIGHT_LEVEL_WITH_LEVEL5_LOCK"; + key { [ dead_acute, dead_tilde, dead_stroke, dead_psili, dead_doubleacute, NoSymbol, dead_breve, NoSymbol ] }; + + // Middle row + // -------------------------------------------------------------- + key.type[Group1] = "EIGHT_LEVEL_ALPHABETIC_WITH_LEVEL5_LOCK"; + key { [ u, U, backslash, NoSymbol, Home, Home, includedin, NoSymbol ] }; + key { [ i, I, slash, Greek_iota, Left, Left, integral, NoSymbol ] }; + key { [ a, A, braceleft, Greek_alpha, Down, Down, U2200, NoSymbol ] }; + key { [ e, E, braceright, Greek_epsilon, Right, Right, U2203, NoSymbol ] }; + key { [ o, O, asterisk, Greek_omicron, End, End, elementof, NoSymbol ] }; + + key { [ s, S, question, Greek_sigma, questiondown, NoSymbol, Greek_SIGMA, NoSymbol ] }; + key { [ n, N, parenleft, Greek_nu, KP_4, KP_4, U2115, NoSymbol ] }; + key { [ r, R, parenright, Greek_rho, KP_5, KP_5, U211D, NoSymbol ] }; + key { [ t, T, minus, Greek_tau, KP_6, KP_6, partialderivative, NoSymbol ] }; + key { [ d, D, colon, Greek_delta, KP_Separator, comma, Greek_DELTA, NoSymbol ] }; + + key { [ y, Y, at, Greek_upsilon, period, KP_Decimal, nabla, NoSymbol ] }; + + // Bottom row + // -------------------------------------------------------------- + key { [ udiaeresis, Udiaeresis, numbersign, NoSymbol, Escape, Escape, union, NoSymbol ] }; + key { [ odiaeresis, Odiaeresis, dollar, U03F5, Tab, Tab, intersection, NoSymbol ] }; + key { [ adiaeresis, Adiaeresis, bar, Greek_eta, Insert, Insert, U2135, NoSymbol ] }; + key { [ p, P, asciitilde, Greek_pi, Return, Return, Greek_PI, NoSymbol ] }; + key { [ z, Z, grave, Greek_zeta, Undo, Redo, U2124, NoSymbol ] }; + + key { [ b, B, plus, Greek_beta, colon, NoSymbol, U21D0, NoSymbol ] }; + key { [ m, M, percent, Greek_mu, KP_1, KP_1, ifonlyif, NoSymbol ] }; + key.type[Group1] = "EIGHT_LEVEL_WITH_LEVEL5_LOCK"; + key { [ comma, endash, quotedbl, U03F1, KP_2, KP_2, U21D2, NoSymbol ] }; + key { [ period, enfilledcircbullet, apostrophe, U03D1, KP_3, KP_3, U21A6, NoSymbol ] }; + key.type[Group1] = "EIGHT_LEVEL_ALPHABETIC_WITH_LEVEL5_LOCK"; + key { [ j, J, semicolon, Greek_theta, semicolon, NoSymbol, Greek_THETA, NoSymbol ] }; + + // Space key + // -------------------------------------------------------------- + key.type[Group1] = "EIGHT_LEVEL_WITH_LEVEL5_LOCK"; + key { [ space, space, space, nobreakspace, KP_0, KP_0, U202F, NoSymbol ] }; + + + // Keypad-keys + // =========== + + // The former Numlock key: + key { [ Tab, ISO_Left_Tab, equal, approxeq, notequal, Pointer_EnableKeys, identical, NoSymbol ] }; + + // Topmost row + // -------------------------------------------------------------- + key { [ KP_Divide, KP_Divide, division, U2300, U2044, NoSymbol, U2223, NoSymbol ] }; + key { [ KP_Multiply, KP_Multiply, U22C5, U2299, multiply, NoSymbol, U2297, NoSymbol ] }; + key { [ KP_Subtract, KP_Subtract, U2212, U2296, U2216, NoSymbol, U2238, NoSymbol ] }; + + // Top row + // -------------------------------------------------------------- + key { [ KP_7, U2714, U2195, U226A, KP_Home, KP_Home, upstile, NoSymbol ] }; + key { [ KP_8, U2718, uparrow, intersection, KP_Up, KP_Up, U22C2, NoSymbol ] }; + key { [ KP_9, dagger, U20D7, U226B, KP_Prior, KP_Prior, U2309, NoSymbol ] }; + key { [ KP_Add, KP_Add, plusminus, U2295, U2213, NoSymbol, U2214, NoSymbol ] }; + + // Middle row + // -------------------------------------------------------------- + key { [ KP_4, club, leftarrow, includedin, KP_Left, KP_Left, U2286, NoSymbol ] }; + key { [ KP_5, EuroSign, colon, U22B6, KP_Begin, KP_Begin, U22B7, NoSymbol ] }; + key { [ KP_6, U2023, rightarrow, includes, KP_Right, KP_Right, U2287, NoSymbol ] }; + + // Bottom row + // -------------------------------------------------------------- + key { [ KP_1, diamond, U2194, lessthanequal, KP_End, KP_End, downstile, NoSymbol ] }; + key { [ KP_2, heart, downarrow, union, KP_Down, KP_Down, U22C3, NoSymbol ] }; + key { [ KP_3, U2660, U21CC, greaterthanequal, KP_Next, KP_Next, U230B, NoSymbol ] }; + key { [ KP_Enter, KP_Enter, KP_Enter, KP_Enter, KP_Enter, KP_Enter, KP_Enter, NoSymbol ] }; + key { [ KP_Equal, NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol ] }; + + // Bottommost row + // -------------------------------------------------------------- + key { [ KP_0, U2423, percent, permille, KP_Insert, KP_Insert, U25A1, NoSymbol ] }; + key { [ KP_Separator, period, comma, minutes, KP_Delete, KP_Delete, seconds, NoSymbol ] }; +}; + +partial alphanumeric_keys modifier_keys keypad_keys +xkb_symbols "neo" { + + include "de(neo_base)" + + name[Group1]= "German (Neo 2)"; + + include "shift(both_capslock)" + include "level3(caps_switch)" + include "level3(bksl_switch)" + include "level5(lsgt_switch_lock)" + include "level5(ralt_switch_lock)" +}; + +// Legacy layout for the German Mac, as depicted on +// https://iks.cs.ovgu.de/~elkner/keyboard/mac/germankbd.html. +partial alphanumeric_keys +xkb_symbols "mac" { + + name[Group1]= "German (Macintosh)"; + + key {[ dead_circumflex, degree, doublelowquotemark, leftdoublequotemark ]}; + key {[ 1, exclam, exclamdown, notsign ]}; + key {[ 2, quotedbl, leftdoublequotemark,rightdoublequotemark]}; + key {[ 3, section, paragraph, numbersign ]}; + key {[ 4, dollar, cent, sterling ]}; + key {[ 5, percent, bracketleft, UFB01 ]}; // fi + key {[ 6, ampersand, bracketright, dead_circumflex ]}; + key {[ 7, slash, bar, backslash ]}; + key {[ 8, parenleft, braceleft, U02DC ]}; // ˜ + key {[ 9, parenright, braceright, periodcentered ]}; + key {[ 0, equal, notequal, macron ]}; + key {[ ssharp, question, questiondown, abovedot ]}; + key {[ dead_acute, dead_grave, apostrophe, U02DA ]}; // ˚ + + key {[ q, Q, guillemotleft, guillemotright ]}; + key {[ w, W, Greek_SIGMA, doublelowquotemark ]}; + key {[ e, E, EuroSign, permille ]}; + key {[ r, R, registered, cedilla ]}; + key {[ t, T, dagger, U02DD ]}; // ˝ + key {[ z, Z, Greek_OMEGA, caron ]}; + key {[ u, U, dead_diaeresis, Aacute ]}; + key {[ i, I, U2044, Ucircumflex ]}; // ⁄ + key {[ o, O, oslash, Oslash ]}; + key {[ p, P, Greek_pi, Greek_PI ]}; + key {[ udiaeresis, Udiaeresis, U2022, degree ]}; // • + key {[ plus, asterisk, plusminus, UF8FF ]}; // Apple logo + + key {[ a, A, aring, Aring ]}; + key {[ s, S, singlelowquotemark, Iacute ]}; + key {[ d, D, partdifferential, trademark ]}; + key {[ f, F, function, Idiaeresis ]}; + key {[ g, G, copyright, Igrave ]}; + key {[ h, H, ordfeminine, Oacute ]}; + key {[ j, J, masculine, idotless ]}; + key {[ k, K, Greek_DELTA, U02C6 ]}; // ˆ + key {[ l, L, at, UFB02 ]}; // fl + key {[ odiaeresis, Odiaeresis, oe, OE ]}; + key {[ adiaeresis, Adiaeresis, ae, AE ]}; + key {[ numbersign, apostrophe, leftsinglequotemark,rightsinglequotemark]}; + + key {[ less, greater, lessthanequal, greaterthanequal ]}; + key {[ y, Y, yen, doubledagger ]}; + key {[ x, X, approxeq, Ugrave ]}; + key {[ c, C, ccedilla, Ccedilla ]}; + key {[ v, V, radical, U25CA ]}; // ◊ + key {[ b, B, integral, U2039 ]}; // ‹ + key {[ n, N, dead_tilde, U203A ]}; // › + key {[ m, M, mu, breve ]}; + key {[ comma, semicolon, infinity, ogonek ]}; + key {[ period, colon, ellipsis, division ]}; + key {[ minus, underscore, endash, emdash ]}; + + include "level3(ralt_switch)" +}; + +partial alphanumeric_keys +xkb_symbols "mac_nodeadkeys" { + // modify the standard German mac layout to not have any dead keys + include "de(mac)" + name[Group1]= "German (Macintosh, no dead keys)"; + + key { [ asciicircum, degree, notsign ] }; + key { [ 4, dollar, onequarter, currency ] }; + key { [ 6, ampersand, bracketright, asciicircum ] }; + key { [ acute, grave, cedilla ] }; + key { [ u, U, diaeresis, Aacute ] }; + key { [ udiaeresis, Udiaeresis, diaeresis ] }; + key { [ plus, asterisk, asciitilde, macron ] }; + key { [ odiaeresis, Odiaeresis, acute ] }; + key { [ adiaeresis, Adiaeresis, asciicircum ] }; + key { [ numbersign, apostrophe, rightsinglequotemark ] }; + + key { [ n, N, asciitilde, U203A ] }; +}; + +partial alphanumeric_keys +xkb_symbols "dsb" +{ + include "latin(basic)" + name[Group1] = "Lower Sorbian"; + + key { [ e, E, ecaron, Ecaron ] }; + key { [ r, R, racute, Racute ] }; + key { [ t, T, cent, EuroSign ] }; + key { [ o, O, oacute, Oacute ] }; + + key { [ s, S, sacute, Sacute ] }; + key { [ d, D, scaron, Scaron ] }; + + key { [ z, Z, zcaron, Zcaron ] }; + key { [ x, X, zacute, Zacute ] }; + key { [ c, C, cacute, Cacute ] }; + key { [ v, V, ccaron, Ccaron ] }; + key { [ n, N, nacute, Nacute ] }; + + include "kpdl(comma)" + include "level3(ralt_switch)" +}; + +partial alphanumeric_keys +xkb_symbols "dsb_qwertz" +{ + include "de(basic)" + name[Group1] = "Lower Sorbian (QWERTZ)"; + + key { [ e, E, ecaron, Ecaron ] }; + key { [ r, R, racute, Racute ] }; + key { [ t, T, cent, EuroSign ] }; + key { [ z, Z, zcaron, Zcaron ] }; + key { [ u, U, zacute, Zacute ] }; + key { [ o, O, oacute, Oacute ] }; + + key { [ s, S, sacute, Sacute ] }; + key { [ d, D, scaron, Scaron ] }; + + key { [ c, C, cacute, Cacute ] }; + key { [ v, V, ccaron, Ccaron ] }; + key { [ n, N, nacute, Nacute ] }; + + include "kpdl(comma)" + include "level3(ralt_switch)" +}; + +partial alphanumeric_keys +xkb_symbols "qwerty" { + + // This layout should work exactly as a de with the exception + // of 'Z' and 'Y' keys, which are in the qwerty style (ie. swapped). + // 2008 by Matej Košík + + include "de(basic)" + + name[Group1] = "German (QWERTY)"; + + key { [ z, Z, leftarrow, yen ] }; + key { [ y, Y, guillemotleft, less ] }; +}; + +// layout for Russian letters on an german keyboard +// based on US-RU layout by Ivan Popov 2005-07-17 +// adopted for german layout by Alexey Fisher 2010-08-19 + +partial alphanumeric_keys +xkb_symbols "ru" { + + include "de(basic)" + + name[Group1]= "Russian (Germany, phonetic)"; + + key {[ Cyrillic_io, Cyrillic_IO, asciitilde ]}; + key {[ Cyrillic_hardsign, Cyrillic_HARDSIGN ]}; + + key {[ Cyrillic_ya, Cyrillic_YA ]}; + key {[ Cyrillic_ve, Cyrillic_VE ]}; + key {[ Cyrillic_ie, Cyrillic_IE ]}; + key {[ Cyrillic_er, Cyrillic_ER ]}; + key {[ Cyrillic_te, Cyrillic_TE ]}; + key {[ Cyrillic_ze, Cyrillic_ZE ]}; + key {[ Cyrillic_u, Cyrillic_U ]}; + key {[ Cyrillic_i, Cyrillic_I ]}; + key {[ Cyrillic_o, Cyrillic_O ]}; + key {[ Cyrillic_pe, Cyrillic_PE ]}; + key {[ Cyrillic_sha, Cyrillic_SHA ]}; + key {[ Cyrillic_shcha, Cyrillic_SHCHA, plus, asterisk ]}; + + key {[ Cyrillic_a, Cyrillic_A ]}; + key {[ Cyrillic_es, Cyrillic_ES ]}; + key {[ Cyrillic_de, Cyrillic_DE ]}; + key {[ Cyrillic_ef, Cyrillic_EF ]}; + key {[ Cyrillic_ghe, Cyrillic_GHE ]}; + key {[ Cyrillic_ha, Cyrillic_HA ]}; + key {[ Cyrillic_shorti, Cyrillic_SHORTI ]}; + key {[ Cyrillic_ka, Cyrillic_KA ]}; + key {[ Cyrillic_el, Cyrillic_EL ]}; + key {[ Cyrillic_che, Cyrillic_CHE ]}; + key {[ Cyrillic_e, Cyrillic_E ]}; + key {[ Cyrillic_yu, Cyrillic_YU, numbersign, apostrophe ]}; + + key {[ Cyrillic_yeru, Cyrillic_YERU ]}; + key {[ Cyrillic_zhe, Cyrillic_ZHE ]}; + key {[ Cyrillic_tse, Cyrillic_TSE ]}; + key {[ Cyrillic_softsign, Cyrillic_SOFTSIGN ]}; + key {[ Cyrillic_be, Cyrillic_BE ]}; + key {[ Cyrillic_en, Cyrillic_EN ]}; + key {[ Cyrillic_em, Cyrillic_EM ]}; + + include "level3(ralt_switch)" +}; + +// layout for Russian (recommended) letters on a german keyboard +// based on "Russisch für Deutsche, empfohlen" by B. Bendixen und H. Rothe http://russisch.urz.uni-leipzig.de/key2000.htm 2016-02-01 +// adapted for Linux by Niko Krause 2016-06-09 + +partial alphanumeric_keys +xkb_symbols "ru-recom" { + + include "de(basic)" + + name[Group1]= "Russian (Germany, recommended)"; + + key {[ Cyrillic_ya, Cyrillic_YA, asciicircum, degree ]}; + key {[ asciitilde, question, backslash, questiondown ]}; + key {[ U0301, U0300, U0323, U0307 ]}; + + key {[ Cyrillic_shcha, Cyrillic_SHCHA ]}; + key {[ Cyrillic_ve, Cyrillic_VE ]}; + key {[ Cyrillic_ie, Cyrillic_IE ]}; + key {[ Cyrillic_er, Cyrillic_ER ]}; + key {[ Cyrillic_te, Cyrillic_TE ]}; + key {[ Cyrillic_tse, Cyrillic_TSE ]}; + key {[ Cyrillic_u, Cyrillic_U ]}; + key {[ Cyrillic_i, Cyrillic_I, Ukrainian_i, Ukrainian_I ]}; + key {[ Cyrillic_o, Cyrillic_O ]}; + key {[ Cyrillic_pe, Cyrillic_PE ]}; + key {[ Cyrillic_yu, Cyrillic_YU ]}; + key {[ Cyrillic_sha, Cyrillic_SHA, plus, asterisk ]}; + + key {[ Cyrillic_a, Cyrillic_A ]}; + key {[ Cyrillic_es, Cyrillic_ES, Cyrillic_ze, Cyrillic_ZE ]}; + key {[ Cyrillic_de, Cyrillic_DE ]}; + key {[ Cyrillic_ef, Cyrillic_EF ]}; + key {[ Cyrillic_ghe, Cyrillic_GHE, Ukrainian_ghe_with_upturn, Ukrainian_GHE_WITH_UPTURN ]}; + key {[ Cyrillic_zhe, Cyrillic_ZHE ]}; + key {[ Cyrillic_shorti, Cyrillic_SHORTI, Ukrainian_yi, Ukrainian_YI ]}; + key {[ Cyrillic_ka, Cyrillic_KA ]}; + key {[ Cyrillic_el, Cyrillic_EL ]}; + key {[ Cyrillic_io, Cyrillic_IO ]}; + key {[ Cyrillic_e, Cyrillic_E, Ukrainian_ie, Ukrainian_IE ]}; + key {[ Cyrillic_hardsign, Cyrillic_HARDSIGN, numbersign, apostrophe ]}; + + key {[ Cyrillic_ze, Cyrillic_ZE ]}; + key {[ Cyrillic_yeru, Cyrillic_YERU ]}; + key {[ Cyrillic_ha, Cyrillic_HA ]}; + key {[ Cyrillic_che, Cyrillic_CHE ]}; + key {[ Cyrillic_softsign, Cyrillic_SOFTSIGN ]}; + key {[ Cyrillic_be, Cyrillic_BE ]}; + key {[ Cyrillic_en, Cyrillic_EN ]}; + key {[ Cyrillic_em, Cyrillic_EM ]}; + + include "level3(ralt_switch)" +}; + +// layout for Russian (transliteration) letters on a german keyboard +// based on "Russisch für Deutsche, Transliteration" by B. Bendixen und H. Rothe http://russisch.urz.uni-leipzig.de/key2000.htm 2016-02-01 +// adapted for Linux by Niko Krause 2016-06-09 + +partial alphanumeric_keys +xkb_symbols "ru-translit" { + + include "de(basic)" + + name[Group1]= "Russian (Germany, transliteration)"; + + key {[ Cyrillic_ya, Cyrillic_YA, asciicircum, degree ]}; + key {[ asciitilde, question, backslash, questiondown ]}; + key {[ U0301, U0300, U0323, U0307 ]}; + + key {[ Cyrillic_shcha, Cyrillic_SHCHA ]}; + key {[ Cyrillic_sha, Cyrillic_SHA ]}; + key {[ Cyrillic_ie, Cyrillic_IE ]}; + key {[ Cyrillic_er, Cyrillic_ER ]}; + key {[ Cyrillic_te, Cyrillic_TE ]}; + key {[ Cyrillic_ze, Cyrillic_ZE ]}; + key {[ Cyrillic_u, Cyrillic_U ]}; + key {[ Cyrillic_i, Cyrillic_I, Ukrainian_i, Ukrainian_I ]}; + key {[ Cyrillic_o, Cyrillic_O ]}; + key {[ Cyrillic_pe, Cyrillic_PE ]}; + key {[ Cyrillic_yu, Cyrillic_YU ]}; + key {[ Cyrillic_hardsign, Cyrillic_HARDSIGN, plus, asterisk ]}; + + key {[ Cyrillic_a, Cyrillic_A ]}; + key {[ Cyrillic_es, Cyrillic_ES, Cyrillic_che, Cyrillic_CHE ]}; + key {[ Cyrillic_de, Cyrillic_DE ]}; + key {[ Cyrillic_ef, Cyrillic_EF ]}; + key {[ Cyrillic_ghe, Cyrillic_GHE, Ukrainian_ghe_with_upturn, Ukrainian_GHE_WITH_UPTURN ]}; + key {[ Cyrillic_zhe, Cyrillic_ZHE ]}; + key {[ Cyrillic_shorti, Cyrillic_SHORTI, Ukrainian_yi, Ukrainian_YI ]}; + key {[ Cyrillic_ka, Cyrillic_KA ]}; + key {[ Cyrillic_el, Cyrillic_EL ]}; + key {[ Cyrillic_io, Cyrillic_IO ]}; + key {[ Cyrillic_e, Cyrillic_E, Ukrainian_ie, Ukrainian_IE ]}; + key {[ Cyrillic_softsign, Cyrillic_SOFTSIGN, numbersign, apostrophe ]}; + + key {[ Cyrillic_che, Cyrillic_CHE ]}; + key {[ Cyrillic_yeru, Cyrillic_YERU ]}; + key {[ Cyrillic_ha, Cyrillic_HA ]}; + key {[ Cyrillic_tse, Cyrillic_TSE ]}; + key {[ Cyrillic_ve, Cyrillic_VE ]}; + key {[ Cyrillic_be, Cyrillic_BE ]}; + key {[ Cyrillic_en, Cyrillic_EN ]}; + key {[ Cyrillic_em, Cyrillic_EM ]}; + + include "level3(ralt_switch)" +}; + +partial alphanumeric_keys +xkb_symbols "pl" { + + // Combined layout for entering both German and Polish symbols on a German physical + // keyboard. Based on German (no dead keys) and Polish (basic). Polish diacritics + // on AltGr+"acelnosxz". EuroSign moved to AE04 (AltGr+dollar key) to avoid conflict + // with Polish eogonek. + + include "de(nodeadkeys)" + + name[Group1]= "Polish (Germany, no dead keys)"; + + key { [ 4, dollar, EuroSign, currency ] }; + + key { [ q, Q ] }; + key { [ w, W ] }; + key { [ e, E, eogonek, Eogonek ] }; + key { [ o, O, oacute, Oacute ] }; + key { [ a, A, aogonek, Aogonek ] }; + key { [ s, S, sacute, Sacute ] }; + key { [ f, F ] }; + key { [ z, Z, zabovedot, Zabovedot ] }; + key { [ x, X, zacute, Zacute ] }; + key { [ c, C, cacute, Cacute ] }; + key { [ n, N, nacute, Nacute ] }; + + include "kpdl(comma)" + + include "level3(ralt_switch)" +}; + +partial alphanumeric_keys +xkb_symbols "tr" { + + // add turkish-specific letters to the basic German layout. + // Turkish symbols are accessible with combination of and + // 'i', 's', 'g', 'c'' (+ for capital letters). + + include "de(basic)" + + name[Group1]="Turkish (Germany)"; + + key {[ i, I, idotless, Iabovedot ], type[group1]="FOUR_LEVEL_ALPHABETIC" }; + key {[ s, S, scedilla, Scedilla ]}; + key {[ g, G, gbreve, Gbreve ]}; + key {[ c, C, ccedilla, Ccedilla ]}; +}; + +partial alphanumeric_keys +xkb_symbols "us" { + include "us" + + name[Group1]="German (US)"; + + key { [ 3, numbersign, section, degree ] }; + key { [ minus, underscore, ssharp, U1E9E ] }; + + key { [ e, E, EuroSign, cent ] }; + key { [ u, U, udiaeresis, Udiaeresis ] }; + key { [ o, O, odiaeresis, Odiaeresis ] }; + key { [ bracketleft, braceleft, udiaeresis, Udiaeresis ] }; + + key { [ a, A, adiaeresis, Adiaeresis ] }; + key { [ s, S, ssharp, U1E9E ] }; + key { [ semicolon, colon, odiaeresis, Odiaeresis ] }; + key { [ apostrophe, quotedbl, adiaeresis, Adiaeresis ] }; + + key { [ c, C, Multi_key, Multi_key ] }; + key { [ m, M, dead_greek, Menu ] }; + + include "level3(ralt_switch)" +}; + +// EXTRAS: + +partial alphanumeric_keys +xkb_symbols "hu" { + + // modify the basic German layout to not have any dead keys and add Hungarian letters + + include "de(basic)" + name[Group1]="German (with Hungarian letters, no dead keys)"; + + key { [ y, Y, guillemotleft, less ] }; + key { [odiaeresis, Odiaeresis, eacute, Eacute ] }; + key { [adiaeresis, Adiaeresis, aacute, Aacute] }; + key { [ e, E, EuroSign, EuroSign ] }; + key { [ z, Z, leftarrow, yen ] }; + key { [ u, U, uacute, Uacute ] }; + key { [ i, I, iacute, Iacute ] }; + key { [ o, O, odoubleacute, Odoubleacute ] }; + key { [udiaeresis, Udiaeresis, udoubleacute, Udoubleacute ] }; + key { [ plus, asterisk, asciitilde, macron ] }; + key { [ acute, grave, oacute, Oacute ] }; + key { [numbersign, apostrophe, rightsinglequotemark, grave ] }; + key { [asciicircum, degree, notsign, notsign ] }; +}; + +partial alphanumeric_keys + xkb_symbols "sun_type6" { + include "sun_vndr/de(sun_type6)" +}; + +partial alphanumeric_keys modifier_keys keypad_keys +xkb_symbols "adnw" { + include "de(neo_base)" + + name[Group1]= "German (Aus der Neo-Welt)"; + + key.type[Group1] = "EIGHT_LEVEL_WITH_LEVEL5_LOCK"; + key { [ period, enfilledcircbullet, NoSymbol, U03D1, NoSymbol, NoSymbol, U21A6, NoSymbol ] }; + key { [ comma, endash, NoSymbol, U03F1, NoSymbol, NoSymbol, U21D2, NoSymbol ] }; + + key.type[Group1] = "EIGHT_LEVEL_ALPHABETIC_WITH_LEVEL5_LOCK"; + key { [ k, K, NoSymbol, Greek_kappa, NoSymbol, NoSymbol, multiply, NoSymbol ] }; + key { [ u, U, NoSymbol, NoSymbol, NoSymbol, NoSymbol, includedin, NoSymbol ] }; + key { [ udiaeresis, Udiaeresis, NoSymbol, NoSymbol, NoSymbol, NoSymbol, union, NoSymbol ] }; + key { [ adiaeresis, Adiaeresis, NoSymbol, Greek_eta, NoSymbol, NoSymbol, U2135, NoSymbol ] }; + key { [ v, V, NoSymbol, NoSymbol, NoSymbol, NoSymbol, radical, NoSymbol ] }; + key { [ g, G, NoSymbol, Greek_gamma, NoSymbol, NoSymbol, Greek_GAMMA, NoSymbol ] }; + key { [ c, C, NoSymbol, Greek_chi, NoSymbol, NoSymbol, U2102, NoSymbol ] }; + key { [ l, L, NoSymbol, Greek_lambda, NoSymbol, NoSymbol, Greek_LAMBDA, NoSymbol ] }; + key { [ j, J, NoSymbol, Greek_theta, NoSymbol, NoSymbol, Greek_THETA, NoSymbol ] }; + key { [ f, F, NoSymbol, Greek_phi, NoSymbol, NoSymbol, Greek_PHI, NoSymbol ] }; + key { [ h, H, NoSymbol, Greek_psi, NoSymbol, NoSymbol, Greek_PSI, NoSymbol ] }; + key { [ i, I, NoSymbol, Greek_iota, NoSymbol, NoSymbol, integral, NoSymbol ] }; + key { [ e, E, NoSymbol, Greek_epsilon, NoSymbol, NoSymbol, U2203, NoSymbol ] }; + key { [ a, A, NoSymbol, Greek_alpha, NoSymbol, NoSymbol, U2200, NoSymbol ] }; + key { [ o, O, NoSymbol, Greek_omicron, NoSymbol, NoSymbol, elementof, NoSymbol ] }; + key { [ d, D, NoSymbol, Greek_delta, NoSymbol, NoSymbol, Greek_DELTA, NoSymbol ] }; + key { [ t, T, NoSymbol, Greek_tau, NoSymbol, NoSymbol, partialderivative, NoSymbol ] }; + key { [ r, R, NoSymbol, Greek_rho, NoSymbol, NoSymbol, U211D, NoSymbol ] }; + key { [ n, N, NoSymbol, Greek_nu, NoSymbol, NoSymbol, U2115, NoSymbol ] }; + key { [ s, S, NoSymbol, Greek_sigma, NoSymbol, NoSymbol, Greek_SIGMA, NoSymbol ] }; + key { [ ssharp, U1E9E, NoSymbol, Greek_finalsmallsigma, NoSymbol, NoSymbol, jot, NoSymbol ] }; + key { [ x, X, NoSymbol, Greek_xi, NoSymbol, NoSymbol, Greek_XI, NoSymbol ] }; + key { [ y, Y, NoSymbol, Greek_upsilon, NoSymbol, NoSymbol, nabla, NoSymbol ] }; + key { [ odiaeresis, Odiaeresis, NoSymbol, U03F5, NoSymbol, NoSymbol, intersection, NoSymbol ] }; + key { [ q, Q, NoSymbol, U03D5, NoSymbol, NoSymbol, U211A, NoSymbol ] }; + key { [ b, B, NoSymbol, Greek_beta, NoSymbol, NoSymbol, U21D0, NoSymbol ] }; + key { [ p, P, NoSymbol, Greek_pi, NoSymbol, NoSymbol, Greek_PI, NoSymbol ] }; + key { [ w, W, NoSymbol, Greek_omega, NoSymbol, NoSymbol, Greek_OMEGA, NoSymbol ] }; + key { [ m, M, NoSymbol, Greek_mu, NoSymbol, NoSymbol, ifonlyif, NoSymbol ] }; + key { [ z, Z, NoSymbol, Greek_zeta, NoSymbol, NoSymbol, U2124, NoSymbol ] }; + + include "shift(both_capslock)" + include "level3(caps_switch)" + include "level3(bksl_switch)" + include "level5(lsgt_switch_lock)" + include "level5(ralt_switch_lock)" +}; + +partial alphanumeric_keys modifier_keys keypad_keys +xkb_symbols "koy" { + include "de(neo_base)" + + name[Group1]= "German (KOY)"; + + key.type[Group1] = "EIGHT_LEVEL_WITH_LEVEL5_LOCK"; + key { [ period, enfilledcircbullet, NoSymbol, U03D1, NoSymbol, NoSymbol, U21A6, NoSymbol ] }; + key { [ comma, endash, NoSymbol, U03F1, NoSymbol, NoSymbol, U21D2, NoSymbol ] }; + + key.type[Group1] = "EIGHT_LEVEL_ALPHABETIC_WITH_LEVEL5_LOCK"; + key { [ k, K, NoSymbol, Greek_kappa, NoSymbol, NoSymbol, multiply, NoSymbol ] }; + key { [ o, O, NoSymbol, Greek_omicron, NoSymbol, NoSymbol, elementof, NoSymbol ] }; + key { [ y, Y, NoSymbol, Greek_upsilon, NoSymbol, NoSymbol, nabla, NoSymbol ] }; + key { [ v, V, NoSymbol, NoSymbol, NoSymbol, NoSymbol, radical, NoSymbol ] }; + key { [ g, G, NoSymbol, Greek_gamma, NoSymbol, NoSymbol, Greek_GAMMA, NoSymbol ] }; + key { [ c, C, NoSymbol, Greek_chi, NoSymbol, NoSymbol, U2102, NoSymbol ] }; + key { [ l, L, NoSymbol, Greek_lambda, NoSymbol, NoSymbol, Greek_LAMBDA, NoSymbol ] }; + key { [ ssharp, U1E9E, NoSymbol, Greek_finalsmallsigma, NoSymbol, NoSymbol, jot, NoSymbol ] }; + key { [ z, Z, NoSymbol, Greek_zeta, NoSymbol, NoSymbol, U2124, NoSymbol ] }; + key { [ h, H, NoSymbol, Greek_psi, NoSymbol, NoSymbol, Greek_PSI, NoSymbol ] }; + key { [ a, A, NoSymbol, Greek_alpha, NoSymbol, NoSymbol, U2200, NoSymbol ] }; + key { [ e, E, NoSymbol, Greek_epsilon, NoSymbol, NoSymbol, U2203, NoSymbol ] }; + key { [ i, I, NoSymbol, Greek_iota, NoSymbol, NoSymbol, integral, NoSymbol ] }; + key { [ u, U, NoSymbol, NoSymbol, NoSymbol, NoSymbol, includedin, NoSymbol ] }; + key { [ d, D, NoSymbol, Greek_delta, NoSymbol, NoSymbol, Greek_DELTA, NoSymbol ] }; + key { [ t, T, NoSymbol, Greek_tau, NoSymbol, NoSymbol, partialderivative, NoSymbol ] }; + key { [ r, R, NoSymbol, Greek_rho, NoSymbol, NoSymbol, U211D, NoSymbol ] }; + key { [ n, N, NoSymbol, Greek_nu, NoSymbol, NoSymbol, U2115, NoSymbol ] }; + key { [ s, S, NoSymbol, Greek_sigma, NoSymbol, NoSymbol, Greek_SIGMA, NoSymbol ] }; + key { [ f, F, NoSymbol, Greek_phi, NoSymbol, NoSymbol, Greek_PHI, NoSymbol ] }; + key { [ x, X, NoSymbol, Greek_xi, NoSymbol, NoSymbol, Greek_XI, NoSymbol ] }; + key { [ q, Q, NoSymbol, U03D5, NoSymbol, NoSymbol, U211A, NoSymbol ] }; + key { [ adiaeresis, Adiaeresis, NoSymbol, Greek_eta, NoSymbol, NoSymbol, U2135, NoSymbol ] }; + key { [ udiaeresis, Udiaeresis, NoSymbol, NoSymbol, NoSymbol, NoSymbol, union, NoSymbol ] }; + key { [ odiaeresis, Odiaeresis, NoSymbol, U03F5, NoSymbol, NoSymbol, intersection, NoSymbol ] }; + key { [ b, B, NoSymbol, Greek_beta, NoSymbol, NoSymbol, U21D0, NoSymbol ] }; + key { [ p, P, NoSymbol, Greek_pi, NoSymbol, NoSymbol, Greek_PI, NoSymbol ] }; + key { [ w, W, NoSymbol, Greek_omega, NoSymbol, NoSymbol, Greek_OMEGA, NoSymbol ] }; + key { [ m, M, NoSymbol, Greek_mu, NoSymbol, NoSymbol, ifonlyif, NoSymbol ] }; + key { [ j, J, NoSymbol, Greek_theta, NoSymbol, NoSymbol, Greek_THETA, NoSymbol ] }; + + include "shift(both_capslock)" + include "level3(caps_switch)" + include "level3(bksl_switch)" + include "level5(lsgt_switch_lock)" + include "level5(ralt_switch_lock)" +}; + +partial alphanumeric_keys +xkb_symbols "bone_base" { + include "de(neo_base)" + + key.type[Group1] = "EIGHT_LEVEL_WITH_LEVEL5_LOCK"; + key { [ comma, endash, NoSymbol, U03F1, NoSymbol, NoSymbol, U21D2, NoSymbol ] }; + key { [ period, enfilledcircbullet, NoSymbol, U03D1, NoSymbol, NoSymbol, U21A6, NoSymbol ] }; + + key.type[Group1] = "EIGHT_LEVEL_ALPHABETIC_WITH_LEVEL5_LOCK"; + key { [ j, J, NoSymbol, Greek_theta, NoSymbol, NoSymbol, Greek_THETA, NoSymbol ] }; + key { [ d, D, NoSymbol, Greek_delta, NoSymbol, NoSymbol, Greek_DELTA, NoSymbol ] }; + key { [ u, U, NoSymbol, NoSymbol, NoSymbol, NoSymbol, includedin, NoSymbol ] }; + key { [ a, A, NoSymbol, Greek_alpha, NoSymbol, NoSymbol, U2200, NoSymbol ] }; + key { [ x, X, NoSymbol, Greek_xi, NoSymbol, NoSymbol, Greek_XI, NoSymbol ] }; + key { [ p, P, NoSymbol, Greek_pi, NoSymbol, NoSymbol, Greek_PI, NoSymbol ] }; + key { [ h, H, NoSymbol, Greek_psi, NoSymbol, NoSymbol, Greek_PSI, NoSymbol ] }; + key { [ l, L, NoSymbol, Greek_lambda, NoSymbol, NoSymbol, Greek_LAMBDA, NoSymbol ] }; + key { [ m, M, NoSymbol, Greek_mu, NoSymbol, NoSymbol, ifonlyif, NoSymbol ] }; + key { [ w, W, NoSymbol, Greek_omega, NoSymbol, NoSymbol, Greek_OMEGA, NoSymbol ] }; + key { [ ssharp, U1E9E, NoSymbol, Greek_finalsmallsigma, NoSymbol, NoSymbol, jot, NoSymbol ] }; + key { [ c, C, NoSymbol, Greek_chi, NoSymbol, NoSymbol, U2102, NoSymbol ] }; + key { [ t, T, NoSymbol, Greek_tau, NoSymbol, NoSymbol, partialderivative, NoSymbol ] }; + key { [ i, I, NoSymbol, Greek_iota, NoSymbol, NoSymbol, integral, NoSymbol ] }; + key { [ e, E, NoSymbol, Greek_epsilon, NoSymbol, NoSymbol, U2203, NoSymbol ] }; + key { [ o, O, NoSymbol, Greek_omicron, NoSymbol, NoSymbol, elementof, NoSymbol ] }; + key { [ b, B, NoSymbol, Greek_beta, NoSymbol, NoSymbol, U21D0, NoSymbol ] }; + key { [ n, N, NoSymbol, Greek_nu, NoSymbol, NoSymbol, U2115, NoSymbol ] }; + key { [ r, R, NoSymbol, Greek_rho, NoSymbol, NoSymbol, U211D, NoSymbol ] }; + key { [ s, S, NoSymbol, Greek_sigma, NoSymbol, NoSymbol, Greek_SIGMA, NoSymbol ] }; + key { [ g, G, NoSymbol, Greek_gamma, NoSymbol, NoSymbol, Greek_GAMMA, NoSymbol ] }; + key { [ q, Q, NoSymbol, U03D5, NoSymbol, NoSymbol, U211A, NoSymbol ] }; + key { [ f, F, NoSymbol, Greek_phi, NoSymbol, NoSymbol, Greek_PHI, NoSymbol ] }; + key { [ v, V, NoSymbol, NoSymbol, NoSymbol, NoSymbol, radical, NoSymbol ] }; + key { [ udiaeresis, Udiaeresis, NoSymbol, NoSymbol, NoSymbol, NoSymbol, union, NoSymbol ] }; + key { [ adiaeresis, Adiaeresis, NoSymbol, Greek_eta, NoSymbol, NoSymbol, U2135, NoSymbol ] }; + key { [ odiaeresis, Odiaeresis, NoSymbol, U03F5, NoSymbol, NoSymbol, intersection, NoSymbol ] }; + key { [ y, Y, NoSymbol, Greek_upsilon, NoSymbol, NoSymbol, nabla, NoSymbol ] }; + key { [ z, Z, NoSymbol, Greek_zeta, NoSymbol, NoSymbol, U2124, NoSymbol ] }; + key { [ k, K, NoSymbol, Greek_kappa, NoSymbol, NoSymbol, multiply, NoSymbol ] }; +}; + +partial alphanumeric_keys modifier_keys keypad_keys +xkb_symbols "bone" { + + include "de(bone_base)" + + name[Group1]= "German (Bone)"; + + include "shift(both_capslock)" + include "level3(caps_switch)" + include "level3(bksl_switch)" + include "level5(lsgt_switch_lock)" + include "level5(ralt_switch_lock)" +}; + +partial alphanumeric_keys modifier_keys keypad_keys +xkb_symbols "bone_eszett_home" { + include "de(bone_base)" + + name[Group1]= "German (Bone, eszett in the home row)"; + + key.type[Group1] = "EIGHT_LEVEL_ALPHABETIC_WITH_LEVEL5_LOCK"; + key { [ q, Q, NoSymbol, U03D5, NoSymbol, NoSymbol, U211A, NoSymbol ] }; + key { [ ssharp, U1E9E, NoSymbol, Greek_finalsmallsigma, NoSymbol, NoSymbol, jot, NoSymbol ] }; + + include "shift(both_capslock)" + include "level3(caps_switch)" + include "level3(bksl_switch)" + include "level5(lsgt_switch_lock)" + include "level5(ralt_switch_lock)" +}; + +partial alphanumeric_keys +xkb_symbols "neo_qwertz_base" { + include "de(neo_base)" + + key.type[Group1] = "EIGHT_LEVEL_WITH_LEVEL5_LOCK"; + key { [ comma, endash, NoSymbol, U03F1, NoSymbol, NoSymbol, U21D2, NoSymbol ] }; + key { [ period, enfilledcircbullet, NoSymbol, U03D1, NoSymbol, NoSymbol, U21A6, NoSymbol ] }; + key { [ minus, emdash, NoSymbol, U2011, NoSymbol, NoSymbol, hyphen, NoSymbol ] }; + + key.type[Group1] = "EIGHT_LEVEL_ALPHABETIC_WITH_LEVEL5_LOCK"; + key { [ ssharp, U1E9E, NoSymbol, Greek_finalsmallsigma, NoSymbol, NoSymbol, jot, NoSymbol ] }; + key { [ q, Q, NoSymbol, U03D5, NoSymbol, NoSymbol, U211A, NoSymbol ] }; + key { [ w, W, NoSymbol, Greek_omega, NoSymbol, NoSymbol, Greek_OMEGA, NoSymbol ] }; + key { [ e, E, NoSymbol, Greek_epsilon, NoSymbol, NoSymbol, U2203, NoSymbol ] }; + key { [ r, R, NoSymbol, Greek_rho, NoSymbol, NoSymbol, U211D, NoSymbol ] }; + key { [ t, T, NoSymbol, Greek_tau, NoSymbol, NoSymbol, partialderivative, NoSymbol ] }; + key { [ z, Z, NoSymbol, Greek_zeta, NoSymbol, NoSymbol, U2124, NoSymbol ] }; + key { [ u, U, NoSymbol, NoSymbol, NoSymbol, NoSymbol, includedin, NoSymbol ] }; + key { [ i, I, NoSymbol, Greek_iota, NoSymbol, NoSymbol, integral, NoSymbol ] }; + key { [ o, O, NoSymbol, Greek_omicron, NoSymbol, NoSymbol, elementof, NoSymbol ] }; + key { [ p, P, NoSymbol, Greek_pi, NoSymbol, NoSymbol, Greek_PI, NoSymbol ] }; + key { [ udiaeresis, Udiaeresis, NoSymbol, NoSymbol, NoSymbol, NoSymbol, union, NoSymbol ] }; + key { [ a, A, NoSymbol, Greek_alpha, NoSymbol, NoSymbol, U2200, NoSymbol ] }; + key { [ s, S, NoSymbol, Greek_sigma, NoSymbol, NoSymbol, Greek_SIGMA, NoSymbol ] }; + key { [ d, D, NoSymbol, Greek_delta, NoSymbol, NoSymbol, Greek_DELTA, NoSymbol ] }; + key { [ f, F, NoSymbol, Greek_phi, NoSymbol, NoSymbol, Greek_PHI, NoSymbol ] }; + key { [ g, G, NoSymbol, Greek_gamma, NoSymbol, NoSymbol, Greek_GAMMA, NoSymbol ] }; + key { [ h, H, NoSymbol, Greek_psi, NoSymbol, NoSymbol, Greek_PSI, NoSymbol ] }; + key { [ j, J, NoSymbol, Greek_theta, NoSymbol, NoSymbol, Greek_THETA, NoSymbol ] }; + key { [ k, K, NoSymbol, Greek_kappa, NoSymbol, NoSymbol, multiply, NoSymbol ] }; + key { [ l, L, NoSymbol, Greek_lambda, NoSymbol, NoSymbol, Greek_LAMBDA, NoSymbol ] }; + key { [ odiaeresis, Odiaeresis, NoSymbol, U03F5, NoSymbol, NoSymbol, intersection, NoSymbol ] }; + key { [ adiaeresis, Adiaeresis, NoSymbol, Greek_eta, NoSymbol, NoSymbol, U2135, NoSymbol ] }; + key { [ y, Y, NoSymbol, Greek_upsilon, NoSymbol, NoSymbol, nabla, NoSymbol ] }; + key { [ x, X, NoSymbol, Greek_xi, NoSymbol, NoSymbol, Greek_XI, NoSymbol ] }; + key { [ c, C, NoSymbol, Greek_chi, NoSymbol, NoSymbol, U2102, NoSymbol ] }; + key { [ v, V, NoSymbol, NoSymbol, NoSymbol, NoSymbol, radical, NoSymbol ] }; + key { [ b, B, NoSymbol, Greek_beta, NoSymbol, NoSymbol, U21D0, NoSymbol ] }; + key { [ n, N, NoSymbol, Greek_nu, NoSymbol, NoSymbol, U2115, NoSymbol ] }; + key { [ m, M, NoSymbol, Greek_mu, NoSymbol, NoSymbol, ifonlyif, NoSymbol ] }; +}; + +partial alphanumeric_keys modifier_keys keypad_keys +xkb_symbols "neo_qwertz" { + + include "de(neo_qwertz_base)" + + name[Group1]= "German (Neo, QWERTZ)"; + + include "shift(both_capslock)" + include "level3(caps_switch)" + include "level3(bksl_switch)" + include "level5(lsgt_switch_lock)" + include "level5(ralt_switch_lock)" +}; + +partial alphanumeric_keys modifier_keys keypad_keys +xkb_symbols "neo_qwerty" { + include "de(neo_qwertz_base)" + + name[Group1]= "German (Neo, QWERTY)"; + + key.type[Group1] = "EIGHT_LEVEL_ALPHABETIC_WITH_LEVEL5_LOCK"; + key { [ y, Y, NoSymbol, Greek_upsilon, NoSymbol, NoSymbol, nabla, NoSymbol ] }; + key { [ z, Z, NoSymbol, Greek_zeta, NoSymbol, NoSymbol, U2124, NoSymbol ] }; + + include "shift(both_capslock)" + include "level3(caps_switch)" + include "level3(bksl_switch)" + include "level5(lsgt_switch_lock)" + include "level5(ralt_switch_lock)" +}; + +partial alphanumeric_keys modifier_keys keypad_keys +xkb_symbols "noted" { + include "de(neo_base)" + + name[Group1]= "German (Noted)"; + + key.type[Group1] = "EIGHT_LEVEL_WITH_LEVEL5_LOCK"; + key { [ comma, endash, NoSymbol, U03F1, NoSymbol, NoSymbol, U21D0, NoSymbol ] }; + key { [ period, enfilledcircbullet, NoSymbol, U03D1, NoSymbol, NoSymbol, ifonlyif, NoSymbol ] }; + key { [ dead_acute, dead_tilde, dead_stroke, dead_psili, dead_doubleacute, NoSymbol, dead_breve, NoSymbol ] }; + + key.type[Group1] = "EIGHT_LEVEL_ALPHABETIC_WITH_LEVEL5_LOCK"; + key { [ z, Z, NoSymbol, Greek_zeta, NoSymbol, NoSymbol, U2124, NoSymbol ] }; + key { [ y, Y, NoSymbol, Greek_upsilon, NoSymbol, NoSymbol, U2135, NoSymbol ] }; + key { [ u, U, NoSymbol, VoidSymbol, NoSymbol, NoSymbol, multiply, NoSymbol ] }; + key { [ a, A, NoSymbol, Greek_alpha, NoSymbol, NoSymbol, U2200, NoSymbol ] }; + key { [ q, Q, NoSymbol, U03D5, NoSymbol, NoSymbol, U211A, NoSymbol ] }; + key { [ p, P, NoSymbol, Greek_pi, NoSymbol, NoSymbol, Greek_PI, NoSymbol ] }; + key { [ b, B, NoSymbol, Greek_beta, NoSymbol, NoSymbol, partialderivative, NoSymbol ] }; + key { [ m, M, NoSymbol, Greek_mu, NoSymbol, NoSymbol, U21A6, NoSymbol ] }; + key { [ l, L, NoSymbol, Greek_lambda, NoSymbol, NoSymbol, Greek_LAMBDA, NoSymbol ] }; + key { [ f, F, NoSymbol, Greek_phi, NoSymbol, NoSymbol, Greek_PHI, NoSymbol ] }; + key { [ j, J, at, Greek_theta, U2212, NoSymbol, Greek_THETA, NoSymbol ] }; + key { [ ssharp, U1E9E, U017F, Greek_finalsmallsigma, semicolon, NoSymbol, jot, NoSymbol ] }; + key { [ c, C, NoSymbol, Greek_chi, NoSymbol, NoSymbol, U2102, NoSymbol ] }; + key { [ s, S, NoSymbol, Greek_sigma, NoSymbol, NoSymbol, Greek_SIGMA, NoSymbol ] }; + key { [ i, I, NoSymbol, Greek_iota, NoSymbol, NoSymbol, integral, NoSymbol ] }; + key { [ e, E, NoSymbol, Greek_epsilon, NoSymbol, NoSymbol, U2203, NoSymbol ] }; + key { [ o, O, NoSymbol, Greek_omicron, NoSymbol, NoSymbol, elementof, NoSymbol ] }; + key { [ d, D, NoSymbol, Greek_delta, NoSymbol, NoSymbol, Greek_DELTA, NoSymbol ] }; + key { [ t, T, NoSymbol, Greek_tau, NoSymbol, NoSymbol, nabla, NoSymbol ] }; + key { [ n, N, NoSymbol, Greek_nu, NoSymbol, NoSymbol, U2115, NoSymbol ] }; + key { [ r, R, NoSymbol, Greek_rho, NoSymbol, NoSymbol, U211D, NoSymbol ] }; + key { [ h, H, NoSymbol, Greek_psi, period, KP_Decimal, Greek_PSI, NoSymbol ] }; + key { [ v, V, NoSymbol, VoidSymbol, NoSymbol, NoSymbol, radical, NoSymbol ] }; + key { [ x, X, NoSymbol, Greek_xi, NoSymbol, NoSymbol, Greek_XI, NoSymbol ] }; + key { [ udiaeresis, Udiaeresis, NoSymbol, VoidSymbol, NoSymbol, NoSymbol, union, NoSymbol ] }; + key { [ adiaeresis, Adiaeresis, NoSymbol, Greek_eta, NoSymbol, NoSymbol, intersection, NoSymbol ] }; + key { [ odiaeresis, Odiaeresis, NoSymbol, U03F5, NoSymbol, NoSymbol, includedin, NoSymbol ] }; + key { [ w, W, NoSymbol, Greek_omega, NoSymbol, NoSymbol, Greek_OMEGA, NoSymbol ] }; + key { [ g, G, NoSymbol, Greek_gamma, NoSymbol, NoSymbol, Greek_GAMMA, NoSymbol ] }; + key { [ k, K, NoSymbol, Greek_kappa, KP_Separator, comma, U21D2, NoSymbol ] }; + + include "shift(both_capslock)" + include "level3(caps_switch)" + include "level3(ac11_switch)" + include "level5(lsgt_switch_lock)" + include "level5(ralt_switch_lock)" +}; diff --git a/library/xkeyboard-config/vendor/symbols/es b/library/xkeyboard-config/vendor/symbols/es new file mode 100644 index 0000000..cc1f6b3 --- /dev/null +++ b/library/xkeyboard-config/vendor/symbols/es @@ -0,0 +1,250 @@ +// Keyboard layouts for Spain. + +// Modified for a real Spanish keyboard by Jon Tombs. +default partial alphanumeric_keys +xkb_symbols "basic" { + + include "latin(type4)" + + name[Group1]="Spanish"; + + key { [ masculine, ordfeminine, backslash, backslash ] }; + key { [ 1, exclam, bar, exclamdown ] }; + key { [ 3, periodcentered, numbersign, sterling ] }; + key { [ 4, dollar, asciitilde, dollar ] }; + key { [apostrophe, question, backslash, questiondown ] }; + key { [exclamdown, questiondown, dead_cedilla, dead_ogonek] }; + + key { [dead_grave, dead_circumflex, bracketleft, dead_abovering ] }; + key { [ plus, asterisk, bracketright, dead_macron ] }; + + key { [ ntilde, Ntilde, dead_tilde, dead_doubleacute ] }; + key { [dead_acute, dead_diaeresis, braceleft, dead_caron ] }; + key { [ ccedilla, Ccedilla, braceright, dead_breve ] }; + + include "level3(ralt_switch)" +}; + +partial alphanumeric_keys +xkb_symbols "winkeys" { + + include "es(basic)" + name[Group1]="Spanish (Windows)"; + include "eurosign(5)" +}; + +partial alphanumeric_keys +xkb_symbols "nodeadkeys" { + + include "es(basic)" + + name[Group1]="Spanish (no dead keys)"; + + key { [exclamdown, questiondown, cedilla, ogonek ] }; + key { [ grave, asciicircum, bracketleft, degree ] }; + key { [ plus, asterisk, bracketright, macron ] }; + key { [ j, J, ezh, EZH ] }; + key { [ ntilde, Ntilde, asciitilde, doubleacute ] }; + key { [ acute, diaeresis, braceleft, caron ] }; + key { [ ccedilla, Ccedilla, braceright, breve ] }; + key { [ minus, underscore, ellipsis, abovedot ] }; +}; + +// Spanish Dvorak mapping (note R-H exchange) +partial alphanumeric_keys +xkb_symbols "dvorak" { + + name[Group1]="Spanish (Dvorak)"; + + key {[ masculine, ordfeminine, backslash, degree ]}; + key {[ 1, exclam, bar, onesuperior ]}; + key {[ 2, quotedbl, at, twosuperior ]}; + key {[ 3, periodcentered, numbersign, threesuperior ]}; + key {[ 4, dollar, asciitilde, onequarter ]}; + key {[ 5, percent, brokenbar, fiveeighths ]}; + key {[ 6, ampersand, notsign, threequarters ]}; + key {[ 7, slash, onehalf, seveneighths ]}; + key {[ 8, parenleft, oneeighth, threeeighths ]}; + key {[ 9, parenright, asciicircum ]}; + key {[ 0, equal, grave, dead_doubleacute ]}; + key {[ apostrophe, question, dead_macron, dead_ogonek ]}; + key {[ exclamdown, questiondown, dead_breve, dead_abovedot ]}; + + key {[ period, colon, less, guillemotleft ]}; + key {[ comma, semicolon, greater, guillemotright ]}; + key {[ ntilde, Ntilde, lstroke, Lstroke ]}; + key {[ p, P, paragraph ]}; + key {[ y, Y, yen ]}; + key {[ f, F, tslash, Tslash ]}; + key {[ g, G, dstroke, Dstroke ]}; + key {[ c, C, cent, copyright ]}; + key {[ h, H, hstroke, Hstroke ]}; + key {[ l, L, sterling ]}; + key {[ dead_grave, dead_circumflex, bracketleft, dead_caron ]}; + key {[ plus, asterisk, bracketright, plusminus ]}; + + key {[ a, A, ae, AE ]}; + key {[ o, O, oslash, Oslash ]}; + key {[ e, E, EuroSign ]}; + key {[ u, U, aring, Aring ]}; + key {[ i, I, oe, OE ]}; + key {[ d, D, eth, ETH ]}; + key {[ r, R, registered, trademark ]}; + key {[ t, T, thorn, THORN ]}; + key {[ n, N, eng, ENG ]}; + key {[ s, S, ssharp, section ]}; + key {[ dead_acute, dead_diaeresis, braceleft, dead_tilde ]}; + key {[ ccedilla, Ccedilla, braceright, dead_cedilla ]}; + + key {[ less, greater, guillemotleft, guillemotright ]}; + key {[ minus, underscore, hyphen, macron ]}; + key {[ q, Q, currency ]}; + key {[ j, J ]}; + key {[ k, K, kra ]}; + key {[ x, X, multiply, division ]}; + key {[ b, B ]}; + key {[ m, M, mu ]}; + key {[ w, W ]}; + key {[ v, V ]}; + key {[ z, Z ]}; + + include "level3(ralt_switch)" +}; + +partial alphanumeric_keys +xkb_symbols "cat" { + + include "es(basic)" + + name[Group1]="Catalan (Spain, with middle-dot L)"; + + key { [ l, L, 0x1000140, 0x100013F ] }; +}; + +partial alphanumeric_keys +xkb_symbols "ast" { + + include "es(basic)" + + name[Group1]="Asturian (Spain, with bottom-dot H and L)"; + + key { [ h, H, 0x1001E25, 0x1001E24 ] }; + key { [ l, L, 0x1001E37, 0x1001E36 ] }; +}; + + +partial alphanumeric_keys +xkb_symbols "olpc" { + + // #HW-SPECIFIC + + // http://wiki.laptop.org/go/OLPC_Spanish_Keyboard + + include "us(basic)" + name[Group1]="Spanish"; + + key { [ masculine, ordfeminine ] }; + key { [ 1, exclam, bar ] }; + key { [ 2, quotedbl, at ] }; + key { [ 3, dead_grave, numbersign, grave ] }; + key { [ 5, percent, asciicircum, dead_circumflex ] }; + key { [ 6, ampersand, notsign ] }; + key { [ 7, slash, backslash ] }; + key { [ 8, parenleft ] }; + key { [ 9, parenright ] }; + key { [ 0, equal ] }; + key { [ apostrophe, question ] }; + key { [ exclamdown, questiondown ] }; + + key { [ e, E, EuroSign ] }; + key { [ dead_acute, dead_diaeresis, acute, dead_abovering ] }; + key { [ bracketleft, braceleft ] }; + + key { [ ntilde, Ntilde ] }; + key { [ plus, asterisk, dead_tilde ] }; + key { [ bracketright, braceright, section ] }; + + key { [ comma, semicolon ] }; + key { [ period, colon ] }; + key { [ minus, underscore ] }; + + key { [ less, greater, ISO_Next_Group ] }; + + include "level3(ralt_switch)" +}; + +partial alphanumeric_keys +xkb_symbols "olpcm" { + + // #HW-SPECIFIC + + // Mechanical (non-membrane) OLPC Spanish keyboard layout. + // See: http://wiki.laptop.org/go/OLPC_Spanish_Non-membrane_Keyboard + + include "us(basic)" + name[Group1]="Spanish"; + + key { [ questiondown, exclamdown, backslash ] }; + key { [ 1, exclam, bar ] }; + key { [ 2, quotedbl, at ] }; + key { [ 3, dead_grave, numbersign, grave ] }; + key { [ 4, dollar, asciitilde, dead_tilde ] }; + key { [ 5, percent, asciicircum, dead_circumflex ] }; + key { [ 6, ampersand, notsign ] }; + key { [ 7, slash, backslash ] }; // no '\' label on olpcm, leave for compatibility + key { [ 8, parenleft, masculine ] }; + key { [ 9, parenright, ordfeminine ] }; + key { [ 0, equal ] }; + key { [ apostrophe, question ] }; + + key { [ e, E, EuroSign ] }; + key { [ dead_acute, dead_diaeresis, dead_abovering, acute ] }; + key { [ plus, asterisk ] }; + + key { [ ntilde, Ntilde ] }; + // no AC11 or AC12 on olpcm + + key { [ comma, semicolon ] }; + key { [ period, colon ] }; + key { [ minus, underscore ] }; + + key { [ less, greater ] }; + key { [ bracketleft, braceleft, ccedilla, Ccedilla ] }; + key { [ bracketright, braceright ] }; + + include "level3(ralt_switch)" +}; + +partial alphanumeric_keys +xkb_symbols "deadtilde" { + + include "es(basic)" + + name[Group1]="Spanish (dead tilde)"; + + key { [ 4, dollar, dead_tilde, dollar ] }; + key { [ ntilde, Ntilde, asciitilde, dead_doubleacute ] }; +}; + +partial alphanumeric_keys +xkb_symbols "olpc2" { + // #HW-SPECIFIC + + // Modified variant of US International layout, specifically for Peru + // Contact: Sayamindu Dasgupta + + include "us(olpc)" + name[Group1]="Spanish"; + + key { [ 3, numbersign, dead_grave, dead_grave] }; // combining grave + key { [ XF86Start ] }; + + include "level3(ralt_switch)" +}; + +// EXTRAS: + +partial alphanumeric_keys + xkb_symbols "sun_type6" { + include "sun_vndr/es(sun_type6)" +}; diff --git a/library/xkeyboard-config/vendor/symbols/fr b/library/xkeyboard-config/vendor/symbols/fr new file mode 100644 index 0000000..a446a34 --- /dev/null +++ b/library/xkeyboard-config/vendor/symbols/fr @@ -0,0 +1,1404 @@ +// Keyboard layouts for France. + +default partial alphanumeric_keys +xkb_symbols "basic" { + + include "latin" + + name[Group1]="French"; + + key { [twosuperior, asciitilde, notsign, notsign ] }; + key { [ ampersand, 1, onesuperior, exclamdown ] }; + key { [ eacute, 2, asciitilde, oneeighth ] }; + key { [ quotedbl, 3, numbersign, sterling ] }; + key { [apostrophe, 4, braceleft, dollar ] }; + key { [ parenleft, 5, bracketleft, threeeighths ] }; + key { [ minus, 6, bar, fiveeighths ] }; + key { [ egrave, 7, grave, seveneighths ] }; + key { [underscore, 8, backslash, trademark ] }; + key { [ ccedilla, 9, asciicircum, plusminus ] }; + key { [ agrave, 0, at, degree ] }; + key { [parenright, degree, bracketright, questiondown ] }; + key { [ equal, plus, braceright, dead_ogonek ] }; + + key { [ a, A, ae, AE ] }; + key { [ z, Z, guillemotleft, less ] }; + key { [ e, E, EuroSign, cent ] }; + key { [dead_circumflex, dead_diaeresis, dead_diaeresis, dead_abovering ] }; + key { [ dollar, sterling, currency, dead_macron ] }; + + key { [ q, Q, at, Greek_OMEGA ] }; + key { [ m, M, mu, masculine ] }; + key { [ ugrave, percent, dead_circumflex, dead_caron] }; + key { [ asterisk, mu, dead_grave, dead_breve ] }; + + key { [ w, W, lstroke, Lstroke ] }; + key { [ comma, question, dead_acute, dead_doubleacute ] }; + key { [ semicolon, period, U2022, multiply ] }; // bullet + key { [ colon, slash, periodcentered, division ] }; + key { [ exclam, section, dead_belowdot, dead_abovedot ] }; + + include "level3(ralt_switch)" +}; + +partial alphanumeric_keys +xkb_symbols "olpc" { + + // #HW-SPECIFIC + + // Contact: Sayamindu Dasgupta + include "fr(basic)" + + name[Group1]="French"; + + key { [ less, greater ] }; + key { [ dead_circumflex, dead_diaeresis, notsign, dead_abovering ] }; + key { [ semicolon, period, underscore, multiply ] }; + key { [ twosuperior, asciitilde, VoidSymbol, VoidSymbol ] }; + + // Some keys only have the Shift+AltGr character printed on them (alongside + // the unmodified one). Make such keys shift-invariant so that the printed + // value is achieved by pressing AltGr or Shift+AltGr. + key { [ x, X, guillemotright, guillemotright ] }; + key { [ s, S, ssharp, U1E9E ] }; + key { [ z, Z, guillemotleft, guillemotleft ] }; +}; + +partial alphanumeric_keys +xkb_symbols "nodeadkeys" { + + // Modifies the basic French layout to eliminate all dead keys + + include "fr(basic)" + + name[Group1]="French (no dead keys)"; + + key { [ equal, plus, braceright, ogonek ] }; + key { [asciicircum, diaeresis, radical, dagger ] }; + key { [ dollar, sterling, currency, macron ] }; + key { [ j, J, ezh, EZH ] }; + key { [ ugrave, percent, asciicircum, caron ] }; + key { [ asterisk, mu, grave, breve ] }; + key { [ comma, question, acute, doubleacute ] }; + key { [ exclam, section, ellipsis, abovedot ] }; +}; + + +// Unicode French derivative +// Loose refactoring of the historic Linux French keyboard layout +// +// Copyright © 2006-2008 Nicolas Mailhot +// +// Credits (fr-latin1, fr-latin0, fr-latin9) +// © 199x-1996 René Cougnenc ✝ +// © 1997-2002 Guylhem Aznar +// © 2003-2006 Nicolas Mailhot +// +// ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┲━━━━━━━━━┓ +// │ ³ ¸ │ 1 ̨ │ 2 É │ 3 ˘ │ 4 — │ 5 – │ 6 ‑ │ 7 È │ 8 ™ │ 9 Ç │ 0 À │ ° ≠ │ + ± ┃ ⌫ Retour┃ +// │ ² ¹ │ & ˇ │ é ~ │ " # │ ' { │ ( [ │ - | │ è ` │ _ \ │ ç ^ │ à @ │ ) ] │ = } ┃ arrière┃ +// ┢━━━━━┷━┱───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┺━┳━━━━━━━┫ +// ┃ ┃ A Æ │ Z  │ E ¢ │ R Ê │ T Þ │ Y Ÿ │ U Û │ I Î │ O Œ │ P Ô │ ¨ ˚ │ £ Ø ┃Entrée ┃ +// ┃Tab ↹ ┃ a æ │ z â │ e € │ r ê │ t þ │ y ÿ │ u û │ i î │ o œ │ p ô │ ^ ~ │ $ ø ┃ ⏎ ┃ +// ┣━━━━━━━┻┱────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┺┓ ┃ +// ┃ ┃ Q Ä │ S „ │ D Ë │ F ‚ │ G ¥ │ H Ð │ J Ü │ K Ï │ L Ŀ │ M Ö │ % Ù │ µ ̄ ┃ ┃ +// ┃Maj ⇬ ┃ q ä │ s ß │ d ë │ f ‘ │ g ’ │ h ð │ j ü │ k ï │ l ŀ │ m ö │ ù ' │ * ` ┃ ┃ +// ┣━━━━━━━┳┹────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┲┷━━━━━┻━━━━━━┫ +// ┃ ┃ > ≥ │ W “ │ X ” │ C ® │ V ← │ B ↑ │ N → │ ? … │ . . │ / ∕ │ § − ┃ ┃ +// ┃Shift ⇧┃ < ≤ │ w « │ x » │ c © │ v ⍽ │ b ↓ │ n ¬ │ , ¿ │ ; × │ : ÷ │ ! ¡ ┃Shift ⇧ ┃ +// ┣━━━━━━━╋━━━━━┷━┳━━━┷━━━┱─┴─────┴─────┴─────┴─────┴─────┴───┲━┷━━━━━╈━━━━━┻━┳━━━━━━━┳━━━┛ +// ┃ ┃ ┃ ┃ ␣ Espace fine insécable ⍽ ┃ ┃ ┃ ┃ +// ┃Ctrl ┃Meta ┃Alt ┃ ␣ Espace Espace insécable ⍽ ┃AltGr ⇮┃Menu ┃Ctrl ┃ +// ┗━━━━━━━┻━━━━━━━┻━━━━━━━┹───────────────────────────────────┺━━━━━━━┻━━━━━━━┻━━━━━━━┛ +partial alphanumeric_keys +xkb_symbols "oss" { + + include "level3(ralt_switch)" + include "nbsp(level3n)" + include "keypad(oss)" + + name[Group1]="French (alt.)"; + + // First row + key { [ twosuperior, threesuperior, onesuperior, dead_cedilla ] }; // ² ³ ¹ ¸ + key { [ ampersand, 1, dead_caron, dead_ogonek ] }; // & 1 ˇ ˛ + key { [ eacute, 2, asciitilde, Eacute ] }; // é 2 ~ É + key { [ quotedbl, 3, numbersign, dead_breve ] }; // " 3 # ˘ + key { [ apostrophe, 4, braceleft, 0x1002014 ] }; // ' 4 { — (tiret cadratin) + key { [ parenleft, 5, bracketleft, 0x1002013 ] }; // ( 5 [ – (tiret demi-cadratin) + key { [ minus, 6, bar, 0x1002011 ] }; // - 6 | ‑ (tiret insécable) + key { [ egrave, 7, grave, Egrave ] }; // è 7 ` È + key { [ underscore, 8, backslash, trademark ] }; // _ 8 \ ™ + key { [ ccedilla, 9, asciicircum, Ccedilla ] }; // ç 9 ^ Ç + key { [ agrave, 0, at, Agrave ] }; // à 0 @ À + key { [ parenright, degree, bracketright, notequal ] }; // ) ° ] ≠ + key { [ equal, plus, braceright, plusminus ] }; // = + } ± + + // Second row + key { [ a, A, ae, AE ] }; // a A æ Æ + key { [ z, Z, acircumflex, Acircumflex ] }; // z Z â  + key { [ e, E, EuroSign, cent ] }; // e E € ¢ + key { [ r, R, ecircumflex, Ecircumflex ] }; // r R ê Ê + key { [ t, T, thorn, THORN ] }; // t T þ Þ + key { [ y, Y, ydiaeresis, Ydiaeresis ] }; // y Y ÿ Ÿ + key { [ u, U, ucircumflex, Ucircumflex ] }; // u U û Û + key { [ i, I, icircumflex, Icircumflex ] }; // i I î Î + key { [ o, O, oe, OE ] }; // o O œ Œ + key { [ p, P, ocircumflex, Ocircumflex ] }; // p P ô Ô + key { [ dead_circumflex, dead_diaeresis, dead_tilde, dead_abovering ] }; // ^ ¨ ˜ ˚ + key { [ dollar, sterling, oslash, Oslash ] }; // $ £ ø Ø + + // Third row + key { [ q, Q, adiaeresis, Adiaeresis ] }; // q Q ä Ä + key { [ s, S, ssharp, doublelowquotemark ] }; // s S ß „ + key { [ d, D, ediaeresis, Ediaeresis ] }; // d D ë Ë + key { [ f, F, leftsinglequotemark, singlelowquotemark ] }; // f F ‘ ‚ + key { [ g, G, rightsinglequotemark, yen ] }; // g G ’ ¥ + key { [ h, H, eth, ETH ] }; // h H ð Ð + key { [ j, J, udiaeresis, Udiaeresis ] }; // j J ü Ü + key { [ k, K, idiaeresis, Idiaeresis ] }; // k K ï Ï + key { [ l, L, 0x1000140, 0x100013F ] }; // l L ŀ Ŀ + key { [ m, M, odiaeresis, Odiaeresis ] }; // m M ö Ö + key { [ ugrave, percent, dead_acute, Ugrave ] }; // ù % ´ Ù + key { [ asterisk, mu, dead_grave, dead_macron ] }; // * µ ` ¯ + + // Fourth row + key { [ less, greater, lessthanequal, greaterthanequal ] }; // < > ≤ ≥ + key { [ w, W, guillemotleft, leftdoublequotemark ] }; // w W « “ + key { [ x, X, guillemotright, rightdoublequotemark ] }; // x X » ” + key { [ c, C, copyright, registered ] }; // c C © ® + key { [ v, V, 0x100202F, leftarrow ] }; // v V ⍽ ← (espace fine insécable) + key { [ b, B, downarrow, uparrow ] }; // b B ↓ ↑ + key { [ n, N, notsign, rightarrow ] }; // n N ¬ → + key { [ comma, question, questiondown, 0x1002026 ] }; // , ? ¿ … + key { [ semicolon, period, multiply, 0x10022C5 ] }; // ; . × ⋅ + key { [ colon, slash, division, 0x1002215 ] }; // : / ÷ ∕ + key { [ exclam, section, exclamdown, 0x1002212 ] }; // ! § ¡ − +}; + +partial alphanumeric_keys +xkb_symbols "oss_latin9" { + + // Restricts the fr(oss) layout to latin9 symbols + + include "fr(oss)" + include "keypad(oss_latin9)" + + name[Group1]="French (alt., Latin-9 only)"; + + // First row + key { [ ampersand, 1, dead_caron, dead_cedilla ] }; // & 1 ˇ ¸ + key { [ quotedbl, 3, numbersign, dead_tilde ] }; // " 3 # ˜ + key { [ apostrophe, 4, braceleft, underscore ] }; // ' 4 { _ + key { [ parenleft, 5, bracketleft, minus ] }; // ( 5 [ - + key { [ minus, 6, bar, minus ] }; // - 6 | - + key { [ underscore, 8, backslash, backslash ] }; // _ 8 \ \ + key { [ parenright, degree, bracketright, equal ] }; // ) ° ] = + + // Third row + key { [ s, S, ssharp, guillemotleft ] }; // s S ß « + key { [ f, F, apostrophe, apostrophe ] }; // f F ' ' + key { [ g, G, apostrophe, yen ] }; // g G ' ¥ + key { [ l, L, periodcentered, periodcentered ] }; // l L · · + key { [ asterisk, mu, dead_grave, dead_circumflex ] }; // * µ ` ^ + + // Fourth row + key { [ less, greater, less, greater ] }; // < > < > + key { [ w, W, guillemotleft, guillemotleft ] }; // w W « « + key { [ x, X, guillemotright, guillemotright ] }; // x X » » + key { [ v, V, nobreakspace, less ] }; // v V ⍽ < (espace insécable) + key { [ b, B, minus, asciicircum ] }; // b B - ^ + key { [ n, N, notsign, greater ] }; // n N ¬ > + key { [ comma, question, questiondown, period ] }; // , ? ¿ . + key { [ semicolon, period, multiply, periodcentered ] }; // ; . × · + key { [ colon, slash, division, slash ] }; // : / ÷ / + key { [ exclam, section, exclamdown, minus ] }; // ! § ¡ - +}; + +partial alphanumeric_keys +xkb_symbols "oss_nodeadkeys" { + + // Modifies the basic fr(oss) layout to eliminate all dead keys + + include "fr(oss)" + + name[Group1]="French (alt., no dead keys)"; + + key { [ twosuperior, threesuperior, onesuperior, cedilla ] }; // ² ³ ¹ ¸ + key { [ ampersand, 1, caron, ogonek ] }; // & 1 ˇ ˛ + key { [ quotedbl, 3, numbersign, breve ] }; // " 3 # ˘ + + key { [ asciicircum, diaeresis, asciitilde, Aring ] }; // ^ ¨ ~ Å + key { [ ugrave, percent, acute, Ugrave ] }; // ù % ' Ù + key { [ asterisk, mu, grave, macron ] }; // * µ ` ¯ +}; + + +// Historic Linux French keyboard layout (fr-latin9) +// Copyright (c) 199x, 2002 Rene Cougnenc (original work) +// Guylhem Aznar (maintainer) +// Nicolas Mailhot +// (XFree86 submission) +// +// This layout has long been distributed and refined outside official channels. +// To this day it remains more feature-rich and popular than the 'fr' layout. +// +// This layout is derived from an original version by Guylhem Aznar. +// The original version is always available from: +// http://en.tldp.org/HOWTO/Francophones-HOWTO.html +// and is distributed under a GPL license. +// +// The author has given permission for this derived version to be distributed +// under the standard XFree86 license. He would like all changes to this +// version to be sent to him at , so he can sync +// the identically named linux console map (kbd, linux-console) and his +// out-of-tree GPL version. +// +// Now follows the keyboard design description in French. +// (If you can't read it you probably have no business changing this file anyway:) +// +// Les accents circonflexes des principales voyelles sont obtenus avec +// la touche Alt_Gr, les trémas sont obtenus par Alt_Gr + Shift. +// +// ____ +// | S A| S = Shift, A = AltGr + Shift +// | s a| s = normal, a = AltGr +// ¯¯¯¯ +// ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ _______ +// | œ "| 1 ·| 2 É| 3 ,| 4 '| 5 "| 6 || 7 È| 8 ¯| 9 Ç| 0 À| ° ÿ| + °| <-- | +// | Œ "| & '| é ~| " #| ' {| ( [| - || è `| _ \| ç ^| à @| ) ]| = }| | +// ======================================================================== +// | |<- | A ä| Z Å| E ¢| R Ç| T Þ| Y Ý| U ü| I ï| O ö| P '| " `| $ ë| , | +// | ->| | a â| z å| e €| r ç| t þ| y ý| u û| i î| o ô| p ¶| ^ ~| £ ê| <-' | +// ===================================================================¬ | +// | | Q Ä| S Ø| D Ë| F ª| G Æ| H Ð| J Ü| K Ï| L Ö| M º| % Ù| µ ¥| | +// | MAJ | q Â| s ø| d Ê| f ±| g æ| h ð| j Û| k Î| l Ô| m ¹| ù ²| * ³| | +// ======================================================================== +// | ^ | > | W | X | C | V | B | N | ? | . | / | § | ^ | +// | | | < || w «| x »| c ©| v ®| b ß| n ¬| , ¿| ; ×| : ÷| ! ¡| | | +// ======================================================================== +// | | | | | | | | | +// | Ctrl | Super| Alt | Space Nobreakspace | AltGr | Super|Menu | Ctrl | +// ¯¯¯¯¯¯ ¯¯¯¯¯¯ ¯¯¯¯¯¯ ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ ¯¯¯¯¯¯¯ ¯¯¯¯¯¯ ¯¯¯¯¯ ¯¯¯¯¯¯ +// +// Si les touches mortes fonctionnent, utiliser les accents dits +// « morts », i.e. fonctionnant comme l'accent circonflexe & le +// tréma des machines à écrire ; sont disponibles : +// +// (^) : accent circonflexe, +// Shift+(^) : tréma, +// AltGr+(^) : tilde, +// AltGr+(1) : accent aigu, +// AltGr+(7) : accent grave +// +// Pour s'en servir, procéder comme avec l'accent circonflexe & le tréma +// sur les vielles machines à écrire : +// +// AltGr+(1) puis e : é +// AltGr+(1) puis E : É +// +partial alphanumeric_keys + +xkb_symbols "latin9" { + + include "latin" + include "nbsp(level3)" + + name[Group1]="French (legacy, alt.)"; + + key { [ oe, OE, leftdoublequotemark, rightdoublequotemark ] }; + key { [ ampersand, 1, dead_acute, periodcentered ] }; + key { [ eacute, 2, asciitilde, Eacute ] }; + key { [ quotedbl, 3, numbersign, cedilla ] }; + key { [ apostrophe, 4, braceleft, acute ] }; + key { [ parenleft, 5, bracketleft, diaeresis ] }; + key { [ minus, 6, bar, brokenbar ] }; + key { [ egrave, 7, dead_grave, Egrave ] }; + key { [ underscore, 8, backslash, macron ] }; + key { [ ccedilla, 9, asciicircum, Ccedilla ] }; + key { [ agrave, 0, at, Agrave ] }; + key { [ parenright, degree, bracketright, ydiaeresis ] }; + key { [ equal, plus, braceright, dead_abovering ] }; + + key { [ a, A, acircumflex, adiaeresis ] }; + key { [ z, Z, aring, Aring ] }; + key { [ e, E, EuroSign, cent ] }; + key { [ r, R, ccedilla, Ccedilla ] }; + key { [ t, T, thorn, THORN ] }; + key { [ y, Y, yacute, Yacute ] }; + key { [ u, U, ucircumflex, udiaeresis ] }; + key { [ i, I, icircumflex, idiaeresis ] }; + key { [ o, O, ocircumflex, odiaeresis ] }; + key { [ p, P, paragraph, grave ] }; + key { [ dead_circumflex, dead_diaeresis, dead_tilde, apostrophe ] }; + key { [ dollar, sterling, ecircumflex, ediaeresis ] }; + + key { [ q, Q, Acircumflex, Adiaeresis ] }; + key { [ s, S, oslash, Oslash ] }; + key { [ d, D, Ecircumflex, Ediaeresis ] }; + key { [ f, F, plusminus, ordfeminine ] }; + key { [ g, G, ae, AE ] }; + key { [ h, H, eth, ETH ] }; + key { [ j, J, Ucircumflex, Udiaeresis ] }; + key { [ k, K, Icircumflex, Idiaeresis ] }; + key { [ l, L, Ocircumflex, Odiaeresis ] }; + key { [ m, M, onesuperior, masculine ] }; + key { [ ugrave, percent, twosuperior, Ugrave ] }; + key { [ asterisk, mu, threesuperior, yen ] }; + + key { [ less, greater, bar ] }; + key { [ w, W, guillemotleft ] }; + key { [ x, X, guillemotright ] }; + key { [ c, C, copyright ] }; + key { [ v, V, registered ] }; + key { [ b, B, ssharp, U1E9E ] }; + key { [ n, N, notsign ] }; + key { [ comma, question, questiondown ] }; + key { [ semicolon, period, multiply ] }; + key { [ colon, slash, division ] }; + key { [ exclam, section, exclamdown ] }; + + // French uses a comma as decimal separator, but keyboards are labeled with a period + // Will take effect when KP_Decimal is mapped to the locale decimal separator + key { [ KP_Delete, KP_Decimal, KP_Delete, KP_Decimal ] }; + + include "level3(ralt_switch)" +}; + +partial alphanumeric_keys +xkb_symbols "latin9_nodeadkeys" { + + // Modifies the basic fr-latin9 layout to eliminate all dead keys + + include "fr(latin9)" + + name[Group1]="French (legacy, alt., no dead keys)"; + + key { [ ampersand, 1, apostrophe, periodcentered ] }; + key { [ egrave, 7, grave, Egrave ] }; + key { [ equal, plus, braceright ] }; + key { [ asciicircum, diaeresis, asciitilde, apostrophe ] }; +}; + +// Bépo : Improved ergonomic french keymap using Dvorak method. +// Built by community on 'Dvorak Fr / Bépo' : +// see http://www.clavier-dvorak.org/wiki/ to join and help. +// XOrg integration (1.0rc2 version) in 2008 +// by Frédéric Boiteux +// +// Bépo layout (1.0rc2 version) for a pc105 keyboard (french) : +// ┌─────┐ +// │ S A │ S = Shift, A = AltGr + Shift +// │ s a │ s = normal, a = AltGr +// └─────┘ +// +// ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┲━━━━━━━━━┓ +// │ # ¶ │ 1 „ │ 2 “ │ 3 ” │ 4 ≤ │ 5 ≥ │ 6 │ 7 ¬ │ 8 ¼ │ 9 ½ │ 0 ¾ │ ° ′ │ ` ″ ┃ ⌫ Retour┃ +// │ $ – │ " — │ « < │ » > │ ( [ │ ) ] │ @ ^ │ + ± │ - − │ / ÷ │ * × │ = ≠ │ % ‰ ┃ arrière┃ +// ┢━━━━━┷━┱───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┺━┳━━━━━━━┫ +// ┃ ┃ B ¦ │ É ˝ │ P § │ O Œ │ È ` │ ! │ V │ D Ð │ L │ J IJ │ Z Ə │ W ┃Entrée ┃ +// ┃Tab ↹ ┃ b | │ é ˊ │ p & │ o œ │ è ` │ ˆ ¡ │ v ˇ │ d ð │ l / │ j ij │ z ə │ w ̆ ┃ ⏎ ┃ +// ┣━━━━━━━┻┱────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┺┓ ┃ +// ┃ ┃ A Æ │ U Ù │ I ˙ │ E ¤ │ ; ̛ │ C ſ │ T Þ │ S ẞ │ R ™ │ N │ M º │ Ç , ┃ ┃ +// ┃Maj ⇬ ┃ a æ │ u ù │ i ̈ │ e € │ , ’ │ c © │ t þ │ s ß │ r ® │ n ˜ │ m ¯ │ ç ¸ ┃ ┃ +// ┣━━━━━━━┳┹────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┲┷━━━━━┻━━━━━━┫ +// ┃ ┃ Ê │ À │ Y ‘ │ X ’ │ : · │ K │ ? ̉ │ Q ̣ │ G │ H ‡ │ F ª ┃ ┃ +// ┃Shift ⇧┃ ê / │ à \ │ y { │ x } │ . … │ k ~ │ ' ¿ │ q ˚ │ g µ │ h † │ f ˛ ┃Shift ⇧ ┃ +// ┣━━━━━━━╋━━━━━┷━┳━━━┷━━━┱─┴─────┴─────┴─────┴─────┴─────┴───┲━┷━━━━━╈━━━━━┻━┳━━━━━━━┳━━━┛ +// ┃ ┃ ┃ ┃ Espace inséc. Espace inséc. fin ┃ ┃ ┃ ┃ +// ┃Ctrl ┃Meta ┃Alt ┃ ␣ (Espace) _ ␣ ┃AltGr ⇮┃Menu ┃Ctrl ┃ +// ┗━━━━━━━┻━━━━━━━┻━━━━━━━┹───────────────────────────────────┺━━━━━━━┻━━━━━━━┻━━━━━━━┛ +partial alphanumeric_keys +xkb_symbols "bepo" { + + include "level3(ralt_switch)" + include "keypad(oss)" + + name[Group1]= "French (BEPO)"; + + // First row + key { [ dollar, numbersign, endash, paragraph ] }; // $ # – ¶ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ quotedbl, 1, emdash, doublelowquotemark ] }; // " 1 — „ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ guillemotleft, 2, less, leftdoublequotemark ] }; // « 2 < “ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ guillemotright, 3, greater, rightdoublequotemark ] }; // » 3 > ” + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ parenleft, 4, bracketleft, lessthanequal ] }; // ( 4 [ ≤ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ parenright, 5, bracketright, greaterthanequal ] }; // ) 5 ] ≥ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ at, 6, asciicircum ] }; // @ 6 ^ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ plus, 7, plusminus, notsign ] }; // + 7 ± ¬ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ minus, 8, U2212, onequarter ] }; // - 8 − ¼ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ slash, 9, division, onehalf ] }; // / 9 ÷ ½ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ asterisk, 0, multiply, threequarters ] }; // * 0 × ¾ + key { [ equal, degree, notequal, minutes ] }; // = ° ≠ ′ + key { [ percent, grave, permille, seconds ] }; // % ` ‰ ″ + + // Second row + key { [ b, B, bar, brokenbar ] }; // b B | ¦ + key { [ eacute, Eacute, dead_acute, dead_doubleacute]}; // é É ˊ ˝ + key { [ p, P, ampersand, section ] }; // p P & § + key { [ o, O, oe, OE ] }; // o O œ Œ + key { [ egrave, Egrave, dead_grave, grave ] }; // è È ` ` + key { [ dead_circumflex, exclam, exclamdown ] }; // ^ ! ¡ + key { [ v, V, dead_caron ] }; // v V ˇ + key { [ d, D, eth, ETH ] }; // d D ð Ð + key { [ l, L, dead_stroke ] }; // l L / + key { [ j, J, U0133, U0132 ] }; // j J ij IJ + key { [ z, Z, schwa, SCHWA ] }; // z Z ə Ə + key { [ w, W, dead_breve ] }; // w W ˘ + + // Third row + key { [ a, A, ae, AE ] }; // a A æ Æ + key { [ u, U, ugrave, Ugrave ] }; // u U ù Ù + key { [ i, I, dead_diaeresis, dead_abovedot ] }; // i I ¨ ˙ + key { [ e, E, EuroSign, dead_currency ] }; // e E € ¤ + key { [ comma, semicolon, rightsinglequotemark, dead_horn] }; // , ; ’ ̛ + key { [ c, C, copyright, U017F ] }; // c C © ſ + key { [ t, T, thorn, THORN ] }; // t T þ Þ + key { [ s, S, ssharp, U1E9E ] }; // s S ß ẞ + key { [ r, R, registered, trademark ] }; // r R ® ™ + key { [ n, N, dead_tilde ] }; // n N ˜ + key { [ m, M, dead_macron, masculine ] }; // m M ¯ º + key { [ ccedilla, Ccedilla, dead_cedilla, dead_belowcomma ]}; // ç Ç ¸ , + + // Fourth row + key { [ ecircumflex, Ecircumflex, slash ] }; // ê Ê / + key { [ agrave, Agrave, backslash ] }; // à À \ + key { [ y, Y, braceleft, leftsinglequotemark ] }; // y Y { ‘ + key { [ x, X, braceright, rightsinglequotemark ] }; // x X } ’ + key { [ period, colon, ellipsis, periodcentered ] }; // . : … · + key { [ k, K, asciitilde ] }; // k K ~ + key { [ apostrophe, question, questiondown, dead_hook ] }; // ' ? ¿ ̉ + key { [ q, Q, dead_abovering, dead_belowdot ] }; // q Q ˚ ̣ + key { [ g, G, dead_greek ] }; // g G µ + key { [ h, H, dagger, doubledagger ] }; // h H † ‡ + key { [ f, F, dead_ogonek, ordfeminine ] }; // f F ˛ ª + + key { [ space, nobreakspace, underscore, U202F ] }; // ␣ (espace insécable) _ (espace insécable fin) +}; + +partial alphanumeric_keys +xkb_symbols "bepo_latin9" { + + // Restricts the Bépo layout to latin9 symbols. + + include "fr(bepo)" + include "keypad(oss_latin9)" + + name[Group1]="French (BEPO, Latin-9 only)"; + + key { [ dollar, numbersign, dollar, paragraph ] }; // $ # $ ¶ + + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ quotedbl, 1 ] }; // " 1 + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ guillemotleft, 2, less ] }; // « 2 < + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ guillemotright, 3, greater ] }; // » 3 > + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ parenleft, 4, bracketleft ] }; // ( 4 [ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ parenright, 5, bracketright ] }; // ) 5 ] + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ minus, 8, minus, onequarter ] }; // - 8 - ¼ + key { [ equal, degree ] }; // = ° + key { [ percent, grave ] }; // % ` + + key { [ b, B, bar ] }; // b B | + key { [ eacute, Eacute, dead_acute ] }; // é É ˊ + key { [ j, J ] }; // j J + key { [ z, Z ] }; // z Z + key { [ w, W ] }; // w W + + key { [ i, I, dead_diaeresis ] }; // i I ¨ + key { [ comma, semicolon, comma, dead_horn ] }; // , ; , ̛ + key { [ c, C, copyright ] }; // c C © + key { [ s, S, ssharp, U1E9E ] }; // s S ß ẞ + key { [ r, R, registered ] }; // r R ® + key { [ m, M, macron, masculine ] }; // m M ¯ º + + key { [ y, Y, braceleft ] }; // y Y { + key { [ x, X, braceright ] }; // x X } + key { [ period, colon ] }; // . : + key { [ h, H ] }; // h H + key { [ f, F, f, ordfeminine ] }; // f F ª + + key { [ space, nobreakspace, underscore, nobreakspace ] }; // ␣ (espace insécable) _ (espace insécable) +}; + +// Version 1.1rc2 of the Bépo keyboard layout, +// normalized by the AFNOR NF Z71‐300 norm. +// +// Layout: https://bepo.fr/wiki/Version_1.1rc2 +// Normalization: https://normalisation.afnor.org/actualites/faq-clavier-francais/ +// +// ┌────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────┬────╔═════════╗ +// │ # ¶│ 1 „│ 2 “│ 3 ”│ 4 ⩽│ 5 ⩾║ 6 │ 7 ¬│ 8 ¼│ 9 ½│ 0 ¾│ ° ′│ ` ″║ ║ +// │ $ –│ " —│ « <│ » >│ ( [│ ) ]║ @ ^│ + ±│ - −│ / ÷│ * ×│ = ≠│ % ‰║ <-- ║ +// ╔════╧══╗─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─┴──┬─╚══╦══════╣ +// ║ |<- ║ B _│ É │ P §│ O Œ│ È `║ ! │ V │ D │ L £│ J │ Z │ W ║ | ║ +// ║ ->| ║ b |│ é ´│ p &│ o œ│ è `║ ˆ ¡│ v ˇ│ d ∞│ l /│ j │ z ―│ w ║ <-' ║ +// ╠═══════╩╗───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───┴┬───╚╗ ║ +// ║ ║ A Æ│ U Ù│ I ˙│ E ¤│ ; ,║ C ©│ T ™│ S ſ│ R ®│ N │ M │ Ç ©║ ║ +// ║ CAPS ║ a æ│ u ù│ i ¨│ e €│ , '║ c ¸│ t ᵉ│ s ß│ r ˘│ n ~│ m ¯│ ç ║ ║ +// ╠══════╦═╝──┬─┴──┬─┴──┬─┴─══─┴──┬─┴──┬─┴─══─┴──┬─┴──┬─┴──┬─┴──╔═╧════╩═════╣ +// ║ ^ ║ Ê ^│ À ‚│ Y ‘│ X ’│ : ·│ K ‑║ ? ̉│ Q ̛│ G †│ H ‡│ F ║ ^ ║ +// ║ | ║ ê /│ à \│ y {│ x }│ . …│ k ~║ ’ ¿│ q °│ g µ│ h ̣ │ f ˛║ | ║ +// ╠══════╩╦═══╧══╦═╧═══╦╧════╧════╧════╧════╧════╧═╦══╧══╦═╧════╬═════╦══════╣ +// ║ ║ ║ ║ Fine insécable Insécable ║ ║ ║ ║ ║ +// ║ Ctrl ║ WinG ║ Alt ║ Espace _ ║AltGr║ WinD ║WinM ║ Ctrl ║ +// ╚═══════╩══════╩═════╩═══════════════════════════╩═════╩══════╩═════╩══════╝ +partial alphanumeric_keys +xkb_symbols "bepo_afnor" { + + name[Group1]= "French (BEPO, AFNOR)"; + + key { type[group1] = "FOUR_LEVEL", [ dollar, numbersign, endash, paragraph ] }; // $ # – ¶ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ quotedbl, 1, emdash, doublelowquotemark ] }; // " 1 — „ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ guillemotleft, 2, less, leftdoublequotemark ] }; // « 2 < “ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ guillemotright, 3, greater, rightdoublequotemark ] }; // » 3 > ” + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ parenleft, 4, bracketleft, U2A7D ] }; // ( 4 [ ⩽ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ parenright, 5, bracketright, U2A7E ] }; // ) 5 ] ⩾ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ at, 6, asciicircum, U262D ] }; // @ 6 ^ ☭ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ plus, 7, plusminus, notsign ] }; // + 7 ± ¬ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ minus, 8, U2212, onequarter ] }; // - 8 − ¼ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ slash, 9, division, onehalf ] }; // / 9 ÷ ½ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ asterisk, 0, multiply, threequarters ] }; // * 0 × ¾ + key { type[group1] = "FOUR_LEVEL", [ equal, degree, notequal, minutes ] }; // = ° ≠ ′ + key { type[group1] = "FOUR_LEVEL", [ percent, grave, permille, seconds ] }; // % ` ‰ ″ + + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ b, B, bar, underscore ] }; // b B | _ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ eacute, Eacute, dead_acute, heart ] }; // é É ´ ♥ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ p, P, ampersand, section ] }; // p P & § + key { type[group1] = "FOUR_LEVEL_ALPHABETIC", [ o, O, oe, OE ] }; // o O œ Œ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ egrave, Egrave, dead_grave, grave ] }; // è È ` ` + key { type[group1] = "FOUR_LEVEL", [ dead_circumflex, exclam, exclamdown, U2620 ] }; // ^ ! ¡ ☠ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ v, V, dead_caron, U2622 ] }; // v V ˇ ☢ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ d, D, UFDD7, U2623 ] }; // d D ∞ ☣ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ l, L, dead_stroke, sterling ] }; // l L / £ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ j, J, U262E, U262F ] }; // j J ☮ ☯ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ z, Z, UFDD8, U2619 ] }; // z Z ― ☙ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ w, W, U269C, U267F ] }; // w W ⚜ ♿ + + key { type[group1] = "FOUR_LEVEL_ALPHABETIC", [ a, A, ae, AE ] }; // a A æ Æ + key { type[group1] = "FOUR_LEVEL_ALPHABETIC", [ u, U, ugrave, Ugrave ] }; // u U ù Ù + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ i, I, dead_diaeresis, dead_abovedot ] }; // i I ¨ ˙ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ e, E, EuroSign, dead_currency ] }; // e E € ¤ + key { type[group1] = "FOUR_LEVEL", [ comma, semicolon, apostrophe, dead_belowcomma ] }; // , ; ' , + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ c, C, dead_cedilla, copyright ] }; // c C ¸ © + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ t, T, UFDD5, trademark ] }; // t T ᵉ ™ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ s, S, UFDD4, U017F ] }; // s S ß ſ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ r, R, dead_breve, registered ] }; // r R ˘ ® + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ n, N, dead_tilde, U2693 ] }; // n N ~ ⚓ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ m, M, dead_macron, U26FD ] }; // m M ¯ ⛽ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ ccedilla, Ccedilla, U2708, U1F12F ] }; // ç Ç ✈ 🄯 + + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ ecircumflex, Ecircumflex, slash, asciicircum ] }; // ê Ê / ^ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ agrave, Agrave, backslash, singlelowquotemark ] }; // à À \ ‚ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ y, Y, braceleft, leftsinglequotemark ] }; // y Y { ‘ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ x, X, braceright, rightsinglequotemark ] }; // x X } ’ + key { type[group1] = "FOUR_LEVEL", [ period, colon, ellipsis, periodcentered ] }; // . : … · + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ k, K, asciitilde, U2011 ] }; // k K ~ ‑ + key { type[group1] = "FOUR_LEVEL", [ rightsinglequotemark, question, questiondown, dead_hook ] }; // ’ ? ¿ ̉ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ q, Q, dead_abovering, dead_horn ] }; // q Q ˚ ̛ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ g, G, dead_greek, dagger ] }; // g G µ † + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ h, H, dead_belowdot, doubledagger ] }; // h H ̣ ‡ + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ f, F, dead_ogonek, U26C4 ] }; // f F ˛ ⛄ + key { type[group1] = "FOUR_LEVEL", [ space, U202F, underscore, nobreakspace ] }; //   _   + + include "level3(ralt_switch)" +}; + +// Ergo‑L +// +// Project page: https://ergol.org +// Author: NuclearSquid (huge thanks to Fabien Cazenave and the “Ergonauts”) +// Version: 1.0.0 +// +// In the following figures, a `*` preceding another character denotes a dead key. +// +// Base layer + Typography (dead key ★, implemented via ISO_Level5_Latch) +// ╭╌╌╌╌╌┰─────┬─────┬─────┬─────┬─────┰─────┬─────┬─────┬─────┬─────┰╌╌╌╌╌┬╌╌╌╌╌╮ +// ┆ ~ ┃ € ‚ │ « ‘ │ » ’ │ $ │ % ┃ ^ │ & │ * │ # │ @ ┃ _ – ┆ + ± ┆ +// ┆ ` ┃ 1 „ │ 2 “ │ 3 ” │ 4 ¢ │ 5 ‰ ┃ 6 │ 7 │ 8 § │ 9 ¶ │ 0 ° ┃ / ÷ ┆ = ≠ ┆ +// ╰╌╌╌╌╌╂─────┼─────┼─────┼─────┼─────╂─────┼─────┼─────┼─────┼─────╂╌╌╌╌╌┼╌╌╌╌╌┤ +// ┃ Q │ C │ O │ P │ W ┃ J │ M │ D _ │ ! ¡ │ Y ┃ { ┆ } ┆ +// ┃ â │ ç │ œ │ ô │ ┃ │ µ │ _ │*★*¨ │ û ┃ [ ┆ ] ┆ +// ┠─────┼─────┼─────┼─────┼─────╂─────┼─────┼─────┼─────┼─────╂╌╌╌╌╌┼╌╌╌╌╌┤ +// ┃ A │ S │ E │ N │ F ┃ L │ R │ T │ I │ U ┃ " ┆ | ┆ +// ┃ à │ é │ è │ ê │ ñ ┃ ( │ ) │ î │ ï │ ù ┃ ' ┆ \ ┆ +// ╭╌╌╌╌╌╂─────┼─────┼─────┼─────┼─────╂─────┼─────┼─────┼─────┼─────╂╌╌╌╌╌┴╌╌╌╌╌╯ +// ┆ > ┃ Z │ X │ ? ¿ │ V │ B ┃ : │ H │ G │ ; • │ K ┃ +// ┆ < ┃ æ │ ß │ - ‑ │ – │ — ┃ . … │ │ *µ │ , · │ ┃ +// ╰╌╌╌╌╌┸─────┴─────┴─────┴─────┴─────┸─────┴─────┴─────┴─────┴─────┚ +// +// Symbols layer (AltGr) +// ╭╌╌╌╌╌┰─────┬─────┬─────┬─────┬─────┰─────┬─────┬─────┬─────┬─────┰╌╌╌╌╌┬╌╌╌╌╌╮ +// ┆ ┃ ¹ │ ² │ ³ │ ⁴ │ ⁵ ┃ ⁶ │ ⁷ │ ⁸ │ ⁹ │ ⁰ ┃ ┆ ┆ +// ┆ ┃ ₁ │ ₂ │ ₃ │ ₄ │ ₅ ┃ ₆ │ ₇ │ ₈ │ ₉ │ ₀ ┃ ┆ ┆ +// ╰╌╌╌╌╌╂─────┼─────┼─────┼─────┼─────╂─────┼─────┼─────┼─────┼─────╂╌╌╌╌╌┼╌╌╌╌╌┤ +// ┃ *^ │ │ │ *¤ │ ‰ ┃ *˚ │ │ × │ *´ │ *` ┃ ┆ ┆ +// ┃ ^ │ < │ > │ $ │ % ┃ @ │ & │ * │ ' │ ` ┃ ┆ ┆ +// ┠─────┼─────┼─────┼─────┼─────╂─────┼─────┼─────┼─────┼─────╂╌╌╌╌╌┼╌╌╌╌╌┤ +// ┃ *ˇ │ │ │ *˙ │ ≠ ┃ */ │ ± │ *¯ │ ÷ │ *” ┃ ┆ ┆ +// ┃ { │ ( │ ) │ } │ = ┃ \ │ + │ - │ / │ " ┃ ┆ ┆ +// ╭╌╌╌╌╌╂─────┼─────┼─────┼─────┼─────╂─────┼─────┼─────┼─────┼─────╂╌╌╌╌╌┴╌╌╌╌╌╯ +// ┆ ┃ *~ │ *, │ *˛ │ – │ ┃ │ ¬ │ *¸ │ : │ *˘ ┃ +// ┆ ┃ ~ │ [ │ ] │ _ │ # ┃ | │ ! │ ; │ : │ ? ┃ +// ╰╌╌╌╌╌┸─────┴─────┴─────┴─────┴─────┸─────┴─────┴─────┴─────┴─────┚ + +partial alphanumeric_keys modifier_keys +xkb_symbols "ergol" { + + name[group1]= "French (Ergo‑L)"; + + key.type[group1] = "EIGHT_LEVEL"; + + // Digits + key {[ 1 , EuroSign , U2081 , onesuperior , U201E , U201A ]}; // 1 € ₁ ¹ „ ‚ + key {[ 2 , guillemotleft , U2082 , twosuperior , U201C , U2018 ]}; // 2 « ₂ ² “ ‘ + key {[ 3 , guillemotright , U2083 , threesuperior , U201D , U2019 ]}; // 3 » ₃ ³ ” ’ + key {[ 4 , dollar , U2084 , U2074 , cent , VoidSymbol ]}; // 4 $ ₄ ⁴ ¢ + key {[ 5 , percent , U2085 , U2075 , U2030 , VoidSymbol ]}; // 5 % ₅ ⁵ ‰ + key {[ 6 , asciicircum , U2086 , U2076 , VoidSymbol , VoidSymbol ]}; // 6 ^ ₆ ⁶ + key {[ 7 , ampersand , U2087 , U2077 , VoidSymbol , VoidSymbol ]}; // 7 & ₇ ⁷ + key {[ 8 , asterisk , U2088 , U2078 , section , VoidSymbol ]}; // 8 * ₈ ⁸ § + key {[ 9 , numbersign , U2089 , U2079 , paragraph , VoidSymbol ]}; // 9 # ₉ ⁹ ¶ + key {[ 0 , at , U2080 , U2070 , degree , VoidSymbol ]}; // 0 @ ₀ ⁰ ° + + // Letters, first row + key {[ q , Q , asciicircum , dead_circumflex , acircumflex , Acircumflex ]}; // q Q ^ ^ â  + key {[ c , C , less , lessthanequal , ccedilla , Ccedilla ]}; // c C < ≤ ç Ç + key {[ o , O , greater , greaterthanequal, oe , OE ]}; // o O > ≥ œ Œ + key {[ p , P , dollar , dead_currency , ocircumflex , Ocircumflex ]}; // p P $ ¤ ô Ô + key {[ w , W , percent , U2030 , VoidSymbol , VoidSymbol ]}; // w W % ‰ + key {[ j , J , at , dead_abovering , VoidSymbol , VoidSymbol ]}; // j J @ ˚ + key {[ m , M , ampersand , VoidSymbol , mu , VoidSymbol ]}; // m M & µ + key {[ d , D , asterisk , multiply , underscore , underscore ]}; // d D * × _ _ + key {[ ISO_Level5_Latch, exclam , apostrophe , dead_acute , dead_diaeresis , exclamdown ]}; // *¨ ! ' ´ ¨ ¡ + key {[ y , Y , grave , dead_grave , ucircumflex , Ucircumflex ]}; // y Y ` ` û Û + + // Letters, second row + key {[ a , A , braceleft , dead_caron , agrave , Agrave ]}; // a A { ˇ à À + key {[ s , S , parenleft , VoidSymbol , eacute , Eacute ]}; // s S ( é É + key {[ e , E , parenright , VoidSymbol , egrave , Egrave ]}; // e E ) è È + key {[ n , N , braceright , dead_abovedot , ecircumflex , Ecircumflex ]}; // n N } ˙ ê Ê + key {[ f , F , equal , notequal , ntilde , Ntilde ]}; // f F = ≠ ñ Ñ + key {[ l , L , backslash , dead_stroke , parenleft , VoidSymbol ]}; // l L \ / ( + key {[ r , R , plus , plusminus , parenright , VoidSymbol ]}; // r R + ± ) + key {[ t , T , minus , dead_macron , icircumflex , Icircumflex ]}; // t T - ˉ î Î + key {[ i , I , slash , division , idiaeresis , Idiaeresis ]}; // i I / ÷ ï Ï + key {[ u , U , quotedbl , dead_doubleacute, ugrave , Ugrave ]}; // u U " ˝ ù Ù + + // Letters, third row + key {[ z , Z , asciitilde , dead_tilde , ae , AE ]}; // z Z ~ ~ æ Æ + key {[ x , X , bracketleft , dead_belowcomma , ssharp , U1E9E ]}; // x X [ , ß ẞ + key {[ minus , question , bracketright , dead_ogonek , U2011 , questiondown ]}; // - ? ] ˛ ‑ ¿ + key {[ v , V , underscore , endash , endash , VoidSymbol ]}; // v V _ – – + key {[ b , B , numbersign , VoidSymbol , emdash , VoidSymbol ]}; // b B # — + key {[ period , colon , bar , brokenbar , ellipsis , VoidSymbol ]}; // . : | ¦ … + key {[ h , H , exclam , notsign , VoidSymbol , VoidSymbol ]}; // h H ! ¬ + key {[ g , G , semicolon , dead_cedilla , dead_greek , VoidSymbol ]}; // g G ; ¸ µ + key {[ comma , semicolon , colon , colon , periodcentered , U2022 ]}; // , ; : : · • + key {[ k , K , question , dead_breve , VoidSymbol , VoidSymbol ]}; // k K ? ˘ + + // Pinky keys + key {[ slash , underscore , VoidSymbol , VoidSymbol , division , endash ]}; // / _ ÷ – + key {[ equal , plus , VoidSymbol , VoidSymbol , notequal , plusminus ]}; // = + ≠ ± + key {[ VoidSymbol , VoidSymbol , VoidSymbol , VoidSymbol , VoidSymbol , VoidSymbol ]}; // + key {[ bracketleft , braceleft , VoidSymbol , VoidSymbol , VoidSymbol , VoidSymbol ]}; // [ { + key {[ bracketright , braceright , VoidSymbol , VoidSymbol , VoidSymbol , VoidSymbol ]}; // ] } + key {[ apostrophe , quotedbl , VoidSymbol , VoidSymbol , VoidSymbol , VoidSymbol ]}; // ' " + key {[ VoidSymbol , VoidSymbol , VoidSymbol , VoidSymbol , VoidSymbol , VoidSymbol ]}; // + key {[ grave , asciitilde , VoidSymbol , VoidSymbol , VoidSymbol , VoidSymbol ]}; // ` ~ + key {[ backslash , bar , VoidSymbol , VoidSymbol , VoidSymbol , VoidSymbol ]}; // \ | + key {[ less , greater , VoidSymbol , VoidSymbol , VoidSymbol , VoidSymbol ]}; // < > + + // Space bar + key {[ space , U202F , space , nobreakspace , U2019 , U2019 ]}; //     ’ ’ + + include "level3(ralt_switch)" +}; + +// Ergo‑L (angle-mod / ISO variant) +// Same as regular Ergo‑L, but with a permutation on the lower left keys. +// before: LSGT | z | x | - | v +// after: z | x | - | v | Backspace + +partial alphanumeric_keys modifier_keys +xkb_symbols "ergol_iso" { + + include "fr(ergol)" + name[group1]= "French (Ergo‑L, ISO variant)"; + + key {[ x , X , bracketleft , dead_belowcomma , ssharp , U1E9E ]}; // x X [ , ß ẞ + key {[ minus , question , bracketright , dead_ogonek , U2011 , questiondown ]}; // - ? ] ˛ ‑ ¿ + key {[ v , V , underscore , endash , endash , VoidSymbol ]}; // v V _ – – + key {[ b , B , numbersign , VoidSymbol , emdash , VoidSymbol ]}; // b B # — + key {[ BackSpace , BackSpace , Delete , Delete , VoidSymbol , VoidSymbol ]}; // bsp bsp del del + key {[ z , Z , asciitilde , dead_tilde , ae , AE ]}; // z Z ~ ~ æ Æ +}; + +// Author : Francis Leboutte, http://www.algo.be/ergo/dvorak-fr.html +// thanks to Fabien Cazenave for his help +// Licence : X11 +// Version : 0.3 + +// Base layer + dead AltGr key (`): +// ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┲━━━━━━━━━━┓ +// │ * │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ + │ % ┃ ┃ +// │ _ │ = │ / ± │ - ¼ │ è ½ │ \ ¾ │ ^ │ ( │ ` ` │ ) │ " │ [ │ ] ┃ ⌫ ┃ +// ┢━━━━━┷━━┱──┴──┬──┴──┬──┴──┬──┴──┬──┴──┬──┴──┬──┴──┬──┴──┬──┴──┬──┴──┬──┴──┬──┺━━┳━━━━━━━┫ +// ┃ ┃ ? Æ │ < │ > │ G │ ! │ H │ V │ C Ç │ M │ K │ Z │ & ┃ ┃ +// ┃ ↹ ┃ : æ │ ' $ │ é É │ g € │ . ° │ h │ v │ c ç │ m µ │ k │ z │ ¨ ┃ ┃ +// ┣━━━━━━━━┻┱────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┺┓ ⏎ ┃ +// ┃ ┃ O Ò │ A À │ U Ù │ E È │ B │ F │ S │ T │ N │ D │ W │ # ┃ ┃ +// ┃ ⇬ ┃ o ò │ a à │ u ù │ e è │ b │ f │ s « │ t │ n » │ d │ w │ ~ ┃ ┃ +// ┣━━━━━━┳━━┹──┬──┴──┬──┴──┬──┴──┬──┴──┬──┴──┬──┴──┬──┴──┬──┴──┬──┴──┬──┴──┲━━┷━━━━━┻━━━━━━┫ +// ┃ ┃ ç Ç │ | Œ │ Q │ @ │ I Ì │ Y │ X │ R │ L │ P │ J ┃ ┃ +// ┃ ⇧ ┃ à À │ ; œ │ q { │ , } │ i ì │ y £ │ x │ r º │ l │ p § │ j ┃ ⇧ ┃ +// ┣━━━━━━┻┳━━━━┷━━┳━━┷━━━━┱┴─────┴─────┴─────┴─────┴─────┴─┲━━━┷━━━┳━┷━━━━━╋━━━━━━━┳━━━━━━━┫ +// ┃ ┃ ┃ ┃ ␣ ⍽ ┃ ┃ ┃ ┃ ┃ +// ┃ ctrl ┃ super ┃ alt ┃ ␣ Espace Espace insécable ⍽ ┃ alt ┃ super ┃ menu ┃ ctrl ┃ +// ┗━━━━━━━┻━━━━━━━┻━━━━━━━┹────────────────────────────────┺━━━━━━━┻━━━━━━━┻━━━━━━━┻━━━━━━━┛ + +// Notice the specific Caps_Lock layer: +// ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┲━━━━━━━━━━┓ +// │ * │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ 0 │ + │ % ┃ ┃ +// │ │ │ │ │ │ │ │ │ │ │ │ │ ┃ ⌫ ┃ +// ┢━━━━━┷━━┱──┴──┬──┴──┬──┴──┬──┴──┬──┴──┬──┴──┬──┴──┬──┴──┬──┴──┬──┴──┬──┴──┬──┺━━┳━━━━━━━┫ +// ┃ ┃ │ < │ > │ │ │ │ │ │ │ │ │ ┃ ┃ +// ┃ ↹ ┃ │ │ │ │ │ │ │ │ │ │ │ ┃ ┃ +// ┣━━━━━━━━┻┱────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┺┓ ⏎ ┃ +// ┃ ┃ │ │ │ │ │ │ │ │ │ │ │ ┃ ┃ +// ┃ ⇬ ┃ │ │ │ │ │ │ │ │ │ │ │ ┃ ┃ +// ┣━━━━━━┳━━┹──┬──┴──┬──┴──┬──┴──┬──┴──┬──┴──┬──┴──┬──┴──┬──┴──┬──┴──┬──┴──┲━━┷━━━━━┻━━━━━━┫ +// ┃ ┃ / │ - │ │ │ │ │ │ │ │ │ ┃ ┃ +// ┃ ⇧ ┃ │ │ │ │ │ │ │ │ │ │ ┃ ⇧ ┃ +// ┣━━━━━━┻┳━━━━┷━━┳━━┷━━━━┱┴─────┴─────┴─────┴─────┴─────┴─┲━━━┷━━━┳━┷━━━━━╋━━━━━━━┳━━━━━━━┫ +// ┃ ┃ ┃ ┃ ␣ ⍽ ┃ ┃ ┃ ┃ ┃ +// ┃ ctrl ┃ super ┃ alt ┃ ␣ Espace Espace insécable ⍽ ┃ alt ┃ super ┃ menu ┃ ctrl ┃ +// ┗━━━━━━━┻━━━━━━━┻━━━━━━━┹────────────────────────────────┺━━━━━━━┻━━━━━━━┻━━━━━━━┻━━━━━━━┛ + +partial alphanumeric_keys modifier_keys +xkb_symbols "dvorak" { + name[Group1]="French (Dvorak)"; + + // First row + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ underscore, asterisk ] }; + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ equal, 1 ] }; + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ slash, 2, plusminus ] }; + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ minus, 3, onequarter ] }; + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ egrave, 4, onehalf ] }; + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ backslash, 5, threequarters ] }; + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ dead_circumflex, 6 ] }; + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ parenleft, 7 ] }; + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ ISO_Level3_Latch, 8, grave ] }; + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ parenright, 9 ] }; + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ quotedbl, 0 ] }; + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ bracketleft, plus ] }; + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ bracketright, percent ] }; + + // Second row + key { [ colon, question, ae, AE ] }; + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ apostrophe, less, dollar ] }; + key { type[group1] = "FOUR_LEVEL_SEMIALPHABETIC", [ eacute, greater, Eacute ] }; + key { [ g, G, EuroSign ] }; + key { [ period, exclam, degree ] }; + key { [ h, H ] }; + key { [ v, V ] }; + key { [ c, C, ccedilla, Ccedilla ] }; + key { [ m, M, mu ] }; + key { [ k, K ] }; + key { [ z, Z ] }; + key { [ dead_diaeresis, ampersand ] }; + + // Third row + key { [ o, O, ograve, Ograve ] }; + key { [ a, A, agrave, Agrave ] }; + key { [ u, U, ugrave, Ugrave ] }; + key { [ e, E, egrave, Egrave ] }; + key { [ b, B ] }; + key { [ f, F ] }; + key { [ s, S, guillemotleft ] }; + key { [ t, T ] }; + key { [ n, N, guillemotright ] }; + key { [ d, D ] }; + key { [ w, W ] }; + key { [ asciitilde, numbersign ] }; + + // Fourth row + key { type[group1] = "FOUR_LEVEL_PLUS_LOCK", [ agrave, ccedilla, Agrave, Ccedilla, slash ] }; + key { type[group1] = "FOUR_LEVEL_PLUS_LOCK", [ semicolon, bar, oe, OE, minus ] }; + key { [ q, Q, braceleft ] }; + key { [ comma, at, braceright ] }; + key { [ i, I, igrave, Igrave ] }; + key { [ y, Y, sterling ] }; + key { [ x, X ] }; + key { [ r, R, masculine ] }; + key { [ l, L ] }; + key { [ p, P, section ] }; + key { [ j, J ] }; + + key { [ space, space, nobreakspace, nobreakspace ] }; +}; + +// C’HWERTY: Breton keyboard. Ar c’hlavier brezhoneg. +// Copyright © 2009 Dominique Pellé +// Version: 0.2 +// +// ┌─────┐ +// │ S A │ S = Reol = Shift, A = ArErl + Pennlizherenn = AltGr + Shift +// │ s a │ s = normal, a = ArErl = AltGr +// └─────┘ +// +// ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┲━━━━━━━━━┓ +// │ ~ Γ │ 1 Δ │ 2 Θ │ 3 Λ │ 4 Ξ │ 5 Π │ 6 Σ │ 7 Φ │ 8 Ψ │ 9 Ç │ 0 Ω │ ° ß │ + ¬ ┃ ⌫ Souzañ┃ +// │ ² ˙ │ & ¯ │ é ´ │ " # │ ' { │ ( [ │ - | │ è ` │ - \ │ ç ± │ à @ │ ) ] │ = } ┃ ┃ +// ┢━━━━━┷━┱───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┺━┳━━━━━━━┫ +// ┃Toalenn┃C’h Α│ W Ω │ E ε │ R Ρ │ T Τ │ Y Ψ │ U Υ │ I ι │ O Œ│ P Π │ ¨ ¥ │ * £ ┃Enankañ┃ +// ┃ ↹ ┃c’h α│ w ω │ e € │ r ρ │ t τ │ y ψ │ u υ │ i ı │ o œ│ p π │ ^ « │ / » ┃ ⏎ ┃ +// ┣━━━━━━━┻┱────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┺┓ ┃ +// ┃Prenn ┃ A Æ │ S Σ │ D δ │ F Φ │ G Γ │ H Η │ J ς │ K κ │ L Λ │ M Μ │ Ù ® │ ! ¡ ┃ ┃ +// ┃Pennli ⇬┃ a æ │ s σ │ d $ │ f φ │ g γ │ h η │ j ς │ k Κ │ l λ │ m μ │ ù ŭ │ ? ¿ ┃ ┃ +// ┣━━━━━━━┳┹────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┲┷━━━━━┻━━━━━━┫ +// ┃ ┃ Q θ │ Z ζ │ X Ξ │ C ς │ V Ο │ B Β │ N Ν │CH Χ │ Ñ ~ │ : © │ ; ‰ ┃ ┃ +// ┃Shift ⇧┃ q < │ z > │ x ξ │ c ¢ │ v ο │ b β │ n ν │ch χ │ ñ ~ │ . § │ , % ┃Shift ⇧ ┃ +// ┣━━━━━━━╋━━━━━┷━┳━━━┷━━━┱─┴─────┴─────┴─────┴─────┴─────┴───┲━┷━━━━━╈━━━━━┻━┳━━━━━━━┳━━━┛ +// ┃ ┃ ┃ ┃ ⍽ Espace insécable ␣ ┃ ┃ ┃ ┃ +// ┃Reol ┃Meta ┃Erl ┃ ␣ Espace ␣ ┃ArErl ⇮┃Menu ┃Reol ┃ +// ┗━━━━━━━┻━━━━━━━┻━━━━━━━┹───────────────────────────────────┺━━━━━━━┻━━━━━━━┻━━━━━━━┛ +partial alphanumeric_keys +xkb_symbols "bre" { + + include "keypad(oss)" + + name[Group1]= "Breton (France)"; + + // First row + key { [ twosuperior, dead_tilde, dead_abovedot, Greek_GAMMA ] }; + key { [ ampersand, 1, dead_macron, Greek_DELTA ] }; + key { [ eacute, 2, dead_acute, Greek_THETA ] }; + key { [ quotedbl, 3, numbersign, Greek_LAMDA ] }; + key { [ apostrophe, 4, braceleft, Greek_XI ] }; + key { [ parenleft, 5, bracketleft, Greek_PI ] }; + key { [ minus, 6, bar, Greek_SIGMA ] }; + key { [ egrave, 7, dead_grave, Greek_PHI ] }; + key { [ underscore, 8, backslash, Greek_PSI ] }; + key { [ ccedilla, 9, plusminus, Ccedilla ] }; + key { [ agrave, 0, at, Greek_OMEGA ] }; + key { [ parenright, dead_abovering, bracketright, ssharp ] }; + key { [ equal, plus, braceright, notsign ] }; + + // Second row + // Handling the C’H key correctly requires an input method. + key { [ c_h, C_h, Greek_alpha, Greek_ALPHA, C_H ], type[group1]="FOUR_LEVEL_PLUS_LOCK" }; + key { [ w, W, Greek_omega, Greek_OMEGA ] }; + key { [ e, E, EuroSign, Greek_epsilon ] }; + key { [ r, R, Greek_rho, Greek_RHO ] }; + key { [ t, T, Greek_tau, Greek_TAU ] }; + key { [ y, Y, Greek_psi, Greek_PSI ] }; + key { [ u, U, Greek_upsilon, Greek_UPSILON ] }; + key { [ i, I, idotless, Greek_iota ] }; + key { [ o, O, oe, OE ] }; + key { [ p, P, Greek_pi, Greek_PI ] }; + key { [ dead_circumflex, dead_diaeresis, guillemotleft, yen ] }; + key { [ slash, asterisk, guillemotright, sterling ] }; + + // Third row + key { [ a, A, ae, AE ] }; + key { [ s, S, Greek_sigma, Greek_SIGMA ] }; + key { [ d, D, dollar, Greek_delta ] }; + key { [ f, F, Greek_phi, Greek_PHI ] }; + key { [ g, G, Greek_gamma, Greek_GAMMA ] }; + key { [ h, H, Greek_eta, Greek_ETA ] }; + key { [ j, J, Greek_finalsmallsigma, Greek_finalsmallsigma ] }; + key { [ k, K, Greek_kappa, Greek_KAPPA ] }; + key { [ l, L, Greek_lamda, Greek_LAMBDA ] }; + key { [ m, M, Greek_mu, Greek_MU ] }; + key { [ ugrave, Ugrave, ubreve, registered ] }; + key { [ question, exclam, questiondown, exclamdown ] }; + + // Fourth row + key { [ q, Q, less, Greek_theta ] }; + key { [ z, Z, greater, Greek_zeta ] }; + key { [ x, X, Greek_xi, Greek_XI ] }; + key { [ c, C, cent, Greek_finalsmallsigma ] }; + key { [ v, V, Greek_omicron, Greek_OMICRON ] }; + key { [ b, B, Greek_beta, Greek_BETA ] }; + key { [ n, N, Greek_nu, Greek_NU ] }; + // Handling the CH key correctly requires an input method. + key { [ ch, Ch, Greek_chi, Greek_CHI, CH ], type[group1]="FOUR_LEVEL_PLUS_LOCK" }; + key { [ ntilde, Ntilde, asciitilde, dead_tilde ] }; + key { [ period, colon, section, copyright ] }; + key { [ comma, semicolon, percent, permille ] }; + + key { [ space, nobreakspace, space, nobreakspace ] }; + + include "level3(ralt_switch)" +}; + +// Occitan layout +// Author : 2009 Thomas Metz +// Derived from the layout defined at http://www.panoccitan.org +// Version: 0.1 +// Differences from OSS French keyboard : +// - add á, í, ò, ó et ú, Á, Í, Ò, Ó, Ú, ñ, Ñ +// - change position of æ, ü, î, û, œ, ô, ö, ï, â, ë +// +// ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┲━━━━━━━━━┓ +// │ ³ ¸ │ 1 ̨ │ 2 É │ 3 ˘ │ 4 — │ 5 – │ 6 ‑ │ 7 È │ 8 ™ │ 9 Ç │ 0 À │ ° ≠ │ + ± ┃ ⌫ Retour┃ +// │ ² ¹ │ & ˇ │ é ~ │ " # │ ' { │ ( [ │ - | │ è ` │ _ \ │ ç ^ │ à @ │ ) ] │ = } ┃ arrière┃ +// ┢━━━━━┷━┱───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┺━┳━━━━━━━┫ +// ┃ ┃ A Á │ Z Æ │ E ¢ │ R Ê │ T Ë │ Y Û │ U Ú │ I Í │ O Ó │ P Ò │ ¨ Œ │ £ Ø ┃Entrée ┃ +// ┃Tab ↹ ┃ a á │ z æ │ e € │ r ê │ t ë │ y û │ u ú │ i í │ o ó │ p ò │ ^ œ │ $ ø ┃ ⏎ ┃ +// ┣━━━━━━━┻┱────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┺┓ ┃ +// ┃ ┃ Q Ä │ S „ │ D  │ F ‚ │ G ¥ │ H Ü │ J Î │ K Ï │ L Ô │ M Ö │ % Ù │ µ ̄ ┃ ┃ +// ┃Maj ⇬ ┃ q ä │ s ß │ d â │ f ‘ │ g ’ │ h ü │ j î │ k ï │ l ô │ m ö │ ù ' │ * ` ┃ ┃ +// ┣━━━━━━━┳┹────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┲┷━━━━━┻━━━━━━┫ +// ┃ ┃ > ≥ │ W “ │ X ” │ C ® │ V ← │ B ↑ │ N Ñ │ ? … │ . . │ / ∕ │ § − ┃ ┃ +// ┃Shift ⇧┃ < ≤ │ w « │ x » │ c © │ v → │ b ↓ │ n ñ │ , ¿ │ ; × │ : ÷ │ ! ¡ ┃Shift ⇧ ┃ +// ┣━━━━━━━╋━━━━━┷━┳━━━┷━━━┱─┴─────┴─────┴─────┴─────┴─────┴───┲━┷━━━━━╈━━━━━┻━┳━━━━━━━┳━━━┛ +// ┃ ┃ ┃ ┃ ␣ Espace fine insécable ⍽ ┃ ┃ ┃ ┃ +// ┃Ctrl ┃Meta ┃Alt ┃ ␣ Espace Espace insécable ⍽ ┃AltGr ⇮┃Menu ┃Ctrl ┃ +// ┗━━━━━━━┻━━━━━━━┻━━━━━━━┹───────────────────────────────────┺━━━━━━━┻━━━━━━━┻━━━━━━━┛ +partial alphanumeric_keys +xkb_symbols "oci" { + + include "fr(oss)" + + name[Group1]= "Occitan"; + + key {[ a, A, aacute, Aacute ]}; // a A á Á + key {[ z, Z, ae, AE ]}; // z Z æ Æ + key {[ t, T, ediaeresis, Ediaeresis ]}; // t T ë Ë + key {[ y, Y, ucircumflex, Ucircumflex ]}; // y Y û Û + key {[ u, U, uacute, Uacute ]}; // u U ú Ú + key {[ i, I, iacute, Iacute ]}; // i I í Í + key {[ o, O, oacute, Oacute ]}; // o O ó Ó + key {[ p, P, ograve, Ograve ]}; // p P ò Ò + key {[ dead_circumflex, dead_diaeresis, oe, OE ]}; // ^ ̈ œ Œ + + key {[ d, D, acircumflex, Acircumflex ]}; // d D â  + key {[ h, H, udiaeresis, Udiaeresis ]}; // h H ü Ü + key {[ j, J, icircumflex, Icircumflex ]}; // j J î Î + key {[ k, K, idiaeresis, Idiaeresis ]}; // k K ï Ï + key {[ l, L, ocircumflex, Ocircumflex ]}; // l L ô Ô + + key {[ v, V, rightarrow, leftarrow ]}; // v V → ← + key {[ n, N, ntilde, Ntilde ]}; // n N ñ Ñ +}; + +// Marc.Shapiro@inria.fr 19-sep-1998 +// modifications : Etienne Herlent june 2000 +// adapted to the new input layer : +// Martin Costabel 3-jan-2001 +// adapted for Latin9 alphabet (ISO-8859-15): +// Etienne Herlent march 2005 + +// This map is an almost-complete mapping of the standard French +// MacIntosh keyboard under Xwindows. I tried to remain as faithful +// as possible to the Mac meaning of each key. I did this entirely by +// hand and by intuition, relying on the Clavier (Keyboard?) Desktop +// Accessory for the Mac meaning of keys, and on reading keysymdef.h +// to intuit the corresponding X names. Lacking proper documentation, +// I may have made some mistakes. + +// Entries marked CHECK are particularly uncertain + +// Entries marked MISSING mark Mac characters for which I was unable +// to find a corresponding keysym. (Some for sure don't: e.g. the +// Apple mark and the oe/OE character; others I may have simply not +// found.) + +// Copied from macintosh_vndr/fr +partial alphanumeric_keys +xkb_symbols "mac" { + + name[Group1]= "French (Macintosh)"; + + key { [ at, numbersign, periodcentered, ydiaeresis ] }; + key { [ ampersand, 1, VoidSymbol, dead_acute ] }; // MISSING: Apple + key { [ eacute, 2, ediaeresis, Eacute ] }; + key { [ quotedbl, 3, leftdoublequotemark, rightdoublequotemark ]}; + key { [ apostrophe, 4, leftsinglequotemark, rightsinglequotemark ]}; + key { [ parenleft, 5, braceleft, bracketleft ] }; + key { [ section, 6, paragraph, aring ] }; + key { [ egrave, 7, guillemotleft, guillemotright ] }; + key { [ exclam, 8, exclamdown, Ucircumflex ] }; + key { [ ccedilla, 9, Ccedilla, Aacute ] }; + key { [ agrave, 0, oslash, Oslash ] }; + key { [ parenright, degree, braceright, bracketright ] }; + key { [ minus, underscore, emdash, endash ] }; + + key { [ a, A, ae, AE ] }; + key { [ z, Z, Acircumflex, Aring ] }; + key { [ e, E, ecircumflex, Ecircumflex ] }; + key { [ r, R, registered, currency ] }; + key { [ t, T, dagger, trademark ] }; + key { [ y, Y, Uacute, Ydiaeresis ] }; + key { [ u, U, masculine, ordfeminine ] }; + key { [ i, I, icircumflex, idiaeresis ] }; + key { [ o, O, oe, OE ] }; + key { [ p, P, Greek_pi, Greek_PI ] }; + key { [dead_circumflex,dead_diaeresis, ocircumflex, Ocircumflex ] }; + key { [ dollar, asterisk, EuroSign, yen ] }; + + key { [ q, Q, acircumflex, Agrave ] }; + key { [ s, S, Ograve, VoidSymbol ] }; + key { [ d, D, Greek_delta, Greek_DELTA ] }; + key { [ f, F, U0192, periodcentered ] }; // ƒ · + key { [ g, G, UFB01, UFB02 ] }; // fi fl + key { [ h, H, Igrave, Icircumflex ] }; + key { [ j, J, Idiaeresis, Iacute ] }; + key { [ k, K, Egrave, Ediaeresis ] }; + key { [ l, L, notsign, bar ] }; + key { [ m, M, mu, Oacute ] }; + key { [ ugrave,percent, Ugrave, ucircumflex ] }; // MISSING: per-mille + key { [ dead_grave, sterling, at, numbersign ] }; + + key { [ less, greater, lessthanequal, greaterthanequal ] }; + key { [ w, W, U2039, U203A ] }; // ‹ › + key { [ x, X, similarequal, U2044 ] }; // ≃ ⁄ + key { [ c, C, copyright, cent ] }; + key { [ v, V, diamond, radical ] }; // CHECK diamond + key { [ b, B, ssharp, integral ] }; + key { [ n, N, dead_tilde, asciitilde ] }; + key { [ comma, question, VoidSymbol, questiondown ] }; + key { [ semicolon, period, ellipsis, periodcentered ] }; + key { [ colon, slash, division, backslash ] }; + key { [ equal, plus, notequal, plusminus ] }; + + key { [ space, space, nobreakspace, nobreakspace ] }; + + key { [ comma,KP_Decimal ] }; + + include "level3(ralt_switch)" +}; + +partial alphanumeric_keys +xkb_symbols "geo" { + + include "ge(basic)" + + name[Group1]= "Georgian (France, AZERTY Tskapo)"; + + key {[ exclam, any ]}; + key {[ U201E, 1 ]}; + key {[ U2116, 2 ]}; + key {[ percent, 3 ]}; + key {[ parenleft, 4 ]}; + key {[ colon, 5 ]}; + key {[ semicolon, 6 ]}; + key {[ question, 7 ]}; + key {[ U2116, 8 ]}; + key {[ degree, 9 ]}; + key {[ parenright, 0 ]}; + key {[ minus, underscore, emdash ]}; + key {[ less, greater ]}; + + key {[ Georgian_an, U10FA ]}; + key {[ Georgian_zen, Z ]}; + key {[ Georgian_en, E, Georgian_he ]}; + key {[ Georgian_rae, registered ]}; + key {[ Georgian_tar, T ]}; + key {[ Georgian_qar, U10F8 ]}; + key {[ Georgian_un, U ]}; + key {[ Georgian_in, Georgian_hie ]}; + key {[ Georgian_on, O ]}; + key {[ Georgian_par, P ]}; + key {[ Georgian_tan, T ]}; + key {[ Georgian_jil, Z ]}; + + key {[ Georgian_khar, Q ]}; + key {[ Georgian_san, S ]}; + key {[ Georgian_don, D ]}; + key {[ Georgian_phar, Georgian_fi ]}; + key {[ Georgian_gan, U10F9 ]}; + key {[ Georgian_hae, Georgian_hoe ]}; + key {[ Georgian_jhan, U10F7 ]}; + key {[ Georgian_kan, K ]}; + key {[ Georgian_las, L ]}; + key {[ Georgian_man, M ]}; + key {[ Georgian_zhar, J ]}; + key {[ Georgian_chin, copyright ]}; + + key {[ guillemotleft, guillemotright ]}; + key {[ Georgian_cil, W ]}; + key {[ Georgian_xan, Georgian_har ]}; + key {[ Georgian_can, copyright ]}; + key {[ Georgian_vin, Georgian_we ]}; + key {[ Georgian_ban, B ]}; + key {[ Georgian_nar, U10FC ]}; + key {[ comma, U2014 ]}; + key {[ Georgian_shin, S ]}; + key {[ Georgian_ghan, any ]}; + key {[ Georgian_char, any ]}; +}; + +// US keyboard made French +// +// Copyright (C) 2018, Florent Gallaire +partial alphanumeric_keys +xkb_symbols "us" { + + include "us(basic)" + name[Group1]= "French (US)"; + + + key { [ grave, asciitilde, dead_grave ] }; + key { [ 4, dollar, EuroSign, currency ] }; // € ¤ + key { [ 6,asciicircum,dead_circumflex ] }; + + key { [ e, E, eacute, Eacute ] }; // é É + key { [ r, R, egrave, Egrave ] }; // è È + key { [ y, Y, ydiaeresis, Ydiaeresis ] }; // ÿ Ÿ + key { [ u, U, ugrave, Ugrave ] }; // ù Ù + key { [ i, I, idiaeresis, Idiaeresis ] }; // ï Ï + key { [ o, O, ocircumflex, Ocircumflex ] }; // ô Ô + key { [ p, P, oe, OE ] }; // œ Œ + key { [ bracketleft, braceleft, guillemotleft, leftdoublequotemark ] }; // « “ + key { [bracketright, braceright, guillemotright, rightdoublequotemark ] }; // » ” + + key { [ a, A, agrave, Agrave ] }; // à À + key { [ s, S, ae, AE ] }; // æ Æ + key { [ d, D, ecircumflex, Ecircumflex ] }; // ê Ê + key { [ f, F, ediaeresis, Ediaeresis ] }; // ë Ë + key { [ h, H, udiaeresis, Udiaeresis ] }; // ü Ü + key { [ j, J, ucircumflex, Ucircumflex ] }; // û Û + key { [ k, K, icircumflex, Icircumflex ] }; // î Î + key { [apostrophe, quotedbl,dead_diaeresis, degree ] }; + + key { [ z, Z, acircumflex, Acircumflex ] }; // â  + key { [ c, C, ccedilla, Ccedilla ] }; // ç Ç + + include "eurosign(5)" + include "level3(ralt_switch)" +}; + +// EXTRAS: + +partial alphanumeric_keys + xkb_symbols "sun_type6" { + include "sun_vndr/fr(sun_type6)" +}; + + +// Plain French Azerty layout. +// Original author: Mats Blakstad , 2015. +// Based on https://en.wikipedia.org/wiki/File:KB_France.svg. + +// ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ _______ +// | | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 0 | ° | + | <-- | +// | ² | & | é ~| " #| ' {| ( [| - || è `| _ \| ç ^| à @| ) ]| = }| | +// ======================================================================== +// | |<- | A | Z | E | R | T | Y | U | I | O | P | ¨ | $ | , | +// | ->| | a | z | e €| r | t | y | u | i | o | p | ^ | £ ¤| <-' | +// ===================================================================¬ | +// | | Q | S | D | F | G | H | J | K | L | M | % | µ | | +// | MAJ | q | s | d | f | g | h | j | k | l | m | ù | * | | +// ======================================================================== +// | ^ | > | W | X | C | V | B | N | ? | . | / | § | ^ | +// | | | < | w | x | c | v | b | n | , | ; | : | ! | | | +// ======================================================================== +// | | | | | | | | | +// | Ctrl | Super| Alt | Space Nobreakspace | AltGr | Super|Menu | Ctrl | +// ¯¯¯¯¯¯ ¯¯¯¯¯¯ ¯¯¯¯¯¯ ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ ¯¯¯¯¯¯¯ ¯¯¯¯¯¯ ¯¯¯¯¯ ¯¯¯¯¯¯ +partial alphanumeric_keys +xkb_symbols "azerty" { + + name[Group1]="French (AZERTY)"; + + key {[ twosuperior ]}; + key {[ ampersand, 1 ]}; + key {[ eacute, 2, asciitilde ]}; + key {[ quotedbl, 3, numbersign ]}; + key {[ apostrophe, 4, braceleft ]}; + key {[ parenleft, 5, bracketleft ]}; + key {[ minus, 6, bar ]}; + key {[ egrave, 7, grave ]}; + key {[ underscore, 8, backslash ]}; + key {[ ccedilla, 9, asciicircum ]}; + key {[ agrave, 0, at ]}; + key {[ parenright, degree, bracketright ]}; + key {[ equal, plus, braceright ]}; + + key {[ a, A ]}; + key {[ z, Z ]}; + key {[ e, E, EuroSign ]}; + key {[ r, R ]}; + key {[ t, T ]}; + key {[ y, Y ]}; + key {[ u, U ]}; + key {[ i, I ]}; + key {[ o, O ]}; + key {[ p, P ]}; + key {[ dead_circumflex,dead_diaeresis ]}; + key {[ dollar, sterling, currency ]}; + + key {[ q, Q ]}; + key {[ s, S ]}; + key {[ d, D ]}; + key {[ f, F ]}; + key {[ g, G ]}; + key {[ h, H ]}; + key {[ j, J ]}; + key {[ k, K ]}; + key {[ l, L ]}; + key {[ m, M ]}; + key {[ ugrave, percent ]}; + key {[ asterisk, mu ]}; + + key {[ less, greater ]}; + key {[ w, W ]}; + key {[ x, X ]}; + key {[ c, C ]}; + key {[ v, V ]}; + key {[ b, B ]}; + key {[ n, N ]}; + key {[ comma, question ]}; + key {[ semicolon, period ]}; + key {[ colon, slash ]}; + key {[ exclam, section ]}; + + include "level3(ralt_switch)" +}; + +// US keyboard made French (with dead keys, alternative) +// +// Copyright (C) 2018, Florent Gallaire + +partial alphanumeric_keys +xkb_symbols "us-alt" { + + include "us(basic)" + name[Group1]= "French (US with dead keys, alt.)"; + + key { [dead_grave, asciitilde, grave ] }; + key { [ 4, dollar, EuroSign, currency ] }; // € ¤ + key { [dead_circumflex, asciicircum, 6 ] }; + + key { [ e, E, eacute, Eacute ] }; // é É + key { [ o, O, oe, OE ] }; // œ Œ + key { [ bracketleft, braceleft, guillemotleft, leftdoublequotemark ] }; // « “ + key { [bracketright, braceright, guillemotright, rightdoublequotemark ] }; // » ” + + key { [ a, A, ae, AE ] }; // æ Æ + key { [dead_diaeresis, quotedbl, apostrophe ] }; + + key { [ c, C, ccedilla, Ccedilla ] }; // ç Ç + + include "eurosign(5)" + include "level3(ralt_switch)" +}; + +// For physically modified US keyboard (Q <-> A, W <-> Z and ; <-> M) +// +// Copyright (C) 2018, Florent Gallaire + +partial alphanumeric_keys +xkb_symbols "us-azerty" { + + include "us" + name[Group1]= "French (US, AZERTY)"; + + key { [ grave, asciitilde, dead_grave ] }; + key { [ 2, at, eacute, Eacute ] }; // é É + key { [ 4, dollar, currency ] }; // ¤ + key { [ 6,asciicircum,dead_circumflex ] }; + key { [ 7, ampersand, egrave, Egrave ] }; // è È + key { [ 9, parenleft, ccedilla, Ccedilla ] }; // ç Ç + key { [ 0, parenright, agrave, Agrave ] }; // à À + + key { [ a, A, ae, AE ] }; // æ Æ + key { [ z, Z ] }; + key { [ o, O, oe, OE ] }; // œ Œ + key { [bracketleft, braceleft,dead_circumflex, dead_diaeresis ] }; + + key { [ q, Q ] }; + key { [ m, M ] }; + key { [apostrophe, quotedbl, ugrave, Ugrave ] }; // ù Ù + + key { [ w, W, guillemotleft, leftdoublequotemark ] }; // « “ + key { [ x, X,guillemotright,rightdoublequotemark ] }; // » ” + key { [ semicolon, colon ] }; + + include "eurosign(e)" + include "level3(ralt_switch)" +}; + +// New Azerty layout, from the French Standardization Association (AFNOR), +// defined in norm NF Z71-300. See https://norme-azerty.fr. +// +// Original author: Cimbali , © 2019. +// +// ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┲━━━━━━━━━┓ +// │ # ̑ │ 1 À │ 2 É │ 3 È │ 4 Ê │ 5 ̋ │ 6 ̏ │ 7 │ 8 — │ 9 ‹ │ 0 › │ " ˚ │ ¨ ┃ ⌫ Retour┃ +// │ @ ̆ │ à § │ é ́ │ è ̀ │ ê & │ ( [ │ ) ] │ ‘ ̄ │ ’ _ │ « “ │ » ” │ ' ° │ ̂ ̌ ┃ arrière┃ +// ┢━━━━━┷━┱───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┺━┳━━━━━━━┫ +// ┃ ┃ A Æ │ Z │ E │ R │ T ™ │ Y │ U Ù │ I ̣ │ O Œ │ P ‰ │ – ‑ │ ± ‡ ┃Entrée ┃ +// ┃Tab ↹ ┃ a æ │ z £ │ e € │ r ® │ t { │ y } │ u ù │ i ̇ │ o œ │ p % │ - − │ + † ┃ ⏎ ┃ +// ┣━━━━━━━┻┱────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┺┓ ┃ +// ┃ ┃ Q │ S ẞ │ D │ F │ G │ H ̱ │ J │ K │ L │ M │ \ √ │ ½ ¼ ┃ ┃ +// ┃Maj ⇬ ┃ q θ │ s ß │ d $ │ f ¤ │ g µ │ h │ j │ k ̷ │ l | │ m ∞ │ / ÷ │ * × ┃ ┃ +// ┣━━━━━━━┳┹────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┲┷━━━━━┻━━━━━━┫ +// ┃ ┃ > ≥ │ W Ʒ │ X │ C Ç │ V ˛ │ B │ N │ ? │ ! ̦ │ … │ = ≠ ┃ ┃ +// ┃Shift ⇧┃ < ≤ │ w ʒ │ x © │ c ç │ v ¸ │ b ̵ │ n ~ │ . ¿ │ , ¡ │ : · │ ; ≃ ┃Shift ⇧ ┃ +// ┣━━━━━━━╋━━━━━┷━┳━━━┷━━━┱─┴─────┴─────┴─────┴─────┴─────┴───┲━┷━━━━━╈━━━━━┻━┳━━━━━━━┳━━━┛ +// ┃ ┃ ┃ ┃ ␣ Espace fine insécable ⍽ ┃ ┃ ┃ ┃ +// ┃Ctrl ┃Meta ┃Alt ┃ ␣ Espace Espace insécable ⍽ ┃AltGr ⇮┃Menu ┃Ctrl ┃ +// ┗━━━━━━━┻━━━━━━━┻━━━━━━━┹───────────────────────────────────┺━━━━━━━┻━━━━━━━┻━━━━━━━┛ +partial alphanumeric_keys +xkb_symbols "afnor" { + + name[Group1]="French (AZERTY, AFNOR)"; + + key {[ at, numbersign, dead_breve, dead_invertedbreve ]}; // @ # ̑ ̆ + key {[ agrave, 1, section, Agrave ]}; // à 1 § À + key {[ eacute, 2, dead_acute, Eacute ]}; // é 2 ́ É + key {[ egrave, 3, dead_grave, Egrave ]}; // è 3 ̀ È + key {[ ecircumflex, 4, ampersand, Ecircumflex ]}; // ê 4 & Ê + key {[ parenleft, 5, bracketleft, dead_doubleacute ]}; // ( 5 [ ̋ + key {[ parenright, 6, bracketright, dead_doublegrave ]}; // ) 6 ] ̏ + key {[ leftsinglequotemark, 7, dead_macron, none ]}; // ‘ 7 ̄ + key {[ rightsinglequotemark, 8, underscore, emdash ]}; // ’ 8 _ — + key {[ guillemotleft, 9, leftdoublequotemark, U2039 ]}; // « 9 “ ‹ + key {[ guillemotright, 0, rightdoublequotemark, U203A ]}; // » 0 ” › + key {[ apostrophe, quotedbl, degree, dead_abovering ]}; // ' " ° ̊ + key {[ dead_circumflex, dead_diaeresis, dead_caron, none ]}; // ̂ ̈ ̌ + + key {[ a, A, ae, AE ]}; // a A æ Æ + key {[ z, Z, sterling, none ]}; // z Z £ + key {[ e, E, EuroSign, none ]}; // e E € + key {[ r, R, registered, none ]}; // r R ® + key {[ t, T, braceleft, trademark ]}; // t T { ™ + key {[ y, Y, braceright, none ]}; // y Y } + key {[ u, U, ugrave, Ugrave ]}; // u U ù Ù + key {[ i, I, dead_abovedot, dead_belowdot ]}; // i I ̇ ̣ + key {[ o, O, oe, OE ]}; // o O œ Œ + key {[ p, P, percent, permille ]}; // p P % ‰ + key {[ minus, endash, U2212, U2011 ]}; // - – − ‑ // signe moins (minus sign), trait d'union insécable (non-breaking hyphen) + key {[ plus, plusminus, dagger, doubledagger ]}; // + ± † ‡ + + key {[ q, Q, Greek_theta, none ]}; // q Q θ + key {[ s, S, ssharp, U1E9E ]}; // s S ß ẞ // lettre majuscule latine S dur (latin capital letter sharp s) + key {[ d, D, dollar, none ]}; // d D $ + key {[ f, F, dead_currency, none ]}; // f F ¤ + key {[ g, G, dead_greek, none ]}; // g G µ + key {[ h, H, none, dead_belowmacron ]}; // h H ̱ // Missing deadkey for other european characters (ªəƏþÞıݺſðÐƞȠijIJ) + key {[ j, J, none, none ]}; // j J + key {[ k, K, dead_stroke, none ]}; // k K ̷ + key {[ l, L, bar, none ]}; // l L | + key {[ m, M, infinity, none ]}; // m M ∞ + key {[ slash, backslash, division, radical ]}; // / \ ÷ √ + key {[ asterisk, onehalf, multiply, onequarter ]}; // * ½ × ¼ + + key {[ less, greater, lessthanequal, greaterthanequal ]}; // < > ≤ ≥ + key {[ w, W, ezh, EZH ]}; // w W ʒ Ʒ + key {[ x, X, copyright, none ]}; // x X © + key {[ c, C, ccedilla, Ccedilla ]}; // c C ç Ç + key {[ v, V, dead_cedilla, dead_ogonek ]}; // v V ̧ ̨ + key {[ b, B, dead_stroke, none ]}; // b B ̵ + key {[ n, N, dead_tilde, none ]}; // n N ̃ + key {[ period, question, questiondown, none ]}; // . ? ¿ + key {[ comma, exclam, exclamdown, dead_belowcomma ]}; // , ! ¡ ̦ + key {[ colon, ellipsis, periodcentered, none ]}; // : … · + key {[ semicolon, equal, similarequal, notequal ]}; // ; = ≃ ≠ + + include "nbsp(level3n)" + include "keypad(oss)" + + include "level3(ralt_switch)" +}; diff --git a/library/xkeyboard-config/vendor/symbols/gb b/library/xkeyboard-config/vendor/symbols/gb new file mode 100644 index 0000000..551484a --- /dev/null +++ b/library/xkeyboard-config/vendor/symbols/gb @@ -0,0 +1,249 @@ +// Keyboard layouts for Great Britain. + +default partial alphanumeric_keys +xkb_symbols "basic" { + + // The basic UK layout, also known as the IBM 166 layout, + // but with the useless brokenbar pushed two levels up. + + include "latin" + + name[Group1]="English (UK)"; + + key { [ grave, notsign, bar, bar ] }; + key { [ 2, quotedbl, twosuperior, oneeighth ] }; + key { [ 3, sterling, threesuperior, sterling ] }; + key { [ 4, dollar, EuroSign, onequarter ] }; + + key { [apostrophe, at, dead_circumflex, dead_caron] }; + key { [numbersign, asciitilde, dead_grave, dead_breve ] }; + + key { [ backslash, bar, bar, brokenbar ] }; + + include "level3(ralt_switch)" +}; + +partial alphanumeric_keys +xkb_symbols "intl" { + + // A UK layout but with five accents made into dead keys: + // grave, diaeresis, circumflex, acute, and tilde. + // By Phil Jones . + + include "latin" + + name[Group1]="English (UK, intl., with dead keys)"; + + key { [ dead_grave, notsign, bar, bar ] }; + key { [ 2, dead_diaeresis, twosuperior, onehalf ] }; + key { [ 3, sterling, threesuperior, onethird ] }; + key { [ 4, dollar, EuroSign, onequarter ] }; + key { [ 6, dead_circumflex, threequarters, onesixth ] }; + + key { [ dead_acute, at, apostrophe, bar ] }; + key { [ numbersign, dead_tilde, bar, bar ] }; + + key { [ backslash, bar, bar, bar ] }; + key { [ comma, less, ccedilla, Ccedilla ] }; + + include "level3(ralt_switch)" +}; + +partial alphanumeric_keys +xkb_symbols "extd" { + // Clone of the Microsoft "United Kingdom Extended" layout, which + // includes dead keys for: grave; diaeresis; circumflex; tilde; and + // accute. It also enables direct access to accute characters using + // the Multi_key (Alt Gr). + // + // Taken from... + // "Windows Keyboard Layouts" + // https://docs.microsoft.com/en-gb/globalization/windows-keyboard-layouts#U + // + // -- Jonathan Miles + + include "latin" + + name[Group1]="English (UK, extended, Windows)"; + + key { [ dead_grave, notsign, brokenbar, NoSymbol ] }; + key { [ 2, quotedbl, dead_diaeresis, onehalf ] }; + key { [ 3, sterling, threesuperior, onethird ] }; + key { [ 4, dollar, EuroSign, onequarter ] }; + key { [ 6, asciicircum, dead_circumflex, NoSymbol ] }; + + key { [ w, W, wacute, Wacute ] }; + key { [ e, E, eacute, Eacute ] }; + key { [ y, Y, yacute, Yacute ] }; + key { [ u, U, uacute, Uacute ] }; + key { [ i, I, iacute, Iacute ] }; + key { [ o, O, oacute, Oacute ] }; + key { [ bracketright, braceright, NoSymbol, bar ] }; + + key { [ a, A, aacute, Aacute ] }; + key { [ apostrophe, at, dead_acute, grave ] }; + key { [ numbersign, asciitilde, dead_tilde, backslash ] }; + + key { [ backslash, bar, NoSymbol, NoSymbol ] }; + key { [ c, C, ccedilla, Ccedilla ] }; + + include "level3(ralt_switch)" +}; + +// Describe the differences between the US Colemak layout +// and a UK variant. By Andy Buckley (andy@insectnation.org) + +partial alphanumeric_keys +xkb_symbols "colemak" { + include "us(colemak)" + + name[Group1]="English (UK, Colemak)"; + + key { [ grave, notsign, bar, asciitilde ] }; + key { [ 2, quotedbl, twosuperior, oneeighth ] }; + key { [ 3, sterling, threesuperior, sterling ] }; + key { [ 4, dollar, EuroSign, onequarter ] }; + + key { [apostrophe, at, dead_circumflex, dead_caron] }; + key { [numbersign, asciitilde, dead_grave, dead_breve ] }; + + key { [ backslash, bar, asciitilde, brokenbar ] }; +}; + +// Colemak-DH (ISO) layout, UK Variant, https://colemakmods.github.io/mod-dh/ + +partial alphanumeric_keys +xkb_symbols "colemak_dh" { + include "us(colemak_dh)" + + name[Group1]="English (UK, Colemak-DH)"; + + key { [ grave, notsign, bar, asciitilde ] }; + key { [ 2, quotedbl, twosuperior, oneeighth ] }; + key { [ 3, sterling, threesuperior, sterling ] }; + key { [ 4, dollar, EuroSign, onequarter ] }; + + key { [apostrophe, at, dead_circumflex, dead_caron] }; + key { [numbersign, asciitilde, dead_grave, dead_breve ] }; + + key { [ backslash, bar, asciitilde, brokenbar ] }; +}; + + +// Dvorak (UK) keymap (by odaen) allowing the usage of +// the £ and ? key and swapping the @ and " keys. + +partial alphanumeric_keys +xkb_symbols "dvorak" { + include "us(dvorak-alt-intl)" + + name[Group1]="English (UK, Dvorak)"; + + key { [ grave, notsign, bar, bar ] }; + key { [ 2, quotedbl, twosuperior, NoSymbol ] }; + key { [ 3, sterling, threesuperior, NoSymbol ] }; + key { [ apostrophe, at ] }; + key { [ numbersign, asciitilde ] }; + key { [ backslash, bar ] }; +}; + +// Dvorak letter positions, but punctuation all in the normal UK positions. + +partial alphanumeric_keys +xkb_symbols "dvorakukp" { + include "gb(dvorak)" + + name[Group1]="English (UK, Dvorak, with UK punctuation)"; + + key { [ minus, underscore ] }; + key { [ equal, plus ] }; + key { [ bracketleft, braceleft ] }; + key { [ bracketright, braceright ] }; + key { [ slash, question ] }; + key { [apostrophe, at, dead_circumflex, dead_caron] }; +}; + +partial alphanumeric_keys +xkb_symbols "mac" { + + include "latin" + + name[Group1]= "English (UK, Macintosh)"; + + key { [ section, plusminus ] }; + key { [ 2, at, EuroSign ] }; + key { [ 3, sterling, numbersign ] }; + key { [ grave, asciitilde ] }; + + include "level3(ralt_switch)" + include "level3(enter_switch)" +}; + + +partial alphanumeric_keys +xkb_symbols "mac_intl" { + + include "latin" + + name[Group1]="English (UK, Macintosh, intl.)"; + + key { [ section, plusminus, notsign, notsign ] }; //dead_grave + key { [ 2, at, EuroSign, onehalf ] }; + key { [ 3, sterling, twosuperior, onethird ] }; + key { [ 4, dollar, threesuperior, onequarter ] }; + key { [ 6, dead_circumflex, NoSymbol, onesixth ] }; + key { [ o, O, oe, OE ] }; + + key { [ dead_acute, dead_diaeresis, dead_diaeresis, bar ] }; //dead_doubleacute + key { [ backslash, bar, numbersign, bar ] }; + + key { [ dead_grave, dead_tilde, brokenbar, bar ] }; + + include "level3(ralt_switch)" +}; + +partial alphanumeric_keys +xkb_symbols "pl" { + + // Polish accented letters on upper levels of corresponding base letters. + // Idea from Wawrzyniec Niewodniczański, adapted by Aleksander Kowalski. + + include "gb(basic)" + + name[Group1]="Polish (British keyboard)"; + + key { [ e, E, eogonek, Eogonek ] }; + key { [ o, O, oacute, Oacute ] }; + + key { [ a, A, aogonek, Aogonek ] }; + key { [ s, S, sacute, Sacute ] }; + + key { [ z, Z, zabovedot, Zabovedot ] }; + key { [ x, X, zacute, Zacute ] }; + key { [ c, C, cacute, Cacute ] }; + key { [ n, N, nacute, Nacute ] }; +}; + +partial alphanumeric_keys +xkb_symbols "gla" { + + // Grave-accented letters on the upper levels of the relevant vowels. + + include "gb(basic)" + + name[Group1]="Scottish Gaelic"; + + key { [ e, E, egrave, Egrave ] }; + key { [ u, U, ugrave, Ugrave ] }; + key { [ i, I, igrave, Igrave ] }; + key { [ o, O, ograve, Ograve ] }; + + key { [ a, A, agrave, Agrave ] }; +}; + +// EXTRAS: + +partial alphanumeric_keys + xkb_symbols "sun_type6" { + include "sun_vndr/gb(sun_type6)" +}; diff --git a/library/xkeyboard-config/vendor/symbols/kpdl b/library/xkeyboard-config/vendor/symbols/kpdl new file mode 100644 index 0000000..968dbd2 --- /dev/null +++ b/library/xkeyboard-config/vendor/symbols/kpdl @@ -0,0 +1,102 @@ +// The key is a mess. +// It was probably originally meant to be a decimal separator. +// Except since it was declared by USA people it didn't use the original +// SI separator "," but a "." (since then the USA managed to f-up the SI +// by making "." an accepted alternative, but standards still use "," as +// default) +// As a result users of SI-abiding countries expect either a "." or a "," +// or a "decimal_separator" which may or may not be translated in one of the +// above depending on applications. +// It's not possible to define a default per-country since user expectations +// depend on the conflicting choices of their most-used applications, +// operating system, etc. Therefore it needs to be a configuration setting +// Copyright © 2007 Nicolas Mailhot + + +// Legacy #1 +// This assumes KP_Decimal will be translated in a dot +partial keypad_keys +xkb_symbols "dot" { + + key.type[Group1]="KEYPAD" ; + + key { [ KP_Delete, KP_Decimal ] }; // +}; + + +// Legacy #2 +// This assumes KP_Separator will be translated in a comma +partial keypad_keys +xkb_symbols "comma" { + + key.type[Group1]="KEYPAD" ; + + key { [ KP_Delete, KP_Separator ] }; // +}; + + +// Period , usual keyboard serigraphy in most countries +partial keypad_keys +xkb_symbols "dotoss" { + + key.type[Group1]="FOUR_LEVEL_MIXED_KEYPAD" ; + + key { [ KP_Delete, period, comma, 0x100202F ] }; // . , ⍽ (narrow no-break space) +}; + + +// Period , usual keyboard serigraphy in most countries, latin-9 restriction +partial keypad_keys +xkb_symbols "dotoss_latin9" { + + key.type[Group1]="FOUR_LEVEL_MIXED_KEYPAD" ; + + key { [ KP_Delete, period, comma, nobreakspace ] }; // . , ⍽ (no-break space) +}; + + +// Comma , what most non anglo-saxon people consider the real separator +partial keypad_keys +xkb_symbols "commaoss" { + + key.type[Group1]="FOUR_LEVEL_MIXED_KEYPAD" ; + + key { [ KP_Delete, comma, period, 0x100202F ] }; // , . ⍽ (narrow no-break space) +}; + + +// Momayyez : Bahrain, Iran, Iraq, Kuwait, Oman, Qatar, Saudi Arabia, Syria, UAE +partial keypad_keys +xkb_symbols "momayyezoss" { + + key.type[Group1]="FOUR_LEVEL_MIXED_KEYPAD" ; + + key { [ KP_Delete, 0x100066B, comma, 0x100202F ] }; // ? , ⍽ (narrow no-break space) +}; + + +// Abstracted , pray everything will work out (it usually does not) +partial keypad_keys +xkb_symbols "kposs" { + + key.type[Group1]="FOUR_LEVEL_MIXED_KEYPAD" ; + + key { [ KP_Delete, KP_Decimal, KP_Separator, 0x100202F ] }; // ? ? ⍽ (narrow no-break space) +}; + +// Spreadsheets may be configured to use the dot as decimal +// punctuation, comma as a thousands separator and then semi-colon as +// the list separator. Of these, dot and semi-colon is most important +// when entering data by the keyboard; the comma can then be inferred +// and added to the presentation afterwards. Using semi-colon as a +// general separator may in fact be preferred to avoid ambiguities +// in data files. Most times a decimal separator is hard-coded, it +// seems to be period, probably since this is the syntax used in +// (most) programming languages. +partial keypad_keys +xkb_symbols "semi" { + + key.type[Group1]="FOUR_LEVEL_MIXED_KEYPAD" ; + + key { [ NoSymbol, NoSymbol, semicolon ] }; +}; diff --git a/library/xkeyboard-config/vendor/symbols/latin b/library/xkeyboard-config/vendor/symbols/latin new file mode 100644 index 0000000..d1742c1 --- /dev/null +++ b/library/xkeyboard-config/vendor/symbols/latin @@ -0,0 +1,255 @@ +// Common Latin alphabet layout + +default partial +xkb_symbols "basic" { + + key { [ 1, exclam, onesuperior, exclamdown ] }; + key { [ 2, at, twosuperior, oneeighth ] }; + key { [ 3, numbersign, threesuperior, sterling ] }; + key { [ 4, dollar, onequarter, dollar ] }; + key { [ 5, percent, onehalf, threeeighths ] }; + key { [ 6, asciicircum, threequarters, fiveeighths ] }; + key { [ 7, ampersand, braceleft, seveneighths ] }; + key { [ 8, asterisk, bracketleft, trademark ] }; + key { [ 9, parenleft, bracketright, plusminus ] }; + key { [ 0, parenright, braceright, degree ] }; + key { [ minus, underscore, backslash, questiondown ] }; + key { [ equal, plus, dead_cedilla, dead_ogonek ] }; + + key { [ q, Q, at, Greek_OMEGA ] }; + key { [ w, W, U017F, section ] }; + key { [ e, E, e, E ] }; + key { [ r, R, paragraph, registered ] }; + key { [ t, T, tslash, Tslash ] }; + key { [ y, Y, leftarrow, yen ] }; + key { [ u, U, downarrow, uparrow ] }; + key { [ i, I, rightarrow, idotless ] }; + key { [ o, O, oslash, Oslash ] }; + key { [ p, P, thorn, THORN ] }; + key { [bracketleft, braceleft, dead_diaeresis, dead_abovering ] }; + key { [bracketright, braceright, dead_tilde, dead_macron ] }; + + key { [ a, A, ae, AE ] }; + key { [ s, S, ssharp, U1E9E ] }; + key { [ d, D, eth, ETH ] }; + key { [ f, F, dstroke, ordfeminine ] }; + key { [ g, G, eng, ENG ] }; + key { [ h, H, hstroke, Hstroke ] }; + key { [ j, J, dead_hook, dead_horn ] }; + key { [ k, K, kra, ampersand ] }; + key { [ l, L, lstroke, Lstroke ] }; + key { [ semicolon, colon, dead_acute, dead_doubleacute ] }; + key { [apostrophe, quotedbl, dead_circumflex, dead_caron ] }; + key { [ grave, asciitilde, notsign, notsign ] }; + + key { [ backslash, bar, dead_grave, dead_breve ] }; + key { [ z, Z, guillemotleft, less ] }; + key { [ x, X, guillemotright, greater ] }; + key { [ c, C, cent, copyright ] }; + key { [ v, V, doublelowquotemark, singlelowquotemark ] }; + key { [ b, B, leftdoublequotemark, leftsinglequotemark ] }; + key { [ n, N, rightdoublequotemark, rightsinglequotemark ] }; + key { [ m, M, mu, masculine ] }; + key { [ comma, less, U2022, multiply ] }; // bullet + key { [ period, greater, periodcentered, division ] }; + key { [ slash, question, dead_belowdot, dead_abovedot ] }; +}; + +// Northern Europe ( Danish, Finnish, Norwegian, Swedish) common layout + +partial +xkb_symbols "type2" { + + include "latin" + + key { [ 1, exclam, exclamdown, onesuperior ] }; + key { [ 2, quotedbl, at, twosuperior ] }; + key { [ 3, numbersign, sterling, threesuperior] }; + key { [ 4, currency, dollar, onequarter ] }; + key { [ 5, percent, onehalf, cent ] }; + key { [ 6, ampersand, yen, fiveeighths ] }; + key { [ 7, slash, braceleft, division ] }; + key { [ 8, parenleft, bracketleft, guillemotleft] }; + key { [ 9, parenright, bracketright, guillemotright] }; + key { [ 0, equal, braceright, degree ] }; + + key { [ e, E, EuroSign, cent ] }; + key { [ r, R, registered, registered ] }; + key { [ t, T, thorn, THORN ] }; + key { [ o, O, oe, OE ] }; + key { [ aring, Aring, dead_diaeresis, dead_abovering ] }; + key { [dead_diaeresis, dead_circumflex, dead_tilde, dead_caron ] }; + + key { [ a, A, ordfeminine, masculine ] }; + + key { [ c, C, copyright, copyright ] }; + key { [ comma, semicolon, dead_cedilla, dead_ogonek ] }; + key { [ period, colon, periodcentered, dead_abovedot ] }; + key { [ minus, underscore, dead_belowdot, dead_abovedot ] }; +}; + +// Slavic Latin ( Albanian, Croatian, Polish, Slovene, Yugoslav) +// common layout + +partial +xkb_symbols "type3" { + + include "latin" + + key { [ q, Q, backslash, Greek_OMEGA ] }; + key { [ w, W, bar, section ] }; + key { [ z, Z, leftarrow, yen ] }; + + key { [ f, F, bracketleft, ordfeminine ] }; + key { [ g, G, bracketright, ENG ] }; + key { [ k, K, lstroke, ampersand ] }; + + key { [ y, Y, guillemotleft, less ] }; + key { [ v, V, at, grave ] }; + key { [ b, B, braceleft, apostrophe ] }; + key { [ n, N, braceright, acute ] }; + key { [ m, M, section, masculine ] }; + key { [ comma, semicolon, less, multiply ] }; + key { [ period, colon, greater, division ] }; +}; + +// Another common Latin layout +// (German, Estonian, Spanish, Icelandic, Italian, Latin American, Portuguese) + +partial +xkb_symbols "type4" { + + include "latin" + + key { [ 2, quotedbl, at, oneeighth ] }; + key { [ 6, ampersand, notsign, fiveeighths ] }; + key { [ 7, slash, braceleft, seveneighths ] }; + key { [ 8, parenleft, bracketleft, trademark ] }; + key { [ 9, parenright, bracketright, plusminus ] }; + key { [ 0, equal, braceright, degree ] }; + + key { [ e, E, EuroSign, cent ] }; + + key { [ comma, semicolon, U2022, multiply ] }; // bullet + key { [ period, colon, periodcentered, division ] }; + key { [ minus, underscore, dead_belowdot, dead_abovedot ] }; +}; + +partial +xkb_symbols "nodeadkeys" { + + key { [ equal, plus, cedilla, ogonek ] }; + key { [bracketleft, braceleft, diaeresis, degree ] }; + key { [bracketright, braceright, asciitilde, macron ] }; + key { [ j, J, ezh, EZH ] }; + key { [ semicolon, colon, acute, doubleacute ] }; + key { [apostrophe, quotedbl, asciicircum, caron ] }; + key { [ backslash, bar, grave, breve ] }; + key { [ slash, question, ellipsis, abovedot ] }; +}; + +partial +xkb_symbols "type2_nodeadkeys" { + + include "latin(nodeadkeys)" + + key { [ aring, Aring, diaeresis, degree ] }; + key { [ diaeresis, asciicircum, asciitilde, caron ] }; + key { [ comma, semicolon, cedilla, ogonek ] }; + key { [ period, colon, periodcentered, abovedot ] }; + key { [ minus, underscore, ellipsis, abovedot ] }; +}; + +partial +xkb_symbols "type3_nodeadkeys" { + + include "latin(nodeadkeys)" +}; + +partial +xkb_symbols "type4_nodeadkeys" { + + include "latin(nodeadkeys)" + + key { [ minus, underscore, ellipsis, abovedot ] }; +}; + +// Added 2008.03.05 by Marcin Woliński +// See http://marcinwolinski.pl/keyboard/ for a description. +// Used by pl(intl) +// +// ┌─────┐ +// │ 2 4 │ 2 = Shift, 4 = Level3 + Shift +// │ 1 3 │ 1 = Normal, 3 = Level3 +// └─────┘ +// ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┲━━━━━━━━━┓ +// │ ~ ~ │ ! ' │ @ " │ # ˝ │ $ ¸ │ % ˇ │ ^ ^ │ & ˘ │ * ̇ │ ( ̣ │ ) ° │ _ ¯ │ + ˛ ┃ ⌫ Back- ┃ +// │ ` ` │ 1 ¡ │ 2 © │ 3 • │ 4 § │ 5 € │ 6 ¢ │ 7 − │ 8 × │ 9 ÷ │ 0 ° │ - – │ = — ┃ space ┃ +// ┢━━━━━┷━┱───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┺━┳━━━━━━━┫ +// ┃ ┃ Q │ W │ E │ R │ T │ Y │ U │ I │ O │ P │ { « │ } » ┃ Enter ┃ +// ┃Tab ↹ ┃ q │ w │ e │ r │ t │ y │ u │ i │ o │ p │ [ ‹ │ ] › ┃ ⏎ ┃ +// ┣━━━━━━━┻┱────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┺┓ ┃ +// ┃ ┃ A │ S │ D │ F │ G │ H │ J │ K │ L │ : “ │ " ” │ | ¶ ┃ ┃ +// ┃Caps ⇬ ┃ a │ s │ d │ f │ g │ h │ j │ k │ l │ ; ‘ │ ' ’ │ \ ┃ ┃ +// ┣━━━━━━━━┹────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┬┴────┲┷━━━━━┻━━━━━━┫ +// ┃ │ Z │ X │ C │ V │ B │ N │ M │ < „ │ > · │ ? ¿ ┃ ┃ +// ┃Shift ⇧ │ z │ x │ c │ v │ b │ n │ m │ , ‚ │ . … │ / ⁄ ┃Shift ⇧ ┃ +// ┣━━━━━━━┳━━━━━┷━┳━━━┷━━━┱─┴─────┴─────┴─────┴─────┴─────┴───┲━┷━━━━━╈━━━━━┻━┳━━━━━━━┳━━━┛ +// ┃ ┃ ┃ ┃ ␣ ⍽ ┃ ┃ ┃ ┃ +// ┃Ctrl ┃Meta ┃Alt ┃ ␣ Space ⍽ ┃AltGr ⇮┃Menu ┃Ctrl ┃ +// ┗━━━━━━━┻━━━━━━━┻━━━━━━━┹───────────────────────────────────┺━━━━━━━┻━━━━━━━┻━━━━━━━┛ + +partial +xkb_symbols "intl" { + + key { [ grave, asciitilde, dead_grave, dead_tilde ] }; + key { [ 1, exclam, exclamdown, dead_acute ] }; + key { [ 2, at, copyright, dead_diaeresis ] }; + key { [ 3, numbersign, U2022, dead_doubleacute ] }; // U+2022 is bullet (the name bullet does not work) + key { [ 4, dollar, section, dead_cedilla ] }; + key { [ 5, percent, EuroSign, dead_caron ] }; + key { [ 6, asciicircum, cent, dead_circumflex ] }; + key { [ 7, ampersand, U2212, dead_breve ] }; // U+2212 is MINUS SIGN + key { [ 8, asterisk, multiply, dead_abovedot ] }; + key { [ 9, parenleft, division, dead_belowdot ] }; + key { [ 0, parenright, degree, dead_abovering ] }; + key { [ minus, underscore, endash, dead_macron ] }; + key { [ equal, plus, emdash, dead_ogonek ] }; + + key { [ q, Q ] }; + key { [ w, W ] }; + key { [ e, E ] }; + key { [ r, R ] }; + key { [ t, T ] }; + key { [ y, Y ] }; + key { [ u, U ] }; + key { [ i, I ] }; + key { [ o, O ] }; + key { [ p, P ] }; + key { [bracketleft, braceleft, U2039, guillemotleft ] }; + key { [bracketright, braceright, U203A, guillemotright ] }; + + key { [ a, A ] }; + key { [ s, S ] }; + key { [ d, D ] }; + key { [ f, F ] }; + key { [ g, G ] }; + key { [ h, H ] }; + key { [ j, J ] }; + key { [ k, K ] }; + key { [ l, L ] }; + key { [ semicolon, colon, leftsinglequotemark, leftdoublequotemark ] }; + key { [apostrophe, quotedbl, rightsinglequotemark, rightdoublequotemark ] }; + + key { [ backslash, bar, NoSymbol, paragraph ] }; + key { [ z, Z ] }; + key { [ x, X ] }; + key { [ c, C ] }; + key { [ v, V ] }; + key { [ b, B ] }; + key { [ n, N ] }; + key { [ m, M ] }; + key { [ comma, less, singlelowquotemark, doublelowquotemark ] }; + key { [ period, greater, ellipsis, periodcentered ] }; + key { [ slash, question, U2044, questiondown ] }; // U+2044 is FRACTION SLASH +}; diff --git a/library/xkeyboard-config/vendor/symbols/level3 b/library/xkeyboard-config/vendor/symbols/level3 new file mode 100644 index 0000000..6471c0c --- /dev/null +++ b/library/xkeyboard-config/vendor/symbols/level3 @@ -0,0 +1,156 @@ +// These variants assign ISO_Level3_Shift to various keys +// so that levels 3 and 4 can be reached. + +// The default behaviour: +// the right Alt key (AltGr) chooses the third symbol engraved on a key. +default partial modifier_keys +xkb_symbols "ralt_switch" { + key {[ ISO_Level3_Shift ], type[group1]="ONE_LEVEL" }; +}; + +// The right Alt key never chooses the third level. +// This option attempts to undo the effect of a layout's inclusion of +// 'ralt_switch'. You may want to also select another level3 option +// to map the level3 shift to some other key. +partial modifier_keys +xkb_symbols "ralt_alt" { + key {[ Alt_R, Meta_R ], type[group1]="TWO_LEVEL" }; + modifier_map Mod1 { }; +}; + +// The right Alt key (while pressed) chooses the third shift level, +// and Compose is mapped to its second level. +partial modifier_keys +xkb_symbols "ralt_switch_multikey" { + key {[ ISO_Level3_Shift, Multi_key ], type[group1]="TWO_LEVEL" }; +}; + +// Either Alt key (while pressed) chooses the third shift level. +// (To be used mostly to imitate Mac OS functionality.) +partial modifier_keys +xkb_symbols "alt_switch" { + include "level3(lalt_switch)" + include "level3(ralt_switch)" +}; + +// The left Alt key (while pressed) chooses the third shift level. +partial modifier_keys +xkb_symbols "lalt_switch" { + key {[ ISO_Level3_Shift ], type[group1]="ONE_LEVEL" }; +}; + +// The right Ctrl key (while pressed) chooses the third shift level. +partial modifier_keys +xkb_symbols "switch" { + key {[ ISO_Level3_Shift ], type[group1]="ONE_LEVEL" }; +}; + +// The Menu key (while pressed) chooses the third shift level. +partial modifier_keys +xkb_symbols "menu_switch" { + key {[ ISO_Level3_Shift ], type[group1]="ONE_LEVEL" }; +}; + +// Either Win key (while pressed) chooses the third shift level. +partial modifier_keys +xkb_symbols "win_switch" { + include "level3(lwin_switch)" + include "level3(rwin_switch)" +}; + +// The left Win key (while pressed) chooses the third shift level. +partial modifier_keys +xkb_symbols "lwin_switch" { + key {[ ISO_Level3_Shift ], type[group1]="ONE_LEVEL" }; +}; + +// The right Win key (while pressed) chooses the third shift level. +partial modifier_keys +xkb_symbols "rwin_switch" { + key {[ ISO_Level3_Shift ], type[group1]="ONE_LEVEL" }; +}; + +// The Enter key on the kepypad (while pressed) chooses the third shift level. +// (This is especially useful for Mac laptops which miss the right Alt key.) +partial modifier_keys +xkb_symbols "enter_switch" { + key {[ ISO_Level3_Shift ], type[group1]="ONE_LEVEL" }; +}; + +// The CapsLock key (while pressed) chooses the third shift level. +partial modifier_keys +xkb_symbols "caps_switch" { + key {[ ISO_Level3_Shift ], type[group1]="ONE_LEVEL" }; +}; + +// The CapsLock key (while pressed) chooses the third shift level and +// Ctrl + CapsLock has the original CapsLock function. +// The 2023 DIN standard for German keyboards recommends it as an option: +// - https://de.wikipedia.org/wiki/E1_(Tastaturbelegung)#Feststelltaste/Umschaltsperre +// - https://en.wikipedia.org/wiki/Caps_Lock#Abolition +partial modifier_keys +xkb_symbols "caps_switch_capslock_with_ctrl" { + virtual_modifiers LevelThree; + + key { + type[Group1] = "PC_CONTROL_LEVEL2", + symbols[Group1] = [ ISO_Level3_Shift, Caps_Lock ], + // Explicit actions are preferred over modMap None/Mod5 { Caps_Lock } + // because they have no side effect + actions[Group1] = [ SetMods(modifiers = LevelThree), LockMods(modifiers = Lock) ] + }; +}; + +// The Backslash key (while pressed) chooses the third shift level. +partial modifier_keys +xkb_symbols "bksl_switch" { + key {[ ISO_Level3_Shift ], type[group1]="ONE_LEVEL" }; +}; + +// The AC11 key (while pressed) chooses the third shift level. +partial modifier_keys +xkb_symbols "ac11_switch" { + key {[ ISO_Level3_Shift ], type[Group1]="ONE_LEVEL" }; +}; + +// The Less/Greater key (while pressed) chooses the third shift level. +partial modifier_keys +xkb_symbols "lsgt_switch" { + key {[ ISO_Level3_Shift ], type[group1]="ONE_LEVEL" }; +}; + +// The CapsLock key (while pressed) chooses the third shift level, +// and latches when pressed together with another third-level chooser. +partial modifier_keys +xkb_symbols "caps_switch_latch" { + key {[ ISO_Level3_Shift, ISO_Level3_Shift, ISO_Level3_Latch ], + type[group1]="THREE_LEVEL" }; +}; + +// The Backslash key (while pressed) chooses the third shift level, +// and latches when pressed together with another third-level chooser. +partial modifier_keys +xkb_symbols "bksl_switch_latch" { + key {[ ISO_Level3_Shift, ISO_Level3_Shift, ISO_Level3_Latch ], + type[group1]="THREE_LEVEL" }; +}; + +// The Less/Greater key (while pressed) chooses the third shift level, +// and latches when pressed together with another third-level chooser. +partial modifier_keys +xkb_symbols "lsgt_switch_latch" { + key {[ ISO_Level3_Shift, ISO_Level3_Shift, ISO_Level3_Latch ], + type[group1]="THREE_LEVEL" }; +}; + +// Top-row digit key 4 chooses third shift level when pressed alone. +partial modifier_keys +xkb_symbols "4_switch_isolated" { + override key {[ ISO_Level3_Shift ]}; +}; + +// Top-row digit key 9 chooses third shift level when pressed alone. +partial modifier_keys +xkb_symbols "9_switch_isolated" { + override key {[ ISO_Level3_Shift ]}; +}; diff --git a/library/xkeyboard-config/vendor/symbols/us b/library/xkeyboard-config/vendor/symbols/us new file mode 100644 index 0000000..2833c5a --- /dev/null +++ b/library/xkeyboard-config/vendor/symbols/us @@ -0,0 +1,2238 @@ +// Keyboard layouts for the United States of America. + +default partial alphanumeric_keys modifier_keys +xkb_symbols "basic" { + + name[Group1]= "English (US)"; + + key {[ grave, asciitilde ]}; + key {[ 1, exclam ]}; + key {[ 2, at ]}; + key {[ 3, numbersign ]}; + key {[ 4, dollar ]}; + key {[ 5, percent ]}; + key {[ 6, asciicircum ]}; + key {[ 7, ampersand ]}; + key {[ 8, asterisk ]}; + key {[ 9, parenleft ]}; + key {[ 0, parenright ]}; + key {[ minus, underscore ]}; + key {[ equal, plus ]}; + + key {[ q, Q ]}; + key {[ w, W ]}; + key {[ e, E ]}; + key {[ r, R ]}; + key {[ t, T ]}; + key {[ y, Y ]}; + key {[ u, U ]}; + key {[ i, I ]}; + key {[ o, O ]}; + key {[ p, P ]}; + key {[ bracketleft, braceleft ]}; + key {[ bracketright, braceright ]}; + + key {[ a, A ]}; + key {[ s, S ]}; + key {[ d, D ]}; + key {[ f, F ]}; + key {[ g, G ]}; + key {[ h, H ]}; + key {[ j, J ]}; + key {[ k, K ]}; + key {[ l, L ]}; + key {[ semicolon, colon ]}; + key {[ apostrophe, quotedbl ]}; + key {[ backslash, bar ]}; + + key {[ z, Z ]}; + key {[ x, X ]}; + key {[ c, C ]}; + key {[ v, V ]}; + key {[ b, B ]}; + key {[ n, N ]}; + key {[ m, M ]}; + key {[ comma, less ]}; + key {[ period, greater ]}; + key {[ slash, question ]}; +}; + +partial alphanumeric_keys +xkb_symbols "euro" { + + include "us(basic)" + name[Group1]= "English (US, euro on 5)"; + + key { [ backslash, bar ] }; + + include "eurosign(5)" + + include "level3(ralt_switch)" +}; + + +partial alphanumeric_keys +xkb_symbols "ibm238l" { + + include "us(basic)" + name[Group1]= "English (US, IBM Arabic 238_L)"; + + key { [ comma, comma ] }; + key { [ period, period ] }; + key { [ grave, asciitilde ] }; + key { [ backslash, bar ] }; + key { [ less, greater ] }; +}; + +partial alphanumeric_keys +xkb_symbols "intl" { + + name[Group1]= "English (US, intl., with dead keys)"; + + key { [dead_grave, dead_tilde, grave, asciitilde ] }; + key { [ 1, exclam, exclamdown, onesuperior ] }; + key { [ 2, at, twosuperior, dead_doubleacute ] }; + key { [ 3, numbersign, threesuperior, dead_macron ] }; + key { [ 4, dollar, currency, sterling ] }; + key { [ 5, percent, EuroSign, dead_cedilla ] }; + key { [ 6, dead_circumflex, onequarter, asciicircum ] }; + key { [ 7, ampersand, onehalf, dead_horn ] }; + key { [ 8, asterisk, threequarters, dead_ogonek ] }; + key { [ 9, parenleft, leftsinglequotemark, dead_breve ] }; + key { [ 0, parenright, rightsinglequotemark, dead_abovering ] }; + key { [ minus, underscore, yen, dead_belowdot ] }; + key { [ equal, plus, multiply, division ] }; + + key { [ q, Q, adiaeresis, Adiaeresis ] }; + key { [ w, W, aring, Aring ] }; + key { [ e, E, eacute, Eacute ] }; + key { [ r, R, registered, trademark ] }; + key { [ t, T, thorn, THORN ] }; + key { [ y, Y, udiaeresis, Udiaeresis ] }; + key { [ u, U, uacute, Uacute ] }; + key { [ i, I, iacute, Iacute ] }; + key { [ o, O, oacute, Oacute ] }; + key { [ p, P, odiaeresis, Odiaeresis ] }; + key { [ bracketleft, braceleft, guillemotleft, leftdoublequotemark ] }; + key { [bracketright, braceright, guillemotright, rightdoublequotemark ] }; + + key { [ a, A, aacute, Aacute ] }; + key { [ s, S, ssharp, section ] }; + key { [ d, D, eth, ETH ] }; + key { [ f, F, ediaeresis, Ediaeresis ] }; + key { [ g, G, g, G ] }; + key { [ h, H, h, H ] }; + key { [ j, J, idiaeresis, Idiaeresis ] }; + key { [ k, K, oe, OE ] }; + key { [ l, L, oslash, Oslash ] }; + key { [ semicolon, colon, paragraph, degree ] }; + key { [dead_acute, dead_diaeresis, apostrophe, quotedbl ] }; + + key { [ z, Z, ae, AE ] }; + key { [ x, X, periodcentered, dead_stroke ] }; + key { [ c, C, copyright, cent ] }; + key { [ v, V, v, V ] }; + key { [ b, B, b, B ] }; + key { [ n, N, ntilde, Ntilde ] }; + key { [ m, M, mu, plusminus ] }; + key { [ comma, less, ccedilla, Ccedilla ] }; + key { [ period, greater, dead_abovedot, dead_caron ] }; + key { [ slash, question, questiondown, dead_hook ] }; + key { [ backslash, bar, notsign, brokenbar ] }; + + key { [ backslash, bar, backslash, bar ] }; + + include "level3(ralt_switch)" +}; + +// Based on symbols/us_intl keyboard map: +// Dead-keys definition for a very simple US/ASCII layout. +// by Conectiva (http://www.conectiva.com.br) +// modified by Ricardo Y. Igarashi (iga@that.com.br) + +// Added the following deadkeys, to make it truly international: +// +// dead_macron: on AltGr-minus +// dead_breve: on AltGr-parenleft +// dead_abovedot: on AltGr-period +// dead_abovering: on AltGr-0 +// dead_doubleacute: on AltGr-equal (as quotedbl is already used) +// dead_caron: on AltGr-less (AltGr-shift-comma) +// dead_cedilla: on AltGr-comma +// dead_ogonek: on AltGr-semicolon +// dead_belowdot: on AltGr-underscore (AltGr-shift-minus) +// dead_hook: on AltGr-question +// dead_horn: on AltGr-plus (AltGr-shift-equal) +// dead_diaeresis: on AltGr-colon (Alt-shift-semicolon) +// +// those were already there: +// dead_grave +// dead_acute +// dead_circumflex +// dead_tilde +// dead_diaeresis + +partial alphanumeric_keys +xkb_symbols "alt-intl" { + + include "us" + name[Group1]= "English (US, alt. intl.)"; + + key { [ dead_grave, dead_tilde, grave, asciitilde ] }; + key { [ 5, percent, EuroSign ] }; + key { [ 6, dead_circumflex, asciicircum, asciicircum ] }; + key { [ 9, parenleft, leftsinglequotemark, dead_breve ] }; + key { [ 0, parenright, rightsinglequotemark, dead_abovering ] }; + key { [ minus, underscore, dead_macron, dead_belowdot ] }; + key { [ equal, plus, dead_doubleacute, dead_horn ] }; + + key { [ e, E, EuroSign, cent ] }; + + key { [ semicolon, colon, dead_ogonek, dead_diaeresis ] }; + key { [ dead_acute, dead_diaeresis, apostrophe, quotedbl ] }; + + key { [ x, X, periodcentered, dead_stroke ] }; + key { [ comma, less, dead_cedilla, dead_caron ] }; + key { [ period, greater, dead_abovedot, dead_circumflex ] }; + key { [ slash, question, dead_hook, dead_hook ] }; + + key { [ backslash, bar, backslash, bar ] }; + + include "level3(ralt_switch)" +}; + +partial alphanumeric_keys +xkb_symbols "dvorak" { + + name[Group1]= "English (Dvorak)"; + + key {[ grave, asciitilde, dead_grave, dead_tilde ]}; + key {[ 1, exclam ]}; + key {[ 2, at ]}; + key {[ 3, numbersign ]}; + key {[ 4, dollar ]}; + key {[ 5, percent ]}; + key {[ 6, asciicircum, dead_circumflex, dead_circumflex ]}; + key {[ 7, ampersand ]}; + key {[ 8, asterisk ]}; + key {[ 9, parenleft, dead_grave, dead_breve ]}; + key {[ 0, parenright ]}; + key {[ bracketleft, braceleft ]}; + key {[bracketright, braceright, dead_tilde]}; + + key {[apostrophe, quotedbl, dead_acute, dead_diaeresis ]}; + key {[ comma, less, dead_cedilla, dead_caron ]}; + key {[ period, greater, dead_abovedot, periodcentered ]}; + key {[ p, P ]}; + key {[ y, Y ]}; + key {[ f, F ]}; + key {[ g, G ]}; + key {[ c, C ]}; + key {[ r, R ]}; + key {[ l, L ]}; + key {[ slash, question ]}; + key {[ equal, plus ]}; + + key {[ a, A ]}; + key {[ o, O ]}; + key {[ e, E ]}; + key {[ u, U ]}; + key {[ i, I ]}; + key {[ d, D ]}; + key {[ h, H ]}; + key {[ t, T ]}; + key {[ n, N ]}; + key {[ s, S ]}; + key {[ minus, underscore ]}; + key {[ backslash, bar ]}; + + key {[ semicolon, colon, dead_ogonek, dead_doubleacute ]}; + key {[ q, Q ]}; + key {[ j, J ]}; + key {[ k, K ]}; + key {[ x, X ]}; + key {[ b, B ]}; + key {[ m, M ]}; + key {[ w, W ]}; + key {[ v, V ]}; + key {[ z, Z ]}; +}; + +// Dvorak intl., with dead keys +// Olivier Mehani (shtrom-xorg@ssji.net) +// Reproduce the per-key mapping of us(intl) for the dvorak layout +// aka "I just swapped my keys over" +partial alphanumeric_keys +xkb_symbols "dvorak-intl" { + + name[Group1]= "English (Dvorak, intl., with dead keys)"; + + key { [dead_grave, dead_tilde, grave, asciitilde ] }; + + key { [ 1, exclam, exclamdown, onesuperior ] }; + key { [ 2, at, twosuperior, dead_doubleacute ] }; + key { [ 3, numbersign, threesuperior, dead_macron ] }; + key { [ 4, dollar, currency, sterling ] }; + key { [ 5, percent, EuroSign, dead_cedilla ] }; + key { [ 6, dead_circumflex, onequarter, asciicircum ] }; + key { [ 7, ampersand, onehalf, dead_horn ] }; + key { [ 8, asterisk, threequarters, dead_ogonek ] }; + key { [ 9, parenleft, leftsinglequotemark, dead_breve ] }; + key { [ 0, parenright, rightsinglequotemark, dead_abovering ] }; + key { [ bracketleft, braceleft, guillemotleft, leftdoublequotemark ] }; + key { [bracketright, braceright, guillemotright, rightdoublequotemark ] }; + + key { [dead_acute, dead_diaeresis, apostrophe, quotedbl ] }; + key { [ comma, less, ccedilla, Ccedilla ] }; + key { [ period, greater, dead_abovedot, dead_caron ] }; + key { [ p, P, odiaeresis, Odiaeresis ] }; + key { [ y, Y, udiaeresis, Udiaeresis ] }; + key { [ f, F, ediaeresis, Ediaeresis ] }; + key { [ g, G, g, G ] }; + key { [ c, C, copyright, cent ] }; + key { [ r, R, registered, trademark ] }; + key { [ l, L, oslash, Oslash ] }; + key { [ slash, question, questiondown, dead_hook ] }; + key { [ equal, plus, multiply, division ] }; + + key { [ a, A, aacute, Aacute ] }; + key { [ o, O, oacute, Oacute ] }; + key { [ e, E, eacute, Eacute ] }; + key { [ u, U, uacute, Uacute ] }; + key { [ i, I, iacute, Iacute ] }; + key { [ d, D, eth, ETH ] }; + key { [ h, H, h, H ] }; + key { [ t, T, thorn, THORN ] }; + key { [ n, N, ntilde, Ntilde ] }; + key { [ s, S, ssharp, section ] }; + key { [ minus, underscore, yen, dead_belowdot ] }; + + key { [ semicolon, colon, paragraph, degree ] }; + key { [ q, Q, adiaeresis, Adiaeresis ] }; + key { [ j, J, idiaeresis, Idiaeresis ] }; + key { [ k, K, oe, OE ] }; + key { [ x, X, periodcentered, dead_stroke ] }; + key { [ b, B, b, B ] }; + key { [ m, M, mu, plusminus ] }; + key { [ w, W, aring, Aring ] }; + key { [ v, V, v, V ] }; + key { [ z, Z, ae, AE ] }; + key { [ backslash, bar, notsign, brokenbar ] }; + + key { [ backslash, bar, backslash, bar ] }; + + include "level3(ralt_switch)" +}; + +// Dvorak international without dead keys +// Stephane Magnenat (stephane at magnenat dot net, http://stephane.magnenat.net) +// Based on information from http://www.poupinou.org/dvorak/index.html +// +// ` 1 2 3 4 5 6 7 8 9 0 [ ] \ +// € +// +// ' , . p y f g c r l / = +// ä ê ë ü ç +// +// a o e u i d h t n s - +// à ô é û î ß +// +// ; q j k x b m w v z +// â ö è ù ï + +partial alphanumeric_keys +xkb_symbols "dvorak-alt-intl" { + + include "us(dvorak)" + name[Group1]= "English (Dvorak, alt. intl.)"; + + key { [ 4, dollar, EuroSign ] }; + + key { [ comma, less, adiaeresis, dead_caron ] }; + key { [ period, greater, ecircumflex, periodcentered ] }; + key { [ p, P, ediaeresis, dead_cedilla ] }; + key { [ y, Y, udiaeresis ] }; + key { [ c, C, ccedilla, dead_abovedot ] }; + + key { [ a, A, agrave ] }; + key { [ o, O, ocircumflex ] }; + key { [ e, E, eacute ] }; + key { [ u, U, ucircumflex ] }; + key { [ i, I, icircumflex ] }; + key { [ s, S, ssharp, U1E9E ] }; + + key { [ semicolon, colon, acircumflex ] }; + key { [ q, Q, odiaeresis, dead_ogonek ] }; + key { [ j, J, egrave, dead_doubleacute ] }; + key { [ k, K, ugrave ] }; + key { [ x, X, idiaeresis, dead_stroke ] }; + + include "level3(ralt_switch)" +}; + +// Left and right handed dvorak layouts +// by sqweek 2006-01-30 +// Based on the corresponding layouts in the console-tools package. +partial alphanumeric_keys +xkb_symbols "dvorak-l" { + + include "us(dvorak)" + name[Group1]= "English (Dvorak, one-handed, left)"; + + key { [ bracketleft, braceleft ] }; + key { [ bracketright, braceright ] }; + key { [ slash, question ] }; + key { [ p, P ] }; + key { [ f, F ] }; + key { [ m, M ] }; + key { [ l, L ] }; + key { [ j, J ] }; + key { [ 4, dollar ] }; + key { [ 3, numbersign ] }; + key { [ 2, at ] }; + key { [ 1, exclam ] }; + + key { [ semicolon, colon ] }; + key { [ q, Q ] }; + key { [ b, B ] }; + key { [ y, Y ] }; + key { [ u, U ] }; + key { [ r, R ] }; + key { [ s, S ] }; + key { [ o, O ] }; + key { [ period, greater ] }; + key { [ 6, asciicircum ] }; + key { [ 5, percent ] }; + key { [ equal, plus ] }; + + key { [ minus, underscore ] }; + key { [ k, K ] }; + key { [ c, C ] }; + key { [ d, D ] }; + key { [ t, T ] }; + key { [ h, H ] }; + key { [ e, E ] }; + key { [ a, A ] }; + key { [ z, Z ] }; + key { [ 8, asterisk ] }; + key { [ 7, ampersand ] }; + + key { [ apostrophe, quotedbl ] }; + key { [ x, X ] }; + key { [ g, G ] }; + key { [ v, V ] }; + key { [ w, W ] }; + key { [ n, N ] }; + key { [ i, I ] }; + key { [ comma, less ] }; + key { [ 0, parenright ] }; + key { [ 9, parenleft ] }; +}; + +partial alphanumeric_keys +xkb_symbols "dvorak-r" { + + include "us(dvorak)" + name[Group1]= "English (Dvorak, one-handed, right)"; + + key { [ 1, exclam ] }; + key { [ 2, at ] }; + key { [ 3, numbersign ] }; + key { [ 4, dollar ] }; + key { [ j, J ] }; + key { [ l, L ] }; + key { [ m, M ] }; + key { [ f, F ] }; + key { [ p, P ] }; + key { [ slash, question ] }; + key { [ bracketleft, braceleft ] }; + key { [ bracketright, braceright ] }; + + key { [ 5, percent ] }; + key { [ 6, asciicircum ] }; + key { [ q, Q ] }; + key { [ period, greater ] }; + key { [ o, O ] }; + key { [ r, R ] }; + key { [ s, S ] }; + key { [ u, U ] }; + key { [ y, Y ] }; + key { [ b, B ] }; + key { [ semicolon, colon ] }; + key { [ equal, plus ] }; + + key { [ 7, ampersand ] }; + key { [ 8, asterisk ] }; + key { [ z, Z ] }; + key { [ a, A ] }; + key { [ e, E ] }; + key { [ h, H ] }; + key { [ t, T ] }; + key { [ d, D ] }; + key { [ c, C ] }; + key { [ k, K ] }; + key { [ minus, underscore ] }; + + key { [ 9, parenleft ] }; + key { [ 0, parenright ] }; + key { [ x, X ] }; + key { [ comma, less ] }; + key { [ i, I ] }; + key { [ n, N ] }; + key { [ w, W ] }; + key { [ v, V ] }; + key { [ g, G ] }; + key { [ apostrophe, quotedbl ] }; +}; + +// Classic dvorak layout +// by Piter Punk - 2006-07-06 +// Based on dvorak layout and e-mail from Russel L. Harris rlharris@oplink.net +// on xorg list. +partial alphanumeric_keys +xkb_symbols "dvorak-classic" { + + name[Group1]= "English (classic Dvorak)"; + + key { [ grave, asciitilde, dead_grave, dead_tilde ] }; + + key { [ bracketleft, braceleft ] }; + key { [ 7, ampersand ] }; + key { [ 5, percent ] }; + key { [ 3, numbersign ] }; + key { [ 1, exclam ] }; + key { [ 9, parenleft, dead_grave] }; + key { [ 0, parenright ] }; + key { [ 2, at ] }; + key { [ 4, dollar ] }; + key { [ 6, asciicircum, dead_circumflex, dead_circumflex ] }; + key { [ 8, asterisk ] }; + key { [ bracketright, braceright, dead_tilde] }; + + key { [ slash, question ] }; + key { [ comma, less, dead_cedilla, dead_caron ] }; + key { [ period, greater, dead_abovedot, periodcentered ] }; + key { [ p, P ] }; + key { [ y, Y ] }; + key { [ f, F ] }; + key { [ g, G ] }; + key { [ c, C ] }; + key { [ r, R ] }; + key { [ l, L ] }; + key { [ apostrophe, quotedbl, dead_acute, dead_diaeresis ] }; + key { [ equal, plus ] }; + + key { [ a, A ] }; + key { [ o, O ] }; + key { [ e, E ] }; + key { [ u, U ] }; + key { [ i, I ] }; + key { [ d, D ] }; + key { [ h, H ] }; + key { [ t, T ] }; + key { [ n, N ] }; + key { [ s, S ] }; + key { [ minus, underscore ] }; + + key { [ semicolon, colon, dead_ogonek, dead_doubleacute ] }; + key { [ q, Q ] }; + key { [ j, J ] }; + key { [ k, K ] }; + key { [ x, X ] }; + key { [ b, B ] }; + key { [ m, M ] }; + key { [ w, W ] }; + key { [ v, V ] }; + key { [ z, Z ] }; + key { [ backslash, bar ] }; +}; + +// programmer Dvorak, by Roland Kaufmann +// License: BSD, available at +// Main features: Numbers are in shift position (like French), symbols have been +// placed in locations that give good hand-alternation and finger rolling with +// symbols that usually follows, accented characters are possible for I18N. +// Patch suggestions should be sent upstream. +partial alphanumeric_keys +xkb_symbols "dvp" { + + include "us(dvorak)" + name[Group1] = "English (programmer Dvorak)"; + + // Unmodified Shift AltGr Shift+AltGr + // symbols row, left side + key { [ dollar, asciitilde, dead_tilde ] }; + key { [ ampersand, percent ] }; + key { [ bracketleft, 7, currency ], type[Group1] = "FOUR_LEVEL_ALPHABETIC" }; + key { [ braceleft, 5, cent ], type[Group1] = "FOUR_LEVEL_ALPHABETIC" }; + key { [ braceright, 3, yen ], type[Group1] = "FOUR_LEVEL_ALPHABETIC" }; + key { [ parenleft, 1, EuroSign ], type[Group1] = "FOUR_LEVEL_ALPHABETIC" }; + key { [ equal, 9, sterling ], type[Group1] = "FOUR_LEVEL_ALPHABETIC" }; + + // symbols row, right side + key { [ asterisk, 0 ], type[Group1] = "FOUR_LEVEL_ALPHABETIC" }; + key { [ parenright, 2, onehalf ], type[Group1] = "FOUR_LEVEL_ALPHABETIC" }; + key { [ plus, 4 ], type[Group1] = "FOUR_LEVEL_ALPHABETIC" }; + key { [ bracketright, 6 ], type[Group1] = "FOUR_LEVEL_ALPHABETIC" }; + key { [ exclam, 8, exclamdown, U2E18 ], type[Group1] = "FOUR_LEVEL_ALPHABETIC" }; // reversed interrobang + key { [ numbersign, grave, dead_grave ] }; + + // upper row, left side + key { [ semicolon, colon, dead_diaeresis ] }; + key { [ comma, less, guillemotleft, U201C ] }; + key { [ period, greater, guillemotright, U201D ] }; + key { [ p, P, paragraph, section ] }; + key { [ y, Y, udiaeresis, Udiaeresis ] }; + + // upper row, right side + key { [ c, C, ccedilla, Ccedilla ] }; + key { [ r, R, registered, trademark ] }; + key { [ slash, question, questiondown, U203D ] }; // interrobang + key { [ at, asciicircum, dead_circumflex, dead_caron ] }; + + // home row, left side + key { [ a, A, aring, Aring ] }; + key { [ o, O, oslash, Oslash ] }; + key { [ e, E, ae, AE ] }; + key { [ u, U, eacute, Eacute ] }; + + // home row, right side + key { [ d, D, eth, ETH ] }; + key { [ h, H, dead_acute ] }; + key { [ t, T, thorn, THORN ] }; + key { [ n, N, ntilde, Ntilde ] }; + key { [ s, S, ssharp, U1E9E ] }; + key { [ minus, underscore, hyphen, endash ], type[Group1] = "FOUR_LEVEL_ALPHABETIC" }; + key { [ backslash, bar ] }; + + // lower row, left side + key { [ apostrophe, quotedbl, dead_acute ] }; + + // do NOT hardcode this switch; use lv3:ralt_switch option instead! + //include "level3(ralt_switch)" +}; + +// Macintosh dvorak keyboard layout +// Based on the Dvorak keyboard layout found in MacOS +partial alphanumeric_keys +xkb_symbols "dvorak-mac" { + name[Group1]= "English (Dvorak, Macintosh)"; + + key { [ grave, asciitilde, dead_grave, grave ] }; + + key { [ 1, exclam, exclamdown, U2044 ] }; + key { [ 2, at, trademark, EuroSign ] }; + key { [ 3, numbersign, sterling, U2039 ] }; + key { [ 4, dollar, cent, U203A ] }; + key { [ 5, percent, infinity, UFB01 ] }; + key { [ 6, asciicircum, section, UFB02 ] }; + key { [ 7, ampersand, paragraph, doubledagger ] }; + key { [ 8, asterisk, enfilledcircbullet, degree ] }; + key { [ 9, parenleft, ordfeminine, periodcentered ] }; + key { [ 0, parenright, masculine, singlelowquotemark ] }; + key { [ bracketleft, braceleft, leftdoublequotemark, rightdoublequotemark ] }; + key { [ bracketright, braceright, leftsinglequotemark, rightsinglequotemark ] }; + + key { [ apostrophe, quotedbl, ae, AE ] }; + key { [ comma, less, lessthanequal, macron ] }; + key { [ period, greater, greaterthanequal, breve ] }; + key { [ p, P, Greek_pi, U220F ] }; + key { [ y, Y, yen, Aacute ] }; + key { [ f, F, function, Idiaeresis ] }; + key { [ g, G, copyright, doubleacute ] }; + key { [ c, C, ccedilla, Ccedilla ] }; + key { [ r, R, registered, permille ] }; + key { [ l, L, notsign, Ograve ] }; + key { [ slash, question, division, questiondown ] }; + key { [ equal, plus, notequal, plusminus ] }; + + key { [ a, A, aring, Aring ] }; + key { [ o, O, oslash, Oslash ] }; + key { [ e, E, dead_acute, acute ] }; + key { [ u, U, dead_diaeresis, diaeresis ] }; + key { [ i, I, dead_circumflex, asciicircum ] }; + key { [ d, D, partialderivative, Icircumflex ] }; + key { [ h, H, abovedot, Oacute ] }; + key { [ t, T, dagger, caron ] }; + key { [ n, N, dead_tilde, asciitilde ] }; + key { [ s, S, ssharp, Iacute ] }; + key { [ minus, underscore, endash, emdash ] }; + + key { [ section, plusminus ] }; + key { [ semicolon, colon, ellipsis, Uacute ] }; + key { [ q, Q, oe, OE ] }; + key { [ j, J, U2206, Ocircumflex ] }; + key { [ k, K, dead_abovering, UF8FF ] }; + key { [ x, X, U2248, ogonek ] }; + key { [ b, B, integral, idotless ] }; + key { [ m, M, mu, Acircumflex ] }; + key { [ w, W, U2211, doublelowquotemark ] }; + key { [ v, V, squareroot, U25CA ] }; + key { [ z, Z, Greek_OMEGA, cedilla ] }; + + key { [ backslash, bar, guillemotleft, guillemotright ] }; + + include "level3(ralt_switch)" +}; + +// A phonetic layout for typing Russian on a US keyboard. +// Originally by Ivan Popov , 2005. +// (The punctuation symbols that are displaced by Cyrillic letters +// have been put on levels 3 and 4, reachable with AltGr.) +partial alphanumeric_keys +xkb_symbols "rus" { + + include "us(basic)" + + name[Group1]= "Russian (US, phonetic)"; + + key {[ Cyrillic_io, Cyrillic_IO, grave, asciitilde ]}; + key {[ Cyrillic_hardsign, Cyrillic_HARDSIGN, equal, plus ]}; + + key {[ Cyrillic_ya, Cyrillic_YA ]}; + key {[ Cyrillic_ve, Cyrillic_VE ]}; + key {[ Cyrillic_ie, Cyrillic_IE ]}; + key {[ Cyrillic_er, Cyrillic_ER ]}; + key {[ Cyrillic_te, Cyrillic_TE ]}; + key {[ Cyrillic_yeru, Cyrillic_YERU ]}; + key {[ Cyrillic_u, Cyrillic_U ]}; + key {[ Cyrillic_i, Cyrillic_I ]}; + key {[ Cyrillic_o, Cyrillic_O ]}; + key {[ Cyrillic_pe, Cyrillic_PE ]}; + key {[ Cyrillic_sha, Cyrillic_SHA, bracketleft, braceleft ]}; + key {[ Cyrillic_shcha, Cyrillic_SHCHA, bracketright, braceright ]}; + + key {[ Cyrillic_a, Cyrillic_A ]}; + key {[ Cyrillic_es, Cyrillic_ES ]}; + key {[ Cyrillic_de, Cyrillic_DE ]}; + key {[ Cyrillic_ef, Cyrillic_EF ]}; + key {[ Cyrillic_ghe, Cyrillic_GHE ]}; + key {[ Cyrillic_ha, Cyrillic_HA ]}; + key {[ Cyrillic_shorti, Cyrillic_SHORTI ]}; + key {[ Cyrillic_ka, Cyrillic_KA ]}; + key {[ Cyrillic_el, Cyrillic_EL ]}; + key {[ Cyrillic_che, Cyrillic_CHE, semicolon, colon ]}; + key {[ Cyrillic_yu, Cyrillic_YU, apostrophe, quotedbl ]}; + key {[ Cyrillic_e, Cyrillic_E, backslash, bar ]}; + + key {[ Cyrillic_ze, Cyrillic_ZE ]}; + key {[ Cyrillic_softsign, Cyrillic_SOFTSIGN ]}; + key {[ Cyrillic_tse, Cyrillic_TSE ]}; + key {[ Cyrillic_zhe, Cyrillic_ZHE ]}; + key {[ Cyrillic_be, Cyrillic_BE ]}; + key {[ Cyrillic_en, Cyrillic_EN ]}; + key {[ Cyrillic_em, Cyrillic_EM ]}; + + include "level3(ralt_switch)" +}; + +partial alphanumeric_keys +xkb_symbols "mac" { + + name[Group1]= "English (Macintosh)"; + + key.type[group1]="FOUR_LEVEL"; + + // Slightly improvised from http://homepage.mac.com/thgewecke/kblayout.jpg + key { [ section, plusminus, section, plusminus ] }; + key { [ grave, asciitilde, dead_grave, dead_horn ] }; + key { [ 1, exclam, exclamdown, U2044 ] }; + key { [ 2, at, trademark, EuroSign ] }; + key { [ 3, numbersign, sterling, U2039 ] }; + key { [ 4, dollar, cent, U203A ] }; + key { [ 5, percent, infinity, UFB01 ] }; + key { [ 6,asciicircum, section, UFB02 ] }; + key { [ 7, ampersand, paragraph, doubledagger ] }; + key { [ 8, asterisk, enfilledcircbullet, degree ] }; + key { [ 9, parenleft, ordfeminine, periodcentered ] }; + key { [ 0, parenright, masculine,singlelowquotemark] }; + key { [ minus, underscore, endash, emdash ] }; + key { [ equal, plus, notequal, plusminus ] }; + + key { [ q, Q, oe, OE ] }; + key { [ w, W, U2211,doublelowquotemark] }; + key { [ e, E, dead_acute, acute ] }; + key { [ r, R, registered, permille ] }; + key { [ t, T, dagger, dead_caron ] }; + key { [ y, Y, yen, onequarter ] }; + key { [ u, U, dead_diaeresis, diaeresis ] }; + key { [ i, I, dead_circumflex, U02C6 ] }; + key { [ o, O, oslash, Oslash ] }; + key { [ p, P, Greek_pi, U220F ] }; + key { [ bracketleft, braceleft, leftdoublequotemark, rightdoublequotemark ] }; + key { [bracketright, braceright, leftsinglequotemark, rightsinglequotemark ] }; + key { [ backslash, bar, guillemotleft, guillemotright ] }; + + key { [ a, A, aring, Aring ] }; + key { [ s, S, ssharp, dead_stroke ] }; + key { [ d, D, partialderivative, eth ] }; + key { [ f, F, function, dead_hook ] }; + key { [ g, G, copyright, dead_doubleacute ] }; + key { [ h, H, dead_abovedot, dead_belowdot ] }; + key { [ j, J, U2206, onehalf ] }; + key { [ k, K,dead_abovering, UF8FF ] }; + key { [ l, L, notsign, THORN ] }; + key { [ semicolon, colon, U2026, thorn ] }; + key { [apostrophe, quotedbl, ae, AE ] }; + + key { [ z, Z, Greek_OMEGA, dead_cedilla ] }; + key { [ x, X, U2248, dead_ogonek ] }; + // unclear whether "approxeq" is 2248 or 2245 + key { [ c, C, ccedilla, Ccedilla ] }; + key { [ v, V, squareroot, U25CA ] }; + key { [ b, B, integral, idotless ] }; + key { [ n, N, dead_tilde, U02DC ] }; + key { [ m, M, mu, threequarters ] }; + key { [ comma, less, lessthanequal, dead_macron ] }; + key { [ period, greater, greaterthanequal, dead_breve ] }; + key { [ slash, question, division, questiondown ] }; + + include "level3(ralt_switch)" +}; + +// Colemak symbols for xkb on X.Org Server 7.x +// 2006-01-01 Shai Coleman, http://colemak.com/ + +partial alphanumeric_keys +xkb_symbols "colemak" { + + name[Group1]= "English (Colemak)"; + + key { [ grave, asciitilde, dead_tilde, asciitilde ] }; + key { [ 1, exclam, exclamdown, onesuperior ] }; + key { [ 2, at, masculine, twosuperior ] }; + key { [ 3, numbersign, ordfeminine, threesuperior ] }; + key { [ 4, dollar, cent, sterling ] }; + key { [ 5, percent, EuroSign, yen ] }; + key { [ 6, asciicircum, hstroke, Hstroke ] }; + key { [ 7, ampersand, eth, ETH ] }; + key { [ 8, asterisk, thorn, THORN ] }; + key { [ 9, parenleft, leftsinglequotemark, leftdoublequotemark ] }; + key { [ 0, parenright, rightsinglequotemark, rightdoublequotemark ] }; + key { [ minus, underscore, endash, emdash ] }; + key { [ equal, plus, multiply, division ] }; + + key { [ q, Q, adiaeresis, Adiaeresis ] }; + key { [ w, W, aring, Aring ] }; + key { [ f, F, atilde, Atilde ] }; + key { [ p, P, oslash, Oslash ] }; + key { [ g, G, dead_ogonek, asciitilde ] }; + key { [ j, J, dstroke, Dstroke ] }; + key { [ l, L, lstroke, Lstroke ] }; + key { [ u, U, uacute, Uacute ] }; + key { [ y, Y, udiaeresis, Udiaeresis ] }; + key { [ semicolon, colon, odiaeresis, Odiaeresis ] }; + key { [ bracketleft, braceleft, guillemotleft, 0x1002039 ] }; + key { [ bracketright, braceright, guillemotright, 0x100203a ] }; + key { [ backslash, bar, asciitilde, asciitilde ] }; + + key { [ a, A, aacute, Aacute ] }; + key { [ r, R, dead_grave, asciitilde ] }; + key { [ s, S, ssharp, 0x1001e9e ] }; + key { [ t, T, dead_acute, dead_doubleacute ] }; + key { [ d, D, dead_diaeresis, asciitilde ] }; + key { [ h, H, dead_caron, asciitilde ] }; + key { [ n, N, ntilde, Ntilde ] }; + key { [ e, E, eacute, Eacute ] }; + key { [ i, I, iacute, Iacute ] }; + key { [ o, O, oacute, Oacute ] }; + key { [ apostrophe, quotedbl, otilde, Otilde ] }; + + key { [ z, Z, ae, AE ] }; + key { [ x, X, dead_circumflex, asciitilde ] }; + key { [ c, C, ccedilla, Ccedilla ] }; + key { [ v, V, oe, OE ] }; + key { [ b, B, dead_breve, asciitilde ] }; + key { [ k, K, dead_abovering, asciitilde ] }; + key { [ m, M, dead_macron, asciitilde ] }; + key { [ comma, less, dead_cedilla, asciitilde ] }; + key { [ period, greater, dead_abovedot, asciitilde ] }; + key { [ slash, question, questiondown, asciitilde ] }; + + key { [ BackSpace, BackSpace, BackSpace, BackSpace ] }; + key { [ minus, underscore, endash, emdash ] }; + key { [ space, space, space, nobreakspace ] }; + + include "level3(ralt_switch)" +}; + +// Colemak-DH (ANSI) symbols for xkb on X.Org Server 7.x +// 2014-10-25 by SteveP, https://colemakmods.github.io/mod-dh/ + +xkb_symbols "colemak_dh" { + + include "us(colemak)" + + name[Group1]= "English (Colemak-DH)"; + + key { [ b, B, dead_breve, asciitilde ] }; + + key { [ g, G, dead_ogonek, asciitilde ] }; + key { [ m, M, dead_macron, asciitilde ] }; + + key { [ z, Z, ae, AE ] }; + key { [ x, X, dead_circumflex, asciitilde ] }; + key { [ c, C, ccedilla, Ccedilla ] }; + key { [ d, D, dead_diaeresis, asciitilde ] }; + key { [ z, Z, ae, AE ] }; //Z appears here too because key is not present on ANSI keyboards + key { [ h, H, dead_caron, asciitilde ] }; + + key { [ Caps_Lock, Caps_Lock, Caps_Lock, Caps_Lock ] }; +}; + +// Colemak-DH (Wide) symbols for xkb on X.Org Server 7.x +// https://colemakmods.github.io/mod-dh/ + +xkb_symbols "colemak_dh_wide" { + + include "us(colemak_dh)" + name[Group1]= "English (Colemak-DH Wide)"; + + key { [ equal, plus, multiply, division ] }; + key { [ 7, ampersand, eth, ETH ] }; + key { [ 8, asterisk, thorn, THORN ] }; + key { [ 9, parenleft, leftsinglequotemark, leftdoublequotemark ] }; + key { [ 0, parenright, rightsinglequotemark, rightdoublequotemark ] }; + key { [ minus, underscore, endash, emdash ] }; + + key { [ bracketleft, braceleft, guillemotleft, 0x1002039 ] }; + key { [ j, J, dstroke, Dstroke ] }; + key { [ l, L, lstroke, Lstroke ] }; + key { [ u, U, uacute, Uacute ] }; + key { [ y, Y, udiaeresis, Udiaeresis ] }; + key { [ semicolon, colon, odiaeresis, Odiaeresis ] }; + key { [ apostrophe, quotedbl, otilde, Otilde ] }; + + key { [ bracketright, braceright, guillemotright, 0x100203a ] }; + key { [ m, M, dead_macron, asciitilde ] }; + key { [ n, N, ntilde, Ntilde ] }; + key { [ e, E, eacute, Eacute ] }; + key { [ i, I, iacute, Iacute ] }; + key { [ o, O, oacute, Oacute ] }; + + key { [ slash, question, questiondown, asciitilde ] }; + key { [ k, K, dead_abovering, asciitilde ] }; + key { [ h, H, dead_caron, asciitilde ] }; + key { [ comma, less, dead_cedilla, asciitilde ] }; + key { [ period, greater, dead_abovedot, asciitilde ] }; + key { [ slash, question, questiondown, asciitilde ] }; +}; + + +// Colemak-DH (ISO) symbols for xkb on X.Org Server 7.x +// https://colemakmods.github.io/mod-dh/ + +xkb_symbols "colemak_dh_iso" { + + include "us(colemak_dh)" + name[Group1]= "English (Colemak-DH ISO)"; + + key { [ numbersign, asciitilde, backslash, bar ] }; + + key { [ backslash, bar, asciitilde, brokenbar ] }; +}; + +// Colemak-DH (Wide ISO) symbols for xkb on X.Org Server 7.x +// https://colemakmods.github.io/mod-dh/ + +xkb_symbols "colemak_dh_wide_iso" { + + include "us(colemak_dh_wide)" + name[Group1]= "English (Colemak-DH Wide ISO)"; + + key { [ slash, question, questiondown, asciitilde ] }; + key { [ apostrophe, quotedbl, otilde, Otilde ] }; + + key { [ backslash, bar, asciitilde, brokenbar ] }; + key { [ numbersign, asciitilde, backslash, bar ] }; +}; + +// Colemak-DH (ortholinear) symbols for xkb on X.Org Server 7.x +// https://colemakmods.github.io/mod-dh/ + +xkb_symbols "colemak_dh_ortho" { + + include "us(colemak_dh)" + name[Group1]= "English (Colemak-DH Ortholinear)"; + + key { [ z, Z, ae, AE ] }; + key { [ x, X, dead_circumflex, asciitilde ] }; + key { [ c, C, ccedilla, Ccedilla ] }; + key { [ d, D, dead_diaeresis, asciitilde ] }; + key { [ v, V, oe, OE ] }; +}; + + +// I do NOT like dead-keys - the International keyboard as defined by Microsoft +// does not fit my needs. Why use two keystrokes for all simple characters (eg ' +// and generates a single ') just to have an é (eacute) in two strokes +// as well? I type ' more often than é (eacute). +// +// This file works just like a regular keyboard, BUT has all dead-keys +// accessible at level3 (through AltGr). An ë (ediaeresis) is now: AltGr+" +// followed by an e. In other words, this keyboard is not international as long +// as you leave the right Alt key alone. +// +// The original MS International keyboard was intended for Latin1 (iso8859-1). +// With the introduction of iso8859-15, the (important) ligature oe (and OE) +// became available. I added them next to ae. Because I write ediaeresis more +// often than registered, I moved registered to be next to copyright and added +// ediaeresis and idiaeresis. - Adriaan +// +// Note: there is an "altgr-weur" layout (in extras) which is no longer based on +// the Microsoft layout, supports all chars that altgr-intl offers, but is +// optimized for 10 Western European languages. More info: https://altgr-weur.eu + +partial alphanumeric_keys +xkb_symbols "altgr-intl" { + + include "us(intl)" + name[Group1]= "English (intl., with AltGr dead keys)"; + +// five dead keys moved into level3: + + key { [ grave, asciitilde, dead_grave, dead_tilde ] }; + key { [apostrophe,quotedbl, dead_acute, dead_diaeresis ] }; + +// diversions from the MS Intl keyboard: + + key { [ 1, exclam, onesuperior, exclamdown ] }; + key { [ r, R, ediaeresis, Ediaeresis ] }; + key { [ f, F, f, F ] }; + key { [ x, X, oe, OE ] }; + key { [ v, V, registered, trademark ] }; + key { [ b, B, periodcentered, dead_stroke ] }; + +// onequarter etc (not in iso8859-15) moved to get three unshifted deadkeys: + + key { [ 6, asciicircum, dead_circumflex, onequarter ] }; + key { [ 7, ampersand, dead_horn, onehalf ] }; + key { [ 8, asterisk, dead_ogonek, threequarters ] }; + + include "level3(ralt_switch)" +}; + +// This (altgr-weur) layout is based on combined letter frequencies +// for English, German, Dutch, French, Spanish, Portuguese, Italian, +// Danish, Norwegian, Swedish and Finnish: all accented characters for +// those languages are available through AltGr- combinations. Further +// explanation can be found at: https://www.altgr-weur.eu/ +// - Adriaan and Enno + +// Version info (for altgr-weur ONLY): +// $Id: altgr-weur,v 2.0 2021/04/12 11:27:12 adriaan Exp $ + +partial alphanumeric_keys +xkb_symbols "altgr-weur" { + + name[Group1]= "English (Western European AltGr dead keys)"; + + key { [ grave, asciitilde, dead_grave, dead_tilde ] }; + key { [ 1, exclam, exclamdown, dead_abovedot ] }; + key { [ 2, at, twosuperior, dead_doubleacute ] }; + key { [ 3, numbersign, threesuperior, dead_macron ] }; + key { [ 4, dollar, cent, yen ] }; + key { [ 5, percent, EuroSign, sterling ] }; + key { [ 6,asciicircum, dead_circumflex, dead_caron ] }; + key { [ 7, ampersand, doublelowquotemark, singlelowquotemark ] }; + key { [ 8, asterisk, ssharp, dead_greek ] }; + key { [ 9, parenleft, leftdoublequotemark, leftsinglequotemark ] }; + key { [ 0, parenright, rightdoublequotemark, rightsinglequotemark ] }; + key { [ minus, underscore, endash, emdash ] }; + key { [ equal, plus, degree, dead_abovering ] }; + + key { [ q, Q, aring, Aring ] }; + key { [ w, W, ae, AE ] }; + key { [ e, E, ediaeresis, Ediaeresis ] }; + key { [ r, R, egrave, Egrave ] }; + key { [ t, T, oslash, Oslash ] }; + key { [ y, Y, ugrave, Ugrave ] }; + key { [ u, U, udiaeresis, Udiaeresis ] }; + key { [ i, I, idiaeresis, Idiaeresis ] }; + key { [ o, O, odiaeresis, Odiaeresis ] }; + key { [ p, P, ograve, Ograve ] }; + // U203[9A]: single right/left-pointing angle quotation marks + key { [ bracketleft, braceleft, guillemotleft, U2039 ] }; + key { [bracketright,braceright, guillemotright, U203A ] }; + + key { [ a, A, adiaeresis, Adiaeresis ] }; + key { [ s, S, agrave, Agrave ] }; + key { [ d, D, eacute, Eacute ] }; + key { [ f, F, ecircumflex, Ecircumflex ] }; + key { [ g, G, icircumflex, Icircumflex ] }; + key { [ h, H, ucircumflex, Ucircumflex ] }; + key { [ j, J, uacute, Uacute ] }; + key { [ k, K, iacute, Iacute ] }; + key { [ l, L, oacute, Oacute ] }; + key { [ semicolon, colon, ocircumflex, Ocircumflex ] }; + key { [apostrophe, quotedbl, dead_acute, dead_diaeresis ] }; + + key { [ z, Z, aacute, Aacute ] }; + key { [ x, X, acircumflex, Acircumflex ] }; + key { [ c, C, ccedilla, Ccedilla ] }; + key { [ v, V, atilde, Atilde ] }; + key { [ b, B, otilde, Otilde ] }; + key { [ n, N, ntilde, Ntilde ] }; + key { [ m, M, igrave, Igrave ] }; + key { [ comma, less, dead_cedilla, dead_ogonek ] }; + key { [ period, greater, oe, OE ] }; + key { [ slash, question, questiondown, dead_stroke ] }; + // ij ligature IJ ligature + key { [ backslash, bar, U0133, U0132 ] }; + + include "level3(ralt_switch)" +}; + +partial alphanumeric_keys +xkb_symbols "olpc" { + + // #HW-SPECIFIC + + include "us(basic)" + name[Group1]= "English (US)"; + + // OLPC international US English keyboard layout. + // It's a little different from the usual international layout. + // See: http://wiki.laptop.org/go/Image:Keyboard_english.png + + key { [ grave, asciitilde, dead_grave, dead_tilde ] }; + key { [ 1, exclam, exclamdown, exclamdown ] }; + key { [ 2, at, notsign, notsign ] }; + key { [ 3, numbersign, 0x1000300, 0x1000300 ] }; // combining grave + key { [ 4, dollar, 0x1000301, 0x1000301 ] }; // combining acute + key { [ 5, percent, 0x1000306, 0x1000306 ] }; // combining breve above + key { [ 6,asciicircum, 0x100030A, 0x100030A ] }; // combining ring above + key { [ 7, ampersand, 0x1000302, 0x1000302 ] }; // combining circumflex above + key { [ 8, asterisk, 0x100030C, 0x100030C ] }; // combining caron above + key { [ 9, parenleft, 0x1000307, 0x1000307 ] }; // combining dot above + key { [ 0, parenright, 0x1000308, 0x1000308 ] }; // combining diaeresis above + key { [ minus, underscore, 0x1000304, 0x1000304 ] }; // combining macron above + key { [ equal, plus, 0x1000303, 0x1000303 ] }; // combining tilde above + + key { [ q, Q, Greek_omega, Greek_OMEGA ] }; + key { [ w, W, oslash, Oslash ] }; + key { [ e, E, oe, OE ] }; + key { [ r, R, 0x1000327, 0x1000327 ] }; // combining cedilla + key { [ t, T, 0x100032E, 0x100032E ] }; // combining breve below + key { [ y, Y, 0x1000325, 0x1000325 ] }; // combining ring below + key { [ u, U, 0x100032D, 0x100032D ] }; // combining circumflex below + key { [ i, I, 0x100032C, 0x100032C ] }; // combining caron below + key { [ o, O, 0x1000323, 0x1000323 ] }; // combining dot below + key { [ p, P, 0x1000324, 0x1000324 ] }; // combining diaeresis below + key { [ bracketleft, braceleft, 0x1000331, 0x1000331 ] }; // combining macron below + key { [bracketright, braceright, 0x1000330, 0x1000330 ] }; // combining tilde below + + key { [ a, A, ae, AE ] }; + key { [ s, S, ssharp, 0x1001E9E ] }; // uppercase S sharp + key { [ d, D, eth, ETH ] }; + key { [ f, F, thorn, THORN ] }; + key { [ h, H, sterling, sterling ] }; + key { [ j, J, EuroSign, EuroSign ] }; + key { [ semicolon, colon, masculine, ordfeminine ] }; + key { [ apostrophe, quotedbl, currency, currency ] }; + key { [ backslash, bar, section, section ] }; + + key { [ c, C, ccedilla, Ccedilla ] }; + key { [ n, N, ntilde, Ntilde ] }; + key { [ m, M, mu, mu ] }; + key { [ comma, less, guillemotleft, guillemotleft ] }; + key { [ period, greater, guillemotright, guillemotright ] }; + key { [ slash, question, questiondown, questiondown ] }; + + key { [ multiply, division, ISO_Next_Group, ISO_Prev_Group ] }; + + include "level3(ralt_switch)" +}; + +partial alphanumeric_keys +xkb_symbols "olpc2" { + include "us(olpc)" + name[Group1]= "English (the divide/multiply toggle the layout)"; + include "group(olpc)" +}; + +xkb_symbols "olpcm" { + + // #HW-SPECIFIC + + include "us(basic)" + name[Group1]= "English (US)"; + + // Mechanical (non-membrane) OLPC int'l US English keyboard layout. + // See: http://wiki.laptop.org/go/OLPC_English_Non-membrane_Keyboard + + key { [ grave, asciitilde, dead_grave, dead_tilde ] }; + key { [ 1, exclam, exclamdown, exclamdown ] }; + key { [ 2, at, notsign, notsign ] }; + key { [ 3, numbersign, 0x1000300, 0x1000300 ] }; // combining grave + key { [ 4, dollar, 0x1000301, 0x1000301 ] }; // combining acute + key { [ 5, percent, 0x1000306, 0x1000306 ] }; // combining breve above + key { [ 6,asciicircum, 0x100030A, 0x100030A ] }; // combining ring above + key { [ 7, ampersand, 0x1000302, 0x1000302 ] }; // combining circumflex above + key { [ 8, asterisk, 0x100030C, 0x100030C ] }; // combining caron above + key { [ 9, parenleft, 0x1000307, 0x1000307 ] }; // combining dot above + key { [ 0, parenright, 0x1000308, 0x1000308 ] }; // combining diaeresis above + key { [ minus, underscore, 0x1000304, 0x1000304 ] }; // combining macron above + + key { [ q, Q, Greek_omega, Greek_OMEGA ] }; + key { [ w, W, oslash, Oslash ] }; + key { [ e, E, oe, OE ] }; + key { [ r, R, 0x1000327, 0x1000327 ] }; // combining cedilla + key { [ t, T, 0x100032E, 0x100032E ] }; // combining breve below + key { [ y, Y, 0x1000325, 0x1000325 ] }; // combining ring below + key { [ u, U, 0x100032D, 0x100032D ] }; // combining circumflex below + key { [ i, I, 0x100032C, 0x100032C ] }; // combining caron below + key { [ o, O, 0x1000323, 0x1000323 ] }; // combining dot below + key { [ p, P, 0x1000324, 0x1000324 ] }; // combining diaeresis below + key { [ bracketleft, braceleft, 0x1000331, 0x1000331 ] }; // combining macron below + key { [bracketright, braceright, 0x1000330, 0x1000330 ] }; // combining tilde below + + key { [ a, A, ae, AE ] }; + key { [ s, S, ssharp, 0x1001E9E ] }; // uppercase S sharp + key { [ d, D, eth, ETH ] }; + key { [ f, F, thorn, THORN ] }; + key { [ h, H, sterling, sterling ] }; + key { [ j, J, EuroSign, EuroSign ] }; + key { [ semicolon, colon, masculine, ordfeminine ] }; + // no AC11 or AC12 on olpcm + + key { [ c, C, ccedilla, Ccedilla ] }; + key { [ n, N, ntilde, Ntilde ] }; + key { [ m, M, mu, mu ] }; + key { [ comma, less, guillemotleft, guillemotleft ] }; + key { [ period, greater, guillemotright, guillemotright ] }; + key { [ slash, question, questiondown, questiondown ] }; + + key { [ backslash, bar, section, section ] }; + key { [ equal, plus, 0x1000303, 0x1000303 ] }; + key { [ apostrophe, quotedbl, currency, currency ] }; + + include "level3(ralt_switch)" +}; + +// Based on Cherokee Nation Official Layout +// http://www.cherokee.org/extras/downloads/font/Keyboard.htm + +partial alphanumeric_keys modifier_keys +xkb_symbols "chr" { + + name[Group1]= "Cherokee"; + key.type[group1]="ALPHABETIC"; + + key { [ grave, U13CA ] }; + key { [ 1, U13B1 ] }; + key { [ 2, U13C7 ] }; + key { [ 3, U13E7 ] }; + key { [ U13D9, U13B0 ] }; + key { [ U13E6, U13B9 ] }; + key { [ U13DC, U13DD ] }; + key { [ U13CB, U13E1 ] }; + key { [ U13D6, U13BA ] }; + key { [ U13D2, parenleft ] }; + key { [ U13C4, parenright ] }; + key { [ U13BF, U13BC ] }; + key { [ U13F3, U13BD ] }; + + key { [ U13AA, U13C6 ] }; + key { [ U13B3, U13EB ] }; + key { [ U13A1, U13E3 ] }; + key { [ U13DB, U13CF ] }; + key { [ U13D4, U13D8 ] }; + key { [ U13EF, U13F2 ] }; + key { [ U13A4, U13AD ] }; + key { [ U13A2, U13F1 ] }; + key { [ U13A3, U13EC ] }; + key { [ U13C1, U13EA ] }; + key { [ U13D5, U13D1 ] }; + key { [ U13B6, U13E4 ] }; + key { [ U13E9, U13EE ] }; + + key { [ U13A0, U13CC ] }; + key { [ U13CD, U13CE ] }; + key { [ U13D7, U13D0 ] }; + key { [ U13A9, U13C8 ] }; + key { [ U13A6, U13E5 ] }; + key { [ U13AF, U13B2 ] }; + key { [ U13DA, U13AB ] }; + key { [ U13B8, U13A7 ] }; + key { [ U13B5, U13AE ] }; + key { [ U13E8, U13E0 ] }; + key { [ apostrophe, quotedbl ] }; + + key { [ U13AC, U13C3 ] }; + key { [ U13F4, U13ED ] }; + key { [ U13D3, U13DF ] }; + key { [ U13A5, U13DE ] }; + key { [ U13A8, U13F0 ] }; + key { [ U13BE, U13BB ] }; + key { [ U13C5, U13B7 ] }; + key { [ comma, U13E2 ] }; + key { [ period, U13B4 ] }; + key { [ U13C2, U13C9 ] }; +}; + +// Add Hawaiian `okina and kahako to US layout +// Author: Greg Meyer , 2020 +// this mapping follows the one for Windows here: http://www.olelo.hawaii.edu/enehana/winkbd.php +// `okina replaces apostrophe (apostrophe moves to level 3) +// vowels with kahako (macron) are level 3 symbols +partial alphanumeric_keys +xkb_symbols "haw" { + + include "us(basic)" + name[Group1] = "Hawaiian"; + + // `okina replaces single apostrophe + // alt gives the literal apostrophe + key {[ U02BB, quotedbl, apostrophe ] }; + + // kahako + key {[ a, A, amacron, Amacron ]}; + key {[ e, E, emacron, Emacron ]}; + key {[ u, U, umacron, Umacron ]}; + key {[ i, I, imacron, Imacron ]}; + key {[ o, O, omacron, Omacron ]}; + + include "level3(ralt_switch)" +}; + +// Serbian charecters added as third level symbols to US keyboard layout. + +partial alphanumeric_keys +xkb_symbols "hbs" { + + include "us" + name[Group1]= "Serbo-Croatian (US)"; + + key { [ grave, asciitilde ] }; + key { [ 6, dead_caron, asciicircum, asciicircum ] }; + key { [ 8, asterisk, multiply, division ] }; + key { [ minus, underscore, endash, emdash ] }; + key { [ l, L, U01C9, U01C8 ] }; // lj Lj + key { [ n, N, U01CC, U01CB ] }; // nj Nj + key { [ z, Z, U01C6, U01C5 ] }; // dž Dž + key { [ e, E, EuroSign, cent ] }; + key { [ d, D, dstroke, Dstroke ] }; + key { [ dead_acute, quotedbl, apostrophe, apostrophe ] }; + key { [ space, space, nobreakspace, nobreakspace ] }; + key { [ comma, less, U3003, guillemotright ] }; + key { [ period, greater, ellipsis, guillemotleft ] }; + + include "level3(ralt_switch)" +}; + +// Workman Keyboard Layout symbols for xkb on X.Org Server 7.x +// 09-06-2010 OJ Bucao. http://www.workmanlayout.com + +partial alphanumeric_keys +xkb_symbols "workman" { + + include "us(basic)" + name[Group1]= "English (Workman)"; + + key { [ q, Q ] }; + key { [ d, D ] }; + key { [ r, R ] }; + key { [ w, W ] }; + key { [ b, B ] }; + key { [ j, J ] }; + key { [ f, F ] }; + key { [ u, U ] }; + key { [ p, P ] }; + key { [ semicolon, colon ] }; + + key { [ a, A ] }; + key { [ s, S ] }; + key { [ h, H ] }; + key { [ t, T ] }; + key { [ g, G ] }; + key { [ y, Y ] }; + key { [ n, N ] }; + key { [ e, E ] }; + key { [ o, O ] }; + key { [ i, I ] }; + + key { [ z, Z ] }; + key { [ x, X ] }; + key { [ m, M ] }; + key { [ c, C ] }; + key { [ v, V ] }; + key { [ k, K ] }; + key { [ l, L ] }; + + key { [ BackSpace, Escape ] }; +}; + +partial alphanumeric_keys +xkb_symbols "workman-intl" { + + include "us(intl)" + name[Group1]= "English (Workman, intl., with dead keys)"; + + key { [ q, Q, adiaeresis, Adiaeresis ] }; + key { [ d, D, eth, ETH ] }; + key { [ r, R, registered, trademark ] }; + key { [ w, W, aring, Aring ] }; + key { [ b, B, b, B ] }; + key { [ j, J, idiaeresis, Idiaeresis ] }; + key { [ f, F, ediaeresis, Ediaeresis ] }; + key { [ u, U, uacute, Uacute ] }; + key { [ p, P, odiaeresis, Odiaeresis ] }; + key { [ semicolon, colon, paragraph, degree ] }; + + key { [ a, A, aacute, Aacute ] }; + key { [ s, S, ssharp, section ] }; + key { [ h, H, h, H ] }; + key { [ t, T, thorn, THORN ] }; + key { [ g, G, g, G ] }; + key { [ y, Y, udiaeresis, Udiaeresis ] }; + key { [ n, N, ntilde, Ntilde ] }; + key { [ e, E, eacute, Eacute ] }; + key { [ o, O, oacute, Oacute ] }; + key { [ i, I, iacute, Iacute ] }; + + key { [ z, Z, ae, AE ] }; + key { [ x, X, periodcentered, dead_stroke ] }; + key { [ m, M, mu, plusminus ] }; + key { [ c, C, copyright, cent ] }; + key { [ v, V, v, V ] }; + key { [ k, K, oe, OE ] }; + key { [ l, L, oslash, Oslash ] }; + + key { [ BackSpace, Escape, BackSpace, BackSpace ] }; + + include "level3(ralt_switch)" +}; + +// US Workman-P layout based on US Workman with top row digits switched only +// US Workman layout site: https://workmanlayout.org +partial alphanumeric_keys +xkb_symbols "workman-p" { + include "us(workman)" + name[Group1]= "English (Workman-P)"; + + key { [ exclam, 1 ] }; + key { [ at, 2 ] }; + key { [ numbersign, 3 ] }; + key { [ dollar, 4 ] }; + key { [ percent, 5 ] }; + key { [ asciicircum, 6 ] }; + key { [ ampersand, 7 ] }; + key { [ asterisk, 8 ] }; + key { [ parenleft, 9 ] }; + key { [ parenright, 0 ] }; +}; + +// Norman keyboard layout symbols for xkb on X.Org Server 7.x +// Written 11/23/2012, revised 3/7/2013 by David Norman http://normanlayout.info +// To the extent possible under law, the author(s) have dedicated all +// copyright and related and neighboring rights to this software to the +// public domain worldwide. This software is distributed without any warranty. + +partial alphanumeric_keys +xkb_symbols "norman" { + + include "us(basic)" + name[Group1]= "English (Norman)"; + + key { [ q, Q ] }; + key { [ w, W ] }; + key { [ d, D ] }; + key { [ f, F ] }; + key { [ k, K ] }; + key { [ j, J ] }; + key { [ u, U ] }; + key { [ r, R ] }; + key { [ l, L ] }; + key { [ semicolon, colon ] }; + + key { [ a, A ] }; + key { [ s, S ] }; + key { [ e, E ] }; + key { [ t, T ] }; + key { [ g, G ] }; + key { [ y, Y ] }; + key { [ n, N ] }; + key { [ i, I ] }; + key { [ o, O ] }; + key { [ h, H ] }; + + key { [ z, Z ] }; + key { [ x, X ] }; + key { [ c, C ] }; + key { [ v, V ] }; + key { [ b, B ] }; + key { [ p, P ] }; + key { [ m, M ] }; + + key { [ BackSpace ] }; + + include "level3(ralt_switch)" +}; + +// Carpalx layout created by Martin Krzywinski +// http://mkweb.bcgsc.ca/carpalx/ + +partial alphanumeric_keys +xkb_symbols "carpalx" { + + name[Group1]= "English (Carpalx)"; + + key { [ grave, asciitilde ] }; + key { [ 1, exclam ] }; + key { [ 2, at ] }; + key { [ 3, numbersign ] }; + key { [ 4, dollar ] }; + key { [ 5, percent ] }; + key { [ 6, asciicircum ] }; + key { [ 7, ampersand ] }; + key { [ 8, asterisk ] }; + key { [ 9, parenleft ] }; + key { [ 0, parenright ] }; + key { [ minus, underscore ] }; + key { [ equal, plus ] }; + + key { [ q, Q ] }; + key { [ g, G ] }; + key { [ m, M ] }; + key { [ l, L ] }; + key { [ w, W ] }; + key { [ y, Y ] }; + key { [ f, F ] }; + key { [ u, U ] }; + key { [ b, B ] }; + key { [ semicolon, colon ] }; + key { [ bracketleft, braceleft ] }; + key { [ bracketright, braceright ] }; + + key { [ d, D ] }; + key { [ s, S ] }; + key { [ t, T ] }; + key { [ n, N ] }; + key { [ r, R ] }; + key { [ i, I ] }; + key { [ a, A ] }; + key { [ e, E ] }; + key { [ o, O ] }; + key { [ h, H ] }; + key { [ apostrophe, quotedbl ] }; + + key { [ z, Z ] }; + key { [ x, X ] }; + key { [ c, C ] }; + key { [ v, V ] }; + key { [ j, J ] }; + key { [ k, K ] }; + key { [ p, P ] }; + key { [ comma, less ] }; + key { [ period, greater ] }; + key { [ slash, question ] }; + + key { [ backslash, bar ] }; +}; + +// Carpalx layout created by Martin Krzywinski +// http://mkweb.bcgsc.ca/carpalx/ +// Merged with us(intl) and modified to move +// accented vowels closer to the plain vowels + +partial alphanumeric_keys +xkb_symbols "carpalx-intl" { + + name[Group1]= "English (Carpalx, intl., with dead keys)"; + + key { [dead_grave, dead_tilde, grave, asciitilde ] }; + key { [ 1, exclam, exclamdown, onesuperior ] }; + key { [ 2, at, twosuperior, dead_doubleacute ] }; + key { [ 3, numbersign, threesuperior, dead_macron ] }; + key { [ 4, dollar, currency, sterling ] }; + key { [ 5, percent, EuroSign, dead_cedilla ] }; + key { [ 6, dead_circumflex, onequarter, asciicircum ] }; + key { [ 7, ampersand, onehalf, dead_horn ] }; + key { [ 8, asterisk, threequarters, dead_ogonek ] }; + key { [ 9, parenleft, leftsinglequotemark, dead_breve ] }; + key { [ 0, parenright, rightsinglequotemark, dead_abovering ] }; + key { [ minus, underscore, yen, dead_belowdot ] }; + key { [ equal, plus, multiply, division ] }; + + key { [ q, Q, degree, paragraph ] }; + key { [ g, G, U011F, U011E ] }; + key { [ m, M, mu, plusminus ] }; + key { [ l, L, copyright, cent ] }; + key { [ w, W, w, W ] }; + key { [ y, Y, idiaeresis, Idiaeresis ] }; + key { [ f, F, adiaeresis, Adiaeresis ] }; + key { [ u, U, udiaeresis, Udiaeresis ] }; + key { [ b, B, odiaeresis, Odiaeresis ] }; + key { [ semicolon, colon, oslash, Oslash ] }; + key { [ bracketleft, braceleft, guillemotleft, leftdoublequotemark ] }; + key { [bracketright, braceright, guillemotright, rightdoublequotemark ] }; + + key { [ d, D, eth, ETH ] }; + key { [ s, S, ssharp, section ] }; + key { [ t, T, thorn, THORN ] }; + key { [ n, N, ntilde, Ntilde ] }; + key { [ r, R, registered, trademark ] }; + key { [ i, I, iacute, Iacute ] }; + key { [ a, A, aacute, Aacute ] }; + key { [ e, E, eacute, Eacute ] }; + key { [ o, O, oacute, Oacute ] }; + key { [ h, H, uacute, Uacute ] }; + key { [dead_acute, dead_diaeresis, apostrophe, quotedbl ] }; + + key { [ z, Z, periodcentered, dead_stroke ] }; + key { [ x, X, U015F, U015E ] }; + key { [ c, C, ccedilla, Ccedilla ] }; + key { [ v, V, ae, AE ] }; + key { [ j, J, oe, OE ] }; + key { [ k, K, U0131, U0130 ] }; + key { [ p, P, aring, Aring ] }; + key { [ comma, less, ediaeresis, Ediaeresis ] }; + key { [ period, greater, dead_abovedot, dead_caron ] }; + key { [ slash, question, questiondown, dead_hook ] }; + key { [ backslash, bar, notsign, brokenbar ] }; + + key { [ backslash, bar, backslash, bar ] }; + + include "level3(ralt_switch)" +}; + +// Carpalx layout created by Martin Krzywinski +// http://mkweb.bcgsc.ca/carpalx/ +// Merged with us(intl) and us(altgr-intl) and modified to move +// accented vowels closer to the plain vowels + +partial alphanumeric_keys +xkb_symbols "carpalx-altgr-intl" { + + include "us(carpalx-intl)" + name[Group1]= "English (Carpalx, intl., with AltGr dead keys)"; + + key { [ grave, asciitilde, dead_grave, dead_tilde ] }; + key { [apostrophe,quotedbl, dead_acute, dead_diaeresis ] }; + + key { [ 1, exclam, onesuperior, exclamdown ] }; + + key { [ 6, asciicircum, dead_circumflex, onequarter ] }; + key { [ 7, ampersand, dead_horn, onehalf ] }; + key { [ 8, asterisk, dead_ogonek, threequarters ] }; + + include "level3(ralt_switch)" +}; + +// Carpalx layout created by Martin Krzywinski +// Full optimization variant without fixed QWERTY-like ZXCV keys +// http://mkweb.bcgsc.ca/carpalx/ + +partial alphanumeric_keys +xkb_symbols "carpalx-full" { + + include "us(carpalx)" + name[Group1]= "English (Carpalx, full optimization)"; + + key { [ b, B ] }; + key { [ y, Y ] }; + key { [ v, V ] }; + + key { [ f, F ] }; +}; + +// Carpalx layout created by Martin Krzywinski +// Full optimization variant without fixed QWERTY-like ZXCV keys +// http://mkweb.bcgsc.ca/carpalx/ +// Merged with us(intl) and modified to move +// accented vowels closer to the plain vowels + +partial alphanumeric_keys +xkb_symbols "carpalx-full-intl" { + + include "us(carpalx-intl)" + name[Group1]= "English (Carpalx, full optimization, intl., with dead keys)"; + + key { [ b, B, idiaeresis, Idiaeresis ] }; + key { [ y, Y, adiaeresis, Adiaeresis ] }; + key { [ v, V, odiaeresis, Odiaeresis ] }; + + key { [ f, F, ae, AE ] }; +}; + +// Carpalx layout created by Martin Krzywinski +// Full optimization variant without fixed QWERTY-like ZXCV keys +// http://mkweb.bcgsc.ca/carpalx/ +// Merged with us(intl) and us(altgr-intl) and modified to move +// accented vowels closer to the plain vowels + +partial alphanumeric_keys +xkb_symbols "carpalx-full-altgr-intl" { + + include "us(carpalx-altgr-intl)" + name[Group1]= "English (Carpalx, full optimization, intl., with AltGr dead keys)"; + + key { [ b, B, idiaeresis, Idiaeresis ] }; + key { [ y, Y, adiaeresis, Adiaeresis ] }; + key { [ v, V, odiaeresis, Odiaeresis ] }; + + key { [ f, F, ae, AE ] }; +}; + +// US Symbolic +// Author: Daniele Baisero +// Based on the default keyboard map from 'symbols/us', edited for scientific literature. +// Added simple Greek letters to alphas, and common symbols everywhere else. +// TLDE and BKSL are AltGr-inverse, to facilitate placement of ESC over TLDE on 60% keyboards. +// LGST (Iso Key) contains rarely used floor and ceiling brackets. +partial alphanumeric_keys modifier_keys +xkb_symbols "symbolic" { + + name[Group1]= "English (US, Symbolic)"; + + key { [ grave, asciitilde, backslash, bar ] }; // ` ~ \ | + key { [ 1, exclam, onesuperior, notsign ] }; // 1 ! ¹ ¬ + key { [ 2, at, twosuperior, therefore ] }; // 2 @ ² ∴ + key { [ 3, numbersign, threesuperior, sterling ] }; // 3 # ³ £ + key { [ 4, dollar, foursuperior, EuroSign ] }; // 4 $ ⁴ € + key { [ 5, percent, fivesuperior, permille ] }; // 5 % ⁵ ‰ + key { [ 6, asciicircum, sixsuperior, squareroot ] }; // 6 ^ ⁶ √ + key { [ 7, ampersand, sevensuperior, section ] }; // 7 & ⁷ § + key { [ 8, asterisk, eightsuperior, infinity ] }; // 8 * ⁸ ∞ + key { [ 9, parenleft, ninesuperior, periodcentered ] }; // 9 ( ⁹ · + key { [ 0, parenright, zerosuperior, degree ] }; // 0 ) ⁰ ° + key { [ minus, underscore, multiply, division ] }; // - _ × ÷ + key { [ equal, plus, notequal, plusminus ] }; // = + ≠ ± + + key { [ q, Q, U2200, U2203 ] }; // q Q ∀ ∃ + key { [ w, W, elementof, notelementof ] }; // w W ∈ ∉ + key { [ e, E, Greek_epsilon, Greek_EPSILON ] }; // e E ε Ε + key { [ r, R, Greek_rho, Greek_RHO ] }; // p P ρ Ρ + key { [ t, T, Greek_tau, Greek_TAU ] }; // t T τ Τ + key { [ y, Y, Greek_upsilon, Greek_UPSILON ] }; // y Y υ Υ + key { [ u, U, Greek_theta, Greek_THETA ] }; // u U θ Θ + key { [ i, I, Greek_iota, Greek_IOTA ] }; // i I ι Ι + key { [ o, O, Greek_omicron, Greek_OMICRON ] }; // o O ο Ο + key { [ p, P, Greek_pi, Greek_PI ] }; // p P π Π + key { [ bracketleft, braceleft, union, intersection ] }; // [ { ∪ ∩ + key { [ bracketright, braceright, includedin, includes ] }; // ] } ⊂ ⊃ + + key { [ a, A, Greek_alpha, Greek_ALPHA ] }; // a A α Α + key { [ s, S, Greek_sigma, Greek_SIGMA ] }; // s S σ Σ + key { [ d, D, Greek_delta, Greek_DELTA ] }; // d D δ Δ + key { [ f, F, Greek_phi, Greek_PHI ] }; // f F φ Φ + key { [ g, G, Greek_gamma, Greek_GAMMA ] }; // g G γ Γ + key { [ h, H, Greek_eta, Greek_ETA ] }; // h H η Η + key { [ j, J, Greek_xi, Greek_XI ] }; // j J ξ Ξ + key { [ k, K, Greek_kappa, Greek_KAPPA ] }; // k K κ Κ + key { [ l, L, Greek_lamda, Greek_LAMDA ] }; // l L λ Λ + key { [ semicolon, colon, downarrow, uparrow ] }; // ; : ↓ ↑ + key { [ apostrophe, quotedbl, rightarrow, leftarrow ] }; // ' " → ← + + key { [ z, Z, Greek_zeta, Greek_ZETA ] }; // z Z ζ Ζ + key { [ x, X, Greek_chi, Greek_CHI ] }; // x X χ Χ + key { [ c, C, Greek_psi, Greek_PSI ] }; // c C ψ Ψ + key { [ v, V, Greek_omega, Greek_OMEGA ] }; // v V ω Ω + key { [ b, B, Greek_beta, Greek_BETA ] }; // b B β Β + key { [ n, N, Greek_nu, Greek_NU ] }; // n N ν Ν + key { [ m, M, Greek_mu, Greek_MU ] }; // m M μ Μ + key { [ comma, less, lessthanequal, guillemotleft ] }; // , < ≤ « + key { [ period, greater, greaterthanequal, guillemotright ] }; // . > ≥ » + key { [ slash, question, U203D, U2766 ] }; // / ? ‽ ❦ + + key { [ backslash, bar, grave, asciitilde ] }; // \ | ` ~ + key { [ U230A, U230B, U2308, U2309 ] }; // ⌊ ⌋ ⌈ ⌉ + + include "level3(ralt_switch)" +}; + +// EXTRAS: + +// Czech, Slovak and German charecters added as third level symbols to US keyboard layout. +partial alphanumeric_keys +xkb_symbols "cz_sk_de" { + + include "us" + name[Group1]="Czech, Slovak and German (US)"; + + key { [grave, asciitilde, uring, Uring ] }; + key { [ 1, exclam, uacute, Uacute ] }; + key { [ 2, at, ecaron, Ecaron ] }; + key { [ 3, numbersign, scaron, Scaron ] }; + key { [ 4, dollar, ccaron, Ccaron ] }; + key { [ 5, percent, rcaron, Rcaron ] }; + key { [ 6, asciicircum, zcaron, Zcaron ] }; + key { [ 7, ampersand, yacute, Yacute ] }; + key { [ 8, asterisk, aacute, Aacute ] }; + key { [ 9, parenleft, iacute, Iacute ] }; + key { [ 0, parenright, eacute, Eacute ] }; + key { [minus, underscore, ssharp, 0x1001E9E ] }; + key { [equal, plus, dead_acute, dead_caron ] }; + + key { [ e, E, EuroSign, Eacute ] }; + + key { [bracketleft, braceleft, udiaeresis, Udiaeresis ] }; + key { [ semicolon, colon, odiaeresis, Odiaeresis ] }; + key { [apostrophe, quotedbl,adiaeresis, Adiaeresis ] }; + + key { [ a, A, aacute, Aacute ] }; + key { [ i, I, iacute, Iacute ] }; + key { [ o, O, oacute, Oacute ] }; + key { [ y, Y, yacute, Yacute ] }; + key { [ u, U, uring, Uring ] }; + + key { [ s, S, scaron, Scaron ] }; + key { [ z, Z, zcaron, Zcaron ] }; + key { [ c, C, ccaron, Ccaron ] }; + key { [ r, R, rcaron, Rcaron ] }; + key { [ t, T, tcaron, Tcaron ] }; + key { [ d, D, dcaron, Dcaron ] }; + key { [ n, N, ncaron, Ncaron ] }; + key { [ l, L, lcaron, Lcaron ] }; + key { [ p, P,ocircumflex, Ocircumflex ] }; + + key { [ space, space, nobreakspace, nobreakspace] }; + + include "level3(ralt_switch)" +}; + +// This is the above Jirka's us(cz_sk_de) layout variant extended with Polish, Spanish, Finnish and Swedish characters. +// This layout variant is primarily targeted to Czech and Slovak polyglots and SW engineers (like the original above one). +partial alphanumeric_keys +xkb_symbols "cz_sk_pl_de_es_fi_sv" { + + include "us" + name[Group1]="Czech, Slovak, Polish, Spanish, Finnish, Swedish and German (US)"; + + key { [grave, asciitilde, uring, Uring ] }; + key { [ 1, exclam, uacute, Uacute ] }; + key { [ 2, at, ecaron, Ecaron ] }; + key { [ 3, numbersign, scaron, Scaron ] }; + key { [ 4, dollar, ccaron, Ccaron ] }; + key { [ 5, percent, rcaron, Rcaron ] }; + key { [ 6, asciicircum, zcaron, Zcaron ] }; + key { [ 7, ampersand, yacute, Yacute ] }; + key { [ 8, asterisk, aacute, Aacute ] }; + key { [ 9, parenleft, iacute, Iacute ] }; + key { [ 0, parenright, eacute, Eacute ] }; + key { [minus, underscore, ssharp, 0x1001E9E ] }; + key { [equal, plus, dead_acute, dead_caron ] }; + + key { [ e, E, EuroSign, Eacute ] }; + + key { [bracketleft, braceleft, udiaeresis, Udiaeresis ] }; + key { [ semicolon, colon, odiaeresis, Odiaeresis ] }; + key { [apostrophe, quotedbl,adiaeresis, Adiaeresis ] }; + + key { [ a, A, aacute, Aacute ] }; + key { [ i, I, iacute, Iacute ] }; + key { [ o, O, oacute, Oacute ] }; + key { [ y, Y, yacute, Yacute ] }; + key { [ u, U, uring, Uring ] }; + + key { [ s, S, scaron, Scaron ] }; + key { [ z, Z, zcaron, Zcaron ] }; + key { [ c, C, ccaron, Ccaron ] }; + key { [ r, R, rcaron, Rcaron ] }; + key { [ t, T, tcaron, Tcaron ] }; + key { [ d, D, dcaron, Dcaron ] }; + key { [ n, N, ncaron, Ncaron ] }; + key { [ l, L, lcaron, Lcaron ] }; + key { [ p, P,ocircumflex, Ocircumflex ] }; + + key { [ space, space, nobreakspace, nobreakspace] }; + + // Polish + key { [ q, Q, aogonek, Aogonek ] }; + key { [ w, W, eogonek, Eogonek ] }; + key { [bracketright, braceright, guillemotleft, guillemotright ] }; + key { [ f, F, sacute, Sacute ] }; + key { [ g, G, copyright, registered ] }; + key { [ h, H, cent, trademark ] }; + key { [ j, J, plusminus, degree ] }; + key { [ k, K, lstroke, Lstroke ] }; + //alias = ; + key { [ backslash, bar, aring, Aring ] }; + //Requires pc105 compatibility + key { [ endash, emdash, zabovedot, Zabovedot ] }; + key { [ x, X, zacute, Zacute ] }; + key { [ v, V, cacute, Cacute ] }; + key { [ b, B, ntilde, Ntilde ] }; + key { [ m, M, nacute, Nacute ] }; + key { [ comma, less,lessthanequal, multiply ] }; + key { [ period, greater, greaterthanequal, division ] }; + key { [ slash, question, exclamdown, questiondown ] }; + + include "level3(ralt_switch)" +}; + +// 03 December 2017 - Added us(scn), please refer to +// Cadèmia Siciliana +partial alphanumeric_keys +xkb_symbols "scn" { + + include "us(intl)" + name[Group1]="Sicilian (US keyboard)"; + + key { [ e, E, schwa, SCHWA ] }; + key { [ d, D, U1E0D, U1E0C ] }; + key { [ f, F, U0111, U0110 ] }; + key { [ h, H, U1E25, U1E24 ] }; + key { [ x, X, U03C7, U03A7 ] }; + key { [ period, greater, U1D58, dead_caron ] }; + + include "level3(ralt_switch)" +}; + +// XCompose is out! Unicode combining is in! For those of us who live +// on the edge: A keymap using Unicode combining characters instead of +// deadkeys. This variation does not deviate from the lame MS-style +// US-intl layout; but it uses AltGr for combining, like altgr-intl. +// +// This might break your font layout systems (because they suck), +// caveat emptor. Also, most of today's software will count +// individual combining marks for selection, deletion, character +// counting &c., and won't be smart enough to do canonical equivalence +// when searching, &c. +// +// With Unicode combining you use "handwriting order", not +// "typewriting order" as with deadkeys. That is, you first type the +// base character, then the diacritics/accents/modifiers. This has +// the advantage of avoiding hidden states --- each keypress changes +// something on screen. +// +// TODO: as of now, this duplicates all us(intl) functionality with +// combining. With care, perhaps we could add more combining marks +// not present in intl, and support all major languages. +partial alphanumeric_keys +xkb_symbols "intl-unicode" { + + include "us(intl)" + include "level3(ralt_switch)" + + name[Group1]= "English (US, intl., AltGr Unicode combining)"; + + key { [ grave, asciitilde, U0300, U0303 ] }; // grave, tilde + key { [ 2, at, twosuperior, U030B ] }; // double acute + key { [ 3, numbersign, threesuperior, U0304 ] }; // macron + key { [ 6, asciicircum, onequarter, U0302 ] }; // circumflex + key { [ 7, ampersand, onehalf, U031B ] }; // horn + key { [ 8, asterisk, threequarters, U0328 ] }; // ogonek + key { [ 9, parenleft, leftsinglequotemark, U0306 ] }; // breve + key { [ 0, parenright, rightsinglequotemark, U030A ] }; // abovering + + key { [ minus, underscore, yen, U0323 ] }; // belowdot + key { [ apostrophe, quotedbl, U0301, U0308 ] }; // acute, diaeresis + key { [ period, greater, U0307, U030C ] }; // abovedot, caron + key { [ slash, question, questiondown, U0309 ] }; // hook + + // alt-intl compatibility + key { [ comma, less, U0327, U030C ] }; // cedilla, caron + key { [ semicolon, colon, U0328, U0308 ] }; // ogonek, diaeresis + key { [ equal, plus, U030B, U031B ] }; // doubleacute, horn + + // We don't do combining latin letters and combining enclosures, + // because support for those is very rare. +}; + +// XCompose is out! Unicode combining is in! For those of us who live +// on the edge: A keymap using Unicode combining characters instead of +// deadkeys. This variation does break compatibility with us-intl, +// whenever I thought it would be more mnemonic or Unicodeish. +partial alphanumeric_keys +xkb_symbols "alt-intl-unicode" { + + include "us(intl-unicode)" + + name[Group1]= "English (US, intl., AltGr Unicode combining, alt.)"; + + // easier macron; em-dash. + // em-dash is available via compose, but I added here since it's such + // an important typographic character. + key { [ minus, underscore, U0304, U2014 ] }; + + // belowdot, abovedot (caron at coma/less key, per above) + key { [ period, greater, U0323, U0307 ] }; +}; + +partial alphanumeric_keys +xkb_symbols "ats" { + + include "us" + name[Group1]= "Atsina"; + + //Using Dead key to get COMBINING COMMA ABOVE for ejectives on + //q, l, t, s, m, g, k, p, w, y, r + //XCompose key is used for the other accute and grave. + + key { [ e, E, eacute, Eacute ] }; + key { [ u, U, uacute, Uacute ] }; + key { [ i, I, iacute, Iacute ] }; + key { [ o, O, oacute, Oacute ] }; + key { [ bracketleft, braceleft, U03B8 ] }; + key { [ bracketright, braceright, U010D, U010C ] }; + //U+010C (uppercase Č) and U+010D (lowercase č). + + key { [ a, A, aacute, Aacute ] }; + + //Small letter Open use compose to key get acute accent + key { [ c, C, U0254, U0186 ] }; + key { [ comma, less, U0313 ] }; + key { [ slash, question, U0294 ] }; + + include "level3(ralt_switch)" + include "compose(rctrl)" +}; + +partial alphanumeric_keys +xkb_symbols "crd" { + + include "us" + name[Group1]= "Coeur d'Alene Salish"; + + key { [ w, W, U02B7, U02B7 ] }; + key { [ 7, ampersand, U0294 ] }; + key { [ q, Q, U221A ] }; + key { [ v, V, schwa ] }; + key { [ backslash, bar, U026B ] }; + key { [ e, E, U025B ] }; + key { [ i, I, U026A ] }; + key { [ j, J, U01F0 ] }; + key { [ 6, asciicircum, U0295 ] }; + key { [ s, S, U0161 ] }; + key { [ c, C, U010D ] }; + key { [ o, O, U0254 ] }; + key { [ period, greater, U0323 ] }; + + include "level3(ralt_switch)" + include "compose(rctrl)" +}; + + +partial alphanumeric_keys + xkb_symbols "sun_type6" { + include "sun_vndr/us(sun_type6)" +}; + +// Implementation of the 3l keyboard layout +// See https://github.com/jackrosenthal/threelayout for specification +partial alphanumeric_keys modifier_keys +xkb_symbols "3l" { + name[Group1] = "English (3l)"; + + key.type[Group1] = "ONE_LEVEL"; + key { [ Escape ] }; + key { [ Tab ] }; + key { [ ISO_Level3_Shift ] }; // Sym Modifier + key { [ ISO_Level5_Shift ] }; // Cur/Num Modifier + + // Top row numbers - not part of spec, but given for convenience + key.type[Group1] = "TWO_LEVEL"; + key { [ grave, asciitilde ] }; + key { [ 1, exclam ] }; + key { [ 2, at ] }; + key { [ 3, numbersign ] }; + key { [ 4, dollar ] }; + key { [ 5, percent ] }; + key { [ 6, asciicircum ] }; + key { [ 7, ampersand ] }; + key { [ 8, asterisk ] }; + key { [ 9, parenleft ] }; + key { [ 0, parenright ] }; + key { [ minus, underscore ] }; + key { [ equal, plus ] }; + + // Main keys + // Order of mods (defined by EIGHT_LEVEL_SEMIALPHABETIC) is: + // [ None, Shift, Sym, Shift+Sym, Num, Shift+Num, Sym+Num, Shift+Sym+Num ] + key.type[Group1] = "EIGHT_LEVEL_SEMIALPHABETIC"; + + // Second row + key { [ q, Q, quotedbl, Greek_omicron, Prior, Prior, U21CD, Greek_OMICRON ] }; + key { [ f, F, underscore, Greek_phi, BackSpace, BackSpace, U21A4, Greek_PHI ] }; + key { [ u, U, bracketleft, Greek_upsilon, Up, Up, U2191, Greek_UPSILON ] }; + key { [ y, Y, bracketright, Greek_psi, Delete, Delete, U21A6, Greek_PSI ] }; + key { [ z, Z, asciicircum, Greek_zeta, Next, Next, U21CF, Greek_ZETA ] }; + key { [ x, X, exclam, Greek_xi, NoSymbol, NoSymbol, U2260, Greek_XI ] }; + key { [ k, K, less, Greek_kappa, 1, A, U2264, Greek_KAPPA ] }; + key { [ c, C, greater, Greek_chi, 2, B, U2265, Greek_CHI ] }; + key { [ w, W, equal, Greek_omega, 3, C, U2261, Greek_OMEGA ] }; + key { [ b, B, ampersand, Greek_beta, NoSymbol, NoSymbol, U2248, Greek_BETA ] }; + key { [ bracketleft, braceleft, NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol ] }; + key { [ bracketright, braceright, NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol ] }; + + // Home row + key { [ o, O, slash, Greek_omega, Home, Home, U21D0, Greek_OMEGA ] }; + key { [ h, H, minus, Greek_theta, Left, Left, U2190, Greek_THETA ] }; + key { [ e, E, braceleft, Greek_epsilon, Down, Down, U2193, Greek_EPSILON ] }; + key { [ a, A, braceright, Greek_alpha, Right, Right, U2192, Greek_ALPHA ] }; + key { [ i, I, asterisk, Greek_iota, End, End, U21D2, Greek_IOTA ] }; + key { [ d, D, question, Greek_delta, period, colon, U2286, Greek_DELTA ] }; + key { [ r, R, parenleft, Greek_rho, 4, D, U2227, Greek_RHO ] }; + key { [ t, T, parenright, Greek_tau, 5, E, U2228, Greek_TAU ] }; + key { [ n, N, apostrophe, Greek_eta, 6, F, U2200, Greek_ETA ] }; + key { [ s, S, colon, Greek_sigma, NoSymbol, NoSymbol, U2203, Greek_SIGMA ] }; + + // Bottom row + key { [ comma, comma, numbersign, NoSymbol, slash, NoSymbol, U21AE, NoSymbol ] }; + key { [ m, M, dollar, Greek_mu, asterisk, NoSymbol, U2194, Greek_MU ] }; + key { [ period, period, bar, NoSymbol, minus, NoSymbol, U21CE, NoSymbol ] }; + key { [ j, J, asciitilde, Greek_SIGMA, plus, NoSymbol, U21D4, NoSymbol ] }; + key { [ semicolon, semicolon, grave, NoSymbol, comma, NoSymbol, U2282, NoSymbol ] }; + key { [ g, G, plus, Greek_gamma, 0, NoSymbol, U2229, Greek_GAMMA ] }; + key { [ l, L, percent, Greek_lambda, 7, parenleft, U222A, Greek_LAMBDA ] }; + key { [ p, P, backslash, Greek_pi, 8, parenright, U2208, Greek_PI ] }; + key { [ v, V, at, Greek_nu, 9, NoSymbol, U2209, Greek_NU ] }; +}; + +// Chromebooks typically have the key which is normally in the caps +// lock position mapped to keycode 133 (LWIN). For 3l, it is critical +// that the key in this positon correspond to tab, so there is a +// variant available for chromebook hardware. +partial modifier_keys +xkb_symbols "3l-cros" { + include "us(3l)" + name[Group1] = "English (3l, Chromebook)"; + key { + type[Group1] = "ONE_LEVEL", + symbols[Group1] = [ Tab ] + }; +}; + +// A 3l variant for emacs users, which maps control to caps lock and (re)maps +// tab back to tab. +partial modifier_keys +xkb_symbols "3l-emacs" { + include "us(3l)" + name[Group1] = "English (3l, emacs)"; + + key { [ Tab ] }; + key { [ Control_L ] }; + + modifier_map Control { }; +}; + +// Drix EU Latin - version 3.1 (2019-10-07) +// Author: Jerome Leclanche +// Latin layout based on classic US qwerty, with azerty-style second-row m key. +// Features: +// - Programmer-centric punctuation keys (All common symbols on right hand except < and > on left) +// - Most common dead accents on altgr-shift number row +// - Unicode arrows on Altgr+shift+WASD +// - Some commonly used special characters available: +// - Most common european special characters +// - Misc currency symbols, copyright/registered/trademark symbols +// - Common math symbols + some common greek letters +// - Compose key replaces Mod5 +// +// This layout is in the Public Domain. +// +// ┌─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┬─────┲━━━━━━━━━┓ +// │ ~ ~ │ " ´ │ ' ` │ ^ ^ │ ` ¨ │ ´ ° │ 6 ¯ │ 7 ¸ │ 8 ˛ │ 9 ˇ │ | ˝ │ _ ± │ = ≠ ┃Backspace┃ +// │ @ £ │ 1 ¹ │ 2 ² │ 3 ³ │ 4 ⁴ │ 5 ⁵ │ 6 ⁶ │ 7 ⁷ │ 8 ⁸ │ 9 ⁹ │ 0 ⁰ │ - " │ + ' ┃ ⌫ ┃ +// ┢━━━━━┷━┱───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┴─┬───┺━┳━━━━━━━┫ +// ┃Tab ┃ Q Ø │ W ↑ │ E € │ R ₽ │ T τ │ Y ¥ │ U U │ I ’ │ O Ω │ P ₱ │ [ « │ ] » ┃ ⏎ ┃ +// ┃ ↹ ┃ q ø │ w w │ e € │ r ® │ t ™ │ y ¥ │ u u │ i ‘ │ o œ │ p π │ ( { │ ) } ┃ Enter ┃ +// ┣━━━━━━━┻┱────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┴┬────┺┓ ┃ +// ┃Caps ┃ A ← │ S ↓ │ D → │ F Ƒ │ G G │ H H │ J ” │ K „ │ L λ │ M M │ % ‰ │ & × ┃ ┃ +// ┃Lock ⇬ ┃ a æ │ s ß │ d Δ │ f ƒ │ g g │ h h │ j “ │ k ‚ │ l £ │ m µ │ # ~ │ * $ ┃ ┃ +// ┣━━━━━━┳━┹───┬─┴───┬─┴───┬─┴───┬─┴───┬─┴───┬─┴───┬─┴───┬─┴───┬─┴───┬─┴───┲━┷━━━━━┻━━━━━━┫ +// ┃Shift ┃ > ≥ │ Z ¶ │ X ÷ │ C ¢ │ V V │ B ₿ │ N N │ ? ¿ │ , · │ ; ´ │ \ ¦ ┃Shift ┃ +// ┃ ⇧ ┃ < ≤ │ z § │ x × │ c © │ v ♀ │ b ♂ │ n ⚥ │ ! ¡ │ . … │ : ` │ / | ┃ ⇧ ┃ +// ┣━━━━━━┻┳━━━━┷━━┳━━┷━━━━┱┴─────┴─────┴─────┴─────┴─────┴────┲┷━━━━━╈━━━━━┻┳━━━━━━┳━━━━━━┫ +// ┃Ctrl ┃ Fn ┃Alt ┃ ␣ Space Nobreakspace ⍽ ┃AltGr ┃Multi ┃ Ctxt ┃ Ctrl ┃ +// ┃ ┃ ┃ ┃ ␣ Space Nobreakspace ⍽ ┃ ┃ ┃ Menu ┃ ┃ +// ┗━━━━━━━┻━━━━━━━┻━━━━━━━┹───────────────────────────────────┺━━━━━━┻━━━━━━┻━━━━━━┻━━━━━━┛ + +partial alphanumeric_keys modifier_keys +xkb_symbols "drix" { + + name[Group1] = "English (Drix)"; + + // First row + key {[ at, asciitilde, sterling, dead_tilde ]}; // @ ~ £ ~ + key {[ 1, quotedbl, onesuperior, dead_grave ]}; // 1 " ¹ ` + key {[ 2, apostrophe, twosuperior, dead_acute ]}; // 2 ' ² ´ + key {[ 3, asciicircum, threesuperior, dead_circumflex ]}; // 3 ^ ³ ^ + key {[ 4, grave, foursuperior, dead_diaeresis ]}; // 4 4 ⁴ ¨ + key {[ 5, degree, fivesuperior, dead_abovering ]}; // 5 ° ⁵ ° + key {[ 6, 6, sixsuperior, dead_macron ]}; // 6 6 ⁶ ¯ + key {[ 7, 7, sevensuperior, dead_cedilla ]}; // 7 7 ⁷ ¸ + key {[ 8, 8, eightsuperior, dead_ogonek ]}; // 8 8 ⁸ ˛ + key {[ 9, 9, ninesuperior, dead_caron ]}; // 9 9 ⁹ ˇ + key {[ 0, bar, zerosuperior, dead_doubleacute ]}; // 0 | ⁰ ˝ + key {[ minus, underscore, quotedbl, plusminus ]}; // - _ " ± + key {[ plus, equal, apostrophe, notequal ]}; // + = ' ≠ + + // Second row + key {[ q, Q, oslash, Oslash ]}; // q Q ø Ø + key {[ w, W, w, uparrow ]}; // w W w ↑ + key {[ e, E, EuroSign, EuroSign ]}; // e E € € + key {[ r, R, registered, 0x10020bd ]}; // r R ® ₽ + key {[ t, T, trademark, Greek_tau ]}; // t T ™ τ + key {[ y, Y, yen, yen ]}; // y Y ¥ ¥ + key {[ u, U, u, U ]}; // u U u U + key {[ i, I, leftsinglequotemark, rightsinglequotemark ]}; // i I ‘ ’ + key {[ o, O, oe, Greek_OMEGA ]}; // o O œ Ω + key {[ p, P, Greek_pi, 0x10020b1 ]}; // p P π ₱ + key {[ parenleft, bracketleft, braceleft, guillemotleft ]}; // ( [ { « + key {[ parenright, bracketright, braceright, guillemotright ]}; // ) ] } » + + // Third row + key {[ a, A, ae, leftarrow ]}; // a A æ ← + key {[ s, S, ssharp, downarrow ]}; // s S ß ↓ + key {[ d, D, Greek_DELTA, rightarrow ]}; // d D Δ → + key {[ f, F, 0x1000192, 0x1000191 ]}; // f F ƒ Ƒ + key {[ g, G, g, G ]}; // g G g G + key {[ h, H, h, H ]}; // h H h H + key {[ j, J, leftdoublequotemark, rightdoublequotemark ]}; // j J “ ” + key {[ k, K, singlelowquotemark, doublelowquotemark ]}; // k K ‚ „ + key {[ l, L, sterling, Greek_lambda ]}; // l L £ λ + key {[ m, M, mu, M ]}; // m M µ M + key {[ numbersign, percent, asciitilde, permille ]}; // # % ~ ‰ + + // Fourth row + key {[ less, greater, lessthanequal, greaterthanequal ]}; // < > ≤ ≥ + key {[ z, Z, section, paragraph ]}; // z Z § ¶ + key {[ x, X, multiply, division ]}; // x X × ÷ + key {[ c, C, copyright, cent ]}; // c C © ¢ + key {[ v, V, 0x1002640, V ]}; // v V ♀ V + key {[ b, B, 0x1002642, 0x10020bf ]}; // b B ♂ ₿ + key {[ n, N, 0x10026a5, N ]}; // n N ⚥ N + key {[ exclam, question, exclamdown, questiondown ]}; // ! ? ¡ ¿ + key {[ period, comma, 0x1002026, periodcentered ]}; // . , … · + key {[ colon, semicolon, grave, acute ]}; // : ; ` ´ + key {[ slash, backslash, bar, brokenbar ]}; // / \ | ¦ + + // Next to the enter key + key {[ asterisk, ampersand, dollar, multiply ]}; // * & $ × + + // Rebind right Super (windows key) into a Compose key + key {[ Multi_key ]}; + + // Implement AltGr and AltGr+Shift + // For some reason, include "level3(ralt_switch)" doesn't do the trick. + key { + type[Group1]="TWO_LEVEL", + [ ISO_Level3_Shift, Multi_key ] + }; +}; + +// German and Swedish characters added as third level symbols to the US keyboard layout +// Author: Stephan Lachnit , 2019 +// the german umlauts are placed over the characters without diaeresis, the sharp-s over the s +// the swedish ao is placed over the p, since it's closed to the position on a swedish keyboard +// the euro sign is placed over the e, as it is usual for german and swedish keyboards +partial alphanumeric_keys +xkb_symbols "de_se_fi" { + + include "us(basic)" + include "eurosign(e)" + name[Group1] = "German, Swedish and Finnish (US)"; + + key {[ a, A, adiaeresis, Adiaeresis ]}; + key {[ s, S, ssharp, U1E9E ]}; + key {[ q, Q, at ]}; + key {[ u, U, udiaeresis, Udiaeresis ]}; + key {[ o, O, odiaeresis, Odiaeresis ]}; + key {[ p, P, aring, Aring ]}; + key {[ bracketright, braceright, asciitilde ]}; + + include "level3(ralt_switch)" +}; diff --git a/library/xkeyboard-config/xkeyboard-config.zig b/library/xkeyboard-config/xkeyboard-config.zig new file mode 100644 index 0000000..55458d0 --- /dev/null +++ b/library/xkeyboard-config/xkeyboard-config.zig @@ -0,0 +1,153 @@ +//! xkeyboard-config — keyboard layouts, compiled from the X11 xkeyboard-config database +//! into native Zig. It turns a physical key (a USB HID usage, as the input module delivers) +//! plus a modifier state into a **keysym** and, when the key produces one, a **character** +//! (a Unicode scalar). This is the piece that lets a `KeyEvent.keycode` become a +//! `KeyEvent.character`, without shipping an X11 runtime. +//! +//! The layout tables in `generated/layouts.zig` are produced by +//! `tools/make-xkeyboard-config.py` (see ./README.md to regenerate). Those tables are +//! deliberately pure data — each key carries its up-to-four levels and an XKB *type*. The +//! type -> level selection semantics (which modifier picks which level) live here, so the +//! data and the policy are separable. +//! +//! Scope (documented in README.md): group 1 only, no dead-key/compose composition (a dead +//! key returns its keysym with no character), and a curated set of key types. Layouts: +//! us, gb, de, fr, es, dvorak. +//! +//! Upstream xkeyboard-config and keysymdef.h are MIT/X11 licensed; see vendor/COPYING and +//! vendor/PROVENANCE.md. + +const std = @import("std"); +const generated = @import("layouts"); + +pub const Level = generated.Level; +pub const KeyType = generated.KeyType; +pub const Key = generated.Key; +pub const Layout = generated.Layout; + +/// The generated layouts, by name — as pointers, so they share identity with `all` and +/// `byName` (and match the `*const Layout` that `map` takes). +pub const us: *const Layout = &generated.us; +pub const gb: *const Layout = &generated.gb; +pub const de: *const Layout = &generated.de; +pub const fr: *const Layout = &generated.fr; +pub const es: *const Layout = &generated.es; +pub const dvorak: *const Layout = &generated.dvorak; + +/// Every generated layout, for enumeration (e.g. a settings UI). +pub const all = generated.all; + +/// The modifier state that selects a key's level. `level3` is AltGr (ISO Level3 Shift); +/// `control` is accepted for completeness but does not affect level selection here. +pub const Modifiers = struct { + shift: bool = false, + caps_lock: bool = false, + level3: bool = false, + control: bool = false, +}; + +/// The result of a lookup: the X11 `keysym`, and the `character` it produces (a Unicode +/// scalar) when it is a printable key — null for keys that produce none (Return, F1, a +/// bare dead key, an unmapped key). +pub const Mapping = struct { + keysym: u32, + character: ?u21, +}; + +/// Which level (0..3) a key of `kind` selects under `mods`. XKB's canonical semantics: +/// Shift picks the odd level, AltGr (level3) adds 2, and Caps acts like Shift for the +/// alphabetic types. See the XKB "key types" — this covers the ones the vendored layouts +/// use; anything else falls back to shift-or-not. +fn selectLevel(kind: KeyType, mods: Modifiers) usize { + const shift_or_caps = mods.shift != mods.caps_lock; // XOR: Caps behaves like Shift + const low: usize = if (mods.shift) 1 else 0; + const high: usize = if (mods.level3) 2 else 0; + return switch (kind) { + .one_level => 0, + .two_level, .keypad, .other => low, + .alphabetic => if (shift_or_caps) 1 else 0, + .four_level => low + high, + .four_level_alphabetic => (if (shift_or_caps) @as(usize, 1) else 0) + high, + // Caps affects only the base pair, not the AltGr pair. + .four_level_semialphabetic => if (mods.level3) 2 + low else (if (shift_or_caps) @as(usize, 1) else 0), + }; +} + +/// Map a physical key (`hid_usage`, a USB HID keyboard-page usage) under `mods` on +/// `layout` to its keysym and character. Falls back gracefully when the selected level is +/// undefined for the key: it drops the AltGr component, then the shift component, so a key +/// with only a base/shift pair still yields something sensible under AltGr. +pub fn map(layout: *const Layout, hid_usage: u8, mods: Modifiers) Mapping { + const key = &layout.keys[hid_usage]; + var level = selectLevel(key.kind, mods); + // Fall back to a defined level: full -> without AltGr -> base. + if (key.levels[level].keysym == 0 and key.levels[level].unicode == 0) { + const candidates = [_]usize{ level & 1, 0 }; + for (candidates) |candidate| { + if (key.levels[candidate].keysym != 0 or key.levels[candidate].unicode != 0) { + level = candidate; + break; + } + } + } + const chosen = key.levels[level]; + return .{ + .keysym = chosen.keysym, + .character = if (chosen.unicode != 0) @intCast(chosen.unicode) else null, + }; +} + +/// Look up a layout by its name (`"us"`, `"gb"`, ...), or null if unknown. +pub fn byName(name: []const u8) ?*const Layout { + for (all) |layout| { + if (std.mem.eql(u8, layout.name, name)) return layout; + } + return null; +} + +// --- tests (host-run via `zig build test`) --------------------------------- + +const testing = std.testing; + +// USB HID usages used in the tests (keyboard page 0x07). +const hid_a: u8 = 0x04; +const hid_1: u8 = 0x1e; +const hid_3: u8 = 0x20; + +test "us: letters obey shift and caps" { + try testing.expectEqual(@as(?u21, 'a'), map(us, hid_a, .{}).character); + try testing.expectEqual(@as(?u21, 'A'), map(us, hid_a, .{ .shift = true }).character); + try testing.expectEqual(@as(?u21, 'A'), map(us, hid_a, .{ .caps_lock = true }).character); + // Shift + Caps cancels for an alphabetic key. + try testing.expectEqual(@as(?u21, 'a'), map(us, hid_a, .{ .shift = true, .caps_lock = true }).character); +} + +test "us: digits and their shifted symbols" { + try testing.expectEqual(@as(?u21, '1'), map(us, hid_1, .{}).character); + try testing.expectEqual(@as(?u21, '!'), map(us, hid_1, .{ .shift = true }).character); + try testing.expectEqual(@as(?u21, '3'), map(us, hid_3, .{}).character); + try testing.expectEqual(@as(?u21, '#'), map(us, hid_3, .{ .shift = true }).character); + // A digit is not alphabetic: Caps alone must not shift it. + try testing.expectEqual(@as(?u21, '3'), map(us, hid_3, .{ .caps_lock = true }).character); +} + +test "layouts differ: GB pound vs US hash on shift+3" { + try testing.expectEqual(@as(?u21, '#'), map(us, hid_3, .{ .shift = true }).character); + try testing.expectEqual(@as(?u21, '£'), map(gb, hid_3, .{ .shift = true }).character); +} + +test "french azerty places q where us has a" { + try testing.expectEqual(@as(?u21, 'q'), map(fr, hid_a, .{}).character); + try testing.expectEqual(@as(?u21, 'Q'), map(fr, hid_a, .{ .shift = true }).character); +} + +test "byName resolves and rejects" { + try testing.expect(byName("us") == us); + try testing.expect(byName("gb") == gb); + try testing.expect(byName("nonsense") == null); +} + +test "unmapped key yields no character" { + // HID 0x00 is not a key; every level is empty. + try testing.expectEqual(@as(?u21, null), map(us, 0x00, .{}).character); +} diff --git a/system/abi.zig b/system/abi.zig index 1000ab3..825039e 100644 --- a/system/abi.zig +++ b/system/abi.zig @@ -52,6 +52,7 @@ pub const SystemCall = enum(u64) { clock = 23, // clock() -> nanoseconds since boot: a monotonic time source (for timeouts/delays) process_enumerate = 24, // process_enumerate(buffer, maximum) -> total: snapshot the task table process_kill = 25, // process_kill(id) -> 0/-errno: end a process this process spawned + ipc_send = 26, // ipc_send(handle, message_ptr, message_len) -> 0/-errno: post a payload to an endpoint's async queue without blocking _, }; @@ -83,6 +84,15 @@ pub const notify_badge_bit: u64 = 1 << 63; /// notifications, which never set this bit). The microkernel's SIGCHLD. pub const notify_exit_bit: u64 = 1 << 62; +/// Set (alongside `notify_badge_bit`) in the badge of a **buffered message** — a payload +/// posted to an endpoint's async queue by `ipc_send`, delivered through `ipc_reply_wait` +/// like a notification (no reply owed) but carrying bytes in the receive buffer, not just +/// a badge. This is what distinguishes a payload-bearing async message from a bare IRQ / +/// child-exit notification (which sets neither this nor `notify_exit_bit`). The low bits +/// carry the sender's task id. The async counterpart of the synchronous `ipc_call`, for +/// broadcasts where a rendezvous is the wrong shape (the input service is the first user). +pub const notify_message_bit: u64 = 1 << 61; + /// Capacity of `ProcessDescriptor.name` — matches the longest name `system_spawn` /// accepts, so a process's recorded name (its argv[0]) is never truncated. pub const maximum_process_name = 64; @@ -113,6 +123,7 @@ pub const ProcessDescriptor = extern struct { /// during bring-up. The VFS server registers under `vfs`; clients look it up. pub const ServiceId = enum(u32) { vfs = 1, + input = 2, _, }; diff --git a/system/devices/device-model.zig b/system/devices/device-model.zig index e9eb0d6..84f63d0 100644 --- a/system/devices/device-model.zig +++ b/system/devices/device-model.zig @@ -3,7 +3,7 @@ //! Discovery backends (ACPI today, device-tree later) translate their native //! hardware description into this one shape, so the rest of the kernel walks a //! plain `Device` tree without knowing which firmware described the machine — -//! the same discipline `root.zig`'s `MemoryKind` applies to memory and `architecture` +//! the same discipline `ps2-library.zig`'s `MemoryKind` applies to memory and `architecture` //! applies to the CPU. //! //! This is deliberately minimal: enough to *describe* what was discovered (a diff --git a/system/drivers/ps2-bus/keyboard.zig b/system/drivers/ps2-bus/keyboard.zig new file mode 100644 index 0000000..985b6c0 --- /dev/null +++ b/system/drivers/ps2-bus/keyboard.zig @@ -0,0 +1,59 @@ +//! PS/2 Keyboard Driver +//! +//! Spawned by the ps2-bus driver once the controller is initialized and port 1 +//! has passed its interface test and device reset. The bus driver hands us our +//! device HID as argv[1]; we use it to locate our own device descriptor. + +const std = @import("std"); +const runtime = @import("runtime"); +const ps2 = @import("ps2-library.zig"); +const device = runtime.device; + +fn writeLine(comptime fmt: []const u8, arguments: anytype) void { + var line: [128]u8 = undefined; + _ = runtime.system.write(std.fmt.bufPrint(&line, fmt, arguments) catch return); +} + +pub fn main() void { + const hid = runtime.argument(1); + if (hid.len == 0) { + _ = runtime.system.write("system/drivers/ps2-bus/keyboard: no HID argument\n"); + return; + } + writeLine("system/drivers/ps2-bus/keyboard: starting for hid {s}\n", .{hid}); + + const buffer = runtime.allocator().alloc(device.DeviceDescriptor, 64) catch { + _ = runtime.system.write("system/drivers/ps2-bus/keyboard: out of memory\n"); + return; + }; + if (device.findDeviceDescriptorByHid(buffer, hid) == null) { + writeLine("system/drivers/ps2-bus/keyboard: no device for hid {s}\n", .{hid}); + return; + } + + // The 8042 ports (0x60/0x64) and this keyboard's IRQ1 both live on the same + // PNP0303 node, which the ps2-bus driver exclusively owns — so the keyboard is + // served through the bus and does not claim the controller itself. + _ = runtime.system.write("system/drivers/ps2-bus/keyboard: served by ps2-bus (controller owned by bus)\n"); + + // Broadcast keyboard events through the input service so programs can listen for them + // (docs/input.md). Until the bus reads real IRQ1 scancodes and hands them here (a + // follow-up), we publish the same synthetic stand-in stream the demo source uses — the + // fan-out path is real, only the source of the bytes is placeholder. + var source = runtime.input.connectSource() orelse { + _ = runtime.system.write("system/drivers/ps2-bus/keyboard: input service unavailable\n"); + return; + }; + _ = runtime.system.write("system/drivers/ps2-bus/keyboard: ok\n"); + + var step: usize = 0; + while (true) : (step +%= 1) { + _ = source.publishKeyboardEvent(runtime.input.syntheticKeyEvent(step)); + runtime.system.sleep(200); + } +} + +pub const panic = runtime.panic; +comptime { + _ = &runtime.start._start; +} diff --git a/system/drivers/ps2-bus/mouse.zig b/system/drivers/ps2-bus/mouse.zig new file mode 100644 index 0000000..cb26ceb --- /dev/null +++ b/system/drivers/ps2-bus/mouse.zig @@ -0,0 +1,63 @@ +//! PS/2 Mouse Driver +//! +//! Spawned by the ps2-bus driver once the controller is initialized and port 2 +//! has passed its interface test and device reset. The bus driver hands us our +//! device HID as argv[1]; we use it to locate our own device descriptor. + +const std = @import("std"); +const runtime = @import("runtime"); +const ps2 = @import("ps2-library.zig"); +const device = runtime.device; + +fn writeLine(comptime fmt: []const u8, arguments: anytype) void { + var line: [128]u8 = undefined; + _ = runtime.system.write(std.fmt.bufPrint(&line, fmt, arguments) catch return); +} + +pub fn main() void { + const hid = runtime.argument(1); + if (hid.len == 0) { + _ = runtime.system.write("system/drivers/ps2-bus/mouse: no HID argument\n"); + return; + } + writeLine("system/drivers/ps2-bus/mouse: starting for hid {s}\n", .{hid}); + + const buffer = runtime.allocator().alloc(device.DeviceDescriptor, 64) catch { + _ = runtime.system.write("system/drivers/ps2-bus/mouse: out of memory\n"); + return; + }; + const mouse_device_descriptor = device.findDeviceDescriptorByHid(buffer, hid) orelse { + writeLine("system/drivers/ps2-bus/mouse: no device for hid {s}\n", .{hid}); + return; + }; + + // The mouse's own node (PNP0F13) carries IRQ12 and is not claimed by the bus, + // so this driver takes exclusive ownership of it. Port IO still goes through + // the bus, which owns the shared 8042 ports. + if (!device.claim(mouse_device_descriptor.id)) { + writeLine("system/drivers/ps2-bus/mouse: unable to claim device for hid {s}\n", .{hid}); + return; + } + writeLine("system/drivers/ps2-bus/mouse: claimed device for hid {s}\n", .{hid}); + + // Broadcast mouse events through the input service so programs can listen for them + // (docs/input.md). As with the keyboard, decoding real PS/2 mouse packets is a + // follow-up; for now we publish the synthetic stand-in stream. The fan-out path is + // real, only the source of the movement is placeholder. + var source = runtime.input.connectSource() orelse { + _ = runtime.system.write("system/drivers/ps2-bus/mouse: input service unavailable\n"); + return; + }; + _ = runtime.system.write("system/drivers/ps2-bus/mouse: ok\n"); + + var step: usize = 0; + while (true) : (step +%= 1) { + _ = source.publishMouseEvent(runtime.input.syntheticMouseEvent(step)); + runtime.system.sleep(200); + } +} + +pub const panic = runtime.panic; +comptime { + _ = &runtime.start._start; +} diff --git a/system/drivers/ps2-bus/ps2-bus.zig b/system/drivers/ps2-bus/ps2-bus.zig new file mode 100644 index 0000000..98c985e --- /dev/null +++ b/system/drivers/ps2-bus/ps2-bus.zig @@ -0,0 +1,175 @@ +//! The PS/2 Controller is located on the mainboard. +//! In the early days the controller was a single chip (Intel 8042). +//! As of today it is part of the Advanced Integrated Peripheral. +//! +//! It shows up in the device discovery as: +//! KBD_ [acpi_device] hid=PNP0303 (PS/2 Keyboard) +//! - io_port 0x60 len 0x1 +//! - io_port 0x64 len 0x1 +//! - irq 0x1 len 0x1 +//! MOU_ [acpi_device] hid=PNP0F13 (PS/2 Mouse) +//! - irq 0xc len 0x1 +const std = @import("std"); +const runtime = @import("runtime"); +const ps2 = @import("ps2-library.zig"); +const device = runtime.device; + +/// Format one whole log line and emit it in a single `debug_write`, so output +/// from the child drivers (which run concurrently) can never interleave with it. +fn writeLine(comptime fmt: []const u8, arguments: anytype) void { + var line: [128]u8 = undefined; + _ = runtime.system.write(std.fmt.bufPrint(&line, fmt, arguments) catch return); +} + +/// Ask the device on `port` what it is, then spawn the matching driver from the +/// initial-ramdisk, handing it the device's HID as argv[1]. The driver is chosen +/// from what the device reports, not from the port number. +fn spawnIdentifiedDriver(controller: ps2.Controller, port: ps2.Port) void { + const device_type = controller.identifyDevice(port) orelse { + writeLine("system/drivers/ps2-bus: identify timed out on port {s}\n", .{@tagName(port)}); + return; + }; + const driver_name = device_type.driverName() orelse { + writeLine("system/drivers/ps2-bus: unrecognized device on port {s}\n", .{@tagName(port)}); + return; + }; + const hid = device_type.hid() orelse ""; + if (runtime.system.spawnWithArguments(driver_name, &.{hid}) != null) { + writeLine("system/drivers/ps2-bus: port {s} is a {s}, spawned {s}\n", .{ @tagName(port), hid, driver_name }); + } else { + writeLine("system/drivers/ps2-bus: failed to spawn {s}\n", .{driver_name}); + } +} + +pub fn main() void { + const buffer = runtime.allocator().alloc(device.DeviceDescriptor, 64) catch { + _ = runtime.system.write("system/drivers/ps2-bus: out of memory\n"); + return; + }; + + var has_two_channels = false; + // The 8042's IO ports (0x60/0x64) are enumerated under the keyboard ACPI node + // (PNP0303), so we init the controller from that descriptor — but which device + // is on which port is decided later by identify, not by this HID. + const maybe_controller_device_descriptor = device.findDeviceDescriptorByHid(buffer, "PNP0303"); + if (maybe_controller_device_descriptor) |controller_device_descriptor| { + _ = runtime.system.write("system/drivers/ps2-bus: found PS/2 controller\n"); + _ = runtime.system.write("system/drivers/ps2-bus: initializing controller\n"); + + if (!device.claim(controller_device_descriptor.id)) { + _ = runtime.system.write("system/drivers/ps2-bus: unable to claim controller \n"); + return; + } + + const controller = ps2.Controller.init(controller_device_descriptor) orelse { + _ = runtime.system.write("system/drivers/ps2-bus: controller is missing its IO ports\n"); + return; + }; + + controller.disablePort(.One); + controller.disablePort(.Two); + controller.flushOutputBuffer(); + + const current = controller.readConfigurationByte() orelse { + _ = runtime.system.write("system/drivers/ps2-bus: controller configuration timed out\n"); + return; + }; + + const update = current & ~(ps2.configuration_first_port_interrupt | + ps2.configuration_second_port_interrupt | + ps2.configuration_first_port_translation); + + if (controller.writeConfigurationByte(update) == null) { + _ = runtime.system.write("system/drivers/ps2-bus: controller configuration timed out\n"); + return; + } + + if (controller.performSelfTest()) | reply | { + if (reply != ps2.response_controller_test_passed) { + _ = runtime.system.write("system/drivers/ps2-bus: perform controller self test failed\n"); + return; + } + } else { + _ = runtime.system.write("system/drivers/ps2-bus: controller self test timed out\n"); + return; + } + + has_two_channels = controller.hasTwoChannels() orelse { + _ = runtime.system.write("system/drivers/ps2-bus: controller channels timed out\n"); + return; + }; + + if (has_two_channels) { + _ = runtime.system.write("system/drivers/ps2-bus: has two channels\n"); + // keep the bus quiet until we have tested the ports and are ready to use them + controller.disablePort(.Two); + } else { + _ = runtime.system.write("system/drivers/ps2-bus: has one channel\n"); + } + + // interface tests: always test port 1, test port 2 only if it exists + const port_one_works = (controller.testPort(.One) orelse { + _ = runtime.system.write("system/drivers/ps2-bus: port 1 test timed out\n"); + return; + }) == ps2.response_port_test_passed; + + var port_two_works = false; + if (has_two_channels) { + port_two_works = (controller.testPort(.Two) orelse { + _ = runtime.system.write("system/drivers/ps2-bus: port 2 test timed out\n"); + return; + }) == ps2.response_port_test_passed; + } + + if (!port_one_works and !port_two_works) { + _ = runtime.system.write("system/drivers/ps2-bus: no usable ports\n"); + return; + } + + // enable the working ports and, via a read-modify-write, their interrupts + controller.enablePort(.One); + if (port_two_works) controller.enablePort(.Two); + + var configuration = controller.readConfigurationByte() orelse { + _ = runtime.system.write("system/drivers/ps2-bus: controller configuration timed out\n"); + return; + }; + if (port_one_works) configuration |= ps2.Port.One.interruptBit(); + if (port_two_works) configuration |= ps2.Port.Two.interruptBit(); + _ = controller.writeConfigurationByte(configuration); + + // reset each working device; a failing device is logged but does not + // abort bring-up of the other one + if (port_one_works) { + if (controller.resetDevice(.One)) |passed| { + if (!passed) _ = runtime.system.write("system/drivers/ps2-bus: port 1 device reset failed\n"); + } else { + _ = runtime.system.write("system/drivers/ps2-bus: port 1 device reset timed out\n"); + } + } + if (port_two_works) { + if (controller.resetDevice(.Two)) |passed| { + if (!passed) _ = runtime.system.write("system/drivers/ps2-bus: port 2 device reset failed\n"); + } else { + _ = runtime.system.write("system/drivers/ps2-bus: port 2 device reset timed out\n"); + } + } + + // Identify the device on each working port and hand it off to the driver + // that matches what it reported — a port is not assumed to be a keyboard + // or a mouse by its number. + if (port_one_works) spawnIdentifiedDriver(controller, .One); + if (port_two_works) spawnIdentifiedDriver(controller, .Two); + } else { + _ = runtime.system.write("system/drivers/ps2-bus: no PS/2 controller found\n"); + return; + } + + _ = runtime.system.write("system/drivers/ps2-bus: ok\n"); + while (true) runtime.system.sleep(1000); +} + +pub const panic = runtime.panic; +comptime { + _ = &runtime.start._start; +} diff --git a/system/drivers/ps2-bus/ps2-library.zig b/system/drivers/ps2-bus/ps2-library.zig new file mode 100644 index 0000000..7b60c06 --- /dev/null +++ b/system/drivers/ps2-bus/ps2-library.zig @@ -0,0 +1,437 @@ +//! shared definitions between the different PS/2 drivers +const std = @import("std"); +const runtime = @import("runtime"); +const device = runtime.device; +const system = runtime.system; + +/// PS-2 io ports: +/// The PS/2 Controller itself uses 2 IO ports (usually, IO ports 0x60 and 0x64). Like many IO +/// ports, reads and writes may access different internal registers. +/// +/// Historical note: The PC-XT PPI had used port 0x61 to reset the keyboard interrupt request +/// signal (among other unrelated functions). Port 0x61 has no keyboard related functions on AT and +/// PS/2 compatibles. +/// +/// The Data Port (typically IO Port 0x60) is used for reading data that was received from a PS/2 +/// device or from the PS/2 controller itself and writing data to a PS/2 device or to the PS/2 +/// controller itself. +// Access type: Read/Write +pub const dataPort = 0x60; +// Access type: Read +pub const statusRegisterPort = 0x64; +// Access type: Write +pub const CommandRegisterPort = 0x64; + +/// How long to poll the status register before giving up. PS/2 controller +/// responses normally arrive within a few milliseconds. +pub const default_wait_timeout_nanoseconds: u64 = 10_000_000; // 10 ms + +/// A PS/2 device reset (0xFF) runs the device's self-test (BAT), whose reply can +/// take far longer than an ordinary controller response. +pub const device_reset_timeout_nanoseconds: u64 = 750_000_000; // 750 ms + +/// PS/2 controller commands, written to the command register (port 0x64). +pub const cmd_read_configuration_byte: u8 = 0x20; // read controller configuration byte (internal RAM byte 0) +pub const cmd_write_configuration_byte: u8 = 0x60; // write controller configuration byte (internal RAM byte 0) +pub const cmd_disable_second_port: u8 = 0xA7; // disable second PS/2 port (dual-channel controllers only) +pub const cmd_enable_second_port: u8 = 0xA8; // enable second PS/2 port (dual-channel controllers only) +pub const cmd_test_second_port: u8 = 0xA9; // test second PS/2 port +pub const cmd_test_controller: u8 = 0xAA; // controller self-test +pub const cmd_test_first_port: u8 = 0xAB; // test first PS/2 port +pub const cmd_diagnostic_dump: u8 = 0xAC; // read all bytes of internal RAM +pub const cmd_disable_first_port: u8 = 0xAD; // disable first PS/2 port +pub const cmd_enable_first_port: u8 = 0xAE; // enable first PS/2 port +pub const cmd_read_controller_input_port: u8 = 0xC0; // read controller input port +pub const cmd_read_controller_output_port: u8 = 0xD0; // read controller output port +pub const cmd_write_controller_output_port: u8 = 0xD1; // write next data byte to the controller output port +pub const cmd_write_first_port_output: u8 = 0xD2; // write next data byte to the first port output buffer +pub const cmd_write_second_port_output: u8 = 0xD3; // write next data byte to the second port output buffer +pub const cmd_write_second_port_input: u8 = 0xD4; // write next data byte to the second port input buffer (to the mouse) +pub const cmd_pulse_system_reset: u8 = 0xFE; // pulse output line 0 low: resets the CPU + +/// PS/2 status register bits (read from the status port, 0x64). Bits 4 and 5 +/// are chipset-specific and intentionally omitted. +pub const status_output_buffer_full: u8 = 1 << 0; // 1 = a byte is waiting to be read from the data port +pub const status_input_buffer_full: u8 = 1 << 1; // 1 = the controller has not yet consumed the last write +pub const status_system_flag: u8 = 1 << 2; // set once the controller passes POST +pub const status_command_or_data: u8 = 1 << 3; // 1 = last write was a command, 0 = data +pub const status_timeout_error: u8 = 1 << 6; // 1 = time-out error +pub const status_parity_error: u8 = 1 << 7; // 1 = parity error + +/// Controller configuration byte bits (internal RAM byte 0; read/written via 0x20/0x60). +pub const configuration_first_port_interrupt: u8 = 1 << 0; // 1 = first port IRQ (IRQ1) enabled +pub const configuration_second_port_interrupt: u8 = 1 << 1; // 1 = second port IRQ (IRQ12) enabled +pub const configuration_system_flag: u8 = 1 << 2; // 1 = system passed POST +pub const configuration_first_port_clock_disabled: u8 = 1 << 4; // 1 = first port clock disabled +pub const configuration_second_port_clock_disabled: u8 = 1 << 5; // 1 = second port clock disabled +pub const configuration_first_port_translation: u8 = 1 << 6; // 1 = first port scancode translation enabled + +/// Controller output port bits (read/written via 0xD0/0xD1). +pub const output_port_system_reset: u8 = 1 << 0; // WARNING: keep this 1; writing 0 can lock the machine +pub const output_port_a20_gate: u8 = 1 << 1; // A20 gate +pub const output_port_second_port_clock: u8 = 1 << 2; // dual-channel controllers only +pub const output_port_second_port_data: u8 = 1 << 3; // dual-channel controllers only +pub const output_port_first_port_output_full: u8 = 1 << 4; // output buffer full from first port (IRQ1) +pub const output_port_second_port_output_full: u8 = 1 << 5; // output buffer full from second port (IRQ12) +pub const output_port_first_port_clock: u8 = 1 << 6; // first port clock +pub const output_port_first_port_data: u8 = 1 << 7; // first port data + +/// Controller self-test (0xAA) result codes. +pub const response_controller_test_passed: u8 = 0x55; +pub const response_controller_test_failed: u8 = 0xFC; + +/// Port test (0xAB / 0xA9) result codes. +pub const response_port_test_passed: u8 = 0x00; +pub const response_port_test_clock_stuck_low: u8 = 0x01; +pub const response_port_test_clock_stuck_high: u8 = 0x02; +pub const response_port_test_data_stuck_low: u8 = 0x03; +pub const response_port_test_data_stuck_high: u8 = 0x04; + +/// PS/2 device commands, written to the data port (0x60) to reach the attached device. +pub const device_cmd_identify: u8 = 0xF2; // identify device +pub const device_cmd_enable_scanning: u8 = 0xF4; +pub const device_cmd_disable_scanning: u8 = 0xF5; +pub const device_cmd_reset: u8 = 0xFF; // reset and run the device self-test (BAT) + +/// PS/2 device response bytes, read from the data port (0x60). +pub const device_response_self_test_passed: u8 = 0xAA; // BAT succeeded after a reset +pub const device_response_echo: u8 = 0xEE; +pub const device_response_acknowledge: u8 = 0xFA; // ACK +pub const device_response_self_test_failed_1: u8 = 0xFC; // BAT failure +pub const device_response_self_test_failed_2: u8 = 0xFD; // BAT failure +pub const device_response_resend: u8 = 0xFE; // ask the host to resend the last byte + +/// PS/2 device identify (0xF2) reply bytes. A keyboard returns a two-byte id +/// beginning with 0xAB; a mouse returns a single-byte id (0x00/0x03/0x04); an +/// ancient AT keyboard returns nothing at all. +pub const identify_keyboard_mf2: u8 = 0xAB; // first byte of a MF2 keyboard id (a subtype byte follows) +pub const identify_mouse_standard: u8 = 0x00; +pub const identify_mouse_scroll: u8 = 0x03; // mouse with scroll wheel +pub const identify_mouse_five_button: u8 = 0x04; // 5-button mouse + +fn waitReadable(id: u64, cmd_index: u64, wait_timeout_nanoseconds: u64) bool { + const deadline = system.clock() + wait_timeout_nanoseconds; + while (system.clock() < deadline) { + if (status(id, cmd_index) & status_output_buffer_full != 0) return true; // OBF set -> data ready + } + return false; +} + +fn waitWritable(id: u64, cmd_index: u64, wait_timeout_nanoseconds: u64) bool { + const deadline = system.clock() + wait_timeout_nanoseconds; + while (system.clock() < deadline) { + if (status(id, cmd_index) & status_input_buffer_full == 0) return true; // IBF clear -> ok to write + } + return false; // timed out +} + +pub fn status(id: u64, cmd_index: u64) u8 { + return @intCast(device.ioRead(id, cmd_index, 0, 1) orelse 0); +} + +pub fn sendCommand(id: u64, cmd_index: u64, byte: u8, timeout_nanoseconds: u64) bool { + // wait IBF clear + if (!waitWritable(id, cmd_index, timeout_nanoseconds)) return false; + return device.ioWrite(id, cmd_index, 0, 1, byte); +} + +pub fn readData(id: u64, status_index: u64, data_index: u64, timeout_nanoseconds: u64) ?u8 { + // OBF lives in the status register (0x64); wait for it there, then read the data port (0x60) + if (!waitReadable(id, status_index, timeout_nanoseconds)) return null; + return @intCast(device.ioRead(id, data_index, 0, 1) orelse 0); +} + +pub fn writeData(id: u64, status_index: u64, data_index: u64, byte: u8, timeout_nanoseconds: u64) bool { + // IBF lives in the status register (0x64); wait for it to clear there, then write the data port (0x60) + if (!waitWritable(id, status_index, timeout_nanoseconds)) return false; + return device.ioWrite(id, data_index, 0, 1, byte); +} + +pub const Port = enum(u2) { + One, + Two, + + /// Command register byte that disables this port. + fn disableCommand(self: Port) u8 { + return switch (self) { + .One => cmd_disable_first_port, + .Two => cmd_disable_second_port, + }; + } + + /// Command register byte that enables this port (and its clock). + fn enableCommand(self: Port) u8 { + return switch (self) { + .One => cmd_enable_first_port, + .Two => cmd_enable_second_port, + }; + } + + /// Command register byte that runs this port's interface test. + fn testCommand(self: Port) u8 { + return switch (self) { + .One => cmd_test_first_port, + .Two => cmd_test_second_port, + }; + } + + /// Configuration-byte bit that, when set, disables this port's clock. + pub fn clockDisabledBit(self: Port) u8 { + return switch (self) { + .One => configuration_first_port_clock_disabled, + .Two => configuration_second_port_clock_disabled, + }; + } + + /// Configuration-byte bit that, when set, enables this port's interrupt. + pub fn interruptBit(self: Port) u8 { + return switch (self) { + .One => configuration_first_port_interrupt, + .Two => configuration_second_port_interrupt, + }; + } + + /// Command register byte that writes the next data byte into this port's + /// output buffer (makes a byte appear as if it came from the device). + pub fn writeOutputBufferCommand(self: Port) u8 { + return switch (self) { + .One => cmd_write_first_port_output, + .Two => cmd_write_second_port_output, + }; + } + + /// Controller command that must prefix a byte destined for this port's + /// device. Port 1 is the default target of the data port, so it needs no + /// prefix (null); port 2 requires the "write second port input" command. + pub fn deviceInputCommand(self: Port) ?u8 { + return switch (self) { + .One => null, + .Two => cmd_write_second_port_input, + }; + } + + /// Controller output-port bit driving this port's clock line. + pub fn outputPortClockBit(self: Port) u8 { + return switch (self) { + .One => output_port_first_port_clock, + .Two => output_port_second_port_clock, + }; + } + + /// Controller output-port bit driving this port's data line. + pub fn outputPortDataBit(self: Port) u8 { + return switch (self) { + .One => output_port_first_port_data, + .Two => output_port_second_port_data, + }; + } + + /// Controller output-port bit set when this port's output buffer is full + /// (wired to the port's IRQ line). + pub fn outputPortBufferFullBit(self: Port) u8 { + return switch (self) { + .One => output_port_first_port_output_full, + .Two => output_port_second_port_output_full, + }; + } +}; + +/// The kind of device attached to a port, as reported by the device itself in +/// response to the identify command — not assumed from the port number. +pub const DeviceType = enum { + keyboard, + mouse, + unknown, + + /// Initial-ramdisk name of the driver that serves this device type, or null + /// if we could not classify it. + pub fn driverName(self: DeviceType) ?[]const u8 { + return switch (self) { + .keyboard => "ps2-keyboard", + .mouse => "ps2-mouse", + .unknown => null, + }; + } + + /// Canonical ACPI HID for this device type, handed to the spawned driver as + /// its command-line argument, or null if we could not classify it. + pub fn hid(self: DeviceType) ?[]const u8 { + return switch (self) { + .keyboard => "PNP0303", + .mouse => "PNP0F13", + .unknown => null, + }; + } +}; + +/// A single PS/2 (8042) controller. Construct one with `Controller.init` and +/// drive the controller through its methods; there is only ever one 8042 per +/// machine, but holding the resolved resource indices in an instance keeps the +/// call sites free of global state. +pub const Controller = struct { + device_id: u64, + /// Resource index of the command/status port (0x64). + status_index: u64, + /// Resource index of the data port (0x60). + data_index: u64, + + /// Resolve the controller's IO-port resource indices from its device + /// descriptor. Returns null if either the data or command/status port is + /// missing from the descriptor. + pub fn init(device_descriptor: device.DeviceDescriptor) ?Controller { + var data_index: ?u64 = null; + var status_index: ?u64 = null; + + for (device_descriptor.resources, 0..device_descriptor.resource_count) |resource, resource_index| { + if (resource.kind != @intFromEnum(device.ResourceKind.io_port)) continue; + if (resource.start == dataPort) { + data_index = @intCast(resource_index); + } else if (resource.start == statusRegisterPort) { + status_index = @intCast(resource_index); + } + } + + return .{ + .device_id = device_descriptor.id, + .data_index = data_index orelse return null, + .status_index = status_index orelse return null, + }; + } + + pub fn disablePort(self: Controller, port: Port) void { + // port enable/disable are controller commands and go to the command register (0x64) + _ = sendCommand(self.device_id, self.status_index, port.disableCommand(), default_wait_timeout_nanoseconds); + } + + pub fn enablePort(self: Controller, port: Port) void { + // enabling a port also starts its clock + _ = sendCommand(self.device_id, self.status_index, port.enableCommand(), default_wait_timeout_nanoseconds); + } + + /// Run a port's interface test. Returns the controller's reply — compare it + /// to `response_port_test_passed` (0x00) — or null on timeout. + pub fn testPort(self: Controller, port: Port) ?u8 { + if (!sendCommand(self.device_id, self.status_index, port.testCommand(), default_wait_timeout_nanoseconds)) return null; + return readData(self.device_id, self.status_index, self.data_index, default_wait_timeout_nanoseconds); + } + + pub fn flushOutputBuffer(self: Controller) void { + // flush any stale byte the controller buffered + _ = device.ioRead(self.device_id, self.data_index, 0, 1); + } + + pub fn readConfigurationByte(self: Controller) ?u8 { + // ask the controller to place its configuration byte in the output buffer, then read it + if (!sendCommand(self.device_id, self.status_index, cmd_read_configuration_byte, default_wait_timeout_nanoseconds)) return null; + return readData(self.device_id, self.status_index, self.data_index, default_wait_timeout_nanoseconds); + } + + pub fn writeConfigurationByte(self: Controller, update_byte: u8) ?u8 { + // command 0x60 makes the controller store the next data-port byte as its configuration byte + if (!sendCommand(self.device_id, self.status_index, cmd_write_configuration_byte, default_wait_timeout_nanoseconds)) return null; + if (!writeData(self.device_id, self.status_index, self.data_index, update_byte, default_wait_timeout_nanoseconds)) return null; + return update_byte; + } + + /// Run the controller self-test. Returns the reply — compare it to + /// `response_controller_test_passed` (0x55) — or null on timeout. + pub fn performSelfTest(self: Controller) ?u8 { + if (!sendCommand(self.device_id, self.status_index, cmd_test_controller, default_wait_timeout_nanoseconds)) return null; + return readData(self.device_id, self.status_index, self.data_index, default_wait_timeout_nanoseconds); + } + + /// Detect whether this is a dual-channel controller by temporarily enabling + /// port 2 and checking whether its clock turned on. Note: this leaves port 2 + /// enabled; the caller should disable it again to keep the bus quiet until + /// device bring-up. + pub fn hasTwoChannels(self: Controller) ?bool { + self.enablePort(.Two); + const configuration = self.readConfigurationByte() orelse return null; + return (configuration & Port.Two.clockDisabledBit()) == 0; + } + + /// Reset the device attached to `port` (device command 0xFF) and wait for + /// its power-on self-test (BAT) result. Returns true if the device both + /// acknowledged and passed, false if it reported a self-test failure, or + /// null on timeout. The BAT reply can be slow, so the response reads use + /// `device_reset_timeout_nanoseconds`. + pub fn resetDevice(self: Controller, port: Port) ?bool { + // A byte destined for port 2 must be prefixed with the "write to second + // port input buffer" controller command (0xD4); port 1 is the default. + if (port.deviceInputCommand()) |prefix| { + if (!sendCommand(self.device_id, self.status_index, prefix, default_wait_timeout_nanoseconds)) return null; + } + if (!writeData(self.device_id, self.status_index, self.data_index, device_cmd_reset, default_wait_timeout_nanoseconds)) return null; + + // A successful reset yields both an ACK (0xFA) and a self-test-passed + // byte (0xAA). Their order is not guaranteed, so accept either ordering. + var saw_acknowledge = false; + var saw_self_test_passed = false; + var reads: u8 = 0; + while (reads < 2) : (reads += 1) { + const reply = readData(self.device_id, self.status_index, self.data_index, device_reset_timeout_nanoseconds) orelse return null; + switch (reply) { + device_response_acknowledge => saw_acknowledge = true, + device_response_self_test_passed => saw_self_test_passed = true, + device_response_self_test_failed_1, device_response_self_test_failed_2 => return false, + else => {}, + } + } + return saw_acknowledge and saw_self_test_passed; + } + + /// Send one command byte to the device on `port` (applying the port-2 prefix + /// as needed) and consume its acknowledgement. Returns true on ACK (0xFA), + /// false on any other reply, or null on timeout. + pub fn sendToDevice(self: Controller, port: Port, byte: u8) ?bool { + if (port.deviceInputCommand()) |prefix| { + if (!sendCommand(self.device_id, self.status_index, prefix, default_wait_timeout_nanoseconds)) return null; + } + if (!writeData(self.device_id, self.status_index, self.data_index, byte, default_wait_timeout_nanoseconds)) return null; + const reply = readData(self.device_id, self.status_index, self.data_index, default_wait_timeout_nanoseconds) orelse return null; + return reply == device_response_acknowledge; + } + + /// Discard any bytes sitting in the output buffer (for example the device-id + /// byte a mouse emits after a reset) so they cannot be mistaken for the reply + /// to a subsequent command. + pub fn drainOutputBuffer(self: Controller) void { + var guard: u8 = 0; + while (guard < 16) : (guard += 1) { + if (status(self.device_id, self.status_index) & status_output_buffer_full == 0) return; + _ = device.ioRead(self.device_id, self.data_index, 0, 1); + } + } + + /// Ask the device on `port` what it is (command 0xF2) and classify the reply. + /// Scanning is disabled around the query so a streaming device cannot inject + /// data bytes that look like the identifier. Returns the device type, or null + /// if the identify command itself timed out. + pub fn identifyDevice(self: Controller, port: Port) ?DeviceType { + // Clear any leftover bytes (e.g. a post-reset mouse id) before we start. + self.drainOutputBuffer(); + + // Stop the device reporting so its data can't be mistaken for the reply. + if (self.sendToDevice(port, device_cmd_disable_scanning) == null) return null; + + if (self.sendToDevice(port, device_cmd_identify) == null) return null; + + // After the ACK, the device sends 0, 1, or 2 identifier bytes. + const first = readData(self.device_id, self.status_index, self.data_index, default_wait_timeout_nanoseconds); + const device_type: DeviceType = if (first) |id| switch (id) { + identify_keyboard_mf2 => blk: { + // A MF2 keyboard sends a second subtype byte; consume and ignore it. + _ = readData(self.device_id, self.status_index, self.data_index, default_wait_timeout_nanoseconds); + break :blk .keyboard; + }, + identify_mouse_standard, identify_mouse_scroll, identify_mouse_five_button => .mouse, + else => .unknown, + } else + // No identifier bytes at all is a legacy AT keyboard. + .keyboard; + + // Resume scanning so the device works once its driver takes over. + _ = self.sendToDevice(port, device_cmd_enable_scanning); + return device_type; + } +}; \ No newline at end of file diff --git a/system/kernel/ipc-synchronous.zig b/system/kernel/ipc-synchronous.zig index 90d6a0c..116f844 100644 --- a/system/kernel/ipc-synchronous.zig +++ b/system/kernel/ipc-synchronous.zig @@ -57,6 +57,29 @@ pub const EPERM: i64 = 9; // not permitted (process_kill by anyone but the super /// shared kernel↔user ABI (system/abi.zig), because ring 3 has to test the same bit. pub const notify_badge_bit: u64 = abi.notify_badge_bit; +/// Set (with `notify_badge_bit`) when a `replyWait` wake carries a buffered payload +/// posted by `send` (`ipc_send`), rather than a bare IRQ/exit notification. Shared with +/// ring 3 through the ABI so the receiver can tell "a message arrived" from "the hardware +/// spoke". +pub const notify_message_bit: u64 = abi.notify_message_bit; + +/// Largest payload a single `send` (`ipc_send`) may post. Kept small — the payload rides +/// inline in every `Endpoint`, and the async path is for events (a `KeyEvent` is 16 +/// bytes), not bulk transfer, which is what `call` and future shared pages are for. +pub const POST_MAXIMUM: usize = 64; + +/// Depth of an endpoint's async payload ring. Absorbs a burst while a receiver is briefly +/// busy; a full ring drops the *oldest* message (see `send`). +const post_capacity: usize = 16; + +/// One buffered message: a length-prefixed payload plus the sender's task id (delivered +/// in the low bits of the receiver's badge). +const PostSlot = struct { + length: u16 = 0, + sender_id: u64 = 0, + bytes: [POST_MAXIMUM]u8 = undefined, +}; + /// End of the user (low) canonical half — user buffers must lie below it. const user_half_end: u64 = 0x0000_8000_0000_0000; @@ -74,6 +97,12 @@ pub const Endpoint = struct { notify_buffer: [8]u64 = undefined, notify_head: u8 = 0, notify_tail: u8 = 0, + // Pending buffered messages (payloads posted by `send`), a small FIFO ring. Unlike + // notifications — which are a level and coalesce — these are discrete messages, so a + // full ring drops the oldest rather than merging. + post_buffer: [post_capacity]PostSlot = undefined, + post_head: u16 = 0, + post_tail: u16 = 0, }; pub fn createIpcEndpoint() ?*Endpoint { @@ -265,12 +294,23 @@ pub fn replyWait(endpoint: *Endpoint, reply_ptr: u64, reply_len: u64, receive_pt scheduler.readyLocked(client); // its `call` now returns } - // (2) Receive the next request (or notification), blocking until one is ready. + // (2) Receive the next request (or notification / buffered message), blocking until + // one is ready. Bare notifications (IRQ/exit) come first — they're latency-sensitive + // and carry no payload — then buffered messages, then synchronous client requests. while (true) { if (popNotify(endpoint)) |badge| { out_badge.* = badge | notify_badge_bit; return 0; // notification: no payload, no reply owed, no cap } + if (popPost(endpoint)) |slot| { + const n = @min(@as(usize, slot.length), receive_cap); + // Copy from the kernel-resident ring slot (source aspace 0) into the receiver. + if (!copyAcross(0, @intFromPtr(&slot.bytes), me.aspace, receive_ptr, n)) { + continue; // bad receive buffer: drop this message, keep serving + } + out_badge.* = slot.sender_id | notify_badge_bit | notify_message_bit; + return @intCast(n); // async message: payload delivered, no reply owed, no cap + } if (dequeueSender(endpoint)) |caller| { const n = @min(caller.ipc_send_len, receive_cap); if (!copyAcross(caller.aspace, caller.ipc_send_ptr, me.aspace, receive_ptr, n)) { @@ -306,6 +346,44 @@ fn popNotify(endpoint: *Endpoint) ?u64 { return badge; } +/// Take the oldest buffered message from the post ring, or null if empty. Returns a +/// pointer into the endpoint's own storage — valid until the next `send`/`popPost` under +/// the same lock region, which is all the copy-out in `replyWait` needs. +fn popPost(endpoint: *Endpoint) ?*const PostSlot { + if (endpoint.post_head == endpoint.post_tail) return null; + const slot = &endpoint.post_buffer[endpoint.post_head % post_capacity]; + endpoint.post_head +%= 1; + return slot; +} + +/// Client-free side of async IPC (`ipc_send`): copy `[source_va, len)` from address space +/// `source_as` into `endpoint`'s post ring and wake a waiting receiver — **without +/// blocking the sender** and with no reply owed. `sender_id` rides along, delivered in the +/// low bits of the receiver's badge. Returns 0, or a negative errno (`-E2BIG` if the +/// payload exceeds `POST_MAXIMUM`, `-EFAULT` if the source buffer is unmapped / out of the +/// user half). A full ring drops the *oldest* message (advancing `post_head`), because a +/// buffered message is discrete, not a level: keeping the newest keeps input responsive. +/// Precondition: the big kernel lock is held. +pub fn sendLocked(endpoint: *Endpoint, source_as: u64, source_va: u64, len: u64, sender_id: u64) i64 { + if (len > POST_MAXIMUM) return -E2BIG; + // Drop the oldest if the ring is full, so this newest message always lands. + if (endpoint.post_tail -% endpoint.post_head >= post_capacity) endpoint.post_head +%= 1; + const slot = &endpoint.post_buffer[endpoint.post_tail % post_capacity]; + if (!copyFromUser(source_as, source_va, slot.bytes[0..@intCast(len)])) return -EFAULT; + slot.length = @intCast(len); + slot.sender_id = sender_id; + endpoint.post_tail +%= 1; + scheduler.wakeLocked(&endpoint.receive_wait_queue); + return 0; +} + +/// `sendLocked` wrapped in its own critical section, for the `ipc_send` syscall path. +pub fn send(endpoint: *Endpoint, source_as: u64, source_va: u64, len: u64, sender_id: u64) i64 { + const flags = sync.enter(); + defer sync.leave(flags); + return sendLocked(endpoint, source_as, source_va, len, sender_id); +} + /// Post an asynchronous notification carrying `badge` to `endpoint` and wake a waiting /// receiver. Precondition: the big kernel lock is held. /// diff --git a/system/kernel/process.zig b/system/kernel/process.zig index a11bd80..db6af84 100644 --- a/system/kernel/process.zig +++ b/system/kernel/process.zig @@ -183,6 +183,7 @@ fn system_call(state: *architecture.CpuState) void { .ipc_lookup => systemIpcLookup(state), .ipc_call => systemIpcCall(state), .ipc_reply_wait => systemIpcReplyWait(state), + .ipc_send => systemIpcSend(state), .device_enumerate => systemDeviceEnumerate(state), .device_claim => systemDeviceClaim(state), .mmio_map => systemMmioMap(state), @@ -263,6 +264,18 @@ fn systemIpcReplyWait(state: *architecture.CpuState) void { architecture.setSystemCallResult3(state, received_cap); } +/// ipc_send(handle, message_ptr, message_len) -> 0/-errno: post a payload to an +/// endpoint's async queue and wake a receiver, without blocking the caller. The async +/// counterpart of ipc_call — for broadcasts (the input service) where a rendezvous would +/// let one dead subscriber hang the sender. Delivered through ipc_reply_wait as a +/// buffered message (badge carries notify_message_bit and the caller's task id). +fn systemIpcSend(state: *architecture.CpuState) void { + const me = scheduler.current(); + const endpoint = ipc.resolveHandle(me, architecture.systemCallArg(state, 0)) orelse return failErr(state, ipc.EBADF); + const r = ipc.send(endpoint, me.aspace, architecture.systemCallArg(state, 1), architecture.systemCallArg(state, 2), me.id); + architecture.setSystemCallResult(state, @bitCast(r)); +} + /// device_enumerate(buffer, maximum) -> total: snapshot the device table into the caller's /// buffer (up to `maximum` entries), returning the total device count. fn systemDeviceEnumerate(state: *architecture.CpuState) void { @@ -700,6 +713,11 @@ fn systemIrqAck(state: *architecture.CpuState) void { if (irq.ack(gsi)) architecture.setSystemCallResult(state, 0) else fail(state); } +/// Whether the debug_write stream sits at the start of a line — the last emitted +/// byte was a newline (true at boot: nothing emitted yet). Guarded by the kernel +/// lock in `systemDebugWrite`, like the stream it describes. +var write_at_line_start: bool = true; + /// debug_write(ptr, len): copy bytes from user memory into the kernel log. /// A bring-up diagnostic — real output goes through the VFS/console later. /// @@ -709,17 +727,27 @@ fn systemIrqAck(state: *architecture.CpuState) void { /// Known gap (fine for trusted user code): a pointer into an *unmapped* hole in /// the user half passes the check and the read #PFs -> on_fault halts — a /// self-DoS, not an isolation break. Fault-recovering copy-in is a later item. +/// +/// The emit runs under the kernel lock, so a message is atomic on the wire — two +/// processes writing from different cores can interleave *messages*, never bytes. +/// The "DANOS-INIT: " marker is emitted only at the start of a line (not per +/// call), so a process may assemble a line from several writes without the marker +/// (or, with the lock, another byte) landing in the middle. Cleanly-terminated +/// lines from concurrent writers stay whole either way. fn systemDebugWrite(state: *architecture.CpuState) void { const ptr = architecture.systemCallArg(state, 0); const len = architecture.systemCallArg(state, 1); if (len <= write_buffer.len and ptr < user_half_end and ptr + len <= user_half_end) { const source: [*]const u8 = @ptrFromInt(ptr); + const flags = sync.enter(); + defer sync.leave(flags); @memcpy(write_buffer[0..len], source[0..len]); // keep the latest message write_len = len; write_from_user = architecture.fromUser(state); write_count += 1; - log.write("DANOS-INIT: "); + if (write_at_line_start) log.write("DANOS-INIT: "); log.write(source[0..len]); + if (len != 0) write_at_line_start = source[len - 1] == '\n'; architecture.setSystemCallResult(state, len); } else { fail(state); diff --git a/system/kernel/tests.zig b/system/kernel/tests.zig index 8c4e22e..e0a68f3 100644 --- a/system/kernel/tests.zig +++ b/system/kernel/tests.zig @@ -136,6 +136,8 @@ pub fn run(case: []const u8, boot_information: *const BootInformation) void { initialRamdiskTest(boot_information); } else if (eql(case, "vfs")) { vfsTest(boot_information); + } else if (eql(case, "input")) { + inputTest(boot_information); } else if (eql(case, "hpet")) { hpetTest(boot_information); } else if (eql(case, "iopass")) { @@ -1585,6 +1587,51 @@ fn vfsTest(boot_information: *const BootInformation) void { result(); } +/// The full input path: spawn the input service, a synthetic source, and a subscriber from +/// the initial_ramdisk. The source publishes keyboard, mouse, and joystick events in turn; +/// the service routes them (with the asynchronous ipc_send) to the subscriber, which took +/// all three classes and — only once it has received one — heartbeats "input-test: ok". +/// Seeing that marker proves an event travelled source -> service -> subscriber over IPC, +/// exercising the async buffered-send primitive, capability-passing subscription, and +/// per-device routing. The source and service stay silent after startup so the subscriber's +/// line is the one left in the shared evidence buffer. +fn inputTest(boot_information: *const BootInformation) void { + log("DANOS-TEST-BEGIN: input\n", .{}); + if (boot_information.initial_ramdisk_len == 0) { + check("bootloader handed over an initial_ramdisk", false); + result(); + return; + } + const image = @as([*]const u8, @ptrFromInt(boot_handoff.physicalToVirtual(boot_information.initial_ramdisk_base)))[0..boot_information.initial_ramdisk_len]; + const rd = initial_ramdisk.Reader.init(image) orelse { + check("initial_ramdisk image is valid", false); + result(); + return; + }; + + process.write_count = 0; + process.write_from_user = false; + _ = spawnNamed(rd, "input"); // the fan-out service + _ = spawnNamed(rd, "input-source"); // a synthetic keyboard publishing events + _ = spawnNamed(rd, "input-test"); // the subscriber whose "ok" line is the marker + + // Wait for the subscriber's success heartbeat (it beats once per received event). + const prefix = "input-test: ok"; + scheduler.setPriority(1); + const deadline = architecture.millis() + 12000; + while (architecture.millis() < deadline) { + if (process.write_len >= prefix.len and eql(process.write_buffer[0..prefix.len], prefix) and process.write_count >= 2) break; + scheduler.yield(); + } + scheduler.setPriority(4); + + const ok = process.write_len >= prefix.len and eql(process.write_buffer[0..prefix.len], prefix); + check("a subscriber received a broadcast key event over IPC (source -> service -> subscriber)", ok); + check("events kept flowing (service + async send stay up)", process.write_count >= 2); + check("client syscalls came from user mode (CPL 3)", process.write_from_user); + result(); +} + /// Process arguments, end to end: spawn args-echo bare (its argv[0] is the /// initial-ramdisk name). Instance 1 sees argc == 1 and respawns itself through /// `system_spawn` with the extra arguments "alpha beta-42" — the syscall argument diff --git a/system/parameters.zig b/system/parameters.zig index 2f01b31..a17e556 100644 --- a/system/parameters.zig +++ b/system/parameters.zig @@ -4,7 +4,7 @@ //! hiding the trade-offs. Keeping them here makes them visible at a glance and gives //! one spot to change them. They're plain `comptime` constants (zero runtime cost); //! any one can later be promoted to a `-D` build option if a target needs to vary it -//! (see build.zig's `-Dtest-case` for the pattern). This keeps root.zig to what it +//! (see build.zig's `-Dtest-case` for the pattern). This keeps ps2-library.zig to what it //! actually is — the bootloader↔kernel handoff *contract* — with tunables living here. /// Ceiling on logical CPUs the kernel tracks — the size of the per-CPU bookkeeping diff --git a/system/services/device-manager/device-manager.zig b/system/services/device-manager/device-manager.zig index 310120a..938ed4c 100644 --- a/system/services/device-manager/device-manager.zig +++ b/system/services/device-manager/device-manager.zig @@ -12,19 +12,34 @@ //! HPET, decides `hpet` serves it, and brings that driver all the way up. (The //! kernel still auto-spawns the whole initial-ramdisk at boot; increment 3 removes //! that redundancy so the manager is the sole owner of driver spawning.) - +const std = @import("std"); const runtime = @import("runtime"); const device = runtime.device; +const system = runtime.system; -/// The driver that serves each device class — the policy table. In a fuller system +/// Format one whole log line and emit it in a single `debug_write`, so output +/// from the drivers this manager starts (which run concurrently) can never land +/// in the middle of it. +fn writeLine(comptime fmt: []const u8, arguments: anytype) void { + var line: [128]u8 = undefined; + _ = runtime.system.write(std.fmt.bufPrint(&line, fmt, arguments) catch return); +} + +/// The driver that serves each device — the policy table. In a fuller system /// this comes from the drivers describing what they bind (or a manifest under /// /system/drivers); for now it is a small static map, which is enough to prove the /// manager reads the tree and decides. `null` = no driver for this class yet. -fn driverFor(class: u64) ?[]const u8 { - if (class == @intFromEnum(device.DeviceClass.timer)) return "hpet"; // the HPET +fn driverFor(d: device.DeviceDescriptor) ?[]const u8 { + // detect device via DeviceClass + if (d.class == @intFromEnum(device.DeviceClass.timer)) return "hpet"; + // detect device via hid + const hid = d.hid[0..@intCast(d.hid_len)]; + if (std.mem.eql(u8, hid, "PNP0303") or std.mem.eql(u8, hid, "PNP0F13")) return "ps2-bus"; + return null; } + pub fn main() void { // Enumerate into a heap buffer (too big for the one-page user stack). const buffer = runtime.allocator().alloc(device.DeviceDescriptor, 64) catch { @@ -36,16 +51,16 @@ pub fn main() void { var matched: usize = 0; for (buffer[0..count]) |descriptor| { - const driver_name = driverFor(descriptor.class) orelse continue; + const driver_name = driverFor(descriptor) orelse continue; matched += 1; - if (runtime.system.spawn(driver_name) != null) { - _ = runtime.system.write("device-manager: spawned "); - _ = runtime.system.write(driver_name); - _ = runtime.system.write("\n"); + if (!system.isProcessRunning(driver_name)) { + if (runtime.system.spawn(driver_name) != null) { + writeLine("device-manager: spawned {s}\n", .{driver_name}); + } else { + writeLine("device-manager: failed to spawn {s}\n", .{driver_name}); + } } else { - _ = runtime.system.write("device-manager: failed to spawn "); - _ = runtime.system.write(driver_name); - _ = runtime.system.write("\n"); + writeLine("device-manager: already spawned {s}\n", .{driver_name}); } } diff --git a/system/services/init/init.zig b/system/services/init/init.zig index e9f656c..461a2b4 100644 --- a/system/services/init/init.zig +++ b/system/services/init/init.zig @@ -17,7 +17,7 @@ const runtime = @import("runtime"); /// microkernel keeps such choices in user space, not the kernel. Drivers are absent /// on purpose: the device manager owns those. (A future init reads this from a /// manifest under /system/services instead of a hardcoded list.) -const boot_services = [_][]const u8{ "vfs", "device-manager" }; +const boot_services = [_][]const u8{ "vfs", "input", "device-manager" }; pub fn main() void { // Prove the heap end to end: allocate through the runtime allocator (which diff --git a/system/services/input-source/input-source.zig b/system/services/input-source/input-source.zig new file mode 100644 index 0000000..a56a2da --- /dev/null +++ b/system/services/input-source/input-source.zig @@ -0,0 +1,40 @@ +//! system/services/input-source — a hardware-free synthetic input source, used to exercise +//! the input service end to end without a real PS/2 controller (the `input` test case, and +//! any bring-up where there is no hardware). It stands in for a driver: it connects to the +//! input service and publishes a rolling stream that cycles through all device classes — +//! keyboard, mouse, and joystick/gamepad — which the service routes to interested +//! subscribers. +//! +//! It stays silent after startup (no per-event logging) so it can share the boot serial +//! transcript with a subscriber whose output is the test's success marker. The real +//! keyboard and mouse drivers publish their own synthetic streams today; swapping in +//! decoded hardware is a follow-up (see docs/input.md). + +const runtime = @import("runtime"); +const input = runtime.input; +const system = runtime.system; + +pub fn main() void { + var source = input.connectSource() orelse { + _ = system.write("input-source: input service unavailable\n"); + return; + }; + _ = system.write("input-source: publishing synthetic input events\n"); + + var step: usize = 0; + while (true) : (step +%= 1) { + // Rotate across the device classes so every publish path (and the service's + // per-device routing) is exercised. + switch (step % 3) { + 0 => _ = source.publishKeyboardEvent(input.syntheticKeyEvent(step)), + 1 => _ = source.publishMouseEvent(input.syntheticMouseEvent(step)), + else => _ = source.publishJoystickEvent(input.syntheticJoystickEvent(step)), + } + system.sleep(200); + } +} + +pub const panic = runtime.panic; +comptime { + _ = &runtime.start._start; +} diff --git a/system/services/input-test/input-test.zig b/system/services/input-test/input-test.zig new file mode 100644 index 0000000..62b3fb9 --- /dev/null +++ b/system/services/input-test/input-test.zig @@ -0,0 +1,56 @@ +//! system/services/input-test — the input service's client and test oracle, the input +//! counterpart of vfs-test. It subscribes to *all* device classes and loops receiving the +//! events a source broadcasts, logging each with its class. It emits the success marker +//! `"input-test: ok"` only **after it has received at least one of each class** (keyboard, +//! mouse, and joystick), then heartbeats it. So the in-kernel `input` test case seeing that +//! marker proves not just that IPC delivery works but that the service *routed* all three +//! device classes to one subscription — source -> service -> subscriber, per device. + +const std = @import("std"); +const runtime = @import("runtime"); +const input = runtime.input; +const system = runtime.system; + +fn writeLine(comptime fmt: []const u8, arguments: anytype) void { + var line: [128]u8 = undefined; + _ = system.write(std.fmt.bufPrint(&line, fmt, arguments) catch return); +} + +pub fn main() void { + var listener = input.subscribeAll() orelse { + _ = system.write("input-test: could not subscribe\n"); + return; + }; + _ = system.write("input-test: subscribed\n"); + + var seen_keyboard = false; + var seen_mouse = false; + var seen_joystick = false; + while (true) { + const event = listener.next() orelse continue; + // Decode the class-specific payload from the tagged envelope and note the class. + if (event.asKeyboard()) |key| { + seen_keyboard = true; + writeLine("input-test: got keyboard code={d} char={d}\n", .{ key.keycode, key.character }); + } else if (event.asMouse()) |mouse| { + seen_mouse = true; + writeLine("input-test: got mouse dx={d} dy={d} buttons={d}\n", .{ mouse.dx, mouse.dy, mouse.buttons }); + } else if (event.asJoystick()) |joystick| { + seen_joystick = true; + writeLine("input-test: got joystick control={d} value={d}\n", .{ joystick.control, joystick.value }); + } else { + writeLine("input-test: got device={d}\n", .{event.device}); + } + + // The success marker: only once every class has been routed here does this appear, + // and then it heartbeats. Seeing "input-test: ok" proves per-device fan-out works. + if (seen_keyboard and seen_mouse and seen_joystick) { + _ = system.write("input-test: ok all classes received (keyboard, mouse, joystick)\n"); + } + } +} + +pub const panic = runtime.panic; +comptime { + _ = &runtime.start._start; +} diff --git a/system/services/input/input.zig b/system/services/input/input.zig new file mode 100644 index 0000000..6c2d86b --- /dev/null +++ b/system/services/input/input.zig @@ -0,0 +1,145 @@ +//! system/services/input — the user-space input service. Shipped in the initial_ramdisk, +//! spawned as a ring-3 process, and published under the well-known `input` service id. It +//! is the fan-out point between **sources** (keyboard, mouse, and joystick/gamepad drivers) +//! and **subscribers** (any program that wants input): a source `publish`es an +//! `InputEvent`, and the service pushes it to every subscriber whose interest mask includes +//! that event's device class (keyboard / mouse / joystick). +//! +//! The delivery discipline is the whole design (see docs/input.md). The kernel's IPC is a +//! synchronous rendezvous: a server holds one pending reply, so it cannot park N +//! subscribers blocked in a "wait for next event" call. Broadcasting therefore has to be +//! *push* — the service delivering to subscribers. But a synchronous push (`ipc_call`) +//! would let one dead or wedged subscriber hang the whole broadcast, since the kernel +//! never wakes a sender parked on a dead peer's endpoint. So delivery uses the +//! asynchronous `ipc.send`: it posts the event to each subscriber's endpoint queue and +//! returns at once, and can never block on a subscriber. That primitive exists for exactly +//! this ([ipc.md](../../../docs/ipc.md), "asynchronous / buffered send"). +//! +//! A subscriber registers by handing the service its own endpoint as a capability (M13 +//! capability passing — this service is its first real consumer). The service keeps that +//! handle and `ipc.send`s each event to it. + +const std = @import("std"); +const runtime = @import("runtime"); +const protocol = runtime.input_protocol; +const ipc = runtime.ipc; +const system = runtime.system; + +/// One registered subscriber: the endpoint we push events to (a capability it handed us at +/// subscribe time) and the task id that owns it (the subscribe call's badge), so a slot +/// left behind by a subscriber that exited can be reclaimed. +const Subscriber = struct { + used: bool = false, + endpoint: ipc.Handle = 0, + task_id: u32 = 0, + /// Which device classes this subscriber wants (an OR of protocol.device_*). An event + /// is delivered only if its device's bit is set here. + device_mask: u32 = 0, +}; + +var subscribers = [_]Subscriber{.{}} ** 8; + +/// Drop any subscriber whose owning process is no longer alive, so its slot (and the +/// endpoint reference it holds) can be reused. Cheap and only run on subscribe — the async +/// `send` to a dead subscriber's orphaned endpoint is harmless (it just fills a queue no +/// one drains), so this is housekeeping, not correctness. +fn pruneDeadSubscribers() void { + var table: [32]system.ProcessDescriptor = undefined; + const total = system.processes(&table); + const count = @min(total, table.len); + for (&subscribers) |*sub| { + if (!sub.used) continue; + var alive = false; + for (table[0..count]) |descriptor| { + if (descriptor.id == sub.task_id) { + alive = true; + break; + } + } + if (!alive) sub.* = .{}; + } +} + +/// Register `endpoint` (owned by task `task_id`) to receive the device classes in +/// `device_mask`. Returns false if the subscriber table is full. +fn addSubscriber(endpoint: ipc.Handle, task_id: u32, device_mask: u32) bool { + for (&subscribers) |*sub| { + if (!sub.used) { + sub.* = .{ .used = true, .endpoint = endpoint, .task_id = task_id, .device_mask = device_mask }; + return true; + } + } + return false; +} + +/// Push `event` to every subscriber whose interest mask includes its device class. +/// `ipc.send` never blocks, so a slow or dead subscriber cannot stall delivery to others. +fn broadcast(event: protocol.InputEvent) void { + const bytes = std.mem.asBytes(&event); + const bit = protocol.deviceBit(event.device); + for (&subscribers) |*sub| { + if (sub.used and sub.device_mask & bit != 0) _ = ipc.send(sub.endpoint, bytes); + } +} + +/// Handle one request. `got` carries the sender badge (a task id) and, for subscribe, the +/// subscriber's endpoint capability in `got.cap`. Writes a `Reply` into `out` and returns +/// its length. +fn handle(message: []const u8, got: ipc.Received, out: []u8) usize { + const reply = struct { + fn write(buffer: []u8, status: i32) usize { + const header = protocol.Reply{ .status = status }; + @memcpy(buffer[0..protocol.reply_size], std.mem.asBytes(&header)); + return protocol.reply_size; + } + }; + + if (message.len < protocol.request_size) return reply.write(out, -1); + const request = std.mem.bytesToValue(protocol.Request, message[0..protocol.request_size]); + + switch (@as(protocol.Operation, @enumFromInt(request.operation))) { + .subscribe => { + const endpoint = got.cap orelse return reply.write(out, -1); // no endpoint passed + // A zero mask means "everything" (a subscriber that named no class still wants input). + const mask = if (request.device_mask == 0) protocol.device_all else request.device_mask; + pruneDeadSubscribers(); + if (!addSubscriber(endpoint, @intCast(got.badge), mask)) return reply.write(out, -1); // table full + return reply.write(out, 0); + }, + .publish => { + broadcast(request.event); + return reply.write(out, 0); + }, + } +} + +pub fn main() void { + const endpoint = ipc.createIpcEndpoint() orelse { + _ = system.write("input: no endpoint\n"); + return; + }; + if (!ipc.register(.input, endpoint)) { + _ = system.write("input: register failed\n"); + return; + } + _ = system.write("input: ready\n"); + + var reply_buffer: [protocol.reply_size]u8 = undefined; + var reply_len: usize = 0; + var receive: [protocol.request_size]u8 = undefined; + while (true) { + const got = ipc.replyWait(endpoint, reply_buffer[0..reply_len], &receive, null); + // Only synchronous client requests (subscribe/publish) arrive here; nothing sends + // this service asynchronous messages, so a notification wake would be spurious. + if (got.isNotification()) { + reply_len = 0; + continue; + } + reply_len = handle(receive[0..got.len], got, &reply_buffer); + } +} + +pub const panic = runtime.panic; +comptime { + _ = &runtime.start._start; +} diff --git a/system/services/input/protocol.zig b/system/services/input/protocol.zig new file mode 100644 index 0000000..daab82c --- /dev/null +++ b/system/services/input/protocol.zig @@ -0,0 +1,210 @@ +//! The input wire protocol — the message format spoken between the user-space input +//! service ([input.zig](input.zig)) and the two kinds of process that reach it: a +//! **source** (a keyboard, mouse, or joystick/gamepad driver) that publishes events, and a +//! **subscriber** (any program) that subscribes and is then pushed each event. +//! +//! The service handles several device classes over one endpoint. Each class has its own +//! typed event (`KeyEvent`, `MouseEvent`, `JoystickEvent`); they all travel in a common +//! `InputEvent` envelope tagged with a `DeviceKind`, so the fan-out path is one code path +//! and a subscriber can take a mix of devices on a single stream. A subscriber declares +//! which classes it wants with a `device_mask`, and the service routes accordingly. +//! +//! Two message shapes ride over the endpoint, tagged by `Operation`, like the +//! [VFS protocol](../vfs/protocol.zig): +//! +//! - **subscribe / publish**: a synchronous `ipc_call` carrying a `Request`. `subscribe` +//! hands the service the subscriber's own endpoint as a capability (`send_cap`) and a +//! `device_mask`; `publish` carries an `InputEvent`. The reply is a `Reply`. +//! - **delivery**: the service pushes each `InputEvent` to every interested subscriber with +//! the asynchronous `ipc_send` — no reply owed, and a dead subscriber can never stall the +//! broadcast. Received in the subscriber's buffer with `Received.isMessage()` set. +//! +//! This is a danos-native contract, shared by the input service, the `runtime.input` +//! client helpers, and every source/subscriber. Everything fits one IPC message. + +const std = @import("std"); + +/// The classes of input device the service fans out. Each names a typed event and a bit in +/// the subscription mask. +pub const DeviceKind = enum(u32) { + keyboard = 0, + mouse = 1, + joystick = 2, // joysticks and gamepads/controllers +}; + +/// Subscription-interest bits (`Request.device_mask`) — which device classes a subscriber +/// wants. OR them together, or use `device_all`. +pub const device_keyboard: u32 = 1 << 0; +pub const device_mouse: u32 = 1 << 1; +pub const device_joystick: u32 = 1 << 2; +pub const device_all: u32 = device_keyboard | device_mouse | device_joystick; + +/// The subscription bit for a `DeviceKind` value (as it appears in `InputEvent.device`). +/// An unknown device maps to 0, so it matches no subscriber. +pub fn deviceBit(device: u32) u32 { + return switch (device) { + @intFromEnum(DeviceKind.keyboard) => device_keyboard, + @intFromEnum(DeviceKind.mouse) => device_mouse, + @intFromEnum(DeviceKind.joystick) => device_joystick, + else => 0, + }; +} + +// --- keyboard --------------------------------------------------------------- + +/// What happened to a key. `key_down`/`key_up` are the physical make/break; `key_press` +/// is the higher-level "a character was produced", carrying it in `KeyEvent.character`. +pub const EventKind = enum(u32) { + key_down = 0, + key_up = 1, + key_press = 2, +}; + +/// One keyboard event. `keycode` names the physical key (layout-independent); `character` +/// is the Unicode scalar for `key_press` (else 0); `modifiers` is an OR of `modifier_*`. +pub const KeyEvent = extern struct { + kind: u32, // an EventKind + keycode: u32, // a Keycode + character: u32, // Unicode scalar for key_press, else 0 + modifiers: u32, // OR of modifier_* +}; + +pub const modifier_shift: u32 = 1 << 0; +pub const modifier_control: u32 = 1 << 1; +pub const modifier_alt: u32 = 1 << 2; + +/// A minimal danos-native keycode namespace — enough for the synthetic source and to show +/// the shape. A real set (USB HID usage-style) fills in with the scancode decoder. +pub const Keycode = enum(u32) { + unknown = 0, + a = 4, // deliberately USB-HID-usage-aligned so a real decoder can extend this + b = 5, + c = 6, + d = 7, + e = 8, + enter = 40, + _, +}; + +// --- mouse ------------------------------------------------------------------ + +/// What a mouse event reports. `motion` carries relative `dx`/`dy`; `button_down`/`up` +/// name a button in `button`; `scroll` carries `scroll_x`/`scroll_y`. +pub const MouseEventKind = enum(u32) { + motion = 0, + button_down = 1, + button_up = 2, + scroll = 3, +}; + +pub const mouse_button_left: u32 = 1 << 0; +pub const mouse_button_right: u32 = 1 << 1; +pub const mouse_button_middle: u32 = 1 << 2; + +/// One mouse event. Relative motion (`dx`/`dy`) and wheel (`scroll_*`) are signed; +/// `buttons` is the current pressed-button bitmask (`mouse_button_*`). +pub const MouseEvent = extern struct { + kind: u32, // a MouseEventKind + button: u32, // the mouse_button_* bit for button_down/up, else 0 + dx: i32, // relative X motion (.motion) + dy: i32, // relative Y motion (.motion) + scroll_x: i32, // horizontal wheel (.scroll) + scroll_y: i32, // vertical wheel (.scroll) + buttons: u32, // current pressed-button bitmask +}; + +// --- joystick / gamepad ----------------------------------------------------- + +/// What a joystick/gamepad event reports. `axis` carries a signed `value` on axis +/// `control`; `button_down`/`up` name a button index in `control`. +pub const JoystickEventKind = enum(u32) { + axis = 0, + button_down = 1, + button_up = 2, +}; + +/// One joystick/gamepad event. `control` is the axis index (`.axis`) or button index +/// (button events); `value` is the axis position (signed, e.g. -32768..32767) for `.axis`; +/// `buttons` is the current pressed-button bitmask. +pub const JoystickEvent = extern struct { + kind: u32, // a JoystickEventKind + control: u32, // axis index (.axis) or button index (button events) + value: i32, // axis value for .axis, else 0 + buttons: u32, // current pressed-button bitmask +}; + +// --- the common envelope ---------------------------------------------------- + +/// The largest per-device event, so `InputEvent` can hold any of them inline. +pub const max_event_size: usize = @max(@sizeOf(KeyEvent), @max(@sizeOf(MouseEvent), @sizeOf(JoystickEvent))); + +/// The tagged envelope broadcast to subscribers: a `DeviceKind` plus the raw bytes of the +/// matching per-device event. Decode it with `asKeyboard`/`asMouse`/`asJoystick` (each +/// returns null unless `device` matches), or build one with the `from*` constructors. +pub const InputEvent = extern struct { + device: u32, // a DeviceKind + _padding: u32 = 0, + data: [max_event_size]u8 = [_]u8{0} ** max_event_size, + + pub fn asKeyboard(self: InputEvent) ?KeyEvent { + if (self.device != @intFromEnum(DeviceKind.keyboard)) return null; + return std.mem.bytesToValue(KeyEvent, self.data[0..@sizeOf(KeyEvent)]); + } + pub fn asMouse(self: InputEvent) ?MouseEvent { + if (self.device != @intFromEnum(DeviceKind.mouse)) return null; + return std.mem.bytesToValue(MouseEvent, self.data[0..@sizeOf(MouseEvent)]); + } + pub fn asJoystick(self: InputEvent) ?JoystickEvent { + if (self.device != @intFromEnum(DeviceKind.joystick)) return null; + return std.mem.bytesToValue(JoystickEvent, self.data[0..@sizeOf(JoystickEvent)]); + } + + pub fn fromKeyboard(event: KeyEvent) InputEvent { + return pack(.keyboard, std.mem.asBytes(&event)); + } + pub fn fromMouse(event: MouseEvent) InputEvent { + return pack(.mouse, std.mem.asBytes(&event)); + } + pub fn fromJoystick(event: JoystickEvent) InputEvent { + return pack(.joystick, std.mem.asBytes(&event)); + } + + fn pack(device: DeviceKind, bytes: []const u8) InputEvent { + var self = InputEvent{ .device = @intFromEnum(device) }; + @memcpy(self.data[0..bytes.len], bytes); + return self; + } +}; + +// --- request / reply -------------------------------------------------------- + +/// Which side of a request this is. +pub const Operation = enum(u32) { + subscribe = 0, // register the caller's endpoint (send_cap) for the classes in device_mask + publish = 1, // a source submits `event` to broadcast to interested subscribers +}; + +/// Request header. For `subscribe`, `device_mask` is the OR of `device_*` bits the caller +/// wants (0 means all) and the caller's receive endpoint travels as the call's capability; +/// `event` is ignored. For `publish`, `event` is the event to broadcast. +pub const Request = extern struct { + operation: u32, // an Operation + device_mask: u32 = 0, // subscribe: interested device classes (0 => all) + event: InputEvent = .{ .device = 0 }, +}; + +/// Reply header. `status` is 0 on success or a negative errno. +pub const Reply = extern struct { + status: i32, + _padding: u32 = 0, +}; + +pub const request_size: usize = @sizeOf(Request); +pub const reply_size: usize = @sizeOf(Reply); +pub const event_size: usize = @sizeOf(InputEvent); + +comptime { + // The delivery path posts a bare InputEvent through ipc_send, so it must fit an + // endpoint's async payload slot (POST_MAXIMUM is 64). + if (event_size > 64) @compileError("InputEvent must fit the ipc_send payload (POST_MAXIMUM)"); +} diff --git a/test/qemu_test.py b/test/qemu_test.py index 982a43f..701ac1b 100644 --- a/test/qemu_test.py +++ b/test/qemu_test.py @@ -250,6 +250,12 @@ CASES = [ {"name": "vfs", "expect": r"DANOS-TEST-RESULT: PASS", "fail": r"DANOS-TEST-RESULT: FAIL"}, + # The input service: a synthetic keyboard source publishes events, the service + # broadcasts them over the async ipc_send primitive, and a subscriber (which joined by + # passing its endpoint as a capability) receives them — source -> service -> subscriber. + {"name": "input", + "expect": r"DANOS-TEST-RESULT: PASS", + "fail": r"DANOS-TEST-RESULT: FAIL"}, # IO passthrough + IRQ-as-IPC: a user-space HPET driver maps device MMIO into # its own address space, binds the device's interrupt to an IPC endpoint, and # is woken by the hardware five times while blocked (never polling). diff --git a/tools/make-xkeyboard-config.py b/tools/make-xkeyboard-config.py new file mode 100644 index 0000000..94c31ab --- /dev/null +++ b/tools/make-xkeyboard-config.py @@ -0,0 +1,468 @@ +#!/usr/bin/env python3 +"""Vendor xkeyboard-config and compile it to a native Zig keymap library. + +danos does not ship an X11 runtime, but it wants X11's keyboard *data*: the layout +tables (US, UK, German, ...) that turn a physical key + modifiers into a character. +So we compile xkeyboard-config down to Zig at build time, the same way the initial +ramdisk is packed by a host-side Python tool. + +Two subcommands: + + fetch Download the pinned xkeyboard-config release, verify its sha256, and copy + the transitively-needed data (the symbols files for the configured layouts + plus everything they `include`) into library/xkeyboard-config/vendor/, + alongside a vendored keysymdef.h, the upstream COPYING, and a PROVENANCE.md. + This is the one step that needs the network; run it when bumping the version. + + generate Parse the vendored data and emit library/xkeyboard-config/generated/layouts.zig + (deterministic, offline). Run whenever the layout list or emitter changes. + +The pipeline per key: our events carry a USB HID usage; HID_TO_NAME maps it to an XKB +key name (); the layout's symbols give the keysyms per level; keysymdef.h resolves +each keysym name to its value and Unicode scalar. Level *selection* (which modifier picks +which level) is deliberately left to the Zig side (xkeyboard-config.zig) — we only emit the +per-key type and its up-to-4 keysyms here. +""" + +import argparse +import hashlib +import io +import os +import re +import sys +import tarfile +import urllib.request + +# --- pinned upstream ------------------------------------------------------- + +VERSION = "2.44" +TARBALL_URL = ( + "https://gitlab.freedesktop.org/xkeyboard-config/xkeyboard-config/-/archive/" + f"xkeyboard-config-{VERSION}/xkeyboard-config-{VERSION}.tar.gz" +) +TARBALL_SHA256 = "35e34edeaf4e8da8d0696ff6b241ee11ddb1b8c6730bac7252d4d0a88ea5f05b" + +# keysymdef.h is xorgproto, not xkeyboard-config; fetch copies it from the build host. +KEYSYMDEF_CANDIDATES = [ + "/opt/homebrew/include/X11/keysymdef.h", + "/usr/include/X11/keysymdef.h", + "/usr/X11/include/X11/keysymdef.h", + "/usr/X11R6/include/X11/keysymdef.h", +] + +# The layouts we generate: (zig name, symbols file, section or None=default). +TARGETS = [ + ("us", "us", None), + ("gb", "gb", None), + ("de", "de", None), + ("fr", "fr", None), + ("es", "es", None), + ("dvorak", "us", "dvorak"), +] + +# USB HID usage (keyboard page 0x07) -> XKB key name. The physical keys we can turn into +# characters; positions are the ANSI standard shared by HID usages and XKB names. +HID_TO_NAME = { + 0x04: "AC01", 0x05: "AB05", 0x06: "AB03", 0x07: "AC03", 0x08: "AD03", + 0x09: "AC04", 0x0A: "AC05", 0x0B: "AC06", 0x0C: "AD08", 0x0D: "AC07", + 0x0E: "AC08", 0x0F: "AC09", 0x10: "AB07", 0x11: "AB06", 0x12: "AD09", + 0x13: "AD10", 0x14: "AD01", 0x15: "AD04", 0x16: "AC02", 0x17: "AD05", + 0x18: "AD07", 0x19: "AB04", 0x1A: "AD02", 0x1B: "AB02", 0x1C: "AD06", + 0x1D: "AB01", + 0x1E: "AE01", 0x1F: "AE02", 0x20: "AE03", 0x21: "AE04", 0x22: "AE05", + 0x23: "AE06", 0x24: "AE07", 0x25: "AE08", 0x26: "AE09", 0x27: "AE10", + 0x2C: "SPCE", + 0x2D: "AE11", 0x2E: "AE12", 0x2F: "AD11", 0x30: "AD12", 0x31: "BKSL", + 0x33: "AC10", 0x34: "AC11", 0x35: "TLDE", + 0x36: "AB08", 0x37: "AB09", 0x38: "AB10", + 0x64: "LSGT", # the extra key on ISO keyboards (102nd key) +} + +# XKB type name -> the KeyType enum tag emitted for the Zig side. +TYPE_TO_TAG = { + "ONE_LEVEL": "one_level", + "TWO_LEVEL": "two_level", + "ALPHABETIC": "alphabetic", + "FOUR_LEVEL": "four_level", + "FOUR_LEVEL_ALPHABETIC": "four_level_alphabetic", + "FOUR_LEVEL_SEMIALPHABETIC": "four_level_semialphabetic", + "FOUR_LEVEL_MIXED_KEYPAD": "keypad", + "FOUR_LEVEL_KEYPAD": "keypad", + "KEYPAD": "keypad", + "PC_SYSRQ": "other", +} + +REPO = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) +LIB = os.path.join(REPO, "library", "xkeyboard-config") +VENDOR = os.path.join(LIB, "vendor") + + +# --- keysymdef.h: keysym name -> (value, unicode scalar or None) ------------ + +def parse_keysymdef(path): + table = {} + line_re = re.compile(r"#define\s+XK_(\w+)\s+0x([0-9a-fA-F]+)\s*(?:/\*\s*U\+([0-9A-Fa-f]+)|/\* (keysym value, unicode scalar or 0).""" + if name in ("NoSymbol", "VoidSymbol", ""): + return (0, 0) + # Unicode escape forms: U00E9 / u00E9. + m = re.fullmatch(r"[Uu]([0-9A-Fa-f]{4,6})", name) + if m: + cp = int(m.group(1), 16) + return (0x01000000 + cp, cp) + # Raw hex keysym value: 0x1000161 (a Unicode keysym) or a plain keysym number. + m = re.fullmatch(r"0x([0-9A-Fa-f]+)", name) + if m: + value = int(m.group(1), 16) + if 0x01000100 <= value <= 0x0110FFFF: + return (value, value - 0x01000000) + if 0x20 <= value <= 0x7E or 0xA0 <= value <= 0xFF: + return (value, value) + return (value, 0) + entry = keysymdef.get(name) + if entry is None: + return (0, 0) # unknown named keysym (dead_*, ISO_*, rare) -> no character + value, unicode_scalar = entry + return (value, unicode_scalar or 0) + + +# --- symbols parsing -------------------------------------------------------- + +def strip_comments(text): + text = re.sub(r"/\*.*?\*/", "", text, flags=re.S) + text = re.sub(r"//[^\n]*", "", text) + return text + + +class KeyDef: + __slots__ = ("levels", "type_name") + + def __init__(self, levels, type_name): + self.levels = levels # list of keysym-name strings (group 1) + self.type_name = type_name # explicit XKB type name, or None + + +class Symbols: + """Loads and resolves xkb_symbols sections from a directory of symbols files.""" + + def __init__(self, symbols_dir): + self.dir = symbols_dir + self._files = {} # filename -> {section_name: body, "__default__": name} + self.visited_files = set() + + def _load(self, fname): + if fname in self._files: + return self._files[fname] + path = os.path.join(self.dir, fname) + self.visited_files.add(fname) + with open(path, encoding="latin-1") as f: + text = strip_comments(f.read()) + sections = {} + default = None + # Find each `[flags] xkb_symbols "NAME" {` and brace-match its body. + for m in re.finditer(r'(\w[\w\s]*?)?\bxkb_symbols\s+"([^"]+)"\s*\{', text): + flags = m.group(1) or "" + name = m.group(2) + body, _ = self._brace_match(text, m.end() - 1) + sections[name] = body + if "default" in flags.split() and default is None: + default = name + if default is None and sections: + default = next(iter(sections)) + sections["__default__"] = default + self._files[fname] = sections + return sections + + @staticmethod + def _brace_match(text, open_index): + depth = 0 + for i in range(open_index, len(text)): + c = text[i] + if c == "{": + depth += 1 + elif c == "}": + depth -= 1 + if depth == 0: + return text[open_index + 1:i], i + raise ValueError("unbalanced braces") + + def resolve(self, fname, section=None, stack=()): + """Merged {key name -> KeyDef} for (fname, section), following includes.""" + sections = self._load(fname) + if section is None: + section = sections["__default__"] + key = (fname, section) + if key in stack: + return {} + body = sections.get(section) + if body is None: + return {} + keys = {} + default_type = None + for stmt in self._statements(body): + kind = stmt[0] + if kind == "include": + augment, inc_file, inc_section = stmt[1], stmt[2], stmt[3] + inc = self.resolve(inc_file, inc_section, stack + (key,)) + for n, kd in inc.items(): + if augment and n in keys: + continue + keys[n] = kd + elif kind == "default_type": + default_type = stmt[1] + elif kind == "key": + augment, name, kd = stmt[1], stmt[2], stmt[3] + if augment and name in keys: + continue + keys[name] = kd + if default_type is not None: + for kd in keys.values(): + if kd.type_name is None: + kd.type_name = default_type + return keys + + def _statements(self, body): + """Yield ('include', augment, file, section) / ('default_type', name) / + ('key', augment, name, KeyDef) in source order.""" + # Recognise the three statement heads and step through the body in order. + head = re.compile( + r'(?P(?:(?Paugment|override|replace)\s+)?include\s+"(?P[^"]+)")' + r'|(?Pkey\.type(?:\[[^\]]*\])?\s*=\s*"(?P[^"]+)")' + r'|(?P(?:(?Paugment|override|replace)\s+)?key\s+<(?P[^>]+)>\s*\{)' + ) + i = 0 + while i < len(body): + m = head.search(body, i) + if not m: + break + if m.group("inc"): + inc_file, inc_section = self._parse_include(m.group("incarg")) + yield ("include", m.group("augi") == "augment", inc_file, inc_section) + i = m.end() + elif m.group("dtype"): + yield ("default_type", m.group("dtypearg")) + i = m.end() + else: # a key definition; brace-match its body + kbody, end = self._brace_match(body, m.end() - 1) + kd = self._parse_key_body(kbody) + if kd is not None: + yield ("key", m.group("augk") == "augment", m.group("kname"), kd) + i = end + 1 + + @staticmethod + def _parse_include(arg): + m = re.fullmatch(r"([^()]+)(?:\(([^)]+)\))?", arg.strip()) + return (m.group(1), m.group(2)) + + @staticmethod + def _parse_key_body(kbody): + type_name = None + mt = re.search(r'type(?:\[[^\]]*\])?\s*=\s*"([^"]+)"', kbody) + if mt: + type_name = mt.group(1) + groups = re.findall(r"\[([^\]]*)\]", kbody) + if not groups: + return None + levels = [tok.strip() for tok in groups[0].split(",")] + levels = [t for t in levels if t != ""] + if not levels: + return None + return KeyDef(levels, type_name) + + +# --- type inference + emission --------------------------------------------- + +def is_case_pair(a, b): + return len(a) == 1 and len(b) == 1 and a.isalpha() and a.islower() and b == a.upper() + + +def key_type_tag(kd): + if kd.type_name is not None: + return TYPE_TO_TAG.get(kd.type_name, "other") + n = len(kd.levels) + if n <= 1: + return "one_level" + if n == 2: + return "alphabetic" if is_case_pair(kd.levels[0], kd.levels[1]) else "two_level" + return "four_level_alphabetic" if is_case_pair(kd.levels[0], kd.levels[1]) else "four_level" + + +def build_layout(symbols, keysymdef, fname, section): + keys = symbols.resolve(fname, section) + table = [] # 256 entries: (tag, [(keysym, unicode) x4]) + for hid in range(256): + name = HID_TO_NAME.get(hid) + kd = keys.get(name) if name else None + if kd is None: + table.append(("one_level", [(0, 0)] * 4)) + continue + levels = [resolve_keysym(kd.levels[i], keysymdef) if i < len(kd.levels) else (0, 0) + for i in range(4)] + table.append((key_type_tag(kd), levels)) + return table + + +def emit_zig(layouts): + out = io.StringIO() + out.write("// GENERATED by tools/make-xkeyboard-config.py from xkeyboard-config " + f"{VERSION}. Do not edit.\n") + out.write("// Keyboard layout tables compiled from the X11 xkeyboard-config database\n") + out.write("// (MIT/X11 licensed; see ../vendor/COPYING and ../vendor/PROVENANCE.md).\n\n") + out.write("pub const Level = struct { keysym: u32 = 0, unicode: u21 = 0 };\n\n") + out.write("pub const KeyType = enum {\n") + out.write(" one_level,\n two_level,\n alphabetic,\n four_level,\n" + " four_level_alphabetic,\n four_level_semialphabetic,\n keypad,\n other,\n};\n\n") + out.write("pub const Key = struct { kind: KeyType = .one_level, levels: [4]Level = [_]Level{.{}} ** 4 };\n\n") + out.write("pub const Layout = struct { name: []const u8, keys: [256]Key };\n\n") + + names = [] + for zig_name, fname, section in TARGETS: + table = layouts[zig_name] + names.append(zig_name) + out.write(f"pub const {zig_name}: Layout = .{{\n") + out.write(f' .name = "{zig_name}",\n') + out.write(" .keys = .{\n") + for hid, (tag, levels) in enumerate(table): + if tag == "one_level" and all(k == 0 and u == 0 for k, u in levels): + out.write(" .{},\n") + continue + parts = ", ".join(f".{{ .keysym = {k}, .unicode = {u} }}" for k, u in levels) + out.write(f" .{{ .kind = .{tag}, .levels = .{{ {parts} }} }},\n") + out.write(" },\n};\n\n") + + out.write("pub const all = [_]*const Layout{ " + ", ".join("&" + n for n in names) + " };\n") + return out.getvalue() + + +# --- fetch ------------------------------------------------------------------ + +def collect_needed(symbols): + for _, fname, section in TARGETS: + symbols.resolve(fname, section) + return set(symbols.visited_files) + + +def find_keysymdef(): + env = os.environ.get("KEYSYMDEF") + if env and os.path.isfile(env): + return env + for p in KEYSYMDEF_CANDIDATES: + if os.path.isfile(p): + return p + sys.exit("error: keysymdef.h not found; install xorgproto or set KEYSYMDEF=/path/to/keysymdef.h") + + +def cmd_fetch(_args): + local = os.environ.get("XKB_TARBALL") + if local: + data = open(local, "rb").read() + else: + print(f"downloading {TARBALL_URL}") + data = urllib.request.urlopen(TARBALL_URL).read() + digest = hashlib.sha256(data).hexdigest() + if digest != TARBALL_SHA256: + sys.exit(f"error: sha256 mismatch\n expected {TARBALL_SHA256}\n got {digest}") + + tar = tarfile.open(fileobj=io.BytesIO(data), mode="r:gz") + members = tar.getnames() + root = members[0].split("/")[0] + + # Extract symbols/ + COPYING to a temp view, resolve includes, keep only what's needed. + tmp = os.path.join(VENDOR, ".upstream") + for m in tar.getmembers(): + if m.name.startswith(f"{root}/symbols/") or m.name == f"{root}/COPYING": + m.name = m.name[len(root) + 1:] + tar.extract(m, tmp) + tar.close() + + needed = collect_needed(Symbols(os.path.join(tmp, "symbols"))) + + os.makedirs(os.path.join(VENDOR, "symbols"), exist_ok=True) + for fname in sorted(needed): + src = os.path.join(tmp, "symbols", fname) + dst = os.path.join(VENDOR, "symbols", fname) + os.makedirs(os.path.dirname(dst), exist_ok=True) + with open(src, "rb") as s, open(dst, "wb") as d: + d.write(s.read()) + _copy(os.path.join(tmp, "COPYING"), os.path.join(VENDOR, "COPYING")) + + keysymdef = find_keysymdef() + _copy(keysymdef, os.path.join(VENDOR, "keysymdef.h")) + + _rmtree(tmp) + + with open(os.path.join(VENDOR, "PROVENANCE.md"), "w") as f: + f.write("# Vendored xkeyboard-config subset\n\n") + f.write(f"- **Package**: xkeyboard-config {VERSION}\n") + f.write(f"- **Source**: {TARBALL_URL}\n") + f.write(f"- **sha256**: `{TARBALL_SHA256}`\n") + f.write(f"- **keysymdef.h**: xorgproto, copied from `{keysymdef}`\n") + f.write("- **License**: MIT/X11 (see COPYING)\n\n") + f.write("Only the symbols files reachable from the generated layouts " + "(tools/make-xkeyboard-config.py `TARGETS`) are vendored; regenerate with\n" + "`python3 tools/make-xkeyboard-config.py fetch` then `... generate`.\n\n") + f.write("Vendored symbols files:\n\n") + for fname in sorted(needed): + f.write(f"- `symbols/{fname}`\n") + print(f"vendored {len(needed)} symbols files + keysymdef.h + COPYING into {VENDOR}") + + +def cmd_generate(args): + symbols_dir = args.symbols or os.path.join(VENDOR, "symbols") + keysymdef_path = args.keysymdef or os.path.join(VENDOR, "keysymdef.h") + keysymdef = parse_keysymdef(keysymdef_path) + symbols = Symbols(symbols_dir) + layouts = {zig_name: build_layout(symbols, keysymdef, fname, section) + for zig_name, fname, section in TARGETS} + out_dir = os.path.join(LIB, "generated") + os.makedirs(out_dir, exist_ok=True) + out_path = os.path.join(out_dir, "layouts.zig") + with open(out_path, "w") as f: + f.write(emit_zig(layouts)) + print(f"wrote {out_path} ({len(TARGETS)} layouts)") + + +def _copy(src, dst): + os.makedirs(os.path.dirname(dst), exist_ok=True) + with open(src, "rb") as s, open(dst, "wb") as d: + d.write(s.read()) + + +def _rmtree(path): + for root, dirs, files in os.walk(path, topdown=False): + for name in files: + os.remove(os.path.join(root, name)) + for name in dirs: + os.rmdir(os.path.join(root, name)) + if os.path.isdir(path): + os.rmdir(path) + + +def main(): + parser = argparse.ArgumentParser(description=__doc__) + sub = parser.add_subparsers(dest="command", required=True) + sub.add_parser("fetch", help="download + vendor the needed xkeyboard-config data") + g = sub.add_parser("generate", help="emit generated/layouts.zig from the vendored data") + g.add_argument("--symbols", help="override the vendored symbols/ dir (for development)") + g.add_argument("--keysymdef", help="override the vendored keysymdef.h (for development)") + args = parser.parse_args() + {"fetch": cmd_fetch, "generate": cmd_generate}[args.command](args) + + +if __name__ == "__main__": + main()