Merge lp:~andreas-pokorny/mir/compose-sequences-in-xkb-keymapper into lp:mir

[Andreas Pokorny]

Dead key key compose sequences in mirserver and mirclient

This implementation of key compose sequences keeps the stream of scan codes intact. So clients still get the full stream - only the scan codes are removed. Hence a client with a different surface keymap could still map key presses unaffected.

This is intended to be used inside qtmir to avoid qts default behavior of converting the compose sequence result into input method events, and thereby filtering out key events.

Add a neutral compose key handling to XKBMapper

After finding out that qts inputcontext plugin in charge of compose handling destroys the key sequence, the decision to not handle dead keys was reversed and this change was started. Because this implementation treats compose key results still as key events and additionally keeps the scan code in place the key sequence is not destroyed. Thus allowing clients to use a different keymap/compose setup then the server...

[Mir CI Bot (mir-ci-bot)]

FAILED: Continuous integration, rev:3644
https://mir-jenkins.ubuntu.com/job/mir-ci/2006/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/2570/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-0-fetch/2633/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/2625/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/2625/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=yakkety/2625/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=yakkety/2599/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/2599/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=yakkety/2599/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/2599/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/2599/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/2599/console

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/2006/rebuild

review: Needs Fixing (continuous-integration)

[Mir CI Bot (mir-ci-bot)]

FAILED: Continuous integration, rev:3774
https://mir-jenkins.ubuntu.com/job/mir-ci/2009/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/2575/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/2638
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/2630
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/2630
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=yakkety/2630
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=yakkety/2604
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=yakkety/2604/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/2604
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/2604/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=yakkety/2604
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=yakkety/2604/artifact/output/*zip*/output.zip
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/2604/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/2604/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/2604
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/2604/artifact/output/*zip*/output.zip

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/2009/rebuild

review: Needs Fixing (continuous-integration)

[Mir CI Bot (mir-ci-bot)]

FAILED: Continuous integration, rev:3775
https://mir-jenkins.ubuntu.com/job/mir-ci/2011/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/2577/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/2640
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/2632
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/2632
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=yakkety/2632
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=yakkety/2606
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=yakkety/2606/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/2606
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/2606/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=yakkety/2606
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=yakkety/2606/artifact/output/*zip*/output.zip
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/2606/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/2606/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/2606
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/2606/artifact/output/*zip*/output.zip

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/2011/rebuild

review: Needs Fixing (continuous-integration)

[Andreas Pokorny (andreas-pokorny)]

This does not build on vivid because v+o is still on libxkbcommon-0.4.2 while the rest is on libxkbcommmon-0.5. I am trying to get v+o upgraded this week.

[Mir CI Bot (mir-ci-bot)]

FAILED: Continuous integration, rev:3776
https://mir-jenkins.ubuntu.com/job/mir-ci/2015/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/2582/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/2645
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/2637
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/2637
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=yakkety/2637
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=yakkety/2611/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/2611/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=yakkety/2611/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/2611/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/2611/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/2611/console

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/2015/rebuild

review: Needs Fixing (continuous-integration)

[Chris Halse Rogers (raof)]

This seems to be sensible behaviour.

review: Approve

[Mir CI Bot (mir-ci-bot)]

FAILED: Continuous integration, rev:3777
https://mir-jenkins.ubuntu.com/job/mir-ci/2028/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/2598/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/2661
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/2653
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/2653
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=yakkety/2653
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=yakkety/2627
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=yakkety/2627/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/2627
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/2627/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=yakkety/2627
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=yakkety/2627/artifact/output/*zip*/output.zip
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/2627/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/2627/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/2627
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/2627/artifact/output/*zip*/output.zip

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/2028/rebuild

review: Needs Fixing (continuous-integration)

[Mir CI Bot (mir-ci-bot)]

FAILED: Continuous integration, rev:3778
https://mir-jenkins.ubuntu.com/job/mir-ci/2032/
Executed test runs:
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-mir/2602/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/2665
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/2657
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/2657
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=yakkety/2657
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=yakkety/2631
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=yakkety/2631/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/2631
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/2631/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=yakkety/2631
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=yakkety/2631/artifact/output/*zip*/output.zip
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/2631/console
    FAILURE: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/2631/console
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/2631
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/2631/artifact/output/*zip*/output.zip

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/2032/rebuild

review: Needs Fixing (continuous-integration)

[Andreas Pokorny (andreas-pokorny)]

oh xkbcommon landed..

[Mir CI Bot (mir-ci-bot)]

PASSED: Continuous integration, rev:3778
https://mir-jenkins.ubuntu.com/job/mir-ci/2081/
Executed test runs:
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-mir/2668
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-0-fetch/2731
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=vivid+overlay/2723
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=xenial+overlay/2723
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-1-sourcepkg/release=yakkety/2723
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=yakkety/2697
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=clang,platform=mesa,release=yakkety/2697/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/2697
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=xenial+overlay/2697/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=yakkety/2697
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=amd64,compiler=gcc,platform=mesa,release=yakkety/2697/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/2697
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=cross-armhf,compiler=gcc,platform=android,release=vivid+overlay/2697/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/2697
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=android,release=vivid+overlay/2697/artifact/output/*zip*/output.zip
    SUCCESS: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/2697
        deb: https://mir-jenkins.ubuntu.com/job/build-2-binpkg-mir/arch=i386,compiler=gcc,platform=mesa,release=xenial+overlay/2697/artifact/output/*zip*/output.zip

Click here to trigger a rebuild:
https://mir-jenkins.ubuntu.com/job/mir-ci/2081/rebuild

review: Approve (continuous-integration)

[Kevin DuBois (kdub)]

+ xkb_keysym_t update_state(uint32_t scan_code, MirKeyboardAction direction, ComposeState* compose_state);
in light of
+ update_state(to_xkb_scan_code(scan_code), mir_keyboard_action_down, nullptr);

I think mir::optional_value<ComposeState*> as the new parameter makes sense. (or having two functions with different parameters).

not too bothered by that though, lgtm

review: Approve

[Alan Griffiths (alan-griffiths)]

I don't feel strongly enough to block, but...

+#include <ostream>
...
+inline std::ostream& operator<<(std::ostream &out, Keymap const& rhs)
+{
+ return out << rhs.model << "-" << rhs.layout << "-"<< rhs.variant << "-" << rhs.options;
+}

This is a public header, couldn't we use <iosfwd> and a non-inline function?

~~~~

+ std::stringstream error;
+ error << "Illegal keymap configuration evdev-" << map;

Why do we construct the error message on both the good and bad codepaths?

~~~~

-xkb_keysym_t mircv::XKBMapper::XkbMappingState::update_state(uint32_t scan_code, MirKeyboardAction action)
+xkb_keysym_t mircv::XKBMapper::XkbMappingState::update_state(uint32_t scan_code, MirKeyboardAction ...
+ if (compose_state)
+ key_sym = compose_state->update_state(key_sym, action);

It really is nicer to use the NullObject pattern or function overloading than to use nullptr as a valid input.

review: Abstain

=== modified file 'debian/control'
--- debian/control	2016-10-18 13:38:19 +0000
+++ debian/control	2016-10-20 14:45:33 +0000
@@ -28,7 +28,7 @@
                libandroid-properties-dev [i386 amd64 armhf arm64],
                libgoogle-glog-dev,
                liblttng-ust-dev,
-               libxkbcommon-dev,
+               libxkbcommon-dev (>= 0.5),
                libumockdev-dev (>= 0.6),
                umockdev (>= 0.8.7),
                libudev-dev,

=== modified file 'include/common/mir/input/keymap.h'
--- include/common/mir/input/keymap.h	2016-06-09 18:16:12 +0000
+++ include/common/mir/input/keymap.h	2016-10-20 14:45:33 +0000
@@ -21,6 +21,7 @@
 #define MIR_INPUT_KEYMAP_H_
 
 #include <string>
+#include <ostream>
 
 namespace mir
 {
@@ -66,6 +67,11 @@
     return !(lhs == rhs);
 }
 
+inline std::ostream& operator<<(std::ostream &out, Keymap const& rhs)
+{
+    return out << rhs.model << "-" << rhs.layout << "-"<< rhs.variant << "-" << rhs.options;
+}
+
 }
 }
 

=== modified file 'src/client/input/xkb_mapper.cpp'
--- src/client/input/xkb_mapper.cpp	2016-10-12 06:03:15 +0000
+++ src/client/input/xkb_mapper.cpp	2016-10-20 14:45:33 +0000
@@ -23,6 +23,7 @@
 #include "mir/events/event_private.h"
 #include "mir/events/event_builders.h"
 
+#include <sstream>
 #include <boost/throw_exception.hpp>
 
 namespace mi = mir::input;
@@ -32,6 +33,18 @@
 namespace
 {
 
+char const* get_locale_from_environment()
+{
+    char const* loc = getenv("LC_ALL");
+    if (!loc)
+        loc = getenv("LC_CTYPE");
+    if (!loc)
+        loc = getenv("LANG");
+    if (!loc)
+        loc = "C";
+    return loc;
+}
+
 MirInputEventModifiers xkb_key_code_to_modifier(xkb_keysym_t key)
 {
     switch(key)
@@ -76,6 +89,26 @@
     // xkb scancodes are offset by 8 from evdev scancodes for compatibility with X protocol.
     return evdev_scan_code + 8;
 }
+
+
+mi::XKBComposeStatePtr make_unique_compose_state(mi::XKBComposeTablePtr const& table)
+{
+    return {xkb_compose_state_new(table.get(), XKB_COMPOSE_STATE_NO_FLAGS), &xkb_compose_state_unref};
+}
+
+mi::XKBComposeTablePtr make_unique_compose_table_from_locale(mi::XKBContextPtr const& context, std::string const& locale)
+{
+    return {xkb_compose_table_new_from_locale(
+            context.get(),
+            locale.c_str(),
+            XKB_COMPOSE_COMPILE_NO_FLAGS),
+           &xkb_compose_table_unref};
+}
+
+mi::XKBStatePtr make_unique_state(xkb_keymap* keymap)
+{
+    return {xkb_state_new(keymap), xkb_state_unref};
+}
 }
 
 mi::XKBContextPtr mi::make_unique_context()
@@ -85,6 +118,8 @@
 
 mi::XKBKeymapPtr mi::make_unique_keymap(xkb_context* context, mi::Keymap const& map)
 {
+    std::stringstream error;
+    error << "Illegal keymap configuration evdev-" << map;
     xkb_rule_names keymap_names
     {
         "evdev",
@@ -93,23 +128,25 @@
         map.variant.c_str(),
         map.options.c_str()
     };
-    return {xkb_keymap_new_from_names(context, &keymap_names, xkb_keymap_compile_flags(0)), &xkb_keymap_unref};
+    auto keymap_ptr = xkb_keymap_new_from_names(context, &keymap_names, xkb_keymap_compile_flags(0));
+
+    if (!keymap_ptr)
+        BOOST_THROW_EXCEPTION(std::invalid_argument(error.str().c_str()));
+    return {keymap_ptr, &xkb_keymap_unref};
 }
 
 mi::XKBKeymapPtr mi::make_unique_keymap(xkb_context* context, char const* buffer, size_t size)
 {
-    return {xkb_keymap_new_from_buffer(context, buffer, size, XKB_KEYMAP_FORMAT_TEXT_V1, xkb_keymap_compile_flags(0)),
-            &xkb_keymap_unref};
-}
-
-using XKBStatePtr = std::unique_ptr<xkb_state, void(*)(xkb_state*)>;
-mi::XKBStatePtr mi::make_unique_state(xkb_keymap* keymap)
-{
-    return {xkb_state_new(keymap), xkb_state_unref};
-}
-
-mircv::XKBMapper::XKBMapper()
-    : context{make_unique_context()}
+    auto keymap_ptr = xkb_keymap_new_from_buffer(context, buffer, size, XKB_KEYMAP_FORMAT_TEXT_V1, xkb_keymap_compile_flags(0));
+    if (!keymap_ptr)
+        BOOST_THROW_EXCEPTION(std::runtime_error("failed to create keymap from buffer."));
+
+    return {keymap_ptr, &xkb_keymap_unref};
+}
+
+mircv::XKBMapper::XKBMapper() :
+    context{make_unique_context()},
+    compose_table{make_unique_compose_table_from_locale(context, get_locale_from_environment())}
 {
 }
 
@@ -130,7 +167,7 @@
         MirInputEventModifiers new_modifier = 0;
         for (auto const& mapping_state : device_mapping)
         {
-            new_modifier |= mapping_state.second.modifier_state;
+            new_modifier |= mapping_state.second->modifier_state;
         }
 
         modifier_state = new_modifier;
@@ -152,8 +189,12 @@
         if (input_type == mir_input_event_type_key)
         {
             auto mapping_state = get_keymapping_state(device_id);
-            if (mapping_state && mapping_state->update_and_map(ev))
-                update_modifier();
+            if (mapping_state)
+            {
+                auto compose_state = get_compose_state(device_id);
+                if (mapping_state->update_and_map(ev, compose_state))
+                    update_modifier();
+            }
         }
         else if (modifier_state.is_set())
         {
@@ -168,14 +209,17 @@
 
     if (dev_keymap != end(device_mapping))
     {
-        return &dev_keymap->second;
+        return dev_keymap->second.get();
     }
     if (default_keymap)
     {
-        return
-            &device_mapping.emplace(std::piecewise_construct,
-                                    std::forward_as_tuple(id),
-                                    std::forward_as_tuple(default_keymap)).first->second;
+        decltype(device_mapping.begin()) insertion_pos;
+        std::tie(insertion_pos, std::ignore) =
+            device_mapping.emplace(std::piecewise_construct,
+                                   std::forward_as_tuple(id),
+                                   std::forward_as_tuple(std::make_unique<XkbMappingState>(default_keymap)));
+
+        return insertion_pos->second.get();
     }
     return nullptr;
 }
@@ -214,7 +258,7 @@
     device_mapping.erase(id);
     device_mapping.emplace(std::piecewise_construct,
                            std::forward_as_tuple(id),
-                           std::forward_as_tuple(std::move(new_keymap)));
+                           std::forward_as_tuple(std::make_unique<XkbMappingState>(std::move(new_keymap))));
 }
 
 void mircv::XKBMapper::clear_all_keymaps()
@@ -250,18 +294,16 @@
     state = make_unique_state(keymap.get());
     modifier_state = mir_input_event_modifier_none;
     for (uint32_t scan_code : key_state)
-        update_state(to_xkb_scan_code(scan_code), mir_keyboard_action_down);
+        update_state(to_xkb_scan_code(scan_code), mir_keyboard_action_down, nullptr);
 }
 
-bool mircv::XKBMapper::XkbMappingState::update_and_map(MirEvent& event)
+bool mircv::XKBMapper::XkbMappingState::update_and_map(MirEvent& event, mircv::XKBMapper::ComposeState* compose_state)
 {
     auto& key_ev = *event.to_input()->to_keyboard();
-    // TODO test if key entry is start of a compose key sequence..
-    // then use compose key API to map key..
     uint32_t xkb_scan_code = to_xkb_scan_code(key_ev.scan_code());
     auto old_state = modifier_state;
 
-    key_ev.set_key_code(update_state(xkb_scan_code, key_ev.action()));
+    key_ev.set_key_code(update_state(xkb_scan_code, key_ev.action(), compose_state));
     // TODO we should also indicate effective/consumed modifier state to properly
     // implement short cuts with keys that are only reachable via modifier keys
     key_ev.set_modifiers(expand_modifiers(modifier_state));
@@ -269,11 +311,14 @@
     return old_state != modifier_state;
 }
 
-xkb_keysym_t mircv::XKBMapper::XkbMappingState::update_state(uint32_t scan_code, MirKeyboardAction action)
+xkb_keysym_t mircv::XKBMapper::XkbMappingState::update_state(uint32_t scan_code, MirKeyboardAction action, mircv::XKBMapper::ComposeState* compose_state)
 {
     auto key_sym = xkb_state_key_get_one_sym(state.get(), scan_code);
     auto mod_change = xkb_key_code_to_modifier(key_sym);
 
+    if (compose_state)
+        key_sym = compose_state->update_state(key_sym, action);
+
     if (action == mir_keyboard_action_up)
     {
         xkb_state_update_key(state.get(), scan_code, XKB_KEY_UP);
@@ -287,3 +332,81 @@
 
     return key_sym;
 }
+
+mircv::XKBMapper::ComposeState* mircv::XKBMapper::get_compose_state(MirInputDeviceId id)
+{
+    auto dev_compose_state = device_composing.find(id);
+
+    if (dev_compose_state != end(device_composing))
+    {
+        return dev_compose_state->second.get();
+    }
+    if (compose_table)
+    {
+        decltype(device_composing.begin()) insertion_pos;
+        std::tie(insertion_pos, std::ignore) =
+            device_composing.emplace(std::piecewise_construct,
+                                     std::forward_as_tuple(id),
+                                     std::forward_as_tuple(std::make_unique<ComposeState>(compose_table)));
+
+        return insertion_pos->second.get();
+    }
+    return nullptr;
+}
+
+mircv::XKBMapper::ComposeState::ComposeState(XKBComposeTablePtr const& table) :
+    state{make_unique_compose_state(table)}
+{
+}
+
+void mircv::XKBMapper::ComposeState::update_and_map(MirEvent& event)
+{
+    auto& key_ev = *event.to_input()->to_keyboard();
+
+    auto const key_sym = key_ev.key_code();
+    auto const action = key_ev.action();
+    key_ev.set_key_code(update_state(key_sym, action));
+}
+
+xkb_keysym_t mircv::XKBMapper::ComposeState::update_state(xkb_keysym_t mapped_key, MirKeyboardAction action)
+{
+    // the state machine only cares about downs
+    if (action == mir_keyboard_action_down)
+    {
+        if (xkb_compose_state_feed(state.get(), mapped_key) == XKB_COMPOSE_FEED_ACCEPTED)
+        {
+            auto result =  xkb_compose_state_get_status(state.get());
+            if (result == XKB_COMPOSE_COMPOSED)
+            {
+                auto composed_key_sym = xkb_compose_state_get_one_sym(state.get());
+                last_composed_key = std::make_tuple(mapped_key, composed_key_sym);
+                return composed_key_sym;
+            }
+            else if (result == XKB_COMPOSE_COMPOSING)
+            {
+                consumed_keys.insert(mapped_key);
+                return XKB_KEY_NoSymbol;
+            }
+            else if (result == XKB_COMPOSE_CANCELLED)
+            {
+                consumed_keys.insert(mapped_key);
+                return XKB_KEY_NoSymbol;
+            }
+        }
+    }
+    else
+    {
+        if (last_composed_key.is_set() &&
+            mapped_key == std::get<0>(last_composed_key.value()))
+        {
+            if (action == mir_keyboard_action_up)
+                return std::get<1>(last_composed_key.consume());
+            else
+                return std::get<1>(last_composed_key.value());
+        }
+        if (consumed_keys.erase(mapped_key))
+            return XKB_KEY_NoSymbol;
+    }
+
+    return mapped_key;
+}

=== modified file 'src/include/common/mir/input/key_mapper.h'
--- src/include/common/mir/input/key_mapper.h	2016-06-24 07:41:32 +0000
+++ src/include/common/mir/input/key_mapper.h	2016-10-20 14:45:33 +0000
@@ -23,7 +23,6 @@
 #include "mir_toolkit/client_types.h"
 #include "mir_toolkit/event.h"
 
-#include <xkbcommon/xkbcommon.h>
 #include <vector>
 #include <memory>
 

=== modified file 'src/include/common/mir/input/xkb_mapper.h'
--- src/include/common/mir/input/xkb_mapper.h	2016-07-07 09:59:19 +0000
+++ src/include/common/mir/input/xkb_mapper.h	2016-10-20 14:45:33 +0000
@@ -24,8 +24,11 @@
 #include "mir/input/key_mapper.h"
 #include "mir/optional_value.h"
 
+#include <xkbcommon/xkbcommon.h>
+#include <xkbcommon/xkbcommon-compose.h>
 #include <mutex>
 #include <unordered_map>
+#include <unordered_set>
 
 namespace mir
 {
@@ -40,7 +43,8 @@
 XKBKeymapPtr make_unique_keymap(xkb_context* context, char const* buffer, size_t size);
 
 using XKBStatePtr = std::unique_ptr<xkb_state, void(*)(xkb_state*)>;
-XKBStatePtr make_unique_state(xkb_keymap* keymap);
+using XKBComposeTablePtr = std::unique_ptr<xkb_compose_table, void(*)(xkb_compose_table*)>;
+using XKBComposeStatePtr = std::unique_ptr<xkb_compose_state, void(*)(xkb_compose_state*)>;
 
 namespace receiver
 {
@@ -71,25 +75,37 @@
 
     std::mutex mutable guard;
 
+    struct ComposeState
+    {
+        ComposeState(XKBComposeTablePtr const& table);
+        void update_and_map(MirEvent& event);
+        xkb_keysym_t update_state(xkb_keysym_t mapped_key, MirKeyboardAction action);
+        XKBComposeStatePtr state;
+        std::unordered_set<xkb_keysym_t> consumed_keys;
+        mir::optional_value<std::tuple<xkb_keysym_t,xkb_keysym_t>> last_composed_key;
+    };
+
     struct XkbMappingState
     {
         explicit XkbMappingState(std::shared_ptr<xkb_keymap> const& keymap);
         void set_key_state(std::vector<uint32_t> const& key_state);
-        bool update_and_map(MirEvent& event);
-        xkb_keysym_t update_state(uint32_t scan_code, MirKeyboardAction direction);
+        bool update_and_map(MirEvent& event, ComposeState* compose_state);
+        xkb_keysym_t update_state(uint32_t scan_code, MirKeyboardAction direction, ComposeState* compose_state);
         std::shared_ptr<xkb_keymap> const keymap;
         XKBStatePtr state;
         MirInputEventModifiers modifier_state{0};
-        // TODO optional compose key state..
     };
 
     XkbMappingState* get_keymapping_state(MirInputDeviceId id);
+    ComposeState* get_compose_state(MirInputDeviceId id);
 
     XKBContextPtr context;
     std::shared_ptr<xkb_keymap> default_keymap;
+    XKBComposeTablePtr compose_table;
 
     mir::optional_value<MirInputEventModifiers> modifier_state;
-    std::unordered_map<MirInputDeviceId, XkbMappingState> device_mapping;
+    std::unordered_map<MirInputDeviceId, std::unique_ptr<XkbMappingState>> device_mapping;
+    std::unordered_map<MirInputDeviceId, std::unique_ptr<ComposeState>> device_composing;
 };
 }
 }

=== modified file 'tests/acceptance-tests/test_client_input.cpp'
--- tests/acceptance-tests/test_client_input.cpp	2016-10-12 06:03:15 +0000
+++ tests/acceptance-tests/test_client_input.cpp	2016-10-20 14:45:33 +0000
@@ -744,7 +744,7 @@
 
     EXPECT_THROW(
         {server.the_shell()->focused_surface()->set_keymap(id, model, layout, "", "");},
-        std::runtime_error);
+        std::invalid_argument);
 }
 
 TEST_F(TestClientInput, event_filter_may_consume_events)

=== modified file 'tests/unit-tests/client/input/test_xkb_mapper.cpp'
--- tests/unit-tests/client/input/test_xkb_mapper.cpp	2016-10-12 06:03:15 +0000
+++ tests/unit-tests/client/input/test_xkb_mapper.cpp	2016-10-20 14:45:33 +0000
@@ -23,6 +23,7 @@
 #include "mir/events/event_private.h"
 #include "mir/events/event_builders.h"
 
+#include "mir_test_framework/temporary_environment_value.h"
 #include "mir/test/event_matchers.h"
 #include <xkbcommon/xkbcommon-keysyms.h>
 #include <xkbcommon/xkbcommon.h>
@@ -36,13 +37,28 @@
 namespace mt = mir::test;
 namespace mircv = mi::receiver;
 namespace mev = mir::events;
+namespace mtf = mir_test_framework;
 
 using namespace ::testing;
 
 struct XKBMapper : Test
 {
+    // en_US.UTF-8 is the fallback used by libxkbcommon - setting this avoids
+    // tests failing on systems with a locale that points to a working but 
+    // different set of compose sequences
+    mir_test_framework::TemporaryEnvironmentValue lc_all{"LC_ALL", "en_US.UTF-8"};
+    int const xkb_new_unicode_symbols_offset = 0x1000000;
     mircv::XKBMapper mapper;
 
+    int map_key(mircv::XKBMapper &keymapper, MirInputDeviceId dev, MirKeyboardAction action, int scan_code)
+    {
+        auto ev = mev::make_event(dev, std::chrono::nanoseconds(0), std::vector<uint8_t>{}, action,
+                                  0, scan_code, mir_input_event_modifier_none);
+
+        keymapper.map_event(*ev);
+        return ev->to_input()->to_keyboard()->key_code();
+    }
+
     int map_key(MirKeyboardAction action, int scan_code)
     {
         auto ev = mev::make_event(MirInputDeviceId(0), std::chrono::nanoseconds(0), std::vector<uint8_t>{}, action,
@@ -334,3 +350,91 @@
     mapper.set_keymap_for_device(keyboard, mi::Keymap{"pc105", "de", "",""});
     EXPECT_EQ(XKB_KEY_y, map_key(keyboard, mir_keyboard_action_down, KEY_Z));
 }
+
+TEST_F(XKBMapper, composes_keys_on_deadkey_keymap)
+{
+    auto keyboard = MirInputDeviceId{3};
+    mapper.set_keymap_for_device(keyboard, mi::Keymap{"pc105", "us", "intl",""});
+    EXPECT_EQ(XKB_KEY_Shift_R, map_key(keyboard, mir_keyboard_action_down, KEY_RIGHTSHIFT));
+    EXPECT_EQ(XKB_KEY_NoSymbol, map_key(keyboard, mir_keyboard_action_down, KEY_APOSTROPHE));
+    EXPECT_EQ(XKB_KEY_NoSymbol, map_key(keyboard, mir_keyboard_action_up, KEY_APOSTROPHE));
+    EXPECT_EQ(XKB_KEY_Shift_R, map_key(keyboard, mir_keyboard_action_up, KEY_RIGHTSHIFT));
+    EXPECT_EQ(XKB_KEY_udiaeresis, map_key(keyboard, mir_keyboard_action_down, KEY_U));
+    EXPECT_EQ(XKB_KEY_udiaeresis, map_key(keyboard, mir_keyboard_action_up, KEY_U));
+}
+
+TEST_F(XKBMapper, release_of_compose_sequence_keys_after_completion_still_yields_dead_keys)
+{
+    auto keyboard = MirInputDeviceId{3};
+    mapper.set_keymap_for_device(keyboard, mi::Keymap{"pc105", "us", "intl",""});
+    EXPECT_EQ(XKB_KEY_Shift_R, map_key(keyboard, mir_keyboard_action_down, KEY_RIGHTSHIFT));
+    EXPECT_EQ(XKB_KEY_NoSymbol, map_key(keyboard, mir_keyboard_action_down, KEY_APOSTROPHE));
+    EXPECT_EQ(XKB_KEY_Udiaeresis, map_key(keyboard, mir_keyboard_action_down, KEY_U));
+    EXPECT_EQ(XKB_KEY_NoSymbol, map_key(keyboard, mir_keyboard_action_up, KEY_APOSTROPHE));
+    EXPECT_EQ(XKB_KEY_Udiaeresis, map_key(keyboard, mir_keyboard_action_up, KEY_U));
+    EXPECT_EQ(XKB_KEY_Shift_R, map_key(keyboard, mir_keyboard_action_up, KEY_RIGHTSHIFT));
+}
+
+TEST_F(XKBMapper, repeated_key_that_completed_the_sequence_yields_a_repeated_completion_key)
+{
+    auto keyboard = MirInputDeviceId{3};
+    mapper.set_keymap_for_device(keyboard, mi::Keymap{"pc105", "us", "intl",""});
+    EXPECT_EQ(XKB_KEY_Shift_R, map_key(keyboard, mir_keyboard_action_down, KEY_RIGHTSHIFT));
+    EXPECT_EQ(XKB_KEY_NoSymbol, map_key(keyboard, mir_keyboard_action_down, KEY_APOSTROPHE));
+    EXPECT_EQ(XKB_KEY_NoSymbol, map_key(keyboard, mir_keyboard_action_up, KEY_APOSTROPHE));
+    EXPECT_EQ(XKB_KEY_Shift_R, map_key(keyboard, mir_keyboard_action_up, KEY_RIGHTSHIFT));
+    EXPECT_EQ(XKB_KEY_udiaeresis, map_key(keyboard, mir_keyboard_action_down, KEY_U));
+    EXPECT_EQ(XKB_KEY_udiaeresis, map_key(keyboard, mir_keyboard_action_repeat, KEY_U));
+    EXPECT_EQ(XKB_KEY_udiaeresis, map_key(keyboard, mir_keyboard_action_repeat, KEY_U));
+    EXPECT_EQ(XKB_KEY_udiaeresis, map_key(keyboard, mir_keyboard_action_repeat, KEY_U));
+    EXPECT_EQ(XKB_KEY_udiaeresis, map_key(keyboard, mir_keyboard_action_repeat, KEY_U));
+    EXPECT_EQ(XKB_KEY_udiaeresis, map_key(keyboard, mir_keyboard_action_repeat, KEY_U));
+    EXPECT_EQ(XKB_KEY_udiaeresis, map_key(keyboard, mir_keyboard_action_repeat, KEY_U));
+}
+
+TEST_F(XKBMapper, compose_key_option_activates_multi_key_based_sequences)
+{
+    auto keyboard = MirInputDeviceId{3};
+    mapper.set_keymap_for_device(keyboard, mi::Keymap{"pc105", "us", "intl","compose:ralt"});
+    EXPECT_EQ(XKB_KEY_NoSymbol, map_key(keyboard, mir_keyboard_action_down, KEY_RIGHTALT));
+    EXPECT_EQ(XKB_KEY_NoSymbol, map_key(keyboard, mir_keyboard_action_up, KEY_RIGHTALT));
+    EXPECT_EQ(XKB_KEY_Shift_R, map_key(keyboard, mir_keyboard_action_down, KEY_RIGHTSHIFT));
+    EXPECT_EQ(XKB_KEY_NoSymbol, map_key(keyboard, mir_keyboard_action_down, KEY_COMMA));
+    EXPECT_EQ(XKB_KEY_NoSymbol, map_key(keyboard, mir_keyboard_action_up, KEY_COMMA));
+    EXPECT_EQ(XKB_KEY_Shift_R, map_key(keyboard, mir_keyboard_action_up, KEY_RIGHTSHIFT));
+    auto const black_heart = xkb_new_unicode_symbols_offset + 0x2665;
+    EXPECT_EQ(black_heart, map_key(keyboard, mir_keyboard_action_down, KEY_3));
+}
+
+TEST_F(XKBMapper, breaking_a_compose_sequence_yields_no_keysym)
+{
+    auto keyboard = MirInputDeviceId{3};
+    mapper.set_keymap_for_device(keyboard, mi::Keymap{"pc105", "us", "intl",""});
+    EXPECT_EQ(XKB_KEY_Shift_R, map_key(keyboard, mir_keyboard_action_down, KEY_RIGHTSHIFT));
+    EXPECT_EQ(XKB_KEY_NoSymbol, map_key(keyboard, mir_keyboard_action_down, KEY_APOSTROPHE));
+    EXPECT_EQ(XKB_KEY_NoSymbol, map_key(keyboard, mir_keyboard_action_up, KEY_APOSTROPHE));
+    EXPECT_EQ(XKB_KEY_Shift_R, map_key(keyboard, mir_keyboard_action_up, KEY_RIGHTSHIFT));
+
+    EXPECT_EQ(XKB_KEY_NoSymbol, map_key(keyboard, mir_keyboard_action_down, KEY_N));
+    EXPECT_EQ(XKB_KEY_NoSymbol, map_key(keyboard, mir_keyboard_action_up, KEY_N));
+
+    EXPECT_EQ(XKB_KEY_u, map_key(keyboard, mir_keyboard_action_down, KEY_U));
+    EXPECT_EQ(XKB_KEY_u, map_key(keyboard, mir_keyboard_action_up, KEY_U));
+}
+
+TEST_F(XKBMapper, no_key_composition_when_no_compose_file_is_found)
+{
+    mtf::TemporaryEnvironmentValue compose_file_path{"XCOMPOSEFILE", "/foo/bogus/path/Compose"};
+    mtf::TemporaryEnvironmentValue home_path{"HOME", "/not/your/home"};
+    mtf::TemporaryEnvironmentValue localedir{"XLOCALEDIR", "/not/your/home"};
+    mircv::XKBMapper local_mapper;
+
+    auto keyboard = MirInputDeviceId{3};
+    local_mapper.set_keymap_for_device(keyboard, mi::Keymap{"pc105", "us", "intl",""});
+    EXPECT_EQ(XKB_KEY_Shift_R, map_key(local_mapper, keyboard, mir_keyboard_action_down, KEY_RIGHTSHIFT));
+    EXPECT_EQ(XKB_KEY_dead_diaeresis, map_key(local_mapper, keyboard, mir_keyboard_action_down, KEY_APOSTROPHE));
+    EXPECT_EQ(XKB_KEY_dead_diaeresis, map_key(local_mapper, keyboard, mir_keyboard_action_up, KEY_APOSTROPHE));
+    EXPECT_EQ(XKB_KEY_Shift_R, map_key(local_mapper, keyboard, mir_keyboard_action_up, KEY_RIGHTSHIFT));
+    EXPECT_EQ(XKB_KEY_u, map_key(local_mapper, keyboard, mir_keyboard_action_down, KEY_U));
+    EXPECT_EQ(XKB_KEY_u, map_key(local_mapper, keyboard, mir_keyboard_action_up, KEY_U));
+}