← Back to branch summary

~compiz-team/compiz-libcompizconfig/0.9.5

« back to all changes in this revision

Viewing changes to src/ini.c

  • Committer: Sam Spilsbury
  • Date: 2011-07-29 15:10:33 UTC
  • mfrom: (412.1.3)
  • Revision ID: git-v1:21d23fe4074b65ff356bf24c51925ab48a70535c
Merge

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/ini.c
136
136
    free (sectionName);
137
137
}
138
138
 
 
139
Bool ccsIniParseString (char       *str,
 
140
                        char        **value)
 
141
{
 
142
     *value = strdup (str);
 
143
     return TRUE;
 
144
}
 
145
 
139
146
Bool
140
147
ccsIniGetString (IniDictionary *dictionary,
141
148
                 const char    *section,
147
154
    retValue = getIniString (dictionary, section, entry);
148
155
    if (retValue)
149
156
    {
150
 
        *value = strdup (retValue);
 
157
        ccsIniParseString (retValue, value);
151
158
        return TRUE;
152
159
    }
153
160
    else
155
162
}
156
163
 
157
164
Bool
 
165
ccsIniParseInt (const char *str,
 
166
                int        *value)
 
167
{
 
168
    *value = strtoul (str, NULL, 10);
 
169
    return TRUE;
 
170
}
 
171
 
 
172
Bool
158
173
ccsIniGetInt (IniDictionary *dictionary,
159
174
              const char    *section,
160
175
              const char    *entry,
165
180
    retValue = getIniString (dictionary, section, entry);
166
181
    if (retValue)
167
182
    {
168
 
        *value = strtoul (retValue, NULL, 10);
 
183
        ccsIniParseInt (retValue, value);
 
184
        return TRUE;
 
185
    }
 
186
    else
 
187
        return FALSE;
 
188
}
 
189
 
 
190
Bool
 
191
ccsIniParseFloat (const char  *str,
 
192
                  float       *value)
 
193
{
 
194
    if (str)
 
195
    {
 
196
        *value = (float) strtod (str, NULL);
169
197
        return TRUE;
170
198
    }
171
199
    else
178
206
                const char    *entry,
179
207
                float         *value)
180
208
{
181
 
    char *retValue;
182
 
 
183
 
    retValue = getIniString (dictionary, section, entry);
184
 
    if (retValue)
 
209
    char *retValue = getIniString (dictionary, section, entry);
 
210
 
 
211
    return ccsIniParseFloat (retValue, value);
 
212
}
 
213
 
 
214
Bool
 
215
ccsIniParseBool (const char  *str,
 
216
                 Bool        *value)
 
217
{
 
218
    if (str)
185
219
    {
186
 
        *value = (float) strtod (retValue, NULL);
 
220
        if ((str[0] == 't') || (str[0] == 'T') ||
 
221
            (str[0] == 'y') || (str[0] == 'Y') ||
 
222
            (str[0] == '1'))
 
223
        {
 
224
            *value = TRUE;
 
225
        }
 
226
        else
 
227
            *value = FALSE;
 
228
 
187
229
        return TRUE;
188
230
    }
189
231
    else
196
238
               const char    *entry,
197
239
               Bool          *value)
198
240
{
199
 
    char *retValue;
200
 
 
201
 
    retValue = getIniString (dictionary, section, entry);
202
 
    if (retValue)
203
 
    {
204
 
        if ((retValue[0] == 't') || (retValue[0] == 'T') ||
205
 
            (retValue[0] == 'y') || (retValue[0] == 'Y') ||
206
 
            (retValue[0] == '1'))
207
 
        {
208
 
            *value = TRUE;
209
 
        }
210
 
        else
211
 
            *value = FALSE;
212
 
 
 
241
    char *retValue = getIniString (dictionary, section, entry);
 
242
 
 
243
    return ccsIniParseBool (retValue, value);
 
244
}
 
245
 
 
246
Bool
 
247
ccsIniParseColor (const char           *str,
 
248
                  CCSSettingColorValue *value)
 
249
{
 
250
    if (str && ccsStringToColor (str, value))
213
251
        return TRUE;
214
 
    }
215
252
    else
216
253
        return FALSE;
217
254
}
222
259
                const char           *entry,
223
260
                CCSSettingColorValue *value)
224
261
{
225
 
    char *retValue;
226
 
 
227
 
    retValue = getIniString (dictionary, section, entry);
228
 
    if (retValue && ccsStringToColor (retValue, value))
229
 
        return TRUE;
230
 
    else
231
 
        return FALSE;
 
262
    char *retValue = getIniString (dictionary, section, entry);
 
263
 
 
264
    return ccsIniParseColor (retValue, value);
 
265
}
 
266
 
 
267
Bool
 
268
ccsIniParseKey (const char         *str,
 
269
                CCSSettingKeyValue *value)
 
270
{
 
271
    if (str)
 
272
        return ccsStringToKeyBinding (str, value);
 
273
 
 
274
    return FALSE;
232
275
}
233
276
 
234
277
Bool
237
280
              const char         *entry,
238
281
              CCSSettingKeyValue *value)
239
282
{
240
 
    char *retValue;
241
 
 
242
 
    retValue = getIniString (dictionary, section, entry);
243
 
    if (retValue)
244
 
        return ccsStringToKeyBinding (retValue, value);
 
283
    char *retValue = getIniString (dictionary, section, entry);
 
284
 
 
285
    return ccsIniParseKey (retValue, value);
 
286
}
 
287
 
 
288
Bool
 
289
ccsIniParseButton (const char            *str,
 
290
                   CCSSettingButtonValue *value)
 
291
{
 
292
    if (str)
 
293
        return ccsStringToButtonBinding (str, value);
245
294
    else
246
295
        return FALSE;
247
296
}
252
301
                 const char            *entry,
253
302
                 CCSSettingButtonValue *value)
254
303
{
255
 
    char *retValue;
256
 
 
257
 
    retValue = getIniString (dictionary, section, entry);
258
 
    if (retValue)
259
 
        return ccsStringToButtonBinding (retValue, value);
 
304
    char *retValue = getIniString (dictionary, section, entry);
 
305
 
 
306
    return ccsIniParseButton (retValue, value);
 
307
}
 
308
 
 
309
Bool
 
310
ccsIniParseEdge (const char   *str,
 
311
                 unsigned int *value)
 
312
{
 
313
    if (str)
 
314
    {
 
315
        *value = ccsStringToEdges (str);
 
316
        return TRUE;
 
317
    }
260
318
    else
261
319
        return FALSE;
262
320
}
267
325
                 const char   *entry,
268
326
                 unsigned int *value)
269
327
{
270
 
    char *retValue;
 
328
    char *retValue = getIniString (dictionary, section, entry);
271
329
 
272
 
    retValue = getIniString (dictionary, section, entry);
273
 
    if (retValue)
274
 
    {
275
 
        *value = ccsStringToEdges (retValue);
276
 
        return TRUE;
277
 
    }
278
 
    else
279
 
        return FALSE;
 
330
    return ccsIniParseEdge (retValue, value);
280
331
}
281
332
 
282
333
Bool
303
354
}
304
355
 
305
356
Bool
306
 
ccsIniGetList (IniDictionary       *dictionary,
307
 
               const char          *section,
308
 
               const char          *entry,
309
 
               CCSSettingValueList *value,
310
 
               CCSSetting          *parent)
 
357
ccsIniParseList (const char          *str,
 
358
                 CCSSettingValueList *value,
 
359
                 CCSSetting          *parent)
311
360
{
312
361
    CCSSettingValueList list = NULL;
313
 
    char                *valueString, *valueStart, *valString;
 
362
    char                *valueString, *valueStart;
314
363
    char                *token;
315
364
    int                 nItems = 1, i = 0, len;
316
365
 
317
 
    valString = getIniString (dictionary, section, entry);
318
 
    if (!valString)
319
 
        return FALSE;
320
 
 
321
 
    if (isEmptyString (valString))
322
 
    {
323
 
        *value = NULL;
324
 
        return TRUE;
325
 
    }
326
 
 
327
 
    valueString = strdup (valString);
 
366
    valueString = strdup (str);
328
367
    valueStart = valueString;
329
368
 
330
369
    /* remove trailing semicolon that we added to be able to differentiate
445
484
                val = malloc (sizeof (CCSSettingValue));
446
485
                if (!val)
447
486
                    break;
 
487
 
 
488
                val->refCount = 1;
 
489
 
448
490
                if (ccsStringToKeyBinding (token, &val->value.asKey))
449
491
                    list = ccsSettingValueListAppend (list, val);
450
492
                else
463
505
                val = malloc (sizeof (CCSSettingValue));
464
506
                if (!val)
465
507
                    break;
 
508
 
 
509
                val->refCount = 1;
 
510
 
466
511
                if (ccsStringToButtonBinding (token, &val->value.asButton))
467
512
                    list = ccsSettingValueListAppend (list, val);
468
513
                else
481
526
                val = malloc (sizeof (CCSSettingValue));
482
527
                if (!val)
483
528
                    break;
 
529
 
 
530
                val->refCount = 1;
 
531
 
484
532
                val->value.asEdge = ccsStringToEdges (token);
485
533
                list = ccsSettingValueListAppend (list, val);
486
534
                token = strsep (&valueString, ";");
504
552
                          token[0] == 't' || token[0] == 'T');
505
553
                
506
554
                val->value.asBell = isTrue;
 
555
                val->refCount = 1;
507
556
                list = ccsSettingValueListAppend (list, val);
508
557
                token = strsep (&valueString, ";");
509
558
            }
519
568
    return TRUE;
520
569
}
521
570
 
 
571
Bool
 
572
ccsIniGetList (IniDictionary       *dictionary,
 
573
               const char          *section,
 
574
               const char          *entry,
 
575
               CCSSettingValueList *value,
 
576
               CCSSetting          *parent)
 
577
{
 
578
    char *valString = getIniString (dictionary, section, entry);
 
579
    if (!valString)
 
580
        return FALSE;
 
581
 
 
582
    if (isEmptyString (valString))
 
583
    {
 
584
        *value = NULL;
 
585
        return TRUE;
 
586
    }
 
587
 
 
588
    return ccsIniParseList (valString, value, parent);
 
589
}
 
590
 
522
591
void
523
592
ccsIniSetString (IniDictionary * dictionary,
524
593
                 const char    * section,