trunk/src/map-tool.c

/*
 * Copyright (C) 2008 Till Harbaum <till@harbaum.org>.
 *
 * This file is part of GPXView.
 *
 * GPXView is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * GPXView is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with GPXView.  If not, see <http://www.gnu.org/licenses/>.
 */

#include "gpxview.h"
#include <math.h>    // for isnan

#ifdef ENABLE_OSM_GPS_MAP
#include "osm-gps-map.h"
#endif

/* equatorial radius in meters */
#define EQ_RADIUS     (6378137.0)

#define RAD2DEG(a)  (((a)*180.0)/M_PI)
#define DEG2RAD(a)  (((a)*M_PI)/180.0)

typedef struct {
  appdata_t *appdata;
  GtkWidget *widget;
  GtkWidget *zoomin, *zoomout, *gps;
  gint handler_id;
  cache_t *press_on;
#if MAEMO_VERSION_MAJOR == 5
  GtkWidget *old_view;
#endif
} map_context_t;

#define PROXY_KEY  "/system/http_proxy/"

static const char *get_proxy_uri(appdata_t *appdata) {
  static char proxy_buffer[64] = "";
  
  /* use environment settings if preset */
  const char *proxy = g_getenv("http_proxy");
  if(proxy) {
    printf("http_proxy: %s\n", proxy);
    return proxy;
  }

  /* ------------- get proxy settings -------------------- */
  if(gconf_client_get_bool(appdata->gconf_client, 
                           PROXY_KEY "use_http_proxy", NULL)) {

    /* we can savely ignore things like "ignore_hosts" since we */
    /* are pretty sure not inside the net of one of our map renderers */
    /* (unless the user works at google :-) */
      
    /* get basic settings */
    char *host = 
      gconf_client_get_string(appdata->gconf_client, PROXY_KEY "host", NULL);
    if(host) {
      int port =
        gconf_client_get_int(appdata->gconf_client, PROXY_KEY "port", NULL);

      snprintf(proxy_buffer, sizeof(proxy_buffer),
               "http://%s:%u", host, port);

      g_free(host);
    }
    return proxy_buffer;
  }

  return NULL;
}

static void map_zoom(map_context_t *context, int step) {
  int zoom;
  OsmGpsMap *map = OSM_GPS_MAP(context->widget);
  g_object_get(map, "zoom", &zoom, NULL);
  zoom = osm_gps_map_set_zoom(map, zoom+step);

  /* enable/disable zoom buttons as required */
  gtk_widget_set_sensitive(context->zoomin, zoom<17);
  gtk_widget_set_sensitive(context->zoomout, zoom>1);
}

static gboolean
cb_map_zoomin(GtkButton *button, map_context_t *context) {
  map_zoom(context, +1);
  return FALSE;
}

static gboolean
cb_map_zoomout(GtkButton *button, map_context_t *context) {
  map_zoom(context, -1);
  return FALSE;
}

static gboolean
cb_map_gps(GtkButton *button, map_context_t *context) {
  pos_t *refpos = get_pos(context->appdata);
  if(refpos && !isnan(refpos->lat) && !isnan(refpos->lon)) {
    osm_gps_map_set_mapcenter(OSM_GPS_MAP(context->widget),
                              refpos->lat, refpos->lon, 14);     
  } else {
    /* no coordinates given: display the entire world */
    osm_gps_map_set_mapcenter(OSM_GPS_MAP(context->widget), 
                              0.0, 0.0, 1);
  }

  return FALSE;
}

static GtkWidget 
*map_add_button(const gchar *icon, GCallback cb, gpointer data, 
                char *tooltip) {
  GtkWidget *button = gtk_button_new();
  gtk_button_set_image(GTK_BUTTON(button), 
                       gtk_image_new_from_stock(icon, GTK_ICON_SIZE_MENU));
  g_signal_connect(button, "clicked", cb, data);
#ifndef USE_MAEMO
  gtk_widget_set_tooltip_text(button, tooltip);
#endif
  return button;
}

static gboolean map_gps_update(gpointer data) {
  map_context_t *context = (map_context_t*)data;

  pos_t *refpos = get_pos(context->appdata);
  gboolean ok = (refpos!= NULL) && !isnan(refpos->lat) && !isnan(refpos->lon);

  /* get reference position and go there */
  gtk_widget_set_sensitive(context->gps, ok);

  return TRUE;
}

static gboolean on_map_configure(GtkWidget *widget,
                                 GdkEventConfigure *event,
                                 map_context_t *context) {

  cb_map_gps(NULL, context);

  return FALSE;
}

static void map_draw_cachelist(GtkWidget *map, cache_t *cache) {
  while(cache) {
    GdkPixbuf *icon = icon_get(ICON_CACHE_TYPE, cache->type);
    
    osm_gps_map_add_image(OSM_GPS_MAP(map), 
                          cache->pos.lat, cache->pos.lon, icon);

    cache = cache->next;
  }
}

/* draw a nice popup */
typedef struct {
  appdata_t *appdata;
  GtkWidget *window;
  GMainLoop *loop;
} popup_context_t;


#ifndef USE_HILDON
#define POPUP_WIDTH  300
#define POPUP_HEIGHT 100
#else
#define POPUP_WIDTH  600
#define POPUP_HEIGHT 200
#endif

static gboolean
pointer_in_window(GtkWidget *widget, gint x_root, gint y_root) {
  if(GTK_WIDGET_MAPPED(gtk_widget_get_toplevel(widget))) {
    gint window_x, window_y;
    
    gdk_window_get_position(gtk_widget_get_toplevel(widget)->window, 
                            &window_x, &window_y);
    
    if(x_root >= window_x && x_root < window_x + widget->allocation.width &&
        y_root >= window_y && y_root < window_y + widget->allocation.height)
      return TRUE;
  }
  
  return FALSE;
}

static gboolean
on_button_press_event(GtkWidget *widget, 
                          GdkEventButton *event, popup_context_t *context) {
  gboolean in = pointer_in_window(widget, event->x_root, event->y_root);

  printf("overlay button press(in = %d)\n", in);
  return !in;
}

static gboolean
on_button_release_event(GtkWidget *widget, 
                          GdkEventButton *event, popup_context_t *context) {
  gboolean in = pointer_in_window(widget, event->x_root, event->y_root);

  printf("overlay button release(in = %d)\n", in);

  if(!in) {
    printf("destroying popup\n");
    gtk_widget_destroy(gtk_widget_get_toplevel(widget));
  }

  return !in;
}

static void
shutdown_loop(popup_context_t *context) {
  if(g_main_loop_is_running(context->loop))
    g_main_loop_quit(context->loop);
}

static gint
run_delete_handler(GtkWindow *window, GdkEventAny *event,
                   popup_context_t *context) {
  shutdown_loop(context);
  return TRUE; /* Do not destroy */
}

static void
run_destroy_handler(GtkWindow *window, popup_context_t *context) {
  /* shutdown_loop will be called by run_unmap_handler */
  printf("popup destroyed\n");
}

static void
run_unmap_handler(GtkWindow *window, popup_context_t *context) {
  shutdown_loop(context);
}

void cache_popup(map_context_t *mcontext, cache_t *cache) {
  popup_context_t pcontext;
  pcontext.appdata = mcontext->appdata;

  pcontext.window = gtk_window_new(GTK_WINDOW_POPUP);
  gtk_widget_realize(pcontext.window);
  gtk_window_set_default_size(GTK_WINDOW(pcontext.window), 
                              POPUP_WIDTH, POPUP_HEIGHT); 
  gtk_window_resize(GTK_WINDOW(pcontext.window), 
                    POPUP_WIDTH, POPUP_HEIGHT); 
  //  gtk_window_set_resizable(GTK_WINDOW(pcontext.window), FALSE);
  gtk_window_set_transient_for(GTK_WINDOW(pcontext.window), 
                               GTK_WINDOW(mcontext->appdata->window));
  gtk_window_set_keep_above(GTK_WINDOW(pcontext.window), TRUE);    
  gtk_window_set_destroy_with_parent(GTK_WINDOW(pcontext.window), TRUE);
  gtk_window_set_gravity(GTK_WINDOW(pcontext.window), GDK_GRAVITY_STATIC);
  gtk_window_set_modal(GTK_WINDOW(pcontext.window), TRUE);

  /* connect events */
  g_signal_connect(G_OBJECT(pcontext.window), "button-press-event",
                   G_CALLBACK(on_button_press_event), &pcontext);
  g_signal_connect(G_OBJECT(pcontext.window), "button-release-event",
                   G_CALLBACK(on_button_release_event), &pcontext);
  g_signal_connect(G_OBJECT(pcontext.window), "delete-event",
                   G_CALLBACK(run_delete_handler), &pcontext);
  g_signal_connect(G_OBJECT(pcontext.window), "destroy",
                   G_CALLBACK(run_destroy_handler), &pcontext);
  g_signal_connect(G_OBJECT(pcontext.window), "unmap",
                   G_CALLBACK(run_unmap_handler), &pcontext);
  
  gdk_pointer_grab(pcontext.window->window, TRUE,
     GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_BUTTON_MOTION_MASK,
                   NULL, NULL, GDK_CURRENT_TIME);
  gtk_grab_add(pcontext.window);

  /* check whether cache is in upper or lower half of window */
  gint x, y;
  osm_gps_map_geographic_to_screen(OSM_GPS_MAP(mcontext->widget),
                                   cache->pos.lat, cache->pos.lon,
                                   &x, &y);
  
  printf("screen pos %d/%d\n", x, y);

  gdk_window_get_origin(mcontext->widget->window, &x, &y);
  printf("window = %d/%d %d/%d\n", x, y, 
         mcontext->widget->allocation.x,
         mcontext->widget->allocation.y);

  //  gtk_window_move(GTK_WINDOW(pcontext.window),
  //              x + button->allocation.x, 
  //              y + button->allocation.y - HEIGHT);


  gtk_window_move(GTK_WINDOW(pcontext.window),
                  100, 
                  100);

  /* a frame with a vscale inside */
  GtkWidget *frame = gtk_frame_new(NULL);
  gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT);

  gtk_container_add(GTK_CONTAINER(frame), gtk_label_new(cache->name));
  gtk_container_add(GTK_CONTAINER(pcontext.window), frame);
  
  gtk_widget_show_all(pcontext.window);

  /* handle this popup until it's gone */
  
  pcontext.loop = g_main_loop_new(NULL, FALSE);

  GDK_THREADS_LEAVE();  
  g_main_loop_run(pcontext.loop);
  GDK_THREADS_ENTER();  

  g_main_loop_unref(pcontext.loop);

  printf("cache popup removed\n");
}

static void
map_cachelist_nearest(cache_t *cache, pos_t *pos, 
                      cache_t **result, float *distance) {
  while(cache) {
    float dist = 
      pow(cache->pos.lat - pos->lat, 2) + 
      pow(cache->pos.lon - pos->lon, 2);

    if(!(dist > *distance)) {
      *result = cache;
      *distance = dist;
    }

    cache = cache->next;
  }
}

static cache_t *map_closest(map_context_t *context, pos_t *pos) {
  cache_t *result = NULL;
  float distance = NAN;
  
#ifdef USE_MAEMO
  if(!context->appdata->cur_gpx) {
#endif
    /* search all geocaches */
    gpx_t *gpx = context->appdata->gpx;
    while(gpx) {
      map_cachelist_nearest(gpx->cache, pos, &result, &distance);
      gpx = gpx->next;
    }
#ifdef USE_MAEMO
  } else {
    map_cachelist_nearest(context->appdata->cur_gpx->cache, 
                          pos, &result, &distance);
  }
#endif

  return result;
}

/* translate between osm-gps-map positions and gpxview ones */
pos_t coord2pos(coord_t coo) {
  pos_t pos;
  pos.lat = RAD2DEG(coo.rlat);
  pos.lon = RAD2DEG(coo.rlon);
  return pos;
}

static int dist2pixel(map_context_t *context, float km, float lat) {
  int zoom;
  g_object_get(OSM_GPS_MAP(context->widget), "zoom", &zoom, NULL);

  /* world at zoom 1 == 512 pixels */
  float m_per_pix = 
    cos(DEG2RAD(lat))*2*M_PI*EQ_RADIUS/(1<<(8+zoom));

  return 1000.0*km/m_per_pix;
}

#define CLICK_FUZZ (10)

static gboolean
on_map_button_press_event(GtkWidget *widget, 
                            GdkEventButton *event, map_context_t *context) {
  OsmGpsMap *map = OSM_GPS_MAP(context->widget);

  pos_t pos = 
    coord2pos(osm_gps_map_get_co_ordinates(map, event->x, event->y));

  cache_t *nearest = map_closest(context, &pos);  
  if(nearest) {
    float dist = gpx_pos_get_distance(pos, nearest->pos, FALSE);
    if(dist2pixel(context, dist, nearest->pos.lat) < CLICK_FUZZ) {
      context->press_on = nearest;
      return TRUE;
    }
  }

  context->press_on = NULL;
  return FALSE;
}

static gboolean
on_map_button_release_event(GtkWidget *widget, 
                            GdkEventButton *event, map_context_t *context) {
  if(context->press_on) {
    OsmGpsMap *map = OSM_GPS_MAP(context->widget);

    pos_t pos = 
      coord2pos(osm_gps_map_get_co_ordinates(map, event->x, event->y));

    cache_t *nearest = map_closest(context, &pos);  
    if(nearest && nearest == context->press_on) {
      float dist = gpx_pos_get_distance(pos, nearest->pos, FALSE);
      if(dist2pixel(context, dist, nearest->pos.lat) < CLICK_FUZZ) {
        
        cache_popup(context, nearest);
      
        context->press_on = NULL;
        return TRUE;
      }
    }
  }

  context->press_on = NULL;
  return FALSE;
}

#if MAEMO_VERSION_MAJOR == 5
static void on_window_destroy(GtkWidget *widget, map_context_t *context) {
  printf("destroy map view\n");

  /* restore cur_view */
  context->appdata->cur_view = context->old_view;

  gtk_timeout_remove(context->handler_id);
  g_free(context);
}
#endif

void map(appdata_t *appdata) {
  map_context_t *context = g_new0(map_context_t, 1);
  context->appdata = appdata;

  GtkWidget *hbox = gtk_hbox_new(FALSE, 0);

  char *path = g_strdup_printf("%s/map/", appdata->image_path);
  const char *proxy = get_proxy_uri(appdata);

  context->widget = g_object_new(OSM_TYPE_GPS_MAP,
                "repo-uri", MAP_SOURCE_OPENSTREETMAP,
                "tile-cache", path,
                proxy?"proxy-uri":NULL, proxy,
                 NULL);

  g_free(path);

  char *name = NULL;
#ifdef USE_MAEMO
  if(!appdata->cur_gpx) {
#endif
    /* draw all geocaches */
    gpx_t *gpx = appdata->gpx;
    while(gpx) {
      map_draw_cachelist(context->widget, gpx->cache);
      gpx = gpx->next;
    }
    name = g_strdup(_("all geocaches"));
#ifdef USE_MAEMO
  } else {
    map_draw_cachelist(context->widget, appdata->cur_gpx->cache);
    name = g_strdup(_("appdata->cur_gpx->name"));
  }
#endif

  char *title = g_strdup_printf(_("Map - %s"), name);
  g_free(name);

#if MAEMO_VERSION_MAJOR == 5
  GtkWidget *window = hildon_stackable_window_new();
  gtk_window_set_title(GTK_WINDOW(window), title);
#else
  GtkWidget *dialog = gtk_dialog_new_with_buttons(title,
                          GTK_WINDOW(appdata->window),
                          GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
                          GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
                          NULL);

#ifndef USE_MAEMO
  gtk_window_set_default_size(GTK_WINDOW(dialog), 400, 350);
#else
  gtk_window_set_default_size(GTK_WINDOW(dialog), 800, 480);
#endif
#endif

  g_free(title);

  g_signal_connect(G_OBJECT(context->widget), "configure-event",
                   G_CALLBACK(on_map_configure), context);

  g_signal_connect(G_OBJECT(context->widget), "button-press-event",
                   G_CALLBACK(on_map_button_press_event), context);

  g_signal_connect(G_OBJECT(context->widget), "button-release-event",
                   G_CALLBACK(on_map_button_release_event), context);

  gtk_box_pack_start_defaults(GTK_BOX(hbox), context->widget);
  /* zoom button box */
  GtkWidget *vbox = gtk_vbox_new(FALSE,0);

  context->zoomin = 
    map_add_button(GTK_STOCK_ZOOM_IN, G_CALLBACK(cb_map_zoomin),
                   context, _("Zoom in"));
  gtk_box_pack_start(GTK_BOX(vbox), context->zoomin, FALSE, FALSE, 0);

  context->zoomout = 
    map_add_button(GTK_STOCK_ZOOM_OUT, G_CALLBACK(cb_map_zoomout),
                   context, _("Zoom out"));
  gtk_box_pack_start(GTK_BOX(vbox), context->zoomout, FALSE, FALSE, 0);

  context->gps = 
    map_add_button(GTK_STOCK_HOME, G_CALLBACK(cb_map_gps),
                   context, _("Jump to GPS position"));
  gtk_widget_set_sensitive(context->gps, FALSE);
  /* install handler for timed updates of the gps button */
  context->handler_id = gtk_timeout_add(1000, map_gps_update, context);
  gtk_box_pack_start(GTK_BOX(vbox), context->gps, FALSE, FALSE, 0);

  gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);

#if MAEMO_VERSION_MAJOR == 5
  /* prevent some of the main screen things */
  context->old_view = appdata->cur_view;
  appdata->cur_view = NULL;

  g_signal_connect(G_OBJECT(window), "destroy", 
                   G_CALLBACK(on_window_destroy), context);

  gtk_container_add(GTK_CONTAINER(window), hbox); 
  gtk_widget_show_all(GTK_WIDGET(window));
 
#else
  gtk_box_pack_start_defaults(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox);
  gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE);
  gtk_widget_show_all(dialog);
  gtk_dialog_run(GTK_DIALOG(dialog));
  gtk_timeout_remove(context->handler_id);
  gtk_widget_destroy(dialog);
  g_free(context);
#endif
}
1	/*
2	* Copyright (C) 2008 Till Harbaum <till@harbaum.org>.
3	*
4	* This file is part of GPXView.
5	*
6	* GPXView is free software: you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as published by
8	* the Free Software Foundation, either version 3 of the License, or
9	* (at your option) any later version.
10	*
11	* GPXView is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with GPXView. If not, see <http://www.gnu.org/licenses/>.
18	*/
19
20	#include "gpxview.h"
21	#include <math.h> // for isnan
22
23	#ifdef ENABLE_OSM_GPS_MAP
24	#include "osm-gps-map.h"
25	#endif
26
27	/* equatorial radius in meters */
28	#define EQ_RADIUS (6378137.0)
29
30	#define RAD2DEG(a) (((a)*180.0)/M_PI)
31	#define DEG2RAD(a) (((a)*M_PI)/180.0)
32
33	typedef struct {
34	appdata_t *appdata;
35	GtkWidget *widget;
36	GtkWidget zoomin, zoomout, *gps;
37	gint handler_id;
38	cache_t *press_on;
39	#if MAEMO_VERSION_MAJOR == 5
40	GtkWidget *old_view;
41	#endif
42	} map_context_t;
43
44	#define PROXY_KEY "/system/http_proxy/"
45
46	static const char get_proxy_uri(appdata_t appdata) {
47	static char proxy_buffer[64] = "";
48
49	/* use environment settings if preset */
50	const char *proxy = g_getenv("http_proxy");
51	if(proxy) {
52	printf("http_proxy: %s\n", proxy);
53	return proxy;
54	}
55
56	/* ------------- get proxy settings -------------------- */
57	if(gconf_client_get_bool(appdata->gconf_client,
58	PROXY_KEY "use_http_proxy", NULL)) {
59
60	/* we can savely ignore things like "ignore_hosts" since we */
61	/* are pretty sure not inside the net of one of our map renderers */
62	/* (unless the user works at google :-) */
63
64	/* get basic settings */
65	char *host =
66	gconf_client_get_string(appdata->gconf_client, PROXY_KEY "host", NULL);
67	if(host) {
68	int port =
69	gconf_client_get_int(appdata->gconf_client, PROXY_KEY "port", NULL);
70
71	snprintf(proxy_buffer, sizeof(proxy_buffer),
72	"http://%s:%u", host, port);
73
74	g_free(host);
75	}
76	return proxy_buffer;
77	}
78
79	return NULL;
80	}
81
82	static void map_zoom(map_context_t *context, int step) {
83	int zoom;
84	OsmGpsMap *map = OSM_GPS_MAP(context->widget);
85	g_object_get(map, "zoom", &zoom, NULL);
86	zoom = osm_gps_map_set_zoom(map, zoom+step);
87
88	/* enable/disable zoom buttons as required */
89	gtk_widget_set_sensitive(context->zoomin, zoom<17);
90	gtk_widget_set_sensitive(context->zoomout, zoom>1);
91	}
92
93	static gboolean
94	cb_map_zoomin(GtkButton button, map_context_t context) {
95	map_zoom(context, +1);
96	return FALSE;
97	}
98
99	static gboolean
100	cb_map_zoomout(GtkButton button, map_context_t context) {
101	map_zoom(context, -1);
102	return FALSE;
103	}
104
105	static gboolean
106	cb_map_gps(GtkButton button, map_context_t context) {
107	pos_t *refpos = get_pos(context->appdata);
108	if(refpos && !isnan(refpos->lat) && !isnan(refpos->lon)) {
109	osm_gps_map_set_mapcenter(OSM_GPS_MAP(context->widget),
110	refpos->lat, refpos->lon, 14);
111	} else {
112	/* no coordinates given: display the entire world */
113	osm_gps_map_set_mapcenter(OSM_GPS_MAP(context->widget),
114	0.0, 0.0, 1);
115	}
116
117	return FALSE;
118	}
119
120	static GtkWidget
121	map_add_button(const gchar icon, GCallback cb, gpointer data,
122	char *tooltip) {
123	GtkWidget *button = gtk_button_new();
124	gtk_button_set_image(GTK_BUTTON(button),
125	gtk_image_new_from_stock(icon, GTK_ICON_SIZE_MENU));
126	g_signal_connect(button, "clicked", cb, data);
127	#ifndef USE_MAEMO
128	gtk_widget_set_tooltip_text(button, tooltip);
129	#endif
130	return button;
131	}
132
133	static gboolean map_gps_update(gpointer data) {
134	map_context_t context = (map_context_t)data;
135
136	pos_t *refpos = get_pos(context->appdata);
137	gboolean ok = (refpos!= NULL) && !isnan(refpos->lat) && !isnan(refpos->lon);
138
139	/* get reference position and go there */
140	gtk_widget_set_sensitive(context->gps, ok);
141
142	return TRUE;
143	}
144
145	static gboolean on_map_configure(GtkWidget *widget,
146	GdkEventConfigure *event,
147	map_context_t *context) {
148
149	cb_map_gps(NULL, context);
150
151	return FALSE;
152	}
153
154	static void map_draw_cachelist(GtkWidget map, cache_t cache) {
155	while(cache) {
156	GdkPixbuf *icon = icon_get(ICON_CACHE_TYPE, cache->type);
157
158	osm_gps_map_add_image(OSM_GPS_MAP(map),
159	cache->pos.lat, cache->pos.lon, icon);
160
161	cache = cache->next;
162	}
163	}
164
165	/* draw a nice popup */
166	typedef struct {
167	appdata_t *appdata;
168	GtkWidget *window;
169	GMainLoop *loop;
170	} popup_context_t;
171
172
173	#ifndef USE_HILDON
174	#define POPUP_WIDTH 300
175	#define POPUP_HEIGHT 100
176	#else
177	#define POPUP_WIDTH 600
178	#define POPUP_HEIGHT 200
179	#endif
180
181	static gboolean
182	pointer_in_window(GtkWidget *widget, gint x_root, gint y_root) {
183	if(GTK_WIDGET_MAPPED(gtk_widget_get_toplevel(widget))) {
184	gint window_x, window_y;
185
186	gdk_window_get_position(gtk_widget_get_toplevel(widget)->window,
187	&window_x, &window_y);
188
189	if(x_root >= window_x && x_root < window_x + widget->allocation.width &&
190	y_root >= window_y && y_root < window_y + widget->allocation.height)
191	return TRUE;
192	}
193
194	return FALSE;
195	}
196
197	static gboolean
198	on_button_press_event(GtkWidget *widget,
199	GdkEventButton event, popup_context_t context) {
200	gboolean in = pointer_in_window(widget, event->x_root, event->y_root);
201
202	printf("overlay button press(in = %d)\n", in);
203	return !in;
204	}
205
206	static gboolean
207	on_button_release_event(GtkWidget *widget,
208	GdkEventButton event, popup_context_t context) {
209	gboolean in = pointer_in_window(widget, event->x_root, event->y_root);
210
211	printf("overlay button release(in = %d)\n", in);
212
213	if(!in) {
214	printf("destroying popup\n");
215	gtk_widget_destroy(gtk_widget_get_toplevel(widget));
216	}
217
218	return !in;
219	}
220
221	static void
222	shutdown_loop(popup_context_t *context) {
223	if(g_main_loop_is_running(context->loop))
224	g_main_loop_quit(context->loop);
225	}
226
227	static gint
228	run_delete_handler(GtkWindow window, GdkEventAny event,
229	popup_context_t *context) {
230	shutdown_loop(context);
231	return TRUE; /* Do not destroy */
232	}
233
234	static void
235	run_destroy_handler(GtkWindow window, popup_context_t context) {
236	/* shutdown_loop will be called by run_unmap_handler */
237	printf("popup destroyed\n");
238	}
239
240	static void
241	run_unmap_handler(GtkWindow window, popup_context_t context) {
242	shutdown_loop(context);
243	}
244
245	void cache_popup(map_context_t mcontext, cache_t cache) {
246	popup_context_t pcontext;
247	pcontext.appdata = mcontext->appdata;
248
249	pcontext.window = gtk_window_new(GTK_WINDOW_POPUP);
250	gtk_widget_realize(pcontext.window);
251	gtk_window_set_default_size(GTK_WINDOW(pcontext.window),
252	POPUP_WIDTH, POPUP_HEIGHT);
253	gtk_window_resize(GTK_WINDOW(pcontext.window),
254	POPUP_WIDTH, POPUP_HEIGHT);
255	// gtk_window_set_resizable(GTK_WINDOW(pcontext.window), FALSE);
256	gtk_window_set_transient_for(GTK_WINDOW(pcontext.window),
257	GTK_WINDOW(mcontext->appdata->window));
258	gtk_window_set_keep_above(GTK_WINDOW(pcontext.window), TRUE);
259	gtk_window_set_destroy_with_parent(GTK_WINDOW(pcontext.window), TRUE);
260	gtk_window_set_gravity(GTK_WINDOW(pcontext.window), GDK_GRAVITY_STATIC);
261	gtk_window_set_modal(GTK_WINDOW(pcontext.window), TRUE);
262
263	/* connect events */
264	g_signal_connect(G_OBJECT(pcontext.window), "button-press-event",
265	G_CALLBACK(on_button_press_event), &pcontext);
266	g_signal_connect(G_OBJECT(pcontext.window), "button-release-event",
267	G_CALLBACK(on_button_release_event), &pcontext);
268	g_signal_connect(G_OBJECT(pcontext.window), "delete-event",
269	G_CALLBACK(run_delete_handler), &pcontext);
270	g_signal_connect(G_OBJECT(pcontext.window), "destroy",
271	G_CALLBACK(run_destroy_handler), &pcontext);
272	g_signal_connect(G_OBJECT(pcontext.window), "unmap",
273	G_CALLBACK(run_unmap_handler), &pcontext);
274
275	gdk_pointer_grab(pcontext.window->window, TRUE,
276	GDK_BUTTON_PRESS_MASK \| GDK_BUTTON_RELEASE_MASK \| GDK_BUTTON_MOTION_MASK,
277	NULL, NULL, GDK_CURRENT_TIME);
278	gtk_grab_add(pcontext.window);
279
280	/* check whether cache is in upper or lower half of window */
281	gint x, y;
282	osm_gps_map_geographic_to_screen(OSM_GPS_MAP(mcontext->widget),
283	cache->pos.lat, cache->pos.lon,
284	&x, &y);
285
286	printf("screen pos %d/%d\n", x, y);
287
288	gdk_window_get_origin(mcontext->widget->window, &x, &y);
289	printf("window = %d/%d %d/%d\n", x, y,
290	mcontext->widget->allocation.x,
291	mcontext->widget->allocation.y);
292
293	// gtk_window_move(GTK_WINDOW(pcontext.window),
294	// x + button->allocation.x,
295	// y + button->allocation.y - HEIGHT);
296
297
298	gtk_window_move(GTK_WINDOW(pcontext.window),
299	100,
300	100);
301
302	/* a frame with a vscale inside */
303	GtkWidget *frame = gtk_frame_new(NULL);
304	gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT);
305
306	gtk_container_add(GTK_CONTAINER(frame), gtk_label_new(cache->name));
307	gtk_container_add(GTK_CONTAINER(pcontext.window), frame);
308
309	gtk_widget_show_all(pcontext.window);
310
311	/* handle this popup until it's gone */
312
313	pcontext.loop = g_main_loop_new(NULL, FALSE);
314
315	GDK_THREADS_LEAVE();
316	g_main_loop_run(pcontext.loop);
317	GDK_THREADS_ENTER();
318
319	g_main_loop_unref(pcontext.loop);
320
321	printf("cache popup removed\n");
322	}
323
324	static void
325	map_cachelist_nearest(cache_t cache, pos_t pos,
326	cache_t *result, float distance) {
327	while(cache) {
328	float dist =
329	pow(cache->pos.lat - pos->lat, 2) +
330	pow(cache->pos.lon - pos->lon, 2);
331
332	if(!(dist > *distance)) {
333	*result = cache;
334	*distance = dist;
335	}
336
337	cache = cache->next;
338	}
339	}
340
341	static cache_t map_closest(map_context_t context, pos_t *pos) {
342	cache_t *result = NULL;
343	float distance = NAN;
344
345	#ifdef USE_MAEMO
346	if(!context->appdata->cur_gpx) {
347	#endif
348	/* search all geocaches */
349	gpx_t *gpx = context->appdata->gpx;
350	while(gpx) {
351	map_cachelist_nearest(gpx->cache, pos, &result, &distance);
352	gpx = gpx->next;
353	}
354	#ifdef USE_MAEMO
355	} else {
356	map_cachelist_nearest(context->appdata->cur_gpx->cache,
357	pos, &result, &distance);
358	}
359	#endif
360
361	return result;
362	}
363
364	/* translate between osm-gps-map positions and gpxview ones */
365	pos_t coord2pos(coord_t coo) {
366	pos_t pos;
367	pos.lat = RAD2DEG(coo.rlat);
368	pos.lon = RAD2DEG(coo.rlon);
369	return pos;
370	}
371
372	static int dist2pixel(map_context_t *context, float km, float lat) {
373	int zoom;
374	g_object_get(OSM_GPS_MAP(context->widget), "zoom", &zoom, NULL);
375
376	/* world at zoom 1 == 512 pixels */
377	float m_per_pix =
378	cos(DEG2RAD(lat))2M_PI*EQ_RADIUS/(1<<(8+zoom));
379
380	return 1000.0*km/m_per_pix;
381	}
382
383	#define CLICK_FUZZ (10)
384
385	static gboolean
386	on_map_button_press_event(GtkWidget *widget,
387	GdkEventButton event, map_context_t context) {
388	OsmGpsMap *map = OSM_GPS_MAP(context->widget);
389
390	pos_t pos =
391	coord2pos(osm_gps_map_get_co_ordinates(map, event->x, event->y));
392
393	cache_t *nearest = map_closest(context, &pos);
394	if(nearest) {
395	float dist = gpx_pos_get_distance(pos, nearest->pos, FALSE);
396	if(dist2pixel(context, dist, nearest->pos.lat) < CLICK_FUZZ) {
397	context->press_on = nearest;
398	return TRUE;
399	}
400	}
401
402	context->press_on = NULL;
403	return FALSE;
404	}
405
406	static gboolean
407	on_map_button_release_event(GtkWidget *widget,
408	GdkEventButton event, map_context_t context) {
409	if(context->press_on) {
410	OsmGpsMap *map = OSM_GPS_MAP(context->widget);
411
412	pos_t pos =
413	coord2pos(osm_gps_map_get_co_ordinates(map, event->x, event->y));
414
415	cache_t *nearest = map_closest(context, &pos);
416	if(nearest && nearest == context->press_on) {
417	float dist = gpx_pos_get_distance(pos, nearest->pos, FALSE);
418	if(dist2pixel(context, dist, nearest->pos.lat) < CLICK_FUZZ) {
419
420	cache_popup(context, nearest);
421
422	context->press_on = NULL;
423	return TRUE;
424	}
425	}
426	}
427
428	context->press_on = NULL;
429	return FALSE;
430	}
431
432	#if MAEMO_VERSION_MAJOR == 5
433	static void on_window_destroy(GtkWidget widget, map_context_t context) {
434	printf("destroy map view\n");
435
436	/* restore cur_view */
437	context->appdata->cur_view = context->old_view;
438
439	gtk_timeout_remove(context->handler_id);
440	g_free(context);
441	}
442	#endif
443
444	void map(appdata_t *appdata) {
445	map_context_t *context = g_new0(map_context_t, 1);
446	context->appdata = appdata;
447
448	GtkWidget *hbox = gtk_hbox_new(FALSE, 0);
449
450	char *path = g_strdup_printf("%s/map/", appdata->image_path);
451	const char *proxy = get_proxy_uri(appdata);
452
453	context->widget = g_object_new(OSM_TYPE_GPS_MAP,
454	"repo-uri", MAP_SOURCE_OPENSTREETMAP,
455	"tile-cache", path,
456	proxy?"proxy-uri":NULL, proxy,
457	NULL);
458
459	g_free(path);
460
461	char *name = NULL;
462	#ifdef USE_MAEMO
463	if(!appdata->cur_gpx) {
464	#endif
465	/* draw all geocaches */
466	gpx_t *gpx = appdata->gpx;
467	while(gpx) {
468	map_draw_cachelist(context->widget, gpx->cache);
469	gpx = gpx->next;
470	}
471	name = g_strdup(_("all geocaches"));
472	#ifdef USE_MAEMO
473	} else {
474	map_draw_cachelist(context->widget, appdata->cur_gpx->cache);
475	name = g_strdup(_("appdata->cur_gpx->name"));
476	}
477	#endif
478
479	char *title = g_strdup_printf(_("Map - %s"), name);
480	g_free(name);
481
482	#if MAEMO_VERSION_MAJOR == 5
483	GtkWidget *window = hildon_stackable_window_new();
484	gtk_window_set_title(GTK_WINDOW(window), title);
485	#else
486	GtkWidget *dialog = gtk_dialog_new_with_buttons(title,
487	GTK_WINDOW(appdata->window),
488	GTK_DIALOG_MODAL \| GTK_DIALOG_DESTROY_WITH_PARENT,
489	GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
490	NULL);
491
492	#ifndef USE_MAEMO
493	gtk_window_set_default_size(GTK_WINDOW(dialog), 400, 350);
494	#else
495	gtk_window_set_default_size(GTK_WINDOW(dialog), 800, 480);
496	#endif
497	#endif
498
499	g_free(title);
500
501	g_signal_connect(G_OBJECT(context->widget), "configure-event",
502	G_CALLBACK(on_map_configure), context);
503
504	g_signal_connect(G_OBJECT(context->widget), "button-press-event",
505	G_CALLBACK(on_map_button_press_event), context);
506
507	g_signal_connect(G_OBJECT(context->widget), "button-release-event",
508	G_CALLBACK(on_map_button_release_event), context);
509
510	gtk_box_pack_start_defaults(GTK_BOX(hbox), context->widget);
511	/* zoom button box */
512	GtkWidget *vbox = gtk_vbox_new(FALSE,0);
513
514	context->zoomin =
515	map_add_button(GTK_STOCK_ZOOM_IN, G_CALLBACK(cb_map_zoomin),
516	context, _("Zoom in"));
517	gtk_box_pack_start(GTK_BOX(vbox), context->zoomin, FALSE, FALSE, 0);
518
519	context->zoomout =
520	map_add_button(GTK_STOCK_ZOOM_OUT, G_CALLBACK(cb_map_zoomout),
521	context, _("Zoom out"));
522	gtk_box_pack_start(GTK_BOX(vbox), context->zoomout, FALSE, FALSE, 0);
523
524	context->gps =
525	map_add_button(GTK_STOCK_HOME, G_CALLBACK(cb_map_gps),
526	context, _("Jump to GPS position"));
527	gtk_widget_set_sensitive(context->gps, FALSE);
528	/* install handler for timed updates of the gps button */
529	context->handler_id = gtk_timeout_add(1000, map_gps_update, context);
530	gtk_box_pack_start(GTK_BOX(vbox), context->gps, FALSE, FALSE, 0);
531
532	gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
533
534	#if MAEMO_VERSION_MAJOR == 5
535	/* prevent some of the main screen things */
536	context->old_view = appdata->cur_view;
537	appdata->cur_view = NULL;
538
539	g_signal_connect(G_OBJECT(window), "destroy",
540	G_CALLBACK(on_window_destroy), context);
541
542	gtk_container_add(GTK_CONTAINER(window), hbox);
543	gtk_widget_show_all(GTK_WIDGET(window));
544
545	#else
546	gtk_box_pack_start_defaults(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox);
547	gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE);
548	gtk_widget_show_all(dialog);
549	gtk_dialog_run(GTK_DIALOG(dialog));
550	gtk_timeout_remove(context->handler_id);
551	gtk_widget_destroy(dialog);
552	g_free(context);
553	#endif
554	}