Committing the new My Evolution.

svn path=/trunk/; revision=10163

1 files changed, 590 insertions, 0 deletions

diff --git a/my-evolution/metar.c b/my-evolution/metar.c
new file mode 100644
index 0000000000..353593da79
--- /dev/null
+++ b/my-evolution/metar.c
@@ -0,0 +1,590 @@
+/*
+ * metar.c: Metar decoding routines.
+ *
+ * Originally written by Papadimitriou Spiros <spapadim+@cs.cmu.ed>
+ */
+
+#include <glib.h>
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <regex.h>
+#include <math.h>
+
+#include <libgnome/gnome-defs.h>
+#include <libgnome/gnome-i18n.h>
+
+#include "e-summary.h"
+#include "weather.h"
+
+#include "metar.h"
+
+static regex_t metar_re[RE_NUM];
+
+/* Unit conversions and names */
+
+#define TEMP_F_TO_C(f)  (((f) - 32.0) * 0.555556)
+#define TEMP_C_TO_F(c)  (((c) * 1.8) + 32.0)
+#define TEMP_UNIT_STR(units)  (((units) == UNITS_IMPERIAL) ? "\260F" : "\260C")
+
+#define WINDSPEED_KNOTS_TO_KPH(knots)  ((knots) * 1.851965)
+#define WINDSPEED_KPH_TO_KNOTS(kph)    ((kph) * 0.539967)
+#define WINDSPEED_UNIT_STR(units) (((units) == UNITS_IMPERIAL) ? "knots" : "kph")
+
+#define PRESSURE_INCH_TO_MM(inch)   ((inch) * 25.4)
+#define PRESSURE_MM_TO_INCH(mm)     ((mm) * 0.03937)
+#define PRESSURE_MBAR_TO_INCH(mbar) ((mbar) * 0.02963742)
+#define PRESSURE_UNIT_STR(units) (((units) == UNITS_IMPERIAL) ? "inHg" : "mmHg")
+#define VISIBILITY_SM_TO_KM(sm)  ((sm) * 1.609344)
+#define VISIBILITY_KM_TO_SM(km)  ((km) * 0.621371)
+#define VISIBILITY_UNIT_STR(units) (((units) == UNITS_IMPERIAL) ? "miles" : "kilometers")
+
+static const char *sky_str[] = {
+	N_("Clear sky"),
+	N_("Broken clouds"),
+	N_("Scattered clouds"),
+	N_("Few clouds"),
+	N_("Overcast")
+};
+
+const char *
+weather_sky_string (Weather *w)
+{
+	if (w->sky < 0 ||
+	    w->sky >= (sizeof (sky_str) / sizeof (char *))) {
+		return _("Invalid");
+	}
+	
+	return _(sky_str[(int)w->sky]);
+}
+
+static const char *wind_direction_str[] = {
+	N_("Variable"),
+	N_("North"), N_("North - NorthEast"), N_("Northeast"), N_("East - NorthEast"),
+	N_("East"), N_("East - Southeast"), N_("Southeast"), N_("South - Southeast"),
+	N_("South"), N_("South - Southwest"), N_("Southwest"), N_("West - Southwest"),
+	N_("West"), N_("West - Northwest"), N_("Northwest"), N_("North - Northwest")};
+
+const char *
+weather_wind_direction_string (Weather *w)
+{
+	if (w->wind < 0 ||
+	    w->wind >= (sizeof (wind_direction_str) / sizeof (char *))) {
+		return _("Invalid");
+	}
+
+	return _(wind_direction_str[(int)w->wind]);
+}
+
+/*
+ * Even though tedious, I switched to a 2D array for weather condition
+ * strings, in order to facilitate internationalization, esp. for languages
+ * with genders.
+ *
+ * I tried to come up with logical names for most phenomena, but I'm no
+ * meteorologist, so there will undoubtedly be some stupid mistakes.
+ * However, combinations that did not seem plausible (eg. I cannot imagine
+ * what a "light tornado" may be like ;-) were filled in with "??".  If this
+ * ever comes up in the weather conditions field, let me know...
+ */
+
+/*
+ * Note, magic numbers, when you change the size here, make sure to change
+ * the below function so that new values are recognized
+ */
+static const gchar *conditions_str[24][13] = {
+/*                   NONE                         VICINITY                             LIGHT                      MODERATE                      HEAVY                      SHALLOW                      PATCHES                         PARTIAL                      THUNDERSTORM                    BLOWING                      SHOWERS                         DRIFTING                      FREEZING                      */
+/*               *******************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************************/
+/* NONE          */ {"",                          "",                                  "",                        "",                           "",                        "",                          "",                             "",                          "",                             "",                          "",                             "",                           "",                          },
+/* DRIZZLE       */ {N_("Drizzle"),               N_("Drizzle in the vicinity"),       N_("Light drizzle"),       N_("Moderate drizzle"),       N_("Heavy drizzle"),       N_("Shallow drizzle"),       N_("Patches of drizzle"),       N_("Partial drizzle"),       N_("Thunderstorm"),             N_("Windy drizzle"),         N_("Showers"),                  N_("Drifting drizzle"),       N_("Freezing drizzle")       },
+/* RAIN          */ {N_("Rain"),                  N_("Rain in the vicinity") ,         N_("Light rain"),          N_("Moderate rain"),          N_("Heavy rain"),          N_("Shallow rain"),          N_("Patches of rain"),          N_("Partial rainfall"),      N_("Thunderstorm"),             N_("Blowing rainfall"),      N_("Rain showers"),             N_("Drifting rain"),          N_("Freezing rain")          },
+/* SNOW          */ {N_("Snow"),                  N_("Snow in the vicinity") ,         N_("Light snow"),          N_("Moderate snow"),          N_("Heavy snow"),          N_("Shallow snow"),          N_("Patches of snow"),          N_("Partial snowfall"),      N_("Snowstorm"),                N_("Blowing snowfall"),      N_("Snow showers"),             N_("Drifting snow"),          N_("Freezing snow")          },
+/* SNOW_GRAINS   */ {N_("Snow grains"),           N_("Snow grains in the vicinity") ,  N_("Light snow grains"),   N_("Moderate snow grains"),   N_("Heavy snow grains"),   N_("Shallow snow grains"),   N_("Patches of snow grains"),   N_("Partial snow grains"),   N_("Snowstorm"),                N_("Blowing snow grains"),   N_("Snow grain showers"),       N_("Drifting snow grains"),   N_("Freezing snow grains")   },
+/* ICE_CRYSTALS  */ {N_("Ice crystals"),          N_("Ice crystals in the vicinity") , N_("Few ice crystals"),    N_("Moderate ice crystals"),  N_("Heavy ice crystals"),  "??",                        N_("Patches of ice crystals"),  N_("Partial ice crystals"),  N_("Ice crystal storm"),        N_("Blowing ice crystals"),  N_("Showers of ice crystals"),  N_("Drifting ice crystals"),  N_("Freezing ice crystals")  },
+/* ICE_PELLETS   */ {N_("Ice pellets"),           N_("Ice pellets in the vicinity") ,  N_("Few ice pellets"),     N_("Moderate ice pellets"),   N_("Heavy ice pellets"),   N_("Shallow ice pellets"),   N_("Patches of ice pellets"),   N_("Partial ice pellets"),   N_("Ice pellet storm"),         N_("Blowing ice pellets"),   N_("Showers of ice pellets"),   N_("Drifting ice pellets"),   N_("Freezing ice pellets")   },
+/* HAIL          */ {N_("Hail"),                  N_("Hail in the vicinity") ,         N_("Light hail"),          N_("Moderate hail"),          N_("Heavy hail"),          N_("Shallow hail"),          N_("Patches of hail"),          N_("Partial hail"),          N_("Hailstorm"),                N_("Blowing hail"),          N_("Hail showers"),             N_("Drifting hail"),          N_("Freezing hail")          },
+/* SMALL_HAIL    */ {N_("Small hail"),            N_("Small hail in the vicinity") ,   N_("Light hail"),          N_("Moderate small hail"),    N_("Heavy small hail"),    N_("Shallow small hail"),    N_("Patches of small hail"),    N_("Partial small hail"),    N_("Small hailstorm"),          N_("Blowing small hail"),    N_("Showers of small hail"),    N_("Drifting small hail"),    N_("Freezing small hail")    },
+/* PRECIPITATION */ {N_("Unknown precipitation"), N_("Precipitation in the vicinity"), N_("Light precipitation"), N_("Moderate precipitation"), N_("Heavy precipitation"), N_("Shallow precipitation"), N_("Patches of precipitation"), N_("Partial precipitation"), N_("Unknown thunderstorm"),     N_("Blowing precipitation"), N_("Showers, type unknown"),    N_("Drifting precipitation"), N_("Freezing precipitation") },
+/* MIST          */ {N_("Mist"),                  N_("Mist in the vicinity") ,         N_("Light mist"),          N_("Moderate mist"),          N_("Thick mist"),          N_("Shallow mist"),          N_("Patches of mist"),          N_("Partial mist"),          "??",                           N_("Mist with wind"),        "??",                           N_("Drifting mist"),          N_("Freezing mist")          },
+/* FOG           */ {N_("Fog"),                   N_("Fog in the vicinity") ,          N_("Light fog"),           N_("Moderate fog"),           N_("Thick fog"),           N_("Shallow fog"),           N_("Patches of fog"),           N_("Partial fog"),           "??",                           N_("Fog with wind"),         "??",                           N_("Drifting fog"),           N_("Freezing fog")           },
+/* SMOKE         */ {N_("Smoke"),                 N_("Smoke in the vicinity") ,        N_("Thin smoke"),          N_("Moderate smoke"),         N_("Thick smoke"),         N_("Shallow smoke"),         N_("Patches of smoke"),         N_("Partial smoke"),         N_("Smoke w/ thunders"),        N_("Smoke with wind"),       "??",                           N_("Drifting smoke"),         "??"                         },
+/* VOLCANIC_ASH  */ {N_("Volcanic ash"),          N_("Volcanic ash in the vicinity") , "??",                      N_("Moderate volcanic ash"),  N_("Thick volcanic ash"),  N_("Shallow volcanic ash"),  N_("Patches of volcanic ash"),  N_("Partial volcanic ash"),  N_("Volcanic ash w/ thunders"), N_("Blowing volcanic ash"),  N_("Showers of volcanic ash "), N_("Drifting volcanic ash"),  N_("Freezing volcanic ash")  },
+/* SAND          */ {N_("Sand"),                  N_("Sand in the vicinity") ,         N_("Light sand"),          N_("Moderate sand"),          N_("Heavy sand"),          "??",                        N_("Patches of sand"),          N_("Partial sand"),          "??",                           N_("Blowing sand"),          "",                             N_("Drifting sand"),          "??"                         },
+/* HAZE          */ {N_("Haze"),                  N_("Haze in the vicinity") ,         N_("Light haze"),          N_("Moderate haze"),          N_("Thick haze"),          N_("Shallow haze"),          N_("Patches of haze"),          N_("Partial haze"),          "??",                           N_("Haze with wind"),        "??",                           N_("Drifting haze"),          N_("Freezing haze")          },
+/* SPRAY         */ {N_("Sprays"),                N_("Sprays in the vicinity") ,       N_("Light sprays"),        N_("Moderate sprays"),        N_("Heavy sprays"),        N_("Shallow sprays"),        N_("Patches of sprays"),        N_("Partial sprays"),        "??",                           N_("Blowing sprays"),        "??",                           N_("Drifting sprays"),        N_("Freezing sprays")        },
+/* DUST          */ {N_("Dust"),                  N_("Dust in the vicinity") ,         N_("Light dust"),          N_("Moderate dust"),          N_("Heavy dust"),          "??",                        N_("Patches of dust"),          N_("Partial dust"),          "??",                           N_("Blowing dust"),          "??",                           N_("Drifting dust"),          "??"                         },
+/* SQUALL        */ {N_("Squall"),                N_("Squall in the vicinity") ,       N_("Light squall"),        N_("Moderate squall"),        N_("Heavy squall"),        "??",                        "??",                           N_("Partial squall"),        N_("Thunderous squall"),        N_("Blowing squall"),        "??",                           N_("Drifting squall"),        N_("Freezing squall")        },
+/* SANDSTORM     */ {N_("Sandstorm"),             N_("Sandstorm in the vicinity") ,    N_("Light standstorm"),    N_("Moderate sandstorm"),     N_("Heavy sandstorm"),     N_("Shallow sandstorm"),     "??",                           N_("Partial sandstorm"),     N_("Thunderous sandstorm"),     N_("Blowing sandstorm"),     "??",                           N_("Drifting sandstorm"),     N_("Freezing sandstorm")     },
+/* DUSTSTORM     */ {N_("Duststorm"),             N_("Duststorm in the vicinity") ,    N_("Light duststorm"),     N_("Moderate duststorm"),     N_("Heavy duststorm"),     N_("Shallow duststorm"),     "??",                           N_("Partial duststorm"),     N_("Thunderous duststorm"),     N_("Blowing duststorm"),     "??",                           N_("Drifting duststorm"),     N_("Freezing duststorm")     },
+/* FUNNEL_CLOUD  */ {N_("Funnel cloud"),          N_("Funnel cloud in the vicinity") , N_("Light funnel cloud"),  N_("Moderate funnel cloud"),  N_("Thick funnel cloud"),  N_("Shallow funnel cloud"),  N_("Patches of funnel clouds"), N_("Partial funnel clouds"), "??",                           N_("Funnel cloud w/ wind"),  "??",                           N_("Drifting funnel cloud"),  "??"                         },
+/* TORNADO       */ {N_("Tornado"),               N_("Tornado in the vicinity") ,      "??",                      N_("Moderate tornado"),       N_("Raging tornado"),      "??",                        "??",                           N_("Partial tornado"),       N_("Thunderous tornado"),       N_("Tornado"),               "??",                           N_("Drifting tornado"),       N_("Freezing tornado")       },
+/* DUST_WHIRLS   */ {N_("Dust whirls"),           N_("Dust whirls in the vicinity") ,  N_("Light dust whirls"),   N_("Moderate dust whirls"),   N_("Heavy dust whirls"),   N_("Shallow dust whirls"),   N_("Patches of dust whirls"),   N_("Partial dust whirls"),   "??",                           N_("Blowing dust whirls"),   "??",                           N_("Drifting dust whirls"),   "??"                         }
+};
+
+const char *
+weather_conditions_string (Weather *w)
+{
+    if (!w->cond.significant) {
+	    return "-";
+    } else {
+	    if (w->cond.phenomenon >= 0 &&
+		w->cond.phenomenon < 24 &&
+		w->cond.qualifier >= 0 &&
+		w->cond.qualifier < 13) {
+		    return _(conditions_str[(int)w->cond.phenomenon][(int)w->cond.qualifier]);
+	    } else {
+		    return _("Invalid");
+	    }
+    }
+}
+
+char *
+weather_temp_string (Weather *w)
+{
+	char *temp;
+
+	temp = g_strdup_printf ("%.1f%s", w->temp, TEMP_UNIT_STR (w->units));
+	return temp;
+}
+
+void
+metar_init_re (void)
+{
+	static gboolean initialized = FALSE;
+	if (initialized)
+		return;
+	initialized = TRUE;
+	
+	regcomp(&metar_re[TIME_RE], TIME_RE_STR, REG_EXTENDED);
+	regcomp(&metar_re[WIND_RE], WIND_RE_STR, REG_EXTENDED);
+	regcomp(&metar_re[VIS_RE], VIS_RE_STR, REG_EXTENDED);
+	regcomp(&metar_re[CLOUD_RE], CLOUD_RE_STR, REG_EXTENDED);
+	regcomp(&metar_re[TEMP_RE], TEMP_RE_STR, REG_EXTENDED);
+	regcomp(&metar_re[PRES_RE], PRES_RE_STR, REG_EXTENDED);
+	regcomp(&metar_re[COND_RE], COND_RE_STR, REG_EXTENDED);
+}
+
+static inline gint 
+days_in_month (gint month, 
+	       gint year)
+{
+	if (month == 1)
+		return ((year % 4) == 0) ? 29 : 28;
+	else if (((month <= 6) && (month % 2 == 0)) || ((month >=7) && (month % 2 != 0)))
+		return 31;
+	else
+		return 30;
+}
+
+/* FIX - there *must* be a simpler, less stupid way to do this!... */
+static time_t 
+make_time (gint date, 
+	   gint hour, 
+	   gint min)
+{
+	struct tm *tm;
+	struct tm tms;
+	time_t now;
+	gint loc_mday, loc_hour, gm_mday, gm_hour;
+	gint hour_diff;  /* local time = UTC - hour_diff */
+	gint is_dst;
+	
+	now = time(NULL);
+	
+	tm = gmtime(&now);
+	gm_mday = tm->tm_mday;
+	gm_hour = tm->tm_hour;
+	memcpy(&tms, tm, sizeof(struct tm));
+	
+	tm = localtime(&now);
+	loc_mday = tm->tm_mday;
+	loc_hour = tm->tm_hour;
+	is_dst = tm->tm_isdst;
+	
+	/* Estimate timezone */
+	if (gm_mday == loc_mday)
+		hour_diff = gm_hour - loc_hour;
+	else
+		if ((gm_mday == loc_mday + 1) || ((gm_mday == 1) && (loc_mday >= 27)))
+			hour_diff = gm_hour + (24 - loc_hour);
+		else
+			hour_diff = -((24 - gm_hour) + loc_hour);
+	
+	/* Make time */
+	tms.tm_min  = min;
+	tms.tm_sec  = 0;
+	tms.tm_hour = hour - hour_diff;
+	tms.tm_mday = date;
+	tms.tm_isdst = is_dst;
+	if (tms.tm_hour < 0) {
+		tms.tm_hour += 24;
+		--tms.tm_mday;
+		if (tms.tm_mday < 1) {
+			--tms.tm_mon;
+			if (tms.tm_mon < 0) {
+				tms.tm_mon = 11;
+				--tms.tm_year;
+			}
+			tms.tm_mday = days_in_month(tms.tm_mon, tms.tm_year + 1900);
+		}
+	} else if (tms.tm_hour > 23) {
+		tms.tm_hour -= 24;
+		++tms.tm_mday;
+		if (tms.tm_mday > days_in_month(tms.tm_mon, tms.tm_year + 1900)) {
+			++tms.tm_mon;
+			if (tms.tm_mon > 11) {
+				tms.tm_mon = 0;
+				++tms.tm_year;
+			}
+			tms.tm_mday = 1;
+		}
+	}
+	
+	return mktime(&tms);
+}
+
+gboolean
+metar_tok_time (char *token,
+		Weather *w)
+{
+	char sday[3], shr[3], smin[3];
+	int day, hour, min;
+
+	if (regexec (&metar_re[TIME_RE], token, 0, NULL, 0) == REG_NOMATCH) {
+		return FALSE;
+	}
+
+	strncpy(sday, token, 2);
+	sday[2] = 0;
+	day = atoi (sday);
+
+	strncpy (shr, token + 2, 2);
+	shr[2] = 0;
+	hour = atoi (shr);
+
+	strncpy (smin, token + 4, 2);
+	smin[2] = 0;
+	min = atoi (smin);
+
+	w->update = make_time (day, hour, min);
+	
+	return TRUE;
+}
+
+#define CONST_DIGITS "0123456789"
+
+gboolean 
+metar_tok_wind (gchar *tokp, 
+		Weather *w)
+{
+	char sdir[4], sspd[4], sgust[4];
+	int dir, spd, gust = -1;
+	char *gustp;
+	
+	if (regexec(&metar_re[WIND_RE], tokp, 0, NULL, 0) == REG_NOMATCH)
+		return FALSE;
+	
+	strncpy(sdir, tokp, 3);
+	sdir[3] = 0;
+	dir = (!strcmp(sdir, "VRB")) ? -1 : atoi(sdir);
+	
+	memset(sspd, 0, sizeof(sspd));
+	strncpy(sspd, tokp+3, strspn(tokp+3, CONST_DIGITS));
+	spd = atoi(sspd);
+	
+	gustp = strchr(tokp, 'G');
+	if (gustp) {
+		memset(sgust, 0, sizeof(sgust));
+		strncpy(sgust, gustp+1, strspn(gustp+1, CONST_DIGITS));
+		gust = atoi(sgust);
+	}
+	
+	if ((349 <= dir) && (dir <= 11))
+		w->wind = WIND_N;
+	else if ((12 <= dir) && (dir <= 33))
+		w->wind = WIND_NNE;
+	else if ((34 <= dir) && (dir <= 56))
+		w->wind = WIND_NE;
+	else if ((57 <= dir) && (dir <= 78))
+		w->wind = WIND_ENE;
+	else if ((79 <= dir) && (dir <= 101))
+		w->wind = WIND_E;
+	else if ((102 <= dir) && (dir <= 123))
+		w->wind = WIND_ESE;
+	else if ((124 <= dir) && (dir <= 146))
+		w->wind = WIND_SE;
+	else if ((147 <= dir) && (dir <= 168))
+		w->wind = WIND_SSE;
+	else if ((169 <= dir) && (dir <= 191))
+		w->wind = WIND_S;
+	else if ((192 <= dir) && (dir <= 213))
+		w->wind = WIND_SSW;
+	else if ((214 <= dir) && (dir <= 236))
+		w->wind = WIND_SW;
+	else if ((247 <= dir) && (dir <= 258))
+		w->wind = WIND_WSW;
+	else if ((259 <= dir) && (dir <= 281))
+		w->wind = WIND_W;
+	else if ((282 <= dir) && (dir <= 303))
+		w->wind = WIND_WNW;
+	else if ((304 <= dir) && (dir <= 326))
+		w->wind = WIND_NW;
+	else if ((327 <= dir) && (dir <= 348))
+		w->wind = WIND_NNW;
+	
+	w->windspeed = (ESummaryWeatherWindSpeed)spd;
+	
+	return TRUE;
+}
+
+gboolean 
+metar_tok_vis (gchar *tokp, 
+	       Weather *w)
+{
+	char *pfrac, *pend;
+	char sval[4];
+	int val;
+	
+	if (regexec(&metar_re[VIS_RE], tokp, 0, NULL, 0) == REG_NOMATCH)
+		return FALSE;
+	
+	pfrac = strchr(tokp, '/');
+	pend = strstr(tokp, "SM");
+	memset(sval, 0, sizeof(sval));
+	
+	if (pfrac) {
+		strncpy(sval, pfrac + 1, pend - pfrac - 1);
+		val = atoi(sval);
+		w->visibility = (*tokp == 'M') ? 0.001 : (1.0 / ((ESummaryWeatherVisibility)val));
+	} else {
+		strncpy(sval, tokp, pend - tokp);
+		val = atoi(sval);
+		w->visibility = (ESummaryWeatherVisibility)val;
+	}
+	
+	return TRUE;
+}
+
+gboolean 
+metar_tok_cloud (gchar *tokp, 
+		 Weather *w)
+{
+	char stype[4], salt[4];
+	int alt = -1;
+	
+	if (regexec(&metar_re[CLOUD_RE], tokp, 0, NULL, 0) == REG_NOMATCH)
+		return FALSE;
+	
+	strncpy(stype, tokp, 3);
+	stype[3] = 0;
+	if (strlen(tokp) == 6) {
+		strncpy(salt, tokp+3, 3);
+		salt[3] = 0;
+		alt = atoi(salt);  /* Altitude - currently unused */
+	}
+	
+	if (!strcmp(stype, "CLR")) {
+		w->sky = SKY_CLEAR;
+	} else if (!strcmp(stype, "BKN")) {
+		w->sky = SKY_BROKEN;
+	} else if (!strcmp(stype, "SCT")) {
+		w->sky = SKY_SCATTERED;
+	} else if (!strcmp(stype, "FEW")) {
+		w->sky = SKY_FEW;
+	} else if (!strcmp(stype, "OVC")) {
+		w->sky = SKY_OVERCAST;
+	}
+	
+	return TRUE;
+}
+
+gboolean 
+metar_tok_pres (gchar *tokp, 
+		Weather *w)
+{
+	if (regexec(&metar_re[PRES_RE], tokp, 0, NULL, 0) == REG_NOMATCH)
+		return FALSE;
+	
+	if (*tokp == 'A') {
+		char sintg[3], sfract[3];
+		int intg, fract;
+		
+		strncpy(sintg, tokp+1, 2);
+		sintg[2] = 0;
+		intg = atoi(sintg);
+		
+		strncpy(sfract, tokp+3, 2);
+		sfract[2] = 0;
+		fract = atoi(sfract);
+		
+		w->pressure = (ESummaryWeatherPressure)intg + (((ESummaryWeatherPressure)fract)/100.0);
+	} else {  /* *tokp == 'Q' */
+		gchar spres[5];
+		gint pres;
+		
+		strncpy(spres, tokp+1, 4);
+		spres[4] = 0;
+		pres = atoi(spres);
+		
+		w->pressure = PRESSURE_MBAR_TO_INCH((ESummaryWeatherPressure)pres);
+	}
+	
+	return TRUE;
+}
+
+/* Relative humidity computation - thanks to <Olof.Oberg@modopaper.modogroup.com> */
+
+
+static inline gint 
+calc_humidity(gdouble temp, 
+	      gdouble dewp)
+{
+	gdouble esat, esurf;
+	
+	temp = TEMP_F_TO_C(temp);
+	dewp = TEMP_F_TO_C(dewp);
+	
+	esat = 6.11 * pow(10.0, (7.5 * temp) / (237.7 + temp));
+	esurf = 6.11 * pow(10.0, (7.5 * dewp) / (237.7 + dewp));
+	
+	return (gint)((esurf/esat) * 100.0);
+}
+
+gboolean 
+metar_tok_temp (gchar *tokp, 
+		Weather *w)
+{
+    gchar *ptemp, *pdew, *psep;
+
+    if (regexec(&metar_re[TEMP_RE], tokp, 0, NULL, 0) == REG_NOMATCH)
+        return FALSE;
+
+    psep = strchr(tokp, '/');
+    *psep = 0;
+    ptemp = tokp;
+    pdew = psep + 1;
+
+    w->temp = (*ptemp == 'M') ? TEMP_C_TO_F(-atoi(ptemp+1)) :
+                                   TEMP_C_TO_F(atoi(ptemp));
+    w->dew = (*pdew == 'M') ? TEMP_C_TO_F(-atoi(pdew+1)) :
+                                 TEMP_C_TO_F(atoi(pdew));
+    w->humidity = calc_humidity(w->temp, w->dew);
+    return TRUE;
+}
+
+gboolean 
+metar_tok_cond (gchar *tokp, 
+		Weather *w)
+{
+	char squal[3], sphen[4];
+	char *pphen;
+	
+	if (regexec(&metar_re[COND_RE], tokp, 0, NULL, 0) == REG_NOMATCH)
+		return FALSE;
+	
+	if ((strlen(tokp) > 3) && ((*tokp == '+') || (*tokp == '-')))
+		++tokp;   /* FIX */
+	
+	if ((*tokp == '+') || (*tokp == '-'))
+		pphen = tokp + 1;
+	else if (strlen(tokp) < 4)
+		pphen = tokp;
+	else
+		pphen = tokp + 2;
+	
+	memset(squal, 0, sizeof(squal));
+	strncpy(squal, tokp, pphen - tokp);
+	squal[pphen - tokp] = 0;
+	
+	memset(sphen, 0, sizeof(sphen));
+	strncpy(sphen, pphen, sizeof(sphen));
+	sphen[sizeof(sphen)-1] = '\0';
+	
+	/* Defaults */
+	w->cond.qualifier = QUALIFIER_NONE;
+	w->cond.phenomenon = PHENOMENON_NONE;
+	w->cond.significant = FALSE;
+	
+	if (!strcmp(squal, "")) {
+		w->cond.qualifier = QUALIFIER_MODERATE;
+	} else if (!strcmp(squal, "-")) {
+		w->cond.qualifier = QUALIFIER_LIGHT;
+	} else if (!strcmp(squal, "+")) {
+		w->cond.qualifier = QUALIFIER_HEAVY;
+	} else if (!strcmp(squal, "VC")) {
+		w->cond.qualifier = QUALIFIER_VICINITY;
+	} else if (!strcmp(squal, "MI")) {
+		w->cond.qualifier = QUALIFIER_SHALLOW;
+	} else if (!strcmp(squal, "BC")) {
+		w->cond.qualifier = QUALIFIER_PATCHES;
+	} else if (!strcmp(squal, "PR")) {
+		w->cond.qualifier = QUALIFIER_PARTIAL;
+	} else if (!strcmp(squal, "TS")) {
+		w->cond.qualifier = QUALIFIER_THUNDERSTORM;
+	} else if (!strcmp(squal, "BL")) {
+		w->cond.qualifier = QUALIFIER_BLOWING;
+	} else if (!strcmp(squal, "SH")) {
+		w->cond.qualifier = QUALIFIER_SHOWERS;
+	} else if (!strcmp(squal, "DR")) {
+		w->cond.qualifier = QUALIFIER_DRIFTING;
+	} else if (!strcmp(squal, "FZ")) {
+		w->cond.qualifier = QUALIFIER_FREEZING;
+	} else {
+		g_return_val_if_fail(FALSE, FALSE);
+	}
+	
+	if (!strcmp(sphen, "DZ")) {
+		w->cond.phenomenon = PHENOMENON_DRIZZLE;
+	} else if (!strcmp(sphen, "RA")) {
+		w->cond.phenomenon = PHENOMENON_RAIN;
+	} else if (!strcmp(sphen, "SN")) {
+		w->cond.phenomenon = PHENOMENON_SNOW;
+	} else if (!strcmp(sphen, "SG")) {
+		w->cond.phenomenon = PHENOMENON_SNOW_GRAINS;
+	} else if (!strcmp(sphen, "IC")) {
+		w->cond.phenomenon = PHENOMENON_ICE_CRYSTALS;
+	} else if (!strcmp(sphen, "PE")) {
+		w->cond.phenomenon = PHENOMENON_ICE_PELLETS;
+	} else if (!strcmp(sphen, "GR")) {
+		w->cond.phenomenon = PHENOMENON_HAIL;
+	} else if (!strcmp(sphen, "GS")) {
+		w->cond.phenomenon = PHENOMENON_SMALL_HAIL;
+	} else if (!strcmp(sphen, "UP")) {
+		w->cond.phenomenon = PHENOMENON_UNKNOWN_PRECIPITATION;
+	} else if (!strcmp(sphen, "BR")) {
+		w->cond.phenomenon = PHENOMENON_MIST;
+	} else if (!strcmp(sphen, "FG")) {
+		w->cond.phenomenon = PHENOMENON_FOG;
+	} else if (!strcmp(sphen, "FU")) {
+		w->cond.phenomenon = PHENOMENON_SMOKE;
+	} else if (!strcmp(sphen, "VA")) {
+		w->cond.phenomenon = PHENOMENON_VOLCANIC_ASH;
+	} else if (!strcmp(sphen, "SA")) {
+		w->cond.phenomenon = PHENOMENON_SAND;
+	} else if (!strcmp(sphen, "HZ")) {
+		w->cond.phenomenon = PHENOMENON_HAZE;
+	} else if (!strcmp(sphen, "PY")) {
+		w->cond.phenomenon = PHENOMENON_SPRAY;
+	} else if (!strcmp(sphen, "DU")) {
+		w->cond.phenomenon = PHENOMENON_DUST;
+	} else if (!strcmp(sphen, "SQ")) {
+		w->cond.phenomenon = PHENOMENON_SQUALL;
+	} else if (!strcmp(sphen, "SS")) {
+		w->cond.phenomenon = PHENOMENON_SANDSTORM;
+	} else if (!strcmp(sphen, "DS")) {
+		w->cond.phenomenon = PHENOMENON_DUSTSTORM;
+	} else if (!strcmp(sphen, "PO")) {
+		w->cond.phenomenon = PHENOMENON_DUST_WHIRLS;
+	} else if (!strcmp(sphen, "+FC")) {
+		w->cond.phenomenon = PHENOMENON_TORNADO;
+	} else if (!strcmp(sphen, "FC")) {
+		w->cond.phenomenon = PHENOMENON_FUNNEL_CLOUD;
+	} else {
+		g_return_val_if_fail(FALSE, FALSE);
+	}
+	
+	if ((w->cond.qualifier != QUALIFIER_NONE) || (w->cond.phenomenon != PHENOMENON_NONE))
+		w->cond.significant = TRUE;
+	
+	return TRUE;
+}