Merge lp:~alan-griffiths/miral/0.4 into lp:miral/release

[Alan Griffiths]

Release 0.4.0

[Alan Griffiths (alan-griffiths)]

lp:1639567

review: Needs Fixing

[Alan Griffiths (alan-griffiths)]

> lp:1639567

Weird can't reproduce

[Alan Griffiths (alan-griffiths)]

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2016-10-16 16:14:18 +0000
+++ CMakeLists.txt	2016-11-04 16:34:03 +0000
@@ -37,7 +37,7 @@
 include_directories(include SYSTEM ${MIRCLIENT_INCLUDE_DIRS})
 
 set(MIRAL_VERSION_MAJOR 0)
-set(MIRAL_VERSION_MINOR 3)
+set(MIRAL_VERSION_MINOR 4)
 set(MIRAL_VERSION_PATCH 0)
 
 set(MIRAL_VERSION ${MIRAL_VERSION_MAJOR}.${MIRAL_VERSION_MINOR}.${MIRAL_VERSION_PATCH})
 
=== modified file 'debian/changelog'
--- debian/changelog	2016-10-28 16:03:16 +0000
+++ debian/changelog	2016-11-04 16:34:03 +0000
@@ -1,3 +1,20 @@
+miral (0.4.0) UNRELEASED; urgency=medium
+
+  * New upstream release 0.4.0 (https://launchpad.net/miral/+milestone/0.4)
+    - ABI summary:
+      . miral ABI unchanged at 1
+    - Enhancements:
+      . Add miral::WindowManagerTools::force_close(window) to forcefully close
+        a window (i.e. without a close request to the client)
+      . Add functions to manage Applications
+      . Add miral::CommandLineOption - enables the setting and processing of
+        configuration options. These may be supplied on the commandline, as
+        MIR_SERVER_XXX environment variables or in a config file.
+      . Add +options to the keymap configuration
+      . [miral-shell] Add window name to titlebars
+
+ -- Alan Griffiths <[e-mail]>  Fri, 28 Oct 2016 12:14:59 +0100
+
 miral (0.3.0+17.04.20161028-0ubuntu1) zesty; urgency=medium
 
   * No change rebuild to target Xenial+Overlay
 
=== modified file 'debian/control'
--- debian/control	2016-09-19 13:27:49 +0000
+++ debian/control	2016-11-04 16:34:03 +0000
@@ -19,6 +19,7 @@
                mirtest-dev,
                libglib2.0-dev,
                libgles2-mesa-dev,
+               libfreetype6-dev,
 # The following workaround missing dependencies in Mir packages
                uuid-dev,
                libboost-system-dev,
 
=== modified file 'debian/libmiral1.symbols'
--- debian/libmiral1.symbols	2016-10-11 13:28:07 +0000
+++ debian/libmiral1.symbols	2016-11-04 16:34:03 +0000
@@ -2,6 +2,7 @@
  MIRAL_0.1@MIRAL_0.1 0.1.0
  MIRAL_0.2@MIRAL_0.2 0.2.0
  MIRAL_0.3@MIRAL_0.3 0.3.0
+ MIRAL_0.4@MIRAL_0.4 0.3.0
  (c++)"miral::ActiveOutputsListener::advise_output_begin()@MIRAL_0.1" 0.1.0
  (c++)"miral::ActiveOutputsListener::advise_output_create(miral::Output const&)@MIRAL_0.1" 0.1.0
  (c++)"miral::ActiveOutputsListener::advise_output_delete(miral::Output const&)@MIRAL_0.1" 0.1.0
@@ -275,3 +276,32 @@
  (c++)"miral::Keymap::~Keymap()@MIRAL_0.3" 0.3.0
  (c++)"miral::Keymap::operator=(miral::Keymap const&)@MIRAL_0.3" 0.3.0
  (c++)"miral::Keymap::operator()(mir::Server&) const@MIRAL_0.3" 0.3.0
+ (c++)"miral::ApplicationInfo::name[abi:cxx11]() const@MIRAL_0.4" 0.4.0
+ (c++)"miral::CommandLineOption::CommandLineOption(miral::CommandLineOption const&)@MIRAL_0.4" 0.4.0
+ (c++)"miral::CommandLineOption::CommandLineOption(std::function<void (mir::optional_value<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > const&)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@MIRAL_0.4" 0.4.0
+ (c++)"miral::CommandLineOption::CommandLineOption(std::function<void (mir::optional_value<bool> const&)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@MIRAL_0.4" 0.4.0
+ (c++)"miral::CommandLineOption::CommandLineOption(std::function<void (mir::optional_value<int> const&)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@MIRAL_0.4" 0.4.0
+ (c++)"miral::CommandLineOption::CommandLineOption(std::function<void (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, char const*)@MIRAL_0.4" 0.4.0
+ (c++)"miral::CommandLineOption::CommandLineOption(std::function<void (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@MIRAL_0.4" 0.4.0
+ (c++)"miral::CommandLineOption::CommandLineOption(std::function<void (bool)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@MIRAL_0.4" 0.4.0
+ (c++)"miral::CommandLineOption::CommandLineOption(std::function<void (bool)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, bool)@MIRAL_0.4" 0.4.0
+ (c++)"miral::CommandLineOption::CommandLineOption(std::function<void (double)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, double)@MIRAL_0.4" 0.4.0
+ (c++)"miral::CommandLineOption::CommandLineOption(std::function<void (int)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, int)@MIRAL_0.4" 0.4.0
+ (c++)"miral::CommandLineOption::CommandLineOption(miral::CommandLineOption const&)@MIRAL_0.4" 0.4.0
+ (c++)"miral::CommandLineOption::CommandLineOption(std::function<void (mir::optional_value<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > > const&)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@MIRAL_0.4" 0.4.0
+ (c++)"miral::CommandLineOption::CommandLineOption(std::function<void (mir::optional_value<bool> const&)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@MIRAL_0.4" 0.4.0
+ (c++)"miral::CommandLineOption::CommandLineOption(std::function<void (mir::optional_value<int> const&)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@MIRAL_0.4" 0.4.0
+ (c++)"miral::CommandLineOption::CommandLineOption(std::function<void (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, char const*)@MIRAL_0.4" 0.4.0
+ (c++)"miral::CommandLineOption::CommandLineOption(std::function<void (std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@MIRAL_0.4" 0.4.0
+ (c++)"miral::CommandLineOption::CommandLineOption(std::function<void (bool)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)@MIRAL_0.4" 0.4.0
+ (c++)"miral::CommandLineOption::CommandLineOption(std::function<void (bool)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, bool)@MIRAL_0.4" 0.4.0
+ (c++)"miral::CommandLineOption::CommandLineOption(std::function<void (double)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, double)@MIRAL_0.4" 0.4.0
+ (c++)"miral::CommandLineOption::CommandLineOption(std::function<void (int)>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, int)@MIRAL_0.4" 0.4.0
+ (c++)"miral::CommandLineOption::~CommandLineOption()@MIRAL_0.4" 0.4.0
+ (c++)"miral::CommandLineOption::~CommandLineOption()@MIRAL_0.4" 0.4.0
+ (c++)"miral::CommandLineOption::operator=(miral::CommandLineOption const&)@MIRAL_0.4" 0.4.0
+ (c++)"miral::CommandLineOption::operator()(mir::Server&) const@MIRAL_0.4" 0.4.0
+ (c++)"miral::WindowManagerTools::force_close(miral::Window const&)@MIRAL_0.4" 0.4.0
+ (c++)"miral::apply_lifecycle_state_to(std::shared_ptr<mir::scene::Session> const&, MirLifecycleState)@MIRAL_0.4" 0.4.0
+ (c++)"miral::pid_of(std::shared_ptr<mir::scene::Session> const&)@MIRAL_0.4" 0.4.0
+ (c++)"miral::name_of[abi:cxx11](std::shared_ptr<mir::scene::Session> const&)@MIRAL_0.4" 0.4.0
 
=== added directory 'debian/tmp'
=== modified file 'include/miral/application.h'
--- include/miral/application.h	2016-04-22 09:24:24 +0000
+++ include/miral/application.h	2016-11-04 16:34:03 +0000
@@ -19,7 +19,10 @@
 #ifndef MIRAL_APPLICATION_H
 #define MIRAL_APPLICATION_H
 
+#include <mir_toolkit/common.h>
+
 #include <memory>
+#include <string>
 
 namespace mir
 {
@@ -30,7 +33,10 @@
 {
 using Application = std::shared_ptr<mir::scene::Session>;
 
+void apply_lifecycle_state_to(Application const& application, MirLifecycleState state);
 void kill(Application const& application, int sig);
+auto name_of(Application const& application) -> std::string;
+auto pid_of(Application const& application) -> pid_t;
 }
 
 #endif //MIRAL_APPLICATION_H
 
=== modified file 'include/miral/application_info.h'
--- include/miral/application_info.h	2016-06-07 16:26:40 +0000
+++ include/miral/application_info.h	2016-11-04 16:34:03 +0000
@@ -21,9 +21,9 @@
 
 #include "miral/application.h"
 
+#include <string>
 #include <vector>
 
-
 namespace miral
 {
 class Window;
@@ -36,6 +36,7 @@
     ApplicationInfo(ApplicationInfo const& that);
     auto operator=(ApplicationInfo const& that) -> miral::ApplicationInfo&;
 
+    auto name() const -> std::string;
     auto application()  const -> Application;
     auto windows() const -> std::vector <Window>&;
     void add_window(Window const& window);
 
=== added file 'include/miral/command_line_option.h'
--- include/miral/command_line_option.h	1970-01-01 00:00:00 +0000
+++ include/miral/command_line_option.h	2016-11-04 16:34:03 +0000
@@ -0,0 +1,100 @@
+/*
+ * Copyright © 2016 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: Alan Griffiths <[e-mail]>
+ */
+
+#ifndef MIRAL_COMMAND_LINE_OPTION_H
+#define MIRAL_COMMAND_LINE_OPTION_H
+
+#include <mir/optional_value.h>
+
+#include <functional>
+#include <memory>
+#include <string>
+
+namespace mir { class Server; }
+
+namespace miral
+{
+/// Add a user configuration option to Mir's option handling.
+/// The callback will be invoked during initialisation with a value supplied
+/// from the command line, environment variable, config file or the default.
+class CommandLineOption
+{
+public:
+    CommandLineOption(
+        std::function<void(int value)> callback,
+        std::string const& option,
+        std::string const& description,
+        int default_value);
+
+    CommandLineOption(
+        std::function<void(double value)> callback,
+        std::string const& option,
+        std::string const& description,
+        double default_value);
+
+    CommandLineOption(
+        std::function<void(std::string const& value)> callback,
+        std::string const& option,
+        std::string const& description,
+        std::string const& default_value);
+
+    CommandLineOption(
+        std::function<void(std::string const& value)> callback,
+        std::string const& option,
+        std::string const& description,
+        char const* default_value);
+
+    CommandLineOption(
+        std::function<void(bool value)> callback,
+        std::string const& option,
+        std::string const& description,
+        bool default_value);
+
+    CommandLineOption(
+        std::function<void(mir::optional_value<int> const& value)> callback,
+        std::string const& option,
+        std::string const& description);
+
+    CommandLineOption(
+        std::function<void(mir::optional_value<std::string> const& value)> callback,
+        std::string const& option,
+        std::string const& description);
+
+    CommandLineOption(
+        std::function<void(mir::optional_value<bool> const& value)> callback,
+        std::string const& option,
+        std::string const& description);
+
+    CommandLineOption(
+        std::function<void(bool is_set)> callback,
+        std::string const& option,
+        std::string const& description);
+
+    void operator()(mir::Server& server) const;
+
+    ~CommandLineOption();
+    CommandLineOption(CommandLineOption const&);
+    auto operator=(CommandLineOption const&) -> CommandLineOption&;
+
+private:
+    struct Self;
+    std::shared_ptr<Self> self;
+};
+}
+
+#endif //MIRAL_COMMAND_LINE_OPTION_H
 
=== modified file 'include/miral/keymap.h'
--- include/miral/keymap.h	2016-10-11 13:09:35 +0000
+++ include/miral/keymap.h	2016-11-04 16:34:03 +0000
@@ -35,7 +35,8 @@
     Keymap();
 
     /// Specify a keymap.
-    /// Format is <language>[+<variant>]
+    /// Format is <language>[+<variant>[+<options>]]
+    /// Options is a comma separated list.
     /// e.g. "uk" or "us+dvorak"
     explicit Keymap(std::string const& keymap);
     ~Keymap();
 
=== modified file 'include/miral/window_manager_tools.h'
--- include/miral/window_manager_tools.h	2016-10-05 16:54:07 +0000
+++ include/miral/window_manager_tools.h	2016-11-04 16:34:03 +0000
@@ -115,6 +115,10 @@
     /// Send close request to the window
     void ask_client_to_close(Window const& window);
 
+    /// Close the window by force
+    /// \note ask_client_to_close() is the polite way
+    void force_close(Window const& window);
+
     /// retrieve the active window
     auto active_window() const -> Window;
 
 
=== modified file 'miral-shell/CMakeLists.txt'
--- miral-shell/CMakeLists.txt	2016-10-06 15:36:15 +0000
+++ miral-shell/CMakeLists.txt	2016-11-04 16:34:03 +0000
@@ -22,8 +22,14 @@
     tiling_window_manager.cpp   tiling_window_manager.h
     titlebar_window_manager.cpp titlebar_window_manager.h
     titlebar_provider.cpp       titlebar_provider.h
+    titlebar_config.cpp         titlebar_config.h
 )
 
+pkg_check_modules(FREETYPE freetype2 REQUIRED)
+target_include_directories(miral-shell PUBLIC ${FREETYPE_INCLUDE_DIRS})
+target_compile_definitions(miral-shell PUBLIC -DTYPO_SUPPORTS_FREETYPE)
+target_link_libraries(miral-shell ${FREETYPE_LIBRARIES})
+
 target_link_libraries(miral-shell
     miral-spinner
     miral
 
=== modified file 'miral-shell/shell_main.cpp'
--- miral-shell/shell_main.cpp	2016-10-11 13:09:35 +0000
+++ miral-shell/shell_main.cpp	2016-11-04 16:34:03 +0000
@@ -18,6 +18,7 @@
 
 #include "tiling_window_manager.h"
 #include "titlebar_window_manager.h"
+#include "titlebar_config.h"
 #include "spinner/splash.h"
 
 #include <miral/display_configuration_option.h>
@@ -25,6 +26,7 @@
 #include <miral/window_management_options.h>
 #include <miral/append_event_filter.h>
 #include <miral/internal_client.h>
+#include <miral/command_line_option.h>
 #include <miral/cursor_theme.h>
 #include <miral/keymap.h>
 
@@ -80,6 +82,8 @@
             outputs_monitor,
             config_keymap,
             AppendEventFilter{quit_on_ctrl_alt_bksp},
-            StartupInternalClient{"Intro", spinner}
+            StartupInternalClient{"Intro", spinner},
+            CommandLineOption{[&](std::string const& typeface) { ::titlebar::font_file(typeface); },
+                              "shell-titlebar-font", "font file to use for titlebars", ::titlebar::font_file()}
         });
 }
 
=== added file 'miral-shell/titlebar_config.cpp'
--- miral-shell/titlebar_config.cpp	1970-01-01 00:00:00 +0000
+++ miral-shell/titlebar_config.cpp	2016-11-04 16:34:03 +0000
@@ -0,0 +1,38 @@
+/*
+ * Copyright © 2016 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: Alan Griffiths <[e-mail]>
+ */
+
+#include "titlebar_config.h"
+#include <mutex>
+
+namespace
+{
+std::mutex mutex;
+std::string font_file{"/usr/share/fonts/truetype/ubuntu-font-family/Ubuntu-B.ttf"};
+}
+
+void titlebar::font_file(std::string const& font_file)
+{
+    std::lock_guard<decltype(mutex)> lock{mutex};
+    ::font_file = font_file;
+}
+
+auto titlebar::font_file() -> std::string
+{
+    std::lock_guard<decltype(mutex)> lock{mutex};
+    return ::font_file;
+}
 
=== added file 'miral-shell/titlebar_config.h'
--- miral-shell/titlebar_config.h	1970-01-01 00:00:00 +0000
+++ miral-shell/titlebar_config.h	2016-11-04 16:34:03 +0000
@@ -0,0 +1,30 @@
+/*
+ * Copyright © 2016 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: Alan Griffiths <[e-mail]>
+ */
+
+#ifndef MIRAL_TITLEBAR_CONFIG_H
+#define MIRAL_TITLEBAR_CONFIG_H
+
+#include <string>
+
+namespace titlebar
+{
+void font_file(std::string const& font_file);
+auto font_file() -> std::string;
+}
+
+#endif //MIRAL_TITLEBAR_CONFIG_H
 
=== modified file 'miral-shell/titlebar_provider.cpp'
--- miral-shell/titlebar_provider.cpp	2016-10-05 16:54:07 +0000
+++ miral-shell/titlebar_provider.cpp	2016-11-04 16:34:03 +0000
@@ -17,21 +17,47 @@
  */
 
 #include "titlebar_provider.h"
+#include "titlebar_config.h"
 
 #include <miral/toolkit/surface_spec.h>
 
 #include <mir_toolkit/mir_buffer_stream.h>
 
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+#include <locale>
+#include <codecvt>
+#include <string>
 #include <cstring>
 #include <sstream>
 
+#include <iostream>
+
 namespace
 {
-int const title_bar_height = 10;
+int const title_bar_height = 12;
 
 void null_surface_callback(MirSurface*, void*) {}
 
-void paint_surface(MirSurface* surface, int const intensity)
+struct Printer
+{
+    Printer();
+    ~Printer();
+    Printer(Printer const&) = delete;
+    Printer& operator=(Printer const&) = delete;
+
+    void print(MirGraphicsRegion const& region, std::string const& title, int const intensity);
+
+private:
+    std::wstring_convert<std::codecvt_utf16<wchar_t>> converter;
+
+    bool working = false;
+    FT_Library lib;
+    FT_Face face;
+};
+
+void paint_surface(MirSurface* surface, std::string const& title, int const intensity)
 {
     MirBufferStream* buffer_stream = mir_surface_get_buffer_stream(surface);
 
@@ -51,8 +77,77 @@
         row += region.stride;
     }
 
+    static Printer printer;
+    printer.print(region, title, intensity);
+
     mir_buffer_stream_swap_buffers_sync(buffer_stream);
 }
+
+Printer::Printer()
+{
+    if (FT_Init_FreeType(&lib))
+        return;
+
+    if (FT_New_Face(lib, titlebar::font_file().c_str(), 0, &face))
+    {
+        std::cerr << "WARNING: failed to load titlebar font: \"" <<  titlebar::font_file() << "\"\n";
+        FT_Done_FreeType(lib);
+        return;
+    }
+
+    FT_Set_Pixel_Sizes(face, 0, 10);
+    working = true;
+}
+
+Printer::~Printer()
+{
+    if (working)
+    {
+        FT_Done_Face(face);
+        FT_Done_FreeType(lib);
+    }
+}
+
+void Printer::print(MirGraphicsRegion const& region, std::string const& title_, int const intensity)
+{
+    if (!working)
+        return;
+
+    auto title = converter.from_bytes(title_);
+
+    int base_x = 2;
+    int base_y = region.height-2;
+
+    for (auto const& ch : title)
+    {
+        FT_Load_Glyph(face, FT_Get_Char_Index(face, ch), FT_LOAD_DEFAULT);
+        auto const glyph = face->glyph;
+        FT_Render_Glyph(glyph, FT_RENDER_MODE_NORMAL);
+
+        auto const& bitmap = glyph->bitmap;
+        auto const x = base_x + glyph->bitmap_left;
+
+        if (static_cast<int>(x + bitmap.width) <= region.width)
+        {
+            unsigned char* src = bitmap.buffer;
+
+            auto const y = base_y - glyph->bitmap_top;
+            char* dest = region.vaddr + y*region.stride + 4*x;
+
+            for (auto row = 0u; row != std::min(bitmap.rows, glyph->bitmap_top+2u); ++row)
+            {
+                for (auto col = 0u; col != bitmap.width; ++col)
+                    memset(dest+ 4*col, (intensity*(0xff^src[col]))/0xff, 4);
+
+                src += bitmap.pitch;
+                dest += region.stride;
+            }
+        }
+
+        base_x += glyph->advance.x >> 6;
+        base_y += glyph->advance.y >> 6;
+    }
+}
 }
 
 using namespace miral::toolkit;
@@ -121,18 +216,22 @@
         });
 }
 
-void TitlebarProvider::paint_titlebar_for(miral::Window const& window, int intensity)
+void TitlebarProvider::paint_titlebar_for(miral::WindowInfo const& info, int intensity)
 {
-    if (auto data = find_titlebar_data(window))
+    this->intensity = intensity;
+
+    if (auto data = find_titlebar_data(info.window()))
     {
+        auto const title = info.name();
+
         if (auto surface = data->titlebar.load())
         {
-            enqueue_work([this, surface, intensity]{ paint_surface(surface, intensity); });
+            enqueue_work([this, surface, title, intensity]{ paint_surface(surface, title, intensity); });
         }
         else
         {
-            data->on_create = [this, intensity](MirSurface* surface)
-                { enqueue_work([this, surface, intensity]{ paint_surface(surface, intensity); }); };
+            data->on_create = [this, title, intensity](MirSurface* surface)
+                { enqueue_work([this, surface, title, intensity]{ paint_surface(surface, title, intensity); }); };
         }
     }
 }
@@ -157,14 +256,18 @@
     }
 }
 
-void TitlebarProvider::resize_titlebar_for(miral::Window const& window, Size const& size)
+void TitlebarProvider::resize_titlebar_for(miral::WindowInfo const& window_info, Size const& size)
 {
+    auto const window = window_info.window();
+
     if (window.size().width == size.width)
         return;
 
     if (auto titlebar_window = find_titlebar_window(window))
     {
         titlebar_window.resize({size.width, title_bar_height});
+
+        repaint_titlebar_for(window_info);
     }
 }
 
@@ -217,6 +320,18 @@
         }
 
         tools.modify_window(titlebar, modifications);
+        repaint_titlebar_for(window_info);
+    }
+}
+
+void TitlebarProvider::repaint_titlebar_for(miral::WindowInfo const& window_info)
+{
+    if (auto data = find_titlebar_data(window_info.window()))
+    {
+        auto const title = window_info.name();
+
+        if (auto surface = data->titlebar.load())
+            enqueue_work([this, surface, title]{ paint_surface(surface, title, intensity); });
     }
 }
 
 
=== modified file 'miral-shell/titlebar_provider.h'
--- miral-shell/titlebar_provider.h	2016-08-10 11:48:02 +0000
+++ miral-shell/titlebar_provider.h	2016-11-04 16:34:03 +0000
@@ -67,9 +67,9 @@
 
     void create_titlebar_for(miral::Window const& window);
     void place_new_titlebar(miral::WindowSpecification& window_spec);
-    void paint_titlebar_for(miral::Window const& window, int intensity);
+    void paint_titlebar_for(miral::WindowInfo const& window, int intensity);
     void destroy_titlebar_for(miral::Window const& window);
-    void resize_titlebar_for(miral::Window const& window, mir::geometry::Size const& size);
+    void resize_titlebar_for(miral::WindowInfo const& window_info, mir::geometry::Size const& size);
     void advise_new_titlebar(miral::WindowInfo const& window_info);
     void advise_state_change(miral::WindowInfo const& window_info, MirSurfaceState state);
 
@@ -92,6 +92,7 @@
     std::mutex mutable mutex;
     miral::toolkit::Connection connection;
     std::weak_ptr<mir::scene::Session> weak_session;
+    std::atomic<int> intensity{0xff};
 
     SurfaceMap window_to_titlebar;
     TitleMap windows_awaiting_titlebar;
@@ -99,6 +100,7 @@
     static void insert(MirSurface* surface, Data* data);
     Data* find_titlebar_data(miral::Window const& window);
     miral::Window find_titlebar_window(miral::Window const& window) const;
+    void repaint_titlebar_for(miral::WindowInfo const& window_info);
 };
 
 
 
=== modified file 'miral-shell/titlebar_window_manager.cpp'
--- miral-shell/titlebar_window_manager.cpp	2016-10-06 08:31:39 +0000
+++ miral-shell/titlebar_window_manager.cpp	2016-11-04 16:34:03 +0000
@@ -31,7 +31,7 @@
 
 namespace
 {
-int const title_bar_height = 10;
+int const title_bar_height = 12;
 }
 
 TitlebarWindowManagerPolicy::TitlebarWindowManagerPolicy(
@@ -275,9 +275,9 @@
         auto const parent = window_info.parent();
 
         if (tools.active_window() == parent)
-            titlebar_provider->paint_titlebar_for(parent, 0xFF);
+            titlebar_provider->paint_titlebar_for(tools.info_for(parent), 0xFF);
         else
-            titlebar_provider->paint_titlebar_for(parent, 0x3F);
+            titlebar_provider->paint_titlebar_for(tools.info_for(parent), 0x3F);
     }
 }
 
@@ -293,14 +293,14 @@
 {
     CanonicalWindowManagerPolicy::advise_focus_lost(info);
 
-    titlebar_provider->paint_titlebar_for(info.window(), 0x3F);
+    titlebar_provider->paint_titlebar_for(info, 0x3F);
 }
 
 void TitlebarWindowManagerPolicy::advise_focus_gained(WindowInfo const& info)
 {
     CanonicalWindowManagerPolicy::advise_focus_gained(info);
 
-    titlebar_provider->paint_titlebar_for(info.window(), 0xFF);
+    titlebar_provider->paint_titlebar_for(info, 0xFF);
 
     // Frig to force the spinner to the top
     if (auto const spinner_session = spinner.session())
@@ -323,7 +323,7 @@
 {
     CanonicalWindowManagerPolicy::advise_resize(window_info, new_size);
 
-    titlebar_provider->resize_titlebar_for(window_info.window(), new_size);
+    titlebar_provider->resize_titlebar_for(window_info, new_size);
 }
 
 void TitlebarWindowManagerPolicy::advise_delete_window(WindowInfo const& window_info)
 
=== modified file 'miral/CMakeLists.txt'
--- miral/CMakeLists.txt	2016-10-16 16:14:18 +0000
+++ miral/CMakeLists.txt	2016-11-04 16:34:03 +0000
@@ -31,6 +31,7 @@
     application_authorizer.cpp          ${CMAKE_SOURCE_DIR}/include/miral/application_authorizer.h
     application_info.cpp                ${CMAKE_SOURCE_DIR}/include/miral/application_info.h
     canonical_window_manager.cpp        ${CMAKE_SOURCE_DIR}/include/miral/canonical_window_manager.h
+    command_line_option.cpp             ${CMAKE_SOURCE_DIR}/include/miral/command_line_option.h
     cursor_theme.cpp                    ${CMAKE_SOURCE_DIR}/include/miral/cursor_theme.h
     keymap.cpp                          ${CMAKE_SOURCE_DIR}/include/miral/keymap.h
     runner.cpp                          ${CMAKE_SOURCE_DIR}/include/miral/runner.h
@@ -70,6 +71,14 @@
         LINK_DEPENDS ${symbol_map}
 )
 
+
+add_custom_target(check-symbols ALL
+        DEPENDS miral ${PROJECT_SOURCE_DIR}/debian/libmiral1.symbols
+        COMMAND dpkg-gensymbols -e${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libmiral.so.1 -plibmiral1 | scripts/filter_symbols_diff.sh
+        WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}"
+        VERBATIM
+)
+
 set(LIBDIR "${CMAKE_INSTALL_FULL_LIBDIR}")
 set(INCLUDEDIR "${CMAKE_INSTALL_PREFIX}/include/miral")
 
 
=== modified file 'miral/application.cpp'
--- miral/application.cpp	2016-07-07 14:24:32 +0000
+++ miral/application.cpp	2016-11-04 16:34:03 +0000
@@ -34,3 +34,18 @@
             ::kill(pid, sig);
     }
 }
+
+auto miral::name_of(Application const& application) -> std::string
+{
+    return application->name();
+}
+
+auto miral::pid_of(Application const& application) -> pid_t
+{
+    return application->process_id();
+}
+
+void miral::apply_lifecycle_state_to(Application const& application, MirLifecycleState state)
+{
+    application->set_lifecycle_state(state);
+}
 
=== modified file 'miral/application_info.cpp'
--- miral/application_info.cpp	2016-06-08 21:20:40 +0000
+++ miral/application_info.cpp	2016-11-04 16:34:03 +0000
@@ -19,6 +19,8 @@
 #include "miral/application_info.h"
 #include "miral/window.h"
 
+#include <mir/scene/session.h>
+
 struct miral::ApplicationInfo::Self
 {
     Self() = default;
@@ -52,6 +54,11 @@
     return *this;
 }
 
+auto miral::ApplicationInfo::name() const -> std::string
+{
+    return self->app ? self->app->name() : std::string{};
+}
+
 auto miral::ApplicationInfo::application() const -> Application
 {
     return self->app;
 
=== modified file 'miral/basic_window_manager.cpp'
--- miral/basic_window_manager.cpp	2016-10-10 14:53:39 +0000
+++ miral/basic_window_manager.cpp	2016-11-04 16:34:03 +0000
@@ -36,7 +36,7 @@
 
 namespace
 {
-int const title_bar_height = 10;
+int const title_bar_height = 12;
 
 struct Locker
 {
@@ -400,6 +400,14 @@
         mir_surface->request_client_surface_close();
 }
 
+void miral::BasicWindowManager::force_close(Window const& window)
+{
+    auto application = window.application();
+
+    if (application && window)
+        remove_surface(application, window);
+}
+
 auto miral::BasicWindowManager::active_window() const -> Window
 {
     return mru_active_windows.top();
 
=== modified file 'miral/basic_window_manager.h'
--- miral/basic_window_manager.h	2016-09-29 14:41:11 +0000
+++ miral/basic_window_manager.h	2016-11-04 16:34:03 +0000
@@ -112,6 +112,8 @@
 
     void ask_client_to_close(Window const& window) override;
 
+    void force_close(Window const& window) override;
+
     auto active_window() const -> Window override;
 
     auto select_active_window(Window const& hint) -> Window override;
 
=== added file 'miral/command_line_option.cpp'
--- miral/command_line_option.cpp	1970-01-01 00:00:00 +0000
+++ miral/command_line_option.cpp	2016-11-04 16:34:03 +0000
@@ -0,0 +1,199 @@
+/*
+ * Copyright © 2016 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: Alan Griffiths <[e-mail]>
+ */
+
+#include "miral/command_line_option.h"
+
+#include <mir/server.h>
+#include <mir/options/option.h>
+
+namespace
+{
+template<typename Type>
+struct OptionType;
+
+template<>
+struct OptionType<bool>
+{
+    auto static constexpr value = mir::OptionType::boolean;
+};
+
+template<>
+struct OptionType<void>
+{
+    auto static constexpr value = mir::OptionType::null;
+};
+
+template<>
+struct OptionType<std::string>
+{
+    auto static constexpr value = mir::OptionType::string;
+};
+
+template<>
+struct OptionType<int>
+{
+    auto static constexpr value = mir::OptionType::integer;
+};
+}
+
+struct miral::CommandLineOption::Self
+{
+    template<typename Value_t>
+    Self(std::function<void(Value_t value)> callback,
+         std::string const& option,
+         std::string const& description,
+         Value_t default_value) :
+        setup{[=](mir::Server& server)
+                  { server.add_configuration_option(option, description, default_value); }},
+        callback{[=](mir::Server& server)
+                     { callback(server.get_options()->get<Value_t>(option.c_str())); }}
+    {
+    }
+
+    template<typename Value_t>
+    Self(std::function<void(Value_t const& value)> callback,
+         std::string const& option,
+         std::string const& description,
+         Value_t const& default_value) :
+        setup{[=](mir::Server& server)
+                  { server.add_configuration_option(option, description, default_value); }},
+        callback{[=](mir::Server& server)
+                     { callback(server.get_options()->get<Value_t>(option.c_str())); }}
+    {
+    }
+
+    template<typename Value_t>
+    Self(std::function<void(mir::optional_value<Value_t> const& value)> callback,
+         std::string const& option,
+         std::string const& description) :
+        setup{[=](mir::Server& server)
+                  { server.add_configuration_option(option, description, OptionType<Value_t>::value); }},
+        callback{[=](mir::Server& server)
+                     {
+                        mir::optional_value<Value_t> optional_value;
+                        auto const options = server.get_options();
+                        if (options->is_set(option.c_str()))
+                            optional_value = server.get_options()->get<Value_t>(option.c_str());
+                        callback(optional_value);
+                     }}
+    {
+    }
+
+    Self(std::function<void(bool is_set)> callback,
+         std::string const& option,
+         std::string const& description) :
+        setup{[=](mir::Server& server)
+                  { server.add_configuration_option(option, description, OptionType<void>::value); }},
+        callback{[=](mir::Server& server)
+                 {
+                     auto const options = server.get_options();
+                     callback(options->is_set(option.c_str()));
+                 }}
+    {
+    }
+
+    std::function<void(mir::Server& server)> setup;
+    std::function<void(mir::Server& server)> callback;
+};
+
+miral::CommandLineOption::CommandLineOption(
+    std::function<void(int value)> callback,
+    std::string const& option,
+    std::string const& description,
+    int default_value) :
+    self{std::make_shared<Self>(callback, option, description, default_value)}
+{
+}
+
+miral::CommandLineOption::CommandLineOption(
+    std::function<void(double value)> callback,
+    std::string const& option,
+    std::string const& description,
+    double default_value) :
+    self{std::make_shared<Self>(callback, option, description, default_value)}
+{
+}
+
+miral::CommandLineOption::CommandLineOption(
+    std::function<void(std::string const& value)> callback,
+    std::string const& option,
+    std::string const& description,
+    std::string const& default_value) :
+    self{std::make_shared<Self>(callback, option, description, default_value)}
+{
+}
+
+miral::CommandLineOption::CommandLineOption(
+    std::function<void(std::string const& value)> callback,
+    std::string const& option,
+    std::string const& description,
+    char const* default_value) :
+    self{std::make_shared<Self>(callback, option, description, std::string{default_value})}
+{
+}
+
+miral::CommandLineOption::CommandLineOption(
+    std::function<void(bool value)> callback,
+    std::string const& option,
+    std::string const& description,
+    bool default_value) :
+    self{std::make_shared<Self>(callback, option, description, default_value)}
+{
+}
+
+miral::CommandLineOption::CommandLineOption(
+    std::function<void(mir::optional_value<int> const& value)> callback,
+    std::string const& option,
+    std::string const& description) :
+    self{std::make_shared<Self>(callback, option, description)}
+{
+}
+
+miral::CommandLineOption::CommandLineOption(
+    std::function<void(mir::optional_value<std::string> const& value)> callback,
+    std::string const& option,
+    std::string const& description) :
+    self{std::make_shared<Self>(callback, option, description)}
+{
+}
+
+miral::CommandLineOption::CommandLineOption(
+    std::function<void(mir::optional_value<bool> const& value)> callback,
+    std::string const& option,
+    std::string const& description) :
+    self{std::make_shared<Self>(callback, option, description)}
+{
+}
+
+miral::CommandLineOption::CommandLineOption(
+    std::function<void(bool is_set)> callback,
+    std::string const& option,
+    std::string const& description) :
+    self{std::make_shared<Self>(callback, option, description)}
+{
+}
+
+void miral::CommandLineOption::operator()(mir::Server& server) const
+{
+    self->setup(server);
+    server.add_init_callback([&]{ self->callback(server); });
+}
+
+miral::CommandLineOption::~CommandLineOption() = default;
+miral::CommandLineOption::CommandLineOption(CommandLineOption const&) = default;
+auto miral::CommandLineOption::operator=(CommandLineOption const&) -> CommandLineOption& = default;
 
=== modified file 'miral/display_configuration_option.cpp'
--- miral/display_configuration_option.cpp	2016-04-05 11:10:11 +0000
+++ miral/display_configuration_option.cpp	2016-11-04 16:34:03 +0000
@@ -58,13 +58,13 @@
 }
 
 PixelFormatSelector::PixelFormatSelector(
-    std::shared_ptr<DisplayConfigurationPolicy> const& base_policy,
+    std::shared_ptr<mg::DisplayConfigurationPolicy> const& base_policy,
     bool with_alpha) :
     base_policy{base_policy},
     with_alpha{with_alpha}
 {}
 
-void PixelFormatSelector::apply_to(mg::DisplayConfiguration & conf)
+void PixelFormatSelector::apply_to(mg::DisplayConfiguration& conf)
 {
     base_policy->apply_to(conf);
     conf.for_each_output(
 
=== modified file 'miral/keymap.cpp'
--- miral/keymap.cpp	2016-10-12 10:30:01 +0000
+++ miral/keymap.cpp	2016-11-04 16:34:03 +0000
@@ -53,13 +53,20 @@
     void set_keymap(std::string const& keymap)
     {
         std::lock_guard<decltype(mutex)> lock{mutex};
-
-        auto const i = keymap.find('+');
-
-        layout = keymap.substr(0, i);
-
-        if (i != std::string::npos)
-            variant = keymap.substr(i + 1);
+        auto get_next_token = [km = keymap]() mutable
+        {
+            auto const i = km.find('+');
+            auto ret = km.substr(0,i);
+            if (i != std::string::npos)
+                km = km.substr(i+1, std::string::npos);
+            else
+                km = "";
+            return ret;
+        };
+
+        layout = get_next_token();
+        variant = get_next_token();
+        options = get_next_token();
 
         for (auto const& keyboard : keyboards)
             apply_keymap(keyboard);
@@ -110,6 +117,7 @@
 
         keymap.layout = layout;
         keymap.variant = variant;
+        keymap.options = options;
         keyboard->apply_keyboard_configuration(std::move(keymap));
     }
 #else
@@ -134,6 +142,7 @@
     std::mutex mutable mutex;
     std::string layout;
     std::string variant;
+    std::string options;
     std::vector<std::shared_ptr<mir::input::Device>> keyboards;
 };
 
@@ -156,7 +165,7 @@
 void miral::Keymap::operator()(mir::Server& server) const
 {
     if (self->layout.empty())
-        server.add_configuration_option(keymap_option, "keymap <layout>[+<variant>], e,g, \"gb\" or \"cz+qwerty\"", keymap_default);
+        server.add_configuration_option(keymap_option, "keymap <layout>[+<variant>[+<options>]], e,g, \"gb\" or \"cz+qwerty\" or \"de++compose:caps\"", keymap_default);
 
     server.add_init_callback([this, &server]
         {
 
=== modified file 'miral/symbols.map'
--- miral/symbols.map	2016-10-11 11:51:49 +0000
+++ miral/symbols.map	2016-11-04 16:34:03 +0000
@@ -313,3 +313,19 @@
     vtable?for?miral::Keymap;
   };
 } MIRAL_0.2;
+
+MIRAL_0.4 {
+global:
+  extern "C++" {
+    miral::ApplicationInfo::name*;
+    miral::CommandLineOption::?CommandLineOption*;
+    miral::CommandLineOption::CommandLineOption*;
+    miral::CommandLineOption::operator*;
+    miral::WindowManagerTools::force_close*;
+    miral::apply_lifecycle_state_to*;
+    miral::name_of*;
+    miral::pid_of*;
+    typeinfo?for?miral::CommandLineOption;
+    vtable?for?miral::CommandLineOption;
+  };
+} MIRAL_0.3;
 
=== modified file 'miral/window_management_trace.cpp'
--- miral/window_management_trace.cpp	2016-10-04 13:58:00 +0000
+++ miral/window_management_trace.cpp	2016-11-04 16:34:03 +0000
@@ -363,6 +363,14 @@
     wrapped.ask_client_to_close(window);
 }
 
+void miral::WindowManagementTrace::force_close(miral::Window const& window)
+{
+    log_input();
+    mir::log_info("%s -> %s", __func__, dump_of(window).c_str());
+    trace_count++;
+    wrapped.force_close(window);
+}
+
 auto miral::WindowManagementTrace::active_window() const -> Window
 {
     log_input();
 
=== modified file 'miral/window_management_trace.h'
--- miral/window_management_trace.h	2016-09-29 14:41:11 +0000
+++ miral/window_management_trace.h	2016-11-04 16:34:03 +0000
@@ -49,6 +49,7 @@
     virtual auto info_for(Window const& window) const -> WindowInfo& override;
 
     virtual void ask_client_to_close(Window const& window) override;
+    virtual void force_close(Window const& window) override;
 
     virtual auto active_window() const -> Window override;
     virtual auto select_active_window(Window const& hint) -> Window override;
 
=== modified file 'miral/window_manager_tools.cpp'
--- miral/window_manager_tools.cpp	2016-10-05 16:54:07 +0000
+++ miral/window_manager_tools.cpp	2016-11-04 16:34:03 +0000
@@ -50,6 +50,9 @@
 void miral::WindowManagerTools::ask_client_to_close(Window const& window)
 { tools->ask_client_to_close(window); }
 
+void miral::WindowManagerTools::force_close(Window const& window)
+{ tools->force_close(window); }
+
 auto miral::WindowManagerTools::active_window() const -> Window
 { return tools->active_window(); }
 
 
=== modified file 'miral/window_manager_tools_implementation.h'
--- miral/window_manager_tools_implementation.h	2016-09-29 14:41:11 +0000
+++ miral/window_manager_tools_implementation.h	2016-11-04 16:34:03 +0000
@@ -54,6 +54,7 @@
     virtual auto info_for(Window const& window) const -> WindowInfo& = 0;
 
     virtual void ask_client_to_close(Window const& window) = 0;
+    virtual void force_close(Window const& window) = 0;
     virtual auto active_window() const -> Window = 0;
     virtual auto select_active_window(Window const& hint) -> Window = 0;
     virtual void drag_active_window(mir::geometry::Displacement movement) = 0;
 
=== added file 'scripts/filter_symbols_diff.sh'
--- scripts/filter_symbols_diff.sh	1970-01-01 00:00:00 +0000
+++ scripts/filter_symbols_diff.sh	2016-11-04 16:34:03 +0000
@@ -0,0 +1,2 @@
+#!/bin/sh
+c++filt | sed 's/+ \([^@]*[^[:space:]]*\)\(.*\)/+ (c++)"\1"\2/'
 
=== modified file 'scripts/process_doxygen_xml.py'
--- scripts/process_doxygen_xml.py	2016-10-06 08:26:40 +0000
+++ scripts/process_doxygen_xml.py	2016-11-04 16:34:03 +0000
@@ -1,79 +1,87 @@
 #! /usr/bin/python
-from xml.dom import minidom
-from sys import argv
-
-helptext = \
 """This script processes the XML generated by "make doc" and produces summary information
 on symbols that libmiral intends to make public.
 
 To use: Go to your build folder and run "make symbols"""""
 
-debug = False
-
-def get_text(node):
-    rc = []
+from xml.dom import minidom
+from sys import argv
+
+HELPTEXT = __doc__
+DEBUG = False
+
+def _get_text(node):
+    substrings = []
     for node in node.childNodes:
         if node.nodeType == node.TEXT_NODE:
-            rc.append(node.data)
+            substrings.append(node.data)
         elif node.nodeType == node.ELEMENT_NODE:
-            rc.append(get_text(node))
-    return ''.join(rc)
-
-def get_text_for_element(parent, tagname):
-    rc = []
-    nodes = parent.getElementsByTagName(tagname);
-    for node in nodes : rc.append(get_text(node))
-    return ''.join(rc)
-
-def get_file_location(node):
+            substrings.append(_get_text(node))
+    return ''.join(substrings)
+
+def _get_text_for_element(parent, tagname):
+    substrings = []
+
+    for node in parent.getElementsByTagName(tagname):
+        substrings.append(_get_text(node))
+
+    return ''.join(substrings)
+
+def _get_file_location(node):
     for node in node.childNodes:
         if node.nodeType == node.ELEMENT_NODE and node.tagName == 'location':
             return node.attributes['file'].value
-    if debug: print 'no location in:', node
+    if DEBUG:
+        print 'no location in:', node
     return None
-    
-def has_element(node, tagname):
+
+def _has_element(node, tagname):
     for node in node.childNodes:
         if node.nodeType == node.ELEMENT_NODE and node.tagName in tagname:
             return True
     return False
 
-def print_attribs(node, attribs):
-    for attrib in attribs : print ' ', attrib, '=', node.attributes[attrib].value
-
-def concat_text_from_tags(parent, tagnames):
-    rc = []
-    for tag in tagnames : rc.append(get_text_for_element(parent, tag))
-    return ''.join(rc)
-    
-def print_location(node):
-    print ' ', 'location', '=', get_file_location(node)
-
-def get_attribs(node):
+def _print_attribs(node, attribs):
+    for attrib in attribs:
+        print ' ', attrib, '=', node.attributes[attrib].value
+
+def _concat_text_from_tags(parent, tagnames):
+    substrings = []
+
+    for tag in tagnames:
+        substrings.append(_get_text_for_element(parent, tag))
+
+    return ''.join(substrings)
+
+def _print_location(node):
+    print ' ', 'location', '=', _get_file_location(node)
+
+def _get_attribs(node):
     kind = node.attributes['kind'].value
     static = node.attributes['static'].value
-    prot =  node.attributes['prot'].value
-    return (kind, static, prot)
-
-# Special cases for publishing anyway:
-publish_special_cases = {}
-
-component_map = {}
-symbols = {'public' : set(), 'private' : set()}
-
-def report(publish, symbol):
+    prot = node.attributes['prot'].value
+    return kind, static, prot
+
+COMPONENT_MAP = {}
+SYMBOLS = {'public' : set(), 'private' : set()}
+
+def _report(publish, symbol):
     symbol = symbol.replace('~', '?')
 
-    if symbol in publish_special_cases: publish = True
-
-    if publish: symbols['public'].add(symbol)
-    else:       symbols['private'].add(symbol)
-
-    if not debug: return
-    if publish: print '  PUBLISH: {}'.format(symbol)
-    else      : print 'NOPUBLISH: {}'.format(symbol)
-
-old_stanzas = '''MIRAL_0.1 {
+    if publish:
+        SYMBOLS['public'].add(symbol)
+    else:
+        SYMBOLS['private'].add(symbol)
+
+    if not DEBUG:
+        return
+
+    if publish:
+        print '  PUBLISH: {}'.format(symbol)
+    else:
+        print 'NOPUBLISH: {}'.format(symbol)
+
+OLD_STANZAS = '''MIRAL_0.1 {
 global:
     # We need to specify the overload of miral::WindowManagerTools::modify_window
     _ZN5miral18WindowManagerTools13modify_windowERNS_10WindowInfoERKNS_19WindowSpecificationE;
@@ -378,123 +386,161 @@
 global:
    # We need to specify the overload of miral::WindowManagerTools::modify_window
   _ZN5miral18WindowManagerTools13modify_windowERKNS_6WindowERKNS_19WindowSpecificationE;
+  extern "C++" {
+    miral::Keymap::?Keymap*;
+    miral::Keymap::Keymap*;
+    miral::Keymap::operator*;
+    miral::Keymap::set_keymap*;
+    miral::WindowSpecification::userdata*;
+    typeinfo?for?miral::Keymap;
+    vtable?for?miral::Keymap;
+  };
+} MIRAL_0.2;
+
+MIRAL_0.4 {
+global:
   extern "C++" {'''
 
-end_new_stanza = '''  };
-} MIRAL_0.2;'''
+END_NEW_STANZA = '''  };
+} MIRAL_0.3;'''
 
-def print_report():
-    print old_stanzas
-    for symbol in sorted(symbols['public']):
+def _print_report():
+    print OLD_STANZAS
+    for symbol in sorted(SYMBOLS['public']):
         formatted_symbol = '    {};'.format(symbol)
-        if not formatted_symbol in old_stanzas:
+        if formatted_symbol not in OLD_STANZAS:
             print formatted_symbol
-    print end_new_stanza
+    print END_NEW_STANZA
 
-def print_debug_info(node, attributes):
-    if not debug: return
+def _print_debug_info(node, attributes):
+    if not DEBUG:
+        return
     print
-    print_attribs(node, attributes)
-    print_location(node)
-
-def find_physical_component(location_file):
-    path_elements = location_file.split('/')
-    found = False
-    for element in path_elements:
-        if found: return element
-        found = element in ['include', 'src']
-    if debug: print 'no component in:', location_file
-    return None
-    
-def parse_member_def(context_name, node, is_class):
-    (kind, static, prot) = get_attribs(node)
-    
-    if kind in ['enum', 'typedef']: return
-    if has_element(node, ['templateparamlist']): return
-    if kind in ['function'] and node.attributes['inline'].value == 'yes': return
-    
-    name = concat_text_from_tags(node, ['name'])
+    _print_attribs(node, attributes)
+    _print_location(node)
+
+def _parse_member_def(context_name, node, is_class):
+    kind = node.attributes['kind'].value
+
+    if (kind in ['enum', 'typedef']
+        or _has_element(node, ['templateparamlist'])
+        or kind in ['function'] and node.attributes['inline'].value == 'yes'):
+        return
+
+    name = _concat_text_from_tags(node, ['name'])
+
     if name in ['__attribute__']:
-        if debug: print '  ignoring doxygen mis-parsing:', concat_text_from_tags(node, ['argsstring'])
+        if DEBUG:
+            print '  ignoring doxygen mis-parsing:', _concat_text_from_tags(node, ['argsstring'])
         return
 
-    if name.startswith('operator'): name = 'operator'
-    if not context_name == None: symbol = context_name + '::' + name
-    else: symbol = name
+    if name.startswith('operator'):
+        name = 'operator'
+
+    if not context_name is None:
+        symbol = context_name + '::' + name
+    else:
+        symbol = name
+
+    is_function = kind == 'function'
+
+    if is_function:
+        _print_debug_info(node, ['kind', 'prot', 'static', 'virt'])
+    else:
+        _print_debug_info(node, ['kind', 'prot', 'static'])
+
+    if DEBUG:
+        print '  is_class:', is_class
+
+    publish = _should_publish(is_class, is_function, node)
+
+    _report(publish, symbol + '*')
+
+    if is_function and node.attributes['virt'].value == 'virtual':
+        _report(publish, 'non-virtual?thunk?to?' + symbol + '*')
+
+
+def _should_publish(is_class, is_function, node):
+    (kind, static, prot) = _get_attribs(node)
 
     publish = True
 
-    is_function = kind == 'function'
-    if publish: publish = kind != 'define'
-    if publish and is_class: publish = is_function or static == 'yes'
+    if publish:
+        publish = kind != 'define'
+
+    if publish and is_class:
+        publish = is_function or static == 'yes'
+
     if publish and prot == 'private':
-        if is_function: publish = node.attributes['virt'].value == 'virtual'
-        else: publish =  False
-
-    if publish and has_element(node, ['argsstring']): 
-        publish = not get_text_for_element(node, 'argsstring').endswith('=0')
-    
-    if is_function: print_debug_info(node, ['kind', 'prot', 'static', 'virt'])
-    else: print_debug_info(node, ['kind', 'prot', 'static'])
-    if debug: print '  is_class:', is_class
-    report(publish, symbol + '*')
-    if is_function and node.attributes['virt'].value == 'virtual': report(publish,
-                                                                          'non-virtual?thunk?to?' + symbol + '*')
-
-def parse_compound_defs(xmldoc):
-    compounddefs = xmldoc.getElementsByTagName('compounddef') 
+        if is_function:
+            publish = node.attributes['virt'].value == 'virtual'
+        else:
+            publish = False
+
+    if publish and _has_element(node, ['argsstring']):
+        publish = not _get_text_for_element(node, 'argsstring').endswith('=0')
+
+    return publish
+
+
+def _parse_compound_defs(xmldoc):
+    compounddefs = xmldoc.getElementsByTagName('compounddef')
     for node in compounddefs:
         kind = node.attributes['kind'].value
 
-        if kind in ['page', 'file', 'example', 'union']: continue
-
-        if kind in ['group']: 
-            for member in node.getElementsByTagName('memberdef') : 
-                parse_member_def(None, member, False)
-            continue
-
-        if kind in ['namespace']: 
-            symbol = concat_text_from_tags(node, ['compoundname'])
-            for member in node.getElementsByTagName('memberdef') : 
-                parse_member_def(symbol, member, False)
-            continue
-        
-        file = get_file_location(node)
-        if debug: print '  from file:', file 
-        if '/examples/' in file or '/test/' in file or '[generated]' in file or '[STL]' in file:
-            continue
-
-        if has_element(node, ['templateparamlist']): continue
-
-        symbol = concat_text_from_tags(node, ['compoundname'])
-        
+        if kind in ['page', 'file', 'example', 'union']:
+            continue
+
+        if kind in ['group']:
+            for member in node.getElementsByTagName('memberdef'):
+                _parse_member_def(None, member, False)
+            continue
+
+        if kind in ['namespace']:
+            symbol = _concat_text_from_tags(node, ['compoundname'])
+            for member in node.getElementsByTagName('memberdef'):
+                _parse_member_def(symbol, member, False)
+            continue
+
+        filename = _get_file_location(node)
+
+        if DEBUG:
+            print '  from file:', filename
+
+        if ('/examples/' in filename or '/test/' in filename or '[generated]' in filename
+            or '[STL]' in filename or _has_element(node, ['templateparamlist'])):
+            continue
+
+        symbol = _concat_text_from_tags(node, ['compoundname'])
+
         publish = True
 
-        if publish: 
+        if publish:
             if kind in ['class', 'struct']:
-                prot =  node.attributes['prot'].value
+                prot = node.attributes['prot'].value
                 publish = prot != 'private'
-                print_debug_info(node, ['kind', 'prot'])
-                report(publish, 'vtable?for?' + symbol)
-                report(publish, 'typeinfo?for?' + symbol)
+                _print_debug_info(node, ['kind', 'prot'])
+                _report(publish, 'vtable?for?' + symbol)
+                _report(publish, 'typeinfo?for?' + symbol)
 
-        if publish: 
-            for member in node.getElementsByTagName('memberdef') : 
-                parse_member_def(symbol, member, kind in ['class', 'struct'])
+        if publish:
+            for member in node.getElementsByTagName('memberdef'):
+                _parse_member_def(symbol, member, kind in ['class', 'struct'])
 
 if __name__ == "__main__":
     if len(argv) == 1 or '-h' in argv or '--help' in argv:
-        print helptext
+        print HELPTEXT
         exit()
 
     for arg in argv[1:]:
         try:
-            if debug: print 'Processing:', arg
-            xmldoc = minidom.parse(arg)
-            parse_compound_defs(xmldoc)
+            if DEBUG:
+                print 'Processing:', arg
+            _parse_compound_defs(minidom.parse(arg))
         except Exception as error:
             print 'Error:', arg, error
 
-    if debug: print 'Processing complete'
+    if DEBUG:
+        print 'Processing complete'
 
-    print_report()
+    _print_report()
 
=== modified file 'tasks_for_the_interested_reader.md'
--- tasks_for_the_interested_reader.md	2016-09-21 16:36:56 +0000
+++ tasks_for_the_interested_reader.md	2016-11-04 16:34:03 +0000
@@ -37,9 +37,6 @@
  - Titlebars. GTK+ apps provide their own titlebars, better integration is
    needed.
    
- - Keyboard layouts. It should be possible to configure and use non-US keyboard
-   layouts.
-   
  - Better integration of startup animation. A short animation is played on
    startup. Ideally this should remain visible until a client is launched,
    fade out over the top of the client and resume when the last client exits.
@@ -72,9 +69,6 @@
     - ability to track connected input devices
     - ability to control cursor visibility
    
- - Cursor images. lp:qtmir stubs the cursor images and paints the cursor in its
-   compositor. Need to consider what ought to be supported here.
-   
  - Cut&Paste/Drag&Drop toolkits expect this functionality, but it isn't
    provided by Mir. We ought to find a way to provide this.