Diff of /trunk/src/main.c

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

revision 24 by harbaum, Sun Dec 21 11:49:35 2008 UTC revision 178 by harbaum, Tue Jun 16 15:27:37 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 22  Line 24 
24  #include <gdk/gdkkeysyms.h>  #include <gdk/gdkkeysyms.h>
25    
26  #include "appdata.h"  #include "appdata.h"
27    #include "banner.h"
28    
29  /* disable/enable main screen control dependant on presence of open project */  /* disable/enable main screen control dependant on presence of open project */
30  static void main_ui_enable(appdata_t *appdata) {  static void main_ui_enable(appdata_t *appdata) {
# Line 33  static void main_ui_enable(appdata_t *ap Line 36  static void main_ui_enable(appdata_t *ap
36      map_action_cancel(appdata);      map_action_cancel(appdata);
37    
38    /* ---- set project name as window title ----- */    /* ---- set project name as window title ----- */
39  #ifndef USE_HILDON  #if defined(USE_HILDON) && MAEMO_VERSION_MAJOR < 5
40      if(project_valid)
41        gtk_window_set_title(GTK_WINDOW(appdata->window), appdata->project->name);
42      else
43        gtk_window_set_title(GTK_WINDOW(appdata->window), "");
44    #else
45    char *str = NULL;    char *str = NULL;
46    if(project_valid)    if(project_valid)
47      str = g_strdup_printf("OSM2Go - %s", appdata->project->name);      str = g_strdup_printf("OSM2Go - %s", appdata->project->name);
# Line 42  static void main_ui_enable(appdata_t *ap Line 50  static void main_ui_enable(appdata_t *ap
50    
51    gtk_window_set_title(GTK_WINDOW(appdata->window), str);    gtk_window_set_title(GTK_WINDOW(appdata->window), str);
52    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), "");  
53  #endif  #endif
54    
55    if(appdata->iconbar && appdata->iconbar->toolbar)    if(appdata->iconbar && appdata->iconbar->toolbar)
# Line 55  static void main_ui_enable(appdata_t *ap Line 58  static void main_ui_enable(appdata_t *ap
58    /* disable all menu entries related to map */    /* disable all menu entries related to map */
59    gtk_widget_set_sensitive(appdata->menu_osm, project_valid);    gtk_widget_set_sensitive(appdata->menu_osm, project_valid);
60    gtk_widget_set_sensitive(appdata->menu_item_osm_upload, osm_valid);    gtk_widget_set_sensitive(appdata->menu_item_osm_upload, osm_valid);
61    gtk_widget_set_sensitive(appdata->menu_item_osm_diff, osm_valid);    if(appdata->menu_item_osm_undo)
62        gtk_widget_set_sensitive(appdata->menu_item_osm_undo, osm_valid);
63      gtk_widget_set_sensitive(appdata->menu_item_osm_save_changes, osm_valid);
64    gtk_widget_set_sensitive(appdata->menu_item_osm_undo_changes, osm_valid);    gtk_widget_set_sensitive(appdata->menu_item_osm_undo_changes, osm_valid);
65      gtk_widget_set_sensitive(appdata->menu_item_osm_relations, osm_valid);
66    gtk_widget_set_sensitive(appdata->track.menu_track, osm_valid);    gtk_widget_set_sensitive(appdata->track.menu_track, osm_valid);
67    gtk_widget_set_sensitive(appdata->menu_view, osm_valid);    gtk_widget_set_sensitive(appdata->menu_view, osm_valid);
68    gtk_widget_set_sensitive(appdata->menu_wms, osm_valid);    gtk_widget_set_sensitive(appdata->menu_wms, osm_valid);
# Line 69  static void main_ui_enable(appdata_t *ap Line 75  static void main_ui_enable(appdata_t *ap
75    
76  /******************** begin of menu *********************/  /******************** begin of menu *********************/
77    
 #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  
   
78  static void  static void
79  cb_menu_project_open(GtkWidget *window, gpointer data) {  cb_menu_project_open(GtkMenuItem *item, gpointer data) {
80    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
81    project_load(appdata, NULL);    project_load(appdata, NULL);
82    main_ui_enable(appdata);    main_ui_enable(appdata);
83  }  }
84    
85  static void  static void
86  cb_menu_project_close(GtkWidget *window, gpointer data) {  cb_menu_project_close(GtkMenuItem *item, gpointer data) {
87    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
88    project_close(appdata);    project_close(appdata);
89    main_ui_enable(appdata);    main_ui_enable(appdata);
90  }  }
91    
92  static void  static void
93  cb_menu_about(GtkWidget *window, gpointer data) {  cb_menu_about(GtkMenuItem *item, gpointer data) {
94    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"));  
95    
96    const gchar *authors[] = {    const gchar *authors[] = {
97      "Till Harbaum <till@harbaum.org>",      "Till Harbaum <till@harbaum.org>",
98      "Andrew Chadwick",      "Andrew Chadwick <andrewc-osm2go@piffle.org>",
99      NULL };      NULL };
100    
101    gtk_about_dialog_set_authors(about, authors);    const gchar *artists[] = {
102        "Andrew Zhilin <drew.zhilin@gmail.com>",
103    gtk_about_dialog_set_website(about,      NULL };
        _("http://www.harbaum.org/till/maemo"));  
   
   gtk_about_dialog_set_comments(about,  
        _("Mobile OSM Editor"));  
104    
105    gtk_widget_show_all(GTK_WIDGET(about));    gtk_show_about_dialog(GTK_WINDOW(appdata->window),
106    gtk_dialog_run(GTK_DIALOG(about));                          "name", "OSM2Go",
107    gtk_widget_destroy(GTK_WIDGET(about));                          "version", VERSION,
108                            "copyright", _("Copyright 2008-2009"),
109                            "authors", authors,
110                            "artists", artists,
111                            "website", _("http://www.harbaum.org/till/maemo"),
112                            "comments", _("Mobile OSM Editor"),
113                            NULL);
114  }  }
115    
116  void on_window_destroy (GtkWidget *widget, gpointer data);  void on_window_destroy (GtkWidget *widget, gpointer data);
117    
118  static void  static void
119  cb_menu_quit(GtkWidget *window, gpointer data) {  cb_menu_quit(GtkMenuItem *item, gpointer data) {
120    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
121    gtk_widget_destroy(GTK_WIDGET(appdata->window));    gtk_widget_destroy(GTK_WIDGET(appdata->window));
122  }  }
123    
124  static void  static void
125  cb_menu_upload(GtkWidget *window, gpointer data) {  cb_menu_upload(GtkMenuItem *item, gpointer data) {
126    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
127    if(!appdata->osm || !appdata->project) return;    if(!appdata->osm || !appdata->project) return;
128    
129      if(project_check_demo(appdata->window, appdata->project))
130        return;
131    
132    osm_upload(appdata, appdata->osm, appdata->project);    osm_upload(appdata, appdata->osm, appdata->project);
133  }  }
134    
135  static void  static void
136  cb_menu_download(GtkWidget *window, gpointer data) {  cb_menu_download(GtkMenuItem *item, gpointer data) {
137    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
138    if(!appdata->project) return;    if(!appdata->project) return;
139    
140      if(project_check_demo(appdata->window, appdata->project))
141        return;
142    
143    /* if we have valid osm data loaded: save state first */    /* if we have valid osm data loaded: save state first */
144    if(appdata->osm) {    if(appdata->osm) {
145      /* 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 154  cb_menu_download(GtkWidget *window, gpoi Line 151  cb_menu_download(GtkWidget *window, gpoi
151    }    }
152    
153    // download    // download
154    if(osm_download(GTK_WIDGET(appdata->window), appdata->project)) {    if(osm_download(GTK_WIDGET(appdata->window), appdata->settings,
155      appdata->osm = osm_parse(appdata->project->osm);                    appdata->project)) {
156        banner_busy_start(appdata, 1, "Redrawing");
157        appdata->osm = osm_parse(appdata->project->path, appdata->project->osm);
158      diff_restore(appdata, appdata->project, appdata->osm);      diff_restore(appdata, appdata->project, appdata->osm);
159      map_paint(appdata);      map_paint(appdata);
160        banner_busy_stop(appdata); //"Redrawing"
161    }    }
162    
163    main_ui_enable(appdata);    main_ui_enable(appdata);
164  }  }
165    
166  static void  static void
167  cb_menu_wms_import(GtkWidget *window, gpointer data) {  cb_menu_wms_import(GtkMenuItem *item, gpointer data) {
168    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
169    wms_import(appdata);    wms_import(appdata);
170  }  }
171    
172  static void  static void
173  cb_menu_wms_clear(GtkWidget *window, gpointer data) {  cb_menu_wms_clear(GtkMenuItem *item, gpointer data) {
174    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
175    wms_remove(appdata);    wms_remove(appdata);
176  }  }
177    
178  static void  static void
179  cb_menu_wms_adjust(GtkWidget *window, gpointer data) {  cb_menu_wms_adjust(GtkMenuItem *item, gpointer data) {
180    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
181    map_action_set(appdata, MAP_ACTION_BG_ADJUST);    map_action_set(appdata, MAP_ACTION_BG_ADJUST);
182  }  }
# Line 184  cb_menu_wms_adjust(GtkWidget *window, gp Line 184  cb_menu_wms_adjust(GtkWidget *window, gp
184  /* ----------- hide objects for performance reasons ----------- */  /* ----------- hide objects for performance reasons ----------- */
185    
186  static void  static void
187  cb_menu_map_hide_sel(GtkWidget *window, gpointer data) {  cb_menu_map_hide_sel(GtkMenuItem *item, gpointer data) {
188    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
189    map_hide_selected(appdata);    map_hide_selected(appdata);
190  }  }
191    
192  static void  static void
193  cb_menu_map_show_all(GtkWidget *window, gpointer data) {  cb_menu_map_show_all(GtkMenuItem *item, gpointer data) {
194    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
195    map_show_all(appdata);    map_show_all(appdata);
196  }  }
# Line 199  cb_menu_map_show_all(GtkWidget *window, Line 199  cb_menu_map_show_all(GtkWidget *window,
199    
200  #if 1  // mainly for testing  #if 1  // mainly for testing
201  static void  static void
202  cb_menu_redraw(GtkWidget *window, gpointer data) {  cb_menu_redraw(GtkMenuItem *item, gpointer data) {
203    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
204    
205    /* redraw the entire map by destroying all map items and redrawing them */    /* redraw the entire map by destroying all map items and redrawing them */
206      banner_busy_start(appdata, 1, "Redrawing");
207    track_save(appdata->project, appdata->track.track);    track_save(appdata->project, appdata->track.track);
208    diff_save(appdata->project, appdata->osm);    diff_save(appdata->project, appdata->osm);
209    map_clear(appdata, MAP_LAYER_ALL);    map_clear(appdata, MAP_LAYER_ALL);
210    osm_free(&appdata->icon, appdata->osm);    osm_free(&appdata->icon, appdata->osm);
211    
212    appdata->osm = osm_parse(appdata->project->osm);    appdata->osm = osm_parse(appdata->project->path, appdata->project->osm);
213    diff_restore(appdata, appdata->project, appdata->osm);    diff_restore(appdata, appdata->project, appdata->osm);
214    map_paint(appdata);    map_paint(appdata);
215    
# Line 217  cb_menu_redraw(GtkWidget *window, gpoint Line 218  cb_menu_redraw(GtkWidget *window, gpoint
218      map_track_draw(appdata->map, appdata->track.track);      map_track_draw(appdata->map, appdata->track.track);
219    
220    wms_load(appdata);    wms_load(appdata);
221      banner_busy_stop(appdata); //"Redrawing"
222  }  }
223  #endif  #endif
224    
225  static void  static void
226  cb_menu_style(GtkWidget *widget, gpointer data) {  cb_menu_map_no_icons(GtkCheckMenuItem *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);    banner_busy_start(appdata, 1, "Redrawing");
230      map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);
231      appdata->settings->no_icons = gtk_check_menu_item_get_active(item);
232      map_paint(appdata);
233      banner_busy_stop(appdata); //"Redrawing"
234  }  }
235    
236  static void  static void
237  cb_menu_map_no_icons(GtkWidget *widget, gpointer data) {  cb_menu_map_no_antialias(GtkCheckMenuItem *item, gpointer data) {
238    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
239    
240      banner_busy_start(appdata, 1, "Redrawing");
241    map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);    map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);
242    appdata->settings->no_icons =    appdata->settings->no_antialias = gtk_check_menu_item_get_active(item);
     gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget));  
243    map_paint(appdata);    map_paint(appdata);
244      banner_busy_stop(appdata); //"Redrawing"
245  }  }
246    
247  static void  static void
248  cb_menu_map_no_antialias(GtkWidget *widget, gpointer data) {  cb_menu_style(GtkMenuItem *item, gpointer data) {
249    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
250    
251    map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);    style_select(GTK_WIDGET(appdata->window), appdata);
   appdata->settings->no_antialias =  
     gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget));  
   map_paint(appdata);  
252  }  }
253    
254  static void  static void
255  cb_menu_save_changes(GtkWidget *widget, gpointer data) {  cb_menu_undo(GtkMenuItem *item, gpointer data) {
256      appdata_t *appdata = (appdata_t*)data;
257    
258      undo(appdata);
259    
260      // the banner will be displayed from within undo with more details
261    }
262    
263    static void
264    cb_menu_save_changes(GtkMenuItem *item, gpointer data) {
265    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
266    
267    diff_save(appdata->project, appdata->osm);    diff_save(appdata->project, appdata->osm);
268    statusbar_set(appdata, _("Saved all changes made "    banner_show_info(appdata, _("Saved local changes"));
                            "to this project so far"), FALSE);  
269  }  }
270    
271  static void  static void
272  cb_menu_undo_changes(GtkWidget *widget, gpointer data) {  cb_menu_undo_changes(GtkMenuItem *item, gpointer data) {
273    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
274    
275    if(!yes_no_f(GTK_WIDGET(appdata->window), NULL, 0, 0,    if(!yes_no_f(GTK_WIDGET(appdata->window), NULL, 0, 0,
276                 _("Undo all changes?"),                 _("Discard local changes?"),
277                 _("Do you really want to undo all your changes "                 _("Throw away all the changes you've not "
278                   "not uploaded so far? This cannot be undone!")))                   "uploaded yet? This can't be undone.")))
279      return;      return;
280    
281      banner_busy_start(appdata, 1, _("Redrawing"));
282    map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);    map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);
283    osm_free(&appdata->icon, appdata->osm);    osm_free(&appdata->icon, appdata->osm);
284    diff_remove(appdata->project);    diff_remove(appdata->project);
285    appdata->osm = osm_parse(appdata->project->osm);    appdata->osm = osm_parse(appdata->project->path, appdata->project->osm);
286    map_paint(appdata);    map_paint(appdata);
287      banner_busy_stop(appdata);  //"Redrawing"
288    
289    statusbar_set(appdata, _("All changes made "    banner_show_info(appdata, _("Discarded local changes"));
290                             "so far have been reset"), FALSE);  }
291    
292    static void
293    cb_menu_osm_relations(GtkMenuItem *item, gpointer data) {
294      relation_list((appdata_t*)data);
295  }  }
296    
297    #if !defined(USE_HILDON) || (MAEMO_VERSION_MAJOR < 5)
298  static void  static void
299  cb_menu_fullscreen(GtkWidget *widget, gpointer data) {  cb_menu_fullscreen(GtkCheckMenuItem *item, gpointer data) {
300    appdata_t *appdata = (appdata_t *)data;    appdata_t *appdata = (appdata_t *)data;
301    
302    if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget)))    if(gtk_check_menu_item_get_active(item))
303      gtk_window_fullscreen(GTK_WINDOW(appdata->window));      gtk_window_fullscreen(GTK_WINDOW(appdata->window));
304    else    else
305      gtk_window_unfullscreen(GTK_WINDOW(appdata->window));      gtk_window_unfullscreen(GTK_WINDOW(appdata->window));
306  }  }
307    #endif
308    
309  static void  static void
310  cb_menu_zoomin(GtkWidget *widget, appdata_t *appdata) {  cb_menu_zoomin(GtkMenuItem *item, appdata_t *appdata) {
311    if(!appdata || !appdata->map) return;    if(!appdata || !appdata->map) return;
312    
313    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_zoomin(GtkWidget *widget, appdat Line 315  cb_menu_zoomin(GtkWidget *widget, appdat
315  }  }
316    
317  static void  static void
318  cb_menu_zoomout(GtkWidget *widget, appdata_t *appdata) {  cb_menu_zoomout(GtkMenuItem *item, appdata_t *appdata) {
319    if(!appdata || !appdata->map) return;    if(!appdata || !appdata->map) return;
320    
321    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 303  cb_menu_zoomout(GtkWidget *widget, appda Line 323  cb_menu_zoomout(GtkWidget *widget, appda
323  }  }
324    
325  static void  static void
326  cb_menu_track_import(GtkWidget *window, appdata_t *appdata) {  cb_menu_view_detail_inc(GtkMenuItem *item, gpointer data) {
327      appdata_t *appdata = (appdata_t*)data;
328    
329      printf("detail level increase\n");
330      map_detail_increase(appdata->map);
331    }
332    
333    static void
334    cb_menu_view_detail_normal(GtkMenuItem *item, gpointer data) {
335      appdata_t *appdata = (appdata_t*)data;
336    
337      printf("detail level normal\n");
338      map_detail_normal(appdata->map);
339    }
340    
341    static void
342    cb_menu_view_detail_dec(GtkMenuItem *item, gpointer data) {
343      appdata_t *appdata = (appdata_t*)data;
344    
345      printf("detail level decrease\n");
346      map_detail_decrease(appdata->map);
347    }
348    
349    static void
350    cb_menu_track_import(GtkMenuItem *item, appdata_t *appdata) {
351      g_assert(appdata->settings);
352    
353    /* open a file selector */    /* open a file selector */
354    GtkWidget *dialog;    GtkWidget *dialog;
# Line 320  cb_menu_track_import(GtkWidget *window, Line 365  cb_menu_track_import(GtkWidget *window,
365                          NULL);                          NULL);
366  #endif  #endif
367    
368    /* use path if one is present */    if(appdata->settings->track_path) {
369    if(appdata->track.import_path)      if(!g_file_test(appdata->settings->track_path, G_FILE_TEST_EXISTS)) {
370      gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),        char *last_sep = strrchr(appdata->settings->track_path, '/');
371                                          appdata->track.import_path);        if(last_sep) {
372            *last_sep = 0;  // seperate path from file
373    
374            /* the user just created a new document */
375            gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
376                                        appdata->settings->track_path);
377            gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog),
378                                              last_sep+1);
379    
380            /* restore full filename */
381            *last_sep = '/';
382          }
383        } else
384          gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),
385                                        appdata->settings->track_path);
386      }
387    
388    gtk_widget_show_all (GTK_WIDGET(dialog));    gtk_widget_show_all (GTK_WIDGET(dialog));
389    if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_FM_OK) {    if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_FM_OK) {
390      char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));      char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
391    
392      /* load a track */      /* load a track */
393      track_do(appdata, TRACK_IMPORT, filename);      appdata->track.track = track_import(appdata, filename);
394      if(appdata->track.track) {      if(appdata->track.track) {
395          if(appdata->settings->track_path) g_free(appdata->settings->track_path);
396        /* 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 = '/';  
       }  
397      }      }
398      g_free (filename);      g_free (filename);
399    }    }
# Line 352  cb_menu_track_import(GtkWidget *window, Line 402  cb_menu_track_import(GtkWidget *window,
402  }  }
403    
404  static void  static void
405  cb_menu_track_gps(GtkWidget *window, gpointer data) {  cb_menu_track_enable_gps(GtkMenuItem *item, gpointer data) {
406    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
407    
408    if(gtk_check_menu_item_get_active(    if(gtk_check_menu_item_get_active(
409      GTK_CHECK_MENU_ITEM(appdata->track.menu_item_gps))) {      GTK_CHECK_MENU_ITEM(appdata->track.menu_item_enable_gps))) {
410      track_do(appdata, TRACK_GPS, NULL);      track_enable_gps(appdata, TRUE);
411    } else {    } else
412      track_do(appdata, TRACK_NONE, NULL);      track_enable_gps(appdata, FALSE);
   }  
413  }  }
414    
415    
416  static void  static void
417  cb_menu_track_export(GtkWidget *window, gpointer data) {  cb_menu_track_follow_gps(GtkMenuItem *item, gpointer data) {
418    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
419    messagef(GTK_WIDGET(appdata->window), _("NIY"),  
420             _("Track export is not yet supported."));    if(gtk_check_menu_item_get_active(
421        GTK_CHECK_MENU_ITEM(appdata->track.menu_item_follow_gps))) {
422        appdata->settings->follow_gps = TRUE;
423      } else
424        appdata->settings->follow_gps = FALSE;
425  }  }
426    
427    
428  static void  static void
429  cb_menu_track_clear(GtkWidget *window, gpointer data) {  cb_menu_track_export(GtkMenuItem *item, appdata_t *appdata) {
430      g_assert(appdata->settings);
431    
432      /* open a file selector */
433      GtkWidget *dialog;
434    
435    #ifdef USE_HILDON
436      dialog = hildon_file_chooser_dialog_new(GTK_WINDOW(appdata->window),
437                                              GTK_FILE_CHOOSER_ACTION_SAVE);
438    #else
439      dialog = gtk_file_chooser_dialog_new(_("Export track file"),
440                                           GTK_WINDOW(appdata->window),
441                                           GTK_FILE_CHOOSER_ACTION_SAVE,
442                                           GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
443                                           GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
444                                           NULL);
445    #endif
446    
447      printf("set filename <%s>\n", appdata->settings->track_path);
448    
449      if(appdata->settings->track_path) {
450        if(!g_file_test(appdata->settings->track_path, G_FILE_TEST_EXISTS)) {
451          char *last_sep = strrchr(appdata->settings->track_path, '/');
452          if(last_sep) {
453            *last_sep = 0;  // seperate path from file
454    
455            /* the user just created a new document */
456            gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
457                                                appdata->settings->track_path);
458            gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog),
459                                              last_sep+1);
460    
461            /* restore full filename */
462            *last_sep = '/';
463          }
464        } else
465          gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),
466                                        appdata->settings->track_path);
467      }
468    
469      if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_FM_OK) {
470        gchar *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
471        if(filename) {
472          printf("export to %s\n", filename);
473    
474          if(!g_file_test(filename, G_FILE_TEST_EXISTS) ||
475             yes_no_f(dialog, appdata, MISC_AGAIN_ID_EXPORT_OVERWRITE,
476                      MISC_AGAIN_FLAG_DONT_SAVE_NO,
477                      "Overwrite existing file",
478                      "The file already exists. "
479                      "Do you really want to replace it?")) {
480            if(appdata->settings->track_path)
481              g_free(appdata->settings->track_path);
482            appdata->settings->track_path = g_strdup(filename);
483    
484            track_export(appdata, filename);
485          }
486        }
487      }
488    
489      gtk_widget_destroy (dialog);
490    }
491    
492    
493    static void
494    cb_menu_track_clear(GtkMenuItem *item, gpointer data) {
495    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
496    track_do(appdata, TRACK_NONE, NULL);    track_clear(appdata, appdata->track.track);
497      appdata->track.track = NULL;
498    }
499    
500    
501    
502    
503    /*
504     *  Platform-specific UI tweaks.
505     */
506    
507    
508    #ifndef USE_HILDON
509    #ifdef PORTRAIT
510    
511    // Portrait mode, for openmoko-like systems
512    #define uispecific_main_menu_new gtk_menu_new
513    
514    #else
515    
516    // Regular desktop builds
517    #define uispecific_main_menu_new gtk_menu_bar_new
518    #define UISPECIFIC_MAIN_MENU_IS_MENU_BAR
519    #define UISPECIFIC_MENU_HAS_ICONS
520    #define UISPECIFIC_MENU_HAS_ACCELS
521    
522    #endif //PORTRAIT
523    #else//USE_HILDON
524    
525    // Maemo/Hildon builds
526    #define uispecific_main_menu_new gtk_menu_new
527    
528    #endif
529    
530    
531    
532    // Half-arsed slapdash common menu item constructor. Let's use GtkBuilder
533    // instead so we have some flexibility.
534    
535    static GtkWidget *
536    menu_append_new_item(appdata_t *appdata,
537                         GtkWidget *menu_shell,
538                         GtkSignalFunc activate_cb,
539                         char *label,
540                         const gchar *icon_name, // stock id or name for icon_load
541                                        // overridden by label, accels, icon_name
542                         const gchar *accel_path,
543                         guint accel_key,      // from gdk/gdkkeysyms.h
544                         GdkModifierType accel_mods, // e.g. GDK_CONTROL_MASK
545                         gboolean enabled,
546                         gboolean is_check, gboolean check_status)
547    {
548      GtkWidget *item = NULL;
549      GtkWidget *image = NULL;
550    
551      gboolean stock_item_known = FALSE;
552      GtkStockItem stock_item;
553      if (icon_name != NULL) {
554        stock_item_known = gtk_stock_lookup(icon_name, &stock_item);
555      }
556    
557      // Icons
558    #ifndef UISPECIFIC_MENU_HAS_ICONS
559      item = is_check ? gtk_check_menu_item_new_with_mnemonic (label)
560                      : gtk_menu_item_new_with_mnemonic       (label);
561    #else
562      if (is_check) {
563        item = gtk_check_menu_item_new_with_mnemonic (label);
564      }
565      else if (!stock_item_known) {
566        GdkPixbuf *pbuf = icon_load(&appdata->icon, icon_name);
567        if (pbuf) {
568          image = gtk_image_new_from_pixbuf(pbuf);
569        }
570        if (image) {
571          item = gtk_image_menu_item_new_with_mnemonic(label);
572          gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
573        }
574        else {
575          item = gtk_menu_item_new_with_mnemonic(label);
576        }
577      }
578      else {
579        item = gtk_image_menu_item_new_with_mnemonic(label);
580        image = gtk_image_new_from_stock(icon_name, GTK_ICON_SIZE_MENU);
581        gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
582      }
583    #endif
584    
585    #ifdef UISPECIFIC_MENU_HAS_ACCELS
586      // Accelerators
587      // Default
588      if (accel_path != NULL) {
589        gtk_menu_item_set_accel_path(GTK_MENU_ITEM(item), accel_path);
590        if (accel_key != 0) {
591          gtk_accel_map_add_entry( accel_path, accel_key, accel_mods );
592        }
593        else if (stock_item_known) {
594          gtk_accel_map_add_entry( accel_path, stock_item.keyval,
595                                   stock_item.modifier );
596        }
597      }
598    #endif
599    
600      gtk_menu_shell_append(GTK_MENU_SHELL(menu_shell), GTK_WIDGET(item));
601      gtk_widget_set_sensitive(GTK_WIDGET(item), enabled);
602      if (is_check)
603        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), check_status);
604    
605      g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(activate_cb),
606                       appdata);
607      return item;
608  }  }
609    
610    
611  void menu_create(appdata_t *appdata) {  void menu_create(appdata_t *appdata) {
612    GtkWidget *menu, *item, *submenu;    GtkWidget *menu, *item, *submenu;
613    menu = gtk_menu_new();    GtkWidget *about_quit_items_menu;
614    
615      if (g_module_supported()) {
616        printf("*** can use GModule: consider using GtkUIManager / GtkBuilder\n");
617      }
618    
619      menu = uispecific_main_menu_new();
620      about_quit_items_menu = menu;
621    
622    /* -------------------- Project submenu -------------------- */    /* -------------------- Project submenu -------------------- */
623    
624    item = gtk_menu_item_new_with_label( _("Project") );    GtkAccelGroup *accel_grp = gtk_accel_group_new();
625    gtk_menu_append(GTK_MENU_SHELL(menu), item);    item = gtk_menu_item_new_with_mnemonic( _("_Project") );
626      gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
627    submenu = gtk_menu_new();    submenu = gtk_menu_new();
628      gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
629    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
630    #ifdef UISPECIFIC_MAIN_MENU_IS_MENU_BAR
631      about_quit_items_menu = submenu;
632    #endif
633    
634    item = gtk_menu_item_new_with_label( _("Open...") );    menu_append_new_item(
635    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_project_open), _("_Open"),
636    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_project_open),      GTK_STOCK_OPEN, "<OSM2Go-Main>/Project/Open",
637                     appdata);      0, 0, TRUE, FALSE, FALSE
638      );
639    appdata->menu_item_project_close = item =  
640      gtk_menu_item_new_with_label( _("Close") );    appdata->menu_item_project_close = menu_append_new_item(
641    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_project_close), _("_Close"),
642    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_project_close),      GTK_STOCK_CLOSE, "<OSM2Go-Main>/Project/Close",
643                     appdata);      0, 0, TRUE, FALSE, FALSE
644      );
645    
646    /* --------------- view menu ------------------- */    /* --------------- view menu ------------------- */
647    
648    gtk_menu_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());  #ifndef UISPECIFIC_MAIN_MENU_IS_MENU_BAR
649      gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
650    #endif
651    
652    appdata->menu_view = item =    appdata->menu_view = item = gtk_menu_item_new_with_mnemonic( _("_View") );
653      gtk_menu_item_new_with_label( _("View") );    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
   gtk_menu_append(GTK_MENU_SHELL(menu), item);  
654    submenu = gtk_menu_new();    submenu = gtk_menu_new();
655      gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
656    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
657    
658    appdata->menu_item_view_fullscreen =  #if !defined(USE_HILDON) || (MAEMO_VERSION_MAJOR < 5)
659      item = gtk_check_menu_item_new_with_label( _("Fullscreen") );    appdata->menu_item_view_fullscreen = menu_append_new_item(
660    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_fullscreen), _("_Fullscreen"),
661    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_fullscreen),      GTK_STOCK_FULLSCREEN, "<OSM2Go-Main>/View/Fullscreen",
662                     appdata);      0, 0, TRUE, TRUE, FALSE
663      );
664    #endif
665    
666    item = gtk_menu_item_new_with_label( _("Zoom +" ));    menu_append_new_item(
667    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_zoomin), _("Zoom _in"),
668    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_zoomin), appdata);      GTK_STOCK_ZOOM_IN, "<OSM2Go-Main>/View/ZoomIn",
669        GDK_comma, GDK_CONTROL_MASK, TRUE, FALSE, FALSE
670    item = gtk_menu_item_new_with_label( _("Zoom -") );    );
671    gtk_menu_append(GTK_MENU_SHELL(submenu), item);  
672    g_signal_connect(item, "activate",    menu_append_new_item(
673                     GTK_SIGNAL_FUNC(cb_menu_zoomout), appdata);      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_zoomout), _("Zoom _out"),
674        GTK_STOCK_ZOOM_OUT, "<OSM2Go-Main>/View/ZoomOut",
675        GDK_period, GDK_CONTROL_MASK, TRUE, FALSE, FALSE
676      );
677    
678      gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
679    
680      menu_append_new_item(
681        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_view_detail_inc), _("More details"),
682        NULL, "<OSM2Go-Main>/View/DetailInc",
683        GDK_period, GDK_MOD1_MASK, TRUE, FALSE, FALSE
684      );
685    
686      menu_append_new_item(
687        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_view_detail_normal), _("Normal details"),
688        NULL, "<OSM2Go-Main>/View/DetailNormal",
689        0, 0, TRUE, FALSE, FALSE
690      );
691    
692      menu_append_new_item(
693        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_view_detail_dec), _("Less details"),
694        NULL, "<OSM2Go-Main>/View/DetailDec",
695        GDK_comma, GDK_MOD1_MASK, TRUE, FALSE, FALSE
696      );
697    
698    /* -------------------- OSM submenu -------------------- */    /* -------------------- OSM submenu -------------------- */
699    
700    appdata->menu_osm = item = gtk_menu_item_new_with_label( _("OSM") );    appdata->menu_osm = item = gtk_menu_item_new_with_mnemonic( _("_OSM") );
701    gtk_menu_append(GTK_MENU_SHELL(menu), item);    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
702    submenu = gtk_menu_new();    submenu = gtk_menu_new();
703      gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
704    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
705    
706    appdata->menu_item_osm_upload = item =    appdata->menu_item_osm_upload = menu_append_new_item(
707      gtk_menu_item_new_with_label( _("Upload...") );      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_upload), _("_Upload"),
708    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      "upload.16", "<OSM2Go-Main>/OSM/Upload",
709    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_upload), appdata);      GDK_u, GDK_SHIFT_MASK|GDK_CONTROL_MASK, TRUE, FALSE, FALSE
710      );
711    item = gtk_menu_item_new_with_label( _("Download...") );  
712    gtk_menu_append(GTK_MENU_SHELL(submenu), item);    menu_append_new_item(
713    g_signal_connect(item, "activate",      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_download), _("_Download"),
714                     GTK_SIGNAL_FUNC(cb_menu_download), appdata);      "download.16", "<OSM2Go-Main>/OSM/Download",
715        GDK_d, GDK_SHIFT_MASK|GDK_CONTROL_MASK, TRUE, FALSE, FALSE
716    gtk_menu_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());    );
717    
718    appdata->menu_item_osm_diff = item =    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
719      gtk_menu_item_new_with_label( _("Save diff file") );  
720    gtk_menu_append(GTK_MENU_SHELL(submenu), item);    if(getenv("OSM2GO_UNDO_TEST")) {
721    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_save_changes),      appdata->menu_item_osm_undo = menu_append_new_item(
722                     appdata);                 appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_undo), _("_Undo"),
723                   GTK_STOCK_UNDO, "<OSM2Go-Main>/OSM/Undo",
724    appdata->menu_item_osm_undo_changes = item =                 GDK_z, GDK_CONTROL_MASK, TRUE, FALSE, FALSE
725      gtk_menu_item_new_with_label( _("Undo all changes...") );                 );
726    gtk_menu_append(GTK_MENU_SHELL(submenu), item);    } else
727    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_undo_changes),      printf("set environment variable OSM2GO_UNDO_TEST to enable undo framework tests\n");
728                     appdata);  
729      appdata->menu_item_osm_save_changes = menu_append_new_item(
730        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_save_changes), _("_Save local changes"),
731        GTK_STOCK_SAVE, "<OSM2Go-Main>/OSM/SaveChanges",
732        GDK_s, GDK_SHIFT_MASK|GDK_CONTROL_MASK, TRUE, FALSE, FALSE
733      );
734    
735      appdata->menu_item_osm_undo_changes = menu_append_new_item(
736        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_undo_changes), _("Disca_rd local changes"),
737        GTK_STOCK_DELETE, "<OSM2Go-Main>/OSM/DiscardChanges",
738        0, 0, TRUE, FALSE, FALSE
739      );
740    
741      gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
742      appdata->menu_item_osm_relations = menu_append_new_item(
743        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_osm_relations), _("_Relations"),
744        NULL, "<OSM2Go-Main>/OSM/Relations",
745        GDK_r, GDK_SHIFT_MASK|GDK_CONTROL_MASK, TRUE, FALSE, FALSE
746      );
747    
748    /* -------------------- wms submenu -------------------- */    /* -------------------- wms submenu -------------------- */
749    
750    appdata->menu_wms = item = gtk_menu_item_new_with_label( _("WMS") );    appdata->menu_wms = item = gtk_menu_item_new_with_mnemonic( _("_WMS") );
751    gtk_menu_append(GTK_MENU_SHELL(menu), item);    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
752    submenu = gtk_menu_new();    submenu = gtk_menu_new();
753      gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
754    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
755    
756    item = gtk_menu_item_new_with_label( _("Import...") );    menu_append_new_item(
757    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_wms_import), _("_Import"),
758    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_wms_import),      GTK_STOCK_INDEX, "<OSM2Go-Main>/WMS/Import",
759                     appdata);      0, 0, TRUE, FALSE, FALSE
760      );
761    appdata->menu_item_wms_clear = item =  
762      gtk_menu_item_new_with_label( _("Clear") );    appdata->menu_item_wms_clear = menu_append_new_item(
763    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_wms_clear), _("_Clear"),
764    gtk_widget_set_sensitive(item, FALSE);      GTK_STOCK_CLEAR, "<OSM2Go-Main>/WMS/Clear",
765    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_wms_clear),      0, 0, TRUE, FALSE, FALSE
766                     appdata);    );
767      gtk_widget_set_sensitive(appdata->menu_item_wms_clear, FALSE);
768    appdata->menu_item_wms_adjust = item =  
769      gtk_menu_item_new_with_label( _("Adjust") );    appdata->menu_item_wms_adjust = menu_append_new_item(
770    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_wms_adjust), _("_Adjust"),
771    gtk_widget_set_sensitive(item, FALSE);      NULL, "<OSM2Go-Main>/WMS/Adjust",
772    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_wms_adjust),      0, 0, TRUE, FALSE, FALSE
773                     appdata);    );
774      gtk_widget_set_sensitive(appdata->menu_item_wms_adjust, FALSE);
775    
776    /* -------------------- map submenu -------------------- */    /* -------------------- map submenu -------------------- */
777    
778    appdata->menu_map = item = gtk_menu_item_new_with_label( _("Map") );    appdata->menu_map = item = gtk_menu_item_new_with_mnemonic( _("_Map") );
779    gtk_menu_append(GTK_MENU_SHELL(menu), item);    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
780    submenu = gtk_menu_new();    submenu = gtk_menu_new();
781      gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
782    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
783    
784    appdata->menu_item_map_hide_sel = item =    appdata->menu_item_map_hide_sel = menu_append_new_item(
785      gtk_menu_item_new_with_label( _("Hide selected") );      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_hide_sel), _("_Hide selected"),
786    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      GTK_STOCK_REMOVE, "<OSM2Go-Main>/Map/HideSelected",
787    gtk_widget_set_sensitive(item, FALSE);      0, 0, TRUE, FALSE, FALSE
788    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_map_hide_sel),    );
789                     appdata);    gtk_widget_set_sensitive(appdata->menu_item_map_hide_sel, FALSE);
790    
791    appdata->menu_item_map_show_all = item =    appdata->menu_item_map_show_all = menu_append_new_item(
792      gtk_menu_item_new_with_label( _("Show all") );      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_show_all), _("_Show all"),
793    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      GTK_STOCK_ADD, "<OSM2Go-Main>/Map/ShowAll",
794    gtk_widget_set_sensitive(item, FALSE);      0, 0, TRUE, FALSE, FALSE
795    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_map_show_all),    );
796                     appdata);    gtk_widget_set_sensitive(appdata->menu_item_map_show_all, FALSE);
797    
798      gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
799    
800      menu_append_new_item(
801        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_style), _("St_yle"),
802        GTK_STOCK_SELECT_COLOR, "<OSM2Go-Main>/Map/Style",
803        0, 0, TRUE, FALSE, FALSE
804      );
805    
806    gtk_menu_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
   
   item = gtk_menu_item_new_with_label( _("Style...") );  
   gtk_menu_append(GTK_MENU_SHELL(submenu), item);  
   g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_style), appdata);  
   
   gtk_menu_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());  
807    
808    /* switches mainly intended for testing/debugging */    /* switches mainly intended for testing/debugging */
809    item = gtk_menu_item_new_with_label( _("Redraw") );    menu_append_new_item(
810    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_redraw), _("_Redraw"),
811    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_redraw), appdata);      NULL, "<OSM2Go-Main>/Map/Redraw",
812        GDK_r, GDK_CONTROL_MASK, TRUE, FALSE, FALSE
813    appdata->menu_item_map_no_icons =    );
814      item = gtk_check_menu_item_new_with_label( _("No Icons") );  
815    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),    appdata->menu_item_map_no_icons = menu_append_new_item(
816                                   appdata->settings->no_icons);      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_no_icons), _("No _icons"),
817    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      NULL, "<OSM2Go-Main>/Map/NoIcons",
818    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_map_no_icons),      0, 0, TRUE, TRUE, appdata->settings->no_icons
819                     appdata);    );
820    
821    appdata->menu_item_map_no_antialias =    appdata->menu_item_map_no_antialias = menu_append_new_item(
822      item = gtk_check_menu_item_new_with_label( _("No Antialias") );      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_no_antialias),
823    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),      _("No _antialias"),
824                                   appdata->settings->no_antialias);      NULL, "<OSM2Go-Main>/Map/NoAntialias",
825    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      0, 0, TRUE, TRUE, appdata->settings->no_antialias
826    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_map_no_antialias),    );
                    appdata);  
827    
828    /* -------------------- track submenu -------------------- */    /* -------------------- track submenu -------------------- */
829    
830    appdata->track.menu_track = item = gtk_menu_item_new_with_label(_("Track"));    appdata->track.menu_track = item = gtk_menu_item_new_with_mnemonic(_("_Track"));
831    gtk_menu_append(GTK_MENU_SHELL(menu), item);    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
832    submenu = gtk_menu_new();    submenu = gtk_menu_new();
833      gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
834    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
835    
836    appdata->track.menu_item_import =    appdata->track.menu_item_import = menu_append_new_item(
837      item = gtk_menu_item_new_with_label( _("Import...") );      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_import), _("_Import"),
838    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      NULL, "<OSM2Go-Main>/Track/Import",
839    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_track_import),      0, 0, TRUE, FALSE, FALSE
840                     appdata);    );
841    
842    appdata->track.menu_item_export =    appdata->track.menu_item_export = menu_append_new_item(
843      item = gtk_menu_item_new_with_label( _("Export...") );      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_export), _("_Export"),
844    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      NULL, "<OSM2Go-Main>/Track/Export",
845    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_track_export),      0, 0, FALSE, FALSE, FALSE
846                     appdata);    );
847    
848    appdata->track.menu_item_clear =    appdata->track.menu_item_clear = menu_append_new_item(
849      item = gtk_menu_item_new_with_label( _("Clear") );      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_clear), _("_Clear"),
850    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      GTK_STOCK_CLEAR, "<OSM2Go-Main>/Track/Clear",
851    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_track_clear),      0, 0, FALSE, FALSE, FALSE
852                     appdata);    );
853    
854    appdata->track.menu_item_gps =  
855      item = gtk_check_menu_item_new_with_label( _("GPS") );    appdata->track.menu_item_enable_gps = menu_append_new_item(
856    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_enable_gps),_("_GPS enable"),
857    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_track_gps),      NULL, "<OSM2Go-Main>/Track/GPS",
858                     appdata);      GDK_g, GDK_CONTROL_MASK|GDK_SHIFT_MASK, TRUE, TRUE,
859        appdata->settings->enable_gps
860      );
861    
862      appdata->track.menu_item_follow_gps = menu_append_new_item(
863        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_follow_gps), _("GPS follow"),
864        NULL, "<OSM2Go-Main>/Track/Follow",
865        0, 0, appdata->settings->enable_gps, TRUE,
866        appdata->settings->follow_gps
867      );
868    
869    /* ------------------------------------------------------- */    /* ------------------------------------------------------- */
870    
871    gtk_menu_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());    gtk_menu_shell_append(GTK_MENU_SHELL(about_quit_items_menu),
872                            gtk_separator_menu_item_new());
873    
874      menu_append_new_item(
875        appdata, about_quit_items_menu, GTK_SIGNAL_FUNC(cb_menu_about), _("_About"),
876        GTK_STOCK_ABOUT, "<OSM2Go-Main>/About",
877        0, 0, TRUE, FALSE, FALSE
878      );
879    
880      menu_append_new_item(
881        appdata, about_quit_items_menu, GTK_SIGNAL_FUNC(cb_menu_quit), _("_Quit"),
882        GTK_STOCK_QUIT, "<OSM2Go-Main>/Quit",
883        0, 0, TRUE, FALSE, FALSE
884      );
885    
886    item = gtk_menu_item_new_with_label( _("About...") );    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_about), appdata);  
   
   
   item = gtk_menu_item_new_with_label( _("Quit") );  
   gtk_menu_append(GTK_MENU_SHELL(menu), item);  
   g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_quit), appdata);  
887    
888  #ifdef USE_HILDON  #ifdef USE_HILDON
889    hildon_window_set_menu(appdata->window, GTK_MENU(menu));    hildon_window_set_menu(appdata->window, GTK_MENU(menu));
890  #else  #else
891    /* attach ordinary gtk menu */    GtkWidget *menu_bar = menu;
892    GtkWidget *menu_bar = gtk_menu_bar_new();  
893    #ifndef UISPECIFIC_MAIN_MENU_IS_MENU_BAR
894      // we need to make one first
895      menu_bar = gtk_menu_bar_new();
896    
897    GtkWidget *root_menu = gtk_menu_item_new_with_label (_("Menu"));    GtkWidget *root_menu = gtk_menu_item_new_with_label (_("Menu"));
898    gtk_widget_show(root_menu);    gtk_widget_show(root_menu);
# Line 589  void menu_create(appdata_t *appdata) { Line 901  void menu_create(appdata_t *appdata) {
901    gtk_menu_item_set_submenu(GTK_MENU_ITEM (root_menu), menu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM (root_menu), menu);
902    
903    gtk_widget_show(menu_bar);    gtk_widget_show(menu_bar);
904    #endif //UISPECIFIC_MAIN_MENU_IS_MENU_BAR
905    
906    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);
907  #endif  
908    #endif //USE_HILDON
909  }  }
910    
911  /********************* end of menu **********************/  /********************* end of menu **********************/
912    
913    #ifdef UISPECIFIC_MENU_HAS_ACCELS
914    #define ACCELS_FILE "accels"
915    
916    static void menu_accels_load(appdata_t *appdata) {
917      char *accels_file = g_strdup_printf("%s/" ACCELS_FILE,
918                                          appdata->settings->base_path);
919      gtk_accel_map_load(accels_file);
920      g_free(accels_file);
921    }
922    
923    static void menu_accels_save(appdata_t *appdata) {
924      char *accels_file = g_strdup_printf("%s" ACCELS_FILE,
925                                          appdata->settings->base_path);
926      gtk_accel_map_save(accels_file);
927      g_free(accels_file);
928    }
929    
930    #endif
931    
932    
933  void cleanup(appdata_t *appdata) {  void cleanup(appdata_t *appdata) {
934    #ifdef UISPECIFIC_MENU_HAS_ACCELS
935      menu_accels_save(appdata);
936    #endif
937    
938    settings_save(appdata->settings);    settings_save(appdata->settings);
939    
940  #ifdef USE_HILDON  #ifdef USE_HILDON
# Line 640  void cleanup(appdata_t *appdata) { Line 978  void cleanup(appdata_t *appdata) {
978    
979    project_free(appdata->project);    project_free(appdata->project);
980    
981      if(appdata->menu_item_osm_undo)
982        undo_free(appdata->undo.state);
983    
984    puts("everything is gone");    puts("everything is gone");
985  }  }
986    
# Line 704  int main(int argc, char *argv[]) { Line 1045  int main(int argc, char *argv[]) {
1045    
1046    g_thread_init(NULL);    g_thread_init(NULL);
1047    
   gps_init(&appdata);  
   
1048    gtk_init (&argc, &argv);    gtk_init (&argc, &argv);
1049    
1050      gps_init(&appdata);
1051    
1052  #ifdef USE_HILDON  #ifdef USE_HILDON
1053    printf("Installing osso context for \"org.harbaum." PACKAGE "\"\n");    printf("Installing osso context for \"org.harbaum." PACKAGE "\"\n");
1054    appdata.osso_context = osso_initialize("org.harbaum."PACKAGE,    appdata.osso_context = osso_initialize("org.harbaum."PACKAGE,
# Line 748  int main(int argc, char *argv[]) { Line 1089  int main(int argc, char *argv[]) {
1089    
1090    appdata.vbox = gtk_vbox_new(FALSE,0);    appdata.vbox = gtk_vbox_new(FALSE,0);
1091    menu_create(&appdata);    menu_create(&appdata);
1092    #ifdef UISPECIFIC_MENU_HAS_ACCELS
1093      menu_accels_load(&appdata);
1094    #endif
1095    
1096    /* ----------------------- setup main window ---------------- */    /* ----------------------- setup main window ---------------- */
1097    
# Line 771  int main(int argc, char *argv[]) { Line 1115  int main(int argc, char *argv[]) {
1115  #ifndef PORTRAIT  #ifndef PORTRAIT
1116    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);
1117  #endif  #endif
1118    gtk_box_pack_start(GTK_BOX(hbox), gtk_vseparator_new(), FALSE, FALSE, 0);    //  gtk_box_pack_start(GTK_BOX(hbox), gtk_vseparator_new(), FALSE, FALSE, 0);
1119    gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);    gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
1120    
1121    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 795  int main(int argc, char *argv[]) { Line 1139  int main(int argc, char *argv[]) {
1139    
1140    main_ui_enable(&appdata);    main_ui_enable(&appdata);
1141    
1142      /* start GPS if enabled by config */
1143      if(appdata.settings && appdata.settings->enable_gps)
1144        track_enable_gps(&appdata, TRUE);
1145    
1146    /* ------------ jump into main loop ---------------- */    /* ------------ jump into main loop ---------------- */
1147    
1148    gtk_main();    gtk_main();
# Line 802  int main(int argc, char *argv[]) { Line 1150  int main(int argc, char *argv[]) {
1150    puts("gtk_main() left");    puts("gtk_main() left");
1151    
1152    track_save(appdata.project, appdata.track.track);    track_save(appdata.project, appdata.track.track);
1153      track_clear(&appdata, appdata.track.track);
1154      appdata.track.track = NULL;
1155    
1156    /* save a diff if there are dirty entries */    /* save a diff if there are dirty entries */
1157    diff_save(appdata.project, appdata.osm);    diff_save(appdata.project, appdata.osm);
# Line 810  int main(int argc, char *argv[]) { Line 1160  int main(int argc, char *argv[]) {
1160    
1161    return 0;    return 0;
1162  }  }
1163    
1164    // vim:et:ts=8:sw=2:sts=2:ai
Legend:
Removed from v.24  
changed lines
  Added in v.178