/gpump/trunk

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/gpump/trunk

« back to all changes in this revision

Viewing changes to src/GPumpSettingsData.c

  • Committer: Gustav Hatvigsson
  • Date: 2014-04-18 21:29:00 UTC
  • Revision ID: gustav.hartvigsson@gmail.com-20140418212900-1rvb6v2n5r4tkz0p
*fixed a bunch of errors
* fixed function names
* much more

  TODO: 
    * add --debug option to use with g_debug ()

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/GPumpSettingsData.c
 
1
 
 
2
#include "GPumpSettingsData.h"
 
3
 
 
4
#define GPUMP_SETTINGS_DATA_GET_PRIVATE(obj)\
 
5
  (G_TYPE_INSTANCE_GET_PRIVATE ((obj), GPUMP_TYPE_SETTINGS_DATA,\
 
6
                                GPumpSettingsDataPrivate))
 
7
 
 
8
G_DEFINE_TYPE (GPumpSettingsData, gpump_settings_data, G_TYPE_OBJECT)
 
9
 
 
10
 
 
11
/* Private datastructure */
 
12
struct GPumpSettingsDataPrivate {
 
13
#if GPUMP_USE_GSETTINGS
 
14
  /* org.gego.gpump.ui */
 
15
  GSettings * ui_settings;
 
16
  /* org.gego.gpump */
 
17
  GSettings * gpump_settings;
 
18
#else
 
19
  GKeyFile * gpump_settings; /* Stores both UI and other settings... */
 
20
  GFile * gpump_settings_file;
 
21
#endif /* GPUMP_USE_GSETTINGS */
 
22
};
 
23
 
 
24
/* Properties enumeration */
 
25
enum {
 
26
  PROP_0,
 
27
  
 
28
  PROP_UI_X,
 
29
  PROP_UI_Y,
 
30
  PROP_UI_H,
 
31
  PROP_UI_W,
 
32
  
 
33
  PROP_MAIN_USE_DARK,
 
34
  PROP_MAIN_FIRST_RUN,
 
35
  
 
36
  N_PROPERTIES
 
37
};
 
38
 
 
39
static GParamSpec * obj_properties[N_PROPERTIES] = { NULL, };
 
40
 
 
41
 
 
42
 
 
43
/* * Override the default constructor and destructor **************************/
 
44
GObject * gpump_settings_data_construct (GType type,
 
45
                        guint n_construct_params,
 
46
                        GObjectConstructParam * construct_params);
 
47
 
 
48
void gpump_settings_data_dispose (GObject * object);
 
49
 
 
50
/* * internal private functions ***********************************************/
 
51
void _print_errors (GError ** err_arr);
 
52
 
 
53
void gpump_settings_data_set_property (GObject * object,
 
54
                                       guint property_id,
 
55
                                       const GValue * value,
 
56
                                       GParamSpec * pspec);
 
57
 
 
58
void gpump_settings_data_get_property (GObject * object,
 
59
                                       guint property_id,
 
60
                                       GValue * value,
 
61
                                       GParamSpec * pspec);
 
62
 
 
63
/* * **************************************************************************/
 
64
GPumpSettingsData * gpump_settings_data_get_default () {
 
65
  GPumpSettingsData * self = g_object_new (GPUMP_TYPE_SETTINGS_DATA,
 
66
                                           NULL);
 
67
  
 
68
  return self;
 
69
}
 
70
 
 
71
void gpump_settings_data_init (GPumpSettingsData * self) {
 
72
  g_print ("Init GPumpSettingsData\n");
 
73
  
 
74
  self->priv = GPUMP_SETTINGS_DATA_GET_PRIVATE (self);
 
75
  
 
76
#if GPUMP_USE_GSETTINGS
 
77
  /* This will not be compiled, this will have to be implemented later...
 
78
   * much later...
 
79
   */
 
80
  self->ui_settings = g_settings_new ("org.gego.gpump.ui");
 
81
  self->gpump_settings = g_settings_new ("org.gego.gpump");
 
82
#else
 
83
  
 
84
  /* Construct the path for the files, 1) the GPump settings 2) the GPump UI 
 
85
   * settings.
 
86
   *
 
87
   * The file names are defined static, so they do not need to be re-created,
 
88
   * each and every time to object is re-created.
 
89
   */
 
90
  self->priv->gpump_settings = g_key_file_new ();
 
91
  
 
92
  static gchar * gpump_settings_file_uri = NULL;
 
93
  static gchar * settings_basedir = NULL;
 
94
  
 
95
  if (!(gpump_settings_file_uri)) {
 
96
    
 
97
    g_print ("Constructing path!\n");
 
98
    
 
99
    const gchar * base_config_dir = g_get_user_config_dir ();
 
100
    
 
101
    settings_basedir = g_strdup_printf ("%s/%s",
 
102
                                                base_config_dir,
 
103
                                                "gpump");
 
104
    g_free ((gchar*)base_config_dir);
 
105
    
 
106
    gpump_settings_file_uri = g_strdup_printf ("%s/%s",
 
107
                                               settings_basedir,
 
108
                                               "gpump.conf");
 
109
  }
 
110
  
 
111
  self->priv->gpump_settings_file = g_file_new_for_path (
 
112
                                                      gpump_settings_file_uri);
 
113
  GError ** err_arr = NULL;
 
114
  /* Dose the file exist? */
 
115
  if (!g_file_test (gpump_settings_file_uri, G_FILE_TEST_EXISTS )) {
 
116
    /* Nope, it did not exist */
 
117
    g_debug ("Config file does not exist, creating it.\n");
 
118
    
 
119
    g_mkdir_with_parents (settings_basedir, 0700);
 
120
    
 
121
    GFileOutputStream * file_stream = g_file_create (
 
122
                                                self->priv->gpump_settings_file,
 
123
                                                G_FILE_CREATE_PRIVATE,
 
124
                                                NULL,
 
125
                                                err_arr);
 
126
    
 
127
    _print_errors (err_arr);
 
128
    
 
129
    /* Construct a set of default settings */
 
130
    
 
131
    /* UI settings */
 
132
    /* -1 is undefined, these are set when the main window is displayed */
 
133
    g_key_file_set_integer (self->priv->gpump_settings, "ui","x", -1);
 
134
    g_key_file_set_integer (self->priv->gpump_settings, "ui","y", -1);
 
135
    /* 500x500 is the default window size */
 
136
    g_key_file_set_integer (self->priv->gpump_settings, "ui","h", 500);
 
137
    g_key_file_set_integer (self->priv->gpump_settings, "ui","w", 500);
 
138
    /* main settings */
 
139
    g_key_file_set_boolean (self->priv->gpump_settings,
 
140
                            "main",
 
141
                            "use dark",
 
142
                            FALSE);
 
143
    g_key_file_set_boolean (self->priv->gpump_settings,
 
144
                            "main",
 
145
                            "first run",
 
146
                            TRUE);
 
147
    
 
148
    g_assert (err_arr == NULL);
 
149
    
 
150
    gchar * buff = g_key_file_to_data (self->priv->gpump_settings,
 
151
                                       NULL,
 
152
                                       err_arr);
 
153
    
 
154
    _print_errors (err_arr);
 
155
    
 
156
    g_output_stream_write (G_OUTPUT_STREAM (file_stream),
 
157
                           buff,
 
158
                           strlen (buff),
 
159
                           NULL,
 
160
                           err_arr);
 
161
    
 
162
    _print_errors (err_arr);
 
163
    
 
164
    g_object_unref (file_stream);
 
165
  } else {
 
166
    /* yes, the file did exit */
 
167
    
 
168
    g_debug ("Reading data from file:\n");
 
169
    g_key_file_load_from_file (self->priv->gpump_settings,
 
170
                               gpump_settings_file_uri,
 
171
                               G_KEY_FILE_NONE,
 
172
                               err_arr);
 
173
    g_debug ("%s\n", g_key_file_to_data (self->priv->gpump_settings,NULL, NULL));
 
174
    _print_errors (err_arr);
 
175
    
 
176
  }
 
177
#endif
 
178
}
 
179
 
 
180
 
 
181
void gpump_settings_data_class_init (GPumpSettingsDataClass * klass) {
 
182
  GObjectClass * parent = G_OBJECT_CLASS (klass);
 
183
  
 
184
  parent->constructor = gpump_settings_data_construct;
 
185
  parent->dispose = gpump_settings_data_dispose;
 
186
  
 
187
  parent->get_property = gpump_settings_data_get_property;
 
188
  parent->set_property = gpump_settings_data_set_property;
 
189
  
 
190
  obj_properties[PROP_UI_X] = g_param_spec_int ("ui-x",
 
191
                                                "UI-X",
 
192
                                              "The x coordinate of the window",
 
193
                                                -1,
 
194
                                                INT_MAX,
 
195
                                                -1,
 
196
                                                G_PARAM_READABLE |
 
197
                                                G_PARAM_WRITABLE);
 
198
  
 
199
  obj_properties[PROP_UI_Y] = g_param_spec_int ("ui-y",
 
200
                                                "UI-Y",
 
201
                                              "The Y coordinate of the window",
 
202
                                                -1,
 
203
                                                INT_MAX,
 
204
                                                -1,
 
205
                                                G_PARAM_READABLE |
 
206
                                                G_PARAM_WRITABLE);
 
207
  
 
208
  obj_properties[PROP_UI_H] = g_param_spec_int ("ui-h",
 
209
                                                "UI-h",
 
210
                                              "The x coordinate of the window",
 
211
                                                1,
 
212
                                                INT_MAX,
 
213
                                                500,
 
214
                                                G_PARAM_READABLE |
 
215
                                                G_PARAM_WRITABLE);
 
216
  
 
217
  obj_properties[PROP_UI_W] = g_param_spec_int ("ui-w",
 
218
                                                "UI-w",
 
219
                                              "The x coordinate of the window",
 
220
                                                1,
 
221
                                                INT_MAX,
 
222
                                                500,
 
223
                                                G_PARAM_READABLE |
 
224
                                                G_PARAM_WRITABLE);
 
225
  
 
226
  obj_properties[PROP_MAIN_USE_DARK] = g_param_spec_boolean ("main-use-dark",
 
227
                                                "MAIN-USE-DARK",
 
228
                                            "Weather or not to use dark theme.",
 
229
                                                FALSE,
 
230
                                                G_PARAM_READABLE |
 
231
                                                G_PARAM_WRITABLE);
 
232
  
 
233
  obj_properties[PROP_MAIN_FIRST_RUN] = g_param_spec_boolean ("main-use-dark",
 
234
                                                "MAIN-USE-DARK",
 
235
                   "Weather or not this is the first time that the app is run.",
 
236
                                                TRUE,
 
237
                                                G_PARAM_READABLE |
 
238
                                                G_PARAM_WRITABLE);
 
239
  
 
240
  g_object_class_install_properties (parent, N_PROPERTIES,
 
241
                                     obj_properties);
 
242
  
 
243
  g_type_class_add_private (klass, sizeof (GPumpSettingsDataPrivate));
 
244
}
 
245
 
 
246
void gpump_settings_data_set (GPumpSettingsData * self,
 
247
                              gchar * name,
 
248
                              GValue * data) {
 
249
  g_object_set_property (G_OBJECT (self),
 
250
                         name,
 
251
                         data);
 
252
}
 
253
 
 
254
 
 
255
GValue * gpump_settings_data_get (GPumpSettingsData * self,
 
256
                                    gchar * name) {
 
257
  GValue * data = NULL;
 
258
  g_object_set_property (G_OBJECT (self),
 
259
                         name,
 
260
                         data);
 
261
  return data;
 
262
}
 
263
 
 
264
 
 
265
gboolean gpump_settings_data_commit (GPumpSettingsData * self,
 
266
                                     GError ** err_arr) {
 
267
  g_object_ref (G_OBJECT(self));
 
268
#if GPUMP_USE_GSETTINGS
 
269
  /* Do thothing */
 
270
  return TRUE;
 
271
#else
 
272
  
 
273
  g_debug ("Committing data to file!\n");
 
274
  g_assert ( err_arr == NULL);
 
275
  
 
276
  GFileOutputStream * out_stream = g_file_replace (
 
277
                                                self->priv->gpump_settings_file,
 
278
                                                NULL,
 
279
                                                FALSE,
 
280
                                                G_FILE_CREATE_PRIVATE,
 
281
                                                NULL,
 
282
                                                err_arr);
 
283
  if (err_arr) {
 
284
    g_object_unref (out_stream);
 
285
    return FALSE;
 
286
  }
 
287
  
 
288
  gchar * buff = g_key_file_to_data (self->priv->gpump_settings, NULL, err_arr);
 
289
  
 
290
  if (err_arr) {
 
291
   g_object_unref (out_stream);
 
292
   g_free (buff);
 
293
   return FALSE;
 
294
  }
 
295
  gssize buff_size = strlen (buff);
 
296
  gssize out_size = g_output_stream_write (G_OUTPUT_STREAM (out_stream),
 
297
                         buff,
 
298
                         buff_size,
 
299
                         NULL,
 
300
                         err_arr);
 
301
  
 
302
  
 
303
  if (err_arr) {
 
304
    g_object_unref (out_stream);
 
305
    g_free (buff);
 
306
    return FALSE;
 
307
  }
 
308
  
 
309
  g_object_unref (out_stream);
 
310
  g_free (buff);
 
311
  
 
312
  g_debug ("Data commited: %i of %i bytes written!\n", (int)out_size, (int)buff_size);
 
313
  
 
314
  return TRUE;
 
315
#endif
 
316
  g_object_unref (G_OBJECT (self));
 
317
}
 
318
 
 
319
/* * **************************************************************************
 
320
 * * Implementation of the constructor ****************************************
 
321
 *
 
322
 * See: blogs.gnome.org/xclaesse/2010/02/11/how-to-make-a-gobject-singleton/
 
323
 * for more information.
 
324
 */
 
325
GObject *gpump_settings_data_construct (GType type,
 
326
                        guint n_construct_params,
 
327
                        GObjectConstructParam * construct_params) {
 
328
  static GObject * self = NULL;
 
329
  static GMutex mutex;
 
330
  
 
331
  g_mutex_lock (&mutex);
 
332
  if (self == NULL) {
 
333
    self = G_OBJECT_CLASS (gpump_settings_data_parent_class)->constructor (
 
334
      type, n_construct_params, construct_params);
 
335
    g_object_add_weak_pointer (self, (gpointer) &self);
 
336
    g_mutex_unlock (&mutex);
 
337
    return self;
 
338
  }
 
339
  g_mutex_unlock (&mutex);
 
340
  return g_object_ref (self);
 
341
}
 
342
 
 
343
/* Destructor */
 
344
void gpump_settings_data_dispose (GObject * object) {
 
345
  GPumpSettingsData * self  = GPUMP_SETTINGS_DATA (object);
 
346
#if GPUMP_USE_GSETTIGS
 
347
  /* do nothing, not implemented yet */
 
348
#else
 
349
  gpump_settings_data_commit (self, NULL);
 
350
  
 
351
  g_key_file_free (self->priv->gpump_settings);
 
352
  g_object_unref (G_OBJECT(self->priv->gpump_settings_file));
 
353
  
 
354
  
 
355
  G_OBJECT_CLASS (gpump_settings_data_parent_class)->dispose (object);
 
356
#endif
 
357
}
 
358
 
 
359
/* * Internal private functions ***********************************************/
 
360
void _print_errors (GError ** err_arr) {
 
361
  if (err_arr) {
 
362
    for (int i = 0; err_arr[i] != NULL; i++) {
 
363
       g_print ("GPumpSettingsData:\n An %s error occured:\n\t%s\n\n",
 
364
                 g_quark_to_string (err_arr[i]->domain),
 
365
                 err_arr[i]->message);
 
366
    }
 
367
    abort ();
 
368
  }
 
369
}
 
370
 
 
371
/* * **************************************************************************
 
372
 * * Getting and setting properties *******************************************
 
373
 * For more information see:
 
374
 * https://developer.gnome.org/gobject/stable/gobject-properties.html
 
375
 */
 
376
 
 
377
/* * declarations of setting functions */
 
378
void _set_ui_x (GPumpSettingsData * self,
 
379
                const GValue * value);
 
380
void _set_ui_y (GPumpSettingsData * self,
 
381
                const GValue * value);
 
382
void _set_ui_h (GPumpSettingsData * self,
 
383
                const GValue * value);
 
384
void _set_ui_w (GPumpSettingsData * self,
 
385
                const GValue * value);
 
386
 
 
387
void _set_main_use_dark (GPumpSettingsData * self,
 
388
                         const GValue * value);
 
389
void _set_main_first_run (GPumpSettingsData * self,
 
390
                          const GValue * value);
 
391
 
 
392
 
 
393
/* * declarations of getting functions */
 
394
void _get_ui_x (GPumpSettingsData * self,
 
395
                GValue * value);
 
396
void _get_ui_y (GPumpSettingsData * self,
 
397
                GValue * value);
 
398
void _get_ui_h (GPumpSettingsData * self,
 
399
                GValue * value);
 
400
void _get_ui_w (GPumpSettingsData * self,
 
401
                GValue * value);
 
402
 
 
403
void _get_main_use_dark (GPumpSettingsData * self,
 
404
                         GValue * value);
 
405
void _get_main_first_run (GPumpSettingsData * self,
 
406
                          GValue * value);
 
407
 
 
408
 
 
409
 
 
410
/* * Setting props */
 
411
void gpump_settings_data_set_property (GObject * object,
 
412
                                       guint property_id,
 
413
                                       const GValue * value,
 
414
                                       GParamSpec * pspec) {
 
415
  g_object_ref (object);
 
416
  
 
417
  GPumpSettingsData * self = GPUMP_SETTINGS_DATA (object);
 
418
  
 
419
  switch (property_id) {
 
420
    
 
421
    /* UI Props */
 
422
    case PROP_UI_X:
 
423
      _set_ui_x (self, value);
 
424
      break;
 
425
    case PROP_UI_Y:
 
426
      _set_ui_x (self, value);
 
427
      break;
 
428
    case PROP_UI_H:
 
429
      _set_ui_x (self, value);
 
430
      break;
 
431
    case PROP_UI_W:
 
432
      _set_ui_x (self, value);
 
433
      break;
 
434
    
 
435
    /* GPump generic props */
 
436
    case PROP_MAIN_USE_DARK:
 
437
      _set_main_use_dark (self, value);
 
438
      break;
 
439
    case PROP_MAIN_FIRST_RUN:
 
440
      _set_main_first_run (self, value);
 
441
      break;
 
442
    
 
443
    /* Default */
 
444
    default:
 
445
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
446
      break;
 
447
    
 
448
  }
 
449
  g_object_unref (object);
 
450
}
 
451
 
 
452
/* * Getting */
 
453
void gpump_settings_data_get_property (GObject * object,
 
454
                                       guint property_id,
 
455
                                       GValue * value,
 
456
                                       GParamSpec * pspec) {
 
457
  g_object_ref (object);
 
458
  
 
459
  GPumpSettingsData * self = GPUMP_SETTINGS_DATA (object);
 
460
  
 
461
  switch (property_id) {
 
462
    
 
463
    /* UI Props */
 
464
    case PROP_UI_X:
 
465
      _get_ui_x (self, value);
 
466
      break;
 
467
    case PROP_UI_Y:
 
468
      _get_ui_x (self, value);
 
469
      break;
 
470
    case PROP_UI_H:
 
471
      _get_ui_x (self, value);
 
472
      break;
 
473
    case PROP_UI_W:
 
474
      _get_ui_x (self, value);
 
475
      break;
 
476
    
 
477
    /* GPump generic props */
 
478
    case PROP_MAIN_USE_DARK:
 
479
      _get_main_use_dark (self, value);
 
480
      break;
 
481
    case PROP_MAIN_FIRST_RUN:
 
482
      _get_main_first_run (self, value);
 
483
      break;
 
484
    
 
485
    /* Default */
 
486
    default:
 
487
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 
488
      break;
 
489
    
 
490
  }
 
491
  g_object_unref (object);
 
492
}
 
493
 
 
494
 
 
495
/* * implimentations of setting functions *************************************/
 
496
void _set_ui_x (GPumpSettingsData * self,
 
497
                const GValue * value) {
 
498
#if GPUMP_USE_GSETTINGS
 
499
  /* TODO */
 
500
#else
 
501
  g_key_file_set_integer (self->priv->gpump_settings,
 
502
                          "ui",
 
503
                          "x",
 
504
                          g_value_get_int (value));
 
505
#endif
 
506
}
 
507
 
 
508
void _set_ui_y (GPumpSettingsData * self,
 
509
                const GValue * value) {
 
510
#if GPUMP_USE_GSETTINGS
 
511
  /* TODO */
 
512
#else
 
513
  g_key_file_set_integer (self->priv->gpump_settings,
 
514
                          "ui",
 
515
                          "y",
 
516
                          g_value_get_int (value));
 
517
#endif
 
518
}
 
519
 
 
520
void _set_ui_h (GPumpSettingsData * self,
 
521
                const GValue * value) {
 
522
#if GPUMP_USE_GSETTINGS
 
523
  /* TODO */
 
524
#else
 
525
  g_key_file_set_integer (self->priv->gpump_settings,
 
526
                          "ui",
 
527
                          "h",
 
528
                          g_value_get_int (value));
 
529
#endif
 
530
}
 
531
 
 
532
void _set_ui_w (GPumpSettingsData * self,
 
533
                const GValue * value) {
 
534
#if GPUMP_USE_GSETTINGS
 
535
  /* TODO */
 
536
#else
 
537
  g_key_file_set_integer (self->priv->gpump_settings,
 
538
                          "ui",
 
539
                          "w",
 
540
                          g_value_get_int (value));
 
541
#endif
 
542
}
 
543
 
 
544
void _set_main_use_dark (GPumpSettingsData * self,
 
545
                         const GValue * value) {
 
546
#if GPUMP_USE_GSETTINGS
 
547
  /* TODO */
 
548
#else
 
549
  g_key_file_set_integer (self->priv->gpump_settings,
 
550
                          "main",
 
551
                          "use dark",
 
552
                          g_value_get_boolean (value));
 
553
#endif
 
554
}
 
555
 
 
556
void _set_main_first_run (GPumpSettingsData * self,
 
557
                          const GValue * value)  {
 
558
#if GPUMP_USE_GSETTINGS
 
559
  /* TODO */
 
560
#else
 
561
  g_key_file_set_integer (self->priv->gpump_settings,
 
562
                          "main",
 
563
                          "first run",
 
564
                          g_value_get_boolean (value));
 
565
#endif
 
566
}
 
567
 
 
568
 
 
569
/* * implimentations of getting functions *************************************/
 
570
void _get_ui_x (GPumpSettingsData * self,
 
571
                GValue * value) {
 
572
#if GPUMP_USE_GSETTINGS
 
573
  /* TODO */
 
574
#else
 
575
  GError ** err_arr = NULL;
 
576
  g_value_set_int (value,
 
577
                   g_key_file_get_integer (self->priv->gpump_settings,
 
578
                                           "ui",
 
579
                                           "x",
 
580
                                           err_arr));
 
581
  _print_errors (err_arr);
 
582
  g_clear_error (err_arr);
 
583
#endif
 
584
}
 
585
 
 
586
void _get_ui_y (GPumpSettingsData * self,
 
587
                GValue * value) {
 
588
#if GPUMP_USE_GSETTINGS
 
589
  /* TODO */
 
590
#else
 
591
  GError ** err_arr = NULL;
 
592
  g_value_set_int (value,
 
593
                   g_key_file_get_integer (self->priv->gpump_settings,
 
594
                                           "ui",
 
595
                                           "y",
 
596
                                           err_arr));
 
597
  _print_errors (err_arr);
 
598
  g_clear_error (err_arr);
 
599
#endif
 
600
}
 
601
 
 
602
void _get_ui_h (GPumpSettingsData * self,
 
603
                GValue * value) {
 
604
#if GPUMP_USE_GSETTINGS
 
605
  /* TODO */
 
606
#else
 
607
  GError ** err_arr = NULL;
 
608
  g_value_set_int (value,
 
609
                   g_key_file_get_integer (self->priv->gpump_settings,
 
610
                                           "ui",
 
611
                                           "h",
 
612
                                           err_arr));
 
613
  _print_errors (err_arr);
 
614
  g_clear_error (err_arr);
 
615
#endif
 
616
}
 
617
 
 
618
void _get_ui_w (GPumpSettingsData * self,
 
619
                GValue * value) {
 
620
#if GPUMP_USE_GSETTINGS
 
621
  /* TODO */
 
622
#else
 
623
  GError ** err_arr = NULL;
 
624
  g_value_set_int (value,
 
625
                   g_key_file_get_integer (self->priv->gpump_settings,
 
626
                                           "ui",
 
627
                                           "w",
 
628
                                           err_arr));
 
629
  _print_errors (err_arr);
 
630
  g_clear_error (err_arr);
 
631
#endif
 
632
}
 
633
 
 
634
void _get_main_use_dark (GPumpSettingsData * self,
 
635
                         GValue * value) {
 
636
#if GPUMP_USE_GSETTINGS
 
637
  /* TODO */
 
638
#else
 
639
  GError ** err_arr = NULL;
 
640
  g_value_set_int (value,
 
641
                   g_key_file_get_integer (self->priv->gpump_settings,
 
642
                                           "main",
 
643
                                           "use dark",
 
644
                                           err_arr));
 
645
  _print_errors (err_arr);
 
646
  g_clear_error (err_arr);
 
647
#endif
 
648
}
 
649
 
 
650
void _get_main_first_run (GPumpSettingsData * self,
 
651
                          GValue * value)  {
 
652
#if GPUMP_USE_GSETTINGS
 
653
  /* TODO */
 
654
#else
 
655
  GError ** err_arr = NULL;
 
656
  g_value_set_int (value,
 
657
                   g_key_file_get_integer (self->priv->gpump_settings,
 
658
                                           "main",
 
659
                                           "first run",
 
660
                                           err_arr));
 
661
  _print_errors (err_arr);
 
662
  g_clear_error (err_arr);
 
663
#endif
 
664
}
 
665