← Back to branch summary

~foxtrotgps-team/foxtrotgps/trunk

« back to all changes in this revision

Viewing changes to src/init.c

  • Committer: Joshua Judson Rosen
  • Date: 2010-08-08 21:26:27 UTC
  • Revision ID: rozzin@geekspace.com-20100808212627-33l17je2wcdeza2n
Install & distribute the foxtrotgps(1) man page.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/init.c
12
12
#include <stdlib.h>
13
13
#include <stdio.h>
14
14
#include <gdk/gdk.h>
 
15
#include <gconf/gconf.h>
15
16
#include <math.h>
16
17
#include <time.h>
17
18
#include <errno.h>
25
26
#include "wp.h"
26
27
 
27
28
 
28
 
GSList *settings_get_repolist();
 
29
GSList *gconf_get_repolist();
29
30
void repoconfig__set_current_list_pointer();
30
31
void repoconfig__create_dropdown();
31
32
 
33
34
void
34
35
pre_init()
35
36
{
36
 
#if ! GLIB_CHECK_VERSION(2,35,0)
37
 
        /* Deprecated since 2.35.0. */
 
37
        GError  **err = NULL;
 
38
 
38
39
        g_type_init();
39
 
#endif
40
40
 
41
41
        trackpoint_list = g_queue_new();
42
42
 
43
43
        global_home_dir = getenv("HOME");
44
44
 
45
 
        global_settings = g_settings_new(SCHEMA);
46
 
        global_curr_reponame    = g_settings_get_string(global_settings, "repo-name");
 
45
        global_gconfclient      = gconf_client_get_default();
 
46
        global_curr_reponame    = gconf_client_get_string(global_gconfclient, GCONF"/repo_name",err);
47
47
 
48
48
 
49
49
        if(global_curr_reponame == NULL)
50
50
        {
51
 
                printf("repo_name setting not set\n");
 
51
                printf("gconf repo_name not set\n");
52
52
                global_curr_reponame = g_strdup("OSM");
53
53
        }
54
 
        settings_get_repolist();
 
54
        gconf_get_repolist();   
55
55
        repoconfig__set_current_list_pointer();
56
 
 
57
 
        global_x = g_settings_get_int(
58
 
                                global_settings,
59
 
                                "global-x");
60
 
        global_y = g_settings_get_int(
61
 
                                global_settings,
62
 
                                "global-y");
63
 
        global_zoom = g_settings_get_int(
64
 
                                global_settings,
65
 
                                "global-zoom");
66
 
        global_detail_zoom = g_settings_get_int (
67
 
                                global_settings,
68
 
                                "global-detail-zoom");
69
 
 
70
 
 
71
 
        if(global_zoom <= 2)
 
56
        
 
57
        global_x = gconf_client_get_int(
 
58
                                global_gconfclient, 
 
59
                                GCONF"/global_x",
 
60
                                err);
 
61
        global_y = gconf_client_get_int(
 
62
                                global_gconfclient, 
 
63
                                GCONF"/global_y",
 
64
                                err);
 
65
        global_zoom = gconf_client_get_int(
 
66
                                global_gconfclient, 
 
67
                                GCONF"/global_zoom",
 
68
                                err);
 
69
        global_detail_zoom = gconf_client_get_int (
 
70
                                global_gconfclient,
 
71
                                GCONF"/global_detail_zoom",
 
72
                                err);
 
73
 
 
74
 
 
75
        if(global_zoom <= 2) 
72
76
        {
73
77
                global_x = 890;
74
78
                global_y = 515;
76
80
        }
77
81
 
78
82
 
79
 
        global_server = g_settings_get_string (global_settings,
80
 
                                                 "gpsd-host");
 
83
        global_server = gconf_client_get_string (global_gconfclient,
 
84
                                                 GCONF "/gpsd_host",
 
85
                                                 err);
81
86
        if (global_server == NULL)
82
87
        {
83
 
                printf("GPSD address setting not set\n");
 
88
                printf("gconf GPSD address not set\n");
84
89
                global_server   = g_strdup("127.0.0.1");
85
90
        }
86
91
 
87
 
        global_port = g_settings_get_string (global_settings,
88
 
                                               "gpsd-port");
 
92
        global_port = gconf_client_get_string (global_gconfclient,
 
93
                                               GCONF "/gpsd_port",
 
94
                                               err);
89
95
        if (global_port == NULL)
90
96
        {
91
 
                printf("GPSD port setting not set\n");
 
97
                printf("gconf GPSD port not set\n");
92
98
                global_port     = g_strdup("2947");
93
99
        }
94
100
 
95
 
        global_no_redownload = g_settings_get_boolean(
96
 
                                global_settings,
97
 
                                "no-redownload");
98
 
 
99
 
        global_auto_download = g_settings_get_boolean(global_settings,
100
 
                                                     "auto-download");
 
101
        if(gconf_client_get_bool(global_gconfclient, GCONF"/started_before", err))      
 
102
                global_auto_download = gconf_client_get_bool(
 
103
                                        global_gconfclient, 
 
104
                                        GCONF"/auto_download",
 
105
                                        err);
 
106
        else
 
107
        {
 
108
                gconf_client_set_bool(global_gconfclient, GCONF"/started_before", TRUE, err);
 
109
                gconf_client_set_bool(global_gconfclient, GCONF"/auto_download", TRUE, err);
 
110
                global_auto_download = TRUE;
 
111
        }
101
112
}
102
113
 
103
114
void
104
115
init()
105
116
{
 
117
        gint timer;
 
118
        gpointer data = NULL;   
 
119
        
106
120
        GError  *err = NULL;
107
 
        const gchar *nick, *pass, *me_msg, *hrm_bt_addr;
 
121
        const gchar *nick, *pass, *me_msg;
108
122
        GtkWidget *widget;
109
123
        gchar buffer[128];
110
124
        gboolean gconf_fftimer_running;
111
125
        char *str = NULL;
112
 
 
113
 
 
 
126
        
 
127
        
114
128
        foxtrotgps_dir = g_strconcat(global_home_dir, "/." PACKAGE, NULL);
115
129
        g_mkdir(foxtrotgps_dir, 0700);
116
130
 
117
131
        repoconfig__create_dropdown();
118
132
 
119
 
 
120
 
 
121
 
 
122
 
        global_settings = g_settings_new(SCHEMA);
123
 
        nick                    = g_settings_get_string(global_settings, "nick");
124
 
        pass                    = g_settings_get_string(global_settings, "pass");
125
 
        me_msg                  = g_settings_get_string(global_settings, "me-msg");
126
 
        hrm_bt_addr             = g_settings_get_string(global_settings, "hrm-bt-addr");
127
 
 
128
 
        global_speed_unit       = g_settings_get_int(global_settings, "speed-unit");
129
 
        global_alt_unit         = g_settings_get_int(global_settings, "alt-unit");
130
 
        global_latlon_unit      = g_settings_get_int(global_settings, "latlon-unit");
131
 
 
132
 
        widget = lookup_widget(window1, "button3");
133
 
        gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(widget),
134
 
                                          global_autocenter);
135
 
 
136
 
        widget = lookup_widget(window1, "button56");
137
 
        gtk_toggle_tool_button_set_active(GTK_TOGGLE_TOOL_BUTTON(widget),
138
 
                                          global_autocenter);
139
 
 
 
133
        
 
134
 
 
135
 
 
136
        global_gconfclient      = gconf_client_get_default(); 
 
137
        nick                    = gconf_client_get_string(global_gconfclient, GCONF"/nick",&err);
 
138
        pass                    = gconf_client_get_string(global_gconfclient, GCONF"/pass",&err);
 
139
        me_msg                  = gconf_client_get_string(global_gconfclient, GCONF"/me_msg",&err);
 
140
        
 
141
        global_speed_unit       = gconf_client_get_int(global_gconfclient, GCONF"/speed_unit",&err);
 
142
        global_alt_unit         = gconf_client_get_int(global_gconfclient, GCONF"/alt_unit",&err);
 
143
        global_latlon_unit      = gconf_client_get_int(global_gconfclient, GCONF"/latlon_unit",&err);
 
144
        
140
145
        switch (global_speed_unit)
141
146
        {
142
147
                case 1:
148
153
                        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), TRUE);
149
154
                        break;
150
155
        }
151
 
 
 
156
        
152
157
        switch (global_alt_unit)
153
158
        {
154
159
                case 1:
156
161
                        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), TRUE);
157
162
                        break;
158
163
        }
159
 
 
 
164
        
160
165
        switch (global_latlon_unit)
161
166
        {
162
167
                case 1:
168
173
                        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), TRUE);
169
174
                        break;
170
175
        }
171
 
 
 
176
        
172
177
        widget  = lookup_widget(window1, "entry7");
173
178
        if(nick)
174
179
                gtk_entry_set_text( GTK_ENTRY(widget), nick );
178
183
        widget  = lookup_widget(window1, "entry29");
179
184
        if(me_msg)
180
185
                gtk_entry_set_text( GTK_ENTRY(widget), me_msg );
181
 
        widget  = lookup_widget(window1, "entry33");
182
 
        if(hrm_bt_addr)
183
 
                gtk_entry_set_text( GTK_ENTRY(widget), hrm_bt_addr );
184
 
 
185
 
 
 
186
 
 
187
        
186
188
        widget = lookup_widget(window1, "vscale1");
187
189
        gtk_range_set_value(GTK_RANGE(widget), (double) global_zoom);
188
 
 
189
 
        global_track_dir        = g_settings_get_string(global_settings, "track-dir");
 
190
        
 
191
        global_track_dir        = gconf_client_get_string(global_gconfclient, GCONF"/track_dir",&err);
190
192
        if(!global_track_dir)
191
193
                global_track_dir = g_strdup_printf("%s/Maps/",global_home_dir);
192
 
 
 
194
        
193
195
        global_myposition.lat = 0;
194
196
        global_myposition.lon = 0;
195
197
 
196
198
        widget = lookup_widget(window1, "checkbutton2");
197
199
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), global_auto_download);
198
200
 
199
 
        widget = glade_xml_get_widget (gladexml, "tile_redownload_toggle");
200
 
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),
201
 
                                     !global_no_redownload);
202
 
 
203
 
        hrm_on = g_settings_get_boolean(global_settings, "hrm-on");
204
 
        widget = lookup_widget(window1, "checkbutton18");
205
 
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), hrm_on);
206
 
 
207
 
        gconf_fftimer_running = FALSE;
208
 
 
209
 
        global_ffupdate_interval_minutes = g_settings_get_double(global_settings, "ffupdate-interval-minutes");
210
 
 
 
201
        
 
202
        
 
203
        
 
204
        
 
205
        
 
206
        gconf_fftimer_running = gconf_client_get_bool(global_gconfclient, GCONF"/fftimer_running",&err);
 
207
        
 
208
        
 
209
        global_ffupdate_interval_minutes = gconf_client_get_float(global_gconfclient, GCONF"/ffupdate_interval_minutes",&err);
 
210
        
211
211
        if(!global_ffupdate_interval_minutes)
212
212
                global_ffupdate_interval_minutes = 5;
213
 
 
 
213
        
214
214
        global_ffupdate_interval = global_ffupdate_interval_minutes * 60000;
215
215
 
216
216
        if (global_ffupdate_interval_minutes<5)
219
219
                g_sprintf(buffer, "%.0f", global_ffupdate_interval_minutes);
220
220
 
221
221
        widget = lookup_widget(window1, "entry16");
222
 
        // gtk_entry_set_text( GTK_ENTRY(widget), buffer );
 
222
        gtk_entry_set_text( GTK_ENTRY(widget), buffer );
 
223
        
223
224
 
 
225
        
224
226
        if(gconf_fftimer_running)
225
227
        {
226
228
                widget = lookup_widget(menu1, "item19");
227
229
                gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widget), TRUE);
228
230
        }
229
 
 
230
 
 
231
 
 
232
 
        str = g_settings_get_string(global_settings, "gpsd-host");
 
231
                
 
232
        
 
233
 
 
234
        str = gconf_client_get_string(global_gconfclient, GCONF"/gpsd_host",&err);
233
235
        widget = lookup_widget(window1, "entry3");
234
236
        if(str)
235
237
                gtk_entry_set_text(GTK_ENTRY(widget), g_strdup(str));
236
238
        g_free(str);
237
 
 
238
 
        str = g_settings_get_string(global_settings, "gpsd-port");
 
239
        
 
240
        str = gconf_client_get_string(global_gconfclient, GCONF"/gpsd_port",&err);
239
241
        widget = lookup_widget(window1, "entry4");
240
242
        if(str)
241
243
                gtk_entry_set_text(GTK_ENTRY(widget), g_strdup(str));
242
244
        g_free(str);
243
 
 
244
 
        if (g_settings_get_boolean(global_settings, "tracklog-on")) {
 
245
        
 
246
        if (gconf_client_get_bool(global_gconfclient, GCONF"/tracklog_on", NULL)) {
245
247
                widget = lookup_widget(window1, "checkbutton17");
246
248
                gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), TRUE);
247
249
        }
248
 
 
249
 
        get_gps ();
250
 
 
 
250
        
 
251
        timer = g_timeout_add (1000,cb_gps_timer,data);
 
252
        
251
253
        gtk_window_set_icon_from_file(GTK_WINDOW(window1), PACKAGE_PIXMAPS_DIR "/" PACKAGE ".png" ,&err);
252
254
        if (err)
253
255
        {
254
 
                fprintf (stderr, _("Failed to load pixbuf file: %s\n"),
255
 
                         err->message);
 
256
                fprintf (stderr, "Failed to load pixbuf file:  %s\n", err->message);
256
257
                g_error_free (err);
257
258
        }
258
 
 
259
 
 
260
 
        global_myposition.lat = g_settings_get_double(global_settings, "myposition-lat");
261
 
        global_myposition.lon = g_settings_get_double(global_settings, "myposition-lon");
 
259
        
 
260
        
 
261
        global_myposition.lat = gconf_client_get_float(global_gconfclient, GCONF"/myposition_lat", NULL);
 
262
        global_myposition.lon = gconf_client_get_float(global_gconfclient, GCONF"/myposition_lon", NULL);
262
263
        paint_myposition();
263
264
}
264
265
 
265
266
GSList *
266
 
settings_get_repolist()
 
267
gconf_get_repolist()
267
268
{
268
 
        gchar  **repo_list;
269
 
 
270
 
 
271
 
        repo_list = g_settings_get_strv(        global_settings,
272
 
                                                "repos");
273
 
 
274
 
        if (repo_list == NULL || repo_list[0] == NULL)
 
269
        GSList  *repo_list;
 
270
        
 
271
        GSList  *list;
 
272
        GError **error = NULL;
 
273
        
 
274
        
 
275
        repo_list = gconf_client_get_list(      global_gconfclient, 
 
276
                                                GCONF"/repos",
 
277
                                                GCONF_VALUE_STRING,
 
278
                                                error);
 
279
        
 
280
        if (repo_list == NULL)
275
281
        {
276
282
                repo_t *repo1 = g_new0(repo_t, 1);
277
283
                repo_t *repo2 = g_new0(repo_t, 1);
279
285
                repo_t *repo4 = g_new0(repo_t, 1);
280
286
                repo_t *repo5 = g_new0(repo_t, 1);
281
287
 
282
 
 
 
288
                
283
289
                printf("REPOLIST == NULL\n");
284
 
 
 
290
                
285
291
                repo1->name = g_strdup("OSM");
286
 
                repo1->uri  = g_strdup("https://tile.openstreetmap.org/%d/%d/%d.png");
 
292
                repo1->uri  = g_strdup("http://tile.openstreetmap.org/%d/%d/%d.png");
287
293
                repo1->dir  = g_strdup_printf("%s/Maps/OSM",global_home_dir);
288
294
                repo1->inverted_zoom = 0;
289
295
                global_repo_list = g_slist_append(global_repo_list, repo1);
293
299
                repo2->dir  = g_strdup_printf("%s/Maps/maps4free",global_home_dir);
294
300
                repo2->inverted_zoom = 0;
295
301
                global_repo_list = g_slist_append(global_repo_list, repo2);
296
 
 
297
 
                repo3->name = g_strdup("OpenCycleMap");
298
 
                repo3->uri  = g_strdup("http://tile.opencyclemap.org/cycle/%d/%d/%d.png");
 
302
                                
 
303
                repo3->name = g_strdup("Opencyclemap");
 
304
                repo3->uri  = g_strdup("http://a.andy.sandbox.cloudmade.com/tiles/cycle/%d/%d/%d.png");
299
305
                repo3->dir  = g_strdup_printf("%s/Maps/opencyclemap",global_home_dir);
300
306
                repo3->inverted_zoom = 0;
301
307
                global_repo_list = g_slist_append(global_repo_list, repo3);
302
308
 
303
309
                repo4->name = g_strdup("Google Maps (testing only)");
304
 
                repo4->uri  = g_strdup("https://mt0.google.com/vt/lyrs=m&hl=en&x=%d&y=%d&z=%d");
 
310
                repo4->uri  = g_strdup("http://mt0.google.com/vt/hl=en&x=%d&y=%d&z=%d");
305
311
                repo4->dir  = g_strdup_printf("%s/Maps/googlemaps",global_home_dir);
306
312
                repo4->inverted_zoom = 1;
307
313
                global_repo_list = g_slist_append(global_repo_list, repo4);
308
314
 
309
315
                repo5->name = g_strdup("Google Sat (testing only)");
310
 
                repo5->uri  = g_strdup("https://mt0.google.com/vt/lyrs=s&hl=en&x=%d&y=%d&z=%d");
 
316
                repo5->uri  = g_strdup("http://khm.google.com/kh/v=53&x=%d&y=%d&z=%d");
311
317
                repo5->dir  = g_strdup_printf("%s/Maps/googlesat",global_home_dir);
312
318
                repo5->inverted_zoom = 1;
313
319
                global_repo_list = g_slist_append(global_repo_list, repo5);
314
320
 
315
321
 
316
322
        }
317
 
 
318
 
 
319
 
        for(gint i = 0; repo_list[i] != NULL; i++)
 
323
        
 
324
        
 
325
        for(list = repo_list; list != NULL; list = list->next)
320
326
        {
321
327
                gchar **array;
322
 
                gchar *str = repo_list[i];
 
328
                gchar *str = list->data;
323
329
                repo_t *repo = g_new0(repo_t, 1);
324
 
 
325
 
                array = g_strsplit(str,"|",4);
326
 
 
 
330
                
 
331
                array = g_strsplit(str,"|",4);  
 
332
                
327
333
                repo->name = g_strdup(array[0]);
328
334
                repo->uri  = g_strdup(array[1]);
329
335
                repo->dir  = g_strdup(array[2]);
330
336
                repo->inverted_zoom = (atoi(g_strdup(array[3])) == 1) ? TRUE : FALSE;
331
 
 
 
337
                
332
338
                global_repo_list = g_slist_append(global_repo_list, repo);
 
339
 
 
340
                printf("GCONF: \n -- name: %s \n -- uri: %s \n -- dir: %s \n",
 
341
                        repo->name, repo->uri, repo->dir);
333
342
        }
334
 
 
335
 
 
336
 
        g_strfreev (repo_list);
337
 
 
338
 
        return global_repo_list;
339
 
 
 
343
        
 
344
        
 
345
        return global_repo_list;        
 
346
                                        
340
347
}
341
348
 
342
349
void
343
 
settings_set_repolist()
 
350
gconf_set_repolist()
344
351
{
345
 
 
346
 
        GSList    *list;
347
 
        GPtrArray *setting_list = NULL;
 
352
        
 
353
        GSList  *list;
 
354
        GSList  *gconf_list = NULL;
 
355
        GError **error = NULL;
348
356
        gboolean success = FALSE;
349
 
 
350
 
 
351
 
 
352
 
        setting_list = g_ptr_array_new ();
353
 
 
 
357
        
 
358
        
 
359
        
354
360
        for(list = global_repo_list; list != NULL; list = list->next)
355
361
        {
356
362
                repo_t *repo;
357
 
                gchar setting_str[1024];
358
 
 
 
363
                gchar gconf_str[1024];
 
364
                
359
365
                repo = list->data;
360
 
 
361
 
 
362
 
                g_sprintf(      setting_str,
 
366
                
 
367
                
 
368
                g_sprintf(      gconf_str, 
363
369
                                "%s|%s|%s|%i",
364
370
                                repo->name, repo->uri, repo->dir, repo->inverted_zoom);
 
371
                
 
372
                gconf_list = g_slist_append(gconf_list, g_strdup(gconf_str));
365
373
 
366
 
                g_ptr_array_add(setting_list, (gpointer) g_strdup(setting_str));
 
374
                printf("GCONFSAVE: \n -- name: %s \n -- uri: %s \n -- dir: %s \n -- zoom: %i \n\n %s \n",
 
375
                        repo->name, repo->uri, repo->dir, repo->inverted_zoom, gconf_str);
367
376
        }
368
 
 
369
 
        g_ptr_array_add(setting_list, NULL);
370
 
 
371
 
        success = g_settings_set_strv(  global_settings,
372
 
                                                "repos",
373
 
                                                (const gchar * const *) setting_list->pdata);
374
 
 
375
 
        g_strfreev((gchar **) setting_list->pdata);
376
 
        g_ptr_array_free (setting_list, FALSE);
 
377
        
 
378
        success = gconf_client_set_list(        global_gconfclient, 
 
379
                                                GCONF"/repos",
 
380
                                                GCONF_VALUE_STRING,
 
381
                                                gconf_list,
 
382
                                                error);
 
383
        
 
384
        printf("*** %s(): %i \n",__PRETTY_FUNCTION__, success);
 
385
 
377
386
}
378
387
 
379
388
 
381
390
void
382
391
repoconfig__set_current_list_pointer()
383
392
{
384
 
 
385
 
 
 
393
        
 
394
        
386
395
        GSList          *list;
387
396
        const gchar     *reponame;
388
397
        int unused;
389
 
 
 
398
        
390
399
        for(list = global_repo_list; list != NULL; list = list->next)
391
400
        {
392
401
                repo_t *repo;
393
402
                repo    = list->data;
394
 
 
 
403
                
395
404
                reponame = g_strdup(repo->name);
396
 
 
 
405
                
397
406
                if(     g_strrstr(reponame,global_curr_reponame) != NULL &&
398
 
                        strlen(reponame) == strlen(global_curr_reponame)
 
407
                        strlen(reponame) == strlen(global_curr_reponame)        
399
408
                )
400
409
                        global_curr_repo = list;
401
410
        }
402
411
        if(!global_curr_repo)
403
412
        {
404
413
                printf("\n#\n#\n#  ERROR: repository %s is broken \n#\n#\n", global_curr_reponame);
405
 
 
 
414
                
406
415
                printf("Resetting repo_name and exiting now.\n\n");
407
416
                printf("If problem persists after restart, \n");
408
 
                printf("execute in a terminal: gsettings reset " SCHEMA " repos\n");
409
 
                unused = system("gsettings reset " SCHEMA " repo_name");
410
 
                exit(EXIT_FAILURE);
 
417
                printf("execute in a terminal: gconftool-2 -u " GCONF "/repos\n");
 
418
                unused = system("gconftool-2 -u " GCONF "/repo_name");
 
419
                exit(EXIT_FAILURE);             
411
420
        }
412
421
}
413
422
 
420
429
        int             i = 0;
421
430
        int             j = 0;
422
431
        const gchar     *reponame;
423
 
 
 
432
        
424
433
        combobox = lookup_widget(window1, "combobox1");
425
434
 
426
435
        for(list = global_repo_list; list != NULL; list = list->next)
427
436
        {
428
437
                repo_t  *repo;
429
 
 
 
438
                
430
439
                repo = list->data;
431
440
                reponame = g_strdup(repo->name);
432
441
                gtk_combo_box_append_text (GTK_COMBO_BOX(combobox), g_strdup(repo->name));
433
 
 
 
442
                
434
443
                if(     g_strrstr(reponame,global_curr_reponame) != NULL &&
435
 
                        strlen(reponame) == strlen(global_curr_reponame)
 
444
                        strlen(reponame) == strlen(global_curr_reponame)        
436
445
                )
437
446
                {
438
447
                        j = i;