--- trunk/src/map-tool.c	2009/07/30 08:29:52	35
+++ trunk/src/map-tool.c	2009/08/03 19:18:13	42
@@ -24,11 +24,21 @@
 #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/"
@@ -141,28 +151,306 @@
   return FALSE;
 }
 
-void map(appdata_t *appdata) {
-  map_context_t context;
-  context.appdata = appdata;
+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);
 
-  GtkWidget *dialog = gtk_dialog_new_with_buttons(_("Map"),
-			  GTK_WINDOW(appdata->window),
-			  GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
-                          GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
-                          NULL);
+    cache = cache->next;
+  }
+}
 
-#ifndef USE_MAEMO
-  gtk_window_set_default_size(GTK_WINDOW(dialog), 400, 350);
+/* 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
-  gtk_window_set_default_size(GTK_WINDOW(dialog), 800, 480);
+#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,
+  context->widget = g_object_new(OSM_TYPE_GPS_MAP,
                 "repo-uri", MAP_SOURCE_OPENSTREETMAP,
                 "tile-cache", path,
 		proxy?"proxy-uri":NULL, proxy,
@@ -170,46 +458,97 @@
 
   g_free(path);
 
-  g_signal_connect(G_OBJECT(context.widget), "configure-event",
-		   G_CALLBACK(on_map_configure), &context);
-#if 0
-  g_signal_connect(G_OBJECT(context.widget), "button-release-event",
-                   G_CALLBACK(on_map_button_release_event), &context);
+  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);
 
-  gtk_box_pack_start_defaults(GTK_BOX(hbox), context.widget);
+#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 = 
+  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, _("Zoom in"));
+  gtk_box_pack_start(GTK_BOX(vbox), context->zoomin, FALSE, FALSE, 0);
 
-  context.zoomout = 
+  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, _("Zoom out"));
+  gtk_box_pack_start(GTK_BOX(vbox), context->zoomout, FALSE, FALSE, 0);
 
-  context.gps = 
+  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);
+		   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);
+  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_timeout_remove(context->handler_id);
   gtk_widget_destroy(dialog);
+  g_free(context);
+#endif
 }