Merge pull request #535 from jonls/cleanup

Cleanup redshift.c + modules + options

1 files changed, 174 insertions, 892 deletions

diff --git a/src/redshift.c b/src/redshift.c
index f46853b..1b9a670 100644
--- a/src/redshift.c
+++ b/src/redshift.c
@@ -64,6 +64,7 @@ int poll(struct pollfd *fds, int nfds, int timeout) { abort(); return -1; }
 #include "systemtime.h"
 #include "hooks.h"
 #include "signals.h"
+#include "options.h"
 
 /* pause() is not defined on windows platform but is not needed either.
    Use a noop macro instead. */
@@ -107,158 +108,6 @@ int poll(struct pollfd *fds, int nfds, int timeout) { abort(); return -1; }
 #undef CLAMP
 #define CLAMP(lo,mid,up)  (((lo) > (mid)) ? (lo) : (((mid) < (up)) ? (mid) : (up)))
 
-/* Union of state data for gamma adjustment methods */
-typedef union {
-#ifdef ENABLE_DRM
-	drm_state_t drm;
-#endif
-#ifdef ENABLE_RANDR
-	randr_state_t randr;
-#endif
-#ifdef ENABLE_VIDMODE
-	vidmode_state_t vidmode;
-#endif
-#ifdef ENABLE_QUARTZ
-	quartz_state_t quartz;
-#endif
-#ifdef ENABLE_WINGDI
-	w32gdi_state_t w32gdi;
-#endif
-} gamma_state_t;
-
-
-/* Gamma adjustment method structs */
-static const gamma_method_t gamma_methods[] = {
-#ifdef ENABLE_DRM
-	{
-		"drm", 0,
-		(gamma_method_init_func *)drm_init,
-		(gamma_method_start_func *)drm_start,
-		(gamma_method_free_func *)drm_free,
-		(gamma_method_print_help_func *)drm_print_help,
-		(gamma_method_set_option_func *)drm_set_option,
-		(gamma_method_restore_func *)drm_restore,
-		(gamma_method_set_temperature_func *)drm_set_temperature
-	},
-#endif
-#ifdef ENABLE_RANDR
-	{
-		"randr", 1,
-		(gamma_method_init_func *)randr_init,
-		(gamma_method_start_func *)randr_start,
-		(gamma_method_free_func *)randr_free,
-		(gamma_method_print_help_func *)randr_print_help,
-		(gamma_method_set_option_func *)randr_set_option,
-		(gamma_method_restore_func *)randr_restore,
-		(gamma_method_set_temperature_func *)randr_set_temperature
-	},
-#endif
-#ifdef ENABLE_VIDMODE
-	{
-		"vidmode", 1,
-		(gamma_method_init_func *)vidmode_init,
-		(gamma_method_start_func *)vidmode_start,
-		(gamma_method_free_func *)vidmode_free,
-		(gamma_method_print_help_func *)vidmode_print_help,
-		(gamma_method_set_option_func *)vidmode_set_option,
-		(gamma_method_restore_func *)vidmode_restore,
-		(gamma_method_set_temperature_func *)vidmode_set_temperature
-	},
-#endif
-#ifdef ENABLE_QUARTZ
-	{
-		"quartz", 1,
-		(gamma_method_init_func *)quartz_init,
-		(gamma_method_start_func *)quartz_start,
-		(gamma_method_free_func *)quartz_free,
-		(gamma_method_print_help_func *)quartz_print_help,
-		(gamma_method_set_option_func *)quartz_set_option,
-		(gamma_method_restore_func *)quartz_restore,
-		(gamma_method_set_temperature_func *)quartz_set_temperature
-	},
-#endif
-#ifdef ENABLE_WINGDI
-	{
-		"wingdi", 1,
-		(gamma_method_init_func *)w32gdi_init,
-		(gamma_method_start_func *)w32gdi_start,
-		(gamma_method_free_func *)w32gdi_free,
-		(gamma_method_print_help_func *)w32gdi_print_help,
-		(gamma_method_set_option_func *)w32gdi_set_option,
-		(gamma_method_restore_func *)w32gdi_restore,
-		(gamma_method_set_temperature_func *)w32gdi_set_temperature
-	},
-#endif
-	{
-		"dummy", 0,
-		(gamma_method_init_func *)gamma_dummy_init,
-		(gamma_method_start_func *)gamma_dummy_start,
-		(gamma_method_free_func *)gamma_dummy_free,
-		(gamma_method_print_help_func *)gamma_dummy_print_help,
-		(gamma_method_set_option_func *)gamma_dummy_set_option,
-		(gamma_method_restore_func *)gamma_dummy_restore,
-		(gamma_method_set_temperature_func *)gamma_dummy_set_temperature
-	},
-	{ NULL }
-};
-
-
-/* Union of state data for location providers */
-typedef union {
-	location_manual_state_t manual;
-#ifdef ENABLE_GEOCLUE2
-	location_geoclue2_state_t geoclue2;
-#endif
-#ifdef ENABLE_CORELOCATION
-	location_corelocation_state_t corelocation;
-#endif
-} location_state_t;
-
-
-/* Location provider method structs */
-static const location_provider_t location_providers[] = {
-#ifdef ENABLE_GEOCLUE2
-	{
-		"geoclue2",
-		(location_provider_init_func *)location_geoclue2_init,
-		(location_provider_start_func *)location_geoclue2_start,
-		(location_provider_free_func *)location_geoclue2_free,
-		(location_provider_print_help_func *)
-		location_geoclue2_print_help,
-		(location_provider_set_option_func *)
-		location_geoclue2_set_option,
-		(location_provider_get_fd_func *)location_geoclue2_get_fd,
-		(location_provider_handle_func *)location_geoclue2_handle
-	},
-#endif
-#ifdef ENABLE_CORELOCATION
-	{
-		"corelocation",
-		(location_provider_init_func *)location_corelocation_init,
-		(location_provider_start_func *)location_corelocation_start,
-		(location_provider_free_func *)location_corelocation_free,
-		(location_provider_print_help_func *)
-		location_corelocation_print_help,
-		(location_provider_set_option_func *)
-		location_corelocation_set_option,
-		(location_provider_get_fd_func *)location_corelocation_get_fd,
-		(location_provider_handle_func *)location_corelocation_handle
-	},
-#endif
-	{
-		"manual",
-		(location_provider_init_func *)location_manual_init,
-		(location_provider_start_func *)location_manual_start,
-		(location_provider_free_func *)location_manual_free,
-		(location_provider_print_help_func *)
-		location_manual_print_help,
-		(location_provider_set_option_func *)
-		location_manual_set_option,
-		(location_provider_get_fd_func *)location_manual_get_fd,
-		(location_provider_handle_func *)location_manual_handle
-	},
-	{ NULL }
-};
 
 /* Bounds for parameters. */
 #define MIN_LAT   -90.0
@@ -272,22 +121,6 @@ static const location_provider_t location_providers[] = {
 #define MIN_GAMMA   0.1
 #define MAX_GAMMA  10.0
 
-/* Default values for parameters. */
-#define DEFAULT_DAY_TEMP    6500
-#define DEFAULT_NIGHT_TEMP  4500
-#define DEFAULT_BRIGHTNESS   1.0
-#define DEFAULT_GAMMA        1.0
-
-/* The color temperature when no adjustment is applied. */
-#define NEUTRAL_TEMP  6500
-
-/* Angular elevation of the sun at which the color temperature
-   transition period starts and ends (in degress).
-   Transition during twilight, and while the sun is lower than
-   3.0 degrees above the horizon. */
-#define TRANSITION_LOW     SOLAR_CIVIL_TWILIGHT_ELEV
-#define TRANSITION_HIGH    3.0
-
 /* Duration of sleep between screen updates (milliseconds). */
 #define SLEEP_DURATION        5000
 #define SLEEP_DURATION_SHORT  100
@@ -295,34 +128,6 @@ static const location_provider_t location_providers[] = {
 /* Length of fade in numbers of short sleep durations. */
 #define FADE_LENGTH  40
 
-/* Program modes. */
-typedef enum {
-	PROGRAM_MODE_CONTINUAL,
-	PROGRAM_MODE_ONE_SHOT,
-	PROGRAM_MODE_PRINT,
-	PROGRAM_MODE_RESET,
-	PROGRAM_MODE_MANUAL
-} program_mode_t;
-
-/* Time range.
-   Fields are offsets from midnight in seconds. */
-typedef struct {
-	int start;
-	int end;
-} time_range_t;
-
-/* Transition scheme.
-   The solar elevations at which the transition begins/ends,
-   and the association color settings. */
-typedef struct {
-	double high;
-	double low;
-	int use_time; /* When enabled, ignore elevation and use time ranges. */
-	time_range_t dawn;
-	time_range_t dusk;
-	color_setting_t day;
-	color_setting_t night;
-} transition_scheme_t;
 
 /* Names of periods of day */
 static const char *period_names[] = {
@@ -496,110 +301,22 @@ color_setting_diff_is_major(
 		fabsf(first->gamma[2] - second->gamma[2]) > 0.1);
 }
 
-
-static void
-print_help(const char *program_name)
-{
-	/* TRANSLATORS: help output 1
-	   LAT is latitude, LON is longitude,
-	   DAY is temperature at daytime,
-	   NIGHT is temperature at night
-	   no-wrap */
-	printf(_("Usage: %s -l LAT:LON -t DAY:NIGHT [OPTIONS...]\n"),
-		program_name);
-	fputs("\n", stdout);
-
-	/* TRANSLATORS: help output 2
-	   no-wrap */
-	fputs(_("Set color temperature of display"
-		" according to time of day.\n"), stdout);
-	fputs("\n", stdout);
-
-	/* TRANSLATORS: help output 3
-	   no-wrap */
-	fputs(_("  -h\t\tDisplay this help message\n"
-		"  -v\t\tVerbose output\n"
-		"  -V\t\tShow program version\n"), stdout);
-	fputs("\n", stdout);
-
-	/* TRANSLATORS: help output 4
-	   `list' must not be translated
-	   no-wrap */
-	fputs(_("  -b DAY:NIGHT\tScreen brightness to apply (between 0.1 and 1.0)\n"
-		"  -c FILE\tLoad settings from specified configuration file\n"
-		"  -g R:G:B\tAdditional gamma correction to apply\n"
-		"  -l LAT:LON\tYour current location\n"
-		"  -l PROVIDER\tSelect provider for automatic"
-		" location updates\n"
-		"  \t\t(Type `list' to see available providers)\n"
-		"  -m METHOD\tMethod to use to set color temperature\n"
-		"  \t\t(Type `list' to see available methods)\n"
-		"  -o\t\tOne shot mode (do not continuously adjust"
-		" color temperature)\n"
-		"  -O TEMP\tOne shot manual mode (set color temperature)\n"
-		"  -p\t\tPrint mode (only print parameters and exit)\n"
-		"  -x\t\tReset mode (remove adjustment from screen)\n"
-		"  -r\t\tDisable fading between color temperatures\n"
-		"  -t DAY:NIGHT\tColor temperature to set at daytime/night\n"),
-	      stdout);
-	fputs("\n", stdout);
-
-	/* TRANSLATORS: help output 5 */
-	printf(_("The neutral temperature is %uK. Using this value will not change "
-		 "the color\ntemperature of the display. Setting the color temperature "
-		 "to a value higher\nthan this results in more blue light, and setting "
-		 "a lower value will result in\nmore red light.\n"),
-		 NEUTRAL_TEMP);
-
-	fputs("\n", stdout);
-
-	/* TRANSLATORS: help output 6 */
-	printf(_("Default values:\n\n"
-		 "  Daytime temperature: %uK\n"
-		 "  Night temperature: %uK\n"),
-	       DEFAULT_DAY_TEMP, DEFAULT_NIGHT_TEMP);
-
-	fputs("\n", stdout);
-
-	/* TRANSLATORS: help output 7 */
-	printf(_("Please report bugs to <%s>\n"), PACKAGE_BUGREPORT);
-}
-
+/* Reset color setting to default values. */
 static void
-print_method_list()
+color_setting_reset(color_setting_t *color)
 {
-	fputs(_("Available adjustment methods:\n"), stdout);
-	for (int i = 0; gamma_methods[i].name != NULL; i++) {
-		printf("  %s\n", gamma_methods[i].name);
-	}
-
-	fputs("\n", stdout);
-	fputs(_("Specify colon-separated options with"
-		" `-m METHOD:OPTIONS'.\n"), stdout);
-	/* TRANSLATORS: `help' must not be translated. */
-	fputs(_("Try `-m METHOD:help' for help.\n"), stdout);
-}
-
-static void
-print_provider_list()
-{
-	fputs(_("Available location providers:\n"), stdout);
-	for (int i = 0; location_providers[i].name != NULL; i++) {
-		printf("  %s\n", location_providers[i].name);
-	}
-
-	fputs("\n", stdout);
-	fputs(_("Specify colon-separated options with"
-		"`-l PROVIDER:OPTIONS'.\n"), stdout);
-	/* TRANSLATORS: `help' must not be translated. */
-	fputs(_("Try `-l PROVIDER:help' for help.\n"), stdout);
+	color->temperature = NEUTRAL_TEMP;
+	color->gamma[0] = 1.0;
+	color->gamma[1] = 1.0;
+	color->gamma[2] = 1.0;
+	color->brightness = 1.0;
 }
 
 
 static int
 provider_try_start(const location_provider_t *provider,
-		   location_state_t *state,
-		   config_ini_state_t *config, char *args)
+		   location_state_t **state, config_ini_state_t *config,
+		   char *args)
 {
 	int r;
 
@@ -616,10 +333,10 @@ provider_try_start(const location_provider_t *provider,
 	if (section != NULL) {
 		config_ini_setting_t *setting = section->settings;
 		while (setting != NULL) {
-			r = provider->set_option(state, setting->name,
+			r = provider->set_option(*state, setting->name,
 						 setting->value);
 			if (r < 0) {
-				provider->free(state);
+				provider->free(*state);
 				fprintf(stderr, _("Failed to set %s"
 						  " option.\n"),
 					provider->name);
@@ -661,9 +378,9 @@ provider_try_start(const location_provider_t *provider,
 			*(value++) = '\0';
 		}
 
-		r = provider->set_option(state, key, value);
+		r = provider->set_option(*state, key, value);
 		if (r < 0) {
-			provider->free(state);
+			provider->free(*state);
 			fprintf(stderr, _("Failed to set %s option.\n"),
 				provider->name);
 			/* TRANSLATORS: `help' must not be translated. */
@@ -677,9 +394,9 @@ provider_try_start(const location_provider_t *provider,
 	}
 
 	/* Start provider. */
-	r = provider->start(state);
+	r = provider->start(*state);
 	if (r < 0) {
-		provider->free(state);
+		provider->free(*state);
 		fprintf(stderr, _("Failed to start provider %s.\n"),
 			provider->name);
 		return -1;
@@ -690,8 +407,7 @@ provider_try_start(const location_provider_t *provider,
 
 static int
 method_try_start(const gamma_method_t *method,
-		 gamma_state_t *state,
-		 config_ini_state_t *config, char *args)
+		 gamma_state_t **state, config_ini_state_t *config, char *args)
 {
 	int r;
 
@@ -708,10 +424,10 @@ method_try_start(const gamma_method_t *method,
 	if (section != NULL) {
 		config_ini_setting_t *setting = section->settings;
 		while (setting != NULL) {
-			r = method->set_option(state, setting->name,
-						 setting->value);
+			r = method->set_option(
+				*state, setting->name, setting->value);
 			if (r < 0) {
-				method->free(state);
+				method->free(*state);
 				fprintf(stderr, _("Failed to set %s"
 						  " option.\n"),
 					method->name);
@@ -741,9 +457,9 @@ method_try_start(const gamma_method_t *method,
 			*(value++) = '\0';
 		}
 
-		r = method->set_option(state, key, value);
+		r = method->set_option(*state, key, value);
 		if (r < 0) {
-			method->free(state);
+			method->free(*state);
 			fprintf(stderr, _("Failed to set %s option.\n"),
 				method->name);
 			/* TRANSLATORS: `help' must not be translated. */
@@ -756,9 +472,9 @@ method_try_start(const gamma_method_t *method,
 	}
 
 	/* Start method. */
-	r = method->start(state);
+	r = method->start(*state);
 	if (r < 0) {
-		method->free(state);
+		method->free(*state);
 		fprintf(stderr, _("Failed to start adjustment method %s.\n"),
 			method->name);
 		return -1;
@@ -767,98 +483,6 @@ method_try_start(const gamma_method_t *method,
 	return 0;
 }
 
-/* A gamma string contains either one floating point value,
-   or three values separated by colon. */
-static int
-parse_gamma_string(const char *str, float gamma[])
-{
-	char *s = strchr(str, ':');
-	if (s == NULL) {
-		/* Use value for all channels */
-		float g = atof(str);
-		gamma[0] = gamma[1] = gamma[2] = g;
-	} else {
-		/* Parse separate value for each channel */
-		*(s++) = '\0';
-		char *g_s = s;
-		s = strchr(s, ':');
-		if (s == NULL) return -1;
-
-		*(s++) = '\0';
-		gamma[0] = atof(str); /* Red */
-		gamma[1] = atof(g_s); /* Blue */
-		gamma[2] = atof(s); /* Green */
-	}
-
-	return 0;
-}
-
-/* A brightness string contains either one floating point value,
-   or two values separated by a colon. */
-static void
-parse_brightness_string(const char *str, float *bright_day, float *bright_night)
-{
-	char *s = strchr(str, ':');
-	if (s == NULL) {
-		/* Same value for day and night. */
-		*bright_day = *bright_night = atof(str);
-	} else {
-		*(s++) = '\0';
-		*bright_day = atof(str);
-		*bright_night = atof(s);
-	}
-}
-
-/* Parse transition time string e.g. "04:50". Returns negative on failure,
-   otherwise the parsed time is returned as seconds since midnight. */
-static int
-parse_transition_time(const char *str, const char **end)
-{
-	const char *min = NULL;
-	errno = 0;
-	long hours = strtol(str, (char **)&min, 10);
-	if (errno != 0 || min == str || min[0] != ':' ||
-	    hours < 0 || hours >= 24) {
-		return -1;
-	}
-
-	min += 1;
-	errno = 0;
-	long minutes = strtol(min, (char **)end, 10);
-	if (errno != 0 || *end == min || minutes < 0 || minutes >= 60) {
-		return -1;
-	}
-
-	return minutes * 60 + hours * 3600;
-}
-
-/* Parse transition range string e.g. "04:50-6:20". Returns negative on
-   failure, otherwise zero. Parsed start and end times are returned as seconds
-   since midnight. */
-static int
-parse_transition_range(const char *str, time_range_t *range)
-{
-	const char *next = NULL;
-	int start_time = parse_transition_time(str, &next);
-	if (start_time < 0) return -1;
-
-	int end_time;
-	if (next[0] == '\0') {
-		end_time = start_time;
-	} else if (next[0] == '-') {
-		next += 1;
-		const char *end = NULL;
-		end_time = parse_transition_time(next, &end);
-		if (end_time < 0 || end[0] != '\0') return -1;
-	} else {
-		return -1;
-	}
-
-	range->start = start_time;
-	range->end = end_time;
-
-	return 0;
-}
 
 /* Check whether gamma is within allowed levels. */
 static int
@@ -899,36 +523,6 @@ location_is_valid(const location_t *location)
 	return 1;
 }
 
-static const gamma_method_t *
-find_gamma_method(const char *name)
-{
-	const gamma_method_t *method = NULL;
-	for (int i = 0; gamma_methods[i].name != NULL; i++) {
-		const gamma_method_t *m = &gamma_methods[i];
-		if (strcasecmp(name, m->name) == 0) {
-		        method = m;
-			break;
-		}
-	}
-
-	return method;
-}
-
-static const location_provider_t *
-find_location_provider(const char *name)
-{
-	const location_provider_t *provider = NULL;
-	for (int i = 0; location_providers[i].name != NULL; i++) {
-		const location_provider_t *p = &location_providers[i];
-		if (strcasecmp(name, p->name) == 0) {
-			provider = p;
-			break;
-		}
-	}
-
-	return provider;
-}
-
 /* Wait for location to become available from provider.
    Waits until timeout (milliseconds) has elapsed or forever if timeout
    is -1. Writes location to loc. Returns -1 on error,
@@ -1008,7 +602,7 @@ run_continual_mode(const location_provider_t *provider,
 		   location_state_t *location_state,
 		   const transition_scheme_t *scheme,
 		   const gamma_method_t *method,
-		   gamma_state_t *state,
+		   gamma_state_t *method_state,
 		   int use_fade, int verbose)
 {
 	int r;
@@ -1029,10 +623,11 @@ run_continual_mode(const location_provider_t *provider,
 
 	/* Previous target color setting and current actual color setting.
 	   Actual color setting takes into account the current color fade. */
-	color_setting_t prev_target_interp =
-		{ NEUTRAL_TEMP, { 1.0, 1.0, 1.0 }, 1.0 };
-	color_setting_t interp =
-		{ NEUTRAL_TEMP, { 1.0, 1.0, 1.0 }, 1.0 };
+	color_setting_t prev_target_interp;
+	color_setting_reset(&prev_target_interp);
+
+	color_setting_t interp;
+	color_setting_reset(&interp);
 
 	location_t loc = { NAN, NAN };
 	int need_location = !scheme->use_time;
@@ -1128,12 +723,7 @@ run_continual_mode(const location_provider_t *provider,
 			scheme, transition_prog, &target_interp);
 
 		if (disabled) {
-			/* Reset to neutral */
-			target_interp.temperature = NEUTRAL_TEMP;
-			target_interp.brightness = 1.0;
-			target_interp.gamma[0] = 1.0;
-			target_interp.gamma[1] = 1.0;
-			target_interp.gamma[2] = 1.0;
+			color_setting_reset(&target_interp);
 		}
 
 		if (done) {
@@ -1206,7 +796,7 @@ run_continual_mode(const location_provider_t *provider,
 		}
 
 		/* Adjust temperature */
-		r = method->set_temperature(state, &interp);
+		r = method->set_temperature(method_state, &interp);
 		if (r < 0) {
 			fputs(_("Temperature adjustment failed.\n"),
 			      stderr);
@@ -1287,7 +877,7 @@ run_continual_mode(const location_provider_t *provider,
 	}
 
 	/* Restore saved gamma ramps */
-	method->restore(state);
+	method->restore(method_state);
 
 	return 0;
 }
@@ -1308,41 +898,38 @@ main(int argc, char *argv[])
 	textdomain(PACKAGE);
 #endif
 
-	/* Initialize settings to NULL values. */
-	char *config_filepath = NULL;
-
-	/* Settings for day, night and transition period.
-	   Initialized to indicate that the values are not set yet. */
-	transition_scheme_t scheme =
-		{ TRANSITION_HIGH, TRANSITION_LOW };
-
-	scheme.use_time = 0;
-	scheme.dawn.start = -1;
-	scheme.dawn.end = -1;
-	scheme.dusk.start = -1;
-	scheme.dusk.end = -1;
-
-	scheme.day.temperature = -1;
-	scheme.day.gamma[0] = NAN;
-	scheme.day.brightness = NAN;
-
-	scheme.night.temperature = -1;
-	scheme.night.gamma[0] = NAN;
-	scheme.night.brightness = NAN;
-
-	/* Temperature for manual mode */
-	int temp_set = -1;
-
-	const gamma_method_t *method = NULL;
-	char *method_args = NULL;
-
-	const location_provider_t *provider = NULL;
-	char *provider_args = NULL;
+	/* List of gamma methods. */
+	const gamma_method_t gamma_methods[] = {
+#ifdef ENABLE_DRM
+		drm_gamma_method,
+#endif
+#ifdef ENABLE_RANDR
+		randr_gamma_method,
+#endif
+#ifdef ENABLE_VIDMODE
+		vidmode_gamma_method,
+#endif
+#ifdef ENABLE_QUARTZ
+		quartz_gamma_method,
+#endif
+#ifdef ENABLE_WINGDI
+		w32gdi_gamma_method,
+#endif
+		dummy_gamma_method,
+		{ NULL }
+	};
 
-	int use_fade = -1;
-	program_mode_t mode = PROGRAM_MODE_CONTINUAL;
-	int verbose = 0;
-	char *s;
+	/* List of location providers. */
+	const location_provider_t location_providers[] = {
+#ifdef ENABLE_GEOCLUE2
+		geoclue2_location_provider,
+#endif
+#ifdef ENABLE_CORELOCATION
+		corelocation_location_provider,
+#endif
+		manual_location_provider,
+		{ NULL }
+	};
 
 	/* Flush messages consistently even if redirected to a pipe or
 	   file.  Change the flush behaviour to line-buffered, without
@@ -1350,383 +937,63 @@ main(int argc, char *argv[])
 	setvbuf(stdout, NULL, _IOLBF, 0);
 	setvbuf(stderr, NULL, _IOLBF, 0);
 
-	/* Parse command line arguments. */
-	int opt;
-	while ((opt = getopt(argc, argv, "b:c:g:hl:m:oO:prt:vVx")) != -1) {
-		switch (opt) {
-		case 'b':
-			parse_brightness_string(optarg,
-						&scheme.day.brightness,
-						&scheme.night.brightness);
-			break;
-		case 'c':
-			free(config_filepath);
-			config_filepath = strdup(optarg);
-			break;
-		case 'g':
-			r = parse_gamma_string(optarg, scheme.day.gamma);
-			if (r < 0) {
-				fputs(_("Malformed gamma argument.\n"),
-				      stderr);
-				fputs(_("Try `-h' for more"
-					" information.\n"), stderr);
-				exit(EXIT_FAILURE);
-			}
-
-			/* Set night gamma to the same value as day gamma.
-			   To set these to distinct values use the config
-			   file. */
-			memcpy(scheme.night.gamma, scheme.day.gamma,
-			       sizeof(scheme.night.gamma));
-			break;
-		case 'h':
-			print_help(argv[0]);
-			exit(EXIT_SUCCESS);
-			break;
-		case 'l':
-			/* Print list of providers if argument is `list' */
-			if (strcasecmp(optarg, "list") == 0) {
-				print_provider_list();
-				exit(EXIT_SUCCESS);
-			}
-
-			char *provider_name = NULL;
-
-			/* Don't save the result of strtof(); we simply want
-			   to know if optarg can be parsed as a float. */
-			errno = 0;
-			char *end;
-			strtof(optarg, &end);
-			if (errno == 0 && *end == ':') {
-				/* Use instead as arguments to `manual'. */
-				provider_name = "manual";
-				provider_args = optarg;
-			} else {
-				/* Split off provider arguments. */
-				s = strchr(optarg, ':');
-				if (s != NULL) {
-					*(s++) = '\0';
-					provider_args = s;
-				}
-
-				provider_name = optarg;
-			}
-
-			/* Lookup provider from name. */
-			provider = find_location_provider(provider_name);
-			if (provider == NULL) {
-				fprintf(stderr, _("Unknown location provider"
-						  " `%s'.\n"), provider_name);
-				exit(EXIT_FAILURE);
-			}
-
-			/* Print provider help if arg is `help'. */
-			if (provider_args != NULL &&
-			    strcasecmp(provider_args, "help") == 0) {
-				provider->print_help(stdout);
-				exit(EXIT_SUCCESS);
-			}
-			break;
-		case 'm':
-			/* Print list of methods if argument is `list' */
-			if (strcasecmp(optarg, "list") == 0) {
-				print_method_list();
-				exit(EXIT_SUCCESS);
-			}
-
-			/* Split off method arguments. */
-			s = strchr(optarg, ':');
-			if (s != NULL) {
-				*(s++) = '\0';
-				method_args = s;
-			}
-
-			/* Find adjustment method by name. */
-			method = find_gamma_method(optarg);
-			if (method == NULL) {
-				/* TRANSLATORS: This refers to the method
-				   used to adjust colors e.g VidMode */
-				fprintf(stderr, _("Unknown adjustment method"
-						  " `%s'.\n"), optarg);
-				exit(EXIT_FAILURE);
-			}
-
-			/* Print method help if arg is `help'. */
-			if (method_args != NULL &&
-			    strcasecmp(method_args, "help") == 0) {
-				method->print_help(stdout);
-				exit(EXIT_SUCCESS);
-			}
-			break;
-		case 'o':
-			mode = PROGRAM_MODE_ONE_SHOT;
-			break;
-		case 'O':
-			mode = PROGRAM_MODE_MANUAL;
-			temp_set = atoi(optarg);
-			break;
-		case 'p':
-			mode = PROGRAM_MODE_PRINT;
-			break;
-		case 'r':
-			use_fade = 0;
-			break;
-		case 't':
-			s = strchr(optarg, ':');
-			if (s == NULL) {
-				fputs(_("Malformed temperature argument.\n"),
-				      stderr);
-				fputs(_("Try `-h' for more information.\n"),
-				      stderr);
-				exit(EXIT_FAILURE);
-			}
-			*(s++) = '\0';
-			scheme.day.temperature = atoi(optarg);
-			scheme.night.temperature = atoi(s);
-			break;
-		case 'v':
-			verbose = 1;
-			break;
-                case 'V':
-                        printf("%s\n", PACKAGE_STRING);
-                        exit(EXIT_SUCCESS);
-                        break;
-		case 'x':
-			mode = PROGRAM_MODE_RESET;
-			break;
-		case '?':
-			fputs(_("Try `-h' for more information.\n"), stderr);
-			exit(EXIT_FAILURE);
-			break;
-		}
-	}
+	options_t options;
+	options_init(&options);
+	options_parse_args(
+		&options, argc, argv, gamma_methods, location_providers);
 
 	/* Load settings from config file. */
 	config_ini_state_t config_state;
-	r = config_ini_init(&config_state, config_filepath);
+	r = config_ini_init(&config_state, options.config_filepath);
 	if (r < 0) {
 		fputs("Unable to load config file.\n", stderr);
 		exit(EXIT_FAILURE);
 	}
 
-	free(config_filepath);
-
-	/* Read global config settings. */
-	config_ini_section_t *section = config_ini_get_section(&config_state,
-							       "redshift");
-	if (section != NULL) {
-		config_ini_setting_t *setting = section->settings;
-		while (setting != NULL) {
-			if (strcasecmp(setting->name, "temp-day") == 0) {
-				if (scheme.day.temperature < 0) {
-					scheme.day.temperature =
-						atoi(setting->value);
-				}
-			} else if (strcasecmp(setting->name,
-					      "temp-night") == 0) {
-				if (scheme.night.temperature < 0) {
-					scheme.night.temperature =
-						atoi(setting->value);
-				}
-			} else if (strcasecmp(
-					setting->name, "transition") == 0 ||
-				   strcasecmp(setting->name, "fade") == 0) {
-				/* "fade" is preferred, "transition" is
-				   deprecated as the setting key. */
-				if (use_fade < 0) {
-					use_fade = !!atoi(setting->value);
-				}
-			} else if (strcasecmp(setting->name,
-					      "brightness") == 0) {
-				if (isnan(scheme.day.brightness)) {
-					scheme.day.brightness =
-						atof(setting->value);
-				}
-				if (isnan(scheme.night.brightness)) {
-					scheme.night.brightness =
-						atof(setting->value);
-				}
-			} else if (strcasecmp(setting->name,
-					      "brightness-day") == 0) {
-				if (isnan(scheme.day.brightness)) {
-					scheme.day.brightness =
-						atof(setting->value);
-				}
-			} else if (strcasecmp(setting->name,
-					      "brightness-night") == 0) {
-				if (isnan(scheme.night.brightness)) {
-					scheme.night.brightness =
-						atof(setting->value);
-				}
-			} else if (strcasecmp(setting->name,
-					      "elevation-high") == 0) {
-				scheme.high = atof(setting->value);
-			} else if (strcasecmp(setting->name,
-					      "elevation-low") == 0) {
-				scheme.low = atof(setting->value);
-			} else if (strcasecmp(setting->name, "gamma") == 0) {
-				if (isnan(scheme.day.gamma[0])) {
-					r = parse_gamma_string(setting->value,
-							       scheme.day.gamma);
-					if (r < 0) {
-						fputs(_("Malformed gamma"
-							" setting.\n"),
-						      stderr);
-						exit(EXIT_FAILURE);
-					}
-					memcpy(scheme.night.gamma, scheme.day.gamma,
-					       sizeof(scheme.night.gamma));
-				}
-			} else if (strcasecmp(setting->name, "gamma-day") == 0) {
-				if (isnan(scheme.day.gamma[0])) {
-					r = parse_gamma_string(setting->value,
-							       scheme.day.gamma);
-					if (r < 0) {
-						fputs(_("Malformed gamma"
-							" setting.\n"),
-						      stderr);
-						exit(EXIT_FAILURE);
-					}
-				}
-			} else if (strcasecmp(setting->name, "gamma-night") == 0) {
-				if (isnan(scheme.night.gamma[0])) {
-					r = parse_gamma_string(setting->value,
-							       scheme.night.gamma);
-					if (r < 0) {
-						fputs(_("Malformed gamma"
-							" setting.\n"),
-						      stderr);
-						exit(EXIT_FAILURE);
-					}
-				}
-			} else if (strcasecmp(setting->name,
-					      "adjustment-method") == 0) {
-				if (method == NULL) {
-					method = find_gamma_method(
-						setting->value);
-					if (method == NULL) {
-						fprintf(stderr, _("Unknown"
-								  " adjustment"
-								  " method"
-								  " `%s'.\n"),
-							setting->value);
-						exit(EXIT_FAILURE);
-					}
-				}
-			} else if (strcasecmp(setting->name,
-					      "location-provider") == 0) {
-				if (provider == NULL) {
-					provider = find_location_provider(
-						setting->value);
-					if (provider == NULL) {
-						fprintf(stderr, _("Unknown"
-								  " location"
-								  " provider"
-								  " `%s'.\n"),
-							setting->value);
-						exit(EXIT_FAILURE);
-					}
-				}
-			} else if (strcasecmp(setting->name,
-					      "dawn-time") == 0) {
-				if (scheme.dawn.start < 0) {
-					int r = parse_transition_range(
-						setting->value, &scheme.dawn);
-					if (r < 0) {
-						fprintf(stderr, _("Malformed"
-								  " dawn-time"
-								  " setting"
-								  " `%s'.\n"),
-							setting->value);
-						exit(EXIT_FAILURE);
-					}
-				}
-			} else if (strcasecmp(setting->name,
-					      "dusk-time") == 0) {
-				if (scheme.dusk.start < 0) {
-					int r = parse_transition_range(
-						setting->value, &scheme.dusk);
-					if (r < 0) {
-						fprintf(stderr, _("Malformed"
-								  " dusk-time"
-								  " setting"
-								  " `%s'.\n"),
-							setting->value);
-						exit(EXIT_FAILURE);
-					}
-				}
-			} else {
-				fprintf(stderr, _("Unknown configuration"
-						  " setting `%s'.\n"),
-					setting->name);
-			}
-			setting = setting->next;
-		}
-	}
-
-	/* Use default values for settings that were neither defined in
-	   the config file nor on the command line. */
-	if (scheme.day.temperature < 0) {
-		scheme.day.temperature = DEFAULT_DAY_TEMP;
-	}
-	if (scheme.night.temperature < 0) {
-		scheme.night.temperature = DEFAULT_NIGHT_TEMP;
-	}
-
-	if (isnan(scheme.day.brightness)) {
-		scheme.day.brightness = DEFAULT_BRIGHTNESS;
-	}
-	if (isnan(scheme.night.brightness)) {
-		scheme.night.brightness = DEFAULT_BRIGHTNESS;
-	}
+	free(options.config_filepath);
 
-	if (isnan(scheme.day.gamma[0])) {
-		scheme.day.gamma[0] = DEFAULT_GAMMA;
-		scheme.day.gamma[1] = DEFAULT_GAMMA;
-		scheme.day.gamma[2] = DEFAULT_GAMMA;
-	}
-	if (isnan(scheme.night.gamma[0])) {
-		scheme.night.gamma[0] = DEFAULT_GAMMA;
-		scheme.night.gamma[1] = DEFAULT_GAMMA;
-		scheme.night.gamma[2] = DEFAULT_GAMMA;
-	}
+	options_parse_config_file(
+		&options, &config_state, gamma_methods, location_providers);
 
-	if (use_fade < 0) use_fade = 1;
+	options_set_defaults(&options);
 
-	if (scheme.dawn.start >= 0 || scheme.dawn.end >= 0 ||
-	    scheme.dusk.start >= 0 || scheme.dusk.end >= 0) {
-		if (scheme.dawn.start < 0 || scheme.dawn.end < 0 ||
-		    scheme.dusk.start < 0 || scheme.dusk.end < 0) {
+	if (options.scheme.dawn.start >= 0 || options.scheme.dawn.end >= 0 ||
+	    options.scheme.dusk.start >= 0 || options.scheme.dusk.end >= 0) {
+		if (options.scheme.dawn.start < 0 ||
+		    options.scheme.dawn.end < 0 ||
+		    options.scheme.dusk.start < 0 ||
+		    options.scheme.dusk.end < 0) {
 			fputs(_("Partitial time-configuration not"
 				" supported!\n"), stderr);
 			exit(EXIT_FAILURE);
 		}
 
-		if (scheme.dawn.start > scheme.dawn.end ||
-		    scheme.dawn.end > scheme.dusk.start ||
-		    scheme.dusk.start > scheme.dusk.end) {
+		if (options.scheme.dawn.start > options.scheme.dawn.end ||
+		    options.scheme.dawn.end > options.scheme.dusk.start ||
+		    options.scheme.dusk.start > options.scheme.dusk.end) {
 			fputs(_("Invalid dawn/dusk time configuration!\n"),
 			      stderr);
 			exit(EXIT_FAILURE);
 		}
 
-		scheme.use_time = 1;
+		options.scheme.use_time = 1;
 	}
 
 	/* Initialize location provider if needed. If provider is NULL
 	   try all providers until one that works is found. */
-	location_state_t location_state;
+	location_state_t *location_state;
 
 	/* Location is not needed for reset mode and manual mode. */
 	int need_location =
-		mode != PROGRAM_MODE_RESET &&
-		mode != PROGRAM_MODE_MANUAL &&
-		!scheme.use_time;
+		options.mode != PROGRAM_MODE_RESET &&
+		options.mode != PROGRAM_MODE_MANUAL &&
+		!options.scheme.use_time;
 	if (need_location) {
-		if (provider != NULL) {
+		if (options.provider != NULL) {
 			/* Use provider specified on command line. */
-			r = provider_try_start(provider, &location_state,
-					       &config_state, provider_args);
+			r = provider_try_start(
+				options.provider, &location_state,
+				&config_state, options.provider_args);
 			if (r < 0) exit(EXIT_FAILURE);
 		} else {
 			/* Try all providers, use the first that works. */
@@ -1747,13 +1014,13 @@ main(int argc, char *argv[])
 
 				/* Found provider that works. */
 				printf(_("Using provider `%s'.\n"), p->name);
-				provider = p;
+				options.provider = p;
 				break;
 			}
 
 			/* Failure if no providers were successful at this
 			   point. */
-			if (provider == NULL) {
+			if (options.provider == NULL) {
 				fputs(_("No more location providers"
 					" to try.\n"), stderr);
 				exit(EXIT_FAILURE);
@@ -1761,33 +1028,33 @@ main(int argc, char *argv[])
 		}
 
 		/* Solar elevations */
-		if (scheme.high < scheme.low) {
+		if (options.scheme.high < options.scheme.low) {
 			fprintf(stderr,
 				_("High transition elevation cannot be lower than"
 				  " the low transition elevation.\n"));
 			exit(EXIT_FAILURE);
 		}
 
-		if (verbose) {
+		if (options.verbose) {
 			/* TRANSLATORS: Append degree symbols if possible. */
 			printf(_("Solar elevations: day above %.1f, night below %.1f\n"),
-			       scheme.high, scheme.low);
+			       options.scheme.high, options.scheme.low);
 		}
 	}
 
-	if (mode != PROGRAM_MODE_RESET &&
-	    mode != PROGRAM_MODE_MANUAL) {
-		if (verbose) {
+	if (options.mode != PROGRAM_MODE_RESET &&
+	    options.mode != PROGRAM_MODE_MANUAL) {
+		if (options.verbose) {
 			printf(_("Temperatures: %dK at day, %dK at night\n"),
-			       scheme.day.temperature,
-			       scheme.night.temperature);
+			       options.scheme.day.temperature,
+			       options.scheme.night.temperature);
 		}
 
 		/* Color temperature */
-		if (scheme.day.temperature < MIN_TEMP ||
-		    scheme.day.temperature > MAX_TEMP ||
-		    scheme.night.temperature < MIN_TEMP ||
-		    scheme.night.temperature > MAX_TEMP) {
+		if (options.scheme.day.temperature < MIN_TEMP ||
+		    options.scheme.day.temperature > MAX_TEMP ||
+		    options.scheme.night.temperature < MIN_TEMP ||
+		    options.scheme.night.temperature > MAX_TEMP) {
 			fprintf(stderr,
 				_("Temperature must be between %uK and %uK.\n"),
 				MIN_TEMP, MAX_TEMP);
@@ -1795,9 +1062,10 @@ main(int argc, char *argv[])
 		}
 	}
 
-	if (mode == PROGRAM_MODE_MANUAL) {
+	if (options.mode == PROGRAM_MODE_MANUAL) {
 		/* Check color temperature to be set */
-		if (temp_set < MIN_TEMP || temp_set > MAX_TEMP) {
+		if (options.temp_set < MIN_TEMP ||
+		    options.temp_set > MAX_TEMP) {
 			fprintf(stderr,
 				_("Temperature must be between %uK and %uK.\n"),
 				MIN_TEMP, MAX_TEMP);
@@ -1806,51 +1074,57 @@ main(int argc, char *argv[])
 	}
 
 	/* Brightness */
-	if (scheme.day.brightness < MIN_BRIGHTNESS ||
-	    scheme.day.brightness > MAX_BRIGHTNESS ||
-	    scheme.night.brightness < MIN_BRIGHTNESS ||
-	    scheme.night.brightness > MAX_BRIGHTNESS) {
+	if (options.scheme.day.brightness < MIN_BRIGHTNESS ||
+	    options.scheme.day.brightness > MAX_BRIGHTNESS ||
+	    options.scheme.night.brightness < MIN_BRIGHTNESS ||
+	    options.scheme.night.brightness > MAX_BRIGHTNESS) {
 		fprintf(stderr,
 			_("Brightness values must be between %.1f and %.1f.\n"),
 			MIN_BRIGHTNESS, MAX_BRIGHTNESS);
 		exit(EXIT_FAILURE);
 	}
 
-	if (verbose) {
+	if (options.verbose) {
 		printf(_("Brightness: %.2f:%.2f\n"),
-		       scheme.day.brightness, scheme.night.brightness);
+		       options.scheme.day.brightness,
+		       options.scheme.night.brightness);
 	}
 
 	/* Gamma */
-	if (!gamma_is_valid(scheme.day.gamma) ||
-	    !gamma_is_valid(scheme.night.gamma)) {
+	if (!gamma_is_valid(options.scheme.day.gamma) ||
+	    !gamma_is_valid(options.scheme.night.gamma)) {
 		fprintf(stderr,
 			_("Gamma value must be between %.1f and %.1f.\n"),
 			MIN_GAMMA, MAX_GAMMA);
 		exit(EXIT_FAILURE);
 	}
 
-	if (verbose) {
+	if (options.verbose) {
 		/* TRANSLATORS: The string in parenthesis is either
 		   Daytime or Night (translated). */
 		printf(_("Gamma (%s): %.3f, %.3f, %.3f\n"),
-		       _("Daytime"), scheme.day.gamma[0],
-		       scheme.day.gamma[1], scheme.day.gamma[2]);
+		       _("Daytime"), options.scheme.day.gamma[0],
+		       options.scheme.day.gamma[1],
+		       options.scheme.day.gamma[2]);
 		printf(_("Gamma (%s): %.3f, %.3f, %.3f\n"),
-		       _("Night"), scheme.night.gamma[0],
-		       scheme.night.gamma[1], scheme.night.gamma[2]);
+		       _("Night"), options.scheme.night.gamma[0],
+		       options.scheme.night.gamma[1],
+		       options.scheme.night.gamma[2]);
 	}
 
+	transition_scheme_t *scheme = &options.scheme;
+
 	/* Initialize gamma adjustment method. If method is NULL
 	   try all methods until one that works is found. */
-	gamma_state_t state;
+	gamma_state_t *method_state;
 
 	/* Gamma adjustment not needed for print mode */
-	if (mode != PROGRAM_MODE_PRINT) {
-		if (method != NULL) {
+	if (options.mode != PROGRAM_MODE_PRINT) {
+		if (options.method != NULL) {
 			/* Use method specified on command line. */
-			r = method_try_start(method, &state, &config_state,
-					     method_args);
+			r = method_try_start(
+				options.method, &method_state, &config_state,
+				options.method_args);
 			if (r < 0) exit(EXIT_FAILURE);
 		} else {
 			/* Try all methods, use the first that works. */
@@ -1858,7 +1132,8 @@ main(int argc, char *argv[])
 				const gamma_method_t *m = &gamma_methods[i];
 				if (!m->autostart) continue;
 
-				r = method_try_start(m, &state, &config_state, NULL);
+				r = method_try_start(
+					m, &method_state, &config_state, NULL);
 				if (r < 0) {
 					fputs(_("Trying next method...\n"), stderr);
 					continue;
@@ -1866,12 +1141,12 @@ main(int argc, char *argv[])
 
 				/* Found method that works. */
 				printf(_("Using method `%s'.\n"), m->name);
-				method = m;
+				options.method = m;
 				break;
 			}
 
 			/* Failure if no methods were successful at this point. */
-			if (method == NULL) {
+			if (options.method == NULL) {
 				fputs(_("No more methods to try.\n"), stderr);
 				exit(EXIT_FAILURE);
 			}
@@ -1880,7 +1155,7 @@ main(int argc, char *argv[])
 
 	config_ini_free(&config_state);
 
-	switch (mode) {
+	switch (options.mode) {
 	case PROGRAM_MODE_ONE_SHOT:
 	case PROGRAM_MODE_PRINT:
 	{
@@ -1891,7 +1166,7 @@ main(int argc, char *argv[])
 
 			/* Wait for location provider. */
 			int r = provider_get_location(
-				provider, &location_state, -1, &loc);
+				options.provider, location_state, -1, &loc);
 			if (r < 0) {
 				fputs(_("Unable to get location"
 					" from provider.\n"), stderr);
@@ -1909,39 +1184,39 @@ main(int argc, char *argv[])
 		r = systemtime_get_time(&now);
 		if (r < 0) {
 			fputs(_("Unable to read system time.\n"), stderr);
-			method->free(&state);
+			options.method->free(method_state);
 			exit(EXIT_FAILURE);
 		}
 
 		period_t period;
 		double transition_prog;
-		if (scheme.use_time) {
+		if (options.scheme.use_time) {
 			int time_offset = get_seconds_since_midnight(now);
-			period = get_period_from_time(&scheme, time_offset);
+			period = get_period_from_time(scheme, time_offset);
 			transition_prog = get_transition_progress_from_time(
-				&scheme, time_offset);
+				scheme, time_offset);
 		} else {
 			/* Current angular elevation of the sun */
 			double elevation = solar_elevation(
 				now, loc.lat, loc.lon);
-			if (verbose) {
+			if (options.verbose) {
 				/* TRANSLATORS: Append degree symbol if
 				   possible. */
 				printf(_("Solar elevation: %f\n"), elevation);
 			}
 
-			period = get_period_from_elevation(&scheme, elevation);
+			period = get_period_from_elevation(scheme, elevation);
 			transition_prog =
 				get_transition_progress_from_elevation(
-					&scheme, elevation);
+					scheme, elevation);
 		}
 
 		/* Use transition progress to set color temperature */
 		color_setting_t interp;
 		interpolate_transition_scheme(
-			&scheme, transition_prog, &interp);
+			scheme, transition_prog, &interp);
 
-		if (verbose || mode == PROGRAM_MODE_PRINT) {
+		if (options.verbose || options.mode == PROGRAM_MODE_PRINT) {
 			print_period(period, transition_prog);
 			printf(_("Color temperature: %uK\n"),
 			       interp.temperature);
@@ -1949,13 +1224,14 @@ main(int argc, char *argv[])
 			       interp.brightness);
 		}
 
-		if (mode != PROGRAM_MODE_PRINT) {
+		if (options.mode != PROGRAM_MODE_PRINT) {
 			/* Adjust temperature */
-			r = method->set_temperature(&state, &interp);
+			r = options.method->set_temperature(
+				method_state, &interp);
 			if (r < 0) {
 				fputs(_("Temperature adjustment failed.\n"),
 				      stderr);
-				method->free(&state);
+				options.method->free(method_state);
 				exit(EXIT_FAILURE);
 			}
 
@@ -1963,7 +1239,7 @@ main(int argc, char *argv[])
 			   automatically revert when the process exits.
 			   Therefore, we have to loop until CTRL-C is received.
 			   */
-			if (strcmp(method->name, "quartz") == 0) {
+			if (strcmp(options.method->name, "quartz") == 0) {
 				fputs(_("Press ctrl-c to stop...\n"), stderr);
 				pause();
 			}
@@ -1972,22 +1248,25 @@ main(int argc, char *argv[])
 	break;
 	case PROGRAM_MODE_MANUAL:
 	{
-		if (verbose) printf(_("Color temperature: %uK\n"), temp_set);
+		if (options.verbose) {
+			printf(_("Color temperature: %uK\n"),
+			       options.temp_set);
+		}
 
 		/* Adjust temperature */
-		color_setting_t manual = scheme.day;
-		manual.temperature = temp_set;
-		r = method->set_temperature(&state, &manual);
+		color_setting_t manual = scheme->day;
+		manual.temperature = options.temp_set;
+		r = options.method->set_temperature(method_state, &manual);
 		if (r < 0) {
 			fputs(_("Temperature adjustment failed.\n"), stderr);
-			method->free(&state);
+			options.method->free(method_state);
 			exit(EXIT_FAILURE);
 		}
 
 		/* In Quartz (OSX) the gamma adjustments will automatically
 		   revert when the process exits. Therefore, we have to loop
 		   until CTRL-C is received. */
-		if (strcmp(method->name, "quartz") == 0) {
+		if (strcmp(options.method->name, "quartz") == 0) {
 			fputs(_("Press ctrl-c to stop...\n"), stderr);
 			pause();
 		}
@@ -1996,18 +1275,20 @@ main(int argc, char *argv[])
 	case PROGRAM_MODE_RESET:
 	{
 		/* Reset screen */
-		color_setting_t reset = { NEUTRAL_TEMP, { 1.0, 1.0, 1.0 }, 1.0 };
-		r = method->set_temperature(&state, &reset);
+		color_setting_t reset;
+		color_setting_reset(&reset);
+
+		r = options.method->set_temperature(method_state, &reset);
 		if (r < 0) {
 			fputs(_("Temperature adjustment failed.\n"), stderr);
-			method->free(&state);
+			options.method->free(method_state);
 			exit(EXIT_FAILURE);
 		}
 
 		/* In Quartz (OSX) the gamma adjustments will automatically
 		   revert when the process exits. Therefore, we have to loop
 		   until CTRL-C is received. */
-		if (strcmp(method->name, "quartz") == 0) {
+		if (strcmp(options.method->name, "quartz") == 0) {
 			fputs(_("Press ctrl-c to stop...\n"), stderr);
 			pause();
 		}
@@ -2015,22 +1296,23 @@ main(int argc, char *argv[])
 	break;
 	case PROGRAM_MODE_CONTINUAL:
 	{
-		r = run_continual_mode(provider, &location_state, &scheme,
-				       method, &state,
-				       use_fade, verbose);
+		r = run_continual_mode(
+			options.provider, location_state, scheme,
+			options.method, method_state,
+			options.use_fade, options.verbose);
 		if (r < 0) exit(EXIT_FAILURE);
 	}
 	break;
 	}
 
 	/* Clean up gamma adjustment state */
-	if (mode != PROGRAM_MODE_PRINT) {
-		method->free(&state);
+	if (options.mode != PROGRAM_MODE_PRINT) {
+		options.method->free(method_state);
 	}
 
 	/* Clean up location provider state */
 	if (need_location) {
-		provider->free(&location_state);
+		options.provider->free(location_state);
 	}
 
 	return EXIT_SUCCESS;