shell: rename widgets to reflect project rename

15 files changed, 267 insertions, 267 deletions

diff --git a/shell/app-icon.c b/shell/app-icon.c
index e53320a..1608650 100644
--- a/shell/app-icon.c
+++ b/shell/app-icon.c
@@ -8,10 +8,10 @@
 
 #include "app-icon.h"
 
-G_DEFINE_TYPE(WestonGtkAppIcon, weston_gtk_app_icon, GTK_TYPE_BUTTON)
+G_DEFINE_TYPE(MaynardAppIcon, maynard_app_icon, GTK_TYPE_BUTTON)
 
 static void
-weston_gtk_app_icon_init (WestonGtkAppIcon *self)
+maynard_app_icon_init (MaynardAppIcon *self)
 {
   gtk_style_context_add_class (
       gtk_widget_get_style_context (GTK_WIDGET (self)),
@@ -28,18 +28,18 @@ weston_gtk_app_icon_init (WestonGtkAppIcon *self)
 }
 
 static void
-weston_gtk_app_icon_class_init (WestonGtkAppIconClass *klass)
+maynard_app_icon_class_init (MaynardAppIconClass *klass)
 {
 }
 
 GtkWidget *
-weston_gtk_app_icon_new (const gchar *icon_name)
+maynard_app_icon_new (const gchar *icon_name)
 {
   GtkWidget *widget;
   GtkWidget *image;
 
   image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_DIALOG);
-  widget = g_object_new (WESTON_GTK_APP_ICON_TYPE,
+  widget = g_object_new (MAYNARD_APP_ICON_TYPE,
       "image", image,
       NULL);
 
@@ -47,13 +47,13 @@ weston_gtk_app_icon_new (const gchar *icon_name)
 }
 
 GtkWidget *
-weston_gtk_app_icon_new_from_gicon (GIcon *icon)
+maynard_app_icon_new_from_gicon (GIcon *icon)
 {
   GtkWidget *widget, *image;
 
   image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_DIALOG);
 
-  widget = g_object_new (WESTON_GTK_APP_ICON_TYPE,
+  widget = g_object_new (MAYNARD_APP_ICON_TYPE,
       "image", image,
       NULL);
 
diff --git a/shell/app-icon.h b/shell/app-icon.h
index f3bc8f5..2209352 100644
--- a/shell/app-icon.h
+++ b/shell/app-icon.h
@@ -4,36 +4,36 @@
  * Author: Jonny Lamb <jonny.lamb@collabora.co.uk>
  */
 
-#ifndef __WESTON_GTK_APP_ICON_H__
-#define __WESTON_GTK_APP_ICON_H__
+#ifndef __MAYNARD_APP_ICON_H__
+#define __MAYNARD_APP_ICON_H__
 
 #include <gtk/gtk.h>
 
-#define WESTON_GTK_APP_ICON_TYPE                 (weston_gtk_app_icon_get_type ())
-#define WESTON_GTK_APP_ICON(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), WESTON_GTK_APP_ICON_TYPE, WestonGtkAppIcon))
-#define WESTON_GTK_APP_ICON_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), WESTON_GTK_APP_ICON_TYPE, WestonGtkAppIconClass))
-#define WESTON_GTK_IS_APP_ICON(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), WESTON_GTK_APP_ICON_TYPE))
-#define WESTON_GTK_IS_APP_ICON_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), WESTON_GTK_APP_ICON_TYPE))
-#define WESTON_GTK_APP_ICON_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), WESTON_GTK_APP_ICON_TYPE, WestonGtkAppIconClass))
+#define MAYNARD_APP_ICON_TYPE                 (maynard_app_icon_get_type ())
+#define MAYNARD_APP_ICON(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAYNARD_APP_ICON_TYPE, MaynardAppIcon))
+#define MAYNARD_APP_ICON_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), MAYNARD_APP_ICON_TYPE, MaynardAppIconClass))
+#define MAYNARD_IS_APP_ICON(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MAYNARD_APP_ICON_TYPE))
+#define MAYNARD_IS_APP_ICON_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), MAYNARD_APP_ICON_TYPE))
+#define MAYNARD_APP_ICON_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), MAYNARD_APP_ICON_TYPE, MaynardAppIconClass))
 
-typedef struct WestonGtkAppIcon WestonGtkAppIcon;
-typedef struct WestonGtkAppIconClass WestonGtkAppIconClass;
-typedef struct WestonGtkAppIconPrivate WestonGtkAppIconPrivate;
+typedef struct MaynardAppIcon MaynardAppIcon;
+typedef struct MaynardAppIconClass MaynardAppIconClass;
+typedef struct MaynardAppIconPrivate MaynardAppIconPrivate;
 
-struct WestonGtkAppIcon
+struct MaynardAppIcon
 {
   GtkButton parent;
 
-  WestonGtkAppIconPrivate *priv;
+  MaynardAppIconPrivate *priv;
 };
 
-struct WestonGtkAppIconClass
+struct MaynardAppIconClass
 {
   GtkButtonClass parent_class;
 };
 
-GType      weston_gtk_app_icon_get_type       (void) G_GNUC_CONST;
-GtkWidget *weston_gtk_app_icon_new            (const gchar *icon_name);
-GtkWidget *weston_gtk_app_icon_new_from_gicon (GIcon *icon);
+GType      maynard_app_icon_get_type       (void) G_GNUC_CONST;
+GtkWidget *maynard_app_icon_new            (const gchar *icon_name);
+GtkWidget *maynard_app_icon_new_from_gicon (GIcon *icon);
 
-#endif /* __WESTON_GTK_APP_ICON_H__ */
+#endif /* __MAYNARD_APP_ICON_H__ */
diff --git a/shell/clock.c b/shell/clock.c
index 4a3cf9c..b854be0 100644
--- a/shell/clock.c
+++ b/shell/clock.c
@@ -11,26 +11,26 @@
 #define GNOME_DESKTOP_USE_UNSTABLE_API
 #include <libgnome-desktop/gnome-wall-clock.h>
 
-struct WestonGtkClockPrivate {
+struct MaynardClockPrivate {
   GtkWidget *label;
 
   GnomeWallClock *wall_clock;
 };
 
-G_DEFINE_TYPE(WestonGtkClock, weston_gtk_clock, GTK_TYPE_WINDOW)
+G_DEFINE_TYPE(MaynardClock, maynard_clock, GTK_TYPE_WINDOW)
 
 static void
-weston_gtk_clock_init (WestonGtkClock *self)
+maynard_clock_init (MaynardClock *self)
 {
   self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
-      WESTON_GTK_CLOCK_TYPE,
-      WestonGtkClockPrivate);
+      MAYNARD_CLOCK_TYPE,
+      MaynardClockPrivate);
 }
 
 static void
 wall_clock_notify_cb (GnomeWallClock *wall_clock,
     GParamSpec *pspec,
-    WestonGtkClock *self)
+    MaynardClock *self)
 {
   GDateTime *datetime;
   gchar *str;
@@ -47,11 +47,11 @@ wall_clock_notify_cb (GnomeWallClock *wall_clock,
 }
 
 static void
-weston_gtk_clock_constructed (GObject *object)
+maynard_clock_constructed (GObject *object)
 {
-  WestonGtkClock *self = WESTON_GTK_CLOCK (object);
+  MaynardClock *self = MAYNARD_CLOCK (object);
 
-  G_OBJECT_CLASS (weston_gtk_clock_parent_class)->constructed (object);
+  G_OBJECT_CLASS (maynard_clock_parent_class)->constructed (object);
 
   self->priv->wall_clock = g_object_new (GNOME_TYPE_WALL_CLOCK, NULL);
   g_signal_connect (self->priv->wall_clock, "notify::clock",
@@ -73,31 +73,31 @@ weston_gtk_clock_constructed (GObject *object)
 }
 
 static void
-weston_gtk_clock_dispose (GObject *object)
+maynard_clock_dispose (GObject *object)
 {
-  WestonGtkClock *self = WESTON_GTK_CLOCK (object);
+  MaynardClock *self = MAYNARD_CLOCK (object);
 
   if (self->priv->wall_clock)
     g_object_unref (self->priv->wall_clock);
   self->priv->wall_clock = NULL;
 
-  G_OBJECT_CLASS (weston_gtk_clock_parent_class)->dispose (object);
+  G_OBJECT_CLASS (maynard_clock_parent_class)->dispose (object);
 }
 
 static void
-weston_gtk_clock_class_init (WestonGtkClockClass *klass)
+maynard_clock_class_init (MaynardClockClass *klass)
 {
   GObjectClass *object_class = (GObjectClass *)klass;
 
-  object_class->constructed = weston_gtk_clock_constructed;
-  object_class->dispose = weston_gtk_clock_dispose;
+  object_class->constructed = maynard_clock_constructed;
+  object_class->dispose = maynard_clock_dispose;
 
-  g_type_class_add_private (object_class, sizeof (WestonGtkClockPrivate));
+  g_type_class_add_private (object_class, sizeof (MaynardClockPrivate));
 }
 
 GtkWidget *
-weston_gtk_clock_new (void)
+maynard_clock_new (void)
 {
-  return g_object_new (WESTON_GTK_CLOCK_TYPE,
+  return g_object_new (MAYNARD_CLOCK_TYPE,
       NULL);
 }
diff --git a/shell/clock.h b/shell/clock.h
index 3de21ea..218c2a8 100644
--- a/shell/clock.h
+++ b/shell/clock.h
@@ -4,41 +4,41 @@
  * Author: Jonny Lamb <jonny.lamb@collabora.co.uk>
  */
 
-#ifndef __WESTON_GTK_CLOCK_H__
-#define __WESTON_GTK_CLOCK_H__
+#ifndef __MAYNARD_CLOCK_H__
+#define __MAYNARD_CLOCK_H__
 
 #include <gtk/gtk.h>
 
 #include "panel.h"
 
-#define WESTON_GTK_CLOCK_TYPE                 (weston_gtk_clock_get_type ())
-#define WESTON_GTK_CLOCK(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), WESTON_GTK_CLOCK_TYPE, WestonGtkClock))
-#define WESTON_GTK_CLOCK_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), WESTON_GTK_CLOCK_TYPE, WestonGtkClockClass))
-#define WESTON_GTK_IS_CLOCK(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), WESTON_GTK_CLOCK_TYPE))
-#define WESTON_GTK_IS_CLOCK_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), WESTON_GTK_CLOCK_TYPE))
-#define WESTON_GTK_CLOCK_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), WESTON_GTK_CLOCK_TYPE, WestonGtkClockClass))
+#define MAYNARD_CLOCK_TYPE                 (maynard_clock_get_type ())
+#define MAYNARD_CLOCK(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAYNARD_CLOCK_TYPE, MaynardClock))
+#define MAYNARD_CLOCK_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), MAYNARD_CLOCK_TYPE, MaynardClockClass))
+#define MAYNARD_IS_CLOCK(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MAYNARD_CLOCK_TYPE))
+#define MAYNARD_IS_CLOCK_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), MAYNARD_CLOCK_TYPE))
+#define MAYNARD_CLOCK_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), MAYNARD_CLOCK_TYPE, MaynardClockClass))
 
-typedef struct WestonGtkClock WestonGtkClock;
-typedef struct WestonGtkClockClass WestonGtkClockClass;
-typedef struct WestonGtkClockPrivate WestonGtkClockPrivate;
+typedef struct MaynardClock MaynardClock;
+typedef struct MaynardClockClass MaynardClockClass;
+typedef struct MaynardClockPrivate MaynardClockPrivate;
 
-struct WestonGtkClock
+struct MaynardClock
 {
   GtkWindow parent;
 
-  WestonGtkClockPrivate *priv;
+  MaynardClockPrivate *priv;
 };
 
-struct WestonGtkClockClass
+struct MaynardClockClass
 {
   GtkWindowClass parent_class;
 };
 
-#define WESTON_GTK_CLOCK_WIDTH (WESTON_GTK_PANEL_WIDTH * 2.6)
-#define WESTON_GTK_CLOCK_HEIGHT (WESTON_GTK_PANEL_WIDTH * 2)
+#define MAYNARD_CLOCK_WIDTH (MAYNARD_PANEL_WIDTH * 2.6)
+#define MAYNARD_CLOCK_HEIGHT (MAYNARD_PANEL_WIDTH * 2)
 
-GType weston_gtk_clock_get_type (void) G_GNUC_CONST;
+GType maynard_clock_get_type (void) G_GNUC_CONST;
 
-GtkWidget * weston_gtk_clock_new (void);
+GtkWidget * maynard_clock_new (void);
 
-#endif /* __WESTON_GTK_CLOCK_H__ */
+#endif /* __MAYNARD_CLOCK_H__ */
diff --git a/shell/favorites.c b/shell/favorites.c
index 267126d..63eeeb2 100644
--- a/shell/favorites.c
+++ b/shell/favorites.c
@@ -18,15 +18,15 @@ enum {
   PROP_0,
 };
 
-struct WestonGtkFavoritesPrivate {
+struct MaynardFavoritesPrivate {
   GSettings *settings;
 };
 
-G_DEFINE_TYPE(WestonGtkFavorites, weston_gtk_favorites, GTK_TYPE_BOX)
+G_DEFINE_TYPE(MaynardFavorites, maynard_favorites, GTK_TYPE_BOX)
 
 static void
 favorite_clicked (GtkButton *button,
-    WestonGtkFavorites *self)
+    MaynardFavorites *self)
 {
   GAppInfo *info = g_object_get_data (G_OBJECT(button), "info");
   GError *error = NULL;
@@ -42,7 +42,7 @@ favorite_clicked (GtkButton *button,
 }
 
 static void
-add_favorite (WestonGtkFavorites *self,
+add_favorite (MaynardFavorites *self,
     const gchar *favorite)
 {
   GDesktopAppInfo *info;
@@ -56,7 +56,7 @@ add_favorite (WestonGtkFavorites *self,
 
   icon = g_app_info_get_icon (G_APP_INFO (info));
 
-  button = weston_gtk_app_icon_new_from_gicon (icon);
+  button = maynard_app_icon_new_from_gicon (icon);
 
   g_object_set_data_full (G_OBJECT (button), "info", info, g_object_unref);
 
@@ -75,7 +75,7 @@ remove_favorite (GtkWidget *favorite,
 static void
 favorites_changed (GSettings *settings,
     const gchar *key,
-    WestonGtkFavorites *self)
+    MaynardFavorites *self)
 {
   gchar **favorites = g_settings_get_strv (settings, key);
   gint i;
@@ -94,21 +94,21 @@ favorites_changed (GSettings *settings,
 }
 
 static void
-weston_gtk_favorites_dispose (GObject *object)
+maynard_favorites_dispose (GObject *object)
 {
-  WestonGtkFavorites *self = WESTON_GTK_FAVORITES (object);
+  MaynardFavorites *self = MAYNARD_FAVORITES (object);
 
   g_clear_object (&self->priv->settings);
 
-  G_OBJECT_CLASS (weston_gtk_favorites_parent_class)->dispose (object);
+  G_OBJECT_CLASS (maynard_favorites_parent_class)->dispose (object);
 }
 
 static void
-weston_gtk_favorites_init (WestonGtkFavorites *self)
+maynard_favorites_init (MaynardFavorites *self)
 {
   self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
-                                            WESTON_GTK_TYPE_FAVORITES,
-                                            WestonGtkFavoritesPrivate);
+                                            MAYNARD_TYPE_FAVORITES,
+                                            MaynardFavoritesPrivate);
 
   self->priv->settings = g_settings_new ("org.raspberrypi.maynard");
   g_signal_connect (self->priv->settings, "changed::favorites",
@@ -119,19 +119,19 @@ weston_gtk_favorites_init (WestonGtkFavorites *self)
 }
 
 static void
-weston_gtk_favorites_class_init (WestonGtkFavoritesClass *klass)
+maynard_favorites_class_init (MaynardFavoritesClass *klass)
 {
   GObjectClass *object_class = (GObjectClass *)klass;
 
-  object_class->dispose = weston_gtk_favorites_dispose;
+  object_class->dispose = maynard_favorites_dispose;
 
-  g_type_class_add_private (object_class, sizeof (WestonGtkFavoritesPrivate));
+  g_type_class_add_private (object_class, sizeof (MaynardFavoritesPrivate));
 }
 
 GtkWidget *
-weston_gtk_favorites_new (void)
+maynard_favorites_new (void)
 {
-  return g_object_new (WESTON_GTK_TYPE_FAVORITES,
+  return g_object_new (MAYNARD_TYPE_FAVORITES,
       "orientation", GTK_ORIENTATION_VERTICAL,
       NULL);
 }
diff --git a/shell/favorites.h b/shell/favorites.h
index 4c192e1..bf462b2 100644
--- a/shell/favorites.h
+++ b/shell/favorites.h
@@ -4,35 +4,35 @@
  * Author: Emilio Pozuelo Monfort <emilio.pozuelo@collabora.co.uk>
  */
 
-#ifndef __WESTON_GTK_FAVORITES_H__
-#define __WESTON_GTK_FAVORITES_H__
+#ifndef __MAYNARD_FAVORITES_H__
+#define __MAYNARD_FAVORITES_H__
 
 #include <gtk/gtk.h>
 
-#define WESTON_GTK_TYPE_FAVORITES                 (weston_gtk_favorites_get_type ())
-#define WESTON_GTK_FAVORITES(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), WESTON_GTK_TYPE_FAVORITES, WestonGtkFavorites))
-#define WESTON_GTK_FAVORITES_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), WESTON_GTK_TYPE_FAVORITES, WestonGtkFavoritesClass))
-#define WESTON_GTK_IS_FAVORITES(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), WESTON_GTK_TYPE_FAVORITES))
-#define WESTON_GTK_IS_FAVORITES_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), WESTON_GTK_TYPE_FAVORITES))
-#define WESTON_GTK_FAVORITES_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), WESTON_GTK_TYPE_FAVORITES, WestonGtkFavoritesClass))
+#define MAYNARD_TYPE_FAVORITES                 (maynard_favorites_get_type ())
+#define MAYNARD_FAVORITES(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAYNARD_TYPE_FAVORITES, MaynardFavorites))
+#define MAYNARD_FAVORITES_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), MAYNARD_TYPE_FAVORITES, MaynardFavoritesClass))
+#define MAYNARD_IS_FAVORITES(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MAYNARD_TYPE_FAVORITES))
+#define MAYNARD_IS_FAVORITES_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), MAYNARD_TYPE_FAVORITES))
+#define MAYNARD_FAVORITES_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), MAYNARD_TYPE_FAVORITES, MaynardFavoritesClass))
 
-typedef struct WestonGtkFavorites WestonGtkFavorites;
-typedef struct WestonGtkFavoritesClass WestonGtkFavoritesClass;
-typedef struct WestonGtkFavoritesPrivate WestonGtkFavoritesPrivate;
+typedef struct MaynardFavorites MaynardFavorites;
+typedef struct MaynardFavoritesClass MaynardFavoritesClass;
+typedef struct MaynardFavoritesPrivate MaynardFavoritesPrivate;
 
-struct WestonGtkFavorites
+struct MaynardFavorites
 {
   GtkBox parent;
 
-  WestonGtkFavoritesPrivate *priv;
+  MaynardFavoritesPrivate *priv;
 };
 
-struct WestonGtkFavoritesClass
+struct MaynardFavoritesClass
 {
   GtkBoxClass parent_class;
 };
 
-GType      weston_gtk_favorites_get_type         (void) G_GNUC_CONST;
-GtkWidget *weston_gtk_favorites_new              (void);
+GType      maynard_favorites_get_type         (void) G_GNUC_CONST;
+GtkWidget *maynard_favorites_new              (void);
 
-#endif /* __WESTON_GTK_FAVORITES_H__ */
+#endif /* __MAYNARD_FAVORITES_H__ */
diff --git a/shell/gtk-shell.c b/shell/gtk-shell.c
index 31ea5cc..9190879 100644
--- a/shell/gtk-shell.c
+++ b/shell/gtk-shell.c
@@ -92,11 +92,11 @@ desktop_shell_configure(void *data,
 				     width, height);
 
 	/* TODO: make this height a little nicer */
-	window_height = height * WESTON_GTK_PANEL_HEIGHT_RATIO;
+	window_height = height * MAYNARD_PANEL_HEIGHT_RATIO;
 	gtk_window_resize (GTK_WINDOW (desktop->panel->window),
-			   WESTON_GTK_PANEL_WIDTH, window_height);
+			   MAYNARD_PANEL_WIDTH, window_height);
 
-	weston_gtk_launcher_calculate (WESTON_GTK_LAUNCHER(desktop->launcher_grid->window),
+	maynard_launcher_calculate (MAYNARD_LAUNCHER(desktop->launcher_grid->window),
 				       &grid_width, &grid_height, NULL);
 	gtk_widget_set_size_request (desktop->launcher_grid->window,
 				     grid_width,
@@ -107,18 +107,18 @@ desktop_shell_configure(void *data,
 				  0, (height - window_height) / 2);
 
 	gtk_window_resize (GTK_WINDOW (desktop->clock->window),
-			   WESTON_GTK_CLOCK_WIDTH,
-			   WESTON_GTK_CLOCK_HEIGHT);
+			   MAYNARD_CLOCK_WIDTH,
+			   MAYNARD_CLOCK_HEIGHT);
 
 	shell_helper_move_surface(desktop->helper,
 				  desktop->clock->surface,
-				  WESTON_GTK_PANEL_WIDTH,
+				  MAYNARD_PANEL_WIDTH,
 				  (height - window_height) / 2);
 
 	shell_helper_move_surface(desktop->helper,
 				  desktop->launcher_grid->surface,
 				  - grid_width,
-				  ((height - window_height) / 2) + WESTON_GTK_CLOCK_HEIGHT);
+				  ((height - window_height) / 2) + MAYNARD_CLOCK_HEIGHT);
 
 	desktop_shell_desktop_ready(desktop->shell);
 
@@ -161,7 +161,7 @@ launcher_grid_toggle (GtkWidget *widget, struct desktop *desktop)
 
 		shell_helper_slide_surface(desktop->helper,
 					   desktop->launcher_grid->surface,
-					   width + WESTON_GTK_PANEL_WIDTH, 0);
+					   width + MAYNARD_PANEL_WIDTH, 0);
 	}
 
 	desktop->grid_visible = !desktop->grid_visible;
@@ -176,7 +176,7 @@ launcher_grid_create (struct desktop *desktop)
 	launcher_grid = malloc (sizeof *launcher_grid);
 	memset (launcher_grid, 0, sizeof *launcher_grid);
 
-	launcher_grid->window = weston_gtk_launcher_new (desktop->background->window);
+	launcher_grid->window = maynard_launcher_new (desktop->background->window);
 	gdk_window = gtk_widget_get_window(launcher_grid->window);
 	launcher_grid->surface = gdk_wayland_window_get_wl_surface(gdk_window);
 
@@ -197,7 +197,7 @@ clock_create (struct desktop *desktop)
 	clock = malloc(sizeof *clock);
 	memset(clock, 0, sizeof *clock);
 
-	clock->window = weston_gtk_clock_new();
+	clock->window = maynard_clock_new();
 
 	gdk_window = gtk_widget_get_window(clock->window);
 	clock->surface = gdk_wayland_window_get_wl_surface(gdk_window);
@@ -228,7 +228,7 @@ panel_window_enter_cb (GtkWidget *widget,
 	shell_helper_slide_surface_back(desktop->helper,
 					desktop->clock->surface);
 
-	weston_gtk_panel_set_expand(WESTON_GTK_PANEL(desktop->panel->window),
+	maynard_panel_set_expand(MAYNARD_PANEL(desktop->panel->window),
 				    TRUE);
 
 	return FALSE;
@@ -247,12 +247,12 @@ leave_panel_idle_cb (gpointer data)
 
 	shell_helper_slide_surface(desktop->helper,
 				   desktop->panel->surface,
-				   WESTON_GTK_VERTICAL_CLOCK_WIDTH - WESTON_GTK_PANEL_WIDTH, 0);
+				   MAYNARD_VERTICAL_CLOCK_WIDTH - MAYNARD_PANEL_WIDTH, 0);
 	shell_helper_slide_surface(desktop->helper,
 				   desktop->clock->surface,
-				   WESTON_GTK_VERTICAL_CLOCK_WIDTH - WESTON_GTK_PANEL_WIDTH - width, 0);
+				   MAYNARD_VERTICAL_CLOCK_WIDTH - MAYNARD_PANEL_WIDTH - width, 0);
 
-	weston_gtk_panel_set_expand(WESTON_GTK_PANEL(desktop->panel->window),
+	maynard_panel_set_expand(MAYNARD_PANEL(desktop->panel->window),
 				    FALSE);
 
 	return FALSE;
@@ -296,7 +296,7 @@ panel_create(struct desktop *desktop)
 	panel = malloc(sizeof *panel);
 	memset(panel, 0, sizeof *panel);
 
-	panel->window = weston_gtk_panel_new();
+	panel->window = maynard_panel_new();
 
 	g_signal_connect(panel->window, "app-menu-toggled",
 			 G_CALLBACK(launcher_grid_toggle), desktop);
diff --git a/shell/launcher.c b/shell/launcher.c
index 679b40a..e2a45a2 100644
--- a/shell/launcher.c
+++ b/shell/launcher.c
@@ -23,7 +23,7 @@ enum {
 };
 static guint signals[N_SIGNALS] = { 0 };
 
-struct WestonGtkLauncherPrivate {
+struct MaynardLauncherPrivate {
   /* background widget so we know the output size */
   GtkWidget *background;
   ShellAppSystem *app_system;
@@ -31,17 +31,17 @@ struct WestonGtkLauncherPrivate {
   GtkWidget *grid;
 };
 
-G_DEFINE_TYPE(WestonGtkLauncher, weston_gtk_launcher, GTK_TYPE_WINDOW)
+G_DEFINE_TYPE(MaynardLauncher, maynard_launcher, GTK_TYPE_WINDOW)
 
 /* each grid item is 114x114 */
 #define GRID_ITEM_WIDTH 114
 
 static void
-weston_gtk_launcher_init (WestonGtkLauncher *self)
+maynard_launcher_init (MaynardLauncher *self)
 {
   self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
-      WESTON_GTK_LAUNCHER_TYPE,
-      WestonGtkLauncherPrivate);
+      MAYNARD_LAUNCHER_TYPE,
+      MaynardLauncherPrivate);
 }
 
 static gint
@@ -87,7 +87,7 @@ get_child_position_cb (GtkOverlay *overlay,
 static gboolean
 app_launched_idle_cb (gpointer data)
 {
-  WestonGtkLauncher *self = data;
+  MaynardLauncher *self = data;
   GtkAdjustment *adjustment;
 
   /* make the scrolled window go back to the top */
@@ -104,7 +104,7 @@ static void
 clicked_cb (GtkWidget *widget,
     GDesktopAppInfo *info)
 {
-  WestonGtkLauncher *self;
+  MaynardLauncher *self;
 
   g_app_info_launch (G_APP_INFO (info), NULL, NULL, NULL);
 
@@ -135,7 +135,7 @@ app_leave_cb (GtkWidget *widget,
 }
 
 static GtkWidget *
-app_launcher_new_from_desktop_info (WestonGtkLauncher *self,
+app_launcher_new_from_desktop_info (MaynardLauncher *self,
     GDesktopAppInfo *info)
 {
   GIcon *icon;
@@ -212,7 +212,7 @@ app_launcher_new_from_desktop_info (WestonGtkLauncher *self,
 
 static void
 installed_changed_cb (ShellAppSystem *app_system,
-    WestonGtkLauncher *self)
+    MaynardLauncher *self)
 {
   GHashTable *entries = shell_app_system_get_entries (app_system);
   GList *l, *values;
@@ -228,7 +228,7 @@ installed_changed_cb (ShellAppSystem *app_system,
   values = g_hash_table_get_values (entries);
   values = g_list_sort (values, sort_apps);
 
-  weston_gtk_launcher_calculate (self, NULL, NULL, &cols);
+  maynard_launcher_calculate (self, NULL, NULL, &cols);
   cols--; /* because we start from zero here */
 
   left = top = 0;
@@ -254,17 +254,17 @@ installed_changed_cb (ShellAppSystem *app_system,
 static void
 background_size_allocate_cb (GtkWidget *widget,
     GdkRectangle *allocation,
-    WestonGtkLauncher *self)
+    MaynardLauncher *self)
 {
   installed_changed_cb (self->priv->app_system, self);
 }
 
 static void
-weston_gtk_launcher_constructed (GObject *object)
+maynard_launcher_constructed (GObject *object)
 {
-  WestonGtkLauncher *self = WESTON_GTK_LAUNCHER (object);
+  MaynardLauncher *self = MAYNARD_LAUNCHER (object);
 
-  G_OBJECT_CLASS (weston_gtk_launcher_parent_class)->constructed (object);
+  G_OBJECT_CLASS (maynard_launcher_parent_class)->constructed (object);
 
   /* window properties */
   gtk_window_set_title (GTK_WINDOW (self), "gtk shell");
@@ -300,12 +300,12 @@ weston_gtk_launcher_constructed (GObject *object)
 }
 
 static void
-weston_gtk_launcher_get_property (GObject *object,
+maynard_launcher_get_property (GObject *object,
     guint param_id,
     GValue *value,
     GParamSpec *pspec)
 {
-  WestonGtkLauncher *self = WESTON_GTK_LAUNCHER (object);
+  MaynardLauncher *self = MAYNARD_LAUNCHER (object);
 
   switch (param_id)
     {
@@ -319,12 +319,12 @@ weston_gtk_launcher_get_property (GObject *object,
 }
 
 static void
-weston_gtk_launcher_set_property (GObject *object,
+maynard_launcher_set_property (GObject *object,
     guint param_id,
     const GValue *value,
     GParamSpec *pspec)
 {
-  WestonGtkLauncher *self = WESTON_GTK_LAUNCHER (object);
+  MaynardLauncher *self = MAYNARD_LAUNCHER (object);
 
   switch (param_id)
     {
@@ -338,13 +338,13 @@ weston_gtk_launcher_set_property (GObject *object,
 }
 
 static void
-weston_gtk_launcher_class_init (WestonGtkLauncherClass *klass)
+maynard_launcher_class_init (MaynardLauncherClass *klass)
 {
   GObjectClass *object_class = (GObjectClass *)klass;
 
-  object_class->constructed = weston_gtk_launcher_constructed;
-  object_class->get_property = weston_gtk_launcher_get_property;
-  object_class->set_property = weston_gtk_launcher_set_property;
+  object_class->constructed = maynard_launcher_constructed;
+  object_class->get_property = maynard_launcher_get_property;
+  object_class->set_property = maynard_launcher_set_property;
 
   g_object_class_install_property (object_class, PROP_BACKGROUND,
       g_param_spec_object ("background",
@@ -357,19 +357,19 @@ weston_gtk_launcher_class_init (WestonGtkLauncherClass *klass)
       G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, 0, NULL, NULL,
       NULL, G_TYPE_NONE, 0);
 
-  g_type_class_add_private (object_class, sizeof (WestonGtkLauncherPrivate));
+  g_type_class_add_private (object_class, sizeof (MaynardLauncherPrivate));
 }
 
 GtkWidget *
-weston_gtk_launcher_new (GtkWidget *background_widget)
+maynard_launcher_new (GtkWidget *background_widget)
 {
-  return g_object_new (WESTON_GTK_LAUNCHER_TYPE,
+  return g_object_new (MAYNARD_LAUNCHER_TYPE,
       "background", background_widget,
       NULL);
 }
 
 void
-weston_gtk_launcher_calculate (WestonGtkLauncher *self,
+maynard_launcher_calculate (MaynardLauncher *self,
     gint *grid_window_width,
     gint *grid_window_height,
     gint *grid_cols)
@@ -382,14 +382,14 @@ weston_gtk_launcher_calculate (WestonGtkLauncher *self,
   gtk_widget_get_size_request (self->priv->background,
       &output_width, &output_height);
 
-  panel_height = output_height * WESTON_GTK_PANEL_HEIGHT_RATIO;
+  panel_height = output_height * MAYNARD_PANEL_HEIGHT_RATIO;
 
   /* the scrollbar is 13 pixels wide */
-  usable_width = output_width - WESTON_GTK_PANEL_WIDTH - 13;
+  usable_width = output_width - MAYNARD_PANEL_WIDTH - 13;
 
   /* we want the height from under the clock which means we need to
    * work out where the clock is, then add the clock height */
-  usable_height = output_height - (((output_height - panel_height) / 2) + WESTON_GTK_CLOCK_HEIGHT);
+  usable_height = output_height - (((output_height - panel_height) / 2) + MAYNARD_CLOCK_HEIGHT);
 
   cols = (guint) (usable_width / GRID_ITEM_WIDTH);
   rows = (guint) (usable_height / GRID_ITEM_WIDTH);
diff --git a/shell/launcher.h b/shell/launcher.h
index 3bd10b0..37b5229 100644
--- a/shell/launcher.h
+++ b/shell/launcher.h
@@ -4,40 +4,40 @@
  * Author: Jonny Lamb <jonny.lamb@collabora.co.uk>
  */
 
-#ifndef __WESTON_GTK_LAUNCHER_H__
-#define __WESTON_GTK_LAUNCHER_H__
+#ifndef __MAYNARD_LAUNCHER_H__
+#define __MAYNARD_LAUNCHER_H__
 
 #include <gtk/gtk.h>
 
-#define WESTON_GTK_LAUNCHER_TYPE                 (weston_gtk_launcher_get_type ())
-#define WESTON_GTK_LAUNCHER(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), WESTON_GTK_LAUNCHER_TYPE, WestonGtkLauncher))
-#define WESTON_GTK_LAUNCHER_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), WESTON_GTK_LAUNCHER_TYPE, WestonGtkLauncherClass))
-#define WESTON_GTK_IS_LAUNCHER(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), WESTON_GTK_LAUNCHER_TYPE))
-#define WESTON_GTK_IS_LAUNCHER_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), WESTON_GTK_LAUNCHER_TYPE))
-#define WESTON_GTK_LAUNCHER_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), WESTON_GTK_LAUNCHER_TYPE, WestonGtkLauncherClass))
+#define MAYNARD_LAUNCHER_TYPE                 (maynard_launcher_get_type ())
+#define MAYNARD_LAUNCHER(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAYNARD_LAUNCHER_TYPE, MaynardLauncher))
+#define MAYNARD_LAUNCHER_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), MAYNARD_LAUNCHER_TYPE, MaynardLauncherClass))
+#define MAYNARD_IS_LAUNCHER(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MAYNARD_LAUNCHER_TYPE))
+#define MAYNARD_IS_LAUNCHER_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), MAYNARD_LAUNCHER_TYPE))
+#define MAYNARD_LAUNCHER_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), MAYNARD_LAUNCHER_TYPE, MaynardLauncherClass))
 
-typedef struct WestonGtkLauncher WestonGtkLauncher;
-typedef struct WestonGtkLauncherClass WestonGtkLauncherClass;
-typedef struct WestonGtkLauncherPrivate WestonGtkLauncherPrivate;
+typedef struct MaynardLauncher MaynardLauncher;
+typedef struct MaynardLauncherClass MaynardLauncherClass;
+typedef struct MaynardLauncherPrivate MaynardLauncherPrivate;
 
-struct WestonGtkLauncher
+struct MaynardLauncher
 {
   GtkWindow parent;
 
-  WestonGtkLauncherPrivate *priv;
+  MaynardLauncherPrivate *priv;
 };
 
-struct WestonGtkLauncherClass
+struct MaynardLauncherClass
 {
   GtkWindowClass parent_class;
 };
 
-GType weston_gtk_launcher_get_type (void) G_GNUC_CONST;
+GType maynard_launcher_get_type (void) G_GNUC_CONST;
 
-GtkWidget * weston_gtk_launcher_new (GtkWidget *background_widget);
+GtkWidget * maynard_launcher_new (GtkWidget *background_widget);
 
-void weston_gtk_launcher_calculate (WestonGtkLauncher *self,
+void maynard_launcher_calculate (MaynardLauncher *self,
     gint *grid_window_width, gint *grid_window_height,
     gint *grid_cols);
 
-#endif /* __WESTON_GTK_LAUNCHER_H__ */
+#endif /* __MAYNARD_LAUNCHER_H__ */
diff --git a/shell/panel.c b/shell/panel.c
index 05ae151..5a4ab7c 100644
--- a/shell/panel.c
+++ b/shell/panel.c
@@ -18,33 +18,33 @@ enum {
 };
 static guint signals[N_SIGNALS] = { 0 };
 
-struct WestonGtkPanelPrivate {
+struct MaynardPanelPrivate {
   gboolean hidden;
 
   GtkWidget *revealer_buttons; /* for the wifi and sound buttons */
   GtkWidget *revealer_clock; /* for the vertical clock */
 };
 
-G_DEFINE_TYPE(WestonGtkPanel, weston_gtk_panel, GTK_TYPE_WINDOW)
+G_DEFINE_TYPE(MaynardPanel, maynard_panel, GTK_TYPE_WINDOW)
 
 static void
-weston_gtk_panel_init (WestonGtkPanel *self)
+maynard_panel_init (MaynardPanel *self)
 {
   self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
-      WESTON_GTK_PANEL_TYPE,
-      WestonGtkPanelPrivate);
+      MAYNARD_PANEL_TYPE,
+      MaynardPanelPrivate);
 }
 
 static gboolean
 widget_enter_notify_event_cb (GtkWidget *widget,
     GdkEventCrossing *event,
-    WestonGtkPanel *self)
+    MaynardPanel *self)
 {
   g_signal_emit_by_name (self, "enter-notify-event", event);
 }
 
 static void
-widget_connect_enter_signal (WestonGtkPanel *self,
+widget_connect_enter_signal (MaynardPanel *self,
     GtkWidget *widget)
 {
   g_signal_connect (widget, "enter-notify-event",
@@ -53,21 +53,21 @@ widget_connect_enter_signal (WestonGtkPanel *self,
 
 static void
 app_menu_button_clicked_cb (GtkButton *button,
-    WestonGtkPanel *self)
+    MaynardPanel *self)
 {
   g_signal_emit (self, signals[APP_MENU_TOGGLED], 0);
 }
 
 static void
-weston_gtk_panel_constructed (GObject *object)
+maynard_panel_constructed (GObject *object)
 {
-  WestonGtkPanel *self = WESTON_GTK_PANEL (object);
+  MaynardPanel *self = MAYNARD_PANEL (object);
   GtkWidget *main_box, *menu_box, *buttons_box;
   GtkWidget *ebox;
   GtkWidget *image;
   GtkWidget *button;
 
-  G_OBJECT_CLASS (weston_gtk_panel_parent_class)->constructed (object);
+  G_OBJECT_CLASS (maynard_panel_parent_class)->constructed (object);
 
   /* window properties */
   gtk_window_set_title (GTK_WINDOW (self), "gtk shell");
@@ -140,20 +140,20 @@ weston_gtk_panel_constructed (GObject *object)
 
   /* vertical clock */
   gtk_container_add (GTK_CONTAINER (self->priv->revealer_clock),
-      weston_gtk_vertical_clock_new ());
+      maynard_vertical_clock_new ());
 
   /* end of the menu buttons and vertical clock */
 
   /* favorites */
   ebox = gtk_event_box_new ();
   gtk_box_pack_start (GTK_BOX (main_box), ebox, FALSE, FALSE, 0);
-  gtk_container_add (GTK_CONTAINER (ebox), weston_gtk_favorites_new ());
+  gtk_container_add (GTK_CONTAINER (ebox), maynard_favorites_new ());
   widget_connect_enter_signal (self, ebox);
 
   /* bottom app menu button */
   ebox = gtk_event_box_new ();
   gtk_box_pack_end (GTK_BOX (main_box), ebox, FALSE, FALSE, 0);
-  button = weston_gtk_app_icon_new ("view-grid-symbolic");
+  button = maynard_app_icon_new ("view-grid-symbolic");
   g_signal_connect (button, "clicked",
       G_CALLBACK (app_menu_button_clicked_cb), self);
   gtk_container_add (GTK_CONTAINER (ebox), button);
@@ -164,29 +164,29 @@ weston_gtk_panel_constructed (GObject *object)
 }
 
 static void
-weston_gtk_panel_class_init (WestonGtkPanelClass *klass)
+maynard_panel_class_init (MaynardPanelClass *klass)
 {
   GObjectClass *object_class = (GObjectClass *)klass;
   GParamSpec *param_spec;
 
-  object_class->constructed = weston_gtk_panel_constructed;
+  object_class->constructed = maynard_panel_constructed;
 
   signals[APP_MENU_TOGGLED] = g_signal_new ("app-menu-toggled",
       G_TYPE_FROM_CLASS (klass), G_SIGNAL_RUN_LAST, 0, NULL, NULL,
       NULL, G_TYPE_NONE, 0);
 
-  g_type_class_add_private (object_class, sizeof (WestonGtkPanelPrivate));
+  g_type_class_add_private (object_class, sizeof (MaynardPanelPrivate));
 }
 
 GtkWidget *
-weston_gtk_panel_new (void)
+maynard_panel_new (void)
 {
-  return g_object_new (WESTON_GTK_PANEL_TYPE,
+  return g_object_new (MAYNARD_PANEL_TYPE,
       NULL);
 }
 
 void
-weston_gtk_panel_set_expand (WestonGtkPanel *self,
+maynard_panel_set_expand (MaynardPanel *self,
     gboolean expand)
 {
   gtk_revealer_set_reveal_child (GTK_REVEALER (self->priv->revealer_buttons), expand);
diff --git a/shell/panel.h b/shell/panel.h
index ac3b250..fb2cfa6 100644
--- a/shell/panel.h
+++ b/shell/panel.h
@@ -4,41 +4,41 @@
  * Author: Jonny Lamb <jonny.lamb@collabora.co.uk>
  */
 
-#ifndef __WESTON_GTK_PANEL_H__
-#define __WESTON_GTK_PANEL_H__
+#ifndef __MAYNARD_PANEL_H__
+#define __MAYNARD_PANEL_H__
 
 #include <gtk/gtk.h>
 
-#define WESTON_GTK_PANEL_TYPE                 (weston_gtk_panel_get_type ())
-#define WESTON_GTK_PANEL(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), WESTON_GTK_PANEL_TYPE, WestonGtkPanel))
-#define WESTON_GTK_PANEL_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), WESTON_GTK_PANEL_TYPE, WestonGtkPanelClass))
-#define WESTON_GTK_IS_PANEL(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), WESTON_GTK_PANEL_TYPE))
-#define WESTON_GTK_IS_PANEL_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), WESTON_GTK_PANEL_TYPE))
-#define WESTON_GTK_PANEL_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), WESTON_GTK_PANEL_TYPE, WestonGtkPanelClass))
+#define MAYNARD_PANEL_TYPE                 (maynard_panel_get_type ())
+#define MAYNARD_PANEL(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAYNARD_PANEL_TYPE, MaynardPanel))
+#define MAYNARD_PANEL_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), MAYNARD_PANEL_TYPE, MaynardPanelClass))
+#define MAYNARD_IS_PANEL(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MAYNARD_PANEL_TYPE))
+#define MAYNARD_IS_PANEL_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), MAYNARD_PANEL_TYPE))
+#define MAYNARD_PANEL_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), MAYNARD_PANEL_TYPE, MaynardPanelClass))
 
-typedef struct WestonGtkPanel WestonGtkPanel;
-typedef struct WestonGtkPanelClass WestonGtkPanelClass;
-typedef struct WestonGtkPanelPrivate WestonGtkPanelPrivate;
+typedef struct MaynardPanel MaynardPanel;
+typedef struct MaynardPanelClass MaynardPanelClass;
+typedef struct MaynardPanelPrivate MaynardPanelPrivate;
 
-struct WestonGtkPanel
+struct MaynardPanel
 {
   GtkWindow parent;
 
-  WestonGtkPanelPrivate *priv;
+  MaynardPanelPrivate *priv;
 };
 
-struct WestonGtkPanelClass
+struct MaynardPanelClass
 {
   GtkWindowClass parent_class;
 };
 
-#define WESTON_GTK_PANEL_WIDTH 56
-#define WESTON_GTK_PANEL_HEIGHT_RATIO 0.73
+#define MAYNARD_PANEL_WIDTH 56
+#define MAYNARD_PANEL_HEIGHT_RATIO 0.73
 
-GType weston_gtk_panel_get_type (void) G_GNUC_CONST;
+GType maynard_panel_get_type (void) G_GNUC_CONST;
 
-GtkWidget * weston_gtk_panel_new (void);
+GtkWidget * maynard_panel_new (void);
 
-void weston_gtk_panel_set_expand (WestonGtkPanel *self, gboolean expand);
+void maynard_panel_set_expand (MaynardPanel *self, gboolean expand);
 
-#endif /* __WESTON_GTK_PANEL_H__ */
+#endif /* __MAYNARD_PANEL_H__ */
diff --git a/shell/sound-applet.c b/shell/sound-applet.c
index 3e5bfbf..4c942eb 100644
--- a/shell/sound-applet.c
+++ b/shell/sound-applet.c
@@ -15,18 +15,18 @@ enum {
   PROP_0,
 };
 
-struct WestonGtkSoundAppletPrivate {
+struct MaynardSoundAppletPrivate {
   GtkWidget *image;
   GtkWidget *scale;
 
   GSettings *settings;
 };
 
-G_DEFINE_TYPE(WestonGtkSoundApplet, weston_gtk_sound_applet, GTK_TYPE_BOX)
+G_DEFINE_TYPE(MaynardSoundApplet, maynard_sound_applet, GTK_TYPE_BOX)
 
 static void
 value_changed_cb (GtkRange *range,
-    WestonGtkSoundApplet *self)
+    MaynardSoundApplet *self)
 {
   GError *error = NULL;
   gdouble value;
@@ -48,21 +48,21 @@ value_changed_cb (GtkRange *range,
 }
 
 static void
-weston_gtk_sound_applet_dispose (GObject *object)
+maynard_sound_applet_dispose (GObject *object)
 {
-  WestonGtkSoundApplet *self = WESTON_GTK_SOUND_APPLET (object);
+  MaynardSoundApplet *self = MAYNARD_SOUND_APPLET (object);
 
   g_clear_object (&self->priv->settings);
 
-  G_OBJECT_CLASS (weston_gtk_sound_applet_parent_class)->dispose (object);
+  G_OBJECT_CLASS (maynard_sound_applet_parent_class)->dispose (object);
 }
 
 static void
-weston_gtk_sound_applet_init (WestonGtkSoundApplet *self)
+maynard_sound_applet_init (MaynardSoundApplet *self)
 {
   self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
-                                            WESTON_GTK_TYPE_SOUND_APPLET,
-                                            WestonGtkSoundAppletPrivate);
+                                            MAYNARD_TYPE_SOUND_APPLET,
+                                            MaynardSoundAppletPrivate);
 
   self->priv->settings = g_settings_new ("org.raspberrypi.maynard");
 
@@ -85,17 +85,17 @@ weston_gtk_sound_applet_init (WestonGtkSoundApplet *self)
 }
 
 static void
-weston_gtk_sound_applet_class_init (WestonGtkSoundAppletClass *klass)
+maynard_sound_applet_class_init (MaynardSoundAppletClass *klass)
 {
   GObjectClass *object_class = (GObjectClass *)klass;
 
-  object_class->dispose = weston_gtk_sound_applet_dispose;
+  object_class->dispose = maynard_sound_applet_dispose;
 
-  g_type_class_add_private (object_class, sizeof (WestonGtkSoundAppletPrivate));
+  g_type_class_add_private (object_class, sizeof (MaynardSoundAppletPrivate));
 }
 
 GtkWidget *
-weston_gtk_sound_applet_new (void)
+maynard_sound_applet_new (void)
 {
-  return g_object_new (WESTON_GTK_TYPE_SOUND_APPLET, NULL);
+  return g_object_new (MAYNARD_TYPE_SOUND_APPLET, NULL);
 }
diff --git a/shell/sound-applet.h b/shell/sound-applet.h
index 0bd9fd6..12fe2d9 100644
--- a/shell/sound-applet.h
+++ b/shell/sound-applet.h
@@ -4,35 +4,35 @@
  * Author: Emilio Pozuelo Monfort <emilio.pozuelo@collabora.co.uk>
  */
 
-#ifndef __WESTON_GTK_SOUND_APPLET_H__
-#define __WESTON_GTK_SOUND_APPLET_H__
+#ifndef __MAYNARD_SOUND_APPLET_H__
+#define __MAYNARD_SOUND_APPLET_H__
 
 #include <gtk/gtk.h>
 
-#define WESTON_GTK_TYPE_SOUND_APPLET                 (weston_gtk_sound_applet_get_type ())
-#define WESTON_GTK_SOUND_APPLET(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), WESTON_GTK_TYPE_SOUND_APPLET, WestonGtkSoundApplet))
-#define WESTON_GTK_SOUND_APPLET_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), WESTON_GTK_TYPE_SOUND_APPLET, WestonGtkSoundAppletClass))
-#define WESTON_GTK_IS_SOUND_APPLET(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), WESTON_GTK_TYPE_SOUND_APPLET))
-#define WESTON_GTK_IS_SOUND_APPLET_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), WESTON_GTK_TYPE_SOUND_APPLET))
-#define WESTON_GTK_SOUND_APPLET_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), WESTON_GTK_TYPE_SOUND_APPLET, WestonGtkSoundAppletClass))
+#define MAYNARD_TYPE_SOUND_APPLET                 (maynard_sound_applet_get_type ())
+#define MAYNARD_SOUND_APPLET(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAYNARD_TYPE_SOUND_APPLET, MaynardSoundApplet))
+#define MAYNARD_SOUND_APPLET_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), MAYNARD_TYPE_SOUND_APPLET, MaynardSoundAppletClass))
+#define MAYNARD_IS_SOUND_APPLET(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MAYNARD_TYPE_SOUND_APPLET))
+#define MAYNARD_IS_SOUND_APPLET_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), MAYNARD_TYPE_SOUND_APPLET))
+#define MAYNARD_SOUND_APPLET_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), MAYNARD_TYPE_SOUND_APPLET, MaynardSoundAppletClass))
 
-typedef struct WestonGtkSoundApplet WestonGtkSoundApplet;
-typedef struct WestonGtkSoundAppletClass WestonGtkSoundAppletClass;
-typedef struct WestonGtkSoundAppletPrivate WestonGtkSoundAppletPrivate;
+typedef struct MaynardSoundApplet MaynardSoundApplet;
+typedef struct MaynardSoundAppletClass MaynardSoundAppletClass;
+typedef struct MaynardSoundAppletPrivate MaynardSoundAppletPrivate;
 
-struct WestonGtkSoundApplet
+struct MaynardSoundApplet
 {
   GtkBox parent;
 
-  WestonGtkSoundAppletPrivate *priv;
+  MaynardSoundAppletPrivate *priv;
 };
 
-struct WestonGtkSoundAppletClass
+struct MaynardSoundAppletClass
 {
   GtkBoxClass parent_class;
 };
 
-GType      weston_gtk_sound_applet_get_type         (void) G_GNUC_CONST;
-GtkWidget *weston_gtk_sound_applet_new              (void);
+GType      maynard_sound_applet_get_type         (void) G_GNUC_CONST;
+GtkWidget *maynard_sound_applet_new              (void);
 
-#endif /* __WESTON_GTK_SOUND_APPLET_H__ */
+#endif /* __MAYNARD_SOUND_APPLET_H__ */
diff --git a/shell/vertical-clock.c b/shell/vertical-clock.c
index 1e30ba7..b09e61f 100644
--- a/shell/vertical-clock.c
+++ b/shell/vertical-clock.c
@@ -13,13 +13,13 @@
 
 #include "panel.h"
 
-struct WestonGtkVerticalClockPrivate {
+struct MaynardVerticalClockPrivate {
   GtkWidget *label;
 
   GnomeWallClock *wall_clock;
 };
 
-G_DEFINE_TYPE(WestonGtkVerticalClock, weston_gtk_vertical_clock, GTK_TYPE_BOX)
+G_DEFINE_TYPE(MaynardVerticalClock, maynard_vertical_clock, GTK_TYPE_BOX)
 
 /* this widget takes up the entire width of the panel and displays
  * padding for the first (panel width - vertical clock width) pixels,
@@ -27,17 +27,17 @@ G_DEFINE_TYPE(WestonGtkVerticalClock, weston_gtk_vertical_clock, GTK_TYPE_BOX)
  * a GtkRevealer and only show it when appropriate. */
 
 static void
-weston_gtk_vertical_clock_init (WestonGtkVerticalClock *self)
+maynard_vertical_clock_init (MaynardVerticalClock *self)
 {
   self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
-      WESTON_GTK_VERTICAL_CLOCK_TYPE,
-      WestonGtkVerticalClockPrivate);
+      MAYNARD_VERTICAL_CLOCK_TYPE,
+      MaynardVerticalClockPrivate);
 }
 
 static void
 wall_clock_notify_cb (GnomeWallClock *wall_clock,
     GParamSpec *pspec,
-    WestonGtkVerticalClock *self)
+    MaynardVerticalClock *self)
 {
   GDateTime *datetime;
   gchar *str;
@@ -55,13 +55,13 @@ wall_clock_notify_cb (GnomeWallClock *wall_clock,
 }
 
 static void
-weston_gtk_vertical_clock_constructed (GObject *object)
+maynard_vertical_clock_constructed (GObject *object)
 {
-  WestonGtkVerticalClock *self = WESTON_GTK_VERTICAL_CLOCK (object);
+  MaynardVerticalClock *self = MAYNARD_VERTICAL_CLOCK (object);
   GtkWidget *padding;
   gint width;
 
-  G_OBJECT_CLASS (weston_gtk_vertical_clock_parent_class)->constructed (object);
+  G_OBJECT_CLASS (maynard_vertical_clock_parent_class)->constructed (object);
 
   self->priv->wall_clock = g_object_new (GNOME_TYPE_WALL_CLOCK, NULL);
   g_signal_connect (self->priv->wall_clock, "notify::clock",
@@ -70,7 +70,7 @@ weston_gtk_vertical_clock_constructed (GObject *object)
   gtk_orientable_set_orientation (GTK_ORIENTABLE (self), GTK_ORIENTATION_HORIZONTAL);
 
   /* a label just to pad things out to the correct width */
-  width = WESTON_GTK_PANEL_WIDTH - WESTON_GTK_VERTICAL_CLOCK_WIDTH;
+  width = MAYNARD_PANEL_WIDTH - MAYNARD_VERTICAL_CLOCK_WIDTH;
 
   padding = gtk_label_new ("");
   gtk_style_context_add_class (gtk_widget_get_style_context (padding),
@@ -84,34 +84,34 @@ weston_gtk_vertical_clock_constructed (GObject *object)
       "wgs-clock");
   gtk_label_set_justify (GTK_LABEL (self->priv->label), GTK_JUSTIFY_CENTER);
   gtk_widget_set_size_request (self->priv->label,
-      WESTON_GTK_VERTICAL_CLOCK_WIDTH, -1);
+      MAYNARD_VERTICAL_CLOCK_WIDTH, -1);
   gtk_box_pack_start (GTK_BOX (self), self->priv->label, FALSE, FALSE, 0);
 
   wall_clock_notify_cb (self->priv->wall_clock, NULL, self);
 }
 
 static void
-weston_gtk_vertical_clock_dispose (GObject *object)
+maynard_vertical_clock_dispose (GObject *object)
 {
-  WestonGtkVerticalClock *self = WESTON_GTK_VERTICAL_CLOCK (object);
+  MaynardVerticalClock *self = MAYNARD_VERTICAL_CLOCK (object);
 
-  G_OBJECT_CLASS (weston_gtk_vertical_clock_parent_class)->dispose (object);
+  G_OBJECT_CLASS (maynard_vertical_clock_parent_class)->dispose (object);
 }
 
 static void
-weston_gtk_vertical_clock_class_init (WestonGtkVerticalClockClass *klass)
+maynard_vertical_clock_class_init (MaynardVerticalClockClass *klass)
 {
   GObjectClass *object_class = (GObjectClass *)klass;
 
-  object_class->constructed = weston_gtk_vertical_clock_constructed;
-  object_class->dispose = weston_gtk_vertical_clock_dispose;
+  object_class->constructed = maynard_vertical_clock_constructed;
+  object_class->dispose = maynard_vertical_clock_dispose;
 
-  g_type_class_add_private (object_class, sizeof (WestonGtkVerticalClockPrivate));
+  g_type_class_add_private (object_class, sizeof (MaynardVerticalClockPrivate));
 }
 
 GtkWidget *
-weston_gtk_vertical_clock_new (void)
+maynard_vertical_clock_new (void)
 {
-  return g_object_new (WESTON_GTK_VERTICAL_CLOCK_TYPE,
+  return g_object_new (MAYNARD_VERTICAL_CLOCK_TYPE,
       NULL);
 }
diff --git a/shell/vertical-clock.h b/shell/vertical-clock.h
index c6c1465..6ad6221 100644
--- a/shell/vertical-clock.h
+++ b/shell/vertical-clock.h
@@ -4,38 +4,38 @@
  * Author: Jonny Lamb <jonny.lamb@collabora.co.uk>
  */
 
-#ifndef __WESTON_GTK_VERTICAL_CLOCK_H__
-#define __WESTON_GTK_VERTICAL_CLOCK_H__
+#ifndef __MAYNARD_VERTICAL_CLOCK_H__
+#define __MAYNARD_VERTICAL_CLOCK_H__
 
 #include <gtk/gtk.h>
 
-#define WESTON_GTK_VERTICAL_CLOCK_TYPE                 (weston_gtk_vertical_clock_get_type ())
-#define WESTON_GTK_VERTICAL_CLOCK(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), WESTON_GTK_VERTICAL_CLOCK_TYPE, WestonGtkVerticalClock))
-#define WESTON_GTK_VERTICAL_CLOCK_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), WESTON_GTK_VERTICAL_CLOCK_TYPE, WestonGtkVerticalClockClass))
-#define WESTON_GTK_IS_VERTICAL_CLOCK(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), WESTON_GTK_VERTICAL_CLOCK_TYPE))
-#define WESTON_GTK_IS_VERTICAL_CLOCK_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), WESTON_GTK_VERTICAL_CLOCK_TYPE))
-#define WESTON_GTK_VERTICAL_CLOCK_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), WESTON_GTK_VERTICAL_CLOCK_TYPE, WestonGtkVerticalClockClass))
+#define MAYNARD_VERTICAL_CLOCK_TYPE                 (maynard_vertical_clock_get_type ())
+#define MAYNARD_VERTICAL_CLOCK(obj)                 (G_TYPE_CHECK_INSTANCE_CAST ((obj), MAYNARD_VERTICAL_CLOCK_TYPE, MaynardVerticalClock))
+#define MAYNARD_VERTICAL_CLOCK_CLASS(klass)         (G_TYPE_CHECK_CLASS_CAST ((klass), MAYNARD_VERTICAL_CLOCK_TYPE, MaynardVerticalClockClass))
+#define MAYNARD_IS_VERTICAL_CLOCK(obj)              (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MAYNARD_VERTICAL_CLOCK_TYPE))
+#define MAYNARD_IS_VERTICAL_CLOCK_CLASS(klass)      (G_TYPE_CHECK_CLASS_TYPE ((klass), MAYNARD_VERTICAL_CLOCK_TYPE))
+#define MAYNARD_VERTICAL_CLOCK_GET_CLASS(obj)       (G_TYPE_INSTANCE_GET_CLASS ((obj), MAYNARD_VERTICAL_CLOCK_TYPE, MaynardVerticalClockClass))
 
-typedef struct WestonGtkVerticalClock WestonGtkVerticalClock;
-typedef struct WestonGtkVerticalClockClass WestonGtkVerticalClockClass;
-typedef struct WestonGtkVerticalClockPrivate WestonGtkVerticalClockPrivate;
+typedef struct MaynardVerticalClock MaynardVerticalClock;
+typedef struct MaynardVerticalClockClass MaynardVerticalClockClass;
+typedef struct MaynardVerticalClockPrivate MaynardVerticalClockPrivate;
 
-struct WestonGtkVerticalClock
+struct MaynardVerticalClock
 {
   GtkBox parent;
 
-  WestonGtkVerticalClockPrivate *priv;
+  MaynardVerticalClockPrivate *priv;
 };
 
-struct WestonGtkVerticalClockClass
+struct MaynardVerticalClockClass
 {
   GtkBoxClass parent_class;
 };
 
-#define WESTON_GTK_VERTICAL_CLOCK_WIDTH 25
+#define MAYNARD_VERTICAL_CLOCK_WIDTH 25
 
-GType weston_gtk_vertical_clock_get_type (void) G_GNUC_CONST;
+GType maynard_vertical_clock_get_type (void) G_GNUC_CONST;
 
-GtkWidget * weston_gtk_vertical_clock_new (void);
+GtkWidget * maynard_vertical_clock_new (void);
 
-#endif /* __WESTON_GTK_VERTICAL_CLOCK_H__ */
+#endif /* __MAYNARD_VERTICAL_CLOCK_H__ */