ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/SIDPlayer/src/prefs.cpp
(Generate patch)

Comparing SIDPlayer/src/prefs.cpp (file contents):
Revision 1.1 by cebix, 2000-07-28T12:42:30Z vs.
Revision 1.4 by cebix, 2001-01-21T18:04:46Z

# Line 1 | Line 1
1   /*
2   *  prefs.cpp - Preferences handling
3   *
4 < *  SIDPlayer (C) Copyright 1996-2000 Christian Bauer
4 > *  SIDPlayer (C) Copyright 1996-2001 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
# Line 28 | Line 28
28   #include "prefs.h"
29  
30  
31 < // List of preferences items
32 < prefs_desc prefs_items[] = {
33 <        {"victype", TYPE_STRING, false},                // Type number of VIC-II to emulate ("6569", "6567" or "6567R5")
34 <        {"sidtype", TYPE_STRING, false},                // Type number of SID to emulate ("6581" or "8580")
35 <        {"samplerate", TYPE_INT32, false},              // Audio sample rate in Hz
36 <        {"audio16bit", TYPE_BOOLEAN, false},    // 16-bit audio output?
37 <        {"stereo", TYPE_BOOLEAN, false},                // Stereo audio output?
38 <        {"filters", TYPE_BOOLEAN, false},               // Emulate SID filters?
39 <        {"dualsid", TYPE_BOOLEAN, false},               // Emulate 2 SID chips?
40 <        {"audioeffect", TYPE_INT32, false},             // Audio effect type (0 = none, 1 = reverb, 2 = spatial)
41 <        {"revdelay", TYPE_INT32, false},                // Reverb delay in ms
42 <        {"revfeedback", TYPE_INT32, false},             // Reverb feedback (0..0x100 = 0..100%)
43 <        {"volume", TYPE_INT32, false},                  // Master volume (0..0x100 = 0..100%)
44 <        {"v1volume", TYPE_INT32, false},                // Volume voice 1 (0..0x100 = 0..100%)
45 <        {"v2volume", TYPE_INT32, false},                // Volume voice 2 (0..0x100 = 0..100%)
46 <        {"v3volume", TYPE_INT32, false},                // Volume voice 3 (0..0x100 = 0..100%)
47 <        {"v4volume", TYPE_INT32, false},                // Volume sampled voice (0..0x100 = 0..100%)
48 <        {"v1pan", TYPE_INT32, false},                   // Panning voice 1 (-0x100..0x100 = left..right)
49 <        {"v2pan", TYPE_INT32, false},                   // Panning voice 2 (-0x100..0x100 = left..right)
50 <        {"v3pan", TYPE_INT32, false},                   // Panning voice 3 (-0x100..0x100 = left..right)
51 <        {"v4pan", TYPE_INT32, false},                   // Panning sampled voice (-0x100..0x100 = left..right)
52 <        {"dualsep", TYPE_INT32, false},                 // Dual-SID stereo separation (0..0x100 = 0..100%)
53 <        {"replayfreq", TYPE_INT32, false},              // Frequency at which 6510 replay routine is called in Hz
54 <        {NULL, TYPE_END, false} // End of list
55 < };
56 <
57 <
58 < // Prefs item are stored in a linked list of these nodes
31 > // Prefs items are stored in a linked list of these nodes
32   struct prefs_node {
33          prefs_node *next;
34          const char *name;
# Line 65 | Line 38 | struct prefs_node {
38   };
39  
40   // List of prefs nodes
41 < static prefs_node *the_prefs;
41 > static prefs_node *the_prefs = NULL;
42 >
43 > // Prototypes
44 > static prefs_desc *find_prefs_desc(const char *name);
45  
46  
47   /*
# Line 74 | Line 50 | static prefs_node *the_prefs;
50  
51   void PrefsInit(int argc, char **argv)
52   {
77 –        // Start with empty list
78 –        the_prefs = NULL;
79 –
53          // Set defaults
54 <        PrefsAddString("victype", "6569");
55 <        PrefsAddString("sidtype", "6581");
56 <        PrefsAddInt32("samplerate", 44100);
57 <        PrefsAddBool("audio16bit", true);
58 <        PrefsAddBool("stereo", true);
59 <        PrefsAddBool("filters", true);
60 <        PrefsAddBool("dualsid", false);
61 <        PrefsAddInt32("audioeffect", 2);
62 <        PrefsAddInt32("revdelay", 125);
63 <        PrefsAddInt32("revfeedback", 0x50);
64 <        PrefsAddInt32("volume", 0x100);
65 <        PrefsAddInt32("v1volume", 0x100);
66 <        PrefsAddInt32("v1pan", -0x40);
67 <        PrefsAddInt32("v2volume", 0x100);
68 <        PrefsAddInt32("v2pan", 0);
69 <        PrefsAddInt32("v3volume", 0x100);
70 <        PrefsAddInt32("v3pan", 0x40);
71 <        PrefsAddInt32("v4volume", 0x100);
72 <        PrefsAddInt32("v4pan", 0);
73 <        PrefsAddInt32("dualsep", 0x80);
74 <        PrefsAddInt32("replayfreq", 50);
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 >
65 >                // Find descriptor for keyword
66 >                const prefs_desc *d = find_prefs_desc(keyword);
67 >                bool negated_bool = false;
68 >                if (d == NULL) {
69 >                        // We also accept boolean arguments in the form '--nokeyword'
70 >                        if (strncmp(keyword, "no", 2) == 0) {
71 >                                negated_bool = true;
72 >                                keyword += 2;
73 >                                d = find_prefs_desc(keyword);
74 >                        }
75 >                        if (d == NULL) {
76 >                                printf("WARNING: Unrecognized argument '%s'\n", *argv);
77 >                                continue;
78 >                        }
79 >                }
80 >
81 >                // Add/replace prefs item
82 >                switch (d->type) {
83 >                        case TYPE_STRING:
84 >                                if (argc < 2) {
85 >                                        printf("WARNING: Argument '%s' must be followed by value\n", *argv);
86 >                                        break;
87 >                                }
88 >                                argc--; argv++;
89 >                                if (d->multiple)
90 >                                        PrefsAddString(keyword, *argv);
91 >                                else
92 >                                        PrefsReplaceString(keyword, *argv);
93 >                                break;
94 >
95 >                        case TYPE_BOOLEAN: {
96 >                                bool new_value;
97 >                                if (negated_bool)
98 >                                        new_value = false;
99 >                                else if (argc > 1 && argv[1][0] != '-') {
100 >                                        if (!strcmp(argv[1], "true") || !strcmp(argv[1], "on") || !strcmp(argv[1], "yes")) {
101 >                                                new_value = true;
102 >                                                argc--; argv++;
103 >                                        } else if (!strcmp(argv[1], "false") || !strcmp(argv[1], "off") || !strcmp(argv[1], "no")) {
104 >                                                new_value = false;
105 >                                                argc--; argv++;
106 >                                        } else
107 >                                                new_value = true;
108 >                                } else
109 >                                        new_value = true;
110 >                                PrefsReplaceBool(keyword, new_value);
111 >                                break;
112 >                        }
113 >
114 >                        case TYPE_INT32:
115 >                                if (argc < 2) {
116 >                                        printf("WARNING: Argument '%s' must be followed by value\n", *argv);
117 >                                        break;
118 >                                }
119 >                                argc--; argv++;
120 >                                PrefsReplaceInt32(keyword, atoi(*argv));
121 >                                break;
122 >
123 >                        default:
124 >                                break;
125 >                }
126 >        }
127   }
128  
129  
# Line 121 | Line 146 | void PrefsExit(void)
146  
147  
148   /*
149 + *  Print preferences options help
150 + */
151 +
152 + static void print_options(const prefs_desc *list)
153 + {
154 +        while (list->type != TYPE_END) {
155 +                if (list->help) {
156 +                        const char *typestr, *defstr;
157 +                        char numstr[32];
158 +                        switch (list->type) {
159 +                                case TYPE_STRING:
160 +                                        typestr = "STRING";
161 +                                        defstr = PrefsFindString(list->name);
162 +                                        if (defstr == NULL)
163 +                                                defstr = "none";
164 +                                        break;
165 +                                case TYPE_BOOLEAN:
166 +                                        typestr = "BOOL";
167 +                                        if (PrefsFindBool(list->name))
168 +                                                defstr = "true";
169 +                                        else
170 +                                                defstr = "false";
171 +                                        break;
172 +                                case TYPE_INT32:
173 +                                        typestr = "NUMBER";
174 +                                        sprintf(numstr, "%d", PrefsFindInt32(list->name));
175 +                                        defstr = numstr;
176 +                                        break;
177 +                                default:
178 +                                        typestr = "<unknown>";
179 +                                        defstr = "none";
180 +                                        break;
181 +                        }
182 +                        printf("  --%s %s\n    %s [default=%s]\n", list->name, typestr, list->help, defstr);
183 +                }
184 +                list++;
185 +        }
186 + }
187 +
188 + void PrefsPrintUsage(void)
189 + {
190 +        printf("\nGeneral options:\n");
191 +        print_options(common_prefs_items);
192 +        printf("\nBoolean options can be specified as '--OPTION true|on|yes' and\n'--OPTION false|off|no', or as '--OPTION' and '--noOPTION'.\n");
193 + }
194 +
195 +
196 + /*
197   *  Find preferences descriptor by keyword
198   */
199  
200   static prefs_desc *find_prefs_desc(const char *name, prefs_desc *list)
201   {
202 <        while (list->type != TYPE_ANY) {
202 >        while (list->type != TYPE_END) {
203                  if (strcmp(list->name, name) == 0)
204                          return list;
205                  list++;
# Line 134 | Line 207 | static prefs_desc *find_prefs_desc(const
207          return NULL;
208   }
209  
210 + static prefs_desc *find_prefs_desc(const char *name)
211 + {
212 +        return find_prefs_desc(name, common_prefs_items);
213 + }
214 +
215  
216   /*
217   *  Set prefs items
# Line 150 | Line 228 | static void add_data(const char *name, p
228          p->name = strdup(name);
229          p->type = type;
230          p->data = d;
231 <        p->desc = find_prefs_desc(p->name, prefs_items);
231 >        p->desc = find_prefs_desc(p->name);
232          if (the_prefs) {
233                  prefs_node *prev = the_prefs;
234                  while (prev->next)
# Line 297 | Line 375 | void PrefsRemoveItem(const char *name, i
375  
376   static void set_callback(const char *name, prefs_func f)
377   {
378 <        prefs_desc *d = find_prefs_desc(name, prefs_items);
378 >        prefs_desc *d = find_prefs_desc(name);
379          if (d == NULL)
380                  return;
381          d->func = f;

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines