trunk/src/goto.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 <stdio.h>
#include <string.h>
#include <math.h>

#include "gpxview.h"

#ifdef USE_MAEMO
#include "dbus.h"
#endif

#define COMPASS_SIZE    230
#define LETTER_SPACE    0.2
#define DIAMOND_WIDTH   0.05
#define DIAMOND_HEIGHT  0.2
#define ARROW_WIDTH     0.3
#define ARROW_LENGTH    0.7
#define UPDATE_MS       1000   /* gps updates are sent once a second */

#define SAT_WIDTH 330
#define SAT_HEIGHT 60

#ifdef ESPEAK
#include <espeak/speak_lib.h>

#define ESPEAK_TIMEOUT (15000)   // every 15 seconds

char *espeak_make_string(float dist, gboolean imperial) {
  char *retval = NULL;

  if(!imperial) {
    /* distance is in kilometers */
    if(dist < 2.0/1000.0)
      retval = g_strdup(_("1 meter"));
    else if(dist < 1.0)
      retval = g_strdup_printf(_("%u meters"), (int)(dist*1000));
    else if(dist < 2.0)
      retval = g_strdup(_("1 kilometer"));
    else
      retval = g_strdup_printf(_("%u kilometers"), (int)dist);
  } else {

    /* 1 mil = 1760 yd = 5280 ft ... */
    if(dist < (2.0/5280.0))
      retval = g_strdup(_("1 foot"));
    else if(dist < (1.0/1760.0))
      retval = g_strdup_printf(_("%u feet"), (int)(dist*5280));
    else if(dist < (2.0/1760.0))
      retval = g_strdup(_("1 yard"));
    else if(dist < 1.0)
      retval = g_strdup_printf(_("%u yard"), (int)(dist*1760));
    else if(dist < 2.0)
      retval = g_strdup(_("1 mile"));
    else
      retval = g_strdup_printf(_("%u miles"), (int)dist);
  }
  return retval;
}

static gboolean espeak_do(gpointer data) {
  cache_context_t *context = (cache_context_t*)data;

  pos_t *pos = gps_get_pos(context->appdata);
  if(pos && !isnan(pos->lat) && !isnan(pos->lon) &&
     !isnan(context->gotoc.pos.lat) && !isnan(context->gotoc.pos.lon)) {

    /* build distance */
    float dist = 
      gpx_pos_get_distance(*pos, context->gotoc.pos,
                           context->appdata->imperial);

    char *talk = espeak_make_string(dist, context->appdata->imperial);

    unsigned int unique_identifier=0;
    espeak_Synth(talk, strlen(talk)+1, 0, 0, 0, espeakCHARS_AUTO,
                 &unique_identifier, NULL);
    
    g_free(talk);
  }
  
  return TRUE;  // speak again
}

static void espeak_enable(cache_context_t *context, gboolean enable) {
  if(enable) {
    g_assert(!context->gotoc.espeak_handler);

    context->gotoc.espeak_handler = 
      gtk_timeout_add(ESPEAK_TIMEOUT, espeak_do, context);  

    espeak_do(context);

  } else {
    if(context->gotoc.espeak_handler) {
      gtk_timeout_remove(context->gotoc.espeak_handler);
      context->gotoc.espeak_handler = 0;
    }
  }
}
#endif

static float rad2deg(float rad) {
  return fmodf(360.0 + (180.0/M_PI) * rad, 360.0);
}

static void compass_draw(GtkWidget *widget, cache_context_t *context) {
  float f;
  int i;

  cairo_t *cr = gdk_cairo_create(context->gotoc.compass_pixmap);

  gint width = widget->allocation.width;
  gint height = widget->allocation.height;
  gint diameter = (height < width)?height:width;

  gint xcenter = width/2;
  gint ycenter = height/2;
  gint radius = diameter/2;

  /* erase background */
  gdk_draw_rectangle(context->gotoc.compass_pixmap, 
                     widget->style->bg_gc[GTK_STATE_NORMAL], TRUE,
                     0, 0, width, height);

  /* use white rosetta background unless the real background */
  /* is very bright. Use bright grey then */
  
  if(widget->style->bg[GTK_STATE_NORMAL].red + 
     widget->style->bg[GTK_STATE_NORMAL].green +
     widget->style->bg[GTK_STATE_NORMAL].blue < 3*60000) {
    /* background is very bright, use white */
    cairo_set_source_rgb(cr, 1, 1, 1);
  } else
    cairo_set_source_rgb(cr, 0.87, 0.87, 0.87);

  cairo_arc(cr, width/2, height/2, diameter/2, 0, 2 * M_PI);
  cairo_fill(cr);

  /* draw the locked/unlocked icon */
  gdk_draw_pixbuf(context->gotoc.compass_pixmap, 
                  widget->style->fg_gc[GTK_STATE_NORMAL],
                  icon_get(ICON_MISC, context->appdata->compass_locked?0:1), 
                  0, 0, (width-diameter)/2 + diameter/64, 
                  (height+diameter)/2 - 32 - diameter/64 , 32, 32,
                  GDK_RGB_DITHER_NONE,0,0);
                  
  /* don't update heading if the compass is locked */
  if(!context->appdata->compass_locked) {
    int i, valid = 0, cnt=0;
    double x_sum = 0.0, y_sum = 0.0;

    /* shift heading buffer up one entry and add new value at entry 0 */
    for(i=MAX_AVERAGE-1;i>0;i--) 
      context->gotoc.head_avg[i] = context->gotoc.head_avg[i-1];
    context->gotoc.head_avg[0] = gps_get_heading(context->appdata)*M_PI/180.0;

    //    printf("Damping = %d\n", context->appdata->compass_damping);
    //    printf("add heading %f\n", rad2deg(context->gotoc.head_avg[0]));

    /* determine number of valid entries */
    for(i=0;i<MAX_AVERAGE && valid<context->appdata->compass_damping;i++) 
      if(!isnan(context->gotoc.head_avg[i])) 
        valid++;

    /* map back to angle if at least one value has been added */
    if(valid) {
      /* map all valid antries onto a circle */
      for(i=0;i<MAX_AVERAGE && cnt<context->appdata->compass_damping;i++) {
        if(!isnan(context->gotoc.head_avg[i])) {
          float weight = 1.0 - ((float)(cnt++)/(float)valid);
          printf("weight = %f * %f\n", 
                 weight, rad2deg(context->gotoc.head_avg[i]));
          x_sum += weight * sin(context->gotoc.head_avg[i]);
          y_sum += weight * cos(context->gotoc.head_avg[i]);
        }
      }

      printf("%d valid heading entries\n", valid);
      context->gotoc.heading = atan2(x_sum, y_sum);
      printf("averaged heading: %f\n", 
             rad2deg(context->gotoc.heading));
    } else { 
      //      printf("no valid heading, keeping old value heading\n");
    }
  }

  if(!isnan(context->gotoc.heading)) {

    /* --------------------------- draw sun ---------------------- */
    float sun_az = astro_get_sun_azimuth(context->appdata);
    if(!isnan(sun_az)) {
      float sang = sun_az - context->gotoc.heading;

      cairo_set_source_rgb(cr, 1.0, 0.8, 0.0);
      
      int sd = diameter/6;
      int sx = xcenter + (diameter/2 - sd/2) * sin(sang);
      int sy = ycenter - (diameter/2 - sd/2) * cos(sang);
      
      int scd = 0.6*sd;
      
      cairo_arc (cr, sx, sy, scd/2, 0, 2 * M_PI);
      cairo_fill(cr);
      
      /* draw sun rays */
      for(f=0;f<2*M_PI-M_PI/8;f+=M_PI/4) {
        float ang = f - context->gotoc.heading;
        
        cairo_move_to(cr, sx + sd *  0.5 *  sin(ang),
                          sy + sd *  0.5 * -cos(ang));
        
        cairo_line_to(cr, sx + sd *  0.2 *  sin(ang+0.5),
                          sy + sd *  0.2 * -cos(ang+0.5));
        
        cairo_line_to(cr, sx + sd *  0.2 *  sin(ang-0.5),
                          sy + sd *  0.2 * -cos(ang-0.5));
        
        cairo_close_path (cr);
        cairo_fill(cr);
      }
    }

    /* ---------------- draw markers -------------------- */
    cairo_set_source_rgb(cr, 0, 0, 0);

    for(i=0,f=0;f<2*M_PI-M_PI/8;f+=M_PI/4,i++) {
      float ang = f - context->gotoc.heading;

      if(!(i&1)) {
#define OUT  (1.0-LETTER_SPACE)

        cairo_move_to(cr, xcenter + radius * OUT *  sin(ang),
                          ycenter + radius * OUT * -cos(ang));

        cairo_line_to(cr, xcenter + radius * (OUT-DIAMOND_HEIGHT/2) * 
                                     sin(ang+DIAMOND_WIDTH),
                          ycenter + radius * (OUT-DIAMOND_HEIGHT/2)*
                                    -cos(ang+DIAMOND_WIDTH));
        
        cairo_line_to(cr, xcenter + radius * (OUT-DIAMOND_HEIGHT) *  sin(ang),
                          ycenter + radius * (OUT-DIAMOND_HEIGHT) * -cos(ang));
        
        cairo_line_to(cr, xcenter + radius * (OUT-DIAMOND_HEIGHT/2) * 
                                     sin(ang-DIAMOND_WIDTH),
                          ycenter + radius * (OUT-DIAMOND_HEIGHT/2) *
                                    -cos(ang-DIAMOND_WIDTH));
        
        cairo_close_path (cr);
        cairo_fill(cr);
        
        const char *str[] = { "N", "E", "S", "W" };
        PangoLayout *layout = 
          gtk_widget_create_pango_layout(widget, _(str[i/2]));
        int tw, th;
        pango_layout_get_pixel_size(layout, &tw, &th);  
        
        gdk_draw_layout(context->gotoc.compass_pixmap, widget->style->black_gc,
                xcenter + radius * (1.0-LETTER_SPACE/2)*sin(ang) - tw/2, 
                ycenter + radius * (1.0-LETTER_SPACE/2)*-cos(ang) - th/2,
                layout);
        
        g_object_unref(layout);
      } else {
        cairo_move_to(cr, xcenter + radius * 0.9 *  sin(ang), 
                          ycenter + radius * 0.9 * -cos(ang));

        cairo_line_to(cr, xcenter + radius * 1.0 *  sin(ang), 
                          ycenter + radius * 1.0 * -cos(ang));
        
        cairo_stroke(cr);
      }
    }
    
    /* --------------------------- draw arrow ---------------------- */

    pos_t *pos = gps_get_pos(context->appdata);
    if(pos && !isnan(pos->lat) && !isnan(pos->lon)) {
      context->appdata->gps.saved = *pos;   /* save position */

      float arot =
        gpx_pos_get_bearing(*pos, context->gotoc.pos) * 
        M_PI/180 - context->gotoc.heading;

      cairo_move_to(cr, xcenter + radius *  ARROW_LENGTH *  sin(arot),
                        ycenter + radius *  ARROW_LENGTH * -cos(arot));
      
      cairo_line_to(cr, xcenter + radius * -ARROW_LENGTH *  sin(arot+ARROW_WIDTH),
                        ycenter + radius * -ARROW_LENGTH * -cos(arot+ARROW_WIDTH));
      
      cairo_line_to(cr, xcenter + radius * -0.5 * ARROW_LENGTH *  sin(arot),
                        ycenter + radius * -0.5 * ARROW_LENGTH * -cos(arot));
      
      cairo_line_to(cr, xcenter + radius * -ARROW_LENGTH *  sin(arot-ARROW_WIDTH),
                        ycenter + radius * -ARROW_LENGTH * -cos(arot-ARROW_WIDTH));
      
      cairo_set_source_rgb(cr, 0.5, 0.0, 0.0);
      cairo_close_path (cr);
      cairo_fill(cr);

    } else {
      PangoLayout *layout;

      if(context->appdata->use_gps)
        layout = gtk_widget_create_pango_layout(widget, _("No fix"));
      else
        layout = gtk_widget_create_pango_layout(widget, _("GPS disabled"));

      int tw, th;
      pango_layout_get_pixel_size(layout, &tw, &th);  
      
      gdk_draw_layout(context->gotoc.compass_pixmap, widget->style->black_gc,
                      xcenter - tw/2, ycenter - th/2, layout);
        
      g_object_unref(layout);
    }
  }
  cairo_destroy(cr);
}

/* Create a new backing pixmap of the appropriate size */
static gint compass_configure_event(GtkWidget *widget, 
                                    GdkEventConfigure *event, gpointer data) {
  cache_context_t *context = (cache_context_t*)data;

  if(context->gotoc.compass_pixmap)
    gdk_pixmap_unref(context->gotoc.compass_pixmap);

  context->gotoc.compass_pixmap = gdk_pixmap_new(widget->window,
                                     widget->allocation.width,
                                     widget->allocation.height,
                                     -1);
  compass_draw(widget, context);
  //  goto_update(context);

  return TRUE;
}

/* Redraw the screen from the backing pixmap */
static gint compass_expose_event(GtkWidget *widget, GdkEventExpose *event, 
                         gpointer data) {
  cache_context_t *context = (cache_context_t*)data;

  gdk_draw_pixmap(widget->window,
                  widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
                  context->gotoc.compass_pixmap,
                  event->area.x, event->area.y,
                  event->area.x, event->area.y,
                  event->area.width, event->area.height);

  return FALSE;
}

static void sat_draw(GtkWidget *widget, cache_context_t *context) {
  gint width = widget->allocation.width;
  gint height = widget->allocation.height;

  /* erase background */
  gdk_draw_rectangle(context->gotoc.sat_pixmap, 
                     widget->style->bg_gc[GTK_STATE_NORMAL], TRUE,
                     0, 0, width, height);

  gps_sat_t *sat = gps_get_sats(context->appdata);
  gint sat_num = gps_get_satnum(context->appdata);

  if(sat && sat_num) {
    /* setup required colors */
    GdkGC *used_gc = gdk_gc_new(context->gotoc.sat_pixmap);
    gdk_gc_copy(used_gc, widget->style->black_gc);
    GdkColor used_color;
    gdk_color_parse("#008000", &used_color);   // green
    gdk_gc_set_rgb_fg_color(used_gc,  &used_color);

#define SAT_SPACING 3
    int i, x;
    int swid = (width-SAT_SPACING*(sat_num-1))/sat_num;

    /* as of xgps, a ss of 40 and more is "plenty" */
    int max_ss = 40;
    for(i=0;i<sat_num;i++)
      if(sat[i].ss > max_ss) sat[i].ss = max_ss;

    if(swid > 40) {
      swid = 40;
      x = (width-sat_num*swid)/2;
    } else
      x = 0;

    for(i=0;i<sat_num;i++) {
      char str[32];
#ifdef USE_MAEMO
      snprintf(str, sizeof(str), "<span size=\"small\">%d</span>", sat[i].prn);
      PangoLayout *layout = gtk_widget_create_pango_layout(widget, NULL);
      pango_layout_set_markup(layout, str, strlen(str));
#else    
      snprintf(str, sizeof(str), "%d", sat[i].prn);
      PangoLayout *layout = gtk_widget_create_pango_layout(widget, str);
#endif

      int tw, th;
      pango_layout_get_pixel_size(layout, &tw, &th);  
      gdk_draw_layout(context->gotoc.sat_pixmap, 
                      widget->style->text_gc[GTK_STATE_NORMAL],
                      x + swid/2 - tw/2, height - th, layout);
        
      g_object_unref(layout);

      int h = (height-th) * sat[i].ss / max_ss; 

      gdk_draw_rectangle(context->gotoc.sat_pixmap, 
                 sat[i].used?used_gc:widget->style->fg_gc[GTK_STATE_NORMAL], 
                 TRUE, x, height-h-th, swid, h);

      x += SAT_SPACING+swid;
    }

  } else {
    PangoLayout *layout = 
      gtk_widget_create_pango_layout(widget, _("No SAT info"));
    int tw, th;
    pango_layout_get_pixel_size(layout, &tw, &th);  
    gdk_draw_layout(context->gotoc.sat_pixmap, 
                    widget->style->text_gc[GTK_STATE_NORMAL],
                    (width - tw)/2, (height - th)/2, layout);
    
    g_object_unref(layout);
  }
}

/* Create a new backing pixmap of the appropriate size */
static gint sat_configure_event(GtkWidget *widget, GdkEventConfigure *event,
                            gpointer data) {
  cache_context_t *context = (cache_context_t*)data;

  if(context->gotoc.sat_pixmap)
    gdk_pixmap_unref(context->gotoc.sat_pixmap);

  context->gotoc.sat_pixmap = gdk_pixmap_new(widget->window,
                                         widget->allocation.width,
                                         widget->allocation.height,
                                         -1);
  sat_draw(widget, context);

  return TRUE;
}

/* Redraw the screen from the backing pixmap */
static gint sat_expose_event(GtkWidget *widget, GdkEventExpose *event, 
                         gpointer data) {
  cache_context_t *context = (cache_context_t*)data;

  gdk_draw_pixmap(widget->window,
                  widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
                  context->gotoc.sat_pixmap,
                  event->area.x, event->area.y,
                  event->area.x, event->area.y,
                  event->area.width, event->area.height);

  return FALSE;
}

gint goto_destroy_event(GtkWidget *widget, gpointer data ) {
  cache_context_t *context = (cache_context_t*)data;

  printf("destroying goto view\n");

#ifdef ESPEAK
  espeak_enable(context, FALSE);
#endif

  /* stop timer */
  if(context->gotoc.handler_id)
    gtk_timeout_remove(context->gotoc.handler_id);

  return FALSE;
}

static gboolean goto_update(gpointer data) {
  cache_context_t *context = (cache_context_t*)data;

  if(context->gotoc.sat_pixmap) {
    static int sub = 0;

    if(!sub) {
      /* draw sat view */
      sat_draw(context->gotoc.sat_area, context);
      gtk_widget_queue_draw_area(context->gotoc.sat_area, 0,0,
                                 context->gotoc.sat_area->allocation.width, 
                                 context->gotoc.sat_area->allocation.height);
    }

    if(sub++ == 5) sub = 0;
  }

  if(context->gotoc.compass_pixmap) {
    /* draw compass */
    compass_draw(context->gotoc.compass_area, context);
    gtk_widget_queue_draw_area(context->gotoc.compass_area, 0,0,
                               context->gotoc.compass_area->allocation.width, 
                               context->gotoc.compass_area->allocation.height);
  }

  pos_t *pos = gps_get_pos(context->appdata);
  if(pos && !isnan(pos->lat) && !isnan(pos->lon) &&
     !isnan(context->gotoc.pos.lat) && !isnan(context->gotoc.pos.lon)) {
    char str[16];
    gpx_pos_get_distance_str(str, sizeof(str), 
                             *pos, context->gotoc.pos, 
                             context->appdata->imperial);
    gtk_label_set_text(GTK_LABEL(context->gotoc.distance_label), str);

    snprintf(str, sizeof(str), _("%.1f°"), 
             gpx_pos_get_bearing(*pos,  context->gotoc.pos));
    gtk_label_set_text(GTK_LABEL(context->gotoc.bearing_label), str);
  } else {
    gtk_label_set_text(GTK_LABEL(context->gotoc.distance_label), "-----");
    gtk_label_set_text(GTK_LABEL(context->gotoc.bearing_label), "-----");
  }

  float eph = gps_get_eph(context->appdata);
  if(isnan(eph))
    gtk_label_set_text(GTK_LABEL(context->gotoc.eph_label), "-----");
  else {
    char str[16];
    /* distance needs to be given in km */
    if(context->appdata->imperial)
      eph /= (6371.0/3959.0);  // km to miles

    distance_str(str, sizeof(str), eph/1000.0, context->appdata->imperial);
    gtk_label_set_text(GTK_LABEL(context->gotoc.eph_label), str);
  }

  return TRUE;   // fire again
}

static gboolean compass_clicked_event(GtkWidget *widget, GdkEventButton *event,
                            gpointer user_data) {
  cache_context_t *context = (cache_context_t*)user_data;

  context->appdata->compass_locked = !context->appdata->compass_locked;

  printf("compass is now %slocked\n", 
         context->appdata->compass_locked?"":"un");

  if(context->gotoc.compass_pixmap) {
    /* draw compass */
    compass_draw(context->gotoc.compass_area, context);
    gtk_widget_queue_draw_area(context->gotoc.compass_area, 0,0,
                               context->gotoc.compass_area->allocation.width, 
                               context->gotoc.compass_area->allocation.height);
  }
  return FALSE;
}

static void pos_modified(GtkWidget *widget, gpointer data ) {
  cache_context_t *context = (cache_context_t*)data;

  /* extract position from entries */
  context->gotoc.pos.lat = lat_entry_get(context->gotoc.lat_entry);
  context->gotoc.pos.lon = lon_entry_get(context->gotoc.lon_entry);

  goto_update(context);
}

#ifdef ESPEAK
static void espeak_clicked(GtkWidget *widget, gpointer data) {
  cache_context_t *context = (cache_context_t*)data;

  GtkWidget *icon = gtk_button_get_image(GTK_BUTTON(widget));
  gtk_widget_destroy(icon);
  context->appdata->espeak.enabled = !context->appdata->espeak.enabled;
  gtk_button_set_image(GTK_BUTTON(widget), icon_get_widget(ICON_MISC, 
                       context->appdata->espeak.enabled?6:7));

  espeak_enable(context, context->appdata->espeak.enabled);
}
#endif

/* create "goto" tab */
GtkWidget *goto_cache(cache_context_t *context) {
  int i;

  /* clear list used for averaging */
  for(i=0;i<MAX_AVERAGE;i++)
    context->gotoc.head_avg[i] = NAN;

  context->gotoc.pos = gpx_cache_pos(context->cache);

  GtkWidget *hbox = portrait_box_new(FALSE, 32);

  context->gotoc.compass_area = gtk_drawing_area_new();
  gtk_drawing_area_size(GTK_DRAWING_AREA(context->gotoc.compass_area), 
                        COMPASS_SIZE, COMPASS_SIZE);

  gtk_signal_connect(GTK_OBJECT(context->gotoc.compass_area), "expose_event",
                     (GtkSignalFunc)compass_expose_event, context);
  gtk_signal_connect(GTK_OBJECT(context->gotoc.compass_area),"configure_event",
                     (GtkSignalFunc)compass_configure_event, context);
  gtk_signal_connect(GTK_OBJECT(context->gotoc.compass_area),
                     "button_press_event",
                     (GtkSignalFunc)compass_clicked_event, context);

  gtk_widget_set_events(context->gotoc.compass_area, GDK_EXPOSURE_MASK);
  gtk_widget_add_events(context->gotoc.compass_area, GDK_BUTTON_PRESS_MASK);
  gtk_box_pack_start_defaults(GTK_BOX(hbox), context->gotoc.compass_area);

  GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
  GtkWidget *table = gtk_table_new(5, 3, FALSE);

  /* ---------- destination coordinates ------- */

  /* SIZE_SMALL doesn't work here as setting the label returns to normal */
  gtk_table_attach_defaults(GTK_TABLE(table), left_label_new(_("Latitude:")), 0,1,0,1);
  context->gotoc.lat_entry = lat_entry_new(context->gotoc.pos.lat);
  gtk_table_attach_defaults(GTK_TABLE(table), context->gotoc.lat_entry, 1,2,0,1);
  gtk_table_attach_defaults(GTK_TABLE(table), left_label_new(_("Longitude:")), 0,1,1,2);
  context->gotoc.lon_entry = lon_entry_new(context->gotoc.pos.lon);
  gtk_table_attach_defaults(GTK_TABLE(table), context->gotoc.lon_entry, 1,2,1,2);

  g_signal_connect(G_OBJECT(context->gotoc.lat_entry), "changed", 
                   G_CALLBACK(pos_modified), context);
  g_signal_connect(G_OBJECT(context->gotoc.lon_entry), "changed", 
                   G_CALLBACK(pos_modified), context);

  gtk_table_attach_defaults(GTK_TABLE(table), preset_coordinate_picker(context->appdata, 
               context->gotoc.lat_entry, context->gotoc.lon_entry), 2,3,0,1);

  gtk_table_attach_defaults(GTK_TABLE(table), goto_coordinate(context->appdata, 
                    context->gotoc.lat_entry, context->gotoc.lon_entry), 2,3,1,2);

  gtk_table_set_row_spacing(GTK_TABLE(table), 1, 16);
  gtk_table_set_col_spacing(GTK_TABLE(table), 0, 16);

  /* -------------- distance label ------------------------- */
  gtk_table_attach_defaults(GTK_TABLE(table), left_label_new(_("Distance:")), 0,1,2,3);
  gtk_table_attach_defaults(GTK_TABLE(table),
            (context->gotoc.distance_label = gtk_label_new("-----")), 1,2,2,3);

  /* -------------- bearing label ------------------------- */
  gtk_table_attach_defaults(GTK_TABLE(table), left_label_new(_("Bearing:")), 0,1,3,4);
  gtk_table_attach_defaults(GTK_TABLE(table),
            (context->gotoc.bearing_label = gtk_label_new("-----")), 1,2,3,4);

  /* -------------- error label ------------------------- */
  gtk_table_attach_defaults(GTK_TABLE(table), left_label_new(_("Est. error:")), 0,1,4,5);
  gtk_table_attach_defaults(GTK_TABLE(table),
            (context->gotoc.eph_label = gtk_label_new("-----")), 1,2,4,5);

  gtk_table_set_row_spacing(GTK_TABLE(table), 4, 16);

  /* -------------- sat view box ------------------------- */
  GtkWidget *ihbox = gtk_hbox_new(FALSE,0);

  context->gotoc.sat_area = gtk_drawing_area_new();
  gtk_drawing_area_size(GTK_DRAWING_AREA(context->gotoc.sat_area), 
                        SAT_WIDTH, SAT_HEIGHT);

  gtk_signal_connect(GTK_OBJECT(context->gotoc.sat_area), "expose_event",
                     (GtkSignalFunc)sat_expose_event, context);
  gtk_signal_connect(GTK_OBJECT(context->gotoc.sat_area),"configure_event",
                     (GtkSignalFunc)sat_configure_event, context);

  gtk_widget_set_events(context->gotoc.sat_area, GDK_EXPOSURE_MASK);

  gtk_box_pack_start(GTK_BOX(ihbox), context->gotoc.sat_area, 1,0,0);

#ifdef ESPEAK
  GtkWidget *ivbox = gtk_vbox_new(FALSE, 0);
  GtkWidget *button = button_new();
  gtk_button_set_image(GTK_BUTTON(button), icon_get_widget(ICON_MISC, 
                       context->appdata->espeak.enabled?6:7));
  gtk_signal_connect (GTK_OBJECT(button), "clicked", 
                      GTK_SIGNAL_FUNC(espeak_clicked), context);
  if(context->appdata->espeak.sample_rate < 0)
    gtk_widget_set_sensitive(button, FALSE);
  else
    if(context->appdata->espeak.enabled)
      espeak_enable(context, TRUE);

  gtk_box_pack_start(GTK_BOX(ivbox), button, 1,0,0);
  gtk_box_pack_start(GTK_BOX(ihbox), ivbox, 1,0,0);
#endif

  gtk_table_attach_defaults(GTK_TABLE(table), ihbox, 0,3,5,6);

  /* ------------------------------------------------------- */

  gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, FALSE, 0);
  gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
 
  context->gotoc.handler_id = 
    gtk_timeout_add(UPDATE_MS, goto_update, context);

  return hbox;
}

void goto_coordinate_update(cache_context_t *context) {
  static pos_t pos = { 0.0, 0.0 };

  if(!context->notes.modified)
    return;

  pos_t npos = notes_get_pos(context);
  if(pos_differ(&npos, &pos)) {
    pos = npos;

    lat_entry_set(context->gotoc.lat_entry, npos.lat);
    lon_entry_set(context->gotoc.lon_entry, npos.lon);
  }
}