[disorder] / disobedience / settings.c

/*
 * This file is part of Disobedience
 * Copyright (C) 2007, 2008 Richard Kettlewell
 *
 * This program 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.
 *
 * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 */
/** @file disobedience/settings.c
 * @brief Disobedience settings
 *
 * Originally I attempted to use a built-in rc file to configure
 * Disobedience's colors.  This is quite convenient but fails in the
 * face of themes, as the theme settings override the application
 * ones.
 *
 * This file therefore collects all the colors of the Disobedience UI
 * and (in time) will have a configuration dialog too.
 */

#include "disobedience.h"
#include "inputline.h"
#include "split.h"
#include <sys/stat.h>

/** @brief HTML displayer */
const char *browser = BROWSER;

/** @brief Default style for layouts */
GtkStyle *layout_style;

/** @brief Title-row style for layouts */
GtkStyle *title_style;

/** @brief Even-row style for layouts */
GtkStyle *even_style;

/** @brief Odd-row style for layouts */
GtkStyle *odd_style;

/** @brief Active-row style for layouts */
GtkStyle *active_style;

/** @brief Style for tools */
GtkStyle *tool_style;

/** @brief Style for search results */
GtkStyle *search_style;

/** @brief Style for drag targets */
GtkStyle *drag_style;

/** @brief Table of styles */
static const struct {
  const char *name;
  GtkStyle **style;
} styles[] = {
  { "layout", &layout_style },
  { "title", &title_style },
  { "even", &even_style },
  { "odd", &odd_style },
  { "active", &active_style },
  { "tool", &tool_style },
  { "search", &search_style },
  { "drag", &drag_style },
};

#define NSTYLES (sizeof styles / sizeof *styles)

/** @brief Table of state types */
static const char *const states[] = {
  "normal",
  "active",
  "prelight",
  "selected",
  "insensitive"
};

#define NSTATES (sizeof states / sizeof *states)

/** @brief Table of colors */
static const struct {
  const char *name;
  size_t offset;
} colors[] = {
  { "fg", offsetof(GtkStyle, fg) },
  { "bg", offsetof(GtkStyle, bg) },
};

#define NCOLORS (sizeof colors / sizeof *colors)

/** @brief Initialize styles */
void init_styles(void) {
  layout_style = gtk_style_new();
  title_style = gtk_style_new();
  even_style = gtk_style_new();
  odd_style = gtk_style_new();
  active_style = gtk_style_new();
  search_style = gtk_style_new();
  tool_style = gtk_style_new();
  drag_style = gtk_style_new();

  /* Style defaults */
    
  /* Layouts are basically black on white */
  layout_style->bg[GTK_STATE_NORMAL] = layout_style->white;
  layout_style->fg[GTK_STATE_NORMAL] = layout_style->black;
    
  /* Title row is inverted */
  title_style->bg[GTK_STATE_NORMAL] = layout_style->fg[GTK_STATE_NORMAL];
  title_style->fg[GTK_STATE_NORMAL] = layout_style->bg[GTK_STATE_NORMAL];

  /* Active row is pastel green */
  active_style->bg[GTK_STATE_NORMAL].red = 0xE000;
  active_style->bg[GTK_STATE_NORMAL].green = 0xFFFF;
  active_style->bg[GTK_STATE_NORMAL].blue = 0xE000;
  active_style->fg[GTK_STATE_NORMAL] = layout_style->fg[GTK_STATE_NORMAL];

  /* Even rows are pastel red */
  even_style->bg[GTK_STATE_NORMAL].red = 0xFFFF;
  even_style->bg[GTK_STATE_NORMAL].green = 0xEC00;
  even_style->bg[GTK_STATE_NORMAL].blue = 0xEC00;
  even_style->fg[GTK_STATE_NORMAL] = layout_style->fg[GTK_STATE_NORMAL];

  /* Odd rows match the underlying layout */
  odd_style->bg[GTK_STATE_NORMAL] = layout_style->bg[GTK_STATE_NORMAL];
  odd_style->fg[GTK_STATE_NORMAL] = layout_style->fg[GTK_STATE_NORMAL];

  /* Search results have a yellow background */
  search_style->fg[GTK_STATE_NORMAL] = layout_style->fg[GTK_STATE_NORMAL];
  search_style->bg[GTK_STATE_NORMAL].red = 0xFFFF;
  search_style->bg[GTK_STATE_NORMAL].green = 0xFFFF;
  search_style->bg[GTK_STATE_NORMAL].blue = 0x0000;

  /* Drag targets are grey */
  drag_style->bg[GTK_STATE_NORMAL].red = 0x6666;
  drag_style->bg[GTK_STATE_NORMAL].green = 0x6666;
  drag_style->bg[GTK_STATE_NORMAL].blue = 0x6666;
  
  /* Tools we leave at GTK+ defaults */
}

void save_settings(void) {
  char *dir, *path, *tmp;
  FILE *fp = 0;
  size_t n, m, c;

  byte_xasprintf(&dir, "%s/.disorder", getenv("HOME"));
  byte_xasprintf(&path, "%s/disobedience", dir);
  byte_xasprintf(&tmp, "%s.tmp", path);
  mkdir(dir, 02700);                    /* make sure directory exists */
  if(!(fp = fopen(tmp, "w"))) {
    fpopup_msg(GTK_MESSAGE_ERROR, "error opening %s: %s",
               tmp, strerror(errno));
    goto done;
  }
  if(fprintf(fp,
             "# automatically generated!\n\n") < 0)
    goto write_error;
  for(n = 0; n < NSTYLES; ++n)
    for(c = 0; c < NCOLORS; ++c)
      for(m = 0; m < NSTATES; ++m) {
        const GdkColor *color = (GdkColor *)((char *)styles[n].style + colors[c].offset) + m;
        if(fprintf(fp, "color %8s %12s %s 0x%04x 0x%04x 0x%04x\n",
                   styles[n].name, states[m], colors[c].name,
                   color->red,
                   color->green,
                   color->blue) < 0)
          goto write_error;
      }
  if(fprintf(fp, "browser %s\n", browser) < 0)
    goto write_error;
  if(fclose(fp) < 0) {
    fp = 0;
  write_error:
    fpopup_msg(GTK_MESSAGE_ERROR, "error writing to %s: %s",
               tmp, strerror(errno));
    goto done;
  }
  fp = 0;
  if(rename(tmp, path) < 0)
    fpopup_msg(GTK_MESSAGE_ERROR, "error renaming %s to %s: %s",
               tmp, path, strerror(errno));
done:
  if(fp)
    fclose(fp);
}

static inline unsigned clamp(unsigned n) {
  return n > 0xFFFF ? 0xFFFF : n;
}

void load_settings(void) {
  char *path, *line;
  FILE *fp;
  char **vec;
  int nvec;
  size_t n, m, c;

  byte_xasprintf(&path, "%s/.disorder/disobedience", getenv("HOME"));
  if(!(fp = fopen(path, "r"))) {
    if(errno != ENOENT)
      fpopup_msg(GTK_MESSAGE_ERROR, "error opening %s: %s",
                 path, strerror(errno));
  } else {
    while(!inputline(path, fp, &line, '\n')) {
      if(!(vec = split(line, &nvec, SPLIT_COMMENTS|SPLIT_QUOTES, 0, 0))
         || !nvec)
        continue;
      if(!strcmp(vec[0], "color")) {
        GdkColor *color;
        if(nvec != 7) {
          disorder_error(0, "%s: malformed '%s' command", path, vec[0]);
          continue;
        }
        for(n = 0; n < NSTYLES && strcmp(styles[n].name, vec[1]); ++n)
          ;
        if(n >= NSTYLES) {
          disorder_error(0, "%s: unknown style '%s'", path, vec[1]);
          continue;
        }
        for(m = 0; m < NSTATES && strcmp(states[m], vec[2]); ++m)
          ;
        if(m >= NSTATES) {
          disorder_error(0, "%s: unknown state '%s'", path, vec[2]);
          continue;
        }
        for(c = 0; c < NCOLORS && strcmp(colors[c].name, vec[3]); ++c)
          ;
        if(c >= NCOLORS) {
          disorder_error(0, "%s: unknown color '%s'", path, vec[3]);
          continue;
        }
        color = (GdkColor *)((char *)styles[n].style + colors[c].offset) + m;
        color->red = strtoul(vec[4], 0, 0);
        color->green = strtoul(vec[5], 0, 0);
        color->blue = strtoul(vec[6], 0, 0);
      } else if(!strcmp(vec[0], "browser")) {
        if(nvec != 2) {
          disorder_error(0, "%s: malformed '%s' command", path, vec[0]);
          continue;
        }
        browser = vec[1];
      } else
        /* mention errors but otherwise ignore them */
        disorder_error(0, "%s: unknown command '%s'", path, vec[0]);
    }
    if(ferror(fp)) {
      fpopup_msg(GTK_MESSAGE_ERROR, "error reading %s: %s",
                 path, strerror(errno));
      fclose(fp);
    }
  }
}

/** @brief Recursively set tool widget colors
 *
 * This is currently unused; the idea was to allow for configurability without
 * allowing GTK+ to override our use of color, but things seem generally better
 * without this particular call.
 */
void set_tool_colors(GtkWidget attribute((unused)) *w) {
}

/** @brief Pop up a settings editor widget */
void popup_settings(void) {
  static GtkWidget *settings_window;
  GtkWidget *table;
  unsigned row, col;

  if(settings_window) { 
    gtk_window_present(GTK_WINDOW(settings_window));
    return;
  }
  /* Create the window */
  settings_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_widget_set_style(settings_window, tool_style);
  gtk_window_set_title(GTK_WINDOW(settings_window), "Disobedience Settings");
  /* Clear the pointer to the window widget when it is closed */
  g_signal_connect(settings_window, "destroy",
		   G_CALLBACK(gtk_widget_destroyed), &settings_window);

  /* The color settings live in a big table */
  table = gtk_table_new(2 * NSTYLES + 1/*rows */, NSTATES + 1/*cols*/,
                        TRUE/*homogeneous*/);
  /* Titles */
  for(row = 0; row < 2 * NSTYLES; ++row) {
    char *legend;

    byte_xasprintf(&legend, "%s %s", styles[row / 2].name,
                   row % 2 ? "background" : "foreground");
    gtk_table_attach(GTK_TABLE(table),
                     gtk_label_new(legend),
                     0, 1,
                     row + 1, row + 2,
                     GTK_FILL, GTK_FILL,
                     1, 1);
  }
  for(col = 0; col < NSTATES; ++col) {
    gtk_table_attach(GTK_TABLE(table),
                     gtk_label_new(states[col]),
                     col + 1, col + 2,
                     0, 1,
                     GTK_FILL, GTK_FILL,
                     1, 1);
  }
  /* The actual colors */
  for(row = 0; row < 2 * NSTYLES; ++row) {
    for(col = 0; col <  NSTATES; ++col) {
      GdkColor *const c = &(row % 2
                            ? (**styles[row / 2].style).bg
                            : (**styles[row / 2].style).fg)[col];
      gtk_table_attach(GTK_TABLE(table),
                       gtk_color_button_new_with_color(c),
                       col + 1, col + 2,
                       row + 1, row + 2,
                       GTK_FILL, GTK_FILL,
                       1, 1);
    }
  }
  gtk_container_add(GTK_CONTAINER(settings_window), frame_widget(table, NULL));
  gtk_widget_show_all(settings_window);
  /* TODO: save settings
     TODO: web browser
     TODO: impose settings when they are set
  */
}

/*
Local Variables:
c-basic-offset:2
comment-column:40
fill-column:79
indent-tabs-mode:nil
End:
*/
Commit	Line	Data
d4ef4132 RK	1	/*
d4ef4132 RK	2	* This file is part of Disobedience
5aff007d	3	* Copyright (C) 2007, 2008 Richard Kettlewell
d4ef4132	4	*
e7eb3a27	5	* This program is free software: you can redistribute it and/or modify
d4ef4132	6	* it under the terms of the GNU General Public License as published by
e7eb3a27	7	* the Free Software Foundation, either version 3 of the License, or
d4ef4132 RK	8	* (at your option) any later version.
d4ef4132 RK	9	*
e7eb3a27 RK	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*
d4ef4132	15	* You should have received a copy of the GNU General Public License
e7eb3a27	16	* along with this program. If not, see <http://www.gnu.org/licenses/>.
d4ef4132	17	*/
f486ea18 RK	18	/** @file disobedience/settings.c
f486ea18 RK	19	* @brief Disobedience settings
d4ef4132 RK	20	*
	21	* Originally I attempted to use a built-in rc file to configure
	22	* Disobedience's colors. This is quite convenient but fails in the
	23	* face of themes, as the theme settings override the application
	24	* ones.
	25	*
	26	* This file therefore collects all the colors of the Disobedience UI
	27	* and (in time) will have a configuration dialog too.
	28	*/
	29
	30	#include "disobedience.h"
	31	#include "inputline.h"
d308abea	32	#include "split.h"
d4ef4132 RK	33	#include <sys/stat.h>
d4ef4132 RK	34
f486ea18 RK	35	/** @brief HTML displayer */
	36	const char *browser = BROWSER;
	37
b4f8eba1 RK	38	/** @brief Default style for layouts */
	39	GtkStyle *layout_style;
	40
	41	/** @brief Title-row style for layouts */
	42	GtkStyle *title_style;
	43
	44	/** @brief Even-row style for layouts */
	45	GtkStyle *even_style;
	46
	47	/** @brief Odd-row style for layouts */
	48	GtkStyle *odd_style;
	49
	50	/** @brief Active-row style for layouts */
	51	GtkStyle *active_style;
	52
	53	/** @brief Style for tools */
	54	GtkStyle *tool_style;
	55
	56	/** @brief Style for search results */
	57	GtkStyle *search_style;
	58
	59	/** @brief Style for drag targets */
	60	GtkStyle *drag_style;
	61
	62	/** @brief Table of styles */
	63	static const struct {
	64	const char *name;
	65	GtkStyle **style;
	66	} styles[] = {
	67	{ "layout", &layout_style },
	68	{ "title", &title_style },
	69	{ "even", &even_style },
	70	{ "odd", &odd_style },
	71	{ "active", &active_style },
	72	{ "tool", &tool_style },
	73	{ "search", &search_style },
	74	{ "drag", &drag_style },
	75	};
	76
	77	#define NSTYLES (sizeof styles / sizeof *styles)
	78
	79	/** @brief Table of state types */
	80	static const char *const states[] = {
	81	"normal",
	82	"active",
	83	"prelight",
	84	"selected",
	85	"insensitive"
	86	};
	87
	88	#define NSTATES (sizeof states / sizeof *states)
	89
	90	/** @brief Table of colors */
	91	static const struct {
	92	const char *name;
	93	size_t offset;
	94	} colors[] = {
	95	{ "fg", offsetof(GtkStyle, fg) },
	96	{ "bg", offsetof(GtkStyle, bg) },
	97	};
	98
	99	#define NCOLORS (sizeof colors / sizeof *colors)
	100
	101	/** @brief Initialize styles */
102	void init_styles(void) {
103	layout_style = gtk_style_new();
104	title_style = gtk_style_new();
105	even_style = gtk_style_new();
106	odd_style = gtk_style_new();
107	active_style = gtk_style_new();
108	search_style = gtk_style_new();
109	tool_style = gtk_style_new();
110	drag_style = gtk_style_new();
111
112	/* Style defaults */
113
114	/* Layouts are basically black on white */
115	layout_style->bg[GTK_STATE_NORMAL] = layout_style->white;
116	layout_style->fg[GTK_STATE_NORMAL] = layout_style->black;
117
118	/* Title row is inverted */
119	title_style->bg[GTK_STATE_NORMAL] = layout_style->fg[GTK_STATE_NORMAL];
120	title_style->fg[GTK_STATE_NORMAL] = layout_style->bg[GTK_STATE_NORMAL];
121
122	/* Active row is pastel green */
123	active_style->bg[GTK_STATE_NORMAL].red = 0xE000;
124	active_style->bg[GTK_STATE_NORMAL].green = 0xFFFF;
125	active_style->bg[GTK_STATE_NORMAL].blue = 0xE000;
126	active_style->fg[GTK_STATE_NORMAL] = layout_style->fg[GTK_STATE_NORMAL];
127
128	/* Even rows are pastel red */
129	even_style->bg[GTK_STATE_NORMAL].red = 0xFFFF;
130	even_style->bg[GTK_STATE_NORMAL].green = 0xEC00;
131	even_style->bg[GTK_STATE_NORMAL].blue = 0xEC00;
132	even_style->fg[GTK_STATE_NORMAL] = layout_style->fg[GTK_STATE_NORMAL];
133
134	/* Odd rows match the underlying layout */
135	odd_style->bg[GTK_STATE_NORMAL] = layout_style->bg[GTK_STATE_NORMAL];
136	odd_style->fg[GTK_STATE_NORMAL] = layout_style->fg[GTK_STATE_NORMAL];
137
138	/* Search results have a yellow background */
139	search_style->fg[GTK_STATE_NORMAL] = layout_style->fg[GTK_STATE_NORMAL];
140	search_style->bg[GTK_STATE_NORMAL].red = 0xFFFF;
141	search_style->bg[GTK_STATE_NORMAL].green = 0xFFFF;
142	search_style->bg[GTK_STATE_NORMAL].blue = 0x0000;
143
144	/* Drag targets are grey */
145	drag_style->bg[GTK_STATE_NORMAL].red = 0x6666;
146	drag_style->bg[GTK_STATE_NORMAL].green = 0x6666;
147	drag_style->bg[GTK_STATE_NORMAL].blue = 0x6666;
148
149	/* Tools we leave at GTK+ defaults */
150	}
151
f486ea18	152	void save_settings(void) {
d4ef4132 RK	153	char dir, path, *tmp;
d4ef4132 RK	154	FILE *fp = 0;
b4f8eba1	155	size_t n, m, c;
d4ef4132 RK	156
	157	byte_xasprintf(&dir, "%s/.disorder", getenv("HOME"));
	158	byte_xasprintf(&path, "%s/disobedience", dir);
	159	byte_xasprintf(&tmp, "%s.tmp", path);
	160	mkdir(dir, 02700); /* make sure directory exists */
	161	if(!(fp = fopen(tmp, "w"))) {
	162	fpopup_msg(GTK_MESSAGE_ERROR, "error opening %s: %s",
	163	tmp, strerror(errno));
	164	goto done;
	165	}
b4f8eba1 RK	166	if(fprintf(fp,
	167	"# automatically generated!\n\n") < 0)
	168	goto write_error;
	169	for(n = 0; n < NSTYLES; ++n)
	170	for(c = 0; c < NCOLORS; ++c)
	171	for(m = 0; m < NSTATES; ++m) {
	172	const GdkColor color = (GdkColor )((char *)styles[n].style + colors[c].offset) + m;
	173	if(fprintf(fp, "color %8s %12s %s 0x%04x 0x%04x 0x%04x\n",
	174	styles[n].name, states[m], colors[c].name,
	175	color->red,
	176	color->green,
	177	color->blue) < 0)
	178	goto write_error;
	179	}
	180	if(fprintf(fp, "browser %s\n", browser) < 0)
	181	goto write_error;
d4ef4132	182	if(fclose(fp) < 0) {
b4f8eba1 RK	183	fp = 0;
b4f8eba1 RK	184	write_error:
d4ef4132 RK	185	fpopup_msg(GTK_MESSAGE_ERROR, "error writing to %s: %s",
d4ef4132 RK	186	tmp, strerror(errno));
d4ef4132 RK	187	goto done;
	188	}
	189	fp = 0;
	190	if(rename(tmp, path) < 0)
	191	fpopup_msg(GTK_MESSAGE_ERROR, "error renaming %s to %s: %s",
	192	tmp, path, strerror(errno));
	193	done:
	194	if(fp)
	195	fclose(fp);
	196	}
	197
	198	static inline unsigned clamp(unsigned n) {
	199	return n > 0xFFFF ? 0xFFFF : n;
	200	}
	201
f486ea18	202	void load_settings(void) {
d4ef4132 RK	203	char path, line;
d4ef4132 RK	204	FILE *fp;
d4ef4132 RK	205	char **vec;
d4ef4132 RK	206	int nvec;
b4f8eba1	207	size_t n, m, c;
d4ef4132 RK	208
	209	byte_xasprintf(&path, "%s/.disorder/disobedience", getenv("HOME"));
	210	if(!(fp = fopen(path, "r"))) {
	211	if(errno != ENOENT)
	212	fpopup_msg(GTK_MESSAGE_ERROR, "error opening %s: %s",
	213	path, strerror(errno));
f3258332 RK	214	} else {
	215	while(!inputline(path, fp, &line, '\n')) {
	216	if(!(vec = split(line, &nvec, SPLIT_COMMENTS\|SPLIT_QUOTES, 0, 0))
	217	\|\| !nvec)
d4ef4132	218	continue;
f3258332	219	if(!strcmp(vec[0], "color")) {
b4f8eba1 RK	220	GdkColor *color;
b4f8eba1 RK	221	if(nvec != 7) {
2e9ba080	222	disorder_error(0, "%s: malformed '%s' command", path, vec[0]);
f3258332 RK	223	continue;
f3258332 RK	224	}
b4f8eba1 RK	225	for(n = 0; n < NSTYLES && strcmp(styles[n].name, vec[1]); ++n)
	226	;
	227	if(n >= NSTYLES) {
2e9ba080	228	disorder_error(0, "%s: unknown style '%s'", path, vec[1]);
b4f8eba1 RK	229	continue;
	230	}
	231	for(m = 0; m < NSTATES && strcmp(states[m], vec[2]); ++m)
	232	;
	233	if(m >= NSTATES) {
2e9ba080	234	disorder_error(0, "%s: unknown state '%s'", path, vec[2]);
b4f8eba1 RK	235	continue;
	236	}
	237	for(c = 0; c < NCOLORS && strcmp(colors[c].name, vec[3]); ++c)
	238	;
	239	if(c >= NCOLORS) {
2e9ba080	240	disorder_error(0, "%s: unknown color '%s'", path, vec[3]);
b4f8eba1 RK	241	continue;
	242	}
	243	color = (GdkColor )((char )styles[n].style + colors[c].offset) + m;
	244	color->red = strtoul(vec[4], 0, 0);
	245	color->green = strtoul(vec[5], 0, 0);
	246	color->blue = strtoul(vec[6], 0, 0);
	247	} else if(!strcmp(vec[0], "browser")) {
	248	if(nvec != 2) {
2e9ba080	249	disorder_error(0, "%s: malformed '%s' command", path, vec[0]);
b4f8eba1 RK	250	continue;
	251	}
	252	browser = vec[1];
f3258332 RK	253	} else
f3258332 RK	254	/* mention errors but otherwise ignore them */
2e9ba080	255	disorder_error(0, "%s: unknown command '%s'", path, vec[0]);
f3258332 RK	256	}
	257	if(ferror(fp)) {
	258	fpopup_msg(GTK_MESSAGE_ERROR, "error reading %s: %s",
	259	path, strerror(errno));
	260	fclose(fp);
	261	}
d4ef4132	262	}
d4ef4132 RK	263	}
d4ef4132 RK	264
87eb933d RK	265	/** @brief Recursively set tool widget colors
	266	*
	267	* This is currently unused; the idea was to allow for configurability without
	268	* allowing GTK+ to override our use of color, but things seem generally better
	269	* without this particular call.
	270	*/
	271	void set_tool_colors(GtkWidget attribute((unused)) *w) {
d4ef4132 RK	272	}
d4ef4132 RK	273
46fb1b05 RK	274	/** @brief Pop up a settings editor widget */
	275	void popup_settings(void) {
	276	static GtkWidget *settings_window;
	277	GtkWidget *table;
	278	unsigned row, col;
	279
	280	if(settings_window) {
	281	gtk_window_present(GTK_WINDOW(settings_window));
	282	return;
	283	}
	284	/* Create the window */
	285	settings_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	286	gtk_widget_set_style(settings_window, tool_style);
	287	gtk_window_set_title(GTK_WINDOW(settings_window), "Disobedience Settings");
	288	/* Clear the pointer to the window widget when it is closed */
	289	g_signal_connect(settings_window, "destroy",
	290	G_CALLBACK(gtk_widget_destroyed), &settings_window);
	291
	292	/* The color settings live in a big table */
	293	table = gtk_table_new(2 * NSTYLES + 1/rows /, NSTATES + 1/cols/,
	294	TRUE/homogeneous/);
	295	/* Titles */
	296	for(row = 0; row < 2 * NSTYLES; ++row) {
	297	char *legend;
	298
	299	byte_xasprintf(&legend, "%s %s", styles[row / 2].name,
	300	row % 2 ? "background" : "foreground");
	301	gtk_table_attach(GTK_TABLE(table),
	302	gtk_label_new(legend),
	303	0, 1,
	304	row + 1, row + 2,
	305	GTK_FILL, GTK_FILL,
	306	1, 1);
	307	}
	308	for(col = 0; col < NSTATES; ++col) {
	309	gtk_table_attach(GTK_TABLE(table),
	310	gtk_label_new(states[col]),
	311	col + 1, col + 2,
	312	0, 1,
	313	GTK_FILL, GTK_FILL,
	314	1, 1);
	315	}
	316	/* The actual colors */
	317	for(row = 0; row < 2 * NSTYLES; ++row) {
	318	for(col = 0; col < NSTATES; ++col) {
	319	GdkColor *const c = &(row % 2
	320	? (**styles[row / 2].style).bg
	321	: (**styles[row / 2].style).fg)[col];
	322	gtk_table_attach(GTK_TABLE(table),
	323	gtk_color_button_new_with_color(c),
	324	col + 1, col + 2,
	325	row + 1, row + 2,
	326	GTK_FILL, GTK_FILL,
	327	1, 1);
	328	}
	329	}
e18c4734	330	gtk_container_add(GTK_CONTAINER(settings_window), frame_widget(table, NULL));
46fb1b05 RK	331	gtk_widget_show_all(settings_window);
	332	/* TODO: save settings
	333	TODO: web browser
	334	TODO: impose settings when they are set
	335	*/
	336	}
	337
d4ef4132 RK	338	/*
	339	Local Variables:
	340	c-basic-offset:2
	341	comment-column:40
	342	fill-column:79
	343	indent-tabs-mode:nil
	344	End:
	345	*/