+ vik_trw_layer_delete_all_routes ( vgl-> trw_children[TRW_DOWNLOAD]);
+#if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
+ vik_trw_layer_delete_all_waypoints ( vgl-> trw_children[TRW_REALTIME]);
+ vik_trw_layer_delete_all_tracks ( vgl-> trw_children[TRW_REALTIME]);
+#endif
+}
+
+#if defined (VIK_CONFIG_REALTIME_GPS_TRACKING) && defined (GPSD_API_MAJOR_VERSION)
+static void realtime_tracking_draw(VikGpsLayer *vgl, VikViewport *vp)
+{
+ struct LatLon ll;
+ VikCoord nw, se;
+ struct LatLon lnw, lse;
+ vik_viewport_screen_to_coord ( vp, -20, -20, &nw );
+ vik_viewport_screen_to_coord ( vp, vik_viewport_get_width(vp)+20, vik_viewport_get_width(vp)+20, &se );
+ vik_coord_to_latlon ( &nw, &lnw );
+ vik_coord_to_latlon ( &se, &lse );
+ if ( vgl->realtime_fix.fix.latitude > lse.lat &&
+ vgl->realtime_fix.fix.latitude < lnw.lat &&
+ vgl->realtime_fix.fix.longitude > lnw.lon &&
+ vgl->realtime_fix.fix.longitude < lse.lon ) {
+ VikCoord gps;
+ gint x, y;
+ gint half_back_x, half_back_y;
+ gint half_back_bg_x, half_back_bg_y;
+ gint pt_x, pt_y;
+ gint ptbg_x;
+ gint side1_x, side1_y, side2_x, side2_y;
+ gint side1bg_x, side1bg_y, side2bg_x, side2bg_y;
+
+ ll.lat = vgl->realtime_fix.fix.latitude;
+ ll.lon = vgl->realtime_fix.fix.longitude;
+ vik_coord_load_from_latlon ( &gps, vik_viewport_get_coord_mode(vp), &ll);
+ vik_viewport_coord_to_screen ( vp, &gps, &x, &y );
+
+ gdouble heading_cos = cos(DEG2RAD(vgl->realtime_fix.fix.track));
+ gdouble heading_sin = sin(DEG2RAD(vgl->realtime_fix.fix.track));
+
+ half_back_y = y+8*heading_cos;
+ half_back_x = x-8*heading_sin;
+ half_back_bg_y = y+10*heading_cos;
+ half_back_bg_x = x-10*heading_sin;
+
+ pt_y = half_back_y-24*heading_cos;
+ pt_x = half_back_x+24*heading_sin;
+ //ptbg_y = half_back_bg_y-28*heading_cos;
+ ptbg_x = half_back_bg_x+28*heading_sin;
+
+ side1_y = half_back_y+9*heading_sin;
+ side1_x = half_back_x+9*heading_cos;
+ side1bg_y = half_back_bg_y+11*heading_sin;
+ side1bg_x = half_back_bg_x+11*heading_cos;
+
+ side2_y = half_back_y-9*heading_sin;
+ side2_x = half_back_x-9*heading_cos;
+ side2bg_y = half_back_bg_y-11*heading_sin;
+ side2bg_x = half_back_bg_x-11*heading_cos;
+
+ GdkPoint trian[3] = { { pt_x, pt_y }, {side1_x, side1_y}, {side2_x, side2_y} };
+ GdkPoint trian_bg[3] = { { ptbg_x, pt_y }, {side1bg_x, side1bg_y}, {side2bg_x, side2bg_y} };
+
+ vik_viewport_draw_polygon ( vp, vgl->realtime_track_bg_gc, TRUE, trian_bg, 3 );
+ vik_viewport_draw_polygon ( vp, vgl->realtime_track_gc, TRUE, trian, 3 );
+ vik_viewport_draw_rectangle ( vp,
+ (vgl->realtime_fix.fix.mode > MODE_2D) ? vgl->realtime_track_pt2_gc : vgl->realtime_track_pt1_gc,
+ TRUE, x-2, y-2, 4, 4 );
+ //vgl->realtime_track_pt_gc = (vgl->realtime_track_pt_gc == vgl->realtime_track_pt1_gc) ? vgl->realtime_track_pt2_gc : vgl->realtime_track_pt1_gc;
+ }
+}
+
+static void create_realtime_trackpoint(VikGpsLayer *vgl, gboolean forced)
+{
+ struct LatLon ll;
+ GList *last_tp;
+
+ /* Note that fix.time is a double, but it should not affect the precision
+ for most GPS */
+ time_t cur_timestamp = vgl->realtime_fix.fix.time;
+ time_t last_timestamp = vgl->last_fix.fix.time;
+
+ if (cur_timestamp < last_timestamp) {
+ return;
+ }
+
+ if (vgl->realtime_record && vgl->realtime_fix.dirty) {
+ gboolean replace = FALSE;
+ int heading = (int)floor(vgl->realtime_fix.fix.track);
+ int last_heading = (int)floor(vgl->last_fix.fix.track);
+ int alt = isnan(vgl->realtime_fix.fix.altitude) ? VIK_DEFAULT_ALTITUDE : floor(vgl->realtime_fix.fix.altitude);
+ int last_alt = isnan(vgl->last_fix.fix.altitude) ? VIK_DEFAULT_ALTITUDE : floor(vgl->last_fix.fix.altitude);
+ if (((last_tp = g_list_last(vgl->realtime_track->trackpoints)) != NULL) &&
+ (vgl->realtime_fix.fix.mode > MODE_2D) &&
+ (vgl->last_fix.fix.mode <= MODE_2D) &&
+ ((cur_timestamp - last_timestamp) < 2)) {
+ g_free(last_tp->data);
+ vgl->realtime_track->trackpoints = g_list_delete_link(vgl->realtime_track->trackpoints, last_tp);
+ replace = TRUE;
+ }
+ if (replace ||
+ ((cur_timestamp != last_timestamp) &&
+ ((forced ||
+ ((heading < last_heading) && (heading < (last_heading - 3))) ||
+ ((heading > last_heading) && (heading > (last_heading + 3))) ||
+ ((alt != VIK_DEFAULT_ALTITUDE) && (alt != last_alt)))))) {
+ /* TODO: check for new segments */
+ VikTrackpoint *tp = vik_trackpoint_new();
+ tp->newsegment = FALSE;
+ tp->has_timestamp = TRUE;
+ tp->timestamp = vgl->realtime_fix.fix.time;
+ tp->altitude = alt;
+ /* speed only available for 3D fix. Check for NAN when use this speed */
+ tp->speed = vgl->realtime_fix.fix.speed;
+ tp->course = vgl->realtime_fix.fix.track;
+ tp->nsats = vgl->realtime_fix.satellites_used;
+ tp->fix_mode = vgl->realtime_fix.fix.mode;
+
+ ll.lat = vgl->realtime_fix.fix.latitude;
+ ll.lon = vgl->realtime_fix.fix.longitude;
+ vik_coord_load_from_latlon(&tp->coord,
+ vik_trw_layer_get_coord_mode(vgl->trw_children[TRW_REALTIME]), &ll);
+
+ vgl->realtime_track->trackpoints = g_list_append(vgl->realtime_track->trackpoints, tp);
+ vgl->realtime_fix.dirty = FALSE;
+ vgl->realtime_fix.satellites_used = 0;
+ vgl->last_fix = vgl->realtime_fix;
+ }
+ }
+
+}
+
+static void gpsd_raw_hook(VglGpsd *vgpsd, gchar *data)
+{
+ gboolean update_all = FALSE;
+ VikGpsLayer *vgl = vgpsd->vgl;
+
+ if (!vgl->realtime_tracking) {
+ g_warning("%s: receiving GPS data while not in realtime mode", __PRETTY_FUNCTION__);
+ return;
+ }
+
+ if ((vgpsd->gpsd.fix.mode >= MODE_2D) &&
+ !isnan(vgpsd->gpsd.fix.latitude) &&
+ !isnan(vgpsd->gpsd.fix.longitude) &&
+ !isnan(vgpsd->gpsd.fix.track)) {
+
+ VikWindow *vw = VIK_WINDOW(VIK_GTK_WINDOW_FROM_LAYER(vgl));
+ VikViewport *vvp = vik_window_viewport(vw);
+ vgl->realtime_fix.fix = vgpsd->gpsd.fix;
+ vgl->realtime_fix.satellites_used = vgpsd->gpsd.satellites_used;
+ vgl->realtime_fix.dirty = TRUE;
+
+ struct LatLon ll;
+ VikCoord vehicle_coord;
+
+ ll.lat = vgl->realtime_fix.fix.latitude;
+ ll.lon = vgl->realtime_fix.fix.longitude;
+ vik_coord_load_from_latlon(&vehicle_coord,
+ vik_trw_layer_get_coord_mode(vgl->trw_children[TRW_REALTIME]), &ll);
+
+ if ((vgl->vehicle_position == VEHICLE_POSITION_CENTERED) ||
+ (vgl->realtime_jump_to_start && vgl->first_realtime_trackpoint)) {
+ vik_viewport_set_center_coord(vvp, &vehicle_coord);
+ update_all = TRUE;
+ }
+ else if (vgl->vehicle_position == VEHICLE_POSITION_ON_SCREEN) {
+ const int hdiv = 6;
+ const int vdiv = 6;
+ const int px = 20; /* adjust ment in pixels to make sure vehicle is inside the box */
+ gint width = vik_viewport_get_width(vvp);
+ gint height = vik_viewport_get_height(vvp);
+ gint vx, vy;
+
+ vik_viewport_coord_to_screen(vvp, &vehicle_coord, &vx, &vy);
+ update_all = TRUE;
+ if (vx < (width/hdiv))
+ vik_viewport_set_center_screen(vvp, vx - width/2 + width/hdiv + px, vy);
+ else if (vx > (width - width/hdiv))
+ vik_viewport_set_center_screen(vvp, vx + width/2 - width/hdiv - px, vy);
+ else if (vy < (height/vdiv))
+ vik_viewport_set_center_screen(vvp, vx, vy - height/2 + height/vdiv + px);
+ else if (vy > (height - height/vdiv))
+ vik_viewport_set_center_screen(vvp, vx, vy + height/2 - height/vdiv - px);
+ else
+ update_all = FALSE;
+ }
+
+ vgl->first_realtime_trackpoint = FALSE;
+ create_realtime_trackpoint(vgl, FALSE);
+
+ vik_layer_emit_update ( update_all ? VIK_LAYER(vgl) : VIK_LAYER(vgl->trw_children[TRW_REALTIME]) ); // NB update from background thread
+ }
+}
+
+static gboolean gpsd_data_available(GIOChannel *source, GIOCondition condition, gpointer data)
+{
+ VikGpsLayer *vgl = data;
+ if (condition == G_IO_IN) {
+#if GPSD_API_MAJOR_VERSION == 3 || GPSD_API_MAJOR_VERSION == 4
+ if (!gps_poll(&vgl->vgpsd->gpsd)) {
+#elif GPSD_API_MAJOR_VERSION == 5
+ if (gps_read(&vgl->vgpsd->gpsd) > -1) {
+ // Reuse old function to perform operations on the new GPS data
+ gpsd_raw_hook(vgl->vgpsd, NULL);
+#else
+ // Broken compile
+#endif
+ return TRUE;
+ }
+ else {
+ g_warning("Disconnected from gpsd. Trying to reconnect");
+ rt_gpsd_disconnect(vgl);
+ rt_gpsd_connect(vgl, FALSE);
+ }
+ }
+ return FALSE; /* no further calling */
+}
+
+static gchar *make_track_name(VikTrwLayer *vtl)
+{
+ const gchar basename[] = "REALTIME";
+ const gint bufsize = sizeof(basename) + 5;
+ gchar *name = g_malloc(bufsize);
+ strcpy(name, basename);
+ gint i = 2;
+
+ while (vik_trw_layer_get_track(vtl, name) != NULL) {
+ g_snprintf(name, bufsize, "%s#%d", basename, i);
+ i++;
+ }
+ return(name);
+
+}
+
+static gboolean rt_gpsd_try_connect(gpointer *data)
+{
+ VikGpsLayer *vgl = (VikGpsLayer *)data;
+#if GPSD_API_MAJOR_VERSION == 3
+ struct gps_data_t *gpsd = gps_open(vgl->gpsd_host, vgl->gpsd_port);
+
+ if (gpsd == NULL) {
+#elif GPSD_API_MAJOR_VERSION == 4
+ vgl->vgpsd = g_malloc(sizeof(VglGpsd));
+
+ if (gps_open_r(vgl->gpsd_host, vgl->gpsd_port, /*(struct gps_data_t *)*/vgl->vgpsd) != 0) {
+#elif GPSD_API_MAJOR_VERSION == 5
+ vgl->vgpsd = g_malloc(sizeof(VglGpsd));
+ if (gps_open(vgl->gpsd_host, vgl->gpsd_port, &vgl->vgpsd->gpsd) != 0) {
+#else
+// Delibrately break compilation...
+#endif
+ g_warning("Failed to connect to gpsd at %s (port %s). Will retry in %d seconds",
+ vgl->gpsd_host, vgl->gpsd_port, vgl->gpsd_retry_interval);
+ return TRUE; /* keep timer running */
+ }
+
+#if GPSD_API_MAJOR_VERSION == 3
+ vgl->vgpsd = realloc(gpsd, sizeof(VglGpsd));
+#endif
+ vgl->vgpsd->vgl = vgl;
+
+ vgl->realtime_fix.dirty = vgl->last_fix.dirty = FALSE;
+ /* track alt/time graph uses VIK_DEFAULT_ALTITUDE (0.0) as invalid */
+ vgl->realtime_fix.fix.altitude = vgl->last_fix.fix.altitude = VIK_DEFAULT_ALTITUDE;
+ vgl->realtime_fix.fix.speed = vgl->last_fix.fix.speed = NAN;
+
+ if (vgl->realtime_record) {
+ VikTrwLayer *vtl = vgl->trw_children[TRW_REALTIME];
+ vgl->realtime_track = vik_track_new();
+ vgl->realtime_track->visible = TRUE;
+ vik_trw_layer_add_track(vtl, make_track_name(vtl), vgl->realtime_track);
+ }
+
+#if GPSD_API_MAJOR_VERSION == 3 || GPSD_API_MAJOR_VERSION == 4
+ gps_set_raw_hook(&vgl->vgpsd->gpsd, gpsd_raw_hook);
+#endif
+
+ vgl->realtime_io_channel = g_io_channel_unix_new(vgl->vgpsd->gpsd.gps_fd);
+ vgl->realtime_io_watch_id = g_io_add_watch( vgl->realtime_io_channel,
+ G_IO_IN | G_IO_ERR | G_IO_HUP, gpsd_data_available, vgl);
+
+#if GPSD_API_MAJOR_VERSION == 3
+ gps_query(&vgl->vgpsd->gpsd, "w+x");
+#endif
+#if GPSD_API_MAJOR_VERSION == 4 || GPSD_API_MAJOR_VERSION == 5
+ gps_stream(&vgl->vgpsd->gpsd, WATCH_ENABLE, NULL);
+#endif
+
+ return FALSE; /* no longer called by timeout */
+}
+
+static gboolean rt_ask_retry(VikGpsLayer *vgl)
+{
+ GtkWidget *dialog = gtk_message_dialog_new (VIK_GTK_WINDOW_FROM_LAYER(vgl),
+ GTK_DIALOG_DESTROY_WITH_PARENT,
+ GTK_MESSAGE_QUESTION,
+ GTK_BUTTONS_YES_NO,
+ "Failed to connect to gpsd at %s (port %s)\n"
+ "Should Viking keep trying (every %d seconds)?",
+ vgl->gpsd_host, vgl->gpsd_port,
+ vgl->gpsd_retry_interval);
+
+ gint res = gtk_dialog_run(GTK_DIALOG(dialog));
+ gtk_widget_destroy(dialog);
+ return (res == GTK_RESPONSE_YES);
+}
+
+static gboolean rt_gpsd_connect(VikGpsLayer *vgl, gboolean ask_if_failed)
+{
+ vgl->realtime_retry_timer = 0;
+ if (rt_gpsd_try_connect((gpointer *)vgl)) {
+ if (vgl->gpsd_retry_interval <= 0) {
+ g_warning("Failed to connect to gpsd but will not retry because retry intervel was set to %d (which is 0 or negative)", vgl->gpsd_retry_interval);
+ return FALSE;
+ }
+ else if (ask_if_failed && !rt_ask_retry(vgl))
+ return FALSE;
+ else
+ vgl->realtime_retry_timer = g_timeout_add_seconds(vgl->gpsd_retry_interval,
+ (GSourceFunc)rt_gpsd_try_connect, (gpointer *)vgl);
+ }
+ return TRUE;
+}
+
+static void rt_gpsd_disconnect(VikGpsLayer *vgl)
+{
+ if (vgl->realtime_retry_timer) {
+ g_source_remove(vgl->realtime_retry_timer);
+ vgl->realtime_retry_timer = 0;
+ }
+ if (vgl->realtime_io_watch_id) {
+ g_source_remove(vgl->realtime_io_watch_id);
+ vgl->realtime_io_watch_id = 0;
+ }
+ if (vgl->realtime_io_channel) {
+ GError *error = NULL;
+ g_io_channel_shutdown (vgl->realtime_io_channel, FALSE, &error);
+ vgl->realtime_io_channel = NULL;
+ }
+ if (vgl->vgpsd) {
+#if GPSD_API_MAJOR_VERSION == 4 || GPSD_API_MAJOR_VERSION == 5
+ gps_stream(&vgl->vgpsd->gpsd, WATCH_DISABLE, NULL);
+#endif
+ gps_close(&vgl->vgpsd->gpsd);
+#if GPSD_API_MAJOR_VERSION == 3
+ free(vgl->vgpsd);
+#elif GPSD_API_MAJOR_VERSION == 4 || GPSD_API_MAJOR_VERSION == 5
+ g_free(vgl->vgpsd);
+#endif
+ vgl->vgpsd = NULL;
+ }
+
+ if (vgl->realtime_record && vgl->realtime_track) {
+ if ((vgl->realtime_track->trackpoints == NULL) || (vgl->realtime_track->trackpoints->next == NULL))
+ vik_trw_layer_delete_track(vgl->trw_children[TRW_REALTIME], vgl->realtime_track);
+ vgl->realtime_track = NULL;
+ }
+}
+
+static void gps_start_stop_tracking_cb( gpointer layer_and_vlp[2])
+{
+ VikGpsLayer *vgl = (VikGpsLayer *)layer_and_vlp[0];
+ vgl->realtime_tracking = (vgl->realtime_tracking == FALSE);
+
+ /* Make sure we are still in the boat with libgps */
+ g_assert((VIK_GPS_MODE_2D == MODE_2D) && (VIK_GPS_MODE_3D == MODE_3D));
+
+ if (vgl->realtime_tracking) {
+ vgl->first_realtime_trackpoint = TRUE;
+ if (!rt_gpsd_connect(vgl, TRUE)) {
+ vgl->first_realtime_trackpoint = FALSE;
+ vgl->realtime_tracking = FALSE;
+ }
+ }
+ else { /* stop realtime tracking */
+ vgl->first_realtime_trackpoint = FALSE;
+ rt_gpsd_disconnect(vgl);
+ }
projects / andy / viking.git / blobdiff