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