This commit was manufactured by cvs2svn to create tagradioactive-1_3_1

'radioactive-1_3_1'.

svn path=/tags/radioactive-1_3_1/; revision=14068

1 files changed, 0 insertions, 1016 deletions

diff --git a/my-evolution/metar.c b/my-evolution/metar.c
deleted file mode 100644
index 00b16518be..0000000000
--- a/my-evolution/metar.c
+++ /dev/null
@@ -1,1016 +0,0 @@
-/*
- * metar.c: Metar decoding routines.
- *
- * Originally written by Papadimitriou Spiros <spapadim+@cs.cmu.ed>
- */
-
-#include <config.h>
-#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_("Thunderous smoke"), 
-	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_("Thunderous volcanic ash"),
-	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_("Spray"),
-	N_("Spray in the vicinity"),
-	N_("Light spray"),  
-	N_("Moderate spray"),  
-	N_("Heavy spray"), 
-	N_("Shallow spray"), 
-	N_("Patches of spray"),   
-	N_("Partial spray"),   
-	"??",    
-	N_("Blowing spray"),   
-	"??",    
-	N_("Drifting spray"),  
-	N_("Freezing spray")  
-},
-/* 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;
-	ESummaryWeatherUnits units;
-
-	if (w->summary->preferences == NULL) {
-		units = UNITS_METRIC;
-	} else {
-		units = w->summary->preferences->units;
-	}
-
-	temp = g_strdup_printf ("%.1f%s", w->temp, TEMP_UNIT_STR (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,
-	      ESummaryWeatherUnits units)
-{
-	gdouble esat, esurf;
-	
-	if (units == UNITS_IMPERIAL) {
-		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)
-{
-	ESummaryWeatherUnits units;
-	gchar *ptemp, *pdew, *psep;
-	
-	if (regexec(&metar_re[TEMP_RE], tokp, 0, NULL, 0) == REG_NOMATCH)
-		return FALSE;
-	
-	if (w->summary->preferences == NULL) {
-		units = UNITS_METRIC;
-	} else {
-		units = w->summary->preferences->units;
-	}
-
-	psep = strchr(tokp, '/');
-	*psep = 0;
-	ptemp = tokp;
-	pdew = psep + 1;
-	
-	if (units == UNITS_IMPERIAL) {
-		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));
-	} else {
-		w->temp = (*ptemp == 'M') ? -atoi(ptemp+1) : atoi(ptemp);
-		w->dew = (*pdew == 'M') ? -atoi(pdew+1) : atoi (pdew);
-	}
-
-	w->humidity = calc_humidity(w->temp, w->dew, units);
-	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;
-}
-
-const char *
-icon_from_weather (Weather *w)
-{
-	ESummaryWeatherConditions cond = w->cond;
-	ESummaryWeatherSky sky = w->sky;
-
-	switch (cond.phenomenon) {
-	case PHENOMENON_DRIZZLE:
-	case PHENOMENON_RAIN:
-	case PHENOMENON_UNKNOWN_PRECIPITATION:
-	case PHENOMENON_HAIL:
-	case PHENOMENON_SMALL_HAIL:
-		return "myweather-rain.png";
-	case PHENOMENON_SNOW:
-	case PHENOMENON_SNOW_GRAINS:
-	case PHENOMENON_ICE_PELLETS:
-	case PHENOMENON_ICE_CRYSTALS:
-		return "myweather-snow.png";
-	case PHENOMENON_TORNADO:
-	case PHENOMENON_SQUALL:
-		return "myweather-storm.png";
-	case PHENOMENON_MIST:
-	case PHENOMENON_FOG:
-	case PHENOMENON_SMOKE:
-	case PHENOMENON_VOLCANIC_ASH:
-	case PHENOMENON_SAND:
-	case PHENOMENON_HAZE:
-	case PHENOMENON_SPRAY:
-	case PHENOMENON_DUST:
-	case PHENOMENON_SANDSTORM:
-	case PHENOMENON_DUSTSTORM:
-	case PHENOMENON_FUNNEL_CLOUD:
-	case PHENOMENON_DUST_WHIRLS:
-		return "myweather-fog.png";
-	default:
-		break;
-	}
-
-	switch (sky) {
-	case SKY_CLEAR:
-		return "myweather-sun.png";
-	case SKY_BROKEN:
-	case SKY_SCATTERED:
-	case SKY_FEW:
-		return "myweather-suncloud.png";
-	case SKY_OVERCAST:
-		return "myweather-clouds.png";
-	default:
-		break;
-	}
-
-	return "es-weather.png";
-}