Diff of /trunk/src/main.c

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

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