callisto-debian/evolution
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
e1fa571225dcf92a75e3ff4a84c7153e32b3664f
evolution/my-evolution/metar.c
Iain Holmes bdb095ab69 Merging patches from 1-0-branch 
svn path=/trunk/; revision=15109
2001-12-17 12:20:19 +00:00

1017 lines
24 KiB
C
Raw Blame History

/*
* 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) ? _(" F") : _(" C"))
#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";
}
Reference in New Issue View Git Blame Copy Permalink