Diff of /trunk/src/main.c

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

revision 79 by achadwick, Sun Feb 15 22:15:06 2009 UTC revision 227 by harbaum, Tue Jul 14 19:07:25 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    
37  /* disable/enable main screen control dependant on presence of open project */  /* disable/enable main screen control dependant on presence of open project */
38  static void main_ui_enable(appdata_t *appdata) {  void main_ui_enable(appdata_t *appdata) {
39    gboolean project_valid = (appdata->project != NULL);    gboolean project_valid = (appdata->project != NULL);
40    gboolean osm_valid = (appdata->osm != NULL);    gboolean osm_valid = (appdata->osm != NULL);
41    
# 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    #ifdef USE_HILDON
55      if(project_valid)
56        str = g_markup_printf_escaped("OSM2Go - <b>%s</b>",
57                                      appdata->project->name);
58      else
59        str = g_markup_printf_escaped("OSM2Go");
60    
61      hildon_window_set_markup(HILDON_WINDOW(appdata->window), str);
62    #else
63    if(project_valid)    if(project_valid)
64      str = g_strdup_printf("OSM2Go - %s", appdata->project->name);      str = g_strdup_printf("OSM2Go - <b>%s</b>", appdata->project->name);
65    else    else
66      str = g_strdup_printf("OSM2Go");      str = g_strdup_printf("OSM2Go");
67    
68    gtk_window_set_title(GTK_WINDOW(appdata->window), str);    gtk_window_set_title(GTK_WINDOW(appdata->window), str);
69    #endif
70    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), "");  
71  #endif  #endif
72    
73    if(appdata->iconbar && appdata->iconbar->toolbar)    if(appdata->iconbar && appdata->iconbar->toolbar)
74      gtk_widget_set_sensitive(appdata->iconbar->toolbar, osm_valid);      gtk_widget_set_sensitive(appdata->iconbar->toolbar, osm_valid);
   
75    /* disable all menu entries related to map */    /* disable all menu entries related to map */
76    gtk_widget_set_sensitive(appdata->menu_osm, project_valid);    gtk_widget_set_sensitive(appdata->submenu_map, project_valid);
77    gtk_widget_set_sensitive(appdata->menu_item_osm_upload, osm_valid);    gtk_widget_set_sensitive(appdata->menu_item_map_upload, osm_valid);
78    if(appdata->menu_item_osm_undo)    if(appdata->menu_item_map_undo)
79      gtk_widget_set_sensitive(appdata->menu_item_osm_undo, osm_valid);      gtk_widget_set_sensitive(appdata->menu_item_map_undo, osm_valid);
80    gtk_widget_set_sensitive(appdata->menu_item_osm_save_changes, osm_valid);    gtk_widget_set_sensitive(appdata->menu_item_map_save_changes, osm_valid);
81    gtk_widget_set_sensitive(appdata->menu_item_osm_undo_changes, osm_valid);    gtk_widget_set_sensitive(appdata->menu_item_map_undo_changes, osm_valid);
82    gtk_widget_set_sensitive(appdata->track.menu_track, osm_valid);    gtk_widget_set_sensitive(appdata->menu_item_map_relations, osm_valid);
83    gtk_widget_set_sensitive(appdata->menu_view, osm_valid);    gtk_widget_set_sensitive(appdata->track.submenu_track, osm_valid);
84    gtk_widget_set_sensitive(appdata->menu_wms, osm_valid);    gtk_widget_set_sensitive(appdata->submenu_view, osm_valid);
85    gtk_widget_set_sensitive(appdata->menu_map, osm_valid);    gtk_widget_set_sensitive(appdata->submenu_wms, osm_valid);
86    gtk_widget_set_sensitive(appdata->menu_item_project_close, project_valid);  
87    #ifdef ZOOM_BUTTONS
88      gtk_widget_set_sensitive(appdata->btn_zoom_in, osm_valid);
89      gtk_widget_set_sensitive(appdata->btn_zoom_out, osm_valid);
90    #endif
91    
92    if(!project_valid)    if(!project_valid)
93      statusbar_set(appdata, _("Please load or create a project"), FALSE);      statusbar_set(appdata, _("Please load or create a project"), FALSE);
# Line 73  static void main_ui_enable(appdata_t *ap Line 96  static void main_ui_enable(appdata_t *ap
96  /******************** begin of menu *********************/  /******************** begin of menu *********************/
97    
98  static void  static void
99  cb_menu_project_open(GtkWidget *window, gpointer data) {  cb_menu_project_open(GtkMenuItem *item, gpointer data) {
100    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
101    project_load(appdata, NULL);    project_load(appdata, NULL);
102    main_ui_enable(appdata);    main_ui_enable(appdata);
103  }  }
104    
105  static void  static void
106  cb_menu_project_close(GtkWidget *window, gpointer data) {  cb_menu_project_wizard(GtkMenuItem *item, gpointer data) {
107    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
108    project_close(appdata);    project_wizard(appdata);
   main_ui_enable(appdata);  
109  }  }
110    
111  static void  static void
112  cb_menu_about(GtkWidget *window, gpointer data) {  cb_menu_about(GtkMenuItem *item, gpointer data) {
113    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"));  
114    
115    const gchar *authors[] = {    const gchar *authors[] = {
116      "Till Harbaum <till@harbaum.org>",      "Till Harbaum <till@harbaum.org>",
117      "Andrew Chadwick <andrewc-osm2go@piffle.org>",      "Andrew Chadwick <andrewc-osm2go@piffle.org>",
118        "Marcus Bauer <marcus.bauer@gmail.com>",
119        "John Stowers <john.stowers@gmail.com>",
120      NULL };      NULL };
121    
122    gtk_about_dialog_set_authors(about, authors);    const gchar *artists[] = {
123        "Andrew Zhilin <drew.zhilin@gmail.com>",
124    gtk_about_dialog_set_website(about,      NULL };
        _("http://www.harbaum.org/till/maemo"));  
   
   gtk_about_dialog_set_comments(about,  
        _("Mobile OSM Editor"));  
125    
126    gtk_widget_show_all(GTK_WIDGET(about));    gtk_show_about_dialog(GTK_WINDOW(appdata->window),
127    gtk_dialog_run(GTK_DIALOG(about));                          "name", "OSM2Go",
128    gtk_widget_destroy(GTK_WIDGET(about));                          "version", VERSION,
129                            "copyright", _("Copyright 2008-2009"),
130                            "authors", authors,
131                            "artists", artists,
132                            "website", _("http://www.harbaum.org/till/maemo"),
133                            "comments", _("Mobile OSM Editor"),
134                            NULL);
135  }  }
136    
137  void on_window_destroy (GtkWidget *widget, gpointer data);  void on_window_destroy (GtkWidget *widget, gpointer data);
138    
139    #ifndef USE_HILDON
140  static void  static void
141  cb_menu_quit(GtkWidget *window, gpointer data) {  cb_menu_quit(GtkMenuItem *item, gpointer data) {
142    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
143    gtk_widget_destroy(GTK_WIDGET(appdata->window));    gtk_widget_destroy(GTK_WIDGET(appdata->window));
144  }  }
145    #endif
146    
147  static void  static void
148  cb_menu_upload(GtkWidget *window, gpointer data) {  cb_menu_upload(GtkMenuItem *item, gpointer data) {
149    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
150    if(!appdata->osm || !appdata->project) return;    if(!appdata->osm || !appdata->project) return;
151    
152      if(project_check_demo(GTK_WIDGET(appdata->window), appdata->project))
153        return;
154    
155    osm_upload(appdata, appdata->osm, appdata->project);    osm_upload(appdata, appdata->osm, appdata->project);
156  }  }
157    
158  static void  static void
159  cb_menu_download(GtkWidget *window, gpointer data) {  cb_menu_download(GtkMenuItem *item, gpointer data) {
160    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
161    if(!appdata->project) return;    if(!appdata->project) return;
162    
163      if(project_check_demo(GTK_WIDGET(appdata->window), appdata->project))
164        return;
165    
166    /* if we have valid osm data loaded: save state first */    /* if we have valid osm data loaded: save state first */
167    if(appdata->osm) {    if(appdata->osm) {
168      /* 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 144  cb_menu_download(GtkWidget *window, gpoi Line 174  cb_menu_download(GtkWidget *window, gpoi
174    }    }
175    
176    // download    // download
177    if(osm_download(GTK_WIDGET(appdata->window), appdata->project)) {    if(osm_download(GTK_WIDGET(appdata->window), appdata->settings,
178      banner_busy_start(appdata, 1, "Redrawing...");                    appdata->project)) {
179      appdata->osm = osm_parse(appdata->project->osm);      banner_busy_start(appdata, 1, "Redrawing");
180        appdata->osm = osm_parse(appdata->project->path, appdata->project->osm);
181      diff_restore(appdata, appdata->project, appdata->osm);      diff_restore(appdata, appdata->project, appdata->osm);
182      map_paint(appdata);      map_paint(appdata);
183      banner_busy_stop(appdata); //"Redrawing..."      banner_busy_stop(appdata); //"Redrawing"
184    }    }
185    
186    main_ui_enable(appdata);    main_ui_enable(appdata);
187  }  }
188    
189  static void  static void
190  cb_menu_wms_import(GtkWidget *window, gpointer data) {  cb_menu_wms_import(GtkMenuItem *item, gpointer data) {
191    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
192    wms_import(appdata);    wms_import(appdata);
193  }  }
194    
195  static void  static void
196  cb_menu_wms_clear(GtkWidget *window, gpointer data) {  cb_menu_wms_clear(GtkMenuItem *item, gpointer data) {
197    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
198    wms_remove(appdata);    wms_remove(appdata);
199  }  }
200    
201  static void  static void
202  cb_menu_wms_adjust(GtkWidget *window, gpointer data) {  cb_menu_wms_adjust(GtkMenuItem *item, gpointer data) {
203    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
204    map_action_set(appdata, MAP_ACTION_BG_ADJUST);    map_action_set(appdata, MAP_ACTION_BG_ADJUST);
205  }  }
# Line 176  cb_menu_wms_adjust(GtkWidget *window, gp Line 207  cb_menu_wms_adjust(GtkWidget *window, gp
207  /* ----------- hide objects for performance reasons ----------- */  /* ----------- hide objects for performance reasons ----------- */
208    
209  static void  static void
210  cb_menu_map_hide_sel(GtkWidget *window, gpointer data) {  cb_menu_map_hide_sel(GtkMenuItem *item, gpointer data) {
211    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
212    map_hide_selected(appdata);    map_hide_selected(appdata);
213  }  }
214    
215  static void  static void
216  cb_menu_map_show_all(GtkWidget *window, gpointer data) {  cb_menu_map_show_all(GtkMenuItem *item, gpointer data) {
217    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
218    map_show_all(appdata);    map_show_all(appdata);
219  }  }
220    
221  /* ---------------------------------------------------------- */  /* ---------------------------------------------------------- */
222    
223  #if 1  // mainly for testing  #if defined(USE_HILDON) && (MAEMO_VERSION_MAJOR == 5)
224  static void  #define MENU_CHECK_ITEM HildonCheckButton
225  cb_menu_redraw(GtkWidget *window, gpointer data) {  #define MENU_CHECK_ITEM_ACTIVE(a) hildon_check_button_get_active(a)
226    appdata_t *appdata = (appdata_t*)data;  #else
227    #define MENU_CHECK_ITEM GtkCheckMenuItem
228    /* redraw the entire map by destroying all map items and redrawing them */  #define MENU_CHECK_ITEM_ACTIVE(a) gtk_check_menu_item_get_active(a)
   banner_busy_start(appdata, 1, "Redrawing...");  
   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);  
   
   appdata->osm = osm_parse(appdata->project->osm);  
   diff_restore(appdata, appdata->project, appdata->osm);  
   map_paint(appdata);  
   
   appdata->track.track = track_restore(appdata, appdata->project);  
   if(appdata->track.track)  
     map_track_draw(appdata->map, appdata->track.track);  
   
   wms_load(appdata);  
   banner_busy_stop(appdata); //"Redrawing..."  
 }  
229  #endif  #endif
230    
231  static void  static void
232  cb_menu_style(GtkWidget *widget, gpointer data) {  cb_menu_map_no_icons(MENU_CHECK_ITEM *item, appdata_t *appdata) {
   appdata_t *appdata = (appdata_t*)data;  
233    
234    style_select(GTK_WIDGET(appdata->window), appdata);    banner_busy_start(appdata, 1, "Redrawing");
235  }    map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);
236    
237  static void    appdata->settings->no_icons = MENU_CHECK_ITEM_ACTIVE(item);
 cb_menu_map_no_icons(GtkWidget *widget, gpointer data) {  
   appdata_t *appdata = (appdata_t*)data;  
238    
   banner_busy_start(appdata, 1, "Redrawing...");  
   map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);  
   appdata->settings->no_icons =  
     gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget));  
239    map_paint(appdata);    map_paint(appdata);
240    banner_busy_stop(appdata); //"Redrawing..."    banner_busy_stop(appdata); //"Redrawing"
241  }  }
242    
243  static void  static void
244  cb_menu_map_no_antialias(GtkWidget *widget, gpointer data) {  cb_menu_style(GtkMenuItem *item, gpointer data) {
245    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
246    
247    banner_busy_start(appdata, 1, "Redrawing...");    style_select(GTK_WIDGET(appdata->window), appdata);
   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..."  
248  }  }
249    
250  static void  static void
251  cb_menu_undo(GtkWidget *widget, gpointer data) {  cb_menu_undo(GtkMenuItem *item, gpointer data) {
252    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
253    
254    undo(appdata);    undo(appdata);
# Line 255  cb_menu_undo(GtkWidget *widget, gpointer Line 257  cb_menu_undo(GtkWidget *widget, gpointer
257  }  }
258    
259  static void  static void
260  cb_menu_save_changes(GtkWidget *widget, gpointer data) {  cb_menu_save_changes(GtkMenuItem *item, gpointer data) {
261    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
262    
263    diff_save(appdata->project, appdata->osm);    diff_save(appdata->project, appdata->osm);
# Line 263  cb_menu_save_changes(GtkWidget *widget, Line 265  cb_menu_save_changes(GtkWidget *widget,
265  }  }
266    
267  static void  static void
268  cb_menu_undo_changes(GtkWidget *widget, gpointer data) {  cb_menu_undo_changes(GtkMenuItem *item, gpointer data) {
269    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
270    
271    if(!yes_no_f(GTK_WIDGET(appdata->window), NULL, 0, 0,    if(!yes_no_f(GTK_WIDGET(appdata->window), NULL, 0, 0,
# Line 272  cb_menu_undo_changes(GtkWidget *widget, Line 274  cb_menu_undo_changes(GtkWidget *widget,
274                   "uploaded yet? This can't be undone.")))                   "uploaded yet? This can't be undone.")))
275      return;      return;
276    
277    banner_busy_start(appdata, 1, _("Redrawing..."));    banner_busy_start(appdata, 1, _("Redrawing"));
278    map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);    map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);
279    osm_free(&appdata->icon, appdata->osm);    osm_free(&appdata->icon, appdata->osm);
280    diff_remove(appdata->project);    diff_remove(appdata->project);
281    appdata->osm = osm_parse(appdata->project->osm);    appdata->osm = osm_parse(appdata->project->path, appdata->project->osm);
282    map_paint(appdata);    map_paint(appdata);
283    banner_busy_stop(appdata);  //"Redrawing..."    banner_busy_stop(appdata);  //"Redrawing"
284    
285    banner_show_info(appdata, _("Discarded local changes"));    banner_show_info(appdata, _("Discarded local changes"));
286  }  }
287    
288  static void  static void
289  cb_menu_osm_relations(GtkWidget *widget, gpointer data) {  cb_menu_osm_relations(GtkMenuItem *item, appdata_t *appdata) {
290    relation_list((appdata_t*)data);    /* list relations of all objects */
291      relation_list(GTK_WIDGET(appdata->window), appdata, NULL);
292  }  }
293    
294    #if !defined(USE_HILDON) || (MAEMO_VERSION_MAJOR < 5)
295  static void  static void
296  cb_menu_fullscreen(GtkWidget *widget, gpointer data) {  cb_menu_fullscreen(MENU_CHECK_ITEM *item, gpointer data) {
297    appdata_t *appdata = (appdata_t *)data;    appdata_t *appdata = (appdata_t *)data;
298    
299    if(gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widget)))    if(MENU_CHECK_ITEM_ACTIVE(item))
300      gtk_window_fullscreen(GTK_WINDOW(appdata->window));      gtk_window_fullscreen(GTK_WINDOW(appdata->window));
301    else    else
302      gtk_window_unfullscreen(GTK_WINDOW(appdata->window));      gtk_window_unfullscreen(GTK_WINDOW(appdata->window));
303  }  }
304    #endif
305    
306  static void  static void
307  cb_menu_zoomin(GtkWidget *widget, appdata_t *appdata) {  cb_menu_zoomin(GtkMenuItem *item, appdata_t *appdata) {
308    if(!appdata || !appdata->map) return;    if(!appdata || !appdata->map) return;
309    
310    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 307  cb_menu_zoomin(GtkWidget *widget, appdat Line 312  cb_menu_zoomin(GtkWidget *widget, appdat
312  }  }
313    
314  static void  static void
315  cb_menu_zoomout(GtkWidget *widget, appdata_t *appdata) {  cb_menu_zoomout(GtkMenuItem *item, appdata_t *appdata) {
316    if(!appdata || !appdata->map) return;    if(!appdata || !appdata->map) return;
317    
318    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 315  cb_menu_zoomout(GtkWidget *widget, appda Line 320  cb_menu_zoomout(GtkWidget *widget, appda
320  }  }
321    
322  static void  static void
323  cb_menu_track_import(GtkWidget *window, appdata_t *appdata) {  cb_menu_view_detail_inc(GtkMenuItem *item, gpointer data) {
324      appdata_t *appdata = (appdata_t*)data;
325    
326      printf("detail level increase\n");
327      map_detail_increase(appdata->map);
328    }
329    
330    static void
331    cb_menu_view_detail_normal(GtkMenuItem *item, gpointer data) {
332      appdata_t *appdata = (appdata_t*)data;
333    
334      printf("detail level normal\n");
335      map_detail_normal(appdata->map);
336    }
337    
338    static void
339    cb_menu_view_detail_dec(GtkMenuItem *item, gpointer data) {
340      appdata_t *appdata = (appdata_t*)data;
341    
342      printf("detail level decrease\n");
343      map_detail_decrease(appdata->map);
344    }
345    
346    static void
347    cb_menu_track_import(GtkMenuItem *item, appdata_t *appdata) {
348      g_assert(appdata->settings);
349    
350    /* open a file selector */    /* open a file selector */
351    GtkWidget *dialog;    GtkWidget *dialog;
# Line 332  cb_menu_track_import(GtkWidget *window, Line 362  cb_menu_track_import(GtkWidget *window,
362                          NULL);                          NULL);
363  #endif  #endif
364    
365    /* use path if one is present */    if(appdata->settings->track_path) {
366    if(appdata->track.import_path)      if(!g_file_test(appdata->settings->track_path, G_FILE_TEST_EXISTS)) {
367      gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),        char *last_sep = strrchr(appdata->settings->track_path, '/');
368                                          appdata->track.import_path);        if(last_sep) {
369            *last_sep = 0;  // seperate path from file
370    
371            /* the user just created a new document */
372            gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
373                                        appdata->settings->track_path);
374            gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog),
375                                              last_sep+1);
376    
377            /* restore full filename */
378            *last_sep = '/';
379          }
380        } else
381          gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),
382                                        appdata->settings->track_path);
383      }
384    
385    gtk_widget_show_all (GTK_WIDGET(dialog));    gtk_widget_show_all (GTK_WIDGET(dialog));
386    if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_FM_OK) {    if (gtk_dialog_run (GTK_DIALOG(dialog)) == GTK_FM_OK) {
387      char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));      char *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
388    
389      /* load a track */      /* load a track */
390      track_do(appdata, TRACK_IMPORT, filename);      appdata->track.track = track_import(appdata, filename);
391      if(appdata->track.track) {      if(appdata->track.track) {
392          if(appdata->settings->track_path) g_free(appdata->settings->track_path);
393        /* 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 = '/';  
       }  
394      }      }
395      g_free (filename);      g_free (filename);
396    }    }
# Line 364  cb_menu_track_import(GtkWidget *window, Line 399  cb_menu_track_import(GtkWidget *window,
399  }  }
400    
401  static void  static void
402  cb_menu_track_gps(GtkWidget *window, gpointer data) {  cb_menu_track_enable_gps(MENU_CHECK_ITEM *item, appdata_t *appdata) {
403    appdata_t *appdata = (appdata_t*)data;    track_enable_gps(appdata, MENU_CHECK_ITEM_ACTIVE(item));
404    }
405    
406    if(gtk_check_menu_item_get_active(  
407      GTK_CHECK_MENU_ITEM(appdata->track.menu_item_gps))) {  static void
408      track_do(appdata, TRACK_GPS, NULL);  cb_menu_track_follow_gps(MENU_CHECK_ITEM *item, appdata_t *appdata) {
409    } else {    appdata->settings->follow_gps = MENU_CHECK_ITEM_ACTIVE(item);
     track_do(appdata, TRACK_NONE, NULL);  
   }  
410  }  }
411    
412    
413  static void  static void
414  cb_menu_track_export(GtkWidget *window, gpointer data) {  cb_menu_track_export(GtkMenuItem *item, appdata_t *appdata) {
415    appdata_t *appdata = (appdata_t*)data;    g_assert(appdata->settings);
416    messagef(GTK_WIDGET(appdata->window), _("NIY"),  
417             _("Track export is not yet supported."));    /* open a file selector */
418      GtkWidget *dialog;
419    
420    #ifdef USE_HILDON
421      dialog = hildon_file_chooser_dialog_new(GTK_WINDOW(appdata->window),
422                                              GTK_FILE_CHOOSER_ACTION_SAVE);
423    #else
424      dialog = gtk_file_chooser_dialog_new(_("Export track file"),
425                                           GTK_WINDOW(appdata->window),
426                                           GTK_FILE_CHOOSER_ACTION_SAVE,
427                                           GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
428                                           GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
429                                           NULL);
430    #endif
431    
432      printf("set filename <%s>\n", appdata->settings->track_path);
433    
434      if(appdata->settings->track_path) {
435        if(!g_file_test(appdata->settings->track_path, G_FILE_TEST_EXISTS)) {
436          char *last_sep = strrchr(appdata->settings->track_path, '/');
437          if(last_sep) {
438            *last_sep = 0;  // seperate path from file
439    
440            /* the user just created a new document */
441            gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog),
442                                                appdata->settings->track_path);
443            gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog),
444                                              last_sep+1);
445    
446            /* restore full filename */
447            *last_sep = '/';
448          }
449        } else
450          gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),
451                                        appdata->settings->track_path);
452      }
453    
454      if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_FM_OK) {
455        gchar *filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
456        if(filename) {
457          printf("export to %s\n", filename);
458    
459          if(!g_file_test(filename, G_FILE_TEST_EXISTS) ||
460             yes_no_f(dialog, appdata, MISC_AGAIN_ID_EXPORT_OVERWRITE,
461                      MISC_AGAIN_FLAG_DONT_SAVE_NO,
462                      "Overwrite existing file",
463                      "The file already exists. "
464                      "Do you really want to replace it?")) {
465            if(appdata->settings->track_path)
466              g_free(appdata->settings->track_path);
467            appdata->settings->track_path = g_strdup(filename);
468    
469            track_export(appdata, filename);
470          }
471        }
472      }
473    
474      gtk_widget_destroy (dialog);
475  }  }
476    
477    
478  static void  static void
479  cb_menu_track_clear(GtkWidget *window, gpointer data) {  cb_menu_track_clear(GtkMenuItem *item, gpointer data) {
480    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
481    track_do(appdata, TRACK_NONE, NULL);    track_clear(appdata, appdata->track.track);
482      appdata->track.track = NULL;
483  }  }
484    
485    
# Line 419  cb_menu_track_clear(GtkWidget *window, g Line 513  cb_menu_track_clear(GtkWidget *window, g
513  #endif  #endif
514    
515    
516    #if !defined(USE_HILDON) || (MAEMO_VERSION_MAJOR < 5)
517  // Half-arsed slapdash common menu item constructor. Let's use GtkBuilder  // Half-arsed slapdash common menu item constructor. Let's use GtkBuilder
518  // instead so we have some flexibility.  // instead so we have some flexibility.
519    
# Line 433  menu_append_new_item(appdata_t *appdata, Line 527  menu_append_new_item(appdata_t *appdata,
527                       const gchar *accel_path,                       const gchar *accel_path,
528                       guint accel_key,      // from gdk/gdkkeysyms.h                       guint accel_key,      // from gdk/gdkkeysyms.h
529                       GdkModifierType accel_mods, // e.g. GDK_CONTROL_MASK                       GdkModifierType accel_mods, // e.g. GDK_CONTROL_MASK
530                         gboolean enabled,
531                       gboolean is_check, gboolean check_status)                       gboolean is_check, gboolean check_status)
532  {  {
533    GtkWidget *item = NULL;    GtkWidget *item = NULL;
# Line 488  menu_append_new_item(appdata_t *appdata, Line 583  menu_append_new_item(appdata_t *appdata,
583  #endif  #endif
584    
585    gtk_menu_shell_append(GTK_MENU_SHELL(menu_shell), GTK_WIDGET(item));    gtk_menu_shell_append(GTK_MENU_SHELL(menu_shell), GTK_WIDGET(item));
586    if (is_check) {    gtk_widget_set_sensitive(GTK_WIDGET(item), enabled);
587      if (is_check)
588      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);
589    }  
590    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(activate_cb),    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(activate_cb),
591                     appdata);                     appdata);
592    return item;    return item;
593  }  }
594    
   
595  void menu_create(appdata_t *appdata) {  void menu_create(appdata_t *appdata) {
596    GtkWidget *menu, *item, *submenu;    GtkWidget *menu, *item, *submenu;
597    GtkWidget *about_quit_items_menu;    GtkWidget *about_quit_items_menu;
# Line 521  void menu_create(appdata_t *appdata) { Line 616  void menu_create(appdata_t *appdata) {
616  #endif  #endif
617    
618    menu_append_new_item(    menu_append_new_item(
619      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_project_open), _("_Open..."),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_project_open), _("_Open"),
620      GTK_STOCK_OPEN, "<OSM2Go-Main>/Project/Open",      GTK_STOCK_OPEN, "<OSM2Go-Main>/Project/Open",
621      0, 0, FALSE, FALSE      0, 0, TRUE, FALSE, FALSE
622    );    );
623    
624    appdata->menu_item_project_close = menu_append_new_item(  #ifndef USE_HILDON
625      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_project_close), _("_Close"),    menu_append_new_item(
626      GTK_STOCK_CLOSE, "<OSM2Go-Main>/Project/Close",      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_project_wizard), _("_Wizard"),
627      0, 0, FALSE, FALSE      GTK_STOCK_NEW, "<OSM2Go-Main>/Project/Wizard",
628        0, 0, TRUE, FALSE, FALSE
629    );    );
630    #endif
631    
632    /* --------------- view menu ------------------- */    /* --------------- view menu ------------------- */
633    
# Line 538  void menu_create(appdata_t *appdata) { Line 635  void menu_create(appdata_t *appdata) {
635    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());
636  #endif  #endif
637    
638    appdata->menu_view = item = gtk_menu_item_new_with_mnemonic( _("_View") );    appdata->submenu_view = item = gtk_menu_item_new_with_mnemonic( _("_View") );
639    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
640    submenu = gtk_menu_new();    submenu = gtk_menu_new();
641    gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);    gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
642    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
643    
644    #if !defined(USE_HILDON) || (MAEMO_VERSION_MAJOR < 5)
645    appdata->menu_item_view_fullscreen = menu_append_new_item(    appdata->menu_item_view_fullscreen = menu_append_new_item(
646      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_fullscreen), _("_Fullscreen"),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_fullscreen), _("_Fullscreen"),
647      GTK_STOCK_FULLSCREEN, "<OSM2Go-Main>/View/Fullscreen",      GTK_STOCK_FULLSCREEN, "<OSM2Go-Main>/View/Fullscreen",
648      0, 0, TRUE, FALSE      0, 0, TRUE, TRUE, FALSE
649    );    );
650    #endif
651    
652    menu_append_new_item(    menu_append_new_item(
653      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_zoomin), _("Zoom _in"),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_zoomin), _("Zoom _in"),
654      GTK_STOCK_ZOOM_IN, "<OSM2Go-Main>/View/ZoomIn",      GTK_STOCK_ZOOM_IN, "<OSM2Go-Main>/View/ZoomIn",
655      GDK_comma, GDK_CONTROL_MASK, FALSE, FALSE      GDK_comma, GDK_CONTROL_MASK, TRUE, FALSE, FALSE
656    );    );
657    
658    menu_append_new_item(    menu_append_new_item(
659      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_zoomout), _("Zoom _out"),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_zoomout), _("Zoom _out"),
660      GTK_STOCK_ZOOM_OUT, "<OSM2Go-Main>/View/ZoomOut",      GTK_STOCK_ZOOM_OUT, "<OSM2Go-Main>/View/ZoomOut",
661      GDK_period, GDK_CONTROL_MASK, FALSE, FALSE      GDK_period, GDK_CONTROL_MASK, TRUE, FALSE, FALSE
662    );    );
663    
664    /* -------------------- OSM submenu -------------------- */    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
665    
666    appdata->menu_osm = item = gtk_menu_item_new_with_mnemonic( _("_OSM") );    menu_append_new_item(
667        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_view_detail_inc), _("More details"),
668        NULL, "<OSM2Go-Main>/View/DetailInc",
669        GDK_period, GDK_MOD1_MASK, TRUE, FALSE, FALSE
670      );
671    
672      menu_append_new_item(
673        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_view_detail_normal), _("Normal details"),
674        NULL, "<OSM2Go-Main>/View/DetailNormal",
675        0, 0, TRUE, FALSE, FALSE
676      );
677    
678      menu_append_new_item(
679        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_view_detail_dec), _("Less details"),
680        NULL, "<OSM2Go-Main>/View/DetailDec",
681        GDK_comma, GDK_MOD1_MASK, TRUE, FALSE, FALSE
682      );
683    
684      gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
685    
686      appdata->menu_item_map_hide_sel = menu_append_new_item(
687        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_hide_sel), _("_Hide selected"),
688        GTK_STOCK_REMOVE, "<OSM2Go-Main>/View/HideSelected",
689        0, 0, TRUE, FALSE, FALSE
690      );
691      gtk_widget_set_sensitive(appdata->menu_item_map_hide_sel, FALSE);
692    
693      appdata->menu_item_map_show_all = menu_append_new_item(
694        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_show_all), _("_Show all"),
695        GTK_STOCK_ADD, "<OSM2Go-Main>/View/ShowAll",
696        0, 0, TRUE, FALSE, FALSE
697      );
698      gtk_widget_set_sensitive(appdata->menu_item_map_show_all, FALSE);
699    
700      gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
701    
702      menu_append_new_item(
703        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_style), _("St_yle"),
704        GTK_STOCK_SELECT_COLOR, "<OSM2Go-Main>/View/Style",
705        0, 0, TRUE, FALSE, FALSE
706      );
707    
708      gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
709    
710      appdata->menu_item_map_no_icons = menu_append_new_item(
711        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_no_icons), _("No _icons"),
712        NULL, "<OSM2Go-Main>/View/NoIcons",
713        0, 0, TRUE, TRUE, appdata->settings->no_icons
714      );
715    
716    
717      /* -------------------- map submenu -------------------- */
718    
719      appdata->submenu_map = item = gtk_menu_item_new_with_mnemonic( _("_Map") );
720    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
721    submenu = gtk_menu_new();    submenu = gtk_menu_new();
722    gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);    gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
723    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
724    
725    appdata->menu_item_osm_upload = menu_append_new_item(    appdata->menu_item_map_upload = menu_append_new_item(
726      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_upload), _("_Upload..."),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_upload), _("_Upload"),
727      "upload.16", "<OSM2Go-Main>/OSM/Upload",      "upload.16", "<OSM2Go-Main>/Map/Upload",
728      GDK_u, GDK_SHIFT_MASK|GDK_CONTROL_MASK, FALSE, FALSE      GDK_u, GDK_SHIFT_MASK|GDK_CONTROL_MASK, TRUE, FALSE, FALSE
729    );    );
730    
731    menu_append_new_item(    menu_append_new_item(
732      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_download), _("_Download..."),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_download), _("_Download"),
733      "download.16", "<OSM2Go-Main>/OSM/Download",      "download.16", "<OSM2Go-Main>/Map/Download",
734      GDK_d, GDK_SHIFT_MASK|GDK_CONTROL_MASK, FALSE, FALSE      GDK_d, GDK_SHIFT_MASK|GDK_CONTROL_MASK, TRUE, FALSE, FALSE
735    );    );
736    
737    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());
738    
739    if(getenv("OSM2GO_UNDO_TEST")) {    if(getenv("OSM2GO_UNDO_TEST")) {
740      appdata->menu_item_osm_undo = menu_append_new_item(      appdata->menu_item_map_undo = menu_append_new_item(
741                 appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_undo), _("_Undo"),                 appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_undo), _("_Undo"),
742                 GTK_STOCK_UNDO, "<OSM2Go-Main>/OSM/Undo",                 GTK_STOCK_UNDO, "<OSM2Go-Main>/Map/Undo",
743                 GDK_z, GDK_CONTROL_MASK, FALSE, FALSE                 GDK_z, GDK_CONTROL_MASK, TRUE, FALSE, FALSE
744                 );                 );
745    } else    } else
746      printf("set environment variable OSM2GO_UNDO_TEST to enable undo framework tests\n");      printf("set environment variable OSM2GO_UNDO_TEST to enable undo framework tests\n");
747    
748    appdata->menu_item_osm_save_changes = menu_append_new_item(    appdata->menu_item_map_save_changes = menu_append_new_item(
749      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_save_changes), _("_Save local changes"),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_save_changes), _("_Save local changes"),
750      GTK_STOCK_SAVE, "<OSM2Go-Main>/OSM/SaveChanges",      GTK_STOCK_SAVE, "<OSM2Go-Main>/Map/SaveChanges",
751      GDK_s, GDK_SHIFT_MASK|GDK_CONTROL_MASK, FALSE, FALSE      GDK_s, GDK_SHIFT_MASK|GDK_CONTROL_MASK, TRUE, FALSE, FALSE
752    );    );
753    
754    appdata->menu_item_osm_undo_changes = menu_append_new_item(    appdata->menu_item_map_undo_changes = menu_append_new_item(
755      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_undo_changes), _("Disca_rd local changes..."),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_undo_changes), _("Disca_rd local changes"),
756      GTK_STOCK_DELETE, "<OSM2Go-Main>/OSM/DiscardChanges",      GTK_STOCK_DELETE, "<OSM2Go-Main>/Map/DiscardChanges",
757      0, 0, FALSE, FALSE      0, 0, TRUE, FALSE, FALSE
758    );    );
759    
760    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());
761    appdata->menu_item_osm_relations = menu_append_new_item(    appdata->menu_item_map_relations = menu_append_new_item(
762      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_osm_relations), _("_Relations..."),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_osm_relations), _("_Relations"),
763      NULL, "<OSM2Go-Main>/OSM/Relations",      NULL, "<OSM2Go-Main>/Map/Relations",
764      GDK_r, GDK_SHIFT_MASK|GDK_CONTROL_MASK, FALSE, FALSE      GDK_r, GDK_SHIFT_MASK|GDK_CONTROL_MASK, TRUE, FALSE, FALSE
765    );    );
766    
767    /* -------------------- wms submenu -------------------- */    /* -------------------- wms submenu -------------------- */
768    
769    appdata->menu_wms = item = gtk_menu_item_new_with_mnemonic( _("_WMS") );    appdata->submenu_wms = item = gtk_menu_item_new_with_mnemonic( _("_WMS") );
770    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
771    submenu = gtk_menu_new();    submenu = gtk_menu_new();
772    gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);    gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
773    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
774    
775    menu_append_new_item(    menu_append_new_item(
776      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_wms_import), _("_Import..."),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_wms_import), _("_Import"),
777      GTK_STOCK_INDEX, "<OSM2Go-Main>/WMS/Import",      GTK_STOCK_INDEX, "<OSM2Go-Main>/WMS/Import",
778      0, 0, FALSE, FALSE      0, 0, TRUE, FALSE, FALSE
779    );    );
780    
781    appdata->menu_item_wms_clear = menu_append_new_item(    appdata->menu_item_wms_clear = menu_append_new_item(
782      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_wms_clear), _("_Clear"),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_wms_clear), _("_Clear"),
783      GTK_STOCK_CLEAR, "<OSM2Go-Main>/WMS/Clear",      GTK_STOCK_CLEAR, "<OSM2Go-Main>/WMS/Clear",
784      0, 0, FALSE, FALSE      0, 0, TRUE, FALSE, FALSE
785    );    );
786    gtk_widget_set_sensitive(appdata->menu_item_wms_clear, FALSE);    gtk_widget_set_sensitive(appdata->menu_item_wms_clear, FALSE);
787    
788    appdata->menu_item_wms_adjust = menu_append_new_item(    appdata->menu_item_wms_adjust = menu_append_new_item(
789      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_wms_adjust), _("_Adjust"),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_wms_adjust), _("_Adjust"),
790      NULL, "<OSM2Go-Main>/WMS/Adjust",      NULL, "<OSM2Go-Main>/WMS/Adjust",
791      0, 0, FALSE, FALSE      0, 0, TRUE, FALSE, FALSE
792    );    );
793    gtk_widget_set_sensitive(appdata->menu_item_wms_adjust, FALSE);    gtk_widget_set_sensitive(appdata->menu_item_wms_adjust, FALSE);
794    
   /* -------------------- map submenu -------------------- */  
   
   appdata->menu_map = item = gtk_menu_item_new_with_mnemonic( _("_Map") );  
   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);  
   
   appdata->menu_item_map_hide_sel = menu_append_new_item(  
     appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_hide_sel), _("_Hide selected"),  
     GTK_STOCK_REMOVE, "<OSM2Go-Main>/Map/HideSelected",  
     0, 0, FALSE, FALSE  
   );  
   gtk_widget_set_sensitive(appdata->menu_item_map_hide_sel, FALSE);  
   
   appdata->menu_item_map_show_all = menu_append_new_item(  
     appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_show_all), _("_Show all"),  
     GTK_STOCK_ADD, "<OSM2Go-Main>/Map/ShowAll",  
     0, 0, FALSE, FALSE  
   );  
   gtk_widget_set_sensitive(appdata->menu_item_map_show_all, FALSE);  
   
   gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());  
   
   menu_append_new_item(  
     appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_style), _("St_yle..."),  
     GTK_STOCK_SELECT_COLOR, "<OSM2Go-Main>/Map/Style",  
     0, 0, FALSE, FALSE  
   );  
   
   gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());  
   
   /* switches mainly intended for testing/debugging */  
   menu_append_new_item(  
     appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_redraw), _("_Redraw"),  
     NULL, "<OSM2Go-Main>/Map/Redraw",  
     GDK_r, GDK_CONTROL_MASK, FALSE, FALSE  
   );  
   
   appdata->menu_item_map_no_icons = menu_append_new_item(  
     appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_no_icons), _("No _icons"),  
     NULL, "<OSM2Go-Main>/Map/NoIcons",  
     0, 0, TRUE, appdata->settings->no_icons  
   );  
   
   appdata->menu_item_map_no_antialias = menu_append_new_item(  
     appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_no_antialias),  
     _("No _antialias"),  
     NULL, "<OSM2Go-Main>/Map/NoAntialias",  
     0, 0, TRUE, appdata->settings->no_antialias  
   );  
   
795    /* -------------------- track submenu -------------------- */    /* -------------------- track submenu -------------------- */
796    
797    appdata->track.menu_track = item = gtk_menu_item_new_with_mnemonic(_("_Track"));    appdata->track.submenu_track = item =
798        gtk_menu_item_new_with_mnemonic(_("_Track"));
799    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
800    submenu = gtk_menu_new();    submenu = gtk_menu_new();
801    gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);    gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
802    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
803    
804    appdata->track.menu_item_import = menu_append_new_item(    appdata->track.menu_item_track_import = menu_append_new_item(
805      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_import), _("_Import..."),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_import), _("_Import"),
806      NULL, "<OSM2Go-Main>/Track/Import",      NULL, "<OSM2Go-Main>/Track/Import",
807      0, 0, FALSE, FALSE      0, 0, TRUE, FALSE, FALSE
808    );    );
809    
810    appdata->track.menu_item_export = menu_append_new_item(    appdata->track.menu_item_track_export = menu_append_new_item(
811      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_export), _("_Export..."),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_export), _("_Export"),
812      NULL, "<OSM2Go-Main>/Track/Export",      NULL, "<OSM2Go-Main>/Track/Export",
813      0, 0, FALSE, FALSE      0, 0, FALSE, FALSE, FALSE
814    );    );
815    
816    appdata->track.menu_item_clear = menu_append_new_item(    appdata->track.menu_item_track_clear = menu_append_new_item(
817      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_clear), _("_Clear"),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_clear), _("_Clear"),
818      GTK_STOCK_CLEAR, "<OSM2Go-Main>/Track/Clear",      GTK_STOCK_CLEAR, "<OSM2Go-Main>/Track/Clear",
819      0, 0, FALSE, FALSE      0, 0, FALSE, FALSE, FALSE
820    );    );
821    
822    
823    appdata->track.menu_item_gps = menu_append_new_item(    appdata->track.menu_item_track_enable_gps = menu_append_new_item(
824      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_gps), _("_GPS"),      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_enable_gps),_("_GPS enable"),
825      NULL, "<OSM2Go-Main>/Track/GPS",      NULL, "<OSM2Go-Main>/Track/GPS",
826      GDK_g, GDK_CONTROL_MASK|GDK_SHIFT_MASK, TRUE, FALSE      GDK_g, GDK_CONTROL_MASK|GDK_SHIFT_MASK, TRUE, TRUE,
827        appdata->settings->enable_gps
828      );
829    
830      appdata->track.menu_item_track_follow_gps = menu_append_new_item(
831        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_follow_gps), _("GPS follow"),
832        NULL, "<OSM2Go-Main>/Track/Follow",
833        0, 0, appdata->settings->enable_gps, TRUE,
834        appdata->settings->follow_gps
835    );    );
836    
837    /* ------------------------------------------------------- */    /* ------------------------------------------------------- */
# Line 731  void menu_create(appdata_t *appdata) { Line 840  void menu_create(appdata_t *appdata) {
840                          gtk_separator_menu_item_new());                          gtk_separator_menu_item_new());
841    
842    menu_append_new_item(    menu_append_new_item(
843      appdata, about_quit_items_menu, GTK_SIGNAL_FUNC(cb_menu_about), _("_About..."),      appdata, about_quit_items_menu, GTK_SIGNAL_FUNC(cb_menu_about), _("_About"),
844      GTK_STOCK_ABOUT, "<OSM2Go-Main>/About",      GTK_STOCK_ABOUT, "<OSM2Go-Main>/About",
845      0, 0, FALSE, FALSE      0, 0, TRUE, FALSE, FALSE
846    );    );
847    
848    #ifndef USE_HILDON
849    menu_append_new_item(    menu_append_new_item(
850      appdata, about_quit_items_menu, GTK_SIGNAL_FUNC(cb_menu_quit), _("_Quit"),      appdata, about_quit_items_menu, GTK_SIGNAL_FUNC(cb_menu_quit), _("_Quit"),
851      GTK_STOCK_QUIT, "<OSM2Go-Main>/Quit",      GTK_STOCK_QUIT, "<OSM2Go-Main>/Quit",
852      0, 0, FALSE, FALSE      0, 0, TRUE, FALSE, FALSE
853    );    );
854    #endif
855    
856    gtk_window_add_accel_group(GTK_WINDOW(appdata->window), accel_grp);    gtk_window_add_accel_group(GTK_WINDOW(appdata->window), accel_grp);
857    
# Line 766  void menu_create(appdata_t *appdata) { Line 877  void menu_create(appdata_t *appdata) {
877    
878  #endif //USE_HILDON  #endif //USE_HILDON
879  }  }
880    #else // !defined(USE_HILDON) || (MAEMO_VERSION_MAJOR < 5)
881    
882    void submenu_entry(appdata_t *appdata, HildonAppMenu *menu,
883                       const char *label, const char *value,
884                       GtkSignalFunc activate_cb) {
885    
886    }
887    
888    typedef struct {
889      const char *label, *value;
890      gboolean enabled;
891      gboolean (*toggle)(appdata_t *appdata);
892      gulong offset;
893      GtkSignalFunc activate_cb;
894    } menu_entry_t;
895    
896    static gboolean no_icon_get_toggle(appdata_t *appdata) {
897      if(!appdata)           return FALSE;
898      if(!appdata->settings) return FALSE;
899      return appdata->settings->no_icons;
900    }
901    
902    static gboolean enable_gps_get_toggle(appdata_t *appdata) {
903      if(!appdata)           return FALSE;
904      if(!appdata->settings) return FALSE;
905      return appdata->settings->enable_gps;
906    }
907    
908    static gboolean follow_gps_get_toggle(appdata_t *appdata) {
909      if(!appdata)           return FALSE;
910      if(!appdata->settings) return FALSE;
911      return appdata->settings->follow_gps;
912    }
913    
914    /* create a HildonAppMenu */
915    static GtkWidget *app_menu_create(appdata_t *appdata,
916                                      const menu_entry_t *menu_entries) {
917      HildonAppMenu *menu = HILDON_APP_MENU(hildon_app_menu_new());
918    
919      while(menu_entries->label) {
920        GtkWidget *button = NULL;
921    
922        if(!menu_entries->toggle) {
923          button = hildon_button_new_with_text(
924                HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH,
925                HILDON_BUTTON_ARRANGEMENT_VERTICAL,
926                _(menu_entries->label), _(menu_entries->value));
927          g_signal_connect_after(button, "clicked",
928                                 menu_entries->activate_cb, appdata);
929        } else {
930          button = hildon_check_button_new(HILDON_SIZE_AUTO);
931          gtk_button_set_label(GTK_BUTTON(button), _(menu_entries->label));
932          printf("requesting check for %s: %p\n", menu_entries->label,
933                 menu_entries->toggle);
934          hildon_check_button_set_active(HILDON_CHECK_BUTTON(button),
935                                         menu_entries->toggle(appdata));
936          g_signal_connect_after(button, "toggled",
937                                 menu_entries->activate_cb, appdata);
938        }
939    
940        /* offset to GtkWidget pointer was given -> store pointer */
941        if(menu_entries->offset)
942          *(GtkWidget**)(((void*)appdata)+menu_entries->offset) = button;
943    
944        gtk_widget_set_sensitive(button, menu_entries->enabled);
945    
946        hildon_app_menu_append(menu, GTK_BUTTON(button));
947        menu_entries++;
948      }
949    
950      gtk_widget_show_all(GTK_WIDGET(menu));
951      return GTK_WIDGET(menu);
952    }
953    
954    /* the view submenu */
955    void on_submenu_view_clicked(GtkButton *button, appdata_t *appdata) {
956      hildon_app_menu_popup(HILDON_APP_MENU(appdata->app_menu_view),
957                            GTK_WINDOW(appdata->window));
958    }
959    
960    void on_submenu_map_clicked(GtkButton *button, appdata_t *appdata) {
961      hildon_app_menu_popup(HILDON_APP_MENU(appdata->app_menu_map),
962                            GTK_WINDOW(appdata->window));
963    }
964    
965    void on_submenu_wms_clicked(GtkButton *button, appdata_t *appdata) {
966      hildon_app_menu_popup(HILDON_APP_MENU(appdata->app_menu_wms),
967                            GTK_WINDOW(appdata->window));
968    }
969    
970    void on_submenu_track_clicked(GtkButton *button, appdata_t *appdata) {
971      hildon_app_menu_popup(HILDON_APP_MENU(appdata->app_menu_track),
972                            GTK_WINDOW(appdata->window));
973    }
974    
975    #define APP_OFFSET(a)  offsetof(appdata_t, a)
976    #define SIMPLE_ENTRY(a,b)     { a, NULL, TRUE,   NULL, 0, G_CALLBACK(b) }
977    #define ENABLED_ENTRY(a,b,c)  { a, NULL, TRUE,  NULL, APP_OFFSET(c), G_CALLBACK(b) }
978    #define DISABLED_ENTRY(a,b,c) { a, NULL, FALSE,  NULL, APP_OFFSET(c), G_CALLBACK(b) }
979    #define TOGGLE_ENTRY(a,b,c)   { a, NULL, TRUE, c, 0, G_CALLBACK(b) }
980    #define DISABLED_TOGGLE_ENTRY(a,b,c,d)  \
981                                  { a, NULL, FALSE, c, APP_OFFSET(d), G_CALLBACK(b) }
982    #define ENABLED_TOGGLE_ENTRY(a,b,c,d) \
983                                  { a, NULL, TRUE, c, APP_OFFSET(d), G_CALLBACK(b) }
984    #define LAST_ENTRY            { NULL, NULL, FALSE, NULL, 0, NULL }
985    
986    /* -- the view submenu -- */
987    static const menu_entry_t submenu_view[] = {
988      SIMPLE_ENTRY("Zoom in",         cb_menu_zoomin),
989      SIMPLE_ENTRY("Zoom out",        cb_menu_zoomout),
990      /* --- */
991      SIMPLE_ENTRY("Style",           cb_menu_style),
992      /* --- */
993      SIMPLE_ENTRY("Normal details",  cb_menu_view_detail_normal),
994      SIMPLE_ENTRY("More details",    cb_menu_view_detail_inc),
995      SIMPLE_ENTRY("Less details",    cb_menu_view_detail_dec),
996      /* --- */
997      DISABLED_ENTRY("Hide selected", cb_menu_map_hide_sel, menu_item_map_hide_sel),
998      DISABLED_ENTRY("Show all",      cb_menu_map_show_all, menu_item_map_show_all),
999      /* --- */
1000      TOGGLE_ENTRY("No icons",        cb_menu_map_no_icons, no_icon_get_toggle),
1001    
1002      LAST_ENTRY
1003    };
1004    
1005    /* -- the map submenu -- */
1006    static const menu_entry_t submenu_map[] = {
1007      ENABLED_ENTRY("Upload",                cb_menu_upload, menu_item_map_upload),
1008      SIMPLE_ENTRY("Download",               cb_menu_download),
1009      ENABLED_ENTRY("Save local changes",    cb_menu_save_changes,
1010                                               menu_item_map_save_changes),
1011      ENABLED_ENTRY("Discard local changes", cb_menu_undo_changes,
1012                                               menu_item_map_undo_changes),
1013      ENABLED_ENTRY("Relations",             cb_menu_osm_relations,
1014                                               menu_item_map_relations),
1015    
1016      LAST_ENTRY
1017    };
1018    
1019    /* -- the wms submenu -- */
1020    static const menu_entry_t submenu_wms[] = {
1021      SIMPLE_ENTRY("Import",   cb_menu_wms_import),
1022      DISABLED_ENTRY("Clear",  cb_menu_wms_clear, menu_item_wms_clear),
1023      DISABLED_ENTRY("Adjust", cb_menu_wms_adjust, menu_item_wms_adjust),
1024    
1025      LAST_ENTRY
1026    };
1027    
1028    /* -- the track submenu -- */
1029    static const menu_entry_t submenu_track[] = {
1030      ENABLED_ENTRY("Import",  cb_menu_track_import, track.menu_item_track_import),
1031      DISABLED_ENTRY("Export", cb_menu_track_export, track.menu_item_track_export),
1032      DISABLED_ENTRY("Clear",  cb_menu_track_clear, track.menu_item_track_clear),
1033      ENABLED_TOGGLE_ENTRY("GPS enable", cb_menu_track_enable_gps,
1034                    enable_gps_get_toggle, track.menu_item_track_enable_gps),
1035      DISABLED_TOGGLE_ENTRY("GPS follow", cb_menu_track_follow_gps,
1036                    follow_gps_get_toggle, track.menu_item_track_follow_gps),
1037    
1038      LAST_ENTRY
1039    };
1040    
1041    
1042    /* -- the applications main menu -- */
1043    static const menu_entry_t main_menu[] = {
1044      SIMPLE_ENTRY("About",   cb_menu_about),
1045      SIMPLE_ENTRY("Project", cb_menu_project_open),
1046      ENABLED_ENTRY("View",   on_submenu_view_clicked,  submenu_view),
1047      ENABLED_ENTRY("Map",    on_submenu_map_clicked,   submenu_map),
1048      ENABLED_ENTRY("WMS",    on_submenu_wms_clicked,   submenu_wms),
1049      ENABLED_ENTRY("Track",  on_submenu_track_clicked, track.submenu_track),
1050    
1051      LAST_ENTRY
1052    };
1053    
1054    void menu_create(appdata_t *appdata) {
1055      HildonAppMenu *menu = HILDON_APP_MENU(hildon_app_menu_new());
1056    
1057      /* build menu/submenus */
1058      menu = HILDON_APP_MENU(app_menu_create(appdata, main_menu));
1059      appdata->app_menu_wms   = app_menu_create(appdata, submenu_wms);
1060      appdata->app_menu_map   = app_menu_create(appdata, submenu_map);
1061      appdata->app_menu_view  = app_menu_create(appdata, submenu_view);
1062      appdata->app_menu_track = app_menu_create(appdata, submenu_track);
1063    
1064      /* enable/disable some entries according to settings */
1065      if(appdata && appdata->settings)
1066        gtk_widget_set_sensitive(appdata->track.menu_item_track_follow_gps,
1067                                 appdata->settings->enable_gps);
1068    
1069      hildon_window_set_app_menu(HILDON_WINDOW(appdata->window), menu);
1070    }
1071    #endif
1072    
1073  /********************* end of menu **********************/  /********************* end of menu **********************/
1074    
# Line 837  void cleanup(appdata_t *appdata) { Line 1140  void cleanup(appdata_t *appdata) {
1140    
1141    project_free(appdata->project);    project_free(appdata->project);
1142    
1143    if(appdata->menu_item_osm_undo)    if(appdata->menu_item_map_undo)
1144      undo_free(appdata->undo.state);      undo_free(appdata->undo.state);
1145    
1146    puts("everything is gone");    puts("everything is gone");
# Line 855  gboolean on_window_key_press(GtkWidget * Line 1158  gboolean on_window_key_press(GtkWidget *
1158    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
1159    int handled = FALSE;    int handled = FALSE;
1160    
1161      //  printf("key event with keyval %x\n", event->keyval);
1162    
1163    // the map handles some keys on its own ...    // the map handles some keys on its own ...
1164    switch(event->keyval) {    switch(event->keyval) {
1165    
1166    #if !defined(USE_HILDON) || (MAEMO_VERSION_MAJOR < 5)
1167  #ifdef USE_HILDON  #ifdef USE_HILDON
1168      /* this is in fact a mapping to GDK_F6 */      /* this is in fact a mapping to GDK_F6 */
1169    case HILDON_HARDKEY_FULLSCREEN:    case HILDON_HARDKEY_FULLSCREEN:
# Line 877  gboolean on_window_key_press(GtkWidget * Line 1183  gboolean on_window_key_press(GtkWidget *
1183    
1184      handled = TRUE;      handled = TRUE;
1185      break;      break;
1186    #endif
1187    }    }
1188    
1189    /* forward unprocessed key presses to map */    /* forward unprocessed key presses to map */
# Line 904  int main(int argc, char *argv[]) { Line 1211  int main(int argc, char *argv[]) {
1211    
1212    g_thread_init(NULL);    g_thread_init(NULL);
1213    
   gps_init(&appdata);  
   
1214    gtk_init (&argc, &argv);    gtk_init (&argc, &argv);
1215    
1216      gps_init(&appdata);
1217    
1218  #ifdef USE_HILDON  #ifdef USE_HILDON
1219    printf("Installing osso context for \"org.harbaum." PACKAGE "\"\n");    printf("Installing osso context for \"org.harbaum." PACKAGE "\"\n");
1220    appdata.osso_context = osso_initialize("org.harbaum."PACKAGE,    appdata.osso_context = osso_initialize("org.harbaum."PACKAGE,
# Line 924  int main(int argc, char *argv[]) { Line 1231  int main(int argc, char *argv[]) {
1231    g_set_application_name("OSM2Go");    g_set_application_name("OSM2Go");
1232    
1233    /* Create HildonWindow and set it to HildonProgram */    /* Create HildonWindow and set it to HildonProgram */
1234    #if MAEMO_VERSION_MAJOR < 5
1235    appdata.window = HILDON_WINDOW(hildon_window_new());    appdata.window = HILDON_WINDOW(hildon_window_new());
1236    #else
1237      appdata.window = HILDON_WINDOW(hildon_stackable_window_new());
1238    #endif
1239    hildon_program_add_window(appdata.program, appdata.window);    hildon_program_add_window(appdata.program, appdata.window);
1240    
1241    #if MAEMO_VERSION_MAJOR == 6
1242      unsigned long val;
1243      XChangeProperty(GDK_DISPLAY(),
1244                      GDK_WINDOW_XID(GTK_WIDGET(appdata.window)->window),
1245                      XInternAtom(GDK_DISPLAY(),
1246                                  "_HILDON_ZOOM_KEY_ATOM",
1247                                  False), XA_INTEGER, 32,
1248                      PropModeReplace, (unsigned char *) &val, 1);
1249    #endif
1250    
1251  #else  #else
1252    /* Create a Window. */    /* Create a Window. */
1253    appdata.window = gtk_window_new(GTK_WINDOW_TOPLEVEL);    appdata.window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
# Line 969  int main(int argc, char *argv[]) { Line 1291  int main(int argc, char *argv[]) {
1291    }    }
1292    
1293    gtk_box_pack_start(GTK_BOX(vbox), map, TRUE, TRUE, 0);    gtk_box_pack_start(GTK_BOX(vbox), map, TRUE, TRUE, 0);
1294    
1295    #ifdef ZOOM_BUTTONS
1296      GtkWidget *zhbox = gtk_hbox_new(FALSE, 0);
1297    
1298      gtk_box_pack_start_defaults(GTK_BOX(zhbox), statusbar_new(&appdata));
1299    
1300      /* ---- add zoom out button right of statusbar ---- */
1301      appdata.btn_zoom_out = gtk_button_new();
1302      gtk_button_set_image(GTK_BUTTON(appdata.btn_zoom_out),
1303            gtk_image_new_from_stock(GTK_STOCK_ZOOM_OUT, GTK_ICON_SIZE_MENU));
1304      g_signal_connect(appdata.btn_zoom_out, "clicked",
1305                       G_CALLBACK(cb_menu_zoomout), &appdata);
1306      gtk_box_pack_start(GTK_BOX(zhbox), appdata.btn_zoom_out, FALSE, FALSE, 0);
1307    
1308      /* ---- add zoom in button right of statusbar ---- */
1309      appdata.btn_zoom_in = gtk_button_new();
1310      gtk_button_set_image(GTK_BUTTON(appdata.btn_zoom_in),
1311            gtk_image_new_from_stock(GTK_STOCK_ZOOM_IN, GTK_ICON_SIZE_MENU));
1312      g_signal_connect(appdata.btn_zoom_in, "clicked",
1313                       G_CALLBACK(cb_menu_zoomin), &appdata);
1314      gtk_box_pack_start(GTK_BOX(zhbox), appdata.btn_zoom_in, FALSE, FALSE, 0);
1315    
1316    
1317      gtk_box_pack_start(GTK_BOX(vbox), zhbox, FALSE, FALSE, 0);
1318    #else
1319    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);
1320    #endif
1321    
1322  #ifndef PORTRAIT  #ifndef PORTRAIT
1323    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);
1324  #endif  #endif
   gtk_box_pack_start(GTK_BOX(hbox), gtk_vseparator_new(), FALSE, FALSE, 0);  
1325    gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);    gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
1326    
1327    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 987  int main(int argc, char *argv[]) { Line 1334  int main(int argc, char *argv[]) {
1334    
1335    /* let gtk do its thing before loading the data, */    /* let gtk do its thing before loading the data, */
1336    /* so the user sees something */    /* so the user sees something */
1337    while(gtk_events_pending()) {    while(gtk_events_pending())
     putchar('.');  
1338      gtk_main_iteration();      gtk_main_iteration();
   }  
1339    
1340    /* load project if one is specified in the settings */    /* load project if one is specified in the settings */
1341    if(appdata.settings->project)    if(appdata.settings->project)
# Line 998  int main(int argc, char *argv[]) { Line 1343  int main(int argc, char *argv[]) {
1343    
1344    main_ui_enable(&appdata);    main_ui_enable(&appdata);
1345    
1346    /* ------------ jump into main loop ---------------- */    /* start GPS if enabled by config */
1347      if(appdata.settings && appdata.settings->enable_gps)
1348        track_enable_gps(&appdata, TRUE);
1349    
1350      /* again let the ui do its thing */
1351      while(gtk_events_pending())
1352        gtk_main_iteration();
1353    
1354    #if 0  // test overlay
1355      {
1356        GtkWidget *overlay = gtk_window_new(GTK_WINDOW_POPUP);
1357        gtk_window_set_default_size(GTK_WINDOW(overlay), 40, 20);
1358        gtk_window_set_transient_for(GTK_WINDOW(overlay), GTK_WINDOW(appdata.window));
1359        gtk_window_set_keep_above(GTK_WINDOW(overlay), TRUE);
1360        gtk_window_set_destroy_with_parent(GTK_WINDOW(overlay), TRUE);
1361        gtk_window_set_position(GTK_WINDOW(overlay), GTK_WIN_POS_CENTER_ON_PARENT);
1362    
1363        gtk_window_set_gravity(GTK_WINDOW(overlay), GDK_GRAVITY_NORTH_EAST);
1364    
1365        printf("x = %d\n", gdk_screen_width() - overlay->allocation.width);
1366        gtk_window_move(GTK_WINDOW(overlay),
1367                        gdk_screen_width() - overlay->allocation.width, 60);
1368    
1369        gtk_window_set_decorated(GTK_WINDOW(overlay), TRUE);
1370    
1371        /* add some zoom buttons for testing */
1372        GtkWidget *hbox = gtk_hbox_new(TRUE, 0);
1373        gtk_box_pack_start_defaults(GTK_BOX(hbox), gtk_button_new_with_label("+"));
1374        gtk_box_pack_start_defaults(GTK_BOX(hbox), gtk_button_new_with_label("-"));
1375        gtk_container_add(GTK_CONTAINER(overlay), hbox);
1376    
1377        gtk_widget_show_all(overlay);
1378      }
1379    #endif
1380    
1381      /* start to interact with the user now that the gui is running */
1382      if(appdata.settings->first_run_demo) {
1383        messagef(GTK_WIDGET(appdata.window), _("Welcome to OSM2Go"),
1384                 _("This is the first time you run OSM2Go. "
1385                   "A demo project has been loaded to get you "
1386                   "started. You can play around with this demo as much "
1387                   "as you like. However, you cannot upload or download "
1388                   "the demo project.\n\n"
1389                   "In order to start working on real data you'll have "
1390                   "to setup a new project and enter your OSM user name "
1391                   "and password. You'll then be able to download the "
1392                   "latest data from OSM and upload your changes into "
1393                   "the OSM main database."
1394                   ));
1395      }
1396    
1397      /* ------------ jump into main loop ---------------- */
1398    gtk_main();    gtk_main();
1399    
1400    puts("gtk_main() left");    puts("gtk_main() left");
1401    
1402    track_save(appdata.project, appdata.track.track);    track_save(appdata.project, appdata.track.track);
1403      track_clear(&appdata, appdata.track.track);
1404      appdata.track.track = NULL;
1405    
1406    /* save a diff if there are dirty entries */    /* save a diff if there are dirty entries */
1407    diff_save(appdata.project, appdata.osm);    diff_save(appdata.project, appdata.osm);
Legend:
Removed from v.79  
changed lines
  Added in v.227