SIDPlayer/src/prefs.cpp

/*
 *  prefs.cpp - Preferences handling
 *
 *  SIDPlayer (C) Copyright 1996-2000 Christian Bauer
 *
 *  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 2 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, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include "sys.h"

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>

#include "prefs.h"


// Prefs items are stored in a linked list of these nodes
struct prefs_node {
        prefs_node *next;
        const char *name;
        prefs_type type;
        void *data;
        prefs_desc *desc;
};

// List of prefs nodes
static prefs_node *the_prefs = NULL;

// Prototypes
static prefs_desc *find_prefs_desc(const char *name);


/*
 *  Initialize preferences
 */

void PrefsInit(int argc, char **argv)
{
        // Set defaults
        AddPrefsDefaults();

        // Override prefs with command line arguments
        argc--; argv++;
        for (; argc>0; argc--, argv++) {

                // Arguments are of the form '--keyword'
                if (strlen(*argv) < 3 || argv[0][0] != '-' || argv[0][1] != '-')
                        continue;
                const char *keyword = *argv + 2;
                const prefs_desc *d = find_prefs_desc(keyword);
                if (d == NULL) {
                        printf("WARNING: Unrecognized argument '%s'\n", *argv);
                        continue;
                }

                // Add/replace prefs item
                switch (d->type) {
                        case TYPE_STRING:
                                if (argc < 2) {
                                        printf("WARNING: Argument '%s' must be followed by value\n", *argv);
                                        break;
                                }
                                argc--; argv++;
                                if (d->multiple)
                                        PrefsAddString(keyword, *argv);
                                else
                                        PrefsReplaceString(keyword, *argv);
                                break;

                        case TYPE_BOOLEAN:
                                if (argc > 1 && argv[1][0] != '-') {
                                        argc--; argv++;
                                        PrefsReplaceBool(keyword, !strcmp(*argv, "true") || !strcmp(*argv, "on"));
                                } else
                                        PrefsReplaceBool(keyword, true);
                                break;

                        case TYPE_INT32:
                                if (argc < 2) {
                                        printf("WARNING: Argument '%s' must be followed by value\n", *argv);
                                        break;
                                }
                                argc--; argv++;
                                PrefsReplaceInt32(keyword, atoi(*argv));
                                break;

                        default:
                                break;
                }
        }
}


/*
 *  Deinitialize preferences
 */

void PrefsExit(void)
{
        // Free prefs list
        prefs_node *p = the_prefs, *next;
        while (p) {
                next = p->next;
                free((void *)p->name);
                free(p->data);
                delete p;
                p = next;
        }
}


/*
 *  Find preferences descriptor by keyword
 */

static prefs_desc *find_prefs_desc(const char *name, prefs_desc *list)
{
        while (list->type != TYPE_ANY) {
                if (strcmp(list->name, name) == 0)
                        return list;
                list++;
        }
        return NULL;
}

static prefs_desc *find_prefs_desc(const char *name)
{
        return find_prefs_desc(name, common_prefs_items);
}


/*
 *  Set prefs items
 */

static void add_data(const char *name, prefs_type type, void *data, int size)
{
        void *d = malloc(size);
        if (d == NULL)
                return;
        memcpy(d, data, size);
        prefs_node *p = new prefs_node;
        p->next = 0;
        p->name = strdup(name);
        p->type = type;
        p->data = d;
        p->desc = find_prefs_desc(p->name);
        if (the_prefs) {
                prefs_node *prev = the_prefs;
                while (prev->next)
                        prev = prev->next;
                prev->next = p;
        } else
                the_prefs = p;
}

void PrefsAddString(const char *name, const char *s)
{
        add_data(name, TYPE_STRING, (void *)s, strlen(s) + 1);
}

void PrefsAddBool(const char *name, bool b)
{
        add_data(name, TYPE_BOOLEAN, &b, sizeof(bool));
}

void PrefsAddInt32(const char *name, int32 val)
{
        add_data(name, TYPE_INT32, &val, sizeof(int32));
}


/*
 *  Replace prefs items
 */

static prefs_node *find_node(const char *name, prefs_type type, int index = 0)
{
        prefs_node *p = the_prefs;
        int i = 0;
        while (p) {
                if ((type == TYPE_ANY || p->type == type) && !strcmp(p->name, name)) {
                        if (i == index)
                                return p;
                        else
                                i++;
                }
                p = p->next;
        }
        return NULL;
}

void PrefsReplaceString(const char *name, const char *s, int index)
{
        prefs_node *p = find_node(name, TYPE_STRING, index);
        if (p) {
                if (p->desc && p->desc->func)
                        ((prefs_func_string)(p->desc->func))(name, (const char *)p->data, s);
                free(p->data);
                p->data = strdup(s);
        } else
                add_data(name, TYPE_STRING, (void *)s, strlen(s) + 1);
}

void PrefsReplaceBool(const char *name, bool b)
{
        prefs_node *p = find_node(name, TYPE_BOOLEAN);
        if (p) {
                if (p->desc && p->desc->func)
                        ((prefs_func_bool)(p->desc->func))(name, *(bool *)(p->data), b);
                *(bool *)(p->data) = b;
        } else
                add_data(name, TYPE_BOOLEAN, &b, sizeof(bool));
}

void PrefsReplaceInt32(const char *name, int32 val)
{
        prefs_node *p = find_node(name, TYPE_INT32);
        if (p) {
                if (p->desc && p->desc->func)
                        ((prefs_func_int32)(p->desc->func))(name, *(int32 *)(p->data), val);
                *(int32 *)(p->data) = val;
        } else
                add_data(name, TYPE_INT32, &val, sizeof(int32));
}


/*
 *  Get prefs items
 */

const char *PrefsFindString(const char *name, int index)
{
        prefs_node *p = find_node(name, TYPE_STRING, index);
        if (p)
                return (char *)(p->data);
        else
                return NULL;
}

bool PrefsFindBool(const char *name)
{
        prefs_node *p = find_node(name, TYPE_BOOLEAN, 0);
        if (p)
                return *(bool *)(p->data);
        else
                return false;
}

int32 PrefsFindInt32(const char *name)
{
        prefs_node *p = find_node(name, TYPE_INT32, 0);
        if (p)
                return *(int32 *)(p->data);
        else
                return 0;
}


/*
 *  Remove prefs items
 */

void PrefsRemoveItem(const char *name, int index)
{
        prefs_node *p = find_node(name, TYPE_ANY, index);
        if (p) {
                free((void *)p->name);
                free(p->data);
                prefs_node *q = the_prefs;
                if (q == p) {
                        the_prefs = NULL;
                        delete p;
                        return;
                }
                while (q) {
                        if (q->next == p) {
                                q->next = p->next;
                                delete p;
                                return;
                        }
                        q = q->next;
                }
        }
}


/*
 *  Set prefs change callback function
 */

static void set_callback(const char *name, prefs_func f)
{
        prefs_desc *d = find_prefs_desc(name);
        if (d == NULL)
                return;
        d->func = f;
}

void PrefsSetCallback(const char *name, prefs_func_string f)
{
        set_callback(name, (prefs_func)f);
}

void PrefsSetCallback(const char *name, prefs_func_bool f)
{
        set_callback(name, (prefs_func)f);
}

void PrefsSetCallback(const char *name, prefs_func_int32 f)
{
        set_callback(name, (prefs_func)f);
}
Revision:	1.2
Committed:	2001-01-04T19:54:13Z (23 years, 10 months ago) by cebix
Branch:	MAIN
Changes since 1.1:	+63 -55 lines
Log Message:	- split prefs.cpp into prefs.cpp and prefs_items.cpp - it's now possible to specify prefs items on the command line
#	User	Rev	Content
1	cebix	1.1	/*
2			* prefs.cpp - Preferences handling
3			*
4			* SIDPlayer (C) Copyright 1996-2000 Christian Bauer
5			*
6			* This program is free software; you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation; either version 2 of the License, or
9			* (at your option) any later version.
10			*
11			* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with this program; if not, write to the Free Software
18			* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19			*/
20
21			#include "sys.h"
22
23			#include <string.h>
24			#include <stdlib.h>
25			#include <stdio.h>
26			#include <ctype.h>
27
28			#include "prefs.h"
29
30
31	cebix	1.2	// Prefs items are stored in a linked list of these nodes
32	cebix	1.1	struct prefs_node {
33			prefs_node *next;
34			const char *name;
35			prefs_type type;
36			void *data;
37			prefs_desc *desc;
38			};
39
40			// List of prefs nodes
41	cebix	1.2	static prefs_node *the_prefs = NULL;
42
43			// Prototypes
44			static prefs_desc find_prefs_desc(const char name);
45	cebix	1.1
46
47			/*
48			* Initialize preferences
49			*/
50
51			void PrefsInit(int argc, char **argv)
52			{
53	cebix	1.2	// Set defaults
54			AddPrefsDefaults();
55
56			// Override prefs with command line arguments
57			argc--; argv++;
58			for (; argc>0; argc--, argv++) {
59
60			// Arguments are of the form '--keyword'
61			if (strlen(*argv) < 3 \|\| argv[0][0] != '-' \|\| argv[0][1] != '-')
62			continue;
63			const char keyword = argv + 2;
64			const prefs_desc *d = find_prefs_desc(keyword);
65			if (d == NULL) {
66			printf("WARNING: Unrecognized argument '%s'\n", *argv);
67			continue;
68			}
69	cebix	1.1
70	cebix	1.2	// Add/replace prefs item
71			switch (d->type) {
72			case TYPE_STRING:
73			if (argc < 2) {
74			printf("WARNING: Argument '%s' must be followed by value\n", *argv);
75			break;
76			}
77			argc--; argv++;
78			if (d->multiple)
79			PrefsAddString(keyword, *argv);
80			else
81			PrefsReplaceString(keyword, *argv);
82			break;
83
84			case TYPE_BOOLEAN:
85			if (argc > 1 && argv[1][0] != '-') {
86			argc--; argv++;
87			PrefsReplaceBool(keyword, !strcmp(argv, "true") \|\| !strcmp(argv, "on"));
88			} else
89			PrefsReplaceBool(keyword, true);
90			break;
91
92			case TYPE_INT32:
93			if (argc < 2) {
94			printf("WARNING: Argument '%s' must be followed by value\n", *argv);
95			break;
96			}
97			argc--; argv++;
98			PrefsReplaceInt32(keyword, atoi(*argv));
99			break;
100
101			default:
102			break;
103			}
104			}
105	cebix	1.1	}
106
107
108			/*
109			* Deinitialize preferences
110			*/
111
112			void PrefsExit(void)
113			{
114			// Free prefs list
115			prefs_node p = the_prefs, next;
116			while (p) {
117			next = p->next;
118			free((void *)p->name);
119			free(p->data);
120			delete p;
121			p = next;
122			}
123			}
124
125
126			/*
127			* Find preferences descriptor by keyword
128			*/
129
130			static prefs_desc find_prefs_desc(const char name, prefs_desc *list)
131			{
132			while (list->type != TYPE_ANY) {
133			if (strcmp(list->name, name) == 0)
134			return list;
135			list++;
136			}
137			return NULL;
138			}
139
140	cebix	1.2	static prefs_desc find_prefs_desc(const char name)
141			{
142			return find_prefs_desc(name, common_prefs_items);
143			}
144
145	cebix	1.1
146			/*
147			* Set prefs items
148			*/
149
150			static void add_data(const char name, prefs_type type, void data, int size)
151			{
152			void *d = malloc(size);
153			if (d == NULL)
154			return;
155			memcpy(d, data, size);
156			prefs_node *p = new prefs_node;
157			p->next = 0;
158			p->name = strdup(name);
159			p->type = type;
160			p->data = d;
161	cebix	1.2	p->desc = find_prefs_desc(p->name);
162	cebix	1.1	if (the_prefs) {
163			prefs_node *prev = the_prefs;
164			while (prev->next)
165			prev = prev->next;
166			prev->next = p;
167			} else
168			the_prefs = p;
169			}
170
171			void PrefsAddString(const char name, const char s)
172			{
173			add_data(name, TYPE_STRING, (void *)s, strlen(s) + 1);
174			}
175
176			void PrefsAddBool(const char *name, bool b)
177			{
178			add_data(name, TYPE_BOOLEAN, &b, sizeof(bool));
179			}
180
181			void PrefsAddInt32(const char *name, int32 val)
182			{
183			add_data(name, TYPE_INT32, &val, sizeof(int32));
184			}
185
186
187			/*
188			* Replace prefs items
189			*/
190
191			static prefs_node find_node(const char name, prefs_type type, int index = 0)
192			{
193			prefs_node *p = the_prefs;
194			int i = 0;
195			while (p) {
196			if ((type == TYPE_ANY \|\| p->type == type) && !strcmp(p->name, name)) {
197			if (i == index)
198			return p;
199			else
200			i++;
201			}
202			p = p->next;
203			}
204			return NULL;
205			}
206
207			void PrefsReplaceString(const char name, const char s, int index)
208			{
209			prefs_node *p = find_node(name, TYPE_STRING, index);
210			if (p) {
211			if (p->desc && p->desc->func)
212			((prefs_func_string)(p->desc->func))(name, (const char *)p->data, s);
213			free(p->data);
214			p->data = strdup(s);
215			} else
216			add_data(name, TYPE_STRING, (void *)s, strlen(s) + 1);
217			}
218
219			void PrefsReplaceBool(const char *name, bool b)
220			{
221			prefs_node *p = find_node(name, TYPE_BOOLEAN);
222			if (p) {
223			if (p->desc && p->desc->func)
224			((prefs_func_bool)(p->desc->func))(name, (bool )(p->data), b);
225			(bool )(p->data) = b;
226			} else
227			add_data(name, TYPE_BOOLEAN, &b, sizeof(bool));
228			}
229
230			void PrefsReplaceInt32(const char *name, int32 val)
231			{
232			prefs_node *p = find_node(name, TYPE_INT32);
233			if (p) {
234			if (p->desc && p->desc->func)
235			((prefs_func_int32)(p->desc->func))(name, (int32 )(p->data), val);
236			(int32 )(p->data) = val;
237			} else
238			add_data(name, TYPE_INT32, &val, sizeof(int32));
239			}
240
241
242			/*
243			* Get prefs items
244			*/
245
246			const char PrefsFindString(const char name, int index)
247			{
248			prefs_node *p = find_node(name, TYPE_STRING, index);
249			if (p)
250			return (char *)(p->data);
251			else
252			return NULL;
253			}
254
255			bool PrefsFindBool(const char *name)
256			{
257			prefs_node *p = find_node(name, TYPE_BOOLEAN, 0);
258			if (p)
259			return (bool )(p->data);
260			else
261			return false;
262			}
263
264			int32 PrefsFindInt32(const char *name)
265			{
266			prefs_node *p = find_node(name, TYPE_INT32, 0);
267			if (p)
268			return (int32 )(p->data);
269			else
270			return 0;
271			}
272
273
274			/*
275			* Remove prefs items
276			*/
277
278			void PrefsRemoveItem(const char *name, int index)
279			{
280			prefs_node *p = find_node(name, TYPE_ANY, index);
281			if (p) {
282			free((void *)p->name);
283			free(p->data);
284			prefs_node *q = the_prefs;
285			if (q == p) {
286			the_prefs = NULL;
287			delete p;
288			return;
289			}
290			while (q) {
291			if (q->next == p) {
292			q->next = p->next;
293			delete p;
294			return;
295			}
296			q = q->next;
297			}
298			}
299			}
300
301
302			/*
303			* Set prefs change callback function
304			*/
305
306			static void set_callback(const char *name, prefs_func f)
307			{
308	cebix	1.2	prefs_desc *d = find_prefs_desc(name);
309	cebix	1.1	if (d == NULL)
310			return;
311			d->func = f;
312			}
313
314			void PrefsSetCallback(const char *name, prefs_func_string f)
315			{
316			set_callback(name, (prefs_func)f);
317			}
318
319			void PrefsSetCallback(const char *name, prefs_func_bool f)
320			{
321			set_callback(name, (prefs_func)f);
322			}
323
324			void PrefsSetCallback(const char *name, prefs_func_int32 f)
325			{
326			set_callback(name, (prefs_func)f);
327			}