From: Adam Boggs Date: Tue, 7 Feb 2012 05:18:32 +0000 (-0700) Subject: Incorporate code review feedback and some minor fixes. X-Git-Url: http://pileus.org/git/?p=aweather;a=commitdiff_plain;h=79413a5b39489d4350bca6f870f50e154f07fadb Incorporate code review feedback and some minor fixes. Fixed indentation to tabs, use g_assert and guint/gchar/etc. Added car and arrow icons for the gps marker and fix Makefile.am to install them. Change gps_state to simply gps. Add gps marker search path so it looks in "." as well as installed location. --- diff --git a/configure.ac b/configure.ac index 7223877..c66b285 100644 --- a/configure.ac +++ b/configure.ac @@ -17,23 +17,13 @@ PKG_CHECK_MODULES(GLIB, glib-2.0) PKG_CHECK_MODULES(GRITS, grits >= 0.6) # Check for gpsd support -AC_ARG_WITH([gps], AS_HELP_STRING([--with-gps], [Build with gpsd support])) - -if test "x$with_gps" = "xyes"; then - PKG_CHECK_MODULES(GPSD, libgps >= 3.0) +AC_ARG_ENABLE([gps], AS_HELP_STRING([--enable-gps], [Build with gpsd support]), + [PKG_CHECK_MODULES(GPSD, libgps >= 3.0) AC_DEFINE([HAVE_GPSD], [], [Have GPSD support]) - AC_SUBST(HAVE_GPSD, [TRUE]) -fi + AC_SUBST(HAVE_GPSD, [TRUE])] +) AM_CONDITIONAL([HAVE_GPSD], test "$HAVE_GPSD" = "TRUE") -# PKG_CHECK_MODULES(GPSD, libgps >= 3.0) -#AC_ARG_WITH([gps], AS_HELP_STRING([--with-gps], [Build with gpsd support])) -#AS_IF([test "x$with_gps" = "xyes"], [ -# PKG_CHECK_MODULES([GPSD], [libgps >= 3.0], -# [AC_DEFINE([HAVE_GPSD], [1], [Use GPSD])], -# [AC_DEFINE([HAVE_GPSD], [0], [No GPSD])] -# ]) - # Define odd RSL install location AC_CHECK_LIB(rsl, RSL_wsr88d_to_radar, RSL_LIBS="-lrsl") AM_CONDITIONAL(HAVE_RSL, test "$RSL_LIBS" != "") diff --git a/data/Makefile.am b/data/Makefile.am index a778609..7a0e964 100644 --- a/data/Makefile.am +++ b/data/Makefile.am @@ -10,6 +10,9 @@ dist_fips_DATA = fips.txt logodir = $(datadir)/aweather/ dist_logo_DATA = logo.svg +icondir = $(datadir)/aweather/ +dist_icon_DATA = car.png arrow.png + colordir = $(datadir)/aweather/colors/ dist_color_DATA = colors/*.clr diff --git a/data/arrow.png b/data/arrow.png new file mode 100644 index 0000000..5d42268 Binary files /dev/null and b/data/arrow.png differ diff --git a/car.png b/data/car.png similarity index 100% rename from car.png rename to data/car.png diff --git a/src/plugins/gps-plugin.c b/src/plugins/gps-plugin.c index cb12807..2b6265d 100644 --- a/src/plugins/gps-plugin.c +++ b/src/plugins/gps-plugin.c @@ -26,7 +26,6 @@ #include #include #include -#include #include #include #include @@ -43,6 +42,10 @@ /* interval to update map with new gps data in seconds. */ #define GPS_UPDATE_INTERVAL (2) +/* Filename and search path to use for gps marker, should be configurable */ +#define GPS_MARKER_ICON_PATH ".:" PKGDATADIR +#define GPS_MARKER_ICON "arrow.png" + /* number of track points per group and number of groups to maintain */ #define NUM_TRACK_POINTS (6) #define NUM_TRACK_GROUPS (4) @@ -55,304 +58,322 @@ /* For updating the status bar conveniently */ #define GPS_STATUSBAR_CONTEXT "GPS" #if 0 -#define GPS_STATUS(gps_state, format, args...) \ - do { \ - char *buf = g_strdup_printf(format, ##args); \ - gtk_statusbar_push(GTK_STATUSBAR(gps_state->status_bar), \ - gtk_statusbar_get_context_id( \ - GTK_STATUSBAR(gps_state->status_bar), \ - GPS_STATUSBAR_CONTEXT), \ - buf); \ - } while (0) +#define GPS_STATUS(gps, format, args...) \ + do { \ + gchar *buf = g_strdup_printf(format, ##args); \ + gtk_statusbar_push(GTK_STATUSBAR(gps->status_bar), \ + gtk_statusbar_get_context_id( \ + GTK_STATUSBAR(gps->status_bar), \ + GPS_STATUSBAR_CONTEXT), \ + buf); \ + } while (0) #endif -#define GPS_STATUS(gps_state, format, args...) \ - do { \ - char *buf = g_strdup_printf(format, ##args); \ - g_debug("STATUS: %s", buf); \ - } while (0) +#define GPS_STATUS(gps, format, args...) \ + do { \ + gchar *buf = g_strdup_printf(format, ##args); \ + g_debug("STATUS: %s", buf); \ + } while (0) static gboolean gps_data_is_valid(struct gps_data_t *gps_data); -static char *gps_get_time_string(time_t gps_time); -static char *gps_get_date_string(double gps_time); +static gchar *gps_get_time_string(time_t gps_time); +static gchar *gps_get_date_string(double gps_time); static void process_gps( gpointer, gint, GdkInputCondition); #ifdef GPS_RANGE_RINGS -static void gps_init_range_rings(GritsPluginGPS *gps_state, - GtkWidget *gbox); -static gboolean on_gps_rangering_clicked_event (GtkWidget *widget, gpointer user_data); +static void gps_init_range_rings(GritsPluginGps *gps, GtkWidget *gbox); +static gboolean on_gps_rangering_clicked_event(GtkWidget *widget, gpointer user_data); #endif -static void gps_init_status_info(GritsPluginGPS *gps_state, - GtkWidget *gbox); -static void gps_init_control_frame(GritsPluginGPS *gps_state, - GtkWidget *gbox); -static gboolean on_gps_follow_clicked_event (GtkWidget *widget, gpointer user_data); +static void gps_init_status_info(GritsPluginGps *gps, GtkWidget *gbox); +static void gps_init_control_frame(GritsPluginGps *gps, GtkWidget *gbox); +static gboolean on_gps_follow_clicked_event(GtkWidget *widget, gpointer user_data); /* GPS logging support */ -static void gps_init_track_log_frame(GritsPluginGPS *gps_state, - GtkWidget *gbox); -static gboolean on_gps_log_clicked_event (GtkWidget *widget, gpointer user_data); +static void gps_init_track_log_frame(GritsPluginGps *gps, GtkWidget *gbox); +static gboolean on_gps_log_clicked_event(GtkWidget *widget, gpointer user_data); /* Track management */ static void gps_track_init(struct gps_track_t *track); static void gps_track_free(struct gps_track_t *track); static void gps_track_clear(struct gps_track_t *track); -static void gps_track_add_point(struct gps_track_t *track, gdouble lat, gdouble lon, gdouble elevation); +static void gps_track_add_point(struct gps_track_t *track, gdouble lat, + gdouble lon, gdouble elevation); static void gps_track_group_incr(struct gps_track_t *track); -static gboolean on_gps_track_enable_clicked_event(GtkWidget *widget, gpointer user_data); -static gboolean on_gps_track_clear_clicked_event(GtkWidget *widget, gpointer user_data); +static gboolean on_gps_track_enable_clicked_event(GtkWidget *widget, + gpointer user_data); +static gboolean on_gps_track_clear_clicked_event(GtkWidget *widget, + gpointer user_data); static gboolean gps_write_log(gpointer data); -static char *gps_get_status(struct gps_data_t *); -static char *gps_get_latitude(struct gps_data_t *); -static char *gps_get_longitude(struct gps_data_t *); -static char *gps_get_elevation(struct gps_data_t *); -static char *gps_get_heading(struct gps_data_t *); -static char *gps_get_speed(struct gps_data_t *); +static gchar *gps_get_status(struct gps_data_t *); +static gchar *gps_get_latitude(struct gps_data_t *); +static gchar *gps_get_longitude(struct gps_data_t *); +static gchar *gps_get_elevation(struct gps_data_t *); +static gchar *gps_get_heading(struct gps_data_t *); +static gchar *gps_get_speed(struct gps_data_t *); /* Describes a line in the gps table */ struct gps_status_info { - char *label; - char *initial_val; - char *(*get_data)(struct gps_data_t *); - unsigned int font_size; - GtkWidget *label_widget; - GtkWidget *value_widget; + gchar *label; + gchar *initial_val; + gchar *(*get_data)(struct gps_data_t *); + guint font_size; + GtkWidget *label_widget; + GtkWidget *value_widget; }; struct gps_status_info gps_table[] = { - {"Status:", "No Data", gps_get_status, 14, NULL, NULL}, -// {"Online:", "No Data", gps_get_online, 14, NULL, NULL}, - {"Latitude:", "No Data", gps_get_latitude, 14, NULL, NULL}, - {"Longitude:", "No Data", gps_get_longitude, 14, NULL, NULL}, - {"Elevation:", "No Data", gps_get_elevation, 14, NULL, NULL}, - {"Heading:", "No Data", gps_get_heading, 14, NULL, NULL}, - {"Speed:", "No Data", gps_get_speed, 14, NULL, NULL}, + {"Status:", "No Data", gps_get_status, 14, NULL, NULL}, +// {"Online:", "No Data", gps_get_online, 14, NULL, NULL}, + {"Latitude:", "No Data", gps_get_latitude, 14, NULL, NULL}, + {"Longitude:", "No Data", gps_get_longitude, 14, NULL, NULL}, + {"Elevation:", "No Data", gps_get_elevation, 14, NULL, NULL}, + {"Heading:", "No Data", gps_get_heading, 14, NULL, NULL}, + {"Speed:", "No Data", gps_get_speed, 14, NULL, NULL}, }; -static -gboolean gps_data_is_valid(struct gps_data_t *gps_data) +/* Find a readable file in a colon delimeted path */ +static gchar *find_path(const gchar *path, const gchar *filename) { - if (gps_data != NULL && gps_data->online != -1.0 && - gps_data->fix.mode >= MODE_2D && - gps_data->status > STATUS_NO_FIX) { - return TRUE; - } + gchar *end_ptr, *fullpath; + + end_ptr = (gchar *)path; - return FALSE; + /* find first : */ + while (*end_ptr != ':' && *end_ptr != '\0') + end_ptr++; + fullpath = g_strdup_printf("%.*s/%s", (int)(end_ptr-path), path, + filename); + g_debug("GritsPluginGps: find_path - searching %s", fullpath); + if (access(fullpath, R_OK) == 0) { + g_debug("GritsPluginGps: find_path - found %s", fullpath); + return fullpath; /* caller frees */ + } + + g_free(fullpath); + /* recurse */ + if (*end_ptr == '\0') { + return NULL; + } else { + return find_path(end_ptr + 1, filename); + } } -static char * -gps_get_date_string(double gps_time) +static gboolean gps_data_is_valid(struct gps_data_t *gps_data) { - static char buf[256]; - time_t int_time = (time_t)gps_time; - struct tm tm_time; + if (gps_data != NULL && gps_data->online != -1.0 && + gps_data->fix.mode >= MODE_2D && + gps_data->status > STATUS_NO_FIX) { + return TRUE; + } + + return FALSE; +} - gmtime_r(&int_time, &tm_time); +static gchar *gps_get_date_string(double gps_time) +{ + static gchar buf[256]; + time_t int_time = (time_t)gps_time; + struct tm tm_time; - snprintf(buf, sizeof(buf), "%04d-%02d-%02d", - tm_time.tm_year+1900, tm_time.tm_mon+1, tm_time.tm_mday); + gmtime_r(&int_time, &tm_time); + snprintf(buf, sizeof(buf), "%04d-%02d-%02d", + tm_time.tm_year+1900, tm_time.tm_mon+1, tm_time.tm_mday); - return buf; + return buf; } -static char * -gps_get_time_string(time_t gps_time) +static gchar *gps_get_time_string(time_t gps_time) { - static char buf[256]; - time_t int_time = (time_t)gps_time; - struct tm tm_time; + static gchar buf[256]; + time_t int_time = (time_t)gps_time; + struct tm tm_time; - gmtime_r(&int_time, &tm_time); + gmtime_r(&int_time, &tm_time); - snprintf(buf, sizeof(buf), "%02d:%02d:%02dZ", - tm_time.tm_hour, tm_time.tm_min, tm_time.tm_sec); + snprintf(buf, sizeof(buf), "%02d:%02d:%02dZ", + tm_time.tm_hour, tm_time.tm_min, tm_time.tm_sec); - return buf; + return buf; } -static void -update_gps_status(GritsPluginGPS *gps_state) +static void update_gps_status(GritsPluginGps *gps) { - struct gps_data_t *gps_data = &gps_state->gps_data; + struct gps_data_t *gps_data = &gps->gps_data; - /* gps table update */ - int i; - gchar *str; - for (i = 0; i < sizeof(gps_table)/sizeof(*gps_table); i++) { - gtk_label_set_markup (GTK_LABEL(gps_table[i].value_widget), - (str = gps_table[i].get_data(gps_data))); - g_free(str); - } + /* gps table update */ + gint i; + gchar *str; + for (i = 0; i < sizeof(gps_table)/sizeof(*gps_table); i++) { + gtk_label_set_markup (GTK_LABEL(gps_table[i].value_widget), + (str = gps_table[i].get_data(gps_data))); + g_free(str); + } } -static void -gps_init_control_frame(GritsPluginGPS *gps_state, GtkWidget *gbox) -{ - /* Control checkboxes */ - GtkWidget *gps_control_frame = gtk_frame_new("GPS Control"); - GtkWidget *cbox = gtk_vbox_new(FALSE, 2); - gtk_container_add(GTK_CONTAINER(gps_control_frame), cbox); - gtk_box_pack_start(GTK_BOX(gbox), gps_control_frame, FALSE, FALSE, 0); - - gps_state->ui.gps_follow_checkbox = gtk_check_button_new_with_label("Follow GPS"); - g_signal_connect(G_OBJECT(gps_state->ui.gps_follow_checkbox), "clicked", - G_CALLBACK (on_gps_follow_clicked_event), - (gpointer)gps_state); - gtk_box_pack_start(GTK_BOX(cbox), gps_state->ui.gps_follow_checkbox, - FALSE, FALSE, 0); - - gps_state->ui.gps_track_checkbox = gtk_check_button_new_with_label("Record Track"); - g_signal_connect(G_OBJECT(gps_state->ui.gps_track_checkbox), "clicked", - G_CALLBACK (on_gps_track_enable_clicked_event), - (gpointer)gps_state); - gtk_box_pack_start(GTK_BOX(cbox), gps_state->ui.gps_track_checkbox, - FALSE, FALSE, 0); +static void gps_init_control_frame(GritsPluginGps *gps, GtkWidget *gbox) +{ + /* Control checkboxes */ + GtkWidget *gps_control_frame = gtk_frame_new("GPS Control"); + GtkWidget *cbox = gtk_vbox_new(FALSE, 2); + gtk_container_add(GTK_CONTAINER(gps_control_frame), cbox); + gtk_box_pack_start(GTK_BOX(gbox), gps_control_frame, FALSE, FALSE, 0); + + gps->ui.gps_follow_checkbox = + gtk_check_button_new_with_label("Follow GPS"); + g_signal_connect(G_OBJECT(gps->ui.gps_follow_checkbox), "clicked", + G_CALLBACK (on_gps_follow_clicked_event), + (gpointer)gps); + gtk_box_pack_start(GTK_BOX(cbox), gps->ui.gps_follow_checkbox, + FALSE, FALSE, 0); + + gps->ui.gps_track_checkbox = + gtk_check_button_new_with_label("Record Track"); + g_signal_connect(G_OBJECT(gps->ui.gps_track_checkbox), "clicked", + G_CALLBACK (on_gps_track_enable_clicked_event), + (gpointer)gps); + gtk_box_pack_start(GTK_BOX(cbox), gps->ui.gps_track_checkbox, + FALSE, FALSE, 0); + + gps->ui.gps_clear_button = gtk_button_new_with_label("Clear Track"); + g_signal_connect(G_OBJECT(gps->ui.gps_clear_button), "clicked", + G_CALLBACK (on_gps_track_clear_clicked_event), + (gpointer)gps); + gtk_box_pack_start(GTK_BOX(cbox), gps->ui.gps_clear_button, + FALSE, FALSE, 0); +} + +static gboolean on_gps_track_enable_clicked_event(GtkWidget *widget, + gpointer user_data) +{ + GritsPluginGps *gps = (GritsPluginGps *)user_data; + + g_debug("GritsPluginGps: track_enable_clicked_event"); + + if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))) { + /* start logging trip history */ + GPS_STATUS(gps, "Enabled GPS track."); + gps->track.active = TRUE; + } else { + /* stop logging trip history */ + GPS_STATUS(gps, "Disabled GPS track."); + gps->track.active = FALSE; + /* advance to the next track group, moving everything down if + * it's full. + */ + gps_track_group_incr(&gps->track); + } - gps_state->ui.gps_clear_button = gtk_button_new_with_label("Clear Track"); - g_signal_connect(G_OBJECT(gps_state->ui.gps_clear_button), "clicked", - G_CALLBACK (on_gps_track_clear_clicked_event), - (gpointer)gps_state); - gtk_box_pack_start(GTK_BOX(cbox), gps_state->ui.gps_clear_button, - FALSE, FALSE, 0); + return FALSE; } -static gboolean -on_gps_track_enable_clicked_event(GtkWidget *widget, gpointer user_data) +static gboolean on_gps_track_clear_clicked_event(GtkWidget *widget, gpointer user_data) { - GritsPluginGPS *gps_state = (GritsPluginGPS *)user_data; + GritsPluginGps *gps = (GritsPluginGps *)user_data; - g_debug("on_gps_track_enable_clicked_event called"); + g_debug("GritsPluginGps: track_clear_clicked_event"); + GPS_STATUS(gps, "Cleared GPS track."); + gps_track_clear(&gps->track); - if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))) { - /* start logging trip history */ - GPS_STATUS(gps_state, "Enabled GPS track."); - gps_state->track.active = TRUE; - } else { - /* stop logging trip history */ - GPS_STATUS(gps_state, "Disabled GPS track."); - gps_state->track.active = FALSE; - /* advance to the next track group, moving everything down if - * it's full. - */ - gps_track_group_incr(&gps_state->track); - } - - return FALSE; + return FALSE; } -static gboolean -on_gps_track_clear_clicked_event(GtkWidget *widget, gpointer user_data) +static gboolean on_gps_log_interval_changed_event(GtkWidget *widget, + gpointer user_data) { - GritsPluginGPS *gps_state = (GritsPluginGPS *)user_data; + GritsPluginGps *gps = (GritsPluginGps *)user_data; - g_debug("on_gps_track_clear_clicked_event called"); + g_assert(gps); - GPS_STATUS(gps_state, "Cleared GPS track."); + g_debug("GritsPluginGps: log_interval_changed_event - value = %f", + gtk_range_get_value(GTK_RANGE(widget))); + + if (gtk_toggle_button_get_active( + GTK_TOGGLE_BUTTON(gps->ui.gps_log_checkbox))) { + g_assert(gps->ui.gps_log_timeout_id != 0); + + /* disable old timeout */ + g_source_remove(gps->ui.gps_log_timeout_id); + gps->ui.gps_log_timeout_id = 0; - gps_track_clear(&gps_state->track); + /* Schedule new log file write */ + gps->ui.gps_log_timeout_id = g_timeout_add( + gtk_range_get_value(GTK_RANGE(widget))*1000, + gps_write_log, gps); + gps_write_log(gps); + } - return FALSE; + return FALSE; } -static gboolean -on_gps_log_interval_changed_event(GtkWidget *widget, gpointer user_data) +static gboolean gps_write_log(gpointer data) { - GritsPluginGPS *gps_state = (GritsPluginGPS *)user_data; - - assert(gps_state); + GritsPluginGps *gps = (GritsPluginGps *)data; + struct gps_data_t *gps_data = &gps->gps_data; + gchar buf[256]; + gchar filename[256]; + gint fd; + gboolean new_file = FALSE; - g_debug("gps interval changed, value = %f", - gtk_range_get_value(GTK_RANGE(widget))); + if (gps_data == NULL) { + g_warning("Skipped write to GPS log file: " + "can not get GPS coordinates."); + GPS_STATUS(gps, "Skipped write to GPS log file: " + "can not get GPS coordinates."); + return TRUE; + } - if (gtk_toggle_button_get_active( - GTK_TOGGLE_BUTTON(gps_state->ui.gps_log_checkbox))) { - assert(gps_state->ui.gps_log_timeout_id != 0); - - /* disable old timeout */ - g_source_remove(gps_state->ui.gps_log_timeout_id); - gps_state->ui.gps_log_timeout_id = 0; - - /* Schedule new log file write */ - gps_state->ui.gps_log_timeout_id = g_timeout_add( - gtk_range_get_value(GTK_RANGE(widget))*1000, - gps_write_log, gps_state); - gps_write_log(gps_state); - } - - return FALSE; -} - -static gboolean -gps_write_log(gpointer data) -{ - GritsPluginGPS *gps_state = (GritsPluginGPS *)data; - struct gps_data_t *gps_data = &gps_state->gps_data; - char buf[256]; - char filename[256]; - int fd; - gboolean new_file = FALSE; - - if (gps_data == NULL) { - g_warning("Skipped write to GPS log file: " - "can not get GPS coordinates."); - GPS_STATUS(gps_state, "Skipped write to GPS log file: " - "can not get GPS coordinates."); - return TRUE; - } - - /* get filename from text entry box. If empty, generate a name from - * the date and time and set it. - */ - if (strlen(gtk_entry_get_text(GTK_ENTRY(gps_state->ui.gps_log_filename_entry))) - == 0) { - snprintf(filename, sizeof(filename), + /* get filename from text entry box. If empty, generate a name from + * the date and time and set it. + */ + if (strlen(gtk_entry_get_text( + GTK_ENTRY(gps->ui.gps_log_filename_entry))) == 0) { + snprintf(filename, sizeof(filename), "%sT%s.%s", - gps_get_date_string(gps_state->gps_data.fix.time), - gps_get_time_string(gps_state->gps_data.fix.time), + gps_get_date_string(gps->gps_data.fix.time), + gps_get_time_string(gps->gps_data.fix.time), GPS_LOG_EXT); - gtk_entry_set_text(GTK_ENTRY(gps_state->ui.gps_log_filename_entry), + gtk_entry_set_text(GTK_ENTRY(gps->ui.gps_log_filename_entry), filename); - } + } - strncpy(filename, - gtk_entry_get_text(GTK_ENTRY(gps_state->ui.gps_log_filename_entry)), + strncpy(filename, + gtk_entry_get_text(GTK_ENTRY(gps->ui.gps_log_filename_entry)), sizeof (filename)); - if (!g_file_test(filename, G_FILE_TEST_EXISTS)) { - new_file = TRUE; - } + if (!g_file_test(filename, G_FILE_TEST_EXISTS)) { + new_file = TRUE; + } - if ((fd = open(filename, O_CREAT|O_APPEND|O_WRONLY, 0644)) == -1) { - g_warning("Error opening log file %s: %s", - filename, strerror(errno)); - return FALSE; - } + if ((fd = open(filename, O_CREAT|O_APPEND|O_WRONLY, 0644)) == -1) { + g_warning("Error opening log file %s: %s", + filename, strerror(errno)); + return FALSE; + } - if (new_file) { - /* write header and reset record counter */ - snprintf(buf, sizeof(buf), - "No,Date,Time,Lat,Lon,Ele,Head,Speed,RTR\n"); - if (write(fd, buf, strlen(buf)) == -1) { - g_warning("Error writing header to log file %s: %s", - filename, strerror(errno)); + if (new_file) { + /* write header and reset record counter */ + snprintf(buf, sizeof(buf), + "No,Date,Time,Lat,Lon,Ele,Head,Speed,RTR\n"); + if (write(fd, buf, strlen(buf)) == -1) { + g_warning("Error writing header to log file %s: %s", + filename, strerror(errno)); + } + gps->ui.gps_log_number = 1; } - gps_state->ui.gps_log_number = 1; - } - - /* Write log entry. Make sure this matches the header */ - /* "No,Date,Time,Lat,Lon,Ele,Head,Speed,Fix,RTR\n" */ - /* RTR values: T=time, B=button push, S=speed, D=distance */ - snprintf(buf, sizeof(buf), "%d,%s,%s,%lf,%lf,%lf,%lf,%lf,%c\n", - gps_state->ui.gps_log_number++, - gps_get_date_string(gps_state->gps_data.fix.time), - gps_get_time_string(gps_state->gps_data.fix.time), + + /* Write log entry. Make sure this matches the header */ + /* "No,Date,Time,Lat,Lon,Ele,Head,Speed,Fix,RTR\n" */ + /* RTR values: T=time, B=button push, S=speed, D=distance */ + snprintf(buf, sizeof(buf), "%d,%s,%s,%lf,%lf,%lf,%lf,%lf,%c\n", + gps->ui.gps_log_number++, + gps_get_date_string(gps->gps_data.fix.time), + gps_get_time_string(gps->gps_data.fix.time), // gps_data->fix.time, gps_data->fix.latitude, gps_data->fix.longitude, @@ -361,273 +382,285 @@ gps_write_log(gpointer data) gps_data->fix.speed * METERS_TO_FEET, 'T'); /* position due to timer expired */ - if (write(fd, buf, strlen(buf)) == -1) { - g_warning("Could not write log number %d to log file %s: %s", - gps_state->ui.gps_log_number-1, filename, strerror(errno)); - } - close(fd); + if (write(fd, buf, strlen(buf)) == -1) { + g_warning("Could not write log number %d to log file %s: %s", + gps->ui.gps_log_number-1, filename, strerror(errno)); + } + close(fd); + + GPS_STATUS(gps, "Updated GPS log file %s.", filename); + + /* reschedule */ + return TRUE; +} + +static gboolean on_gps_follow_clicked_event (GtkWidget *widget, gpointer user_data) +{ + GritsPluginGps *gps = (GritsPluginGps *)user_data; + + g_debug("GritsPluginGps: follow_clicked_event - button status %d", + gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))); + if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))) { + gps->follow_gps = TRUE; + } else { + gps->follow_gps = FALSE; + } + + return FALSE; +} + + +static void gps_init_track_log_frame(GritsPluginGps *gps, GtkWidget *gbox) +{ + /* Track log box with enable checkbox and filename entry */ + GtkWidget *gps_log_frame = gtk_frame_new ("Track Log"); + GtkWidget *lbox = gtk_vbox_new (FALSE, 2); + gtk_container_add (GTK_CONTAINER (gps_log_frame), lbox); + gtk_box_pack_start (GTK_BOX(gbox), gps_log_frame, + FALSE, FALSE, 0); + + gps->ui.gps_log_checkbox = + gtk_check_button_new_with_label("Log Position to File"); + g_signal_connect (G_OBJECT (gps->ui.gps_log_checkbox), "clicked", + G_CALLBACK (on_gps_log_clicked_event), + (gpointer)gps); + gtk_box_pack_start (GTK_BOX(lbox), gps->ui.gps_log_checkbox, + FALSE, FALSE, 0); + + /* Set up filename entry box */ + GtkWidget *fbox = gtk_hbox_new (FALSE, 2); + GtkWidget *filename_label = gtk_label_new ("Filename:"); + gtk_box_pack_start (GTK_BOX(fbox), filename_label, FALSE, FALSE, 0); + gps->ui.gps_log_filename_entry = gtk_entry_new(); + gtk_box_pack_start (GTK_BOX(fbox), gps->ui.gps_log_filename_entry, + TRUE, TRUE, 0); + gtk_box_pack_start (GTK_BOX(lbox), fbox, FALSE, FALSE, 0); + + /* set up gps log interval slider */ + GtkWidget *ubox = gtk_hbox_new (FALSE, 4); + GtkWidget *interval_label = gtk_label_new ("Update Interval:"); + gtk_box_pack_start (GTK_BOX(ubox), interval_label, FALSE, FALSE, 0); + gps->ui.gps_log_interval_slider = + gtk_hscale_new_with_range(1.0, 600.0, 30.0); + gtk_range_set_value (GTK_RANGE(gps->ui.gps_log_interval_slider), + GPS_LOG_DEFAULT_UPDATE_INTERVAL); + g_signal_connect (G_OBJECT (gps->ui.gps_log_interval_slider), + "value-changed", + G_CALLBACK(on_gps_log_interval_changed_event), + (gpointer)gps); + gtk_range_set_increments( + GTK_RANGE(gps->ui.gps_log_interval_slider), + 10.0 /* step */, 30.0 /* page up/down */); + gtk_range_set_update_policy( + GTK_RANGE(gps->ui.gps_log_interval_slider), + GTK_UPDATE_DELAYED); + gtk_box_pack_start (GTK_BOX(ubox), gps->ui.gps_log_interval_slider, + TRUE, TRUE, 0); + gtk_box_pack_start (GTK_BOX(lbox), ubox, FALSE, FALSE, 0); +} + +static gboolean on_gps_log_clicked_event (GtkWidget *widget, gpointer user_data) +{ + GritsPluginGps *gps = (GritsPluginGps *)user_data; + + g_debug("GritsPluginGps: log_clicked_event"); + + if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))) { + gps_write_log(gps); + + /* Schedule log file write */ + gps->ui.gps_log_timeout_id = g_timeout_add( + gtk_range_get_value( + GTK_RANGE(gps->ui.gps_log_interval_slider))*1000, + gps_write_log, gps); + } else { + /* button unchecked */ + g_source_remove(gps->ui.gps_log_timeout_id); + gps->ui.gps_log_timeout_id = 0; + g_debug("GritsPluginGps: log_clicked_event - closed log file."); + } - GPS_STATUS(gps_state, "Updated GPS log file %s.", filename); - - /* reschedule */ - return TRUE; -} - -static gboolean -on_gps_follow_clicked_event (GtkWidget *widget, gpointer user_data) -{ - GritsPluginGPS *gps_state = (GritsPluginGPS *)user_data; - - g_debug("on_gps_follow_clicked_event called!, button status %d", - gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))); - if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))) - gps_state->follow_gps = TRUE; - else - gps_state->follow_gps = FALSE; - - return FALSE; -} - - -static void -gps_init_track_log_frame(GritsPluginGPS *gps_state, GtkWidget *gbox) -{ - /* Track log box with enable checkbox and filename entry */ - GtkWidget *gps_log_frame = gtk_frame_new ("Track Log"); - GtkWidget *lbox = gtk_vbox_new (FALSE, 2); - gtk_container_add (GTK_CONTAINER (gps_log_frame), lbox); - gtk_box_pack_start (GTK_BOX(gbox), gps_log_frame, - FALSE, FALSE, 0); - - gps_state->ui.gps_log_checkbox = gtk_check_button_new_with_label("Log Position to File"); - g_signal_connect (G_OBJECT (gps_state->ui.gps_log_checkbox), "clicked", - G_CALLBACK (on_gps_log_clicked_event), - (gpointer)gps_state); - gtk_box_pack_start (GTK_BOX(lbox), gps_state->ui.gps_log_checkbox, - FALSE, FALSE, 0); - - /* Set up filename entry box */ - GtkWidget *fbox = gtk_hbox_new (FALSE, 2); - GtkWidget *filename_label = gtk_label_new ("Filename:"); - gtk_box_pack_start (GTK_BOX(fbox), filename_label, FALSE, FALSE, 0); - gps_state->ui.gps_log_filename_entry = gtk_entry_new(); - gtk_box_pack_start (GTK_BOX(fbox), gps_state->ui.gps_log_filename_entry, - TRUE, TRUE, 0); - gtk_box_pack_start (GTK_BOX(lbox), fbox, FALSE, FALSE, 0); - - /* set up gps log interval slider */ - GtkWidget *ubox = gtk_hbox_new (FALSE, 4); - GtkWidget *interval_label = gtk_label_new ("Update Interval:"); - gtk_box_pack_start (GTK_BOX(ubox), interval_label, FALSE, FALSE, 0); - gps_state->ui.gps_log_interval_slider = - gtk_hscale_new_with_range(1.0, 600.0, 30.0); - gtk_range_set_value (GTK_RANGE(gps_state->ui.gps_log_interval_slider), - GPS_LOG_DEFAULT_UPDATE_INTERVAL); - g_signal_connect (G_OBJECT (gps_state->ui.gps_log_interval_slider), - "value-changed", - G_CALLBACK(on_gps_log_interval_changed_event), - (gpointer)gps_state); - gtk_range_set_increments (GTK_RANGE(gps_state->ui.gps_log_interval_slider), - 10.0 /* step */, 30.0 /* page up/down */); - gtk_range_set_update_policy (GTK_RANGE(gps_state->ui.gps_log_interval_slider), - GTK_UPDATE_DELAYED); - gtk_box_pack_start (GTK_BOX(ubox), gps_state->ui.gps_log_interval_slider, - TRUE, TRUE, 0); - gtk_box_pack_start (GTK_BOX(lbox), ubox, FALSE, FALSE, 0); -} - -static gboolean -on_gps_log_clicked_event (GtkWidget *widget, gpointer user_data) -{ - GritsPluginGPS *gps_state = (GritsPluginGPS *)user_data; - - g_debug("on_gps_log_clicked_event called!"); - - if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))) { - gps_write_log(gps_state); - - /* Schedule log file write */ - gps_state->ui.gps_log_timeout_id = g_timeout_add( - gtk_range_get_value( - GTK_RANGE(gps_state->ui.gps_log_interval_slider))*1000, - gps_write_log, gps_state); - } else { - /* button unchecked */ - g_source_remove(gps_state->ui.gps_log_timeout_id); - gps_state->ui.gps_log_timeout_id = 0; - g_debug("Closed log file."); - } - - return FALSE; -} - - -static void -gps_init_status_info(GritsPluginGPS *gps_state, GtkWidget *gbox) -{ - gps_state->ui.gps_status_frame = gtk_frame_new ("GPS Data"); - gps_state->ui.gps_status_table = gtk_table_new (5, 2, TRUE); - gtk_container_add (GTK_CONTAINER (gps_state->ui.gps_status_frame), - gps_state->ui.gps_status_table); - - /* gps data table setup */ - int i; - for (i = 0; i < sizeof(gps_table)/sizeof(*gps_table); i++) { - gps_table[i].label_widget = gtk_label_new (gps_table[i].label); - gtk_label_set_justify(GTK_LABEL(gps_table[i].label_widget), - GTK_JUSTIFY_LEFT); - gtk_table_attach( GTK_TABLE(gps_state->ui.gps_status_table), - gps_table[i].label_widget, 0, 1, i, i+1, 0, 0, 0, 0); - gps_table[i].value_widget = gtk_label_new (gps_table[i].initial_val); - gtk_table_attach( GTK_TABLE(gps_state->ui.gps_status_table), - gps_table[i].value_widget, 1, 2, i, i+1, 0, 0, 0, 0); - - PangoFontDescription *font_desc = pango_font_description_new (); - pango_font_description_set_size (font_desc, - gps_table[i].font_size*PANGO_SCALE); - gtk_widget_modify_font (gps_table[i].label_widget, font_desc); - gtk_widget_modify_font (gps_table[i].value_widget, font_desc); - pango_font_description_free (font_desc); - } - gtk_box_pack_start (GTK_BOX(gbox), gps_state->ui.gps_status_frame, - FALSE, FALSE, 0); - - /* Start UI refresh task, which will reschedule itself periodically. */ - gps_redraw_all(gps_state); - gps_state->gps_update_timeout_id = g_timeout_add( + return FALSE; +} + + +static void gps_init_status_info(GritsPluginGps *gps, GtkWidget *gbox) +{ + gps->ui.gps_status_frame = gtk_frame_new("GPS Data"); + gps->ui.gps_status_table = gtk_table_new(5, 2, TRUE); + gtk_container_add(GTK_CONTAINER (gps->ui.gps_status_frame), + gps->ui.gps_status_table); + + /* gps data table setup */ + gint i; + for (i = 0; i < sizeof(gps_table)/sizeof(*gps_table); i++) { + gps_table[i].label_widget = gtk_label_new (gps_table[i].label); + gtk_label_set_justify(GTK_LABEL(gps_table[i].label_widget), + GTK_JUSTIFY_LEFT); + gtk_table_attach(GTK_TABLE(gps->ui.gps_status_table), + gps_table[i].label_widget, + 0, 1, i, i+1, 0, 0, 0, 0); + gps_table[i].value_widget = gtk_label_new(gps_table[i].initial_val); + gtk_table_attach( GTK_TABLE(gps->ui.gps_status_table), + gps_table[i].value_widget, 1, 2, i, i+1, 0, 0, 0, 0); + + PangoFontDescription *font_desc = pango_font_description_new (); + pango_font_description_set_size (font_desc, + gps_table[i].font_size*PANGO_SCALE); + gtk_widget_modify_font (gps_table[i].label_widget, font_desc); + gtk_widget_modify_font (gps_table[i].value_widget, font_desc); + pango_font_description_free (font_desc); + } + gtk_box_pack_start(GTK_BOX(gbox), gps->ui.gps_status_frame, + FALSE, FALSE, 0); + + /* Start UI refresh task, which will reschedule itgps. */ + gps_redraw_all(gps); + gps->gps_update_timeout_id = g_timeout_add( GPS_UPDATE_INTERVAL*1000, - gps_redraw_all, gps_state); + gps_redraw_all, gps); } #ifdef GPS_RANGE_RINGS -static void -gps_init_range_rings(GritsPluginGPS *gps_state, GtkWidget *gbox) +static void gps_init_range_rings(GritsPluginGps *gps, GtkWidget *gbox) { - GtkWidget *gps_range_ring_frame = gtk_frame_new ("Range Rings"); - GtkWidget *cbox = gtk_vbox_new (FALSE, 2); - gtk_container_add (GTK_CONTAINER (gps_range_ring_frame), cbox); - gtk_box_pack_start (GTK_BOX(gbox), gps_range_ring_frame, FALSE, FALSE, 0); + GtkWidget *gps_range_ring_frame = gtk_frame_new("Range Rings"); + GtkWidget *cbox = gtk_vbox_new(FALSE, 2); + gtk_container_add(GTK_CONTAINER(gps_range_ring_frame), cbox); + gtk_box_pack_start(GTK_BOX(gbox), gps_range_ring_frame, FALSE, FALSE, 0); - gps_state->ui.gps_rangering_checkbox = gtk_check_button_new_with_label("Enable Range Rings"); - g_signal_connect (G_OBJECT (gps_state->ui.gps_rangering_checkbox), "clicked", - G_CALLBACK (on_gps_rangering_clicked_event), - (gpointer)gps_state); - gtk_box_pack_start (GTK_BOX(cbox), gps_state->ui.gps_rangering_checkbox, - FALSE, FALSE, 0); + gps->ui.gps_rangering_checkbox = gtk_check_button_new_with_label("Enable Range Rings"); + g_signal_connect(G_OBJECT(gps->ui.gps_rangering_checkbox), + "clicked", G_CALLBACK(on_gps_rangering_clicked_event), + (gpointer)gps); + gtk_box_pack_start(GTK_BOX(cbox), gps->ui.gps_rangering_checkbox, + FALSE, FALSE, 0); } -static gboolean -on_gps_rangering_clicked_event (GtkWidget *widget, gpointer user_data) +static gboolean on_gps_rangering_clicked_event(GtkWidget *widget, gpointer user_data) { - GritsPluginGPS *gps_state = (GritsPluginGPS *)user_data; + GritsPluginGps *gps = (GritsPluginGps *)user_data; - if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget))) { - gps_state->gps_rangering_active = TRUE; - } else { - gps_state->gps_rangering_active = FALSE; - } + if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget))) { + gps->gps_rangering_active = TRUE; + } else { + gps->gps_rangering_active = FALSE; + } - /* XXX force a redraw */ + /* XXX force a redraw */ - return FALSE; + return FALSE; } #endif /* GPS_RANGE_RINGS */ /* external interface to update UI from latest GPS data. */ gboolean gps_redraw_all(gpointer data) { - GritsPluginGPS *gps_state = (GritsPluginGPS *)data; - assert(gps_state); - - struct gps_data_t *gps_data = &gps_state->gps_data; + GritsPluginGps *gps = (GritsPluginGps *)data; + g_assert(gps); - g_debug("gps_redraw_all called"); + struct gps_data_t *gps_data = &gps->gps_data; - assert(gps_data); - if (!gps_data_is_valid(gps_data)) { - g_debug("gps_data is not valid."); - /* XXX Change marker to indicate data is not valid */ - return TRUE; - } + g_debug("GritsPluginGps: redraw_all"); - /* update position labels */ - update_gps_status(gps_state); + g_assert(gps_data); + if (!gps_data_is_valid(gps_data)) { + g_debug("GritsPluginGps: redraw_all - gps_data is not valid."); + /* XXX Change marker to indicate data is not valid */ + return TRUE; + } - /* Update track and marker position */ - if (gps_data_is_valid(gps_data) && gps_state->track.active) { - g_debug("Updating track group %u point %u at " - "lat = %f, long = %f, track = %f", - gps_state->track.cur_group, gps_state->track.cur_point, - gps_data->fix.latitude, - gps_data->fix.longitude, - gps_data->fix.track); + /* update position labels */ + update_gps_status(gps); + + /* Update track and marker position */ + if (gps_data_is_valid(gps_data) && gps->track.active) { + g_debug("GritsPluginGps: redraw_all - updating track group %u " + "point %u at lat = %f, long = %f, track = %f", + gps->track.cur_group, + gps->track.cur_point, + gps_data->fix.latitude, + gps_data->fix.longitude, + gps_data->fix.track); + + gps_track_add_point(&gps->track, + gps_data->fix.latitude, gps_data->fix.longitude, 0.0); + + if (gps->track.line) { + grits_viewer_remove(gps->viewer, + GRITS_OBJECT(gps->track.line)); + gps->track.line = NULL; + } - gps_track_add_point(&gps_state->track, - gps_data->fix.latitude, gps_data->fix.longitude, 0.0); + gps->track.line = grits_line_new(gps->track.points); + gps->track.line->color[0] = 1.0; + gps->track.line->color[1] = 0; + gps->track.line->color[2] = 0.1; + gps->track.line->color[3] = 0.5; + gps->track.line->width = 3; - if (gps_state->track.line) { - grits_viewer_remove(gps_state->viewer, - GRITS_OBJECT(gps_state->track.line)); - gps_state->track.line = NULL; + grits_viewer_add(gps->viewer, GRITS_OBJECT(gps->track.line), + GRITS_LEVEL_OVERLAY, TRUE); + grits_object_queue_draw(GRITS_OBJECT(gps->track.line)); } - gps_state->track.line = grits_line_new(gps_state->track.points); - gps_state->track.line->color[0] = 1.0; - gps_state->track.line->color[1] = 0; - gps_state->track.line->color[2] = 0.1; - gps_state->track.line->color[3] = 0.5; - gps_state->track.line->width = 3; - - grits_viewer_add(gps_state->viewer, GRITS_OBJECT(gps_state->track.line), - GRITS_LEVEL_OVERLAY, TRUE); - grits_object_queue_draw(GRITS_OBJECT(gps_state->track.line)); - } - - if (gps_data_is_valid(gps_data)) { - if (gps_state->marker) { - grits_viewer_remove(gps_state->viewer, - GRITS_OBJECT(gps_state->marker)); - gps_state->marker = NULL; - } + if (gps_data_is_valid(gps_data)) { + if (gps->marker) { + grits_viewer_remove(gps->viewer, + GRITS_OBJECT(gps->marker)); + gps->marker = NULL; + } - gps_state->marker = grits_marker_icon_new("GPS", "car.png", - gps_data->fix.track, TRUE); + gchar *path = find_path(GPS_MARKER_ICON_PATH, GPS_MARKER_ICON); + if (path) { + gps->marker = grits_marker_icon_new("GPS", path, + gps_data->fix.track, TRUE, MARKER_DMASK_ICON); + g_free(path); + } else { + /* if icon not found just use a point */ + g_warning("Could not find GPS marker icon %s in path %s.", + GPS_MARKER_ICON, GPS_MARKER_ICON_PATH); + gps->marker = grits_marker_icon_new("GPS", NULL, + gps_data->fix.track, FALSE, + MARKER_DMASK_POINT|MARKER_DMASK_LABEL); + } - GRITS_OBJECT(gps_state->marker)->center.lat = gps_data->fix.latitude; - GRITS_OBJECT(gps_state->marker)->center.lon = gps_data->fix.longitude; - GRITS_OBJECT(gps_state->marker)->center.elev = 0.0; - GRITS_OBJECT(gps_state->marker)->lod = EARTH_R; - - grits_viewer_add(gps_state->viewer, GRITS_OBJECT(gps_state->marker), - GRITS_LEVEL_OVERLAY, TRUE); - grits_object_queue_draw(GRITS_OBJECT(gps_state->marker)); - } - - if (gps_state->follow_gps && gps_data_is_valid(gps_data)) { - /* Center map at current GPS position. */ - g_debug("Centering map at lat = %f, long = %f, track = %f", - gps_data->fix.latitude, - gps_data->fix.longitude, - gps_data->fix.track); - - double lat, lon, elev; - grits_viewer_get_location(gps_state->viewer, &lat, &lon, &elev); - grits_viewer_set_location(gps_state->viewer, gps_data->fix.latitude, + GRITS_OBJECT(gps->marker)->center.lat = gps_data->fix.latitude; + GRITS_OBJECT(gps->marker)->center.lon = gps_data->fix.longitude; + GRITS_OBJECT(gps->marker)->center.elev = 0.0; + GRITS_OBJECT(gps->marker)->lod = EARTH_R; + + grits_viewer_add(gps->viewer, + GRITS_OBJECT(gps->marker), + GRITS_LEVEL_OVERLAY, TRUE); + grits_object_queue_draw(GRITS_OBJECT(gps->marker)); + } + + if (gps->follow_gps && gps_data_is_valid(gps_data)) { + /* Center map at current GPS position. */ + g_debug("GritsPluginGps: redraw_all - centering map at " + "lat = %f, long = %f, track = %f", + gps_data->fix.latitude, + gps_data->fix.longitude, + gps_data->fix.track); + + double lat, lon, elev; + grits_viewer_get_location(gps->viewer, &lat, &lon, &elev); + grits_viewer_set_location(gps->viewer, gps_data->fix.latitude, gps_data->fix.longitude, elev); - //grits_viewer_set_rotation(gps_state->viewer, 0, 0, 0); - } + //grits_viewer_set_rotation(gps->viewer, 0, 0, 0); + } - /* reschedule */ - return TRUE; + /* reschedule */ + return TRUE; } /******************* Track handling routines *****************/ -static void -gps_track_init(struct gps_track_t *track) +static void gps_track_init(struct gps_track_t *track) { /* Save a spot at the end for the NULL termination */ track->points = (gpointer)g_new0(double*, NUM_TRACK_GROUPS + 1); @@ -637,10 +670,9 @@ gps_track_init(struct gps_track_t *track) track->line = NULL; } -static void -gps_track_clear(struct gps_track_t *track) +static void gps_track_clear(struct gps_track_t *track) { - int pi; + gint pi; for (pi = 0; pi < NUM_TRACK_GROUPS; pi++) { if (track->points[pi] != NULL) { g_free(track->points[pi]); @@ -652,8 +684,7 @@ gps_track_clear(struct gps_track_t *track) track->num_points = 1; /* starts at 1 so realloc logic works */ } -static void -gps_track_free(struct gps_track_t *track) +static void gps_track_free(struct gps_track_t *track) { gps_track_clear(track); g_free(track->points); @@ -662,8 +693,7 @@ gps_track_free(struct gps_track_t *track) /* add a new track group (points in a track group are connected, and * separated from points in other track groups). */ -static void -gps_track_group_incr(struct gps_track_t *track) +static void gps_track_group_incr(struct gps_track_t *track) { gdouble (**points)[3] = track->points; /* for simplicity */ @@ -671,42 +701,41 @@ gps_track_group_incr(struct gps_track_t *track) * been added. */ if (points[track->cur_group] == NULL) { - return; + return; } - g_debug("track_group_incr: incrementing track group to %u.", - track->cur_group + 1); + g_debug("GritsPluginGps: track_group_incr - track group %u->%u.", + track->cur_group, track->cur_group + 1); track->cur_group++; track->cur_point = 0; track->num_points = 1; /* starts at 1 so realloc logic works */ if (track->cur_group >= NUM_TRACK_GROUPS) { - g_debug("track_group_incr: current track group %u is at max %u, " - "shifting groups.", - track->cur_group, NUM_TRACK_GROUPS); + g_debug("GritsPluginGps: track_group_incr - track group %u " + "is at max %u, shifting groups", + track->cur_group, NUM_TRACK_GROUPS); - /* Free the oldest one which falls off the end */ - g_free(points[0]); + /* Free the oldest one which falls off the end */ + g_free(points[0]); - /* shift the rest down, last one should always be NULL already */ - /* note we alloc NUM_TRACK_GROUPS+1 */ - for (int pi = 0; pi < NUM_TRACK_GROUPS; pi++) { - points[pi] = points[pi+1]; - } + /* shift the rest down, last one should be NULL already */ + /* note we alloc NUM_TRACK_GROUPS+1 */ + for (int pi = 0; pi < NUM_TRACK_GROUPS; pi++) { + points[pi] = points[pi+1]; + } - /* always write into the last group */ - track->cur_group = NUM_TRACK_GROUPS - 1; + /* always write into the last group */ + track->cur_group = NUM_TRACK_GROUPS - 1; } } -static void -gps_track_add_point(struct gps_track_t *track, gdouble lat, gdouble lon, - gdouble elevation) +static void gps_track_add_point(struct gps_track_t *track, + gdouble lat, gdouble lon, gdouble elevation) { gdouble (**points)[3] = track->points; /* for simplicity */ - g_debug("GritsPluginGPS: track_add_point"); + g_debug("GritsPluginGps: track_add_point"); g_assert(track->cur_group < NUM_TRACK_GROUPS && (track->cur_point <= track->num_points)); @@ -716,7 +745,7 @@ gps_track_add_point(struct gps_track_t *track, gdouble lat, gdouble lon, guint new_size = track->num_points == 1 ? NUM_TRACK_POINTS : track->num_points * NUM_TRACK_POINTS_FACTOR; - g_debug("GritsPluginGPS: track_add_point: reallocating points " + g_debug("GritsPluginGps: track_add_point - reallocating points " "array from %u points to %u points.\n", track->num_points, new_size); points[track->cur_group] = (gpointer)g_renew(gdouble, @@ -741,223 +770,216 @@ gps_track_add_point(struct gps_track_t *track, gdouble lat, gdouble lon, } -static -char *gps_get_status(struct gps_data_t *gps_data) +static gchar *gps_get_status(struct gps_data_t *gps_data) { - gchar *status_color; - gchar *status_text; + gchar *status_color; + gchar *status_text; - switch (gps_data->fix.mode) { + switch (gps_data->fix.mode) { case MODE_NOT_SEEN: - status_color = "red"; - status_text = "No Signal"; - break; + status_color = "red"; + status_text = "No Signal"; + break; case MODE_NO_FIX: - status_color = "red"; - status_text = "No Fix"; - break; + status_color = "red"; + status_text = "No Fix"; + break; case MODE_2D: - status_color = "yellow"; - status_text = "2D Mode"; - break; + status_color = "yellow"; + status_text = "2D Mode"; + break; case MODE_3D: - status_color = "green"; - status_text = "3D Mode"; - break; + status_color = "green"; + status_text = "3D Mode"; + break; default: - status_color = "black"; - status_text = "Unknown"; - break; - } - return g_strdup_printf("%s", - status_color, status_text); + status_color = "black"; + status_text = "Unknown"; + break; + } + return g_strdup_printf("%s", + status_color, status_text); } #if 0 -static char *gps_get_online(struct gps_data_t *); - -static -char *gps_get_online(struct gps_data_t *gps_data) -{ - char *status_str; - char *online_str; - - if (gps_data->online == -1.0) { - online_str = "Offline"; - } else { - online_str = "Online"; - } - - switch (gps_data->status) { - case 0: - status_str = "No Fix"; - break; - case 1: - status_str = "Fix Acquired"; - break; - case 2: - status_str = "DGPS Fix"; - break; - default: - status_str = "Unknown Status"; - break; - } - - return g_strdup_printf("%lf,%s,%s", gps_data->online, online_str, status_str); +static gchar *gps_get_online(struct gps_data_t *); + +static gchar *gps_get_online(struct gps_data_t *gps_data) +{ + gchar *status_str; + gchar *online_str; + + if (gps_data->online == -1.0) { + online_str = "Offline"; + } else { + online_str = "Online"; + } + + switch (gps_data->status) { + case 0: + status_str = "No Fix"; + break; + case 1: + status_str = "Fix Acquired"; + break; + case 2: + status_str = "DGPS Fix"; + break; + default: + status_str = "Unknown Status"; + break; + } + + return g_strdup_printf("%lf,%s,%s", gps_data->online, online_str, status_str); } #endif -static -char *gps_get_latitude(struct gps_data_t *gps_data) +static gchar *gps_get_latitude(struct gps_data_t *gps_data) { - return g_strdup_printf("%3.4f", gps_data->fix.latitude); + return g_strdup_printf("%3.4f", gps_data->fix.latitude); } -static -char *gps_get_longitude(struct gps_data_t *gps_data) +static gchar *gps_get_longitude(struct gps_data_t *gps_data) { - return g_strdup_printf("%3.4f", gps_data->fix.longitude); + return g_strdup_printf("%3.4f", gps_data->fix.longitude); } -static -char *gps_get_elevation(struct gps_data_t *gps_data) +static gchar *gps_get_elevation(struct gps_data_t *gps_data) { - /* XXX Make units (m/ft) settable */ - return g_strdup_printf("%.1lf %s", + /* XXX Make units (m/ft) settable */ + return g_strdup_printf("%.1lf %s", (gps_data->fix.altitude * METERS_TO_FEET), "ft"); } -static -char *gps_get_heading(struct gps_data_t *gps_data) +static gchar *gps_get_heading(struct gps_data_t *gps_data) { - /* XXX Make units (m/ft) settable */ - return g_strdup_printf("%03.0lf", gps_data->fix.track); + /* XXX Make units (m/ft) settable */ + return g_strdup_printf("%03.0lf", gps_data->fix.track); } -static -char *gps_get_speed(struct gps_data_t *gps_data) +static gchar *gps_get_speed(struct gps_data_t *gps_data) { - /* XXX Make units (m/ft) settable */ - return g_strdup_printf("%1.1f %s", - (gps_data->fix.speed*3600.0*METERS_TO_FEET/5280.0), "mph"); + /* XXX Make units (m/ft) settable */ + return g_strdup_printf("%1.1f %s", + (gps_data->fix.speed*3600.0*METERS_TO_FEET/5280.0), "mph"); } -static -gint initialize_gpsd(char *server, char *port, +static gint initialize_gpsd(char *server, gchar *port, struct gps_data_t *gps_data) { #if GPSD_API_MAJOR_VERSION < 5 #error "GPSD protocol version 5 or greater required." #endif - int result; - - if ((result = gps_open(server, port, gps_data)) != 0) { - g_warning("Unable to open gpsd connection to %s:%s: %d, %d, %s", - server, port, result, errno, gps_errstr(errno)); - } else { - (void)gps_stream(gps_data, WATCH_ENABLE|WATCH_JSON, NULL); - g_debug("initialize_gpsd(): gpsd fd %u.", gps_data->gps_fd); - gdk_input_add(gps_data->gps_fd, GDK_INPUT_READ, process_gps, gps_data); - } + gint result; + + if ((result = gps_open(server, port, gps_data)) != 0) { + g_warning("Unable to open gpsd connection to %s:%s: %d, %d, %s", + server, port, result, errno, gps_errstr(errno)); + } else { + (void)gps_stream(gps_data, WATCH_ENABLE|WATCH_JSON, NULL); + g_debug("GritsPluginGps: initialize_gpsd - gpsd fd %u.", + gps_data->gps_fd); + gdk_input_add(gps_data->gps_fd, GDK_INPUT_READ, process_gps, gps_data); + } - return result; + return result; } -static void -process_gps(gpointer data, gint source, GdkInputCondition condition) +static void process_gps(gpointer data, gint source, GdkInputCondition condition) { - struct gps_data_t *gps_data = (struct gps_data_t *)data; + struct gps_data_t *gps_data = (struct gps_data_t *)data; + + g_debug("GritsPluginGps: process_gps"); - /* Process any data from the gps and call the hook function */ - g_debug("In process_gps()"); - if (gps_data != NULL) { - int result = gps_read(gps_data); - g_debug("In process_gps(), gps_read returned %d, position %f, %f.", result, gps_data->fix.latitude, gps_data->fix.longitude); - } else { - g_debug("process_gps: gps_data == NULL."); - } + /* Process any data from the gps and call the hook function */ + if (gps_data != NULL) { + gint result = gps_read(gps_data); + g_debug("GritsPluginGps: process_gps - gps_read returned %d, " + "position %f, %f.", result, + gps_data->fix.latitude, gps_data->fix.longitude); + } else { + g_warning("GritsPluginGps: process_gps - gps_data == NULL."); + } } /************************** GPS Object Methods *************************/ /* Methods */ -GritsPluginGPS *grits_plugin_gps_new(GritsViewer *viewer, GritsPrefs *prefs) +GritsPluginGps *grits_plugin_gps_new(GritsViewer *viewer, GritsPrefs *prefs) { /* TODO: move to constructor if possible */ - g_debug("GritsPluginGPS: new"); - GritsPluginGPS *self = g_object_new(GRITS_TYPE_PLUGIN_GPS, NULL); - self->viewer = viewer; - self->prefs = prefs; + g_debug("GritsPluginGps: new"); + GritsPluginGps *gps = g_object_new(GRITS_TYPE_PLUGIN_GPS, NULL); + gps->viewer = viewer; + gps->prefs = prefs; - g_debug("grits_plugin_gps_new()"); - - initialize_gpsd("localhost", DEFAULT_GPSD_PORT, &self->gps_data); - self->follow_gps = FALSE; + initialize_gpsd("localhost", DEFAULT_GPSD_PORT, &gps->gps_data); + gps->follow_gps = FALSE; - gps_track_init(&self->track); - gps_init_status_info(self, self->hbox); - gps_init_control_frame(self, self->hbox); - gps_init_track_log_frame(self, self->hbox); + gps_track_init(&gps->track); + gps_init_status_info(gps, gps->hbox); + gps_init_control_frame(gps, gps->hbox); + gps_init_track_log_frame(gps, gps->hbox); #ifdef GPS_RANGE_RINGS - gps_init_range_rings(self, self->hbox); + gps_init_range_rings(gps, gps->hbox); #endif - return self; + return gps; } -static GtkWidget *grits_plugin_gps_get_config(GritsPlugin *_self) +static GtkWidget *grits_plugin_gps_get_config(GritsPlugin *_gps) { - GritsPluginGPS *self = GRITS_PLUGIN_GPS(_self); - return self->config; + GritsPluginGps *gps = GRITS_PLUGIN_GPS(_gps); + return gps->config; } /* GObject code */ static void grits_plugin_gps_plugin_init(GritsPluginInterface *iface); -G_DEFINE_TYPE_WITH_CODE(GritsPluginGPS, grits_plugin_gps, G_TYPE_OBJECT, +G_DEFINE_TYPE_WITH_CODE(GritsPluginGps, grits_plugin_gps, G_TYPE_OBJECT, G_IMPLEMENT_INTERFACE(GRITS_TYPE_PLUGIN, grits_plugin_gps_plugin_init)); static void grits_plugin_gps_plugin_init(GritsPluginInterface *iface) { - g_debug("GritsPluginGPS: plugin_init"); + g_debug("GritsPluginGps: plugin_init"); /* Add methods to the interface */ iface->get_config = grits_plugin_gps_get_config; } -static void grits_plugin_gps_init(GritsPluginGPS *self) +static void grits_plugin_gps_init(GritsPluginGps *gps) { - g_debug("GritsPluginGPS: in gps_init()"); + g_debug("GritsPluginGps: gps_init"); - self->config = gtk_notebook_new(); + gps->config = gtk_notebook_new(); - self->hbox = gtk_hbox_new(FALSE, 2); - gtk_notebook_insert_page(GTK_NOTEBOOK(self->config), - GTK_WIDGET(self->hbox), + gps->hbox = gtk_hbox_new(FALSE, 2); + gtk_notebook_insert_page(GTK_NOTEBOOK(gps->config), + GTK_WIDGET(gps->hbox), gtk_label_new("GPS"), 0); /* Need to position on the top because of Win32 bug */ - gtk_notebook_set_tab_pos(GTK_NOTEBOOK(self->config), GTK_POS_LEFT); + gtk_notebook_set_tab_pos(GTK_NOTEBOOK(gps->config), GTK_POS_LEFT); } static void grits_plugin_gps_dispose(GObject *gobject) { - GritsPluginGPS *self = GRITS_PLUGIN_GPS(gobject); + GritsPluginGps *gps = GRITS_PLUGIN_GPS(gobject); - g_debug("GritsPluginGPS: dispose"); + g_debug("GritsPluginGps: dispose"); - if (self->viewer) { - if (self->marker) { - grits_viewer_remove(self->viewer, - GRITS_OBJECT(self->marker)); + if (gps->viewer) { + if (gps->marker) { + grits_viewer_remove(gps->viewer, + GRITS_OBJECT(gps->marker)); } - g_object_unref(self->viewer); - self->viewer = NULL; - } + g_object_unref(gps->viewer); + gps->viewer = NULL; + } - gps_track_free(&self->track); + gps_track_free(&gps->track); /* Drop references */ G_OBJECT_CLASS(grits_plugin_gps_parent_class)->dispose(gobject); @@ -965,18 +987,18 @@ static void grits_plugin_gps_dispose(GObject *gobject) static void grits_plugin_gps_finalize(GObject *gobject) { - GritsPluginGPS *self = GRITS_PLUGIN_GPS(gobject); + GritsPluginGps *gps = GRITS_PLUGIN_GPS(gobject); - g_debug("GritsPluginGPS: finalize"); + g_debug("GritsPluginGps: finalize"); /* Free data */ - gtk_widget_destroy(self->config); + gtk_widget_destroy(gps->config); G_OBJECT_CLASS(grits_plugin_gps_parent_class)->finalize(gobject); } -static void grits_plugin_gps_class_init(GritsPluginGPSClass *klass) +static void grits_plugin_gps_class_init(GritsPluginGpsClass *klass) { - g_debug("GritsPluginGPS: class_init"); + g_debug("GritsPluginGps: class_init"); GObjectClass *gobject_class = (GObjectClass*)klass; gobject_class->dispose = grits_plugin_gps_dispose; gobject_class->finalize = grits_plugin_gps_finalize; diff --git a/src/plugins/gps-plugin.h b/src/plugins/gps-plugin.h index 6517cdd..b2fe36e 100644 --- a/src/plugins/gps-plugin.h +++ b/src/plugins/gps-plugin.h @@ -24,42 +24,42 @@ gboolean gps_key_press_event(gpointer state, GdkEventKey *kevent); gboolean gps_redraw_all(gpointer data); #define GRITS_TYPE_PLUGIN_GPS (grits_plugin_gps_get_type ()) -#define GRITS_PLUGIN_GPS(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GRITS_TYPE_PLUGIN_GPS, GritsPluginGPS)) +#define GRITS_PLUGIN_GPS(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GRITS_TYPE_PLUGIN_GPS, GritsPluginGps)) #define GRITS_IS_PLUGIN_GPS(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GRITS_TYPE_PLUGIN_GPS)) -#define GRITS_PLUGIN_GPS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GRITS_TYPE_PLUGIN_GPS, GritsPluginGPSClass)) +#define GRITS_PLUGIN_GPS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GRITS_TYPE_PLUGIN_GPS, GritsPluginGpsClass)) #define GRITS_IS_PLUGIN_GPS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GRITS_TYPE_PLUGIN_GPS)) -#define GRITS_PLUGIN_GPS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GRITS_TYPE_PLUGIN_GPS, GritsPluginGPSClass)) +#define GRITS_PLUGIN_GPS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GRITS_TYPE_PLUGIN_GPS, GritsPluginGpsClass)) -typedef struct _GritsPluginGPS GritsPluginGPS; -typedef struct _GritsPluginGPSClass GritsPluginGPSClass; +typedef struct _GritsPluginGps GritsPluginGps; +typedef struct _GritsPluginGpsClass GritsPluginGpsClass; /* All the User Interface objects we need to keep track of. */ struct gps_ui_t { - /* gps info frame */ - GtkWidget *gps_status_frame; - GtkWidget *gps_status_table; - GtkWidget *gps_status_label; - GtkWidget *gps_latitude_label; - GtkWidget *gps_longitude_label; - GtkWidget *gps_heading_label; - GtkWidget *gps_elevation_label; - - GtkWidget *status_bar; - - /* control frame */ - GtkWidget *gps_follow_checkbox; - GtkWidget *gps_track_checkbox; - GtkWidget *gps_clear_button; - - /* log frame */ - GtkWidget *gps_log_checkbox; - GtkWidget *gps_log_filename_entry; - GtkWidget *gps_log_interval_slider; - guint gps_log_timeout_id; /* id of timeout so we can delete it */ - unsigned int gps_log_number; /* sequential log number */ - - /* range ring frame */ - GtkWidget *gps_rangering_checkbox; + /* gps info frame */ + GtkWidget *gps_status_frame; + GtkWidget *gps_status_table; + GtkWidget *gps_status_label; + GtkWidget *gps_latitude_label; + GtkWidget *gps_longitude_label; + GtkWidget *gps_heading_label; + GtkWidget *gps_elevation_label; + + GtkWidget *status_bar; + + /* control frame */ + GtkWidget *gps_follow_checkbox; + GtkWidget *gps_track_checkbox; + GtkWidget *gps_clear_button; + + /* log frame */ + GtkWidget *gps_log_checkbox; + GtkWidget *gps_log_filename_entry; + GtkWidget *gps_log_interval_slider; + guint gps_log_timeout_id; /* id of timeout so we can delete it */ + guint gps_log_number; /* sequential log number */ + + /* range ring frame */ + GtkWidget *gps_rangering_checkbox; }; struct gps_track_t { @@ -73,7 +73,7 @@ struct gps_track_t { }; /* GPS private data */ -struct _GritsPluginGPS { +struct _GritsPluginGps { GObject parent_instance; /* instance members */ @@ -93,7 +93,7 @@ struct _GritsPluginGPS { struct gps_ui_t ui; }; -struct _GritsPluginGPSClass { +struct _GritsPluginGpsClass { GObjectClass parent_class; };