Use global context

11 files changed, 282 insertions, 294 deletions

diff --git a/src/buffer.c b/src/buffer.c
index 83f48ad..2fa34bb 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -70,7 +70,7 @@ static bool get_shm_fd (int *fd, size_t size)
 		 */
 		if ( errno != EEXIST )
 		{
-			clocklog(NULL, 0, "ERROR: shm_open: %s\n", strerror(errno));
+			clocklog(0, "ERROR: shm_open: %s\n", strerror(errno));
 			return false;
 		}
 	}
@@ -121,7 +121,7 @@ static bool create_buffer (struct wl_shm *shm, struct Wlclock_buffer *buffer,
 					fd, 0)) )
 	{
 		close(fd);
-		clocklog(NULL, 0, "ERROR: mmap: %s\n", strerror(errno));
+		clocklog(0, "ERROR: mmap: %s\n", strerror(errno));
 		return false;
 	}
 
@@ -165,7 +165,7 @@ bool next_buffer (struct Wlclock_buffer **buffer, struct wl_shm *shm,
 		*buffer = &buffers[1];
 	else
 	{
-		clocklog(NULL, 0, "ERROR: All buffers are busy.\n");
+		clocklog(0, "ERROR: All buffers are busy.\n");
 		*buffer = NULL;
 		return false;
 	}
diff --git a/src/colour.c b/src/colour.c
index 8095d69..8a98232 100644
--- a/src/colour.c
+++ b/src/colour.c
@@ -5,6 +5,7 @@
 #include<string.h>
 #include<cairo/cairo.h>
 
+#include"wlclock.h"
 #include"misc.h"
 #include"colour.h"
 
@@ -66,7 +67,7 @@ bool colour_from_string (struct Wlclock_colour *colour, const char *str)
 	return true;
 
 error:
-	clocklog(NULL, 0, "ERROR: \"%s\" is not a valid colour.\n");
+	clocklog(0, "ERROR: \"%s\" is not a valid colour.\n");
 	return false;
 }
 
diff --git a/src/misc.c b/src/misc.c
index 289e00d..5cac695 100644
--- a/src/misc.c
+++ b/src/misc.c
@@ -19,9 +19,9 @@ void set_string (char **ptr, char *arg)
 	*ptr = strdup(arg);
 }
 
-void clocklog (struct Wlclock *clock, int level, const char *fmt, ...)
+void clocklog (int level, const char *fmt, ...)
 {
-	if ( clock != NULL && level > clock->verbosity )
+	if ( level > context.verbosity )
 		return;
 
 	va_list args;
diff --git a/src/misc.h b/src/misc.h
index 477841f..094d308 100644
--- a/src/misc.h
+++ b/src/misc.h
@@ -7,7 +7,7 @@ struct Wlclock;
 
 void free_if_set (void *ptr);
 void set_string (char **ptr, char *arg);
-void clocklog (struct Wlclock *clock, int level, const char *fmt, ...);
+void clocklog (int level, const char *fmt, ...);
 bool is_boolean_true (const char *in);
 bool is_boolean_false (const char *in);
 
diff --git a/src/output.c b/src/output.c
index a6980ae..708c98f 100644
--- a/src/output.c
+++ b/src/output.c
@@ -25,7 +25,7 @@ static void output_handle_scale (void *data, struct wl_output *wl_output,
 {
 	struct Wlclock_output *output = (struct Wlclock_output *)data;
 	output->scale                 = (uint32_t)factor;
-	clocklog(output->clock, 1, "[output] Property update: global_name=%d scale=%d\n",
+	clocklog(1, "[output] Property update: global_name=%d scale=%d\n",
 				output->global_name, output->scale);
 }
 
@@ -36,8 +36,7 @@ static void output_update_surface (struct Wlclock_output *output)
 
 	if ( output->surface == NULL )
 	{
-		struct Wlclock *clock = output->clock;
-		if ( clock->output == NULL || ! strcmp(clock->output, output->name) )
+		if ( context.output == NULL || ! strcmp(context.output, output->name) )
 			create_surface(output);
 	}
 	else
@@ -50,7 +49,7 @@ static void output_handle_done (void *data, struct wl_output *wl_output)
 	 * and by xdg_output) have been advertised by preceding events.
 	 */
 	struct Wlclock_output *output = (struct Wlclock_output *)data;
-	clocklog(output->clock, 1, "[output] Atomic update complete: global_name=%d\n",
+	clocklog(1, "[output] Atomic update complete: global_name=%d\n",
 				output->global_name);
 	output_update_surface(output);
 }
@@ -67,7 +66,7 @@ static void xdg_output_handle_name (void *data, struct zxdg_output_v1 *xdg_outpu
 {
 	struct Wlclock_output *output = (struct Wlclock_output *)data;
 	set_string(&output->name, (char *)name);
-	clocklog(output->clock, 1, "[output] Property update: global_name=%d name=%s\n",
+	clocklog(1, "[output] Property update: global_name=%d name=%s\n",
 				output->global_name, name);
 }
 
@@ -83,14 +82,13 @@ static const struct zxdg_output_v1_listener xdg_output_listener = {
 
 bool configure_output (struct Wlclock_output *output)
 {
-	struct Wlclock *clock = output->clock;
-	clocklog(clock, 1, "[output] Configuring: global_name=%d\n", output->global_name);
+	clocklog(1, "[output] Configuring: global_name=%d\n", output->global_name);
 
 	/* Create xdg_output and attach listeners. */
 	if ( NULL == (output->xdg_output = zxdg_output_manager_v1_get_xdg_output(
-					clock->xdg_output_manager, output->wl_output)) )
+					context.xdg_output_manager, output->wl_output)) )
 	{
-		clocklog(NULL, 0, "ERROR: Could not get XDG output.\n");
+		clocklog(0, "ERROR: Could not get XDG output.\n");
 		return false;
 	}
 
@@ -99,10 +97,10 @@ bool configure_output (struct Wlclock_output *output)
 	return true;
 }
 
-bool create_output (struct Wlclock *clock, struct wl_registry *registry,
-		uint32_t name, const char *interface, uint32_t version)
+bool create_output (struct wl_registry *registry, uint32_t name,
+		const char *interface, uint32_t version)
 {
-	clocklog(clock, 1, "[output] Creating: global_name=%d\n", name);
+	clocklog(1, "[output] Creating: global_name=%d\n", name);
 
 	struct wl_output *wl_output = wl_registry_bind(registry, name,
 			&wl_output_interface, 3);
@@ -111,18 +109,17 @@ bool create_output (struct Wlclock *clock, struct wl_registry *registry,
 	struct Wlclock_output *output = calloc(1, sizeof(struct Wlclock_output));
 	if ( output == NULL )
 	{
-		clocklog(NULL, 0, "ERROR: Could not allocate.\n");
+		clocklog(0, "ERROR: Could not allocate.\n");
 		return false;
 	}
 
-	output->clock       = clock;
 	output->global_name = name;
 	output->scale       = 1;
 	output->wl_output   = wl_output;
 	output->configured  = false;
 	output->name        = NULL;
 
-	wl_list_insert(&clock->outputs, &output->link);
+	wl_list_insert(&context.outputs, &output->link);
 	wl_output_set_user_data(wl_output, output);
 	wl_output_add_listener(wl_output, &output_listener, output);
 
@@ -130,21 +127,21 @@ bool create_output (struct Wlclock *clock, struct wl_registry *registry,
 	 * the layer_shell. If either one is not available yet, we have to
 	 * configure the output later (see init_wayland()).
 	 */
-	if ( clock->xdg_output_manager != NULL && clock->layer_shell != NULL )
+	if ( context.xdg_output_manager != NULL && context.layer_shell != NULL )
 	{
 		if (! configure_output(output))
 			return false;
 	}
 	else
-		clocklog(clock, 2, "[output] Not yet configureable.\n");
+		clocklog(2, "[output] Not yet configureable.\n");
 
 	return true;
 }
 
-struct Wlclock_output *get_output_from_global_name (struct Wlclock *clock, uint32_t name)
+struct Wlclock_output *get_output_from_global_name (uint32_t name)
 {
 	struct Wlclock_output *op;
-	wl_list_for_each(op, &clock->outputs, link)
+	wl_list_for_each(op, &context.outputs, link)
 		if ( op->global_name == name )
 			return op;
 	return NULL;
@@ -161,11 +158,11 @@ void destroy_output (struct Wlclock_output *output)
 	free(output);
 }
 
-void destroy_all_outputs (struct Wlclock *clock)
+void destroy_all_outputs (void)
 {
-	clocklog(clock, 1, "[output] Destroying all outputs.\n");
+	clocklog(1, "[output] Destroying all outputs.\n");
 	struct Wlclock_output *op, *tmp;
-	wl_list_for_each_safe(op, tmp, &clock->outputs, link)
+	wl_list_for_each_safe(op, tmp, &context.outputs, link)
 		destroy_output(op);
 }
 
diff --git a/src/output.h b/src/output.h
index 0085bd7..6212240 100644
--- a/src/output.h
+++ b/src/output.h
@@ -3,13 +3,11 @@
 
 #include<wayland-server.h>
 
-struct Wlclock;
 struct Wlclock_surface;
 
 struct Wlclock_output
 {
 	struct wl_list  link;
-	struct Wlclock *clock;
 
 	struct wl_output      *wl_output;
 	struct zxdg_output_v1 *xdg_output;
@@ -23,11 +21,12 @@ struct Wlclock_output
 	struct Wlclock_surface *surface;
 };
 
-bool create_output (struct Wlclock *clock, struct wl_registry *registry,
+bool create_output (struct wl_registry *registry,
 		uint32_t name, const char *interface, uint32_t version);
 bool configure_output (struct Wlclock_output *output);
-struct Wlclock_output *get_output_from_global_name (struct Wlclock *clock, uint32_t name);
+struct Wlclock_output *get_output_from_global_name (uint32_t name);
 void destroy_output (struct Wlclock_output *output);
-void destroy_all_outputs (struct Wlclock *clock);
+void destroy_all_outputs (void);
 
 #endif
+
diff --git a/src/render.c b/src/render.c
index 975b393..c672c83 100644
--- a/src/render.c
+++ b/src/render.c
@@ -31,11 +31,10 @@ static void rounded_rectangle (cairo_t *cairo, uint32_t x, uint32_t y, uint32_t
 	cairo_close_path(cairo);
 }
 
-static void draw_background (cairo_t *cairo, struct Wlclock_dimensions *dimensions,
-		int32_t scale, struct Wlclock *clock)
+static void draw_background (cairo_t *cairo, struct Wlclock_dimensions *dimensions, int32_t scale)
 {
-	if ( colour_is_transparent(&clock->background_colour)
-			&& colour_is_transparent(&clock->border_colour) )
+	if ( colour_is_transparent(&context.background_colour)
+			&& colour_is_transparent(&context.border_colour) )
 		return;
 
 	int32_t w                   = scale * dimensions->w;
@@ -43,10 +42,10 @@ static void draw_background (cairo_t *cairo, struct Wlclock_dimensions *dimensio
 	int32_t center_x            = scale * dimensions->center_x;
 	int32_t center_y            = scale * dimensions->center_y;
 	int32_t center_size         = scale * dimensions->center_size;
-	int32_t radius_top_left     = scale * clock->radius_top_left;
-	int32_t radius_top_right    = scale * clock->radius_top_right;
-	int32_t radius_bottom_left  = scale * clock->radius_bottom_left;
-	int32_t radius_bottom_right = scale * clock->radius_bottom_right;
+	int32_t radius_top_left     = scale * context.radius_top_left;
+	int32_t radius_top_right    = scale * context.radius_top_right;
+	int32_t radius_bottom_left  = scale * context.radius_bottom_left;
+	int32_t radius_bottom_right = scale * context.radius_bottom_right;
 
 	/* Avoid too radii so big that they cause unexpected drawing behaviour. */
 	if ( radius_top_left > center_size / 2 )
@@ -58,7 +57,7 @@ static void draw_background (cairo_t *cairo, struct Wlclock_dimensions *dimensio
 	if ( radius_bottom_right > center_size / 2 )
 		radius_bottom_right = center_size / 2;
 
-	clocklog(clock, 3, "[render] Render dimensions (scaled): size=%d cx=%d cy=%d w=%d h=%d\n",
+	clocklog(3, "[render] Render dimensions (scaled): size=%d cx=%d cy=%d w=%d h=%d\n",
 			center_size, center_x, center_y, w, h);
 
 	cairo_save(cairo);
@@ -70,17 +69,17 @@ static void draw_background (cairo_t *cairo, struct Wlclock_dimensions *dimensio
 		if ( center_x == 0 && center_y == 0 && center_size == w && center_size == h )
 		{
 			cairo_rectangle(cairo, 0, 0, w, h);
-			colour_set_cairo_source(cairo, &clock->background_colour);
+			colour_set_cairo_source(cairo, &context.background_colour);
 			cairo_fill(cairo);
 		}
 		else
 		{
 			cairo_rectangle(cairo, 0, 0, w, h);
-			colour_set_cairo_source(cairo, &clock->border_colour);
+			colour_set_cairo_source(cairo, &context.border_colour);
 			cairo_fill(cairo);
 
 			cairo_rectangle(cairo, center_x, center_y, center_size, center_size);
-			colour_set_cairo_source(cairo, &clock->background_colour);
+			colour_set_cairo_source(cairo, &context.background_colour);
 			cairo_fill(cairo);
 		}
 	}
@@ -91,7 +90,7 @@ static void draw_background (cairo_t *cairo, struct Wlclock_dimensions *dimensio
 			rounded_rectangle(cairo, 0, 0, w, h,
 					radius_top_left, radius_top_right,
 					radius_bottom_left, radius_bottom_right);
-			colour_set_cairo_source(cairo, &clock->background_colour);
+			colour_set_cairo_source(cairo, &context.background_colour);
 			cairo_fill(cairo);
 		}
 		else
@@ -99,13 +98,13 @@ static void draw_background (cairo_t *cairo, struct Wlclock_dimensions *dimensio
 			rounded_rectangle(cairo, 0, 0, w, h,
 					radius_top_left, radius_top_right,
 					radius_bottom_left, radius_bottom_right);
-			colour_set_cairo_source(cairo, &clock->border_colour);
+			colour_set_cairo_source(cairo, &context.border_colour);
 			cairo_fill(cairo);
 
 			rounded_rectangle(cairo, center_x, center_y, center_size, center_size,
 					radius_top_left, radius_top_right,
 					radius_bottom_left, radius_bottom_right);
-			colour_set_cairo_source(cairo, &clock->background_colour);
+			colour_set_cairo_source(cairo, &context.background_colour);
 			cairo_fill(cairo);
 		}
 	}
@@ -113,13 +112,12 @@ static void draw_background (cairo_t *cairo, struct Wlclock_dimensions *dimensio
 	cairo_restore(cairo);
 }
 
-static void draw_clock_face (cairo_t *cairo, struct Wlclock_dimensions *dimensions,
-		int32_t scale, struct Wlclock *clock)
+static void draw_clock_face (cairo_t *cairo, struct Wlclock_dimensions *dimensions, int32_t scale)
 {
-	if ( clock->marking_width == 0 )
+	if ( context.marking_width == 0 )
 		return;
 
-	/* Radii are choosen to roughly mimic xclock. */
+	/* Radii are choosen to roughly mimic xcontext. */
 	double cx  = scale * (dimensions->center_x + (dimensions->center_size / 2));
 	double cy  = scale * (dimensions->center_y + (dimensions->center_size / 2));
 	double or  = scale * 0.9  * dimensions->center_size / 2;
@@ -137,15 +135,15 @@ static void draw_clock_face (cairo_t *cairo, struct Wlclock_dimensions *dimensio
 		else
 			cairo_line_to(cairo, cx + ir * cos(phi), cy + ir * sin(phi));
 	}
-	cairo_set_line_width(cairo, clock->marking_width * scale);
-	colour_set_cairo_source(cairo, &clock->clock_colour);
+	cairo_set_line_width(cairo, context.marking_width * scale);
+	colour_set_cairo_source(cairo, &context.clock_colour);
 	cairo_stroke(cairo);
 	cairo_restore(cairo);
 }
 
-static void draw_clock_hands (cairo_t *cairo, int32_t size, int32_t scale, struct Wlclock *clock)
+static void draw_clock_hands (cairo_t *cairo, int32_t size, int32_t scale)
 {
-	/* Radii are choosen to roughly mimic xclock. */
+	/* Radii are choosen to roughly mimic xcontext. */
 	double cxy = scale       * size / 2;
 	double mr  = scale * 0.6 * size / 2;
 	double hr  = scale * 0.4 * size / 2;
@@ -158,13 +156,13 @@ static void draw_clock_hands (cairo_t *cairo, int32_t size, int32_t scale, struc
 	double phi_min      = phi_min_step * (tm.tm_min + 45);
 	double phi_h_step   = 2 * PI / 12;
 	double phi_h        = phi_h_step * (tm.tm_hour + 9);
-	if (! clock->snap)
+	if (! context.snap)
 		phi_h += tm.tm_min * phi_h_step / 60.0;
 
 	cairo_save(cairo);
-	colour_set_cairo_source(cairo, &clock->clock_colour);
+	colour_set_cairo_source(cairo, &context.clock_colour);
 
-	if ( clock->hand_width == 0 )
+	if ( context.hand_width == 0 )
 	{
 		/* Xclock-esque clock hands. Not pixel-perfect, but close enough. */
 
@@ -197,7 +195,7 @@ static void draw_clock_hands (cairo_t *cairo, int32_t size, int32_t scale, struc
 		cairo_move_to(cairo, cxy + hr * cos(phi_h), cxy + hr * sin(phi_h));
 		cairo_line_to(cairo, cxy + ir * cos(phi_h + PI), cxy + ir * sin(phi_h +PI));
 
-		cairo_set_line_width(cairo, scale * clock->hand_width);
+		cairo_set_line_width(cairo, scale * context.hand_width);
 		cairo_stroke(cairo);
 	}
 
@@ -215,13 +213,12 @@ static void clear_buffer (cairo_t *cairo)
 void render_background_frame (struct Wlclock_surface *surface)
 {
 	struct Wlclock_output *output = surface->output;
-	struct Wlclock        *clock  = output->clock;
 	uint32_t               scale  = output->scale;
 
-	clocklog(clock, 2, "[render] Render background frame: global_name=%d\n",
+	clocklog(2, "[render] Render background frame: global_name=%d\n",
 			output->global_name);
 
-	if (! next_buffer(&surface->current_background_buffer, clock->shm,
+	if (! next_buffer(&surface->current_background_buffer, context.shm,
 				surface->background_buffers,
 				surface->dimensions.w * scale,
 				surface->dimensions.h * scale))
@@ -231,8 +228,8 @@ void render_background_frame (struct Wlclock_surface *surface)
 	cairo_t *cairo = surface->current_background_buffer->cairo;
 	clear_buffer(cairo);
 
-	draw_background(cairo, &surface->dimensions, scale, clock);
-	draw_clock_face(cairo, &surface->dimensions, scale, clock);
+	draw_background(cairo, &surface->dimensions, scale);
+	draw_clock_face(cairo, &surface->dimensions, scale);
 
 	wl_surface_set_buffer_scale(surface->background_surface, scale);
 	wl_surface_damage_buffer(surface->background_surface, 0, 0, INT32_MAX, INT32_MAX);
@@ -242,13 +239,12 @@ void render_background_frame (struct Wlclock_surface *surface)
 void render_hands_frame (struct Wlclock_surface *surface)
 {
 	struct Wlclock_output *output = surface->output;
-	struct Wlclock        *clock  = output->clock;
 	uint32_t               scale  = output->scale;
 
-	clocklog(clock, 2, "[render] Render hands frame: global_name=%d\n",
+	clocklog(2, "[render] Render hands frame: global_name=%d\n",
 			output->global_name);
 
-	if (! next_buffer(&surface->current_hands_buffer, clock->shm,
+	if (! next_buffer(&surface->current_hands_buffer, context.shm,
 				surface->hands_buffers,
 				surface->dimensions.center_size * scale,
 				surface->dimensions.center_size * scale))
@@ -258,7 +254,7 @@ void render_hands_frame (struct Wlclock_surface *surface)
 	cairo_t *cairo = surface->current_hands_buffer->cairo;
 	clear_buffer(cairo);
 
-	draw_clock_hands(cairo, surface->dimensions.center_size, scale, clock);
+	draw_clock_hands(cairo, surface->dimensions.center_size, scale);
 
 	wl_surface_set_buffer_scale(surface->hands_surface, scale);
 	wl_surface_damage_buffer(surface->hands_surface, 0, 0, INT32_MAX, INT32_MAX);
diff --git a/src/surface.c b/src/surface.c
index 106460a..f736504 100644
--- a/src/surface.c
+++ b/src/surface.c
@@ -26,8 +26,7 @@ static void layer_surface_handle_configure (void *data,
 		uint32_t w, uint32_t h)
 {
 	struct Wlclock_surface *surface = (struct Wlclock_surface *)data;
-	struct Wlclock         *clock   = surface->output->clock;
-	clocklog(clock, 1, "[surface] Layer surface configure request: global_name=%d w=%d h=%d serial=%d\n",
+	clocklog(1, "[surface] Layer surface configure request: global_name=%d w=%d h=%d serial=%d\n",
 			surface->output->global_name, w, h, serial);
 	zwlr_layer_surface_v1_ack_configure(layer_surface, serial);
 	if ( (w != (uint32_t)surface->dimensions.w || h != (uint32_t)surface->dimensions.h)
@@ -37,8 +36,8 @@ static void layer_surface_handle_configure (void *data,
 		 * while also keeping the center square and not changing the
 		 * border sizes.
 		 */
-		int32_t size_a = (int32_t)w - clock->border_left - clock->border_right;
-		int32_t size_b = (int32_t)h - clock->border_top  - clock->border_bottom;
+		int32_t size_a = (int32_t)w - context.border_left - context.border_right;
+		int32_t size_b = (int32_t)h - context.border_top  - context.border_bottom;
 		surface->dimensions.center_size = size_a < size_b ? size_a : size_b;
 		if ( surface->dimensions.center_size < 10 )
 			surface->dimensions.center_size = 10;
@@ -51,8 +50,7 @@ static void layer_surface_handle_configure (void *data,
 static void layer_surface_handle_closed (void *data, struct zwlr_layer_surface_v1 *layer_surface)
 {
 	struct Wlclock_surface *surface = (struct Wlclock_surface *)data;
-	clocklog(surface->output->clock, 1,
-			"[surface] Layer surface has been closed: global_name=%d\n",
+	clocklog(1, "[surface] Layer surface has been closed: global_name=%d\n",
 			surface->output->global_name);
 	destroy_surface(surface);
 }
@@ -64,8 +62,7 @@ const struct zwlr_layer_surface_v1_listener layer_surface_listener = {
 
 static int32_t get_exclusive_zone (struct Wlclock_surface *surface)
 {
-	struct Wlclock *clock = surface->output->clock;
-	if ( clock->exclusive_zone == 1 ) switch (clock->anchor)
+	if ( context.exclusive_zone == 1 ) switch (context.anchor)
 	{
 		case ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM:
 		case ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP:
@@ -79,36 +76,35 @@ static int32_t get_exclusive_zone (struct Wlclock_surface *surface)
 			return 0;
 	}
 	else
-		return surface->output->clock->exclusive_zone;
+		return context.exclusive_zone;
 }
 
 static void configure_subsurface (struct Wlclock_surface *surface)
 {
-	clocklog(surface->output->clock, 1, "[surface] Configuring sub surface: global_name=%d\n",
+	clocklog(1, "[surface] Configuring sub surface: global_name=%d\n",
 			surface->output->global_name);
 	wl_subsurface_set_position(surface->subsurface,
 			surface->dimensions.center_x, surface->dimensions.center_y);
-	struct wl_region *region = wl_compositor_create_region(surface->output->clock->compositor);
+	struct wl_region *region = wl_compositor_create_region(context.compositor);
 	wl_surface_set_input_region(surface->hands_surface, region);
 	wl_region_destroy(region);
 }
 
 static void configure_layer_surface (struct Wlclock_surface *surface)
 {
-	struct Wlclock *clock = surface->output->clock;
-	clocklog(clock, 1, "[surface] Configuring layer surface: global_name=%d\n",
+	clocklog(1, "[surface] Configuring layer surface: global_name=%d\n",
 			surface->output->global_name);
 	zwlr_layer_surface_v1_set_size(surface->layer_surface,
 			surface->dimensions.w, surface->dimensions.h);
-	zwlr_layer_surface_v1_set_anchor(surface->layer_surface, clock->anchor);
+	zwlr_layer_surface_v1_set_anchor(surface->layer_surface, context.anchor);
 	zwlr_layer_surface_v1_set_margin(surface->layer_surface,
-			clock->margin_top, clock->margin_right,
-			clock->margin_bottom, clock->margin_left);
+			context.margin_top, context.margin_right,
+			context.margin_bottom, context.margin_left);
 	zwlr_layer_surface_v1_set_exclusive_zone(surface->layer_surface,
 			get_exclusive_zone(surface));
-	if (! clock->input)
+	if (! context.input)
 	{
-		struct wl_region *region = wl_compositor_create_region(clock->compositor);
+		struct wl_region *region = wl_compositor_create_region(context.compositor);
 		wl_surface_set_input_region(surface->background_surface, region);
 		wl_region_destroy(region);
 	}
@@ -116,50 +112,49 @@ static void configure_layer_surface (struct Wlclock_surface *surface)
 
 bool create_surface (struct Wlclock_output *output)
 {
-	struct Wlclock *clock = output->clock;
-	clocklog(clock, 1, "[surface] Creating surface: global_name=%d\n", output->global_name);
+	clocklog(1, "[surface] Creating surface: global_name=%d\n", output->global_name);
 
 	struct Wlclock_surface *surface = calloc(1, sizeof(struct Wlclock_surface));
 	if ( surface == NULL )
 	{
-		clocklog(NULL, 0, "ERROR: Could not allocate.\n");
+		clocklog(0, "ERROR: Could not allocate.\n");
 		return false;
 	}
 
 	output->surface             = surface;
-	surface->dimensions         = clock->dimensions;
+	surface->dimensions         = context.dimensions;
 	surface->output             = output;
 	surface->background_surface = NULL;
 	surface->hands_surface      = NULL;
 	surface->layer_surface      = NULL;
 	surface->configured         = false;
 
-	if ( NULL == (surface->background_surface = wl_compositor_create_surface(clock->compositor)) )
+	if ( NULL == (surface->background_surface = wl_compositor_create_surface(context.compositor)) )
 	{
-		clocklog(NULL, 0, "ERROR: Compositor did not create wl_surface (background).\n");
+		clocklog(0, "ERROR: Compositor did not create wl_surface (background).\n");
 		return false;
 	}
 	if ( NULL == (surface->layer_surface = zwlr_layer_shell_v1_get_layer_surface(
-					clock->layer_shell, surface->background_surface,
-					output->wl_output, clock->layer,
-					clock->namespace)) )
+					context.layer_shell, surface->background_surface,
+					output->wl_output, context.layer,
+					context.namespace)) )
 	{
-		clocklog(NULL, 0, "ERROR: Compositor did not create layer_surface.\n");
+		clocklog(0, "ERROR: Compositor did not create layer_surface.\n");
 		return false;
 	}
 	zwlr_layer_surface_v1_add_listener(surface->layer_surface,
 			&layer_surface_listener, surface);
 
-	if ( NULL == (surface->hands_surface = wl_compositor_create_surface(clock->compositor)) )
+	if ( NULL == (surface->hands_surface = wl_compositor_create_surface(context.compositor)) )
 	{
-		clocklog(NULL, 0, "ERROR: Compositor did not create wl_surface (hands).\n");
+		clocklog(0, "ERROR: Compositor did not create wl_surface (hands).\n");
 		return false;
 	}
 	if ( NULL == (surface->subsurface = wl_subcompositor_get_subsurface(
-					clock->subcompositor, surface->hands_surface,
+					context.subcompositor, surface->hands_surface,
 					surface->background_surface)) )
 	{
-		clocklog(NULL, 0, "ERROR: Compositor did not create wl_subsurface.\n");
+		clocklog(0, "ERROR: Compositor did not create wl_subsurface.\n");
 		return false;
 	}
 
@@ -204,11 +199,11 @@ void update_surface (struct Wlclock_surface *surface)
 	wl_surface_commit(surface->background_surface);
 }
 
-void update_all_hands (struct Wlclock *clock)
+void update_all_hands (void)
 {
-	clocklog(clock, 1, "[surface] Updating all hands.\n");
+	clocklog(1, "[surface] Updating all hands.\n");
 	struct Wlclock_output *op, *tmp;
-	wl_list_for_each_safe(op, tmp, &clock->outputs, link)
+	wl_list_for_each_safe(op, tmp, &context.outputs, link)
 		if ( op->surface != NULL )
 		{
 			render_hands_frame(op->surface);
diff --git a/src/surface.h b/src/surface.h
index 9d36f69..716697f 100644
--- a/src/surface.h
+++ b/src/surface.h
@@ -9,7 +9,6 @@
 #include<stdint.h>
 #include<stdbool.h>
 
-struct Wlclock;
 struct Wlclock_output;
 
 struct Wlclock_surface
@@ -31,6 +30,6 @@ struct Wlclock_surface
 bool create_surface (struct Wlclock_output *output);
 void destroy_surface (struct Wlclock_surface *surface);
 void update_surface (struct Wlclock_surface *surface);
-void update_all_hands (struct Wlclock *clock);
+void update_all_hands (void);
 
 #endif
diff --git a/src/wlclock.c b/src/wlclock.c
index 3aed505..7257f3d 100644
--- a/src/wlclock.c
+++ b/src/wlclock.c
@@ -25,55 +25,54 @@
 #include"surface.h"
 #include"colour.h"
 
+struct Wlclock_context context = {0};
+
 static void registry_handle_global (void *data, struct wl_registry *registry,
 		uint32_t name, const char *interface, uint32_t version)
 {
-	struct Wlclock *clock = (struct Wlclock *)data;
-
 	if (! strcmp(interface, wl_compositor_interface.name))
 	{
-		clocklog(clock, 2, "[main] Get wl_compositor.\n");
-		clock->compositor = wl_registry_bind(registry, name, &wl_compositor_interface, 4);
+		clocklog(2, "[main] Get wl_compositor.\n");
+		context.compositor = wl_registry_bind(registry, name, &wl_compositor_interface, 4);
 	}
 	if (! strcmp(interface, wl_subcompositor_interface.name))
 	{
-		clocklog(clock, 2, "[main] Get wl_subcompositor.\n");
-		clock->subcompositor = wl_registry_bind(registry, name,
+		clocklog(2, "[main] Get wl_subcompositor.\n");
+		context.subcompositor = wl_registry_bind(registry, name,
 				&wl_subcompositor_interface, 1);
 	}
 	else if (! strcmp(interface, wl_shm_interface.name))
 	{
-		clocklog(clock, 2, "[main] Get wl_shm.\n");
-		clock->shm = wl_registry_bind(registry, name, &wl_shm_interface, 1);
+		clocklog(2, "[main] Get wl_shm.\n");
+		context.shm = wl_registry_bind(registry, name, &wl_shm_interface, 1);
 	}
 	else if (! strcmp(interface, zwlr_layer_shell_v1_interface.name))
 	{
-		clocklog(clock, 2, "[main] Get zwlr_layer_shell_v1.\n");
-		clock->layer_shell = wl_registry_bind(registry, name, &zwlr_layer_shell_v1_interface, 1);
+		clocklog(2, "[main] Get zwlr_layer_shell_v1.\n");
+		context.layer_shell = wl_registry_bind(registry, name, &zwlr_layer_shell_v1_interface, 1);
 	}
 	else if (! strcmp(interface, zxdg_output_manager_v1_interface.name))
 	{
-		clocklog(clock, 2, "[main] Get zxdg_output_manager_v1.\n");
-		clock->xdg_output_manager = wl_registry_bind(registry, name, &zxdg_output_manager_v1_interface, 3);
+		clocklog(2, "[main] Get zxdg_output_manager_v1.\n");
+		context.xdg_output_manager = wl_registry_bind(registry, name, &zxdg_output_manager_v1_interface, 3);
 	}
 	else if (! strcmp(interface, wl_output_interface.name))
 	{
-		if (! create_output(data, registry, name, interface, version))
+		if (! create_output(registry, name, interface, version))
 			goto error;
 	}
 
 	return;
 error:
-	clock->loop = false;
-	clock->ret  = EXIT_FAILURE;
+	context.loop = false;
+	context.ret  = EXIT_FAILURE;
 }
 
 static void registry_handle_global_remove (void *data,
 		struct wl_registry *registry, uint32_t name)
 {
-	struct Wlclock *clock = (struct Wlclock *)data;
-	clocklog(clock, 1, "[main] Global remove.\n");
-	destroy_output(get_output_from_global_name(clock, name));
+	clocklog(1, "[main] Global remove.\n");
+	destroy_output(get_output_from_global_name(name));
 }
 
 static const struct wl_registry_listener registry_listener = {
@@ -86,51 +85,51 @@ static bool capability_test (void *ptr, const char *name)
 {
 	if ( ptr != NULL )
 		return true;
-	clocklog(NULL, 0, "ERROR: Wayland compositor does not support %s.\n", name);
+	clocklog(0, "ERROR: Wayland compositor does not support %s.\n", name);
 	return false;
 }
 
-static bool init_wayland (struct Wlclock *clock)
+static bool init_wayland (void)
 {
-	clocklog(clock, 1, "[main] Init Wayland.\n");
+	clocklog(1, "[main] Init Wayland.\n");
 
 	/* Connect to Wayland server. */
-	clocklog(clock, 2, "[main] Connecting to server.\n");
-	if ( NULL == (clock->display = wl_display_connect(NULL)) )
+	clocklog(2, "[main] Connecting to server.\n");
+	if ( NULL == (context.display = wl_display_connect(NULL)) )
 	{
-		clocklog(NULL, 0, "ERROR: Can not connect to a Wayland server.\n");
+		clocklog(0, "ERROR: Can not connect to a Wayland server.\n");
 		return false;
 	}
 
 	/* Get registry and add listeners. */
-	clocklog(clock, 2, "[main] Get wl_registry.\n");
-	if ( NULL == (clock->registry = wl_display_get_registry(clock->display)) )
+	clocklog(2, "[main] Get wl_registry.\n");
+	if ( NULL == (context.registry = wl_display_get_registry(context.display)) )
 	{
-		clocklog(NULL, 0, "ERROR: Can not get registry.\n");
+		clocklog(0, "ERROR: Can not get registry.\n");
 		return false;
 	}
-	wl_registry_add_listener(clock->registry, &registry_listener, clock);
+	wl_registry_add_listener(context.registry, &registry_listener, NULL);
 
 	/* Allow registry listeners to catch up. */
-	if ( wl_display_roundtrip(clock->display) == -1 )
+	if ( wl_display_roundtrip(context.display) == -1 )
 	{
-		clocklog(NULL, 0, "ERROR: Roundtrip failed.\n");
+		clocklog(0, "ERROR: Roundtrip failed.\n");
 		return false;
 	}
 
 	/* Testing compatibilities. */
-	if (! capability_test(clock->compositor, "wl_compositor"))
+	if (! capability_test(context.compositor, "wl_compositor"))
 		return false;
-	if (! capability_test(clock->shm, "wl_shm"))
+	if (! capability_test(context.shm, "wl_shm"))
 		return false;
-	if (! capability_test(clock->layer_shell, "zwlr_layer_shell"))
+	if (! capability_test(context.layer_shell, "zwlr_layer_shell"))
 		return false;
-	if (! capability_test(clock->xdg_output_manager, "xdg_output_manager"))
+	if (! capability_test(context.xdg_output_manager, "xdg_output_manager"))
 		return false;
 
-	clocklog(clock, 2, "[main] Catching up on output configuration.\n");
+	clocklog(2, "[main] Catching up on output configuration.\n");
 	struct Wlclock_output *op;
-	wl_list_for_each(op, &clock->outputs, link)
+	wl_list_for_each(op, &context.outputs, link)
 		if ( ! op->configured && ! configure_output(op) )
 			return false;
 
@@ -138,27 +137,27 @@ static bool init_wayland (struct Wlclock *clock)
 }
 
 /* Finish him! */
-static void finish_wayland (struct Wlclock *clock)
+static void finish_wayland (void)
 {
-	if ( clock->display == NULL )
+	if ( context.display == NULL )
 		return;
 
-	clocklog(clock, 1, "[main] Finish Wayland.\n");
+	clocklog(1, "[main] Finish Wayland.\n");
 
-	destroy_all_outputs(clock);
+	destroy_all_outputs();
 
-	clocklog(clock, 2, "[main] Destroying Wayland objects.\n");
-	if ( clock->layer_shell != NULL )
-		zwlr_layer_shell_v1_destroy(clock->layer_shell);
-	if ( clock->compositor != NULL )
-		wl_compositor_destroy(clock->compositor);
-	if ( clock->shm != NULL )
-		wl_shm_destroy(clock->shm);
-	if ( clock->registry != NULL )
-		wl_registry_destroy(clock->registry);
+	clocklog(2, "[main] Destroying Wayland objects.\n");
+	if ( context.layer_shell != NULL )
+		zwlr_layer_shell_v1_destroy(context.layer_shell);
+	if ( context.compositor != NULL )
+		wl_compositor_destroy(context.compositor);
+	if ( context.shm != NULL )
+		wl_shm_destroy(context.shm);
+	if ( context.registry != NULL )
+		wl_registry_destroy(context.registry);
 
-	clocklog(clock, 2, "[main] Diconnecting from server.\n");
-	wl_display_disconnect(clock->display);
+	clocklog(2, "[main] Diconnecting from server.\n");
+	wl_display_disconnect(context.display);
 }
 
 static int count_args (int index, int argc, char *argv[])
@@ -175,7 +174,7 @@ static int count_args (int index, int argc, char *argv[])
 	return args;
 }
 
-static bool handle_command_flags (struct Wlclock *clock, int argc, char *argv[])
+static bool handle_command_flags (int argc, char *argv[])
 {
 	enum
 	{
@@ -239,8 +238,8 @@ static bool handle_command_flags (struct Wlclock *clock, int argc, char *argv[])
 		"      --namespace          Namespace of the layer surface.\n"
 		"      --no-input           Let inputs surface pass trough the layer surface.\n"
 		"      --output             The output which the clock will be displayed.\n"
-		"      --position           Set the position of the clock.\n"
-		"      --size               Size of the clock.\n"
+		"      --position           Set the position of the context.\n"
+		"      --size               Size of the context.\n"
 		"      --snap               Let the hour hand snap to the next position instead of slowly progressing.\n"
 		"\n";
 
@@ -251,44 +250,44 @@ static bool handle_command_flags (struct Wlclock *clock, int argc, char *argv[])
 	{
 		case 'h':
 			fputs(usage, stderr);
-			clock->ret = EXIT_SUCCESS;
+			context.ret = EXIT_SUCCESS;
 			return false;
 
 		case 'v':
-			clock->verbosity++;
+			context.verbosity++;
 			break;
 
 		case 'V':
 			fputs("wlclock version " VERSION "\n", stderr);
-			clock->ret = EXIT_SUCCESS;
+			context.ret = EXIT_SUCCESS;
 			return false;
 
 		case POSITION:
 			if (! strcmp(optarg, "center"))
-				clock->anchor = 0;
+				context.anchor = 0;
 			else if (! strcmp(optarg, "top"))
-				clock->anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP;
+				context.anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP;
 			else if (! strcmp(optarg, "right"))
-				clock->anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT;
+				context.anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT;
 			else if (! strcmp(optarg, "bottom"))
-				clock->anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
+				context.anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
 			else if (! strcmp(optarg, "left"))
-				clock->anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT;
+				context.anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT;
 			else if (! strcmp(optarg, "top-left"))
-				clock->anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP
+				context.anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP
 					| ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT;
 			else if (! strcmp(optarg, "top-right"))
-				clock->anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP
+				context.anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP
 					| ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT;
 			else if (! strcmp(optarg, "bottom-left"))
-				clock->anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM
+				context.anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM
 					| ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT;
 			else if (! strcmp(optarg, "bottom-right"))
-				clock->anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM
+				context.anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM
 					| ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT;
 			else
 			{
-				clocklog(NULL, 0, "ERROR: Unrecognized position \"%s\".\n"
+				clocklog(0, "ERROR: Unrecognized position \"%s\".\n"
 						"INFO: Possible positisions are 'center', "
 						"'top', 'right', 'bottom', 'left', "
 						"'top-right', 'top-left', 'bottom-right', 'bottom-left'.\n",
@@ -299,76 +298,76 @@ static bool handle_command_flags (struct Wlclock *clock, int argc, char *argv[])
 			break;
 
 		case BACKGROUND_COLOUR:
-			if (! colour_from_string(&clock->background_colour, optarg))
+			if (! colour_from_string(&context.background_colour, optarg))
 				return false;
 			break;
 
 		case BORDER_COLOUR:
-			if (! colour_from_string(&clock->border_colour, optarg))
+			if (! colour_from_string(&context.border_colour, optarg))
 				return false;
 			break;
 
 		case BORDER_SIZE:
 			args = count_args(optind, argc, argv);
 			if ( args == 1 )
-				clock->border_top = clock->border_right =
-					clock->border_bottom = clock->border_left =
+				context.border_top = context.border_right =
+					context.border_bottom = context.border_left =
 					atoi(optarg);
 			else if ( args == 4 )
 			{
-				clock->border_top    = atoi(argv[optind-1]);
-				clock->border_right  = atoi(argv[optind]);
-				clock->border_bottom = atoi(argv[optind+1]);
-				clock->border_left   = atoi(argv[optind+2]);
+				context.border_top    = atoi(argv[optind-1]);
+				context.border_right  = atoi(argv[optind]);
+				context.border_bottom = atoi(argv[optind+1]);
+				context.border_left   = atoi(argv[optind+2]);
 				optind += 3; /* Tell getopt() to skip three argv fields. */
 			}
 			else
 			{
-				clocklog(NULL, 0, "ERROR: Border configuration "
+				clocklog(0, "ERROR: Border configuration "
 						"requires one or four arguments.\n");
 				return false;
 			}
-			if ( clock->border_top < 0 || clock->border_right < 0
-					|| clock->border_bottom < 0 || clock->border_left < 0 )
+			if ( context.border_top < 0 || context.border_right < 0
+					|| context.border_bottom < 0 || context.border_left < 0 )
 			{
-				clocklog(NULL, 0, "ERROR: Borders may not be smaller than zero.\n");
+				clocklog(0, "ERROR: Borders may not be smaller than zero.\n");
 				return false;
 			}
 			break;
 
 		case CLOCK_COLOUR:
-			if (! colour_from_string(&clock->clock_colour, optarg))
+			if (! colour_from_string(&context.clock_colour, optarg))
 				return false;
 			break;
 
 		case MARKING_WIDTH:
-			clock->marking_width = atoi(optarg);
-			if ( clock->marking_width < 0 )
+			context.marking_width = atoi(optarg);
+			if ( context.marking_width < 0 )
 			{
-				clocklog(NULL, 0, "ERROR: Marking width may not be smaller than zero.\n");
+				clocklog(0, "ERROR: Marking width may not be smaller than zero.\n");
 				return false;
 			}
 			break;
 
 		case HAND_WIDTH:
-			clock->hand_width = atoi(optarg);
-			if ( clock->hand_width < 0 )
+			context.hand_width = atoi(optarg);
+			if ( context.hand_width < 0 )
 			{
-				clocklog(NULL, 0, "ERROR: Hand width may not be smaller than zero.\n");
+				clocklog(0, "ERROR: Hand width may not be smaller than zero.\n");
 				return false;
 			}
 			break;
 
 		case EXCLUSIVE_ZONE:
 			if (is_boolean_true(optarg))
-				clock->exclusive_zone = 1;
+				context.exclusive_zone = 1;
 			else if (is_boolean_false(optarg))
-				clock->exclusive_zone = 0;
+				context.exclusive_zone = 0;
 			else if (! strcmp(optarg, "stationary"))
-				clock->exclusive_zone = -1;
+				context.exclusive_zone = -1;
 			else
 			{
-				clocklog(NULL, 0, "ERROR: Unrecognized exclusive zone option \"%s\".\n"
+				clocklog(0, "ERROR: Unrecognized exclusive zone option \"%s\".\n"
 						"INFO: Possible options are 'true', "
 						"'false' and 'stationary'.\n", optarg);
 				return false;
@@ -377,16 +376,16 @@ static bool handle_command_flags (struct Wlclock *clock, int argc, char *argv[])
 
 		case LAYER:
 			if (! strcmp(optarg, "overlay"))
-				clock->layer = ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY;
+				context.layer = ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY;
 			else if (! strcmp(optarg, "top"))
-				clock->layer = ZWLR_LAYER_SHELL_V1_LAYER_TOP;
+				context.layer = ZWLR_LAYER_SHELL_V1_LAYER_TOP;
 			else if (! strcmp(optarg, "bottom"))
-				clock->layer = ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM;
+				context.layer = ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM;
 			else if (! strcmp(optarg, "background"))
-				clock->layer = ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND;
+				context.layer = ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND;
 			else
 			{
-				clocklog(NULL, 0, "ERROR: Unrecognized layer \"%s\".\n"
+				clocklog(0, "ERROR: Unrecognized layer \"%s\".\n"
 						"INFO: Possible layers are 'overlay', "
 						"'top', 'bottom', and 'background'.\n", optarg);
 				return false;
@@ -396,84 +395,84 @@ static bool handle_command_flags (struct Wlclock *clock, int argc, char *argv[])
 		case MARGIN:
 			args = count_args(optind, argc, argv);
 			if ( args == 1 )
-				clock->margin_top = clock->margin_right =
-					clock->margin_bottom = clock->margin_left =
+				context.margin_top = context.margin_right =
+					context.margin_bottom = context.margin_left =
 					atoi(optarg);
 			else if ( args == 4 )
 			{
-				clock->margin_top    = atoi(argv[optind-1]);
-				clock->margin_right  = atoi(argv[optind]);
-				clock->margin_bottom = atoi(argv[optind+1]);
-				clock->margin_left   = atoi(argv[optind+2]);
+				context.margin_top    = atoi(argv[optind-1]);
+				context.margin_right  = atoi(argv[optind]);
+				context.margin_bottom = atoi(argv[optind+1]);
+				context.margin_left   = atoi(argv[optind+2]);
 				optind += 3; /* Tell getopt() to skip three argv fields. */
 			}
 			else
 			{
-				clocklog(NULL, 0, "ERROR: Margin configuration "
+				clocklog(0, "ERROR: Margin configuration "
 						"requires one or four arguments.\n");
 				return false;
 			}
-			if ( clock->margin_top < 0 || clock->margin_right < 0
-					|| clock->margin_bottom < 0 || clock->margin_left < 0 )
+			if ( context.margin_top < 0 || context.margin_right < 0
+					|| context.margin_bottom < 0 || context.margin_left < 0 )
 			{
-				clocklog(NULL, 0, "ERROR: Margins may not be smaller than zero.\n");
+				clocklog(0, "ERROR: Margins may not be smaller than zero.\n");
 				return false;
 			}
 			break;
 
 		case NAMEPSACE:
-			set_string(&clock->namespace, optarg);
+			set_string(&context.namespace, optarg);
 			break;
 
 		case NO_INPUT:
-			clock->input = false;
+			context.input = false;
 			break;
 
 		case SNAP:
-			clock->snap = true;
+			context.snap = true;
 			break;
 
 		case OUTPUT:
 			if ( ! strcmp("all", optarg) || ! strcmp("*", optarg) )
-				free_if_set(clock->output);
+				free_if_set(context.output);
 			else
-				set_string(&clock->output, optarg);
+				set_string(&context.output, optarg);
 			break;
 
 		case CORNER_RADIUS:
 			args = count_args(optind, argc, argv);
 			if ( args == 1 )
-				clock->radius_top_left = clock->radius_top_right =
-					clock->radius_bottom_right = clock->radius_bottom_left =
+				context.radius_top_left = context.radius_top_right =
+					context.radius_bottom_right = context.radius_bottom_left =
 					atoi(optarg);
 			else if ( args == 4 )
 			{
-				clock->radius_top_left     = atoi(argv[optind-1]);
-				clock->radius_top_right    = atoi(argv[optind]);
-				clock->radius_bottom_right = atoi(argv[optind+1]);
-				clock->radius_bottom_left  = atoi(argv[optind+2]);
+				context.radius_top_left     = atoi(argv[optind-1]);
+				context.radius_top_right    = atoi(argv[optind]);
+				context.radius_bottom_right = atoi(argv[optind+1]);
+				context.radius_bottom_left  = atoi(argv[optind+2]);
 				optind += 3; /* Tell getopt() to skip three argv fields. */
 			}
 			else
 			{
-				clocklog(NULL, 0, "ERROR: Radius configuration "
+				clocklog(0, "ERROR: Radius configuration "
 						"requires one or four arguments.\n");
 				return false;
 			}
-			if ( clock->radius_top_left < 0 || clock->radius_top_right < 0
-					|| clock->radius_bottom_right < 0 || clock->radius_bottom_left < 0 )
+			if ( context.radius_top_left < 0 || context.radius_top_right < 0
+					|| context.radius_bottom_right < 0 || context.radius_bottom_left < 0 )
 			{
-				clocklog(NULL, 0, "ERROR: Radii may not be smaller than zero.\n");
+				clocklog(0, "ERROR: Radii may not be smaller than zero.\n");
 				return false;
 			}
 			break;
 
 		case SIZE:
-			clock->dimensions.center_size = atoi(optarg);
-			if ( clock->dimensions.center_size <= 10 )
+			context.dimensions.center_size = atoi(optarg);
+			if ( context.dimensions.center_size <= 10 )
 			{
-				clocklog(NULL, 0, "ERROR: Unreasonably small size \"%d\".\n",
-						clock->dimensions.center_size);
+				clocklog(0, "ERROR: Unreasonably small size \"%d\".\n",
+						context.dimensions.center_size);
 				return false;
 			}
 			break;
@@ -492,10 +491,10 @@ static time_t get_timeout (void)
 	return ((now / 60 * 60 ) + 60 - now) * 1000;
 }
 
-static void clock_run (struct Wlclock *clock)
+static void clock_run ()
 {
-	clocklog(clock, 1, "[main] Starting loop.\n");
-	clock->ret = EXIT_SUCCESS;
+	clocklog(1, "[main] Starting loop.\n");
+	context.ret = EXIT_SUCCESS;
 
 	struct pollfd fds[2] = { 0 };
 	size_t wayland_fd = 0;
@@ -507,9 +506,9 @@ static void clock_run (struct Wlclock *clock)
 #endif
 
 	fds[wayland_fd].events = POLLIN;
-	if ( -1 ==  (fds[wayland_fd].fd = wl_display_get_fd(clock->display)) )
+	if ( -1 ==  (fds[wayland_fd].fd = wl_display_get_fd(context.display)) )
 	{
-		clocklog(NULL, 0, "ERROR: Unable to open Wayland display fd.\n");
+		clocklog(0, "ERROR: Unable to open Wayland display fd.\n");
 		goto error;
 	}
 
@@ -524,26 +523,26 @@ static void clock_run (struct Wlclock *clock)
 	sigaddset(&mask, SIGUSR2);
 	if ( sigprocmask(SIG_BLOCK, &mask, NULL) == -1 )
 	{
-		clocklog(NULL, 0, "ERROR: sigprocmask() failed.\n");
+		clocklog(0, "ERROR: sigprocmask() failed.\n");
 		goto error;
 	}
 	fds[signal_fd].events = POLLIN;
 	if ( -1 ==  (fds[signal_fd].fd = signalfd(-1, &mask, 0)) )
 	{
-		clocklog(NULL, 0, "ERROR: Unable to open signal fd.\n"
+		clocklog(0, "ERROR: Unable to open signal fd.\n"
 				"ERROR: signalfd: %s\n", strerror(errno));
 		goto error;
 	}
 #endif
 
-	while (clock->loop)
+	while (context.loop)
 	{
 		/* Flush Wayland events. */
 		errno = 0;
 		do {
-			if ( wl_display_flush(clock->display) == 1 && errno != EAGAIN )
+			if ( wl_display_flush(context.display) == 1 && errno != EAGAIN )
 			{
-				clocklog(NULL, 0, "ERROR: wl_display_flush: %s\n",
+				clocklog(0, "ERROR: wl_display_flush: %s\n",
 						strerror(errno));
 				break;
 			}
@@ -553,24 +552,24 @@ static void clock_run (struct Wlclock *clock)
 
 		if ( ret == 0 ) /* Timeout -> update clock hands. */
 		{
-			update_all_hands(clock);
+			update_all_hands();
 			continue;
 		}
 		else if ( ret < 0 )
 		{
-			clocklog(NULL, 0, "ERROR: poll: %s\n", strerror(errno));
+			clocklog(0, "ERROR: poll: %s\n", strerror(errno));
 			continue;
 		}
 	
 		/* Wayland events */
-		if ( fds[wayland_fd].revents & POLLIN && wl_display_dispatch(clock->display) == -1 )
+		if ( fds[wayland_fd].revents & POLLIN && wl_display_dispatch(context.display) == -1 )
 		{
-			clocklog(NULL, 0, "ERROR: wl_display_flush: %s\n", strerror(errno));
+			clocklog(0, "ERROR: wl_display_flush: %s\n", strerror(errno));
 			goto error;
 		}
-		if ( fds[wayland_fd].revents & POLLOUT && wl_display_flush(clock->display) == -1 )
+		if ( fds[wayland_fd].revents & POLLOUT && wl_display_flush(context.display) == -1 )
 		{
-			clocklog(NULL, 0, "ERROR: wl_display_flush: %s\n", strerror(errno));
+			clocklog(0, "ERROR: wl_display_flush: %s\n", strerror(errno));
 			goto error;
 		}
 
@@ -581,24 +580,24 @@ static void clock_run (struct Wlclock *clock)
 			if ( read(fds[signal_fd].fd, &fdsi, sizeof(struct signalfd_siginfo))
 					!= sizeof(struct signalfd_siginfo) )
 			{
-				clocklog(NULL, 0, "ERROR: Can not read signal info.\n");
+				clocklog(0, "ERROR: Can not read signal info.\n");
 				goto error;
 			}
 
 			if ( fdsi.ssi_signo == SIGINT || fdsi.ssi_signo == SIGQUIT || fdsi.ssi_signo == SIGTERM )
 			{
-				clocklog(clock, 1, "[main] Received SIGINT, SIGQUIT or SIGTERM; Exiting.\n");
+				clocklog(1, "[main] Received SIGINT, SIGQUIT or SIGTERM; Exiting.\n");
 				goto exit;
 			}
 			else if ( fdsi.ssi_signo == SIGUSR1 || fdsi.ssi_signo == SIGUSR2 )
-				clocklog(clock, 1, "[main] Received SIGUSR; Ignoring.\n");
+				clocklog(1, "[main] Received SIGUSR; Ignoring.\n");
 		}
 #endif
 	}
 
 	return;
 error:
-	clock->ret = EXIT_FAILURE;
+	context.ret = EXIT_FAILURE;
 #ifdef HANDLE_SIGNALS
 exit:
 	if ( fds[signal_fd].fd != -1 )
@@ -611,57 +610,56 @@ exit:
 
 int main (int argc, char *argv[])
 {
-	struct Wlclock clock = { 0 };
-	wl_list_init(&clock.outputs);
-	clock.ret = EXIT_FAILURE;
-	clock.loop = true;
-	clock.verbosity = 0;
-
-	clock.dimensions.center_size = 165; /* About the size of xclock, at least on my machine. */
-	clock.exclusive_zone = -1;
-	clock.input = true;
-	clock.snap = false;
-	clock.layer = ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY;
-	clock.anchor = 0; /* Center */
-	set_string(&clock.namespace, "wlclock");
-	clock.border_bottom = clock.border_top
-		= clock.border_left = clock.border_right = 1;
-	clock.radius_bottom_left = clock.radius_bottom_right
-		= clock.radius_top_left = clock.radius_top_right = 0;
-	clock.margin_bottom = clock.margin_top
-		= clock.margin_left = clock.margin_right = 0;
-	clock.marking_width = 1;
-	clock.hand_width = 0;
-	colour_from_string(&clock.background_colour, "#FFFFFF");
-	colour_from_string(&clock.border_colour,     "#000000");
-	colour_from_string(&clock.clock_colour,      "#000000");
-
-	if (! handle_command_flags(&clock, argc, argv))
+	wl_list_init(&context.outputs);
+	context.ret = EXIT_FAILURE;
+	context.loop = true;
+	context.verbosity = 0;
+
+	context.dimensions.center_size = 165; /* About the size of xclock, at least on my machine. */
+	context.exclusive_zone = -1;
+	context.input = true;
+	context.snap = false;
+	context.layer = ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY;
+	context.anchor = 0; /* Center */
+	set_string(&context.namespace, "wlclock");
+	context.border_bottom = context.border_top
+		= context.border_left = context.border_right = 1;
+	context.radius_bottom_left = context.radius_bottom_right
+		= context.radius_top_left = context.radius_top_right = 0;
+	context.margin_bottom = context.margin_top
+		= context.margin_left = context.margin_right = 0;
+	context.marking_width = 1;
+	context.hand_width = 0;
+	colour_from_string(&context.background_colour, "#FFFFFF");
+	colour_from_string(&context.border_colour,     "#000000");
+	colour_from_string(&context.clock_colour,      "#000000");
+
+	if (! handle_command_flags(argc, argv))
 		goto exit;
 
-	clock.dimensions.w = clock.dimensions.center_size
-		+ clock.border_left + clock.border_right;
-	clock.dimensions.h = clock.dimensions.center_size
-		+ clock.border_top + clock.border_bottom;
-	clock.dimensions.center_x = clock.border_left;
-	clock.dimensions.center_y = clock.border_top;
+	context.dimensions.w = context.dimensions.center_size
+		+ context.border_left + context.border_right;
+	context.dimensions.h = context.dimensions.center_size
+		+ context.border_top + context.border_bottom;
+	context.dimensions.center_x = context.border_left;
+	context.dimensions.center_y = context.border_top;
 
 
-	clocklog(&clock, 1, "[main] wlclock: version=%s\n"
+	clocklog(1, "[main] wlclock: version=%s\n"
 			"[main] Default dimensions: size=%d cx=%d cy=%d w=%d h=%d\n",
-			VERSION, clock.dimensions.center_size,
-			clock.dimensions.center_x, clock.dimensions.center_y,
-			clock.dimensions.w, clock.dimensions.h);
+			VERSION, context.dimensions.center_size,
+			context.dimensions.center_x, context.dimensions.center_y,
+			context.dimensions.w, context.dimensions.h);
 
-	if (! init_wayland(&clock))
+	if (! init_wayland())
 		goto exit;
 
-	clock_run(&clock);
+	clock_run();
 
 exit:
-	finish_wayland(&clock);
-	free_if_set(clock.output);
-	free_if_set(clock.namespace);
-	return clock.ret;
+	finish_wayland();
+	free_if_set(context.output);
+	free_if_set(context.namespace);
+	return context.ret;
 }
 
diff --git a/src/wlclock.h b/src/wlclock.h
index bf2c19e..8e72269 100644
--- a/src/wlclock.h
+++ b/src/wlclock.h
@@ -21,7 +21,7 @@ struct Wlclock_dimensions
 	int32_t center_x, center_y, center_size;
 };
 
-struct Wlclock
+struct Wlclock_context
 {
 	struct wl_display             *display;
 	struct wl_registry            *registry;
@@ -54,4 +54,7 @@ struct Wlclock
 	struct Wlclock_colour clock_colour;
 };
 
+extern struct Wlclock_context context;
+
 #endif
+