← Back to branch summary

~ubuntu-branches/ubuntu/saucy/darktable/saucy

« back to all changes in this revision

Viewing changes to src/control/conf.h

  • Committer: Bazaar Package Importer
  • Author(s): David Bremner
  • Date: 2011-07-12 09:36:46 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20110712093646-yp9dbxan44dmw15h
Tags: 0.9-1
* New upstream release.
* Remove all patches now upstream; only patch for
  -Wno-error=unused-but-set-variable remains.
* Bump Standards-Version to 3.9.2 (no changes)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/control/conf.h
39
39
 
40
40
typedef struct dt_conf_t
41
41
{
 
42
  dt_pthread_mutex_t mutex;
42
43
#ifdef HAVE_GCONF
43
44
  GConfClient *gconf;
44
45
#else
45
46
  char filename[1024];
46
 
  dt_pthread_mutex_t mutex;
47
47
  int  num;
48
48
  char varname[DT_CONF_MAX_VARS][DT_CONF_MAX_VAR_BUF];
49
49
  char varval [DT_CONF_MAX_VARS][DT_CONF_MAX_VAR_BUF];
68
68
 
69
69
static inline void dt_conf_set_int(const char *name, int val)
70
70
{
 
71
  dt_pthread_mutex_lock(&darktable.conf->mutex);
71
72
#ifdef HAVE_GCONF
72
73
  char var[1024];
73
74
  snprintf(var, 1024, "%s/%s", DT_GCONF_DIR, name);
74
75
  gconf_client_set_int (darktable.conf->gconf, var, val, NULL);
75
76
#else
76
 
  dt_pthread_mutex_lock(&darktable.conf->mutex);
77
77
  const int num = dt_conf_get_var_pos(name);
78
78
  snprintf(darktable.conf->varval[num], DT_CONF_MAX_VAR_BUF, "%d", val);
 
79
#endif
79
80
  dt_pthread_mutex_unlock(&darktable.conf->mutex);
80
 
#endif
81
81
}
82
82
 
83
83
static inline void dt_conf_set_float(const char *name, float val)
84
84
{
 
85
  dt_pthread_mutex_lock(&darktable.conf->mutex);
85
86
#ifdef HAVE_GCONF
86
87
  char var[1024];
87
88
  snprintf(var, 1024, "%s/%s", DT_GCONF_DIR, name);
88
89
  gconf_client_set_float (darktable.conf->gconf, var, val, NULL);
89
90
#else
90
 
  dt_pthread_mutex_lock(&darktable.conf->mutex);
91
91
  const int num = dt_conf_get_var_pos(name);
92
92
  snprintf(darktable.conf->varval[num], DT_CONF_MAX_VAR_BUF, "%f", val);
 
93
#endif
93
94
  dt_pthread_mutex_unlock(&darktable.conf->mutex);
94
 
#endif
95
95
}
96
96
 
97
97
static inline void dt_conf_set_bool(const char *name, int val)
98
98
{
 
99
  dt_pthread_mutex_lock(&darktable.conf->mutex);
99
100
#ifdef HAVE_GCONF
100
101
  char var[1024];
101
102
  snprintf(var, 1024, "%s/%s", DT_GCONF_DIR, name);
102
103
  gconf_client_set_bool (darktable.conf->gconf, var, val, NULL);
103
104
#else
104
 
  dt_pthread_mutex_lock(&darktable.conf->mutex);
105
105
  const int num = dt_conf_get_var_pos(name);
106
106
  snprintf(darktable.conf->varval[num], DT_CONF_MAX_VAR_BUF, "%s", val ? "TRUE" : "FALSE");
 
107
#endif
107
108
  dt_pthread_mutex_unlock(&darktable.conf->mutex);
108
 
#endif
109
109
}
110
110
 
111
111
static inline void dt_conf_set_string(const char *name, const char *val)
112
112
{
 
113
  dt_pthread_mutex_lock(&darktable.conf->mutex);
113
114
#ifdef HAVE_GCONF
114
115
  char var[1024];
115
116
  snprintf(var, 1024, "%s/%s", DT_GCONF_DIR, name);
116
117
  gconf_client_set_string (darktable.conf->gconf, var, val, NULL);
117
118
#else
118
 
  dt_pthread_mutex_lock(&darktable.conf->mutex);
119
119
  const int num = dt_conf_get_var_pos(name);
120
120
  snprintf(darktable.conf->varval[num], DT_CONF_MAX_VAR_BUF, "%s", val);
 
121
#endif
121
122
  dt_pthread_mutex_unlock(&darktable.conf->mutex);
122
 
#endif
123
123
}
124
124
 
125
125
static inline int dt_conf_get_int(const char *name)
126
126
{
 
127
  dt_pthread_mutex_lock(&darktable.conf->mutex);
127
128
#ifdef HAVE_GCONF
128
129
  char var[1024];
129
130
  snprintf(var, 1024, "%s/%s", DT_GCONF_DIR, name);
 
131
  dt_pthread_mutex_unlock(&darktable.conf->mutex);
130
132
  return gconf_client_get_int (darktable.conf->gconf, var, NULL);
131
133
#else
132
 
  dt_pthread_mutex_lock(&darktable.conf->mutex);
133
134
  const int num = dt_conf_get_var_pos(name);
134
135
  const int val = atol(darktable.conf->varval[num]);
135
136
  dt_pthread_mutex_unlock(&darktable.conf->mutex);
139
140
 
140
141
static inline float dt_conf_get_float(const char *name)
141
142
{
 
143
  dt_pthread_mutex_lock(&darktable.conf->mutex);
142
144
#ifdef HAVE_GCONF
143
145
  char var[1024];
144
146
  snprintf(var, 1024, "%s/%s", DT_GCONF_DIR, name);
 
147
  dt_pthread_mutex_unlock(&darktable.conf->mutex);
145
148
  return gconf_client_get_float (darktable.conf->gconf, var, NULL);
146
149
#else
147
 
  dt_pthread_mutex_lock(&darktable.conf->mutex);
148
150
  const int num = dt_conf_get_var_pos(name);
149
151
  const float val = atof(darktable.conf->varval[num]);
150
152
  dt_pthread_mutex_unlock(&darktable.conf->mutex);
154
156
 
155
157
static inline int dt_conf_get_bool(const char *name)
156
158
{
 
159
  dt_pthread_mutex_lock(&darktable.conf->mutex);
157
160
#ifdef HAVE_GCONF
158
161
  char var[1024];
159
162
  snprintf(var, 1024, "%s/%s", DT_GCONF_DIR, name);
 
163
  dt_pthread_mutex_unlock(&darktable.conf->mutex);
160
164
  return gconf_client_get_bool (darktable.conf->gconf, var, NULL);
161
165
#else
162
 
  dt_pthread_mutex_lock(&darktable.conf->mutex);
163
166
  const int num = dt_conf_get_var_pos(name);
164
167
  const int val = darktable.conf->varval[num][0] == 'T';
165
168
  dt_pthread_mutex_unlock(&darktable.conf->mutex);
169
172
 
170
173
static inline gchar *dt_conf_get_string(const char *name)
171
174
{
 
175
  dt_pthread_mutex_lock(&darktable.conf->mutex);
172
176
#ifdef HAVE_GCONF
173
177
  char var[1024];
174
178
  snprintf(var, 1024, "%s/%s", DT_GCONF_DIR, name);
 
179
  dt_pthread_mutex_unlock(&darktable.conf->mutex);
175
180
  return gconf_client_get_string (darktable.conf->gconf, var, NULL);
176
181
#else
177
 
  dt_pthread_mutex_lock(&darktable.conf->mutex);
178
182
  const int num = dt_conf_get_var_pos(name);
179
183
  dt_pthread_mutex_unlock(&darktable.conf->mutex);
180
184
  return g_strdup(darktable.conf->varval[num]);
192
196
{
193
197
  GSList *result = NULL;
194
198
 
 
199
  dt_pthread_mutex_lock(&darktable.conf->mutex);
195
200
#ifdef HAVE_GCONF
196
201
  char var[1024];
197
202
  snprintf (var, 1024, "%s/%s", DT_GCONF_DIR, dir);
222
227
    while ((item=g_slist_next (item))!=NULL);
223
228
 
224
229
#else
225
 
  dt_pthread_mutex_lock(&darktable.conf->mutex);
226
230
  for (int i=0; i<DT_CONF_MAX_VARS; i++)
227
231
  {
228
232
    if (strcmp(darktable.conf->varname[i],dir)==0)
241
245
      result = g_slist_append (result,nv);
242
246
    }
243
247
  }
244
 
  dt_pthread_mutex_unlock(&darktable.conf->mutex);
245
248
 
246
249
#endif
 
250
  dt_pthread_mutex_unlock(&darktable.conf->mutex);
247
251
  return result;
248
252
}
249
253
 
250
254
static inline void dt_conf_init(dt_conf_t *cf, const char *filename)
251
255
{
 
256
  dt_pthread_mutex_init(&darktable.conf->mutex, NULL);
252
257
#ifdef HAVE_GCONF
253
258
  g_type_init();
254
259
  cf->gconf = gconf_client_get_default();
256
261
#else
257
262
  memset(cf->varname,0, DT_CONF_MAX_VARS*DT_CONF_MAX_VAR_BUF);
258
263
  memset(cf->varval, 0, DT_CONF_MAX_VARS*DT_CONF_MAX_VAR_BUF);
259
 
  dt_pthread_mutex_init(&darktable.conf->mutex, NULL);
260
264
  snprintf(darktable.conf->filename, 1024, "%s", filename);
261
265
  darktable.conf->num = 0;
262
266
  FILE *f = fopen(filename, "rb");
298
302
    fprintf(f, "%s=%s\n", cf->varname[i], cf->varval[i]);
299
303
  }
300
304
  fclose(f);
 
305
#endif
301
306
  dt_pthread_mutex_destroy(&darktable.conf->mutex);
302
 
#endif
303
307
}
304
308
 
305
309
/** check if key exists, return 1 if lookup successed, 0 if failed..*/
306
310
static inline int dt_conf_key_exists (const char *key)
307
311
{
 
312
  dt_pthread_mutex_lock (&darktable.conf->mutex);
308
313
  int res = 0;
309
314
#ifdef HAVE_GCONF
310
315
  GError *error=NULL;
312
317
  if( value != NULL && error == NULL ) res = 1;
313
318
#else
314
319
  /* lookup in stringtable for match of key name */
315
 
  dt_pthread_mutex_lock (&darktable.conf->mutex);
316
320
  for (int i=0; i<darktable.conf->num; i++)
317
321
  {
318
322
    if (!strncmp (key, darktable.conf->varname[i], DT_CONF_MAX_VAR_BUF))
321
325
      break;
322
326
    }
323
327
  }
 
328
#endif
324
329
  dt_pthread_mutex_unlock (&darktable.conf->mutex);
325
 
#endif
326
330
  return res;
327
331
}
328
332