Diff of /trunk/src/main.c

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

revision 55 by achadwick, Sat Feb 7 01:14:09 2009 UTC revision 200 by harbaum, Thu Jul 9 11:44:27 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 21  Line 23 
23  #include <curl/curl.h>  #include <curl/curl.h>
24  #include <gdk/gdkkeysyms.h>  #include <gdk/gdkkeysyms.h>
25    
26    #if defined(USE_HILDON) && (MAEMO_VERSION_MAJOR == 5)
27    #include <hildon/hildon-button.h>
28    #include <hildon/hildon-check-button.h>
29    #include <hildon/hildon-window-stack.h>
30    #include <gdk/gdkx.h>
31    #include <X11/Xatom.h>
32    #endif
33    
34  #include "appdata.h"  #include "appdata.h"
35  #include "banner.h"  #include "banner.h"
36    
# Line 34  static void main_ui_enable(appdata_t *ap Line 44  static void main_ui_enable(appdata_t *ap
44      map_action_cancel(appdata);      map_action_cancel(appdata);
45    
46    /* ---- set project name as window title ----- */    /* ---- set project name as window title ----- */
47  #ifndef USE_HILDON  #if defined(USE_HILDON) && MAEMO_VERSION_MAJOR < 5
48      if(project_valid)
49        gtk_window_set_title(GTK_WINDOW(appdata->window), appdata->project->name);
50      else
51        gtk_window_set_title(GTK_WINDOW(appdata->window), "");
52    #else
53    char *str = NULL;    char *str = NULL;
54    if(project_valid)    if(project_valid)
55      str = g_strdup_printf("OSM2Go - %s", appdata->project->name);      str = g_strdup_printf("OSM2Go - %s", appdata->project->name);
# Line 43  static void main_ui_enable(appdata_t *ap Line 58  static void main_ui_enable(appdata_t *ap
58    
59    gtk_window_set_title(GTK_WINDOW(appdata->window), str);    gtk_window_set_title(GTK_WINDOW(appdata->window), str);
60    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), "");  
61  #endif  #endif
62    
63    if(appdata->iconbar && appdata->iconbar->toolbar)    if(appdata->iconbar && appdata->iconbar->toolbar)
64      gtk_widget_set_sensitive(appdata->iconbar->toolbar, osm_valid);      gtk_widget_set_sensitive(appdata->iconbar->toolbar, osm_valid);
   
65    /* disable all menu entries related to map */    /* disable all menu entries related to map */
66    gtk_widget_set_sensitive(appdata->menu_osm, project_valid);    gtk_widget_set_sensitive(appdata->submenu_map, project_valid);
67    gtk_widget_set_sensitive(appdata->menu_item_osm_upload, osm_valid);    gtk_widget_set_sensitive(appdata->menu_item_map_upload, osm_valid);
68    gtk_widget_set_sensitive(appdata->menu_item_osm_diff, osm_valid);    if(appdata->menu_item_map_undo)
69    gtk_widget_set_sensitive(appdata->menu_item_osm_undo_changes, osm_valid);      gtk_widget_set_sensitive(appdata->menu_item_map_undo, osm_valid);
70    gtk_widget_set_sensitive(appdata->track.menu_track, osm_valid);    gtk_widget_set_sensitive(appdata->menu_item_map_save_changes, osm_valid);
71    gtk_widget_set_sensitive(appdata->menu_view, osm_valid);    gtk_widget_set_sensitive(appdata->menu_item_map_undo_changes, osm_valid);
72    gtk_widget_set_sensitive(appdata->menu_wms, osm_valid);    gtk_widget_set_sensitive(appdata->menu_item_map_relations, osm_valid);
73    gtk_widget_set_sensitive(appdata->menu_map, osm_valid);    gtk_widget_set_sensitive(appdata->track.submenu_track, osm_valid);
74    gtk_widget_set_sensitive(appdata->menu_item_project_close, project_valid);    gtk_widget_set_sensitive(appdata->submenu_view, osm_valid);
75      gtk_widget_set_sensitive(appdata->submenu_wms, osm_valid);
76    
77    #ifdef ZOOM_BUTTONS
78      gtk_widget_set_sensitive(appdata->btn_zoom_in, osm_valid);
79      gtk_widget_set_sensitive(appdata->btn_zoom_out, osm_valid);
80    #endif
81    
82    if(!project_valid)    if(!project_valid)
83      statusbar_set(appdata, _("Please load or create a project"), FALSE);      statusbar_set(appdata, _("Please load or create a project"), FALSE);
# Line 70  static void main_ui_enable(appdata_t *ap Line 85  static void main_ui_enable(appdata_t *ap
85    
86  /******************** begin of menu *********************/  /******************** begin of menu *********************/
87    
 #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  
   
88  static void  static void
89  cb_menu_project_open(GtkWidget *window, gpointer data) {  cb_menu_project_open(GtkMenuItem *item, gpointer data) {
90    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
91    project_load(appdata, NULL);    project_load(appdata, NULL);
92    main_ui_enable(appdata);    main_ui_enable(appdata);
93  }  }
94    
95  static void  static void
96  cb_menu_project_close(GtkWidget *window, gpointer data) {  cb_menu_project_wizard(GtkMenuItem *item, gpointer data) {
97    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
98    project_close(appdata);    project_wizard(appdata);
   main_ui_enable(appdata);  
99  }  }
100    
101  static void  static void
102  cb_menu_about(GtkWidget *window, gpointer data) {  cb_menu_about(GtkMenuItem *item, gpointer data) {
103    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"));  
104    
105    const gchar *authors[] = {    const gchar *authors[] = {
106      "Till Harbaum <till@harbaum.org>",      "Till Harbaum <till@harbaum.org>",
107      "Andrew Chadwick <andrewc-osm2go@piffle.org>",      "Andrew Chadwick <andrewc-osm2go@piffle.org>",
108        "Marcus Bauer <marcus.bauer@gmail.com>",
109        "John Stowers <john.stowers@gmail.com>",
110      NULL };      NULL };
111    
112    gtk_about_dialog_set_authors(about, authors);    const gchar *artists[] = {
113        "Andrew Zhilin <drew.zhilin@gmail.com>",
114    gtk_about_dialog_set_website(about,      NULL };
        _("http://www.harbaum.org/till/maemo"));  
   
   gtk_about_dialog_set_comments(about,  
        _("Mobile OSM Editor"));  
115    
116    gtk_widget_show_all(GTK_WIDGET(about));    gtk_show_about_dialog(GTK_WINDOW(appdata->window),
117    gtk_dialog_run(GTK_DIALOG(about));                          "name", "OSM2Go",
118    gtk_widget_destroy(GTK_WIDGET(about));                          "version", VERSION,
119                            "copyright", _("Copyright 2008-2009"),
120                            "authors", authors,
121                            "artists", artists,
122                            "website", _("http://www.harbaum.org/till/maemo"),
123                            "comments", _("Mobile OSM Editor"),
124                            NULL);
125  }  }
126    
127  void on_window_destroy (GtkWidget *widget, gpointer data);  void on_window_destroy (GtkWidget *widget, gpointer data);
128    
129    #ifndef USE_HILDON
130  static void  static void
131  cb_menu_quit(GtkWidget *window, gpointer data) {  cb_menu_quit(GtkMenuItem *item, gpointer data) {
132    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
133    gtk_widget_destroy(GTK_WIDGET(appdata->window));    gtk_widget_destroy(GTK_WIDGET(appdata->window));
134  }  }
135    #endif
136    
137  static void  static void
138  cb_menu_upload(GtkWidget *window, gpointer data) {  cb_menu_upload(GtkMenuItem *item, gpointer data) {
139    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
140    if(!appdata->osm || !appdata->project) return;    if(!appdata->osm || !appdata->project) return;
141    
142      if(project_check_demo(GTK_WIDGET(appdata->window), appdata->project))
143        return;
144    
145    osm_upload(appdata, appdata->osm, appdata->project);    osm_upload(appdata, appdata->osm, appdata->project);
146  }  }
147    
148  static void  static void
149  cb_menu_download(GtkWidget *window, gpointer data) {  cb_menu_download(GtkMenuItem *item, gpointer data) {
150    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
151    if(!appdata->project) return;    if(!appdata->project) return;
152    
153      if(project_check_demo(GTK_WIDGET(appdata->window), appdata->project))
154        return;
155    
156    /* if we have valid osm data loaded: save state first */    /* if we have valid osm data loaded: save state first */
157    if(appdata->osm) {    if(appdata->osm) {
158      /* 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 155  cb_menu_download(GtkWidget *window, gpoi Line 164  cb_menu_download(GtkWidget *window, gpoi
164    }    }
165    
166    // download    // download
167    if(osm_download(GTK_WIDGET(appdata->window), appdata->project)) {    if(osm_download(GTK_WIDGET(appdata->window), appdata->settings,
168      banner_busy_start(appdata, 1, "Redrawing...");                    appdata->project)) {
169      appdata->osm = osm_parse(appdata->project->osm);      banner_busy_start(appdata, 1, "Redrawing");
170        appdata->osm = osm_parse(appdata->project->path, appdata->project->osm);
171      diff_restore(appdata, appdata->project, appdata->osm);      diff_restore(appdata, appdata->project, appdata->osm);
172      map_paint(appdata);      map_paint(appdata);
173      banner_busy_stop(appdata); //"Redrawing..."      banner_busy_stop(appdata); //"Redrawing"
174    }    }
175    
176    main_ui_enable(appdata);    main_ui_enable(appdata);
177  }  }
178    
179  static void  static void
180  cb_menu_wms_import(GtkWidget *window, gpointer data) {  cb_menu_wms_import(GtkMenuItem *item, gpointer data) {
181    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
182    wms_import(appdata);    wms_import(appdata);
183  }  }
184    
185  static void  static void
186  cb_menu_wms_clear(GtkWidget *window, gpointer data) {  cb_menu_wms_clear(GtkMenuItem *item, gpointer data) {
187    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
188    wms_remove(appdata);    wms_remove(appdata);
189  }  }
190    
191  static void  static void
192  cb_menu_wms_adjust(GtkWidget *window, gpointer data) {  cb_menu_wms_adjust(GtkMenuItem *item, gpointer data) {
193    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
194    map_action_set(appdata, MAP_ACTION_BG_ADJUST);    map_action_set(appdata, MAP_ACTION_BG_ADJUST);
195  }  }
# Line 187  cb_menu_wms_adjust(GtkWidget *window, gp Line 197  cb_menu_wms_adjust(GtkWidget *window, gp
197  /* ----------- hide objects for performance reasons ----------- */  /* ----------- hide objects for performance reasons ----------- */
198    
199  static void  static void
200  cb_menu_map_hide_sel(GtkWidget *window, gpointer data) {  cb_menu_map_hide_sel(GtkMenuItem *item, gpointer data) {
201    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
202    map_hide_selected(appdata);    map_hide_selected(appdata);
203  }  }
204    
205  static void  static void
206  cb_menu_map_show_all(GtkWidget *window, gpointer data) {  cb_menu_map_show_all(GtkMenuItem *item, gpointer data) {
207    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
208    map_show_all(appdata);    map_show_all(appdata);
209  }  }
210    
211  /* ---------------------------------------------------------- */  /* ---------------------------------------------------------- */
212    
213  #if 1  // mainly for testing  #if defined(USE_HILDON) && (MAEMO_VERSION_MAJOR == 5)
214  static void  #define MENU_CHECK_ITEM HildonCheckButton
215  cb_menu_redraw(GtkWidget *window, gpointer data) {  #define MENU_CHECK_ITEM_ACTIVE(a) hildon_check_button_get_active(a)
216    appdata_t *appdata = (appdata_t*)data;  #else
217    #define MENU_CHECK_ITEM GtkCheckMenuItem
218    #define MENU_CHECK_ITEM_ACTIVE(a) gtk_check_menu_item_get_active(a)
219    #endif
220    
221    /* redraw the entire map by destroying all map items and redrawing them */  static void
222    banner_busy_start(appdata, 1, "Redrawing...");  cb_menu_map_no_icons(MENU_CHECK_ITEM *item, appdata_t *appdata) {
   track_save(appdata->project, appdata->track.track);  
   diff_save(appdata->project, appdata->osm);  
   map_clear(appdata, MAP_LAYER_ALL);  
   osm_free(&appdata->icon, appdata->osm);  
223    
224    appdata->osm = osm_parse(appdata->project->osm);    banner_busy_start(appdata, 1, "Redrawing");
225    diff_restore(appdata, appdata->project, appdata->osm);    map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);
   map_paint(appdata);  
226    
227    appdata->track.track = track_restore(appdata, appdata->project);    appdata->settings->no_icons = MENU_CHECK_ITEM_ACTIVE(item);
   if(appdata->track.track)  
     map_track_draw(appdata->map, appdata->track.track);  
228    
229    wms_load(appdata);    map_paint(appdata);
230    banner_busy_stop(appdata); //"Redrawing..."    banner_busy_stop(appdata); //"Redrawing"
231  }  }
 #endif  
232    
233  static void  static void
234  cb_menu_style(GtkWidget *widget, gpointer data) {  cb_menu_style(GtkMenuItem *item, gpointer data) {
235    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
236    
237    style_select(GTK_WIDGET(appdata->window), appdata);    style_select(GTK_WIDGET(appdata->window), appdata);
238  }  }
239    
240  static void  static void
241  cb_menu_map_no_icons(GtkWidget *widget, gpointer data) {  cb_menu_undo(GtkMenuItem *item, gpointer data) {
242    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
243    
244    banner_busy_start(appdata, 1, "Redrawing...");    undo(appdata);
   map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);  
   appdata->settings->no_icons =  
     gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget));  
   map_paint(appdata);  
   banner_busy_stop(appdata); //"Redrawing..."  
 }  
   
 static void  
 cb_menu_map_no_antialias(GtkWidget *widget, gpointer data) {  
   appdata_t *appdata = (appdata_t*)data;  
245    
246    banner_busy_start(appdata, 1, "Redrawing...");    // the banner will be displayed from within undo with more details
   map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);  
   appdata->settings->no_antialias =  
     gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget));  
   map_paint(appdata);  
   banner_busy_stop(appdata); //"Redrawing..."  
247  }  }
248    
249  static void  static void
250  cb_menu_save_changes(GtkWidget *widget, gpointer data) {  cb_menu_save_changes(GtkMenuItem *item, gpointer data) {
251    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
252    
253    diff_save(appdata->project, appdata->osm);    diff_save(appdata->project, appdata->osm);
# Line 265  cb_menu_save_changes(GtkWidget *widget, Line 255  cb_menu_save_changes(GtkWidget *widget,
255  }  }
256    
257  static void  static void
258  cb_menu_undo_changes(GtkWidget *widget, gpointer data) {  cb_menu_undo_changes(GtkMenuItem *item, gpointer data) {
259    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
260    
261    if(!yes_no_f(GTK_WIDGET(appdata->window), NULL, 0, 0,    if(!yes_no_f(GTK_WIDGET(appdata->window), NULL, 0, 0,
262                 _("Discard local changes?"),                 _("Discard local changes?"),
263                 _("Throw away all the changes you've not uploaded yet? This can't be undone.")))                 _("Throw away all the changes you've not "
264                     "uploaded yet? This can't be undone.")))
265      return;      return;
266    
267    banner_busy_start(appdata, 1, _("Redrawing..."));    banner_busy_start(appdata, 1, _("Redrawing"));
268    map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);    map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);
269    osm_free(&appdata->icon, appdata->osm);    osm_free(&appdata->icon, appdata->osm);
270    diff_remove(appdata->project);    diff_remove(appdata->project);
271    appdata->osm = osm_parse(appdata->project->osm);    appdata->osm = osm_parse(appdata->project->path, appdata->project->osm);
272    map_paint(appdata);    map_paint(appdata);
273    banner_busy_stop(appdata);  //"Redrawing..."    banner_busy_stop(appdata);  //"Redrawing"
274    
275    banner_show_info(appdata, _("Discarded local changes"));    banner_show_info(appdata, _("Discarded local changes"));
276  }  }
277    
278  static void  static void
279  cb_menu_fullscreen(GtkWidget *widget, gpointer data) {  cb_menu_osm_relations(GtkMenuItem *item, appdata_t *appdata) {
280      /* list relations of all objects */
281      relation_list(GTK_WIDGET(appdata->window), appdata, NULL);
282    }
283    
284    #if !defined(USE_HILDON) || (MAEMO_VERSION_MAJOR < 5)
285    static void
286    cb_menu_fullscreen(MENU_CHECK_ITEM *item, gpointer data) {
287    appdata_t *appdata = (appdata_t *)data;    appdata_t *appdata = (appdata_t *)data;
288    
289    if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget)))    if(MENU_CHECK_ITEM_ACTIVE(item))
290      gtk_window_fullscreen(GTK_WINDOW(appdata->window));      gtk_window_fullscreen(GTK_WINDOW(appdata->window));
291    else    else
292      gtk_window_unfullscreen(GTK_WINDOW(appdata->window));      gtk_window_unfullscreen(GTK_WINDOW(appdata->window));
293  }  }
294    #endif
295    
296  static void  static void
297  cb_menu_zoomin(GtkWidget *widget, appdata_t *appdata) {  cb_menu_zoomin(GtkMenuItem *item, appdata_t *appdata) {
298    if(!appdata || !appdata->map) return;    if(!appdata || !appdata->map) return;
299    
300    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_zoomin(GtkWidget *widget, appdat Line 302  cb_menu_zoomin(GtkWidget *widget, appdat
302  }  }
303    
304  static void  static void
305  cb_menu_zoomout(GtkWidget *widget, appdata_t *appdata) {  cb_menu_zoomout(GtkMenuItem *item, appdata_t *appdata) {
306    if(!appdata || !appdata->map) return;    if(!appdata || !appdata->map) return;
307    
308    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 311  cb_menu_zoomout(GtkWidget *widget, appda Line 310  cb_menu_zoomout(GtkWidget *widget, appda
310  }  }
311    
312  static void  static void
313  cb_menu_track_import(GtkWidget *window, appdata_t *appdata) {  cb_menu_view_detail_inc(GtkMenuItem *item, gpointer data) {
314      appdata_t *appdata = (appdata_t*)data;
315    
316      printf("detail level increase\n");
317      map_detail_increase(appdata->map);
318    }
319    
320    static void
321    cb_menu_view_detail_normal(GtkMenuItem *item, gpointer data) {
322      appdata_t *appdata = (appdata_t*)data;
323    
324      printf("detail level normal\n");
325      map_detail_normal(appdata->map);
326    }
327    
328    static void
329    cb_menu_view_detail_dec(GtkMenuItem *item, gpointer data) {
330      appdata_t *appdata = (appdata_t*)data;
331    
332      printf("detail level decrease\n");
333      map_detail_decrease(appdata->map);
334    }
335    
336    static void
337    cb_menu_track_import(GtkMenuItem *item, appdata_t *appdata) {
338      g_assert(appdata->settings);
339    
340    /* open a file selector */    /* open a file selector */
341    GtkWidget *dialog;    GtkWidget *dialog;
# Line 328  cb_menu_track_import(GtkWidget *window, Line 352  cb_menu_track_import(GtkWidget *window,
352                          NULL);                          NULL);
353  #endif  #endif
354    
355    /* use path if one is present */    if(appdata->settings->track_path) {
356    if(appdata->track.import_path)      if(!g_file_test(appdata->settings->track_path, G_FILE_TEST_EXISTS)) {
357      gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),        char *last_sep = strrchr(appdata->settings->track_path, '/');
358                                          appdata->track.import_path);        if(last_sep) {
359            *last_sep = 0;  // seperate path from file
360    
361            /* the user just created a new document */
362            gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
363                                        appdata->settings->track_path);
364            gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog),
365                                              last_sep+1);
366    
367            /* restore full filename */
368            *last_sep = '/';
369          }
370        } else
371          gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),
372                                        appdata->settings->track_path);
373      }
374    
375    gtk_widget_show_all (GTK_WIDGET(dialog));    gtk_widget_show_all (GTK_WIDGET(dialog));
376    if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_FM_OK) {    if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_FM_OK) {
377      char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));      char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
378    
379      /* load a track */      /* load a track */
380      track_do(appdata, TRACK_IMPORT, filename);      appdata->track.track = track_import(appdata, filename);
381      if(appdata->track.track) {      if(appdata->track.track) {
382          if(appdata->settings->track_path) g_free(appdata->settings->track_path);
383        /* 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 = '/';  
       }  
384      }      }
385      g_free (filename);      g_free (filename);
386    }    }
# Line 360  cb_menu_track_import(GtkWidget *window, Line 389  cb_menu_track_import(GtkWidget *window,
389  }  }
390    
391  static void  static void
392  cb_menu_track_gps(GtkWidget *window, gpointer data) {  cb_menu_track_enable_gps(MENU_CHECK_ITEM *item, appdata_t *appdata) {
393    appdata_t *appdata = (appdata_t*)data;    track_enable_gps(appdata, MENU_CHECK_ITEM_ACTIVE(item));
394    }
395    
396    if(gtk_check_menu_item_get_active(  
397      GTK_CHECK_MENU_ITEM(appdata->track.menu_item_gps))) {  static void
398      track_do(appdata, TRACK_GPS, NULL);  cb_menu_track_follow_gps(MENU_CHECK_ITEM *item, appdata_t *appdata) {
399    } else {    appdata->settings->follow_gps = MENU_CHECK_ITEM_ACTIVE(item);
     track_do(appdata, TRACK_NONE, NULL);  
   }  
400  }  }
401    
402    
403  static void  static void
404  cb_menu_track_export(GtkWidget *window, gpointer data) {  cb_menu_track_export(GtkMenuItem *item, appdata_t *appdata) {
405    appdata_t *appdata = (appdata_t*)data;    g_assert(appdata->settings);
406    messagef(GTK_WIDGET(appdata->window), _("NIY"),  
407             _("Track export is not yet supported."));    /* open a file selector */
408      GtkWidget *dialog;
409    
410    #ifdef USE_HILDON
411      dialog = hildon_file_chooser_dialog_new(GTK_WINDOW(appdata->window),
412                                              GTK_FILE_CHOOSER_ACTION_SAVE);
413    #else
414      dialog = gtk_file_chooser_dialog_new(_("Export track file"),
415                                           GTK_WINDOW(appdata->window),
416                                           GTK_FILE_CHOOSER_ACTION_SAVE,
417                                           GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
418                                           GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
419                                           NULL);
420    #endif
421    
422      printf("set filename <%s>\n", appdata->settings->track_path);
423    
424      if(appdata->settings->track_path) {
425        if(!g_file_test(appdata->settings->track_path, G_FILE_TEST_EXISTS)) {
426          char *last_sep = strrchr(appdata->settings->track_path, '/');
427          if(last_sep) {
428            *last_sep = 0;  // seperate path from file
429    
430            /* the user just created a new document */
431            gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
432                                                appdata->settings->track_path);
433            gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog),
434                                              last_sep+1);
435    
436            /* restore full filename */
437            *last_sep = '/';
438          }
439        } else
440          gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),
441                                        appdata->settings->track_path);
442      }
443    
444      if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_FM_OK) {
445        gchar *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
446        if(filename) {
447          printf("export to %s\n", filename);
448    
449          if(!g_file_test(filename, G_FILE_TEST_EXISTS) ||
450             yes_no_f(dialog, appdata, MISC_AGAIN_ID_EXPORT_OVERWRITE,
451                      MISC_AGAIN_FLAG_DONT_SAVE_NO,
452                      "Overwrite existing file",
453                      "The file already exists. "
454                      "Do you really want to replace it?")) {
455            if(appdata->settings->track_path)
456              g_free(appdata->settings->track_path);
457            appdata->settings->track_path = g_strdup(filename);
458    
459            track_export(appdata, filename);
460          }
461        }
462      }
463    
464      gtk_widget_destroy (dialog);
465  }  }
466    
467    
468  static void  static void
469  cb_menu_track_clear(GtkWidget *window, gpointer data) {  cb_menu_track_clear(GtkMenuItem *item, gpointer data) {
470    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
471    track_do(appdata, TRACK_NONE, NULL);    track_clear(appdata, appdata->track.track);
472      appdata->track.track = NULL;
473  }  }
474    
475    
# Line 415  cb_menu_track_clear(GtkWidget *window, g Line 503  cb_menu_track_clear(GtkWidget *window, g
503  #endif  #endif
504    
505    
506    #if !defined(USE_HILDON) || (MAEMO_VERSION_MAJOR < 5)
507  // Half-arsed slapdash common menu item constructor. Let's use GtkBuilder  // Half-arsed slapdash common menu item constructor. Let's use GtkBuilder
508  // instead so we have some flexibility.  // instead so we have some flexibility.
509    
# Line 424  menu_append_new_item(appdata_t *appdata, Line 512  menu_append_new_item(appdata_t *appdata,
512                       GtkWidget *menu_shell,                       GtkWidget *menu_shell,
513                       GtkSignalFunc activate_cb,                       GtkSignalFunc activate_cb,
514                       char *label,                       char *label,
515                       const gchar *stock_id, // overridden by label, accels                       const gchar *icon_name, // stock id or name for icon_load
516                                        // overridden by label, accels, icon_name
517                       const gchar *accel_path,                       const gchar *accel_path,
518                       guint accel_key,      // from gdk/gdkkeysyms.h                       guint accel_key,      // from gdk/gdkkeysyms.h
519                       GdkModifierType accel_mods, // e.g. GDK_CONTROL_MASK                       GdkModifierType accel_mods, // e.g. GDK_CONTROL_MASK
520                         gboolean enabled,
521                       gboolean is_check, gboolean check_status)                       gboolean is_check, gboolean check_status)
522  {  {
523    GtkWidget *item = NULL;    GtkWidget *item = NULL;
524    GtkStockItem stock_item;    GtkWidget *image = NULL;
525    
526    gboolean stock_item_known = FALSE;    gboolean stock_item_known = FALSE;
527    if (stock_id != NULL) {    GtkStockItem stock_item;
528      stock_item_known = gtk_stock_lookup(stock_id, &stock_item);    if (icon_name != NULL) {
529        stock_item_known = gtk_stock_lookup(icon_name, &stock_item);
530    }    }
531    
532    // Icons    // Icons
# Line 442  menu_append_new_item(appdata_t *appdata, Line 534  menu_append_new_item(appdata_t *appdata,
534    item = is_check ? gtk_check_menu_item_new_with_mnemonic (label)    item = is_check ? gtk_check_menu_item_new_with_mnemonic (label)
535                    : gtk_menu_item_new_with_mnemonic       (label);                    : gtk_menu_item_new_with_mnemonic       (label);
536  #else  #else
537    if (is_check || !stock_item_known) {    if (is_check) {
538      item = is_check ? gtk_check_menu_item_new_with_mnemonic (label)      item = gtk_check_menu_item_new_with_mnemonic (label);
539                      : gtk_menu_item_new_with_mnemonic       (label);    }
540      else if (!stock_item_known) {
541        GdkPixbuf *pbuf = icon_load(&appdata->icon, icon_name);
542        if (pbuf) {
543          image = gtk_image_new_from_pixbuf(pbuf);
544        }
545        if (image) {
546          item = gtk_image_menu_item_new_with_mnemonic(label);
547          gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
548        }
549        else {
550          item = gtk_menu_item_new_with_mnemonic(label);
551        }
552    }    }
553    else {    else {
554      item = gtk_image_menu_item_new_with_mnemonic(label);      item = gtk_image_menu_item_new_with_mnemonic(label);
555      GtkWidget *stock_image = gtk_image_new_from_stock(stock_id, GTK_ICON_SIZE_MENU);      image = gtk_image_new_from_stock(icon_name, GTK_ICON_SIZE_MENU);
556      gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), stock_image);      gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
557    }    }
558  #endif  #endif
559    
# Line 469  menu_append_new_item(appdata_t *appdata, Line 573  menu_append_new_item(appdata_t *appdata,
573  #endif  #endif
574    
575    gtk_menu_shell_append(GTK_MENU_SHELL(menu_shell), GTK_WIDGET(item));    gtk_menu_shell_append(GTK_MENU_SHELL(menu_shell), GTK_WIDGET(item));
576    if (is_check) {    gtk_widget_set_sensitive(GTK_WIDGET(item), enabled);
577      if (is_check)
578      gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), check_status);      gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), check_status);
579    }  
580    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(activate_cb),    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(activate_cb),
581                     appdata);                     appdata);
582    return item;    return item;
583  }  }
584    
   
585  void menu_create(appdata_t *appdata) {  void menu_create(appdata_t *appdata) {
586    GtkWidget *menu, *item, *submenu;    GtkWidget *menu, *item, *submenu;
587    GtkWidget *about_quit_items_menu;    GtkWidget *about_quit_items_menu;
# Line 502  void menu_create(appdata_t *appdata) { Line 606  void menu_create(appdata_t *appdata) {
606  #endif  #endif
607    
608    menu_append_new_item(    menu_append_new_item(
609      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_project_open), _("_Open..."),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_project_open), _("_Open"),
610      GTK_STOCK_OPEN, "<OSM2Go-Main>/Project/Open",      GTK_STOCK_OPEN, "<OSM2Go-Main>/Project/Open",
611      0, 0, FALSE, FALSE      0, 0, TRUE, FALSE, FALSE
612    );    );
613    
614    appdata->menu_item_project_close = menu_append_new_item(    menu_append_new_item(
615      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_project_close), _("_Close"),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_project_wizard), _("_Wizard"),
616      GTK_STOCK_CLOSE, "<OSM2Go-Main>/Project/Close",      GTK_STOCK_NEW, "<OSM2Go-Main>/Project/Wizard",
617      0, 0, FALSE, FALSE      0, 0, TRUE, FALSE, FALSE
618    );    );
619    
620    /* --------------- view menu ------------------- */    /* --------------- view menu ------------------- */
621    
622  #ifndef UISPECIFIC_MENU_IS_MENU_BAR  #ifndef UISPECIFIC_MAIN_MENU_IS_MENU_BAR
623    gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());    gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
624  #endif  #endif
625    
626    appdata->menu_view = item = gtk_menu_item_new_with_mnemonic( _("_View") );    appdata->submenu_view = item = gtk_menu_item_new_with_mnemonic( _("_View") );
627    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
628    submenu = gtk_menu_new();    submenu = gtk_menu_new();
629    gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);    gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
630    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
631    
632    #if !defined(USE_HILDON) || (MAEMO_VERSION_MAJOR < 5)
633    appdata->menu_item_view_fullscreen = menu_append_new_item(    appdata->menu_item_view_fullscreen = menu_append_new_item(
634      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_fullscreen), _("_Fullscreen"),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_fullscreen), _("_Fullscreen"),
635      GTK_STOCK_FULLSCREEN, "<OSM2Go-Main>/View/Fullscreen",      GTK_STOCK_FULLSCREEN, "<OSM2Go-Main>/View/Fullscreen",
636      0, 0, TRUE, FALSE      0, 0, TRUE, TRUE, FALSE
637    );    );
638    #endif
639    
640    menu_append_new_item(    menu_append_new_item(
641      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_zoomin), _("Zoom _in"),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_zoomin), _("Zoom _in"),
642      GTK_STOCK_ZOOM_IN, "<OSM2Go-Main>/View/ZoomIn",      GTK_STOCK_ZOOM_IN, "<OSM2Go-Main>/View/ZoomIn",
643      GDK_comma, GDK_CONTROL_MASK, FALSE, FALSE      GDK_comma, GDK_CONTROL_MASK, TRUE, FALSE, FALSE
644    );    );
645    
646    menu_append_new_item(    menu_append_new_item(
647      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_zoomout), _("Zoom _out"),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_zoomout), _("Zoom _out"),
648      GTK_STOCK_ZOOM_OUT, "<OSM2Go-Main>/View/ZoomOut",      GTK_STOCK_ZOOM_OUT, "<OSM2Go-Main>/View/ZoomOut",
649      GDK_period, GDK_CONTROL_MASK, FALSE, FALSE      GDK_period, GDK_CONTROL_MASK, TRUE, FALSE, FALSE
650    );    );
651    
652    /* -------------------- OSM submenu -------------------- */    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
653    
654    appdata->menu_osm = item = gtk_menu_item_new_with_mnemonic( _("_OSM") );    menu_append_new_item(
655    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_view_detail_inc), _("More details"),
656    submenu = gtk_menu_new();      NULL, "<OSM2Go-Main>/View/DetailInc",
657    gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);      GDK_period, GDK_MOD1_MASK, TRUE, FALSE, FALSE
658    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    );
659    
660    appdata->menu_item_osm_upload = menu_append_new_item(    menu_append_new_item(
661      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_upload), _("_Upload..."),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_view_detail_normal), _("Normal details"),
662      NULL, "<OSM2Go-Main>/OSM/Upload",      NULL, "<OSM2Go-Main>/View/DetailNormal",
663      GDK_u, GDK_SHIFT_MASK|GDK_CONTROL_MASK, FALSE, FALSE      0, 0, TRUE, FALSE, FALSE
664    );    );
665    
666    menu_append_new_item(    menu_append_new_item(
667      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_download), _("_Download..."),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_view_detail_dec), _("Less details"),
668      NULL, "<OSM2Go-Main>/OSM/Download",      NULL, "<OSM2Go-Main>/View/DetailDec",
669      GDK_d, GDK_SHIFT_MASK|GDK_CONTROL_MASK, FALSE, FALSE      GDK_comma, GDK_MOD1_MASK, TRUE, FALSE, FALSE
670    );    );
671    
672    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
673    
674      appdata->menu_item_map_hide_sel = menu_append_new_item(
675    appdata->menu_item_osm_diff = menu_append_new_item(      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_hide_sel), _("_Hide selected"),
676      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_save_changes), _("_Save local changes"),      GTK_STOCK_REMOVE, "<OSM2Go-Main>/View/HideSelected",
677      GTK_STOCK_SAVE, "<OSM2Go-Main>/OSM/SaveChanges",      0, 0, TRUE, FALSE, FALSE
     GDK_s, GDK_SHIFT_MASK|GDK_CONTROL_MASK, FALSE, FALSE  
678    );    );
679      gtk_widget_set_sensitive(appdata->menu_item_map_hide_sel, FALSE);
680    
681    appdata->menu_item_osm_undo_changes = menu_append_new_item(    appdata->menu_item_map_show_all = menu_append_new_item(
682      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_undo_changes), _("Disca_rd local changes..."),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_show_all), _("_Show all"),
683      GTK_STOCK_DELETE, "<OSM2Go-Main>/OSM/DiscardChanges",      GTK_STOCK_ADD, "<OSM2Go-Main>/View/ShowAll",
684      0, 0, FALSE, FALSE      0, 0, TRUE, FALSE, FALSE
685    );    );
686      gtk_widget_set_sensitive(appdata->menu_item_map_show_all, FALSE);
687    
688    /* -------------------- wms submenu -------------------- */    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
689    
   appdata->menu_wms = item = gtk_menu_item_new_with_mnemonic( _("_WMS") );  
   gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);  
   submenu = gtk_menu_new();  
   gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);  
   gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);  
   
690    menu_append_new_item(    menu_append_new_item(
691      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_wms_import), _("_Import..."),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_style), _("St_yle"),
692      GTK_STOCK_INDEX, "<OSM2Go-Main>/WMS/Import",      GTK_STOCK_SELECT_COLOR, "<OSM2Go-Main>/View/Style",
693      0, 0, FALSE, FALSE      0, 0, TRUE, FALSE, FALSE
694    );    );
695    
696    appdata->menu_item_wms_clear = menu_append_new_item(    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
     appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_wms_clear), _("_Clear"),  
     GTK_STOCK_CLEAR, "<OSM2Go-Main>/WMS/Clear",  
     0, 0, FALSE, FALSE  
   );  
   gtk_widget_set_sensitive(appdata->menu_item_wms_clear, FALSE);  
697    
698    appdata->menu_item_wms_adjust = menu_append_new_item(    appdata->menu_item_map_no_icons = menu_append_new_item(
699      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_wms_adjust), _("_Adjust"),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_no_icons), _("No _icons"),
700      NULL, "<OSM2Go-Main>/WMS/Adjust",      NULL, "<OSM2Go-Main>/View/NoIcons",
701      0, 0, FALSE, FALSE      0, 0, TRUE, TRUE, appdata->settings->no_icons
702    );    );
703    gtk_widget_set_sensitive(appdata->menu_item_wms_adjust, FALSE);  
704    
705    /* -------------------- map submenu -------------------- */    /* -------------------- map submenu -------------------- */
706    
707    appdata->menu_map = item = gtk_menu_item_new_with_mnemonic( _("_Map") );    appdata->submenu_map = item = gtk_menu_item_new_with_mnemonic( _("_Map") );
708    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
709    submenu = gtk_menu_new();    submenu = gtk_menu_new();
710    gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);    gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
711    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
712    
713    appdata->menu_item_map_hide_sel = menu_append_new_item(    appdata->menu_item_map_upload = menu_append_new_item(
714      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_hide_sel), _("_Hide selected"),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_upload), _("_Upload"),
715      GTK_STOCK_REMOVE, "<OSM2Go-Main>/Map/HideSelected",      "upload.16", "<OSM2Go-Main>/Map/Upload",
716      0, 0, FALSE, FALSE      GDK_u, GDK_SHIFT_MASK|GDK_CONTROL_MASK, TRUE, FALSE, FALSE
717    );    );
   gtk_widget_set_sensitive(appdata->menu_item_map_hide_sel, FALSE);  
718    
719    appdata->menu_item_map_show_all = menu_append_new_item(    menu_append_new_item(
720      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_show_all), _("_Show all"),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_download), _("_Download"),
721      GTK_STOCK_ADD, "<OSM2Go-Main>/Map/ShowAll",      "download.16", "<OSM2Go-Main>/Map/Download",
722      0, 0, FALSE, FALSE      GDK_d, GDK_SHIFT_MASK|GDK_CONTROL_MASK, TRUE, FALSE, FALSE
723    );    );
   gtk_widget_set_sensitive(appdata->menu_item_map_show_all, FALSE);  
724    
725    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
726    
727    menu_append_new_item(    if(getenv("OSM2GO_UNDO_TEST")) {
728      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_style), _("St_yle..."),      appdata->menu_item_map_undo = menu_append_new_item(
729      GTK_STOCK_SELECT_COLOR, "<OSM2Go-Main>/Map/Style",                 appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_undo), _("_Undo"),
730      0, 0, FALSE, FALSE                 GTK_STOCK_UNDO, "<OSM2Go-Main>/Map/Undo",
731                   GDK_z, GDK_CONTROL_MASK, TRUE, FALSE, FALSE
732                   );
733      } else
734        printf("set environment variable OSM2GO_UNDO_TEST to enable undo framework tests\n");
735    
736      appdata->menu_item_map_save_changes = menu_append_new_item(
737        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_save_changes), _("_Save local changes"),
738        GTK_STOCK_SAVE, "<OSM2Go-Main>/Map/SaveChanges",
739        GDK_s, GDK_SHIFT_MASK|GDK_CONTROL_MASK, TRUE, FALSE, FALSE
740      );
741    
742      appdata->menu_item_map_undo_changes = menu_append_new_item(
743        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_undo_changes), _("Disca_rd local changes"),
744        GTK_STOCK_DELETE, "<OSM2Go-Main>/Map/DiscardChanges",
745        0, 0, TRUE, FALSE, FALSE
746    );    );
747    
748    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
749      appdata->menu_item_map_relations = menu_append_new_item(
750        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_osm_relations), _("_Relations"),
751        NULL, "<OSM2Go-Main>/Map/Relations",
752        GDK_r, GDK_SHIFT_MASK|GDK_CONTROL_MASK, TRUE, FALSE, FALSE
753      );
754    
755      /* -------------------- wms submenu -------------------- */
756    
757    /* switches mainly intended for testing/debugging */    appdata->submenu_wms = item = gtk_menu_item_new_with_mnemonic( _("_WMS") );
758      gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
759      submenu = gtk_menu_new();
760      gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
761      gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
762    
763    menu_append_new_item(    menu_append_new_item(
764      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_redraw), _("_Redraw"),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_wms_import), _("_Import"),
765      NULL, "<OSM2Go-Main>/Map/Redraw",      GTK_STOCK_INDEX, "<OSM2Go-Main>/WMS/Import",
766      GDK_r, GDK_CONTROL_MASK, FALSE, FALSE      0, 0, TRUE, FALSE, FALSE
767    );    );
768    
769    appdata->menu_item_map_no_icons = menu_append_new_item(    appdata->menu_item_wms_clear = menu_append_new_item(
770      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_no_icons), _("No _icons"),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_wms_clear), _("_Clear"),
771      NULL, "<OSM2Go-Main>/Map/NoIcons",      GTK_STOCK_CLEAR, "<OSM2Go-Main>/WMS/Clear",
772      0, 0, TRUE, appdata->settings->no_icons      0, 0, TRUE, FALSE, FALSE
773    );    );
774      gtk_widget_set_sensitive(appdata->menu_item_wms_clear, FALSE);
775    
776    appdata->menu_item_map_no_antialias = menu_append_new_item(    appdata->menu_item_wms_adjust = menu_append_new_item(
777      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_no_antialias),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_wms_adjust), _("_Adjust"),
778      _("No _antialias"),      NULL, "<OSM2Go-Main>/WMS/Adjust",
779      NULL, "<OSM2Go-Main>/Map/NoAntialias",      0, 0, TRUE, FALSE, FALSE
     0, 0, TRUE, appdata->settings->no_antialias  
780    );    );
781      gtk_widget_set_sensitive(appdata->menu_item_wms_adjust, FALSE);
782    
783    /* -------------------- track submenu -------------------- */    /* -------------------- track submenu -------------------- */
784    
785    appdata->track.menu_track = item = gtk_menu_item_new_with_mnemonic(_("_Track"));    appdata->track.submenu_track = item =
786        gtk_menu_item_new_with_mnemonic(_("_Track"));
787    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
788    submenu = gtk_menu_new();    submenu = gtk_menu_new();
789    gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);    gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
790    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
791    
792    appdata->track.menu_item_import = menu_append_new_item(    appdata->track.menu_item_track_import = menu_append_new_item(
793      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_import), _("_Import..."),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_import), _("_Import"),
794      NULL, "<OSM2Go-Main>/Track/Import",      NULL, "<OSM2Go-Main>/Track/Import",
795      0, 0, FALSE, FALSE      0, 0, TRUE, FALSE, FALSE
796    );    );
797    
798    appdata->track.menu_item_export = menu_append_new_item(    appdata->track.menu_item_track_export = menu_append_new_item(
799      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_export), _("_Export..."),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_export), _("_Export"),
800      NULL, "<OSM2Go-Main>/Track/Export",      NULL, "<OSM2Go-Main>/Track/Export",
801      0, 0, FALSE, FALSE      0, 0, FALSE, FALSE, FALSE
802    );    );
803    
804    appdata->track.menu_item_clear = menu_append_new_item(    appdata->track.menu_item_track_clear = menu_append_new_item(
805      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_clear), _("_Clear"),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_clear), _("_Clear"),
806      GTK_STOCK_CLEAR, "<OSM2Go-Main>/Track/Clear",      GTK_STOCK_CLEAR, "<OSM2Go-Main>/Track/Clear",
807      0, 0, FALSE, FALSE      0, 0, FALSE, FALSE, FALSE
808    );    );
809    
810    
811    appdata->track.menu_item_gps = menu_append_new_item(    appdata->track.menu_item_track_enable_gps = menu_append_new_item(
812      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_gps), _("_GPS"),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_enable_gps),_("_GPS enable"),
813      NULL, "<OSM2Go-Main>/Track/GPS",      NULL, "<OSM2Go-Main>/Track/GPS",
814      GDK_g, GDK_CONTROL_MASK|GDK_SHIFT_MASK, TRUE, FALSE      GDK_g, GDK_CONTROL_MASK|GDK_SHIFT_MASK, TRUE, TRUE,
815        appdata->settings->enable_gps
816      );
817    
818      appdata->track.menu_item_track_follow_gps = menu_append_new_item(
819        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_follow_gps), _("GPS follow"),
820        NULL, "<OSM2Go-Main>/Track/Follow",
821        0, 0, appdata->settings->enable_gps, TRUE,
822        appdata->settings->follow_gps
823    );    );
824    
825    /* ------------------------------------------------------- */    /* ------------------------------------------------------- */
# Line 697  void menu_create(appdata_t *appdata) { Line 828  void menu_create(appdata_t *appdata) {
828                          gtk_separator_menu_item_new());                          gtk_separator_menu_item_new());
829    
830    menu_append_new_item(    menu_append_new_item(
831      appdata, about_quit_items_menu, GTK_SIGNAL_FUNC(cb_menu_about), _("_About..."),      appdata, about_quit_items_menu, GTK_SIGNAL_FUNC(cb_menu_about), _("_About"),
832      GTK_STOCK_ABOUT, "<OSM2Go-Main>/About",      GTK_STOCK_ABOUT, "<OSM2Go-Main>/About",
833      0, 0, FALSE, FALSE      0, 0, TRUE, FALSE, FALSE
834    );    );
835    
836    #ifndef USE_HILDON
837    menu_append_new_item(    menu_append_new_item(
838      appdata, about_quit_items_menu, GTK_SIGNAL_FUNC(cb_menu_quit), _("_Quit"),      appdata, about_quit_items_menu, GTK_SIGNAL_FUNC(cb_menu_quit), _("_Quit"),
839      GTK_STOCK_QUIT, "<OSM2Go-Main>/Quit",      GTK_STOCK_QUIT, "<OSM2Go-Main>/Quit",
840      0, 0, FALSE, FALSE      0, 0, TRUE, FALSE, FALSE
841    );    );
842    #endif
843    
844    gtk_window_add_accel_group(GTK_WINDOW(appdata->window), accel_grp);    gtk_window_add_accel_group(GTK_WINDOW(appdata->window), accel_grp);
845    
# Line 732  void menu_create(appdata_t *appdata) { Line 865  void menu_create(appdata_t *appdata) {
865    
866  #endif //USE_HILDON  #endif //USE_HILDON
867  }  }
868    #else // !defined(USE_HILDON) || (MAEMO_VERSION_MAJOR < 5)
869    
870    void submenu_entry(appdata_t *appdata, HildonAppMenu *menu,
871                       const char *label, const char *value,
872                       GtkSignalFunc activate_cb) {
873    
874    }
875    
876    typedef struct {
877      const char *label, *value;
878      gboolean enabled;
879      gboolean (*toggle)(appdata_t *appdata);
880      gulong offset;
881      GtkSignalFunc activate_cb;
882    } menu_entry_t;
883    
884    static gboolean no_icon_get_toggle(appdata_t *appdata) {
885      if(!appdata)           return FALSE;
886      if(!appdata->settings) return FALSE;
887      return appdata->settings->no_icons;
888    }
889    
890    static gboolean enable_gps_get_toggle(appdata_t *appdata) {
891      if(!appdata)           return FALSE;
892      if(!appdata->settings) return FALSE;
893      return appdata->settings->enable_gps;
894    }
895    
896    static gboolean follow_gps_get_toggle(appdata_t *appdata) {
897      if(!appdata)           return FALSE;
898      if(!appdata->settings) return FALSE;
899      return appdata->settings->follow_gps;
900    }
901    
902    /* create a HildonAppMenu */
903    static GtkWidget *app_menu_create(appdata_t *appdata,
904                                      const menu_entry_t *menu_entries) {
905      HildonAppMenu *menu = HILDON_APP_MENU(hildon_app_menu_new());
906    
907      while(menu_entries->label) {
908        GtkWidget *button = NULL;
909    
910        if(!menu_entries->toggle) {
911          button = hildon_button_new_with_text(
912                HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH,
913                HILDON_BUTTON_ARRANGEMENT_VERTICAL,
914                _(menu_entries->label), _(menu_entries->value));
915          g_signal_connect_after(button, "clicked",
916                                 menu_entries->activate_cb, appdata);
917        } else {
918          button = hildon_check_button_new(HILDON_SIZE_AUTO);
919          gtk_button_set_label(GTK_BUTTON(button), _(menu_entries->label));
920          printf("requesting check for %s: %p\n", menu_entries->label,
921                 menu_entries->toggle);
922          hildon_check_button_set_active(HILDON_CHECK_BUTTON(button),
923                                         menu_entries->toggle(appdata));
924          g_signal_connect_after(button, "toggled",
925                                 menu_entries->activate_cb, appdata);
926        }
927    
928        /* offset to GtkWidget pointer was given -> store pointer */
929        if(menu_entries->offset)
930          *(GtkWidget**)(((void*)appdata)+menu_entries->offset) = button;
931    
932        gtk_widget_set_sensitive(button, menu_entries->enabled);
933    
934        hildon_app_menu_append(menu, GTK_BUTTON(button));
935        menu_entries++;
936      }
937    
938      gtk_widget_show_all(GTK_WIDGET(menu));
939      return GTK_WIDGET(menu);
940    }
941    
942    /* the view submenu */
943    void on_submenu_view_clicked(GtkButton *button, appdata_t *appdata) {
944      hildon_app_menu_popup(HILDON_APP_MENU(appdata->app_menu_view),
945                            GTK_WINDOW(appdata->window));
946    }
947    
948    void on_submenu_map_clicked(GtkButton *button, appdata_t *appdata) {
949      hildon_app_menu_popup(HILDON_APP_MENU(appdata->app_menu_map),
950                            GTK_WINDOW(appdata->window));
951    }
952    
953    void on_submenu_wms_clicked(GtkButton *button, appdata_t *appdata) {
954      hildon_app_menu_popup(HILDON_APP_MENU(appdata->app_menu_wms),
955                            GTK_WINDOW(appdata->window));
956    }
957    
958    void on_submenu_track_clicked(GtkButton *button, appdata_t *appdata) {
959      hildon_app_menu_popup(HILDON_APP_MENU(appdata->app_menu_track),
960                            GTK_WINDOW(appdata->window));
961    }
962    
963    #define APP_OFFSET(a)  offsetof(appdata_t, a)
964    #define SIMPLE_ENTRY(a,b)     { a, NULL, TRUE,   NULL, 0, G_CALLBACK(b) }
965    #define ENABLED_ENTRY(a,b,c)  { a, NULL, TRUE,  NULL, APP_OFFSET(c), G_CALLBACK(b) }
966    #define DISABLED_ENTRY(a,b,c) { a, NULL, FALSE,  NULL, APP_OFFSET(c), G_CALLBACK(b) }
967    #define TOGGLE_ENTRY(a,b,c)   { a, NULL, TRUE, c, 0, G_CALLBACK(b) }
968    #define DISABLED_TOGGLE_ENTRY(a,b,c,d)  \
969                                  { a, NULL, FALSE, c, APP_OFFSET(d), G_CALLBACK(b) }
970    #define ENABLED_TOGGLE_ENTRY(a,b,c,d) \
971                                  { a, NULL, TRUE, c, APP_OFFSET(d), G_CALLBACK(b) }
972    #define LAST_ENTRY            { NULL, NULL, FALSE, NULL, 0, NULL }
973    
974    /* -- the view submenu -- */
975    static const menu_entry_t submenu_view[] = {
976      SIMPLE_ENTRY("Zoom in",         cb_menu_zoomin),
977      SIMPLE_ENTRY("Zoom out",        cb_menu_zoomout),
978      /* --- */
979      SIMPLE_ENTRY("Style",           cb_menu_style),
980      /* --- */
981      SIMPLE_ENTRY("Normal details",  cb_menu_view_detail_normal),
982      SIMPLE_ENTRY("More details",    cb_menu_view_detail_inc),
983      SIMPLE_ENTRY("Less details",    cb_menu_view_detail_dec),
984      /* --- */
985      DISABLED_ENTRY("Hide selected", cb_menu_map_hide_sel, menu_item_map_hide_sel),
986      DISABLED_ENTRY("Show all",      cb_menu_map_show_all, menu_item_map_show_all),
987      /* --- */
988      TOGGLE_ENTRY("No icons",        cb_menu_map_no_icons, no_icon_get_toggle),
989    
990      LAST_ENTRY
991    };
992    
993    /* -- the map submenu -- */
994    static const menu_entry_t submenu_map[] = {
995      ENABLED_ENTRY("Upload",                cb_menu_upload, menu_item_map_upload),
996      SIMPLE_ENTRY("Download",               cb_menu_download),
997      ENABLED_ENTRY("Save local changes",    cb_menu_save_changes,
998                                               menu_item_map_save_changes),
999      ENABLED_ENTRY("Discard local changes", cb_menu_undo_changes,
1000                                               menu_item_map_undo_changes),
1001      ENABLED_ENTRY("Relations",             cb_menu_osm_relations,
1002                                               menu_item_map_relations),
1003    
1004      LAST_ENTRY
1005    };
1006    
1007    /* -- the wms submenu -- */
1008    static const menu_entry_t submenu_wms[] = {
1009      SIMPLE_ENTRY("Import",   cb_menu_wms_import),
1010      DISABLED_ENTRY("Clear",  cb_menu_wms_clear, menu_item_wms_clear),
1011      DISABLED_ENTRY("Adjust", cb_menu_wms_adjust, menu_item_wms_adjust),
1012    
1013      LAST_ENTRY
1014    };
1015    
1016    /* -- the track submenu -- */
1017    static const menu_entry_t submenu_track[] = {
1018      ENABLED_ENTRY("Import",  cb_menu_track_import, track.menu_item_track_import),
1019      DISABLED_ENTRY("Export", cb_menu_track_export, track.menu_item_track_export),
1020      DISABLED_ENTRY("Clear",  cb_menu_track_clear, track.menu_item_track_clear),
1021      ENABLED_TOGGLE_ENTRY("GPS enable", cb_menu_track_enable_gps,
1022                    enable_gps_get_toggle, track.menu_item_track_enable_gps),
1023      DISABLED_TOGGLE_ENTRY("GPS follow", cb_menu_track_follow_gps,
1024                    follow_gps_get_toggle, track.menu_item_track_follow_gps),
1025    
1026      LAST_ENTRY
1027    };
1028    
1029    
1030    /* -- the applications main menu -- */
1031    static const menu_entry_t main_menu[] = {
1032      SIMPLE_ENTRY("About",   cb_menu_about),
1033      SIMPLE_ENTRY("Project", cb_menu_project_open),
1034      ENABLED_ENTRY("View",   on_submenu_view_clicked,  submenu_view),
1035      ENABLED_ENTRY("Map",    on_submenu_map_clicked,   submenu_map),
1036      ENABLED_ENTRY("WMS",    on_submenu_wms_clicked,   submenu_wms),
1037      ENABLED_ENTRY("Track",  on_submenu_track_clicked, track.submenu_track),
1038    
1039      LAST_ENTRY
1040    };
1041    
1042    void menu_create(appdata_t *appdata) {
1043      HildonAppMenu *menu = HILDON_APP_MENU(hildon_app_menu_new());
1044    
1045      /* build menu/submenus */
1046      menu = HILDON_APP_MENU(app_menu_create(appdata, main_menu));
1047      appdata->app_menu_wms   = app_menu_create(appdata, submenu_wms);
1048      appdata->app_menu_map   = app_menu_create(appdata, submenu_map);
1049      appdata->app_menu_view  = app_menu_create(appdata, submenu_view);
1050      appdata->app_menu_track = app_menu_create(appdata, submenu_track);
1051    
1052      /* enable/disable some entries according to settings */
1053      if(appdata && appdata->settings)
1054        gtk_widget_set_sensitive(appdata->track.menu_item_track_follow_gps,
1055                                 appdata->settings->enable_gps);
1056    
1057      hildon_window_set_app_menu(HILDON_WINDOW(appdata->window), menu);
1058    }
1059    #endif
1060    
1061  /********************* end of menu **********************/  /********************* end of menu **********************/
1062    
# Line 803  void cleanup(appdata_t *appdata) { Line 1128  void cleanup(appdata_t *appdata) {
1128    
1129    project_free(appdata->project);    project_free(appdata->project);
1130    
1131    undo_free(appdata->undo_state);    if(appdata->menu_item_map_undo)
1132        undo_free(appdata->undo.state);
1133    
1134    puts("everything is gone");    puts("everything is gone");
1135  }  }
# Line 820  gboolean on_window_key_press(GtkWidget * Line 1146  gboolean on_window_key_press(GtkWidget *
1146    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
1147    int handled = FALSE;    int handled = FALSE;
1148    
1149      //  printf("key event with keyval %x\n", event->keyval);
1150    
1151    // the map handles some keys on its own ...    // the map handles some keys on its own ...
1152    switch(event->keyval) {    switch(event->keyval) {
1153    
1154    #if !defined(USE_HILDON) || (MAEMO_VERSION_MAJOR < 5)
1155  #ifdef USE_HILDON  #ifdef USE_HILDON
1156      /* this is in fact a mapping to GDK_F6 */      /* this is in fact a mapping to GDK_F6 */
1157    case HILDON_HARDKEY_FULLSCREEN:    case HILDON_HARDKEY_FULLSCREEN:
# Line 842  gboolean on_window_key_press(GtkWidget * Line 1171  gboolean on_window_key_press(GtkWidget *
1171    
1172      handled = TRUE;      handled = TRUE;
1173      break;      break;
1174    #endif
1175    }    }
1176    
1177    /* forward unprocessed key presses to map */    /* forward unprocessed key presses to map */
# Line 869  int main(int argc, char *argv[]) { Line 1199  int main(int argc, char *argv[]) {
1199    
1200    g_thread_init(NULL);    g_thread_init(NULL);
1201    
   gps_init(&appdata);  
   
1202    gtk_init (&argc, &argv);    gtk_init (&argc, &argv);
1203    
1204      gps_init(&appdata);
1205    
1206  #ifdef USE_HILDON  #ifdef USE_HILDON
1207    printf("Installing osso context for \"org.harbaum." PACKAGE "\"\n");    printf("Installing osso context for \"org.harbaum." PACKAGE "\"\n");
1208    appdata.osso_context = osso_initialize("org.harbaum."PACKAGE,    appdata.osso_context = osso_initialize("org.harbaum."PACKAGE,
# Line 891  int main(int argc, char *argv[]) { Line 1221  int main(int argc, char *argv[]) {
1221    /* Create HildonWindow and set it to HildonProgram */    /* Create HildonWindow and set it to HildonProgram */
1222    appdata.window = HILDON_WINDOW(hildon_window_new());    appdata.window = HILDON_WINDOW(hildon_window_new());
1223    hildon_program_add_window(appdata.program, appdata.window);    hildon_program_add_window(appdata.program, appdata.window);
1224    
1225    #if MAEMO_VERSION_MAJOR == 5
1226      unsigned long val;
1227      XChangeProperty(GDK_DISPLAY(),
1228                      GDK_WINDOW_XID(GTK_WIDGET(appdata.window)->window),
1229                      XInternAtom(GDK_DISPLAY(),
1230                                  "_HILDON_ZOOM_KEY_ATOM",
1231                                  False), XA_INTEGER, 32,
1232                      PropModeReplace, (unsigned char *) &val, 1);
1233    #endif
1234    
1235  #else  #else
1236    /* Create a Window. */    /* Create a Window. */
1237    appdata.window = gtk_window_new(GTK_WINDOW_TOPLEVEL);    appdata.window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
# Line 933  int main(int argc, char *argv[]) { Line 1274  int main(int argc, char *argv[]) {
1274      return -1;      return -1;
1275    }    }
1276    
1277    #if 0  // another test overlay
1278      {
1279        GtkWidget *fixed = gtk_fixed_new();
1280    
1281        gtk_fixed_put(GTK_FIXED(fixed), gtk_label_new("Nase"), 0,0);
1282        gtk_fixed_put(GTK_FIXED(fixed), map, 0,0);
1283    
1284        gtk_box_pack_start(GTK_BOX(vbox), fixed, TRUE, TRUE, 0);
1285      }
1286    #else
1287    gtk_box_pack_start(GTK_BOX(vbox), map, TRUE, TRUE, 0);    gtk_box_pack_start(GTK_BOX(vbox), map, TRUE, TRUE, 0);
1288    #endif
1289    
1290    #ifdef ZOOM_BUTTONS
1291      GtkWidget *zhbox = gtk_hbox_new(FALSE, 0);
1292    
1293      gtk_box_pack_start_defaults(GTK_BOX(zhbox), statusbar_new(&appdata));
1294    
1295      /* ---- add zoom in button right of statusbar ---- */
1296      appdata.btn_zoom_in = gtk_button_new();
1297      gtk_button_set_image(GTK_BUTTON(appdata.btn_zoom_in),
1298                           gtk_image_new_from_stock(GTK_STOCK_ZOOM_IN, GTK_ICON_SIZE_MENU));
1299      g_signal_connect(appdata.btn_zoom_in, "clicked", G_CALLBACK(cb_menu_zoomin), &appdata);
1300      gtk_box_pack_start(GTK_BOX(zhbox), appdata.btn_zoom_in, FALSE, FALSE, 0);
1301    
1302      /* ---- add zoom out button right of statusbar ---- */
1303      appdata.btn_zoom_out = gtk_button_new();
1304      gtk_button_set_image(GTK_BUTTON(appdata.btn_zoom_out),
1305                           gtk_image_new_from_stock(GTK_STOCK_ZOOM_OUT, GTK_ICON_SIZE_MENU));
1306      g_signal_connect(appdata.btn_zoom_out, "clicked", G_CALLBACK(cb_menu_zoomout), &appdata);
1307      gtk_box_pack_start(GTK_BOX(zhbox), appdata.btn_zoom_out, FALSE, FALSE, 0);
1308    
1309    
1310      gtk_box_pack_start(GTK_BOX(vbox), zhbox, FALSE, FALSE, 0);
1311    #else
1312    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);
1313    #endif
1314    
1315  #ifndef PORTRAIT  #ifndef PORTRAIT
1316    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);
1317  #endif  #endif
   gtk_box_pack_start(GTK_BOX(hbox), gtk_vseparator_new(), FALSE, FALSE, 0);  
1318    gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);    gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
1319    
1320    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 952  int main(int argc, char *argv[]) { Line 1327  int main(int argc, char *argv[]) {
1327    
1328    /* let gtk do its thing before loading the data, */    /* let gtk do its thing before loading the data, */
1329    /* so the user sees something */    /* so the user sees something */
1330    while(gtk_events_pending()) {    while(gtk_events_pending())
     putchar('.');  
1331      gtk_main_iteration();      gtk_main_iteration();
   }  
1332    
1333    /* load project if one is specified in the settings */    /* load project if one is specified in the settings */
1334    if(appdata.settings->project)    if(appdata.settings->project)
# Line 963  int main(int argc, char *argv[]) { Line 1336  int main(int argc, char *argv[]) {
1336    
1337    main_ui_enable(&appdata);    main_ui_enable(&appdata);
1338    
1339    /* ------------ jump into main loop ---------------- */    /* start GPS if enabled by config */
1340      if(appdata.settings && appdata.settings->enable_gps)
1341        track_enable_gps(&appdata, TRUE);
1342    
1343      /* again let the ui do its thing */
1344      while(gtk_events_pending())
1345        gtk_main_iteration();
1346    
1347    #if 0  // test overlay
1348      {
1349        GtkWidget *overlay = gtk_window_new(GTK_WINDOW_POPUP);
1350        gtk_window_set_default_size(GTK_WINDOW(overlay), 40, 20);
1351        gtk_window_set_transient_for(GTK_WINDOW(overlay), GTK_WINDOW(appdata.window));
1352        gtk_window_set_keep_above(GTK_WINDOW(overlay), TRUE);
1353        gtk_window_set_destroy_with_parent(GTK_WINDOW(overlay), TRUE);
1354        gtk_window_set_position(GTK_WINDOW(overlay), GTK_WIN_POS_CENTER_ON_PARENT);
1355        gtk_window_set_decorated(GTK_WINDOW(overlay), TRUE);
1356    
1357        /* add some zoom buttons for testing */
1358        GtkWidget *hbox = gtk_hbox_new(TRUE, 0);
1359        gtk_box_pack_start_defaults(GTK_BOX(hbox), gtk_button_new_with_label("+"));
1360        gtk_box_pack_start_defaults(GTK_BOX(hbox), gtk_button_new_with_label("-"));
1361        gtk_container_add(GTK_CONTAINER(overlay), hbox);
1362    
1363        gtk_widget_show_all(overlay);
1364      }
1365    #endif
1366    
1367      /* start to interact with the user now that the gui is running */
1368      if(appdata.settings->first_run_demo) {
1369        messagef(GTK_WIDGET(appdata.window), _("Welcome to OSM2Go"),
1370                 _("This is the first time you run OSM2Go. "
1371                   "A demo project has been loaded to get you "
1372                   "started. You can play around with this demo as much "
1373                   "as you like. However, you cannot upload or download "
1374                   "the demo project.\n\n"
1375                   "In order to start working on real data you'll have "
1376                   "to setup a new project and enter your OSM user name "
1377                   "and password. You'll then be able to download the "
1378                   "latest data from OSM and upload your changes into "
1379                   "the OSM main database."
1380                   ));
1381      }
1382    
1383      /* ------------ jump into main loop ---------------- */
1384    gtk_main();    gtk_main();
1385    
1386    puts("gtk_main() left");    puts("gtk_main() left");
1387    
1388    track_save(appdata.project, appdata.track.track);    track_save(appdata.project, appdata.track.track);
1389      track_clear(&appdata, appdata.track.track);
1390      appdata.track.track = NULL;
1391    
1392    /* save a diff if there are dirty entries */    /* save a diff if there are dirty entries */
1393    diff_save(appdata.project, appdata.osm);    diff_save(appdata.project, appdata.osm);
Legend:
Removed from v.55  
changed lines
  Added in v.200