init hs project

1 files changed, 3248 insertions, 0 deletions

diff --git a/csrc/services/configuration-service.c b/csrc/services/configuration-service.c
new file mode 100644
index 0000000..f3ca010
--- /dev/null
+++ b/csrc/services/configuration-service.c
@@ -0,0 +1,3248 @@
+#include "services/configuration-service.h"
+#include <gio/gio.h>
+
+#define UPDATE_APPLY_DELAY           250
+#define CONFIGURATION_LOG_DOMAIN     "foobar.conf"
+#define CONFIGURATION_WARNING( ... ) g_log( CONFIGURATION_LOG_DOMAIN, G_LOG_LEVEL_WARNING, __VA_ARGS__ )
+
+//
+// FoobarScreenEdge:
+//
+// An edge of the screen.
+//
+
+G_STATIC_ASSERT( sizeof( FoobarScreenEdge ) == sizeof( gint ) );
+G_DEFINE_ENUM_TYPE(
+	FoobarScreenEdge,
+	foobar_screen_edge,
+	G_DEFINE_ENUM_VALUE( FOOBAR_SCREEN_EDGE_LEFT, "left" ),
+	G_DEFINE_ENUM_VALUE( FOOBAR_SCREEN_EDGE_RIGHT, "right" ),
+	G_DEFINE_ENUM_VALUE( FOOBAR_SCREEN_EDGE_TOP, "top" ),
+	G_DEFINE_ENUM_VALUE( FOOBAR_SCREEN_EDGE_BOTTOM, "bottom" ) )
+
+//
+// FoobarOrientation:
+//
+// An orientation value.
+//
+
+G_STATIC_ASSERT( sizeof( FoobarOrientation ) == sizeof( gint ) );
+G_DEFINE_ENUM_TYPE(
+	FoobarOrientation,
+	foobar_orientation,
+	G_DEFINE_ENUM_VALUE( FOOBAR_ORIENTATION_HORIZONTAL, "horizontal" ),
+	G_DEFINE_ENUM_VALUE( FOOBAR_ORIENTATION_VERTICAL, "vertical" ) )
+
+//
+// FoobarStatusItem:
+//
+// An item to display in a status panel item.
+//
+
+G_STATIC_ASSERT( sizeof( FoobarStatusItem ) == sizeof( gint ) );
+G_DEFINE_ENUM_TYPE(
+	FoobarStatusItem,
+	foobar_status_item,
+	G_DEFINE_ENUM_VALUE( FOOBAR_STATUS_ITEM_NETWORK, "network" ),
+	G_DEFINE_ENUM_VALUE( FOOBAR_STATUS_ITEM_BLUETOOTH, "bluetooth" ),
+	G_DEFINE_ENUM_VALUE( FOOBAR_STATUS_ITEM_BATTERY, "battery" ),
+	G_DEFINE_ENUM_VALUE( FOOBAR_STATUS_ITEM_BRIGHTNESS, "brightness" ),
+	G_DEFINE_ENUM_VALUE( FOOBAR_STATUS_ITEM_AUDIO, "audio" ),
+	G_DEFINE_ENUM_VALUE( FOOBAR_STATUS_ITEM_NOTIFICATIONS, "notifications" ) )
+
+//
+// FoobarPanelItemKind:
+//
+// Enum representing the various panel item types.
+//
+
+G_STATIC_ASSERT( sizeof( FoobarPanelItemKind ) == sizeof( gint ) );
+G_DEFINE_ENUM_TYPE(
+	FoobarPanelItemKind,
+	foobar_panel_item_kind,
+	G_DEFINE_ENUM_VALUE( FOOBAR_PANEL_ITEM_KIND_ICON, "icon" ),
+	G_DEFINE_ENUM_VALUE( FOOBAR_PANEL_ITEM_KIND_CLOCK, "clock" ),
+	G_DEFINE_ENUM_VALUE( FOOBAR_PANEL_ITEM_KIND_WORKSPACES, "workspaces" ),
+	G_DEFINE_ENUM_VALUE( FOOBAR_PANEL_ITEM_KIND_STATUS, "status" ) )
+
+//
+// FoobarPanelItemAction:
+//
+// The action to be executed when a panel item is clicked (if supported by the item).
+//
+
+G_STATIC_ASSERT( sizeof( FoobarPanelItemAction ) == sizeof( gint ) );
+G_DEFINE_ENUM_TYPE(
+	FoobarPanelItemAction,
+	foobar_panel_item_action,
+	G_DEFINE_ENUM_VALUE( FOOBAR_PANEL_ITEM_ACTION_NONE, "none" ),
+	G_DEFINE_ENUM_VALUE( FOOBAR_PANEL_ITEM_ACTION_LAUNCHER, "launcher" ),
+	G_DEFINE_ENUM_VALUE( FOOBAR_PANEL_ITEM_ACTION_CONTROL_CENTER, "control-center" ) )
+
+//
+// FoobarPanelItemPosition:
+//
+// Position of a panel item in the panel.
+//
+
+G_STATIC_ASSERT( sizeof( FoobarPanelItemPosition ) == sizeof( gint ) );
+G_DEFINE_ENUM_TYPE(
+	FoobarPanelItemPosition,
+	foobar_panel_item_position,
+	G_DEFINE_ENUM_VALUE( FOOBAR_PANEL_ITEM_POSITION_START, "start" ),
+	G_DEFINE_ENUM_VALUE( FOOBAR_PANEL_ITEM_POSITION_CENTER, "center" ),
+	G_DEFINE_ENUM_VALUE( FOOBAR_PANEL_ITEM_POSITION_END, "end" ) )
+
+//
+// FoobarControlCenterRow:
+//
+// A row in the "controls" section of the control center.
+//
+
+G_STATIC_ASSERT( sizeof( FoobarControlCenterRow ) == sizeof( gint ) );
+G_DEFINE_ENUM_TYPE(
+	FoobarControlCenterRow,
+	foobar_control_center_row,
+	G_DEFINE_ENUM_VALUE( FOOBAR_CONTROL_CENTER_ROW_CONNECTIVITY, "connectivity" ),
+	G_DEFINE_ENUM_VALUE( FOOBAR_CONTROL_CENTER_ROW_AUDIO_OUTPUT, "audio-output" ),
+	G_DEFINE_ENUM_VALUE( FOOBAR_CONTROL_CENTER_ROW_AUDIO_INPUT, "audio-input" ),
+	G_DEFINE_ENUM_VALUE( FOOBAR_CONTROL_CENTER_ROW_BRIGHTNESS, "brightness" ) )
+
+//
+// FoobarControlCenterAlignment:
+//
+// Alignment of the control center along its screen edge.
+//
+
+G_STATIC_ASSERT( sizeof( FoobarControlCenterAlignment ) == sizeof( gint ) );
+G_DEFINE_ENUM_TYPE(
+	FoobarControlCenterAlignment,
+	foobar_control_center_alignment,
+	G_DEFINE_ENUM_VALUE( FOOBAR_CONTROL_CENTER_ALIGNMENT_START, "start" ),
+	G_DEFINE_ENUM_VALUE( FOOBAR_CONTROL_CENTER_ALIGNMENT_CENTER, "center" ),
+	G_DEFINE_ENUM_VALUE( FOOBAR_CONTROL_CENTER_ALIGNMENT_END, "end" ),
+	G_DEFINE_ENUM_VALUE( FOOBAR_CONTROL_CENTER_ALIGNMENT_FILL, "fill" ) )
+
+//
+// FoobarGeneralConfiguration:
+//
+// General application settings not specific to a single component.
+//
+
+struct _FoobarGeneralConfiguration
+{
+	gchar* stylesheet;
+};
+
+static void foobar_general_configuration_load ( FoobarGeneralConfiguration*       self,
+                                                GKeyFile*                         file );
+static void foobar_general_configuration_store( FoobarGeneralConfiguration const* self,
+                                                GKeyFile*                         file );
+
+G_DEFINE_BOXED_TYPE(
+	FoobarGeneralConfiguration,
+	foobar_general_configuration,
+	foobar_general_configuration_copy,
+	foobar_general_configuration_free )
+
+//
+// FoobarPanelItemConfiguration:
+//
+// Configuration for an item in the panel. Structures of this type have a specific item kind with more properties.
+//
+
+struct _FoobarPanelItemConfiguration
+{
+	FoobarPanelItemKind     kind;
+	gchar*                  name;
+	FoobarPanelItemPosition position;
+	FoobarPanelItemAction   action;
+	union
+	{
+		struct
+		{
+			gchar* icon_name;
+		} icon;
+
+		struct
+		{
+			gchar* format;
+		} clock;
+
+		struct
+		{
+			gint button_size;
+			gint spacing;
+		} workspaces;
+
+		struct
+		{
+			FoobarStatusItem* items;
+			gsize             items_count;
+			gint              spacing;
+			gboolean          show_labels;
+			gboolean          enable_scrolling;
+		} status;
+	};
+};
+
+static FoobarPanelItemConfiguration* foobar_panel_item_configuration_load ( GKeyFile*                           file,
+                                                                            gchar const*                        group );
+static void                          foobar_panel_item_configuration_store( FoobarPanelItemConfiguration const* self,
+                                                                            GKeyFile*                           file );
+
+G_DEFINE_BOXED_TYPE(
+	FoobarPanelItemConfiguration,
+	foobar_panel_item_configuration,
+	foobar_panel_item_configuration_copy,
+	foobar_panel_item_configuration_free )
+
+//
+// FoobarPanelConfiguration:
+//
+// Configuration for the panel shown at the edge of a screen.
+//
+
+struct _FoobarPanelConfiguration
+{
+	FoobarScreenEdge               position;
+	gint                           margin;
+	gint                           padding;
+	gint                           size;
+	gint                           spacing;
+	gboolean                       multi_monitor;
+	FoobarPanelItemConfiguration** items;
+	gsize                          items_count;
+};
+
+static void foobar_panel_configuration_load ( FoobarPanelConfiguration*       self,
+                                              GKeyFile*                       file );
+static void foobar_panel_configuration_store( FoobarPanelConfiguration const* self,
+                                              GKeyFile*                       file );
+
+G_DEFINE_BOXED_TYPE(
+	FoobarPanelConfiguration,
+	foobar_panel_configuration,
+	foobar_panel_configuration_copy,
+	foobar_panel_configuration_free )
+
+//
+// FoobarLauncherConfiguration:
+//
+// Configuration for the application launcher.
+//
+
+struct _FoobarLauncherConfiguration
+{
+	gint width;
+	gint position;
+	gint max_height;
+};
+
+static void foobar_launcher_configuration_load ( FoobarLauncherConfiguration*       self,
+                                                 GKeyFile*                          file );
+static void foobar_launcher_configuration_store( FoobarLauncherConfiguration const* self,
+                                                 GKeyFile*                          file );
+
+G_DEFINE_BOXED_TYPE(
+	FoobarLauncherConfiguration,
+	foobar_launcher_configuration,
+	foobar_launcher_configuration_copy,
+	foobar_launcher_configuration_free )
+
+//
+// FoobarControlCenterConfiguration:
+//
+// Configuration for the control center.
+//
+
+struct _FoobarControlCenterConfiguration
+{
+	gint                         width;
+	gint                         height;
+	FoobarScreenEdge             position;
+	gint                         offset;
+	gint                         padding;
+	gint                         spacing;
+	FoobarOrientation            orientation;
+	FoobarControlCenterAlignment alignment;
+	FoobarControlCenterRow*      rows;
+	gsize                        rows_count;
+};
+
+static void foobar_control_center_configuration_load ( FoobarControlCenterConfiguration*       self,
+                                                       GKeyFile*                               file );
+static void foobar_control_center_configuration_store( FoobarControlCenterConfiguration const* self,
+                                                       GKeyFile*                               file );
+
+G_DEFINE_BOXED_TYPE(
+	FoobarControlCenterConfiguration,
+	foobar_control_center_configuration,
+	foobar_control_center_configuration_copy,
+	foobar_control_center_configuration_free )
+
+//
+// FoobarNotificationConfiguration:
+//
+// Configuration for notifications and the notification area shown in the corner of the screen.
+//
+
+struct _FoobarNotificationConfiguration
+{
+	gint   width;
+	gint   min_height;
+	gint   spacing;
+	gint   close_button_inset;
+	gchar* time_format;
+};
+
+static void foobar_notification_configuration_load ( FoobarNotificationConfiguration*       self,
+                                                     GKeyFile*                              file );
+static void foobar_notification_configuration_store( FoobarNotificationConfiguration const* self,
+                                                     GKeyFile*                              file );
+
+G_DEFINE_BOXED_TYPE(
+	FoobarNotificationConfiguration,
+	foobar_notification_configuration,
+	foobar_notification_configuration_copy,
+	foobar_notification_configuration_free )
+
+//
+// FoobarConfiguration:
+//
+// Main configuration structure containing the configuration state for all components of the application.
+//
+
+struct _FoobarConfiguration
+{
+	FoobarGeneralConfiguration*       general;
+	FoobarPanelConfiguration*         panel;
+	FoobarLauncherConfiguration*      launcher;
+	FoobarControlCenterConfiguration* control_center;
+	FoobarNotificationConfiguration*  notifications;
+};
+
+static void foobar_configuration_load          ( FoobarConfiguration*       self,
+                                                 GKeyFile*                  file );
+static void foobar_configuration_load_from_file( FoobarConfiguration*       self,
+                                                 gchar const*               path );
+static void foobar_configuration_store         ( FoobarConfiguration const* self, 
+                                                 GKeyFile*                  file );
+
+G_DEFINE_BOXED_TYPE( FoobarConfiguration, foobar_configuration, foobar_configuration_copy, foobar_configuration_free )
+
+//
+// FoobarConfigurationService:
+//
+// Service monitoring the configuration state of the application specified in its config file.
+//
+
+struct _FoobarConfigurationService
+{
+	GObject              parent_instance;
+	gchar*               path;
+	char*                actual_path;
+	FoobarConfiguration* current;
+	GFileMonitor*        monitor;
+	GFileMonitor*        actual_monitor;
+	gulong               changed_handler_id;
+	gulong               actual_changed_handler_id;
+	guint                update_source_id;
+};
+
+enum
+{
+	PROP_CURRENT = 1,
+	N_PROPS,
+};
+
+static GParamSpec* props[N_PROPS] = { 0 };
+
+static void          foobar_configuration_service_class_init           ( FoobarConfigurationServiceClass* klass );
+static void          foobar_configuration_service_init                 ( FoobarConfigurationService*      self );
+static void          foobar_configuration_service_get_property         ( GObject*                         object,
+                                                                         guint                            prop_id,
+                                                                         GValue*                          value,
+                                                                         GParamSpec*                      pspec );
+static void          foobar_configuration_service_finalize             ( GObject*                         object );
+static void          foobar_configuration_service_handle_changed       ( GFileMonitor*                    monitor,
+                                                                         GFile*                           file,
+                                                                         GFile*                           other_file,
+                                                                         GFileMonitorEvent                event_type,
+                                                                         gpointer                         userdata );
+static void          foobar_configuration_service_handle_actual_changed( GFileMonitor*                    monitor,
+                                                                         GFile*                           file,
+                                                                         GFile*                           other_file,
+                                                                         GFileMonitorEvent                event_type,
+                                                                         gpointer                         userdata );
+static void          foobar_configuration_service_update               ( FoobarConfigurationService*      self );
+static gboolean      foobar_configuration_service_update_cb            ( gpointer                         userdata );
+static GFileMonitor* foobar_configuration_service_create_monitor       ( gchar const*                     path );
+
+G_DEFINE_FINAL_TYPE( FoobarConfigurationService, foobar_configuration_service, G_TYPE_OBJECT )
+
+//
+// Parsing/Serialization Helpers:
+//
+// These functions make it easier to parse, validate and serialize various data types.
+//
+
+typedef enum
+{
+	VALIDATE_NONE = 0,
+	VALIDATE_NON_NEGATIVE = 1 << 0,
+	VALIDATE_NON_ZERO = 1 << 1,
+	VALIDATE_POSITIVE = VALIDATE_NON_NEGATIVE | VALIDATE_NON_ZERO,
+	VALIDATE_FILE_URL = 1 << 2,
+	VALIDATE_DISTINCT = 1 << 3,
+} ValidationFlags;
+
+static gboolean try_get_string_value     ( GKeyFile*       file,
+                                           gchar const*    group,
+                                           gchar const*    key,
+                                           ValidationFlags validation,
+                                           gchar**         out );
+static gboolean try_get_string_list_value( GKeyFile*       file,
+                                           gchar const*    group,
+                                           gchar const*    key,
+                                           ValidationFlags validation,
+                                           GStrv*          out,
+                                           gsize*          out_count );
+static gboolean try_get_int_value        ( GKeyFile*       file,
+                                           gchar const*    group,
+                                           gchar const*    key,
+                                           ValidationFlags validation,
+                                           gint*           out );
+static gboolean try_get_enum_value       ( GKeyFile*       file,
+                                           gchar const*    group,
+                                           gchar const*    key,
+                                           GType           enum_type,
+                                           ValidationFlags validation,
+                                           gint*           out );
+static gboolean try_get_enum_list_value  ( GKeyFile*       file,
+                                           gchar const*    group,
+                                           gchar const*    key,
+                                           GType           enum_type,
+                                           ValidationFlags validation,
+                                           gpointer*       out,
+                                           gsize*          out_count );
+static gboolean try_get_boolean_value    ( GKeyFile*       file,
+                                           gchar const*    group,
+                                           gchar const*    key,
+                                           ValidationFlags validation,
+                                           gboolean*       out );
+
+static gchar const*  enum_value_to_string ( GType         enum_type,
+                                            gint          value );
+static gchar const** enum_list_to_string  ( GType         enum_type,
+                                            gconstpointer values,
+                                            gsize         values_count );
+static gchar*        enum_format_help_text( GType         enum_type );
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Default Configuration
+// ---------------------------------------------------------------------------------------------------------------------
+
+static FoobarGeneralConfiguration default_general_configuration =
+	{
+		.stylesheet = "resource:///foobar/styles/default.css",
+	};
+
+static FoobarPanelItemConfiguration default_panel_item_icon_configuration =
+	{
+		.kind = FOOBAR_PANEL_ITEM_KIND_ICON,
+		.name = "launcher",
+		.position = FOOBAR_PANEL_ITEM_POSITION_START,
+		.action = FOOBAR_PANEL_ITEM_ACTION_LAUNCHER,
+		.icon.icon_name = "fluent-grid-dots-symbolic",
+	};
+
+static FoobarPanelItemConfiguration default_panel_item_clock_configuration =
+	{
+		.kind = FOOBAR_PANEL_ITEM_KIND_CLOCK,
+		.name = "clock",
+		.position = FOOBAR_PANEL_ITEM_POSITION_CENTER,
+		.action = FOOBAR_PANEL_ITEM_ACTION_NONE,
+		.clock.format = "%H\n%M",
+	};
+
+static FoobarPanelItemConfiguration default_panel_item_workspaces_configuration =
+	{
+		.kind = FOOBAR_PANEL_ITEM_KIND_WORKSPACES,
+		.name = "workspaces",
+		.position = FOOBAR_PANEL_ITEM_POSITION_START,
+		.action = FOOBAR_PANEL_ITEM_ACTION_NONE,
+		.workspaces.button_size = 20,
+		.workspaces.spacing = 6,
+	};
+
+static FoobarStatusItem default_panel_item_status_configuration_items[] =
+	{
+		FOOBAR_STATUS_ITEM_BATTERY,
+		FOOBAR_STATUS_ITEM_BRIGHTNESS,
+		FOOBAR_STATUS_ITEM_AUDIO,
+		FOOBAR_STATUS_ITEM_NETWORK,
+		FOOBAR_STATUS_ITEM_BLUETOOTH,
+		FOOBAR_STATUS_ITEM_NOTIFICATIONS
+	};
+
+static FoobarPanelItemConfiguration default_panel_item_status_configuration =
+	{
+		.kind = FOOBAR_PANEL_ITEM_KIND_STATUS,
+		.name = "status",
+		.position = FOOBAR_PANEL_ITEM_POSITION_END,
+		.action = FOOBAR_PANEL_ITEM_ACTION_CONTROL_CENTER,
+		.status.items = default_panel_item_status_configuration_items,
+		.status.items_count = G_N_ELEMENTS( default_panel_item_status_configuration_items ),
+		.status.spacing = 6,
+		.status.show_labels = FALSE,
+		.status.enable_scrolling = FALSE,
+	};
+
+static FoobarPanelItemConfiguration *default_panel_configuration_items[] =
+	{
+		&default_panel_item_icon_configuration,
+		&default_panel_item_workspaces_configuration,
+		&default_panel_item_clock_configuration,
+		&default_panel_item_status_configuration,
+		NULL,
+	};
+
+static FoobarPanelConfiguration default_panel_configuration =
+	{
+		.position = FOOBAR_SCREEN_EDGE_LEFT,
+		.margin = 16,
+		.padding = 12,
+		.size = 48,
+		.spacing = 12,
+		.multi_monitor = TRUE,
+		.items = default_panel_configuration_items,
+		.items_count = G_N_ELEMENTS( default_panel_configuration_items ) - 1,
+	};
+
+static FoobarLauncherConfiguration default_launcher_configuration =
+	{
+		.width = 600,
+		.position = 300,
+		.max_height = 400,
+	};
+
+static FoobarControlCenterRow default_control_center_configuration_rows[] =
+	{
+		FOOBAR_CONTROL_CENTER_ROW_CONNECTIVITY,
+		FOOBAR_CONTROL_CENTER_ROW_AUDIO_OUTPUT,
+		FOOBAR_CONTROL_CENTER_ROW_BRIGHTNESS,
+	};
+
+static FoobarControlCenterConfiguration default_control_center_configuration =
+	{
+		.position = FOOBAR_SCREEN_EDGE_LEFT,
+		.width = 400,
+		.height = 600,
+		.offset = 16,
+		.padding = 24,
+		.spacing = 12,
+		.orientation = FOOBAR_ORIENTATION_VERTICAL,
+		.alignment = FOOBAR_CONTROL_CENTER_ALIGNMENT_CENTER,
+		.rows = default_control_center_configuration_rows,
+		.rows_count = G_N_ELEMENTS( default_control_center_configuration_rows ),
+	};
+
+static FoobarNotificationConfiguration default_notification_configuration =
+	{
+		.width = 400,
+		.min_height = 48,
+		.spacing = 16,
+		.close_button_inset = -6,
+		.time_format = "%H:%M",
+	};
+
+static FoobarConfiguration default_configuration =
+	{
+		.general = &default_general_configuration,
+		.panel = &default_panel_configuration,
+		.launcher = &default_launcher_configuration,
+		.control_center = &default_control_center_configuration,
+		.notifications = &default_notification_configuration,
+	};
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Default Configuration
+// ---------------------------------------------------------------------------------------------------------------------
+
+//
+// Create a default general configuration structure.
+//
+FoobarGeneralConfiguration* foobar_general_configuration_new( void )
+{
+	return foobar_general_configuration_copy( &default_general_configuration );
+}
+
+//
+// Create a mutable copy of another general configuration structure.
+//
+FoobarGeneralConfiguration* foobar_general_configuration_copy( FoobarGeneralConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, NULL );
+
+	FoobarGeneralConfiguration* copy = g_new0( FoobarGeneralConfiguration, 1 );
+	copy->stylesheet = g_strdup( self->stylesheet );
+	return copy;
+}
+
+//
+// Release resources associated with a general configuration structure.
+//
+void foobar_general_configuration_free( FoobarGeneralConfiguration* self )
+{
+	g_return_if_fail( self != NULL );
+
+	g_free( self->stylesheet );
+	g_free( self );
+}
+
+//
+// Check if two general configuration structures are equal.
+//
+gboolean foobar_general_configuration_equal(
+	FoobarGeneralConfiguration const* a,
+	FoobarGeneralConfiguration const* b )
+{
+	g_return_val_if_fail( a != NULL, FALSE );
+	g_return_val_if_fail( b != NULL, FALSE );
+
+	if ( g_strcmp0( a->stylesheet, b->stylesheet ) ) { return FALSE; }
+
+	return TRUE;
+}
+
+//
+// URI to the CSS stylesheet to use -- this may be a resource that's bundled with Foobar or a "file:" URI.
+//
+gchar const* foobar_general_configuration_get_stylesheet( FoobarGeneralConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, NULL );
+	return self->stylesheet;
+}
+
+//
+// URI to the CSS stylesheet to use -- this may be a resource that's bundled with Foobar or a "file:" URI.
+//
+void foobar_general_configuration_set_stylesheet(
+	FoobarGeneralConfiguration* self,
+	gchar const*                value )
+{
+	g_return_if_fail( self != NULL );
+	g_return_if_fail( value != NULL );
+
+	g_free( self->stylesheet );
+	self->stylesheet = g_strdup( value );
+}
+
+//
+// Populate a general configuration structure from the "general" section of a keyfile.
+//
+void foobar_general_configuration_load(
+	FoobarGeneralConfiguration* self,
+	GKeyFile*                   file )
+{
+	g_autofree gchar* stylesheet = NULL;
+	if ( try_get_string_value( file, "general", "stylesheet", VALIDATE_FILE_URL, &stylesheet ) )
+	{
+		foobar_general_configuration_set_stylesheet( self, stylesheet );
+	}
+}
+
+//
+// Store a general configuration structure in the "general" section of a keyfile.
+//
+void foobar_general_configuration_store(
+	FoobarGeneralConfiguration const* self,
+	GKeyFile*                         file )
+{
+	gchar const* stylesheet = foobar_general_configuration_get_stylesheet( self );
+	g_key_file_set_string( file, "general", "stylesheet", stylesheet );
+	g_key_file_set_comment(
+		file,
+		"general",
+		"stylesheet",
+		" URI to the CSS stylesheet to use -- this may be a resource that's bundled with Foobar or a \"file:\" URI.",
+		NULL );
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Panel Item Configuration
+// ---------------------------------------------------------------------------------------------------------------------
+
+//
+// Create a default icon panel item configuration structure.
+//
+FoobarPanelItemConfiguration* foobar_panel_item_icon_configuration_new( void )
+{
+	return foobar_panel_item_configuration_copy( &default_panel_item_icon_configuration );
+}
+
+//
+// Create a default clock panel item configuration structure.
+//
+FoobarPanelItemConfiguration* foobar_panel_item_clock_configuration_new( void )
+{
+	return foobar_panel_item_configuration_copy( &default_panel_item_clock_configuration );
+}
+
+//
+// Create a default workspaces panel item configuration structure.
+//
+FoobarPanelItemConfiguration* foobar_panel_item_workspaces_configuration_new( void )
+{
+	return foobar_panel_item_configuration_copy( &default_panel_item_workspaces_configuration );
+}
+
+//
+// Create a default status panel item configuration structure.
+//
+FoobarPanelItemConfiguration* foobar_panel_item_status_configuration_new( void )
+{
+	return foobar_panel_item_configuration_copy( &default_panel_item_status_configuration );
+}
+
+//
+// Create a mutable copy of another panel item configuration structure, preserving its item type.
+//
+FoobarPanelItemConfiguration* foobar_panel_item_configuration_copy( FoobarPanelItemConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, NULL );
+
+	FoobarPanelItemConfiguration* copy = g_new0( FoobarPanelItemConfiguration, 1 );
+	copy->kind = self->kind;
+	copy->name = g_strdup( self->name );
+	copy->position = self->position;
+	copy->action = self->action;
+	switch ( copy->kind )
+	{
+		case FOOBAR_PANEL_ITEM_KIND_ICON:
+			copy->icon.icon_name = g_strdup( self->icon.icon_name );
+			break;
+		case FOOBAR_PANEL_ITEM_KIND_CLOCK:
+			copy->clock.format = g_strdup( self->clock.format );
+			break;
+		case FOOBAR_PANEL_ITEM_KIND_WORKSPACES:
+			copy->workspaces.button_size = self->workspaces.button_size;
+			copy->workspaces.spacing = self->workspaces.spacing;
+			break;
+		case FOOBAR_PANEL_ITEM_KIND_STATUS:
+			copy->status.items = g_new( FoobarStatusItem, self->status.items_count );
+			copy->status.items_count = self->status.items_count;
+			memcpy( copy->status.items, self->status.items, sizeof( *copy->status.items ) * copy->status.items_count );
+			copy->status.spacing = self->status.spacing;
+			copy->status.show_labels = self->status.show_labels;
+			copy->status.enable_scrolling = self->status.enable_scrolling;
+			break;
+		default:
+			g_warn_if_reached( );
+	}
+	return copy;
+}
+
+//
+// Release resources associated with a panel item configuration structure.
+//
+void foobar_panel_item_configuration_free( FoobarPanelItemConfiguration* self )
+{
+	g_return_if_fail( self != NULL );
+
+	switch ( self->kind )
+	{
+		case FOOBAR_PANEL_ITEM_KIND_ICON:
+			g_free( self->icon.icon_name );
+			break;
+		case FOOBAR_PANEL_ITEM_KIND_CLOCK:
+			g_free( self->clock.format );
+			break;
+		case FOOBAR_PANEL_ITEM_KIND_WORKSPACES:
+			break;
+		case FOOBAR_PANEL_ITEM_KIND_STATUS:
+			g_free( self->status.items );
+			break;
+		default:
+			g_warn_if_reached( );
+			break;
+	}
+
+	g_free( self->name );
+	g_free( self );
+}
+
+//
+// Check if two panel item configuration structures are equal.
+//
+gboolean foobar_panel_item_configuration_equal(
+	FoobarPanelItemConfiguration const* a,
+	FoobarPanelItemConfiguration const* b )
+{
+	g_return_val_if_fail( a != NULL, FALSE );
+	g_return_val_if_fail( b != NULL, FALSE );
+
+	if ( a->kind != b->kind ) { return FALSE; }
+	if ( a->position != b->position ) { return FALSE; }
+	if ( a->action != b->action ) { return FALSE; }
+	if ( g_strcmp0( a->name, b->name ) ) { return FALSE; }
+
+	switch ( a->kind )
+	{
+		case FOOBAR_PANEL_ITEM_KIND_ICON:
+			if ( g_strcmp0( a->icon.icon_name, b->icon.icon_name ) ) { return FALSE; }
+			break;
+		case FOOBAR_PANEL_ITEM_KIND_CLOCK:
+			if ( g_strcmp0( a->clock.format, b->clock.format ) ) { return FALSE; }
+			break;
+		case FOOBAR_PANEL_ITEM_KIND_WORKSPACES:
+			if ( a->workspaces.button_size != b->workspaces.button_size ) { return FALSE; }
+			if ( a->workspaces.spacing != b->workspaces.spacing ) { return FALSE; }
+			break;
+		case FOOBAR_PANEL_ITEM_KIND_STATUS:
+			if ( a->status.items_count != b->status.items_count ) { return FALSE; }
+			if ( memcmp( a->status.items, b->status.items, sizeof( *a->status.items ) * a->status.items_count ) ) { return FALSE; }
+			if ( a->status.spacing != b->status.spacing ) { return FALSE; }
+			if ( a->status.show_labels != b->status.show_labels ) { return FALSE; }
+			if ( a->status.enable_scrolling != b->status.enable_scrolling ) { return FALSE; }
+			break;
+		default:
+			g_warn_if_reached( );
+			break;
+	}
+
+	return TRUE;
+}
+
+//
+// The type of panel item to be configured by this structure.
+//
+FoobarPanelItemKind foobar_panel_item_configuration_get_kind( FoobarPanelItemConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	return self->kind;
+}
+
+//
+// Name of the panel item (this is derived from the section name, which has the form "panel.[name]").
+//
+gchar const* foobar_panel_item_configuration_get_name( FoobarPanelItemConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	return self->name;
+}
+
+//
+// Position where the item should be placed item within the panel.
+//
+FoobarPanelItemPosition foobar_panel_item_configuration_get_position( FoobarPanelItemConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	return self->position;
+}
+
+//
+// Action invoked when the user clicks the item (if supported by the item).
+//
+FoobarPanelItemAction foobar_panel_item_configuration_get_action( FoobarPanelItemConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	return self->action;
+}
+
+//
+// The GTK icon to use for the item.
+//
+gchar const* foobar_panel_item_icon_configuration_get_icon_name( FoobarPanelItemConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, NULL );
+	g_return_val_if_fail( self->kind == FOOBAR_PANEL_ITEM_KIND_ICON, NULL );
+
+	return self->icon.icon_name;
+}
+
+//
+// The time format string as used by g_date_time_format.
+//
+gchar const* foobar_panel_item_clock_configuration_get_format( FoobarPanelItemConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, NULL );
+	g_return_val_if_fail( self->kind == FOOBAR_PANEL_ITEM_KIND_CLOCK, NULL );
+
+	return self->clock.format;
+}
+
+//
+// Size of each workspace button.
+//
+gint foobar_panel_item_workspaces_configuration_get_button_size( FoobarPanelItemConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	g_return_val_if_fail( self->kind == FOOBAR_PANEL_ITEM_KIND_WORKSPACES, 0 );
+
+	return self->workspaces.button_size;
+}
+
+//
+// Inner spacing between the workspace buttons.
+//
+gint foobar_panel_item_workspaces_configuration_get_spacing( FoobarPanelItemConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	g_return_val_if_fail( self->kind == FOOBAR_PANEL_ITEM_KIND_WORKSPACES, 0 );
+
+	return self->workspaces.spacing;
+}
+
+//
+// Ordered list of status items to display in the item.
+//
+FoobarStatusItem const* foobar_panel_item_status_configuration_get_items(
+	FoobarPanelItemConfiguration const* self,
+	gsize*                              out_count )
+{
+	g_return_val_if_fail( self != NULL, NULL );
+	g_return_val_if_fail( self->kind == FOOBAR_PANEL_ITEM_KIND_STATUS, NULL );
+	g_return_val_if_fail( out_count != NULL, NULL );
+
+	*out_count = self->status.items_count;
+	return self->status.items;
+}
+
+//
+// Inner spacing between the status items.
+//
+gint foobar_panel_item_status_configuration_get_spacing( FoobarPanelItemConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	g_return_val_if_fail( self->kind == FOOBAR_PANEL_ITEM_KIND_STATUS, 0 );
+
+	return self->status.spacing;
+}
+
+//
+// Indicates whether text labels should be shown next to the status icons.
+//
+gboolean foobar_panel_item_status_configuration_get_show_labels( FoobarPanelItemConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, FALSE );
+	g_return_val_if_fail( self->kind == FOOBAR_PANEL_ITEM_KIND_STATUS, FALSE );
+
+	return self->status.show_labels;
+}
+
+//
+// If set to true, some settings like volume or brightness can be adjusted by scrolling while hovering over the status
+// item.
+//
+gboolean foobar_panel_item_status_configuration_get_enable_scrolling( FoobarPanelItemConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, FALSE );
+	g_return_val_if_fail( self->kind == FOOBAR_PANEL_ITEM_KIND_STATUS, FALSE );
+
+	return self->status.enable_scrolling;
+}
+
+//
+// Name of the panel item (this is derived from the section name, which has the form "panel.[name]").
+//
+void foobar_panel_item_configuration_set_name(
+	FoobarPanelItemConfiguration* self,
+	gchar const*                  value )
+{
+	g_return_if_fail( self != NULL );
+	g_return_if_fail( value != NULL );
+
+	g_free( self->name );
+	self->name = g_strdup( value );
+}
+
+//
+// Position where the item should be placed item within the panel.
+//
+void foobar_panel_item_configuration_set_position(
+	FoobarPanelItemConfiguration* self,
+	FoobarPanelItemPosition       value )
+{
+	g_return_if_fail( self != NULL );
+	self->position = value;
+}
+
+//
+// Action invoked when the user clicks the item (if supported by the item).
+//
+void foobar_panel_item_configuration_set_action(
+	FoobarPanelItemConfiguration* self,
+	FoobarPanelItemAction         value )
+{
+	g_return_if_fail( self != NULL );
+	self->action = value;
+}
+
+//
+// The GTK icon to use for the item.
+//
+void foobar_panel_item_icon_configuration_set_icon_name(
+	FoobarPanelItemConfiguration* self,
+	gchar const*                  value )
+{
+	g_return_if_fail( self != NULL );
+	g_return_if_fail( self->kind == FOOBAR_PANEL_ITEM_KIND_ICON );
+	g_return_if_fail( value != NULL );
+
+	g_free( self->icon.icon_name );
+	self->icon.icon_name = g_strdup( value );
+}
+
+//
+// The time format string as used by g_date_time_format.
+//
+void foobar_panel_item_clock_configuration_set_format(
+	FoobarPanelItemConfiguration* self,
+	gchar const*                  value )
+{
+	g_return_if_fail( self != NULL );
+	g_return_if_fail( self->kind == FOOBAR_PANEL_ITEM_KIND_CLOCK );
+	g_return_if_fail( value != NULL );
+
+	g_free( self->clock.format );
+	self->clock.format = g_strdup( value );
+}
+
+//
+// Size of each workspace button.
+//
+void foobar_panel_item_workspaces_configuration_set_button_size(
+	FoobarPanelItemConfiguration* self,
+	gint                          value )
+{
+	g_return_if_fail( self != NULL );
+	g_return_if_fail( self->kind == FOOBAR_PANEL_ITEM_KIND_WORKSPACES );
+
+	self->workspaces.button_size = value;
+}
+
+//
+// Inner spacing between the workspace buttons.
+//
+void foobar_panel_item_workspaces_configuration_set_spacing(
+	FoobarPanelItemConfiguration* self,
+	gint                          value )
+{
+	g_return_if_fail( self != NULL );
+	g_return_if_fail( self->kind == FOOBAR_PANEL_ITEM_KIND_WORKSPACES );
+
+	self->workspaces.spacing = value;
+}
+
+//
+// Ordered list of status items to display in the item.
+//
+void foobar_panel_item_status_configuration_set_items(
+	FoobarPanelItemConfiguration* self,
+	FoobarStatusItem const*       value,
+	gsize                         value_count )
+{
+	g_return_if_fail( self != NULL );
+	g_return_if_fail( self->kind == FOOBAR_PANEL_ITEM_KIND_STATUS );
+	g_return_if_fail( value != NULL || value_count == 0 );
+
+	g_free( self->status.items );
+	self->status.items = g_new( FoobarStatusItem, value_count );
+	self->status.items_count = value_count;
+	memcpy( self->status.items, value, sizeof( *self->status.items ) * self->status.items_count );
+}
+
+//
+// Inner spacing between the status items.
+//
+void foobar_panel_item_status_configuration_set_spacing(
+	FoobarPanelItemConfiguration* self,
+	gint                          value )
+{
+	g_return_if_fail( self != NULL );
+	g_return_if_fail( self->kind == FOOBAR_PANEL_ITEM_KIND_STATUS );
+
+	self->status.spacing = value;
+}
+
+//
+// Indicates whether text labels should be shown next to the status icons.
+//
+void foobar_panel_item_status_configuration_set_show_labels(
+	FoobarPanelItemConfiguration* self,
+	gboolean                      value )
+{
+	g_return_if_fail( self != NULL );
+	g_return_if_fail( self->kind == FOOBAR_PANEL_ITEM_KIND_STATUS );
+
+	self->status.show_labels = value;
+}
+
+//
+// If set to true, some settings like volume or brightness can be adjusted by scrolling while hovering over the status
+// item.
+//
+void foobar_panel_item_status_configuration_set_enable_scrolling(
+	FoobarPanelItemConfiguration* self,
+	gboolean                      value )
+{
+	g_return_if_fail( self != NULL );
+	g_return_if_fail( self->kind == FOOBAR_PANEL_ITEM_KIND_STATUS );
+
+	self->status.enable_scrolling = value;
+}
+
+//
+// Create a panel item configuration structure from the given section of a keyfile, returning NULL if it is not a panel
+// item configuration section.
+//
+FoobarPanelItemConfiguration* foobar_panel_item_configuration_load(
+	GKeyFile*    file,
+	gchar const* group )
+{
+	if ( !g_str_has_prefix( group, "panel." ) )
+	{
+		return NULL;
+	}
+
+	gint kind;
+	if ( !try_get_enum_value( file, group, "kind", FOOBAR_TYPE_PANEL_ITEM_KIND, VALIDATE_NONE, &kind ) )
+	{
+		return NULL;
+	}
+
+	FoobarPanelItemConfiguration* result;
+	switch ( (FoobarPanelItemKind)kind )
+	{
+		case FOOBAR_PANEL_ITEM_KIND_ICON:
+		{
+			result = foobar_panel_item_icon_configuration_new( );
+
+			g_autofree gchar* icon_name = NULL;
+			if ( try_get_string_value( file, group, "icon-name", VALIDATE_NONE, &icon_name ) )
+			{
+				foobar_panel_item_icon_configuration_set_icon_name( result, icon_name );
+			}
+
+			break;
+		}
+		case FOOBAR_PANEL_ITEM_KIND_CLOCK:
+		{
+			result = foobar_panel_item_clock_configuration_new( );
+
+			g_autofree gchar* format = NULL;
+			if ( try_get_string_value( file, group, "format", VALIDATE_NONE, &format ) )
+			{
+				foobar_panel_item_clock_configuration_set_format( result, format );
+			}
+
+			break;
+		}
+		case FOOBAR_PANEL_ITEM_KIND_WORKSPACES:
+		{
+			result = foobar_panel_item_workspaces_configuration_new( );
+
+			gint button_size;
+			if ( try_get_int_value( file, group, "button-size", VALIDATE_POSITIVE, &button_size ) )
+			{
+				foobar_panel_item_workspaces_configuration_set_button_size( result, button_size );
+			}
+
+			gint spacing;
+			if ( try_get_int_value( file, group, "spacing", VALIDATE_NON_NEGATIVE, &spacing ) )
+			{
+				foobar_panel_item_workspaces_configuration_set_spacing( result, spacing );
+			}
+
+			break;
+		}
+		case FOOBAR_PANEL_ITEM_KIND_STATUS:
+		{
+			result = foobar_panel_item_status_configuration_new( );
+
+			g_autofree gpointer items = NULL;
+			gsize items_count;
+			if ( try_get_enum_list_value( file, group, "items", FOOBAR_TYPE_STATUS_ITEM, VALIDATE_DISTINCT, &items, &items_count ) )
+			{
+				foobar_panel_item_status_configuration_set_items( result, items, items_count );
+			}
+
+			gint spacing;
+			if ( try_get_int_value( file, group, "spacing", VALIDATE_NON_NEGATIVE, &spacing ) )
+			{
+				foobar_panel_item_status_configuration_set_spacing( result, spacing );
+			}
+
+			gboolean show_labels;
+			if ( try_get_boolean_value( file, group, "show-labels", VALIDATE_NONE, &show_labels ) )
+			{
+				foobar_panel_item_status_configuration_set_show_labels( result, show_labels );
+			}
+
+			gboolean enable_scrolling;
+			if ( try_get_boolean_value( file, group, "enable-scrolling", VALIDATE_NONE, &enable_scrolling ) )
+			{
+				foobar_panel_item_status_configuration_set_enable_scrolling( result, enable_scrolling );
+			}
+
+			break;
+		}
+		default:
+		{
+			g_warn_if_reached( );
+			return NULL;
+		}
+	}
+
+	gchar const* name = group + strlen( "panel." );
+	foobar_panel_item_configuration_set_name( result, name );
+
+	gint position;
+	if ( try_get_enum_value( file, group, "position", FOOBAR_TYPE_PANEL_ITEM_POSITION, VALIDATE_NONE, &position ) )
+	{
+		foobar_panel_item_configuration_set_position( result, position );
+	}
+
+	gint action;
+	if ( try_get_enum_value( file, group, "action", FOOBAR_TYPE_PANEL_ITEM_ACTION, VALIDATE_NONE, &action ) )
+	{
+		foobar_panel_item_configuration_set_action( result, action );
+	}
+
+	return result;
+}
+
+//
+// Store a panel item configuration structure in the "panel.[name]" section of a keyfile.
+//
+void foobar_panel_item_configuration_store(
+	FoobarPanelItemConfiguration const* self,
+	GKeyFile* file )
+{
+	gchar const* name = foobar_panel_item_configuration_get_name( self );
+	g_autofree gchar* group = g_strdup_printf( "panel.%s", name );
+
+	FoobarPanelItemKind kind = foobar_panel_item_configuration_get_kind( self );
+	g_key_file_set_string( file, group, "kind", enum_value_to_string( FOOBAR_TYPE_PANEL_ITEM_KIND, kind ) );
+
+	FoobarPanelItemPosition position = foobar_panel_item_configuration_get_position( self );
+	g_key_file_set_string( file, group, "position", enum_value_to_string( FOOBAR_TYPE_PANEL_ITEM_POSITION, position ) );
+
+	FoobarPanelItemAction action = foobar_panel_item_configuration_get_action( self );
+	g_key_file_set_string( file, group, "action", enum_value_to_string( FOOBAR_TYPE_PANEL_ITEM_ACTION, action ) );
+
+	switch ( kind )
+	{
+		case FOOBAR_PANEL_ITEM_KIND_ICON:
+		{
+			gchar const* icon_name = foobar_panel_item_icon_configuration_get_icon_name( self );
+			g_key_file_set_string( file, group, "icon-name", icon_name );
+			g_key_file_set_comment(
+				file,
+				group,
+				"icon-name",
+				" The GTK icon to use for the item.",
+				NULL );
+
+			break;
+		}
+		case FOOBAR_PANEL_ITEM_KIND_CLOCK:
+		{
+			gchar const* format = foobar_panel_item_clock_configuration_get_format( self );
+			g_key_file_set_string( file, group, "format", format );
+			g_key_file_set_comment(
+				file,
+				group,
+				"format",
+				" The time format string as used by g_date_time_format.",
+				NULL );
+
+			break;
+		}
+		case FOOBAR_PANEL_ITEM_KIND_WORKSPACES:
+		{
+			gint button_size = foobar_panel_item_workspaces_configuration_get_button_size( self );
+			g_key_file_set_integer( file, group, "button-size", button_size );
+			g_key_file_set_comment(
+				file,
+				group,
+				"button-size",
+				" Size of each workspace button.",
+				NULL );
+
+			gint spacing = foobar_panel_item_workspaces_configuration_get_spacing( self );
+			g_key_file_set_integer( file, group, "spacing", spacing );
+			g_key_file_set_comment(
+				file,
+				group,
+				"spacing",
+				" Inner spacing between the workspace buttons.",
+				NULL );
+
+			break;
+		}
+		case FOOBAR_PANEL_ITEM_KIND_STATUS:
+		{
+			gsize items_count;
+			FoobarStatusItem const* items = foobar_panel_item_status_configuration_get_items( self, &items_count );
+			g_autofree gchar const** items_str = enum_list_to_string( FOOBAR_TYPE_STATUS_ITEM, items, items_count );
+			g_key_file_set_string_list( file, group, "items", items_str, items_count );
+			g_key_file_set_comment(
+				file,
+				group,
+				"items",
+				" Ordered list of status items to display in the item.",
+				NULL );
+
+			gint spacing = foobar_panel_item_status_configuration_get_spacing( self );
+			g_key_file_set_integer( file, group, "spacing", spacing );
+			g_key_file_set_comment(
+				file,
+				group,
+				"spacing",
+				" Inner spacing between the status items.",
+				NULL );
+
+			gboolean show_labels = foobar_panel_item_status_configuration_get_show_labels( self );
+			g_key_file_set_boolean( file, group, "show-labels", show_labels );
+			g_key_file_set_comment(
+				file,
+				group,
+				"show-labels",
+				" Indicates whether text labels should be shown next to the status icons.",
+				NULL );
+
+			gboolean enable_scrolling = foobar_panel_item_status_configuration_get_enable_scrolling( self );
+			g_key_file_set_boolean( file, group, "enable-scrolling", enable_scrolling );
+			g_key_file_set_comment(
+				file,
+				group,
+				"enable-scrolling",
+				" If set to true, some settings like volume or brightness can be adjusted by scrolling while hovering"
+				" over the status item.",
+				NULL );
+
+			break;
+		}
+		default:
+		{
+			g_warn_if_reached( );
+			break;
+		}
+	}
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Panel Configuration
+// ---------------------------------------------------------------------------------------------------------------------
+
+//
+// Create a default panel configuration structure.
+//
+FoobarPanelConfiguration* foobar_panel_configuration_new( void )
+{
+	return foobar_panel_configuration_copy( &default_panel_configuration );
+}
+
+//
+// Create a mutable copy of another panel configuration structure.
+//
+FoobarPanelConfiguration* foobar_panel_configuration_copy( FoobarPanelConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, NULL );
+
+	FoobarPanelConfiguration* copy = g_new0( FoobarPanelConfiguration, 1 );
+	copy->position = self->position;
+	copy->margin = self->margin;
+	copy->padding = self->padding;
+	copy->size = self->size;
+	copy->spacing = self->spacing;
+	copy->multi_monitor = self->multi_monitor;
+	copy->items = g_new( FoobarPanelItemConfiguration*, self->items_count + 1 );
+	copy->items_count = self->items_count;
+	for ( gsize i = 0; i < copy->items_count; ++i )
+	{
+		copy->items[i] = foobar_panel_item_configuration_copy( self->items[i] );
+	}
+	return copy;
+}
+
+//
+// Release resources associated with a panel configuration structure.
+//
+void foobar_panel_configuration_free( FoobarPanelConfiguration* self )
+{
+	g_return_if_fail( self != NULL );
+
+	for ( gsize i = 0; i < self->items_count; ++i )
+	{
+		foobar_panel_item_configuration_free( self->items[i] );
+	}
+	g_free( self->items );
+	g_free( self );
+}
+
+//
+// Check if two panel configuration structures are equal.
+//
+gboolean foobar_panel_configuration_equal(
+	FoobarPanelConfiguration const* a,
+	FoobarPanelConfiguration const* b )
+{
+	g_return_val_if_fail( a != NULL, FALSE );
+	g_return_val_if_fail( b != NULL, FALSE );
+
+	if ( a->position != b->position ) { return FALSE; }
+	if ( a->margin != b->margin ) { return FALSE; }
+	if ( a->padding != b->padding ) { return FALSE; }
+	if ( a->size != b->size ) { return FALSE; }
+	if ( a->spacing != b->spacing ) { return FALSE; }
+	if ( a->multi_monitor != b->multi_monitor ) { return FALSE; }
+	if ( a->items_count != b->items_count ) { return FALSE; }
+
+	for ( gsize i = 0; i < a->items_count; ++i )
+	{
+		if ( !foobar_panel_item_configuration_equal( a->items[i], b->items[i] ) ) { return FALSE; }
+	}
+
+	return TRUE;
+}
+
+//
+// The screen edge which the panel should appear on.
+//
+FoobarScreenEdge foobar_panel_configuration_get_position( FoobarPanelConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	return self->position;
+}
+
+//
+// Offset of the panel from all screen edges.
+//
+gint foobar_panel_configuration_get_margin( FoobarPanelConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	return self->margin;
+}
+
+//
+// Inset of the panel along its orientation.
+//
+gint foobar_panel_configuration_get_padding( FoobarPanelConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	return self->padding;
+}
+
+//
+// Size of the panel (depending on the orientation, this can be either the width or the height).
+//
+gint foobar_panel_configuration_get_size( FoobarPanelConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	return self->size;
+}
+
+//
+// Spacing between panel items.
+//
+gint foobar_panel_configuration_get_spacing( FoobarPanelConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	return self->spacing;
+}
+
+//
+// Flag to enable the panel on all monitors.
+//
+gboolean foobar_panel_configuration_get_multi_monitor( FoobarPanelConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, FALSE );
+	return self->multi_monitor;
+}
+
+//
+// Items configured to be displayed in the panel.
+//
+FoobarPanelItemConfiguration const* const* foobar_panel_configuration_get_items(
+	FoobarPanelConfiguration const* self,
+	gsize*                          out_count )
+{
+	g_return_val_if_fail( self != NULL, NULL );
+
+	if ( out_count ) { *out_count = self->items_count; }
+	return (FoobarPanelItemConfiguration const* const*)self->items;
+}
+
+//
+// Mutable items configured to be displayed in the panel.
+//
+FoobarPanelItemConfiguration* const* foobar_panel_configuration_get_items_mut(
+	FoobarPanelConfiguration* self,
+	gsize*                    out_count )
+{
+	g_return_val_if_fail( self != NULL, NULL );
+
+	if ( out_count ) { *out_count = self->items_count; }
+	return self->items;
+}
+
+//
+// The screen edge which the panel should appear on.
+//
+void foobar_panel_configuration_set_position(
+	FoobarPanelConfiguration* self,
+	FoobarScreenEdge          value )
+{
+	g_return_if_fail( self != NULL );
+	self->position = value;
+}
+
+//
+// Offset of the panel from all screen edges.
+//
+void foobar_panel_configuration_set_margin(
+	FoobarPanelConfiguration* self,
+	gint                      value )
+{
+	g_return_if_fail( self != NULL );
+	self->margin = value;
+}
+
+//
+// Inset of the panel along its orientation.
+//
+void foobar_panel_configuration_set_padding(
+	FoobarPanelConfiguration* self,
+	gint                      value )
+{
+	g_return_if_fail( self != NULL );
+	self->padding = value;
+}
+
+//
+// Size of the panel (depending on the orientation, this can be either the width or the height).
+//
+void foobar_panel_configuration_set_size(
+	FoobarPanelConfiguration* self,
+	gint                      value )
+{
+	g_return_if_fail( self != NULL );
+	self->size = value;
+}
+
+//
+// Spacing between panel items.
+//
+void foobar_panel_configuration_set_spacing(
+	FoobarPanelConfiguration* self,
+	gint                      value )
+{
+	g_return_if_fail( self != NULL );
+	self->spacing = value;
+}
+
+//
+// Flag to enable the panel on all monitors.
+//
+void foobar_panel_configuration_set_multi_monitor(
+	FoobarPanelConfiguration* self,
+	gboolean                  value )
+{
+	g_return_if_fail( self != NULL );
+	self->multi_monitor = value;
+}
+
+//
+// Items configured to be displayed in the panel.
+//
+void foobar_panel_configuration_set_items(
+	FoobarPanelConfiguration*                  self,
+	FoobarPanelItemConfiguration const* const* value,
+	gsize                                      value_count )
+{
+	g_return_if_fail( self != NULL );
+	g_return_if_fail( value != NULL || value_count == 0 );
+
+	for ( gsize i = 0; i < self->items_count; ++i )
+	{
+		foobar_panel_item_configuration_free( self->items[i] );
+	}
+	g_free( self->items );
+	self->items = g_new0( FoobarPanelItemConfiguration*, value_count + 1 );
+	self->items_count = 0;
+	for ( gsize i = 0; i < value_count; ++i )
+	{
+		g_warn_if_fail( value[i] != NULL );
+		if ( value[i] )
+		{
+			self->items[self->items_count++] = foobar_panel_item_configuration_copy( value[i] );
+		}
+	}
+}
+
+//
+// Populate a panel configuration structure from the "panel" section of a keyfile.
+//
+void foobar_panel_configuration_load(
+	FoobarPanelConfiguration* self,
+	GKeyFile*                 file )
+{
+	gint position;
+	if ( try_get_enum_value( file, "panel", "position", FOOBAR_TYPE_SCREEN_EDGE, VALIDATE_NONE, &position ) )
+	{
+		foobar_panel_configuration_set_position( self, position );
+	}
+
+	gint margin;
+	if ( try_get_int_value( file, "panel", "margin", VALIDATE_NON_NEGATIVE, &margin ) )
+	{
+		foobar_panel_configuration_set_margin( self, margin );
+	}
+
+	gint padding;
+	if ( try_get_int_value( file, "panel", "padding", VALIDATE_NON_NEGATIVE, &padding ) )
+	{
+		foobar_panel_configuration_set_padding( self, padding );
+	}
+
+	gint size;
+	if ( try_get_int_value( file, "panel", "size", VALIDATE_POSITIVE, &size ) )
+	{
+		foobar_panel_configuration_set_size( self, size );
+	}
+
+	gint spacing;
+	if ( try_get_int_value( file, "panel", "spacing", VALIDATE_NON_NEGATIVE, &spacing ) )
+	{
+		foobar_panel_configuration_set_spacing( self, spacing );
+	}
+
+	gboolean multi_monitor;
+	if ( try_get_boolean_value( file, "panel", "multi-monitor", VALIDATE_NONE, &multi_monitor ) )
+	{
+		foobar_panel_configuration_set_multi_monitor( self, multi_monitor );
+	}
+
+	g_autoptr( GPtrArray ) items = g_ptr_array_new_with_free_func( (GDestroyNotify)foobar_panel_item_configuration_free );
+	g_auto( GStrv ) groups = g_key_file_get_groups( file, NULL );
+	for ( gchar** it = groups; *it; ++it )
+	{
+		FoobarPanelItemConfiguration* item = foobar_panel_item_configuration_load( file, *it );
+		if ( item ) { g_ptr_array_add( items, item ); }
+	}
+	foobar_panel_configuration_set_items( self, (FoobarPanelItemConfiguration const* const*)items->pdata, items->len );
+}
+
+//
+// Store a panel configuration structure in the "panel" section of a keyfile.
+//
+void foobar_panel_configuration_store(
+	FoobarPanelConfiguration const* self,
+	GKeyFile*                       file )
+{
+	FoobarScreenEdge position = foobar_panel_configuration_get_position( self );
+	g_key_file_set_string( file, "panel", "position", enum_value_to_string( FOOBAR_TYPE_SCREEN_EDGE, position ) );
+	g_key_file_set_comment(
+		file,
+		"panel",
+		"position",
+		" The screen edge which the panel should appear on.",
+		NULL );
+
+	gint margin = foobar_panel_configuration_get_margin( self );
+	g_key_file_set_integer( file, "panel", "margin", margin );
+	g_key_file_set_comment(
+		file,
+		"panel",
+		"margin",
+		" Offset of the panel from all screen edges.",
+		NULL );
+
+	gint padding = foobar_panel_configuration_get_padding( self );
+	g_key_file_set_integer( file, "panel", "padding", padding );
+	g_key_file_set_comment(
+		file,
+		"panel",
+		"padding",
+		" Inset of the panel along its orientation.",
+		NULL );
+
+	gint size = foobar_panel_configuration_get_size( self );
+	g_key_file_set_integer( file, "panel", "size", size );
+	g_key_file_set_comment(
+		file,
+		"panel",
+		"size",
+		" Size of the panel (depending on the orientation, this can be either the width or the height).",
+		NULL );
+
+	gint spacing = foobar_panel_configuration_get_spacing( self );
+	g_key_file_set_integer( file, "panel", "spacing", spacing );
+	g_key_file_set_comment(
+		file,
+		"panel",
+		"spacing",
+		" Spacing between panel items.",
+		NULL );
+
+	gboolean multi_monitor = foobar_panel_configuration_get_multi_monitor( self );
+	g_key_file_set_boolean( file, "panel", "multi-monitor", multi_monitor );
+	g_key_file_set_comment(
+		file,
+		"panel",
+		"multi-monitor",
+		" Flag to enable the panel on all monitors.",
+		NULL );
+
+	gsize items_count;
+	FoobarPanelItemConfiguration const* const* items = foobar_panel_configuration_get_items( self, &items_count );
+	for ( gsize i = 0; i < items_count; ++i )
+	{
+		foobar_panel_item_configuration_store( items[i], file );
+	}
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Launcher Configuration
+// ---------------------------------------------------------------------------------------------------------------------
+
+//
+// Create a default launcher configuration structure.
+//
+FoobarLauncherConfiguration* foobar_launcher_configuration_new( void )
+{
+	return foobar_launcher_configuration_copy( &default_launcher_configuration );
+}
+
+//
+// Create a mutable copy of another launcher configuration structure.
+//
+FoobarLauncherConfiguration* foobar_launcher_configuration_copy( FoobarLauncherConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, NULL );
+
+	FoobarLauncherConfiguration* copy = g_new0( FoobarLauncherConfiguration, 1 );
+	copy->width = self->width;
+	copy->position = self->position;
+	copy->max_height = self->max_height;
+	return copy;
+}
+
+//
+// Release resources associated with a launcher configuration structure.
+//
+void foobar_launcher_configuration_free( FoobarLauncherConfiguration* self )
+{
+	g_return_if_fail( self != NULL );
+
+	g_free( self );
+}
+
+//
+// Check if two launcher configuration structures are equal.
+//
+gboolean foobar_launcher_configuration_equal(
+	FoobarLauncherConfiguration const* a,
+	FoobarLauncherConfiguration const* b )
+{
+	g_return_val_if_fail( a != NULL, FALSE );
+	g_return_val_if_fail( b != NULL, FALSE );
+
+	if ( a->width != b->width ) { return FALSE; }
+	if ( a->position != b->position ) { return FALSE; }
+	if ( a->max_height != b->max_height ) { return FALSE; }
+
+	return TRUE;
+}
+
+//
+// Horizontal size of the launcher.
+//
+gint foobar_launcher_configuration_get_width( FoobarLauncherConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	return self->width;
+}
+
+//
+// Offset from the top of the screen.
+//
+gint foobar_launcher_configuration_get_position( FoobarLauncherConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	return self->position;
+}
+
+//
+// Maximum allowed height for the launcher before scrolling is enabled.
+//
+gint foobar_launcher_configuration_get_max_height( FoobarLauncherConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	return self->max_height;
+}
+
+//
+// Horizontal size of the launcher.
+//
+void foobar_launcher_configuration_set_width(
+	FoobarLauncherConfiguration* self,
+	gint                         value )
+{
+	g_return_if_fail( self != NULL );
+	self->width = value;
+}
+
+//
+// Offset from the top of the screen.
+//
+void foobar_launcher_configuration_set_position(
+	FoobarLauncherConfiguration* self,
+	gint                         value )
+{
+	g_return_if_fail( self != NULL );
+	self->position = value;
+}
+
+//
+// Maximum allowed height for the launcher before scrolling is enabled.
+//
+void foobar_launcher_configuration_set_max_height(
+	FoobarLauncherConfiguration* self,
+	gint                         value )
+{
+	g_return_if_fail( self != NULL );
+	self->max_height = value;
+}
+
+//
+// Populate a launcher configuration structure from the "launcher" section of a keyfile.
+//
+void foobar_launcher_configuration_load(
+	FoobarLauncherConfiguration* self,
+	GKeyFile*                    file )
+{
+	gint width;
+	if ( try_get_int_value( file, "launcher", "width", VALIDATE_POSITIVE, &width ) )
+	{
+		foobar_launcher_configuration_set_width( self, width );
+	}
+
+	gint position;
+	if ( try_get_int_value( file, "launcher", "position", VALIDATE_NON_NEGATIVE, &position ) )
+	{
+		foobar_launcher_configuration_set_position( self, position );
+	}
+
+	gint max_height;
+	if ( try_get_int_value( file, "launcher", "max-height", VALIDATE_POSITIVE, &max_height ) )
+	{
+		foobar_launcher_configuration_set_position( self, max_height );
+	}
+}
+
+//
+// Store a launcher configuration structure in the "launcher" section of a keyfile.
+//
+void foobar_launcher_configuration_store(
+	FoobarLauncherConfiguration const* self,
+	GKeyFile*                          file )
+{
+	gint width = foobar_launcher_configuration_get_width( self );
+	g_key_file_set_integer( file, "launcher", "width", width );
+
+	gint position = foobar_launcher_configuration_get_position( self );
+	g_key_file_set_integer( file, "launcher", "position", position );
+	g_key_file_set_comment(
+		file,
+		"launcher",
+		"position",
+		" Offset from the top of the screen.",
+		NULL );
+
+	gint max_height = foobar_launcher_configuration_get_max_height( self );
+	g_key_file_set_integer( file, "launcher", "max-height", max_height );
+	g_key_file_set_comment(
+		file,
+		"launcher",
+		"max-height",
+		" Maximum allowed height for the launcher before scrolling is enabled.",
+		NULL );
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Control Center Configuration
+// ---------------------------------------------------------------------------------------------------------------------
+
+//
+// Create a default control center configuration structure.
+//
+FoobarControlCenterConfiguration* foobar_control_center_configuration_new( void )
+{
+	return foobar_control_center_configuration_copy( &default_control_center_configuration );
+}
+
+//
+// Create a mutable copy of another control center configuration structure.
+//
+FoobarControlCenterConfiguration* foobar_control_center_configuration_copy( FoobarControlCenterConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, NULL );
+
+	FoobarControlCenterConfiguration* copy = g_new0( FoobarControlCenterConfiguration, 1 );
+	copy->width = self->width;
+	copy->height = self->height;
+	copy->position = self->position;
+	copy->offset = self->offset;
+	copy->padding = self->padding;
+	copy->spacing = self->spacing;
+	copy->orientation = self->orientation;
+	copy->alignment = self->alignment;
+	copy->rows = g_new( FoobarControlCenterRow, self->rows_count );
+	copy->rows_count = self->rows_count;
+	memcpy( copy->rows, self->rows, sizeof( *copy->rows ) * copy->rows_count );
+	return copy;
+}
+
+//
+// Release resources associated with a control center configuration structure.
+//
+void foobar_control_center_configuration_free( FoobarControlCenterConfiguration* self )
+{
+	g_return_if_fail( self != NULL );
+
+	g_free( self->rows );
+	g_free( self );
+}
+
+//
+// Check if two control center configuration structures are equal.
+//
+gboolean foobar_control_center_configuration_equal(
+	FoobarControlCenterConfiguration const* a,
+	FoobarControlCenterConfiguration const* b )
+{
+	g_return_val_if_fail( a != NULL, FALSE );
+	g_return_val_if_fail( b != NULL, FALSE );
+
+	if ( a->width != b->width ) { return FALSE; }
+	if ( a->height != b->height ) { return FALSE; }
+	if ( a->position != b->position ) { return FALSE; }
+	if ( a->offset != b->offset ) { return FALSE; }
+	if ( a->padding != b->padding ) { return FALSE; }
+	if ( a->spacing != b->spacing ) { return FALSE; }
+	if ( a->orientation != b->orientation ) { return FALSE; }
+	if ( a->alignment != b->alignment ) { return FALSE; }
+	if ( a->rows_count != b->rows_count ) { return FALSE; }
+	if ( memcmp( a->rows, b->rows, sizeof( *a->rows ) * a->rows_count ) ) { return FALSE; }
+
+	return TRUE;
+}
+
+//
+// Horizontal size of the control center.
+//
+gint foobar_control_center_configuration_get_width( FoobarControlCenterConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	return self->width;
+}
+
+//
+// Vertical size of the control center.
+//
+gint foobar_control_center_configuration_get_height( FoobarControlCenterConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	return self->height;
+}
+
+//
+// The screen edge which the control center should be attached to.
+//
+FoobarScreenEdge foobar_control_center_configuration_get_position( FoobarControlCenterConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	return self->position;
+}
+
+//
+// Offset from the attached screen edge.
+//
+gint foobar_control_center_configuration_get_offset( FoobarControlCenterConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	return self->offset;
+}
+
+//
+// Spacing between the edges of the control center and its items.
+//
+gint foobar_control_center_configuration_get_padding( FoobarControlCenterConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	return self->padding;
+}
+
+//
+// Spacing between the items.
+//
+gint foobar_control_center_configuration_get_spacing( FoobarControlCenterConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	return self->spacing;
+}
+
+//
+// The orientation used to arrange the controls and notifications sections.
+//
+FoobarOrientation foobar_control_center_configuration_get_orientation( FoobarControlCenterConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	return self->orientation;
+}
+
+//
+// Alignment along the attached screen edge, or "fill".
+//
+FoobarControlCenterAlignment foobar_control_center_configuration_get_alignment( FoobarControlCenterConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	return self->alignment;
+}
+
+//
+// Ordered list of rows to display in the controls section.
+//
+FoobarControlCenterRow const* foobar_control_center_configuration_get_rows(
+	FoobarControlCenterConfiguration const* self,
+	gsize*                                  out_count )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	g_return_val_if_fail( out_count != NULL, NULL );
+
+	*out_count = self->rows_count;
+	return self->rows;
+}
+
+//
+// Horizontal size of the control center.
+//
+void foobar_control_center_configuration_set_width(
+	FoobarControlCenterConfiguration* self,
+	gint                              value )
+{
+	g_return_if_fail( self != NULL );
+	self->width = value;
+}
+
+//
+// Vertical size of the control center.
+//
+void foobar_control_center_configuration_set_height(
+	FoobarControlCenterConfiguration* self,
+	gint                              value )
+{
+	g_return_if_fail( self != NULL );
+	self->height = value;
+}
+
+//
+// The screen edge which the control center should be attached to.
+//
+void foobar_control_center_configuration_set_position(
+	FoobarControlCenterConfiguration* self,
+	FoobarScreenEdge                  value )
+{
+	g_return_if_fail( self != NULL );
+	self->position = value;
+}
+
+//
+// Offset from the attached screen edge.
+//
+void foobar_control_center_configuration_set_offset(
+	FoobarControlCenterConfiguration* self,
+	gint                              value )
+{
+	g_return_if_fail( self != NULL );
+	self->offset = value;
+}
+
+//
+// Spacing between the edges of the control center and its items.
+//
+void foobar_control_center_configuration_set_padding(
+	FoobarControlCenterConfiguration* self,
+	gint                              value )
+{
+	g_return_if_fail( self != NULL );
+	self->padding = value;
+}
+
+//
+// Spacing between the items.
+//
+void foobar_control_center_configuration_set_spacing(
+	FoobarControlCenterConfiguration* self,
+	gint                              value )
+{
+	g_return_if_fail( self != NULL );
+	self->spacing = value;
+}
+
+//
+// The orientation used to arrange the controls and notifications sections.
+//
+void foobar_control_center_configuration_set_orientation(
+	FoobarControlCenterConfiguration* self,
+	FoobarOrientation                 value )
+{
+	g_return_if_fail( self != NULL );
+	self->orientation = value;
+}
+
+//
+// Alignment along the attached screen edge, or "fill".
+//
+void foobar_control_center_configuration_set_alignment(
+	FoobarControlCenterConfiguration* self,
+	FoobarControlCenterAlignment      value )
+{
+	g_return_if_fail( self != NULL );
+	self->alignment = value;
+}
+
+//
+// Ordered list of rows to display in the controls section.
+//
+void foobar_control_center_configuration_set_rows(
+	FoobarControlCenterConfiguration* self,
+	FoobarControlCenterRow const*     value,
+	gsize                             value_count )
+{
+	g_return_if_fail( self != NULL );
+	g_return_if_fail( value != NULL || value_count == 0 );
+
+	g_free( self->rows );
+	self->rows = g_new( FoobarControlCenterRow, value_count );
+	self->rows_count = value_count;
+	memcpy( self->rows, value, sizeof( *self->rows ) * self->rows_count );
+}
+
+//
+// Populate a control center configuration structure from the "control-center" section of a keyfile.
+//
+void foobar_control_center_configuration_load(
+	FoobarControlCenterConfiguration* self,
+	GKeyFile*                         file )
+{
+	gint width;
+	if ( try_get_int_value( file, "control-center", "width", VALIDATE_POSITIVE, &width ) )
+	{
+		foobar_control_center_configuration_set_width( self, width );
+	}
+
+	gint height;
+	if ( try_get_int_value( file, "control-center", "height", VALIDATE_POSITIVE, &height ) )
+	{
+		foobar_control_center_configuration_set_height( self, height );
+	}
+
+	gint position;
+	if ( try_get_enum_value( file, "control-center", "position", FOOBAR_TYPE_SCREEN_EDGE, VALIDATE_NONE, &position ) )
+	{
+		foobar_control_center_configuration_set_position( self, position );
+	}
+
+	gint offset;
+	if ( try_get_int_value( file, "control-center", "offset", VALIDATE_NON_NEGATIVE, &offset ) )
+	{
+		foobar_control_center_configuration_set_offset( self, offset );
+	}
+
+	gint padding;
+	if ( try_get_int_value( file, "control-center", "padding", VALIDATE_NON_NEGATIVE, &padding ) )
+	{
+		foobar_control_center_configuration_set_padding( self, padding );
+	}
+
+	gint spacing;
+	if ( try_get_int_value( file, "control-center", "spacing", VALIDATE_NON_NEGATIVE, &spacing ) )
+	{
+		foobar_control_center_configuration_set_spacing( self, spacing );
+	}
+
+	gint orientation;
+	if ( try_get_enum_value( file, "control-center", "orientation", FOOBAR_TYPE_ORIENTATION, VALIDATE_NONE, &orientation ) )
+	{
+		foobar_control_center_configuration_set_orientation( self, orientation );
+	}
+
+	gint alignment;
+	if ( try_get_enum_value( file, "control-center", "alignment", FOOBAR_TYPE_CONTROL_CENTER_ALIGNMENT, VALIDATE_NONE, &alignment ) )
+	{
+		foobar_control_center_configuration_set_alignment( self, alignment );
+	}
+
+	g_autofree gpointer rows = NULL;
+	gsize rows_count;
+	if ( try_get_enum_list_value( file, "control-center", "rows", FOOBAR_TYPE_CONTROL_CENTER_ROW, VALIDATE_DISTINCT, &rows, &rows_count ) )
+	{
+		foobar_control_center_configuration_set_rows( self, rows, rows_count );
+	}
+}
+
+//
+// Store a control center configuration structure in the "control-center" section of a keyfile.
+//
+void foobar_control_center_configuration_store(
+	FoobarControlCenterConfiguration const* self,
+	GKeyFile*                               file )
+{
+	gint width = foobar_control_center_configuration_get_width( self );
+	g_key_file_set_integer( file, "control-center", "width", width );
+
+	gint height = foobar_control_center_configuration_get_height( self );
+	g_key_file_set_integer( file, "control-center", "height", height );
+
+	FoobarScreenEdge position = foobar_control_center_configuration_get_position( self );
+	g_key_file_set_string( file, "control-center", "position", enum_value_to_string( FOOBAR_TYPE_SCREEN_EDGE, position ) );
+	g_key_file_set_comment(
+		file,
+		"control-center",
+		"position",
+		" The screen edge which the control center should be attached to.",
+		NULL );
+
+	gint offset = foobar_control_center_configuration_get_offset( self );
+	g_key_file_set_integer( file, "control-center", "offset", offset );
+	g_key_file_set_comment(
+		file,
+		"control-center",
+		"offset",
+		" Offset from the attached screen edge.",
+		NULL );
+
+	gint padding = foobar_control_center_configuration_get_padding( self );
+	g_key_file_set_integer( file, "control-center", "padding", padding );
+	g_key_file_set_comment(
+		file,
+		"control-center",
+		"padding",
+		" Spacing between the edges of the control center and its items.",
+		NULL );
+
+	gint spacing = foobar_control_center_configuration_get_spacing( self );
+	g_key_file_set_integer( file, "control-center", "spacing", spacing );
+	g_key_file_set_comment(
+		file,
+		"control-center",
+		"spacing",
+		" Spacing between the items.",
+		NULL );
+
+	FoobarOrientation orientation = foobar_control_center_configuration_get_orientation( self );
+	g_key_file_set_string( file, "control-center", "orientation", enum_value_to_string( FOOBAR_TYPE_ORIENTATION, orientation ) );
+	g_key_file_set_comment(
+		file,
+		"control-center",
+		"orientation",
+		" The orientation used to arrange the controls and notifications sections.",
+		NULL );
+
+	FoobarControlCenterAlignment alignment = foobar_control_center_configuration_get_alignment( self );
+	g_key_file_set_string( file, "control-center", "alignment", enum_value_to_string( FOOBAR_TYPE_CONTROL_CENTER_ALIGNMENT, alignment ) );
+	g_key_file_set_comment(
+		file,
+		"control-center",
+		"alignment",
+		" Alignment along the attached screen edge, or \"fill\".",
+		NULL );
+
+	gsize rows_count;
+	FoobarControlCenterRow const* rows = foobar_control_center_configuration_get_rows( self, &rows_count );
+	g_autofree gchar const** rows_str = enum_list_to_string( FOOBAR_TYPE_CONTROL_CENTER_ROW, rows, rows_count );
+	g_key_file_set_string_list( file, "control-center", "rows", rows_str, rows_count );
+	g_key_file_set_comment(
+		file,
+		"control-center",
+		"rows",
+		" Ordered list of rows to display in the controls section.",
+		NULL );
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Notification Configuration
+// ---------------------------------------------------------------------------------------------------------------------
+
+//
+// Create a default notification configuration structure.
+//
+FoobarNotificationConfiguration* foobar_notification_configuration_new( void )
+{
+	return foobar_notification_configuration_copy( &default_notification_configuration );
+}
+
+//
+// Create a mutable copy of another notification configuration structure.
+//
+FoobarNotificationConfiguration* foobar_notification_configuration_copy( FoobarNotificationConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, NULL );
+
+	FoobarNotificationConfiguration* copy = g_new0( FoobarNotificationConfiguration, 1 );
+	copy->width = self->width;
+	copy->min_height = self->min_height;
+	copy->spacing = self->spacing;
+	copy->close_button_inset = self->close_button_inset;
+	copy->time_format = g_strdup( self->time_format );
+	return copy;
+}
+
+//
+// Release resources associated with a notification configuration structure.
+//
+void foobar_notification_configuration_free( FoobarNotificationConfiguration* self )
+{
+	g_return_if_fail( self != NULL );
+
+	g_free( self->time_format );
+	g_free( self );
+}
+
+//
+// Check if two notification configuration structures are equal.
+//
+gboolean foobar_notification_configuration_equal(
+	FoobarNotificationConfiguration const* a,
+	FoobarNotificationConfiguration const* b )
+{
+	g_return_val_if_fail( a != NULL, FALSE );
+	g_return_val_if_fail( b != NULL, FALSE );
+
+	if ( a->width != b->width ) { return FALSE; }
+	if ( a->min_height != b->min_height ) { return FALSE; }
+	if ( a->spacing != b->spacing ) { return FALSE; }
+	if ( a->close_button_inset != b->close_button_inset ) { return FALSE; }
+	if ( g_strcmp0( a->time_format, b->time_format ) ) { return FALSE; }
+
+	return TRUE;
+}
+
+//
+// Horizontal size of notifications in the notification area.
+//
+gint foobar_notification_configuration_get_width( FoobarNotificationConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	return self->width;
+}
+
+//
+// Minimum height for each notification.
+//
+gint foobar_notification_configuration_get_min_height( FoobarNotificationConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	return self->min_height;
+}
+
+//
+// Spacing between notifications and from the screen edges.
+//
+gint foobar_notification_configuration_get_spacing( FoobarNotificationConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	return self->spacing;
+}
+
+//
+// Inset of the close button within the notification (may be negative).
+//
+gint foobar_notification_configuration_get_close_button_inset( FoobarNotificationConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, 0 );
+	return self->close_button_inset;
+}
+
+//
+// The time format string as used by g_date_time_format.
+//
+gchar const* foobar_notification_configuration_get_time_format( FoobarNotificationConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, NULL );
+	return self->time_format;
+}
+
+//
+// Horizontal size of notifications in the notification area.
+//
+void foobar_notification_configuration_set_width(
+	FoobarNotificationConfiguration* self,
+	gint                             value )
+{
+	g_return_if_fail( self != NULL );
+	self->width = value;
+}
+
+//
+// Minimum height for each notification.
+//
+void foobar_notification_configuration_set_min_height(
+	FoobarNotificationConfiguration* self,
+	gint                             value )
+{
+	g_return_if_fail( self != NULL );
+	self->min_height = value;
+}
+
+//
+// Spacing between notifications and from the screen edges.
+//
+void foobar_notification_configuration_set_spacing(
+	FoobarNotificationConfiguration* self,
+	gint                             value )
+{
+	g_return_if_fail( self != NULL );
+	self->spacing = value;
+}
+
+//
+// Inset of the close button within the notification (may be negative).
+//
+void foobar_notification_configuration_set_close_button_inset(
+	FoobarNotificationConfiguration* self,
+	gint                             value )
+{
+	g_return_if_fail( self != NULL );
+	self->close_button_inset = value;
+}
+
+//
+// The time format string as used by g_date_time_format.
+//
+void foobar_notification_configuration_set_time_format(
+	FoobarNotificationConfiguration* self,
+	gchar const*                     value )
+{
+	g_return_if_fail( self != NULL );
+	g_return_if_fail( value != NULL );
+
+	g_free( self->time_format );
+	self->time_format = g_strdup( value );
+}
+
+//
+// Populate a notification configuration structure from the "notifications" section of a keyfile.
+//
+void foobar_notification_configuration_load(
+	FoobarNotificationConfiguration* self,
+	GKeyFile*                        file )
+{
+	gint width;
+	if ( try_get_int_value( file, "notifications", "width", VALIDATE_POSITIVE, &width ) )
+	{
+		foobar_notification_configuration_set_width( self, width );
+	}
+
+	gint min_height;
+	if ( try_get_int_value( file, "notifications", "min-height", VALIDATE_NON_NEGATIVE, &min_height ) )
+	{
+		foobar_notification_configuration_set_min_height( self, min_height );
+	}
+
+	gint spacing;
+	if ( try_get_int_value( file, "notifications", "spacing", VALIDATE_NON_NEGATIVE, &spacing ) )
+	{
+		foobar_notification_configuration_set_spacing( self, spacing );
+	}
+
+	gint close_button_inset;
+	if ( try_get_int_value( file, "notifications", "close-button-inset", VALIDATE_NONE, &close_button_inset ) )
+	{
+		foobar_notification_configuration_set_close_button_inset( self, close_button_inset );
+	}
+
+	g_autofree gchar* time_format = NULL;
+	if ( try_get_string_value( file, "notifications", "time-format", VALIDATE_NONE, &time_format ) )
+	{
+		foobar_notification_configuration_set_time_format( self, time_format );
+	}
+}
+
+//
+// Store a notification configuration structure in the "notifications" section of a keyfile.
+//
+void foobar_notification_configuration_store(
+	FoobarNotificationConfiguration const* self,
+	GKeyFile*                              file )
+{
+	gint width = foobar_notification_configuration_get_width( self );
+	g_key_file_set_integer( file, "notifications", "width", width );
+
+	gint min_height = foobar_notification_configuration_get_min_height( self );
+	g_key_file_set_integer( file, "notifications", "min-height", min_height );
+	g_key_file_set_comment(
+		file,
+		"notifications",
+		"min-height",
+		" Minimum height for each notification.",
+		NULL );
+
+	gint spacing = foobar_notification_configuration_get_spacing( self );
+	g_key_file_set_integer( file, "notifications", "spacing", spacing );
+	g_key_file_set_comment(
+		file,
+		"notifications",
+		"spacing",
+		" Spacing between notifications and from the screen edges.",
+		NULL );
+
+	gint close_button_inset = foobar_notification_configuration_get_close_button_inset( self );
+	g_key_file_set_integer( file, "notifications", "close-button-inset", close_button_inset );
+	g_key_file_set_comment(
+		file,
+		"notifications",
+		"close-button-inset",
+		" Inset of the close button within the notification (may be negative).",
+		NULL );
+
+	gchar const* time_format = foobar_notification_configuration_get_time_format( self );
+	g_key_file_set_string( file, "notifications", "time-format", time_format );
+	g_key_file_set_comment(
+		file,
+		"notifications",
+		"time-format",
+		" The time format string as used by g_date_time_format.",
+		NULL );
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Configuration
+// ---------------------------------------------------------------------------------------------------------------------
+
+//
+// Create a default configuration structure.
+//
+FoobarConfiguration* foobar_configuration_new( void )
+{
+	return foobar_configuration_copy( &default_configuration );
+}
+
+//
+// Create a mutable copy of another configuration structure.
+//
+FoobarConfiguration* foobar_configuration_copy( FoobarConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, NULL );
+
+	FoobarConfiguration* copy = g_new0( FoobarConfiguration, 1 );
+	copy->general = foobar_general_configuration_copy( self->general );
+	copy->panel = foobar_panel_configuration_copy( self->panel );
+	copy->launcher = foobar_launcher_configuration_copy( self->launcher );
+	copy->control_center = foobar_control_center_configuration_copy( self->control_center );
+	copy->notifications = foobar_notification_configuration_copy( self->notifications );
+	return copy;
+}
+
+//
+// Release resources associated with a configuration structure.
+//
+void foobar_configuration_free( FoobarConfiguration* self )
+{
+	g_return_if_fail( self != NULL );
+
+	foobar_general_configuration_free( self->general );
+	foobar_panel_configuration_free( self->panel );
+	foobar_launcher_configuration_free( self->launcher );
+	foobar_control_center_configuration_free( self->control_center );
+	foobar_notification_configuration_free( self->notifications );
+	g_free( self );
+}
+
+//
+// Check if two configuration structures are equal.
+//
+gboolean foobar_configuration_equal(
+	FoobarConfiguration const* a,
+	FoobarConfiguration const* b )
+{
+	g_return_val_if_fail( a != NULL, FALSE );
+	g_return_val_if_fail( b != NULL, FALSE );
+
+	if ( !foobar_general_configuration_equal( a->general, b->general ) ) { return FALSE; }
+	if ( !foobar_panel_configuration_equal( a->panel, b->panel ) ) { return FALSE; }
+	if ( !foobar_launcher_configuration_equal( a->launcher, b->launcher ) ) { return FALSE; }
+	if ( !foobar_control_center_configuration_equal( a->control_center, b->control_center ) ) { return FALSE; }
+	if ( !foobar_notification_configuration_equal( a->notifications, b->notifications ) ) { return FALSE; }
+
+	return TRUE;
+}
+
+//
+// Get the general application configuration.
+//
+FoobarGeneralConfiguration const* foobar_configuration_get_general( FoobarConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, NULL );
+	return self->general;
+}
+
+//
+// Get a mutable reference to the general application configuration.
+//
+FoobarGeneralConfiguration* foobar_configuration_get_general_mut( FoobarConfiguration* self )
+{
+	g_return_val_if_fail( self != NULL, NULL );
+	return self->general;
+}
+
+//
+// Get the panel configuration.
+//
+FoobarPanelConfiguration const* foobar_configuration_get_panel( FoobarConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, NULL );
+	return self->panel;
+}
+
+//
+// Get a mutable reference to the panel configuration.
+//
+FoobarPanelConfiguration* foobar_configuration_get_panel_mut( FoobarConfiguration* self )
+{
+	g_return_val_if_fail( self != NULL, NULL );
+	return self->panel;
+}
+
+//
+// Get the launcher configuration.
+//
+FoobarLauncherConfiguration const* foobar_configuration_get_launcher( FoobarConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, NULL );
+	return self->launcher;
+}
+
+//
+// Get a mutable reference to the launcher configuration.
+//
+FoobarLauncherConfiguration* foobar_configuration_get_launcher_mut( FoobarConfiguration* self )
+{
+	g_return_val_if_fail( self != NULL, NULL );
+	return self->launcher;
+}
+
+//
+// Get the control center configuration.
+//
+FoobarControlCenterConfiguration const* foobar_configuration_get_control_center( FoobarConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, NULL );
+	return self->control_center;
+}
+
+//
+// Get a mutable reference to the control center configuration.
+//
+FoobarControlCenterConfiguration* foobar_configuration_get_control_center_mut( FoobarConfiguration* self )
+{
+	g_return_val_if_fail( self != NULL, NULL );
+	return self->control_center;
+}
+
+//
+// Get the notification configuration.
+//
+FoobarNotificationConfiguration const* foobar_configuration_get_notifications( FoobarConfiguration const* self )
+{
+	g_return_val_if_fail( self != NULL, NULL );
+	return self->notifications;
+}
+
+//
+// Get a mutable reference to the notification configuration.
+//
+FoobarNotificationConfiguration* foobar_configuration_get_notifications_mut( FoobarConfiguration* self )
+{
+	g_return_val_if_fail( self != NULL, NULL );
+	return self->notifications;
+}
+
+//
+// Populate a configuration structure from a keyfile.
+//
+void foobar_configuration_load(
+	FoobarConfiguration* self,
+	GKeyFile*            file )
+{
+	foobar_general_configuration_load( foobar_configuration_get_general_mut( self ), file );
+	foobar_panel_configuration_load( foobar_configuration_get_panel_mut( self ), file );
+	foobar_launcher_configuration_load( foobar_configuration_get_launcher_mut( self ), file );
+	foobar_control_center_configuration_load( foobar_configuration_get_control_center_mut( self ), file );
+	foobar_notification_configuration_load( foobar_configuration_get_notifications_mut( self ), file );
+}
+
+//
+// Store a configuration structure in a keyfile.
+//
+void foobar_configuration_store(
+	FoobarConfiguration const* self,
+	GKeyFile*                  file )
+{
+	foobar_general_configuration_store( foobar_configuration_get_general( self ), file );
+	foobar_panel_configuration_store( foobar_configuration_get_panel( self ), file );
+	foobar_launcher_configuration_store( foobar_configuration_get_launcher( self ), file );
+	foobar_control_center_configuration_store( foobar_configuration_get_control_center( self ), file );
+	foobar_notification_configuration_store( foobar_configuration_get_notifications( self ), file );
+}
+
+//
+// Populate a configuration structure from a keyfile at the given path.
+//
+void foobar_configuration_load_from_file(
+	FoobarConfiguration* self,
+	gchar const*         path )
+{
+	g_autoptr( GKeyFile ) file = g_key_file_new( );
+	g_autoptr( GError ) error = NULL;
+	if ( !g_key_file_load_from_file( file, path, G_KEY_FILE_NONE, &error ) )
+	{
+		CONFIGURATION_WARNING( "%s", error->message );
+		return;
+	}
+	foobar_configuration_load( self, file );
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Service Implementation
+// ---------------------------------------------------------------------------------------------------------------------
+
+//
+// Static initialization for the configuration service.
+//
+void foobar_configuration_service_class_init( FoobarConfigurationServiceClass* klass )
+{
+	GObjectClass* object_klass = G_OBJECT_CLASS( klass );
+	object_klass->get_property = foobar_configuration_service_get_property;
+	object_klass->finalize = foobar_configuration_service_finalize;
+
+	props[PROP_CURRENT] = g_param_spec_boxed(
+		"current",
+		"Current",
+		"The current configuration state.",
+		FOOBAR_TYPE_CONFIGURATION,
+		G_PARAM_READABLE );
+	g_object_class_install_properties( object_klass, N_PROPS, props );
+}
+
+//
+// Instance initialization for the configuration service.
+//
+void foobar_configuration_service_init( FoobarConfigurationService* self )
+{
+	self->path = g_strdup_printf( "%s/foobar.conf", g_get_user_config_dir( ) );
+	self->current = foobar_configuration_new( );
+	g_return_if_fail( self->path != NULL );
+
+	// Ensure that the file at path exists.
+
+	if ( g_file_test( self->path, G_FILE_TEST_EXISTS ) )
+	{
+		foobar_configuration_load_from_file( self->current, self->path );
+	}
+	else
+	{
+		g_info( "Config file does not exist -- falling back to default config and creating a copy of it." );
+		g_autoptr( GKeyFile ) file = g_key_file_new( );
+		foobar_configuration_store( self->current, file );
+		g_key_file_save_to_file( file, self->path, NULL );
+	}
+
+	// Monitor the config file.
+
+	self->monitor = foobar_configuration_service_create_monitor( self->path );
+	if ( self->monitor )
+	{
+		self->changed_handler_id = g_signal_connect(
+			self->monitor,
+			"changed",
+			G_CALLBACK( foobar_configuration_service_handle_changed ),
+			self );
+	}
+
+	// In case the config is symlinked, also watch the actual file for content changes.
+
+	self->actual_path = realpath( self->path, NULL );
+	if ( self->actual_path && g_strcmp0( self->actual_path, self->path ) )
+	{
+		self->actual_monitor = foobar_configuration_service_create_monitor( self->actual_path );
+		if ( self->actual_monitor )
+		{
+			self->actual_changed_handler_id = g_signal_connect(
+				self->actual_monitor,
+				"changed",
+				G_CALLBACK( foobar_configuration_service_handle_actual_changed ),
+				self );
+		}
+	}
+}
+
+//
+// Property getter implementation, mapping a property id to a method.
+//
+void foobar_configuration_service_get_property(
+	GObject*    object,
+	guint       prop_id,
+	GValue*     value,
+	GParamSpec* pspec )
+{
+	FoobarConfigurationService* self = (FoobarConfigurationService*)object;
+
+	switch ( prop_id )
+	{
+		case PROP_CURRENT:
+			g_value_set_boxed( value, foobar_configuration_service_get_current( self ) );
+			break;
+		default:
+			G_OBJECT_WARN_INVALID_PROPERTY_ID( object, prop_id, pspec );
+			break;
+	}
+}
+
+//
+// Instance cleanup for the configuration service.
+//
+void foobar_configuration_service_finalize( GObject* object )
+{
+	FoobarConfigurationService* self = (FoobarConfigurationService*)object;
+
+	g_clear_handle_id( &self->update_source_id, g_source_remove );
+	g_clear_signal_handler( &self->changed_handler_id, self->monitor );
+	g_clear_signal_handler( &self->actual_changed_handler_id, self->actual_monitor );
+	g_clear_object( &self->monitor );
+	g_clear_object( &self->actual_monitor );
+	g_clear_pointer( &self->current, foobar_configuration_free );
+	g_clear_pointer( &self->path, g_free );
+	g_clear_pointer( &self->actual_path, free );
+
+	G_OBJECT_CLASS( foobar_configuration_service_parent_class )->finalize( object );
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------------------------------------------------
+
+//
+// Create a new configuration service instance.
+//
+FoobarConfigurationService* foobar_configuration_service_new( void )
+{
+	return g_object_new( FOOBAR_TYPE_CONFIGURATION_SERVICE, NULL );
+}
+
+//
+// Get the current configuration state.
+//
+FoobarConfiguration const* foobar_configuration_service_get_current( FoobarConfigurationService* self )
+{
+	g_return_val_if_fail( FOOBAR_IS_CONFIGURATION_SERVICE( self ), NULL );
+	return self->current;
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Signal Handlers
+// ---------------------------------------------------------------------------------------------------------------------
+
+//
+// Called when the file at self->path has changed.
+//
+void foobar_configuration_service_handle_changed(
+	GFileMonitor*     monitor,
+	GFile*            file,
+	GFile*            other_file,
+	GFileMonitorEvent event_type,
+	gpointer          userdata )
+{
+	(void)monitor;
+	(void)file;
+	(void)other_file;
+	FoobarConfigurationService* self = (FoobarConfigurationService*)userdata;
+
+	// If this file is a symlink, the actual path might have changed.
+
+	char* actual_path = realpath( self->path, NULL );
+	if ( g_strcmp0( self->actual_path, actual_path ) )
+	{
+		free(self->actual_path);
+		self->actual_path = g_steal_pointer( &actual_path );
+
+		// Recreate the file monitor.
+
+		g_clear_signal_handler( &self->actual_changed_handler_id, self->actual_monitor );
+		g_clear_object( &self->actual_monitor );
+
+		if ( self->actual_path && g_strcmp0( self->actual_path, self->path ) )
+		{
+			self->actual_monitor = foobar_configuration_service_create_monitor( self->actual_path );
+			if ( self->actual_monitor )
+			{
+				self->actual_changed_handler_id = g_signal_connect(
+					self->actual_monitor,
+					"changed",
+					G_CALLBACK( foobar_configuration_service_handle_actual_changed ),
+					self );
+			}
+		}
+	}
+	free(actual_path);
+
+	// Handle actual file changes.
+
+	if ( event_type == G_FILE_MONITOR_EVENT_CREATED || event_type == G_FILE_MONITOR_EVENT_CHANGED )
+	{
+		foobar_configuration_service_update( self );
+	}
+}
+
+//
+// Called when the actual file (the one at self->actual_path) behind the symlink has changed.
+//
+void foobar_configuration_service_handle_actual_changed(
+	GFileMonitor*     monitor,
+	GFile*            file,
+	GFile*            other_file,
+	GFileMonitorEvent event_type,
+	gpointer          userdata )
+{
+	(void)monitor;
+	(void)file;
+	(void)other_file;
+	FoobarConfigurationService* self = (FoobarConfigurationService*)userdata;
+
+	if ( event_type == G_FILE_MONITOR_EVENT_CREATED || event_type == G_FILE_MONITOR_EVENT_CHANGED )
+	{
+		foobar_configuration_service_update( self );
+	}
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Helper Methods
+// ---------------------------------------------------------------------------------------------------------------------
+
+//
+// Schedule a configuration file reload, used to coalesce change events.
+//
+void foobar_configuration_service_update( FoobarConfigurationService* self )
+{
+	if ( !self->update_source_id )
+	{
+		self->update_source_id = g_timeout_add(
+			UPDATE_APPLY_DELAY,
+			foobar_configuration_service_update_cb,
+			self );
+	}
+}
+
+//
+// Reload the configuration file.
+//
+gboolean foobar_configuration_service_update_cb( gpointer userdata )
+{
+	FoobarConfigurationService* self = (FoobarConfigurationService*)userdata;
+
+	FoobarConfiguration* updated = foobar_configuration_new( );
+	foobar_configuration_load_from_file( updated, self->path );
+	if ( !foobar_configuration_equal( self->current, updated ) )
+	{
+		foobar_configuration_free( self->current );
+		self->current = g_steal_pointer( &updated );
+		g_object_notify_by_pspec( G_OBJECT( self ), props[PROP_CURRENT] );
+		g_info( "Config reloaded." );
+	}
+	g_clear_pointer( &updated, foobar_configuration_free );
+
+	self->update_source_id = 0;
+	return G_SOURCE_REMOVE;
+}
+
+//
+// Create a new file monitor, logging a warning on error.
+//
+GFileMonitor* foobar_configuration_service_create_monitor( gchar const* path )
+{
+	g_autoptr( GError ) error = NULL;
+	g_autoptr( GFile ) file = g_file_new_for_path( path );
+	GFileMonitor* monitor = g_file_monitor( file, G_FILE_MONITOR_NONE, NULL, &error );
+	if ( !monitor )
+	{
+		g_warning( "Unable to monitor config file: %s", error->message );
+	}
+
+	return monitor;
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Parsing Helpers
+// ---------------------------------------------------------------------------------------------------------------------
+
+//
+// Get and validate a string value from a keyfile. *out should always be freed, even if FALSE is returned.
+//
+gboolean try_get_string_value(
+	GKeyFile*       file,
+	gchar const*    group,
+	gchar const*    key,
+	ValidationFlags validation,
+	gchar**         out )
+{
+	if ( !g_key_file_has_key( file, group, key, NULL ) ) { return FALSE; }
+
+	g_autoptr( GError ) error = NULL;
+	*out = g_key_file_get_string( file, group, key, &error );
+	if ( !*out )
+	{
+		CONFIGURATION_WARNING( "%s:%s: %s", group, key, error->message );
+		return FALSE;
+	}
+
+	if ( validation & VALIDATE_FILE_URL )
+	{
+		g_autoptr( GFile ) test_file = g_file_new_for_uri( *out );
+		if ( !g_file_query_exists( test_file, NULL ) )
+		{
+			CONFIGURATION_WARNING( "%s:%s: A file with the URL \"%s\" does not exist.", group, key, *out );
+			return FALSE;
+		}
+	}
+
+	return TRUE;
+}
+
+//
+// Get and validate a list of string values from a keyfile. *out should always be freed, even if FALSE is returned.
+//
+gboolean try_get_string_list_value(
+	GKeyFile*       file,
+	gchar const*    group,
+	gchar const*    key,
+	ValidationFlags validation,
+	GStrv*          out,
+	gsize*          out_count )
+{
+	if ( !g_key_file_has_key( file, group, key, NULL ) ) { return FALSE; }
+
+	g_autoptr( GError ) error = NULL;
+	*out = g_key_file_get_string_list( file, group, key, out_count, &error );
+	if ( !*out )
+	{
+		CONFIGURATION_WARNING( "%s:%s: %s", group, key, error->message );
+		return FALSE;
+	}
+
+	if ( validation & VALIDATE_DISTINCT )
+	{
+		g_autoptr( GHashTable ) items = g_hash_table_new( g_str_hash, g_str_equal );
+		for ( gchar** it = *out; *it; ++it )
+		{
+			if ( !g_hash_table_add( items, *it ) )
+			{
+				CONFIGURATION_WARNING( "%s:%s: Duplicate value \"%s\" not allowed.", group, key, *it );
+				return FALSE;
+			}
+		}
+	}
+
+	return TRUE;
+}
+
+//
+// Get and validate an integer value from a keyfile.
+//
+gboolean try_get_int_value(
+	GKeyFile*       file,
+	gchar const*    group,
+	gchar const*    key,
+	ValidationFlags validation,
+	gint*           out )
+{
+	if ( !g_key_file_has_key( file, group, key, NULL ) ) { return FALSE; }
+
+	g_autoptr( GError ) error = NULL;
+	*out = g_key_file_get_integer( file, group, key, &error );
+	if ( error )
+	{
+		CONFIGURATION_WARNING( "%s:%s: %s", group, key, error->message );
+		return FALSE;
+	}
+
+	if ( validation & VALIDATE_NON_NEGATIVE )
+	{
+		if ( *out < 0 )
+		{
+			CONFIGURATION_WARNING( "%s:%s: Value is not allowed to be negative.", group, key );
+			return FALSE;
+		}
+	}
+
+	if ( validation & VALIDATE_NON_ZERO )
+	{
+		if ( *out == 0 )
+		{
+			CONFIGURATION_WARNING( "%s:%s: Value is not allowed to be 0.", group, key );
+			return FALSE;
+		}
+	}
+
+	return TRUE;
+}
+
+//
+// Get and validate an enum value (encoded as a string) from a keyfile.
+//
+gboolean try_get_enum_value(
+	GKeyFile*       file,
+	gchar const*    group,
+	gchar const*    key,
+	GType           enum_type,
+	ValidationFlags validation,
+	gint*           out )
+{
+	(void)validation;
+
+	g_autofree gchar* str = NULL;
+	if ( !try_get_string_value( file, group, key, VALIDATE_NONE, &str ) ) { return FALSE; }
+
+	g_autoptr( GEnumClass ) enum_klass = g_type_class_ref( enum_type );
+	GEnumValue* val = g_enum_get_value_by_nick( enum_klass, str );
+	if ( !val )
+	{
+		g_autofree gchar* help_text = enum_format_help_text( enum_type );
+		CONFIGURATION_WARNING( "%s:%s: Invalid enum value \"%s\" (allowed values: %s).", group, key, str, help_text );
+		return FALSE;
+	}
+
+	*out = val->value;
+	return TRUE;
+}
+
+//
+// Get and validate a list of enum values (encoded as strings) from a keyfile. *out should always be freed, even if
+// FALSE is returned.
+//
+gboolean try_get_enum_list_value(
+	GKeyFile*       file,
+	gchar const*    group,
+	gchar const*    key,
+	GType           enum_type,
+	ValidationFlags validation,
+	gpointer*       out,
+	gsize*          out_count )
+{
+	g_auto( GStrv ) str_values = NULL;
+	if ( !try_get_string_list_value( file, group, key, validation, &str_values, out_count ) ) { return FALSE; }
+
+	gint* untyped_out = g_new0( gint, *out_count );
+	*out = untyped_out;
+
+	g_autoptr( GEnumClass ) enum_klass = g_type_class_ref( enum_type );
+	for ( gsize i = 0; i < *out_count; ++i )
+	{
+		GEnumValue* val = g_enum_get_value_by_nick( enum_klass, str_values[i] );
+		if ( !val )
+		{
+			g_autofree gchar* help_text = enum_format_help_text( enum_type );
+			CONFIGURATION_WARNING( "%s:%s: Invalid enum value \"%s\" (allowed values: %s).", group, key, str_values[i], help_text );
+			return FALSE;
+		}
+
+		untyped_out[i] = val->value;
+	}
+
+	return TRUE;
+}
+
+//
+// Get and validate a boolean value from a keyfile.
+//
+gboolean try_get_boolean_value(
+	GKeyFile*       file,
+	gchar const*    group,
+	gchar const*    key,
+	ValidationFlags validation,
+	gboolean*       out )
+{
+	(void)validation;
+
+	if ( !g_key_file_has_key( file, group, key, NULL ) ) { return FALSE; }
+
+	g_autoptr( GError ) error = NULL;
+	*out = g_key_file_get_boolean( file, group, key, &error );
+	if ( error )
+	{
+		CONFIGURATION_WARNING( "%s:%s: %s", group, key, error->message );
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+// Serialization
+// ---------------------------------------------------------------------------------------------------------------------
+
+//
+// Get the string constant for an enum value.
+//
+gchar const* enum_value_to_string(
+	GType enum_type,
+	gint  value )
+{
+	g_autoptr( GEnumClass ) enum_klass = g_type_class_ref( enum_type );
+	GEnumValue* val = g_enum_get_value( enum_klass, value );
+	return val->value_nick;
+}
+
+//
+// Get a list of string constants for a list of enum values. Only the list itself needs to be freed.
+//
+gchar const** enum_list_to_string(
+	GType         enum_type,
+	gconstpointer values,
+	gsize         values_count )
+{
+	gint const* untyped_values = values;
+	gchar const** result = g_new0( gchar const*, values_count );
+
+	g_autoptr( GEnumClass ) enum_klass = g_type_class_ref( enum_type );
+	for ( gsize i = 0; i < values_count; ++i )
+	{
+		GEnumValue* val = g_enum_get_value( enum_klass, untyped_values[i] );
+		result[i] = val->value_nick;
+	}
+
+	return result;
+}
+
+//
+// Return a comma-separated list of all allowed values for an enum type. The result needs to be freed.
+//
+gchar* enum_format_help_text( GType enum_type )
+{
+	GString* result = g_string_new( NULL );
+	g_autoptr( GEnumClass ) enum_klass = g_type_class_ref( enum_type );
+
+	gboolean is_first = TRUE;
+	for ( guint i = 0; i < enum_klass->n_values; ++i )
+	{
+		g_string_append_printf( result, is_first ? "\"%s\"" : ", \"%s\"", enum_klass->values[i].value_nick );
+		is_first = FALSE;
+	}
+
+	return g_string_free_and_steal( result );
+}