Diff of /trunk/src/main.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 15 by harbaum, Tue Dec 16 17:00:20 2008 UTC revision 189 by harbaum, Mon Jul 6 15:51:30 2009 UTC
# Line 1  Line 1 
1  /*  /*
2     * Copyright (C) 2008 Till Harbaum <till@harbaum.org>.
3     *
4   * This file is part of OSM2Go.   * This file is part of OSM2Go.
5   *   *
6   * OSM2Go is free software: you can redistribute it and/or modify   * OSM2Go is free software: you can redistribute it and/or modify
# Line 19  Line 21 
21  #include <string.h>  #include <string.h>
22    
23  #include <curl/curl.h>  #include <curl/curl.h>
24    #include <gdk/gdkkeysyms.h>
25    
26    #if defined(USE_HILDON) && (MAEMO_VERSION_MAJOR == 5)
27    #include <hildon/hildon-button.h>
28    #include <hildon/hildon-check-button.h>
29    #include <hildon/hildon-window-stack.h>
30    #endif
31    
32  #include "appdata.h"  #include "appdata.h"
33    #include "banner.h"
34    
35  /* disable/enable main screen control dependant on presence of open project */  /* disable/enable main screen control dependant on presence of open project */
36  static void main_ui_enable(appdata_t *appdata) {  static void main_ui_enable(appdata_t *appdata) {
# Line 32  static void main_ui_enable(appdata_t *ap Line 42  static void main_ui_enable(appdata_t *ap
42      map_action_cancel(appdata);      map_action_cancel(appdata);
43    
44    /* ---- set project name as window title ----- */    /* ---- set project name as window title ----- */
45  #ifndef USE_HILDON  #if defined(USE_HILDON) && MAEMO_VERSION_MAJOR < 5
46      if(project_valid)
47        gtk_window_set_title(GTK_WINDOW(appdata->window), appdata->project->name);
48      else
49        gtk_window_set_title(GTK_WINDOW(appdata->window), "");
50    #else
51    char *str = NULL;    char *str = NULL;
52    if(project_valid)    if(project_valid)
53      str = g_strdup_printf("OSM2Go - %s", appdata->project->name);      str = g_strdup_printf("OSM2Go - %s", appdata->project->name);
# Line 41  static void main_ui_enable(appdata_t *ap Line 56  static void main_ui_enable(appdata_t *ap
56    
57    gtk_window_set_title(GTK_WINDOW(appdata->window), str);    gtk_window_set_title(GTK_WINDOW(appdata->window), str);
58    g_free(str);    g_free(str);
 #else  
   if(project_valid)  
     gtk_window_set_title(GTK_WINDOW(appdata->window), appdata->project->name);  
   else  
     gtk_window_set_title(GTK_WINDOW(appdata->window), "");  
59  #endif  #endif
60    
61    if(appdata->iconbar && appdata->iconbar->toolbar)    if(appdata->iconbar && appdata->iconbar->toolbar)
62      gtk_widget_set_sensitive(appdata->iconbar->toolbar, osm_valid);      gtk_widget_set_sensitive(appdata->iconbar->toolbar, osm_valid);
63    
64    /* disable all menu entries related to map */    /* disable all menu entries related to map */
65    gtk_widget_set_sensitive(appdata->menu_osm, project_valid);    gtk_widget_set_sensitive(appdata->submenu_map, project_valid);
66    gtk_widget_set_sensitive(appdata->menu_item_osm_upload, osm_valid);    gtk_widget_set_sensitive(appdata->menu_item_map_upload, osm_valid);
67    gtk_widget_set_sensitive(appdata->menu_item_osm_diff, osm_valid);    if(appdata->menu_item_map_undo)
68    gtk_widget_set_sensitive(appdata->menu_item_osm_undo_changes, osm_valid);      gtk_widget_set_sensitive(appdata->menu_item_map_undo, osm_valid);
69    gtk_widget_set_sensitive(appdata->track.menu_track, osm_valid);    gtk_widget_set_sensitive(appdata->menu_item_map_save_changes, osm_valid);
70    gtk_widget_set_sensitive(appdata->menu_view, osm_valid);    gtk_widget_set_sensitive(appdata->menu_item_map_undo_changes, osm_valid);
71    gtk_widget_set_sensitive(appdata->menu_wms, osm_valid);    gtk_widget_set_sensitive(appdata->menu_item_map_relations, osm_valid);
72    gtk_widget_set_sensitive(appdata->menu_map, osm_valid);    gtk_widget_set_sensitive(appdata->track.submenu_track, osm_valid);
73    gtk_widget_set_sensitive(appdata->menu_item_project_close, project_valid);    gtk_widget_set_sensitive(appdata->submenu_view, osm_valid);
74      gtk_widget_set_sensitive(appdata->submenu_wms, osm_valid);
75    
76    if(!project_valid)    if(!project_valid)
77      statusbar_set(appdata, _("Please load or create a project"), FALSE);      statusbar_set(appdata, _("Please load or create a project"), FALSE);
# Line 68  static void main_ui_enable(appdata_t *ap Line 79  static void main_ui_enable(appdata_t *ap
79    
80  /******************** begin of menu *********************/  /******************** begin of menu *********************/
81    
 #if 0 // simplify menu  
 static struct {  
   enum { MENU_END, MENU_ITEM, MENU_SUB, MENU_SUB_END, MENU_SEP }  type;  
   
   char *title;  
   GCallback c_handler;  
 } menu[] = {  
   { MENU_SUB, "OSM", NULL },  
   
   { MENU_END,  NULL, NULL },  
 };  
 #endif  
   
82  static void  static void
83  cb_menu_project_open(GtkWidget *window, gpointer data) {  cb_menu_project_open(GtkMenuItem *item, gpointer data) {
84    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
85    project_load(appdata, NULL);    project_load(appdata, NULL);
86    main_ui_enable(appdata);    main_ui_enable(appdata);
87  }  }
88    
89  static void  static void
90  cb_menu_project_close(GtkWidget *window, gpointer data) {  cb_menu_project_wizard(GtkMenuItem *item, gpointer data) {
91    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
92    project_close(appdata);    project_wizard(appdata);
   main_ui_enable(appdata);  
93  }  }
94    
95  static void  static void
96  cb_menu_about(GtkWidget *window, gpointer data) {  cb_menu_about(GtkMenuItem *item, gpointer data) {
97    GtkAboutDialog *about = GTK_ABOUT_DIALOG(gtk_about_dialog_new());    appdata_t *appdata = (appdata_t*)data;
   
   gtk_about_dialog_set_name(about, "OSM2Go");  
   gtk_about_dialog_set_version(about, VERSION);  
   gtk_about_dialog_set_copyright(about, _("Copyright 2008"));  
98    
99    const gchar *authors[] = {    const gchar *authors[] = {
100      "Till Harbaum <till@harbaum.org>",      "Till Harbaum <till@harbaum.org>",
101      "Andrew Chadwick",      "Andrew Chadwick <andrewc-osm2go@piffle.org>",
102      NULL };      NULL };
103    
104    gtk_about_dialog_set_authors(about, authors);    const gchar *artists[] = {
105        "Andrew Zhilin <drew.zhilin@gmail.com>",
106    gtk_about_dialog_set_website(about,      NULL };
        _("http://www.harbaum.org/till/maemo"));  
   
   gtk_about_dialog_set_comments(about,  
        _("Mobile OSM Editor"));  
107    
108    gtk_widget_show_all(GTK_WIDGET(about));    gtk_show_about_dialog(GTK_WINDOW(appdata->window),
109    gtk_dialog_run(GTK_DIALOG(about));                          "name", "OSM2Go",
110    gtk_widget_destroy(GTK_WIDGET(about));                          "version", VERSION,
111                            "copyright", _("Copyright 2008-2009"),
112                            "authors", authors,
113                            "artists", artists,
114                            "website", _("http://www.harbaum.org/till/maemo"),
115                            "comments", _("Mobile OSM Editor"),
116                            NULL);
117  }  }
118    
119  void on_window_destroy (GtkWidget *widget, gpointer data);  void on_window_destroy (GtkWidget *widget, gpointer data);
120    
121    #ifndef USE_HILDON
122  static void  static void
123  cb_menu_quit(GtkWidget *window, gpointer data) {  cb_menu_quit(GtkMenuItem *item, gpointer data) {
124    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
125    gtk_widget_destroy(GTK_WIDGET(appdata->window));    gtk_widget_destroy(GTK_WIDGET(appdata->window));
126  }  }
127    #endif
128    
129  static void  static void
130  cb_menu_upload(GtkWidget *window, gpointer data) {  cb_menu_upload(GtkMenuItem *item, gpointer data) {
131    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
132    if(!appdata->osm || !appdata->project) return;    if(!appdata->osm || !appdata->project) return;
133    
134      if(project_check_demo(GTK_WIDGET(appdata->window), appdata->project))
135        return;
136    
137    osm_upload(appdata, appdata->osm, appdata->project);    osm_upload(appdata, appdata->osm, appdata->project);
138  }  }
139    
140  static void  static void
141  cb_menu_download(GtkWidget *window, gpointer data) {  cb_menu_download(GtkMenuItem *item, gpointer data) {
142    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
143    if(!appdata->project) return;    if(!appdata->project) return;
144    
145      if(project_check_demo(GTK_WIDGET(appdata->window), appdata->project))
146        return;
147    
148    /* if we have valid osm data loaded: save state first */    /* if we have valid osm data loaded: save state first */
149    if(appdata->osm) {    if(appdata->osm) {
150      /* redraw the entire map by destroying all map items and redrawing them */      /* redraw the entire map by destroying all map items and redrawing them */
# Line 153  cb_menu_download(GtkWidget *window, gpoi Line 156  cb_menu_download(GtkWidget *window, gpoi
156    }    }
157    
158    // download    // download
159    if(osm_download(GTK_WIDGET(appdata->window), appdata->project)) {    if(osm_download(GTK_WIDGET(appdata->window), appdata->settings,
160      appdata->osm = osm_parse(appdata->project->osm);                    appdata->project)) {
161        banner_busy_start(appdata, 1, "Redrawing");
162        appdata->osm = osm_parse(appdata->project->path, appdata->project->osm);
163      diff_restore(appdata, appdata->project, appdata->osm);      diff_restore(appdata, appdata->project, appdata->osm);
164      map_paint(appdata);      map_paint(appdata);
165        banner_busy_stop(appdata); //"Redrawing"
166    }    }
167    
168    main_ui_enable(appdata);    main_ui_enable(appdata);
169  }  }
170    
171  static void  static void
172  cb_menu_wms_import(GtkWidget *window, gpointer data) {  cb_menu_wms_import(GtkMenuItem *item, gpointer data) {
173    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
174    wms_import(appdata);    wms_import(appdata);
175  }  }
176    
177  static void  static void
178  cb_menu_wms_clear(GtkWidget *window, gpointer data) {  cb_menu_wms_clear(GtkMenuItem *item, gpointer data) {
179    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
180    wms_remove(appdata);    wms_remove(appdata);
181  }  }
182    
183  static void  static void
184  cb_menu_wms_adjust(GtkWidget *window, gpointer data) {  cb_menu_wms_adjust(GtkMenuItem *item, gpointer data) {
185    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
186    map_action_set(appdata, MAP_ACTION_BG_ADJUST);    map_action_set(appdata, MAP_ACTION_BG_ADJUST);
187  }  }
# Line 183  cb_menu_wms_adjust(GtkWidget *window, gp Line 189  cb_menu_wms_adjust(GtkWidget *window, gp
189  /* ----------- hide objects for performance reasons ----------- */  /* ----------- hide objects for performance reasons ----------- */
190    
191  static void  static void
192  cb_menu_map_hide_sel(GtkWidget *window, gpointer data) {  cb_menu_map_hide_sel(GtkMenuItem *item, gpointer data) {
193    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
194    map_hide_selected(appdata);    map_hide_selected(appdata);
195  }  }
196    
197  static void  static void
198  cb_menu_map_show_all(GtkWidget *window, gpointer data) {  cb_menu_map_show_all(GtkMenuItem *item, gpointer data) {
199    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
200    map_show_all(appdata);    map_show_all(appdata);
201  }  }
202    
203  /* ---------------------------------------------------------- */  /* ---------------------------------------------------------- */
204    
205  #if 1  // mainly for testing  #if defined(USE_HILDON) && (MAEMO_VERSION_MAJOR == 5)
206  static void  #define MENU_CHECK_ITEM HildonCheckButton
207  cb_menu_redraw(GtkWidget *window, gpointer data) {  #define MENU_CHECK_ITEM_ACTIVE(a) hildon_check_button_get_active(a)
208    appdata_t *appdata = (appdata_t*)data;  #else
209    #define MENU_CHECK_ITEM GtkCheckMenuItem
210    #define MENU_CHECK_ITEM_ACTIVE(a) gtk_check_menu_item_get_active(a)
211    #endif
212    
213    /* redraw the entire map by destroying all map items and redrawing them */  static void
214    track_save(appdata->project, appdata->track.track);  cb_menu_map_no_icons(MENU_CHECK_ITEM *item, appdata_t *appdata) {
   diff_save(appdata->project, appdata->osm);  
   map_clear(appdata, MAP_LAYER_ALL);  
   osm_free(&appdata->icon, appdata->osm);  
215    
216    appdata->osm = osm_parse(appdata->project->osm);    banner_busy_start(appdata, 1, "Redrawing");
217    diff_restore(appdata, appdata->project, appdata->osm);    map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);
   map_paint(appdata);  
218    
219    appdata->track.track = track_restore(appdata, appdata->project);    appdata->settings->no_icons = MENU_CHECK_ITEM_ACTIVE(item);
   if(appdata->track.track)  
     map_track_draw(appdata->map, appdata->track.track);  
220    
221    wms_load(appdata);    map_paint(appdata);
222      banner_busy_stop(appdata); //"Redrawing"
223  }  }
 #endif  
224    
225  static void  static void
226  cb_menu_style(GtkWidget *widget, gpointer data) {  cb_menu_style(GtkMenuItem *item, gpointer data) {
227    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
228    
229    style_select(GTK_WIDGET(appdata->window), appdata);    style_select(GTK_WIDGET(appdata->window), appdata);
230  }  }
231    
232  static void  static void
233  cb_menu_map_no_icons(GtkWidget *widget, gpointer data) {  cb_menu_undo(GtkMenuItem *item, gpointer data) {
234    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
235    
236    map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);    undo(appdata);
237    appdata->settings->no_icons =  
238      gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget));    // the banner will be displayed from within undo with more details
   map_paint(appdata);  
239  }  }
240    
241  static void  static void
242  cb_menu_save_changes(GtkWidget *widget, gpointer data) {  cb_menu_save_changes(GtkMenuItem *item, gpointer data) {
243    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
244    
245    diff_save(appdata->project, appdata->osm);    diff_save(appdata->project, appdata->osm);
246    statusbar_set(appdata, _("Saved all changes made "    banner_show_info(appdata, _("Saved local changes"));
                            "to this project so far"), FALSE);  
247  }  }
248    
249  static void  static void
250  cb_menu_undo_changes(GtkWidget *widget, gpointer data) {  cb_menu_undo_changes(GtkMenuItem *item, gpointer data) {
251    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
252    
253    if(!yes_no_f(GTK_WIDGET(appdata->window), NULL, 0, 0,    if(!yes_no_f(GTK_WIDGET(appdata->window), NULL, 0, 0,
254                 _("Undo all changes?"),                 _("Discard local changes?"),
255                 _("Do you really want to undo all your changes "                 _("Throw away all the changes you've not "
256                   "not uploaded so far? This cannot be undone!")))                   "uploaded yet? This can't be undone.")))
257      return;      return;
258    
259      banner_busy_start(appdata, 1, _("Redrawing"));
260    map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);    map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);
261    osm_free(&appdata->icon, appdata->osm);    osm_free(&appdata->icon, appdata->osm);
262    diff_remove(appdata->project);    diff_remove(appdata->project);
263    appdata->osm = osm_parse(appdata->project->osm);    appdata->osm = osm_parse(appdata->project->path, appdata->project->osm);
264    map_paint(appdata);    map_paint(appdata);
265      banner_busy_stop(appdata);  //"Redrawing"
266    
267    statusbar_set(appdata, _("All changes made "    banner_show_info(appdata, _("Discarded local changes"));
                            "so far have been reset"), FALSE);  
268  }  }
269    
270    static void
271    cb_menu_osm_relations(GtkMenuItem *item, gpointer data) {
272      relation_list((appdata_t*)data);
273    }
274    
275  #ifdef USE_HILDON  #if !defined(USE_HILDON) || (MAEMO_VERSION_MAJOR < 5)
276  static void  static void
277  cb_menu_fullscreen(GtkWidget *widget, gpointer data) {  cb_menu_fullscreen(MENU_CHECK_ITEM *item, gpointer data) {
278    appdata_t *appdata = (appdata_t *)data;    appdata_t *appdata = (appdata_t *)data;
279    
280    if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget)))    if(MENU_CHECK_ITEM_ACTIVE(item))
281      gtk_window_fullscreen(GTK_WINDOW(appdata->window));      gtk_window_fullscreen(GTK_WINDOW(appdata->window));
282    else    else
283      gtk_window_unfullscreen(GTK_WINDOW(appdata->window));      gtk_window_unfullscreen(GTK_WINDOW(appdata->window));
# Line 279  cb_menu_fullscreen(GtkWidget *widget, gp Line 285  cb_menu_fullscreen(GtkWidget *widget, gp
285  #endif  #endif
286    
287  static void  static void
288  cb_menu_zoomin(GtkWidget *widget, appdata_t *appdata) {  cb_menu_zoomin(GtkMenuItem *item, appdata_t *appdata) {
289    if(!appdata || !appdata->map) return;    if(!appdata || !appdata->map) return;
290    
291    map_set_zoom(appdata->map, appdata->map->state->zoom*ZOOM_FACTOR_MENU, TRUE);    map_set_zoom(appdata->map, appdata->map->state->zoom*ZOOM_FACTOR_MENU, TRUE);
# Line 287  cb_menu_zoomin(GtkWidget *widget, appdat Line 293  cb_menu_zoomin(GtkWidget *widget, appdat
293  }  }
294    
295  static void  static void
296  cb_menu_zoomout(GtkWidget *widget, appdata_t *appdata) {  cb_menu_zoomout(GtkMenuItem *item, appdata_t *appdata) {
297    if(!appdata || !appdata->map) return;    if(!appdata || !appdata->map) return;
298    
299    map_set_zoom(appdata->map, appdata->map->state->zoom/ZOOM_FACTOR_MENU, TRUE);    map_set_zoom(appdata->map, appdata->map->state->zoom/ZOOM_FACTOR_MENU, TRUE);
# Line 295  cb_menu_zoomout(GtkWidget *widget, appda Line 301  cb_menu_zoomout(GtkWidget *widget, appda
301  }  }
302    
303  static void  static void
304  cb_menu_track_import(GtkWidget *window, appdata_t *appdata) {  cb_menu_view_detail_inc(GtkMenuItem *item, gpointer data) {
305      appdata_t *appdata = (appdata_t*)data;
306    
307      printf("detail level increase\n");
308      map_detail_increase(appdata->map);
309    }
310    
311    static void
312    cb_menu_view_detail_normal(GtkMenuItem *item, gpointer data) {
313      appdata_t *appdata = (appdata_t*)data;
314    
315      printf("detail level normal\n");
316      map_detail_normal(appdata->map);
317    }
318    
319    static void
320    cb_menu_view_detail_dec(GtkMenuItem *item, gpointer data) {
321      appdata_t *appdata = (appdata_t*)data;
322    
323      printf("detail level decrease\n");
324      map_detail_decrease(appdata->map);
325    }
326    
327    static void
328    cb_menu_track_import(GtkMenuItem *item, appdata_t *appdata) {
329      g_assert(appdata->settings);
330    
331    /* open a file selector */    /* open a file selector */
332    GtkWidget *dialog;    GtkWidget *dialog;
# Line 312  cb_menu_track_import(GtkWidget *window, Line 343  cb_menu_track_import(GtkWidget *window,
343                          NULL);                          NULL);
344  #endif  #endif
345    
346    /* use path if one is present */    if(appdata->settings->track_path) {
347    if(appdata->track.import_path)      if(!g_file_test(appdata->settings->track_path, G_FILE_TEST_EXISTS)) {
348      gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),        char *last_sep = strrchr(appdata->settings->track_path, '/');
349                                          appdata->track.import_path);        if(last_sep) {
350            *last_sep = 0;  // seperate path from file
351    
352            /* the user just created a new document */
353            gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
354                                        appdata->settings->track_path);
355            gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog),
356                                              last_sep+1);
357    
358            /* restore full filename */
359            *last_sep = '/';
360          }
361        } else
362          gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),
363                                        appdata->settings->track_path);
364      }
365    
366    gtk_widget_show_all (GTK_WIDGET(dialog));    gtk_widget_show_all (GTK_WIDGET(dialog));
367    if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_FM_OK) {    if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_FM_OK) {
368      char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));      char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
369    
370      /* load a track */      /* load a track */
371      track_do(appdata, TRACK_IMPORT, filename);      appdata->track.track = track_import(appdata, filename);
372      if(appdata->track.track) {      if(appdata->track.track) {
373          if(appdata->settings->track_path) g_free(appdata->settings->track_path);
374        /* save path if gpx was successfully loaded */        appdata->settings->track_path = g_strdup(filename);
       char *r = strrchr(filename, '/');  
   
       /* there is a delimiter, use everything left of it as path */  
       if(r) {  
         *r = 0;  
         if(appdata->track.import_path) g_free(appdata->track.import_path);  
         appdata->track.import_path = g_strdup(filename);  
         /* restore path ... just in case ... */  
         *r = '/';  
       }  
375      }      }
376      g_free (filename);      g_free (filename);
377    }    }
# Line 344  cb_menu_track_import(GtkWidget *window, Line 380  cb_menu_track_import(GtkWidget *window,
380  }  }
381    
382  static void  static void
383  cb_menu_track_gps(GtkWidget *window, gpointer data) {  cb_menu_track_enable_gps(MENU_CHECK_ITEM *item, appdata_t *appdata) {
384    appdata_t *appdata = (appdata_t*)data;    track_enable_gps(appdata, MENU_CHECK_ITEM_ACTIVE(item));
385    }
386    
387    if(gtk_check_menu_item_get_active(  
388      GTK_CHECK_MENU_ITEM(appdata->track.menu_item_gps))) {  static void
389      track_do(appdata, TRACK_GPS, NULL);  cb_menu_track_follow_gps(MENU_CHECK_ITEM *item, appdata_t *appdata) {
390    } else {    appdata->settings->follow_gps = MENU_CHECK_ITEM_ACTIVE(item);
     track_do(appdata, TRACK_NONE, NULL);  
   }  
391  }  }
392    
393    
394  static void  static void
395  cb_menu_track_export(GtkWidget *window, gpointer data) {  cb_menu_track_export(GtkMenuItem *item, appdata_t *appdata) {
396    appdata_t *appdata = (appdata_t*)data;    g_assert(appdata->settings);
397    messagef(GTK_WIDGET(appdata->window), _("NIY"),  
398             _("Track export is not yet supported."));    /* open a file selector */
399      GtkWidget *dialog;
400    
401    #ifdef USE_HILDON
402      dialog = hildon_file_chooser_dialog_new(GTK_WINDOW(appdata->window),
403                                              GTK_FILE_CHOOSER_ACTION_SAVE);
404    #else
405      dialog = gtk_file_chooser_dialog_new(_("Export track file"),
406                                           GTK_WINDOW(appdata->window),
407                                           GTK_FILE_CHOOSER_ACTION_SAVE,
408                                           GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
409                                           GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
410                                           NULL);
411    #endif
412    
413      printf("set filename <%s>\n", appdata->settings->track_path);
414    
415      if(appdata->settings->track_path) {
416        if(!g_file_test(appdata->settings->track_path, G_FILE_TEST_EXISTS)) {
417          char *last_sep = strrchr(appdata->settings->track_path, '/');
418          if(last_sep) {
419            *last_sep = 0;  // seperate path from file
420    
421            /* the user just created a new document */
422            gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
423                                                appdata->settings->track_path);
424            gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog),
425                                              last_sep+1);
426    
427            /* restore full filename */
428            *last_sep = '/';
429          }
430        } else
431          gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),
432                                        appdata->settings->track_path);
433      }
434    
435      if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_FM_OK) {
436        gchar *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
437        if(filename) {
438          printf("export to %s\n", filename);
439    
440          if(!g_file_test(filename, G_FILE_TEST_EXISTS) ||
441             yes_no_f(dialog, appdata, MISC_AGAIN_ID_EXPORT_OVERWRITE,
442                      MISC_AGAIN_FLAG_DONT_SAVE_NO,
443                      "Overwrite existing file",
444                      "The file already exists. "
445                      "Do you really want to replace it?")) {
446            if(appdata->settings->track_path)
447              g_free(appdata->settings->track_path);
448            appdata->settings->track_path = g_strdup(filename);
449    
450            track_export(appdata, filename);
451          }
452        }
453      }
454    
455      gtk_widget_destroy (dialog);
456  }  }
457    
458    
459  static void  static void
460  cb_menu_track_clear(GtkWidget *window, gpointer data) {  cb_menu_track_clear(GtkMenuItem *item, gpointer data) {
461    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
462    track_do(appdata, TRACK_NONE, NULL);    track_clear(appdata, appdata->track.track);
463      appdata->track.track = NULL;
464  }  }
465    
 void menu_create(appdata_t *appdata) {  
   GtkWidget *menu, *item, *submenu;  
   menu = gtk_menu_new();  
466    
467    
   /* -------------------- Project submenu -------------------- */  
468    
469    item = gtk_menu_item_new_with_label( _("Project") );  /*
470    gtk_menu_append(GTK_MENU_SHELL(menu), item);   *  Platform-specific UI tweaks.
471    submenu = gtk_menu_new();   */
   gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);  
472    
   item = gtk_menu_item_new_with_label( _("Open...") );  
   gtk_menu_append(GTK_MENU_SHELL(submenu), item);  
   g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_project_open),  
                    appdata);  
473    
474    appdata->menu_item_project_close = item =  #ifndef USE_HILDON
475      gtk_menu_item_new_with_label( _("Close") );  #ifdef PORTRAIT
   gtk_menu_append(GTK_MENU_SHELL(submenu), item);  
   g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_project_close),  
                    appdata);  
476    
477    /* --------------- view menu ------------------- */  // Portrait mode, for openmoko-like systems
478    #define uispecific_main_menu_new gtk_menu_new
479    
480    gtk_menu_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());  #else
481    
482    // Regular desktop builds
483    #define uispecific_main_menu_new gtk_menu_bar_new
484    #define UISPECIFIC_MAIN_MENU_IS_MENU_BAR
485    #define UISPECIFIC_MENU_HAS_ICONS
486    #define UISPECIFIC_MENU_HAS_ACCELS
487    
488    #endif //PORTRAIT
489    #else//USE_HILDON
490    
491    // Maemo/Hildon builds
492    #define uispecific_main_menu_new gtk_menu_new
493    
   appdata->menu_view = item =  
     gtk_menu_item_new_with_label( _("View") );  
   gtk_menu_append(GTK_MENU_SHELL(menu), item);  
   submenu = gtk_menu_new();  
   gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);  
   
 #ifdef USE_HILDON  
   appdata->fullscreen_menu_item =  
     item = gtk_check_menu_item_new_with_label( _("Fullscreen") );  
   gtk_menu_append(GTK_MENU_SHELL(submenu), item);  
   g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_fullscreen),  
                    appdata);  
494  #endif  #endif
495    
   item = gtk_menu_item_new_with_label( _("Zoom +" ));  
   gtk_menu_append(GTK_MENU_SHELL(submenu), item);  
   g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_zoomin), appdata);  
   
   item = gtk_menu_item_new_with_label( _("Zoom -") );  
   gtk_menu_append(GTK_MENU_SHELL(submenu), item);  
   g_signal_connect(item, "activate",  
                    GTK_SIGNAL_FUNC(cb_menu_zoomout), appdata);  
496    
497    /* -------------------- OSM submenu -------------------- */  #if !defined(USE_HILDON) || (MAEMO_VERSION_MAJOR < 5)
498    // Half-arsed slapdash common menu item constructor. Let's use GtkBuilder
499    // instead so we have some flexibility.
500    
501    static GtkWidget *
502    menu_append_new_item(appdata_t *appdata,
503                         GtkWidget *menu_shell,
504                         GtkSignalFunc activate_cb,
505                         char *label,
506                         const gchar *icon_name, // stock id or name for icon_load
507                                        // overridden by label, accels, icon_name
508                         const gchar *accel_path,
509                         guint accel_key,      // from gdk/gdkkeysyms.h
510                         GdkModifierType accel_mods, // e.g. GDK_CONTROL_MASK
511                         gboolean enabled,
512                         gboolean is_check, gboolean check_status)
513    {
514      GtkWidget *item = NULL;
515      GtkWidget *image = NULL;
516    
517      gboolean stock_item_known = FALSE;
518      GtkStockItem stock_item;
519      if (icon_name != NULL) {
520        stock_item_known = gtk_stock_lookup(icon_name, &stock_item);
521      }
522    
523      // Icons
524    #ifndef UISPECIFIC_MENU_HAS_ICONS
525      item = is_check ? gtk_check_menu_item_new_with_mnemonic (label)
526                      : gtk_menu_item_new_with_mnemonic       (label);
527    #else
528      if (is_check) {
529        item = gtk_check_menu_item_new_with_mnemonic (label);
530      }
531      else if (!stock_item_known) {
532        GdkPixbuf *pbuf = icon_load(&appdata->icon, icon_name);
533        if (pbuf) {
534          image = gtk_image_new_from_pixbuf(pbuf);
535        }
536        if (image) {
537          item = gtk_image_menu_item_new_with_mnemonic(label);
538          gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
539        }
540        else {
541          item = gtk_menu_item_new_with_mnemonic(label);
542        }
543      }
544      else {
545        item = gtk_image_menu_item_new_with_mnemonic(label);
546        image = gtk_image_new_from_stock(icon_name, GTK_ICON_SIZE_MENU);
547        gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
548      }
549    #endif
550    
551    appdata->menu_osm = item = gtk_menu_item_new_with_label( _("OSM") );  #ifdef UISPECIFIC_MENU_HAS_ACCELS
552    gtk_menu_append(GTK_MENU_SHELL(menu), item);    // Accelerators
553      // Default
554      if (accel_path != NULL) {
555        gtk_menu_item_set_accel_path(GTK_MENU_ITEM(item), accel_path);
556        if (accel_key != 0) {
557          gtk_accel_map_add_entry( accel_path, accel_key, accel_mods );
558        }
559        else if (stock_item_known) {
560          gtk_accel_map_add_entry( accel_path, stock_item.keyval,
561                                   stock_item.modifier );
562        }
563      }
564    #endif
565    
566      gtk_menu_shell_append(GTK_MENU_SHELL(menu_shell), GTK_WIDGET(item));
567      gtk_widget_set_sensitive(GTK_WIDGET(item), enabled);
568      if (is_check)
569        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), check_status);
570    
571      g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(activate_cb),
572                       appdata);
573      return item;
574    }
575    
576    void menu_create(appdata_t *appdata) {
577      GtkWidget *menu, *item, *submenu;
578      GtkWidget *about_quit_items_menu;
579    
580      if (g_module_supported()) {
581        printf("*** can use GModule: consider using GtkUIManager / GtkBuilder\n");
582      }
583    
584      menu = uispecific_main_menu_new();
585      about_quit_items_menu = menu;
586    
587      /* -------------------- Project submenu -------------------- */
588    
589      GtkAccelGroup *accel_grp = gtk_accel_group_new();
590      item = gtk_menu_item_new_with_mnemonic( _("_Project") );
591      gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
592    submenu = gtk_menu_new();    submenu = gtk_menu_new();
593      gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
594    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
595    #ifdef UISPECIFIC_MAIN_MENU_IS_MENU_BAR
596      about_quit_items_menu = submenu;
597    #endif
598    
599    appdata->menu_item_osm_upload = item =    menu_append_new_item(
600      gtk_menu_item_new_with_label( _("Upload...") );      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_project_open), _("_Open"),
601    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      GTK_STOCK_OPEN, "<OSM2Go-Main>/Project/Open",
602    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_upload), appdata);      0, 0, TRUE, FALSE, FALSE
603      );
604    item = gtk_menu_item_new_with_label( _("Download...") );  
605    gtk_menu_append(GTK_MENU_SHELL(submenu), item);    menu_append_new_item(
606    g_signal_connect(item, "activate",      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_project_wizard), _("_Wizard"),
607                     GTK_SIGNAL_FUNC(cb_menu_download), appdata);      GTK_STOCK_NEW, "<OSM2Go-Main>/Project/Wizard",
608        0, 0, TRUE, FALSE, FALSE
609    gtk_menu_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());    );
   
   appdata->menu_item_osm_diff = item =  
     gtk_menu_item_new_with_label( _("Save diff file") );  
   gtk_menu_append(GTK_MENU_SHELL(submenu), item);  
   g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_save_changes),  
                    appdata);  
610    
611    appdata->menu_item_osm_undo_changes = item =    /* --------------- view menu ------------------- */
     gtk_menu_item_new_with_label( _("Undo all changes...") );  
   gtk_menu_append(GTK_MENU_SHELL(submenu), item);  
   g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_undo_changes),  
                    appdata);  
612    
613    /* -------------------- wms submenu -------------------- */  #ifndef UISPECIFIC_MAIN_MENU_IS_MENU_BAR
614      gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
615    #endif
616    
617    appdata->menu_wms = item = gtk_menu_item_new_with_label( _("WMS") );    appdata->submenu_view = item = gtk_menu_item_new_with_mnemonic( _("_View") );
618    gtk_menu_append(GTK_MENU_SHELL(menu), item);    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
619    submenu = gtk_menu_new();    submenu = gtk_menu_new();
620      gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
621    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
622    
623    item = gtk_menu_item_new_with_label( _("Import...") );  #if !defined(USE_HILDON) || (MAEMO_VERSION_MAJOR < 5)
624    gtk_menu_append(GTK_MENU_SHELL(submenu), item);    appdata->menu_item_view_fullscreen = menu_append_new_item(
625    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_wms_import),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_fullscreen), _("_Fullscreen"),
626                     appdata);      GTK_STOCK_FULLSCREEN, "<OSM2Go-Main>/View/Fullscreen",
627        0, 0, TRUE, TRUE, FALSE
628      );
629    #endif
630    
631    appdata->menu_item_wms_clear = item =    menu_append_new_item(
632      gtk_menu_item_new_with_label( _("Clear") );      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_zoomin), _("Zoom _in"),
633    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      GTK_STOCK_ZOOM_IN, "<OSM2Go-Main>/View/ZoomIn",
634    gtk_widget_set_sensitive(item, FALSE);      GDK_comma, GDK_CONTROL_MASK, TRUE, FALSE, FALSE
635    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_wms_clear),    );
636                     appdata);  
637      menu_append_new_item(
638        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_zoomout), _("Zoom _out"),
639        GTK_STOCK_ZOOM_OUT, "<OSM2Go-Main>/View/ZoomOut",
640        GDK_period, GDK_CONTROL_MASK, TRUE, FALSE, FALSE
641      );
642    
643      gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
644    
645      menu_append_new_item(
646        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_view_detail_inc), _("More details"),
647        NULL, "<OSM2Go-Main>/View/DetailInc",
648        GDK_period, GDK_MOD1_MASK, TRUE, FALSE, FALSE
649      );
650    
651      menu_append_new_item(
652        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_view_detail_normal), _("Normal details"),
653        NULL, "<OSM2Go-Main>/View/DetailNormal",
654        0, 0, TRUE, FALSE, FALSE
655      );
656    
657      menu_append_new_item(
658        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_view_detail_dec), _("Less details"),
659        NULL, "<OSM2Go-Main>/View/DetailDec",
660        GDK_comma, GDK_MOD1_MASK, TRUE, FALSE, FALSE
661      );
662    
663      gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
664    
665      appdata->menu_item_map_hide_sel = menu_append_new_item(
666        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_hide_sel), _("_Hide selected"),
667        GTK_STOCK_REMOVE, "<OSM2Go-Main>/View/HideSelected",
668        0, 0, TRUE, FALSE, FALSE
669      );
670      gtk_widget_set_sensitive(appdata->menu_item_map_hide_sel, FALSE);
671    
672      appdata->menu_item_map_show_all = menu_append_new_item(
673        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_show_all), _("_Show all"),
674        GTK_STOCK_ADD, "<OSM2Go-Main>/View/ShowAll",
675        0, 0, TRUE, FALSE, FALSE
676      );
677      gtk_widget_set_sensitive(appdata->menu_item_map_show_all, FALSE);
678    
679      gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
680    
681      menu_append_new_item(
682        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_style), _("St_yle"),
683        GTK_STOCK_SELECT_COLOR, "<OSM2Go-Main>/View/Style",
684        0, 0, TRUE, FALSE, FALSE
685      );
686    
687      gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
688    
689      appdata->menu_item_map_no_icons = menu_append_new_item(
690        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_no_icons), _("No _icons"),
691        NULL, "<OSM2Go-Main>/View/NoIcons",
692        0, 0, TRUE, TRUE, appdata->settings->no_icons
693      );
694    
   appdata->menu_item_wms_adjust = item =  
     gtk_menu_item_new_with_label( _("Adjust") );  
   gtk_menu_append(GTK_MENU_SHELL(submenu), item);  
   gtk_widget_set_sensitive(item, FALSE);  
   g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_wms_adjust),  
                    appdata);  
695    
696    /* -------------------- map submenu -------------------- */    /* -------------------- map submenu -------------------- */
697    
698    appdata->menu_map = item = gtk_menu_item_new_with_label( _("Map") );    appdata->submenu_map = item = gtk_menu_item_new_with_mnemonic( _("_Map") );
699    gtk_menu_append(GTK_MENU_SHELL(menu), item);    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
700    submenu = gtk_menu_new();    submenu = gtk_menu_new();
701      gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
702    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
703    
704    appdata->menu_item_map_hide_sel = item =    appdata->menu_item_map_upload = menu_append_new_item(
705      gtk_menu_item_new_with_label( _("Hide selected") );      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_upload), _("_Upload"),
706    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      "upload.16", "<OSM2Go-Main>/Map/Upload",
707    gtk_widget_set_sensitive(item, FALSE);      GDK_u, GDK_SHIFT_MASK|GDK_CONTROL_MASK, TRUE, FALSE, FALSE
708    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_map_hide_sel),    );
709                     appdata);  
710      menu_append_new_item(
711    appdata->menu_item_map_show_all = item =      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_download), _("_Download"),
712      gtk_menu_item_new_with_label( _("Show all") );      "download.16", "<OSM2Go-Main>/Map/Download",
713    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      GDK_d, GDK_SHIFT_MASK|GDK_CONTROL_MASK, TRUE, FALSE, FALSE
714    gtk_widget_set_sensitive(item, FALSE);    );
715    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_map_show_all),  
716                     appdata);    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
717    
718      if(getenv("OSM2GO_UNDO_TEST")) {
719        appdata->menu_item_map_undo = menu_append_new_item(
720                   appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_undo), _("_Undo"),
721                   GTK_STOCK_UNDO, "<OSM2Go-Main>/Map/Undo",
722                   GDK_z, GDK_CONTROL_MASK, TRUE, FALSE, FALSE
723                   );
724      } else
725        printf("set environment variable OSM2GO_UNDO_TEST to enable undo framework tests\n");
726    
727      appdata->menu_item_map_save_changes = menu_append_new_item(
728        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_save_changes), _("_Save local changes"),
729        GTK_STOCK_SAVE, "<OSM2Go-Main>/Map/SaveChanges",
730        GDK_s, GDK_SHIFT_MASK|GDK_CONTROL_MASK, TRUE, FALSE, FALSE
731      );
732    
733      appdata->menu_item_map_undo_changes = menu_append_new_item(
734        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_undo_changes), _("Disca_rd local changes"),
735        GTK_STOCK_DELETE, "<OSM2Go-Main>/Map/DiscardChanges",
736        0, 0, TRUE, FALSE, FALSE
737      );
738    
739      gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
740      appdata->menu_item_map_relations = menu_append_new_item(
741        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_osm_relations), _("_Relations"),
742        NULL, "<OSM2Go-Main>/Map/Relations",
743        GDK_r, GDK_SHIFT_MASK|GDK_CONTROL_MASK, TRUE, FALSE, FALSE
744      );
745    
746    gtk_menu_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());    /* -------------------- wms submenu -------------------- */
747    
748    item = gtk_menu_item_new_with_label( _("Redraw") );    appdata->submenu_wms = item = gtk_menu_item_new_with_mnemonic( _("_WMS") );
749    gtk_menu_append(GTK_MENU_SHELL(submenu), item);    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
750    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_redraw), appdata);    submenu = gtk_menu_new();
751      gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
752    gtk_menu_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
753    
754    item = gtk_menu_item_new_with_label( _("Style...") );    menu_append_new_item(
755    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_wms_import), _("_Import"),
756    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_style), appdata);      GTK_STOCK_INDEX, "<OSM2Go-Main>/WMS/Import",
757        0, 0, TRUE, FALSE, FALSE
758    gtk_menu_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());    );
759    
760    appdata->menu_item_map_no_icons =    appdata->menu_item_wms_clear = menu_append_new_item(
761      item = gtk_check_menu_item_new_with_label( _("No Icons") );      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_wms_clear), _("_Clear"),
762    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),      GTK_STOCK_CLEAR, "<OSM2Go-Main>/WMS/Clear",
763                                   appdata->settings->no_icons);      0, 0, TRUE, FALSE, FALSE
764    gtk_menu_append(GTK_MENU_SHELL(submenu), item);    );
765    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_map_no_icons),    gtk_widget_set_sensitive(appdata->menu_item_wms_clear, FALSE);
766                     appdata);  
767      appdata->menu_item_wms_adjust = menu_append_new_item(
768        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_wms_adjust), _("_Adjust"),
769        NULL, "<OSM2Go-Main>/WMS/Adjust",
770        0, 0, TRUE, FALSE, FALSE
771      );
772      gtk_widget_set_sensitive(appdata->menu_item_wms_adjust, FALSE);
773    
774    /* -------------------- track submenu -------------------- */    /* -------------------- track submenu -------------------- */
775    
776    appdata->track.menu_track = item = gtk_menu_item_new_with_label(_("Track"));    appdata->track.submenu_track = item =
777    gtk_menu_append(GTK_MENU_SHELL(menu), item);      gtk_menu_item_new_with_mnemonic(_("_Track"));
778      gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
779    submenu = gtk_menu_new();    submenu = gtk_menu_new();
780      gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
781    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
782    
783    appdata->track.menu_item_import =    appdata->track.menu_item_track_import = menu_append_new_item(
784      item = gtk_menu_item_new_with_label( _("Import...") );      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_import), _("_Import"),
785    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      NULL, "<OSM2Go-Main>/Track/Import",
786    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_track_import),      0, 0, TRUE, FALSE, FALSE
787                     appdata);    );
788    
789    appdata->track.menu_item_export =    appdata->track.menu_item_track_export = menu_append_new_item(
790      item = gtk_menu_item_new_with_label( _("Export...") );      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_export), _("_Export"),
791    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      NULL, "<OSM2Go-Main>/Track/Export",
792    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_track_export),      0, 0, FALSE, FALSE, FALSE
793                     appdata);    );
794    
795    appdata->track.menu_item_clear =    appdata->track.menu_item_track_clear = menu_append_new_item(
796      item = gtk_menu_item_new_with_label( _("Clear") );      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_clear), _("_Clear"),
797    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      GTK_STOCK_CLEAR, "<OSM2Go-Main>/Track/Clear",
798    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_track_clear),      0, 0, FALSE, FALSE, FALSE
799                     appdata);    );
800    
801    appdata->track.menu_item_gps =  
802      item = gtk_check_menu_item_new_with_label( _("GPS") );    appdata->track.menu_item_track_enable_gps = menu_append_new_item(
803    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_enable_gps),_("_GPS enable"),
804    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_track_gps),      NULL, "<OSM2Go-Main>/Track/GPS",
805                     appdata);      GDK_g, GDK_CONTROL_MASK|GDK_SHIFT_MASK, TRUE, TRUE,
806        appdata->settings->enable_gps
807      );
808    
809      appdata->track.menu_item_track_follow_gps = menu_append_new_item(
810        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_follow_gps), _("GPS follow"),
811        NULL, "<OSM2Go-Main>/Track/Follow",
812        0, 0, appdata->settings->enable_gps, TRUE,
813        appdata->settings->follow_gps
814      );
815    
816    /* ------------------------------------------------------- */    /* ------------------------------------------------------- */
817    
818    gtk_menu_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());    gtk_menu_shell_append(GTK_MENU_SHELL(about_quit_items_menu),
819                            gtk_separator_menu_item_new());
820    
821      menu_append_new_item(
822        appdata, about_quit_items_menu, GTK_SIGNAL_FUNC(cb_menu_about), _("_About"),
823        GTK_STOCK_ABOUT, "<OSM2Go-Main>/About",
824        0, 0, TRUE, FALSE, FALSE
825      );
826    
827    item = gtk_menu_item_new_with_label( _("About...") );  #ifndef USE_HILDON
828    gtk_menu_append(GTK_MENU_SHELL(menu), item);    menu_append_new_item(
829    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_about), appdata);      appdata, about_quit_items_menu, GTK_SIGNAL_FUNC(cb_menu_quit), _("_Quit"),
830        GTK_STOCK_QUIT, "<OSM2Go-Main>/Quit",
831        0, 0, TRUE, FALSE, FALSE
832      );
833    #endif
834    
835    item = gtk_menu_item_new_with_label( _("Quit") );    gtk_window_add_accel_group(GTK_WINDOW(appdata->window), accel_grp);
   gtk_menu_append(GTK_MENU_SHELL(menu), item);  
   g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_quit), appdata);  
836    
837  #ifdef USE_HILDON  #ifdef USE_HILDON
838    hildon_window_set_menu(appdata->window, GTK_MENU(menu));    hildon_window_set_menu(appdata->window, GTK_MENU(menu));
839  #else  #else
840    /* attach ordinary gtk menu */    GtkWidget *menu_bar = menu;
841    GtkWidget *menu_bar = gtk_menu_bar_new();  
842    #ifndef UISPECIFIC_MAIN_MENU_IS_MENU_BAR
843      // we need to make one first
844      menu_bar = gtk_menu_bar_new();
845    
846    GtkWidget *root_menu = gtk_menu_item_new_with_label (_("Menu"));    GtkWidget *root_menu = gtk_menu_item_new_with_label (_("Menu"));
847    gtk_widget_show(root_menu);    gtk_widget_show(root_menu);
# Line 576  void menu_create(appdata_t *appdata) { Line 850  void menu_create(appdata_t *appdata) {
850    gtk_menu_item_set_submenu(GTK_MENU_ITEM (root_menu), menu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM (root_menu), menu);
851    
852    gtk_widget_show(menu_bar);    gtk_widget_show(menu_bar);
853    #endif //UISPECIFIC_MAIN_MENU_IS_MENU_BAR
854    
855    gtk_box_pack_start(GTK_BOX(appdata->vbox), menu_bar, 0, 0, 0);    gtk_box_pack_start(GTK_BOX(appdata->vbox), menu_bar, 0, 0, 0);
856  #endif  
857    #endif //USE_HILDON
858    }
859    #else // !defined(USE_HILDON) || (MAEMO_VERSION_MAJOR < 5)
860    
861    void submenu_entry(appdata_t *appdata, HildonAppMenu *menu,
862                       const char *label, const char *value,
863                       GtkSignalFunc activate_cb) {
864    
865    }
866    
867    typedef struct {
868      const char *label, *value;
869      gboolean enabled;
870      gboolean (*toggle)(appdata_t *appdata);
871      gulong offset;
872      GtkSignalFunc activate_cb;
873    } menu_entry_t;
874    
875    static gboolean no_icon_get_toggle(appdata_t *appdata) {
876      if(!appdata)           return FALSE;
877      if(!appdata->settings) return FALSE;
878      return appdata->settings->no_icons;
879    }
880    
881    /* create a HildonAppMenu */
882    static GtkWidget *app_menu_create(appdata_t *appdata, const menu_entry_t *menu_entries) {
883      HildonAppMenu *menu = HILDON_APP_MENU(hildon_app_menu_new());
884    
885      while(menu_entries->label) {
886        GtkWidget *button = NULL;
887    
888        if(!menu_entries->toggle) {
889          button = hildon_button_new_with_text(
890                HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH,
891                HILDON_BUTTON_ARRANGEMENT_VERTICAL,
892                _(menu_entries->label), menu_entries->value);
893          g_signal_connect_after(button, "clicked", menu_entries->activate_cb, appdata);
894        } else {
895          button = hildon_check_button_new(HILDON_SIZE_AUTO);
896          gtk_button_set_label(GTK_BUTTON(button), _(menu_entries->label));
897          hildon_check_button_set_active(HILDON_CHECK_BUTTON(button),
898                                         menu_entries->toggle(appdata));
899          g_signal_connect_after(button, "toggled", menu_entries->activate_cb, appdata);
900        }
901    
902        /* offset to GtkWidget pointer was given -> store pointer */
903        if(menu_entries->offset)
904          *(GtkWidget**)(((void*)appdata)+menu_entries->offset) = button;
905    
906        gtk_widget_set_sensitive(button, menu_entries->enabled);
907    
908        hildon_app_menu_append(menu, GTK_BUTTON(button));
909        menu_entries++;
910      }
911    
912      gtk_widget_show_all(GTK_WIDGET(menu));
913      return GTK_WIDGET(menu);
914    }
915    
916    /* the view submenu */
917    void on_submenu_view_clicked(GtkButton *button, appdata_t *appdata) {
918      /* draw a popup menu. */
919      hildon_app_menu_popup(HILDON_APP_MENU(appdata->submenu_view),
920                            GTK_WINDOW(appdata->window));
921    }
922    
923    void on_submenu_wms_clicked(GtkButton *button, appdata_t *appdata) {
924      /* draw a popup menu. */
925      hildon_app_menu_popup(HILDON_APP_MENU(appdata->submenu_wms),
926                            GTK_WINDOW(appdata->window));
927    }
928    
929    /* -- the view submenu -- */
930    #define APP_OFFSET(a)  offsetof(appdata_t, a)
931    #define SIMPLE_ENTRY(a,b)     { a, NULL, TRUE,   NULL, 0, G_CALLBACK(b) }
932    #define DISABLED_ENTRY(a,b,c) { a, NULL, FALSE,  NULL, APP_OFFSET(c), G_CALLBACK(b) }
933    #define LAST_ENTRY            { NULL, NULL, FALSE, NULL, 0, NULL }
934    
935    static const menu_entry_t submenu_view[] = {
936      SIMPLE_ENTRY("Zoom in",         cb_menu_zoomin),
937      SIMPLE_ENTRY("Zoom out",        cb_menu_zoomout),
938      /* --- */
939      SIMPLE_ENTRY("Style",           cb_menu_style),
940      /* --- */
941      SIMPLE_ENTRY("Normal details",  cb_menu_view_detail_normal),
942      SIMPLE_ENTRY("More details",    cb_menu_view_detail_inc),
943      SIMPLE_ENTRY("Less details",    cb_menu_view_detail_dec),
944      /* --- */
945      DISABLED_ENTRY("Hide selected", cb_menu_map_hide_sel, menu_item_map_hide_sel),
946      DISABLED_ENTRY("Show all",      cb_menu_map_show_all, menu_item_map_show_all),
947      /* --- */
948      { "No icons",       NULL, TRUE,  no_icon_get_toggle, 0, G_CALLBACK(cb_menu_map_no_icons) },
949    
950      LAST_ENTRY
951    };
952    
953    /* -- the wms submenu -- */
954    static const menu_entry_t submenu_wms[] = {
955      SIMPLE_ENTRY("Import",   cb_menu_wms_import),
956      DISABLED_ENTRY("Clear",  cb_menu_wms_clear, menu_item_wms_clear),
957      DISABLED_ENTRY("Adjust", cb_menu_wms_adjust, menu_item_wms_adjust),
958    
959      LAST_ENTRY
960    };
961    
962    void menu_create(appdata_t *appdata) {
963      GtkWidget *button;
964      HildonAppMenu *menu = HILDON_APP_MENU(hildon_app_menu_new());
965    
966      /* build submenus */
967      appdata->submenu_wms = app_menu_create(appdata, submenu_wms);
968      appdata->submenu_view = app_menu_create(appdata, submenu_view);
969    
970      /* ------- */
971      button = gtk_button_new_with_label(_("About"));
972      g_signal_connect_after(button, "clicked",
973                             G_CALLBACK(cb_menu_about), appdata);
974      hildon_app_menu_append(menu, GTK_BUTTON(button));
975    
976      button = gtk_button_new_with_label(_("View"));
977      g_signal_connect_after(button, "clicked",
978                             G_CALLBACK(on_submenu_view_clicked), appdata);
979      hildon_app_menu_append(menu, GTK_BUTTON(button));
980    
981      button = gtk_button_new_with_label(_("WMS"));
982      g_signal_connect_after(button, "clicked",
983                             G_CALLBACK(on_submenu_wms_clicked), appdata);
984      hildon_app_menu_append(menu, GTK_BUTTON(button));
985    
986    
987    
988      gtk_widget_show_all(GTK_WIDGET(menu));
989      hildon_window_set_app_menu(HILDON_WINDOW(appdata->window), menu);
990  }  }
991    #endif
992    
993  /********************* end of menu **********************/  /********************* end of menu **********************/
994    
995    #ifdef UISPECIFIC_MENU_HAS_ACCELS
996    #define ACCELS_FILE "accels"
997    
998    static void menu_accels_load(appdata_t *appdata) {
999      char *accels_file = g_strdup_printf("%s/" ACCELS_FILE,
1000                                          appdata->settings->base_path);
1001      gtk_accel_map_load(accels_file);
1002      g_free(accels_file);
1003    }
1004    
1005    static void menu_accels_save(appdata_t *appdata) {
1006      char *accels_file = g_strdup_printf("%s" ACCELS_FILE,
1007                                          appdata->settings->base_path);
1008      gtk_accel_map_save(accels_file);
1009      g_free(accels_file);
1010    }
1011    
1012    #endif
1013    
1014    
1015  void cleanup(appdata_t *appdata) {  void cleanup(appdata_t *appdata) {
1016    #ifdef UISPECIFIC_MENU_HAS_ACCELS
1017      menu_accels_save(appdata);
1018    #endif
1019    
1020    settings_save(appdata->settings);    settings_save(appdata->settings);
1021    
1022  #ifdef USE_HILDON  #ifdef USE_HILDON
# Line 627  void cleanup(appdata_t *appdata) { Line 1060  void cleanup(appdata_t *appdata) {
1060    
1061    project_free(appdata->project);    project_free(appdata->project);
1062    
1063      if(appdata->menu_item_map_undo)
1064        undo_free(appdata->undo.state);
1065    
1066    puts("everything is gone");    puts("everything is gone");
1067  }  }
1068    
# Line 642  gboolean on_window_key_press(GtkWidget * Line 1078  gboolean on_window_key_press(GtkWidget *
1078    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
1079    int handled = FALSE;    int handled = FALSE;
1080    
   //  printf("key event %d\n", event->keyval);  
   
1081    // the map handles some keys on its own ...    // the map handles some keys on its own ...
1082    switch(event->keyval) {    switch(event->keyval) {
 #ifdef USE_HILDON  
1083    
1084  #if 0  #if !defined(USE_HILDON) || (MAEMO_VERSION_MAJOR < 5)
1085    case HILDON_HARDKEY_SELECT:  #ifdef USE_HILDON
1086      handled = TRUE;      /* this is in fact a mapping to GDK_F6 */
     break;  
 #endif  
   
1087    case HILDON_HARDKEY_FULLSCREEN:    case HILDON_HARDKEY_FULLSCREEN:
1088      {  #else
1089        gboolean fullscreen = !gtk_check_menu_item_get_active(    case GDK_F11:
1090                 GTK_CHECK_MENU_ITEM(appdata->fullscreen_menu_item));  #endif
1091        if(!gtk_check_menu_item_get_active(
1092                 GTK_CHECK_MENU_ITEM(appdata->menu_item_view_fullscreen))) {
1093          gtk_window_fullscreen(GTK_WINDOW(appdata->window));
1094        gtk_check_menu_item_set_active(        gtk_check_menu_item_set_active(
1095                 GTK_CHECK_MENU_ITEM(appdata->fullscreen_menu_item), fullscreen);               GTK_CHECK_MENU_ITEM(appdata->menu_item_view_fullscreen), TRUE);
1096          } else {
       if(fullscreen)  
         gtk_window_fullscreen(GTK_WINDOW(appdata->window));  
       else  
1097          gtk_window_unfullscreen(GTK_WINDOW(appdata->window));          gtk_window_unfullscreen(GTK_WINDOW(appdata->window));
1098            gtk_check_menu_item_set_active(
1099        handled = TRUE;               GTK_CHECK_MENU_ITEM(appdata->menu_item_view_fullscreen), FALSE);
1100      }        }
1101    
1102        handled = TRUE;
1103      break;      break;
1104  #endif  #endif
1105    }    }
# Line 697  int main(int argc, char *argv[]) { Line 1129  int main(int argc, char *argv[]) {
1129    
1130    g_thread_init(NULL);    g_thread_init(NULL);
1131    
   gps_init(&appdata);  
   
1132    gtk_init (&argc, &argv);    gtk_init (&argc, &argv);
1133    
1134      gps_init(&appdata);
1135    
1136  #ifdef USE_HILDON  #ifdef USE_HILDON
1137    printf("Installing osso context for \"org.harbaum." PACKAGE "\"\n");    printf("Installing osso context for \"org.harbaum." PACKAGE "\"\n");
1138    appdata.osso_context = osso_initialize("org.harbaum."PACKAGE,    appdata.osso_context = osso_initialize("org.harbaum."PACKAGE,
# Line 741  int main(int argc, char *argv[]) { Line 1173  int main(int argc, char *argv[]) {
1173    
1174    appdata.vbox = gtk_vbox_new(FALSE,0);    appdata.vbox = gtk_vbox_new(FALSE,0);
1175    menu_create(&appdata);    menu_create(&appdata);
1176    #ifdef UISPECIFIC_MENU_HAS_ACCELS
1177      menu_accels_load(&appdata);
1178    #endif
1179    
1180    /* ----------------------- setup main window ---------------- */    /* ----------------------- setup main window ---------------- */
1181    
# Line 750  int main(int argc, char *argv[]) { Line 1185  int main(int argc, char *argv[]) {
1185  #ifdef PORTRAIT  #ifdef PORTRAIT
1186    gtk_box_pack_start(GTK_BOX(vbox), iconbar_new(&appdata), FALSE, FALSE, 0);    gtk_box_pack_start(GTK_BOX(vbox), iconbar_new(&appdata), FALSE, FALSE, 0);
1187  #endif  #endif
1188    gtk_box_pack_start(GTK_BOX(vbox), map_new(&appdata), TRUE, TRUE, 0);  
1189      /* generate main map view */
1190      GtkWidget *map = map_new(&appdata);
1191      if(!map) {
1192        cleanup(&appdata);
1193        return -1;
1194      }
1195    
1196    #if 0  // another test overlay
1197      {
1198        GtkWidget *fixed = gtk_fixed_new();
1199    
1200        gtk_fixed_put(GTK_FIXED(fixed), gtk_label_new("Nase"), 0,0);
1201        gtk_fixed_put(GTK_FIXED(fixed), map, 0,0);
1202    
1203        gtk_box_pack_start(GTK_BOX(vbox), fixed, TRUE, TRUE, 0);
1204      }
1205    #else
1206      gtk_box_pack_start(GTK_BOX(vbox), map, TRUE, TRUE, 0);
1207    #endif
1208    
1209    gtk_box_pack_start(GTK_BOX(vbox), statusbar_new(&appdata), FALSE, FALSE, 0);    gtk_box_pack_start(GTK_BOX(vbox), statusbar_new(&appdata), FALSE, FALSE, 0);
1210    
1211  #ifndef PORTRAIT  #ifndef PORTRAIT
1212    gtk_box_pack_start(GTK_BOX(hbox), iconbar_new(&appdata), FALSE, FALSE, 0);    gtk_box_pack_start(GTK_BOX(hbox), iconbar_new(&appdata), FALSE, FALSE, 0);
1213  #endif  #endif
   gtk_box_pack_start(GTK_BOX(hbox), gtk_vseparator_new(), FALSE, FALSE, 0);  
1214    gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);    gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
1215    
1216    gtk_box_pack_start(GTK_BOX(appdata.vbox), hbox, TRUE, TRUE, 0);    gtk_box_pack_start(GTK_BOX(appdata.vbox), hbox, TRUE, TRUE, 0);
# Line 769  int main(int argc, char *argv[]) { Line 1223  int main(int argc, char *argv[]) {
1223    
1224    /* let gtk do its thing before loading the data, */    /* let gtk do its thing before loading the data, */
1225    /* so the user sees something */    /* so the user sees something */
1226    while(gtk_events_pending()) {    while(gtk_events_pending())
     putchar('.');  
1227      gtk_main_iteration();      gtk_main_iteration();
   }  
1228    
1229    /* load project if one is specified in the settings */    /* load project if one is specified in the settings */
1230    if(appdata.settings->project)    if(appdata.settings->project)
# Line 780  int main(int argc, char *argv[]) { Line 1232  int main(int argc, char *argv[]) {
1232    
1233    main_ui_enable(&appdata);    main_ui_enable(&appdata);
1234    
1235    /* ------------ jump into main loop ---------------- */    /* start GPS if enabled by config */
1236      if(appdata.settings && appdata.settings->enable_gps)
1237        track_enable_gps(&appdata, TRUE);
1238    
1239      /* again let the ui do its thing */
1240      while(gtk_events_pending())
1241        gtk_main_iteration();
1242    
1243    #if 0  // test overlay
1244      {
1245        GtkWidget *overlay = gtk_window_new(GTK_WINDOW_POPUP);
1246        gtk_window_set_default_size(GTK_WINDOW(overlay), 40, 20);
1247        gtk_window_set_transient_for(GTK_WINDOW(overlay), GTK_WINDOW(appdata.window));
1248        gtk_window_set_keep_above(GTK_WINDOW(overlay), TRUE);
1249        gtk_window_set_destroy_with_parent(GTK_WINDOW(overlay), TRUE);
1250        gtk_window_set_position(GTK_WINDOW(overlay), GTK_WIN_POS_CENTER_ON_PARENT);
1251        gtk_window_set_decorated(GTK_WINDOW(overlay), TRUE);
1252    
1253        /* add some zoom buttons for testing */
1254        GtkWidget *hbox = gtk_hbox_new(TRUE, 0);
1255        gtk_box_pack_start_defaults(GTK_BOX(hbox), gtk_button_new_with_label("+"));
1256        gtk_box_pack_start_defaults(GTK_BOX(hbox), gtk_button_new_with_label("-"));
1257        gtk_container_add(GTK_CONTAINER(overlay), hbox);
1258    
1259        gtk_widget_show_all(overlay);
1260      }
1261    #endif
1262    
1263      /* start to interact with the user now that the gui is running */
1264      if(appdata.settings->first_run_demo) {
1265        messagef(GTK_WIDGET(appdata.window), _("Welcome to OSM2Go"),
1266                 _("This is the first time you run OSM2Go. "
1267                   "A demo project has been loaded to get you "
1268                   "started. You can play around with this demo as much "
1269                   "as you like. However, you cannot upload or download "
1270                   "the demo project.\n\n"
1271                   "In order to start working on real data you'll have "
1272                   "to setup a new project and enter your OSM user name "
1273                   "and password. You'll then be able to download the "
1274                   "latest data from OSM and upload your changes into "
1275                   "the OSM main database."
1276                   ));
1277      }
1278    
1279      /* ------------ jump into main loop ---------------- */
1280    gtk_main();    gtk_main();
1281    
1282    puts("gtk_main() left");    puts("gtk_main() left");
1283    
1284    track_save(appdata.project, appdata.track.track);    track_save(appdata.project, appdata.track.track);
1285      track_clear(&appdata, appdata.track.track);
1286      appdata.track.track = NULL;
1287    
1288    /* save a diff if there are dirty entries */    /* save a diff if there are dirty entries */
1289    diff_save(appdata.project, appdata.osm);    diff_save(appdata.project, appdata.osm);
# Line 795  int main(int argc, char *argv[]) { Line 1292  int main(int argc, char *argv[]) {
1292    
1293    return 0;    return 0;
1294  }  }
1295    
1296    // vim:et:ts=8:sw=2:sts=2:ai
Legend:
Removed from v.15  
changed lines
  Added in v.189