Merge pull request #535 from jonls/cleanup

Cleanup redshift.c + modules + options

24 files changed, 1336 insertions, 1276 deletions

diff --git a/po/POTFILES.in b/po/POTFILES.in
index e6b9c4d..5ef8dac 100644
--- a/po/POTFILES.in
+++ b/po/POTFILES.in
@@ -5,7 +5,7 @@ data/applications/redshift.desktop.in
 data/applications/redshift-gtk.desktop.in
 
 src/redshift.c
-
+src/options.c
 src/config-ini.c
 
 src/gamma-drm.c
diff --git a/src/Makefile.am b/src/Makefile.am
index 99c8a2e..8aa96ea 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -14,6 +14,7 @@ redshift_SOURCES = \
 	gamma-dummy.c gamma-dummy.h \
 	hooks.c hooks.h \
 	location-manual.c location-manual.h \
+	options.c options.h \
 	pipeutils.c pipeutils.h \
 	redshift.c redshift.h \
 	signals.c signals.h \
diff --git a/src/gamma-drm.c b/src/gamma-drm.c
index c2ac4bd..67f819e 100644
--- a/src/gamma-drm.c
+++ b/src/gamma-drm.c
@@ -15,6 +15,7 @@
    along with Redshift.  If not, see <http://www.gnu.org/licenses/>.
 
    Copyright (c) 2014  Mattias Andrée <maandree@member.fsf.org>
+   Copyright (c) 2017  Jon Lund Steffensen <jonlst@gmail.com>
 */
 
 #include <stdio.h>
@@ -37,24 +38,49 @@
   #define O_CLOEXEC  02000000
 #endif
 
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
 #include "gamma-drm.h"
 #include "colorramp.h"
 
 
-int
-drm_init(drm_state_t *state)
+typedef struct {
+	int crtc_num;
+	int crtc_id;
+	int gamma_size;
+	uint16_t* r_gamma;
+	uint16_t* g_gamma;
+	uint16_t* b_gamma;
+} drm_crtc_state_t;
+
+typedef struct {
+	int card_num;
+	int crtc_num;
+	int fd;
+	drmModeRes* res;
+	drm_crtc_state_t* crtcs;
+} drm_state_t;
+
+
+static int
+drm_init(drm_state_t **state)
 {
 	/* Initialize state. */
-	state->card_num = 0;
-	state->crtc_num = -1;
-	state->fd = -1;
-	state->res = NULL;
-	state->crtcs = NULL;
+	*state = malloc(sizeof(drm_state_t));
+	if (*state == NULL) return -1;
+
+	drm_state_t *s = *state;
+	s->card_num = 0;
+	s->crtc_num = -1;
+	s->fd = -1;
+	s->res = NULL;
+	s->crtcs = NULL;
 
 	return 0;
 }
 
-int
+static int
 drm_start(drm_state_t *state)
 {
 	/* Acquire access to a graphics card. */
@@ -172,7 +198,7 @@ drm_start(drm_state_t *state)
 	return 0;
 }
 
-void
+static void
 drm_restore(drm_state_t *state)
 {
 	drm_crtc_state_t *crtcs = state->crtcs;
@@ -185,7 +211,7 @@ drm_restore(drm_state_t *state)
 	}
 }
 
-void
+static void
 drm_free(drm_state_t *state)
 {
 	if (state->crtcs != NULL) {
@@ -206,9 +232,11 @@ drm_free(drm_state_t *state)
 		close(state->fd);
 		state->fd = -1;
 	}
+
+	free(state);
 }
 
-void
+static void
 drm_print_help(FILE *f)
 {
 	fputs(_("Adjust gamma ramps with Direct Rendering Manager.\n"), f);
@@ -221,7 +249,7 @@ drm_print_help(FILE *f)
 	fputs("\n", f);
 }
 
-int
+static int
 drm_set_option(drm_state_t *state, const char *key, const char *value)
 {
 	if (strcasecmp(key, "card") == 0) {
@@ -240,7 +268,7 @@ drm_set_option(drm_state_t *state, const char *key, const char *value)
 	return 0;
 }
 
-int
+static int
 drm_set_temperature(drm_state_t *state, const color_setting_t *setting)
 {
 	drm_crtc_state_t *crtcs = state->crtcs;
@@ -288,3 +316,15 @@ drm_set_temperature(drm_state_t *state, const color_setting_t *setting)
 
 	return 0;
 }
+
+
+const gamma_method_t drm_gamma_method = {
+	"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
+};
diff --git a/src/gamma-drm.h b/src/gamma-drm.h
index ae97d00..21ba5c2 100644
--- a/src/gamma-drm.h
+++ b/src/gamma-drm.h
@@ -15,47 +15,14 @@
    along with Redshift.  If not, see <http://www.gnu.org/licenses/>.
 
    Copyright (c) 2014  Mattias Andrée <maandree@member.fsf.org>
+   Copyright (c) 2017  Jon Lund Steffensen <jonlst@gmail.com>
 */
 
 #ifndef REDSHIFT_GAMMA_DRM_H
 #define REDSHIFT_GAMMA_DRM_H
 
-#include <stdint.h>
-
-#include <xf86drm.h>
-#include <xf86drmMode.h>
-
 #include "redshift.h"
 
-
-typedef struct {
-	int crtc_num;
-	int crtc_id;
-	int gamma_size;
-	uint16_t* r_gamma;
-	uint16_t* g_gamma;
-	uint16_t* b_gamma;
-} drm_crtc_state_t;
-
-typedef struct {
-	int card_num;
-	int crtc_num;
-	int fd;
-	drmModeRes* res;
-	drm_crtc_state_t* crtcs;
-} drm_state_t;
-
-
-int drm_init(drm_state_t *state);
-int drm_start(drm_state_t *state);
-void drm_free(drm_state_t *state);
-
-void drm_print_help(FILE *f);
-int drm_set_option(drm_state_t *state, const char *key, const char *value);
-
-void drm_restore(drm_state_t *state);
-int drm_set_temperature(drm_state_t *state,
-			const color_setting_t *setting);
-
+extern const gamma_method_t drm_gamma_method;
 
 #endif /* ! REDSHIFT_GAMMA_DRM_H */
diff --git a/src/gamma-dummy.c b/src/gamma-dummy.c
index ba62d93..25e723f 100644
--- a/src/gamma-dummy.c
+++ b/src/gamma-dummy.c
@@ -14,7 +14,7 @@
    You should have received a copy of the GNU General Public License
    along with Redshift.  If not, see <http://www.gnu.org/licenses/>.
 
-   Copyright (c) 2013-2014  Jon Lund Steffensen <jonlst@gmail.com>
+   Copyright (c) 2013-2017  Jon Lund Steffensen <jonlst@gmail.com>
 */
 
 #include <stdio.h>
@@ -30,46 +30,59 @@
 #include "redshift.h"
 
 
-int
-gamma_dummy_init(void *state)
+static int
+gamma_dummy_init(void **state)
 {
+	*state = NULL;
 	return 0;
 }
 
-int
+static int
 gamma_dummy_start(void *state)
 {
 	fputs(_("WARNING: Using dummy gamma method! Display will not be affected by this gamma method.\n"), stderr);
 	return 0;
 }
 
-void
+static void
 gamma_dummy_restore(void *state)
 {
 }
 
-void
+static void
 gamma_dummy_free(void *state)
 {
 }
 
-void
+static void
 gamma_dummy_print_help(FILE *f)
 {
 	fputs(_("Does not affect the display but prints the color temperature to the terminal.\n"), f);
 	fputs("\n", f);
 }
 
-int
+static int
 gamma_dummy_set_option(void *state, const char *key, const char *value)
 {
 	fprintf(stderr, _("Unknown method parameter: `%s'.\n"), key);
 	return -1;
 }
 
-int
+static int
 gamma_dummy_set_temperature(void *state, const color_setting_t *setting)
 {
 	printf(_("Temperature: %i\n"), setting->temperature);
 	return 0;
 }
+
+
+const gamma_method_t dummy_gamma_method = {
+	"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
+};
diff --git a/src/gamma-dummy.h b/src/gamma-dummy.h
index 3e58ec1..c610d94 100644
--- a/src/gamma-dummy.h
+++ b/src/gamma-dummy.h
@@ -14,7 +14,7 @@
    You should have received a copy of the GNU General Public License
    along with Redshift.  If not, see <http://www.gnu.org/licenses/>.
 
-   Copyright (c) 2013-2014  Jon Lund Steffensen <jonlst@gmail.com>
+   Copyright (c) 2013-2017  Jon Lund Steffensen <jonlst@gmail.com>
 */
 
 #ifndef REDSHIFT_GAMMA_DUMMY_H
@@ -22,17 +22,6 @@
 
 #include "redshift.h"
 
-
-int gamma_dummy_init(void *state);
-int gamma_dummy_start(void *state);
-void gamma_dummy_free(void *state);
-
-void gamma_dummy_print_help(FILE *f);
-int gamma_dummy_set_option(void *state, const char *key, const char *value);
-
-void gamma_dummy_restore(void *state);
-int gamma_dummy_set_temperature(void *state,
-				const color_setting_t *setting);
-
+extern const gamma_method_t dummy_gamma_method;
 
 #endif /* ! REDSHIFT_GAMMA_DUMMY_H */
diff --git a/src/gamma-quartz.c b/src/gamma-quartz.c
index 879da21..2b04d8b 100644
--- a/src/gamma-quartz.c
+++ b/src/gamma-quartz.c
@@ -14,7 +14,7 @@
    You should have received a copy of the GNU General Public License
    along with Redshift.  If not, see <http://www.gnu.org/licenses/>.
 
-   Copyright (c) 2014  Jon Lund Steffensen <jonlst@gmail.com>
+   Copyright (c) 2014-2017  Jon Lund Steffensen <jonlst@gmail.com>
 */
 
 #ifdef HAVE_CONFIG_H
@@ -37,19 +37,35 @@
 #include "colorramp.h"
 
 
-int
-quartz_init(quartz_state_t *state)
+typedef struct {
+	CGDirectDisplayID display;
+	uint32_t ramp_size;
+	float *saved_ramps;
+} quartz_display_state_t;
+
+typedef struct {
+	quartz_display_state_t *displays;
+	uint32_t display_count;
+	int preserve;
+} quartz_state_t;
+
+
+static int
+quartz_init(quartz_state_t **state)
 {
-	state->preserve = 1;
-	state->displays = NULL;
+	*state = malloc(sizeof(quartz_state_t));
+	if (*state == NULL) return -1;
+
+	quartz_state_t *s = *state;
+	s->preserve = 1;
+	s->displays = NULL;
 
 	return 0;
 }
 
-int
+static int
 quartz_start(quartz_state_t *state)
 {
-	int r;
 	CGError error;
 	uint32_t display_count;
 
@@ -132,13 +148,13 @@ quartz_start(quartz_state_t *state)
 	return 0;
 }
 
-void
+static void
 quartz_restore(quartz_state_t *state)
 {
 	CGDisplayRestoreColorSyncSettings();
 }
 
-void
+static void
 quartz_free(quartz_state_t *state)
 {
 	if (state->displays != NULL) {
@@ -147,9 +163,10 @@ quartz_free(quartz_state_t *state)
 		}
 	}
 	free(state->displays);
+	free(state);
 }
 
-void
+static void
 quartz_print_help(FILE *f)
 {
 	fputs(_("Adjust gamma ramps on OSX using Quartz.\n"), f);
@@ -163,7 +180,7 @@ quartz_print_help(FILE *f)
 	fputs("\n", f);
 }
 
-int
+static int
 quartz_set_option(quartz_state_t *state, const char *key, const char *value)
 {
 	if (strcasecmp(key, "preserve") == 0) {
@@ -222,7 +239,7 @@ quartz_set_temperature_for_display(quartz_state_t *state, int display_index,
 	free(gamma_ramps);
 }
 
-int
+static int
 quartz_set_temperature(quartz_state_t *state,
 		       const color_setting_t *setting)
 {
@@ -232,3 +249,15 @@ quartz_set_temperature(quartz_state_t *state,
 
 	return 0;
 }
+
+
+const gamma_method_t quartz_gamma_method = {
+	"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
+};
diff --git a/src/gamma-quartz.h b/src/gamma-quartz.h
index cd29d54..9a40137 100644
--- a/src/gamma-quartz.h
+++ b/src/gamma-quartz.h
@@ -14,43 +14,14 @@
    You should have received a copy of the GNU General Public License
    along with Redshift.  If not, see <http://www.gnu.org/licenses/>.
 
-   Copyright (c) 2014  Jon Lund Steffensen <jonlst@gmail.com>
+   Copyright (c) 2014-2017  Jon Lund Steffensen <jonlst@gmail.com>
 */
 
 #ifndef REDSHIFT_GAMMA_QUARTZ_H
 #define REDSHIFT_GAMMA_QUARTZ_H
 
-#include <stdint.h>
-
-#include <ApplicationServices/ApplicationServices.h>
-
 #include "redshift.h"
 
-
-typedef struct {
-	CGDirectDisplayID display;
-	uint32_t ramp_size;
-	float *saved_ramps;
-} quartz_display_state_t;
-
-typedef struct {
-	quartz_display_state_t *displays;
-	uint32_t display_count;
-	int preserve;
-} quartz_state_t;
-
-
-int quartz_init(quartz_state_t *state);
-int quartz_start(quartz_state_t *state);
-void quartz_free(quartz_state_t *state);
-
-void quartz_print_help(FILE *f);
-int quartz_set_option(quartz_state_t *state, const char *key,
-		      const char *value);
-
-void quartz_restore(quartz_state_t *state);
-int quartz_set_temperature(quartz_state_t *state,
-			   const color_setting_t *setting);
-
+extern const gamma_method_t quartz_gamma_method;
 
 #endif /* ! REDSHIFT_GAMMA_QUARTZ_H */
diff --git a/src/gamma-randr.c b/src/gamma-randr.c
index 6e0fd00..e35315b 100644
--- a/src/gamma-randr.c
+++ b/src/gamma-randr.c
@@ -14,7 +14,7 @@
    You should have received a copy of the GNU General Public License
    along with Redshift.  If not, see <http://www.gnu.org/licenses/>.
 
-   Copyright (c) 2010-2014  Jon Lund Steffensen <jonlst@gmail.com>
+   Copyright (c) 2010-2017  Jon Lund Steffensen <jonlst@gmail.com>
 */
 
 #include <stdio.h>
@@ -42,30 +42,53 @@
 #define RANDR_VERSION_MINOR  3
 
 
-int
-randr_init(randr_state_t *state)
+typedef struct {
+	xcb_randr_crtc_t crtc;
+	unsigned int ramp_size;
+	uint16_t *saved_ramps;
+} randr_crtc_state_t;
+
+typedef struct {
+	xcb_connection_t *conn;
+	xcb_screen_t *screen;
+	int preferred_screen;
+	int preserve;
+	int screen_num;
+	int crtc_num_count;
+	int* crtc_num;
+	unsigned int crtc_count;
+	randr_crtc_state_t *crtcs;
+} randr_state_t;
+
+
+static int
+randr_init(randr_state_t **state)
 {
 	/* Initialize state. */
-	state->screen_num = -1;
-	state->crtc_num = NULL;
+	*state = malloc(sizeof(randr_state_t));
+	if (*state == NULL) return -1;
+
+	randr_state_t *s = *state;
+	s->screen_num = -1;
+	s->crtc_num = NULL;
 
-	state->crtc_num_count = 0;
-	state->crtc_count = 0;
-	state->crtcs = NULL;
+	s->crtc_num_count = 0;
+	s->crtc_count = 0;
+	s->crtcs = NULL;
 
-	state->preserve = 1;
+	s->preserve = 1;
 
 	xcb_generic_error_t *error;
 
 	/* Open X server connection */
-	state->conn = xcb_connect(NULL, &state->preferred_screen);
+	s->conn = xcb_connect(NULL, &s->preferred_screen);
 
 	/* Query RandR version */
 	xcb_randr_query_version_cookie_t ver_cookie =
-		xcb_randr_query_version(state->conn, RANDR_VERSION_MAJOR,
+		xcb_randr_query_version(s->conn, RANDR_VERSION_MAJOR,
 					RANDR_VERSION_MINOR);
 	xcb_randr_query_version_reply_t *ver_reply =
-		xcb_randr_query_version_reply(state->conn, ver_cookie, &error);
+		xcb_randr_query_version_reply(s->conn, ver_cookie, &error);
 
 	/* TODO What does it mean when both error and ver_reply is NULL?
 	   Apparently, we have to check both to avoid seg faults. */
@@ -73,7 +96,8 @@ randr_init(randr_state_t *state)
 		int ec = (error != 0) ? error->error_code : -1;
 		fprintf(stderr, _("`%s' returned error %d\n"),
 			"RANDR Query Version", ec);
-		xcb_disconnect(state->conn);
+		xcb_disconnect(s->conn);
+		free(s);
 		return -1;
 	}
 
@@ -82,7 +106,8 @@ randr_init(randr_state_t *state)
 		fprintf(stderr, _("Unsupported RANDR version (%u.%u)\n"),
 			ver_reply->major_version, ver_reply->minor_version);
 		free(ver_reply);
-		xcb_disconnect(state->conn);
+		xcb_disconnect(s->conn);
+		free(s);
 		return -1;
 	}
 
@@ -91,7 +116,7 @@ randr_init(randr_state_t *state)
 	return 0;
 }
 
-int
+static int
 randr_start(randr_state_t *state)
 {
 	xcb_generic_error_t *error;
@@ -228,7 +253,7 @@ randr_start(randr_state_t *state)
 	return 0;
 }
 
-void
+static void
 randr_restore(randr_state_t *state)
 {
 	xcb_generic_error_t *error;
@@ -257,7 +282,7 @@ randr_restore(randr_state_t *state)
 	}
 }
 
-void
+static void
 randr_free(randr_state_t *state)
 {
 	/* Free CRTC state */
@@ -269,9 +294,11 @@ randr_free(randr_state_t *state)
 
 	/* Close connection */
 	xcb_disconnect(state->conn);
+
+	free(state);
 }
 
-void
+static void
 randr_print_help(FILE *f)
 {
 	fputs(_("Adjust gamma ramps with the X RANDR extension.\n"), f);
@@ -287,7 +314,7 @@ randr_print_help(FILE *f)
 	fputs("\n", f);
 }
 
-int
+static int
 randr_set_option(randr_state_t *state, const char *key, const char *value)
 {
 	if (strcasecmp(key, "screen") == 0) {
@@ -416,7 +443,7 @@ randr_set_temperature_for_crtc(randr_state_t *state, int crtc_num,
 	return 0;
 }
 
-int
+static int
 randr_set_temperature(randr_state_t *state,
 		      const color_setting_t *setting)
 {
@@ -440,3 +467,15 @@ randr_set_temperature(randr_state_t *state,
 
 	return 0;
 }
+
+
+const gamma_method_t randr_gamma_method = {
+	"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
+};
diff --git a/src/gamma-randr.h b/src/gamma-randr.h
index 1fe7cb3..0545d2f 100644
--- a/src/gamma-randr.h
+++ b/src/gamma-randr.h
@@ -14,50 +14,14 @@
    You should have received a copy of the GNU General Public License
    along with Redshift.  If not, see <http://www.gnu.org/licenses/>.
 
-   Copyright (c) 2010-2014  Jon Lund Steffensen <jonlst@gmail.com>
+   Copyright (c) 2010-2017  Jon Lund Steffensen <jonlst@gmail.com>
 */
 
 #ifndef REDSHIFT_GAMMA_RANDR_H
 #define REDSHIFT_GAMMA_RANDR_H
 
-#include <stdio.h>
-#include <stdint.h>
-
-#include <xcb/xcb.h>
-#include <xcb/randr.h>
-
 #include "redshift.h"
 
-
-typedef struct {
-	xcb_randr_crtc_t crtc;
-	unsigned int ramp_size;
-	uint16_t *saved_ramps;
-} randr_crtc_state_t;
-
-typedef struct {
-	xcb_connection_t *conn;
-	xcb_screen_t *screen;
-	int preferred_screen;
-	int preserve;
-	int screen_num;
-	int crtc_num_count;
-	int* crtc_num;
-	unsigned int crtc_count;
-	randr_crtc_state_t *crtcs;
-} randr_state_t;
-
-
-int randr_init(randr_state_t *state);
-int randr_start(randr_state_t *state);
-void randr_free(randr_state_t *state);
-
-void randr_print_help(FILE *f);
-int randr_set_option(randr_state_t *state, const char *key, const char *value);
-
-void randr_restore(randr_state_t *state);
-int randr_set_temperature(randr_state_t *state,
-			  const color_setting_t *setting);
-
+extern const gamma_method_t randr_gamma_method;
 
 #endif /* ! REDSHIFT_GAMMA_RANDR_H */
diff --git a/src/gamma-vidmode.c b/src/gamma-vidmode.c
index e664f80..76950c8 100644
--- a/src/gamma-vidmode.c
+++ b/src/gamma-vidmode.c
@@ -14,7 +14,7 @@
    You should have received a copy of the GNU General Public License
    along with Redshift.  If not, see <http://www.gnu.org/licenses/>.
 
-   Copyright (c) 2010-2014  Jon Lund Steffensen <jonlst@gmail.com>
+   Copyright (c) 2010-2017  Jon Lund Steffensen <jonlst@gmail.com>
 */
 
 #include <stdlib.h>
@@ -37,26 +37,38 @@
 #include "colorramp.h"
 
 
-int
-vidmode_init(vidmode_state_t *state)
+typedef struct {
+	Display *display;
+	int preserve;
+	int screen_num;
+	int ramp_size;
+	uint16_t *saved_ramps;
+} vidmode_state_t;
+
+
+static int
+vidmode_init(vidmode_state_t **state)
 {
-	state->screen_num = -1;
-	state->saved_ramps = NULL;
+	*state = malloc(sizeof(vidmode_state_t));
+	if (*state == NULL) return -1;
 
-	state->preserve = 1;
+	vidmode_state_t *s = *state;
+	s->screen_num = -1;
+	s->saved_ramps = NULL;
+
+	s->preserve = 1;
 
 	/* Open display */
-	state->display = XOpenDisplay(NULL);
-	if (state->display == NULL) {
-		fprintf(stderr, _("X request failed: %s\n"),
-			"XOpenDisplay");
+	s->display = XOpenDisplay(NULL);
+	if (s->display == NULL) {
+		fprintf(stderr, _("X request failed: %s\n"), "XOpenDisplay");
 		return -1;
 	}
 
 	return 0;
 }
 
-int
+static int
 vidmode_start(vidmode_state_t *state)
 {
 	int r;
@@ -113,7 +125,7 @@ vidmode_start(vidmode_state_t *state)
 	return 0;
 }
 
-void
+static void
 vidmode_free(vidmode_state_t *state)
 {
 	/* Free saved ramps */
@@ -121,9 +133,11 @@ vidmode_free(vidmode_state_t *state)
 
 	/* Close display connection */
 	XCloseDisplay(state->display);
+
+	free(state);
 }
 
-void
+static void
 vidmode_print_help(FILE *f)
 {
 	fputs(_("Adjust gamma ramps with the X VidMode extension.\n"), f);
@@ -138,7 +152,7 @@ vidmode_print_help(FILE *f)
 	fputs("\n", f);
 }
 
-int
+static int
 vidmode_set_option(vidmode_state_t *state, const char *key, const char *value)
 {
 	if (strcasecmp(key, "screen") == 0) {
@@ -153,7 +167,7 @@ vidmode_set_option(vidmode_state_t *state, const char *key, const char *value)
 	return 0;
 }
 
-void
+static void
 vidmode_restore(vidmode_state_t *state)
 {
 	uint16_t *gamma_r = &state->saved_ramps[0*state->ramp_size];
@@ -170,7 +184,7 @@ vidmode_restore(vidmode_state_t *state)
 	}
 }
 
-int
+static int
 vidmode_set_temperature(vidmode_state_t *state,
 			const color_setting_t *setting)
 {
@@ -220,3 +234,15 @@ vidmode_set_temperature(vidmode_state_t *state,
 
 	return 0;
 }
+
+
+const gamma_method_t vidmode_gamma_method = {
+	"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
+};
diff --git a/src/gamma-vidmode.h b/src/gamma-vidmode.h
index 4b6cecc..6bad207 100644
--- a/src/gamma-vidmode.h
+++ b/src/gamma-vidmode.h
@@ -14,7 +14,7 @@
    You should have received a copy of the GNU General Public License
    along with Redshift.  If not, see <http://www.gnu.org/licenses/>.
 
-   Copyright (c) 2010-2014  Jon Lund Steffensen <jonlst@gmail.com>
+   Copyright (c) 2010-2017  Jon Lund Steffensen <jonlst@gmail.com>
 */
 
 #ifndef REDSHIFT_GAMMA_VIDMODE_H
@@ -22,31 +22,6 @@
 
 #include "redshift.h"
 
-#include <stdio.h>
-#include <stdint.h>
-
-#include <X11/Xlib.h>
-
-typedef struct {
-	Display *display;
-	int preserve;
-	int screen_num;
-	int ramp_size;
-	uint16_t *saved_ramps;
-} vidmode_state_t;
-
-
-int vidmode_init(vidmode_state_t *state);
-int vidmode_start(vidmode_state_t *state);
-void vidmode_free(vidmode_state_t *state);
-
-void vidmode_print_help(FILE *f);
-int vidmode_set_option(vidmode_state_t *state, const char *key,
-		       const char *value);
-
-void vidmode_restore(vidmode_state_t *state);
-int vidmode_set_temperature(vidmode_state_t *state,
-			    const color_setting_t *setting);
-
+extern const gamma_method_t vidmode_gamma_method;
 
 #endif /* ! REDSHIFT_GAMMA_VIDMODE_H */
diff --git a/src/gamma-w32gdi.c b/src/gamma-w32gdi.c
index 3d67331..298528b 100644
--- a/src/gamma-w32gdi.c
+++ b/src/gamma-w32gdi.c
@@ -14,7 +14,7 @@
    You should have received a copy of the GNU General Public License
    along with Redshift.  If not, see <http://www.gnu.org/licenses/>.
 
-   Copyright (c) 2010-2014  Jon Lund Steffensen <jonlst@gmail.com>
+   Copyright (c) 2010-2017  Jon Lund Steffensen <jonlst@gmail.com>
 */
 
 #include <stdio.h>
@@ -40,16 +40,26 @@
 #define MAX_ATTEMPTS  10
 
 
-int
-w32gdi_init(w32gdi_state_t *state)
+typedef struct {
+	WORD *saved_ramps;
+	int preserve;
+} w32gdi_state_t;
+
+
+static int
+w32gdi_init(w32gdi_state_t **state)
 {
-	state->saved_ramps = NULL;
-	state->preserve = 1;
+	*state = malloc(sizeof(w32gdi_state_t));
+	if (state == NULL) return -1;
+
+	w32gdi_state_t *s = *state;
+	s->saved_ramps = NULL;
+	s->preserve = 1;
 
 	return 0;
 }
 
-int
+static int
 w32gdi_start(w32gdi_state_t *state)
 {
 	BOOL r;
@@ -91,15 +101,17 @@ w32gdi_start(w32gdi_state_t *state)
 	return 0;
 }
 
-void
+static void
 w32gdi_free(w32gdi_state_t *state)
 {
 	/* Free saved ramps */
 	free(state->saved_ramps);
+
+	free(state);
 }
 
 
-void
+static void
 w32gdi_print_help(FILE *f)
 {
 	fputs(_("Adjust gamma ramps with the Windows GDI.\n"), f);
@@ -113,7 +125,7 @@ w32gdi_print_help(FILE *f)
 	fputs("\n", f);
 }
 
-int
+static int
 w32gdi_set_option(w32gdi_state_t *state, const char *key, const char *value)
 {
 	if (strcasecmp(key, "preserve") == 0) {
@@ -126,7 +138,7 @@ w32gdi_set_option(w32gdi_state_t *state, const char *key, const char *value)
 	return 0;
 }
 
-void
+static void
 w32gdi_restore(w32gdi_state_t *state)
 {
 	/* Open device context */
@@ -150,7 +162,7 @@ w32gdi_restore(w32gdi_state_t *state)
 	ReleaseDC(NULL, hDC);
 }
 
-int
+static int
 w32gdi_set_temperature(w32gdi_state_t *state,
 		       const color_setting_t *setting)
 {
@@ -215,3 +227,15 @@ w32gdi_set_temperature(w32gdi_state_t *state,
 
 	return 0;
 }
+
+
+const gamma_method_t w32gdi_gamma_method = {
+	"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
+};
diff --git a/src/gamma-w32gdi.h b/src/gamma-w32gdi.h
index 6e73cd1..ac6eb10 100644
--- a/src/gamma-w32gdi.h
+++ b/src/gamma-w32gdi.h
@@ -14,35 +14,14 @@
    You should have received a copy of the GNU General Public License
    along with Redshift.  If not, see <http://www.gnu.org/licenses/>.
 
-   Copyright (c) 2010-2014  Jon Lund Steffensen <jonlst@gmail.com>
+   Copyright (c) 2010-2017  Jon Lund Steffensen <jonlst@gmail.com>
 */
 
 #ifndef REDSHIFT_GAMMA_W32GDI_H
 #define REDSHIFT_GAMMA_W32GDI_H
 
-#include <windows.h>
-#include <wingdi.h>
-
 #include "redshift.h"
 
-
-typedef struct {
-	WORD *saved_ramps;
-	int preserve;
-} w32gdi_state_t;
-
-
-int w32gdi_init(w32gdi_state_t *state);
-int w32gdi_start(w32gdi_state_t *state);
-void w32gdi_free(w32gdi_state_t *state);
-
-void w32gdi_print_help(FILE *f);
-int w32gdi_set_option(w32gdi_state_t *state, const char *key,
-		      const char *value);
-
-void w32gdi_restore(w32gdi_state_t *state);
-int w32gdi_set_temperature(w32gdi_state_t *state,
-			   const color_setting_t *color);
-
+extern const gamma_method_t w32gdi_gamma_method;
 
 #endif /* ! REDSHIFT_GAMMA_W32GDI_H */
diff --git a/src/location-corelocation.h b/src/location-corelocation.h
index ae1feeb..4af302c 100644
--- a/src/location-corelocation.h
+++ b/src/location-corelocation.h
@@ -20,37 +20,8 @@
 #ifndef REDSHIFT_LOCATION_CORELOCATION_H
 #define REDSHIFT_LOCATION_CORELOCATION_H
 
-#include <stdio.h>
-
 #include "redshift.h"
 
-typedef struct location_corelocation_private location_corelocation_private_t;
-
-typedef struct {
-	location_corelocation_private_t *private;
-	int pipe_fd_read;
-	int pipe_fd_write;
-	int available;
-	int error;
-	float latitude;
-	float longitude;
-} location_corelocation_state_t;
-
-
-int location_corelocation_init(location_corelocation_state_t *state);
-int location_corelocation_start(location_corelocation_state_t *state);
-void location_corelocation_free(location_corelocation_state_t *state);
-
-void location_corelocation_print_help(FILE *f);
-int location_corelocation_set_option(
-	location_corelocation_state_t *state,
-	const char *key, const char *value);
-
-int location_corelocation_get_fd(
-	location_corelocation_state_t *state);
-int location_corelocation_handle(
-	location_corelocation_state_t *state,
-	location_t *location, int *available);
-
+extern const location_provider_t corelocation_location_provider;
 
 #endif /* ! REDSHIFT_LOCATION_CORELOCATION_H */
diff --git a/src/location-corelocation.m b/src/location-corelocation.m
index 5150839..1a04d54 100644
--- a/src/location-corelocation.m
+++ b/src/location-corelocation.m
@@ -39,10 +39,16 @@
 #endif
 
 
-struct location_corelocation_private {
+typedef struct {
   NSThread *thread;
   NSLock *lock;
-};
+  int pipe_fd_read;
+  int pipe_fd_write;
+  int available;
+  int error;
+  float latitude;
+  float longitude;
+} location_corelocation_state_t;
 
 
 @interface LocationDelegate : NSObject <CLLocationManagerDelegate>
@@ -74,11 +80,11 @@ struct location_corelocation_private {
 
 - (void)markError
 {
-  [self.state->private->lock lock];
+  [self.state->lock lock];
 
   self.state->error = 1;
 
-  [self.state->private->lock unlock];
+  [self.state->lock unlock];
 
   pipeutils_signal(self.state->pipe_fd_write);
 }
@@ -88,13 +94,13 @@ struct location_corelocation_private {
 {
   CLLocation *newLocation = [locations firstObject];
 
-  [self.state->private->lock lock];
+  [self.state->lock lock];
 
   self.state->latitude = newLocation.coordinate.latitude;
   self.state->longitude = newLocation.coordinate.longitude;
   self.state->available = 1;
 
-  [self.state->private->lock unlock];
+  [self.state->lock unlock];
 
   pipeutils_signal(self.state->pipe_fd_write);
 }
@@ -172,13 +178,15 @@ pipe_close_callback(
 @end
 
 
-int
-location_corelocation_init(location_corelocation_state_t *state)
+static int
+location_corelocation_init(location_corelocation_state_t **state)
 {
+  *state = malloc(sizeof(location_corelocation_state_t));
+  if (*state == NULL) return -1;
   return 0;
 }
 
-int
+static int
 location_corelocation_start(location_corelocation_state_t *state)
 {
   state->pipe_fd_read = -1;
@@ -189,14 +197,10 @@ location_corelocation_start(location_corelocation_state_t *state)
   state->latitude = 0;
   state->longitude = 0;
 
-  state->private = malloc(sizeof(location_corelocation_private_t));
-  if (state->private == NULL) return -1;
-
   int pipefds[2];
   int r = pipeutils_create_nonblocking(pipefds);
   if (r < 0) {
     fputs(_("Failed to start CoreLocation provider!\n"), stderr);
-    free(state->private);
     return -1;
   }
 
@@ -205,34 +209,34 @@ location_corelocation_start(location_corelocation_state_t *state)
 
   pipeutils_signal(state->pipe_fd_write);
 
-  state->private->lock = [[NSLock alloc] init];
+  state->lock = [[NSLock alloc] init];
 
   LocationThread *thread = [[LocationThread alloc] init];
   thread.state = state;
   [thread start];
-  state->private->thread = thread;
+  state->thread = thread;
 
   return 0;
 }
 
-void
+static void
 location_corelocation_free(location_corelocation_state_t *state)
 {
   if (state->pipe_fd_read != -1) {
     close(state->pipe_fd_read);
   }
 
-  free(state->private);
+  free(state);
 }
 
-void
+static void
 location_corelocation_print_help(FILE *f)
 {
   fputs(_("Use the location as discovered by the Corelocation provider.\n"), f);
   fputs("\n", f);
 }
 
-int
+static int
 location_corelocation_set_option(
     location_corelocation_state_t *state, const char *key, const char *value)
 {
@@ -240,28 +244,41 @@ location_corelocation_set_option(
   return -1;
 }
 
-int
+static int
 location_corelocation_get_fd(location_corelocation_state_t *state)
 {
   return state->pipe_fd_read;
 }
 
-int location_corelocation_handle(
+static int
+location_corelocation_handle(
     location_corelocation_state_t *state,
     location_t *location, int *available)
 {
   pipeutils_handle_signal(state->pipe_fd_read);
 
-  [state->private->lock lock];
+  [state->lock lock];
 
   int error = state->error;
   location->lat = state->latitude;
   location->lon = state->longitude;
   *available = state->available;
 
-  [state->private->lock unlock];
+  [state->lock unlock];
 
   if (error) return -1;
 
   return 0;
 }
+
+
+const location_provider_t corelocation_location_provider = {
+  "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
+};
diff --git a/src/location-geoclue2.c b/src/location-geoclue2.c
index 6ebedb4..696867e 100644
--- a/src/location-geoclue2.c
+++ b/src/location-geoclue2.c
@@ -38,6 +38,19 @@
 #define DBUS_ACCESS_ERROR  "org.freedesktop.DBus.Error.AccessDenied"
 
 
+typedef struct {
+	GMainLoop *loop;
+	GThread *thread;
+	GMutex lock;
+	int pipe_fd_read;
+	int pipe_fd_write;
+	int available;
+	int error;
+	float latitude;
+	float longitude;
+} location_geoclue2_state_t;
+
+
 /* Print the message explaining denial from GeoClue. */
 static void
 print_denial_message()
@@ -285,7 +298,7 @@ on_pipe_closed(GIOChannel *channel, GIOCondition condition, gpointer user_data)
 
 
 /* Run loop for location provider thread. */
-void *
+static void *
 run_geoclue2_loop(void *state_)
 {
 	location_geoclue2_state_t *state = state_;
@@ -324,16 +337,18 @@ run_geoclue2_loop(void *state_)
 	return NULL;
 }
 
-int
-location_geoclue2_init(location_geoclue2_state_t *state)
+static int
+location_geoclue2_init(location_geoclue2_state_t **state)
 {
 #if !GLIB_CHECK_VERSION(2, 35, 0)
 	g_type_init();
 #endif
+	*state = malloc(sizeof(location_geoclue2_state_t));
+	if (*state == NULL) return -1;
 	return 0;
 }
 
-int
+static int
 location_geoclue2_start(location_geoclue2_state_t *state)
 {
 	state->pipe_fd_read = -1;
@@ -362,7 +377,7 @@ location_geoclue2_start(location_geoclue2_state_t *state)
 	return 0;
 }
 
-void
+static void
 location_geoclue2_free(location_geoclue2_state_t *state)
 {
 	if (state->pipe_fd_read != -1) {
@@ -374,9 +389,11 @@ location_geoclue2_free(location_geoclue2_state_t *state)
 	state->thread = NULL;
 
 	g_mutex_clear(&state->lock);
+
+	free(state);
 }
 
-void
+static void
 location_geoclue2_print_help(FILE *f)
 {
 	fputs(_("Use the location as discovered by a GeoClue2 provider.\n"),
@@ -384,7 +401,7 @@ location_geoclue2_print_help(FILE *f)
 	fputs("\n", f);
 }
 
-int
+static int
 location_geoclue2_set_option(location_geoclue2_state_t *state,
 			     const char *key, const char *value)
 {
@@ -392,13 +409,13 @@ location_geoclue2_set_option(location_geoclue2_state_t *state,
 	return -1;
 }
 
-int
+static int
 location_geoclue2_get_fd(location_geoclue2_state_t *state)
 {
 	return state->pipe_fd_read;
 }
 
-int
+static int
 location_geoclue2_handle(
 	location_geoclue2_state_t *state,
 	location_t *location, int *available)
@@ -418,3 +435,15 @@ location_geoclue2_handle(
 
 	return 0;
 }
+
+
+const location_provider_t geoclue2_location_provider = {
+	"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
+};
diff --git a/src/location-geoclue2.h b/src/location-geoclue2.h
index 2f04eea..a7189a7 100644
--- a/src/location-geoclue2.h
+++ b/src/location-geoclue2.h
@@ -20,36 +20,8 @@
 #ifndef REDSHIFT_LOCATION_GEOCLUE2_H
 #define REDSHIFT_LOCATION_GEOCLUE2_H
 
-#include <stdio.h>
-
-#include <glib.h>
-
 #include "redshift.h"
 
-typedef struct {
-	GMainLoop *loop;
-	GThread *thread;
-	GMutex lock;
-	int pipe_fd_read;
-	int pipe_fd_write;
-	int available;
-	int error;
-	float latitude;
-	float longitude;
-} location_geoclue2_state_t;
-
-
-int location_geoclue2_init(location_geoclue2_state_t *state);
-int location_geoclue2_start(location_geoclue2_state_t *state);
-void location_geoclue2_free(location_geoclue2_state_t *state);
-
-void location_geoclue2_print_help(FILE *f);
-int location_geoclue2_set_option(location_geoclue2_state_t *state,
-				 const char *key, const char *value);
-
-int location_geoclue2_get_fd(location_geoclue2_state_t *state);
-int location_geoclue2_handle(location_geoclue2_state_t *state,
-			     location_t *location, int *available);
-
+extern const location_provider_t geoclue2_location_provider;
 
 #endif /* ! REDSHIFT_LOCATION_GEOCLUE2_H */
diff --git a/src/location-manual.c b/src/location-manual.c
index 8ce324c..137500c 100644
--- a/src/location-manual.c
+++ b/src/location-manual.c
@@ -33,16 +33,25 @@
 #endif
 
 
-int
-location_manual_init(location_manual_state_t *state)
+typedef struct {
+	location_t loc;
+} location_manual_state_t;
+
+
+static int
+location_manual_init(location_manual_state_t **state)
 {
-	state->loc.lat = NAN;
-	state->loc.lon = NAN;
+	*state = malloc(sizeof(location_manual_state_t));
+	if (*state == NULL) return -1;
+
+	location_manual_state_t *s = *state;
+	s->loc.lat = NAN;
+	s->loc.lon = NAN;
 
 	return 0;
 }
 
-int
+static int
 location_manual_start(location_manual_state_t *state)
 {
 	/* Latitude and longitude must be set */
@@ -54,12 +63,13 @@ location_manual_start(location_manual_state_t *state)
 	return 0;
 }
 
-void
+static void
 location_manual_free(location_manual_state_t *state)
 {
+	free(state);
 }
 
-void
+static void
 location_manual_print_help(FILE *f)
 {
 	fputs(_("Specify location manually.\n"), f);
@@ -75,7 +85,7 @@ location_manual_print_help(FILE *f)
 	fputs("\n", f);
 }
 
-int
+static int
 location_manual_set_option(location_manual_state_t *state, const char *key,
 			   const char *value)
 {
@@ -100,13 +110,13 @@ location_manual_set_option(location_manual_state_t *state, const char *key,
 	return 0;
 }
 
-int
+static int
 location_manual_get_fd(location_manual_state_t *state)
 {
 	return -1;
 }
 
-int
+static int
 location_manual_handle(
 	location_manual_state_t *state, location_t *location, int *available)
 {
@@ -115,3 +125,15 @@ location_manual_handle(
 
 	return 0;
 }
+
+
+const location_provider_t manual_location_provider = {
+	"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
+};
diff --git a/src/location-manual.h b/src/location-manual.h
index 7094e9a..c7ef2ad 100644
--- a/src/location-manual.h
+++ b/src/location-manual.h
@@ -20,27 +20,8 @@
 #ifndef REDSHIFT_LOCATION_MANUAL_H
 #define REDSHIFT_LOCATION_MANUAL_H
 
-#include <stdio.h>
-
 #include "redshift.h"
 
-
-typedef struct {
-	location_t loc;
-} location_manual_state_t;
-
-
-int location_manual_init(location_manual_state_t *state);
-int location_manual_start(location_manual_state_t *state);
-void location_manual_free(location_manual_state_t *state);
-
-void location_manual_print_help(FILE *f);
-int location_manual_set_option(location_manual_state_t *state,
-			       const char *key, const char *value);
-
-int location_manual_get_fd(location_manual_state_t *state);
-int location_manual_handle(
-	location_manual_state_t *state, location_t *location, int *available);
-
+extern const location_provider_t manual_location_provider;
 
 #endif /* ! REDSHIFT_LOCATION_MANUAL_H */
diff --git a/src/options.c b/src/options.c
new file mode 100644
index 0000000..8a0a0d2
--- /dev/null
+++ b/src/options.c
@@ -0,0 +1,672 @@
+/* options.c -- Program options
+   This file is part of Redshift.
+
+   Redshift is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   Redshift is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with Redshift.  If not, see <http://www.gnu.org/licenses/>.
+
+   Copyright (c) 2017  Jon Lund Steffensen <jonlst@gmail.com>
+*/
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <errno.h>
+#include <math.h>
+
+#ifdef ENABLE_NLS
+# include <libintl.h>
+# define _(s) gettext(s)
+#else
+# define _(s) s
+#endif
+
+#include "redshift.h"
+#include "config-ini.h"
+#include "options.h"
+#include "solar.h"
+
+/* 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
+
+/* Default values for parameters. */
+#define DEFAULT_DAY_TEMP    6500
+#define DEFAULT_NIGHT_TEMP  4500
+#define DEFAULT_BRIGHTNESS   1.0
+#define DEFAULT_GAMMA        1.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);
+	}
+}
+
+/* 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;
+}
+
+/* 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;
+}
+
+/* Print help text. */
+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);
+}
+
+/* Print list of adjustment methods. */
+static void
+print_method_list(const gamma_method_t *gamma_methods)
+{
+	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);
+}
+
+/* Print list of location providers. */
+static void
+print_provider_list(const location_provider_t location_providers[])
+{
+	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);
+}
+
+/* Return the gamma method with the given name. */
+static const gamma_method_t *
+find_gamma_method(const gamma_method_t gamma_methods[], 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;
+}
+
+/* Return location provider with the given name. */
+static const location_provider_t *
+find_location_provider(
+	const location_provider_t location_providers[], 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;
+}
+
+
+/* Initialize options struct. */
+void
+options_init(options_t *options)
+{
+	options->config_filepath = NULL;
+
+	/* Default elevation values. */
+	options->scheme.high = TRANSITION_HIGH;
+	options->scheme.low = TRANSITION_LOW;
+
+	/* Settings for day, night and transition period.
+	   Initialized to indicate that the values are not set yet. */
+	options->scheme.use_time = 0;
+	options->scheme.dawn.start = -1;
+	options->scheme.dawn.end = -1;
+	options->scheme.dusk.start = -1;
+	options->scheme.dusk.end = -1;
+
+	options->scheme.day.temperature = -1;
+	options->scheme.day.gamma[0] = NAN;
+	options->scheme.day.brightness = NAN;
+
+	options->scheme.night.temperature = -1;
+	options->scheme.night.gamma[0] = NAN;
+	options->scheme.night.brightness = NAN;
+
+	/* Temperature for manual mode */
+	options->temp_set = -1;
+
+	options->method = NULL;
+	options->method_args = NULL;
+
+	options->provider = NULL;
+	options->provider_args = NULL;
+
+	options->use_fade = -1;
+	options->mode = PROGRAM_MODE_CONTINUAL;
+	options->verbose = 0;
+}
+
+/* Parse command line arguments. */
+void
+options_parse_args(
+	options_t *options, int argc, char *argv[],
+	const gamma_method_t *gamma_methods,
+	const location_provider_t *location_providers)
+{
+	int r;
+	char *s;
+
+	/* 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,
+				&options->scheme.day.brightness,
+				&options->scheme.night.brightness);
+			break;
+		case 'c':
+			free(options->config_filepath);
+			options->config_filepath = strdup(optarg);
+			break;
+		case 'g':
+			r = parse_gamma_string(
+				optarg, options->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(options->scheme.night.gamma,
+			       options->scheme.day.gamma,
+			       sizeof(options->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(location_providers);
+				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";
+				options->provider_args = optarg;
+			} else {
+				/* Split off provider arguments. */
+				s = strchr(optarg, ':');
+				if (s != NULL) {
+					*(s++) = '\0';
+					options->provider_args = s;
+				}
+
+				provider_name = optarg;
+			}
+
+			/* Lookup provider from name. */
+			options->provider = find_location_provider(
+				location_providers, provider_name);
+			if (options->provider == NULL) {
+				fprintf(stderr, _("Unknown location provider"
+						  " `%s'.\n"), provider_name);
+				exit(EXIT_FAILURE);
+			}
+
+			/* Print provider help if arg is `help'. */
+			if (options->provider_args != NULL &&
+			    strcasecmp(options->provider_args, "help") == 0) {
+				options->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(gamma_methods);
+				exit(EXIT_SUCCESS);
+			}
+
+			/* Split off method arguments. */
+			s = strchr(optarg, ':');
+			if (s != NULL) {
+				*(s++) = '\0';
+				options->method_args = s;
+			}
+
+			/* Find adjustment method by name. */
+			options->method = find_gamma_method(
+				gamma_methods, optarg);
+			if (options->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 (options->method_args != NULL &&
+			    strcasecmp(options->method_args, "help") == 0) {
+				options->method->print_help(stdout);
+				exit(EXIT_SUCCESS);
+			}
+			break;
+		case 'o':
+			options->mode = PROGRAM_MODE_ONE_SHOT;
+			break;
+		case 'O':
+			options->mode = PROGRAM_MODE_MANUAL;
+			options->temp_set = atoi(optarg);
+			break;
+		case 'p':
+			options->mode = PROGRAM_MODE_PRINT;
+			break;
+		case 'r':
+			options->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';
+			options->scheme.day.temperature = atoi(optarg);
+			options->scheme.night.temperature = atoi(s);
+			break;
+		case 'v':
+			options->verbose = 1;
+			break;
+		case 'V':
+			printf("%s\n", PACKAGE_STRING);
+			exit(EXIT_SUCCESS);
+			break;
+		case 'x':
+			options->mode = PROGRAM_MODE_RESET;
+			break;
+		case '?':
+			fputs(_("Try `-h' for more information.\n"), stderr);
+			exit(EXIT_FAILURE);
+			break;
+		}
+	}
+}
+
+/* Parse options defined in the config file. */
+void
+options_parse_config_file(
+	options_t *options, config_ini_state_t *config_state,
+	const gamma_method_t *gamma_methods,
+	const location_provider_t *location_providers)
+{
+	int r;
+
+	/* Read global config settings. */
+	config_ini_section_t *section = config_ini_get_section(
+		config_state, "redshift");
+	if (section == NULL) return;
+
+	config_ini_setting_t *setting = section->settings;
+	while (setting != NULL) {
+		if (strcasecmp(setting->name, "temp-day") == 0) {
+			if (options->scheme.day.temperature < 0) {
+				options->scheme.day.temperature =
+					atoi(setting->value);
+			}
+		} else if (strcasecmp(setting->name, "temp-night") == 0) {
+			if (options->scheme.night.temperature < 0) {
+				options->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 (options->use_fade < 0) {
+				options->use_fade = !!atoi(setting->value);
+			}
+		} else if (strcasecmp(setting->name, "brightness") == 0) {
+			if (isnan(options->scheme.day.brightness)) {
+				options->scheme.day.brightness =
+					atof(setting->value);
+			}
+			if (isnan(options->scheme.night.brightness)) {
+				options->scheme.night.brightness =
+					atof(setting->value);
+			}
+		} else if (strcasecmp(setting->name, "brightness-day") == 0) {
+			if (isnan(options->scheme.day.brightness)) {
+				options->scheme.day.brightness =
+					atof(setting->value);
+			}
+		} else if (strcasecmp(setting->name,
+			              "brightness-night") == 0) {
+			if (isnan(options->scheme.night.brightness)) {
+				options->scheme.night.brightness =
+					atof(setting->value);
+			}
+		} else if (strcasecmp(setting->name, "elevation-high") == 0) {
+			options->scheme.high = atof(setting->value);
+		} else if (strcasecmp(setting->name, "elevation-low") == 0) {
+			options->scheme.low = atof(setting->value);
+		} else if (strcasecmp(setting->name, "gamma") == 0) {
+			if (isnan(options->scheme.day.gamma[0])) {
+				r = parse_gamma_string(
+					setting->value,
+					options->scheme.day.gamma);
+				if (r < 0) {
+					fputs(_("Malformed gamma setting.\n"),
+					      stderr);
+					exit(EXIT_FAILURE);
+				}
+				memcpy(options->scheme.night.gamma,
+				       options->scheme.day.gamma,
+				       sizeof(options->scheme.night.gamma));
+			}
+		} else if (strcasecmp(setting->name, "gamma-day") == 0) {
+			if (isnan(options->scheme.day.gamma[0])) {
+				r = parse_gamma_string(
+					setting->value,
+					options->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(options->scheme.night.gamma[0])) {
+				r = parse_gamma_string(
+					setting->value,
+					options->scheme.night.gamma);
+				if (r < 0) {
+					fputs(_("Malformed gamma setting.\n"),
+					      stderr);
+					exit(EXIT_FAILURE);
+				}
+			}
+		} else if (strcasecmp(setting->name,
+				      "adjustment-method") == 0) {
+			if (options->method == NULL) {
+				options->method = find_gamma_method(
+					gamma_methods, setting->value);
+				if (options->method == NULL) {
+					fprintf(stderr, _("Unknown adjustment"
+							  " method `%s'.\n"),
+						setting->value);
+					exit(EXIT_FAILURE);
+				}
+			}
+		} else if (strcasecmp(setting->name,
+				      "location-provider") == 0) {
+			if (options->provider == NULL) {
+				options->provider = find_location_provider(
+					location_providers,
+					setting->value);
+				if (options->provider == NULL) {
+					fprintf(stderr, _("Unknown location"
+							  " provider `%s'.\n"),
+						setting->value);
+					exit(EXIT_FAILURE);
+				}
+			}
+		} else if (strcasecmp(setting->name, "dawn-time") == 0) {
+			if (options->scheme.dawn.start < 0) {
+				int r = parse_transition_range(
+					setting->value, &options->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 (options->scheme.dusk.start < 0) {
+				int r = parse_transition_range(
+					setting->value, &options->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;
+	}
+}
+
+/* Replace unspecified options with default values. */
+void
+options_set_defaults(options_t *options)
+{
+	if (options->scheme.day.temperature < 0) {
+		options->scheme.day.temperature = DEFAULT_DAY_TEMP;
+	}
+	if (options->scheme.night.temperature < 0) {
+		options->scheme.night.temperature = DEFAULT_NIGHT_TEMP;
+	}
+
+	if (isnan(options->scheme.day.brightness)) {
+		options->scheme.day.brightness = DEFAULT_BRIGHTNESS;
+	}
+	if (isnan(options->scheme.night.brightness)) {
+		options->scheme.night.brightness = DEFAULT_BRIGHTNESS;
+	}
+
+	if (isnan(options->scheme.day.gamma[0])) {
+		options->scheme.day.gamma[0] = DEFAULT_GAMMA;
+		options->scheme.day.gamma[1] = DEFAULT_GAMMA;
+		options->scheme.day.gamma[2] = DEFAULT_GAMMA;
+	}
+	if (isnan(options->scheme.night.gamma[0])) {
+		options->scheme.night.gamma[0] = DEFAULT_GAMMA;
+		options->scheme.night.gamma[1] = DEFAULT_GAMMA;
+		options->scheme.night.gamma[2] = DEFAULT_GAMMA;
+	}
+
+	if (options->use_fade < 0) options->use_fade = 1;
+}
diff --git a/src/options.h b/src/options.h
new file mode 100644
index 0000000..95a31b1
--- /dev/null
+++ b/src/options.h
@@ -0,0 +1,61 @@
+/* options.h -- Program options header
+   This file is part of Redshift.
+
+   Redshift is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   Redshift is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with Redshift.  If not, see <http://www.gnu.org/licenses/>.
+
+   Copyright (c) 2017  Jon Lund Steffensen <jonlst@gmail.com>
+*/
+
+#ifndef REDSHIFT_OPTIONS_H
+#define REDSHIFT_OPTIONS_H
+
+#include "redshift.h"
+
+typedef struct {
+	/* Path to config file */
+	char *config_filepath;
+
+	transition_scheme_t scheme;
+	program_mode_t mode;
+	int verbose;
+
+	/* Temperature to set in manual mode. */
+	int temp_set;
+	/* Whether to fade between large skips in color temperature. */
+	int use_fade;
+
+	/* Selected gamma method. */
+	const gamma_method_t *method;
+	/* Arguments for gamma method. */
+	char *method_args;
+
+	/* Selected location provider. */
+	const location_provider_t *provider;
+	/* Arguments for location provider. */
+	char *provider_args;
+} options_t;
+
+
+void options_init(options_t *options);
+void options_parse_args(
+	options_t *options, int argc, char *argv[],
+	const gamma_method_t *gamma_methods,
+	const location_provider_t *location_providers);
+void options_parse_config_file(
+	options_t *options, config_ini_state_t *config_state,
+	const gamma_method_t *gamma_methods,
+	const location_provider_t *location_providers);
+void options_set_defaults(options_t *options);
+
+#endif /* ! REDSHIFT_OPTIONS_H */
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;
diff --git a/src/redshift.h b/src/redshift.h
index c659502..f597c67 100644
--- a/src/redshift.h
+++ b/src/redshift.h
@@ -14,7 +14,7 @@
    You should have received a copy of the GNU General Public License
    along with Redshift.  If not, see <http://www.gnu.org/licenses/>.
 
-   Copyright (c) 2013-2014  Jon Lund Steffensen <jonlst@gmail.com>
+   Copyright (c) 2013-2017  Jon Lund Steffensen <jonlst@gmail.com>
 */
 
 #ifndef REDSHIFT_REDSHIFT_H
@@ -23,6 +23,9 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+/* The color temperature when no adjustment is applied. */
+#define NEUTRAL_TEMP  6500
+
 
 /* Location */
 typedef struct {
@@ -45,16 +48,47 @@ typedef struct {
 	float brightness;
 } color_setting_t;
 
+/* 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;
+
 
 /* Gamma adjustment method */
-typedef int gamma_method_init_func(void *state);
-typedef int gamma_method_start_func(void *state);
-typedef void gamma_method_free_func(void *state);
+typedef struct gamma_state gamma_state_t;
+
+typedef int gamma_method_init_func(gamma_state_t **state);
+typedef int gamma_method_start_func(gamma_state_t *state);
+typedef void gamma_method_free_func(gamma_state_t *state);
 typedef void gamma_method_print_help_func(FILE *f);
-typedef int gamma_method_set_option_func(void *state, const char *key,
+typedef int gamma_method_set_option_func(gamma_state_t *state, const char *key,
 					 const char *value);
-typedef void gamma_method_restore_func(void *state);
-typedef int gamma_method_set_temperature_func(void *state,
+typedef void gamma_method_restore_func(gamma_state_t *state);
+typedef int gamma_method_set_temperature_func(gamma_state_t *state,
 					      const color_setting_t *setting);
 
 typedef struct {
@@ -83,15 +117,17 @@ typedef struct {
 
 
 /* Location provider */
-typedef int location_provider_init_func(void *state);
-typedef int location_provider_start_func(void *state);
-typedef void location_provider_free_func(void *state);
+typedef struct location_state location_state_t;
+
+typedef int location_provider_init_func(location_state_t **state);
+typedef int location_provider_start_func(location_state_t *state);
+typedef void location_provider_free_func(location_state_t *state);
 typedef void location_provider_print_help_func(FILE *f);
-typedef int location_provider_set_option_func(void *state, const char *key,
-					      const char *value);
-typedef int location_provider_get_fd_func(void *state);
+typedef int location_provider_set_option_func(
+	location_state_t *state, const char *key, const char *value);
+typedef int location_provider_get_fd_func(location_state_t *state);
 typedef int location_provider_handle_func(
-	void *state, location_t *location, int *available);
+	location_state_t *state, location_t *location, int *available);
 
 typedef struct {
 	char *name;