Added update to cursor when string is committed

Cleanups leading to Xwayland compatibility

See merge request Librem5/squeekboard!389

README.md

@@ -30,29 +30,42 @@ Building
 
 ### Dependencies
 
-See `.gitlab-ci.yml`.
+See `.gitlab-ci.yml` or run `apt-get build-dep .`
 
 ### Build from git repo
 
-```
+```bash
 $ git clone https://source.puri.sm/Librem5/squeekboard.git
 $ cd squeekboard
-$ mkdir ../build
-$ meson ../build/
-$ cd ../build
-$ ninja test
-$ ninja install
+$ mkdir _build
+$ meson _build/
+$ cd _build
+$ ninja
 ```
 
+To run tests use `ninja test`. To install squeekboard run `ninja install`.
+
 Running
 -------
 
-```
+```bash
 $ phoc # if no compatible Wayland compositor is running yet
 $ cd ../build/
 $ src/squeekboard
 ```
 
+Squeekboard honors the gnome "screen-keyboard-enabled" setting. Either enable this through gnome-settings under accessibility or run:
+
+```bash
+$ gsettings set org.gnome.desktop.a11y.applications screen-keyboard-enabled true
+```
+
+To make the keyboard show you can use either an application that does so automatically, like a text editor or `python3 ./tests/entry.py`, or you can manually trigger it with:
+
+```bash
+busctl call --user sm.puri.OSK0 /sm/puri/OSK0 sm.puri.OSK0 SetVisible b true
+```
+
 Developing
 ----------
 

data/keyboards/be.yaml

@@ -0,0 +1,89 @@
+---
+outlines:
+    default:   { width: 35.33, height: 52 }
+    altline:   { width: 52.67, height: 52 }
+    wide:      { width: 59,    height: 52 }
+    spaceline: { width: 140,   height: 52 }
+    special:   { width: 44,    height: 52 }
+
+views:
+    base:
+        - "a z e r t y u i o p"
+        - "q s d f g h j k l m"
+        - "Shift_L   w x c v b n .   BackSpace"
+        - "show_numbers preferences         space        show_eschars Return"
+    upper:
+        - "A Z E R T Y U I O P"
+        - "Q S D F G H J K L M"
+        - "Shift_L   W X C V B N ,  BackSpace"
+        - "show_numbers preferences         space        show_eschars Return"
+    numbers:
+        - "1 2 3 4 5 6 7 8 9 0"
+        - "@ # € % & - _ + ( )"
+        - "show_symbols   , \" ' colon ; ! ?  BackSpace"
+        - "show_letters preferences         space        show_eschars Return"
+    symbols:
+        - "~ ` | · √ π τ ÷ × ¶"
+        - "© ® £ $ ¥ ^ ° * { }"
+        - "show_numbers_from_symbols   \\ / < > = [ ]  BackSpace"
+        - "show_letters preferences         space        show_eschars Return"
+    eschars:
+        - "à â ç é è ê î ô ù û"
+        - "À Â Ç É È Ê Î Ô Ù Û"
+        - "show_numbers_from_symbols  æ œ ä ë ï ö ü  BackSpace"
+        - "show_letters preferences         space        show_eschars Return"
+
+buttons:
+    Shift_L:
+        action:
+            locking:
+                lock_view: "upper"
+                unlock_view: "base"
+        outline: "altline"
+        icon: "key-shift"
+    BackSpace:
+        outline: "altline"
+        icon: "edit-clear-symbolic"
+        action: erase
+    preferences:
+        action: "show_prefs"
+        outline: "special"
+        icon: "keyboard-mode-symbolic"
+    show_numbers:
+        action:
+            set_view: "numbers"
+        outline: "wide"
+        label: "123"
+    show_numbers_from_symbols:
+        action:
+            set_view: "numbers"
+        outline: "altline"
+        label: "123"
+    show_letters:
+        action:
+            set_view: "base"
+        outline: "wide"
+        label: "abc"
+    show_symbols:
+        action:
+            set_view: "symbols"
+        outline: "altline"
+        label: "*/="
+    show_eschars:
+        action:
+            locking:
+                lock_view: "eschars"
+                unlock_view: "base"
+        outline: "altline"
+        label: "âÂ"
+    space:
+        outline: "spaceline"
+        text: " "
+    Return:
+        outline: "wide"
+        icon: "key-enter"
+        keysym: "Return"
+    colon:
+        text: ":"
+    "\"":
+        keysym: "quotedbl"

data/keyboards/be_wide.yaml

@@ -0,0 +1,89 @@
+---
+outlines:
+    default:   { width: 54,  height: 42 }
+    altline:   { width: 81,  height: 42 }
+    wide:      { width: 100, height: 42 }
+    spaceline: { width: 205, height: 42 }
+    special:   { width: 54,  height: 42 }
+
+views:
+    base:
+        - "a z e r t y u i o p"
+        - "q s d f g h j k l m"
+        - "Shift_L   w x c v b n .   BackSpace"
+        - "show_numbers preferences         space        show_eschars Return"
+    upper:
+        - "A Z E R T Y U I O P"
+        - "Q S D F G H J K L M"
+        - "Shift_L   W X C V B N ,  BackSpace"
+        - "show_numbers preferences         space        show_eschars Return"
+    numbers:
+        - "1 2 3 4 5 6 7 8 9 0"
+        - "@ # € % & - _ + ( )"
+        - "show_symbols   , \" ' colon ; ! ?  BackSpace"
+        - "show_letters preferences         space        show_eschars Return"
+    symbols:
+        - "~ ` | · √ π τ ÷ × ¶"
+        - "© ® £ $ ¥ ^ ° * { }"
+        - "show_numbers_from_symbols   \\ / < > = [ ]  BackSpace"
+        - "show_letters preferences         space        show_eschars Return"
+    eschars:
+        - "à â ç é è ê î ô ù û"
+        - "À Â Ç É È Ê Î Ô Ù Û"
+        - "show_numbers_from_symbols  æ œ ä ë ï ö ü  BackSpace"
+        - "show_letters preferences         space        show_eschars Return"
+
+buttons:
+    Shift_L:
+        action:
+            locking:
+                lock_view: "upper"
+                unlock_view: "base"
+        outline: "altline"
+        icon: "key-shift"
+    BackSpace:
+        outline: "altline"
+        icon: "edit-clear-symbolic"
+        action: erase
+    preferences:
+        action: "show_prefs"
+        outline: "special"
+        icon: "keyboard-mode-symbolic"
+    show_numbers:
+        action:
+            set_view: "numbers"
+        outline: "wide"
+        label: "123"
+    show_numbers_from_symbols:
+        action:
+            set_view: "numbers"
+        outline: "altline"
+        label: "123"
+    show_letters:
+        action:
+            set_view: "base"
+        outline: "wide"
+        label: "abc"
+    show_symbols:
+        action:
+            set_view: "symbols"
+        outline: "altline"
+        label: "*/="
+    show_eschars:
+        action:
+            locking:
+                lock_view: "eschars"
+                unlock_view: "base"
+        outline: "altline"
+        label: "âÂ"
+    space:
+        outline: "spaceline"
+        text: " "
+    Return:
+        outline: "wide"
+        icon: "key-enter"
+        keysym: "Return"
+    colon:
+        text: ":"
+    "\"":
+        keysym: "quotedbl"

data/keyboards/fr_wide.yaml

@@ -0,0 +1,89 @@
+---
+outlines:
+    default:   { width: 54,  height: 42 }
+    altline:   { width: 81,  height: 42 }
+    wide:      { width: 100, height: 42 }
+    spaceline: { width: 205, height: 42 }
+    special:   { width: 54,  height: 42 }
+
+views:
+    base:
+        - "a z e r t y u i o p"
+        - "q s d f g h j k l m"
+        - "Shift_L   w x c v b n .   BackSpace"
+        - "show_numbers preferences         space        show_eschars Return"
+    upper:
+        - "A Z E R T Y U I O P"
+        - "Q S D F G H J K L M"
+        - "Shift_L   W X C V B N ,  BackSpace"
+        - "show_numbers preferences         space        show_eschars Return"
+    numbers:
+        - "1 2 3 4 5 6 7 8 9 0"
+        - "@ # € % & - _ + ( )"
+        - "show_symbols   , \" ' colon ; ! ?  BackSpace"
+        - "show_letters preferences         space        show_eschars Return"
+    symbols:
+        - "~ ` | · √ π τ ÷ × ¶"
+        - "© ® £ $ ¥ ^ ° * { }"
+        - "show_numbers_from_symbols   \\ / < > = [ ]  BackSpace"
+        - "show_letters preferences         space        show_eschars Return"
+    eschars:
+        - "à â ç é è ê î ô ù û"
+        - "À Â Ç É È Ê Î Ô Ù Û"
+        - "show_numbers_from_symbols  æ œ ä ë ï ö ü  BackSpace"
+        - "show_letters preferences         space        show_eschars Return"
+
+buttons:
+    Shift_L:
+        action:
+            locking:
+                lock_view: "upper"
+                unlock_view: "base"
+        outline: "altline"
+        icon: "key-shift"
+    BackSpace:
+        outline: "altline"
+        icon: "edit-clear-symbolic"
+        action: erase
+    preferences:
+        action: "show_prefs"
+        outline: "special"
+        icon: "keyboard-mode-symbolic"
+    show_numbers:
+        action:
+            set_view: "numbers"
+        outline: "wide"
+        label: "123"
+    show_numbers_from_symbols:
+        action:
+            set_view: "numbers"
+        outline: "altline"
+        label: "123"
+    show_letters:
+        action:
+            set_view: "base"
+        outline: "wide"
+        label: "abc"
+    show_symbols:
+        action:
+            set_view: "symbols"
+        outline: "altline"
+        label: "*/="
+    show_eschars:
+        action:
+            locking:
+                lock_view: "eschars"
+                unlock_view: "base"
+        outline: "altline"
+        label: "âÂ"
+    space:
+        outline: "spaceline"
+        text: " "
+    Return:
+        outline: "wide"
+        icon: "key-enter"
+        keysym: "Return"
+    colon:
+        text: ":"
+    "\"":
+        keysym: "quotedbl"

data/keyboards/terminal_wide.yaml

@@ -0,0 +1,211 @@
+---
+outlines:
+    default:   { width: 54,   height: 37 }
+    action:    { width: 90,   height: 37 }
+    altline:   { width: 81,   height: 37 }
+    wide:      { width: 90,   height: 37 }
+    spaceline: { width: 225,  height: 37 }
+    special:   { width: 54,   height: 37 }
+    small:     { width: 67.4, height: 22 }
+
+views:
+    base:
+        - "EscSmall TabSmall Ctrl Alt ↑ ↓ ← →"
+        - "q w e r t y u i o p"
+        - "a s d f g h j k l"
+        - "Shift_L   z x c v b n m  BackSpace"
+        - "show_numbers preferences      space        show_actions Return"
+    upper:
+        - "EscSmall TabSmall Ctrl Alt PgUp PgDn Home End"
+        - "Q W E R T Y U I O P"
+        - "A S D F G H J K L"
+        - "Shift_L   Z X C V B N M  BackSpace"
+        - "show_numbers preferences      space        show_actions Return"
+    numbers:
+        - "EscSmall TabSmall Ctrl Alt ↑ ↓ ← →"
+        - "1 2 3 4 5 6 7 8 9 0"
+        - "* # $ / & - _ + ( )"
+        - "show_symbols   , \" ' colon ; ! ?  BackSpace"
+        - "show_letters preferences         space        period Return"
+    symbols:
+        - "EscSmall TabSmall Ctrl Alt ↑ ↓ ← →"
+        - "~ ` | · √ π τ ÷ × ¶"
+        - "© ® £ € ¥ ^ ° @ { }"
+        - "show_numbers_from_symbols   \\ % < > = [ ]  BackSpace"
+        - "show_letters preferences         space        period Return"
+    actions:
+        - "EscSmall TabSmall Ctrl Alt PgUp PgDn Home End"
+        - "F1  F2  F3  F4  F5  F6"
+        - "F7  F8  F9  F10 F11 F12"
+        - "Esc Tab Pause Insert Up Del"
+        - "show_letters Menu Break Left Down Right"
+
+buttons:
+    Shift_L:
+        action:
+            locking:
+                lock_view: "upper"
+                unlock_view: "base"
+        outline: "altline"
+        icon: "key-shift"
+    BackSpace:
+        outline: "altline"
+        icon: "edit-clear-symbolic"
+        action: erase
+    preferences:
+        action: "show_prefs"
+        outline: "special"
+        icon: "keyboard-mode-symbolic"
+    show_numbers:
+        action:
+            set_view: "numbers"
+        outline: "wide"
+        label: "123"
+    show_numbers_from_symbols:
+        action:
+            set_view: "numbers"
+        outline: "altline"
+        label: "123"
+    show_letters:
+        action:
+            set_view: "base"
+        outline: "wide"
+        label: "ABC"
+    show_symbols:
+        action:
+            set_view: "symbols"
+        outline: "altline"
+        label: "τ=\\"
+    show_actions:
+        action:
+            set_view: "actions"
+        outline: "altline"
+        label: ">_"
+    period:
+        outline: "altline"
+        text: "."
+    space:
+        outline: "spaceline"
+        text: " "
+    Return:
+        outline: "wide"
+        icon: "key-enter"
+        keysym: "Return"
+    colon:
+        text: ":"
+    F1:
+        outline: "action"
+        keysym: "F1"
+    F2:
+        outline: "action"
+        keysym: "F2"
+    F3:
+        outline: "action"
+        keysym: "F3"
+    F4:
+        outline: "action"
+        keysym: "F4"
+    F5:
+        outline: "action"
+        keysym: "F5"
+    F6:
+        outline: "action"
+        keysym: "F6"
+    F7:
+        outline: "action"
+        keysym: "F7"
+    F8:
+        outline: "action"
+        keysym: "F8"
+    F9:
+        outline: "action"
+        keysym: "F9"
+    F10:
+        outline: "action"
+        keysym: "F10"
+    F11:
+        outline: "action"
+        keysym: "F11"
+    F12:
+        outline: "action"
+        keysym: "F12"
+    Esc:
+        outline: "action"
+        keysym: "Escape"
+    EscSmall:
+        outline: "small"
+        keysym: "Escape"
+        label: "Esc"
+    Tab:
+        outline: "action"
+        keysym: "Tab"
+    TabSmall:
+        outline: "small"
+        keysym: "Tab"
+        label: "Tab"
+    Del:
+        outline: "action"
+        keysym: "Delete"
+    Insert:
+        outline: "action"
+        keysym: "Insert"
+    Menu:
+        outline: "action"
+        keysym: "Menu"
+    Pause:
+        outline: "action"
+        keysym: "Pause"
+    Menu:
+        outline: "action"
+        keysym: "Menu"
+    Break:
+        outline: "action"
+        keysym: "Break"
+    Home:
+        outline: "small"
+        keysym: "Home"
+    End:
+        outline: "small"
+        keysym: "End"
+    PgUp:
+        outline: "small"
+        keysym: "Page_Up"
+    PgDn:
+        outline: "small"
+        keysym: "Page_Down"
+    "↑":
+        outline: "small"
+        keysym: "Up"
+    "↓":
+        outline: "small"
+        keysym: "Down"
+    "←":
+        outline: "small"
+        keysym: "Left"
+    "→":
+        outline: "small"
+        keysym: "Right"
+    Up:
+        label: "↑"
+        outline: "action"
+        keysym: "Up"
+    Left:
+        label: "←"
+        outline: "action"
+        keysym: "Left"
+    Down:
+        label: "↓"
+        outline: "action"
+        keysym: "Down"
+    Right:
+        label: "→"
+        outline: "action"
+        keysym: "Right"
+    Ctrl:
+        modifier: "Control"
+        outline: "small"
+        label: "Ctrl"
+    Alt:
+        modifier: "Alt"
+        outline: "small"
+        label: "Alt"

debian/control

@@ -38,6 +38,8 @@ Depends:
  gnome-themes-extra-data,
  ${shlibs:Depends},
  ${misc:Depends},
+Breaks:
+ librem5-base (<< 24),
 Description: On-screen keyboard for Wayland
  Virtual keyboard supporting Wayland, built primarily for the Librem 5 phone.
 

doc/hacking.md

@@ -13,16 +13,16 @@ The overarching principle of *squeekboard* is to empower users.
 Software is primarily meant to solve problems of its users. Often in the quest to make software better, a hard distinction is made between the developer, who becomes the creator, and the user, who takes the role of the consumer, without direct influence on the software they use.
 This project aims to give users the power to make the software work for them by blurring the lines between users and developers.
 
-Nonwithstanding its current state, *squeekboard* must be structured in a way that provides users a gradual way to gain more experience and power to adjust it. It must be easy, in order of importance:
+Notwithstanding its current state, *squeekboard* must be structured in a way that provides users a gradual way to gain more experience and power to adjust it. It must be easy, in order of importance:
 
 - to use the software,
 - to modify its resources,
-- to change its behaviour,
+- to change its behavior,
 - to contribute upstream.
 
 To give an idea of what it means in practice, those are some examples of what has been important for *squeekboard* so far:
 
-- being quick and useable,
+- being quick and usable,
 - allowing local overrides of resources and config,
 - storing resources and config as editable, standard files,
 - having complete, up to date documentation of interfaces,
@@ -33,7 +33,7 @@ To give an idea of what it means in practice, those are some examples of what ha
 - having code that is [simple and obvious](https://www.python.org/dev/peps/pep-0020/),
 - having an easy process of testing and accepting contributions.
 
-You may notice that they are ordered roughly from "user-focused" to "maintainer-focused". While good properties are desired, sometimes they conflict, and maintainers should give additional weight to those benefitting the user compared to those benefitting regular contributors.
+You may notice that they are ordered roughly from "user-focused" to "maintainer-focused". While good properties are desired, sometimes they conflict, and maintainers should give additional weight to those benefiting the user compared to those benefiting regular contributors.
 
 Sending patches
 ---------------
@@ -43,7 +43,7 @@ By submitting a change to this project, you agree to license it under the [GPL l
 Development environment
 -----------------------
 
-*Squeekboard* is regularly built and tested on [the develpment environment](https://developer.puri.sm/Librem5/Development_Environment.html).
+*Squeekboard* is regularly built and tested on [the development environment](https://developer.puri.sm/Librem5/Development_Environment.html).
 
 Recent Fedora releases are likely to be tested as well.
 
@@ -162,7 +162,7 @@ Maintenance
 
 Squeekboard uses Rust & Cargo for some of its dependencies.
 
-Use the `cargo.sh` script for maintaining the Cargo part of the build. The script takes the usual Cargo commands, after the first 2 positionsl arguments: source directory, and output artifact. So, `cargo test` becomes:
+Use the `cargo.sh` script for maintaining the Cargo part of the build. The script takes the usual Cargo commands, after the first 2 positional arguments: source directory, and output artifact. So, `cargo test` becomes:
 
 ```
 cd build_dir

doc/tutorial.md

@@ -1,34 +1,87 @@
-Kareema's guide to creating layouts
-===================================
+A guide to creating layouts
+===========================
+
+This guide is based on the original Kareema's [forum post](https://forums.puri.sm/t/translations-and-virtual-touch-keyboards-tracking-localization/7669/48).
 
 It’s long overdue to write a comprehensive guide how to add a keyboard layout from start. But unfortunately, I don’t have much time left ATM. A lot of information can be found in [this](https://forums.puri.sm/t/using-non-latin-language-on-librem-5/7103/5) thread.
 
-So at least I will try to start writing a short how-to here and edit this post as I find the time. Hope this helps a bit - comments and corrections welcome.
+So at least I will try to start writing a short how-to here and edit this post as I find the time. Hope this helps a bit - comments and corrections [welcome](https://source.puri.sm/Librem5/squeekboard/-/merge_requests/)
 
-**Get one of the existing keyboard layouts**
+## Creating a new layout
+
+Creating a layout is easy. You don't need to recompile things, just edit and test. It's easiest to start with an existing layout.
+
+### Get one of the existing keyboard layouts
 
 * You can get one of the keyboards from the squeekboard git repository : [https://source.puri.sm/Librem5/squeekboard](https://source.puri.sm/Librem5/squeekboard)
-* The keyboard layouts are located in the subdirectory `data/keyboard/` in the `.yaml` files
+* The keyboard layouts are located in the subdirectory [`data/keyboards/`](https://source.puri.sm/Librem5/squeekboard/-/tree/master/data/keyboards) in the `.yaml` files
 * Take a look and try to understand them :slight_smile:
 
-**Fork your own copy of squeekboard**
+
+### Creating the keyboard layout
+
+* To be written: For the time being, take a look at [Using non-latin language on Librem 5](https://forums.puri.sm/t/using-non-latin-language-on-librem-5/7103/5)
+* The correct name of the .yaml file can be found with the command 
+
+```
+gsettings get org.gnome.desktop.input-sources sources
+```
+
+The output should be something like this: `[('xkb', 'us'), ('xkb', 'de')]`
+So for example “de.yaml” would be the correct name for the German keyboard layout.
+
+If the name of your layout is not translated correctly in the list, you can fix it by adding it and recompiling Squeekboard.
+
+### Testing the layout
+
+Copy your yaml file to `~/.local/share/squeekboard/keyboards/` for testing purposes. From there it should get picked up by squeekboard automatically.
+
+You can also use the `test_layout` tool from the -devel package to check it for errors:
+
+```
+# squeekboard_test_layout ./mylayout.yaml
+Test result: OK
+```
+
+## Contributing your changes
+
+If you want to share your layout with the world, the best way is to submit it to the Squeekboard project. The workflow is similar to any other Gitlab-based project.
+
+Above all, your layout should be working, be tested, not break anything, and make sense.
+
+### Fork your own copy of squeekboard
 
 * Best way would be to start with a fork of the squeekboard repository: Create a user account at https://source.puri.sm/, go the the squeekboard git repository, press “Fork” in the web interface. You can find further instructions [here](https://docs.gitlab.com/ee/user/project/repository/forking_workflow.html#creating-a-fork).
 * Clone your fork locally with `git clone` and use the uri of your forked repo there
 
-**Workflow to edit your keyboard and get it merged**
+### Edit your keyboard and get it merged
 
-* A generic guide how the workflow to contribute works, can be found at https://developer.puri.sm/Librem5/Contact/Contributing.html
+* It may be useful to check out the [generic guide how the workflow to contribute works](https://developer.puri.sm/Librem5/Contact/Contributing.html)
 * Create a branch: Name it “keyboard-layout-mylanguage” or whatever
 * Checkout your branch, edit your keyboard layout and commit your changes
+* Your layout **must** be correctly named, and in `data/keyboards/`.
+* Your layout **must** pass the `test_layout` tool with zero problems.
+* Your translation **must** be correctly named, and in `data/langs/`.
+* Your layout or translation **must** be added to automatic tests. **Don’t forget to add it** to `src/resources.rs` and the layout to `tests/meson.build` (that’s for me, because I always forget it).
+
+### Get it merged
+
+It's always recommended to **compile and run** squeekboard before submitting your changes. This serves as a test that all is working. See instructions in the [compiling section](#compiling-and-running-squeekboard).
+
 * Push the local changes (to the branch of your fork of squeekboard)
 * Create a merge request for the branch to get your changes merged to the official squeekboard git repository
 
-**Compile squeekboard**
+If your changes pass automated tests (CI), then the merge request will be reviewed by the maintainers, and you might be asked to change a thing or two.
+
+## Compiling and running Squeekboard
+
+If you want your change to become part of official Squeekboard, or if you want to add a translation of your layout name, you will have to recompile Squeekboard and test your changes there.
+
+### Compile squeekboard
 
 * Follow the instructions found in “Building” section of the squeekboard’s README: Running squeekboard: [https://source.puri.sm/Librem5/squeekboard/blob/master/README.md#building](https://source.puri.sm/Librem5/squeekboard/blob/master/README.md#building)
 
-**Running squeekboard**
+### Run squeekboard
 
 * Follow these instructions to run squeekboard: [https://source.puri.sm/Librem5/squeekboard/blob/master/README.md#running](https://source.puri.sm/Librem5/squeekboard/blob/master/README.md#running)
 * Additionally take a look at the contribution document for [testing info](HACKING.md#testing)
@@ -37,19 +90,3 @@ So at least I will try to start writing a short how-to here and edit this post a
   `deb [arch=amd64] http://ci.puri.sm/ scratch librem5`
 
 Squeekboard can be installed from there as a Debian package, too (that’s what I often do). But beware - there be dragons! You could bork your system with these packages and you should probably disable this repository again after installing what you need - these packages are not meant for production systems (or so I heard :wink: )
-
-**Creating the keyboard layout**
-
-* To be written: For the time being, take a look at [Using non-latin language on Librem 5 ](https://forums.puri.sm/t/using-non-latin-language-on-librem-5/7103/5)
-* The correct name of the .yaml file can be found with the command `gsettings get org.gnome.desktop.input-sources sources`
-
-The output should be something like this: `[('xkb', 'us'), ('xkb', 'de')]`
-So f.ex. “de.yaml” would be the correct name for the German keyboard layout.
-* The translations for the keyboard layout names in the different languages can be found at `data/langs/`
-* Don’t forget to add your newly created layout or translation to `src/resources.rs` and the layout to `tests/meson.build` (that’s for me, because I always forget it)
-
-**Testing the layout**
-
-* Copy your yaml file to `~/.local/share/squeekboard/keyboards/` for testing purposes. From there it should get picked up by squeekboard
-* To test the translations in `data/langs/` , you have to compile squeekboard
-

eek/eek-gtk-keyboard.c

@@ -104,10 +104,10 @@ eek_gtk_keyboard_real_draw (GtkWidget *self,
     return FALSE;
 }
 
-// Units of pixel size
+// Units of virtual pixels size
 static enum squeek_arrangement_kind get_type(uint32_t width, uint32_t height) {
     (void)height;
-    if (width < 1080) {
+    if (width < 540) {
         return ARRANGEMENT_KIND_BASE;
     }
     return ARRANGEMENT_KIND_WIDE;
@@ -119,11 +119,10 @@ eek_gtk_keyboard_real_size_allocate (GtkWidget     *self,
 {
     EekGtkKeyboardPrivate *priv =
         eek_gtk_keyboard_get_instance_private (EEK_GTK_KEYBOARD (self));
-    uint32_t scale = (uint32_t)gtk_widget_get_scale_factor(self);
     // check if the change would switch types
     enum squeek_arrangement_kind new_type = get_type(
-                (uint32_t)(allocation->width - allocation->x) * scale,
-                (uint32_t)(allocation->height - allocation->y) * scale);
+                (uint32_t)(allocation->width - allocation->x),
+                (uint32_t)(allocation->height - allocation->y));
     if (priv->layout->arrangement != new_type) {
         priv->layout->arrangement = new_type;
         uint32_t time = gdk_event_get_time(NULL);
@@ -360,6 +359,10 @@ eek_gtk_keyboard_init (EekGtkKeyboard *self)
         priv->event = lfb_event_new ("button-pressed");
     else
         g_warning ("Failed to init libfeedback: %s", err->message);
+
+    GtkIconTheme *theme = gtk_icon_theme_get_default ();
+
+    gtk_icon_theme_add_resource_path (theme, "/sm/puri/squeekboard/icons");
 }
 
 static void

eek/eek-keyboard.c

@@ -28,33 +28,24 @@
 #include <sys/random.h> // TODO: this is Linux-specific
 #include <xkbcommon/xkbcommon.h>
 
-
 #include "eek-keyboard.h"
 
-void level_keyboard_free(LevelKeyboard *self) {
-    xkb_keymap_unref(self->keymap);
-    close(self->keymap_fd);
-    squeek_layout_free(self->layout);
-    g_free(self);
+
+static void eek_key_map_deinit(struct keymap *self) {
+    if (self->fd < 0) {
+        g_error("Deinit called multiple times on KeyMap");
+    } else {
+        close(self->fd);
+    }
+    self->fd = -1;
 }
 
-LevelKeyboard*
-level_keyboard_new (struct squeek_layout *layout)
-{
-    LevelKeyboard *keyboard = g_new0(LevelKeyboard, 1);
-
-    if (!keyboard) {
-        g_error("Failed to create a keyboard");
-    }
-    keyboard->layout = layout;
-
+static struct keymap eek_key_map_from_str(const char *keymap_str) {
     struct xkb_context *context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
     if (!context) {
         g_error("No context created");
     }
 
-    const gchar *keymap_str = squeek_layout_get_keymap(keyboard->layout);
-
     struct xkb_keymap *keymap = xkb_keymap_new_from_string(context, keymap_str,
         XKB_KEYMAP_FORMAT_TEXT_V1, XKB_KEYMAP_COMPILE_NO_FLAGS);
 
@@ -62,10 +53,9 @@ level_keyboard_new (struct squeek_layout *layout)
         g_error("Bad keymap:\n%s", keymap_str);
 
     xkb_context_unref(context);
-    keyboard->keymap = keymap;
 
-    keymap_str = xkb_keymap_get_as_string(keymap, XKB_KEYMAP_FORMAT_TEXT_V1);
-    keyboard->keymap_len = strlen(keymap_str) + 1;
+    char *xkb_keymap_str = xkb_keymap_get_as_string(keymap, XKB_KEYMAP_FORMAT_TEXT_V1);
+    size_t keymap_len = strlen(xkb_keymap_str) + 1;
 
     g_autofree char *path = strdup("/eek_keymap-XXXXXX");
     char *r = &path[strlen(path) - 6];
@@ -79,17 +69,42 @@ level_keyboard_new (struct squeek_layout *layout)
     if (keymap_fd < 0) {
         g_error("Failed to set up keymap fd");
     }
-    keyboard->keymap_fd = keymap_fd;
+
     shm_unlink(path);
-    if (ftruncate(keymap_fd, (off_t)keyboard->keymap_len)) {
+    if (ftruncate(keymap_fd, (off_t)keymap_len)) {
         g_error("Failed to increase keymap fd size");
     }
-    char *ptr = mmap(NULL, keyboard->keymap_len, PROT_WRITE, MAP_SHARED,
+    char *ptr = mmap(NULL, keymap_len, PROT_WRITE, MAP_SHARED,
         keymap_fd, 0);
     if ((void*)ptr == (void*)-1) {
         g_error("Failed to set up mmap");
     }
-    strncpy(ptr, keymap_str, keyboard->keymap_len);
-    munmap(ptr, keyboard->keymap_len);
+    strncpy(ptr, xkb_keymap_str, keymap_len);
+    munmap(ptr, keymap_len);
+    free(xkb_keymap_str);
+    xkb_keymap_unref(keymap);
+    struct keymap km = {
+        .fd = keymap_fd,
+        .fd_len = keymap_len,
+    };
+    return km;
+}
+
+void level_keyboard_free(LevelKeyboard *self) {
+    eek_key_map_deinit(&self->keymap);
+    squeek_layout_free(self->layout);
+    g_free(self);
+}
+
+LevelKeyboard*
+level_keyboard_new (struct squeek_layout *layout)
+{
+    LevelKeyboard *keyboard = g_new0(LevelKeyboard, 1);
+    if (!keyboard) {
+        g_error("Failed to create a keyboard");
+    }
+    keyboard->layout = layout;
+    const gchar *keymap_str = squeek_layout_get_keymap(keyboard->layout);
+    keyboard->keymap = eek_key_map_from_str(keymap_str);
     return keyboard;
 }

eek/eek-keyboard.h

@@ -32,19 +32,20 @@
 
 G_BEGIN_DECLS
 
+/// Keymap container for Rust interoperability.
+struct keymap {
+    uint32_t fd; // keymap formatted as XKB string
+    size_t fd_len; // length of the data inside keymap_fd
+};
+
 /// Keyboard state holder
 struct _LevelKeyboard {
     struct squeek_layout *layout; // owned
-    struct xkb_keymap *keymap; // owned
-    int keymap_fd; // keymap formatted as XKB string
-    size_t keymap_len; // length of the data inside keymap_fd
-
-    guint id; // as a key to layout choices
+    struct keymap keymap; // owned
 };
 typedef struct _LevelKeyboard LevelKeyboard;
 
-gchar *             eek_keyboard_get_keymap
-                                     (LevelKeyboard *keyboard);
+gchar *eek_keyboard_get_keymap(LevelKeyboard *keyboard);
 
 LevelKeyboard*
 level_keyboard_new (struct squeek_layout *layout);

eek/eek-renderer.c

@@ -265,10 +265,6 @@ renderer_init (EekRenderer *self)
     self->allocation_height = 0.0;
     self->scale_factor = 1;
 
-    GtkIconTheme *theme = gtk_icon_theme_get_default ();
-
-    gtk_icon_theme_add_resource_path (theme, "/sm/puri/squeekboard/icons");
-
     self->css_provider = squeek_load_style();
 }
 

examples/test_layout.rs

@@ -5,6 +5,7 @@ use std::env;
 
 fn main() -> () {
     check_builtin_layout(
-        env::args().nth(1).expect("No argument given").as_str()
+        env::args().nth(1).expect("No argument given").as_str(),
+        env::args().nth(2).map(|s| s == "allow_missing_return").unwrap_or(false),
     );
 }

meson.build

@@ -19,6 +19,7 @@ add_project_arguments(
     '-Werror=missing-field-initializers',
     '-Werror=incompatible-pointer-types',
     '-Werror=int-conversion',
+    '-Werror=redundant-decls',
     '-Wformat-nonliteral',
     '-Wformat-security',
     '-Winit-self',

src/data.rs

@@ -382,37 +382,28 @@ impl Layout {
                 )
             )}).collect();
 
-        let keymap: HashMap<String, u32> = generate_keycodes(
-            button_actions.iter()
-                .filter_map(|(_name, action)| {
-                    match action {
-                        ::action::Action::Submit {
-                            text: _, keys,
-                        } => Some(keys),
-                        _ => None,
-                    }
-                })
-                .flatten()
-                .map(|named_keysym| named_keysym.0.as_str())
+        let symbolmap: HashMap<String, u32> = generate_keycodes(
+            extract_symbol_names(&button_actions)
         );
 
-        let button_states = button_actions.into_iter().map(|(name, action)| {
+        let button_states = HashMap::<String, KeyState>::from_iter(
+            button_actions.into_iter().map(|(name, action)| {
                 let keycodes = match &action {
                     ::action::Action::Submit { text: _, keys } => {
-                    keys.iter().map(|named_keycode| {
-                        *keymap.get(named_keycode.0.as_str())
+                        keys.iter().map(|named_keysym| {
+                            *symbolmap.get(named_keysym.0.as_str())
                                 .expect(
                                     format!(
-                                    "keycode {} in key {} missing from keymap",
-                                    named_keycode.0,
+                                        "keysym {} in key {} missing from symbol map",
+                                        named_keysym.0,
                                         name
                                     ).as_str()
                                 )
                         }).collect()
                     },
                     action::Action::Erase => vec![
-                    *keymap.get("BackSpace")
-                        .expect(&format!("BackSpace missing from keymap")),
+                        *symbolmap.get("BackSpace")
+                            .expect(&format!("BackSpace missing from symbol map")),
                     ],
                     _ => Vec::new(),
                 };
@@ -424,14 +415,10 @@ impl Layout {
                         action,
                     }
                 )
-        });
-
-        let button_states = HashMap::<String, KeyState>::from_iter(
-            button_states
+            })
         );
 
-        // TODO: generate from symbols
-        let keymap_str = match generate_keymap(&button_states) {
+        let keymap_str = match generate_keymap(symbolmap) {
             Err(e) => { return (Err(e), warning_handler) },
             Ok(v) => v,
         };
@@ -459,14 +446,14 @@ impl Layout {
                                 &mut warning_handler,
                             ))
                         });
-                    layout::Row {
-                        buttons: add_offsets(
+                    layout::Row::new(
+                        add_offsets(
                             buttons,
                             |button| button.size.width,
                         ).collect()
-                    }
+                    )
                 });
-                let rows = add_offsets(rows, |row| row.get_height())
+                let rows = add_offsets(rows, |row| row.get_size().height)
                     .collect();
                 (
                     name.clone(),
@@ -484,8 +471,8 @@ impl Layout {
                 name,
                 (
                     layout::c::Point {
-                        x: (total_size.width - view.get_width()) / 2.0,
-                        y: (total_size.height - view.get_height()) / 2.0,
+                        x: (total_size.width - view.get_size().width) / 2.0,
+                        y: (total_size.height - view.get_size().height) / 2.0,
                     },
                     view,
                 ),
@@ -734,11 +721,26 @@ fn create_button<H: logging::Handler>(
     }
 }
 
+fn extract_symbol_names<'a>(actions: &'a [(&str, action::Action)])
+    -> impl Iterator<Item=&'a str>
+{
+    actions.iter()
+        .filter_map(|(_name, act)| {
+            match act {
+                action::Action::Submit {
+                    text: _, keys,
+                } => Some(keys),
+                _ => None,
+            }
+        })
+        .flatten()
+        .map(|named_keysym| named_keysym.0.as_str())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    use std::error::Error as ErrorTrait;
     use ::logging::ProblemPanic;
 
     const THIS_FILE: &str = file!();
@@ -786,7 +788,8 @@ mod tests {
             Err(e) => {
                 let mut handled = false;
                 if let Error::Yaml(ye) = &e {
-                    handled = ye.description() == "missing field `views`";
+                    handled = ye.to_string()
+                        .starts_with("missing field `views`");
                 };
                 if !handled {
                     println!("Unexpected error {:?}", e);
@@ -804,7 +807,7 @@ mod tests {
             Err(e) => {
                 let mut handled = false;
                 if let Error::Yaml(ye) = &e {
-                    handled = ye.description()
+                    handled = ye.to_string()
                         .starts_with("unknown field `bad_field`");
                 };
                 if !handled {
@@ -824,7 +827,7 @@ mod tests {
         assert_eq!(
             out.views["base"].1
                 .get_rows()[0].1
-                .buttons[0].1
+                .get_buttons()[0].1
                 .label,
             ::layout::Label::Text(CString::new("test").unwrap())
         );
@@ -839,7 +842,7 @@ mod tests {
         assert_eq!(
             out.views["base"].1
                 .get_rows()[0].1
-                .buttons[0].1
+                .get_buttons()[0].1
                 .label,
             ::layout::Label::Text(CString::new("test").unwrap())
         );
@@ -855,13 +858,30 @@ mod tests {
         assert_eq!(
             out.views["base"].1
                 .get_rows()[0].1
-                .buttons[0].1
+                .get_buttons()[0].1
                 .state.borrow()
                 .keycodes.len(),
             2
         );
     }
 
+    /// Test if erase yields a useable keycode
+    #[test]
+    fn test_layout_erase() {
+        let out = Layout::from_file(path_from_root("tests/layout_erase.yaml"))
+            .unwrap()
+            .build(ProblemPanic).0
+            .unwrap();
+        assert_eq!(
+            out.views["base"].1
+                .get_rows()[0].1
+                .buttons[0].1
+                .state.borrow()
+                .keycodes.len(),
+            1
+        );
+    }
+
     #[test]
     fn parsing_fallback() {
         assert!(Layout::from_resource(FALLBACK_LAYOUT_NAME)
@@ -939,4 +959,35 @@ mod tests {
             }
         );
     }
+
+    #[test]
+    fn test_extract_symbols() {
+        let actions = [(
+            "ac",
+            action::Action::Submit {
+                text: None,
+                keys: vec![
+                    action::KeySym("a".into()),
+                    action::KeySym("c".into()),
+                ],
+            },
+        )];
+        assert_eq!(
+            extract_symbol_names(&actions[..]).collect::<Vec<_>>(),
+            vec!["a", "c"],
+        );
+    }
+
+    #[test]
+    fn test_extract_symbols_erase() {
+        let actions = [(
+            "Erase",
+            action::Action::Erase,
+        )];
+        assert_eq!(
+            extract_symbol_names(&actions[..]).collect::<Vec<_>>(),
+            Vec::<&str>::new(), //"BackSpace"], // TODO: centralize handling of BackSpace
+        );
+    }
+
 }

src/imservice.rs

@@ -54,7 +54,7 @@ pub mod c {
         im: *const InputMethod)
     {
         let imservice = check_imservice(imservice, im).unwrap();
-        imservice.preedit_string = String::new();
+        imservice.preedit_string = String::new(); // I don't think this is ever used. Remove it?
         imservice.pending = IMProtocolState {
             active: true,
             ..IMProtocolState::default()
@@ -84,7 +84,7 @@ pub mod c {
             surrounding_text: into_cstring(text)
                 .expect("Received invalid string")
                 .expect("Received null string"),
-            surrounding_cursor: cursor,
+            cursor,
             ..imservice.pending.clone()
         };
     }
@@ -146,10 +146,6 @@ pub mod c {
         let active_changed = imservice.current.active ^ imservice.pending.active;
 
         imservice.current = imservice.pending.clone();
-        imservice.pending = IMProtocolState {
-            active: imservice.current.active,
-            ..IMProtocolState::default()
-        };
 
         if active_changed {
             if imservice.current.active {
@@ -314,7 +310,7 @@ impl TryFrom<u32> for ChangeCause {
 #[derive(Clone)]
 struct IMProtocolState {
     surrounding_text: CString,
-    surrounding_cursor: u32,
+    cursor: u32,
     content_purpose: ContentPurpose,
     content_hint: ContentHint,
     text_change_cause: ChangeCause,
@@ -325,7 +321,7 @@ impl Default for IMProtocolState {
     fn default() -> IMProtocolState {
         IMProtocolState {
             surrounding_text: CString::default(),
-            surrounding_cursor: 0, // TODO: mark that there's no cursor
+            cursor: 0, // TODO: mark that there's no cursor
             content_hint: ContentHint::NONE,
             content_purpose: ContentPurpose::Normal,
             text_change_cause: ChangeCause::InputMethod,
@@ -344,7 +340,7 @@ pub struct IMService {
 
     pending: IMProtocolState,
     current: IMProtocolState, // turn current into an idiomatic representation?
-    preedit_string: String,
+    preedit_string: String, // I don't think this is ever used. Remove it?
     serial: Wrapping<u32>,
 }
 
@@ -366,7 +362,7 @@ impl IMService {
             state_manager,
             pending: IMProtocolState::default(),
             current: IMProtocolState::default(),
-            preedit_string: String::new(),
+            preedit_string: String::new(), // I don't think this is ever used. Remove it?
             serial: Wrapping(0u32),
         });
         unsafe {
@@ -378,9 +374,14 @@ impl IMService {
         imservice
     }
     
-    pub fn commit_string(&self, text: &CString) -> Result<(), SubmitError> {
+    pub fn commit_string(&mut self, text: &CString) -> Result<(), SubmitError> {
         match self.current.active {
             true => {
+                let cursor_position = self.pending.cursor.try_into().unwrap(); // Converts u32 of cursor to usize
+                self.pending
+                    .surrounding_text
+                    .insert_str(cursor_position, text);
+                self.pending.cursor += text.len() as u32;
                 unsafe {
                     c::eek_input_method_commit_string(self.im, text.as_ptr())
                 }
@@ -391,11 +392,16 @@ impl IMService {
     }
 
     pub fn delete_surrounding_text(
-        &self,
+        &mut self,
         before: u32, after: u32,
     ) -> Result<(), SubmitError> {
         match self.current.active {
             true => {
+                let cursor_position: usize = self.pending.cursor.try_into().unwrap(); // Converts u32 of cursor to usize
+                self.pending.surrounding_text.replace_range(
+                    cursor_position - (before as usize)..cursor_position + (after as usize),
+                    "",
+                );
                 unsafe {
                     c::eek_input_method_delete_surrounding_text(
                         self.im,
@@ -415,6 +421,7 @@ impl IMService {
                     c::eek_input_method_commit(self.im, self.serial.0)
                 }
                 self.serial += Wrapping(1u32);
+                imservice_handle_done(self);
                 Ok(())
             },
             false => Err(SubmitError::NotActive),

src/keyboard.rs

@@ -9,7 +9,6 @@ use std::rc::Rc;
 use std::string::FromUtf8Error;
 
 use ::action::Action;
-use ::logging;
 
 // Traits
 use std::io::Write;
@@ -92,7 +91,7 @@ fn sorted<'a, I: Iterator<Item=&'a str>>(
 /// HACK: starting from 9, because 8 results in keycode 0,
 /// which the compositor likes to discard
 pub fn generate_keycodes<'a, C: IntoIterator<Item=&'a str>>(
-    key_names: C
+    key_names: C,
 ) -> HashMap<String, u32> {
     let special_keysyms = ["BackSpace", "Return"].iter().map(|&s| s);
     HashMap::from_iter(
@@ -125,11 +124,9 @@ impl From<io::Error> for FormattingError {
 }
 
 /// Generates a de-facto single level keymap.
-// TODO: don't rely on keys and their order,
-// but rather on what keysyms and keycodes are in use.
-// Iterating actions makes it hard to deduplicate keysyms.
+/// Key codes must not repeat and should remain between 9 and 255.
 pub fn generate_keymap(
-    keystates: &HashMap::<String, KeyState>
+    symbolmap: HashMap::<String, KeyCode>,
 ) -> Result<String, FormattingError> {
     let mut buf: Vec<u8> = Vec::new();
     writeln!(
@@ -138,88 +135,75 @@ pub fn generate_keymap(
 
     xkb_keycodes \"squeekboard\" {{
         minimum = 8;
-        maximum = 255;"
+        maximum = 999;"
     )?;
     
-    for (name, state) in keystates.iter() {
-        match &state.action {
-            Action::Submit { text: _, keys } => {
-                if let 0 = keys.len() {
-                    log_print!(
-                        logging::Level::Warning,
-                        "Key {} has no keysyms", name,
-                    );
-                };
-                for (named_keysym, keycode) in keys.iter().zip(&state.keycodes) {
+    // Xorg can only consume up to 255 keys, so this may not work in Xwayland.
+    // Two possible solutions:
+    // - use levels to cram multiple characters into one key
+    // - swap layouts on key presses
+    for keycode in symbolmap.values() {
         write!(
             buf,
             "
-        <{}> = {};",
-                        named_keysym.0,
+        <I{}> = {0};",
             keycode,
         )?;
     }
-            },
-            Action::Erase => {
-                let mut keycodes = state.keycodes.iter();
-                write!(
-                    buf,
-                    "
-        <BackSpace> = {};",
-                    keycodes.next().expect("Erase key has no keycode"),
-                )?;
-                if let Some(_) = keycodes.next() {
-                    log_print!(
-                        logging::Level::Bug,
-                        "Erase key has multiple keycodes",
-                    );
-                }
-            },
-            _ => {},
-        }
-    }
 
     writeln!(
         buf,
         "
+        indicator 1 = \"Caps Lock\"; // Xwayland won't accept without it.
     }};
     
     xkb_symbols \"squeekboard\" {{
-
-        name[Group1] = \"Letters\";
-        name[Group2] = \"Numbers/Symbols\";
-        
-        key <BackSpace> {{ [ BackSpace ] }};"
+"
     )?;
     
-    for (_name, state) in keystates.iter() {
-        if let Action::Submit { text: _, keys } = &state.action {
-            for keysym in keys.iter() {
+    for (name, keycode) in symbolmap.iter() {
         write!(
             buf,
             "
-        key <{}> {{ [ {0} ] }};",
-                    keysym.0,
+key <I{}> {{ [ {} ] }};",
+            keycode,
+            name,
         )?;
     }
-        }
-    }
+
     writeln!(
         buf,
         "
     }};
 
     xkb_types \"squeekboard\" {{
+        virtual_modifiers Squeekboard; // No modifiers! Needed for Xorg for some reason.
     
-	type \"TWO_LEVEL\" {{
-            modifiers = Shift;
-            map[Shift] = Level2;
-            level_name[Level1] = \"Base\";
-            level_name[Level2] = \"Shift\";
+        // Those names are needed for Xwayland.
+        type \"ONE_LEVEL\" {{
+            modifiers= none;
+            level_name[Level1]= \"Any\";
         }};
+        type \"TWO_LEVEL\" {{
+            level_name[Level1]= \"Base\";
+        }};
+        type \"ALPHABETIC\" {{
+            level_name[Level1]= \"Base\";
+        }};
+        type \"KEYPAD\" {{
+            level_name[Level1]= \"Base\";
+        }};
+        type \"SHIFT+ALT\" {{
+            level_name[Level1]= \"Base\";
+        }};
+
     }};
 
     xkb_compatibility \"squeekboard\" {{
+        // Needed for Xwayland again.
+        interpret Any+AnyOf(all) {{
+            action= SetMods(modifiers=modMapMods,clearLocks);
+        }};
     }};
 }};"
     )?;
@@ -234,21 +218,13 @@ mod tests {
     
     use xkbcommon::xkb;
 
-    use ::action::KeySym;
-
     #[test]
     fn test_keymap_multi() {
         let context = xkb::Context::new(xkb::CONTEXT_NO_FLAGS);
 
-        let keymap_str = generate_keymap(&hashmap!{
-            "ac".into() => KeyState {
-                action: Action::Submit {
-                    text: None,
-                    keys: vec!(KeySym("a".into()), KeySym("c".into())),
-                },
-                keycodes: vec!(9, 10),
-                pressed: PressType::Released,
-            },
+        let keymap_str = generate_keymap(hashmap!{
+            "a".into() => 9,
+            "c".into() => 10,
         }).unwrap();
 
         let keymap = xkb::Keymap::new_from_string(

src/layout.rs

@@ -493,38 +493,63 @@ pub struct Button {
 }
 
 /// The graphical representation of a row of buttons
+#[derive(Clone, Debug)]
 pub struct Row {
-    /// Buttons together with their offset from the left
-    pub buttons: Vec<(f64, Box<Button>)>,
+    /// Buttons together with their offset from the left relative to the row.
+    /// ie. the first button always start at 0.
+    buttons: Vec<(f64, Box<Button>)>,
+
+    /// Total size of the row
+    size: Size,
 }
 
 impl Row {
-    pub fn get_height(&self) -> f64 {
-        find_max_double(
-            self.buttons.iter(),
+    pub fn new(buttons: Vec<(f64, Box<Button>)>) -> Row {
+        // Make sure buttons are sorted by offset.
+        debug_assert!({
+            let mut sorted = buttons.clone();
+            sorted.sort_by(|(f1, _), (f2, _)| f1.partial_cmp(f2).unwrap());
+
+            sorted.iter().map(|(f, _)| *f).collect::<Vec<_>>()
+                == buttons.iter().map(|(f, _)| *f).collect::<Vec<_>>()
+        });
+
+        let width = buttons.iter().next_back()
+            .map(|(x_offset, button)| button.size.width + x_offset)
+            .unwrap_or(0.0);
+
+        let height = find_max_double(
+            buttons.iter(),
             |(_offset, button)| button.size.height,
-        )
+        );
+
+        Row { buttons, size: Size { width, height } }
     }
 
-    fn get_width(&self) -> f64 {
-        self.buttons.iter().next_back()
-            .map(|(x_offset, button)| button.size.width + x_offset)
-            .unwrap_or(0.0)
+    pub fn get_size(&self) -> Size {
+        self.size.clone()
+    }
+
+    pub fn get_buttons(&self) -> &Vec<(f64, Box<Button>)> {
+        &self.buttons
     }
 
     /// Finds the first button that covers the specified point
     /// relative to row's position's origin
-    fn find_button_by_position(&self, point: c::Point)
-        -> Option<(f64, &Box<Button>)>
+    fn find_button_by_position(&self, x: f64) -> &(f64, Box<Button>)
     {
-        self.buttons.iter().find(|(x_offset, button)| {
-            c::Bounds {
-                x: *x_offset, y: 0.0,
-                width: button.size.width,
-                height: button.size.height,
-            }.contains(&point)
-        })
-            .map(|(x_offset, button)| (*x_offset, button))
+        // Buttons are sorted so we can use a binary search to find the clicked
+        // button. Note this doesn't check whether the point is actually within
+        // a button. This is on purpose as we want a click past the left edge of
+        // the left-most button to register as a click.
+        let result = self.buttons.binary_search_by(
+            |&(f, _)| f.partial_cmp(&x).unwrap()
+        );
+
+        let index = result.unwrap_or_else(|r| r);
+        let index = if index > 0 { index - 1 } else { 0 };
+
+        &self.buttons[index]
     }
 }
 
@@ -535,56 +560,85 @@ pub struct Spacing {
 }
 
 pub struct View {
-    /// Rows together with their offsets from the top
-    rows: Vec<(f64, Row)>,
+    /// Rows together with their offsets from the top left
+    rows: Vec<(c::Point, Row)>,
+
+    /// Total size of the view
+    size: Size,
 }
 
 impl View {
     pub fn new(rows: Vec<(f64, Row)>) -> View {
-        View { rows }
+        // Make sure rows are sorted by offset.
+        debug_assert!({
+            let mut sorted = rows.clone();
+            sorted.sort_by(|(f1, _), (f2, _)| f1.partial_cmp(f2).unwrap());
+
+            sorted.iter().map(|(f, _)| *f).collect::<Vec<_>>()
+                == rows.iter().map(|(f, _)| *f).collect::<Vec<_>>()
+        });
+
+        // No need to call `get_rows()`,
+        // as the biggest row is the most far reaching in both directions
+        // because they are all centered.
+        let width = find_max_double(rows.iter(), |(_offset, row)| row.size.width);
+
+        let height = rows.iter().next_back()
+            .map(|(y_offset, row)| row.size.height + y_offset)
+            .unwrap_or(0.0);
+
+        // Center the rows
+        let rows = rows.into_iter().map(|(y_offset, row)| {(
+                c::Point {
+                    x: (width - row.size.width) / 2.0,
+                    y: y_offset,
+                },
+                row,
+            )}).collect::<Vec<_>>();
+
+        View { rows, size: Size { width, height } }
     }
     /// Finds the first button that covers the specified point
     /// relative to view's position's origin
     fn find_button_by_position(&self, point: c::Point)
         -> Option<ButtonPlace>
     {
-        self.get_rows().iter().find_map(|(row_offset, row)| {
-            // make point relative to the inside of the row
-            row.find_button_by_position({
-                c::Point { x: point.x, y: point.y } - row_offset
-            }).map(|(button_x_offset, button)| ButtonPlace {
-                button,
-                offset: row_offset + c::Point {
-                    x: button_x_offset,
+        // Only test bounds of the view here, letting rows/column search extend
+        // to the edges of these bounds.
+        let bounds = c::Bounds {
+            x: 0.0,
             y: 0.0,
-                },
-            })
+            width: self.size.width,
+            height: self.size.height,
+        };
+        if !bounds.contains(&point) {
+            return None;
+        }
+
+        // Rows are sorted so we can use a binary search to find the row.
+        let result = self.rows.binary_search_by(
+            |(f, _)| f.y.partial_cmp(&point.y).unwrap()
+        );
+
+        let index = result.unwrap_or_else(|r| r);
+        let index = if index > 0 { index - 1 } else { 0 };
+
+        let row = &self.rows[index];
+        let button = row.1.find_button_by_position(point.x - row.0.x);
+
+        Some(ButtonPlace {
+            button: &button.1,
+            offset: &row.0 + c::Point { x: button.0, y: 0.0 },
         })
     }
     
-    pub fn get_width(&self) -> f64 {
-        // No need to call `get_rows()`,
-        // as the biggest row is the most far reaching in both directions
-        // because they are all centered.
-        find_max_double(self.rows.iter(), |(_offset, row)| row.get_width())
-    }
-    
-    pub fn get_height(&self) -> f64 {
-        self.rows.iter().next_back()
-            .map(|(y_offset, row)| row.get_height() + y_offset)
-            .unwrap_or(0.0)
+    pub fn get_size(&self) -> Size {
+        self.size.clone()
     }
     
     /// Returns positioned rows, with appropriate x offsets (centered)
-    pub fn get_rows(&self) -> Vec<(c::Point, &Row)> {
-        let available_width = self.get_width();
-        self.rows.iter().map(|(y_offset, row)| {(
-            c::Point {
-                x: (available_width - row.get_width()) / 2.0,
-                y: *y_offset,
-            },
-            row,
-        )}).collect()
+    pub fn get_rows(&self) -> &Vec<(c::Point, Row)> {
+        &self.rows
     }
 
     /// Returns a size which contains all the views
@@ -593,11 +647,11 @@ impl View {
         Size {
             height: find_max_double(
                 views.iter(),
-                |view| view.get_height(),
+                |view| view.size.height,
             ),
             width: find_max_double(
                 views.iter(),
-                |view| view.get_width(),
+                |view| view.size.width,
             ),
         }
     }
@@ -745,7 +799,7 @@ impl Layout {
         where F: FnMut(c::Point, &Box<Button>)
     {
         let (view_offset, view) = self.get_current_view_position();
-        for (row_offset, row) in &view.get_rows() {
+        for (row_offset, row) in view.get_rows() {
             for (x_offset, button) in &row.buttons {
                 let offset = view_offset
                     + row_offset.clone()
@@ -758,7 +812,7 @@ impl Layout {
     pub fn get_locked_keys(&self) -> Vec<Rc<RefCell<KeyState>>> {
         let mut out = Vec::new();
         let view = self.get_current_view();
-        for (_, row) in &view.get_rows() {
+        for (_, row) in view.get_rows() {
             for (_, button) in &row.buttons {
                 let locked = {
                     let state = RefCell::borrow(&button.state).clone();
@@ -820,13 +874,9 @@ mod procedures {
             let button = make_button_with_state("1".into(), state);
             let button_ptr = as_ptr(&button);
 
-            let row = Row {
-                buttons: vec!((0.1, button)),
-            };
+            let row = Row::new(vec!((0.1, button)));
 
-            let view = View {
-                rows: vec!((1.2, row)),
-            };
+            let view = View::new(vec!((1.2, row)));
 
             assert_eq!(
                 find_key_places(&view, &state_clone.clone()).into_iter()
@@ -837,9 +887,7 @@ mod procedures {
                 )
             );
 
-            let view = View {
-                rows: Vec::new(),
-            };
+            let view = View::new(vec![]);
             assert_eq!(
                 find_key_places(&view, &state_clone.clone()).is_empty(),
                 true
@@ -1082,37 +1130,56 @@ mod test {
     
     #[test]
     fn check_centering() {
-        //    foo
+        //    A B
         // ---bar---
         let view = View::new(vec![
             (
                 0.0,
-                Row {
-                    buttons: vec![(
+                Row::new(vec![
+                    (
                         0.0,
                         Box::new(Button {
-                            size: Size { width: 10.0, height: 10.0 },
-                            ..*make_button_with_state("foo".into(), make_state())
+                            size: Size { width: 5.0, height: 10.0 },
+                            ..*make_button_with_state("A".into(), make_state())
                         }),
-                    )]
-                },
+                    ),
+                    (
+                        5.0,
+                        Box::new(Button {
+                            size: Size { width: 5.0, height: 10.0 },
+                            ..*make_button_with_state("B".into(), make_state())
+                        }),
+                    ),
+                ]),
             ),
             (
                 10.0,
-                Row {
-                    buttons: vec![(
+                Row::new(vec![
+                    (
                         0.0,
                         Box::new(Button {
                             size: Size { width: 30.0, height: 10.0 },
                             ..*make_button_with_state("bar".into(), make_state())
                         }),
-                    )]
-                },
+                    ),
+                ]),
             )
         ]);
         assert!(
             view.find_button_by_position(c::Point { x: 5.0, y: 5.0 })
-                .is_none()
+                .unwrap().button.name.to_str().unwrap() == "A"
+        );
+        assert!(
+            view.find_button_by_position(c::Point { x: 14.99, y: 5.0 })
+                .unwrap().button.name.to_str().unwrap() == "A"
+        );
+        assert!(
+            view.find_button_by_position(c::Point { x: 15.01, y: 5.0 })
+                .unwrap().button.name.to_str().unwrap() == "B"
+        );
+        assert!(
+            view.find_button_by_position(c::Point { x: 25.0, y: 5.0 })
+                .unwrap().button.name.to_str().unwrap() == "B"
         );
     }
 
@@ -1122,15 +1189,13 @@ mod test {
         let view = View::new(vec![
             (
                 0.0,
-                Row {
-                    buttons: vec![(
+                Row::new(vec![(
                     0.0,
                     Box::new(Button {
                         size: Size { width: 1.0, height: 1.0 },
                         ..*make_button_with_state("foo".into(), make_state())
                     }),
-                    )]
-                },
+                )]),
             ),
         ]);
         let layout = Layout {

src/locale_config.rs

@@ -31,21 +31,15 @@ pub enum Error {
 
 impl ::std::fmt::Display for Error {
     fn fmt(&self, out: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
-        use ::std::error::Error;
-        out.write_str(self.description())
-    }
-}
-
-impl ::std::error::Error for Error {
-    fn description(&self) -> &str {
-        match self {
+        out.write_str(match self {
             &Error::NotWellFormed => "Language tag is not well-formed.",
             // this is exception: here we do want exhaustive match so we don't publish version with
             // missing descriptions by mistake.
             &Error::__NonExhaustive => panic!("Placeholder error must not be instantiated!"),
+        })
     }
 }
-}
+
 
 /// Convenience Result alias.
 type Result<T> = ::std::result::Result<T, Error>;

src/meson.build

@@ -14,6 +14,7 @@ sources = [
   config_h,
   'dbus.c',
   'imservice.c',
+  'popover.c',
   'server-context-service.c',
   'wayland.c',
   '../eek/eek.c',

src/popover.c

@@ -0,0 +1,69 @@
+#include <gio/gio.h>
+
+static void
+call_dbus_cb (GDBusProxy *proxy,
+              GAsyncResult *res,
+              gpointer user_data)
+{
+  g_autoptr (GError) err = NULL;
+  g_autoptr (GVariant) output = NULL;
+
+  output = g_dbus_proxy_call_finish (proxy, res, &err);
+  if (err) {
+    g_warning ("Can't open panel %s", err->message);
+  }
+  g_object_unref (proxy);
+}
+
+static void
+create_dbus_proxy_cb (GObject *source_object, GAsyncResult *res, char *panel)
+{
+  GDBusProxy *proxy;
+  g_autoptr (GError) err = NULL;
+  GVariantBuilder builder;
+  GVariant *params[3];
+  GVariant *array[1];
+
+  proxy = g_dbus_proxy_new_for_bus_finish (res, &err);
+
+  if (err != NULL) {
+    g_warning ("Can't open panel %s: %s", panel, err->message);
+    g_free (panel);
+    return;
+  }
+
+  g_variant_builder_init (&builder, G_VARIANT_TYPE ("av"));
+  g_variant_builder_add (&builder, "v", g_variant_new_string (""));
+
+  array[0] = g_variant_new ("v", g_variant_new ("(sav)", panel, &builder));
+
+  params[0] = g_variant_new_string ("launch-panel");
+  params[1] = g_variant_new_array (G_VARIANT_TYPE ("v"), array, 1);
+  params[2] = g_variant_new_array (G_VARIANT_TYPE ("{sv}"), NULL, 0);
+
+  g_dbus_proxy_call (proxy,
+             "Activate",
+             g_variant_new_tuple (params, 3),
+             G_DBUS_CALL_FLAGS_NONE,
+             -1,
+             NULL,
+             (GAsyncReadyCallback) call_dbus_cb,
+             NULL);
+
+  g_free (panel);
+}
+
+void
+popover_open_settings_panel (char *panel)
+{
+  g_dbus_proxy_new_for_bus (G_BUS_TYPE_SESSION,
+                G_DBUS_PROXY_FLAGS_NONE,
+                NULL,
+                "org.gnome.ControlCenter",
+                "/org/gnome/ControlCenter",
+                "org.gtk.Actions",
+                NULL,
+                (GAsyncReadyCallback) create_dbus_proxy_cb,
+                g_strdup (panel));
+
+}

src/popover.rs

@@ -3,6 +3,7 @@
 use gio;
 use gtk;
 use std::ffi::CString;
+use std::cmp::Ordering;
 use ::layout::c::{ Bounds, EekGtkKeyboard };
 use ::locale;
 use ::locale::{ OwnedTranslation, Translation, compare_current_locale };
@@ -25,6 +26,15 @@ use gtk::WidgetExt;
 use std::io::Write;
 use ::logging::Warn;
 
+mod c {
+    use std::os::raw::c_char;
+
+    #[no_mangle]
+    extern "C" {
+        pub fn popover_open_settings_panel(panel: *const c_char);
+    }
+}
+
 mod variants {
     use glib;
     use glib::Variant;
@@ -128,6 +138,12 @@ fn make_menu_builder(inputs: Vec<(&str, OwnedTranslation)>) -> gtk::Builder {
         xml,
         "
     </section>
+    <section>
+        <item>
+            <attribute name=\"label\" translatable=\"yes\">Keyboard Settings</attribute>
+            <attribute name=\"action\">settings</attribute>
+        </item>
+    </section>
   </menu>
 </interface>"
     ).unwrap();
@@ -334,8 +350,13 @@ pub fn show(
         .zip(all_layouts.clone().into_iter())
         .collect();
 
-    human_names.sort_unstable_by(|(tr_a, _), (tr_b, _)| {
-        compare_current_locale(&tr_a.0, &tr_b.0)
+    human_names.sort_unstable_by(|(tr_a, layout_a), (tr_b, layout_b)| {
+        // Sort first by layout then name
+        match (layout_a, layout_b) {
+            (LayoutId::Local(_), LayoutId::System { .. }) => Ordering::Greater,
+            (LayoutId::System { .. }, LayoutId::Local(_)) => Ordering::Less,
+            _ => compare_current_locale(&tr_a.0, &tr_b.0)
+        }
     });
 
     // GVariant doesn't natively support `enum`s,
@@ -414,8 +435,14 @@ pub fn show(
             menu_inner.popdown();
         });
 
+        let settings_action = gio::SimpleAction::new("settings", None);
+        settings_action.connect_activate(move |_, _| {
+            unsafe { c::popover_open_settings_panel(CString::new("region").unwrap().as_ptr()) };
+        });
+
         let action_group = gio::SimpleActionGroup::new();
         action_group.add_action(&layout_action);
+        action_group.add_action(&settings_action);
 
         menu.insert_action_group("popup", Some(&action_group));
     };

src/resources.rs

@@ -17,11 +17,14 @@ const KEYBOARDS: &[(*const str, *const str)] = &[
     ("us_wide", include_str!("../data/keyboards/us_wide.yaml")),
     ("br", include_str!("../data/keyboards/br.yaml")),
     ("de", include_str!("../data/keyboards/de.yaml")),
+    ("be", include_str!("../data/keyboards/be.yaml")),
+    ("be_wide", include_str!("../data/keyboards/be_wide.yaml")),
     ("de_wide", include_str!("../data/keyboards/de_wide.yaml")),
     ("dk", include_str!("../data/keyboards/dk.yaml")),
     ("es", include_str!("../data/keyboards/es.yaml")),
     ("fi", include_str!("../data/keyboards/fi.yaml")),
     ("fr", include_str!("../data/keyboards/fr.yaml")),
+    ("fr_wide", include_str!("../data/keyboards/fr_wide.yaml")),
     ("gr", include_str!("../data/keyboards/gr.yaml")),
     ("it", include_str!("../data/keyboards/it.yaml")),
     ("jp+kana", include_str!("../data/keyboards/jp+kana.yaml")),
@@ -35,6 +38,7 @@ const KEYBOARDS: &[(*const str, *const str)] = &[
     ("ua", include_str!("../data/keyboards/ua.yaml")),
     // layout+overlay
     ("terminal", include_str!("../data/keyboards/terminal.yaml")),
+    ("terminal_wide", include_str!("../data/keyboards/terminal_wide.yaml")),
     // Overlays
     ("emoji", include_str!("../data/keyboards/emoji.yaml")),
 ];

src/server-context-service.c

@@ -31,6 +31,7 @@
 enum {
     PROP_0,
     PROP_VISIBLE,
+    PROP_ENABLED,
     PROP_LAST
 };
 
@@ -44,6 +45,7 @@ struct _ServerContextService {
     struct ui_manager *manager; // unowned
 
     gboolean visible;
+    gboolean enabled;
     PhoshLayerSurface *window;
     GtkWidget *widget; // nullable
     guint hiding;
@@ -83,13 +85,20 @@ on_notify_unmap (ServerContextService *self, GtkWidget *widget)
 }
 
 static uint32_t
-calculate_height(int32_t width)
+calculate_height(int32_t width, GdkRectangle *geometry)
 {
-    uint32_t height = 180;
-    if (width < 360 && width > 0) {
+    uint32_t height;
+    if (geometry->width > geometry->height) {
+        // 1:5 ratio works fine on lanscape mode, and makes sure there's
+        // room left for the app window
+        height = width / 5;
+    } else {
+        if (width < 540 && width > 0) {
             height = ((unsigned)width * 7 / 12); // to match 360×210
-    } else if (width < 540) {
-        height = 180 + (540 - (unsigned)width) * 30 / 180; // smooth transition
+        } else {
+            // Here we switch to wide layout, less height needed
+            height = ((unsigned)width * 7 / 22);
+        }
     }
     return height;
 }
@@ -97,6 +106,10 @@ calculate_height(int32_t width)
 static void
 on_surface_configure(ServerContextService *self, PhoshLayerSurface *surface)
 {
+    GdkDisplay *display = NULL;
+    GdkWindow *window = NULL;
+    GdkMonitor *monitor = NULL;
+    GdkRectangle geometry;
     gint width;
     gint height;
 
@@ -108,11 +121,24 @@ on_surface_configure(ServerContextService *self, PhoshLayerSurface *surface)
                  "configured-height", &height,
                  NULL);
 
+    // In order to improve height calculation, we need the monitor geometry so
+    // we can use different algorithms for portrait and landscape mode.
+    // Note: this is a temporary fix until the size manager is complete.
+    display = gdk_display_get_default ();
+    if (display)
+        window = gtk_widget_get_window (GTK_WIDGET (surface));
+    if (window)
+        monitor = gdk_display_get_monitor_at_window (display, window);
+    if (monitor)
+        gdk_monitor_get_geometry (monitor, &geometry);
+    else
+        geometry.width = geometry.height = 0;
+
      // When the geometry event comes after surface.configure,
      // this entire height calculation does nothing.
      // guint desired_height = squeek_uiman_get_perceptual_height(context->manager);
      // Temporarily use old method, until the size manager is complete.
-    guint desired_height = calculate_height(width);
+    guint desired_height = calculate_height(width, &geometry);
 
     guint configured_height = (guint)height;
     // if height was already requested once but a different one was given
@@ -208,6 +234,9 @@ on_hide (ServerContextService *self)
 static void
 server_context_service_real_show_keyboard (ServerContextService *self)
 {
+    if (!self->enabled)
+        return;
+
     if (self->hiding) {
 	    g_source_remove (self->hiding);
 	    self->hiding = 0;
@@ -263,7 +292,9 @@ server_context_service_set_property (GObject      *object,
     case PROP_VISIBLE:
         self->visible = g_value_get_boolean (value);
         break;
-
+    case PROP_ENABLED:
+        server_context_service_set_enabled (self, g_value_get_boolean (value));
+        break;
     default:
         G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
         break;
@@ -319,11 +350,43 @@ server_context_service_class_init (ServerContextServiceClass *klass)
     g_object_class_install_property (gobject_class,
                                      PROP_VISIBLE,
                                      pspec);
+
+    /**
+     * ServerContextServie:keyboard:
+     *
+     * Does the user want the keyboard to show up automatically?
+     */
+    pspec =
+        g_param_spec_boolean ("enabled",
+                              "Enabled",
+                              "Whether the keyboard is enabled",
+                              TRUE,
+                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+    g_object_class_install_property (gobject_class,
+                                     PROP_ENABLED,
+                                     pspec);
 }
 
 static void
 server_context_service_init (ServerContextService *self) {
-    (void)self;
+    const char *schema_name = "org.gnome.desktop.a11y.applications";
+    GSettingsSchemaSource *ssrc = g_settings_schema_source_get_default();
+    g_autoptr(GSettingsSchema) schema = NULL;
+
+    self->enabled = TRUE;
+    if (!ssrc) {
+        g_warning("No gsettings schemas installed.");
+        return;
+    }
+    schema = g_settings_schema_source_lookup(ssrc, schema_name, TRUE);
+    if (schema) {
+        g_autoptr(GSettings) settings = g_settings_new (schema_name);
+        g_settings_bind (settings, "screen-keyboard-enabled",
+                         self, "enabled", G_SETTINGS_BIND_GET);
+    } else {
+        g_warning("Gsettings schema %s is not installed on the system. "
+                  "Enabling by default.", schema_name);
+    }
 }
 
 ServerContextService *
@@ -336,3 +399,18 @@ server_context_service_new (EekboardContextService *self, struct submission *sub
     ui->manager = uiman;
     return ui;
 }
+
+void
+server_context_service_set_enabled (ServerContextService *self, gboolean enabled)
+{
+    g_return_if_fail (SERVER_IS_CONTEXT_SERVICE (self));
+
+    if (enabled == self->enabled)
+        return;
+
+    self->enabled = enabled;
+    if (self->enabled)
+        server_context_service_show_keyboard (self);
+    else
+        server_context_service_hide_keyboard (self);
+}

src/server-context-service.h

@@ -33,6 +33,7 @@ ServerContextService *server_context_service_new(EekboardContextService *self, s
 enum squeek_arrangement_kind server_context_service_get_layout_type(ServerContextService *);
 void server_context_service_show_keyboard (ServerContextService *self);
 void server_context_service_hide_keyboard (ServerContextService *self);
+void server_context_service_set_enabled (ServerContextService *self, gboolean enabled);
 G_END_DECLS
 #endif  /* SERVER_CONTEXT_SERVICE_H */
 

src/tests.rs

@@ -26,17 +26,45 @@ impl CountAndPrint {
     }
 }
 
-pub fn check_builtin_layout(name: &str) {
-    check_layout(Layout::from_resource(name).expect("Invalid layout data"))
+pub fn check_builtin_layout(name: &str, missing_return: bool) {
+    check_layout(
+        Layout::from_resource(name).expect("Invalid layout data"),
+        missing_return,
+    )
 }
 
 pub fn check_layout_file(path: &str) {
-    check_layout(Layout::from_file(path.into()).expect("Invalid layout file"))
+    check_layout(
+        Layout::from_file(path.into()).expect("Invalid layout file"),
+        false,
+    )
 }
 
-fn check_layout(layout: Layout) {
+fn check_sym_presence(
+    state: &xkb::State,
+    sym_name: &str,
+    handler: &mut dyn logging::Handler,
+) {
+    let sym = xkb::keysym_from_name(sym_name, xkb::KEYSYM_NO_FLAGS);
+    if sym == xkb::KEY_NoSymbol {
+        panic!(format!("Entered invalid keysym: {}", sym_name));
+    }
+    let map = state.get_keymap();
+    let range = map.min_keycode()..=map.max_keycode();
+    let found = range.flat_map(|code| state.key_get_syms(code))
+        .find(|s| **s == sym)
+        .is_some();
+    if !found {
+        handler.handle(
+            logging::Level::Surprise,
+            &format!("There's no way to input the keysym {} on this layout", sym_name),
+        )
+    }
+}
+
+fn check_layout(layout: Layout, allow_missing_return: bool) {
     let handler = CountAndPrint::new();
-    let (layout, handler) = layout.build(handler);
+    let (layout, mut handler) = layout.build(handler);
 
     if handler.0 > 0 {
         println!("{} problems while parsing layout", handler.0)
@@ -59,10 +87,19 @@ fn check_layout(layout: Layout) {
 
     let state = xkb::State::new(&keymap);
 
+    check_sym_presence(&state, "BackSpace", &mut handler);
+    let mut printer = logging::Print;
+    check_sym_presence(
+        &state,
+        "Return",
+        if allow_missing_return { &mut printer }
+        else { &mut handler },
+    );
+
     // "Press" each button with keysyms
     for (_pos, view) in layout.views.values() {
-        for (_y, row) in &view.get_rows() {
-            for (_x, button) in &row.buttons {
+        for (_y, row) in view.get_rows() {
+            for (_x, button) in row.get_buttons() {
                 let keystate = button.state.borrow();
                 for keycode in &keystate.keycodes {
                     match state.key_get_one_sym(*keycode) {

src/vkeyboard.rs

@@ -41,7 +41,7 @@ impl VirtualKeyboard {
     // TODO: error out if keymap not set
     pub fn switch(
         &self,
-        keycodes: &Vec<KeyCode>,
+        keycodes: &[KeyCode],
         action: PressType,
         timestamp: Timestamp,
     ) {

src/wayland.c

@@ -17,7 +17,7 @@ eek_virtual_keyboard_v1_key(struct zwp_virtual_keyboard_v1 *zwp_virtual_keyboard
 void eek_virtual_keyboard_update_keymap(struct zwp_virtual_keyboard_v1 *zwp_virtual_keyboard_v1, const LevelKeyboard *keyboard) {
     zwp_virtual_keyboard_v1_keymap(zwp_virtual_keyboard_v1,
         WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1,
-        keyboard->keymap_fd, keyboard->keymap_len);
+        keyboard->keymap.fd, keyboard->keymap.fd_len);
 }
 
 void

tests/layout_erase.yaml

@@ -0,0 +1,10 @@
+---
+# Erase only
+views:
+    base:
+        - "BackSpace"
+outlines:
+    default: { width: 0, height: 0 }
+buttons:
+    BackSpace:
+        action: erase

tests/meson.build

@@ -50,11 +50,12 @@ endforeach
 foreach layout : [
     'us', 'us_wide',
     'br',
+    'be', 'be_wide',
     'de', 'de_wide',
     'dk',
     'es',
     'fi',
-    'fr',
+    'fr', 'fr_wide',
     'gr',
     'it',
     'jp+kana','jp+kana_wide',
@@ -64,15 +65,21 @@ foreach layout : [
     'ru',
     'se',
     'ua',
-    'terminal',
+    'terminal', 'terminal_wide',
 
     'emoji',
 ]
+    extra = []
+    if layout == 'emoji'
+        extra += ['allow_missing_return']
+    endif
+
     test(
         'test_layout_' + layout,
         cargo_script,
         args: ['run'] + cargo_build_flags
-            + [ '--example', 'test_layout', '--', layout],
+            + ['--example', 'test_layout', '--', layout]
+            + extra,
         workdir: meson.build_root(),
     )
 endforeach