Merge lp:~unity-team/unity-system-compositor/new-gl-screen into lp:unity-system-compositor

[Michael Terry]

This branch adds a new option "--spinner=/path" which allows for an interstitial 'busy wait' program to be specified during boot and between greeter and user sessions.

This branch adds a new option "--spinner=/path" which allows for an interstitial 'busy wait' program to be specified during boot and between greeter and user sessions.

- I've added a default spinner (not used yet, it's still be workshopped with Design, but is functional in current form) in the spinner/ subdirectory
- This meant adding gettext support and a po/ subdirectory (with sample fr.po translation)
- I cleaned up CMake rules a bit to better handle building two different executables.
- And finally added logic to the main USC executable to support the option, launch the spinner, and use it appropriately when a requested session is not available.

Once this lands, in future, we can fix up the spinner to be what design wants. And then add a --spinner option to ubuntu-touch-session to point to the default one. (And eventually, when we want to use the spinner on the desktop too, we can just have USC use the default spinner as a fallback when --spinner isn't specified.)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:131
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ci/90/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-trusty-amd64-ci/42
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-trusty-armhf-ci/42

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-system-compositor-ci/90/rebuild

review: Approve (continuous-integration)

[Oliver Grawert (ogra)]

Is the design work coordinated with the spinner we have in the recovery img now (which is shown during upgrades) ?

[Oliver Grawert (ogra)]

hmm, seems the --spinner option is non-functional ... booting while connected via USB and excusting the following on a PC gets me a spinner though ...

adb wait-for-device && adb shell unity-system-compositor-spinner

so it seems there is something missing in usc to actually execute the spinner when the option is set

[Michael Terry (mterry)]

I talked with Oliver on IRC about this. He was passing --spinner instead of --spinner=/path. Once fixed, the branch worked for him. I corrected the description to make that explicit.

[Michael Terry (mterry)]

And as far as design goes, no. It's not coordinated with the recovery img animation yet. Design is getting back to me on what this loading screen should look like.

[Oliver Grawert (ogra)]

Ok with the proper option it works on all devices for me (tested on flo, mako and manta)

review: Approve

[Michael Terry (mterry)]

Heads up that I changed this branch slightly in response to some design feedback:
- Black background instead of aubergine
- No "Loading..." text

This simplifies the merge a bunch (no gettext support needed now). I figured it was OK to glom this onto an Accepted branch since it doesn't touch the interesting parts of this merge, just the visual design.

[Michał Sawicz (saviq)]

Hey folks.

Looks like we need to make the libandroid-properties-dev dependency arch-specific (only for i386, amd64, armhf) and fall back to the default when it's unavailable. Otherwise we're limited to those three arches while currently u-s-c builds on arm64 as well.

review: Needs Fixing

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:149
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ci/105/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-amd64-ci/1
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-armhf-ci/1

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-system-compositor-ci/105/rebuild

review: Approve (continuous-integration)

[Michał Sawicz (saviq)]

Confirmed with rsalveti, this (optional dependency on hybris) is the only way forward for now.

[lp:~unity-team/unity-system-compositor/new-gl-screen]

150. By Michael Terry on 2014-05-06

Make libandroid-properties optional and only build-dep on it on supported architectures

[Michael Terry (mterry)]

Saviq, I've updated this branch to not require libandroid-properties (but to make use of it on the supported architectures).

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:150
http://jenkins.qa.ubuntu.com/job/unity-system-compositor-ci/106/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-amd64-ci/2
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-system-compositor-utopic-armhf-ci/2

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-system-compositor-ci/106/rebuild

review: Approve (continuous-integration)

[Michał Sawicz (saviq)]

review: Abstain

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-11-20 10:46:10 +0000
+++ CMakeLists.txt	2014-05-06 20:06:39 +0000
@@ -14,7 +14,8 @@
 #
 # Authored by: Robert Ancell <[e-mail]>
 
-project(UnitySystemCompisitor)
+project(UnitySystemCompositor)
+set(PACKAGE "unity-system-compositor")
 set(USC_VERSION_MAJOR 0)
 set(USC_VERSION_MINOR 0)
 set(USC_VERSION_PATCH 2)
@@ -34,23 +35,20 @@
 set(CMAKE_AUTOMOC ON)
 
 # Use C++11 and warnings
+set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c11 -Wall")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -Wall")
 
-# Check for Mir server library
 find_package(PkgConfig)
+pkg_check_modules(ANDROIDPROPS libandroid-properties)
+pkg_check_modules(CAIRO REQUIRED cairo)
+pkg_check_modules(GLIB REQUIRED glib-2.0)
+pkg_check_modules(MIRCLIENT REQUIRED mirclient)
 pkg_check_modules(MIRSERVER REQUIRED mirserver)
-include_directories(${MIRSERVER_INCLUDE_DIRS})
-link_directories(${MIRSERVER_LIBRARY_DIRS})
 
+find_package(Boost 1.48.0 COMPONENTS chrono date_time filesystem system thread program_options regex REQUIRED)
+find_package(GLESv2 REQUIRED)
 find_package(Qt5Core)
 find_package(Qt5DBus)
 
-# Check for boost
-find_package(Boost 1.48.0 COMPONENTS chrono date_time filesystem system thread program_options regex REQUIRED)
-include_directories(${Boost_INCLUDE_DIRS})
-
-# Check for GL
-find_package(GLESv2 REQUIRED)
-include_directories (${GLESv2_INCLUDE_DIRS})
-
+add_subdirectory(spinner/)
 add_subdirectory(src/)
 
=== modified file 'debian/control'
--- debian/control	2014-04-15 20:47:54 +0000
+++ debian/control	2014-05-06 20:06:39 +0000
@@ -5,6 +5,7 @@
 Build-Depends: cmake,
                cmake-data,
                debhelper (>= 9),
+               libandroid-properties-dev [i386 amd64 armhf],
                libboost-chrono-dev,
                libboost-date-time-dev,
                libboost-filesystem-dev,
@@ -12,11 +13,14 @@
                libboost-regex-dev,
                libboost-system-dev,
                libboost-thread-dev,
+               libcairo2-dev,
+               libglib2.0-dev,
                libgles2-mesa-dev,
+               libmirclient-dev (>= 0.1.9),
                libmirserver-dev (>= 0.1.9),
                libprotobuf-dev,
                pkg-config,
-               python (>= 2.7),
+               python:any (>= 2.7),
                python-setuptools,
                qt5-default,
                qtbase5-dev,
 
=== modified file 'debian/unity-system-compositor.install'
--- debian/unity-system-compositor.install	2013-11-19 21:57:55 +0000
+++ debian/unity-system-compositor.install	2014-05-06 20:06:39 +0000
@@ -1,5 +1,7 @@
 debian/source_unity-system-compositor.py usr/share/apport/package-hooks
 debian/unity-system-compositor.sleep usr/sbin/
 etc/dbus-1/system.d/com.canonical.Unity.Screen.conf
+usr/bin/unity-system-compositor-spinner
 usr/sbin/unity-system-compositor
 usr/share/dbus-1/interfaces/com.canonical.Unity.Screen.xml
+usr/share/unity-system-compositor
 
=== added directory 'spinner'
=== added file 'spinner/CMakeLists.txt'
--- spinner/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ spinner/CMakeLists.txt	2014-05-06 20:06:39 +0000
@@ -0,0 +1,48 @@
+# -*- Mode: CMake; indent-tabs-mode: nil; tab-width: 2 -*-
+#
+# Copyright © 2014 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/>.
+
+include_directories(
+  ${CAIRO_INCLUDE_DIRS}
+  ${GLIB_INCLUDE_DIRS}
+  ${ANDROIDPROPS_INCLUDE_DIRS}
+  ${GLESv2_INCLUDE_DIRS}
+  ${MIRCLIENT_INCLUDE_DIRS}
+)
+add_definitions(
+  -DPACKAGE="${PACKAGE}"
+  -DLOCALEDIR="${CMAKE_INSTALL_FULL_LOCALEDIR}"
+  -DPKGDATADIR="${CMAKE_INSTALL_FULL_DATAROOTDIR}/${PACKAGE}"
+)
+
+if(ANDROIDPROPS_FOUND)
+add_definitions(-DHAVE_PROPS)
+endif()
+
+link_directories(${MIRCLIENT_LIBRARY_DIRS})
+
+add_executable(unity-system-compositor-spinner eglapp.c eglapp.h eglspinner.c)
+target_link_libraries(unity-system-compositor-spinner
+  EGL
+  ${CAIRO_LDFLAGS}
+  ${GLIB_LDFLAGS}
+  ${ANDROIDPROPS_LDFLAGS}
+  ${GLESv2_LIBRARIES}
+  ${MIRCLIENT_LDFLAGS}
+)
+install(TARGETS unity-system-compositor-spinner RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR})
+
+install(FILES spinner-logo.png DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PACKAGE})
+install(FILES spinner-glow.png DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/${PACKAGE})
 
=== added file 'spinner/eglapp.c'
--- spinner/eglapp.c	1970-01-01 00:00:00 +0000
+++ spinner/eglapp.c	2014-05-06 20:06:39 +0000
@@ -0,0 +1,372 @@
+/*
+ * Copyright © 2013 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/>.
+ *
+ * Author: Daniel van Vugt <[e-mail]>
+ */
+
+#include "eglapp.h"
+#include "mir_toolkit/mir_client_library.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <time.h>
+#include <EGL/egl.h>
+#include <GLES2/gl2.h>
+
+float mir_eglapp_background_opacity = 1.0f;
+
+static const char appname[] = "eglspinner";
+
+static MirConnection *connection;
+static MirSurface *surface;
+static EGLDisplay egldisplay;
+static EGLSurface eglsurface;
+static volatile sig_atomic_t running = 0;
+
+#define CHECK(_cond, _err) \
+    if (!(_cond)) \
+    { \
+        printf("%s\n", (_err)); \
+        return 0; \
+    }
+
+void mir_eglapp_shutdown(void)
+{
+    eglMakeCurrent(egldisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+    eglTerminate(egldisplay);
+    mir_surface_release_sync(surface);
+    surface = NULL;
+    mir_connection_release(connection);
+    connection = NULL;
+}
+
+static void shutdown(int signum)
+{
+    if (running)
+    {
+        running = 0;
+        printf("Signal %d received. Good night.\n", signum);
+    }
+}
+
+mir_eglapp_bool mir_eglapp_running(void)
+{
+    return running;
+}
+
+void mir_eglapp_swap_buffers(void)
+{
+    EGLint width, height;
+
+    if (!running)
+        return;
+
+    eglSwapBuffers(egldisplay, eglsurface);
+
+    /*
+     * Querying the surface (actually the current buffer) dimensions here is
+     * the only truly safe way to be sure that the dimensions we think we
+     * have are those of the buffer being rendered to. But this should be
+     * improved in future; https://bugs.launchpad.net/mir/+bug/1194384
+     */
+    if (eglQuerySurface(egldisplay, eglsurface, EGL_WIDTH, &width) &&
+        eglQuerySurface(egldisplay, eglsurface, EGL_HEIGHT, &height))
+    {
+        glViewport(0, 0, width, height);
+    }
+}
+
+static void mir_eglapp_handle_event(MirSurface* surface, MirEvent const* ev, void* context)
+{
+    (void) surface;
+    (void) context;
+    if (ev->type == mir_event_type_resize)
+    {
+        /*
+         * FIXME: https://bugs.launchpad.net/mir/+bug/1194384
+         * It is unsafe to set the width and height here because we're in a
+         * different thread to that doing the rendering. So we either need
+         * support for event queuing (directing them to another thread) or
+         * full single-threaded callbacks. (LP: #1194384).
+         */
+        printf("Resized to %dx%d\n", ev->resize.width, ev->resize.height);
+    }
+}
+
+static const MirDisplayOutput *find_active_output(
+    const MirDisplayConfiguration *conf)
+{
+    const MirDisplayOutput *output = NULL;
+    int d;
+
+    for (d = 0; d < (int)conf->num_outputs; d++)
+    {
+        const MirDisplayOutput *out = conf->outputs + d;
+
+        if (out->used &&
+            out->connected &&
+            out->num_modes &&
+            out->current_mode < out->num_modes)
+        {
+            output = out;
+            break;
+        }
+    }
+
+    return output;
+}
+
+mir_eglapp_bool mir_eglapp_init(int argc, char *argv[],
+                                unsigned int *width, unsigned int *height)
+{
+    EGLint ctxattribs[] =
+    {
+        EGL_CONTEXT_CLIENT_VERSION, 2,
+        EGL_NONE
+    };
+    MirSurfaceParameters surfaceparm =
+    {
+        "eglappsurface",
+        256, 256,
+        mir_pixel_format_xbgr_8888,
+        mir_buffer_usage_hardware,
+        mir_display_output_id_invalid
+    };
+    MirEventDelegate delegate = 
+    {
+        mir_eglapp_handle_event,
+        NULL
+    };
+    EGLConfig eglconfig;
+    EGLint neglconfigs;
+    EGLContext eglctx;
+    EGLBoolean ok;
+    EGLint swapinterval = 1;
+    char *mir_socket = NULL;
+
+    if (argc > 1)
+    {
+        int i;
+        for (i = 1; i < argc; i++)
+        {
+            mir_eglapp_bool help = 0;
+            const char *arg = argv[i];
+
+            if (arg[0] == '-')
+            {
+                switch (arg[1])
+                {
+                case 'b':
+                    {
+                        float alpha = 1.0f;
+                        arg += 2;
+                        if (!arg[0] && i < argc-1)
+                        {
+                            i++;
+                            arg = argv[i];
+                        }
+                        if (sscanf(arg, "%f", &alpha) == 1)
+                        {
+                            mir_eglapp_background_opacity = alpha;
+                        }
+                        else
+                        {
+                            printf("Invalid opacity value: %s\n", arg);
+                            help = 1;
+                        }
+                    }
+                    break;
+                case 'n':
+                    swapinterval = 0;
+                    break;
+                case 'o':
+                    {
+                        unsigned int output_id = 0;
+                        arg += 2;
+                        if (!arg[0] && i < argc-1)
+                        {
+                            i++;
+                            arg = argv[i];
+                        }
+                        if (sscanf(arg, "%u", &output_id) == 1)
+                        {
+                            surfaceparm.output_id = output_id;
+                        }
+                        else
+                        {
+                            printf("Invalid output ID: %s\n", arg);
+                            help = 1;
+                        }
+                    }
+                    break;
+                case 'f':
+                    *width = 0;
+                    *height = 0;
+                    break;
+                case 's':
+                    {
+                        unsigned int w, h;
+                        arg += 2;
+                        if (!arg[0] && i < argc-1)
+                        {
+                            i++;
+                            arg = argv[i];
+                        }
+                        if (sscanf(arg, "%ux%u", &w, &h) == 2)
+                        {
+                            *width = w;
+                            *height = h;
+                        }
+                        else
+                        {
+                            printf("Invalid size: %s\n", arg);
+                            help = 1;
+                        }
+                    }
+                    break;
+                case 'm':
+                    mir_socket = argv[++i];
+                    break;
+                case 'q':
+                    {
+                        FILE *unused = freopen("/dev/null", "a", stdout);
+                        (void)unused;
+                        break;
+                    }
+                case 'h':
+                default:
+                    help = 1;
+                    break;
+                }
+            }
+            else
+            {
+                help = 1;
+            }
+
+            if (help)
+            {
+                printf("Usage: %s [<options>]\n"
+                       "  -b               Background opacity (0.0 - 1.0)\n"
+                       "  -h               Show this help text\n"
+                       "  -f               Force full screen\n"
+                       "  -o ID            Force placement on output monitor ID\n"
+                       "  -n               Don't sync to vblank\n"
+                       "  -m socket        Mir server socket\n"
+                       "  -s WIDTHxHEIGHT  Force surface size\n"
+                       "  -q               Quiet mode (no messages output)\n"
+                       , argv[0]);
+                return 0;
+            }
+        }
+    }
+
+    connection = mir_connect_sync(mir_socket, appname);
+    CHECK(mir_connection_is_valid(connection), "Can't get connection");
+
+    /* eglapps are interested in the screen size, so
+       use mir_connection_create_display_config */
+    MirDisplayConfiguration* display_config =
+        mir_connection_create_display_config(connection);
+
+    const MirDisplayOutput *output = find_active_output(display_config);
+
+    if (output == NULL)
+    {
+        printf("No active outputs found.\n");
+        return 0;
+    }
+
+    const MirDisplayMode *mode = &output->modes[output->current_mode];
+
+    unsigned int format[mir_pixel_formats];
+    unsigned int nformats;
+
+    mir_connection_get_available_surface_formats(connection,
+        (MirPixelFormat*) format, mir_pixel_formats, &nformats);
+
+    surfaceparm.pixel_format = (MirPixelFormat) format[0];
+
+    printf("Current active output is %dx%d %+d%+d\n",
+           mode->horizontal_resolution, mode->vertical_resolution,
+           output->position_x, output->position_y);
+
+    surfaceparm.width = *width > 0 ? *width : mode->horizontal_resolution;
+    surfaceparm.height = *height > 0 ? *height : mode->vertical_resolution;
+
+    mir_display_config_destroy(display_config);
+
+    printf("Server supports %d of %d surface pixel formats. Using format: %d\n",
+        nformats, mir_pixel_formats, surfaceparm.pixel_format);
+    unsigned int bpp = 8 * MIR_BYTES_PER_PIXEL(surfaceparm.pixel_format);
+    EGLint attribs[] =
+    {
+        EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
+        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
+        EGL_COLOR_BUFFER_TYPE, EGL_RGB_BUFFER,
+        EGL_BUFFER_SIZE, (EGLint) bpp,
+        EGL_NONE
+    };
+
+    surface = mir_connection_create_surface_sync(connection, &surfaceparm);
+    CHECK(mir_surface_is_valid(surface), "Can't create a surface");
+
+    mir_surface_set_event_handler(surface, &delegate);
+
+    egldisplay = eglGetDisplay(
+                    (EGLNativeDisplayType) mir_connection_get_egl_native_display(connection));
+    CHECK(egldisplay != EGL_NO_DISPLAY, "Can't eglGetDisplay");
+
+    ok = eglInitialize(egldisplay, NULL, NULL);
+    CHECK(ok, "Can't eglInitialize");
+
+    ok = eglChooseConfig(egldisplay, attribs, &eglconfig, 1, &neglconfigs);
+    CHECK(ok, "Could not eglChooseConfig");
+    CHECK(neglconfigs > 0, "No EGL config available");
+
+    eglsurface = eglCreateWindowSurface(egldisplay, eglconfig,
+            (EGLNativeWindowType)mir_surface_get_egl_native_window(surface),
+            NULL);
+    CHECK(eglsurface != EGL_NO_SURFACE, "eglCreateWindowSurface failed");
+
+    eglctx = eglCreateContext(egldisplay, eglconfig, EGL_NO_CONTEXT,
+                              ctxattribs);
+    CHECK(eglctx != EGL_NO_CONTEXT, "eglCreateContext failed");
+
+    ok = eglMakeCurrent(egldisplay, eglsurface, eglsurface, eglctx);
+    CHECK(ok, "Can't eglMakeCurrent");
+
+    signal(SIGINT, shutdown);
+    signal(SIGTERM, shutdown);
+
+    *width = surfaceparm.width;
+    *height = surfaceparm.height;
+
+    eglSwapInterval(egldisplay, swapinterval);
+
+    running = 1;
+
+    return 1;
+}
+
+struct MirConnection* mir_eglapp_native_connection()
+{
+    return connection;
+}
+
+struct MirSurface* mir_eglapp_native_surface()
+{
+    return surface;
+}
 
=== added file 'spinner/eglapp.h'
--- spinner/eglapp.h	1970-01-01 00:00:00 +0000
+++ spinner/eglapp.h	2014-05-06 20:06:39 +0000
@@ -0,0 +1,44 @@
+/*
+ * Copyright © 2013 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/>.
+ *
+ * Author: Daniel van Vugt <[e-mail]>
+ */
+
+#ifndef __EGLAPP_H__
+#define __EGLAPP_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef int mir_eglapp_bool;
+struct MirConnection;
+struct MirSurface;
+
+extern float mir_eglapp_background_opacity;
+
+mir_eglapp_bool mir_eglapp_init(int argc, char *argv[],
+                                unsigned int *width, unsigned int *height);
+void            mir_eglapp_swap_buffers(void);
+mir_eglapp_bool mir_eglapp_running(void);
+void            mir_eglapp_shutdown(void);
+
+struct MirConnection* mir_eglapp_native_connection();
+struct MirSurface*    mir_eglapp_native_surface();
+#ifdef __cplusplus
+}
+#endif
+
+#endif
 
=== added file 'spinner/eglspinner.c'
--- spinner/eglspinner.c	1970-01-01 00:00:00 +0000
+++ spinner/eglspinner.c	2014-05-06 20:06:39 +0000
@@ -0,0 +1,415 @@
+/*
+ * Copyright © 2013 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/>.
+ *
+ * Authors: Daniel van Vugt <[e-mail]>
+ *          Mirco Müller <[e-mail]>
+ */
+
+#include "eglapp.h"
+#include <assert.h>
+#include <cairo.h>
+#include <glib.h>
+#include <stdio.h>
+#include <string.h>
+#include <strings.h>
+#include <stdlib.h>
+#include <GLES2/gl2.h>
+#include <math.h>
+#if HAVE_PROPS
+#include <hybris/properties/properties.h>
+#endif
+
+// this is needed for get_gu() to obtain the grid-unit value
+#define MAX_LENGTH       256
+#define VALUE_KEY        "GRID_UNIT_PX"
+#define VALUE_KEY_LENGTH 12
+#define PROP_KEY         "ro.product.device"
+#define FILE_BASE        "/etc/ubuntu-touch-session.d/"
+#define FILE_EXTENSION   ".conf"
+
+int get_gu ()
+{
+    int   gu           = 10; // use 10 as a default value
+    FILE* handle       = NULL;
+    int   i            = 0;
+    int   j            = 0;
+    int   len          = 0;
+    char  line[MAX_LENGTH];
+    char  filename[MAX_LENGTH];
+
+    // get name of file to read from
+    bzero ((void*) filename, MAX_LENGTH);
+    strcpy (filename, FILE_BASE);
+#ifdef HAVE_PROPS
+    char* defaultValue = "";
+    char  value[PROP_VALUE_MAX];
+    property_get (PROP_KEY, value, defaultValue);
+    strcat (filename, value);
+#endif
+    strcat (filename, FILE_EXTENSION);
+
+    // try to open it
+    handle = fopen ((const char*) filename, "r");
+    if (!handle)
+        return gu;
+
+    // read one line at a time
+    while (fgets (line, MAX_LENGTH, handle))
+    {
+        // strip line of whitespaces
+        i = 0;
+        j = 0;
+        len = (int) strlen (line);
+        while (i != len)
+        {
+            if (line[i] != ' ' && line[i] != '\t')
+                line[j++] = line[i];
+            i++;
+        }
+        line[j] = 0;
+
+        // parse the line for GU-value
+        if (!strncmp (line, VALUE_KEY, VALUE_KEY_LENGTH))
+            sscanf (line, VALUE_KEY"=%d", &gu);
+    }
+
+    // clean up
+    fclose (handle);
+
+    return gu;
+}
+
+static GLuint load_shader(const char *src, GLenum type)
+{
+    GLuint shader = glCreateShader(type);
+    if (shader)
+    {
+        GLint compiled;
+        glShaderSource(shader, 1, &src, NULL);
+        glCompileShader(shader);
+        glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
+        if (!compiled)
+        {
+            GLchar log[1024];
+            glGetShaderInfoLog(shader, sizeof log - 1, NULL, log);
+            log[sizeof log - 1] = '\0';
+            printf("load_shader compile failed: %s\n", log);
+            glDeleteShader(shader);
+            shader = 0;
+        }
+    }
+    return shader;
+}
+
+// Colours from http://design.ubuntu.com/brand/colour-palette
+#define MID_AUBERGINE   0.368627451f, 0.152941176f, 0.31372549f
+#define ORANGE          0.866666667f, 0.282352941f, 0.141414141f
+#define WARM_GREY       0.682352941f, 0.654901961f, 0.623529412f
+#define COOL_GREY       0.2f,         0.2f,         0.2f
+#define LIGHT_AUBERGINE 0.466666667f, 0.297297297f, 0.435294118f
+#define DARK_AUBERGINE  0.17254902f,  0.0f,         0.117647059f
+#define BLACK           0.0f,         0.0f,         0.0f
+#define WHITE           1.0f,         1.0f,         1.0f
+
+cairo_surface_t* pngToSurface (const char* filename)
+{
+    // sanity check
+    if (!filename)
+        return NULL;
+
+    // create surface from PNG
+    cairo_surface_t* surface = NULL;
+    surface = cairo_image_surface_create_from_png (filename);
+    if (cairo_surface_status (surface) != CAIRO_STATUS_SUCCESS)
+        return NULL;
+
+    return surface;
+}
+
+void uploadTexture (GLuint id, const char* filename)
+{
+    if (!id || !filename)
+        return;
+
+    cairo_surface_t* surface = pngToSurface (filename);
+
+    glBindTexture(GL_TEXTURE_2D, id);
+
+    if (cairo_surface_status (surface) == CAIRO_STATUS_SUCCESS)
+    {
+        glTexImage2D(GL_TEXTURE_2D,
+                     0,
+                     cairo_image_surface_get_format (surface) == CAIRO_FORMAT_ARGB32 ? GL_RGBA : GL_RGB,
+                     cairo_image_surface_get_width (surface),
+                     cairo_image_surface_get_height (surface),
+                     0,
+                     cairo_image_surface_get_format (surface) == CAIRO_FORMAT_ARGB32 ? GL_RGBA : GL_RGB,
+                     GL_UNSIGNED_BYTE,
+                     cairo_image_surface_get_data (surface));
+        cairo_surface_destroy (surface);
+    }
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+    glBindTexture(GL_TEXTURE_2D, 0);
+}
+
+GLuint createShaderProgram(const char* vertexShaderSrc, const char* fragmentShaderSrc)
+{
+    if (!vertexShaderSrc || !fragmentShaderSrc)
+        return 0;
+
+    GLuint vShaderId = 0;
+    vShaderId = load_shader(vertexShaderSrc, GL_VERTEX_SHADER);
+    assert(vShaderId);
+
+    GLuint fShaderId = 0;
+    fShaderId = load_shader(fragmentShaderSrc, GL_FRAGMENT_SHADER);
+    assert(fShaderId);
+
+    GLuint progId = 0;
+    progId = glCreateProgram();
+    assert(progId);
+    glAttachShader(progId, vShaderId);
+    glAttachShader(progId, fShaderId);
+    glLinkProgram(progId);
+
+    GLint linked = 0;
+    glGetProgramiv(progId, GL_LINK_STATUS, &linked);
+    if (!linked)
+    {
+        GLchar log[1024];
+        glGetProgramInfoLog(progId, sizeof log - 1, NULL, log);
+        log[sizeof log - 1] = '\0';
+        printf("Link failed: %s\n", log);
+        return 0;
+    }
+
+    return progId;
+}
+
+typedef struct _AnimationValues
+{
+    double lastTimeStamp;
+    double angle;
+    double fadeBackground;
+    double fadeLogo;
+    double fadeGlow;
+} AnimationValues;
+
+void
+updateAnimation (GTimer* timer, AnimationValues* anim)
+{
+    if (!timer || !anim)
+        return;
+
+    //1.) 0.0   - 0.6:   logo fades in fully
+    //2.) 0.0   - 6.0:   logo does one full spin 360°
+    //3.) 6.0   - 6.833: glow fades in fully, black-background fades out to 50%
+    //4.) 6.833 - 7.666: glow fades out fully, black-background fades out to 0% 
+    //5.) 7.666 - 8.266: logo fades out fully
+    //8.266..:       now spinner can be closed as all its elements are faded out
+
+    double elapsed = g_timer_elapsed (timer, NULL);
+    double dt = elapsed - anim->lastTimeStamp;
+    anim->lastTimeStamp = elapsed;
+
+    // step 1.)
+    if (elapsed < 0.6f)
+        anim->fadeLogo += 1.6f * dt;
+
+    // step 2.)
+    anim->angle -= (0.017453292519943f * 360.0f / 6.0f) * dt;
+
+    // step 3.) glow
+    if (elapsed > 6.0f && elapsed < 6.833f)
+        anim->fadeGlow += 1.2f * dt;
+
+    // Ignore the following three until we can synchronize with greeter
+
+    // step 3.) background
+    //if (elapsed > 6.0f && elapsed < 6.833f)
+    //    anim->fadeBackground -= 0.6f * dt;
+
+    // step 4.) background
+    //if (elapsed > 7.0f)
+    //    anim->fadeBackground -= 0.6f * dt;
+
+    // step 5.)
+    //if (elapsed > 6.833f)
+    //    anim->fadeLogo -= 1.6f * dt;
+}
+
+int main(int argc, char *argv[])
+{
+    const char vShaderSrcSpinner[] =
+        "attribute vec4 vPosition;                       \n"
+        "attribute vec2 aTexCoords;                      \n"
+        "uniform float theta;                            \n"
+        "varying vec2 vTexCoords;                        \n"
+        "void main()                                     \n"
+        "{                                               \n"
+        "    float c = cos(theta);                       \n"
+        "    float s = sin(theta);                       \n"
+        "    mat2 m;                                     \n"
+        "    m[0] = vec2(c, s);                          \n"
+        "    m[1] = vec2(-s, c);                         \n"
+        "    vTexCoords = m * aTexCoords + vec2 (0.5, 0.5); \n"
+        "    gl_Position = vec4(vPosition.xy, -1.0, 1.0); \n"
+        "}                                               \n";
+
+    const char fShaderSrcGlow[] =
+        "precision mediump float;                             \n"
+        "varying vec2 vTexCoords;                             \n"
+        "uniform sampler2D uSampler;                          \n"
+        "uniform float uFadeGlow;                             \n"
+        "void main()                                          \n"
+        "{                                                    \n"
+        "    // swizzle because texture was created with cairo\n"
+        "    vec4 col = texture2D(uSampler, vTexCoords).bgra; \n"
+        "    float r = col.r * uFadeGlow;                     \n"
+        "    float g = col.g * uFadeGlow;                     \n"
+        "    float b = col.b * uFadeGlow;                     \n"
+        "    float a = col.a * uFadeGlow;                     \n"
+        "    gl_FragColor = vec4(r, g, b, a);                 \n"
+        "}                                                    \n";
+
+    const char fShaderSrcLogo[] =
+        "precision mediump float;                             \n"
+        "varying vec2 vTexCoords;                             \n"
+        "uniform sampler2D uSampler;                          \n"
+        "uniform float uFadeLogo;                             \n"
+        "void main()                                          \n"
+        "{                                                    \n"
+        "    // swizzle because texture was created with cairo\n"
+        "    vec4 col = texture2D(uSampler, vTexCoords).bgra; \n"
+        "    float r = col.r * uFadeLogo;                     \n"
+        "    float g = col.g * uFadeLogo;                     \n"
+        "    float b = col.b * uFadeLogo;                     \n"
+        "    float a = col.a * uFadeLogo;                     \n"
+        "    gl_FragColor = vec4(r, g, b, a);                 \n"
+        "}                                                    \n";
+
+    GLuint prog[2];
+    GLuint texture[2];
+    GLint vpos[2];
+    GLint theta;
+    GLint fadeGlow;
+    GLint fadeLogo;
+    GLint aTexCoords[2];
+    GLint sampler[2];
+    unsigned int width = 0;
+    unsigned int height = 0;
+
+    if (!mir_eglapp_init(argc, argv, &width, &height))
+        return 1;
+
+    double pixelSize = (double) get_gu () * 11.18;
+    double halfRealWidth = ((2.0 / (double) width) * pixelSize) / 2.0;
+    double halfRealHeight = ((2.0 / (double) height) * pixelSize) / 2.0;
+
+    const GLfloat vertices[] =
+    {
+         halfRealWidth,  halfRealHeight,
+         halfRealWidth, -halfRealHeight,
+        -halfRealWidth,  halfRealHeight,
+        -halfRealWidth, -halfRealHeight,
+    };
+
+    const GLfloat texCoordsSpinner[] =
+    {
+        -0.5f, 0.5f,
+        -0.5f, -0.5f,
+        0.5f, 0.5f,
+        0.5f, -0.5f,
+    };
+
+    prog[0] = createShaderProgram (vShaderSrcSpinner, fShaderSrcGlow);
+    prog[1] = createShaderProgram (vShaderSrcSpinner, fShaderSrcLogo);
+
+    // setup viewport and projection
+    glClearColor(BLACK, mir_eglapp_background_opacity);
+    glViewport(0, 0, width, height);
+
+    // setup proper GL-blending
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+    glBlendEquation(GL_FUNC_ADD);
+
+    // get locations of shader-attributes/uniforms
+    vpos[0] = glGetAttribLocation(prog[0], "vPosition");
+    aTexCoords[0] = glGetAttribLocation(prog[0], "aTexCoords");
+    theta = glGetUniformLocation(prog[0], "theta");
+    sampler[0] = glGetUniformLocation(prog[0], "uSampler");
+    fadeGlow = glGetUniformLocation(prog[0], "uFadeGlow");
+    vpos[1] = glGetAttribLocation(prog[1], "vPosition");
+    aTexCoords[1] = glGetAttribLocation(prog[1], "aTexCoords");
+    sampler[1] = glGetUniformLocation(prog[1], "uSampler");
+    fadeLogo = glGetUniformLocation(prog[1], "uFadeLogo");
+
+    // create and upload spinner-artwork
+    glGenTextures(2, texture);
+    uploadTexture(texture[0], PKGDATADIR "/spinner-glow.png");
+    uploadTexture(texture[1], PKGDATADIR "/spinner-logo.png");
+
+    // bunch of shader-attributes to enable
+    glVertexAttribPointer(vpos[0], 2, GL_FLOAT, GL_FALSE, 0, vertices);
+    glVertexAttribPointer(vpos[1], 2, GL_FLOAT, GL_FALSE, 0, vertices);
+    glVertexAttribPointer(aTexCoords[0], 2, GL_FLOAT, GL_FALSE, 0, texCoordsSpinner);
+    glVertexAttribPointer(aTexCoords[1], 2, GL_FLOAT, GL_FALSE, 0, texCoordsSpinner);
+    glEnableVertexAttribArray(vpos[0]);
+    glEnableVertexAttribArray(vpos[1]);
+    glEnableVertexAttribArray(aTexCoords[0]);
+    glEnableVertexAttribArray(aTexCoords[1]);
+    glActiveTexture(GL_TEXTURE0);
+
+    AnimationValues anim = {0.0, 0.0, 1.0, 0.0, 0.0};
+    GTimer* timer = g_timer_new ();
+
+    while (mir_eglapp_running())
+    {
+        glClearColor(BLACK, anim.fadeBackground);
+        glClear(GL_COLOR_BUFFER_BIT);
+
+        // draw glow
+        glUseProgram(prog[0]);
+        glBindTexture(GL_TEXTURE_2D, texture[0]);
+        glUniform1i(sampler[0], 0);
+        glUniform1f(theta, anim.angle);
+        glUniform1f(fadeGlow, anim.fadeGlow);
+        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+
+        // draw logo
+        glUseProgram(prog[1]);
+        glBindTexture(GL_TEXTURE_2D, texture[1]);
+        glUniform1i(sampler[1], 0);
+        glUniform1f(theta, anim.angle);
+        glUniform1f(fadeLogo, anim.fadeLogo);
+        glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
+
+        // update animation variable
+        updateAnimation (timer, &anim);
+
+        mir_eglapp_swap_buffers();
+    }
+
+    mir_eglapp_shutdown();
+
+    glDeleteTextures(2, texture);
+    g_timer_destroy (timer);
+
+    return 0;
+}
 
=== added file 'spinner/spinner-glow.png'
 Binary files spinner/spinner-glow.png	1970-01-01 00:00:00 +0000 and spinner/spinner-glow.png	2014-05-06 20:06:39 +0000 differ
=== added file 'spinner/spinner-logo.png'
 Binary files spinner/spinner-logo.png	1970-01-01 00:00:00 +0000 and spinner/spinner-logo.png	2014-05-06 20:06:39 +0000 differ
=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2013-10-31 19:16:23 +0000
+++ src/CMakeLists.txt	2014-05-06 20:06:39 +0000
@@ -39,9 +39,16 @@
 include_directories(
   ${CMAKE_CURRENT_SOURCE_DIR}
   ${CMAKE_CURRENT_BINARY_DIR}
+  ${Boost_INCLUDE_DIRS}
+  ${GLESv2_INCLUDE_DIRS}
+  ${MIRSERVER_INCLUDE_DIRS}
+)
+add_definitions(
+  -DDEFAULT_SPINNER="${CMAKE_INSTALL_FULL_BINDIR}/unity-system-compositor-spinner"
 )
 
 # Link against libmirserver
+link_directories(${MIRSERVER_LIBRARY_DIRS})
 target_link_libraries(unity-system-compositor
   mirserver
   pthread
 
=== modified file 'src/system_compositor.cpp'
--- src/system_compositor.cpp	2014-04-15 20:47:54 +0000
+++ src/system_compositor.cpp	2014-05-06 20:06:39 +0000
@@ -48,9 +48,10 @@
 class SystemCompositorShell : public mf::Shell
 {
 public:
-    SystemCompositorShell(std::shared_ptr<mf::Shell> const& self,
+    SystemCompositorShell(SystemCompositor *compositor,
+                          std::shared_ptr<mf::Shell> const& self,
                           std::shared_ptr<msh::FocusController> const& focus_controller)
-        : self(self), focus_controller{focus_controller} {}
+        : compositor{compositor}, self(self), focus_controller{focus_controller} {}
 
     std::shared_ptr<mf::Session> session_named(std::string const& name)
     {
@@ -60,42 +61,72 @@
     void set_active_session(std::string const& name)
     {
         active_session = name;
-
-        if (auto session = std::static_pointer_cast<msc::Session>(session_named(name)))
-            focus_controller->set_focus_to(session);
-        else
-            std::cerr << "Unable to set active session, unknown client name " << name << std::endl;
+        update_session_focus();
     }
 
     void set_next_session(std::string const& name)
     {
-        if (auto const session = std::static_pointer_cast<msc::Session>(session_named(name)))
-        {
-            focus_controller->set_focus_to(session); // raise session inside its depth id set
-            set_active_session(active_session); // to restore input focus to where it should be
-        }
-        else
-            std::cerr << "Unable to set next session, unknown client name " << name << std::endl;
+        next_session = name;
+        update_session_focus();
     }
 
 private:
+    void update_session_focus()
+    {
+        auto spinner = std::static_pointer_cast<msc::Session>(session_named(spinner_session));
+        auto next = std::static_pointer_cast<msc::Session>(session_named(next_session));
+        auto active = std::static_pointer_cast<msc::Session>(session_named(active_session));
+
+        if (spinner)
+            spinner->hide();
+
+        if (next)
+        {
+            std::cerr << "Setting next focus to session " << next_session;
+            focus_controller->set_focus_to(next);
+        }
+        else if (spinner)
+        {
+            std::cerr << "Setting next focus to spinner";
+            spinner->show();
+            focus_controller->set_focus_to(spinner);
+        }
+
+        if (active)
+        {
+            std::cerr << "; active focus to session " << active_session << std::endl;
+            focus_controller->set_focus_to(active);
+        }
+        else if (spinner)
+        {
+            std::cerr << "; active focus to spinner" << std::endl;
+            spinner->show();
+            focus_controller->set_focus_to(spinner);
+        }
+    }
+
     std::shared_ptr<mf::Session> open_session(
         pid_t client_pid,
         std::string const& name,
         std::shared_ptr<mf::EventSink> const& sink)
     {
+        std::cerr << "Opening session " << name << std::endl;
         auto result = self->open_session(client_pid, name, sink);
         sessions[name] = result;
 
-        // Opening a new session will steal focus from our active session, so
-        // restore the focus if needed.
-        set_active_session(active_session);
+        if (client_pid == compositor->get_spinner_pid())
+            spinner_session = name;
 
         return result;
     }
 
     void close_session(std::shared_ptr<mf::Session> const& session)
     {
+        std::cerr << "Closing session " << session->name() << std::endl;
+
+        if (session->name() == spinner_session)
+            spinner_session = "";
+
         sessions.erase(session->name());
         self->close_session(session);
     }
@@ -110,12 +141,19 @@
     void handle_surface_created(std::shared_ptr<mf::Session> const& session)
     {
         self->handle_surface_created(session);
+
+        // Opening a new surface will steal focus from our active surface, so
+        // restore the focus if needed.
+        update_session_focus();
     }
 
+    SystemCompositor *compositor;
     std::shared_ptr<mf::Shell> const self;
     std::shared_ptr<msh::FocusController> const focus_controller;
     std::map<std::string, std::shared_ptr<mf::Session>> sessions;
     std::string active_session;
+    std::string next_session;
+    std::string spinner_session;
 };
 
 class SystemCompositorServerConfiguration : public mir::DefaultServerConfiguration
@@ -158,6 +196,15 @@
         return x;
     }
 
+    std::string spinner()
+    {
+        // TODO: once our default spinner is ready for use everywhere, replace
+        // default value with DEFAULT_SPINNER instead of the empty string.
+        auto x = the_options()->get("spinner", "");
+        boost::trim(x);
+        return x;
+    }
+
     bool public_socket()
     {
         return !the_options()->is_set("no-file") && the_options()->get("public-socket", true);
@@ -217,6 +264,7 @@
         return sc_shell([this]
         {
             return std::make_shared<SystemCompositorShell>(
+                compositor,
                 mir::DefaultServerConfiguration::the_frontend_shell(),
                 the_focus_controller());
         });
@@ -244,6 +292,7 @@
             ("to-dm-fd", po::value<int>(),  "File descriptor of write end of pipe to display manager [int]")
             ("blacklist", po::value<std::string>(), "Video blacklist regex to use")
             ("version", "Show version of Unity System Compositor")
+            ("spinner", po::value<std::string>(), "Path to spinner executable")
             ("public-socket", po::value<bool>(), "Make the socket file publicly writable")
             ("power-off-delay", po::value<int>(), "Delay in milliseconds before powering off screen [int]")
             ("enable-hardware-cursor", po::value<bool>(), "Enable the hardware cursor (disabled by default)");
@@ -354,6 +403,11 @@
         active_session->set_lifecycle_state(mir_lifecycle_state_resumed);
 }
 
+pid_t SystemCompositor::get_spinner_pid() const
+{
+    return spinner_process.pid();
+}
+
 void SystemCompositor::set_active_session(std::string client_name)
 {
     std::cerr << "set_active_session" << std::endl;
@@ -381,9 +435,22 @@
     io_service.run();
 }
 
+void SystemCompositor::launch_spinner()
+{
+    if (config->spinner().empty())
+        return;
+
+    // Launch spinner process to provide default background when a session isn't ready
+    QStringList env = QProcess::systemEnvironment();
+    env << "MIR_SOCKET=" + QString(config->get_socket_file().c_str());
+    spinner_process.setEnvironment(env);
+    spinner_process.start(config->spinner().c_str());
+}
+
 void SystemCompositor::qt_main(int argc, char **argv)
 {
     QCoreApplication app(argc, argv);
     DBusScreen dbus_screen(config, config->power_off_delay());
+    launch_spinner();
     app.exec();
 }
 
=== modified file 'src/system_compositor.h'
--- src/system_compositor.h	2014-04-15 20:47:54 +0000
+++ src/system_compositor.h	2014-05-06 20:06:39 +0000
@@ -20,6 +20,7 @@
 #define SYSTEM_COMPOSITOR_H_
 
 #include "dm_connection.h"
+#include <QProcess>
 
 namespace mir { namespace scene { class Session; } }
 
@@ -32,17 +33,20 @@
     void run(int argc, char **argv);
     void pause();
     void resume();
+    pid_t get_spinner_pid() const;
 
 private:
     std::shared_ptr<SystemCompositorServerConfiguration> config;
     std::shared_ptr<SystemCompositorShell> shell;
     boost::asio::io_service io_service;
     std::shared_ptr<DMConnection> dm_connection;
+    QProcess spinner_process;
 
     void set_active_session(std::string client_name);
     void set_next_session(std::string client_name);
     void main();
     void qt_main(int argc, char **argv);
+    void launch_spinner();
 };
 
 #endif /* SYSTEM_COMPOSITOR_H_ */