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 175 by harbaum, Wed Jun 10 09:24:47 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  #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 54  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 68  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    
# Line 138  cb_menu_upload(GtkWidget *window, gpoint Line 130  cb_menu_upload(GtkWidget *window, gpoint
130  }  }
131    
132  static void  static void
133  cb_menu_download(GtkWidget *window, gpointer data) {  cb_menu_download(GtkMenuItem *item, gpointer data) {
134    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
135    if(!appdata->project) return;    if(!appdata->project) return;
136    
# Line 153  cb_menu_download(GtkWidget *window, gpoi Line 145  cb_menu_download(GtkWidget *window, gpoi
145    }    }
146    
147    // download    // download
148    if(osm_download(GTK_WIDGET(appdata->window), appdata->project)) {    if(osm_download(GTK_WIDGET(appdata->window), appdata->settings,
149      appdata->osm = osm_parse(appdata->project->osm);                    appdata->project)) {
150        banner_busy_start(appdata, 1, "Redrawing...");
151        appdata->osm = osm_parse(appdata->project->path, appdata->project->osm);
152      diff_restore(appdata, appdata->project, appdata->osm);      diff_restore(appdata, appdata->project, appdata->osm);
153      map_paint(appdata);      map_paint(appdata);
154        banner_busy_stop(appdata); //"Redrawing..."
155    }    }
156    
157    main_ui_enable(appdata);    main_ui_enable(appdata);
158  }  }
159    
160  static void  static void
161  cb_menu_wms_import(GtkWidget *window, gpointer data) {  cb_menu_wms_import(GtkMenuItem *item, gpointer data) {
162    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
163    wms_import(appdata);    wms_import(appdata);
164  }  }
165    
166  static void  static void
167  cb_menu_wms_clear(GtkWidget *window, gpointer data) {  cb_menu_wms_clear(GtkMenuItem *item, gpointer data) {
168    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
169    wms_remove(appdata);    wms_remove(appdata);
170  }  }
171    
172  static void  static void
173  cb_menu_wms_adjust(GtkWidget *window, gpointer data) {  cb_menu_wms_adjust(GtkMenuItem *item, gpointer data) {
174    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
175    map_action_set(appdata, MAP_ACTION_BG_ADJUST);    map_action_set(appdata, MAP_ACTION_BG_ADJUST);
176  }  }
# Line 183  cb_menu_wms_adjust(GtkWidget *window, gp Line 178  cb_menu_wms_adjust(GtkWidget *window, gp
178  /* ----------- hide objects for performance reasons ----------- */  /* ----------- hide objects for performance reasons ----------- */
179    
180  static void  static void
181  cb_menu_map_hide_sel(GtkWidget *window, gpointer data) {  cb_menu_map_hide_sel(GtkMenuItem *item, gpointer data) {
182    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
183    map_hide_selected(appdata);    map_hide_selected(appdata);
184  }  }
185    
186  static void  static void
187  cb_menu_map_show_all(GtkWidget *window, gpointer data) {  cb_menu_map_show_all(GtkMenuItem *item, gpointer data) {
188    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
189    map_show_all(appdata);    map_show_all(appdata);
190  }  }
# Line 198  cb_menu_map_show_all(GtkWidget *window, Line 193  cb_menu_map_show_all(GtkWidget *window,
193    
194  #if 1  // mainly for testing  #if 1  // mainly for testing
195  static void  static void
196  cb_menu_redraw(GtkWidget *window, gpointer data) {  cb_menu_redraw(GtkMenuItem *item, gpointer data) {
197    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
198    
199    /* redraw the entire map by destroying all map items and redrawing them */    /* redraw the entire map by destroying all map items and redrawing them */
200      banner_busy_start(appdata, 1, "Redrawing...");
201    track_save(appdata->project, appdata->track.track);    track_save(appdata->project, appdata->track.track);
202    diff_save(appdata->project, appdata->osm);    diff_save(appdata->project, appdata->osm);
203    map_clear(appdata, MAP_LAYER_ALL);    map_clear(appdata, MAP_LAYER_ALL);
204    osm_free(&appdata->icon, appdata->osm);    osm_free(&appdata->icon, appdata->osm);
205    
206    appdata->osm = osm_parse(appdata->project->osm);    appdata->osm = osm_parse(appdata->project->path, appdata->project->osm);
207    diff_restore(appdata, appdata->project, appdata->osm);    diff_restore(appdata, appdata->project, appdata->osm);
208    map_paint(appdata);    map_paint(appdata);
209    
# Line 216  cb_menu_redraw(GtkWidget *window, gpoint Line 212  cb_menu_redraw(GtkWidget *window, gpoint
212      map_track_draw(appdata->map, appdata->track.track);      map_track_draw(appdata->map, appdata->track.track);
213    
214    wms_load(appdata);    wms_load(appdata);
215      banner_busy_stop(appdata); //"Redrawing..."
216  }  }
217  #endif  #endif
218    
219  static void  static void
220  cb_menu_style(GtkWidget *widget, gpointer data) {  cb_menu_map_no_icons(GtkCheckMenuItem *item, gpointer data) {
221    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
222    
223    style_select(GTK_WIDGET(appdata->window), appdata);    banner_busy_start(appdata, 1, "Redrawing...");
224      map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);
225      appdata->settings->no_icons = gtk_check_menu_item_get_active(item);
226      map_paint(appdata);
227      banner_busy_stop(appdata); //"Redrawing..."
228  }  }
229    
230  static void  static void
231  cb_menu_map_no_icons(GtkWidget *widget, gpointer data) {  cb_menu_map_no_antialias(GtkCheckMenuItem *item, gpointer data) {
232    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
233    
234      banner_busy_start(appdata, 1, "Redrawing...");
235    map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);    map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);
236    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));  
237    map_paint(appdata);    map_paint(appdata);
238      banner_busy_stop(appdata); //"Redrawing..."
239    }
240    
241    static void
242    cb_menu_style(GtkMenuItem *item, gpointer data) {
243      appdata_t *appdata = (appdata_t*)data;
244    
245      style_select(GTK_WIDGET(appdata->window), appdata);
246    }
247    
248    static void
249    cb_menu_undo(GtkMenuItem *item, gpointer data) {
250      appdata_t *appdata = (appdata_t*)data;
251    
252      undo(appdata);
253    
254      // the banner will be displayed from within undo with more details
255  }  }
256    
257  static void  static void
258  cb_menu_save_changes(GtkWidget *widget, gpointer data) {  cb_menu_save_changes(GtkMenuItem *item, gpointer data) {
259    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
260    
261    diff_save(appdata->project, appdata->osm);    diff_save(appdata->project, appdata->osm);
262    statusbar_set(appdata, _("Saved all changes made "    banner_show_info(appdata, _("Saved local changes"));
                            "to this project so far"), FALSE);  
263  }  }
264    
265  static void  static void
266  cb_menu_undo_changes(GtkWidget *widget, gpointer data) {  cb_menu_undo_changes(GtkMenuItem *item, gpointer data) {
267    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
268    
269    if(!yes_no_f(GTK_WIDGET(appdata->window), NULL, 0, 0,    if(!yes_no_f(GTK_WIDGET(appdata->window), NULL, 0, 0,
270                 _("Undo all changes?"),                 _("Discard local changes?"),
271                 _("Do you really want to undo all your changes "                 _("Throw away all the changes you've not "
272                   "not uploaded so far? This cannot be undone!")))                   "uploaded yet? This can't be undone.")))
273      return;      return;
274    
275      banner_busy_start(appdata, 1, _("Redrawing..."));
276    map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);    map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);
277    osm_free(&appdata->icon, appdata->osm);    osm_free(&appdata->icon, appdata->osm);
278    diff_remove(appdata->project);    diff_remove(appdata->project);
279    appdata->osm = osm_parse(appdata->project->osm);    appdata->osm = osm_parse(appdata->project->path, appdata->project->osm);
280    map_paint(appdata);    map_paint(appdata);
281      banner_busy_stop(appdata);  //"Redrawing..."
282    
283    statusbar_set(appdata, _("All changes made "    banner_show_info(appdata, _("Discarded local changes"));
                            "so far have been reset"), FALSE);  
284  }  }
285    
286    static void
287    cb_menu_osm_relations(GtkMenuItem *item, gpointer data) {
288      relation_list((appdata_t*)data);
289    }
290    
291  #ifdef USE_HILDON  #if !defined(USE_HILDON) || (MAEMO_VERSION_MAJOR < 5)
292  static void  static void
293  cb_menu_fullscreen(GtkWidget *widget, gpointer data) {  cb_menu_fullscreen(GtkCheckMenuItem *item, gpointer data) {
294    appdata_t *appdata = (appdata_t *)data;    appdata_t *appdata = (appdata_t *)data;
295    
296    if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget)))    if(gtk_check_menu_item_get_active(item))
297      gtk_window_fullscreen(GTK_WINDOW(appdata->window));      gtk_window_fullscreen(GTK_WINDOW(appdata->window));
298    else    else
299      gtk_window_unfullscreen(GTK_WINDOW(appdata->window));      gtk_window_unfullscreen(GTK_WINDOW(appdata->window));
# Line 279  cb_menu_fullscreen(GtkWidget *widget, gp Line 301  cb_menu_fullscreen(GtkWidget *widget, gp
301  #endif  #endif
302    
303  static void  static void
304  cb_menu_zoomin(GtkWidget *widget, appdata_t *appdata) {  cb_menu_zoomin(GtkMenuItem *item, appdata_t *appdata) {
305    if(!appdata || !appdata->map) return;    if(!appdata || !appdata->map) return;
306    
307    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 309  cb_menu_zoomin(GtkWidget *widget, appdat
309  }  }
310    
311  static void  static void
312  cb_menu_zoomout(GtkWidget *widget, appdata_t *appdata) {  cb_menu_zoomout(GtkMenuItem *item, appdata_t *appdata) {
313    if(!appdata || !appdata->map) return;    if(!appdata || !appdata->map) return;
314    
315    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 317  cb_menu_zoomout(GtkWidget *widget, appda
317  }  }
318    
319  static void  static void
320  cb_menu_track_import(GtkWidget *window, appdata_t *appdata) {  cb_menu_view_detail_inc(GtkMenuItem *item, gpointer data) {
321      appdata_t *appdata = (appdata_t*)data;
322    
323      printf("detail level increase\n");
324      map_detail_increase(appdata->map);
325    }
326    
327    static void
328    cb_menu_view_detail_normal(GtkMenuItem *item, gpointer data) {
329      appdata_t *appdata = (appdata_t*)data;
330    
331      printf("detail level normal\n");
332      map_detail_normal(appdata->map);
333    }
334    
335    static void
336    cb_menu_view_detail_dec(GtkMenuItem *item, gpointer data) {
337      appdata_t *appdata = (appdata_t*)data;
338    
339      printf("detail level decrease\n");
340      map_detail_decrease(appdata->map);
341    }
342    
343    static void
344    cb_menu_track_import(GtkMenuItem *item, appdata_t *appdata) {
345      g_assert(appdata->settings);
346    
347    /* open a file selector */    /* open a file selector */
348    GtkWidget *dialog;    GtkWidget *dialog;
# Line 312  cb_menu_track_import(GtkWidget *window, Line 359  cb_menu_track_import(GtkWidget *window,
359                          NULL);                          NULL);
360  #endif  #endif
361    
362    /* use path if one is present */    if(appdata->settings->track_path) {
363    if(appdata->track.import_path)      if(!g_file_test(appdata->settings->track_path, G_FILE_TEST_EXISTS)) {
364      gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),        char *last_sep = strrchr(appdata->settings->track_path, '/');
365                                          appdata->track.import_path);        if(last_sep) {
366            *last_sep = 0;  // seperate path from file
367    
368            /* the user just created a new document */
369            gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
370                                        appdata->settings->track_path);
371            gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog),
372                                              last_sep+1);
373    
374            /* restore full filename */
375            *last_sep = '/';
376          }
377        } else
378          gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),
379                                        appdata->settings->track_path);
380      }
381    
382    gtk_widget_show_all (GTK_WIDGET(dialog));    gtk_widget_show_all (GTK_WIDGET(dialog));
383    if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_FM_OK) {    if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_FM_OK) {
384      char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));      char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
385    
386      /* load a track */      /* load a track */
387      track_do(appdata, TRACK_IMPORT, filename);      appdata->track.track = track_import(appdata, filename);
388      if(appdata->track.track) {      if(appdata->track.track) {
389          if(appdata->settings->track_path) g_free(appdata->settings->track_path);
390        /* 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 = '/';  
       }  
391      }      }
392      g_free (filename);      g_free (filename);
393    }    }
# Line 344  cb_menu_track_import(GtkWidget *window, Line 396  cb_menu_track_import(GtkWidget *window,
396  }  }
397    
398  static void  static void
399  cb_menu_track_gps(GtkWidget *window, gpointer data) {  cb_menu_track_enable_gps(GtkMenuItem *item, gpointer data) {
400    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
401    
402    if(gtk_check_menu_item_get_active(    if(gtk_check_menu_item_get_active(
403      GTK_CHECK_MENU_ITEM(appdata->track.menu_item_gps))) {      GTK_CHECK_MENU_ITEM(appdata->track.menu_item_enable_gps))) {
404      track_do(appdata, TRACK_GPS, NULL);      track_enable_gps(appdata, TRUE);
405    } else {    } else
406      track_do(appdata, TRACK_NONE, NULL);      track_enable_gps(appdata, FALSE);
   }  
407  }  }
408    
409    
410  static void  static void
411  cb_menu_track_export(GtkWidget *window, gpointer data) {  cb_menu_track_follow_gps(GtkMenuItem *item, gpointer data) {
412    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
413    messagef(GTK_WIDGET(appdata->window), _("NIY"),  
414             _("Track export is not yet supported."));    if(gtk_check_menu_item_get_active(
415        GTK_CHECK_MENU_ITEM(appdata->track.menu_item_follow_gps))) {
416        appdata->settings->follow_gps = TRUE;
417      } else
418        appdata->settings->follow_gps = FALSE;
419    }
420    
421    
422    static void
423    cb_menu_track_export(GtkMenuItem *item, appdata_t *appdata) {
424      g_assert(appdata->settings);
425    
426      /* open a file selector */
427      GtkWidget *dialog;
428    
429    #ifdef USE_HILDON
430      dialog = hildon_file_chooser_dialog_new(GTK_WINDOW(appdata->window),
431                                              GTK_FILE_CHOOSER_ACTION_SAVE);
432    #else
433      dialog = gtk_file_chooser_dialog_new(_("Export track file"),
434                                           GTK_WINDOW(appdata->window),
435                                           GTK_FILE_CHOOSER_ACTION_SAVE,
436                                           GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
437                                           GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
438                                           NULL);
439    #endif
440    
441      printf("set filename <%s>\n", appdata->settings->track_path);
442    
443      if(appdata->settings->track_path) {
444        if(!g_file_test(appdata->settings->track_path, G_FILE_TEST_EXISTS)) {
445          char *last_sep = strrchr(appdata->settings->track_path, '/');
446          if(last_sep) {
447            *last_sep = 0;  // seperate path from file
448    
449            /* the user just created a new document */
450            gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
451                                                appdata->settings->track_path);
452            gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog),
453                                              last_sep+1);
454    
455            /* restore full filename */
456            *last_sep = '/';
457          }
458        } else
459          gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),
460                                        appdata->settings->track_path);
461      }
462    
463      if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_FM_OK) {
464        gchar *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
465        if(filename) {
466          printf("export to %s\n", filename);
467    
468          if(!g_file_test(filename, G_FILE_TEST_EXISTS) ||
469             yes_no_f(dialog, appdata, MISC_AGAIN_ID_EXPORT_OVERWRITE,
470                      MISC_AGAIN_FLAG_DONT_SAVE_NO,
471                      "Overwrite existing file",
472                      "The file already exists. "
473                      "Do you really want to replace it?")) {
474            if(appdata->settings->track_path)
475              g_free(appdata->settings->track_path);
476            appdata->settings->track_path = g_strdup(filename);
477    
478            track_export(appdata, filename);
479          }
480        }
481      }
482    
483      gtk_widget_destroy (dialog);
484  }  }
485    
486    
487  static void  static void
488  cb_menu_track_clear(GtkWidget *window, gpointer data) {  cb_menu_track_clear(GtkMenuItem *item, gpointer data) {
489    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
490    track_do(appdata, TRACK_NONE, NULL);    track_clear(appdata, appdata->track.track);
491      appdata->track.track = NULL;
492    }
493    
494    
495    
496    
497    /*
498     *  Platform-specific UI tweaks.
499     */
500    
501    
502    #ifndef USE_HILDON
503    #ifdef PORTRAIT
504    
505    // Portrait mode, for openmoko-like systems
506    #define uispecific_main_menu_new gtk_menu_new
507    
508    #else
509    
510    // Regular desktop builds
511    #define uispecific_main_menu_new gtk_menu_bar_new
512    #define UISPECIFIC_MAIN_MENU_IS_MENU_BAR
513    #define UISPECIFIC_MENU_HAS_ICONS
514    #define UISPECIFIC_MENU_HAS_ACCELS
515    
516    #endif //PORTRAIT
517    #else//USE_HILDON
518    
519    // Maemo/Hildon builds
520    #define uispecific_main_menu_new gtk_menu_new
521    
522    #endif
523    
524    
525    
526    // Half-arsed slapdash common menu item constructor. Let's use GtkBuilder
527    // instead so we have some flexibility.
528    
529    static GtkWidget *
530    menu_append_new_item(appdata_t *appdata,
531                         GtkWidget *menu_shell,
532                         GtkSignalFunc activate_cb,
533                         char *label,
534                         const gchar *icon_name, // stock id or name for icon_load
535                                        // overridden by label, accels, icon_name
536                         const gchar *accel_path,
537                         guint accel_key,      // from gdk/gdkkeysyms.h
538                         GdkModifierType accel_mods, // e.g. GDK_CONTROL_MASK
539                         gboolean enabled,
540                         gboolean is_check, gboolean check_status)
541    {
542      GtkWidget *item = NULL;
543      GtkWidget *image = NULL;
544    
545      gboolean stock_item_known = FALSE;
546      GtkStockItem stock_item;
547      if (icon_name != NULL) {
548        stock_item_known = gtk_stock_lookup(icon_name, &stock_item);
549      }
550    
551      // Icons
552    #ifndef UISPECIFIC_MENU_HAS_ICONS
553      item = is_check ? gtk_check_menu_item_new_with_mnemonic (label)
554                      : gtk_menu_item_new_with_mnemonic       (label);
555    #else
556      if (is_check) {
557        item = gtk_check_menu_item_new_with_mnemonic (label);
558      }
559      else if (!stock_item_known) {
560        GdkPixbuf *pbuf = icon_load(&appdata->icon, icon_name);
561        if (pbuf) {
562          image = gtk_image_new_from_pixbuf(pbuf);
563        }
564        if (image) {
565          item = gtk_image_menu_item_new_with_mnemonic(label);
566          gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
567        }
568        else {
569          item = gtk_menu_item_new_with_mnemonic(label);
570        }
571      }
572      else {
573        item = gtk_image_menu_item_new_with_mnemonic(label);
574        image = gtk_image_new_from_stock(icon_name, GTK_ICON_SIZE_MENU);
575        gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
576      }
577    #endif
578    
579    #ifdef UISPECIFIC_MENU_HAS_ACCELS
580      // Accelerators
581      // Default
582      if (accel_path != NULL) {
583        gtk_menu_item_set_accel_path(GTK_MENU_ITEM(item), accel_path);
584        if (accel_key != 0) {
585          gtk_accel_map_add_entry( accel_path, accel_key, accel_mods );
586        }
587        else if (stock_item_known) {
588          gtk_accel_map_add_entry( accel_path, stock_item.keyval,
589                                   stock_item.modifier );
590        }
591      }
592    #endif
593    
594      gtk_menu_shell_append(GTK_MENU_SHELL(menu_shell), GTK_WIDGET(item));
595      gtk_widget_set_sensitive(GTK_WIDGET(item), enabled);
596      if (is_check)
597        gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), check_status);
598    
599      g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(activate_cb),
600                       appdata);
601      return item;
602  }  }
603    
604    
605  void menu_create(appdata_t *appdata) {  void menu_create(appdata_t *appdata) {
606    GtkWidget *menu, *item, *submenu;    GtkWidget *menu, *item, *submenu;
607    menu = gtk_menu_new();    GtkWidget *about_quit_items_menu;
608    
609      if (g_module_supported()) {
610        printf("*** can use GModule: consider using GtkUIManager / GtkBuilder\n");
611      }
612    
613      menu = uispecific_main_menu_new();
614      about_quit_items_menu = menu;
615    
616    /* -------------------- Project submenu -------------------- */    /* -------------------- Project submenu -------------------- */
617    
618    item = gtk_menu_item_new_with_label( _("Project") );    GtkAccelGroup *accel_grp = gtk_accel_group_new();
619    gtk_menu_append(GTK_MENU_SHELL(menu), item);    item = gtk_menu_item_new_with_mnemonic( _("_Project") );
620      gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
621    submenu = gtk_menu_new();    submenu = gtk_menu_new();
622      gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
623    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
624    #ifdef UISPECIFIC_MAIN_MENU_IS_MENU_BAR
625      about_quit_items_menu = submenu;
626    #endif
627    
628    item = gtk_menu_item_new_with_label( _("Open...") );    menu_append_new_item(
629    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_project_open), _("_Open..."),
630    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_project_open),      GTK_STOCK_OPEN, "<OSM2Go-Main>/Project/Open",
631                     appdata);      0, 0, TRUE, FALSE, FALSE
632      );
633    appdata->menu_item_project_close = item =  
634      gtk_menu_item_new_with_label( _("Close") );    appdata->menu_item_project_close = menu_append_new_item(
635    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_project_close), _("_Close"),
636    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_project_close),      GTK_STOCK_CLOSE, "<OSM2Go-Main>/Project/Close",
637                     appdata);      0, 0, TRUE, FALSE, FALSE
638      );
639    
640    /* --------------- view menu ------------------- */    /* --------------- view menu ------------------- */
641    
642    gtk_menu_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());  #ifndef UISPECIFIC_MAIN_MENU_IS_MENU_BAR
643      gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
644    #endif
645    
646    appdata->menu_view = item =    appdata->menu_view = item = gtk_menu_item_new_with_mnemonic( _("_View") );
647      gtk_menu_item_new_with_label( _("View") );    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
   gtk_menu_append(GTK_MENU_SHELL(menu), item);  
648    submenu = gtk_menu_new();    submenu = gtk_menu_new();
649      gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
650    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
651    
652  #ifdef USE_HILDON  #if !defined(USE_HILDON) || (MAEMO_VERSION_MAJOR < 5)
653    appdata->fullscreen_menu_item =    appdata->menu_item_view_fullscreen = menu_append_new_item(
654      item = gtk_check_menu_item_new_with_label( _("Fullscreen") );      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_fullscreen), _("_Fullscreen"),
655    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      GTK_STOCK_FULLSCREEN, "<OSM2Go-Main>/View/Fullscreen",
656    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_fullscreen),      0, 0, TRUE, TRUE, FALSE
657                     appdata);    );
658  #endif  #endif
659    
660    item = gtk_menu_item_new_with_label( _("Zoom +" ));    menu_append_new_item(
661    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_zoomin), _("Zoom _in"),
662    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_zoomin), appdata);      GTK_STOCK_ZOOM_IN, "<OSM2Go-Main>/View/ZoomIn",
663        GDK_comma, GDK_CONTROL_MASK, TRUE, FALSE, FALSE
664    item = gtk_menu_item_new_with_label( _("Zoom -") );    );
665    gtk_menu_append(GTK_MENU_SHELL(submenu), item);  
666    g_signal_connect(item, "activate",    menu_append_new_item(
667                     GTK_SIGNAL_FUNC(cb_menu_zoomout), appdata);      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_zoomout), _("Zoom _out"),
668        GTK_STOCK_ZOOM_OUT, "<OSM2Go-Main>/View/ZoomOut",
669        GDK_period, GDK_CONTROL_MASK, TRUE, FALSE, FALSE
670      );
671    
672      gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
673    
674      menu_append_new_item(
675        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_view_detail_inc), _("More details"),
676        NULL, "<OSM2Go-Main>/View/DetailInc",
677        GDK_period, GDK_MOD1_MASK, TRUE, FALSE, FALSE
678      );
679    
680      menu_append_new_item(
681        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_view_detail_normal), _("Normal details"),
682        NULL, "<OSM2Go-Main>/View/DetailNormal",
683        0, 0, TRUE, FALSE, FALSE
684      );
685    
686      menu_append_new_item(
687        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_view_detail_dec), _("Less details"),
688        NULL, "<OSM2Go-Main>/View/DetailDec",
689        GDK_comma, GDK_MOD1_MASK, TRUE, FALSE, FALSE
690      );
691    
692    /* -------------------- OSM submenu -------------------- */    /* -------------------- OSM submenu -------------------- */
693    
694    appdata->menu_osm = item = gtk_menu_item_new_with_label( _("OSM") );    appdata->menu_osm = item = gtk_menu_item_new_with_mnemonic( _("_OSM") );
695    gtk_menu_append(GTK_MENU_SHELL(menu), item);    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
696    submenu = gtk_menu_new();    submenu = gtk_menu_new();
697      gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
698    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
699    
700    appdata->menu_item_osm_upload = item =    appdata->menu_item_osm_upload = menu_append_new_item(
701      gtk_menu_item_new_with_label( _("Upload...") );      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_upload), _("_Upload..."),
702    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      "upload.16", "<OSM2Go-Main>/OSM/Upload",
703    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_upload), appdata);      GDK_u, GDK_SHIFT_MASK|GDK_CONTROL_MASK, TRUE, FALSE, FALSE
704      );
705    item = gtk_menu_item_new_with_label( _("Download...") );  
706    gtk_menu_append(GTK_MENU_SHELL(submenu), item);    menu_append_new_item(
707    g_signal_connect(item, "activate",      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_download), _("_Download..."),
708                     GTK_SIGNAL_FUNC(cb_menu_download), appdata);      "download.16", "<OSM2Go-Main>/OSM/Download",
709        GDK_d, GDK_SHIFT_MASK|GDK_CONTROL_MASK, TRUE, FALSE, FALSE
710    gtk_menu_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());    );
711    
712    appdata->menu_item_osm_diff = item =    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
713      gtk_menu_item_new_with_label( _("Save diff file") );  
714    gtk_menu_append(GTK_MENU_SHELL(submenu), item);    if(getenv("OSM2GO_UNDO_TEST")) {
715    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_save_changes),      appdata->menu_item_osm_undo = menu_append_new_item(
716                     appdata);                 appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_undo), _("_Undo"),
717                   GTK_STOCK_UNDO, "<OSM2Go-Main>/OSM/Undo",
718    appdata->menu_item_osm_undo_changes = item =                 GDK_z, GDK_CONTROL_MASK, TRUE, FALSE, FALSE
719      gtk_menu_item_new_with_label( _("Undo all changes...") );                 );
720    gtk_menu_append(GTK_MENU_SHELL(submenu), item);    } else
721    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");
722                     appdata);  
723      appdata->menu_item_osm_save_changes = menu_append_new_item(
724        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_save_changes), _("_Save local changes"),
725        GTK_STOCK_SAVE, "<OSM2Go-Main>/OSM/SaveChanges",
726        GDK_s, GDK_SHIFT_MASK|GDK_CONTROL_MASK, TRUE, FALSE, FALSE
727      );
728    
729      appdata->menu_item_osm_undo_changes = menu_append_new_item(
730        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_undo_changes), _("Disca_rd local changes..."),
731        GTK_STOCK_DELETE, "<OSM2Go-Main>/OSM/DiscardChanges",
732        0, 0, TRUE, FALSE, FALSE
733      );
734    
735      gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
736      appdata->menu_item_osm_relations = menu_append_new_item(
737        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_osm_relations), _("_Relations..."),
738        NULL, "<OSM2Go-Main>/OSM/Relations",
739        GDK_r, GDK_SHIFT_MASK|GDK_CONTROL_MASK, TRUE, FALSE, FALSE
740      );
741    
742    /* -------------------- wms submenu -------------------- */    /* -------------------- wms submenu -------------------- */
743    
744    appdata->menu_wms = item = gtk_menu_item_new_with_label( _("WMS") );    appdata->menu_wms = item = gtk_menu_item_new_with_mnemonic( _("_WMS") );
745    gtk_menu_append(GTK_MENU_SHELL(menu), item);    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
746    submenu = gtk_menu_new();    submenu = gtk_menu_new();
747      gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
748    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
749    
750    item = gtk_menu_item_new_with_label( _("Import...") );    menu_append_new_item(
751    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_wms_import), _("_Import..."),
752    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_wms_import),      GTK_STOCK_INDEX, "<OSM2Go-Main>/WMS/Import",
753                     appdata);      0, 0, TRUE, FALSE, FALSE
754      );
755    appdata->menu_item_wms_clear = item =  
756      gtk_menu_item_new_with_label( _("Clear") );    appdata->menu_item_wms_clear = menu_append_new_item(
757    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_wms_clear), _("_Clear"),
758    gtk_widget_set_sensitive(item, FALSE);      GTK_STOCK_CLEAR, "<OSM2Go-Main>/WMS/Clear",
759    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_wms_clear),      0, 0, TRUE, FALSE, FALSE
760                     appdata);    );
761      gtk_widget_set_sensitive(appdata->menu_item_wms_clear, FALSE);
762    appdata->menu_item_wms_adjust = item =  
763      gtk_menu_item_new_with_label( _("Adjust") );    appdata->menu_item_wms_adjust = menu_append_new_item(
764    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_wms_adjust), _("_Adjust"),
765    gtk_widget_set_sensitive(item, FALSE);      NULL, "<OSM2Go-Main>/WMS/Adjust",
766    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_wms_adjust),      0, 0, TRUE, FALSE, FALSE
767                     appdata);    );
768      gtk_widget_set_sensitive(appdata->menu_item_wms_adjust, FALSE);
769    
770    /* -------------------- map submenu -------------------- */    /* -------------------- map submenu -------------------- */
771    
772    appdata->menu_map = item = gtk_menu_item_new_with_label( _("Map") );    appdata->menu_map = item = gtk_menu_item_new_with_mnemonic( _("_Map") );
773    gtk_menu_append(GTK_MENU_SHELL(menu), item);    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
774    submenu = gtk_menu_new();    submenu = gtk_menu_new();
775      gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
776    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
777    
778    appdata->menu_item_map_hide_sel = item =    appdata->menu_item_map_hide_sel = menu_append_new_item(
779      gtk_menu_item_new_with_label( _("Hide selected") );      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_hide_sel), _("_Hide selected"),
780    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      GTK_STOCK_REMOVE, "<OSM2Go-Main>/Map/HideSelected",
781    gtk_widget_set_sensitive(item, FALSE);      0, 0, TRUE, FALSE, FALSE
782    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_map_hide_sel),    );
783                     appdata);    gtk_widget_set_sensitive(appdata->menu_item_map_hide_sel, FALSE);
784    
785    appdata->menu_item_map_show_all = item =    appdata->menu_item_map_show_all = menu_append_new_item(
786      gtk_menu_item_new_with_label( _("Show all") );      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_show_all), _("_Show all"),
787    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      GTK_STOCK_ADD, "<OSM2Go-Main>/Map/ShowAll",
788    gtk_widget_set_sensitive(item, FALSE);      0, 0, TRUE, FALSE, FALSE
789    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_map_show_all),    );
790                     appdata);    gtk_widget_set_sensitive(appdata->menu_item_map_show_all, FALSE);
791    
792    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());
793    
794    item = gtk_menu_item_new_with_label( _("Redraw") );    menu_append_new_item(
795    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_style), _("St_yle..."),
796    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_redraw), appdata);      GTK_STOCK_SELECT_COLOR, "<OSM2Go-Main>/Map/Style",
797        0, 0, TRUE, FALSE, FALSE
798    gtk_menu_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());    );
799    
800    item = gtk_menu_item_new_with_label( _("Style...") );    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
801    gtk_menu_append(GTK_MENU_SHELL(submenu), item);  
802    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_style), appdata);    /* switches mainly intended for testing/debugging */
803      menu_append_new_item(
804    gtk_menu_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_redraw), _("_Redraw"),
805        NULL, "<OSM2Go-Main>/Map/Redraw",
806    appdata->menu_item_map_no_icons =      GDK_r, GDK_CONTROL_MASK, TRUE, FALSE, FALSE
807      item = gtk_check_menu_item_new_with_label( _("No Icons") );    );
808    gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),  
809                                   appdata->settings->no_icons);    appdata->menu_item_map_no_icons = menu_append_new_item(
810    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_no_icons), _("No _icons"),
811    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_map_no_icons),      NULL, "<OSM2Go-Main>/Map/NoIcons",
812                     appdata);      0, 0, TRUE, TRUE, appdata->settings->no_icons
813      );
814    
815      appdata->menu_item_map_no_antialias = menu_append_new_item(
816        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_no_antialias),
817        _("No _antialias"),
818        NULL, "<OSM2Go-Main>/Map/NoAntialias",
819        0, 0, TRUE, TRUE, appdata->settings->no_antialias
820      );
821    
822    /* -------------------- track submenu -------------------- */    /* -------------------- track submenu -------------------- */
823    
824    appdata->track.menu_track = item = gtk_menu_item_new_with_label(_("Track"));    appdata->track.menu_track = item = gtk_menu_item_new_with_mnemonic(_("_Track"));
825    gtk_menu_append(GTK_MENU_SHELL(menu), item);    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
826    submenu = gtk_menu_new();    submenu = gtk_menu_new();
827      gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
828    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
829    
830    appdata->track.menu_item_import =    appdata->track.menu_item_import = menu_append_new_item(
831      item = gtk_menu_item_new_with_label( _("Import...") );      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_import), _("_Import..."),
832    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      NULL, "<OSM2Go-Main>/Track/Import",
833    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_track_import),      0, 0, TRUE, FALSE, FALSE
834                     appdata);    );
835    
836    appdata->track.menu_item_export =    appdata->track.menu_item_export = menu_append_new_item(
837      item = gtk_menu_item_new_with_label( _("Export...") );      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_export), _("_Export..."),
838    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      NULL, "<OSM2Go-Main>/Track/Export",
839    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_track_export),      0, 0, FALSE, FALSE, FALSE
840                     appdata);    );
841    
842    appdata->track.menu_item_clear =    appdata->track.menu_item_clear = menu_append_new_item(
843      item = gtk_menu_item_new_with_label( _("Clear") );      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_clear), _("_Clear"),
844    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      GTK_STOCK_CLEAR, "<OSM2Go-Main>/Track/Clear",
845    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_track_clear),      0, 0, FALSE, FALSE, FALSE
846                     appdata);    );
847    
848    appdata->track.menu_item_gps =  
849      item = gtk_check_menu_item_new_with_label( _("GPS") );    appdata->track.menu_item_enable_gps = menu_append_new_item(
850    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_enable_gps),_("_GPS enable"),
851    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_track_gps),      NULL, "<OSM2Go-Main>/Track/GPS",
852                     appdata);      GDK_g, GDK_CONTROL_MASK|GDK_SHIFT_MASK, TRUE, TRUE,
853        appdata->settings->enable_gps
854      );
855    
856      appdata->track.menu_item_follow_gps = menu_append_new_item(
857        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_follow_gps), _("GPS follow"),
858        NULL, "<OSM2Go-Main>/Track/Follow",
859        0, 0, appdata->settings->enable_gps, TRUE,
860        appdata->settings->follow_gps
861      );
862    
863    /* ------------------------------------------------------- */    /* ------------------------------------------------------- */
864    
865    gtk_menu_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());    gtk_menu_shell_append(GTK_MENU_SHELL(about_quit_items_menu),
866                            gtk_separator_menu_item_new());
867    
868      menu_append_new_item(
869        appdata, about_quit_items_menu, GTK_SIGNAL_FUNC(cb_menu_about), _("_About..."),
870        GTK_STOCK_ABOUT, "<OSM2Go-Main>/About",
871        0, 0, TRUE, FALSE, FALSE
872      );
873    
874      menu_append_new_item(
875        appdata, about_quit_items_menu, GTK_SIGNAL_FUNC(cb_menu_quit), _("_Quit"),
876        GTK_STOCK_QUIT, "<OSM2Go-Main>/Quit",
877        0, 0, TRUE, FALSE, FALSE
878      );
879    
880    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);  
881    
882  #ifdef USE_HILDON  #ifdef USE_HILDON
883    hildon_window_set_menu(appdata->window, GTK_MENU(menu));    hildon_window_set_menu(appdata->window, GTK_MENU(menu));
884  #else  #else
885    /* attach ordinary gtk menu */    GtkWidget *menu_bar = menu;
886    GtkWidget *menu_bar = gtk_menu_bar_new();  
887    #ifndef UISPECIFIC_MAIN_MENU_IS_MENU_BAR
888      // we need to make one first
889      menu_bar = gtk_menu_bar_new();
890    
891    GtkWidget *root_menu = gtk_menu_item_new_with_label (_("Menu"));    GtkWidget *root_menu = gtk_menu_item_new_with_label (_("Menu"));
892    gtk_widget_show(root_menu);    gtk_widget_show(root_menu);
# Line 576  void menu_create(appdata_t *appdata) { Line 895  void menu_create(appdata_t *appdata) {
895    gtk_menu_item_set_submenu(GTK_MENU_ITEM (root_menu), menu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM (root_menu), menu);
896    
897    gtk_widget_show(menu_bar);    gtk_widget_show(menu_bar);
898    #endif //UISPECIFIC_MAIN_MENU_IS_MENU_BAR
899    
900    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);
901  #endif  
902    #endif //USE_HILDON
903  }  }
904    
905  /********************* end of menu **********************/  /********************* end of menu **********************/
906    
907    #ifdef UISPECIFIC_MENU_HAS_ACCELS
908    #define ACCELS_FILE "accels"
909    
910    static void menu_accels_load(appdata_t *appdata) {
911      char *accels_file = g_strdup_printf("%s/" ACCELS_FILE,
912                                          appdata->settings->base_path);
913      gtk_accel_map_load(accels_file);
914      g_free(accels_file);
915    }
916    
917    static void menu_accels_save(appdata_t *appdata) {
918      char *accels_file = g_strdup_printf("%s" ACCELS_FILE,
919                                          appdata->settings->base_path);
920      gtk_accel_map_save(accels_file);
921      g_free(accels_file);
922    }
923    
924    #endif
925    
926    
927  void cleanup(appdata_t *appdata) {  void cleanup(appdata_t *appdata) {
928    #ifdef UISPECIFIC_MENU_HAS_ACCELS
929      menu_accels_save(appdata);
930    #endif
931    
932    settings_save(appdata->settings);    settings_save(appdata->settings);
933    
934  #ifdef USE_HILDON  #ifdef USE_HILDON
# Line 627  void cleanup(appdata_t *appdata) { Line 972  void cleanup(appdata_t *appdata) {
972    
973    project_free(appdata->project);    project_free(appdata->project);
974    
975      if(appdata->menu_item_osm_undo)
976        undo_free(appdata->undo.state);
977    
978    puts("everything is gone");    puts("everything is gone");
979  }  }
980    
# Line 642  gboolean on_window_key_press(GtkWidget * Line 990  gboolean on_window_key_press(GtkWidget *
990    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
991    int handled = FALSE;    int handled = FALSE;
992    
   //  printf("key event %d\n", event->keyval);  
   
993    // the map handles some keys on its own ...    // the map handles some keys on its own ...
994    switch(event->keyval) {    switch(event->keyval) {
 #ifdef USE_HILDON  
995    
996  #if 0  #ifdef USE_HILDON
997    case HILDON_HARDKEY_SELECT:      /* this is in fact a mapping to GDK_F6 */
     handled = TRUE;  
     break;  
 #endif  
   
998    case HILDON_HARDKEY_FULLSCREEN:    case HILDON_HARDKEY_FULLSCREEN:
999      {  #else
1000        gboolean fullscreen = !gtk_check_menu_item_get_active(    case GDK_F11:
1001                 GTK_CHECK_MENU_ITEM(appdata->fullscreen_menu_item));  #endif
1002        if(!gtk_check_menu_item_get_active(
1003                 GTK_CHECK_MENU_ITEM(appdata->menu_item_view_fullscreen))) {
1004          gtk_window_fullscreen(GTK_WINDOW(appdata->window));
1005        gtk_check_menu_item_set_active(        gtk_check_menu_item_set_active(
1006                 GTK_CHECK_MENU_ITEM(appdata->fullscreen_menu_item), fullscreen);               GTK_CHECK_MENU_ITEM(appdata->menu_item_view_fullscreen), TRUE);
1007          } else {
       if(fullscreen)  
         gtk_window_fullscreen(GTK_WINDOW(appdata->window));  
       else  
1008          gtk_window_unfullscreen(GTK_WINDOW(appdata->window));          gtk_window_unfullscreen(GTK_WINDOW(appdata->window));
1009            gtk_check_menu_item_set_active(
1010        handled = TRUE;               GTK_CHECK_MENU_ITEM(appdata->menu_item_view_fullscreen), FALSE);
1011      }        }
1012    
1013        handled = TRUE;
1014      break;      break;
 #endif  
1015    }    }
1016    
1017    /* forward unprocessed key presses to map */    /* forward unprocessed key presses to map */
# Line 697  int main(int argc, char *argv[]) { Line 1039  int main(int argc, char *argv[]) {
1039    
1040    g_thread_init(NULL);    g_thread_init(NULL);
1041    
   gps_init(&appdata);  
   
1042    gtk_init (&argc, &argv);    gtk_init (&argc, &argv);
1043    
1044      gps_init(&appdata);
1045    
1046  #ifdef USE_HILDON  #ifdef USE_HILDON
1047    printf("Installing osso context for \"org.harbaum." PACKAGE "\"\n");    printf("Installing osso context for \"org.harbaum." PACKAGE "\"\n");
1048    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 1083  int main(int argc, char *argv[]) {
1083    
1084    appdata.vbox = gtk_vbox_new(FALSE,0);    appdata.vbox = gtk_vbox_new(FALSE,0);
1085    menu_create(&appdata);    menu_create(&appdata);
1086    #ifdef UISPECIFIC_MENU_HAS_ACCELS
1087      menu_accels_load(&appdata);
1088    #endif
1089    
1090    /* ----------------------- setup main window ---------------- */    /* ----------------------- setup main window ---------------- */
1091    
# Line 750  int main(int argc, char *argv[]) { Line 1095  int main(int argc, char *argv[]) {
1095  #ifdef PORTRAIT  #ifdef PORTRAIT
1096    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);
1097  #endif  #endif
1098    gtk_box_pack_start(GTK_BOX(vbox), map_new(&appdata), TRUE, TRUE, 0);  
1099      /* generate main map view */
1100      GtkWidget *map = map_new(&appdata);
1101      if(!map) {
1102        cleanup(&appdata);
1103        return -1;
1104      }
1105    
1106      gtk_box_pack_start(GTK_BOX(vbox), map, TRUE, TRUE, 0);
1107    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);
1108    
1109  #ifndef PORTRAIT  #ifndef PORTRAIT
1110    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);
1111  #endif  #endif
1112    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);
1113    gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);    gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
1114    
1115    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 780  int main(int argc, char *argv[]) { Line 1133  int main(int argc, char *argv[]) {
1133    
1134    main_ui_enable(&appdata);    main_ui_enable(&appdata);
1135    
1136      /* start GPS if enabled by config */
1137      if(appdata.settings && appdata.settings->enable_gps)
1138        track_enable_gps(&appdata, TRUE);
1139    
1140    /* ------------ jump into main loop ---------------- */    /* ------------ jump into main loop ---------------- */
1141    
1142    gtk_main();    gtk_main();
# Line 787  int main(int argc, char *argv[]) { Line 1144  int main(int argc, char *argv[]) {
1144    puts("gtk_main() left");    puts("gtk_main() left");
1145    
1146    track_save(appdata.project, appdata.track.track);    track_save(appdata.project, appdata.track.track);
1147      track_clear(&appdata, appdata.track.track);
1148      appdata.track.track = NULL;
1149    
1150    /* save a diff if there are dirty entries */    /* save a diff if there are dirty entries */
1151    diff_save(appdata.project, appdata.osm);    diff_save(appdata.project, appdata.osm);
# Line 795  int main(int argc, char *argv[]) { Line 1154  int main(int argc, char *argv[]) {
1154    
1155    return 0;    return 0;
1156  }  }
1157    
1158    // vim:et:ts=8:sw=2:sts=2:ai
Legend:
Removed from v.15  
changed lines
  Added in v.175