Merge lp:~andreas-pokorny/mir/example-configure-input-devices into lp:mir

[Andreas Pokorny]

Add program options to mir_demo_server for input devices

touchpad and mouse cursor and scroll speeds can be configured separately.

Extend examples to provide a few settings that affect input devices.

=== modified file 'examples/CMakeLists.txt'
--- examples/CMakeLists.txt	2015-10-20 03:30:00 +0000
+++ examples/CMakeLists.txt	2015-11-18 14:50:22 +0000
@@ -21,6 +21,7 @@
   server_example_basic_window_manager.h
   server_example_canonical_window_manager.cpp
   server_example_display_configuration_policy.cpp
+  server_example_input_device_config.cpp
   server_example_input_event_filter.cpp
   server_example_log_options.cpp
   server_example_input_filter.cpp

=== modified file 'examples/server_example.cpp'
--- examples/server_example.cpp	2015-10-07 16:39:31 +0000
+++ examples/server_example.cpp	2015-11-18 14:50:22 +0000
@@ -25,6 +25,7 @@
 #include "server_example_custom_compositor.h"
 #include "server_example_test_client.h"
 #include "server_example_cursor_images.h"
+#include "server_example_input_device_config.h"
 
 #include "mir/server.h"
 #include "mir/main_loop.h"
@@ -92,6 +93,7 @@
     me::add_glog_options_to(server);
     me::add_window_manager_option_to(server);
     me::add_custom_compositor_option_to(server);
+    me::add_input_device_configuration_options_to(server);
     add_launcher_option_to(server);
     add_timeout_option_to(server);
     me::add_x_cursor_images(server);

=== added file 'examples/server_example_input_device_config.cpp'
--- examples/server_example_input_device_config.cpp	1970-01-01 00:00:00 +0000
+++ examples/server_example_input_device_config.cpp	2015-11-18 14:50:22 +0000
@@ -0,0 +1,163 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored By: Andreas Pokorny <[e-mail]>
+ */
+
+#include "server_example_input_device_config.h"
+
+#include "mir/input/device_capability.h"
+#include "mir/input/pointer_configuration.h"
+#include "mir/input/touchpad_configuration.h"
+#include "mir/input/input_device_hub.h"
+#include "mir/input/device.h"
+#include "mir/options/option.h"
+#include "mir/server.h"
+
+namespace me = mir::examples;
+namespace mi = mir::input;
+
+///\example server_example_input_device_config.cpp
+/// Demonstrate input device configuration
+
+char const* const me::disable_while_typing_opt = "disable-while-typing";
+char const* const me::mouse_cursor_accleration_bias_opt = "mouse-cursor-acceleration-bias";
+char const* const me::mouse_scroll_speed_scale_opt = "mouse-scroll-speed-scale";
+char const* const me::touchpad_cursor_accleration_bias_opt = "touchpad-cursor-acceleration-bias";
+char const* const me::touchpad_scroll_speed_scale_opt = "touchpad-scroll-speed-scale";
+char const* const me::touchpad_scroll_mode_opt = "touchpad-scroll-mode";
+
+char const* const touchpad_scroll_mode_two_finger = "two-finger";
+char const* const touchpad_scroll_mode_edge = "edge";
+
+char const* const me::touchpad_click_mode_opt= "touchpad-click-mode";
+
+char const* const touchpad_click_mode_area = "area";
+char const* const touchpad_click_mode_finger_count = "finger-count";
+
+void me::add_input_device_configuration_options_to(mir::Server& server)
+{
+    // Add choice of monitor configuration
+    server.add_configuration_option(disable_while_typing_opt,
+                                    "Disable touch pad while typing on keyboard configuration [true, false]",
+                                    false);
+    server.add_configuration_option(mouse_cursor_accleration_bias_opt,
+                                    "Bias to the acceleration curve within the range [-1.0, 1.0] for mice",
+                                    0.0);
+    server.add_configuration_option(mouse_scroll_speed_scale_opt,
+                                    "Scales mice scroll events, use negative values for natural scrolling",
+                                    1.0);
+    server.add_configuration_option(touchpad_cursor_accleration_bias_opt,
+                                    "Bias to the acceleration curve within the range [-1.0, 1.0] for touchpads",
+                                    0.0);
+    server.add_configuration_option(touchpad_scroll_speed_scale_opt,
+                                    "Scales touchpad scroll events, use negative values for natural scrolling",
+                                    -1.0);
+
+    server.add_configuration_option(touchpad_scroll_mode_opt,
+                                    "Select scrolll mode for touchpads: [{two-finger, edge}]",
+                                    touchpad_scroll_mode_two_finger);
+
+    server.add_configuration_option(touchpad_click_mode_opt,
+                                    "Select click mode for touchpads: [{area, finger-count}]",
+                                    touchpad_click_mode_finger_count);
+
+    auto clamp_to_range = [](double val)
+    {
+        if (val < -1.0)
+            val = -1.0;
+        else if (val > 1.0)
+            val = 1.0;
+        return val;
+    };
+
+    // TODO the configuration api allows a combination of values. We might want to expose that in the command line api too.
+    auto convert_to_scroll_mode = [](std::string const& val)
+    {
+        if (val == touchpad_scroll_mode_edge)
+            return mir_touchpad_scroll_mode_edge_scroll;
+        if (val == touchpad_scroll_mode_two_finger)
+            return mir_touchpad_scroll_mode_two_finger_scroll;
+        return mir_touchpad_scroll_mode_none;
+    };
+
+    auto convert_to_click_mode = [](std::string const& val)
+    {
+        if (val == touchpad_click_mode_finger_count)
+            return mir_touchpad_click_mode_finger_count;
+        if (val == touchpad_click_mode_area)
+            return mir_touchpad_click_mode_area_to_click;
+        return mir_touchpad_click_mode_none;
+    };
+
+    server.add_init_callback([&]()
+        {
+            auto const options = server.get_options();
+            auto const input_config = std::make_shared<me::InputDeviceConfig>(
+                options->get<bool>(disable_while_typing_opt),
+                clamp_to_range(options->get<double>(mouse_cursor_accleration_bias_opt)),
+                options->get<double>(mouse_scroll_speed_scale_opt),
+                clamp_to_range(options->get<double>(touchpad_cursor_accleration_bias_opt)),
+                options->get<double>(touchpad_scroll_speed_scale_opt),
+                convert_to_click_mode(options->get<std::string>(touchpad_click_mode_opt)),
+                convert_to_scroll_mode(options->get<std::string>(touchpad_scroll_mode_opt))
+                );
+            server.the_input_device_hub()->add_observer(input_config);
+        });
+}
+
+///\example server_example_input_device_config.cpp
+/// Demonstrate how to implement an InputDeviceObserver that identifies and configures input devices.
+
+me::InputDeviceConfig::InputDeviceConfig(bool disable_while_typing,
+                                         double mouse_cursor_accleration_bias,
+                                         double mouse_scroll_speed_scale,
+                                         double touchpad_scroll_speed_scale,
+                                         double touchpad_cursor_accleration_bias,
+                                         MirTouchpadClickModes click_mode,
+                                         MirTouchpadClickModes scroll_mode)
+    : disable_while_typing(disable_while_typing), mouse_cursor_accleration_bias(mouse_cursor_accleration_bias),
+      mouse_scroll_speed_scale(mouse_scroll_speed_scale),
+      touchpad_cursor_accleration_bias(touchpad_cursor_accleration_bias),
+      touchpad_scroll_speed_scale(touchpad_scroll_speed_scale), click_mode(click_mode), scroll_mode(scroll_mode)
+{
+}
+
+void me::InputDeviceConfig::device_added(std::shared_ptr<mi::Device> const& device)
+{
+    if (contains(device->capabilities(), mi::DeviceCapability::pointer) &&
+        contains(device->capabilities(), mi::DeviceCapability::touchpad))
+    {
+        mi::PointerConfiguration pointer_config( device->pointer_configuration().value() );
+        pointer_config.cursor_acceleration_bias = touchpad_cursor_accleration_bias;
+        pointer_config.vertical_scroll_scale  = touchpad_scroll_speed_scale;
+        pointer_config.horizontal_scroll_scale = touchpad_scroll_speed_scale;
+        device->apply_pointer_configuration(pointer_config);
+
+        mi::TouchpadConfiguration touch_config( device->touchpad_configuration().value() );
+        touch_config.disable_while_typing = disable_while_typing;
+        touch_config.click_mode = click_mode;
+        touch_config.scroll_mode = scroll_mode;
+        device->apply_touchpad_configuration(touch_config);
+    }
+    else if (contains(device->capabilities(), mi::DeviceCapability::pointer))
+    {
+        mi::PointerConfiguration pointer_config( device->pointer_configuration().value() );
+        pointer_config.cursor_acceleration_bias = mouse_cursor_accleration_bias;
+        pointer_config.vertical_scroll_scale  = mouse_scroll_speed_scale;
+        pointer_config.horizontal_scroll_scale = mouse_scroll_speed_scale;
+        device->apply_pointer_configuration(pointer_config);
+    }
+}

=== added file 'examples/server_example_input_device_config.h'
--- examples/server_example_input_device_config.h	1970-01-01 00:00:00 +0000
+++ examples/server_example_input_device_config.h	2015-11-18 14:50:22 +0000
@@ -0,0 +1,73 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored By: Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef MIR_EXAMPLES_INPUT_DEVICE_CONFIG_H_
+#define MIR_EXAMPLES_INPUT_DEVICE_CONFIG_H_
+
+#include "mir/input/input_device_observer.h"
+#include "mir_toolkit/mir_input_device.h"
+
+namespace mir
+{
+class Server;
+
+namespace input
+{
+class Device;
+}
+
+namespace examples
+{
+extern char const* const disable_while_typing_opt;
+extern char const* const mouse_cursor_accleration_bias_opt;
+extern char const* const mouse_scroll_speed_scale_opt;
+extern char const* const touchpad_cursor_accleration_bias_opt;
+extern char const* const touchpad_scroll_speed_scale_opt;
+extern char const* const touchpad_click_mode_opt;
+extern char const* const touchpad_scroll_mode_opt;
+
+void add_input_device_configuration_options_to(Server& server);
+
+class InputDeviceConfig : public mir::input::InputDeviceObserver
+{
+public:
+    InputDeviceConfig(bool disable_while_typing,
+                      double mouse_cursor_accleration_bias,
+                      double mouse_scroll_speed_scale,
+                      double touchpad_scroll_speed_scale,
+                      double touchpad_cursor_accleration_bias,
+                      MirTouchpadClickModes click_mode,
+                      MirTouchpadScrollModes scroll_mode);
+    void device_added(std::shared_ptr<input::Device> const& device) override;
+    void device_changed(std::shared_ptr<input::Device> const&) override {};
+    void device_removed(std::shared_ptr<input::Device> const&) override {};
+    void changes_complete() override {}
+private:
+    bool disable_while_typing;
+    double mouse_cursor_accleration_bias;
+    double mouse_scroll_speed_scale;
+    double touchpad_cursor_accleration_bias;
+    double touchpad_scroll_speed_scale;
+    MirTouchpadClickModes click_mode;
+    MirTouchpadScrollModes scroll_mode;
+};
+
+}
+}
+
+#endif

=== modified file 'include/server/mir/input/device.h'
--- include/server/mir/input/device.h	2015-10-26 03:33:22 +0000
+++ include/server/mir/input/device.h	2015-11-18 14:50:22 +0000
@@ -22,6 +22,7 @@
 
 #include "mir/input/device_capability.h"
 #include "mir_toolkit/event.h"
+#include "mir/optional_value.h"
 
 #include <memory>
 
@@ -30,8 +31,8 @@
 namespace input
 {
 
-class PointerSettings;
-class TouchpadSettings;
+class PointerConfiguration;
+class TouchpadConfiguration;
 
 class Device
 {
@@ -43,6 +44,12 @@
     virtual std::string name() const = 0;
     virtual std::string unique_id() const = 0;
 
+    virtual mir::optional_value<PointerConfiguration> pointer_configuration() const = 0;
+    virtual void apply_pointer_configuration(PointerConfiguration const&) = 0;
+
+    virtual mir::optional_value<TouchpadConfiguration> touchpad_configuration() const = 0;
+    virtual void apply_touchpad_configuration(TouchpadConfiguration const&) = 0;
+
 private:
     Device(Device const&) = delete;
     Device& operator=(Device const&) = delete;

=== added file 'include/server/mir/input/pointer_configuration.h'
--- include/server/mir/input/pointer_configuration.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/input/pointer_configuration.h	2015-11-18 14:50:22 +0000
@@ -0,0 +1,71 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by:
+ *   Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef MIR_INPUT_POINTER_CONFIGURATION_H_
+#define MIR_INPUT_POINTER_CONFIGURATION_H_
+
+#include "mir_toolkit/common.h"
+#include "mir_toolkit/client_types.h"
+#include "mir_toolkit/mir_input_device.h"
+
+namespace mir
+{
+namespace input
+{
+
+struct PointerConfiguration
+{
+    PointerConfiguration() {}
+
+    PointerConfiguration(MirPointerHandedness handedness, double acceleration_bias, double horizontal_scroll_scale,
+                         double vertical_scroll_scale)
+        : handedness{handedness}, cursor_acceleration_bias{acceleration_bias},
+          horizontal_scroll_scale{horizontal_scroll_scale}, vertical_scroll_scale{vertical_scroll_scale}
+    {
+    }
+
+    /*!
+     * Configure which button shall be used as primary button. That way the input device is configured to be either
+     * right or left handed.
+     */
+    MirPointerHandedness handedness{mir_pointer_handedness_right};
+
+    /*!
+     * Configures the intensity of the cursor acceleration. Values within the range of [-1, 1] are allowed.
+     *   - 0: default acceleration
+     *   - [-1, 0): reduced acceleration
+     *   - (0, 1]: increased acceleration
+     */
+    double cursor_acceleration_bias{0.0};
+
+    /*!
+     * Configures a signed scale of the horizontal scrolling. Use negative values to configure 'natural scrolling'
+     */
+    double horizontal_scroll_scale{1.0};
+
+    /*!
+     * Configures a signed scale of the vertical scrolling. Use negative values to configure 'natural scrolling'
+     */
+    double vertical_scroll_scale{1.0};
+};
+
+}
+}
+
+#endif

=== added file 'include/server/mir/input/touchpad_configuration.h'
--- include/server/mir/input/touchpad_configuration.h	1970-01-01 00:00:00 +0000
+++ include/server/mir/input/touchpad_configuration.h	2015-11-18 14:50:22 +0000
@@ -0,0 +1,82 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 3,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by:
+ *   Andreas Pokorny <[e-mail]>
+ */
+
+#ifndef MIR_INPUT_TOUCH_PAD_CONFIGURATION_H_
+#define MIR_INPUT_TOUCH_PAD_CONFIGURATION_H_
+
+#include "mir_toolkit/common.h"
+#include "mir_toolkit/mir_input_device.h"
+
+namespace mir
+{
+namespace input
+{
+
+struct TouchpadConfiguration
+{
+    TouchpadConfiguration() {}
+    TouchpadConfiguration(MirTouchpadClickModes click_mode,
+                          MirTouchpadScrollModes scroll_mode,
+                          int button_down_scroll_button,
+                          bool tap_to_click,
+                          bool disable_while_typing,
+                          bool disable_with_mouse,
+                          bool middle_mouse_button_emulation)
+        : click_mode{click_mode}, scroll_mode{scroll_mode}, button_down_scroll_button{button_down_scroll_button},
+          tap_to_click{tap_to_click}, middle_mouse_button_emulation{middle_mouse_button_emulation},
+          disable_with_mouse{disable_with_mouse}, disable_while_typing{disable_while_typing}
+    {
+    }
+
+    /*!
+     * The click mode defines when the touchpad generates software emulated button events.
+     */
+    MirTouchpadClickModes click_mode{mir_touchpad_click_mode_finger_count};
+/*!
+     * The scroll mode defines when the touchpad generates scroll events instead of pointer motion events.
+     */
+    MirTouchpadScrollModes scroll_mode{mir_touchpad_scroll_mode_two_finger_scroll};
+
+    /*!
+     * Configures the button used for the on-button-down scroll mode
+     */
+    int button_down_scroll_button{0};
+
+    /*!
+     * When tap to click is enabled the system will interpret short finger touch down/up sequences as button clicks.
+     */
+    bool tap_to_click{true};
+    /*!
+     * Emulates a middle mouse button press when the left and right buttons on a touchpad are pressed.
+     */
+    bool middle_mouse_button_emulation{true};
+    /*!
+     * When disable-with-mouse is enabled the touchpad will stop to emit user input events when another pointing device is plugged in.
+     */
+    bool disable_with_mouse{false};
+    /*!
+     * When disable-with-mouse is enabled the touchpad will stop to emit user input events when the user starts to use a keyboard and a short period after.
+     */
+    bool disable_while_typing{false};
+};
+
+}
+}
+
+#endif

=== modified file 'include/server/mir/server.h'
--- include/server/mir/server.h	2015-10-07 16:41:50 +0000
+++ include/server/mir/server.h	2015-11-18 14:50:22 +0000
@@ -127,6 +127,14 @@
     void add_configuration_option(
         std::string const& option,
         std::string const& description,
+        double default_value);
+
+    /// Add user configuration option(s) to Mir's option handling.
+    /// These will be resolved during initialisation from the command line,
+    /// environment variables, a config file or the supplied default.
+    void add_configuration_option(
+        std::string const& option,
+        std::string const& description,
         std::string const& default_value);
 
     /// Add user configuration option(s) to Mir's option handling.

=== modified file 'src/server/input/CMakeLists.txt'
--- src/server/input/CMakeLists.txt	2015-11-04 07:43:28 +0000
+++ src/server/input/CMakeLists.txt	2015-11-18 14:50:22 +0000
@@ -4,26 +4,24 @@
 set(
   INPUT_SOURCES
 
+  builtin_cursor_images.cpp
+  cursor_controller.cpp
+  default_configuration.cpp
   default_device.cpp
   default_event_builder.cpp
+  default_input_device_hub.cpp
   default_input_manager.cpp
-  default_input_device_hub.cpp
+  display_input_region.cpp
+  event_filter_chain_dispatcher.cpp
   input_modifier_utils.cpp
+  key_repeat_dispatcher.cpp
+  null_input_channel_factory.cpp
+  null_input_dispatcher.cpp
   seat.cpp
-
   surface_input_dispatcher.cpp
-  event_filter_chain_dispatcher.cpp
-
-  null_input_channel_factory.cpp
-  null_input_dispatcher.cpp
-  display_input_region.cpp
-  vt_filter.cpp
-  cursor_controller.cpp
-  default_configuration.cpp
-  builtin_cursor_images.cpp
   touchspot_controller.cpp
-  key_repeat_dispatcher.cpp
   validator.cpp
+  vt_filter.cpp
 )
 
 add_subdirectory(android)

=== modified file 'src/server/input/default_device.cpp'
--- src/server/input/default_device.cpp	2015-09-30 20:33:59 +0000
+++ src/server/input/default_device.cpp	2015-11-18 14:50:22 +0000
@@ -17,12 +17,21 @@
  *   Andreas Pokorny <[e-mail]>
  */
 
-#include "device_handle.h"
+#include "default_device.h"
+#include "mir/dispatch/action_queue.h"
+#include "mir/input/device_capability.h"
+#include "mir/input/input_device.h"
+#include "mir/input/touchpad_configuration.h"
+#include "mir/input/pointer_configuration.h"
+
+#include <boost/throw_exception.hpp>
+#include <stdexcept>
 
 namespace mi = mir::input;
 
-mi::DefaultDevice::DefaultDevice(MirInputDeviceId id, mi::InputDeviceInfo const& info) :
-    device_id{id}, info(info)
+mi::DefaultDevice::DefaultDevice(MirInputDeviceId id, std::shared_ptr<dispatch::ActionQueue> const& actions,
+                                 std::shared_ptr<InputDevice> const& device) :
+    device_id{id}, device{device}, info(device->get_device_info()), pointer{device->get_pointer_settings()}, touchpad{device->get_touchpad_settings()}, actions{actions}
 {
 }
 
@@ -45,3 +54,73 @@
 {
     return device_id;
 }
+
+mir::optional_value<mi::PointerConfiguration> mi::DefaultDevice::pointer_configuration() const
+{
+    if (!pointer.is_set())
+        return {};
+
+    auto const& settings = pointer.value();
+
+    return PointerConfiguration(settings.handedness, settings.cursor_acceleration_bias,
+                                settings.horizontal_scroll_scale, settings.vertical_scroll_scale);
+}
+
+mir::optional_value<mi::TouchpadConfiguration> mi::DefaultDevice::touchpad_configuration() const
+{
+    if (!touchpad.is_set())
+        return {};
+
+    auto const& settings = touchpad.value();
+
+    return TouchpadConfiguration(settings.click_mode, settings.scroll_mode, settings.button_down_scroll_button,
+                                 settings.tap_to_click, settings.disable_while_typing, settings.disable_with_mouse,
+                                 settings.middle_mouse_button_emulation);
+}
+
+void mi::DefaultDevice::apply_pointer_configuration(mi::PointerConfiguration const& conf)
+{
+    if (!pointer.is_set())
+        BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot apply a pointer configuration"));
+
+    if (conf.cursor_acceleration_bias < -1.0 || conf.cursor_acceleration_bias > 1.0)
+        BOOST_THROW_EXCEPTION(std::invalid_argument("Cursor acceleration bias out of range"));
+
+    PointerSettings settings;
+    settings.handedness = conf.handedness;
+    settings.cursor_acceleration_bias = conf.cursor_acceleration_bias;
+    settings.vertical_scroll_scale = conf.vertical_scroll_scale;
+    settings.horizontal_scroll_scale = conf.horizontal_scroll_scale;
+
+    pointer = settings;
+
+    actions->enqueue([settings = std::move(settings), dev=device]
+                     {
+                         dev->apply_settings(settings);
+                     });
+}
+
+void mi::DefaultDevice::apply_touchpad_configuration(mi::TouchpadConfiguration const& conf)
+{
+    if (!touchpad.is_set())
+        BOOST_THROW_EXCEPTION(std::invalid_argument("Cannot apply a touchpad configuration"));
+
+    if (conf.scroll_mode & mir_touchpad_scroll_mode_button_down_scroll && conf.button_down_scroll_button == mi::no_scroll_button)
+        BOOST_THROW_EXCEPTION(std::invalid_argument("No scroll button configured"));
+
+    TouchpadSettings settings;
+    settings.click_mode = conf.click_mode;
+    settings.scroll_mode = conf.scroll_mode;
+    settings.button_down_scroll_button = conf.button_down_scroll_button;
+    settings.disable_with_mouse = conf.disable_with_mouse;
+    settings.disable_while_typing = conf.disable_while_typing;
+    settings.tap_to_click = conf.tap_to_click;
+    settings.middle_mouse_button_emulation = conf.middle_mouse_button_emulation;
+
+    touchpad = settings;
+
+    actions->enqueue([settings = std::move(settings), dev=device]
+                     {
+                         dev->apply_settings(settings);
+                     });
+}

=== renamed file 'src/server/input/device_handle.h' => 'src/server/input/default_device.h'
--- src/server/input/device_handle.h	2015-10-01 09:52:28 +0000
+++ src/server/input/default_device.h	2015-11-18 14:50:22 +0000
@@ -23,26 +23,44 @@
 #include "mir_toolkit/event.h"
 #include "mir/input/device.h"
 #include "mir/input/input_device_info.h"
-#include "mir/module_deleter.h"
+#include "mir/input/pointer_settings.h"
+#include "mir/input/touchpad_settings.h"
+#include "mir/optional_value.h"
 
 #include <memory>
 
 namespace mir
 {
+namespace dispatch
+{
+class ActionQueue;
+}
 namespace input
 {
 
+class InputDevice;
+
 class DefaultDevice : public Device
 {
 public:
-    DefaultDevice(MirInputDeviceId id, InputDeviceInfo const& info);
+    DefaultDevice(MirInputDeviceId id, std::shared_ptr<dispatch::ActionQueue> const& actions,
+                  std::shared_ptr<InputDevice> const& device);
     MirInputDeviceId id() const override;
     DeviceCapabilities capabilities() const override;
     std::string name() const override;
     std::string unique_id() const override;
+
+    optional_value<PointerConfiguration> pointer_configuration() const override;
+    void apply_pointer_configuration(PointerConfiguration const&) override;
+    optional_value<TouchpadConfiguration> touchpad_configuration() const override;
+    void apply_touchpad_configuration(TouchpadConfiguration const&) override;
 private:
-    MirInputDeviceId device_id;
-    InputDeviceInfo info;
+    MirInputDeviceId const device_id;
+    std::shared_ptr<InputDevice> const device;
+    InputDeviceInfo const info;
+    optional_value<PointerSettings> pointer;
+    optional_value<TouchpadSettings> touchpad;
+    std::shared_ptr<dispatch::ActionQueue> const actions;
 };
 
 }

=== modified file 'src/server/input/default_input_device_hub.cpp'
--- src/server/input/default_input_device_hub.cpp	2015-11-04 07:43:28 +0000
+++ src/server/input/default_input_device_hub.cpp	2015-11-18 14:50:22 +0000
@@ -17,7 +17,7 @@
  */
 
 #include "default_input_device_hub.h"
-#include "device_handle.h"
+#include "default_device.h"
 
 #include "seat.h"
 #include "mir/input/input_dispatcher.h"
@@ -27,6 +27,7 @@
 #include "mir/geometry/point.h"
 #include "mir/events/event_builders.h"
 #include "mir/dispatch/multiplexing_dispatchable.h"
+#include "mir/dispatch/action_queue.h"
 #include "mir/server_action_queue.h"
 #include "mir/cookie_factory.h"
 #define MIR_LOG_COMPONENT "Input"
@@ -52,11 +53,13 @@
     : input_dispatcher(input_dispatcher),
       input_dispatchable{input_multiplexer},
       observer_queue(observer_queue),
+      device_queue(std::make_shared<dispatch::ActionQueue>()),
       input_region(input_region),
       cookie_factory(cookie_factory),
       seat(touch_visualizer, cursor_listener),
       device_id_generator{0}
 {
+    input_dispatchable->add_watch(device_queue);
 }
 
 void mi::DefaultInputDeviceHub::add_device(std::shared_ptr<InputDevice> const& device)
@@ -80,8 +83,7 @@
         auto const& dev = devices.back();
         seat.add_device(dev->id());
 
-        auto handle = std::make_shared<DefaultDevice>(
-            dev->id(), device->get_device_info());
+        auto handle = std::make_shared<DefaultDevice>(dev->id(), device_queue, device);
 
         // pass input device handle to observer loop..
         observer_queue->enqueue(this,

=== modified file 'src/server/input/default_input_device_hub.h'
--- src/server/input/default_input_device_hub.h	2015-11-04 07:43:28 +0000
+++ src/server/input/default_input_device_hub.h	2015-11-18 14:50:22 +0000
@@ -44,6 +44,7 @@
 {
 class Dispatchable;
 class MultiplexingDispatchable;
+class ActionQueue;
 }
 namespace input
 {
@@ -82,6 +83,7 @@
     std::shared_ptr<InputDispatcher> const input_dispatcher;
     std::shared_ptr<dispatch::MultiplexingDispatchable> const input_dispatchable;
     std::shared_ptr<ServerActionQueue> const observer_queue;
+    std::shared_ptr<dispatch::ActionQueue> const device_queue;
     std::shared_ptr<InputRegion> const input_region;
     std::shared_ptr<cookie::CookieFactory> const cookie_factory;
     Seat seat;

=== modified file 'src/server/server.cpp'
--- src/server/server.cpp	2015-10-09 14:59:25 +0000
+++ src/server/server.cpp	2015-11-18 14:50:22 +0000
@@ -507,6 +507,27 @@
 void mir::Server::add_configuration_option(
     std::string const& option,
     std::string const& description,
+    double default_)
+{
+    verify_setting_allowed(self->server_config);
+    namespace po = boost::program_options;
+
+    auto const& existing = self->add_configuration_options;
+
+    auto const option_adder = [=](options::DefaultConfiguration& config)
+        {
+            existing(config);
+
+            config.add_options()
+            (option.c_str(), po::value<double>()->default_value(default_), description.c_str());
+        };
+
+    self->set_add_configuration_options(option_adder);
+}
+
+void mir::Server::add_configuration_option(
+    std::string const& option,
+    std::string const& description,
     std::string const& default_)
 {
     verify_setting_allowed(self->server_config);

=== modified file 'tests/unit-tests/input/CMakeLists.txt'
--- tests/unit-tests/input/CMakeLists.txt	2015-10-29 03:39:10 +0000
+++ tests/unit-tests/input/CMakeLists.txt	2015-11-18 14:50:22 +0000
@@ -9,6 +9,7 @@
   ${CMAKE_CURRENT_SOURCE_DIR}/test_touchspot_controller.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_input_event.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_event_builders.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/test_default_device.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_default_input_device_hub.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_default_input_manager.cpp
   ${CMAKE_CURRENT_SOURCE_DIR}/test_surface_input_dispatcher.cpp

=== added file 'tests/unit-tests/input/test_default_device.cpp'
--- tests/unit-tests/input/test_default_device.cpp	1970-01-01 00:00:00 +0000
+++ tests/unit-tests/input/test_default_device.cpp	2015-11-18 14:50:22 +0000
@@ -0,0 +1,135 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Andreas Pokorny <[e-mail]>
+ */
+
+#include "src/server/input/default_device.h"
+#include "mir/input/input_device.h"
+#include "mir/input/touchpad_configuration.h"
+#include "mir/input/pointer_configuration.h"
+#include "mir/dispatch/action_queue.h"
+#include "mir/test/fake_shared.h"
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <stdexcept>
+
+namespace mi = mir::input;
+namespace mt = mir::test;
+namespace md = mir::dispatch;
+using namespace ::testing;
+namespace
+{
+struct MockInputDevice : public mi::InputDevice
+{
+    MOCK_METHOD2(start, void(mi::InputSink* destination, mi::EventBuilder* builder));
+    MOCK_METHOD0(stop, void());
+    MOCK_METHOD0(get_device_info, mi::InputDeviceInfo());
+    MOCK_CONST_METHOD0(get_pointer_settings, mir::optional_value<mi::PointerSettings>());
+    MOCK_METHOD1(apply_settings, void(mi::PointerSettings const&));
+    MOCK_CONST_METHOD0(get_touchpad_settings, mir::optional_value<mi::TouchpadSettings>());
+    MOCK_METHOD1(apply_settings, void(mi::TouchpadSettings const&));
+};
+
+struct DefaultDevice : Test
+{
+    NiceMock<MockInputDevice> touchpad;
+    NiceMock<MockInputDevice> mouse;
+    NiceMock<MockInputDevice> keyboard;
+    std::shared_ptr<md::ActionQueue> queue{std::make_shared<md::ActionQueue>()};
+
+    DefaultDevice()
+    {
+        using optional_pointer_settings = mir::optional_value<mi::PointerSettings>;
+        using optional_touchpad_settings = mir::optional_value<mi::TouchpadSettings>;
+        ON_CALL(touchpad, get_device_info())
+            .WillByDefault(Return(mi::InputDeviceInfo{"name", "unique", mi::DeviceCapability::touchpad|mi::DeviceCapability::pointer}));
+        ON_CALL(touchpad, get_pointer_settings())
+            .WillByDefault(Return(optional_pointer_settings{mi::PointerSettings{}}));
+        ON_CALL(touchpad, get_touchpad_settings())
+            .WillByDefault(Return(optional_touchpad_settings{mi::TouchpadSettings{}}));
+
+        ON_CALL(mouse, get_device_info())
+            .WillByDefault(Return(mi::InputDeviceInfo{"name", "unique", mi::DeviceCapability::pointer}));
+        ON_CALL(mouse, get_pointer_settings()).WillByDefault(Return(optional_pointer_settings{mi::PointerSettings{}}));
+        ON_CALL(mouse, get_touchpad_settings()).WillByDefault(Return(optional_touchpad_settings{}));
+
+        ON_CALL(keyboard, get_device_info())
+            .WillByDefault(Return(mi::InputDeviceInfo{"name", "unique", mi::DeviceCapability::keyboard}));
+        ON_CALL(keyboard, get_pointer_settings()).WillByDefault(Return(optional_pointer_settings{}));
+        ON_CALL(keyboard, get_touchpad_settings()).WillByDefault(Return(optional_touchpad_settings{}));
+    }
+};
+
+}
+
+TEST_F(DefaultDevice, refuses_touchpad_config_on_mice)
+{
+    mi::DefaultDevice dev(MirInputDeviceId{17}, queue, mt::fake_shared(mouse));
+    mi::TouchpadConfiguration touch_conf;
+
+    EXPECT_THROW({dev.apply_touchpad_configuration(touch_conf);}, std::invalid_argument);
+}
+
+TEST_F(DefaultDevice, refuses_touchpad_and_pointer_settings_on_keyboards)
+{
+    mi::DefaultDevice dev(MirInputDeviceId{17}, queue, mt::fake_shared(keyboard));
+    mi::TouchpadConfiguration touch_conf;
+    mi::PointerConfiguration pointer_conf;
+
+    EXPECT_THROW({dev.apply_touchpad_configuration(touch_conf);}, std::invalid_argument);
+    EXPECT_THROW({dev.apply_pointer_configuration(pointer_conf);}, std::invalid_argument);
+}
+
+
+TEST_F(DefaultDevice, accepts_pointer_config_on_mice)
+{
+    mi::DefaultDevice dev(MirInputDeviceId{17}, queue, mt::fake_shared(mouse));
+    mi::PointerConfiguration pointer_conf;
+
+    EXPECT_CALL(mouse, apply_settings(Matcher<mi::PointerSettings const&>(_)));
+
+    dev.apply_pointer_configuration(pointer_conf);
+    queue->dispatch(md::FdEvent::readable);
+}
+
+TEST_F(DefaultDevice, accepts_touchpad_and_pointer_config_on_touchpads)
+{
+    mi::DefaultDevice dev(MirInputDeviceId{17}, queue, mt::fake_shared(touchpad));
+    mi::TouchpadConfiguration touch_conf;
+    mi::PointerConfiguration pointer_conf;
+
+    EXPECT_CALL(touchpad, apply_settings(Matcher<mi::PointerSettings const&>(_)));
+    EXPECT_CALL(touchpad, apply_settings(Matcher<mi::TouchpadSettings const&>(_)));
+
+    dev.apply_touchpad_configuration(touch_conf);
+    dev.apply_pointer_configuration(pointer_conf);
+    queue->dispatch(md::FdEvent::readable);
+    queue->dispatch(md::FdEvent::readable);
+}
+
+TEST_F(DefaultDevice, ensures_cursor_accleration_bias_is_in_range)
+{
+    mi::DefaultDevice dev(MirInputDeviceId{17}, queue, mt::fake_shared(touchpad));
+
+    mi::PointerConfiguration pointer_conf;
+    pointer_conf.cursor_acceleration_bias = 3.0;
+    EXPECT_THROW({dev.apply_pointer_configuration(pointer_conf);}, std::invalid_argument);
+    pointer_conf.cursor_acceleration_bias = -2.0;
+    EXPECT_THROW({dev.apply_pointer_configuration(pointer_conf);}, std::invalid_argument);
+
+    pointer_conf.cursor_acceleration_bias = 1.0;
+    EXPECT_NO_THROW(dev.apply_pointer_configuration(pointer_conf));
+}

=== modified file 'tests/unit-tests/input/test_default_input_device_hub.cpp'
--- tests/unit-tests/input/test_default_input_device_hub.cpp	2015-11-04 07:43:28 +0000
+++ tests/unit-tests/input/test_default_input_device_hub.cpp	2015-11-18 14:50:22 +0000
@@ -29,6 +29,8 @@
 #include "mir/input/touchpad_settings.h"
 #include "mir/input/device.h"
 #include "mir/input/touch_visualizer.h"
+#include "mir/input/pointer_configuration.h"
+#include "mir/input/touchpad_configuration.h"
 #include "mir/input/input_device_observer.h"
 #include "mir/dispatch/multiplexing_dispatchable.h"
 #include "mir/dispatch/action_queue.h"
@@ -48,6 +50,7 @@
 namespace mtd = mt::doubles;
 namespace geom = mir::geometry;
 using namespace std::literals::chrono_literals;
+using namespace ::testing;
 
 namespace mir
 {
@@ -112,25 +115,43 @@
     Nice<MockInputDevice> device;
     Nice<MockInputDevice> another_device;
     Nice<MockInputDevice> third_device;
+    Nice<MockInputDevice> touchpad;
 
     std::chrono::nanoseconds arbitrary_timestamp;
 
     InputDeviceHubTest()
     {
-        using namespace testing;
-        ON_CALL(device,get_device_info())
+        ON_CALL(device, get_device_info())
             .WillByDefault(Return(mi::InputDeviceInfo{"device","dev-1", mi::DeviceCapability::unknown}));
+        ON_CALL(device, get_pointer_settings())
+            .WillByDefault(Return(mir::optional_value<mi::PointerSettings>()));
+        ON_CALL(device, get_touchpad_settings())
+            .WillByDefault(Return(mir::optional_value<mi::TouchpadSettings>()));
 
-        ON_CALL(another_device,get_device_info())
+        ON_CALL(another_device, get_device_info())
             .WillByDefault(Return(mi::InputDeviceInfo{"another_device","dev-2", mi::DeviceCapability::keyboard}));
+        ON_CALL(another_device, get_pointer_settings())
+            .WillByDefault(Return(mir::optional_value<mi::PointerSettings>()));
+        ON_CALL(another_device, get_touchpad_settings())
+            .WillByDefault(Return(mir::optional_value<mi::TouchpadSettings>()));
 
         ON_CALL(third_device,get_device_info())
             .WillByDefault(Return(mi::InputDeviceInfo{"third_device","dev-3", mi::DeviceCapability::keyboard}));
+        ON_CALL(third_device, get_pointer_settings())
+            .WillByDefault(Return(mir::optional_value<mi::PointerSettings>()));
+        ON_CALL(third_device, get_touchpad_settings())
+            .WillByDefault(Return(mir::optional_value<mi::TouchpadSettings>()));
+
+        ON_CALL(touchpad, get_device_info())
+            .WillByDefault(Return(mi::InputDeviceInfo{"touchpad", "dev-4", mi::DeviceCapability::touchpad|mi::DeviceCapability::pointer}));
+        ON_CALL(touchpad, get_pointer_settings())
+            .WillByDefault(Return(mi::PointerSettings()));
+        ON_CALL(touchpad, get_touchpad_settings())
+            .WillByDefault(Return(mi::TouchpadSettings()));
     }
 
     void capture_input_sink(Nice<MockInputDevice>& dev, mi::InputSink*& sink, mi::EventBuilder*& builder)
     {
-        using namespace ::testing;
         ON_CALL(dev,start(_,_))
             .WillByDefault(Invoke([&sink,&builder](mi::InputSink* input_sink, mi::EventBuilder* event_builder)
                                   {
@@ -143,8 +164,6 @@
 
 TEST_F(InputDeviceHubTest, input_device_hub_starts_device)
 {
-    using namespace ::testing;
-
     EXPECT_CALL(device,start(_,_));
 
     hub.add_device(mt::fake_shared(device));
@@ -152,8 +171,6 @@
 
 TEST_F(InputDeviceHubTest, input_device_hub_stops_device_on_removal)
 {
-    using namespace ::testing;
-
     EXPECT_CALL(device,stop());
 
     hub.add_device(mt::fake_shared(device));
@@ -162,7 +179,6 @@
 
 TEST_F(InputDeviceHubTest, input_device_hub_ignores_removal_of_unknown_devices)
 {
-    using namespace ::testing;
 
     EXPECT_CALL(device,start(_,_)).Times(0);
     EXPECT_CALL(device,stop()).Times(0);
@@ -172,7 +188,6 @@
 
 TEST_F(InputDeviceHubTest, input_device_hub_start_stop_happens_in_order)
 {
-    using namespace ::testing;
 
     InSequence seq;
     EXPECT_CALL(device, start(_,_));
@@ -199,8 +214,6 @@
 
 TEST_F(InputDeviceHubTest, observers_receive_devices_on_add)
 {
-    using namespace ::testing;
-
     std::shared_ptr<mi::Device> handle_1, handle_2;
 
     InSequence seq;
@@ -239,8 +252,6 @@
 
 TEST_F(InputDeviceHubTest, observers_receive_device_changes)
 {
-    using namespace ::testing;
-
     InSequence seq;
     EXPECT_CALL(mock_observer, changes_complete());
     EXPECT_CALL(mock_observer, device_added(WithName("device")));
@@ -257,8 +268,6 @@
 
 TEST_F(InputDeviceHubTest, input_sink_posts_events_to_input_dispatcher)
 {
-    using namespace ::testing;
-
     mi::InputSink* sink;
     mi::EventBuilder* builder;
     std::shared_ptr<mi::Device> handle;
@@ -283,7 +292,6 @@
 
 TEST_F(InputDeviceHubTest, forwards_touch_spots_to_visualizer)
 {
-    using namespace ::testing;
     mi::InputSink* sink;
     mi::EventBuilder* builder;
 
@@ -352,7 +360,6 @@
 
 TEST_F(InputDeviceHubTest, confines_pointer_movement)
 {
-    using namespace ::testing;
     geom::Point confined_pos{10, 18};
 
     ON_CALL(mock_region,confine(_))
@@ -375,8 +382,6 @@
 
 TEST_F(InputDeviceHubTest, forwards_pointer_updates_to_cursor_listener)
 {
-    using namespace ::testing;
-
     auto x = 12.2f, y = 14.3f;
 
     mi::InputSink* sink;
@@ -391,6 +396,38 @@
     sink->handle_input(*event);
 }
 
+TEST_F(InputDeviceHubTest, forwards_pointer_settings_to_input_device)
+{
+    std::shared_ptr<mi::Device> dev;
+    ON_CALL(mock_observer, device_added(_)).WillByDefault(SaveArg<0>(&dev));
+
+    hub.add_observer(mt::fake_shared(mock_observer));
+    hub.add_device(mt::fake_shared(touchpad));
+    observer_loop.trigger_server_actions();
+
+    EXPECT_CALL(touchpad, apply_settings(Matcher<mi::PointerSettings const&>(_)));
+
+    auto conf = dev->pointer_configuration();
+    dev->apply_pointer_configuration(conf.value());
+    multiplexer.dispatch(mir::dispatch::FdEvent::readable);
+}
+
+TEST_F(InputDeviceHubTest, forwards_touchpad_settings_to_input_device)
+{
+    std::shared_ptr<mi::Device> dev;
+    ON_CALL(mock_observer, device_added(_)).WillByDefault(SaveArg<0>(&dev));
+
+    hub.add_observer(mt::fake_shared(mock_observer));
+    hub.add_device(mt::fake_shared(touchpad));
+    observer_loop.trigger_server_actions();
+
+    EXPECT_CALL(touchpad, apply_settings(Matcher<mi::TouchpadSettings const&>(_)));
+
+    auto conf = dev->touchpad_configuration();
+    dev->apply_touchpad_configuration(conf.value());
+    multiplexer.dispatch(mir::dispatch::FdEvent::readable);
+}
+
 TEST_F(InputDeviceHubTest, input_sink_tracks_modifier)
 {
     using namespace ::testing;