Diff of /trunk/src/main.c

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

revision 2 by achadwick, Wed Dec 10 00:00:05 2008 UTC revision 242 by harbaum, Fri Jul 24 09:48:42 2009 UTC
# Line 1  Line 1 
1  /*  /*
2     * Copyright (C) 2008 Till Harbaum <till@harbaum.org>.
3     *
4   * This file is part of OSM2Go.   * This file is part of OSM2Go.
5   *   *
6   * OSM2Go is free software: you can redistribute it and/or modify   * OSM2Go is free software: you can redistribute it and/or modify
# Line 19  Line 21 
21  #include <string.h>  #include <string.h>
22    
23  #include <curl/curl.h>  #include <curl/curl.h>
24    #include <gdk/gdkkeysyms.h>
25    
26    #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"
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_project_loaded(appdata_t *appdata) {  void main_ui_enable(appdata_t *appdata) {
39    gboolean loaded = (appdata->project != NULL);    gboolean project_valid = (appdata->project != NULL);
40      gboolean osm_valid = (appdata->osm != NULL);
41    
42    /* cancel any action in progress */    /* cancel any action in progress */
43    if(GTK_WIDGET_FLAGS(appdata->iconbar->cancel) & GTK_SENSITIVE)    if(GTK_WIDGET_FLAGS(appdata->iconbar->cancel) & GTK_SENSITIVE)
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(loaded)  #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)
64      str = g_strdup_printf("OSM2Go - %s", appdata->project->name);      str = g_strdup_printf("OSM2Go - %s", 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(loaded)  
     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, loaded);      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->track.menu_track, loaded);    gtk_widget_set_sensitive(appdata->submenu_map, project_valid);
77    gtk_widget_set_sensitive(appdata->menu_view, loaded);    gtk_widget_set_sensitive(appdata->menu_item_map_upload, osm_valid);
78    gtk_widget_set_sensitive(appdata->menu_osm, loaded);    if(appdata->menu_item_map_undo)
79    gtk_widget_set_sensitive(appdata->menu_wms, loaded);      gtk_widget_set_sensitive(appdata->menu_item_map_undo, osm_valid);
80    gtk_widget_set_sensitive(appdata->menu_map, loaded);    gtk_widget_set_sensitive(appdata->menu_item_map_save_changes, osm_valid);
81    gtk_widget_set_sensitive(appdata->menu_item_project_close, loaded);    gtk_widget_set_sensitive(appdata->menu_item_map_undo_changes, osm_valid);
82      gtk_widget_set_sensitive(appdata->menu_item_map_relations, osm_valid);
83      gtk_widget_set_sensitive(appdata->track.submenu_track, osm_valid);
84      gtk_widget_set_sensitive(appdata->submenu_view, osm_valid);
85      gtk_widget_set_sensitive(appdata->submenu_wms, osm_valid);
86    
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(!loaded)    if(!project_valid)
93      statusbar_set(appdata, _("Plase load or create a project"), FALSE);      statusbar_set(appdata, _("Please load or create a project"), FALSE);
94  }  }
95    
96  /******************** begin of menu *********************/  /******************** begin of menu *********************/
97    
 #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  
   
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_project_loaded(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_project_loaded(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",      "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->osm || !appdata->project) return;    if(!appdata->project) return;
162    
163    /* redraw the entire map by destroying all map items and redrawing them */    if(project_check_demo(GTK_WIDGET(appdata->window), appdata->project))
164    diff_save(appdata->project, appdata->osm);      return;
165    map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);  
166    osm_free(&appdata->icon, appdata->osm);    /* if we have valid osm data loaded: save state first */
167      if(appdata->osm) {
168        /* redraw the entire map by destroying all map items and redrawing them */
169        diff_save(appdata->project, appdata->osm);
170        map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);
171        osm_free(&appdata->icon, appdata->osm);
172    
173        appdata->osm = NULL;
174      }
175    
176    // download    // download
177    osm_download(GTK_WIDGET(appdata->window), appdata->project);    if(osm_download(GTK_WIDGET(appdata->window), appdata->settings,
178                      appdata->project)) {
179        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);
182        map_paint(appdata);
183        banner_busy_stop(appdata); //"Redrawing"
184      }
185    
186    appdata->osm = osm_parse(appdata->project->osm);    main_ui_enable(appdata);
   diff_restore(appdata, appdata->project, appdata->osm);  
   map_paint(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 172  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 defined(USE_HILDON) && (MAEMO_VERSION_MAJOR == 5)
224    #define MENU_CHECK_ITEM HildonCheckButton
225    #define MENU_CHECK_ITEM_ACTIVE(a) hildon_check_button_get_active(a)
226    #else
227    #define MENU_CHECK_ITEM GtkCheckMenuItem
228    #define MENU_CHECK_ITEM_ACTIVE(a) gtk_check_menu_item_get_active(a)
229    #endif
230    
 #if 1  // mainly for testing  
231  static void  static void
232  cb_menu_redraw(GtkWidget *window, gpointer data) {  cb_menu_map_no_icons(MENU_CHECK_ITEM *item, appdata_t *appdata) {
   appdata_t *appdata = (appdata_t*)data;  
233    
234    /* redraw the entire map by destroying all map items and redrawing them */    banner_busy_start(appdata, 1, "Redrawing");
235    track_save(appdata->project, appdata->track.track);    map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);
236    diff_save(appdata->project, appdata->osm);  
237    map_clear(appdata, MAP_LAYER_ALL);    appdata->settings->no_icons = MENU_CHECK_ITEM_ACTIVE(item);
   osm_free(&appdata->icon, appdata->osm);  
238    
   appdata->osm = osm_parse(appdata->project->osm);  
   diff_restore(appdata, appdata->project, appdata->osm);  
239    map_paint(appdata);    map_paint(appdata);
240      banner_busy_stop(appdata); //"Redrawing"
241    }
242    
243    appdata->track.track = track_restore(appdata, appdata->project);  static void
244    if(appdata->track.track)  cb_menu_style(GtkMenuItem *item, gpointer data) {
245      map_track_draw(appdata->map, appdata->track.track);    appdata_t *appdata = (appdata_t*)data;
246    
247    wms_load(appdata);    style_select(GTK_WIDGET(appdata->window), appdata);
248  }  }
 #endif  
249    
250  static void  static void
251  cb_menu_style(GtkWidget *window, gpointer data) {  cb_menu_undo(GtkMenuItem *item, gpointer data) {
252    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
253    
254    style_select(GTK_WIDGET(appdata->window), appdata);    undo(appdata);
255    
256      // the banner will be displayed from within undo with more details
257  }  }
258    
259  static void  static void
260  cb_menu_save_changes(GtkWidget *window, 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);
264    statusbar_set(appdata, _("Saved all changes in projects diff file"), FALSE);    banner_show_info(appdata, _("Saved local changes"));
265  }  }
266    
267    static void
268    cb_menu_undo_changes(GtkMenuItem *item, gpointer data) {
269      appdata_t *appdata = (appdata_t*)data;
270    
271  #ifdef USE_HILDON    if(!yes_no_f(GTK_WIDGET(appdata->window), NULL, 0, 0,
272                   _("Undo all changes?"),
273                   _("Throw away all the changes you've not "
274                     "uploaded yet? This can't be undone.")))
275        return;
276    
277      banner_busy_start(appdata, 1, _("Redrawing"));
278      map_clear(appdata, MAP_LAYER_OBJECTS_ONLY);
279      osm_free(&appdata->icon, appdata->osm);
280      diff_remove(appdata->project);
281      appdata->osm = osm_parse(appdata->project->path, appdata->project->osm);
282      map_paint(appdata);
283      banner_busy_stop(appdata);  //"Redrawing"
284    
285      banner_show_info(appdata, _("Undo all changes"));
286    }
287    
288    static void
289    cb_menu_osm_relations(GtkMenuItem *item, appdata_t *appdata) {
290      /* 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));
# Line 237  cb_menu_fullscreen(GtkWidget *widget, gp Line 304  cb_menu_fullscreen(GtkWidget *widget, gp
304  #endif  #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 245  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 253  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 270  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 302  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    
 void menu_create(appdata_t *appdata) {  
   GtkWidget *menu, *item, *submenu;  
   menu = gtk_menu_new();  
485    
486    
   /* -------------------- Project submenu -------------------- */  
487    
488    item = gtk_menu_item_new_with_label( _("Project") );  /*
489    gtk_menu_append(GTK_MENU_SHELL(menu), item);   *  Platform-specific UI tweaks.
490    submenu = gtk_menu_new();   */
   gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);  
491    
   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);  
492    
493    appdata->menu_item_project_close = item =  #ifndef USE_HILDON
494      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);  
495    
496    /* --------------- view menu ------------------- */  // Portrait mode, for openmoko-like systems
497    #define uispecific_main_menu_new gtk_menu_new
498    
499    gtk_menu_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());  #else
500    
501    // Regular desktop builds
502    #define uispecific_main_menu_new gtk_menu_bar_new
503    #define UISPECIFIC_MAIN_MENU_IS_MENU_BAR
504    #define UISPECIFIC_MENU_HAS_ICONS
505    #define UISPECIFIC_MENU_HAS_ACCELS
506    
507    #endif //PORTRAIT
508    #else//USE_HILDON
509    
510    // Maemo/Hildon builds
511    #define uispecific_main_menu_new gtk_menu_new
512    
   appdata->menu_view = item =  
     gtk_menu_item_new_with_label( _("View") );  
   gtk_menu_append(GTK_MENU_SHELL(menu), item);  
   submenu = gtk_menu_new();  
   gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);  
   
 #ifdef USE_HILDON  
   appdata->fullscreen_menu_item =  
     item = gtk_check_menu_item_new_with_label( _("Fullscreen") );  
   gtk_menu_append(GTK_MENU_SHELL(submenu), item);  
   g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_fullscreen),  
                    appdata);  
513  #endif  #endif
514    
   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_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);  
515    
516    /* -------------------- OSM submenu -------------------- */  #if !defined(USE_HILDON) || (MAEMO_VERSION_MAJOR < 5)
517    // Half-arsed slapdash common menu item constructor. Let's use GtkBuilder
518    // instead so we have some flexibility.
519    
520    static GtkWidget *
521    menu_append_new_item(appdata_t *appdata,
522                         GtkWidget *menu_shell,
523                         GtkSignalFunc activate_cb,
524                         char *label,
525                         const gchar *icon_name, // stock id or name for icon_load
526                                        // overridden by label, accels, icon_name
527                         const gchar *accel_path,
528                         guint accel_key,      // from gdk/gdkkeysyms.h
529                         GdkModifierType accel_mods, // e.g. GDK_CONTROL_MASK
530                         gboolean enabled,
531                         gboolean is_check, gboolean check_status)
532    {
533      GtkWidget *item = NULL;
534      GtkWidget *image = NULL;
535    
536      gboolean stock_item_known = FALSE;
537      GtkStockItem stock_item;
538      if (icon_name != NULL) {
539        stock_item_known = gtk_stock_lookup(icon_name, &stock_item);
540      }
541    
542    appdata->menu_osm = item = gtk_menu_item_new_with_label( _("OSM") );    // Icons
543    gtk_menu_append(GTK_MENU_SHELL(menu), item);  #ifndef UISPECIFIC_MENU_HAS_ICONS
544    submenu = gtk_menu_new();    item = is_check ? gtk_check_menu_item_new_with_mnemonic (label)
545    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);                    : gtk_menu_item_new_with_mnemonic       (label);
546    #else
547      if (is_check) {
548        item = gtk_check_menu_item_new_with_mnemonic (label);
549      }
550      else if (!stock_item_known) {
551        GdkPixbuf *pbuf = icon_load(&appdata->icon, icon_name);
552        if (pbuf) {
553          image = gtk_image_new_from_pixbuf(pbuf);
554        }
555        if (image) {
556          item = gtk_image_menu_item_new_with_mnemonic(label);
557          gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
558        }
559        else {
560          item = gtk_menu_item_new_with_mnemonic(label);
561        }
562      }
563      else {
564        item = gtk_image_menu_item_new_with_mnemonic(label);
565        image = gtk_image_new_from_stock(icon_name, GTK_ICON_SIZE_MENU);
566        gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
567      }
568    #endif
569    
570    item = gtk_menu_item_new_with_label( _("Upload...") );  #ifdef UISPECIFIC_MENU_HAS_ACCELS
571    gtk_menu_append(GTK_MENU_SHELL(submenu), item);    // Accelerators
572    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_upload), appdata);    // Default
573      if (accel_path != NULL) {
574    item = gtk_menu_item_new_with_label( _("Download...") );      gtk_menu_item_set_accel_path(GTK_MENU_ITEM(item), accel_path);
575    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      if (accel_key != 0) {
576    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_download), appdata);        gtk_accel_map_add_entry( accel_path, accel_key, accel_mods );
577        }
578    gtk_menu_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());      else if (stock_item_known) {
579          gtk_accel_map_add_entry( accel_path, stock_item.keyval,
580    item = gtk_menu_item_new_with_label( _("Save diff file") );                                 stock_item.modifier );
581    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      }
582    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_save_changes),    }
583    #endif
584    
585      gtk_menu_shell_append(GTK_MENU_SHELL(menu_shell), GTK_WIDGET(item));
586      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);
589    
590      g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(activate_cb),
591                     appdata);                     appdata);
592      return item;
593    }
594    
595    /* -------------------- wms submenu -------------------- */  void menu_create(appdata_t *appdata) {
596      GtkWidget *menu, *item, *submenu;
597      GtkWidget *about_quit_items_menu;
598    
599      if (g_module_supported()) {
600        printf("*** can use GModule: consider using GtkUIManager / GtkBuilder\n");
601      }
602    
603    appdata->menu_wms = item = gtk_menu_item_new_with_label( _("WMS") );    menu = uispecific_main_menu_new();
604    gtk_menu_append(GTK_MENU_SHELL(menu), item);    about_quit_items_menu = menu;
605    
606      /* -------------------- Project submenu -------------------- */
607    
608      GtkAccelGroup *accel_grp = gtk_accel_group_new();
609    
610    #ifndef USE_HILDON
611      item = gtk_menu_item_new_with_mnemonic( _("_Project") );
612      gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
613    submenu = gtk_menu_new();    submenu = gtk_menu_new();
614      gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
615    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
616    #ifdef UISPECIFIC_MAIN_MENU_IS_MENU_BAR
617    item = gtk_menu_item_new_with_label( _("Import...") );    about_quit_items_menu = submenu;
618    gtk_menu_append(GTK_MENU_SHELL(submenu), item);  #endif
   g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_wms_import),  
                    appdata);  
619    
620    appdata->menu_item_wms_clear = item =    menu_append_new_item(
621      gtk_menu_item_new_with_label( _("Clear") );      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_project_open), _("_Open"),
622    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      GTK_STOCK_OPEN, "<OSM2Go-Main>/Project/Open",
623    gtk_widget_set_sensitive(item, FALSE);      0, 0, TRUE, FALSE, FALSE
624    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_wms_clear),    );
625                     appdata);  
626      menu_append_new_item(
627        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_project_wizard), _("_Wizard"),
628        GTK_STOCK_NEW, "<OSM2Go-Main>/Project/Wizard",
629        0, 0, TRUE, FALSE, FALSE
630      );
631    #else
632      menu_append_new_item(
633        appdata, menu, GTK_SIGNAL_FUNC(cb_menu_project_open), _("_Project"),
634        GTK_STOCK_OPEN, "<OSM2Go-Main>/Project",
635        0, 0, TRUE, FALSE, FALSE
636      );
637    #endif
638    
639    appdata->menu_item_wms_adjust = item =    /* --------------- view menu ------------------- */
     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);  
640    
641    /* -------------------- map submenu -------------------- */  #ifndef UISPECIFIC_MAIN_MENU_IS_MENU_BAR
642      gtk_menu_shell_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());
643    #endif
644    
645    appdata->menu_map = item = gtk_menu_item_new_with_label( _("Map") );    appdata->submenu_view = item = gtk_menu_item_new_with_mnemonic( _("_View") );
646    gtk_menu_append(GTK_MENU_SHELL(menu), item);    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
647    submenu = gtk_menu_new();    submenu = gtk_menu_new();
648      gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
649    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
650    
651    appdata->menu_item_map_hide_sel = item =  #if !defined(USE_HILDON) || (MAEMO_VERSION_MAJOR < 5)
652      gtk_menu_item_new_with_label( _("Hide selected") );    appdata->menu_item_view_fullscreen = menu_append_new_item(
653    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_fullscreen), _("_Fullscreen"),
654    gtk_widget_set_sensitive(item, FALSE);      GTK_STOCK_FULLSCREEN, "<OSM2Go-Main>/View/Fullscreen",
655    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_map_hide_sel),      0, 0, TRUE, TRUE, FALSE
656                     appdata);    );
657    #endif
   appdata->menu_item_map_show_all = item =  
     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);  
658    
659    gtk_menu_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());  #if !defined(ZOOM_BUTTONS) || !defined(USE_HILDON)
660      menu_append_new_item(
661        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_zoomin), _("Zoom _in"),
662        GTK_STOCK_ZOOM_IN, "<OSM2Go-Main>/View/ZoomIn",
663        GDK_comma, GDK_CONTROL_MASK, TRUE, FALSE, FALSE
664      );
665    
666      menu_append_new_item(
667        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_zoomout), _("Zoom _out"),
668        GTK_STOCK_ZOOM_OUT, "<OSM2Go-Main>/View/ZoomOut",
669        GDK_period, GDK_CONTROL_MASK, TRUE, FALSE, FALSE
670      );
671    #endif
672    
673    item = gtk_menu_item_new_with_label( _("Redraw") );    gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
   gtk_menu_append(GTK_MENU_SHELL(submenu), item);  
   g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_redraw), appdata);  
674    
675    gtk_menu_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());    menu_append_new_item(
676        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_view_detail_inc), _("More details"),
677        NULL, "<OSM2Go-Main>/View/DetailInc",
678        GDK_period, GDK_MOD1_MASK, TRUE, FALSE, FALSE
679      );
680    
681      menu_append_new_item(
682        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_view_detail_normal), _("Normal details"),
683        NULL, "<OSM2Go-Main>/View/DetailNormal",
684        0, 0, TRUE, FALSE, FALSE
685      );
686    
687      menu_append_new_item(
688        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_view_detail_dec), _("Less details"),
689        NULL, "<OSM2Go-Main>/View/DetailDec",
690        GDK_comma, GDK_MOD1_MASK, TRUE, FALSE, FALSE
691      );
692    
693      gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
694    
695      appdata->menu_item_map_hide_sel = menu_append_new_item(
696        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_hide_sel), _("_Hide selected"),
697        GTK_STOCK_REMOVE, "<OSM2Go-Main>/View/HideSelected",
698        0, 0, TRUE, FALSE, FALSE
699      );
700      gtk_widget_set_sensitive(appdata->menu_item_map_hide_sel, FALSE);
701    
702      appdata->menu_item_map_show_all = menu_append_new_item(
703        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_show_all), _("_Show all"),
704        GTK_STOCK_ADD, "<OSM2Go-Main>/View/ShowAll",
705        0, 0, TRUE, FALSE, FALSE
706      );
707      gtk_widget_set_sensitive(appdata->menu_item_map_show_all, FALSE);
708    
709      gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
710    
711      menu_append_new_item(
712        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_style), _("St_yle"),
713        GTK_STOCK_SELECT_COLOR, "<OSM2Go-Main>/View/Style",
714        0, 0, TRUE, FALSE, FALSE
715      );
716    
717      gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
718    
719      appdata->menu_item_map_no_icons = menu_append_new_item(
720        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_map_no_icons), _("No _icons"),
721        NULL, "<OSM2Go-Main>/View/NoIcons",
722        0, 0, TRUE, TRUE, appdata->settings->no_icons
723      );
724    
   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);  
725    
726    /* -------------------- track submenu -------------------- */    /* -------------------- map submenu -------------------- */
727    
728    appdata->track.menu_track = item = gtk_menu_item_new_with_label(_("Track"));    appdata->submenu_map = item = gtk_menu_item_new_with_mnemonic( _("_Map") );
729    gtk_menu_append(GTK_MENU_SHELL(menu), item);    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
730    submenu = gtk_menu_new();    submenu = gtk_menu_new();
731      gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
732    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
733    
734    appdata->track.menu_item_import =    appdata->menu_item_map_upload = menu_append_new_item(
735      item = gtk_menu_item_new_with_label( _("Import...") );      appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_upload), _("_Upload"),
736    gtk_menu_append(GTK_MENU_SHELL(submenu), item);      "upload.16", "<OSM2Go-Main>/Map/Upload",
737    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_track_import),      GDK_u, GDK_SHIFT_MASK|GDK_CONTROL_MASK, TRUE, FALSE, FALSE
738                     appdata);    );
739    
740      menu_append_new_item(
741        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_download), _("_Download"),
742        "download.16", "<OSM2Go-Main>/Map/Download",
743        GDK_d, GDK_SHIFT_MASK|GDK_CONTROL_MASK, TRUE, FALSE, FALSE
744      );
745    
746      gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
747    
748      if(getenv("OSM2GO_UNDO_TEST")) {
749        appdata->menu_item_map_undo = menu_append_new_item(
750                   appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_undo), _("_Undo"),
751                   GTK_STOCK_UNDO, "<OSM2Go-Main>/Map/Undo",
752                   GDK_z, GDK_CONTROL_MASK, TRUE, FALSE, FALSE
753                   );
754      } else
755        printf("set environment variable OSM2GO_UNDO_TEST to enable undo framework tests\n");
756    
757      appdata->menu_item_map_save_changes = menu_append_new_item(
758        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_save_changes), _("_Save local changes"),
759        GTK_STOCK_SAVE, "<OSM2Go-Main>/Map/SaveChanges",
760        GDK_s, GDK_SHIFT_MASK|GDK_CONTROL_MASK, TRUE, FALSE, FALSE
761      );
762    
763      appdata->menu_item_map_undo_changes = menu_append_new_item(
764        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_undo_changes), _("Undo _all"),
765        GTK_STOCK_DELETE, "<OSM2Go-Main>/Map/UndoAll",
766        0, 0, TRUE, FALSE, FALSE
767      );
768    
769      gtk_menu_shell_append(GTK_MENU_SHELL(submenu), gtk_separator_menu_item_new());
770      appdata->menu_item_map_relations = menu_append_new_item(
771        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_osm_relations), _("_Relations"),
772        NULL, "<OSM2Go-Main>/Map/Relations",
773        GDK_r, GDK_SHIFT_MASK|GDK_CONTROL_MASK, TRUE, FALSE, FALSE
774      );
775    
776    appdata->track.menu_item_export =    /* -------------------- wms submenu -------------------- */
     item = gtk_menu_item_new_with_label( _("Export...") );  
   gtk_menu_append(GTK_MENU_SHELL(submenu), item);  
   g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_track_export),  
                    appdata);  
777    
778    appdata->track.menu_item_clear =    appdata->submenu_wms = item = gtk_menu_item_new_with_mnemonic( _("_WMS") );
779      item = gtk_menu_item_new_with_label( _("Clear") );    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
780    gtk_menu_append(GTK_MENU_SHELL(submenu), item);    submenu = gtk_menu_new();
781    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_track_clear),    gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
782                     appdata);    gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
783    
784      menu_append_new_item(
785        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_wms_import), _("_Import"),
786        GTK_STOCK_INDEX, "<OSM2Go-Main>/WMS/Import",
787        0, 0, TRUE, FALSE, FALSE
788      );
789    
790      appdata->menu_item_wms_clear = menu_append_new_item(
791        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_wms_clear), _("_Clear"),
792        GTK_STOCK_CLEAR, "<OSM2Go-Main>/WMS/Clear",
793        0, 0, TRUE, FALSE, FALSE
794      );
795      gtk_widget_set_sensitive(appdata->menu_item_wms_clear, FALSE);
796    
797      appdata->menu_item_wms_adjust = menu_append_new_item(
798        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_wms_adjust), _("_Adjust"),
799        NULL, "<OSM2Go-Main>/WMS/Adjust",
800        0, 0, TRUE, FALSE, FALSE
801      );
802      gtk_widget_set_sensitive(appdata->menu_item_wms_adjust, FALSE);
803    
804    appdata->track.menu_item_gps =    /* -------------------- track submenu -------------------- */
805      item = gtk_check_menu_item_new_with_label( _("GPS") );  
806    gtk_menu_append(GTK_MENU_SHELL(submenu), item);    appdata->track.submenu_track = item =
807    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_track_gps),      gtk_menu_item_new_with_mnemonic(_("_Track"));
808                     appdata);    gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
809      submenu = gtk_menu_new();
810      gtk_menu_set_accel_group(GTK_MENU(submenu), accel_grp);
811      gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
812    
813      appdata->track.menu_item_track_import = menu_append_new_item(
814        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_import), _("_Import"),
815        NULL, "<OSM2Go-Main>/Track/Import",
816        0, 0, TRUE, FALSE, FALSE
817      );
818    
819      appdata->track.menu_item_track_export = menu_append_new_item(
820        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_export), _("_Export"),
821        NULL, "<OSM2Go-Main>/Track/Export",
822        0, 0, FALSE, FALSE, FALSE
823      );
824    
825      appdata->track.menu_item_track_clear = menu_append_new_item(
826        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_clear), _("_Clear"),
827        GTK_STOCK_CLEAR, "<OSM2Go-Main>/Track/Clear",
828        0, 0, FALSE, FALSE, FALSE
829      );
830    
831    
832      appdata->track.menu_item_track_enable_gps = menu_append_new_item(
833        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_enable_gps),_("_GPS enable"),
834        NULL, "<OSM2Go-Main>/Track/GPS",
835        GDK_g, GDK_CONTROL_MASK|GDK_SHIFT_MASK, TRUE, TRUE,
836        appdata->settings->enable_gps
837      );
838    
839      appdata->track.menu_item_track_follow_gps = menu_append_new_item(
840        appdata, submenu, GTK_SIGNAL_FUNC(cb_menu_track_follow_gps), _("GPS follow"),
841        NULL, "<OSM2Go-Main>/Track/Follow",
842        0, 0, appdata->settings->enable_gps, TRUE,
843        appdata->settings->follow_gps
844      );
845    
846    /* ------------------------------------------------------- */    /* ------------------------------------------------------- */
847    
848    gtk_menu_append(GTK_MENU_SHELL(menu), gtk_separator_menu_item_new());    gtk_menu_shell_append(GTK_MENU_SHELL(about_quit_items_menu),
849                            gtk_separator_menu_item_new());
850    
851    item = gtk_menu_item_new_with_label( _("About...") );    menu_append_new_item(
852    gtk_menu_append(GTK_MENU_SHELL(menu), item);      appdata, about_quit_items_menu, GTK_SIGNAL_FUNC(cb_menu_about), _("_About"),
853    g_signal_connect(item, "activate", GTK_SIGNAL_FUNC(cb_menu_about), appdata);      GTK_STOCK_ABOUT, "<OSM2Go-Main>/About",
854        0, 0, TRUE, FALSE, FALSE
855      );
856    
857    #ifndef USE_HILDON
858      menu_append_new_item(
859        appdata, about_quit_items_menu, GTK_SIGNAL_FUNC(cb_menu_quit), _("_Quit"),
860        GTK_STOCK_QUIT, "<OSM2Go-Main>/Quit",
861        0, 0, TRUE, FALSE, FALSE
862      );
863    #endif
864    
865    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);  
866    
867  #ifdef USE_HILDON  #ifdef USE_HILDON
868    hildon_window_set_menu(appdata->window, GTK_MENU(menu));    hildon_window_set_menu(appdata->window, GTK_MENU(menu));
869  #else  #else
870    /* attach ordinary gtk menu */    GtkWidget *menu_bar = menu;
871    GtkWidget *menu_bar = gtk_menu_bar_new();  
872    #ifndef UISPECIFIC_MAIN_MENU_IS_MENU_BAR
873      // we need to make one first
874      menu_bar = gtk_menu_bar_new();
875    
876    GtkWidget *root_menu = gtk_menu_item_new_with_label (_("Menu"));    GtkWidget *root_menu = gtk_menu_item_new_with_label (_("Menu"));
877    gtk_widget_show(root_menu);    gtk_widget_show(root_menu);
# Line 514  void menu_create(appdata_t *appdata) { Line 880  void menu_create(appdata_t *appdata) {
880    gtk_menu_item_set_submenu(GTK_MENU_ITEM (root_menu), menu);    gtk_menu_item_set_submenu(GTK_MENU_ITEM (root_menu), menu);
881    
882    gtk_widget_show(menu_bar);    gtk_widget_show(menu_bar);
883    #endif //UISPECIFIC_MAIN_MENU_IS_MENU_BAR
884    
885    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);
886    
887    #endif //USE_HILDON
888    }
889    #else // !defined(USE_HILDON) || (MAEMO_VERSION_MAJOR < 5)
890    
891    void submenu_entry(appdata_t *appdata, HildonAppMenu *menu,
892                       const char *label, const char *value,
893                       GtkSignalFunc activate_cb) {
894    
895    }
896    
897    typedef struct {
898      const char *label, *value;
899      gboolean enabled;
900      gboolean (*toggle)(appdata_t *appdata);
901      gulong offset;
902      GtkSignalFunc activate_cb;
903    } menu_entry_t;
904    
905    typedef struct {
906      const char *title;
907      const menu_entry_t *menu;
908      int len;
909    } submenu_t;
910    
911    static gboolean no_icon_get_toggle(appdata_t *appdata) {
912      if(!appdata)           return FALSE;
913      if(!appdata->settings) return FALSE;
914      return appdata->settings->no_icons;
915    }
916    
917    static gboolean enable_gps_get_toggle(appdata_t *appdata) {
918      if(!appdata)           return FALSE;
919      if(!appdata->settings) return FALSE;
920      return appdata->settings->enable_gps;
921    }
922    
923    static gboolean follow_gps_get_toggle(appdata_t *appdata) {
924      if(!appdata)           return FALSE;
925      if(!appdata->settings) return FALSE;
926      return appdata->settings->follow_gps;
927    }
928    
929    /* create a HildonAppMenu */
930    static GtkWidget *app_menu_create(appdata_t *appdata,
931                                      const menu_entry_t *menu_entries) {
932      HildonAppMenu *menu = HILDON_APP_MENU(hildon_app_menu_new());
933    
934      while(menu_entries->label) {
935        GtkWidget *button = NULL;
936    
937        if(!menu_entries->toggle) {
938          button = hildon_button_new_with_text(
939                HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH,
940                HILDON_BUTTON_ARRANGEMENT_VERTICAL,
941                _(menu_entries->label), _(menu_entries->value));
942          g_signal_connect_after(button, "clicked",
943                                 menu_entries->activate_cb, appdata);
944        } else {
945          button = hildon_check_button_new(HILDON_SIZE_AUTO);
946          gtk_button_set_label(GTK_BUTTON(button), _(menu_entries->label));
947          printf("requesting check for %s: %p\n", menu_entries->label,
948                 menu_entries->toggle);
949          hildon_check_button_set_active(HILDON_CHECK_BUTTON(button),
950                                         menu_entries->toggle(appdata));
951          g_signal_connect_after(button, "toggled",
952                                 menu_entries->activate_cb, appdata);
953        }
954    
955        /* offset to GtkWidget pointer was given -> store pointer */
956        if(menu_entries->offset)
957          *(GtkWidget**)(((void*)appdata)+menu_entries->offset) = button;
958    
959        gtk_widget_set_sensitive(button, menu_entries->enabled);
960    
961        hildon_app_menu_append(menu, GTK_BUTTON(button));
962        menu_entries++;
963      }
964    
965      gtk_widget_show_all(GTK_WIDGET(menu));
966      return GTK_WIDGET(menu);
967    }
968    
969    #ifdef MAEMO5_SUBMENU_POPUP
970    static GtkWidget *app_submenu_create(appdata_t *appdata,
971                                         const submenu_t *submenu) {
972      return app_menu_create(appdata, submenu->menu);
973    }
974    
975    static void submenu_popup(GtkWidget *menu) {
976      GtkWidget *top = hildon_window_stack_peek(hildon_window_stack_get_default());
977    
978    #if 0 // nasty workaround for race condition in hildonappmenu
979      int start, end;
980      GTimeVal tv;
981      g_get_current_time(&tv);
982      start = tv.tv_sec * 1000 + tv.tv_usec / 1000;
983      do {
984        if(gtk_events_pending())
985          while(gtk_events_pending()) {
986            putchar('.'); fflush(stdout);
987            gtk_main_iteration();
988          }
989        else
990          usleep(100);
991    
992        g_get_current_time(&tv);
993        end = tv.tv_sec * 1000 + tv.tv_usec / 1000;
994      } while(end-start < 500);
995  #endif  #endif
996    
997      hildon_app_menu_popup(HILDON_APP_MENU(menu), GTK_WINDOW(top));
998    }
999    
1000    static void submenu_cleanup(GtkWidget *menu) {
1001      g_object_unref(menu);
1002  }  }
1003    #else
1004    #define COLUMNS  2
1005    
1006    void on_submenu_entry_clicked(GtkButton *button, GtkWidget *menu) {
1007    
1008      /* force closing of submenu dialog */
1009      gtk_dialog_response(GTK_DIALOG(menu), GTK_RESPONSE_NONE);
1010      gtk_widget_hide(menu);
1011    
1012      /* let gtk clean up */
1013      while(gtk_events_pending())
1014        gtk_main_iteration();
1015    }
1016    
1017    /* use standard dialog boxes for fremantle submenues */
1018    static GtkWidget *app_submenu_create(appdata_t *appdata,
1019                                         const submenu_t *submenu) {
1020    
1021      /* create a oridinary dialog box */
1022      GtkWidget *dialog = misc_dialog_new(MISC_DIALOG_SMALL, _(submenu->title),
1023                                          GTK_WINDOW(appdata->window), NULL);
1024    
1025      gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
1026    
1027      GtkWidget *table = gtk_table_new(submenu->len/COLUMNS, COLUMNS, TRUE);
1028      int x = 0, y = 0;
1029    
1030      const menu_entry_t *menu_entries = submenu->menu;
1031      while(menu_entries->label) {
1032        GtkWidget *button = NULL;
1033    
1034        if(!menu_entries->toggle) {
1035          button = hildon_button_new_with_text(
1036                HILDON_SIZE_FINGER_HEIGHT | HILDON_SIZE_AUTO_WIDTH,
1037                HILDON_BUTTON_ARRANGEMENT_VERTICAL,
1038                _(menu_entries->label), _(menu_entries->value));
1039    
1040          g_signal_connect(button, "clicked",
1041                           G_CALLBACK(on_submenu_entry_clicked), dialog);
1042    
1043          g_signal_connect(button, "clicked",
1044                           menu_entries->activate_cb, appdata);
1045        } else {
1046          button = hildon_check_button_new(HILDON_SIZE_AUTO);
1047          gtk_button_set_label(GTK_BUTTON(button), _(menu_entries->label));
1048          printf("requesting check for %s: %p\n", menu_entries->label,
1049                 menu_entries->toggle);
1050          hildon_check_button_set_active(HILDON_CHECK_BUTTON(button),
1051                                         menu_entries->toggle(appdata));
1052    
1053          g_signal_connect(button, "clicked",
1054                           G_CALLBACK(on_submenu_entry_clicked), dialog);
1055    
1056          g_signal_connect(button, "toggled",
1057                           menu_entries->activate_cb, appdata);
1058        }
1059    
1060        /* offset to GtkWidget pointer was given -> store pointer */
1061        if(menu_entries->offset)
1062          *(GtkWidget**)(((void*)appdata)+menu_entries->offset) = button;
1063    
1064        gtk_widget_set_sensitive(button, menu_entries->enabled);
1065    
1066        gtk_table_attach_defaults(GTK_TABLE(table),  button, x, x+1, y, y+1);
1067    
1068        x++;
1069        if(x == COLUMNS) { x = 0; y++; }
1070    
1071        menu_entries++;
1072      }
1073    
1074    
1075      gtk_box_pack_start_defaults(GTK_BOX(GTK_DIALOG(dialog)->vbox), table);
1076    
1077      return dialog;
1078    }
1079    
1080    /* popup the dialog shaped submenu */
1081    static void submenu_popup(GtkWidget *menu) {
1082      gtk_widget_show_all(menu);
1083      gtk_dialog_run(GTK_DIALOG(menu));
1084      gtk_widget_hide(menu);
1085    }
1086    
1087    static void submenu_cleanup(GtkWidget *menu) {
1088      gtk_widget_destroy(menu);
1089    }
1090    #endif
1091    
1092    /* the view submenu */
1093    void on_submenu_view_clicked(GtkButton *button, appdata_t *appdata) {
1094      submenu_popup(appdata->app_menu_view);
1095    }
1096    
1097    void on_submenu_map_clicked(GtkButton *button, appdata_t *appdata) {
1098      submenu_popup(appdata->app_menu_map);
1099    }
1100    
1101    void on_submenu_wms_clicked(GtkButton *button, appdata_t *appdata) {
1102      submenu_popup(appdata->app_menu_wms);
1103    }
1104    
1105    void on_submenu_track_clicked(GtkButton *button, appdata_t *appdata) {
1106      submenu_popup(appdata->app_menu_track);
1107    }
1108    
1109    #define APP_OFFSET(a)  offsetof(appdata_t, a)
1110    #define SIMPLE_ENTRY(a,b)     { a, NULL, TRUE,   NULL, 0, G_CALLBACK(b) }
1111    #define ENABLED_ENTRY(a,b,c)  { a, NULL, TRUE,  NULL, APP_OFFSET(c), G_CALLBACK(b) }
1112    #define DISABLED_ENTRY(a,b,c) { a, NULL, FALSE,  NULL, APP_OFFSET(c), G_CALLBACK(b) }
1113    #define TOGGLE_ENTRY(a,b,c)   { a, NULL, TRUE, c, 0, G_CALLBACK(b) }
1114    #define DISABLED_TOGGLE_ENTRY(a,b,c,d)  \
1115                                  { a, NULL, FALSE, c, APP_OFFSET(d), G_CALLBACK(b) }
1116    #define ENABLED_TOGGLE_ENTRY(a,b,c,d) \
1117                                  { a, NULL, TRUE, c, APP_OFFSET(d), G_CALLBACK(b) }
1118    #define LAST_ENTRY            { NULL, NULL, FALSE, NULL, 0, NULL }
1119    
1120    /* -- the view submenu -- */
1121    static const menu_entry_t submenu_view_entries[] = {
1122    #ifndef ZOOM_BUTTONS
1123      SIMPLE_ENTRY("Zoom in",         cb_menu_zoomin),
1124      SIMPLE_ENTRY("Zoom out",        cb_menu_zoomout),
1125    #endif
1126      /* --- */
1127      SIMPLE_ENTRY("Style",           cb_menu_style),
1128      /* --- */
1129      SIMPLE_ENTRY("Normal details",  cb_menu_view_detail_normal),
1130      SIMPLE_ENTRY("More details",    cb_menu_view_detail_inc),
1131      SIMPLE_ENTRY("Less details",    cb_menu_view_detail_dec),
1132      /* --- */
1133      DISABLED_ENTRY("Hide selected", cb_menu_map_hide_sel, menu_item_map_hide_sel),
1134      DISABLED_ENTRY("Show all",      cb_menu_map_show_all, menu_item_map_show_all),
1135      /* --- */
1136      TOGGLE_ENTRY("No icons",        cb_menu_map_no_icons, no_icon_get_toggle),
1137    
1138      LAST_ENTRY
1139    };
1140    
1141    static const submenu_t submenu_view = {
1142      "View", submenu_view_entries, sizeof(submenu_view_entries)/sizeof(menu_entry_t)
1143    };
1144    
1145    /* -- the map submenu -- */
1146    static const menu_entry_t submenu_map_entries[] = {
1147      ENABLED_ENTRY("Upload",                cb_menu_upload, menu_item_map_upload),
1148      SIMPLE_ENTRY("Download",               cb_menu_download),
1149      ENABLED_ENTRY("Save changes",          cb_menu_save_changes,
1150                    menu_item_map_save_changes),
1151      ENABLED_ENTRY("Undo all",              cb_menu_undo_changes,
1152                    menu_item_map_undo_changes),
1153      ENABLED_ENTRY("Relations",             cb_menu_osm_relations,
1154                    menu_item_map_relations),
1155    
1156      LAST_ENTRY
1157    };
1158    
1159    static const submenu_t submenu_map = {
1160      "Map", submenu_map_entries, sizeof(submenu_map_entries)/sizeof(menu_entry_t)
1161    };
1162    
1163    /* -- the wms submenu -- */
1164    static const menu_entry_t submenu_wms_entries[] = {
1165      SIMPLE_ENTRY("Import",   cb_menu_wms_import),
1166      DISABLED_ENTRY("Clear",  cb_menu_wms_clear, menu_item_wms_clear),
1167      DISABLED_ENTRY("Adjust", cb_menu_wms_adjust, menu_item_wms_adjust),
1168    
1169      LAST_ENTRY
1170    };
1171    
1172    static const submenu_t submenu_wms = {
1173      "WMS", submenu_wms_entries, sizeof(submenu_wms_entries)/sizeof(menu_entry_t)
1174    };
1175    
1176    /* -- the track submenu -- */
1177    static const menu_entry_t submenu_track_entries[] = {
1178      ENABLED_ENTRY("Import",  cb_menu_track_import, track.menu_item_track_import),
1179      DISABLED_ENTRY("Export", cb_menu_track_export, track.menu_item_track_export),
1180      DISABLED_ENTRY("Clear",  cb_menu_track_clear, track.menu_item_track_clear),
1181      ENABLED_TOGGLE_ENTRY("GPS enable", cb_menu_track_enable_gps,
1182                    enable_gps_get_toggle, track.menu_item_track_enable_gps),
1183      DISABLED_TOGGLE_ENTRY("GPS follow", cb_menu_track_follow_gps,
1184                    follow_gps_get_toggle, track.menu_item_track_follow_gps),
1185    
1186      LAST_ENTRY
1187    };
1188    
1189    static const submenu_t submenu_track = {
1190      "Track", submenu_track_entries, sizeof(submenu_track_entries)/sizeof(menu_entry_t)
1191    };
1192    
1193    
1194    /* -- the applications main menu -- */
1195    static const menu_entry_t main_menu[] = {
1196      SIMPLE_ENTRY("About",   cb_menu_about),
1197      SIMPLE_ENTRY("Project", cb_menu_project_open),
1198      ENABLED_ENTRY("View",   on_submenu_view_clicked,  submenu_view),
1199      ENABLED_ENTRY("Map",    on_submenu_map_clicked,   submenu_map),
1200      ENABLED_ENTRY("WMS",    on_submenu_wms_clicked,   submenu_wms),
1201      ENABLED_ENTRY("Track",  on_submenu_track_clicked, track.submenu_track),
1202    
1203      LAST_ENTRY
1204    };
1205    
1206    void menu_create(appdata_t *appdata) {
1207      HildonAppMenu *menu = HILDON_APP_MENU(hildon_app_menu_new());
1208    
1209      /* build menu/submenus */
1210      menu = HILDON_APP_MENU(app_menu_create(appdata, main_menu));
1211      appdata->app_menu_wms   = app_submenu_create(appdata, &submenu_wms);
1212      g_object_ref(appdata->app_menu_wms);
1213      appdata->app_menu_map   = app_submenu_create(appdata, &submenu_map);
1214      g_object_ref(appdata->app_menu_map);
1215      appdata->app_menu_view  = app_submenu_create(appdata, &submenu_view);
1216      g_object_ref(appdata->app_menu_view);
1217      appdata->app_menu_track = app_submenu_create(appdata, &submenu_track);
1218      g_object_ref(appdata->app_menu_track);
1219    
1220      /* enable/disable some entries according to settings */
1221      if(appdata && appdata->settings)
1222        gtk_widget_set_sensitive(appdata->track.menu_item_track_follow_gps,
1223                                 appdata->settings->enable_gps);
1224    
1225      hildon_window_set_app_menu(HILDON_WINDOW(appdata->window), menu);
1226    }
1227    
1228    void menu_cleanup(appdata_t *appdata) {
1229      submenu_cleanup(appdata->app_menu_view);
1230      submenu_cleanup(appdata->app_menu_map);
1231      submenu_cleanup(appdata->app_menu_wms);
1232      submenu_cleanup(appdata->app_menu_track);
1233    }
1234    #endif
1235    
1236  /********************* end of menu **********************/  /********************* end of menu **********************/
1237    
1238    #ifdef UISPECIFIC_MENU_HAS_ACCELS
1239    #define ACCELS_FILE "accels"
1240    
1241    static void menu_accels_load(appdata_t *appdata) {
1242      char *accels_file = g_strdup_printf("%s/" ACCELS_FILE,
1243                                          appdata->settings->base_path);
1244      gtk_accel_map_load(accels_file);
1245      g_free(accels_file);
1246    }
1247    
1248    static void menu_accels_save(appdata_t *appdata) {
1249      char *accels_file = g_strdup_printf("%s" ACCELS_FILE,
1250                                          appdata->settings->base_path);
1251      gtk_accel_map_save(accels_file);
1252      g_free(accels_file);
1253    }
1254    
1255    #endif
1256    
1257    
1258  void cleanup(appdata_t *appdata) {  void cleanup(appdata_t *appdata) {
1259    #ifdef UISPECIFIC_MENU_HAS_ACCELS
1260      menu_accels_save(appdata);
1261    #endif
1262    
1263    settings_save(appdata->settings);    settings_save(appdata->settings);
1264    
1265  #ifdef USE_HILDON  #ifdef USE_HILDON
# Line 565  void cleanup(appdata_t *appdata) { Line 1303  void cleanup(appdata_t *appdata) {
1303    
1304    project_free(appdata->project);    project_free(appdata->project);
1305    
1306      if(appdata->menu_item_map_undo)
1307        undo_free(appdata->osm, appdata->undo.state);
1308    
1309      menu_cleanup(appdata);
1310    
1311    puts("everything is gone");    puts("everything is gone");
1312  }  }
1313    
# Line 580  gboolean on_window_key_press(GtkWidget * Line 1323  gboolean on_window_key_press(GtkWidget *
1323    appdata_t *appdata = (appdata_t*)data;    appdata_t *appdata = (appdata_t*)data;
1324    int handled = FALSE;    int handled = FALSE;
1325    
1326    //  printf("key event %d\n", event->keyval);    //  printf("key event with keyval %x\n", event->keyval);
1327    
1328    // the map handles some keys on its own ...    // the map handles some keys on its own ...
1329    switch(event->keyval) {    switch(event->keyval) {
 #ifdef USE_HILDON  
1330    
1331  #if 0  #if !defined(USE_HILDON) || (MAEMO_VERSION_MAJOR < 5)
1332    case HILDON_HARDKEY_SELECT:  #ifdef USE_HILDON
1333      handled = TRUE;      /* this is in fact a mapping to GDK_F6 */
     break;  
 #endif  
   
1334    case HILDON_HARDKEY_FULLSCREEN:    case HILDON_HARDKEY_FULLSCREEN:
1335      {  #else
1336        gboolean fullscreen = !gtk_check_menu_item_get_active(    case GDK_F11:
1337                 GTK_CHECK_MENU_ITEM(appdata->fullscreen_menu_item));  #endif
1338        if(!gtk_check_menu_item_get_active(
1339                 GTK_CHECK_MENU_ITEM(appdata->menu_item_view_fullscreen))) {
1340          gtk_window_fullscreen(GTK_WINDOW(appdata->window));
1341        gtk_check_menu_item_set_active(        gtk_check_menu_item_set_active(
1342                 GTK_CHECK_MENU_ITEM(appdata->fullscreen_menu_item), fullscreen);               GTK_CHECK_MENU_ITEM(appdata->menu_item_view_fullscreen), TRUE);
1343          } else {
       if(fullscreen)  
         gtk_window_fullscreen(GTK_WINDOW(appdata->window));  
       else  
1344          gtk_window_unfullscreen(GTK_WINDOW(appdata->window));          gtk_window_unfullscreen(GTK_WINDOW(appdata->window));
1345            gtk_check_menu_item_set_active(
1346        handled = TRUE;               GTK_CHECK_MENU_ITEM(appdata->menu_item_view_fullscreen), FALSE);
1347      }        }
1348    
1349        handled = TRUE;
1350      break;      break;
1351  #endif  #endif
1352    }    }
# Line 635  int main(int argc, char *argv[]) { Line 1376  int main(int argc, char *argv[]) {
1376    
1377    g_thread_init(NULL);    g_thread_init(NULL);
1378    
   gps_init(&appdata);  
   
1379    gtk_init (&argc, &argv);    gtk_init (&argc, &argv);
1380    
1381      gps_init(&appdata);
1382    
1383  #ifdef USE_HILDON  #ifdef USE_HILDON
1384    printf("Installing osso context for \"org.harbaum." PACKAGE "\"\n");    printf("Installing osso context for \"org.harbaum." PACKAGE "\"\n");
1385    appdata.osso_context = osso_initialize("org.harbaum."PACKAGE,    appdata.osso_context = osso_initialize("org.harbaum."PACKAGE,
# Line 655  int main(int argc, char *argv[]) { Line 1396  int main(int argc, char *argv[]) {
1396    g_set_application_name("OSM2Go");    g_set_application_name("OSM2Go");
1397    
1398    /* Create HildonWindow and set it to HildonProgram */    /* Create HildonWindow and set it to HildonProgram */
1399    #if MAEMO_VERSION_MAJOR < 5
1400    appdata.window = HILDON_WINDOW(hildon_window_new());    appdata.window = HILDON_WINDOW(hildon_window_new());
1401    #else
1402      appdata.window = HILDON_WINDOW(hildon_stackable_window_new());
1403    #endif
1404    hildon_program_add_window(appdata.program, appdata.window);    hildon_program_add_window(appdata.program, appdata.window);
1405    
1406    #if MAEMO_VERSION_MAJOR == 6
1407      unsigned long val = False;
1408      XChangeProperty(GDK_DISPLAY(),
1409                      GDK_WINDOW_XID(GTK_WIDGET(appdata.window)->window),
1410                      XInternAtom(GDK_DISPLAY(),
1411                                  "_HILDON_ZOOM_KEY_ATOM",
1412                                  False), XA_INTEGER, 32,
1413                      PropModeReplace, (unsigned char *) &val, 1);
1414    #endif
1415    
1416  #else  #else
1417    /* Create a Window. */    /* Create a Window. */
1418    appdata.window = gtk_window_new(GTK_WINDOW_TOPLEVEL);    appdata.window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
# Line 674  int main(int argc, char *argv[]) { Line 1430  int main(int argc, char *argv[]) {
1430    g_signal_connect(G_OBJECT(appdata.window), "key_press_event",    g_signal_connect(G_OBJECT(appdata.window), "key_press_event",
1431                     G_CALLBACK(on_window_key_press), &appdata);                     G_CALLBACK(on_window_key_press), &appdata);
1432    
   appdata.vbox = gtk_vbox_new(FALSE,0);  
   menu_create(&appdata);  
   
1433    /* user specific init */    /* user specific init */
1434    appdata.settings = settings_load();    appdata.settings = settings_load();
1435    
1436      appdata.vbox = gtk_vbox_new(FALSE,0);
1437      menu_create(&appdata);
1438    #ifdef UISPECIFIC_MENU_HAS_ACCELS
1439      menu_accels_load(&appdata);
1440    #endif
1441    
1442    /* ----------------------- setup main window ---------------- */    /* ----------------------- setup main window ---------------- */
1443    
1444    GtkWidget *hbox = gtk_hbox_new(FALSE,0);    GtkWidget *hbox = gtk_hbox_new(FALSE,0);
# Line 688  int main(int argc, char *argv[]) { Line 1447  int main(int argc, char *argv[]) {
1447  #ifdef PORTRAIT  #ifdef PORTRAIT
1448    gtk_box_pack_start(GTK_BOX(vbox), iconbar_new(&appdata), FALSE, FALSE, 0);    gtk_box_pack_start(GTK_BOX(vbox), iconbar_new(&appdata), FALSE, FALSE, 0);
1449  #endif  #endif
1450    gtk_box_pack_start(GTK_BOX(vbox), map_new(&appdata), TRUE, TRUE, 0);  
1451      /* generate main map view */
1452      GtkWidget *map = map_new(&appdata);
1453      if(!map) {
1454        cleanup(&appdata);
1455        return -1;
1456      }
1457    
1458      gtk_box_pack_start(GTK_BOX(vbox), map, TRUE, TRUE, 0);
1459    
1460    #ifdef ZOOM_BUTTONS
1461      GtkWidget *zhbox = gtk_hbox_new(FALSE, 0);
1462    
1463      gtk_box_pack_start_defaults(GTK_BOX(zhbox), statusbar_new(&appdata));
1464    
1465      /* ---- add zoom out button right of statusbar ---- */
1466      appdata.btn_zoom_out = gtk_button_new();
1467      gtk_button_set_image(GTK_BUTTON(appdata.btn_zoom_out),
1468            gtk_image_new_from_stock(GTK_STOCK_ZOOM_OUT, GTK_ICON_SIZE_MENU));
1469      g_signal_connect(appdata.btn_zoom_out, "clicked",
1470                       G_CALLBACK(cb_menu_zoomout), &appdata);
1471      gtk_box_pack_start(GTK_BOX(zhbox), appdata.btn_zoom_out, FALSE, FALSE, 0);
1472    
1473      /* ---- add zoom in button right of statusbar ---- */
1474      appdata.btn_zoom_in = gtk_button_new();
1475      gtk_button_set_image(GTK_BUTTON(appdata.btn_zoom_in),
1476            gtk_image_new_from_stock(GTK_STOCK_ZOOM_IN, GTK_ICON_SIZE_MENU));
1477      g_signal_connect(appdata.btn_zoom_in, "clicked",
1478                       G_CALLBACK(cb_menu_zoomin), &appdata);
1479      gtk_box_pack_start(GTK_BOX(zhbox), appdata.btn_zoom_in, FALSE, FALSE, 0);
1480    
1481    
1482      gtk_box_pack_start(GTK_BOX(vbox), zhbox, FALSE, FALSE, 0);
1483    #else
1484    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);
1485    #endif
1486    
1487  #ifndef PORTRAIT  #ifndef PORTRAIT
1488    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);
1489  #endif  #endif
   gtk_box_pack_start(GTK_BOX(hbox), gtk_vseparator_new(), FALSE, FALSE, 0);  
1490    gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);    gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
1491    
1492    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 707  int main(int argc, char *argv[]) { Line 1499  int main(int argc, char *argv[]) {
1499    
1500    /* let gtk do its thing before loading the data, */    /* let gtk do its thing before loading the data, */
1501    /* so the user sees something */    /* so the user sees something */
1502    while(gtk_events_pending()) {    while(gtk_events_pending())
     putchar('.');  
1503      gtk_main_iteration();      gtk_main_iteration();
   }  
1504    
1505    /* load project if one is specified in the settings */    /* load project if one is specified in the settings */
1506    if(appdata.settings->project)    if(appdata.settings->project)
1507      project_load(&appdata, appdata.settings->project);      project_load(&appdata, appdata.settings->project);
1508    
1509    main_project_loaded(&appdata);    main_ui_enable(&appdata);
1510    
1511    /* ------------ jump into main loop ---------------- */    /* start GPS if enabled by config */
1512      if(appdata.settings && appdata.settings->enable_gps)
1513        track_enable_gps(&appdata, TRUE);
1514    
1515      /* again let the ui do its thing */
1516      while(gtk_events_pending())
1517        gtk_main_iteration();
1518    
1519    #if 0  // test overlay
1520      {
1521        GtkWidget *overlay = gtk_window_new(GTK_WINDOW_POPUP);
1522        gtk_window_set_default_size(GTK_WINDOW(overlay), 40, 20);
1523        gtk_window_set_transient_for(GTK_WINDOW(overlay), GTK_WINDOW(appdata.window));
1524        gtk_window_set_keep_above(GTK_WINDOW(overlay), TRUE);
1525        gtk_window_set_destroy_with_parent(GTK_WINDOW(overlay), TRUE);
1526        gtk_window_set_position(GTK_WINDOW(overlay), GTK_WIN_POS_CENTER_ON_PARENT);
1527    
1528        gtk_window_set_gravity(GTK_WINDOW(overlay), GDK_GRAVITY_NORTH_EAST);
1529    
1530        printf("x = %d\n", gdk_screen_width() - overlay->allocation.width);
1531        gtk_window_move(GTK_WINDOW(overlay),
1532                        gdk_screen_width() - overlay->allocation.width, 60);
1533    
1534        gtk_window_set_decorated(GTK_WINDOW(overlay), TRUE);
1535    
1536        /* add some zoom buttons for testing */
1537        GtkWidget *hbox = gtk_hbox_new(TRUE, 0);
1538        gtk_box_pack_start_defaults(GTK_BOX(hbox), gtk_button_new_with_label("+"));
1539        gtk_box_pack_start_defaults(GTK_BOX(hbox), gtk_button_new_with_label("-"));
1540        gtk_container_add(GTK_CONTAINER(overlay), hbox);
1541    
1542        gtk_widget_show_all(overlay);
1543      }
1544    #endif
1545    
1546      /* start to interact with the user now that the gui is running */
1547      if(appdata.settings->first_run_demo) {
1548        messagef(GTK_WIDGET(appdata.window), _("Welcome to OSM2Go"),
1549                 _("This is the first time you run OSM2Go. "
1550                   "A demo project has been loaded to get you "
1551                   "started. You can play around with this demo as much "
1552                   "as you like. However, you cannot upload or download "
1553                   "the demo project.\n\n"
1554                   "In order to start working on real data you'll have "
1555                   "to setup a new project and enter your OSM user name "
1556                   "and password. You'll then be able to download the "
1557                   "latest data from OSM and upload your changes into "
1558                   "the OSM main database."
1559                   ));
1560      }
1561    
1562      /* ------------ jump into main loop ---------------- */
1563    gtk_main();    gtk_main();
1564    
1565      puts("gtk_main() left");
1566    
1567    track_save(appdata.project, appdata.track.track);    track_save(appdata.project, appdata.track.track);
1568      track_clear(&appdata, appdata.track.track);
1569      appdata.track.track = NULL;
1570    
1571    /* save a diff if there are dirty entries */    /* save a diff if there are dirty entries */
1572    diff_save(appdata.project, appdata.osm);    diff_save(appdata.project, appdata.osm);
# Line 731  int main(int argc, char *argv[]) { Line 1575  int main(int argc, char *argv[]) {
1575    
1576    return 0;    return 0;
1577  }  }
1578    
1579    // vim:et:ts=8:sw=2:sts=2:ai
Legend:
Removed from v.2  
changed lines
  Added in v.242